
void main()
main: scope:[main]  from
  [0] *BG_COLOR = 5
  [1] call print_cls
  to:main::@1
main::@1: scope:[main]  from main
  [2] phi()
  [3] call mulf_init
  to:main::@2
main::@2: scope:[main]  from main::@1
  [4] phi()
  [5] call mulf_init_asm
  to:main::@3
main::@3: scope:[main]  from main::@2
  [6] phi()
  [7] call mulf_tables_cmp
  to:main::@4
main::@4: scope:[main]  from main::@3
  [8] phi()
  [9] call mul8u_compare
  to:main::@5
main::@5: scope:[main]  from main::@4
  [10] phi()
  [11] call mul8s_compare
  to:main::@return
main::@return: scope:[main]  from main::@5
  [12] return 
  to:@return

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

void mulf_init()
mulf_init: scope:[mulf_init]  from main::@1
  [16] phi()
  to:mulf_init::@1
mulf_init::@1: scope:[mulf_init]  from mulf_init mulf_init::@3
  [17] mulf_init::x_2#3 = phi( mulf_init/0, mulf_init::@3/mulf_init::x_2#2 )
  [17] mulf_init::sqr1_hi#2 = phi( mulf_init/mulf_sqr1_hi+1, mulf_init::@3/mulf_init::sqr1_hi#1 )
  [17] mulf_init::sqr#4 = phi( mulf_init/0, mulf_init::@3/mulf_init::sqr#1 )
  [17] mulf_init::c#2 = phi( mulf_init/0, mulf_init::@3/mulf_init::c#1 )
  [17] mulf_init::sqr1_lo#2 = phi( mulf_init/mulf_sqr1_lo+1, mulf_init::@3/mulf_init::sqr1_lo#1 )
  [18] if(mulf_init::sqr1_lo#2!=mulf_sqr1_lo+$200) goto mulf_init::@2
  to:mulf_init::@5
mulf_init::@5: scope:[mulf_init]  from mulf_init::@1 mulf_init::@8
  [19] mulf_init::dir#2 = phi( mulf_init::@1/$ff, mulf_init::@8/mulf_init::dir#4 )
  [19] mulf_init::sqr2_hi#2 = phi( mulf_init::@1/mulf_sqr2_hi, mulf_init::@8/mulf_init::sqr2_hi#1 )
  [19] mulf_init::x_255#2 = phi( mulf_init::@1/-1, mulf_init::@8/mulf_init::x_255#1 )
  [19] mulf_init::sqr2_lo#2 = phi( mulf_init::@1/mulf_sqr2_lo, mulf_init::@8/mulf_init::sqr2_lo#1 )
  [20] if(mulf_init::sqr2_lo#2!=mulf_sqr2_lo+$1ff) goto mulf_init::@6
  to:mulf_init::@7
mulf_init::@7: scope:[mulf_init]  from mulf_init::@5
  [21] *(mulf_sqr2_lo+$1ff) = *(mulf_sqr1_lo+$100)
  [22] *(mulf_sqr2_hi+$1ff) = *(mulf_sqr1_hi+$100)
  to:mulf_init::@return
mulf_init::@return: scope:[mulf_init]  from mulf_init::@7
  [23] return 
  to:@return
mulf_init::@6: scope:[mulf_init]  from mulf_init::@5
  [24] *mulf_init::sqr2_lo#2 = mulf_sqr1_lo[mulf_init::x_255#2]
  [25] *mulf_init::sqr2_hi#2 = mulf_sqr1_hi[mulf_init::x_255#2]
  [26] mulf_init::sqr2_hi#1 = ++ mulf_init::sqr2_hi#2
  [27] mulf_init::x_255#1 = mulf_init::x_255#2 + mulf_init::dir#2
  [28] if(mulf_init::x_255#1!=0) goto mulf_init::@9
  to:mulf_init::@8
mulf_init::@9: scope:[mulf_init]  from mulf_init::@6
  [29] phi()
  to:mulf_init::@8
mulf_init::@8: scope:[mulf_init]  from mulf_init::@6 mulf_init::@9
  [30] mulf_init::dir#4 = phi( mulf_init::@6/1, mulf_init::@9/mulf_init::dir#2 )
  [31] mulf_init::sqr2_lo#1 = ++ mulf_init::sqr2_lo#2
  to:mulf_init::@5
mulf_init::@2: scope:[mulf_init]  from mulf_init::@1
  [32] mulf_init::c#1 = ++ mulf_init::c#2
  [33] mulf_init::$1 = mulf_init::c#1 & 1
  [34] if(mulf_init::$1!=0) goto mulf_init::@3
  to:mulf_init::@4
mulf_init::@4: scope:[mulf_init]  from mulf_init::@2
  [35] mulf_init::x_2#1 = ++ mulf_init::x_2#3
  [36] mulf_init::sqr#2 = ++ mulf_init::sqr#4
  to:mulf_init::@3
mulf_init::@3: scope:[mulf_init]  from mulf_init::@2 mulf_init::@4
  [37] mulf_init::x_2#2 = phi( mulf_init::@2/mulf_init::x_2#3, mulf_init::@4/mulf_init::x_2#1 )
  [37] mulf_init::sqr#3 = phi( mulf_init::@2/mulf_init::sqr#4, mulf_init::@4/mulf_init::sqr#2 )
  [38] mulf_init::$4 = byte0  mulf_init::sqr#3
  [39] *mulf_init::sqr1_lo#2 = mulf_init::$4
  [40] mulf_init::$5 = byte1  mulf_init::sqr#3
  [41] *mulf_init::sqr1_hi#2 = mulf_init::$5
  [42] mulf_init::sqr1_hi#1 = ++ mulf_init::sqr1_hi#2
  [43] mulf_init::sqr#1 = mulf_init::sqr#3 + mulf_init::x_2#2
  [44] mulf_init::sqr1_lo#1 = ++ mulf_init::sqr1_lo#2
  to:mulf_init::@1

void mulf_init_asm()
mulf_init_asm: scope:[mulf_init_asm]  from main::@2
  asm { ldx#$00 txa .byte$c9 lb1: tya adc#$00 ml1: stamula_sqr1_hi,x tay cmp#$40 txa ror ml9: adc#$00 staml9+1 inx ml0: stamula_sqr1_lo,x bnelb1 incml0+2 incml1+2 clc iny bnelb1 ldx#$00 ldy#$ff !: ldamula_sqr1_hi+1,x stamula_sqr2_hi+$100,x ldamula_sqr1_hi,x stamula_sqr2_hi,y ldamula_sqr1_lo+1,x stamula_sqr2_lo+$100,x ldamula_sqr1_lo,x stamula_sqr2_lo,y dey inx bne!-  }
  [46] *mulf_init_asm::mem = *mula_sqr1_lo
  [47] *mulf_init_asm::mem = *mula_sqr1_hi
  [48] *mulf_init_asm::mem = *mula_sqr2_lo
  [49] *mulf_init_asm::mem = *mula_sqr2_hi
  to:mulf_init_asm::@return
mulf_init_asm::@return: scope:[mulf_init_asm]  from mulf_init_asm
  [50] return 
  to:@return

void mulf_tables_cmp()
mulf_tables_cmp: scope:[mulf_tables_cmp]  from main::@3
  [51] phi()
  to:mulf_tables_cmp::@1
mulf_tables_cmp::@1: scope:[mulf_tables_cmp]  from mulf_tables_cmp mulf_tables_cmp::@4
  [52] mulf_tables_cmp::asm_sqr#2 = phi( mulf_tables_cmp/mula_sqr1_lo, mulf_tables_cmp::@4/mulf_tables_cmp::asm_sqr#1 )
  [52] mulf_tables_cmp::kc_sqr#2 = phi( mulf_tables_cmp/mulf_sqr1_lo, mulf_tables_cmp::@4/mulf_tables_cmp::kc_sqr#1 )
  [53] if(mulf_tables_cmp::kc_sqr#2<mulf_sqr1_lo+$200*4) goto mulf_tables_cmp::@2
  to:mulf_tables_cmp::@3
mulf_tables_cmp::@3: scope:[mulf_tables_cmp]  from mulf_tables_cmp::@1
  [54] phi()
  [55] call print_str
  to:mulf_tables_cmp::@6
mulf_tables_cmp::@6: scope:[mulf_tables_cmp]  from mulf_tables_cmp::@3
  [56] phi()
  [57] call print_ln
  to:mulf_tables_cmp::@7
mulf_tables_cmp::@7: scope:[mulf_tables_cmp]  from mulf_tables_cmp::@6
  [58] print_char_cursor#231 = print_line_cursor#0
  to:mulf_tables_cmp::@return
mulf_tables_cmp::@return: scope:[mulf_tables_cmp]  from mulf_tables_cmp::@10 mulf_tables_cmp::@7
  [59] print_line_cursor#10 = phi( mulf_tables_cmp::@10/print_screen#0, mulf_tables_cmp::@7/print_line_cursor#0 )
  [59] print_char_cursor#101 = phi( mulf_tables_cmp::@10/print_char_cursor#18, mulf_tables_cmp::@7/print_char_cursor#231 )
  [60] return 
  to:@return
mulf_tables_cmp::@2: scope:[mulf_tables_cmp]  from mulf_tables_cmp::@1
  [61] if(*mulf_tables_cmp::kc_sqr#2==*mulf_tables_cmp::asm_sqr#2) goto mulf_tables_cmp::@4
  to:mulf_tables_cmp::@5
mulf_tables_cmp::@5: scope:[mulf_tables_cmp]  from mulf_tables_cmp::@2
  [62] *BG_COLOR = 2
  [63] call print_str
  to:mulf_tables_cmp::@8
mulf_tables_cmp::@8: scope:[mulf_tables_cmp]  from mulf_tables_cmp::@5
  [64] print_uint::w#1 = (unsigned int)mulf_tables_cmp::asm_sqr#2
  [65] call print_uint
  to:mulf_tables_cmp::@9
mulf_tables_cmp::@9: scope:[mulf_tables_cmp]  from mulf_tables_cmp::@8
  [66] phi()
  [67] call print_str
  to:mulf_tables_cmp::@10
mulf_tables_cmp::@10: scope:[mulf_tables_cmp]  from mulf_tables_cmp::@9
  [68] print_uint::w#2 = (unsigned int)mulf_tables_cmp::kc_sqr#2
  [69] call print_uint
  to:mulf_tables_cmp::@return
mulf_tables_cmp::@4: scope:[mulf_tables_cmp]  from mulf_tables_cmp::@2
  [70] mulf_tables_cmp::asm_sqr#1 = ++ mulf_tables_cmp::asm_sqr#2
  [71] mulf_tables_cmp::kc_sqr#1 = ++ mulf_tables_cmp::kc_sqr#2
  to:mulf_tables_cmp::@1

void mul8u_compare()
mul8u_compare: scope:[mul8u_compare]  from main::@4
  [72] phi()
  to:mul8u_compare::@1
mul8u_compare::@1: scope:[mul8u_compare]  from mul8u_compare mul8u_compare::@8
  [73] mul8u_compare::a#7 = phi( mul8u_compare/0, mul8u_compare::@8/mul8u_compare::a#1 )
  to:mul8u_compare::@2
mul8u_compare::@2: scope:[mul8u_compare]  from mul8u_compare::@1 mul8u_compare::@5
  [74] mul8u_compare::b#10 = phi( mul8u_compare::@1/0, mul8u_compare::@5/mul8u_compare::b#1 )
  [75] muls8u::a#0 = mul8u_compare::a#7
  [76] muls8u::b#0 = mul8u_compare::b#10
  [77] call muls8u
  [78] muls8u::return#2 = muls8u::return#0
  to:mul8u_compare::@10
mul8u_compare::@10: scope:[mul8u_compare]  from mul8u_compare::@2
  [79] mul8u_compare::ms#0 = muls8u::return#2
  [80] mulf8u::a#0 = mul8u_compare::a#7
  [81] mulf8u::b#0 = mul8u_compare::b#10
  [82] call mulf8u
  [83] mulf8u::return#2 = mulf8u::return#0
  to:mul8u_compare::@11
mul8u_compare::@11: scope:[mul8u_compare]  from mul8u_compare::@10
  [84] mul8u_compare::mf#0 = mulf8u::return#2
  [85] mul8u::a#2 = mul8u_compare::a#7
  [86] mul8u::b#1 = mul8u_compare::b#10
  [87] call mul8u
  [88] mul8u::return#3 = mul8u::res#2
  to:mul8u_compare::@12
mul8u_compare::@12: scope:[mul8u_compare]  from mul8u_compare::@11
  [89] mul8u_compare::mn#0 = mul8u::return#3
  [90] if(mul8u_compare::ms#0==mul8u_compare::mf#0) goto mul8u_compare::@3
  to:mul8u_compare::@6
mul8u_compare::@6: scope:[mul8u_compare]  from mul8u_compare::@12
  [91] phi()
  to:mul8u_compare::@3
mul8u_compare::@3: scope:[mul8u_compare]  from mul8u_compare::@12 mul8u_compare::@6
  [92] mul8u_compare::ok#4 = phi( mul8u_compare::@12/1, mul8u_compare::@6/0 )
  [93] if(mul8u_compare::ms#0==mul8u_compare::mn#0) goto mul8u_compare::@14
  to:mul8u_compare::@4
mul8u_compare::@14: scope:[mul8u_compare]  from mul8u_compare::@3
  [94] phi()
  to:mul8u_compare::@4
mul8u_compare::@4: scope:[mul8u_compare]  from mul8u_compare::@14 mul8u_compare::@3
  [95] mul8u_compare::ok#3 = phi( mul8u_compare::@14/mul8u_compare::ok#4, mul8u_compare::@3/0 )
  [96] if(mul8u_compare::ok#3!=0) goto mul8u_compare::@5
  to:mul8u_compare::@7
mul8u_compare::@7: scope:[mul8u_compare]  from mul8u_compare::@4
  [97] *BG_COLOR = 2
  [98] mul8u_error::a#0 = mul8u_compare::a#7
  [99] mul8u_error::b#0 = mul8u_compare::b#10
  [100] mul8u_error::ms#0 = mul8u_compare::ms#0
  [101] mul8u_error::mn#0 = mul8u_compare::mn#0
  [102] mul8u_error::mf#0 = mul8u_compare::mf#0
  [103] call mul8u_error
  to:mul8u_compare::@return
mul8u_compare::@return: scope:[mul8u_compare]  from mul8u_compare::@13 mul8u_compare::@7
  [104] return 
  to:@return
mul8u_compare::@5: scope:[mul8u_compare]  from mul8u_compare::@4
  [105] mul8u_compare::b#1 = ++ mul8u_compare::b#10
  [106] if(mul8u_compare::b#1!=0) goto mul8u_compare::@2
  to:mul8u_compare::@8
mul8u_compare::@8: scope:[mul8u_compare]  from mul8u_compare::@5
  [107] mul8u_compare::a#1 = ++ mul8u_compare::a#7
  [108] if(mul8u_compare::a#1!=0) goto mul8u_compare::@1
  to:mul8u_compare::@9
mul8u_compare::@9: scope:[mul8u_compare]  from mul8u_compare::@8
  [109] phi()
  [110] call print_str
  to:mul8u_compare::@13
mul8u_compare::@13: scope:[mul8u_compare]  from mul8u_compare::@9
  [111] phi()
  [112] call print_ln
  to:mul8u_compare::@return

void mul8s_compare()
mul8s_compare: scope:[mul8s_compare]  from main::@5
  [113] phi()
  to:mul8s_compare::@1
mul8s_compare::@1: scope:[mul8s_compare]  from mul8s_compare mul8s_compare::@5
  [114] mul8s_compare::a#10 = phi( mul8s_compare/-$80, mul8s_compare::@5/mul8s_compare::a#1 )
  [115] if(mul8s_compare::a#10!=-$80) goto mul8s_compare::@3
  to:mul8s_compare::@2
mul8s_compare::@2: scope:[mul8s_compare]  from mul8s_compare::@1
  [116] print_char_cursor#192 = print_line_cursor#0
  [117] call print_str
  to:mul8s_compare::@11
mul8s_compare::@11: scope:[mul8s_compare]  from mul8s_compare::@2
  [118] phi()
  [119] call print_ln
  to:mul8s_compare::@return
mul8s_compare::@return: scope:[mul8s_compare]  from mul8s_compare::@10 mul8s_compare::@11
  [120] return 
  to:@return
mul8s_compare::@3: scope:[mul8s_compare]  from mul8s_compare::@1 mul8s_compare::@8
  [121] mul8s_compare::b#10 = phi( mul8s_compare::@1/-$80, mul8s_compare::@8/mul8s_compare::b#1 )
  [122] if(mul8s_compare::b#10!=-$80) goto mul8s_compare::@4
  to:mul8s_compare::@5
mul8s_compare::@5: scope:[mul8s_compare]  from mul8s_compare::@3
  [123] mul8s_compare::a#1 = ++ mul8s_compare::a#10
  to:mul8s_compare::@1
mul8s_compare::@4: scope:[mul8s_compare]  from mul8s_compare::@3
  [124] muls8s::a#0 = mul8s_compare::a#10
  [125] muls8s::b#0 = mul8s_compare::b#10
  [126] call muls8s
  [127] muls8s::return#2 = muls8s::return#0
  to:mul8s_compare::@12
mul8s_compare::@12: scope:[mul8s_compare]  from mul8s_compare::@4
  [128] mul8s_compare::ms#0 = muls8s::return#2
  [129] mulf8s::a#0 = mul8s_compare::a#10
  [130] mulf8s::b#0 = mul8s_compare::b#10
  [131] call mulf8s
  [132] mulf8s::return#2 = mulf8s::return#0
  to:mul8s_compare::@13
mul8s_compare::@13: scope:[mul8s_compare]  from mul8s_compare::@12
  [133] mul8s_compare::mf#0 = mulf8s::return#2
  [134] mul8s::a#0 = mul8s_compare::a#10
  [135] mul8s::b#0 = mul8s_compare::b#10
  [136] call mul8s
  to:mul8s_compare::@14
mul8s_compare::@14: scope:[mul8s_compare]  from mul8s_compare::@13
  [137] mul8s_compare::mn#0 = (int)mul8s::m#4
  [138] if(mul8s_compare::ms#0==mul8s_compare::mf#0) goto mul8s_compare::@6
  to:mul8s_compare::@9
mul8s_compare::@9: scope:[mul8s_compare]  from mul8s_compare::@14
  [139] phi()
  to:mul8s_compare::@6
mul8s_compare::@6: scope:[mul8s_compare]  from mul8s_compare::@14 mul8s_compare::@9
  [140] mul8s_compare::ok#4 = phi( mul8s_compare::@9/0, mul8s_compare::@14/1 )
  [141] if(mul8s_compare::ms#0==mul8s_compare::mn#0) goto mul8s_compare::@15
  to:mul8s_compare::@7
mul8s_compare::@15: scope:[mul8s_compare]  from mul8s_compare::@6
  [142] phi()
  to:mul8s_compare::@7
mul8s_compare::@7: scope:[mul8s_compare]  from mul8s_compare::@15 mul8s_compare::@6
  [143] mul8s_compare::ok#3 = phi( mul8s_compare::@6/0, mul8s_compare::@15/mul8s_compare::ok#4 )
  [144] if(mul8s_compare::ok#3!=0) goto mul8s_compare::@8
  to:mul8s_compare::@10
mul8s_compare::@10: scope:[mul8s_compare]  from mul8s_compare::@7
  [145] *BG_COLOR = 2
  [146] mul8s_error::a#0 = mul8s_compare::a#10
  [147] mul8s_error::b#0 = mul8s_compare::b#10
  [148] mul8s_error::ms#0 = mul8s_compare::ms#0
  [149] mul8s_error::mn#0 = mul8s_compare::mn#0
  [150] mul8s_error::mf#0 = mul8s_compare::mf#0
  [151] call mul8s_error
  to:mul8s_compare::@return
mul8s_compare::@8: scope:[mul8s_compare]  from mul8s_compare::@7
  [152] mul8s_compare::b#1 = ++ mul8s_compare::b#10
  to:mul8s_compare::@3

void * memset(void *str , char c , unsigned int num)
memset: scope:[memset]  from print_cls
  [153] phi()
  to:memset::@1
memset::@1: scope:[memset]  from memset memset::@2
  [154] memset::dst#2 = phi( memset/(char *)memset::str#0, memset::@2/memset::dst#1 )
  [155] if(memset::dst#2!=memset::end#0) goto memset::@2
  to:memset::@return
memset::@return: scope:[memset]  from memset::@1
  [156] return 
  to:@return
memset::@2: scope:[memset]  from memset::@1
  [157] *memset::dst#2 = memset::c#0
  [158] memset::dst#1 = ++ memset::dst#2
  to:memset::@1

void print_str(char *str)
print_str: scope:[print_str]  from mul8s_compare::@2 mul8s_error mul8s_error::@2 mul8s_error::@4 mul8s_error::@6 mul8s_error::@8 mul8u_compare::@9 mul8u_error mul8u_error::@2 mul8u_error::@4 mul8u_error::@6 mul8u_error::@8 mulf_tables_cmp::@3 mulf_tables_cmp::@5 mulf_tables_cmp::@9
  [159] print_char_cursor#158 = phi( mul8s_compare::@2/print_char_cursor#192, mul8s_error/print_char_cursor#193, mul8s_error::@2/print_char_cursor#18, mul8s_error::@4/print_char_cursor#18, mul8s_error::@6/print_char_cursor#18, mul8s_error::@8/print_char_cursor#18, mul8u_compare::@9/print_char_cursor#101, mul8u_error/print_char_cursor#101, mul8u_error::@2/print_char_cursor#18, mul8u_error::@4/print_char_cursor#18, mul8u_error::@6/print_char_cursor#18, mul8u_error::@8/print_char_cursor#18, mulf_tables_cmp::@3/print_screen#0, mulf_tables_cmp::@5/print_screen#0, mulf_tables_cmp::@9/print_char_cursor#18 )
  [159] print_str::str#19 = phi( mul8s_compare::@2/mul8s_compare::str, mul8s_error/mul8s_error::str, mul8s_error::@2/str1, mul8s_error::@4/str2, mul8s_error::@6/str3, mul8s_error::@8/str4, mul8u_compare::@9/mul8u_compare::str, mul8u_error/mul8u_error::str, mul8u_error::@2/str1, mul8u_error::@4/str2, mul8u_error::@6/str3, mul8u_error::@8/str4, mulf_tables_cmp::@3/mulf_tables_cmp::str, mulf_tables_cmp::@5/mulf_tables_cmp::str1, mulf_tables_cmp::@9/mulf_tables_cmp::str2 )
  to:print_str::@1
print_str::@1: scope:[print_str]  from print_str print_str::@3
  [160] print_char_cursor#1 = phi( print_str/print_char_cursor#158, print_str::@3/print_char_cursor#18 )
  [160] print_str::str#16 = phi( print_str/print_str::str#19, print_str::@3/print_str::str#0 )
  [161] if(0!=*print_str::str#16) goto print_str::@2
  to:print_str::@return
print_str::@return: scope:[print_str]  from print_str::@1
  [162] return 
  to:@return
print_str::@2: scope:[print_str]  from print_str::@1
  [163] print_char::ch#0 = *print_str::str#16
  [164] call print_char
  to:print_str::@3
print_str::@3: scope:[print_str]  from print_str::@2
  [165] print_str::str#0 = ++ print_str::str#16
  to:print_str::@1

void print_ln()
print_ln: scope:[print_ln]  from mul8s_compare::@11 mul8s_error::@10 mul8u_compare::@13 mul8u_error::@10 mulf_tables_cmp::@6
  [166] print_char_cursor#138 = phi( mul8s_compare::@11/print_char_cursor#1, mul8s_error::@10/print_char_cursor#18, mul8u_compare::@13/print_char_cursor#1, mul8u_error::@10/print_char_cursor#18, mulf_tables_cmp::@6/print_char_cursor#1 )
  [166] print_line_cursor#47 = phi( mul8s_compare::@11/print_line_cursor#0, mul8s_error::@10/print_line_cursor#0, mul8u_compare::@13/print_line_cursor#10, mul8u_error::@10/print_line_cursor#10, mulf_tables_cmp::@6/print_screen#0 )
  to:print_ln::@1
print_ln::@1: scope:[print_ln]  from print_ln print_ln::@1
  [167] print_line_cursor#24 = phi( print_ln/print_line_cursor#47, print_ln::@1/print_line_cursor#0 )
  [168] print_line_cursor#0 = print_line_cursor#24 + $28
  [169] if(print_line_cursor#0<print_char_cursor#138) goto print_ln::@1
  to:print_ln::@return
print_ln::@return: scope:[print_ln]  from print_ln::@1
  [170] return 
  to:@return

void print_uint(unsigned int w)
print_uint: scope:[print_uint]  from mul8u_error::@5 mul8u_error::@7 mul8u_error::@9 mulf_tables_cmp::@10 mulf_tables_cmp::@8 print_sint::@2
  [171] print_char_cursor#145 = phi( mul8u_error::@5/print_char_cursor#1, mul8u_error::@7/print_char_cursor#1, mul8u_error::@9/print_char_cursor#1, mulf_tables_cmp::@10/print_char_cursor#1, mulf_tables_cmp::@8/print_char_cursor#1, print_sint::@2/print_char_cursor#18 )
  [171] print_uint::w#6 = phi( mul8u_error::@5/print_uint::w#3, mul8u_error::@7/print_uint::w#4, mul8u_error::@9/print_uint::w#5, mulf_tables_cmp::@10/print_uint::w#2, mulf_tables_cmp::@8/print_uint::w#1, print_sint::@2/print_uint::w#0 )
  [172] print_uchar::b#1 = byte1  print_uint::w#6
  [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#6
  [175] call print_uchar
  to:print_uint::@return
print_uint::@return: scope:[print_uint]  from print_uint::@1
  [176] return 
  to:@return

unsigned int muls8u(char a , char b)
muls8u: scope:[muls8u]  from mul8u_compare::@2
  [177] if(muls8u::a#0==0) goto muls8u::@1
  to:muls8u::@2
muls8u::@2: scope:[muls8u]  from muls8u muls8u::@3
  [178] muls8u::m#3 = phi( muls8u/0, muls8u::@3/muls8u::m#1 )
  [178] muls8u::i#2 = phi( muls8u/0, muls8u::@3/muls8u::i#1 )
  [179] if(muls8u::i#2!=muls8u::a#0) goto muls8u::@3
  to:muls8u::@1
muls8u::@1: scope:[muls8u]  from muls8u muls8u::@2
  [180] muls8u::return#0 = phi( muls8u/0, muls8u::@2/muls8u::m#3 )
  to:muls8u::@return
muls8u::@return: scope:[muls8u]  from muls8u::@1
  [181] return 
  to:@return
muls8u::@3: scope:[muls8u]  from muls8u::@2
  [182] muls8u::m#1 = muls8u::m#3 + muls8u::b#0
  [183] muls8u::i#1 = ++ muls8u::i#2
  to:muls8u::@2

unsigned int mulf8u(char a , char b)
mulf8u: scope:[mulf8u]  from mul8u_compare::@10
  [184] mulf8u_prepare::a#0 = mulf8u::a#0
  [185] call mulf8u_prepare
  to:mulf8u::@1
mulf8u::@1: scope:[mulf8u]  from mulf8u
  [186] mulf8u_prepared::b#0 = mulf8u::b#0
  [187] call mulf8u_prepared
  [188] mulf8u_prepared::return#2 = mulf8u_prepared::return#0
  to:mulf8u::@2
mulf8u::@2: scope:[mulf8u]  from mulf8u::@1
  [189] mulf8u::return#0 = mulf8u_prepared::return#2
  to:mulf8u::@return
mulf8u::@return: scope:[mulf8u]  from mulf8u::@2
  [190] return 
  to:@return

unsigned int mul8u(char a , char b)
mul8u: scope:[mul8u]  from mul8s mul8u_compare::@11
  [191] mul8u::a#6 = phi( mul8s/mul8u::a#1, mul8u_compare::@11/mul8u::a#2 )
  [191] mul8u::b#2 = phi( mul8s/mul8u::b#0, mul8u_compare::@11/mul8u::b#1 )
  [192] mul8u::mb#0 = (unsigned int)mul8u::b#2
  to:mul8u::@1
mul8u::@1: scope:[mul8u]  from mul8u mul8u::@3
  [193] mul8u::mb#2 = phi( mul8u/mul8u::mb#0, mul8u::@3/mul8u::mb#1 )
  [193] mul8u::res#2 = phi( mul8u/0, mul8u::@3/mul8u::res#6 )
  [193] mul8u::a#3 = phi( mul8u/mul8u::a#6, mul8u::@3/mul8u::a#0 )
  [194] if(mul8u::a#3!=0) goto mul8u::@2
  to:mul8u::@return
mul8u::@return: scope:[mul8u]  from mul8u::@1
  [195] return 
  to:@return
mul8u::@2: scope:[mul8u]  from mul8u::@1
  [196] mul8u::$1 = mul8u::a#3 & 1
  [197] if(mul8u::$1==0) goto mul8u::@3
  to:mul8u::@4
mul8u::@4: scope:[mul8u]  from mul8u::@2
  [198] mul8u::res#1 = mul8u::res#2 + mul8u::mb#2
  to:mul8u::@3
mul8u::@3: scope:[mul8u]  from mul8u::@2 mul8u::@4
  [199] mul8u::res#6 = phi( mul8u::@2/mul8u::res#2, mul8u::@4/mul8u::res#1 )
  [200] mul8u::a#0 = mul8u::a#3 >> 1
  [201] mul8u::mb#1 = mul8u::mb#2 << 1
  to:mul8u::@1

void mul8u_error(char a , char b , unsigned int ms , unsigned int mn , unsigned int mf)
mul8u_error: scope:[mul8u_error]  from mul8u_compare::@7
  [202] phi()
  [203] call print_str
  to:mul8u_error::@1
mul8u_error::@1: scope:[mul8u_error]  from mul8u_error
  [204] print_uchar::b#3 = mul8u_error::a#0
  [205] call print_uchar
  to:mul8u_error::@2
mul8u_error::@2: scope:[mul8u_error]  from mul8u_error::@1
  [206] phi()
  [207] call print_str
  to:mul8u_error::@3
mul8u_error::@3: scope:[mul8u_error]  from mul8u_error::@2
  [208] print_uchar::b#4 = mul8u_error::b#0
  [209] call print_uchar
  to:mul8u_error::@4
mul8u_error::@4: scope:[mul8u_error]  from mul8u_error::@3
  [210] phi()
  [211] call print_str
  to:mul8u_error::@5
mul8u_error::@5: scope:[mul8u_error]  from mul8u_error::@4
  [212] print_uint::w#3 = mul8u_error::ms#0
  [213] call print_uint
  to:mul8u_error::@6
mul8u_error::@6: scope:[mul8u_error]  from mul8u_error::@5
  [214] phi()
  [215] call print_str
  to:mul8u_error::@7
mul8u_error::@7: scope:[mul8u_error]  from mul8u_error::@6
  [216] print_uint::w#4 = mul8u_error::mn#0
  [217] call print_uint
  to:mul8u_error::@8
mul8u_error::@8: scope:[mul8u_error]  from mul8u_error::@7
  [218] phi()
  [219] call print_str
  to:mul8u_error::@9
mul8u_error::@9: scope:[mul8u_error]  from mul8u_error::@8
  [220] print_uint::w#5 = mul8u_error::mf#0
  [221] call print_uint
  to:mul8u_error::@10
mul8u_error::@10: scope:[mul8u_error]  from mul8u_error::@9
  [222] phi()
  [223] call print_ln
  to:mul8u_error::@return
mul8u_error::@return: scope:[mul8u_error]  from mul8u_error::@10
  [224] return 
  to:@return

int muls8s(signed char a , signed char b)
muls8s: scope:[muls8s]  from mul8s_compare::@4
  [225] if(muls8s::a#0<0) goto muls8s::@5
  to:muls8s::@2
muls8s::@2: scope:[muls8s]  from muls8s
  [226] if(muls8s::a#0<=0) goto muls8s::@1
  to:muls8s::@3
muls8s::@3: scope:[muls8s]  from muls8s::@2 muls8s::@4
  [227] muls8s::m#3 = phi( muls8s::@2/0, muls8s::@4/muls8s::m#1 )
  [227] muls8s::j#2 = phi( muls8s::@2/0, muls8s::@4/muls8s::j#1 )
  [228] if(muls8s::j#2!=muls8s::a#0) goto muls8s::@4
  to:muls8s::@1
muls8s::@1: scope:[muls8s]  from muls8s::@2 muls8s::@3 muls8s::@5
  [229] muls8s::return#0 = phi( muls8s::@2/0, muls8s::@3/muls8s::m#3, muls8s::@5/muls8s::m#5 )
  to:muls8s::@return
muls8s::@return: scope:[muls8s]  from muls8s::@1
  [230] return 
  to:@return
muls8s::@4: scope:[muls8s]  from muls8s::@3
  [231] muls8s::m#1 = muls8s::m#3 + muls8s::b#0
  [232] muls8s::j#1 = ++ muls8s::j#2
  to:muls8s::@3
muls8s::@5: scope:[muls8s]  from muls8s muls8s::@6
  [233] muls8s::m#5 = phi( muls8s/0, muls8s::@6/muls8s::m#2 )
  [233] muls8s::i#2 = phi( muls8s/0, muls8s::@6/muls8s::i#1 )
  [234] if(muls8s::i#2!=muls8s::a#0) goto muls8s::@6
  to:muls8s::@1
muls8s::@6: scope:[muls8s]  from muls8s::@5
  [235] muls8s::m#2 = muls8s::m#5 - muls8s::b#0
  [236] muls8s::i#1 = -- muls8s::i#2
  to:muls8s::@5

int mulf8s(signed char a , signed char b)
mulf8s: scope:[mulf8s]  from mul8s_compare::@12
  [237] phi()
  to:mulf8s::mulf8s_prepare1
mulf8s::mulf8s_prepare1: scope:[mulf8s]  from mulf8s
  [238] mulf8u_prepare::a#1 = (char)mulf8s::a#0
  [239] call mulf8u_prepare
  to:mulf8s::@1
mulf8s::@1: scope:[mulf8s]  from mulf8s::mulf8s_prepare1
  [240] mulf8s_prepared::b#0 = mulf8s::b#0
  [241] call mulf8s_prepared
  to:mulf8s::@2
mulf8s::@2: scope:[mulf8s]  from mulf8s::@1
  [242] mulf8s::return#0 = (int)mulf8s_prepared::m#4
  to:mulf8s::@return
mulf8s::@return: scope:[mulf8s]  from mulf8s::@2
  [243] return 
  to:@return

int mul8s(signed char a , signed char b)
mul8s: scope:[mul8s]  from mul8s_compare::@13
  [244] mul8u::a#1 = (char)mul8s::a#0
  [245] mul8u::b#0 = (char)mul8s::b#0
  [246] call mul8u
  [247] mul8u::return#2 = mul8u::res#2
  to:mul8s::@5
mul8s::@5: scope:[mul8s]  from mul8s
  [248] mul8s::m#0 = mul8u::return#2
  [249] if(mul8s::a#0>=0) goto mul8s::@1
  to:mul8s::@3
mul8s::@3: scope:[mul8s]  from mul8s::@5
  [250] mul8s::$6 = byte1  mul8s::m#0
  [251] mul8s::$11 = mul8s::$6 - (char)mul8s::b#0
  [252] mul8s::m#1 = mul8s::m#0 byte1= mul8s::$11
  to:mul8s::@1
mul8s::@1: scope:[mul8s]  from mul8s::@3 mul8s::@5
  [253] mul8s::m#5 = phi( mul8s::@3/mul8s::m#1, mul8s::@5/mul8s::m#0 )
  [254] if(mul8s::b#0>=0) goto mul8s::@2
  to:mul8s::@4
mul8s::@4: scope:[mul8s]  from mul8s::@1
  [255] mul8s::$9 = byte1  mul8s::m#5
  [256] mul8s::$12 = mul8s::$9 - (char)mul8s::a#0
  [257] mul8s::m#2 = mul8s::m#5 byte1= mul8s::$12
  to:mul8s::@2
mul8s::@2: scope:[mul8s]  from mul8s::@1 mul8s::@4
  [258] mul8s::m#4 = phi( mul8s::@1/mul8s::m#5, mul8s::@4/mul8s::m#2 )
  to:mul8s::@return
mul8s::@return: scope:[mul8s]  from mul8s::@2
  [259] return 
  to:@return

void mul8s_error(signed char a , signed char b , int ms , int mn , int mf)
mul8s_error: scope:[mul8s_error]  from mul8s_compare::@10
  [260] print_char_cursor#193 = print_line_cursor#0
  [261] call print_str
  to:mul8s_error::@1
mul8s_error::@1: scope:[mul8s_error]  from mul8s_error
  [262] print_schar::b#1 = mul8s_error::a#0
  [263] call print_schar
  to:mul8s_error::@2
mul8s_error::@2: scope:[mul8s_error]  from mul8s_error::@1
  [264] phi()
  [265] call print_str
  to:mul8s_error::@3
mul8s_error::@3: scope:[mul8s_error]  from mul8s_error::@2
  [266] print_schar::b#2 = mul8s_error::b#0
  [267] call print_schar
  to:mul8s_error::@4
mul8s_error::@4: scope:[mul8s_error]  from mul8s_error::@3
  [268] phi()
  [269] call print_str
  to:mul8s_error::@5
mul8s_error::@5: scope:[mul8s_error]  from mul8s_error::@4
  [270] print_sint::w#1 = mul8s_error::ms#0
  [271] call print_sint
  to:mul8s_error::@6
mul8s_error::@6: scope:[mul8s_error]  from mul8s_error::@5
  [272] phi()
  [273] call print_str
  to:mul8s_error::@7
mul8s_error::@7: scope:[mul8s_error]  from mul8s_error::@6
  [274] print_sint::w#2 = mul8s_error::mn#0
  [275] call print_sint
  to:mul8s_error::@8
mul8s_error::@8: scope:[mul8s_error]  from mul8s_error::@7
  [276] phi()
  [277] call print_str
  to:mul8s_error::@9
mul8s_error::@9: scope:[mul8s_error]  from mul8s_error::@8
  [278] print_sint::w#3 = mul8s_error::mf#0
  [279] call print_sint
  to:mul8s_error::@10
mul8s_error::@10: scope:[mul8s_error]  from mul8s_error::@9
  [280] phi()
  [281] call print_ln
  to:mul8s_error::@return
mul8s_error::@return: scope:[mul8s_error]  from mul8s_error::@10
  [282] 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
  [283] print_char_cursor#87 = phi( print_schar::@1/print_char_cursor#1, print_schar::@3/print_char_cursor#1, print_sint::@1/print_char_cursor#1, print_sint::@3/print_char_cursor#1, print_str::@2/print_char_cursor#1, print_uchar/print_char_cursor#146, print_uchar::@1/print_char_cursor#18 )
  [283] 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 )
  [284] *print_char_cursor#87 = print_char::ch#7
  [285] print_char_cursor#18 = ++ print_char_cursor#87
  to:print_char::@return
print_char::@return: scope:[print_char]  from print_char
  [286] return 
  to:@return

void print_uchar(char b)
print_uchar: scope:[print_uchar]  from mul8u_error::@1 mul8u_error::@3 print_schar::@2 print_uint print_uint::@1
  [287] print_char_cursor#146 = phi( mul8u_error::@1/print_char_cursor#1, mul8u_error::@3/print_char_cursor#1, print_schar::@2/print_char_cursor#18, print_uint/print_char_cursor#145, print_uint::@1/print_char_cursor#18 )
  [287] print_uchar::b#5 = phi( mul8u_error::@1/print_uchar::b#3, mul8u_error::@3/print_uchar::b#4, print_schar::@2/print_uchar::b#0, print_uint/print_uchar::b#1, print_uint::@1/print_uchar::b#2 )
  [288] print_uchar::$0 = print_uchar::b#5 >> 4
  [289] print_char::ch#5 = print_hextab[print_uchar::$0]
  [290] call print_char
  to:print_uchar::@1
print_uchar::@1: scope:[print_uchar]  from print_uchar
  [291] print_uchar::$2 = print_uchar::b#5 & $f
  [292] print_char::ch#6 = print_hextab[print_uchar::$2]
  [293] call print_char
  to:print_uchar::@return
print_uchar::@return: scope:[print_uchar]  from print_uchar::@1
  [294] return 
  to:@return

void mulf8u_prepare(char a)
mulf8u_prepare: scope:[mulf8u_prepare]  from mulf8s::mulf8s_prepare1 mulf8u
  [295] mulf8u_prepare::a#2 = phi( mulf8s::mulf8s_prepare1/mulf8u_prepare::a#1, mulf8u/mulf8u_prepare::a#0 )
  [296] *mulf8u_prepare::memA = mulf8u_prepare::a#2
  asm { ldamemA stamulf8u_prepared.sm1+1 stamulf8u_prepared.sm3+1 eor#$ff stamulf8u_prepared.sm2+1 stamulf8u_prepared.sm4+1  }
  to:mulf8u_prepare::@return
mulf8u_prepare::@return: scope:[mulf8u_prepare]  from mulf8u_prepare
  [298] return 
  to:@return

unsigned int mulf8u_prepared(char b)
mulf8u_prepared: scope:[mulf8u_prepared]  from mulf8s_prepared mulf8u::@1
  [299] mulf8u_prepared::b#2 = phi( mulf8s_prepared/mulf8u_prepared::b#1, mulf8u::@1/mulf8u_prepared::b#0 )
  [300] *mulf8u_prepared::memB = mulf8u_prepared::b#2
  asm { ldxmemB sec sm1: ldamulf_sqr1_lo,x sm2: sbcmulf_sqr2_lo,x staresL sm3: ldamulf_sqr1_hi,x sm4: sbcmulf_sqr2_hi,x stamemB  }
  [302] mulf8u_prepared::return#0 = *mulf8u_prepared::memB w= *mulf8u_prepared::resL
  to:mulf8u_prepared::@return
mulf8u_prepared::@return: scope:[mulf8u_prepared]  from mulf8u_prepared
  [303] return 
  to:@return

int mulf8s_prepared(signed char b)
mulf8s_prepared: scope:[mulf8s_prepared]  from mulf8s::@1
  [304] mulf8u_prepared::b#1 = (char)mulf8s_prepared::b#0
  [305] call mulf8u_prepared
  [306] mulf8u_prepared::return#3 = mulf8u_prepared::return#0
  to:mulf8s_prepared::@5
mulf8s_prepared::@5: scope:[mulf8s_prepared]  from mulf8s_prepared
  [307] mulf8s_prepared::m#0 = mulf8u_prepared::return#3
  [308] if(*mulf8s_prepared::memA>=0) goto mulf8s_prepared::@1
  to:mulf8s_prepared::@3
mulf8s_prepared::@3: scope:[mulf8s_prepared]  from mulf8s_prepared::@5
  [309] mulf8s_prepared::$6 = byte1  mulf8s_prepared::m#0
  [310] mulf8s_prepared::$11 = mulf8s_prepared::$6 - (char)mulf8s_prepared::b#0
  [311] mulf8s_prepared::m#1 = mulf8s_prepared::m#0 byte1= mulf8s_prepared::$11
  to:mulf8s_prepared::@1
mulf8s_prepared::@1: scope:[mulf8s_prepared]  from mulf8s_prepared::@3 mulf8s_prepared::@5
  [312] mulf8s_prepared::m#5 = phi( mulf8s_prepared::@3/mulf8s_prepared::m#1, mulf8s_prepared::@5/mulf8s_prepared::m#0 )
  [313] if(mulf8s_prepared::b#0>=0) goto mulf8s_prepared::@2
  to:mulf8s_prepared::@4
mulf8s_prepared::@4: scope:[mulf8s_prepared]  from mulf8s_prepared::@1
  [314] mulf8s_prepared::$9 = byte1  mulf8s_prepared::m#5
  [315] mulf8s_prepared::$12 = mulf8s_prepared::$9 - (char)*mulf8s_prepared::memA
  [316] mulf8s_prepared::m#2 = mulf8s_prepared::m#5 byte1= mulf8s_prepared::$12
  to:mulf8s_prepared::@2
mulf8s_prepared::@2: scope:[mulf8s_prepared]  from mulf8s_prepared::@1 mulf8s_prepared::@4
  [317] mulf8s_prepared::m#4 = phi( mulf8s_prepared::@1/mulf8s_prepared::m#5, mulf8s_prepared::@4/mulf8s_prepared::m#2 )
  to:mulf8s_prepared::@return
mulf8s_prepared::@return: scope:[mulf8s_prepared]  from mulf8s_prepared::@2
  [318] return 
  to:@return

void print_schar(signed char b)
print_schar: scope:[print_schar]  from mul8s_error::@1 mul8s_error::@3
  [319] print_schar::b#3 = phi( mul8s_error::@1/print_schar::b#1, mul8s_error::@3/print_schar::b#2 )
  [320] if(print_schar::b#3<0) goto print_schar::@1
  to:print_schar::@3
print_schar::@3: scope:[print_schar]  from print_schar
  [321] phi()
  [322] call print_char
  to:print_schar::@2
print_schar::@2: scope:[print_schar]  from print_schar::@3 print_schar::@4
  [323] print_schar::b#5 = phi( print_schar::@4/print_schar::b#0, print_schar::@3/print_schar::b#3 )
  [324] print_uchar::b#0 = (char)print_schar::b#5
  [325] call print_uchar
  to:print_schar::@return
print_schar::@return: scope:[print_schar]  from print_schar::@2
  [326] return 
  to:@return
print_schar::@1: scope:[print_schar]  from print_schar
  [327] phi()
  [328] call print_char
  to:print_schar::@4
print_schar::@4: scope:[print_schar]  from print_schar::@1
  [329] print_schar::b#0 = - print_schar::b#3
  to:print_schar::@2

void print_sint(int w)
print_sint: scope:[print_sint]  from mul8s_error::@5 mul8s_error::@7 mul8s_error::@9
  [330] print_sint::w#4 = phi( mul8s_error::@5/print_sint::w#1, mul8s_error::@7/print_sint::w#2, mul8s_error::@9/print_sint::w#3 )
  [331] if(print_sint::w#4<0) goto print_sint::@1
  to:print_sint::@3
print_sint::@3: scope:[print_sint]  from print_sint
  [332] phi()
  [333] call print_char
  to:print_sint::@2
print_sint::@2: scope:[print_sint]  from print_sint::@3 print_sint::@4
  [334] print_sint::w#6 = phi( print_sint::@4/print_sint::w#0, print_sint::@3/print_sint::w#4 )
  [335] print_uint::w#0 = (unsigned int)print_sint::w#6
  [336] call print_uint
  to:print_sint::@return
print_sint::@return: scope:[print_sint]  from print_sint::@2
  [337] return 
  to:@return
print_sint::@1: scope:[print_sint]  from print_sint
  [338] phi()
  [339] call print_char
  to:print_sint::@4
print_sint::@4: scope:[print_sint]  from print_sint::@1
  [340] print_sint::w#0 = - print_sint::w#4
  to:print_sint::@2
