@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
