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

CONTROL FLOW GRAPH SSA
@begin: scope:[]  from
  to:@3

(void()) main()
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

(void()) testBytes()
testBytes: scope:[testBytes]  from main
  (byte) testBytes::idx#0 ← (byte) 0
  *((const byte*) testBytes::SCREEN + (byte) testBytes::idx#0) ← (number) $c
  (byte) testBytes::idx#1 ← ++ (byte) testBytes::idx#0
  *((const byte*) testBytes::SCREEN + (byte) testBytes::idx#1) ← (number) 6+(number) 6
  (byte) testBytes::idx#2 ← ++ (byte) testBytes::idx#1
  *((const byte*) testBytes::SCREEN + (byte) testBytes::idx#2) ← (number) $12-(number) 6
  (byte) testBytes::idx#3 ← ++ (byte) testBytes::idx#2
  *((const byte*) testBytes::SCREEN + (byte) testBytes::idx#3) ← (number) $714-(number) $708
  (byte) testBytes::idx#4 ← ++ (byte) testBytes::idx#3
  *((const byte*) testBytes::SCREEN + (byte) testBytes::idx#4) ← (number) 1+(number) 2+(number) 3+(number) 6
  (byte) testBytes::idx#5 ← ++ (byte) testBytes::idx#4
  *((const byte*) testBytes::SCREEN + (byte) testBytes::idx#5) ← (number) 2*(number) 6
  (byte) testBytes::idx#6 ← ++ (byte) testBytes::idx#5
  *((const byte*) testBytes::SCREEN + (byte) testBytes::idx#6) ← (number) 3<<(number) 2
  (byte) testBytes::idx#7 ← ++ (byte) testBytes::idx#6
  *((const byte*) testBytes::SCREEN + (byte) testBytes::idx#7) ← (number) $18>>(number) 1
  (byte) testBytes::idx#8 ← ++ (byte) testBytes::idx#7
  *((const byte*) testBytes::SCREEN + (byte) testBytes::idx#8) ← (number) $f&(number) $1c
  (byte) testBytes::idx#9 ← ++ (byte) testBytes::idx#8
  *((const byte*) testBytes::SCREEN + (byte) testBytes::idx#9) ← (number) 4|(number) 8
  (byte) testBytes::idx#10 ← ++ (byte) testBytes::idx#9
  *((const byte*) testBytes::SCREEN + (byte) testBytes::idx#10) ← (number) 5^(number) 9
  (byte) testBytes::idx#11 ← ++ (byte) testBytes::idx#10
  *((const byte*) testBytes::SCREEN + (byte) testBytes::idx#11) ← (number) 2+(number) 2*(number) $f/(number) 5
  (byte) testBytes::idx#12 ← ++ (byte) testBytes::idx#11
  *((const byte*) testBytes::SCREEN + (byte) testBytes::idx#12) ← (byte)(number) $1000+(number) $c
  (byte) testBytes::idx#13 ← ++ (byte) testBytes::idx#12
  to:testBytes::@return
testBytes::@return: scope:[testBytes]  from testBytes
  return 
  to:@return

(void()) testSBytes()
testSBytes: scope:[testSBytes]  from main::@1
  (byte) testSBytes::idx#0 ← (byte) 0
  *((const signed byte*) testSBytes::SCREEN + (byte) testSBytes::idx#0) ← (number) -$c
  (byte) testSBytes::idx#1 ← ++ (byte) testSBytes::idx#0
  *((const signed byte*) testSBytes::SCREEN + (byte) testSBytes::idx#1) ← (number) -6-(number) 6
  (byte) testSBytes::idx#2 ← ++ (byte) testSBytes::idx#1
  *((const signed byte*) testSBytes::SCREEN + (byte) testSBytes::idx#2) ← (number) -$12+(number) 6
  (byte) testSBytes::idx#3 ← ++ (byte) testSBytes::idx#2
  *((const signed byte*) testSBytes::SCREEN + (byte) testSBytes::idx#3) ← (number) -$714+(number) $708
  (byte) testSBytes::idx#4 ← ++ (byte) testSBytes::idx#3
  *((const signed byte*) testSBytes::SCREEN + (byte) testSBytes::idx#4) ← (number) -1-(number) 2-(number) 3-(number) 6
  (byte) testSBytes::idx#5 ← ++ (byte) testSBytes::idx#4
  *((const signed byte*) testSBytes::SCREEN + (byte) testSBytes::idx#5) ← (number) -2*(number) 6
  (byte) testSBytes::idx#6 ← ++ (byte) testSBytes::idx#5
  *((const signed byte*) testSBytes::SCREEN + (byte) testSBytes::idx#6) ← (number) -3<<(number) 2
  (byte) testSBytes::idx#7 ← ++ (byte) testSBytes::idx#6
  *((const signed byte*) testSBytes::SCREEN + (byte) testSBytes::idx#7) ← (number) -$18>>(number) 1
  (byte) testSBytes::idx#8 ← ++ (byte) testSBytes::idx#7
  *((const signed byte*) testSBytes::SCREEN + (byte) testSBytes::idx#8) ← (number) -4&(number) -9
  (byte) testSBytes::idx#9 ← ++ (byte) testSBytes::idx#8
  *((const signed byte*) testSBytes::SCREEN + (byte) testSBytes::idx#9) ← (number) -$10|(number) -$fc
  (byte) testSBytes::idx#10 ← ++ (byte) testSBytes::idx#9
  *((const signed byte*) testSBytes::SCREEN + (byte) testSBytes::idx#10) ← (number) -2-(number) 2*(number) $f/(number) 5
  (byte) testSBytes::idx#11 ← ++ (byte) testSBytes::idx#10
  *((const signed byte*) testSBytes::SCREEN + (byte) testSBytes::idx#11) ← (signed byte)(number) $1000-(number) $c
  (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()
(label) testBytes::@return
(const byte*) testBytes::SCREEN = (byte*)(number) $400
(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()
(label) testSBytes::@return
(const signed byte*) testSBytes::SCREEN = (signed byte*)(number) $428
(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) $c in *((const byte*) testBytes::SCREEN + (byte) testBytes::idx#0) ← (number) $c
Adding number conversion cast (unumber) 6+6 in *((const byte*) testBytes::SCREEN + (byte) testBytes::idx#1) ← (number) 6+(number) 6
Adding number conversion cast (unumber) $12-6 in *((const byte*) testBytes::SCREEN + (byte) testBytes::idx#2) ← (number) $12-(number) 6
Adding number conversion cast (unumber) $714-$708 in *((const byte*) testBytes::SCREEN + (byte) testBytes::idx#3) ← (number) $714-(number) $708
Adding number conversion cast (unumber) 1+2+3+6 in *((const byte*) testBytes::SCREEN + (byte) testBytes::idx#4) ← (number) 1+(number) 2+(number) 3+(number) 6
Adding number conversion cast (unumber) 2*6 in *((const byte*) testBytes::SCREEN + (byte) testBytes::idx#5) ← (number) 2*(number) 6
Adding number conversion cast (unumber) 3<<2 in *((const byte*) testBytes::SCREEN + (byte) testBytes::idx#6) ← (number) 3<<(number) 2
Adding number conversion cast (unumber) $18>>1 in *((const byte*) testBytes::SCREEN + (byte) testBytes::idx#7) ← (number) $18>>(number) 1
Adding number conversion cast (unumber) $f&$1c in *((const byte*) testBytes::SCREEN + (byte) testBytes::idx#8) ← (number) $f&(number) $1c
Adding number conversion cast (unumber) 4|8 in *((const byte*) testBytes::SCREEN + (byte) testBytes::idx#9) ← (number) 4|(number) 8
Adding number conversion cast (unumber) 5^9 in *((const byte*) testBytes::SCREEN + (byte) testBytes::idx#10) ← (number) 5^(number) 9
Adding number conversion cast (unumber) 2+2*$f/5 in *((const byte*) testBytes::SCREEN + (byte) testBytes::idx#11) ← (number) 2+(number) 2*(number) $f/(number) 5
Adding number conversion cast (snumber) -$c in *((const signed byte*) testSBytes::SCREEN + (byte) testSBytes::idx#0) ← (number) -$c
Adding number conversion cast (snumber) -6-6 in *((const signed byte*) testSBytes::SCREEN + (byte) testSBytes::idx#1) ← (number) -6-(number) 6
Adding number conversion cast (snumber) -$12+6 in *((const signed byte*) testSBytes::SCREEN + (byte) testSBytes::idx#2) ← (number) -$12+(number) 6
Adding number conversion cast (snumber) -$714+$708 in *((const signed byte*) testSBytes::SCREEN + (byte) testSBytes::idx#3) ← (number) -$714+(number) $708
Adding number conversion cast (snumber) -1-2-3-6 in *((const signed byte*) testSBytes::SCREEN + (byte) testSBytes::idx#4) ← (number) -1-(number) 2-(number) 3-(number) 6
Adding number conversion cast (snumber) -2*6 in *((const signed byte*) testSBytes::SCREEN + (byte) testSBytes::idx#5) ← (number) -2*(number) 6
Adding number conversion cast (snumber) -3<<2 in *((const signed byte*) testSBytes::SCREEN + (byte) testSBytes::idx#6) ← (number) -3<<(number) 2
Adding number conversion cast (snumber) -$18>>1 in *((const signed byte*) testSBytes::SCREEN + (byte) testSBytes::idx#7) ← (number) -$18>>(number) 1
Adding number conversion cast (snumber) -4&-9 in *((const signed byte*) testSBytes::SCREEN + (byte) testSBytes::idx#8) ← (number) -4&(number) -9
Adding number conversion cast (snumber) -$10|-$fc in *((const signed byte*) testSBytes::SCREEN + (byte) testSBytes::idx#9) ← (number) -$10|(number) -$fc
Adding number conversion cast (snumber) -2-2*$f/5 in *((const signed byte*) testSBytes::SCREEN + (byte) testSBytes::idx#10) ← (number) -2-(number) 2*(number) $f/(number) 5
Successful SSA optimization PassNAddNumberTypeConversions
Inlining cast *((const byte*) testBytes::SCREEN + (byte) testBytes::idx#0) ← (unumber)(number) $c
Inlining cast *((const byte*) testBytes::SCREEN + (byte) testBytes::idx#1) ← (unumber)(number) 6+(number) 6
Inlining cast *((const byte*) testBytes::SCREEN + (byte) testBytes::idx#2) ← (unumber)(number) $12-(number) 6
Inlining cast *((const byte*) testBytes::SCREEN + (byte) testBytes::idx#3) ← (unumber)(number) $714-(number) $708
Inlining cast *((const byte*) testBytes::SCREEN + (byte) testBytes::idx#4) ← (unumber)(number) 1+(number) 2+(number) 3+(number) 6
Inlining cast *((const byte*) testBytes::SCREEN + (byte) testBytes::idx#5) ← (unumber)(number) 2*(number) 6
Inlining cast *((const byte*) testBytes::SCREEN + (byte) testBytes::idx#6) ← (unumber)(number) 3<<(number) 2
Inlining cast *((const byte*) testBytes::SCREEN + (byte) testBytes::idx#7) ← (unumber)(number) $18>>(number) 1
Inlining cast *((const byte*) testBytes::SCREEN + (byte) testBytes::idx#8) ← (unumber)(number) $f&(number) $1c
Inlining cast *((const byte*) testBytes::SCREEN + (byte) testBytes::idx#9) ← (unumber)(number) 4|(number) 8
Inlining cast *((const byte*) testBytes::SCREEN + (byte) testBytes::idx#10) ← (unumber)(number) 5^(number) 9
Inlining cast *((const byte*) testBytes::SCREEN + (byte) testBytes::idx#11) ← (unumber)(number) 2+(number) 2*(number) $f/(number) 5
Inlining cast *((const signed byte*) testSBytes::SCREEN + (byte) testSBytes::idx#0) ← (snumber)(number) -$c
Inlining cast *((const signed byte*) testSBytes::SCREEN + (byte) testSBytes::idx#1) ← (snumber)(number) -6-(number) 6
Inlining cast *((const signed byte*) testSBytes::SCREEN + (byte) testSBytes::idx#2) ← (snumber)(number) -$12+(number) 6
Inlining cast *((const signed byte*) testSBytes::SCREEN + (byte) testSBytes::idx#3) ← (snumber)(number) -$714+(number) $708
Inlining cast *((const signed byte*) testSBytes::SCREEN + (byte) testSBytes::idx#4) ← (snumber)(number) -1-(number) 2-(number) 3-(number) 6
Inlining cast *((const signed byte*) testSBytes::SCREEN + (byte) testSBytes::idx#5) ← (snumber)(number) -2*(number) 6
Inlining cast *((const signed byte*) testSBytes::SCREEN + (byte) testSBytes::idx#6) ← (snumber)(number) -3<<(number) 2
Inlining cast *((const signed byte*) testSBytes::SCREEN + (byte) testSBytes::idx#7) ← (snumber)(number) -$18>>(number) 1
Inlining cast *((const signed byte*) testSBytes::SCREEN + (byte) testSBytes::idx#8) ← (snumber)(number) -4&(number) -9
Inlining cast *((const signed byte*) testSBytes::SCREEN + (byte) testSBytes::idx#9) ← (snumber)(number) -$10|(number) -$fc
Inlining cast *((const signed byte*) testSBytes::SCREEN + (byte) testSBytes::idx#10) ← (snumber)(number) -2-(number) 2*(number) $f/(number) 5
Successful SSA optimization Pass2InlineCast
Simplifying constant pointer cast (byte*) 1024
Simplifying constant pointer cast (signed byte*) 1064
Simplifying constant integer cast $c
Simplifying constant integer cast -$c
Successful SSA optimization PassNCastSimplification
Finalized unsigned number type (byte) $c
Finalized signed number type (signed byte) -$c
Successful SSA optimization PassNFinalizeNumberTypeConversions
Constant right-side identified [6] *((const byte*) testBytes::SCREEN + (byte) testBytes::idx#1) ← (unumber)(number) 6+(number) 6
Constant right-side identified [8] *((const byte*) testBytes::SCREEN + (byte) testBytes::idx#2) ← (unumber)(number) $12-(number) 6
Constant right-side identified [10] *((const byte*) testBytes::SCREEN + (byte) testBytes::idx#3) ← (unumber)(number) $714-(number) $708
Constant right-side identified [12] *((const byte*) testBytes::SCREEN + (byte) testBytes::idx#4) ← (unumber)(number) 1+(number) 2+(number) 3+(number) 6
Constant right-side identified [14] *((const byte*) testBytes::SCREEN + (byte) testBytes::idx#5) ← (unumber)(number) 2*(number) 6
Constant right-side identified [16] *((const byte*) testBytes::SCREEN + (byte) testBytes::idx#6) ← (unumber)(number) 3<<(number) 2
Constant right-side identified [18] *((const byte*) testBytes::SCREEN + (byte) testBytes::idx#7) ← (unumber)(number) $18>>(number) 1
Constant right-side identified [20] *((const byte*) testBytes::SCREEN + (byte) testBytes::idx#8) ← (unumber)(number) $f&(number) $1c
Constant right-side identified [22] *((const byte*) testBytes::SCREEN + (byte) testBytes::idx#9) ← (unumber)(number) 4|(number) 8
Constant right-side identified [24] *((const byte*) testBytes::SCREEN + (byte) testBytes::idx#10) ← (unumber)(number) 5^(number) 9
Constant right-side identified [26] *((const byte*) testBytes::SCREEN + (byte) testBytes::idx#11) ← (unumber)(number) 2+(number) 2*(number) $f/(number) 5
Constant right-side identified [34] *((const signed byte*) testSBytes::SCREEN + (byte) testSBytes::idx#1) ← (snumber)(number) -6-(number) 6
Constant right-side identified [36] *((const signed byte*) testSBytes::SCREEN + (byte) testSBytes::idx#2) ← (snumber)(number) -$12+(number) 6
Constant right-side identified [38] *((const signed byte*) testSBytes::SCREEN + (byte) testSBytes::idx#3) ← (snumber)(number) -$714+(number) $708
Constant right-side identified [40] *((const signed byte*) testSBytes::SCREEN + (byte) testSBytes::idx#4) ← (snumber)(number) -1-(number) 2-(number) 3-(number) 6
Constant right-side identified [42] *((const signed byte*) testSBytes::SCREEN + (byte) testSBytes::idx#5) ← (snumber)(number) -2*(number) 6
Constant right-side identified [44] *((const signed byte*) testSBytes::SCREEN + (byte) testSBytes::idx#6) ← (snumber)(number) -3<<(number) 2
Constant right-side identified [46] *((const signed byte*) testSBytes::SCREEN + (byte) testSBytes::idx#7) ← (snumber)(number) -$18>>(number) 1
Constant right-side identified [48] *((const signed byte*) testSBytes::SCREEN + (byte) testSBytes::idx#8) ← (snumber)(number) -4&(number) -9
Constant right-side identified [50] *((const signed byte*) testSBytes::SCREEN + (byte) testSBytes::idx#9) ← (snumber)(number) -$10|(number) -$fc
Constant right-side identified [52] *((const signed byte*) testSBytes::SCREEN + (byte) testSBytes::idx#10) ← (snumber)(number) -2-(number) 2*(number) $f/(number) 5
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte) testBytes::idx#0 = 0
Constant (const byte) testSBytes::idx#0 = 0
Successful SSA optimization Pass2ConstantIdentification
Simplifying expression containing zero testBytes::SCREEN in [4] *((const byte*) testBytes::SCREEN + (const byte) testBytes::idx#0) ← (byte) $c
Simplifying expression containing zero testSBytes::SCREEN in [32] *((const signed byte*) testSBytes::SCREEN + (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 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)
Consolidated array index constant in *(testBytes::SCREEN+++++0)
Consolidated array index constant in *(testBytes::SCREEN+++++++0)
Consolidated array index constant in *(testBytes::SCREEN+++++++++0)
Consolidated array index constant in *(testBytes::SCREEN+++++++++++0)
Consolidated array index constant in *(testBytes::SCREEN+++++++++++++0)
Consolidated array index constant in *(testBytes::SCREEN+++++++++++++++0)
Consolidated array index constant in *(testBytes::SCREEN+++++++++++++++++0)
Consolidated array index constant in *(testBytes::SCREEN+++++++++++++++++++0)
Consolidated array index constant in *(testBytes::SCREEN+++++++++++++++++++++0)
Consolidated array index constant in *(testBytes::SCREEN+++++++++++++++++++++++0)
Consolidated array index constant in *(testBytes::SCREEN+++++++++++++++++++++++++0)
Consolidated array index constant in *(testSBytes::SCREEN+++0)
Consolidated array index constant in *(testSBytes::SCREEN+++++0)
Consolidated array index constant in *(testSBytes::SCREEN+++++++0)
Consolidated array index constant in *(testSBytes::SCREEN+++++++++0)
Consolidated array index constant in *(testSBytes::SCREEN+++++++++++0)
Consolidated array index constant in *(testSBytes::SCREEN+++++++++++++0)
Consolidated array index constant in *(testSBytes::SCREEN+++++++++++++++0)
Consolidated array index constant in *(testSBytes::SCREEN+++++++++++++++++0)
Consolidated array index constant in *(testSBytes::SCREEN+++++++++++++++++++0)
Consolidated array index constant in *(testSBytes::SCREEN+++++++++++++++++++++0)
Consolidated array index constant in *(testSBytes::SCREEN+++++++++++++++++++++++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()

(void()) main()
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

(void()) testSBytes()
testSBytes: scope:[testSBytes]  from main::@1
  [9] *((const signed byte*) testSBytes::SCREEN) ← (signed byte) -$c
  [10] *((const signed byte*) testSBytes::SCREEN+(byte) 1) ← (signed byte)(number) -6-(number) 6
  [11] *((const signed byte*) testSBytes::SCREEN+(byte) 2) ← (signed byte)(number) -$12+(number) 6
  [12] *((const signed byte*) testSBytes::SCREEN+(byte) 3) ← (signed byte)(number) -$714+(number) $708
  [13] *((const signed byte*) testSBytes::SCREEN+(byte) 4) ← (signed byte)(number) -1-(number) 2-(number) 3-(number) 6
  [14] *((const signed byte*) testSBytes::SCREEN+(byte) 5) ← (signed byte)(number) -2*(number) 6
  [15] *((const signed byte*) testSBytes::SCREEN+(byte) 6) ← (signed byte)(number) -3<<(number) 2
  [16] *((const signed byte*) testSBytes::SCREEN+(byte) 7) ← (signed byte)(number) -$18>>(number) 1
  [17] *((const signed byte*) testSBytes::SCREEN+(byte) 8) ← (signed byte)(number) -4&(number) -9
  [18] *((const signed byte*) testSBytes::SCREEN+(byte) 9) ← (signed byte)(number) -$10|(number) -$fc
  [19] *((const signed byte*) testSBytes::SCREEN+(byte) $a) ← (signed byte)(number) -2-(number) 2*(number) $f/(number) 5
  [20] *((const signed byte*) testSBytes::SCREEN+(byte) $b) ← (signed byte)(number) $1000-(number) $c
  to:testSBytes::@return
testSBytes::@return: scope:[testSBytes]  from testSBytes
  [21] return 
  to:@return

(void()) testBytes()
testBytes: scope:[testBytes]  from main
  [22] *((const byte*) testBytes::SCREEN) ← (byte) $c
  [23] *((const byte*) testBytes::SCREEN+(byte) 1) ← (byte)(number) 6+(number) 6
  [24] *((const byte*) testBytes::SCREEN+(byte) 2) ← (byte)(number) $12-(number) 6
  [25] *((const byte*) testBytes::SCREEN+(byte) 3) ← (byte)(number) $714-(number) $708
  [26] *((const byte*) testBytes::SCREEN+(byte) 4) ← (byte)(number) 1+(number) 2+(number) 3+(number) 6
  [27] *((const byte*) testBytes::SCREEN+(byte) 5) ← (byte)(number) 2*(number) 6
  [28] *((const byte*) testBytes::SCREEN+(byte) 6) ← (byte)(number) 3<<(number) 2
  [29] *((const byte*) testBytes::SCREEN+(byte) 7) ← (byte)(number) $18>>(number) 1
  [30] *((const byte*) testBytes::SCREEN+(byte) 8) ← (byte)(number) $f&(number) $1c
  [31] *((const byte*) testBytes::SCREEN+(byte) 9) ← (byte)(number) 4|(number) 8
  [32] *((const byte*) testBytes::SCREEN+(byte) $a) ← (byte)(number) 5^(number) 9
  [33] *((const byte*) testBytes::SCREEN+(byte) $b) ← (byte)(number) 2+(number) 2*(number) $f/(number) 5
  [34] *((const byte*) testBytes::SCREEN+(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::idx
(void()) testSBytes()
(byte) testSBytes::idx

Initial phi equivalence classes
Complete equivalence classes

INITIAL ASM
Target platform is c64basic / MOS6502X
  // 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) ← (signed byte) -$c -- _deref_pbsc1=vbsc2 
    lda #-$c
    sta SCREEN
    // [10] *((const signed byte*) testSBytes::SCREEN+(byte) 1) ← (signed byte)(number) -6-(number) 6 -- _deref_pbsc1=vbsc2 
    lda #-6-6
    sta SCREEN+1
    // [11] *((const signed byte*) testSBytes::SCREEN+(byte) 2) ← (signed byte)(number) -$12+(number) 6 -- _deref_pbsc1=vbsc2 
    lda #-$12+6
    sta SCREEN+2
    // [12] *((const signed byte*) testSBytes::SCREEN+(byte) 3) ← (signed byte)(number) -$714+(number) $708 -- _deref_pbsc1=vbsc2 
    lda #-$714+$708
    sta SCREEN+3
    // [13] *((const signed byte*) testSBytes::SCREEN+(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+(byte) 5) ← (signed byte)(number) -2*(number) 6 -- _deref_pbsc1=vbsc2 
    lda #-2*6
    sta SCREEN+5
    // [15] *((const signed byte*) testSBytes::SCREEN+(byte) 6) ← (signed byte)(number) -3<<(number) 2 -- _deref_pbsc1=vbsc2 
    lda #-3<<2
    sta SCREEN+6
    // [16] *((const signed byte*) testSBytes::SCREEN+(byte) 7) ← (signed byte)(number) -$18>>(number) 1 -- _deref_pbsc1=vbsc2 
    lda #-$18>>1
    sta SCREEN+7
    // [17] *((const signed byte*) testSBytes::SCREEN+(byte) 8) ← (signed byte)(number) -4&(number) -9 -- _deref_pbsc1=vbsc2 
    lda #-4&-9
    sta SCREEN+8
    // [18] *((const signed byte*) testSBytes::SCREEN+(byte) 9) ← (signed byte)(number) -$10|(number) -$fc -- _deref_pbsc1=vbsc2 
    lda #-$10|-$fc
    sta SCREEN+9
    // [19] *((const signed byte*) testSBytes::SCREEN+(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+(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) ← (byte) $c -- _deref_pbuc1=vbuc2 
    lda #$c
    sta SCREEN
    // [23] *((const byte*) testBytes::SCREEN+(byte) 1) ← (byte)(number) 6+(number) 6 -- _deref_pbuc1=vbuc2 
    lda #6+6
    sta SCREEN+1
    // [24] *((const byte*) testBytes::SCREEN+(byte) 2) ← (byte)(number) $12-(number) 6 -- _deref_pbuc1=vbuc2 
    lda #$12-6
    sta SCREEN+2
    // [25] *((const byte*) testBytes::SCREEN+(byte) 3) ← (byte)(number) $714-(number) $708 -- _deref_pbuc1=vbuc2 
    lda #$714-$708
    sta SCREEN+3
    // [26] *((const byte*) testBytes::SCREEN+(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+(byte) 5) ← (byte)(number) 2*(number) 6 -- _deref_pbuc1=vbuc2 
    lda #2*6
    sta SCREEN+5
    // [28] *((const byte*) testBytes::SCREEN+(byte) 6) ← (byte)(number) 3<<(number) 2 -- _deref_pbuc1=vbuc2 
    lda #3<<2
    sta SCREEN+6
    // [29] *((const byte*) testBytes::SCREEN+(byte) 7) ← (byte)(number) $18>>(number) 1 -- _deref_pbuc1=vbuc2 
    lda #$18>>1
    sta SCREEN+7
    // [30] *((const byte*) testBytes::SCREEN+(byte) 8) ← (byte)(number) $f&(number) $1c -- _deref_pbuc1=vbuc2 
    lda #$f&$1c
    sta SCREEN+8
    // [31] *((const byte*) testBytes::SCREEN+(byte) 9) ← (byte)(number) 4|(number) 8 -- _deref_pbuc1=vbuc2 
    lda #4|8
    sta SCREEN+9
    // [32] *((const byte*) testBytes::SCREEN+(byte) $a) ← (byte)(number) 5^(number) 9 -- _deref_pbuc1=vbuc2 
    lda #5^9
    sta SCREEN+$a
    // [33] *((const byte*) testBytes::SCREEN+(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+(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) ← (signed byte) -$c [ ] ( main:2::testSBytes:7 [ ] ) always clobbers reg byte a 
Statement [10] *((const signed byte*) testSBytes::SCREEN+(byte) 1) ← (signed byte)(number) -6-(number) 6 [ ] ( main:2::testSBytes:7 [ ] ) always clobbers reg byte a 
Statement [11] *((const signed byte*) testSBytes::SCREEN+(byte) 2) ← (signed byte)(number) -$12+(number) 6 [ ] ( main:2::testSBytes:7 [ ] ) always clobbers reg byte a 
Statement [12] *((const signed byte*) testSBytes::SCREEN+(byte) 3) ← (signed byte)(number) -$714+(number) $708 [ ] ( main:2::testSBytes:7 [ ] ) always clobbers reg byte a 
Statement [13] *((const signed byte*) testSBytes::SCREEN+(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+(byte) 5) ← (signed byte)(number) -2*(number) 6 [ ] ( main:2::testSBytes:7 [ ] ) always clobbers reg byte a 
Statement [15] *((const signed byte*) testSBytes::SCREEN+(byte) 6) ← (signed byte)(number) -3<<(number) 2 [ ] ( main:2::testSBytes:7 [ ] ) always clobbers reg byte a 
Statement [16] *((const signed byte*) testSBytes::SCREEN+(byte) 7) ← (signed byte)(number) -$18>>(number) 1 [ ] ( main:2::testSBytes:7 [ ] ) always clobbers reg byte a 
Statement [17] *((const signed byte*) testSBytes::SCREEN+(byte) 8) ← (signed byte)(number) -4&(number) -9 [ ] ( main:2::testSBytes:7 [ ] ) always clobbers reg byte a 
Statement [18] *((const signed byte*) testSBytes::SCREEN+(byte) 9) ← (signed byte)(number) -$10|(number) -$fc [ ] ( main:2::testSBytes:7 [ ] ) always clobbers reg byte a 
Statement [19] *((const signed byte*) testSBytes::SCREEN+(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+(byte) $b) ← (signed byte)(number) $1000-(number) $c [ ] ( main:2::testSBytes:7 [ ] ) always clobbers reg byte a 
Statement [22] *((const byte*) testBytes::SCREEN) ← (byte) $c [ ] ( main:2::testBytes:5 [ ] ) always clobbers reg byte a 
Statement [23] *((const byte*) testBytes::SCREEN+(byte) 1) ← (byte)(number) 6+(number) 6 [ ] ( main:2::testBytes:5 [ ] ) always clobbers reg byte a 
Statement [24] *((const byte*) testBytes::SCREEN+(byte) 2) ← (byte)(number) $12-(number) 6 [ ] ( main:2::testBytes:5 [ ] ) always clobbers reg byte a 
Statement [25] *((const byte*) testBytes::SCREEN+(byte) 3) ← (byte)(number) $714-(number) $708 [ ] ( main:2::testBytes:5 [ ] ) always clobbers reg byte a 
Statement [26] *((const byte*) testBytes::SCREEN+(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+(byte) 5) ← (byte)(number) 2*(number) 6 [ ] ( main:2::testBytes:5 [ ] ) always clobbers reg byte a 
Statement [28] *((const byte*) testBytes::SCREEN+(byte) 6) ← (byte)(number) 3<<(number) 2 [ ] ( main:2::testBytes:5 [ ] ) always clobbers reg byte a 
Statement [29] *((const byte*) testBytes::SCREEN+(byte) 7) ← (byte)(number) $18>>(number) 1 [ ] ( main:2::testBytes:5 [ ] ) always clobbers reg byte a 
Statement [30] *((const byte*) testBytes::SCREEN+(byte) 8) ← (byte)(number) $f&(number) $1c [ ] ( main:2::testBytes:5 [ ] ) always clobbers reg byte a 
Statement [31] *((const byte*) testBytes::SCREEN+(byte) 9) ← (byte)(number) 4|(number) 8 [ ] ( main:2::testBytes:5 [ ] ) always clobbers reg byte a 
Statement [32] *((const byte*) testBytes::SCREEN+(byte) $a) ← (byte)(number) 5^(number) 9 [ ] ( main:2::testBytes:5 [ ] ) always clobbers reg byte a 
Statement [33] *((const byte*) testBytes::SCREEN+(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+(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) ← (signed byte) -$c -- _deref_pbsc1=vbsc2 
    lda #-$c
    sta SCREEN
    // [10] *((const signed byte*) testSBytes::SCREEN+(byte) 1) ← (signed byte)(number) -6-(number) 6 -- _deref_pbsc1=vbsc2 
    lda #-6-6
    sta SCREEN+1
    // [11] *((const signed byte*) testSBytes::SCREEN+(byte) 2) ← (signed byte)(number) -$12+(number) 6 -- _deref_pbsc1=vbsc2 
    lda #-$12+6
    sta SCREEN+2
    // [12] *((const signed byte*) testSBytes::SCREEN+(byte) 3) ← (signed byte)(number) -$714+(number) $708 -- _deref_pbsc1=vbsc2 
    lda #-$714+$708
    sta SCREEN+3
    // [13] *((const signed byte*) testSBytes::SCREEN+(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+(byte) 5) ← (signed byte)(number) -2*(number) 6 -- _deref_pbsc1=vbsc2 
    lda #-2*6
    sta SCREEN+5
    // [15] *((const signed byte*) testSBytes::SCREEN+(byte) 6) ← (signed byte)(number) -3<<(number) 2 -- _deref_pbsc1=vbsc2 
    lda #-3<<2
    sta SCREEN+6
    // [16] *((const signed byte*) testSBytes::SCREEN+(byte) 7) ← (signed byte)(number) -$18>>(number) 1 -- _deref_pbsc1=vbsc2 
    lda #-$18>>1
    sta SCREEN+7
    // [17] *((const signed byte*) testSBytes::SCREEN+(byte) 8) ← (signed byte)(number) -4&(number) -9 -- _deref_pbsc1=vbsc2 
    lda #-4&-9
    sta SCREEN+8
    // [18] *((const signed byte*) testSBytes::SCREEN+(byte) 9) ← (signed byte)(number) -$10|(number) -$fc -- _deref_pbsc1=vbsc2 
    lda #-$10|-$fc
    sta SCREEN+9
    // [19] *((const signed byte*) testSBytes::SCREEN+(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+(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) ← (byte) $c -- _deref_pbuc1=vbuc2 
    lda #$c
    sta SCREEN
    // [23] *((const byte*) testBytes::SCREEN+(byte) 1) ← (byte)(number) 6+(number) 6 -- _deref_pbuc1=vbuc2 
    lda #6+6
    sta SCREEN+1
    // [24] *((const byte*) testBytes::SCREEN+(byte) 2) ← (byte)(number) $12-(number) 6 -- _deref_pbuc1=vbuc2 
    lda #$12-6
    sta SCREEN+2
    // [25] *((const byte*) testBytes::SCREEN+(byte) 3) ← (byte)(number) $714-(number) $708 -- _deref_pbuc1=vbuc2 
    lda #$714-$708
    sta SCREEN+3
    // [26] *((const byte*) testBytes::SCREEN+(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+(byte) 5) ← (byte)(number) 2*(number) 6 -- _deref_pbuc1=vbuc2 
    lda #2*6
    sta SCREEN+5
    // [28] *((const byte*) testBytes::SCREEN+(byte) 6) ← (byte)(number) 3<<(number) 2 -- _deref_pbuc1=vbuc2 
    lda #3<<2
    sta SCREEN+6
    // [29] *((const byte*) testBytes::SCREEN+(byte) 7) ← (byte)(number) $18>>(number) 1 -- _deref_pbuc1=vbuc2 
    lda #$18>>1
    sta SCREEN+7
    // [30] *((const byte*) testBytes::SCREEN+(byte) 8) ← (byte)(number) $f&(number) $1c -- _deref_pbuc1=vbuc2 
    lda #$f&$1c
    sta SCREEN+8
    // [31] *((const byte*) testBytes::SCREEN+(byte) 9) ← (byte)(number) 4|(number) 8 -- _deref_pbuc1=vbuc2 
    lda #4|8
    sta SCREEN+9
    // [32] *((const byte*) testBytes::SCREEN+(byte) $a) ← (byte)(number) 5^(number) 9 -- _deref_pbuc1=vbuc2 
    lda #5^9
    sta SCREEN+$a
    // [33] *((const byte*) testBytes::SCREEN+(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+(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
Replacing label __bbegin with __b1
Removing instruction __bbegin:
Removing instruction __b1_from___bbegin:
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 __b1:
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
(const byte*) testBytes::SCREEN = (byte*) 1024
(byte) testBytes::idx
(void()) testSBytes()
(label) testSBytes::@return
(const signed byte*) testSBytes::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) ← (signed byte) -$c -- _deref_pbsc1=vbsc2 
    lda #-$c
    sta SCREEN
    // SCREEN[idx++] = -6-6
    // [10] *((const signed byte*) testSBytes::SCREEN+(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+(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+(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+(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+(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+(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+(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+(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+(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+(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+(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) ← (byte) $c -- _deref_pbuc1=vbuc2 
    lda #$c
    sta SCREEN
    // SCREEN[idx++] = 6+6
    // [23] *((const byte*) testBytes::SCREEN+(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+(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+(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+(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+(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+(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+(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+(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+(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+(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+(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+(byte) $c) ← (byte)(number) $1000+(number) $c -- _deref_pbuc1=vbuc2 
    lda #$ff&$1000+$c
    sta SCREEN+$c
    // testBytes::@return
    // }
    // [35] return 
    rts
}
  // File Data

