
void main()
main: scope:[main]  from
  [0] phi()
  [1] call print_cls
  to:main::@1
main::@1: scope:[main]  from main
  [2] phi()
  [3] call test_8u
  to:main::@2
main::@2: scope:[main]  from main::@1
  [4] phi()
  [5] call test_16u
  to:main::@3
main::@3: scope:[main]  from main::@2
  [6] phi()
  [7] call test_8s
  to:main::@4
main::@4: scope:[main]  from main::@3
  [8] phi()
  [9] call test_16s
  to:main::@return
main::@return: scope:[main]  from main::@4
  [10] return 
  to:@return

void print_cls()
print_cls: scope:[print_cls]  from main
  [11] phi()
  [12] call memset
  to:print_cls::@return
print_cls::@return: scope:[print_cls]  from print_cls
  [13] return 
  to:@return

void test_8u()
test_8u: scope:[test_8u]  from main::@1
  [14] phi()
  to:test_8u::@1
test_8u::@1: scope:[test_8u]  from test_8u test_8u::@11
  [15] print_line_cursor#43 = phi( test_8u/print_screen#0, test_8u::@11/print_line_cursor#0 )
  [15] print_char_cursor#144 = phi( test_8u/print_screen#0, test_8u::@11/print_char_cursor#187 )
  [15] test_8u::i#10 = phi( test_8u/0, test_8u::@11/test_8u::i#1 )
  [16] test_8u::dividend#0 = test_8u::dividends[test_8u::i#10]
  [17] test_8u::divisor#0 = test_8u::divisors[test_8u::i#10]
  [18] div8u::dividend#1 = test_8u::dividend#0
  [19] div8u::divisor#1 = test_8u::divisor#0
  [20] call div8u
  [21] div8u::return#3 = div8u::return#0
  to:test_8u::@2
test_8u::@2: scope:[test_8u]  from test_8u::@1
  [22] test_8u::res#0 = div8u::return#3
  [23] print_uchar::b#3 = test_8u::dividend#0
  [24] call print_uchar
  to:test_8u::@3
test_8u::@3: scope:[test_8u]  from test_8u::@2
  [25] phi()
  [26] call print_str
  to:test_8u::@4
test_8u::@4: scope:[test_8u]  from test_8u::@3
  [27] print_uchar::b#4 = test_8u::divisor#0
  [28] call print_uchar
  to:test_8u::@5
test_8u::@5: scope:[test_8u]  from test_8u::@4
  [29] phi()
  [30] call print_str
  to:test_8u::@6
test_8u::@6: scope:[test_8u]  from test_8u::@5
  [31] print_uchar::b#5 = test_8u::res#0
  [32] call print_uchar
  to:test_8u::@7
test_8u::@7: scope:[test_8u]  from test_8u::@6
  [33] phi()
  [34] call print_str
  to:test_8u::@8
test_8u::@8: scope:[test_8u]  from test_8u::@7
  [35] print_uchar::b#6 = rem8u#18
  [36] call print_uchar
  to:test_8u::@9
test_8u::@9: scope:[test_8u]  from test_8u::@8
  [37] phi()
  [38] call print_ln
  to:test_8u::@10
