@begin: scope:[]  from
  [0] phi()
  to:@1
@1: scope:[]  from @begin
  [1] phi()
  [2] call main 
  to:@end
@end: scope:[]  from @1
  [3] phi()

(void()) main()
main: scope:[main]  from @1
  [4] *((const byte*) BGCOL) ← (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

(void()) mul8s_compare()
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::@5
  [18] (signed byte) mul8s_compare::a#10 ← phi( mul8s_compare/(signed byte) -$80 mul8s_compare::@5/(signed byte) mul8s_compare::a#1 )
  [19] if((signed byte) mul8s_compare::a#10!=(signed byte) -$80) goto mul8s_compare::@3
  to:mul8s_compare::@2
mul8s_compare::@2: scope:[mul8s_compare]  from mul8s_compare::@1
  [20] (byte*) print_char_cursor#189 ← (byte*) print_line_cursor#1
  [21] call print_str 
  to:mul8s_compare::@11
mul8s_compare::@11: scope:[mul8s_compare]  from mul8s_compare::@2
  [22] phi()
  [23] call print_ln 
  to:mul8s_compare::@return
mul8s_compare::@return: scope:[mul8s_compare]  from mul8s_compare::@10 mul8s_compare::@11
  [24] return 
  to:@return
mul8s_compare::@3: scope:[mul8s_compare]  from mul8s_compare::@1 mul8s_compare::@8
  [25] (signed byte) mul8s_compare::b#10 ← phi( mul8s_compare::@1/(signed byte) -$80 mul8s_compare::@8/(signed byte) mul8s_compare::b#1 )
  [26] if((signed byte) mul8s_compare::b#10!=(signed byte) -$80) goto mul8s_compare::@4
  to:mul8s_compare::@5
mul8s_compare::@5: scope:[mul8s_compare]  from mul8s_compare::@3
  [27] (signed byte) mul8s_compare::a#1 ← ++ (signed byte) mul8s_compare::a#10
  to:mul8s_compare::@1
mul8s_compare::@4: scope:[mul8s_compare]  from mul8s_compare::@3
  [28] (signed byte) muls8s::a#0 ← (signed byte) mul8s_compare::a#10
  [29] (signed byte) muls8s::b#0 ← (signed byte) mul8s_compare::b#10
  [30] call muls8s 
  [31] (signed word) muls8s::return#2 ← (signed word) muls8s::return#0
  to:mul8s_compare::@12
mul8s_compare::@12: scope:[mul8s_compare]  from mul8s_compare::@4
  [32] (signed word) mul8s_compare::ms#0 ← (signed word) muls8s::return#2
  [33] (signed byte) mulf8s::a#0 ← (signed byte) mul8s_compare::a#10
  [34] (signed byte) mulf8s::b#0 ← (signed byte) mul8s_compare::b#10
  [35] call mulf8s 
  [36] (signed word) mulf8s::return#2 ← (signed word) mulf8s::return#0
  to:mul8s_compare::@13
mul8s_compare::@13: scope:[mul8s_compare]  from mul8s_compare::@12
  [37] (signed word) mul8s_compare::mf#0 ← (signed word) mulf8s::return#2
  [38] (signed byte) mul8s::a#0 ← (signed byte) mul8s_compare::a#10
  [39] (signed byte) mul8s::b#0 ← (signed byte) mul8s_compare::b#10
  [40] call mul8s 
  to:mul8s_compare::@14
mul8s_compare::@14: scope:[mul8s_compare]  from mul8s_compare::@13
  [41] (signed word) mul8s_compare::mn#0 ← (signed word)(word) mul8s::m#4
  [42] if((signed word) mul8s_compare::ms#0==(signed word) mul8s_compare::mf#0) goto mul8s_compare::@6
  to:mul8s_compare::@9
mul8s_compare::@9: scope:[mul8s_compare]  from mul8s_compare::@14
  [43] phi()
  to:mul8s_compare::@6
mul8s_compare::@6: scope:[mul8s_compare]  from mul8s_compare::@14 mul8s_compare::@9
  [44] (byte) mul8s_compare::ok#4 ← phi( mul8s_compare::@9/(byte) 0 mul8s_compare::@14/(byte) 1 )
  [45] if((signed word) mul8s_compare::ms#0==(signed word) mul8s_compare::mn#0) goto mul8s_compare::@15
  to:mul8s_compare::@7
mul8s_compare::@15: scope:[mul8s_compare]  from mul8s_compare::@6
  [46] phi()
  to:mul8s_compare::@7
mul8s_compare::@7: scope:[mul8s_compare]  from mul8s_compare::@15 mul8s_compare::@6
  [47] (byte) mul8s_compare::ok#3 ← phi( mul8s_compare::@6/(byte) 0 mul8s_compare::@15/(byte) mul8s_compare::ok#4 )
  [48] if((byte) mul8s_compare::ok#3!=(byte) 0) goto mul8s_compare::@8
  to:mul8s_compare::@10
mul8s_compare::@10: scope:[mul8s_compare]  from mul8s_compare::@7
  [49] *((const byte*) BGCOL) ← (byte) 2
  [50] (signed byte) mul8s_error::a#0 ← (signed byte) mul8s_compare::a#10
  [51] (signed byte) mul8s_error::b#0 ← (signed byte) mul8s_compare::b#10
  [52] (signed word) mul8s_error::ms#0 ← (signed word) mul8s_compare::ms#0
  [53] (signed word) mul8s_error::mn#0 ← (signed word) mul8s_compare::mn#0
  [54] (signed word) mul8s_error::mf#0 ← (signed word) mul8s_compare::mf#0
  [55] call mul8s_error 
  to:mul8s_compare::@return
mul8s_compare::@8: scope:[mul8s_compare]  from mul8s_compare::@7
  [56] (signed byte) mul8s_compare::b#1 ← ++ (signed byte) mul8s_compare::b#10
  to:mul8s_compare::@3

(void()) mul8s_error((signed byte) mul8s_error::a , (signed byte) mul8s_error::b , (signed word) mul8s_error::ms , (signed word) mul8s_error::mn , (signed word) mul8s_error::mf)
mul8s_error: scope:[mul8s_error]  from mul8s_compare::@10
  [57] (byte*) print_char_cursor#190 ← (byte*) print_line_cursor#1
  [58] call print_str 
  to:mul8s_error::@1
mul8s_error::@1: scope:[mul8s_error]  from mul8s_error
  [59] (signed byte) print_sbyte::b#1 ← (signed byte) mul8s_error::a#0
  [60] call print_sbyte 
  to:mul8s_error::@2
mul8s_error::@2: scope:[mul8s_error]  from mul8s_error::@1
  [61] phi()
  [62] call print_str 
  to:mul8s_error::@3
mul8s_error::@3: scope:[mul8s_error]  from mul8s_error::@2
  [63] (signed byte) print_sbyte::b#2 ← (signed byte) mul8s_error::b#0
  [64] call print_sbyte 
  to:mul8s_error::@4
mul8s_error::@4: scope:[mul8s_error]  from mul8s_error::@3
  [65] phi()
  [66] call print_str 
  to:mul8s_error::@5
mul8s_error::@5: scope:[mul8s_error]  from mul8s_error::@4
  [67] (signed word) print_sword::w#1 ← (signed word) mul8s_error::ms#0
  [68] call print_sword 
  to:mul8s_error::@6
mul8s_error::@6: scope:[mul8s_error]  from mul8s_error::@5
  [69] phi()
  [70] call print_str 
  to:mul8s_error::@7
mul8s_error::@7: scope:[mul8s_error]  from mul8s_error::@6
  [71] (signed word) print_sword::w#2 ← (signed word) mul8s_error::mn#0
  [72] call print_sword 
  to:mul8s_error::@8
mul8s_error::@8: scope:[mul8s_error]  from mul8s_error::@7
  [73] phi()
  [74] call print_str 
  to:mul8s_error::@9
mul8s_error::@9: scope:[mul8s_error]  from mul8s_error::@8
  [75] (signed word) print_sword::w#3 ← (signed word) mul8s_error::mf#0
  [76] call print_sword 
  to:mul8s_error::@10
mul8s_error::@10: scope:[mul8s_error]  from mul8s_error::@9
  [77] phi()
  [78] call print_ln 
  to:mul8s_error::@return
mul8s_error::@return: scope:[mul8s_error]  from mul8s_error::@10
  [79] return 
  to:@return

(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
  [80] (byte*) print_char_cursor#135 ← phi( mul8s_compare::@11/(byte*) print_char_cursor#134 mul8s_error::@10/(byte*) print_char_cursor#19 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 )
  [80] (byte*) print_line_cursor#45 ← phi( mul8s_compare::@11/(byte*) print_line_cursor#1 mul8s_error::@10/(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
  [81] (byte*) print_line_cursor#23 ← phi( print_ln/(byte*) print_line_cursor#45 print_ln::@1/(byte*) print_line_cursor#1 )
  [82] (byte*) print_line_cursor#1 ← (byte*) print_line_cursor#23 + (byte) $28
  [83] 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
  [84] return 
  to:@return

(void()) print_sword((signed word) print_sword::w)
print_sword: scope:[print_sword]  from mul8s_error::@5 mul8s_error::@7 mul8s_error::@9
  [85] (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 )
  [86] if((signed word) print_sword::w#4<(signed byte) 0) goto print_sword::@1
  to:print_sword::@3
print_sword::@3: scope:[print_sword]  from print_sword
  [87] phi()
  [88] call print_char 
  to:print_sword::@2
print_sword::@2: scope:[print_sword]  from print_sword::@3 print_sword::@4
  [89] (signed word) print_sword::w#6 ← phi( print_sword::@4/(signed word) print_sword::w#0 print_sword::@3/(signed word) print_sword::w#4 )
  [90] (word) print_word::w#0 ← (word)(signed word) print_sword::w#6
  [91] call print_word 
  to:print_sword::@return
print_sword::@return: scope:[print_sword]  from print_sword::@2
  [92] return 
  to:@return
print_sword::@1: scope:[print_sword]  from print_sword
  [93] phi()
  [94] call print_char 
  to:print_sword::@4
print_sword::@4: scope:[print_sword]  from print_sword::@1
  [95] (signed word) print_sword::w#0 ← - (signed word) print_sword::w#4
  to:print_sword::@2

(void()) print_char((byte) print_char::ch)
print_char: scope:[print_char]  from print_byte print_byte::@1 print_sbyte::@1 print_sbyte::@3 print_sword::@1 print_sword::@3
  [96] (byte*) print_char_cursor#86 ← phi( print_byte/(byte*) print_char_cursor#143 print_byte::@1/(byte*) print_char_cursor#19 print_sbyte::@1/(byte*) print_char_cursor#134 print_sbyte::@3/(byte*) print_char_cursor#134 print_sword::@1/(byte*) print_char_cursor#134 print_sword::@3/(byte*) print_char_cursor#134 )
  [96] (byte) print_char::ch#6 ← phi( print_byte/(byte) print_char::ch#4 print_byte::@1/(byte) print_char::ch#5 print_sbyte::@1/(byte) '-' print_sbyte::@3/(byte) ' ' print_sword::@1/(byte) '-' print_sword::@3/(byte) ' ' )
  [97] *((byte*) print_char_cursor#86) ← (byte) print_char::ch#6
  [98] (byte*) print_char_cursor#19 ← ++ (byte*) print_char_cursor#86
  to:print_char::@return
print_char::@return: scope:[print_char]  from print_char
  [99] return 
  to:@return

(void()) print_word((word) print_word::w)
print_word: scope:[print_word]  from mul8u_error::@5 mul8u_error::@7 mul8u_error::@9 mulf_tables_cmp::@10 mulf_tables_cmp::@8 print_sword::@2
  [100] (byte*) print_char_cursor#142 ← phi( mul8u_error::@5/(byte*) print_char_cursor#134 mul8u_error::@7/(byte*) print_char_cursor#134 mul8u_error::@9/(byte*) print_char_cursor#134 mulf_tables_cmp::@8/(byte*) print_char_cursor#134 mulf_tables_cmp::@10/(byte*) print_char_cursor#134 print_sword::@2/(byte*) print_char_cursor#19 )
  [100] (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 print_sword::@2/(word) print_word::w#0 )
  [101] (byte) print_byte::b#1 ← > (word) print_word::w#6
  [102] call print_byte 
  to:print_word::@1
print_word::@1: scope:[print_word]  from print_word
  [103] (byte) print_byte::b#2 ← < (word) print_word::w#6
  [104] call print_byte 
  to:print_word::@return
print_word::@return: scope:[print_word]  from print_word::@1
  [105] return 
  to:@return

(void()) print_byte((byte) print_byte::b)
print_byte: scope:[print_byte]  from mul8u_error::@1 mul8u_error::@3 print_sbyte::@2 print_word print_word::@1
  [106] (byte*) print_char_cursor#143 ← phi( mul8u_error::@1/(byte*) print_char_cursor#134 mul8u_error::@3/(byte*) print_char_cursor#134 print_sbyte::@2/(byte*) print_char_cursor#19 print_word/(byte*) print_char_cursor#142 print_word::@1/(byte*) print_char_cursor#19 )
  [106] (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#0 print_word/(byte) print_byte::b#1 print_word::@1/(byte) print_byte::b#2 )
  [107] (byte~) print_byte::$0 ← (byte) print_byte::b#5 >> (byte) 4
  [108] (byte) print_char::ch#4 ← *((const byte*) print_hextab + (byte~) print_byte::$0)
  [109] call print_char 
  to:print_byte::@1
print_byte::@1: scope:[print_byte]  from print_byte
  [110] (byte~) print_byte::$2 ← (byte) print_byte::b#5 & (byte) $f
  [111] (byte) print_char::ch#5 ← *((const byte*) print_hextab + (byte~) print_byte::$2)
  [112] call print_char 
  to:print_byte::@return
print_byte::@return: scope:[print_byte]  from print_byte::@1
  [113] return 
  to:@return

(void()) print_str((byte*) print_str::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
  [114] (byte*) print_char_cursor#155 ← phi( mul8s_compare::@2/(byte*) print_char_cursor#189 mul8s_error/(byte*) print_char_cursor#190 mul8s_error::@2/(byte*) print_char_cursor#19 mul8s_error::@4/(byte*) print_char_cursor#19 mul8s_error::@6/(byte*) print_char_cursor#19 mul8s_error::@8/(byte*) print_char_cursor#19 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 )
  [114] (byte*) print_str::str#18 ← phi( mul8s_compare::@2/(const byte*) mul8s_compare::str mul8s_error/(const byte*) mul8s_error::str mul8s_error::@2/(const byte*) str1 mul8s_error::@4/(const byte*) str2 mul8s_error::@6/(const byte*) str3 mul8s_error::@8/(const byte*) str4 mul8u_compare::@9/(const byte*) mul8u_compare::str mul8u_error/(const byte*) mul8u_error::str mul8u_error::@2/(const byte*) str1 mul8u_error::@4/(const byte*) str2 mul8u_error::@6/(const byte*) str3 mul8u_error::@8/(const byte*) str4 mulf_tables_cmp::@9/(const byte*) mulf_tables_cmp::str2 mulf_tables_cmp::@3/(const byte*) mulf_tables_cmp::str mulf_tables_cmp::@5/(const byte*) mulf_tables_cmp::str1 )
  to:print_str::@1
print_str::@1: scope:[print_str]  from print_str print_str::@2
  [115] (byte*) print_char_cursor#134 ← phi( print_str/(byte*) print_char_cursor#155 print_str::@2/(byte*) print_char_cursor#1 )
  [115] (byte*) print_str::str#16 ← phi( print_str/(byte*) print_str::str#18 print_str::@2/(byte*) print_str::str#0 )
  [116] 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
  [117] return 
  to:@return
print_str::@2: scope:[print_str]  from print_str::@1
  [118] *((byte*) print_char_cursor#134) ← *((byte*) print_str::str#16)
  [119] (byte*) print_char_cursor#1 ← ++ (byte*) print_char_cursor#134
  [120] (byte*) print_str::str#0 ← ++ (byte*) print_str::str#16
  to:print_str::@1

(void()) print_sbyte((signed byte) print_sbyte::b)
print_sbyte: scope:[print_sbyte]  from mul8s_error::@1 mul8s_error::@3
  [121] (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 )
  [122] if((signed byte) print_sbyte::b#3<(signed byte) 0) goto print_sbyte::@1
  to:print_sbyte::@3
print_sbyte::@3: scope:[print_sbyte]  from print_sbyte
  [123] phi()
  [124] call print_char 
  to:print_sbyte::@2
print_sbyte::@2: scope:[print_sbyte]  from print_sbyte::@3 print_sbyte::@4
  [125] (signed byte) print_sbyte::b#5 ← phi( print_sbyte::@4/(signed byte) print_sbyte::b#0 print_sbyte::@3/(signed byte) print_sbyte::b#3 )
  [126] (byte) print_byte::b#0 ← (byte)(signed byte) print_sbyte::b#5
  [127] call print_byte 
  to:print_sbyte::@return
print_sbyte::@return: scope:[print_sbyte]  from print_sbyte::@2
  [128] return 
  to:@return
print_sbyte::@1: scope:[print_sbyte]  from print_sbyte
  [129] phi()
  [130] call print_char 
  to:print_sbyte::@4
print_sbyte::@4: scope:[print_sbyte]  from print_sbyte::@1
  [131] (signed byte) print_sbyte::b#0 ← - (signed byte) print_sbyte::b#3
  to:print_sbyte::@2

(signed word()) mul8s((signed byte) mul8s::a , (signed byte) mul8s::b)
mul8s: scope:[mul8s]  from mul8s_compare::@13
  [132] (byte) mul8u::a#1 ← (byte)(signed byte) mul8s::a#0
  [133] (byte) mul8u::b#0 ← (byte)(signed byte) mul8s::b#0
  [134] call mul8u 
  [135] (word) mul8u::return#2 ← (word) mul8u::res#2
  to:mul8s::@5
mul8s::@5: scope:[mul8s]  from mul8s
  [136] (word) mul8s::m#0 ← (word) mul8u::return#2
  [137] if((signed byte) mul8s::a#0>=(signed byte) 0) goto mul8s::@1
  to:mul8s::@3
mul8s::@3: scope:[mul8s]  from mul8s::@5
  [138] (byte~) mul8s::$9 ← > (word) mul8s::m#0
  [139] (byte~) mul8s::$16 ← (byte~) mul8s::$9 - (byte)(signed byte) mul8s::b#0
  [140] (word) mul8s::m#1 ← (word) mul8s::m#0 hi= (byte~) mul8s::$16
  to:mul8s::@1
mul8s::@1: scope:[mul8s]  from mul8s::@3 mul8s::@5
  [141] (word) mul8s::m#5 ← phi( mul8s::@3/(word) mul8s::m#1 mul8s::@5/(word) mul8s::m#0 )
  [142] if((signed byte) mul8s::b#0>=(signed byte) 0) goto mul8s::@2
  to:mul8s::@4
mul8s::@4: scope:[mul8s]  from mul8s::@1
  [143] (byte~) mul8s::$13 ← > (word) mul8s::m#5
  [144] (byte~) mul8s::$17 ← (byte~) mul8s::$13 - (byte)(signed byte) mul8s::a#0
  [145] (word) mul8s::m#2 ← (word) mul8s::m#5 hi= (byte~) mul8s::$17
  to:mul8s::@2
mul8s::@2: scope:[mul8s]  from mul8s::@1 mul8s::@4
  [146] (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
  [147] return 
  to:@return

(word()) mul8u((byte) mul8u::a , (byte) mul8u::b)
mul8u: scope:[mul8u]  from mul8s mul8u_compare::@11
  [148] (byte) mul8u::a#6 ← phi( mul8s/(byte) mul8u::a#1 mul8u_compare::@11/(byte) mul8u::a#2 )
  [148] (byte) mul8u::b#2 ← phi( mul8s/(byte) mul8u::b#0 mul8u_compare::@11/(byte) mul8u::b#1 )
  [149] (word) mul8u::mb#0 ← (word)(byte) mul8u::b#2
  to:mul8u::@1
mul8u::@1: scope:[mul8u]  from mul8u mul8u::@3
  [150] (word) mul8u::mb#2 ← phi( mul8u/(word) mul8u::mb#0 mul8u::@3/(word) mul8u::mb#1 )
  [150] (word) mul8u::res#2 ← phi( mul8u/(word) 0 mul8u::@3/(word) mul8u::res#6 )
  [150] (byte) mul8u::a#3 ← phi( mul8u/(byte) mul8u::a#6 mul8u::@3/(byte) mul8u::a#0 )
  [151] if((byte) mul8u::a#3!=(byte) 0) goto mul8u::@2
  to:mul8u::@return
mul8u::@return: scope:[mul8u]  from mul8u::@1
  [152] return 
  to:@return
mul8u::@2: scope:[mul8u]  from mul8u::@1
  [153] (byte~) mul8u::$1 ← (byte) mul8u::a#3 & (byte) 1
  [154] if((byte~) mul8u::$1==(byte) 0) goto mul8u::@3
  to:mul8u::@4
mul8u::@4: scope:[mul8u]  from mul8u::@2
  [155] (word) mul8u::res#1 ← (word) mul8u::res#2 + (word) mul8u::mb#2
  to:mul8u::@3
mul8u::@3: scope:[mul8u]  from mul8u::@2 mul8u::@4
  [156] (word) mul8u::res#6 ← phi( mul8u::@2/(word) mul8u::res#2 mul8u::@4/(word) mul8u::res#1 )
  [157] (byte) mul8u::a#0 ← (byte) mul8u::a#3 >> (byte) 1
  [158] (word) mul8u::mb#1 ← (word) mul8u::mb#2 << (byte) 1
  to:mul8u::@1

(signed word()) mulf8s((signed byte) mulf8s::a , (signed byte) mulf8s::b)
mulf8s: scope:[mulf8s]  from mul8s_compare::@12
  [159] phi()
  to:mulf8s::mulf8s_prepare1
mulf8s::mulf8s_prepare1: scope:[mulf8s]  from mulf8s
  [160] (byte) mulf8u_prepare::a#1 ← (byte)(signed byte) mulf8s::a#0
  [161] call mulf8u_prepare 
  to:mulf8s::@1
mulf8s::@1: scope:[mulf8s]  from mulf8s::mulf8s_prepare1
  [162] (signed byte) mulf8s_prepared::b#0 ← (signed byte) mulf8s::b#0
  [163] call mulf8s_prepared 
  to:mulf8s::@2
mulf8s::@2: scope:[mulf8s]  from mulf8s::@1
  [164] (signed word) mulf8s::return#0 ← (signed word)(word) mulf8s_prepared::m#4
  to:mulf8s::@return
mulf8s::@return: scope:[mulf8s]  from mulf8s::@2
  [165] return 
  to:@return

(signed word()) mulf8s_prepared((signed byte) mulf8s_prepared::b)
mulf8s_prepared: scope:[mulf8s_prepared]  from mulf8s::@1
  [166] (byte) mulf8u_prepared::b#1 ← (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::@5
mulf8s_prepared::@5: 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)>=(signed byte) 0) goto mulf8s_prepared::@1
  to:mulf8s_prepared::@3
mulf8s_prepared::@3: scope:[mulf8s_prepared]  from mulf8s_prepared::@5
  [171] (byte~) mulf8s_prepared::$8 ← > (word) mulf8s_prepared::m#0
  [172] (byte~) mulf8s_prepared::$15 ← (byte~) mulf8s_prepared::$8 - (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::@5
  [174] (word) mulf8s_prepared::m#5 ← phi( mulf8s_prepared::@3/(word) mulf8s_prepared::m#1 mulf8s_prepared::@5/(word) mulf8s_prepared::m#0 )
  [175] if((signed byte) mulf8s_prepared::b#0>=(signed byte) 0) goto mulf8s_prepared::@2
  to:mulf8s_prepared::@4
mulf8s_prepared::@4: scope:[mulf8s_prepared]  from mulf8s_prepared::@1
  [176] (byte~) mulf8s_prepared::$12 ← > (word) mulf8s_prepared::m#5
  [177] (byte~) mulf8s_prepared::$16 ← (byte~) mulf8s_prepared::$12 - (byte)*((const signed byte*) mulf8s_prepared::memA)
  [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

(word()) mulf8u_prepared((byte) mulf8u_prepared::b)
mulf8u_prepared: scope:[mulf8u_prepared]  from mulf8s_prepared mulf8u::@1
  [181] (byte) mulf8u_prepared::b#2 ← phi( mulf8s_prepared/(byte) mulf8u_prepared::b#1 mulf8u::@1/(byte) mulf8u_prepared::b#0 )
  [182] *((const byte*) mulf8u_prepared::memB) ← (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) w= *((const byte*) mulf8u_prepared::resL)
  to:mulf8u_prepared::@return
mulf8u_prepared::@return: scope:[mulf8u_prepared]  from mulf8u_prepared
  [185] return 
  to:@return

(void()) mulf8u_prepare((byte) mulf8u_prepare::a)
mulf8u_prepare: scope:[mulf8u_prepare]  from mulf8s::mulf8s_prepare1 mulf8u
  [186] (byte) mulf8u_prepare::a#2 ← phi( mulf8s::mulf8s_prepare1/(byte) mulf8u_prepare::a#1 mulf8u/(byte) mulf8u_prepare::a#0 )
  [187] *((const byte*) mulf8u_prepare::memA) ← (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

(signed word()) muls8s((signed byte) muls8s::a , (signed byte) muls8s::b)
muls8s: scope:[muls8s]  from mul8s_compare::@4
  [190] if((signed byte) muls8s::a#0<(signed byte) 0) goto muls8s::@5
  to:muls8s::@2
muls8s::@2: scope:[muls8s]  from muls8s
  [191] if((signed byte) muls8s::a#0<=(signed byte) 0) goto muls8s::@1
  to:muls8s::@3
muls8s::@3: scope:[muls8s]  from muls8s::@2 muls8s::@4
  [192] (signed word) muls8s::m#3 ← phi( muls8s::@2/(signed word) 0 muls8s::@4/(signed word) muls8s::m#1 )
  [192] (signed byte) muls8s::j#2 ← phi( muls8s::@2/(signed byte) 0 muls8s::@4/(signed byte) muls8s::j#1 )
  [193] if((signed byte) muls8s::j#2!=(signed byte) muls8s::a#0) goto muls8s::@4
  to:muls8s::@1
muls8s::@1: scope:[muls8s]  from muls8s::@2 muls8s::@3 muls8s::@5
  [194] (signed word) muls8s::return#0 ← phi( muls8s::@5/(signed word) muls8s::m#5 muls8s::@2/(signed word) 0 muls8s::@3/(signed word) muls8s::m#3 )
  to:muls8s::@return
muls8s::@return: scope:[muls8s]  from muls8s::@1
  [195] return 
  to:@return
muls8s::@4: scope:[muls8s]  from muls8s::@3
  [196] (signed word) muls8s::m#1 ← (signed word) muls8s::m#3 + (signed byte) muls8s::b#0
  [197] (signed byte) muls8s::j#1 ← ++ (signed byte) muls8s::j#2
  to:muls8s::@3
muls8s::@5: scope:[muls8s]  from muls8s muls8s::@6
  [198] (signed word) muls8s::m#5 ← phi( muls8s/(signed word) 0 muls8s::@6/(signed word) muls8s::m#2 )
  [198] (signed byte) muls8s::i#2 ← phi( muls8s/(signed byte) 0 muls8s::@6/(signed byte) muls8s::i#1 )
  [199] if((signed byte) muls8s::i#2!=(signed byte) muls8s::a#0) goto muls8s::@6
  to:muls8s::@1
muls8s::@6: scope:[muls8s]  from muls8s::@5
  [200] (signed word) muls8s::m#2 ← (signed word) muls8s::m#5 - (signed byte) muls8s::b#0
  [201] (signed byte) muls8s::i#1 ← -- (signed byte) muls8s::i#2
  to:muls8s::@5

(void()) mul8u_compare()
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::@8
  [203] (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
  [204] (byte) mul8u_compare::b#10 ← phi( mul8u_compare::@1/(byte) 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::@10
mul8u_compare::@10: 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::@11
mul8u_compare::@11: scope:[mul8u_compare]  from mul8u_compare::@10
  [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::@12
mul8u_compare::@12: scope:[mul8u_compare]  from mul8u_compare::@11
  [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::@12
  [221] phi()
  to:mul8u_compare::@3
mul8u_compare::@3: scope:[mul8u_compare]  from mul8u_compare::@12 mul8u_compare::@6
  [222] (byte) mul8u_compare::ok#4 ← phi( mul8u_compare::@12/(byte) 1 mul8u_compare::@6/(byte) 0 )
  [223] 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
  [224] phi()
  to:mul8u_compare::@4
mul8u_compare::@4: scope:[mul8u_compare]  from mul8u_compare::@14 mul8u_compare::@3
  [225] (byte) mul8u_compare::ok#3 ← phi( mul8u_compare::@14/(byte) mul8u_compare::ok#4 mul8u_compare::@3/(byte) 0 )
  [226] 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
  [227] *((const byte*) BGCOL) ← (byte) 2
  [228] (byte) mul8u_error::a#0 ← (byte) mul8u_compare::a#7
  [229] (byte) mul8u_error::b#0 ← (byte) mul8u_compare::b#10
  [230] (word) mul8u_error::ms#0 ← (word) mul8u_compare::ms#0
  [231] (word) mul8u_error::mn#0 ← (word) mul8u_compare::mn#0
  [232] (word) mul8u_error::mf#0 ← (word) mul8u_compare::mf#0
  [233] call mul8u_error 
  to:mul8u_compare::@return
mul8u_compare::@return: scope:[mul8u_compare]  from mul8u_compare::@13 mul8u_compare::@7
  [234] return 
  to:@return
mul8u_compare::@5: scope:[mul8u_compare]  from mul8u_compare::@4
  [235] (byte) mul8u_compare::b#1 ← ++ (byte) mul8u_compare::b#10
  [236] 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
  [237] (byte) mul8u_compare::a#1 ← ++ (byte) mul8u_compare::a#7
  [238] 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
  [239] phi()
  [240] call print_str 
  to:mul8u_compare::@13
mul8u_compare::@13: scope:[mul8u_compare]  from mul8u_compare::@9
  [241] phi()
  [242] call print_ln 
  to:mul8u_compare::@return

(void()) mul8u_error((byte) mul8u_error::a , (byte) mul8u_error::b , (word) mul8u_error::ms , (word) mul8u_error::mn , (word) mul8u_error::mf)
mul8u_error: scope:[mul8u_error]  from mul8u_compare::@7
  [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

(word()) mulf8u((byte) mulf8u::a , (byte) mulf8u::b)
mulf8u: scope:[mulf8u]  from mul8u_compare::@10
  [266] (byte) mulf8u_prepare::a#0 ← (byte) mulf8u::a#0
  [267] call mulf8u_prepare 
  to:mulf8u::@1
mulf8u::@1: 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::@2
mulf8u::@2: scope:[mulf8u]  from mulf8u::@1
  [271] (word) mulf8u::return#0 ← (word) mulf8u_prepared::return#2
  to:mulf8u::@return
mulf8u::@return: scope:[mulf8u]  from mulf8u::@2
  [272] return 
  to:@return

(word()) muls8u((byte) muls8u::a , (byte) muls8u::b)
muls8u: scope:[muls8u]  from mul8u_compare::@2
  [273] if((byte) muls8u::a#0==(byte) 0) goto muls8u::@1
  to:muls8u::@2
muls8u::@2: scope:[muls8u]  from muls8u muls8u::@3
  [274] (word) muls8u::m#3 ← phi( muls8u/(word) 0 muls8u::@3/(word) muls8u::m#1 )
  [274] (byte) muls8u::i#2 ← phi( muls8u/(byte) 0 muls8u::@3/(byte) muls8u::i#1 )
  [275] if((byte) muls8u::i#2!=(byte) muls8u::a#0) goto muls8u::@3
  to:muls8u::@1
muls8u::@1: scope:[muls8u]  from muls8u muls8u::@2
  [276] (word) muls8u::return#0 ← phi( muls8u/(word) 0 muls8u::@2/(word) muls8u::m#3 )
  to:muls8u::@return
muls8u::@return: scope:[muls8u]  from muls8u::@1
  [277] return 
  to:@return
muls8u::@3: scope:[muls8u]  from muls8u::@2
  [278] (word) muls8u::m#1 ← (word) muls8u::m#3 + (byte) muls8u::b#0
  [279] (byte) muls8u::i#1 ← ++ (byte) muls8u::i#2
  to:muls8u::@2

(void()) mulf_tables_cmp()
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::@4
  [281] (byte*) mulf_tables_cmp::asm_sqr#2 ← phi( mulf_tables_cmp/(const byte*) mula_sqr1_lo mulf_tables_cmp::@4/(byte*) mulf_tables_cmp::asm_sqr#1 )
  [281] (byte*) mulf_tables_cmp::kc_sqr#2 ← phi( mulf_tables_cmp/(const byte*) mulf_sqr1_lo mulf_tables_cmp::@4/(byte*) mulf_tables_cmp::kc_sqr#1 )
  [282] if((byte*) mulf_tables_cmp::kc_sqr#2<(const byte*) mulf_sqr1_lo+(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
  [283] phi()
  [284] call print_str 
  to:mulf_tables_cmp::@6
mulf_tables_cmp::@6: scope:[mulf_tables_cmp]  from mulf_tables_cmp::@3
  [285] phi()
  [286] call print_ln 
  to:mulf_tables_cmp::@7
mulf_tables_cmp::@7: scope:[mulf_tables_cmp]  from mulf_tables_cmp::@6
  [287] (byte*) print_char_cursor#226 ← (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
  [288] (byte*) print_line_cursor#11 ← phi( mulf_tables_cmp::@7/(byte*) print_line_cursor#1 mulf_tables_cmp::@10/(byte*) 1024 )
  [288] (byte*) print_char_cursor#100 ← phi( mulf_tables_cmp::@7/(byte*) print_char_cursor#226 mulf_tables_cmp::@10/(byte*) print_char_cursor#19 )
  [289] return 
  to:@return
mulf_tables_cmp::@2: scope:[mulf_tables_cmp]  from mulf_tables_cmp::@1
  [290] 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
  [291] *((const byte*) BGCOL) ← (byte) 2
  [292] call print_str 
  to:mulf_tables_cmp::@8
mulf_tables_cmp::@8: scope:[mulf_tables_cmp]  from mulf_tables_cmp::@5
  [293] (word) print_word::w#1 ← (word)(byte*) mulf_tables_cmp::asm_sqr#2
  [294] call print_word 
  to:mulf_tables_cmp::@9
mulf_tables_cmp::@9: scope:[mulf_tables_cmp]  from mulf_tables_cmp::@8
  [295] phi()
  [296] call print_str 
  to:mulf_tables_cmp::@10
mulf_tables_cmp::@10: scope:[mulf_tables_cmp]  from mulf_tables_cmp::@9
  [297] (word) print_word::w#2 ← (word)(byte*) mulf_tables_cmp::kc_sqr#2
  [298] call print_word 
  to:mulf_tables_cmp::@return
mulf_tables_cmp::@4: scope:[mulf_tables_cmp]  from mulf_tables_cmp::@2
  [299] (byte*) mulf_tables_cmp::asm_sqr#1 ← ++ (byte*) mulf_tables_cmp::asm_sqr#2
  [300] (byte*) mulf_tables_cmp::kc_sqr#1 ← ++ (byte*) mulf_tables_cmp::kc_sqr#2
  to:mulf_tables_cmp::@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!-  }
  [302] *((const byte*) mulf_init_asm::mem) ← *((const byte*) mula_sqr1_lo)
  [303] *((const byte*) mulf_init_asm::mem) ← *((const byte*) mula_sqr1_hi)
  [304] *((const byte*) mulf_init_asm::mem) ← *((const byte*) mula_sqr2_lo)
  [305] *((const byte*) mulf_init_asm::mem) ← *((const byte*) mula_sqr2_hi)
  to:mulf_init_asm::@return
mulf_init_asm::@return: scope:[mulf_init_asm]  from mulf_init_asm
  [306] return 
  to:@return

(void()) mulf_init()
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::@3
  [308] (byte) mulf_init::x_2#3 ← phi( mulf_init/(byte) 0 mulf_init::@3/(byte) mulf_init::x_2#2 )
  [308] (byte*) mulf_init::sqr1_hi#2 ← phi( mulf_init/(const byte*) mulf_sqr1_hi+(byte) 1 mulf_init::@3/(byte*) mulf_init::sqr1_hi#1 )
  [308] (word) mulf_init::sqr#4 ← phi( mulf_init/(word) 0 mulf_init::@3/(word) mulf_init::sqr#1 )
  [308] (byte) mulf_init::c#2 ← phi( mulf_init/(byte) 0 mulf_init::@3/(byte) mulf_init::c#1 )
  [308] (byte*) mulf_init::sqr1_lo#2 ← phi( mulf_init/(const byte*) mulf_sqr1_lo+(byte) 1 mulf_init::@3/(byte*) mulf_init::sqr1_lo#1 )
  [309] if((byte*) mulf_init::sqr1_lo#2!=(const byte*) mulf_sqr1_lo+(word) $200) goto mulf_init::@2
  to:mulf_init::@5
mulf_init::@5: scope:[mulf_init]  from mulf_init::@1 mulf_init::@8
  [310] (byte) mulf_init::dir#2 ← phi( mulf_init::@8/(byte) mulf_init::dir#4 mulf_init::@1/(byte) $ff )
  [310] (byte*) mulf_init::sqr2_hi#2 ← phi( mulf_init::@8/(byte*) mulf_init::sqr2_hi#1 mulf_init::@1/(const byte*) mulf_sqr2_hi )
  [310] (byte) mulf_init::x_255#2 ← phi( mulf_init::@8/(byte) mulf_init::x_255#1 mulf_init::@1/(byte) -1 )
  [310] (byte*) mulf_init::sqr2_lo#2 ← phi( mulf_init::@8/(byte*) mulf_init::sqr2_lo#1 mulf_init::@1/(const byte*) mulf_sqr2_lo )
  [311] if((byte*) mulf_init::sqr2_lo#2!=(const byte*) mulf_sqr2_lo+(word) $1ff) goto mulf_init::@6
  to:mulf_init::@7
mulf_init::@7: scope:[mulf_init]  from mulf_init::@5
  [312] *((const byte*) mulf_sqr2_lo+(word) $1ff) ← *((const byte*) mulf_sqr1_lo+(word) $100)
  [313] *((const byte*) mulf_sqr2_hi+(word) $1ff) ← *((const byte*) mulf_sqr1_hi+(word) $100)
  to:mulf_init::@return
mulf_init::@return: scope:[mulf_init]  from mulf_init::@7
  [314] return 
  to:@return
mulf_init::@6: scope:[mulf_init]  from mulf_init::@5
  [315] *((byte*) mulf_init::sqr2_lo#2) ← *((const byte*) mulf_sqr1_lo + (byte) mulf_init::x_255#2)
  [316] *((byte*) mulf_init::sqr2_hi#2) ← *((const byte*) mulf_sqr1_hi + (byte) mulf_init::x_255#2)
  [317] (byte*) mulf_init::sqr2_hi#1 ← ++ (byte*) mulf_init::sqr2_hi#2
  [318] (byte) mulf_init::x_255#1 ← (byte) mulf_init::x_255#2 + (byte) mulf_init::dir#2
  [319] 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
  [320] phi()
  to:mulf_init::@8
mulf_init::@8: scope:[mulf_init]  from mulf_init::@6 mulf_init::@9
  [321] (byte) mulf_init::dir#4 ← phi( mulf_init::@9/(byte) mulf_init::dir#2 mulf_init::@6/(byte) 1 )
  [322] (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
  [323] (byte) mulf_init::c#1 ← ++ (byte) mulf_init::c#2
  [324] (byte~) mulf_init::$1 ← (byte) mulf_init::c#1 & (byte) 1
  [325] if((byte~) mulf_init::$1!=(byte) 0) goto mulf_init::@3
  to:mulf_init::@4
mulf_init::@4: scope:[mulf_init]  from mulf_init::@2
  [326] (byte) mulf_init::x_2#1 ← ++ (byte) mulf_init::x_2#3
  [327] (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
  [328] (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 )
  [328] (word) mulf_init::sqr#3 ← phi( mulf_init::@2/(word) mulf_init::sqr#4 mulf_init::@4/(word) mulf_init::sqr#2 )
  [329] (byte~) mulf_init::$4 ← < (word) mulf_init::sqr#3
  [330] *((byte*) mulf_init::sqr1_lo#2) ← (byte~) mulf_init::$4
  [331] (byte~) mulf_init::$5 ← > (word) mulf_init::sqr#3
  [332] *((byte*) mulf_init::sqr1_hi#2) ← (byte~) mulf_init::$5
  [333] (byte*) mulf_init::sqr1_hi#1 ← ++ (byte*) mulf_init::sqr1_hi#2
  [334] (word) mulf_init::sqr#1 ← (word) mulf_init::sqr#3 + (byte) mulf_init::x_2#2
  [335] (byte*) mulf_init::sqr1_lo#1 ← ++ (byte*) mulf_init::sqr1_lo#2
  to:mulf_init::@1

(void()) print_cls()
print_cls: scope:[print_cls]  from main
  [336] phi()
  [337] call memset 
  to:print_cls::@return
print_cls::@return: scope:[print_cls]  from print_cls
  [338] return 
  to:@return

(void*()) memset((void*) memset::str , (byte) memset::c , (word) memset::num)
memset: scope:[memset]  from print_cls
  [339] phi()
  to:memset::@1
memset::@1: scope:[memset]  from memset memset::@2
  [340] (byte*) memset::dst#2 ← phi( memset/(byte*)(const void*) memset::str#0 memset::@2/(byte*) memset::dst#1 )
  [341] if((byte*) memset::dst#2!=(const byte*) memset::end#0) goto memset::@2
  to:memset::@return
memset::@return: scope:[memset]  from memset::@1
  [342] return 
  to:@return
memset::@2: scope:[memset]  from memset::@1
  [343] *((byte*) memset::dst#2) ← (const byte) memset::c#0
  [344] (byte*) memset::dst#1 ← ++ (byte*) memset::dst#2
  to:memset::@1
