@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] phi()
  [5] call sin8s_gen 
  to:main::@2
main::@2: scope:[main]  from main
  [6] phi()
  [7] call sin16s_gen 
  to:main::@3
main::@3: scope:[main]  from main::@2
  [8] phi()
  [9] call print_cls 
  to:main::@1
main::@1: scope:[main]  from main::@3 main::@5
  [10] (byte*) print_char_cursor#42 ← phi( main::@3/(const byte*) print_line_cursor#0 main::@5/(byte*) print_char_cursor#19 )
  [10] (byte) main::i#2 ← phi( main::@3/(byte) 0 main::@5/(byte) main::i#1 )
  [11] (signed byte) main::sb#0 ← *((const signed byte*) main::sintabb + (byte) main::i#2)
  [12] (word~) main::$3 ← (word)(byte) main::i#2
  [13] (word~) main::$11 ← (word~) main::$3 << (byte) 1
  [14] (signed word*~) main::$4 ← (const signed word*) main::sintabw + (word~) main::$11
  [15] (signed word) main::sw#0 ← *((signed word*~) main::$4)
  [16] (byte~) main::$6 ← > (signed word) main::sw#0
  [17] (signed byte) main::sd#0 ← (signed byte) main::sb#0 - (signed byte)(byte~) main::$6
  [18] (signed byte) print_sbyte::b#1 ← (signed byte) main::sd#0
  [19] call print_sbyte 
  to:main::@4
main::@4: scope:[main]  from main::@1
  [20] phi()
  [21] call print_str 
  to:main::@5
