Culled Empty Block (label) @1
Culled Empty Block (label) @2

CONTROL FLOW GRAPH SSA
@begin: scope:[]  from
  to:@3
main: scope:[main]  from @3
  call testBytes 
  to:main::@1
main::@1: scope:[main]  from main
  call testSBytes 
  to:main::@2
main::@2: scope:[main]  from main::@1
  to:main::@return
main::@return: scope:[main]  from main::@2
  return 
  to:@return
testBytes: scope:[testBytes]  from main
  (byte*) testBytes::SCREEN#0 ← ((byte*)) (number) $400
  (byte) testBytes::idx#0 ← (number) 0
  *((byte*) testBytes::SCREEN#0 + (byte) testBytes::idx#0) ← (number) $c
  (byte) testBytes::idx#1 ← ++ (byte) testBytes::idx#0
  *((byte*) testBytes::SCREEN#0 + (byte) testBytes::idx#1) ← (number) 6+(number) 6
  (byte) testBytes::idx#2 ← ++ (byte) testBytes::idx#1
  *((byte*) testBytes::SCREEN#0 + (byte) testBytes::idx#2) ← (number) $12-(number) 6
  (byte) testBytes::idx#3 ← ++ (byte) testBytes::idx#2
  *((byte*) testBytes::SCREEN#0 + (byte) testBytes::idx#3) ← (number) $714-(number) $708
  (byte) testBytes::idx#4 ← ++ (byte) testBytes::idx#3
  *((byte*) testBytes::SCREEN#0 + (byte) testBytes::idx#4) ← (number) 1+(number) 2+(number) 3+(number) 6
  (byte) testBytes::idx#5 ← ++ (byte) testBytes::idx#4
  *((byte*) testBytes::SCREEN#0 + (byte) testBytes::idx#5) ← (number) 2*(number) 6
  (byte) testBytes::idx#6 ← ++ (byte) testBytes::idx#5
  *((byte*) testBytes::SCREEN#0 + (byte) testBytes::idx#6) ← (number) 3<<(number) 2
  (byte) testBytes::idx#7 ← ++ (byte) testBytes::idx#6
  *((byte*) testBytes::SCREEN#0 + (byte) testBytes::idx#7) ← (number) $18>>(number) 1
  (byte) testBytes::idx#8 ← ++ (byte) testBytes::idx#7
  *((byte*) testBytes::SCREEN#0 + (byte) testBytes::idx#8) ← (number) $f&(number) $1c
  (byte) testBytes::idx#9 ← ++ (byte) testBytes::idx#8
  *((byte*) testBytes::SCREEN#0 + (byte) testBytes::idx#9) ← (number) 4|(number) 8
  (byte) testBytes::idx#10 ← ++ (byte) testBytes::idx#9
  *((byte*) testBytes::SCREEN#0 + (byte) testBytes::idx#10) ← (number) 5^(number) 9
  (byte) testBytes::idx#11 ← ++ (byte) testBytes::idx#10
  *((byte*) testBytes::SCREEN#0 + (byte) testBytes::idx#11) ← (number) 2+(number) 2*(number) $f/(number) 5
  (byte) testBytes::idx#12 ← ++ (byte) testBytes::idx#11
  (byte~) testBytes::$0 ← ((byte)) (number) $1000+(number) $c
  *((byte*) testBytes::SCREEN#0 + (byte) testBytes::idx#12) ← (byte~) testBytes::$0
  (byte) testBytes::idx#13 ← ++ (byte) testBytes::idx#12
  to:testBytes::@return
testBytes::@return: scope:[testBytes]  from testBytes
  return 
  to:@return
testSBytes: scope:[testSBytes]  from main::@1
  (signed byte*) testSBytes::SCREEN#0 ← ((signed byte*)) (number) $428
  (byte) testSBytes::idx#0 ← (number) 0
  *((signed byte*) testSBytes::SCREEN#0 + (byte) testSBytes::idx#0) ← (number) -$c
  (byte) testSBytes::idx#1 ← ++ (byte) testSBytes::idx#0
  *((signed byte*) testSBytes::SCREEN#0 + (byte) testSBytes::idx#1) ← (number) -6-(number) 6
  (byte) testSBytes::idx#2 ← ++ (byte) testSBytes::idx#1
  *((signed byte*) testSBytes::SCREEN#0 + (byte) testSBytes::idx#2) ← (number) -$12+(number) 6
  (byte) testSBytes::idx#3 ← ++ (byte) testSBytes::idx#2
  *((signed byte*) testSBytes::SCREEN#0 + (byte) testSBytes::idx#3) ← (number) -$714+(number) $708
  (byte) testSBytes::idx#4 ← ++ (byte) testSBytes::idx#3
  *((signed byte*) testSBytes::SCREEN#0 + (byte) testSBytes::idx#4) ← (number) -1-(number) 2-(number) 3-(number) 6
  (byte) testSBytes::idx#5 ← ++ (byte) testSBytes::idx#4
  *((signed byte*) testSBytes::SCREEN#0 + (byte) testSBytes::idx#5) ← (number) -2*(number) 6
  (byte) testSBytes::idx#6 ← ++ (byte) testSBytes::idx#5
  *((signed byte*) testSBytes::SCREEN#0 + (byte) testSBytes::idx#6) ← (number) -3<<(number) 2
  (byte) testSBytes::idx#7 ← ++ (byte) testSBytes::idx#6
  *((signed byte*) testSBytes::SCREEN#0 + (byte) testSBytes::idx#7) ← (number) -$18>>(number) 1
  (byte) testSBytes::idx#8 ← ++ (byte) testSBytes::idx#7
  *((signed byte*) testSBytes::SCREEN#0 + (byte) testSBytes::idx#8) ← (number) -4&(number) -9
  (byte) testSBytes::idx#9 ← ++ (byte) testSBytes::idx#8
  *((signed byte*) testSBytes::SCREEN#0 + (byte) testSBytes::idx#9) ← (number) -$10|(number) -$fc
  (byte) testSBytes::idx#10 ← ++ (byte) testSBytes::idx#9
  *((signed byte*) testSBytes::SCREEN#0 + (byte) testSBytes::idx#10) ← (number) -2-(number) 2*(number) $f/(number) 5
  (byte) testSBytes::idx#11 ← ++ (byte) testSBytes::idx#10
  (signed byte~) testSBytes::$0 ← ((signed byte)) (number) $1000-(number) $c
  *((signed byte*) testSBytes::SCREEN#0 + (byte) testSBytes::idx#11) ← (signed byte~) testSBytes::$0
  (byte) testSBytes::idx#12 ← ++ (byte) testSBytes::idx#11
  to:testSBytes::@return
testSBytes::@return: scope:[testSBytes]  from testSBytes
  return 
  to:@return
@3: scope:[]  from @begin
  call main 
  to:@4
@4: scope:[]  from @3
  to:@end
@end: scope:[]  from @4

SYMBOL TABLE SSA
(label) @3
(label) @4
(label) @begin
(label) @end
(void()) main()
(label) main::@1
(label) main::@2
(label) main::@return
(void()) testBytes()
(byte~) testBytes::$0
(label) testBytes::@return
(byte*) testBytes::SCREEN
(byte*) testBytes::SCREEN#0
(byte) testBytes::idx
(byte) testBytes::idx#0
(byte) testBytes::idx#1
(byte) testBytes::idx#10
(byte) testBytes::idx#11
(byte) testBytes::idx#12
(byte) testBytes::idx#13
(byte) testBytes::idx#2
(byte) testBytes::idx#3
(byte) testBytes::idx#4
(byte) testBytes::idx#5
(byte) testBytes::idx#6
(byte) testBytes::idx#7
(byte) testBytes::idx#8
(byte) testBytes::idx#9
(void()) testSBytes()
(signed byte~) testSBytes::$0
(label) testSBytes::@return
(signed byte*) testSBytes::SCREEN
(signed byte*) testSBytes::SCREEN#0
(byte) testSBytes::idx
(byte) testSBytes::idx#0
(byte) testSBytes::idx#1
(byte) testSBytes::idx#10
(byte) testSBytes::idx#11
(byte) testSBytes::idx#12
(byte) testSBytes::idx#2
(byte) testSBytes::idx#3
(byte) testSBytes::idx#4
(byte) testSBytes::idx#5
(byte) testSBytes::idx#6
(byte) testSBytes::idx#7
(byte) testSBytes::idx#8
(byte) testSBytes::idx#9

Adding number conversion cast (unumber) 0 in (byte) testBytes::idx#0 ← (number) 0
Adding number conversion cast (unumber) $c in *((byte*) testBytes::SCREEN#0 + (byte) testBytes::idx#0) ← (number) $c
Adding number conversion cast (unumber) 6+6 in *((byte*) testBytes::SCREEN#0 + (byte) testBytes::idx#1) ← (number) 6+(number) 6
Adding number conversion cast (unumber) $12-6 in *((byte*) testBytes::SCREEN#0 + (byte) testBytes::idx#2) ← (number) $12-(number) 6
Adding number conversion cast (unumber) $714-$708 in *((byte*) testBytes::SCREEN#0 + (byte) testBytes::idx#3) ← (number) $714-(number) $708
Adding number conversion cast (unumber) 1+2+3+6 in *((byte*) testBytes::SCREEN#0 + (byte) testBytes::idx#4) ← (number) 1+(number) 2+(number) 3+(number) 6
Adding number conversion cast (unumber) 2*6 in *((byte*) testBytes::SCREEN#0 + (byte) testBytes::idx#5) ← (number) 2*(number) 6
Adding number conversion cast (unumber) 3<<2 in *((byte*) testBytes::SCREEN#0 + (byte) testBytes::idx#6) ← (number) 3<<(number) 2
Adding number conversion cast (unumber) $18>>1 in *((byte*) testBytes::SCREEN#0 + (byte) testBytes::idx#7) ← (number) $18>>(number) 1
Adding number conversion cast (unumber) $f&$1c in *((byte*) testBytes::SCREEN#0 + (byte) testBytes::idx#8) ← (number) $f&(number) $1c
Adding number conversion cast (unumber) 4|8 in *((byte*) testBytes::SCREEN#0 + (byte) testBytes::idx#9) ← (number) 4|(number) 8
Adding number conversion cast (unumber) 5^9 in *((byte*) testBytes::SCREEN#0 + (byte) testBytes::idx#10) ← (number) 5^(number) 9
Adding number conversion cast (unumber) 2+2*$f/5 in *((byte*) testBytes::SCREEN#0 + (byte) testBytes::idx#11) ← (number) 2+(number) 2*(number) $f/(number) 5
Adding number conversion cast (unumber) 0 in (byte) testSBytes::idx#0 ← (number) 0
Adding number conversion cast (snumber) -$c in *((signed byte*) testSBytes::SCREEN#0 + (byte) testSBytes::idx#0) ← (number) -$c
Adding number conversion cast (snumber) -6-6 in *((signed byte*) testSBytes::SCREEN#0 + (byte) testSBytes::idx#1) ← (number) -6-(number) 6
Adding number conversion cast (snumber) -$12+6 in *((signed byte*) testSBytes::SCREEN#0 + (byte) testSBytes::idx#2) ← (number) -$12+(number) 6
Adding number conversion cast (snumber) -$714+$708 in *((signed byte*) testSBytes::SCREEN#0 + (byte) testSBytes::idx#3) ← (number) -$714+(number) $708
Adding number conversion cast (snumber) -1-2-3-6 in *((signed byte*) testSBytes::SCREEN#0 + (byte) testSBytes::idx#4) ← (number) -1-(number) 2-(number) 3-(number) 6
Adding number conversion cast (snumber) -2*6 in *((signed byte*) testSBytes::SCREEN#0 + (byte) testSBytes::idx#5) ← (number) -2*(number) 6
Adding number conversion cast (snumber) -3<<2 in *((signed byte*) testSBytes::SCREEN#0 + (byte) testSBytes::idx#6) ← (number) -3<<(number) 2
Adding number conversion cast (snumber) -$18>>1 in *((signed byte*) testSBytes::SCREEN#0 + (byte) testSBytes::idx#7) ← (number) -$18>>(number) 1
Adding number conversion cast (snumber) -4&-9 in *((signed byte*) testSBytes::SCREEN#0 + (byte) testSBytes::idx#8) ← (number) -4&(number) -9
Adding number conversion cast (snumber) -$10|-$fc in *((signed byte*) testSBytes::SCREEN#0 + (byte) testSBytes::idx#9) ← (number) -$10|(number) -$fc
Adding number conversion cast (snumber) -2-2*$f/5 in *((signed byte*) testSBytes::SCREEN#0 + (byte) testSBytes::idx#10) ← (number) -2-(number) 2*(number) $f/(number) 5
Successful SSA optimization PassNAddNumberTypeConversions
Inlining cast (byte*) testBytes::SCREEN#0 ← (byte*)(number) $400
Inlining cast (byte) testBytes::idx#0 ← (unumber)(number) 0
Inlining cast *((byte*) testBytes::SCREEN#0 + (byte) testBytes::idx#0) ← (unumber)(number) $c
Inlining cast *((byte*) testBytes::SCREEN#0 + (byte) testBytes::idx#1) ← (unumber)(number) 6+(number) 6
Inlining cast *((byte*) testBytes::SCREEN#0 + (byte) testBytes::idx#2) ← (unumber)(number) $12-(number) 6
Inlining cast *((byte*) testBytes::SCREEN#0 + (byte) testBytes::idx#3) ← (unumber)(number) $714-(number) $708
Inlining cast *((byte*) testBytes::SCREEN#0 + (byte) testBytes::idx#4) ← (unumber)(number) 1+(number) 2+(number) 3+(number) 6
Inlining cast *((byte*) testBytes::SCREEN#0 + (byte) testBytes::idx#5) ← (unumber)(number) 2*(number) 6
Inlining cast *((byte*) testBytes::SCREEN#0 + (byte) testBytes::idx#6) ← (unumber)(number) 3<<(number) 2
Inlining cast *((byte*) testBytes::SCREEN#0 + (byte) testBytes::idx#7) ← (unumber)(number) $18>>(number) 1
Inlining cast *((byte*) testBytes::SCREEN#0 + (byte) testBytes::idx#8) ← (unumber)(number) $f&(number) $1c
Inlining cast *((byte*) testBytes::SCREEN#0 + (byte) testBytes::idx#9) ← (unumber)(number) 4|(number) 8
Inlining cast *((byte*) testBytes::SCREEN#0 + (byte) testBytes::idx#10) ← (unumber)(number) 5^(number) 9
Inlining cast *((byte*) testBytes::SCREEN#0 + (byte) testBytes::idx#11) ← (unumber)(number) 2+(number) 2*(number) $f/(number) 5
Inlining cast (byte~) testBytes::$0 ← (byte)(number) $1000+(number) $c
Inlining cast (signed byte*) testSBytes::SCREEN#0 ← (signed byte*)(number) $428
Inlining cast (byte) testSBytes::idx#0 ← (unumber)(number) 0
Inlining cast *((signed byte*) testSBytes::SCREEN#0 + (byte) testSBytes::idx#0) ← (snumber)(number) -$c
Inlining cast *((signed byte*) testSBytes::SCREEN#0 + (byte) testSBytes::idx#1) ← (snumber)(number) -6-(number) 6
Inlining cast *((signed byte*) testSBytes::SCREEN#0 + (byte) testSBytes::idx#2) ← (snumber)(number) -$12+(number) 6
Inlining cast *((signed byte*) testSBytes::SCREEN#0 + (byte) testSBytes::idx#3) ← (snumber)(number) -$714+(number) $708
Inlining cast *((signed byte*) testSBytes::SCREEN#0 + (byte) testSBytes::idx#4) ← (snumber)(number) -1-(number) 2-(number) 3-(number) 6
Inlining cast *((signed byte*) testSBytes::SCREEN#0 + (byte) testSBytes::idx#5) ← (snumber)(number) -2*(number) 6
Inlining cast *((signed byte*) testSBytes::SCREEN#0 + (byte) testSBytes::idx#6) ← (snumber)(number) -3<<(number) 2
Inlining cast *((signed byte*) testSBytes::SCREEN#0 + (byte) testSBytes::idx#7) ← (snumber)(number) -$18>>(number) 1
Inlining cast *((signed byte*) testSBytes::SCREEN#0 + (byte) testSBytes::idx#8) ← (snumber)(number) -4&(number) -9
Inlining cast *((signed byte*) testSBytes::SCREEN#0 + (byte) testSBytes::idx#9) ← (snumber)(number) -$10|(number) -$fc
Inlining cast *((signed byte*) testSBytes::SCREEN#0 + (byte) testSBytes::idx#10) ← (snumber)(number) -2-(number) 2*(number) $f/(number) 5
Inlining cast (signed byte~) testSBytes::$0 ← (signed byte)(number) $1000-(number) $c
Successful SSA optimization Pass2InlineCast
Simplifying constant pointer cast (byte*) 1024
Simplifying constant integer cast 0
Simplifying constant integer cast $c
Simplifying constant pointer cast (signed byte*) 1064
Simplifying constant integer cast 0
Simplifying constant integer cast -$c
Successful SSA optimization PassNCastSimplification
Finalized unsigned number type (byte) 0
Finalized unsigned number type (byte) $c
Finalized unsigned number type (byte) 0
Finalized signed number type (signed byte) -$c
Successful SSA optimization PassNFinalizeNumberTypeConversions
Constant right-side identified [7] *((byte*) testBytes::SCREEN#0 + (byte) testBytes::idx#1) ← (unumber)(number) 6+(number) 6
Constant right-side identified [9] *((byte*) testBytes::SCREEN#0 + (byte) testBytes::idx#2) ← (unumber)(number) $12-(number) 6
Constant right-side identified [11] *((byte*) testBytes::SCREEN#0 + (byte) testBytes::idx#3) ← (unumber)(number) $714-(number) $708
Constant right-side identified [13] *((byte*) testBytes::SCREEN#0 + (byte) testBytes::idx#4) ← (unumber)(number) 1+(number) 2+(number) 3+(number) 6
Constant right-side identified [15] *((byte*) testBytes::SCREEN#0 + (byte) testBytes::idx#5) ← (unumber)(number) 2*(number) 6
Constant right-side identified [17] *((byte*) testBytes::SCREEN#0 + (byte) testBytes::idx#6) ← (unumber)(number) 3<<(number) 2
Constant right-side identified [19] *((byte*) testBytes::SCREEN#0 + (byte) testBytes::idx#7) ← (unumber)(number) $18>>(number) 1
Constant right-side identified [21] *((byte*) testBytes::SCREEN#0 + (byte) testBytes::idx#8) ← (unumber)(number) $f&(number) $1c
Constant right-side identified [23] *((byte*) testBytes::SCREEN#0 + (byte) testBytes::idx#9) ← (unumber)(number) 4|(number) 8
Constant right-side identified [25] *((byte*) testBytes::SCREEN#0 + (byte) testBytes::idx#10) ← (unumber)(number) 5^(number) 9
Constant right-side identified [27] *((byte*) testBytes::SCREEN#0 + (byte) testBytes::idx#11) ← (unumber)(number) 2+(number) 2*(number) $f/(number) 5
Constant right-side identified [29] (byte~) testBytes::$0 ← (byte)(number) $1000+(number) $c
Constant right-side identified [37] *((signed byte*) testSBytes::SCREEN#0 + (byte) testSBytes::idx#1) ← (snumber)(number) -6-(number) 6
Constant right-side identified [39] *((signed byte*) testSBytes::SCREEN#0 + (byte) testSBytes::idx#2) ← (snumber)(number) -$12+(number) 6
Constant right-side identified [41] *((signed byte*) testSBytes::SCREEN#0 + (byte) testSBytes::idx#3) ← (snumber)(number) -$714+(number) $708
Constant right-side identified [43] *((signed byte*) testSBytes::SCREEN#0 + (byte) testSBytes::idx#4) ← (snumber)(number) -1-(number) 2-(number) 3-(number) 6
Constant right-side identified [45] *((signed byte*) testSBytes::SCREEN#0 + (byte) testSBytes::idx#5) ← (snumber)(number) -2*(number) 6
Constant right-side identified [47] *((signed byte*) testSBytes::SCREEN#0 + (byte) testSBytes::idx#6) ← (snumber)(number) -3<<(number) 2
Constant right-side identified [49] *((signed byte*) testSBytes::SCREEN#0 + (byte) testSBytes::idx#7) ← (snumber)(number) -$18>>(number) 1
Constant right-side identified [51] *((signed byte*) testSBytes::SCREEN#0 + (byte) testSBytes::idx#8) ← (snumber)(number) -4&(number) -9
Constant right-side identified [53] *((signed byte*) testSBytes::SCREEN#0 + (byte) testSBytes::idx#9) ← (snumber)(number) -$10|(number) -$fc
Constant right-side identified [55] *((signed byte*) testSBytes::SCREEN#0 + (byte) testSBytes::idx#10) ← (snumber)(number) -2-(number) 2*(number) $f/(number) 5
Constant right-side identified [57] (signed byte~) testSBytes::$0 ← (signed byte)(number) $1000-(number) $c
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte*) testBytes::SCREEN#0 = (byte*) 1024
Constant (const byte) testBytes::idx#0 = 0
Constant (const byte) testBytes::$0 = (byte)$1000+$c
Constant (const signed byte*) testSBytes::SCREEN#0 = (signed byte*) 1064
Constant (const byte) testSBytes::idx#0 = 0
Constant (const signed byte) testSBytes::$0 = (signed byte)$1000-$c
Successful SSA optimization Pass2ConstantIdentification
Simplifying expression containing zero testBytes::SCREEN#0 in [5] *((const byte*) testBytes::SCREEN#0 + (const byte) testBytes::idx#0) ← (byte) $c
Simplifying expression containing zero testSBytes::SCREEN#0 in [35] *((const signed byte*) testSBytes::SCREEN#0 + (const byte) testSBytes::idx#0) ← (signed byte) -$c
Successful SSA optimization PassNSimplifyExpressionWithZero
Eliminating unused variable (byte) testBytes::idx#13 and assignment [28] (byte) testBytes::idx#13 ← ++ (byte) testBytes::idx#12
Eliminating unused variable (byte) testSBytes::idx#12 and assignment [53] (byte) testSBytes::idx#12 ← ++ (byte) testSBytes::idx#11
Successful SSA optimization PassNEliminateUnusedVars
Constant right-side identified [4] (byte) testBytes::idx#1 ← ++ (const byte) testBytes::idx#0
Constant right-side identified [30] (byte) testSBytes::idx#1 ← ++ (const byte) testSBytes::idx#0
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) testBytes::idx#1 = ++testBytes::idx#0
Constant (const byte) testSBytes::idx#1 = ++testSBytes::idx#0
Successful SSA optimization Pass2ConstantIdentification
Constant right-side identified [5] (byte) testBytes::idx#2 ← ++ (const byte) testBytes::idx#1
Constant right-side identified [30] (byte) testSBytes::idx#2 ← ++ (const byte) testSBytes::idx#1
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) testBytes::idx#2 = ++testBytes::idx#1
Constant (const byte) testSBytes::idx#2 = ++testSBytes::idx#1
Successful SSA optimization Pass2ConstantIdentification
Constant right-side identified [6] (byte) testBytes::idx#3 ← ++ (const byte) testBytes::idx#2
Constant right-side identified [30] (byte) testSBytes::idx#3 ← ++ (const byte) testSBytes::idx#2
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) testBytes::idx#3 = ++testBytes::idx#2
Constant (const byte) testSBytes::idx#3 = ++testSBytes::idx#2
Successful SSA optimization Pass2ConstantIdentification
Constant right-side identified [7] (byte) testBytes::idx#4 ← ++ (const byte) testBytes::idx#3
Constant right-side identified [30] (byte) testSBytes::idx#4 ← ++ (const byte) testSBytes::idx#3
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) testBytes::idx#4 = ++testBytes::idx#3
Constant (const byte) testSBytes::idx#4 = ++testSBytes::idx#3
Successful SSA optimization Pass2ConstantIdentification
Constant right-side identified [8] (byte) testBytes::idx#5 ← ++ (const byte) testBytes::idx#4
Constant right-side identified [30] (byte) testSBytes::idx#5 ← ++ (const byte) testSBytes::idx#4
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) testBytes::idx#5 = ++testBytes::idx#4
Constant (const byte) testSBytes::idx#5 = ++testSBytes::idx#4
Successful SSA optimization Pass2ConstantIdentification
Constant right-side identified [9] (byte) testBytes::idx#6 ← ++ (const byte) testBytes::idx#5
Constant right-side identified [30] (byte) testSBytes::idx#6 ← ++ (const byte) testSBytes::idx#5
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) testBytes::idx#6 = ++testBytes::idx#5
Constant (const byte) testSBytes::idx#6 = ++testSBytes::idx#5
Successful SSA optimization Pass2ConstantIdentification
Constant right-side identified [10] (byte) testBytes::idx#7 ← ++ (const byte) testBytes::idx#6
Constant right-side identified [30] (byte) testSBytes::idx#7 ← ++ (const byte) testSBytes::idx#6
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) testBytes::idx#7 = ++testBytes::idx#6
Constant (const byte) testSBytes::idx#7 = ++testSBytes::idx#6
Successful SSA optimization Pass2ConstantIdentification
Constant right-side identified [11] (byte) testBytes::idx#8 ← ++ (const byte) testBytes::idx#7
Constant right-side identified [30] (byte) testSBytes::idx#8 ← ++ (const byte) testSBytes::idx#7
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) testBytes::idx#8 = ++testBytes::idx#7
Constant (const byte) testSBytes::idx#8 = ++testSBytes::idx#7
Successful SSA optimization Pass2ConstantIdentification
Constant right-side identified [12] (byte) testBytes::idx#9 ← ++ (const byte) testBytes::idx#8
Constant right-side identified [30] (byte) testSBytes::idx#9 ← ++ (const byte) testSBytes::idx#8
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) testBytes::idx#9 = ++testBytes::idx#8
Constant (const byte) testSBytes::idx#9 = ++testSBytes::idx#8
Successful SSA optimization Pass2ConstantIdentification
Constant right-side identified [13] (byte) testBytes::idx#10 ← ++ (const byte) testBytes::idx#9
Constant right-side identified [30] (byte) testSBytes::idx#10 ← ++ (const byte) testSBytes::idx#9
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) testBytes::idx#10 = ++testBytes::idx#9
Constant (const byte) testSBytes::idx#10 = ++testSBytes::idx#9
Successful SSA optimization Pass2ConstantIdentification
Constant right-side identified [14] (byte) testBytes::idx#11 ← ++ (const byte) testBytes::idx#10
Constant right-side identified [30] (byte) testSBytes::idx#11 ← ++ (const byte) testSBytes::idx#10
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) testBytes::idx#11 = ++testBytes::idx#10
Constant (const byte) testSBytes::idx#11 = ++testSBytes::idx#10
Successful SSA optimization Pass2ConstantIdentification
Constant right-side identified [15] (byte) testBytes::idx#12 ← ++ (const byte) testBytes::idx#11
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) testBytes::idx#12 = ++testBytes::idx#11
Successful SSA optimization Pass2ConstantIdentification
Inlining constant with different constant siblings (const byte) testBytes::idx#0
Inlining constant with different constant siblings (const byte) testBytes::idx#1
Inlining constant with different constant siblings (const byte) testBytes::idx#2
Inlining constant with different constant siblings (const byte) testBytes::idx#3
Inlining constant with different constant siblings (const byte) testBytes::idx#4
Inlining constant with different constant siblings (const byte) testBytes::idx#5
Inlining constant with different constant siblings (const byte) testBytes::idx#6
Inlining constant with different constant siblings (const byte) testBytes::idx#7
Inlining constant with different constant siblings (const byte) testBytes::idx#8
Inlining constant with different constant siblings (const byte) testBytes::idx#9
Inlining constant with different constant siblings (const byte) testBytes::idx#10
Inlining constant with different constant siblings (const byte) testBytes::idx#11
Inlining constant with different constant siblings (const byte) testBytes::idx#12
Inlining constant with different constant siblings (const byte) testSBytes::idx#0
Inlining constant with different constant siblings (const byte) testSBytes::idx#1
Inlining constant with different constant siblings (const byte) testSBytes::idx#2
Inlining constant with different constant siblings (const byte) testSBytes::idx#3
Inlining constant with different constant siblings (const byte) testSBytes::idx#4
Inlining constant with different constant siblings (const byte) testSBytes::idx#5
Inlining constant with different constant siblings (const byte) testSBytes::idx#6
Inlining constant with different constant siblings (const byte) testSBytes::idx#7
Inlining constant with different constant siblings (const byte) testSBytes::idx#8
Inlining constant with different constant siblings (const byte) testSBytes::idx#9
Inlining constant with different constant siblings (const byte) testSBytes::idx#10
Inlining constant with different constant siblings (const byte) testSBytes::idx#11
Constant inlined testBytes::idx#5 = ++++++++++(byte) 0
Constant inlined testBytes::idx#6 = ++++++++++++(byte) 0
Constant inlined testBytes::idx#3 = ++++++(byte) 0
Constant inlined testBytes::idx#4 = ++++++++(byte) 0
Constant inlined testBytes::idx#1 = ++(byte) 0
Constant inlined testBytes::idx#2 = ++++(byte) 0
Constant inlined testBytes::idx#0 = (byte) 0
Constant inlined testBytes::idx#9 = ++++++++++++++++++(byte) 0
Constant inlined testBytes::idx#7 = ++++++++++++++(byte) 0
Constant inlined testBytes::idx#8 = ++++++++++++++++(byte) 0
Constant inlined testBytes::idx#12 = ++++++++++++++++++++++++(byte) 0
Constant inlined testBytes::idx#11 = ++++++++++++++++++++++(byte) 0
Constant inlined testBytes::idx#10 = ++++++++++++++++++++(byte) 0
Constant inlined testBytes::$0 = (byte)(number) $1000+(number) $c
Constant inlined testSBytes::$0 = (signed byte)(number) $1000-(number) $c
Constant inlined testSBytes::idx#10 = ++++++++++++++++++++(byte) 0
Constant inlined testSBytes::idx#9 = ++++++++++++++++++(byte) 0
Constant inlined testSBytes::idx#11 = ++++++++++++++++++++++(byte) 0
Constant inlined testSBytes::idx#8 = ++++++++++++++++(byte) 0
Constant inlined testSBytes::idx#5 = ++++++++++(byte) 0
Constant inlined testSBytes::idx#4 = ++++++++(byte) 0
Constant inlined testSBytes::idx#7 = ++++++++++++++(byte) 0
Constant inlined testSBytes::idx#6 = ++++++++++++(byte) 0
Constant inlined testSBytes::idx#1 = ++(byte) 0
Constant inlined testSBytes::idx#0 = (byte) 0
Constant inlined testSBytes::idx#3 = ++++++(byte) 0
Constant inlined testSBytes::idx#2 = ++++(byte) 0
Successful SSA optimization Pass2ConstantInlining
Consolidated array index constant in *(testBytes::SCREEN#0+++0)
Consolidated array index constant in *(testBytes::SCREEN#0+++++0)
Consolidated array index constant in *(testBytes::SCREEN#0+++++++0)
Consolidated array index constant in *(testBytes::SCREEN#0+++++++++0)
Consolidated array index constant in *(testBytes::SCREEN#0+++++++++++0)
Consolidated array index constant in *(testBytes::SCREEN#0+++++++++++++0)
Consolidated array index constant in *(testBytes::SCREEN#0+++++++++++++++0)
Consolidated array index constant in *(testBytes::SCREEN#0+++++++++++++++++0)
Consolidated array index constant in *(testBytes::SCREEN#0+++++++++++++++++++0)
Consolidated array index constant in *(testBytes::SCREEN#0+++++++++++++++++++++0)
Consolidated array index constant in *(testBytes::SCREEN#0+++++++++++++++++++++++0)
Consolidated array index constant in *(testBytes::SCREEN#0+++++++++++++++++++++++++0)
Consolidated array index constant in *(testSBytes::SCREEN#0+++0)
Consolidated array index constant in *(testSBytes::SCREEN#0+++++0)
Consolidated array index constant in *(testSBytes::SCREEN#0+++++++0)
Consolidated array index constant in *(testSBytes::SCREEN#0+++++++++0)
Consolidated array index constant in *(testSBytes::SCREEN#0+++++++++++0)
Consolidated array index constant in *(testSBytes::SCREEN#0+++++++++++++0)
Consolidated array index constant in *(testSBytes::SCREEN#0+++++++++++++++0)
Consolidated array index constant in *(testSBytes::SCREEN#0+++++++++++++++++0)
Consolidated array index constant in *(testSBytes::SCREEN#0+++++++++++++++++++0)
Consolidated array index constant in *(testSBytes::SCREEN#0+++++++++++++++++++++0)
Consolidated array index constant in *(testSBytes::SCREEN#0+++++++++++++++++++++++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 ++9
Simplifying constant integer increment ++$a
Simplifying constant integer increment ++0
Simplifying constant integer increment ++0
Simplifying constant integer increment ++1
Simplifying constant integer increment ++2
Simplifying constant integer increment ++3
Simplifying constant integer increment ++4
Simplifying constant integer increment ++5
Simplifying constant integer increment ++6
Simplifying constant integer increment ++7
Simplifying constant integer increment ++8
Simplifying constant integer increment ++9
Successful SSA optimization Pass2ConstantSimplification
Simplifying constant integer increment ++1
Simplifying constant integer increment ++2
Simplifying constant integer increment ++3
Simplifying constant integer increment ++4
Simplifying constant integer increment ++5
Simplifying constant integer increment ++6
Simplifying constant integer increment ++7
Simplifying constant integer increment ++8
Simplifying constant integer increment ++9
Simplifying constant integer increment ++$a
Simplifying constant integer increment ++$b
Simplifying constant integer increment ++1
Simplifying constant integer increment ++2
Simplifying constant integer increment ++3
Simplifying constant integer increment ++4
Simplifying constant integer increment ++5
Simplifying constant integer increment ++6
Simplifying constant integer increment ++7
Simplifying constant integer increment ++8
Simplifying constant integer increment ++9
Simplifying constant integer increment ++$a
Successful SSA optimization Pass2ConstantSimplification
Adding NOP phi() at start of @begin
Adding NOP phi() at start of @3
Adding NOP phi() at start of @4
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::@2
CALL GRAPH
Calls in [] to main:2 
Calls in [main] to testBytes:6 testSBytes:8 

Created 0 initial phi equivalence classes
Coalesced down to 0 phi equivalence classes
Culled Empty Block (label) @4
Culled Empty Block (label) main::@2
Renumbering block @3 to @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
Adding NOP phi() at start of main::@1

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()
  [5] call testBytes 
  to:main::@1
main::@1: scope:[main]  from main
  [6] phi()
  [7] call testSBytes 
  to:main::@return
main::@return: scope:[main]  from main::@1
  [8] return 
  to:@return
testSBytes: scope:[testSBytes]  from main::@1
  [9] *((const signed byte*) testSBytes::SCREEN#0) ← (signed byte) -$c
  [10] *((const signed byte*) testSBytes::SCREEN#0+(byte) 1) ← (signed byte)(number) -6-(number) 6
  [11] *((const signed byte*) testSBytes::SCREEN#0+(byte) 2) ← (signed byte)(number) -$12+(number) 6
  [12] *((const signed byte*) testSBytes::SCREEN#0+(byte) 3) ← (signed byte)(number) -$714+(number) $708
  [13] *((const signed byte*) testSBytes::SCREEN#0+(byte) 4) ← (signed byte)(number) -1-(number) 2-(number) 3-(number) 6
  [14] *((const signed byte*) testSBytes::SCREEN#0+(byte) 5) ← (signed byte)(number) -2*(number) 6
  [15] *((const signed byte*) testSBytes::SCREEN#0+(byte) 6) ← (signed byte)(number) -3<<(number) 2
  [16] *((const signed byte*) testSBytes::SCREEN#0+(byte) 7) ← (signed byte)(number) -$18>>(number) 1
  [17] *((const signed byte*) testSBytes::SCREEN#0+(byte) 8) ← (signed byte)(number) -4&(number) -9
  [18] *((const signed byte*) testSBytes::SCREEN#0+(byte) 9) ← (signed byte)(number) -$10|(number) -$fc
  [19] *((const signed byte*) testSBytes::SCREEN#0+(byte) $a) ← (signed byte)(number) -2-(number) 2*(number) $f/(number) 5
  [20] *((const signed byte*) testSBytes::SCREEN#0+(byte) $b) ← (signed byte)(number) $1000-(number) $c
  to:testSBytes::@return
testSBytes::@return: scope:[testSBytes]  from testSBytes
  [21] return 
  to:@return
testBytes: scope:[testBytes]  from main
  [22] *((const byte*) testBytes::SCREEN#0) ← (byte) $c
  [23] *((const byte*) testBytes::SCREEN#0+(byte) 1) ← (byte)(number) 6+(number) 6
  [24] *((const byte*) testBytes::SCREEN#0+(byte) 2) ← (byte)(number) $12-(number) 6
  [25] *((const byte*) testBytes::SCREEN#0+(byte) 3) ← (byte)(number) $714-(number) $708
  [26] *((const byte*) testBytes::SCREEN#0+(byte) 4) ← (byte)(number) 1+(number) 2+(number) 3+(number) 6
  [27] *((const byte*) testBytes::SCREEN#0+(byte) 5) ← (byte)(number) 2*(number) 6
  [28] *((const byte*) testBytes::SCREEN#0+(byte) 6) ← (byte)(number) 3<<(number) 2
  [29] *((const byte*) testBytes::SCREEN#0+(byte) 7) ← (byte)(number) $18>>(number) 1
  [30] *((const byte*) testBytes::SCREEN#0+(byte) 8) ← (byte)(number) $f&(number) $1c
  [31] *((const byte*) testBytes::SCREEN#0+(byte) 9) ← (byte)(number) 4|(number) 8
  [32] *((const byte*) testBytes::SCREEN#0+(byte) $a) ← (byte)(number) 5^(number) 9
  [33] *((const byte*) testBytes::SCREEN#0+(byte) $b) ← (byte)(number) 2+(number) 2*(number) $f/(number) 5
  [34] *((const byte*) testBytes::SCREEN#0+(byte) $c) ← (byte)(number) $1000+(number) $c
  to:testBytes::@return
testBytes::@return: scope:[testBytes]  from testBytes
  [35] return 
  to:@return


VARIABLE REGISTER WEIGHTS
(void()) main()
(void()) testBytes()
(byte*) testBytes::SCREEN
(byte) testBytes::idx
(void()) testSBytes()
(signed byte*) testSBytes::SCREEN
(byte) testSBytes::idx

Initial phi equivalence classes
Complete equivalence classes

INITIAL ASM
Target platform is c64basic
  // File Comments
// Tests the number type used for constant expressions
  // 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: {
    // [5] call testBytes 
    jsr testBytes
    // [6] phi from main to main::@1 [phi:main->main::@1]
  b1_from_main:
    jmp b1
    // main::@1
  b1:
    // [7] call testSBytes 
    jsr testSBytes
    jmp breturn
    // main::@return
  breturn:
    // [8] return 
    rts
}
  // testSBytes
testSBytes: {
    // Constant values resolvable to signed bytes
    .label SCREEN = $428
    // [9] *((const signed byte*) testSBytes::SCREEN#0) ← (signed byte) -$c -- _deref_pbsc1=vbsc2 
    lda #-$c
    sta SCREEN
    // [10] *((const signed byte*) testSBytes::SCREEN#0+(byte) 1) ← (signed byte)(number) -6-(number) 6 -- _deref_pbsc1=vbsc2 
    lda #-6-6
    sta SCREEN+1
    // [11] *((const signed byte*) testSBytes::SCREEN#0+(byte) 2) ← (signed byte)(number) -$12+(number) 6 -- _deref_pbsc1=vbsc2 
    lda #-$12+6
    sta SCREEN+2
    // [12] *((const signed byte*) testSBytes::SCREEN#0+(byte) 3) ← (signed byte)(number) -$714+(number) $708 -- _deref_pbsc1=vbsc2 
    lda #-$714+$708
    sta SCREEN+3
    // [13] *((const signed byte*) testSBytes::SCREEN#0+(byte) 4) ← (signed byte)(number) -1-(number) 2-(number) 3-(number) 6 -- _deref_pbsc1=vbsc2 
    lda #-1-2-3-6
    sta SCREEN+4
    // [14] *((const signed byte*) testSBytes::SCREEN#0+(byte) 5) ← (signed byte)(number) -2*(number) 6 -- _deref_pbsc1=vbsc2 
    lda #-2*6
    sta SCREEN+5
    // [15] *((const signed byte*) testSBytes::SCREEN#0+(byte) 6) ← (signed byte)(number) -3<<(number) 2 -- _deref_pbsc1=vbsc2 
    lda #-3<<2
    sta SCREEN+6
    // [16] *((const signed byte*) testSBytes::SCREEN#0+(byte) 7) ← (signed byte)(number) -$18>>(number) 1 -- _deref_pbsc1=vbsc2 
    lda #-$18>>1
    sta SCREEN+7
    // [17] *((const signed byte*) testSBytes::SCREEN#0+(byte) 8) ← (signed byte)(number) -4&(number) -9 -- _deref_pbsc1=vbsc2 
    lda #-4&-9
    sta SCREEN+8
    // [18] *((const signed byte*) testSBytes::SCREEN#0+(byte) 9) ← (signed byte)(number) -$10|(number) -$fc -- _deref_pbsc1=vbsc2 
    lda #-$10|-$fc
    sta SCREEN+9
    // [19] *((const signed byte*) testSBytes::SCREEN#0+(byte) $a) ← (signed byte)(number) -2-(number) 2*(number) $f/(number) 5 -- _deref_pbsc1=vbsc2 
    lda #(-2-2)*$f/5
    sta SCREEN+$a
    // [20] *((const signed byte*) testSBytes::SCREEN#0+(byte) $b) ← (signed byte)(number) $1000-(number) $c -- _deref_pbsc1=vbsc2 
    lda #$ff&$1000-$c
    sta SCREEN+$b
    jmp breturn
    // testSBytes::@return
  breturn:
    // [21] return 
    rts
}
  // testBytes
testBytes: {
    // Constant values resolvable to bytes
    .label SCREEN = $400
    // [22] *((const byte*) testBytes::SCREEN#0) ← (byte) $c -- _deref_pbuc1=vbuc2 
    lda #$c
    sta SCREEN
    // [23] *((const byte*) testBytes::SCREEN#0+(byte) 1) ← (byte)(number) 6+(number) 6 -- _deref_pbuc1=vbuc2 
    lda #6+6
    sta SCREEN+1
    // [24] *((const byte*) testBytes::SCREEN#0+(byte) 2) ← (byte)(number) $12-(number) 6 -- _deref_pbuc1=vbuc2 
    lda #$12-6
    sta SCREEN+2
    // [25] *((const byte*) testBytes::SCREEN#0+(byte) 3) ← (byte)(number) $714-(number) $708 -- _deref_pbuc1=vbuc2 
    lda #$714-$708
    sta SCREEN+3
    // [26] *((const byte*) testBytes::SCREEN#0+(byte) 4) ← (byte)(number) 1+(number) 2+(number) 3+(number) 6 -- _deref_pbuc1=vbuc2 
    lda #1+2+3+6
    sta SCREEN+4
    // [27] *((const byte*) testBytes::SCREEN#0+(byte) 5) ← (byte)(number) 2*(number) 6 -- _deref_pbuc1=vbuc2 
    lda #2*6
    sta SCREEN+5
    // [28] *((const byte*) testBytes::SCREEN#0+(byte) 6) ← (byte)(number) 3<<(number) 2 -- _deref_pbuc1=vbuc2 
    lda #3<<2
    sta SCREEN+6
    // [29] *((const byte*) testBytes::SCREEN#0+(byte) 7) ← (byte)(number) $18>>(number) 1 -- _deref_pbuc1=vbuc2 
    lda #$18>>1
    sta SCREEN+7
    // [30] *((const byte*) testBytes::SCREEN#0+(byte) 8) ← (byte)(number) $f&(number) $1c -- _deref_pbuc1=vbuc2 
    lda #$f&$1c
    sta SCREEN+8
    // [31] *((const byte*) testBytes::SCREEN#0+(byte) 9) ← (byte)(number) 4|(number) 8 -- _deref_pbuc1=vbuc2 
    lda #4|8
    sta SCREEN+9
    // [32] *((const byte*) testBytes::SCREEN#0+(byte) $a) ← (byte)(number) 5^(number) 9 -- _deref_pbuc1=vbuc2 
    lda #5^9
    sta SCREEN+$a
    // [33] *((const byte*) testBytes::SCREEN#0+(byte) $b) ← (byte)(number) 2+(number) 2*(number) $f/(number) 5 -- _deref_pbuc1=vbuc2 
    lda #(2+2)*$f/5
    sta SCREEN+$b
    // [34] *((const byte*) testBytes::SCREEN#0+(byte) $c) ← (byte)(number) $1000+(number) $c -- _deref_pbuc1=vbuc2 
    lda #$ff&$1000+$c
    sta SCREEN+$c
    jmp breturn
    // testBytes::@return
  breturn:
    // [35] return 
    rts
}
  // File Data

REGISTER UPLIFT POTENTIAL REGISTERS
Statement [9] *((const signed byte*) testSBytes::SCREEN#0) ← (signed byte) -$c [ ] ( main:2::testSBytes:7 [ ] ) always clobbers reg byte a 
Statement [10] *((const signed byte*) testSBytes::SCREEN#0+(byte) 1) ← (signed byte)(number) -6-(number) 6 [ ] ( main:2::testSBytes:7 [ ] ) always clobbers reg byte a 
Statement [11] *((const signed byte*) testSBytes::SCREEN#0+(byte) 2) ← (signed byte)(number) -$12+(number) 6 [ ] ( main:2::testSBytes:7 [ ] ) always clobbers reg byte a 
Statement [12] *((const signed byte*) testSBytes::SCREEN#0+(byte) 3) ← (signed byte)(number) -$714+(number) $708 [ ] ( main:2::testSBytes:7 [ ] ) always clobbers reg byte a 
Statement [13] *((const signed byte*) testSBytes::SCREEN#0+(byte) 4) ← (signed byte)(number) -1-(number) 2-(number) 3-(number) 6 [ ] ( main:2::testSBytes:7 [ ] ) always clobbers reg byte a 
Statement [14] *((const signed byte*) testSBytes::SCREEN#0+(byte) 5) ← (signed byte)(number) -2*(number) 6 [ ] ( main:2::testSBytes:7 [ ] ) always clobbers reg byte a 
Statement [15] *((const signed byte*) testSBytes::SCREEN#0+(byte) 6) ← (signed byte)(number) -3<<(number) 2 [ ] ( main:2::testSBytes:7 [ ] ) always clobbers reg byte a 
Statement [16] *((const signed byte*) testSBytes::SCREEN#0+(byte) 7) ← (signed byte)(number) -$18>>(number) 1 [ ] ( main:2::testSBytes:7 [ ] ) always clobbers reg byte a 
Statement [17] *((const signed byte*) testSBytes::SCREEN#0+(byte) 8) ← (signed byte)(number) -4&(number) -9 [ ] ( main:2::testSBytes:7 [ ] ) always clobbers reg byte a 
Statement [18] *((const signed byte*) testSBytes::SCREEN#0+(byte) 9) ← (signed byte)(number) -$10|(number) -$fc [ ] ( main:2::testSBytes:7 [ ] ) always clobbers reg byte a 
Statement [19] *((const signed byte*) testSBytes::SCREEN#0+(byte) $a) ← (signed byte)(number) -2-(number) 2*(number) $f/(number) 5 [ ] ( main:2::testSBytes:7 [ ] ) always clobbers reg byte a 
Statement [20] *((const signed byte*) testSBytes::SCREEN#0+(byte) $b) ← (signed byte)(number) $1000-(number) $c [ ] ( main:2::testSBytes:7 [ ] ) always clobbers reg byte a 
Statement [22] *((const byte*) testBytes::SCREEN#0) ← (byte) $c [ ] ( main:2::testBytes:5 [ ] ) always clobbers reg byte a 
Statement [23] *((const byte*) testBytes::SCREEN#0+(byte) 1) ← (byte)(number) 6+(number) 6 [ ] ( main:2::testBytes:5 [ ] ) always clobbers reg byte a 
Statement [24] *((const byte*) testBytes::SCREEN#0+(byte) 2) ← (byte)(number) $12-(number) 6 [ ] ( main:2::testBytes:5 [ ] ) always clobbers reg byte a 
Statement [25] *((const byte*) testBytes::SCREEN#0+(byte) 3) ← (byte)(number) $714-(number) $708 [ ] ( main:2::testBytes:5 [ ] ) always clobbers reg byte a 
Statement [26] *((const byte*) testBytes::SCREEN#0+(byte) 4) ← (byte)(number) 1+(number) 2+(number) 3+(number) 6 [ ] ( main:2::testBytes:5 [ ] ) always clobbers reg byte a 
Statement [27] *((const byte*) testBytes::SCREEN#0+(byte) 5) ← (byte)(number) 2*(number) 6 [ ] ( main:2::testBytes:5 [ ] ) always clobbers reg byte a 
Statement [28] *((const byte*) testBytes::SCREEN#0+(byte) 6) ← (byte)(number) 3<<(number) 2 [ ] ( main:2::testBytes:5 [ ] ) always clobbers reg byte a 
Statement [29] *((const byte*) testBytes::SCREEN#0+(byte) 7) ← (byte)(number) $18>>(number) 1 [ ] ( main:2::testBytes:5 [ ] ) always clobbers reg byte a 
Statement [30] *((const byte*) testBytes::SCREEN#0+(byte) 8) ← (byte)(number) $f&(number) $1c [ ] ( main:2::testBytes:5 [ ] ) always clobbers reg byte a 
Statement [31] *((const byte*) testBytes::SCREEN#0+(byte) 9) ← (byte)(number) 4|(number) 8 [ ] ( main:2::testBytes:5 [ ] ) always clobbers reg byte a 
Statement [32] *((const byte*) testBytes::SCREEN#0+(byte) $a) ← (byte)(number) 5^(number) 9 [ ] ( main:2::testBytes:5 [ ] ) always clobbers reg byte a 
Statement [33] *((const byte*) testBytes::SCREEN#0+(byte) $b) ← (byte)(number) 2+(number) 2*(number) $f/(number) 5 [ ] ( main:2::testBytes:5 [ ] ) always clobbers reg byte a 
Statement [34] *((const byte*) testBytes::SCREEN#0+(byte) $c) ← (byte)(number) $1000+(number) $c [ ] ( main:2::testBytes:5 [ ] ) always clobbers reg byte a 

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

Uplifting [main] best 204 combination 
Uplifting [testBytes] best 204 combination 
Uplifting [testSBytes] best 204 combination 
Uplifting [] best 204 combination 

ASSEMBLER BEFORE OPTIMIZATION
  // File Comments
// Tests the number type used for constant expressions
  // 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: {
    // [5] call testBytes 
    jsr testBytes
    // [6] phi from main to main::@1 [phi:main->main::@1]
  b1_from_main:
    jmp b1
    // main::@1
  b1:
    // [7] call testSBytes 
    jsr testSBytes
    jmp breturn
    // main::@return
  breturn:
    // [8] return 
    rts
}
  // testSBytes
testSBytes: {
    // Constant values resolvable to signed bytes
    .label SCREEN = $428
    // [9] *((const signed byte*) testSBytes::SCREEN#0) ← (signed byte) -$c -- _deref_pbsc1=vbsc2 
    lda #-$c
    sta SCREEN
    // [10] *((const signed byte*) testSBytes::SCREEN#0+(byte) 1) ← (signed byte)(number) -6-(number) 6 -- _deref_pbsc1=vbsc2 
    lda #-6-6
    sta SCREEN+1
    // [11] *((const signed byte*) testSBytes::SCREEN#0+(byte) 2) ← (signed byte)(number) -$12+(number) 6 -- _deref_pbsc1=vbsc2 
    lda #-$12+6
    sta SCREEN+2
    // [12] *((const signed byte*) testSBytes::SCREEN#0+(byte) 3) ← (signed byte)(number) -$714+(number) $708 -- _deref_pbsc1=vbsc2 
    lda #-$714+$708
    sta SCREEN+3
    // [13] *((const signed byte*) testSBytes::SCREEN#0+(byte) 4) ← (signed byte)(number) -1-(number) 2-(number) 3-(number) 6 -- _deref_pbsc1=vbsc2 
    lda #-1-2-3-6
    sta SCREEN+4
    // [14] *((const signed byte*) testSBytes::SCREEN#0+(byte) 5) ← (signed byte)(number) -2*(number) 6 -- _deref_pbsc1=vbsc2 
    lda #-2*6
    sta SCREEN+5
    // [15] *((const signed byte*) testSBytes::SCREEN#0+(byte) 6) ← (signed byte)(number) -3<<(number) 2 -- _deref_pbsc1=vbsc2 
    lda #-3<<2
    sta SCREEN+6
    // [16] *((const signed byte*) testSBytes::SCREEN#0+(byte) 7) ← (signed byte)(number) -$18>>(number) 1 -- _deref_pbsc1=vbsc2 
    lda #-$18>>1
    sta SCREEN+7
    // [17] *((const signed byte*) testSBytes::SCREEN#0+(byte) 8) ← (signed byte)(number) -4&(number) -9 -- _deref_pbsc1=vbsc2 
    lda #-4&-9
    sta SCREEN+8
    // [18] *((const signed byte*) testSBytes::SCREEN#0+(byte) 9) ← (signed byte)(number) -$10|(number) -$fc -- _deref_pbsc1=vbsc2 
    lda #-$10|-$fc
    sta SCREEN+9
    // [19] *((const signed byte*) testSBytes::SCREEN#0+(byte) $a) ← (signed byte)(number) -2-(number) 2*(number) $f/(number) 5 -- _deref_pbsc1=vbsc2 
    lda #(-2-2)*$f/5
    sta SCREEN+$a
    // [20] *((const signed byte*) testSBytes::SCREEN#0+(byte) $b) ← (signed byte)(number) $1000-(number) $c -- _deref_pbsc1=vbsc2 
    lda #$ff&$1000-$c
    sta SCREEN+$b
    jmp breturn
    // testSBytes::@return
  breturn:
    // [21] return 
    rts
}
  // testBytes
testBytes: {
    // Constant values resolvable to bytes
    .label SCREEN = $400
    // [22] *((const byte*) testBytes::SCREEN#0) ← (byte) $c -- _deref_pbuc1=vbuc2 
    lda #$c
    sta SCREEN
    // [23] *((const byte*) testBytes::SCREEN#0+(byte) 1) ← (byte)(number) 6+(number) 6 -- _deref_pbuc1=vbuc2 
    lda #6+6
    sta SCREEN+1
    // [24] *((const byte*) testBytes::SCREEN#0+(byte) 2) ← (byte)(number) $12-(number) 6 -- _deref_pbuc1=vbuc2 
    lda #$12-6
    sta SCREEN+2
    // [25] *((const byte*) testBytes::SCREEN#0+(byte) 3) ← (byte)(number) $714-(number) $708 -- _deref_pbuc1=vbuc2 
    lda #$714-$708
    sta SCREEN+3
    // [26] *((const byte*) testBytes::SCREEN#0+(byte) 4) ← (byte)(number) 1+(number) 2+(number) 3+(number) 6 -- _deref_pbuc1=vbuc2 
    lda #1+2+3+6
    sta SCREEN+4
    // [27] *((const byte*) testBytes::SCREEN#0+(byte) 5) ← (byte)(number) 2*(number) 6 -- _deref_pbuc1=vbuc2 
    lda #2*6
    sta SCREEN+5
    // [28] *((const byte*) testBytes::SCREEN#0+(byte) 6) ← (byte)(number) 3<<(number) 2 -- _deref_pbuc1=vbuc2 
    lda #3<<2
    sta SCREEN+6
    // [29] *((const byte*) testBytes::SCREEN#0+(byte) 7) ← (byte)(number) $18>>(number) 1 -- _deref_pbuc1=vbuc2 
    lda #$18>>1
    sta SCREEN+7
    // [30] *((const byte*) testBytes::SCREEN#0+(byte) 8) ← (byte)(number) $f&(number) $1c -- _deref_pbuc1=vbuc2 
    lda #$f&$1c
    sta SCREEN+8
    // [31] *((const byte*) testBytes::SCREEN#0+(byte) 9) ← (byte)(number) 4|(number) 8 -- _deref_pbuc1=vbuc2 
    lda #4|8
    sta SCREEN+9
    // [32] *((const byte*) testBytes::SCREEN#0+(byte) $a) ← (byte)(number) 5^(number) 9 -- _deref_pbuc1=vbuc2 
    lda #5^9
    sta SCREEN+$a
    // [33] *((const byte*) testBytes::SCREEN#0+(byte) $b) ← (byte)(number) 2+(number) 2*(number) $f/(number) 5 -- _deref_pbuc1=vbuc2 
    lda #(2+2)*$f/5
    sta SCREEN+$b
    // [34] *((const byte*) testBytes::SCREEN#0+(byte) $c) ← (byte)(number) $1000+(number) $c -- _deref_pbuc1=vbuc2 
    lda #$ff&$1000+$c
    sta SCREEN+$c
    jmp breturn
    // testBytes::@return
  breturn:
    // [35] return 
    rts
}
  // File Data

ASSEMBLER OPTIMIZATIONS
Removing instruction jmp b1
Removing instruction jmp bend
Removing instruction jmp b1
Removing instruction jmp breturn
Removing instruction jmp breturn
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:
Removing instruction b1_from_main:
Succesful ASM optimization Pass5RedundantLabelElimination
Removing instruction bend:
Removing instruction b1:
Removing instruction breturn:
Removing instruction breturn:
Removing instruction breturn:
Succesful ASM optimization Pass5UnusedLabelElimination
Updating BasicUpstart to call main directly
Removing instruction jsr main
Succesful ASM optimization Pass5SkipBegin
Removing instruction bbegin:
Succesful ASM optimization Pass5UnusedLabelElimination

FINAL SYMBOL TABLE
(label) @1
(label) @begin
(label) @end
(void()) main()
(label) main::@1
(label) main::@return
(void()) testBytes()
(label) testBytes::@return
(byte*) testBytes::SCREEN
(const byte*) testBytes::SCREEN#0 SCREEN = (byte*) 1024
(byte) testBytes::idx
(void()) testSBytes()
(label) testSBytes::@return
(signed byte*) testSBytes::SCREEN
(const signed byte*) testSBytes::SCREEN#0 SCREEN = (signed byte*) 1064
(byte) testSBytes::idx



FINAL ASSEMBLER
Score: 180

  // File Comments
// Tests the number type used for constant expressions
  // 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: {
    // testBytes()
    // [5] call testBytes 
    jsr testBytes
    // [6] phi from main to main::@1 [phi:main->main::@1]
    // main::@1
    // testSBytes()
    // [7] call testSBytes 
    jsr testSBytes
    // main::@return
    // }
    // [8] return 
    rts
}
  // testSBytes
testSBytes: {
    // Constant values resolvable to signed bytes
    .label SCREEN = $428
    // SCREEN[idx++] = -12
    // [9] *((const signed byte*) testSBytes::SCREEN#0) ← (signed byte) -$c -- _deref_pbsc1=vbsc2 
    lda #-$c
    sta SCREEN
    // SCREEN[idx++] = -6-6
    // [10] *((const signed byte*) testSBytes::SCREEN#0+(byte) 1) ← (signed byte)(number) -6-(number) 6 -- _deref_pbsc1=vbsc2 
    lda #-6-6
    sta SCREEN+1
    // SCREEN[idx++] = -18+6
    // [11] *((const signed byte*) testSBytes::SCREEN#0+(byte) 2) ← (signed byte)(number) -$12+(number) 6 -- _deref_pbsc1=vbsc2 
    lda #-$12+6
    sta SCREEN+2
    // SCREEN[idx++] = -1812+1800
    // [12] *((const signed byte*) testSBytes::SCREEN#0+(byte) 3) ← (signed byte)(number) -$714+(number) $708 -- _deref_pbsc1=vbsc2 
    lda #-$714+$708
    sta SCREEN+3
    // SCREEN[idx++] = -1-2-3-6
    // [13] *((const signed byte*) testSBytes::SCREEN#0+(byte) 4) ← (signed byte)(number) -1-(number) 2-(number) 3-(number) 6 -- _deref_pbsc1=vbsc2 
    lda #-1-2-3-6
    sta SCREEN+4
    // SCREEN[idx++] = -2*6
    // [14] *((const signed byte*) testSBytes::SCREEN#0+(byte) 5) ← (signed byte)(number) -2*(number) 6 -- _deref_pbsc1=vbsc2 
    lda #-2*6
    sta SCREEN+5
    // SCREEN[idx++] = -3<<2
    // [15] *((const signed byte*) testSBytes::SCREEN#0+(byte) 6) ← (signed byte)(number) -3<<(number) 2 -- _deref_pbsc1=vbsc2 
    lda #-3<<2
    sta SCREEN+6
    // SCREEN[idx++] = -24>>1
    // [16] *((const signed byte*) testSBytes::SCREEN#0+(byte) 7) ← (signed byte)(number) -$18>>(number) 1 -- _deref_pbsc1=vbsc2 
    lda #-$18>>1
    sta SCREEN+7
    // SCREEN[idx++] = -4&-9
    // [17] *((const signed byte*) testSBytes::SCREEN#0+(byte) 8) ← (signed byte)(number) -4&(number) -9 -- _deref_pbsc1=vbsc2 
    lda #-4&-9
    sta SCREEN+8
    // SCREEN[idx++] = -0x10|-0xfc
    // [18] *((const signed byte*) testSBytes::SCREEN#0+(byte) 9) ← (signed byte)(number) -$10|(number) -$fc -- _deref_pbsc1=vbsc2 
    lda #-$10|-$fc
    sta SCREEN+9
    // SCREEN[idx++] = (-2-2)*(15/5)
    // [19] *((const signed byte*) testSBytes::SCREEN#0+(byte) $a) ← (signed byte)(number) -2-(number) 2*(number) $f/(number) 5 -- _deref_pbsc1=vbsc2 
    lda #(-2-2)*$f/5
    sta SCREEN+$a
    // SCREEN[idx++] = (signed byte)(4096-12)
    // [20] *((const signed byte*) testSBytes::SCREEN#0+(byte) $b) ← (signed byte)(number) $1000-(number) $c -- _deref_pbsc1=vbsc2 
    lda #$ff&$1000-$c
    sta SCREEN+$b
    // testSBytes::@return
    // }
    // [21] return 
    rts
}
  // testBytes
testBytes: {
    // Constant values resolvable to bytes
    .label SCREEN = $400
    // SCREEN[idx++] = 12
    // [22] *((const byte*) testBytes::SCREEN#0) ← (byte) $c -- _deref_pbuc1=vbuc2 
    lda #$c
    sta SCREEN
    // SCREEN[idx++] = 6+6
    // [23] *((const byte*) testBytes::SCREEN#0+(byte) 1) ← (byte)(number) 6+(number) 6 -- _deref_pbuc1=vbuc2 
    lda #6+6
    sta SCREEN+1
    // SCREEN[idx++] = 18-6
    // [24] *((const byte*) testBytes::SCREEN#0+(byte) 2) ← (byte)(number) $12-(number) 6 -- _deref_pbuc1=vbuc2 
    lda #$12-6
    sta SCREEN+2
    // SCREEN[idx++] = 1812-1800
    // [25] *((const byte*) testBytes::SCREEN#0+(byte) 3) ← (byte)(number) $714-(number) $708 -- _deref_pbuc1=vbuc2 
    lda #$714-$708
    sta SCREEN+3
    // SCREEN[idx++] = 1+2+3+6
    // [26] *((const byte*) testBytes::SCREEN#0+(byte) 4) ← (byte)(number) 1+(number) 2+(number) 3+(number) 6 -- _deref_pbuc1=vbuc2 
    lda #1+2+3+6
    sta SCREEN+4
    // SCREEN[idx++] = 2*6
    // [27] *((const byte*) testBytes::SCREEN#0+(byte) 5) ← (byte)(number) 2*(number) 6 -- _deref_pbuc1=vbuc2 
    lda #2*6
    sta SCREEN+5
    // SCREEN[idx++] = 3<<2
    // [28] *((const byte*) testBytes::SCREEN#0+(byte) 6) ← (byte)(number) 3<<(number) 2 -- _deref_pbuc1=vbuc2 
    lda #3<<2
    sta SCREEN+6
    // SCREEN[idx++] = 24>>1
    // [29] *((const byte*) testBytes::SCREEN#0+(byte) 7) ← (byte)(number) $18>>(number) 1 -- _deref_pbuc1=vbuc2 
    lda #$18>>1
    sta SCREEN+7
    // SCREEN[idx++] = 15&28
    // [30] *((const byte*) testBytes::SCREEN#0+(byte) 8) ← (byte)(number) $f&(number) $1c -- _deref_pbuc1=vbuc2 
    lda #$f&$1c
    sta SCREEN+8
    // SCREEN[idx++] = 4|8
    // [31] *((const byte*) testBytes::SCREEN#0+(byte) 9) ← (byte)(number) 4|(number) 8 -- _deref_pbuc1=vbuc2 
    lda #4|8
    sta SCREEN+9
    // SCREEN[idx++] = 5^9
    // [32] *((const byte*) testBytes::SCREEN#0+(byte) $a) ← (byte)(number) 5^(number) 9 -- _deref_pbuc1=vbuc2 
    lda #5^9
    sta SCREEN+$a
    // SCREEN[idx++] = (2+2)*(15/5)
    // [33] *((const byte*) testBytes::SCREEN#0+(byte) $b) ← (byte)(number) 2+(number) 2*(number) $f/(number) 5 -- _deref_pbuc1=vbuc2 
    lda #(2+2)*$f/5
    sta SCREEN+$b
    // SCREEN[idx++] = (byte)(4096+12)
    // [34] *((const byte*) testBytes::SCREEN#0+(byte) $c) ← (byte)(number) $1000+(number) $c -- _deref_pbuc1=vbuc2 
    lda #$ff&$1000+$c
    sta SCREEN+$c
    // testBytes::@return
    // }
    // [35] return 
    rts
}
  // File Data

