Identified constant variable (byte*) main::SCREEN
Culled Empty Block (label) main::@4

CONTROL FLOW GRAPH SSA
@begin: scope:[]  from
  to:@1
main: scope:[main]  from @1
  (byte*) main::SCREEN#0 ← ((byte*)) (number) $400
  (byte) main::x#0 ← (byte) 0
  to:main::@1
main::@1: scope:[main]  from main main::@3
  (byte) main::x#4 ← phi( main/(byte) main::x#0 main::@3/(byte) main::x#1 )
  (byte) main::line#0 ← (byte) 0
  to:main::@2
main::@2: scope:[main]  from main::@1 main::@2
  (byte) main::x#2 ← phi( main::@1/(byte) main::x#4 main::@2/(byte) main::x#2 )
  (byte) main::line#2 ← phi( main::@1/(byte) main::line#0 main::@2/(byte) main::line#1 )
  (number~) main::$0 ← (byte) main::line#2 * (number) $28
  (byte*~) main::$1 ← (byte*) main::SCREEN#0 + (number~) main::$0
  *((byte*~) main::$1 + (byte) main::x#2) ← (byte) main::x#2
  (byte) main::line#1 ← (byte) main::line#2 + rangenext(0,$18)
  (bool~) main::$2 ← (byte) main::line#1 != rangelast(0,$18)
  unroll if((bool~) main::$2) goto main::@2
  to:main::@3
main::@3: scope:[main]  from main::@2
  (byte) main::x#3 ← phi( main::@2/(byte) main::x#2 )
  (byte) main::x#1 ← (byte) main::x#3 + rangenext(0,$27)
  (bool~) main::$3 ← (byte) main::x#1 != rangelast(0,$27)
  if((bool~) main::$3) goto main::@1
  to:main::@return
main::@return: scope:[main]  from main::@3
  return 
  to:@return
@1: scope:[]  from @begin
  call main 
  to:@2
@2: scope:[]  from @1
  to:@end
@end: scope:[]  from @2

SYMBOL TABLE SSA
(label) @1
(label) @2
(label) @begin
(label) @end
(void()) main()
(number~) main::$0
(byte*~) main::$1
(bool~) main::$2
(bool~) main::$3
(label) main::@1
(label) main::@2
(label) main::@3
(label) main::@return
(byte*) main::SCREEN
(byte*) main::SCREEN#0
(byte) main::line
(byte) main::line#0
(byte) main::line#1
(byte) main::line#2
(byte) main::x
(byte) main::x#0
(byte) main::x#1
(byte) main::x#2
(byte) main::x#3
(byte) main::x#4

Adding number conversion cast (unumber) $28 in (number~) main::$0 ← (byte) main::line#2 * (number) $28
Adding number conversion cast (unumber) main::$0 in (number~) main::$0 ← (byte) main::line#2 * (unumber)(number) $28
Successful SSA optimization PassNAddNumberTypeConversions
Inlining cast (byte*) main::SCREEN#0 ← (byte*)(number) $400
Successful SSA optimization Pass2InlineCast
Simplifying constant pointer cast (byte*) 1024
Simplifying constant integer cast $28
Successful SSA optimization PassNCastSimplification
Finalized unsigned number type (byte) $28
Successful SSA optimization PassNFinalizeNumberTypeConversions
Inferred type updated to byte in (unumber~) main::$0 ← (byte) main::line#2 * (byte) $28
Alias (byte) main::x#2 = (byte) main::x#3 
Successful SSA optimization Pass2AliasElimination
Identical Phi Values (byte) main::x#2 (byte) main::x#4
Successful SSA optimization Pass2IdenticalPhiElimination
Simple Condition (bool~) main::$2 [10] unroll if((byte) main::line#1!=rangelast(0,$18)) goto main::@2
Simple Condition (bool~) main::$3 [14] if((byte) main::x#1!=rangelast(0,$27)) goto main::@1
Successful SSA optimization Pass2ConditionalJumpSimplification
Constant (const byte*) main::SCREEN#0 = (byte*) 1024
Constant (const byte) main::x#0 = 0
Constant (const byte) main::line#0 = 0
Successful SSA optimization Pass2ConstantIdentification
Resolved ranged next value [8] main::line#1 ← ++ main::line#2 to ++
Resolved ranged comparison value [10] unroll if(main::line#1!=rangelast(0,$18)) goto main::@2 to (number) $19
Resolved ranged next value [12] main::x#1 ← ++ main::x#4 to ++
Resolved ranged comparison value [14] if(main::x#1!=rangelast(0,$27)) goto main::@1 to (number) $28
Adding number conversion cast (unumber) $19 in unroll if((byte) main::line#1!=(number) $19) goto main::@2
Adding number conversion cast (unumber) $28 in if((byte) main::x#1!=(number) $28) goto main::@1
Successful SSA optimization PassNAddNumberTypeConversions
Simplifying constant integer cast $19
Simplifying constant integer cast $28
Successful SSA optimization PassNCastSimplification
Finalized unsigned number type (byte) $19
Finalized unsigned number type (byte) $28
Successful SSA optimization PassNFinalizeNumberTypeConversions
Unrolling loop Loop head: main::@2 tails: main::@2 blocks: main::@2 
Successful SSA optimization Pass2LoopUnroll
Identical Phi Values (byte) main::line#2 (const byte) main::line#0
Successful SSA optimization Pass2IdenticalPhiElimination
Negating conditional jump and destination [6] if((byte) main::line#1==(byte) $19) goto main::@3
Successful SSA optimization Pass2ConditionalJumpSequenceImprovement
Constant right-side identified [2] (byte~) main::$0 ← (const byte) main::line#0 * (byte) $28
Constant right-side identified [5] (byte) main::line#1 ← ++ (const byte) main::line#0
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) main::$0 = main::line#0*$28
Constant (const byte) main::line#1 = ++main::line#0
Successful SSA optimization Pass2ConstantIdentification
if() condition always false - eliminating [6] if((const byte) main::line#1==(byte) $19) goto main::@3
Successful SSA optimization Pass2ConstantIfs
Simplifying constant evaluating to zero (const byte) main::line#0*(byte) $28 in 
Successful SSA optimization PassNSimplifyConstantZero
Simplifying expression containing zero main::SCREEN#0 in [3] (byte*~) main::$1 ← (const byte*) main::SCREEN#0 + (const byte) main::$0
Successful SSA optimization PassNSimplifyExpressionWithZero
Eliminating unused constant (const byte) main::$0
Successful SSA optimization PassNEliminateUnusedVars
Constant (const byte*) main::$1 = main::SCREEN#0
Successful SSA optimization Pass2ConstantIdentification
Unrolling loop Loop head: main::@2_1 tails: main::@2_1 blocks: main::@2_1 
Successful SSA optimization Pass2LoopUnroll
Identical Phi Values (byte) main::line#3 (const byte) main::line#1
Successful SSA optimization Pass2IdenticalPhiElimination
Negating conditional jump and destination [8] if((byte) main::line#4==(byte) $19) goto main::@3
Successful SSA optimization Pass2ConditionalJumpSequenceImprovement
Constant right-side identified [4] (byte~) main::$4 ← (const byte) main::line#1 * (byte) $28
Constant right-side identified [7] (byte) main::line#4 ← ++ (const byte) main::line#1
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) main::$4 = main::line#1*$28
Constant (const byte) main::line#4 = ++main::line#1
Successful SSA optimization Pass2ConstantIdentification
if() condition always false - eliminating [8] if((const byte) main::line#4==(byte) $19) goto main::@3
Successful SSA optimization Pass2ConstantIfs
Constant right-side identified [3] (byte*~) main::$5 ← (const byte*) main::SCREEN#0 + (const byte) main::$4
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte*) main::$5 = main::SCREEN#0+main::$4
Successful SSA optimization Pass2ConstantIdentification
Unrolling loop Loop head: main::@2_2 tails: main::@2_2 blocks: main::@2_2 
Successful SSA optimization Pass2LoopUnroll
Identical Phi Values (byte) main::line#5 (const byte) main::line#4
Successful SSA optimization Pass2IdenticalPhiElimination
Negating conditional jump and destination [9] if((byte) main::line#6==(byte) $19) goto main::@3
Successful SSA optimization Pass2ConditionalJumpSequenceImprovement
Constant right-side identified [5] (byte~) main::$6 ← (const byte) main::line#4 * (byte) $28
Constant right-side identified [8] (byte) main::line#6 ← ++ (const byte) main::line#4
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) main::$6 = main::line#4*$28
Constant (const byte) main::line#6 = ++main::line#4
Successful SSA optimization Pass2ConstantIdentification
if() condition always false - eliminating [9] if((const byte) main::line#6==(byte) $19) goto main::@3
Successful SSA optimization Pass2ConstantIfs
Constant right-side identified [4] (byte*~) main::$7 ← (const byte*) main::SCREEN#0 + (const byte) main::$6
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte*) main::$7 = main::SCREEN#0+main::$6
Successful SSA optimization Pass2ConstantIdentification
Unrolling loop Loop head: main::@2_3 tails: main::@2_3 blocks: main::@2_3 
Successful SSA optimization Pass2LoopUnroll
Identical Phi Values (byte) main::line#7 (const byte) main::line#6
Successful SSA optimization Pass2IdenticalPhiElimination
Negating conditional jump and destination [10] if((byte) main::line#8==(byte) $19) goto main::@3
Successful SSA optimization Pass2ConditionalJumpSequenceImprovement
Constant right-side identified [6] (byte~) main::$8 ← (const byte) main::line#6 * (byte) $28
Constant right-side identified [9] (byte) main::line#8 ← ++ (const byte) main::line#6
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) main::$8 = main::line#6*$28
Constant (const byte) main::line#8 = ++main::line#6
Successful SSA optimization Pass2ConstantIdentification
if() condition always false - eliminating [10] if((const byte) main::line#8==(byte) $19) goto main::@3
Successful SSA optimization Pass2ConstantIfs
Constant right-side identified [5] (byte*~) main::$9 ← (const byte*) main::SCREEN#0 + (const byte) main::$8
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte*) main::$9 = main::SCREEN#0+main::$8
Successful SSA optimization Pass2ConstantIdentification
Unrolling loop Loop head: main::@2_4 tails: main::@2_4 blocks: main::@2_4 
Successful SSA optimization Pass2LoopUnroll
Identical Phi Values (byte) main::line#9 (const byte) main::line#8
Successful SSA optimization Pass2IdenticalPhiElimination
Negating conditional jump and destination [11] if((byte) main::line#10==(byte) $19) goto main::@3
Successful SSA optimization Pass2ConditionalJumpSequenceImprovement
Constant right-side identified [7] (byte~) main::$10 ← (const byte) main::line#8 * (byte) $28
Constant right-side identified [10] (byte) main::line#10 ← ++ (const byte) main::line#8
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) main::$10 = main::line#8*$28
Constant (const byte) main::line#10 = ++main::line#8
Successful SSA optimization Pass2ConstantIdentification
if() condition always false - eliminating [11] if((const byte) main::line#10==(byte) $19) goto main::@3
Successful SSA optimization Pass2ConstantIfs
Constant right-side identified [6] (byte*~) main::$11 ← (const byte*) main::SCREEN#0 + (const byte) main::$10
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte*) main::$11 = main::SCREEN#0+main::$10
Successful SSA optimization Pass2ConstantIdentification
Unrolling loop Loop head: main::@2_5 tails: main::@2_5 blocks: main::@2_5 
Successful SSA optimization Pass2LoopUnroll
Identical Phi Values (byte) main::line#11 (const byte) main::line#10
Successful SSA optimization Pass2IdenticalPhiElimination
Negating conditional jump and destination [12] if((byte) main::line#12==(byte) $19) goto main::@3
Successful SSA optimization Pass2ConditionalJumpSequenceImprovement
Constant right-side identified [8] (byte~) main::$12 ← (const byte) main::line#10 * (byte) $28
Constant right-side identified [11] (byte) main::line#12 ← ++ (const byte) main::line#10
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) main::$12 = main::line#10*$28
Constant (const byte) main::line#12 = ++main::line#10
Successful SSA optimization Pass2ConstantIdentification
if() condition always false - eliminating [12] if((const byte) main::line#12==(byte) $19) goto main::@3
Successful SSA optimization Pass2ConstantIfs
Constant right-side identified [7] (byte*~) main::$13 ← (const byte*) main::SCREEN#0 + (const byte) main::$12
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte*) main::$13 = main::SCREEN#0+main::$12
Successful SSA optimization Pass2ConstantIdentification
Unrolling loop Loop head: main::@2_6 tails: main::@2_6 blocks: main::@2_6 
Successful SSA optimization Pass2LoopUnroll
Identical Phi Values (byte) main::line#13 (const byte) main::line#12
Successful SSA optimization Pass2IdenticalPhiElimination
Negating conditional jump and destination [13] if((byte) main::line#14==(byte) $19) goto main::@3
Successful SSA optimization Pass2ConditionalJumpSequenceImprovement
Constant right-side identified [9] (byte~) main::$14 ← (const byte) main::line#12 * (byte) $28
Constant right-side identified [12] (byte) main::line#14 ← ++ (const byte) main::line#12
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) main::$14 = main::line#12*$28
Constant (const byte) main::line#14 = ++main::line#12
Successful SSA optimization Pass2ConstantIdentification
if() condition always false - eliminating [13] if((const byte) main::line#14==(byte) $19) goto main::@3
Successful SSA optimization Pass2ConstantIfs
Constant right-side identified [8] (byte*~) main::$15 ← (const byte*) main::SCREEN#0 + (const byte) main::$14
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte*) main::$15 = main::SCREEN#0+main::$14
Successful SSA optimization Pass2ConstantIdentification
Unrolling loop Loop head: main::@2_7 tails: main::@2_7 blocks: main::@2_7 
Successful SSA optimization Pass2LoopUnroll
Identical Phi Values (byte) main::line#15 (const byte) main::line#14
Successful SSA optimization Pass2IdenticalPhiElimination
Negating conditional jump and destination [14] if((byte) main::line#16==(byte) $19) goto main::@3
Successful SSA optimization Pass2ConditionalJumpSequenceImprovement
Constant right-side identified [10] (byte~) main::$16 ← (const byte) main::line#14 * (byte) $28
Constant right-side identified [13] (byte) main::line#16 ← ++ (const byte) main::line#14
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) main::$16 = main::line#14*$28
Constant (const byte) main::line#16 = ++main::line#14
Successful SSA optimization Pass2ConstantIdentification
if() condition always false - eliminating [14] if((const byte) main::line#16==(byte) $19) goto main::@3
Successful SSA optimization Pass2ConstantIfs
Constant right-side identified [9] (byte*~) main::$17 ← (const byte*) main::SCREEN#0 + (const byte) main::$16
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte*) main::$17 = main::SCREEN#0+main::$16
Successful SSA optimization Pass2ConstantIdentification
Unrolling loop Loop head: main::@2_8 tails: main::@2_8 blocks: main::@2_8 
Successful SSA optimization Pass2LoopUnroll
Identical Phi Values (byte) main::line#17 (const byte) main::line#16
Successful SSA optimization Pass2IdenticalPhiElimination
Negating conditional jump and destination [15] if((byte) main::line#18==(byte) $19) goto main::@3
Successful SSA optimization Pass2ConditionalJumpSequenceImprovement
Constant right-side identified [11] (byte~) main::$18 ← (const byte) main::line#16 * (byte) $28
Constant right-side identified [14] (byte) main::line#18 ← ++ (const byte) main::line#16
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) main::$18 = main::line#16*$28
Constant (const byte) main::line#18 = ++main::line#16
Successful SSA optimization Pass2ConstantIdentification
if() condition always false - eliminating [15] if((const byte) main::line#18==(byte) $19) goto main::@3
Successful SSA optimization Pass2ConstantIfs
Constant right-side identified [10] (byte*~) main::$19 ← (const byte*) main::SCREEN#0 + (const byte) main::$18
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte*) main::$19 = main::SCREEN#0+main::$18
Successful SSA optimization Pass2ConstantIdentification
Unrolling loop Loop head: main::@2_9 tails: main::@2_9 blocks: main::@2_9 
Successful SSA optimization Pass2LoopUnroll
Identical Phi Values (byte) main::line#19 (const byte) main::line#18
Successful SSA optimization Pass2IdenticalPhiElimination
Negating conditional jump and destination [16] if((byte) main::line#20==(byte) $19) goto main::@3
Successful SSA optimization Pass2ConditionalJumpSequenceImprovement
Constant right-side identified [12] (byte~) main::$20 ← (const byte) main::line#18 * (byte) $28
Constant right-side identified [15] (byte) main::line#20 ← ++ (const byte) main::line#18
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) main::$20 = main::line#18*$28
Constant (const byte) main::line#20 = ++main::line#18
Successful SSA optimization Pass2ConstantIdentification
if() condition always false - eliminating [16] if((const byte) main::line#20==(byte) $19) goto main::@3
Successful SSA optimization Pass2ConstantIfs
Constant right-side identified [11] (byte*~) main::$21 ← (const byte*) main::SCREEN#0 + (const byte) main::$20
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte*) main::$21 = main::SCREEN#0+main::$20
Successful SSA optimization Pass2ConstantIdentification
Unrolling loop Loop head: main::@2_10 tails: main::@2_10 blocks: main::@2_10 
Successful SSA optimization Pass2LoopUnroll
Identical Phi Values (byte) main::line#21 (const byte) main::line#20
Successful SSA optimization Pass2IdenticalPhiElimination
Negating conditional jump and destination [17] if((byte) main::line#22==(byte) $19) goto main::@3
Successful SSA optimization Pass2ConditionalJumpSequenceImprovement
Constant right-side identified [13] (byte~) main::$22 ← (const byte) main::line#20 * (byte) $28
Constant right-side identified [16] (byte) main::line#22 ← ++ (const byte) main::line#20
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) main::$22 = main::line#20*$28
Constant (const byte) main::line#22 = ++main::line#20
Successful SSA optimization Pass2ConstantIdentification
if() condition always false - eliminating [17] if((const byte) main::line#22==(byte) $19) goto main::@3
Successful SSA optimization Pass2ConstantIfs
Constant right-side identified [12] (byte*~) main::$23 ← (const byte*) main::SCREEN#0 + (const byte) main::$22
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte*) main::$23 = main::SCREEN#0+main::$22
Successful SSA optimization Pass2ConstantIdentification
Unrolling loop Loop head: main::@2_11 tails: main::@2_11 blocks: main::@2_11 
Successful SSA optimization Pass2LoopUnroll
Identical Phi Values (byte) main::line#23 (const byte) main::line#22
Successful SSA optimization Pass2IdenticalPhiElimination
Negating conditional jump and destination [18] if((byte) main::line#24==(byte) $19) goto main::@3
Successful SSA optimization Pass2ConditionalJumpSequenceImprovement
Constant right-side identified [14] (byte~) main::$24 ← (const byte) main::line#22 * (byte) $28
Constant right-side identified [17] (byte) main::line#24 ← ++ (const byte) main::line#22
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) main::$24 = main::line#22*$28
Constant (const byte) main::line#24 = ++main::line#22
Successful SSA optimization Pass2ConstantIdentification
if() condition always false - eliminating [18] if((const byte) main::line#24==(byte) $19) goto main::@3
Successful SSA optimization Pass2ConstantIfs
Constant right-side identified [13] (byte*~) main::$25 ← (const byte*) main::SCREEN#0 + (const byte) main::$24
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte*) main::$25 = main::SCREEN#0+main::$24
Successful SSA optimization Pass2ConstantIdentification
Unrolling loop Loop head: main::@2_12 tails: main::@2_12 blocks: main::@2_12 
Successful SSA optimization Pass2LoopUnroll
Identical Phi Values (byte) main::line#25 (const byte) main::line#24
Successful SSA optimization Pass2IdenticalPhiElimination
Negating conditional jump and destination [19] if((byte) main::line#26==(byte) $19) goto main::@3
Successful SSA optimization Pass2ConditionalJumpSequenceImprovement
Constant right-side identified [15] (byte~) main::$26 ← (const byte) main::line#24 * (byte) $28
Constant right-side identified [18] (byte) main::line#26 ← ++ (const byte) main::line#24
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) main::$26 = main::line#24*$28
Constant (const byte) main::line#26 = ++main::line#24
Successful SSA optimization Pass2ConstantIdentification
if() condition always false - eliminating [19] if((const byte) main::line#26==(byte) $19) goto main::@3
Successful SSA optimization Pass2ConstantIfs
Constant right-side identified [14] (byte*~) main::$27 ← (const byte*) main::SCREEN#0 + (const byte) main::$26
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte*) main::$27 = main::SCREEN#0+main::$26
Successful SSA optimization Pass2ConstantIdentification
Unrolling loop Loop head: main::@2_13 tails: main::@2_13 blocks: main::@2_13 
Successful SSA optimization Pass2LoopUnroll
Identical Phi Values (byte) main::line#27 (const byte) main::line#26
Successful SSA optimization Pass2IdenticalPhiElimination
Negating conditional jump and destination [20] if((byte) main::line#28==(byte) $19) goto main::@3
Successful SSA optimization Pass2ConditionalJumpSequenceImprovement
Constant right-side identified [16] (byte~) main::$28 ← (const byte) main::line#26 * (byte) $28
Constant right-side identified [19] (byte) main::line#28 ← ++ (const byte) main::line#26
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) main::$28 = main::line#26*$28
Constant (const byte) main::line#28 = ++main::line#26
Successful SSA optimization Pass2ConstantIdentification
if() condition always false - eliminating [20] if((const byte) main::line#28==(byte) $19) goto main::@3
Successful SSA optimization Pass2ConstantIfs
Constant right-side identified [15] (byte*~) main::$29 ← (const byte*) main::SCREEN#0 + (const byte) main::$28
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte*) main::$29 = main::SCREEN#0+main::$28
Successful SSA optimization Pass2ConstantIdentification
Unrolling loop Loop head: main::@2_14 tails: main::@2_14 blocks: main::@2_14 
Successful SSA optimization Pass2LoopUnroll
Identical Phi Values (byte) main::line#29 (const byte) main::line#28
Successful SSA optimization Pass2IdenticalPhiElimination
Negating conditional jump and destination [21] if((byte) main::line#30==(byte) $19) goto main::@3
Successful SSA optimization Pass2ConditionalJumpSequenceImprovement
Constant right-side identified [17] (byte~) main::$30 ← (const byte) main::line#28 * (byte) $28
Constant right-side identified [20] (byte) main::line#30 ← ++ (const byte) main::line#28
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) main::$30 = main::line#28*$28
Constant (const byte) main::line#30 = ++main::line#28
Successful SSA optimization Pass2ConstantIdentification
if() condition always false - eliminating [21] if((const byte) main::line#30==(byte) $19) goto main::@3
Successful SSA optimization Pass2ConstantIfs
Constant right-side identified [16] (byte*~) main::$31 ← (const byte*) main::SCREEN#0 + (const byte) main::$30
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte*) main::$31 = main::SCREEN#0+main::$30
Successful SSA optimization Pass2ConstantIdentification
Unrolling loop Loop head: main::@2_15 tails: main::@2_15 blocks: main::@2_15 
Successful SSA optimization Pass2LoopUnroll
Identical Phi Values (byte) main::line#31 (const byte) main::line#30
Successful SSA optimization Pass2IdenticalPhiElimination
Negating conditional jump and destination [22] if((byte) main::line#32==(byte) $19) goto main::@3
Successful SSA optimization Pass2ConditionalJumpSequenceImprovement
Constant right-side identified [18] (byte~) main::$32 ← (const byte) main::line#30 * (byte) $28
Constant right-side identified [21] (byte) main::line#32 ← ++ (const byte) main::line#30
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) main::$32 = main::line#30*$28
Constant (const byte) main::line#32 = ++main::line#30
Successful SSA optimization Pass2ConstantIdentification
if() condition always false - eliminating [22] if((const byte) main::line#32==(byte) $19) goto main::@3
Successful SSA optimization Pass2ConstantIfs
Constant right-side identified [17] (byte*~) main::$33 ← (const byte*) main::SCREEN#0 + (const byte) main::$32
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte*) main::$33 = main::SCREEN#0+main::$32
Successful SSA optimization Pass2ConstantIdentification
Unrolling loop Loop head: main::@2_16 tails: main::@2_16 blocks: main::@2_16 
Successful SSA optimization Pass2LoopUnroll
Identical Phi Values (byte) main::line#33 (const byte) main::line#32
Successful SSA optimization Pass2IdenticalPhiElimination
Negating conditional jump and destination [23] if((byte) main::line#34==(byte) $19) goto main::@3
Successful SSA optimization Pass2ConditionalJumpSequenceImprovement
Constant right-side identified [19] (byte~) main::$34 ← (const byte) main::line#32 * (byte) $28
Constant right-side identified [22] (byte) main::line#34 ← ++ (const byte) main::line#32
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) main::$34 = main::line#32*$28
Constant (const byte) main::line#34 = ++main::line#32
Successful SSA optimization Pass2ConstantIdentification
if() condition always false - eliminating [23] if((const byte) main::line#34==(byte) $19) goto main::@3
Successful SSA optimization Pass2ConstantIfs
Constant right-side identified [18] (byte*~) main::$35 ← (const byte*) main::SCREEN#0 + (const byte) main::$34
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte*) main::$35 = main::SCREEN#0+main::$34
Successful SSA optimization Pass2ConstantIdentification
Unrolling loop Loop head: main::@2_17 tails: main::@2_17 blocks: main::@2_17 
Successful SSA optimization Pass2LoopUnroll
Identical Phi Values (byte) main::line#35 (const byte) main::line#34
Successful SSA optimization Pass2IdenticalPhiElimination
Negating conditional jump and destination [24] if((byte) main::line#36==(byte) $19) goto main::@3
Successful SSA optimization Pass2ConditionalJumpSequenceImprovement
Constant right-side identified [20] (byte~) main::$36 ← (const byte) main::line#34 * (byte) $28
Constant right-side identified [23] (byte) main::line#36 ← ++ (const byte) main::line#34
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) main::$36 = main::line#34*$28
Constant (const byte) main::line#36 = ++main::line#34
Successful SSA optimization Pass2ConstantIdentification
if() condition always false - eliminating [24] if((const byte) main::line#36==(byte) $19) goto main::@3
Successful SSA optimization Pass2ConstantIfs
Constant right-side identified [19] (byte*~) main::$37 ← (const byte*) main::SCREEN#0 + (const byte) main::$36
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte*) main::$37 = main::SCREEN#0+main::$36
Successful SSA optimization Pass2ConstantIdentification
Unrolling loop Loop head: main::@2_18 tails: main::@2_18 blocks: main::@2_18 
Successful SSA optimization Pass2LoopUnroll
Identical Phi Values (byte) main::line#37 (const byte) main::line#36
Successful SSA optimization Pass2IdenticalPhiElimination
Negating conditional jump and destination [25] if((byte) main::line#38==(byte) $19) goto main::@3
Successful SSA optimization Pass2ConditionalJumpSequenceImprovement
Constant right-side identified [21] (byte~) main::$38 ← (const byte) main::line#36 * (byte) $28
Constant right-side identified [24] (byte) main::line#38 ← ++ (const byte) main::line#36
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) main::$38 = main::line#36*$28
Constant (const byte) main::line#38 = ++main::line#36
Successful SSA optimization Pass2ConstantIdentification
if() condition always false - eliminating [25] if((const byte) main::line#38==(byte) $19) goto main::@3
Successful SSA optimization Pass2ConstantIfs
Constant right-side identified [20] (byte*~) main::$39 ← (const byte*) main::SCREEN#0 + (const byte) main::$38
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte*) main::$39 = main::SCREEN#0+main::$38
Successful SSA optimization Pass2ConstantIdentification
Unrolling loop Loop head: main::@2_19 tails: main::@2_19 blocks: main::@2_19 
Successful SSA optimization Pass2LoopUnroll
Identical Phi Values (byte) main::line#39 (const byte) main::line#38
Successful SSA optimization Pass2IdenticalPhiElimination
Negating conditional jump and destination [26] if((byte) main::line#40==(byte) $19) goto main::@3
Successful SSA optimization Pass2ConditionalJumpSequenceImprovement
Constant right-side identified [22] (byte~) main::$40 ← (const byte) main::line#38 * (byte) $28
Constant right-side identified [25] (byte) main::line#40 ← ++ (const byte) main::line#38
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) main::$40 = main::line#38*$28
Constant (const byte) main::line#40 = ++main::line#38
Successful SSA optimization Pass2ConstantIdentification
if() condition always false - eliminating [26] if((const byte) main::line#40==(byte) $19) goto main::@3
Successful SSA optimization Pass2ConstantIfs
Constant right-side identified [21] (byte*~) main::$41 ← (const byte*) main::SCREEN#0 + (const byte) main::$40
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte*) main::$41 = main::SCREEN#0+main::$40
Successful SSA optimization Pass2ConstantIdentification
Unrolling loop Loop head: main::@2_20 tails: main::@2_20 blocks: main::@2_20 
Successful SSA optimization Pass2LoopUnroll
Identical Phi Values (byte) main::line#41 (const byte) main::line#40
Successful SSA optimization Pass2IdenticalPhiElimination
Negating conditional jump and destination [27] if((byte) main::line#42==(byte) $19) goto main::@3
Successful SSA optimization Pass2ConditionalJumpSequenceImprovement
Constant right-side identified [23] (byte~) main::$42 ← (const byte) main::line#40 * (byte) $28
Constant right-side identified [26] (byte) main::line#42 ← ++ (const byte) main::line#40
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) main::$42 = main::line#40*$28
Constant (const byte) main::line#42 = ++main::line#40
Successful SSA optimization Pass2ConstantIdentification
if() condition always false - eliminating [27] if((const byte) main::line#42==(byte) $19) goto main::@3
Successful SSA optimization Pass2ConstantIfs
Constant right-side identified [22] (byte*~) main::$43 ← (const byte*) main::SCREEN#0 + (const byte) main::$42
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte*) main::$43 = main::SCREEN#0+main::$42
Successful SSA optimization Pass2ConstantIdentification
Unrolling loop Loop head: main::@2_21 tails: main::@2_21 blocks: main::@2_21 
Successful SSA optimization Pass2LoopUnroll
Identical Phi Values (byte) main::line#43 (const byte) main::line#42
Successful SSA optimization Pass2IdenticalPhiElimination
Negating conditional jump and destination [28] if((byte) main::line#44==(byte) $19) goto main::@3
Successful SSA optimization Pass2ConditionalJumpSequenceImprovement
Constant right-side identified [24] (byte~) main::$44 ← (const byte) main::line#42 * (byte) $28
Constant right-side identified [27] (byte) main::line#44 ← ++ (const byte) main::line#42
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) main::$44 = main::line#42*$28
Constant (const byte) main::line#44 = ++main::line#42
Successful SSA optimization Pass2ConstantIdentification
if() condition always false - eliminating [28] if((const byte) main::line#44==(byte) $19) goto main::@3
Successful SSA optimization Pass2ConstantIfs
Constant right-side identified [23] (byte*~) main::$45 ← (const byte*) main::SCREEN#0 + (const byte) main::$44
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte*) main::$45 = main::SCREEN#0+main::$44
Successful SSA optimization Pass2ConstantIdentification
Unrolling loop Loop head: main::@2_22 tails: main::@2_22 blocks: main::@2_22 
Successful SSA optimization Pass2LoopUnroll
Identical Phi Values (byte) main::line#45 (const byte) main::line#44
Successful SSA optimization Pass2IdenticalPhiElimination
Negating conditional jump and destination [29] if((byte) main::line#46==(byte) $19) goto main::@3
Successful SSA optimization Pass2ConditionalJumpSequenceImprovement
Constant right-side identified [25] (byte~) main::$46 ← (const byte) main::line#44 * (byte) $28
Constant right-side identified [28] (byte) main::line#46 ← ++ (const byte) main::line#44
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) main::$46 = main::line#44*$28
Constant (const byte) main::line#46 = ++main::line#44
Successful SSA optimization Pass2ConstantIdentification
if() condition always false - eliminating [29] if((const byte) main::line#46==(byte) $19) goto main::@3
Successful SSA optimization Pass2ConstantIfs
Constant right-side identified [24] (byte*~) main::$47 ← (const byte*) main::SCREEN#0 + (const byte) main::$46
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte*) main::$47 = main::SCREEN#0+main::$46
Successful SSA optimization Pass2ConstantIdentification
Unrolling loop Loop head: main::@2_23 tails: main::@2_23 blocks: main::@2_23 
Successful SSA optimization Pass2LoopUnroll
Identical Phi Values (byte) main::line#47 (const byte) main::line#46
Successful SSA optimization Pass2IdenticalPhiElimination
Negating conditional jump and destination [30] if((byte) main::line#48==(byte) $19) goto main::@3
Successful SSA optimization Pass2ConditionalJumpSequenceImprovement
Constant right-side identified [26] (byte~) main::$48 ← (const byte) main::line#46 * (byte) $28
Constant right-side identified [29] (byte) main::line#48 ← ++ (const byte) main::line#46
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) main::$48 = main::line#46*$28
Constant (const byte) main::line#48 = ++main::line#46
Successful SSA optimization Pass2ConstantIdentification
if() condition always false - eliminating [30] if((const byte) main::line#48==(byte) $19) goto main::@3
Successful SSA optimization Pass2ConstantIfs
Constant right-side identified [25] (byte*~) main::$49 ← (const byte*) main::SCREEN#0 + (const byte) main::$48
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte*) main::$49 = main::SCREEN#0+main::$48
Successful SSA optimization Pass2ConstantIdentification
Unrolling loop Loop head: main::@2_24 tails: main::@2_24 blocks: main::@2_24 
Successful SSA optimization Pass2LoopUnroll
Identical Phi Values (byte) main::line#49 (const byte) main::line#48
Successful SSA optimization Pass2IdenticalPhiElimination
Negating conditional jump and destination [31] if((byte) main::line#50==(byte) $19) goto main::@3
Successful SSA optimization Pass2ConditionalJumpSequenceImprovement
Constant right-side identified [27] (byte~) main::$50 ← (const byte) main::line#48 * (byte) $28
Constant right-side identified [30] (byte) main::line#50 ← ++ (const byte) main::line#48
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) main::$50 = main::line#48*$28
Constant (const byte) main::line#50 = ++main::line#48
Successful SSA optimization Pass2ConstantIdentification
Removing PHI-reference to removed block (main::@2_24) in block main::@2_25
if() condition always true - replacing block destination [31] if((const byte) main::line#50==(byte) $19) goto main::@3
Successful SSA optimization Pass2ConstantIfs
Eliminating unused constant (const byte) main::line#50
Successful SSA optimization PassNEliminateUnusedVars
Eliminating variable (byte) main::line#51 from unused block main::@2_25
Eliminating variable (byte~) main::$52 from unused block main::@2_25
Eliminating variable (byte*~) main::$53 from unused block main::@2_25
Eliminating variable (byte) main::line#52 from unused block main::@2_25
Removing unused block main::@2_25
Successful SSA optimization Pass2EliminateUnusedBlocks
Constant right-side identified [26] (byte*~) main::$51 ← (const byte*) main::SCREEN#0 + (const byte) main::$50
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte*) main::$51 = main::SCREEN#0+main::$50
Successful SSA optimization Pass2ConstantIdentification
Inlining constant with var siblings (const byte) main::x#0
Inlining constant with different constant siblings (const byte) main::line#0
Inlining constant with different constant siblings (const byte) main::line#1
Inlining constant with different constant siblings (const byte) main::line#4
Inlining constant with different constant siblings (const byte) main::line#6
Inlining constant with different constant siblings (const byte) main::line#8
Inlining constant with different constant siblings (const byte) main::line#10
Inlining constant with different constant siblings (const byte) main::line#12
Inlining constant with different constant siblings (const byte) main::line#14
Inlining constant with different constant siblings (const byte) main::line#16
Inlining constant with different constant siblings (const byte) main::line#18
Inlining constant with different constant siblings (const byte) main::line#20
Inlining constant with different constant siblings (const byte) main::line#22
Inlining constant with different constant siblings (const byte) main::line#24
Inlining constant with different constant siblings (const byte) main::line#26
Inlining constant with different constant siblings (const byte) main::line#28
Inlining constant with different constant siblings (const byte) main::line#30
Inlining constant with different constant siblings (const byte) main::line#32
Inlining constant with different constant siblings (const byte) main::line#34
Inlining constant with different constant siblings (const byte) main::line#36
Inlining constant with different constant siblings (const byte) main::line#38
Inlining constant with different constant siblings (const byte) main::line#40
Inlining constant with different constant siblings (const byte) main::line#42
Inlining constant with different constant siblings (const byte) main::line#44
Inlining constant with different constant siblings (const byte) main::line#46
Inlining constant with different constant siblings (const byte) main::line#48
Constant inlined main::$50 = ++++++++++++++++++++++++++++++++++++++++++++++++(byte) 0*(byte) $28
Constant inlined main::$51 = (const byte*) main::SCREEN#0+++++++++++++++++++++++++++++++++++++++++++++++++(byte) 0*(byte) $28
Constant inlined main::$12 = ++++++++++(byte) 0*(byte) $28
Constant inlined main::$13 = (const byte*) main::SCREEN#0+++++++++++(byte) 0*(byte) $28
Constant inlined main::$14 = ++++++++++++(byte) 0*(byte) $28
Constant inlined main::$15 = (const byte*) main::SCREEN#0+++++++++++++(byte) 0*(byte) $28
Constant inlined main::$10 = ++++++++(byte) 0*(byte) $28
Constant inlined main::$11 = (const byte*) main::SCREEN#0+++++++++(byte) 0*(byte) $28
Constant inlined main::line#42 = ++++++++++++++++++++++++++++++++++++++++++(byte) 0
Constant inlined main::line#44 = ++++++++++++++++++++++++++++++++++++++++++++(byte) 0
Constant inlined main::$16 = ++++++++++++++(byte) 0*(byte) $28
Constant inlined main::$17 = (const byte*) main::SCREEN#0+++++++++++++++(byte) 0*(byte) $28
Constant inlined main::$18 = ++++++++++++++++(byte) 0*(byte) $28
Constant inlined main::$19 = (const byte*) main::SCREEN#0+++++++++++++++++(byte) 0*(byte) $28
Constant inlined main::line#40 = ++++++++++++++++++++++++++++++++++++++++(byte) 0
Constant inlined main::line#4 = ++++(byte) 0
Constant inlined main::line#0 = (byte) 0
Constant inlined main::line#1 = ++(byte) 0
Constant inlined main::line#46 = ++++++++++++++++++++++++++++++++++++++++++++++(byte) 0
Constant inlined main::line#48 = ++++++++++++++++++++++++++++++++++++++++++++++++(byte) 0
Constant inlined main::$40 = ++++++++++++++++++++++++++++++++++++++(byte) 0*(byte) $28
Constant inlined main::line#8 = ++++++++(byte) 0
Constant inlined main::line#6 = ++++++(byte) 0
Constant inlined main::$45 = (const byte*) main::SCREEN#0+++++++++++++++++++++++++++++++++++++++++++(byte) 0*(byte) $28
Constant inlined main::$46 = ++++++++++++++++++++++++++++++++++++++++++++(byte) 0*(byte) $28
Constant inlined main::$47 = (const byte*) main::SCREEN#0+++++++++++++++++++++++++++++++++++++++++++++(byte) 0*(byte) $28
Constant inlined main::$48 = ++++++++++++++++++++++++++++++++++++++++++++++(byte) 0*(byte) $28
Constant inlined main::$41 = (const byte*) main::SCREEN#0+++++++++++++++++++++++++++++++++++++++(byte) 0*(byte) $28
Constant inlined main::$42 = ++++++++++++++++++++++++++++++++++++++++(byte) 0*(byte) $28
Constant inlined main::$43 = (const byte*) main::SCREEN#0+++++++++++++++++++++++++++++++++++++++++(byte) 0*(byte) $28
Constant inlined main::$44 = ++++++++++++++++++++++++++++++++++++++++++(byte) 0*(byte) $28
Constant inlined main::line#10 = ++++++++++(byte) 0
Constant inlined main::line#12 = ++++++++++++(byte) 0
Constant inlined main::$49 = (const byte*) main::SCREEN#0+++++++++++++++++++++++++++++++++++++++++++++++(byte) 0*(byte) $28
Constant inlined main::line#18 = ++++++++++++++++++(byte) 0
Constant inlined main::line#14 = ++++++++++++++(byte) 0
Constant inlined main::line#16 = ++++++++++++++++(byte) 0
Constant inlined main::$34 = ++++++++++++++++++++++++++++++++(byte) 0*(byte) $28
Constant inlined main::$35 = (const byte*) main::SCREEN#0+++++++++++++++++++++++++++++++++(byte) 0*(byte) $28
Constant inlined main::$36 = ++++++++++++++++++++++++++++++++++(byte) 0*(byte) $28
Constant inlined main::$37 = (const byte*) main::SCREEN#0+++++++++++++++++++++++++++++++++++(byte) 0*(byte) $28
Constant inlined main::$30 = ++++++++++++++++++++++++++++(byte) 0*(byte) $28
Constant inlined main::$31 = (const byte*) main::SCREEN#0+++++++++++++++++++++++++++++(byte) 0*(byte) $28
Constant inlined main::$32 = ++++++++++++++++++++++++++++++(byte) 0*(byte) $28
Constant inlined main::$33 = (const byte*) main::SCREEN#0+++++++++++++++++++++++++++++++(byte) 0*(byte) $28
Constant inlined main::line#20 = ++++++++++++++++++++(byte) 0
Constant inlined main::line#22 = ++++++++++++++++++++++(byte) 0
Constant inlined main::$38 = ++++++++++++++++++++++++++++++++++++(byte) 0*(byte) $28
Constant inlined main::$39 = (const byte*) main::SCREEN#0+++++++++++++++++++++++++++++++++++++(byte) 0*(byte) $28
Constant inlined main::line#28 = ++++++++++++++++++++++++++++(byte) 0
Constant inlined main::line#24 = ++++++++++++++++++++++++(byte) 0
Constant inlined main::line#26 = ++++++++++++++++++++++++++(byte) 0
Constant inlined main::$23 = (const byte*) main::SCREEN#0+++++++++++++++++++++(byte) 0*(byte) $28
Constant inlined main::$24 = ++++++++++++++++++++++(byte) 0*(byte) $28
Constant inlined main::$25 = (const byte*) main::SCREEN#0+++++++++++++++++++++++(byte) 0*(byte) $28
Constant inlined main::x#0 = (byte) 0
Constant inlined main::$26 = ++++++++++++++++++++++++(byte) 0*(byte) $28
Constant inlined main::$20 = ++++++++++++++++++(byte) 0*(byte) $28
Constant inlined main::$21 = (const byte*) main::SCREEN#0+++++++++++++++++++(byte) 0*(byte) $28
Constant inlined main::$22 = ++++++++++++++++++++(byte) 0*(byte) $28
Constant inlined main::line#32 = ++++++++++++++++++++++++++++++++(byte) 0
Constant inlined main::line#34 = ++++++++++++++++++++++++++++++++++(byte) 0
Constant inlined main::$1 = (const byte*) main::SCREEN#0
Constant inlined main::$27 = (const byte*) main::SCREEN#0+++++++++++++++++++++++++(byte) 0*(byte) $28
Constant inlined main::$28 = ++++++++++++++++++++++++++(byte) 0*(byte) $28
Constant inlined main::$29 = (const byte*) main::SCREEN#0+++++++++++++++++++++++++++(byte) 0*(byte) $28
Constant inlined main::line#30 = ++++++++++++++++++++++++++++++(byte) 0
Constant inlined main::$5 = (const byte*) main::SCREEN#0+++(byte) 0*(byte) $28
Constant inlined main::$6 = ++++(byte) 0*(byte) $28
Constant inlined main::$4 = ++(byte) 0*(byte) $28
Constant inlined main::$9 = (const byte*) main::SCREEN#0+++++++(byte) 0*(byte) $28
Constant inlined main::line#36 = ++++++++++++++++++++++++++++++++++++(byte) 0
Constant inlined main::$7 = (const byte*) main::SCREEN#0+++++(byte) 0*(byte) $28
Constant inlined main::line#38 = ++++++++++++++++++++++++++++++++++++++(byte) 0
Constant inlined main::$8 = ++++++(byte) 0*(byte) $28
Successful SSA optimization Pass2ConstantInlining
Simplifying constant integer increment ++0
Simplifying constant integer increment ++0
Simplifying constant integer increment ++1
Simplifying constant integer increment ++2
Simplifying constant integer increment ++3
Simplifying constant integer increment ++4
Simplifying constant integer increment ++5
Simplifying constant integer increment ++6
Simplifying constant integer increment ++7
Simplifying constant integer increment ++8
Simplifying constant integer increment ++9
Simplifying constant integer increment ++$a
Simplifying constant integer increment ++$b
Simplifying constant integer increment ++$c
Simplifying constant integer increment ++$d
Simplifying constant integer increment ++$e
Simplifying constant integer increment ++$f
Simplifying constant integer increment ++$10
Simplifying constant integer increment ++$11
Simplifying constant integer increment ++$12
Simplifying constant integer increment ++$13
Simplifying constant integer increment ++$14
Simplifying constant integer increment ++$15
Simplifying constant integer increment ++$16
Successful SSA optimization Pass2ConstantSimplification
Simplifying constant integer increment ++1
Simplifying constant integer increment ++2
Simplifying constant integer increment ++3
Simplifying constant integer increment ++4
Simplifying constant integer increment ++5
Simplifying constant integer increment ++6
Simplifying constant integer increment ++7
Simplifying constant integer increment ++8
Simplifying constant integer increment ++9
Simplifying constant integer increment ++$a
Simplifying constant integer increment ++$b
Simplifying constant integer increment ++$c
Simplifying constant integer increment ++$d
Simplifying constant integer increment ++$e
Simplifying constant integer increment ++$f
Simplifying constant integer increment ++$10
Simplifying constant integer increment ++$11
Simplifying constant integer increment ++$12
Simplifying constant integer increment ++$13
Simplifying constant integer increment ++$14
Simplifying constant integer increment ++$15
Simplifying constant integer increment ++$16
Simplifying constant integer increment ++$17
Successful SSA optimization Pass2ConstantSimplification
Added new block during phi lifting main::@5(between main::@3 and main::@1)
Adding NOP phi() at start of @begin
Adding NOP phi() at start of @1
Adding NOP phi() at start of @2
Adding NOP phi() at start of @end
Adding NOP phi() at start of main
CALL GRAPH
Calls in [] to main:2 

Created 1 initial phi equivalence classes
Coalesced [35] main::x#5 ← main::x#1
Coalesced down to 1 phi equivalence classes
Culled Empty Block (label) @2
Culled Empty Block (label) main::@5
Adding NOP phi() at start of @begin
Adding NOP phi() at start of @1
Adding NOP phi() at start of @end
Adding NOP phi() at start of main

FINAL CONTROL FLOW GRAPH
@begin: scope:[]  from
  [0] phi()
  to:@1
@1: scope:[]  from @begin
  [1] phi()
  [2] call main 
  to:@end
@end: scope:[]  from @1
  [3] phi()
main: scope:[main]  from @1
  [4] phi()
  to:main::@1
main::@1: scope:[main]  from main main::@3
  [5] (byte) main::x#4 ← phi( main/(byte) 0 main::@3/(byte) main::x#1 )
  to:main::@2
main::@2: scope:[main]  from main::@1
  [6] *((const byte*) main::SCREEN#0 + (byte) main::x#4) ← (byte) main::x#4
  to:main::@2_1
main::@2_1: scope:[main]  from main::@2
  [7] *((const byte*) main::SCREEN#0+(byte) 1*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4
  to:main::@2_2
main::@2_2: scope:[main]  from main::@2_1
  [8] *((const byte*) main::SCREEN#0+(byte) 2*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4
  to:main::@2_3
main::@2_3: scope:[main]  from main::@2_2
  [9] *((const byte*) main::SCREEN#0+(byte) 3*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4
  to:main::@2_4
main::@2_4: scope:[main]  from main::@2_3
  [10] *((const byte*) main::SCREEN#0+(byte) 4*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4
  to:main::@2_5
main::@2_5: scope:[main]  from main::@2_4
  [11] *((const byte*) main::SCREEN#0+(byte) 5*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4
  to:main::@2_6
main::@2_6: scope:[main]  from main::@2_5
  [12] *((const byte*) main::SCREEN#0+(byte) 6*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4
  to:main::@2_7
main::@2_7: scope:[main]  from main::@2_6
  [13] *((const byte*) main::SCREEN#0+(byte) 7*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4
  to:main::@2_8
main::@2_8: scope:[main]  from main::@2_7
  [14] *((const byte*) main::SCREEN#0+(byte) 8*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4
  to:main::@2_9
main::@2_9: scope:[main]  from main::@2_8
  [15] *((const byte*) main::SCREEN#0+(byte) 9*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4
  to:main::@2_10
main::@2_10: scope:[main]  from main::@2_9
  [16] *((const byte*) main::SCREEN#0+(byte) $a*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4
  to:main::@2_11
main::@2_11: scope:[main]  from main::@2_10
  [17] *((const byte*) main::SCREEN#0+(byte) $b*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4
  to:main::@2_12
main::@2_12: scope:[main]  from main::@2_11
  [18] *((const byte*) main::SCREEN#0+(byte) $c*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4
  to:main::@2_13
main::@2_13: scope:[main]  from main::@2_12
  [19] *((const byte*) main::SCREEN#0+(byte) $d*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4
  to:main::@2_14
main::@2_14: scope:[main]  from main::@2_13
  [20] *((const byte*) main::SCREEN#0+(byte) $e*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4
  to:main::@2_15
main::@2_15: scope:[main]  from main::@2_14
  [21] *((const byte*) main::SCREEN#0+(byte) $f*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4
  to:main::@2_16
main::@2_16: scope:[main]  from main::@2_15
  [22] *((const byte*) main::SCREEN#0+(byte) $10*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4
  to:main::@2_17
main::@2_17: scope:[main]  from main::@2_16
  [23] *((const byte*) main::SCREEN#0+(byte) $11*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4
  to:main::@2_18
main::@2_18: scope:[main]  from main::@2_17
  [24] *((const byte*) main::SCREEN#0+(byte) $12*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4
  to:main::@2_19
main::@2_19: scope:[main]  from main::@2_18
  [25] *((const byte*) main::SCREEN#0+(byte) $13*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4
  to:main::@2_20
main::@2_20: scope:[main]  from main::@2_19
  [26] *((const byte*) main::SCREEN#0+(byte) $14*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4
  to:main::@2_21
main::@2_21: scope:[main]  from main::@2_20
  [27] *((const byte*) main::SCREEN#0+(byte) $15*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4
  to:main::@2_22
main::@2_22: scope:[main]  from main::@2_21
  [28] *((const byte*) main::SCREEN#0+(byte) $16*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4
  to:main::@2_23
main::@2_23: scope:[main]  from main::@2_22
  [29] *((const byte*) main::SCREEN#0+(byte) $17*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4
  to:main::@2_24
main::@2_24: scope:[main]  from main::@2_23
  [30] *((const byte*) main::SCREEN#0+(byte) $18*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4
  to:main::@3
main::@3: scope:[main]  from main::@2_24
  [31] (byte) main::x#1 ← ++ (byte) main::x#4
  [32] if((byte) main::x#1!=(byte) $28) goto main::@1
  to:main::@return
main::@return: scope:[main]  from main::@3
  [33] return 
  to:@return


VARIABLE REGISTER WEIGHTS
(void()) main()
(byte*) main::SCREEN
(byte) main::line
(byte) main::x
(byte) main::x#1 16.5
(byte) main::x#4 22.00000000000001

Initial phi equivalence classes
[ main::x#4 main::x#1 ]
Complete equivalence classes
[ main::x#4 main::x#1 ]
Allocated zp ZP_BYTE:2 [ main::x#4 main::x#1 ]

INITIAL ASM
Target platform is c64basic
  // File Comments
// Fills the screen using an unrolled inner ranged for()-loop
  // Upstart
.pc = $801 "Basic"
:BasicUpstart(bbegin)
.pc = $80d "Program"
  // Global Constants & labels
  // @begin
bbegin:
  // [1] phi from @begin to @1 [phi:@begin->@1]
b1_from_bbegin:
  jmp b1
  // @1
b1:
  // [2] call main 
  // [4] phi from @1 to main [phi:@1->main]
main_from_b1:
  jsr main
  // [3] phi from @1 to @end [phi:@1->@end]
bend_from_b1:
  jmp bend
  // @end
bend:
  // main
main: {
    .label SCREEN = $400
    .label x = 2
    // [5] phi from main to main::@1 [phi:main->main::@1]
  b1_from_main:
    // [5] phi (byte) main::x#4 = (byte) 0 [phi:main->main::@1#0] -- vbuz1=vbuc1 
    lda #0
    sta.z x
    jmp b1
    // [5] phi from main::@3 to main::@1 [phi:main::@3->main::@1]
  b1_from_b3:
    // [5] phi (byte) main::x#4 = (byte) main::x#1 [phi:main::@3->main::@1#0] -- register_copy 
    jmp b1
    // main::@1
  b1:
    jmp b2
    // main::@2
  b2:
    // [6] *((const byte*) main::SCREEN#0 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuz1=vbuz1 
    ldy.z x
    tya
    sta SCREEN,y
    jmp b2_1
    // main::@2_1
  b2_1:
    // [7] *((const byte*) main::SCREEN#0+(byte) 1*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuz1=vbuz1 
    ldy.z x
    tya
    sta SCREEN+1*$28,y
    jmp b2_2
    // main::@2_2
  b2_2:
    // [8] *((const byte*) main::SCREEN#0+(byte) 2*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuz1=vbuz1 
    ldy.z x
    tya
    sta SCREEN+2*$28,y
    jmp b2_3
    // main::@2_3
  b2_3:
    // [9] *((const byte*) main::SCREEN#0+(byte) 3*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuz1=vbuz1 
    ldy.z x
    tya
    sta SCREEN+3*$28,y
    jmp b2_4
    // main::@2_4
  b2_4:
    // [10] *((const byte*) main::SCREEN#0+(byte) 4*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuz1=vbuz1 
    ldy.z x
    tya
    sta SCREEN+4*$28,y
    jmp b2_5
    // main::@2_5
  b2_5:
    // [11] *((const byte*) main::SCREEN#0+(byte) 5*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuz1=vbuz1 
    ldy.z x
    tya
    sta SCREEN+5*$28,y
    jmp b2_6
    // main::@2_6
  b2_6:
    // [12] *((const byte*) main::SCREEN#0+(byte) 6*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuz1=vbuz1 
    ldy.z x
    tya
    sta SCREEN+6*$28,y
    jmp b2_7
    // main::@2_7
  b2_7:
    // [13] *((const byte*) main::SCREEN#0+(byte) 7*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuz1=vbuz1 
    ldy.z x
    tya
    sta SCREEN+7*$28,y
    jmp b2_8
    // main::@2_8
  b2_8:
    // [14] *((const byte*) main::SCREEN#0+(byte) 8*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuz1=vbuz1 
    ldy.z x
    tya
    sta SCREEN+8*$28,y
    jmp b2_9
    // main::@2_9
  b2_9:
    // [15] *((const byte*) main::SCREEN#0+(byte) 9*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuz1=vbuz1 
    ldy.z x
    tya
    sta SCREEN+9*$28,y
    jmp b2_10
    // main::@2_10
  b2_10:
    // [16] *((const byte*) main::SCREEN#0+(byte) $a*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuz1=vbuz1 
    ldy.z x
    tya
    sta SCREEN+$a*$28,y
    jmp b2_11
    // main::@2_11
  b2_11:
    // [17] *((const byte*) main::SCREEN#0+(byte) $b*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuz1=vbuz1 
    ldy.z x
    tya
    sta SCREEN+$b*$28,y
    jmp b2_12
    // main::@2_12
  b2_12:
    // [18] *((const byte*) main::SCREEN#0+(byte) $c*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuz1=vbuz1 
    ldy.z x
    tya
    sta SCREEN+$c*$28,y
    jmp b2_13
    // main::@2_13
  b2_13:
    // [19] *((const byte*) main::SCREEN#0+(byte) $d*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuz1=vbuz1 
    ldy.z x
    tya
    sta SCREEN+$d*$28,y
    jmp b2_14
    // main::@2_14
  b2_14:
    // [20] *((const byte*) main::SCREEN#0+(byte) $e*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuz1=vbuz1 
    ldy.z x
    tya
    sta SCREEN+$e*$28,y
    jmp b2_15
    // main::@2_15
  b2_15:
    // [21] *((const byte*) main::SCREEN#0+(byte) $f*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuz1=vbuz1 
    ldy.z x
    tya
    sta SCREEN+$f*$28,y
    jmp b2_16
    // main::@2_16
  b2_16:
    // [22] *((const byte*) main::SCREEN#0+(byte) $10*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuz1=vbuz1 
    ldy.z x
    tya
    sta SCREEN+$10*$28,y
    jmp b2_17
    // main::@2_17
  b2_17:
    // [23] *((const byte*) main::SCREEN#0+(byte) $11*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuz1=vbuz1 
    ldy.z x
    tya
    sta SCREEN+$11*$28,y
    jmp b2_18
    // main::@2_18
  b2_18:
    // [24] *((const byte*) main::SCREEN#0+(byte) $12*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuz1=vbuz1 
    ldy.z x
    tya
    sta SCREEN+$12*$28,y
    jmp b2_19
    // main::@2_19
  b2_19:
    // [25] *((const byte*) main::SCREEN#0+(byte) $13*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuz1=vbuz1 
    ldy.z x
    tya
    sta SCREEN+$13*$28,y
    jmp b2_20
    // main::@2_20
  b2_20:
    // [26] *((const byte*) main::SCREEN#0+(byte) $14*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuz1=vbuz1 
    ldy.z x
    tya
    sta SCREEN+$14*$28,y
    jmp b2_21
    // main::@2_21
  b2_21:
    // [27] *((const byte*) main::SCREEN#0+(byte) $15*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuz1=vbuz1 
    ldy.z x
    tya
    sta SCREEN+$15*$28,y
    jmp b2_22
    // main::@2_22
  b2_22:
    // [28] *((const byte*) main::SCREEN#0+(byte) $16*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuz1=vbuz1 
    ldy.z x
    tya
    sta SCREEN+$16*$28,y
    jmp b2_23
    // main::@2_23
  b2_23:
    // [29] *((const byte*) main::SCREEN#0+(byte) $17*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuz1=vbuz1 
    ldy.z x
    tya
    sta SCREEN+$17*$28,y
    jmp b2_24
    // main::@2_24
  b2_24:
    // [30] *((const byte*) main::SCREEN#0+(byte) $18*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuz1=vbuz1 
    ldy.z x
    tya
    sta SCREEN+$18*$28,y
    jmp b3
    // main::@3
  b3:
    // [31] (byte) main::x#1 ← ++ (byte) main::x#4 -- vbuz1=_inc_vbuz1 
    inc.z x
    // [32] if((byte) main::x#1!=(byte) $28) goto main::@1 -- vbuz1_neq_vbuc1_then_la1 
    lda #$28
    cmp.z x
    bne b1_from_b3
    jmp breturn
    // main::@return
  breturn:
    // [33] return 
    rts
}
  // File Data

REGISTER UPLIFT POTENTIAL REGISTERS
Potential registers zp ZP_BYTE:2 [ main::x#4 main::x#1 ] : zp ZP_BYTE:2 , reg byte a , reg byte x , reg byte y , 

REGISTER UPLIFT SCOPES
Uplift Scope [main] 38.5: zp ZP_BYTE:2 [ main::x#4 main::x#1 ] 
Uplift Scope [] 

Uplifting [main] best 2723 combination reg byte x [ main::x#4 main::x#1 ] 
Uplifting [] best 2723 combination 

ASSEMBLER BEFORE OPTIMIZATION
  // File Comments
// Fills the screen using an unrolled inner ranged for()-loop
  // Upstart
.pc = $801 "Basic"
:BasicUpstart(bbegin)
.pc = $80d "Program"
  // Global Constants & labels
  // @begin
bbegin:
  // [1] phi from @begin to @1 [phi:@begin->@1]
b1_from_bbegin:
  jmp b1
  // @1
b1:
  // [2] call main 
  // [4] phi from @1 to main [phi:@1->main]
main_from_b1:
  jsr main
  // [3] phi from @1 to @end [phi:@1->@end]
bend_from_b1:
  jmp bend
  // @end
bend:
  // main
main: {
    .label SCREEN = $400
    // [5] phi from main to main::@1 [phi:main->main::@1]
  b1_from_main:
    // [5] phi (byte) main::x#4 = (byte) 0 [phi:main->main::@1#0] -- vbuxx=vbuc1 
    ldx #0
    jmp b1
    // [5] phi from main::@3 to main::@1 [phi:main::@3->main::@1]
  b1_from_b3:
    // [5] phi (byte) main::x#4 = (byte) main::x#1 [phi:main::@3->main::@1#0] -- register_copy 
    jmp b1
    // main::@1
  b1:
    jmp b2
    // main::@2
  b2:
    // [6] *((const byte*) main::SCREEN#0 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN,x
    jmp b2_1
    // main::@2_1
  b2_1:
    // [7] *((const byte*) main::SCREEN#0+(byte) 1*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+1*$28,x
    jmp b2_2
    // main::@2_2
  b2_2:
    // [8] *((const byte*) main::SCREEN#0+(byte) 2*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+2*$28,x
    jmp b2_3
    // main::@2_3
  b2_3:
    // [9] *((const byte*) main::SCREEN#0+(byte) 3*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+3*$28,x
    jmp b2_4
    // main::@2_4
  b2_4:
    // [10] *((const byte*) main::SCREEN#0+(byte) 4*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+4*$28,x
    jmp b2_5
    // main::@2_5
  b2_5:
    // [11] *((const byte*) main::SCREEN#0+(byte) 5*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+5*$28,x
    jmp b2_6
    // main::@2_6
  b2_6:
    // [12] *((const byte*) main::SCREEN#0+(byte) 6*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+6*$28,x
    jmp b2_7
    // main::@2_7
  b2_7:
    // [13] *((const byte*) main::SCREEN#0+(byte) 7*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+7*$28,x
    jmp b2_8
    // main::@2_8
  b2_8:
    // [14] *((const byte*) main::SCREEN#0+(byte) 8*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+8*$28,x
    jmp b2_9
    // main::@2_9
  b2_9:
    // [15] *((const byte*) main::SCREEN#0+(byte) 9*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+9*$28,x
    jmp b2_10
    // main::@2_10
  b2_10:
    // [16] *((const byte*) main::SCREEN#0+(byte) $a*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+$a*$28,x
    jmp b2_11
    // main::@2_11
  b2_11:
    // [17] *((const byte*) main::SCREEN#0+(byte) $b*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+$b*$28,x
    jmp b2_12
    // main::@2_12
  b2_12:
    // [18] *((const byte*) main::SCREEN#0+(byte) $c*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+$c*$28,x
    jmp b2_13
    // main::@2_13
  b2_13:
    // [19] *((const byte*) main::SCREEN#0+(byte) $d*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+$d*$28,x
    jmp b2_14
    // main::@2_14
  b2_14:
    // [20] *((const byte*) main::SCREEN#0+(byte) $e*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+$e*$28,x
    jmp b2_15
    // main::@2_15
  b2_15:
    // [21] *((const byte*) main::SCREEN#0+(byte) $f*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+$f*$28,x
    jmp b2_16
    // main::@2_16
  b2_16:
    // [22] *((const byte*) main::SCREEN#0+(byte) $10*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+$10*$28,x
    jmp b2_17
    // main::@2_17
  b2_17:
    // [23] *((const byte*) main::SCREEN#0+(byte) $11*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+$11*$28,x
    jmp b2_18
    // main::@2_18
  b2_18:
    // [24] *((const byte*) main::SCREEN#0+(byte) $12*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+$12*$28,x
    jmp b2_19
    // main::@2_19
  b2_19:
    // [25] *((const byte*) main::SCREEN#0+(byte) $13*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+$13*$28,x
    jmp b2_20
    // main::@2_20
  b2_20:
    // [26] *((const byte*) main::SCREEN#0+(byte) $14*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+$14*$28,x
    jmp b2_21
    // main::@2_21
  b2_21:
    // [27] *((const byte*) main::SCREEN#0+(byte) $15*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+$15*$28,x
    jmp b2_22
    // main::@2_22
  b2_22:
    // [28] *((const byte*) main::SCREEN#0+(byte) $16*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+$16*$28,x
    jmp b2_23
    // main::@2_23
  b2_23:
    // [29] *((const byte*) main::SCREEN#0+(byte) $17*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+$17*$28,x
    jmp b2_24
    // main::@2_24
  b2_24:
    // [30] *((const byte*) main::SCREEN#0+(byte) $18*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+$18*$28,x
    jmp b3
    // main::@3
  b3:
    // [31] (byte) main::x#1 ← ++ (byte) main::x#4 -- vbuxx=_inc_vbuxx 
    inx
    // [32] if((byte) main::x#1!=(byte) $28) goto main::@1 -- vbuxx_neq_vbuc1_then_la1 
    cpx #$28
    bne b1_from_b3
    jmp breturn
    // main::@return
  breturn:
    // [33] return 
    rts
}
  // File Data

ASSEMBLER OPTIMIZATIONS
Removing instruction jmp b1
Removing instruction jmp bend
Removing instruction jmp b1
Removing instruction jmp b2
Removing instruction jmp b2_1
Removing instruction jmp b2_2
Removing instruction jmp b2_3
Removing instruction jmp b2_4
Removing instruction jmp b2_5
Removing instruction jmp b2_6
Removing instruction jmp b2_7
Removing instruction jmp b2_8
Removing instruction jmp b2_9
Removing instruction jmp b2_10
Removing instruction jmp b2_11
Removing instruction jmp b2_12
Removing instruction jmp b2_13
Removing instruction jmp b2_14
Removing instruction jmp b2_15
Removing instruction jmp b2_16
Removing instruction jmp b2_17
Removing instruction jmp b2_18
Removing instruction jmp b2_19
Removing instruction jmp b2_20
Removing instruction jmp b2_21
Removing instruction jmp b2_22
Removing instruction jmp b2_23
Removing instruction jmp b2_24
Removing instruction jmp b3
Removing instruction jmp breturn
Succesful ASM optimization Pass5NextJumpElimination
Replacing label b1 with b2
Replacing label b1_from_b3 with b2
Removing instruction b1_from_bbegin:
Removing instruction b1:
Removing instruction main_from_b1:
Removing instruction bend_from_b1:
Removing instruction b1_from_b3:
Removing instruction b1:
Succesful ASM optimization Pass5RedundantLabelElimination
Removing instruction bend:
Removing instruction b1_from_main:
Removing instruction b2_1:
Removing instruction b2_2:
Removing instruction b2_3:
Removing instruction b2_4:
Removing instruction b2_5:
Removing instruction b2_6:
Removing instruction b2_7:
Removing instruction b2_8:
Removing instruction b2_9:
Removing instruction b2_10:
Removing instruction b2_11:
Removing instruction b2_12:
Removing instruction b2_13:
Removing instruction b2_14:
Removing instruction b2_15:
Removing instruction b2_16:
Removing instruction b2_17:
Removing instruction b2_18:
Removing instruction b2_19:
Removing instruction b2_20:
Removing instruction b2_21:
Removing instruction b2_22:
Removing instruction b2_23:
Removing instruction b2_24:
Removing instruction b3:
Removing instruction breturn:
Succesful ASM optimization Pass5UnusedLabelElimination
Updating BasicUpstart to call main directly
Removing instruction jsr main
Succesful ASM optimization Pass5SkipBegin
Removing instruction jmp b2
Succesful ASM optimization Pass5NextJumpElimination
Removing instruction bbegin:
Succesful ASM optimization Pass5UnusedLabelElimination

FINAL SYMBOL TABLE
(label) @1
(label) @begin
(label) @end
(void()) main()
(label) main::@1
(label) main::@2
(label) main::@2_1
(label) main::@2_10
(label) main::@2_11
(label) main::@2_12
(label) main::@2_13
(label) main::@2_14
(label) main::@2_15
(label) main::@2_16
(label) main::@2_17
(label) main::@2_18
(label) main::@2_19
(label) main::@2_2
(label) main::@2_20
(label) main::@2_21
(label) main::@2_22
(label) main::@2_23
(label) main::@2_24
(label) main::@2_3
(label) main::@2_4
(label) main::@2_5
(label) main::@2_6
(label) main::@2_7
(label) main::@2_8
(label) main::@2_9
(label) main::@3
(label) main::@return
(byte*) main::SCREEN
(const byte*) main::SCREEN#0 SCREEN = (byte*) 1024
(byte) main::line
(byte) main::x
(byte) main::x#1 reg byte x 16.5
(byte) main::x#4 reg byte x 22.00000000000001

reg byte x [ main::x#4 main::x#1 ]


FINAL ASSEMBLER
Score: 1841

  // File Comments
// Fills the screen using an unrolled inner ranged for()-loop
  // Upstart
.pc = $801 "Basic"
:BasicUpstart(main)
.pc = $80d "Program"
  // Global Constants & labels
  // @begin
  // [1] phi from @begin to @1 [phi:@begin->@1]
  // @1
  // [2] call main 
  // [4] phi from @1 to main [phi:@1->main]
  // [3] phi from @1 to @end [phi:@1->@end]
  // @end
  // main
main: {
    .label SCREEN = $400
    // [5] phi from main to main::@1 [phi:main->main::@1]
    // [5] phi (byte) main::x#4 = (byte) 0 [phi:main->main::@1#0] -- vbuxx=vbuc1 
    ldx #0
    // [5] phi from main::@3 to main::@1 [phi:main::@3->main::@1]
    // [5] phi (byte) main::x#4 = (byte) main::x#1 [phi:main::@3->main::@1#0] -- register_copy 
    // main::@1
    // main::@2
  b2:
    // (SCREEN+line*40)[x] = x
    // [6] *((const byte*) main::SCREEN#0 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN,x
    // main::@2_1
    // [7] *((const byte*) main::SCREEN#0+(byte) 1*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+1*$28,x
    // main::@2_2
    // [8] *((const byte*) main::SCREEN#0+(byte) 2*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+2*$28,x
    // main::@2_3
    // [9] *((const byte*) main::SCREEN#0+(byte) 3*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+3*$28,x
    // main::@2_4
    // [10] *((const byte*) main::SCREEN#0+(byte) 4*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+4*$28,x
    // main::@2_5
    // [11] *((const byte*) main::SCREEN#0+(byte) 5*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+5*$28,x
    // main::@2_6
    // [12] *((const byte*) main::SCREEN#0+(byte) 6*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+6*$28,x
    // main::@2_7
    // [13] *((const byte*) main::SCREEN#0+(byte) 7*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+7*$28,x
    // main::@2_8
    // [14] *((const byte*) main::SCREEN#0+(byte) 8*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+8*$28,x
    // main::@2_9
    // [15] *((const byte*) main::SCREEN#0+(byte) 9*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+9*$28,x
    // main::@2_10
    // [16] *((const byte*) main::SCREEN#0+(byte) $a*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+$a*$28,x
    // main::@2_11
    // [17] *((const byte*) main::SCREEN#0+(byte) $b*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+$b*$28,x
    // main::@2_12
    // [18] *((const byte*) main::SCREEN#0+(byte) $c*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+$c*$28,x
    // main::@2_13
    // [19] *((const byte*) main::SCREEN#0+(byte) $d*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+$d*$28,x
    // main::@2_14
    // [20] *((const byte*) main::SCREEN#0+(byte) $e*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+$e*$28,x
    // main::@2_15
    // [21] *((const byte*) main::SCREEN#0+(byte) $f*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+$f*$28,x
    // main::@2_16
    // [22] *((const byte*) main::SCREEN#0+(byte) $10*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+$10*$28,x
    // main::@2_17
    // [23] *((const byte*) main::SCREEN#0+(byte) $11*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+$11*$28,x
    // main::@2_18
    // [24] *((const byte*) main::SCREEN#0+(byte) $12*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+$12*$28,x
    // main::@2_19
    // [25] *((const byte*) main::SCREEN#0+(byte) $13*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+$13*$28,x
    // main::@2_20
    // [26] *((const byte*) main::SCREEN#0+(byte) $14*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+$14*$28,x
    // main::@2_21
    // [27] *((const byte*) main::SCREEN#0+(byte) $15*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+$15*$28,x
    // main::@2_22
    // [28] *((const byte*) main::SCREEN#0+(byte) $16*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+$16*$28,x
    // main::@2_23
    // [29] *((const byte*) main::SCREEN#0+(byte) $17*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+$17*$28,x
    // main::@2_24
    // [30] *((const byte*) main::SCREEN#0+(byte) $18*(byte) $28 + (byte) main::x#4) ← (byte) main::x#4 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+$18*$28,x
    // main::@3
    // for(byte x: 0..39)
    // [31] (byte) main::x#1 ← ++ (byte) main::x#4 -- vbuxx=_inc_vbuxx 
    inx
    // [32] if((byte) main::x#1!=(byte) $28) goto main::@1 -- vbuxx_neq_vbuc1_then_la1 
    cpx #$28
    bne b2
    // main::@return
    // }
    // [33] return 
    rts
}
  // File Data