main::@5: scope:[main]  from main::@4
  [22] (byte) main::i#1 ← ++ (byte) main::i#2
  [23] if((byte) main::i#1!=(byte) $c0) goto main::@1
  to:main::@return
main::@return: scope:[main]  from main::@5
  [24] return 
  to:@return

(void()) print_str((byte*) print_str::str)
print_str: scope:[print_str]  from main::@4
  [25] phi()
  to:print_str::@1
print_str::@1: scope:[print_str]  from print_str print_str::@2
  [26] (byte*) print_char_cursor#19 ← phi( print_str/(byte*) print_char_cursor#10 print_str::@2/(byte*) print_char_cursor#1 )
  [26] (byte*) print_str::str#2 ← phi( print_str/(const string) main::str print_str::@2/(byte*) print_str::str#0 )
  [27] if((byte) 0!=*((byte*) print_str::str#2)) goto print_str::@2
  to:print_str::@return
print_str::@return: scope:[print_str]  from print_str::@1
  [28] return 
  to:@return
print_str::@2: scope:[print_str]  from print_str::@1
  [29] *((byte*) print_char_cursor#19) ← *((byte*) print_str::str#2)
  [30] (byte*) print_char_cursor#1 ← ++ (byte*) print_char_cursor#19
  [31] (byte*) print_str::str#0 ← ++ (byte*) print_str::str#2
  to:print_str::@1

(void()) print_sbyte((signed byte) print_sbyte::b)
print_sbyte: scope:[print_sbyte]  from main::@1
  [32] if((signed byte) print_sbyte::b#1<(signed byte) 0) goto print_sbyte::@1
  to:print_sbyte::@3
print_sbyte::@3: scope:[print_sbyte]  from print_sbyte
  [33] phi()
  [34] call print_char 
  to:print_sbyte::@2
print_sbyte::@2: scope:[print_sbyte]  from print_sbyte::@3 print_sbyte::@4
  [35] (signed byte) print_sbyte::b#4 ← phi( print_sbyte::@4/(signed byte) print_sbyte::b#0 print_sbyte::@3/(signed byte) print_sbyte::b#1 )
  [36] (byte) print_byte::b#0 ← (byte)(signed byte) print_sbyte::b#4
  [37] call print_byte 
  to:print_sbyte::@return
print_sbyte::@return: scope:[print_sbyte]  from print_sbyte::@2
  [38] return 
  to:@return
print_sbyte::@1: scope:[print_sbyte]  from print_sbyte
  [39] phi()
  [40] call print_char 
  to:print_sbyte::@4
print_sbyte::@4: scope:[print_sbyte]  from print_sbyte::@1
  [41] (signed byte) print_sbyte::b#0 ← - (signed byte) print_sbyte::b#1
  to:print_sbyte::@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
  [42] (byte*) print_char_cursor#28 ← phi( print_byte/(byte*) print_char_cursor#10 print_byte::@1/(byte*) print_char_cursor#10 print_sbyte::@1/(byte*) print_char_cursor#42 print_sbyte::@3/(byte*) print_char_cursor#42 )
  [42] (byte) print_char::ch#4 ← phi( print_byte/(byte) print_char::ch#2 print_byte::@1/(byte) print_char::ch#3 print_sbyte::@1/(byte) '-' print_sbyte::@3/(byte) ' ' )
  [43] *((byte*) print_char_cursor#28) ← (byte) print_char::ch#4
  [44] (byte*) print_char_cursor#10 ← ++ (byte*) print_char_cursor#28
  to:print_char::@return
print_char::@return: scope:[print_char]  from print_char
  [45] return 
  to:@return

(void()) print_byte((byte) print_byte::b)
print_byte: scope:[print_byte]  from print_sbyte::@2
  [46] (byte~) print_byte::$0 ← (byte) print_byte::b#0 >> (byte) 4
  [47] (byte) print_char::ch#2 ← *((const byte*) print_hextab + (byte~) print_byte::$0)
  [48] call print_char 
  to:print_byte::@1
print_byte::@1: scope:[print_byte]  from print_byte
  [49] (byte~) print_byte::$2 ← (byte) print_byte::b#0 & (byte) $f
  [50] (byte) print_char::ch#3 ← *((const byte*) print_hextab + (byte~) print_byte::$2)
  [51] call print_char 
  to:print_byte::@return
print_byte::@return: scope:[print_byte]  from print_byte::@1
  [52] return 
  to:@return

(void()) print_cls()
print_cls: scope:[print_cls]  from main::@3
  [53] phi()
  [54] call memset 
  to:print_cls::@return
print_cls::@return: scope:[print_cls]  from print_cls
  [55] return 
  to:@return

(void*()) memset((void*) memset::str , (byte) memset::c , (word) memset::num)
memset: scope:[memset]  from print_cls
  [56] phi()
  to:memset::@1
memset::@1: scope:[memset]  from memset memset::@2
  [57] (byte*) memset::dst#2 ← phi( memset/(byte*)(const void*) memset::str#0 memset::@2/(byte*) memset::dst#1 )
  [58] if((byte*) memset::dst#2!=(const byte*) memset::end#0) goto memset::@2
  to:memset::@return
memset::@return: scope:[memset]  from memset::@1
  [59] return 
  to:@return
memset::@2: scope:[memset]  from memset::@1
  [60] *((byte*) memset::dst#2) ← (const byte) memset::c#0
  [61] (byte*) memset::dst#1 ← ++ (byte*) memset::dst#2
  to:memset::@1

(void()) sin16s_gen((signed word*) sin16s_gen::sintab , (word) sin16s_gen::wavelength)
sin16s_gen: scope:[sin16s_gen]  from main::@2
  [62] phi()
  [63] call div32u16u 
  [64] (dword) div32u16u::return#2 ← (dword) div32u16u::return#0
  to:sin16s_gen::@3
sin16s_gen::@3: scope:[sin16s_gen]  from sin16s_gen
  [65] (dword) sin16s_gen::step#0 ← (dword) div32u16u::return#2
  to:sin16s_gen::@1
sin16s_gen::@1: scope:[sin16s_gen]  from sin16s_gen::@3 sin16s_gen::@4
  [66] (signed word*) sin16s_gen::sintab#2 ← phi( sin16s_gen::@3/(const signed word*) main::sintabw sin16s_gen::@4/(signed word*) sin16s_gen::sintab#0 )
  [66] (dword) sin16s_gen::x#2 ← phi( sin16s_gen::@3/(dword) 0 sin16s_gen::@4/(dword) sin16s_gen::x#1 )
  [66] (word) sin16s_gen::i#2 ← phi( sin16s_gen::@3/(word) 0 sin16s_gen::@4/(word) sin16s_gen::i#1 )
  [67] if((word) sin16s_gen::i#2<(const word) main::wavelength) goto sin16s_gen::@2
  to:sin16s_gen::@return
sin16s_gen::@return: scope:[sin16s_gen]  from sin16s_gen::@1
  [68] return 
  to:@return
sin16s_gen::@2: scope:[sin16s_gen]  from sin16s_gen::@1
  [69] (dword) sin16s::x#0 ← (dword) sin16s_gen::x#2
  [70] call sin16s 
  [71] (signed word) sin16s::return#0 ← (signed word) sin16s::return#1
  to:sin16s_gen::@4
sin16s_gen::@4: scope:[sin16s_gen]  from sin16s_gen::@2
  [72] (signed word~) sin16s_gen::$2 ← (signed word) sin16s::return#0
  [73] *((signed word*) sin16s_gen::sintab#2) ← (signed word~) sin16s_gen::$2
  [74] (signed word*) sin16s_gen::sintab#0 ← (signed word*) sin16s_gen::sintab#2 + (const byte) SIZEOF_SIGNED_WORD
  [75] (dword) sin16s_gen::x#1 ← (dword) sin16s_gen::x#2 + (dword) sin16s_gen::step#0
  [76] (word) sin16s_gen::i#1 ← ++ (word) sin16s_gen::i#2
  to:sin16s_gen::@1

(signed word()) sin16s((dword) sin16s::x)
sin16s: scope:[sin16s]  from sin16s_gen::@2
  [77] if((dword) sin16s::x#0<(const dword) PI_u4f28) goto sin16s::@1
  to:sin16s::@4
sin16s::@4: scope:[sin16s]  from sin16s
  [78] (dword) sin16s::x#1 ← (dword) sin16s::x#0 - (const dword) PI_u4f28
  to:sin16s::@1
sin16s::@1: scope:[sin16s]  from sin16s sin16s::@4
  [79] (byte) sin16s::isUpper#2 ← phi( sin16s/(byte) 0 sin16s::@4/(byte) 1 )
  [79] (dword) sin16s::x#4 ← phi( sin16s/(dword) sin16s::x#0 sin16s::@4/(dword) sin16s::x#1 )
  [80] if((dword) sin16s::x#4<(const dword) PI_HALF_u4f28) goto sin16s::@2
  to:sin16s::@5
sin16s::@5: scope:[sin16s]  from sin16s::@1
  [81] (dword) sin16s::x#2 ← (const dword) PI_u4f28 - (dword) sin16s::x#4
  to:sin16s::@2
sin16s::@2: scope:[sin16s]  from sin16s::@1 sin16s::@5
  [82] (dword) sin16s::x#6 ← phi( sin16s::@1/(dword) sin16s::x#4 sin16s::@5/(dword) sin16s::x#2 )
  [83] (dword~) sin16s::$4 ← (dword) sin16s::x#6 << (byte) 3
  [84] (word) sin16s::x1#0 ← > (dword~) sin16s::$4
  [85] (word) mulu16_sel::v1#0 ← (word) sin16s::x1#0
  [86] (word) mulu16_sel::v2#0 ← (word) sin16s::x1#0
  [87] call mulu16_sel 
  [88] (word) mulu16_sel::return#0 ← (word) mulu16_sel::return#12
  to:sin16s::@7
sin16s::@7: scope:[sin16s]  from sin16s::@2
  [89] (word) sin16s::x2#0 ← (word) mulu16_sel::return#0
  [90] (word) mulu16_sel::v1#1 ← (word) sin16s::x2#0
  [91] (word) mulu16_sel::v2#1 ← (word) sin16s::x1#0
  [92] call mulu16_sel 
  [93] (word) mulu16_sel::return#1 ← (word) mulu16_sel::return#12
  to:sin16s::@8
sin16s::@8: scope:[sin16s]  from sin16s::@7
  [94] (word) sin16s::x3#0 ← (word) mulu16_sel::return#1
  [95] (word) mulu16_sel::v1#2 ← (word) sin16s::x3#0
  [96] call mulu16_sel 
  [97] (word) mulu16_sel::return#2 ← (word) mulu16_sel::return#12
  to:sin16s::@9
sin16s::@9: scope:[sin16s]  from sin16s::@8
  [98] (word) sin16s::x3_6#0 ← (word) mulu16_sel::return#2
  [99] (word) sin16s::usinx#0 ← (word) sin16s::x1#0 - (word) sin16s::x3_6#0
  [100] (word) mulu16_sel::v1#3 ← (word) sin16s::x3#0
  [101] (word) mulu16_sel::v2#3 ← (word) sin16s::x1#0
  [102] call mulu16_sel 
  [103] (word) mulu16_sel::return#10 ← (word) mulu16_sel::return#12
  to:sin16s::@10
sin16s::@10: scope:[sin16s]  from sin16s::@9
  [104] (word) sin16s::x4#0 ← (word) mulu16_sel::return#10
  [105] (word) mulu16_sel::v1#4 ← (word) sin16s::x4#0
  [106] (word) mulu16_sel::v2#4 ← (word) sin16s::x1#0
  [107] call mulu16_sel 
  [108] (word) mulu16_sel::return#11 ← (word) mulu16_sel::return#12
  to:sin16s::@11
sin16s::@11: scope:[sin16s]  from sin16s::@10
  [109] (word) sin16s::x5#0 ← (word) mulu16_sel::return#11
  [110] (word) sin16s::x5_128#0 ← (word) sin16s::x5#0 >> (byte) 4
  [111] (word) sin16s::usinx#1 ← (word) sin16s::usinx#0 + (word) sin16s::x5_128#0
  [112] if((byte) sin16s::isUpper#2==(byte) 0) goto sin16s::@12
  to:sin16s::@6
sin16s::@6: scope:[sin16s]  from sin16s::@11
  [113] (signed word) sin16s::sinx#1 ← - (signed word)(word) sin16s::usinx#1
  to:sin16s::@3
sin16s::@3: scope:[sin16s]  from sin16s::@12 sin16s::@6
  [114] (signed word) sin16s::return#1 ← phi( sin16s::@12/(signed word) sin16s::return#5 sin16s::@6/(signed word) sin16s::sinx#1 )
  to:sin16s::@return
sin16s::@return: scope:[sin16s]  from sin16s::@3
  [115] return 
  to:@return
sin16s::@12: scope:[sin16s]  from sin16s::@11
  [116] (signed word) sin16s::return#5 ← (signed word)(word) sin16s::usinx#1
  to:sin16s::@3

(word()) mulu16_sel((word) mulu16_sel::v1 , (word) mulu16_sel::v2 , (byte) mulu16_sel::select)
mulu16_sel: scope:[mulu16_sel]  from sin16s::@10 sin16s::@2 sin16s::@7 sin16s::@8 sin16s::@9
  [117] (byte) mulu16_sel::select#5 ← phi( sin16s::@9/(byte) 0 sin16s::@10/(byte) 0 sin16s::@2/(byte) 0 sin16s::@7/(byte) 1 sin16s::@8/(byte) 1 )
  [117] (word) mulu16_sel::v2#5 ← phi( sin16s::@9/(word) mulu16_sel::v2#3 sin16s::@10/(word) mulu16_sel::v2#4 sin16s::@2/(word) mulu16_sel::v2#0 sin16s::@7/(word) mulu16_sel::v2#1 sin16s::@8/(word)(number) $10000/(number) 6 )
  [117] (word) mulu16_sel::v1#5 ← phi( sin16s::@9/(word) mulu16_sel::v1#3 sin16s::@10/(word) mulu16_sel::v1#4 sin16s::@2/(word) mulu16_sel::v1#0 sin16s::@7/(word) mulu16_sel::v1#1 sin16s::@8/(word) mulu16_sel::v1#2 )
  [118] (word) mul16u::a#1 ← (word) mulu16_sel::v1#5
  [119] (word) mul16u::b#0 ← (word) mulu16_sel::v2#5
  [120] call mul16u 
  [121] (dword) mul16u::return#2 ← (dword) mul16u::res#2
  to:mulu16_sel::@1
mulu16_sel::@1: scope:[mulu16_sel]  from mulu16_sel
  [122] (dword~) mulu16_sel::$0 ← (dword) mul16u::return#2
  [123] (dword~) mulu16_sel::$1 ← (dword~) mulu16_sel::$0 << (byte) mulu16_sel::select#5
  [124] (word) mulu16_sel::return#12 ← > (dword~) mulu16_sel::$1
  to:mulu16_sel::@return
mulu16_sel::@return: scope:[mulu16_sel]  from mulu16_sel::@1
  [125] return 
  to:@return

(dword()) mul16u((word) mul16u::a , (word) mul16u::b)
mul16u: scope:[mul16u]  from mulu16_sel
  [126] (dword) mul16u::mb#0 ← (dword)(word) mul16u::b#0
  to:mul16u::@1
mul16u::@1: scope:[mul16u]  from mul16u mul16u::@3
  [127] (dword) mul16u::mb#2 ← phi( mul16u/(dword) mul16u::mb#0 mul16u::@3/(dword) mul16u::mb#1 )
  [127] (dword) mul16u::res#2 ← phi( mul16u/(dword) 0 mul16u::@3/(dword) mul16u::res#6 )
  [127] (word) mul16u::a#2 ← phi( mul16u/(word) mul16u::a#1 mul16u::@3/(word) mul16u::a#0 )
  [128] if((word) mul16u::a#2!=(byte) 0) goto mul16u::@2
  to:mul16u::@return
mul16u::@return: scope:[mul16u]  from mul16u::@1
  [129] return 
  to:@return
mul16u::@2: scope:[mul16u]  from mul16u::@1
  [130] (byte~) mul16u::$1 ← (word) mul16u::a#2 & (byte) 1
  [131] if((byte~) mul16u::$1==(byte) 0) goto mul16u::@3
  to:mul16u::@4
mul16u::@4: scope:[mul16u]  from mul16u::@2
  [132] (dword) mul16u::res#1 ← (dword) mul16u::res#2 + (dword) mul16u::mb#2
  to:mul16u::@3
mul16u::@3: scope:[mul16u]  from mul16u::@2 mul16u::@4
  [133] (dword) mul16u::res#6 ← phi( mul16u::@2/(dword) mul16u::res#2 mul16u::@4/(dword) mul16u::res#1 )
  [134] (word) mul16u::a#0 ← (word) mul16u::a#2 >> (byte) 1
  [135] (dword) mul16u::mb#1 ← (dword) mul16u::mb#2 << (byte) 1
  to:mul16u::@1

(dword()) div32u16u((dword) div32u16u::dividend , (word) div32u16u::divisor)
div32u16u: scope:[div32u16u]  from sin16s_gen
  [136] phi()
  [137] call divr16u 
  [138] (word) divr16u::return#3 ← (word) divr16u::return#0
  to:div32u16u::@1
div32u16u::@1: scope:[div32u16u]  from div32u16u
  [139] (word) div32u16u::quotient_hi#0 ← (word) divr16u::return#3
  [140] (word) divr16u::rem#5 ← (word) rem16u#1
  [141] call divr16u 
  [142] (word) divr16u::return#4 ← (word) divr16u::return#0
  to:div32u16u::@2
div32u16u::@2: scope:[div32u16u]  from div32u16u::@1
  [143] (word) div32u16u::quotient_lo#0 ← (word) divr16u::return#4
  [144] (dword) div32u16u::return#0 ← (word) div32u16u::quotient_hi#0 dw= (word) div32u16u::quotient_lo#0
  to:div32u16u::@return
div32u16u::@return: scope:[div32u16u]  from div32u16u::@2
  [145] return 
  to:@return

(word()) divr16u((word) divr16u::dividend , (word) divr16u::divisor , (word) divr16u::rem)
divr16u: scope:[divr16u]  from div16u div32u16u div32u16u::@1
  [146] (word) divr16u::dividend#6 ← phi( div16u/(const word) PI2_u4f12 div32u16u/>(const dword) PI2_u4f28 div32u16u::@1/<(const dword) PI2_u4f28 )
  [146] (word) divr16u::rem#11 ← phi( div16u/(byte) 0 div32u16u/(byte) 0 div32u16u::@1/(word) divr16u::rem#5 )
  to:divr16u::@1
divr16u::@1: scope:[divr16u]  from divr16u divr16u::@3
  [147] (byte) divr16u::i#2 ← phi( divr16u/(byte) 0 divr16u::@3/(byte) divr16u::i#1 )
  [147] (word) divr16u::quotient#3 ← phi( divr16u/(word) 0 divr16u::@3/(word) divr16u::return#0 )
  [147] (word) divr16u::dividend#4 ← phi( divr16u/(word) divr16u::dividend#6 divr16u::@3/(word) divr16u::dividend#0 )
  [147] (word) divr16u::rem#6 ← phi( divr16u/(word) divr16u::rem#11 divr16u::@3/(word) divr16u::rem#10 )
  [148] (word) divr16u::rem#0 ← (word) divr16u::rem#6 << (byte) 1
  [149] (byte~) divr16u::$1 ← > (word) divr16u::dividend#4
  [150] (byte~) divr16u::$2 ← (byte~) divr16u::$1 & (byte) $80
  [151] if((byte~) divr16u::$2==(byte) 0) goto divr16u::@2
  to:divr16u::@4
divr16u::@4: scope:[divr16u]  from divr16u::@1
  [152] (word) divr16u::rem#1 ← (word) divr16u::rem#0 | (byte) 1
  to:divr16u::@2
divr16u::@2: scope:[divr16u]  from divr16u::@1 divr16u::@4
  [153] (word) divr16u::rem#7 ← phi( divr16u::@1/(word) divr16u::rem#0 divr16u::@4/(word) divr16u::rem#1 )
  [154] (word) divr16u::dividend#0 ← (word) divr16u::dividend#4 << (byte) 1
  [155] (word) divr16u::quotient#1 ← (word) divr16u::quotient#3 << (byte) 1
  [156] if((word) divr16u::rem#7<(const word) main::wavelength) goto divr16u::@3
  to:divr16u::@5
divr16u::@5: scope:[divr16u]  from divr16u::@2
  [157] (word) divr16u::quotient#2 ← ++ (word) divr16u::quotient#1
  [158] (word) divr16u::rem#2 ← (word) divr16u::rem#7 - (const word) main::wavelength
  to:divr16u::@3
divr16u::@3: scope:[divr16u]  from divr16u::@2 divr16u::@5
  [159] (word) divr16u::return#0 ← phi( divr16u::@2/(word) divr16u::quotient#1 divr16u::@5/(word) divr16u::quotient#2 )
  [159] (word) divr16u::rem#10 ← phi( divr16u::@2/(word) divr16u::rem#7 divr16u::@5/(word) divr16u::rem#2 )
  [160] (byte) divr16u::i#1 ← ++ (byte) divr16u::i#2
  [161] if((byte) divr16u::i#1!=(byte) $10) goto divr16u::@1
  to:divr16u::@6
divr16u::@6: scope:[divr16u]  from divr16u::@3
  [162] (word) rem16u#1 ← (word) divr16u::rem#10
  to:divr16u::@return
divr16u::@return: scope:[divr16u]  from divr16u::@6
  [163] return 
  to:@return

(void()) sin8s_gen((signed byte*) sin8s_gen::sintab , (word) sin8s_gen::wavelength)
sin8s_gen: scope:[sin8s_gen]  from main
  [164] phi()
  [165] call div16u 
  [166] (word) div16u::return#2 ← (word) div16u::return#0
  to:sin8s_gen::@3
sin8s_gen::@3: scope:[sin8s_gen]  from sin8s_gen
  [167] (word) sin8s_gen::step#0 ← (word) div16u::return#2
  to:sin8s_gen::@1
sin8s_gen::@1: scope:[sin8s_gen]  from sin8s_gen::@3 sin8s_gen::@4
  [168] (signed byte*) sin8s_gen::sintab#2 ← phi( sin8s_gen::@3/(const signed byte*) main::sintabb sin8s_gen::@4/(signed byte*) sin8s_gen::sintab#0 )
  [168] (word) sin8s_gen::x#2 ← phi( sin8s_gen::@3/(word) 0 sin8s_gen::@4/(word) sin8s_gen::x#1 )
  [168] (word) sin8s_gen::i#2 ← phi( sin8s_gen::@3/(word) 0 sin8s_gen::@4/(word) sin8s_gen::i#1 )
  [169] if((word) sin8s_gen::i#2<(const word) main::wavelength) goto sin8s_gen::@2
  to:sin8s_gen::@return
sin8s_gen::@return: scope:[sin8s_gen]  from sin8s_gen::@1
  [170] return 
  to:@return
sin8s_gen::@2: scope:[sin8s_gen]  from sin8s_gen::@1
  [171] (word) sin8s::x#0 ← (word) sin8s_gen::x#2
  [172] call sin8s 
  [173] (signed byte) sin8s::return#0 ← (signed byte) sin8s::return#1
  to:sin8s_gen::@4
sin8s_gen::@4: scope:[sin8s_gen]  from sin8s_gen::@2
  [174] (signed byte~) sin8s_gen::$2 ← (signed byte) sin8s::return#0
  [175] *((signed byte*) sin8s_gen::sintab#2) ← (signed byte~) sin8s_gen::$2
  [176] (signed byte*) sin8s_gen::sintab#0 ← ++ (signed byte*) sin8s_gen::sintab#2
  [177] (word) sin8s_gen::x#1 ← (word) sin8s_gen::x#2 + (word) sin8s_gen::step#0
  [178] (word) sin8s_gen::i#1 ← ++ (word) sin8s_gen::i#2
  to:sin8s_gen::@1

(signed byte()) sin8s((word) sin8s::x)
sin8s: scope:[sin8s]  from sin8s_gen::@2
  [179] if((word) sin8s::x#0<(const word) PI_u4f12) goto sin8s::@1
  to:sin8s::@5
sin8s::@5: scope:[sin8s]  from sin8s
  [180] (word) sin8s::x#1 ← (word) sin8s::x#0 - (const word) PI_u4f12
  to:sin8s::@1
sin8s::@1: scope:[sin8s]  from sin8s sin8s::@5
  [181] (byte) sin8s::isUpper#10 ← phi( sin8s/(byte) 0 sin8s::@5/(byte) 1 )
  [181] (word) sin8s::x#4 ← phi( sin8s/(word) sin8s::x#0 sin8s::@5/(word) sin8s::x#1 )
  [182] if((word) sin8s::x#4<(const word) PI_HALF_u4f12) goto sin8s::@2
  to:sin8s::@6
sin8s::@6: scope:[sin8s]  from sin8s::@1
  [183] (word) sin8s::x#2 ← (const word) PI_u4f12 - (word) sin8s::x#4
  to:sin8s::@2
sin8s::@2: scope:[sin8s]  from sin8s::@1 sin8s::@6
  [184] (word) sin8s::x#6 ← phi( sin8s::@1/(word) sin8s::x#4 sin8s::@6/(word) sin8s::x#2 )
  [185] (word~) sin8s::$4 ← (word) sin8s::x#6 << (byte) 3
  [186] (byte) sin8s::x1#0 ← > (word~) sin8s::$4
  [187] (byte) mulu8_sel::v1#0 ← (byte) sin8s::x1#0
  [188] (byte) mulu8_sel::v2#0 ← (byte) sin8s::x1#0
  [189] call mulu8_sel 
  [190] (byte) mulu8_sel::return#0 ← (byte) mulu8_sel::return#12
  to:sin8s::@9
sin8s::@9: scope:[sin8s]  from sin8s::@2
  [191] (byte) sin8s::x2#0 ← (byte) mulu8_sel::return#0
  [192] (byte) mulu8_sel::v1#1 ← (byte) sin8s::x2#0
  [193] (byte) mulu8_sel::v2#1 ← (byte) sin8s::x1#0
  [194] call mulu8_sel 
  [195] (byte) mulu8_sel::return#1 ← (byte) mulu8_sel::return#12
  to:sin8s::@10
sin8s::@10: scope:[sin8s]  from sin8s::@9
  [196] (byte) sin8s::x3#0 ← (byte) mulu8_sel::return#1
  [197] (byte) mulu8_sel::v1#2 ← (byte) sin8s::x3#0
  [198] call mulu8_sel 
  [199] (byte) mulu8_sel::return#2 ← (byte) mulu8_sel::return#12
  to:sin8s::@11
sin8s::@11: scope:[sin8s]  from sin8s::@10
  [200] (byte) sin8s::x3_6#0 ← (byte) mulu8_sel::return#2
  [201] (byte) sin8s::usinx#0 ← (byte) sin8s::x1#0 - (byte) sin8s::x3_6#0
  [202] (byte) mulu8_sel::v1#3 ← (byte) sin8s::x3#0
  [203] (byte) mulu8_sel::v2#3 ← (byte) sin8s::x1#0
  [204] call mulu8_sel 
  [205] (byte) mulu8_sel::return#10 ← (byte) mulu8_sel::return#12
  to:sin8s::@12
sin8s::@12: scope:[sin8s]  from sin8s::@11
  [206] (byte) sin8s::x4#0 ← (byte) mulu8_sel::return#10
  [207] (byte) mulu8_sel::v1#4 ← (byte) sin8s::x4#0
  [208] (byte) mulu8_sel::v2#4 ← (byte) sin8s::x1#0
  [209] call mulu8_sel 
  [210] (byte) mulu8_sel::return#11 ← (byte) mulu8_sel::return#12
  to:sin8s::@13
sin8s::@13: scope:[sin8s]  from sin8s::@12
  [211] (byte) sin8s::x5#0 ← (byte) mulu8_sel::return#11
  [212] (byte) sin8s::x5_128#0 ← (byte) sin8s::x5#0 >> (byte) 4
  [213] (byte) sin8s::usinx#1 ← (byte) sin8s::usinx#0 + (byte) sin8s::x5_128#0
  [214] if((byte) sin8s::usinx#1<(byte) $80) goto sin8s::@3
  to:sin8s::@7
sin8s::@7: scope:[sin8s]  from sin8s::@13
  [215] (byte) sin8s::usinx#2 ← -- (byte) sin8s::usinx#1
  to:sin8s::@3
sin8s::@3: scope:[sin8s]  from sin8s::@13 sin8s::@7
  [216] (byte) sin8s::usinx#4 ← phi( sin8s::@13/(byte) sin8s::usinx#1 sin8s::@7/(byte) sin8s::usinx#2 )
  [217] if((byte) sin8s::isUpper#10==(byte) 0) goto sin8s::@14
  to:sin8s::@8
sin8s::@8: scope:[sin8s]  from sin8s::@3
  [218] (signed byte) sin8s::sinx#1 ← - (signed byte)(byte) sin8s::usinx#4
  to:sin8s::@4
sin8s::@4: scope:[sin8s]  from sin8s::@14 sin8s::@8
  [219] (signed byte) sin8s::return#1 ← phi( sin8s::@14/(signed byte) sin8s::return#5 sin8s::@8/(signed byte) sin8s::sinx#1 )
  to:sin8s::@return
sin8s::@return: scope:[sin8s]  from sin8s::@4
  [220] return 
  to:@return
sin8s::@14: scope:[sin8s]  from sin8s::@3
  [221] (signed byte) sin8s::return#5 ← (signed byte)(byte) sin8s::usinx#4
  to:sin8s::@4

(byte()) mulu8_sel((byte) mulu8_sel::v1 , (byte) mulu8_sel::v2 , (byte) mulu8_sel::select)
mulu8_sel: scope:[mulu8_sel]  from sin8s::@10 sin8s::@11 sin8s::@12 sin8s::@2 sin8s::@9
  [222] (byte) mulu8_sel::select#5 ← phi( sin8s::@9/(byte) 1 sin8s::@10/(byte) 1 sin8s::@11/(byte) 0 sin8s::@12/(byte) 0 sin8s::@2/(byte) 0 )
  [222] (byte) mulu8_sel::v2#5 ← phi( sin8s::@9/(byte) mulu8_sel::v2#1 sin8s::@10/(const byte) sin8s::DIV_6 sin8s::@11/(byte) mulu8_sel::v2#3 sin8s::@12/(byte) mulu8_sel::v2#4 sin8s::@2/(byte) mulu8_sel::v2#0 )
  [222] (byte) mulu8_sel::v1#5 ← phi( sin8s::@9/(byte) mulu8_sel::v1#1 sin8s::@10/(byte) mulu8_sel::v1#2 sin8s::@11/(byte) mulu8_sel::v1#3 sin8s::@12/(byte) mulu8_sel::v1#4 sin8s::@2/(byte) mulu8_sel::v1#0 )
  [223] (byte) mul8u::a#1 ← (byte) mulu8_sel::v1#5
  [224] (byte) mul8u::b#0 ← (byte) mulu8_sel::v2#5
  [225] call mul8u 
  [226] (word) mul8u::return#2 ← (word) mul8u::res#2
  to:mulu8_sel::@1
mulu8_sel::@1: scope:[mulu8_sel]  from mulu8_sel
  [227] (word~) mulu8_sel::$0 ← (word) mul8u::return#2
  [228] (word~) mulu8_sel::$1 ← (word~) mulu8_sel::$0 << (byte) mulu8_sel::select#5
  [229] (byte) mulu8_sel::return#12 ← > (word~) mulu8_sel::$1
  to:mulu8_sel::@return
mulu8_sel::@return: scope:[mulu8_sel]  from mulu8_sel::@1
  [230] return 
  to:@return

(word()) mul8u((byte) mul8u::a , (byte) mul8u::b)
mul8u: scope:[mul8u]  from mulu8_sel
  [231] (word) mul8u::mb#0 ← (word)(byte) mul8u::b#0
  to:mul8u::@1
mul8u::@1: scope:[mul8u]  from mul8u mul8u::@3
  [232] (word) mul8u::mb#2 ← phi( mul8u/(word) mul8u::mb#0 mul8u::@3/(word) mul8u::mb#1 )
  [232] (word) mul8u::res#2 ← phi( mul8u/(word) 0 mul8u::@3/(word) mul8u::res#6 )
  [232] (byte) mul8u::a#2 ← phi( mul8u/(byte) mul8u::a#1 mul8u::@3/(byte) mul8u::a#0 )
  [233] if((byte) mul8u::a#2!=(byte) 0) goto mul8u::@2
  to:mul8u::@return
mul8u::@return: scope:[mul8u]  from mul8u::@1
  [234] return 
  to:@return
mul8u::@2: scope:[mul8u]  from mul8u::@1
  [235] (byte~) mul8u::$1 ← (byte) mul8u::a#2 & (byte) 1
  [236] if((byte~) mul8u::$1==(byte) 0) goto mul8u::@3
  to:mul8u::@4
mul8u::@4: scope:[mul8u]  from mul8u::@2
  [237] (word) mul8u::res#1 ← (word) mul8u::res#2 + (word) mul8u::mb#2
  to:mul8u::@3
mul8u::@3: scope:[mul8u]  from mul8u::@2 mul8u::@4
  [238] (word) mul8u::res#6 ← phi( mul8u::@2/(word) mul8u::res#2 mul8u::@4/(word) mul8u::res#1 )
  [239] (byte) mul8u::a#0 ← (byte) mul8u::a#2 >> (byte) 1
  [240] (word) mul8u::mb#1 ← (word) mul8u::mb#2 << (byte) 1
  to:mul8u::@1

(word()) div16u((word) div16u::dividend , (word) div16u::divisor)
div16u: scope:[div16u]  from sin8s_gen
  [241] phi()
  [242] call divr16u 
  [243] (word) divr16u::return#2 ← (word) divr16u::return#0
  to:div16u::@1
div16u::@1: scope:[div16u]  from div16u
  [244] (word) div16u::return#0 ← (word) divr16u::return#2
  to:div16u::@return
div16u::@return: scope:[div16u]  from div16u::@1
  [245] return 
  to:@return
