
CONTROL FLOW GRAPH SSA

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

void testSBytes()
testSBytes: scope:[testSBytes]  from main::@1
  testSBytes::idx#0 = 0
  testSBytes::SCREEN[testSBytes::idx#0] = -$c
  testSBytes::idx#1 = ++ testSBytes::idx#0
  testSBytes::SCREEN[testSBytes::idx#1] = -6-6
  testSBytes::idx#2 = ++ testSBytes::idx#1
  testSBytes::SCREEN[testSBytes::idx#2] = -$12+6
  testSBytes::idx#3 = ++ testSBytes::idx#2
  testSBytes::SCREEN[testSBytes::idx#3] = -$714+$708
  testSBytes::idx#4 = ++ testSBytes::idx#3
  testSBytes::SCREEN[testSBytes::idx#4] = -1-2-3-6
  testSBytes::idx#5 = ++ testSBytes::idx#4
  testSBytes::SCREEN[testSBytes::idx#5] = -2*6
  testSBytes::idx#6 = ++ testSBytes::idx#5
  testSBytes::SCREEN[testSBytes::idx#6] = -3<<2
  testSBytes::idx#7 = ++ testSBytes::idx#6
  testSBytes::SCREEN[testSBytes::idx#7] = -$18>>1
  testSBytes::idx#8 = ++ testSBytes::idx#7
  testSBytes::SCREEN[testSBytes::idx#8] = -4&-9
  testSBytes::idx#9 = ++ testSBytes::idx#8
  testSBytes::SCREEN[testSBytes::idx#9] = -$10|-$fc
  testSBytes::idx#10 = ++ testSBytes::idx#9
  testSBytes::SCREEN[testSBytes::idx#10] = -2-2*$f/5
  testSBytes::idx#11 = ++ testSBytes::idx#10
  testSBytes::SCREEN[testSBytes::idx#11] = (signed char)$1000-$c
  testSBytes::idx#12 = ++ testSBytes::idx#11
  to:testSBytes::@return
testSBytes::@return: scope:[testSBytes]  from testSBytes
  return 
  to:@return

void __start()
__start: scope:[__start]  from
  call main
  to:__start::@1
__start::@1: scope:[__start]  from __start
  to:__start::@return
__start::@return: scope:[__start]  from __start::@1
  return 
  to:@return

SYMBOL TABLE SSA
void __start()
void main()
void testBytes()
__constant char * const testBytes::SCREEN = (char *)$400
char testBytes::idx
char testBytes::idx#0
char testBytes::idx#1
char testBytes::idx#10
char testBytes::idx#11
char testBytes::idx#12
char testBytes::idx#13
char testBytes::idx#2
char testBytes::idx#3
char testBytes::idx#4
char testBytes::idx#5
char testBytes::idx#6
char testBytes::idx#7
char testBytes::idx#8
char testBytes::idx#9
void testSBytes()
__constant signed char * const testSBytes::SCREEN = (signed char *)$428
char testSBytes::idx
char testSBytes::idx#0
char testSBytes::idx#1
char testSBytes::idx#10
char testSBytes::idx#11
char testSBytes::idx#12
char testSBytes::idx#2
char testSBytes::idx#3
char testSBytes::idx#4
char testSBytes::idx#5
char testSBytes::idx#6
char testSBytes::idx#7
char testSBytes::idx#8
char testSBytes::idx#9

Adding number conversion cast (unumber) $c in testBytes::SCREEN[testBytes::idx#0] = $c
Adding number conversion cast (unumber) 6+6 in testBytes::SCREEN[testBytes::idx#1] = 6+6
Adding number conversion cast (unumber) $12-6 in testBytes::SCREEN[testBytes::idx#2] = $12-6
Adding number conversion cast (unumber) $714-$708 in testBytes::SCREEN[testBytes::idx#3] = $714-$708
Adding number conversion cast (unumber) 1+2+3+6 in testBytes::SCREEN[testBytes::idx#4] = 1+2+3+6
Adding number conversion cast (unumber) 2*6 in testBytes::SCREEN[testBytes::idx#5] = 2*6
Adding number conversion cast (unumber) 3<<2 in testBytes::SCREEN[testBytes::idx#6] = 3<<2
Adding number conversion cast (unumber) $18>>1 in testBytes::SCREEN[testBytes::idx#7] = $18>>1
Adding number conversion cast (unumber) $f&$1c in testBytes::SCREEN[testBytes::idx#8] = $f&$1c
Adding number conversion cast (unumber) 4|8 in testBytes::SCREEN[testBytes::idx#9] = 4|8
Adding number conversion cast (unumber) 5^9 in testBytes::SCREEN[testBytes::idx#10] = 5^9
Adding number conversion cast (unumber) 2+2*$f/5 in testBytes::SCREEN[testBytes::idx#11] = 2+2*$f/5
Adding number conversion cast (snumber) -$c in testSBytes::SCREEN[testSBytes::idx#0] = -$c
Adding number conversion cast (snumber) -6-6 in testSBytes::SCREEN[testSBytes::idx#1] = -6-6
Adding number conversion cast (snumber) -$12+6 in testSBytes::SCREEN[testSBytes::idx#2] = -$12+6
Adding number conversion cast (snumber) -$714+$708 in testSBytes::SCREEN[testSBytes::idx#3] = -$714+$708
Adding number conversion cast (snumber) -1-2-3-6 in testSBytes::SCREEN[testSBytes::idx#4] = -1-2-3-6
Adding number conversion cast (snumber) -2*6 in testSBytes::SCREEN[testSBytes::idx#5] = -2*6
Adding number conversion cast (snumber) -3<<2 in testSBytes::SCREEN[testSBytes::idx#6] = -3<<2
Adding number conversion cast (snumber) -$18>>1 in testSBytes::SCREEN[testSBytes::idx#7] = -$18>>1
Adding number conversion cast (snumber) -4&-9 in testSBytes::SCREEN[testSBytes::idx#8] = -4&-9
Adding number conversion cast (snumber) -$10|-$fc in testSBytes::SCREEN[testSBytes::idx#9] = -$10|-$fc
Adding number conversion cast (snumber) -2-2*$f/5 in testSBytes::SCREEN[testSBytes::idx#10] = -2-2*$f/5
Successful SSA optimization PassNAddNumberTypeConversions
Inlining cast testBytes::SCREEN[testBytes::idx#0] = (unumber)$c
Inlining cast testBytes::SCREEN[testBytes::idx#1] = (unumber)6+6
Inlining cast testBytes::SCREEN[testBytes::idx#2] = (unumber)$12-6
Inlining cast testBytes::SCREEN[testBytes::idx#3] = (unumber)$714-$708
Inlining cast testBytes::SCREEN[testBytes::idx#4] = (unumber)1+2+3+6
Inlining cast testBytes::SCREEN[testBytes::idx#5] = (unumber)2*6
Inlining cast testBytes::SCREEN[testBytes::idx#6] = (unumber)3<<2
Inlining cast testBytes::SCREEN[testBytes::idx#7] = (unumber)$18>>1
Inlining cast testBytes::SCREEN[testBytes::idx#8] = (unumber)$f&$1c
Inlining cast testBytes::SCREEN[testBytes::idx#9] = (unumber)4|8
Inlining cast testBytes::SCREEN[testBytes::idx#10] = (unumber)5^9
Inlining cast testBytes::SCREEN[testBytes::idx#11] = (unumber)2+2*$f/5
Inlining cast testSBytes::SCREEN[testSBytes::idx#0] = (snumber)-$c
Inlining cast testSBytes::SCREEN[testSBytes::idx#1] = (snumber)-6-6
Inlining cast testSBytes::SCREEN[testSBytes::idx#2] = (snumber)-$12+6
Inlining cast testSBytes::SCREEN[testSBytes::idx#3] = (snumber)-$714+$708
Inlining cast testSBytes::SCREEN[testSBytes::idx#4] = (snumber)-1-2-3-6
Inlining cast testSBytes::SCREEN[testSBytes::idx#5] = (snumber)-2*6
Inlining cast testSBytes::SCREEN[testSBytes::idx#6] = (snumber)-3<<2
Inlining cast testSBytes::SCREEN[testSBytes::idx#7] = (snumber)-$18>>1
Inlining cast testSBytes::SCREEN[testSBytes::idx#8] = (snumber)-4&-9
Inlining cast testSBytes::SCREEN[testSBytes::idx#9] = (snumber)-$10|-$fc
Inlining cast testSBytes::SCREEN[testSBytes::idx#10] = (snumber)-2-2*$f/5
Successful SSA optimization Pass2InlineCast
Simplifying constant pointer cast (char *) 1024
Simplifying constant pointer cast (signed char *) 1064
Simplifying constant integer cast $c
Simplifying constant integer cast -$c
Successful SSA optimization PassNCastSimplification
Finalized unsigned number type (char) $c
Finalized signed number type (signed char) -$c
Successful SSA optimization PassNFinalizeNumberTypeConversions
Constant right-side identified [6] testBytes::SCREEN[testBytes::idx#1] = (unumber)6+6
Constant right-side identified [8] testBytes::SCREEN[testBytes::idx#2] = (unumber)$12-6
Constant right-side identified [10] testBytes::SCREEN[testBytes::idx#3] = (unumber)$714-$708
Constant right-side identified [12] testBytes::SCREEN[testBytes::idx#4] = (unumber)1+2+3+6
Constant right-side identified [14] testBytes::SCREEN[testBytes::idx#5] = (unumber)2*6
Constant right-side identified [16] testBytes::SCREEN[testBytes::idx#6] = (unumber)3<<2
Constant right-side identified [18] testBytes::SCREEN[testBytes::idx#7] = (unumber)$18>>1
Constant right-side identified [20] testBytes::SCREEN[testBytes::idx#8] = (unumber)$f&$1c
Constant right-side identified [22] testBytes::SCREEN[testBytes::idx#9] = (unumber)4|8
Constant right-side identified [24] testBytes::SCREEN[testBytes::idx#10] = (unumber)5^9
Constant right-side identified [26] testBytes::SCREEN[testBytes::idx#11] = (unumber)2+2*$f/5
Constant right-side identified [34] testSBytes::SCREEN[testSBytes::idx#1] = (snumber)-6-6
Constant right-side identified [36] testSBytes::SCREEN[testSBytes::idx#2] = (snumber)-$12+6
Constant right-side identified [38] testSBytes::SCREEN[testSBytes::idx#3] = (snumber)-$714+$708
Constant right-side identified [40] testSBytes::SCREEN[testSBytes::idx#4] = (snumber)-1-2-3-6
Constant right-side identified [42] testSBytes::SCREEN[testSBytes::idx#5] = (snumber)-2*6
Constant right-side identified [44] testSBytes::SCREEN[testSBytes::idx#6] = (snumber)-3<<2
Constant right-side identified [46] testSBytes::SCREEN[testSBytes::idx#7] = (snumber)-$18>>1
Constant right-side identified [48] testSBytes::SCREEN[testSBytes::idx#8] = (snumber)-4&-9
Constant right-side identified [50] testSBytes::SCREEN[testSBytes::idx#9] = (snumber)-$10|-$fc
Constant right-side identified [52] testSBytes::SCREEN[testSBytes::idx#10] = (snumber)-2-2*$f/5
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant testBytes::idx#0 = 0
Constant testSBytes::idx#0 = 0
Successful SSA optimization Pass2ConstantIdentification
Simplifying expression containing zero testBytes::SCREEN in [4] testBytes::SCREEN[testBytes::idx#0] = $c
Simplifying expression containing zero testSBytes::SCREEN in [32] testSBytes::SCREEN[testSBytes::idx#0] = -$c
Successful SSA optimization PassNSimplifyExpressionWithZero
Eliminating unused variable testBytes::idx#13 and assignment [28] testBytes::idx#13 = ++ testBytes::idx#12
Eliminating unused variable testSBytes::idx#12 and assignment [53] testSBytes::idx#12 = ++ testSBytes::idx#11
Successful SSA optimization PassNEliminateUnusedVars
Removing unused procedure __start
Removing unused procedure block __start
Removing unused procedure block __start::@1
Removing unused procedure block __start::@return
Successful SSA optimization PassNEliminateEmptyStart
Constant right-side identified [4] testBytes::idx#1 = ++ testBytes::idx#0
Constant right-side identified [30] testSBytes::idx#1 = ++ testSBytes::idx#0
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant testBytes::idx#1 = ++testBytes::idx#0
Constant testSBytes::idx#1 = ++testSBytes::idx#0
Successful SSA optimization Pass2ConstantIdentification
Constant right-side identified [5] testBytes::idx#2 = ++ testBytes::idx#1
Constant right-side identified [30] testSBytes::idx#2 = ++ testSBytes::idx#1
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant testBytes::idx#2 = ++testBytes::idx#1
Constant testSBytes::idx#2 = ++testSBytes::idx#1
Successful SSA optimization Pass2ConstantIdentification
Constant right-side identified [6] testBytes::idx#3 = ++ testBytes::idx#2
Constant right-side identified [30] testSBytes::idx#3 = ++ testSBytes::idx#2
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant testBytes::idx#3 = ++testBytes::idx#2
Constant testSBytes::idx#3 = ++testSBytes::idx#2
Successful SSA optimization Pass2ConstantIdentification
Constant right-side identified [7] testBytes::idx#4 = ++ testBytes::idx#3
Constant right-side identified [30] testSBytes::idx#4 = ++ testSBytes::idx#3
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant testBytes::idx#4 = ++testBytes::idx#3
Constant testSBytes::idx#4 = ++testSBytes::idx#3
Successful SSA optimization Pass2ConstantIdentification
Constant right-side identified [8] testBytes::idx#5 = ++ testBytes::idx#4
Constant right-side identified [30] testSBytes::idx#5 = ++ testSBytes::idx#4
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant testBytes::idx#5 = ++testBytes::idx#4
Constant testSBytes::idx#5 = ++testSBytes::idx#4
Successful SSA optimization Pass2ConstantIdentification
Constant right-side identified [9] testBytes::idx#6 = ++ testBytes::idx#5
Constant right-side identified [30] testSBytes::idx#6 = ++ testSBytes::idx#5
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant testBytes::idx#6 = ++testBytes::idx#5
Constant testSBytes::idx#6 = ++testSBytes::idx#5
Successful SSA optimization Pass2ConstantIdentification
Constant right-side identified [10] testBytes::idx#7 = ++ testBytes::idx#6
Constant right-side identified [30] testSBytes::idx#7 = ++ testSBytes::idx#6
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant testBytes::idx#7 = ++testBytes::idx#6
Constant testSBytes::idx#7 = ++testSBytes::idx#6
Successful SSA optimization Pass2ConstantIdentification
Constant right-side identified [11] testBytes::idx#8 = ++ testBytes::idx#7
Constant right-side identified [30] testSBytes::idx#8 = ++ testSBytes::idx#7
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant testBytes::idx#8 = ++testBytes::idx#7
Constant testSBytes::idx#8 = ++testSBytes::idx#7
Successful SSA optimization Pass2ConstantIdentification
Constant right-side identified [12] testBytes::idx#9 = ++ testBytes::idx#8
Constant right-side identified [30] testSBytes::idx#9 = ++ testSBytes::idx#8
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant testBytes::idx#9 = ++testBytes::idx#8
Constant testSBytes::idx#9 = ++testSBytes::idx#8
Successful SSA optimization Pass2ConstantIdentification
Constant right-side identified [13] testBytes::idx#10 = ++ testBytes::idx#9
Constant right-side identified [30] testSBytes::idx#10 = ++ testSBytes::idx#9
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant testBytes::idx#10 = ++testBytes::idx#9
Constant testSBytes::idx#10 = ++testSBytes::idx#9
Successful SSA optimization Pass2ConstantIdentification
Constant right-side identified [14] testBytes::idx#11 = ++ testBytes::idx#10
Constant right-side identified [30] testSBytes::idx#11 = ++ testSBytes::idx#10
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant testBytes::idx#11 = ++testBytes::idx#10
Constant testSBytes::idx#11 = ++testSBytes::idx#10
Successful SSA optimization Pass2ConstantIdentification
Constant right-side identified [15] testBytes::idx#12 = ++ testBytes::idx#11
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant testBytes::idx#12 = ++testBytes::idx#11
Successful SSA optimization Pass2ConstantIdentification
Inlining constant with different constant siblings testBytes::idx#0
Inlining constant with different constant siblings testBytes::idx#1
Inlining constant with different constant siblings testBytes::idx#2
Inlining constant with different constant siblings testBytes::idx#3
Inlining constant with different constant siblings testBytes::idx#4
Inlining constant with different constant siblings testBytes::idx#5
Inlining constant with different constant siblings testBytes::idx#6
Inlining constant with different constant siblings testBytes::idx#7
Inlining constant with different constant siblings testBytes::idx#8
Inlining constant with different constant siblings testBytes::idx#9
Inlining constant with different constant siblings testBytes::idx#10
Inlining constant with different constant siblings testBytes::idx#11
Inlining constant with different constant siblings testBytes::idx#12
Inlining constant with different constant siblings testSBytes::idx#0
Inlining constant with different constant siblings testSBytes::idx#1
Inlining constant with different constant siblings testSBytes::idx#2
Inlining constant with different constant siblings testSBytes::idx#3
Inlining constant with different constant siblings testSBytes::idx#4
Inlining constant with different constant siblings testSBytes::idx#5
Inlining constant with different constant siblings testSBytes::idx#6
Inlining constant with different constant siblings testSBytes::idx#7
Inlining constant with different constant siblings testSBytes::idx#8
Inlining constant with different constant siblings testSBytes::idx#9
Inlining constant with different constant siblings testSBytes::idx#10
Inlining constant with different constant siblings testSBytes::idx#11
Constant inlined testBytes::idx#5 = ++++++++++0
Constant inlined testBytes::idx#6 = ++++++++++++0
Constant inlined testBytes::idx#3 = ++++++0
Constant inlined testBytes::idx#4 = ++++++++0
Constant inlined testBytes::idx#1 = ++0
Constant inlined testBytes::idx#2 = ++++0
Constant inlined testBytes::idx#0 = 0
Constant inlined testBytes::idx#9 = ++++++++++++++++++0
Constant inlined testBytes::idx#7 = ++++++++++++++0
Constant inlined testBytes::idx#8 = ++++++++++++++++0
Constant inlined testBytes::idx#12 = ++++++++++++++++++++++++0
Constant inlined testBytes::idx#11 = ++++++++++++++++++++++0
Constant inlined testBytes::idx#10 = ++++++++++++++++++++0
Constant inlined testSBytes::idx#10 = ++++++++++++++++++++0
Constant inlined testSBytes::idx#9 = ++++++++++++++++++0
Constant inlined testSBytes::idx#11 = ++++++++++++++++++++++0
Constant inlined testSBytes::idx#8 = ++++++++++++++++0
Constant inlined testSBytes::idx#5 = ++++++++++0
Constant inlined testSBytes::idx#4 = ++++++++0
Constant inlined testSBytes::idx#7 = ++++++++++++++0
Constant inlined testSBytes::idx#6 = ++++++++++++0
Constant inlined testSBytes::idx#1 = ++0
Constant inlined testSBytes::idx#0 = 0
Constant inlined testSBytes::idx#3 = ++++++0
Constant inlined testSBytes::idx#2 = ++++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
Finalized unsigned number type (char) 6
Finalized unsigned number type (char) 6
Finalized unsigned number type (char) $12
Finalized unsigned number type (char) 6
Finalized unsigned number type (unsigned int) $714
Finalized unsigned number type (unsigned int) $708
Finalized unsigned number type (char) 1
Finalized unsigned number type (char) 2
Finalized unsigned number type (char) 3
Finalized unsigned number type (char) 6
Finalized unsigned number type (char) 2
Finalized unsigned number type (char) 6
Finalized unsigned number type (char) 3
Finalized unsigned number type (char) 2
Finalized unsigned number type (char) $18
Finalized unsigned number type (char) 1
Finalized unsigned number type (char) $f
Finalized unsigned number type (char) $1c
Finalized unsigned number type (char) 4
Finalized unsigned number type (char) 8
Finalized unsigned number type (char) 5
Finalized unsigned number type (char) 9
Finalized unsigned number type (char) 2
Finalized unsigned number type (char) 2
Finalized unsigned number type (char) $f
Finalized unsigned number type (char) 5
Finalized unsigned number type (unsigned int) $1000
Finalized unsigned number type (char) $c
Finalized signed number type (signed char) -6
Finalized unsigned number type (char) 6
Finalized signed number type (signed char) -$12
Finalized unsigned number type (char) 6
Finalized signed number type (int) -$714
Finalized unsigned number type (unsigned int) $708
Finalized signed number type (signed char) -1
Finalized unsigned number type (char) 2
Finalized unsigned number type (char) 3
Finalized unsigned number type (char) 6
Finalized signed number type (signed char) -2
Finalized unsigned number type (char) 6
Finalized signed number type (signed char) -3
Finalized unsigned number type (char) 2
Finalized signed number type (signed char) -$18
Finalized unsigned number type (char) 1
Finalized signed number type (signed char) -4
Finalized signed number type (signed char) -9
Finalized signed number type (signed char) -$10
Finalized signed number type (int) -$fc
Finalized signed number type (signed char) -2
Finalized unsigned number type (char) 2
Finalized unsigned number type (char) $f
Finalized unsigned number type (char) 5
Finalized unsigned number type (unsigned int) $1000
Finalized unsigned number type (char) $c
Successful SSA optimization PassNFinalizeNumberTypeConversions
Simplifying constant integer cast 6+6
Simplifying constant integer cast $12-6
Simplifying constant integer cast 1+2+3+6
Simplifying constant integer cast 2*6
Simplifying constant integer cast 3<<2
Simplifying constant integer cast $18>>1
Simplifying constant integer cast $f&$1c
Simplifying constant integer cast 4|8
Simplifying constant integer cast 5^9
Simplifying constant integer cast 2+2*$f/5
Simplifying constant integer cast -3<<2
Simplifying constant integer cast -$18>>1
Simplifying constant integer cast -4&-9
Successful SSA optimization PassNCastSimplification
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 [main] to testBytes:1 testSBytes:3 

Created 0 initial phi equivalence classes
Coalesced down to 0 phi equivalence classes
Culled Empty Block label main::@2
Adding NOP phi() at start of main
Adding NOP phi() at start of main::@1

FINAL CONTROL FLOW GRAPH

void main()
main: scope:[main]  from
  [0] phi()
  [1] call testBytes
  to:main::@1
main::@1: scope:[main]  from main
  [2] phi()
  [3] call testSBytes
  to:main::@return
main::@return: scope:[main]  from main::@1
  [4] return 
  to:@return

void testBytes()
testBytes: scope:[testBytes]  from main
  [5] *testBytes::SCREEN = $c
  [6] *(testBytes::SCREEN+1) = 6+6
  [7] *(testBytes::SCREEN+2) = $12-6
  [8] *(testBytes::SCREEN+3) = (char)$714-$708
  [9] *(testBytes::SCREEN+4) = 1+2+3+6
  [10] *(testBytes::SCREEN+5) = 2*6
  [11] *(testBytes::SCREEN+6) = 3<<2
  [12] *(testBytes::SCREEN+7) = $18>>1
  [13] *(testBytes::SCREEN+8) = $f&$1c
  [14] *(testBytes::SCREEN+9) = 4|8
  [15] *(testBytes::SCREEN+$a) = 5^9
  [16] *(testBytes::SCREEN+$b) = 2+2*$f/5
  [17] *(testBytes::SCREEN+$c) = (char)$1000+$c
  to:testBytes::@return
testBytes::@return: scope:[testBytes]  from testBytes
  [18] return 
  to:@return

void testSBytes()
testSBytes: scope:[testSBytes]  from main::@1
  [19] *testSBytes::SCREEN = -$c
  [20] *(testSBytes::SCREEN+1) = (signed char)-6-6
  [21] *(testSBytes::SCREEN+2) = (signed char)-$12+6
  [22] *(testSBytes::SCREEN+3) = (signed char)-$714+$708
  [23] *(testSBytes::SCREEN+4) = (signed char)-1-2-3-6
  [24] *(testSBytes::SCREEN+5) = (signed char)-2*6
  [25] *(testSBytes::SCREEN+6) = -3<<2
  [26] *(testSBytes::SCREEN+7) = -$18>>1
  [27] *(testSBytes::SCREEN+8) = -4&-9
  [28] *(testSBytes::SCREEN+9) = (signed char)-$10|-$fc
  [29] *(testSBytes::SCREEN+$a) = (signed char)-2-2*$f/5
  [30] *(testSBytes::SCREEN+$b) = (signed char)$1000-$c
  to:testSBytes::@return
testSBytes::@return: scope:[testSBytes]  from testSBytes
  [31] return 
  to:@return


VARIABLE REGISTER WEIGHTS
void main()
void testBytes()
char testBytes::idx
void testSBytes()
char testSBytes::idx

Initial phi equivalence classes
Complete equivalence classes
REGISTER UPLIFT POTENTIAL REGISTERS
Statement [5] *testBytes::SCREEN = $c [ ] ( testBytes:1 [ ] { }  ) always clobbers reg byte a 
Statement [6] *(testBytes::SCREEN+1) = 6+6 [ ] ( testBytes:1 [ ] { }  ) always clobbers reg byte a 
Statement [7] *(testBytes::SCREEN+2) = $12-6 [ ] ( testBytes:1 [ ] { }  ) always clobbers reg byte a 
Statement [8] *(testBytes::SCREEN+3) = (char)$714-$708 [ ] ( testBytes:1 [ ] { }  ) always clobbers reg byte a 
Statement [9] *(testBytes::SCREEN+4) = 1+2+3+6 [ ] ( testBytes:1 [ ] { }  ) always clobbers reg byte a 
Statement [10] *(testBytes::SCREEN+5) = 2*6 [ ] ( testBytes:1 [ ] { }  ) always clobbers reg byte a 
Statement [11] *(testBytes::SCREEN+6) = 3<<2 [ ] ( testBytes:1 [ ] { }  ) always clobbers reg byte a 
Statement [12] *(testBytes::SCREEN+7) = $18>>1 [ ] ( testBytes:1 [ ] { }  ) always clobbers reg byte a 
Statement [13] *(testBytes::SCREEN+8) = $f&$1c [ ] ( testBytes:1 [ ] { }  ) always clobbers reg byte a 
Statement [14] *(testBytes::SCREEN+9) = 4|8 [ ] ( testBytes:1 [ ] { }  ) always clobbers reg byte a 
Statement [15] *(testBytes::SCREEN+$a) = 5^9 [ ] ( testBytes:1 [ ] { }  ) always clobbers reg byte a 
Statement [16] *(testBytes::SCREEN+$b) = 2+2*$f/5 [ ] ( testBytes:1 [ ] { }  ) always clobbers reg byte a 
Statement [17] *(testBytes::SCREEN+$c) = (char)$1000+$c [ ] ( testBytes:1 [ ] { }  ) always clobbers reg byte a 
Statement [19] *testSBytes::SCREEN = -$c [ ] ( testSBytes:3 [ ] { }  ) always clobbers reg byte a 
Statement [20] *(testSBytes::SCREEN+1) = (signed char)-6-6 [ ] ( testSBytes:3 [ ] { }  ) always clobbers reg byte a 
Statement [21] *(testSBytes::SCREEN+2) = (signed char)-$12+6 [ ] ( testSBytes:3 [ ] { }  ) always clobbers reg byte a 
Statement [22] *(testSBytes::SCREEN+3) = (signed char)-$714+$708 [ ] ( testSBytes:3 [ ] { }  ) always clobbers reg byte a 
Statement [23] *(testSBytes::SCREEN+4) = (signed char)-1-2-3-6 [ ] ( testSBytes:3 [ ] { }  ) always clobbers reg byte a 
Statement [24] *(testSBytes::SCREEN+5) = (signed char)-2*6 [ ] ( testSBytes:3 [ ] { }  ) always clobbers reg byte a 
Statement [25] *(testSBytes::SCREEN+6) = -3<<2 [ ] ( testSBytes:3 [ ] { }  ) always clobbers reg byte a 
Statement [26] *(testSBytes::SCREEN+7) = -$18>>1 [ ] ( testSBytes:3 [ ] { }  ) always clobbers reg byte a 
Statement [27] *(testSBytes::SCREEN+8) = -4&-9 [ ] ( testSBytes:3 [ ] { }  ) always clobbers reg byte a 
Statement [28] *(testSBytes::SCREEN+9) = (signed char)-$10|-$fc [ ] ( testSBytes:3 [ ] { }  ) always clobbers reg byte a 
Statement [29] *(testSBytes::SCREEN+$a) = (signed char)-2-2*$f/5 [ ] ( testSBytes:3 [ ] { }  ) always clobbers reg byte a 
Statement [30] *(testSBytes::SCREEN+$b) = (signed char)$1000-$c [ ] ( testSBytes:3 [ ] { }  ) always clobbers reg byte a 

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

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

ASSEMBLER BEFORE OPTIMIZATION
  // File Comments
// Tests the number type used for constant expressions
  // Upstart
  // Commodore 64 PRG executable file
.file [name="number-type.prg", type="prg", segments="Program"]
.segmentdef Program [segments="Basic, Code, Data"]
.segmentdef Basic [start=$0801]
.segmentdef Code [start=$80d]
.segmentdef Data [startAfter="Code"]
.segment Basic
:BasicUpstart(main)
  // Global Constants & labels
.segment Code
  // main
main: {
    // [1] call testBytes
    jsr testBytes
    // [2] phi from main to main::@1 [phi:main->main::@1]
  __b1_from_main:
    jmp __b1
    // main::@1
  __b1:
    // [3] call testSBytes
    jsr testSBytes
    jmp __breturn
    // main::@return
  __breturn:
    // [4] return 
    rts
}
  // testBytes
testBytes: {
    // Constant values resolvable to bytes
    .label SCREEN = $400
    // [5] *testBytes::SCREEN = $c -- _deref_pbuc1=vbuc2 
    lda #$c
    sta SCREEN
    // [6] *(testBytes::SCREEN+1) = 6+6 -- _deref_pbuc1=vbuc2 
    lda #6+6
    sta SCREEN+1
    // [7] *(testBytes::SCREEN+2) = $12-6 -- _deref_pbuc1=vbuc2 
    lda #$12-6
    sta SCREEN+2
    // [8] *(testBytes::SCREEN+3) = (char)$714-$708 -- _deref_pbuc1=vbuc2 
    lda #$714-$708
    sta SCREEN+3
    // [9] *(testBytes::SCREEN+4) = 1+2+3+6 -- _deref_pbuc1=vbuc2 
    lda #1+2+3+6
    sta SCREEN+4
    // [10] *(testBytes::SCREEN+5) = 2*6 -- _deref_pbuc1=vbuc2 
    lda #2*6
    sta SCREEN+5
    // [11] *(testBytes::SCREEN+6) = 3<<2 -- _deref_pbuc1=vbuc2 
    lda #3<<2
    sta SCREEN+6
    // [12] *(testBytes::SCREEN+7) = $18>>1 -- _deref_pbuc1=vbuc2 
    lda #$18>>1
    sta SCREEN+7
    // [13] *(testBytes::SCREEN+8) = $f&$1c -- _deref_pbuc1=vbuc2 
    lda #$f&$1c
    sta SCREEN+8
    // [14] *(testBytes::SCREEN+9) = 4|8 -- _deref_pbuc1=vbuc2 
    lda #4|8
    sta SCREEN+9
    // [15] *(testBytes::SCREEN+$a) = 5^9 -- _deref_pbuc1=vbuc2 
    lda #5^9
    sta SCREEN+$a
    // [16] *(testBytes::SCREEN+$b) = 2+2*$f/5 -- _deref_pbuc1=vbuc2 
    lda #(2+2)*$f/5
    sta SCREEN+$b
    // [17] *(testBytes::SCREEN+$c) = (char)$1000+$c -- _deref_pbuc1=vbuc2 
    lda #$ff&$1000+$c
    sta SCREEN+$c
    jmp __breturn
    // testBytes::@return
  __breturn:
    // [18] return 
    rts
}
  // testSBytes
testSBytes: {
    // Constant values resolvable to signed bytes
    .label SCREEN = $428
    // [19] *testSBytes::SCREEN = -$c -- _deref_pbsc1=vbsc2 
    lda #-$c
    sta SCREEN
    // [20] *(testSBytes::SCREEN+1) = (signed char)-6-6 -- _deref_pbsc1=vbsc2 
    lda #-6-6
    sta SCREEN+1
    // [21] *(testSBytes::SCREEN+2) = (signed char)-$12+6 -- _deref_pbsc1=vbsc2 
    lda #-$12+6
    sta SCREEN+2
    // [22] *(testSBytes::SCREEN+3) = (signed char)-$714+$708 -- _deref_pbsc1=vbsc2 
    lda #-$714+$708
    sta SCREEN+3
    // [23] *(testSBytes::SCREEN+4) = (signed char)-1-2-3-6 -- _deref_pbsc1=vbsc2 
    lda #-1-2-3-6
    sta SCREEN+4
    // [24] *(testSBytes::SCREEN+5) = (signed char)-2*6 -- _deref_pbsc1=vbsc2 
    lda #-2*6
    sta SCREEN+5
    // [25] *(testSBytes::SCREEN+6) = -3<<2 -- _deref_pbsc1=vbsc2 
    lda #-3<<2
    sta SCREEN+6
    // [26] *(testSBytes::SCREEN+7) = -$18>>1 -- _deref_pbsc1=vbsc2 
    lda #-$18>>1
    sta SCREEN+7
    // [27] *(testSBytes::SCREEN+8) = -4&-9 -- _deref_pbsc1=vbsc2 
    lda #-4&-9
    sta SCREEN+8
    // [28] *(testSBytes::SCREEN+9) = (signed char)-$10|-$fc -- _deref_pbsc1=vbsc2 
    lda #-$10|-$fc
    sta SCREEN+9
    // [29] *(testSBytes::SCREEN+$a) = (signed char)-2-2*$f/5 -- _deref_pbsc1=vbsc2 
    lda #(-2-2)*$f/5
    sta SCREEN+$a
    // [30] *(testSBytes::SCREEN+$b) = (signed char)$1000-$c -- _deref_pbsc1=vbsc2 
    lda #$ff&$1000-$c
    sta SCREEN+$b
    jmp __breturn
    // testSBytes::@return
  __breturn:
    // [31] return 
    rts
}
  // File Data

ASSEMBLER OPTIMIZATIONS
Removing instruction jmp __b1
Removing instruction jmp __breturn
Removing instruction jmp __breturn
Removing instruction jmp __breturn
Succesful ASM optimization Pass5NextJumpElimination
Removing instruction __b1_from_main:
Succesful ASM optimization Pass5RedundantLabelElimination
Removing instruction __b1:
Removing instruction __breturn:
Removing instruction __breturn:
Removing instruction __breturn:
Succesful ASM optimization Pass5UnusedLabelElimination

FINAL SYMBOL TABLE
void main()
void testBytes()
__constant char * const testBytes::SCREEN = (char *) 1024
char testBytes::idx
void testSBytes()
__constant signed char * const testSBytes::SCREEN = (signed char *) 1064
char testSBytes::idx



FINAL ASSEMBLER
Score: 180

  // File Comments
// Tests the number type used for constant expressions
  // Upstart
  // Commodore 64 PRG executable file
.file [name="number-type.prg", type="prg", segments="Program"]
.segmentdef Program [segments="Basic, Code, Data"]
.segmentdef Basic [start=$0801]
.segmentdef Code [start=$80d]
.segmentdef Data [startAfter="Code"]
.segment Basic
:BasicUpstart(main)
  // Global Constants & labels
.segment Code
  // main
main: {
    // testBytes()
    // [1] call testBytes
    jsr testBytes
    // [2] phi from main to main::@1 [phi:main->main::@1]
    // main::@1
    // testSBytes()
    // [3] call testSBytes
    jsr testSBytes
    // main::@return
    // }
    // [4] return 
    rts
}
  // testBytes
testBytes: {
    // Constant values resolvable to bytes
    .label SCREEN = $400
    // SCREEN[idx++] = 12
    // [5] *testBytes::SCREEN = $c -- _deref_pbuc1=vbuc2 
    lda #$c
    sta SCREEN
    // SCREEN[idx++] = 6+6
    // [6] *(testBytes::SCREEN+1) = 6+6 -- _deref_pbuc1=vbuc2 
    lda #6+6
    sta SCREEN+1
    // SCREEN[idx++] = 18-6
    // [7] *(testBytes::SCREEN+2) = $12-6 -- _deref_pbuc1=vbuc2 
    lda #$12-6
    sta SCREEN+2
    // SCREEN[idx++] = 1812-1800
    // [8] *(testBytes::SCREEN+3) = (char)$714-$708 -- _deref_pbuc1=vbuc2 
    lda #$714-$708
    sta SCREEN+3
    // SCREEN[idx++] = 1+2+3+6
    // [9] *(testBytes::SCREEN+4) = 1+2+3+6 -- _deref_pbuc1=vbuc2 
    lda #1+2+3+6
    sta SCREEN+4
    // SCREEN[idx++] = 2*6
    // [10] *(testBytes::SCREEN+5) = 2*6 -- _deref_pbuc1=vbuc2 
    lda #2*6
    sta SCREEN+5
    // SCREEN[idx++] = 3<<2
    // [11] *(testBytes::SCREEN+6) = 3<<2 -- _deref_pbuc1=vbuc2 
    lda #3<<2
    sta SCREEN+6
    // SCREEN[idx++] = 24>>1
    // [12] *(testBytes::SCREEN+7) = $18>>1 -- _deref_pbuc1=vbuc2 
    lda #$18>>1
    sta SCREEN+7
    // SCREEN[idx++] = 15&28
    // [13] *(testBytes::SCREEN+8) = $f&$1c -- _deref_pbuc1=vbuc2 
    lda #$f&$1c
    sta SCREEN+8
    // SCREEN[idx++] = 4|8
    // [14] *(testBytes::SCREEN+9) = 4|8 -- _deref_pbuc1=vbuc2 
    lda #4|8
    sta SCREEN+9
    // SCREEN[idx++] = 5^9
    // [15] *(testBytes::SCREEN+$a) = 5^9 -- _deref_pbuc1=vbuc2 
    lda #5^9
    sta SCREEN+$a
    // SCREEN[idx++] = (2+2)*(15/5)
    // [16] *(testBytes::SCREEN+$b) = 2+2*$f/5 -- _deref_pbuc1=vbuc2 
    lda #(2+2)*$f/5
    sta SCREEN+$b
    // SCREEN[idx++] = (byte)(4096+12)
    // [17] *(testBytes::SCREEN+$c) = (char)$1000+$c -- _deref_pbuc1=vbuc2 
    lda #$ff&$1000+$c
    sta SCREEN+$c
    // testBytes::@return
    // }
    // [18] return 
    rts
}
  // testSBytes
testSBytes: {
    // Constant values resolvable to signed bytes
    .label SCREEN = $428
    // SCREEN[idx++] = -12
    // [19] *testSBytes::SCREEN = -$c -- _deref_pbsc1=vbsc2 
    lda #-$c
    sta SCREEN
    // SCREEN[idx++] = -6-6
    // [20] *(testSBytes::SCREEN+1) = (signed char)-6-6 -- _deref_pbsc1=vbsc2 
    lda #-6-6
    sta SCREEN+1
    // SCREEN[idx++] = -18+6
    // [21] *(testSBytes::SCREEN+2) = (signed char)-$12+6 -- _deref_pbsc1=vbsc2 
    lda #-$12+6
    sta SCREEN+2
    // SCREEN[idx++] = -1812+1800
    // [22] *(testSBytes::SCREEN+3) = (signed char)-$714+$708 -- _deref_pbsc1=vbsc2 
    lda #-$714+$708
    sta SCREEN+3
    // SCREEN[idx++] = -1-2-3-6
    // [23] *(testSBytes::SCREEN+4) = (signed char)-1-2-3-6 -- _deref_pbsc1=vbsc2 
    lda #-1-2-3-6
    sta SCREEN+4
    // SCREEN[idx++] = -2*6
    // [24] *(testSBytes::SCREEN+5) = (signed char)-2*6 -- _deref_pbsc1=vbsc2 
    lda #-2*6
    sta SCREEN+5
    // SCREEN[idx++] = -3<<2
    // [25] *(testSBytes::SCREEN+6) = -3<<2 -- _deref_pbsc1=vbsc2 
    lda #-3<<2
    sta SCREEN+6
    // SCREEN[idx++] = -24>>1
    // [26] *(testSBytes::SCREEN+7) = -$18>>1 -- _deref_pbsc1=vbsc2 
    lda #-$18>>1
    sta SCREEN+7
    // SCREEN[idx++] = -4&-9
    // [27] *(testSBytes::SCREEN+8) = -4&-9 -- _deref_pbsc1=vbsc2 
    lda #-4&-9
    sta SCREEN+8
    // SCREEN[idx++] = -0x10|-0xfc
    // [28] *(testSBytes::SCREEN+9) = (signed char)-$10|-$fc -- _deref_pbsc1=vbsc2 
    lda #-$10|-$fc
    sta SCREEN+9
    // SCREEN[idx++] = (-2-2)*(15/5)
    // [29] *(testSBytes::SCREEN+$a) = (signed char)-2-2*$f/5 -- _deref_pbsc1=vbsc2 
    lda #(-2-2)*$f/5
    sta SCREEN+$a
    // SCREEN[idx++] = (signed byte)(4096-12)
    // [30] *(testSBytes::SCREEN+$b) = (signed char)$1000-$c -- _deref_pbsc1=vbsc2 
    lda #$ff&$1000-$c
    sta SCREEN+$b
    // testSBytes::@return
    // }
    // [31] return 
    rts
}
  // File Data