test_8u::@10: scope:[test_8u]  from test_8u::@9
  [39] test_8u::i#1 = ++ test_8u::i#10
  [40] if(test_8u::i#1!=6) goto test_8u::@11
  to:test_8u::@return
test_8u::@return: scope:[test_8u]  from test_8u::@10
  [41] return 
  to:@return
test_8u::@11: scope:[test_8u]  from test_8u::@10
  [42] print_char_cursor#187 = print_line_cursor#0
  to:test_8u::@1

void test_16u()
test_16u: scope:[test_16u]  from main::@2
  [43] phi()
  to:test_16u::@1
test_16u::@1: scope:[test_16u]  from test_16u test_16u::@10
  [44] test_16u::i#10 = phi( test_16u/0, test_16u::@10/test_16u::i#1 )
  [45] test_16u::$11 = test_16u::i#10 << 1
  [46] test_16u::dividend#0 = test_16u::dividends[test_16u::$11]
  [47] test_16u::divisor#0 = test_16u::divisors[test_16u::$11]
  [48] div16u::dividend#0 = test_16u::dividend#0
  [49] div16u::divisor#0 = test_16u::divisor#0
  [50] call div16u
  [51] div16u::return#2 = div16u::return#0
  to:test_16u::@2
test_16u::@2: scope:[test_16u]  from test_16u::@1
  [52] test_16u::res#0 = div16u::return#2
  [53] print_uint::w#1 = test_16u::dividend#0
  [54] print_char_cursor#169 = print_line_cursor#0
  [55] call print_uint
  to:test_16u::@3
test_16u::@3: scope:[test_16u]  from test_16u::@2
  [56] phi()
  [57] call print_str
  to:test_16u::@4
test_16u::@4: scope:[test_16u]  from test_16u::@3
  [58] print_uint::w#2 = test_16u::divisor#0
  [59] call print_uint
  to:test_16u::@5
test_16u::@5: scope:[test_16u]  from test_16u::@4
  [60] phi()
  [61] call print_str
  to:test_16u::@6
test_16u::@6: scope:[test_16u]  from test_16u::@5
  [62] print_uint::w#3 = test_16u::res#0
  [63] call print_uint
  to:test_16u::@7
test_16u::@7: scope:[test_16u]  from test_16u::@6
  [64] phi()
  [65] call print_str
  to:test_16u::@8
test_16u::@8: scope:[test_16u]  from test_16u::@7
  [66] print_uint::w#4 = rem16u#0
  [67] call print_uint
  to:test_16u::@9
test_16u::@9: scope:[test_16u]  from test_16u::@8
  [68] phi()
  [69] call print_ln
  to:test_16u::@10
test_16u::@10: scope:[test_16u]  from test_16u::@9
  [70] test_16u::i#1 = ++ test_16u::i#10
  [71] if(test_16u::i#1!=6) goto test_16u::@1
  to:test_16u::@return
test_16u::@return: scope:[test_16u]  from test_16u::@10
  [72] return 
  to:@return

void test_8s()
test_8s: scope:[test_8s]  from main::@3
  [73] phi()
  to:test_8s::@1
test_8s::@1: scope:[test_8s]  from test_8s test_8s::@10
  [74] test_8s::i#10 = phi( test_8s/0, test_8s::@10/test_8s::i#1 )
  [75] test_8s::dividend#0 = test_8s::dividends[test_8s::i#10]
  [76] test_8s::divisor#0 = test_8s::divisors[test_8s::i#10]
  [77] div8s::dividend#0 = test_8s::dividend#0
  [78] div8s::divisor#0 = test_8s::divisor#0
  [79] call div8s
  [80] div8s::return#3 = div8s::return#2
  to:test_8s::@2
test_8s::@2: scope:[test_8s]  from test_8s::@1
  [81] test_8s::res#0 = div8s::return#3
  [82] print_schar::b#1 = test_8s::dividend#0
  [83] print_char_cursor#164 = print_line_cursor#0
  [84] call print_schar
  to:test_8s::@3
test_8s::@3: scope:[test_8s]  from test_8s::@2
  [85] phi()
  [86] call print_str
  to:test_8s::@4
test_8s::@4: scope:[test_8s]  from test_8s::@3
  [87] print_schar::b#2 = test_8s::divisor#0
  [88] call print_schar
  to:test_8s::@5
test_8s::@5: scope:[test_8s]  from test_8s::@4
  [89] phi()
  [90] call print_str
  to:test_8s::@6
test_8s::@6: scope:[test_8s]  from test_8s::@5
  [91] print_schar::b#3 = test_8s::res#0
  [92] call print_schar
  to:test_8s::@7
test_8s::@7: scope:[test_8s]  from test_8s::@6
  [93] phi()
  [94] call print_str
  to:test_8s::@8
test_8s::@8: scope:[test_8s]  from test_8s::@7
  [95] print_schar::b#4 = rem8s#10
  [96] call print_schar
  to:test_8s::@9
test_8s::@9: scope:[test_8s]  from test_8s::@8
  [97] phi()
  [98] call print_ln
  to:test_8s::@10
test_8s::@10: scope:[test_8s]  from test_8s::@9
  [99] test_8s::i#1 = ++ test_8s::i#10
  [100] if(test_8s::i#1!=6) goto test_8s::@1
  to:test_8s::@return
test_8s::@return: scope:[test_8s]  from test_8s::@10
  [101] return 
  to:@return

void test_16s()
test_16s: scope:[test_16s]  from main::@4
  [102] phi()
  to:test_16s::@1
test_16s::@1: scope:[test_16s]  from test_16s test_16s::@10
  [103] test_16s::i#10 = phi( test_16s/0, test_16s::@10/test_16s::i#1 )
  [104] test_16s::$11 = test_16s::i#10 << 1
  [105] test_16s::dividend#0 = test_16s::dividends[test_16s::$11]
  [106] test_16s::divisor#0 = test_16s::divisors[test_16s::$11]
  [107] div16s::dividend#0 = test_16s::dividend#0
  [108] div16s::divisor#0 = test_16s::divisor#0
  [109] call div16s
  [110] div16s::return#2 = div16s::return#0
  to:test_16s::@2
test_16s::@2: scope:[test_16s]  from test_16s::@1
  [111] test_16s::res#0 = div16s::return#2
  [112] print_sint::w#1 = test_16s::dividend#0
  [113] print_char_cursor#160 = print_line_cursor#0
  [114] call print_sint
  to:test_16s::@3
test_16s::@3: scope:[test_16s]  from test_16s::@2
  [115] phi()
  [116] call print_str
  to:test_16s::@4
test_16s::@4: scope:[test_16s]  from test_16s::@3
  [117] print_sint::w#2 = test_16s::divisor#0
  [118] call print_sint
  to:test_16s::@5
test_16s::@5: scope:[test_16s]  from test_16s::@4
  [119] phi()
  [120] call print_str
  to:test_16s::@6
test_16s::@6: scope:[test_16s]  from test_16s::@5
  [121] print_sint::w#3 = test_16s::res#0
  [122] call print_sint
  to:test_16s::@7
test_16s::@7: scope:[test_16s]  from test_16s::@6
  [123] phi()
  [124] call print_str
  to:test_16s::@8
test_16s::@8: scope:[test_16s]  from test_16s::@7
  [125] print_sint::w#4 = rem16s#12
  [126] call print_sint
  to:test_16s::@9
test_16s::@9: scope:[test_16s]  from test_16s::@8
  [127] phi()
  [128] call print_ln
  to:test_16s::@10
test_16s::@10: scope:[test_16s]  from test_16s::@9
  [129] test_16s::i#1 = ++ test_16s::i#10
  [130] if(test_16s::i#1!=6) goto test_16s::@1
  to:test_16s::@return
test_16s::@return: scope:[test_16s]  from test_16s::@10
  [131] return 
  to:@return

void * memset(void *str , char c , unsigned int num)
memset: scope:[memset]  from print_cls
  [132] phi()
  to:memset::@1
memset::@1: scope:[memset]  from memset memset::@2
  [133] memset::dst#2 = phi( memset/(char *)memset::str#0, memset::@2/memset::dst#1 )
  [134] if(memset::dst#2!=memset::end#0) goto memset::@2
  to:memset::@return
memset::@return: scope:[memset]  from memset::@1
  [135] return 
  to:@return
memset::@2: scope:[memset]  from memset::@1
  [136] *memset::dst#2 = memset::c#0
  [137] memset::dst#1 = ++ memset::dst#2
  to:memset::@1

char div8u(char dividend , char divisor)
div8u: scope:[div8u]  from div8s::@4 test_8u::@1
  [138] div8u::divisor#2 = phi( div8s::@4/div8u::divisor#0, test_8u::@1/div8u::divisor#1 )
  [138] div8u::dividend#2 = phi( div8s::@4/div8u::dividend#0, test_8u::@1/div8u::dividend#1 )
  [139] divr8u::dividend#0 = div8u::dividend#2
  [140] divr8u::divisor#0 = div8u::divisor#2
  [141] call divr8u
  [142] divr8u::return#0 = divr8u::return#1
  to:div8u::@1
div8u::@1: scope:[div8u]  from div8u
  [143] div8u::return#0 = divr8u::return#0
  to:div8u::@return
div8u::@return: scope:[div8u]  from div8u::@1
  [144] return 
  to:@return

void print_uchar(char b)
print_uchar: scope:[print_uchar]  from print_schar::@2 print_uint print_uint::@1 test_8u::@2 test_8u::@4 test_8u::@6 test_8u::@8
  [145] print_char_cursor#142 = phi( print_schar::@2/print_char_cursor#18, print_uint/print_char_cursor#141, print_uint::@1/print_char_cursor#18, test_8u::@2/print_char_cursor#144, test_8u::@4/print_char_cursor#18, test_8u::@6/print_char_cursor#18, test_8u::@8/print_char_cursor#18 )
  [145] print_uchar::b#7 = phi( print_schar::@2/print_uchar::b#0, print_uint/print_uchar::b#1, print_uint::@1/print_uchar::b#2, test_8u::@2/print_uchar::b#3, test_8u::@4/print_uchar::b#4, test_8u::@6/print_uchar::b#5, test_8u::@8/print_uchar::b#6 )
  [146] print_uchar::$0 = print_uchar::b#7 >> 4
  [147] print_char::ch#5 = print_hextab[print_uchar::$0]
  [148] call print_char
  to:print_uchar::@1
print_uchar::@1: scope:[print_uchar]  from print_uchar
  [149] print_uchar::$2 = print_uchar::b#7 & $f
  [150] print_char::ch#6 = print_hextab[print_uchar::$2]
  [151] call print_char
  to:print_uchar::@return
print_uchar::@return: scope:[print_uchar]  from print_uchar::@1
  [152] return 
  to:@return

void print_str(char *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
  [153] print_str::str#16 = phi( test_16s::@3/str, test_16s::@5/str1, test_16s::@7/str2, test_16u::@3/str, test_16u::@5/str1, test_16u::@7/str2, test_8s::@3/str, test_8s::@5/str1, test_8s::@7/str2, test_8u::@3/str, test_8u::@5/str1, test_8u::@7/str2 )
  to:print_str::@1
print_str::@1: scope:[print_str]  from print_str print_str::@3
  [154] print_str::str#13 = phi( print_str/print_str::str#16, print_str::@3/print_str::str#0 )
  [155] if(0!=*print_str::str#13) goto print_str::@2
  to:print_str::@return
print_str::@return: scope:[print_str]  from print_str::@1
  [156] return 
  to:@return
print_str::@2: scope:[print_str]  from print_str::@1
  [157] print_char::ch#0 = *print_str::str#13
  [158] call print_char
  to:print_str::@3
print_str::@3: scope:[print_str]  from print_str::@2
  [159] print_str::str#0 = ++ print_str::str#13
  to:print_str::@1

void print_ln()
print_ln: scope:[print_ln]  from test_16s::@9 test_16u::@9 test_8s::@9 test_8u::@9
  [160] print_line_cursor#41 = phi( test_16s::@9/print_line_cursor#0, test_16u::@9/print_line_cursor#0, test_8s::@9/print_line_cursor#0, test_8u::@9/print_line_cursor#43 )
  to:print_ln::@1
print_ln::@1: scope:[print_ln]  from print_ln print_ln::@1
  [161] print_line_cursor#21 = phi( print_ln/print_line_cursor#41, print_ln::@1/print_line_cursor#0 )
  [162] print_line_cursor#0 = print_line_cursor#21 + $28
  [163] if(print_line_cursor#0<print_char_cursor#18) goto print_ln::@1
  to:print_ln::@return
print_ln::@return: scope:[print_ln]  from print_ln::@1
  [164] return 
  to:@return

unsigned int div16u(unsigned int dividend , unsigned int divisor)
div16u: scope:[div16u]  from test_16u::@1
  [165] divr16u::dividend#1 = div16u::dividend#0
  [166] divr16u::divisor#0 = div16u::divisor#0
  [167] call divr16u
  [168] divr16u::return#2 = divr16u::return#0
  to:div16u::@1
div16u::@1: scope:[div16u]  from div16u
  [169] div16u::return#0 = divr16u::return#2
  to:div16u::@return
div16u::@return: scope:[div16u]  from div16u::@1
  [170] return 
  to:@return

void print_uint(unsigned int w)
print_uint: scope:[print_uint]  from print_sint::@2 test_16u::@2 test_16u::@4 test_16u::@6 test_16u::@8
  [171] print_char_cursor#141 = phi( print_sint::@2/print_char_cursor#18, test_16u::@2/print_char_cursor#169, test_16u::@4/print_char_cursor#18, test_16u::@6/print_char_cursor#18, test_16u::@8/print_char_cursor#18 )
  [171] print_uint::w#5 = phi( print_sint::@2/print_uint::w#0, test_16u::@2/print_uint::w#1, test_16u::@4/print_uint::w#2, test_16u::@6/print_uint::w#3, test_16u::@8/print_uint::w#4 )
  [172] print_uchar::b#1 = byte1  print_uint::w#5
  [173] call print_uchar
  to:print_uint::@1
print_uint::@1: scope:[print_uint]  from print_uint
  [174] print_uchar::b#2 = byte0  print_uint::w#5
  [175] call print_uchar
  to:print_uint::@return
print_uint::@return: scope:[print_uint]  from print_uint::@1
  [176] return 
  to:@return

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

void print_schar(signed char b)
print_schar: scope:[print_schar]  from test_8s::@2 test_8s::@4 test_8s::@6 test_8s::@8
  [200] print_char_cursor#138 = phi( test_8s::@2/print_char_cursor#164, test_8s::@4/print_char_cursor#18, test_8s::@6/print_char_cursor#18, test_8s::@8/print_char_cursor#18 )
  [200] print_schar::b#10 = phi( test_8s::@2/print_schar::b#1, test_8s::@4/print_schar::b#2, test_8s::@6/print_schar::b#3, test_8s::@8/print_schar::b#4 )
  [201] if(print_schar::b#10<0) goto print_schar::@1
  to:print_schar::@3
print_schar::@3: scope:[print_schar]  from print_schar
  [202] phi()
  [203] call print_char
  to:print_schar::@2
print_schar::@2: scope:[print_schar]  from print_schar::@3 print_schar::@4
  [204] print_schar::b#7 = phi( print_schar::@4/print_schar::b#0, print_schar::@3/print_schar::b#10 )
  [205] print_uchar::b#0 = (char)print_schar::b#7
  [206] call print_uchar
  to:print_schar::@return
print_schar::@return: scope:[print_schar]  from print_schar::@2
  [207] return 
  to:@return
print_schar::@1: scope:[print_schar]  from print_schar
  [208] phi()
  [209] call print_char
  to:print_schar::@4
print_schar::@4: scope:[print_schar]  from print_schar::@1
  [210] print_schar::b#0 = - print_schar::b#10
  to:print_schar::@2

int div16s(int dividend , int divisor)
div16s: scope:[div16s]  from test_16s::@1
  [211] divr16s::dividend#0 = div16s::dividend#0
  [212] divr16s::divisor#0 = div16s::divisor#0
  [213] call divr16s
  [214] divr16s::return#3 = divr16s::return#2
  to:div16s::@1
div16s::@1: scope:[div16s]  from div16s
  [215] div16s::return#0 = divr16s::return#3
  to:div16s::@return
div16s::@return: scope:[div16s]  from div16s::@1
  [216] return 
  to:@return

void print_sint(int w)
print_sint: scope:[print_sint]  from test_16s::@2 test_16s::@4 test_16s::@6 test_16s::@8
  [217] print_char_cursor#135 = phi( test_16s::@2/print_char_cursor#160, test_16s::@4/print_char_cursor#18, test_16s::@6/print_char_cursor#18, test_16s::@8/print_char_cursor#18 )
  [217] print_sint::w#10 = phi( test_16s::@2/print_sint::w#1, test_16s::@4/print_sint::w#2, test_16s::@6/print_sint::w#3, test_16s::@8/print_sint::w#4 )
  [218] if(print_sint::w#10<0) goto print_sint::@1
  to:print_sint::@3
print_sint::@3: scope:[print_sint]  from print_sint
  [219] phi()
  [220] call print_char
  to:print_sint::@2
print_sint::@2: scope:[print_sint]  from print_sint::@3 print_sint::@4
  [221] print_sint::w#7 = phi( print_sint::@4/print_sint::w#0, print_sint::@3/print_sint::w#10 )
  [222] print_uint::w#0 = (unsigned int)print_sint::w#7
  [223] call print_uint
  to:print_sint::@return
print_sint::@return: scope:[print_sint]  from print_sint::@2
  [224] return 
  to:@return
print_sint::@1: scope:[print_sint]  from print_sint
  [225] phi()
  [226] call print_char
  to:print_sint::@4
print_sint::@4: scope:[print_sint]  from print_sint::@1
  [227] print_sint::w#0 = - print_sint::w#10
  to:print_sint::@2

char divr8u(char dividend , char divisor , char rem)
divr8u: scope:[divr8u]  from div8u
  [228] phi()
  to:divr8u::@1
divr8u::@1: scope:[divr8u]  from divr8u divr8u::@3
  [229] divr8u::i#2 = phi( divr8u/0, divr8u::@3/divr8u::i#1 )
  [229] divr8u::quotient#3 = phi( divr8u/0, divr8u::@3/divr8u::return#1 )
  [229] divr8u::dividend#2 = phi( divr8u/divr8u::dividend#0, divr8u::@3/divr8u::dividend#1 )
  [229] divr8u::rem#4 = phi( divr8u/0, divr8u::@3/divr8u::rem#10 )
  [230] divr8u::rem#1 = divr8u::rem#4 << 1
  [231] divr8u::$1 = divr8u::dividend#2 & $80
  [232] if(divr8u::$1==0) goto divr8u::@2
  to:divr8u::@4
divr8u::@4: scope:[divr8u]  from divr8u::@1
  [233] divr8u::rem#2 = divr8u::rem#1 | 1
  to:divr8u::@2
divr8u::@2: scope:[divr8u]  from divr8u::@1 divr8u::@4
  [234] divr8u::rem#5 = phi( divr8u::@1/divr8u::rem#1, divr8u::@4/divr8u::rem#2 )
  [235] divr8u::dividend#1 = divr8u::dividend#2 << 1
  [236] divr8u::quotient#1 = divr8u::quotient#3 << 1
  [237] if(divr8u::rem#5<divr8u::divisor#0) goto divr8u::@3
  to:divr8u::@5
divr8u::@5: scope:[divr8u]  from divr8u::@2
  [238] divr8u::quotient#2 = ++ divr8u::quotient#1
  [239] divr8u::rem#3 = divr8u::rem#5 - divr8u::divisor#0
  to:divr8u::@3
divr8u::@3: scope:[divr8u]  from divr8u::@2 divr8u::@5
  [240] divr8u::return#1 = phi( divr8u::@2/divr8u::quotient#1, divr8u::@5/divr8u::quotient#2 )
  [240] divr8u::rem#10 = phi( divr8u::@2/divr8u::rem#5, divr8u::@5/divr8u::rem#3 )
  [241] divr8u::i#1 = ++ divr8u::i#2
  [242] if(divr8u::i#1!=8) goto divr8u::@1
  to:divr8u::@6
divr8u::@6: scope:[divr8u]  from divr8u::@3
  [243] rem8u#18 = divr8u::rem#10
  to:divr8u::@return
divr8u::@return: scope:[divr8u]  from divr8u::@6
  [244] return 
  to:@return

void print_char(char ch)
print_char: scope:[print_char]  from print_schar::@1 print_schar::@3 print_sint::@1 print_sint::@3 print_str::@2 print_uchar print_uchar::@1
  [245] print_char_cursor#85 = phi( print_schar::@1/print_char_cursor#138, print_schar::@3/print_char_cursor#138, print_sint::@1/print_char_cursor#135, print_sint::@3/print_char_cursor#135, print_str::@2/print_char_cursor#18, print_uchar/print_char_cursor#142, print_uchar::@1/print_char_cursor#18 )
  [245] print_char::ch#7 = phi( print_schar::@1/'-', print_schar::@3/' ', print_sint::@1/'-', print_sint::@3/' ', print_str::@2/print_char::ch#0, print_uchar/print_char::ch#5, print_uchar::@1/print_char::ch#6 )
  [246] *print_char_cursor#85 = print_char::ch#7
  [247] print_char_cursor#18 = ++ print_char_cursor#85
  to:print_char::@return
print_char::@return: scope:[print_char]  from print_char
  [248] return 
  to:@return

unsigned int divr16u(unsigned int dividend , unsigned int divisor , unsigned int rem)
divr16u: scope:[divr16u]  from div16u divr16s::@4
  [249] divr16u::divisor#6 = phi( div16u/divr16u::divisor#0, divr16s::@4/divr16u::divisor#1 )
  [249] divr16u::dividend#5 = phi( div16u/divr16u::dividend#1, divr16s::@4/divr16u::dividend#2 )
  to:divr16u::@1
divr16u::@1: scope:[divr16u]  from divr16u divr16u::@3
  [250] divr16u::i#2 = phi( divr16u/0, divr16u::@3/divr16u::i#1 )
  [250] divr16u::quotient#3 = phi( divr16u/0, divr16u::@3/divr16u::return#0 )
  [250] divr16u::dividend#3 = phi( divr16u/divr16u::dividend#5, divr16u::@3/divr16u::dividend#0 )
  [250] divr16u::rem#5 = phi( divr16u/0, divr16u::@3/divr16u::rem#11 )
  [251] divr16u::rem#0 = divr16u::rem#5 << 1
  [252] divr16u::$1 = byte1  divr16u::dividend#3
  [253] divr16u::$2 = divr16u::$1 & $80
  [254] if(divr16u::$2==0) goto divr16u::@2
  to:divr16u::@4
divr16u::@4: scope:[divr16u]  from divr16u::@1
  [255] divr16u::rem#1 = divr16u::rem#0 | 1
  to:divr16u::@2
divr16u::@2: scope:[divr16u]  from divr16u::@1 divr16u::@4
  [256] divr16u::rem#6 = phi( divr16u::@1/divr16u::rem#0, divr16u::@4/divr16u::rem#1 )
  [257] divr16u::dividend#0 = divr16u::dividend#3 << 1
  [258] divr16u::quotient#1 = divr16u::quotient#3 << 1
  [259] if(divr16u::rem#6<divr16u::divisor#6) goto divr16u::@3
  to:divr16u::@5
divr16u::@5: scope:[divr16u]  from divr16u::@2
  [260] divr16u::quotient#2 = ++ divr16u::quotient#1
  [261] divr16u::rem#2 = divr16u::rem#6 - divr16u::divisor#6
  to:divr16u::@3
divr16u::@3: scope:[divr16u]  from divr16u::@2 divr16u::@5
  [262] divr16u::return#0 = phi( divr16u::@2/divr16u::quotient#1, divr16u::@5/divr16u::quotient#2 )
  [262] divr16u::rem#11 = phi( divr16u::@2/divr16u::rem#6, divr16u::@5/divr16u::rem#2 )
  [263] divr16u::i#1 = ++ divr16u::i#2
  [264] if(divr16u::i#1!=$10) goto divr16u::@1
  to:divr16u::@6
divr16u::@6: scope:[divr16u]  from divr16u::@3
  [265] rem16u#0 = divr16u::rem#11
  to:divr16u::@return
divr16u::@return: scope:[divr16u]  from divr16u::@6
  [266] return 
  to:@return

int divr16s(int dividend , int divisor , int rem)
divr16s: scope:[divr16s]  from div16s
  [267] if(divr16s::dividend#0<0) goto divr16s::@1
  to:divr16s::@6
divr16s::@6: scope:[divr16s]  from divr16s
  [268] divr16s::dividendu#8 = (unsigned int)divr16s::dividend#0
  to:divr16s::@2
divr16s::@2: scope:[divr16s]  from divr16s::@1 divr16s::@6
  [269] divr16s::dividendu#3 = phi( divr16s::@1/divr16s::dividendu#7, divr16s::@6/divr16s::dividendu#8 )
  [269] divr16s::neg#3 = phi( divr16s::@1/1, divr16s::@6/0 )
  [270] if(divr16s::divisor#0<0) goto divr16s::@3
  to:divr16s::@7
divr16s::@7: scope:[divr16s]  from divr16s::@2
  [271] divr16s::divisoru#5 = (unsigned int)divr16s::divisor#0
  to:divr16s::@4
divr16s::@4: scope:[divr16s]  from divr16s::@3 divr16s::@7
  [272] divr16s::neg#4 = phi( divr16s::@3/divr16s::neg#2, divr16s::@7/divr16s::neg#3 )
  [272] divr16s::divisoru#3 = phi( divr16s::@3/divr16s::divisoru#4, divr16s::@7/divr16s::divisoru#5 )
  [273] divr16u::dividend#2 = divr16s::dividendu#3
  [274] divr16u::divisor#1 = divr16s::divisoru#3
  [275] call divr16u
  [276] divr16u::return#3 = divr16u::return#0
  to:divr16s::@9
divr16s::@9: scope:[divr16s]  from divr16s::@4
  [277] divr16s::resultu#0 = divr16u::return#3
  [278] if(divr16s::neg#4==0) goto divr16s::@5
  to:divr16s::@8
divr16s::@8: scope:[divr16s]  from divr16s::@9
  [279] rem16s#1 = - (int)rem16u#0
  [280] divr16s::return#1 = - (int)divr16s::resultu#0
  to:divr16s::@return
divr16s::@return: scope:[divr16s]  from divr16s::@5 divr16s::@8
  [281] rem16s#12 = phi( divr16s::@5/rem16s#38, divr16s::@8/rem16s#1 )
  [281] divr16s::return#2 = phi( divr16s::@5/divr16s::return#6, divr16s::@8/divr16s::return#1 )
  [282] return 
  to:@return
divr16s::@5: scope:[divr16s]  from divr16s::@9
  [283] divr16s::return#6 = (int)divr16s::resultu#0
  [284] rem16s#38 = (int)rem16u#0
  to:divr16s::@return
divr16s::@3: scope:[divr16s]  from divr16s::@2
  [285] divr16s::divisoru#1 = - divr16s::divisor#0
  [286] divr16s::neg#2 = divr16s::neg#3 ^ 1
  [287] divr16s::divisoru#4 = (unsigned int)divr16s::divisoru#1
  to:divr16s::@4
divr16s::@1: scope:[divr16s]  from divr16s
  [288] divr16s::dividendu#1 = - divr16s::dividend#0
  [289] divr16s::dividendu#7 = (unsigned int)divr16s::dividendu#1
  to:divr16s::@2
