
void main()
main: scope:[main]  from
  [0] phi()
  [1] call sin8s_gen
  to:main::@2
main::@2: scope:[main]  from main
  [2] phi()
  [3] call sin16s_gen
  to:main::@3
main::@3: scope:[main]  from main::@2
  [4] phi()
  [5] call print_cls
  to:main::@1
main::@1: scope:[main]  from main::@3 main::@5
  [6] print_char_cursor#45 = phi( main::@3/print_screen#0, main::@5/print_char_cursor#10 )
  [6] main::i#2 = phi( main::@3/0, main::@5/main::i#1 )
  [7] main::sb#0 = main::sintabb[main::i#2]
  [8] main::$10 = (unsigned int)main::i#2
  [9] main::$9 = main::$10 << 1
  [10] main::$3 = main::sintabw + main::$9
  [11] main::sw#0 = *main::$3
  [12] main::$11 = byte1  main::sw#0
  [13] main::sd#0 = main::sb#0 - (signed char)main::$11
  [14] print_schar::b#1 = main::sd#0
  [15] call print_schar
  to:main::@4
main::@4: scope:[main]  from main::@1
  [16] phi()
  [17] call print_str
  to:main::@5
main::@5: scope:[main]  from main::@4
  [18] main::i#1 = ++ main::i#2
  [19] if(main::i#1!=$c0) goto main::@1
  to:main::@return
main::@return: scope:[main]  from main::@5
  [20] return 
  to:@return

void sin8s_gen(signed char *sintab , unsigned int wavelength)
sin8s_gen: scope:[sin8s_gen]  from main
  [21] phi()
  [22] call div16u
  [23] div16u::return#0 = div16u::return#1
  to:sin8s_gen::@3
sin8s_gen::@3: scope:[sin8s_gen]  from sin8s_gen
  [24] sin8s_gen::step#0 = div16u::return#0
  to:sin8s_gen::@1
sin8s_gen::@1: scope:[sin8s_gen]  from sin8s_gen::@3 sin8s_gen::@4
  [25] sin8s_gen::sintab#2 = phi( sin8s_gen::@3/main::sintabb, sin8s_gen::@4/sin8s_gen::sintab#0 )
  [25] sin8s_gen::x#2 = phi( sin8s_gen::@3/0, sin8s_gen::@4/sin8s_gen::x#1 )
  [25] sin8s_gen::i#2 = phi( sin8s_gen::@3/0, sin8s_gen::@4/sin8s_gen::i#1 )
  [26] if(sin8s_gen::i#2<main::wavelength) goto sin8s_gen::@2
  to:sin8s_gen::@return
sin8s_gen::@return: scope:[sin8s_gen]  from sin8s_gen::@1
  [27] return 
  to:@return
sin8s_gen::@2: scope:[sin8s_gen]  from sin8s_gen::@1
  [28] sin8s::x#0 = sin8s_gen::x#2
  [29] call sin8s
  [30] sin8s::return#0 = sin8s::return#1
  to:sin8s_gen::@4
sin8s_gen::@4: scope:[sin8s_gen]  from sin8s_gen::@2
  [31] sin8s_gen::$2 = sin8s::return#0
  [32] *sin8s_gen::sintab#2 = sin8s_gen::$2
  [33] sin8s_gen::sintab#0 = ++ sin8s_gen::sintab#2
  [34] sin8s_gen::x#1 = sin8s_gen::x#2 + sin8s_gen::step#0
  [35] sin8s_gen::i#1 = ++ sin8s_gen::i#2
  to:sin8s_gen::@1

void sin16s_gen(int *sintab , unsigned int wavelength)
sin16s_gen: scope:[sin16s_gen]  from main::@2
  [36] phi()
  [37] call div32u16u
  [38] div32u16u::return#0 = div32u16u::return#1
  to:sin16s_gen::@3
sin16s_gen::@3: scope:[sin16s_gen]  from sin16s_gen
  [39] sin16s_gen::step#0 = div32u16u::return#0
  to:sin16s_gen::@1
sin16s_gen::@1: scope:[sin16s_gen]  from sin16s_gen::@3 sin16s_gen::@4
  [40] sin16s_gen::sintab#2 = phi( sin16s_gen::@3/main::sintabw, sin16s_gen::@4/sin16s_gen::sintab#0 )
  [40] sin16s_gen::x#2 = phi( sin16s_gen::@3/0, sin16s_gen::@4/sin16s_gen::x#1 )
  [40] sin16s_gen::i#2 = phi( sin16s_gen::@3/0, sin16s_gen::@4/sin16s_gen::i#1 )
  [41] if(sin16s_gen::i#2<main::wavelength) goto sin16s_gen::@2
  to:sin16s_gen::@return
sin16s_gen::@return: scope:[sin16s_gen]  from sin16s_gen::@1
  [42] return 
  to:@return
sin16s_gen::@2: scope:[sin16s_gen]  from sin16s_gen::@1
  [43] sin16s::x#0 = sin16s_gen::x#2
  [44] call sin16s
  [45] sin16s::return#0 = sin16s::return#1
  to:sin16s_gen::@4
sin16s_gen::@4: scope:[sin16s_gen]  from sin16s_gen::@2
  [46] sin16s_gen::$2 = sin16s::return#0
  [47] *sin16s_gen::sintab#2 = sin16s_gen::$2
  [48] sin16s_gen::sintab#0 = sin16s_gen::sintab#2 + SIZEOF_INT
  [49] sin16s_gen::x#1 = sin16s_gen::x#2 + sin16s_gen::step#0
  [50] sin16s_gen::i#1 = ++ sin16s_gen::i#2
  to:sin16s_gen::@1

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

void print_schar(signed char b)
print_schar: scope:[print_schar]  from main::@1
  [54] if(print_schar::b#1<0) goto print_schar::@1
  to:print_schar::@3
print_schar::@3: scope:[print_schar]  from print_schar
  [55] phi()
  [56] call print_char
  to:print_schar::@2
print_schar::@2: scope:[print_schar]  from print_schar::@3 print_schar::@4
  [57] print_schar::b#4 = phi( print_schar::@4/print_schar::b#0, print_schar::@3/print_schar::b#1 )
  [58] print_uchar::b#0 = (char)print_schar::b#4
  [59] call print_uchar
  to:print_schar::@return
print_schar::@return: scope:[print_schar]  from print_schar::@2
  [60] return 
  to:@return
print_schar::@1: scope:[print_schar]  from print_schar
  [61] phi()
  [62] call print_char
  to:print_schar::@4
print_schar::@4: scope:[print_schar]  from print_schar::@1
  [63] print_schar::b#0 = - print_schar::b#1
  to:print_schar::@2

void print_str(char *str)
print_str: scope:[print_str]  from main::@4
  [64] phi()
  to:print_str::@1
print_str::@1: scope:[print_str]  from print_str print_str::@3
  [65] print_str::str#2 = phi( print_str/main::str, print_str::@3/print_str::str#0 )
  [66] if(0!=*print_str::str#2) goto print_str::@2
  to:print_str::@return
print_str::@return: scope:[print_str]  from print_str::@1
  [67] return 
  to:@return
print_str::@2: scope:[print_str]  from print_str::@1
  [68] print_char::ch#0 = *print_str::str#2
  [69] call print_char
  to:print_str::@3
print_str::@3: scope:[print_str]  from print_str::@2
  [70] print_str::str#0 = ++ print_str::str#2
  to:print_str::@1

unsigned int div16u(unsigned int dividend , unsigned int divisor)
div16u: scope:[div16u]  from sin8s_gen
  [71] phi()
  [72] call divr16u
  [73] divr16u::return#2 = divr16u::return#0
  to:div16u::@1
div16u::@1: scope:[div16u]  from div16u
  [74] div16u::return#1 = divr16u::return#2
  to:div16u::@return
div16u::@return: scope:[div16u]  from div16u::@1
  [75] return 
  to:@return

signed char sin8s(unsigned int x)
sin8s: scope:[sin8s]  from sin8s_gen::@2
  [76] if(sin8s::x#0<PI_u4f12) goto sin8s::@1
  to:sin8s::@5
sin8s::@5: scope:[sin8s]  from sin8s
  [77] sin8s::x#1 = sin8s::x#0 - PI_u4f12
  to:sin8s::@1
sin8s::@1: scope:[sin8s]  from sin8s sin8s::@5
  [78] sin8s::isUpper#10 = phi( sin8s/0, sin8s::@5/1 )
  [78] sin8s::x#4 = phi( sin8s/sin8s::x#0, sin8s::@5/sin8s::x#1 )
  [79] if(sin8s::x#4<PI_HALF_u4f12) goto sin8s::@2
  to:sin8s::@6
sin8s::@6: scope:[sin8s]  from sin8s::@1
  [80] sin8s::x#2 = PI_u4f12 - sin8s::x#4
  to:sin8s::@2
sin8s::@2: scope:[sin8s]  from sin8s::@1 sin8s::@6
  [81] sin8s::x#6 = phi( sin8s::@1/sin8s::x#4, sin8s::@6/sin8s::x#2 )
  [82] sin8s::$4 = sin8s::x#6 << 3
  [83] sin8s::x1#0 = byte1  sin8s::$4
  [84] mulu8_sel::v1#0 = sin8s::x1#0
  [85] mulu8_sel::v2#0 = sin8s::x1#0
  [86] call mulu8_sel
  [87] mulu8_sel::return#0 = mulu8_sel::return#12
  to:sin8s::@9
sin8s::@9: scope:[sin8s]  from sin8s::@2
  [88] sin8s::x2#0 = mulu8_sel::return#0
  [89] mulu8_sel::v1#1 = sin8s::x2#0
  [90] mulu8_sel::v2#1 = sin8s::x1#0
  [91] call mulu8_sel
  [92] mulu8_sel::return#1 = mulu8_sel::return#12
  to:sin8s::@10
sin8s::@10: scope:[sin8s]  from sin8s::@9
  [93] sin8s::x3#0 = mulu8_sel::return#1
  [94] mulu8_sel::v1#2 = sin8s::x3#0
  [95] call mulu8_sel
  [96] mulu8_sel::return#2 = mulu8_sel::return#12
  to:sin8s::@11
sin8s::@11: scope:[sin8s]  from sin8s::@10
  [97] sin8s::x3_6#0 = mulu8_sel::return#2
  [98] sin8s::usinx#0 = sin8s::x1#0 - sin8s::x3_6#0
  [99] mulu8_sel::v1#3 = sin8s::x3#0
  [100] mulu8_sel::v2#3 = sin8s::x1#0
  [101] call mulu8_sel
  [102] mulu8_sel::return#10 = mulu8_sel::return#12
  to:sin8s::@12
sin8s::@12: scope:[sin8s]  from sin8s::@11
  [103] sin8s::x4#0 = mulu8_sel::return#10
  [104] mulu8_sel::v1#4 = sin8s::x4#0
  [105] mulu8_sel::v2#4 = sin8s::x1#0
  [106] call mulu8_sel
  [107] mulu8_sel::return#11 = mulu8_sel::return#12
  to:sin8s::@13
sin8s::@13: scope:[sin8s]  from sin8s::@12
  [108] sin8s::x5#0 = mulu8_sel::return#11
  [109] sin8s::x5_128#0 = sin8s::x5#0 >> 4
  [110] sin8s::usinx#1 = sin8s::usinx#0 + sin8s::x5_128#0
  [111] if(sin8s::usinx#1<$80) goto sin8s::@3
  to:sin8s::@7
sin8s::@7: scope:[sin8s]  from sin8s::@13
  [112] sin8s::usinx#2 = -- sin8s::usinx#1
  to:sin8s::@3
sin8s::@3: scope:[sin8s]  from sin8s::@13 sin8s::@7
  [113] sin8s::usinx#4 = phi( sin8s::@13/sin8s::usinx#1, sin8s::@7/sin8s::usinx#2 )
  [114] if(sin8s::isUpper#10==0) goto sin8s::@14
  to:sin8s::@8
sin8s::@8: scope:[sin8s]  from sin8s::@3
  [115] sin8s::sinx#1 = - (signed char)sin8s::usinx#4
  to:sin8s::@4
sin8s::@4: scope:[sin8s]  from sin8s::@14 sin8s::@8
  [116] sin8s::return#1 = phi( sin8s::@14/sin8s::return#5, sin8s::@8/sin8s::sinx#1 )
  to:sin8s::@return
sin8s::@return: scope:[sin8s]  from sin8s::@4
  [117] return 
  to:@return
sin8s::@14: scope:[sin8s]  from sin8s::@3
  [118] sin8s::return#5 = (signed char)sin8s::usinx#4
  to:sin8s::@4

unsigned long div32u16u(unsigned long dividend , unsigned int divisor)
div32u16u: scope:[div32u16u]  from sin16s_gen
  [119] phi()
  [120] call divr16u
  [121] divr16u::return#3 = divr16u::return#0
  to:div32u16u::@1
div32u16u::@1: scope:[div32u16u]  from div32u16u
  [122] div32u16u::quotient_hi#0 = divr16u::return#3
  [123] divr16u::rem#5 = rem16u#21
  [124] call divr16u
  [125] divr16u::return#4 = divr16u::return#0
  to:div32u16u::@2
div32u16u::@2: scope:[div32u16u]  from div32u16u::@1
  [126] div32u16u::quotient_lo#0 = divr16u::return#4
  [127] div32u16u::return#1 = div32u16u::quotient_hi#0 dw= div32u16u::quotient_lo#0
  to:div32u16u::@return
div32u16u::@return: scope:[div32u16u]  from div32u16u::@2
  [128] return 
  to:@return

int sin16s(unsigned long x)
sin16s: scope:[sin16s]  from sin16s_gen::@2
  [129] if(sin16s::x#0<PI_u4f28) goto sin16s::@1
  to:sin16s::@4
sin16s::@4: scope:[sin16s]  from sin16s
  [130] sin16s::x#1 = sin16s::x#0 - PI_u4f28
  to:sin16s::@1
sin16s::@1: scope:[sin16s]  from sin16s sin16s::@4
  [131] sin16s::isUpper#2 = phi( sin16s/0, sin16s::@4/1 )
  [131] sin16s::x#4 = phi( sin16s/sin16s::x#0, sin16s::@4/sin16s::x#1 )
  [132] if(sin16s::x#4<PI_HALF_u4f28) goto sin16s::@2
  to:sin16s::@5
sin16s::@5: scope:[sin16s]  from sin16s::@1
  [133] sin16s::x#2 = PI_u4f28 - sin16s::x#4
  to:sin16s::@2
sin16s::@2: scope:[sin16s]  from sin16s::@1 sin16s::@5
  [134] sin16s::x#6 = phi( sin16s::@1/sin16s::x#4, sin16s::@5/sin16s::x#2 )
  [135] sin16s::$4 = sin16s::x#6 << 3
  [136] sin16s::x1#0 = word1  sin16s::$4
  [137] mulu16_sel::v1#0 = sin16s::x1#0
  [138] mulu16_sel::v2#0 = sin16s::x1#0
  [139] call mulu16_sel
  [140] mulu16_sel::return#0 = mulu16_sel::return#12
  to:sin16s::@7
sin16s::@7: scope:[sin16s]  from sin16s::@2
  [141] sin16s::x2#0 = mulu16_sel::return#0
  [142] mulu16_sel::v1#1 = sin16s::x2#0
  [143] mulu16_sel::v2#1 = sin16s::x1#0
  [144] call mulu16_sel
  [145] mulu16_sel::return#1 = mulu16_sel::return#12
  to:sin16s::@8
sin16s::@8: scope:[sin16s]  from sin16s::@7
  [146] sin16s::x3#0 = mulu16_sel::return#1
  [147] mulu16_sel::v1#2 = sin16s::x3#0
  [148] call mulu16_sel
  [149] mulu16_sel::return#2 = mulu16_sel::return#12
  to:sin16s::@9
sin16s::@9: scope:[sin16s]  from sin16s::@8
  [150] sin16s::x3_6#0 = mulu16_sel::return#2
  [151] sin16s::usinx#0 = sin16s::x1#0 - sin16s::x3_6#0
  [152] mulu16_sel::v1#3 = sin16s::x3#0
  [153] mulu16_sel::v2#3 = sin16s::x1#0
  [154] call mulu16_sel
  [155] mulu16_sel::return#10 = mulu16_sel::return#12
  to:sin16s::@10
sin16s::@10: scope:[sin16s]  from sin16s::@9
  [156] sin16s::x4#0 = mulu16_sel::return#10
  [157] mulu16_sel::v1#4 = sin16s::x4#0
  [158] mulu16_sel::v2#4 = sin16s::x1#0
  [159] call mulu16_sel
  [160] mulu16_sel::return#11 = mulu16_sel::return#12
  to:sin16s::@11
sin16s::@11: scope:[sin16s]  from sin16s::@10
  [161] sin16s::x5#0 = mulu16_sel::return#11
  [162] sin16s::x5_128#0 = sin16s::x5#0 >> 4
  [163] sin16s::usinx#1 = sin16s::usinx#0 + sin16s::x5_128#0
  [164] if(sin16s::isUpper#2==0) goto sin16s::@12
  to:sin16s::@6
sin16s::@6: scope:[sin16s]  from sin16s::@11
  [165] sin16s::sinx#1 = - (int)sin16s::usinx#1
  to:sin16s::@3
sin16s::@3: scope:[sin16s]  from sin16s::@12 sin16s::@6
  [166] sin16s::return#1 = phi( sin16s::@12/sin16s::return#5, sin16s::@6/sin16s::sinx#1 )
  to:sin16s::@return
sin16s::@return: scope:[sin16s]  from sin16s::@3
  [167] return 
  to:@return
sin16s::@12: scope:[sin16s]  from sin16s::@11
  [168] sin16s::return#5 = (int)sin16s::usinx#1
  to:sin16s::@3

void * memset(void *str , char c , unsigned int num)
memset: scope:[memset]  from print_cls
  [169] phi()
  to:memset::@1
memset::@1: scope:[memset]  from memset memset::@2
  [170] memset::dst#2 = phi( memset/(char *)memset::str#0, memset::@2/memset::dst#1 )
  [171] if(memset::dst#2!=memset::end#0) goto memset::@2
  to:memset::@return
memset::@return: scope:[memset]  from memset::@1
  [172] return 
  to:@return
memset::@2: scope:[memset]  from memset::@1
  [173] *memset::dst#2 = memset::c#0
  [174] memset::dst#1 = ++ memset::dst#2
  to:memset::@1

void print_char(char ch)
print_char: scope:[print_char]  from print_schar::@1 print_schar::@3 print_str::@2 print_uchar print_uchar::@1
  [175] print_char_cursor#29 = phi( print_schar::@1/print_char_cursor#45, print_schar::@3/print_char_cursor#45, print_str::@2/print_char_cursor#10, print_uchar/print_char_cursor#10, print_uchar::@1/print_char_cursor#10 )
  [175] print_char::ch#5 = phi( print_schar::@1/'-', print_schar::@3/' ', print_str::@2/print_char::ch#0, print_uchar/print_char::ch#3, print_uchar::@1/print_char::ch#4 )
  [176] *print_char_cursor#29 = print_char::ch#5
  [177] print_char_cursor#10 = ++ print_char_cursor#29
  to:print_char::@return
print_char::@return: scope:[print_char]  from print_char
  [178] return 
  to:@return

void print_uchar(char b)
print_uchar: scope:[print_uchar]  from print_schar::@2
  [179] print_uchar::$0 = print_uchar::b#0 >> 4
  [180] print_char::ch#3 = print_hextab[print_uchar::$0]
  [181] call print_char
  to:print_uchar::@1
print_uchar::@1: scope:[print_uchar]  from print_uchar
  [182] print_uchar::$2 = print_uchar::b#0 & $f
  [183] print_char::ch#4 = print_hextab[print_uchar::$2]
  [184] call print_char
  to:print_uchar::@return
print_uchar::@return: scope:[print_uchar]  from print_uchar::@1
  [185] return 
  to:@return

unsigned int divr16u(unsigned int dividend , unsigned int divisor , unsigned int rem)
divr16u: scope:[divr16u]  from div16u div32u16u div32u16u::@1
  [186] divr16u::dividend#6 = phi( div16u/PI2_u4f12, div32u16u/word1 PI2_u4f28, div32u16u::@1/word0 PI2_u4f28 )
  [186] divr16u::rem#11 = phi( div16u/0, div32u16u/0, div32u16u::@1/divr16u::rem#5 )
  to:divr16u::@1
divr16u::@1: scope:[divr16u]  from divr16u divr16u::@3
  [187] divr16u::i#2 = phi( divr16u/0, divr16u::@3/divr16u::i#1 )
  [187] divr16u::quotient#3 = phi( divr16u/0, divr16u::@3/divr16u::return#0 )
  [187] divr16u::dividend#4 = phi( divr16u/divr16u::dividend#6, divr16u::@3/divr16u::dividend#0 )
  [187] divr16u::rem#6 = phi( divr16u/divr16u::rem#11, divr16u::@3/divr16u::rem#10 )
  [188] divr16u::rem#0 = divr16u::rem#6 << 1
  [189] divr16u::$1 = byte1  divr16u::dividend#4
  [190] divr16u::$2 = divr16u::$1 & $80
  [191] if(divr16u::$2==0) goto divr16u::@2
  to:divr16u::@4
divr16u::@4: scope:[divr16u]  from divr16u::@1
  [192] divr16u::rem#1 = divr16u::rem#0 | 1
  to:divr16u::@2
divr16u::@2: scope:[divr16u]  from divr16u::@1 divr16u::@4
  [193] divr16u::rem#7 = phi( divr16u::@1/divr16u::rem#0, divr16u::@4/divr16u::rem#1 )
  [194] divr16u::dividend#0 = divr16u::dividend#4 << 1
  [195] divr16u::quotient#1 = divr16u::quotient#3 << 1
  [196] if(divr16u::rem#7<main::wavelength) goto divr16u::@3
  to:divr16u::@5
divr16u::@5: scope:[divr16u]  from divr16u::@2
  [197] divr16u::quotient#2 = ++ divr16u::quotient#1
  [198] divr16u::rem#2 = divr16u::rem#7 - main::wavelength
  to:divr16u::@3
divr16u::@3: scope:[divr16u]  from divr16u::@2 divr16u::@5
  [199] divr16u::return#0 = phi( divr16u::@2/divr16u::quotient#1, divr16u::@5/divr16u::quotient#2 )
  [199] divr16u::rem#10 = phi( divr16u::@2/divr16u::rem#7, divr16u::@5/divr16u::rem#2 )
  [200] divr16u::i#1 = ++ divr16u::i#2
  [201] if(divr16u::i#1!=$10) goto divr16u::@1
  to:divr16u::@6
divr16u::@6: scope:[divr16u]  from divr16u::@3
  [202] rem16u#21 = divr16u::rem#10
  to:divr16u::@return
divr16u::@return: scope:[divr16u]  from divr16u::@6
  [203] return 
  to:@return

char mulu8_sel(char v1 , char v2 , char select)
mulu8_sel: scope:[mulu8_sel]  from sin8s::@10 sin8s::@11 sin8s::@12 sin8s::@2 sin8s::@9
  [204] mulu8_sel::select#5 = phi( sin8s::@10/1, sin8s::@11/0, sin8s::@12/0, sin8s::@2/0, sin8s::@9/1 )
  [204] mulu8_sel::v2#5 = phi( sin8s::@10/sin8s::DIV_6, sin8s::@11/mulu8_sel::v2#3, sin8s::@12/mulu8_sel::v2#4, sin8s::@2/mulu8_sel::v2#0, sin8s::@9/mulu8_sel::v2#1 )
  [204] mulu8_sel::v1#5 = phi( sin8s::@10/mulu8_sel::v1#2, sin8s::@11/mulu8_sel::v1#3, sin8s::@12/mulu8_sel::v1#4, sin8s::@2/mulu8_sel::v1#0, sin8s::@9/mulu8_sel::v1#1 )
  [205] mul8u::a#0 = mulu8_sel::v1#5
  [206] mul8u::b#0 = mulu8_sel::v2#5
  [207] call mul8u
  [208] mul8u::return#0 = mul8u::res#2
  to:mulu8_sel::@1
mulu8_sel::@1: scope:[mulu8_sel]  from mulu8_sel
  [209] mulu8_sel::$0 = mul8u::return#0
  [210] mulu8_sel::$1 = mulu8_sel::$0 << mulu8_sel::select#5
  [211] mulu8_sel::return#12 = byte1  mulu8_sel::$1
  to:mulu8_sel::@return
mulu8_sel::@return: scope:[mulu8_sel]  from mulu8_sel::@1
  [212] return 
  to:@return

unsigned int mulu16_sel(unsigned int v1 , unsigned int v2 , char select)
mulu16_sel: scope:[mulu16_sel]  from sin16s::@10 sin16s::@2 sin16s::@7 sin16s::@8 sin16s::@9
  [213] mulu16_sel::select#5 = phi( sin16s::@10/0, sin16s::@2/0, sin16s::@7/1, sin16s::@8/1, sin16s::@9/0 )
  [213] mulu16_sel::v2#5 = phi( sin16s::@10/mulu16_sel::v2#4, sin16s::@2/mulu16_sel::v2#0, sin16s::@7/mulu16_sel::v2#1, sin16s::@8/(unsigned int)$10000/6, sin16s::@9/mulu16_sel::v2#3 )
  [213] mulu16_sel::v1#5 = phi( sin16s::@10/mulu16_sel::v1#4, sin16s::@2/mulu16_sel::v1#0, sin16s::@7/mulu16_sel::v1#1, sin16s::@8/mulu16_sel::v1#2, sin16s::@9/mulu16_sel::v1#3 )
  [214] mul16u::a#0 = mulu16_sel::v1#5
  [215] mul16u::b#0 = mulu16_sel::v2#5
  [216] call mul16u
  [217] mul16u::return#0 = mul16u::res#2
  to:mulu16_sel::@1
mulu16_sel::@1: scope:[mulu16_sel]  from mulu16_sel
  [218] mulu16_sel::$0 = mul16u::return#0
  [219] mulu16_sel::$1 = mulu16_sel::$0 << mulu16_sel::select#5
  [220] mulu16_sel::return#12 = word1  mulu16_sel::$1
  to:mulu16_sel::@return
mulu16_sel::@return: scope:[mulu16_sel]  from mulu16_sel::@1
  [221] return 
  to:@return

unsigned int mul8u(char a , char b)
mul8u: scope:[mul8u]  from mulu8_sel
  [222] mul8u::mb#0 = (unsigned int)mul8u::b#0
  to:mul8u::@1
mul8u::@1: scope:[mul8u]  from mul8u mul8u::@3
  [223] mul8u::mb#2 = phi( mul8u/mul8u::mb#0, mul8u::@3/mul8u::mb#1 )
  [223] mul8u::res#2 = phi( mul8u/0, mul8u::@3/mul8u::res#6 )
  [223] mul8u::a#2 = phi( mul8u/mul8u::a#0, mul8u::@3/mul8u::a#1 )
  [224] if(mul8u::a#2!=0) goto mul8u::@2
  to:mul8u::@return
mul8u::@return: scope:[mul8u]  from mul8u::@1
  [225] return 
  to:@return
mul8u::@2: scope:[mul8u]  from mul8u::@1
  [226] mul8u::$1 = mul8u::a#2 & 1
  [227] if(mul8u::$1==0) goto mul8u::@3
  to:mul8u::@4
mul8u::@4: scope:[mul8u]  from mul8u::@2
  [228] mul8u::res#1 = mul8u::res#2 + mul8u::mb#2
  to:mul8u::@3
mul8u::@3: scope:[mul8u]  from mul8u::@2 mul8u::@4
  [229] mul8u::res#6 = phi( mul8u::@2/mul8u::res#2, mul8u::@4/mul8u::res#1 )
  [230] mul8u::a#1 = mul8u::a#2 >> 1
  [231] mul8u::mb#1 = mul8u::mb#2 << 1
  to:mul8u::@1

unsigned long mul16u(unsigned int a , unsigned int b)
mul16u: scope:[mul16u]  from mulu16_sel
  [232] mul16u::mb#0 = (unsigned long)mul16u::b#0
  to:mul16u::@1
mul16u::@1: scope:[mul16u]  from mul16u mul16u::@3
  [233] mul16u::mb#2 = phi( mul16u/mul16u::mb#0, mul16u::@3/mul16u::mb#1 )
  [233] mul16u::res#2 = phi( mul16u/0, mul16u::@3/mul16u::res#6 )
  [233] mul16u::a#2 = phi( mul16u/mul16u::a#0, mul16u::@3/mul16u::a#1 )
  [234] if(mul16u::a#2!=0) goto mul16u::@2
  to:mul16u::@return
mul16u::@return: scope:[mul16u]  from mul16u::@1
  [235] return 
  to:@return
mul16u::@2: scope:[mul16u]  from mul16u::@1
  [236] mul16u::$1 = mul16u::a#2 & 1
  [237] if(mul16u::$1==0) goto mul16u::@3
  to:mul16u::@4
mul16u::@4: scope:[mul16u]  from mul16u::@2
  [238] mul16u::res#1 = mul16u::res#2 + mul16u::mb#2
  to:mul16u::@3
mul16u::@3: scope:[mul16u]  from mul16u::@2 mul16u::@4
  [239] mul16u::res#6 = phi( mul16u::@2/mul16u::res#2, mul16u::@4/mul16u::res#1 )
  [240] mul16u::a#1 = mul16u::a#2 >> 1
  [241] mul16u::mb#1 = mul16u::mb#2 << 1
  to:mul16u::@1
