Fixing pointer addition (word*~) bsearch16u::$7 ← (word*) bsearch16u::items + (byte~) bsearch16u::$6
Fixing pointer addition (word*~) bsearch16u::$15 ← (word*) bsearch16u::pivot + (number) 1
Fixing pointer addition (word*~) bsearch16u::$1 ← (word*) bsearch16u::items - (number) 1
Fixing pointer array-indexing *((word*) utoa::digit_values + (byte) utoa::digit)
Fixing pointer array-indexing *((dword*) ultoa::digit_values + (byte) ultoa::digit)
Fixing pointer array-indexing *((const word*) test_16u::dividends + (byte) test_16u::i)
Fixing pointer array-indexing *((const word*) test_16u::divisors + (byte) test_16u::i)
Fixing pointer array-indexing *((const signed word*) test_16s::dividends + (byte) test_16s::i)
Fixing pointer array-indexing *((const signed word*) test_16s::divisors + (byte) test_16s::i)
Warning! Adding boolean cast to non-boolean condition *((byte*) strcpy::src)
Warning! Adding boolean cast to non-boolean condition *((byte*) strlen::str)
Warning! Adding boolean cast to non-boolean condition *((byte*) print_str_lines::str)
Warning! Adding boolean cast to non-boolean condition (byte) print_str_lines::ch
Warning! Adding boolean cast to non-boolean condition *((byte*) print_str::str)
Warning! Adding boolean cast to non-boolean condition *((byte*) print_str_at::str)
Warning! Adding boolean cast to non-boolean sub-expression (byte) print_str_lines::ch
Identified constant variable (byte*) HEAP_TOP
Identified constant variable (byte) test_8u::rem
Culled Empty Block (label) @1
Culled Empty Block (label) @2
Culled Empty Block (label) memset::@7
Culled Empty Block (label) memset::@6
Culled Empty Block (label) memset::@8
Culled Empty Block (label) memset::@9
Culled Empty Block (label) memset::@3
Culled Empty Block (label) @3
Culled Empty Block (label) @4
Culled Empty Block (label) @5
Culled Empty Block (label) @6
Culled Empty Block (label) @7
Culled Empty Block (label) @8
Culled Empty Block (label) @9
Culled Empty Block (label) @10
Culled Empty Block (label) @11
Culled Empty Block (label) @12
Culled Empty Block (label) @14
Culled Empty Block (label) @15
Culled Empty Block (label) print_str::@4
Culled Empty Block (label) print_str::@3
Culled Empty Block (label) print_str::@5
Culled Empty Block (label) print_str::@6
Culled Empty Block (label) @16
Culled Empty Block (label) @17
Culled Empty Block (label) @18
Culled Empty Block (label) print_sword::@4
Culled Empty Block (label) @19
Culled Empty Block (label) print_sbyte::@4
Culled Empty Block (label) @20
Culled Empty Block (label) @21
Culled Empty Block (label) @22
Culled Empty Block (label) @23
Culled Empty Block (label) @24
Culled Empty Block (label) @25
Culled Empty Block (label) @26
Culled Empty Block (label) @27
Culled Empty Block (label) @28
Culled Empty Block (label) @29
Culled Empty Block (label) @30
Culled Empty Block (label) @31
Culled Empty Block (label) @32
Culled Empty Block (label) @33
Culled Empty Block (label) @34
Culled Empty Block (label) @35
Culled Empty Block (label) @36
Culled Empty Block (label) div8u::@1
Culled Empty Block (label) @38
Culled Empty Block (label) divr8u::@7
Culled Empty Block (label) divr16u::@7
Culled Empty Block (label) @40
Culled Empty Block (label) div16u::@1
Culled Empty Block (label) @41
Culled Empty Block (label) div8s::@8
Culled Empty Block (label) div8s::@10
Culled Empty Block (label) div8s::@12
Culled Empty Block (label) div8s::@6
Culled Empty Block (label) div8s::@13
Culled Empty Block (label) div8s::@14
Culled Empty Block (label) divr16s::@8
Culled Empty Block (label) divr16s::@10
Culled Empty Block (label) divr16s::@12
Culled Empty Block (label) divr16s::@6
Culled Empty Block (label) divr16s::@13
Culled Empty Block (label) divr16s::@14
Culled Empty Block (label) @44
Culled Empty Block (label) div16s::@1
Culled Empty Block (label) @45
Culled Empty Block (label) @46
Culled Empty Block (label) test_8u::@2
Culled Empty Block (label) @47
Culled Empty Block (label) test_16u::@2
Culled Empty Block (label) @48
Culled Empty Block (label) test_8s::@2
Culled Empty Block (label) @49
Culled Empty Block (label) test_16s::@2

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

(void*()) memset((void*) memset::str , (byte) memset::c , (word) memset::num)
memset: scope:[memset]  from print_cls
  (byte) memset::c#4 ← phi( print_cls/(byte) memset::c#0 )
  (void*) memset::str#3 ← phi( print_cls/(void*) memset::str#0 )
  (word) memset::num#1 ← phi( print_cls/(word) memset::num#0 )
  (bool~) memset::$0 ← (word) memset::num#1 > (number) 0
  (bool~) memset::$1 ← ! (bool~) memset::$0
  if((bool~) memset::$1) goto memset::@1
  to:memset::@2
memset::@1: scope:[memset]  from memset memset::@4
  (void*) memset::str#1 ← phi( memset/(void*) memset::str#3 memset::@4/(void*) memset::str#4 )
  (void*) memset::return#0 ← (void*) memset::str#1
  to:memset::@return
memset::@2: scope:[memset]  from memset
  (byte) memset::c#3 ← phi( memset/(byte) memset::c#4 )
  (word) memset::num#2 ← phi( memset/(word) memset::num#1 )
  (void*) memset::str#2 ← phi( memset/(void*) memset::str#3 )
  (byte*~) memset::$2 ← ((byte*)) (void*) memset::str#2
  (byte*~) memset::$3 ← (byte*~) memset::$2 + (word) memset::num#2
  (byte*) memset::end#0 ← (byte*~) memset::$3
  (byte*) memset::dst#0 ← ((byte*)) (void*) memset::str#2
  to:memset::@4
memset::@4: scope:[memset]  from memset::@2 memset::@5
  (byte) memset::c#2 ← phi( memset::@2/(byte) memset::c#3 memset::@5/(byte) memset::c#1 )
  (void*) memset::str#4 ← phi( memset::@2/(void*) memset::str#2 memset::@5/(void*) memset::str#5 )
  (byte*) memset::end#1 ← phi( memset::@2/(byte*) memset::end#0 memset::@5/(byte*) memset::end#2 )
  (byte*) memset::dst#2 ← phi( memset::@2/(byte*) memset::dst#0 memset::@5/(byte*) memset::dst#1 )
  (bool~) memset::$4 ← (byte*) memset::dst#2 != (byte*) memset::end#1
  if((bool~) memset::$4) goto memset::@5
  to:memset::@1
memset::@5: scope:[memset]  from memset::@4
  (void*) memset::str#5 ← phi( memset::@4/(void*) memset::str#4 )
  (byte*) memset::end#2 ← phi( memset::@4/(byte*) memset::end#1 )
  (byte*) memset::dst#3 ← phi( memset::@4/(byte*) memset::dst#2 )
  (byte) memset::c#1 ← phi( memset::@4/(byte) memset::c#2 )
  *((byte*) memset::dst#3) ← (byte) memset::c#1
  (byte*) memset::dst#1 ← ++ (byte*) memset::dst#3
  to:memset::@4
memset::@return: scope:[memset]  from memset::@1
  (void*) memset::return#3 ← phi( memset::@1/(void*) memset::return#0 )
  (void*) memset::return#1 ← (void*) memset::return#3
  return 
  to:@return
@13: scope:[]  from @begin
  (byte*) print_screen#0 ← (byte*)(number) $400
  (byte*) print_line_cursor#0 ← (byte*) print_screen#0
  (byte*) print_char_cursor#0 ← (byte*) print_line_cursor#0
  to:@37

(void()) print_str((byte*) print_str::str)
print_str: scope:[print_str]  from test_16s::@4 test_16s::@6 test_16s::@8 test_16u::@4 test_16u::@6 test_16u::@8 test_8s::@4 test_8s::@6 test_8s::@8 test_8u::@4 test_8u::@6 test_8u::@8
  (byte*) print_char_cursor#146 ← phi( test_16s::@4/(byte*) print_char_cursor#56 test_16s::@6/(byte*) print_char_cursor#58 test_16s::@8/(byte*) print_char_cursor#60 test_16u::@4/(byte*) print_char_cursor#38 test_16u::@6/(byte*) print_char_cursor#40 test_16u::@8/(byte*) print_char_cursor#42 test_8s::@4/(byte*) print_char_cursor#47 test_8s::@6/(byte*) print_char_cursor#49 test_8s::@8/(byte*) print_char_cursor#51 test_8u::@4/(byte*) print_char_cursor#29 test_8u::@6/(byte*) print_char_cursor#31 test_8u::@8/(byte*) print_char_cursor#33 )
  (byte*) print_str::str#15 ← phi( test_16s::@4/(byte*) print_str::str#10 test_16s::@6/(byte*) print_str::str#11 test_16s::@8/(byte*) print_str::str#12 test_16u::@4/(byte*) print_str::str#4 test_16u::@6/(byte*) print_str::str#5 test_16u::@8/(byte*) print_str::str#6 test_8s::@4/(byte*) print_str::str#7 test_8s::@6/(byte*) print_str::str#8 test_8s::@8/(byte*) print_str::str#9 test_8u::@4/(byte*) print_str::str#1 test_8u::@6/(byte*) print_str::str#2 test_8u::@8/(byte*) print_str::str#3 )
  to:print_str::@1
print_str::@1: scope:[print_str]  from print_str print_str::@2
  (byte*) print_char_cursor#130 ← phi( print_str/(byte*) print_char_cursor#146 print_str::@2/(byte*) print_char_cursor#1 )
  (byte*) print_str::str#13 ← phi( print_str/(byte*) print_str::str#15 print_str::@2/(byte*) print_str::str#0 )
  (bool~) print_str::$0 ← (number) 0 != *((byte*) print_str::str#13)
  if((bool~) print_str::$0) goto print_str::@2
  to:print_str::@return
print_str::@2: scope:[print_str]  from print_str::@1
  (byte*) print_char_cursor#66 ← phi( print_str::@1/(byte*) print_char_cursor#130 )
  (byte*) print_str::str#14 ← phi( print_str::@1/(byte*) print_str::str#13 )
  *((byte*) print_char_cursor#66) ← *((byte*) print_str::str#14)
  (byte*) print_char_cursor#1 ← ++ (byte*) print_char_cursor#66
  (byte*) print_str::str#0 ← ++ (byte*) print_str::str#14
  to:print_str::@1
print_str::@return: scope:[print_str]  from print_str::@1
  (byte*) print_char_cursor#67 ← phi( print_str::@1/(byte*) print_char_cursor#130 )
  (byte*) print_char_cursor#2 ← (byte*) print_char_cursor#67
  return 
  to:@return

(void()) print_ln()
print_ln: scope:[print_ln]  from test_16s::@10 test_16u::@10 test_8s::@10 test_8u::@10
  (byte*) print_char_cursor#131 ← phi( test_16s::@10/(byte*) print_char_cursor#62 test_16u::@10/(byte*) print_char_cursor#44 test_8s::@10/(byte*) print_char_cursor#53 test_8u::@10/(byte*) print_char_cursor#35 )
  (byte*) print_line_cursor#39 ← phi( test_16s::@10/(byte*) print_line_cursor#44 test_16u::@10/(byte*) print_line_cursor#42 test_8s::@10/(byte*) print_line_cursor#43 test_8u::@10/(byte*) print_line_cursor#41 )
  to:print_ln::@1
print_ln::@1: scope:[print_ln]  from print_ln print_ln::@1
  (byte*) print_char_cursor#68 ← phi( print_ln/(byte*) print_char_cursor#131 print_ln::@1/(byte*) print_char_cursor#68 )
  (byte*) print_line_cursor#20 ← phi( print_ln/(byte*) print_line_cursor#39 print_ln::@1/(byte*) print_line_cursor#1 )
  (byte*~) print_ln::$0 ← (byte*) print_line_cursor#20 + (number) $28
  (byte*) print_line_cursor#1 ← (byte*~) print_ln::$0
  (bool~) print_ln::$1 ← (byte*) print_line_cursor#1 < (byte*) print_char_cursor#68
  if((bool~) print_ln::$1) goto print_ln::@1
  to:print_ln::@2
print_ln::@2: scope:[print_ln]  from print_ln::@1
  (byte*) print_line_cursor#21 ← phi( print_ln::@1/(byte*) print_line_cursor#1 )
  (byte*) print_char_cursor#3 ← (byte*) print_line_cursor#21
  to:print_ln::@return
print_ln::@return: scope:[print_ln]  from print_ln::@2
  (byte*) print_char_cursor#69 ← phi( print_ln::@2/(byte*) print_char_cursor#3 )
  (byte*) print_line_cursor#22 ← phi( print_ln::@2/(byte*) print_line_cursor#21 )
  (byte*) print_line_cursor#2 ← (byte*) print_line_cursor#22
  (byte*) print_char_cursor#4 ← (byte*) print_char_cursor#69
  return 
  to:@return

(void()) print_sword((signed word) print_sword::w)
print_sword: scope:[print_sword]  from test_16s::@3 test_16s::@5 test_16s::@7 test_16s::@9
  (byte*) print_char_cursor#147 ← phi( test_16s::@3/(byte*) print_char_cursor#144 test_16s::@5/(byte*) print_char_cursor#57 test_16s::@7/(byte*) print_char_cursor#59 test_16s::@9/(byte*) print_char_cursor#61 )
  (signed word) print_sword::w#5 ← phi( test_16s::@3/(signed word) print_sword::w#1 test_16s::@5/(signed word) print_sword::w#2 test_16s::@7/(signed word) print_sword::w#3 test_16s::@9/(signed word) print_sword::w#4 )
  (bool~) print_sword::$0 ← (signed word) print_sword::w#5 < (number) 0
  if((bool~) print_sword::$0) goto print_sword::@1
  to:print_sword::@3
print_sword::@1: scope:[print_sword]  from print_sword
  (signed word) print_sword::w#8 ← phi( print_sword/(signed word) print_sword::w#5 )
  (byte*) print_char_cursor#132 ← phi( print_sword/(byte*) print_char_cursor#147 )
  (byte) print_char::ch#0 ← (byte) '-'
  call print_char 
  to:print_sword::@5
print_sword::@5: scope:[print_sword]  from print_sword::@1
  (signed word) print_sword::w#6 ← phi( print_sword::@1/(signed word) print_sword::w#8 )
  (byte*) print_char_cursor#70 ← phi( print_sword::@1/(byte*) print_char_cursor#20 )
  (byte*) print_char_cursor#5 ← (byte*) print_char_cursor#70
  (signed word~) print_sword::$5 ← - (signed word) print_sword::w#6
  (signed word) print_sword::w#0 ← (signed word~) print_sword::$5
  to:print_sword::@2
print_sword::@3: scope:[print_sword]  from print_sword
  (signed word) print_sword::w#10 ← phi( print_sword/(signed word) print_sword::w#5 )
  (byte*) print_char_cursor#133 ← phi( print_sword/(byte*) print_char_cursor#147 )
  (byte) print_char::ch#1 ← (byte) ' '
  call print_char 
  to:print_sword::@6
print_sword::@6: scope:[print_sword]  from print_sword::@3
  (signed word) print_sword::w#9 ← phi( print_sword::@3/(signed word) print_sword::w#10 )
  (byte*) print_char_cursor#71 ← phi( print_sword::@3/(byte*) print_char_cursor#20 )
  (byte*) print_char_cursor#6 ← (byte*) print_char_cursor#71
  to:print_sword::@2
print_sword::@2: scope:[print_sword]  from print_sword::@5 print_sword::@6
  (byte*) print_char_cursor#134 ← phi( print_sword::@5/(byte*) print_char_cursor#5 print_sword::@6/(byte*) print_char_cursor#6 )
  (signed word) print_sword::w#7 ← phi( print_sword::@5/(signed word) print_sword::w#0 print_sword::@6/(signed word) print_sword::w#9 )
  (word~) print_sword::$1 ← ((word)) (signed word) print_sword::w#7
  (word) print_word::w#0 ← (word~) print_sword::$1
  call print_word 
  to:print_sword::@7
print_sword::@7: scope:[print_sword]  from print_sword::@2
  (byte*) print_char_cursor#72 ← phi( print_sword::@2/(byte*) print_char_cursor#15 )
  (byte*) print_char_cursor#7 ← (byte*) print_char_cursor#72
  to:print_sword::@return
print_sword::@return: scope:[print_sword]  from print_sword::@7
  (byte*) print_char_cursor#73 ← phi( print_sword::@7/(byte*) print_char_cursor#7 )
  (byte*) print_char_cursor#8 ← (byte*) print_char_cursor#73
  return 
  to:@return

(void()) print_sbyte((signed byte) print_sbyte::b)
print_sbyte: scope:[print_sbyte]  from test_8s::@3 test_8s::@5 test_8s::@7 test_8s::@9
  (byte*) print_char_cursor#148 ← phi( test_8s::@3/(byte*) print_char_cursor#143 test_8s::@5/(byte*) print_char_cursor#48 test_8s::@7/(byte*) print_char_cursor#50 test_8s::@9/(byte*) print_char_cursor#52 )
  (signed byte) print_sbyte::b#5 ← phi( test_8s::@3/(signed byte) print_sbyte::b#1 test_8s::@5/(signed byte) print_sbyte::b#2 test_8s::@7/(signed byte) print_sbyte::b#3 test_8s::@9/(signed byte) print_sbyte::b#4 )
  (bool~) print_sbyte::$0 ← (signed byte) print_sbyte::b#5 < (number) 0
  if((bool~) print_sbyte::$0) goto print_sbyte::@1
  to:print_sbyte::@3
print_sbyte::@1: scope:[print_sbyte]  from print_sbyte
  (signed byte) print_sbyte::b#8 ← phi( print_sbyte/(signed byte) print_sbyte::b#5 )
  (byte*) print_char_cursor#135 ← phi( print_sbyte/(byte*) print_char_cursor#148 )
  (byte) print_char::ch#2 ← (byte) '-'
  call print_char 
  to:print_sbyte::@5
print_sbyte::@5: scope:[print_sbyte]  from print_sbyte::@1
  (signed byte) print_sbyte::b#6 ← phi( print_sbyte::@1/(signed byte) print_sbyte::b#8 )
  (byte*) print_char_cursor#74 ← phi( print_sbyte::@1/(byte*) print_char_cursor#20 )
  (byte*) print_char_cursor#9 ← (byte*) print_char_cursor#74
  (signed byte~) print_sbyte::$5 ← - (signed byte) print_sbyte::b#6
  (signed byte) print_sbyte::b#0 ← (signed byte~) print_sbyte::$5
  to:print_sbyte::@2
print_sbyte::@3: scope:[print_sbyte]  from print_sbyte
  (signed byte) print_sbyte::b#10 ← phi( print_sbyte/(signed byte) print_sbyte::b#5 )
  (byte*) print_char_cursor#136 ← phi( print_sbyte/(byte*) print_char_cursor#148 )
  (byte) print_char::ch#3 ← (byte) ' '
  call print_char 
  to:print_sbyte::@6
print_sbyte::@6: scope:[print_sbyte]  from print_sbyte::@3
  (signed byte) print_sbyte::b#9 ← phi( print_sbyte::@3/(signed byte) print_sbyte::b#10 )
  (byte*) print_char_cursor#75 ← phi( print_sbyte::@3/(byte*) print_char_cursor#20 )
  (byte*) print_char_cursor#10 ← (byte*) print_char_cursor#75
  to:print_sbyte::@2
print_sbyte::@2: scope:[print_sbyte]  from print_sbyte::@5 print_sbyte::@6
  (byte*) print_char_cursor#137 ← phi( print_sbyte::@5/(byte*) print_char_cursor#9 print_sbyte::@6/(byte*) print_char_cursor#10 )
  (signed byte) print_sbyte::b#7 ← phi( print_sbyte::@5/(signed byte) print_sbyte::b#0 print_sbyte::@6/(signed byte) print_sbyte::b#9 )
  (byte~) print_sbyte::$1 ← ((byte)) (signed byte) print_sbyte::b#7
  (byte) print_byte::b#0 ← (byte~) print_sbyte::$1
  call print_byte 
  to:print_sbyte::@7
print_sbyte::@7: scope:[print_sbyte]  from print_sbyte::@2
  (byte*) print_char_cursor#76 ← phi( print_sbyte::@2/(byte*) print_char_cursor#18 )
  (byte*) print_char_cursor#11 ← (byte*) print_char_cursor#76
  to:print_sbyte::@return
print_sbyte::@return: scope:[print_sbyte]  from print_sbyte::@7
  (byte*) print_char_cursor#77 ← phi( print_sbyte::@7/(byte*) print_char_cursor#11 )
  (byte*) print_char_cursor#12 ← (byte*) print_char_cursor#77
  return 
  to:@return

(void()) print_word((word) print_word::w)
print_word: scope:[print_word]  from print_sword::@2 test_16u::@3 test_16u::@5 test_16u::@7 test_16u::@9
  (byte*) print_char_cursor#138 ← phi( print_sword::@2/(byte*) print_char_cursor#134 test_16u::@3/(byte*) print_char_cursor#142 test_16u::@5/(byte*) print_char_cursor#39 test_16u::@7/(byte*) print_char_cursor#41 test_16u::@9/(byte*) print_char_cursor#43 )
  (word) print_word::w#5 ← phi( print_sword::@2/(word) print_word::w#0 test_16u::@3/(word) print_word::w#1 test_16u::@5/(word) print_word::w#2 test_16u::@7/(word) print_word::w#3 test_16u::@9/(word) print_word::w#4 )
  (byte~) print_word::$0 ← > (word) print_word::w#5
  (byte) print_byte::b#1 ← (byte~) print_word::$0
  call print_byte 
  to:print_word::@1
print_word::@1: scope:[print_word]  from print_word
  (word) print_word::w#6 ← phi( print_word/(word) print_word::w#5 )
  (byte*) print_char_cursor#78 ← phi( print_word/(byte*) print_char_cursor#18 )
  (byte*) print_char_cursor#13 ← (byte*) print_char_cursor#78
  (byte~) print_word::$2 ← < (word) print_word::w#6
  (byte) print_byte::b#2 ← (byte~) print_word::$2
  call print_byte 
  to:print_word::@2
print_word::@2: scope:[print_word]  from print_word::@1
  (byte*) print_char_cursor#79 ← phi( print_word::@1/(byte*) print_char_cursor#18 )
  (byte*) print_char_cursor#14 ← (byte*) print_char_cursor#79
  to:print_word::@return
print_word::@return: scope:[print_word]  from print_word::@2
  (byte*) print_char_cursor#80 ← phi( print_word::@2/(byte*) print_char_cursor#14 )
  (byte*) print_char_cursor#15 ← (byte*) print_char_cursor#80
  return 
  to:@return

(void()) print_byte((byte) print_byte::b)
print_byte: scope:[print_byte]  from print_sbyte::@2 print_word print_word::@1 test_8u::@3 test_8u::@5 test_8u::@7 test_8u::@9
  (byte*) print_char_cursor#139 ← phi( print_sbyte::@2/(byte*) print_char_cursor#137 print_word/(byte*) print_char_cursor#138 print_word::@1/(byte*) print_char_cursor#13 test_8u::@3/(byte*) print_char_cursor#141 test_8u::@5/(byte*) print_char_cursor#30 test_8u::@7/(byte*) print_char_cursor#32 test_8u::@9/(byte*) print_char_cursor#34 )
  (byte) print_byte::b#7 ← phi( print_sbyte::@2/(byte) print_byte::b#0 print_word/(byte) print_byte::b#1 print_word::@1/(byte) print_byte::b#2 test_8u::@3/(byte) print_byte::b#3 test_8u::@5/(byte) print_byte::b#4 test_8u::@7/(byte) print_byte::b#5 test_8u::@9/(byte) print_byte::b#6 )
  (byte~) print_byte::$0 ← (byte) print_byte::b#7 >> (number) 4
  (byte) print_char::ch#4 ← *((const byte*) print_hextab + (byte~) print_byte::$0)
  call print_char 
  to:print_byte::@1
print_byte::@1: scope:[print_byte]  from print_byte
  (byte) print_byte::b#8 ← phi( print_byte/(byte) print_byte::b#7 )
  (byte*) print_char_cursor#81 ← phi( print_byte/(byte*) print_char_cursor#20 )
  (byte*) print_char_cursor#16 ← (byte*) print_char_cursor#81
  (number~) print_byte::$2 ← (byte) print_byte::b#8 & (number) $f
  (byte) print_char::ch#5 ← *((const byte*) print_hextab + (number~) print_byte::$2)
  call print_char 
  to:print_byte::@2
print_byte::@2: scope:[print_byte]  from print_byte::@1
  (byte*) print_char_cursor#82 ← phi( print_byte::@1/(byte*) print_char_cursor#20 )
  (byte*) print_char_cursor#17 ← (byte*) print_char_cursor#82
  to:print_byte::@return
print_byte::@return: scope:[print_byte]  from print_byte::@2
  (byte*) print_char_cursor#83 ← phi( print_byte::@2/(byte*) print_char_cursor#17 )
  (byte*) print_char_cursor#18 ← (byte*) print_char_cursor#83
  return 
  to:@return

(void()) print_char((byte) print_char::ch)
print_char: scope:[print_char]  from print_byte print_byte::@1 print_sbyte::@1 print_sbyte::@3 print_sword::@1 print_sword::@3
  (byte*) print_char_cursor#84 ← phi( print_byte/(byte*) print_char_cursor#139 print_byte::@1/(byte*) print_char_cursor#16 print_sbyte::@1/(byte*) print_char_cursor#135 print_sbyte::@3/(byte*) print_char_cursor#136 print_sword::@1/(byte*) print_char_cursor#132 print_sword::@3/(byte*) print_char_cursor#133 )
  (byte) print_char::ch#6 ← phi( print_byte/(byte) print_char::ch#4 print_byte::@1/(byte) print_char::ch#5 print_sbyte::@1/(byte) print_char::ch#2 print_sbyte::@3/(byte) print_char::ch#3 print_sword::@1/(byte) print_char::ch#0 print_sword::@3/(byte) print_char::ch#1 )
  *((byte*) print_char_cursor#84) ← (byte) print_char::ch#6
  (byte*) print_char_cursor#19 ← ++ (byte*) print_char_cursor#84
  to:print_char::@return
print_char::@return: scope:[print_char]  from print_char
  (byte*) print_char_cursor#85 ← phi( print_char/(byte*) print_char_cursor#19 )
  (byte*) print_char_cursor#20 ← (byte*) print_char_cursor#85
  return 
  to:@return

(void()) print_cls()
print_cls: scope:[print_cls]  from main
  (byte*) print_screen#1 ← phi( main/(byte*) print_screen#3 )
  (void*) memset::str#0 ← (void*)(byte*) print_screen#1
  (byte) memset::c#0 ← (byte) ' '
  (word) memset::num#0 ← (number) $3e8
  call memset 
  (void*) memset::return#2 ← (void*) memset::return#1
  to:print_cls::@1
print_cls::@1: scope:[print_cls]  from print_cls
  (byte*) print_screen#2 ← phi( print_cls/(byte*) print_screen#1 )
  (byte*) print_line_cursor#3 ← (byte*) print_screen#2
  (byte*) print_char_cursor#21 ← (byte*) print_line_cursor#3
  to:print_cls::@return
print_cls::@return: scope:[print_cls]  from print_cls::@1
  (byte*) print_char_cursor#86 ← phi( print_cls::@1/(byte*) print_char_cursor#21 )
  (byte*) print_line_cursor#23 ← phi( print_cls::@1/(byte*) print_line_cursor#3 )
  (byte*) print_line_cursor#4 ← (byte*) print_line_cursor#23
  (byte*) print_char_cursor#22 ← (byte*) print_char_cursor#86
  return 
  to:@return
@37: scope:[]  from @13
  (byte*) print_screen#8 ← phi( @13/(byte*) print_screen#0 )
  (byte*) print_char_cursor#160 ← phi( @13/(byte*) print_char_cursor#0 )
  (byte*) print_line_cursor#61 ← phi( @13/(byte*) print_line_cursor#0 )
  (byte) rem8u#0 ← (byte) 0
  to:@39

(byte()) div8u((byte) div8u::dividend , (byte) div8u::divisor)
div8u: scope:[div8u]  from div8s::@4 test_8u::@1
  (byte) rem8u#31 ← phi( div8s::@4/(byte) rem8u#32 test_8u::@1/(byte) rem8u#36 )
  (byte) div8u::divisor#2 ← phi( div8s::@4/(byte) div8u::divisor#0 test_8u::@1/(byte) div8u::divisor#1 )
  (byte) div8u::dividend#2 ← phi( div8s::@4/(byte) div8u::dividend#0 test_8u::@1/(byte) div8u::dividend#1 )
  (byte) divr8u::dividend#0 ← (byte) div8u::dividend#2
  (byte) divr8u::divisor#0 ← (byte) div8u::divisor#2
  (byte) divr8u::rem#0 ← (number) 0
  call divr8u 
  (byte) divr8u::return#0 ← (byte) divr8u::return#2
  to:div8u::@2
div8u::@2: scope:[div8u]  from div8u
  (byte) rem8u#15 ← phi( div8u/(byte) rem8u#4 )
  (byte) divr8u::return#3 ← phi( div8u/(byte) divr8u::return#0 )
  (byte~) div8u::$0 ← (byte) divr8u::return#3
  (byte) rem8u#1 ← (byte) rem8u#15
  (byte) div8u::return#0 ← (byte~) div8u::$0
  to:div8u::@return
div8u::@return: scope:[div8u]  from div8u::@2
  (byte) rem8u#16 ← phi( div8u::@2/(byte) rem8u#1 )
  (byte) div8u::return#4 ← phi( div8u::@2/(byte) div8u::return#0 )
  (byte) div8u::return#1 ← (byte) div8u::return#4
  (byte) rem8u#2 ← (byte) rem8u#16
  return 
  to:@return

(byte()) divr8u((byte) divr8u::dividend , (byte) divr8u::divisor , (byte) divr8u::rem)
divr8u: scope:[divr8u]  from div8u
  (byte) divr8u::divisor#5 ← phi( div8u/(byte) divr8u::divisor#0 )
  (byte) divr8u::dividend#4 ← phi( div8u/(byte) divr8u::dividend#0 )
  (byte) divr8u::rem#9 ← phi( div8u/(byte) divr8u::rem#0 )
  (byte) divr8u::quotient#0 ← (byte) 0
  (byte) divr8u::i#0 ← (byte) 0
  to:divr8u::@1
divr8u::@1: scope:[divr8u]  from divr8u divr8u::@3
  (byte) divr8u::i#5 ← phi( divr8u/(byte) divr8u::i#0 divr8u::@3/(byte) divr8u::i#1 )
  (byte) divr8u::divisor#3 ← phi( divr8u/(byte) divr8u::divisor#5 divr8u::@3/(byte) divr8u::divisor#6 )
  (byte) divr8u::quotient#6 ← phi( divr8u/(byte) divr8u::quotient#0 divr8u::@3/(byte) divr8u::quotient#8 )
  (byte) divr8u::dividend#2 ← phi( divr8u/(byte) divr8u::dividend#4 divr8u::@3/(byte) divr8u::dividend#5 )
  (byte) divr8u::rem#4 ← phi( divr8u/(byte) divr8u::rem#9 divr8u::@3/(byte) divr8u::rem#10 )
  (byte~) divr8u::$0 ← (byte) divr8u::rem#4 << (number) 1
  (byte) divr8u::rem#1 ← (byte~) divr8u::$0
  (number~) divr8u::$1 ← (byte) divr8u::dividend#2 & (number) $80
  (bool~) divr8u::$2 ← (number~) divr8u::$1 != (number) 0
  (bool~) divr8u::$3 ← ! (bool~) divr8u::$2
  if((bool~) divr8u::$3) goto divr8u::@2
  to:divr8u::@4
divr8u::@2: scope:[divr8u]  from divr8u::@1 divr8u::@4
  (byte) divr8u::i#3 ← phi( divr8u::@1/(byte) divr8u::i#5 divr8u::@4/(byte) divr8u::i#6 )
  (byte) divr8u::divisor#1 ← phi( divr8u::@1/(byte) divr8u::divisor#3 divr8u::@4/(byte) divr8u::divisor#4 )
  (byte) divr8u::rem#5 ← phi( divr8u::@1/(byte) divr8u::rem#1 divr8u::@4/(byte) divr8u::rem#2 )
  (byte) divr8u::quotient#3 ← phi( divr8u::@1/(byte) divr8u::quotient#6 divr8u::@4/(byte) divr8u::quotient#7 )
  (byte) divr8u::dividend#3 ← phi( divr8u::@1/(byte) divr8u::dividend#2 divr8u::@4/(byte) divr8u::dividend#6 )
  (byte~) divr8u::$5 ← (byte) divr8u::dividend#3 << (number) 1
  (byte) divr8u::dividend#1 ← (byte~) divr8u::$5
  (byte~) divr8u::$6 ← (byte) divr8u::quotient#3 << (number) 1
  (byte) divr8u::quotient#1 ← (byte~) divr8u::$6
  (bool~) divr8u::$7 ← (byte) divr8u::rem#5 >= (byte) divr8u::divisor#1
  (bool~) divr8u::$8 ← ! (bool~) divr8u::$7
  if((bool~) divr8u::$8) goto divr8u::@3
  to:divr8u::@5
divr8u::@4: scope:[divr8u]  from divr8u::@1
  (byte) divr8u::i#6 ← phi( divr8u::@1/(byte) divr8u::i#5 )
  (byte) divr8u::divisor#4 ← phi( divr8u::@1/(byte) divr8u::divisor#3 )
  (byte) divr8u::quotient#7 ← phi( divr8u::@1/(byte) divr8u::quotient#6 )
  (byte) divr8u::dividend#6 ← phi( divr8u::@1/(byte) divr8u::dividend#2 )
  (byte) divr8u::rem#6 ← phi( divr8u::@1/(byte) divr8u::rem#1 )
  (number~) divr8u::$4 ← (byte) divr8u::rem#6 | (number) 1
  (byte) divr8u::rem#2 ← (number~) divr8u::$4
  to:divr8u::@2
divr8u::@3: scope:[divr8u]  from divr8u::@2 divr8u::@5
  (byte) divr8u::divisor#6 ← phi( divr8u::@2/(byte) divr8u::divisor#1 divr8u::@5/(byte) divr8u::divisor#2 )
  (byte) divr8u::quotient#8 ← phi( divr8u::@2/(byte) divr8u::quotient#1 divr8u::@5/(byte) divr8u::quotient#2 )
  (byte) divr8u::dividend#5 ← phi( divr8u::@2/(byte) divr8u::dividend#1 divr8u::@5/(byte) divr8u::dividend#7 )
  (byte) divr8u::rem#10 ← phi( divr8u::@2/(byte) divr8u::rem#5 divr8u::@5/(byte) divr8u::rem#3 )
  (byte) divr8u::i#2 ← phi( divr8u::@2/(byte) divr8u::i#3 divr8u::@5/(byte) divr8u::i#4 )
  (byte) divr8u::i#1 ← (byte) divr8u::i#2 + rangenext(0,7)
  (bool~) divr8u::$10 ← (byte) divr8u::i#1 != rangelast(0,7)
  if((bool~) divr8u::$10) goto divr8u::@1
  to:divr8u::@6
divr8u::@5: scope:[divr8u]  from divr8u::@2
  (byte) divr8u::dividend#7 ← phi( divr8u::@2/(byte) divr8u::dividend#1 )
  (byte) divr8u::i#4 ← phi( divr8u::@2/(byte) divr8u::i#3 )
  (byte) divr8u::divisor#2 ← phi( divr8u::@2/(byte) divr8u::divisor#1 )
  (byte) divr8u::rem#7 ← phi( divr8u::@2/(byte) divr8u::rem#5 )
  (byte) divr8u::quotient#4 ← phi( divr8u::@2/(byte) divr8u::quotient#1 )
  (byte) divr8u::quotient#2 ← ++ (byte) divr8u::quotient#4
  (byte~) divr8u::$9 ← (byte) divr8u::rem#7 - (byte) divr8u::divisor#2
  (byte) divr8u::rem#3 ← (byte~) divr8u::$9
  to:divr8u::@3
divr8u::@6: scope:[divr8u]  from divr8u::@3
  (byte) divr8u::quotient#5 ← phi( divr8u::@3/(byte) divr8u::quotient#8 )
  (byte) divr8u::rem#8 ← phi( divr8u::@3/(byte) divr8u::rem#10 )
  (byte) rem8u#3 ← (byte) divr8u::rem#8
  (byte) divr8u::return#1 ← (byte) divr8u::quotient#5
  to:divr8u::@return
divr8u::@return: scope:[divr8u]  from divr8u::@6
  (byte) rem8u#17 ← phi( divr8u::@6/(byte) rem8u#3 )
  (byte) divr8u::return#4 ← phi( divr8u::@6/(byte) divr8u::return#1 )
  (byte) divr8u::return#2 ← (byte) divr8u::return#4
  (byte) rem8u#4 ← (byte) rem8u#17
  return 
  to:@return
@39: scope:[]  from @37
  (byte*) print_screen#7 ← phi( @37/(byte*) print_screen#8 )
  (byte) rem8u#55 ← phi( @37/(byte) rem8u#0 )
  (byte*) print_char_cursor#159 ← phi( @37/(byte*) print_char_cursor#160 )
  (byte*) print_line_cursor#56 ← phi( @37/(byte*) print_line_cursor#61 )
  (word) rem16u#0 ← (word) 0
  to:@42

(word()) divr16u((word) divr16u::dividend , (word) divr16u::divisor , (word) divr16u::rem)
divr16u: scope:[divr16u]  from div16u divr16s::@4
  (word) divr16u::divisor#6 ← phi( div16u/(word) divr16u::divisor#0 divr16s::@4/(word) divr16u::divisor#1 )
  (word) divr16u::dividend#5 ← phi( div16u/(word) divr16u::dividend#1 divr16s::@4/(word) divr16u::dividend#2 )
  (word) divr16u::rem#10 ← phi( div16u/(word) divr16u::rem#3 divr16s::@4/(word) divr16u::rem#4 )
  (word) divr16u::quotient#0 ← (word) 0
  (byte) divr16u::i#0 ← (byte) 0
  to:divr16u::@1
divr16u::@1: scope:[divr16u]  from divr16u divr16u::@3
  (byte) divr16u::i#5 ← phi( divr16u/(byte) divr16u::i#0 divr16u::@3/(byte) divr16u::i#1 )
  (word) divr16u::divisor#4 ← phi( divr16u/(word) divr16u::divisor#6 divr16u::@3/(word) divr16u::divisor#7 )
  (word) divr16u::quotient#6 ← phi( divr16u/(word) divr16u::quotient#0 divr16u::@3/(word) divr16u::quotient#8 )
  (word) divr16u::dividend#3 ← phi( divr16u/(word) divr16u::dividend#5 divr16u::@3/(word) divr16u::dividend#6 )
  (word) divr16u::rem#5 ← phi( divr16u/(word) divr16u::rem#10 divr16u::@3/(word) divr16u::rem#11 )
  (word~) divr16u::$0 ← (word) divr16u::rem#5 << (number) 1
  (word) divr16u::rem#0 ← (word~) divr16u::$0
  (byte~) divr16u::$1 ← > (word) divr16u::dividend#3
  (number~) divr16u::$2 ← (byte~) divr16u::$1 & (number) $80
  (bool~) divr16u::$3 ← (number~) divr16u::$2 != (number) 0
  (bool~) divr16u::$4 ← ! (bool~) divr16u::$3
  if((bool~) divr16u::$4) goto divr16u::@2
  to:divr16u::@4
divr16u::@2: scope:[divr16u]  from divr16u::@1 divr16u::@4
  (byte) divr16u::i#3 ← phi( divr16u::@1/(byte) divr16u::i#5 divr16u::@4/(byte) divr16u::i#6 )
  (word) divr16u::divisor#2 ← phi( divr16u::@1/(word) divr16u::divisor#4 divr16u::@4/(word) divr16u::divisor#5 )
  (word) divr16u::rem#6 ← phi( divr16u::@1/(word) divr16u::rem#0 divr16u::@4/(word) divr16u::rem#1 )
  (word) divr16u::quotient#3 ← phi( divr16u::@1/(word) divr16u::quotient#6 divr16u::@4/(word) divr16u::quotient#7 )
  (word) divr16u::dividend#4 ← phi( divr16u::@1/(word) divr16u::dividend#3 divr16u::@4/(word) divr16u::dividend#7 )
  (word~) divr16u::$6 ← (word) divr16u::dividend#4 << (number) 1
  (word) divr16u::dividend#0 ← (word~) divr16u::$6
  (word~) divr16u::$7 ← (word) divr16u::quotient#3 << (number) 1
  (word) divr16u::quotient#1 ← (word~) divr16u::$7
  (bool~) divr16u::$8 ← (word) divr16u::rem#6 >= (word) divr16u::divisor#2
  (bool~) divr16u::$9 ← ! (bool~) divr16u::$8
  if((bool~) divr16u::$9) goto divr16u::@3
  to:divr16u::@5
divr16u::@4: scope:[divr16u]  from divr16u::@1
  (byte) divr16u::i#6 ← phi( divr16u::@1/(byte) divr16u::i#5 )
  (word) divr16u::divisor#5 ← phi( divr16u::@1/(word) divr16u::divisor#4 )
  (word) divr16u::quotient#7 ← phi( divr16u::@1/(word) divr16u::quotient#6 )
  (word) divr16u::dividend#7 ← phi( divr16u::@1/(word) divr16u::dividend#3 )
  (word) divr16u::rem#7 ← phi( divr16u::@1/(word) divr16u::rem#0 )
  (number~) divr16u::$5 ← (word) divr16u::rem#7 | (number) 1
  (word) divr16u::rem#1 ← (number~) divr16u::$5
  to:divr16u::@2
divr16u::@3: scope:[divr16u]  from divr16u::@2 divr16u::@5
  (word) divr16u::divisor#7 ← phi( divr16u::@2/(word) divr16u::divisor#2 divr16u::@5/(word) divr16u::divisor#3 )
  (word) divr16u::quotient#8 ← phi( divr16u::@2/(word) divr16u::quotient#1 divr16u::@5/(word) divr16u::quotient#2 )
  (word) divr16u::dividend#6 ← phi( divr16u::@2/(word) divr16u::dividend#0 divr16u::@5/(word) divr16u::dividend#8 )
  (word) divr16u::rem#11 ← phi( divr16u::@2/(word) divr16u::rem#6 divr16u::@5/(word) divr16u::rem#2 )
  (byte) divr16u::i#2 ← phi( divr16u::@2/(byte) divr16u::i#3 divr16u::@5/(byte) divr16u::i#4 )
  (byte) divr16u::i#1 ← (byte) divr16u::i#2 + rangenext(0,$f)
  (bool~) divr16u::$11 ← (byte) divr16u::i#1 != rangelast(0,$f)
  if((bool~) divr16u::$11) goto divr16u::@1
  to:divr16u::@6
divr16u::@5: scope:[divr16u]  from divr16u::@2
  (word) divr16u::dividend#8 ← phi( divr16u::@2/(word) divr16u::dividend#0 )
  (byte) divr16u::i#4 ← phi( divr16u::@2/(byte) divr16u::i#3 )
  (word) divr16u::divisor#3 ← phi( divr16u::@2/(word) divr16u::divisor#2 )
  (word) divr16u::rem#8 ← phi( divr16u::@2/(word) divr16u::rem#6 )
  (word) divr16u::quotient#4 ← phi( divr16u::@2/(word) divr16u::quotient#1 )
  (word) divr16u::quotient#2 ← ++ (word) divr16u::quotient#4
  (word~) divr16u::$10 ← (word) divr16u::rem#8 - (word) divr16u::divisor#3
  (word) divr16u::rem#2 ← (word~) divr16u::$10
  to:divr16u::@3
divr16u::@6: scope:[divr16u]  from divr16u::@3
  (word) divr16u::quotient#5 ← phi( divr16u::@3/(word) divr16u::quotient#8 )
  (word) divr16u::rem#9 ← phi( divr16u::@3/(word) divr16u::rem#11 )
  (word) rem16u#1 ← (word) divr16u::rem#9
  (word) divr16u::return#0 ← (word) divr16u::quotient#5
  to:divr16u::@return
divr16u::@return: scope:[divr16u]  from divr16u::@6
  (word) rem16u#17 ← phi( divr16u::@6/(word) rem16u#1 )
  (word) divr16u::return#4 ← phi( divr16u::@6/(word) divr16u::return#0 )
  (word) divr16u::return#1 ← (word) divr16u::return#4
  (word) rem16u#2 ← (word) rem16u#17
  return 
  to:@return

(word()) div16u((word) div16u::dividend , (word) div16u::divisor)
div16u: scope:[div16u]  from test_16u::@1
  (word) rem16u#35 ← phi( test_16u::@1/(word) rem16u#40 )
  (word) div16u::divisor#1 ← phi( test_16u::@1/(word) div16u::divisor#0 )
  (word) div16u::dividend#1 ← phi( test_16u::@1/(word) div16u::dividend#0 )
  (word) divr16u::dividend#1 ← (word) div16u::dividend#1
  (word) divr16u::divisor#0 ← (word) div16u::divisor#1
  (word) divr16u::rem#3 ← (number) 0
  call divr16u 
  (word) divr16u::return#2 ← (word) divr16u::return#1
  to:div16u::@2
div16u::@2: scope:[div16u]  from div16u
  (word) rem16u#18 ← phi( div16u/(word) rem16u#2 )
  (word) divr16u::return#5 ← phi( div16u/(word) divr16u::return#2 )
  (word~) div16u::$0 ← (word) divr16u::return#5
  (word) rem16u#3 ← (word) rem16u#18
  (word) div16u::return#0 ← (word~) div16u::$0
  to:div16u::@return
div16u::@return: scope:[div16u]  from div16u::@2
  (word) rem16u#19 ← phi( div16u::@2/(word) rem16u#3 )
  (word) div16u::return#3 ← phi( div16u::@2/(word) div16u::return#0 )
  (word) div16u::return#1 ← (word) div16u::return#3
  (word) rem16u#4 ← (word) rem16u#19
  return 
  to:@return
@42: scope:[]  from @39
  (byte*) print_screen#6 ← phi( @39/(byte*) print_screen#7 )
  (word) rem16u#55 ← phi( @39/(word) rem16u#0 )
  (byte) rem8u#52 ← phi( @39/(byte) rem8u#55 )
  (byte*) print_char_cursor#154 ← phi( @39/(byte*) print_char_cursor#159 )
  (byte*) print_line_cursor#51 ← phi( @39/(byte*) print_line_cursor#56 )
  (signed byte) rem8s#0 ← (signed byte) 0
  to:@43

(signed byte()) div8s((signed byte) div8s::dividend , (signed byte) div8s::divisor)
div8s: scope:[div8s]  from test_8s::@1
  (byte) rem8u#60 ← phi( test_8s::@1/(byte) rem8u#39 )
  (signed byte) div8s::divisor#6 ← phi( test_8s::@1/(signed byte) div8s::divisor#0 )
  (signed byte) div8s::dividend#1 ← phi( test_8s::@1/(signed byte) div8s::dividend#0 )
  (byte) div8s::neg#0 ← (byte) 0
  (byte) div8s::dividendu#0 ← (byte) 0
  (bool~) div8s::$0 ← (signed byte) div8s::dividend#1 < (number) 0
  if((bool~) div8s::$0) goto div8s::@1
  to:div8s::@7
div8s::@1: scope:[div8s]  from div8s
  (byte) rem8u#56 ← phi( div8s/(byte) rem8u#60 )
  (signed byte) div8s::divisor#4 ← phi( div8s/(signed byte) div8s::divisor#6 )
  (signed byte) div8s::dividend#2 ← phi( div8s/(signed byte) div8s::dividend#1 )
  (signed byte~) div8s::$5 ← - (signed byte) div8s::dividend#2
  (byte~) div8s::$6 ← ((byte)) (signed byte~) div8s::$5
  (byte) div8s::dividendu#1 ← (byte~) div8s::$6
  (byte) div8s::neg#1 ← (number) 1
  to:div8s::@2
div8s::@7: scope:[div8s]  from div8s
  (byte) rem8u#57 ← phi( div8s/(byte) rem8u#60 )
  (byte) div8s::neg#7 ← phi( div8s/(byte) div8s::neg#0 )
  (signed byte) div8s::divisor#5 ← phi( div8s/(signed byte) div8s::divisor#6 )
  (signed byte) div8s::dividend#3 ← phi( div8s/(signed byte) div8s::dividend#1 )
  (byte~) div8s::$4 ← ((byte)) (signed byte) div8s::dividend#3
  (byte) div8s::dividendu#2 ← (byte~) div8s::$4
  to:div8s::@2
div8s::@2: scope:[div8s]  from div8s::@1 div8s::@7
  (byte) rem8u#51 ← phi( div8s::@1/(byte) rem8u#56 div8s::@7/(byte) rem8u#57 )
  (byte) div8s::dividendu#6 ← phi( div8s::@1/(byte) div8s::dividendu#1 div8s::@7/(byte) div8s::dividendu#2 )
  (byte) div8s::neg#5 ← phi( div8s::@1/(byte) div8s::neg#1 div8s::@7/(byte) div8s::neg#7 )
  (signed byte) div8s::divisor#1 ← phi( div8s::@1/(signed byte) div8s::divisor#4 div8s::@7/(signed byte) div8s::divisor#5 )
  (byte) div8s::divisoru#0 ← (byte) 0
  (bool~) div8s::$1 ← (signed byte) div8s::divisor#1 < (number) 0
  if((bool~) div8s::$1) goto div8s::@3
  to:div8s::@9
div8s::@3: scope:[div8s]  from div8s::@2
  (byte) rem8u#42 ← phi( div8s::@2/(byte) rem8u#51 )
  (byte) div8s::dividendu#4 ← phi( div8s::@2/(byte) div8s::dividendu#6 )
  (byte) div8s::neg#3 ← phi( div8s::@2/(byte) div8s::neg#5 )
  (signed byte) div8s::divisor#2 ← phi( div8s::@2/(signed byte) div8s::divisor#1 )
  (signed byte~) div8s::$8 ← - (signed byte) div8s::divisor#2
  (byte~) div8s::$9 ← ((byte)) (signed byte~) div8s::$8
  (byte) div8s::divisoru#1 ← (byte~) div8s::$9
  (number~) div8s::$10 ← (byte) div8s::neg#3 ^ (number) 1
  (byte) div8s::neg#2 ← (number~) div8s::$10
  to:div8s::@4
div8s::@9: scope:[div8s]  from div8s::@2
  (byte) div8s::neg#8 ← phi( div8s::@2/(byte) div8s::neg#5 )
  (byte) rem8u#43 ← phi( div8s::@2/(byte) rem8u#51 )
  (byte) div8s::dividendu#5 ← phi( div8s::@2/(byte) div8s::dividendu#6 )
  (signed byte) div8s::divisor#3 ← phi( div8s::@2/(signed byte) div8s::divisor#1 )
  (byte~) div8s::$7 ← ((byte)) (signed byte) div8s::divisor#3
  (byte) div8s::divisoru#2 ← (byte~) div8s::$7
  to:div8s::@4
div8s::@4: scope:[div8s]  from div8s::@3 div8s::@9
  (byte) div8s::neg#6 ← phi( div8s::@3/(byte) div8s::neg#2 div8s::@9/(byte) div8s::neg#8 )
  (byte) rem8u#32 ← phi( div8s::@3/(byte) rem8u#42 div8s::@9/(byte) rem8u#43 )
  (byte) div8s::divisoru#3 ← phi( div8s::@3/(byte) div8s::divisoru#1 div8s::@9/(byte) div8s::divisoru#2 )
  (byte) div8s::dividendu#3 ← phi( div8s::@3/(byte) div8s::dividendu#4 div8s::@9/(byte) div8s::dividendu#5 )
  (byte) div8u::dividend#0 ← (byte) div8s::dividendu#3
  (byte) div8u::divisor#0 ← (byte) div8s::divisoru#3
  call div8u 
  (byte) div8u::return#2 ← (byte) div8u::return#1
  to:div8s::@15
div8s::@15: scope:[div8s]  from div8s::@4
  (byte) div8s::neg#4 ← phi( div8s::@4/(byte) div8s::neg#6 )
  (byte) rem8u#18 ← phi( div8s::@4/(byte) rem8u#2 )
  (byte) div8u::return#5 ← phi( div8s::@4/(byte) div8u::return#2 )
  (byte~) div8s::$2 ← (byte) div8u::return#5
  (byte) rem8u#5 ← (byte) rem8u#18
  (byte) div8s::resultu#0 ← (byte~) div8s::$2
  (bool~) div8s::$3 ← (byte) div8s::neg#4 == (number) 0
  if((bool~) div8s::$3) goto div8s::@5
  to:div8s::@11
div8s::@5: scope:[div8s]  from div8s::@15
  (byte) div8s::resultu#1 ← phi( div8s::@15/(byte) div8s::resultu#0 )
  (byte) rem8u#19 ← phi( div8s::@15/(byte) rem8u#5 )
  (signed byte~) div8s::$15 ← ((signed byte)) (byte) rem8u#19
  (signed byte) rem8s#1 ← (signed byte~) div8s::$15
  (signed byte~) div8s::$16 ← ((signed byte)) (byte) div8s::resultu#1
  (signed byte) div8s::return#0 ← (signed byte~) div8s::$16
  to:div8s::@return
div8s::@11: scope:[div8s]  from div8s::@15
  (byte) div8s::resultu#2 ← phi( div8s::@15/(byte) div8s::resultu#0 )
  (byte) rem8u#20 ← phi( div8s::@15/(byte) rem8u#5 )
  (signed byte~) div8s::$11 ← ((signed byte)) (byte) rem8u#20
  (signed byte~) div8s::$12 ← - (signed byte~) div8s::$11
  (signed byte) rem8s#2 ← (signed byte~) div8s::$12
  (signed byte~) div8s::$13 ← ((signed byte)) (byte) div8s::resultu#2
  (signed byte~) div8s::$14 ← - (signed byte~) div8s::$13
  (signed byte) div8s::return#1 ← (signed byte~) div8s::$14
  to:div8s::@return
div8s::@return: scope:[div8s]  from div8s::@11 div8s::@5
  (signed byte) rem8s#9 ← phi( div8s::@11/(signed byte) rem8s#2 div8s::@5/(signed byte) rem8s#1 )
  (byte) rem8u#21 ← phi( div8s::@11/(byte) rem8u#20 div8s::@5/(byte) rem8u#19 )
  (signed byte) div8s::return#4 ← phi( div8s::@11/(signed byte) div8s::return#1 div8s::@5/(signed byte) div8s::return#0 )
  (signed byte) div8s::return#2 ← (signed byte) div8s::return#4
  (byte) rem8u#6 ← (byte) rem8u#21
  (signed byte) rem8s#3 ← (signed byte) rem8s#9
  return 
  to:@return
@43: scope:[]  from @42
  (byte*) print_screen#5 ← phi( @42/(byte*) print_screen#6 )
  (signed byte) rem8s#26 ← phi( @42/(signed byte) rem8s#0 )
  (word) rem16u#54 ← phi( @42/(word) rem16u#55 )
  (byte) rem8u#50 ← phi( @42/(byte) rem8u#52 )
  (byte*) print_char_cursor#153 ← phi( @42/(byte*) print_char_cursor#154 )
  (byte*) print_line_cursor#50 ← phi( @42/(byte*) print_line_cursor#51 )
  (signed word) rem16s#0 ← (signed word) 0
  to:@50

(signed word()) divr16s((signed word) divr16s::dividend , (signed word) divr16s::divisor , (signed word) divr16s::rem)
divr16s: scope:[divr16s]  from div16s
  (word) rem16u#64 ← phi( div16s/(word) rem16u#37 )
  (signed word) divr16s::divisor#6 ← phi( div16s/(signed word) divr16s::divisor#0 )
  (signed word) divr16s::rem#1 ← phi( div16s/(signed word) divr16s::rem#0 )
  (signed word) divr16s::dividend#1 ← phi( div16s/(signed word) divr16s::dividend#0 )
  (byte) divr16s::neg#0 ← (byte) 0
  (word) divr16s::dividendu#0 ← (word) 0
  (word) divr16s::remu#0 ← (word) 0
  (bool~) divr16s::$0 ← (signed word) divr16s::dividend#1 < (number) 0
  (bool~) divr16s::$1 ← (signed word) divr16s::rem#1 < (number) 0
  (bool~) divr16s::$2 ← (bool~) divr16s::$0 || (bool~) divr16s::$1
  if((bool~) divr16s::$2) goto divr16s::@1
  to:divr16s::@7
divr16s::@1: scope:[divr16s]  from divr16s
  (word) rem16u#60 ← phi( divr16s/(word) rem16u#64 )
  (signed word) divr16s::divisor#4 ← phi( divr16s/(signed word) divr16s::divisor#6 )
  (signed word) divr16s::rem#2 ← phi( divr16s/(signed word) divr16s::rem#1 )
  (signed word) divr16s::dividend#2 ← phi( divr16s/(signed word) divr16s::dividend#1 )
  (signed word~) divr16s::$8 ← - (signed word) divr16s::dividend#2
  (word~) divr16s::$9 ← ((word)) (signed word~) divr16s::$8
  (word) divr16s::dividendu#1 ← (word~) divr16s::$9
  (signed word~) divr16s::$10 ← - (signed word) divr16s::rem#2
  (word~) divr16s::$11 ← ((word)) (signed word~) divr16s::$10
  (word) divr16s::remu#1 ← (word~) divr16s::$11
  (byte) divr16s::neg#1 ← (number) 1
  to:divr16s::@2
divr16s::@7: scope:[divr16s]  from divr16s
  (word) rem16u#61 ← phi( divr16s/(word) rem16u#64 )
  (byte) divr16s::neg#7 ← phi( divr16s/(byte) divr16s::neg#0 )
  (signed word) divr16s::divisor#5 ← phi( divr16s/(signed word) divr16s::divisor#6 )
  (signed word) divr16s::rem#3 ← phi( divr16s/(signed word) divr16s::rem#1 )
  (signed word) divr16s::dividend#3 ← phi( divr16s/(signed word) divr16s::dividend#1 )
  (word~) divr16s::$6 ← ((word)) (signed word) divr16s::dividend#3
  (word) divr16s::dividendu#2 ← (word~) divr16s::$6
  (word~) divr16s::$7 ← ((word)) (signed word) divr16s::rem#3
  (word) divr16s::remu#2 ← (word~) divr16s::$7
  to:divr16s::@2
divr16s::@2: scope:[divr16s]  from divr16s::@1 divr16s::@7
  (word) rem16u#56 ← phi( divr16s::@1/(word) rem16u#60 divr16s::@7/(word) rem16u#61 )
  (word) divr16s::remu#6 ← phi( divr16s::@1/(word) divr16s::remu#1 divr16s::@7/(word) divr16s::remu#2 )
  (word) divr16s::dividendu#6 ← phi( divr16s::@1/(word) divr16s::dividendu#1 divr16s::@7/(word) divr16s::dividendu#2 )
  (byte) divr16s::neg#5 ← phi( divr16s::@1/(byte) divr16s::neg#1 divr16s::@7/(byte) divr16s::neg#7 )
  (signed word) divr16s::divisor#1 ← phi( divr16s::@1/(signed word) divr16s::divisor#4 divr16s::@7/(signed word) divr16s::divisor#5 )
  (word) divr16s::divisoru#0 ← (word) 0
  (bool~) divr16s::$3 ← (signed word) divr16s::divisor#1 < (number) 0
  if((bool~) divr16s::$3) goto divr16s::@3
  to:divr16s::@9
divr16s::@3: scope:[divr16s]  from divr16s::@2
  (word) rem16u#46 ← phi( divr16s::@2/(word) rem16u#56 )
  (word) divr16s::remu#4 ← phi( divr16s::@2/(word) divr16s::remu#6 )
  (word) divr16s::dividendu#4 ← phi( divr16s::@2/(word) divr16s::dividendu#6 )
  (byte) divr16s::neg#3 ← phi( divr16s::@2/(byte) divr16s::neg#5 )
  (signed word) divr16s::divisor#2 ← phi( divr16s::@2/(signed word) divr16s::divisor#1 )
  (signed word~) divr16s::$13 ← - (signed word) divr16s::divisor#2
  (word~) divr16s::$14 ← ((word)) (signed word~) divr16s::$13
  (word) divr16s::divisoru#1 ← (word~) divr16s::$14
  (number~) divr16s::$15 ← (byte) divr16s::neg#3 ^ (number) 1
  (byte) divr16s::neg#2 ← (number~) divr16s::$15
  to:divr16s::@4
divr16s::@9: scope:[divr16s]  from divr16s::@2
  (byte) divr16s::neg#8 ← phi( divr16s::@2/(byte) divr16s::neg#5 )
  (word) rem16u#47 ← phi( divr16s::@2/(word) rem16u#56 )
  (word) divr16s::remu#5 ← phi( divr16s::@2/(word) divr16s::remu#6 )
  (word) divr16s::dividendu#5 ← phi( divr16s::@2/(word) divr16s::dividendu#6 )
  (signed word) divr16s::divisor#3 ← phi( divr16s::@2/(signed word) divr16s::divisor#1 )
  (word~) divr16s::$12 ← ((word)) (signed word) divr16s::divisor#3
  (word) divr16s::divisoru#2 ← (word~) divr16s::$12
  to:divr16s::@4
divr16s::@4: scope:[divr16s]  from divr16s::@3 divr16s::@9
  (byte) divr16s::neg#6 ← phi( divr16s::@3/(byte) divr16s::neg#2 divr16s::@9/(byte) divr16s::neg#8 )
  (word) rem16u#36 ← phi( divr16s::@3/(word) rem16u#46 divr16s::@9/(word) rem16u#47 )
  (word) divr16s::remu#3 ← phi( divr16s::@3/(word) divr16s::remu#4 divr16s::@9/(word) divr16s::remu#5 )
  (word) divr16s::divisoru#3 ← phi( divr16s::@3/(word) divr16s::divisoru#1 divr16s::@9/(word) divr16s::divisoru#2 )
  (word) divr16s::dividendu#3 ← phi( divr16s::@3/(word) divr16s::dividendu#4 divr16s::@9/(word) divr16s::dividendu#5 )
  (word) divr16u::dividend#2 ← (word) divr16s::dividendu#3
  (word) divr16u::divisor#1 ← (word) divr16s::divisoru#3
  (word) divr16u::rem#4 ← (word) divr16s::remu#3
  call divr16u 
  (word) divr16u::return#3 ← (word) divr16u::return#1
  to:divr16s::@15
divr16s::@15: scope:[divr16s]  from divr16s::@4
  (byte) divr16s::neg#4 ← phi( divr16s::@4/(byte) divr16s::neg#6 )
  (word) rem16u#20 ← phi( divr16s::@4/(word) rem16u#2 )
  (word) divr16u::return#6 ← phi( divr16s::@4/(word) divr16u::return#3 )
  (word~) divr16s::$4 ← (word) divr16u::return#6
  (word) rem16u#5 ← (word) rem16u#20
  (word) divr16s::resultu#0 ← (word~) divr16s::$4
  (bool~) divr16s::$5 ← (byte) divr16s::neg#4 == (number) 0
  if((bool~) divr16s::$5) goto divr16s::@5
  to:divr16s::@11
divr16s::@5: scope:[divr16s]  from divr16s::@15
  (word) divr16s::resultu#1 ← phi( divr16s::@15/(word) divr16s::resultu#0 )
  (word) rem16u#21 ← phi( divr16s::@15/(word) rem16u#5 )
  (signed word~) divr16s::$20 ← ((signed word)) (word) rem16u#21
  (signed word) rem16s#1 ← (signed word~) divr16s::$20
  (signed word~) divr16s::$21 ← ((signed word)) (word) divr16s::resultu#1
  (signed word) divr16s::return#0 ← (signed word~) divr16s::$21
  to:divr16s::@return
divr16s::@11: scope:[divr16s]  from divr16s::@15
  (word) divr16s::resultu#2 ← phi( divr16s::@15/(word) divr16s::resultu#0 )
  (word) rem16u#22 ← phi( divr16s::@15/(word) rem16u#5 )
  (signed word~) divr16s::$16 ← ((signed word)) (word) rem16u#22
  (signed word~) divr16s::$17 ← - (signed word~) divr16s::$16
  (signed word) rem16s#2 ← (signed word~) divr16s::$17
  (signed word~) divr16s::$18 ← ((signed word)) (word) divr16s::resultu#2
  (signed word~) divr16s::$19 ← - (signed word~) divr16s::$18
  (signed word) divr16s::return#1 ← (signed word~) divr16s::$19
  to:divr16s::@return
divr16s::@return: scope:[divr16s]  from divr16s::@11 divr16s::@5
  (signed word) rem16s#11 ← phi( divr16s::@11/(signed word) rem16s#2 divr16s::@5/(signed word) rem16s#1 )
  (word) rem16u#23 ← phi( divr16s::@11/(word) rem16u#22 divr16s::@5/(word) rem16u#21 )
  (signed word) divr16s::return#4 ← phi( divr16s::@11/(signed word) divr16s::return#1 divr16s::@5/(signed word) divr16s::return#0 )
  (signed word) divr16s::return#2 ← (signed word) divr16s::return#4
  (word) rem16u#6 ← (word) rem16u#23
  (signed word) rem16s#3 ← (signed word) rem16s#11
  return 
  to:@return

(signed word()) div16s((signed word) div16s::dividend , (signed word) div16s::divisor)
div16s: scope:[div16s]  from test_16s::@1
  (signed word) rem16s#20 ← phi( test_16s::@1/(signed word) rem16s#22 )
  (word) rem16u#37 ← phi( test_16s::@1/(word) rem16u#43 )
  (signed word) div16s::divisor#1 ← phi( test_16s::@1/(signed word) div16s::divisor#0 )
  (signed word) div16s::dividend#1 ← phi( test_16s::@1/(signed word) div16s::dividend#0 )
  (signed word) divr16s::dividend#0 ← (signed word) div16s::dividend#1
  (signed word) divr16s::divisor#0 ← (signed word) div16s::divisor#1
  (signed word) divr16s::rem#0 ← (number) 0
  call divr16s 
  (signed word) divr16s::return#3 ← (signed word) divr16s::return#2
  to:div16s::@2
div16s::@2: scope:[div16s]  from div16s
  (signed word) rem16s#12 ← phi( div16s/(signed word) rem16s#3 )
  (word) rem16u#24 ← phi( div16s/(word) rem16u#6 )
  (signed word) divr16s::return#5 ← phi( div16s/(signed word) divr16s::return#3 )
  (signed word~) div16s::$0 ← (signed word) divr16s::return#5
  (word) rem16u#7 ← (word) rem16u#24
  (signed word) rem16s#4 ← (signed word) rem16s#12
  (signed word) div16s::return#0 ← (signed word~) div16s::$0
  to:div16s::@return
div16s::@return: scope:[div16s]  from div16s::@2
  (signed word) rem16s#13 ← phi( div16s::@2/(signed word) rem16s#4 )
  (word) rem16u#25 ← phi( div16s::@2/(word) rem16u#7 )
  (signed word) div16s::return#3 ← phi( div16s::@2/(signed word) div16s::return#0 )
  (signed word) div16s::return#1 ← (signed word) div16s::return#3
  (word) rem16u#8 ← (word) rem16u#25
  (signed word) rem16s#5 ← (signed word) rem16s#13
  return 
  to:@return

(void()) main()
main: scope:[main]  from @50
  (signed word) rem16s#34 ← phi( @50/(signed word) rem16s#25 )
  (signed byte) rem8s#29 ← phi( @50/(signed byte) rem8s#21 )
  (word) rem16u#57 ← phi( @50/(word) rem16u#45 )
  (byte) rem8u#44 ← phi( @50/(byte) rem8u#41 )
  (byte*) print_char_cursor#140 ← phi( @50/(byte*) print_char_cursor#145 )
  (byte*) print_line_cursor#40 ← phi( @50/(byte*) print_line_cursor#45 )
  (byte*) print_screen#3 ← phi( @50/(byte*) print_screen#4 )
  call print_cls 
  to:main::@1
main::@1: scope:[main]  from main
  (signed word) rem16s#32 ← phi( main/(signed word) rem16s#34 )
  (signed byte) rem8s#27 ← phi( main/(signed byte) rem8s#29 )
  (word) rem16u#48 ← phi( main/(word) rem16u#57 )
  (byte) rem8u#33 ← phi( main/(byte) rem8u#44 )
  (byte*) print_char_cursor#87 ← phi( main/(byte*) print_char_cursor#22 )
  (byte*) print_line_cursor#24 ← phi( main/(byte*) print_line_cursor#4 )
  (byte*) print_line_cursor#5 ← (byte*) print_line_cursor#24
  (byte*) print_char_cursor#23 ← (byte*) print_char_cursor#87
  call test_8u 
  to:main::@2
main::@2: scope:[main]  from main::@1
  (signed word) rem16s#30 ← phi( main::@1/(signed word) rem16s#32 )
  (signed byte) rem8s#22 ← phi( main::@1/(signed byte) rem8s#27 )
  (word) rem16u#38 ← phi( main::@1/(word) rem16u#48 )
  (byte*) print_line_cursor#25 ← phi( main::@1/(byte*) print_line_cursor#12 )
  (byte*) print_char_cursor#88 ← phi( main::@1/(byte*) print_char_cursor#37 )
  (byte) rem8u#22 ← phi( main::@1/(byte) rem8u#11 )
  (byte) rem8u#7 ← (byte) rem8u#22
  (byte*) print_char_cursor#24 ← (byte*) print_char_cursor#88
  (byte*) print_line_cursor#6 ← (byte*) print_line_cursor#25
  call test_16u 
  to:main::@3
main::@3: scope:[main]  from main::@2
  (signed word) rem16s#26 ← phi( main::@2/(signed word) rem16s#30 )
  (signed byte) rem8s#16 ← phi( main::@2/(signed byte) rem8s#22 )
  (byte) rem8u#34 ← phi( main::@2/(byte) rem8u#7 )
  (byte*) print_line_cursor#26 ← phi( main::@2/(byte*) print_line_cursor#14 )
  (byte*) print_char_cursor#89 ← phi( main::@2/(byte*) print_char_cursor#46 )
  (word) rem16u#26 ← phi( main::@2/(word) rem16u#13 )
  (word) rem16u#9 ← (word) rem16u#26
  (byte*) print_char_cursor#25 ← (byte*) print_char_cursor#89
  (byte*) print_line_cursor#7 ← (byte*) print_line_cursor#26
  call test_8s 
  to:main::@4
main::@4: scope:[main]  from main::@3
  (signed word) rem16s#21 ← phi( main::@3/(signed word) rem16s#26 )
  (word) rem16u#39 ← phi( main::@3/(word) rem16u#9 )
  (byte*) print_line_cursor#27 ← phi( main::@3/(byte*) print_line_cursor#16 )
  (byte*) print_char_cursor#90 ← phi( main::@3/(byte*) print_char_cursor#55 )
  (signed byte) rem8s#10 ← phi( main::@3/(signed byte) rem8s#7 )
  (byte) rem8u#23 ← phi( main::@3/(byte) rem8u#13 )
  (byte) rem8u#8 ← (byte) rem8u#23
  (signed byte) rem8s#4 ← (signed byte) rem8s#10
  (byte*) print_char_cursor#26 ← (byte*) print_char_cursor#90
  (byte*) print_line_cursor#8 ← (byte*) print_line_cursor#27
  call test_16s 
  to:main::@5
main::@5: scope:[main]  from main::@4
  (signed byte) rem8s#17 ← phi( main::@4/(signed byte) rem8s#4 )
  (byte) rem8u#35 ← phi( main::@4/(byte) rem8u#8 )
  (byte*) print_line_cursor#28 ← phi( main::@4/(byte*) print_line_cursor#18 )
  (byte*) print_char_cursor#91 ← phi( main::@4/(byte*) print_char_cursor#64 )
  (signed word) rem16s#14 ← phi( main::@4/(signed word) rem16s#9 )
  (word) rem16u#27 ← phi( main::@4/(word) rem16u#15 )
  (word) rem16u#10 ← (word) rem16u#27
  (signed word) rem16s#6 ← (signed word) rem16s#14
  (byte*) print_char_cursor#27 ← (byte*) print_char_cursor#91
  (byte*) print_line_cursor#9 ← (byte*) print_line_cursor#28
  to:main::@return
main::@return: scope:[main]  from main::@5
  (signed word) rem16s#15 ← phi( main::@5/(signed word) rem16s#6 )
  (signed byte) rem8s#11 ← phi( main::@5/(signed byte) rem8s#17 )
  (word) rem16u#28 ← phi( main::@5/(word) rem16u#10 )
  (byte) rem8u#24 ← phi( main::@5/(byte) rem8u#35 )
  (byte*) print_char_cursor#92 ← phi( main::@5/(byte*) print_char_cursor#27 )
  (byte*) print_line_cursor#29 ← phi( main::@5/(byte*) print_line_cursor#9 )
  (byte*) print_line_cursor#10 ← (byte*) print_line_cursor#29
  (byte*) print_char_cursor#28 ← (byte*) print_char_cursor#92
  (byte) rem8u#9 ← (byte) rem8u#24
  (word) rem16u#11 ← (word) rem16u#28
  (signed byte) rem8s#5 ← (signed byte) rem8s#11
  (signed word) rem16s#7 ← (signed word) rem16s#15
  return 
  to:@return

(void()) test_8u()
test_8u: scope:[test_8u]  from main::@1
  (byte*) print_line_cursor#82 ← phi( main::@1/(byte*) print_line_cursor#5 )
  (byte*) print_char_cursor#155 ← phi( main::@1/(byte*) print_char_cursor#23 )
  (byte) rem8u#45 ← phi( main::@1/(byte) rem8u#33 )
  (byte) test_8u::i#0 ← (byte) 0
  to:test_8u::@1
test_8u::@1: scope:[test_8u]  from test_8u test_8u::@11
  (byte*) print_line_cursor#78 ← phi( test_8u/(byte*) print_line_cursor#82 test_8u::@11/(byte*) print_line_cursor#11 )
  (byte*) print_char_cursor#149 ← phi( test_8u/(byte*) print_char_cursor#155 test_8u::@11/(byte*) print_char_cursor#36 )
  (byte) rem8u#36 ← phi( test_8u/(byte) rem8u#45 test_8u::@11/(byte) rem8u#38 )
  (byte) test_8u::i#2 ← phi( test_8u/(byte) test_8u::i#0 test_8u::@11/(byte) test_8u::i#1 )
  (byte) test_8u::dividend#0 ← *((const byte*) test_8u::dividends + (byte) test_8u::i#2)
  (byte) test_8u::divisor#0 ← *((const byte*) test_8u::divisors + (byte) test_8u::i#2)
  (byte) div8u::dividend#1 ← (byte) test_8u::dividend#0
  (byte) div8u::divisor#1 ← (byte) test_8u::divisor#0
  call div8u 
  (byte) div8u::return#3 ← (byte) div8u::return#1
  to:test_8u::@3
test_8u::@3: scope:[test_8u]  from test_8u::@1
  (byte) test_8u::i#11 ← phi( test_8u::@1/(byte) test_8u::i#2 )
  (byte*) print_line_cursor#74 ← phi( test_8u::@1/(byte*) print_line_cursor#78 )
  (byte) test_8u::divisor#3 ← phi( test_8u::@1/(byte) test_8u::divisor#0 )
  (byte*) print_char_cursor#141 ← phi( test_8u::@1/(byte*) print_char_cursor#149 )
  (byte) test_8u::dividend#1 ← phi( test_8u::@1/(byte) test_8u::dividend#0 )
  (byte) rem8u#25 ← phi( test_8u::@1/(byte) rem8u#2 )
  (byte) div8u::return#6 ← phi( test_8u::@1/(byte) div8u::return#3 )
  (byte~) test_8u::$0 ← (byte) div8u::return#6
  (byte) rem8u#10 ← (byte) rem8u#25
  (byte) test_8u::res#0 ← (byte~) test_8u::$0
  (byte) print_byte::b#3 ← (byte) test_8u::dividend#1
  call print_byte 
  to:test_8u::@4
test_8u::@4: scope:[test_8u]  from test_8u::@3
  (byte) test_8u::i#10 ← phi( test_8u::@3/(byte) test_8u::i#11 )
  (byte*) print_line_cursor#70 ← phi( test_8u::@3/(byte*) print_line_cursor#74 )
  (byte) rem8u#61 ← phi( test_8u::@3/(byte) rem8u#10 )
  (byte) test_8u::res#4 ← phi( test_8u::@3/(byte) test_8u::res#0 )
  (byte) test_8u::divisor#2 ← phi( test_8u::@3/(byte) test_8u::divisor#3 )
  (byte*) print_char_cursor#93 ← phi( test_8u::@3/(byte*) print_char_cursor#18 )
  (byte*) print_char_cursor#29 ← (byte*) print_char_cursor#93
  (byte*) print_str::str#1 ← (const string) test_8u::str
  call print_str 
  to:test_8u::@5
test_8u::@5: scope:[test_8u]  from test_8u::@4
  (byte) test_8u::i#9 ← phi( test_8u::@4/(byte) test_8u::i#10 )
  (byte*) print_line_cursor#66 ← phi( test_8u::@4/(byte*) print_line_cursor#70 )
  (byte) rem8u#58 ← phi( test_8u::@4/(byte) rem8u#61 )
  (byte) test_8u::res#3 ← phi( test_8u::@4/(byte) test_8u::res#4 )
  (byte) test_8u::divisor#1 ← phi( test_8u::@4/(byte) test_8u::divisor#2 )
  (byte*) print_char_cursor#94 ← phi( test_8u::@4/(byte*) print_char_cursor#2 )
  (byte*) print_char_cursor#30 ← (byte*) print_char_cursor#94
  (byte) print_byte::b#4 ← (byte) test_8u::divisor#1
  call print_byte 
  to:test_8u::@6
test_8u::@6: scope:[test_8u]  from test_8u::@5
  (byte) test_8u::i#8 ← phi( test_8u::@5/(byte) test_8u::i#9 )
  (byte*) print_line_cursor#62 ← phi( test_8u::@5/(byte*) print_line_cursor#66 )
  (byte) rem8u#53 ← phi( test_8u::@5/(byte) rem8u#58 )
  (byte) test_8u::res#2 ← phi( test_8u::@5/(byte) test_8u::res#3 )
  (byte*) print_char_cursor#95 ← phi( test_8u::@5/(byte*) print_char_cursor#18 )
  (byte*) print_char_cursor#31 ← (byte*) print_char_cursor#95
  (byte*) print_str::str#2 ← (const string) test_8u::str1
  call print_str 
  to:test_8u::@7
test_8u::@7: scope:[test_8u]  from test_8u::@6
  (byte) test_8u::i#7 ← phi( test_8u::@6/(byte) test_8u::i#8 )
  (byte*) print_line_cursor#57 ← phi( test_8u::@6/(byte*) print_line_cursor#62 )
  (byte) rem8u#46 ← phi( test_8u::@6/(byte) rem8u#53 )
  (byte) test_8u::res#1 ← phi( test_8u::@6/(byte) test_8u::res#2 )
  (byte*) print_char_cursor#96 ← phi( test_8u::@6/(byte*) print_char_cursor#2 )
  (byte*) print_char_cursor#32 ← (byte*) print_char_cursor#96
  (byte) print_byte::b#5 ← (byte) test_8u::res#1
  call print_byte 
  to:test_8u::@8
test_8u::@8: scope:[test_8u]  from test_8u::@7
  (byte) test_8u::i#6 ← phi( test_8u::@7/(byte) test_8u::i#7 )
  (byte*) print_line_cursor#52 ← phi( test_8u::@7/(byte*) print_line_cursor#57 )
  (byte) rem8u#37 ← phi( test_8u::@7/(byte) rem8u#46 )
  (byte*) print_char_cursor#97 ← phi( test_8u::@7/(byte*) print_char_cursor#18 )
  (byte*) print_char_cursor#33 ← (byte*) print_char_cursor#97
  (byte*) print_str::str#3 ← (const string) test_8u::str2
  call print_str 
  to:test_8u::@9
test_8u::@9: scope:[test_8u]  from test_8u::@8
  (byte) test_8u::i#5 ← phi( test_8u::@8/(byte) test_8u::i#6 )
  (byte*) print_line_cursor#46 ← phi( test_8u::@8/(byte*) print_line_cursor#52 )
  (byte) rem8u#26 ← phi( test_8u::@8/(byte) rem8u#37 )
  (byte*) print_char_cursor#98 ← phi( test_8u::@8/(byte*) print_char_cursor#2 )
  (byte*) print_char_cursor#34 ← (byte*) print_char_cursor#98
  (byte) print_byte::b#6 ← (byte) rem8u#26
  call print_byte 
  to:test_8u::@10
test_8u::@10: scope:[test_8u]  from test_8u::@9
  (byte) rem8u#47 ← phi( test_8u::@9/(byte) rem8u#26 )
  (byte) test_8u::i#4 ← phi( test_8u::@9/(byte) test_8u::i#5 )
  (byte*) print_line_cursor#41 ← phi( test_8u::@9/(byte*) print_line_cursor#46 )
  (byte*) print_char_cursor#99 ← phi( test_8u::@9/(byte*) print_char_cursor#18 )
  (byte*) print_char_cursor#35 ← (byte*) print_char_cursor#99
  call print_ln 
  to:test_8u::@11
test_8u::@11: scope:[test_8u]  from test_8u::@10
  (byte) rem8u#38 ← phi( test_8u::@10/(byte) rem8u#47 )
  (byte) test_8u::i#3 ← phi( test_8u::@10/(byte) test_8u::i#4 )
  (byte*) print_char_cursor#100 ← phi( test_8u::@10/(byte*) print_char_cursor#4 )
  (byte*) print_line_cursor#30 ← phi( test_8u::@10/(byte*) print_line_cursor#2 )
  (byte*) print_line_cursor#11 ← (byte*) print_line_cursor#30
  (byte*) print_char_cursor#36 ← (byte*) print_char_cursor#100
  (byte) test_8u::i#1 ← (byte) test_8u::i#3 + rangenext(0,5)
  (bool~) test_8u::$9 ← (byte) test_8u::i#1 != rangelast(0,5)
  if((bool~) test_8u::$9) goto test_8u::@1
  to:test_8u::@return
test_8u::@return: scope:[test_8u]  from test_8u::@11
  (byte*) print_line_cursor#31 ← phi( test_8u::@11/(byte*) print_line_cursor#11 )
  (byte*) print_char_cursor#101 ← phi( test_8u::@11/(byte*) print_char_cursor#36 )
  (byte) rem8u#27 ← phi( test_8u::@11/(byte) rem8u#38 )
  (byte) rem8u#11 ← (byte) rem8u#27
  (byte*) print_char_cursor#37 ← (byte*) print_char_cursor#101
  (byte*) print_line_cursor#12 ← (byte*) print_line_cursor#31
  return 
  to:@return

(void()) test_16u()
test_16u: scope:[test_16u]  from main::@2
  (byte*) print_line_cursor#83 ← phi( main::@2/(byte*) print_line_cursor#6 )
  (byte*) print_char_cursor#156 ← phi( main::@2/(byte*) print_char_cursor#24 )
  (word) rem16u#49 ← phi( main::@2/(word) rem16u#38 )
  (byte) test_16u::i#0 ← (byte) 0
  to:test_16u::@1
test_16u::@1: scope:[test_16u]  from test_16u test_16u::@11
  (byte*) print_line_cursor#79 ← phi( test_16u/(byte*) print_line_cursor#83 test_16u::@11/(byte*) print_line_cursor#13 )
  (byte*) print_char_cursor#150 ← phi( test_16u/(byte*) print_char_cursor#156 test_16u::@11/(byte*) print_char_cursor#45 )
  (word) rem16u#40 ← phi( test_16u/(word) rem16u#49 test_16u::@11/(word) rem16u#42 )
  (byte) test_16u::i#2 ← phi( test_16u/(byte) test_16u::i#0 test_16u::@11/(byte) test_16u::i#1 )
  (byte~) test_16u::$10 ← (byte) test_16u::i#2 * (const byte) SIZEOF_WORD
  (word) test_16u::dividend#0 ← *((const word*) test_16u::dividends + (byte~) test_16u::$10)
  (byte~) test_16u::$11 ← (byte) test_16u::i#2 * (const byte) SIZEOF_WORD
  (word) test_16u::divisor#0 ← *((const word*) test_16u::divisors + (byte~) test_16u::$11)
  (word) div16u::dividend#0 ← (word) test_16u::dividend#0
  (word) div16u::divisor#0 ← (word) test_16u::divisor#0
  call div16u 
  (word) div16u::return#2 ← (word) div16u::return#1
  to:test_16u::@3
test_16u::@3: scope:[test_16u]  from test_16u::@1
  (byte) test_16u::i#11 ← phi( test_16u::@1/(byte) test_16u::i#2 )
  (byte*) print_line_cursor#75 ← phi( test_16u::@1/(byte*) print_line_cursor#79 )
  (word) test_16u::divisor#3 ← phi( test_16u::@1/(word) test_16u::divisor#0 )
  (byte*) print_char_cursor#142 ← phi( test_16u::@1/(byte*) print_char_cursor#150 )
  (word) test_16u::dividend#1 ← phi( test_16u::@1/(word) test_16u::dividend#0 )
  (word) rem16u#29 ← phi( test_16u::@1/(word) rem16u#4 )
  (word) div16u::return#4 ← phi( test_16u::@1/(word) div16u::return#2 )
  (word~) test_16u::$0 ← (word) div16u::return#4
  (word) rem16u#12 ← (word) rem16u#29
  (word) test_16u::res#0 ← (word~) test_16u::$0
  (word) print_word::w#1 ← (word) test_16u::dividend#1
  call print_word 
  to:test_16u::@4
test_16u::@4: scope:[test_16u]  from test_16u::@3
  (byte) test_16u::i#10 ← phi( test_16u::@3/(byte) test_16u::i#11 )
  (byte*) print_line_cursor#71 ← phi( test_16u::@3/(byte*) print_line_cursor#75 )
  (word) rem16u#65 ← phi( test_16u::@3/(word) rem16u#12 )
  (word) test_16u::res#4 ← phi( test_16u::@3/(word) test_16u::res#0 )
  (word) test_16u::divisor#2 ← phi( test_16u::@3/(word) test_16u::divisor#3 )
  (byte*) print_char_cursor#102 ← phi( test_16u::@3/(byte*) print_char_cursor#15 )
  (byte*) print_char_cursor#38 ← (byte*) print_char_cursor#102
  (byte*) print_str::str#4 ← (const string) test_16u::str
  call print_str 
  to:test_16u::@5
test_16u::@5: scope:[test_16u]  from test_16u::@4
  (byte) test_16u::i#9 ← phi( test_16u::@4/(byte) test_16u::i#10 )
  (byte*) print_line_cursor#67 ← phi( test_16u::@4/(byte*) print_line_cursor#71 )
  (word) rem16u#62 ← phi( test_16u::@4/(word) rem16u#65 )
  (word) test_16u::res#3 ← phi( test_16u::@4/(word) test_16u::res#4 )
  (word) test_16u::divisor#1 ← phi( test_16u::@4/(word) test_16u::divisor#2 )
  (byte*) print_char_cursor#103 ← phi( test_16u::@4/(byte*) print_char_cursor#2 )
  (byte*) print_char_cursor#39 ← (byte*) print_char_cursor#103
  (word) print_word::w#2 ← (word) test_16u::divisor#1
  call print_word 
  to:test_16u::@6
test_16u::@6: scope:[test_16u]  from test_16u::@5
  (byte) test_16u::i#8 ← phi( test_16u::@5/(byte) test_16u::i#9 )
  (byte*) print_line_cursor#63 ← phi( test_16u::@5/(byte*) print_line_cursor#67 )
  (word) rem16u#58 ← phi( test_16u::@5/(word) rem16u#62 )
  (word) test_16u::res#2 ← phi( test_16u::@5/(word) test_16u::res#3 )
  (byte*) print_char_cursor#104 ← phi( test_16u::@5/(byte*) print_char_cursor#15 )
  (byte*) print_char_cursor#40 ← (byte*) print_char_cursor#104
  (byte*) print_str::str#5 ← (const string) test_16u::str1
  call print_str 
  to:test_16u::@7
test_16u::@7: scope:[test_16u]  from test_16u::@6
  (byte) test_16u::i#7 ← phi( test_16u::@6/(byte) test_16u::i#8 )
  (byte*) print_line_cursor#58 ← phi( test_16u::@6/(byte*) print_line_cursor#63 )
  (word) rem16u#50 ← phi( test_16u::@6/(word) rem16u#58 )
  (word) test_16u::res#1 ← phi( test_16u::@6/(word) test_16u::res#2 )
  (byte*) print_char_cursor#105 ← phi( test_16u::@6/(byte*) print_char_cursor#2 )
  (byte*) print_char_cursor#41 ← (byte*) print_char_cursor#105
  (word) print_word::w#3 ← (word) test_16u::res#1
  call print_word 
  to:test_16u::@8
test_16u::@8: scope:[test_16u]  from test_16u::@7
  (byte) test_16u::i#6 ← phi( test_16u::@7/(byte) test_16u::i#7 )
  (byte*) print_line_cursor#53 ← phi( test_16u::@7/(byte*) print_line_cursor#58 )
  (word) rem16u#41 ← phi( test_16u::@7/(word) rem16u#50 )
  (byte*) print_char_cursor#106 ← phi( test_16u::@7/(byte*) print_char_cursor#15 )
  (byte*) print_char_cursor#42 ← (byte*) print_char_cursor#106
  (byte*) print_str::str#6 ← (const string) test_16u::str2
  call print_str 
  to:test_16u::@9
test_16u::@9: scope:[test_16u]  from test_16u::@8
  (byte) test_16u::i#5 ← phi( test_16u::@8/(byte) test_16u::i#6 )
  (byte*) print_line_cursor#47 ← phi( test_16u::@8/(byte*) print_line_cursor#53 )
  (word) rem16u#30 ← phi( test_16u::@8/(word) rem16u#41 )
  (byte*) print_char_cursor#107 ← phi( test_16u::@8/(byte*) print_char_cursor#2 )
  (byte*) print_char_cursor#43 ← (byte*) print_char_cursor#107
  (word) print_word::w#4 ← (word) rem16u#30
  call print_word 
  to:test_16u::@10
test_16u::@10: scope:[test_16u]  from test_16u::@9
  (word) rem16u#51 ← phi( test_16u::@9/(word) rem16u#30 )
  (byte) test_16u::i#4 ← phi( test_16u::@9/(byte) test_16u::i#5 )
  (byte*) print_line_cursor#42 ← phi( test_16u::@9/(byte*) print_line_cursor#47 )
  (byte*) print_char_cursor#108 ← phi( test_16u::@9/(byte*) print_char_cursor#15 )
  (byte*) print_char_cursor#44 ← (byte*) print_char_cursor#108
  call print_ln 
  to:test_16u::@11
test_16u::@11: scope:[test_16u]  from test_16u::@10
  (word) rem16u#42 ← phi( test_16u::@10/(word) rem16u#51 )
  (byte) test_16u::i#3 ← phi( test_16u::@10/(byte) test_16u::i#4 )
  (byte*) print_char_cursor#109 ← phi( test_16u::@10/(byte*) print_char_cursor#4 )
  (byte*) print_line_cursor#32 ← phi( test_16u::@10/(byte*) print_line_cursor#2 )
  (byte*) print_line_cursor#13 ← (byte*) print_line_cursor#32
  (byte*) print_char_cursor#45 ← (byte*) print_char_cursor#109
  (byte) test_16u::i#1 ← (byte) test_16u::i#3 + rangenext(0,5)
  (bool~) test_16u::$9 ← (byte) test_16u::i#1 != rangelast(0,5)
  if((bool~) test_16u::$9) goto test_16u::@1
  to:test_16u::@return
test_16u::@return: scope:[test_16u]  from test_16u::@11
  (byte*) print_line_cursor#33 ← phi( test_16u::@11/(byte*) print_line_cursor#13 )
  (byte*) print_char_cursor#110 ← phi( test_16u::@11/(byte*) print_char_cursor#45 )
  (word) rem16u#31 ← phi( test_16u::@11/(word) rem16u#42 )
  (word) rem16u#13 ← (word) rem16u#31
  (byte*) print_char_cursor#46 ← (byte*) print_char_cursor#110
  (byte*) print_line_cursor#14 ← (byte*) print_line_cursor#33
  return 
  to:@return

(void()) test_8s()
test_8s: scope:[test_8s]  from main::@3
  (byte*) print_line_cursor#84 ← phi( main::@3/(byte*) print_line_cursor#7 )
  (byte*) print_char_cursor#157 ← phi( main::@3/(byte*) print_char_cursor#25 )
  (signed byte) rem8s#23 ← phi( main::@3/(signed byte) rem8s#16 )
  (byte) rem8u#48 ← phi( main::@3/(byte) rem8u#34 )
  (byte) test_8s::i#0 ← (byte) 0
  to:test_8s::@1
test_8s::@1: scope:[test_8s]  from test_8s test_8s::@11
  (byte*) print_line_cursor#80 ← phi( test_8s/(byte*) print_line_cursor#84 test_8s::@11/(byte*) print_line_cursor#15 )
  (byte*) print_char_cursor#151 ← phi( test_8s/(byte*) print_char_cursor#157 test_8s::@11/(byte*) print_char_cursor#54 )
  (signed byte) rem8s#18 ← phi( test_8s/(signed byte) rem8s#23 test_8s::@11/(signed byte) rem8s#20 )
  (byte) rem8u#39 ← phi( test_8s/(byte) rem8u#48 test_8s::@11/(byte) rem8u#40 )
  (byte) test_8s::i#2 ← phi( test_8s/(byte) test_8s::i#0 test_8s::@11/(byte) test_8s::i#1 )
  (signed byte) test_8s::dividend#0 ← *((const signed byte*) test_8s::dividends + (byte) test_8s::i#2)
  (signed byte) test_8s::divisor#0 ← *((const signed byte*) test_8s::divisors + (byte) test_8s::i#2)
  (signed byte) div8s::dividend#0 ← (signed byte) test_8s::dividend#0
  (signed byte) div8s::divisor#0 ← (signed byte) test_8s::divisor#0
  call div8s 
  (signed byte) div8s::return#3 ← (signed byte) div8s::return#2
  to:test_8s::@3
test_8s::@3: scope:[test_8s]  from test_8s::@1
  (byte) test_8s::i#11 ← phi( test_8s::@1/(byte) test_8s::i#2 )
  (byte*) print_line_cursor#76 ← phi( test_8s::@1/(byte*) print_line_cursor#80 )
  (signed byte) test_8s::divisor#3 ← phi( test_8s::@1/(signed byte) test_8s::divisor#0 )
  (byte*) print_char_cursor#143 ← phi( test_8s::@1/(byte*) print_char_cursor#151 )
  (signed byte) test_8s::dividend#1 ← phi( test_8s::@1/(signed byte) test_8s::dividend#0 )
  (signed byte) rem8s#12 ← phi( test_8s::@1/(signed byte) rem8s#3 )
  (byte) rem8u#28 ← phi( test_8s::@1/(byte) rem8u#6 )
  (signed byte) div8s::return#5 ← phi( test_8s::@1/(signed byte) div8s::return#3 )
  (signed byte~) test_8s::$0 ← (signed byte) div8s::return#5
  (byte) rem8u#12 ← (byte) rem8u#28
  (signed byte) rem8s#6 ← (signed byte) rem8s#12
  (signed byte) test_8s::res#0 ← (signed byte~) test_8s::$0
  (signed byte) print_sbyte::b#1 ← (signed byte) test_8s::dividend#1
  call print_sbyte 
  to:test_8s::@4
test_8s::@4: scope:[test_8s]  from test_8s::@3
  (byte) rem8u#65 ← phi( test_8s::@3/(byte) rem8u#12 )
  (byte) test_8s::i#10 ← phi( test_8s::@3/(byte) test_8s::i#11 )
  (byte*) print_line_cursor#72 ← phi( test_8s::@3/(byte*) print_line_cursor#76 )
  (signed byte) rem8s#31 ← phi( test_8s::@3/(signed byte) rem8s#6 )
  (signed byte) test_8s::res#4 ← phi( test_8s::@3/(signed byte) test_8s::res#0 )
  (signed byte) test_8s::divisor#2 ← phi( test_8s::@3/(signed byte) test_8s::divisor#3 )
  (byte*) print_char_cursor#111 ← phi( test_8s::@3/(byte*) print_char_cursor#12 )
  (byte*) print_char_cursor#47 ← (byte*) print_char_cursor#111
  (byte*) print_str::str#7 ← (const string) test_8s::str
  call print_str 
  to:test_8s::@5
test_8s::@5: scope:[test_8s]  from test_8s::@4
  (byte) rem8u#64 ← phi( test_8s::@4/(byte) rem8u#65 )
  (byte) test_8s::i#9 ← phi( test_8s::@4/(byte) test_8s::i#10 )
  (byte*) print_line_cursor#68 ← phi( test_8s::@4/(byte*) print_line_cursor#72 )
  (signed byte) rem8s#30 ← phi( test_8s::@4/(signed byte) rem8s#31 )
  (signed byte) test_8s::res#3 ← phi( test_8s::@4/(signed byte) test_8s::res#4 )
  (signed byte) test_8s::divisor#1 ← phi( test_8s::@4/(signed byte) test_8s::divisor#2 )
  (byte*) print_char_cursor#112 ← phi( test_8s::@4/(byte*) print_char_cursor#2 )
  (byte*) print_char_cursor#48 ← (byte*) print_char_cursor#112
  (signed byte) print_sbyte::b#2 ← (signed byte) test_8s::divisor#1
  call print_sbyte 
  to:test_8s::@6
test_8s::@6: scope:[test_8s]  from test_8s::@5
  (byte) rem8u#63 ← phi( test_8s::@5/(byte) rem8u#64 )
  (byte) test_8s::i#8 ← phi( test_8s::@5/(byte) test_8s::i#9 )
  (byte*) print_line_cursor#64 ← phi( test_8s::@5/(byte*) print_line_cursor#68 )
  (signed byte) rem8s#28 ← phi( test_8s::@5/(signed byte) rem8s#30 )
  (signed byte) test_8s::res#2 ← phi( test_8s::@5/(signed byte) test_8s::res#3 )
  (byte*) print_char_cursor#113 ← phi( test_8s::@5/(byte*) print_char_cursor#12 )
  (byte*) print_char_cursor#49 ← (byte*) print_char_cursor#113
  (byte*) print_str::str#8 ← (const string) test_8s::str1
  call print_str 
  to:test_8s::@7
test_8s::@7: scope:[test_8s]  from test_8s::@6
  (byte) rem8u#62 ← phi( test_8s::@6/(byte) rem8u#63 )
  (byte) test_8s::i#7 ← phi( test_8s::@6/(byte) test_8s::i#8 )
  (byte*) print_line_cursor#59 ← phi( test_8s::@6/(byte*) print_line_cursor#64 )
  (signed byte) rem8s#24 ← phi( test_8s::@6/(signed byte) rem8s#28 )
  (signed byte) test_8s::res#1 ← phi( test_8s::@6/(signed byte) test_8s::res#2 )
  (byte*) print_char_cursor#114 ← phi( test_8s::@6/(byte*) print_char_cursor#2 )
  (byte*) print_char_cursor#50 ← (byte*) print_char_cursor#114
  (signed byte) print_sbyte::b#3 ← (signed byte) test_8s::res#1
  call print_sbyte 
  to:test_8s::@8
test_8s::@8: scope:[test_8s]  from test_8s::@7
  (byte) rem8u#59 ← phi( test_8s::@7/(byte) rem8u#62 )
  (byte) test_8s::i#6 ← phi( test_8s::@7/(byte) test_8s::i#7 )
  (byte*) print_line_cursor#54 ← phi( test_8s::@7/(byte*) print_line_cursor#59 )
  (signed byte) rem8s#19 ← phi( test_8s::@7/(signed byte) rem8s#24 )
  (byte*) print_char_cursor#115 ← phi( test_8s::@7/(byte*) print_char_cursor#12 )
  (byte*) print_char_cursor#51 ← (byte*) print_char_cursor#115
  (byte*) print_str::str#9 ← (const string) test_8s::str2
  call print_str 
  to:test_8s::@9
test_8s::@9: scope:[test_8s]  from test_8s::@8
  (byte) rem8u#54 ← phi( test_8s::@8/(byte) rem8u#59 )
  (byte) test_8s::i#5 ← phi( test_8s::@8/(byte) test_8s::i#6 )
  (byte*) print_line_cursor#48 ← phi( test_8s::@8/(byte*) print_line_cursor#54 )
  (signed byte) rem8s#13 ← phi( test_8s::@8/(signed byte) rem8s#19 )
  (byte*) print_char_cursor#116 ← phi( test_8s::@8/(byte*) print_char_cursor#2 )
  (byte*) print_char_cursor#52 ← (byte*) print_char_cursor#116
  (signed byte) print_sbyte::b#4 ← (signed byte) rem8s#13
  call print_sbyte 
  to:test_8s::@10
test_8s::@10: scope:[test_8s]  from test_8s::@9
  (signed byte) rem8s#25 ← phi( test_8s::@9/(signed byte) rem8s#13 )
  (byte) rem8u#49 ← phi( test_8s::@9/(byte) rem8u#54 )
  (byte) test_8s::i#4 ← phi( test_8s::@9/(byte) test_8s::i#5 )
  (byte*) print_line_cursor#43 ← phi( test_8s::@9/(byte*) print_line_cursor#48 )
  (byte*) print_char_cursor#117 ← phi( test_8s::@9/(byte*) print_char_cursor#12 )
  (byte*) print_char_cursor#53 ← (byte*) print_char_cursor#117
  call print_ln 
  to:test_8s::@11
test_8s::@11: scope:[test_8s]  from test_8s::@10
  (signed byte) rem8s#20 ← phi( test_8s::@10/(signed byte) rem8s#25 )
  (byte) rem8u#40 ← phi( test_8s::@10/(byte) rem8u#49 )
  (byte) test_8s::i#3 ← phi( test_8s::@10/(byte) test_8s::i#4 )
  (byte*) print_char_cursor#118 ← phi( test_8s::@10/(byte*) print_char_cursor#4 )
  (byte*) print_line_cursor#34 ← phi( test_8s::@10/(byte*) print_line_cursor#2 )
  (byte*) print_line_cursor#15 ← (byte*) print_line_cursor#34
  (byte*) print_char_cursor#54 ← (byte*) print_char_cursor#118
  (byte) test_8s::i#1 ← (byte) test_8s::i#3 + rangenext(0,5)
  (bool~) test_8s::$9 ← (byte) test_8s::i#1 != rangelast(0,5)
  if((bool~) test_8s::$9) goto test_8s::@1
  to:test_8s::@return
test_8s::@return: scope:[test_8s]  from test_8s::@11
  (byte*) print_line_cursor#35 ← phi( test_8s::@11/(byte*) print_line_cursor#15 )
  (byte*) print_char_cursor#119 ← phi( test_8s::@11/(byte*) print_char_cursor#54 )
  (signed byte) rem8s#14 ← phi( test_8s::@11/(signed byte) rem8s#20 )
  (byte) rem8u#29 ← phi( test_8s::@11/(byte) rem8u#40 )
  (byte) rem8u#13 ← (byte) rem8u#29
  (signed byte) rem8s#7 ← (signed byte) rem8s#14
  (byte*) print_char_cursor#55 ← (byte*) print_char_cursor#119
  (byte*) print_line_cursor#16 ← (byte*) print_line_cursor#35
  return 
  to:@return

(void()) test_16s()
test_16s: scope:[test_16s]  from main::@4
  (byte*) print_line_cursor#85 ← phi( main::@4/(byte*) print_line_cursor#8 )
  (byte*) print_char_cursor#158 ← phi( main::@4/(byte*) print_char_cursor#26 )
  (signed word) rem16s#27 ← phi( main::@4/(signed word) rem16s#21 )
  (word) rem16u#52 ← phi( main::@4/(word) rem16u#39 )
  (byte) test_16s::i#0 ← (byte) 0
  to:test_16s::@1
test_16s::@1: scope:[test_16s]  from test_16s test_16s::@11
  (byte*) print_line_cursor#81 ← phi( test_16s/(byte*) print_line_cursor#85 test_16s::@11/(byte*) print_line_cursor#17 )
  (byte*) print_char_cursor#152 ← phi( test_16s/(byte*) print_char_cursor#158 test_16s::@11/(byte*) print_char_cursor#63 )
  (signed word) rem16s#22 ← phi( test_16s/(signed word) rem16s#27 test_16s::@11/(signed word) rem16s#24 )
  (word) rem16u#43 ← phi( test_16s/(word) rem16u#52 test_16s::@11/(word) rem16u#44 )
  (byte) test_16s::i#2 ← phi( test_16s/(byte) test_16s::i#0 test_16s::@11/(byte) test_16s::i#1 )
  (byte~) test_16s::$10 ← (byte) test_16s::i#2 * (const byte) SIZEOF_SIGNED_WORD
  (signed word) test_16s::dividend#0 ← *((const signed word*) test_16s::dividends + (byte~) test_16s::$10)
  (byte~) test_16s::$11 ← (byte) test_16s::i#2 * (const byte) SIZEOF_SIGNED_WORD
  (signed word) test_16s::divisor#0 ← *((const signed word*) test_16s::divisors + (byte~) test_16s::$11)
  (signed word) div16s::dividend#0 ← (signed word) test_16s::dividend#0
  (signed word) div16s::divisor#0 ← (signed word) test_16s::divisor#0
  call div16s 
  (signed word) div16s::return#2 ← (signed word) div16s::return#1
  to:test_16s::@3
test_16s::@3: scope:[test_16s]  from test_16s::@1
  (byte) test_16s::i#11 ← phi( test_16s::@1/(byte) test_16s::i#2 )
  (byte*) print_line_cursor#77 ← phi( test_16s::@1/(byte*) print_line_cursor#81 )
  (signed word) test_16s::divisor#3 ← phi( test_16s::@1/(signed word) test_16s::divisor#0 )
  (byte*) print_char_cursor#144 ← phi( test_16s::@1/(byte*) print_char_cursor#152 )
  (signed word) test_16s::dividend#1 ← phi( test_16s::@1/(signed word) test_16s::dividend#0 )
  (signed word) rem16s#16 ← phi( test_16s::@1/(signed word) rem16s#5 )
  (word) rem16u#32 ← phi( test_16s::@1/(word) rem16u#8 )
  (signed word) div16s::return#4 ← phi( test_16s::@1/(signed word) div16s::return#2 )
  (signed word~) test_16s::$0 ← (signed word) div16s::return#4
  (word) rem16u#14 ← (word) rem16u#32
  (signed word) rem16s#8 ← (signed word) rem16s#16
  (signed word) test_16s::res#0 ← (signed word~) test_16s::$0
  (signed word) print_sword::w#1 ← (signed word) test_16s::dividend#1
  call print_sword 
  to:test_16s::@4
test_16s::@4: scope:[test_16s]  from test_16s::@3
  (word) rem16u#69 ← phi( test_16s::@3/(word) rem16u#14 )
  (byte) test_16s::i#10 ← phi( test_16s::@3/(byte) test_16s::i#11 )
  (byte*) print_line_cursor#73 ← phi( test_16s::@3/(byte*) print_line_cursor#77 )
  (signed word) rem16s#35 ← phi( test_16s::@3/(signed word) rem16s#8 )
  (signed word) test_16s::res#4 ← phi( test_16s::@3/(signed word) test_16s::res#0 )
  (signed word) test_16s::divisor#2 ← phi( test_16s::@3/(signed word) test_16s::divisor#3 )
  (byte*) print_char_cursor#120 ← phi( test_16s::@3/(byte*) print_char_cursor#8 )
  (byte*) print_char_cursor#56 ← (byte*) print_char_cursor#120
  (byte*) print_str::str#10 ← (const string) test_16s::str
  call print_str 
  to:test_16s::@5
test_16s::@5: scope:[test_16s]  from test_16s::@4
  (word) rem16u#68 ← phi( test_16s::@4/(word) rem16u#69 )
  (byte) test_16s::i#9 ← phi( test_16s::@4/(byte) test_16s::i#10 )
  (byte*) print_line_cursor#69 ← phi( test_16s::@4/(byte*) print_line_cursor#73 )
  (signed word) rem16s#33 ← phi( test_16s::@4/(signed word) rem16s#35 )
  (signed word) test_16s::res#3 ← phi( test_16s::@4/(signed word) test_16s::res#4 )
  (signed word) test_16s::divisor#1 ← phi( test_16s::@4/(signed word) test_16s::divisor#2 )
  (byte*) print_char_cursor#121 ← phi( test_16s::@4/(byte*) print_char_cursor#2 )
  (byte*) print_char_cursor#57 ← (byte*) print_char_cursor#121
  (signed word) print_sword::w#2 ← (signed word) test_16s::divisor#1
  call print_sword 
  to:test_16s::@6
test_16s::@6: scope:[test_16s]  from test_16s::@5
  (word) rem16u#67 ← phi( test_16s::@5/(word) rem16u#68 )
  (byte) test_16s::i#8 ← phi( test_16s::@5/(byte) test_16s::i#9 )
  (byte*) print_line_cursor#65 ← phi( test_16s::@5/(byte*) print_line_cursor#69 )
  (signed word) rem16s#31 ← phi( test_16s::@5/(signed word) rem16s#33 )
  (signed word) test_16s::res#2 ← phi( test_16s::@5/(signed word) test_16s::res#3 )
  (byte*) print_char_cursor#122 ← phi( test_16s::@5/(byte*) print_char_cursor#8 )
  (byte*) print_char_cursor#58 ← (byte*) print_char_cursor#122
  (byte*) print_str::str#11 ← (const string) test_16s::str1
  call print_str 
  to:test_16s::@7
test_16s::@7: scope:[test_16s]  from test_16s::@6
  (word) rem16u#66 ← phi( test_16s::@6/(word) rem16u#67 )
  (byte) test_16s::i#7 ← phi( test_16s::@6/(byte) test_16s::i#8 )
  (byte*) print_line_cursor#60 ← phi( test_16s::@6/(byte*) print_line_cursor#65 )
  (signed word) rem16s#28 ← phi( test_16s::@6/(signed word) rem16s#31 )
  (signed word) test_16s::res#1 ← phi( test_16s::@6/(signed word) test_16s::res#2 )
  (byte*) print_char_cursor#123 ← phi( test_16s::@6/(byte*) print_char_cursor#2 )
  (byte*) print_char_cursor#59 ← (byte*) print_char_cursor#123
  (signed word) print_sword::w#3 ← (signed word) test_16s::res#1
  call print_sword 
  to:test_16s::@8
test_16s::@8: scope:[test_16s]  from test_16s::@7
  (word) rem16u#63 ← phi( test_16s::@7/(word) rem16u#66 )
  (byte) test_16s::i#6 ← phi( test_16s::@7/(byte) test_16s::i#7 )
  (byte*) print_line_cursor#55 ← phi( test_16s::@7/(byte*) print_line_cursor#60 )
  (signed word) rem16s#23 ← phi( test_16s::@7/(signed word) rem16s#28 )
  (byte*) print_char_cursor#124 ← phi( test_16s::@7/(byte*) print_char_cursor#8 )
  (byte*) print_char_cursor#60 ← (byte*) print_char_cursor#124
  (byte*) print_str::str#12 ← (const string) test_16s::str2
  call print_str 
  to:test_16s::@9
test_16s::@9: scope:[test_16s]  from test_16s::@8
  (word) rem16u#59 ← phi( test_16s::@8/(word) rem16u#63 )
  (byte) test_16s::i#5 ← phi( test_16s::@8/(byte) test_16s::i#6 )
  (byte*) print_line_cursor#49 ← phi( test_16s::@8/(byte*) print_line_cursor#55 )
  (signed word) rem16s#17 ← phi( test_16s::@8/(signed word) rem16s#23 )
  (byte*) print_char_cursor#125 ← phi( test_16s::@8/(byte*) print_char_cursor#2 )
  (byte*) print_char_cursor#61 ← (byte*) print_char_cursor#125
  (signed word) print_sword::w#4 ← (signed word) rem16s#17
  call print_sword 
  to:test_16s::@10
test_16s::@10: scope:[test_16s]  from test_16s::@9
  (signed word) rem16s#29 ← phi( test_16s::@9/(signed word) rem16s#17 )
  (word) rem16u#53 ← phi( test_16s::@9/(word) rem16u#59 )
  (byte) test_16s::i#4 ← phi( test_16s::@9/(byte) test_16s::i#5 )
  (byte*) print_line_cursor#44 ← phi( test_16s::@9/(byte*) print_line_cursor#49 )
  (byte*) print_char_cursor#126 ← phi( test_16s::@9/(byte*) print_char_cursor#8 )
  (byte*) print_char_cursor#62 ← (byte*) print_char_cursor#126
  call print_ln 
  to:test_16s::@11
test_16s::@11: scope:[test_16s]  from test_16s::@10
  (signed word) rem16s#24 ← phi( test_16s::@10/(signed word) rem16s#29 )
  (word) rem16u#44 ← phi( test_16s::@10/(word) rem16u#53 )
  (byte) test_16s::i#3 ← phi( test_16s::@10/(byte) test_16s::i#4 )
  (byte*) print_char_cursor#127 ← phi( test_16s::@10/(byte*) print_char_cursor#4 )
  (byte*) print_line_cursor#36 ← phi( test_16s::@10/(byte*) print_line_cursor#2 )
  (byte*) print_line_cursor#17 ← (byte*) print_line_cursor#36
  (byte*) print_char_cursor#63 ← (byte*) print_char_cursor#127
  (byte) test_16s::i#1 ← (byte) test_16s::i#3 + rangenext(0,5)
  (bool~) test_16s::$9 ← (byte) test_16s::i#1 != rangelast(0,5)
  if((bool~) test_16s::$9) goto test_16s::@1
  to:test_16s::@return
test_16s::@return: scope:[test_16s]  from test_16s::@11
  (byte*) print_line_cursor#37 ← phi( test_16s::@11/(byte*) print_line_cursor#17 )
  (byte*) print_char_cursor#128 ← phi( test_16s::@11/(byte*) print_char_cursor#63 )
  (signed word) rem16s#18 ← phi( test_16s::@11/(signed word) rem16s#24 )
  (word) rem16u#33 ← phi( test_16s::@11/(word) rem16u#44 )
  (word) rem16u#15 ← (word) rem16u#33
  (signed word) rem16s#9 ← (signed word) rem16s#18
  (byte*) print_char_cursor#64 ← (byte*) print_char_cursor#128
  (byte*) print_line_cursor#18 ← (byte*) print_line_cursor#37
  return 
  to:@return
@50: scope:[]  from @43
  (byte*) print_screen#4 ← phi( @43/(byte*) print_screen#5 )
  (signed word) rem16s#25 ← phi( @43/(signed word) rem16s#0 )
  (signed byte) rem8s#21 ← phi( @43/(signed byte) rem8s#26 )
  (word) rem16u#45 ← phi( @43/(word) rem16u#54 )
  (byte) rem8u#41 ← phi( @43/(byte) rem8u#50 )
  (byte*) print_char_cursor#145 ← phi( @43/(byte*) print_char_cursor#153 )
  (byte*) print_line_cursor#45 ← phi( @43/(byte*) print_line_cursor#50 )
  call main 
  to:@51
@51: scope:[]  from @50
  (signed word) rem16s#19 ← phi( @50/(signed word) rem16s#7 )
  (signed byte) rem8s#15 ← phi( @50/(signed byte) rem8s#5 )
  (word) rem16u#34 ← phi( @50/(word) rem16u#11 )
  (byte) rem8u#30 ← phi( @50/(byte) rem8u#9 )
  (byte*) print_char_cursor#129 ← phi( @50/(byte*) print_char_cursor#28 )
  (byte*) print_line_cursor#38 ← phi( @50/(byte*) print_line_cursor#10 )
  (byte*) print_line_cursor#19 ← (byte*) print_line_cursor#38
  (byte*) print_char_cursor#65 ← (byte*) print_char_cursor#129
  (byte) rem8u#14 ← (byte) rem8u#30
  (word) rem16u#16 ← (word) rem16u#34
  (signed byte) rem8s#8 ← (signed byte) rem8s#15
  (signed word) rem16s#10 ← (signed word) rem16s#19
  to:@end
@end: scope:[]  from @51

SYMBOL TABLE SSA
(label) @13
(label) @37
(label) @39
(label) @42
(label) @43
(label) @50
(label) @51
(label) @begin
(label) @end
(const byte) RADIX::BINARY = (number) 2
(const byte) RADIX::DECIMAL = (number) $a
(const byte) RADIX::HEXADECIMAL = (number) $10
(const byte) RADIX::OCTAL = (number) 8
(const byte) SIZEOF_SIGNED_WORD = (byte) 2
(const byte) SIZEOF_WORD = (byte) 2
(signed word()) div16s((signed word) div16s::dividend , (signed word) div16s::divisor)
(signed word~) div16s::$0
(label) div16s::@2
(label) div16s::@return
(signed word) div16s::dividend
(signed word) div16s::dividend#0
(signed word) div16s::dividend#1
(signed word) div16s::divisor
(signed word) div16s::divisor#0
(signed word) div16s::divisor#1
(signed word) div16s::return
(signed word) div16s::return#0
(signed word) div16s::return#1
(signed word) div16s::return#2
(signed word) div16s::return#3
(signed word) div16s::return#4
(word()) div16u((word) div16u::dividend , (word) div16u::divisor)
(word~) div16u::$0
(label) div16u::@2
(label) div16u::@return
(word) div16u::dividend
(word) div16u::dividend#0
(word) div16u::dividend#1
(word) div16u::divisor
(word) div16u::divisor#0
(word) div16u::divisor#1
(word) div16u::return
(word) div16u::return#0
(word) div16u::return#1
(word) div16u::return#2
(word) div16u::return#3
(word) div16u::return#4
(signed byte()) div8s((signed byte) div8s::dividend , (signed byte) div8s::divisor)
(bool~) div8s::$0
(bool~) div8s::$1
(number~) div8s::$10
(signed byte~) div8s::$11
(signed byte~) div8s::$12
(signed byte~) div8s::$13
(signed byte~) div8s::$14
(signed byte~) div8s::$15
(signed byte~) div8s::$16
(byte~) div8s::$2
(bool~) div8s::$3
(byte~) div8s::$4
(signed byte~) div8s::$5
(byte~) div8s::$6
(byte~) div8s::$7
(signed byte~) div8s::$8
(byte~) div8s::$9
(label) div8s::@1
(label) div8s::@11
(label) div8s::@15
(label) div8s::@2
(label) div8s::@3
(label) div8s::@4
(label) div8s::@5
(label) div8s::@7
(label) div8s::@9
(label) div8s::@return
(signed byte) div8s::dividend
(signed byte) div8s::dividend#0
(signed byte) div8s::dividend#1
(signed byte) div8s::dividend#2
(signed byte) div8s::dividend#3
(byte) div8s::dividendu
(byte) div8s::dividendu#0
(byte) div8s::dividendu#1
(byte) div8s::dividendu#2
(byte) div8s::dividendu#3
(byte) div8s::dividendu#4
(byte) div8s::dividendu#5
(byte) div8s::dividendu#6
(signed byte) div8s::divisor
(signed byte) div8s::divisor#0
(signed byte) div8s::divisor#1
(signed byte) div8s::divisor#2
(signed byte) div8s::divisor#3
(signed byte) div8s::divisor#4
(signed byte) div8s::divisor#5
(signed byte) div8s::divisor#6
(byte) div8s::divisoru
(byte) div8s::divisoru#0
(byte) div8s::divisoru#1
(byte) div8s::divisoru#2
(byte) div8s::divisoru#3
(byte) div8s::neg
(byte) div8s::neg#0
(byte) div8s::neg#1
(byte) div8s::neg#2
(byte) div8s::neg#3
(byte) div8s::neg#4
(byte) div8s::neg#5
(byte) div8s::neg#6
(byte) div8s::neg#7
(byte) div8s::neg#8
(byte) div8s::resultu
(byte) div8s::resultu#0
(byte) div8s::resultu#1
(byte) div8s::resultu#2
(signed byte) div8s::return
(signed byte) div8s::return#0
(signed byte) div8s::return#1
(signed byte) div8s::return#2
(signed byte) div8s::return#3
(signed byte) div8s::return#4
(signed byte) div8s::return#5
(byte()) div8u((byte) div8u::dividend , (byte) div8u::divisor)
(byte~) div8u::$0
(label) div8u::@2
(label) div8u::@return
(byte) div8u::dividend
(byte) div8u::dividend#0
(byte) div8u::dividend#1
(byte) div8u::dividend#2
(byte) div8u::divisor
(byte) div8u::divisor#0
(byte) div8u::divisor#1
(byte) div8u::divisor#2
(byte) div8u::return
(byte) div8u::return#0
(byte) div8u::return#1
(byte) div8u::return#2
(byte) div8u::return#3
(byte) div8u::return#4
(byte) div8u::return#5
(byte) div8u::return#6
(signed word()) divr16s((signed word) divr16s::dividend , (signed word) divr16s::divisor , (signed word) divr16s::rem)
(bool~) divr16s::$0
(bool~) divr16s::$1
(signed word~) divr16s::$10
(word~) divr16s::$11
(word~) divr16s::$12
(signed word~) divr16s::$13
(word~) divr16s::$14
(number~) divr16s::$15
(signed word~) divr16s::$16
(signed word~) divr16s::$17
(signed word~) divr16s::$18
(signed word~) divr16s::$19
(bool~) divr16s::$2
(signed word~) divr16s::$20
(signed word~) divr16s::$21
(bool~) divr16s::$3
(word~) divr16s::$4
(bool~) divr16s::$5
(word~) divr16s::$6
(word~) divr16s::$7
(signed word~) divr16s::$8
(word~) divr16s::$9
(label) divr16s::@1
(label) divr16s::@11
(label) divr16s::@15
(label) divr16s::@2
(label) divr16s::@3
(label) divr16s::@4
(label) divr16s::@5
(label) divr16s::@7
(label) divr16s::@9
(label) divr16s::@return
(signed word) divr16s::dividend
(signed word) divr16s::dividend#0
(signed word) divr16s::dividend#1
(signed word) divr16s::dividend#2
(signed word) divr16s::dividend#3
(word) divr16s::dividendu
(word) divr16s::dividendu#0
(word) divr16s::dividendu#1
(word) divr16s::dividendu#2
(word) divr16s::dividendu#3
(word) divr16s::dividendu#4
(word) divr16s::dividendu#5
(word) divr16s::dividendu#6
(signed word) divr16s::divisor
(signed word) divr16s::divisor#0
(signed word) divr16s::divisor#1
(signed word) divr16s::divisor#2
(signed word) divr16s::divisor#3
(signed word) divr16s::divisor#4
(signed word) divr16s::divisor#5
(signed word) divr16s::divisor#6
(word) divr16s::divisoru
(word) divr16s::divisoru#0
(word) divr16s::divisoru#1
(word) divr16s::divisoru#2
(word) divr16s::divisoru#3
(byte) divr16s::neg
(byte) divr16s::neg#0
(byte) divr16s::neg#1
(byte) divr16s::neg#2
(byte) divr16s::neg#3
(byte) divr16s::neg#4
(byte) divr16s::neg#5
(byte) divr16s::neg#6
(byte) divr16s::neg#7
(byte) divr16s::neg#8
(signed word) divr16s::rem
(signed word) divr16s::rem#0
(signed word) divr16s::rem#1
(signed word) divr16s::rem#2
(signed word) divr16s::rem#3
(word) divr16s::remu
(word) divr16s::remu#0
(word) divr16s::remu#1
(word) divr16s::remu#2
(word) divr16s::remu#3
(word) divr16s::remu#4
(word) divr16s::remu#5
(word) divr16s::remu#6
(word) divr16s::resultu
(word) divr16s::resultu#0
(word) divr16s::resultu#1
(word) divr16s::resultu#2
(signed word) divr16s::return
(signed word) divr16s::return#0
(signed word) divr16s::return#1
(signed word) divr16s::return#2
(signed word) divr16s::return#3
(signed word) divr16s::return#4
(signed word) divr16s::return#5
(word()) divr16u((word) divr16u::dividend , (word) divr16u::divisor , (word) divr16u::rem)
(word~) divr16u::$0
(byte~) divr16u::$1
(word~) divr16u::$10
(bool~) divr16u::$11
(number~) divr16u::$2
(bool~) divr16u::$3
(bool~) divr16u::$4
(number~) divr16u::$5
(word~) divr16u::$6
(word~) divr16u::$7
(bool~) divr16u::$8
(bool~) divr16u::$9
(label) divr16u::@1
(label) divr16u::@2
(label) divr16u::@3
(label) divr16u::@4
(label) divr16u::@5
(label) divr16u::@6
(label) divr16u::@return
(word) divr16u::dividend
(word) divr16u::dividend#0
(word) divr16u::dividend#1
(word) divr16u::dividend#2
(word) divr16u::dividend#3
(word) divr16u::dividend#4
(word) divr16u::dividend#5
(word) divr16u::dividend#6
(word) divr16u::dividend#7
(word) divr16u::dividend#8
(word) divr16u::divisor
(word) divr16u::divisor#0
(word) divr16u::divisor#1
(word) divr16u::divisor#2
(word) divr16u::divisor#3
(word) divr16u::divisor#4
(word) divr16u::divisor#5
(word) divr16u::divisor#6
(word) divr16u::divisor#7
(byte) divr16u::i
(byte) divr16u::i#0
(byte) divr16u::i#1
(byte) divr16u::i#2
(byte) divr16u::i#3
(byte) divr16u::i#4
(byte) divr16u::i#5
(byte) divr16u::i#6
(word) divr16u::quotient
(word) divr16u::quotient#0
(word) divr16u::quotient#1
(word) divr16u::quotient#2
(word) divr16u::quotient#3
(word) divr16u::quotient#4
(word) divr16u::quotient#5
(word) divr16u::quotient#6
(word) divr16u::quotient#7
(word) divr16u::quotient#8
(word) divr16u::rem
(word) divr16u::rem#0
(word) divr16u::rem#1
(word) divr16u::rem#10
(word) divr16u::rem#11
(word) divr16u::rem#2
(word) divr16u::rem#3
(word) divr16u::rem#4
(word) divr16u::rem#5
(word) divr16u::rem#6
(word) divr16u::rem#7
(word) divr16u::rem#8
(word) divr16u::rem#9
(word) divr16u::return
(word) divr16u::return#0
(word) divr16u::return#1
(word) divr16u::return#2
(word) divr16u::return#3
(word) divr16u::return#4
(word) divr16u::return#5
(word) divr16u::return#6
(byte()) divr8u((byte) divr8u::dividend , (byte) divr8u::divisor , (byte) divr8u::rem)
(byte~) divr8u::$0
(number~) divr8u::$1
(bool~) divr8u::$10
(bool~) divr8u::$2
(bool~) divr8u::$3
(number~) divr8u::$4
(byte~) divr8u::$5
(byte~) divr8u::$6
(bool~) divr8u::$7
(bool~) divr8u::$8
(byte~) divr8u::$9
(label) divr8u::@1
(label) divr8u::@2
(label) divr8u::@3
(label) divr8u::@4
(label) divr8u::@5
(label) divr8u::@6
(label) divr8u::@return
(byte) divr8u::dividend
(byte) divr8u::dividend#0
(byte) divr8u::dividend#1
(byte) divr8u::dividend#2
(byte) divr8u::dividend#3
(byte) divr8u::dividend#4
(byte) divr8u::dividend#5
(byte) divr8u::dividend#6
(byte) divr8u::dividend#7
(byte) divr8u::divisor
(byte) divr8u::divisor#0
(byte) divr8u::divisor#1
(byte) divr8u::divisor#2
(byte) divr8u::divisor#3
(byte) divr8u::divisor#4
(byte) divr8u::divisor#5
(byte) divr8u::divisor#6
(byte) divr8u::i
(byte) divr8u::i#0
(byte) divr8u::i#1
(byte) divr8u::i#2
(byte) divr8u::i#3
(byte) divr8u::i#4
(byte) divr8u::i#5
(byte) divr8u::i#6
(byte) divr8u::quotient
(byte) divr8u::quotient#0
(byte) divr8u::quotient#1
(byte) divr8u::quotient#2
(byte) divr8u::quotient#3
(byte) divr8u::quotient#4
(byte) divr8u::quotient#5
(byte) divr8u::quotient#6
(byte) divr8u::quotient#7
(byte) divr8u::quotient#8
(byte) divr8u::rem
(byte) divr8u::rem#0
(byte) divr8u::rem#1
(byte) divr8u::rem#10
(byte) divr8u::rem#2
(byte) divr8u::rem#3
(byte) divr8u::rem#4
(byte) divr8u::rem#5
(byte) divr8u::rem#6
(byte) divr8u::rem#7
(byte) divr8u::rem#8
(byte) divr8u::rem#9
(byte) divr8u::return
(byte) divr8u::return#0
(byte) divr8u::return#1
(byte) divr8u::return#2
(byte) divr8u::return#3
(byte) divr8u::return#4
(void()) main()
(label) main::@1
(label) main::@2
(label) main::@3
(label) main::@4
(label) main::@5
(label) main::@return
(void*()) memset((void*) memset::str , (byte) memset::c , (word) memset::num)
(bool~) memset::$0
(bool~) memset::$1
(byte*~) memset::$2
(byte*~) memset::$3
(bool~) memset::$4
(label) memset::@1
(label) memset::@2
(label) memset::@4
(label) memset::@5
(label) memset::@return
(byte) memset::c
(byte) memset::c#0
(byte) memset::c#1
(byte) memset::c#2
(byte) memset::c#3
(byte) memset::c#4
(byte*) memset::dst
(byte*) memset::dst#0
(byte*) memset::dst#1
(byte*) memset::dst#2
(byte*) memset::dst#3
(byte*) memset::end
(byte*) memset::end#0
(byte*) memset::end#1
(byte*) memset::end#2
(word) memset::num
(word) memset::num#0
(word) memset::num#1
(word) memset::num#2
(void*) memset::return
(void*) memset::return#0
(void*) memset::return#1
(void*) memset::return#2
(void*) memset::return#3
(void*) memset::str
(void*) memset::str#0
(void*) memset::str#1
(void*) memset::str#2
(void*) memset::str#3
(void*) memset::str#4
(void*) memset::str#5
(void()) print_byte((byte) print_byte::b)
(byte~) print_byte::$0
(number~) print_byte::$2
(label) print_byte::@1
(label) print_byte::@2
(label) print_byte::@return
(byte) print_byte::b
(byte) print_byte::b#0
(byte) print_byte::b#1
(byte) print_byte::b#2
(byte) print_byte::b#3
(byte) print_byte::b#4
(byte) print_byte::b#5
(byte) print_byte::b#6
(byte) print_byte::b#7
(byte) print_byte::b#8
(void()) print_char((byte) print_char::ch)
(label) print_char::@return
(byte) print_char::ch
(byte) print_char::ch#0
(byte) print_char::ch#1
(byte) print_char::ch#2
(byte) print_char::ch#3
(byte) print_char::ch#4
(byte) print_char::ch#5
(byte) print_char::ch#6
(byte*) print_char_cursor
(byte*) print_char_cursor#0
(byte*) print_char_cursor#1
(byte*) print_char_cursor#10
(byte*) print_char_cursor#100
(byte*) print_char_cursor#101
(byte*) print_char_cursor#102
(byte*) print_char_cursor#103
(byte*) print_char_cursor#104
(byte*) print_char_cursor#105
(byte*) print_char_cursor#106
(byte*) print_char_cursor#107
(byte*) print_char_cursor#108
(byte*) print_char_cursor#109
(byte*) print_char_cursor#11
(byte*) print_char_cursor#110
(byte*) print_char_cursor#111
(byte*) print_char_cursor#112
(byte*) print_char_cursor#113
(byte*) print_char_cursor#114
(byte*) print_char_cursor#115
(byte*) print_char_cursor#116
(byte*) print_char_cursor#117
(byte*) print_char_cursor#118
(byte*) print_char_cursor#119
(byte*) print_char_cursor#12
(byte*) print_char_cursor#120
(byte*) print_char_cursor#121
(byte*) print_char_cursor#122
(byte*) print_char_cursor#123
(byte*) print_char_cursor#124
(byte*) print_char_cursor#125
(byte*) print_char_cursor#126
(byte*) print_char_cursor#127
(byte*) print_char_cursor#128
(byte*) print_char_cursor#129
(byte*) print_char_cursor#13
(byte*) print_char_cursor#130
(byte*) print_char_cursor#131
(byte*) print_char_cursor#132
(byte*) print_char_cursor#133
(byte*) print_char_cursor#134
(byte*) print_char_cursor#135
(byte*) print_char_cursor#136
(byte*) print_char_cursor#137
(byte*) print_char_cursor#138
(byte*) print_char_cursor#139
(byte*) print_char_cursor#14
(byte*) print_char_cursor#140
(byte*) print_char_cursor#141
(byte*) print_char_cursor#142
(byte*) print_char_cursor#143
(byte*) print_char_cursor#144
(byte*) print_char_cursor#145
(byte*) print_char_cursor#146
(byte*) print_char_cursor#147
(byte*) print_char_cursor#148
(byte*) print_char_cursor#149
(byte*) print_char_cursor#15
(byte*) print_char_cursor#150
(byte*) print_char_cursor#151
(byte*) print_char_cursor#152
(byte*) print_char_cursor#153
(byte*) print_char_cursor#154
(byte*) print_char_cursor#155
(byte*) print_char_cursor#156
(byte*) print_char_cursor#157
(byte*) print_char_cursor#158
(byte*) print_char_cursor#159
(byte*) print_char_cursor#16
(byte*) print_char_cursor#160
(byte*) print_char_cursor#17
(byte*) print_char_cursor#18
(byte*) print_char_cursor#19
(byte*) print_char_cursor#2
(byte*) print_char_cursor#20
(byte*) print_char_cursor#21
(byte*) print_char_cursor#22
(byte*) print_char_cursor#23
(byte*) print_char_cursor#24
(byte*) print_char_cursor#25
(byte*) print_char_cursor#26
(byte*) print_char_cursor#27
(byte*) print_char_cursor#28
(byte*) print_char_cursor#29
(byte*) print_char_cursor#3
(byte*) print_char_cursor#30
(byte*) print_char_cursor#31
(byte*) print_char_cursor#32
(byte*) print_char_cursor#33
(byte*) print_char_cursor#34
(byte*) print_char_cursor#35
(byte*) print_char_cursor#36
(byte*) print_char_cursor#37
(byte*) print_char_cursor#38
(byte*) print_char_cursor#39
(byte*) print_char_cursor#4
(byte*) print_char_cursor#40
(byte*) print_char_cursor#41
(byte*) print_char_cursor#42
(byte*) print_char_cursor#43
(byte*) print_char_cursor#44
(byte*) print_char_cursor#45
(byte*) print_char_cursor#46
(byte*) print_char_cursor#47
(byte*) print_char_cursor#48
(byte*) print_char_cursor#49
(byte*) print_char_cursor#5
(byte*) print_char_cursor#50
(byte*) print_char_cursor#51
(byte*) print_char_cursor#52
(byte*) print_char_cursor#53
(byte*) print_char_cursor#54
(byte*) print_char_cursor#55
(byte*) print_char_cursor#56
(byte*) print_char_cursor#57
(byte*) print_char_cursor#58
(byte*) print_char_cursor#59
(byte*) print_char_cursor#6
(byte*) print_char_cursor#60
(byte*) print_char_cursor#61
(byte*) print_char_cursor#62
(byte*) print_char_cursor#63
(byte*) print_char_cursor#64
(byte*) print_char_cursor#65
(byte*) print_char_cursor#66
(byte*) print_char_cursor#67
(byte*) print_char_cursor#68
(byte*) print_char_cursor#69
(byte*) print_char_cursor#7
(byte*) print_char_cursor#70
(byte*) print_char_cursor#71
(byte*) print_char_cursor#72
(byte*) print_char_cursor#73
(byte*) print_char_cursor#74
(byte*) print_char_cursor#75
(byte*) print_char_cursor#76
(byte*) print_char_cursor#77
(byte*) print_char_cursor#78
(byte*) print_char_cursor#79
(byte*) print_char_cursor#8
(byte*) print_char_cursor#80
(byte*) print_char_cursor#81
(byte*) print_char_cursor#82
(byte*) print_char_cursor#83
(byte*) print_char_cursor#84
(byte*) print_char_cursor#85
(byte*) print_char_cursor#86
(byte*) print_char_cursor#87
(byte*) print_char_cursor#88
(byte*) print_char_cursor#89
(byte*) print_char_cursor#9
(byte*) print_char_cursor#90
(byte*) print_char_cursor#91
(byte*) print_char_cursor#92
(byte*) print_char_cursor#93
(byte*) print_char_cursor#94
(byte*) print_char_cursor#95
(byte*) print_char_cursor#96
(byte*) print_char_cursor#97
(byte*) print_char_cursor#98
(byte*) print_char_cursor#99
(void()) print_cls()
(label) print_cls::@1
(label) print_cls::@return
(const byte*) print_hextab[]  = (string) "0123456789abcdef"z
(byte*) print_line_cursor
(byte*) print_line_cursor#0
(byte*) print_line_cursor#1
(byte*) print_line_cursor#10
(byte*) print_line_cursor#11
(byte*) print_line_cursor#12
(byte*) print_line_cursor#13
(byte*) print_line_cursor#14
(byte*) print_line_cursor#15
(byte*) print_line_cursor#16
(byte*) print_line_cursor#17
(byte*) print_line_cursor#18
(byte*) print_line_cursor#19
(byte*) print_line_cursor#2
(byte*) print_line_cursor#20
(byte*) print_line_cursor#21
(byte*) print_line_cursor#22
(byte*) print_line_cursor#23
(byte*) print_line_cursor#24
(byte*) print_line_cursor#25
(byte*) print_line_cursor#26
(byte*) print_line_cursor#27
(byte*) print_line_cursor#28
(byte*) print_line_cursor#29
(byte*) print_line_cursor#3
(byte*) print_line_cursor#30
(byte*) print_line_cursor#31
(byte*) print_line_cursor#32
(byte*) print_line_cursor#33
(byte*) print_line_cursor#34
(byte*) print_line_cursor#35
(byte*) print_line_cursor#36
(byte*) print_line_cursor#37
(byte*) print_line_cursor#38
(byte*) print_line_cursor#39
(byte*) print_line_cursor#4
(byte*) print_line_cursor#40
(byte*) print_line_cursor#41
(byte*) print_line_cursor#42
(byte*) print_line_cursor#43
(byte*) print_line_cursor#44
(byte*) print_line_cursor#45
(byte*) print_line_cursor#46
(byte*) print_line_cursor#47
(byte*) print_line_cursor#48
(byte*) print_line_cursor#49
(byte*) print_line_cursor#5
(byte*) print_line_cursor#50
(byte*) print_line_cursor#51
(byte*) print_line_cursor#52
(byte*) print_line_cursor#53
(byte*) print_line_cursor#54
(byte*) print_line_cursor#55
(byte*) print_line_cursor#56
(byte*) print_line_cursor#57
(byte*) print_line_cursor#58
(byte*) print_line_cursor#59
(byte*) print_line_cursor#6
(byte*) print_line_cursor#60
(byte*) print_line_cursor#61
(byte*) print_line_cursor#62
(byte*) print_line_cursor#63
(byte*) print_line_cursor#64
(byte*) print_line_cursor#65
(byte*) print_line_cursor#66
(byte*) print_line_cursor#67
(byte*) print_line_cursor#68
(byte*) print_line_cursor#69
(byte*) print_line_cursor#7
(byte*) print_line_cursor#70
(byte*) print_line_cursor#71
(byte*) print_line_cursor#72
(byte*) print_line_cursor#73
(byte*) print_line_cursor#74
(byte*) print_line_cursor#75
(byte*) print_line_cursor#76
(byte*) print_line_cursor#77
(byte*) print_line_cursor#78
(byte*) print_line_cursor#79
(byte*) print_line_cursor#8
(byte*) print_line_cursor#80
(byte*) print_line_cursor#81
(byte*) print_line_cursor#82
(byte*) print_line_cursor#83
(byte*) print_line_cursor#84
(byte*) print_line_cursor#85
(byte*) print_line_cursor#9
(void()) print_ln()
(byte*~) print_ln::$0
(bool~) print_ln::$1
(label) print_ln::@1
(label) print_ln::@2
(label) print_ln::@return
(void()) print_sbyte((signed byte) print_sbyte::b)
(bool~) print_sbyte::$0
(byte~) print_sbyte::$1
(signed byte~) print_sbyte::$5
(label) print_sbyte::@1
(label) print_sbyte::@2
(label) print_sbyte::@3
(label) print_sbyte::@5
(label) print_sbyte::@6
(label) print_sbyte::@7
(label) print_sbyte::@return
(signed byte) print_sbyte::b
(signed byte) print_sbyte::b#0
(signed byte) print_sbyte::b#1
(signed byte) print_sbyte::b#10
(signed byte) print_sbyte::b#2
(signed byte) print_sbyte::b#3
(signed byte) print_sbyte::b#4
(signed byte) print_sbyte::b#5
(signed byte) print_sbyte::b#6
(signed byte) print_sbyte::b#7
(signed byte) print_sbyte::b#8
(signed byte) print_sbyte::b#9
(byte*) print_screen
(byte*) print_screen#0
(byte*) print_screen#1
(byte*) print_screen#2
(byte*) print_screen#3
(byte*) print_screen#4
(byte*) print_screen#5
(byte*) print_screen#6
(byte*) print_screen#7
(byte*) print_screen#8
(void()) print_str((byte*) print_str::str)
(bool~) print_str::$0
(label) print_str::@1
(label) print_str::@2
(label) print_str::@return
(byte*) print_str::str
(byte*) print_str::str#0
(byte*) print_str::str#1
(byte*) print_str::str#10
(byte*) print_str::str#11
(byte*) print_str::str#12
(byte*) print_str::str#13
(byte*) print_str::str#14
(byte*) print_str::str#15
(byte*) print_str::str#2
(byte*) print_str::str#3
(byte*) print_str::str#4
(byte*) print_str::str#5
(byte*) print_str::str#6
(byte*) print_str::str#7
(byte*) print_str::str#8
(byte*) print_str::str#9
(void()) print_sword((signed word) print_sword::w)
(bool~) print_sword::$0
(word~) print_sword::$1
(signed word~) print_sword::$5
(label) print_sword::@1
(label) print_sword::@2
(label) print_sword::@3
(label) print_sword::@5
(label) print_sword::@6
(label) print_sword::@7
(label) print_sword::@return
(signed word) print_sword::w
(signed word) print_sword::w#0
(signed word) print_sword::w#1
(signed word) print_sword::w#10
(signed word) print_sword::w#2
(signed word) print_sword::w#3
(signed word) print_sword::w#4
(signed word) print_sword::w#5
(signed word) print_sword::w#6
(signed word) print_sword::w#7
(signed word) print_sword::w#8
(signed word) print_sword::w#9
(void()) print_word((word) print_word::w)
(byte~) print_word::$0
(byte~) print_word::$2
(label) print_word::@1
(label) print_word::@2
(label) print_word::@return
(word) print_word::w
(word) print_word::w#0
(word) print_word::w#1
(word) print_word::w#2
(word) print_word::w#3
(word) print_word::w#4
(word) print_word::w#5
(word) print_word::w#6
(signed word) rem16s
(signed word) rem16s#0
(signed word) rem16s#1
(signed word) rem16s#10
(signed word) rem16s#11
(signed word) rem16s#12
(signed word) rem16s#13
(signed word) rem16s#14
(signed word) rem16s#15
(signed word) rem16s#16
(signed word) rem16s#17
(signed word) rem16s#18
(signed word) rem16s#19
(signed word) rem16s#2
(signed word) rem16s#20
(signed word) rem16s#21
(signed word) rem16s#22
(signed word) rem16s#23
(signed word) rem16s#24
(signed word) rem16s#25
(signed word) rem16s#26
(signed word) rem16s#27
(signed word) rem16s#28
(signed word) rem16s#29
(signed word) rem16s#3
(signed word) rem16s#30
(signed word) rem16s#31
(signed word) rem16s#32
(signed word) rem16s#33
(signed word) rem16s#34
(signed word) rem16s#35
(signed word) rem16s#4
(signed word) rem16s#5
(signed word) rem16s#6
(signed word) rem16s#7
(signed word) rem16s#8
(signed word) rem16s#9
(word) rem16u
(word) rem16u#0
(word) rem16u#1
(word) rem16u#10
(word) rem16u#11
(word) rem16u#12
(word) rem16u#13
(word) rem16u#14
(word) rem16u#15
(word) rem16u#16
(word) rem16u#17
(word) rem16u#18
(word) rem16u#19
(word) rem16u#2
(word) rem16u#20
(word) rem16u#21
(word) rem16u#22
(word) rem16u#23
(word) rem16u#24
(word) rem16u#25
(word) rem16u#26
(word) rem16u#27
(word) rem16u#28
(word) rem16u#29
(word) rem16u#3
(word) rem16u#30
(word) rem16u#31
(word) rem16u#32
(word) rem16u#33
(word) rem16u#34
(word) rem16u#35
(word) rem16u#36
(word) rem16u#37
(word) rem16u#38
(word) rem16u#39
(word) rem16u#4
(word) rem16u#40
(word) rem16u#41
(word) rem16u#42
(word) rem16u#43
(word) rem16u#44
(word) rem16u#45
(word) rem16u#46
(word) rem16u#47
(word) rem16u#48
(word) rem16u#49
(word) rem16u#5
(word) rem16u#50
(word) rem16u#51
(word) rem16u#52
(word) rem16u#53
(word) rem16u#54
(word) rem16u#55
(word) rem16u#56
(word) rem16u#57
(word) rem16u#58
(word) rem16u#59
(word) rem16u#6
(word) rem16u#60
(word) rem16u#61
(word) rem16u#62
(word) rem16u#63
(word) rem16u#64
(word) rem16u#65
(word) rem16u#66
(word) rem16u#67
(word) rem16u#68
(word) rem16u#69
(word) rem16u#7
(word) rem16u#8
(word) rem16u#9
(signed byte) rem8s
(signed byte) rem8s#0
(signed byte) rem8s#1
(signed byte) rem8s#10
(signed byte) rem8s#11
(signed byte) rem8s#12
(signed byte) rem8s#13
(signed byte) rem8s#14
(signed byte) rem8s#15
(signed byte) rem8s#16
(signed byte) rem8s#17
(signed byte) rem8s#18
(signed byte) rem8s#19
(signed byte) rem8s#2
(signed byte) rem8s#20
(signed byte) rem8s#21
(signed byte) rem8s#22
(signed byte) rem8s#23
(signed byte) rem8s#24
(signed byte) rem8s#25
(signed byte) rem8s#26
(signed byte) rem8s#27
(signed byte) rem8s#28
(signed byte) rem8s#29
(signed byte) rem8s#3
(signed byte) rem8s#30
(signed byte) rem8s#31
(signed byte) rem8s#4
(signed byte) rem8s#5
(signed byte) rem8s#6
(signed byte) rem8s#7
(signed byte) rem8s#8
(signed byte) rem8s#9
(byte) rem8u
(byte) rem8u#0
(byte) rem8u#1
(byte) rem8u#10
(byte) rem8u#11
(byte) rem8u#12
(byte) rem8u#13
(byte) rem8u#14
(byte) rem8u#15
(byte) rem8u#16
(byte) rem8u#17
(byte) rem8u#18
(byte) rem8u#19
(byte) rem8u#2
(byte) rem8u#20
(byte) rem8u#21
(byte) rem8u#22
(byte) rem8u#23
(byte) rem8u#24
(byte) rem8u#25
(byte) rem8u#26
(byte) rem8u#27
(byte) rem8u#28
(byte) rem8u#29
(byte) rem8u#3
(byte) rem8u#30
(byte) rem8u#31
(byte) rem8u#32
(byte) rem8u#33
(byte) rem8u#34
(byte) rem8u#35
(byte) rem8u#36
(byte) rem8u#37
(byte) rem8u#38
(byte) rem8u#39
(byte) rem8u#4
(byte) rem8u#40
(byte) rem8u#41
(byte) rem8u#42
(byte) rem8u#43
(byte) rem8u#44
(byte) rem8u#45
(byte) rem8u#46
(byte) rem8u#47
(byte) rem8u#48
(byte) rem8u#49
(byte) rem8u#5
(byte) rem8u#50
(byte) rem8u#51
(byte) rem8u#52
(byte) rem8u#53
(byte) rem8u#54
(byte) rem8u#55
(byte) rem8u#56
(byte) rem8u#57
(byte) rem8u#58
(byte) rem8u#59
(byte) rem8u#6
(byte) rem8u#60
(byte) rem8u#61
(byte) rem8u#62
(byte) rem8u#63
(byte) rem8u#64
(byte) rem8u#65
(byte) rem8u#7
(byte) rem8u#8
(byte) rem8u#9
(void()) test_16s()
(signed word~) test_16s::$0
(byte~) test_16s::$10
(byte~) test_16s::$11
(bool~) test_16s::$9
(label) test_16s::@1
(label) test_16s::@10
(label) test_16s::@11
(label) test_16s::@3
(label) test_16s::@4
(label) test_16s::@5
(label) test_16s::@6
(label) test_16s::@7
(label) test_16s::@8
(label) test_16s::@9
(label) test_16s::@return
(signed word) test_16s::dividend
(signed word) test_16s::dividend#0
(signed word) test_16s::dividend#1
(const signed word*) test_16s::dividends[]  = { (signed word) $7fff, (signed word) $7fff, (signed word) -$7fff, (signed word) -$7fff, (signed word) $7fff, (signed word) -$7fff }
(signed word) test_16s::divisor
(signed word) test_16s::divisor#0
(signed word) test_16s::divisor#1
(signed word) test_16s::divisor#2
(signed word) test_16s::divisor#3
(const signed word*) test_16s::divisors[]  = { (signed word) 5, (signed word) -7, (signed word) $b, (signed word) -$d, (signed word) -$11, (signed word) $13 }
(byte) test_16s::i
(byte) test_16s::i#0
(byte) test_16s::i#1
(byte) test_16s::i#10
(byte) test_16s::i#11
(byte) test_16s::i#2
(byte) test_16s::i#3
(byte) test_16s::i#4
(byte) test_16s::i#5
(byte) test_16s::i#6
(byte) test_16s::i#7
(byte) test_16s::i#8
(byte) test_16s::i#9
(signed word) test_16s::res
(signed word) test_16s::res#0
(signed word) test_16s::res#1
(signed word) test_16s::res#2
(signed word) test_16s::res#3
(signed word) test_16s::res#4
(const string) test_16s::str[]  = (string) " / "
(const string) test_16s::str1[]  = (string) " = "
(const string) test_16s::str2[]  = (string) " "
(void()) test_16u()
(word~) test_16u::$0
(byte~) test_16u::$10
(byte~) test_16u::$11
(bool~) test_16u::$9
(label) test_16u::@1
(label) test_16u::@10
(label) test_16u::@11
(label) test_16u::@3
(label) test_16u::@4
(label) test_16u::@5
(label) test_16u::@6
(label) test_16u::@7
(label) test_16u::@8
(label) test_16u::@9
(label) test_16u::@return
(word) test_16u::dividend
(word) test_16u::dividend#0
(word) test_16u::dividend#1
(const word*) test_16u::dividends[]  = { (word) $ffff, (word) $ffff, (word) $ffff, (word) $ffff, (word) $ffff, (word) $ffff }
(word) test_16u::divisor
(word) test_16u::divisor#0
(word) test_16u::divisor#1
(word) test_16u::divisor#2
(word) test_16u::divisor#3
(const word*) test_16u::divisors[]  = { (word) 5, (word) 7, (word) $b, (word) $d, (word) $11, (word) $13 }
(byte) test_16u::i
(byte) test_16u::i#0
(byte) test_16u::i#1
(byte) test_16u::i#10
(byte) test_16u::i#11
(byte) test_16u::i#2
(byte) test_16u::i#3
(byte) test_16u::i#4
(byte) test_16u::i#5
(byte) test_16u::i#6
(byte) test_16u::i#7
(byte) test_16u::i#8
(byte) test_16u::i#9
(word) test_16u::res
(word) test_16u::res#0
(word) test_16u::res#1
(word) test_16u::res#2
(word) test_16u::res#3
(word) test_16u::res#4
(const string) test_16u::str[]  = (string) " / "
(const string) test_16u::str1[]  = (string) " = "
(const string) test_16u::str2[]  = (string) " "
(void()) test_8s()
(signed byte~) test_8s::$0
(bool~) test_8s::$9
(label) test_8s::@1
(label) test_8s::@10
(label) test_8s::@11
(label) test_8s::@3
(label) test_8s::@4
(label) test_8s::@5
(label) test_8s::@6
(label) test_8s::@7
(label) test_8s::@8
(label) test_8s::@9
(label) test_8s::@return
(signed byte) test_8s::dividend
(signed byte) test_8s::dividend#0
(signed byte) test_8s::dividend#1
(const signed byte*) test_8s::dividends[]  = { (signed byte) $7f, (signed byte) -$7f, (signed byte) -$7f, (signed byte) $7f, (signed byte) $7f, (signed byte) $7f }
(signed byte) test_8s::divisor
(signed byte) test_8s::divisor#0
(signed byte) test_8s::divisor#1
(signed byte) test_8s::divisor#2
(signed byte) test_8s::divisor#3
(const signed byte*) test_8s::divisors[]  = { (signed byte) 5, (signed byte) 7, (signed byte) -$b, (signed byte) -$d, (signed byte) $11, (signed byte) $13 }
(byte) test_8s::i
(byte) test_8s::i#0
(byte) test_8s::i#1
(byte) test_8s::i#10
(byte) test_8s::i#11
(byte) test_8s::i#2
(byte) test_8s::i#3
(byte) test_8s::i#4
(byte) test_8s::i#5
(byte) test_8s::i#6
(byte) test_8s::i#7
(byte) test_8s::i#8
(byte) test_8s::i#9
(signed byte) test_8s::res
(signed byte) test_8s::res#0
(signed byte) test_8s::res#1
(signed byte) test_8s::res#2
(signed byte) test_8s::res#3
(signed byte) test_8s::res#4
(const string) test_8s::str[]  = (string) " / "
(const string) test_8s::str1[]  = (string) " = "
(const string) test_8s::str2[]  = (string) " "
(void()) test_8u()
(byte~) test_8u::$0
(bool~) test_8u::$9
(label) test_8u::@1
(label) test_8u::@10
(label) test_8u::@11
(label) test_8u::@3
(label) test_8u::@4
(label) test_8u::@5
(label) test_8u::@6
(label) test_8u::@7
(label) test_8u::@8
(label) test_8u::@9
(label) test_8u::@return
(byte) test_8u::dividend
(byte) test_8u::dividend#0
(byte) test_8u::dividend#1
(const byte*) test_8u::dividends[]  = { (byte) $ff, (byte) $ff, (byte) $ff, (byte) $ff, (byte) $ff, (byte) $ff }
(byte) test_8u::divisor
(byte) test_8u::divisor#0
(byte) test_8u::divisor#1
(byte) test_8u::divisor#2
(byte) test_8u::divisor#3
(const byte*) test_8u::divisors[]  = { (byte) 5, (byte) 7, (byte) $b, (byte) $d, (byte) $11, (byte) $13 }
(byte) test_8u::i
(byte) test_8u::i#0
(byte) test_8u::i#1
(byte) test_8u::i#10
(byte) test_8u::i#11
(byte) test_8u::i#2
(byte) test_8u::i#3
(byte) test_8u::i#4
(byte) test_8u::i#5
(byte) test_8u::i#6
(byte) test_8u::i#7
(byte) test_8u::i#8
(byte) test_8u::i#9
(byte) test_8u::res
(byte) test_8u::res#0
(byte) test_8u::res#1
(byte) test_8u::res#2
(byte) test_8u::res#3
(byte) test_8u::res#4
(const string) test_8u::str[]  = (string) " / "
(const string) test_8u::str1[]  = (string) " = "
(const string) test_8u::str2[]  = (string) " "

Adding number conversion cast (unumber) 0 in (bool~) memset::$0 ← (word) memset::num#1 > (number) 0
Adding number conversion cast (unumber) 0 in (bool~) print_str::$0 ← (number) 0 != *((byte*) print_str::str#13)
Adding number conversion cast (unumber) $28 in (byte*~) print_ln::$0 ← (byte*) print_line_cursor#20 + (number) $28
Adding number conversion cast (snumber) 0 in (bool~) print_sword::$0 ← (signed word) print_sword::w#5 < (number) 0
Adding number conversion cast (snumber) 0 in (bool~) print_sbyte::$0 ← (signed byte) print_sbyte::b#5 < (number) 0
Adding number conversion cast (unumber) 4 in (byte~) print_byte::$0 ← (byte) print_byte::b#7 >> (number) 4
Adding number conversion cast (unumber) $f in (number~) print_byte::$2 ← (byte) print_byte::b#8 & (number) $f
Adding number conversion cast (unumber) print_byte::$2 in (number~) print_byte::$2 ← (byte) print_byte::b#8 & (unumber)(number) $f
Adding number conversion cast (unumber) $3e8 in (word) memset::num#0 ← (number) $3e8
Adding number conversion cast (unumber) 0 in (byte) divr8u::rem#0 ← (number) 0
Adding number conversion cast (unumber) 1 in (byte~) divr8u::$0 ← (byte) divr8u::rem#4 << (number) 1
Adding number conversion cast (unumber) $80 in (number~) divr8u::$1 ← (byte) divr8u::dividend#2 & (number) $80
Adding number conversion cast (unumber) divr8u::$1 in (number~) divr8u::$1 ← (byte) divr8u::dividend#2 & (unumber)(number) $80
Adding number conversion cast (unumber) 0 in (bool~) divr8u::$2 ← (unumber~) divr8u::$1 != (number) 0
Adding number conversion cast (unumber) 1 in (byte~) divr8u::$5 ← (byte) divr8u::dividend#3 << (number) 1
Adding number conversion cast (unumber) 1 in (byte~) divr8u::$6 ← (byte) divr8u::quotient#3 << (number) 1
Adding number conversion cast (unumber) 1 in (number~) divr8u::$4 ← (byte) divr8u::rem#6 | (number) 1
Adding number conversion cast (unumber) divr8u::$4 in (number~) divr8u::$4 ← (byte) divr8u::rem#6 | (unumber)(number) 1
Adding number conversion cast (unumber) 1 in (word~) divr16u::$0 ← (word) divr16u::rem#5 << (number) 1
Adding number conversion cast (unumber) $80 in (number~) divr16u::$2 ← (byte~) divr16u::$1 & (number) $80
Adding number conversion cast (unumber) divr16u::$2 in (number~) divr16u::$2 ← (byte~) divr16u::$1 & (unumber)(number) $80
Adding number conversion cast (unumber) 0 in (bool~) divr16u::$3 ← (unumber~) divr16u::$2 != (number) 0
Adding number conversion cast (unumber) 1 in (word~) divr16u::$6 ← (word) divr16u::dividend#4 << (number) 1
Adding number conversion cast (unumber) 1 in (word~) divr16u::$7 ← (word) divr16u::quotient#3 << (number) 1
Adding number conversion cast (unumber) 1 in (number~) divr16u::$5 ← (word) divr16u::rem#7 | (number) 1
Adding number conversion cast (unumber) divr16u::$5 in (number~) divr16u::$5 ← (word) divr16u::rem#7 | (unumber)(number) 1
Adding number conversion cast (unumber) 0 in (word) divr16u::rem#3 ← (number) 0
Adding number conversion cast (snumber) 0 in (bool~) div8s::$0 ← (signed byte) div8s::dividend#1 < (number) 0
Adding number conversion cast (unumber) 1 in (byte) div8s::neg#1 ← (number) 1
Adding number conversion cast (snumber) 0 in (bool~) div8s::$1 ← (signed byte) div8s::divisor#1 < (number) 0
Adding number conversion cast (unumber) 1 in (number~) div8s::$10 ← (byte) div8s::neg#3 ^ (number) 1
Adding number conversion cast (unumber) div8s::$10 in (number~) div8s::$10 ← (byte) div8s::neg#3 ^ (unumber)(number) 1
Adding number conversion cast (unumber) 0 in (bool~) div8s::$3 ← (byte) div8s::neg#4 == (number) 0
Adding number conversion cast (snumber) 0 in (bool~) divr16s::$0 ← (signed word) divr16s::dividend#1 < (number) 0
Adding number conversion cast (snumber) 0 in (bool~) divr16s::$1 ← (signed word) divr16s::rem#1 < (number) 0
Adding number conversion cast (unumber) 1 in (byte) divr16s::neg#1 ← (number) 1
Adding number conversion cast (snumber) 0 in (bool~) divr16s::$3 ← (signed word) divr16s::divisor#1 < (number) 0
Adding number conversion cast (unumber) 1 in (number~) divr16s::$15 ← (byte) divr16s::neg#3 ^ (number) 1
Adding number conversion cast (unumber) divr16s::$15 in (number~) divr16s::$15 ← (byte) divr16s::neg#3 ^ (unumber)(number) 1
Adding number conversion cast (unumber) 0 in (bool~) divr16s::$5 ← (byte) divr16s::neg#4 == (number) 0
Adding number conversion cast (snumber) 0 in (signed word) divr16s::rem#0 ← (number) 0
Successful SSA optimization PassNAddNumberTypeConversions
Inlining cast (byte*~) memset::$2 ← (byte*)(void*) memset::str#2
Inlining cast (byte*) memset::dst#0 ← (byte*)(void*) memset::str#2
Inlining cast (word~) print_sword::$1 ← (word)(signed word) print_sword::w#7
Inlining cast (byte~) print_sbyte::$1 ← (byte)(signed byte) print_sbyte::b#7
Inlining cast (word) memset::num#0 ← (unumber)(number) $3e8
Inlining cast (byte) divr8u::rem#0 ← (unumber)(number) 0
Inlining cast (word) divr16u::rem#3 ← (unumber)(number) 0
Inlining cast (byte~) div8s::$6 ← (byte)(signed byte~) div8s::$5
Inlining cast (byte) div8s::neg#1 ← (unumber)(number) 1
Inlining cast (byte~) div8s::$4 ← (byte)(signed byte) div8s::dividend#3
Inlining cast (byte~) div8s::$9 ← (byte)(signed byte~) div8s::$8
Inlining cast (byte~) div8s::$7 ← (byte)(signed byte) div8s::divisor#3
Inlining cast (signed byte~) div8s::$15 ← (signed byte)(byte) rem8u#19
Inlining cast (signed byte~) div8s::$16 ← (signed byte)(byte) div8s::resultu#1
Inlining cast (signed byte~) div8s::$11 ← (signed byte)(byte) rem8u#20
Inlining cast (signed byte~) div8s::$13 ← (signed byte)(byte) div8s::resultu#2
Inlining cast (word~) divr16s::$9 ← (word)(signed word~) divr16s::$8
Inlining cast (word~) divr16s::$11 ← (word)(signed word~) divr16s::$10
Inlining cast (byte) divr16s::neg#1 ← (unumber)(number) 1
Inlining cast (word~) divr16s::$6 ← (word)(signed word) divr16s::dividend#3
Inlining cast (word~) divr16s::$7 ← (word)(signed word) divr16s::rem#3
Inlining cast (word~) divr16s::$14 ← (word)(signed word~) divr16s::$13
Inlining cast (word~) divr16s::$12 ← (word)(signed word) divr16s::divisor#3
Inlining cast (signed word~) divr16s::$20 ← (signed word)(word) rem16u#21
Inlining cast (signed word~) divr16s::$21 ← (signed word)(word) divr16s::resultu#1
Inlining cast (signed word~) divr16s::$16 ← (signed word)(word) rem16u#22
Inlining cast (signed word~) divr16s::$18 ← (signed word)(word) divr16s::resultu#2
Inlining cast (signed word) divr16s::rem#0 ← (snumber)(number) 0
Successful SSA optimization Pass2InlineCast
Simplifying constant integer cast 0
Simplifying constant pointer cast (byte*) 1024
Simplifying constant integer cast 0
Simplifying constant integer cast $28
Simplifying constant integer cast 0
Simplifying constant integer cast 0
Simplifying constant integer cast 4
Simplifying constant integer cast $f
Simplifying constant integer cast $3e8
Simplifying constant integer cast 0
Simplifying constant integer cast 1
Simplifying constant integer cast $80
Simplifying constant integer cast 0
Simplifying constant integer cast 1
Simplifying constant integer cast 1
Simplifying constant integer cast 1
Simplifying constant integer cast 1
Simplifying constant integer cast $80
Simplifying constant integer cast 0
Simplifying constant integer cast 1
Simplifying constant integer cast 1
Simplifying constant integer cast 1
Simplifying constant integer cast 0
Simplifying constant integer cast 0
Simplifying constant integer cast 1
Simplifying constant integer cast 0
Simplifying constant integer cast 1
Simplifying constant integer cast 0
Simplifying constant integer cast 0
Simplifying constant integer cast 0
Simplifying constant integer cast 1
Simplifying constant integer cast 0
Simplifying constant integer cast 1
Simplifying constant integer cast 0
Simplifying constant integer cast 0
Successful SSA optimization PassNCastSimplification
Finalized unsigned number type (byte) 0
Finalized unsigned number type (byte) 0
Finalized unsigned number type (byte) $28
Finalized signed number type (signed byte) 0
Finalized signed number type (signed byte) 0
Finalized unsigned number type (byte) 4
Finalized unsigned number type (byte) $f
Finalized unsigned number type (word) $3e8
Finalized unsigned number type (byte) 0
Finalized unsigned number type (byte) 1
Finalized unsigned number type (byte) $80
Finalized unsigned number type (byte) 0
Finalized unsigned number type (byte) 1
Finalized unsigned number type (byte) 1
Finalized unsigned number type (byte) 1
Finalized unsigned number type (byte) 1
Finalized unsigned number type (byte) $80
Finalized unsigned number type (byte) 0
Finalized unsigned number type (byte) 1
Finalized unsigned number type (byte) 1
Finalized unsigned number type (byte) 1
Finalized unsigned number type (byte) 0
Finalized signed number type (signed byte) 0
Finalized unsigned number type (byte) 1
Finalized signed number type (signed byte) 0
Finalized unsigned number type (byte) 1
Finalized unsigned number type (byte) 0
Finalized signed number type (signed byte) 0
Finalized signed number type (signed byte) 0
Finalized unsigned number type (byte) 1
Finalized signed number type (signed byte) 0
Finalized unsigned number type (byte) 1
Finalized unsigned number type (byte) 0
Finalized signed number type (signed byte) 0
Successful SSA optimization PassNFinalizeNumberTypeConversions
Inferred type updated to byte in (unumber~) print_byte::$2 ← (byte) print_byte::b#8 & (byte) $f
Inferred type updated to byte in (unumber~) divr8u::$1 ← (byte) divr8u::dividend#2 & (byte) $80
Inferred type updated to byte in (unumber~) divr8u::$4 ← (byte) divr8u::rem#6 | (byte) 1
Inferred type updated to byte in (unumber~) divr16u::$2 ← (byte~) divr16u::$1 & (byte) $80
Inferred type updated to word in (unumber~) divr16u::$5 ← (word) divr16u::rem#7 | (byte) 1
Inferred type updated to byte in (unumber~) div8s::$10 ← (byte) div8s::neg#3 ^ (byte) 1
Inferred type updated to byte in (unumber~) divr16s::$15 ← (byte) divr16s::neg#3 ^ (byte) 1
Inversing boolean not [2] (bool~) memset::$1 ← (word) memset::num#1 <= (byte) 0 from [1] (bool~) memset::$0 ← (word) memset::num#1 > (byte) 0
Inversing boolean not [165] (bool~) divr8u::$3 ← (byte~) divr8u::$1 == (byte) 0 from [164] (bool~) divr8u::$2 ← (byte~) divr8u::$1 != (byte) 0
Inversing boolean not [173] (bool~) divr8u::$8 ← (byte) divr8u::rem#5 < (byte) divr8u::divisor#1 from [172] (bool~) divr8u::$7 ← (byte) divr8u::rem#5 >= (byte) divr8u::divisor#1
Inversing boolean not [204] (bool~) divr16u::$4 ← (byte~) divr16u::$2 == (byte) 0 from [203] (bool~) divr16u::$3 ← (byte~) divr16u::$2 != (byte) 0
Inversing boolean not [212] (bool~) divr16u::$9 ← (word) divr16u::rem#6 < (word) divr16u::divisor#2 from [211] (bool~) divr16u::$8 ← (word) divr16u::rem#6 >= (word) divr16u::divisor#2
Successful SSA optimization Pass2UnaryNotSimplification
Alias (void*) memset::return#0 = (void*) memset::str#1 (void*) memset::return#3 (void*) memset::return#1 
Alias (void*) memset::str#2 = (void*) memset::str#3 
Alias (word) memset::num#1 = (word) memset::num#2 
Alias (byte) memset::c#3 = (byte) memset::c#4 
Alias (byte*) memset::end#0 = (byte*~) memset::$3 
Alias (byte) memset::c#1 = (byte) memset::c#2 
Alias (byte*) memset::dst#2 = (byte*) memset::dst#3 
Alias (byte*) memset::end#1 = (byte*) memset::end#2 
Alias (void*) memset::str#4 = (void*) memset::str#5 
Alias (byte*) print_line_cursor#0 = (byte*) print_screen#0 (byte*) print_char_cursor#0 (byte*) print_line_cursor#61 (byte*) print_char_cursor#160 (byte*) print_screen#8 (byte*) print_line_cursor#56 (byte*) print_char_cursor#159 (byte*) print_screen#7 (byte*) print_line_cursor#51 (byte*) print_char_cursor#154 (byte*) print_screen#6 (byte*) print_line_cursor#50 (byte*) print_char_cursor#153 (byte*) print_screen#5 (byte*) print_line_cursor#45 (byte*) print_char_cursor#145 (byte*) print_screen#4 
Alias (byte*) print_str::str#13 = (byte*) print_str::str#14 
Alias (byte*) print_char_cursor#130 = (byte*) print_char_cursor#66 (byte*) print_char_cursor#67 (byte*) print_char_cursor#2 
Alias (byte*) print_line_cursor#1 = (byte*~) print_ln::$0 (byte*) print_line_cursor#21 (byte*) print_char_cursor#3 (byte*) print_line_cursor#22 (byte*) print_char_cursor#69 (byte*) print_line_cursor#2 (byte*) print_char_cursor#4 
Alias (byte*) print_char_cursor#132 = (byte*) print_char_cursor#147 (byte*) print_char_cursor#133 
Alias (signed word) print_sword::w#10 = (signed word) print_sword::w#8 (signed word) print_sword::w#5 (signed word) print_sword::w#6 (signed word) print_sword::w#9 
Alias (byte*) print_char_cursor#5 = (byte*) print_char_cursor#70 
Alias (signed word) print_sword::w#0 = (signed word~) print_sword::$5 
Alias (byte*) print_char_cursor#6 = (byte*) print_char_cursor#71 
Alias (word) print_word::w#0 = (word~) print_sword::$1 
Alias (byte*) print_char_cursor#7 = (byte*) print_char_cursor#72 (byte*) print_char_cursor#73 (byte*) print_char_cursor#8 
Alias (byte*) print_char_cursor#135 = (byte*) print_char_cursor#148 (byte*) print_char_cursor#136 
Alias (signed byte) print_sbyte::b#10 = (signed byte) print_sbyte::b#8 (signed byte) print_sbyte::b#5 (signed byte) print_sbyte::b#6 (signed byte) print_sbyte::b#9 
Alias (byte*) print_char_cursor#74 = (byte*) print_char_cursor#9 
Alias (signed byte) print_sbyte::b#0 = (signed byte~) print_sbyte::$5 
Alias (byte*) print_char_cursor#10 = (byte*) print_char_cursor#75 
Alias (byte) print_byte::b#0 = (byte~) print_sbyte::$1 
Alias (byte*) print_char_cursor#11 = (byte*) print_char_cursor#76 (byte*) print_char_cursor#77 (byte*) print_char_cursor#12 
Alias (byte) print_byte::b#1 = (byte~) print_word::$0 
Alias (word) print_word::w#5 = (word) print_word::w#6 
Alias (byte*) print_char_cursor#13 = (byte*) print_char_cursor#78 
Alias (byte) print_byte::b#2 = (byte~) print_word::$2 
Alias (byte*) print_char_cursor#14 = (byte*) print_char_cursor#79 (byte*) print_char_cursor#80 (byte*) print_char_cursor#15 
Alias (byte) print_byte::b#7 = (byte) print_byte::b#8 
Alias (byte*) print_char_cursor#16 = (byte*) print_char_cursor#81 
Alias (byte*) print_char_cursor#17 = (byte*) print_char_cursor#82 (byte*) print_char_cursor#83 (byte*) print_char_cursor#18 
Alias (byte*) print_char_cursor#19 = (byte*) print_char_cursor#85 (byte*) print_char_cursor#20 
Alias (byte*) print_line_cursor#23 = (byte*) print_screen#2 (byte*) print_screen#1 (byte*) print_line_cursor#3 (byte*) print_char_cursor#21 (byte*) print_char_cursor#86 (byte*) print_line_cursor#4 (byte*) print_char_cursor#22 
Alias (byte) divr8u::return#0 = (byte) divr8u::return#3 
Alias (byte) rem8u#1 = (byte) rem8u#15 (byte) rem8u#16 (byte) rem8u#2 
Alias (byte) div8u::return#0 = (byte~) div8u::$0 (byte) div8u::return#4 (byte) div8u::return#1 
Alias (byte) divr8u::rem#1 = (byte~) divr8u::$0 (byte) divr8u::rem#6 
Alias (byte) divr8u::dividend#1 = (byte~) divr8u::$5 (byte) divr8u::dividend#7 
Alias (byte) divr8u::quotient#1 = (byte~) divr8u::$6 (byte) divr8u::quotient#4 
Alias (byte) divr8u::dividend#2 = (byte) divr8u::dividend#6 
Alias (byte) divr8u::quotient#6 = (byte) divr8u::quotient#7 
Alias (byte) divr8u::divisor#3 = (byte) divr8u::divisor#4 
Alias (byte) divr8u::i#5 = (byte) divr8u::i#6 
Alias (byte) divr8u::rem#2 = (byte~) divr8u::$4 
Alias (byte) divr8u::rem#5 = (byte) divr8u::rem#7 
Alias (byte) divr8u::divisor#1 = (byte) divr8u::divisor#2 
Alias (byte) divr8u::i#3 = (byte) divr8u::i#4 
Alias (byte) divr8u::rem#3 = (byte~) divr8u::$9 
Alias (byte) divr8u::rem#10 = (byte) divr8u::rem#8 
Alias (byte) divr8u::return#1 = (byte) divr8u::quotient#5 (byte) divr8u::quotient#8 (byte) divr8u::return#4 (byte) divr8u::return#2 
Alias (byte) rem8u#17 = (byte) rem8u#3 (byte) rem8u#4 
Alias (byte) rem8u#0 = (byte) rem8u#55 (byte) rem8u#52 (byte) rem8u#50 (byte) rem8u#41 
Alias (word) divr16u::rem#0 = (word~) divr16u::$0 (word) divr16u::rem#7 
Alias (word) divr16u::dividend#0 = (word~) divr16u::$6 (word) divr16u::dividend#8 
Alias (word) divr16u::quotient#1 = (word~) divr16u::$7 (word) divr16u::quotient#4 
Alias (word) divr16u::dividend#3 = (word) divr16u::dividend#7 
Alias (word) divr16u::quotient#6 = (word) divr16u::quotient#7 
Alias (word) divr16u::divisor#4 = (word) divr16u::divisor#5 
Alias (byte) divr16u::i#5 = (byte) divr16u::i#6 
Alias (word) divr16u::rem#1 = (word~) divr16u::$5 
Alias (word) divr16u::rem#6 = (word) divr16u::rem#8 
Alias (word) divr16u::divisor#2 = (word) divr16u::divisor#3 
Alias (byte) divr16u::i#3 = (byte) divr16u::i#4 
Alias (word) divr16u::rem#2 = (word~) divr16u::$10 
Alias (word) divr16u::rem#11 = (word) divr16u::rem#9 
Alias (word) divr16u::return#0 = (word) divr16u::quotient#5 (word) divr16u::quotient#8 (word) divr16u::return#4 (word) divr16u::return#1 
Alias (word) rem16u#1 = (word) rem16u#17 (word) rem16u#2 
Alias (word) divr16u::return#2 = (word) divr16u::return#5 
Alias (word) rem16u#18 = (word) rem16u#3 (word) rem16u#19 (word) rem16u#4 
Alias (word) div16u::return#0 = (word~) div16u::$0 (word) div16u::return#3 (word) div16u::return#1 
Alias (word) rem16u#0 = (word) rem16u#55 (word) rem16u#54 (word) rem16u#45 
Alias (signed byte) div8s::dividend#1 = (signed byte) div8s::dividend#2 (signed byte) div8s::dividend#3 
Alias (signed byte) div8s::divisor#4 = (signed byte) div8s::divisor#6 (signed byte) div8s::divisor#5 
Alias (byte) rem8u#56 = (byte) rem8u#60 (byte) rem8u#57 
Alias (byte) div8s::dividendu#1 = (byte~) div8s::$6 
Alias (byte) div8s::neg#0 = (byte) div8s::neg#7 
Alias (byte) div8s::dividendu#2 = (byte~) div8s::$4 
Alias (signed byte) div8s::divisor#1 = (signed byte) div8s::divisor#2 (signed byte) div8s::divisor#3 
Alias (byte) div8s::neg#3 = (byte) div8s::neg#5 (byte) div8s::neg#8 
Alias (byte) div8s::dividendu#4 = (byte) div8s::dividendu#6 (byte) div8s::dividendu#5 
Alias (byte) rem8u#42 = (byte) rem8u#51 (byte) rem8u#43 
Alias (byte) div8s::divisoru#1 = (byte~) div8s::$9 
Alias (byte) div8s::neg#2 = (byte~) div8s::$10 
Alias (byte) div8s::divisoru#2 = (byte~) div8s::$7 
Alias (byte) div8u::return#2 = (byte) div8u::return#5 
Alias (byte) div8s::neg#4 = (byte) div8s::neg#6 
Alias (byte) rem8u#18 = (byte) rem8u#5 (byte) rem8u#19 (byte) rem8u#20 
Alias (byte) div8s::resultu#0 = (byte~) div8s::$2 (byte) div8s::resultu#1 (byte) div8s::resultu#2 
Alias (signed byte) rem8s#1 = (signed byte~) div8s::$15 
Alias (signed byte) div8s::return#0 = (signed byte~) div8s::$16 
Alias (signed byte) rem8s#2 = (signed byte~) div8s::$12 
Alias (signed byte) div8s::return#1 = (signed byte~) div8s::$14 
Alias (signed byte) div8s::return#2 = (signed byte) div8s::return#4 
Alias (byte) rem8u#21 = (byte) rem8u#6 
Alias (signed byte) rem8s#3 = (signed byte) rem8s#9 
Alias (signed byte) rem8s#0 = (signed byte) rem8s#26 (signed byte) rem8s#21 
Alias (signed word) divr16s::dividend#1 = (signed word) divr16s::dividend#2 (signed word) divr16s::dividend#3 
Alias (signed word) divr16s::rem#1 = (signed word) divr16s::rem#2 (signed word) divr16s::rem#3 
Alias (signed word) divr16s::divisor#4 = (signed word) divr16s::divisor#6 (signed word) divr16s::divisor#5 
Alias (word) rem16u#60 = (word) rem16u#64 (word) rem16u#61 
Alias (word) divr16s::dividendu#1 = (word~) divr16s::$9 
Alias (word) divr16s::remu#1 = (word~) divr16s::$11 
Alias (byte) divr16s::neg#0 = (byte) divr16s::neg#7 
Alias (word) divr16s::dividendu#2 = (word~) divr16s::$6 
Alias (word) divr16s::remu#2 = (word~) divr16s::$7 
Alias (signed word) divr16s::divisor#1 = (signed word) divr16s::divisor#2 (signed word) divr16s::divisor#3 
Alias (byte) divr16s::neg#3 = (byte) divr16s::neg#5 (byte) divr16s::neg#8 
Alias (word) divr16s::dividendu#4 = (word) divr16s::dividendu#6 (word) divr16s::dividendu#5 
Alias (word) divr16s::remu#4 = (word) divr16s::remu#6 (word) divr16s::remu#5 
Alias (word) rem16u#46 = (word) rem16u#56 (word) rem16u#47 
Alias (word) divr16s::divisoru#1 = (word~) divr16s::$14 
Alias (byte) divr16s::neg#2 = (byte~) divr16s::$15 
Alias (word) divr16s::divisoru#2 = (word~) divr16s::$12 
Alias (word) divr16u::return#3 = (word) divr16u::return#6 
Alias (byte) divr16s::neg#4 = (byte) divr16s::neg#6 
Alias (word) rem16u#20 = (word) rem16u#5 (word) rem16u#21 (word) rem16u#22 
Alias (word) divr16s::resultu#0 = (word~) divr16s::$4 (word) divr16s::resultu#1 (word) divr16s::resultu#2 
Alias (signed word) rem16s#1 = (signed word~) divr16s::$20 
Alias (signed word) divr16s::return#0 = (signed word~) divr16s::$21 
Alias (signed word) rem16s#2 = (signed word~) divr16s::$17 
Alias (signed word) divr16s::return#1 = (signed word~) divr16s::$19 
Alias (signed word) divr16s::return#2 = (signed word) divr16s::return#4 
Alias (word) rem16u#23 = (word) rem16u#6 
Alias (signed word) rem16s#11 = (signed word) rem16s#3 
Alias (signed word) divr16s::return#3 = (signed word) divr16s::return#5 
Alias (word) rem16u#24 = (word) rem16u#7 (word) rem16u#25 (word) rem16u#8 
Alias (signed word) rem16s#12 = (signed word) rem16s#4 (signed word) rem16s#13 (signed word) rem16s#5 
Alias (signed word) div16s::return#0 = (signed word~) div16s::$0 (signed word) div16s::return#3 (signed word) div16s::return#1 
Alias (byte) rem8u#33 = (byte) rem8u#44 
Alias (word) rem16u#38 = (word) rem16u#48 (word) rem16u#57 
Alias (signed byte) rem8s#16 = (signed byte) rem8s#27 (signed byte) rem8s#29 (signed byte) rem8s#22 
Alias (signed word) rem16s#21 = (signed word) rem16s#32 (signed word) rem16s#34 (signed word) rem16s#30 (signed word) rem16s#26 
Alias (byte*) print_line_cursor#24 = (byte*) print_line_cursor#5 
Alias (byte*) print_char_cursor#23 = (byte*) print_char_cursor#87 
Alias (byte) rem8u#22 = (byte) rem8u#7 (byte) rem8u#34 
Alias (byte*) print_char_cursor#24 = (byte*) print_char_cursor#88 
Alias (byte*) print_line_cursor#25 = (byte*) print_line_cursor#6 
Alias (word) rem16u#26 = (word) rem16u#9 (word) rem16u#39 
Alias (byte*) print_char_cursor#25 = (byte*) print_char_cursor#89 
Alias (byte*) print_line_cursor#26 = (byte*) print_line_cursor#7 
Alias (byte) rem8u#23 = (byte) rem8u#8 (byte) rem8u#35 (byte) rem8u#24 (byte) rem8u#9 
Alias (signed byte) rem8s#10 = (signed byte) rem8s#4 (signed byte) rem8s#17 (signed byte) rem8s#11 (signed byte) rem8s#5 
Alias (byte*) print_char_cursor#26 = (byte*) print_char_cursor#90 
Alias (byte*) print_line_cursor#27 = (byte*) print_line_cursor#8 
Alias (word) rem16u#10 = (word) rem16u#27 (word) rem16u#28 (word) rem16u#11 
Alias (signed word) rem16s#14 = (signed word) rem16s#6 (signed word) rem16s#15 (signed word) rem16s#7 
Alias (byte*) print_char_cursor#27 = (byte*) print_char_cursor#91 (byte*) print_char_cursor#92 (byte*) print_char_cursor#28 
Alias (byte*) print_line_cursor#10 = (byte*) print_line_cursor#9 (byte*) print_line_cursor#28 (byte*) print_line_cursor#29 
Alias (byte) div8u::return#3 = (byte) div8u::return#6 
Alias (byte) test_8u::dividend#0 = (byte) test_8u::dividend#1 
Alias (byte*) print_char_cursor#141 = (byte*) print_char_cursor#149 
Alias (byte) test_8u::divisor#0 = (byte) test_8u::divisor#3 (byte) test_8u::divisor#2 (byte) test_8u::divisor#1 
Alias (byte*) print_line_cursor#41 = (byte*) print_line_cursor#74 (byte*) print_line_cursor#78 (byte*) print_line_cursor#70 (byte*) print_line_cursor#66 (byte*) print_line_cursor#62 (byte*) print_line_cursor#57 (byte*) print_line_cursor#52 (byte*) print_line_cursor#46 
Alias (byte) test_8u::i#10 = (byte) test_8u::i#11 (byte) test_8u::i#2 (byte) test_8u::i#9 (byte) test_8u::i#8 (byte) test_8u::i#7 (byte) test_8u::i#6 (byte) test_8u::i#5 (byte) test_8u::i#4 (byte) test_8u::i#3 
Alias (byte) rem8u#10 = (byte) rem8u#25 (byte) rem8u#61 (byte) rem8u#58 (byte) rem8u#53 (byte) rem8u#46 (byte) rem8u#37 (byte) rem8u#26 (byte) rem8u#47 (byte) rem8u#38 (byte) rem8u#27 (byte) rem8u#11 
Alias (byte) test_8u::res#0 = (byte~) test_8u::$0 (byte) test_8u::res#4 (byte) test_8u::res#3 (byte) test_8u::res#2 (byte) test_8u::res#1 
Alias (byte*) print_char_cursor#29 = (byte*) print_char_cursor#93 
Alias (byte*) print_char_cursor#30 = (byte*) print_char_cursor#94 
Alias (byte*) print_char_cursor#31 = (byte*) print_char_cursor#95 
Alias (byte*) print_char_cursor#32 = (byte*) print_char_cursor#96 
Alias (byte*) print_char_cursor#33 = (byte*) print_char_cursor#97 
Alias (byte*) print_char_cursor#34 = (byte*) print_char_cursor#98 
Alias (byte*) print_char_cursor#35 = (byte*) print_char_cursor#99 
Alias (byte*) print_line_cursor#11 = (byte*) print_line_cursor#30 (byte*) print_line_cursor#31 (byte*) print_line_cursor#12 
Alias (byte*) print_char_cursor#100 = (byte*) print_char_cursor#36 (byte*) print_char_cursor#101 (byte*) print_char_cursor#37 
Alias (word) div16u::return#2 = (word) div16u::return#4 
Alias (word) test_16u::dividend#0 = (word) test_16u::dividend#1 
Alias (byte*) print_char_cursor#142 = (byte*) print_char_cursor#150 
Alias (word) test_16u::divisor#0 = (word) test_16u::divisor#3 (word) test_16u::divisor#2 (word) test_16u::divisor#1 
Alias (byte*) print_line_cursor#42 = (byte*) print_line_cursor#75 (byte*) print_line_cursor#79 (byte*) print_line_cursor#71 (byte*) print_line_cursor#67 (byte*) print_line_cursor#63 (byte*) print_line_cursor#58 (byte*) print_line_cursor#53 (byte*) print_line_cursor#47 
Alias (byte) test_16u::i#10 = (byte) test_16u::i#11 (byte) test_16u::i#2 (byte) test_16u::i#9 (byte) test_16u::i#8 (byte) test_16u::i#7 (byte) test_16u::i#6 (byte) test_16u::i#5 (byte) test_16u::i#4 (byte) test_16u::i#3 
Alias (word) rem16u#12 = (word) rem16u#29 (word) rem16u#65 (word) rem16u#62 (word) rem16u#58 (word) rem16u#50 (word) rem16u#41 (word) rem16u#30 (word) rem16u#51 (word) rem16u#42 (word) rem16u#31 (word) rem16u#13 
Alias (word) test_16u::res#0 = (word~) test_16u::$0 (word) test_16u::res#4 (word) test_16u::res#3 (word) test_16u::res#2 (word) test_16u::res#1 
Alias (byte*) print_char_cursor#102 = (byte*) print_char_cursor#38 
Alias (byte*) print_char_cursor#103 = (byte*) print_char_cursor#39 
Alias (byte*) print_char_cursor#104 = (byte*) print_char_cursor#40 
Alias (byte*) print_char_cursor#105 = (byte*) print_char_cursor#41 
Alias (byte*) print_char_cursor#106 = (byte*) print_char_cursor#42 
Alias (byte*) print_char_cursor#107 = (byte*) print_char_cursor#43 
Alias (byte*) print_char_cursor#108 = (byte*) print_char_cursor#44 
Alias (byte*) print_line_cursor#13 = (byte*) print_line_cursor#32 (byte*) print_line_cursor#33 (byte*) print_line_cursor#14 
Alias (byte*) print_char_cursor#109 = (byte*) print_char_cursor#45 (byte*) print_char_cursor#110 (byte*) print_char_cursor#46 
Alias (signed byte) div8s::return#3 = (signed byte) div8s::return#5 
Alias (signed byte) test_8s::dividend#0 = (signed byte) test_8s::dividend#1 
Alias (byte*) print_char_cursor#143 = (byte*) print_char_cursor#151 
Alias (signed byte) test_8s::divisor#0 = (signed byte) test_8s::divisor#3 (signed byte) test_8s::divisor#2 (signed byte) test_8s::divisor#1 
Alias (byte*) print_line_cursor#43 = (byte*) print_line_cursor#76 (byte*) print_line_cursor#80 (byte*) print_line_cursor#72 (byte*) print_line_cursor#68 (byte*) print_line_cursor#64 (byte*) print_line_cursor#59 (byte*) print_line_cursor#54 (byte*) print_line_cursor#48 
Alias (byte) test_8s::i#10 = (byte) test_8s::i#11 (byte) test_8s::i#2 (byte) test_8s::i#9 (byte) test_8s::i#8 (byte) test_8s::i#7 (byte) test_8s::i#6 (byte) test_8s::i#5 (byte) test_8s::i#4 (byte) test_8s::i#3 
Alias (byte) rem8u#12 = (byte) rem8u#28 (byte) rem8u#65 (byte) rem8u#64 (byte) rem8u#63 (byte) rem8u#62 (byte) rem8u#59 (byte) rem8u#54 (byte) rem8u#49 (byte) rem8u#40 (byte) rem8u#29 (byte) rem8u#13 
Alias (signed byte) rem8s#12 = (signed byte) rem8s#6 (signed byte) rem8s#31 (signed byte) rem8s#30 (signed byte) rem8s#28 (signed byte) rem8s#24 (signed byte) rem8s#19 (signed byte) rem8s#13 (signed byte) rem8s#25 (signed byte) rem8s#20 (signed byte) rem8s#14 (signed byte) rem8s#7 
Alias (signed byte) test_8s::res#0 = (signed byte~) test_8s::$0 (signed byte) test_8s::res#4 (signed byte) test_8s::res#3 (signed byte) test_8s::res#2 (signed byte) test_8s::res#1 
Alias (byte*) print_char_cursor#111 = (byte*) print_char_cursor#47 
Alias (byte*) print_char_cursor#112 = (byte*) print_char_cursor#48 
Alias (byte*) print_char_cursor#113 = (byte*) print_char_cursor#49 
Alias (byte*) print_char_cursor#114 = (byte*) print_char_cursor#50 
Alias (byte*) print_char_cursor#115 = (byte*) print_char_cursor#51 
Alias (byte*) print_char_cursor#116 = (byte*) print_char_cursor#52 
Alias (byte*) print_char_cursor#117 = (byte*) print_char_cursor#53 
Alias (byte*) print_line_cursor#15 = (byte*) print_line_cursor#34 (byte*) print_line_cursor#35 (byte*) print_line_cursor#16 
Alias (byte*) print_char_cursor#118 = (byte*) print_char_cursor#54 (byte*) print_char_cursor#119 (byte*) print_char_cursor#55 
Alias (signed word) div16s::return#2 = (signed word) div16s::return#4 
Alias (signed word) test_16s::dividend#0 = (signed word) test_16s::dividend#1 
Alias (byte*) print_char_cursor#144 = (byte*) print_char_cursor#152 
Alias (signed word) test_16s::divisor#0 = (signed word) test_16s::divisor#3 (signed word) test_16s::divisor#2 (signed word) test_16s::divisor#1 
Alias (byte*) print_line_cursor#44 = (byte*) print_line_cursor#77 (byte*) print_line_cursor#81 (byte*) print_line_cursor#73 (byte*) print_line_cursor#69 (byte*) print_line_cursor#65 (byte*) print_line_cursor#60 (byte*) print_line_cursor#55 (byte*) print_line_cursor#49 
Alias (byte) test_16s::i#10 = (byte) test_16s::i#11 (byte) test_16s::i#2 (byte) test_16s::i#9 (byte) test_16s::i#8 (byte) test_16s::i#7 (byte) test_16s::i#6 (byte) test_16s::i#5 (byte) test_16s::i#4 (byte) test_16s::i#3 
Alias (word) rem16u#14 = (word) rem16u#32 (word) rem16u#69 (word) rem16u#68 (word) rem16u#67 (word) rem16u#66 (word) rem16u#63 (word) rem16u#59 (word) rem16u#53 (word) rem16u#44 (word) rem16u#33 (word) rem16u#15 
Alias (signed word) rem16s#16 = (signed word) rem16s#8 (signed word) rem16s#35 (signed word) rem16s#33 (signed word) rem16s#31 (signed word) rem16s#28 (signed word) rem16s#23 (signed word) rem16s#17 (signed word) rem16s#29 (signed word) rem16s#24 (signed word) rem16s#18 (signed word) rem16s#9 
Alias (signed word) test_16s::res#0 = (signed word~) test_16s::$0 (signed word) test_16s::res#4 (signed word) test_16s::res#3 (signed word) test_16s::res#2 (signed word) test_16s::res#1 
Alias (byte*) print_char_cursor#120 = (byte*) print_char_cursor#56 
Alias (byte*) print_char_cursor#121 = (byte*) print_char_cursor#57 
Alias (byte*) print_char_cursor#122 = (byte*) print_char_cursor#58 
Alias (byte*) print_char_cursor#123 = (byte*) print_char_cursor#59 
Alias (byte*) print_char_cursor#124 = (byte*) print_char_cursor#60 
Alias (byte*) print_char_cursor#125 = (byte*) print_char_cursor#61 
Alias (byte*) print_char_cursor#126 = (byte*) print_char_cursor#62 
Alias (byte*) print_line_cursor#17 = (byte*) print_line_cursor#36 (byte*) print_line_cursor#37 (byte*) print_line_cursor#18 
Alias (byte*) print_char_cursor#127 = (byte*) print_char_cursor#63 (byte*) print_char_cursor#128 (byte*) print_char_cursor#64 
Alias (signed word) rem16s#0 = (signed word) rem16s#25 
Alias (byte*) print_line_cursor#19 = (byte*) print_line_cursor#38 
Alias (byte*) print_char_cursor#129 = (byte*) print_char_cursor#65 
Alias (byte) rem8u#14 = (byte) rem8u#30 
Alias (word) rem16u#16 = (word) rem16u#34 
Alias (signed byte) rem8s#15 = (signed byte) rem8s#8 
Alias (signed word) rem16s#10 = (signed word) rem16s#19 
Successful SSA optimization Pass2AliasElimination
Alias (byte) divr8u::dividend#2 = (byte) divr8u::dividend#3 
Alias (byte) divr8u::quotient#3 = (byte) divr8u::quotient#6 
Alias (byte) divr8u::divisor#1 = (byte) divr8u::divisor#3 (byte) divr8u::divisor#6 
Alias (byte) divr8u::i#2 = (byte) divr8u::i#3 (byte) divr8u::i#5 
Alias (byte) divr8u::dividend#1 = (byte) divr8u::dividend#5 
Alias (word) divr16u::dividend#3 = (word) divr16u::dividend#4 
Alias (word) divr16u::quotient#3 = (word) divr16u::quotient#6 
Alias (word) divr16u::divisor#2 = (word) divr16u::divisor#4 (word) divr16u::divisor#7 
Alias (byte) divr16u::i#2 = (byte) divr16u::i#3 (byte) divr16u::i#5 
Alias (word) divr16u::dividend#0 = (word) divr16u::dividend#6 
Alias (signed byte) div8s::divisor#1 = (signed byte) div8s::divisor#4 
Alias (byte) rem8u#32 = (byte) rem8u#42 (byte) rem8u#56 
Alias (byte) div8s::dividendu#3 = (byte) div8s::dividendu#4 
Alias (byte) rem8u#18 = (byte) rem8u#21 
Alias (signed word) divr16s::divisor#1 = (signed word) divr16s::divisor#4 
Alias (word) rem16u#36 = (word) rem16u#46 (word) rem16u#60 
Alias (word) divr16s::dividendu#3 = (word) divr16s::dividendu#4 
Alias (word) divr16s::remu#3 = (word) divr16s::remu#4 
Alias (word) rem16u#20 = (word) rem16u#23 
Successful SSA optimization Pass2AliasElimination
Identical Phi Values (word) memset::num#1 (word) memset::num#0
Identical Phi Values (void*) memset::str#2 (void*) memset::str#0
Identical Phi Values (byte) memset::c#3 (byte) memset::c#0
Identical Phi Values (byte*) memset::end#1 (byte*) memset::end#0
Identical Phi Values (void*) memset::str#4 (void*) memset::str#2
Identical Phi Values (byte) memset::c#1 (byte) memset::c#3
Identical Phi Values (byte*) print_char_cursor#68 (byte*) print_char_cursor#131
Identical Phi Values (byte*) print_char_cursor#5 (byte*) print_char_cursor#19
Identical Phi Values (byte*) print_char_cursor#6 (byte*) print_char_cursor#19
Identical Phi Values (byte*) print_char_cursor#7 (byte*) print_char_cursor#14
Identical Phi Values (byte*) print_char_cursor#74 (byte*) print_char_cursor#19
Identical Phi Values (byte*) print_char_cursor#10 (byte*) print_char_cursor#19
Identical Phi Values (byte*) print_char_cursor#11 (byte*) print_char_cursor#17
Identical Phi Values (byte*) print_char_cursor#13 (byte*) print_char_cursor#17
Identical Phi Values (byte*) print_char_cursor#14 (byte*) print_char_cursor#17
Identical Phi Values (byte*) print_char_cursor#16 (byte*) print_char_cursor#19
Identical Phi Values (byte*) print_char_cursor#17 (byte*) print_char_cursor#19
Identical Phi Values (byte*) print_line_cursor#23 (byte*) print_screen#3
Identical Phi Values (byte) rem8u#1 (byte) rem8u#17
Identical Phi Values (byte) divr8u::rem#9 (byte) divr8u::rem#0
Identical Phi Values (byte) divr8u::dividend#4 (byte) divr8u::dividend#0
Identical Phi Values (byte) divr8u::divisor#5 (byte) divr8u::divisor#0
Identical Phi Values (byte) divr8u::divisor#1 (byte) divr8u::divisor#5
Identical Phi Values (word) divr16u::divisor#2 (word) divr16u::divisor#6
Identical Phi Values (word) div16u::dividend#1 (word) div16u::dividend#0
Identical Phi Values (word) div16u::divisor#1 (word) div16u::divisor#0
Identical Phi Values (word) rem16u#35 (word) rem16u#40
Identical Phi Values (word) rem16u#18 (word) rem16u#1
Identical Phi Values (signed byte) div8s::dividend#1 (signed byte) div8s::dividend#0
Identical Phi Values (signed byte) div8s::divisor#1 (signed byte) div8s::divisor#0
Identical Phi Values (byte) rem8u#32 (byte) rem8u#39
Identical Phi Values (byte) rem8u#18 (byte) rem8u#1
Identical Phi Values (signed word) divr16s::dividend#1 (signed word) divr16s::dividend#0
Identical Phi Values (signed word) divr16s::rem#1 (signed word) divr16s::rem#0
Identical Phi Values (signed word) divr16s::divisor#1 (signed word) divr16s::divisor#0
Identical Phi Values (word) rem16u#36 (word) rem16u#37
Identical Phi Values (word) rem16u#20 (word) rem16u#1
Identical Phi Values (signed word) div16s::dividend#1 (signed word) div16s::dividend#0
Identical Phi Values (signed word) div16s::divisor#1 (signed word) div16s::divisor#0
Identical Phi Values (word) rem16u#37 (word) rem16u#43
Identical Phi Values (signed word) rem16s#20 (signed word) rem16s#22
Identical Phi Values (word) rem16u#24 (word) rem16u#20
Identical Phi Values (signed word) rem16s#12 (signed word) rem16s#11
Identical Phi Values (byte*) print_screen#3 (byte*) print_line_cursor#0
Identical Phi Values (byte*) print_line_cursor#40 (byte*) print_line_cursor#0
Identical Phi Values (byte*) print_char_cursor#140 (byte*) print_line_cursor#0
Identical Phi Values (byte) rem8u#33 (byte) rem8u#0
Identical Phi Values (word) rem16u#38 (word) rem16u#0
Identical Phi Values (signed byte) rem8s#16 (signed byte) rem8s#0
Identical Phi Values (signed word) rem16s#21 (signed word) rem16s#0
Identical Phi Values (byte*) print_line_cursor#24 (byte*) print_line_cursor#23
Identical Phi Values (byte*) print_char_cursor#23 (byte*) print_line_cursor#23
Identical Phi Values (byte) rem8u#22 (byte) rem8u#10
Identical Phi Values (byte*) print_char_cursor#24 (byte*) print_char_cursor#100
Identical Phi Values (byte*) print_line_cursor#25 (byte*) print_line_cursor#11
Identical Phi Values (word) rem16u#26 (word) rem16u#12
Identical Phi Values (byte*) print_char_cursor#25 (byte*) print_char_cursor#109
Identical Phi Values (byte*) print_line_cursor#26 (byte*) print_line_cursor#13
Identical Phi Values (byte) rem8u#23 (byte) rem8u#12
Identical Phi Values (signed byte) rem8s#10 (signed byte) rem8s#12
Identical Phi Values (byte*) print_char_cursor#26 (byte*) print_char_cursor#118
Identical Phi Values (byte*) print_line_cursor#27 (byte*) print_line_cursor#15
Identical Phi Values (word) rem16u#10 (word) rem16u#14
Identical Phi Values (signed word) rem16s#14 (signed word) rem16s#16
Identical Phi Values (byte*) print_char_cursor#27 (byte*) print_char_cursor#127
Identical Phi Values (byte*) print_line_cursor#10 (byte*) print_line_cursor#17
Identical Phi Values (byte) rem8u#45 (byte) rem8u#33
Identical Phi Values (byte*) print_char_cursor#155 (byte*) print_char_cursor#23
Identical Phi Values (byte*) print_line_cursor#82 (byte*) print_line_cursor#24
Identical Phi Values (byte) rem8u#10 (byte) rem8u#1
Identical Phi Values (byte*) print_char_cursor#29 (byte*) print_char_cursor#17
Identical Phi Values (byte*) print_char_cursor#30 (byte*) print_char_cursor#130
Identical Phi Values (byte*) print_char_cursor#31 (byte*) print_char_cursor#17
Identical Phi Values (byte*) print_char_cursor#32 (byte*) print_char_cursor#130
Identical Phi Values (byte*) print_char_cursor#33 (byte*) print_char_cursor#17
Identical Phi Values (byte*) print_char_cursor#34 (byte*) print_char_cursor#130
Identical Phi Values (byte*) print_char_cursor#35 (byte*) print_char_cursor#17
Identical Phi Values (byte*) print_line_cursor#11 (byte*) print_line_cursor#1
Identical Phi Values (byte*) print_char_cursor#100 (byte*) print_line_cursor#1
Identical Phi Values (word) rem16u#49 (word) rem16u#38
Identical Phi Values (byte*) print_char_cursor#156 (byte*) print_char_cursor#24
Identical Phi Values (byte*) print_line_cursor#83 (byte*) print_line_cursor#25
Identical Phi Values (word) rem16u#12 (word) rem16u#18
Identical Phi Values (byte*) print_char_cursor#102 (byte*) print_char_cursor#14
Identical Phi Values (byte*) print_char_cursor#103 (byte*) print_char_cursor#130
Identical Phi Values (byte*) print_char_cursor#104 (byte*) print_char_cursor#14
Identical Phi Values (byte*) print_char_cursor#105 (byte*) print_char_cursor#130
Identical Phi Values (byte*) print_char_cursor#106 (byte*) print_char_cursor#14
Identical Phi Values (byte*) print_char_cursor#107 (byte*) print_char_cursor#130
Identical Phi Values (byte*) print_char_cursor#108 (byte*) print_char_cursor#14
Identical Phi Values (byte*) print_line_cursor#13 (byte*) print_line_cursor#1
Identical Phi Values (byte*) print_char_cursor#109 (byte*) print_line_cursor#1
Identical Phi Values (byte) rem8u#48 (byte) rem8u#22
Identical Phi Values (signed byte) rem8s#23 (signed byte) rem8s#16
Identical Phi Values (byte*) print_char_cursor#157 (byte*) print_char_cursor#25
Identical Phi Values (byte*) print_line_cursor#84 (byte*) print_line_cursor#26
Identical Phi Values (byte) rem8u#12 (byte) rem8u#18
Identical Phi Values (signed byte) rem8s#12 (signed byte) rem8s#3
Identical Phi Values (byte*) print_char_cursor#111 (byte*) print_char_cursor#11
Identical Phi Values (byte*) print_char_cursor#112 (byte*) print_char_cursor#130
Identical Phi Values (byte*) print_char_cursor#113 (byte*) print_char_cursor#11
Identical Phi Values (byte*) print_char_cursor#114 (byte*) print_char_cursor#130
Identical Phi Values (byte*) print_char_cursor#115 (byte*) print_char_cursor#11
Identical Phi Values (byte*) print_char_cursor#116 (byte*) print_char_cursor#130
Identical Phi Values (byte*) print_char_cursor#117 (byte*) print_char_cursor#11
Identical Phi Values (byte*) print_line_cursor#15 (byte*) print_line_cursor#1
Identical Phi Values (byte*) print_char_cursor#118 (byte*) print_line_cursor#1
Identical Phi Values (word) rem16u#52 (word) rem16u#26
Identical Phi Values (signed word) rem16s#27 (signed word) rem16s#21
Identical Phi Values (byte*) print_char_cursor#158 (byte*) print_char_cursor#26
Identical Phi Values (byte*) print_line_cursor#85 (byte*) print_line_cursor#27
Identical Phi Values (word) rem16u#14 (word) rem16u#24
Identical Phi Values (signed word) rem16s#16 (signed word) rem16s#12
Identical Phi Values (byte*) print_char_cursor#120 (byte*) print_char_cursor#7
Identical Phi Values (byte*) print_char_cursor#121 (byte*) print_char_cursor#130
Identical Phi Values (byte*) print_char_cursor#122 (byte*) print_char_cursor#7
Identical Phi Values (byte*) print_char_cursor#123 (byte*) print_char_cursor#130
Identical Phi Values (byte*) print_char_cursor#124 (byte*) print_char_cursor#7
Identical Phi Values (byte*) print_char_cursor#125 (byte*) print_char_cursor#130
Identical Phi Values (byte*) print_char_cursor#126 (byte*) print_char_cursor#7
Identical Phi Values (byte*) print_line_cursor#17 (byte*) print_line_cursor#1
Identical Phi Values (byte*) print_char_cursor#127 (byte*) print_line_cursor#1
Identical Phi Values (byte*) print_line_cursor#19 (byte*) print_line_cursor#10
Identical Phi Values (byte*) print_char_cursor#129 (byte*) print_char_cursor#27
Identical Phi Values (byte) rem8u#14 (byte) rem8u#23
Identical Phi Values (word) rem16u#16 (word) rem16u#10
Identical Phi Values (signed byte) rem8s#15 (signed byte) rem8s#10
Identical Phi Values (signed word) rem16s#10 (signed word) rem16s#14
Successful SSA optimization Pass2IdenticalPhiElimination
Identical Phi Values (void*) memset::return#0 (void*) memset::str#0
Identical Phi Values (byte*) print_char_cursor#146 (byte*) print_char_cursor#19
Identical Phi Values (byte*) print_char_cursor#131 (byte*) print_char_cursor#19
Identical Phi Values (byte*) print_char_cursor#134 (byte*) print_char_cursor#19
Identical Phi Values (byte*) print_char_cursor#137 (byte*) print_char_cursor#19
Identical Phi Values (byte*) print_char_cursor#142 (byte*) print_line_cursor#1
Identical Phi Values (byte*) print_line_cursor#42 (byte*) print_line_cursor#1
Identical Phi Values (byte) rem8u#39 (byte) rem8u#17
Identical Phi Values (byte*) print_char_cursor#143 (byte*) print_line_cursor#1
Identical Phi Values (byte*) print_line_cursor#43 (byte*) print_line_cursor#1
Identical Phi Values (word) rem16u#43 (word) rem16u#1
Identical Phi Values (byte*) print_char_cursor#144 (byte*) print_line_cursor#1
Identical Phi Values (byte*) print_line_cursor#44 (byte*) print_line_cursor#1
Successful SSA optimization Pass2IdenticalPhiElimination
Identified duplicate assignment right side [476] (byte~) test_16u::$11 ← (byte) test_16u::i#10 * (const byte) SIZEOF_WORD
Identified duplicate assignment right side [586] (byte~) test_16s::$11 ← (byte) test_16s::i#10 * (const byte) SIZEOF_SIGNED_WORD
Successful SSA optimization Pass2DuplicateRValueIdentification
Simple Condition (bool~) memset::$1 [3] if((word) memset::num#0<=(byte) 0) goto memset::@1
Simple Condition (bool~) memset::$4 [13] if((byte*) memset::dst#2!=(byte*) memset::end#0) goto memset::@5
Simple Condition (bool~) print_str::$0 [26] if((byte) 0!=*((byte*) print_str::str#13)) goto print_str::@2
Simple Condition (bool~) print_ln::$1 [39] if((byte*) print_line_cursor#1<(byte*) print_char_cursor#19) goto print_ln::@1
Simple Condition (bool~) print_sword::$0 [48] if((signed word) print_sword::w#10<(signed byte) 0) goto print_sword::@1
Simple Condition (bool~) print_sbyte::$0 [72] if((signed byte) print_sbyte::b#10<(signed byte) 0) goto print_sbyte::@1
Simple Condition (bool~) divr8u::$3 [166] if((byte~) divr8u::$1==(byte) 0) goto divr8u::@2
Simple Condition (bool~) divr8u::$8 [174] if((byte) divr8u::rem#5<(byte) divr8u::divisor#0) goto divr8u::@3
Simple Condition (bool~) divr8u::$10 [181] if((byte) divr8u::i#1!=rangelast(0,7)) goto divr8u::@1
Simple Condition (bool~) divr16u::$4 [205] if((byte~) divr16u::$2==(byte) 0) goto divr16u::@2
Simple Condition (bool~) divr16u::$9 [213] if((word) divr16u::rem#6<(word) divr16u::divisor#6) goto divr16u::@3
Simple Condition (bool~) divr16u::$11 [220] if((byte) divr16u::i#1!=rangelast(0,$f)) goto divr16u::@1
Simple Condition (bool~) div8s::$0 [252] if((signed byte) div8s::dividend#0<(signed byte) 0) goto div8s::@1
Simple Condition (bool~) div8s::$1 [264] if((signed byte) div8s::divisor#0<(signed byte) 0) goto div8s::@3
Simple Condition (bool~) div8s::$3 [284] if((byte) div8s::neg#4==(byte) 0) goto div8s::@5
Simple Condition (bool~) divr16s::$3 [328] if((signed word) divr16s::divisor#0<(signed byte) 0) goto divr16s::@3
Simple Condition (bool~) divr16s::$5 [349] if((byte) divr16s::neg#4==(byte) 0) goto divr16s::@5
Simple Condition (bool~) test_8u::$9 [465] if((byte) test_8u::i#1!=rangelast(0,5)) goto test_8u::@1
Simple Condition (bool~) test_16u::$9 [520] if((byte) test_16u::i#1!=rangelast(0,5)) goto test_16u::@1
Simple Condition (bool~) test_8s::$9 [574] if((byte) test_8s::i#1!=rangelast(0,5)) goto test_8s::@1
Simple Condition (bool~) test_16s::$9 [631] if((byte) test_16s::i#1!=rangelast(0,5)) goto test_16s::@1
Successful SSA optimization Pass2ConditionalJumpSimplification
Rewriting || if()-condition to two if()s [310] (bool~) divr16s::$2 ← (bool~) divr16s::$0 || (bool~) divr16s::$1
Successful SSA optimization Pass2ConditionalAndOrRewriting
Constant (const byte*) print_line_cursor#0 = (byte*) 1024
Constant (const byte) print_char::ch#0 = '-'
Constant (const byte) print_char::ch#1 = ' '
Constant (const byte) print_char::ch#2 = '-'
Constant (const byte) print_char::ch#3 = ' '
Constant (const byte) memset::c#0 = ' '
Constant (const word) memset::num#0 = $3e8
Constant (const byte) rem8u#0 = 0
Constant (const byte) divr8u::rem#0 = 0
Constant (const byte) divr8u::quotient#0 = 0
Constant (const byte) divr8u::i#0 = 0
Constant (const word) rem16u#0 = 0
Constant (const word) divr16u::quotient#0 = 0
Constant (const byte) divr16u::i#0 = 0
Constant (const word) divr16u::rem#3 = 0
Constant (const signed byte) rem8s#0 = 0
Constant (const byte) div8s::neg#0 = 0
Constant (const byte) div8s::dividendu#0 = 0
Constant (const byte) div8s::neg#1 = 1
Constant (const byte) div8s::divisoru#0 = 0
Constant (const signed word) rem16s#0 = 0
Constant (const byte) divr16s::neg#0 = 0
Constant (const word) divr16s::dividendu#0 = 0
Constant (const word) divr16s::remu#0 = 0
Constant (const byte) divr16s::neg#1 = 1
Constant (const word) divr16s::divisoru#0 = 0
Constant (const signed word) divr16s::rem#0 = 0
Constant (const byte) test_8u::i#0 = 0
Constant (const byte*) print_str::str#1 = test_8u::str
Constant (const byte*) print_str::str#2 = test_8u::str1
Constant (const byte*) print_str::str#3 = test_8u::str2
Constant (const byte) test_16u::i#0 = 0
Constant (const byte*) print_str::str#4 = test_16u::str
Constant (const byte*) print_str::str#5 = test_16u::str1
Constant (const byte*) print_str::str#6 = test_16u::str2
Constant (const byte) test_8s::i#0 = 0
Constant (const byte*) print_str::str#7 = test_8s::str
Constant (const byte*) print_str::str#8 = test_8s::str1
Constant (const byte*) print_str::str#9 = test_8s::str2
Constant (const byte) test_16s::i#0 = 0
Constant (const byte*) print_str::str#10 = test_16s::str
Constant (const byte*) print_str::str#11 = test_16s::str1
Constant (const byte*) print_str::str#12 = test_16s::str2
Successful SSA optimization Pass2ConstantIdentification
Constant (const void*) memset::str#0 = (void*)print_line_cursor#0
Constant (const word) divr16s::remu#2 = (word)divr16s::rem#0
Successful SSA optimization Pass2ConstantIdentification
Constant (const byte*) memset::$2 = (byte*)memset::str#0
Constant (const byte*) memset::dst#0 = (byte*)memset::str#0
Constant (const void*) memset::return#2 = memset::str#0
Successful SSA optimization Pass2ConstantIdentification
if() condition always false - eliminating [3] if((const word) memset::num#0<=(byte) 0) goto memset::@1
Successful SSA optimization Pass2ConstantIfs
Successful SSA optimization Pass2ConstantStringConsolidation
Resolved ranged next value [179] divr8u::i#1 ← ++ divr8u::i#2 to ++
Resolved ranged comparison value [181] if(divr8u::i#1!=rangelast(0,7)) goto divr8u::@1 to (number) 8
Resolved ranged next value [218] divr16u::i#1 ← ++ divr16u::i#2 to ++
Resolved ranged comparison value [220] if(divr16u::i#1!=rangelast(0,$f)) goto divr16u::@1 to (number) $10
Resolved ranged next value [463] test_8u::i#1 ← ++ test_8u::i#10 to ++
Resolved ranged comparison value [465] if(test_8u::i#1!=rangelast(0,5)) goto test_8u::@1 to (number) 6
Resolved ranged next value [518] test_16u::i#1 ← ++ test_16u::i#10 to ++
Resolved ranged comparison value [520] if(test_16u::i#1!=rangelast(0,5)) goto test_16u::@1 to (number) 6
Resolved ranged next value [572] test_8s::i#1 ← ++ test_8s::i#10 to ++
Resolved ranged comparison value [574] if(test_8s::i#1!=rangelast(0,5)) goto test_8s::@1 to (number) 6
Resolved ranged next value [629] test_16s::i#1 ← ++ test_16s::i#10 to ++
Resolved ranged comparison value [631] if(test_16s::i#1!=rangelast(0,5)) goto test_16s::@1 to (number) 6
Simplifying constant evaluating to zero (word)(const signed word) divr16s::rem#0 in 
Successful SSA optimization PassNSimplifyConstantZero
Eliminating unused variable - keeping the phi block (byte) rem8u#31
Eliminating unused variable - keeping the phi block (word) rem16u#40
Eliminating unused variable - keeping the phi block (signed byte) rem8s#18
Eliminating unused variable - keeping the phi block (signed word) rem16s#22
Eliminating unused constant (const void*) memset::return#2
Eliminating unused constant (const byte) div8s::dividendu#0
Eliminating unused constant (const byte) div8s::divisoru#0
Eliminating unused constant (const word) divr16s::dividendu#0
Eliminating unused constant (const word) divr16s::remu#0
Eliminating unused constant (const word) divr16s::divisoru#0
Successful SSA optimization PassNEliminateUnusedVars
Eliminating unused variable - keeping the phi block (byte) rem8u#36
Eliminating unused constant (const word) rem16u#0
Eliminating unused constant (const signed byte) rem8s#0
Eliminating unused constant (const signed word) rem16s#0
Successful SSA optimization PassNEliminateUnusedVars
Eliminating unused constant (const byte) rem8u#0
Successful SSA optimization PassNEliminateUnusedVars
Adding number conversion cast (unumber) 8 in if((byte) divr8u::i#1!=(number) 8) goto divr8u::@1
Adding number conversion cast (unumber) $10 in if((byte) divr16u::i#1!=(number) $10) goto divr16u::@1
Adding number conversion cast (unumber) 6 in if((byte) test_8u::i#1!=(number) 6) goto test_8u::@1
Adding number conversion cast (unumber) 6 in if((byte) test_16u::i#1!=(number) 6) goto test_16u::@1
Adding number conversion cast (unumber) 6 in if((byte) test_8s::i#1!=(number) 6) goto test_8s::@1
Adding number conversion cast (unumber) 6 in if((byte) test_16s::i#1!=(number) 6) goto test_16s::@1
Successful SSA optimization PassNAddNumberTypeConversions
Simplifying constant integer cast 8
Simplifying constant integer cast $10
Simplifying constant integer cast 6
Simplifying constant integer cast 6
Simplifying constant integer cast 6
Simplifying constant integer cast 6
Successful SSA optimization PassNCastSimplification
Finalized unsigned number type (byte) 8
Finalized unsigned number type (byte) $10
Finalized unsigned number type (byte) 6
Finalized unsigned number type (byte) 6
Finalized unsigned number type (byte) 6
Finalized unsigned number type (byte) 6
Successful SSA optimization PassNFinalizeNumberTypeConversions
Alias (byte~) test_16u::$11 = (byte~) test_16u::$10 
Alias (byte~) test_16s::$11 = (byte~) test_16s::$10 
Successful SSA optimization Pass2AliasElimination
Simple Condition (bool~) divr16s::$0 [130] if((signed word) divr16s::dividend#0<(signed byte) 0) goto divr16s::@1
Simple Condition (bool~) divr16s::$1 [267] if((const signed word) divr16s::rem#0<(signed byte) 0) goto divr16s::@1
Successful SSA optimization Pass2ConditionalJumpSimplification
Constant right-side identified [0] (byte*) memset::end#0 ← (const byte*) memset::$2 + (const word) memset::num#0
Constant right-side identified [133] (signed word~) divr16s::$10 ← - (const signed word) divr16s::rem#0
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte*) memset::end#0 = memset::$2+memset::num#0
Constant (const signed word) divr16s::$10 = -divr16s::rem#0
Successful SSA optimization Pass2ConstantIdentification
Constant (const word) divr16s::remu#1 = (word)divr16s::$10
Successful SSA optimization Pass2ConstantIdentification
if() condition always false - eliminating [267] if((const signed word) divr16s::rem#0<(signed byte) 0) goto divr16s::@1
Successful SSA optimization Pass2ConstantIfs
Simplifying constant evaluating to zero -(const signed word) divr16s::rem#0 in 
Simplifying constant evaluating to zero (word)(const signed word) divr16s::$10 in 
Successful SSA optimization PassNSimplifyConstantZero
Eliminating unused constant (const signed word) divr16s::rem#0
Eliminating unused constant (const signed word) divr16s::$10
Successful SSA optimization PassNEliminateUnusedVars
Inlining Noop Cast [104] (byte) div8s::dividendu#1 ← (byte)(signed byte~) div8s::$5 keeping div8s::dividendu#1
Inlining Noop Cast [109] (byte) div8s::divisoru#1 ← (byte)(signed byte~) div8s::$8 keeping div8s::divisoru#1
Inlining Noop Cast [129] (word) divr16s::dividendu#1 ← (word)(signed word~) divr16s::$8 keeping divr16s::dividendu#1
Inlining Noop Cast [134] (word) divr16s::divisoru#1 ← (word)(signed word~) divr16s::$13 keeping divr16s::divisoru#1
Successful SSA optimization Pass2NopCastInlining
Inlining Noop Cast [105] (byte) div8s::dividendu#2 ← (byte)(signed byte) div8s::dividend#0 keeping div8s::dividend#0
Inlining Noop Cast [111] (byte) div8s::divisoru#2 ← (byte)(signed byte) div8s::divisor#0 keeping div8s::divisor#0
Inlining Noop Cast [119] (signed byte) rem8s#1 ← (signed byte)(byte) rem8u#17 keeping rem8u#17
Inlining Noop Cast [120] (signed byte) div8s::return#0 ← (signed byte)(byte) div8s::resultu#0 keeping div8s::resultu#0
Inlining Noop Cast [123] (signed byte~) div8s::$13 ← (signed byte)(byte) div8s::resultu#0 keeping div8s::resultu#0
Inlining Noop Cast [130] (word) divr16s::dividendu#2 ← (word)(signed word) divr16s::dividend#0 keeping divr16s::dividend#0
Inlining Noop Cast [136] (word) divr16s::divisoru#2 ← (word)(signed word) divr16s::divisor#0 keeping divr16s::divisor#0
Inlining Noop Cast [145] (signed word) rem16s#1 ← (signed word)(word) rem16u#1 keeping rem16u#1
Inlining Noop Cast [146] (signed word) divr16s::return#0 ← (signed word)(word) divr16s::resultu#0 keeping divr16s::resultu#0
Inlining Noop Cast [149] (signed word~) divr16s::$18 ← (signed word)(word) divr16s::resultu#0 keeping divr16s::resultu#0
Successful SSA optimization Pass2NopCastInlining
Rewriting multiplication to use shift [189] (byte~) test_16u::$11 ← (byte) test_16u::i#10 * (const byte) SIZEOF_WORD
Rewriting multiplication to use shift [236] (byte~) test_16s::$11 ← (byte) test_16s::i#10 * (const byte) SIZEOF_SIGNED_WORD
Successful SSA optimization Pass2MultiplyToShiftRewriting
Inlining constant with var siblings (const byte*) memset::dst#0
Inlining constant with var siblings (const byte*) print_str::str#1
Inlining constant with var siblings (const byte*) print_str::str#2
Inlining constant with var siblings (const byte*) print_str::str#3
Inlining constant with var siblings (const byte*) print_str::str#4
Inlining constant with var siblings (const byte*) print_str::str#5
Inlining constant with var siblings (const byte*) print_str::str#6
Inlining constant with var siblings (const byte*) print_str::str#7
Inlining constant with var siblings (const byte*) print_str::str#8
Inlining constant with var siblings (const byte*) print_str::str#9
Inlining constant with var siblings (const byte*) print_str::str#10
Inlining constant with var siblings (const byte*) print_str::str#11
Inlining constant with var siblings (const byte*) print_str::str#12
Inlining constant with var siblings (const byte) print_char::ch#0
Inlining constant with var siblings (const byte) print_char::ch#1
Inlining constant with var siblings (const byte) print_char::ch#2
Inlining constant with var siblings (const byte) print_char::ch#3
Inlining constant with var siblings (const byte) divr8u::rem#0
Inlining constant with var siblings (const byte) divr8u::quotient#0
Inlining constant with var siblings (const byte) divr8u::i#0
Inlining constant with var siblings (const word) divr16u::quotient#0
Inlining constant with var siblings (const byte) divr16u::i#0
Inlining constant with var siblings (const word) divr16u::rem#3
Inlining constant with var siblings (const byte) div8s::neg#0
Inlining constant with var siblings (const byte) div8s::neg#1
Inlining constant with var siblings (const byte) divr16s::neg#0
Inlining constant with var siblings (const byte) divr16s::neg#1
Inlining constant with var siblings (const word) divr16s::remu#2
Inlining constant with var siblings (const word) divr16s::remu#1
Inlining constant with var siblings (const byte) test_8u::i#0
Inlining constant with var siblings (const byte) test_16u::i#0
Inlining constant with var siblings (const byte) test_8s::i#0
Inlining constant with var siblings (const byte) test_16s::i#0
Inlining constant with var siblings (const byte*) print_line_cursor#0
Constant inlined divr16u::rem#3 = (byte) 0
Constant inlined test_16s::str = (const string) str
Constant inlined test_8s::str1 = (const string) str1
Constant inlined divr16u::i#0 = (byte) 0
Constant inlined test_8s::str2 = (const string) str2
Constant inlined print_str::str#12 = (const string) str2
Constant inlined print_str::str#11 = (const string) str1
Constant inlined print_str::str#10 = (const string) str
Constant inlined divr16s::neg#1 = (byte) 1
Constant inlined divr8u::i#0 = (byte) 0
Constant inlined divr16s::neg#0 = (byte) 0
Constant inlined test_16u::i#0 = (byte) 0
Constant inlined test_8u::str2 = (const string) str2
Constant inlined memset::$2 = (byte*)(const void*) memset::str#0
Constant inlined divr16u::quotient#0 = (word) 0
Constant inlined test_8u::str1 = (const string) str1
Constant inlined test_8u::i#0 = (byte) 0
Constant inlined test_8s::str = (const string) str
Constant inlined test_16s::str1 = (const string) str1
Constant inlined print_line_cursor#0 = (byte*) 1024
Constant inlined test_16s::str2 = (const string) str2
Constant inlined test_16s::i#0 = (byte) 0
Constant inlined divr8u::rem#0 = (byte) 0
Constant inlined print_char::ch#3 = (byte) ' '
Constant inlined divr8u::quotient#0 = (byte) 0
Constant inlined test_16u::str1 = (const string) str1
Constant inlined print_char::ch#2 = (byte) '-'
Constant inlined test_16u::str = (const string) str
Constant inlined print_str::str#9 = (const string) str2
Constant inlined test_16u::str2 = (const string) str2
Constant inlined print_char::ch#1 = (byte) ' '
Constant inlined print_char::ch#0 = (byte) '-'
Constant inlined print_str::str#4 = (const string) str
Constant inlined print_str::str#3 = (const string) str2
Constant inlined div8s::neg#1 = (byte) 1
Constant inlined print_str::str#2 = (const string) str1
Constant inlined memset::dst#0 = (byte*)(const void*) memset::str#0
Constant inlined div8s::neg#0 = (byte) 0
Constant inlined print_str::str#1 = (const string) str
Constant inlined print_str::str#8 = (const string) str1
Constant inlined print_str::str#7 = (const string) str
Constant inlined test_8u::str = (const string) str
Constant inlined print_str::str#6 = (const string) str2
Constant inlined divr16s::remu#1 = (word) 0
Constant inlined test_8s::i#0 = (byte) 0
Constant inlined print_str::str#5 = (const string) str1
Constant inlined divr16s::remu#2 = (word) 0
Successful SSA optimization Pass2ConstantInlining
Identical Phi Values (word) divr16s::remu#3 (word) 0
Successful SSA optimization Pass2IdenticalPhiElimination
Constant (const word) divr16u::rem#4 = 0
Successful SSA optimization Pass2ConstantIdentification
Eliminating unused constant (const byte) SIZEOF_WORD
Eliminating unused constant (const byte) SIZEOF_SIGNED_WORD
Successful SSA optimization PassNEliminateUnusedVars
Inlining constant with var siblings (const word) divr16u::rem#4
Constant inlined divr16u::rem#4 = (word) 0
Successful SSA optimization Pass2ConstantInlining
Identical Phi Values (word) divr16u::rem#10 (byte) 0
Successful SSA optimization Pass2IdenticalPhiElimination
Added new block during phi lifting print_ln::@3(between print_ln::@1 and print_ln::@1)
Added new block during phi lifting divr8u::@8(between divr8u::@3 and divr8u::@1)
Added new block during phi lifting divr8u::@9(between divr8u::@1 and divr8u::@2)
Added new block during phi lifting divr8u::@10(between divr8u::@2 and divr8u::@3)
Added new block during phi lifting divr16u::@8(between divr16u::@3 and divr16u::@1)
Added new block during phi lifting divr16u::@9(between divr16u::@1 and divr16u::@2)
Added new block during phi lifting divr16u::@10(between divr16u::@2 and divr16u::@3)
Added new block during phi lifting test_8u::@12(between test_8u::@11 and test_8u::@1)
Added new block during phi lifting test_16u::@12(between test_16u::@11 and test_16u::@1)
Added new block during phi lifting test_8s::@12(between test_8s::@11 and test_8s::@1)
Added new block during phi lifting test_16s::@12(between test_16s::@11 and test_16s::@1)
Adding NOP phi() at start of @begin
Adding NOP phi() at start of @13
Adding NOP phi() at start of @37
Adding NOP phi() at start of @39
Adding NOP phi() at start of @42
Adding NOP phi() at start of @43
Adding NOP phi() at start of @50
Adding NOP phi() at start of @51
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
Adding NOP phi() at start of main::@3
Adding NOP phi() at start of main::@4
Adding NOP phi() at start of main::@5
Adding NOP phi() at start of test_16s
Adding NOP phi() at start of test_16s::@4
Adding NOP phi() at start of test_16s::@6
Adding NOP phi() at start of test_16s::@8
Adding NOP phi() at start of print_ln::@2
Adding NOP phi() at start of print_sword::@7
Adding NOP phi() at start of print_word::@2
Adding NOP phi() at start of print_byte::@2
Adding NOP phi() at start of divr16s::@16
Adding NOP phi() at start of test_8s
Adding NOP phi() at start of test_8s::@4
Adding NOP phi() at start of test_8s::@6
Adding NOP phi() at start of test_8s::@8
Adding NOP phi() at start of print_sbyte::@7
Adding NOP phi() at start of test_16u
Adding NOP phi() at start of test_16u::@4
Adding NOP phi() at start of test_16u::@6
Adding NOP phi() at start of test_16u::@8
Adding NOP phi() at start of test_8u
Adding NOP phi() at start of test_8u::@4
Adding NOP phi() at start of test_8u::@6
Adding NOP phi() at start of test_8u::@8
Adding NOP phi() at start of print_cls
Adding NOP phi() at start of print_cls::@1
Adding NOP phi() at start of memset
Adding NOP phi() at start of memset::@2
Adding NOP phi() at start of memset::@1
CALL GRAPH
Calls in [] to main:7 
Calls in [main] to print_cls:11 test_8u:13 test_16u:15 test_8s:17 test_16s:19 
Calls in [test_16s] to div16s:29 print_sword:35 print_str:37 print_sword:41 print_str:43 print_sword:47 print_str:49 print_sword:53 print_ln:55 
Calls in [print_sword] to print_char:71 print_word:77 print_char:81 
Calls in [print_word] to print_byte:92 print_byte:96 
Calls in [print_byte] to print_char:104 print_char:109 
Calls in [div16s] to divr16s:125 
Calls in [divr16s] to divr16u:141 
Calls in [test_8s] to div8s:195 print_sbyte:201 print_str:203 print_sbyte:207 print_str:209 print_sbyte:213 print_str:215 print_sbyte:219 print_ln:221 
Calls in [print_sbyte] to print_char:229 print_byte:235 print_char:239 
Calls in [div8s] to div8u:253 
Calls in [div8u] to divr8u:275 
Calls in [test_16u] to div16u:313 print_word:319 print_str:321 print_word:325 print_str:327 print_word:331 print_str:333 print_word:337 print_ln:339 
Calls in [div16u] to divr16u:348 
Calls in [test_8u] to div8u:360 print_byte:366 print_str:368 print_byte:372 print_str:374 print_byte:378 print_str:380 print_byte:384 print_ln:386 
Calls in [print_cls] to memset:394 

Created 54 initial phi equivalence classes
Coalesced [33] print_sword::w#11 ← print_sword::w#1
Not coalescing [34] print_char_cursor#163 ← print_line_cursor#1
Coalesced [39] print_sword::w#12 ← print_sword::w#2
Coalesced [40] print_char_cursor#164 ← print_char_cursor#130
Coalesced [45] print_sword::w#13 ← print_sword::w#3
Coalesced (already) [46] print_char_cursor#165 ← print_char_cursor#130
Coalesced [51] print_sword::w#14 ← print_sword::w#4
Coalesced (already) [52] print_char_cursor#166 ← print_char_cursor#130
Coalesced [54] print_line_cursor#86 ← print_line_cursor#1
Coalesced [59] test_16s::i#12 ← test_16s::i#1
Coalesced [61] print_line_cursor#90 ← print_line_cursor#39
Coalesced (already) [67] print_line_cursor#91 ← print_line_cursor#1
Coalesced [70] print_char_cursor#188 ← print_char_cursor#132
Coalesced [72] print_sword::w#16 ← print_sword::w#10
Coalesced [75] print_word::w#7 ← print_word::w#0
Coalesced [76] print_char_cursor#171 ← print_char_cursor#19
Coalesced (already) [80] print_char_cursor#187 ← print_char_cursor#132
Coalesced [83] print_sword::w#15 ← print_sword::w#0
Coalesced [90] print_byte::b#10 ← print_byte::b#1
Coalesced [91] print_char_cursor#177 ← print_char_cursor#138
Coalesced [94] print_byte::b#11 ← print_byte::b#2
Coalesced (already) [95] print_char_cursor#178 ← print_char_cursor#19
Coalesced [102] print_char::ch#7 ← print_char::ch#4
Coalesced [103] print_char_cursor#183 ← print_char_cursor#139
Coalesced [107] print_char::ch#8 ← print_char::ch#5
Coalesced (already) [108] print_char_cursor#184 ← print_char_cursor#19
Coalesced [113] print_str::str#16 ← print_str::str#15
Coalesced (already) [114] print_char_cursor#161 ← print_char_cursor#19
Coalesced [121] print_str::str#17 ← print_str::str#0
Coalesced [122] print_char_cursor#162 ← print_char_cursor#1
Coalesced [135] divr16s::neg#10 ← divr16s::neg#3
Coalesced [139] divr16u::dividend#10 ← divr16u::dividend#2
Coalesced [140] divr16u::divisor#9 ← divr16u::divisor#1
Coalesced [148] divr16s::return#6 ← divr16s::return#1
Coalesced [149] rem16s#36 ← rem16s#2
Coalesced [157] divr16s::neg#9 ← divr16s::neg#2
Coalesced [161] divr16u::dividend#11 ← divr16u::dividend#5
Coalesced [168] divr16u::rem#14 ← divr16u::rem#1
Coalesced [175] divr16u::rem#16 ← divr16u::rem#2
Coalesced [176] divr16u::return#8 ← divr16u::quotient#2
Coalesced [182] divr16u::rem#12 ← divr16u::rem#11
Coalesced [183] divr16u::dividend#12 ← divr16u::dividend#0
Coalesced [184] divr16u::quotient#9 ← divr16u::return#0
Coalesced [185] divr16u::i#7 ← divr16u::i#1
Coalesced [186] divr16u::rem#15 ← divr16u::rem#6
Coalesced [187] divr16u::return#7 ← divr16u::quotient#1
Coalesced [188] divr16u::rem#13 ← divr16u::rem#0
Coalesced [199] print_sbyte::b#11 ← print_sbyte::b#1
Not coalescing [200] print_char_cursor#167 ← print_line_cursor#1
Coalesced [205] print_sbyte::b#12 ← print_sbyte::b#2
Coalesced [206] print_char_cursor#168 ← print_char_cursor#130
Coalesced [211] print_sbyte::b#13 ← print_sbyte::b#3
Coalesced (already) [212] print_char_cursor#169 ← print_char_cursor#130
Coalesced [217] print_sbyte::b#14 ← print_sbyte::b#4
Coalesced (already) [218] print_char_cursor#170 ← print_char_cursor#130
Coalesced (already) [220] print_line_cursor#88 ← print_line_cursor#1
Coalesced [225] test_8s::i#12 ← test_8s::i#1
Coalesced (already) [228] print_char_cursor#186 ← print_char_cursor#135
Coalesced [230] print_sbyte::b#16 ← print_sbyte::b#10
Coalesced [233] print_byte::b#9 ← print_byte::b#0
Coalesced (already) [234] print_char_cursor#176 ← print_char_cursor#19
Coalesced (already) [238] print_char_cursor#185 ← print_char_cursor#135
Coalesced [241] print_sbyte::b#15 ← print_sbyte::b#0
Coalesced [247] div8s::neg#10 ← div8s::neg#3
Coalesced [251] div8u::dividend#3 ← div8u::dividend#0
Coalesced [252] div8u::divisor#3 ← div8u::divisor#0
Coalesced [260] div8s::return#6 ← div8s::return#1
Coalesced [261] rem8s#32 ← rem8s#2
Coalesced [269] div8s::neg#9 ← div8s::neg#2
Coalesced [279] divr8u::dividend#8 ← divr8u::dividend#0
Coalesced [285] divr8u::rem#13 ← divr8u::rem#2
Coalesced [292] divr8u::rem#15 ← divr8u::rem#3
Coalesced [293] divr8u::return#6 ← divr8u::quotient#2
Coalesced [299] divr8u::rem#11 ← divr8u::rem#10
Coalesced [300] divr8u::dividend#9 ← divr8u::dividend#1
Coalesced [301] divr8u::quotient#9 ← divr8u::return#1
Coalesced [302] divr8u::i#7 ← divr8u::i#1
Coalesced [303] divr8u::rem#14 ← divr8u::rem#5
Coalesced [304] divr8u::return#5 ← divr8u::quotient#1
Coalesced [305] divr8u::rem#12 ← divr8u::rem#1
Coalesced [317] print_word::w#8 ← print_word::w#1
Not coalescing [318] print_char_cursor#172 ← print_line_cursor#1
Coalesced [323] print_word::w#9 ← print_word::w#2
Coalesced (already) [324] print_char_cursor#173 ← print_char_cursor#130
Coalesced [329] print_word::w#10 ← print_word::w#3
Coalesced (already) [330] print_char_cursor#174 ← print_char_cursor#130
Coalesced [335] print_word::w#11 ← print_word::w#4
Coalesced (already) [336] print_char_cursor#175 ← print_char_cursor#130
Coalesced (already) [338] print_line_cursor#87 ← print_line_cursor#1
Coalesced [343] test_16u::i#12 ← test_16u::i#1
Coalesced [346] divr16u::dividend#9 ← divr16u::dividend#1
Coalesced [347] divr16u::divisor#8 ← divr16u::divisor#0
Coalesced [358] div8u::dividend#4 ← div8u::dividend#1
Coalesced [359] div8u::divisor#4 ← div8u::divisor#1
Coalesced [364] print_byte::b#12 ← print_byte::b#3
Coalesced [365] print_char_cursor#179 ← print_char_cursor#141
Coalesced [370] print_byte::b#13 ← print_byte::b#4
Coalesced (already) [371] print_char_cursor#180 ← print_char_cursor#130
Coalesced [376] print_byte::b#14 ← print_byte::b#5
Coalesced (already) [377] print_char_cursor#181 ← print_char_cursor#130
Coalesced [382] print_byte::b#15 ← print_byte::b#6
Coalesced (already) [383] print_char_cursor#182 ← print_char_cursor#130
Coalesced [385] print_line_cursor#89 ← print_line_cursor#41
Coalesced [390] test_8u::i#12 ← test_8u::i#1
Not coalescing [391] print_char_cursor#189 ← print_line_cursor#1
Coalesced (already) [392] print_line_cursor#92 ← print_line_cursor#1
Coalesced [405] memset::dst#4 ← memset::dst#1
Coalesced down to 34 phi equivalence classes
Culled Empty Block (label) @13
Culled Empty Block (label) @37
Culled Empty Block (label) @39
Culled Empty Block (label) @42
Culled Empty Block (label) @43
Culled Empty Block (label) @51
Culled Empty Block (label) main::@5
Culled Empty Block (label) test_16s::@12
Culled Empty Block (label) print_ln::@2
Culled Empty Block (label) print_ln::@3
Culled Empty Block (label) print_sword::@6
Culled Empty Block (label) print_sword::@7
Culled Empty Block (label) print_word::@2
Culled Empty Block (label) print_byte::@2
Culled Empty Block (label) divr16s::@16
Culled Empty Block (label) divr16u::@8
Culled Empty Block (label) divr16u::@10
Culled Empty Block (label) divr16u::@9
Culled Empty Block (label) test_8s::@12
Culled Empty Block (label) print_sbyte::@6
Culled Empty Block (label) print_sbyte::@7
Culled Empty Block (label) divr8u::@8
Culled Empty Block (label) divr8u::@10
Culled Empty Block (label) divr8u::@9
Culled Empty Block (label) test_16u::@12
Culled Empty Block (label) print_cls::@1
Culled Empty Block (label) memset::@2
Culled Empty Block (label) memset::@1
Renumbering block @50 to @1
Renumbering block memset::@4 to memset::@1
Renumbering block memset::@5 to memset::@2
Renumbering block print_sword::@5 to print_sword::@4
Renumbering block print_sbyte::@5 to print_sbyte::@4
Renumbering block div8u::@2 to div8u::@1
Renumbering block div16u::@2 to div16u::@1
Renumbering block div8s::@7 to div8s::@6
Renumbering block div8s::@9 to div8s::@7
Renumbering block div8s::@11 to div8s::@8
Renumbering block div8s::@15 to div8s::@9
Renumbering block divr16s::@7 to divr16s::@6
Renumbering block divr16s::@9 to divr16s::@7
Renumbering block divr16s::@11 to divr16s::@8
Renumbering block divr16s::@15 to divr16s::@9
Renumbering block div16s::@2 to div16s::@1
Renumbering block test_8u::@3 to test_8u::@2
Renumbering block test_8u::@4 to test_8u::@3
Renumbering block test_8u::@5 to test_8u::@4
Renumbering block test_8u::@6 to test_8u::@5
Renumbering block test_8u::@7 to test_8u::@6
Renumbering block test_8u::@8 to test_8u::@7
Renumbering block test_8u::@9 to test_8u::@8
Renumbering block test_8u::@10 to test_8u::@9
Renumbering block test_8u::@11 to test_8u::@10
Renumbering block test_8u::@12 to test_8u::@11
Renumbering block test_16u::@3 to test_16u::@2
Renumbering block test_16u::@4 to test_16u::@3
Renumbering block test_16u::@5 to test_16u::@4
Renumbering block test_16u::@6 to test_16u::@5
Renumbering block test_16u::@7 to test_16u::@6
Renumbering block test_16u::@8 to test_16u::@7
Renumbering block test_16u::@9 to test_16u::@8
Renumbering block test_16u::@10 to test_16u::@9
Renumbering block test_16u::@11 to test_16u::@10
Renumbering block test_8s::@3 to test_8s::@2
Renumbering block test_8s::@4 to test_8s::@3
Renumbering block test_8s::@5 to test_8s::@4
Renumbering block test_8s::@6 to test_8s::@5
Renumbering block test_8s::@7 to test_8s::@6
Renumbering block test_8s::@8 to test_8s::@7
Renumbering block test_8s::@9 to test_8s::@8
Renumbering block test_8s::@10 to test_8s::@9
Renumbering block test_8s::@11 to test_8s::@10
Renumbering block test_16s::@3 to test_16s::@2
Renumbering block test_16s::@4 to test_16s::@3
Renumbering block test_16s::@5 to test_16s::@4
Renumbering block test_16s::@6 to test_16s::@5
Renumbering block test_16s::@7 to test_16s::@6
Renumbering block test_16s::@8 to test_16s::@7
Renumbering block test_16s::@9 to test_16s::@8
Renumbering block test_16s::@10 to test_16s::@9
Renumbering block test_16s::@11 to test_16s::@10
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
Adding NOP phi() at start of main::@2
Adding NOP phi() at start of main::@3
Adding NOP phi() at start of main::@4
Adding NOP phi() at start of test_16s
Adding NOP phi() at start of test_16s::@3
Adding NOP phi() at start of test_16s::@5
Adding NOP phi() at start of test_16s::@7
Adding NOP phi() at start of test_16s::@9
Adding NOP phi() at start of print_sword::@3
Adding NOP phi() at start of print_sword::@1
Adding NOP phi() at start of test_8s
Adding NOP phi() at start of test_8s::@3
Adding NOP phi() at start of test_8s::@5
Adding NOP phi() at start of test_8s::@7
Adding NOP phi() at start of test_8s::@9
Adding NOP phi() at start of print_sbyte::@3
Adding NOP phi() at start of print_sbyte::@1
Adding NOP phi() at start of divr8u
Adding NOP phi() at start of test_16u
Adding NOP phi() at start of test_16u::@3
Adding NOP phi() at start of test_16u::@5
Adding NOP phi() at start of test_16u::@7
Adding NOP phi() at start of test_16u::@9
Adding NOP phi() at start of test_8u
Adding NOP phi() at start of test_8u::@3
Adding NOP phi() at start of test_8u::@5
Adding NOP phi() at start of test_8u::@7
Adding NOP phi() at start of test_8u::@9
Adding NOP phi() at start of print_cls
Adding NOP phi() at start of memset

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 print_cls 
  to:main::@1
main::@1: scope:[main]  from main
  [6] phi()
  [7] call test_8u 
  to:main::@2
main::@2: scope:[main]  from main::@1
  [8] phi()
  [9] call test_16u 
  to:main::@3
main::@3: scope:[main]  from main::@2
  [10] phi()
  [11] call test_8s 
  to:main::@4
main::@4: scope:[main]  from main::@3
  [12] phi()
  [13] call test_16s 
  to:main::@return
main::@return: scope:[main]  from main::@4
  [14] return 
  to:@return

(void()) test_16s()
test_16s: scope:[test_16s]  from main::@4
  [15] phi()
  to:test_16s::@1
test_16s::@1: scope:[test_16s]  from test_16s test_16s::@10
  [16] (byte) test_16s::i#10 ← phi( test_16s/(byte) 0 test_16s::@10/(byte) test_16s::i#1 )
  [17] (byte~) test_16s::$11 ← (byte) test_16s::i#10 << (byte) 1
  [18] (signed word) test_16s::dividend#0 ← *((const signed word*) test_16s::dividends + (byte~) test_16s::$11)
  [19] (signed word) test_16s::divisor#0 ← *((const signed word*) test_16s::divisors + (byte~) test_16s::$11)
  [20] (signed word) div16s::dividend#0 ← (signed word) test_16s::dividend#0
  [21] (signed word) div16s::divisor#0 ← (signed word) test_16s::divisor#0
  [22] call div16s 
  [23] (signed word) div16s::return#2 ← (signed word) div16s::return#0
  to:test_16s::@2
test_16s::@2: scope:[test_16s]  from test_16s::@1
  [24] (signed word) test_16s::res#0 ← (signed word) div16s::return#2
  [25] (signed word) print_sword::w#1 ← (signed word) test_16s::dividend#0
  [26] (byte*) print_char_cursor#163 ← (byte*) print_line_cursor#1
  [27] call print_sword 
  to:test_16s::@3
test_16s::@3: scope:[test_16s]  from test_16s::@2
  [28] phi()
  [29] call print_str 
  to:test_16s::@4
test_16s::@4: scope:[test_16s]  from test_16s::@3
  [30] (signed word) print_sword::w#2 ← (signed word) test_16s::divisor#0
  [31] call print_sword 
  to:test_16s::@5
test_16s::@5: scope:[test_16s]  from test_16s::@4
  [32] phi()
  [33] call print_str 
  to:test_16s::@6
test_16s::@6: scope:[test_16s]  from test_16s::@5
  [34] (signed word) print_sword::w#3 ← (signed word) test_16s::res#0
  [35] call print_sword 
  to:test_16s::@7
test_16s::@7: scope:[test_16s]  from test_16s::@6
  [36] phi()
  [37] call print_str 
  to:test_16s::@8
test_16s::@8: scope:[test_16s]  from test_16s::@7
  [38] (signed word) print_sword::w#4 ← (signed word) rem16s#11
  [39] call print_sword 
  to:test_16s::@9
test_16s::@9: scope:[test_16s]  from test_16s::@8
  [40] phi()
  [41] call print_ln 
  to:test_16s::@10
test_16s::@10: scope:[test_16s]  from test_16s::@9
  [42] (byte) test_16s::i#1 ← ++ (byte) test_16s::i#10
  [43] if((byte) test_16s::i#1!=(byte) 6) goto test_16s::@1
  to:test_16s::@return
test_16s::@return: scope:[test_16s]  from test_16s::@10
  [44] return 
  to:@return

(void()) print_ln()
print_ln: scope:[print_ln]  from test_16s::@9 test_16u::@9 test_8s::@9 test_8u::@9
  [45] (byte*) print_line_cursor#39 ← phi( test_16s::@9/(byte*) print_line_cursor#1 test_16u::@9/(byte*) print_line_cursor#1 test_8s::@9/(byte*) print_line_cursor#1 test_8u::@9/(byte*) print_line_cursor#41 )
  to:print_ln::@1
print_ln::@1: scope:[print_ln]  from print_ln print_ln::@1
  [46] (byte*) print_line_cursor#20 ← phi( print_ln/(byte*) print_line_cursor#39 print_ln::@1/(byte*) print_line_cursor#1 )
  [47] (byte*) print_line_cursor#1 ← (byte*) print_line_cursor#20 + (byte) $28
  [48] if((byte*) print_line_cursor#1<(byte*) print_char_cursor#19) goto print_ln::@1
  to:print_ln::@return
print_ln::@return: scope:[print_ln]  from print_ln::@1
  [49] return 
  to:@return

(void()) print_sword((signed word) print_sword::w)
print_sword: scope:[print_sword]  from test_16s::@2 test_16s::@4 test_16s::@6 test_16s::@8
  [50] (byte*) print_char_cursor#132 ← phi( test_16s::@2/(byte*) print_char_cursor#163 test_16s::@4/(byte*) print_char_cursor#130 test_16s::@6/(byte*) print_char_cursor#130 test_16s::@8/(byte*) print_char_cursor#130 )
  [50] (signed word) print_sword::w#10 ← phi( test_16s::@2/(signed word) print_sword::w#1 test_16s::@4/(signed word) print_sword::w#2 test_16s::@6/(signed word) print_sword::w#3 test_16s::@8/(signed word) print_sword::w#4 )
  [51] if((signed word) print_sword::w#10<(signed byte) 0) goto print_sword::@1
  to:print_sword::@3
print_sword::@3: scope:[print_sword]  from print_sword
  [52] phi()
  [53] call print_char 
  to:print_sword::@2
print_sword::@2: scope:[print_sword]  from print_sword::@3 print_sword::@4
  [54] (signed word) print_sword::w#7 ← phi( print_sword::@4/(signed word) print_sword::w#0 print_sword::@3/(signed word) print_sword::w#10 )
  [55] (word) print_word::w#0 ← (word)(signed word) print_sword::w#7
  [56] call print_word 
  to:print_sword::@return
print_sword::@return: scope:[print_sword]  from print_sword::@2
  [57] return 
  to:@return
print_sword::@1: scope:[print_sword]  from print_sword
  [58] phi()
  [59] call print_char 
  to:print_sword::@4
print_sword::@4: scope:[print_sword]  from print_sword::@1
  [60] (signed word) print_sword::w#0 ← - (signed word) print_sword::w#10
  to:print_sword::@2

(void()) print_char((byte) print_char::ch)
print_char: scope:[print_char]  from print_byte print_byte::@1 print_sbyte::@1 print_sbyte::@3 print_sword::@1 print_sword::@3
  [61] (byte*) print_char_cursor#84 ← phi( print_byte/(byte*) print_char_cursor#139 print_byte::@1/(byte*) print_char_cursor#19 print_sbyte::@1/(byte*) print_char_cursor#135 print_sbyte::@3/(byte*) print_char_cursor#135 print_sword::@1/(byte*) print_char_cursor#132 print_sword::@3/(byte*) print_char_cursor#132 )
  [61] (byte) print_char::ch#6 ← phi( print_byte/(byte) print_char::ch#4 print_byte::@1/(byte) print_char::ch#5 print_sbyte::@1/(byte) '-' print_sbyte::@3/(byte) ' ' print_sword::@1/(byte) '-' print_sword::@3/(byte) ' ' )
  [62] *((byte*) print_char_cursor#84) ← (byte) print_char::ch#6
  [63] (byte*) print_char_cursor#19 ← ++ (byte*) print_char_cursor#84
  to:print_char::@return
print_char::@return: scope:[print_char]  from print_char
  [64] return 
  to:@return

(void()) print_word((word) print_word::w)
print_word: scope:[print_word]  from print_sword::@2 test_16u::@2 test_16u::@4 test_16u::@6 test_16u::@8
  [65] (byte*) print_char_cursor#138 ← phi( print_sword::@2/(byte*) print_char_cursor#19 test_16u::@2/(byte*) print_char_cursor#172 test_16u::@4/(byte*) print_char_cursor#130 test_16u::@6/(byte*) print_char_cursor#130 test_16u::@8/(byte*) print_char_cursor#130 )
  [65] (word) print_word::w#5 ← phi( print_sword::@2/(word) print_word::w#0 test_16u::@2/(word) print_word::w#1 test_16u::@4/(word) print_word::w#2 test_16u::@6/(word) print_word::w#3 test_16u::@8/(word) print_word::w#4 )
  [66] (byte) print_byte::b#1 ← > (word) print_word::w#5
  [67] call print_byte 
  to:print_word::@1
print_word::@1: scope:[print_word]  from print_word
  [68] (byte) print_byte::b#2 ← < (word) print_word::w#5
  [69] call print_byte 
  to:print_word::@return
print_word::@return: scope:[print_word]  from print_word::@1
  [70] return 
  to:@return

(void()) print_byte((byte) print_byte::b)
print_byte: scope:[print_byte]  from print_sbyte::@2 print_word print_word::@1 test_8u::@2 test_8u::@4 test_8u::@6 test_8u::@8
  [71] (byte*) print_char_cursor#139 ← phi( print_sbyte::@2/(byte*) print_char_cursor#19 print_word/(byte*) print_char_cursor#138 print_word::@1/(byte*) print_char_cursor#19 test_8u::@2/(byte*) print_char_cursor#141 test_8u::@4/(byte*) print_char_cursor#130 test_8u::@6/(byte*) print_char_cursor#130 test_8u::@8/(byte*) print_char_cursor#130 )
  [71] (byte) print_byte::b#7 ← phi( print_sbyte::@2/(byte) print_byte::b#0 print_word/(byte) print_byte::b#1 print_word::@1/(byte) print_byte::b#2 test_8u::@2/(byte) print_byte::b#3 test_8u::@4/(byte) print_byte::b#4 test_8u::@6/(byte) print_byte::b#5 test_8u::@8/(byte) print_byte::b#6 )
  [72] (byte~) print_byte::$0 ← (byte) print_byte::b#7 >> (byte) 4
  [73] (byte) print_char::ch#4 ← *((const byte*) print_hextab + (byte~) print_byte::$0)
  [74] call print_char 
  to:print_byte::@1
print_byte::@1: scope:[print_byte]  from print_byte
  [75] (byte~) print_byte::$2 ← (byte) print_byte::b#7 & (byte) $f
  [76] (byte) print_char::ch#5 ← *((const byte*) print_hextab + (byte~) print_byte::$2)
  [77] call print_char 
  to:print_byte::@return
print_byte::@return: scope:[print_byte]  from print_byte::@1
  [78] return 
  to:@return

(void()) print_str((byte*) print_str::str)
print_str: scope:[print_str]  from test_16s::@3 test_16s::@5 test_16s::@7 test_16u::@3 test_16u::@5 test_16u::@7 test_8s::@3 test_8s::@5 test_8s::@7 test_8u::@3 test_8u::@5 test_8u::@7
  [79] (byte*) print_str::str#15 ← phi( test_16s::@3/(const string) str test_16s::@5/(const string) str1 test_16s::@7/(const string) str2 test_16u::@3/(const string) str test_16u::@5/(const string) str1 test_16u::@7/(const string) str2 test_8s::@3/(const string) str test_8s::@5/(const string) str1 test_8s::@7/(const string) str2 test_8u::@3/(const string) str test_8u::@5/(const string) str1 test_8u::@7/(const string) str2 )
  to:print_str::@1
print_str::@1: scope:[print_str]  from print_str print_str::@2
  [80] (byte*) print_char_cursor#130 ← phi( print_str/(byte*) print_char_cursor#19 print_str::@2/(byte*) print_char_cursor#1 )
  [80] (byte*) print_str::str#13 ← phi( print_str/(byte*) print_str::str#15 print_str::@2/(byte*) print_str::str#0 )
  [81] if((byte) 0!=*((byte*) print_str::str#13)) goto print_str::@2
  to:print_str::@return
print_str::@return: scope:[print_str]  from print_str::@1
  [82] return 
  to:@return
print_str::@2: scope:[print_str]  from print_str::@1
  [83] *((byte*) print_char_cursor#130) ← *((byte*) print_str::str#13)
  [84] (byte*) print_char_cursor#1 ← ++ (byte*) print_char_cursor#130
  [85] (byte*) print_str::str#0 ← ++ (byte*) print_str::str#13
  to:print_str::@1

(signed word()) div16s((signed word) div16s::dividend , (signed word) div16s::divisor)
div16s: scope:[div16s]  from test_16s::@1
  [86] (signed word) divr16s::dividend#0 ← (signed word) div16s::dividend#0
  [87] (signed word) divr16s::divisor#0 ← (signed word) div16s::divisor#0
  [88] call divr16s 
  [89] (signed word) divr16s::return#3 ← (signed word) divr16s::return#2
  to:div16s::@1
div16s::@1: scope:[div16s]  from div16s
  [90] (signed word) div16s::return#0 ← (signed word) divr16s::return#3
  to:div16s::@return
div16s::@return: scope:[div16s]  from div16s::@1
  [91] return 
  to:@return

(signed word()) divr16s((signed word) divr16s::dividend , (signed word) divr16s::divisor , (signed word) divr16s::rem)
divr16s: scope:[divr16s]  from div16s
  [92] if((signed word) divr16s::dividend#0<(signed byte) 0) goto divr16s::@1
  to:divr16s::@6
divr16s::@6: scope:[divr16s]  from divr16s
  [93] (word) divr16s::dividendu#8 ← (word)(signed word) divr16s::dividend#0
  to:divr16s::@2
divr16s::@2: scope:[divr16s]  from divr16s::@1 divr16s::@6
  [94] (word) divr16s::dividendu#3 ← phi( divr16s::@1/(word) divr16s::dividendu#7 divr16s::@6/(word) divr16s::dividendu#8 )
  [94] (byte) divr16s::neg#3 ← phi( divr16s::@1/(byte) 1 divr16s::@6/(byte) 0 )
  [95] if((signed word) divr16s::divisor#0<(signed byte) 0) goto divr16s::@3
  to:divr16s::@7
divr16s::@7: scope:[divr16s]  from divr16s::@2
  [96] (word) divr16s::divisoru#5 ← (word)(signed word) divr16s::divisor#0
  to:divr16s::@4
divr16s::@4: scope:[divr16s]  from divr16s::@3 divr16s::@7
  [97] (byte) divr16s::neg#4 ← phi( divr16s::@3/(byte) divr16s::neg#2 divr16s::@7/(byte) divr16s::neg#3 )
  [97] (word) divr16s::divisoru#3 ← phi( divr16s::@3/(word) divr16s::divisoru#4 divr16s::@7/(word) divr16s::divisoru#5 )
  [98] (word) divr16u::dividend#2 ← (word) divr16s::dividendu#3
  [99] (word) divr16u::divisor#1 ← (word) divr16s::divisoru#3
  [100] call divr16u 
  [101] (word) divr16u::return#3 ← (word) divr16u::return#0
  to:divr16s::@9
divr16s::@9: scope:[divr16s]  from divr16s::@4
  [102] (word) divr16s::resultu#0 ← (word) divr16u::return#3
  [103] if((byte) divr16s::neg#4==(byte) 0) goto divr16s::@5
  to:divr16s::@8
divr16s::@8: scope:[divr16s]  from divr16s::@9
  [104] (signed word~) divr16s::$16 ← (signed word)(word) rem16u#1
  [105] (signed word) rem16s#2 ← - (signed word~) divr16s::$16
  [106] (signed word) divr16s::return#1 ← - (signed word)(word) divr16s::resultu#0
  to:divr16s::@return
divr16s::@return: scope:[divr16s]  from divr16s::@5 divr16s::@8
  [107] (signed word) rem16s#11 ← phi( divr16s::@8/(signed word) rem16s#2 divr16s::@5/(signed word) rem16s#37 )
  [107] (signed word) divr16s::return#2 ← phi( divr16s::@8/(signed word) divr16s::return#1 divr16s::@5/(signed word) divr16s::return#7 )
  [108] return 
  to:@return
divr16s::@5: scope:[divr16s]  from divr16s::@9
  [109] (signed word) divr16s::return#7 ← (signed word)(word) divr16s::resultu#0
  [110] (signed word) rem16s#37 ← (signed word)(word) rem16u#1
  to:divr16s::@return
divr16s::@3: scope:[divr16s]  from divr16s::@2
  [111] (signed word) divr16s::divisoru#1 ← - (signed word) divr16s::divisor#0
  [112] (byte) divr16s::neg#2 ← (byte) divr16s::neg#3 ^ (byte) 1
  [113] (word) divr16s::divisoru#4 ← (word)(signed word) divr16s::divisoru#1
  to:divr16s::@4
divr16s::@1: scope:[divr16s]  from divr16s
  [114] (signed word) divr16s::dividendu#1 ← - (signed word) divr16s::dividend#0
  [115] (word) divr16s::dividendu#7 ← (word)(signed word) divr16s::dividendu#1
  to:divr16s::@2

(word()) divr16u((word) divr16u::dividend , (word) divr16u::divisor , (word) divr16u::rem)
divr16u: scope:[divr16u]  from div16u divr16s::@4
  [116] (word) divr16u::divisor#6 ← phi( div16u/(word) divr16u::divisor#0 divr16s::@4/(word) divr16u::divisor#1 )
  [116] (word) divr16u::dividend#5 ← phi( div16u/(word) divr16u::dividend#1 divr16s::@4/(word) divr16u::dividend#2 )
  to:divr16u::@1
divr16u::@1: scope:[divr16u]  from divr16u divr16u::@3
  [117] (byte) divr16u::i#2 ← phi( divr16u/(byte) 0 divr16u::@3/(byte) divr16u::i#1 )
  [117] (word) divr16u::quotient#3 ← phi( divr16u/(word) 0 divr16u::@3/(word) divr16u::return#0 )
  [117] (word) divr16u::dividend#3 ← phi( divr16u/(word) divr16u::dividend#5 divr16u::@3/(word) divr16u::dividend#0 )
  [117] (word) divr16u::rem#5 ← phi( divr16u/(byte) 0 divr16u::@3/(word) divr16u::rem#11 )
  [118] (word) divr16u::rem#0 ← (word) divr16u::rem#5 << (byte) 1
  [119] (byte~) divr16u::$1 ← > (word) divr16u::dividend#3
  [120] (byte~) divr16u::$2 ← (byte~) divr16u::$1 & (byte) $80
  [121] if((byte~) divr16u::$2==(byte) 0) goto divr16u::@2
  to:divr16u::@4
divr16u::@4: scope:[divr16u]  from divr16u::@1
  [122] (word) divr16u::rem#1 ← (word) divr16u::rem#0 | (byte) 1
  to:divr16u::@2
divr16u::@2: scope:[divr16u]  from divr16u::@1 divr16u::@4
  [123] (word) divr16u::rem#6 ← phi( divr16u::@1/(word) divr16u::rem#0 divr16u::@4/(word) divr16u::rem#1 )
  [124] (word) divr16u::dividend#0 ← (word) divr16u::dividend#3 << (byte) 1
  [125] (word) divr16u::quotient#1 ← (word) divr16u::quotient#3 << (byte) 1
  [126] if((word) divr16u::rem#6<(word) divr16u::divisor#6) goto divr16u::@3
  to:divr16u::@5
divr16u::@5: scope:[divr16u]  from divr16u::@2
  [127] (word) divr16u::quotient#2 ← ++ (word) divr16u::quotient#1
  [128] (word) divr16u::rem#2 ← (word) divr16u::rem#6 - (word) divr16u::divisor#6
  to:divr16u::@3
divr16u::@3: scope:[divr16u]  from divr16u::@2 divr16u::@5
  [129] (word) divr16u::return#0 ← phi( divr16u::@2/(word) divr16u::quotient#1 divr16u::@5/(word) divr16u::quotient#2 )
  [129] (word) divr16u::rem#11 ← phi( divr16u::@2/(word) divr16u::rem#6 divr16u::@5/(word) divr16u::rem#2 )
  [130] (byte) divr16u::i#1 ← ++ (byte) divr16u::i#2
  [131] if((byte) divr16u::i#1!=(byte) $10) goto divr16u::@1
  to:divr16u::@6
divr16u::@6: scope:[divr16u]  from divr16u::@3
  [132] (word) rem16u#1 ← (word) divr16u::rem#11
  to:divr16u::@return
divr16u::@return: scope:[divr16u]  from divr16u::@6
  [133] return 
  to:@return

(void()) test_8s()
test_8s: scope:[test_8s]  from main::@3
  [134] phi()
  to:test_8s::@1
test_8s::@1: scope:[test_8s]  from test_8s test_8s::@10
  [135] (byte) test_8s::i#10 ← phi( test_8s/(byte) 0 test_8s::@10/(byte) test_8s::i#1 )
  [136] (signed byte) test_8s::dividend#0 ← *((const signed byte*) test_8s::dividends + (byte) test_8s::i#10)
  [137] (signed byte) test_8s::divisor#0 ← *((const signed byte*) test_8s::divisors + (byte) test_8s::i#10)
  [138] (signed byte) div8s::dividend#0 ← (signed byte) test_8s::dividend#0
  [139] (signed byte) div8s::divisor#0 ← (signed byte) test_8s::divisor#0
  [140] call div8s 
  [141] (signed byte) div8s::return#3 ← (signed byte) div8s::return#2
  to:test_8s::@2
test_8s::@2: scope:[test_8s]  from test_8s::@1
  [142] (signed byte) test_8s::res#0 ← (signed byte) div8s::return#3
  [143] (signed byte) print_sbyte::b#1 ← (signed byte) test_8s::dividend#0
  [144] (byte*) print_char_cursor#167 ← (byte*) print_line_cursor#1
  [145] call print_sbyte 
  to:test_8s::@3
test_8s::@3: scope:[test_8s]  from test_8s::@2
  [146] phi()
  [147] call print_str 
  to:test_8s::@4
test_8s::@4: scope:[test_8s]  from test_8s::@3
  [148] (signed byte) print_sbyte::b#2 ← (signed byte) test_8s::divisor#0
  [149] call print_sbyte 
  to:test_8s::@5
test_8s::@5: scope:[test_8s]  from test_8s::@4
  [150] phi()
  [151] call print_str 
  to:test_8s::@6
test_8s::@6: scope:[test_8s]  from test_8s::@5
  [152] (signed byte) print_sbyte::b#3 ← (signed byte) test_8s::res#0
  [153] call print_sbyte 
  to:test_8s::@7
test_8s::@7: scope:[test_8s]  from test_8s::@6
  [154] phi()
  [155] call print_str 
  to:test_8s::@8
test_8s::@8: scope:[test_8s]  from test_8s::@7
  [156] (signed byte) print_sbyte::b#4 ← (signed byte) rem8s#3
  [157] call print_sbyte 
  to:test_8s::@9
test_8s::@9: scope:[test_8s]  from test_8s::@8
  [158] phi()
  [159] call print_ln 
  to:test_8s::@10
test_8s::@10: scope:[test_8s]  from test_8s::@9
  [160] (byte) test_8s::i#1 ← ++ (byte) test_8s::i#10
  [161] if((byte) test_8s::i#1!=(byte) 6) goto test_8s::@1
  to:test_8s::@return
test_8s::@return: scope:[test_8s]  from test_8s::@10
  [162] return 
  to:@return

(void()) print_sbyte((signed byte) print_sbyte::b)
print_sbyte: scope:[print_sbyte]  from test_8s::@2 test_8s::@4 test_8s::@6 test_8s::@8
  [163] (byte*) print_char_cursor#135 ← phi( test_8s::@2/(byte*) print_char_cursor#167 test_8s::@4/(byte*) print_char_cursor#130 test_8s::@6/(byte*) print_char_cursor#130 test_8s::@8/(byte*) print_char_cursor#130 )
  [163] (signed byte) print_sbyte::b#10 ← phi( test_8s::@2/(signed byte) print_sbyte::b#1 test_8s::@4/(signed byte) print_sbyte::b#2 test_8s::@6/(signed byte) print_sbyte::b#3 test_8s::@8/(signed byte) print_sbyte::b#4 )
  [164] if((signed byte) print_sbyte::b#10<(signed byte) 0) goto print_sbyte::@1
  to:print_sbyte::@3
print_sbyte::@3: scope:[print_sbyte]  from print_sbyte
  [165] phi()
  [166] call print_char 
  to:print_sbyte::@2
print_sbyte::@2: scope:[print_sbyte]  from print_sbyte::@3 print_sbyte::@4
  [167] (signed byte) print_sbyte::b#7 ← phi( print_sbyte::@4/(signed byte) print_sbyte::b#0 print_sbyte::@3/(signed byte) print_sbyte::b#10 )
  [168] (byte) print_byte::b#0 ← (byte)(signed byte) print_sbyte::b#7
  [169] call print_byte 
  to:print_sbyte::@return
print_sbyte::@return: scope:[print_sbyte]  from print_sbyte::@2
  [170] return 
  to:@return
print_sbyte::@1: scope:[print_sbyte]  from print_sbyte
  [171] phi()
  [172] call print_char 
  to:print_sbyte::@4
print_sbyte::@4: scope:[print_sbyte]  from print_sbyte::@1
  [173] (signed byte) print_sbyte::b#0 ← - (signed byte) print_sbyte::b#10
  to:print_sbyte::@2

(signed byte()) div8s((signed byte) div8s::dividend , (signed byte) div8s::divisor)
div8s: scope:[div8s]  from test_8s::@1
  [174] if((signed byte) div8s::dividend#0<(signed byte) 0) goto div8s::@1
  to:div8s::@6
div8s::@6: scope:[div8s]  from div8s
  [175] (byte) div8s::dividendu#8 ← (byte)(signed byte) div8s::dividend#0
  to:div8s::@2
div8s::@2: scope:[div8s]  from div8s::@1 div8s::@6
  [176] (byte) div8s::dividendu#3 ← phi( div8s::@1/(byte) div8s::dividendu#7 div8s::@6/(byte) div8s::dividendu#8 )
  [176] (byte) div8s::neg#3 ← phi( div8s::@1/(byte) 1 div8s::@6/(byte) 0 )
  [177] if((signed byte) div8s::divisor#0<(signed byte) 0) goto div8s::@3
  to:div8s::@7
div8s::@7: scope:[div8s]  from div8s::@2
  [178] (byte) div8s::divisoru#5 ← (byte)(signed byte) div8s::divisor#0
  to:div8s::@4
div8s::@4: scope:[div8s]  from div8s::@3 div8s::@7
  [179] (byte) div8s::neg#4 ← phi( div8s::@3/(byte) div8s::neg#2 div8s::@7/(byte) div8s::neg#3 )
  [179] (byte) div8s::divisoru#3 ← phi( div8s::@3/(byte) div8s::divisoru#4 div8s::@7/(byte) div8s::divisoru#5 )
  [180] (byte) div8u::dividend#0 ← (byte) div8s::dividendu#3
  [181] (byte) div8u::divisor#0 ← (byte) div8s::divisoru#3
  [182] call div8u 
  [183] (byte) div8u::return#2 ← (byte) div8u::return#0
  to:div8s::@9
div8s::@9: scope:[div8s]  from div8s::@4
  [184] (byte) div8s::resultu#0 ← (byte) div8u::return#2
  [185] if((byte) div8s::neg#4==(byte) 0) goto div8s::@5
  to:div8s::@8
div8s::@8: scope:[div8s]  from div8s::@9
  [186] (signed byte~) div8s::$11 ← (signed byte)(byte) rem8u#17
  [187] (signed byte) rem8s#2 ← - (signed byte~) div8s::$11
  [188] (signed byte) div8s::return#1 ← - (signed byte)(byte) div8s::resultu#0
  to:div8s::@return
div8s::@return: scope:[div8s]  from div8s::@5 div8s::@8
  [189] (signed byte) rem8s#3 ← phi( div8s::@8/(signed byte) rem8s#2 div8s::@5/(signed byte) rem8s#33 )
  [189] (signed byte) div8s::return#2 ← phi( div8s::@8/(signed byte) div8s::return#1 div8s::@5/(signed byte) div8s::return#7 )
  [190] return 
  to:@return
div8s::@5: scope:[div8s]  from div8s::@9
  [191] (signed byte) div8s::return#7 ← (signed byte)(byte) div8s::resultu#0
  [192] (signed byte) rem8s#33 ← (signed byte)(byte) rem8u#17
  to:div8s::@return
div8s::@3: scope:[div8s]  from div8s::@2
  [193] (signed byte) div8s::divisoru#1 ← - (signed byte) div8s::divisor#0
  [194] (byte) div8s::neg#2 ← (byte) div8s::neg#3 ^ (byte) 1
  [195] (byte) div8s::divisoru#4 ← (byte)(signed byte) div8s::divisoru#1
  to:div8s::@4
div8s::@1: scope:[div8s]  from div8s
  [196] (signed byte) div8s::dividendu#1 ← - (signed byte) div8s::dividend#0
  [197] (byte) div8s::dividendu#7 ← (byte)(signed byte) div8s::dividendu#1
  to:div8s::@2

(byte()) div8u((byte) div8u::dividend , (byte) div8u::divisor)
div8u: scope:[div8u]  from div8s::@4 test_8u::@1
  [198] (byte) div8u::divisor#2 ← phi( div8s::@4/(byte) div8u::divisor#0 test_8u::@1/(byte) div8u::divisor#1 )
  [198] (byte) div8u::dividend#2 ← phi( div8s::@4/(byte) div8u::dividend#0 test_8u::@1/(byte) div8u::dividend#1 )
  [199] (byte) divr8u::dividend#0 ← (byte) div8u::dividend#2
  [200] (byte) divr8u::divisor#0 ← (byte) div8u::divisor#2
  [201] call divr8u 
  [202] (byte) divr8u::return#0 ← (byte) divr8u::return#1
  to:div8u::@1
div8u::@1: scope:[div8u]  from div8u
  [203] (byte) div8u::return#0 ← (byte) divr8u::return#0
  to:div8u::@return
div8u::@return: scope:[div8u]  from div8u::@1
  [204] return 
  to:@return

(byte()) divr8u((byte) divr8u::dividend , (byte) divr8u::divisor , (byte) divr8u::rem)
divr8u: scope:[divr8u]  from div8u
  [205] phi()
  to:divr8u::@1
divr8u::@1: scope:[divr8u]  from divr8u divr8u::@3
  [206] (byte) divr8u::i#2 ← phi( divr8u/(byte) 0 divr8u::@3/(byte) divr8u::i#1 )
  [206] (byte) divr8u::quotient#3 ← phi( divr8u/(byte) 0 divr8u::@3/(byte) divr8u::return#1 )
  [206] (byte) divr8u::dividend#2 ← phi( divr8u/(byte) divr8u::dividend#0 divr8u::@3/(byte) divr8u::dividend#1 )
  [206] (byte) divr8u::rem#4 ← phi( divr8u/(byte) 0 divr8u::@3/(byte) divr8u::rem#10 )
  [207] (byte) divr8u::rem#1 ← (byte) divr8u::rem#4 << (byte) 1
  [208] (byte~) divr8u::$1 ← (byte) divr8u::dividend#2 & (byte) $80
  [209] if((byte~) divr8u::$1==(byte) 0) goto divr8u::@2
  to:divr8u::@4
divr8u::@4: scope:[divr8u]  from divr8u::@1
  [210] (byte) divr8u::rem#2 ← (byte) divr8u::rem#1 | (byte) 1
  to:divr8u::@2
divr8u::@2: scope:[divr8u]  from divr8u::@1 divr8u::@4
  [211] (byte) divr8u::rem#5 ← phi( divr8u::@1/(byte) divr8u::rem#1 divr8u::@4/(byte) divr8u::rem#2 )
  [212] (byte) divr8u::dividend#1 ← (byte) divr8u::dividend#2 << (byte) 1
  [213] (byte) divr8u::quotient#1 ← (byte) divr8u::quotient#3 << (byte) 1
  [214] if((byte) divr8u::rem#5<(byte) divr8u::divisor#0) goto divr8u::@3
  to:divr8u::@5
divr8u::@5: scope:[divr8u]  from divr8u::@2
  [215] (byte) divr8u::quotient#2 ← ++ (byte) divr8u::quotient#1
  [216] (byte) divr8u::rem#3 ← (byte) divr8u::rem#5 - (byte) divr8u::divisor#0
  to:divr8u::@3
divr8u::@3: scope:[divr8u]  from divr8u::@2 divr8u::@5
  [217] (byte) divr8u::return#1 ← phi( divr8u::@2/(byte) divr8u::quotient#1 divr8u::@5/(byte) divr8u::quotient#2 )
  [217] (byte) divr8u::rem#10 ← phi( divr8u::@2/(byte) divr8u::rem#5 divr8u::@5/(byte) divr8u::rem#3 )
  [218] (byte) divr8u::i#1 ← ++ (byte) divr8u::i#2
  [219] if((byte) divr8u::i#1!=(byte) 8) goto divr8u::@1
  to:divr8u::@6
divr8u::@6: scope:[divr8u]  from divr8u::@3
  [220] (byte) rem8u#17 ← (byte) divr8u::rem#10
  to:divr8u::@return
divr8u::@return: scope:[divr8u]  from divr8u::@6
  [221] return 
  to:@return

(void()) test_16u()
test_16u: scope:[test_16u]  from main::@2
  [222] phi()
  to:test_16u::@1
test_16u::@1: scope:[test_16u]  from test_16u test_16u::@10
  [223] (byte) test_16u::i#10 ← phi( test_16u/(byte) 0 test_16u::@10/(byte) test_16u::i#1 )
  [224] (byte~) test_16u::$11 ← (byte) test_16u::i#10 << (byte) 1
  [225] (word) test_16u::dividend#0 ← *((const word*) test_16u::dividends + (byte~) test_16u::$11)
  [226] (word) test_16u::divisor#0 ← *((const word*) test_16u::divisors + (byte~) test_16u::$11)
  [227] (word) div16u::dividend#0 ← (word) test_16u::dividend#0
  [228] (word) div16u::divisor#0 ← (word) test_16u::divisor#0
  [229] call div16u 
  [230] (word) div16u::return#2 ← (word) div16u::return#0
  to:test_16u::@2
test_16u::@2: scope:[test_16u]  from test_16u::@1
  [231] (word) test_16u::res#0 ← (word) div16u::return#2
  [232] (word) print_word::w#1 ← (word) test_16u::dividend#0
  [233] (byte*) print_char_cursor#172 ← (byte*) print_line_cursor#1
  [234] call print_word 
  to:test_16u::@3
test_16u::@3: scope:[test_16u]  from test_16u::@2
  [235] phi()
  [236] call print_str 
  to:test_16u::@4
test_16u::@4: scope:[test_16u]  from test_16u::@3
  [237] (word) print_word::w#2 ← (word) test_16u::divisor#0
  [238] call print_word 
  to:test_16u::@5
test_16u::@5: scope:[test_16u]  from test_16u::@4
  [239] phi()
  [240] call print_str 
  to:test_16u::@6
test_16u::@6: scope:[test_16u]  from test_16u::@5
  [241] (word) print_word::w#3 ← (word) test_16u::res#0
  [242] call print_word 
  to:test_16u::@7
test_16u::@7: scope:[test_16u]  from test_16u::@6
  [243] phi()
  [244] call print_str 
  to:test_16u::@8
test_16u::@8: scope:[test_16u]  from test_16u::@7
  [245] (word) print_word::w#4 ← (word) rem16u#1
  [246] call print_word 
  to:test_16u::@9
test_16u::@9: scope:[test_16u]  from test_16u::@8
  [247] phi()
  [248] call print_ln 
  to:test_16u::@10
test_16u::@10: scope:[test_16u]  from test_16u::@9
  [249] (byte) test_16u::i#1 ← ++ (byte) test_16u::i#10
  [250] if((byte) test_16u::i#1!=(byte) 6) goto test_16u::@1
  to:test_16u::@return
test_16u::@return: scope:[test_16u]  from test_16u::@10
  [251] return 
  to:@return

(word()) div16u((word) div16u::dividend , (word) div16u::divisor)
div16u: scope:[div16u]  from test_16u::@1
  [252] (word) divr16u::dividend#1 ← (word) div16u::dividend#0
  [253] (word) divr16u::divisor#0 ← (word) div16u::divisor#0
  [254] call divr16u 
  [255] (word) divr16u::return#2 ← (word) divr16u::return#0
  to:div16u::@1
div16u::@1: scope:[div16u]  from div16u
  [256] (word) div16u::return#0 ← (word) divr16u::return#2
  to:div16u::@return
div16u::@return: scope:[div16u]  from div16u::@1
  [257] return 
  to:@return

(void()) test_8u()
test_8u: scope:[test_8u]  from main::@1
  [258] phi()
  to:test_8u::@1
test_8u::@1: scope:[test_8u]  from test_8u test_8u::@11
  [259] (byte*) print_line_cursor#41 ← phi( test_8u/(byte*) 1024 test_8u::@11/(byte*) print_line_cursor#1 )
  [259] (byte*) print_char_cursor#141 ← phi( test_8u/(byte*) 1024 test_8u::@11/(byte*) print_char_cursor#189 )
  [259] (byte) test_8u::i#10 ← phi( test_8u/(byte) 0 test_8u::@11/(byte) test_8u::i#1 )
  [260] (byte) test_8u::dividend#0 ← *((const byte*) test_8u::dividends + (byte) test_8u::i#10)
  [261] (byte) test_8u::divisor#0 ← *((const byte*) test_8u::divisors + (byte) test_8u::i#10)
  [262] (byte) div8u::dividend#1 ← (byte) test_8u::dividend#0
  [263] (byte) div8u::divisor#1 ← (byte) test_8u::divisor#0
  [264] call div8u 
  [265] (byte) div8u::return#3 ← (byte) div8u::return#0
  to:test_8u::@2
test_8u::@2: scope:[test_8u]  from test_8u::@1
  [266] (byte) test_8u::res#0 ← (byte) div8u::return#3
  [267] (byte) print_byte::b#3 ← (byte) test_8u::dividend#0
  [268] call print_byte 
  to:test_8u::@3
test_8u::@3: scope:[test_8u]  from test_8u::@2
  [269] phi()
  [270] call print_str 
  to:test_8u::@4
test_8u::@4: scope:[test_8u]  from test_8u::@3
  [271] (byte) print_byte::b#4 ← (byte) test_8u::divisor#0
  [272] call print_byte 
  to:test_8u::@5
test_8u::@5: scope:[test_8u]  from test_8u::@4
  [273] phi()
  [274] call print_str 
  to:test_8u::@6
test_8u::@6: scope:[test_8u]  from test_8u::@5
  [275] (byte) print_byte::b#5 ← (byte) test_8u::res#0
  [276] call print_byte 
  to:test_8u::@7
test_8u::@7: scope:[test_8u]  from test_8u::@6
  [277] phi()
  [278] call print_str 
  to:test_8u::@8
test_8u::@8: scope:[test_8u]  from test_8u::@7
  [279] (byte) print_byte::b#6 ← (byte) rem8u#17
  [280] call print_byte 
  to:test_8u::@9
test_8u::@9: scope:[test_8u]  from test_8u::@8
  [281] phi()
  [282] call print_ln 
  to:test_8u::@10
test_8u::@10: scope:[test_8u]  from test_8u::@9
  [283] (byte) test_8u::i#1 ← ++ (byte) test_8u::i#10
  [284] if((byte) test_8u::i#1!=(byte) 6) goto test_8u::@11
  to:test_8u::@return
test_8u::@return: scope:[test_8u]  from test_8u::@10
  [285] return 
  to:@return
test_8u::@11: scope:[test_8u]  from test_8u::@10
  [286] (byte*) print_char_cursor#189 ← (byte*) print_line_cursor#1
  to:test_8u::@1

(void()) print_cls()
print_cls: scope:[print_cls]  from main
  [287] phi()
  [288] call memset 
  to:print_cls::@return
print_cls::@return: scope:[print_cls]  from print_cls
  [289] return 
  to:@return

(void*()) memset((void*) memset::str , (byte) memset::c , (word) memset::num)
memset: scope:[memset]  from print_cls
  [290] phi()
  to:memset::@1
memset::@1: scope:[memset]  from memset memset::@2
  [291] (byte*) memset::dst#2 ← phi( memset/(byte*)(const void*) memset::str#0 memset::@2/(byte*) memset::dst#1 )
  [292] if((byte*) memset::dst#2!=(const byte*) memset::end#0) goto memset::@2
  to:memset::@return
memset::@return: scope:[memset]  from memset::@1
  [293] return 
  to:@return
memset::@2: scope:[memset]  from memset::@1
  [294] *((byte*) memset::dst#2) ← (const byte) memset::c#0
  [295] (byte*) memset::dst#1 ← ++ (byte*) memset::dst#2
  to:memset::@1


VARIABLE REGISTER WEIGHTS
(signed word()) div16s((signed word) div16s::dividend , (signed word) div16s::divisor)
(signed word) div16s::dividend
(signed word) div16s::dividend#0 6.5
(signed word) div16s::divisor
(signed word) div16s::divisor#0 6.5
(signed word) div16s::return
(signed word) div16s::return#0 4.333333333333333
(signed word) div16s::return#2 22.0
(word()) div16u((word) div16u::dividend , (word) div16u::divisor)
(word) div16u::dividend
(word) div16u::dividend#0 6.5
(word) div16u::divisor
(word) div16u::divisor#0 6.5
(word) div16u::return
(word) div16u::return#0 4.333333333333333
(word) div16u::return#2 22.0
(signed byte()) div8s((signed byte) div8s::dividend , (signed byte) div8s::divisor)
(signed byte~) div8s::$11 4.0
(signed byte) div8s::dividend
(signed byte) div8s::dividend#0 5.0
(byte) div8s::dividendu
(signed byte) div8s::dividendu#1 2.0
(byte) div8s::dividendu#3 0.8571428571428571
(byte) div8s::dividendu#7 4.0
(byte) div8s::dividendu#8 4.0
(signed byte) div8s::divisor
(signed byte) div8s::divisor#0 2.142857142857143
(byte) div8s::divisoru
(signed byte) div8s::divisoru#1 1.0
(byte) div8s::divisoru#3 3.0
(byte) div8s::divisoru#4 4.0
(byte) div8s::divisoru#5 4.0
(byte) div8s::neg
(byte) div8s::neg#2 2.0
(byte) div8s::neg#3 1.0
(byte) div8s::neg#4 1.0
(byte) div8s::resultu
(byte) div8s::resultu#0 0.5
(signed byte) div8s::return
(signed byte) div8s::return#1 4.0
(signed byte) div8s::return#2 5.0
(signed byte) div8s::return#3 22.0
(signed byte) div8s::return#7 2.0
(byte()) div8u((byte) div8u::dividend , (byte) div8u::divisor)
(byte) div8u::dividend
(byte) div8u::dividend#0 2.0
(byte) div8u::dividend#1 11.0
(byte) div8u::dividend#2 15.0
(byte) div8u::divisor
(byte) div8u::divisor#0 4.0
(byte) div8u::divisor#1 22.0
(byte) div8u::divisor#2 7.5
(byte) div8u::return
(byte) div8u::return#0 3.75
(byte) div8u::return#2 4.0
(byte) div8u::return#3 22.0
(signed word()) divr16s((signed word) divr16s::dividend , (signed word) divr16s::divisor , (signed word) divr16s::rem)
(signed word~) divr16s::$16 4.0
(signed word) divr16s::dividend
(signed word) divr16s::dividend#0 2.0
(word) divr16s::dividendu
(signed word) divr16s::dividendu#1 2.0
(word) divr16s::dividendu#3 0.8571428571428571
(word) divr16s::dividendu#7 4.0
(word) divr16s::dividendu#8 4.0
(signed word) divr16s::divisor
(signed word) divr16s::divisor#0 0.8571428571428571
(word) divr16s::divisoru
(signed word) divr16s::divisoru#1 1.0
(word) divr16s::divisoru#3 3.0
(word) divr16s::divisoru#4 4.0
(word) divr16s::divisoru#5 4.0
(byte) divr16s::neg
(byte) divr16s::neg#2 2.0
(byte) divr16s::neg#3 1.0
(byte) divr16s::neg#4 1.0
(signed word) divr16s::rem
(word) divr16s::remu
(word) divr16s::resultu
(word) divr16s::resultu#0 0.5
(signed word) divr16s::return
(signed word) divr16s::return#1 4.0
(signed word) divr16s::return#2 2.0
(signed word) divr16s::return#3 4.0
(signed word) divr16s::return#7 2.0
(word()) divr16u((word) divr16u::dividend , (word) divr16u::divisor , (word) divr16u::rem)
(byte~) divr16u::$1 202.0
(byte~) divr16u::$2 202.0
(word) divr16u::dividend
(word) divr16u::dividend#0 25.25
(word) divr16u::dividend#1 2.0
(word) divr16u::dividend#2 2.0
(word) divr16u::dividend#3 43.57142857142858
(word) divr16u::dividend#5 6.0
(word) divr16u::divisor
(word) divr16u::divisor#0 4.0
(word) divr16u::divisor#1 4.0
(word) divr16u::divisor#6 12.875
(byte) divr16u::i
(byte) divr16u::i#1 151.5
(byte) divr16u::i#2 15.538461538461538
(word) divr16u::quotient
(word) divr16u::quotient#1 151.5
(word) divr16u::quotient#2 101.0
(word) divr16u::quotient#3 25.25
(word) divr16u::rem
(word) divr16u::rem#0 75.75
(word) divr16u::rem#1 202.0
(word) divr16u::rem#11 101.66666666666667
(word) divr16u::rem#2 202.0
(word) divr16u::rem#5 202.0
(word) divr16u::rem#6 101.0
(word) divr16u::return
(word) divr16u::return#0 43.85714285714286
(word) divr16u::return#2 4.0
(word) divr16u::return#3 4.0
(byte()) divr8u((byte) divr8u::dividend , (byte) divr8u::divisor , (byte) divr8u::rem)
(byte~) divr8u::$1 202.0
(byte) divr8u::dividend
(byte) divr8u::dividend#0 1.3333333333333333
(byte) divr8u::dividend#1 25.25
(byte) divr8u::dividend#2 50.83333333333333
(byte) divr8u::divisor
(byte) divr8u::divisor#0 12.75
(byte) divr8u::i
(byte) divr8u::i#1 151.5
(byte) divr8u::i#2 16.833333333333332
(byte) divr8u::quotient
(byte) divr8u::quotient#1 151.5
(byte) divr8u::quotient#2 101.0
(byte) divr8u::quotient#3 28.857142857142858
(byte) divr8u::rem
(byte) divr8u::rem#1 101.0
(byte) divr8u::rem#10 101.66666666666667
(byte) divr8u::rem#2 202.0
(byte) divr8u::rem#3 202.0
(byte) divr8u::rem#4 202.0
(byte) divr8u::rem#5 101.0
(byte) divr8u::return
(byte) divr8u::return#0 4.0
(byte) divr8u::return#1 50.83333333333333
(void()) main()
(void*()) memset((void*) memset::str , (byte) memset::c , (word) memset::num)
(byte) memset::c
(byte*) memset::dst
(byte*) memset::dst#1 22.0
(byte*) memset::dst#2 14.666666666666666
(byte*) memset::end
(word) memset::num
(void*) memset::return
(void*) memset::str
(void()) print_byte((byte) print_byte::b)
(byte~) print_byte::$0 4.0
(byte~) print_byte::$2 4.0
(byte) print_byte::b
(byte) print_byte::b#0 4.0
(byte) print_byte::b#1 4.0
(byte) print_byte::b#2 4.0
(byte) print_byte::b#3 22.0
(byte) print_byte::b#4 22.0
(byte) print_byte::b#5 22.0
(byte) print_byte::b#6 22.0
(byte) print_byte::b#7 13.5
(void()) print_char((byte) print_char::ch)
(byte) print_char::ch
(byte) print_char::ch#4 4.0
(byte) print_char::ch#5 4.0
(byte) print_char::ch#6 6.0
(byte*) print_char_cursor
(byte*) print_char_cursor#1 101.0
(byte*) print_char_cursor#130 15.607142857142856
(byte*) print_char_cursor#132 12.0
(byte*) print_char_cursor#135 12.0
(byte*) print_char_cursor#138 24.0
(byte*) print_char_cursor#139 17.333333333333332
(byte*) print_char_cursor#141 2.4444444444444446
(byte*) print_char_cursor#163 22.0
(byte*) print_char_cursor#167 22.0
(byte*) print_char_cursor#172 22.0
(byte*) print_char_cursor#189 22.0
(byte*) print_char_cursor#19 1.8225806451612903
(byte*) print_char_cursor#84 8.0
(void()) print_cls()
(byte*) print_line_cursor
(byte*) print_line_cursor#1 3.833333333333334
(byte*) print_line_cursor#20 204.0
(byte*) print_line_cursor#39 46.0
(byte*) print_line_cursor#41 0.9565217391304348
(void()) print_ln()
(void()) print_sbyte((signed byte) print_sbyte::b)
(signed byte) print_sbyte::b
(signed byte) print_sbyte::b#0 4.0
(signed byte) print_sbyte::b#1 11.0
(signed byte) print_sbyte::b#10 8.333333333333332
(signed byte) print_sbyte::b#2 22.0
(signed byte) print_sbyte::b#3 22.0
(signed byte) print_sbyte::b#4 22.0
(signed byte) print_sbyte::b#7 4.0
(byte*) print_screen
(void()) print_str((byte*) print_str::str)
(byte*) print_str::str
(byte*) print_str::str#0 202.0
(byte*) print_str::str#13 101.5
(byte*) print_str::str#15 2.0
(void()) print_sword((signed word) print_sword::w)
(signed word) print_sword::w
(signed word) print_sword::w#0 4.0
(signed word) print_sword::w#1 11.0
(signed word) print_sword::w#10 8.333333333333332
(signed word) print_sword::w#2 22.0
(signed word) print_sword::w#3 22.0
(signed word) print_sword::w#4 22.0
(signed word) print_sword::w#7 4.0
(void()) print_word((word) print_word::w)
(word) print_word::w
(word) print_word::w#0 4.0
(word) print_word::w#1 11.0
(word) print_word::w#2 22.0
(word) print_word::w#3 22.0
(word) print_word::w#4 22.0
(word) print_word::w#5 16.666666666666664
(signed word) rem16s
(signed word) rem16s#11 0.6818181818181819
(signed word) rem16s#2 2.0
(signed word) rem16s#37 4.0
(word) rem16u
(word) rem16u#1 0.48148148148148145
(signed byte) rem8s
(signed byte) rem8s#2 2.0
(signed byte) rem8s#3 0.8333333333333335
(signed byte) rem8s#33 4.0
(byte) rem8u
(byte) rem8u#17 0.5
(void()) test_16s()
(byte~) test_16s::$11 16.5
(signed word) test_16s::dividend
(signed word) test_16s::dividend#0 4.714285714285714
(signed word) test_16s::divisor
(signed word) test_16s::divisor#0 3.0
(byte) test_16s::i
(byte) test_16s::i#1 16.5
(byte) test_16s::i#10 1.2692307692307692
(signed word) test_16s::res
(signed word) test_16s::res#0 2.2
(void()) test_16u()
(byte~) test_16u::$11 16.5
(word) test_16u::dividend
(word) test_16u::dividend#0 4.714285714285714
(word) test_16u::divisor
(word) test_16u::divisor#0 3.0
(byte) test_16u::i
(byte) test_16u::i#1 16.5
(byte) test_16u::i#10 1.2692307692307692
(word) test_16u::res
(word) test_16u::res#0 2.2
(void()) test_8s()
(signed byte) test_8s::dividend
(signed byte) test_8s::dividend#0 4.714285714285714
(signed byte) test_8s::divisor
(signed byte) test_8s::divisor#0 3.0
(byte) test_8s::i
(byte) test_8s::i#1 16.5
(byte) test_8s::i#10 1.76
(signed byte) test_8s::res
(signed byte) test_8s::res#0 2.2
(void()) test_8u()
(byte) test_8u::dividend
(byte) test_8u::dividend#0 4.714285714285714
(byte) test_8u::divisor
(byte) test_8u::divisor#0 3.3000000000000003
(byte) test_8u::i
(byte) test_8u::i#1 11.0
(byte) test_8u::i#10 1.8333333333333333
(byte) test_8u::res
(byte) test_8u::res#0 2.4444444444444446

Initial phi equivalence classes
[ test_16s::i#10 test_16s::i#1 ]
[ print_line_cursor#20 print_line_cursor#39 print_line_cursor#1 print_line_cursor#41 ]
[ print_sword::w#7 print_sword::w#0 print_sword::w#10 print_sword::w#1 print_sword::w#2 print_sword::w#3 print_sword::w#4 ]
[ print_char::ch#6 print_char::ch#4 print_char::ch#5 ]
[ print_word::w#5 print_word::w#0 print_word::w#1 print_word::w#2 print_word::w#3 print_word::w#4 ]
[ print_char_cursor#138 print_char_cursor#84 print_char_cursor#139 print_char_cursor#19 print_char_cursor#135 print_char_cursor#132 print_char_cursor#163 print_char_cursor#130 print_char_cursor#172 print_char_cursor#141 print_char_cursor#1 print_char_cursor#167 print_char_cursor#189 ]
[ print_byte::b#7 print_byte::b#0 print_byte::b#1 print_byte::b#2 print_byte::b#3 print_byte::b#4 print_byte::b#5 print_byte::b#6 ]
[ print_str::str#13 print_str::str#15 print_str::str#0 ]
[ divr16s::dividendu#3 divr16s::dividendu#7 divr16s::dividendu#8 ]
[ divr16s::divisoru#3 divr16s::divisoru#4 divr16s::divisoru#5 ]
[ divr16s::neg#4 divr16s::neg#2 divr16s::neg#3 ]
[ divr16s::return#2 divr16s::return#1 divr16s::return#7 ]
[ rem16s#11 rem16s#2 rem16s#37 ]
[ divr16u::divisor#6 divr16u::divisor#0 divr16u::divisor#1 ]
[ divr16u::rem#5 divr16u::rem#11 divr16u::rem#6 divr16u::rem#0 divr16u::rem#1 divr16u::rem#2 ]
[ divr16u::dividend#3 divr16u::dividend#5 divr16u::dividend#1 divr16u::dividend#2 divr16u::dividend#0 ]
[ divr16u::quotient#3 divr16u::return#0 divr16u::quotient#1 divr16u::quotient#2 ]
[ divr16u::i#2 divr16u::i#1 ]
[ test_8s::i#10 test_8s::i#1 ]
[ print_sbyte::b#7 print_sbyte::b#0 print_sbyte::b#10 print_sbyte::b#1 print_sbyte::b#2 print_sbyte::b#3 print_sbyte::b#4 ]
[ div8s::dividendu#3 div8s::dividendu#7 div8s::dividendu#8 ]
[ div8s::divisoru#3 div8s::divisoru#4 div8s::divisoru#5 ]
[ div8s::neg#4 div8s::neg#2 div8s::neg#3 ]
[ div8s::return#2 div8s::return#1 div8s::return#7 ]
[ rem8s#3 rem8s#2 rem8s#33 ]
[ div8u::dividend#2 div8u::dividend#0 div8u::dividend#1 ]
[ div8u::divisor#2 div8u::divisor#0 div8u::divisor#1 ]
[ divr8u::rem#4 divr8u::rem#10 divr8u::rem#5 divr8u::rem#1 divr8u::rem#2 divr8u::rem#3 ]
[ divr8u::dividend#2 divr8u::dividend#0 divr8u::dividend#1 ]
[ divr8u::quotient#3 divr8u::return#1 divr8u::quotient#1 divr8u::quotient#2 ]
[ divr8u::i#2 divr8u::i#1 ]
[ test_16u::i#10 test_16u::i#1 ]
[ test_8u::i#10 test_8u::i#1 ]
[ memset::dst#2 memset::dst#1 ]
Added variable test_16s::$11 to live range equivalence class [ test_16s::$11 ]
Added variable test_16s::dividend#0 to live range equivalence class [ test_16s::dividend#0 ]
Added variable test_16s::divisor#0 to live range equivalence class [ test_16s::divisor#0 ]
Added variable div16s::dividend#0 to live range equivalence class [ div16s::dividend#0 ]
Added variable div16s::divisor#0 to live range equivalence class [ div16s::divisor#0 ]
Added variable div16s::return#2 to live range equivalence class [ div16s::return#2 ]
Added variable test_16s::res#0 to live range equivalence class [ test_16s::res#0 ]
Added variable print_byte::$0 to live range equivalence class [ print_byte::$0 ]
Added variable print_byte::$2 to live range equivalence class [ print_byte::$2 ]
Added variable divr16s::dividend#0 to live range equivalence class [ divr16s::dividend#0 ]
Added variable divr16s::divisor#0 to live range equivalence class [ divr16s::divisor#0 ]
Added variable divr16s::return#3 to live range equivalence class [ divr16s::return#3 ]
Added variable div16s::return#0 to live range equivalence class [ div16s::return#0 ]
Added variable divr16u::return#3 to live range equivalence class [ divr16u::return#3 ]
Added variable divr16s::resultu#0 to live range equivalence class [ divr16s::resultu#0 ]
Added variable divr16s::$16 to live range equivalence class [ divr16s::$16 ]
Added variable divr16s::divisoru#1 to live range equivalence class [ divr16s::divisoru#1 ]
Added variable divr16s::dividendu#1 to live range equivalence class [ divr16s::dividendu#1 ]
Added variable divr16u::$1 to live range equivalence class [ divr16u::$1 ]
Added variable divr16u::$2 to live range equivalence class [ divr16u::$2 ]
Added variable rem16u#1 to live range equivalence class [ rem16u#1 ]
Added variable test_8s::dividend#0 to live range equivalence class [ test_8s::dividend#0 ]
Added variable test_8s::divisor#0 to live range equivalence class [ test_8s::divisor#0 ]
Added variable div8s::dividend#0 to live range equivalence class [ div8s::dividend#0 ]
Added variable div8s::divisor#0 to live range equivalence class [ div8s::divisor#0 ]
Added variable div8s::return#3 to live range equivalence class [ div8s::return#3 ]
Added variable test_8s::res#0 to live range equivalence class [ test_8s::res#0 ]
Added variable div8u::return#2 to live range equivalence class [ div8u::return#2 ]
Added variable div8s::resultu#0 to live range equivalence class [ div8s::resultu#0 ]
Added variable div8s::$11 to live range equivalence class [ div8s::$11 ]
Added variable div8s::divisoru#1 to live range equivalence class [ div8s::divisoru#1 ]
Added variable div8s::dividendu#1 to live range equivalence class [ div8s::dividendu#1 ]
Added variable divr8u::divisor#0 to live range equivalence class [ divr8u::divisor#0 ]
Added variable divr8u::return#0 to live range equivalence class [ divr8u::return#0 ]
Added variable div8u::return#0 to live range equivalence class [ div8u::return#0 ]
Added variable divr8u::$1 to live range equivalence class [ divr8u::$1 ]
Added variable rem8u#17 to live range equivalence class [ rem8u#17 ]
Added variable test_16u::$11 to live range equivalence class [ test_16u::$11 ]
Added variable test_16u::dividend#0 to live range equivalence class [ test_16u::dividend#0 ]
Added variable test_16u::divisor#0 to live range equivalence class [ test_16u::divisor#0 ]
Added variable div16u::dividend#0 to live range equivalence class [ div16u::dividend#0 ]
Added variable div16u::divisor#0 to live range equivalence class [ div16u::divisor#0 ]
Added variable div16u::return#2 to live range equivalence class [ div16u::return#2 ]
Added variable test_16u::res#0 to live range equivalence class [ test_16u::res#0 ]
Added variable divr16u::return#2 to live range equivalence class [ divr16u::return#2 ]
Added variable div16u::return#0 to live range equivalence class [ div16u::return#0 ]
Added variable test_8u::dividend#0 to live range equivalence class [ test_8u::dividend#0 ]
Added variable test_8u::divisor#0 to live range equivalence class [ test_8u::divisor#0 ]
Added variable div8u::return#3 to live range equivalence class [ div8u::return#3 ]
Added variable test_8u::res#0 to live range equivalence class [ test_8u::res#0 ]
Complete equivalence classes
[ test_16s::i#10 test_16s::i#1 ]
[ print_line_cursor#20 print_line_cursor#39 print_line_cursor#1 print_line_cursor#41 ]
[ print_sword::w#7 print_sword::w#0 print_sword::w#10 print_sword::w#1 print_sword::w#2 print_sword::w#3 print_sword::w#4 ]
[ print_char::ch#6 print_char::ch#4 print_char::ch#5 ]
[ print_word::w#5 print_word::w#0 print_word::w#1 print_word::w#2 print_word::w#3 print_word::w#4 ]
[ print_char_cursor#138 print_char_cursor#84 print_char_cursor#139 print_char_cursor#19 print_char_cursor#135 print_char_cursor#132 print_char_cursor#163 print_char_cursor#130 print_char_cursor#172 print_char_cursor#141 print_char_cursor#1 print_char_cursor#167 print_char_cursor#189 ]
[ print_byte::b#7 print_byte::b#0 print_byte::b#1 print_byte::b#2 print_byte::b#3 print_byte::b#4 print_byte::b#5 print_byte::b#6 ]
[ print_str::str#13 print_str::str#15 print_str::str#0 ]
[ divr16s::dividendu#3 divr16s::dividendu#7 divr16s::dividendu#8 ]
[ divr16s::divisoru#3 divr16s::divisoru#4 divr16s::divisoru#5 ]
[ divr16s::neg#4 divr16s::neg#2 divr16s::neg#3 ]
[ divr16s::return#2 divr16s::return#1 divr16s::return#7 ]
[ rem16s#11 rem16s#2 rem16s#37 ]
[ divr16u::divisor#6 divr16u::divisor#0 divr16u::divisor#1 ]
[ divr16u::rem#5 divr16u::rem#11 divr16u::rem#6 divr16u::rem#0 divr16u::rem#1 divr16u::rem#2 ]
[ divr16u::dividend#3 divr16u::dividend#5 divr16u::dividend#1 divr16u::dividend#2 divr16u::dividend#0 ]
[ divr16u::quotient#3 divr16u::return#0 divr16u::quotient#1 divr16u::quotient#2 ]
[ divr16u::i#2 divr16u::i#1 ]
[ test_8s::i#10 test_8s::i#1 ]
[ print_sbyte::b#7 print_sbyte::b#0 print_sbyte::b#10 print_sbyte::b#1 print_sbyte::b#2 print_sbyte::b#3 print_sbyte::b#4 ]
[ div8s::dividendu#3 div8s::dividendu#7 div8s::dividendu#8 ]
[ div8s::divisoru#3 div8s::divisoru#4 div8s::divisoru#5 ]
[ div8s::neg#4 div8s::neg#2 div8s::neg#3 ]
[ div8s::return#2 div8s::return#1 div8s::return#7 ]
[ rem8s#3 rem8s#2 rem8s#33 ]
[ div8u::dividend#2 div8u::dividend#0 div8u::dividend#1 ]
[ div8u::divisor#2 div8u::divisor#0 div8u::divisor#1 ]
[ divr8u::rem#4 divr8u::rem#10 divr8u::rem#5 divr8u::rem#1 divr8u::rem#2 divr8u::rem#3 ]
[ divr8u::dividend#2 divr8u::dividend#0 divr8u::dividend#1 ]
[ divr8u::quotient#3 divr8u::return#1 divr8u::quotient#1 divr8u::quotient#2 ]
[ divr8u::i#2 divr8u::i#1 ]
[ test_16u::i#10 test_16u::i#1 ]
[ test_8u::i#10 test_8u::i#1 ]
[ memset::dst#2 memset::dst#1 ]
[ test_16s::$11 ]
[ test_16s::dividend#0 ]
[ test_16s::divisor#0 ]
[ div16s::dividend#0 ]
[ div16s::divisor#0 ]
[ div16s::return#2 ]
[ test_16s::res#0 ]
[ print_byte::$0 ]
[ print_byte::$2 ]
[ divr16s::dividend#0 ]
[ divr16s::divisor#0 ]
[ divr16s::return#3 ]
[ div16s::return#0 ]
[ divr16u::return#3 ]
[ divr16s::resultu#0 ]
[ divr16s::$16 ]
[ divr16s::divisoru#1 ]
[ divr16s::dividendu#1 ]
[ divr16u::$1 ]
[ divr16u::$2 ]
[ rem16u#1 ]
[ test_8s::dividend#0 ]
[ test_8s::divisor#0 ]
[ div8s::dividend#0 ]
[ div8s::divisor#0 ]
[ div8s::return#3 ]
[ test_8s::res#0 ]
[ div8u::return#2 ]
[ div8s::resultu#0 ]
[ div8s::$11 ]
[ div8s::divisoru#1 ]
[ div8s::dividendu#1 ]
[ divr8u::divisor#0 ]
[ divr8u::return#0 ]
[ div8u::return#0 ]
[ divr8u::$1 ]
[ rem8u#17 ]
[ test_16u::$11 ]
[ test_16u::dividend#0 ]
[ test_16u::divisor#0 ]
[ div16u::dividend#0 ]
[ div16u::divisor#0 ]
[ div16u::return#2 ]
[ test_16u::res#0 ]
[ divr16u::return#2 ]
[ div16u::return#0 ]
[ test_8u::dividend#0 ]
[ test_8u::divisor#0 ]
[ div8u::return#3 ]
[ test_8u::res#0 ]
Allocated zp[1]:2 [ test_16s::i#10 test_16s::i#1 ]
Allocated zp[2]:3 [ print_line_cursor#20 print_line_cursor#39 print_line_cursor#1 print_line_cursor#41 ]
Allocated zp[2]:5 [ print_sword::w#7 print_sword::w#0 print_sword::w#10 print_sword::w#1 print_sword::w#2 print_sword::w#3 print_sword::w#4 ]
Allocated zp[1]:7 [ print_char::ch#6 print_char::ch#4 print_char::ch#5 ]
Allocated zp[2]:8 [ print_word::w#5 print_word::w#0 print_word::w#1 print_word::w#2 print_word::w#3 print_word::w#4 ]
Allocated zp[2]:10 [ print_char_cursor#138 print_char_cursor#84 print_char_cursor#139 print_char_cursor#19 print_char_cursor#135 print_char_cursor#132 print_char_cursor#163 print_char_cursor#130 print_char_cursor#172 print_char_cursor#141 print_char_cursor#1 print_char_cursor#167 print_char_cursor#189 ]
Allocated zp[1]:12 [ print_byte::b#7 print_byte::b#0 print_byte::b#1 print_byte::b#2 print_byte::b#3 print_byte::b#4 print_byte::b#5 print_byte::b#6 ]
Allocated zp[2]:13 [ print_str::str#13 print_str::str#15 print_str::str#0 ]
Allocated zp[2]:15 [ divr16s::dividendu#3 divr16s::dividendu#7 divr16s::dividendu#8 ]
Allocated zp[2]:17 [ divr16s::divisoru#3 divr16s::divisoru#4 divr16s::divisoru#5 ]
Allocated zp[1]:19 [ divr16s::neg#4 divr16s::neg#2 divr16s::neg#3 ]
Allocated zp[2]:20 [ divr16s::return#2 divr16s::return#1 divr16s::return#7 ]
Allocated zp[2]:22 [ rem16s#11 rem16s#2 rem16s#37 ]
Allocated zp[2]:24 [ divr16u::divisor#6 divr16u::divisor#0 divr16u::divisor#1 ]
Allocated zp[2]:26 [ divr16u::rem#5 divr16u::rem#11 divr16u::rem#6 divr16u::rem#0 divr16u::rem#1 divr16u::rem#2 ]
Allocated zp[2]:28 [ divr16u::dividend#3 divr16u::dividend#5 divr16u::dividend#1 divr16u::dividend#2 divr16u::dividend#0 ]
Allocated zp[2]:30 [ divr16u::quotient#3 divr16u::return#0 divr16u::quotient#1 divr16u::quotient#2 ]
Allocated zp[1]:32 [ divr16u::i#2 divr16u::i#1 ]
Allocated zp[1]:33 [ test_8s::i#10 test_8s::i#1 ]
Allocated zp[1]:34 [ print_sbyte::b#7 print_sbyte::b#0 print_sbyte::b#10 print_sbyte::b#1 print_sbyte::b#2 print_sbyte::b#3 print_sbyte::b#4 ]
Allocated zp[1]:35 [ div8s::dividendu#3 div8s::dividendu#7 div8s::dividendu#8 ]
Allocated zp[1]:36 [ div8s::divisoru#3 div8s::divisoru#4 div8s::divisoru#5 ]
Allocated zp[1]:37 [ div8s::neg#4 div8s::neg#2 div8s::neg#3 ]
Allocated zp[1]:38 [ div8s::return#2 div8s::return#1 div8s::return#7 ]
Allocated zp[1]:39 [ rem8s#3 rem8s#2 rem8s#33 ]
Allocated zp[1]:40 [ div8u::dividend#2 div8u::dividend#0 div8u::dividend#1 ]
Allocated zp[1]:41 [ div8u::divisor#2 div8u::divisor#0 div8u::divisor#1 ]
Allocated zp[1]:42 [ divr8u::rem#4 divr8u::rem#10 divr8u::rem#5 divr8u::rem#1 divr8u::rem#2 divr8u::rem#3 ]
Allocated zp[1]:43 [ divr8u::dividend#2 divr8u::dividend#0 divr8u::dividend#1 ]
Allocated zp[1]:44 [ divr8u::quotient#3 divr8u::return#1 divr8u::quotient#1 divr8u::quotient#2 ]
Allocated zp[1]:45 [ divr8u::i#2 divr8u::i#1 ]
Allocated zp[1]:46 [ test_16u::i#10 test_16u::i#1 ]
Allocated zp[1]:47 [ test_8u::i#10 test_8u::i#1 ]
Allocated zp[2]:48 [ memset::dst#2 memset::dst#1 ]
Allocated zp[1]:50 [ test_16s::$11 ]
Allocated zp[2]:51 [ test_16s::dividend#0 ]
Allocated zp[2]:53 [ test_16s::divisor#0 ]
Allocated zp[2]:55 [ div16s::dividend#0 ]
Allocated zp[2]:57 [ div16s::divisor#0 ]
Allocated zp[2]:59 [ div16s::return#2 ]
Allocated zp[2]:61 [ test_16s::res#0 ]
Allocated zp[1]:63 [ print_byte::$0 ]
Allocated zp[1]:64 [ print_byte::$2 ]
Allocated zp[2]:65 [ divr16s::dividend#0 ]
Allocated zp[2]:67 [ divr16s::divisor#0 ]
Allocated zp[2]:69 [ divr16s::return#3 ]
Allocated zp[2]:71 [ div16s::return#0 ]
Allocated zp[2]:73 [ divr16u::return#3 ]
Allocated zp[2]:75 [ divr16s::resultu#0 ]
Allocated zp[2]:77 [ divr16s::$16 ]
Allocated zp[2]:79 [ divr16s::divisoru#1 ]
Allocated zp[2]:81 [ divr16s::dividendu#1 ]
Allocated zp[1]:83 [ divr16u::$1 ]
Allocated zp[1]:84 [ divr16u::$2 ]
Allocated zp[2]:85 [ rem16u#1 ]
Allocated zp[1]:87 [ test_8s::dividend#0 ]
Allocated zp[1]:88 [ test_8s::divisor#0 ]
Allocated zp[1]:89 [ div8s::dividend#0 ]
Allocated zp[1]:90 [ div8s::divisor#0 ]
Allocated zp[1]:91 [ div8s::return#3 ]
Allocated zp[1]:92 [ test_8s::res#0 ]
Allocated zp[1]:93 [ div8u::return#2 ]
Allocated zp[1]:94 [ div8s::resultu#0 ]
Allocated zp[1]:95 [ div8s::$11 ]
Allocated zp[1]:96 [ div8s::divisoru#1 ]
Allocated zp[1]:97 [ div8s::dividendu#1 ]
Allocated zp[1]:98 [ divr8u::divisor#0 ]
Allocated zp[1]:99 [ divr8u::return#0 ]
Allocated zp[1]:100 [ div8u::return#0 ]
Allocated zp[1]:101 [ divr8u::$1 ]
Allocated zp[1]:102 [ rem8u#17 ]
Allocated zp[1]:103 [ test_16u::$11 ]
Allocated zp[2]:104 [ test_16u::dividend#0 ]
Allocated zp[2]:106 [ test_16u::divisor#0 ]
Allocated zp[2]:108 [ div16u::dividend#0 ]
Allocated zp[2]:110 [ div16u::divisor#0 ]
Allocated zp[2]:112 [ div16u::return#2 ]
Allocated zp[2]:114 [ test_16u::res#0 ]
Allocated zp[2]:116 [ divr16u::return#2 ]
Allocated zp[2]:118 [ div16u::return#0 ]
Allocated zp[1]:120 [ test_8u::dividend#0 ]
Allocated zp[1]:121 [ test_8u::divisor#0 ]
Allocated zp[1]:122 [ div8u::return#3 ]
Allocated zp[1]:123 [ test_8u::res#0 ]

INITIAL ASM
Target platform is c64basic / MOS6502X
  // File Comments
// Test the binary division library
  // Upstart
.pc = $801 "Basic"
:BasicUpstart(__bbegin)
.pc = $80d "Program"
  // Global Constants & labels
  .label print_char_cursor = $a
  .label print_line_cursor = 3
  // Remainder after unsigned 16-bit division
  .label rem16u = $55
  // Remainder after signed 8 bit division
  .label rem8s = $27
  // Remainder after signed 16 bit division
  .label rem16s = $16
  // Remainder after signed 8 bit division
  .label rem8u = $66
  // @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 print_cls 
    // [287] phi from main to print_cls [phi:main->print_cls]
  print_cls_from_main:
    jsr print_cls
    // [6] phi from main to main::@1 [phi:main->main::@1]
  __b1_from_main:
    jmp __b1
    // main::@1
  __b1:
    // [7] call test_8u 
    // [258] phi from main::@1 to test_8u [phi:main::@1->test_8u]
  test_8u_from___b1:
    jsr test_8u
    // [8] phi from main::@1 to main::@2 [phi:main::@1->main::@2]
  __b2_from___b1:
    jmp __b2
    // main::@2
  __b2:
    // [9] call test_16u 
    // [222] phi from main::@2 to test_16u [phi:main::@2->test_16u]
  test_16u_from___b2:
    jsr test_16u
    // [10] phi from main::@2 to main::@3 [phi:main::@2->main::@3]
  __b3_from___b2:
    jmp __b3
    // main::@3
  __b3:
    // [11] call test_8s 
    // [134] phi from main::@3 to test_8s [phi:main::@3->test_8s]
  test_8s_from___b3:
    jsr test_8s
    // [12] phi from main::@3 to main::@4 [phi:main::@3->main::@4]
  __b4_from___b3:
    jmp __b4
    // main::@4
  __b4:
    // [13] call test_16s 
    // [15] phi from main::@4 to test_16s [phi:main::@4->test_16s]
  test_16s_from___b4:
    jsr test_16s
    jmp __breturn
    // main::@return
  __breturn:
    // [14] return 
    rts
}
  // test_16s
test_16s: {
    .label __11 = $32
    .label dividend = $33
    .label divisor = $35
    .label res = $3d
    .label i = 2
    // [16] phi from test_16s to test_16s::@1 [phi:test_16s->test_16s::@1]
  __b1_from_test_16s:
    // [16] phi (byte) test_16s::i#10 = (byte) 0 [phi:test_16s->test_16s::@1#0] -- vbuz1=vbuc1 
    lda #0
    sta.z i
    jmp __b1
    // [16] phi from test_16s::@10 to test_16s::@1 [phi:test_16s::@10->test_16s::@1]
  __b1_from___b10:
    // [16] phi (byte) test_16s::i#10 = (byte) test_16s::i#1 [phi:test_16s::@10->test_16s::@1#0] -- register_copy 
    jmp __b1
    // test_16s::@1
  __b1:
    // [17] (byte~) test_16s::$11 ← (byte) test_16s::i#10 << (byte) 1 -- vbuz1=vbuz2_rol_1 
    lda.z i
    asl
    sta.z __11
    // [18] (signed word) test_16s::dividend#0 ← *((const signed word*) test_16s::dividends + (byte~) test_16s::$11) -- vwsz1=pwsc1_derefidx_vbuz2 
    ldy.z __11
    lda dividends,y
    sta.z dividend
    lda dividends+1,y
    sta.z dividend+1
    // [19] (signed word) test_16s::divisor#0 ← *((const signed word*) test_16s::divisors + (byte~) test_16s::$11) -- vwsz1=pwsc1_derefidx_vbuz2 
    ldy.z __11
    lda divisors,y
    sta.z divisor
    lda divisors+1,y
    sta.z divisor+1
    // [20] (signed word) div16s::dividend#0 ← (signed word) test_16s::dividend#0 -- vwsz1=vwsz2 
    lda.z dividend
    sta.z div16s.dividend
    lda.z dividend+1
    sta.z div16s.dividend+1
    // [21] (signed word) div16s::divisor#0 ← (signed word) test_16s::divisor#0 -- vwsz1=vwsz2 
    lda.z divisor
    sta.z div16s.divisor
    lda.z divisor+1
    sta.z div16s.divisor+1
    // [22] call div16s 
    jsr div16s
    // [23] (signed word) div16s::return#2 ← (signed word) div16s::return#0 -- vwsz1=vwsz2 
    lda.z div16s.return
    sta.z div16s.return_1
    lda.z div16s.return+1
    sta.z div16s.return_1+1
    jmp __b2
    // test_16s::@2
  __b2:
    // [24] (signed word) test_16s::res#0 ← (signed word) div16s::return#2 -- vwsz1=vwsz2 
    lda.z div16s.return_1
    sta.z res
    lda.z div16s.return_1+1
    sta.z res+1
    // [25] (signed word) print_sword::w#1 ← (signed word) test_16s::dividend#0 -- vwsz1=vwsz2 
    lda.z dividend
    sta.z print_sword.w
    lda.z dividend+1
    sta.z print_sword.w+1
    // [26] (byte*) print_char_cursor#163 ← (byte*) print_line_cursor#1 -- pbuz1=pbuz2 
    lda.z print_line_cursor
    sta.z print_char_cursor
    lda.z print_line_cursor+1
    sta.z print_char_cursor+1
    // [27] call print_sword 
    // [50] phi from test_16s::@2 to print_sword [phi:test_16s::@2->print_sword]
  print_sword_from___b2:
    // [50] phi (byte*) print_char_cursor#132 = (byte*) print_char_cursor#163 [phi:test_16s::@2->print_sword#0] -- register_copy 
    // [50] phi (signed word) print_sword::w#10 = (signed word) print_sword::w#1 [phi:test_16s::@2->print_sword#1] -- register_copy 
    jsr print_sword
    // [28] phi from test_16s::@2 to test_16s::@3 [phi:test_16s::@2->test_16s::@3]
  __b3_from___b2:
    jmp __b3
    // test_16s::@3
  __b3:
    // [29] call print_str 
    // [79] phi from test_16s::@3 to print_str [phi:test_16s::@3->print_str]
  print_str_from___b3:
    // [79] phi (byte*) print_str::str#15 = (const string) str [phi:test_16s::@3->print_str#0] -- pbuz1=pbuc1 
    lda #<str
    sta.z print_str.str
    lda #>str
    sta.z print_str.str+1
    jsr print_str
    jmp __b4
    // test_16s::@4
  __b4:
    // [30] (signed word) print_sword::w#2 ← (signed word) test_16s::divisor#0 -- vwsz1=vwsz2 
    lda.z divisor
    sta.z print_sword.w
    lda.z divisor+1
    sta.z print_sword.w+1
    // [31] call print_sword 
    // [50] phi from test_16s::@4 to print_sword [phi:test_16s::@4->print_sword]
  print_sword_from___b4:
    // [50] phi (byte*) print_char_cursor#132 = (byte*) print_char_cursor#130 [phi:test_16s::@4->print_sword#0] -- register_copy 
    // [50] phi (signed word) print_sword::w#10 = (signed word) print_sword::w#2 [phi:test_16s::@4->print_sword#1] -- register_copy 
    jsr print_sword
    // [32] phi from test_16s::@4 to test_16s::@5 [phi:test_16s::@4->test_16s::@5]
  __b5_from___b4:
    jmp __b5
    // test_16s::@5
  __b5:
    // [33] call print_str 
    // [79] phi from test_16s::@5 to print_str [phi:test_16s::@5->print_str]
  print_str_from___b5:
    // [79] phi (byte*) print_str::str#15 = (const string) str1 [phi:test_16s::@5->print_str#0] -- pbuz1=pbuc1 
    lda #<str1
    sta.z print_str.str
    lda #>str1
    sta.z print_str.str+1
    jsr print_str
    jmp __b6
    // test_16s::@6
  __b6:
    // [34] (signed word) print_sword::w#3 ← (signed word) test_16s::res#0 -- vwsz1=vwsz2 
    lda.z res
    sta.z print_sword.w
    lda.z res+1
    sta.z print_sword.w+1
    // [35] call print_sword 
    // [50] phi from test_16s::@6 to print_sword [phi:test_16s::@6->print_sword]
  print_sword_from___b6:
    // [50] phi (byte*) print_char_cursor#132 = (byte*) print_char_cursor#130 [phi:test_16s::@6->print_sword#0] -- register_copy 
    // [50] phi (signed word) print_sword::w#10 = (signed word) print_sword::w#3 [phi:test_16s::@6->print_sword#1] -- register_copy 
    jsr print_sword
    // [36] phi from test_16s::@6 to test_16s::@7 [phi:test_16s::@6->test_16s::@7]
  __b7_from___b6:
    jmp __b7
    // test_16s::@7
  __b7:
    // [37] call print_str 
    // [79] phi from test_16s::@7 to print_str [phi:test_16s::@7->print_str]
  print_str_from___b7:
    // [79] phi (byte*) print_str::str#15 = (const string) str2 [phi:test_16s::@7->print_str#0] -- pbuz1=pbuc1 
    lda #<str2
    sta.z print_str.str
    lda #>str2
    sta.z print_str.str+1
    jsr print_str
    jmp __b8
    // test_16s::@8
  __b8:
    // [38] (signed word) print_sword::w#4 ← (signed word) rem16s#11 -- vwsz1=vwsz2 
    lda.z rem16s
    sta.z print_sword.w
    lda.z rem16s+1
    sta.z print_sword.w+1
    // [39] call print_sword 
    // [50] phi from test_16s::@8 to print_sword [phi:test_16s::@8->print_sword]
  print_sword_from___b8:
    // [50] phi (byte*) print_char_cursor#132 = (byte*) print_char_cursor#130 [phi:test_16s::@8->print_sword#0] -- register_copy 
    // [50] phi (signed word) print_sword::w#10 = (signed word) print_sword::w#4 [phi:test_16s::@8->print_sword#1] -- register_copy 
    jsr print_sword
    // [40] phi from test_16s::@8 to test_16s::@9 [phi:test_16s::@8->test_16s::@9]
  __b9_from___b8:
    jmp __b9
    // test_16s::@9
  __b9:
    // [41] call print_ln 
    // [45] phi from test_16s::@9 to print_ln [phi:test_16s::@9->print_ln]
  print_ln_from___b9:
    // [45] phi (byte*) print_line_cursor#39 = (byte*) print_line_cursor#1 [phi:test_16s::@9->print_ln#0] -- register_copy 
    jsr print_ln
    jmp __b10
    // test_16s::@10
  __b10:
    // [42] (byte) test_16s::i#1 ← ++ (byte) test_16s::i#10 -- vbuz1=_inc_vbuz1 
    inc.z i
    // [43] if((byte) test_16s::i#1!=(byte) 6) goto test_16s::@1 -- vbuz1_neq_vbuc1_then_la1 
    lda #6
    cmp.z i
    bne __b1_from___b10
    jmp __breturn
    // test_16s::@return
  __breturn:
    // [44] return 
    rts
    dividends: .word $7fff, $7fff, -$7fff, -$7fff, $7fff, -$7fff
    divisors: .word 5, -7, $b, -$d, -$11, $13
}
  // print_ln
// Print a newline
print_ln: {
    // [46] phi from print_ln print_ln::@1 to print_ln::@1 [phi:print_ln/print_ln::@1->print_ln::@1]
  __b1_from_print_ln:
  __b1_from___b1:
    // [46] phi (byte*) print_line_cursor#20 = (byte*) print_line_cursor#39 [phi:print_ln/print_ln::@1->print_ln::@1#0] -- register_copy 
    jmp __b1
    // print_ln::@1
  __b1:
    // [47] (byte*) print_line_cursor#1 ← (byte*) print_line_cursor#20 + (byte) $28 -- pbuz1=pbuz1_plus_vbuc1 
    lda #$28
    clc
    adc.z print_line_cursor
    sta.z print_line_cursor
    bcc !+
    inc.z print_line_cursor+1
  !:
    // [48] if((byte*) print_line_cursor#1<(byte*) print_char_cursor#19) goto print_ln::@1 -- pbuz1_lt_pbuz2_then_la1 
    lda.z print_line_cursor+1
    cmp.z print_char_cursor+1
    bcc __b1_from___b1
    bne !+
    lda.z print_line_cursor
    cmp.z print_char_cursor
    bcc __b1_from___b1
  !:
    jmp __breturn
    // print_ln::@return
  __breturn:
    // [49] return 
    rts
}
  // print_sword
// Print a signed word as HEX
// print_sword(signed word zp(5) w)
print_sword: {
    .label w = 5
    // [51] if((signed word) print_sword::w#10<(signed byte) 0) goto print_sword::@1 -- vwsz1_lt_0_then_la1 
    lda.z w+1
    bmi __b1_from_print_sword
    // [52] phi from print_sword to print_sword::@3 [phi:print_sword->print_sword::@3]
  __b3_from_print_sword:
    jmp __b3
    // print_sword::@3
  __b3:
    // [53] call print_char 
    // [61] phi from print_sword::@3 to print_char [phi:print_sword::@3->print_char]
  print_char_from___b3:
    // [61] phi (byte*) print_char_cursor#84 = (byte*) print_char_cursor#132 [phi:print_sword::@3->print_char#0] -- register_copy 
    // [61] phi (byte) print_char::ch#6 = (byte) ' ' [phi:print_sword::@3->print_char#1] -- vbuz1=vbuc1 
    lda #' '
    sta.z print_char.ch
    jsr print_char
    // [54] phi from print_sword::@3 print_sword::@4 to print_sword::@2 [phi:print_sword::@3/print_sword::@4->print_sword::@2]
  __b2_from___b3:
  __b2_from___b4:
    // [54] phi (signed word) print_sword::w#7 = (signed word) print_sword::w#10 [phi:print_sword::@3/print_sword::@4->print_sword::@2#0] -- register_copy 
    jmp __b2
    // print_sword::@2
  __b2:
    // [55] (word) print_word::w#0 ← (word)(signed word) print_sword::w#7 -- vwuz1=vwuz2 
    lda.z w
    sta.z print_word.w
    lda.z w+1
    sta.z print_word.w+1
    // [56] call print_word 
    // [65] phi from print_sword::@2 to print_word [phi:print_sword::@2->print_word]
  print_word_from___b2:
    // [65] phi (byte*) print_char_cursor#138 = (byte*) print_char_cursor#19 [phi:print_sword::@2->print_word#0] -- register_copy 
    // [65] phi (word) print_word::w#5 = (word) print_word::w#0 [phi:print_sword::@2->print_word#1] -- register_copy 
    jsr print_word
    jmp __breturn
    // print_sword::@return
  __breturn:
    // [57] return 
    rts
    // [58] phi from print_sword to print_sword::@1 [phi:print_sword->print_sword::@1]
  __b1_from_print_sword:
    jmp __b1
    // print_sword::@1
  __b1:
    // [59] call print_char 
    // [61] phi from print_sword::@1 to print_char [phi:print_sword::@1->print_char]
  print_char_from___b1:
    // [61] phi (byte*) print_char_cursor#84 = (byte*) print_char_cursor#132 [phi:print_sword::@1->print_char#0] -- register_copy 
    // [61] phi (byte) print_char::ch#6 = (byte) '-' [phi:print_sword::@1->print_char#1] -- vbuz1=vbuc1 
    lda #'-'
    sta.z print_char.ch
    jsr print_char
    jmp __b4
    // print_sword::@4
  __b4:
    // [60] (signed word) print_sword::w#0 ← - (signed word) print_sword::w#10 -- vwsz1=_neg_vwsz1 
    sec
    lda #0
    sbc.z w
    sta.z w
    lda #0
    sbc.z w+1
    sta.z w+1
    jmp __b2_from___b4
}
  // print_char
// Print a single char
// print_char(byte zp(7) ch)
print_char: {
    .label ch = 7
    // [62] *((byte*) print_char_cursor#84) ← (byte) print_char::ch#6 -- _deref_pbuz1=vbuz2 
    lda.z ch
    ldy #0
    sta (print_char_cursor),y
    // [63] (byte*) print_char_cursor#19 ← ++ (byte*) print_char_cursor#84 -- pbuz1=_inc_pbuz1 
    inc.z print_char_cursor
    bne !+
    inc.z print_char_cursor+1
  !:
    jmp __breturn
    // print_char::@return
  __breturn:
    // [64] return 
    rts
}
  // print_word
// Print a word as HEX
// print_word(word zp(8) w)
print_word: {
    .label w = 8
    // [66] (byte) print_byte::b#1 ← > (word) print_word::w#5 -- vbuz1=_hi_vwuz2 
    lda.z w+1
    sta.z print_byte.b
    // [67] call print_byte 
    // [71] phi from print_word to print_byte [phi:print_word->print_byte]
  print_byte_from_print_word:
    // [71] phi (byte*) print_char_cursor#139 = (byte*) print_char_cursor#138 [phi:print_word->print_byte#0] -- register_copy 
    // [71] phi (byte) print_byte::b#7 = (byte) print_byte::b#1 [phi:print_word->print_byte#1] -- register_copy 
    jsr print_byte
    jmp __b1
    // print_word::@1
  __b1:
    // [68] (byte) print_byte::b#2 ← < (word) print_word::w#5 -- vbuz1=_lo_vwuz2 
    lda.z w
    sta.z print_byte.b
    // [69] call print_byte 
    // [71] phi from print_word::@1 to print_byte [phi:print_word::@1->print_byte]
  print_byte_from___b1:
    // [71] phi (byte*) print_char_cursor#139 = (byte*) print_char_cursor#19 [phi:print_word::@1->print_byte#0] -- register_copy 
    // [71] phi (byte) print_byte::b#7 = (byte) print_byte::b#2 [phi:print_word::@1->print_byte#1] -- register_copy 
    jsr print_byte
    jmp __breturn
    // print_word::@return
  __breturn:
    // [70] return 
    rts
}
  // print_byte
// Print a byte as HEX
// print_byte(byte zp($c) b)
print_byte: {
    .label __0 = $3f
    .label __2 = $40
    .label b = $c
    // [72] (byte~) print_byte::$0 ← (byte) print_byte::b#7 >> (byte) 4 -- vbuz1=vbuz2_ror_4 
    lda.z b
    lsr
    lsr
    lsr
    lsr
    sta.z __0
    // [73] (byte) print_char::ch#4 ← *((const byte*) print_hextab + (byte~) print_byte::$0) -- vbuz1=pbuc1_derefidx_vbuz2 
    ldy.z __0
    lda print_hextab,y
    sta.z print_char.ch
    // [74] call print_char 
    // [61] phi from print_byte to print_char [phi:print_byte->print_char]
  print_char_from_print_byte:
    // [61] phi (byte*) print_char_cursor#84 = (byte*) print_char_cursor#139 [phi:print_byte->print_char#0] -- register_copy 
    // [61] phi (byte) print_char::ch#6 = (byte) print_char::ch#4 [phi:print_byte->print_char#1] -- register_copy 
    jsr print_char
    jmp __b1
    // print_byte::@1
  __b1:
    // [75] (byte~) print_byte::$2 ← (byte) print_byte::b#7 & (byte) $f -- vbuz1=vbuz2_band_vbuc1 
    lda #$f
    and.z b
    sta.z __2
    // [76] (byte) print_char::ch#5 ← *((const byte*) print_hextab + (byte~) print_byte::$2) -- vbuz1=pbuc1_derefidx_vbuz2 
    ldy.z __2
    lda print_hextab,y
    sta.z print_char.ch
    // [77] call print_char 
    // [61] phi from print_byte::@1 to print_char [phi:print_byte::@1->print_char]
  print_char_from___b1:
    // [61] phi (byte*) print_char_cursor#84 = (byte*) print_char_cursor#19 [phi:print_byte::@1->print_char#0] -- register_copy 
    // [61] phi (byte) print_char::ch#6 = (byte) print_char::ch#5 [phi:print_byte::@1->print_char#1] -- register_copy 
    jsr print_char
    jmp __breturn
    // print_byte::@return
  __breturn:
    // [78] return 
    rts
}
  // print_str
// Print a zero-terminated string
// print_str(byte* zp($d) str)
print_str: {
    .label str = $d
    // [80] phi from print_str print_str::@2 to print_str::@1 [phi:print_str/print_str::@2->print_str::@1]
  __b1_from_print_str:
  __b1_from___b2:
    // [80] phi (byte*) print_char_cursor#130 = (byte*) print_char_cursor#19 [phi:print_str/print_str::@2->print_str::@1#0] -- register_copy 
    // [80] phi (byte*) print_str::str#13 = (byte*) print_str::str#15 [phi:print_str/print_str::@2->print_str::@1#1] -- register_copy 
    jmp __b1
    // print_str::@1
  __b1:
    // [81] if((byte) 0!=*((byte*) print_str::str#13)) goto print_str::@2 -- vbuc1_neq__deref_pbuz1_then_la1 
    ldy #0
    lda (str),y
    cmp #0
    bne __b2
    jmp __breturn
    // print_str::@return
  __breturn:
    // [82] return 
    rts
    // print_str::@2
  __b2:
    // [83] *((byte*) print_char_cursor#130) ← *((byte*) print_str::str#13) -- _deref_pbuz1=_deref_pbuz2 
    ldy #0
    lda (str),y
    ldy #0
    sta (print_char_cursor),y
    // [84] (byte*) print_char_cursor#1 ← ++ (byte*) print_char_cursor#130 -- pbuz1=_inc_pbuz1 
    inc.z print_char_cursor
    bne !+
    inc.z print_char_cursor+1
  !:
    // [85] (byte*) print_str::str#0 ← ++ (byte*) print_str::str#13 -- pbuz1=_inc_pbuz1 
    inc.z str
    bne !+
    inc.z str+1
  !:
    jmp __b1_from___b2
}
  // div16s
// Perform division on two signed 16-bit numbers
// Returns dividend/divisor.
// The remainder will be set into the global variable rem16s.
// Implemented using simple binary division
// Follows the C99 standard by truncating toward zero on negative results.
// See http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1124.pdf section 6.5.5
// div16s(signed word zp($37) dividend, signed word zp($39) divisor)
div16s: {
    .label return = $47
    .label dividend = $37
    .label divisor = $39
    .label return_1 = $3b
    // [86] (signed word) divr16s::dividend#0 ← (signed word) div16s::dividend#0 -- vwsz1=vwsz2 
    lda.z dividend
    sta.z divr16s.dividend
    lda.z dividend+1
    sta.z divr16s.dividend+1
    // [87] (signed word) divr16s::divisor#0 ← (signed word) div16s::divisor#0 -- vwsz1=vwsz2 
    lda.z divisor
    sta.z divr16s.divisor
    lda.z divisor+1
    sta.z divr16s.divisor+1
    // [88] call divr16s 
    jsr divr16s
    // [89] (signed word) divr16s::return#3 ← (signed word) divr16s::return#2 -- vwsz1=vwsz2 
    lda.z divr16s.return
    sta.z divr16s.return_1
    lda.z divr16s.return+1
    sta.z divr16s.return_1+1
    jmp __b1
    // div16s::@1
  __b1:
    // [90] (signed word) div16s::return#0 ← (signed word) divr16s::return#3 -- vwsz1=vwsz2 
    lda.z divr16s.return_1
    sta.z return
    lda.z divr16s.return_1+1
    sta.z return+1
    jmp __breturn
    // div16s::@return
  __breturn:
    // [91] return 
    rts
}
  // divr16s
// Perform division on two signed 16-bit numbers with an initial remainder.
// Returns dividend/divisor. The remainder will be set into the global variable rem16s.
// Implemented using simple binary division
// Follows the C99 standard by truncating toward zero on negative results.
// See http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1124.pdf section 6.5.5
// divr16s(signed word zp($41) dividend, signed word zp($43) divisor)
divr16s: {
    .label __16 = $4d
    .label dividendu = $51
    .label divisoru = $4f
    .label neg = $13
    .label resultu = $4b
    .label return = $14
    .label dividend = $41
    .label divisor = $43
    .label return_1 = $45
    .label dividendu_1 = $f
    .label divisoru_1 = $11
    // [92] if((signed word) divr16s::dividend#0<(signed byte) 0) goto divr16s::@1 -- vwsz1_lt_0_then_la1 
    lda.z dividend+1
    bmi __b1
    jmp __b6
    // divr16s::@6
  __b6:
    // [93] (word) divr16s::dividendu#8 ← (word)(signed word) divr16s::dividend#0 -- vwuz1=vwuz2 
    lda.z dividend
    sta.z dividendu_1
    lda.z dividend+1
    sta.z dividendu_1+1
    // [94] phi from divr16s::@6 to divr16s::@2 [phi:divr16s::@6->divr16s::@2]
  __b2_from___b6:
    // [94] phi (word) divr16s::dividendu#3 = (word) divr16s::dividendu#8 [phi:divr16s::@6->divr16s::@2#0] -- register_copy 
    // [94] phi (byte) divr16s::neg#3 = (byte) 0 [phi:divr16s::@6->divr16s::@2#1] -- vbuz1=vbuc1 
    lda #0
    sta.z neg
    jmp __b2
    // divr16s::@2
  __b2:
    // [95] if((signed word) divr16s::divisor#0<(signed byte) 0) goto divr16s::@3 -- vwsz1_lt_0_then_la1 
    lda.z divisor+1
    bmi __b3
    jmp __b7
    // divr16s::@7
  __b7:
    // [96] (word) divr16s::divisoru#5 ← (word)(signed word) divr16s::divisor#0 -- vwuz1=vwuz2 
    lda.z divisor
    sta.z divisoru_1
    lda.z divisor+1
    sta.z divisoru_1+1
    // [97] phi from divr16s::@3 divr16s::@7 to divr16s::@4 [phi:divr16s::@3/divr16s::@7->divr16s::@4]
  __b4_from___b3:
  __b4_from___b7:
    // [97] phi (byte) divr16s::neg#4 = (byte) divr16s::neg#2 [phi:divr16s::@3/divr16s::@7->divr16s::@4#0] -- register_copy 
    // [97] phi (word) divr16s::divisoru#3 = (word) divr16s::divisoru#4 [phi:divr16s::@3/divr16s::@7->divr16s::@4#1] -- register_copy 
    jmp __b4
    // divr16s::@4
  __b4:
    // [98] (word) divr16u::dividend#2 ← (word) divr16s::dividendu#3 -- vwuz1=vwuz2 
    lda.z dividendu_1
    sta.z divr16u.dividend
    lda.z dividendu_1+1
    sta.z divr16u.dividend+1
    // [99] (word) divr16u::divisor#1 ← (word) divr16s::divisoru#3 -- vwuz1=vwuz2 
    lda.z divisoru_1
    sta.z divr16u.divisor
    lda.z divisoru_1+1
    sta.z divr16u.divisor+1
    // [100] call divr16u 
    // [116] phi from divr16s::@4 to divr16u [phi:divr16s::@4->divr16u]
  divr16u_from___b4:
    // [116] phi (word) divr16u::divisor#6 = (word) divr16u::divisor#1 [phi:divr16s::@4->divr16u#0] -- register_copy 
    // [116] phi (word) divr16u::dividend#5 = (word) divr16u::dividend#2 [phi:divr16s::@4->divr16u#1] -- register_copy 
    jsr divr16u
    // [101] (word) divr16u::return#3 ← (word) divr16u::return#0 -- vwuz1=vwuz2 
    lda.z divr16u.return
    sta.z divr16u.return_2
    lda.z divr16u.return+1
    sta.z divr16u.return_2+1
    jmp __b9
    // divr16s::@9
  __b9:
    // [102] (word) divr16s::resultu#0 ← (word) divr16u::return#3 -- vwuz1=vwuz2 
    lda.z divr16u.return_2
    sta.z resultu
    lda.z divr16u.return_2+1
    sta.z resultu+1
    // [103] if((byte) divr16s::neg#4==(byte) 0) goto divr16s::@5 -- vbuz1_eq_0_then_la1 
    lda.z neg
    cmp #0
    beq __b5
    jmp __b8
    // divr16s::@8
  __b8:
    // [104] (signed word~) divr16s::$16 ← (signed word)(word) rem16u#1 -- vwsz1=vwsz2 
    lda.z rem16u
    sta.z __16
    lda.z rem16u+1
    sta.z __16+1
    // [105] (signed word) rem16s#2 ← - (signed word~) divr16s::$16 -- vwsz1=_neg_vwsz2 
    sec
    lda #0
    sbc.z __16
    sta.z rem16s
    lda #0
    sbc.z __16+1
    sta.z rem16s+1
    // [106] (signed word) divr16s::return#1 ← - (signed word)(word) divr16s::resultu#0 -- vwsz1=_neg_vwsz2 
    sec
    lda #0
    sbc.z resultu
    sta.z return
    lda #0
    sbc.z resultu+1
    sta.z return+1
    // [107] phi from divr16s::@5 divr16s::@8 to divr16s::@return [phi:divr16s::@5/divr16s::@8->divr16s::@return]
  __breturn_from___b5:
  __breturn_from___b8:
    // [107] phi (signed word) rem16s#11 = (signed word) rem16s#37 [phi:divr16s::@5/divr16s::@8->divr16s::@return#0] -- register_copy 
    // [107] phi (signed word) divr16s::return#2 = (signed word) divr16s::return#7 [phi:divr16s::@5/divr16s::@8->divr16s::@return#1] -- register_copy 
    jmp __breturn
    // divr16s::@return
  __breturn:
    // [108] return 
    rts
    // divr16s::@5
  __b5:
    // [109] (signed word) divr16s::return#7 ← (signed word)(word) divr16s::resultu#0 -- vwsz1=vwsz2 
    lda.z resultu
    sta.z return
    lda.z resultu+1
    sta.z return+1
    // [110] (signed word) rem16s#37 ← (signed word)(word) rem16u#1 -- vwsz1=vwsz2 
    lda.z rem16u
    sta.z rem16s
    lda.z rem16u+1
    sta.z rem16s+1
    jmp __breturn_from___b5
    // divr16s::@3
  __b3:
    // [111] (signed word) divr16s::divisoru#1 ← - (signed word) divr16s::divisor#0 -- vwsz1=_neg_vwsz2 
    sec
    lda #0
    sbc.z divisor
    sta.z divisoru
    lda #0
    sbc.z divisor+1
    sta.z divisoru+1
    // [112] (byte) divr16s::neg#2 ← (byte) divr16s::neg#3 ^ (byte) 1 -- vbuz1=vbuz1_bxor_vbuc1 
    lda #1
    eor.z neg
    sta.z neg
    // [113] (word) divr16s::divisoru#4 ← (word)(signed word) divr16s::divisoru#1 -- vwuz1=vwuz2 
    lda.z divisoru
    sta.z divisoru_1
    lda.z divisoru+1
    sta.z divisoru_1+1
    jmp __b4_from___b3
    // divr16s::@1
  __b1:
    // [114] (signed word) divr16s::dividendu#1 ← - (signed word) divr16s::dividend#0 -- vwsz1=_neg_vwsz2 
    sec
    lda #0
    sbc.z dividend
    sta.z dividendu
    lda #0
    sbc.z dividend+1
    sta.z dividendu+1
    // [115] (word) divr16s::dividendu#7 ← (word)(signed word) divr16s::dividendu#1 -- vwuz1=vwuz2 
    lda.z dividendu
    sta.z dividendu_1
    lda.z dividendu+1
    sta.z dividendu_1+1
    // [94] phi from divr16s::@1 to divr16s::@2 [phi:divr16s::@1->divr16s::@2]
  __b2_from___b1:
    // [94] phi (word) divr16s::dividendu#3 = (word) divr16s::dividendu#7 [phi:divr16s::@1->divr16s::@2#0] -- register_copy 
    // [94] phi (byte) divr16s::neg#3 = (byte) 1 [phi:divr16s::@1->divr16s::@2#1] -- vbuz1=vbuc1 
    lda #1
    sta.z neg
    jmp __b2
}
  // divr16u
// Performs division on two 16 bit unsigned words and an initial remainder
// Returns the quotient dividend/divisor.
// The final remainder will be set into the global variable rem16u
// Implemented using simple binary division
// divr16u(word zp($1c) dividend, word zp($18) divisor, word zp($1a) rem)
divr16u: {
    .label __1 = $53
    .label __2 = $54
    .label rem = $1a
    .label dividend = $1c
    .label quotient = $1e
    .label i = $20
    .label return = $1e
    .label divisor = $18
    .label return_1 = $74
    .label return_2 = $49
    // [117] phi from divr16u to divr16u::@1 [phi:divr16u->divr16u::@1]
  __b1_from_divr16u:
    // [117] phi (byte) divr16u::i#2 = (byte) 0 [phi:divr16u->divr16u::@1#0] -- vbuz1=vbuc1 
    lda #0
    sta.z i
    // [117] phi (word) divr16u::quotient#3 = (word) 0 [phi:divr16u->divr16u::@1#1] -- vwuz1=vwuc1 
    lda #<0
    sta.z quotient
    lda #>0
    sta.z quotient+1
    // [117] phi (word) divr16u::dividend#3 = (word) divr16u::dividend#5 [phi:divr16u->divr16u::@1#2] -- register_copy 
    // [117] phi (word) divr16u::rem#5 = (byte) 0 [phi:divr16u->divr16u::@1#3] -- vwuz1=vbuc1 
    lda #<0
    sta.z rem
    lda #>0
    sta.z rem+1
    jmp __b1
    // [117] phi from divr16u::@3 to divr16u::@1 [phi:divr16u::@3->divr16u::@1]
  __b1_from___b3:
    // [117] phi (byte) divr16u::i#2 = (byte) divr16u::i#1 [phi:divr16u::@3->divr16u::@1#0] -- register_copy 
    // [117] phi (word) divr16u::quotient#3 = (word) divr16u::return#0 [phi:divr16u::@3->divr16u::@1#1] -- register_copy 
    // [117] phi (word) divr16u::dividend#3 = (word) divr16u::dividend#0 [phi:divr16u::@3->divr16u::@1#2] -- register_copy 
    // [117] phi (word) divr16u::rem#5 = (word) divr16u::rem#11 [phi:divr16u::@3->divr16u::@1#3] -- register_copy 
    jmp __b1
    // divr16u::@1
  __b1:
    // [118] (word) divr16u::rem#0 ← (word) divr16u::rem#5 << (byte) 1 -- vwuz1=vwuz1_rol_1 
    asl.z rem
    rol.z rem+1
    // [119] (byte~) divr16u::$1 ← > (word) divr16u::dividend#3 -- vbuz1=_hi_vwuz2 
    lda.z dividend+1
    sta.z __1
    // [120] (byte~) divr16u::$2 ← (byte~) divr16u::$1 & (byte) $80 -- vbuz1=vbuz2_band_vbuc1 
    lda #$80
    and.z __1
    sta.z __2
    // [121] if((byte~) divr16u::$2==(byte) 0) goto divr16u::@2 -- vbuz1_eq_0_then_la1 
    lda.z __2
    cmp #0
    beq __b2_from___b1
    jmp __b4
    // divr16u::@4
  __b4:
    // [122] (word) divr16u::rem#1 ← (word) divr16u::rem#0 | (byte) 1 -- vwuz1=vwuz1_bor_vbuc1 
    lda #1
    ora.z rem
    sta.z rem
    // [123] phi from divr16u::@1 divr16u::@4 to divr16u::@2 [phi:divr16u::@1/divr16u::@4->divr16u::@2]
  __b2_from___b1:
  __b2_from___b4:
    // [123] phi (word) divr16u::rem#6 = (word) divr16u::rem#0 [phi:divr16u::@1/divr16u::@4->divr16u::@2#0] -- register_copy 
    jmp __b2
    // divr16u::@2
  __b2:
    // [124] (word) divr16u::dividend#0 ← (word) divr16u::dividend#3 << (byte) 1 -- vwuz1=vwuz1_rol_1 
    asl.z dividend
    rol.z dividend+1
    // [125] (word) divr16u::quotient#1 ← (word) divr16u::quotient#3 << (byte) 1 -- vwuz1=vwuz1_rol_1 
    asl.z quotient
    rol.z quotient+1
    // [126] if((word) divr16u::rem#6<(word) divr16u::divisor#6) goto divr16u::@3 -- vwuz1_lt_vwuz2_then_la1 
    lda.z rem+1
    cmp.z divisor+1
    bcc __b3_from___b2
    bne !+
    lda.z rem
    cmp.z divisor
    bcc __b3_from___b2
  !:
    jmp __b5
    // divr16u::@5
  __b5:
    // [127] (word) divr16u::quotient#2 ← ++ (word) divr16u::quotient#1 -- vwuz1=_inc_vwuz1 
    inc.z quotient
    bne !+
    inc.z quotient+1
  !:
    // [128] (word) divr16u::rem#2 ← (word) divr16u::rem#6 - (word) divr16u::divisor#6 -- vwuz1=vwuz1_minus_vwuz2 
    lda.z rem
    sec
    sbc.z divisor
    sta.z rem
    lda.z rem+1
    sbc.z divisor+1
    sta.z rem+1
    // [129] phi from divr16u::@2 divr16u::@5 to divr16u::@3 [phi:divr16u::@2/divr16u::@5->divr16u::@3]
  __b3_from___b2:
  __b3_from___b5:
    // [129] phi (word) divr16u::return#0 = (word) divr16u::quotient#1 [phi:divr16u::@2/divr16u::@5->divr16u::@3#0] -- register_copy 
    // [129] phi (word) divr16u::rem#11 = (word) divr16u::rem#6 [phi:divr16u::@2/divr16u::@5->divr16u::@3#1] -- register_copy 
    jmp __b3
    // divr16u::@3
  __b3:
    // [130] (byte) divr16u::i#1 ← ++ (byte) divr16u::i#2 -- vbuz1=_inc_vbuz1 
    inc.z i
    // [131] if((byte) divr16u::i#1!=(byte) $10) goto divr16u::@1 -- vbuz1_neq_vbuc1_then_la1 
    lda #$10
    cmp.z i
    bne __b1_from___b3
    jmp __b6
    // divr16u::@6
  __b6:
    // [132] (word) rem16u#1 ← (word) divr16u::rem#11 -- vwuz1=vwuz2 
    lda.z rem
    sta.z rem16u
    lda.z rem+1
    sta.z rem16u+1
    jmp __breturn
    // divr16u::@return
  __breturn:
    // [133] return 
    rts
}
  // test_8s
test_8s: {
    .label dividend = $57
    .label divisor = $58
    .label res = $5c
    .label i = $21
    // [135] phi from test_8s to test_8s::@1 [phi:test_8s->test_8s::@1]
  __b1_from_test_8s:
    // [135] phi (byte) test_8s::i#10 = (byte) 0 [phi:test_8s->test_8s::@1#0] -- vbuz1=vbuc1 
    lda #0
    sta.z i
    jmp __b1
    // [135] phi from test_8s::@10 to test_8s::@1 [phi:test_8s::@10->test_8s::@1]
  __b1_from___b10:
    // [135] phi (byte) test_8s::i#10 = (byte) test_8s::i#1 [phi:test_8s::@10->test_8s::@1#0] -- register_copy 
    jmp __b1
    // test_8s::@1
  __b1:
    // [136] (signed byte) test_8s::dividend#0 ← *((const signed byte*) test_8s::dividends + (byte) test_8s::i#10) -- vbsz1=pbsc1_derefidx_vbuz2 
    ldy.z i
    lda dividends,y
    sta.z dividend
    // [137] (signed byte) test_8s::divisor#0 ← *((const signed byte*) test_8s::divisors + (byte) test_8s::i#10) -- vbsz1=pbsc1_derefidx_vbuz2 
    ldy.z i
    lda divisors,y
    sta.z divisor
    // [138] (signed byte) div8s::dividend#0 ← (signed byte) test_8s::dividend#0 -- vbsz1=vbsz2 
    lda.z dividend
    sta.z div8s.dividend
    // [139] (signed byte) div8s::divisor#0 ← (signed byte) test_8s::divisor#0 -- vbsz1=vbsz2 
    lda.z divisor
    sta.z div8s.divisor
    // [140] call div8s 
    jsr div8s
    // [141] (signed byte) div8s::return#3 ← (signed byte) div8s::return#2 -- vbsz1=vbsz2 
    lda.z div8s.return
    sta.z div8s.return_1
    jmp __b2
    // test_8s::@2
  __b2:
    // [142] (signed byte) test_8s::res#0 ← (signed byte) div8s::return#3 -- vbsz1=vbsz2 
    lda.z div8s.return_1
    sta.z res
    // [143] (signed byte) print_sbyte::b#1 ← (signed byte) test_8s::dividend#0 -- vbsz1=vbsz2 
    lda.z dividend
    sta.z print_sbyte.b
    // [144] (byte*) print_char_cursor#167 ← (byte*) print_line_cursor#1 -- pbuz1=pbuz2 
    lda.z print_line_cursor
    sta.z print_char_cursor
    lda.z print_line_cursor+1
    sta.z print_char_cursor+1
    // [145] call print_sbyte 
    // [163] phi from test_8s::@2 to print_sbyte [phi:test_8s::@2->print_sbyte]
  print_sbyte_from___b2:
    // [163] phi (byte*) print_char_cursor#135 = (byte*) print_char_cursor#167 [phi:test_8s::@2->print_sbyte#0] -- register_copy 
    // [163] phi (signed byte) print_sbyte::b#10 = (signed byte) print_sbyte::b#1 [phi:test_8s::@2->print_sbyte#1] -- register_copy 
    jsr print_sbyte
    // [146] phi from test_8s::@2 to test_8s::@3 [phi:test_8s::@2->test_8s::@3]
  __b3_from___b2:
    jmp __b3
    // test_8s::@3
  __b3:
    // [147] call print_str 
    // [79] phi from test_8s::@3 to print_str [phi:test_8s::@3->print_str]
  print_str_from___b3:
    // [79] phi (byte*) print_str::str#15 = (const string) str [phi:test_8s::@3->print_str#0] -- pbuz1=pbuc1 
    lda #<str
    sta.z print_str.str
    lda #>str
    sta.z print_str.str+1
    jsr print_str
    jmp __b4
    // test_8s::@4
  __b4:
    // [148] (signed byte) print_sbyte::b#2 ← (signed byte) test_8s::divisor#0 -- vbsz1=vbsz2 
    lda.z divisor
    sta.z print_sbyte.b
    // [149] call print_sbyte 
    // [163] phi from test_8s::@4 to print_sbyte [phi:test_8s::@4->print_sbyte]
  print_sbyte_from___b4:
    // [163] phi (byte*) print_char_cursor#135 = (byte*) print_char_cursor#130 [phi:test_8s::@4->print_sbyte#0] -- register_copy 
    // [163] phi (signed byte) print_sbyte::b#10 = (signed byte) print_sbyte::b#2 [phi:test_8s::@4->print_sbyte#1] -- register_copy 
    jsr print_sbyte
    // [150] phi from test_8s::@4 to test_8s::@5 [phi:test_8s::@4->test_8s::@5]
  __b5_from___b4:
    jmp __b5
    // test_8s::@5
  __b5:
    // [151] call print_str 
    // [79] phi from test_8s::@5 to print_str [phi:test_8s::@5->print_str]
  print_str_from___b5:
    // [79] phi (byte*) print_str::str#15 = (const string) str1 [phi:test_8s::@5->print_str#0] -- pbuz1=pbuc1 
    lda #<str1
    sta.z print_str.str
    lda #>str1
    sta.z print_str.str+1
    jsr print_str
    jmp __b6
    // test_8s::@6
  __b6:
    // [152] (signed byte) print_sbyte::b#3 ← (signed byte) test_8s::res#0 -- vbsz1=vbsz2 
    lda.z res
    sta.z print_sbyte.b
    // [153] call print_sbyte 
    // [163] phi from test_8s::@6 to print_sbyte [phi:test_8s::@6->print_sbyte]
  print_sbyte_from___b6:
    // [163] phi (byte*) print_char_cursor#135 = (byte*) print_char_cursor#130 [phi:test_8s::@6->print_sbyte#0] -- register_copy 
    // [163] phi (signed byte) print_sbyte::b#10 = (signed byte) print_sbyte::b#3 [phi:test_8s::@6->print_sbyte#1] -- register_copy 
    jsr print_sbyte
    // [154] phi from test_8s::@6 to test_8s::@7 [phi:test_8s::@6->test_8s::@7]
  __b7_from___b6:
    jmp __b7
    // test_8s::@7
  __b7:
    // [155] call print_str 
    // [79] phi from test_8s::@7 to print_str [phi:test_8s::@7->print_str]
  print_str_from___b7:
    // [79] phi (byte*) print_str::str#15 = (const string) str2 [phi:test_8s::@7->print_str#0] -- pbuz1=pbuc1 
    lda #<str2
    sta.z print_str.str
    lda #>str2
    sta.z print_str.str+1
    jsr print_str
    jmp __b8
    // test_8s::@8
  __b8:
    // [156] (signed byte) print_sbyte::b#4 ← (signed byte) rem8s#3 -- vbsz1=vbsz2 
    lda.z rem8s
    sta.z print_sbyte.b
    // [157] call print_sbyte 
    // [163] phi from test_8s::@8 to print_sbyte [phi:test_8s::@8->print_sbyte]
  print_sbyte_from___b8:
    // [163] phi (byte*) print_char_cursor#135 = (byte*) print_char_cursor#130 [phi:test_8s::@8->print_sbyte#0] -- register_copy 
    // [163] phi (signed byte) print_sbyte::b#10 = (signed byte) print_sbyte::b#4 [phi:test_8s::@8->print_sbyte#1] -- register_copy 
    jsr print_sbyte
    // [158] phi from test_8s::@8 to test_8s::@9 [phi:test_8s::@8->test_8s::@9]
  __b9_from___b8:
    jmp __b9
    // test_8s::@9
  __b9:
    // [159] call print_ln 
    // [45] phi from test_8s::@9 to print_ln [phi:test_8s::@9->print_ln]
  print_ln_from___b9:
    // [45] phi (byte*) print_line_cursor#39 = (byte*) print_line_cursor#1 [phi:test_8s::@9->print_ln#0] -- register_copy 
    jsr print_ln
    jmp __b10
    // test_8s::@10
  __b10:
    // [160] (byte) test_8s::i#1 ← ++ (byte) test_8s::i#10 -- vbuz1=_inc_vbuz1 
    inc.z i
    // [161] if((byte) test_8s::i#1!=(byte) 6) goto test_8s::@1 -- vbuz1_neq_vbuc1_then_la1 
    lda #6
    cmp.z i
    bne __b1_from___b10
    jmp __breturn
    // test_8s::@return
  __breturn:
    // [162] return 
    rts
    dividends: .byte $7f, -$7f, -$7f, $7f, $7f, $7f
    divisors: .byte 5, 7, -$b, -$d, $11, $13
}
  // print_sbyte
// Print a signed byte as HEX
// print_sbyte(signed byte zp($22) b)
print_sbyte: {
    .label b = $22
    // [164] if((signed byte) print_sbyte::b#10<(signed byte) 0) goto print_sbyte::@1 -- vbsz1_lt_0_then_la1 
    lda.z b
    bmi __b1_from_print_sbyte
    // [165] phi from print_sbyte to print_sbyte::@3 [phi:print_sbyte->print_sbyte::@3]
  __b3_from_print_sbyte:
    jmp __b3
    // print_sbyte::@3
  __b3:
    // [166] call print_char 
    // [61] phi from print_sbyte::@3 to print_char [phi:print_sbyte::@3->print_char]
  print_char_from___b3:
    // [61] phi (byte*) print_char_cursor#84 = (byte*) print_char_cursor#135 [phi:print_sbyte::@3->print_char#0] -- register_copy 
    // [61] phi (byte) print_char::ch#6 = (byte) ' ' [phi:print_sbyte::@3->print_char#1] -- vbuz1=vbuc1 
    lda #' '
    sta.z print_char.ch
    jsr print_char
    // [167] phi from print_sbyte::@3 print_sbyte::@4 to print_sbyte::@2 [phi:print_sbyte::@3/print_sbyte::@4->print_sbyte::@2]
  __b2_from___b3:
  __b2_from___b4:
    // [167] phi (signed byte) print_sbyte::b#7 = (signed byte) print_sbyte::b#10 [phi:print_sbyte::@3/print_sbyte::@4->print_sbyte::@2#0] -- register_copy 
    jmp __b2
    // print_sbyte::@2
  __b2:
    // [168] (byte) print_byte::b#0 ← (byte)(signed byte) print_sbyte::b#7 -- vbuz1=vbuz2 
    lda.z b
    sta.z print_byte.b
    // [169] call print_byte 
    // [71] phi from print_sbyte::@2 to print_byte [phi:print_sbyte::@2->print_byte]
  print_byte_from___b2:
    // [71] phi (byte*) print_char_cursor#139 = (byte*) print_char_cursor#19 [phi:print_sbyte::@2->print_byte#0] -- register_copy 
    // [71] phi (byte) print_byte::b#7 = (byte) print_byte::b#0 [phi:print_sbyte::@2->print_byte#1] -- register_copy 
    jsr print_byte
    jmp __breturn
    // print_sbyte::@return
  __breturn:
    // [170] return 
    rts
    // [171] phi from print_sbyte to print_sbyte::@1 [phi:print_sbyte->print_sbyte::@1]
  __b1_from_print_sbyte:
    jmp __b1
    // print_sbyte::@1
  __b1:
    // [172] call print_char 
    // [61] phi from print_sbyte::@1 to print_char [phi:print_sbyte::@1->print_char]
  print_char_from___b1:
    // [61] phi (byte*) print_char_cursor#84 = (byte*) print_char_cursor#135 [phi:print_sbyte::@1->print_char#0] -- register_copy 
    // [61] phi (byte) print_char::ch#6 = (byte) '-' [phi:print_sbyte::@1->print_char#1] -- vbuz1=vbuc1 
    lda #'-'
    sta.z print_char.ch
    jsr print_char
    jmp __b4
    // print_sbyte::@4
  __b4:
    // [173] (signed byte) print_sbyte::b#0 ← - (signed byte) print_sbyte::b#10 -- vbsz1=_neg_vbsz1 
    lda.z b
    eor #$ff
    clc
    adc #1
    sta.z b
    jmp __b2_from___b4
}
  // div8s
// Perform division on two signed 8-bit numbers
// Returns dividend/divisor.
// The remainder will be set into the global variable rem8s.
// Implemented using simple binary division
// Follows the C99 standard by truncating toward zero on negative results.
// See http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1124.pdf section 6.5.5
// div8s(signed byte zp($59) dividend, signed byte zp($5a) divisor)
div8s: {
    .label __11 = $5f
    .label dividendu = $61
    .label divisoru = $60
    .label neg = $25
    .label resultu = $5e
    .label return = $26
    .label dividend = $59
    .label divisor = $5a
    .label return_1 = $5b
    .label dividendu_1 = $23
    .label divisoru_1 = $24
    // [174] if((signed byte) div8s::dividend#0<(signed byte) 0) goto div8s::@1 -- vbsz1_lt_0_then_la1 
    lda.z dividend
    bmi __b1
    jmp __b6
    // div8s::@6
  __b6:
    // [175] (byte) div8s::dividendu#8 ← (byte)(signed byte) div8s::dividend#0 -- vbuz1=vbuz2 
    lda.z dividend
    sta.z dividendu_1
    // [176] phi from div8s::@6 to div8s::@2 [phi:div8s::@6->div8s::@2]
  __b2_from___b6:
    // [176] phi (byte) div8s::dividendu#3 = (byte) div8s::dividendu#8 [phi:div8s::@6->div8s::@2#0] -- register_copy 
    // [176] phi (byte) div8s::neg#3 = (byte) 0 [phi:div8s::@6->div8s::@2#1] -- vbuz1=vbuc1 
    lda #0
    sta.z neg
    jmp __b2
    // div8s::@2
  __b2:
    // [177] if((signed byte) div8s::divisor#0<(signed byte) 0) goto div8s::@3 -- vbsz1_lt_0_then_la1 
    lda.z divisor
    bmi __b3
    jmp __b7
    // div8s::@7
  __b7:
    // [178] (byte) div8s::divisoru#5 ← (byte)(signed byte) div8s::divisor#0 -- vbuz1=vbuz2 
    lda.z divisor
    sta.z divisoru_1
    // [179] phi from div8s::@3 div8s::@7 to div8s::@4 [phi:div8s::@3/div8s::@7->div8s::@4]
  __b4_from___b3:
  __b4_from___b7:
    // [179] phi (byte) div8s::neg#4 = (byte) div8s::neg#2 [phi:div8s::@3/div8s::@7->div8s::@4#0] -- register_copy 
    // [179] phi (byte) div8s::divisoru#3 = (byte) div8s::divisoru#4 [phi:div8s::@3/div8s::@7->div8s::@4#1] -- register_copy 
    jmp __b4
    // div8s::@4
  __b4:
    // [180] (byte) div8u::dividend#0 ← (byte) div8s::dividendu#3 -- vbuz1=vbuz2 
    lda.z dividendu_1
    sta.z div8u.dividend
    // [181] (byte) div8u::divisor#0 ← (byte) div8s::divisoru#3 -- vbuz1=vbuz2 
    lda.z divisoru_1
    sta.z div8u.divisor
    // [182] call div8u 
    // [198] phi from div8s::@4 to div8u [phi:div8s::@4->div8u]
  div8u_from___b4:
    // [198] phi (byte) div8u::divisor#2 = (byte) div8u::divisor#0 [phi:div8s::@4->div8u#0] -- register_copy 
    // [198] phi (byte) div8u::dividend#2 = (byte) div8u::dividend#0 [phi:div8s::@4->div8u#1] -- register_copy 
    jsr div8u
    // [183] (byte) div8u::return#2 ← (byte) div8u::return#0 -- vbuz1=vbuz2 
    lda.z div8u.return
    sta.z div8u.return_1
    jmp __b9
    // div8s::@9
  __b9:
    // [184] (byte) div8s::resultu#0 ← (byte) div8u::return#2 -- vbuz1=vbuz2 
    lda.z div8u.return_1
    sta.z resultu
    // [185] if((byte) div8s::neg#4==(byte) 0) goto div8s::@5 -- vbuz1_eq_0_then_la1 
    lda.z neg
    cmp #0
    beq __b5
    jmp __b8
    // div8s::@8
  __b8:
    // [186] (signed byte~) div8s::$11 ← (signed byte)(byte) rem8u#17 -- vbsz1=vbsz2 
    lda.z rem8u
    sta.z __11
    // [187] (signed byte) rem8s#2 ← - (signed byte~) div8s::$11 -- vbsz1=_neg_vbsz2 
    lda.z __11
    eor #$ff
    clc
    adc #1
    sta.z rem8s
    // [188] (signed byte) div8s::return#1 ← - (signed byte)(byte) div8s::resultu#0 -- vbsz1=_neg_vbsz2 
    lda.z resultu
    eor #$ff
    clc
    adc #1
    sta.z return
    // [189] phi from div8s::@5 div8s::@8 to div8s::@return [phi:div8s::@5/div8s::@8->div8s::@return]
  __breturn_from___b5:
  __breturn_from___b8:
    // [189] phi (signed byte) rem8s#3 = (signed byte) rem8s#33 [phi:div8s::@5/div8s::@8->div8s::@return#0] -- register_copy 
    // [189] phi (signed byte) div8s::return#2 = (signed byte) div8s::return#7 [phi:div8s::@5/div8s::@8->div8s::@return#1] -- register_copy 
    jmp __breturn
    // div8s::@return
  __breturn:
    // [190] return 
    rts
    // div8s::@5
  __b5:
    // [191] (signed byte) div8s::return#7 ← (signed byte)(byte) div8s::resultu#0 -- vbsz1=vbsz2 
    lda.z resultu
    sta.z return
    // [192] (signed byte) rem8s#33 ← (signed byte)(byte) rem8u#17 -- vbsz1=vbsz2 
    lda.z rem8u
    sta.z rem8s
    jmp __breturn_from___b5
    // div8s::@3
  __b3:
    // [193] (signed byte) div8s::divisoru#1 ← - (signed byte) div8s::divisor#0 -- vbsz1=_neg_vbsz2 
    lda.z divisor
    eor #$ff
    clc
    adc #1
    sta.z divisoru
    // [194] (byte) div8s::neg#2 ← (byte) div8s::neg#3 ^ (byte) 1 -- vbuz1=vbuz1_bxor_vbuc1 
    lda #1
    eor.z neg
    sta.z neg
    // [195] (byte) div8s::divisoru#4 ← (byte)(signed byte) div8s::divisoru#1 -- vbuz1=vbuz2 
    lda.z divisoru
    sta.z divisoru_1
    jmp __b4_from___b3
    // div8s::@1
  __b1:
    // [196] (signed byte) div8s::dividendu#1 ← - (signed byte) div8s::dividend#0 -- vbsz1=_neg_vbsz2 
    lda.z dividend
    eor #$ff
    clc
    adc #1
    sta.z dividendu
    // [197] (byte) div8s::dividendu#7 ← (byte)(signed byte) div8s::dividendu#1 -- vbuz1=vbuz2 
    lda.z dividendu
    sta.z dividendu_1
    // [176] phi from div8s::@1 to div8s::@2 [phi:div8s::@1->div8s::@2]
  __b2_from___b1:
    // [176] phi (byte) div8s::dividendu#3 = (byte) div8s::dividendu#7 [phi:div8s::@1->div8s::@2#0] -- register_copy 
    // [176] phi (byte) div8s::neg#3 = (byte) 1 [phi:div8s::@1->div8s::@2#1] -- vbuz1=vbuc1 
    lda #1
    sta.z neg
    jmp __b2
}
  // div8u
// Performs division on two 8 bit unsigned bytes
// Returns dividend/divisor.
// The remainder will be set into the global variable rem8u
// Implemented using simple binary division
// div8u(byte zp($28) dividend, byte zp($29) divisor)
div8u: {
    .label return = $64
    .label dividend = $28
    .label divisor = $29
    .label return_1 = $5d
    .label return_2 = $7a
    // [199] (byte) divr8u::dividend#0 ← (byte) div8u::dividend#2 -- vbuz1=vbuz2 
    lda.z dividend
    sta.z divr8u.dividend
    // [200] (byte) divr8u::divisor#0 ← (byte) div8u::divisor#2 -- vbuz1=vbuz2 
    lda.z divisor
    sta.z divr8u.divisor
    // [201] call divr8u 
    // [205] phi from div8u to divr8u [phi:div8u->divr8u]
  divr8u_from_div8u:
    jsr divr8u
    // [202] (byte) divr8u::return#0 ← (byte) divr8u::return#1 -- vbuz1=vbuz2 
    lda.z divr8u.return_1
    sta.z divr8u.return
    jmp __b1
    // div8u::@1
  __b1:
    // [203] (byte) div8u::return#0 ← (byte) divr8u::return#0 -- vbuz1=vbuz2 
    lda.z divr8u.return
    sta.z return
    jmp __breturn
    // div8u::@return
  __breturn:
    // [204] return 
    rts
}
  // divr8u
// Performs division on two 8 bit unsigned bytes and an initial remainder
// Returns dividend/divisor.
// The final remainder will be set into the global variable rem8u
// Implemented using simple binary division
// divr8u(byte zp($2b) dividend, byte zp($62) divisor, byte zp($2a) rem)
divr8u: {
    .label __1 = $65
    .label dividend = $2b
    .label divisor = $62
    .label return = $63
    .label rem = $2a
    .label quotient = $2c
    .label i = $2d
    .label return_1 = $2c
    // [206] phi from divr8u to divr8u::@1 [phi:divr8u->divr8u::@1]
  __b1_from_divr8u:
    // [206] phi (byte) divr8u::i#2 = (byte) 0 [phi:divr8u->divr8u::@1#0] -- vbuz1=vbuc1 
    lda #0
    sta.z i
    // [206] phi (byte) divr8u::quotient#3 = (byte) 0 [phi:divr8u->divr8u::@1#1] -- vbuz1=vbuc1 
    lda #0
    sta.z quotient
    // [206] phi (byte) divr8u::dividend#2 = (byte) divr8u::dividend#0 [phi:divr8u->divr8u::@1#2] -- register_copy 
    // [206] phi (byte) divr8u::rem#4 = (byte) 0 [phi:divr8u->divr8u::@1#3] -- vbuz1=vbuc1 
    lda #0
    sta.z rem
    jmp __b1
    // [206] phi from divr8u::@3 to divr8u::@1 [phi:divr8u::@3->divr8u::@1]
  __b1_from___b3:
    // [206] phi (byte) divr8u::i#2 = (byte) divr8u::i#1 [phi:divr8u::@3->divr8u::@1#0] -- register_copy 
    // [206] phi (byte) divr8u::quotient#3 = (byte) divr8u::return#1 [phi:divr8u::@3->divr8u::@1#1] -- register_copy 
    // [206] phi (byte) divr8u::dividend#2 = (byte) divr8u::dividend#1 [phi:divr8u::@3->divr8u::@1#2] -- register_copy 
    // [206] phi (byte) divr8u::rem#4 = (byte) divr8u::rem#10 [phi:divr8u::@3->divr8u::@1#3] -- register_copy 
    jmp __b1
    // divr8u::@1
  __b1:
    // [207] (byte) divr8u::rem#1 ← (byte) divr8u::rem#4 << (byte) 1 -- vbuz1=vbuz1_rol_1 
    asl.z rem
    // [208] (byte~) divr8u::$1 ← (byte) divr8u::dividend#2 & (byte) $80 -- vbuz1=vbuz2_band_vbuc1 
    lda #$80
    and.z dividend
    sta.z __1
    // [209] if((byte~) divr8u::$1==(byte) 0) goto divr8u::@2 -- vbuz1_eq_0_then_la1 
    lda.z __1
    cmp #0
    beq __b2_from___b1
    jmp __b4
    // divr8u::@4
  __b4:
    // [210] (byte) divr8u::rem#2 ← (byte) divr8u::rem#1 | (byte) 1 -- vbuz1=vbuz1_bor_vbuc1 
    lda #1
    ora.z rem
    sta.z rem
    // [211] phi from divr8u::@1 divr8u::@4 to divr8u::@2 [phi:divr8u::@1/divr8u::@4->divr8u::@2]
  __b2_from___b1:
  __b2_from___b4:
    // [211] phi (byte) divr8u::rem#5 = (byte) divr8u::rem#1 [phi:divr8u::@1/divr8u::@4->divr8u::@2#0] -- register_copy 
    jmp __b2
    // divr8u::@2
  __b2:
    // [212] (byte) divr8u::dividend#1 ← (byte) divr8u::dividend#2 << (byte) 1 -- vbuz1=vbuz1_rol_1 
    asl.z dividend
    // [213] (byte) divr8u::quotient#1 ← (byte) divr8u::quotient#3 << (byte) 1 -- vbuz1=vbuz1_rol_1 
    asl.z quotient
    // [214] if((byte) divr8u::rem#5<(byte) divr8u::divisor#0) goto divr8u::@3 -- vbuz1_lt_vbuz2_then_la1 
    lda.z rem
    cmp.z divisor
    bcc __b3_from___b2
    jmp __b5
    // divr8u::@5
  __b5:
    // [215] (byte) divr8u::quotient#2 ← ++ (byte) divr8u::quotient#1 -- vbuz1=_inc_vbuz1 
    inc.z quotient
    // [216] (byte) divr8u::rem#3 ← (byte) divr8u::rem#5 - (byte) divr8u::divisor#0 -- vbuz1=vbuz1_minus_vbuz2 
    lda.z rem
    sec
    sbc.z divisor
    sta.z rem
    // [217] phi from divr8u::@2 divr8u::@5 to divr8u::@3 [phi:divr8u::@2/divr8u::@5->divr8u::@3]
  __b3_from___b2:
  __b3_from___b5:
    // [217] phi (byte) divr8u::return#1 = (byte) divr8u::quotient#1 [phi:divr8u::@2/divr8u::@5->divr8u::@3#0] -- register_copy 
    // [217] phi (byte) divr8u::rem#10 = (byte) divr8u::rem#5 [phi:divr8u::@2/divr8u::@5->divr8u::@3#1] -- register_copy 
    jmp __b3
    // divr8u::@3
  __b3:
    // [218] (byte) divr8u::i#1 ← ++ (byte) divr8u::i#2 -- vbuz1=_inc_vbuz1 
    inc.z i
    // [219] if((byte) divr8u::i#1!=(byte) 8) goto divr8u::@1 -- vbuz1_neq_vbuc1_then_la1 
    lda #8
    cmp.z i
    bne __b1_from___b3
    jmp __b6
    // divr8u::@6
  __b6:
    // [220] (byte) rem8u#17 ← (byte) divr8u::rem#10 -- vbuz1=vbuz2 
    lda.z rem
    sta.z rem8u
    jmp __breturn
    // divr8u::@return
  __breturn:
    // [221] return 
    rts
}
  // test_16u
test_16u: {
    .label __11 = $67
    .label dividend = $68
    .label divisor = $6a
    .label res = $72
    .label i = $2e
    // [223] phi from test_16u to test_16u::@1 [phi:test_16u->test_16u::@1]
  __b1_from_test_16u:
    // [223] phi (byte) test_16u::i#10 = (byte) 0 [phi:test_16u->test_16u::@1#0] -- vbuz1=vbuc1 
    lda #0
    sta.z i
    jmp __b1
    // [223] phi from test_16u::@10 to test_16u::@1 [phi:test_16u::@10->test_16u::@1]
  __b1_from___b10:
    // [223] phi (byte) test_16u::i#10 = (byte) test_16u::i#1 [phi:test_16u::@10->test_16u::@1#0] -- register_copy 
    jmp __b1
    // test_16u::@1
  __b1:
    // [224] (byte~) test_16u::$11 ← (byte) test_16u::i#10 << (byte) 1 -- vbuz1=vbuz2_rol_1 
    lda.z i
    asl
    sta.z __11
    // [225] (word) test_16u::dividend#0 ← *((const word*) test_16u::dividends + (byte~) test_16u::$11) -- vwuz1=pwuc1_derefidx_vbuz2 
    ldy.z __11
    lda dividends,y
    sta.z dividend
    lda dividends+1,y
    sta.z dividend+1
    // [226] (word) test_16u::divisor#0 ← *((const word*) test_16u::divisors + (byte~) test_16u::$11) -- vwuz1=pwuc1_derefidx_vbuz2 
    ldy.z __11
    lda divisors,y
    sta.z divisor
    lda divisors+1,y
    sta.z divisor+1
    // [227] (word) div16u::dividend#0 ← (word) test_16u::dividend#0 -- vwuz1=vwuz2 
    lda.z dividend
    sta.z div16u.dividend
    lda.z dividend+1
    sta.z div16u.dividend+1
    // [228] (word) div16u::divisor#0 ← (word) test_16u::divisor#0 -- vwuz1=vwuz2 
    lda.z divisor
    sta.z div16u.divisor
    lda.z divisor+1
    sta.z div16u.divisor+1
    // [229] call div16u 
    jsr div16u
    // [230] (word) div16u::return#2 ← (word) div16u::return#0 -- vwuz1=vwuz2 
    lda.z div16u.return
    sta.z div16u.return_1
    lda.z div16u.return+1
    sta.z div16u.return_1+1
    jmp __b2
    // test_16u::@2
  __b2:
    // [231] (word) test_16u::res#0 ← (word) div16u::return#2 -- vwuz1=vwuz2 
    lda.z div16u.return_1
    sta.z res
    lda.z div16u.return_1+1
    sta.z res+1
    // [232] (word) print_word::w#1 ← (word) test_16u::dividend#0 -- vwuz1=vwuz2 
    lda.z dividend
    sta.z print_word.w
    lda.z dividend+1
    sta.z print_word.w+1
    // [233] (byte*) print_char_cursor#172 ← (byte*) print_line_cursor#1 -- pbuz1=pbuz2 
    lda.z print_line_cursor
    sta.z print_char_cursor
    lda.z print_line_cursor+1
    sta.z print_char_cursor+1
    // [234] call print_word 
    // [65] phi from test_16u::@2 to print_word [phi:test_16u::@2->print_word]
  print_word_from___b2:
    // [65] phi (byte*) print_char_cursor#138 = (byte*) print_char_cursor#172 [phi:test_16u::@2->print_word#0] -- register_copy 
    // [65] phi (word) print_word::w#5 = (word) print_word::w#1 [phi:test_16u::@2->print_word#1] -- register_copy 
    jsr print_word
    // [235] phi from test_16u::@2 to test_16u::@3 [phi:test_16u::@2->test_16u::@3]
  __b3_from___b2:
    jmp __b3
    // test_16u::@3
  __b3:
    // [236] call print_str 
    // [79] phi from test_16u::@3 to print_str [phi:test_16u::@3->print_str]
  print_str_from___b3:
    // [79] phi (byte*) print_str::str#15 = (const string) str [phi:test_16u::@3->print_str#0] -- pbuz1=pbuc1 
    lda #<str
    sta.z print_str.str
    lda #>str
    sta.z print_str.str+1
    jsr print_str
    jmp __b4
    // test_16u::@4
  __b4:
    // [237] (word) print_word::w#2 ← (word) test_16u::divisor#0 -- vwuz1=vwuz2 
    lda.z divisor
    sta.z print_word.w
    lda.z divisor+1
    sta.z print_word.w+1
    // [238] call print_word 
    // [65] phi from test_16u::@4 to print_word [phi:test_16u::@4->print_word]
  print_word_from___b4:
    // [65] phi (byte*) print_char_cursor#138 = (byte*) print_char_cursor#130 [phi:test_16u::@4->print_word#0] -- register_copy 
    // [65] phi (word) print_word::w#5 = (word) print_word::w#2 [phi:test_16u::@4->print_word#1] -- register_copy 
    jsr print_word
    // [239] phi from test_16u::@4 to test_16u::@5 [phi:test_16u::@4->test_16u::@5]
  __b5_from___b4:
    jmp __b5
    // test_16u::@5
  __b5:
    // [240] call print_str 
    // [79] phi from test_16u::@5 to print_str [phi:test_16u::@5->print_str]
  print_str_from___b5:
    // [79] phi (byte*) print_str::str#15 = (const string) str1 [phi:test_16u::@5->print_str#0] -- pbuz1=pbuc1 
    lda #<str1
    sta.z print_str.str
    lda #>str1
    sta.z print_str.str+1
    jsr print_str
    jmp __b6
    // test_16u::@6
  __b6:
    // [241] (word) print_word::w#3 ← (word) test_16u::res#0 -- vwuz1=vwuz2 
    lda.z res
    sta.z print_word.w
    lda.z res+1
    sta.z print_word.w+1
    // [242] call print_word 
    // [65] phi from test_16u::@6 to print_word [phi:test_16u::@6->print_word]
  print_word_from___b6:
    // [65] phi (byte*) print_char_cursor#138 = (byte*) print_char_cursor#130 [phi:test_16u::@6->print_word#0] -- register_copy 
    // [65] phi (word) print_word::w#5 = (word) print_word::w#3 [phi:test_16u::@6->print_word#1] -- register_copy 
    jsr print_word
    // [243] phi from test_16u::@6 to test_16u::@7 [phi:test_16u::@6->test_16u::@7]
  __b7_from___b6:
    jmp __b7
    // test_16u::@7
  __b7:
    // [244] call print_str 
    // [79] phi from test_16u::@7 to print_str [phi:test_16u::@7->print_str]
  print_str_from___b7:
    // [79] phi (byte*) print_str::str#15 = (const string) str2 [phi:test_16u::@7->print_str#0] -- pbuz1=pbuc1 
    lda #<str2
    sta.z print_str.str
    lda #>str2
    sta.z print_str.str+1
    jsr print_str
    jmp __b8
    // test_16u::@8
  __b8:
    // [245] (word) print_word::w#4 ← (word) rem16u#1 -- vwuz1=vwuz2 
    lda.z rem16u
    sta.z print_word.w
    lda.z rem16u+1
    sta.z print_word.w+1
    // [246] call print_word 
    // [65] phi from test_16u::@8 to print_word [phi:test_16u::@8->print_word]
  print_word_from___b8:
    // [65] phi (byte*) print_char_cursor#138 = (byte*) print_char_cursor#130 [phi:test_16u::@8->print_word#0] -- register_copy 
    // [65] phi (word) print_word::w#5 = (word) print_word::w#4 [phi:test_16u::@8->print_word#1] -- register_copy 
    jsr print_word
    // [247] phi from test_16u::@8 to test_16u::@9 [phi:test_16u::@8->test_16u::@9]
  __b9_from___b8:
    jmp __b9
    // test_16u::@9
  __b9:
    // [248] call print_ln 
    // [45] phi from test_16u::@9 to print_ln [phi:test_16u::@9->print_ln]
  print_ln_from___b9:
    // [45] phi (byte*) print_line_cursor#39 = (byte*) print_line_cursor#1 [phi:test_16u::@9->print_ln#0] -- register_copy 
    jsr print_ln
    jmp __b10
    // test_16u::@10
  __b10:
    // [249] (byte) test_16u::i#1 ← ++ (byte) test_16u::i#10 -- vbuz1=_inc_vbuz1 
    inc.z i
    // [250] if((byte) test_16u::i#1!=(byte) 6) goto test_16u::@1 -- vbuz1_neq_vbuc1_then_la1 
    lda #6
    cmp.z i
    bne __b1_from___b10
    jmp __breturn
    // test_16u::@return
  __breturn:
    // [251] return 
    rts
    dividends: .word $ffff, $ffff, $ffff, $ffff, $ffff, $ffff
    divisors: .word 5, 7, $b, $d, $11, $13
}
  // div16u
// Performs division on two 16 bit unsigned words
// Returns the quotient dividend/divisor.
// The remainder will be set into the global variable rem16u
// Implemented using simple binary division
// div16u(word zp($6c) dividend, word zp($6e) divisor)
div16u: {
    .label return = $76
    .label dividend = $6c
    .label divisor = $6e
    .label return_1 = $70
    // [252] (word) divr16u::dividend#1 ← (word) div16u::dividend#0 -- vwuz1=vwuz2 
    lda.z dividend
    sta.z divr16u.dividend
    lda.z dividend+1
    sta.z divr16u.dividend+1
    // [253] (word) divr16u::divisor#0 ← (word) div16u::divisor#0 -- vwuz1=vwuz2 
    lda.z divisor
    sta.z divr16u.divisor
    lda.z divisor+1
    sta.z divr16u.divisor+1
    // [254] call divr16u 
    // [116] phi from div16u to divr16u [phi:div16u->divr16u]
  divr16u_from_div16u:
    // [116] phi (word) divr16u::divisor#6 = (word) divr16u::divisor#0 [phi:div16u->divr16u#0] -- register_copy 
    // [116] phi (word) divr16u::dividend#5 = (word) divr16u::dividend#1 [phi:div16u->divr16u#1] -- register_copy 
    jsr divr16u
    // [255] (word) divr16u::return#2 ← (word) divr16u::return#0 -- vwuz1=vwuz2 
    lda.z divr16u.return
    sta.z divr16u.return_1
    lda.z divr16u.return+1
    sta.z divr16u.return_1+1
    jmp __b1
    // div16u::@1
  __b1:
    // [256] (word) div16u::return#0 ← (word) divr16u::return#2 -- vwuz1=vwuz2 
    lda.z divr16u.return_1
    sta.z return
    lda.z divr16u.return_1+1
    sta.z return+1
    jmp __breturn
    // div16u::@return
  __breturn:
    // [257] return 
    rts
}
  // test_8u
test_8u: {
    .label dividend = $78
    .label divisor = $79
    .label res = $7b
    .label i = $2f
    // [259] phi from test_8u to test_8u::@1 [phi:test_8u->test_8u::@1]
  __b1_from_test_8u:
    // [259] phi (byte*) print_line_cursor#41 = (byte*) 1024 [phi:test_8u->test_8u::@1#0] -- pbuz1=pbuc1 
    lda #<$400
    sta.z print_line_cursor
    lda #>$400
    sta.z print_line_cursor+1
    // [259] phi (byte*) print_char_cursor#141 = (byte*) 1024 [phi:test_8u->test_8u::@1#1] -- pbuz1=pbuc1 
    lda #<$400
    sta.z print_char_cursor
    lda #>$400
    sta.z print_char_cursor+1
    // [259] phi (byte) test_8u::i#10 = (byte) 0 [phi:test_8u->test_8u::@1#2] -- vbuz1=vbuc1 
    lda #0
    sta.z i
    jmp __b1
    // test_8u::@1
  __b1:
    // [260] (byte) test_8u::dividend#0 ← *((const byte*) test_8u::dividends + (byte) test_8u::i#10) -- vbuz1=pbuc1_derefidx_vbuz2 
    ldy.z i
    lda dividends,y
    sta.z dividend
    // [261] (byte) test_8u::divisor#0 ← *((const byte*) test_8u::divisors + (byte) test_8u::i#10) -- vbuz1=pbuc1_derefidx_vbuz2 
    ldy.z i
    lda divisors,y
    sta.z divisor
    // [262] (byte) div8u::dividend#1 ← (byte) test_8u::dividend#0 -- vbuz1=vbuz2 
    lda.z dividend
    sta.z div8u.dividend
    // [263] (byte) div8u::divisor#1 ← (byte) test_8u::divisor#0 -- vbuz1=vbuz2 
    lda.z divisor
    sta.z div8u.divisor
    // [264] call div8u 
    // [198] phi from test_8u::@1 to div8u [phi:test_8u::@1->div8u]
  div8u_from___b1:
    // [198] phi (byte) div8u::divisor#2 = (byte) div8u::divisor#1 [phi:test_8u::@1->div8u#0] -- register_copy 
    // [198] phi (byte) div8u::dividend#2 = (byte) div8u::dividend#1 [phi:test_8u::@1->div8u#1] -- register_copy 
    jsr div8u
    // [265] (byte) div8u::return#3 ← (byte) div8u::return#0 -- vbuz1=vbuz2 
    lda.z div8u.return
    sta.z div8u.return_2
    jmp __b2
    // test_8u::@2
  __b2:
    // [266] (byte) test_8u::res#0 ← (byte) div8u::return#3 -- vbuz1=vbuz2 
    lda.z div8u.return_2
    sta.z res
    // [267] (byte) print_byte::b#3 ← (byte) test_8u::dividend#0 -- vbuz1=vbuz2 
    lda.z dividend
    sta.z print_byte.b
    // [268] call print_byte 
    // [71] phi from test_8u::@2 to print_byte [phi:test_8u::@2->print_byte]
  print_byte_from___b2:
    // [71] phi (byte*) print_char_cursor#139 = (byte*) print_char_cursor#141 [phi:test_8u::@2->print_byte#0] -- register_copy 
    // [71] phi (byte) print_byte::b#7 = (byte) print_byte::b#3 [phi:test_8u::@2->print_byte#1] -- register_copy 
    jsr print_byte
    // [269] phi from test_8u::@2 to test_8u::@3 [phi:test_8u::@2->test_8u::@3]
  __b3_from___b2:
    jmp __b3
    // test_8u::@3
  __b3:
    // [270] call print_str 
    // [79] phi from test_8u::@3 to print_str [phi:test_8u::@3->print_str]
  print_str_from___b3:
    // [79] phi (byte*) print_str::str#15 = (const string) str [phi:test_8u::@3->print_str#0] -- pbuz1=pbuc1 
    lda #<str
    sta.z print_str.str
    lda #>str
    sta.z print_str.str+1
    jsr print_str
    jmp __b4
    // test_8u::@4
  __b4:
    // [271] (byte) print_byte::b#4 ← (byte) test_8u::divisor#0 -- vbuz1=vbuz2 
    lda.z divisor
    sta.z print_byte.b
    // [272] call print_byte 
    // [71] phi from test_8u::@4 to print_byte [phi:test_8u::@4->print_byte]
  print_byte_from___b4:
    // [71] phi (byte*) print_char_cursor#139 = (byte*) print_char_cursor#130 [phi:test_8u::@4->print_byte#0] -- register_copy 
    // [71] phi (byte) print_byte::b#7 = (byte) print_byte::b#4 [phi:test_8u::@4->print_byte#1] -- register_copy 
    jsr print_byte
    // [273] phi from test_8u::@4 to test_8u::@5 [phi:test_8u::@4->test_8u::@5]
  __b5_from___b4:
    jmp __b5
    // test_8u::@5
  __b5:
    // [274] call print_str 
    // [79] phi from test_8u::@5 to print_str [phi:test_8u::@5->print_str]
  print_str_from___b5:
    // [79] phi (byte*) print_str::str#15 = (const string) str1 [phi:test_8u::@5->print_str#0] -- pbuz1=pbuc1 
    lda #<str1
    sta.z print_str.str
    lda #>str1
    sta.z print_str.str+1
    jsr print_str
    jmp __b6
    // test_8u::@6
  __b6:
    // [275] (byte) print_byte::b#5 ← (byte) test_8u::res#0 -- vbuz1=vbuz2 
    lda.z res
    sta.z print_byte.b
    // [276] call print_byte 
    // [71] phi from test_8u::@6 to print_byte [phi:test_8u::@6->print_byte]
  print_byte_from___b6:
    // [71] phi (byte*) print_char_cursor#139 = (byte*) print_char_cursor#130 [phi:test_8u::@6->print_byte#0] -- register_copy 
    // [71] phi (byte) print_byte::b#7 = (byte) print_byte::b#5 [phi:test_8u::@6->print_byte#1] -- register_copy 
    jsr print_byte
    // [277] phi from test_8u::@6 to test_8u::@7 [phi:test_8u::@6->test_8u::@7]
  __b7_from___b6:
    jmp __b7
    // test_8u::@7
  __b7:
    // [278] call print_str 
    // [79] phi from test_8u::@7 to print_str [phi:test_8u::@7->print_str]
  print_str_from___b7:
    // [79] phi (byte*) print_str::str#15 = (const string) str2 [phi:test_8u::@7->print_str#0] -- pbuz1=pbuc1 
    lda #<str2
    sta.z print_str.str
    lda #>str2
    sta.z print_str.str+1
    jsr print_str
    jmp __b8
    // test_8u::@8
  __b8:
    // [279] (byte) print_byte::b#6 ← (byte) rem8u#17 -- vbuz1=vbuz2 
    lda.z rem8u
    sta.z print_byte.b
    // [280] call print_byte 
    // [71] phi from test_8u::@8 to print_byte [phi:test_8u::@8->print_byte]
  print_byte_from___b8:
    // [71] phi (byte*) print_char_cursor#139 = (byte*) print_char_cursor#130 [phi:test_8u::@8->print_byte#0] -- register_copy 
    // [71] phi (byte) print_byte::b#7 = (byte) print_byte::b#6 [phi:test_8u::@8->print_byte#1] -- register_copy 
    jsr print_byte
    // [281] phi from test_8u::@8 to test_8u::@9 [phi:test_8u::@8->test_8u::@9]
  __b9_from___b8:
    jmp __b9
    // test_8u::@9
  __b9:
    // [282] call print_ln 
    // [45] phi from test_8u::@9 to print_ln [phi:test_8u::@9->print_ln]
  print_ln_from___b9:
    // [45] phi (byte*) print_line_cursor#39 = (byte*) print_line_cursor#41 [phi:test_8u::@9->print_ln#0] -- register_copy 
    jsr print_ln
    jmp __b10
    // test_8u::@10
  __b10:
    // [283] (byte) test_8u::i#1 ← ++ (byte) test_8u::i#10 -- vbuz1=_inc_vbuz1 
    inc.z i
    // [284] if((byte) test_8u::i#1!=(byte) 6) goto test_8u::@11 -- vbuz1_neq_vbuc1_then_la1 
    lda #6
    cmp.z i
    bne __b11
    jmp __breturn
    // test_8u::@return
  __breturn:
    // [285] return 
    rts
    // test_8u::@11
  __b11:
    // [286] (byte*) print_char_cursor#189 ← (byte*) print_line_cursor#1 -- pbuz1=pbuz2 
    lda.z print_line_cursor
    sta.z print_char_cursor
    lda.z print_line_cursor+1
    sta.z print_char_cursor+1
    // [259] phi from test_8u::@11 to test_8u::@1 [phi:test_8u::@11->test_8u::@1]
  __b1_from___b11:
    // [259] phi (byte*) print_line_cursor#41 = (byte*) print_line_cursor#1 [phi:test_8u::@11->test_8u::@1#0] -- register_copy 
    // [259] phi (byte*) print_char_cursor#141 = (byte*) print_char_cursor#189 [phi:test_8u::@11->test_8u::@1#1] -- register_copy 
    // [259] phi (byte) test_8u::i#10 = (byte) test_8u::i#1 [phi:test_8u::@11->test_8u::@1#2] -- register_copy 
    jmp __b1
    dividends: .byte $ff, $ff, $ff, $ff, $ff, $ff
    divisors: .byte 5, 7, $b, $d, $11, $13
}
  // print_cls
// Clear the screen. Also resets current line/char cursor.
print_cls: {
    // [288] call memset 
    // [290] phi from print_cls to memset [phi:print_cls->memset]
  memset_from_print_cls:
    jsr memset
    jmp __breturn
    // print_cls::@return
  __breturn:
    // [289] return 
    rts
}
  // memset
// Copies the character c (an unsigned char) to the first num characters of the object pointed to by the argument str.
memset: {
    .const c = ' '
    .const num = $3e8
    .label str = $400
    .label end = str+num
    .label dst = $30
    // [291] phi from memset to memset::@1 [phi:memset->memset::@1]
  __b1_from_memset:
    // [291] phi (byte*) memset::dst#2 = (byte*)(const void*) memset::str#0 [phi:memset->memset::@1#0] -- pbuz1=pbuc1 
    lda #<str
    sta.z dst
    lda #>str
    sta.z dst+1
    jmp __b1
    // memset::@1
  __b1:
    // [292] if((byte*) memset::dst#2!=(const byte*) memset::end#0) goto memset::@2 -- pbuz1_neq_pbuc1_then_la1 
    lda.z dst+1
    cmp #>end
    bne __b2
    lda.z dst
    cmp #<end
    bne __b2
    jmp __breturn
    // memset::@return
  __breturn:
    // [293] return 
    rts
    // memset::@2
  __b2:
    // [294] *((byte*) memset::dst#2) ← (const byte) memset::c#0 -- _deref_pbuz1=vbuc1 
    lda #c
    ldy #0
    sta (dst),y
    // [295] (byte*) memset::dst#1 ← ++ (byte*) memset::dst#2 -- pbuz1=_inc_pbuz1 
    inc.z dst
    bne !+
    inc.z dst+1
  !:
    // [291] phi from memset::@2 to memset::@1 [phi:memset::@2->memset::@1]
  __b1_from___b2:
    // [291] phi (byte*) memset::dst#2 = (byte*) memset::dst#1 [phi:memset::@2->memset::@1#0] -- register_copy 
    jmp __b1
}
  // File Data
  print_hextab: .text "0123456789abcdef"
  str: .text " / "
  .byte 0
  str1: .text " = "
  .byte 0
  str2: .text " "
  .byte 0

REGISTER UPLIFT POTENTIAL REGISTERS
Statement [17] (byte~) test_16s::$11 ← (byte) test_16s::i#10 << (byte) 1 [ test_16s::i#10 test_16s::$11 print_line_cursor#1 ] ( main:2::test_16s:13 [ test_16s::i#10 test_16s::$11 print_line_cursor#1 ] ) always clobbers reg byte a 
Removing always clobbered register reg byte a as potential for zp[1]:2 [ test_16s::i#10 test_16s::i#1 ]
Statement [18] (signed word) test_16s::dividend#0 ← *((const signed word*) test_16s::dividends + (byte~) test_16s::$11) [ test_16s::i#10 test_16s::$11 test_16s::dividend#0 print_line_cursor#1 ] ( main:2::test_16s:13 [ test_16s::i#10 test_16s::$11 test_16s::dividend#0 print_line_cursor#1 ] ) always clobbers reg byte a 
Removing always clobbered register reg byte a as potential for zp[1]:50 [ test_16s::$11 ]
Statement [19] (signed word) test_16s::divisor#0 ← *((const signed word*) test_16s::divisors + (byte~) test_16s::$11) [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 ] ( main:2::test_16s:13 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 ] ) always clobbers reg byte a 
Statement [20] (signed word) div16s::dividend#0 ← (signed word) test_16s::dividend#0 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 div16s::dividend#0 print_line_cursor#1 ] ( main:2::test_16s:13 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 div16s::dividend#0 print_line_cursor#1 ] ) always clobbers reg byte a 
Statement [21] (signed word) div16s::divisor#0 ← (signed word) test_16s::divisor#0 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 div16s::dividend#0 div16s::divisor#0 print_line_cursor#1 ] ( main:2::test_16s:13 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 div16s::dividend#0 div16s::divisor#0 print_line_cursor#1 ] ) always clobbers reg byte a 
Statement [23] (signed word) div16s::return#2 ← (signed word) div16s::return#0 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 div16s::return#2 print_line_cursor#1 rem16s#11 ] ( main:2::test_16s:13 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 div16s::return#2 print_line_cursor#1 rem16s#11 ] ) always clobbers reg byte a 
Statement [24] (signed word) test_16s::res#0 ← (signed word) div16s::return#2 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 test_16s::res#0 print_line_cursor#1 rem16s#11 ] ( main:2::test_16s:13 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 test_16s::res#0 print_line_cursor#1 rem16s#11 ] ) always clobbers reg byte a 
Statement [25] (signed word) print_sword::w#1 ← (signed word) test_16s::dividend#0 [ test_16s::i#10 test_16s::divisor#0 test_16s::res#0 print_sword::w#1 print_line_cursor#1 rem16s#11 ] ( main:2::test_16s:13 [ test_16s::i#10 test_16s::divisor#0 test_16s::res#0 print_sword::w#1 print_line_cursor#1 rem16s#11 ] ) always clobbers reg byte a 
Statement [26] (byte*) print_char_cursor#163 ← (byte*) print_line_cursor#1 [ test_16s::i#10 test_16s::divisor#0 test_16s::res#0 print_sword::w#1 print_char_cursor#163 print_line_cursor#1 rem16s#11 ] ( main:2::test_16s:13 [ test_16s::i#10 test_16s::divisor#0 test_16s::res#0 print_sword::w#1 print_char_cursor#163 print_line_cursor#1 rem16s#11 ] ) always clobbers reg byte a 
Statement [30] (signed word) print_sword::w#2 ← (signed word) test_16s::divisor#0 [ test_16s::i#10 test_16s::res#0 print_line_cursor#1 print_sword::w#2 rem16s#11 print_char_cursor#130 ] ( main:2::test_16s:13 [ test_16s::i#10 test_16s::res#0 print_line_cursor#1 print_sword::w#2 rem16s#11 print_char_cursor#130 ] ) always clobbers reg byte a 
Statement [34] (signed word) print_sword::w#3 ← (signed word) test_16s::res#0 [ test_16s::i#10 print_line_cursor#1 print_sword::w#3 rem16s#11 print_char_cursor#130 ] ( main:2::test_16s:13 [ test_16s::i#10 print_line_cursor#1 print_sword::w#3 rem16s#11 print_char_cursor#130 ] ) always clobbers reg byte a 
Statement [38] (signed word) print_sword::w#4 ← (signed word) rem16s#11 [ test_16s::i#10 print_line_cursor#1 print_sword::w#4 print_char_cursor#130 ] ( main:2::test_16s:13 [ test_16s::i#10 print_line_cursor#1 print_sword::w#4 print_char_cursor#130 ] ) always clobbers reg byte a 
Statement [47] (byte*) print_line_cursor#1 ← (byte*) print_line_cursor#20 + (byte) $28 [ print_line_cursor#1 print_char_cursor#19 ] ( main:2::test_16s:13::print_ln:41 [ test_16s::i#10 print_line_cursor#1 print_char_cursor#19 ] main:2::test_8s:11::print_ln:159 [ test_8s::i#10 print_line_cursor#1 print_char_cursor#19 ] main:2::test_16u:9::print_ln:248 [ test_16u::i#10 print_line_cursor#1 print_char_cursor#19 ] main:2::test_8u:7::print_ln:282 [ test_8u::i#10 print_line_cursor#1 print_char_cursor#19 ] ) always clobbers reg byte a 
Removing always clobbered register reg byte a as potential for zp[1]:33 [ test_8s::i#10 test_8s::i#1 ]
Removing always clobbered register reg byte a as potential for zp[1]:46 [ test_16u::i#10 test_16u::i#1 ]
Removing always clobbered register reg byte a as potential for zp[1]:47 [ test_8u::i#10 test_8u::i#1 ]
Statement [48] if((byte*) print_line_cursor#1<(byte*) print_char_cursor#19) goto print_ln::@1 [ print_line_cursor#1 print_char_cursor#19 ] ( main:2::test_16s:13::print_ln:41 [ test_16s::i#10 print_line_cursor#1 print_char_cursor#19 ] main:2::test_8s:11::print_ln:159 [ test_8s::i#10 print_line_cursor#1 print_char_cursor#19 ] main:2::test_16u:9::print_ln:248 [ test_16u::i#10 print_line_cursor#1 print_char_cursor#19 ] main:2::test_8u:7::print_ln:282 [ test_8u::i#10 print_line_cursor#1 print_char_cursor#19 ] ) always clobbers reg byte a 
Statement [51] if((signed word) print_sword::w#10<(signed byte) 0) goto print_sword::@1 [ print_sword::w#10 print_char_cursor#132 ] ( main:2::test_16s:13::print_sword:27 [ test_16s::i#10 test_16s::divisor#0 test_16s::res#0 print_line_cursor#1 rem16s#11 print_sword::w#10 print_char_cursor#132 ] main:2::test_16s:13::print_sword:31 [ test_16s::i#10 test_16s::res#0 print_line_cursor#1 rem16s#11 print_sword::w#10 print_char_cursor#132 ] main:2::test_16s:13::print_sword:35 [ test_16s::i#10 print_line_cursor#1 rem16s#11 print_sword::w#10 print_char_cursor#132 ] main:2::test_16s:13::print_sword:39 [ test_16s::i#10 print_line_cursor#1 print_sword::w#10 print_char_cursor#132 ] ) always clobbers reg byte a 
Statement [55] (word) print_word::w#0 ← (word)(signed word) print_sword::w#7 [ print_char_cursor#19 print_word::w#0 ] ( main:2::test_16s:13::print_sword:27 [ test_16s::i#10 test_16s::divisor#0 test_16s::res#0 print_line_cursor#1 rem16s#11 print_char_cursor#19 print_word::w#0 ] main:2::test_16s:13::print_sword:31 [ test_16s::i#10 test_16s::res#0 print_line_cursor#1 rem16s#11 print_char_cursor#19 print_word::w#0 ] main:2::test_16s:13::print_sword:35 [ test_16s::i#10 print_line_cursor#1 rem16s#11 print_char_cursor#19 print_word::w#0 ] main:2::test_16s:13::print_sword:39 [ test_16s::i#10 print_line_cursor#1 print_char_cursor#19 print_word::w#0 ] ) always clobbers reg byte a 
Statement [60] (signed word) print_sword::w#0 ← - (signed word) print_sword::w#10 [ print_char_cursor#19 print_sword::w#0 ] ( main:2::test_16s:13::print_sword:27 [ test_16s::i#10 test_16s::divisor#0 test_16s::res#0 print_line_cursor#1 rem16s#11 print_char_cursor#19 print_sword::w#0 ] main:2::test_16s:13::print_sword:31 [ test_16s::i#10 test_16s::res#0 print_line_cursor#1 rem16s#11 print_char_cursor#19 print_sword::w#0 ] main:2::test_16s:13::print_sword:35 [ test_16s::i#10 print_line_cursor#1 rem16s#11 print_char_cursor#19 print_sword::w#0 ] main:2::test_16s:13::print_sword:39 [ test_16s::i#10 print_line_cursor#1 print_char_cursor#19 print_sword::w#0 ] ) always clobbers reg byte a 
Statement [62] *((byte*) print_char_cursor#84) ← (byte) print_char::ch#6 [ print_char_cursor#84 ] ( main:2::test_16s:13::print_sword:27::print_char:53 [ test_16s::i#10 test_16s::divisor#0 test_16s::res#0 print_line_cursor#1 rem16s#11 print_sword::w#10 print_char_cursor#84 ] main:2::test_16s:13::print_sword:31::print_char:53 [ test_16s::i#10 test_16s::res#0 print_line_cursor#1 rem16s#11 print_sword::w#10 print_char_cursor#84 ] main:2::test_16s:13::print_sword:35::print_char:53 [ test_16s::i#10 print_line_cursor#1 rem16s#11 print_sword::w#10 print_char_cursor#84 ] main:2::test_16s:13::print_sword:39::print_char:53 [ test_16s::i#10 print_line_cursor#1 print_sword::w#10 print_char_cursor#84 ] main:2::test_16s:13::print_sword:27::print_char:59 [ test_16s::i#10 test_16s::divisor#0 test_16s::res#0 print_line_cursor#1 rem16s#11 print_sword::w#10 print_char_cursor#84 ] main:2::test_16s:13::print_sword:31::print_char:59 [ test_16s::i#10 test_16s::res#0 print_line_cursor#1 rem16s#11 print_sword::w#10 print_char_cursor#84 ] main:2::test_16s:13::print_sword:35::print_char:59 [ test_16s::i#10 print_line_cursor#1 rem16s#11 print_sword::w#10 print_char_cursor#84 ] main:2::test_16s:13::print_sword:39::print_char:59 [ test_16s::i#10 print_line_cursor#1 print_sword::w#10 print_char_cursor#84 ] main:2::test_16s:13::print_sword:27::print_word:56::print_byte:67::print_char:74 [ test_16s::i#10 test_16s::divisor#0 test_16s::res#0 print_line_cursor#1 rem16s#11 print_word::w#5 print_byte::b#7 print_char_cursor#84 ] main:2::test_16s:13::print_sword:31::print_word:56::print_byte:67::print_char:74 [ test_16s::i#10 test_16s::res#0 print_line_cursor#1 rem16s#11 print_word::w#5 print_byte::b#7 print_char_cursor#84 ] main:2::test_16s:13::print_sword:35::print_word:56::print_byte:67::print_char:74 [ test_16s::i#10 print_line_cursor#1 rem16s#11 print_word::w#5 print_byte::b#7 print_char_cursor#84 ] main:2::test_16s:13::print_sword:39::print_word:56::print_byte:67::print_char:74 [ test_16s::i#10 print_line_cursor#1 print_word::w#5 print_byte::b#7 print_char_cursor#84 ] main:2::test_16u:9::print_word:234::print_byte:67::print_char:74 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::divisor#0 test_16u::res#0 print_word::w#5 print_byte::b#7 print_char_cursor#84 ] main:2::test_16u:9::print_word:238::print_byte:67::print_char:74 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::res#0 print_word::w#5 print_byte::b#7 print_char_cursor#84 ] main:2::test_16u:9::print_word:242::print_byte:67::print_char:74 [ print_line_cursor#1 rem16u#1 test_16u::i#10 print_word::w#5 print_byte::b#7 print_char_cursor#84 ] main:2::test_16u:9::print_word:246::print_byte:67::print_char:74 [ print_line_cursor#1 test_16u::i#10 print_word::w#5 print_byte::b#7 print_char_cursor#84 ] main:2::test_16s:13::print_sword:27::print_word:56::print_byte:69::print_char:74 [ test_16s::i#10 test_16s::divisor#0 test_16s::res#0 print_line_cursor#1 rem16s#11 print_byte::b#7 print_char_cursor#84 ] main:2::test_16s:13::print_sword:31::print_word:56::print_byte:69::print_char:74 [ test_16s::i#10 test_16s::res#0 print_line_cursor#1 rem16s#11 print_byte::b#7 print_char_cursor#84 ] main:2::test_16s:13::print_sword:35::print_word:56::print_byte:69::print_char:74 [ test_16s::i#10 print_line_cursor#1 rem16s#11 print_byte::b#7 print_char_cursor#84 ] main:2::test_16s:13::print_sword:39::print_word:56::print_byte:69::print_char:74 [ test_16s::i#10 print_line_cursor#1 print_byte::b#7 print_char_cursor#84 ] main:2::test_16u:9::print_word:234::print_byte:69::print_char:74 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::divisor#0 test_16u::res#0 print_byte::b#7 print_char_cursor#84 ] main:2::test_16u:9::print_word:238::print_byte:69::print_char:74 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::res#0 print_byte::b#7 print_char_cursor#84 ] main:2::test_16u:9::print_word:242::print_byte:69::print_char:74 [ print_line_cursor#1 rem16u#1 test_16u::i#10 print_byte::b#7 print_char_cursor#84 ] main:2::test_16u:9::print_word:246::print_byte:69::print_char:74 [ print_line_cursor#1 test_16u::i#10 print_byte::b#7 print_char_cursor#84 ] main:2::test_8s:11::print_sbyte:145::print_byte:169::print_char:74 [ print_line_cursor#1 test_8s::i#10 test_8s::divisor#0 test_8s::res#0 rem8s#3 print_byte::b#7 print_char_cursor#84 ] main:2::test_8s:11::print_sbyte:149::print_byte:169::print_char:74 [ print_line_cursor#1 test_8s::i#10 test_8s::res#0 rem8s#3 print_byte::b#7 print_char_cursor#84 ] main:2::test_8s:11::print_sbyte:153::print_byte:169::print_char:74 [ print_line_cursor#1 test_8s::i#10 rem8s#3 print_byte::b#7 print_char_cursor#84 ] main:2::test_8s:11::print_sbyte:157::print_byte:169::print_char:74 [ print_line_cursor#1 test_8s::i#10 print_byte::b#7 print_char_cursor#84 ] main:2::test_8u:7::print_byte:268::print_char:74 [ print_line_cursor#41 rem8u#17 test_8u::i#10 test_8u::divisor#0 test_8u::res#0 print_byte::b#7 print_char_cursor#84 ] main:2::test_8u:7::print_byte:272::print_char:74 [ print_line_cursor#41 rem8u#17 test_8u::i#10 test_8u::res#0 print_byte::b#7 print_char_cursor#84 ] main:2::test_8u:7::print_byte:276::print_char:74 [ print_line_cursor#41 rem8u#17 test_8u::i#10 print_byte::b#7 print_char_cursor#84 ] main:2::test_8u:7::print_byte:280::print_char:74 [ print_line_cursor#41 test_8u::i#10 print_byte::b#7 print_char_cursor#84 ] main:2::test_16s:13::print_sword:27::print_word:56::print_byte:67::print_char:77 [ test_16s::i#10 test_16s::divisor#0 test_16s::res#0 print_line_cursor#1 rem16s#11 print_word::w#5 print_char_cursor#84 ] main:2::test_16s:13::print_sword:31::print_word:56::print_byte:67::print_char:77 [ test_16s::i#10 test_16s::res#0 print_line_cursor#1 rem16s#11 print_word::w#5 print_char_cursor#84 ] main:2::test_16s:13::print_sword:35::print_word:56::print_byte:67::print_char:77 [ test_16s::i#10 print_line_cursor#1 rem16s#11 print_word::w#5 print_char_cursor#84 ] main:2::test_16s:13::print_sword:39::print_word:56::print_byte:67::print_char:77 [ test_16s::i#10 print_line_cursor#1 print_word::w#5 print_char_cursor#84 ] main:2::test_16u:9::print_word:234::print_byte:67::print_char:77 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::divisor#0 test_16u::res#0 print_word::w#5 print_char_cursor#84 ] main:2::test_16u:9::print_word:238::print_byte:67::print_char:77 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::res#0 print_word::w#5 print_char_cursor#84 ] main:2::test_16u:9::print_word:242::print_byte:67::print_char:77 [ print_line_cursor#1 rem16u#1 test_16u::i#10 print_word::w#5 print_char_cursor#84 ] main:2::test_16u:9::print_word:246::print_byte:67::print_char:77 [ print_line_cursor#1 test_16u::i#10 print_word::w#5 print_char_cursor#84 ] main:2::test_16s:13::print_sword:27::print_word:56::print_byte:69::print_char:77 [ test_16s::i#10 test_16s::divisor#0 test_16s::res#0 print_line_cursor#1 rem16s#11 print_char_cursor#84 ] main:2::test_16s:13::print_sword:31::print_word:56::print_byte:69::print_char:77 [ test_16s::i#10 test_16s::res#0 print_line_cursor#1 rem16s#11 print_char_cursor#84 ] main:2::test_16s:13::print_sword:35::print_word:56::print_byte:69::print_char:77 [ test_16s::i#10 print_line_cursor#1 rem16s#11 print_char_cursor#84 ] main:2::test_16s:13::print_sword:39::print_word:56::print_byte:69::print_char:77 [ test_16s::i#10 print_line_cursor#1 print_char_cursor#84 ] main:2::test_16u:9::print_word:234::print_byte:69::print_char:77 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::divisor#0 test_16u::res#0 print_char_cursor#84 ] main:2::test_16u:9::print_word:238::print_byte:69::print_char:77 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::res#0 print_char_cursor#84 ] main:2::test_16u:9::print_word:242::print_byte:69::print_char:77 [ print_line_cursor#1 rem16u#1 test_16u::i#10 print_char_cursor#84 ] main:2::test_16u:9::print_word:246::print_byte:69::print_char:77 [ print_line_cursor#1 test_16u::i#10 print_char_cursor#84 ] main:2::test_8s:11::print_sbyte:145::print_byte:169::print_char:77 [ print_line_cursor#1 test_8s::i#10 test_8s::divisor#0 test_8s::res#0 rem8s#3 print_char_cursor#84 ] main:2::test_8s:11::print_sbyte:149::print_byte:169::print_char:77 [ print_line_cursor#1 test_8s::i#10 test_8s::res#0 rem8s#3 print_char_cursor#84 ] main:2::test_8s:11::print_sbyte:153::print_byte:169::print_char:77 [ print_line_cursor#1 test_8s::i#10 rem8s#3 print_char_cursor#84 ] main:2::test_8s:11::print_sbyte:157::print_byte:169::print_char:77 [ print_line_cursor#1 test_8s::i#10 print_char_cursor#84 ] main:2::test_8u:7::print_byte:268::print_char:77 [ print_line_cursor#41 rem8u#17 test_8u::i#10 test_8u::divisor#0 test_8u::res#0 print_char_cursor#84 ] main:2::test_8u:7::print_byte:272::print_char:77 [ print_line_cursor#41 rem8u#17 test_8u::i#10 test_8u::res#0 print_char_cursor#84 ] main:2::test_8u:7::print_byte:276::print_char:77 [ print_line_cursor#41 rem8u#17 test_8u::i#10 print_char_cursor#84 ] main:2::test_8u:7::print_byte:280::print_char:77 [ print_line_cursor#41 test_8u::i#10 print_char_cursor#84 ] main:2::test_8s:11::print_sbyte:145::print_char:166 [ print_line_cursor#1 test_8s::i#10 test_8s::divisor#0 test_8s::res#0 rem8s#3 print_sbyte::b#10 print_char_cursor#84 ] main:2::test_8s:11::print_sbyte:149::print_char:166 [ print_line_cursor#1 test_8s::i#10 test_8s::res#0 rem8s#3 print_sbyte::b#10 print_char_cursor#84 ] main:2::test_8s:11::print_sbyte:153::print_char:166 [ print_line_cursor#1 test_8s::i#10 rem8s#3 print_sbyte::b#10 print_char_cursor#84 ] main:2::test_8s:11::print_sbyte:157::print_char:166 [ print_line_cursor#1 test_8s::i#10 print_sbyte::b#10 print_char_cursor#84 ] main:2::test_8s:11::print_sbyte:145::print_char:172 [ print_line_cursor#1 test_8s::i#10 test_8s::divisor#0 test_8s::res#0 rem8s#3 print_sbyte::b#10 print_char_cursor#84 ] main:2::test_8s:11::print_sbyte:149::print_char:172 [ print_line_cursor#1 test_8s::i#10 test_8s::res#0 rem8s#3 print_sbyte::b#10 print_char_cursor#84 ] main:2::test_8s:11::print_sbyte:153::print_char:172 [ print_line_cursor#1 test_8s::i#10 rem8s#3 print_sbyte::b#10 print_char_cursor#84 ] main:2::test_8s:11::print_sbyte:157::print_char:172 [ print_line_cursor#1 test_8s::i#10 print_sbyte::b#10 print_char_cursor#84 ] ) always clobbers reg byte y 
Removing always clobbered register reg byte y as potential for zp[1]:2 [ test_16s::i#10 test_16s::i#1 ]
Removing always clobbered register reg byte y as potential for zp[1]:12 [ print_byte::b#7 print_byte::b#0 print_byte::b#1 print_byte::b#2 print_byte::b#3 print_byte::b#4 print_byte::b#5 print_byte::b#6 ]
Removing always clobbered register reg byte y as potential for zp[1]:46 [ test_16u::i#10 test_16u::i#1 ]
Removing always clobbered register reg byte y as potential for zp[1]:33 [ test_8s::i#10 test_8s::i#1 ]
Removing always clobbered register reg byte y as potential for zp[1]:88 [ test_8s::divisor#0 ]
Removing always clobbered register reg byte y as potential for zp[1]:92 [ test_8s::res#0 ]
Removing always clobbered register reg byte y as potential for zp[1]:39 [ rem8s#3 rem8s#2 rem8s#33 ]
Removing always clobbered register reg byte y as potential for zp[1]:102 [ rem8u#17 ]
Removing always clobbered register reg byte y as potential for zp[1]:47 [ test_8u::i#10 test_8u::i#1 ]
Removing always clobbered register reg byte y as potential for zp[1]:121 [ test_8u::divisor#0 ]
Removing always clobbered register reg byte y as potential for zp[1]:123 [ test_8u::res#0 ]
Removing always clobbered register reg byte y as potential for zp[1]:34 [ print_sbyte::b#7 print_sbyte::b#0 print_sbyte::b#10 print_sbyte::b#1 print_sbyte::b#2 print_sbyte::b#3 print_sbyte::b#4 ]
Statement [66] (byte) print_byte::b#1 ← > (word) print_word::w#5 [ print_word::w#5 print_char_cursor#138 print_byte::b#1 ] ( main:2::test_16s:13::print_sword:27::print_word:56 [ test_16s::i#10 test_16s::divisor#0 test_16s::res#0 print_line_cursor#1 rem16s#11 print_word::w#5 print_char_cursor#138 print_byte::b#1 ] main:2::test_16s:13::print_sword:31::print_word:56 [ test_16s::i#10 test_16s::res#0 print_line_cursor#1 rem16s#11 print_word::w#5 print_char_cursor#138 print_byte::b#1 ] main:2::test_16s:13::print_sword:35::print_word:56 [ test_16s::i#10 print_line_cursor#1 rem16s#11 print_word::w#5 print_char_cursor#138 print_byte::b#1 ] main:2::test_16s:13::print_sword:39::print_word:56 [ test_16s::i#10 print_line_cursor#1 print_word::w#5 print_char_cursor#138 print_byte::b#1 ] main:2::test_16u:9::print_word:234 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::divisor#0 test_16u::res#0 print_word::w#5 print_char_cursor#138 print_byte::b#1 ] main:2::test_16u:9::print_word:238 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::res#0 print_word::w#5 print_char_cursor#138 print_byte::b#1 ] main:2::test_16u:9::print_word:242 [ print_line_cursor#1 rem16u#1 test_16u::i#10 print_word::w#5 print_char_cursor#138 print_byte::b#1 ] main:2::test_16u:9::print_word:246 [ print_line_cursor#1 test_16u::i#10 print_word::w#5 print_char_cursor#138 print_byte::b#1 ] ) always clobbers reg byte a 
Statement [68] (byte) print_byte::b#2 ← < (word) print_word::w#5 [ print_char_cursor#19 print_byte::b#2 ] ( main:2::test_16s:13::print_sword:27::print_word:56 [ test_16s::i#10 test_16s::divisor#0 test_16s::res#0 print_line_cursor#1 rem16s#11 print_char_cursor#19 print_byte::b#2 ] main:2::test_16s:13::print_sword:31::print_word:56 [ test_16s::i#10 test_16s::res#0 print_line_cursor#1 rem16s#11 print_char_cursor#19 print_byte::b#2 ] main:2::test_16s:13::print_sword:35::print_word:56 [ test_16s::i#10 print_line_cursor#1 rem16s#11 print_char_cursor#19 print_byte::b#2 ] main:2::test_16s:13::print_sword:39::print_word:56 [ test_16s::i#10 print_line_cursor#1 print_char_cursor#19 print_byte::b#2 ] main:2::test_16u:9::print_word:234 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::divisor#0 test_16u::res#0 print_char_cursor#19 print_byte::b#2 ] main:2::test_16u:9::print_word:238 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::res#0 print_char_cursor#19 print_byte::b#2 ] main:2::test_16u:9::print_word:242 [ print_line_cursor#1 rem16u#1 test_16u::i#10 print_char_cursor#19 print_byte::b#2 ] main:2::test_16u:9::print_word:246 [ print_line_cursor#1 test_16u::i#10 print_char_cursor#19 print_byte::b#2 ] ) always clobbers reg byte a 
Statement [72] (byte~) print_byte::$0 ← (byte) print_byte::b#7 >> (byte) 4 [ print_char_cursor#139 print_byte::b#7 print_byte::$0 ] ( main:2::test_16s:13::print_sword:27::print_word:56::print_byte:67 [ test_16s::i#10 test_16s::divisor#0 test_16s::res#0 print_line_cursor#1 rem16s#11 print_word::w#5 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_16s:13::print_sword:31::print_word:56::print_byte:67 [ test_16s::i#10 test_16s::res#0 print_line_cursor#1 rem16s#11 print_word::w#5 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_16s:13::print_sword:35::print_word:56::print_byte:67 [ test_16s::i#10 print_line_cursor#1 rem16s#11 print_word::w#5 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_16s:13::print_sword:39::print_word:56::print_byte:67 [ test_16s::i#10 print_line_cursor#1 print_word::w#5 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_16u:9::print_word:234::print_byte:67 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::divisor#0 test_16u::res#0 print_word::w#5 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_16u:9::print_word:238::print_byte:67 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::res#0 print_word::w#5 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_16u:9::print_word:242::print_byte:67 [ print_line_cursor#1 rem16u#1 test_16u::i#10 print_word::w#5 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_16u:9::print_word:246::print_byte:67 [ print_line_cursor#1 test_16u::i#10 print_word::w#5 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_16s:13::print_sword:27::print_word:56::print_byte:69 [ test_16s::i#10 test_16s::divisor#0 test_16s::res#0 print_line_cursor#1 rem16s#11 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_16s:13::print_sword:31::print_word:56::print_byte:69 [ test_16s::i#10 test_16s::res#0 print_line_cursor#1 rem16s#11 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_16s:13::print_sword:35::print_word:56::print_byte:69 [ test_16s::i#10 print_line_cursor#1 rem16s#11 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_16s:13::print_sword:39::print_word:56::print_byte:69 [ test_16s::i#10 print_line_cursor#1 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_16u:9::print_word:234::print_byte:69 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::divisor#0 test_16u::res#0 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_16u:9::print_word:238::print_byte:69 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::res#0 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_16u:9::print_word:242::print_byte:69 [ print_line_cursor#1 rem16u#1 test_16u::i#10 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_16u:9::print_word:246::print_byte:69 [ print_line_cursor#1 test_16u::i#10 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_8s:11::print_sbyte:145::print_byte:169 [ print_line_cursor#1 test_8s::i#10 test_8s::divisor#0 test_8s::res#0 rem8s#3 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_8s:11::print_sbyte:149::print_byte:169 [ print_line_cursor#1 test_8s::i#10 test_8s::res#0 rem8s#3 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_8s:11::print_sbyte:153::print_byte:169 [ print_line_cursor#1 test_8s::i#10 rem8s#3 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_8s:11::print_sbyte:157::print_byte:169 [ print_line_cursor#1 test_8s::i#10 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_8u:7::print_byte:268 [ print_line_cursor#41 rem8u#17 test_8u::i#10 test_8u::divisor#0 test_8u::res#0 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_8u:7::print_byte:272 [ print_line_cursor#41 rem8u#17 test_8u::i#10 test_8u::res#0 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_8u:7::print_byte:276 [ print_line_cursor#41 rem8u#17 test_8u::i#10 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_8u:7::print_byte:280 [ print_line_cursor#41 test_8u::i#10 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] ) always clobbers reg byte a 
Removing always clobbered register reg byte a as potential for zp[1]:12 [ print_byte::b#7 print_byte::b#0 print_byte::b#1 print_byte::b#2 print_byte::b#3 print_byte::b#4 print_byte::b#5 print_byte::b#6 ]
Removing always clobbered register reg byte a as potential for zp[1]:88 [ test_8s::divisor#0 ]
Removing always clobbered register reg byte a as potential for zp[1]:92 [ test_8s::res#0 ]
Removing always clobbered register reg byte a as potential for zp[1]:39 [ rem8s#3 rem8s#2 rem8s#33 ]
Removing always clobbered register reg byte a as potential for zp[1]:102 [ rem8u#17 ]
Removing always clobbered register reg byte a as potential for zp[1]:121 [ test_8u::divisor#0 ]
Removing always clobbered register reg byte a as potential for zp[1]:123 [ test_8u::res#0 ]
Statement [75] (byte~) print_byte::$2 ← (byte) print_byte::b#7 & (byte) $f [ print_char_cursor#19 print_byte::$2 ] ( main:2::test_16s:13::print_sword:27::print_word:56::print_byte:67 [ test_16s::i#10 test_16s::divisor#0 test_16s::res#0 print_line_cursor#1 rem16s#11 print_word::w#5 print_char_cursor#19 print_byte::$2 ] main:2::test_16s:13::print_sword:31::print_word:56::print_byte:67 [ test_16s::i#10 test_16s::res#0 print_line_cursor#1 rem16s#11 print_word::w#5 print_char_cursor#19 print_byte::$2 ] main:2::test_16s:13::print_sword:35::print_word:56::print_byte:67 [ test_16s::i#10 print_line_cursor#1 rem16s#11 print_word::w#5 print_char_cursor#19 print_byte::$2 ] main:2::test_16s:13::print_sword:39::print_word:56::print_byte:67 [ test_16s::i#10 print_line_cursor#1 print_word::w#5 print_char_cursor#19 print_byte::$2 ] main:2::test_16u:9::print_word:234::print_byte:67 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::divisor#0 test_16u::res#0 print_word::w#5 print_char_cursor#19 print_byte::$2 ] main:2::test_16u:9::print_word:238::print_byte:67 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::res#0 print_word::w#5 print_char_cursor#19 print_byte::$2 ] main:2::test_16u:9::print_word:242::print_byte:67 [ print_line_cursor#1 rem16u#1 test_16u::i#10 print_word::w#5 print_char_cursor#19 print_byte::$2 ] main:2::test_16u:9::print_word:246::print_byte:67 [ print_line_cursor#1 test_16u::i#10 print_word::w#5 print_char_cursor#19 print_byte::$2 ] main:2::test_16s:13::print_sword:27::print_word:56::print_byte:69 [ test_16s::i#10 test_16s::divisor#0 test_16s::res#0 print_line_cursor#1 rem16s#11 print_char_cursor#19 print_byte::$2 ] main:2::test_16s:13::print_sword:31::print_word:56::print_byte:69 [ test_16s::i#10 test_16s::res#0 print_line_cursor#1 rem16s#11 print_char_cursor#19 print_byte::$2 ] main:2::test_16s:13::print_sword:35::print_word:56::print_byte:69 [ test_16s::i#10 print_line_cursor#1 rem16s#11 print_char_cursor#19 print_byte::$2 ] main:2::test_16s:13::print_sword:39::print_word:56::print_byte:69 [ test_16s::i#10 print_line_cursor#1 print_char_cursor#19 print_byte::$2 ] main:2::test_16u:9::print_word:234::print_byte:69 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::divisor#0 test_16u::res#0 print_char_cursor#19 print_byte::$2 ] main:2::test_16u:9::print_word:238::print_byte:69 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::res#0 print_char_cursor#19 print_byte::$2 ] main:2::test_16u:9::print_word:242::print_byte:69 [ print_line_cursor#1 rem16u#1 test_16u::i#10 print_char_cursor#19 print_byte::$2 ] main:2::test_16u:9::print_word:246::print_byte:69 [ print_line_cursor#1 test_16u::i#10 print_char_cursor#19 print_byte::$2 ] main:2::test_8s:11::print_sbyte:145::print_byte:169 [ print_line_cursor#1 test_8s::i#10 test_8s::divisor#0 test_8s::res#0 rem8s#3 print_char_cursor#19 print_byte::$2 ] main:2::test_8s:11::print_sbyte:149::print_byte:169 [ print_line_cursor#1 test_8s::i#10 test_8s::res#0 rem8s#3 print_char_cursor#19 print_byte::$2 ] main:2::test_8s:11::print_sbyte:153::print_byte:169 [ print_line_cursor#1 test_8s::i#10 rem8s#3 print_char_cursor#19 print_byte::$2 ] main:2::test_8s:11::print_sbyte:157::print_byte:169 [ print_line_cursor#1 test_8s::i#10 print_char_cursor#19 print_byte::$2 ] main:2::test_8u:7::print_byte:268 [ print_line_cursor#41 rem8u#17 test_8u::i#10 test_8u::divisor#0 test_8u::res#0 print_char_cursor#19 print_byte::$2 ] main:2::test_8u:7::print_byte:272 [ print_line_cursor#41 rem8u#17 test_8u::i#10 test_8u::res#0 print_char_cursor#19 print_byte::$2 ] main:2::test_8u:7::print_byte:276 [ print_line_cursor#41 rem8u#17 test_8u::i#10 print_char_cursor#19 print_byte::$2 ] main:2::test_8u:7::print_byte:280 [ print_line_cursor#41 test_8u::i#10 print_char_cursor#19 print_byte::$2 ] ) always clobbers reg byte a 
Statement [81] if((byte) 0!=*((byte*) print_str::str#13)) goto print_str::@2 [ print_char_cursor#130 print_str::str#13 ] ( main:2::test_16s:13::print_str:29 [ test_16s::i#10 test_16s::divisor#0 test_16s::res#0 print_line_cursor#1 rem16s#11 print_char_cursor#130 print_str::str#13 ] main:2::test_16s:13::print_str:33 [ test_16s::i#10 test_16s::res#0 print_line_cursor#1 rem16s#11 print_char_cursor#130 print_str::str#13 ] main:2::test_16s:13::print_str:37 [ test_16s::i#10 print_line_cursor#1 rem16s#11 print_char_cursor#130 print_str::str#13 ] main:2::test_8s:11::print_str:147 [ print_line_cursor#1 test_8s::i#10 test_8s::divisor#0 test_8s::res#0 rem8s#3 print_char_cursor#130 print_str::str#13 ] main:2::test_8s:11::print_str:151 [ print_line_cursor#1 test_8s::i#10 test_8s::res#0 rem8s#3 print_char_cursor#130 print_str::str#13 ] main:2::test_8s:11::print_str:155 [ print_line_cursor#1 test_8s::i#10 rem8s#3 print_char_cursor#130 print_str::str#13 ] main:2::test_16u:9::print_str:236 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::divisor#0 test_16u::res#0 print_char_cursor#130 print_str::str#13 ] main:2::test_16u:9::print_str:240 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::res#0 print_char_cursor#130 print_str::str#13 ] main:2::test_16u:9::print_str:244 [ print_line_cursor#1 rem16u#1 test_16u::i#10 print_char_cursor#130 print_str::str#13 ] main:2::test_8u:7::print_str:270 [ print_line_cursor#41 rem8u#17 test_8u::i#10 test_8u::divisor#0 test_8u::res#0 print_char_cursor#130 print_str::str#13 ] main:2::test_8u:7::print_str:274 [ print_line_cursor#41 rem8u#17 test_8u::i#10 test_8u::res#0 print_char_cursor#130 print_str::str#13 ] main:2::test_8u:7::print_str:278 [ print_line_cursor#41 rem8u#17 test_8u::i#10 print_char_cursor#130 print_str::str#13 ] ) always clobbers reg byte a reg byte y 
Statement [83] *((byte*) print_char_cursor#130) ← *((byte*) print_str::str#13) [ print_char_cursor#130 print_str::str#13 ] ( main:2::test_16s:13::print_str:29 [ test_16s::i#10 test_16s::divisor#0 test_16s::res#0 print_line_cursor#1 rem16s#11 print_char_cursor#130 print_str::str#13 ] main:2::test_16s:13::print_str:33 [ test_16s::i#10 test_16s::res#0 print_line_cursor#1 rem16s#11 print_char_cursor#130 print_str::str#13 ] main:2::test_16s:13::print_str:37 [ test_16s::i#10 print_line_cursor#1 rem16s#11 print_char_cursor#130 print_str::str#13 ] main:2::test_8s:11::print_str:147 [ print_line_cursor#1 test_8s::i#10 test_8s::divisor#0 test_8s::res#0 rem8s#3 print_char_cursor#130 print_str::str#13 ] main:2::test_8s:11::print_str:151 [ print_line_cursor#1 test_8s::i#10 test_8s::res#0 rem8s#3 print_char_cursor#130 print_str::str#13 ] main:2::test_8s:11::print_str:155 [ print_line_cursor#1 test_8s::i#10 rem8s#3 print_char_cursor#130 print_str::str#13 ] main:2::test_16u:9::print_str:236 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::divisor#0 test_16u::res#0 print_char_cursor#130 print_str::str#13 ] main:2::test_16u:9::print_str:240 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::res#0 print_char_cursor#130 print_str::str#13 ] main:2::test_16u:9::print_str:244 [ print_line_cursor#1 rem16u#1 test_16u::i#10 print_char_cursor#130 print_str::str#13 ] main:2::test_8u:7::print_str:270 [ print_line_cursor#41 rem8u#17 test_8u::i#10 test_8u::divisor#0 test_8u::res#0 print_char_cursor#130 print_str::str#13 ] main:2::test_8u:7::print_str:274 [ print_line_cursor#41 rem8u#17 test_8u::i#10 test_8u::res#0 print_char_cursor#130 print_str::str#13 ] main:2::test_8u:7::print_str:278 [ print_line_cursor#41 rem8u#17 test_8u::i#10 print_char_cursor#130 print_str::str#13 ] ) always clobbers reg byte a reg byte y 
Statement [86] (signed word) divr16s::dividend#0 ← (signed word) div16s::dividend#0 [ div16s::divisor#0 divr16s::dividend#0 ] ( main:2::test_16s:13::div16s:22 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 div16s::divisor#0 divr16s::dividend#0 ] ) always clobbers reg byte a 
Statement [87] (signed word) divr16s::divisor#0 ← (signed word) div16s::divisor#0 [ divr16s::dividend#0 divr16s::divisor#0 ] ( main:2::test_16s:13::div16s:22 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 divr16s::dividend#0 divr16s::divisor#0 ] ) always clobbers reg byte a 
Statement [89] (signed word) divr16s::return#3 ← (signed word) divr16s::return#2 [ rem16s#11 divr16s::return#3 ] ( main:2::test_16s:13::div16s:22 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 rem16s#11 divr16s::return#3 ] ) always clobbers reg byte a 
Statement [90] (signed word) div16s::return#0 ← (signed word) divr16s::return#3 [ div16s::return#0 rem16s#11 ] ( main:2::test_16s:13::div16s:22 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 div16s::return#0 rem16s#11 ] ) always clobbers reg byte a 
Statement [92] if((signed word) divr16s::dividend#0<(signed byte) 0) goto divr16s::@1 [ divr16s::dividend#0 divr16s::divisor#0 ] ( main:2::test_16s:13::div16s:22::divr16s:88 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 divr16s::dividend#0 divr16s::divisor#0 ] ) always clobbers reg byte a 
Statement [93] (word) divr16s::dividendu#8 ← (word)(signed word) divr16s::dividend#0 [ divr16s::divisor#0 divr16s::dividendu#8 ] ( main:2::test_16s:13::div16s:22::divr16s:88 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 divr16s::divisor#0 divr16s::dividendu#8 ] ) always clobbers reg byte a 
Statement [95] if((signed word) divr16s::divisor#0<(signed byte) 0) goto divr16s::@3 [ divr16s::divisor#0 divr16s::neg#3 divr16s::dividendu#3 ] ( main:2::test_16s:13::div16s:22::divr16s:88 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 divr16s::divisor#0 divr16s::neg#3 divr16s::dividendu#3 ] ) always clobbers reg byte a 
Removing always clobbered register reg byte a as potential for zp[1]:19 [ divr16s::neg#4 divr16s::neg#2 divr16s::neg#3 ]
Statement [96] (word) divr16s::divisoru#5 ← (word)(signed word) divr16s::divisor#0 [ divr16s::neg#3 divr16s::dividendu#3 divr16s::divisoru#5 ] ( main:2::test_16s:13::div16s:22::divr16s:88 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 divr16s::neg#3 divr16s::dividendu#3 divr16s::divisoru#5 ] ) always clobbers reg byte a 
Statement [98] (word) divr16u::dividend#2 ← (word) divr16s::dividendu#3 [ divr16s::divisoru#3 divr16s::neg#4 divr16u::dividend#2 ] ( main:2::test_16s:13::div16s:22::divr16s:88 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 divr16s::divisoru#3 divr16s::neg#4 divr16u::dividend#2 ] ) always clobbers reg byte a 
Statement [99] (word) divr16u::divisor#1 ← (word) divr16s::divisoru#3 [ divr16s::neg#4 divr16u::dividend#2 divr16u::divisor#1 ] ( main:2::test_16s:13::div16s:22::divr16s:88 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 divr16s::neg#4 divr16u::dividend#2 divr16u::divisor#1 ] ) always clobbers reg byte a 
Statement [101] (word) divr16u::return#3 ← (word) divr16u::return#0 [ divr16s::neg#4 divr16u::return#3 rem16u#1 ] ( main:2::test_16s:13::div16s:22::divr16s:88 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 divr16s::neg#4 divr16u::return#3 rem16u#1 ] ) always clobbers reg byte a 
Statement [102] (word) divr16s::resultu#0 ← (word) divr16u::return#3 [ divr16s::neg#4 divr16s::resultu#0 rem16u#1 ] ( main:2::test_16s:13::div16s:22::divr16s:88 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 divr16s::neg#4 divr16s::resultu#0 rem16u#1 ] ) always clobbers reg byte a 
Statement [104] (signed word~) divr16s::$16 ← (signed word)(word) rem16u#1 [ divr16s::resultu#0 divr16s::$16 ] ( main:2::test_16s:13::div16s:22::divr16s:88 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 divr16s::resultu#0 divr16s::$16 ] ) always clobbers reg byte a 
Statement [105] (signed word) rem16s#2 ← - (signed word~) divr16s::$16 [ divr16s::resultu#0 rem16s#2 ] ( main:2::test_16s:13::div16s:22::divr16s:88 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 divr16s::resultu#0 rem16s#2 ] ) always clobbers reg byte a 
Statement [106] (signed word) divr16s::return#1 ← - (signed word)(word) divr16s::resultu#0 [ rem16s#2 divr16s::return#1 ] ( main:2::test_16s:13::div16s:22::divr16s:88 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 rem16s#2 divr16s::return#1 ] ) always clobbers reg byte a 
Statement [109] (signed word) divr16s::return#7 ← (signed word)(word) divr16s::resultu#0 [ rem16u#1 divr16s::return#7 ] ( main:2::test_16s:13::div16s:22::divr16s:88 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 rem16u#1 divr16s::return#7 ] ) always clobbers reg byte a 
Statement [110] (signed word) rem16s#37 ← (signed word)(word) rem16u#1 [ divr16s::return#7 rem16s#37 ] ( main:2::test_16s:13::div16s:22::divr16s:88 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 divr16s::return#7 rem16s#37 ] ) always clobbers reg byte a 
Statement [111] (signed word) divr16s::divisoru#1 ← - (signed word) divr16s::divisor#0 [ divr16s::neg#3 divr16s::dividendu#3 divr16s::divisoru#1 ] ( main:2::test_16s:13::div16s:22::divr16s:88 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 divr16s::neg#3 divr16s::dividendu#3 divr16s::divisoru#1 ] ) always clobbers reg byte a 
Statement [112] (byte) divr16s::neg#2 ← (byte) divr16s::neg#3 ^ (byte) 1 [ divr16s::dividendu#3 divr16s::neg#2 divr16s::divisoru#1 ] ( main:2::test_16s:13::div16s:22::divr16s:88 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 divr16s::dividendu#3 divr16s::neg#2 divr16s::divisoru#1 ] ) always clobbers reg byte a 
Statement [113] (word) divr16s::divisoru#4 ← (word)(signed word) divr16s::divisoru#1 [ divr16s::dividendu#3 divr16s::divisoru#4 divr16s::neg#2 ] ( main:2::test_16s:13::div16s:22::divr16s:88 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 divr16s::dividendu#3 divr16s::divisoru#4 divr16s::neg#2 ] ) always clobbers reg byte a 
Statement [114] (signed word) divr16s::dividendu#1 ← - (signed word) divr16s::dividend#0 [ divr16s::divisor#0 divr16s::dividendu#1 ] ( main:2::test_16s:13::div16s:22::divr16s:88 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 divr16s::divisor#0 divr16s::dividendu#1 ] ) always clobbers reg byte a 
Statement [115] (word) divr16s::dividendu#7 ← (word)(signed word) divr16s::dividendu#1 [ divr16s::divisor#0 divr16s::dividendu#7 ] ( main:2::test_16s:13::div16s:22::divr16s:88 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 divr16s::divisor#0 divr16s::dividendu#7 ] ) always clobbers reg byte a 
Statement [119] (byte~) divr16u::$1 ← > (word) divr16u::dividend#3 [ divr16u::divisor#6 divr16u::dividend#3 divr16u::quotient#3 divr16u::i#2 divr16u::rem#0 divr16u::$1 ] ( main:2::test_16s:13::div16s:22::divr16s:88::divr16u:100 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 divr16s::neg#4 divr16u::divisor#6 divr16u::dividend#3 divr16u::quotient#3 divr16u::i#2 divr16u::rem#0 divr16u::$1 ] main:2::test_16u:9::div16u:229::divr16u:254 [ print_line_cursor#1 test_16u::i#10 test_16u::dividend#0 test_16u::divisor#0 divr16u::divisor#6 divr16u::dividend#3 divr16u::quotient#3 divr16u::i#2 divr16u::rem#0 divr16u::$1 ] ) always clobbers reg byte a 
Removing always clobbered register reg byte a as potential for zp[1]:32 [ divr16u::i#2 divr16u::i#1 ]
Statement [122] (word) divr16u::rem#1 ← (word) divr16u::rem#0 | (byte) 1 [ divr16u::divisor#6 divr16u::dividend#3 divr16u::quotient#3 divr16u::i#2 divr16u::rem#1 ] ( main:2::test_16s:13::div16s:22::divr16s:88::divr16u:100 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 divr16s::neg#4 divr16u::divisor#6 divr16u::dividend#3 divr16u::quotient#3 divr16u::i#2 divr16u::rem#1 ] main:2::test_16u:9::div16u:229::divr16u:254 [ print_line_cursor#1 test_16u::i#10 test_16u::dividend#0 test_16u::divisor#0 divr16u::divisor#6 divr16u::dividend#3 divr16u::quotient#3 divr16u::i#2 divr16u::rem#1 ] ) always clobbers reg byte a 
Statement [126] if((word) divr16u::rem#6<(word) divr16u::divisor#6) goto divr16u::@3 [ divr16u::divisor#6 divr16u::i#2 divr16u::dividend#0 divr16u::rem#6 divr16u::quotient#1 ] ( main:2::test_16s:13::div16s:22::divr16s:88::divr16u:100 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 divr16s::neg#4 divr16u::divisor#6 divr16u::i#2 divr16u::dividend#0 divr16u::rem#6 divr16u::quotient#1 ] main:2::test_16u:9::div16u:229::divr16u:254 [ print_line_cursor#1 test_16u::i#10 test_16u::dividend#0 test_16u::divisor#0 divr16u::divisor#6 divr16u::i#2 divr16u::dividend#0 divr16u::rem#6 divr16u::quotient#1 ] ) always clobbers reg byte a 
Statement [128] (word) divr16u::rem#2 ← (word) divr16u::rem#6 - (word) divr16u::divisor#6 [ divr16u::divisor#6 divr16u::i#2 divr16u::dividend#0 divr16u::quotient#2 divr16u::rem#2 ] ( main:2::test_16s:13::div16s:22::divr16s:88::divr16u:100 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 divr16s::neg#4 divr16u::divisor#6 divr16u::i#2 divr16u::dividend#0 divr16u::quotient#2 divr16u::rem#2 ] main:2::test_16u:9::div16u:229::divr16u:254 [ print_line_cursor#1 test_16u::i#10 test_16u::dividend#0 test_16u::divisor#0 divr16u::divisor#6 divr16u::i#2 divr16u::dividend#0 divr16u::quotient#2 divr16u::rem#2 ] ) always clobbers reg byte a 
Statement [132] (word) rem16u#1 ← (word) divr16u::rem#11 [ divr16u::return#0 rem16u#1 ] ( main:2::test_16s:13::div16s:22::divr16s:88::divr16u:100 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 divr16s::neg#4 divr16u::return#0 rem16u#1 ] main:2::test_16u:9::div16u:229::divr16u:254 [ print_line_cursor#1 test_16u::i#10 test_16u::dividend#0 test_16u::divisor#0 divr16u::return#0 rem16u#1 ] ) always clobbers reg byte a 
Statement [144] (byte*) print_char_cursor#167 ← (byte*) print_line_cursor#1 [ print_line_cursor#1 test_8s::i#10 test_8s::divisor#0 test_8s::res#0 print_sbyte::b#1 print_char_cursor#167 rem8s#3 ] ( main:2::test_8s:11 [ print_line_cursor#1 test_8s::i#10 test_8s::divisor#0 test_8s::res#0 print_sbyte::b#1 print_char_cursor#167 rem8s#3 ] ) always clobbers reg byte a 
Removing always clobbered register reg byte a as potential for zp[1]:34 [ print_sbyte::b#7 print_sbyte::b#0 print_sbyte::b#10 print_sbyte::b#1 print_sbyte::b#2 print_sbyte::b#3 print_sbyte::b#4 ]
Statement [173] (signed byte) print_sbyte::b#0 ← - (signed byte) print_sbyte::b#10 [ print_char_cursor#19 print_sbyte::b#0 ] ( main:2::test_8s:11::print_sbyte:145 [ print_line_cursor#1 test_8s::i#10 test_8s::divisor#0 test_8s::res#0 rem8s#3 print_char_cursor#19 print_sbyte::b#0 ] main:2::test_8s:11::print_sbyte:149 [ print_line_cursor#1 test_8s::i#10 test_8s::res#0 rem8s#3 print_char_cursor#19 print_sbyte::b#0 ] main:2::test_8s:11::print_sbyte:153 [ print_line_cursor#1 test_8s::i#10 rem8s#3 print_char_cursor#19 print_sbyte::b#0 ] main:2::test_8s:11::print_sbyte:157 [ print_line_cursor#1 test_8s::i#10 print_char_cursor#19 print_sbyte::b#0 ] ) always clobbers reg byte a 
Statement [187] (signed byte) rem8s#2 ← - (signed byte~) div8s::$11 [ div8s::resultu#0 rem8s#2 ] ( main:2::test_8s:11::div8s:140 [ print_line_cursor#1 test_8s::i#10 test_8s::dividend#0 test_8s::divisor#0 div8s::resultu#0 rem8s#2 ] ) always clobbers reg byte a 
Removing always clobbered register reg byte a as potential for zp[1]:87 [ test_8s::dividend#0 ]
Removing always clobbered register reg byte a as potential for zp[1]:94 [ div8s::resultu#0 ]
Statement [188] (signed byte) div8s::return#1 ← - (signed byte)(byte) div8s::resultu#0 [ rem8s#2 div8s::return#1 ] ( main:2::test_8s:11::div8s:140 [ print_line_cursor#1 test_8s::i#10 test_8s::dividend#0 test_8s::divisor#0 rem8s#2 div8s::return#1 ] ) always clobbers reg byte a 
Statement [193] (signed byte) div8s::divisoru#1 ← - (signed byte) div8s::divisor#0 [ div8s::neg#3 div8s::dividendu#3 div8s::divisoru#1 ] ( main:2::test_8s:11::div8s:140 [ print_line_cursor#1 test_8s::i#10 test_8s::dividend#0 test_8s::divisor#0 div8s::neg#3 div8s::dividendu#3 div8s::divisoru#1 ] ) always clobbers reg byte a 
Removing always clobbered register reg byte a as potential for zp[1]:37 [ div8s::neg#4 div8s::neg#2 div8s::neg#3 ]
Removing always clobbered register reg byte a as potential for zp[1]:35 [ div8s::dividendu#3 div8s::dividendu#7 div8s::dividendu#8 ]
Statement [194] (byte) div8s::neg#2 ← (byte) div8s::neg#3 ^ (byte) 1 [ div8s::dividendu#3 div8s::neg#2 div8s::divisoru#1 ] ( main:2::test_8s:11::div8s:140 [ print_line_cursor#1 test_8s::i#10 test_8s::dividend#0 test_8s::divisor#0 div8s::dividendu#3 div8s::neg#2 div8s::divisoru#1 ] ) always clobbers reg byte a 
Removing always clobbered register reg byte a as potential for zp[1]:96 [ div8s::divisoru#1 ]
Statement [196] (signed byte) div8s::dividendu#1 ← - (signed byte) div8s::dividend#0 [ div8s::divisor#0 div8s::dividendu#1 ] ( main:2::test_8s:11::div8s:140 [ print_line_cursor#1 test_8s::i#10 test_8s::dividend#0 test_8s::divisor#0 div8s::divisor#0 div8s::dividendu#1 ] ) always clobbers reg byte a 
Removing always clobbered register reg byte a as potential for zp[1]:90 [ div8s::divisor#0 ]
Statement [210] (byte) divr8u::rem#2 ← (byte) divr8u::rem#1 | (byte) 1 [ divr8u::divisor#0 divr8u::dividend#2 divr8u::quotient#3 divr8u::i#2 divr8u::rem#2 ] ( main:2::test_8s:11::div8s:140::div8u:182::divr8u:201 [ print_line_cursor#1 test_8s::i#10 test_8s::dividend#0 test_8s::divisor#0 div8s::neg#4 divr8u::divisor#0 divr8u::dividend#2 divr8u::quotient#3 divr8u::i#2 divr8u::rem#2 ] main:2::test_8u:7::div8u:264::divr8u:201 [ print_line_cursor#41 print_char_cursor#141 test_8u::i#10 test_8u::dividend#0 test_8u::divisor#0 divr8u::divisor#0 divr8u::dividend#2 divr8u::quotient#3 divr8u::i#2 divr8u::rem#2 ] ) always clobbers reg byte a 
Removing always clobbered register reg byte a as potential for zp[1]:98 [ divr8u::divisor#0 ]
Removing always clobbered register reg byte a as potential for zp[1]:43 [ divr8u::dividend#2 divr8u::dividend#0 divr8u::dividend#1 ]
Removing always clobbered register reg byte a as potential for zp[1]:44 [ divr8u::quotient#3 divr8u::return#1 divr8u::quotient#1 divr8u::quotient#2 ]
Removing always clobbered register reg byte a as potential for zp[1]:45 [ divr8u::i#2 divr8u::i#1 ]
Removing always clobbered register reg byte a as potential for zp[1]:120 [ test_8u::dividend#0 ]
Statement [216] (byte) divr8u::rem#3 ← (byte) divr8u::rem#5 - (byte) divr8u::divisor#0 [ divr8u::divisor#0 divr8u::i#2 divr8u::dividend#1 divr8u::quotient#2 divr8u::rem#3 ] ( main:2::test_8s:11::div8s:140::div8u:182::divr8u:201 [ print_line_cursor#1 test_8s::i#10 test_8s::dividend#0 test_8s::divisor#0 div8s::neg#4 divr8u::divisor#0 divr8u::i#2 divr8u::dividend#1 divr8u::quotient#2 divr8u::rem#3 ] main:2::test_8u:7::div8u:264::divr8u:201 [ print_line_cursor#41 print_char_cursor#141 test_8u::i#10 test_8u::dividend#0 test_8u::divisor#0 divr8u::divisor#0 divr8u::i#2 divr8u::dividend#1 divr8u::quotient#2 divr8u::rem#3 ] ) always clobbers reg byte a 
Statement [224] (byte~) test_16u::$11 ← (byte) test_16u::i#10 << (byte) 1 [ print_line_cursor#1 test_16u::i#10 test_16u::$11 ] ( main:2::test_16u:9 [ print_line_cursor#1 test_16u::i#10 test_16u::$11 ] ) always clobbers reg byte a 
Statement [225] (word) test_16u::dividend#0 ← *((const word*) test_16u::dividends + (byte~) test_16u::$11) [ print_line_cursor#1 test_16u::i#10 test_16u::$11 test_16u::dividend#0 ] ( main:2::test_16u:9 [ print_line_cursor#1 test_16u::i#10 test_16u::$11 test_16u::dividend#0 ] ) always clobbers reg byte a 
Removing always clobbered register reg byte a as potential for zp[1]:103 [ test_16u::$11 ]
Statement [226] (word) test_16u::divisor#0 ← *((const word*) test_16u::divisors + (byte~) test_16u::$11) [ print_line_cursor#1 test_16u::i#10 test_16u::dividend#0 test_16u::divisor#0 ] ( main:2::test_16u:9 [ print_line_cursor#1 test_16u::i#10 test_16u::dividend#0 test_16u::divisor#0 ] ) always clobbers reg byte a 
Statement [227] (word) div16u::dividend#0 ← (word) test_16u::dividend#0 [ print_line_cursor#1 test_16u::i#10 test_16u::dividend#0 test_16u::divisor#0 div16u::dividend#0 ] ( main:2::test_16u:9 [ print_line_cursor#1 test_16u::i#10 test_16u::dividend#0 test_16u::divisor#0 div16u::dividend#0 ] ) always clobbers reg byte a 
Statement [228] (word) div16u::divisor#0 ← (word) test_16u::divisor#0 [ print_line_cursor#1 test_16u::i#10 test_16u::dividend#0 test_16u::divisor#0 div16u::dividend#0 div16u::divisor#0 ] ( main:2::test_16u:9 [ print_line_cursor#1 test_16u::i#10 test_16u::dividend#0 test_16u::divisor#0 div16u::dividend#0 div16u::divisor#0 ] ) always clobbers reg byte a 
Statement [230] (word) div16u::return#2 ← (word) div16u::return#0 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::dividend#0 test_16u::divisor#0 div16u::return#2 ] ( main:2::test_16u:9 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::dividend#0 test_16u::divisor#0 div16u::return#2 ] ) always clobbers reg byte a 
Statement [231] (word) test_16u::res#0 ← (word) div16u::return#2 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::dividend#0 test_16u::divisor#0 test_16u::res#0 ] ( main:2::test_16u:9 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::dividend#0 test_16u::divisor#0 test_16u::res#0 ] ) always clobbers reg byte a 
Statement [232] (word) print_word::w#1 ← (word) test_16u::dividend#0 [ print_line_cursor#1 print_word::w#1 rem16u#1 test_16u::i#10 test_16u::divisor#0 test_16u::res#0 ] ( main:2::test_16u:9 [ print_line_cursor#1 print_word::w#1 rem16u#1 test_16u::i#10 test_16u::divisor#0 test_16u::res#0 ] ) always clobbers reg byte a 
Statement [233] (byte*) print_char_cursor#172 ← (byte*) print_line_cursor#1 [ print_line_cursor#1 print_word::w#1 print_char_cursor#172 rem16u#1 test_16u::i#10 test_16u::divisor#0 test_16u::res#0 ] ( main:2::test_16u:9 [ print_line_cursor#1 print_word::w#1 print_char_cursor#172 rem16u#1 test_16u::i#10 test_16u::divisor#0 test_16u::res#0 ] ) always clobbers reg byte a 
Statement [237] (word) print_word::w#2 ← (word) test_16u::divisor#0 [ print_line_cursor#1 print_char_cursor#130 print_word::w#2 rem16u#1 test_16u::i#10 test_16u::res#0 ] ( main:2::test_16u:9 [ print_line_cursor#1 print_char_cursor#130 print_word::w#2 rem16u#1 test_16u::i#10 test_16u::res#0 ] ) always clobbers reg byte a 
Statement [241] (word) print_word::w#3 ← (word) test_16u::res#0 [ print_line_cursor#1 print_char_cursor#130 print_word::w#3 rem16u#1 test_16u::i#10 ] ( main:2::test_16u:9 [ print_line_cursor#1 print_char_cursor#130 print_word::w#3 rem16u#1 test_16u::i#10 ] ) always clobbers reg byte a 
Statement [245] (word) print_word::w#4 ← (word) rem16u#1 [ print_line_cursor#1 print_char_cursor#130 print_word::w#4 test_16u::i#10 ] ( main:2::test_16u:9 [ print_line_cursor#1 print_char_cursor#130 print_word::w#4 test_16u::i#10 ] ) always clobbers reg byte a 
Statement [252] (word) divr16u::dividend#1 ← (word) div16u::dividend#0 [ divr16u::dividend#1 div16u::divisor#0 ] ( main:2::test_16u:9::div16u:229 [ print_line_cursor#1 test_16u::i#10 test_16u::dividend#0 test_16u::divisor#0 divr16u::dividend#1 div16u::divisor#0 ] ) always clobbers reg byte a 
Statement [253] (word) divr16u::divisor#0 ← (word) div16u::divisor#0 [ divr16u::dividend#1 divr16u::divisor#0 ] ( main:2::test_16u:9::div16u:229 [ print_line_cursor#1 test_16u::i#10 test_16u::dividend#0 test_16u::divisor#0 divr16u::dividend#1 divr16u::divisor#0 ] ) always clobbers reg byte a 
Statement [255] (word) divr16u::return#2 ← (word) divr16u::return#0 [ rem16u#1 divr16u::return#2 ] ( main:2::test_16u:9::div16u:229 [ print_line_cursor#1 test_16u::i#10 test_16u::dividend#0 test_16u::divisor#0 rem16u#1 divr16u::return#2 ] ) always clobbers reg byte a 
Statement [256] (word) div16u::return#0 ← (word) divr16u::return#2 [ rem16u#1 div16u::return#0 ] ( main:2::test_16u:9::div16u:229 [ print_line_cursor#1 test_16u::i#10 test_16u::dividend#0 test_16u::divisor#0 rem16u#1 div16u::return#0 ] ) always clobbers reg byte a 
Statement [286] (byte*) print_char_cursor#189 ← (byte*) print_line_cursor#1 [ print_line_cursor#1 test_8u::i#1 print_char_cursor#189 ] ( main:2::test_8u:7 [ print_line_cursor#1 test_8u::i#1 print_char_cursor#189 ] ) always clobbers reg byte a 
Statement [292] if((byte*) memset::dst#2!=(const byte*) memset::end#0) goto memset::@2 [ memset::dst#2 ] ( main:2::print_cls:5::memset:288 [ memset::dst#2 ] ) always clobbers reg byte a 
Statement [294] *((byte*) memset::dst#2) ← (const byte) memset::c#0 [ memset::dst#2 ] ( main:2::print_cls:5::memset:288 [ memset::dst#2 ] ) always clobbers reg byte a reg byte y 
Statement [17] (byte~) test_16s::$11 ← (byte) test_16s::i#10 << (byte) 1 [ test_16s::i#10 test_16s::$11 print_line_cursor#1 ] ( main:2::test_16s:13 [ test_16s::i#10 test_16s::$11 print_line_cursor#1 ] ) always clobbers reg byte a 
Statement [18] (signed word) test_16s::dividend#0 ← *((const signed word*) test_16s::dividends + (byte~) test_16s::$11) [ test_16s::i#10 test_16s::$11 test_16s::dividend#0 print_line_cursor#1 ] ( main:2::test_16s:13 [ test_16s::i#10 test_16s::$11 test_16s::dividend#0 print_line_cursor#1 ] ) always clobbers reg byte a 
Statement [19] (signed word) test_16s::divisor#0 ← *((const signed word*) test_16s::divisors + (byte~) test_16s::$11) [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 ] ( main:2::test_16s:13 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 ] ) always clobbers reg byte a 
Statement [20] (signed word) div16s::dividend#0 ← (signed word) test_16s::dividend#0 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 div16s::dividend#0 print_line_cursor#1 ] ( main:2::test_16s:13 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 div16s::dividend#0 print_line_cursor#1 ] ) always clobbers reg byte a 
Statement [21] (signed word) div16s::divisor#0 ← (signed word) test_16s::divisor#0 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 div16s::dividend#0 div16s::divisor#0 print_line_cursor#1 ] ( main:2::test_16s:13 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 div16s::dividend#0 div16s::divisor#0 print_line_cursor#1 ] ) always clobbers reg byte a 
Statement [23] (signed word) div16s::return#2 ← (signed word) div16s::return#0 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 div16s::return#2 print_line_cursor#1 rem16s#11 ] ( main:2::test_16s:13 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 div16s::return#2 print_line_cursor#1 rem16s#11 ] ) always clobbers reg byte a 
Statement [24] (signed word) test_16s::res#0 ← (signed word) div16s::return#2 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 test_16s::res#0 print_line_cursor#1 rem16s#11 ] ( main:2::test_16s:13 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 test_16s::res#0 print_line_cursor#1 rem16s#11 ] ) always clobbers reg byte a 
Statement [25] (signed word) print_sword::w#1 ← (signed word) test_16s::dividend#0 [ test_16s::i#10 test_16s::divisor#0 test_16s::res#0 print_sword::w#1 print_line_cursor#1 rem16s#11 ] ( main:2::test_16s:13 [ test_16s::i#10 test_16s::divisor#0 test_16s::res#0 print_sword::w#1 print_line_cursor#1 rem16s#11 ] ) always clobbers reg byte a 
Statement [26] (byte*) print_char_cursor#163 ← (byte*) print_line_cursor#1 [ test_16s::i#10 test_16s::divisor#0 test_16s::res#0 print_sword::w#1 print_char_cursor#163 print_line_cursor#1 rem16s#11 ] ( main:2::test_16s:13 [ test_16s::i#10 test_16s::divisor#0 test_16s::res#0 print_sword::w#1 print_char_cursor#163 print_line_cursor#1 rem16s#11 ] ) always clobbers reg byte a 
Statement [30] (signed word) print_sword::w#2 ← (signed word) test_16s::divisor#0 [ test_16s::i#10 test_16s::res#0 print_line_cursor#1 print_sword::w#2 rem16s#11 print_char_cursor#130 ] ( main:2::test_16s:13 [ test_16s::i#10 test_16s::res#0 print_line_cursor#1 print_sword::w#2 rem16s#11 print_char_cursor#130 ] ) always clobbers reg byte a 
Statement [34] (signed word) print_sword::w#3 ← (signed word) test_16s::res#0 [ test_16s::i#10 print_line_cursor#1 print_sword::w#3 rem16s#11 print_char_cursor#130 ] ( main:2::test_16s:13 [ test_16s::i#10 print_line_cursor#1 print_sword::w#3 rem16s#11 print_char_cursor#130 ] ) always clobbers reg byte a 
Statement [38] (signed word) print_sword::w#4 ← (signed word) rem16s#11 [ test_16s::i#10 print_line_cursor#1 print_sword::w#4 print_char_cursor#130 ] ( main:2::test_16s:13 [ test_16s::i#10 print_line_cursor#1 print_sword::w#4 print_char_cursor#130 ] ) always clobbers reg byte a 
Statement [47] (byte*) print_line_cursor#1 ← (byte*) print_line_cursor#20 + (byte) $28 [ print_line_cursor#1 print_char_cursor#19 ] ( main:2::test_16s:13::print_ln:41 [ test_16s::i#10 print_line_cursor#1 print_char_cursor#19 ] main:2::test_8s:11::print_ln:159 [ test_8s::i#10 print_line_cursor#1 print_char_cursor#19 ] main:2::test_16u:9::print_ln:248 [ test_16u::i#10 print_line_cursor#1 print_char_cursor#19 ] main:2::test_8u:7::print_ln:282 [ test_8u::i#10 print_line_cursor#1 print_char_cursor#19 ] ) always clobbers reg byte a 
Statement [48] if((byte*) print_line_cursor#1<(byte*) print_char_cursor#19) goto print_ln::@1 [ print_line_cursor#1 print_char_cursor#19 ] ( main:2::test_16s:13::print_ln:41 [ test_16s::i#10 print_line_cursor#1 print_char_cursor#19 ] main:2::test_8s:11::print_ln:159 [ test_8s::i#10 print_line_cursor#1 print_char_cursor#19 ] main:2::test_16u:9::print_ln:248 [ test_16u::i#10 print_line_cursor#1 print_char_cursor#19 ] main:2::test_8u:7::print_ln:282 [ test_8u::i#10 print_line_cursor#1 print_char_cursor#19 ] ) always clobbers reg byte a 
Statement [51] if((signed word) print_sword::w#10<(signed byte) 0) goto print_sword::@1 [ print_sword::w#10 print_char_cursor#132 ] ( main:2::test_16s:13::print_sword:27 [ test_16s::i#10 test_16s::divisor#0 test_16s::res#0 print_line_cursor#1 rem16s#11 print_sword::w#10 print_char_cursor#132 ] main:2::test_16s:13::print_sword:31 [ test_16s::i#10 test_16s::res#0 print_line_cursor#1 rem16s#11 print_sword::w#10 print_char_cursor#132 ] main:2::test_16s:13::print_sword:35 [ test_16s::i#10 print_line_cursor#1 rem16s#11 print_sword::w#10 print_char_cursor#132 ] main:2::test_16s:13::print_sword:39 [ test_16s::i#10 print_line_cursor#1 print_sword::w#10 print_char_cursor#132 ] ) always clobbers reg byte a 
Statement [55] (word) print_word::w#0 ← (word)(signed word) print_sword::w#7 [ print_char_cursor#19 print_word::w#0 ] ( main:2::test_16s:13::print_sword:27 [ test_16s::i#10 test_16s::divisor#0 test_16s::res#0 print_line_cursor#1 rem16s#11 print_char_cursor#19 print_word::w#0 ] main:2::test_16s:13::print_sword:31 [ test_16s::i#10 test_16s::res#0 print_line_cursor#1 rem16s#11 print_char_cursor#19 print_word::w#0 ] main:2::test_16s:13::print_sword:35 [ test_16s::i#10 print_line_cursor#1 rem16s#11 print_char_cursor#19 print_word::w#0 ] main:2::test_16s:13::print_sword:39 [ test_16s::i#10 print_line_cursor#1 print_char_cursor#19 print_word::w#0 ] ) always clobbers reg byte a 
Statement [60] (signed word) print_sword::w#0 ← - (signed word) print_sword::w#10 [ print_char_cursor#19 print_sword::w#0 ] ( main:2::test_16s:13::print_sword:27 [ test_16s::i#10 test_16s::divisor#0 test_16s::res#0 print_line_cursor#1 rem16s#11 print_char_cursor#19 print_sword::w#0 ] main:2::test_16s:13::print_sword:31 [ test_16s::i#10 test_16s::res#0 print_line_cursor#1 rem16s#11 print_char_cursor#19 print_sword::w#0 ] main:2::test_16s:13::print_sword:35 [ test_16s::i#10 print_line_cursor#1 rem16s#11 print_char_cursor#19 print_sword::w#0 ] main:2::test_16s:13::print_sword:39 [ test_16s::i#10 print_line_cursor#1 print_char_cursor#19 print_sword::w#0 ] ) always clobbers reg byte a 
Statement [62] *((byte*) print_char_cursor#84) ← (byte) print_char::ch#6 [ print_char_cursor#84 ] ( main:2::test_16s:13::print_sword:27::print_char:53 [ test_16s::i#10 test_16s::divisor#0 test_16s::res#0 print_line_cursor#1 rem16s#11 print_sword::w#10 print_char_cursor#84 ] main:2::test_16s:13::print_sword:31::print_char:53 [ test_16s::i#10 test_16s::res#0 print_line_cursor#1 rem16s#11 print_sword::w#10 print_char_cursor#84 ] main:2::test_16s:13::print_sword:35::print_char:53 [ test_16s::i#10 print_line_cursor#1 rem16s#11 print_sword::w#10 print_char_cursor#84 ] main:2::test_16s:13::print_sword:39::print_char:53 [ test_16s::i#10 print_line_cursor#1 print_sword::w#10 print_char_cursor#84 ] main:2::test_16s:13::print_sword:27::print_char:59 [ test_16s::i#10 test_16s::divisor#0 test_16s::res#0 print_line_cursor#1 rem16s#11 print_sword::w#10 print_char_cursor#84 ] main:2::test_16s:13::print_sword:31::print_char:59 [ test_16s::i#10 test_16s::res#0 print_line_cursor#1 rem16s#11 print_sword::w#10 print_char_cursor#84 ] main:2::test_16s:13::print_sword:35::print_char:59 [ test_16s::i#10 print_line_cursor#1 rem16s#11 print_sword::w#10 print_char_cursor#84 ] main:2::test_16s:13::print_sword:39::print_char:59 [ test_16s::i#10 print_line_cursor#1 print_sword::w#10 print_char_cursor#84 ] main:2::test_16s:13::print_sword:27::print_word:56::print_byte:67::print_char:74 [ test_16s::i#10 test_16s::divisor#0 test_16s::res#0 print_line_cursor#1 rem16s#11 print_word::w#5 print_byte::b#7 print_char_cursor#84 ] main:2::test_16s:13::print_sword:31::print_word:56::print_byte:67::print_char:74 [ test_16s::i#10 test_16s::res#0 print_line_cursor#1 rem16s#11 print_word::w#5 print_byte::b#7 print_char_cursor#84 ] main:2::test_16s:13::print_sword:35::print_word:56::print_byte:67::print_char:74 [ test_16s::i#10 print_line_cursor#1 rem16s#11 print_word::w#5 print_byte::b#7 print_char_cursor#84 ] main:2::test_16s:13::print_sword:39::print_word:56::print_byte:67::print_char:74 [ test_16s::i#10 print_line_cursor#1 print_word::w#5 print_byte::b#7 print_char_cursor#84 ] main:2::test_16u:9::print_word:234::print_byte:67::print_char:74 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::divisor#0 test_16u::res#0 print_word::w#5 print_byte::b#7 print_char_cursor#84 ] main:2::test_16u:9::print_word:238::print_byte:67::print_char:74 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::res#0 print_word::w#5 print_byte::b#7 print_char_cursor#84 ] main:2::test_16u:9::print_word:242::print_byte:67::print_char:74 [ print_line_cursor#1 rem16u#1 test_16u::i#10 print_word::w#5 print_byte::b#7 print_char_cursor#84 ] main:2::test_16u:9::print_word:246::print_byte:67::print_char:74 [ print_line_cursor#1 test_16u::i#10 print_word::w#5 print_byte::b#7 print_char_cursor#84 ] main:2::test_16s:13::print_sword:27::print_word:56::print_byte:69::print_char:74 [ test_16s::i#10 test_16s::divisor#0 test_16s::res#0 print_line_cursor#1 rem16s#11 print_byte::b#7 print_char_cursor#84 ] main:2::test_16s:13::print_sword:31::print_word:56::print_byte:69::print_char:74 [ test_16s::i#10 test_16s::res#0 print_line_cursor#1 rem16s#11 print_byte::b#7 print_char_cursor#84 ] main:2::test_16s:13::print_sword:35::print_word:56::print_byte:69::print_char:74 [ test_16s::i#10 print_line_cursor#1 rem16s#11 print_byte::b#7 print_char_cursor#84 ] main:2::test_16s:13::print_sword:39::print_word:56::print_byte:69::print_char:74 [ test_16s::i#10 print_line_cursor#1 print_byte::b#7 print_char_cursor#84 ] main:2::test_16u:9::print_word:234::print_byte:69::print_char:74 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::divisor#0 test_16u::res#0 print_byte::b#7 print_char_cursor#84 ] main:2::test_16u:9::print_word:238::print_byte:69::print_char:74 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::res#0 print_byte::b#7 print_char_cursor#84 ] main:2::test_16u:9::print_word:242::print_byte:69::print_char:74 [ print_line_cursor#1 rem16u#1 test_16u::i#10 print_byte::b#7 print_char_cursor#84 ] main:2::test_16u:9::print_word:246::print_byte:69::print_char:74 [ print_line_cursor#1 test_16u::i#10 print_byte::b#7 print_char_cursor#84 ] main:2::test_8s:11::print_sbyte:145::print_byte:169::print_char:74 [ print_line_cursor#1 test_8s::i#10 test_8s::divisor#0 test_8s::res#0 rem8s#3 print_byte::b#7 print_char_cursor#84 ] main:2::test_8s:11::print_sbyte:149::print_byte:169::print_char:74 [ print_line_cursor#1 test_8s::i#10 test_8s::res#0 rem8s#3 print_byte::b#7 print_char_cursor#84 ] main:2::test_8s:11::print_sbyte:153::print_byte:169::print_char:74 [ print_line_cursor#1 test_8s::i#10 rem8s#3 print_byte::b#7 print_char_cursor#84 ] main:2::test_8s:11::print_sbyte:157::print_byte:169::print_char:74 [ print_line_cursor#1 test_8s::i#10 print_byte::b#7 print_char_cursor#84 ] main:2::test_8u:7::print_byte:268::print_char:74 [ print_line_cursor#41 rem8u#17 test_8u::i#10 test_8u::divisor#0 test_8u::res#0 print_byte::b#7 print_char_cursor#84 ] main:2::test_8u:7::print_byte:272::print_char:74 [ print_line_cursor#41 rem8u#17 test_8u::i#10 test_8u::res#0 print_byte::b#7 print_char_cursor#84 ] main:2::test_8u:7::print_byte:276::print_char:74 [ print_line_cursor#41 rem8u#17 test_8u::i#10 print_byte::b#7 print_char_cursor#84 ] main:2::test_8u:7::print_byte:280::print_char:74 [ print_line_cursor#41 test_8u::i#10 print_byte::b#7 print_char_cursor#84 ] main:2::test_16s:13::print_sword:27::print_word:56::print_byte:67::print_char:77 [ test_16s::i#10 test_16s::divisor#0 test_16s::res#0 print_line_cursor#1 rem16s#11 print_word::w#5 print_char_cursor#84 ] main:2::test_16s:13::print_sword:31::print_word:56::print_byte:67::print_char:77 [ test_16s::i#10 test_16s::res#0 print_line_cursor#1 rem16s#11 print_word::w#5 print_char_cursor#84 ] main:2::test_16s:13::print_sword:35::print_word:56::print_byte:67::print_char:77 [ test_16s::i#10 print_line_cursor#1 rem16s#11 print_word::w#5 print_char_cursor#84 ] main:2::test_16s:13::print_sword:39::print_word:56::print_byte:67::print_char:77 [ test_16s::i#10 print_line_cursor#1 print_word::w#5 print_char_cursor#84 ] main:2::test_16u:9::print_word:234::print_byte:67::print_char:77 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::divisor#0 test_16u::res#0 print_word::w#5 print_char_cursor#84 ] main:2::test_16u:9::print_word:238::print_byte:67::print_char:77 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::res#0 print_word::w#5 print_char_cursor#84 ] main:2::test_16u:9::print_word:242::print_byte:67::print_char:77 [ print_line_cursor#1 rem16u#1 test_16u::i#10 print_word::w#5 print_char_cursor#84 ] main:2::test_16u:9::print_word:246::print_byte:67::print_char:77 [ print_line_cursor#1 test_16u::i#10 print_word::w#5 print_char_cursor#84 ] main:2::test_16s:13::print_sword:27::print_word:56::print_byte:69::print_char:77 [ test_16s::i#10 test_16s::divisor#0 test_16s::res#0 print_line_cursor#1 rem16s#11 print_char_cursor#84 ] main:2::test_16s:13::print_sword:31::print_word:56::print_byte:69::print_char:77 [ test_16s::i#10 test_16s::res#0 print_line_cursor#1 rem16s#11 print_char_cursor#84 ] main:2::test_16s:13::print_sword:35::print_word:56::print_byte:69::print_char:77 [ test_16s::i#10 print_line_cursor#1 rem16s#11 print_char_cursor#84 ] main:2::test_16s:13::print_sword:39::print_word:56::print_byte:69::print_char:77 [ test_16s::i#10 print_line_cursor#1 print_char_cursor#84 ] main:2::test_16u:9::print_word:234::print_byte:69::print_char:77 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::divisor#0 test_16u::res#0 print_char_cursor#84 ] main:2::test_16u:9::print_word:238::print_byte:69::print_char:77 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::res#0 print_char_cursor#84 ] main:2::test_16u:9::print_word:242::print_byte:69::print_char:77 [ print_line_cursor#1 rem16u#1 test_16u::i#10 print_char_cursor#84 ] main:2::test_16u:9::print_word:246::print_byte:69::print_char:77 [ print_line_cursor#1 test_16u::i#10 print_char_cursor#84 ] main:2::test_8s:11::print_sbyte:145::print_byte:169::print_char:77 [ print_line_cursor#1 test_8s::i#10 test_8s::divisor#0 test_8s::res#0 rem8s#3 print_char_cursor#84 ] main:2::test_8s:11::print_sbyte:149::print_byte:169::print_char:77 [ print_line_cursor#1 test_8s::i#10 test_8s::res#0 rem8s#3 print_char_cursor#84 ] main:2::test_8s:11::print_sbyte:153::print_byte:169::print_char:77 [ print_line_cursor#1 test_8s::i#10 rem8s#3 print_char_cursor#84 ] main:2::test_8s:11::print_sbyte:157::print_byte:169::print_char:77 [ print_line_cursor#1 test_8s::i#10 print_char_cursor#84 ] main:2::test_8u:7::print_byte:268::print_char:77 [ print_line_cursor#41 rem8u#17 test_8u::i#10 test_8u::divisor#0 test_8u::res#0 print_char_cursor#84 ] main:2::test_8u:7::print_byte:272::print_char:77 [ print_line_cursor#41 rem8u#17 test_8u::i#10 test_8u::res#0 print_char_cursor#84 ] main:2::test_8u:7::print_byte:276::print_char:77 [ print_line_cursor#41 rem8u#17 test_8u::i#10 print_char_cursor#84 ] main:2::test_8u:7::print_byte:280::print_char:77 [ print_line_cursor#41 test_8u::i#10 print_char_cursor#84 ] main:2::test_8s:11::print_sbyte:145::print_char:166 [ print_line_cursor#1 test_8s::i#10 test_8s::divisor#0 test_8s::res#0 rem8s#3 print_sbyte::b#10 print_char_cursor#84 ] main:2::test_8s:11::print_sbyte:149::print_char:166 [ print_line_cursor#1 test_8s::i#10 test_8s::res#0 rem8s#3 print_sbyte::b#10 print_char_cursor#84 ] main:2::test_8s:11::print_sbyte:153::print_char:166 [ print_line_cursor#1 test_8s::i#10 rem8s#3 print_sbyte::b#10 print_char_cursor#84 ] main:2::test_8s:11::print_sbyte:157::print_char:166 [ print_line_cursor#1 test_8s::i#10 print_sbyte::b#10 print_char_cursor#84 ] main:2::test_8s:11::print_sbyte:145::print_char:172 [ print_line_cursor#1 test_8s::i#10 test_8s::divisor#0 test_8s::res#0 rem8s#3 print_sbyte::b#10 print_char_cursor#84 ] main:2::test_8s:11::print_sbyte:149::print_char:172 [ print_line_cursor#1 test_8s::i#10 test_8s::res#0 rem8s#3 print_sbyte::b#10 print_char_cursor#84 ] main:2::test_8s:11::print_sbyte:153::print_char:172 [ print_line_cursor#1 test_8s::i#10 rem8s#3 print_sbyte::b#10 print_char_cursor#84 ] main:2::test_8s:11::print_sbyte:157::print_char:172 [ print_line_cursor#1 test_8s::i#10 print_sbyte::b#10 print_char_cursor#84 ] ) always clobbers reg byte y 
Statement [66] (byte) print_byte::b#1 ← > (word) print_word::w#5 [ print_word::w#5 print_char_cursor#138 print_byte::b#1 ] ( main:2::test_16s:13::print_sword:27::print_word:56 [ test_16s::i#10 test_16s::divisor#0 test_16s::res#0 print_line_cursor#1 rem16s#11 print_word::w#5 print_char_cursor#138 print_byte::b#1 ] main:2::test_16s:13::print_sword:31::print_word:56 [ test_16s::i#10 test_16s::res#0 print_line_cursor#1 rem16s#11 print_word::w#5 print_char_cursor#138 print_byte::b#1 ] main:2::test_16s:13::print_sword:35::print_word:56 [ test_16s::i#10 print_line_cursor#1 rem16s#11 print_word::w#5 print_char_cursor#138 print_byte::b#1 ] main:2::test_16s:13::print_sword:39::print_word:56 [ test_16s::i#10 print_line_cursor#1 print_word::w#5 print_char_cursor#138 print_byte::b#1 ] main:2::test_16u:9::print_word:234 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::divisor#0 test_16u::res#0 print_word::w#5 print_char_cursor#138 print_byte::b#1 ] main:2::test_16u:9::print_word:238 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::res#0 print_word::w#5 print_char_cursor#138 print_byte::b#1 ] main:2::test_16u:9::print_word:242 [ print_line_cursor#1 rem16u#1 test_16u::i#10 print_word::w#5 print_char_cursor#138 print_byte::b#1 ] main:2::test_16u:9::print_word:246 [ print_line_cursor#1 test_16u::i#10 print_word::w#5 print_char_cursor#138 print_byte::b#1 ] ) always clobbers reg byte a 
Statement [68] (byte) print_byte::b#2 ← < (word) print_word::w#5 [ print_char_cursor#19 print_byte::b#2 ] ( main:2::test_16s:13::print_sword:27::print_word:56 [ test_16s::i#10 test_16s::divisor#0 test_16s::res#0 print_line_cursor#1 rem16s#11 print_char_cursor#19 print_byte::b#2 ] main:2::test_16s:13::print_sword:31::print_word:56 [ test_16s::i#10 test_16s::res#0 print_line_cursor#1 rem16s#11 print_char_cursor#19 print_byte::b#2 ] main:2::test_16s:13::print_sword:35::print_word:56 [ test_16s::i#10 print_line_cursor#1 rem16s#11 print_char_cursor#19 print_byte::b#2 ] main:2::test_16s:13::print_sword:39::print_word:56 [ test_16s::i#10 print_line_cursor#1 print_char_cursor#19 print_byte::b#2 ] main:2::test_16u:9::print_word:234 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::divisor#0 test_16u::res#0 print_char_cursor#19 print_byte::b#2 ] main:2::test_16u:9::print_word:238 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::res#0 print_char_cursor#19 print_byte::b#2 ] main:2::test_16u:9::print_word:242 [ print_line_cursor#1 rem16u#1 test_16u::i#10 print_char_cursor#19 print_byte::b#2 ] main:2::test_16u:9::print_word:246 [ print_line_cursor#1 test_16u::i#10 print_char_cursor#19 print_byte::b#2 ] ) always clobbers reg byte a 
Statement [72] (byte~) print_byte::$0 ← (byte) print_byte::b#7 >> (byte) 4 [ print_char_cursor#139 print_byte::b#7 print_byte::$0 ] ( main:2::test_16s:13::print_sword:27::print_word:56::print_byte:67 [ test_16s::i#10 test_16s::divisor#0 test_16s::res#0 print_line_cursor#1 rem16s#11 print_word::w#5 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_16s:13::print_sword:31::print_word:56::print_byte:67 [ test_16s::i#10 test_16s::res#0 print_line_cursor#1 rem16s#11 print_word::w#5 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_16s:13::print_sword:35::print_word:56::print_byte:67 [ test_16s::i#10 print_line_cursor#1 rem16s#11 print_word::w#5 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_16s:13::print_sword:39::print_word:56::print_byte:67 [ test_16s::i#10 print_line_cursor#1 print_word::w#5 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_16u:9::print_word:234::print_byte:67 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::divisor#0 test_16u::res#0 print_word::w#5 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_16u:9::print_word:238::print_byte:67 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::res#0 print_word::w#5 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_16u:9::print_word:242::print_byte:67 [ print_line_cursor#1 rem16u#1 test_16u::i#10 print_word::w#5 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_16u:9::print_word:246::print_byte:67 [ print_line_cursor#1 test_16u::i#10 print_word::w#5 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_16s:13::print_sword:27::print_word:56::print_byte:69 [ test_16s::i#10 test_16s::divisor#0 test_16s::res#0 print_line_cursor#1 rem16s#11 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_16s:13::print_sword:31::print_word:56::print_byte:69 [ test_16s::i#10 test_16s::res#0 print_line_cursor#1 rem16s#11 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_16s:13::print_sword:35::print_word:56::print_byte:69 [ test_16s::i#10 print_line_cursor#1 rem16s#11 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_16s:13::print_sword:39::print_word:56::print_byte:69 [ test_16s::i#10 print_line_cursor#1 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_16u:9::print_word:234::print_byte:69 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::divisor#0 test_16u::res#0 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_16u:9::print_word:238::print_byte:69 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::res#0 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_16u:9::print_word:242::print_byte:69 [ print_line_cursor#1 rem16u#1 test_16u::i#10 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_16u:9::print_word:246::print_byte:69 [ print_line_cursor#1 test_16u::i#10 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_8s:11::print_sbyte:145::print_byte:169 [ print_line_cursor#1 test_8s::i#10 test_8s::divisor#0 test_8s::res#0 rem8s#3 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_8s:11::print_sbyte:149::print_byte:169 [ print_line_cursor#1 test_8s::i#10 test_8s::res#0 rem8s#3 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_8s:11::print_sbyte:153::print_byte:169 [ print_line_cursor#1 test_8s::i#10 rem8s#3 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_8s:11::print_sbyte:157::print_byte:169 [ print_line_cursor#1 test_8s::i#10 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_8u:7::print_byte:268 [ print_line_cursor#41 rem8u#17 test_8u::i#10 test_8u::divisor#0 test_8u::res#0 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_8u:7::print_byte:272 [ print_line_cursor#41 rem8u#17 test_8u::i#10 test_8u::res#0 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_8u:7::print_byte:276 [ print_line_cursor#41 rem8u#17 test_8u::i#10 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_8u:7::print_byte:280 [ print_line_cursor#41 test_8u::i#10 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] ) always clobbers reg byte a 
Statement [75] (byte~) print_byte::$2 ← (byte) print_byte::b#7 & (byte) $f [ print_char_cursor#19 print_byte::$2 ] ( main:2::test_16s:13::print_sword:27::print_word:56::print_byte:67 [ test_16s::i#10 test_16s::divisor#0 test_16s::res#0 print_line_cursor#1 rem16s#11 print_word::w#5 print_char_cursor#19 print_byte::$2 ] main:2::test_16s:13::print_sword:31::print_word:56::print_byte:67 [ test_16s::i#10 test_16s::res#0 print_line_cursor#1 rem16s#11 print_word::w#5 print_char_cursor#19 print_byte::$2 ] main:2::test_16s:13::print_sword:35::print_word:56::print_byte:67 [ test_16s::i#10 print_line_cursor#1 rem16s#11 print_word::w#5 print_char_cursor#19 print_byte::$2 ] main:2::test_16s:13::print_sword:39::print_word:56::print_byte:67 [ test_16s::i#10 print_line_cursor#1 print_word::w#5 print_char_cursor#19 print_byte::$2 ] main:2::test_16u:9::print_word:234::print_byte:67 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::divisor#0 test_16u::res#0 print_word::w#5 print_char_cursor#19 print_byte::$2 ] main:2::test_16u:9::print_word:238::print_byte:67 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::res#0 print_word::w#5 print_char_cursor#19 print_byte::$2 ] main:2::test_16u:9::print_word:242::print_byte:67 [ print_line_cursor#1 rem16u#1 test_16u::i#10 print_word::w#5 print_char_cursor#19 print_byte::$2 ] main:2::test_16u:9::print_word:246::print_byte:67 [ print_line_cursor#1 test_16u::i#10 print_word::w#5 print_char_cursor#19 print_byte::$2 ] main:2::test_16s:13::print_sword:27::print_word:56::print_byte:69 [ test_16s::i#10 test_16s::divisor#0 test_16s::res#0 print_line_cursor#1 rem16s#11 print_char_cursor#19 print_byte::$2 ] main:2::test_16s:13::print_sword:31::print_word:56::print_byte:69 [ test_16s::i#10 test_16s::res#0 print_line_cursor#1 rem16s#11 print_char_cursor#19 print_byte::$2 ] main:2::test_16s:13::print_sword:35::print_word:56::print_byte:69 [ test_16s::i#10 print_line_cursor#1 rem16s#11 print_char_cursor#19 print_byte::$2 ] main:2::test_16s:13::print_sword:39::print_word:56::print_byte:69 [ test_16s::i#10 print_line_cursor#1 print_char_cursor#19 print_byte::$2 ] main:2::test_16u:9::print_word:234::print_byte:69 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::divisor#0 test_16u::res#0 print_char_cursor#19 print_byte::$2 ] main:2::test_16u:9::print_word:238::print_byte:69 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::res#0 print_char_cursor#19 print_byte::$2 ] main:2::test_16u:9::print_word:242::print_byte:69 [ print_line_cursor#1 rem16u#1 test_16u::i#10 print_char_cursor#19 print_byte::$2 ] main:2::test_16u:9::print_word:246::print_byte:69 [ print_line_cursor#1 test_16u::i#10 print_char_cursor#19 print_byte::$2 ] main:2::test_8s:11::print_sbyte:145::print_byte:169 [ print_line_cursor#1 test_8s::i#10 test_8s::divisor#0 test_8s::res#0 rem8s#3 print_char_cursor#19 print_byte::$2 ] main:2::test_8s:11::print_sbyte:149::print_byte:169 [ print_line_cursor#1 test_8s::i#10 test_8s::res#0 rem8s#3 print_char_cursor#19 print_byte::$2 ] main:2::test_8s:11::print_sbyte:153::print_byte:169 [ print_line_cursor#1 test_8s::i#10 rem8s#3 print_char_cursor#19 print_byte::$2 ] main:2::test_8s:11::print_sbyte:157::print_byte:169 [ print_line_cursor#1 test_8s::i#10 print_char_cursor#19 print_byte::$2 ] main:2::test_8u:7::print_byte:268 [ print_line_cursor#41 rem8u#17 test_8u::i#10 test_8u::divisor#0 test_8u::res#0 print_char_cursor#19 print_byte::$2 ] main:2::test_8u:7::print_byte:272 [ print_line_cursor#41 rem8u#17 test_8u::i#10 test_8u::res#0 print_char_cursor#19 print_byte::$2 ] main:2::test_8u:7::print_byte:276 [ print_line_cursor#41 rem8u#17 test_8u::i#10 print_char_cursor#19 print_byte::$2 ] main:2::test_8u:7::print_byte:280 [ print_line_cursor#41 test_8u::i#10 print_char_cursor#19 print_byte::$2 ] ) always clobbers reg byte a 
Statement [81] if((byte) 0!=*((byte*) print_str::str#13)) goto print_str::@2 [ print_char_cursor#130 print_str::str#13 ] ( main:2::test_16s:13::print_str:29 [ test_16s::i#10 test_16s::divisor#0 test_16s::res#0 print_line_cursor#1 rem16s#11 print_char_cursor#130 print_str::str#13 ] main:2::test_16s:13::print_str:33 [ test_16s::i#10 test_16s::res#0 print_line_cursor#1 rem16s#11 print_char_cursor#130 print_str::str#13 ] main:2::test_16s:13::print_str:37 [ test_16s::i#10 print_line_cursor#1 rem16s#11 print_char_cursor#130 print_str::str#13 ] main:2::test_8s:11::print_str:147 [ print_line_cursor#1 test_8s::i#10 test_8s::divisor#0 test_8s::res#0 rem8s#3 print_char_cursor#130 print_str::str#13 ] main:2::test_8s:11::print_str:151 [ print_line_cursor#1 test_8s::i#10 test_8s::res#0 rem8s#3 print_char_cursor#130 print_str::str#13 ] main:2::test_8s:11::print_str:155 [ print_line_cursor#1 test_8s::i#10 rem8s#3 print_char_cursor#130 print_str::str#13 ] main:2::test_16u:9::print_str:236 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::divisor#0 test_16u::res#0 print_char_cursor#130 print_str::str#13 ] main:2::test_16u:9::print_str:240 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::res#0 print_char_cursor#130 print_str::str#13 ] main:2::test_16u:9::print_str:244 [ print_line_cursor#1 rem16u#1 test_16u::i#10 print_char_cursor#130 print_str::str#13 ] main:2::test_8u:7::print_str:270 [ print_line_cursor#41 rem8u#17 test_8u::i#10 test_8u::divisor#0 test_8u::res#0 print_char_cursor#130 print_str::str#13 ] main:2::test_8u:7::print_str:274 [ print_line_cursor#41 rem8u#17 test_8u::i#10 test_8u::res#0 print_char_cursor#130 print_str::str#13 ] main:2::test_8u:7::print_str:278 [ print_line_cursor#41 rem8u#17 test_8u::i#10 print_char_cursor#130 print_str::str#13 ] ) always clobbers reg byte a reg byte y 
Statement [83] *((byte*) print_char_cursor#130) ← *((byte*) print_str::str#13) [ print_char_cursor#130 print_str::str#13 ] ( main:2::test_16s:13::print_str:29 [ test_16s::i#10 test_16s::divisor#0 test_16s::res#0 print_line_cursor#1 rem16s#11 print_char_cursor#130 print_str::str#13 ] main:2::test_16s:13::print_str:33 [ test_16s::i#10 test_16s::res#0 print_line_cursor#1 rem16s#11 print_char_cursor#130 print_str::str#13 ] main:2::test_16s:13::print_str:37 [ test_16s::i#10 print_line_cursor#1 rem16s#11 print_char_cursor#130 print_str::str#13 ] main:2::test_8s:11::print_str:147 [ print_line_cursor#1 test_8s::i#10 test_8s::divisor#0 test_8s::res#0 rem8s#3 print_char_cursor#130 print_str::str#13 ] main:2::test_8s:11::print_str:151 [ print_line_cursor#1 test_8s::i#10 test_8s::res#0 rem8s#3 print_char_cursor#130 print_str::str#13 ] main:2::test_8s:11::print_str:155 [ print_line_cursor#1 test_8s::i#10 rem8s#3 print_char_cursor#130 print_str::str#13 ] main:2::test_16u:9::print_str:236 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::divisor#0 test_16u::res#0 print_char_cursor#130 print_str::str#13 ] main:2::test_16u:9::print_str:240 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::res#0 print_char_cursor#130 print_str::str#13 ] main:2::test_16u:9::print_str:244 [ print_line_cursor#1 rem16u#1 test_16u::i#10 print_char_cursor#130 print_str::str#13 ] main:2::test_8u:7::print_str:270 [ print_line_cursor#41 rem8u#17 test_8u::i#10 test_8u::divisor#0 test_8u::res#0 print_char_cursor#130 print_str::str#13 ] main:2::test_8u:7::print_str:274 [ print_line_cursor#41 rem8u#17 test_8u::i#10 test_8u::res#0 print_char_cursor#130 print_str::str#13 ] main:2::test_8u:7::print_str:278 [ print_line_cursor#41 rem8u#17 test_8u::i#10 print_char_cursor#130 print_str::str#13 ] ) always clobbers reg byte a reg byte y 
Statement [86] (signed word) divr16s::dividend#0 ← (signed word) div16s::dividend#0 [ div16s::divisor#0 divr16s::dividend#0 ] ( main:2::test_16s:13::div16s:22 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 div16s::divisor#0 divr16s::dividend#0 ] ) always clobbers reg byte a 
Statement [87] (signed word) divr16s::divisor#0 ← (signed word) div16s::divisor#0 [ divr16s::dividend#0 divr16s::divisor#0 ] ( main:2::test_16s:13::div16s:22 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 divr16s::dividend#0 divr16s::divisor#0 ] ) always clobbers reg byte a 
Statement [89] (signed word) divr16s::return#3 ← (signed word) divr16s::return#2 [ rem16s#11 divr16s::return#3 ] ( main:2::test_16s:13::div16s:22 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 rem16s#11 divr16s::return#3 ] ) always clobbers reg byte a 
Statement [90] (signed word) div16s::return#0 ← (signed word) divr16s::return#3 [ div16s::return#0 rem16s#11 ] ( main:2::test_16s:13::div16s:22 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 div16s::return#0 rem16s#11 ] ) always clobbers reg byte a 
Statement [92] if((signed word) divr16s::dividend#0<(signed byte) 0) goto divr16s::@1 [ divr16s::dividend#0 divr16s::divisor#0 ] ( main:2::test_16s:13::div16s:22::divr16s:88 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 divr16s::dividend#0 divr16s::divisor#0 ] ) always clobbers reg byte a 
Statement [93] (word) divr16s::dividendu#8 ← (word)(signed word) divr16s::dividend#0 [ divr16s::divisor#0 divr16s::dividendu#8 ] ( main:2::test_16s:13::div16s:22::divr16s:88 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 divr16s::divisor#0 divr16s::dividendu#8 ] ) always clobbers reg byte a 
Statement [95] if((signed word) divr16s::divisor#0<(signed byte) 0) goto divr16s::@3 [ divr16s::divisor#0 divr16s::neg#3 divr16s::dividendu#3 ] ( main:2::test_16s:13::div16s:22::divr16s:88 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 divr16s::divisor#0 divr16s::neg#3 divr16s::dividendu#3 ] ) always clobbers reg byte a 
Statement [96] (word) divr16s::divisoru#5 ← (word)(signed word) divr16s::divisor#0 [ divr16s::neg#3 divr16s::dividendu#3 divr16s::divisoru#5 ] ( main:2::test_16s:13::div16s:22::divr16s:88 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 divr16s::neg#3 divr16s::dividendu#3 divr16s::divisoru#5 ] ) always clobbers reg byte a 
Statement [98] (word) divr16u::dividend#2 ← (word) divr16s::dividendu#3 [ divr16s::divisoru#3 divr16s::neg#4 divr16u::dividend#2 ] ( main:2::test_16s:13::div16s:22::divr16s:88 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 divr16s::divisoru#3 divr16s::neg#4 divr16u::dividend#2 ] ) always clobbers reg byte a 
Statement [99] (word) divr16u::divisor#1 ← (word) divr16s::divisoru#3 [ divr16s::neg#4 divr16u::dividend#2 divr16u::divisor#1 ] ( main:2::test_16s:13::div16s:22::divr16s:88 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 divr16s::neg#4 divr16u::dividend#2 divr16u::divisor#1 ] ) always clobbers reg byte a 
Statement [101] (word) divr16u::return#3 ← (word) divr16u::return#0 [ divr16s::neg#4 divr16u::return#3 rem16u#1 ] ( main:2::test_16s:13::div16s:22::divr16s:88 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 divr16s::neg#4 divr16u::return#3 rem16u#1 ] ) always clobbers reg byte a 
Statement [102] (word) divr16s::resultu#0 ← (word) divr16u::return#3 [ divr16s::neg#4 divr16s::resultu#0 rem16u#1 ] ( main:2::test_16s:13::div16s:22::divr16s:88 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 divr16s::neg#4 divr16s::resultu#0 rem16u#1 ] ) always clobbers reg byte a 
Statement [104] (signed word~) divr16s::$16 ← (signed word)(word) rem16u#1 [ divr16s::resultu#0 divr16s::$16 ] ( main:2::test_16s:13::div16s:22::divr16s:88 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 divr16s::resultu#0 divr16s::$16 ] ) always clobbers reg byte a 
Statement [105] (signed word) rem16s#2 ← - (signed word~) divr16s::$16 [ divr16s::resultu#0 rem16s#2 ] ( main:2::test_16s:13::div16s:22::divr16s:88 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 divr16s::resultu#0 rem16s#2 ] ) always clobbers reg byte a 
Statement [106] (signed word) divr16s::return#1 ← - (signed word)(word) divr16s::resultu#0 [ rem16s#2 divr16s::return#1 ] ( main:2::test_16s:13::div16s:22::divr16s:88 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 rem16s#2 divr16s::return#1 ] ) always clobbers reg byte a 
Statement [109] (signed word) divr16s::return#7 ← (signed word)(word) divr16s::resultu#0 [ rem16u#1 divr16s::return#7 ] ( main:2::test_16s:13::div16s:22::divr16s:88 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 rem16u#1 divr16s::return#7 ] ) always clobbers reg byte a 
Statement [110] (signed word) rem16s#37 ← (signed word)(word) rem16u#1 [ divr16s::return#7 rem16s#37 ] ( main:2::test_16s:13::div16s:22::divr16s:88 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 divr16s::return#7 rem16s#37 ] ) always clobbers reg byte a 
Statement [111] (signed word) divr16s::divisoru#1 ← - (signed word) divr16s::divisor#0 [ divr16s::neg#3 divr16s::dividendu#3 divr16s::divisoru#1 ] ( main:2::test_16s:13::div16s:22::divr16s:88 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 divr16s::neg#3 divr16s::dividendu#3 divr16s::divisoru#1 ] ) always clobbers reg byte a 
Statement [112] (byte) divr16s::neg#2 ← (byte) divr16s::neg#3 ^ (byte) 1 [ divr16s::dividendu#3 divr16s::neg#2 divr16s::divisoru#1 ] ( main:2::test_16s:13::div16s:22::divr16s:88 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 divr16s::dividendu#3 divr16s::neg#2 divr16s::divisoru#1 ] ) always clobbers reg byte a 
Statement [113] (word) divr16s::divisoru#4 ← (word)(signed word) divr16s::divisoru#1 [ divr16s::dividendu#3 divr16s::divisoru#4 divr16s::neg#2 ] ( main:2::test_16s:13::div16s:22::divr16s:88 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 divr16s::dividendu#3 divr16s::divisoru#4 divr16s::neg#2 ] ) always clobbers reg byte a 
Statement [114] (signed word) divr16s::dividendu#1 ← - (signed word) divr16s::dividend#0 [ divr16s::divisor#0 divr16s::dividendu#1 ] ( main:2::test_16s:13::div16s:22::divr16s:88 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 divr16s::divisor#0 divr16s::dividendu#1 ] ) always clobbers reg byte a 
Statement [115] (word) divr16s::dividendu#7 ← (word)(signed word) divr16s::dividendu#1 [ divr16s::divisor#0 divr16s::dividendu#7 ] ( main:2::test_16s:13::div16s:22::divr16s:88 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 divr16s::divisor#0 divr16s::dividendu#7 ] ) always clobbers reg byte a 
Statement [119] (byte~) divr16u::$1 ← > (word) divr16u::dividend#3 [ divr16u::divisor#6 divr16u::dividend#3 divr16u::quotient#3 divr16u::i#2 divr16u::rem#0 divr16u::$1 ] ( main:2::test_16s:13::div16s:22::divr16s:88::divr16u:100 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 divr16s::neg#4 divr16u::divisor#6 divr16u::dividend#3 divr16u::quotient#3 divr16u::i#2 divr16u::rem#0 divr16u::$1 ] main:2::test_16u:9::div16u:229::divr16u:254 [ print_line_cursor#1 test_16u::i#10 test_16u::dividend#0 test_16u::divisor#0 divr16u::divisor#6 divr16u::dividend#3 divr16u::quotient#3 divr16u::i#2 divr16u::rem#0 divr16u::$1 ] ) always clobbers reg byte a 
Statement [122] (word) divr16u::rem#1 ← (word) divr16u::rem#0 | (byte) 1 [ divr16u::divisor#6 divr16u::dividend#3 divr16u::quotient#3 divr16u::i#2 divr16u::rem#1 ] ( main:2::test_16s:13::div16s:22::divr16s:88::divr16u:100 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 divr16s::neg#4 divr16u::divisor#6 divr16u::dividend#3 divr16u::quotient#3 divr16u::i#2 divr16u::rem#1 ] main:2::test_16u:9::div16u:229::divr16u:254 [ print_line_cursor#1 test_16u::i#10 test_16u::dividend#0 test_16u::divisor#0 divr16u::divisor#6 divr16u::dividend#3 divr16u::quotient#3 divr16u::i#2 divr16u::rem#1 ] ) always clobbers reg byte a 
Statement [126] if((word) divr16u::rem#6<(word) divr16u::divisor#6) goto divr16u::@3 [ divr16u::divisor#6 divr16u::i#2 divr16u::dividend#0 divr16u::rem#6 divr16u::quotient#1 ] ( main:2::test_16s:13::div16s:22::divr16s:88::divr16u:100 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 divr16s::neg#4 divr16u::divisor#6 divr16u::i#2 divr16u::dividend#0 divr16u::rem#6 divr16u::quotient#1 ] main:2::test_16u:9::div16u:229::divr16u:254 [ print_line_cursor#1 test_16u::i#10 test_16u::dividend#0 test_16u::divisor#0 divr16u::divisor#6 divr16u::i#2 divr16u::dividend#0 divr16u::rem#6 divr16u::quotient#1 ] ) always clobbers reg byte a 
Statement [128] (word) divr16u::rem#2 ← (word) divr16u::rem#6 - (word) divr16u::divisor#6 [ divr16u::divisor#6 divr16u::i#2 divr16u::dividend#0 divr16u::quotient#2 divr16u::rem#2 ] ( main:2::test_16s:13::div16s:22::divr16s:88::divr16u:100 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 divr16s::neg#4 divr16u::divisor#6 divr16u::i#2 divr16u::dividend#0 divr16u::quotient#2 divr16u::rem#2 ] main:2::test_16u:9::div16u:229::divr16u:254 [ print_line_cursor#1 test_16u::i#10 test_16u::dividend#0 test_16u::divisor#0 divr16u::divisor#6 divr16u::i#2 divr16u::dividend#0 divr16u::quotient#2 divr16u::rem#2 ] ) always clobbers reg byte a 
Statement [132] (word) rem16u#1 ← (word) divr16u::rem#11 [ divr16u::return#0 rem16u#1 ] ( main:2::test_16s:13::div16s:22::divr16s:88::divr16u:100 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 divr16s::neg#4 divr16u::return#0 rem16u#1 ] main:2::test_16u:9::div16u:229::divr16u:254 [ print_line_cursor#1 test_16u::i#10 test_16u::dividend#0 test_16u::divisor#0 divr16u::return#0 rem16u#1 ] ) always clobbers reg byte a 
Statement [144] (byte*) print_char_cursor#167 ← (byte*) print_line_cursor#1 [ print_line_cursor#1 test_8s::i#10 test_8s::divisor#0 test_8s::res#0 print_sbyte::b#1 print_char_cursor#167 rem8s#3 ] ( main:2::test_8s:11 [ print_line_cursor#1 test_8s::i#10 test_8s::divisor#0 test_8s::res#0 print_sbyte::b#1 print_char_cursor#167 rem8s#3 ] ) always clobbers reg byte a 
Statement [173] (signed byte) print_sbyte::b#0 ← - (signed byte) print_sbyte::b#10 [ print_char_cursor#19 print_sbyte::b#0 ] ( main:2::test_8s:11::print_sbyte:145 [ print_line_cursor#1 test_8s::i#10 test_8s::divisor#0 test_8s::res#0 rem8s#3 print_char_cursor#19 print_sbyte::b#0 ] main:2::test_8s:11::print_sbyte:149 [ print_line_cursor#1 test_8s::i#10 test_8s::res#0 rem8s#3 print_char_cursor#19 print_sbyte::b#0 ] main:2::test_8s:11::print_sbyte:153 [ print_line_cursor#1 test_8s::i#10 rem8s#3 print_char_cursor#19 print_sbyte::b#0 ] main:2::test_8s:11::print_sbyte:157 [ print_line_cursor#1 test_8s::i#10 print_char_cursor#19 print_sbyte::b#0 ] ) always clobbers reg byte a 
Statement [187] (signed byte) rem8s#2 ← - (signed byte~) div8s::$11 [ div8s::resultu#0 rem8s#2 ] ( main:2::test_8s:11::div8s:140 [ print_line_cursor#1 test_8s::i#10 test_8s::dividend#0 test_8s::divisor#0 div8s::resultu#0 rem8s#2 ] ) always clobbers reg byte a 
Statement [188] (signed byte) div8s::return#1 ← - (signed byte)(byte) div8s::resultu#0 [ rem8s#2 div8s::return#1 ] ( main:2::test_8s:11::div8s:140 [ print_line_cursor#1 test_8s::i#10 test_8s::dividend#0 test_8s::divisor#0 rem8s#2 div8s::return#1 ] ) always clobbers reg byte a 
Statement [193] (signed byte) div8s::divisoru#1 ← - (signed byte) div8s::divisor#0 [ div8s::neg#3 div8s::dividendu#3 div8s::divisoru#1 ] ( main:2::test_8s:11::div8s:140 [ print_line_cursor#1 test_8s::i#10 test_8s::dividend#0 test_8s::divisor#0 div8s::neg#3 div8s::dividendu#3 div8s::divisoru#1 ] ) always clobbers reg byte a 
Statement [194] (byte) div8s::neg#2 ← (byte) div8s::neg#3 ^ (byte) 1 [ div8s::dividendu#3 div8s::neg#2 div8s::divisoru#1 ] ( main:2::test_8s:11::div8s:140 [ print_line_cursor#1 test_8s::i#10 test_8s::dividend#0 test_8s::divisor#0 div8s::dividendu#3 div8s::neg#2 div8s::divisoru#1 ] ) always clobbers reg byte a 
Statement [196] (signed byte) div8s::dividendu#1 ← - (signed byte) div8s::dividend#0 [ div8s::divisor#0 div8s::dividendu#1 ] ( main:2::test_8s:11::div8s:140 [ print_line_cursor#1 test_8s::i#10 test_8s::dividend#0 test_8s::divisor#0 div8s::divisor#0 div8s::dividendu#1 ] ) always clobbers reg byte a 
Statement [208] (byte~) divr8u::$1 ← (byte) divr8u::dividend#2 & (byte) $80 [ divr8u::divisor#0 divr8u::dividend#2 divr8u::quotient#3 divr8u::i#2 divr8u::rem#1 divr8u::$1 ] ( main:2::test_8s:11::div8s:140::div8u:182::divr8u:201 [ print_line_cursor#1 test_8s::i#10 test_8s::dividend#0 test_8s::divisor#0 div8s::neg#4 divr8u::divisor#0 divr8u::dividend#2 divr8u::quotient#3 divr8u::i#2 divr8u::rem#1 divr8u::$1 ] main:2::test_8u:7::div8u:264::divr8u:201 [ print_line_cursor#41 print_char_cursor#141 test_8u::i#10 test_8u::dividend#0 test_8u::divisor#0 divr8u::divisor#0 divr8u::dividend#2 divr8u::quotient#3 divr8u::i#2 divr8u::rem#1 divr8u::$1 ] ) always clobbers reg byte a 
Removing always clobbered register reg byte a as potential for zp[1]:42 [ divr8u::rem#4 divr8u::rem#10 divr8u::rem#5 divr8u::rem#1 divr8u::rem#2 divr8u::rem#3 ]
Statement [210] (byte) divr8u::rem#2 ← (byte) divr8u::rem#1 | (byte) 1 [ divr8u::divisor#0 divr8u::dividend#2 divr8u::quotient#3 divr8u::i#2 divr8u::rem#2 ] ( main:2::test_8s:11::div8s:140::div8u:182::divr8u:201 [ print_line_cursor#1 test_8s::i#10 test_8s::dividend#0 test_8s::divisor#0 div8s::neg#4 divr8u::divisor#0 divr8u::dividend#2 divr8u::quotient#3 divr8u::i#2 divr8u::rem#2 ] main:2::test_8u:7::div8u:264::divr8u:201 [ print_line_cursor#41 print_char_cursor#141 test_8u::i#10 test_8u::dividend#0 test_8u::divisor#0 divr8u::divisor#0 divr8u::dividend#2 divr8u::quotient#3 divr8u::i#2 divr8u::rem#2 ] ) always clobbers reg byte a 
Statement [216] (byte) divr8u::rem#3 ← (byte) divr8u::rem#5 - (byte) divr8u::divisor#0 [ divr8u::divisor#0 divr8u::i#2 divr8u::dividend#1 divr8u::quotient#2 divr8u::rem#3 ] ( main:2::test_8s:11::div8s:140::div8u:182::divr8u:201 [ print_line_cursor#1 test_8s::i#10 test_8s::dividend#0 test_8s::divisor#0 div8s::neg#4 divr8u::divisor#0 divr8u::i#2 divr8u::dividend#1 divr8u::quotient#2 divr8u::rem#3 ] main:2::test_8u:7::div8u:264::divr8u:201 [ print_line_cursor#41 print_char_cursor#141 test_8u::i#10 test_8u::dividend#0 test_8u::divisor#0 divr8u::divisor#0 divr8u::i#2 divr8u::dividend#1 divr8u::quotient#2 divr8u::rem#3 ] ) always clobbers reg byte a 
Statement [224] (byte~) test_16u::$11 ← (byte) test_16u::i#10 << (byte) 1 [ print_line_cursor#1 test_16u::i#10 test_16u::$11 ] ( main:2::test_16u:9 [ print_line_cursor#1 test_16u::i#10 test_16u::$11 ] ) always clobbers reg byte a 
Statement [225] (word) test_16u::dividend#0 ← *((const word*) test_16u::dividends + (byte~) test_16u::$11) [ print_line_cursor#1 test_16u::i#10 test_16u::$11 test_16u::dividend#0 ] ( main:2::test_16u:9 [ print_line_cursor#1 test_16u::i#10 test_16u::$11 test_16u::dividend#0 ] ) always clobbers reg byte a 
Statement [226] (word) test_16u::divisor#0 ← *((const word*) test_16u::divisors + (byte~) test_16u::$11) [ print_line_cursor#1 test_16u::i#10 test_16u::dividend#0 test_16u::divisor#0 ] ( main:2::test_16u:9 [ print_line_cursor#1 test_16u::i#10 test_16u::dividend#0 test_16u::divisor#0 ] ) always clobbers reg byte a 
Statement [227] (word) div16u::dividend#0 ← (word) test_16u::dividend#0 [ print_line_cursor#1 test_16u::i#10 test_16u::dividend#0 test_16u::divisor#0 div16u::dividend#0 ] ( main:2::test_16u:9 [ print_line_cursor#1 test_16u::i#10 test_16u::dividend#0 test_16u::divisor#0 div16u::dividend#0 ] ) always clobbers reg byte a 
Statement [228] (word) div16u::divisor#0 ← (word) test_16u::divisor#0 [ print_line_cursor#1 test_16u::i#10 test_16u::dividend#0 test_16u::divisor#0 div16u::dividend#0 div16u::divisor#0 ] ( main:2::test_16u:9 [ print_line_cursor#1 test_16u::i#10 test_16u::dividend#0 test_16u::divisor#0 div16u::dividend#0 div16u::divisor#0 ] ) always clobbers reg byte a 
Statement [230] (word) div16u::return#2 ← (word) div16u::return#0 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::dividend#0 test_16u::divisor#0 div16u::return#2 ] ( main:2::test_16u:9 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::dividend#0 test_16u::divisor#0 div16u::return#2 ] ) always clobbers reg byte a 
Statement [231] (word) test_16u::res#0 ← (word) div16u::return#2 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::dividend#0 test_16u::divisor#0 test_16u::res#0 ] ( main:2::test_16u:9 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::dividend#0 test_16u::divisor#0 test_16u::res#0 ] ) always clobbers reg byte a 
Statement [232] (word) print_word::w#1 ← (word) test_16u::dividend#0 [ print_line_cursor#1 print_word::w#1 rem16u#1 test_16u::i#10 test_16u::divisor#0 test_16u::res#0 ] ( main:2::test_16u:9 [ print_line_cursor#1 print_word::w#1 rem16u#1 test_16u::i#10 test_16u::divisor#0 test_16u::res#0 ] ) always clobbers reg byte a 
Statement [233] (byte*) print_char_cursor#172 ← (byte*) print_line_cursor#1 [ print_line_cursor#1 print_word::w#1 print_char_cursor#172 rem16u#1 test_16u::i#10 test_16u::divisor#0 test_16u::res#0 ] ( main:2::test_16u:9 [ print_line_cursor#1 print_word::w#1 print_char_cursor#172 rem16u#1 test_16u::i#10 test_16u::divisor#0 test_16u::res#0 ] ) always clobbers reg byte a 
Statement [237] (word) print_word::w#2 ← (word) test_16u::divisor#0 [ print_line_cursor#1 print_char_cursor#130 print_word::w#2 rem16u#1 test_16u::i#10 test_16u::res#0 ] ( main:2::test_16u:9 [ print_line_cursor#1 print_char_cursor#130 print_word::w#2 rem16u#1 test_16u::i#10 test_16u::res#0 ] ) always clobbers reg byte a 
Statement [241] (word) print_word::w#3 ← (word) test_16u::res#0 [ print_line_cursor#1 print_char_cursor#130 print_word::w#3 rem16u#1 test_16u::i#10 ] ( main:2::test_16u:9 [ print_line_cursor#1 print_char_cursor#130 print_word::w#3 rem16u#1 test_16u::i#10 ] ) always clobbers reg byte a 
Statement [245] (word) print_word::w#4 ← (word) rem16u#1 [ print_line_cursor#1 print_char_cursor#130 print_word::w#4 test_16u::i#10 ] ( main:2::test_16u:9 [ print_line_cursor#1 print_char_cursor#130 print_word::w#4 test_16u::i#10 ] ) always clobbers reg byte a 
Statement [252] (word) divr16u::dividend#1 ← (word) div16u::dividend#0 [ divr16u::dividend#1 div16u::divisor#0 ] ( main:2::test_16u:9::div16u:229 [ print_line_cursor#1 test_16u::i#10 test_16u::dividend#0 test_16u::divisor#0 divr16u::dividend#1 div16u::divisor#0 ] ) always clobbers reg byte a 
Statement [253] (word) divr16u::divisor#0 ← (word) div16u::divisor#0 [ divr16u::dividend#1 divr16u::divisor#0 ] ( main:2::test_16u:9::div16u:229 [ print_line_cursor#1 test_16u::i#10 test_16u::dividend#0 test_16u::divisor#0 divr16u::dividend#1 divr16u::divisor#0 ] ) always clobbers reg byte a 
Statement [255] (word) divr16u::return#2 ← (word) divr16u::return#0 [ rem16u#1 divr16u::return#2 ] ( main:2::test_16u:9::div16u:229 [ print_line_cursor#1 test_16u::i#10 test_16u::dividend#0 test_16u::divisor#0 rem16u#1 divr16u::return#2 ] ) always clobbers reg byte a 
Statement [256] (word) div16u::return#0 ← (word) divr16u::return#2 [ rem16u#1 div16u::return#0 ] ( main:2::test_16u:9::div16u:229 [ print_line_cursor#1 test_16u::i#10 test_16u::dividend#0 test_16u::divisor#0 rem16u#1 div16u::return#0 ] ) always clobbers reg byte a 
Statement [286] (byte*) print_char_cursor#189 ← (byte*) print_line_cursor#1 [ print_line_cursor#1 test_8u::i#1 print_char_cursor#189 ] ( main:2::test_8u:7 [ print_line_cursor#1 test_8u::i#1 print_char_cursor#189 ] ) always clobbers reg byte a 
Statement [292] if((byte*) memset::dst#2!=(const byte*) memset::end#0) goto memset::@2 [ memset::dst#2 ] ( main:2::print_cls:5::memset:288 [ memset::dst#2 ] ) always clobbers reg byte a 
Statement [294] *((byte*) memset::dst#2) ← (const byte) memset::c#0 [ memset::dst#2 ] ( main:2::print_cls:5::memset:288 [ memset::dst#2 ] ) always clobbers reg byte a reg byte y 
Statement [17] (byte~) test_16s::$11 ← (byte) test_16s::i#10 << (byte) 1 [ test_16s::i#10 test_16s::$11 print_line_cursor#1 ] ( main:2::test_16s:13 [ test_16s::i#10 test_16s::$11 print_line_cursor#1 ] ) always clobbers reg byte a 
Statement [18] (signed word) test_16s::dividend#0 ← *((const signed word*) test_16s::dividends + (byte~) test_16s::$11) [ test_16s::i#10 test_16s::$11 test_16s::dividend#0 print_line_cursor#1 ] ( main:2::test_16s:13 [ test_16s::i#10 test_16s::$11 test_16s::dividend#0 print_line_cursor#1 ] ) always clobbers reg byte a 
Statement [19] (signed word) test_16s::divisor#0 ← *((const signed word*) test_16s::divisors + (byte~) test_16s::$11) [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 ] ( main:2::test_16s:13 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 ] ) always clobbers reg byte a 
Statement [20] (signed word) div16s::dividend#0 ← (signed word) test_16s::dividend#0 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 div16s::dividend#0 print_line_cursor#1 ] ( main:2::test_16s:13 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 div16s::dividend#0 print_line_cursor#1 ] ) always clobbers reg byte a 
Statement [21] (signed word) div16s::divisor#0 ← (signed word) test_16s::divisor#0 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 div16s::dividend#0 div16s::divisor#0 print_line_cursor#1 ] ( main:2::test_16s:13 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 div16s::dividend#0 div16s::divisor#0 print_line_cursor#1 ] ) always clobbers reg byte a 
Statement [23] (signed word) div16s::return#2 ← (signed word) div16s::return#0 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 div16s::return#2 print_line_cursor#1 rem16s#11 ] ( main:2::test_16s:13 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 div16s::return#2 print_line_cursor#1 rem16s#11 ] ) always clobbers reg byte a 
Statement [24] (signed word) test_16s::res#0 ← (signed word) div16s::return#2 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 test_16s::res#0 print_line_cursor#1 rem16s#11 ] ( main:2::test_16s:13 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 test_16s::res#0 print_line_cursor#1 rem16s#11 ] ) always clobbers reg byte a 
Statement [25] (signed word) print_sword::w#1 ← (signed word) test_16s::dividend#0 [ test_16s::i#10 test_16s::divisor#0 test_16s::res#0 print_sword::w#1 print_line_cursor#1 rem16s#11 ] ( main:2::test_16s:13 [ test_16s::i#10 test_16s::divisor#0 test_16s::res#0 print_sword::w#1 print_line_cursor#1 rem16s#11 ] ) always clobbers reg byte a 
Statement [26] (byte*) print_char_cursor#163 ← (byte*) print_line_cursor#1 [ test_16s::i#10 test_16s::divisor#0 test_16s::res#0 print_sword::w#1 print_char_cursor#163 print_line_cursor#1 rem16s#11 ] ( main:2::test_16s:13 [ test_16s::i#10 test_16s::divisor#0 test_16s::res#0 print_sword::w#1 print_char_cursor#163 print_line_cursor#1 rem16s#11 ] ) always clobbers reg byte a 
Statement [30] (signed word) print_sword::w#2 ← (signed word) test_16s::divisor#0 [ test_16s::i#10 test_16s::res#0 print_line_cursor#1 print_sword::w#2 rem16s#11 print_char_cursor#130 ] ( main:2::test_16s:13 [ test_16s::i#10 test_16s::res#0 print_line_cursor#1 print_sword::w#2 rem16s#11 print_char_cursor#130 ] ) always clobbers reg byte a 
Statement [34] (signed word) print_sword::w#3 ← (signed word) test_16s::res#0 [ test_16s::i#10 print_line_cursor#1 print_sword::w#3 rem16s#11 print_char_cursor#130 ] ( main:2::test_16s:13 [ test_16s::i#10 print_line_cursor#1 print_sword::w#3 rem16s#11 print_char_cursor#130 ] ) always clobbers reg byte a 
Statement [38] (signed word) print_sword::w#4 ← (signed word) rem16s#11 [ test_16s::i#10 print_line_cursor#1 print_sword::w#4 print_char_cursor#130 ] ( main:2::test_16s:13 [ test_16s::i#10 print_line_cursor#1 print_sword::w#4 print_char_cursor#130 ] ) always clobbers reg byte a 
Statement [47] (byte*) print_line_cursor#1 ← (byte*) print_line_cursor#20 + (byte) $28 [ print_line_cursor#1 print_char_cursor#19 ] ( main:2::test_16s:13::print_ln:41 [ test_16s::i#10 print_line_cursor#1 print_char_cursor#19 ] main:2::test_8s:11::print_ln:159 [ test_8s::i#10 print_line_cursor#1 print_char_cursor#19 ] main:2::test_16u:9::print_ln:248 [ test_16u::i#10 print_line_cursor#1 print_char_cursor#19 ] main:2::test_8u:7::print_ln:282 [ test_8u::i#10 print_line_cursor#1 print_char_cursor#19 ] ) always clobbers reg byte a 
Statement [48] if((byte*) print_line_cursor#1<(byte*) print_char_cursor#19) goto print_ln::@1 [ print_line_cursor#1 print_char_cursor#19 ] ( main:2::test_16s:13::print_ln:41 [ test_16s::i#10 print_line_cursor#1 print_char_cursor#19 ] main:2::test_8s:11::print_ln:159 [ test_8s::i#10 print_line_cursor#1 print_char_cursor#19 ] main:2::test_16u:9::print_ln:248 [ test_16u::i#10 print_line_cursor#1 print_char_cursor#19 ] main:2::test_8u:7::print_ln:282 [ test_8u::i#10 print_line_cursor#1 print_char_cursor#19 ] ) always clobbers reg byte a 
Statement [51] if((signed word) print_sword::w#10<(signed byte) 0) goto print_sword::@1 [ print_sword::w#10 print_char_cursor#132 ] ( main:2::test_16s:13::print_sword:27 [ test_16s::i#10 test_16s::divisor#0 test_16s::res#0 print_line_cursor#1 rem16s#11 print_sword::w#10 print_char_cursor#132 ] main:2::test_16s:13::print_sword:31 [ test_16s::i#10 test_16s::res#0 print_line_cursor#1 rem16s#11 print_sword::w#10 print_char_cursor#132 ] main:2::test_16s:13::print_sword:35 [ test_16s::i#10 print_line_cursor#1 rem16s#11 print_sword::w#10 print_char_cursor#132 ] main:2::test_16s:13::print_sword:39 [ test_16s::i#10 print_line_cursor#1 print_sword::w#10 print_char_cursor#132 ] ) always clobbers reg byte a 
Statement [55] (word) print_word::w#0 ← (word)(signed word) print_sword::w#7 [ print_char_cursor#19 print_word::w#0 ] ( main:2::test_16s:13::print_sword:27 [ test_16s::i#10 test_16s::divisor#0 test_16s::res#0 print_line_cursor#1 rem16s#11 print_char_cursor#19 print_word::w#0 ] main:2::test_16s:13::print_sword:31 [ test_16s::i#10 test_16s::res#0 print_line_cursor#1 rem16s#11 print_char_cursor#19 print_word::w#0 ] main:2::test_16s:13::print_sword:35 [ test_16s::i#10 print_line_cursor#1 rem16s#11 print_char_cursor#19 print_word::w#0 ] main:2::test_16s:13::print_sword:39 [ test_16s::i#10 print_line_cursor#1 print_char_cursor#19 print_word::w#0 ] ) always clobbers reg byte a 
Statement [60] (signed word) print_sword::w#0 ← - (signed word) print_sword::w#10 [ print_char_cursor#19 print_sword::w#0 ] ( main:2::test_16s:13::print_sword:27 [ test_16s::i#10 test_16s::divisor#0 test_16s::res#0 print_line_cursor#1 rem16s#11 print_char_cursor#19 print_sword::w#0 ] main:2::test_16s:13::print_sword:31 [ test_16s::i#10 test_16s::res#0 print_line_cursor#1 rem16s#11 print_char_cursor#19 print_sword::w#0 ] main:2::test_16s:13::print_sword:35 [ test_16s::i#10 print_line_cursor#1 rem16s#11 print_char_cursor#19 print_sword::w#0 ] main:2::test_16s:13::print_sword:39 [ test_16s::i#10 print_line_cursor#1 print_char_cursor#19 print_sword::w#0 ] ) always clobbers reg byte a 
Statement [62] *((byte*) print_char_cursor#84) ← (byte) print_char::ch#6 [ print_char_cursor#84 ] ( main:2::test_16s:13::print_sword:27::print_char:53 [ test_16s::i#10 test_16s::divisor#0 test_16s::res#0 print_line_cursor#1 rem16s#11 print_sword::w#10 print_char_cursor#84 ] main:2::test_16s:13::print_sword:31::print_char:53 [ test_16s::i#10 test_16s::res#0 print_line_cursor#1 rem16s#11 print_sword::w#10 print_char_cursor#84 ] main:2::test_16s:13::print_sword:35::print_char:53 [ test_16s::i#10 print_line_cursor#1 rem16s#11 print_sword::w#10 print_char_cursor#84 ] main:2::test_16s:13::print_sword:39::print_char:53 [ test_16s::i#10 print_line_cursor#1 print_sword::w#10 print_char_cursor#84 ] main:2::test_16s:13::print_sword:27::print_char:59 [ test_16s::i#10 test_16s::divisor#0 test_16s::res#0 print_line_cursor#1 rem16s#11 print_sword::w#10 print_char_cursor#84 ] main:2::test_16s:13::print_sword:31::print_char:59 [ test_16s::i#10 test_16s::res#0 print_line_cursor#1 rem16s#11 print_sword::w#10 print_char_cursor#84 ] main:2::test_16s:13::print_sword:35::print_char:59 [ test_16s::i#10 print_line_cursor#1 rem16s#11 print_sword::w#10 print_char_cursor#84 ] main:2::test_16s:13::print_sword:39::print_char:59 [ test_16s::i#10 print_line_cursor#1 print_sword::w#10 print_char_cursor#84 ] main:2::test_16s:13::print_sword:27::print_word:56::print_byte:67::print_char:74 [ test_16s::i#10 test_16s::divisor#0 test_16s::res#0 print_line_cursor#1 rem16s#11 print_word::w#5 print_byte::b#7 print_char_cursor#84 ] main:2::test_16s:13::print_sword:31::print_word:56::print_byte:67::print_char:74 [ test_16s::i#10 test_16s::res#0 print_line_cursor#1 rem16s#11 print_word::w#5 print_byte::b#7 print_char_cursor#84 ] main:2::test_16s:13::print_sword:35::print_word:56::print_byte:67::print_char:74 [ test_16s::i#10 print_line_cursor#1 rem16s#11 print_word::w#5 print_byte::b#7 print_char_cursor#84 ] main:2::test_16s:13::print_sword:39::print_word:56::print_byte:67::print_char:74 [ test_16s::i#10 print_line_cursor#1 print_word::w#5 print_byte::b#7 print_char_cursor#84 ] main:2::test_16u:9::print_word:234::print_byte:67::print_char:74 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::divisor#0 test_16u::res#0 print_word::w#5 print_byte::b#7 print_char_cursor#84 ] main:2::test_16u:9::print_word:238::print_byte:67::print_char:74 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::res#0 print_word::w#5 print_byte::b#7 print_char_cursor#84 ] main:2::test_16u:9::print_word:242::print_byte:67::print_char:74 [ print_line_cursor#1 rem16u#1 test_16u::i#10 print_word::w#5 print_byte::b#7 print_char_cursor#84 ] main:2::test_16u:9::print_word:246::print_byte:67::print_char:74 [ print_line_cursor#1 test_16u::i#10 print_word::w#5 print_byte::b#7 print_char_cursor#84 ] main:2::test_16s:13::print_sword:27::print_word:56::print_byte:69::print_char:74 [ test_16s::i#10 test_16s::divisor#0 test_16s::res#0 print_line_cursor#1 rem16s#11 print_byte::b#7 print_char_cursor#84 ] main:2::test_16s:13::print_sword:31::print_word:56::print_byte:69::print_char:74 [ test_16s::i#10 test_16s::res#0 print_line_cursor#1 rem16s#11 print_byte::b#7 print_char_cursor#84 ] main:2::test_16s:13::print_sword:35::print_word:56::print_byte:69::print_char:74 [ test_16s::i#10 print_line_cursor#1 rem16s#11 print_byte::b#7 print_char_cursor#84 ] main:2::test_16s:13::print_sword:39::print_word:56::print_byte:69::print_char:74 [ test_16s::i#10 print_line_cursor#1 print_byte::b#7 print_char_cursor#84 ] main:2::test_16u:9::print_word:234::print_byte:69::print_char:74 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::divisor#0 test_16u::res#0 print_byte::b#7 print_char_cursor#84 ] main:2::test_16u:9::print_word:238::print_byte:69::print_char:74 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::res#0 print_byte::b#7 print_char_cursor#84 ] main:2::test_16u:9::print_word:242::print_byte:69::print_char:74 [ print_line_cursor#1 rem16u#1 test_16u::i#10 print_byte::b#7 print_char_cursor#84 ] main:2::test_16u:9::print_word:246::print_byte:69::print_char:74 [ print_line_cursor#1 test_16u::i#10 print_byte::b#7 print_char_cursor#84 ] main:2::test_8s:11::print_sbyte:145::print_byte:169::print_char:74 [ print_line_cursor#1 test_8s::i#10 test_8s::divisor#0 test_8s::res#0 rem8s#3 print_byte::b#7 print_char_cursor#84 ] main:2::test_8s:11::print_sbyte:149::print_byte:169::print_char:74 [ print_line_cursor#1 test_8s::i#10 test_8s::res#0 rem8s#3 print_byte::b#7 print_char_cursor#84 ] main:2::test_8s:11::print_sbyte:153::print_byte:169::print_char:74 [ print_line_cursor#1 test_8s::i#10 rem8s#3 print_byte::b#7 print_char_cursor#84 ] main:2::test_8s:11::print_sbyte:157::print_byte:169::print_char:74 [ print_line_cursor#1 test_8s::i#10 print_byte::b#7 print_char_cursor#84 ] main:2::test_8u:7::print_byte:268::print_char:74 [ print_line_cursor#41 rem8u#17 test_8u::i#10 test_8u::divisor#0 test_8u::res#0 print_byte::b#7 print_char_cursor#84 ] main:2::test_8u:7::print_byte:272::print_char:74 [ print_line_cursor#41 rem8u#17 test_8u::i#10 test_8u::res#0 print_byte::b#7 print_char_cursor#84 ] main:2::test_8u:7::print_byte:276::print_char:74 [ print_line_cursor#41 rem8u#17 test_8u::i#10 print_byte::b#7 print_char_cursor#84 ] main:2::test_8u:7::print_byte:280::print_char:74 [ print_line_cursor#41 test_8u::i#10 print_byte::b#7 print_char_cursor#84 ] main:2::test_16s:13::print_sword:27::print_word:56::print_byte:67::print_char:77 [ test_16s::i#10 test_16s::divisor#0 test_16s::res#0 print_line_cursor#1 rem16s#11 print_word::w#5 print_char_cursor#84 ] main:2::test_16s:13::print_sword:31::print_word:56::print_byte:67::print_char:77 [ test_16s::i#10 test_16s::res#0 print_line_cursor#1 rem16s#11 print_word::w#5 print_char_cursor#84 ] main:2::test_16s:13::print_sword:35::print_word:56::print_byte:67::print_char:77 [ test_16s::i#10 print_line_cursor#1 rem16s#11 print_word::w#5 print_char_cursor#84 ] main:2::test_16s:13::print_sword:39::print_word:56::print_byte:67::print_char:77 [ test_16s::i#10 print_line_cursor#1 print_word::w#5 print_char_cursor#84 ] main:2::test_16u:9::print_word:234::print_byte:67::print_char:77 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::divisor#0 test_16u::res#0 print_word::w#5 print_char_cursor#84 ] main:2::test_16u:9::print_word:238::print_byte:67::print_char:77 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::res#0 print_word::w#5 print_char_cursor#84 ] main:2::test_16u:9::print_word:242::print_byte:67::print_char:77 [ print_line_cursor#1 rem16u#1 test_16u::i#10 print_word::w#5 print_char_cursor#84 ] main:2::test_16u:9::print_word:246::print_byte:67::print_char:77 [ print_line_cursor#1 test_16u::i#10 print_word::w#5 print_char_cursor#84 ] main:2::test_16s:13::print_sword:27::print_word:56::print_byte:69::print_char:77 [ test_16s::i#10 test_16s::divisor#0 test_16s::res#0 print_line_cursor#1 rem16s#11 print_char_cursor#84 ] main:2::test_16s:13::print_sword:31::print_word:56::print_byte:69::print_char:77 [ test_16s::i#10 test_16s::res#0 print_line_cursor#1 rem16s#11 print_char_cursor#84 ] main:2::test_16s:13::print_sword:35::print_word:56::print_byte:69::print_char:77 [ test_16s::i#10 print_line_cursor#1 rem16s#11 print_char_cursor#84 ] main:2::test_16s:13::print_sword:39::print_word:56::print_byte:69::print_char:77 [ test_16s::i#10 print_line_cursor#1 print_char_cursor#84 ] main:2::test_16u:9::print_word:234::print_byte:69::print_char:77 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::divisor#0 test_16u::res#0 print_char_cursor#84 ] main:2::test_16u:9::print_word:238::print_byte:69::print_char:77 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::res#0 print_char_cursor#84 ] main:2::test_16u:9::print_word:242::print_byte:69::print_char:77 [ print_line_cursor#1 rem16u#1 test_16u::i#10 print_char_cursor#84 ] main:2::test_16u:9::print_word:246::print_byte:69::print_char:77 [ print_line_cursor#1 test_16u::i#10 print_char_cursor#84 ] main:2::test_8s:11::print_sbyte:145::print_byte:169::print_char:77 [ print_line_cursor#1 test_8s::i#10 test_8s::divisor#0 test_8s::res#0 rem8s#3 print_char_cursor#84 ] main:2::test_8s:11::print_sbyte:149::print_byte:169::print_char:77 [ print_line_cursor#1 test_8s::i#10 test_8s::res#0 rem8s#3 print_char_cursor#84 ] main:2::test_8s:11::print_sbyte:153::print_byte:169::print_char:77 [ print_line_cursor#1 test_8s::i#10 rem8s#3 print_char_cursor#84 ] main:2::test_8s:11::print_sbyte:157::print_byte:169::print_char:77 [ print_line_cursor#1 test_8s::i#10 print_char_cursor#84 ] main:2::test_8u:7::print_byte:268::print_char:77 [ print_line_cursor#41 rem8u#17 test_8u::i#10 test_8u::divisor#0 test_8u::res#0 print_char_cursor#84 ] main:2::test_8u:7::print_byte:272::print_char:77 [ print_line_cursor#41 rem8u#17 test_8u::i#10 test_8u::res#0 print_char_cursor#84 ] main:2::test_8u:7::print_byte:276::print_char:77 [ print_line_cursor#41 rem8u#17 test_8u::i#10 print_char_cursor#84 ] main:2::test_8u:7::print_byte:280::print_char:77 [ print_line_cursor#41 test_8u::i#10 print_char_cursor#84 ] main:2::test_8s:11::print_sbyte:145::print_char:166 [ print_line_cursor#1 test_8s::i#10 test_8s::divisor#0 test_8s::res#0 rem8s#3 print_sbyte::b#10 print_char_cursor#84 ] main:2::test_8s:11::print_sbyte:149::print_char:166 [ print_line_cursor#1 test_8s::i#10 test_8s::res#0 rem8s#3 print_sbyte::b#10 print_char_cursor#84 ] main:2::test_8s:11::print_sbyte:153::print_char:166 [ print_line_cursor#1 test_8s::i#10 rem8s#3 print_sbyte::b#10 print_char_cursor#84 ] main:2::test_8s:11::print_sbyte:157::print_char:166 [ print_line_cursor#1 test_8s::i#10 print_sbyte::b#10 print_char_cursor#84 ] main:2::test_8s:11::print_sbyte:145::print_char:172 [ print_line_cursor#1 test_8s::i#10 test_8s::divisor#0 test_8s::res#0 rem8s#3 print_sbyte::b#10 print_char_cursor#84 ] main:2::test_8s:11::print_sbyte:149::print_char:172 [ print_line_cursor#1 test_8s::i#10 test_8s::res#0 rem8s#3 print_sbyte::b#10 print_char_cursor#84 ] main:2::test_8s:11::print_sbyte:153::print_char:172 [ print_line_cursor#1 test_8s::i#10 rem8s#3 print_sbyte::b#10 print_char_cursor#84 ] main:2::test_8s:11::print_sbyte:157::print_char:172 [ print_line_cursor#1 test_8s::i#10 print_sbyte::b#10 print_char_cursor#84 ] ) always clobbers reg byte y 
Statement [66] (byte) print_byte::b#1 ← > (word) print_word::w#5 [ print_word::w#5 print_char_cursor#138 print_byte::b#1 ] ( main:2::test_16s:13::print_sword:27::print_word:56 [ test_16s::i#10 test_16s::divisor#0 test_16s::res#0 print_line_cursor#1 rem16s#11 print_word::w#5 print_char_cursor#138 print_byte::b#1 ] main:2::test_16s:13::print_sword:31::print_word:56 [ test_16s::i#10 test_16s::res#0 print_line_cursor#1 rem16s#11 print_word::w#5 print_char_cursor#138 print_byte::b#1 ] main:2::test_16s:13::print_sword:35::print_word:56 [ test_16s::i#10 print_line_cursor#1 rem16s#11 print_word::w#5 print_char_cursor#138 print_byte::b#1 ] main:2::test_16s:13::print_sword:39::print_word:56 [ test_16s::i#10 print_line_cursor#1 print_word::w#5 print_char_cursor#138 print_byte::b#1 ] main:2::test_16u:9::print_word:234 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::divisor#0 test_16u::res#0 print_word::w#5 print_char_cursor#138 print_byte::b#1 ] main:2::test_16u:9::print_word:238 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::res#0 print_word::w#5 print_char_cursor#138 print_byte::b#1 ] main:2::test_16u:9::print_word:242 [ print_line_cursor#1 rem16u#1 test_16u::i#10 print_word::w#5 print_char_cursor#138 print_byte::b#1 ] main:2::test_16u:9::print_word:246 [ print_line_cursor#1 test_16u::i#10 print_word::w#5 print_char_cursor#138 print_byte::b#1 ] ) always clobbers reg byte a 
Statement [68] (byte) print_byte::b#2 ← < (word) print_word::w#5 [ print_char_cursor#19 print_byte::b#2 ] ( main:2::test_16s:13::print_sword:27::print_word:56 [ test_16s::i#10 test_16s::divisor#0 test_16s::res#0 print_line_cursor#1 rem16s#11 print_char_cursor#19 print_byte::b#2 ] main:2::test_16s:13::print_sword:31::print_word:56 [ test_16s::i#10 test_16s::res#0 print_line_cursor#1 rem16s#11 print_char_cursor#19 print_byte::b#2 ] main:2::test_16s:13::print_sword:35::print_word:56 [ test_16s::i#10 print_line_cursor#1 rem16s#11 print_char_cursor#19 print_byte::b#2 ] main:2::test_16s:13::print_sword:39::print_word:56 [ test_16s::i#10 print_line_cursor#1 print_char_cursor#19 print_byte::b#2 ] main:2::test_16u:9::print_word:234 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::divisor#0 test_16u::res#0 print_char_cursor#19 print_byte::b#2 ] main:2::test_16u:9::print_word:238 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::res#0 print_char_cursor#19 print_byte::b#2 ] main:2::test_16u:9::print_word:242 [ print_line_cursor#1 rem16u#1 test_16u::i#10 print_char_cursor#19 print_byte::b#2 ] main:2::test_16u:9::print_word:246 [ print_line_cursor#1 test_16u::i#10 print_char_cursor#19 print_byte::b#2 ] ) always clobbers reg byte a 
Statement [72] (byte~) print_byte::$0 ← (byte) print_byte::b#7 >> (byte) 4 [ print_char_cursor#139 print_byte::b#7 print_byte::$0 ] ( main:2::test_16s:13::print_sword:27::print_word:56::print_byte:67 [ test_16s::i#10 test_16s::divisor#0 test_16s::res#0 print_line_cursor#1 rem16s#11 print_word::w#5 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_16s:13::print_sword:31::print_word:56::print_byte:67 [ test_16s::i#10 test_16s::res#0 print_line_cursor#1 rem16s#11 print_word::w#5 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_16s:13::print_sword:35::print_word:56::print_byte:67 [ test_16s::i#10 print_line_cursor#1 rem16s#11 print_word::w#5 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_16s:13::print_sword:39::print_word:56::print_byte:67 [ test_16s::i#10 print_line_cursor#1 print_word::w#5 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_16u:9::print_word:234::print_byte:67 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::divisor#0 test_16u::res#0 print_word::w#5 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_16u:9::print_word:238::print_byte:67 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::res#0 print_word::w#5 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_16u:9::print_word:242::print_byte:67 [ print_line_cursor#1 rem16u#1 test_16u::i#10 print_word::w#5 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_16u:9::print_word:246::print_byte:67 [ print_line_cursor#1 test_16u::i#10 print_word::w#5 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_16s:13::print_sword:27::print_word:56::print_byte:69 [ test_16s::i#10 test_16s::divisor#0 test_16s::res#0 print_line_cursor#1 rem16s#11 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_16s:13::print_sword:31::print_word:56::print_byte:69 [ test_16s::i#10 test_16s::res#0 print_line_cursor#1 rem16s#11 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_16s:13::print_sword:35::print_word:56::print_byte:69 [ test_16s::i#10 print_line_cursor#1 rem16s#11 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_16s:13::print_sword:39::print_word:56::print_byte:69 [ test_16s::i#10 print_line_cursor#1 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_16u:9::print_word:234::print_byte:69 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::divisor#0 test_16u::res#0 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_16u:9::print_word:238::print_byte:69 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::res#0 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_16u:9::print_word:242::print_byte:69 [ print_line_cursor#1 rem16u#1 test_16u::i#10 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_16u:9::print_word:246::print_byte:69 [ print_line_cursor#1 test_16u::i#10 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_8s:11::print_sbyte:145::print_byte:169 [ print_line_cursor#1 test_8s::i#10 test_8s::divisor#0 test_8s::res#0 rem8s#3 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_8s:11::print_sbyte:149::print_byte:169 [ print_line_cursor#1 test_8s::i#10 test_8s::res#0 rem8s#3 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_8s:11::print_sbyte:153::print_byte:169 [ print_line_cursor#1 test_8s::i#10 rem8s#3 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_8s:11::print_sbyte:157::print_byte:169 [ print_line_cursor#1 test_8s::i#10 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_8u:7::print_byte:268 [ print_line_cursor#41 rem8u#17 test_8u::i#10 test_8u::divisor#0 test_8u::res#0 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_8u:7::print_byte:272 [ print_line_cursor#41 rem8u#17 test_8u::i#10 test_8u::res#0 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_8u:7::print_byte:276 [ print_line_cursor#41 rem8u#17 test_8u::i#10 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] main:2::test_8u:7::print_byte:280 [ print_line_cursor#41 test_8u::i#10 print_char_cursor#139 print_byte::b#7 print_byte::$0 ] ) always clobbers reg byte a 
Statement [75] (byte~) print_byte::$2 ← (byte) print_byte::b#7 & (byte) $f [ print_char_cursor#19 print_byte::$2 ] ( main:2::test_16s:13::print_sword:27::print_word:56::print_byte:67 [ test_16s::i#10 test_16s::divisor#0 test_16s::res#0 print_line_cursor#1 rem16s#11 print_word::w#5 print_char_cursor#19 print_byte::$2 ] main:2::test_16s:13::print_sword:31::print_word:56::print_byte:67 [ test_16s::i#10 test_16s::res#0 print_line_cursor#1 rem16s#11 print_word::w#5 print_char_cursor#19 print_byte::$2 ] main:2::test_16s:13::print_sword:35::print_word:56::print_byte:67 [ test_16s::i#10 print_line_cursor#1 rem16s#11 print_word::w#5 print_char_cursor#19 print_byte::$2 ] main:2::test_16s:13::print_sword:39::print_word:56::print_byte:67 [ test_16s::i#10 print_line_cursor#1 print_word::w#5 print_char_cursor#19 print_byte::$2 ] main:2::test_16u:9::print_word:234::print_byte:67 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::divisor#0 test_16u::res#0 print_word::w#5 print_char_cursor#19 print_byte::$2 ] main:2::test_16u:9::print_word:238::print_byte:67 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::res#0 print_word::w#5 print_char_cursor#19 print_byte::$2 ] main:2::test_16u:9::print_word:242::print_byte:67 [ print_line_cursor#1 rem16u#1 test_16u::i#10 print_word::w#5 print_char_cursor#19 print_byte::$2 ] main:2::test_16u:9::print_word:246::print_byte:67 [ print_line_cursor#1 test_16u::i#10 print_word::w#5 print_char_cursor#19 print_byte::$2 ] main:2::test_16s:13::print_sword:27::print_word:56::print_byte:69 [ test_16s::i#10 test_16s::divisor#0 test_16s::res#0 print_line_cursor#1 rem16s#11 print_char_cursor#19 print_byte::$2 ] main:2::test_16s:13::print_sword:31::print_word:56::print_byte:69 [ test_16s::i#10 test_16s::res#0 print_line_cursor#1 rem16s#11 print_char_cursor#19 print_byte::$2 ] main:2::test_16s:13::print_sword:35::print_word:56::print_byte:69 [ test_16s::i#10 print_line_cursor#1 rem16s#11 print_char_cursor#19 print_byte::$2 ] main:2::test_16s:13::print_sword:39::print_word:56::print_byte:69 [ test_16s::i#10 print_line_cursor#1 print_char_cursor#19 print_byte::$2 ] main:2::test_16u:9::print_word:234::print_byte:69 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::divisor#0 test_16u::res#0 print_char_cursor#19 print_byte::$2 ] main:2::test_16u:9::print_word:238::print_byte:69 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::res#0 print_char_cursor#19 print_byte::$2 ] main:2::test_16u:9::print_word:242::print_byte:69 [ print_line_cursor#1 rem16u#1 test_16u::i#10 print_char_cursor#19 print_byte::$2 ] main:2::test_16u:9::print_word:246::print_byte:69 [ print_line_cursor#1 test_16u::i#10 print_char_cursor#19 print_byte::$2 ] main:2::test_8s:11::print_sbyte:145::print_byte:169 [ print_line_cursor#1 test_8s::i#10 test_8s::divisor#0 test_8s::res#0 rem8s#3 print_char_cursor#19 print_byte::$2 ] main:2::test_8s:11::print_sbyte:149::print_byte:169 [ print_line_cursor#1 test_8s::i#10 test_8s::res#0 rem8s#3 print_char_cursor#19 print_byte::$2 ] main:2::test_8s:11::print_sbyte:153::print_byte:169 [ print_line_cursor#1 test_8s::i#10 rem8s#3 print_char_cursor#19 print_byte::$2 ] main:2::test_8s:11::print_sbyte:157::print_byte:169 [ print_line_cursor#1 test_8s::i#10 print_char_cursor#19 print_byte::$2 ] main:2::test_8u:7::print_byte:268 [ print_line_cursor#41 rem8u#17 test_8u::i#10 test_8u::divisor#0 test_8u::res#0 print_char_cursor#19 print_byte::$2 ] main:2::test_8u:7::print_byte:272 [ print_line_cursor#41 rem8u#17 test_8u::i#10 test_8u::res#0 print_char_cursor#19 print_byte::$2 ] main:2::test_8u:7::print_byte:276 [ print_line_cursor#41 rem8u#17 test_8u::i#10 print_char_cursor#19 print_byte::$2 ] main:2::test_8u:7::print_byte:280 [ print_line_cursor#41 test_8u::i#10 print_char_cursor#19 print_byte::$2 ] ) always clobbers reg byte a 
Statement [81] if((byte) 0!=*((byte*) print_str::str#13)) goto print_str::@2 [ print_char_cursor#130 print_str::str#13 ] ( main:2::test_16s:13::print_str:29 [ test_16s::i#10 test_16s::divisor#0 test_16s::res#0 print_line_cursor#1 rem16s#11 print_char_cursor#130 print_str::str#13 ] main:2::test_16s:13::print_str:33 [ test_16s::i#10 test_16s::res#0 print_line_cursor#1 rem16s#11 print_char_cursor#130 print_str::str#13 ] main:2::test_16s:13::print_str:37 [ test_16s::i#10 print_line_cursor#1 rem16s#11 print_char_cursor#130 print_str::str#13 ] main:2::test_8s:11::print_str:147 [ print_line_cursor#1 test_8s::i#10 test_8s::divisor#0 test_8s::res#0 rem8s#3 print_char_cursor#130 print_str::str#13 ] main:2::test_8s:11::print_str:151 [ print_line_cursor#1 test_8s::i#10 test_8s::res#0 rem8s#3 print_char_cursor#130 print_str::str#13 ] main:2::test_8s:11::print_str:155 [ print_line_cursor#1 test_8s::i#10 rem8s#3 print_char_cursor#130 print_str::str#13 ] main:2::test_16u:9::print_str:236 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::divisor#0 test_16u::res#0 print_char_cursor#130 print_str::str#13 ] main:2::test_16u:9::print_str:240 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::res#0 print_char_cursor#130 print_str::str#13 ] main:2::test_16u:9::print_str:244 [ print_line_cursor#1 rem16u#1 test_16u::i#10 print_char_cursor#130 print_str::str#13 ] main:2::test_8u:7::print_str:270 [ print_line_cursor#41 rem8u#17 test_8u::i#10 test_8u::divisor#0 test_8u::res#0 print_char_cursor#130 print_str::str#13 ] main:2::test_8u:7::print_str:274 [ print_line_cursor#41 rem8u#17 test_8u::i#10 test_8u::res#0 print_char_cursor#130 print_str::str#13 ] main:2::test_8u:7::print_str:278 [ print_line_cursor#41 rem8u#17 test_8u::i#10 print_char_cursor#130 print_str::str#13 ] ) always clobbers reg byte a reg byte y 
Statement [83] *((byte*) print_char_cursor#130) ← *((byte*) print_str::str#13) [ print_char_cursor#130 print_str::str#13 ] ( main:2::test_16s:13::print_str:29 [ test_16s::i#10 test_16s::divisor#0 test_16s::res#0 print_line_cursor#1 rem16s#11 print_char_cursor#130 print_str::str#13 ] main:2::test_16s:13::print_str:33 [ test_16s::i#10 test_16s::res#0 print_line_cursor#1 rem16s#11 print_char_cursor#130 print_str::str#13 ] main:2::test_16s:13::print_str:37 [ test_16s::i#10 print_line_cursor#1 rem16s#11 print_char_cursor#130 print_str::str#13 ] main:2::test_8s:11::print_str:147 [ print_line_cursor#1 test_8s::i#10 test_8s::divisor#0 test_8s::res#0 rem8s#3 print_char_cursor#130 print_str::str#13 ] main:2::test_8s:11::print_str:151 [ print_line_cursor#1 test_8s::i#10 test_8s::res#0 rem8s#3 print_char_cursor#130 print_str::str#13 ] main:2::test_8s:11::print_str:155 [ print_line_cursor#1 test_8s::i#10 rem8s#3 print_char_cursor#130 print_str::str#13 ] main:2::test_16u:9::print_str:236 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::divisor#0 test_16u::res#0 print_char_cursor#130 print_str::str#13 ] main:2::test_16u:9::print_str:240 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::res#0 print_char_cursor#130 print_str::str#13 ] main:2::test_16u:9::print_str:244 [ print_line_cursor#1 rem16u#1 test_16u::i#10 print_char_cursor#130 print_str::str#13 ] main:2::test_8u:7::print_str:270 [ print_line_cursor#41 rem8u#17 test_8u::i#10 test_8u::divisor#0 test_8u::res#0 print_char_cursor#130 print_str::str#13 ] main:2::test_8u:7::print_str:274 [ print_line_cursor#41 rem8u#17 test_8u::i#10 test_8u::res#0 print_char_cursor#130 print_str::str#13 ] main:2::test_8u:7::print_str:278 [ print_line_cursor#41 rem8u#17 test_8u::i#10 print_char_cursor#130 print_str::str#13 ] ) always clobbers reg byte a reg byte y 
Statement [86] (signed word) divr16s::dividend#0 ← (signed word) div16s::dividend#0 [ div16s::divisor#0 divr16s::dividend#0 ] ( main:2::test_16s:13::div16s:22 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 div16s::divisor#0 divr16s::dividend#0 ] ) always clobbers reg byte a 
Statement [87] (signed word) divr16s::divisor#0 ← (signed word) div16s::divisor#0 [ divr16s::dividend#0 divr16s::divisor#0 ] ( main:2::test_16s:13::div16s:22 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 divr16s::dividend#0 divr16s::divisor#0 ] ) always clobbers reg byte a 
Statement [89] (signed word) divr16s::return#3 ← (signed word) divr16s::return#2 [ rem16s#11 divr16s::return#3 ] ( main:2::test_16s:13::div16s:22 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 rem16s#11 divr16s::return#3 ] ) always clobbers reg byte a 
Statement [90] (signed word) div16s::return#0 ← (signed word) divr16s::return#3 [ div16s::return#0 rem16s#11 ] ( main:2::test_16s:13::div16s:22 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 div16s::return#0 rem16s#11 ] ) always clobbers reg byte a 
Statement [92] if((signed word) divr16s::dividend#0<(signed byte) 0) goto divr16s::@1 [ divr16s::dividend#0 divr16s::divisor#0 ] ( main:2::test_16s:13::div16s:22::divr16s:88 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 divr16s::dividend#0 divr16s::divisor#0 ] ) always clobbers reg byte a 
Statement [93] (word) divr16s::dividendu#8 ← (word)(signed word) divr16s::dividend#0 [ divr16s::divisor#0 divr16s::dividendu#8 ] ( main:2::test_16s:13::div16s:22::divr16s:88 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 divr16s::divisor#0 divr16s::dividendu#8 ] ) always clobbers reg byte a 
Statement [95] if((signed word) divr16s::divisor#0<(signed byte) 0) goto divr16s::@3 [ divr16s::divisor#0 divr16s::neg#3 divr16s::dividendu#3 ] ( main:2::test_16s:13::div16s:22::divr16s:88 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 divr16s::divisor#0 divr16s::neg#3 divr16s::dividendu#3 ] ) always clobbers reg byte a 
Statement [96] (word) divr16s::divisoru#5 ← (word)(signed word) divr16s::divisor#0 [ divr16s::neg#3 divr16s::dividendu#3 divr16s::divisoru#5 ] ( main:2::test_16s:13::div16s:22::divr16s:88 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 divr16s::neg#3 divr16s::dividendu#3 divr16s::divisoru#5 ] ) always clobbers reg byte a 
Statement [98] (word) divr16u::dividend#2 ← (word) divr16s::dividendu#3 [ divr16s::divisoru#3 divr16s::neg#4 divr16u::dividend#2 ] ( main:2::test_16s:13::div16s:22::divr16s:88 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 divr16s::divisoru#3 divr16s::neg#4 divr16u::dividend#2 ] ) always clobbers reg byte a 
Statement [99] (word) divr16u::divisor#1 ← (word) divr16s::divisoru#3 [ divr16s::neg#4 divr16u::dividend#2 divr16u::divisor#1 ] ( main:2::test_16s:13::div16s:22::divr16s:88 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 divr16s::neg#4 divr16u::dividend#2 divr16u::divisor#1 ] ) always clobbers reg byte a 
Statement [101] (word) divr16u::return#3 ← (word) divr16u::return#0 [ divr16s::neg#4 divr16u::return#3 rem16u#1 ] ( main:2::test_16s:13::div16s:22::divr16s:88 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 divr16s::neg#4 divr16u::return#3 rem16u#1 ] ) always clobbers reg byte a 
Statement [102] (word) divr16s::resultu#0 ← (word) divr16u::return#3 [ divr16s::neg#4 divr16s::resultu#0 rem16u#1 ] ( main:2::test_16s:13::div16s:22::divr16s:88 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 divr16s::neg#4 divr16s::resultu#0 rem16u#1 ] ) always clobbers reg byte a 
Statement [104] (signed word~) divr16s::$16 ← (signed word)(word) rem16u#1 [ divr16s::resultu#0 divr16s::$16 ] ( main:2::test_16s:13::div16s:22::divr16s:88 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 divr16s::resultu#0 divr16s::$16 ] ) always clobbers reg byte a 
Statement [105] (signed word) rem16s#2 ← - (signed word~) divr16s::$16 [ divr16s::resultu#0 rem16s#2 ] ( main:2::test_16s:13::div16s:22::divr16s:88 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 divr16s::resultu#0 rem16s#2 ] ) always clobbers reg byte a 
Statement [106] (signed word) divr16s::return#1 ← - (signed word)(word) divr16s::resultu#0 [ rem16s#2 divr16s::return#1 ] ( main:2::test_16s:13::div16s:22::divr16s:88 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 rem16s#2 divr16s::return#1 ] ) always clobbers reg byte a 
Statement [109] (signed word) divr16s::return#7 ← (signed word)(word) divr16s::resultu#0 [ rem16u#1 divr16s::return#7 ] ( main:2::test_16s:13::div16s:22::divr16s:88 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 rem16u#1 divr16s::return#7 ] ) always clobbers reg byte a 
Statement [110] (signed word) rem16s#37 ← (signed word)(word) rem16u#1 [ divr16s::return#7 rem16s#37 ] ( main:2::test_16s:13::div16s:22::divr16s:88 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 divr16s::return#7 rem16s#37 ] ) always clobbers reg byte a 
Statement [111] (signed word) divr16s::divisoru#1 ← - (signed word) divr16s::divisor#0 [ divr16s::neg#3 divr16s::dividendu#3 divr16s::divisoru#1 ] ( main:2::test_16s:13::div16s:22::divr16s:88 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 divr16s::neg#3 divr16s::dividendu#3 divr16s::divisoru#1 ] ) always clobbers reg byte a 
Statement [112] (byte) divr16s::neg#2 ← (byte) divr16s::neg#3 ^ (byte) 1 [ divr16s::dividendu#3 divr16s::neg#2 divr16s::divisoru#1 ] ( main:2::test_16s:13::div16s:22::divr16s:88 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 divr16s::dividendu#3 divr16s::neg#2 divr16s::divisoru#1 ] ) always clobbers reg byte a 
Statement [113] (word) divr16s::divisoru#4 ← (word)(signed word) divr16s::divisoru#1 [ divr16s::dividendu#3 divr16s::divisoru#4 divr16s::neg#2 ] ( main:2::test_16s:13::div16s:22::divr16s:88 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 divr16s::dividendu#3 divr16s::divisoru#4 divr16s::neg#2 ] ) always clobbers reg byte a 
Statement [114] (signed word) divr16s::dividendu#1 ← - (signed word) divr16s::dividend#0 [ divr16s::divisor#0 divr16s::dividendu#1 ] ( main:2::test_16s:13::div16s:22::divr16s:88 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 divr16s::divisor#0 divr16s::dividendu#1 ] ) always clobbers reg byte a 
Statement [115] (word) divr16s::dividendu#7 ← (word)(signed word) divr16s::dividendu#1 [ divr16s::divisor#0 divr16s::dividendu#7 ] ( main:2::test_16s:13::div16s:22::divr16s:88 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 divr16s::divisor#0 divr16s::dividendu#7 ] ) always clobbers reg byte a 
Statement [119] (byte~) divr16u::$1 ← > (word) divr16u::dividend#3 [ divr16u::divisor#6 divr16u::dividend#3 divr16u::quotient#3 divr16u::i#2 divr16u::rem#0 divr16u::$1 ] ( main:2::test_16s:13::div16s:22::divr16s:88::divr16u:100 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 divr16s::neg#4 divr16u::divisor#6 divr16u::dividend#3 divr16u::quotient#3 divr16u::i#2 divr16u::rem#0 divr16u::$1 ] main:2::test_16u:9::div16u:229::divr16u:254 [ print_line_cursor#1 test_16u::i#10 test_16u::dividend#0 test_16u::divisor#0 divr16u::divisor#6 divr16u::dividend#3 divr16u::quotient#3 divr16u::i#2 divr16u::rem#0 divr16u::$1 ] ) always clobbers reg byte a 
Statement [122] (word) divr16u::rem#1 ← (word) divr16u::rem#0 | (byte) 1 [ divr16u::divisor#6 divr16u::dividend#3 divr16u::quotient#3 divr16u::i#2 divr16u::rem#1 ] ( main:2::test_16s:13::div16s:22::divr16s:88::divr16u:100 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 divr16s::neg#4 divr16u::divisor#6 divr16u::dividend#3 divr16u::quotient#3 divr16u::i#2 divr16u::rem#1 ] main:2::test_16u:9::div16u:229::divr16u:254 [ print_line_cursor#1 test_16u::i#10 test_16u::dividend#0 test_16u::divisor#0 divr16u::divisor#6 divr16u::dividend#3 divr16u::quotient#3 divr16u::i#2 divr16u::rem#1 ] ) always clobbers reg byte a 
Statement [126] if((word) divr16u::rem#6<(word) divr16u::divisor#6) goto divr16u::@3 [ divr16u::divisor#6 divr16u::i#2 divr16u::dividend#0 divr16u::rem#6 divr16u::quotient#1 ] ( main:2::test_16s:13::div16s:22::divr16s:88::divr16u:100 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 divr16s::neg#4 divr16u::divisor#6 divr16u::i#2 divr16u::dividend#0 divr16u::rem#6 divr16u::quotient#1 ] main:2::test_16u:9::div16u:229::divr16u:254 [ print_line_cursor#1 test_16u::i#10 test_16u::dividend#0 test_16u::divisor#0 divr16u::divisor#6 divr16u::i#2 divr16u::dividend#0 divr16u::rem#6 divr16u::quotient#1 ] ) always clobbers reg byte a 
Statement [128] (word) divr16u::rem#2 ← (word) divr16u::rem#6 - (word) divr16u::divisor#6 [ divr16u::divisor#6 divr16u::i#2 divr16u::dividend#0 divr16u::quotient#2 divr16u::rem#2 ] ( main:2::test_16s:13::div16s:22::divr16s:88::divr16u:100 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 divr16s::neg#4 divr16u::divisor#6 divr16u::i#2 divr16u::dividend#0 divr16u::quotient#2 divr16u::rem#2 ] main:2::test_16u:9::div16u:229::divr16u:254 [ print_line_cursor#1 test_16u::i#10 test_16u::dividend#0 test_16u::divisor#0 divr16u::divisor#6 divr16u::i#2 divr16u::dividend#0 divr16u::quotient#2 divr16u::rem#2 ] ) always clobbers reg byte a 
Statement [132] (word) rem16u#1 ← (word) divr16u::rem#11 [ divr16u::return#0 rem16u#1 ] ( main:2::test_16s:13::div16s:22::divr16s:88::divr16u:100 [ test_16s::i#10 test_16s::dividend#0 test_16s::divisor#0 print_line_cursor#1 divr16s::neg#4 divr16u::return#0 rem16u#1 ] main:2::test_16u:9::div16u:229::divr16u:254 [ print_line_cursor#1 test_16u::i#10 test_16u::dividend#0 test_16u::divisor#0 divr16u::return#0 rem16u#1 ] ) always clobbers reg byte a 
Statement [144] (byte*) print_char_cursor#167 ← (byte*) print_line_cursor#1 [ print_line_cursor#1 test_8s::i#10 test_8s::divisor#0 test_8s::res#0 print_sbyte::b#1 print_char_cursor#167 rem8s#3 ] ( main:2::test_8s:11 [ print_line_cursor#1 test_8s::i#10 test_8s::divisor#0 test_8s::res#0 print_sbyte::b#1 print_char_cursor#167 rem8s#3 ] ) always clobbers reg byte a 
Statement [173] (signed byte) print_sbyte::b#0 ← - (signed byte) print_sbyte::b#10 [ print_char_cursor#19 print_sbyte::b#0 ] ( main:2::test_8s:11::print_sbyte:145 [ print_line_cursor#1 test_8s::i#10 test_8s::divisor#0 test_8s::res#0 rem8s#3 print_char_cursor#19 print_sbyte::b#0 ] main:2::test_8s:11::print_sbyte:149 [ print_line_cursor#1 test_8s::i#10 test_8s::res#0 rem8s#3 print_char_cursor#19 print_sbyte::b#0 ] main:2::test_8s:11::print_sbyte:153 [ print_line_cursor#1 test_8s::i#10 rem8s#3 print_char_cursor#19 print_sbyte::b#0 ] main:2::test_8s:11::print_sbyte:157 [ print_line_cursor#1 test_8s::i#10 print_char_cursor#19 print_sbyte::b#0 ] ) always clobbers reg byte a 
Statement [187] (signed byte) rem8s#2 ← - (signed byte~) div8s::$11 [ div8s::resultu#0 rem8s#2 ] ( main:2::test_8s:11::div8s:140 [ print_line_cursor#1 test_8s::i#10 test_8s::dividend#0 test_8s::divisor#0 div8s::resultu#0 rem8s#2 ] ) always clobbers reg byte a 
Statement [188] (signed byte) div8s::return#1 ← - (signed byte)(byte) div8s::resultu#0 [ rem8s#2 div8s::return#1 ] ( main:2::test_8s:11::div8s:140 [ print_line_cursor#1 test_8s::i#10 test_8s::dividend#0 test_8s::divisor#0 rem8s#2 div8s::return#1 ] ) always clobbers reg byte a 
Statement [193] (signed byte) div8s::divisoru#1 ← - (signed byte) div8s::divisor#0 [ div8s::neg#3 div8s::dividendu#3 div8s::divisoru#1 ] ( main:2::test_8s:11::div8s:140 [ print_line_cursor#1 test_8s::i#10 test_8s::dividend#0 test_8s::divisor#0 div8s::neg#3 div8s::dividendu#3 div8s::divisoru#1 ] ) always clobbers reg byte a 
Statement [194] (byte) div8s::neg#2 ← (byte) div8s::neg#3 ^ (byte) 1 [ div8s::dividendu#3 div8s::neg#2 div8s::divisoru#1 ] ( main:2::test_8s:11::div8s:140 [ print_line_cursor#1 test_8s::i#10 test_8s::dividend#0 test_8s::divisor#0 div8s::dividendu#3 div8s::neg#2 div8s::divisoru#1 ] ) always clobbers reg byte a 
Statement [196] (signed byte) div8s::dividendu#1 ← - (signed byte) div8s::dividend#0 [ div8s::divisor#0 div8s::dividendu#1 ] ( main:2::test_8s:11::div8s:140 [ print_line_cursor#1 test_8s::i#10 test_8s::dividend#0 test_8s::divisor#0 div8s::divisor#0 div8s::dividendu#1 ] ) always clobbers reg byte a 
Statement [208] (byte~) divr8u::$1 ← (byte) divr8u::dividend#2 & (byte) $80 [ divr8u::divisor#0 divr8u::dividend#2 divr8u::quotient#3 divr8u::i#2 divr8u::rem#1 divr8u::$1 ] ( main:2::test_8s:11::div8s:140::div8u:182::divr8u:201 [ print_line_cursor#1 test_8s::i#10 test_8s::dividend#0 test_8s::divisor#0 div8s::neg#4 divr8u::divisor#0 divr8u::dividend#2 divr8u::quotient#3 divr8u::i#2 divr8u::rem#1 divr8u::$1 ] main:2::test_8u:7::div8u:264::divr8u:201 [ print_line_cursor#41 print_char_cursor#141 test_8u::i#10 test_8u::dividend#0 test_8u::divisor#0 divr8u::divisor#0 divr8u::dividend#2 divr8u::quotient#3 divr8u::i#2 divr8u::rem#1 divr8u::$1 ] ) always clobbers reg byte a 
Statement [210] (byte) divr8u::rem#2 ← (byte) divr8u::rem#1 | (byte) 1 [ divr8u::divisor#0 divr8u::dividend#2 divr8u::quotient#3 divr8u::i#2 divr8u::rem#2 ] ( main:2::test_8s:11::div8s:140::div8u:182::divr8u:201 [ print_line_cursor#1 test_8s::i#10 test_8s::dividend#0 test_8s::divisor#0 div8s::neg#4 divr8u::divisor#0 divr8u::dividend#2 divr8u::quotient#3 divr8u::i#2 divr8u::rem#2 ] main:2::test_8u:7::div8u:264::divr8u:201 [ print_line_cursor#41 print_char_cursor#141 test_8u::i#10 test_8u::dividend#0 test_8u::divisor#0 divr8u::divisor#0 divr8u::dividend#2 divr8u::quotient#3 divr8u::i#2 divr8u::rem#2 ] ) always clobbers reg byte a 
Statement [216] (byte) divr8u::rem#3 ← (byte) divr8u::rem#5 - (byte) divr8u::divisor#0 [ divr8u::divisor#0 divr8u::i#2 divr8u::dividend#1 divr8u::quotient#2 divr8u::rem#3 ] ( main:2::test_8s:11::div8s:140::div8u:182::divr8u:201 [ print_line_cursor#1 test_8s::i#10 test_8s::dividend#0 test_8s::divisor#0 div8s::neg#4 divr8u::divisor#0 divr8u::i#2 divr8u::dividend#1 divr8u::quotient#2 divr8u::rem#3 ] main:2::test_8u:7::div8u:264::divr8u:201 [ print_line_cursor#41 print_char_cursor#141 test_8u::i#10 test_8u::dividend#0 test_8u::divisor#0 divr8u::divisor#0 divr8u::i#2 divr8u::dividend#1 divr8u::quotient#2 divr8u::rem#3 ] ) always clobbers reg byte a 
Statement [224] (byte~) test_16u::$11 ← (byte) test_16u::i#10 << (byte) 1 [ print_line_cursor#1 test_16u::i#10 test_16u::$11 ] ( main:2::test_16u:9 [ print_line_cursor#1 test_16u::i#10 test_16u::$11 ] ) always clobbers reg byte a 
Statement [225] (word) test_16u::dividend#0 ← *((const word*) test_16u::dividends + (byte~) test_16u::$11) [ print_line_cursor#1 test_16u::i#10 test_16u::$11 test_16u::dividend#0 ] ( main:2::test_16u:9 [ print_line_cursor#1 test_16u::i#10 test_16u::$11 test_16u::dividend#0 ] ) always clobbers reg byte a 
Statement [226] (word) test_16u::divisor#0 ← *((const word*) test_16u::divisors + (byte~) test_16u::$11) [ print_line_cursor#1 test_16u::i#10 test_16u::dividend#0 test_16u::divisor#0 ] ( main:2::test_16u:9 [ print_line_cursor#1 test_16u::i#10 test_16u::dividend#0 test_16u::divisor#0 ] ) always clobbers reg byte a 
Statement [227] (word) div16u::dividend#0 ← (word) test_16u::dividend#0 [ print_line_cursor#1 test_16u::i#10 test_16u::dividend#0 test_16u::divisor#0 div16u::dividend#0 ] ( main:2::test_16u:9 [ print_line_cursor#1 test_16u::i#10 test_16u::dividend#0 test_16u::divisor#0 div16u::dividend#0 ] ) always clobbers reg byte a 
Statement [228] (word) div16u::divisor#0 ← (word) test_16u::divisor#0 [ print_line_cursor#1 test_16u::i#10 test_16u::dividend#0 test_16u::divisor#0 div16u::dividend#0 div16u::divisor#0 ] ( main:2::test_16u:9 [ print_line_cursor#1 test_16u::i#10 test_16u::dividend#0 test_16u::divisor#0 div16u::dividend#0 div16u::divisor#0 ] ) always clobbers reg byte a 
Statement [230] (word) div16u::return#2 ← (word) div16u::return#0 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::dividend#0 test_16u::divisor#0 div16u::return#2 ] ( main:2::test_16u:9 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::dividend#0 test_16u::divisor#0 div16u::return#2 ] ) always clobbers reg byte a 
Statement [231] (word) test_16u::res#0 ← (word) div16u::return#2 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::dividend#0 test_16u::divisor#0 test_16u::res#0 ] ( main:2::test_16u:9 [ print_line_cursor#1 rem16u#1 test_16u::i#10 test_16u::dividend#0 test_16u::divisor#0 test_16u::res#0 ] ) always clobbers reg byte a 
Statement [232] (word) print_word::w#1 ← (word) test_16u::dividend#0 [ print_line_cursor#1 print_word::w#1 rem16u#1 test_16u::i#10 test_16u::divisor#0 test_16u::res#0 ] ( main:2::test_16u:9 [ print_line_cursor#1 print_word::w#1 rem16u#1 test_16u::i#10 test_16u::divisor#0 test_16u::res#0 ] ) always clobbers reg byte a 
Statement [233] (byte*) print_char_cursor#172 ← (byte*) print_line_cursor#1 [ print_line_cursor#1 print_word::w#1 print_char_cursor#172 rem16u#1 test_16u::i#10 test_16u::divisor#0 test_16u::res#0 ] ( main:2::test_16u:9 [ print_line_cursor#1 print_word::w#1 print_char_cursor#172 rem16u#1 test_16u::i#10 test_16u::divisor#0 test_16u::res#0 ] ) always clobbers reg byte a 
Statement [237] (word) print_word::w#2 ← (word) test_16u::divisor#0 [ print_line_cursor#1 print_char_cursor#130 print_word::w#2 rem16u#1 test_16u::i#10 test_16u::res#0 ] ( main:2::test_16u:9 [ print_line_cursor#1 print_char_cursor#130 print_word::w#2 rem16u#1 test_16u::i#10 test_16u::res#0 ] ) always clobbers reg byte a 
Statement [241] (word) print_word::w#3 ← (word) test_16u::res#0 [ print_line_cursor#1 print_char_cursor#130 print_word::w#3 rem16u#1 test_16u::i#10 ] ( main:2::test_16u:9 [ print_line_cursor#1 print_char_cursor#130 print_word::w#3 rem16u#1 test_16u::i#10 ] ) always clobbers reg byte a 
Statement [245] (word) print_word::w#4 ← (word) rem16u#1 [ print_line_cursor#1 print_char_cursor#130 print_word::w#4 test_16u::i#10 ] ( main:2::test_16u:9 [ print_line_cursor#1 print_char_cursor#130 print_word::w#4 test_16u::i#10 ] ) always clobbers reg byte a 
Statement [252] (word) divr16u::dividend#1 ← (word) div16u::dividend#0 [ divr16u::dividend#1 div16u::divisor#0 ] ( main:2::test_16u:9::div16u:229 [ print_line_cursor#1 test_16u::i#10 test_16u::dividend#0 test_16u::divisor#0 divr16u::dividend#1 div16u::divisor#0 ] ) always clobbers reg byte a 
Statement [253] (word) divr16u::divisor#0 ← (word) div16u::divisor#0 [ divr16u::dividend#1 divr16u::divisor#0 ] ( main:2::test_16u:9::div16u:229 [ print_line_cursor#1 test_16u::i#10 test_16u::dividend#0 test_16u::divisor#0 divr16u::dividend#1 divr16u::divisor#0 ] ) always clobbers reg byte a 
Statement [255] (word) divr16u::return#2 ← (word) divr16u::return#0 [ rem16u#1 divr16u::return#2 ] ( main:2::test_16u:9::div16u:229 [ print_line_cursor#1 test_16u::i#10 test_16u::dividend#0 test_16u::divisor#0 rem16u#1 divr16u::return#2 ] ) always clobbers reg byte a 
Statement [256] (word) div16u::return#0 ← (word) divr16u::return#2 [ rem16u#1 div16u::return#0 ] ( main:2::test_16u:9::div16u:229 [ print_line_cursor#1 test_16u::i#10 test_16u::dividend#0 test_16u::divisor#0 rem16u#1 div16u::return#0 ] ) always clobbers reg byte a 
Statement [286] (byte*) print_char_cursor#189 ← (byte*) print_line_cursor#1 [ print_line_cursor#1 test_8u::i#1 print_char_cursor#189 ] ( main:2::test_8u:7 [ print_line_cursor#1 test_8u::i#1 print_char_cursor#189 ] ) always clobbers reg byte a 
Statement [292] if((byte*) memset::dst#2!=(const byte*) memset::end#0) goto memset::@2 [ memset::dst#2 ] ( main:2::print_cls:5::memset:288 [ memset::dst#2 ] ) always clobbers reg byte a 
Statement [294] *((byte*) memset::dst#2) ← (const byte) memset::c#0 [ memset::dst#2 ] ( main:2::print_cls:5::memset:288 [ memset::dst#2 ] ) always clobbers reg byte a reg byte y 
Potential registers zp[1]:2 [ test_16s::i#10 test_16s::i#1 ] : zp[1]:2 , reg byte x , 
Potential registers zp[2]:3 [ print_line_cursor#20 print_line_cursor#39 print_line_cursor#1 print_line_cursor#41 ] : zp[2]:3 , 
Potential registers zp[2]:5 [ print_sword::w#7 print_sword::w#0 print_sword::w#10 print_sword::w#1 print_sword::w#2 print_sword::w#3 print_sword::w#4 ] : zp[2]:5 , 
Potential registers zp[1]:7 [ print_char::ch#6 print_char::ch#4 print_char::ch#5 ] : zp[1]:7 , reg byte a , reg byte x , reg byte y , 
Potential registers zp[2]:8 [ print_word::w#5 print_word::w#0 print_word::w#1 print_word::w#2 print_word::w#3 print_word::w#4 ] : zp[2]:8 , 
Potential registers zp[2]:10 [ print_char_cursor#138 print_char_cursor#84 print_char_cursor#139 print_char_cursor#19 print_char_cursor#135 print_char_cursor#132 print_char_cursor#163 print_char_cursor#130 print_char_cursor#172 print_char_cursor#141 print_char_cursor#1 print_char_cursor#167 print_char_cursor#189 ] : zp[2]:10 , 
Potential registers zp[1]:12 [ print_byte::b#7 print_byte::b#0 print_byte::b#1 print_byte::b#2 print_byte::b#3 print_byte::b#4 print_byte::b#5 print_byte::b#6 ] : zp[1]:12 , reg byte x , 
Potential registers zp[2]:13 [ print_str::str#13 print_str::str#15 print_str::str#0 ] : zp[2]:13 , 
Potential registers zp[2]:15 [ divr16s::dividendu#3 divr16s::dividendu#7 divr16s::dividendu#8 ] : zp[2]:15 , 
Potential registers zp[2]:17 [ divr16s::divisoru#3 divr16s::divisoru#4 divr16s::divisoru#5 ] : zp[2]:17 , 
Potential registers zp[1]:19 [ divr16s::neg#4 divr16s::neg#2 divr16s::neg#3 ] : zp[1]:19 , reg byte x , reg byte y , 
Potential registers zp[2]:20 [ divr16s::return#2 divr16s::return#1 divr16s::return#7 ] : zp[2]:20 , 
Potential registers zp[2]:22 [ rem16s#11 rem16s#2 rem16s#37 ] : zp[2]:22 , 
Potential registers zp[2]:24 [ divr16u::divisor#6 divr16u::divisor#0 divr16u::divisor#1 ] : zp[2]:24 , 
Potential registers zp[2]:26 [ divr16u::rem#5 divr16u::rem#11 divr16u::rem#6 divr16u::rem#0 divr16u::rem#1 divr16u::rem#2 ] : zp[2]:26 , 
Potential registers zp[2]:28 [ divr16u::dividend#3 divr16u::dividend#5 divr16u::dividend#1 divr16u::dividend#2 divr16u::dividend#0 ] : zp[2]:28 , 
Potential registers zp[2]:30 [ divr16u::quotient#3 divr16u::return#0 divr16u::quotient#1 divr16u::quotient#2 ] : zp[2]:30 , 
Potential registers zp[1]:32 [ divr16u::i#2 divr16u::i#1 ] : zp[1]:32 , reg byte x , reg byte y , 
Potential registers zp[1]:33 [ test_8s::i#10 test_8s::i#1 ] : zp[1]:33 , reg byte x , 
Potential registers zp[1]:34 [ print_sbyte::b#7 print_sbyte::b#0 print_sbyte::b#10 print_sbyte::b#1 print_sbyte::b#2 print_sbyte::b#3 print_sbyte::b#4 ] : zp[1]:34 , reg byte x , 
Potential registers zp[1]:35 [ div8s::dividendu#3 div8s::dividendu#7 div8s::dividendu#8 ] : zp[1]:35 , reg byte x , reg byte y , 
Potential registers zp[1]:36 [ div8s::divisoru#3 div8s::divisoru#4 div8s::divisoru#5 ] : zp[1]:36 , reg byte a , reg byte x , reg byte y , 
Potential registers zp[1]:37 [ div8s::neg#4 div8s::neg#2 div8s::neg#3 ] : zp[1]:37 , reg byte x , reg byte y , 
Potential registers zp[1]:38 [ div8s::return#2 div8s::return#1 div8s::return#7 ] : zp[1]:38 , reg byte a , reg byte x , reg byte y , 
Potential registers zp[1]:39 [ rem8s#3 rem8s#2 rem8s#33 ] : zp[1]:39 , reg byte x , 
Potential registers zp[1]:40 [ div8u::dividend#2 div8u::dividend#0 div8u::dividend#1 ] : zp[1]:40 , reg byte a , reg byte x , reg byte y , 
Potential registers zp[1]:41 [ div8u::divisor#2 div8u::divisor#0 div8u::divisor#1 ] : zp[1]:41 , reg byte a , reg byte x , reg byte y , 
Potential registers zp[1]:42 [ divr8u::rem#4 divr8u::rem#10 divr8u::rem#5 divr8u::rem#1 divr8u::rem#2 divr8u::rem#3 ] : zp[1]:42 , reg byte x , reg byte y , 
Potential registers zp[1]:43 [ divr8u::dividend#2 divr8u::dividend#0 divr8u::dividend#1 ] : zp[1]:43 , reg byte x , reg byte y , 
Potential registers zp[1]:44 [ divr8u::quotient#3 divr8u::return#1 divr8u::quotient#1 divr8u::quotient#2 ] : zp[1]:44 , reg byte x , reg byte y , 
Potential registers zp[1]:45 [ divr8u::i#2 divr8u::i#1 ] : zp[1]:45 , reg byte x , reg byte y , 
Potential registers zp[1]:46 [ test_16u::i#10 test_16u::i#1 ] : zp[1]:46 , reg byte x , 
Potential registers zp[1]:47 [ test_8u::i#10 test_8u::i#1 ] : zp[1]:47 , reg byte x , 
Potential registers zp[2]:48 [ memset::dst#2 memset::dst#1 ] : zp[2]:48 , 
Potential registers zp[1]:50 [ test_16s::$11 ] : zp[1]:50 , reg byte x , reg byte y , 
Potential registers zp[2]:51 [ test_16s::dividend#0 ] : zp[2]:51 , 
Potential registers zp[2]:53 [ test_16s::divisor#0 ] : zp[2]:53 , 
Potential registers zp[2]:55 [ div16s::dividend#0 ] : zp[2]:55 , 
Potential registers zp[2]:57 [ div16s::divisor#0 ] : zp[2]:57 , 
Potential registers zp[2]:59 [ div16s::return#2 ] : zp[2]:59 , 
Potential registers zp[2]:61 [ test_16s::res#0 ] : zp[2]:61 , 
Potential registers zp[1]:63 [ print_byte::$0 ] : zp[1]:63 , reg byte a , reg byte x , reg byte y , 
Potential registers zp[1]:64 [ print_byte::$2 ] : zp[1]:64 , reg byte a , reg byte x , reg byte y , 
Potential registers zp[2]:65 [ divr16s::dividend#0 ] : zp[2]:65 , 
Potential registers zp[2]:67 [ divr16s::divisor#0 ] : zp[2]:67 , 
Potential registers zp[2]:69 [ divr16s::return#3 ] : zp[2]:69 , 
Potential registers zp[2]:71 [ div16s::return#0 ] : zp[2]:71 , 
Potential registers zp[2]:73 [ divr16u::return#3 ] : zp[2]:73 , 
Potential registers zp[2]:75 [ divr16s::resultu#0 ] : zp[2]:75 , 
Potential registers zp[2]:77 [ divr16s::$16 ] : zp[2]:77 , 
Potential registers zp[2]:79 [ divr16s::divisoru#1 ] : zp[2]:79 , 
Potential registers zp[2]:81 [ divr16s::dividendu#1 ] : zp[2]:81 , 
Potential registers zp[1]:83 [ divr16u::$1 ] : zp[1]:83 , reg byte a , reg byte x , reg byte y , 
Potential registers zp[1]:84 [ divr16u::$2 ] : zp[1]:84 , reg byte a , reg byte x , reg byte y , 
Potential registers zp[2]:85 [ rem16u#1 ] : zp[2]:85 , 
Potential registers zp[1]:87 [ test_8s::dividend#0 ] : zp[1]:87 , reg byte x , reg byte y , 
Potential registers zp[1]:88 [ test_8s::divisor#0 ] : zp[1]:88 , reg byte x , 
Potential registers zp[1]:89 [ div8s::dividend#0 ] : zp[1]:89 , reg byte a , reg byte x , reg byte y , 
Potential registers zp[1]:90 [ div8s::divisor#0 ] : zp[1]:90 , reg byte x , reg byte y , 
Potential registers zp[1]:91 [ div8s::return#3 ] : zp[1]:91 , reg byte a , reg byte x , reg byte y , 
Potential registers zp[1]:92 [ test_8s::res#0 ] : zp[1]:92 , reg byte x , 
Potential registers zp[1]:93 [ div8u::return#2 ] : zp[1]:93 , reg byte a , reg byte x , reg byte y , 
Potential registers zp[1]:94 [ div8s::resultu#0 ] : zp[1]:94 , reg byte x , reg byte y , 
Potential registers zp[1]:95 [ div8s::$11 ] : zp[1]:95 , reg byte a , reg byte x , reg byte y , 
Potential registers zp[1]:96 [ div8s::divisoru#1 ] : zp[1]:96 , reg byte x , reg byte y , 
Potential registers zp[1]:97 [ div8s::dividendu#1 ] : zp[1]:97 , reg byte a , reg byte x , reg byte y , 
Potential registers zp[1]:98 [ divr8u::divisor#0 ] : zp[1]:98 , reg byte x , reg byte y , 
Potential registers zp[1]:99 [ divr8u::return#0 ] : zp[1]:99 , reg byte a , reg byte x , reg byte y , 
Potential registers zp[1]:100 [ div8u::return#0 ] : zp[1]:100 , reg byte a , reg byte x , reg byte y , 
Potential registers zp[1]:101 [ divr8u::$1 ] : zp[1]:101 , reg byte a , reg byte x , reg byte y , 
Potential registers zp[1]:102 [ rem8u#17 ] : zp[1]:102 , reg byte x , 
Potential registers zp[1]:103 [ test_16u::$11 ] : zp[1]:103 , reg byte x , reg byte y , 
Potential registers zp[2]:104 [ test_16u::dividend#0 ] : zp[2]:104 , 
Potential registers zp[2]:106 [ test_16u::divisor#0 ] : zp[2]:106 , 
Potential registers zp[2]:108 [ div16u::dividend#0 ] : zp[2]:108 , 
Potential registers zp[2]:110 [ div16u::divisor#0 ] : zp[2]:110 , 
Potential registers zp[2]:112 [ div16u::return#2 ] : zp[2]:112 , 
Potential registers zp[2]:114 [ test_16u::res#0 ] : zp[2]:114 , 
Potential registers zp[2]:116 [ divr16u::return#2 ] : zp[2]:116 , 
Potential registers zp[2]:118 [ div16u::return#0 ] : zp[2]:118 , 
Potential registers zp[1]:120 [ test_8u::dividend#0 ] : zp[1]:120 , reg byte x , reg byte y , 
Potential registers zp[1]:121 [ test_8u::divisor#0 ] : zp[1]:121 , reg byte x , 
Potential registers zp[1]:122 [ div8u::return#3 ] : zp[1]:122 , reg byte a , reg byte x , reg byte y , 
Potential registers zp[1]:123 [ test_8u::res#0 ] : zp[1]:123 , reg byte x , 

REGISTER UPLIFT SCOPES
Uplift Scope [divr16u] 884.42: zp[2]:26 [ divr16u::rem#5 divr16u::rem#11 divr16u::rem#6 divr16u::rem#0 divr16u::rem#1 divr16u::rem#2 ] 321.61: zp[2]:30 [ divr16u::quotient#3 divr16u::return#0 divr16u::quotient#1 divr16u::quotient#2 ] 202: zp[1]:83 [ divr16u::$1 ] 202: zp[1]:84 [ divr16u::$2 ] 167.04: zp[1]:32 [ divr16u::i#2 divr16u::i#1 ] 78.82: zp[2]:28 [ divr16u::dividend#3 divr16u::dividend#5 divr16u::dividend#1 divr16u::dividend#2 divr16u::dividend#0 ] 20.88: zp[2]:24 [ divr16u::divisor#6 divr16u::divisor#0 divr16u::divisor#1 ] 4: zp[2]:73 [ divr16u::return#3 ] 4: zp[2]:116 [ divr16u::return#2 ] 
Uplift Scope [divr8u] 909.67: zp[1]:42 [ divr8u::rem#4 divr8u::rem#10 divr8u::rem#5 divr8u::rem#1 divr8u::rem#2 divr8u::rem#3 ] 332.19: zp[1]:44 [ divr8u::quotient#3 divr8u::return#1 divr8u::quotient#1 divr8u::quotient#2 ] 202: zp[1]:101 [ divr8u::$1 ] 168.33: zp[1]:45 [ divr8u::i#2 divr8u::i#1 ] 77.42: zp[1]:43 [ divr8u::dividend#2 divr8u::dividend#0 divr8u::dividend#1 ] 12.75: zp[1]:98 [ divr8u::divisor#0 ] 4: zp[1]:99 [ divr8u::return#0 ] 
Uplift Scope [] 282.21: zp[2]:10 [ print_char_cursor#138 print_char_cursor#84 print_char_cursor#139 print_char_cursor#19 print_char_cursor#135 print_char_cursor#132 print_char_cursor#163 print_char_cursor#130 print_char_cursor#172 print_char_cursor#141 print_char_cursor#1 print_char_cursor#167 print_char_cursor#189 ] 254.79: zp[2]:3 [ print_line_cursor#20 print_line_cursor#39 print_line_cursor#1 print_line_cursor#41 ] 6.83: zp[1]:39 [ rem8s#3 rem8s#2 rem8s#33 ] 6.68: zp[2]:22 [ rem16s#11 rem16s#2 rem16s#37 ] 0.5: zp[1]:102 [ rem8u#17 ] 0.48: zp[2]:85 [ rem16u#1 ] 
Uplift Scope [print_str] 305.5: zp[2]:13 [ print_str::str#13 print_str::str#15 print_str::str#0 ] 
Uplift Scope [print_byte] 113.5: zp[1]:12 [ print_byte::b#7 print_byte::b#0 print_byte::b#1 print_byte::b#2 print_byte::b#3 print_byte::b#4 print_byte::b#5 print_byte::b#6 ] 4: zp[1]:63 [ print_byte::$0 ] 4: zp[1]:64 [ print_byte::$2 ] 
Uplift Scope [print_word] 97.67: zp[2]:8 [ print_word::w#5 print_word::w#0 print_word::w#1 print_word::w#2 print_word::w#3 print_word::w#4 ] 
Uplift Scope [print_sword] 93.33: zp[2]:5 [ print_sword::w#7 print_sword::w#0 print_sword::w#10 print_sword::w#1 print_sword::w#2 print_sword::w#3 print_sword::w#4 ] 
Uplift Scope [print_sbyte] 93.33: zp[1]:34 [ print_sbyte::b#7 print_sbyte::b#0 print_sbyte::b#10 print_sbyte::b#1 print_sbyte::b#2 print_sbyte::b#3 print_sbyte::b#4 ] 
Uplift Scope [div8u] 33.5: zp[1]:41 [ div8u::divisor#2 div8u::divisor#0 div8u::divisor#1 ] 28: zp[1]:40 [ div8u::dividend#2 div8u::dividend#0 div8u::dividend#1 ] 22: zp[1]:122 [ div8u::return#3 ] 4: zp[1]:93 [ div8u::return#2 ] 3.75: zp[1]:100 [ div8u::return#0 ] 
Uplift Scope [div8s] 22: zp[1]:91 [ div8s::return#3 ] 11: zp[1]:36 [ div8s::divisoru#3 div8s::divisoru#4 div8s::divisoru#5 ] 11: zp[1]:38 [ div8s::return#2 div8s::return#1 div8s::return#7 ] 8.86: zp[1]:35 [ div8s::dividendu#3 div8s::dividendu#7 div8s::dividendu#8 ] 5: zp[1]:89 [ div8s::dividend#0 ] 4: zp[1]:37 [ div8s::neg#4 div8s::neg#2 div8s::neg#3 ] 4: zp[1]:95 [ div8s::$11 ] 2.14: zp[1]:90 [ div8s::divisor#0 ] 2: zp[1]:97 [ div8s::dividendu#1 ] 1: zp[1]:96 [ div8s::divisoru#1 ] 0.5: zp[1]:94 [ div8s::resultu#0 ] 
Uplift Scope [divr16s] 11: zp[2]:17 [ divr16s::divisoru#3 divr16s::divisoru#4 divr16s::divisoru#5 ] 8.86: zp[2]:15 [ divr16s::dividendu#3 divr16s::dividendu#7 divr16s::dividendu#8 ] 8: zp[2]:20 [ divr16s::return#2 divr16s::return#1 divr16s::return#7 ] 4: zp[1]:19 [ divr16s::neg#4 divr16s::neg#2 divr16s::neg#3 ] 4: zp[2]:69 [ divr16s::return#3 ] 4: zp[2]:77 [ divr16s::$16 ] 2: zp[2]:65 [ divr16s::dividend#0 ] 2: zp[2]:81 [ divr16s::dividendu#1 ] 1: zp[2]:79 [ divr16s::divisoru#1 ] 0.86: zp[2]:67 [ divr16s::divisor#0 ] 0.5: zp[2]:75 [ divr16s::resultu#0 ] 
Uplift Scope [test_16u] 17.77: zp[1]:46 [ test_16u::i#10 test_16u::i#1 ] 16.5: zp[1]:103 [ test_16u::$11 ] 4.71: zp[2]:104 [ test_16u::dividend#0 ] 3: zp[2]:106 [ test_16u::divisor#0 ] 2.2: zp[2]:114 [ test_16u::res#0 ] 
Uplift Scope [test_16s] 17.77: zp[1]:2 [ test_16s::i#10 test_16s::i#1 ] 16.5: zp[1]:50 [ test_16s::$11 ] 4.71: zp[2]:51 [ test_16s::dividend#0 ] 3: zp[2]:53 [ test_16s::divisor#0 ] 2.2: zp[2]:61 [ test_16s::res#0 ] 
Uplift Scope [div16u] 22: zp[2]:112 [ div16u::return#2 ] 6.5: zp[2]:108 [ div16u::dividend#0 ] 6.5: zp[2]:110 [ div16u::divisor#0 ] 4.33: zp[2]:118 [ div16u::return#0 ] 
Uplift Scope [div16s] 22: zp[2]:59 [ div16s::return#2 ] 6.5: zp[2]:55 [ div16s::dividend#0 ] 6.5: zp[2]:57 [ div16s::divisor#0 ] 4.33: zp[2]:71 [ div16s::return#0 ] 
Uplift Scope [memset] 36.67: zp[2]:48 [ memset::dst#2 memset::dst#1 ] 
Uplift Scope [test_8s] 18.26: zp[1]:33 [ test_8s::i#10 test_8s::i#1 ] 4.71: zp[1]:87 [ test_8s::dividend#0 ] 3: zp[1]:88 [ test_8s::divisor#0 ] 2.2: zp[1]:92 [ test_8s::res#0 ] 
Uplift Scope [test_8u] 12.83: zp[1]:47 [ test_8u::i#10 test_8u::i#1 ] 4.71: zp[1]:120 [ test_8u::dividend#0 ] 3.3: zp[1]:121 [ test_8u::divisor#0 ] 2.44: zp[1]:123 [ test_8u::res#0 ] 
Uplift Scope [print_char] 14: zp[1]:7 [ print_char::ch#6 print_char::ch#4 print_char::ch#5 ] 
Uplift Scope [RADIX] 
Uplift Scope [print_ln] 
Uplift Scope [print_cls] 
Uplift Scope [main] 

Uplifting [divr16u] best 45229 combination zp[2]:26 [ divr16u::rem#5 divr16u::rem#11 divr16u::rem#6 divr16u::rem#0 divr16u::rem#1 divr16u::rem#2 ] zp[2]:30 [ divr16u::quotient#3 divr16u::return#0 divr16u::quotient#1 divr16u::quotient#2 ] reg byte a [ divr16u::$1 ] reg byte a [ divr16u::$2 ] reg byte x [ divr16u::i#2 divr16u::i#1 ] zp[2]:28 [ divr16u::dividend#3 divr16u::dividend#5 divr16u::dividend#1 divr16u::dividend#2 divr16u::dividend#0 ] zp[2]:24 [ divr16u::divisor#6 divr16u::divisor#0 divr16u::divisor#1 ] zp[2]:73 [ divr16u::return#3 ] zp[2]:116 [ divr16u::return#2 ] 
Uplifting [divr8u] best 42826 combination reg byte y [ divr8u::rem#4 divr8u::rem#10 divr8u::rem#5 divr8u::rem#1 divr8u::rem#2 divr8u::rem#3 ] zp[1]:44 [ divr8u::quotient#3 divr8u::return#1 divr8u::quotient#1 divr8u::quotient#2 ] reg byte a [ divr8u::$1 ] reg byte x [ divr8u::i#2 divr8u::i#1 ] zp[1]:43 [ divr8u::dividend#2 divr8u::dividend#0 divr8u::dividend#1 ] zp[1]:98 [ divr8u::divisor#0 ] zp[1]:99 [ divr8u::return#0 ] 
Limited combination testing to 100 combinations of 3888 possible.
Uplifting [] best 42757 combination zp[2]:10 [ print_char_cursor#138 print_char_cursor#84 print_char_cursor#139 print_char_cursor#19 print_char_cursor#135 print_char_cursor#132 print_char_cursor#163 print_char_cursor#130 print_char_cursor#172 print_char_cursor#141 print_char_cursor#1 print_char_cursor#167 print_char_cursor#189 ] zp[2]:3 [ print_line_cursor#20 print_line_cursor#39 print_line_cursor#1 print_line_cursor#41 ] reg byte x [ rem8s#3 rem8s#2 rem8s#33 ] zp[2]:22 [ rem16s#11 rem16s#2 rem16s#37 ] reg byte x [ rem8u#17 ] zp[2]:85 [ rem16u#1 ] 
Uplifting [print_str] best 42757 combination zp[2]:13 [ print_str::str#13 print_str::str#15 print_str::str#0 ] 
Uplifting [print_byte] best 42749 combination zp[1]:12 [ print_byte::b#7 print_byte::b#0 print_byte::b#1 print_byte::b#2 print_byte::b#3 print_byte::b#4 print_byte::b#5 print_byte::b#6 ] reg byte a [ print_byte::$0 ] reg byte a [ print_byte::$2 ] 
Uplifting [print_word] best 42749 combination zp[2]:8 [ print_word::w#5 print_word::w#0 print_word::w#1 print_word::w#2 print_word::w#3 print_word::w#4 ] 
Uplifting [print_sword] best 42749 combination zp[2]:5 [ print_sword::w#7 print_sword::w#0 print_sword::w#10 print_sword::w#1 print_sword::w#2 print_sword::w#3 print_sword::w#4 ] 
Uplifting [print_sbyte] best 42749 combination zp[1]:34 [ print_sbyte::b#7 print_sbyte::b#0 print_sbyte::b#10 print_sbyte::b#1 print_sbyte::b#2 print_sbyte::b#3 print_sbyte::b#4 ] 
Uplifting [div8u] best 42611 combination reg byte x [ div8u::divisor#2 div8u::divisor#0 div8u::divisor#1 ] reg byte a [ div8u::dividend#2 div8u::dividend#0 div8u::dividend#1 ] reg byte a [ div8u::return#3 ] reg byte a [ div8u::return#2 ] zp[1]:100 [ div8u::return#0 ] 
Limited combination testing to 100 combinations of 1024 possible.
Uplifting [div8s] best 42506 combination reg byte a [ div8s::return#3 ] reg byte x [ div8s::divisoru#3 div8s::divisoru#4 div8s::divisoru#5 ] reg byte a [ div8s::return#2 div8s::return#1 div8s::return#7 ] zp[1]:35 [ div8s::dividendu#3 div8s::dividendu#7 div8s::dividendu#8 ] zp[1]:89 [ div8s::dividend#0 ] zp[1]:37 [ div8s::neg#4 div8s::neg#2 div8s::neg#3 ] zp[1]:95 [ div8s::$11 ] zp[1]:90 [ div8s::divisor#0 ] zp[1]:97 [ div8s::dividendu#1 ] zp[1]:96 [ div8s::divisoru#1 ] zp[1]:94 [ div8s::resultu#0 ] 
Limited combination testing to 100 combinations of 995328 possible.
Uplifting [divr16s] best 42495 combination zp[2]:17 [ divr16s::divisoru#3 divr16s::divisoru#4 divr16s::divisoru#5 ] zp[2]:15 [ divr16s::dividendu#3 divr16s::dividendu#7 divr16s::dividendu#8 ] zp[2]:20 [ divr16s::return#2 divr16s::return#1 divr16s::return#7 ] reg byte y [ divr16s::neg#4 divr16s::neg#2 divr16s::neg#3 ] zp[2]:69 [ divr16s::return#3 ] zp[2]:77 [ divr16s::$16 ] zp[2]:65 [ divr16s::dividend#0 ] zp[2]:81 [ divr16s::dividendu#1 ] zp[2]:79 [ divr16s::divisoru#1 ] zp[2]:67 [ divr16s::divisor#0 ] zp[2]:75 [ divr16s::resultu#0 ] 
Uplifting [test_16u] best 42425 combination zp[1]:46 [ test_16u::i#10 test_16u::i#1 ] reg byte x [ test_16u::$11 ] zp[2]:104 [ test_16u::dividend#0 ] zp[2]:106 [ test_16u::divisor#0 ] zp[2]:114 [ test_16u::res#0 ] 
Uplifting [test_16s] best 42355 combination zp[1]:2 [ test_16s::i#10 test_16s::i#1 ] reg byte x [ test_16s::$11 ] zp[2]:51 [ test_16s::dividend#0 ] zp[2]:53 [ test_16s::divisor#0 ] zp[2]:61 [ test_16s::res#0 ] 
Uplifting [div16u] best 42355 combination zp[2]:112 [ div16u::return#2 ] zp[2]:108 [ div16u::dividend#0 ] zp[2]:110 [ div16u::divisor#0 ] zp[2]:118 [ div16u::return#0 ] 
Uplifting [div16s] best 42355 combination zp[2]:59 [ div16s::return#2 ] zp[2]:55 [ div16s::dividend#0 ] zp[2]:57 [ div16s::divisor#0 ] zp[2]:71 [ div16s::return#0 ] 
Uplifting [memset] best 42355 combination zp[2]:48 [ memset::dst#2 memset::dst#1 ] 
Uplifting [test_8s] best 42355 combination zp[1]:33 [ test_8s::i#10 test_8s::i#1 ] zp[1]:87 [ test_8s::dividend#0 ] zp[1]:88 [ test_8s::divisor#0 ] zp[1]:92 [ test_8s::res#0 ] 
Uplifting [test_8u] best 42355 combination zp[1]:47 [ test_8u::i#10 test_8u::i#1 ] zp[1]:120 [ test_8u::dividend#0 ] zp[1]:121 [ test_8u::divisor#0 ] zp[1]:123 [ test_8u::res#0 ] 
Uplifting [print_char] best 42334 combination reg byte a [ print_char::ch#6 print_char::ch#4 print_char::ch#5 ] 
Uplifting [RADIX] best 42334 combination 
Uplifting [print_ln] best 42334 combination 
Uplifting [print_cls] best 42334 combination 
Uplifting [main] best 42334 combination 
Attempting to uplift remaining variables inzp[1]:44 [ divr8u::quotient#3 divr8u::return#1 divr8u::quotient#1 divr8u::quotient#2 ]
Uplifting [divr8u] best 42334 combination zp[1]:44 [ divr8u::quotient#3 divr8u::return#1 divr8u::quotient#1 divr8u::quotient#2 ] 
Attempting to uplift remaining variables inzp[1]:12 [ print_byte::b#7 print_byte::b#0 print_byte::b#1 print_byte::b#2 print_byte::b#3 print_byte::b#4 print_byte::b#5 print_byte::b#6 ]
Uplifting [print_byte] best 42334 combination zp[1]:12 [ print_byte::b#7 print_byte::b#0 print_byte::b#1 print_byte::b#2 print_byte::b#3 print_byte::b#4 print_byte::b#5 print_byte::b#6 ] 
Attempting to uplift remaining variables inzp[1]:34 [ print_sbyte::b#7 print_sbyte::b#0 print_sbyte::b#10 print_sbyte::b#1 print_sbyte::b#2 print_sbyte::b#3 print_sbyte::b#4 ]
Uplifting [print_sbyte] best 42334 combination zp[1]:34 [ print_sbyte::b#7 print_sbyte::b#0 print_sbyte::b#10 print_sbyte::b#1 print_sbyte::b#2 print_sbyte::b#3 print_sbyte::b#4 ] 
Attempting to uplift remaining variables inzp[1]:43 [ divr8u::dividend#2 divr8u::dividend#0 divr8u::dividend#1 ]
Uplifting [divr8u] best 42334 combination zp[1]:43 [ divr8u::dividend#2 divr8u::dividend#0 divr8u::dividend#1 ] 
Attempting to uplift remaining variables inzp[1]:33 [ test_8s::i#10 test_8s::i#1 ]
Uplifting [test_8s] best 42334 combination zp[1]:33 [ test_8s::i#10 test_8s::i#1 ] 
Attempting to uplift remaining variables inzp[1]:2 [ test_16s::i#10 test_16s::i#1 ]
Uplifting [test_16s] best 42334 combination zp[1]:2 [ test_16s::i#10 test_16s::i#1 ] 
Attempting to uplift remaining variables inzp[1]:46 [ test_16u::i#10 test_16u::i#1 ]
Uplifting [test_16u] best 42334 combination zp[1]:46 [ test_16u::i#10 test_16u::i#1 ] 
Attempting to uplift remaining variables inzp[1]:47 [ test_8u::i#10 test_8u::i#1 ]
Uplifting [test_8u] best 42334 combination zp[1]:47 [ test_8u::i#10 test_8u::i#1 ] 
Attempting to uplift remaining variables inzp[1]:98 [ divr8u::divisor#0 ]
Uplifting [divr8u] best 42334 combination zp[1]:98 [ divr8u::divisor#0 ] 
Attempting to uplift remaining variables inzp[1]:35 [ div8s::dividendu#3 div8s::dividendu#7 div8s::dividendu#8 ]
Uplifting [div8s] best 42327 combination reg byte y [ div8s::dividendu#3 div8s::dividendu#7 div8s::dividendu#8 ] 
Attempting to uplift remaining variables inzp[1]:89 [ div8s::dividend#0 ]
Uplifting [div8s] best 42292 combination reg byte y [ div8s::dividend#0 ] 
Attempting to uplift remaining variables inzp[1]:87 [ test_8s::dividend#0 ]
Uplifting [test_8s] best 42292 combination zp[1]:87 [ test_8s::dividend#0 ] 
Attempting to uplift remaining variables inzp[1]:120 [ test_8u::dividend#0 ]
Uplifting [test_8u] best 42292 combination zp[1]:120 [ test_8u::dividend#0 ] 
Attempting to uplift remaining variables inzp[1]:37 [ div8s::neg#4 div8s::neg#2 div8s::neg#3 ]
Uplifting [div8s] best 42292 combination zp[1]:37 [ div8s::neg#4 div8s::neg#2 div8s::neg#3 ] 
Attempting to uplift remaining variables inzp[1]:95 [ div8s::$11 ]
Uplifting [div8s] best 42288 combination reg byte a [ div8s::$11 ] 
Attempting to uplift remaining variables inzp[1]:99 [ divr8u::return#0 ]
Uplifting [divr8u] best 42282 combination reg byte a [ divr8u::return#0 ] 
Attempting to uplift remaining variables inzp[1]:100 [ div8u::return#0 ]
Uplifting [div8u] best 42246 combination reg byte a [ div8u::return#0 ] 
Attempting to uplift remaining variables inzp[1]:121 [ test_8u::divisor#0 ]
Uplifting [test_8u] best 42246 combination zp[1]:121 [ test_8u::divisor#0 ] 
Attempting to uplift remaining variables inzp[1]:88 [ test_8s::divisor#0 ]
Uplifting [test_8s] best 42246 combination zp[1]:88 [ test_8s::divisor#0 ] 
Attempting to uplift remaining variables inzp[1]:123 [ test_8u::res#0 ]
Uplifting [test_8u] best 42246 combination zp[1]:123 [ test_8u::res#0 ] 
Attempting to uplift remaining variables inzp[1]:92 [ test_8s::res#0 ]
Uplifting [test_8s] best 42246 combination zp[1]:92 [ test_8s::res#0 ] 
Attempting to uplift remaining variables inzp[1]:90 [ div8s::divisor#0 ]
Uplifting [div8s] best 42211 combination reg byte x [ div8s::divisor#0 ] 
Attempting to uplift remaining variables inzp[1]:97 [ div8s::dividendu#1 ]
Uplifting [div8s] best 42207 combination reg byte a [ div8s::dividendu#1 ] 
Attempting to uplift remaining variables inzp[1]:96 [ div8s::divisoru#1 ]
Uplifting [div8s] best 42203 combination reg byte x [ div8s::divisoru#1 ] 
Attempting to uplift remaining variables inzp[1]:94 [ div8s::resultu#0 ]
Uplifting [div8s] best 42200 combination reg byte y [ div8s::resultu#0 ] 
Coalescing zero page register [ zp[2]:20 [ divr16s::return#2 divr16s::return#1 divr16s::return#7 ] ] with [ zp[2]:75 [ divr16s::resultu#0 ] ] - score: 2
Coalescing zero page register [ zp[2]:5 [ print_sword::w#7 print_sword::w#0 print_sword::w#10 print_sword::w#1 print_sword::w#2 print_sword::w#3 print_sword::w#4 ] ] with [ zp[2]:8 [ print_word::w#5 print_word::w#0 print_word::w#1 print_word::w#2 print_word::w#3 print_word::w#4 ] ] - score: 1
Coalescing zero page register [ zp[2]:5 [ print_sword::w#7 print_sword::w#0 print_sword::w#10 print_sword::w#1 print_sword::w#2 print_sword::w#3 print_sword::w#4 print_word::w#5 print_word::w#0 print_word::w#1 print_word::w#2 print_word::w#3 print_word::w#4 ] ] with [ zp[2]:51 [ test_16s::dividend#0 ] ] - score: 1
Coalescing zero page register [ zp[1]:12 [ print_byte::b#7 print_byte::b#0 print_byte::b#1 print_byte::b#2 print_byte::b#3 print_byte::b#4 print_byte::b#5 print_byte::b#6 ] ] with [ zp[1]:34 [ print_sbyte::b#7 print_sbyte::b#0 print_sbyte::b#10 print_sbyte::b#1 print_sbyte::b#2 print_sbyte::b#3 print_sbyte::b#4 ] ] - score: 1
Coalescing zero page register [ zp[1]:12 [ print_byte::b#7 print_byte::b#0 print_byte::b#1 print_byte::b#2 print_byte::b#3 print_byte::b#4 print_byte::b#5 print_byte::b#6 print_sbyte::b#7 print_sbyte::b#0 print_sbyte::b#10 print_sbyte::b#1 print_sbyte::b#2 print_sbyte::b#3 print_sbyte::b#4 ] ] with [ zp[1]:120 [ test_8u::dividend#0 ] ] - score: 1
Coalescing zero page register [ zp[2]:15 [ divr16s::dividendu#3 divr16s::dividendu#7 divr16s::dividendu#8 ] ] with [ zp[2]:28 [ divr16u::dividend#3 divr16u::dividend#5 divr16u::dividend#1 divr16u::dividend#2 divr16u::dividend#0 ] ] - score: 1
Coalescing zero page register [ zp[2]:15 [ divr16s::dividendu#3 divr16s::dividendu#7 divr16s::dividendu#8 divr16u::dividend#3 divr16u::dividend#5 divr16u::dividend#1 divr16u::dividend#2 divr16u::dividend#0 ] ] with [ zp[2]:65 [ divr16s::dividend#0 ] ] - score: 1
Coalescing zero page register [ zp[2]:15 [ divr16s::dividendu#3 divr16s::dividendu#7 divr16s::dividendu#8 divr16u::dividend#3 divr16u::dividend#5 divr16u::dividend#1 divr16u::dividend#2 divr16u::dividend#0 divr16s::dividend#0 ] ] with [ zp[2]:81 [ divr16s::dividendu#1 ] ] - score: 1
Coalescing zero page register [ zp[2]:17 [ divr16s::divisoru#3 divr16s::divisoru#4 divr16s::divisoru#5 ] ] with [ zp[2]:24 [ divr16u::divisor#6 divr16u::divisor#0 divr16u::divisor#1 ] ] - score: 1
Coalescing zero page register [ zp[2]:17 [ divr16s::divisoru#3 divr16s::divisoru#4 divr16s::divisoru#5 divr16u::divisor#6 divr16u::divisor#0 divr16u::divisor#1 ] ] with [ zp[2]:67 [ divr16s::divisor#0 ] ] - score: 1
Coalescing zero page register [ zp[2]:17 [ divr16s::divisoru#3 divr16s::divisoru#4 divr16s::divisoru#5 divr16u::divisor#6 divr16u::divisor#0 divr16u::divisor#1 divr16s::divisor#0 ] ] with [ zp[2]:79 [ divr16s::divisoru#1 ] ] - score: 1
Coalescing zero page register [ zp[2]:20 [ divr16s::return#2 divr16s::return#1 divr16s::return#7 divr16s::resultu#0 ] ] with [ zp[2]:69 [ divr16s::return#3 ] ] - score: 1
Coalescing zero page register [ zp[2]:22 [ rem16s#11 rem16s#2 rem16s#37 ] ] with [ zp[2]:77 [ divr16s::$16 ] ] - score: 1
Coalescing zero page register [ zp[2]:22 [ rem16s#11 rem16s#2 rem16s#37 divr16s::$16 ] ] with [ zp[2]:85 [ rem16u#1 ] ] - score: 1
Coalescing zero page register [ zp[2]:30 [ divr16u::quotient#3 divr16u::return#0 divr16u::quotient#1 divr16u::quotient#2 ] ] with [ zp[2]:73 [ divr16u::return#3 ] ] - score: 1
Coalescing zero page register [ zp[2]:30 [ divr16u::quotient#3 divr16u::return#0 divr16u::quotient#1 divr16u::quotient#2 divr16u::return#3 ] ] with [ zp[2]:116 [ divr16u::return#2 ] ] - score: 1
Coalescing zero page register [ zp[2]:53 [ test_16s::divisor#0 ] ] with [ zp[2]:57 [ div16s::divisor#0 ] ] - score: 1
Coalescing zero page register [ zp[2]:59 [ div16s::return#2 ] ] with [ zp[2]:61 [ test_16s::res#0 ] ] - score: 1
Coalescing zero page register [ zp[2]:59 [ div16s::return#2 test_16s::res#0 ] ] with [ zp[2]:71 [ div16s::return#0 ] ] - score: 1
Coalescing zero page register [ zp[2]:104 [ test_16u::dividend#0 ] ] with [ zp[2]:108 [ div16u::dividend#0 ] ] - score: 1
Coalescing zero page register [ zp[2]:106 [ test_16u::divisor#0 ] ] with [ zp[2]:110 [ div16u::divisor#0 ] ] - score: 1
Coalescing zero page register [ zp[2]:112 [ div16u::return#2 ] ] with [ zp[2]:114 [ test_16u::res#0 ] ] - score: 1
Coalescing zero page register [ zp[2]:112 [ div16u::return#2 test_16u::res#0 ] ] with [ zp[2]:118 [ div16u::return#0 ] ] - score: 1
Coalescing zero page register [ zp[2]:5 [ print_sword::w#7 print_sword::w#0 print_sword::w#10 print_sword::w#1 print_sword::w#2 print_sword::w#3 print_sword::w#4 print_word::w#5 print_word::w#0 print_word::w#1 print_word::w#2 print_word::w#3 print_word::w#4 test_16s::dividend#0 ] ] with [ zp[2]:55 [ div16s::dividend#0 ] ] - score: 1
Coalescing zero page register [ zp[2]:5 [ print_sword::w#7 print_sword::w#0 print_sword::w#10 print_sword::w#1 print_sword::w#2 print_sword::w#3 print_sword::w#4 print_word::w#5 print_word::w#0 print_word::w#1 print_word::w#2 print_word::w#3 print_word::w#4 test_16s::dividend#0 div16s::dividend#0 ] ] with [ zp[2]:104 [ test_16u::dividend#0 div16u::dividend#0 ] ] - score: 1
Coalescing zero page register [ zp[1]:12 [ print_byte::b#7 print_byte::b#0 print_byte::b#1 print_byte::b#2 print_byte::b#3 print_byte::b#4 print_byte::b#5 print_byte::b#6 print_sbyte::b#7 print_sbyte::b#0 print_sbyte::b#10 print_sbyte::b#1 print_sbyte::b#2 print_sbyte::b#3 print_sbyte::b#4 test_8u::dividend#0 ] ] with [ zp[1]:87 [ test_8s::dividend#0 ] ] - score: 1
Coalescing zero page register [ zp[2]:17 [ divr16s::divisoru#3 divr16s::divisoru#4 divr16s::divisoru#5 divr16u::divisor#6 divr16u::divisor#0 divr16u::divisor#1 divr16s::divisor#0 divr16s::divisoru#1 ] ] with [ zp[2]:106 [ test_16u::divisor#0 div16u::divisor#0 ] ] - score: 1
Coalescing zero page register [ zp[2]:20 [ divr16s::return#2 divr16s::return#1 divr16s::return#7 divr16s::resultu#0 divr16s::return#3 ] ] with [ zp[2]:30 [ divr16u::quotient#3 divr16u::return#0 divr16u::quotient#1 divr16u::quotient#2 divr16u::return#3 divr16u::return#2 ] ] - score: 1
Coalescing zero page register [ zp[2]:20 [ divr16s::return#2 divr16s::return#1 divr16s::return#7 divr16s::resultu#0 divr16s::return#3 divr16u::quotient#3 divr16u::return#0 divr16u::quotient#1 divr16u::quotient#2 divr16u::return#3 divr16u::return#2 ] ] with [ zp[2]:59 [ div16s::return#2 test_16s::res#0 div16s::return#0 ] ] - score: 1
Coalescing zero page register [ zp[2]:22 [ rem16s#11 rem16s#2 rem16s#37 divr16s::$16 rem16u#1 ] ] with [ zp[2]:26 [ divr16u::rem#5 divr16u::rem#11 divr16u::rem#6 divr16u::rem#0 divr16u::rem#1 divr16u::rem#2 ] ] - score: 1
Coalescing zero page register [ zp[2]:20 [ divr16s::return#2 divr16s::return#1 divr16s::return#7 divr16s::resultu#0 divr16s::return#3 divr16u::quotient#3 divr16u::return#0 divr16u::quotient#1 divr16u::quotient#2 divr16u::return#3 divr16u::return#2 div16s::return#2 test_16s::res#0 div16s::return#0 ] ] with [ zp[2]:112 [ div16u::return#2 test_16u::res#0 div16u::return#0 ] ] - score: 1
Coalescing zero page register [ zp[2]:13 [ print_str::str#13 print_str::str#15 print_str::str#0 ] ] with [ zp[2]:5 [ print_sword::w#7 print_sword::w#0 print_sword::w#10 print_sword::w#1 print_sword::w#2 print_sword::w#3 print_sword::w#4 print_word::w#5 print_word::w#0 print_word::w#1 print_word::w#2 print_word::w#3 print_word::w#4 test_16s::dividend#0 div16s::dividend#0 test_16u::dividend#0 div16u::dividend#0 ] ]
Coalescing zero page register [ zp[2]:15 [ divr16s::dividendu#3 divr16s::dividendu#7 divr16s::dividendu#8 divr16u::dividend#3 divr16u::dividend#5 divr16u::dividend#1 divr16u::dividend#2 divr16u::dividend#0 divr16s::dividend#0 divr16s::dividendu#1 ] ] with [ zp[2]:10 [ print_char_cursor#138 print_char_cursor#84 print_char_cursor#139 print_char_cursor#19 print_char_cursor#135 print_char_cursor#132 print_char_cursor#163 print_char_cursor#130 print_char_cursor#172 print_char_cursor#141 print_char_cursor#1 print_char_cursor#167 print_char_cursor#189 ] ]
Coalescing zero page register [ zp[1]:33 [ test_8s::i#10 test_8s::i#1 ] ] with [ zp[1]:2 [ test_16s::i#10 test_16s::i#1 ] ]
Coalescing zero page register [ zp[1]:46 [ test_16u::i#10 test_16u::i#1 ] ] with [ zp[1]:37 [ div8s::neg#4 div8s::neg#2 div8s::neg#3 ] ]
Coalescing zero page register [ zp[2]:48 [ memset::dst#2 memset::dst#1 ] ] with [ zp[2]:3 [ print_line_cursor#20 print_line_cursor#39 print_line_cursor#1 print_line_cursor#41 ] ]
Coalescing zero page register [ zp[1]:88 [ test_8s::divisor#0 ] ] with [ zp[1]:47 [ test_8u::i#10 test_8u::i#1 ] ]
Coalescing zero page register [ zp[1]:92 [ test_8s::res#0 ] ] with [ zp[1]:43 [ divr8u::dividend#2 divr8u::dividend#0 divr8u::dividend#1 ] ]
Coalescing zero page register [ zp[1]:121 [ test_8u::divisor#0 ] ] with [ zp[1]:98 [ divr8u::divisor#0 ] ]
Coalescing zero page register [ zp[1]:123 [ test_8u::res#0 ] ] with [ zp[1]:44 [ divr8u::quotient#3 divr8u::return#1 divr8u::quotient#1 divr8u::quotient#2 ] ]
Allocated (was zp[1]:12) zp[1]:2 [ print_byte::b#7 print_byte::b#0 print_byte::b#1 print_byte::b#2 print_byte::b#3 print_byte::b#4 print_byte::b#5 print_byte::b#6 print_sbyte::b#7 print_sbyte::b#0 print_sbyte::b#10 print_sbyte::b#1 print_sbyte::b#2 print_sbyte::b#3 print_sbyte::b#4 test_8u::dividend#0 test_8s::dividend#0 ]
Allocated (was zp[2]:13) zp[2]:3 [ print_str::str#13 print_str::str#15 print_str::str#0 print_sword::w#7 print_sword::w#0 print_sword::w#10 print_sword::w#1 print_sword::w#2 print_sword::w#3 print_sword::w#4 print_word::w#5 print_word::w#0 print_word::w#1 print_word::w#2 print_word::w#3 print_word::w#4 test_16s::dividend#0 div16s::dividend#0 test_16u::dividend#0 div16u::dividend#0 ]
Allocated (was zp[2]:15) zp[2]:5 [ divr16s::dividendu#3 divr16s::dividendu#7 divr16s::dividendu#8 divr16u::dividend#3 divr16u::dividend#5 divr16u::dividend#1 divr16u::dividend#2 divr16u::dividend#0 divr16s::dividend#0 divr16s::dividendu#1 print_char_cursor#138 print_char_cursor#84 print_char_cursor#139 print_char_cursor#19 print_char_cursor#135 print_char_cursor#132 print_char_cursor#163 print_char_cursor#130 print_char_cursor#172 print_char_cursor#141 print_char_cursor#1 print_char_cursor#167 print_char_cursor#189 ]
Allocated (was zp[2]:17) zp[2]:7 [ divr16s::divisoru#3 divr16s::divisoru#4 divr16s::divisoru#5 divr16u::divisor#6 divr16u::divisor#0 divr16u::divisor#1 divr16s::divisor#0 divr16s::divisoru#1 test_16u::divisor#0 div16u::divisor#0 ]
Allocated (was zp[2]:20) zp[2]:9 [ divr16s::return#2 divr16s::return#1 divr16s::return#7 divr16s::resultu#0 divr16s::return#3 divr16u::quotient#3 divr16u::return#0 divr16u::quotient#1 divr16u::quotient#2 divr16u::return#3 divr16u::return#2 div16s::return#2 test_16s::res#0 div16s::return#0 div16u::return#2 test_16u::res#0 div16u::return#0 ]
Allocated (was zp[2]:22) zp[2]:11 [ rem16s#11 rem16s#2 rem16s#37 divr16s::$16 rem16u#1 divr16u::rem#5 divr16u::rem#11 divr16u::rem#6 divr16u::rem#0 divr16u::rem#1 divr16u::rem#2 ]
Allocated (was zp[1]:33) zp[1]:13 [ test_8s::i#10 test_8s::i#1 test_16s::i#10 test_16s::i#1 ]
Allocated (was zp[1]:46) zp[1]:14 [ test_16u::i#10 test_16u::i#1 div8s::neg#4 div8s::neg#2 div8s::neg#3 ]
Allocated (was zp[2]:48) zp[2]:15 [ memset::dst#2 memset::dst#1 print_line_cursor#20 print_line_cursor#39 print_line_cursor#1 print_line_cursor#41 ]
Allocated (was zp[2]:53) zp[2]:17 [ test_16s::divisor#0 div16s::divisor#0 ]
Allocated (was zp[1]:88) zp[1]:19 [ test_8s::divisor#0 test_8u::i#10 test_8u::i#1 ]
Allocated (was zp[1]:92) zp[1]:20 [ test_8s::res#0 divr8u::dividend#2 divr8u::dividend#0 divr8u::dividend#1 ]
Allocated (was zp[1]:121) zp[1]:21 [ test_8u::divisor#0 divr8u::divisor#0 ]
Allocated (was zp[1]:123) zp[1]:22 [ test_8u::res#0 divr8u::quotient#3 divr8u::return#1 divr8u::quotient#1 divr8u::quotient#2 ]

ASSEMBLER BEFORE OPTIMIZATION
  // File Comments
// Test the binary division library
  // Upstart
.pc = $801 "Basic"
:BasicUpstart(__bbegin)
.pc = $80d "Program"
  // Global Constants & labels
  .label print_char_cursor = 5
  .label print_line_cursor = $f
  // Remainder after unsigned 16-bit division
  .label rem16u = $b
  // Remainder after signed 16 bit division
  .label rem16s = $b
  // @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 print_cls 
    // [287] phi from main to print_cls [phi:main->print_cls]
  print_cls_from_main:
    jsr print_cls
    // [6] phi from main to main::@1 [phi:main->main::@1]
  __b1_from_main:
    jmp __b1
    // main::@1
  __b1:
    // [7] call test_8u 
    // [258] phi from main::@1 to test_8u [phi:main::@1->test_8u]
  test_8u_from___b1:
    jsr test_8u
    // [8] phi from main::@1 to main::@2 [phi:main::@1->main::@2]
  __b2_from___b1:
    jmp __b2
    // main::@2
  __b2:
    // [9] call test_16u 
    // [222] phi from main::@2 to test_16u [phi:main::@2->test_16u]
  test_16u_from___b2:
    jsr test_16u
    // [10] phi from main::@2 to main::@3 [phi:main::@2->main::@3]
  __b3_from___b2:
    jmp __b3
    // main::@3
  __b3:
    // [11] call test_8s 
    // [134] phi from main::@3 to test_8s [phi:main::@3->test_8s]
  test_8s_from___b3:
    jsr test_8s
    // [12] phi from main::@3 to main::@4 [phi:main::@3->main::@4]
  __b4_from___b3:
    jmp __b4
    // main::@4
  __b4:
    // [13] call test_16s 
    // [15] phi from main::@4 to test_16s [phi:main::@4->test_16s]
  test_16s_from___b4:
    jsr test_16s
    jmp __breturn
    // main::@return
  __breturn:
    // [14] return 
    rts
}
  // test_16s
test_16s: {
    .label dividend = 3
    .label divisor = $11
    .label res = 9
    .label i = $d
    // [16] phi from test_16s to test_16s::@1 [phi:test_16s->test_16s::@1]
  __b1_from_test_16s:
    // [16] phi (byte) test_16s::i#10 = (byte) 0 [phi:test_16s->test_16s::@1#0] -- vbuz1=vbuc1 
    lda #0
    sta.z i
    jmp __b1
    // [16] phi from test_16s::@10 to test_16s::@1 [phi:test_16s::@10->test_16s::@1]
  __b1_from___b10:
    // [16] phi (byte) test_16s::i#10 = (byte) test_16s::i#1 [phi:test_16s::@10->test_16s::@1#0] -- register_copy 
    jmp __b1
    // test_16s::@1
  __b1:
    // [17] (byte~) test_16s::$11 ← (byte) test_16s::i#10 << (byte) 1 -- vbuxx=vbuz1_rol_1 
    lda.z i
    asl
    tax
    // [18] (signed word) test_16s::dividend#0 ← *((const signed word*) test_16s::dividends + (byte~) test_16s::$11) -- vwsz1=pwsc1_derefidx_vbuxx 
    lda dividends,x
    sta.z dividend
    lda dividends+1,x
    sta.z dividend+1
    // [19] (signed word) test_16s::divisor#0 ← *((const signed word*) test_16s::divisors + (byte~) test_16s::$11) -- vwsz1=pwsc1_derefidx_vbuxx 
    lda divisors,x
    sta.z divisor
    lda divisors+1,x
    sta.z divisor+1
    // [20] (signed word) div16s::dividend#0 ← (signed word) test_16s::dividend#0
    // [21] (signed word) div16s::divisor#0 ← (signed word) test_16s::divisor#0
    // [22] call div16s 
    jsr div16s
    // [23] (signed word) div16s::return#2 ← (signed word) div16s::return#0
    jmp __b2
    // test_16s::@2
  __b2:
    // [24] (signed word) test_16s::res#0 ← (signed word) div16s::return#2
    // [25] (signed word) print_sword::w#1 ← (signed word) test_16s::dividend#0
    // [26] (byte*) print_char_cursor#163 ← (byte*) print_line_cursor#1 -- pbuz1=pbuz2 
    lda.z print_line_cursor
    sta.z print_char_cursor
    lda.z print_line_cursor+1
    sta.z print_char_cursor+1
    // [27] call print_sword 
    // [50] phi from test_16s::@2 to print_sword [phi:test_16s::@2->print_sword]
  print_sword_from___b2:
    // [50] phi (byte*) print_char_cursor#132 = (byte*) print_char_cursor#163 [phi:test_16s::@2->print_sword#0] -- register_copy 
    // [50] phi (signed word) print_sword::w#10 = (signed word) print_sword::w#1 [phi:test_16s::@2->print_sword#1] -- register_copy 
    jsr print_sword
    // [28] phi from test_16s::@2 to test_16s::@3 [phi:test_16s::@2->test_16s::@3]
  __b3_from___b2:
    jmp __b3
    // test_16s::@3
  __b3:
    // [29] call print_str 
    // [79] phi from test_16s::@3 to print_str [phi:test_16s::@3->print_str]
  print_str_from___b3:
    // [79] phi (byte*) print_str::str#15 = (const string) str [phi:test_16s::@3->print_str#0] -- pbuz1=pbuc1 
    lda #<str
    sta.z print_str.str
    lda #>str
    sta.z print_str.str+1
    jsr print_str
    jmp __b4
    // test_16s::@4
  __b4:
    // [30] (signed word) print_sword::w#2 ← (signed word) test_16s::divisor#0 -- vwsz1=vwsz2 
    lda.z divisor
    sta.z print_sword.w
    lda.z divisor+1
    sta.z print_sword.w+1
    // [31] call print_sword 
    // [50] phi from test_16s::@4 to print_sword [phi:test_16s::@4->print_sword]
  print_sword_from___b4:
    // [50] phi (byte*) print_char_cursor#132 = (byte*) print_char_cursor#130 [phi:test_16s::@4->print_sword#0] -- register_copy 
    // [50] phi (signed word) print_sword::w#10 = (signed word) print_sword::w#2 [phi:test_16s::@4->print_sword#1] -- register_copy 
    jsr print_sword
    // [32] phi from test_16s::@4 to test_16s::@5 [phi:test_16s::@4->test_16s::@5]
  __b5_from___b4:
    jmp __b5
    // test_16s::@5
  __b5:
    // [33] call print_str 
    // [79] phi from test_16s::@5 to print_str [phi:test_16s::@5->print_str]
  print_str_from___b5:
    // [79] phi (byte*) print_str::str#15 = (const string) str1 [phi:test_16s::@5->print_str#0] -- pbuz1=pbuc1 
    lda #<str1
    sta.z print_str.str
    lda #>str1
    sta.z print_str.str+1
    jsr print_str
    jmp __b6
    // test_16s::@6
  __b6:
    // [34] (signed word) print_sword::w#3 ← (signed word) test_16s::res#0 -- vwsz1=vwsz2 
    lda.z res
    sta.z print_sword.w
    lda.z res+1
    sta.z print_sword.w+1
    // [35] call print_sword 
    // [50] phi from test_16s::@6 to print_sword [phi:test_16s::@6->print_sword]
  print_sword_from___b6:
    // [50] phi (byte*) print_char_cursor#132 = (byte*) print_char_cursor#130 [phi:test_16s::@6->print_sword#0] -- register_copy 
    // [50] phi (signed word) print_sword::w#10 = (signed word) print_sword::w#3 [phi:test_16s::@6->print_sword#1] -- register_copy 
    jsr print_sword
    // [36] phi from test_16s::@6 to test_16s::@7 [phi:test_16s::@6->test_16s::@7]
  __b7_from___b6:
    jmp __b7
    // test_16s::@7
  __b7:
    // [37] call print_str 
    // [79] phi from test_16s::@7 to print_str [phi:test_16s::@7->print_str]
  print_str_from___b7:
    // [79] phi (byte*) print_str::str#15 = (const string) str2 [phi:test_16s::@7->print_str#0] -- pbuz1=pbuc1 
    lda #<str2
    sta.z print_str.str
    lda #>str2
    sta.z print_str.str+1
    jsr print_str
    jmp __b8
    // test_16s::@8
  __b8:
    // [38] (signed word) print_sword::w#4 ← (signed word) rem16s#11 -- vwsz1=vwsz2 
    lda.z rem16s
    sta.z print_sword.w
    lda.z rem16s+1
    sta.z print_sword.w+1
    // [39] call print_sword 
    // [50] phi from test_16s::@8 to print_sword [phi:test_16s::@8->print_sword]
  print_sword_from___b8:
    // [50] phi (byte*) print_char_cursor#132 = (byte*) print_char_cursor#130 [phi:test_16s::@8->print_sword#0] -- register_copy 
    // [50] phi (signed word) print_sword::w#10 = (signed word) print_sword::w#4 [phi:test_16s::@8->print_sword#1] -- register_copy 
    jsr print_sword
    // [40] phi from test_16s::@8 to test_16s::@9 [phi:test_16s::@8->test_16s::@9]
  __b9_from___b8:
    jmp __b9
    // test_16s::@9
  __b9:
    // [41] call print_ln 
    // [45] phi from test_16s::@9 to print_ln [phi:test_16s::@9->print_ln]
  print_ln_from___b9:
    // [45] phi (byte*) print_line_cursor#39 = (byte*) print_line_cursor#1 [phi:test_16s::@9->print_ln#0] -- register_copy 
    jsr print_ln
    jmp __b10
    // test_16s::@10
  __b10:
    // [42] (byte) test_16s::i#1 ← ++ (byte) test_16s::i#10 -- vbuz1=_inc_vbuz1 
    inc.z i
    // [43] if((byte) test_16s::i#1!=(byte) 6) goto test_16s::@1 -- vbuz1_neq_vbuc1_then_la1 
    lda #6
    cmp.z i
    bne __b1_from___b10
    jmp __breturn
    // test_16s::@return
  __breturn:
    // [44] return 
    rts
    dividends: .word $7fff, $7fff, -$7fff, -$7fff, $7fff, -$7fff
    divisors: .word 5, -7, $b, -$d, -$11, $13
}
  // print_ln
// Print a newline
print_ln: {
    // [46] phi from print_ln print_ln::@1 to print_ln::@1 [phi:print_ln/print_ln::@1->print_ln::@1]
  __b1_from_print_ln:
  __b1_from___b1:
    // [46] phi (byte*) print_line_cursor#20 = (byte*) print_line_cursor#39 [phi:print_ln/print_ln::@1->print_ln::@1#0] -- register_copy 
    jmp __b1
    // print_ln::@1
  __b1:
    // [47] (byte*) print_line_cursor#1 ← (byte*) print_line_cursor#20 + (byte) $28 -- pbuz1=pbuz1_plus_vbuc1 
    lda #$28
    clc
    adc.z print_line_cursor
    sta.z print_line_cursor
    bcc !+
    inc.z print_line_cursor+1
  !:
    // [48] if((byte*) print_line_cursor#1<(byte*) print_char_cursor#19) goto print_ln::@1 -- pbuz1_lt_pbuz2_then_la1 
    lda.z print_line_cursor+1
    cmp.z print_char_cursor+1
    bcc __b1_from___b1
    bne !+
    lda.z print_line_cursor
    cmp.z print_char_cursor
    bcc __b1_from___b1
  !:
    jmp __breturn
    // print_ln::@return
  __breturn:
    // [49] return 
    rts
}
  // print_sword
// Print a signed word as HEX
// print_sword(signed word zp(3) w)
print_sword: {
    .label w = 3
    // [51] if((signed word) print_sword::w#10<(signed byte) 0) goto print_sword::@1 -- vwsz1_lt_0_then_la1 
    lda.z w+1
    bmi __b1_from_print_sword
    // [52] phi from print_sword to print_sword::@3 [phi:print_sword->print_sword::@3]
  __b3_from_print_sword:
    jmp __b3
    // print_sword::@3
  __b3:
    // [53] call print_char 
    // [61] phi from print_sword::@3 to print_char [phi:print_sword::@3->print_char]
  print_char_from___b3:
    // [61] phi (byte*) print_char_cursor#84 = (byte*) print_char_cursor#132 [phi:print_sword::@3->print_char#0] -- register_copy 
    // [61] phi (byte) print_char::ch#6 = (byte) ' ' [phi:print_sword::@3->print_char#1] -- vbuaa=vbuc1 
    lda #' '
    jsr print_char
    // [54] phi from print_sword::@3 print_sword::@4 to print_sword::@2 [phi:print_sword::@3/print_sword::@4->print_sword::@2]
  __b2_from___b3:
  __b2_from___b4:
    // [54] phi (signed word) print_sword::w#7 = (signed word) print_sword::w#10 [phi:print_sword::@3/print_sword::@4->print_sword::@2#0] -- register_copy 
    jmp __b2
    // print_sword::@2
  __b2:
    // [55] (word) print_word::w#0 ← (word)(signed word) print_sword::w#7
    // [56] call print_word 
    // [65] phi from print_sword::@2 to print_word [phi:print_sword::@2->print_word]
  print_word_from___b2:
    // [65] phi (byte*) print_char_cursor#138 = (byte*) print_char_cursor#19 [phi:print_sword::@2->print_word#0] -- register_copy 
    // [65] phi (word) print_word::w#5 = (word) print_word::w#0 [phi:print_sword::@2->print_word#1] -- register_copy 
    jsr print_word
    jmp __breturn
    // print_sword::@return
  __breturn:
    // [57] return 
    rts
    // [58] phi from print_sword to print_sword::@1 [phi:print_sword->print_sword::@1]
  __b1_from_print_sword:
    jmp __b1
    // print_sword::@1
  __b1:
    // [59] call print_char 
    // [61] phi from print_sword::@1 to print_char [phi:print_sword::@1->print_char]
  print_char_from___b1:
    // [61] phi (byte*) print_char_cursor#84 = (byte*) print_char_cursor#132 [phi:print_sword::@1->print_char#0] -- register_copy 
    // [61] phi (byte) print_char::ch#6 = (byte) '-' [phi:print_sword::@1->print_char#1] -- vbuaa=vbuc1 
    lda #'-'
    jsr print_char
    jmp __b4
    // print_sword::@4
  __b4:
    // [60] (signed word) print_sword::w#0 ← - (signed word) print_sword::w#10 -- vwsz1=_neg_vwsz1 
    sec
    lda #0
    sbc.z w
    sta.z w
    lda #0
    sbc.z w+1
    sta.z w+1
    jmp __b2_from___b4
}
  // print_char
// Print a single char
// print_char(byte register(A) ch)
print_char: {
    // [62] *((byte*) print_char_cursor#84) ← (byte) print_char::ch#6 -- _deref_pbuz1=vbuaa 
    ldy #0
    sta (print_char_cursor),y
    // [63] (byte*) print_char_cursor#19 ← ++ (byte*) print_char_cursor#84 -- pbuz1=_inc_pbuz1 
    inc.z print_char_cursor
    bne !+
    inc.z print_char_cursor+1
  !:
    jmp __breturn
    // print_char::@return
  __breturn:
    // [64] return 
    rts
}
  // print_word
// Print a word as HEX
// print_word(word zp(3) w)
print_word: {
    .label w = 3
    // [66] (byte) print_byte::b#1 ← > (word) print_word::w#5 -- vbuz1=_hi_vwuz2 
    lda.z w+1
    sta.z print_byte.b
    // [67] call print_byte 
    // [71] phi from print_word to print_byte [phi:print_word->print_byte]
  print_byte_from_print_word:
    // [71] phi (byte*) print_char_cursor#139 = (byte*) print_char_cursor#138 [phi:print_word->print_byte#0] -- register_copy 
    // [71] phi (byte) print_byte::b#7 = (byte) print_byte::b#1 [phi:print_word->print_byte#1] -- register_copy 
    jsr print_byte
    jmp __b1
    // print_word::@1
  __b1:
    // [68] (byte) print_byte::b#2 ← < (word) print_word::w#5 -- vbuz1=_lo_vwuz2 
    lda.z w
    sta.z print_byte.b
    // [69] call print_byte 
    // [71] phi from print_word::@1 to print_byte [phi:print_word::@1->print_byte]
  print_byte_from___b1:
    // [71] phi (byte*) print_char_cursor#139 = (byte*) print_char_cursor#19 [phi:print_word::@1->print_byte#0] -- register_copy 
    // [71] phi (byte) print_byte::b#7 = (byte) print_byte::b#2 [phi:print_word::@1->print_byte#1] -- register_copy 
    jsr print_byte
    jmp __breturn
    // print_word::@return
  __breturn:
    // [70] return 
    rts
}
  // print_byte
// Print a byte as HEX
// print_byte(byte zp(2) b)
print_byte: {
    .label b = 2
    // [72] (byte~) print_byte::$0 ← (byte) print_byte::b#7 >> (byte) 4 -- vbuaa=vbuz1_ror_4 
    lda.z b
    lsr
    lsr
    lsr
    lsr
    // [73] (byte) print_char::ch#4 ← *((const byte*) print_hextab + (byte~) print_byte::$0) -- vbuaa=pbuc1_derefidx_vbuaa 
    tay
    lda print_hextab,y
    // [74] call print_char 
    // [61] phi from print_byte to print_char [phi:print_byte->print_char]
  print_char_from_print_byte:
    // [61] phi (byte*) print_char_cursor#84 = (byte*) print_char_cursor#139 [phi:print_byte->print_char#0] -- register_copy 
    // [61] phi (byte) print_char::ch#6 = (byte) print_char::ch#4 [phi:print_byte->print_char#1] -- register_copy 
    jsr print_char
    jmp __b1
    // print_byte::@1
  __b1:
    // [75] (byte~) print_byte::$2 ← (byte) print_byte::b#7 & (byte) $f -- vbuaa=vbuz1_band_vbuc1 
    lda #$f
    and.z b
    // [76] (byte) print_char::ch#5 ← *((const byte*) print_hextab + (byte~) print_byte::$2) -- vbuaa=pbuc1_derefidx_vbuaa 
    tay
    lda print_hextab,y
    // [77] call print_char 
    // [61] phi from print_byte::@1 to print_char [phi:print_byte::@1->print_char]
  print_char_from___b1:
    // [61] phi (byte*) print_char_cursor#84 = (byte*) print_char_cursor#19 [phi:print_byte::@1->print_char#0] -- register_copy 
    // [61] phi (byte) print_char::ch#6 = (byte) print_char::ch#5 [phi:print_byte::@1->print_char#1] -- register_copy 
    jsr print_char
    jmp __breturn
    // print_byte::@return
  __breturn:
    // [78] return 
    rts
}
  // print_str
// Print a zero-terminated string
// print_str(byte* zp(3) str)
print_str: {
    .label str = 3
    // [80] phi from print_str print_str::@2 to print_str::@1 [phi:print_str/print_str::@2->print_str::@1]
  __b1_from_print_str:
  __b1_from___b2:
    // [80] phi (byte*) print_char_cursor#130 = (byte*) print_char_cursor#19 [phi:print_str/print_str::@2->print_str::@1#0] -- register_copy 
    // [80] phi (byte*) print_str::str#13 = (byte*) print_str::str#15 [phi:print_str/print_str::@2->print_str::@1#1] -- register_copy 
    jmp __b1
    // print_str::@1
  __b1:
    // [81] if((byte) 0!=*((byte*) print_str::str#13)) goto print_str::@2 -- vbuc1_neq__deref_pbuz1_then_la1 
    ldy #0
    lda (str),y
    cmp #0
    bne __b2
    jmp __breturn
    // print_str::@return
  __breturn:
    // [82] return 
    rts
    // print_str::@2
  __b2:
    // [83] *((byte*) print_char_cursor#130) ← *((byte*) print_str::str#13) -- _deref_pbuz1=_deref_pbuz2 
    ldy #0
    lda (str),y
    ldy #0
    sta (print_char_cursor),y
    // [84] (byte*) print_char_cursor#1 ← ++ (byte*) print_char_cursor#130 -- pbuz1=_inc_pbuz1 
    inc.z print_char_cursor
    bne !+
    inc.z print_char_cursor+1
  !:
    // [85] (byte*) print_str::str#0 ← ++ (byte*) print_str::str#13 -- pbuz1=_inc_pbuz1 
    inc.z str
    bne !+
    inc.z str+1
  !:
    jmp __b1_from___b2
}
  // div16s
// Perform division on two signed 16-bit numbers
// Returns dividend/divisor.
// The remainder will be set into the global variable rem16s.
// Implemented using simple binary division
// Follows the C99 standard by truncating toward zero on negative results.
// See http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1124.pdf section 6.5.5
// div16s(signed word zp(3) dividend, signed word zp($11) divisor)
div16s: {
    .label return = 9
    .label dividend = 3
    .label divisor = $11
    // [86] (signed word) divr16s::dividend#0 ← (signed word) div16s::dividend#0 -- vwsz1=vwsz2 
    lda.z dividend
    sta.z divr16s.dividend
    lda.z dividend+1
    sta.z divr16s.dividend+1
    // [87] (signed word) divr16s::divisor#0 ← (signed word) div16s::divisor#0 -- vwsz1=vwsz2 
    lda.z divisor
    sta.z divr16s.divisor
    lda.z divisor+1
    sta.z divr16s.divisor+1
    // [88] call divr16s 
    jsr divr16s
    // [89] (signed word) divr16s::return#3 ← (signed word) divr16s::return#2
    jmp __b1
    // div16s::@1
  __b1:
    // [90] (signed word) div16s::return#0 ← (signed word) divr16s::return#3
    jmp __breturn
    // div16s::@return
  __breturn:
    // [91] return 
    rts
}
  // divr16s
// Perform division on two signed 16-bit numbers with an initial remainder.
// Returns dividend/divisor. The remainder will be set into the global variable rem16s.
// Implemented using simple binary division
// Follows the C99 standard by truncating toward zero on negative results.
// See http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1124.pdf section 6.5.5
// divr16s(signed word zp(5) dividend, signed word zp(7) divisor)
divr16s: {
    .label __16 = $b
    .label dividendu = 5
    .label divisoru = 7
    .label resultu = 9
    .label return = 9
    .label dividend = 5
    .label divisor = 7
    // [92] if((signed word) divr16s::dividend#0<(signed byte) 0) goto divr16s::@1 -- vwsz1_lt_0_then_la1 
    lda.z dividend+1
    bmi __b1
    jmp __b6
    // divr16s::@6
  __b6:
    // [93] (word) divr16s::dividendu#8 ← (word)(signed word) divr16s::dividend#0
    // [94] phi from divr16s::@6 to divr16s::@2 [phi:divr16s::@6->divr16s::@2]
  __b2_from___b6:
    // [94] phi (word) divr16s::dividendu#3 = (word) divr16s::dividendu#8 [phi:divr16s::@6->divr16s::@2#0] -- register_copy 
    // [94] phi (byte) divr16s::neg#3 = (byte) 0 [phi:divr16s::@6->divr16s::@2#1] -- vbuyy=vbuc1 
    ldy #0
    jmp __b2
    // divr16s::@2
  __b2:
    // [95] if((signed word) divr16s::divisor#0<(signed byte) 0) goto divr16s::@3 -- vwsz1_lt_0_then_la1 
    lda.z divisor+1
    bmi __b3
    jmp __b7
    // divr16s::@7
  __b7:
    // [96] (word) divr16s::divisoru#5 ← (word)(signed word) divr16s::divisor#0
    // [97] phi from divr16s::@3 divr16s::@7 to divr16s::@4 [phi:divr16s::@3/divr16s::@7->divr16s::@4]
  __b4_from___b3:
  __b4_from___b7:
    // [97] phi (byte) divr16s::neg#4 = (byte) divr16s::neg#2 [phi:divr16s::@3/divr16s::@7->divr16s::@4#0] -- register_copy 
    // [97] phi (word) divr16s::divisoru#3 = (word) divr16s::divisoru#4 [phi:divr16s::@3/divr16s::@7->divr16s::@4#1] -- register_copy 
    jmp __b4
    // divr16s::@4
  __b4:
    // [98] (word) divr16u::dividend#2 ← (word) divr16s::dividendu#3
    // [99] (word) divr16u::divisor#1 ← (word) divr16s::divisoru#3
    // [100] call divr16u 
    // [116] phi from divr16s::@4 to divr16u [phi:divr16s::@4->divr16u]
  divr16u_from___b4:
    // [116] phi (word) divr16u::divisor#6 = (word) divr16u::divisor#1 [phi:divr16s::@4->divr16u#0] -- register_copy 
    // [116] phi (word) divr16u::dividend#5 = (word) divr16u::dividend#2 [phi:divr16s::@4->divr16u#1] -- register_copy 
    jsr divr16u
    // [101] (word) divr16u::return#3 ← (word) divr16u::return#0
    jmp __b9
    // divr16s::@9
  __b9:
    // [102] (word) divr16s::resultu#0 ← (word) divr16u::return#3
    // [103] if((byte) divr16s::neg#4==(byte) 0) goto divr16s::@5 -- vbuyy_eq_0_then_la1 
    cpy #0
    beq __b5
    jmp __b8
    // divr16s::@8
  __b8:
    // [104] (signed word~) divr16s::$16 ← (signed word)(word) rem16u#1
    // [105] (signed word) rem16s#2 ← - (signed word~) divr16s::$16 -- vwsz1=_neg_vwsz1 
    sec
    lda #0
    sbc.z rem16s
    sta.z rem16s
    lda #0
    sbc.z rem16s+1
    sta.z rem16s+1
    // [106] (signed word) divr16s::return#1 ← - (signed word)(word) divr16s::resultu#0 -- vwsz1=_neg_vwsz1 
    sec
    lda #0
    sbc.z return
    sta.z return
    lda #0
    sbc.z return+1
    sta.z return+1
    // [107] phi from divr16s::@5 divr16s::@8 to divr16s::@return [phi:divr16s::@5/divr16s::@8->divr16s::@return]
  __breturn_from___b5:
  __breturn_from___b8:
    // [107] phi (signed word) rem16s#11 = (signed word) rem16s#37 [phi:divr16s::@5/divr16s::@8->divr16s::@return#0] -- register_copy 
    // [107] phi (signed word) divr16s::return#2 = (signed word) divr16s::return#7 [phi:divr16s::@5/divr16s::@8->divr16s::@return#1] -- register_copy 
    jmp __breturn
    // divr16s::@return
  __breturn:
    // [108] return 
    rts
    // divr16s::@5
  __b5:
    // [109] (signed word) divr16s::return#7 ← (signed word)(word) divr16s::resultu#0
    // [110] (signed word) rem16s#37 ← (signed word)(word) rem16u#1
    jmp __breturn_from___b5
    // divr16s::@3
  __b3:
    // [111] (signed word) divr16s::divisoru#1 ← - (signed word) divr16s::divisor#0 -- vwsz1=_neg_vwsz1 
    sec
    lda #0
    sbc.z divisoru
    sta.z divisoru
    lda #0
    sbc.z divisoru+1
    sta.z divisoru+1
    // [112] (byte) divr16s::neg#2 ← (byte) divr16s::neg#3 ^ (byte) 1 -- vbuyy=vbuyy_bxor_vbuc1 
    tya
    eor #1
    tay
    // [113] (word) divr16s::divisoru#4 ← (word)(signed word) divr16s::divisoru#1
    jmp __b4_from___b3
    // divr16s::@1
  __b1:
    // [114] (signed word) divr16s::dividendu#1 ← - (signed word) divr16s::dividend#0 -- vwsz1=_neg_vwsz1 
    sec
    lda #0
    sbc.z dividendu
    sta.z dividendu
    lda #0
    sbc.z dividendu+1
    sta.z dividendu+1
    // [115] (word) divr16s::dividendu#7 ← (word)(signed word) divr16s::dividendu#1
    // [94] phi from divr16s::@1 to divr16s::@2 [phi:divr16s::@1->divr16s::@2]
  __b2_from___b1:
    // [94] phi (word) divr16s::dividendu#3 = (word) divr16s::dividendu#7 [phi:divr16s::@1->divr16s::@2#0] -- register_copy 
    // [94] phi (byte) divr16s::neg#3 = (byte) 1 [phi:divr16s::@1->divr16s::@2#1] -- vbuyy=vbuc1 
    ldy #1
    jmp __b2
}
  // divr16u
// Performs division on two 16 bit unsigned words and an initial remainder
// Returns the quotient dividend/divisor.
// The final remainder will be set into the global variable rem16u
// Implemented using simple binary division
// divr16u(word zp(5) dividend, word zp(7) divisor, word zp($b) rem)
divr16u: {
    .label rem = $b
    .label dividend = 5
    .label quotient = 9
    .label return = 9
    .label divisor = 7
    // [117] phi from divr16u to divr16u::@1 [phi:divr16u->divr16u::@1]
  __b1_from_divr16u:
    // [117] phi (byte) divr16u::i#2 = (byte) 0 [phi:divr16u->divr16u::@1#0] -- vbuxx=vbuc1 
    ldx #0
    // [117] phi (word) divr16u::quotient#3 = (word) 0 [phi:divr16u->divr16u::@1#1] -- vwuz1=vwuc1 
    lda #<0
    sta.z quotient
    lda #>0
    sta.z quotient+1
    // [117] phi (word) divr16u::dividend#3 = (word) divr16u::dividend#5 [phi:divr16u->divr16u::@1#2] -- register_copy 
    // [117] phi (word) divr16u::rem#5 = (byte) 0 [phi:divr16u->divr16u::@1#3] -- vwuz1=vbuc1 
    lda #<0
    sta.z rem
    lda #>0
    sta.z rem+1
    jmp __b1
    // [117] phi from divr16u::@3 to divr16u::@1 [phi:divr16u::@3->divr16u::@1]
  __b1_from___b3:
    // [117] phi (byte) divr16u::i#2 = (byte) divr16u::i#1 [phi:divr16u::@3->divr16u::@1#0] -- register_copy 
    // [117] phi (word) divr16u::quotient#3 = (word) divr16u::return#0 [phi:divr16u::@3->divr16u::@1#1] -- register_copy 
    // [117] phi (word) divr16u::dividend#3 = (word) divr16u::dividend#0 [phi:divr16u::@3->divr16u::@1#2] -- register_copy 
    // [117] phi (word) divr16u::rem#5 = (word) divr16u::rem#11 [phi:divr16u::@3->divr16u::@1#3] -- register_copy 
    jmp __b1
    // divr16u::@1
  __b1:
    // [118] (word) divr16u::rem#0 ← (word) divr16u::rem#5 << (byte) 1 -- vwuz1=vwuz1_rol_1 
    asl.z rem
    rol.z rem+1
    // [119] (byte~) divr16u::$1 ← > (word) divr16u::dividend#3 -- vbuaa=_hi_vwuz1 
    lda.z dividend+1
    // [120] (byte~) divr16u::$2 ← (byte~) divr16u::$1 & (byte) $80 -- vbuaa=vbuaa_band_vbuc1 
    and #$80
    // [121] if((byte~) divr16u::$2==(byte) 0) goto divr16u::@2 -- vbuaa_eq_0_then_la1 
    cmp #0
    beq __b2_from___b1
    jmp __b4
    // divr16u::@4
  __b4:
    // [122] (word) divr16u::rem#1 ← (word) divr16u::rem#0 | (byte) 1 -- vwuz1=vwuz1_bor_vbuc1 
    lda #1
    ora.z rem
    sta.z rem
    // [123] phi from divr16u::@1 divr16u::@4 to divr16u::@2 [phi:divr16u::@1/divr16u::@4->divr16u::@2]
  __b2_from___b1:
  __b2_from___b4:
    // [123] phi (word) divr16u::rem#6 = (word) divr16u::rem#0 [phi:divr16u::@1/divr16u::@4->divr16u::@2#0] -- register_copy 
    jmp __b2
    // divr16u::@2
  __b2:
    // [124] (word) divr16u::dividend#0 ← (word) divr16u::dividend#3 << (byte) 1 -- vwuz1=vwuz1_rol_1 
    asl.z dividend
    rol.z dividend+1
    // [125] (word) divr16u::quotient#1 ← (word) divr16u::quotient#3 << (byte) 1 -- vwuz1=vwuz1_rol_1 
    asl.z quotient
    rol.z quotient+1
    // [126] if((word) divr16u::rem#6<(word) divr16u::divisor#6) goto divr16u::@3 -- vwuz1_lt_vwuz2_then_la1 
    lda.z rem+1
    cmp.z divisor+1
    bcc __b3_from___b2
    bne !+
    lda.z rem
    cmp.z divisor
    bcc __b3_from___b2
  !:
    jmp __b5
    // divr16u::@5
  __b5:
    // [127] (word) divr16u::quotient#2 ← ++ (word) divr16u::quotient#1 -- vwuz1=_inc_vwuz1 
    inc.z quotient
    bne !+
    inc.z quotient+1
  !:
    // [128] (word) divr16u::rem#2 ← (word) divr16u::rem#6 - (word) divr16u::divisor#6 -- vwuz1=vwuz1_minus_vwuz2 
    lda.z rem
    sec
    sbc.z divisor
    sta.z rem
    lda.z rem+1
    sbc.z divisor+1
    sta.z rem+1
    // [129] phi from divr16u::@2 divr16u::@5 to divr16u::@3 [phi:divr16u::@2/divr16u::@5->divr16u::@3]
  __b3_from___b2:
  __b3_from___b5:
    // [129] phi (word) divr16u::return#0 = (word) divr16u::quotient#1 [phi:divr16u::@2/divr16u::@5->divr16u::@3#0] -- register_copy 
    // [129] phi (word) divr16u::rem#11 = (word) divr16u::rem#6 [phi:divr16u::@2/divr16u::@5->divr16u::@3#1] -- register_copy 
    jmp __b3
    // divr16u::@3
  __b3:
    // [130] (byte) divr16u::i#1 ← ++ (byte) divr16u::i#2 -- vbuxx=_inc_vbuxx 
    inx
    // [131] if((byte) divr16u::i#1!=(byte) $10) goto divr16u::@1 -- vbuxx_neq_vbuc1_then_la1 
    cpx #$10
    bne __b1_from___b3
    jmp __b6
    // divr16u::@6
  __b6:
    // [132] (word) rem16u#1 ← (word) divr16u::rem#11
    jmp __breturn
    // divr16u::@return
  __breturn:
    // [133] return 
    rts
}
  // test_8s
test_8s: {
    .label dividend = 2
    .label divisor = $13
    .label res = $14
    .label i = $d
    // [135] phi from test_8s to test_8s::@1 [phi:test_8s->test_8s::@1]
  __b1_from_test_8s:
    // [135] phi (byte) test_8s::i#10 = (byte) 0 [phi:test_8s->test_8s::@1#0] -- vbuz1=vbuc1 
    lda #0
    sta.z i
    jmp __b1
    // [135] phi from test_8s::@10 to test_8s::@1 [phi:test_8s::@10->test_8s::@1]
  __b1_from___b10:
    // [135] phi (byte) test_8s::i#10 = (byte) test_8s::i#1 [phi:test_8s::@10->test_8s::@1#0] -- register_copy 
    jmp __b1
    // test_8s::@1
  __b1:
    // [136] (signed byte) test_8s::dividend#0 ← *((const signed byte*) test_8s::dividends + (byte) test_8s::i#10) -- vbsz1=pbsc1_derefidx_vbuz2 
    ldy.z i
    lda dividends,y
    sta.z dividend
    // [137] (signed byte) test_8s::divisor#0 ← *((const signed byte*) test_8s::divisors + (byte) test_8s::i#10) -- vbsz1=pbsc1_derefidx_vbuz2 
    ldy.z i
    lda divisors,y
    sta.z divisor
    // [138] (signed byte) div8s::dividend#0 ← (signed byte) test_8s::dividend#0 -- vbsyy=vbsz1 
    ldy.z dividend
    // [139] (signed byte) div8s::divisor#0 ← (signed byte) test_8s::divisor#0 -- vbsxx=vbsz1 
    ldx.z divisor
    // [140] call div8s 
    jsr div8s
    // [141] (signed byte) div8s::return#3 ← (signed byte) div8s::return#2
    jmp __b2
    // test_8s::@2
  __b2:
    // [142] (signed byte) test_8s::res#0 ← (signed byte) div8s::return#3 -- vbsz1=vbsaa 
    sta.z res
    // [143] (signed byte) print_sbyte::b#1 ← (signed byte) test_8s::dividend#0
    // [144] (byte*) print_char_cursor#167 ← (byte*) print_line_cursor#1 -- pbuz1=pbuz2 
    lda.z print_line_cursor
    sta.z print_char_cursor
    lda.z print_line_cursor+1
    sta.z print_char_cursor+1
    // [145] call print_sbyte 
    // [163] phi from test_8s::@2 to print_sbyte [phi:test_8s::@2->print_sbyte]
  print_sbyte_from___b2:
    // [163] phi (byte*) print_char_cursor#135 = (byte*) print_char_cursor#167 [phi:test_8s::@2->print_sbyte#0] -- register_copy 
    // [163] phi (signed byte) print_sbyte::b#10 = (signed byte) print_sbyte::b#1 [phi:test_8s::@2->print_sbyte#1] -- register_copy 
    jsr print_sbyte
    // [146] phi from test_8s::@2 to test_8s::@3 [phi:test_8s::@2->test_8s::@3]
  __b3_from___b2:
    jmp __b3
    // test_8s::@3
  __b3:
    // [147] call print_str 
    // [79] phi from test_8s::@3 to print_str [phi:test_8s::@3->print_str]
  print_str_from___b3:
    // [79] phi (byte*) print_str::str#15 = (const string) str [phi:test_8s::@3->print_str#0] -- pbuz1=pbuc1 
    lda #<str
    sta.z print_str.str
    lda #>str
    sta.z print_str.str+1
    jsr print_str
    jmp __b4
    // test_8s::@4
  __b4:
    // [148] (signed byte) print_sbyte::b#2 ← (signed byte) test_8s::divisor#0 -- vbsz1=vbsz2 
    lda.z divisor
    sta.z print_sbyte.b
    // [149] call print_sbyte 
    // [163] phi from test_8s::@4 to print_sbyte [phi:test_8s::@4->print_sbyte]
  print_sbyte_from___b4:
    // [163] phi (byte*) print_char_cursor#135 = (byte*) print_char_cursor#130 [phi:test_8s::@4->print_sbyte#0] -- register_copy 
    // [163] phi (signed byte) print_sbyte::b#10 = (signed byte) print_sbyte::b#2 [phi:test_8s::@4->print_sbyte#1] -- register_copy 
    jsr print_sbyte
    // [150] phi from test_8s::@4 to test_8s::@5 [phi:test_8s::@4->test_8s::@5]
  __b5_from___b4:
    jmp __b5
    // test_8s::@5
  __b5:
    // [151] call print_str 
    // [79] phi from test_8s::@5 to print_str [phi:test_8s::@5->print_str]
  print_str_from___b5:
    // [79] phi (byte*) print_str::str#15 = (const string) str1 [phi:test_8s::@5->print_str#0] -- pbuz1=pbuc1 
    lda #<str1
    sta.z print_str.str
    lda #>str1
    sta.z print_str.str+1
    jsr print_str
    jmp __b6
    // test_8s::@6
  __b6:
    // [152] (signed byte) print_sbyte::b#3 ← (signed byte) test_8s::res#0 -- vbsz1=vbsz2 
    lda.z res
    sta.z print_sbyte.b
    // [153] call print_sbyte 
    // [163] phi from test_8s::@6 to print_sbyte [phi:test_8s::@6->print_sbyte]
  print_sbyte_from___b6:
    // [163] phi (byte*) print_char_cursor#135 = (byte*) print_char_cursor#130 [phi:test_8s::@6->print_sbyte#0] -- register_copy 
    // [163] phi (signed byte) print_sbyte::b#10 = (signed byte) print_sbyte::b#3 [phi:test_8s::@6->print_sbyte#1] -- register_copy 
    jsr print_sbyte
    // [154] phi from test_8s::@6 to test_8s::@7 [phi:test_8s::@6->test_8s::@7]
  __b7_from___b6:
    jmp __b7
    // test_8s::@7
  __b7:
    // [155] call print_str 
    // [79] phi from test_8s::@7 to print_str [phi:test_8s::@7->print_str]
  print_str_from___b7:
    // [79] phi (byte*) print_str::str#15 = (const string) str2 [phi:test_8s::@7->print_str#0] -- pbuz1=pbuc1 
    lda #<str2
    sta.z print_str.str
    lda #>str2
    sta.z print_str.str+1
    jsr print_str
    jmp __b8
    // test_8s::@8
  __b8:
    // [156] (signed byte) print_sbyte::b#4 ← (signed byte) rem8s#3 -- vbsz1=vbsxx 
    stx.z print_sbyte.b
    // [157] call print_sbyte 
    // [163] phi from test_8s::@8 to print_sbyte [phi:test_8s::@8->print_sbyte]
  print_sbyte_from___b8:
    // [163] phi (byte*) print_char_cursor#135 = (byte*) print_char_cursor#130 [phi:test_8s::@8->print_sbyte#0] -- register_copy 
    // [163] phi (signed byte) print_sbyte::b#10 = (signed byte) print_sbyte::b#4 [phi:test_8s::@8->print_sbyte#1] -- register_copy 
    jsr print_sbyte
    // [158] phi from test_8s::@8 to test_8s::@9 [phi:test_8s::@8->test_8s::@9]
  __b9_from___b8:
    jmp __b9
    // test_8s::@9
  __b9:
    // [159] call print_ln 
    // [45] phi from test_8s::@9 to print_ln [phi:test_8s::@9->print_ln]
  print_ln_from___b9:
    // [45] phi (byte*) print_line_cursor#39 = (byte*) print_line_cursor#1 [phi:test_8s::@9->print_ln#0] -- register_copy 
    jsr print_ln
    jmp __b10
    // test_8s::@10
  __b10:
    // [160] (byte) test_8s::i#1 ← ++ (byte) test_8s::i#10 -- vbuz1=_inc_vbuz1 
    inc.z i
    // [161] if((byte) test_8s::i#1!=(byte) 6) goto test_8s::@1 -- vbuz1_neq_vbuc1_then_la1 
    lda #6
    cmp.z i
    bne __b1_from___b10
    jmp __breturn
    // test_8s::@return
  __breturn:
    // [162] return 
    rts
    dividends: .byte $7f, -$7f, -$7f, $7f, $7f, $7f
    divisors: .byte 5, 7, -$b, -$d, $11, $13
}
  // print_sbyte
// Print a signed byte as HEX
// print_sbyte(signed byte zp(2) b)
print_sbyte: {
    .label b = 2
    // [164] if((signed byte) print_sbyte::b#10<(signed byte) 0) goto print_sbyte::@1 -- vbsz1_lt_0_then_la1 
    lda.z b
    bmi __b1_from_print_sbyte
    // [165] phi from print_sbyte to print_sbyte::@3 [phi:print_sbyte->print_sbyte::@3]
  __b3_from_print_sbyte:
    jmp __b3
    // print_sbyte::@3
  __b3:
    // [166] call print_char 
    // [61] phi from print_sbyte::@3 to print_char [phi:print_sbyte::@3->print_char]
  print_char_from___b3:
    // [61] phi (byte*) print_char_cursor#84 = (byte*) print_char_cursor#135 [phi:print_sbyte::@3->print_char#0] -- register_copy 
    // [61] phi (byte) print_char::ch#6 = (byte) ' ' [phi:print_sbyte::@3->print_char#1] -- vbuaa=vbuc1 
    lda #' '
    jsr print_char
    // [167] phi from print_sbyte::@3 print_sbyte::@4 to print_sbyte::@2 [phi:print_sbyte::@3/print_sbyte::@4->print_sbyte::@2]
  __b2_from___b3:
  __b2_from___b4:
    // [167] phi (signed byte) print_sbyte::b#7 = (signed byte) print_sbyte::b#10 [phi:print_sbyte::@3/print_sbyte::@4->print_sbyte::@2#0] -- register_copy 
    jmp __b2
    // print_sbyte::@2
  __b2:
    // [168] (byte) print_byte::b#0 ← (byte)(signed byte) print_sbyte::b#7
    // [169] call print_byte 
    // [71] phi from print_sbyte::@2 to print_byte [phi:print_sbyte::@2->print_byte]
  print_byte_from___b2:
    // [71] phi (byte*) print_char_cursor#139 = (byte*) print_char_cursor#19 [phi:print_sbyte::@2->print_byte#0] -- register_copy 
    // [71] phi (byte) print_byte::b#7 = (byte) print_byte::b#0 [phi:print_sbyte::@2->print_byte#1] -- register_copy 
    jsr print_byte
    jmp __breturn
    // print_sbyte::@return
  __breturn:
    // [170] return 
    rts
    // [171] phi from print_sbyte to print_sbyte::@1 [phi:print_sbyte->print_sbyte::@1]
  __b1_from_print_sbyte:
    jmp __b1
    // print_sbyte::@1
  __b1:
    // [172] call print_char 
    // [61] phi from print_sbyte::@1 to print_char [phi:print_sbyte::@1->print_char]
  print_char_from___b1:
    // [61] phi (byte*) print_char_cursor#84 = (byte*) print_char_cursor#135 [phi:print_sbyte::@1->print_char#0] -- register_copy 
    // [61] phi (byte) print_char::ch#6 = (byte) '-' [phi:print_sbyte::@1->print_char#1] -- vbuaa=vbuc1 
    lda #'-'
    jsr print_char
    jmp __b4
    // print_sbyte::@4
  __b4:
    // [173] (signed byte) print_sbyte::b#0 ← - (signed byte) print_sbyte::b#10 -- vbsz1=_neg_vbsz1 
    lda.z b
    eor #$ff
    clc
    adc #1
    sta.z b
    jmp __b2_from___b4
}
  // div8s
// Perform division on two signed 8-bit numbers
// Returns dividend/divisor.
// The remainder will be set into the global variable rem8s.
// Implemented using simple binary division
// Follows the C99 standard by truncating toward zero on negative results.
// See http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1124.pdf section 6.5.5
// div8s(signed byte register(Y) dividend, signed byte register(X) divisor)
div8s: {
    .label neg = $e
    // [174] if((signed byte) div8s::dividend#0<(signed byte) 0) goto div8s::@1 -- vbsyy_lt_0_then_la1 
    cpy #0
    bmi __b1
    jmp __b6
    // div8s::@6
  __b6:
    // [175] (byte) div8s::dividendu#8 ← (byte)(signed byte) div8s::dividend#0
    // [176] phi from div8s::@6 to div8s::@2 [phi:div8s::@6->div8s::@2]
  __b2_from___b6:
    // [176] phi (byte) div8s::dividendu#3 = (byte) div8s::dividendu#8 [phi:div8s::@6->div8s::@2#0] -- register_copy 
    // [176] phi (byte) div8s::neg#3 = (byte) 0 [phi:div8s::@6->div8s::@2#1] -- vbuz1=vbuc1 
    lda #0
    sta.z neg
    jmp __b2
    // div8s::@2
  __b2:
    // [177] if((signed byte) div8s::divisor#0<(signed byte) 0) goto div8s::@3 -- vbsxx_lt_0_then_la1 
    cpx #0
    bmi __b3
    jmp __b7
    // div8s::@7
  __b7:
    // [178] (byte) div8s::divisoru#5 ← (byte)(signed byte) div8s::divisor#0
    // [179] phi from div8s::@3 div8s::@7 to div8s::@4 [phi:div8s::@3/div8s::@7->div8s::@4]
  __b4_from___b3:
  __b4_from___b7:
    // [179] phi (byte) div8s::neg#4 = (byte) div8s::neg#2 [phi:div8s::@3/div8s::@7->div8s::@4#0] -- register_copy 
    // [179] phi (byte) div8s::divisoru#3 = (byte) div8s::divisoru#4 [phi:div8s::@3/div8s::@7->div8s::@4#1] -- register_copy 
    jmp __b4
    // div8s::@4
  __b4:
    // [180] (byte) div8u::dividend#0 ← (byte) div8s::dividendu#3 -- vbuaa=vbuyy 
    tya
    // [181] (byte) div8u::divisor#0 ← (byte) div8s::divisoru#3
    // [182] call div8u 
    // [198] phi from div8s::@4 to div8u [phi:div8s::@4->div8u]
  div8u_from___b4:
    // [198] phi (byte) div8u::divisor#2 = (byte) div8u::divisor#0 [phi:div8s::@4->div8u#0] -- register_copy 
    // [198] phi (byte) div8u::dividend#2 = (byte) div8u::dividend#0 [phi:div8s::@4->div8u#1] -- register_copy 
    jsr div8u
    // [183] (byte) div8u::return#2 ← (byte) div8u::return#0
    jmp __b9
    // div8s::@9
  __b9:
    // [184] (byte) div8s::resultu#0 ← (byte) div8u::return#2 -- vbuyy=vbuaa 
    tay
    // [185] if((byte) div8s::neg#4==(byte) 0) goto div8s::@5 -- vbuz1_eq_0_then_la1 
    lda.z neg
    cmp #0
    beq __b5
    jmp __b8
    // div8s::@8
  __b8:
    // [186] (signed byte~) div8s::$11 ← (signed byte)(byte) rem8u#17 -- vbsaa=vbsxx 
    txa
    // [187] (signed byte) rem8s#2 ← - (signed byte~) div8s::$11 -- vbsxx=_neg_vbsaa 
    eor #$ff
    clc
    adc #1
    tax
    // [188] (signed byte) div8s::return#1 ← - (signed byte)(byte) div8s::resultu#0 -- vbsaa=_neg_vbsyy 
    tya
    eor #$ff
    clc
    adc #1
    // [189] phi from div8s::@5 div8s::@8 to div8s::@return [phi:div8s::@5/div8s::@8->div8s::@return]
  __breturn_from___b5:
  __breturn_from___b8:
    // [189] phi (signed byte) rem8s#3 = (signed byte) rem8s#33 [phi:div8s::@5/div8s::@8->div8s::@return#0] -- register_copy 
    // [189] phi (signed byte) div8s::return#2 = (signed byte) div8s::return#7 [phi:div8s::@5/div8s::@8->div8s::@return#1] -- register_copy 
    jmp __breturn
    // div8s::@return
  __breturn:
    // [190] return 
    rts
    // div8s::@5
  __b5:
    // [191] (signed byte) div8s::return#7 ← (signed byte)(byte) div8s::resultu#0 -- vbsaa=vbsyy 
    tya
    // [192] (signed byte) rem8s#33 ← (signed byte)(byte) rem8u#17
    jmp __breturn_from___b5
    // div8s::@3
  __b3:
    // [193] (signed byte) div8s::divisoru#1 ← - (signed byte) div8s::divisor#0 -- vbsxx=_neg_vbsxx 
    txa
    eor #$ff
    clc
    adc #1
    tax
    // [194] (byte) div8s::neg#2 ← (byte) div8s::neg#3 ^ (byte) 1 -- vbuz1=vbuz1_bxor_vbuc1 
    lda #1
    eor.z neg
    sta.z neg
    // [195] (byte) div8s::divisoru#4 ← (byte)(signed byte) div8s::divisoru#1
    jmp __b4_from___b3
    // div8s::@1
  __b1:
    // [196] (signed byte) div8s::dividendu#1 ← - (signed byte) div8s::dividend#0 -- vbsaa=_neg_vbsyy 
    tya
    eor #$ff
    clc
    adc #1
    // [197] (byte) div8s::dividendu#7 ← (byte)(signed byte) div8s::dividendu#1 -- vbuyy=vbuaa 
    tay
    // [176] phi from div8s::@1 to div8s::@2 [phi:div8s::@1->div8s::@2]
  __b2_from___b1:
    // [176] phi (byte) div8s::dividendu#3 = (byte) div8s::dividendu#7 [phi:div8s::@1->div8s::@2#0] -- register_copy 
    // [176] phi (byte) div8s::neg#3 = (byte) 1 [phi:div8s::@1->div8s::@2#1] -- vbuz1=vbuc1 
    lda #1
    sta.z neg
    jmp __b2
}
  // div8u
// Performs division on two 8 bit unsigned bytes
// Returns dividend/divisor.
// The remainder will be set into the global variable rem8u
// Implemented using simple binary division
// div8u(byte register(A) dividend, byte register(X) divisor)
div8u: {
    // [199] (byte) divr8u::dividend#0 ← (byte) div8u::dividend#2 -- vbuz1=vbuaa 
    sta.z divr8u.dividend
    // [200] (byte) divr8u::divisor#0 ← (byte) div8u::divisor#2 -- vbuz1=vbuxx 
    stx.z divr8u.divisor
    // [201] call divr8u 
    // [205] phi from div8u to divr8u [phi:div8u->divr8u]
  divr8u_from_div8u:
    jsr divr8u
    // [202] (byte) divr8u::return#0 ← (byte) divr8u::return#1 -- vbuaa=vbuz1 
    lda.z divr8u.return
    jmp __b1
    // div8u::@1
  __b1:
    // [203] (byte) div8u::return#0 ← (byte) divr8u::return#0
    jmp __breturn
    // div8u::@return
  __breturn:
    // [204] return 
    rts
}
  // divr8u
// Performs division on two 8 bit unsigned bytes and an initial remainder
// Returns dividend/divisor.
// The final remainder will be set into the global variable rem8u
// Implemented using simple binary division
// divr8u(byte zp($14) dividend, byte zp($15) divisor, byte register(Y) rem)
divr8u: {
    .label dividend = $14
    .label divisor = $15
    .label quotient = $16
    .label return = $16
    // [206] phi from divr8u to divr8u::@1 [phi:divr8u->divr8u::@1]
  __b1_from_divr8u:
    // [206] phi (byte) divr8u::i#2 = (byte) 0 [phi:divr8u->divr8u::@1#0] -- vbuxx=vbuc1 
    ldx #0
    // [206] phi (byte) divr8u::quotient#3 = (byte) 0 [phi:divr8u->divr8u::@1#1] -- vbuz1=vbuc1 
    lda #0
    sta.z quotient
    // [206] phi (byte) divr8u::dividend#2 = (byte) divr8u::dividend#0 [phi:divr8u->divr8u::@1#2] -- register_copy 
    // [206] phi (byte) divr8u::rem#4 = (byte) 0 [phi:divr8u->divr8u::@1#3] -- vbuyy=vbuc1 
    ldy #0
    jmp __b1
    // [206] phi from divr8u::@3 to divr8u::@1 [phi:divr8u::@3->divr8u::@1]
  __b1_from___b3:
    // [206] phi (byte) divr8u::i#2 = (byte) divr8u::i#1 [phi:divr8u::@3->divr8u::@1#0] -- register_copy 
    // [206] phi (byte) divr8u::quotient#3 = (byte) divr8u::return#1 [phi:divr8u::@3->divr8u::@1#1] -- register_copy 
    // [206] phi (byte) divr8u::dividend#2 = (byte) divr8u::dividend#1 [phi:divr8u::@3->divr8u::@1#2] -- register_copy 
    // [206] phi (byte) divr8u::rem#4 = (byte) divr8u::rem#10 [phi:divr8u::@3->divr8u::@1#3] -- register_copy 
    jmp __b1
    // divr8u::@1
  __b1:
    // [207] (byte) divr8u::rem#1 ← (byte) divr8u::rem#4 << (byte) 1 -- vbuyy=vbuyy_rol_1 
    tya
    asl
    tay
    // [208] (byte~) divr8u::$1 ← (byte) divr8u::dividend#2 & (byte) $80 -- vbuaa=vbuz1_band_vbuc1 
    lda #$80
    and.z dividend
    // [209] if((byte~) divr8u::$1==(byte) 0) goto divr8u::@2 -- vbuaa_eq_0_then_la1 
    cmp #0
    beq __b2_from___b1
    jmp __b4
    // divr8u::@4
  __b4:
    // [210] (byte) divr8u::rem#2 ← (byte) divr8u::rem#1 | (byte) 1 -- vbuyy=vbuyy_bor_vbuc1 
    tya
    ora #1
    tay
    // [211] phi from divr8u::@1 divr8u::@4 to divr8u::@2 [phi:divr8u::@1/divr8u::@4->divr8u::@2]
  __b2_from___b1:
  __b2_from___b4:
    // [211] phi (byte) divr8u::rem#5 = (byte) divr8u::rem#1 [phi:divr8u::@1/divr8u::@4->divr8u::@2#0] -- register_copy 
    jmp __b2
    // divr8u::@2
  __b2:
    // [212] (byte) divr8u::dividend#1 ← (byte) divr8u::dividend#2 << (byte) 1 -- vbuz1=vbuz1_rol_1 
    asl.z dividend
    // [213] (byte) divr8u::quotient#1 ← (byte) divr8u::quotient#3 << (byte) 1 -- vbuz1=vbuz1_rol_1 
    asl.z quotient
    // [214] if((byte) divr8u::rem#5<(byte) divr8u::divisor#0) goto divr8u::@3 -- vbuyy_lt_vbuz1_then_la1 
    cpy.z divisor
    bcc __b3_from___b2
    jmp __b5
    // divr8u::@5
  __b5:
    // [215] (byte) divr8u::quotient#2 ← ++ (byte) divr8u::quotient#1 -- vbuz1=_inc_vbuz1 
    inc.z quotient
    // [216] (byte) divr8u::rem#3 ← (byte) divr8u::rem#5 - (byte) divr8u::divisor#0 -- vbuyy=vbuyy_minus_vbuz1 
    tya
    sec
    sbc.z divisor
    tay
    // [217] phi from divr8u::@2 divr8u::@5 to divr8u::@3 [phi:divr8u::@2/divr8u::@5->divr8u::@3]
  __b3_from___b2:
  __b3_from___b5:
    // [217] phi (byte) divr8u::return#1 = (byte) divr8u::quotient#1 [phi:divr8u::@2/divr8u::@5->divr8u::@3#0] -- register_copy 
    // [217] phi (byte) divr8u::rem#10 = (byte) divr8u::rem#5 [phi:divr8u::@2/divr8u::@5->divr8u::@3#1] -- register_copy 
    jmp __b3
    // divr8u::@3
  __b3:
    // [218] (byte) divr8u::i#1 ← ++ (byte) divr8u::i#2 -- vbuxx=_inc_vbuxx 
    inx
    // [219] if((byte) divr8u::i#1!=(byte) 8) goto divr8u::@1 -- vbuxx_neq_vbuc1_then_la1 
    cpx #8
    bne __b1_from___b3
    jmp __b6
    // divr8u::@6
  __b6:
    // [220] (byte) rem8u#17 ← (byte) divr8u::rem#10 -- vbuxx=vbuyy 
    tya
    tax
    jmp __breturn
    // divr8u::@return
  __breturn:
    // [221] return 
    rts
}
  // test_16u
test_16u: {
    .label dividend = 3
    .label divisor = 7
    .label res = 9
    .label i = $e
    // [223] phi from test_16u to test_16u::@1 [phi:test_16u->test_16u::@1]
  __b1_from_test_16u:
    // [223] phi (byte) test_16u::i#10 = (byte) 0 [phi:test_16u->test_16u::@1#0] -- vbuz1=vbuc1 
    lda #0
    sta.z i
    jmp __b1
    // [223] phi from test_16u::@10 to test_16u::@1 [phi:test_16u::@10->test_16u::@1]
  __b1_from___b10:
    // [223] phi (byte) test_16u::i#10 = (byte) test_16u::i#1 [phi:test_16u::@10->test_16u::@1#0] -- register_copy 
    jmp __b1
    // test_16u::@1
  __b1:
    // [224] (byte~) test_16u::$11 ← (byte) test_16u::i#10 << (byte) 1 -- vbuxx=vbuz1_rol_1 
    lda.z i
    asl
    tax
    // [225] (word) test_16u::dividend#0 ← *((const word*) test_16u::dividends + (byte~) test_16u::$11) -- vwuz1=pwuc1_derefidx_vbuxx 
    lda dividends,x
    sta.z dividend
    lda dividends+1,x
    sta.z dividend+1
    // [226] (word) test_16u::divisor#0 ← *((const word*) test_16u::divisors + (byte~) test_16u::$11) -- vwuz1=pwuc1_derefidx_vbuxx 
    lda divisors,x
    sta.z divisor
    lda divisors+1,x
    sta.z divisor+1
    // [227] (word) div16u::dividend#0 ← (word) test_16u::dividend#0
    // [228] (word) div16u::divisor#0 ← (word) test_16u::divisor#0
    // [229] call div16u 
    jsr div16u
    // [230] (word) div16u::return#2 ← (word) div16u::return#0
    jmp __b2
    // test_16u::@2
  __b2:
    // [231] (word) test_16u::res#0 ← (word) div16u::return#2
    // [232] (word) print_word::w#1 ← (word) test_16u::dividend#0
    // [233] (byte*) print_char_cursor#172 ← (byte*) print_line_cursor#1 -- pbuz1=pbuz2 
    lda.z print_line_cursor
    sta.z print_char_cursor
    lda.z print_line_cursor+1
    sta.z print_char_cursor+1
    // [234] call print_word 
    // [65] phi from test_16u::@2 to print_word [phi:test_16u::@2->print_word]
  print_word_from___b2:
    // [65] phi (byte*) print_char_cursor#138 = (byte*) print_char_cursor#172 [phi:test_16u::@2->print_word#0] -- register_copy 
    // [65] phi (word) print_word::w#5 = (word) print_word::w#1 [phi:test_16u::@2->print_word#1] -- register_copy 
    jsr print_word
    // [235] phi from test_16u::@2 to test_16u::@3 [phi:test_16u::@2->test_16u::@3]
  __b3_from___b2:
    jmp __b3
    // test_16u::@3
  __b3:
    // [236] call print_str 
    // [79] phi from test_16u::@3 to print_str [phi:test_16u::@3->print_str]
  print_str_from___b3:
    // [79] phi (byte*) print_str::str#15 = (const string) str [phi:test_16u::@3->print_str#0] -- pbuz1=pbuc1 
    lda #<str
    sta.z print_str.str
    lda #>str
    sta.z print_str.str+1
    jsr print_str
    jmp __b4
    // test_16u::@4
  __b4:
    // [237] (word) print_word::w#2 ← (word) test_16u::divisor#0 -- vwuz1=vwuz2 
    lda.z divisor
    sta.z print_word.w
    lda.z divisor+1
    sta.z print_word.w+1
    // [238] call print_word 
    // [65] phi from test_16u::@4 to print_word [phi:test_16u::@4->print_word]
  print_word_from___b4:
    // [65] phi (byte*) print_char_cursor#138 = (byte*) print_char_cursor#130 [phi:test_16u::@4->print_word#0] -- register_copy 
    // [65] phi (word) print_word::w#5 = (word) print_word::w#2 [phi:test_16u::@4->print_word#1] -- register_copy 
    jsr print_word
    // [239] phi from test_16u::@4 to test_16u::@5 [phi:test_16u::@4->test_16u::@5]
  __b5_from___b4:
    jmp __b5
    // test_16u::@5
  __b5:
    // [240] call print_str 
    // [79] phi from test_16u::@5 to print_str [phi:test_16u::@5->print_str]
  print_str_from___b5:
    // [79] phi (byte*) print_str::str#15 = (const string) str1 [phi:test_16u::@5->print_str#0] -- pbuz1=pbuc1 
    lda #<str1
    sta.z print_str.str
    lda #>str1
    sta.z print_str.str+1
    jsr print_str
    jmp __b6
    // test_16u::@6
  __b6:
    // [241] (word) print_word::w#3 ← (word) test_16u::res#0 -- vwuz1=vwuz2 
    lda.z res
    sta.z print_word.w
    lda.z res+1
    sta.z print_word.w+1
    // [242] call print_word 
    // [65] phi from test_16u::@6 to print_word [phi:test_16u::@6->print_word]
  print_word_from___b6:
    // [65] phi (byte*) print_char_cursor#138 = (byte*) print_char_cursor#130 [phi:test_16u::@6->print_word#0] -- register_copy 
    // [65] phi (word) print_word::w#5 = (word) print_word::w#3 [phi:test_16u::@6->print_word#1] -- register_copy 
    jsr print_word
    // [243] phi from test_16u::@6 to test_16u::@7 [phi:test_16u::@6->test_16u::@7]
  __b7_from___b6:
    jmp __b7
    // test_16u::@7
  __b7:
    // [244] call print_str 
    // [79] phi from test_16u::@7 to print_str [phi:test_16u::@7->print_str]
  print_str_from___b7:
    // [79] phi (byte*) print_str::str#15 = (const string) str2 [phi:test_16u::@7->print_str#0] -- pbuz1=pbuc1 
    lda #<str2
    sta.z print_str.str
    lda #>str2
    sta.z print_str.str+1
    jsr print_str
    jmp __b8
    // test_16u::@8
  __b8:
    // [245] (word) print_word::w#4 ← (word) rem16u#1 -- vwuz1=vwuz2 
    lda.z rem16u
    sta.z print_word.w
    lda.z rem16u+1
    sta.z print_word.w+1
    // [246] call print_word 
    // [65] phi from test_16u::@8 to print_word [phi:test_16u::@8->print_word]
  print_word_from___b8:
    // [65] phi (byte*) print_char_cursor#138 = (byte*) print_char_cursor#130 [phi:test_16u::@8->print_word#0] -- register_copy 
    // [65] phi (word) print_word::w#5 = (word) print_word::w#4 [phi:test_16u::@8->print_word#1] -- register_copy 
    jsr print_word
    // [247] phi from test_16u::@8 to test_16u::@9 [phi:test_16u::@8->test_16u::@9]
  __b9_from___b8:
    jmp __b9
    // test_16u::@9
  __b9:
    // [248] call print_ln 
    // [45] phi from test_16u::@9 to print_ln [phi:test_16u::@9->print_ln]
  print_ln_from___b9:
    // [45] phi (byte*) print_line_cursor#39 = (byte*) print_line_cursor#1 [phi:test_16u::@9->print_ln#0] -- register_copy 
    jsr print_ln
    jmp __b10
    // test_16u::@10
  __b10:
    // [249] (byte) test_16u::i#1 ← ++ (byte) test_16u::i#10 -- vbuz1=_inc_vbuz1 
    inc.z i
    // [250] if((byte) test_16u::i#1!=(byte) 6) goto test_16u::@1 -- vbuz1_neq_vbuc1_then_la1 
    lda #6
    cmp.z i
    bne __b1_from___b10
    jmp __breturn
    // test_16u::@return
  __breturn:
    // [251] return 
    rts
    dividends: .word $ffff, $ffff, $ffff, $ffff, $ffff, $ffff
    divisors: .word 5, 7, $b, $d, $11, $13
}
  // div16u
// Performs division on two 16 bit unsigned words
// Returns the quotient dividend/divisor.
// The remainder will be set into the global variable rem16u
// Implemented using simple binary division
// div16u(word zp(3) dividend, word zp(7) divisor)
div16u: {
    .label return = 9
    .label dividend = 3
    .label divisor = 7
    // [252] (word) divr16u::dividend#1 ← (word) div16u::dividend#0 -- vwuz1=vwuz2 
    lda.z dividend
    sta.z divr16u.dividend
    lda.z dividend+1
    sta.z divr16u.dividend+1
    // [253] (word) divr16u::divisor#0 ← (word) div16u::divisor#0
    // [254] call divr16u 
    // [116] phi from div16u to divr16u [phi:div16u->divr16u]
  divr16u_from_div16u:
    // [116] phi (word) divr16u::divisor#6 = (word) divr16u::divisor#0 [phi:div16u->divr16u#0] -- register_copy 
    // [116] phi (word) divr16u::dividend#5 = (word) divr16u::dividend#1 [phi:div16u->divr16u#1] -- register_copy 
    jsr divr16u
    // [255] (word) divr16u::return#2 ← (word) divr16u::return#0
    jmp __b1
    // div16u::@1
  __b1:
    // [256] (word) div16u::return#0 ← (word) divr16u::return#2
    jmp __breturn
    // div16u::@return
  __breturn:
    // [257] return 
    rts
}
  // test_8u
test_8u: {
    .label dividend = 2
    .label divisor = $15
    .label res = $16
    .label i = $13
    // [259] phi from test_8u to test_8u::@1 [phi:test_8u->test_8u::@1]
  __b1_from_test_8u:
    // [259] phi (byte*) print_line_cursor#41 = (byte*) 1024 [phi:test_8u->test_8u::@1#0] -- pbuz1=pbuc1 
    lda #<$400
    sta.z print_line_cursor
    lda #>$400
    sta.z print_line_cursor+1
    // [259] phi (byte*) print_char_cursor#141 = (byte*) 1024 [phi:test_8u->test_8u::@1#1] -- pbuz1=pbuc1 
    lda #<$400
    sta.z print_char_cursor
    lda #>$400
    sta.z print_char_cursor+1
    // [259] phi (byte) test_8u::i#10 = (byte) 0 [phi:test_8u->test_8u::@1#2] -- vbuz1=vbuc1 
    lda #0
    sta.z i
    jmp __b1
    // test_8u::@1
  __b1:
    // [260] (byte) test_8u::dividend#0 ← *((const byte*) test_8u::dividends + (byte) test_8u::i#10) -- vbuz1=pbuc1_derefidx_vbuz2 
    ldy.z i
    lda dividends,y
    sta.z dividend
    // [261] (byte) test_8u::divisor#0 ← *((const byte*) test_8u::divisors + (byte) test_8u::i#10) -- vbuz1=pbuc1_derefidx_vbuz2 
    ldy.z i
    lda divisors,y
    sta.z divisor
    // [262] (byte) div8u::dividend#1 ← (byte) test_8u::dividend#0 -- vbuaa=vbuz1 
    lda.z dividend
    // [263] (byte) div8u::divisor#1 ← (byte) test_8u::divisor#0 -- vbuxx=vbuz1 
    ldx.z divisor
    // [264] call div8u 
    // [198] phi from test_8u::@1 to div8u [phi:test_8u::@1->div8u]
  div8u_from___b1:
    // [198] phi (byte) div8u::divisor#2 = (byte) div8u::divisor#1 [phi:test_8u::@1->div8u#0] -- register_copy 
    // [198] phi (byte) div8u::dividend#2 = (byte) div8u::dividend#1 [phi:test_8u::@1->div8u#1] -- register_copy 
    jsr div8u
    // [265] (byte) div8u::return#3 ← (byte) div8u::return#0
    jmp __b2
    // test_8u::@2
  __b2:
    // [266] (byte) test_8u::res#0 ← (byte) div8u::return#3 -- vbuz1=vbuaa 
    sta.z res
    // [267] (byte) print_byte::b#3 ← (byte) test_8u::dividend#0
    // [268] call print_byte 
    // [71] phi from test_8u::@2 to print_byte [phi:test_8u::@2->print_byte]
  print_byte_from___b2:
    // [71] phi (byte*) print_char_cursor#139 = (byte*) print_char_cursor#141 [phi:test_8u::@2->print_byte#0] -- register_copy 
    // [71] phi (byte) print_byte::b#7 = (byte) print_byte::b#3 [phi:test_8u::@2->print_byte#1] -- register_copy 
    jsr print_byte
    // [269] phi from test_8u::@2 to test_8u::@3 [phi:test_8u::@2->test_8u::@3]
  __b3_from___b2:
    jmp __b3
    // test_8u::@3
  __b3:
    // [270] call print_str 
    // [79] phi from test_8u::@3 to print_str [phi:test_8u::@3->print_str]
  print_str_from___b3:
    // [79] phi (byte*) print_str::str#15 = (const string) str [phi:test_8u::@3->print_str#0] -- pbuz1=pbuc1 
    lda #<str
    sta.z print_str.str
    lda #>str
    sta.z print_str.str+1
    jsr print_str
    jmp __b4
    // test_8u::@4
  __b4:
    // [271] (byte) print_byte::b#4 ← (byte) test_8u::divisor#0 -- vbuz1=vbuz2 
    lda.z divisor
    sta.z print_byte.b
    // [272] call print_byte 
    // [71] phi from test_8u::@4 to print_byte [phi:test_8u::@4->print_byte]
  print_byte_from___b4:
    // [71] phi (byte*) print_char_cursor#139 = (byte*) print_char_cursor#130 [phi:test_8u::@4->print_byte#0] -- register_copy 
    // [71] phi (byte) print_byte::b#7 = (byte) print_byte::b#4 [phi:test_8u::@4->print_byte#1] -- register_copy 
    jsr print_byte
    // [273] phi from test_8u::@4 to test_8u::@5 [phi:test_8u::@4->test_8u::@5]
  __b5_from___b4:
    jmp __b5
    // test_8u::@5
  __b5:
    // [274] call print_str 
    // [79] phi from test_8u::@5 to print_str [phi:test_8u::@5->print_str]
  print_str_from___b5:
    // [79] phi (byte*) print_str::str#15 = (const string) str1 [phi:test_8u::@5->print_str#0] -- pbuz1=pbuc1 
    lda #<str1
    sta.z print_str.str
    lda #>str1
    sta.z print_str.str+1
    jsr print_str
    jmp __b6
    // test_8u::@6
  __b6:
    // [275] (byte) print_byte::b#5 ← (byte) test_8u::res#0 -- vbuz1=vbuz2 
    lda.z res
    sta.z print_byte.b
    // [276] call print_byte 
    // [71] phi from test_8u::@6 to print_byte [phi:test_8u::@6->print_byte]
  print_byte_from___b6:
    // [71] phi (byte*) print_char_cursor#139 = (byte*) print_char_cursor#130 [phi:test_8u::@6->print_byte#0] -- register_copy 
    // [71] phi (byte) print_byte::b#7 = (byte) print_byte::b#5 [phi:test_8u::@6->print_byte#1] -- register_copy 
    jsr print_byte
    // [277] phi from test_8u::@6 to test_8u::@7 [phi:test_8u::@6->test_8u::@7]
  __b7_from___b6:
    jmp __b7
    // test_8u::@7
  __b7:
    // [278] call print_str 
    // [79] phi from test_8u::@7 to print_str [phi:test_8u::@7->print_str]
  print_str_from___b7:
    // [79] phi (byte*) print_str::str#15 = (const string) str2 [phi:test_8u::@7->print_str#0] -- pbuz1=pbuc1 
    lda #<str2
    sta.z print_str.str
    lda #>str2
    sta.z print_str.str+1
    jsr print_str
    jmp __b8
    // test_8u::@8
  __b8:
    // [279] (byte) print_byte::b#6 ← (byte) rem8u#17 -- vbuz1=vbuxx 
    stx.z print_byte.b
    // [280] call print_byte 
    // [71] phi from test_8u::@8 to print_byte [phi:test_8u::@8->print_byte]
  print_byte_from___b8:
    // [71] phi (byte*) print_char_cursor#139 = (byte*) print_char_cursor#130 [phi:test_8u::@8->print_byte#0] -- register_copy 
    // [71] phi (byte) print_byte::b#7 = (byte) print_byte::b#6 [phi:test_8u::@8->print_byte#1] -- register_copy 
    jsr print_byte
    // [281] phi from test_8u::@8 to test_8u::@9 [phi:test_8u::@8->test_8u::@9]
  __b9_from___b8:
    jmp __b9
    // test_8u::@9
  __b9:
    // [282] call print_ln 
    // [45] phi from test_8u::@9 to print_ln [phi:test_8u::@9->print_ln]
  print_ln_from___b9:
    // [45] phi (byte*) print_line_cursor#39 = (byte*) print_line_cursor#41 [phi:test_8u::@9->print_ln#0] -- register_copy 
    jsr print_ln
    jmp __b10
    // test_8u::@10
  __b10:
    // [283] (byte) test_8u::i#1 ← ++ (byte) test_8u::i#10 -- vbuz1=_inc_vbuz1 
    inc.z i
    // [284] if((byte) test_8u::i#1!=(byte) 6) goto test_8u::@11 -- vbuz1_neq_vbuc1_then_la1 
    lda #6
    cmp.z i
    bne __b11
    jmp __breturn
    // test_8u::@return
  __breturn:
    // [285] return 
    rts
    // test_8u::@11
  __b11:
    // [286] (byte*) print_char_cursor#189 ← (byte*) print_line_cursor#1 -- pbuz1=pbuz2 
    lda.z print_line_cursor
    sta.z print_char_cursor
    lda.z print_line_cursor+1
    sta.z print_char_cursor+1
    // [259] phi from test_8u::@11 to test_8u::@1 [phi:test_8u::@11->test_8u::@1]
  __b1_from___b11:
    // [259] phi (byte*) print_line_cursor#41 = (byte*) print_line_cursor#1 [phi:test_8u::@11->test_8u::@1#0] -- register_copy 
    // [259] phi (byte*) print_char_cursor#141 = (byte*) print_char_cursor#189 [phi:test_8u::@11->test_8u::@1#1] -- register_copy 
    // [259] phi (byte) test_8u::i#10 = (byte) test_8u::i#1 [phi:test_8u::@11->test_8u::@1#2] -- register_copy 
    jmp __b1
    dividends: .byte $ff, $ff, $ff, $ff, $ff, $ff
    divisors: .byte 5, 7, $b, $d, $11, $13
}
  // print_cls
// Clear the screen. Also resets current line/char cursor.
print_cls: {
    // [288] call memset 
    // [290] phi from print_cls to memset [phi:print_cls->memset]
  memset_from_print_cls:
    jsr memset
    jmp __breturn
    // print_cls::@return
  __breturn:
    // [289] return 
    rts
}
  // memset
// Copies the character c (an unsigned char) to the first num characters of the object pointed to by the argument str.
memset: {
    .const c = ' '
    .const num = $3e8
    .label str = $400
    .label end = str+num
    .label dst = $f
    // [291] phi from memset to memset::@1 [phi:memset->memset::@1]
  __b1_from_memset:
    // [291] phi (byte*) memset::dst#2 = (byte*)(const void*) memset::str#0 [phi:memset->memset::@1#0] -- pbuz1=pbuc1 
    lda #<str
    sta.z dst
    lda #>str
    sta.z dst+1
    jmp __b1
    // memset::@1
  __b1:
    // [292] if((byte*) memset::dst#2!=(const byte*) memset::end#0) goto memset::@2 -- pbuz1_neq_pbuc1_then_la1 
    lda.z dst+1
    cmp #>end
    bne __b2
    lda.z dst
    cmp #<end
    bne __b2
    jmp __breturn
    // memset::@return
  __breturn:
    // [293] return 
    rts
    // memset::@2
  __b2:
    // [294] *((byte*) memset::dst#2) ← (const byte) memset::c#0 -- _deref_pbuz1=vbuc1 
    lda #c
    ldy #0
    sta (dst),y
    // [295] (byte*) memset::dst#1 ← ++ (byte*) memset::dst#2 -- pbuz1=_inc_pbuz1 
    inc.z dst
    bne !+
    inc.z dst+1
  !:
    // [291] phi from memset::@2 to memset::@1 [phi:memset::@2->memset::@1]
  __b1_from___b2:
    // [291] phi (byte*) memset::dst#2 = (byte*) memset::dst#1 [phi:memset::@2->memset::@1#0] -- register_copy 
    jmp __b1
}
  // File Data
  print_hextab: .text "0123456789abcdef"
  str: .text " / "
  .byte 0
  str1: .text " = "
  .byte 0
  str2: .text " "
  .byte 0

ASSEMBLER OPTIMIZATIONS
Removing instruction jmp __b1
Removing instruction jmp __bend
Removing instruction jmp __b1
Removing instruction jmp __b2
Removing instruction jmp __b3
Removing instruction jmp __b4
Removing instruction jmp __breturn
Removing instruction jmp __b1
Removing instruction jmp __b2
Removing instruction jmp __b3
Removing instruction jmp __b4
Removing instruction jmp __b5
Removing instruction jmp __b6
Removing instruction jmp __b7
Removing instruction jmp __b8
Removing instruction jmp __b9
Removing instruction jmp __b10
Removing instruction jmp __breturn
Removing instruction jmp __b1
Removing instruction jmp __breturn
Removing instruction jmp __b3
Removing instruction jmp __b2
Removing instruction jmp __breturn
Removing instruction jmp __b1
Removing instruction jmp __b4
Removing instruction jmp __breturn
Removing instruction jmp __b1
Removing instruction jmp __breturn
Removing instruction jmp __b1
Removing instruction jmp __breturn
Removing instruction jmp __b1
Removing instruction jmp __breturn
Removing instruction jmp __b1
Removing instruction jmp __breturn
Removing instruction jmp __b6
Removing instruction jmp __b2
Removing instruction jmp __b7
Removing instruction jmp __b4
Removing instruction jmp __b9
Removing instruction jmp __b8
Removing instruction jmp __breturn
Removing instruction jmp __b1
Removing instruction jmp __b4
Removing instruction jmp __b2
Removing instruction jmp __b5
Removing instruction jmp __b3
Removing instruction jmp __b6
Removing instruction jmp __breturn
Removing instruction jmp __b1
Removing instruction jmp __b2
Removing instruction jmp __b3
Removing instruction jmp __b4
Removing instruction jmp __b5
Removing instruction jmp __b6
Removing instruction jmp __b7
Removing instruction jmp __b8
Removing instruction jmp __b9
Removing instruction jmp __b10
Removing instruction jmp __breturn
Removing instruction jmp __b3
Removing instruction jmp __b2
Removing instruction jmp __breturn
Removing instruction jmp __b1
Removing instruction jmp __b4
Removing instruction jmp __b6
Removing instruction jmp __b2
Removing instruction jmp __b7
Removing instruction jmp __b4
Removing instruction jmp __b9
Removing instruction jmp __b8
Removing instruction jmp __breturn
Removing instruction jmp __b1
Removing instruction jmp __breturn
Removing instruction jmp __b1
Removing instruction jmp __b4
Removing instruction jmp __b2
Removing instruction jmp __b5
Removing instruction jmp __b3
Removing instruction jmp __b6
Removing instruction jmp __breturn
Removing instruction jmp __b1
Removing instruction jmp __b2
Removing instruction jmp __b3
Removing instruction jmp __b4
Removing instruction jmp __b5
Removing instruction jmp __b6
Removing instruction jmp __b7
Removing instruction jmp __b8
Removing instruction jmp __b9
Removing instruction jmp __b10
Removing instruction jmp __breturn
Removing instruction jmp __b1
Removing instruction jmp __breturn
Removing instruction jmp __b1
Removing instruction jmp __b2
Removing instruction jmp __b3
Removing instruction jmp __b4
Removing instruction jmp __b5
Removing instruction jmp __b6
Removing instruction jmp __b7
Removing instruction jmp __b8
Removing instruction jmp __b9
Removing instruction jmp __b10
Removing instruction jmp __breturn
Removing instruction jmp __breturn
Removing instruction jmp __b1
Removing instruction jmp __breturn
Succesful ASM optimization Pass5NextJumpElimination
Removing instruction ldy #0
Replacing instruction lda #<0 with TXA
Removing instruction lda #>0
Removing instruction lda #<0
Removing instruction lda #>0
Removing instruction ldy.z i
Replacing instruction ldx.z divisor with TAX
Replacing instruction lda #0 with TXA
Replacing instruction ldy #0 with TAY
Removing instruction ldy.z i
Succesful ASM optimization Pass5UnnecesaryLoadElimination
Replacing label __bbegin with __b1
Replacing label __b1_from___b10 with __b1
Replacing label __b1_from___b1 with __b1
Replacing label __b1_from___b1 with __b1
Replacing label __b1_from_print_sword with __b1
Replacing label __b2_from___b4 with __b2
Replacing label __b1_from___b2 with __b1
Replacing label __breturn_from___b5 with __breturn
Replacing label __b4_from___b3 with __b4
Replacing label __b2_from___b1 with __b2
Replacing label __b3_from___b2 with __b3
Replacing label __b3_from___b2 with __b3
Replacing label __b1_from___b3 with __b1
Replacing label __b1_from___b10 with __b1
Replacing label __b1_from_print_sbyte with __b1
Replacing label __b2_from___b4 with __b2
Replacing label __breturn_from___b5 with __breturn
Replacing label __b4_from___b3 with __b4
Replacing label __b2_from___b1 with __b2
Replacing label __b3_from___b2 with __b3
Replacing label __b1_from___b3 with __b1
Replacing label __b1_from___b10 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:
Removing instruction test_8u_from___b1:
Removing instruction __b2_from___b1:
Removing instruction test_16u_from___b2:
Removing instruction __b3_from___b2:
Removing instruction test_8s_from___b3:
Removing instruction __b4_from___b3:
Removing instruction test_16s_from___b4:
Removing instruction __b1_from___b10:
Removing instruction __b3_from___b2:
Removing instruction print_str_from___b3:
Removing instruction __b5_from___b4:
Removing instruction print_str_from___b5:
Removing instruction __b7_from___b6:
Removing instruction print_str_from___b7:
Removing instruction __b9_from___b8:
Removing instruction print_ln_from___b9:
Removing instruction __b1_from_print_ln:
Removing instruction __b1_from___b1:
Removing instruction __b3_from_print_sword:
Removing instruction print_char_from___b3:
Removing instruction __b2_from___b3:
Removing instruction __b2_from___b4:
Removing instruction print_word_from___b2:
Removing instruction __b1_from_print_sword:
Removing instruction print_char_from___b1:
Removing instruction __b1_from_print_str:
Removing instruction __b1_from___b2:
Removing instruction __breturn:
Removing instruction __b2_from___b6:
Removing instruction __b7:
Removing instruction __b4_from___b3:
Removing instruction __b4_from___b7:
Removing instruction divr16u_from___b4:
Removing instruction __breturn_from___b5:
Removing instruction __breturn_from___b8:
Removing instruction __b1_from___b3:
Removing instruction __b2_from___b1:
Removing instruction __b2_from___b4:
Removing instruction __b3_from___b2:
Removing instruction __b3_from___b5:
Removing instruction __breturn:
Removing instruction __b1_from___b10:
Removing instruction __b3_from___b2:
Removing instruction print_str_from___b3:
Removing instruction __b5_from___b4:
Removing instruction print_str_from___b5:
Removing instruction __b7_from___b6:
Removing instruction print_str_from___b7:
Removing instruction __b9_from___b8:
Removing instruction print_ln_from___b9:
Removing instruction __b3_from_print_sbyte:
Removing instruction print_char_from___b3:
Removing instruction __b2_from___b3:
Removing instruction __b2_from___b4:
Removing instruction print_byte_from___b2:
Removing instruction __b1_from_print_sbyte:
Removing instruction print_char_from___b1:
Removing instruction __b2_from___b6:
Removing instruction __b7:
Removing instruction __b4_from___b3:
Removing instruction __b4_from___b7:
Removing instruction __breturn_from___b5:
Removing instruction __breturn_from___b8:
Removing instruction __breturn:
Removing instruction __b1_from___b3:
Removing instruction __b2_from___b1:
Removing instruction __b2_from___b4:
Removing instruction __b3_from___b2:
Removing instruction __b3_from___b5:
Removing instruction __b1_from___b10:
Removing instruction __b3_from___b2:
Removing instruction print_str_from___b3:
Removing instruction __b5_from___b4:
Removing instruction print_str_from___b5:
Removing instruction __b7_from___b6:
Removing instruction print_str_from___b7:
Removing instruction __b9_from___b8:
Removing instruction print_ln_from___b9:
Removing instruction __breturn:
Removing instruction __b3_from___b2:
Removing instruction print_str_from___b3:
Removing instruction __b5_from___b4:
Removing instruction print_str_from___b5:
Removing instruction __b7_from___b6:
Removing instruction print_str_from___b7:
Removing instruction __b9_from___b8:
Removing instruction print_ln_from___b9:
Succesful ASM optimization Pass5RedundantLabelElimination
Removing instruction __bend:
Removing instruction print_cls_from_main:
Removing instruction __b1:
Removing instruction __b2:
Removing instruction __b3:
Removing instruction __b4:
Removing instruction __breturn:
Removing instruction __b1_from_test_16s:
Removing instruction __b2:
Removing instruction print_sword_from___b2:
Removing instruction __b3:
Removing instruction __b4:
Removing instruction print_sword_from___b4:
Removing instruction __b5:
Removing instruction __b6:
Removing instruction print_sword_from___b6:
Removing instruction __b7:
Removing instruction __b8:
Removing instruction print_sword_from___b8:
Removing instruction __b9:
Removing instruction __b10:
Removing instruction __breturn:
Removing instruction __breturn:
Removing instruction __b3:
Removing instruction __breturn:
Removing instruction __b4:
Removing instruction __breturn:
Removing instruction print_byte_from_print_word:
Removing instruction __b1:
Removing instruction print_byte_from___b1:
Removing instruction __breturn:
Removing instruction print_char_from_print_byte:
Removing instruction __b1:
Removing instruction print_char_from___b1:
Removing instruction __breturn:
Removing instruction __breturn:
Removing instruction __b1:
Removing instruction __b6:
Removing instruction __b9:
Removing instruction __b8:
Removing instruction __b2_from___b1:
Removing instruction __b1_from_divr16u:
Removing instruction __b4:
Removing instruction __b5:
Removing instruction __b6:
Removing instruction __b1_from_test_8s:
Removing instruction __b2:
Removing instruction print_sbyte_from___b2:
Removing instruction __b3:
Removing instruction __b4:
Removing instruction print_sbyte_from___b4:
Removing instruction __b5:
Removing instruction __b6:
Removing instruction print_sbyte_from___b6:
Removing instruction __b7:
Removing instruction __b8:
Removing instruction print_sbyte_from___b8:
Removing instruction __b9:
Removing instruction __b10:
Removing instruction __breturn:
Removing instruction __b3:
Removing instruction __breturn:
Removing instruction __b4:
Removing instruction __b6:
Removing instruction div8u_from___b4:
Removing instruction __b9:
Removing instruction __b8:
Removing instruction __b2_from___b1:
Removing instruction divr8u_from_div8u:
Removing instruction __b1:
Removing instruction __b1_from_divr8u:
Removing instruction __b4:
Removing instruction __b5:
Removing instruction __b6:
Removing instruction __breturn:
Removing instruction __b1_from_test_16u:
Removing instruction __b2:
Removing instruction print_word_from___b2:
Removing instruction __b3:
Removing instruction __b4:
Removing instruction print_word_from___b4:
Removing instruction __b5:
Removing instruction __b6:
Removing instruction print_word_from___b6:
Removing instruction __b7:
Removing instruction __b8:
Removing instruction print_word_from___b8:
Removing instruction __b9:
Removing instruction __b10:
Removing instruction __breturn:
Removing instruction divr16u_from_div16u:
Removing instruction __b1:
Removing instruction __b1_from_test_8u:
Removing instruction div8u_from___b1:
Removing instruction __b2:
Removing instruction print_byte_from___b2:
Removing instruction __b3:
Removing instruction __b4:
Removing instruction print_byte_from___b4:
Removing instruction __b5:
Removing instruction __b6:
Removing instruction print_byte_from___b6:
Removing instruction __b7:
Removing instruction __b8:
Removing instruction print_byte_from___b8:
Removing instruction __b9:
Removing instruction __b10:
Removing instruction __breturn:
Removing instruction __b1_from___b11:
Removing instruction memset_from_print_cls:
Removing instruction __breturn:
Removing instruction __b1_from_memset:
Removing instruction __breturn:
Removing instruction __b1_from___b2:
Succesful ASM optimization Pass5UnusedLabelElimination
Updating BasicUpstart to call main directly
Removing instruction jsr main
Succesful ASM optimization Pass5SkipBegin
Skipping double jump to __breturn in beq __b5
Replacing jump to rts with rts in jmp __breturn
Replacing jump to rts with rts in jmp __breturn
Succesful ASM optimization Pass5DoubleJumpElimination
Removing instruction jmp __b1
Removing instruction jmp __b1
Removing instruction jmp __b1
Removing instruction jmp __b1
Removing instruction jmp __b1
Succesful ASM optimization Pass5NextJumpElimination
Removing instruction __b1:
Removing instruction __b5:
Removing instruction __breturn:
Succesful ASM optimization Pass5UnusedLabelElimination
Removing unreachable instruction rts
Succesful ASM optimization Pass5UnreachableCodeElimination

FINAL SYMBOL TABLE
(label) @1
(label) @begin
(label) @end
(const byte) RADIX::BINARY = (number) 2
(const byte) RADIX::DECIMAL = (number) $a
(const byte) RADIX::HEXADECIMAL = (number) $10
(const byte) RADIX::OCTAL = (number) 8
(signed word()) div16s((signed word) div16s::dividend , (signed word) div16s::divisor)
(label) div16s::@1
(label) div16s::@return
(signed word) div16s::dividend
(signed word) div16s::dividend#0 dividend zp[2]:3 6.5
(signed word) div16s::divisor
(signed word) div16s::divisor#0 divisor zp[2]:17 6.5
(signed word) div16s::return
(signed word) div16s::return#0 return zp[2]:9 4.333333333333333
(signed word) div16s::return#2 return zp[2]:9 22.0
(word()) div16u((word) div16u::dividend , (word) div16u::divisor)
(label) div16u::@1
(label) div16u::@return
(word) div16u::dividend
(word) div16u::dividend#0 dividend zp[2]:3 6.5
(word) div16u::divisor
(word) div16u::divisor#0 divisor zp[2]:7 6.5
(word) div16u::return
(word) div16u::return#0 return zp[2]:9 4.333333333333333
(word) div16u::return#2 return zp[2]:9 22.0
(signed byte()) div8s((signed byte) div8s::dividend , (signed byte) div8s::divisor)
(signed byte~) div8s::$11 reg byte a 4.0
(label) div8s::@1
(label) div8s::@2
(label) div8s::@3
(label) div8s::@4
(label) div8s::@5
(label) div8s::@6
(label) div8s::@7
(label) div8s::@8
(label) div8s::@9
(label) div8s::@return
(signed byte) div8s::dividend
(signed byte) div8s::dividend#0 reg byte y 5.0
(byte) div8s::dividendu
(signed byte) div8s::dividendu#1 reg byte a 2.0
(byte) div8s::dividendu#3 reg byte y 0.8571428571428571
(byte) div8s::dividendu#7 reg byte y 4.0
(byte) div8s::dividendu#8 reg byte y 4.0
(signed byte) div8s::divisor
(signed byte) div8s::divisor#0 reg byte x 2.142857142857143
(byte) div8s::divisoru
(signed byte) div8s::divisoru#1 reg byte x 1.0
(byte) div8s::divisoru#3 reg byte x 3.0
(byte) div8s::divisoru#4 reg byte x 4.0
(byte) div8s::divisoru#5 reg byte x 4.0
(byte) div8s::neg
(byte) div8s::neg#2 neg zp[1]:14 2.0
(byte) div8s::neg#3 neg zp[1]:14 1.0
(byte) div8s::neg#4 neg zp[1]:14 1.0
(byte) div8s::resultu
(byte) div8s::resultu#0 reg byte y 0.5
(signed byte) div8s::return
(signed byte) div8s::return#1 reg byte a 4.0
(signed byte) div8s::return#2 reg byte a 5.0
(signed byte) div8s::return#3 reg byte a 22.0
(signed byte) div8s::return#7 reg byte a 2.0
(byte()) div8u((byte) div8u::dividend , (byte) div8u::divisor)
(label) div8u::@1
(label) div8u::@return
(byte) div8u::dividend
(byte) div8u::dividend#0 reg byte a 2.0
(byte) div8u::dividend#1 reg byte a 11.0
(byte) div8u::dividend#2 reg byte a 15.0
(byte) div8u::divisor
(byte) div8u::divisor#0 reg byte x 4.0
(byte) div8u::divisor#1 reg byte x 22.0
(byte) div8u::divisor#2 reg byte x 7.5
(byte) div8u::return
(byte) div8u::return#0 reg byte a 3.75
(byte) div8u::return#2 reg byte a 4.0
(byte) div8u::return#3 reg byte a 22.0
(signed word()) divr16s((signed word) divr16s::dividend , (signed word) divr16s::divisor , (signed word) divr16s::rem)
(signed word~) divr16s::$16 zp[2]:11 4.0
(label) divr16s::@1
(label) divr16s::@2
(label) divr16s::@3
(label) divr16s::@4
(label) divr16s::@5
(label) divr16s::@6
(label) divr16s::@7
(label) divr16s::@8
(label) divr16s::@9
(label) divr16s::@return
(signed word) divr16s::dividend
(signed word) divr16s::dividend#0 dividend zp[2]:5 2.0
(word) divr16s::dividendu
(signed word) divr16s::dividendu#1 dividendu zp[2]:5 2.0
(word) divr16s::dividendu#3 dividendu zp[2]:5 0.8571428571428571
(word) divr16s::dividendu#7 dividendu zp[2]:5 4.0
(word) divr16s::dividendu#8 dividendu zp[2]:5 4.0
(signed word) divr16s::divisor
(signed word) divr16s::divisor#0 divisor zp[2]:7 0.8571428571428571
(word) divr16s::divisoru
(signed word) divr16s::divisoru#1 divisoru zp[2]:7 1.0
(word) divr16s::divisoru#3 divisoru zp[2]:7 3.0
(word) divr16s::divisoru#4 divisoru zp[2]:7 4.0
(word) divr16s::divisoru#5 divisoru zp[2]:7 4.0
(byte) divr16s::neg
(byte) divr16s::neg#2 reg byte y 2.0
(byte) divr16s::neg#3 reg byte y 1.0
(byte) divr16s::neg#4 reg byte y 1.0
(signed word) divr16s::rem
(word) divr16s::remu
(word) divr16s::resultu
(word) divr16s::resultu#0 resultu zp[2]:9 0.5
(signed word) divr16s::return
(signed word) divr16s::return#1 return zp[2]:9 4.0
(signed word) divr16s::return#2 return zp[2]:9 2.0
(signed word) divr16s::return#3 return zp[2]:9 4.0
(signed word) divr16s::return#7 return zp[2]:9 2.0
(word()) divr16u((word) divr16u::dividend , (word) divr16u::divisor , (word) divr16u::rem)
(byte~) divr16u::$1 reg byte a 202.0
(byte~) divr16u::$2 reg byte a 202.0
(label) divr16u::@1
(label) divr16u::@2
(label) divr16u::@3
(label) divr16u::@4
(label) divr16u::@5
(label) divr16u::@6
(label) divr16u::@return
(word) divr16u::dividend
(word) divr16u::dividend#0 dividend zp[2]:5 25.25
(word) divr16u::dividend#1 dividend zp[2]:5 2.0
(word) divr16u::dividend#2 dividend zp[2]:5 2.0
(word) divr16u::dividend#3 dividend zp[2]:5 43.57142857142858
(word) divr16u::dividend#5 dividend zp[2]:5 6.0
(word) divr16u::divisor
(word) divr16u::divisor#0 divisor zp[2]:7 4.0
(word) divr16u::divisor#1 divisor zp[2]:7 4.0
(word) divr16u::divisor#6 divisor zp[2]:7 12.875
(byte) divr16u::i
(byte) divr16u::i#1 reg byte x 151.5
(byte) divr16u::i#2 reg byte x 15.538461538461538
(word) divr16u::quotient
(word) divr16u::quotient#1 quotient zp[2]:9 151.5
(word) divr16u::quotient#2 quotient zp[2]:9 101.0
(word) divr16u::quotient#3 quotient zp[2]:9 25.25
(word) divr16u::rem
(word) divr16u::rem#0 rem zp[2]:11 75.75
(word) divr16u::rem#1 rem zp[2]:11 202.0
(word) divr16u::rem#11 rem zp[2]:11 101.66666666666667
(word) divr16u::rem#2 rem zp[2]:11 202.0
(word) divr16u::rem#5 rem zp[2]:11 202.0
(word) divr16u::rem#6 rem zp[2]:11 101.0
(word) divr16u::return
(word) divr16u::return#0 return zp[2]:9 43.85714285714286
(word) divr16u::return#2 return zp[2]:9 4.0
(word) divr16u::return#3 return zp[2]:9 4.0
(byte()) divr8u((byte) divr8u::dividend , (byte) divr8u::divisor , (byte) divr8u::rem)
(byte~) divr8u::$1 reg byte a 202.0
(label) divr8u::@1
(label) divr8u::@2
(label) divr8u::@3
(label) divr8u::@4
(label) divr8u::@5
(label) divr8u::@6
(label) divr8u::@return
(byte) divr8u::dividend
(byte) divr8u::dividend#0 dividend zp[1]:20 1.3333333333333333
(byte) divr8u::dividend#1 dividend zp[1]:20 25.25
(byte) divr8u::dividend#2 dividend zp[1]:20 50.83333333333333
(byte) divr8u::divisor
(byte) divr8u::divisor#0 divisor zp[1]:21 12.75
(byte) divr8u::i
(byte) divr8u::i#1 reg byte x 151.5
(byte) divr8u::i#2 reg byte x 16.833333333333332
(byte) divr8u::quotient
(byte) divr8u::quotient#1 quotient zp[1]:22 151.5
(byte) divr8u::quotient#2 quotient zp[1]:22 101.0
(byte) divr8u::quotient#3 quotient zp[1]:22 28.857142857142858
(byte) divr8u::rem
(byte) divr8u::rem#1 reg byte y 101.0
(byte) divr8u::rem#10 reg byte y 101.66666666666667
(byte) divr8u::rem#2 reg byte y 202.0
(byte) divr8u::rem#3 reg byte y 202.0
(byte) divr8u::rem#4 reg byte y 202.0
(byte) divr8u::rem#5 reg byte y 101.0
(byte) divr8u::return
(byte) divr8u::return#0 reg byte a 4.0
(byte) divr8u::return#1 return zp[1]:22 50.83333333333333
(void()) main()
(label) main::@1
(label) main::@2
(label) main::@3
(label) main::@4
(label) main::@return
(void*()) memset((void*) memset::str , (byte) memset::c , (word) memset::num)
(label) memset::@1
(label) memset::@2
(label) memset::@return
(byte) memset::c
(const byte) memset::c#0 c = (byte) ' '
(byte*) memset::dst
(byte*) memset::dst#1 dst zp[2]:15 22.0
(byte*) memset::dst#2 dst zp[2]:15 14.666666666666666
(byte*) memset::end
(const byte*) memset::end#0 end = (byte*)(const void*) memset::str#0+(const word) memset::num#0
(word) memset::num
(const word) memset::num#0 num = (word) $3e8
(void*) memset::return
(void*) memset::str
(const void*) memset::str#0 str = (void*)(byte*) 1024
(void()) print_byte((byte) print_byte::b)
(byte~) print_byte::$0 reg byte a 4.0
(byte~) print_byte::$2 reg byte a 4.0
(label) print_byte::@1
(label) print_byte::@return
(byte) print_byte::b
(byte) print_byte::b#0 b zp[1]:2 4.0
(byte) print_byte::b#1 b zp[1]:2 4.0
(byte) print_byte::b#2 b zp[1]:2 4.0
(byte) print_byte::b#3 b zp[1]:2 22.0
(byte) print_byte::b#4 b zp[1]:2 22.0
(byte) print_byte::b#5 b zp[1]:2 22.0
(byte) print_byte::b#6 b zp[1]:2 22.0
(byte) print_byte::b#7 b zp[1]:2 13.5
(void()) print_char((byte) print_char::ch)
(label) print_char::@return
(byte) print_char::ch
(byte) print_char::ch#4 reg byte a 4.0
(byte) print_char::ch#5 reg byte a 4.0
(byte) print_char::ch#6 reg byte a 6.0
(byte*) print_char_cursor
(byte*) print_char_cursor#1 print_char_cursor zp[2]:5 101.0
(byte*) print_char_cursor#130 print_char_cursor zp[2]:5 15.607142857142856
(byte*) print_char_cursor#132 print_char_cursor zp[2]:5 12.0
(byte*) print_char_cursor#135 print_char_cursor zp[2]:5 12.0
(byte*) print_char_cursor#138 print_char_cursor zp[2]:5 24.0
(byte*) print_char_cursor#139 print_char_cursor zp[2]:5 17.333333333333332
(byte*) print_char_cursor#141 print_char_cursor zp[2]:5 2.4444444444444446
(byte*) print_char_cursor#163 print_char_cursor zp[2]:5 22.0
(byte*) print_char_cursor#167 print_char_cursor zp[2]:5 22.0
(byte*) print_char_cursor#172 print_char_cursor zp[2]:5 22.0
(byte*) print_char_cursor#189 print_char_cursor zp[2]:5 22.0
(byte*) print_char_cursor#19 print_char_cursor zp[2]:5 1.8225806451612903
(byte*) print_char_cursor#84 print_char_cursor zp[2]:5 8.0
(void()) print_cls()
(label) print_cls::@return
(const byte*) print_hextab[]  = (string) "0123456789abcdef"z
(byte*) print_line_cursor
(byte*) print_line_cursor#1 print_line_cursor zp[2]:15 3.833333333333334
(byte*) print_line_cursor#20 print_line_cursor zp[2]:15 204.0
(byte*) print_line_cursor#39 print_line_cursor zp[2]:15 46.0
(byte*) print_line_cursor#41 print_line_cursor zp[2]:15 0.9565217391304348
(void()) print_ln()
(label) print_ln::@1
(label) print_ln::@return
(void()) print_sbyte((signed byte) print_sbyte::b)
(label) print_sbyte::@1
(label) print_sbyte::@2
(label) print_sbyte::@3
(label) print_sbyte::@4
(label) print_sbyte::@return
(signed byte) print_sbyte::b
(signed byte) print_sbyte::b#0 b zp[1]:2 4.0
(signed byte) print_sbyte::b#1 b zp[1]:2 11.0
(signed byte) print_sbyte::b#10 b zp[1]:2 8.333333333333332
(signed byte) print_sbyte::b#2 b zp[1]:2 22.0
(signed byte) print_sbyte::b#3 b zp[1]:2 22.0
(signed byte) print_sbyte::b#4 b zp[1]:2 22.0
(signed byte) print_sbyte::b#7 b zp[1]:2 4.0
(byte*) print_screen
(void()) print_str((byte*) print_str::str)
(label) print_str::@1
(label) print_str::@2
(label) print_str::@return
(byte*) print_str::str
(byte*) print_str::str#0 str zp[2]:3 202.0
(byte*) print_str::str#13 str zp[2]:3 101.5
(byte*) print_str::str#15 str zp[2]:3 2.0
(void()) print_sword((signed word) print_sword::w)
(label) print_sword::@1
(label) print_sword::@2
(label) print_sword::@3
(label) print_sword::@4
(label) print_sword::@return
(signed word) print_sword::w
(signed word) print_sword::w#0 w zp[2]:3 4.0
(signed word) print_sword::w#1 w zp[2]:3 11.0
(signed word) print_sword::w#10 w zp[2]:3 8.333333333333332
(signed word) print_sword::w#2 w zp[2]:3 22.0
(signed word) print_sword::w#3 w zp[2]:3 22.0
(signed word) print_sword::w#4 w zp[2]:3 22.0
(signed word) print_sword::w#7 w zp[2]:3 4.0
(void()) print_word((word) print_word::w)
(label) print_word::@1
(label) print_word::@return
(word) print_word::w
(word) print_word::w#0 w zp[2]:3 4.0
(word) print_word::w#1 w zp[2]:3 11.0
(word) print_word::w#2 w zp[2]:3 22.0
(word) print_word::w#3 w zp[2]:3 22.0
(word) print_word::w#4 w zp[2]:3 22.0
(word) print_word::w#5 w zp[2]:3 16.666666666666664
(signed word) rem16s
(signed word) rem16s#11 rem16s zp[2]:11 0.6818181818181819
(signed word) rem16s#2 rem16s zp[2]:11 2.0
(signed word) rem16s#37 rem16s zp[2]:11 4.0
(word) rem16u
(word) rem16u#1 rem16u zp[2]:11 0.48148148148148145
(signed byte) rem8s
(signed byte) rem8s#2 reg byte x 2.0
(signed byte) rem8s#3 reg byte x 0.8333333333333335
(signed byte) rem8s#33 reg byte x 4.0
(byte) rem8u
(byte) rem8u#17 reg byte x 0.5
(const string) str[]  = (string) " / "
(const string) str1[]  = (string) " = "
(const string) str2[]  = (string) " "
(void()) test_16s()
(byte~) test_16s::$11 reg byte x 16.5
(label) test_16s::@1
(label) test_16s::@10
(label) test_16s::@2
(label) test_16s::@3
(label) test_16s::@4
(label) test_16s::@5
(label) test_16s::@6
(label) test_16s::@7
(label) test_16s::@8
(label) test_16s::@9
(label) test_16s::@return
(signed word) test_16s::dividend
(signed word) test_16s::dividend#0 dividend zp[2]:3 4.714285714285714
(const signed word*) test_16s::dividends[]  = { (signed word) $7fff, (signed word) $7fff, (signed word) -$7fff, (signed word) -$7fff, (signed word) $7fff, (signed word) -$7fff }
(signed word) test_16s::divisor
(signed word) test_16s::divisor#0 divisor zp[2]:17 3.0
(const signed word*) test_16s::divisors[]  = { (signed word) 5, (signed word) -7, (signed word) $b, (signed word) -$d, (signed word) -$11, (signed word) $13 }
(byte) test_16s::i
(byte) test_16s::i#1 i zp[1]:13 16.5
(byte) test_16s::i#10 i zp[1]:13 1.2692307692307692
(signed word) test_16s::res
(signed word) test_16s::res#0 res zp[2]:9 2.2
(void()) test_16u()
(byte~) test_16u::$11 reg byte x 16.5
(label) test_16u::@1
(label) test_16u::@10
(label) test_16u::@2
(label) test_16u::@3
(label) test_16u::@4
(label) test_16u::@5
(label) test_16u::@6
(label) test_16u::@7
(label) test_16u::@8
(label) test_16u::@9
(label) test_16u::@return
(word) test_16u::dividend
(word) test_16u::dividend#0 dividend zp[2]:3 4.714285714285714
(const word*) test_16u::dividends[]  = { (word) $ffff, (word) $ffff, (word) $ffff, (word) $ffff, (word) $ffff, (word) $ffff }
(word) test_16u::divisor
(word) test_16u::divisor#0 divisor zp[2]:7 3.0
(const word*) test_16u::divisors[]  = { (word) 5, (word) 7, (word) $b, (word) $d, (word) $11, (word) $13 }
(byte) test_16u::i
(byte) test_16u::i#1 i zp[1]:14 16.5
(byte) test_16u::i#10 i zp[1]:14 1.2692307692307692
(word) test_16u::res
(word) test_16u::res#0 res zp[2]:9 2.2
(void()) test_8s()
(label) test_8s::@1
(label) test_8s::@10
(label) test_8s::@2
(label) test_8s::@3
(label) test_8s::@4
(label) test_8s::@5
(label) test_8s::@6
(label) test_8s::@7
(label) test_8s::@8
(label) test_8s::@9
(label) test_8s::@return
(signed byte) test_8s::dividend
(signed byte) test_8s::dividend#0 dividend zp[1]:2 4.714285714285714
(const signed byte*) test_8s::dividends[]  = { (signed byte) $7f, (signed byte) -$7f, (signed byte) -$7f, (signed byte) $7f, (signed byte) $7f, (signed byte) $7f }
(signed byte) test_8s::divisor
(signed byte) test_8s::divisor#0 divisor zp[1]:19 3.0
(const signed byte*) test_8s::divisors[]  = { (signed byte) 5, (signed byte) 7, (signed byte) -$b, (signed byte) -$d, (signed byte) $11, (signed byte) $13 }
(byte) test_8s::i
(byte) test_8s::i#1 i zp[1]:13 16.5
(byte) test_8s::i#10 i zp[1]:13 1.76
(signed byte) test_8s::res
(signed byte) test_8s::res#0 res zp[1]:20 2.2
(void()) test_8u()
(label) test_8u::@1
(label) test_8u::@10
(label) test_8u::@11
(label) test_8u::@2
(label) test_8u::@3
(label) test_8u::@4
(label) test_8u::@5
(label) test_8u::@6
(label) test_8u::@7
(label) test_8u::@8
(label) test_8u::@9
(label) test_8u::@return
(byte) test_8u::dividend
(byte) test_8u::dividend#0 dividend zp[1]:2 4.714285714285714
(const byte*) test_8u::dividends[]  = { (byte) $ff, (byte) $ff, (byte) $ff, (byte) $ff, (byte) $ff, (byte) $ff }
(byte) test_8u::divisor
(byte) test_8u::divisor#0 divisor zp[1]:21 3.3000000000000003
(const byte*) test_8u::divisors[]  = { (byte) 5, (byte) 7, (byte) $b, (byte) $d, (byte) $11, (byte) $13 }
(byte) test_8u::i
(byte) test_8u::i#1 i zp[1]:19 11.0
(byte) test_8u::i#10 i zp[1]:19 1.8333333333333333
(byte) test_8u::res
(byte) test_8u::res#0 res zp[1]:22 2.4444444444444446

reg byte a [ print_char::ch#6 print_char::ch#4 print_char::ch#5 ]
zp[1]:2 [ print_byte::b#7 print_byte::b#0 print_byte::b#1 print_byte::b#2 print_byte::b#3 print_byte::b#4 print_byte::b#5 print_byte::b#6 print_sbyte::b#7 print_sbyte::b#0 print_sbyte::b#10 print_sbyte::b#1 print_sbyte::b#2 print_sbyte::b#3 print_sbyte::b#4 test_8u::dividend#0 test_8s::dividend#0 ]
zp[2]:3 [ print_str::str#13 print_str::str#15 print_str::str#0 print_sword::w#7 print_sword::w#0 print_sword::w#10 print_sword::w#1 print_sword::w#2 print_sword::w#3 print_sword::w#4 print_word::w#5 print_word::w#0 print_word::w#1 print_word::w#2 print_word::w#3 print_word::w#4 test_16s::dividend#0 div16s::dividend#0 test_16u::dividend#0 div16u::dividend#0 ]
zp[2]:5 [ divr16s::dividendu#3 divr16s::dividendu#7 divr16s::dividendu#8 divr16u::dividend#3 divr16u::dividend#5 divr16u::dividend#1 divr16u::dividend#2 divr16u::dividend#0 divr16s::dividend#0 divr16s::dividendu#1 print_char_cursor#138 print_char_cursor#84 print_char_cursor#139 print_char_cursor#19 print_char_cursor#135 print_char_cursor#132 print_char_cursor#163 print_char_cursor#130 print_char_cursor#172 print_char_cursor#141 print_char_cursor#1 print_char_cursor#167 print_char_cursor#189 ]
zp[2]:7 [ divr16s::divisoru#3 divr16s::divisoru#4 divr16s::divisoru#5 divr16u::divisor#6 divr16u::divisor#0 divr16u::divisor#1 divr16s::divisor#0 divr16s::divisoru#1 test_16u::divisor#0 div16u::divisor#0 ]
reg byte y [ divr16s::neg#4 divr16s::neg#2 divr16s::neg#3 ]
zp[2]:9 [ divr16s::return#2 divr16s::return#1 divr16s::return#7 divr16s::resultu#0 divr16s::return#3 divr16u::quotient#3 divr16u::return#0 divr16u::quotient#1 divr16u::quotient#2 divr16u::return#3 divr16u::return#2 div16s::return#2 test_16s::res#0 div16s::return#0 div16u::return#2 test_16u::res#0 div16u::return#0 ]
zp[2]:11 [ rem16s#11 rem16s#2 rem16s#37 divr16s::$16 rem16u#1 divr16u::rem#5 divr16u::rem#11 divr16u::rem#6 divr16u::rem#0 divr16u::rem#1 divr16u::rem#2 ]
reg byte x [ divr16u::i#2 divr16u::i#1 ]
zp[1]:13 [ test_8s::i#10 test_8s::i#1 test_16s::i#10 test_16s::i#1 ]
reg byte y [ div8s::dividendu#3 div8s::dividendu#7 div8s::dividendu#8 ]
reg byte x [ div8s::divisoru#3 div8s::divisoru#4 div8s::divisoru#5 ]
reg byte a [ div8s::return#2 div8s::return#1 div8s::return#7 ]
reg byte x [ rem8s#3 rem8s#2 rem8s#33 ]
reg byte a [ div8u::dividend#2 div8u::dividend#0 div8u::dividend#1 ]
reg byte x [ div8u::divisor#2 div8u::divisor#0 div8u::divisor#1 ]
reg byte y [ divr8u::rem#4 divr8u::rem#10 divr8u::rem#5 divr8u::rem#1 divr8u::rem#2 divr8u::rem#3 ]
reg byte x [ divr8u::i#2 divr8u::i#1 ]
zp[1]:14 [ test_16u::i#10 test_16u::i#1 div8s::neg#4 div8s::neg#2 div8s::neg#3 ]
zp[2]:15 [ memset::dst#2 memset::dst#1 print_line_cursor#20 print_line_cursor#39 print_line_cursor#1 print_line_cursor#41 ]
reg byte x [ test_16s::$11 ]
zp[2]:17 [ test_16s::divisor#0 div16s::divisor#0 ]
reg byte a [ print_byte::$0 ]
reg byte a [ print_byte::$2 ]
reg byte a [ divr16u::$1 ]
reg byte a [ divr16u::$2 ]
zp[1]:19 [ test_8s::divisor#0 test_8u::i#10 test_8u::i#1 ]
reg byte y [ div8s::dividend#0 ]
reg byte x [ div8s::divisor#0 ]
reg byte a [ div8s::return#3 ]
zp[1]:20 [ test_8s::res#0 divr8u::dividend#2 divr8u::dividend#0 divr8u::dividend#1 ]
reg byte a [ div8u::return#2 ]
reg byte y [ div8s::resultu#0 ]
reg byte a [ div8s::$11 ]
reg byte x [ div8s::divisoru#1 ]
reg byte a [ div8s::dividendu#1 ]
reg byte a [ divr8u::return#0 ]
reg byte a [ div8u::return#0 ]
reg byte a [ divr8u::$1 ]
reg byte x [ rem8u#17 ]
reg byte x [ test_16u::$11 ]
zp[1]:21 [ test_8u::divisor#0 divr8u::divisor#0 ]
reg byte a [ div8u::return#3 ]
zp[1]:22 [ test_8u::res#0 divr8u::quotient#3 divr8u::return#1 divr8u::quotient#1 divr8u::quotient#2 ]


FINAL ASSEMBLER
Score: 33209

  // File Comments
// Test the binary division library
  // Upstart
.pc = $801 "Basic"
:BasicUpstart(main)
.pc = $80d "Program"
  // Global Constants & labels
  .label print_char_cursor = 5
  .label print_line_cursor = $f
  // Remainder after unsigned 16-bit division
  .label rem16u = $b
  // Remainder after signed 16 bit division
  .label rem16s = $b
  // @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: {
    // print_cls()
    // [5] call print_cls 
    // [287] phi from main to print_cls [phi:main->print_cls]
    jsr print_cls
    // [6] phi from main to main::@1 [phi:main->main::@1]
    // main::@1
    // test_8u()
    // [7] call test_8u 
    // [258] phi from main::@1 to test_8u [phi:main::@1->test_8u]
    jsr test_8u
    // [8] phi from main::@1 to main::@2 [phi:main::@1->main::@2]
    // main::@2
    // test_16u()
    // [9] call test_16u 
    // [222] phi from main::@2 to test_16u [phi:main::@2->test_16u]
    jsr test_16u
    // [10] phi from main::@2 to main::@3 [phi:main::@2->main::@3]
    // main::@3
    // test_8s()
    // [11] call test_8s 
    // [134] phi from main::@3 to test_8s [phi:main::@3->test_8s]
    jsr test_8s
    // [12] phi from main::@3 to main::@4 [phi:main::@3->main::@4]
    // main::@4
    // test_16s()
    // [13] call test_16s 
    // [15] phi from main::@4 to test_16s [phi:main::@4->test_16s]
    jsr test_16s
    // main::@return
    // }
    // [14] return 
    rts
}
  // test_16s
test_16s: {
    .label dividend = 3
    .label divisor = $11
    .label res = 9
    .label i = $d
    // [16] phi from test_16s to test_16s::@1 [phi:test_16s->test_16s::@1]
    // [16] phi (byte) test_16s::i#10 = (byte) 0 [phi:test_16s->test_16s::@1#0] -- vbuz1=vbuc1 
    lda #0
    sta.z i
    // [16] phi from test_16s::@10 to test_16s::@1 [phi:test_16s::@10->test_16s::@1]
    // [16] phi (byte) test_16s::i#10 = (byte) test_16s::i#1 [phi:test_16s::@10->test_16s::@1#0] -- register_copy 
    // test_16s::@1
  __b1:
    // dividend = dividends[i]
    // [17] (byte~) test_16s::$11 ← (byte) test_16s::i#10 << (byte) 1 -- vbuxx=vbuz1_rol_1 
    lda.z i
    asl
    tax
    // [18] (signed word) test_16s::dividend#0 ← *((const signed word*) test_16s::dividends + (byte~) test_16s::$11) -- vwsz1=pwsc1_derefidx_vbuxx 
    lda dividends,x
    sta.z dividend
    lda dividends+1,x
    sta.z dividend+1
    // divisor = divisors[i]
    // [19] (signed word) test_16s::divisor#0 ← *((const signed word*) test_16s::divisors + (byte~) test_16s::$11) -- vwsz1=pwsc1_derefidx_vbuxx 
    lda divisors,x
    sta.z divisor
    lda divisors+1,x
    sta.z divisor+1
    // div16s(dividend, divisor)
    // [20] (signed word) div16s::dividend#0 ← (signed word) test_16s::dividend#0
    // [21] (signed word) div16s::divisor#0 ← (signed word) test_16s::divisor#0
    // [22] call div16s 
    jsr div16s
    // [23] (signed word) div16s::return#2 ← (signed word) div16s::return#0
    // test_16s::@2
    // res = div16s(dividend, divisor)
    // [24] (signed word) test_16s::res#0 ← (signed word) div16s::return#2
    // print_sword(dividend)
    // [25] (signed word) print_sword::w#1 ← (signed word) test_16s::dividend#0
    // [26] (byte*) print_char_cursor#163 ← (byte*) print_line_cursor#1 -- pbuz1=pbuz2 
    lda.z print_line_cursor
    sta.z print_char_cursor
    lda.z print_line_cursor+1
    sta.z print_char_cursor+1
    // print_sword(dividend)
    // [27] call print_sword 
    // [50] phi from test_16s::@2 to print_sword [phi:test_16s::@2->print_sword]
    // [50] phi (byte*) print_char_cursor#132 = (byte*) print_char_cursor#163 [phi:test_16s::@2->print_sword#0] -- register_copy 
    // [50] phi (signed word) print_sword::w#10 = (signed word) print_sword::w#1 [phi:test_16s::@2->print_sword#1] -- register_copy 
    jsr print_sword
    // [28] phi from test_16s::@2 to test_16s::@3 [phi:test_16s::@2->test_16s::@3]
    // test_16s::@3
    // print_str(" / ")
    // [29] call print_str 
    // [79] phi from test_16s::@3 to print_str [phi:test_16s::@3->print_str]
    // [79] phi (byte*) print_str::str#15 = (const string) str [phi:test_16s::@3->print_str#0] -- pbuz1=pbuc1 
    lda #<str
    sta.z print_str.str
    lda #>str
    sta.z print_str.str+1
    jsr print_str
    // test_16s::@4
    // print_sword(divisor)
    // [30] (signed word) print_sword::w#2 ← (signed word) test_16s::divisor#0 -- vwsz1=vwsz2 
    lda.z divisor
    sta.z print_sword.w
    lda.z divisor+1
    sta.z print_sword.w+1
    // [31] call print_sword 
    // [50] phi from test_16s::@4 to print_sword [phi:test_16s::@4->print_sword]
    // [50] phi (byte*) print_char_cursor#132 = (byte*) print_char_cursor#130 [phi:test_16s::@4->print_sword#0] -- register_copy 
    // [50] phi (signed word) print_sword::w#10 = (signed word) print_sword::w#2 [phi:test_16s::@4->print_sword#1] -- register_copy 
    jsr print_sword
    // [32] phi from test_16s::@4 to test_16s::@5 [phi:test_16s::@4->test_16s::@5]
    // test_16s::@5
    // print_str(" = ")
    // [33] call print_str 
    // [79] phi from test_16s::@5 to print_str [phi:test_16s::@5->print_str]
    // [79] phi (byte*) print_str::str#15 = (const string) str1 [phi:test_16s::@5->print_str#0] -- pbuz1=pbuc1 
    lda #<str1
    sta.z print_str.str
    lda #>str1
    sta.z print_str.str+1
    jsr print_str
    // test_16s::@6
    // print_sword(res)
    // [34] (signed word) print_sword::w#3 ← (signed word) test_16s::res#0 -- vwsz1=vwsz2 
    lda.z res
    sta.z print_sword.w
    lda.z res+1
    sta.z print_sword.w+1
    // [35] call print_sword 
    // [50] phi from test_16s::@6 to print_sword [phi:test_16s::@6->print_sword]
    // [50] phi (byte*) print_char_cursor#132 = (byte*) print_char_cursor#130 [phi:test_16s::@6->print_sword#0] -- register_copy 
    // [50] phi (signed word) print_sword::w#10 = (signed word) print_sword::w#3 [phi:test_16s::@6->print_sword#1] -- register_copy 
    jsr print_sword
    // [36] phi from test_16s::@6 to test_16s::@7 [phi:test_16s::@6->test_16s::@7]
    // test_16s::@7
    // print_str(" ")
    // [37] call print_str 
    // [79] phi from test_16s::@7 to print_str [phi:test_16s::@7->print_str]
    // [79] phi (byte*) print_str::str#15 = (const string) str2 [phi:test_16s::@7->print_str#0] -- pbuz1=pbuc1 
    lda #<str2
    sta.z print_str.str
    lda #>str2
    sta.z print_str.str+1
    jsr print_str
    // test_16s::@8
    // print_sword(rem16s)
    // [38] (signed word) print_sword::w#4 ← (signed word) rem16s#11 -- vwsz1=vwsz2 
    lda.z rem16s
    sta.z print_sword.w
    lda.z rem16s+1
    sta.z print_sword.w+1
    // [39] call print_sword 
    // [50] phi from test_16s::@8 to print_sword [phi:test_16s::@8->print_sword]
    // [50] phi (byte*) print_char_cursor#132 = (byte*) print_char_cursor#130 [phi:test_16s::@8->print_sword#0] -- register_copy 
    // [50] phi (signed word) print_sword::w#10 = (signed word) print_sword::w#4 [phi:test_16s::@8->print_sword#1] -- register_copy 
    jsr print_sword
    // [40] phi from test_16s::@8 to test_16s::@9 [phi:test_16s::@8->test_16s::@9]
    // test_16s::@9
    // print_ln()
    // [41] call print_ln 
    // [45] phi from test_16s::@9 to print_ln [phi:test_16s::@9->print_ln]
    // [45] phi (byte*) print_line_cursor#39 = (byte*) print_line_cursor#1 [phi:test_16s::@9->print_ln#0] -- register_copy 
    jsr print_ln
    // test_16s::@10
    // for( byte i: 0..5)
    // [42] (byte) test_16s::i#1 ← ++ (byte) test_16s::i#10 -- vbuz1=_inc_vbuz1 
    inc.z i
    // [43] if((byte) test_16s::i#1!=(byte) 6) goto test_16s::@1 -- vbuz1_neq_vbuc1_then_la1 
    lda #6
    cmp.z i
    bne __b1
    // test_16s::@return
    // }
    // [44] return 
    rts
    dividends: .word $7fff, $7fff, -$7fff, -$7fff, $7fff, -$7fff
    divisors: .word 5, -7, $b, -$d, -$11, $13
}
  // print_ln
// Print a newline
print_ln: {
    // [46] phi from print_ln print_ln::@1 to print_ln::@1 [phi:print_ln/print_ln::@1->print_ln::@1]
    // [46] phi (byte*) print_line_cursor#20 = (byte*) print_line_cursor#39 [phi:print_ln/print_ln::@1->print_ln::@1#0] -- register_copy 
    // print_ln::@1
  __b1:
    // print_line_cursor + $28
    // [47] (byte*) print_line_cursor#1 ← (byte*) print_line_cursor#20 + (byte) $28 -- pbuz1=pbuz1_plus_vbuc1 
    lda #$28
    clc
    adc.z print_line_cursor
    sta.z print_line_cursor
    bcc !+
    inc.z print_line_cursor+1
  !:
    // while (print_line_cursor<print_char_cursor)
    // [48] if((byte*) print_line_cursor#1<(byte*) print_char_cursor#19) goto print_ln::@1 -- pbuz1_lt_pbuz2_then_la1 
    lda.z print_line_cursor+1
    cmp.z print_char_cursor+1
    bcc __b1
    bne !+
    lda.z print_line_cursor
    cmp.z print_char_cursor
    bcc __b1
  !:
    // print_ln::@return
    // }
    // [49] return 
    rts
}
  // print_sword
// Print a signed word as HEX
// print_sword(signed word zp(3) w)
print_sword: {
    .label w = 3
    // if(w<0)
    // [51] if((signed word) print_sword::w#10<(signed byte) 0) goto print_sword::@1 -- vwsz1_lt_0_then_la1 
    lda.z w+1
    bmi __b1
    // [52] phi from print_sword to print_sword::@3 [phi:print_sword->print_sword::@3]
    // print_sword::@3
    // print_char(' ')
    // [53] call print_char 
    // [61] phi from print_sword::@3 to print_char [phi:print_sword::@3->print_char]
    // [61] phi (byte*) print_char_cursor#84 = (byte*) print_char_cursor#132 [phi:print_sword::@3->print_char#0] -- register_copy 
    // [61] phi (byte) print_char::ch#6 = (byte) ' ' [phi:print_sword::@3->print_char#1] -- vbuaa=vbuc1 
    lda #' '
    jsr print_char
    // [54] phi from print_sword::@3 print_sword::@4 to print_sword::@2 [phi:print_sword::@3/print_sword::@4->print_sword::@2]
    // [54] phi (signed word) print_sword::w#7 = (signed word) print_sword::w#10 [phi:print_sword::@3/print_sword::@4->print_sword::@2#0] -- register_copy 
    // print_sword::@2
  __b2:
    // print_word((word)w)
    // [55] (word) print_word::w#0 ← (word)(signed word) print_sword::w#7
    // [56] call print_word 
    // [65] phi from print_sword::@2 to print_word [phi:print_sword::@2->print_word]
    // [65] phi (byte*) print_char_cursor#138 = (byte*) print_char_cursor#19 [phi:print_sword::@2->print_word#0] -- register_copy 
    // [65] phi (word) print_word::w#5 = (word) print_word::w#0 [phi:print_sword::@2->print_word#1] -- register_copy 
    jsr print_word
    // print_sword::@return
    // }
    // [57] return 
    rts
    // [58] phi from print_sword to print_sword::@1 [phi:print_sword->print_sword::@1]
    // print_sword::@1
  __b1:
    // print_char('-')
    // [59] call print_char 
    // [61] phi from print_sword::@1 to print_char [phi:print_sword::@1->print_char]
    // [61] phi (byte*) print_char_cursor#84 = (byte*) print_char_cursor#132 [phi:print_sword::@1->print_char#0] -- register_copy 
    // [61] phi (byte) print_char::ch#6 = (byte) '-' [phi:print_sword::@1->print_char#1] -- vbuaa=vbuc1 
    lda #'-'
    jsr print_char
    // print_sword::@4
    // w = -w
    // [60] (signed word) print_sword::w#0 ← - (signed word) print_sword::w#10 -- vwsz1=_neg_vwsz1 
    sec
    lda #0
    sbc.z w
    sta.z w
    lda #0
    sbc.z w+1
    sta.z w+1
    jmp __b2
}
  // print_char
// Print a single char
// print_char(byte register(A) ch)
print_char: {
    // *(print_char_cursor++) = ch
    // [62] *((byte*) print_char_cursor#84) ← (byte) print_char::ch#6 -- _deref_pbuz1=vbuaa 
    ldy #0
    sta (print_char_cursor),y
    // *(print_char_cursor++) = ch;
    // [63] (byte*) print_char_cursor#19 ← ++ (byte*) print_char_cursor#84 -- pbuz1=_inc_pbuz1 
    inc.z print_char_cursor
    bne !+
    inc.z print_char_cursor+1
  !:
    // print_char::@return
    // }
    // [64] return 
    rts
}
  // print_word
// Print a word as HEX
// print_word(word zp(3) w)
print_word: {
    .label w = 3
    // print_byte(>w)
    // [66] (byte) print_byte::b#1 ← > (word) print_word::w#5 -- vbuz1=_hi_vwuz2 
    lda.z w+1
    sta.z print_byte.b
    // [67] call print_byte 
    // [71] phi from print_word to print_byte [phi:print_word->print_byte]
    // [71] phi (byte*) print_char_cursor#139 = (byte*) print_char_cursor#138 [phi:print_word->print_byte#0] -- register_copy 
    // [71] phi (byte) print_byte::b#7 = (byte) print_byte::b#1 [phi:print_word->print_byte#1] -- register_copy 
    jsr print_byte
    // print_word::@1
    // print_byte(<w)
    // [68] (byte) print_byte::b#2 ← < (word) print_word::w#5 -- vbuz1=_lo_vwuz2 
    lda.z w
    sta.z print_byte.b
    // [69] call print_byte 
    // [71] phi from print_word::@1 to print_byte [phi:print_word::@1->print_byte]
    // [71] phi (byte*) print_char_cursor#139 = (byte*) print_char_cursor#19 [phi:print_word::@1->print_byte#0] -- register_copy 
    // [71] phi (byte) print_byte::b#7 = (byte) print_byte::b#2 [phi:print_word::@1->print_byte#1] -- register_copy 
    jsr print_byte
    // print_word::@return
    // }
    // [70] return 
    rts
}
  // print_byte
// Print a byte as HEX
// print_byte(byte zp(2) b)
print_byte: {
    .label b = 2
    // b>>4
    // [72] (byte~) print_byte::$0 ← (byte) print_byte::b#7 >> (byte) 4 -- vbuaa=vbuz1_ror_4 
    lda.z b
    lsr
    lsr
    lsr
    lsr
    // print_char(print_hextab[b>>4])
    // [73] (byte) print_char::ch#4 ← *((const byte*) print_hextab + (byte~) print_byte::$0) -- vbuaa=pbuc1_derefidx_vbuaa 
    tay
    lda print_hextab,y
    // [74] call print_char 
    // [61] phi from print_byte to print_char [phi:print_byte->print_char]
    // [61] phi (byte*) print_char_cursor#84 = (byte*) print_char_cursor#139 [phi:print_byte->print_char#0] -- register_copy 
    // [61] phi (byte) print_char::ch#6 = (byte) print_char::ch#4 [phi:print_byte->print_char#1] -- register_copy 
    jsr print_char
    // print_byte::@1
    // b&$f
    // [75] (byte~) print_byte::$2 ← (byte) print_byte::b#7 & (byte) $f -- vbuaa=vbuz1_band_vbuc1 
    lda #$f
    and.z b
    // print_char(print_hextab[b&$f])
    // [76] (byte) print_char::ch#5 ← *((const byte*) print_hextab + (byte~) print_byte::$2) -- vbuaa=pbuc1_derefidx_vbuaa 
    tay
    lda print_hextab,y
    // [77] call print_char 
    // [61] phi from print_byte::@1 to print_char [phi:print_byte::@1->print_char]
    // [61] phi (byte*) print_char_cursor#84 = (byte*) print_char_cursor#19 [phi:print_byte::@1->print_char#0] -- register_copy 
    // [61] phi (byte) print_char::ch#6 = (byte) print_char::ch#5 [phi:print_byte::@1->print_char#1] -- register_copy 
    jsr print_char
    // print_byte::@return
    // }
    // [78] return 
    rts
}
  // print_str
// Print a zero-terminated string
// print_str(byte* zp(3) str)
print_str: {
    .label str = 3
    // [80] phi from print_str print_str::@2 to print_str::@1 [phi:print_str/print_str::@2->print_str::@1]
    // [80] phi (byte*) print_char_cursor#130 = (byte*) print_char_cursor#19 [phi:print_str/print_str::@2->print_str::@1#0] -- register_copy 
    // [80] phi (byte*) print_str::str#13 = (byte*) print_str::str#15 [phi:print_str/print_str::@2->print_str::@1#1] -- register_copy 
    // print_str::@1
  __b1:
    // while(*str)
    // [81] if((byte) 0!=*((byte*) print_str::str#13)) goto print_str::@2 -- vbuc1_neq__deref_pbuz1_then_la1 
    ldy #0
    lda (str),y
    cmp #0
    bne __b2
    // print_str::@return
    // }
    // [82] return 
    rts
    // print_str::@2
  __b2:
    // *(print_char_cursor++) = *(str++)
    // [83] *((byte*) print_char_cursor#130) ← *((byte*) print_str::str#13) -- _deref_pbuz1=_deref_pbuz2 
    ldy #0
    lda (str),y
    sta (print_char_cursor),y
    // *(print_char_cursor++) = *(str++);
    // [84] (byte*) print_char_cursor#1 ← ++ (byte*) print_char_cursor#130 -- pbuz1=_inc_pbuz1 
    inc.z print_char_cursor
    bne !+
    inc.z print_char_cursor+1
  !:
    // [85] (byte*) print_str::str#0 ← ++ (byte*) print_str::str#13 -- pbuz1=_inc_pbuz1 
    inc.z str
    bne !+
    inc.z str+1
  !:
    jmp __b1
}
  // div16s
// Perform division on two signed 16-bit numbers
// Returns dividend/divisor.
// The remainder will be set into the global variable rem16s.
// Implemented using simple binary division
// Follows the C99 standard by truncating toward zero on negative results.
// See http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1124.pdf section 6.5.5
// div16s(signed word zp(3) dividend, signed word zp($11) divisor)
div16s: {
    .label return = 9
    .label dividend = 3
    .label divisor = $11
    // divr16s(dividend, divisor, 0)
    // [86] (signed word) divr16s::dividend#0 ← (signed word) div16s::dividend#0 -- vwsz1=vwsz2 
    lda.z dividend
    sta.z divr16s.dividend
    lda.z dividend+1
    sta.z divr16s.dividend+1
    // [87] (signed word) divr16s::divisor#0 ← (signed word) div16s::divisor#0 -- vwsz1=vwsz2 
    lda.z divisor
    sta.z divr16s.divisor
    lda.z divisor+1
    sta.z divr16s.divisor+1
    // [88] call divr16s 
    jsr divr16s
    // [89] (signed word) divr16s::return#3 ← (signed word) divr16s::return#2
    // div16s::@1
    // [90] (signed word) div16s::return#0 ← (signed word) divr16s::return#3
    // div16s::@return
    // }
    // [91] return 
    rts
}
  // divr16s
// Perform division on two signed 16-bit numbers with an initial remainder.
// Returns dividend/divisor. The remainder will be set into the global variable rem16s.
// Implemented using simple binary division
// Follows the C99 standard by truncating toward zero on negative results.
// See http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1124.pdf section 6.5.5
// divr16s(signed word zp(5) dividend, signed word zp(7) divisor)
divr16s: {
    .label __16 = $b
    .label dividendu = 5
    .label divisoru = 7
    .label resultu = 9
    .label return = 9
    .label dividend = 5
    .label divisor = 7
    // if(dividend<0 || rem<0)
    // [92] if((signed word) divr16s::dividend#0<(signed byte) 0) goto divr16s::@1 -- vwsz1_lt_0_then_la1 
    lda.z dividend+1
    bmi __b1
    // divr16s::@6
    // [93] (word) divr16s::dividendu#8 ← (word)(signed word) divr16s::dividend#0
    // [94] phi from divr16s::@6 to divr16s::@2 [phi:divr16s::@6->divr16s::@2]
    // [94] phi (word) divr16s::dividendu#3 = (word) divr16s::dividendu#8 [phi:divr16s::@6->divr16s::@2#0] -- register_copy 
    // [94] phi (byte) divr16s::neg#3 = (byte) 0 [phi:divr16s::@6->divr16s::@2#1] -- vbuyy=vbuc1 
    ldy #0
    // divr16s::@2
  __b2:
    // if(divisor<0)
    // [95] if((signed word) divr16s::divisor#0<(signed byte) 0) goto divr16s::@3 -- vwsz1_lt_0_then_la1 
    lda.z divisor+1
    bmi __b3
    // divr16s::@7
    // [96] (word) divr16s::divisoru#5 ← (word)(signed word) divr16s::divisor#0
    // [97] phi from divr16s::@3 divr16s::@7 to divr16s::@4 [phi:divr16s::@3/divr16s::@7->divr16s::@4]
    // [97] phi (byte) divr16s::neg#4 = (byte) divr16s::neg#2 [phi:divr16s::@3/divr16s::@7->divr16s::@4#0] -- register_copy 
    // [97] phi (word) divr16s::divisoru#3 = (word) divr16s::divisoru#4 [phi:divr16s::@3/divr16s::@7->divr16s::@4#1] -- register_copy 
    // divr16s::@4
  __b4:
    // divr16u(dividendu, divisoru, remu)
    // [98] (word) divr16u::dividend#2 ← (word) divr16s::dividendu#3
    // [99] (word) divr16u::divisor#1 ← (word) divr16s::divisoru#3
    // [100] call divr16u 
    // [116] phi from divr16s::@4 to divr16u [phi:divr16s::@4->divr16u]
    // [116] phi (word) divr16u::divisor#6 = (word) divr16u::divisor#1 [phi:divr16s::@4->divr16u#0] -- register_copy 
    // [116] phi (word) divr16u::dividend#5 = (word) divr16u::dividend#2 [phi:divr16s::@4->divr16u#1] -- register_copy 
    jsr divr16u
    // divr16u(dividendu, divisoru, remu)
    // [101] (word) divr16u::return#3 ← (word) divr16u::return#0
    // divr16s::@9
    // resultu = divr16u(dividendu, divisoru, remu)
    // [102] (word) divr16s::resultu#0 ← (word) divr16u::return#3
    // if(neg==0)
    // [103] if((byte) divr16s::neg#4==(byte) 0) goto divr16s::@5 -- vbuyy_eq_0_then_la1 
    cpy #0
    beq __breturn
    // divr16s::@8
    // (signed word)rem16u
    // [104] (signed word~) divr16s::$16 ← (signed word)(word) rem16u#1
    // rem16s = -(signed word)rem16u
    // [105] (signed word) rem16s#2 ← - (signed word~) divr16s::$16 -- vwsz1=_neg_vwsz1 
    sec
    lda #0
    sbc.z rem16s
    sta.z rem16s
    lda #0
    sbc.z rem16s+1
    sta.z rem16s+1
    // return -(signed word)resultu;
    // [106] (signed word) divr16s::return#1 ← - (signed word)(word) divr16s::resultu#0 -- vwsz1=_neg_vwsz1 
    sec
    lda #0
    sbc.z return
    sta.z return
    lda #0
    sbc.z return+1
    sta.z return+1
    // [107] phi from divr16s::@5 divr16s::@8 to divr16s::@return [phi:divr16s::@5/divr16s::@8->divr16s::@return]
    // [107] phi (signed word) rem16s#11 = (signed word) rem16s#37 [phi:divr16s::@5/divr16s::@8->divr16s::@return#0] -- register_copy 
    // [107] phi (signed word) divr16s::return#2 = (signed word) divr16s::return#7 [phi:divr16s::@5/divr16s::@8->divr16s::@return#1] -- register_copy 
    // divr16s::@return
  __breturn:
    // }
    // [108] return 
    rts
    // divr16s::@5
    // [109] (signed word) divr16s::return#7 ← (signed word)(word) divr16s::resultu#0
    // [110] (signed word) rem16s#37 ← (signed word)(word) rem16u#1
    // divr16s::@3
  __b3:
    // -divisor
    // [111] (signed word) divr16s::divisoru#1 ← - (signed word) divr16s::divisor#0 -- vwsz1=_neg_vwsz1 
    sec
    lda #0
    sbc.z divisoru
    sta.z divisoru
    lda #0
    sbc.z divisoru+1
    sta.z divisoru+1
    // neg = neg ^ 1
    // [112] (byte) divr16s::neg#2 ← (byte) divr16s::neg#3 ^ (byte) 1 -- vbuyy=vbuyy_bxor_vbuc1 
    tya
    eor #1
    tay
    // [113] (word) divr16s::divisoru#4 ← (word)(signed word) divr16s::divisoru#1
    jmp __b4
    // divr16s::@1
  __b1:
    // -dividend
    // [114] (signed word) divr16s::dividendu#1 ← - (signed word) divr16s::dividend#0 -- vwsz1=_neg_vwsz1 
    sec
    lda #0
    sbc.z dividendu
    sta.z dividendu
    lda #0
    sbc.z dividendu+1
    sta.z dividendu+1
    // [115] (word) divr16s::dividendu#7 ← (word)(signed word) divr16s::dividendu#1
    // [94] phi from divr16s::@1 to divr16s::@2 [phi:divr16s::@1->divr16s::@2]
    // [94] phi (word) divr16s::dividendu#3 = (word) divr16s::dividendu#7 [phi:divr16s::@1->divr16s::@2#0] -- register_copy 
    // [94] phi (byte) divr16s::neg#3 = (byte) 1 [phi:divr16s::@1->divr16s::@2#1] -- vbuyy=vbuc1 
    ldy #1
    jmp __b2
}
  // divr16u
// Performs division on two 16 bit unsigned words and an initial remainder
// Returns the quotient dividend/divisor.
// The final remainder will be set into the global variable rem16u
// Implemented using simple binary division
// divr16u(word zp(5) dividend, word zp(7) divisor, word zp($b) rem)
divr16u: {
    .label rem = $b
    .label dividend = 5
    .label quotient = 9
    .label return = 9
    .label divisor = 7
    // [117] phi from divr16u to divr16u::@1 [phi:divr16u->divr16u::@1]
    // [117] phi (byte) divr16u::i#2 = (byte) 0 [phi:divr16u->divr16u::@1#0] -- vbuxx=vbuc1 
    ldx #0
    // [117] phi (word) divr16u::quotient#3 = (word) 0 [phi:divr16u->divr16u::@1#1] -- vwuz1=vwuc1 
    txa
    sta.z quotient
    sta.z quotient+1
    // [117] phi (word) divr16u::dividend#3 = (word) divr16u::dividend#5 [phi:divr16u->divr16u::@1#2] -- register_copy 
    // [117] phi (word) divr16u::rem#5 = (byte) 0 [phi:divr16u->divr16u::@1#3] -- vwuz1=vbuc1 
    sta.z rem
    sta.z rem+1
    // [117] phi from divr16u::@3 to divr16u::@1 [phi:divr16u::@3->divr16u::@1]
    // [117] phi (byte) divr16u::i#2 = (byte) divr16u::i#1 [phi:divr16u::@3->divr16u::@1#0] -- register_copy 
    // [117] phi (word) divr16u::quotient#3 = (word) divr16u::return#0 [phi:divr16u::@3->divr16u::@1#1] -- register_copy 
    // [117] phi (word) divr16u::dividend#3 = (word) divr16u::dividend#0 [phi:divr16u::@3->divr16u::@1#2] -- register_copy 
    // [117] phi (word) divr16u::rem#5 = (word) divr16u::rem#11 [phi:divr16u::@3->divr16u::@1#3] -- register_copy 
    // divr16u::@1
  __b1:
    // rem = rem << 1
    // [118] (word) divr16u::rem#0 ← (word) divr16u::rem#5 << (byte) 1 -- vwuz1=vwuz1_rol_1 
    asl.z rem
    rol.z rem+1
    // >dividend
    // [119] (byte~) divr16u::$1 ← > (word) divr16u::dividend#3 -- vbuaa=_hi_vwuz1 
    lda.z dividend+1
    // >dividend & $80
    // [120] (byte~) divr16u::$2 ← (byte~) divr16u::$1 & (byte) $80 -- vbuaa=vbuaa_band_vbuc1 
    and #$80
    // if( (>dividend & $80) != 0 )
    // [121] if((byte~) divr16u::$2==(byte) 0) goto divr16u::@2 -- vbuaa_eq_0_then_la1 
    cmp #0
    beq __b2
    // divr16u::@4
    // rem = rem | 1
    // [122] (word) divr16u::rem#1 ← (word) divr16u::rem#0 | (byte) 1 -- vwuz1=vwuz1_bor_vbuc1 
    lda #1
    ora.z rem
    sta.z rem
    // [123] phi from divr16u::@1 divr16u::@4 to divr16u::@2 [phi:divr16u::@1/divr16u::@4->divr16u::@2]
    // [123] phi (word) divr16u::rem#6 = (word) divr16u::rem#0 [phi:divr16u::@1/divr16u::@4->divr16u::@2#0] -- register_copy 
    // divr16u::@2
  __b2:
    // dividend = dividend << 1
    // [124] (word) divr16u::dividend#0 ← (word) divr16u::dividend#3 << (byte) 1 -- vwuz1=vwuz1_rol_1 
    asl.z dividend
    rol.z dividend+1
    // quotient = quotient << 1
    // [125] (word) divr16u::quotient#1 ← (word) divr16u::quotient#3 << (byte) 1 -- vwuz1=vwuz1_rol_1 
    asl.z quotient
    rol.z quotient+1
    // if(rem>=divisor)
    // [126] if((word) divr16u::rem#6<(word) divr16u::divisor#6) goto divr16u::@3 -- vwuz1_lt_vwuz2_then_la1 
    lda.z rem+1
    cmp.z divisor+1
    bcc __b3
    bne !+
    lda.z rem
    cmp.z divisor
    bcc __b3
  !:
    // divr16u::@5
    // quotient++;
    // [127] (word) divr16u::quotient#2 ← ++ (word) divr16u::quotient#1 -- vwuz1=_inc_vwuz1 
    inc.z quotient
    bne !+
    inc.z quotient+1
  !:
    // rem = rem - divisor
    // [128] (word) divr16u::rem#2 ← (word) divr16u::rem#6 - (word) divr16u::divisor#6 -- vwuz1=vwuz1_minus_vwuz2 
    lda.z rem
    sec
    sbc.z divisor
    sta.z rem
    lda.z rem+1
    sbc.z divisor+1
    sta.z rem+1
    // [129] phi from divr16u::@2 divr16u::@5 to divr16u::@3 [phi:divr16u::@2/divr16u::@5->divr16u::@3]
    // [129] phi (word) divr16u::return#0 = (word) divr16u::quotient#1 [phi:divr16u::@2/divr16u::@5->divr16u::@3#0] -- register_copy 
    // [129] phi (word) divr16u::rem#11 = (word) divr16u::rem#6 [phi:divr16u::@2/divr16u::@5->divr16u::@3#1] -- register_copy 
    // divr16u::@3
  __b3:
    // for( byte i : 0..15)
    // [130] (byte) divr16u::i#1 ← ++ (byte) divr16u::i#2 -- vbuxx=_inc_vbuxx 
    inx
    // [131] if((byte) divr16u::i#1!=(byte) $10) goto divr16u::@1 -- vbuxx_neq_vbuc1_then_la1 
    cpx #$10
    bne __b1
    // divr16u::@6
    // rem16u = rem
    // [132] (word) rem16u#1 ← (word) divr16u::rem#11
    // divr16u::@return
    // }
    // [133] return 
    rts
}
  // test_8s
test_8s: {
    .label dividend = 2
    .label divisor = $13
    .label res = $14
    .label i = $d
    // [135] phi from test_8s to test_8s::@1 [phi:test_8s->test_8s::@1]
    // [135] phi (byte) test_8s::i#10 = (byte) 0 [phi:test_8s->test_8s::@1#0] -- vbuz1=vbuc1 
    lda #0
    sta.z i
    // [135] phi from test_8s::@10 to test_8s::@1 [phi:test_8s::@10->test_8s::@1]
    // [135] phi (byte) test_8s::i#10 = (byte) test_8s::i#1 [phi:test_8s::@10->test_8s::@1#0] -- register_copy 
    // test_8s::@1
  __b1:
    // dividend = dividends[i]
    // [136] (signed byte) test_8s::dividend#0 ← *((const signed byte*) test_8s::dividends + (byte) test_8s::i#10) -- vbsz1=pbsc1_derefidx_vbuz2 
    ldy.z i
    lda dividends,y
    sta.z dividend
    // divisor = divisors[i]
    // [137] (signed byte) test_8s::divisor#0 ← *((const signed byte*) test_8s::divisors + (byte) test_8s::i#10) -- vbsz1=pbsc1_derefidx_vbuz2 
    lda divisors,y
    sta.z divisor
    // div8s(dividend, divisor)
    // [138] (signed byte) div8s::dividend#0 ← (signed byte) test_8s::dividend#0 -- vbsyy=vbsz1 
    ldy.z dividend
    // [139] (signed byte) div8s::divisor#0 ← (signed byte) test_8s::divisor#0 -- vbsxx=vbsz1 
    tax
    // [140] call div8s 
    jsr div8s
    // [141] (signed byte) div8s::return#3 ← (signed byte) div8s::return#2
    // test_8s::@2
    // res = div8s(dividend, divisor)
    // [142] (signed byte) test_8s::res#0 ← (signed byte) div8s::return#3 -- vbsz1=vbsaa 
    sta.z res
    // print_sbyte(dividend)
    // [143] (signed byte) print_sbyte::b#1 ← (signed byte) test_8s::dividend#0
    // [144] (byte*) print_char_cursor#167 ← (byte*) print_line_cursor#1 -- pbuz1=pbuz2 
    lda.z print_line_cursor
    sta.z print_char_cursor
    lda.z print_line_cursor+1
    sta.z print_char_cursor+1
    // print_sbyte(dividend)
    // [145] call print_sbyte 
    // [163] phi from test_8s::@2 to print_sbyte [phi:test_8s::@2->print_sbyte]
    // [163] phi (byte*) print_char_cursor#135 = (byte*) print_char_cursor#167 [phi:test_8s::@2->print_sbyte#0] -- register_copy 
    // [163] phi (signed byte) print_sbyte::b#10 = (signed byte) print_sbyte::b#1 [phi:test_8s::@2->print_sbyte#1] -- register_copy 
    jsr print_sbyte
    // [146] phi from test_8s::@2 to test_8s::@3 [phi:test_8s::@2->test_8s::@3]
    // test_8s::@3
    // print_str(" / ")
    // [147] call print_str 
    // [79] phi from test_8s::@3 to print_str [phi:test_8s::@3->print_str]
    // [79] phi (byte*) print_str::str#15 = (const string) str [phi:test_8s::@3->print_str#0] -- pbuz1=pbuc1 
    lda #<str
    sta.z print_str.str
    lda #>str
    sta.z print_str.str+1
    jsr print_str
    // test_8s::@4
    // print_sbyte(divisor)
    // [148] (signed byte) print_sbyte::b#2 ← (signed byte) test_8s::divisor#0 -- vbsz1=vbsz2 
    lda.z divisor
    sta.z print_sbyte.b
    // [149] call print_sbyte 
    // [163] phi from test_8s::@4 to print_sbyte [phi:test_8s::@4->print_sbyte]
    // [163] phi (byte*) print_char_cursor#135 = (byte*) print_char_cursor#130 [phi:test_8s::@4->print_sbyte#0] -- register_copy 
    // [163] phi (signed byte) print_sbyte::b#10 = (signed byte) print_sbyte::b#2 [phi:test_8s::@4->print_sbyte#1] -- register_copy 
    jsr print_sbyte
    // [150] phi from test_8s::@4 to test_8s::@5 [phi:test_8s::@4->test_8s::@5]
    // test_8s::@5
    // print_str(" = ")
    // [151] call print_str 
    // [79] phi from test_8s::@5 to print_str [phi:test_8s::@5->print_str]
    // [79] phi (byte*) print_str::str#15 = (const string) str1 [phi:test_8s::@5->print_str#0] -- pbuz1=pbuc1 
    lda #<str1
    sta.z print_str.str
    lda #>str1
    sta.z print_str.str+1
    jsr print_str
    // test_8s::@6
    // print_sbyte(res)
    // [152] (signed byte) print_sbyte::b#3 ← (signed byte) test_8s::res#0 -- vbsz1=vbsz2 
    lda.z res
    sta.z print_sbyte.b
    // [153] call print_sbyte 
    // [163] phi from test_8s::@6 to print_sbyte [phi:test_8s::@6->print_sbyte]
    // [163] phi (byte*) print_char_cursor#135 = (byte*) print_char_cursor#130 [phi:test_8s::@6->print_sbyte#0] -- register_copy 
    // [163] phi (signed byte) print_sbyte::b#10 = (signed byte) print_sbyte::b#3 [phi:test_8s::@6->print_sbyte#1] -- register_copy 
    jsr print_sbyte
    // [154] phi from test_8s::@6 to test_8s::@7 [phi:test_8s::@6->test_8s::@7]
    // test_8s::@7
    // print_str(" ")
    // [155] call print_str 
    // [79] phi from test_8s::@7 to print_str [phi:test_8s::@7->print_str]
    // [79] phi (byte*) print_str::str#15 = (const string) str2 [phi:test_8s::@7->print_str#0] -- pbuz1=pbuc1 
    lda #<str2
    sta.z print_str.str
    lda #>str2
    sta.z print_str.str+1
    jsr print_str
    // test_8s::@8
    // print_sbyte(rem8s)
    // [156] (signed byte) print_sbyte::b#4 ← (signed byte) rem8s#3 -- vbsz1=vbsxx 
    stx.z print_sbyte.b
    // [157] call print_sbyte 
    // [163] phi from test_8s::@8 to print_sbyte [phi:test_8s::@8->print_sbyte]
    // [163] phi (byte*) print_char_cursor#135 = (byte*) print_char_cursor#130 [phi:test_8s::@8->print_sbyte#0] -- register_copy 
    // [163] phi (signed byte) print_sbyte::b#10 = (signed byte) print_sbyte::b#4 [phi:test_8s::@8->print_sbyte#1] -- register_copy 
    jsr print_sbyte
    // [158] phi from test_8s::@8 to test_8s::@9 [phi:test_8s::@8->test_8s::@9]
    // test_8s::@9
    // print_ln()
    // [159] call print_ln 
    // [45] phi from test_8s::@9 to print_ln [phi:test_8s::@9->print_ln]
    // [45] phi (byte*) print_line_cursor#39 = (byte*) print_line_cursor#1 [phi:test_8s::@9->print_ln#0] -- register_copy 
    jsr print_ln
    // test_8s::@10
    // for( byte i: 0..5 )
    // [160] (byte) test_8s::i#1 ← ++ (byte) test_8s::i#10 -- vbuz1=_inc_vbuz1 
    inc.z i
    // [161] if((byte) test_8s::i#1!=(byte) 6) goto test_8s::@1 -- vbuz1_neq_vbuc1_then_la1 
    lda #6
    cmp.z i
    bne __b1
    // test_8s::@return
    // }
    // [162] return 
    rts
    dividends: .byte $7f, -$7f, -$7f, $7f, $7f, $7f
    divisors: .byte 5, 7, -$b, -$d, $11, $13
}
  // print_sbyte
// Print a signed byte as HEX
// print_sbyte(signed byte zp(2) b)
print_sbyte: {
    .label b = 2
    // if(b<0)
    // [164] if((signed byte) print_sbyte::b#10<(signed byte) 0) goto print_sbyte::@1 -- vbsz1_lt_0_then_la1 
    lda.z b
    bmi __b1
    // [165] phi from print_sbyte to print_sbyte::@3 [phi:print_sbyte->print_sbyte::@3]
    // print_sbyte::@3
    // print_char(' ')
    // [166] call print_char 
    // [61] phi from print_sbyte::@3 to print_char [phi:print_sbyte::@3->print_char]
    // [61] phi (byte*) print_char_cursor#84 = (byte*) print_char_cursor#135 [phi:print_sbyte::@3->print_char#0] -- register_copy 
    // [61] phi (byte) print_char::ch#6 = (byte) ' ' [phi:print_sbyte::@3->print_char#1] -- vbuaa=vbuc1 
    lda #' '
    jsr print_char
    // [167] phi from print_sbyte::@3 print_sbyte::@4 to print_sbyte::@2 [phi:print_sbyte::@3/print_sbyte::@4->print_sbyte::@2]
    // [167] phi (signed byte) print_sbyte::b#7 = (signed byte) print_sbyte::b#10 [phi:print_sbyte::@3/print_sbyte::@4->print_sbyte::@2#0] -- register_copy 
    // print_sbyte::@2
  __b2:
    // print_byte((byte)b)
    // [168] (byte) print_byte::b#0 ← (byte)(signed byte) print_sbyte::b#7
    // [169] call print_byte 
    // [71] phi from print_sbyte::@2 to print_byte [phi:print_sbyte::@2->print_byte]
    // [71] phi (byte*) print_char_cursor#139 = (byte*) print_char_cursor#19 [phi:print_sbyte::@2->print_byte#0] -- register_copy 
    // [71] phi (byte) print_byte::b#7 = (byte) print_byte::b#0 [phi:print_sbyte::@2->print_byte#1] -- register_copy 
    jsr print_byte
    // print_sbyte::@return
    // }
    // [170] return 
    rts
    // [171] phi from print_sbyte to print_sbyte::@1 [phi:print_sbyte->print_sbyte::@1]
    // print_sbyte::@1
  __b1:
    // print_char('-')
    // [172] call print_char 
    // [61] phi from print_sbyte::@1 to print_char [phi:print_sbyte::@1->print_char]
    // [61] phi (byte*) print_char_cursor#84 = (byte*) print_char_cursor#135 [phi:print_sbyte::@1->print_char#0] -- register_copy 
    // [61] phi (byte) print_char::ch#6 = (byte) '-' [phi:print_sbyte::@1->print_char#1] -- vbuaa=vbuc1 
    lda #'-'
    jsr print_char
    // print_sbyte::@4
    // b = -b
    // [173] (signed byte) print_sbyte::b#0 ← - (signed byte) print_sbyte::b#10 -- vbsz1=_neg_vbsz1 
    lda.z b
    eor #$ff
    clc
    adc #1
    sta.z b
    jmp __b2
}
  // div8s
// Perform division on two signed 8-bit numbers
// Returns dividend/divisor.
// The remainder will be set into the global variable rem8s.
// Implemented using simple binary division
// Follows the C99 standard by truncating toward zero on negative results.
// See http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1124.pdf section 6.5.5
// div8s(signed byte register(Y) dividend, signed byte register(X) divisor)
div8s: {
    .label neg = $e
    // if(dividend<0)
    // [174] if((signed byte) div8s::dividend#0<(signed byte) 0) goto div8s::@1 -- vbsyy_lt_0_then_la1 
    cpy #0
    bmi __b1
    // div8s::@6
    // [175] (byte) div8s::dividendu#8 ← (byte)(signed byte) div8s::dividend#0
    // [176] phi from div8s::@6 to div8s::@2 [phi:div8s::@6->div8s::@2]
    // [176] phi (byte) div8s::dividendu#3 = (byte) div8s::dividendu#8 [phi:div8s::@6->div8s::@2#0] -- register_copy 
    // [176] phi (byte) div8s::neg#3 = (byte) 0 [phi:div8s::@6->div8s::@2#1] -- vbuz1=vbuc1 
    lda #0
    sta.z neg
    // div8s::@2
  __b2:
    // if(divisor<0)
    // [177] if((signed byte) div8s::divisor#0<(signed byte) 0) goto div8s::@3 -- vbsxx_lt_0_then_la1 
    cpx #0
    bmi __b3
    // div8s::@7
    // [178] (byte) div8s::divisoru#5 ← (byte)(signed byte) div8s::divisor#0
    // [179] phi from div8s::@3 div8s::@7 to div8s::@4 [phi:div8s::@3/div8s::@7->div8s::@4]
    // [179] phi (byte) div8s::neg#4 = (byte) div8s::neg#2 [phi:div8s::@3/div8s::@7->div8s::@4#0] -- register_copy 
    // [179] phi (byte) div8s::divisoru#3 = (byte) div8s::divisoru#4 [phi:div8s::@3/div8s::@7->div8s::@4#1] -- register_copy 
    // div8s::@4
  __b4:
    // div8u(dividendu, divisoru)
    // [180] (byte) div8u::dividend#0 ← (byte) div8s::dividendu#3 -- vbuaa=vbuyy 
    tya
    // [181] (byte) div8u::divisor#0 ← (byte) div8s::divisoru#3
    // [182] call div8u 
    // [198] phi from div8s::@4 to div8u [phi:div8s::@4->div8u]
    // [198] phi (byte) div8u::divisor#2 = (byte) div8u::divisor#0 [phi:div8s::@4->div8u#0] -- register_copy 
    // [198] phi (byte) div8u::dividend#2 = (byte) div8u::dividend#0 [phi:div8s::@4->div8u#1] -- register_copy 
    jsr div8u
    // div8u(dividendu, divisoru)
    // [183] (byte) div8u::return#2 ← (byte) div8u::return#0
    // div8s::@9
    // resultu = div8u(dividendu, divisoru)
    // [184] (byte) div8s::resultu#0 ← (byte) div8u::return#2 -- vbuyy=vbuaa 
    tay
    // if(neg==0)
    // [185] if((byte) div8s::neg#4==(byte) 0) goto div8s::@5 -- vbuz1_eq_0_then_la1 
    lda.z neg
    cmp #0
    beq __b5
    // div8s::@8
    // (signed byte)rem8u
    // [186] (signed byte~) div8s::$11 ← (signed byte)(byte) rem8u#17 -- vbsaa=vbsxx 
    txa
    // rem8s = -(signed byte)rem8u
    // [187] (signed byte) rem8s#2 ← - (signed byte~) div8s::$11 -- vbsxx=_neg_vbsaa 
    eor #$ff
    clc
    adc #1
    tax
    // return -(signed byte)resultu;
    // [188] (signed byte) div8s::return#1 ← - (signed byte)(byte) div8s::resultu#0 -- vbsaa=_neg_vbsyy 
    tya
    eor #$ff
    clc
    adc #1
    // [189] phi from div8s::@5 div8s::@8 to div8s::@return [phi:div8s::@5/div8s::@8->div8s::@return]
    // [189] phi (signed byte) rem8s#3 = (signed byte) rem8s#33 [phi:div8s::@5/div8s::@8->div8s::@return#0] -- register_copy 
    // [189] phi (signed byte) div8s::return#2 = (signed byte) div8s::return#7 [phi:div8s::@5/div8s::@8->div8s::@return#1] -- register_copy 
    // div8s::@return
    // }
    // [190] return 
    rts
    // div8s::@5
  __b5:
    // [191] (signed byte) div8s::return#7 ← (signed byte)(byte) div8s::resultu#0 -- vbsaa=vbsyy 
    tya
    // [192] (signed byte) rem8s#33 ← (signed byte)(byte) rem8u#17
    rts
    // div8s::@3
  __b3:
    // -divisor
    // [193] (signed byte) div8s::divisoru#1 ← - (signed byte) div8s::divisor#0 -- vbsxx=_neg_vbsxx 
    txa
    eor #$ff
    clc
    adc #1
    tax
    // neg = neg ^ 1
    // [194] (byte) div8s::neg#2 ← (byte) div8s::neg#3 ^ (byte) 1 -- vbuz1=vbuz1_bxor_vbuc1 
    lda #1
    eor.z neg
    sta.z neg
    // [195] (byte) div8s::divisoru#4 ← (byte)(signed byte) div8s::divisoru#1
    jmp __b4
    // div8s::@1
  __b1:
    // -dividend
    // [196] (signed byte) div8s::dividendu#1 ← - (signed byte) div8s::dividend#0 -- vbsaa=_neg_vbsyy 
    tya
    eor #$ff
    clc
    adc #1
    // [197] (byte) div8s::dividendu#7 ← (byte)(signed byte) div8s::dividendu#1 -- vbuyy=vbuaa 
    tay
    // [176] phi from div8s::@1 to div8s::@2 [phi:div8s::@1->div8s::@2]
    // [176] phi (byte) div8s::dividendu#3 = (byte) div8s::dividendu#7 [phi:div8s::@1->div8s::@2#0] -- register_copy 
    // [176] phi (byte) div8s::neg#3 = (byte) 1 [phi:div8s::@1->div8s::@2#1] -- vbuz1=vbuc1 
    lda #1
    sta.z neg
    jmp __b2
}
  // div8u
// Performs division on two 8 bit unsigned bytes
// Returns dividend/divisor.
// The remainder will be set into the global variable rem8u
// Implemented using simple binary division
// div8u(byte register(A) dividend, byte register(X) divisor)
div8u: {
    // divr8u(dividend, divisor, 0)
    // [199] (byte) divr8u::dividend#0 ← (byte) div8u::dividend#2 -- vbuz1=vbuaa 
    sta.z divr8u.dividend
    // [200] (byte) divr8u::divisor#0 ← (byte) div8u::divisor#2 -- vbuz1=vbuxx 
    stx.z divr8u.divisor
    // [201] call divr8u 
    // [205] phi from div8u to divr8u [phi:div8u->divr8u]
    jsr divr8u
    // divr8u(dividend, divisor, 0)
    // [202] (byte) divr8u::return#0 ← (byte) divr8u::return#1 -- vbuaa=vbuz1 
    lda.z divr8u.return
    // div8u::@1
    // [203] (byte) div8u::return#0 ← (byte) divr8u::return#0
    // div8u::@return
    // }
    // [204] return 
    rts
}
  // divr8u
// Performs division on two 8 bit unsigned bytes and an initial remainder
// Returns dividend/divisor.
// The final remainder will be set into the global variable rem8u
// Implemented using simple binary division
// divr8u(byte zp($14) dividend, byte zp($15) divisor, byte register(Y) rem)
divr8u: {
    .label dividend = $14
    .label divisor = $15
    .label quotient = $16
    .label return = $16
    // [206] phi from divr8u to divr8u::@1 [phi:divr8u->divr8u::@1]
    // [206] phi (byte) divr8u::i#2 = (byte) 0 [phi:divr8u->divr8u::@1#0] -- vbuxx=vbuc1 
    ldx #0
    // [206] phi (byte) divr8u::quotient#3 = (byte) 0 [phi:divr8u->divr8u::@1#1] -- vbuz1=vbuc1 
    txa
    sta.z quotient
    // [206] phi (byte) divr8u::dividend#2 = (byte) divr8u::dividend#0 [phi:divr8u->divr8u::@1#2] -- register_copy 
    // [206] phi (byte) divr8u::rem#4 = (byte) 0 [phi:divr8u->divr8u::@1#3] -- vbuyy=vbuc1 
    tay
    // [206] phi from divr8u::@3 to divr8u::@1 [phi:divr8u::@3->divr8u::@1]
    // [206] phi (byte) divr8u::i#2 = (byte) divr8u::i#1 [phi:divr8u::@3->divr8u::@1#0] -- register_copy 
    // [206] phi (byte) divr8u::quotient#3 = (byte) divr8u::return#1 [phi:divr8u::@3->divr8u::@1#1] -- register_copy 
    // [206] phi (byte) divr8u::dividend#2 = (byte) divr8u::dividend#1 [phi:divr8u::@3->divr8u::@1#2] -- register_copy 
    // [206] phi (byte) divr8u::rem#4 = (byte) divr8u::rem#10 [phi:divr8u::@3->divr8u::@1#3] -- register_copy 
    // divr8u::@1
  __b1:
    // rem = rem << 1
    // [207] (byte) divr8u::rem#1 ← (byte) divr8u::rem#4 << (byte) 1 -- vbuyy=vbuyy_rol_1 
    tya
    asl
    tay
    // dividend & $80
    // [208] (byte~) divr8u::$1 ← (byte) divr8u::dividend#2 & (byte) $80 -- vbuaa=vbuz1_band_vbuc1 
    lda #$80
    and.z dividend
    // if( (dividend & $80) != 0 )
    // [209] if((byte~) divr8u::$1==(byte) 0) goto divr8u::@2 -- vbuaa_eq_0_then_la1 
    cmp #0
    beq __b2
    // divr8u::@4
    // rem = rem | 1
    // [210] (byte) divr8u::rem#2 ← (byte) divr8u::rem#1 | (byte) 1 -- vbuyy=vbuyy_bor_vbuc1 
    tya
    ora #1
    tay
    // [211] phi from divr8u::@1 divr8u::@4 to divr8u::@2 [phi:divr8u::@1/divr8u::@4->divr8u::@2]
    // [211] phi (byte) divr8u::rem#5 = (byte) divr8u::rem#1 [phi:divr8u::@1/divr8u::@4->divr8u::@2#0] -- register_copy 
    // divr8u::@2
  __b2:
    // dividend = dividend << 1
    // [212] (byte) divr8u::dividend#1 ← (byte) divr8u::dividend#2 << (byte) 1 -- vbuz1=vbuz1_rol_1 
    asl.z dividend
    // quotient = quotient << 1
    // [213] (byte) divr8u::quotient#1 ← (byte) divr8u::quotient#3 << (byte) 1 -- vbuz1=vbuz1_rol_1 
    asl.z quotient
    // if(rem>=divisor)
    // [214] if((byte) divr8u::rem#5<(byte) divr8u::divisor#0) goto divr8u::@3 -- vbuyy_lt_vbuz1_then_la1 
    cpy.z divisor
    bcc __b3
    // divr8u::@5
    // quotient++;
    // [215] (byte) divr8u::quotient#2 ← ++ (byte) divr8u::quotient#1 -- vbuz1=_inc_vbuz1 
    inc.z quotient
    // rem = rem - divisor
    // [216] (byte) divr8u::rem#3 ← (byte) divr8u::rem#5 - (byte) divr8u::divisor#0 -- vbuyy=vbuyy_minus_vbuz1 
    tya
    sec
    sbc.z divisor
    tay
    // [217] phi from divr8u::@2 divr8u::@5 to divr8u::@3 [phi:divr8u::@2/divr8u::@5->divr8u::@3]
    // [217] phi (byte) divr8u::return#1 = (byte) divr8u::quotient#1 [phi:divr8u::@2/divr8u::@5->divr8u::@3#0] -- register_copy 
    // [217] phi (byte) divr8u::rem#10 = (byte) divr8u::rem#5 [phi:divr8u::@2/divr8u::@5->divr8u::@3#1] -- register_copy 
    // divr8u::@3
  __b3:
    // for( byte i : 0..7)
    // [218] (byte) divr8u::i#1 ← ++ (byte) divr8u::i#2 -- vbuxx=_inc_vbuxx 
    inx
    // [219] if((byte) divr8u::i#1!=(byte) 8) goto divr8u::@1 -- vbuxx_neq_vbuc1_then_la1 
    cpx #8
    bne __b1
    // divr8u::@6
    // rem8u = rem
    // [220] (byte) rem8u#17 ← (byte) divr8u::rem#10 -- vbuxx=vbuyy 
    tya
    tax
    // divr8u::@return
    // }
    // [221] return 
    rts
}
  // test_16u
test_16u: {
    .label dividend = 3
    .label divisor = 7
    .label res = 9
    .label i = $e
    // [223] phi from test_16u to test_16u::@1 [phi:test_16u->test_16u::@1]
    // [223] phi (byte) test_16u::i#10 = (byte) 0 [phi:test_16u->test_16u::@1#0] -- vbuz1=vbuc1 
    lda #0
    sta.z i
    // [223] phi from test_16u::@10 to test_16u::@1 [phi:test_16u::@10->test_16u::@1]
    // [223] phi (byte) test_16u::i#10 = (byte) test_16u::i#1 [phi:test_16u::@10->test_16u::@1#0] -- register_copy 
    // test_16u::@1
  __b1:
    // dividend = dividends[i]
    // [224] (byte~) test_16u::$11 ← (byte) test_16u::i#10 << (byte) 1 -- vbuxx=vbuz1_rol_1 
    lda.z i
    asl
    tax
    // [225] (word) test_16u::dividend#0 ← *((const word*) test_16u::dividends + (byte~) test_16u::$11) -- vwuz1=pwuc1_derefidx_vbuxx 
    lda dividends,x
    sta.z dividend
    lda dividends+1,x
    sta.z dividend+1
    // divisor = divisors[i]
    // [226] (word) test_16u::divisor#0 ← *((const word*) test_16u::divisors + (byte~) test_16u::$11) -- vwuz1=pwuc1_derefidx_vbuxx 
    lda divisors,x
    sta.z divisor
    lda divisors+1,x
    sta.z divisor+1
    // div16u(dividend, divisor)
    // [227] (word) div16u::dividend#0 ← (word) test_16u::dividend#0
    // [228] (word) div16u::divisor#0 ← (word) test_16u::divisor#0
    // [229] call div16u 
    jsr div16u
    // [230] (word) div16u::return#2 ← (word) div16u::return#0
    // test_16u::@2
    // res = div16u(dividend, divisor)
    // [231] (word) test_16u::res#0 ← (word) div16u::return#2
    // print_word(dividend)
    // [232] (word) print_word::w#1 ← (word) test_16u::dividend#0
    // [233] (byte*) print_char_cursor#172 ← (byte*) print_line_cursor#1 -- pbuz1=pbuz2 
    lda.z print_line_cursor
    sta.z print_char_cursor
    lda.z print_line_cursor+1
    sta.z print_char_cursor+1
    // print_word(dividend)
    // [234] call print_word 
    // [65] phi from test_16u::@2 to print_word [phi:test_16u::@2->print_word]
    // [65] phi (byte*) print_char_cursor#138 = (byte*) print_char_cursor#172 [phi:test_16u::@2->print_word#0] -- register_copy 
    // [65] phi (word) print_word::w#5 = (word) print_word::w#1 [phi:test_16u::@2->print_word#1] -- register_copy 
    jsr print_word
    // [235] phi from test_16u::@2 to test_16u::@3 [phi:test_16u::@2->test_16u::@3]
    // test_16u::@3
    // print_str(" / ")
    // [236] call print_str 
    // [79] phi from test_16u::@3 to print_str [phi:test_16u::@3->print_str]
    // [79] phi (byte*) print_str::str#15 = (const string) str [phi:test_16u::@3->print_str#0] -- pbuz1=pbuc1 
    lda #<str
    sta.z print_str.str
    lda #>str
    sta.z print_str.str+1
    jsr print_str
    // test_16u::@4
    // print_word(divisor)
    // [237] (word) print_word::w#2 ← (word) test_16u::divisor#0 -- vwuz1=vwuz2 
    lda.z divisor
    sta.z print_word.w
    lda.z divisor+1
    sta.z print_word.w+1
    // [238] call print_word 
    // [65] phi from test_16u::@4 to print_word [phi:test_16u::@4->print_word]
    // [65] phi (byte*) print_char_cursor#138 = (byte*) print_char_cursor#130 [phi:test_16u::@4->print_word#0] -- register_copy 
    // [65] phi (word) print_word::w#5 = (word) print_word::w#2 [phi:test_16u::@4->print_word#1] -- register_copy 
    jsr print_word
    // [239] phi from test_16u::@4 to test_16u::@5 [phi:test_16u::@4->test_16u::@5]
    // test_16u::@5
    // print_str(" = ")
    // [240] call print_str 
    // [79] phi from test_16u::@5 to print_str [phi:test_16u::@5->print_str]
    // [79] phi (byte*) print_str::str#15 = (const string) str1 [phi:test_16u::@5->print_str#0] -- pbuz1=pbuc1 
    lda #<str1
    sta.z print_str.str
    lda #>str1
    sta.z print_str.str+1
    jsr print_str
    // test_16u::@6
    // print_word(res)
    // [241] (word) print_word::w#3 ← (word) test_16u::res#0 -- vwuz1=vwuz2 
    lda.z res
    sta.z print_word.w
    lda.z res+1
    sta.z print_word.w+1
    // [242] call print_word 
    // [65] phi from test_16u::@6 to print_word [phi:test_16u::@6->print_word]
    // [65] phi (byte*) print_char_cursor#138 = (byte*) print_char_cursor#130 [phi:test_16u::@6->print_word#0] -- register_copy 
    // [65] phi (word) print_word::w#5 = (word) print_word::w#3 [phi:test_16u::@6->print_word#1] -- register_copy 
    jsr print_word
    // [243] phi from test_16u::@6 to test_16u::@7 [phi:test_16u::@6->test_16u::@7]
    // test_16u::@7
    // print_str(" ")
    // [244] call print_str 
    // [79] phi from test_16u::@7 to print_str [phi:test_16u::@7->print_str]
    // [79] phi (byte*) print_str::str#15 = (const string) str2 [phi:test_16u::@7->print_str#0] -- pbuz1=pbuc1 
    lda #<str2
    sta.z print_str.str
    lda #>str2
    sta.z print_str.str+1
    jsr print_str
    // test_16u::@8
    // print_word(rem16u)
    // [245] (word) print_word::w#4 ← (word) rem16u#1 -- vwuz1=vwuz2 
    lda.z rem16u
    sta.z print_word.w
    lda.z rem16u+1
    sta.z print_word.w+1
    // [246] call print_word 
    // [65] phi from test_16u::@8 to print_word [phi:test_16u::@8->print_word]
    // [65] phi (byte*) print_char_cursor#138 = (byte*) print_char_cursor#130 [phi:test_16u::@8->print_word#0] -- register_copy 
    // [65] phi (word) print_word::w#5 = (word) print_word::w#4 [phi:test_16u::@8->print_word#1] -- register_copy 
    jsr print_word
    // [247] phi from test_16u::@8 to test_16u::@9 [phi:test_16u::@8->test_16u::@9]
    // test_16u::@9
    // print_ln()
    // [248] call print_ln 
    // [45] phi from test_16u::@9 to print_ln [phi:test_16u::@9->print_ln]
    // [45] phi (byte*) print_line_cursor#39 = (byte*) print_line_cursor#1 [phi:test_16u::@9->print_ln#0] -- register_copy 
    jsr print_ln
    // test_16u::@10
    // for( byte i : 0..5)
    // [249] (byte) test_16u::i#1 ← ++ (byte) test_16u::i#10 -- vbuz1=_inc_vbuz1 
    inc.z i
    // [250] if((byte) test_16u::i#1!=(byte) 6) goto test_16u::@1 -- vbuz1_neq_vbuc1_then_la1 
    lda #6
    cmp.z i
    bne __b1
    // test_16u::@return
    // }
    // [251] return 
    rts
    dividends: .word $ffff, $ffff, $ffff, $ffff, $ffff, $ffff
    divisors: .word 5, 7, $b, $d, $11, $13
}
  // div16u
// Performs division on two 16 bit unsigned words
// Returns the quotient dividend/divisor.
// The remainder will be set into the global variable rem16u
// Implemented using simple binary division
// div16u(word zp(3) dividend, word zp(7) divisor)
div16u: {
    .label return = 9
    .label dividend = 3
    .label divisor = 7
    // divr16u(dividend, divisor, 0)
    // [252] (word) divr16u::dividend#1 ← (word) div16u::dividend#0 -- vwuz1=vwuz2 
    lda.z dividend
    sta.z divr16u.dividend
    lda.z dividend+1
    sta.z divr16u.dividend+1
    // [253] (word) divr16u::divisor#0 ← (word) div16u::divisor#0
    // [254] call divr16u 
    // [116] phi from div16u to divr16u [phi:div16u->divr16u]
    // [116] phi (word) divr16u::divisor#6 = (word) divr16u::divisor#0 [phi:div16u->divr16u#0] -- register_copy 
    // [116] phi (word) divr16u::dividend#5 = (word) divr16u::dividend#1 [phi:div16u->divr16u#1] -- register_copy 
    jsr divr16u
    // divr16u(dividend, divisor, 0)
    // [255] (word) divr16u::return#2 ← (word) divr16u::return#0
    // div16u::@1
    // [256] (word) div16u::return#0 ← (word) divr16u::return#2
    // div16u::@return
    // }
    // [257] return 
    rts
}
  // test_8u
test_8u: {
    .label dividend = 2
    .label divisor = $15
    .label res = $16
    .label i = $13
    // [259] phi from test_8u to test_8u::@1 [phi:test_8u->test_8u::@1]
    // [259] phi (byte*) print_line_cursor#41 = (byte*) 1024 [phi:test_8u->test_8u::@1#0] -- pbuz1=pbuc1 
    lda #<$400
    sta.z print_line_cursor
    lda #>$400
    sta.z print_line_cursor+1
    // [259] phi (byte*) print_char_cursor#141 = (byte*) 1024 [phi:test_8u->test_8u::@1#1] -- pbuz1=pbuc1 
    lda #<$400
    sta.z print_char_cursor
    lda #>$400
    sta.z print_char_cursor+1
    // [259] phi (byte) test_8u::i#10 = (byte) 0 [phi:test_8u->test_8u::@1#2] -- vbuz1=vbuc1 
    lda #0
    sta.z i
    // test_8u::@1
  __b1:
    // dividend = dividends[i]
    // [260] (byte) test_8u::dividend#0 ← *((const byte*) test_8u::dividends + (byte) test_8u::i#10) -- vbuz1=pbuc1_derefidx_vbuz2 
    ldy.z i
    lda dividends,y
    sta.z dividend
    // divisor = divisors[i]
    // [261] (byte) test_8u::divisor#0 ← *((const byte*) test_8u::divisors + (byte) test_8u::i#10) -- vbuz1=pbuc1_derefidx_vbuz2 
    lda divisors,y
    sta.z divisor
    // div8u(dividend, divisor)
    // [262] (byte) div8u::dividend#1 ← (byte) test_8u::dividend#0 -- vbuaa=vbuz1 
    lda.z dividend
    // [263] (byte) div8u::divisor#1 ← (byte) test_8u::divisor#0 -- vbuxx=vbuz1 
    ldx.z divisor
    // [264] call div8u 
    // [198] phi from test_8u::@1 to div8u [phi:test_8u::@1->div8u]
    // [198] phi (byte) div8u::divisor#2 = (byte) div8u::divisor#1 [phi:test_8u::@1->div8u#0] -- register_copy 
    // [198] phi (byte) div8u::dividend#2 = (byte) div8u::dividend#1 [phi:test_8u::@1->div8u#1] -- register_copy 
    jsr div8u
    // div8u(dividend, divisor)
    // [265] (byte) div8u::return#3 ← (byte) div8u::return#0
    // test_8u::@2
    // res = div8u(dividend, divisor)
    // [266] (byte) test_8u::res#0 ← (byte) div8u::return#3 -- vbuz1=vbuaa 
    sta.z res
    // print_byte(dividend)
    // [267] (byte) print_byte::b#3 ← (byte) test_8u::dividend#0
    // [268] call print_byte 
    // [71] phi from test_8u::@2 to print_byte [phi:test_8u::@2->print_byte]
    // [71] phi (byte*) print_char_cursor#139 = (byte*) print_char_cursor#141 [phi:test_8u::@2->print_byte#0] -- register_copy 
    // [71] phi (byte) print_byte::b#7 = (byte) print_byte::b#3 [phi:test_8u::@2->print_byte#1] -- register_copy 
    jsr print_byte
    // [269] phi from test_8u::@2 to test_8u::@3 [phi:test_8u::@2->test_8u::@3]
    // test_8u::@3
    // print_str(" / ")
    // [270] call print_str 
    // [79] phi from test_8u::@3 to print_str [phi:test_8u::@3->print_str]
    // [79] phi (byte*) print_str::str#15 = (const string) str [phi:test_8u::@3->print_str#0] -- pbuz1=pbuc1 
    lda #<str
    sta.z print_str.str
    lda #>str
    sta.z print_str.str+1
    jsr print_str
    // test_8u::@4
    // print_byte(divisor)
    // [271] (byte) print_byte::b#4 ← (byte) test_8u::divisor#0 -- vbuz1=vbuz2 
    lda.z divisor
    sta.z print_byte.b
    // [272] call print_byte 
    // [71] phi from test_8u::@4 to print_byte [phi:test_8u::@4->print_byte]
    // [71] phi (byte*) print_char_cursor#139 = (byte*) print_char_cursor#130 [phi:test_8u::@4->print_byte#0] -- register_copy 
    // [71] phi (byte) print_byte::b#7 = (byte) print_byte::b#4 [phi:test_8u::@4->print_byte#1] -- register_copy 
    jsr print_byte
    // [273] phi from test_8u::@4 to test_8u::@5 [phi:test_8u::@4->test_8u::@5]
    // test_8u::@5
    // print_str(" = ")
    // [274] call print_str 
    // [79] phi from test_8u::@5 to print_str [phi:test_8u::@5->print_str]
    // [79] phi (byte*) print_str::str#15 = (const string) str1 [phi:test_8u::@5->print_str#0] -- pbuz1=pbuc1 
    lda #<str1
    sta.z print_str.str
    lda #>str1
    sta.z print_str.str+1
    jsr print_str
    // test_8u::@6
    // print_byte(res)
    // [275] (byte) print_byte::b#5 ← (byte) test_8u::res#0 -- vbuz1=vbuz2 
    lda.z res
    sta.z print_byte.b
    // [276] call print_byte 
    // [71] phi from test_8u::@6 to print_byte [phi:test_8u::@6->print_byte]
    // [71] phi (byte*) print_char_cursor#139 = (byte*) print_char_cursor#130 [phi:test_8u::@6->print_byte#0] -- register_copy 
    // [71] phi (byte) print_byte::b#7 = (byte) print_byte::b#5 [phi:test_8u::@6->print_byte#1] -- register_copy 
    jsr print_byte
    // [277] phi from test_8u::@6 to test_8u::@7 [phi:test_8u::@6->test_8u::@7]
    // test_8u::@7
    // print_str(" ")
    // [278] call print_str 
    // [79] phi from test_8u::@7 to print_str [phi:test_8u::@7->print_str]
    // [79] phi (byte*) print_str::str#15 = (const string) str2 [phi:test_8u::@7->print_str#0] -- pbuz1=pbuc1 
    lda #<str2
    sta.z print_str.str
    lda #>str2
    sta.z print_str.str+1
    jsr print_str
    // test_8u::@8
    // print_byte(rem8u)
    // [279] (byte) print_byte::b#6 ← (byte) rem8u#17 -- vbuz1=vbuxx 
    stx.z print_byte.b
    // [280] call print_byte 
    // [71] phi from test_8u::@8 to print_byte [phi:test_8u::@8->print_byte]
    // [71] phi (byte*) print_char_cursor#139 = (byte*) print_char_cursor#130 [phi:test_8u::@8->print_byte#0] -- register_copy 
    // [71] phi (byte) print_byte::b#7 = (byte) print_byte::b#6 [phi:test_8u::@8->print_byte#1] -- register_copy 
    jsr print_byte
    // [281] phi from test_8u::@8 to test_8u::@9 [phi:test_8u::@8->test_8u::@9]
    // test_8u::@9
    // print_ln()
    // [282] call print_ln 
    // [45] phi from test_8u::@9 to print_ln [phi:test_8u::@9->print_ln]
    // [45] phi (byte*) print_line_cursor#39 = (byte*) print_line_cursor#41 [phi:test_8u::@9->print_ln#0] -- register_copy 
    jsr print_ln
    // test_8u::@10
    // for( byte i: 0..5 )
    // [283] (byte) test_8u::i#1 ← ++ (byte) test_8u::i#10 -- vbuz1=_inc_vbuz1 
    inc.z i
    // [284] if((byte) test_8u::i#1!=(byte) 6) goto test_8u::@11 -- vbuz1_neq_vbuc1_then_la1 
    lda #6
    cmp.z i
    bne __b11
    // test_8u::@return
    // }
    // [285] return 
    rts
    // test_8u::@11
  __b11:
    // [286] (byte*) print_char_cursor#189 ← (byte*) print_line_cursor#1 -- pbuz1=pbuz2 
    lda.z print_line_cursor
    sta.z print_char_cursor
    lda.z print_line_cursor+1
    sta.z print_char_cursor+1
    // [259] phi from test_8u::@11 to test_8u::@1 [phi:test_8u::@11->test_8u::@1]
    // [259] phi (byte*) print_line_cursor#41 = (byte*) print_line_cursor#1 [phi:test_8u::@11->test_8u::@1#0] -- register_copy 
    // [259] phi (byte*) print_char_cursor#141 = (byte*) print_char_cursor#189 [phi:test_8u::@11->test_8u::@1#1] -- register_copy 
    // [259] phi (byte) test_8u::i#10 = (byte) test_8u::i#1 [phi:test_8u::@11->test_8u::@1#2] -- register_copy 
    jmp __b1
    dividends: .byte $ff, $ff, $ff, $ff, $ff, $ff
    divisors: .byte 5, 7, $b, $d, $11, $13
}
  // print_cls
// Clear the screen. Also resets current line/char cursor.
print_cls: {
    // memset(print_screen, ' ', 1000)
    // [288] call memset 
    // [290] phi from print_cls to memset [phi:print_cls->memset]
    jsr memset
    // print_cls::@return
    // }
    // [289] return 
    rts
}
  // memset
// Copies the character c (an unsigned char) to the first num characters of the object pointed to by the argument str.
memset: {
    .const c = ' '
    .const num = $3e8
    .label str = $400
    .label end = str+num
    .label dst = $f
    // [291] phi from memset to memset::@1 [phi:memset->memset::@1]
    // [291] phi (byte*) memset::dst#2 = (byte*)(const void*) memset::str#0 [phi:memset->memset::@1#0] -- pbuz1=pbuc1 
    lda #<str
    sta.z dst
    lda #>str
    sta.z dst+1
    // memset::@1
  __b1:
    // for(char* dst = str; dst!=end; dst++)
    // [292] if((byte*) memset::dst#2!=(const byte*) memset::end#0) goto memset::@2 -- pbuz1_neq_pbuc1_then_la1 
    lda.z dst+1
    cmp #>end
    bne __b2
    lda.z dst
    cmp #<end
    bne __b2
    // memset::@return
    // }
    // [293] return 
    rts
    // memset::@2
  __b2:
    // *dst = c
    // [294] *((byte*) memset::dst#2) ← (const byte) memset::c#0 -- _deref_pbuz1=vbuc1 
    lda #c
    ldy #0
    sta (dst),y
    // for(char* dst = str; dst!=end; dst++)
    // [295] (byte*) memset::dst#1 ← ++ (byte*) memset::dst#2 -- pbuz1=_inc_pbuz1 
    inc.z dst
    bne !+
    inc.z dst+1
  !:
    // [291] phi from memset::@2 to memset::@1 [phi:memset::@2->memset::@1]
    // [291] phi (byte*) memset::dst#2 = (byte*) memset::dst#1 [phi:memset::@2->memset::@1#0] -- register_copy 
    jmp __b1
}
  // File Data
  print_hextab: .text "0123456789abcdef"
  str: .text " / "
  .byte 0
  str1: .text " = "
  .byte 0
  str2: .text " "
  .byte 0

