@begin: scope:[]  from
  [0] phi()
  to:@42
@42: scope:[]  from @begin
  [1] phi()
  [2] call main 
  to:@end
@end: scope:[]  from @42
  [3] phi()
main: scope:[main]  from @42
  [4] *((const byte*) BGCOL#0) ← (byte/signed byte/word/signed word/dword/signed dword) 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 mul8s_compare::@10
  [18] (signed byte) mul8s_compare::a#7 ← phi( mul8s_compare/-(byte/word/signed word/dword/signed dword) 128 mul8s_compare::@10/(signed byte) mul8s_compare::a#1 )
  to:mul8s_compare::@2
mul8s_compare::@2: scope:[mul8s_compare]  from mul8s_compare::@1 mul8s_compare::@5
  [19] (signed byte) mul8s_compare::b#10 ← phi( mul8s_compare::@1/-(byte/word/signed word/dword/signed dword) 128 mul8s_compare::@5/(signed byte) mul8s_compare::b#1 )
  [20] (signed byte) muls8s::a#0 ← (signed byte) mul8s_compare::a#7
  [21] (signed byte) muls8s::b#0 ← (signed byte) mul8s_compare::b#10
  [22] call muls8s 
  [23] (signed word) muls8s::return#2 ← (signed word) muls8s::return#0
  to:mul8s_compare::@12
mul8s_compare::@12: scope:[mul8s_compare]  from mul8s_compare::@2
  [24] (signed word) mul8s_compare::ms#0 ← (signed word) muls8s::return#2
  [25] (signed byte) mulf8s::a#0 ← (signed byte) mul8s_compare::a#7
  [26] (signed byte) mulf8s::b#0 ← (signed byte) mul8s_compare::b#10
  [27] call mulf8s 
  [28] (signed word) mulf8s::return#2 ← (signed word) mulf8s::return#0
  to:mul8s_compare::@13
mul8s_compare::@13: scope:[mul8s_compare]  from mul8s_compare::@12
  [29] (signed word) mul8s_compare::mf#0 ← (signed word) mulf8s::return#2
  [30] (signed byte) mul8s::a#0 ← (signed byte) mul8s_compare::a#7
  [31] (signed byte) mul8s::b#0 ← (signed byte) mul8s_compare::b#10
  [32] call mul8s 
  [33] (signed word) mul8s::return#2 ← (signed word)(word) mul8s::m#4
  to:mul8s_compare::@14
mul8s_compare::@14: scope:[mul8s_compare]  from mul8s_compare::@13
  [34] (signed word) mul8s_compare::mn#0 ← (signed word) mul8s::return#2
  [35] if((signed word) mul8s_compare::ms#0==(signed word) mul8s_compare::mf#0) goto mul8s_compare::@3
  to:mul8s_compare::@6
mul8s_compare::@6: scope:[mul8s_compare]  from mul8s_compare::@14
  [36] phi()
  to:mul8s_compare::@3
mul8s_compare::@3: scope:[mul8s_compare]  from mul8s_compare::@14 mul8s_compare::@6
  [37] (byte) mul8s_compare::ok#4 ← phi( mul8s_compare::@14/(byte/signed byte/word/signed word/dword/signed dword) 1 mul8s_compare::@6/(byte/signed byte/word/signed word/dword/signed dword) 0 )
  [38] if((signed word) mul8s_compare::ms#0==(signed word) mul8s_compare::mn#0) goto mul8s_compare::@20
  to:mul8s_compare::@4
mul8s_compare::@4: scope:[mul8s_compare]  from mul8s_compare::@20 mul8s_compare::@3
  [39] (byte) mul8s_compare::ok#3 ← phi( mul8s_compare::@20/(byte) mul8s_compare::ok#4 mul8s_compare::@3/(byte/signed byte/word/signed word/dword/signed dword) 0 )
  [40] if((byte) mul8s_compare::ok#3!=(byte/signed byte/word/signed word/dword/signed dword) 0) goto mul8s_compare::@5
  to:mul8s_compare::@8
mul8s_compare::@8: scope:[mul8s_compare]  from mul8s_compare::@4
  [41] *((const byte*) BGCOL#0) ← (byte/signed byte/word/signed word/dword/signed dword) 2
  [42] (signed byte) mul8s_error::a#0 ← (signed byte) mul8s_compare::a#7
  [43] (signed byte) mul8s_error::b#0 ← (signed byte) mul8s_compare::b#10
  [44] (signed word) mul8s_error::ms#0 ← (signed word) mul8s_compare::ms#0
  [45] (signed word) mul8s_error::mn#0 ← (signed word) mul8s_compare::mn#0
  [46] (signed word) mul8s_error::mf#0 ← (signed word) mul8s_compare::mf#0
  [47] call mul8s_error 
  to:mul8s_compare::@return
mul8s_compare::@return: scope:[mul8s_compare]  from mul8s_compare::@16 mul8s_compare::@8
  [48] return 
  to:@return
mul8s_compare::@5: scope:[mul8s_compare]  from mul8s_compare::@4
  [49] (signed byte) mul8s_compare::b#1 ← ++ (signed byte) mul8s_compare::b#10
  [50] if((signed byte) mul8s_compare::b#1!=-(byte/word/signed word/dword/signed dword) 128) goto mul8s_compare::@2
  to:mul8s_compare::@10
mul8s_compare::@10: scope:[mul8s_compare]  from mul8s_compare::@5
  [51] (signed byte) mul8s_compare::a#1 ← ++ (signed byte) mul8s_compare::a#7
  [52] if((signed byte) mul8s_compare::a#1!=-(byte/word/signed word/dword/signed dword) 128) goto mul8s_compare::@1
  to:mul8s_compare::@11
mul8s_compare::@11: scope:[mul8s_compare]  from mul8s_compare::@10
  [53] (byte*~) print_char_cursor#192 ← (byte*) print_line_cursor#1
  [54] call print_str 
  to:mul8s_compare::@16
mul8s_compare::@16: scope:[mul8s_compare]  from mul8s_compare::@11
  [55] phi()
  [56] call print_ln 
  to:mul8s_compare::@return
mul8s_compare::@20: scope:[mul8s_compare]  from mul8s_compare::@3
  [57] phi()
  to:mul8s_compare::@4
print_ln: scope:[print_ln]  from mul8s_compare::@16 mul8s_error::@10 mul8u_compare::@16 mul8u_error::@10 mulf_tables_cmp::@10
  [58] (byte*) print_char_cursor#133 ← phi( mul8s_compare::@16/(byte*) print_char_cursor#132 mul8s_error::@10/(byte*) print_char_cursor#18 mul8u_compare::@16/(byte*) print_char_cursor#132 mul8u_error::@10/(byte*) print_char_cursor#18 mulf_tables_cmp::@10/(byte*) print_char_cursor#132 )
  [58] (byte*) print_line_cursor#45 ← phi( mul8s_compare::@16/(byte*) print_line_cursor#1 mul8s_error::@10/(byte*) print_line_cursor#1 mul8u_compare::@16/(byte*) print_line_cursor#10 mul8u_error::@10/(byte*) print_line_cursor#10 mulf_tables_cmp::@10/((byte*))(word/signed word/dword/signed dword) 1024 )
  to:print_ln::@1
print_ln::@1: scope:[print_ln]  from print_ln print_ln::@1
  [59] (byte*) print_line_cursor#23 ← phi( print_ln/(byte*) print_line_cursor#45 print_ln::@1/(byte*) print_line_cursor#1 )
  [60] (byte*) print_line_cursor#1 ← (byte*) print_line_cursor#23 + (byte/signed byte/word/signed word/dword/signed dword) 40
  [61] if((byte*) print_line_cursor#1<(byte*) print_char_cursor#133) goto print_ln::@1
  to:print_ln::@return
print_ln::@return: scope:[print_ln]  from print_ln::@1
  [62] return 
  to:@return
print_str: scope:[print_str]  from mul8s_compare::@11 mul8s_error mul8s_error::@2 mul8s_error::@4 mul8s_error::@6 mul8s_error::@8 mul8u_compare::@11 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::@7
  [63] (byte*) print_char_cursor#152 ← phi( mul8s_compare::@11/(byte*~) print_char_cursor#192 mul8s_error/(byte*~) print_char_cursor#193 mul8s_error::@2/(byte*) print_char_cursor#18 mul8s_error::@4/(byte*) print_char_cursor#18 mul8s_error::@6/(byte*) print_char_cursor#18 mul8s_error::@8/(byte*) print_char_cursor#18 mul8u_compare::@11/(byte*) print_char_cursor#31 mul8u_error/(byte*) print_char_cursor#31 mul8u_error::@2/(byte*) print_char_cursor#18 mul8u_error::@4/(byte*) print_char_cursor#18 mul8u_error::@6/(byte*) print_char_cursor#18 mul8u_error::@8/(byte*) print_char_cursor#18 mulf_tables_cmp::@3/((byte*))(word/signed word/dword/signed dword) 1024 mulf_tables_cmp::@5/((byte*))(word/signed word/dword/signed dword) 1024 mulf_tables_cmp::@7/(byte*) print_char_cursor#18 )
  [63] (byte*) print_str::str#18 ← phi( mul8s_compare::@11/(const string) mul8s_compare::str mul8s_error/(const string) mul8s_error::str mul8s_error::@2/(const string) str1 mul8s_error::@4/(const string) str2 mul8s_error::@6/(const string) str3 mul8s_error::@8/(const string) str4 mul8u_compare::@11/(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::@3/(const string) mulf_tables_cmp::str mulf_tables_cmp::@5/(const string) mulf_tables_cmp::str2 mulf_tables_cmp::@7/(const string) mulf_tables_cmp::str1 )
  to:print_str::@1
print_str::@1: scope:[print_str]  from print_str print_str::@2
  [64] (byte*) print_char_cursor#132 ← phi( print_str/(byte*) print_char_cursor#152 print_str::@2/(byte*) print_char_cursor#1 )
  [64] (byte*) print_str::str#16 ← phi( print_str/(byte*) print_str::str#18 print_str::@2/(byte*) print_str::str#0 )
  [65] if(*((byte*) print_str::str#16)!=(byte) '@') goto print_str::@2
  to:print_str::@return
print_str::@return: scope:[print_str]  from print_str::@1
  [66] return 
  to:@return
print_str::@2: scope:[print_str]  from print_str::@1
  [67] *((byte*) print_char_cursor#132) ← *((byte*) print_str::str#16)
  [68] (byte*) print_char_cursor#1 ← ++ (byte*) print_char_cursor#132
  [69] (byte*) print_str::str#0 ← ++ (byte*) print_str::str#16
  to:print_str::@1
mul8s_error: scope:[mul8s_error]  from mul8s_compare::@8
  [70] (byte*~) print_char_cursor#193 ← (byte*) print_line_cursor#1
  [71] call print_str 
  to:mul8s_error::@1
mul8s_error::@1: scope:[mul8s_error]  from mul8s_error
  [72] (signed byte) print_sbyte::b#1 ← (signed byte) mul8s_error::a#0
  [73] call print_sbyte 
  to:mul8s_error::@2
mul8s_error::@2: scope:[mul8s_error]  from mul8s_error::@1
  [74] phi()
  [75] call print_str 
  to:mul8s_error::@3
mul8s_error::@3: scope:[mul8s_error]  from mul8s_error::@2
  [76] (signed byte) print_sbyte::b#2 ← (signed byte) mul8s_error::b#0
  [77] call print_sbyte 
  to:mul8s_error::@4
mul8s_error::@4: scope:[mul8s_error]  from mul8s_error::@3
  [78] phi()
  [79] call print_str 
  to:mul8s_error::@5
mul8s_error::@5: scope:[mul8s_error]  from mul8s_error::@4
  [80] (signed word) print_sword::w#1 ← (signed word) mul8s_error::ms#0
  [81] call print_sword 
  to:mul8s_error::@6
mul8s_error::@6: scope:[mul8s_error]  from mul8s_error::@5
  [82] phi()
  [83] call print_str 
  to:mul8s_error::@7
mul8s_error::@7: scope:[mul8s_error]  from mul8s_error::@6
  [84] (signed word) print_sword::w#2 ← (signed word) mul8s_error::mn#0
  [85] call print_sword 
  to:mul8s_error::@8
mul8s_error::@8: scope:[mul8s_error]  from mul8s_error::@7
  [86] phi()
  [87] call print_str 
  to:mul8s_error::@9
mul8s_error::@9: scope:[mul8s_error]  from mul8s_error::@8
  [88] (signed word) print_sword::w#3 ← (signed word) mul8s_error::mf#0
  [89] call print_sword 
  to:mul8s_error::@10
mul8s_error::@10: scope:[mul8s_error]  from mul8s_error::@9
  [90] phi()
  [91] call print_ln 
  to:mul8s_error::@return
mul8s_error::@return: scope:[mul8s_error]  from mul8s_error::@10
  [92] return 
  to:@return
print_sword: scope:[print_sword]  from mul8s_error::@5 mul8s_error::@7 mul8s_error::@9
  [93] (signed word) print_sword::w#4 ← phi( mul8s_error::@5/(signed word) print_sword::w#1 mul8s_error::@7/(signed word) print_sword::w#2 mul8s_error::@9/(signed word) print_sword::w#3 )
  [94] if((signed word) print_sword::w#4>=(byte/signed byte/word/signed word/dword/signed dword) 0) goto print_sword::@1
  to:print_sword::@2
print_sword::@2: scope:[print_sword]  from print_sword
  [95] phi()
  [96] call print_char 
  to:print_sword::@4
print_sword::@4: scope:[print_sword]  from print_sword::@2
  [97] (signed word) print_sword::w#0 ← - (signed word) print_sword::w#4
  to:print_sword::@1
print_sword::@1: scope:[print_sword]  from print_sword print_sword::@4
  [98] (byte*) print_char_cursor#134 ← phi( print_sword/(byte*) print_char_cursor#132 print_sword::@4/(byte*) print_char_cursor#18 )
  [98] (signed word) print_sword::w#5 ← phi( print_sword/(signed word) print_sword::w#4 print_sword::@4/(signed word) print_sword::w#0 )
  [99] (word~) print_word::w#13 ← (word)(signed word) print_sword::w#5
  [100] call print_word 
  to:print_sword::@return
print_sword::@return: scope:[print_sword]  from print_sword::@1
  [101] return 
  to:@return
print_word: scope:[print_word]  from mul8u_error::@5 mul8u_error::@7 mul8u_error::@9 mulf_tables_cmp::@6 mulf_tables_cmp::@8 print_sword::@1
  [102] (byte*) print_char_cursor#139 ← phi( mul8u_error::@5/(byte*) print_char_cursor#132 mul8u_error::@7/(byte*) print_char_cursor#132 mul8u_error::@9/(byte*) print_char_cursor#132 mulf_tables_cmp::@6/(byte*) print_char_cursor#132 mulf_tables_cmp::@8/(byte*) print_char_cursor#132 print_sword::@1/(byte*) print_char_cursor#134 )
  [102] (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::@6/(word~) print_word::w#11 mulf_tables_cmp::@8/(word~) print_word::w#12 print_sword::@1/(word~) print_word::w#13 )
  [103] (byte) print_byte::b#1 ← > (word) print_word::w#6
  [104] call print_byte 
  to:print_word::@1
print_word::@1: scope:[print_word]  from print_word
  [105] (byte) print_byte::b#2 ← < (word) print_word::w#6
  [106] call print_byte 
  to:print_word::@return
print_word::@return: scope:[print_word]  from print_word::@1
  [107] return 
  to:@return
print_byte: scope:[print_byte]  from mul8u_error::@1 mul8u_error::@3 print_sbyte::@2 print_word print_word::@1
  [108] (byte*) print_char_cursor#140 ← phi( mul8u_error::@1/(byte*) print_char_cursor#132 mul8u_error::@3/(byte*) print_char_cursor#132 print_sbyte::@2/(byte*) print_char_cursor#18 print_word/(byte*) print_char_cursor#139 print_word::@1/(byte*) print_char_cursor#18 )
  [108] (byte) print_byte::b#5 ← phi( mul8u_error::@1/(byte) print_byte::b#3 mul8u_error::@3/(byte) print_byte::b#4 print_sbyte::@2/(byte~) print_byte::b#9 print_word/(byte) print_byte::b#1 print_word::@1/(byte) print_byte::b#2 )
  [109] (byte~) print_byte::$0 ← (byte) print_byte::b#5 >> (byte/signed byte/word/signed word/dword/signed dword) 4
  [110] (byte) print_char::ch#3 ← *((const byte[]) print_hextab#0 + (byte~) print_byte::$0)
  [111] call print_char 
  to:print_byte::@1
print_byte::@1: scope:[print_byte]  from print_byte
  [112] (byte~) print_byte::$2 ← (byte) print_byte::b#5 & (byte/signed byte/word/signed word/dword/signed dword) 15
  [113] (byte) print_char::ch#4 ← *((const byte[]) print_hextab#0 + (byte~) print_byte::$2)
  [114] call print_char 
  to:print_byte::@return
print_byte::@return: scope:[print_byte]  from print_byte::@1
  [115] return 
  to:@return
print_char: scope:[print_char]  from print_byte print_byte::@1 print_sbyte::@1 print_sbyte::@3 print_sword::@2
  [116] (byte*) print_char_cursor#84 ← phi( print_byte/(byte*) print_char_cursor#140 print_byte::@1/(byte*) print_char_cursor#18 print_sbyte::@1/(byte*) print_char_cursor#132 print_sbyte::@3/(byte*) print_char_cursor#132 print_sword::@2/(byte*) print_char_cursor#132 )
  [116] (byte) print_char::ch#5 ← phi( print_byte/(byte) print_char::ch#3 print_byte::@1/(byte) print_char::ch#4 print_sbyte::@1/(byte) '-' print_sbyte::@3/(byte) ' ' print_sword::@2/(byte) '-' )
  [117] *((byte*) print_char_cursor#84) ← (byte) print_char::ch#5
  [118] (byte*) print_char_cursor#18 ← ++ (byte*) print_char_cursor#84
  to:print_char::@return
print_char::@return: scope:[print_char]  from print_char
  [119] return 
  to:@return
print_sbyte: scope:[print_sbyte]  from mul8s_error::@1 mul8s_error::@3
  [120] (signed byte) print_sbyte::b#3 ← phi( mul8s_error::@1/(signed byte) print_sbyte::b#1 mul8s_error::@3/(signed byte) print_sbyte::b#2 )
  [121] if((signed byte) print_sbyte::b#3<(byte/signed byte/word/signed word/dword/signed dword) 0) goto print_sbyte::@1
  to:print_sbyte::@3
print_sbyte::@3: scope:[print_sbyte]  from print_sbyte
  [122] phi()
  [123] call print_char 
  to:print_sbyte::@2
print_sbyte::@2: scope:[print_sbyte]  from print_sbyte::@3 print_sbyte::@5
  [124] (signed byte) print_sbyte::b#5 ← phi( print_sbyte::@5/(signed byte) print_sbyte::b#0 print_sbyte::@3/(signed byte) print_sbyte::b#3 )
  [125] (byte~) print_byte::b#9 ← (byte)(signed byte) print_sbyte::b#5
  [126] call print_byte 
  to:print_sbyte::@return
print_sbyte::@return: scope:[print_sbyte]  from print_sbyte::@2
  [127] return 
  to:@return
print_sbyte::@1: scope:[print_sbyte]  from print_sbyte
  [128] phi()
  [129] call print_char 
  to:print_sbyte::@5
print_sbyte::@5: scope:[print_sbyte]  from print_sbyte::@1
  [130] (signed byte) print_sbyte::b#0 ← - (signed byte) print_sbyte::b#3
  to:print_sbyte::@2
mul8s: scope:[mul8s]  from mul8s_compare::@13
  [131] (byte~) mul8u::b#3 ← (byte)(signed byte) mul8s::b#0
  [132] (byte~) mul8u::a#8 ← (byte)(signed byte) mul8s::a#0
  [133] call mul8u 
  [134] (word) mul8u::return#2 ← (word) mul8u::res#2
  to:mul8s::@6
mul8s::@6: scope:[mul8s]  from mul8s
  [135] (word) mul8s::m#0 ← (word) mul8u::return#2
  [136] if((signed byte) mul8s::a#0>=(byte/signed byte/word/signed word/dword/signed dword) 0) goto mul8s::@1
  to:mul8s::@3
mul8s::@3: scope:[mul8s]  from mul8s::@6
  [137] (byte~) mul8s::$6 ← > (word) mul8s::m#0
  [138] (byte~) mul8s::$16 ← (byte~) mul8s::$6 - (byte)(signed byte) mul8s::b#0
  [139] (word) mul8s::m#1 ← (word) mul8s::m#0 hi= (byte~) mul8s::$16
  to:mul8s::@1
mul8s::@1: scope:[mul8s]  from mul8s::@3 mul8s::@6
  [140] (word) mul8s::m#5 ← phi( mul8s::@3/(word) mul8s::m#1 mul8s::@6/(word) mul8s::m#0 )
  [141] if((signed byte) mul8s::b#0>=(byte/signed byte/word/signed word/dword/signed dword) 0) goto mul8s::@2
  to:mul8s::@4
mul8s::@4: scope:[mul8s]  from mul8s::@1
  [142] (byte~) mul8s::$12 ← > (word) mul8s::m#5
  [143] (byte~) mul8s::$17 ← (byte~) mul8s::$12 - (byte)(signed byte) mul8s::a#0
  [144] (word) mul8s::m#2 ← (word) mul8s::m#5 hi= (byte~) mul8s::$17
  to:mul8s::@2
mul8s::@2: scope:[mul8s]  from mul8s::@1 mul8s::@4
  [145] (word) mul8s::m#4 ← phi( mul8s::@1/(word) mul8s::m#5 mul8s::@4/(word) mul8s::m#2 )
  to:mul8s::@return
mul8s::@return: scope:[mul8s]  from mul8s::@2
  [146] return 
  to:@return
mul8u: scope:[mul8u]  from mul8s mul8u_compare::@13
  [147] (byte) mul8u::a#6 ← phi( mul8s/(byte~) mul8u::a#8 mul8u_compare::@13/(byte) mul8u::a#2 )
  [147] (byte) mul8u::b#2 ← phi( mul8s/(byte~) mul8u::b#3 mul8u_compare::@13/(byte) mul8u::b#1 )
  [148] (word) mul8u::mb#0 ← ((word)) (byte) mul8u::b#2
  to:mul8u::@1
mul8u::@1: scope:[mul8u]  from mul8u mul8u::@4
  [149] (word) mul8u::mb#2 ← phi( mul8u/(word) mul8u::mb#0 mul8u::@4/(word) mul8u::mb#1 )
  [149] (word) mul8u::res#2 ← phi( mul8u/(byte/signed byte/word/signed word/dword/signed dword) 0 mul8u::@4/(word) mul8u::res#6 )
  [149] (byte) mul8u::a#3 ← phi( mul8u/(byte) mul8u::a#6 mul8u::@4/(byte) mul8u::a#0 )
  [150] if((byte) mul8u::a#3!=(byte/signed byte/word/signed word/dword/signed dword) 0) goto mul8u::@2
  to:mul8u::@return
mul8u::@return: scope:[mul8u]  from mul8u::@1
  [151] return 
  to:@return
mul8u::@2: scope:[mul8u]  from mul8u::@1
  [152] (byte~) mul8u::$1 ← (byte) mul8u::a#3 & (byte/signed byte/word/signed word/dword/signed dword) 1
  [153] if((byte~) mul8u::$1==(byte/signed byte/word/signed word/dword/signed dword) 0) goto mul8u::@4
  to:mul8u::@7
mul8u::@7: scope:[mul8u]  from mul8u::@2
  [154] (word) mul8u::res#1 ← (word) mul8u::res#2 + (word) mul8u::mb#2
  to:mul8u::@4
mul8u::@4: scope:[mul8u]  from mul8u::@2 mul8u::@7
  [155] (word) mul8u::res#6 ← phi( mul8u::@2/(word) mul8u::res#2 mul8u::@7/(word) mul8u::res#1 )
  [156] (byte) mul8u::a#0 ← (byte) mul8u::a#3 >> (byte/signed byte/word/signed word/dword/signed dword) 1
  [157] (word) mul8u::mb#1 ← (word) mul8u::mb#2 << (byte/signed byte/word/signed word/dword/signed dword) 1
  to:mul8u::@1
mulf8s: scope:[mulf8s]  from mul8s_compare::@12
  [158] phi()
  to:mulf8s::mulf8s_prepare1
mulf8s::mulf8s_prepare1: scope:[mulf8s]  from mulf8s
  [159] (byte~) mulf8u_prepare::a#3 ← (byte)(signed byte) mulf8s::a#0
  [160] call mulf8u_prepare 
  to:mulf8s::@2
mulf8s::@2: scope:[mulf8s]  from mulf8s::mulf8s_prepare1
  [161] (signed byte) mulf8s_prepared::b#0 ← (signed byte) mulf8s::b#0
  [162] call mulf8s_prepared 
  [163] (signed word) mulf8s_prepared::return#2 ← (signed word)(word) mulf8s_prepared::m#4
  to:mulf8s::@4
mulf8s::@4: scope:[mulf8s]  from mulf8s::@2
  [164] (signed word) mulf8s::return#0 ← (signed word) mulf8s_prepared::return#2
  to:mulf8s::@return
mulf8s::@return: scope:[mulf8s]  from mulf8s::@4
  [165] return 
  to:@return
mulf8s_prepared: scope:[mulf8s_prepared]  from mulf8s::@2
  [166] (byte~) mulf8u_prepared::b#3 ← (byte)(signed byte) mulf8s_prepared::b#0
  [167] call mulf8u_prepared 
  [168] (word) mulf8u_prepared::return#3 ← (word) mulf8u_prepared::return#0
  to:mulf8s_prepared::@6
mulf8s_prepared::@6: scope:[mulf8s_prepared]  from mulf8s_prepared
  [169] (word) mulf8s_prepared::m#0 ← (word) mulf8u_prepared::return#3
  [170] if(*((const signed byte*) mulf8s_prepared::memA#0)>=(byte/signed byte/word/signed word/dword/signed dword) 0) goto mulf8s_prepared::@1
  to:mulf8s_prepared::@3
mulf8s_prepared::@3: scope:[mulf8s_prepared]  from mulf8s_prepared::@6
  [171] (byte~) mulf8s_prepared::$5 ← > (word) mulf8s_prepared::m#0
  [172] (byte~) mulf8s_prepared::$15 ← (byte~) mulf8s_prepared::$5 - (byte)(signed byte) mulf8s_prepared::b#0
  [173] (word) mulf8s_prepared::m#1 ← (word) mulf8s_prepared::m#0 hi= (byte~) mulf8s_prepared::$15
  to:mulf8s_prepared::@1
mulf8s_prepared::@1: scope:[mulf8s_prepared]  from mulf8s_prepared::@3 mulf8s_prepared::@6
  [174] (word) mulf8s_prepared::m#5 ← phi( mulf8s_prepared::@3/(word) mulf8s_prepared::m#1 mulf8s_prepared::@6/(word) mulf8s_prepared::m#0 )
  [175] if((signed byte) mulf8s_prepared::b#0>=(byte/signed byte/word/signed word/dword/signed dword) 0) goto mulf8s_prepared::@2
  to:mulf8s_prepared::@4
mulf8s_prepared::@4: scope:[mulf8s_prepared]  from mulf8s_prepared::@1
  [176] (byte~) mulf8s_prepared::$11 ← > (word) mulf8s_prepared::m#5
  [177] (byte~) mulf8s_prepared::$16 ← (byte~) mulf8s_prepared::$11 - (byte)*((const signed byte*) mulf8s_prepared::memA#0)
  [178] (word) mulf8s_prepared::m#2 ← (word) mulf8s_prepared::m#5 hi= (byte~) mulf8s_prepared::$16
  to:mulf8s_prepared::@2
mulf8s_prepared::@2: scope:[mulf8s_prepared]  from mulf8s_prepared::@1 mulf8s_prepared::@4
  [179] (word) mulf8s_prepared::m#4 ← phi( mulf8s_prepared::@1/(word) mulf8s_prepared::m#5 mulf8s_prepared::@4/(word) mulf8s_prepared::m#2 )
  to:mulf8s_prepared::@return
mulf8s_prepared::@return: scope:[mulf8s_prepared]  from mulf8s_prepared::@2
  [180] return 
  to:@return
mulf8u_prepared: scope:[mulf8u_prepared]  from mulf8s_prepared mulf8u::@2
  [181] (byte) mulf8u_prepared::b#2 ← phi( mulf8s_prepared/(byte~) mulf8u_prepared::b#3 mulf8u::@2/(byte) mulf8u_prepared::b#0 )
  [182] *((const byte*) mulf8u_prepared::memB#0) ← (byte) 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  }
  [184] (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
  [185] return 
  to:@return
mulf8u_prepare: scope:[mulf8u_prepare]  from mulf8s::mulf8s_prepare1 mulf8u
  [186] (byte) mulf8u_prepare::a#2 ← phi( mulf8s::mulf8s_prepare1/(byte~) mulf8u_prepare::a#3 mulf8u/(byte) mulf8u_prepare::a#0 )
  [187] *((const byte*) mulf8u_prepare::memA#0) ← (byte) 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
  [189] return 
  to:@return
muls8s: scope:[muls8s]  from mul8s_compare::@2
  [190] if((signed byte) muls8s::a#0<(byte/signed byte/word/signed word/dword/signed dword) 0) goto muls8s::@5
  to:muls8s::@6
muls8s::@6: scope:[muls8s]  from muls8s
  [191] if((signed byte) muls8s::a#0<=(byte/signed byte/word/signed word/dword/signed dword) 0) goto muls8s::@4
  to:muls8s::@3
muls8s::@3: scope:[muls8s]  from muls8s::@3 muls8s::@6
  [192] (signed byte) muls8s::j#2 ← phi( muls8s::@3/(signed byte) muls8s::j#1 muls8s::@6/(byte/signed byte/word/signed word/dword/signed dword) 0 )
  [192] (signed word) muls8s::m#3 ← phi( muls8s::@3/(signed word) muls8s::m#1 muls8s::@6/(byte/signed byte/word/signed word/dword/signed dword) 0 )
  [193] (signed word) muls8s::m#1 ← (signed word) muls8s::m#3 + (signed byte) muls8s::b#0
  [194] (signed byte) muls8s::j#1 ← ++ (signed byte) muls8s::j#2
  [195] if((signed byte) muls8s::j#1!=(signed byte) muls8s::a#0) goto muls8s::@3
  to:muls8s::@4
muls8s::@4: scope:[muls8s]  from muls8s::@3 muls8s::@5 muls8s::@6
  [196] (signed word) muls8s::return#0 ← phi( muls8s::@6/(byte/signed byte/word/signed word/dword/signed dword) 0 muls8s::@3/(signed word) muls8s::m#1 muls8s::@5/(signed word) muls8s::m#2 )
  to:muls8s::@return
muls8s::@return: scope:[muls8s]  from muls8s::@4
  [197] return 
  to:@return
muls8s::@5: scope:[muls8s]  from muls8s muls8s::@5
  [198] (signed byte) muls8s::i#2 ← phi( muls8s/(byte/signed byte/word/signed word/dword/signed dword) 0 muls8s::@5/(signed byte) muls8s::i#1 )
  [198] (signed word) muls8s::m#5 ← phi( muls8s/(byte/signed byte/word/signed word/dword/signed dword) 0 muls8s::@5/(signed word) muls8s::m#2 )
  [199] (signed word) muls8s::m#2 ← (signed word) muls8s::m#5 - (signed byte) muls8s::b#0
  [200] (signed byte) muls8s::i#1 ← -- (signed byte) muls8s::i#2
  [201] if((signed byte) muls8s::i#1!=(signed byte) muls8s::a#0) goto muls8s::@5
  to:muls8s::@4
mul8u_compare: scope:[mul8u_compare]  from main::@4
  [202] phi()
  to:mul8u_compare::@1
mul8u_compare::@1: scope:[mul8u_compare]  from mul8u_compare mul8u_compare::@10
  [203] (byte) mul8u_compare::a#7 ← phi( mul8u_compare/(byte/signed byte/word/signed word/dword/signed dword) 0 mul8u_compare::@10/(byte) mul8u_compare::a#1 )
  to:mul8u_compare::@2
mul8u_compare::@2: scope:[mul8u_compare]  from mul8u_compare::@1 mul8u_compare::@5
  [204] (byte) mul8u_compare::b#10 ← phi( mul8u_compare::@1/(byte/signed byte/word/signed word/dword/signed dword) 0 mul8u_compare::@5/(byte) mul8u_compare::b#1 )
  [205] (byte) muls8u::a#0 ← (byte) mul8u_compare::a#7
  [206] (byte) muls8u::b#0 ← (byte) mul8u_compare::b#10
  [207] call muls8u 
  [208] (word) muls8u::return#2 ← (word) muls8u::return#0
  to:mul8u_compare::@12
mul8u_compare::@12: scope:[mul8u_compare]  from mul8u_compare::@2
  [209] (word) mul8u_compare::ms#0 ← (word) muls8u::return#2
  [210] (byte) mulf8u::a#0 ← (byte) mul8u_compare::a#7
  [211] (byte) mulf8u::b#0 ← (byte) mul8u_compare::b#10
  [212] call mulf8u 
  [213] (word) mulf8u::return#2 ← (word) mulf8u::return#0
  to:mul8u_compare::@13
mul8u_compare::@13: scope:[mul8u_compare]  from mul8u_compare::@12
  [214] (word) mul8u_compare::mf#0 ← (word) mulf8u::return#2
  [215] (byte) mul8u::a#2 ← (byte) mul8u_compare::a#7
  [216] (byte) mul8u::b#1 ← (byte) mul8u_compare::b#10
  [217] call mul8u 
  [218] (word) mul8u::return#3 ← (word) mul8u::res#2
  to:mul8u_compare::@14
mul8u_compare::@14: scope:[mul8u_compare]  from mul8u_compare::@13
  [219] (word) mul8u_compare::mn#0 ← (word) mul8u::return#3
  [220] 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::@14
  [221] phi()
  to:mul8u_compare::@3
mul8u_compare::@3: scope:[mul8u_compare]  from mul8u_compare::@14 mul8u_compare::@6
  [222] (byte) mul8u_compare::ok#4 ← phi( mul8u_compare::@14/(byte/signed byte/word/signed word/dword/signed dword) 1 mul8u_compare::@6/(byte/signed byte/word/signed word/dword/signed dword) 0 )
  [223] if((word) mul8u_compare::ms#0==(word) mul8u_compare::mn#0) goto mul8u_compare::@20
  to:mul8u_compare::@4
mul8u_compare::@4: scope:[mul8u_compare]  from mul8u_compare::@20 mul8u_compare::@3
  [224] (byte) mul8u_compare::ok#3 ← phi( mul8u_compare::@20/(byte) mul8u_compare::ok#4 mul8u_compare::@3/(byte/signed byte/word/signed word/dword/signed dword) 0 )
  [225] if((byte) mul8u_compare::ok#3!=(byte/signed byte/word/signed word/dword/signed dword) 0) goto mul8u_compare::@5
  to:mul8u_compare::@8
mul8u_compare::@8: scope:[mul8u_compare]  from mul8u_compare::@4
  [226] *((const byte*) BGCOL#0) ← (byte/signed byte/word/signed word/dword/signed dword) 2
  [227] (byte) mul8u_error::a#0 ← (byte) mul8u_compare::a#7
  [228] (byte) mul8u_error::b#0 ← (byte) mul8u_compare::b#10
  [229] (word) mul8u_error::ms#0 ← (word) mul8u_compare::ms#0
  [230] (word) mul8u_error::mn#0 ← (word) mul8u_compare::mn#0
  [231] (word) mul8u_error::mf#0 ← (word) mul8u_compare::mf#0
  [232] call mul8u_error 
  to:mul8u_compare::@return
mul8u_compare::@return: scope:[mul8u_compare]  from mul8u_compare::@16 mul8u_compare::@8
  [233] return 
  to:@return
mul8u_compare::@5: scope:[mul8u_compare]  from mul8u_compare::@4
  [234] (byte) mul8u_compare::b#1 ← ++ (byte) mul8u_compare::b#10
  [235] if((byte) mul8u_compare::b#1!=(byte/signed byte/word/signed word/dword/signed dword) 0) goto mul8u_compare::@2
  to:mul8u_compare::@10
mul8u_compare::@10: scope:[mul8u_compare]  from mul8u_compare::@5
  [236] (byte) mul8u_compare::a#1 ← ++ (byte) mul8u_compare::a#7
  [237] if((byte) mul8u_compare::a#1!=(byte/signed byte/word/signed word/dword/signed dword) 0) goto mul8u_compare::@1
  to:mul8u_compare::@11
mul8u_compare::@11: scope:[mul8u_compare]  from mul8u_compare::@10
  [238] phi()
  [239] call print_str 
  to:mul8u_compare::@16
mul8u_compare::@16: scope:[mul8u_compare]  from mul8u_compare::@11
  [240] phi()
  [241] call print_ln 
  to:mul8u_compare::@return
mul8u_compare::@20: scope:[mul8u_compare]  from mul8u_compare::@3
  [242] phi()
  to:mul8u_compare::@4
mul8u_error: scope:[mul8u_error]  from mul8u_compare::@8
  [243] phi()
  [244] call print_str 
  to:mul8u_error::@1
mul8u_error::@1: scope:[mul8u_error]  from mul8u_error
  [245] (byte) print_byte::b#3 ← (byte) mul8u_error::a#0
  [246] call print_byte 
  to:mul8u_error::@2
mul8u_error::@2: scope:[mul8u_error]  from mul8u_error::@1
  [247] phi()
  [248] call print_str 
  to:mul8u_error::@3
mul8u_error::@3: scope:[mul8u_error]  from mul8u_error::@2
  [249] (byte) print_byte::b#4 ← (byte) mul8u_error::b#0
  [250] call print_byte 
  to:mul8u_error::@4
mul8u_error::@4: scope:[mul8u_error]  from mul8u_error::@3
  [251] phi()
  [252] call print_str 
  to:mul8u_error::@5
mul8u_error::@5: scope:[mul8u_error]  from mul8u_error::@4
  [253] (word) print_word::w#3 ← (word) mul8u_error::ms#0
  [254] call print_word 
  to:mul8u_error::@6
mul8u_error::@6: scope:[mul8u_error]  from mul8u_error::@5
  [255] phi()
  [256] call print_str 
  to:mul8u_error::@7
mul8u_error::@7: scope:[mul8u_error]  from mul8u_error::@6
  [257] (word) print_word::w#4 ← (word) mul8u_error::mn#0
  [258] call print_word 
  to:mul8u_error::@8
mul8u_error::@8: scope:[mul8u_error]  from mul8u_error::@7
  [259] phi()
  [260] call print_str 
  to:mul8u_error::@9
mul8u_error::@9: scope:[mul8u_error]  from mul8u_error::@8
  [261] (word) print_word::w#5 ← (word) mul8u_error::mf#0
  [262] call print_word 
  to:mul8u_error::@10
mul8u_error::@10: scope:[mul8u_error]  from mul8u_error::@9
  [263] phi()
  [264] call print_ln 
  to:mul8u_error::@return
mul8u_error::@return: scope:[mul8u_error]  from mul8u_error::@10
  [265] return 
  to:@return
mulf8u: scope:[mulf8u]  from mul8u_compare::@12
  [266] (byte) mulf8u_prepare::a#0 ← (byte) mulf8u::a#0
  [267] call mulf8u_prepare 
  to:mulf8u::@2
mulf8u::@2: scope:[mulf8u]  from mulf8u
  [268] (byte) mulf8u_prepared::b#0 ← (byte) mulf8u::b#0
  [269] call mulf8u_prepared 
  [270] (word) mulf8u_prepared::return#2 ← (word) mulf8u_prepared::return#0
  to:mulf8u::@3
mulf8u::@3: scope:[mulf8u]  from mulf8u::@2
  [271] (word) mulf8u::return#0 ← (word) mulf8u_prepared::return#2
  to:mulf8u::@return
mulf8u::@return: scope:[mulf8u]  from mulf8u::@3
  [272] return 
  to:@return
muls8u: scope:[muls8u]  from mul8u_compare::@2
  [273] if((byte) muls8u::a#0==(byte/signed byte/word/signed word/dword/signed dword) 0) goto muls8u::@1
  to:muls8u::@2
muls8u::@2: scope:[muls8u]  from muls8u muls8u::@2
  [274] (byte) muls8u::i#2 ← phi( muls8u::@2/(byte) muls8u::i#1 muls8u/(byte/signed byte/word/signed word/dword/signed dword) 0 )
  [274] (word) muls8u::m#3 ← phi( muls8u::@2/(word) muls8u::m#1 muls8u/(byte/signed byte/word/signed word/dword/signed dword) 0 )
  [275] (word) muls8u::m#1 ← (word) muls8u::m#3 + (byte) muls8u::b#0
  [276] (byte) muls8u::i#1 ← ++ (byte) muls8u::i#2
  [277] if((byte) muls8u::i#1!=(byte) muls8u::a#0) goto muls8u::@2
  to:muls8u::@1
muls8u::@1: scope:[muls8u]  from muls8u muls8u::@2
  [278] (word) muls8u::return#0 ← phi( muls8u/(byte/signed byte/word/signed word/dword/signed dword) 0 muls8u::@2/(word) muls8u::m#1 )
  to:muls8u::@return
muls8u::@return: scope:[muls8u]  from muls8u::@1
  [279] return 
  to:@return
mulf_tables_cmp: scope:[mulf_tables_cmp]  from main::@3
  [280] phi()
  to:mulf_tables_cmp::@1
mulf_tables_cmp::@1: scope:[mulf_tables_cmp]  from mulf_tables_cmp mulf_tables_cmp::@2
  [281] (byte*) mulf_tables_cmp::asm_sqr#2 ← phi( mulf_tables_cmp/(const byte[512]) mula_sqr1_lo#0 mulf_tables_cmp::@2/(byte*) mulf_tables_cmp::asm_sqr#1 )
  [281] (byte*) mulf_tables_cmp::kc_sqr#2 ← phi( mulf_tables_cmp/(const byte[512]) mulf_sqr1_lo#0 mulf_tables_cmp::@2/(byte*) mulf_tables_cmp::kc_sqr#1 )
  [282] if(*((byte*) mulf_tables_cmp::kc_sqr#2)==*((byte*) mulf_tables_cmp::asm_sqr#2)) goto mulf_tables_cmp::@2
  to:mulf_tables_cmp::@3
mulf_tables_cmp::@3: scope:[mulf_tables_cmp]  from mulf_tables_cmp::@1
  [283] *((const byte*) BGCOL#0) ← (byte/signed byte/word/signed word/dword/signed dword) 2
  [284] call print_str 
  to:mulf_tables_cmp::@6
mulf_tables_cmp::@6: scope:[mulf_tables_cmp]  from mulf_tables_cmp::@3
  [285] (word~) print_word::w#11 ← (word)(byte*) mulf_tables_cmp::asm_sqr#2
  [286] call print_word 
  to:mulf_tables_cmp::@7
mulf_tables_cmp::@7: scope:[mulf_tables_cmp]  from mulf_tables_cmp::@6
  [287] phi()
  [288] call print_str 
  to:mulf_tables_cmp::@8
mulf_tables_cmp::@8: scope:[mulf_tables_cmp]  from mulf_tables_cmp::@7
  [289] (word~) print_word::w#12 ← (word)(byte*) mulf_tables_cmp::kc_sqr#2
  [290] call print_word 
  to:mulf_tables_cmp::@return
mulf_tables_cmp::@return: scope:[mulf_tables_cmp]  from mulf_tables_cmp::@10 mulf_tables_cmp::@8
  [291] (byte*) print_line_cursor#10 ← phi( mulf_tables_cmp::@10/(byte*) print_line_cursor#1 mulf_tables_cmp::@8/((byte*))(word/signed word/dword/signed dword) 1024 )
  [291] (byte*) print_char_cursor#31 ← phi( mulf_tables_cmp::@10/(byte*~) print_char_cursor#225 mulf_tables_cmp::@8/(byte*) print_char_cursor#18 )
  [292] return 
  to:@return
mulf_tables_cmp::@2: scope:[mulf_tables_cmp]  from mulf_tables_cmp::@1
  [293] (byte*) mulf_tables_cmp::asm_sqr#1 ← ++ (byte*) mulf_tables_cmp::asm_sqr#2
  [294] (byte*) mulf_tables_cmp::kc_sqr#1 ← ++ (byte*) mulf_tables_cmp::kc_sqr#2
  [295] if((byte*) mulf_tables_cmp::kc_sqr#1<(const byte[512]) mulf_sqr1_lo#0+(word/signed word/dword/signed dword) 512*(byte/signed byte/word/signed word/dword/signed dword) 4) goto mulf_tables_cmp::@1
  to:mulf_tables_cmp::@5
mulf_tables_cmp::@5: scope:[mulf_tables_cmp]  from mulf_tables_cmp::@2
  [296] phi()
  [297] call print_str 
  to:mulf_tables_cmp::@10
mulf_tables_cmp::@10: scope:[mulf_tables_cmp]  from mulf_tables_cmp::@5
  [298] phi()
  [299] call print_ln 
  [300] (byte*~) print_char_cursor#225 ← (byte*) print_line_cursor#1
  to:mulf_tables_cmp::@return
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!-  }
  [302] *((const byte*) mulf_init_asm::mem#0) ← *((const byte[512]) mula_sqr1_lo#0)
  [303] *((const byte*) mulf_init_asm::mem#0) ← *((const byte[512]) mula_sqr1_hi#0)
  [304] *((const byte*) mulf_init_asm::mem#0) ← *((const byte[512]) mula_sqr2_lo#0)
  [305] *((const byte*) mulf_init_asm::mem#0) ← *((const byte[512]) mula_sqr2_hi#0)
  to:mulf_init_asm::@return
mulf_init_asm::@return: scope:[mulf_init_asm]  from mulf_init_asm
  [306] return 
  to:@return
mulf_init: scope:[mulf_init]  from main::@1
  [307] phi()
  to:mulf_init::@1
mulf_init::@1: scope:[mulf_init]  from mulf_init mulf_init::@2
  [308] (byte) mulf_init::x_2#3 ← phi( mulf_init/(byte/signed byte/word/signed word/dword/signed dword) 0 mulf_init::@2/(byte) mulf_init::x_2#2 )
  [308] (byte*) mulf_init::sqr1_hi#2 ← phi( mulf_init/(const byte[512]) mulf_sqr1_hi#0+(byte/signed byte/word/signed word/dword/signed dword) 1 mulf_init::@2/(byte*) mulf_init::sqr1_hi#1 )
  [308] (byte*) mulf_init::sqr1_lo#2 ← phi( mulf_init/(const byte[512]) mulf_sqr1_lo#0+(byte/signed byte/word/signed word/dword/signed dword) 1 mulf_init::@2/(byte*) mulf_init::sqr1_lo#1 )
  [308] (word) mulf_init::sqr#4 ← phi( mulf_init/(byte/signed byte/word/signed word/dword/signed dword) 0 mulf_init::@2/(word) mulf_init::sqr#1 )
  [308] (byte) mulf_init::c#2 ← phi( mulf_init/(byte/signed byte/word/signed word/dword/signed dword) 0 mulf_init::@2/(byte) mulf_init::c#1 )
  [309] (byte) mulf_init::c#1 ← ++ (byte) mulf_init::c#2
  [310] (byte~) mulf_init::$2 ← (byte) mulf_init::c#1 & (byte/signed byte/word/signed word/dword/signed dword) 1
  [311] if((byte~) mulf_init::$2!=(byte/signed byte/word/signed word/dword/signed dword) 0) goto mulf_init::@2
  to:mulf_init::@5
mulf_init::@5: scope:[mulf_init]  from mulf_init::@1
  [312] (byte) mulf_init::x_2#1 ← ++ (byte) mulf_init::x_2#3
  [313] (word) mulf_init::sqr#2 ← ++ (word) mulf_init::sqr#4
  to:mulf_init::@2
mulf_init::@2: scope:[mulf_init]  from mulf_init::@1 mulf_init::@5
  [314] (byte) mulf_init::x_2#2 ← phi( mulf_init::@1/(byte) mulf_init::x_2#3 mulf_init::@5/(byte) mulf_init::x_2#1 )
  [314] (word) mulf_init::sqr#3 ← phi( mulf_init::@1/(word) mulf_init::sqr#4 mulf_init::@5/(word) mulf_init::sqr#2 )
  [315] (byte~) mulf_init::$5 ← < (word) mulf_init::sqr#3
  [316] *((byte*) mulf_init::sqr1_lo#2) ← (byte~) mulf_init::$5
  [317] (byte~) mulf_init::$6 ← > (word) mulf_init::sqr#3
  [318] *((byte*) mulf_init::sqr1_hi#2) ← (byte~) mulf_init::$6
  [319] (byte*) mulf_init::sqr1_hi#1 ← ++ (byte*) mulf_init::sqr1_hi#2
  [320] (word) mulf_init::sqr#1 ← (word) mulf_init::sqr#3 + (byte) mulf_init::x_2#2
  [321] (byte*) mulf_init::sqr1_lo#1 ← ++ (byte*) mulf_init::sqr1_lo#2
  [322] if((byte*) mulf_init::sqr1_lo#1!=(const byte[512]) mulf_sqr1_lo#0+(word/signed word/dword/signed dword) 512) goto mulf_init::@1
  to:mulf_init::@3
mulf_init::@3: scope:[mulf_init]  from mulf_init::@2 mulf_init::@4
  [323] (byte) mulf_init::dir#2 ← phi( mulf_init::@4/(byte) mulf_init::dir#3 mulf_init::@2/(byte/word/signed word/dword/signed dword) 255 )
  [323] (byte*) mulf_init::sqr2_hi#2 ← phi( mulf_init::@4/(byte*) mulf_init::sqr2_hi#1 mulf_init::@2/(const byte[512]) mulf_sqr2_hi#0 )
  [323] (byte*) mulf_init::sqr2_lo#2 ← phi( mulf_init::@4/(byte*) mulf_init::sqr2_lo#1 mulf_init::@2/(const byte[512]) mulf_sqr2_lo#0 )
  [323] (byte) mulf_init::x_255#2 ← phi( mulf_init::@4/(byte) mulf_init::x_255#1 mulf_init::@2/((byte))-(byte/signed byte/word/signed word/dword/signed dword) 1 )
  [324] *((byte*) mulf_init::sqr2_lo#2) ← *((const byte[512]) mulf_sqr1_lo#0 + (byte) mulf_init::x_255#2)
  [325] *((byte*) mulf_init::sqr2_hi#2) ← *((const byte[512]) mulf_sqr1_hi#0 + (byte) mulf_init::x_255#2)
  [326] (byte*) mulf_init::sqr2_hi#1 ← ++ (byte*) mulf_init::sqr2_hi#2
  [327] (byte) mulf_init::x_255#1 ← (byte) mulf_init::x_255#2 + (byte) mulf_init::dir#2
  [328] if((byte) mulf_init::x_255#1!=(byte/signed byte/word/signed word/dword/signed dword) 0) goto mulf_init::@12
  to:mulf_init::@4
mulf_init::@4: scope:[mulf_init]  from mulf_init::@12 mulf_init::@3
  [329] (byte) mulf_init::dir#3 ← phi( mulf_init::@12/(byte) mulf_init::dir#2 mulf_init::@3/(byte/signed byte/word/signed word/dword/signed dword) 1 )
  [330] (byte*) mulf_init::sqr2_lo#1 ← ++ (byte*) mulf_init::sqr2_lo#2
  [331] if((byte*) mulf_init::sqr2_lo#1!=(const byte[512]) mulf_sqr2_lo#0+(word/signed word/dword/signed dword) 511) goto mulf_init::@3
  to:mulf_init::@8
mulf_init::@8: scope:[mulf_init]  from mulf_init::@4
  [332] *((const byte[512]) mulf_sqr2_lo#0+(word/signed word/dword/signed dword) 511) ← *((const byte[512]) mulf_sqr1_lo#0+(word/signed word/dword/signed dword) 256)
  [333] *((const byte[512]) mulf_sqr2_hi#0+(word/signed word/dword/signed dword) 511) ← *((const byte[512]) mulf_sqr1_hi#0+(word/signed word/dword/signed dword) 256)
  to:mulf_init::@return
mulf_init::@return: scope:[mulf_init]  from mulf_init::@8
  [334] return 
  to:@return
mulf_init::@12: scope:[mulf_init]  from mulf_init::@3
  [335] phi()
  to:mulf_init::@4
print_cls: scope:[print_cls]  from main
  [336] phi()
  to:print_cls::@1
print_cls::@1: scope:[print_cls]  from print_cls print_cls::@1
  [337] (byte*) print_cls::sc#2 ← phi( print_cls/((byte*))(word/signed word/dword/signed dword) 1024 print_cls::@1/(byte*) print_cls::sc#1 )
  [338] *((byte*) print_cls::sc#2) ← (byte) ' '
  [339] (byte*) print_cls::sc#1 ← ++ (byte*) print_cls::sc#2
  [340] if((byte*) print_cls::sc#1!=((byte*))(word/signed word/dword/signed dword) 1024+(word/signed word/dword/signed dword) 1000) goto print_cls::@1
  to:print_cls::@return
print_cls::@return: scope:[print_cls]  from print_cls::@1
  [341] return 
  to:@return
