Identified constant variable (byte*) main::SCREEN
Culled Empty Block (label) main::@5
Culled Empty Block (label) main::@6
Culled Empty Block (label) main::@7
Culled Empty Block (label) main::@8

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::@4
  (byte) main::x#5 ← phi( main/(byte) main::x#0 main::@4/(byte) main::x#1 )
  (byte) main::line#0 ← (number) 0
  to:main::@2
main::@2: scope:[main]  from main::@1 main::@3
  (byte) main::x#4 ← phi( main::@1/(byte) main::x#5 main::@3/(byte) main::x#2 )
  (byte) main::line#2 ← phi( main::@1/(byte) main::line#0 main::@3/(byte) main::line#1 )
  (bool~) main::$0 ← (byte) main::line#2 != (number) $19
  unroll if((bool~) main::$0) goto main::@3
  to:main::@4
main::@3: scope:[main]  from main::@2
  (byte) main::x#2 ← phi( main::@2/(byte) main::x#4 )
  (byte) main::line#3 ← phi( main::@2/(byte) main::line#2 )
  (number~) main::$1 ← (byte) main::line#3 * (number) $28
  (byte*~) main::$2 ← (byte*) main::SCREEN#0 + (number~) main::$1
  *((byte*~) main::$2 + (byte) main::x#2) ← (byte) main::x#2
  (byte) main::line#1 ← ++ (byte) main::line#3
  to:main::@2
main::@4: scope:[main]  from main::@2
  (byte) main::x#3 ← phi( main::@2/(byte) main::x#4 )
  (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::@4
  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()
(bool~) main::$0
(number~) main::$1
(byte*~) main::$2
(bool~) main::$3
(label) main::@1
(label) main::@2
(label) main::@3
(label) main::@4
(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::line#3
(byte) main::x
(byte) main::x#0
(byte) main::x#1
(byte) main::x#2
(byte) main::x#3
(byte) main::x#4
(byte) main::x#5

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

Created 1 initial phi equivalence classes
Coalesced [61] main::x#6 ← main::x#1
Coalesced down to 1 phi equivalence classes
Culled Empty Block (label) @2
Culled Empty Block (label) main::@2_1
Culled Empty Block (label) main::@2
Culled Empty Block (label) main::@2_2
Culled Empty Block (label) main::@2_3
Culled Empty Block (label) main::@2_4
Culled Empty Block (label) main::@2_5
Culled Empty Block (label) main::@2_6
Culled Empty Block (label) main::@2_7
Culled Empty Block (label) main::@2_8
Culled Empty Block (label) main::@2_9
Culled Empty Block (label) main::@2_10
Culled Empty Block (label) main::@2_11
Culled Empty Block (label) main::@2_12
Culled Empty Block (label) main::@2_13
Culled Empty Block (label) main::@2_14
Culled Empty Block (label) main::@2_15
Culled Empty Block (label) main::@2_16
Culled Empty Block (label) main::@2_17
Culled Empty Block (label) main::@2_18
Culled Empty Block (label) main::@2_19
Culled Empty Block (label) main::@2_20
Culled Empty Block (label) main::@2_21
Culled Empty Block (label) main::@2_22
Culled Empty Block (label) main::@2_23
Culled Empty Block (label) main::@2_24
Culled Empty Block (label) main::@2_25
Culled Empty Block (label) main::@9
Renumbering block main::@3 to main::@2
Renumbering block main::@4 to main::@3
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#5 ← 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#5) ← (byte) main::x#5
  to:main::@3_1
main::@3_1: scope:[main]  from main::@2
  [7] *((const byte*) main::SCREEN#0+(byte) 1*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5
  to:main::@3_2
main::@3_2: scope:[main]  from main::@3_1
  [8] *((const byte*) main::SCREEN#0+(byte) 2*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5
  to:main::@3_3
main::@3_3: scope:[main]  from main::@3_2
  [9] *((const byte*) main::SCREEN#0+(byte) 3*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5
  to:main::@3_4
main::@3_4: scope:[main]  from main::@3_3
  [10] *((const byte*) main::SCREEN#0+(byte) 4*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5
  to:main::@3_5
main::@3_5: scope:[main]  from main::@3_4
  [11] *((const byte*) main::SCREEN#0+(byte) 5*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5
  to:main::@3_6
main::@3_6: scope:[main]  from main::@3_5
  [12] *((const byte*) main::SCREEN#0+(byte) 6*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5
  to:main::@3_7
main::@3_7: scope:[main]  from main::@3_6
  [13] *((const byte*) main::SCREEN#0+(byte) 7*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5
  to:main::@3_8
main::@3_8: scope:[main]  from main::@3_7
  [14] *((const byte*) main::SCREEN#0+(byte) 8*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5
  to:main::@3_9
main::@3_9: scope:[main]  from main::@3_8
  [15] *((const byte*) main::SCREEN#0+(byte) 9*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5
  to:main::@3_10
main::@3_10: scope:[main]  from main::@3_9
  [16] *((const byte*) main::SCREEN#0+(byte) $a*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5
  to:main::@3_11
main::@3_11: scope:[main]  from main::@3_10
  [17] *((const byte*) main::SCREEN#0+(byte) $b*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5
  to:main::@3_12
main::@3_12: scope:[main]  from main::@3_11
  [18] *((const byte*) main::SCREEN#0+(byte) $c*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5
  to:main::@3_13
main::@3_13: scope:[main]  from main::@3_12
  [19] *((const byte*) main::SCREEN#0+(byte) $d*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5
  to:main::@3_14
main::@3_14: scope:[main]  from main::@3_13
  [20] *((const byte*) main::SCREEN#0+(byte) $e*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5
  to:main::@3_15
main::@3_15: scope:[main]  from main::@3_14
  [21] *((const byte*) main::SCREEN#0+(byte) $f*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5
  to:main::@3_16
main::@3_16: scope:[main]  from main::@3_15
  [22] *((const byte*) main::SCREEN#0+(byte) $10*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5
  to:main::@3_17
main::@3_17: scope:[main]  from main::@3_16
  [23] *((const byte*) main::SCREEN#0+(byte) $11*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5
  to:main::@3_18
main::@3_18: scope:[main]  from main::@3_17
  [24] *((const byte*) main::SCREEN#0+(byte) $12*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5
  to:main::@3_19
main::@3_19: scope:[main]  from main::@3_18
  [25] *((const byte*) main::SCREEN#0+(byte) $13*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5
  to:main::@3_20
main::@3_20: scope:[main]  from main::@3_19
  [26] *((const byte*) main::SCREEN#0+(byte) $14*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5
  to:main::@3_21
main::@3_21: scope:[main]  from main::@3_20
  [27] *((const byte*) main::SCREEN#0+(byte) $15*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5
  to:main::@3_22
main::@3_22: scope:[main]  from main::@3_21
  [28] *((const byte*) main::SCREEN#0+(byte) $16*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5
  to:main::@3_23
main::@3_23: scope:[main]  from main::@3_22
  [29] *((const byte*) main::SCREEN#0+(byte) $17*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5
  to:main::@3_24
main::@3_24: scope:[main]  from main::@3_23
  [30] *((const byte*) main::SCREEN#0+(byte) $18*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5
  to:main::@3
main::@3: scope:[main]  from main::@3_24
  [31] (byte) main::x#1 ← ++ (byte) main::x#5
  [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#5 22.00000000000001

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

INITIAL ASM
Target platform is c64basic
  // File Comments
// Fills the screen using an unrolled inner while()-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#5 = (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#5 = (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#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuz1=vbuz1 
    ldy.z x
    tya
    sta SCREEN,y
    jmp b3_1
    // main::@3_1
  b3_1:
    // [7] *((const byte*) main::SCREEN#0+(byte) 1*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuz1=vbuz1 
    ldy.z x
    tya
    sta SCREEN+1*$28,y
    jmp b3_2
    // main::@3_2
  b3_2:
    // [8] *((const byte*) main::SCREEN#0+(byte) 2*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuz1=vbuz1 
    ldy.z x
    tya
    sta SCREEN+2*$28,y
    jmp b3_3
    // main::@3_3
  b3_3:
    // [9] *((const byte*) main::SCREEN#0+(byte) 3*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuz1=vbuz1 
    ldy.z x
    tya
    sta SCREEN+3*$28,y
    jmp b3_4
    // main::@3_4
  b3_4:
    // [10] *((const byte*) main::SCREEN#0+(byte) 4*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuz1=vbuz1 
    ldy.z x
    tya
    sta SCREEN+4*$28,y
    jmp b3_5
    // main::@3_5
  b3_5:
    // [11] *((const byte*) main::SCREEN#0+(byte) 5*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuz1=vbuz1 
    ldy.z x
    tya
    sta SCREEN+5*$28,y
    jmp b3_6
    // main::@3_6
  b3_6:
    // [12] *((const byte*) main::SCREEN#0+(byte) 6*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuz1=vbuz1 
    ldy.z x
    tya
    sta SCREEN+6*$28,y
    jmp b3_7
    // main::@3_7
  b3_7:
    // [13] *((const byte*) main::SCREEN#0+(byte) 7*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuz1=vbuz1 
    ldy.z x
    tya
    sta SCREEN+7*$28,y
    jmp b3_8
    // main::@3_8
  b3_8:
    // [14] *((const byte*) main::SCREEN#0+(byte) 8*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuz1=vbuz1 
    ldy.z x
    tya
    sta SCREEN+8*$28,y
    jmp b3_9
    // main::@3_9
  b3_9:
    // [15] *((const byte*) main::SCREEN#0+(byte) 9*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuz1=vbuz1 
    ldy.z x
    tya
    sta SCREEN+9*$28,y
    jmp b3_10
    // main::@3_10
  b3_10:
    // [16] *((const byte*) main::SCREEN#0+(byte) $a*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuz1=vbuz1 
    ldy.z x
    tya
    sta SCREEN+$a*$28,y
    jmp b3_11
    // main::@3_11
  b3_11:
    // [17] *((const byte*) main::SCREEN#0+(byte) $b*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuz1=vbuz1 
    ldy.z x
    tya
    sta SCREEN+$b*$28,y
    jmp b3_12
    // main::@3_12
  b3_12:
    // [18] *((const byte*) main::SCREEN#0+(byte) $c*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuz1=vbuz1 
    ldy.z x
    tya
    sta SCREEN+$c*$28,y
    jmp b3_13
    // main::@3_13
  b3_13:
    // [19] *((const byte*) main::SCREEN#0+(byte) $d*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuz1=vbuz1 
    ldy.z x
    tya
    sta SCREEN+$d*$28,y
    jmp b3_14
    // main::@3_14
  b3_14:
    // [20] *((const byte*) main::SCREEN#0+(byte) $e*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuz1=vbuz1 
    ldy.z x
    tya
    sta SCREEN+$e*$28,y
    jmp b3_15
    // main::@3_15
  b3_15:
    // [21] *((const byte*) main::SCREEN#0+(byte) $f*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuz1=vbuz1 
    ldy.z x
    tya
    sta SCREEN+$f*$28,y
    jmp b3_16
    // main::@3_16
  b3_16:
    // [22] *((const byte*) main::SCREEN#0+(byte) $10*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuz1=vbuz1 
    ldy.z x
    tya
    sta SCREEN+$10*$28,y
    jmp b3_17
    // main::@3_17
  b3_17:
    // [23] *((const byte*) main::SCREEN#0+(byte) $11*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuz1=vbuz1 
    ldy.z x
    tya
    sta SCREEN+$11*$28,y
    jmp b3_18
    // main::@3_18
  b3_18:
    // [24] *((const byte*) main::SCREEN#0+(byte) $12*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuz1=vbuz1 
    ldy.z x
    tya
    sta SCREEN+$12*$28,y
    jmp b3_19
    // main::@3_19
  b3_19:
    // [25] *((const byte*) main::SCREEN#0+(byte) $13*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuz1=vbuz1 
    ldy.z x
    tya
    sta SCREEN+$13*$28,y
    jmp b3_20
    // main::@3_20
  b3_20:
    // [26] *((const byte*) main::SCREEN#0+(byte) $14*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuz1=vbuz1 
    ldy.z x
    tya
    sta SCREEN+$14*$28,y
    jmp b3_21
    // main::@3_21
  b3_21:
    // [27] *((const byte*) main::SCREEN#0+(byte) $15*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuz1=vbuz1 
    ldy.z x
    tya
    sta SCREEN+$15*$28,y
    jmp b3_22
    // main::@3_22
  b3_22:
    // [28] *((const byte*) main::SCREEN#0+(byte) $16*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuz1=vbuz1 
    ldy.z x
    tya
    sta SCREEN+$16*$28,y
    jmp b3_23
    // main::@3_23
  b3_23:
    // [29] *((const byte*) main::SCREEN#0+(byte) $17*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuz1=vbuz1 
    ldy.z x
    tya
    sta SCREEN+$17*$28,y
    jmp b3_24
    // main::@3_24
  b3_24:
    // [30] *((const byte*) main::SCREEN#0+(byte) $18*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- 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#5 -- 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#5 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#5 main::x#1 ] 
Uplift Scope [] 

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

ASSEMBLER BEFORE OPTIMIZATION
  // File Comments
// Fills the screen using an unrolled inner while()-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#5 = (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#5 = (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#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN,x
    jmp b3_1
    // main::@3_1
  b3_1:
    // [7] *((const byte*) main::SCREEN#0+(byte) 1*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+1*$28,x
    jmp b3_2
    // main::@3_2
  b3_2:
    // [8] *((const byte*) main::SCREEN#0+(byte) 2*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+2*$28,x
    jmp b3_3
    // main::@3_3
  b3_3:
    // [9] *((const byte*) main::SCREEN#0+(byte) 3*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+3*$28,x
    jmp b3_4
    // main::@3_4
  b3_4:
    // [10] *((const byte*) main::SCREEN#0+(byte) 4*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+4*$28,x
    jmp b3_5
    // main::@3_5
  b3_5:
    // [11] *((const byte*) main::SCREEN#0+(byte) 5*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+5*$28,x
    jmp b3_6
    // main::@3_6
  b3_6:
    // [12] *((const byte*) main::SCREEN#0+(byte) 6*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+6*$28,x
    jmp b3_7
    // main::@3_7
  b3_7:
    // [13] *((const byte*) main::SCREEN#0+(byte) 7*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+7*$28,x
    jmp b3_8
    // main::@3_8
  b3_8:
    // [14] *((const byte*) main::SCREEN#0+(byte) 8*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+8*$28,x
    jmp b3_9
    // main::@3_9
  b3_9:
    // [15] *((const byte*) main::SCREEN#0+(byte) 9*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+9*$28,x
    jmp b3_10
    // main::@3_10
  b3_10:
    // [16] *((const byte*) main::SCREEN#0+(byte) $a*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+$a*$28,x
    jmp b3_11
    // main::@3_11
  b3_11:
    // [17] *((const byte*) main::SCREEN#0+(byte) $b*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+$b*$28,x
    jmp b3_12
    // main::@3_12
  b3_12:
    // [18] *((const byte*) main::SCREEN#0+(byte) $c*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+$c*$28,x
    jmp b3_13
    // main::@3_13
  b3_13:
    // [19] *((const byte*) main::SCREEN#0+(byte) $d*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+$d*$28,x
    jmp b3_14
    // main::@3_14
  b3_14:
    // [20] *((const byte*) main::SCREEN#0+(byte) $e*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+$e*$28,x
    jmp b3_15
    // main::@3_15
  b3_15:
    // [21] *((const byte*) main::SCREEN#0+(byte) $f*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+$f*$28,x
    jmp b3_16
    // main::@3_16
  b3_16:
    // [22] *((const byte*) main::SCREEN#0+(byte) $10*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+$10*$28,x
    jmp b3_17
    // main::@3_17
  b3_17:
    // [23] *((const byte*) main::SCREEN#0+(byte) $11*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+$11*$28,x
    jmp b3_18
    // main::@3_18
  b3_18:
    // [24] *((const byte*) main::SCREEN#0+(byte) $12*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+$12*$28,x
    jmp b3_19
    // main::@3_19
  b3_19:
    // [25] *((const byte*) main::SCREEN#0+(byte) $13*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+$13*$28,x
    jmp b3_20
    // main::@3_20
  b3_20:
    // [26] *((const byte*) main::SCREEN#0+(byte) $14*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+$14*$28,x
    jmp b3_21
    // main::@3_21
  b3_21:
    // [27] *((const byte*) main::SCREEN#0+(byte) $15*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+$15*$28,x
    jmp b3_22
    // main::@3_22
  b3_22:
    // [28] *((const byte*) main::SCREEN#0+(byte) $16*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+$16*$28,x
    jmp b3_23
    // main::@3_23
  b3_23:
    // [29] *((const byte*) main::SCREEN#0+(byte) $17*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+$17*$28,x
    jmp b3_24
    // main::@3_24
  b3_24:
    // [30] *((const byte*) main::SCREEN#0+(byte) $18*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+$18*$28,x
    jmp b3
    // main::@3
  b3:
    // [31] (byte) main::x#1 ← ++ (byte) main::x#5 -- 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 b3_1
Removing instruction jmp b3_2
Removing instruction jmp b3_3
Removing instruction jmp b3_4
Removing instruction jmp b3_5
Removing instruction jmp b3_6
Removing instruction jmp b3_7
Removing instruction jmp b3_8
Removing instruction jmp b3_9
Removing instruction jmp b3_10
Removing instruction jmp b3_11
Removing instruction jmp b3_12
Removing instruction jmp b3_13
Removing instruction jmp b3_14
Removing instruction jmp b3_15
Removing instruction jmp b3_16
Removing instruction jmp b3_17
Removing instruction jmp b3_18
Removing instruction jmp b3_19
Removing instruction jmp b3_20
Removing instruction jmp b3_21
Removing instruction jmp b3_22
Removing instruction jmp b3_23
Removing instruction jmp b3_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 b3_1:
Removing instruction b3_2:
Removing instruction b3_3:
Removing instruction b3_4:
Removing instruction b3_5:
Removing instruction b3_6:
Removing instruction b3_7:
Removing instruction b3_8:
Removing instruction b3_9:
Removing instruction b3_10:
Removing instruction b3_11:
Removing instruction b3_12:
Removing instruction b3_13:
Removing instruction b3_14:
Removing instruction b3_15:
Removing instruction b3_16:
Removing instruction b3_17:
Removing instruction b3_18:
Removing instruction b3_19:
Removing instruction b3_20:
Removing instruction b3_21:
Removing instruction b3_22:
Removing instruction b3_23:
Removing instruction b3_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::@3
(label) main::@3_1
(label) main::@3_10
(label) main::@3_11
(label) main::@3_12
(label) main::@3_13
(label) main::@3_14
(label) main::@3_15
(label) main::@3_16
(label) main::@3_17
(label) main::@3_18
(label) main::@3_19
(label) main::@3_2
(label) main::@3_20
(label) main::@3_21
(label) main::@3_22
(label) main::@3_23
(label) main::@3_24
(label) main::@3_3
(label) main::@3_4
(label) main::@3_5
(label) main::@3_6
(label) main::@3_7
(label) main::@3_8
(label) main::@3_9
(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#5 reg byte x 22.00000000000001

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


FINAL ASSEMBLER
Score: 1841

  // File Comments
// Fills the screen using an unrolled inner while()-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#5 = (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#5 = (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#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN,x
    // main::@3_1
    // [7] *((const byte*) main::SCREEN#0+(byte) 1*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+1*$28,x
    // main::@3_2
    // [8] *((const byte*) main::SCREEN#0+(byte) 2*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+2*$28,x
    // main::@3_3
    // [9] *((const byte*) main::SCREEN#0+(byte) 3*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+3*$28,x
    // main::@3_4
    // [10] *((const byte*) main::SCREEN#0+(byte) 4*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+4*$28,x
    // main::@3_5
    // [11] *((const byte*) main::SCREEN#0+(byte) 5*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+5*$28,x
    // main::@3_6
    // [12] *((const byte*) main::SCREEN#0+(byte) 6*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+6*$28,x
    // main::@3_7
    // [13] *((const byte*) main::SCREEN#0+(byte) 7*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+7*$28,x
    // main::@3_8
    // [14] *((const byte*) main::SCREEN#0+(byte) 8*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+8*$28,x
    // main::@3_9
    // [15] *((const byte*) main::SCREEN#0+(byte) 9*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+9*$28,x
    // main::@3_10
    // [16] *((const byte*) main::SCREEN#0+(byte) $a*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+$a*$28,x
    // main::@3_11
    // [17] *((const byte*) main::SCREEN#0+(byte) $b*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+$b*$28,x
    // main::@3_12
    // [18] *((const byte*) main::SCREEN#0+(byte) $c*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+$c*$28,x
    // main::@3_13
    // [19] *((const byte*) main::SCREEN#0+(byte) $d*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+$d*$28,x
    // main::@3_14
    // [20] *((const byte*) main::SCREEN#0+(byte) $e*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+$e*$28,x
    // main::@3_15
    // [21] *((const byte*) main::SCREEN#0+(byte) $f*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+$f*$28,x
    // main::@3_16
    // [22] *((const byte*) main::SCREEN#0+(byte) $10*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+$10*$28,x
    // main::@3_17
    // [23] *((const byte*) main::SCREEN#0+(byte) $11*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+$11*$28,x
    // main::@3_18
    // [24] *((const byte*) main::SCREEN#0+(byte) $12*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+$12*$28,x
    // main::@3_19
    // [25] *((const byte*) main::SCREEN#0+(byte) $13*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+$13*$28,x
    // main::@3_20
    // [26] *((const byte*) main::SCREEN#0+(byte) $14*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+$14*$28,x
    // main::@3_21
    // [27] *((const byte*) main::SCREEN#0+(byte) $15*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+$15*$28,x
    // main::@3_22
    // [28] *((const byte*) main::SCREEN#0+(byte) $16*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+$16*$28,x
    // main::@3_23
    // [29] *((const byte*) main::SCREEN#0+(byte) $17*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- pbuc1_derefidx_vbuxx=vbuxx 
    txa
    sta SCREEN+$17*$28,x
    // main::@3_24
    // [30] *((const byte*) main::SCREEN#0+(byte) $18*(byte) $28 + (byte) main::x#5) ← (byte) main::x#5 -- 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#5 -- 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

