@begin: scope:[]  from
  [0] phi()
  to:@1
@1: scope:[]  from @begin
  [1] phi()
  [2] call main 
  to:@end
@end: scope:[]  from @1
  [3] phi()
main: scope:[main]  from @1
  [4] *((const byte*) BGCOL#0) ← (byte) 5
  [5] call print_cls 
  to:main::@1
main::@1: scope:[main]  from main
  [6] phi()
  [7] call mulf_init 
  to:main::@2
main::@2: scope:[main]  from main::@1
  [8] phi()
  [9] call mulf_init_asm 
  to:main::@3
main::@3: scope:[main]  from main::@2
  [10] phi()
  [11] call mulf_tables_cmp 
  to:main::@4
main::@4: scope:[main]  from main::@3
  [12] phi()
  [13] call mul8u_compare 
  to:main::@5
main::@5: scope:[main]  from main::@4
  [14] phi()
  [15] call mul8s_compare 
  to:main::@return
main::@return: scope:[main]  from main::@5
  [16] return 
  to:@return
mul8s_compare: scope:[mul8s_compare]  from main::@5
  [17] phi()
  to:mul8s_compare::@1
mul8s_compare::@1: scope:[mul8s_compare]  from mul8s_compare
  [18] (byte*~) print_char_cursor#193 ← (byte*) print_line_cursor#1
  [19] call print_str 
  to:mul8s_compare::@2
mul8s_compare::@2: scope:[mul8s_compare]  from mul8s_compare::@1
  [20] phi()
  [21] call print_ln 
  to:mul8s_compare::@return
mul8s_compare::@return: scope:[mul8s_compare]  from mul8s_compare::@2
  [22] return 
  to:@return
print_ln: scope:[print_ln]  from mul8s_compare::@2 mul8u_compare::@13 mul8u_error::@10 mulf_tables_cmp::@6
  [23] (byte*) print_char_cursor#135 ← phi( mul8s_compare::@2/(byte*) print_char_cursor#134 mul8u_compare::@13/(byte*) print_char_cursor#134 mul8u_error::@10/(byte*) print_char_cursor#19 mulf_tables_cmp::@6/(byte*) print_char_cursor#134 )
  [23] (byte*) print_line_cursor#45 ← phi( mul8s_compare::@2/(byte*) print_line_cursor#1 mul8u_compare::@13/(byte*) print_line_cursor#11 mul8u_error::@10/(byte*) print_line_cursor#11 mulf_tables_cmp::@6/(byte*) 1024 )
  to:print_ln::@1
print_ln::@1: scope:[print_ln]  from print_ln print_ln::@1
  [24] (byte*) print_line_cursor#23 ← phi( print_ln/(byte*) print_line_cursor#45 print_ln::@1/(byte*) print_line_cursor#1 )
  [25] (byte*) print_line_cursor#1 ← (byte*) print_line_cursor#23 + (byte) $28
  [26] if((byte*) print_line_cursor#1<(byte*) print_char_cursor#135) goto print_ln::@1
  to:print_ln::@return
print_ln::@return: scope:[print_ln]  from print_ln::@1
  [27] return 
  to:@return
print_str: scope:[print_str]  from mul8s_compare::@1 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
  [28] (byte*) print_char_cursor#155 ← phi( mul8s_compare::@1/(byte*~) print_char_cursor#193 mul8u_compare::@9/(byte*) print_char_cursor#100 mul8u_error/(byte*) print_char_cursor#100 mul8u_error::@2/(byte*) print_char_cursor#19 mul8u_error::@4/(byte*) print_char_cursor#19 mul8u_error::@6/(byte*) print_char_cursor#19 mul8u_error::@8/(byte*) print_char_cursor#19 mulf_tables_cmp::@9/(byte*) print_char_cursor#19 mulf_tables_cmp::@3/(byte*) 1024 mulf_tables_cmp::@5/(byte*) 1024 )
  [28] (byte*) print_str::str#18 ← phi( mul8s_compare::@1/(const string) mul8s_compare::str mul8u_compare::@9/(const string) mul8u_compare::str mul8u_error/(const string) mul8u_error::str mul8u_error::@2/(const string) str1 mul8u_error::@4/(const string) str2 mul8u_error::@6/(const string) str3 mul8u_error::@8/(const string) str4 mulf_tables_cmp::@9/(const string) mulf_tables_cmp::str2 mulf_tables_cmp::@3/(const string) mulf_tables_cmp::str mulf_tables_cmp::@5/(const string) mulf_tables_cmp::str1 )
  to:print_str::@1
print_str::@1: scope:[print_str]  from print_str print_str::@2
  [29] (byte*) print_char_cursor#134 ← phi( print_str/(byte*) print_char_cursor#155 print_str::@2/(byte*) print_char_cursor#1 )
  [29] (byte*) print_str::str#16 ← phi( print_str/(byte*) print_str::str#18 print_str::@2/(byte*) print_str::str#0 )
  [30] if((byte) 0!=*((byte*) print_str::str#16)) goto print_str::@2
  to:print_str::@return
print_str::@return: scope:[print_str]  from print_str::@1
  [31] return 
  to:@return
print_str::@2: scope:[print_str]  from print_str::@1
  [32] *((byte*) print_char_cursor#134) ← *((byte*) print_str::str#16)
  [33] (byte*) print_char_cursor#1 ← ++ (byte*) print_char_cursor#134
  [34] (byte*) print_str::str#0 ← ++ (byte*) print_str::str#16
  to:print_str::@1
mul8u_compare: scope:[mul8u_compare]  from main::@4
  [35] phi()
  to:mul8u_compare::@1
mul8u_compare::@1: scope:[mul8u_compare]  from mul8u_compare mul8u_compare::@8
  [36] (byte) mul8u_compare::a#7 ← phi( mul8u_compare/(byte) 0 mul8u_compare::@8/(byte) mul8u_compare::a#1 )
  to:mul8u_compare::@2
mul8u_compare::@2: scope:[mul8u_compare]  from mul8u_compare::@1 mul8u_compare::@5
  [37] (byte) mul8u_compare::b#10 ← phi( mul8u_compare::@1/(byte) 0 mul8u_compare::@5/(byte) mul8u_compare::b#1 )
  [38] (byte) muls8u::a#0 ← (byte) mul8u_compare::a#7
  [39] (byte) muls8u::b#0 ← (byte) mul8u_compare::b#10
  [40] call muls8u 
  [41] (word) muls8u::return#2 ← (word) muls8u::return#0
  to:mul8u_compare::@10
mul8u_compare::@10: scope:[mul8u_compare]  from mul8u_compare::@2
  [42] (word) mul8u_compare::ms#0 ← (word) muls8u::return#2
  [43] (byte) mulf8u::a#0 ← (byte) mul8u_compare::a#7
  [44] (byte) mulf8u::b#0 ← (byte) mul8u_compare::b#10
  [45] call mulf8u 
  [46] (word) mulf8u::return#2 ← (word) mulf8u::return#0
  to:mul8u_compare::@11
mul8u_compare::@11: scope:[mul8u_compare]  from mul8u_compare::@10
  [47] (word) mul8u_compare::mf#0 ← (word) mulf8u::return#2
  [48] (byte) mul8u::a#2 ← (byte) mul8u_compare::a#7
  [49] (byte) mul8u::b#1 ← (byte) mul8u_compare::b#10
  [50] call mul8u 
  [51] (word) mul8u::return#3 ← (word) mul8u::res#2
  to:mul8u_compare::@12
mul8u_compare::@12: scope:[mul8u_compare]  from mul8u_compare::@11
  [52] (word) mul8u_compare::mn#0 ← (word) mul8u::return#3
  [53] if((word) mul8u_compare::ms#0==(word) mul8u_compare::mf#0) goto mul8u_compare::@3
  to:mul8u_compare::@6
mul8u_compare::@6: scope:[mul8u_compare]  from mul8u_compare::@12
  [54] phi()
  to:mul8u_compare::@3
mul8u_compare::@3: scope:[mul8u_compare]  from mul8u_compare::@12 mul8u_compare::@6
  [55] (byte) mul8u_compare::ok#4 ← phi( mul8u_compare::@12/(byte) 1 mul8u_compare::@6/(byte) 0 )
  [56] if((word) mul8u_compare::ms#0==(word) mul8u_compare::mn#0) goto mul8u_compare::@14
  to:mul8u_compare::@4
mul8u_compare::@14: scope:[mul8u_compare]  from mul8u_compare::@3
  [57] phi()
  to:mul8u_compare::@4
mul8u_compare::@4: scope:[mul8u_compare]  from mul8u_compare::@14 mul8u_compare::@3
  [58] (byte) mul8u_compare::ok#3 ← phi( mul8u_compare::@14/(byte) mul8u_compare::ok#4 mul8u_compare::@3/(byte) 0 )
  [59] if((byte) mul8u_compare::ok#3!=(byte) 0) goto mul8u_compare::@5
  to:mul8u_compare::@7
mul8u_compare::@7: scope:[mul8u_compare]  from mul8u_compare::@4
  [60] *((const byte*) BGCOL#0) ← (byte) 2
  [61] (byte) mul8u_error::a#0 ← (byte) mul8u_compare::a#7
  [62] (byte) mul8u_error::b#0 ← (byte) mul8u_compare::b#10
  [63] (word) mul8u_error::ms#0 ← (word) mul8u_compare::ms#0
  [64] (word) mul8u_error::mn#0 ← (word) mul8u_compare::mn#0
  [65] (word) mul8u_error::mf#0 ← (word) mul8u_compare::mf#0
  [66] call mul8u_error 
  to:mul8u_compare::@return
mul8u_compare::@return: scope:[mul8u_compare]  from mul8u_compare::@13 mul8u_compare::@7
  [67] return 
  to:@return
mul8u_compare::@5: scope:[mul8u_compare]  from mul8u_compare::@4
  [68] (byte) mul8u_compare::b#1 ← ++ (byte) mul8u_compare::b#10
  [69] if((byte) mul8u_compare::b#1!=(byte) 0) goto mul8u_compare::@2
  to:mul8u_compare::@8
mul8u_compare::@8: scope:[mul8u_compare]  from mul8u_compare::@5
  [70] (byte) mul8u_compare::a#1 ← ++ (byte) mul8u_compare::a#7
  [71] if((byte) mul8u_compare::a#1!=(byte) 0) goto mul8u_compare::@1
  to:mul8u_compare::@9
mul8u_compare::@9: scope:[mul8u_compare]  from mul8u_compare::@8
  [72] phi()
  [73] call print_str 
  to:mul8u_compare::@13
mul8u_compare::@13: scope:[mul8u_compare]  from mul8u_compare::@9
  [74] phi()
  [75] call print_ln 
  to:mul8u_compare::@return
mul8u_error: scope:[mul8u_error]  from mul8u_compare::@7
  [76] phi()
  [77] call print_str 
  to:mul8u_error::@1
mul8u_error::@1: scope:[mul8u_error]  from mul8u_error
  [78] (byte) print_byte::b#3 ← (byte) mul8u_error::a#0
  [79] call print_byte 
  to:mul8u_error::@2
mul8u_error::@2: scope:[mul8u_error]  from mul8u_error::@1
  [80] phi()
  [81] call print_str 
  to:mul8u_error::@3
mul8u_error::@3: scope:[mul8u_error]  from mul8u_error::@2
  [82] (byte) print_byte::b#4 ← (byte) mul8u_error::b#0
  [83] call print_byte 
  to:mul8u_error::@4
mul8u_error::@4: scope:[mul8u_error]  from mul8u_error::@3
  [84] phi()
  [85] call print_str 
  to:mul8u_error::@5
mul8u_error::@5: scope:[mul8u_error]  from mul8u_error::@4
  [86] (word) print_word::w#3 ← (word) mul8u_error::ms#0
  [87] call print_word 
  to:mul8u_error::@6
mul8u_error::@6: scope:[mul8u_error]  from mul8u_error::@5
  [88] phi()
  [89] call print_str 
  to:mul8u_error::@7
mul8u_error::@7: scope:[mul8u_error]  from mul8u_error::@6
  [90] (word) print_word::w#4 ← (word) mul8u_error::mn#0
  [91] call print_word 
  to:mul8u_error::@8
mul8u_error::@8: scope:[mul8u_error]  from mul8u_error::@7
  [92] phi()
  [93] call print_str 
  to:mul8u_error::@9
mul8u_error::@9: scope:[mul8u_error]  from mul8u_error::@8
  [94] (word) print_word::w#5 ← (word) mul8u_error::mf#0
  [95] call print_word 
  to:mul8u_error::@10
mul8u_error::@10: scope:[mul8u_error]  from mul8u_error::@9
  [96] phi()
  [97] call print_ln 
  to:mul8u_error::@return
mul8u_error::@return: scope:[mul8u_error]  from mul8u_error::@10
  [98] return 
  to:@return
print_word: scope:[print_word]  from mul8u_error::@5 mul8u_error::@7 mul8u_error::@9 mulf_tables_cmp::@10 mulf_tables_cmp::@8
  [99] (word) print_word::w#6 ← phi( mul8u_error::@5/(word) print_word::w#3 mul8u_error::@7/(word) print_word::w#4 mul8u_error::@9/(word) print_word::w#5 mulf_tables_cmp::@8/(word) print_word::w#1 mulf_tables_cmp::@10/(word) print_word::w#2 )
  [100] (byte) print_byte::b#1 ← > (word) print_word::w#6
  [101] call print_byte 
  to:print_word::@1
print_word::@1: scope:[print_word]  from print_word
  [102] (byte) print_byte::b#2 ← < (word) print_word::w#6
  [103] call print_byte 
  to:print_word::@return
print_word::@return: scope:[print_word]  from print_word::@1
  [104] return 
  to:@return
print_byte: scope:[print_byte]  from mul8u_error::@1 mul8u_error::@3 print_word print_word::@1
  [105] (byte*) print_char_cursor#143 ← phi( mul8u_error::@1/(byte*) print_char_cursor#134 mul8u_error::@3/(byte*) print_char_cursor#134 print_word/(byte*) print_char_cursor#134 print_word::@1/(byte*) print_char_cursor#19 )
  [105] (byte) print_byte::b#5 ← phi( mul8u_error::@1/(byte) print_byte::b#3 mul8u_error::@3/(byte) print_byte::b#4 print_word/(byte) print_byte::b#1 print_word::@1/(byte) print_byte::b#2 )
  [106] (byte~) print_byte::$0 ← (byte) print_byte::b#5 >> (byte) 4
  [107] (byte) print_char::ch#4 ← *((const byte[]) print_hextab#0 + (byte~) print_byte::$0)
  [108] call print_char 
  to:print_byte::@1
print_byte::@1: scope:[print_byte]  from print_byte
  [109] (byte~) print_byte::$2 ← (byte) print_byte::b#5 & (byte) $f
  [110] (byte) print_char::ch#5 ← *((const byte[]) print_hextab#0 + (byte~) print_byte::$2)
  [111] call print_char 
  to:print_byte::@return
print_byte::@return: scope:[print_byte]  from print_byte::@1
  [112] return 
  to:@return
print_char: scope:[print_char]  from print_byte print_byte::@1
  [113] (byte*) print_char_cursor#86 ← phi( print_byte/(byte*) print_char_cursor#143 print_byte::@1/(byte*) print_char_cursor#19 )
  [113] (byte) print_char::ch#6 ← phi( print_byte/(byte) print_char::ch#4 print_byte::@1/(byte) print_char::ch#5 )
  [114] *((byte*) print_char_cursor#86) ← (byte) print_char::ch#6
  [115] (byte*) print_char_cursor#19 ← ++ (byte*) print_char_cursor#86
  to:print_char::@return
print_char::@return: scope:[print_char]  from print_char
  [116] return 
  to:@return
mul8u: scope:[mul8u]  from mul8u_compare::@11
  [117] phi()
  to:mul8u::@1
mul8u::@1: scope:[mul8u]  from mul8u mul8u::@3
  [118] (word) mul8u::mb#2 ← phi( mul8u/(byte) mul8u::b#1 mul8u::@3/(word) mul8u::mb#1 )
  [118] (word) mul8u::res#2 ← phi( mul8u/(byte) 0 mul8u::@3/(word) mul8u::res#6 )
  [118] (byte) mul8u::a#3 ← phi( mul8u/(byte) mul8u::a#2 mul8u::@3/(byte) mul8u::a#0 )
  [119] if((byte) mul8u::a#3!=(byte) 0) goto mul8u::@2
  to:mul8u::@return
mul8u::@return: scope:[mul8u]  from mul8u::@1
  [120] return 
  to:@return
mul8u::@2: scope:[mul8u]  from mul8u::@1
  [121] (byte~) mul8u::$1 ← (byte) mul8u::a#3 & (byte) 1
  [122] if((byte~) mul8u::$1==(byte) 0) goto mul8u::@3
  to:mul8u::@4
mul8u::@4: scope:[mul8u]  from mul8u::@2
  [123] (word) mul8u::res#1 ← (word) mul8u::res#2 + (word) mul8u::mb#2
  to:mul8u::@3
mul8u::@3: scope:[mul8u]  from mul8u::@2 mul8u::@4
  [124] (word) mul8u::res#6 ← phi( mul8u::@2/(word) mul8u::res#2 mul8u::@4/(word) mul8u::res#1 )
  [125] (byte) mul8u::a#0 ← (byte) mul8u::a#3 >> (byte) 1
  [126] (word) mul8u::mb#1 ← (word) mul8u::mb#2 << (byte) 1
  to:mul8u::@1
mulf8u: scope:[mulf8u]  from mul8u_compare::@10
  [127] (byte) mulf8u_prepare::a#0 ← (byte) mulf8u::a#0
  [128] call mulf8u_prepare 
  to:mulf8u::@1
mulf8u::@1: scope:[mulf8u]  from mulf8u
  [129] (byte) mulf8u_prepared::b#0 ← (byte) mulf8u::b#0
  [130] call mulf8u_prepared 
  [131] (word) mulf8u_prepared::return#2 ← (word) mulf8u_prepared::return#0
  to:mulf8u::@2
mulf8u::@2: scope:[mulf8u]  from mulf8u::@1
  [132] (word) mulf8u::return#0 ← (word) mulf8u_prepared::return#2
  to:mulf8u::@return
mulf8u::@return: scope:[mulf8u]  from mulf8u::@2
  [133] return 
  to:@return
mulf8u_prepared: scope:[mulf8u_prepared]  from mulf8u::@1
  [134] *((const byte*) mulf8u_prepared::memB#0) ← (byte) mulf8u_prepared::b#0
  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  }
  [136] (word) mulf8u_prepared::return#0 ← *((const byte*) mulf8u_prepared::memB#0) w= *((const byte*) mulf8u_prepared::resL#0)
  to:mulf8u_prepared::@return
mulf8u_prepared::@return: scope:[mulf8u_prepared]  from mulf8u_prepared
  [137] return 
  to:@return
mulf8u_prepare: scope:[mulf8u_prepare]  from mulf8u
  [138] *((const byte*) mulf8u_prepare::memA#0) ← (byte) mulf8u_prepare::a#0
  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
  [140] return 
  to:@return
muls8u: scope:[muls8u]  from mul8u_compare::@2
  [141] if((byte) muls8u::a#0==(byte) 0) goto muls8u::@1
  to:muls8u::@2
muls8u::@2: scope:[muls8u]  from muls8u muls8u::@3
  [142] (word) muls8u::m#3 ← phi( muls8u/(byte) 0 muls8u::@3/(word) muls8u::m#1 )
  [142] (byte) muls8u::i#2 ← phi( muls8u/(byte) 0 muls8u::@3/(byte) muls8u::i#1 )
  [143] if((byte) muls8u::i#2!=(byte) muls8u::a#0) goto muls8u::@3
  to:muls8u::@1
muls8u::@1: scope:[muls8u]  from muls8u muls8u::@2
  [144] (word) muls8u::return#0 ← phi( muls8u/(byte) 0 muls8u::@2/(word) muls8u::m#3 )
  to:muls8u::@return
muls8u::@return: scope:[muls8u]  from muls8u::@1
  [145] return 
  to:@return
muls8u::@3: scope:[muls8u]  from muls8u::@2
  [146] (word) muls8u::m#1 ← (word) muls8u::m#3 + (byte) muls8u::b#0
  [147] (byte) muls8u::i#1 ← ++ (byte) muls8u::i#2
  to:muls8u::@2
mulf_tables_cmp: scope:[mulf_tables_cmp]  from main::@3
  [148] phi()
  to:mulf_tables_cmp::@1
mulf_tables_cmp::@1: scope:[mulf_tables_cmp]  from mulf_tables_cmp mulf_tables_cmp::@4
  [149] (byte*) mulf_tables_cmp::asm_sqr#2 ← phi( mulf_tables_cmp/(const byte[$200]) mula_sqr1_lo#0 mulf_tables_cmp::@4/(byte*) mulf_tables_cmp::asm_sqr#1 )
  [149] (byte*) mulf_tables_cmp::kc_sqr#2 ← phi( mulf_tables_cmp/(const byte[$200]) mulf_sqr1_lo#0 mulf_tables_cmp::@4/(byte*) mulf_tables_cmp::kc_sqr#1 )
  [150] if((byte*) mulf_tables_cmp::kc_sqr#2<(const byte[$200]) mulf_sqr1_lo#0+(word)(number) $200*(number) 4) goto mulf_tables_cmp::@2
  to:mulf_tables_cmp::@3
mulf_tables_cmp::@3: scope:[mulf_tables_cmp]  from mulf_tables_cmp::@1
  [151] phi()
  [152] call print_str 
  to:mulf_tables_cmp::@6
mulf_tables_cmp::@6: scope:[mulf_tables_cmp]  from mulf_tables_cmp::@3
  [153] phi()
  [154] call print_ln 
  to:mulf_tables_cmp::@7
mulf_tables_cmp::@7: scope:[mulf_tables_cmp]  from mulf_tables_cmp::@6
  [155] (byte*~) print_char_cursor#213 ← (byte*) print_line_cursor#1
  to:mulf_tables_cmp::@return
mulf_tables_cmp::@return: scope:[mulf_tables_cmp]  from mulf_tables_cmp::@10 mulf_tables_cmp::@7
  [156] (byte*) print_line_cursor#11 ← phi( mulf_tables_cmp::@7/(byte*) print_line_cursor#1 mulf_tables_cmp::@10/(byte*) 1024 )
  [156] (byte*) print_char_cursor#100 ← phi( mulf_tables_cmp::@7/(byte*~) print_char_cursor#213 mulf_tables_cmp::@10/(byte*) print_char_cursor#19 )
  [157] return 
  to:@return
mulf_tables_cmp::@2: scope:[mulf_tables_cmp]  from mulf_tables_cmp::@1
  [158] if(*((byte*) mulf_tables_cmp::kc_sqr#2)==*((byte*) 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
  [159] *((const byte*) BGCOL#0) ← (byte) 2
  [160] call print_str 
  to:mulf_tables_cmp::@8
mulf_tables_cmp::@8: scope:[mulf_tables_cmp]  from mulf_tables_cmp::@5
  [161] (word) print_word::w#1 ← (word)(byte*) mulf_tables_cmp::asm_sqr#2
  [162] call print_word 
  to:mulf_tables_cmp::@9
mulf_tables_cmp::@9: scope:[mulf_tables_cmp]  from mulf_tables_cmp::@8
  [163] phi()
  [164] call print_str 
  to:mulf_tables_cmp::@10
mulf_tables_cmp::@10: scope:[mulf_tables_cmp]  from mulf_tables_cmp::@9
  [165] (word) print_word::w#2 ← (word)(byte*) mulf_tables_cmp::kc_sqr#2
  [166] call print_word 
  to:mulf_tables_cmp::@return
mulf_tables_cmp::@4: scope:[mulf_tables_cmp]  from mulf_tables_cmp::@2
  [167] (byte*) mulf_tables_cmp::asm_sqr#1 ← ++ (byte*) mulf_tables_cmp::asm_sqr#2
  [168] (byte*) mulf_tables_cmp::kc_sqr#1 ← ++ (byte*) mulf_tables_cmp::kc_sqr#2
  to:mulf_tables_cmp::@1
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!-  }
  [170] *((const byte*) mulf_init_asm::mem#0) ← *((const byte[$200]) mula_sqr1_lo#0)
  [171] *((const byte*) mulf_init_asm::mem#0) ← *((const byte[$200]) mula_sqr1_hi#0)
  [172] *((const byte*) mulf_init_asm::mem#0) ← *((const byte[$200]) mula_sqr2_lo#0)
  [173] *((const byte*) mulf_init_asm::mem#0) ← *((const byte[$200]) mula_sqr2_hi#0)
  to:mulf_init_asm::@return
mulf_init_asm::@return: scope:[mulf_init_asm]  from mulf_init_asm
  [174] return 
  to:@return
mulf_init: scope:[mulf_init]  from main::@1
  [175] phi()
  to:mulf_init::@1
mulf_init::@1: scope:[mulf_init]  from mulf_init mulf_init::@3
  [176] (byte) mulf_init::x_2#3 ← phi( mulf_init/(byte) 0 mulf_init::@3/(byte) mulf_init::x_2#2 )
  [176] (byte*) mulf_init::sqr1_hi#2 ← phi( mulf_init/(const byte[$200]) mulf_sqr1_hi#0+(byte) 1 mulf_init::@3/(byte*) mulf_init::sqr1_hi#1 )
  [176] (word) mulf_init::sqr#4 ← phi( mulf_init/(byte) 0 mulf_init::@3/(word) mulf_init::sqr#1 )
  [176] (byte) mulf_init::c#2 ← phi( mulf_init/(byte) 0 mulf_init::@3/(byte) mulf_init::c#1 )
  [176] (byte*) mulf_init::sqr1_lo#2 ← phi( mulf_init/(const byte[$200]) mulf_sqr1_lo#0+(byte) 1 mulf_init::@3/(byte*) mulf_init::sqr1_lo#1 )
  [177] if((byte*) mulf_init::sqr1_lo#2!=(const byte[$200]) mulf_sqr1_lo#0+(word) $200) goto mulf_init::@2
  to:mulf_init::@5
mulf_init::@5: scope:[mulf_init]  from mulf_init::@1 mulf_init::@8
  [178] (byte) mulf_init::dir#2 ← phi( mulf_init::@8/(byte) mulf_init::dir#4 mulf_init::@1/(byte) $ff )
  [178] (byte*) mulf_init::sqr2_hi#2 ← phi( mulf_init::@8/(byte*) mulf_init::sqr2_hi#1 mulf_init::@1/(const byte[$200]) mulf_sqr2_hi#0 )
  [178] (byte) mulf_init::x_255#2 ← phi( mulf_init::@8/(byte) mulf_init::x_255#1 mulf_init::@1/(byte) -1 )
  [178] (byte*) mulf_init::sqr2_lo#2 ← phi( mulf_init::@8/(byte*) mulf_init::sqr2_lo#1 mulf_init::@1/(const byte[$200]) mulf_sqr2_lo#0 )
  [179] if((byte*) mulf_init::sqr2_lo#2!=(const byte[$200]) mulf_sqr2_lo#0+(word) $1ff) goto mulf_init::@6
  to:mulf_init::@7
mulf_init::@7: scope:[mulf_init]  from mulf_init::@5
  [180] *((const byte[$200]) mulf_sqr2_lo#0+(word) $1ff) ← *((const byte[$200]) mulf_sqr1_lo#0+(word) $100)
  [181] *((const byte[$200]) mulf_sqr2_hi#0+(word) $1ff) ← *((const byte[$200]) mulf_sqr1_hi#0+(word) $100)
  to:mulf_init::@return
mulf_init::@return: scope:[mulf_init]  from mulf_init::@7
  [182] return 
  to:@return
mulf_init::@6: scope:[mulf_init]  from mulf_init::@5
  [183] *((byte*) mulf_init::sqr2_lo#2) ← *((const byte[$200]) mulf_sqr1_lo#0 + (byte) mulf_init::x_255#2)
  [184] *((byte*) mulf_init::sqr2_hi#2) ← *((const byte[$200]) mulf_sqr1_hi#0 + (byte) mulf_init::x_255#2)
  [185] (byte*) mulf_init::sqr2_hi#1 ← ++ (byte*) mulf_init::sqr2_hi#2
  [186] (byte) mulf_init::x_255#1 ← (byte) mulf_init::x_255#2 + (byte) mulf_init::dir#2
  [187] if((byte) mulf_init::x_255#1!=(byte) 0) goto mulf_init::@9
  to:mulf_init::@8
mulf_init::@9: scope:[mulf_init]  from mulf_init::@6
  [188] phi()
  to:mulf_init::@8
mulf_init::@8: scope:[mulf_init]  from mulf_init::@6 mulf_init::@9
  [189] (byte) mulf_init::dir#4 ← phi( mulf_init::@9/(byte) mulf_init::dir#2 mulf_init::@6/(byte) 1 )
  [190] (byte*) mulf_init::sqr2_lo#1 ← ++ (byte*) mulf_init::sqr2_lo#2
  to:mulf_init::@5
mulf_init::@2: scope:[mulf_init]  from mulf_init::@1
  [191] (byte) mulf_init::c#1 ← ++ (byte) mulf_init::c#2
  [192] (byte~) mulf_init::$9 ← (byte) mulf_init::c#1 & (byte) 1
  [193] if((byte~) mulf_init::$9!=(byte) 0) goto mulf_init::@3
  to:mulf_init::@4
mulf_init::@4: scope:[mulf_init]  from mulf_init::@2
  [194] (byte) mulf_init::x_2#1 ← ++ (byte) mulf_init::x_2#3
  [195] (word) mulf_init::sqr#2 ← ++ (word) mulf_init::sqr#4
  to:mulf_init::@3
mulf_init::@3: scope:[mulf_init]  from mulf_init::@2 mulf_init::@4
  [196] (byte) mulf_init::x_2#2 ← phi( mulf_init::@2/(byte) mulf_init::x_2#3 mulf_init::@4/(byte) mulf_init::x_2#1 )
  [196] (word) mulf_init::sqr#3 ← phi( mulf_init::@2/(word) mulf_init::sqr#4 mulf_init::@4/(word) mulf_init::sqr#2 )
  [197] (byte~) mulf_init::$12 ← < (word) mulf_init::sqr#3
  [198] *((byte*) mulf_init::sqr1_lo#2) ← (byte~) mulf_init::$12
  [199] (byte~) mulf_init::$13 ← > (word) mulf_init::sqr#3
  [200] *((byte*) mulf_init::sqr1_hi#2) ← (byte~) mulf_init::$13
  [201] (byte*) mulf_init::sqr1_hi#1 ← ++ (byte*) mulf_init::sqr1_hi#2
  [202] (word) mulf_init::sqr#1 ← (word) mulf_init::sqr#3 + (byte) mulf_init::x_2#2
  [203] (byte*) mulf_init::sqr1_lo#1 ← ++ (byte*) mulf_init::sqr1_lo#2
  to:mulf_init::@1
print_cls: scope:[print_cls]  from main
  [204] phi()
  [205] call memset 
  to:print_cls::@return
print_cls::@return: scope:[print_cls]  from print_cls
  [206] return 
  to:@return
memset: scope:[memset]  from print_cls
  [207] phi()
  to:memset::@2
memset::@2: scope:[memset]  from memset memset::@1
  [208] (byte*) memset::dst#4 ← phi( memset::@1/(byte*) memset::dst#1 memset/(byte*)(const void*) memset::str#0 )
  [209] *((byte*) memset::dst#4) ← (const byte) memset::c#0
  [210] (byte*) memset::dst#1 ← ++ (byte*) memset::dst#4
  to:memset::@1
memset::@1: scope:[memset]  from memset::@2
  [211] if((byte*) memset::dst#1!=(const byte*) memset::end#0) goto memset::@2
  to:memset::@return
memset::@return: scope:[memset]  from memset::@1
  [212] return 
  to:@return
