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,$a)
  (bool~) main::$2 ← (byte) main::line#1 != rangelast(0,$a)
  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,$a)
  (bool~) main::$3 ← (byte) main::x#1 != rangelast(0,$a)
  unroll 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
Self Phi Eliminated (byte) main::x#2
Successful SSA optimization Pass2SelfPhiElimination
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,$a)) goto main::@2
Simple Condition (bool~) main::$3 [14] unroll if((byte) main::x#1!=rangelast(0,$a)) 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,$a)) goto main::@2 to (number) $b
Resolved ranged next value [12] main::x#1 ← ++ main::x#4 to ++
Resolved ranged comparison value [14] unroll if(main::x#1!=rangelast(0,$a)) goto main::@1 to (number) $b
Adding number conversion cast (unumber) $b in unroll if((byte) main::line#1!=(number) $b) goto main::@2
Adding number conversion cast (unumber) $b in unroll if((byte) main::x#1!=(number) $b) goto main::@1
Successful SSA optimization PassNAddNumberTypeConversions
Simplifying constant integer cast $b
Simplifying constant integer cast $b
Successful SSA optimization PassNCastSimplification
Finalized unsigned number type (byte) $b
Finalized unsigned number type (byte) $b
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) $b) 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) $b) 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) $b) 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) $b) 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) $b) 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) $b) 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) $b) 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) $b) 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) $b) 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) $b) 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) $b) 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) $b) 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) $b) 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) $b) 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) $b) 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) $b) 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) $b) 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) $b) 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) $b) 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) $b) 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) $b) 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
Removing PHI-reference to removed block (main::@2_10) in block main::@2_11
if() condition always true - replacing block destination [17] if((const byte) main::line#22==(byte) $b) goto main::@3
Successful SSA optimization Pass2ConstantIfs
Eliminating unused constant (const byte) main::line#22
Successful SSA optimization PassNEliminateUnusedVars
Eliminating variable (byte) main::line#23 from unused block main::@2_11
Eliminating variable (byte~) main::$24 from unused block main::@2_11
Eliminating variable (byte*~) main::$25 from unused block main::@2_11
Eliminating variable (byte) main::line#24 from unused block main::@2_11
Removing unused block main::@2_11
Successful SSA optimization Pass2EliminateUnusedBlocks
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::@1 tails: main::@3 blocks: main::@3 main::@2_10 main::@2_9 main::@2_8 main::@2_7 main::@2_6 main::@2_5 main::@2_4 main::@2_3 main::@2_2 main::@2_1 main::@2 main::@1 
Successful SSA optimization Pass2LoopUnroll
Identical Phi Values (byte) main::x#4 (const byte) main::x#0
Successful SSA optimization Pass2IdenticalPhiElimination
Constant right-side identified [13] (byte) main::x#1 ← ++ (const byte) main::x#0
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) main::x#1 = ++main::x#0
Successful SSA optimization Pass2ConstantIdentification
if() condition always true - replacing block destination [14] if((const byte) main::x#1!=(byte) $b) goto main::@1_1
Successful SSA optimization Pass2ConstantIfs
Simplifying expression containing zero main::$1 in [2] *((const byte*) main::$1 + (const byte) main::x#0) ← (const byte) main::x#0
Simplifying expression containing zero main::$5 in [3] *((const byte*) main::$5 + (const byte) main::x#0) ← (const byte) main::x#0
Simplifying expression containing zero main::$7 in [4] *((const byte*) main::$7 + (const byte) main::x#0) ← (const byte) main::x#0
Simplifying expression containing zero main::$9 in [5] *((const byte*) main::$9 + (const byte) main::x#0) ← (const byte) main::x#0
Simplifying expression containing zero main::$11 in [6] *((const byte*) main::$11 + (const byte) main::x#0) ← (const byte) main::x#0
Simplifying expression containing zero main::$13 in [7] *((const byte*) main::$13 + (const byte) main::x#0) ← (const byte) main::x#0
Simplifying expression containing zero main::$15 in [8] *((const byte*) main::$15 + (const byte) main::x#0) ← (const byte) main::x#0
Simplifying expression containing zero main::$17 in [9] *((const byte*) main::$17 + (const byte) main::x#0) ← (const byte) main::x#0
Simplifying expression containing zero main::$19 in [10] *((const byte*) main::$19 + (const byte) main::x#0) ← (const byte) main::x#0
Simplifying expression containing zero main::$21 in [11] *((const byte*) main::$21 + (const byte) main::x#0) ← (const byte) main::x#0
Simplifying expression containing zero main::$23 in [12] *((const byte*) main::$23 + (const byte) main::x#0) ← (const byte) main::x#0
Successful SSA optimization PassNSimplifyExpressionWithZero
Unrolling loop Loop head: main::@1_1 tails: main::@3_1 blocks: main::@3_1 main::@2_21 main::@2_20 main::@2_19 main::@2_18 main::@2_17 main::@2_16 main::@2_15 main::@2_14 main::@2_13 main::@2_12 main::@2_11 main::@1_1 
Successful SSA optimization Pass2LoopUnroll
Identical Phi Values (byte) main::x#5 (const byte) main::x#1
Successful SSA optimization Pass2IdenticalPhiElimination
Constant right-side identified [24] (byte) main::x#6 ← ++ (const byte) main::x#1
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) main::x#6 = ++main::x#1
Successful SSA optimization Pass2ConstantIdentification
if() condition always true - replacing block destination [25] if((const byte) main::x#6!=(byte) $b) goto main::@1_2
Successful SSA optimization Pass2ConstantIfs
Unrolling loop Loop head: main::@1_2 tails: main::@3_2 blocks: main::@3_2 main::@2_32 main::@2_31 main::@2_30 main::@2_29 main::@2_28 main::@2_27 main::@2_26 main::@2_25 main::@2_24 main::@2_23 main::@2_22 main::@1_2 
Successful SSA optimization Pass2LoopUnroll
Identical Phi Values (byte) main::x#7 (const byte) main::x#6
Successful SSA optimization Pass2IdenticalPhiElimination
Constant right-side identified [35] (byte) main::x#8 ← ++ (const byte) main::x#6
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) main::x#8 = ++main::x#6
Successful SSA optimization Pass2ConstantIdentification
if() condition always true - replacing block destination [36] if((const byte) main::x#8!=(byte) $b) goto main::@1_3
Successful SSA optimization Pass2ConstantIfs
Unrolling loop Loop head: main::@1_3 tails: main::@3_3 blocks: main::@3_3 main::@2_43 main::@2_42 main::@2_41 main::@2_40 main::@2_39 main::@2_38 main::@2_37 main::@2_36 main::@2_35 main::@2_34 main::@2_33 main::@1_3 
Successful SSA optimization Pass2LoopUnroll
Identical Phi Values (byte) main::x#9 (const byte) main::x#8
Successful SSA optimization Pass2IdenticalPhiElimination
Constant right-side identified [46] (byte) main::x#10 ← ++ (const byte) main::x#8
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) main::x#10 = ++main::x#8
Successful SSA optimization Pass2ConstantIdentification
if() condition always true - replacing block destination [47] if((const byte) main::x#10!=(byte) $b) goto main::@1_4
Successful SSA optimization Pass2ConstantIfs
Unrolling loop Loop head: main::@1_4 tails: main::@3_4 blocks: main::@3_4 main::@2_54 main::@2_53 main::@2_52 main::@2_51 main::@2_50 main::@2_49 main::@2_48 main::@2_47 main::@2_46 main::@2_45 main::@2_44 main::@1_4 
Successful SSA optimization Pass2LoopUnroll
Identical Phi Values (byte) main::x#11 (const byte) main::x#10
Successful SSA optimization Pass2IdenticalPhiElimination
Constant right-side identified [57] (byte) main::x#12 ← ++ (const byte) main::x#10
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) main::x#12 = ++main::x#10
Successful SSA optimization Pass2ConstantIdentification
if() condition always true - replacing block destination [58] if((const byte) main::x#12!=(byte) $b) goto main::@1_5
Successful SSA optimization Pass2ConstantIfs
Unrolling loop Loop head: main::@1_5 tails: main::@3_5 blocks: main::@3_5 main::@2_65 main::@2_64 main::@2_63 main::@2_62 main::@2_61 main::@2_60 main::@2_59 main::@2_58 main::@2_57 main::@2_56 main::@2_55 main::@1_5 
Successful SSA optimization Pass2LoopUnroll
Identical Phi Values (byte) main::x#13 (const byte) main::x#12
Successful SSA optimization Pass2IdenticalPhiElimination
Constant right-side identified [68] (byte) main::x#14 ← ++ (const byte) main::x#12
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) main::x#14 = ++main::x#12
Successful SSA optimization Pass2ConstantIdentification
if() condition always true - replacing block destination [69] if((const byte) main::x#14!=(byte) $b) goto main::@1_6
Successful SSA optimization Pass2ConstantIfs
Unrolling loop Loop head: main::@1_6 tails: main::@3_6 blocks: main::@3_6 main::@2_76 main::@2_75 main::@2_74 main::@2_73 main::@2_72 main::@2_71 main::@2_70 main::@2_69 main::@2_68 main::@2_67 main::@2_66 main::@1_6 
Successful SSA optimization Pass2LoopUnroll
Identical Phi Values (byte) main::x#15 (const byte) main::x#14
Successful SSA optimization Pass2IdenticalPhiElimination
Constant right-side identified [79] (byte) main::x#16 ← ++ (const byte) main::x#14
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) main::x#16 = ++main::x#14
Successful SSA optimization Pass2ConstantIdentification
if() condition always true - replacing block destination [80] if((const byte) main::x#16!=(byte) $b) goto main::@1_7
Successful SSA optimization Pass2ConstantIfs
Unrolling loop Loop head: main::@1_7 tails: main::@3_7 blocks: main::@3_7 main::@2_87 main::@2_86 main::@2_85 main::@2_84 main::@2_83 main::@2_82 main::@2_81 main::@2_80 main::@2_79 main::@2_78 main::@2_77 main::@1_7 
Successful SSA optimization Pass2LoopUnroll
Identical Phi Values (byte) main::x#17 (const byte) main::x#16
Successful SSA optimization Pass2IdenticalPhiElimination
Constant right-side identified [90] (byte) main::x#18 ← ++ (const byte) main::x#16
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) main::x#18 = ++main::x#16
Successful SSA optimization Pass2ConstantIdentification
if() condition always true - replacing block destination [91] if((const byte) main::x#18!=(byte) $b) goto main::@1_8
Successful SSA optimization Pass2ConstantIfs
Unrolling loop Loop head: main::@1_8 tails: main::@3_8 blocks: main::@3_8 main::@2_98 main::@2_97 main::@2_96 main::@2_95 main::@2_94 main::@2_93 main::@2_92 main::@2_91 main::@2_90 main::@2_89 main::@2_88 main::@1_8 
Successful SSA optimization Pass2LoopUnroll
Identical Phi Values (byte) main::x#19 (const byte) main::x#18
Successful SSA optimization Pass2IdenticalPhiElimination
Constant right-side identified [101] (byte) main::x#20 ← ++ (const byte) main::x#18
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) main::x#20 = ++main::x#18
Successful SSA optimization Pass2ConstantIdentification
if() condition always true - replacing block destination [102] if((const byte) main::x#20!=(byte) $b) goto main::@1_9
Successful SSA optimization Pass2ConstantIfs
Unrolling loop Loop head: main::@1_9 tails: main::@3_9 blocks: main::@3_9 main::@2_109 main::@2_108 main::@2_107 main::@2_106 main::@2_105 main::@2_104 main::@2_103 main::@2_102 main::@2_101 main::@2_100 main::@2_99 main::@1_9 
Successful SSA optimization Pass2LoopUnroll
Identical Phi Values (byte) main::x#21 (const byte) main::x#20
Successful SSA optimization Pass2IdenticalPhiElimination
Constant right-side identified [112] (byte) main::x#22 ← ++ (const byte) main::x#20
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) main::x#22 = ++main::x#20
Successful SSA optimization Pass2ConstantIdentification
if() condition always true - replacing block destination [113] if((const byte) main::x#22!=(byte) $b) goto main::@1_10
Successful SSA optimization Pass2ConstantIfs
Unrolling loop Loop head: main::@1_10 tails: main::@3_10 blocks: main::@3_10 main::@2_120 main::@2_119 main::@2_118 main::@2_117 main::@2_116 main::@2_115 main::@2_114 main::@2_113 main::@2_112 main::@2_111 main::@2_110 main::@1_10 
Successful SSA optimization Pass2LoopUnroll
Identical Phi Values (byte) main::x#23 (const byte) main::x#22
Successful SSA optimization Pass2IdenticalPhiElimination
Constant right-side identified [123] (byte) main::x#24 ← ++ (const byte) main::x#22
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) main::x#24 = ++main::x#22
Successful SSA optimization Pass2ConstantIdentification
Removing PHI-reference to removed block (main::@3_10) in block main::@1_11
if() condition always false - eliminating [124] if((const byte) main::x#24!=(byte) $b) goto main::@1_11
Successful SSA optimization Pass2ConstantIfs
Eliminating unused constant (const byte) main::x#24
Successful SSA optimization PassNEliminateUnusedVars
Eliminating variable (byte) main::x#25 from unused block main::@1_11
Eliminating variable (byte) main::x#26 from unused block main::@3_11
Removing unused block main::@1_11
Removing unused block main::@2_121
Removing unused block main::@2_122
Removing unused block main::@2_123
Removing unused block main::@2_124
Removing unused block main::@2_125
Removing unused block main::@2_126
Removing unused block main::@2_127
Removing unused block main::@2_128
Removing unused block main::@2_129
Removing unused block main::@2_130
Removing unused block main::@2_131
Removing unused block main::@3_11
Successful SSA optimization Pass2EliminateUnusedBlocks
Inlining constant with different constant 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::x#1
Inlining constant with different constant siblings (const byte) main::x#6
Inlining constant with different constant siblings (const byte) main::x#8
Inlining constant with different constant siblings (const byte) main::x#10
Inlining constant with different constant siblings (const byte) main::x#12
Inlining constant with different constant siblings (const byte) main::x#14
Inlining constant with different constant siblings (const byte) main::x#16
Inlining constant with different constant siblings (const byte) main::x#18
Inlining constant with different constant siblings (const byte) main::x#20
Inlining constant with different constant siblings (const byte) main::x#22
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#20 = ++++++++++++++++++++(byte) 0
Constant inlined main::$16 = ++++++++++++++(byte) 0*(byte) $28
Constant inlined main::x#16 = ++++++++++++++(byte) 0
Constant inlined main::$17 = (const byte*) main::SCREEN#0+++++++++++++++(byte) 0*(byte) $28
Constant inlined main::$18 = ++++++++++++++++(byte) 0*(byte) $28
Constant inlined main::x#18 = ++++++++++++++++(byte) 0
Constant inlined main::$19 = (const byte*) main::SCREEN#0+++++++++++++++++(byte) 0*(byte) $28
Constant inlined main::line#4 = ++++(byte) 0
Constant inlined main::x#12 = ++++++++++(byte) 0
Constant inlined main::x#14 = ++++++++++++(byte) 0
Constant inlined main::line#0 = (byte) 0
Constant inlined main::line#1 = ++(byte) 0
Constant inlined main::x#10 = ++++++++(byte) 0
Constant inlined main::line#8 = ++++++++(byte) 0
Constant inlined main::line#6 = ++++++(byte) 0
Constant inlined main::$23 = (const byte*) main::SCREEN#0+++++++++++++++++++++(byte) 0*(byte) $28
Constant inlined main::x#0 = (byte) 0
Constant inlined main::x#1 = ++(byte) 0
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#10 = ++++++++++(byte) 0
Constant inlined main::line#12 = ++++++++++++(byte) 0
Constant inlined main::x#8 = ++++++(byte) 0
Constant inlined main::$1 = (const byte*) main::SCREEN#0
Constant inlined main::x#6 = ++++(byte) 0
Constant inlined main::$5 = (const byte*) main::SCREEN#0+++(byte) 0*(byte) $28
Constant inlined main::line#18 = ++++++++++++++++++(byte) 0
Constant inlined main::$6 = ++++(byte) 0*(byte) $28
Constant inlined main::x#22 = ++++++++++++++++++++(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#14 = ++++++++++++++(byte) 0
Constant inlined main::$7 = (const byte*) main::SCREEN#0+++++(byte) 0*(byte) $28
Constant inlined main::line#16 = ++++++++++++++++(byte) 0
Constant inlined main::$8 = ++++++(byte) 0*(byte) $28
Constant inlined main::x#20 = ++++++++++++++++++(byte) 0
Successful SSA optimization Pass2ConstantInlining
Consolidated array index constant in *(main::SCREEN#0+++0)
Consolidated array index constant in *(main::SCREEN#0+++0*$28+++0)
Consolidated array index constant in *(main::SCREEN#0+++++0*$28+++0)
Consolidated array index constant in *(main::SCREEN#0+++++++0*$28+++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++0*$28+++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++++0*$28+++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++++++0*$28+++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++++++++0*$28+++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++++++++++0*$28+++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++++++++++++0*$28+++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++++++++++++++0*$28+++0)
Consolidated array index constant in *(main::SCREEN#0+++++0)
Consolidated array index constant in *(main::SCREEN#0+++0*$28+++++0)
Consolidated array index constant in *(main::SCREEN#0+++++0*$28+++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++0*$28+++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++0*$28+++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++++0*$28+++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++++++0*$28+++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++++++++0*$28+++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++++++++++0*$28+++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++++++++++++0*$28+++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++++++++++++++0*$28+++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++0)
Consolidated array index constant in *(main::SCREEN#0+++0*$28+++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++0*$28+++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++0*$28+++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++0*$28+++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++++0*$28+++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++++++0*$28+++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++++++++0*$28+++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++++++++++0*$28+++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++++++++++++0*$28+++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++++++++++++++0*$28+++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++0*$28+++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++0*$28+++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++0*$28+++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++0*$28+++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++++0*$28+++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++++++0*$28+++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++++++++0*$28+++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++++++++++0*$28+++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++++++++++++0*$28+++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++++++++++++++0*$28+++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++0*$28+++++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++0*$28+++++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++0*$28+++++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++0*$28+++++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++++0*$28+++++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++++++0*$28+++++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++++++++0*$28+++++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++++++++++0*$28+++++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++++++++++++0*$28+++++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++++++++++++++0*$28+++++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++0*$28+++++++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++0*$28+++++++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++0*$28+++++++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++0*$28+++++++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++++0*$28+++++++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++++++0*$28+++++++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++++++++0*$28+++++++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++++++++++0*$28+++++++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++++++++++++0*$28+++++++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++++++++++++++0*$28+++++++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++0*$28+++++++++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++0*$28+++++++++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++0*$28+++++++++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++0*$28+++++++++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++++0*$28+++++++++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++++++0*$28+++++++++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++++++++0*$28+++++++++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++++++++++0*$28+++++++++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++++++++++++0*$28+++++++++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++++++++++++++0*$28+++++++++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++0*$28+++++++++++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++0*$28+++++++++++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++0*$28+++++++++++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++0*$28+++++++++++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++++0*$28+++++++++++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++++++0*$28+++++++++++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++++++++0*$28+++++++++++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++++++++++0*$28+++++++++++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++++++++++++0*$28+++++++++++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++++++++++++++0*$28+++++++++++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++++++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++0*$28+++++++++++++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++0*$28+++++++++++++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++0*$28+++++++++++++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++0*$28+++++++++++++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++++0*$28+++++++++++++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++++++0*$28+++++++++++++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++++++++0*$28+++++++++++++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++++++++++0*$28+++++++++++++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++++++++++++0*$28+++++++++++++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++++++++++++++0*$28+++++++++++++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++++++++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++0*$28+++++++++++++++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++0*$28+++++++++++++++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++0*$28+++++++++++++++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++0*$28+++++++++++++++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++++0*$28+++++++++++++++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++++++0*$28+++++++++++++++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++++++++0*$28+++++++++++++++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++++++++++0*$28+++++++++++++++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++++++++++++0*$28+++++++++++++++++++++0)
Consolidated array index constant in *(main::SCREEN#0+++++++++++++++++++++0*$28+++++++++++++++++++++0)
Successful SSA optimization Pass2ConstantAdditionElimination
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 ++0
Simplifying constant integer increment ++0
Simplifying constant integer increment ++0
Simplifying constant integer increment ++0
Simplifying constant integer increment ++0
Simplifying constant integer increment ++1
Simplifying constant integer increment ++0
Simplifying constant integer increment ++0
Simplifying constant integer increment ++2
Simplifying constant integer increment ++0
Simplifying constant integer increment ++0
Simplifying constant integer increment ++3
Simplifying constant integer increment ++0
Simplifying constant integer increment ++0
Simplifying constant integer increment ++4
Simplifying constant integer increment ++0
Simplifying constant integer increment ++0
Simplifying constant integer increment ++5
Simplifying constant integer increment ++0
Simplifying constant integer increment ++0
Simplifying constant integer increment ++6
Simplifying constant integer increment ++0
Simplifying constant integer increment ++0
Simplifying constant integer increment ++7
Simplifying constant integer increment ++0
Simplifying constant integer increment ++0
Simplifying constant integer increment ++8
Simplifying constant integer increment ++0
Simplifying constant integer increment ++0
Simplifying constant integer increment ++9
Simplifying constant integer increment ++0
Simplifying constant integer increment ++0
Simplifying constant integer increment ++1
Simplifying constant integer increment ++1
Simplifying constant integer increment ++1
Simplifying constant integer increment ++1
Simplifying constant integer increment ++1
Simplifying constant integer increment ++1
Simplifying constant integer increment ++1
Simplifying constant integer increment ++1
Simplifying constant integer increment ++1
Simplifying constant integer increment ++1
Simplifying constant integer increment ++1
Simplifying constant integer increment ++1
Simplifying constant integer increment ++1
Simplifying constant integer increment ++1
Simplifying constant integer increment ++1
Simplifying constant integer increment ++1
Simplifying constant integer increment ++1
Simplifying constant integer increment ++1
Simplifying constant integer increment ++1
Simplifying constant integer increment ++1
Simplifying constant integer increment ++1
Simplifying constant integer increment ++1
Simplifying constant integer increment ++2
Simplifying constant integer increment ++2
Simplifying constant integer increment ++2
Simplifying constant integer increment ++2
Simplifying constant integer increment ++2
Simplifying constant integer increment ++2
Simplifying constant integer increment ++2
Simplifying constant integer increment ++2
Simplifying constant integer increment ++2
Simplifying constant integer increment ++2
Simplifying constant integer increment ++2
Simplifying constant integer increment ++2
Simplifying constant integer increment ++2
Simplifying constant integer increment ++2
Simplifying constant integer increment ++2
Simplifying constant integer increment ++2
Simplifying constant integer increment ++2
Simplifying constant integer increment ++2
Simplifying constant integer increment ++2
Simplifying constant integer increment ++2
Simplifying constant integer increment ++2
Simplifying constant integer increment ++2
Simplifying constant integer increment ++3
Simplifying constant integer increment ++3
Simplifying constant integer increment ++3
Simplifying constant integer increment ++3
Simplifying constant integer increment ++3
Simplifying constant integer increment ++3
Simplifying constant integer increment ++3
Simplifying constant integer increment ++3
Simplifying constant integer increment ++3
Simplifying constant integer increment ++3
Simplifying constant integer increment ++3
Simplifying constant integer increment ++3
Simplifying constant integer increment ++3
Simplifying constant integer increment ++3
Simplifying constant integer increment ++3
Simplifying constant integer increment ++3
Simplifying constant integer increment ++3
Simplifying constant integer increment ++3
Simplifying constant integer increment ++3
Simplifying constant integer increment ++3
Simplifying constant integer increment ++3
Simplifying constant integer increment ++3
Simplifying constant integer increment ++4
Simplifying constant integer increment ++4
Simplifying constant integer increment ++4
Simplifying constant integer increment ++4
Simplifying constant integer increment ++4
Simplifying constant integer increment ++4
Simplifying constant integer increment ++4
Simplifying constant integer increment ++4
Simplifying constant integer increment ++4
Simplifying constant integer increment ++4
Simplifying constant integer increment ++4
Simplifying constant integer increment ++4
Simplifying constant integer increment ++4
Simplifying constant integer increment ++4
Simplifying constant integer increment ++4
Simplifying constant integer increment ++4
Simplifying constant integer increment ++4
Simplifying constant integer increment ++4
Simplifying constant integer increment ++4
Simplifying constant integer increment ++4
Simplifying constant integer increment ++4
Simplifying constant integer increment ++4
Simplifying constant integer increment ++5
Simplifying constant integer increment ++5
Simplifying constant integer increment ++5
Simplifying constant integer increment ++5
Simplifying constant integer increment ++5
Simplifying constant integer increment ++5
Simplifying constant integer increment ++5
Simplifying constant integer increment ++5
Simplifying constant integer increment ++5
Simplifying constant integer increment ++5
Simplifying constant integer increment ++5
Simplifying constant integer increment ++5
Simplifying constant integer increment ++5
Simplifying constant integer increment ++5
Simplifying constant integer increment ++5
Simplifying constant integer increment ++5
Simplifying constant integer increment ++5
Simplifying constant integer increment ++5
Simplifying constant integer increment ++5
Simplifying constant integer increment ++5
Simplifying constant integer increment ++5
Simplifying constant integer increment ++5
Simplifying constant integer increment ++6
Simplifying constant integer increment ++6
Simplifying constant integer increment ++6
Simplifying constant integer increment ++6
Simplifying constant integer increment ++6
Simplifying constant integer increment ++6
Simplifying constant integer increment ++6
Simplifying constant integer increment ++6
Simplifying constant integer increment ++6
Simplifying constant integer increment ++6
Simplifying constant integer increment ++6
Simplifying constant integer increment ++6
Simplifying constant integer increment ++6
Simplifying constant integer increment ++6
Simplifying constant integer increment ++6
Simplifying constant integer increment ++6
Simplifying constant integer increment ++6
Simplifying constant integer increment ++6
Simplifying constant integer increment ++6
Simplifying constant integer increment ++6
Simplifying constant integer increment ++6
Simplifying constant integer increment ++6
Simplifying constant integer increment ++7
Simplifying constant integer increment ++7
Simplifying constant integer increment ++7
Simplifying constant integer increment ++7
Simplifying constant integer increment ++7
Simplifying constant integer increment ++7
Simplifying constant integer increment ++7
Simplifying constant integer increment ++7
Simplifying constant integer increment ++7
Simplifying constant integer increment ++7
Simplifying constant integer increment ++7
Simplifying constant integer increment ++7
Simplifying constant integer increment ++7
Simplifying constant integer increment ++7
Simplifying constant integer increment ++7
Simplifying constant integer increment ++7
Simplifying constant integer increment ++7
Simplifying constant integer increment ++7
Simplifying constant integer increment ++7
Simplifying constant integer increment ++7
Simplifying constant integer increment ++7
Simplifying constant integer increment ++7
Simplifying constant integer increment ++8
Simplifying constant integer increment ++8
Simplifying constant integer increment ++8
Simplifying constant integer increment ++8
Simplifying constant integer increment ++8
Simplifying constant integer increment ++8
Simplifying constant integer increment ++8
Simplifying constant integer increment ++8
Simplifying constant integer increment ++8
Simplifying constant integer increment ++8
Simplifying constant integer increment ++8
Simplifying constant integer increment ++8
Simplifying constant integer increment ++8
Simplifying constant integer increment ++8
Simplifying constant integer increment ++8
Simplifying constant integer increment ++8
Simplifying constant integer increment ++8
Simplifying constant integer increment ++8
Simplifying constant integer increment ++8
Simplifying constant integer increment ++8
Simplifying constant integer increment ++8
Simplifying constant integer increment ++8
Simplifying constant integer increment ++9
Simplifying constant integer increment ++9
Simplifying constant integer increment ++9
Simplifying constant integer increment ++9
Simplifying constant integer increment ++9
Simplifying constant integer increment ++9
Simplifying constant integer increment ++9
Simplifying constant integer increment ++9
Simplifying constant integer increment ++9
Simplifying constant integer increment ++9
Simplifying constant integer increment ++9
Simplifying constant integer increment ++9
Simplifying constant integer increment ++9
Simplifying constant integer increment ++9
Simplifying constant integer increment ++9
Simplifying constant integer increment ++9
Simplifying constant integer increment ++9
Simplifying constant integer increment ++9
Simplifying constant integer increment ++9
Simplifying constant integer increment ++9
Simplifying constant integer increment ++9
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
Successful SSA optimization Pass2ConstantSimplification
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::@1
Adding NOP phi() at start of main::@3
Adding NOP phi() at start of main::@1_1
Adding NOP phi() at start of main::@3_1
Adding NOP phi() at start of main::@1_2
Adding NOP phi() at start of main::@3_2
Adding NOP phi() at start of main::@1_3
Adding NOP phi() at start of main::@3_3
Adding NOP phi() at start of main::@1_4
Adding NOP phi() at start of main::@3_4
Adding NOP phi() at start of main::@1_5
Adding NOP phi() at start of main::@3_5
Adding NOP phi() at start of main::@1_6
Adding NOP phi() at start of main::@3_6
Adding NOP phi() at start of main::@1_7
Adding NOP phi() at start of main::@3_7
Adding NOP phi() at start of main::@1_8
Adding NOP phi() at start of main::@3_8
Adding NOP phi() at start of main::@1_9
Adding NOP phi() at start of main::@3_9
Adding NOP phi() at start of main::@1_10
Adding NOP phi() at start of main::@3_10
CALL GRAPH
Calls in [] to main:2 

Created 0 initial phi equivalence classes
Coalesced down to 0 phi equivalence classes
Culled Empty Block (label) @2
Culled Empty Block (label) main::@1
Culled Empty Block (label) main::@3
Culled Empty Block (label) main::@1_1
Culled Empty Block (label) main::@3_1
Culled Empty Block (label) main::@1_2
Culled Empty Block (label) main::@3_2
Culled Empty Block (label) main::@1_3
Culled Empty Block (label) main::@3_3
Culled Empty Block (label) main::@1_4
Culled Empty Block (label) main::@3_4
Culled Empty Block (label) main::@1_5
Culled Empty Block (label) main::@3_5
Culled Empty Block (label) main::@1_6
Culled Empty Block (label) main::@3_6
Culled Empty Block (label) main::@1_7
Culled Empty Block (label) main::@3_7
Culled Empty Block (label) main::@1_8
Culled Empty Block (label) main::@3_8
Culled Empty Block (label) main::@1_9
Culled Empty Block (label) main::@3_9
Culled Empty Block (label) main::@1_10
Culled Empty Block (label) main::@3_10
Renumbering block main::@2 to main::@1
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
  [5] *((const byte*) main::SCREEN#0) ← (byte) 0
  to:main::@2_1
main::@2_1: scope:[main]  from main::@1
  [6] *((const byte*) main::SCREEN#0+(byte) 1*(byte) $28) ← (byte) 0
  to:main::@2_2
main::@2_2: scope:[main]  from main::@2_1
  [7] *((const byte*) main::SCREEN#0+(byte) 2*(byte) $28) ← (byte) 0
  to:main::@2_3
main::@2_3: scope:[main]  from main::@2_2
  [8] *((const byte*) main::SCREEN#0+(byte) 3*(byte) $28) ← (byte) 0
  to:main::@2_4
main::@2_4: scope:[main]  from main::@2_3
  [9] *((const byte*) main::SCREEN#0+(byte) 4*(byte) $28) ← (byte) 0
  to:main::@2_5
main::@2_5: scope:[main]  from main::@2_4
  [10] *((const byte*) main::SCREEN#0+(byte) 5*(byte) $28) ← (byte) 0
  to:main::@2_6
main::@2_6: scope:[main]  from main::@2_5
  [11] *((const byte*) main::SCREEN#0+(byte) 6*(byte) $28) ← (byte) 0
  to:main::@2_7
main::@2_7: scope:[main]  from main::@2_6
  [12] *((const byte*) main::SCREEN#0+(byte) 7*(byte) $28) ← (byte) 0
  to:main::@2_8
main::@2_8: scope:[main]  from main::@2_7
  [13] *((const byte*) main::SCREEN#0+(byte) 8*(byte) $28) ← (byte) 0
  to:main::@2_9
main::@2_9: scope:[main]  from main::@2_8
  [14] *((const byte*) main::SCREEN#0+(byte) 9*(byte) $28) ← (byte) 0
  to:main::@2_10
main::@2_10: scope:[main]  from main::@2_9
  [15] *((const byte*) main::SCREEN#0+(byte) $a*(byte) $28) ← (byte) 0
  to:main::@2_11
main::@2_11: scope:[main]  from main::@2_10
  [16] *((const byte*) main::SCREEN#0+(byte) 1) ← (byte) 1
  to:main::@2_12
main::@2_12: scope:[main]  from main::@2_11
  [17] *((const byte*) main::SCREEN#0+(byte) 1*(byte) $28+(byte) 1) ← (byte) 1
  to:main::@2_13
main::@2_13: scope:[main]  from main::@2_12
  [18] *((const byte*) main::SCREEN#0+(byte) 2*(byte) $28+(byte) 1) ← (byte) 1
  to:main::@2_14
main::@2_14: scope:[main]  from main::@2_13
  [19] *((const byte*) main::SCREEN#0+(byte) 3*(byte) $28+(byte) 1) ← (byte) 1
  to:main::@2_15
main::@2_15: scope:[main]  from main::@2_14
  [20] *((const byte*) main::SCREEN#0+(byte) 4*(byte) $28+(byte) 1) ← (byte) 1
  to:main::@2_16
main::@2_16: scope:[main]  from main::@2_15
  [21] *((const byte*) main::SCREEN#0+(byte) 5*(byte) $28+(byte) 1) ← (byte) 1
  to:main::@2_17
main::@2_17: scope:[main]  from main::@2_16
  [22] *((const byte*) main::SCREEN#0+(byte) 6*(byte) $28+(byte) 1) ← (byte) 1
  to:main::@2_18
main::@2_18: scope:[main]  from main::@2_17
  [23] *((const byte*) main::SCREEN#0+(byte) 7*(byte) $28+(byte) 1) ← (byte) 1
  to:main::@2_19
main::@2_19: scope:[main]  from main::@2_18
  [24] *((const byte*) main::SCREEN#0+(byte) 8*(byte) $28+(byte) 1) ← (byte) 1
  to:main::@2_20
main::@2_20: scope:[main]  from main::@2_19
  [25] *((const byte*) main::SCREEN#0+(byte) 9*(byte) $28+(byte) 1) ← (byte) 1
  to:main::@2_21
main::@2_21: scope:[main]  from main::@2_20
  [26] *((const byte*) main::SCREEN#0+(byte) $a*(byte) $28+(byte) 1) ← (byte) 1
  to:main::@2_22
main::@2_22: scope:[main]  from main::@2_21
  [27] *((const byte*) main::SCREEN#0+(byte) 2) ← (byte) 2
  to:main::@2_23
main::@2_23: scope:[main]  from main::@2_22
  [28] *((const byte*) main::SCREEN#0+(byte) 1*(byte) $28+(byte) 2) ← (byte) 2
  to:main::@2_24
main::@2_24: scope:[main]  from main::@2_23
  [29] *((const byte*) main::SCREEN#0+(byte) 2*(byte) $28+(byte) 2) ← (byte) 2
  to:main::@2_25
main::@2_25: scope:[main]  from main::@2_24
  [30] *((const byte*) main::SCREEN#0+(byte) 3*(byte) $28+(byte) 2) ← (byte) 2
  to:main::@2_26
main::@2_26: scope:[main]  from main::@2_25
  [31] *((const byte*) main::SCREEN#0+(byte) 4*(byte) $28+(byte) 2) ← (byte) 2
  to:main::@2_27
main::@2_27: scope:[main]  from main::@2_26
  [32] *((const byte*) main::SCREEN#0+(byte) 5*(byte) $28+(byte) 2) ← (byte) 2
  to:main::@2_28
main::@2_28: scope:[main]  from main::@2_27
  [33] *((const byte*) main::SCREEN#0+(byte) 6*(byte) $28+(byte) 2) ← (byte) 2
  to:main::@2_29
main::@2_29: scope:[main]  from main::@2_28
  [34] *((const byte*) main::SCREEN#0+(byte) 7*(byte) $28+(byte) 2) ← (byte) 2
  to:main::@2_30
main::@2_30: scope:[main]  from main::@2_29
  [35] *((const byte*) main::SCREEN#0+(byte) 8*(byte) $28+(byte) 2) ← (byte) 2
  to:main::@2_31
main::@2_31: scope:[main]  from main::@2_30
  [36] *((const byte*) main::SCREEN#0+(byte) 9*(byte) $28+(byte) 2) ← (byte) 2
  to:main::@2_32
main::@2_32: scope:[main]  from main::@2_31
  [37] *((const byte*) main::SCREEN#0+(byte) $a*(byte) $28+(byte) 2) ← (byte) 2
  to:main::@2_33
main::@2_33: scope:[main]  from main::@2_32
  [38] *((const byte*) main::SCREEN#0+(byte) 3) ← (byte) 3
  to:main::@2_34
main::@2_34: scope:[main]  from main::@2_33
  [39] *((const byte*) main::SCREEN#0+(byte) 1*(byte) $28+(byte) 3) ← (byte) 3
  to:main::@2_35
main::@2_35: scope:[main]  from main::@2_34
  [40] *((const byte*) main::SCREEN#0+(byte) 2*(byte) $28+(byte) 3) ← (byte) 3
  to:main::@2_36
main::@2_36: scope:[main]  from main::@2_35
  [41] *((const byte*) main::SCREEN#0+(byte) 3*(byte) $28+(byte) 3) ← (byte) 3
  to:main::@2_37
main::@2_37: scope:[main]  from main::@2_36
  [42] *((const byte*) main::SCREEN#0+(byte) 4*(byte) $28+(byte) 3) ← (byte) 3
  to:main::@2_38
main::@2_38: scope:[main]  from main::@2_37
  [43] *((const byte*) main::SCREEN#0+(byte) 5*(byte) $28+(byte) 3) ← (byte) 3
  to:main::@2_39
main::@2_39: scope:[main]  from main::@2_38
  [44] *((const byte*) main::SCREEN#0+(byte) 6*(byte) $28+(byte) 3) ← (byte) 3
  to:main::@2_40
main::@2_40: scope:[main]  from main::@2_39
  [45] *((const byte*) main::SCREEN#0+(byte) 7*(byte) $28+(byte) 3) ← (byte) 3
  to:main::@2_41
main::@2_41: scope:[main]  from main::@2_40
  [46] *((const byte*) main::SCREEN#0+(byte) 8*(byte) $28+(byte) 3) ← (byte) 3
  to:main::@2_42
main::@2_42: scope:[main]  from main::@2_41
  [47] *((const byte*) main::SCREEN#0+(byte) 9*(byte) $28+(byte) 3) ← (byte) 3
  to:main::@2_43
main::@2_43: scope:[main]  from main::@2_42
  [48] *((const byte*) main::SCREEN#0+(byte) $a*(byte) $28+(byte) 3) ← (byte) 3
  to:main::@2_44
main::@2_44: scope:[main]  from main::@2_43
  [49] *((const byte*) main::SCREEN#0+(byte) 4) ← (byte) 4
  to:main::@2_45
main::@2_45: scope:[main]  from main::@2_44
  [50] *((const byte*) main::SCREEN#0+(byte) 1*(byte) $28+(byte) 4) ← (byte) 4
  to:main::@2_46
main::@2_46: scope:[main]  from main::@2_45
  [51] *((const byte*) main::SCREEN#0+(byte) 2*(byte) $28+(byte) 4) ← (byte) 4
  to:main::@2_47
main::@2_47: scope:[main]  from main::@2_46
  [52] *((const byte*) main::SCREEN#0+(byte) 3*(byte) $28+(byte) 4) ← (byte) 4
  to:main::@2_48
main::@2_48: scope:[main]  from main::@2_47
  [53] *((const byte*) main::SCREEN#0+(byte) 4*(byte) $28+(byte) 4) ← (byte) 4
  to:main::@2_49
main::@2_49: scope:[main]  from main::@2_48
  [54] *((const byte*) main::SCREEN#0+(byte) 5*(byte) $28+(byte) 4) ← (byte) 4
  to:main::@2_50
main::@2_50: scope:[main]  from main::@2_49
  [55] *((const byte*) main::SCREEN#0+(byte) 6*(byte) $28+(byte) 4) ← (byte) 4
  to:main::@2_51
main::@2_51: scope:[main]  from main::@2_50
  [56] *((const byte*) main::SCREEN#0+(byte) 7*(byte) $28+(byte) 4) ← (byte) 4
  to:main::@2_52
main::@2_52: scope:[main]  from main::@2_51
  [57] *((const byte*) main::SCREEN#0+(byte) 8*(byte) $28+(byte) 4) ← (byte) 4
  to:main::@2_53
main::@2_53: scope:[main]  from main::@2_52
  [58] *((const byte*) main::SCREEN#0+(byte) 9*(byte) $28+(byte) 4) ← (byte) 4
  to:main::@2_54
main::@2_54: scope:[main]  from main::@2_53
  [59] *((const byte*) main::SCREEN#0+(byte) $a*(byte) $28+(byte) 4) ← (byte) 4
  to:main::@2_55
main::@2_55: scope:[main]  from main::@2_54
  [60] *((const byte*) main::SCREEN#0+(byte) 5) ← (byte) 5
  to:main::@2_56
main::@2_56: scope:[main]  from main::@2_55
  [61] *((const byte*) main::SCREEN#0+(byte) 1*(byte) $28+(byte) 5) ← (byte) 5
  to:main::@2_57
main::@2_57: scope:[main]  from main::@2_56
  [62] *((const byte*) main::SCREEN#0+(byte) 2*(byte) $28+(byte) 5) ← (byte) 5
  to:main::@2_58
main::@2_58: scope:[main]  from main::@2_57
  [63] *((const byte*) main::SCREEN#0+(byte) 3*(byte) $28+(byte) 5) ← (byte) 5
  to:main::@2_59
main::@2_59: scope:[main]  from main::@2_58
  [64] *((const byte*) main::SCREEN#0+(byte) 4*(byte) $28+(byte) 5) ← (byte) 5
  to:main::@2_60
main::@2_60: scope:[main]  from main::@2_59
  [65] *((const byte*) main::SCREEN#0+(byte) 5*(byte) $28+(byte) 5) ← (byte) 5
  to:main::@2_61
main::@2_61: scope:[main]  from main::@2_60
  [66] *((const byte*) main::SCREEN#0+(byte) 6*(byte) $28+(byte) 5) ← (byte) 5
  to:main::@2_62
main::@2_62: scope:[main]  from main::@2_61
  [67] *((const byte*) main::SCREEN#0+(byte) 7*(byte) $28+(byte) 5) ← (byte) 5
  to:main::@2_63
main::@2_63: scope:[main]  from main::@2_62
  [68] *((const byte*) main::SCREEN#0+(byte) 8*(byte) $28+(byte) 5) ← (byte) 5
  to:main::@2_64
main::@2_64: scope:[main]  from main::@2_63
  [69] *((const byte*) main::SCREEN#0+(byte) 9*(byte) $28+(byte) 5) ← (byte) 5
  to:main::@2_65
main::@2_65: scope:[main]  from main::@2_64
  [70] *((const byte*) main::SCREEN#0+(byte) $a*(byte) $28+(byte) 5) ← (byte) 5
  to:main::@2_66
main::@2_66: scope:[main]  from main::@2_65
  [71] *((const byte*) main::SCREEN#0+(byte) 6) ← (byte) 6
  to:main::@2_67
main::@2_67: scope:[main]  from main::@2_66
  [72] *((const byte*) main::SCREEN#0+(byte) 1*(byte) $28+(byte) 6) ← (byte) 6
  to:main::@2_68
main::@2_68: scope:[main]  from main::@2_67
  [73] *((const byte*) main::SCREEN#0+(byte) 2*(byte) $28+(byte) 6) ← (byte) 6
  to:main::@2_69
main::@2_69: scope:[main]  from main::@2_68
  [74] *((const byte*) main::SCREEN#0+(byte) 3*(byte) $28+(byte) 6) ← (byte) 6
  to:main::@2_70
main::@2_70: scope:[main]  from main::@2_69
  [75] *((const byte*) main::SCREEN#0+(byte) 4*(byte) $28+(byte) 6) ← (byte) 6
  to:main::@2_71
main::@2_71: scope:[main]  from main::@2_70
  [76] *((const byte*) main::SCREEN#0+(byte) 5*(byte) $28+(byte) 6) ← (byte) 6
  to:main::@2_72
main::@2_72: scope:[main]  from main::@2_71
  [77] *((const byte*) main::SCREEN#0+(byte) 6*(byte) $28+(byte) 6) ← (byte) 6
  to:main::@2_73
main::@2_73: scope:[main]  from main::@2_72
  [78] *((const byte*) main::SCREEN#0+(byte) 7*(byte) $28+(byte) 6) ← (byte) 6
  to:main::@2_74
main::@2_74: scope:[main]  from main::@2_73
  [79] *((const byte*) main::SCREEN#0+(byte) 8*(byte) $28+(byte) 6) ← (byte) 6
  to:main::@2_75
main::@2_75: scope:[main]  from main::@2_74
  [80] *((const byte*) main::SCREEN#0+(byte) 9*(byte) $28+(byte) 6) ← (byte) 6
  to:main::@2_76
main::@2_76: scope:[main]  from main::@2_75
  [81] *((const byte*) main::SCREEN#0+(byte) $a*(byte) $28+(byte) 6) ← (byte) 6
  to:main::@2_77
main::@2_77: scope:[main]  from main::@2_76
  [82] *((const byte*) main::SCREEN#0+(byte) 7) ← (byte) 7
  to:main::@2_78
main::@2_78: scope:[main]  from main::@2_77
  [83] *((const byte*) main::SCREEN#0+(byte) 1*(byte) $28+(byte) 7) ← (byte) 7
  to:main::@2_79
main::@2_79: scope:[main]  from main::@2_78
  [84] *((const byte*) main::SCREEN#0+(byte) 2*(byte) $28+(byte) 7) ← (byte) 7
  to:main::@2_80
main::@2_80: scope:[main]  from main::@2_79
  [85] *((const byte*) main::SCREEN#0+(byte) 3*(byte) $28+(byte) 7) ← (byte) 7
  to:main::@2_81
main::@2_81: scope:[main]  from main::@2_80
  [86] *((const byte*) main::SCREEN#0+(byte) 4*(byte) $28+(byte) 7) ← (byte) 7
  to:main::@2_82
main::@2_82: scope:[main]  from main::@2_81
  [87] *((const byte*) main::SCREEN#0+(byte) 5*(byte) $28+(byte) 7) ← (byte) 7
  to:main::@2_83
main::@2_83: scope:[main]  from main::@2_82
  [88] *((const byte*) main::SCREEN#0+(byte) 6*(byte) $28+(byte) 7) ← (byte) 7
  to:main::@2_84
main::@2_84: scope:[main]  from main::@2_83
  [89] *((const byte*) main::SCREEN#0+(byte) 7*(byte) $28+(byte) 7) ← (byte) 7
  to:main::@2_85
main::@2_85: scope:[main]  from main::@2_84
  [90] *((const byte*) main::SCREEN#0+(byte) 8*(byte) $28+(byte) 7) ← (byte) 7
  to:main::@2_86
main::@2_86: scope:[main]  from main::@2_85
  [91] *((const byte*) main::SCREEN#0+(byte) 9*(byte) $28+(byte) 7) ← (byte) 7
  to:main::@2_87
main::@2_87: scope:[main]  from main::@2_86
  [92] *((const byte*) main::SCREEN#0+(byte) $a*(byte) $28+(byte) 7) ← (byte) 7
  to:main::@2_88
main::@2_88: scope:[main]  from main::@2_87
  [93] *((const byte*) main::SCREEN#0+(byte) 8) ← (byte) 8
  to:main::@2_89
main::@2_89: scope:[main]  from main::@2_88
  [94] *((const byte*) main::SCREEN#0+(byte) 1*(byte) $28+(byte) 8) ← (byte) 8
  to:main::@2_90
main::@2_90: scope:[main]  from main::@2_89
  [95] *((const byte*) main::SCREEN#0+(byte) 2*(byte) $28+(byte) 8) ← (byte) 8
  to:main::@2_91
main::@2_91: scope:[main]  from main::@2_90
  [96] *((const byte*) main::SCREEN#0+(byte) 3*(byte) $28+(byte) 8) ← (byte) 8
  to:main::@2_92
main::@2_92: scope:[main]  from main::@2_91
  [97] *((const byte*) main::SCREEN#0+(byte) 4*(byte) $28+(byte) 8) ← (byte) 8
  to:main::@2_93
main::@2_93: scope:[main]  from main::@2_92
  [98] *((const byte*) main::SCREEN#0+(byte) 5*(byte) $28+(byte) 8) ← (byte) 8
  to:main::@2_94
main::@2_94: scope:[main]  from main::@2_93
  [99] *((const byte*) main::SCREEN#0+(byte) 6*(byte) $28+(byte) 8) ← (byte) 8
  to:main::@2_95
main::@2_95: scope:[main]  from main::@2_94
  [100] *((const byte*) main::SCREEN#0+(byte) 7*(byte) $28+(byte) 8) ← (byte) 8
  to:main::@2_96
main::@2_96: scope:[main]  from main::@2_95
  [101] *((const byte*) main::SCREEN#0+(byte) 8*(byte) $28+(byte) 8) ← (byte) 8
  to:main::@2_97
main::@2_97: scope:[main]  from main::@2_96
  [102] *((const byte*) main::SCREEN#0+(byte) 9*(byte) $28+(byte) 8) ← (byte) 8
  to:main::@2_98
main::@2_98: scope:[main]  from main::@2_97
  [103] *((const byte*) main::SCREEN#0+(byte) $a*(byte) $28+(byte) 8) ← (byte) 8
  to:main::@2_99
main::@2_99: scope:[main]  from main::@2_98
  [104] *((const byte*) main::SCREEN#0+(byte) 9) ← (byte) 9
  to:main::@2_100
main::@2_100: scope:[main]  from main::@2_99
  [105] *((const byte*) main::SCREEN#0+(byte) 1*(byte) $28+(byte) 9) ← (byte) 9
  to:main::@2_101
main::@2_101: scope:[main]  from main::@2_100
  [106] *((const byte*) main::SCREEN#0+(byte) 2*(byte) $28+(byte) 9) ← (byte) 9
  to:main::@2_102
main::@2_102: scope:[main]  from main::@2_101
  [107] *((const byte*) main::SCREEN#0+(byte) 3*(byte) $28+(byte) 9) ← (byte) 9
  to:main::@2_103
main::@2_103: scope:[main]  from main::@2_102
  [108] *((const byte*) main::SCREEN#0+(byte) 4*(byte) $28+(byte) 9) ← (byte) 9
  to:main::@2_104
main::@2_104: scope:[main]  from main::@2_103
  [109] *((const byte*) main::SCREEN#0+(byte) 5*(byte) $28+(byte) 9) ← (byte) 9
  to:main::@2_105
main::@2_105: scope:[main]  from main::@2_104
  [110] *((const byte*) main::SCREEN#0+(byte) 6*(byte) $28+(byte) 9) ← (byte) 9
  to:main::@2_106
main::@2_106: scope:[main]  from main::@2_105
  [111] *((const byte*) main::SCREEN#0+(byte) 7*(byte) $28+(byte) 9) ← (byte) 9
  to:main::@2_107
main::@2_107: scope:[main]  from main::@2_106
  [112] *((const byte*) main::SCREEN#0+(byte) 8*(byte) $28+(byte) 9) ← (byte) 9
  to:main::@2_108
main::@2_108: scope:[main]  from main::@2_107
  [113] *((const byte*) main::SCREEN#0+(byte) 9*(byte) $28+(byte) 9) ← (byte) 9
  to:main::@2_109
main::@2_109: scope:[main]  from main::@2_108
  [114] *((const byte*) main::SCREEN#0+(byte) $a*(byte) $28+(byte) 9) ← (byte) 9
  to:main::@2_110
main::@2_110: scope:[main]  from main::@2_109
  [115] *((const byte*) main::SCREEN#0+(byte) $a) ← (byte) $a
  to:main::@2_111
main::@2_111: scope:[main]  from main::@2_110
  [116] *((const byte*) main::SCREEN#0+(byte) 1*(byte) $28+(byte) $a) ← (byte) $a
  to:main::@2_112
main::@2_112: scope:[main]  from main::@2_111
  [117] *((const byte*) main::SCREEN#0+(byte) 2*(byte) $28+(byte) $a) ← (byte) $a
  to:main::@2_113
main::@2_113: scope:[main]  from main::@2_112
  [118] *((const byte*) main::SCREEN#0+(byte) 3*(byte) $28+(byte) $a) ← (byte) $a
  to:main::@2_114
main::@2_114: scope:[main]  from main::@2_113
  [119] *((const byte*) main::SCREEN#0+(byte) 4*(byte) $28+(byte) $a) ← (byte) $a
  to:main::@2_115
main::@2_115: scope:[main]  from main::@2_114
  [120] *((const byte*) main::SCREEN#0+(byte) 5*(byte) $28+(byte) $a) ← (byte) $a
  to:main::@2_116
main::@2_116: scope:[main]  from main::@2_115
  [121] *((const byte*) main::SCREEN#0+(byte) 6*(byte) $28+(byte) $a) ← (byte) $a
  to:main::@2_117
main::@2_117: scope:[main]  from main::@2_116
  [122] *((const byte*) main::SCREEN#0+(byte) 7*(byte) $28+(byte) $a) ← (byte) $a
  to:main::@2_118
main::@2_118: scope:[main]  from main::@2_117
  [123] *((const byte*) main::SCREEN#0+(byte) 8*(byte) $28+(byte) $a) ← (byte) $a
  to:main::@2_119
main::@2_119: scope:[main]  from main::@2_118
  [124] *((const byte*) main::SCREEN#0+(byte) 9*(byte) $28+(byte) $a) ← (byte) $a
  to:main::@2_120
main::@2_120: scope:[main]  from main::@2_119
  [125] *((const byte*) main::SCREEN#0+(byte) $a*(byte) $28+(byte) $a) ← (byte) $a
  to:main::@return
main::@return: scope:[main]  from main::@2_120
  [126] return 
  to:@return


VARIABLE REGISTER WEIGHTS
(void()) main()
(byte*) main::SCREEN
(byte) main::line
(byte) main::x

Initial phi equivalence classes
Complete equivalence classes

INITIAL ASM
  // File Comments
// Fills the screen using two unrolled ranged for()-loops
  // Basic 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
    jmp b1
    // main::@1
  b1:
    // [5] *((const byte*) main::SCREEN#0) ← (byte) 0 -- _deref_pbuc1=vbuc2 
    lda #0
    sta SCREEN
    jmp b2_1
    // main::@2_1
  b2_1:
    // [6] *((const byte*) main::SCREEN#0+(byte) 1*(byte) $28) ← (byte) 0 -- _deref_pbuc1=vbuc2 
    lda #0
    sta SCREEN+1*$28
    jmp b2_2
    // main::@2_2
  b2_2:
    // [7] *((const byte*) main::SCREEN#0+(byte) 2*(byte) $28) ← (byte) 0 -- _deref_pbuc1=vbuc2 
    lda #0
    sta SCREEN+2*$28
    jmp b2_3
    // main::@2_3
  b2_3:
    // [8] *((const byte*) main::SCREEN#0+(byte) 3*(byte) $28) ← (byte) 0 -- _deref_pbuc1=vbuc2 
    lda #0
    sta SCREEN+3*$28
    jmp b2_4
    // main::@2_4
  b2_4:
    // [9] *((const byte*) main::SCREEN#0+(byte) 4*(byte) $28) ← (byte) 0 -- _deref_pbuc1=vbuc2 
    lda #0
    sta SCREEN+4*$28
    jmp b2_5
    // main::@2_5
  b2_5:
    // [10] *((const byte*) main::SCREEN#0+(byte) 5*(byte) $28) ← (byte) 0 -- _deref_pbuc1=vbuc2 
    lda #0
    sta SCREEN+5*$28
    jmp b2_6
    // main::@2_6
  b2_6:
    // [11] *((const byte*) main::SCREEN#0+(byte) 6*(byte) $28) ← (byte) 0 -- _deref_pbuc1=vbuc2 
    lda #0
    sta SCREEN+6*$28
    jmp b2_7
    // main::@2_7
  b2_7:
    // [12] *((const byte*) main::SCREEN#0+(byte) 7*(byte) $28) ← (byte) 0 -- _deref_pbuc1=vbuc2 
    lda #0
    sta SCREEN+7*$28
    jmp b2_8
    // main::@2_8
  b2_8:
    // [13] *((const byte*) main::SCREEN#0+(byte) 8*(byte) $28) ← (byte) 0 -- _deref_pbuc1=vbuc2 
    lda #0
    sta SCREEN+8*$28
    jmp b2_9
    // main::@2_9
  b2_9:
    // [14] *((const byte*) main::SCREEN#0+(byte) 9*(byte) $28) ← (byte) 0 -- _deref_pbuc1=vbuc2 
    lda #0
    sta SCREEN+9*$28
    jmp b2_10
    // main::@2_10
  b2_10:
    // [15] *((const byte*) main::SCREEN#0+(byte) $a*(byte) $28) ← (byte) 0 -- _deref_pbuc1=vbuc2 
    lda #0
    sta SCREEN+$a*$28
    jmp b2_11
    // main::@2_11
  b2_11:
    // [16] *((const byte*) main::SCREEN#0+(byte) 1) ← (byte) 1 -- _deref_pbuc1=vbuc2 
    lda #1
    sta SCREEN+1
    jmp b2_12
    // main::@2_12
  b2_12:
    // [17] *((const byte*) main::SCREEN#0+(byte) 1*(byte) $28+(byte) 1) ← (byte) 1 -- _deref_pbuc1=vbuc2 
    lda #1
    sta SCREEN+1*$28+1
    jmp b2_13
    // main::@2_13
  b2_13:
    // [18] *((const byte*) main::SCREEN#0+(byte) 2*(byte) $28+(byte) 1) ← (byte) 1 -- _deref_pbuc1=vbuc2 
    lda #1
    sta SCREEN+2*$28+1
    jmp b2_14
    // main::@2_14
  b2_14:
    // [19] *((const byte*) main::SCREEN#0+(byte) 3*(byte) $28+(byte) 1) ← (byte) 1 -- _deref_pbuc1=vbuc2 
    lda #1
    sta SCREEN+3*$28+1
    jmp b2_15
    // main::@2_15
  b2_15:
    // [20] *((const byte*) main::SCREEN#0+(byte) 4*(byte) $28+(byte) 1) ← (byte) 1 -- _deref_pbuc1=vbuc2 
    lda #1
    sta SCREEN+4*$28+1
    jmp b2_16
    // main::@2_16
  b2_16:
    // [21] *((const byte*) main::SCREEN#0+(byte) 5*(byte) $28+(byte) 1) ← (byte) 1 -- _deref_pbuc1=vbuc2 
    lda #1
    sta SCREEN+5*$28+1
    jmp b2_17
    // main::@2_17
  b2_17:
    // [22] *((const byte*) main::SCREEN#0+(byte) 6*(byte) $28+(byte) 1) ← (byte) 1 -- _deref_pbuc1=vbuc2 
    lda #1
    sta SCREEN+6*$28+1
    jmp b2_18
    // main::@2_18
  b2_18:
    // [23] *((const byte*) main::SCREEN#0+(byte) 7*(byte) $28+(byte) 1) ← (byte) 1 -- _deref_pbuc1=vbuc2 
    lda #1
    sta SCREEN+7*$28+1
    jmp b2_19
    // main::@2_19
  b2_19:
    // [24] *((const byte*) main::SCREEN#0+(byte) 8*(byte) $28+(byte) 1) ← (byte) 1 -- _deref_pbuc1=vbuc2 
    lda #1
    sta SCREEN+8*$28+1
    jmp b2_20
    // main::@2_20
  b2_20:
    // [25] *((const byte*) main::SCREEN#0+(byte) 9*(byte) $28+(byte) 1) ← (byte) 1 -- _deref_pbuc1=vbuc2 
    lda #1
    sta SCREEN+9*$28+1
    jmp b2_21
    // main::@2_21
  b2_21:
    // [26] *((const byte*) main::SCREEN#0+(byte) $a*(byte) $28+(byte) 1) ← (byte) 1 -- _deref_pbuc1=vbuc2 
    lda #1
    sta SCREEN+$a*$28+1
    jmp b2_22
    // main::@2_22
  b2_22:
    // [27] *((const byte*) main::SCREEN#0+(byte) 2) ← (byte) 2 -- _deref_pbuc1=vbuc2 
    lda #2
    sta SCREEN+2
    jmp b2_23
    // main::@2_23
  b2_23:
    // [28] *((const byte*) main::SCREEN#0+(byte) 1*(byte) $28+(byte) 2) ← (byte) 2 -- _deref_pbuc1=vbuc2 
    lda #2
    sta SCREEN+1*$28+2
    jmp b2_24
    // main::@2_24
  b2_24:
    // [29] *((const byte*) main::SCREEN#0+(byte) 2*(byte) $28+(byte) 2) ← (byte) 2 -- _deref_pbuc1=vbuc2 
    lda #2
    sta SCREEN+2*$28+2
    jmp b2_25
    // main::@2_25
  b2_25:
    // [30] *((const byte*) main::SCREEN#0+(byte) 3*(byte) $28+(byte) 2) ← (byte) 2 -- _deref_pbuc1=vbuc2 
    lda #2
    sta SCREEN+3*$28+2
    jmp b2_26
    // main::@2_26
  b2_26:
    // [31] *((const byte*) main::SCREEN#0+(byte) 4*(byte) $28+(byte) 2) ← (byte) 2 -- _deref_pbuc1=vbuc2 
    lda #2
    sta SCREEN+4*$28+2
    jmp b2_27
    // main::@2_27
  b2_27:
    // [32] *((const byte*) main::SCREEN#0+(byte) 5*(byte) $28+(byte) 2) ← (byte) 2 -- _deref_pbuc1=vbuc2 
    lda #2
    sta SCREEN+5*$28+2
    jmp b2_28
    // main::@2_28
  b2_28:
    // [33] *((const byte*) main::SCREEN#0+(byte) 6*(byte) $28+(byte) 2) ← (byte) 2 -- _deref_pbuc1=vbuc2 
    lda #2
    sta SCREEN+6*$28+2
    jmp b2_29
    // main::@2_29
  b2_29:
    // [34] *((const byte*) main::SCREEN#0+(byte) 7*(byte) $28+(byte) 2) ← (byte) 2 -- _deref_pbuc1=vbuc2 
    lda #2
    sta SCREEN+7*$28+2
    jmp b2_30
    // main::@2_30
  b2_30:
    // [35] *((const byte*) main::SCREEN#0+(byte) 8*(byte) $28+(byte) 2) ← (byte) 2 -- _deref_pbuc1=vbuc2 
    lda #2
    sta SCREEN+8*$28+2
    jmp b2_31
    // main::@2_31
  b2_31:
    // [36] *((const byte*) main::SCREEN#0+(byte) 9*(byte) $28+(byte) 2) ← (byte) 2 -- _deref_pbuc1=vbuc2 
    lda #2
    sta SCREEN+9*$28+2
    jmp b2_32
    // main::@2_32
  b2_32:
    // [37] *((const byte*) main::SCREEN#0+(byte) $a*(byte) $28+(byte) 2) ← (byte) 2 -- _deref_pbuc1=vbuc2 
    lda #2
    sta SCREEN+$a*$28+2
    jmp b2_33
    // main::@2_33
  b2_33:
    // [38] *((const byte*) main::SCREEN#0+(byte) 3) ← (byte) 3 -- _deref_pbuc1=vbuc2 
    lda #3
    sta SCREEN+3
    jmp b2_34
    // main::@2_34
  b2_34:
    // [39] *((const byte*) main::SCREEN#0+(byte) 1*(byte) $28+(byte) 3) ← (byte) 3 -- _deref_pbuc1=vbuc2 
    lda #3
    sta SCREEN+1*$28+3
    jmp b2_35
    // main::@2_35
  b2_35:
    // [40] *((const byte*) main::SCREEN#0+(byte) 2*(byte) $28+(byte) 3) ← (byte) 3 -- _deref_pbuc1=vbuc2 
    lda #3
    sta SCREEN+2*$28+3
    jmp b2_36
    // main::@2_36
  b2_36:
    // [41] *((const byte*) main::SCREEN#0+(byte) 3*(byte) $28+(byte) 3) ← (byte) 3 -- _deref_pbuc1=vbuc2 
    lda #3
    sta SCREEN+3*$28+3
    jmp b2_37
    // main::@2_37
  b2_37:
    // [42] *((const byte*) main::SCREEN#0+(byte) 4*(byte) $28+(byte) 3) ← (byte) 3 -- _deref_pbuc1=vbuc2 
    lda #3
    sta SCREEN+4*$28+3
    jmp b2_38
    // main::@2_38
  b2_38:
    // [43] *((const byte*) main::SCREEN#0+(byte) 5*(byte) $28+(byte) 3) ← (byte) 3 -- _deref_pbuc1=vbuc2 
    lda #3
    sta SCREEN+5*$28+3
    jmp b2_39
    // main::@2_39
  b2_39:
    // [44] *((const byte*) main::SCREEN#0+(byte) 6*(byte) $28+(byte) 3) ← (byte) 3 -- _deref_pbuc1=vbuc2 
    lda #3
    sta SCREEN+6*$28+3
    jmp b2_40
    // main::@2_40
  b2_40:
    // [45] *((const byte*) main::SCREEN#0+(byte) 7*(byte) $28+(byte) 3) ← (byte) 3 -- _deref_pbuc1=vbuc2 
    lda #3
    sta SCREEN+7*$28+3
    jmp b2_41
    // main::@2_41
  b2_41:
    // [46] *((const byte*) main::SCREEN#0+(byte) 8*(byte) $28+(byte) 3) ← (byte) 3 -- _deref_pbuc1=vbuc2 
    lda #3
    sta SCREEN+8*$28+3
    jmp b2_42
    // main::@2_42
  b2_42:
    // [47] *((const byte*) main::SCREEN#0+(byte) 9*(byte) $28+(byte) 3) ← (byte) 3 -- _deref_pbuc1=vbuc2 
    lda #3
    sta SCREEN+9*$28+3
    jmp b2_43
    // main::@2_43
  b2_43:
    // [48] *((const byte*) main::SCREEN#0+(byte) $a*(byte) $28+(byte) 3) ← (byte) 3 -- _deref_pbuc1=vbuc2 
    lda #3
    sta SCREEN+$a*$28+3
    jmp b2_44
    // main::@2_44
  b2_44:
    // [49] *((const byte*) main::SCREEN#0+(byte) 4) ← (byte) 4 -- _deref_pbuc1=vbuc2 
    lda #4
    sta SCREEN+4
    jmp b2_45
    // main::@2_45
  b2_45:
    // [50] *((const byte*) main::SCREEN#0+(byte) 1*(byte) $28+(byte) 4) ← (byte) 4 -- _deref_pbuc1=vbuc2 
    lda #4
    sta SCREEN+1*$28+4
    jmp b2_46
    // main::@2_46
  b2_46:
    // [51] *((const byte*) main::SCREEN#0+(byte) 2*(byte) $28+(byte) 4) ← (byte) 4 -- _deref_pbuc1=vbuc2 
    lda #4
    sta SCREEN+2*$28+4
    jmp b2_47
    // main::@2_47
  b2_47:
    // [52] *((const byte*) main::SCREEN#0+(byte) 3*(byte) $28+(byte) 4) ← (byte) 4 -- _deref_pbuc1=vbuc2 
    lda #4
    sta SCREEN+3*$28+4
    jmp b2_48
    // main::@2_48
  b2_48:
    // [53] *((const byte*) main::SCREEN#0+(byte) 4*(byte) $28+(byte) 4) ← (byte) 4 -- _deref_pbuc1=vbuc2 
    lda #4
    sta SCREEN+4*$28+4
    jmp b2_49
    // main::@2_49
  b2_49:
    // [54] *((const byte*) main::SCREEN#0+(byte) 5*(byte) $28+(byte) 4) ← (byte) 4 -- _deref_pbuc1=vbuc2 
    lda #4
    sta SCREEN+5*$28+4
    jmp b2_50
    // main::@2_50
  b2_50:
    // [55] *((const byte*) main::SCREEN#0+(byte) 6*(byte) $28+(byte) 4) ← (byte) 4 -- _deref_pbuc1=vbuc2 
    lda #4
    sta SCREEN+6*$28+4
    jmp b2_51
    // main::@2_51
  b2_51:
    // [56] *((const byte*) main::SCREEN#0+(byte) 7*(byte) $28+(byte) 4) ← (byte) 4 -- _deref_pbuc1=vbuc2 
    lda #4
    sta SCREEN+7*$28+4
    jmp b2_52
    // main::@2_52
  b2_52:
    // [57] *((const byte*) main::SCREEN#0+(byte) 8*(byte) $28+(byte) 4) ← (byte) 4 -- _deref_pbuc1=vbuc2 
    lda #4
    sta SCREEN+8*$28+4
    jmp b2_53
    // main::@2_53
  b2_53:
    // [58] *((const byte*) main::SCREEN#0+(byte) 9*(byte) $28+(byte) 4) ← (byte) 4 -- _deref_pbuc1=vbuc2 
    lda #4
    sta SCREEN+9*$28+4
    jmp b2_54
    // main::@2_54
  b2_54:
    // [59] *((const byte*) main::SCREEN#0+(byte) $a*(byte) $28+(byte) 4) ← (byte) 4 -- _deref_pbuc1=vbuc2 
    lda #4
    sta SCREEN+$a*$28+4
    jmp b2_55
    // main::@2_55
  b2_55:
    // [60] *((const byte*) main::SCREEN#0+(byte) 5) ← (byte) 5 -- _deref_pbuc1=vbuc2 
    lda #5
    sta SCREEN+5
    jmp b2_56
    // main::@2_56
  b2_56:
    // [61] *((const byte*) main::SCREEN#0+(byte) 1*(byte) $28+(byte) 5) ← (byte) 5 -- _deref_pbuc1=vbuc2 
    lda #5
    sta SCREEN+1*$28+5
    jmp b2_57
    // main::@2_57
  b2_57:
    // [62] *((const byte*) main::SCREEN#0+(byte) 2*(byte) $28+(byte) 5) ← (byte) 5 -- _deref_pbuc1=vbuc2 
    lda #5
    sta SCREEN+2*$28+5
    jmp b2_58
    // main::@2_58
  b2_58:
    // [63] *((const byte*) main::SCREEN#0+(byte) 3*(byte) $28+(byte) 5) ← (byte) 5 -- _deref_pbuc1=vbuc2 
    lda #5
    sta SCREEN+3*$28+5
    jmp b2_59
    // main::@2_59
  b2_59:
    // [64] *((const byte*) main::SCREEN#0+(byte) 4*(byte) $28+(byte) 5) ← (byte) 5 -- _deref_pbuc1=vbuc2 
    lda #5
    sta SCREEN+4*$28+5
    jmp b2_60
    // main::@2_60
  b2_60:
    // [65] *((const byte*) main::SCREEN#0+(byte) 5*(byte) $28+(byte) 5) ← (byte) 5 -- _deref_pbuc1=vbuc2 
    lda #5
    sta SCREEN+5*$28+5
    jmp b2_61
    // main::@2_61
  b2_61:
    // [66] *((const byte*) main::SCREEN#0+(byte) 6*(byte) $28+(byte) 5) ← (byte) 5 -- _deref_pbuc1=vbuc2 
    lda #5
    sta SCREEN+6*$28+5
    jmp b2_62
    // main::@2_62
  b2_62:
    // [67] *((const byte*) main::SCREEN#0+(byte) 7*(byte) $28+(byte) 5) ← (byte) 5 -- _deref_pbuc1=vbuc2 
    lda #5
    sta SCREEN+7*$28+5
    jmp b2_63
    // main::@2_63
  b2_63:
    // [68] *((const byte*) main::SCREEN#0+(byte) 8*(byte) $28+(byte) 5) ← (byte) 5 -- _deref_pbuc1=vbuc2 
    lda #5
    sta SCREEN+8*$28+5
    jmp b2_64
    // main::@2_64
  b2_64:
    // [69] *((const byte*) main::SCREEN#0+(byte) 9*(byte) $28+(byte) 5) ← (byte) 5 -- _deref_pbuc1=vbuc2 
    lda #5
    sta SCREEN+9*$28+5
    jmp b2_65
    // main::@2_65
  b2_65:
    // [70] *((const byte*) main::SCREEN#0+(byte) $a*(byte) $28+(byte) 5) ← (byte) 5 -- _deref_pbuc1=vbuc2 
    lda #5
    sta SCREEN+$a*$28+5
    jmp b2_66
    // main::@2_66
  b2_66:
    // [71] *((const byte*) main::SCREEN#0+(byte) 6) ← (byte) 6 -- _deref_pbuc1=vbuc2 
    lda #6
    sta SCREEN+6
    jmp b2_67
    // main::@2_67
  b2_67:
    // [72] *((const byte*) main::SCREEN#0+(byte) 1*(byte) $28+(byte) 6) ← (byte) 6 -- _deref_pbuc1=vbuc2 
    lda #6
    sta SCREEN+1*$28+6
    jmp b2_68
    // main::@2_68
  b2_68:
    // [73] *((const byte*) main::SCREEN#0+(byte) 2*(byte) $28+(byte) 6) ← (byte) 6 -- _deref_pbuc1=vbuc2 
    lda #6
    sta SCREEN+2*$28+6
    jmp b2_69
    // main::@2_69
  b2_69:
    // [74] *((const byte*) main::SCREEN#0+(byte) 3*(byte) $28+(byte) 6) ← (byte) 6 -- _deref_pbuc1=vbuc2 
    lda #6
    sta SCREEN+3*$28+6
    jmp b2_70
    // main::@2_70
  b2_70:
    // [75] *((const byte*) main::SCREEN#0+(byte) 4*(byte) $28+(byte) 6) ← (byte) 6 -- _deref_pbuc1=vbuc2 
    lda #6
    sta SCREEN+4*$28+6
    jmp b2_71
    // main::@2_71
  b2_71:
    // [76] *((const byte*) main::SCREEN#0+(byte) 5*(byte) $28+(byte) 6) ← (byte) 6 -- _deref_pbuc1=vbuc2 
    lda #6
    sta SCREEN+5*$28+6
    jmp b2_72
    // main::@2_72
  b2_72:
    // [77] *((const byte*) main::SCREEN#0+(byte) 6*(byte) $28+(byte) 6) ← (byte) 6 -- _deref_pbuc1=vbuc2 
    lda #6
    sta SCREEN+6*$28+6
    jmp b2_73
    // main::@2_73
  b2_73:
    // [78] *((const byte*) main::SCREEN#0+(byte) 7*(byte) $28+(byte) 6) ← (byte) 6 -- _deref_pbuc1=vbuc2 
    lda #6
    sta SCREEN+7*$28+6
    jmp b2_74
    // main::@2_74
  b2_74:
    // [79] *((const byte*) main::SCREEN#0+(byte) 8*(byte) $28+(byte) 6) ← (byte) 6 -- _deref_pbuc1=vbuc2 
    lda #6
    sta SCREEN+8*$28+6
    jmp b2_75
    // main::@2_75
  b2_75:
    // [80] *((const byte*) main::SCREEN#0+(byte) 9*(byte) $28+(byte) 6) ← (byte) 6 -- _deref_pbuc1=vbuc2 
    lda #6
    sta SCREEN+9*$28+6
    jmp b2_76
    // main::@2_76
  b2_76:
    // [81] *((const byte*) main::SCREEN#0+(byte) $a*(byte) $28+(byte) 6) ← (byte) 6 -- _deref_pbuc1=vbuc2 
    lda #6
    sta SCREEN+$a*$28+6
    jmp b2_77
    // main::@2_77
  b2_77:
    // [82] *((const byte*) main::SCREEN#0+(byte) 7) ← (byte) 7 -- _deref_pbuc1=vbuc2 
    lda #7
    sta SCREEN+7
    jmp b2_78
    // main::@2_78
  b2_78:
    // [83] *((const byte*) main::SCREEN#0+(byte) 1*(byte) $28+(byte) 7) ← (byte) 7 -- _deref_pbuc1=vbuc2 
    lda #7
    sta SCREEN+1*$28+7
    jmp b2_79
    // main::@2_79
  b2_79:
    // [84] *((const byte*) main::SCREEN#0+(byte) 2*(byte) $28+(byte) 7) ← (byte) 7 -- _deref_pbuc1=vbuc2 
    lda #7
    sta SCREEN+2*$28+7
    jmp b2_80
    // main::@2_80
  b2_80:
    // [85] *((const byte*) main::SCREEN#0+(byte) 3*(byte) $28+(byte) 7) ← (byte) 7 -- _deref_pbuc1=vbuc2 
    lda #7
    sta SCREEN+3*$28+7
    jmp b2_81
    // main::@2_81
  b2_81:
    // [86] *((const byte*) main::SCREEN#0+(byte) 4*(byte) $28+(byte) 7) ← (byte) 7 -- _deref_pbuc1=vbuc2 
    lda #7
    sta SCREEN+4*$28+7
    jmp b2_82
    // main::@2_82
  b2_82:
    // [87] *((const byte*) main::SCREEN#0+(byte) 5*(byte) $28+(byte) 7) ← (byte) 7 -- _deref_pbuc1=vbuc2 
    lda #7
    sta SCREEN+5*$28+7
    jmp b2_83
    // main::@2_83
  b2_83:
    // [88] *((const byte*) main::SCREEN#0+(byte) 6*(byte) $28+(byte) 7) ← (byte) 7 -- _deref_pbuc1=vbuc2 
    lda #7
    sta SCREEN+6*$28+7
    jmp b2_84
    // main::@2_84
  b2_84:
    // [89] *((const byte*) main::SCREEN#0+(byte) 7*(byte) $28+(byte) 7) ← (byte) 7 -- _deref_pbuc1=vbuc2 
    lda #7
    sta SCREEN+7*$28+7
    jmp b2_85
    // main::@2_85
  b2_85:
    // [90] *((const byte*) main::SCREEN#0+(byte) 8*(byte) $28+(byte) 7) ← (byte) 7 -- _deref_pbuc1=vbuc2 
    lda #7
    sta SCREEN+8*$28+7
    jmp b2_86
    // main::@2_86
  b2_86:
    // [91] *((const byte*) main::SCREEN#0+(byte) 9*(byte) $28+(byte) 7) ← (byte) 7 -- _deref_pbuc1=vbuc2 
    lda #7
    sta SCREEN+9*$28+7
    jmp b2_87
    // main::@2_87
  b2_87:
    // [92] *((const byte*) main::SCREEN#0+(byte) $a*(byte) $28+(byte) 7) ← (byte) 7 -- _deref_pbuc1=vbuc2 
    lda #7
    sta SCREEN+$a*$28+7
    jmp b2_88
    // main::@2_88
  b2_88:
    // [93] *((const byte*) main::SCREEN#0+(byte) 8) ← (byte) 8 -- _deref_pbuc1=vbuc2 
    lda #8
    sta SCREEN+8
    jmp b2_89
    // main::@2_89
  b2_89:
    // [94] *((const byte*) main::SCREEN#0+(byte) 1*(byte) $28+(byte) 8) ← (byte) 8 -- _deref_pbuc1=vbuc2 
    lda #8
    sta SCREEN+1*$28+8
    jmp b2_90
    // main::@2_90
  b2_90:
    // [95] *((const byte*) main::SCREEN#0+(byte) 2*(byte) $28+(byte) 8) ← (byte) 8 -- _deref_pbuc1=vbuc2 
    lda #8
    sta SCREEN+2*$28+8
    jmp b2_91
    // main::@2_91
  b2_91:
    // [96] *((const byte*) main::SCREEN#0+(byte) 3*(byte) $28+(byte) 8) ← (byte) 8 -- _deref_pbuc1=vbuc2 
    lda #8
    sta SCREEN+3*$28+8
    jmp b2_92
    // main::@2_92
  b2_92:
    // [97] *((const byte*) main::SCREEN#0+(byte) 4*(byte) $28+(byte) 8) ← (byte) 8 -- _deref_pbuc1=vbuc2 
    lda #8
    sta SCREEN+4*$28+8
    jmp b2_93
    // main::@2_93
  b2_93:
    // [98] *((const byte*) main::SCREEN#0+(byte) 5*(byte) $28+(byte) 8) ← (byte) 8 -- _deref_pbuc1=vbuc2 
    lda #8
    sta SCREEN+5*$28+8
    jmp b2_94
    // main::@2_94
  b2_94:
    // [99] *((const byte*) main::SCREEN#0+(byte) 6*(byte) $28+(byte) 8) ← (byte) 8 -- _deref_pbuc1=vbuc2 
    lda #8
    sta SCREEN+6*$28+8
    jmp b2_95
    // main::@2_95
  b2_95:
    // [100] *((const byte*) main::SCREEN#0+(byte) 7*(byte) $28+(byte) 8) ← (byte) 8 -- _deref_pbuc1=vbuc2 
    lda #8
    sta SCREEN+7*$28+8
    jmp b2_96
    // main::@2_96
  b2_96:
    // [101] *((const byte*) main::SCREEN#0+(byte) 8*(byte) $28+(byte) 8) ← (byte) 8 -- _deref_pbuc1=vbuc2 
    lda #8
    sta SCREEN+8*$28+8
    jmp b2_97
    // main::@2_97
  b2_97:
    // [102] *((const byte*) main::SCREEN#0+(byte) 9*(byte) $28+(byte) 8) ← (byte) 8 -- _deref_pbuc1=vbuc2 
    lda #8
    sta SCREEN+9*$28+8
    jmp b2_98
    // main::@2_98
  b2_98:
    // [103] *((const byte*) main::SCREEN#0+(byte) $a*(byte) $28+(byte) 8) ← (byte) 8 -- _deref_pbuc1=vbuc2 
    lda #8
    sta SCREEN+$a*$28+8
    jmp b2_99
    // main::@2_99
  b2_99:
    // [104] *((const byte*) main::SCREEN#0+(byte) 9) ← (byte) 9 -- _deref_pbuc1=vbuc2 
    lda #9
    sta SCREEN+9
    jmp b2_100
    // main::@2_100
  b2_100:
    // [105] *((const byte*) main::SCREEN#0+(byte) 1*(byte) $28+(byte) 9) ← (byte) 9 -- _deref_pbuc1=vbuc2 
    lda #9
    sta SCREEN+1*$28+9
    jmp b2_101
    // main::@2_101
  b2_101:
    // [106] *((const byte*) main::SCREEN#0+(byte) 2*(byte) $28+(byte) 9) ← (byte) 9 -- _deref_pbuc1=vbuc2 
    lda #9
    sta SCREEN+2*$28+9
    jmp b2_102
    // main::@2_102
  b2_102:
    // [107] *((const byte*) main::SCREEN#0+(byte) 3*(byte) $28+(byte) 9) ← (byte) 9 -- _deref_pbuc1=vbuc2 
    lda #9
    sta SCREEN+3*$28+9
    jmp b2_103
    // main::@2_103
  b2_103:
    // [108] *((const byte*) main::SCREEN#0+(byte) 4*(byte) $28+(byte) 9) ← (byte) 9 -- _deref_pbuc1=vbuc2 
    lda #9
    sta SCREEN+4*$28+9
    jmp b2_104
    // main::@2_104
  b2_104:
    // [109] *((const byte*) main::SCREEN#0+(byte) 5*(byte) $28+(byte) 9) ← (byte) 9 -- _deref_pbuc1=vbuc2 
    lda #9
    sta SCREEN+5*$28+9
    jmp b2_105
    // main::@2_105
  b2_105:
    // [110] *((const byte*) main::SCREEN#0+(byte) 6*(byte) $28+(byte) 9) ← (byte) 9 -- _deref_pbuc1=vbuc2 
    lda #9
    sta SCREEN+6*$28+9
    jmp b2_106
    // main::@2_106
  b2_106:
    // [111] *((const byte*) main::SCREEN#0+(byte) 7*(byte) $28+(byte) 9) ← (byte) 9 -- _deref_pbuc1=vbuc2 
    lda #9
    sta SCREEN+7*$28+9
    jmp b2_107
    // main::@2_107
  b2_107:
    // [112] *((const byte*) main::SCREEN#0+(byte) 8*(byte) $28+(byte) 9) ← (byte) 9 -- _deref_pbuc1=vbuc2 
    lda #9
    sta SCREEN+8*$28+9
    jmp b2_108
    // main::@2_108
  b2_108:
    // [113] *((const byte*) main::SCREEN#0+(byte) 9*(byte) $28+(byte) 9) ← (byte) 9 -- _deref_pbuc1=vbuc2 
    lda #9
    sta SCREEN+9*$28+9
    jmp b2_109
    // main::@2_109
  b2_109:
    // [114] *((const byte*) main::SCREEN#0+(byte) $a*(byte) $28+(byte) 9) ← (byte) 9 -- _deref_pbuc1=vbuc2 
    lda #9
    sta SCREEN+$a*$28+9
    jmp b2_110
    // main::@2_110
  b2_110:
    // [115] *((const byte*) main::SCREEN#0+(byte) $a) ← (byte) $a -- _deref_pbuc1=vbuc2 
    lda #$a
    sta SCREEN+$a
    jmp b2_111
    // main::@2_111
  b2_111:
    // [116] *((const byte*) main::SCREEN#0+(byte) 1*(byte) $28+(byte) $a) ← (byte) $a -- _deref_pbuc1=vbuc2 
    lda #$a
    sta SCREEN+1*$28+$a
    jmp b2_112
    // main::@2_112
  b2_112:
    // [117] *((const byte*) main::SCREEN#0+(byte) 2*(byte) $28+(byte) $a) ← (byte) $a -- _deref_pbuc1=vbuc2 
    lda #$a
    sta SCREEN+2*$28+$a
    jmp b2_113
    // main::@2_113
  b2_113:
    // [118] *((const byte*) main::SCREEN#0+(byte) 3*(byte) $28+(byte) $a) ← (byte) $a -- _deref_pbuc1=vbuc2 
    lda #$a
    sta SCREEN+3*$28+$a
    jmp b2_114
    // main::@2_114
  b2_114:
    // [119] *((const byte*) main::SCREEN#0+(byte) 4*(byte) $28+(byte) $a) ← (byte) $a -- _deref_pbuc1=vbuc2 
    lda #$a
    sta SCREEN+4*$28+$a
    jmp b2_115
    // main::@2_115
  b2_115:
    // [120] *((const byte*) main::SCREEN#0+(byte) 5*(byte) $28+(byte) $a) ← (byte) $a -- _deref_pbuc1=vbuc2 
    lda #$a
    sta SCREEN+5*$28+$a
    jmp b2_116
    // main::@2_116
  b2_116:
    // [121] *((const byte*) main::SCREEN#0+(byte) 6*(byte) $28+(byte) $a) ← (byte) $a -- _deref_pbuc1=vbuc2 
    lda #$a
    sta SCREEN+6*$28+$a
    jmp b2_117
    // main::@2_117
  b2_117:
    // [122] *((const byte*) main::SCREEN#0+(byte) 7*(byte) $28+(byte) $a) ← (byte) $a -- _deref_pbuc1=vbuc2 
    lda #$a
    sta SCREEN+7*$28+$a
    jmp b2_118
    // main::@2_118
  b2_118:
    // [123] *((const byte*) main::SCREEN#0+(byte) 8*(byte) $28+(byte) $a) ← (byte) $a -- _deref_pbuc1=vbuc2 
    lda #$a
    sta SCREEN+8*$28+$a
    jmp b2_119
    // main::@2_119
  b2_119:
    // [124] *((const byte*) main::SCREEN#0+(byte) 9*(byte) $28+(byte) $a) ← (byte) $a -- _deref_pbuc1=vbuc2 
    lda #$a
    sta SCREEN+9*$28+$a
    jmp b2_120
    // main::@2_120
  b2_120:
    // [125] *((const byte*) main::SCREEN#0+(byte) $a*(byte) $28+(byte) $a) ← (byte) $a -- _deref_pbuc1=vbuc2 
    lda #$a
    sta SCREEN+$a*$28+$a
    jmp breturn
    // main::@return
  breturn:
    // [126] return 
    rts
}
  // File Data

REGISTER UPLIFT POTENTIAL REGISTERS
Statement [5] *((const byte*) main::SCREEN#0) ← (byte) 0 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [6] *((const byte*) main::SCREEN#0+(byte) 1*(byte) $28) ← (byte) 0 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [7] *((const byte*) main::SCREEN#0+(byte) 2*(byte) $28) ← (byte) 0 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [8] *((const byte*) main::SCREEN#0+(byte) 3*(byte) $28) ← (byte) 0 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [9] *((const byte*) main::SCREEN#0+(byte) 4*(byte) $28) ← (byte) 0 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [10] *((const byte*) main::SCREEN#0+(byte) 5*(byte) $28) ← (byte) 0 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [11] *((const byte*) main::SCREEN#0+(byte) 6*(byte) $28) ← (byte) 0 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [12] *((const byte*) main::SCREEN#0+(byte) 7*(byte) $28) ← (byte) 0 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [13] *((const byte*) main::SCREEN#0+(byte) 8*(byte) $28) ← (byte) 0 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [14] *((const byte*) main::SCREEN#0+(byte) 9*(byte) $28) ← (byte) 0 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [15] *((const byte*) main::SCREEN#0+(byte) $a*(byte) $28) ← (byte) 0 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [16] *((const byte*) main::SCREEN#0+(byte) 1) ← (byte) 1 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [17] *((const byte*) main::SCREEN#0+(byte) 1*(byte) $28+(byte) 1) ← (byte) 1 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [18] *((const byte*) main::SCREEN#0+(byte) 2*(byte) $28+(byte) 1) ← (byte) 1 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [19] *((const byte*) main::SCREEN#0+(byte) 3*(byte) $28+(byte) 1) ← (byte) 1 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [20] *((const byte*) main::SCREEN#0+(byte) 4*(byte) $28+(byte) 1) ← (byte) 1 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [21] *((const byte*) main::SCREEN#0+(byte) 5*(byte) $28+(byte) 1) ← (byte) 1 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [22] *((const byte*) main::SCREEN#0+(byte) 6*(byte) $28+(byte) 1) ← (byte) 1 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [23] *((const byte*) main::SCREEN#0+(byte) 7*(byte) $28+(byte) 1) ← (byte) 1 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [24] *((const byte*) main::SCREEN#0+(byte) 8*(byte) $28+(byte) 1) ← (byte) 1 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [25] *((const byte*) main::SCREEN#0+(byte) 9*(byte) $28+(byte) 1) ← (byte) 1 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [26] *((const byte*) main::SCREEN#0+(byte) $a*(byte) $28+(byte) 1) ← (byte) 1 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [27] *((const byte*) main::SCREEN#0+(byte) 2) ← (byte) 2 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [28] *((const byte*) main::SCREEN#0+(byte) 1*(byte) $28+(byte) 2) ← (byte) 2 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [29] *((const byte*) main::SCREEN#0+(byte) 2*(byte) $28+(byte) 2) ← (byte) 2 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [30] *((const byte*) main::SCREEN#0+(byte) 3*(byte) $28+(byte) 2) ← (byte) 2 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [31] *((const byte*) main::SCREEN#0+(byte) 4*(byte) $28+(byte) 2) ← (byte) 2 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [32] *((const byte*) main::SCREEN#0+(byte) 5*(byte) $28+(byte) 2) ← (byte) 2 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [33] *((const byte*) main::SCREEN#0+(byte) 6*(byte) $28+(byte) 2) ← (byte) 2 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [34] *((const byte*) main::SCREEN#0+(byte) 7*(byte) $28+(byte) 2) ← (byte) 2 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [35] *((const byte*) main::SCREEN#0+(byte) 8*(byte) $28+(byte) 2) ← (byte) 2 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [36] *((const byte*) main::SCREEN#0+(byte) 9*(byte) $28+(byte) 2) ← (byte) 2 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [37] *((const byte*) main::SCREEN#0+(byte) $a*(byte) $28+(byte) 2) ← (byte) 2 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [38] *((const byte*) main::SCREEN#0+(byte) 3) ← (byte) 3 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [39] *((const byte*) main::SCREEN#0+(byte) 1*(byte) $28+(byte) 3) ← (byte) 3 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [40] *((const byte*) main::SCREEN#0+(byte) 2*(byte) $28+(byte) 3) ← (byte) 3 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [41] *((const byte*) main::SCREEN#0+(byte) 3*(byte) $28+(byte) 3) ← (byte) 3 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [42] *((const byte*) main::SCREEN#0+(byte) 4*(byte) $28+(byte) 3) ← (byte) 3 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [43] *((const byte*) main::SCREEN#0+(byte) 5*(byte) $28+(byte) 3) ← (byte) 3 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [44] *((const byte*) main::SCREEN#0+(byte) 6*(byte) $28+(byte) 3) ← (byte) 3 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [45] *((const byte*) main::SCREEN#0+(byte) 7*(byte) $28+(byte) 3) ← (byte) 3 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [46] *((const byte*) main::SCREEN#0+(byte) 8*(byte) $28+(byte) 3) ← (byte) 3 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [47] *((const byte*) main::SCREEN#0+(byte) 9*(byte) $28+(byte) 3) ← (byte) 3 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [48] *((const byte*) main::SCREEN#0+(byte) $a*(byte) $28+(byte) 3) ← (byte) 3 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [49] *((const byte*) main::SCREEN#0+(byte) 4) ← (byte) 4 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [50] *((const byte*) main::SCREEN#0+(byte) 1*(byte) $28+(byte) 4) ← (byte) 4 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [51] *((const byte*) main::SCREEN#0+(byte) 2*(byte) $28+(byte) 4) ← (byte) 4 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [52] *((const byte*) main::SCREEN#0+(byte) 3*(byte) $28+(byte) 4) ← (byte) 4 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [53] *((const byte*) main::SCREEN#0+(byte) 4*(byte) $28+(byte) 4) ← (byte) 4 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [54] *((const byte*) main::SCREEN#0+(byte) 5*(byte) $28+(byte) 4) ← (byte) 4 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [55] *((const byte*) main::SCREEN#0+(byte) 6*(byte) $28+(byte) 4) ← (byte) 4 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [56] *((const byte*) main::SCREEN#0+(byte) 7*(byte) $28+(byte) 4) ← (byte) 4 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [57] *((const byte*) main::SCREEN#0+(byte) 8*(byte) $28+(byte) 4) ← (byte) 4 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [58] *((const byte*) main::SCREEN#0+(byte) 9*(byte) $28+(byte) 4) ← (byte) 4 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [59] *((const byte*) main::SCREEN#0+(byte) $a*(byte) $28+(byte) 4) ← (byte) 4 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [60] *((const byte*) main::SCREEN#0+(byte) 5) ← (byte) 5 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [61] *((const byte*) main::SCREEN#0+(byte) 1*(byte) $28+(byte) 5) ← (byte) 5 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [62] *((const byte*) main::SCREEN#0+(byte) 2*(byte) $28+(byte) 5) ← (byte) 5 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [63] *((const byte*) main::SCREEN#0+(byte) 3*(byte) $28+(byte) 5) ← (byte) 5 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [64] *((const byte*) main::SCREEN#0+(byte) 4*(byte) $28+(byte) 5) ← (byte) 5 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [65] *((const byte*) main::SCREEN#0+(byte) 5*(byte) $28+(byte) 5) ← (byte) 5 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [66] *((const byte*) main::SCREEN#0+(byte) 6*(byte) $28+(byte) 5) ← (byte) 5 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [67] *((const byte*) main::SCREEN#0+(byte) 7*(byte) $28+(byte) 5) ← (byte) 5 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [68] *((const byte*) main::SCREEN#0+(byte) 8*(byte) $28+(byte) 5) ← (byte) 5 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [69] *((const byte*) main::SCREEN#0+(byte) 9*(byte) $28+(byte) 5) ← (byte) 5 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [70] *((const byte*) main::SCREEN#0+(byte) $a*(byte) $28+(byte) 5) ← (byte) 5 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [71] *((const byte*) main::SCREEN#0+(byte) 6) ← (byte) 6 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [72] *((const byte*) main::SCREEN#0+(byte) 1*(byte) $28+(byte) 6) ← (byte) 6 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [73] *((const byte*) main::SCREEN#0+(byte) 2*(byte) $28+(byte) 6) ← (byte) 6 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [74] *((const byte*) main::SCREEN#0+(byte) 3*(byte) $28+(byte) 6) ← (byte) 6 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [75] *((const byte*) main::SCREEN#0+(byte) 4*(byte) $28+(byte) 6) ← (byte) 6 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [76] *((const byte*) main::SCREEN#0+(byte) 5*(byte) $28+(byte) 6) ← (byte) 6 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [77] *((const byte*) main::SCREEN#0+(byte) 6*(byte) $28+(byte) 6) ← (byte) 6 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [78] *((const byte*) main::SCREEN#0+(byte) 7*(byte) $28+(byte) 6) ← (byte) 6 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [79] *((const byte*) main::SCREEN#0+(byte) 8*(byte) $28+(byte) 6) ← (byte) 6 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [80] *((const byte*) main::SCREEN#0+(byte) 9*(byte) $28+(byte) 6) ← (byte) 6 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [81] *((const byte*) main::SCREEN#0+(byte) $a*(byte) $28+(byte) 6) ← (byte) 6 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [82] *((const byte*) main::SCREEN#0+(byte) 7) ← (byte) 7 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [83] *((const byte*) main::SCREEN#0+(byte) 1*(byte) $28+(byte) 7) ← (byte) 7 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [84] *((const byte*) main::SCREEN#0+(byte) 2*(byte) $28+(byte) 7) ← (byte) 7 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [85] *((const byte*) main::SCREEN#0+(byte) 3*(byte) $28+(byte) 7) ← (byte) 7 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [86] *((const byte*) main::SCREEN#0+(byte) 4*(byte) $28+(byte) 7) ← (byte) 7 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [87] *((const byte*) main::SCREEN#0+(byte) 5*(byte) $28+(byte) 7) ← (byte) 7 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [88] *((const byte*) main::SCREEN#0+(byte) 6*(byte) $28+(byte) 7) ← (byte) 7 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [89] *((const byte*) main::SCREEN#0+(byte) 7*(byte) $28+(byte) 7) ← (byte) 7 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [90] *((const byte*) main::SCREEN#0+(byte) 8*(byte) $28+(byte) 7) ← (byte) 7 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [91] *((const byte*) main::SCREEN#0+(byte) 9*(byte) $28+(byte) 7) ← (byte) 7 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [92] *((const byte*) main::SCREEN#0+(byte) $a*(byte) $28+(byte) 7) ← (byte) 7 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [93] *((const byte*) main::SCREEN#0+(byte) 8) ← (byte) 8 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [94] *((const byte*) main::SCREEN#0+(byte) 1*(byte) $28+(byte) 8) ← (byte) 8 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [95] *((const byte*) main::SCREEN#0+(byte) 2*(byte) $28+(byte) 8) ← (byte) 8 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [96] *((const byte*) main::SCREEN#0+(byte) 3*(byte) $28+(byte) 8) ← (byte) 8 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [97] *((const byte*) main::SCREEN#0+(byte) 4*(byte) $28+(byte) 8) ← (byte) 8 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [98] *((const byte*) main::SCREEN#0+(byte) 5*(byte) $28+(byte) 8) ← (byte) 8 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [99] *((const byte*) main::SCREEN#0+(byte) 6*(byte) $28+(byte) 8) ← (byte) 8 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [100] *((const byte*) main::SCREEN#0+(byte) 7*(byte) $28+(byte) 8) ← (byte) 8 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [101] *((const byte*) main::SCREEN#0+(byte) 8*(byte) $28+(byte) 8) ← (byte) 8 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [102] *((const byte*) main::SCREEN#0+(byte) 9*(byte) $28+(byte) 8) ← (byte) 8 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [103] *((const byte*) main::SCREEN#0+(byte) $a*(byte) $28+(byte) 8) ← (byte) 8 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [104] *((const byte*) main::SCREEN#0+(byte) 9) ← (byte) 9 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [105] *((const byte*) main::SCREEN#0+(byte) 1*(byte) $28+(byte) 9) ← (byte) 9 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [106] *((const byte*) main::SCREEN#0+(byte) 2*(byte) $28+(byte) 9) ← (byte) 9 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [107] *((const byte*) main::SCREEN#0+(byte) 3*(byte) $28+(byte) 9) ← (byte) 9 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [108] *((const byte*) main::SCREEN#0+(byte) 4*(byte) $28+(byte) 9) ← (byte) 9 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [109] *((const byte*) main::SCREEN#0+(byte) 5*(byte) $28+(byte) 9) ← (byte) 9 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [110] *((const byte*) main::SCREEN#0+(byte) 6*(byte) $28+(byte) 9) ← (byte) 9 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [111] *((const byte*) main::SCREEN#0+(byte) 7*(byte) $28+(byte) 9) ← (byte) 9 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [112] *((const byte*) main::SCREEN#0+(byte) 8*(byte) $28+(byte) 9) ← (byte) 9 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [113] *((const byte*) main::SCREEN#0+(byte) 9*(byte) $28+(byte) 9) ← (byte) 9 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [114] *((const byte*) main::SCREEN#0+(byte) $a*(byte) $28+(byte) 9) ← (byte) 9 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [115] *((const byte*) main::SCREEN#0+(byte) $a) ← (byte) $a [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [116] *((const byte*) main::SCREEN#0+(byte) 1*(byte) $28+(byte) $a) ← (byte) $a [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [117] *((const byte*) main::SCREEN#0+(byte) 2*(byte) $28+(byte) $a) ← (byte) $a [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [118] *((const byte*) main::SCREEN#0+(byte) 3*(byte) $28+(byte) $a) ← (byte) $a [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [119] *((const byte*) main::SCREEN#0+(byte) 4*(byte) $28+(byte) $a) ← (byte) $a [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [120] *((const byte*) main::SCREEN#0+(byte) 5*(byte) $28+(byte) $a) ← (byte) $a [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [121] *((const byte*) main::SCREEN#0+(byte) 6*(byte) $28+(byte) $a) ← (byte) $a [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [122] *((const byte*) main::SCREEN#0+(byte) 7*(byte) $28+(byte) $a) ← (byte) $a [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [123] *((const byte*) main::SCREEN#0+(byte) 8*(byte) $28+(byte) $a) ← (byte) $a [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [124] *((const byte*) main::SCREEN#0+(byte) 9*(byte) $28+(byte) $a) ← (byte) $a [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [125] *((const byte*) main::SCREEN#0+(byte) $a*(byte) $28+(byte) $a) ← (byte) $a [ ] ( main:2 [ ] ) always clobbers reg byte a 

REGISTER UPLIFT SCOPES
Uplift Scope [main] 
Uplift Scope [] 

Uplifting [main] best 1137 combination 
Uplifting [] best 1137 combination 

ASSEMBLER BEFORE OPTIMIZATION
  // File Comments
// Fills the screen using two unrolled ranged for()-loops
  // Basic 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
    jmp b1
    // main::@1
  b1:
    // [5] *((const byte*) main::SCREEN#0) ← (byte) 0 -- _deref_pbuc1=vbuc2 
    lda #0
    sta SCREEN
    jmp b2_1
    // main::@2_1
  b2_1:
    // [6] *((const byte*) main::SCREEN#0+(byte) 1*(byte) $28) ← (byte) 0 -- _deref_pbuc1=vbuc2 
    lda #0
    sta SCREEN+1*$28
    jmp b2_2
    // main::@2_2
  b2_2:
    // [7] *((const byte*) main::SCREEN#0+(byte) 2*(byte) $28) ← (byte) 0 -- _deref_pbuc1=vbuc2 
    lda #0
    sta SCREEN+2*$28
    jmp b2_3
    // main::@2_3
  b2_3:
    // [8] *((const byte*) main::SCREEN#0+(byte) 3*(byte) $28) ← (byte) 0 -- _deref_pbuc1=vbuc2 
    lda #0
    sta SCREEN+3*$28
    jmp b2_4
    // main::@2_4
  b2_4:
    // [9] *((const byte*) main::SCREEN#0+(byte) 4*(byte) $28) ← (byte) 0 -- _deref_pbuc1=vbuc2 
    lda #0
    sta SCREEN+4*$28
    jmp b2_5
    // main::@2_5
  b2_5:
    // [10] *((const byte*) main::SCREEN#0+(byte) 5*(byte) $28) ← (byte) 0 -- _deref_pbuc1=vbuc2 
    lda #0
    sta SCREEN+5*$28
    jmp b2_6
    // main::@2_6
  b2_6:
    // [11] *((const byte*) main::SCREEN#0+(byte) 6*(byte) $28) ← (byte) 0 -- _deref_pbuc1=vbuc2 
    lda #0
    sta SCREEN+6*$28
    jmp b2_7
    // main::@2_7
  b2_7:
    // [12] *((const byte*) main::SCREEN#0+(byte) 7*(byte) $28) ← (byte) 0 -- _deref_pbuc1=vbuc2 
    lda #0
    sta SCREEN+7*$28
    jmp b2_8
    // main::@2_8
  b2_8:
    // [13] *((const byte*) main::SCREEN#0+(byte) 8*(byte) $28) ← (byte) 0 -- _deref_pbuc1=vbuc2 
    lda #0
    sta SCREEN+8*$28
    jmp b2_9
    // main::@2_9
  b2_9:
    // [14] *((const byte*) main::SCREEN#0+(byte) 9*(byte) $28) ← (byte) 0 -- _deref_pbuc1=vbuc2 
    lda #0
    sta SCREEN+9*$28
    jmp b2_10
    // main::@2_10
  b2_10:
    // [15] *((const byte*) main::SCREEN#0+(byte) $a*(byte) $28) ← (byte) 0 -- _deref_pbuc1=vbuc2 
    lda #0
    sta SCREEN+$a*$28
    jmp b2_11
    // main::@2_11
  b2_11:
    // [16] *((const byte*) main::SCREEN#0+(byte) 1) ← (byte) 1 -- _deref_pbuc1=vbuc2 
    lda #1
    sta SCREEN+1
    jmp b2_12
    // main::@2_12
  b2_12:
    // [17] *((const byte*) main::SCREEN#0+(byte) 1*(byte) $28+(byte) 1) ← (byte) 1 -- _deref_pbuc1=vbuc2 
    lda #1
    sta SCREEN+1*$28+1
    jmp b2_13
    // main::@2_13
  b2_13:
    // [18] *((const byte*) main::SCREEN#0+(byte) 2*(byte) $28+(byte) 1) ← (byte) 1 -- _deref_pbuc1=vbuc2 
    lda #1
    sta SCREEN+2*$28+1
    jmp b2_14
    // main::@2_14
  b2_14:
    // [19] *((const byte*) main::SCREEN#0+(byte) 3*(byte) $28+(byte) 1) ← (byte) 1 -- _deref_pbuc1=vbuc2 
    lda #1
    sta SCREEN+3*$28+1
    jmp b2_15
    // main::@2_15
  b2_15:
    // [20] *((const byte*) main::SCREEN#0+(byte) 4*(byte) $28+(byte) 1) ← (byte) 1 -- _deref_pbuc1=vbuc2 
    lda #1
    sta SCREEN+4*$28+1
    jmp b2_16
    // main::@2_16
  b2_16:
    // [21] *((const byte*) main::SCREEN#0+(byte) 5*(byte) $28+(byte) 1) ← (byte) 1 -- _deref_pbuc1=vbuc2 
    lda #1
    sta SCREEN+5*$28+1
    jmp b2_17
    // main::@2_17
  b2_17:
    // [22] *((const byte*) main::SCREEN#0+(byte) 6*(byte) $28+(byte) 1) ← (byte) 1 -- _deref_pbuc1=vbuc2 
    lda #1
    sta SCREEN+6*$28+1
    jmp b2_18
    // main::@2_18
  b2_18:
    // [23] *((const byte*) main::SCREEN#0+(byte) 7*(byte) $28+(byte) 1) ← (byte) 1 -- _deref_pbuc1=vbuc2 
    lda #1
    sta SCREEN+7*$28+1
    jmp b2_19
    // main::@2_19
  b2_19:
    // [24] *((const byte*) main::SCREEN#0+(byte) 8*(byte) $28+(byte) 1) ← (byte) 1 -- _deref_pbuc1=vbuc2 
    lda #1
    sta SCREEN+8*$28+1
    jmp b2_20
    // main::@2_20
  b2_20:
    // [25] *((const byte*) main::SCREEN#0+(byte) 9*(byte) $28+(byte) 1) ← (byte) 1 -- _deref_pbuc1=vbuc2 
    lda #1
    sta SCREEN+9*$28+1
    jmp b2_21
    // main::@2_21
  b2_21:
    // [26] *((const byte*) main::SCREEN#0+(byte) $a*(byte) $28+(byte) 1) ← (byte) 1 -- _deref_pbuc1=vbuc2 
    lda #1
    sta SCREEN+$a*$28+1
    jmp b2_22
    // main::@2_22
  b2_22:
    // [27] *((const byte*) main::SCREEN#0+(byte) 2) ← (byte) 2 -- _deref_pbuc1=vbuc2 
    lda #2
    sta SCREEN+2
    jmp b2_23
    // main::@2_23
  b2_23:
    // [28] *((const byte*) main::SCREEN#0+(byte) 1*(byte) $28+(byte) 2) ← (byte) 2 -- _deref_pbuc1=vbuc2 
    lda #2
    sta SCREEN+1*$28+2
    jmp b2_24
    // main::@2_24
  b2_24:
    // [29] *((const byte*) main::SCREEN#0+(byte) 2*(byte) $28+(byte) 2) ← (byte) 2 -- _deref_pbuc1=vbuc2 
    lda #2
    sta SCREEN+2*$28+2
    jmp b2_25
    // main::@2_25
  b2_25:
    // [30] *((const byte*) main::SCREEN#0+(byte) 3*(byte) $28+(byte) 2) ← (byte) 2 -- _deref_pbuc1=vbuc2 
    lda #2
    sta SCREEN+3*$28+2
    jmp b2_26
    // main::@2_26
  b2_26:
    // [31] *((const byte*) main::SCREEN#0+(byte) 4*(byte) $28+(byte) 2) ← (byte) 2 -- _deref_pbuc1=vbuc2 
    lda #2
    sta SCREEN+4*$28+2
    jmp b2_27
    // main::@2_27
  b2_27:
    // [32] *((const byte*) main::SCREEN#0+(byte) 5*(byte) $28+(byte) 2) ← (byte) 2 -- _deref_pbuc1=vbuc2 
    lda #2
    sta SCREEN+5*$28+2
    jmp b2_28
    // main::@2_28
  b2_28:
    // [33] *((const byte*) main::SCREEN#0+(byte) 6*(byte) $28+(byte) 2) ← (byte) 2 -- _deref_pbuc1=vbuc2 
    lda #2
    sta SCREEN+6*$28+2
    jmp b2_29
    // main::@2_29
  b2_29:
    // [34] *((const byte*) main::SCREEN#0+(byte) 7*(byte) $28+(byte) 2) ← (byte) 2 -- _deref_pbuc1=vbuc2 
    lda #2
    sta SCREEN+7*$28+2
    jmp b2_30
    // main::@2_30
  b2_30:
    // [35] *((const byte*) main::SCREEN#0+(byte) 8*(byte) $28+(byte) 2) ← (byte) 2 -- _deref_pbuc1=vbuc2 
    lda #2
    sta SCREEN+8*$28+2
    jmp b2_31
    // main::@2_31
  b2_31:
    // [36] *((const byte*) main::SCREEN#0+(byte) 9*(byte) $28+(byte) 2) ← (byte) 2 -- _deref_pbuc1=vbuc2 
    lda #2
    sta SCREEN+9*$28+2
    jmp b2_32
    // main::@2_32
  b2_32:
    // [37] *((const byte*) main::SCREEN#0+(byte) $a*(byte) $28+(byte) 2) ← (byte) 2 -- _deref_pbuc1=vbuc2 
    lda #2
    sta SCREEN+$a*$28+2
    jmp b2_33
    // main::@2_33
  b2_33:
    // [38] *((const byte*) main::SCREEN#0+(byte) 3) ← (byte) 3 -- _deref_pbuc1=vbuc2 
    lda #3
    sta SCREEN+3
    jmp b2_34
    // main::@2_34
  b2_34:
    // [39] *((const byte*) main::SCREEN#0+(byte) 1*(byte) $28+(byte) 3) ← (byte) 3 -- _deref_pbuc1=vbuc2 
    lda #3
    sta SCREEN+1*$28+3
    jmp b2_35
    // main::@2_35
  b2_35:
    // [40] *((const byte*) main::SCREEN#0+(byte) 2*(byte) $28+(byte) 3) ← (byte) 3 -- _deref_pbuc1=vbuc2 
    lda #3
    sta SCREEN+2*$28+3
    jmp b2_36
    // main::@2_36
  b2_36:
    // [41] *((const byte*) main::SCREEN#0+(byte) 3*(byte) $28+(byte) 3) ← (byte) 3 -- _deref_pbuc1=vbuc2 
    lda #3
    sta SCREEN+3*$28+3
    jmp b2_37
    // main::@2_37
  b2_37:
    // [42] *((const byte*) main::SCREEN#0+(byte) 4*(byte) $28+(byte) 3) ← (byte) 3 -- _deref_pbuc1=vbuc2 
    lda #3
    sta SCREEN+4*$28+3
    jmp b2_38
    // main::@2_38
  b2_38:
    // [43] *((const byte*) main::SCREEN#0+(byte) 5*(byte) $28+(byte) 3) ← (byte) 3 -- _deref_pbuc1=vbuc2 
    lda #3
    sta SCREEN+5*$28+3
    jmp b2_39
    // main::@2_39
  b2_39:
    // [44] *((const byte*) main::SCREEN#0+(byte) 6*(byte) $28+(byte) 3) ← (byte) 3 -- _deref_pbuc1=vbuc2 
    lda #3
    sta SCREEN+6*$28+3
    jmp b2_40
    // main::@2_40
  b2_40:
    // [45] *((const byte*) main::SCREEN#0+(byte) 7*(byte) $28+(byte) 3) ← (byte) 3 -- _deref_pbuc1=vbuc2 
    lda #3
    sta SCREEN+7*$28+3
    jmp b2_41
    // main::@2_41
  b2_41:
    // [46] *((const byte*) main::SCREEN#0+(byte) 8*(byte) $28+(byte) 3) ← (byte) 3 -- _deref_pbuc1=vbuc2 
    lda #3
    sta SCREEN+8*$28+3
    jmp b2_42
    // main::@2_42
  b2_42:
    // [47] *((const byte*) main::SCREEN#0+(byte) 9*(byte) $28+(byte) 3) ← (byte) 3 -- _deref_pbuc1=vbuc2 
    lda #3
    sta SCREEN+9*$28+3
    jmp b2_43
    // main::@2_43
  b2_43:
    // [48] *((const byte*) main::SCREEN#0+(byte) $a*(byte) $28+(byte) 3) ← (byte) 3 -- _deref_pbuc1=vbuc2 
    lda #3
    sta SCREEN+$a*$28+3
    jmp b2_44
    // main::@2_44
  b2_44:
    // [49] *((const byte*) main::SCREEN#0+(byte) 4) ← (byte) 4 -- _deref_pbuc1=vbuc2 
    lda #4
    sta SCREEN+4
    jmp b2_45
    // main::@2_45
  b2_45:
    // [50] *((const byte*) main::SCREEN#0+(byte) 1*(byte) $28+(byte) 4) ← (byte) 4 -- _deref_pbuc1=vbuc2 
    lda #4
    sta SCREEN+1*$28+4
    jmp b2_46
    // main::@2_46
  b2_46:
    // [51] *((const byte*) main::SCREEN#0+(byte) 2*(byte) $28+(byte) 4) ← (byte) 4 -- _deref_pbuc1=vbuc2 
    lda #4
    sta SCREEN+2*$28+4
    jmp b2_47
    // main::@2_47
  b2_47:
    // [52] *((const byte*) main::SCREEN#0+(byte) 3*(byte) $28+(byte) 4) ← (byte) 4 -- _deref_pbuc1=vbuc2 
    lda #4
    sta SCREEN+3*$28+4
    jmp b2_48
    // main::@2_48
  b2_48:
    // [53] *((const byte*) main::SCREEN#0+(byte) 4*(byte) $28+(byte) 4) ← (byte) 4 -- _deref_pbuc1=vbuc2 
    lda #4
    sta SCREEN+4*$28+4
    jmp b2_49
    // main::@2_49
  b2_49:
    // [54] *((const byte*) main::SCREEN#0+(byte) 5*(byte) $28+(byte) 4) ← (byte) 4 -- _deref_pbuc1=vbuc2 
    lda #4
    sta SCREEN+5*$28+4
    jmp b2_50
    // main::@2_50
  b2_50:
    // [55] *((const byte*) main::SCREEN#0+(byte) 6*(byte) $28+(byte) 4) ← (byte) 4 -- _deref_pbuc1=vbuc2 
    lda #4
    sta SCREEN+6*$28+4
    jmp b2_51
    // main::@2_51
  b2_51:
    // [56] *((const byte*) main::SCREEN#0+(byte) 7*(byte) $28+(byte) 4) ← (byte) 4 -- _deref_pbuc1=vbuc2 
    lda #4
    sta SCREEN+7*$28+4
    jmp b2_52
    // main::@2_52
  b2_52:
    // [57] *((const byte*) main::SCREEN#0+(byte) 8*(byte) $28+(byte) 4) ← (byte) 4 -- _deref_pbuc1=vbuc2 
    lda #4
    sta SCREEN+8*$28+4
    jmp b2_53
    // main::@2_53
  b2_53:
    // [58] *((const byte*) main::SCREEN#0+(byte) 9*(byte) $28+(byte) 4) ← (byte) 4 -- _deref_pbuc1=vbuc2 
    lda #4
    sta SCREEN+9*$28+4
    jmp b2_54
    // main::@2_54
  b2_54:
    // [59] *((const byte*) main::SCREEN#0+(byte) $a*(byte) $28+(byte) 4) ← (byte) 4 -- _deref_pbuc1=vbuc2 
    lda #4
    sta SCREEN+$a*$28+4
    jmp b2_55
    // main::@2_55
  b2_55:
    // [60] *((const byte*) main::SCREEN#0+(byte) 5) ← (byte) 5 -- _deref_pbuc1=vbuc2 
    lda #5
    sta SCREEN+5
    jmp b2_56
    // main::@2_56
  b2_56:
    // [61] *((const byte*) main::SCREEN#0+(byte) 1*(byte) $28+(byte) 5) ← (byte) 5 -- _deref_pbuc1=vbuc2 
    lda #5
    sta SCREEN+1*$28+5
    jmp b2_57
    // main::@2_57
  b2_57:
    // [62] *((const byte*) main::SCREEN#0+(byte) 2*(byte) $28+(byte) 5) ← (byte) 5 -- _deref_pbuc1=vbuc2 
    lda #5
    sta SCREEN+2*$28+5
    jmp b2_58
    // main::@2_58
  b2_58:
    // [63] *((const byte*) main::SCREEN#0+(byte) 3*(byte) $28+(byte) 5) ← (byte) 5 -- _deref_pbuc1=vbuc2 
    lda #5
    sta SCREEN+3*$28+5
    jmp b2_59
    // main::@2_59
  b2_59:
    // [64] *((const byte*) main::SCREEN#0+(byte) 4*(byte) $28+(byte) 5) ← (byte) 5 -- _deref_pbuc1=vbuc2 
    lda #5
    sta SCREEN+4*$28+5
    jmp b2_60
    // main::@2_60
  b2_60:
    // [65] *((const byte*) main::SCREEN#0+(byte) 5*(byte) $28+(byte) 5) ← (byte) 5 -- _deref_pbuc1=vbuc2 
    lda #5
    sta SCREEN+5*$28+5
    jmp b2_61
    // main::@2_61
  b2_61:
    // [66] *((const byte*) main::SCREEN#0+(byte) 6*(byte) $28+(byte) 5) ← (byte) 5 -- _deref_pbuc1=vbuc2 
    lda #5
    sta SCREEN+6*$28+5
    jmp b2_62
    // main::@2_62
  b2_62:
    // [67] *((const byte*) main::SCREEN#0+(byte) 7*(byte) $28+(byte) 5) ← (byte) 5 -- _deref_pbuc1=vbuc2 
    lda #5
    sta SCREEN+7*$28+5
    jmp b2_63
    // main::@2_63
  b2_63:
    // [68] *((const byte*) main::SCREEN#0+(byte) 8*(byte) $28+(byte) 5) ← (byte) 5 -- _deref_pbuc1=vbuc2 
    lda #5
    sta SCREEN+8*$28+5
    jmp b2_64
    // main::@2_64
  b2_64:
    // [69] *((const byte*) main::SCREEN#0+(byte) 9*(byte) $28+(byte) 5) ← (byte) 5 -- _deref_pbuc1=vbuc2 
    lda #5
    sta SCREEN+9*$28+5
    jmp b2_65
    // main::@2_65
  b2_65:
    // [70] *((const byte*) main::SCREEN#0+(byte) $a*(byte) $28+(byte) 5) ← (byte) 5 -- _deref_pbuc1=vbuc2 
    lda #5
    sta SCREEN+$a*$28+5
    jmp b2_66
    // main::@2_66
  b2_66:
    // [71] *((const byte*) main::SCREEN#0+(byte) 6) ← (byte) 6 -- _deref_pbuc1=vbuc2 
    lda #6
    sta SCREEN+6
    jmp b2_67
    // main::@2_67
  b2_67:
    // [72] *((const byte*) main::SCREEN#0+(byte) 1*(byte) $28+(byte) 6) ← (byte) 6 -- _deref_pbuc1=vbuc2 
    lda #6
    sta SCREEN+1*$28+6
    jmp b2_68
    // main::@2_68
  b2_68:
    // [73] *((const byte*) main::SCREEN#0+(byte) 2*(byte) $28+(byte) 6) ← (byte) 6 -- _deref_pbuc1=vbuc2 
    lda #6
    sta SCREEN+2*$28+6
    jmp b2_69
    // main::@2_69
  b2_69:
    // [74] *((const byte*) main::SCREEN#0+(byte) 3*(byte) $28+(byte) 6) ← (byte) 6 -- _deref_pbuc1=vbuc2 
    lda #6
    sta SCREEN+3*$28+6
    jmp b2_70
    // main::@2_70
  b2_70:
    // [75] *((const byte*) main::SCREEN#0+(byte) 4*(byte) $28+(byte) 6) ← (byte) 6 -- _deref_pbuc1=vbuc2 
    lda #6
    sta SCREEN+4*$28+6
    jmp b2_71
    // main::@2_71
  b2_71:
    // [76] *((const byte*) main::SCREEN#0+(byte) 5*(byte) $28+(byte) 6) ← (byte) 6 -- _deref_pbuc1=vbuc2 
    lda #6
    sta SCREEN+5*$28+6
    jmp b2_72
    // main::@2_72
  b2_72:
    // [77] *((const byte*) main::SCREEN#0+(byte) 6*(byte) $28+(byte) 6) ← (byte) 6 -- _deref_pbuc1=vbuc2 
    lda #6
    sta SCREEN+6*$28+6
    jmp b2_73
    // main::@2_73
  b2_73:
    // [78] *((const byte*) main::SCREEN#0+(byte) 7*(byte) $28+(byte) 6) ← (byte) 6 -- _deref_pbuc1=vbuc2 
    lda #6
    sta SCREEN+7*$28+6
    jmp b2_74
    // main::@2_74
  b2_74:
    // [79] *((const byte*) main::SCREEN#0+(byte) 8*(byte) $28+(byte) 6) ← (byte) 6 -- _deref_pbuc1=vbuc2 
    lda #6
    sta SCREEN+8*$28+6
    jmp b2_75
    // main::@2_75
  b2_75:
    // [80] *((const byte*) main::SCREEN#0+(byte) 9*(byte) $28+(byte) 6) ← (byte) 6 -- _deref_pbuc1=vbuc2 
    lda #6
    sta SCREEN+9*$28+6
    jmp b2_76
    // main::@2_76
  b2_76:
    // [81] *((const byte*) main::SCREEN#0+(byte) $a*(byte) $28+(byte) 6) ← (byte) 6 -- _deref_pbuc1=vbuc2 
    lda #6
    sta SCREEN+$a*$28+6
    jmp b2_77
    // main::@2_77
  b2_77:
    // [82] *((const byte*) main::SCREEN#0+(byte) 7) ← (byte) 7 -- _deref_pbuc1=vbuc2 
    lda #7
    sta SCREEN+7
    jmp b2_78
    // main::@2_78
  b2_78:
    // [83] *((const byte*) main::SCREEN#0+(byte) 1*(byte) $28+(byte) 7) ← (byte) 7 -- _deref_pbuc1=vbuc2 
    lda #7
    sta SCREEN+1*$28+7
    jmp b2_79
    // main::@2_79
  b2_79:
    // [84] *((const byte*) main::SCREEN#0+(byte) 2*(byte) $28+(byte) 7) ← (byte) 7 -- _deref_pbuc1=vbuc2 
    lda #7
    sta SCREEN+2*$28+7
    jmp b2_80
    // main::@2_80
  b2_80:
    // [85] *((const byte*) main::SCREEN#0+(byte) 3*(byte) $28+(byte) 7) ← (byte) 7 -- _deref_pbuc1=vbuc2 
    lda #7
    sta SCREEN+3*$28+7
    jmp b2_81
    // main::@2_81
  b2_81:
    // [86] *((const byte*) main::SCREEN#0+(byte) 4*(byte) $28+(byte) 7) ← (byte) 7 -- _deref_pbuc1=vbuc2 
    lda #7
    sta SCREEN+4*$28+7
    jmp b2_82
    // main::@2_82
  b2_82:
    // [87] *((const byte*) main::SCREEN#0+(byte) 5*(byte) $28+(byte) 7) ← (byte) 7 -- _deref_pbuc1=vbuc2 
    lda #7
    sta SCREEN+5*$28+7
    jmp b2_83
    // main::@2_83
  b2_83:
    // [88] *((const byte*) main::SCREEN#0+(byte) 6*(byte) $28+(byte) 7) ← (byte) 7 -- _deref_pbuc1=vbuc2 
    lda #7
    sta SCREEN+6*$28+7
    jmp b2_84
    // main::@2_84
  b2_84:
    // [89] *((const byte*) main::SCREEN#0+(byte) 7*(byte) $28+(byte) 7) ← (byte) 7 -- _deref_pbuc1=vbuc2 
    lda #7
    sta SCREEN+7*$28+7
    jmp b2_85
    // main::@2_85
  b2_85:
    // [90] *((const byte*) main::SCREEN#0+(byte) 8*(byte) $28+(byte) 7) ← (byte) 7 -- _deref_pbuc1=vbuc2 
    lda #7
    sta SCREEN+8*$28+7
    jmp b2_86
    // main::@2_86
  b2_86:
    // [91] *((const byte*) main::SCREEN#0+(byte) 9*(byte) $28+(byte) 7) ← (byte) 7 -- _deref_pbuc1=vbuc2 
    lda #7
    sta SCREEN+9*$28+7
    jmp b2_87
    // main::@2_87
  b2_87:
    // [92] *((const byte*) main::SCREEN#0+(byte) $a*(byte) $28+(byte) 7) ← (byte) 7 -- _deref_pbuc1=vbuc2 
    lda #7
    sta SCREEN+$a*$28+7
    jmp b2_88
    // main::@2_88
  b2_88:
    // [93] *((const byte*) main::SCREEN#0+(byte) 8) ← (byte) 8 -- _deref_pbuc1=vbuc2 
    lda #8
    sta SCREEN+8
    jmp b2_89
    // main::@2_89
  b2_89:
    // [94] *((const byte*) main::SCREEN#0+(byte) 1*(byte) $28+(byte) 8) ← (byte) 8 -- _deref_pbuc1=vbuc2 
    lda #8
    sta SCREEN+1*$28+8
    jmp b2_90
    // main::@2_90
  b2_90:
    // [95] *((const byte*) main::SCREEN#0+(byte) 2*(byte) $28+(byte) 8) ← (byte) 8 -- _deref_pbuc1=vbuc2 
    lda #8
    sta SCREEN+2*$28+8
    jmp b2_91
    // main::@2_91
  b2_91:
    // [96] *((const byte*) main::SCREEN#0+(byte) 3*(byte) $28+(byte) 8) ← (byte) 8 -- _deref_pbuc1=vbuc2 
    lda #8
    sta SCREEN+3*$28+8
    jmp b2_92
    // main::@2_92
  b2_92:
    // [97] *((const byte*) main::SCREEN#0+(byte) 4*(byte) $28+(byte) 8) ← (byte) 8 -- _deref_pbuc1=vbuc2 
    lda #8
    sta SCREEN+4*$28+8
    jmp b2_93
    // main::@2_93
  b2_93:
    // [98] *((const byte*) main::SCREEN#0+(byte) 5*(byte) $28+(byte) 8) ← (byte) 8 -- _deref_pbuc1=vbuc2 
    lda #8
    sta SCREEN+5*$28+8
    jmp b2_94
    // main::@2_94
  b2_94:
    // [99] *((const byte*) main::SCREEN#0+(byte) 6*(byte) $28+(byte) 8) ← (byte) 8 -- _deref_pbuc1=vbuc2 
    lda #8
    sta SCREEN+6*$28+8
    jmp b2_95
    // main::@2_95
  b2_95:
    // [100] *((const byte*) main::SCREEN#0+(byte) 7*(byte) $28+(byte) 8) ← (byte) 8 -- _deref_pbuc1=vbuc2 
    lda #8
    sta SCREEN+7*$28+8
    jmp b2_96
    // main::@2_96
  b2_96:
    // [101] *((const byte*) main::SCREEN#0+(byte) 8*(byte) $28+(byte) 8) ← (byte) 8 -- _deref_pbuc1=vbuc2 
    lda #8
    sta SCREEN+8*$28+8
    jmp b2_97
    // main::@2_97
  b2_97:
    // [102] *((const byte*) main::SCREEN#0+(byte) 9*(byte) $28+(byte) 8) ← (byte) 8 -- _deref_pbuc1=vbuc2 
    lda #8
    sta SCREEN+9*$28+8
    jmp b2_98
    // main::@2_98
  b2_98:
    // [103] *((const byte*) main::SCREEN#0+(byte) $a*(byte) $28+(byte) 8) ← (byte) 8 -- _deref_pbuc1=vbuc2 
    lda #8
    sta SCREEN+$a*$28+8
    jmp b2_99
    // main::@2_99
  b2_99:
    // [104] *((const byte*) main::SCREEN#0+(byte) 9) ← (byte) 9 -- _deref_pbuc1=vbuc2 
    lda #9
    sta SCREEN+9
    jmp b2_100
    // main::@2_100
  b2_100:
    // [105] *((const byte*) main::SCREEN#0+(byte) 1*(byte) $28+(byte) 9) ← (byte) 9 -- _deref_pbuc1=vbuc2 
    lda #9
    sta SCREEN+1*$28+9
    jmp b2_101
    // main::@2_101
  b2_101:
    // [106] *((const byte*) main::SCREEN#0+(byte) 2*(byte) $28+(byte) 9) ← (byte) 9 -- _deref_pbuc1=vbuc2 
    lda #9
    sta SCREEN+2*$28+9
    jmp b2_102
    // main::@2_102
  b2_102:
    // [107] *((const byte*) main::SCREEN#0+(byte) 3*(byte) $28+(byte) 9) ← (byte) 9 -- _deref_pbuc1=vbuc2 
    lda #9
    sta SCREEN+3*$28+9
    jmp b2_103
    // main::@2_103
  b2_103:
    // [108] *((const byte*) main::SCREEN#0+(byte) 4*(byte) $28+(byte) 9) ← (byte) 9 -- _deref_pbuc1=vbuc2 
    lda #9
    sta SCREEN+4*$28+9
    jmp b2_104
    // main::@2_104
  b2_104:
    // [109] *((const byte*) main::SCREEN#0+(byte) 5*(byte) $28+(byte) 9) ← (byte) 9 -- _deref_pbuc1=vbuc2 
    lda #9
    sta SCREEN+5*$28+9
    jmp b2_105
    // main::@2_105
  b2_105:
    // [110] *((const byte*) main::SCREEN#0+(byte) 6*(byte) $28+(byte) 9) ← (byte) 9 -- _deref_pbuc1=vbuc2 
    lda #9
    sta SCREEN+6*$28+9
    jmp b2_106
    // main::@2_106
  b2_106:
    // [111] *((const byte*) main::SCREEN#0+(byte) 7*(byte) $28+(byte) 9) ← (byte) 9 -- _deref_pbuc1=vbuc2 
    lda #9
    sta SCREEN+7*$28+9
    jmp b2_107
    // main::@2_107
  b2_107:
    // [112] *((const byte*) main::SCREEN#0+(byte) 8*(byte) $28+(byte) 9) ← (byte) 9 -- _deref_pbuc1=vbuc2 
    lda #9
    sta SCREEN+8*$28+9
    jmp b2_108
    // main::@2_108
  b2_108:
    // [113] *((const byte*) main::SCREEN#0+(byte) 9*(byte) $28+(byte) 9) ← (byte) 9 -- _deref_pbuc1=vbuc2 
    lda #9
    sta SCREEN+9*$28+9
    jmp b2_109
    // main::@2_109
  b2_109:
    // [114] *((const byte*) main::SCREEN#0+(byte) $a*(byte) $28+(byte) 9) ← (byte) 9 -- _deref_pbuc1=vbuc2 
    lda #9
    sta SCREEN+$a*$28+9
    jmp b2_110
    // main::@2_110
  b2_110:
    // [115] *((const byte*) main::SCREEN#0+(byte) $a) ← (byte) $a -- _deref_pbuc1=vbuc2 
    lda #$a
    sta SCREEN+$a
    jmp b2_111
    // main::@2_111
  b2_111:
    // [116] *((const byte*) main::SCREEN#0+(byte) 1*(byte) $28+(byte) $a) ← (byte) $a -- _deref_pbuc1=vbuc2 
    lda #$a
    sta SCREEN+1*$28+$a
    jmp b2_112
    // main::@2_112
  b2_112:
    // [117] *((const byte*) main::SCREEN#0+(byte) 2*(byte) $28+(byte) $a) ← (byte) $a -- _deref_pbuc1=vbuc2 
    lda #$a
    sta SCREEN+2*$28+$a
    jmp b2_113
    // main::@2_113
  b2_113:
    // [118] *((const byte*) main::SCREEN#0+(byte) 3*(byte) $28+(byte) $a) ← (byte) $a -- _deref_pbuc1=vbuc2 
    lda #$a
    sta SCREEN+3*$28+$a
    jmp b2_114
    // main::@2_114
  b2_114:
    // [119] *((const byte*) main::SCREEN#0+(byte) 4*(byte) $28+(byte) $a) ← (byte) $a -- _deref_pbuc1=vbuc2 
    lda #$a
    sta SCREEN+4*$28+$a
    jmp b2_115
    // main::@2_115
  b2_115:
    // [120] *((const byte*) main::SCREEN#0+(byte) 5*(byte) $28+(byte) $a) ← (byte) $a -- _deref_pbuc1=vbuc2 
    lda #$a
    sta SCREEN+5*$28+$a
    jmp b2_116
    // main::@2_116
  b2_116:
    // [121] *((const byte*) main::SCREEN#0+(byte) 6*(byte) $28+(byte) $a) ← (byte) $a -- _deref_pbuc1=vbuc2 
    lda #$a
    sta SCREEN+6*$28+$a
    jmp b2_117
    // main::@2_117
  b2_117:
    // [122] *((const byte*) main::SCREEN#0+(byte) 7*(byte) $28+(byte) $a) ← (byte) $a -- _deref_pbuc1=vbuc2 
    lda #$a
    sta SCREEN+7*$28+$a
    jmp b2_118
    // main::@2_118
  b2_118:
    // [123] *((const byte*) main::SCREEN#0+(byte) 8*(byte) $28+(byte) $a) ← (byte) $a -- _deref_pbuc1=vbuc2 
    lda #$a
    sta SCREEN+8*$28+$a
    jmp b2_119
    // main::@2_119
  b2_119:
    // [124] *((const byte*) main::SCREEN#0+(byte) 9*(byte) $28+(byte) $a) ← (byte) $a -- _deref_pbuc1=vbuc2 
    lda #$a
    sta SCREEN+9*$28+$a
    jmp b2_120
    // main::@2_120
  b2_120:
    // [125] *((const byte*) main::SCREEN#0+(byte) $a*(byte) $28+(byte) $a) ← (byte) $a -- _deref_pbuc1=vbuc2 
    lda #$a
    sta SCREEN+$a*$28+$a
    jmp breturn
    // main::@return
  breturn:
    // [126] return 
    rts
}
  // File Data

ASSEMBLER OPTIMIZATIONS
Removing instruction jmp b1
Removing instruction jmp bend
Removing instruction jmp b1
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 b2_25
Removing instruction jmp b2_26
Removing instruction jmp b2_27
Removing instruction jmp b2_28
Removing instruction jmp b2_29
Removing instruction jmp b2_30
Removing instruction jmp b2_31
Removing instruction jmp b2_32
Removing instruction jmp b2_33
Removing instruction jmp b2_34
Removing instruction jmp b2_35
Removing instruction jmp b2_36
Removing instruction jmp b2_37
Removing instruction jmp b2_38
Removing instruction jmp b2_39
Removing instruction jmp b2_40
Removing instruction jmp b2_41
Removing instruction jmp b2_42
Removing instruction jmp b2_43
Removing instruction jmp b2_44
Removing instruction jmp b2_45
Removing instruction jmp b2_46
Removing instruction jmp b2_47
Removing instruction jmp b2_48
Removing instruction jmp b2_49
Removing instruction jmp b2_50
Removing instruction jmp b2_51
Removing instruction jmp b2_52
Removing instruction jmp b2_53
Removing instruction jmp b2_54
Removing instruction jmp b2_55
Removing instruction jmp b2_56
Removing instruction jmp b2_57
Removing instruction jmp b2_58
Removing instruction jmp b2_59
Removing instruction jmp b2_60
Removing instruction jmp b2_61
Removing instruction jmp b2_62
Removing instruction jmp b2_63
Removing instruction jmp b2_64
Removing instruction jmp b2_65
Removing instruction jmp b2_66
Removing instruction jmp b2_67
Removing instruction jmp b2_68
Removing instruction jmp b2_69
Removing instruction jmp b2_70
Removing instruction jmp b2_71
Removing instruction jmp b2_72
Removing instruction jmp b2_73
Removing instruction jmp b2_74
Removing instruction jmp b2_75
Removing instruction jmp b2_76
Removing instruction jmp b2_77
Removing instruction jmp b2_78
Removing instruction jmp b2_79
Removing instruction jmp b2_80
Removing instruction jmp b2_81
Removing instruction jmp b2_82
Removing instruction jmp b2_83
Removing instruction jmp b2_84
Removing instruction jmp b2_85
Removing instruction jmp b2_86
Removing instruction jmp b2_87
Removing instruction jmp b2_88
Removing instruction jmp b2_89
Removing instruction jmp b2_90
Removing instruction jmp b2_91
Removing instruction jmp b2_92
Removing instruction jmp b2_93
Removing instruction jmp b2_94
Removing instruction jmp b2_95
Removing instruction jmp b2_96
Removing instruction jmp b2_97
Removing instruction jmp b2_98
Removing instruction jmp b2_99
Removing instruction jmp b2_100
Removing instruction jmp b2_101
Removing instruction jmp b2_102
Removing instruction jmp b2_103
Removing instruction jmp b2_104
Removing instruction jmp b2_105
Removing instruction jmp b2_106
Removing instruction jmp b2_107
Removing instruction jmp b2_108
Removing instruction jmp b2_109
Removing instruction jmp b2_110
Removing instruction jmp b2_111
Removing instruction jmp b2_112
Removing instruction jmp b2_113
Removing instruction jmp b2_114
Removing instruction jmp b2_115
Removing instruction jmp b2_116
Removing instruction jmp b2_117
Removing instruction jmp b2_118
Removing instruction jmp b2_119
Removing instruction jmp b2_120
Removing instruction jmp breturn
Succesful ASM optimization Pass5NextJumpElimination
Removing instruction b1_from_bbegin:
Removing instruction b1:
Removing instruction main_from_b1:
Removing instruction bend_from_b1:
Succesful ASM optimization Pass5RedundantLabelElimination
Removing instruction bend:
Removing instruction b1:
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 b2_25:
Removing instruction b2_26:
Removing instruction b2_27:
Removing instruction b2_28:
Removing instruction b2_29:
Removing instruction b2_30:
Removing instruction b2_31:
Removing instruction b2_32:
Removing instruction b2_33:
Removing instruction b2_34:
Removing instruction b2_35:
Removing instruction b2_36:
Removing instruction b2_37:
Removing instruction b2_38:
Removing instruction b2_39:
Removing instruction b2_40:
Removing instruction b2_41:
Removing instruction b2_42:
Removing instruction b2_43:
Removing instruction b2_44:
Removing instruction b2_45:
Removing instruction b2_46:
Removing instruction b2_47:
Removing instruction b2_48:
Removing instruction b2_49:
Removing instruction b2_50:
Removing instruction b2_51:
Removing instruction b2_52:
Removing instruction b2_53:
Removing instruction b2_54:
Removing instruction b2_55:
Removing instruction b2_56:
Removing instruction b2_57:
Removing instruction b2_58:
Removing instruction b2_59:
Removing instruction b2_60:
Removing instruction b2_61:
Removing instruction b2_62:
Removing instruction b2_63:
Removing instruction b2_64:
Removing instruction b2_65:
Removing instruction b2_66:
Removing instruction b2_67:
Removing instruction b2_68:
Removing instruction b2_69:
Removing instruction b2_70:
Removing instruction b2_71:
Removing instruction b2_72:
Removing instruction b2_73:
Removing instruction b2_74:
Removing instruction b2_75:
Removing instruction b2_76:
Removing instruction b2_77:
Removing instruction b2_78:
Removing instruction b2_79:
Removing instruction b2_80:
Removing instruction b2_81:
Removing instruction b2_82:
Removing instruction b2_83:
Removing instruction b2_84:
Removing instruction b2_85:
Removing instruction b2_86:
Removing instruction b2_87:
Removing instruction b2_88:
Removing instruction b2_89:
Removing instruction b2_90:
Removing instruction b2_91:
Removing instruction b2_92:
Removing instruction b2_93:
Removing instruction b2_94:
Removing instruction b2_95:
Removing instruction b2_96:
Removing instruction b2_97:
Removing instruction b2_98:
Removing instruction b2_99:
Removing instruction b2_100:
Removing instruction b2_101:
Removing instruction b2_102:
Removing instruction b2_103:
Removing instruction b2_104:
Removing instruction b2_105:
Removing instruction b2_106:
Removing instruction b2_107:
Removing instruction b2_108:
Removing instruction b2_109:
Removing instruction b2_110:
Removing instruction b2_111:
Removing instruction b2_112:
Removing instruction b2_113:
Removing instruction b2_114:
Removing instruction b2_115:
Removing instruction b2_116:
Removing instruction b2_117:
Removing instruction b2_118:
Removing instruction b2_119:
Removing instruction b2_120:
Removing instruction breturn:
Succesful ASM optimization Pass5UnusedLabelElimination
Updating BasicUpstart to call main directly
Removing instruction jsr main
Succesful ASM optimization Pass5SkipBegin
Removing instruction lda #0
Removing instruction lda #0
Removing instruction lda #0
Removing instruction lda #0
Removing instruction lda #0
Removing instruction lda #0
Removing instruction lda #0
Removing instruction lda #0
Removing instruction lda #0
Removing instruction lda #0
Removing instruction lda #1
Removing instruction lda #1
Removing instruction lda #1
Removing instruction lda #1
Removing instruction lda #1
Removing instruction lda #1
Removing instruction lda #1
Removing instruction lda #1
Removing instruction lda #1
Removing instruction lda #1
Removing instruction lda #2
Removing instruction lda #2
Removing instruction lda #2
Removing instruction lda #2
Removing instruction lda #2
Removing instruction lda #2
Removing instruction lda #2
Removing instruction lda #2
Removing instruction lda #2
Removing instruction lda #2
Removing instruction lda #3
Removing instruction lda #3
Removing instruction lda #3
Removing instruction lda #3
Removing instruction lda #3
Removing instruction lda #3
Removing instruction lda #3
Removing instruction lda #3
Removing instruction lda #3
Removing instruction lda #3
Removing instruction lda #4
Removing instruction lda #4
Removing instruction lda #4
Removing instruction lda #4
Removing instruction lda #4
Removing instruction lda #4
Removing instruction lda #4
Removing instruction lda #4
Removing instruction lda #4
Removing instruction lda #4
Removing instruction lda #5
Removing instruction lda #5
Removing instruction lda #5
Removing instruction lda #5
Removing instruction lda #5
Removing instruction lda #5
Removing instruction lda #5
Removing instruction lda #5
Removing instruction lda #5
Removing instruction lda #5
Removing instruction lda #6
Removing instruction lda #6
Removing instruction lda #6
Removing instruction lda #6
Removing instruction lda #6
Removing instruction lda #6
Removing instruction lda #6
Removing instruction lda #6
Removing instruction lda #6
Removing instruction lda #6
Removing instruction lda #7
Removing instruction lda #7
Removing instruction lda #7
Removing instruction lda #7
Removing instruction lda #7
Removing instruction lda #7
Removing instruction lda #7
Removing instruction lda #7
Removing instruction lda #7
Removing instruction lda #7
Removing instruction lda #8
Removing instruction lda #8
Removing instruction lda #8
Removing instruction lda #8
Removing instruction lda #8
Removing instruction lda #8
Removing instruction lda #8
Removing instruction lda #8
Removing instruction lda #8
Removing instruction lda #8
Removing instruction lda #9
Removing instruction lda #9
Removing instruction lda #9
Removing instruction lda #9
Removing instruction lda #9
Removing instruction lda #9
Removing instruction lda #9
Removing instruction lda #9
Removing instruction lda #9
Removing instruction lda #9
Removing instruction lda #$a
Removing instruction lda #$a
Removing instruction lda #$a
Removing instruction lda #$a
Removing instruction lda #$a
Removing instruction lda #$a
Removing instruction lda #$a
Removing instruction lda #$a
Removing instruction lda #$a
Removing instruction lda #$a
Succesful ASM optimization Pass5UnnecesaryLoadElimination
Removing instruction bbegin:
Succesful ASM optimization Pass5UnusedLabelElimination

FINAL SYMBOL TABLE
(label) @1
(label) @begin
(label) @end
(void()) main()
(label) main::@1
(label) main::@2_1
(label) main::@2_10
(label) main::@2_100
(label) main::@2_101
(label) main::@2_102
(label) main::@2_103
(label) main::@2_104
(label) main::@2_105
(label) main::@2_106
(label) main::@2_107
(label) main::@2_108
(label) main::@2_109
(label) main::@2_11
(label) main::@2_110
(label) main::@2_111
(label) main::@2_112
(label) main::@2_113
(label) main::@2_114
(label) main::@2_115
(label) main::@2_116
(label) main::@2_117
(label) main::@2_118
(label) main::@2_119
(label) main::@2_12
(label) main::@2_120
(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_25
(label) main::@2_26
(label) main::@2_27
(label) main::@2_28
(label) main::@2_29
(label) main::@2_3
(label) main::@2_30
(label) main::@2_31
(label) main::@2_32
(label) main::@2_33
(label) main::@2_34
(label) main::@2_35
(label) main::@2_36
(label) main::@2_37
(label) main::@2_38
(label) main::@2_39
(label) main::@2_4
(label) main::@2_40
(label) main::@2_41
(label) main::@2_42
(label) main::@2_43
(label) main::@2_44
(label) main::@2_45
(label) main::@2_46
(label) main::@2_47
(label) main::@2_48
(label) main::@2_49
(label) main::@2_5
(label) main::@2_50
(label) main::@2_51
(label) main::@2_52
(label) main::@2_53
(label) main::@2_54
(label) main::@2_55
(label) main::@2_56
(label) main::@2_57
(label) main::@2_58
(label) main::@2_59
(label) main::@2_6
(label) main::@2_60
(label) main::@2_61
(label) main::@2_62
(label) main::@2_63
(label) main::@2_64
(label) main::@2_65
(label) main::@2_66
(label) main::@2_67
(label) main::@2_68
(label) main::@2_69
(label) main::@2_7
(label) main::@2_70
(label) main::@2_71
(label) main::@2_72
(label) main::@2_73
(label) main::@2_74
(label) main::@2_75
(label) main::@2_76
(label) main::@2_77
(label) main::@2_78
(label) main::@2_79
(label) main::@2_8
(label) main::@2_80
(label) main::@2_81
(label) main::@2_82
(label) main::@2_83
(label) main::@2_84
(label) main::@2_85
(label) main::@2_86
(label) main::@2_87
(label) main::@2_88
(label) main::@2_89
(label) main::@2_9
(label) main::@2_90
(label) main::@2_91
(label) main::@2_92
(label) main::@2_93
(label) main::@2_94
(label) main::@2_95
(label) main::@2_96
(label) main::@2_97
(label) main::@2_98
(label) main::@2_99
(label) main::@return
(byte*) main::SCREEN
(const byte*) main::SCREEN#0 SCREEN = (byte*) 1024
(byte) main::line
(byte) main::x



FINAL ASSEMBLER
Score: 512

  // File Comments
// Fills the screen using two unrolled ranged for()-loops
  // Basic 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
    // main::@1
    // (SCREEN+line*40)[x] = x
    // [5] *((const byte*) main::SCREEN#0) ← (byte) 0 -- _deref_pbuc1=vbuc2 
    lda #0
    sta SCREEN
    // main::@2_1
    // [6] *((const byte*) main::SCREEN#0+(byte) 1*(byte) $28) ← (byte) 0 -- _deref_pbuc1=vbuc2 
    sta SCREEN+1*$28
    // main::@2_2
    // [7] *((const byte*) main::SCREEN#0+(byte) 2*(byte) $28) ← (byte) 0 -- _deref_pbuc1=vbuc2 
    sta SCREEN+2*$28
    // main::@2_3
    // [8] *((const byte*) main::SCREEN#0+(byte) 3*(byte) $28) ← (byte) 0 -- _deref_pbuc1=vbuc2 
    sta SCREEN+3*$28
    // main::@2_4
    // [9] *((const byte*) main::SCREEN#0+(byte) 4*(byte) $28) ← (byte) 0 -- _deref_pbuc1=vbuc2 
    sta SCREEN+4*$28
    // main::@2_5
    // [10] *((const byte*) main::SCREEN#0+(byte) 5*(byte) $28) ← (byte) 0 -- _deref_pbuc1=vbuc2 
    sta SCREEN+5*$28
    // main::@2_6
    // [11] *((const byte*) main::SCREEN#0+(byte) 6*(byte) $28) ← (byte) 0 -- _deref_pbuc1=vbuc2 
    sta SCREEN+6*$28
    // main::@2_7
    // [12] *((const byte*) main::SCREEN#0+(byte) 7*(byte) $28) ← (byte) 0 -- _deref_pbuc1=vbuc2 
    sta SCREEN+7*$28
    // main::@2_8
    // [13] *((const byte*) main::SCREEN#0+(byte) 8*(byte) $28) ← (byte) 0 -- _deref_pbuc1=vbuc2 
    sta SCREEN+8*$28
    // main::@2_9
    // [14] *((const byte*) main::SCREEN#0+(byte) 9*(byte) $28) ← (byte) 0 -- _deref_pbuc1=vbuc2 
    sta SCREEN+9*$28
    // main::@2_10
    // [15] *((const byte*) main::SCREEN#0+(byte) $a*(byte) $28) ← (byte) 0 -- _deref_pbuc1=vbuc2 
    sta SCREEN+$a*$28
    // main::@2_11
    // [16] *((const byte*) main::SCREEN#0+(byte) 1) ← (byte) 1 -- _deref_pbuc1=vbuc2 
    lda #1
    sta SCREEN+1
    // main::@2_12
    // [17] *((const byte*) main::SCREEN#0+(byte) 1*(byte) $28+(byte) 1) ← (byte) 1 -- _deref_pbuc1=vbuc2 
    sta SCREEN+1*$28+1
    // main::@2_13
    // [18] *((const byte*) main::SCREEN#0+(byte) 2*(byte) $28+(byte) 1) ← (byte) 1 -- _deref_pbuc1=vbuc2 
    sta SCREEN+2*$28+1
    // main::@2_14
    // [19] *((const byte*) main::SCREEN#0+(byte) 3*(byte) $28+(byte) 1) ← (byte) 1 -- _deref_pbuc1=vbuc2 
    sta SCREEN+3*$28+1
    // main::@2_15
    // [20] *((const byte*) main::SCREEN#0+(byte) 4*(byte) $28+(byte) 1) ← (byte) 1 -- _deref_pbuc1=vbuc2 
    sta SCREEN+4*$28+1
    // main::@2_16
    // [21] *((const byte*) main::SCREEN#0+(byte) 5*(byte) $28+(byte) 1) ← (byte) 1 -- _deref_pbuc1=vbuc2 
    sta SCREEN+5*$28+1
    // main::@2_17
    // [22] *((const byte*) main::SCREEN#0+(byte) 6*(byte) $28+(byte) 1) ← (byte) 1 -- _deref_pbuc1=vbuc2 
    sta SCREEN+6*$28+1
    // main::@2_18
    // [23] *((const byte*) main::SCREEN#0+(byte) 7*(byte) $28+(byte) 1) ← (byte) 1 -- _deref_pbuc1=vbuc2 
    sta SCREEN+7*$28+1
    // main::@2_19
    // [24] *((const byte*) main::SCREEN#0+(byte) 8*(byte) $28+(byte) 1) ← (byte) 1 -- _deref_pbuc1=vbuc2 
    sta SCREEN+8*$28+1
    // main::@2_20
    // [25] *((const byte*) main::SCREEN#0+(byte) 9*(byte) $28+(byte) 1) ← (byte) 1 -- _deref_pbuc1=vbuc2 
    sta SCREEN+9*$28+1
    // main::@2_21
    // [26] *((const byte*) main::SCREEN#0+(byte) $a*(byte) $28+(byte) 1) ← (byte) 1 -- _deref_pbuc1=vbuc2 
    sta SCREEN+$a*$28+1
    // main::@2_22
    // [27] *((const byte*) main::SCREEN#0+(byte) 2) ← (byte) 2 -- _deref_pbuc1=vbuc2 
    lda #2
    sta SCREEN+2
    // main::@2_23
    // [28] *((const byte*) main::SCREEN#0+(byte) 1*(byte) $28+(byte) 2) ← (byte) 2 -- _deref_pbuc1=vbuc2 
    sta SCREEN+1*$28+2
    // main::@2_24
    // [29] *((const byte*) main::SCREEN#0+(byte) 2*(byte) $28+(byte) 2) ← (byte) 2 -- _deref_pbuc1=vbuc2 
    sta SCREEN+2*$28+2
    // main::@2_25
    // [30] *((const byte*) main::SCREEN#0+(byte) 3*(byte) $28+(byte) 2) ← (byte) 2 -- _deref_pbuc1=vbuc2 
    sta SCREEN+3*$28+2
    // main::@2_26
    // [31] *((const byte*) main::SCREEN#0+(byte) 4*(byte) $28+(byte) 2) ← (byte) 2 -- _deref_pbuc1=vbuc2 
    sta SCREEN+4*$28+2
    // main::@2_27
    // [32] *((const byte*) main::SCREEN#0+(byte) 5*(byte) $28+(byte) 2) ← (byte) 2 -- _deref_pbuc1=vbuc2 
    sta SCREEN+5*$28+2
    // main::@2_28
    // [33] *((const byte*) main::SCREEN#0+(byte) 6*(byte) $28+(byte) 2) ← (byte) 2 -- _deref_pbuc1=vbuc2 
    sta SCREEN+6*$28+2
    // main::@2_29
    // [34] *((const byte*) main::SCREEN#0+(byte) 7*(byte) $28+(byte) 2) ← (byte) 2 -- _deref_pbuc1=vbuc2 
    sta SCREEN+7*$28+2
    // main::@2_30
    // [35] *((const byte*) main::SCREEN#0+(byte) 8*(byte) $28+(byte) 2) ← (byte) 2 -- _deref_pbuc1=vbuc2 
    sta SCREEN+8*$28+2
    // main::@2_31
    // [36] *((const byte*) main::SCREEN#0+(byte) 9*(byte) $28+(byte) 2) ← (byte) 2 -- _deref_pbuc1=vbuc2 
    sta SCREEN+9*$28+2
    // main::@2_32
    // [37] *((const byte*) main::SCREEN#0+(byte) $a*(byte) $28+(byte) 2) ← (byte) 2 -- _deref_pbuc1=vbuc2 
    sta SCREEN+$a*$28+2
    // main::@2_33
    // [38] *((const byte*) main::SCREEN#0+(byte) 3) ← (byte) 3 -- _deref_pbuc1=vbuc2 
    lda #3
    sta SCREEN+3
    // main::@2_34
    // [39] *((const byte*) main::SCREEN#0+(byte) 1*(byte) $28+(byte) 3) ← (byte) 3 -- _deref_pbuc1=vbuc2 
    sta SCREEN+1*$28+3
    // main::@2_35
    // [40] *((const byte*) main::SCREEN#0+(byte) 2*(byte) $28+(byte) 3) ← (byte) 3 -- _deref_pbuc1=vbuc2 
    sta SCREEN+2*$28+3
    // main::@2_36
    // [41] *((const byte*) main::SCREEN#0+(byte) 3*(byte) $28+(byte) 3) ← (byte) 3 -- _deref_pbuc1=vbuc2 
    sta SCREEN+3*$28+3
    // main::@2_37
    // [42] *((const byte*) main::SCREEN#0+(byte) 4*(byte) $28+(byte) 3) ← (byte) 3 -- _deref_pbuc1=vbuc2 
    sta SCREEN+4*$28+3
    // main::@2_38
    // [43] *((const byte*) main::SCREEN#0+(byte) 5*(byte) $28+(byte) 3) ← (byte) 3 -- _deref_pbuc1=vbuc2 
    sta SCREEN+5*$28+3
    // main::@2_39
    // [44] *((const byte*) main::SCREEN#0+(byte) 6*(byte) $28+(byte) 3) ← (byte) 3 -- _deref_pbuc1=vbuc2 
    sta SCREEN+6*$28+3
    // main::@2_40
    // [45] *((const byte*) main::SCREEN#0+(byte) 7*(byte) $28+(byte) 3) ← (byte) 3 -- _deref_pbuc1=vbuc2 
    sta SCREEN+7*$28+3
    // main::@2_41
    // [46] *((const byte*) main::SCREEN#0+(byte) 8*(byte) $28+(byte) 3) ← (byte) 3 -- _deref_pbuc1=vbuc2 
    sta SCREEN+8*$28+3
    // main::@2_42
    // [47] *((const byte*) main::SCREEN#0+(byte) 9*(byte) $28+(byte) 3) ← (byte) 3 -- _deref_pbuc1=vbuc2 
    sta SCREEN+9*$28+3
    // main::@2_43
    // [48] *((const byte*) main::SCREEN#0+(byte) $a*(byte) $28+(byte) 3) ← (byte) 3 -- _deref_pbuc1=vbuc2 
    sta SCREEN+$a*$28+3
    // main::@2_44
    // [49] *((const byte*) main::SCREEN#0+(byte) 4) ← (byte) 4 -- _deref_pbuc1=vbuc2 
    lda #4
    sta SCREEN+4
    // main::@2_45
    // [50] *((const byte*) main::SCREEN#0+(byte) 1*(byte) $28+(byte) 4) ← (byte) 4 -- _deref_pbuc1=vbuc2 
    sta SCREEN+1*$28+4
    // main::@2_46
    // [51] *((const byte*) main::SCREEN#0+(byte) 2*(byte) $28+(byte) 4) ← (byte) 4 -- _deref_pbuc1=vbuc2 
    sta SCREEN+2*$28+4
    // main::@2_47
    // [52] *((const byte*) main::SCREEN#0+(byte) 3*(byte) $28+(byte) 4) ← (byte) 4 -- _deref_pbuc1=vbuc2 
    sta SCREEN+3*$28+4
    // main::@2_48
    // [53] *((const byte*) main::SCREEN#0+(byte) 4*(byte) $28+(byte) 4) ← (byte) 4 -- _deref_pbuc1=vbuc2 
    sta SCREEN+4*$28+4
    // main::@2_49
    // [54] *((const byte*) main::SCREEN#0+(byte) 5*(byte) $28+(byte) 4) ← (byte) 4 -- _deref_pbuc1=vbuc2 
    sta SCREEN+5*$28+4
    // main::@2_50
    // [55] *((const byte*) main::SCREEN#0+(byte) 6*(byte) $28+(byte) 4) ← (byte) 4 -- _deref_pbuc1=vbuc2 
    sta SCREEN+6*$28+4
    // main::@2_51
    // [56] *((const byte*) main::SCREEN#0+(byte) 7*(byte) $28+(byte) 4) ← (byte) 4 -- _deref_pbuc1=vbuc2 
    sta SCREEN+7*$28+4
    // main::@2_52
    // [57] *((const byte*) main::SCREEN#0+(byte) 8*(byte) $28+(byte) 4) ← (byte) 4 -- _deref_pbuc1=vbuc2 
    sta SCREEN+8*$28+4
    // main::@2_53
    // [58] *((const byte*) main::SCREEN#0+(byte) 9*(byte) $28+(byte) 4) ← (byte) 4 -- _deref_pbuc1=vbuc2 
    sta SCREEN+9*$28+4
    // main::@2_54
    // [59] *((const byte*) main::SCREEN#0+(byte) $a*(byte) $28+(byte) 4) ← (byte) 4 -- _deref_pbuc1=vbuc2 
    sta SCREEN+$a*$28+4
    // main::@2_55
    // [60] *((const byte*) main::SCREEN#0+(byte) 5) ← (byte) 5 -- _deref_pbuc1=vbuc2 
    lda #5
    sta SCREEN+5
    // main::@2_56
    // [61] *((const byte*) main::SCREEN#0+(byte) 1*(byte) $28+(byte) 5) ← (byte) 5 -- _deref_pbuc1=vbuc2 
    sta SCREEN+1*$28+5
    // main::@2_57
    // [62] *((const byte*) main::SCREEN#0+(byte) 2*(byte) $28+(byte) 5) ← (byte) 5 -- _deref_pbuc1=vbuc2 
    sta SCREEN+2*$28+5
    // main::@2_58
    // [63] *((const byte*) main::SCREEN#0+(byte) 3*(byte) $28+(byte) 5) ← (byte) 5 -- _deref_pbuc1=vbuc2 
    sta SCREEN+3*$28+5
    // main::@2_59
    // [64] *((const byte*) main::SCREEN#0+(byte) 4*(byte) $28+(byte) 5) ← (byte) 5 -- _deref_pbuc1=vbuc2 
    sta SCREEN+4*$28+5
    // main::@2_60
    // [65] *((const byte*) main::SCREEN#0+(byte) 5*(byte) $28+(byte) 5) ← (byte) 5 -- _deref_pbuc1=vbuc2 
    sta SCREEN+5*$28+5
    // main::@2_61
    // [66] *((const byte*) main::SCREEN#0+(byte) 6*(byte) $28+(byte) 5) ← (byte) 5 -- _deref_pbuc1=vbuc2 
    sta SCREEN+6*$28+5
    // main::@2_62
    // [67] *((const byte*) main::SCREEN#0+(byte) 7*(byte) $28+(byte) 5) ← (byte) 5 -- _deref_pbuc1=vbuc2 
    sta SCREEN+7*$28+5
    // main::@2_63
    // [68] *((const byte*) main::SCREEN#0+(byte) 8*(byte) $28+(byte) 5) ← (byte) 5 -- _deref_pbuc1=vbuc2 
    sta SCREEN+8*$28+5
    // main::@2_64
    // [69] *((const byte*) main::SCREEN#0+(byte) 9*(byte) $28+(byte) 5) ← (byte) 5 -- _deref_pbuc1=vbuc2 
    sta SCREEN+9*$28+5
    // main::@2_65
    // [70] *((const byte*) main::SCREEN#0+(byte) $a*(byte) $28+(byte) 5) ← (byte) 5 -- _deref_pbuc1=vbuc2 
    sta SCREEN+$a*$28+5
    // main::@2_66
    // [71] *((const byte*) main::SCREEN#0+(byte) 6) ← (byte) 6 -- _deref_pbuc1=vbuc2 
    lda #6
    sta SCREEN+6
    // main::@2_67
    // [72] *((const byte*) main::SCREEN#0+(byte) 1*(byte) $28+(byte) 6) ← (byte) 6 -- _deref_pbuc1=vbuc2 
    sta SCREEN+1*$28+6
    // main::@2_68
    // [73] *((const byte*) main::SCREEN#0+(byte) 2*(byte) $28+(byte) 6) ← (byte) 6 -- _deref_pbuc1=vbuc2 
    sta SCREEN+2*$28+6
    // main::@2_69
    // [74] *((const byte*) main::SCREEN#0+(byte) 3*(byte) $28+(byte) 6) ← (byte) 6 -- _deref_pbuc1=vbuc2 
    sta SCREEN+3*$28+6
    // main::@2_70
    // [75] *((const byte*) main::SCREEN#0+(byte) 4*(byte) $28+(byte) 6) ← (byte) 6 -- _deref_pbuc1=vbuc2 
    sta SCREEN+4*$28+6
    // main::@2_71
    // [76] *((const byte*) main::SCREEN#0+(byte) 5*(byte) $28+(byte) 6) ← (byte) 6 -- _deref_pbuc1=vbuc2 
    sta SCREEN+5*$28+6
    // main::@2_72
    // [77] *((const byte*) main::SCREEN#0+(byte) 6*(byte) $28+(byte) 6) ← (byte) 6 -- _deref_pbuc1=vbuc2 
    sta SCREEN+6*$28+6
    // main::@2_73
    // [78] *((const byte*) main::SCREEN#0+(byte) 7*(byte) $28+(byte) 6) ← (byte) 6 -- _deref_pbuc1=vbuc2 
    sta SCREEN+7*$28+6
    // main::@2_74
    // [79] *((const byte*) main::SCREEN#0+(byte) 8*(byte) $28+(byte) 6) ← (byte) 6 -- _deref_pbuc1=vbuc2 
    sta SCREEN+8*$28+6
    // main::@2_75
    // [80] *((const byte*) main::SCREEN#0+(byte) 9*(byte) $28+(byte) 6) ← (byte) 6 -- _deref_pbuc1=vbuc2 
    sta SCREEN+9*$28+6
    // main::@2_76
    // [81] *((const byte*) main::SCREEN#0+(byte) $a*(byte) $28+(byte) 6) ← (byte) 6 -- _deref_pbuc1=vbuc2 
    sta SCREEN+$a*$28+6
    // main::@2_77
    // [82] *((const byte*) main::SCREEN#0+(byte) 7) ← (byte) 7 -- _deref_pbuc1=vbuc2 
    lda #7
    sta SCREEN+7
    // main::@2_78
    // [83] *((const byte*) main::SCREEN#0+(byte) 1*(byte) $28+(byte) 7) ← (byte) 7 -- _deref_pbuc1=vbuc2 
    sta SCREEN+1*$28+7
    // main::@2_79
    // [84] *((const byte*) main::SCREEN#0+(byte) 2*(byte) $28+(byte) 7) ← (byte) 7 -- _deref_pbuc1=vbuc2 
    sta SCREEN+2*$28+7
    // main::@2_80
    // [85] *((const byte*) main::SCREEN#0+(byte) 3*(byte) $28+(byte) 7) ← (byte) 7 -- _deref_pbuc1=vbuc2 
    sta SCREEN+3*$28+7
    // main::@2_81
    // [86] *((const byte*) main::SCREEN#0+(byte) 4*(byte) $28+(byte) 7) ← (byte) 7 -- _deref_pbuc1=vbuc2 
    sta SCREEN+4*$28+7
    // main::@2_82
    // [87] *((const byte*) main::SCREEN#0+(byte) 5*(byte) $28+(byte) 7) ← (byte) 7 -- _deref_pbuc1=vbuc2 
    sta SCREEN+5*$28+7
    // main::@2_83
    // [88] *((const byte*) main::SCREEN#0+(byte) 6*(byte) $28+(byte) 7) ← (byte) 7 -- _deref_pbuc1=vbuc2 
    sta SCREEN+6*$28+7
    // main::@2_84
    // [89] *((const byte*) main::SCREEN#0+(byte) 7*(byte) $28+(byte) 7) ← (byte) 7 -- _deref_pbuc1=vbuc2 
    sta SCREEN+7*$28+7
    // main::@2_85
    // [90] *((const byte*) main::SCREEN#0+(byte) 8*(byte) $28+(byte) 7) ← (byte) 7 -- _deref_pbuc1=vbuc2 
    sta SCREEN+8*$28+7
    // main::@2_86
    // [91] *((const byte*) main::SCREEN#0+(byte) 9*(byte) $28+(byte) 7) ← (byte) 7 -- _deref_pbuc1=vbuc2 
    sta SCREEN+9*$28+7
    // main::@2_87
    // [92] *((const byte*) main::SCREEN#0+(byte) $a*(byte) $28+(byte) 7) ← (byte) 7 -- _deref_pbuc1=vbuc2 
    sta SCREEN+$a*$28+7
    // main::@2_88
    // [93] *((const byte*) main::SCREEN#0+(byte) 8) ← (byte) 8 -- _deref_pbuc1=vbuc2 
    lda #8
    sta SCREEN+8
    // main::@2_89
    // [94] *((const byte*) main::SCREEN#0+(byte) 1*(byte) $28+(byte) 8) ← (byte) 8 -- _deref_pbuc1=vbuc2 
    sta SCREEN+1*$28+8
    // main::@2_90
    // [95] *((const byte*) main::SCREEN#0+(byte) 2*(byte) $28+(byte) 8) ← (byte) 8 -- _deref_pbuc1=vbuc2 
    sta SCREEN+2*$28+8
    // main::@2_91
    // [96] *((const byte*) main::SCREEN#0+(byte) 3*(byte) $28+(byte) 8) ← (byte) 8 -- _deref_pbuc1=vbuc2 
    sta SCREEN+3*$28+8
    // main::@2_92
    // [97] *((const byte*) main::SCREEN#0+(byte) 4*(byte) $28+(byte) 8) ← (byte) 8 -- _deref_pbuc1=vbuc2 
    sta SCREEN+4*$28+8
    // main::@2_93
    // [98] *((const byte*) main::SCREEN#0+(byte) 5*(byte) $28+(byte) 8) ← (byte) 8 -- _deref_pbuc1=vbuc2 
    sta SCREEN+5*$28+8
    // main::@2_94
    // [99] *((const byte*) main::SCREEN#0+(byte) 6*(byte) $28+(byte) 8) ← (byte) 8 -- _deref_pbuc1=vbuc2 
    sta SCREEN+6*$28+8
    // main::@2_95
    // [100] *((const byte*) main::SCREEN#0+(byte) 7*(byte) $28+(byte) 8) ← (byte) 8 -- _deref_pbuc1=vbuc2 
    sta SCREEN+7*$28+8
    // main::@2_96
    // [101] *((const byte*) main::SCREEN#0+(byte) 8*(byte) $28+(byte) 8) ← (byte) 8 -- _deref_pbuc1=vbuc2 
    sta SCREEN+8*$28+8
    // main::@2_97
    // [102] *((const byte*) main::SCREEN#0+(byte) 9*(byte) $28+(byte) 8) ← (byte) 8 -- _deref_pbuc1=vbuc2 
    sta SCREEN+9*$28+8
    // main::@2_98
    // [103] *((const byte*) main::SCREEN#0+(byte) $a*(byte) $28+(byte) 8) ← (byte) 8 -- _deref_pbuc1=vbuc2 
    sta SCREEN+$a*$28+8
    // main::@2_99
    // [104] *((const byte*) main::SCREEN#0+(byte) 9) ← (byte) 9 -- _deref_pbuc1=vbuc2 
    lda #9
    sta SCREEN+9
    // main::@2_100
    // [105] *((const byte*) main::SCREEN#0+(byte) 1*(byte) $28+(byte) 9) ← (byte) 9 -- _deref_pbuc1=vbuc2 
    sta SCREEN+1*$28+9
    // main::@2_101
    // [106] *((const byte*) main::SCREEN#0+(byte) 2*(byte) $28+(byte) 9) ← (byte) 9 -- _deref_pbuc1=vbuc2 
    sta SCREEN+2*$28+9
    // main::@2_102
    // [107] *((const byte*) main::SCREEN#0+(byte) 3*(byte) $28+(byte) 9) ← (byte) 9 -- _deref_pbuc1=vbuc2 
    sta SCREEN+3*$28+9
    // main::@2_103
    // [108] *((const byte*) main::SCREEN#0+(byte) 4*(byte) $28+(byte) 9) ← (byte) 9 -- _deref_pbuc1=vbuc2 
    sta SCREEN+4*$28+9
    // main::@2_104
    // [109] *((const byte*) main::SCREEN#0+(byte) 5*(byte) $28+(byte) 9) ← (byte) 9 -- _deref_pbuc1=vbuc2 
    sta SCREEN+5*$28+9
    // main::@2_105
    // [110] *((const byte*) main::SCREEN#0+(byte) 6*(byte) $28+(byte) 9) ← (byte) 9 -- _deref_pbuc1=vbuc2 
    sta SCREEN+6*$28+9
    // main::@2_106
    // [111] *((const byte*) main::SCREEN#0+(byte) 7*(byte) $28+(byte) 9) ← (byte) 9 -- _deref_pbuc1=vbuc2 
    sta SCREEN+7*$28+9
    // main::@2_107
    // [112] *((const byte*) main::SCREEN#0+(byte) 8*(byte) $28+(byte) 9) ← (byte) 9 -- _deref_pbuc1=vbuc2 
    sta SCREEN+8*$28+9
    // main::@2_108
    // [113] *((const byte*) main::SCREEN#0+(byte) 9*(byte) $28+(byte) 9) ← (byte) 9 -- _deref_pbuc1=vbuc2 
    sta SCREEN+9*$28+9
    // main::@2_109
    // [114] *((const byte*) main::SCREEN#0+(byte) $a*(byte) $28+(byte) 9) ← (byte) 9 -- _deref_pbuc1=vbuc2 
    sta SCREEN+$a*$28+9
    // main::@2_110
    // [115] *((const byte*) main::SCREEN#0+(byte) $a) ← (byte) $a -- _deref_pbuc1=vbuc2 
    lda #$a
    sta SCREEN+$a
    // main::@2_111
    // [116] *((const byte*) main::SCREEN#0+(byte) 1*(byte) $28+(byte) $a) ← (byte) $a -- _deref_pbuc1=vbuc2 
    sta SCREEN+1*$28+$a
    // main::@2_112
    // [117] *((const byte*) main::SCREEN#0+(byte) 2*(byte) $28+(byte) $a) ← (byte) $a -- _deref_pbuc1=vbuc2 
    sta SCREEN+2*$28+$a
    // main::@2_113
    // [118] *((const byte*) main::SCREEN#0+(byte) 3*(byte) $28+(byte) $a) ← (byte) $a -- _deref_pbuc1=vbuc2 
    sta SCREEN+3*$28+$a
    // main::@2_114
    // [119] *((const byte*) main::SCREEN#0+(byte) 4*(byte) $28+(byte) $a) ← (byte) $a -- _deref_pbuc1=vbuc2 
    sta SCREEN+4*$28+$a
    // main::@2_115
    // [120] *((const byte*) main::SCREEN#0+(byte) 5*(byte) $28+(byte) $a) ← (byte) $a -- _deref_pbuc1=vbuc2 
    sta SCREEN+5*$28+$a
    // main::@2_116
    // [121] *((const byte*) main::SCREEN#0+(byte) 6*(byte) $28+(byte) $a) ← (byte) $a -- _deref_pbuc1=vbuc2 
    sta SCREEN+6*$28+$a
    // main::@2_117
    // [122] *((const byte*) main::SCREEN#0+(byte) 7*(byte) $28+(byte) $a) ← (byte) $a -- _deref_pbuc1=vbuc2 
    sta SCREEN+7*$28+$a
    // main::@2_118
    // [123] *((const byte*) main::SCREEN#0+(byte) 8*(byte) $28+(byte) $a) ← (byte) $a -- _deref_pbuc1=vbuc2 
    sta SCREEN+8*$28+$a
    // main::@2_119
    // [124] *((const byte*) main::SCREEN#0+(byte) 9*(byte) $28+(byte) $a) ← (byte) $a -- _deref_pbuc1=vbuc2 
    sta SCREEN+9*$28+$a
    // main::@2_120
    // [125] *((const byte*) main::SCREEN#0+(byte) $a*(byte) $28+(byte) $a) ← (byte) $a -- _deref_pbuc1=vbuc2 
    sta SCREEN+$a*$28+$a
    // main::@return
    // }
    // [126] return 
    rts
}
  // File Data

