
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 print_cls
  to:main::@1
main::@1: scope:[main]  from main::@2 main::@4
  [4] print_char_cursor#45 = phi( main::@2/print_screen#0, main::@4/print_char_cursor#10 )
  [4] main::i#2 = phi( main::@2/0, main::@4/main::i#1 )
  [5] main::sb#0 = sintab2[main::i#2] - (signed char)sintabref[main::i#2]
  [6] print_schar::b#1 = main::sb#0
  [7] call print_schar
  to:main::@3
main::@3: scope:[main]  from main::@1
  [8] phi()
  [9] call print_str
  to:main::@4
main::@4: scope:[main]  from main::@3
  [10] main::i#1 = ++ main::i#2
  [11] if(main::i#1!=$c0) goto main::@1
  to:main::@return
main::@return: scope:[main]  from main::@4
  [12] return 
  to:@return

void sin8s_gen(signed char *sintab , unsigned int wavelength)
sin8s_gen: scope:[sin8s_gen]  from main
  [13] phi()
  [14] call div16u
  [15] div16u::return#0 = div16u::return#1
  to:sin8s_gen::@3
sin8s_gen::@3: scope:[sin8s_gen]  from sin8s_gen
  [16] sin8s_gen::step#0 = div16u::return#0
  to:sin8s_gen::@1
sin8s_gen::@1: scope:[sin8s_gen]  from sin8s_gen::@3 sin8s_gen::@4
  [17] sin8s_gen::sintab#2 = phi( sin8s_gen::@3/sintab2, sin8s_gen::@4/sin8s_gen::sintab#0 )
  [17] sin8s_gen::x#2 = phi( sin8s_gen::@3/0, sin8s_gen::@4/sin8s_gen::x#1 )
  [17] sin8s_gen::i#2 = phi( sin8s_gen::@3/0, sin8s_gen::@4/sin8s_gen::i#1 )
  [18] if(sin8s_gen::i#2<wavelength) goto sin8s_gen::@2
  to:sin8s_gen::@return
sin8s_gen::@return: scope:[sin8s_gen]  from sin8s_gen::@1
  [19] return 
  to:@return
sin8s_gen::@2: scope:[sin8s_gen]  from sin8s_gen::@1
  [20] sin8s::x#0 = sin8s_gen::x#2
  [21] call sin8s
  [22] sin8s::return#0 = sin8s::return#1
  to:sin8s_gen::@4
sin8s_gen::@4: scope:[sin8s_gen]  from sin8s_gen::@2
  [23] sin8s_gen::$2 = sin8s::return#0
  [24] *sin8s_gen::sintab#2 = sin8s_gen::$2
  [25] sin8s_gen::sintab#0 = ++ sin8s_gen::sintab#2
  [26] sin8s_gen::x#1 = sin8s_gen::x#2 + sin8s_gen::step#0
  [27] sin8s_gen::i#1 = ++ sin8s_gen::i#2
  to:sin8s_gen::@1

void print_cls()
print_cls: scope:[print_cls]  from main::@2
  [28] phi()
  [29] call memset
  to:print_cls::@return
print_cls::@return: scope:[print_cls]  from print_cls
  [30] return 
  to:@return

void print_schar(signed char b)
print_schar: scope:[print_schar]  from main::@1
  [31] if(print_schar::b#1<0) goto print_schar::@1
  to:print_schar::@3
print_schar::@3: scope:[print_schar]  from print_schar
  [32] phi()
  [33] call print_char
  to:print_schar::@2
print_schar::@2: scope:[print_schar]  from print_schar::@3 print_schar::@4
  [34] print_schar::b#4 = phi( print_schar::@4/print_schar::b#0, print_schar::@3/print_schar::b#1 )
  [35] print_uchar::b#0 = (char)print_schar::b#4
  [36] call print_uchar
  to:print_schar::@return
print_schar::@return: scope:[print_schar]  from print_schar::@2
  [37] return 
  to:@return
print_schar::@1: scope:[print_schar]  from print_schar
  [38] phi()
  [39] call print_char
  to:print_schar::@4
print_schar::@4: scope:[print_schar]  from print_schar::@1
  [40] print_schar::b#0 = - print_schar::b#1
  to:print_schar::@2

void print_str(char *str)
print_str: scope:[print_str]  from main::@3
  [41] phi()
  to:print_str::@1
print_str::@1: scope:[print_str]  from print_str print_str::@3
  [42] print_str::str#2 = phi( print_str/main::str, print_str::@3/print_str::str#0 )
  [43] if(0!=*print_str::str#2) goto print_str::@2
  to:print_str::@return
print_str::@return: scope:[print_str]  from print_str::@1
  [44] return 
  to:@return
print_str::@2: scope:[print_str]  from print_str::@1
  [45] print_char::ch#0 = *print_str::str#2
  [46] call print_char
  to:print_str::@3
print_str::@3: scope:[print_str]  from print_str::@2
  [47] 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
  [48] phi()
  [49] call divr16u
  [50] divr16u::return#2 = divr16u::return#0
  to:div16u::@1
div16u::@1: scope:[div16u]  from div16u
  [51] div16u::return#1 = divr16u::return#2
  to:div16u::@return
div16u::@return: scope:[div16u]  from div16u::@1
  [52] return 
  to:@return

signed char sin8s(unsigned int x)
sin8s: scope:[sin8s]  from sin8s_gen::@2
  [53] if(sin8s::x#0<PI_u4f12) goto sin8s::@1
  to:sin8s::@5
sin8s::@5: scope:[sin8s]  from sin8s
  [54] sin8s::x#1 = sin8s::x#0 - PI_u4f12
  to:sin8s::@1
sin8s::@1: scope:[sin8s]  from sin8s sin8s::@5
  [55] sin8s::isUpper#10 = phi( sin8s/0, sin8s::@5/1 )
  [55] sin8s::x#4 = phi( sin8s/sin8s::x#0, sin8s::@5/sin8s::x#1 )
  [56] if(sin8s::x#4<PI_HALF_u4f12) goto sin8s::@2
  to:sin8s::@6
sin8s::@6: scope:[sin8s]  from sin8s::@1
  [57] sin8s::x#2 = PI_u4f12 - sin8s::x#4
  to:sin8s::@2
sin8s::@2: scope:[sin8s]  from sin8s::@1 sin8s::@6
  [58] sin8s::x#6 = phi( sin8s::@1/sin8s::x#4, sin8s::@6/sin8s::x#2 )
  [59] sin8s::$4 = sin8s::x#6 << 3
  [60] sin8s::x1#0 = byte1  sin8s::$4
  [61] mulu8_sel::v1#0 = sin8s::x1#0
  [62] mulu8_sel::v2#0 = sin8s::x1#0
  [63] call mulu8_sel
  [64] mulu8_sel::return#0 = mulu8_sel::return#12
  to:sin8s::@9
sin8s::@9: scope:[sin8s]  from sin8s::@2
  [65] sin8s::x2#0 = mulu8_sel::return#0
  [66] mulu8_sel::v1#1 = sin8s::x2#0
  [67] mulu8_sel::v2#1 = sin8s::x1#0
  [68] call mulu8_sel
  [69] mulu8_sel::return#1 = mulu8_sel::return#12
  to:sin8s::@10
sin8s::@10: scope:[sin8s]  from sin8s::@9
  [70] sin8s::x3#0 = mulu8_sel::return#1
  [71] mulu8_sel::v1#2 = sin8s::x3#0
  [72] call mulu8_sel
  [73] mulu8_sel::return#2 = mulu8_sel::return#12
  to:sin8s::@11
sin8s::@11: scope:[sin8s]  from sin8s::@10
  [74] sin8s::x3_6#0 = mulu8_sel::return#2
  [75] sin8s::usinx#0 = sin8s::x1#0 - sin8s::x3_6#0
  [76] mulu8_sel::v1#3 = sin8s::x3#0
  [77] mulu8_sel::v2#3 = sin8s::x1#0
  [78] call mulu8_sel
  [79] mulu8_sel::return#10 = mulu8_sel::return#12
  to:sin8s::@12
sin8s::@12: scope:[sin8s]  from sin8s::@11
  [80] sin8s::x4#0 = mulu8_sel::return#10
  [81] mulu8_sel::v1#4 = sin8s::x4#0
  [82] mulu8_sel::v2#4 = sin8s::x1#0
  [83] call mulu8_sel
  [84] mulu8_sel::return#11 = mulu8_sel::return#12
  to:sin8s::@13
sin8s::@13: scope:[sin8s]  from sin8s::@12
  [85] sin8s::x5#0 = mulu8_sel::return#11
  [86] sin8s::x5_128#0 = sin8s::x5#0 >> 4
  [87] sin8s::usinx#1 = sin8s::usinx#0 + sin8s::x5_128#0
  [88] if(sin8s::usinx#1<$80) goto sin8s::@3
  to:sin8s::@7
sin8s::@7: scope:[sin8s]  from sin8s::@13
  [89] sin8s::usinx#2 = -- sin8s::usinx#1
  to:sin8s::@3
sin8s::@3: scope:[sin8s]  from sin8s::@13 sin8s::@7
  [90] sin8s::usinx#4 = phi( sin8s::@13/sin8s::usinx#1, sin8s::@7/sin8s::usinx#2 )
  [91] if(sin8s::isUpper#10==0) goto sin8s::@14
  to:sin8s::@8
sin8s::@8: scope:[sin8s]  from sin8s::@3
  [92] sin8s::sinx#1 = - (signed char)sin8s::usinx#4
  to:sin8s::@4
sin8s::@4: scope:[sin8s]  from sin8s::@14 sin8s::@8
  [93] sin8s::return#1 = phi( sin8s::@14/sin8s::return#5, sin8s::@8/sin8s::sinx#1 )
  to:sin8s::@return
sin8s::@return: scope:[sin8s]  from sin8s::@4
  [94] return 
  to:@return
sin8s::@14: scope:[sin8s]  from sin8s::@3
  [95] sin8s::return#5 = (signed char)sin8s::usinx#4
  to:sin8s::@4

void * memset(void *str , char c , unsigned int num)
memset: scope:[memset]  from print_cls
  [96] phi()
  to:memset::@1
memset::@1: scope:[memset]  from memset memset::@2
  [97] memset::dst#2 = phi( memset/(char *)memset::str#0, memset::@2/memset::dst#1 )
  [98] if(memset::dst#2!=memset::end#0) goto memset::@2
  to:memset::@return
memset::@return: scope:[memset]  from memset::@1
  [99] return 
  to:@return
memset::@2: scope:[memset]  from memset::@1
  [100] *memset::dst#2 = memset::c#0
  [101] 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
  [102] 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 )
  [102] 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 )
  [103] *print_char_cursor#29 = print_char::ch#5
  [104] print_char_cursor#10 = ++ print_char_cursor#29
  to:print_char::@return
print_char::@return: scope:[print_char]  from print_char
  [105] return 
  to:@return

void print_uchar(char b)
print_uchar: scope:[print_uchar]  from print_schar::@2
  [106] print_uchar::$0 = print_uchar::b#0 >> 4
  [107] print_char::ch#3 = print_hextab[print_uchar::$0]
  [108] call print_char
  to:print_uchar::@1
print_uchar::@1: scope:[print_uchar]  from print_uchar
  [109] print_uchar::$2 = print_uchar::b#0 & $f
  [110] print_char::ch#4 = print_hextab[print_uchar::$2]
  [111] call print_char
  to:print_uchar::@return
print_uchar::@return: scope:[print_uchar]  from print_uchar::@1
  [112] return 
  to:@return

unsigned int divr16u(unsigned int dividend , unsigned int divisor , unsigned int rem)
divr16u: scope:[divr16u]  from div16u
  [113] phi()
  to:divr16u::@1
divr16u::@1: scope:[divr16u]  from divr16u divr16u::@3
  [114] divr16u::i#2 = phi( divr16u/0, divr16u::@3/divr16u::i#1 )
  [114] divr16u::quotient#3 = phi( divr16u/0, divr16u::@3/divr16u::return#0 )
  [114] divr16u::dividend#2 = phi( divr16u/PI2_u4f12, divr16u::@3/divr16u::dividend#0 )
  [114] divr16u::rem#4 = phi( divr16u/0, divr16u::@3/divr16u::rem#9 )
  [115] divr16u::rem#0 = divr16u::rem#4 << 1
  [116] divr16u::$1 = byte1  divr16u::dividend#2
  [117] divr16u::$2 = divr16u::$1 & $80
  [118] if(divr16u::$2==0) goto divr16u::@2
  to:divr16u::@4
divr16u::@4: scope:[divr16u]  from divr16u::@1
  [119] divr16u::rem#1 = divr16u::rem#0 | 1
  to:divr16u::@2
divr16u::@2: scope:[divr16u]  from divr16u::@1 divr16u::@4
  [120] divr16u::rem#5 = phi( divr16u::@1/divr16u::rem#0, divr16u::@4/divr16u::rem#1 )
  [121] divr16u::dividend#0 = divr16u::dividend#2 << 1
  [122] divr16u::quotient#1 = divr16u::quotient#3 << 1
  [123] if(divr16u::rem#5<wavelength) goto divr16u::@3
  to:divr16u::@5
divr16u::@5: scope:[divr16u]  from divr16u::@2
  [124] divr16u::quotient#2 = ++ divr16u::quotient#1
  [125] divr16u::rem#2 = divr16u::rem#5 - wavelength
  to:divr16u::@3
divr16u::@3: scope:[divr16u]  from divr16u::@2 divr16u::@5
  [126] divr16u::return#0 = phi( divr16u::@2/divr16u::quotient#1, divr16u::@5/divr16u::quotient#2 )
  [126] divr16u::rem#9 = phi( divr16u::@2/divr16u::rem#5, divr16u::@5/divr16u::rem#2 )
  [127] divr16u::i#1 = ++ divr16u::i#2
  [128] if(divr16u::i#1!=$10) goto divr16u::@1
  to:divr16u::@return
divr16u::@return: scope:[divr16u]  from divr16u::@3
  [129] 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
  [130] mulu8_sel::select#5 = phi( sin8s::@10/1, sin8s::@11/0, sin8s::@12/0, sin8s::@2/0, sin8s::@9/1 )
  [130] 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 )
  [130] 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 )
  [131] mul8u::a#0 = mulu8_sel::v1#5
  [132] mul8u::b#0 = mulu8_sel::v2#5
  [133] call mul8u
  [134] mul8u::return#0 = mul8u::res#2
  to:mulu8_sel::@1
mulu8_sel::@1: scope:[mulu8_sel]  from mulu8_sel
  [135] mulu8_sel::$0 = mul8u::return#0
  [136] mulu8_sel::$1 = mulu8_sel::$0 << mulu8_sel::select#5
  [137] mulu8_sel::return#12 = byte1  mulu8_sel::$1
  to:mulu8_sel::@return
mulu8_sel::@return: scope:[mulu8_sel]  from mulu8_sel::@1
  [138] return 
  to:@return

unsigned int mul8u(char a , char b)
mul8u: scope:[mul8u]  from mulu8_sel
  [139] mul8u::mb#0 = (unsigned int)mul8u::b#0
  to:mul8u::@1
mul8u::@1: scope:[mul8u]  from mul8u mul8u::@3
  [140] mul8u::mb#2 = phi( mul8u/mul8u::mb#0, mul8u::@3/mul8u::mb#1 )
  [140] mul8u::res#2 = phi( mul8u/0, mul8u::@3/mul8u::res#6 )
  [140] mul8u::a#2 = phi( mul8u/mul8u::a#0, mul8u::@3/mul8u::a#1 )
  [141] if(mul8u::a#2!=0) goto mul8u::@2
  to:mul8u::@return
mul8u::@return: scope:[mul8u]  from mul8u::@1
  [142] return 
  to:@return
mul8u::@2: scope:[mul8u]  from mul8u::@1
  [143] mul8u::$1 = mul8u::a#2 & 1
  [144] if(mul8u::$1==0) goto mul8u::@3
  to:mul8u::@4
mul8u::@4: scope:[mul8u]  from mul8u::@2
  [145] mul8u::res#1 = mul8u::res#2 + mul8u::mb#2
  to:mul8u::@3
mul8u::@3: scope:[mul8u]  from mul8u::@2 mul8u::@4
  [146] mul8u::res#6 = phi( mul8u::@2/mul8u::res#2, mul8u::@4/mul8u::res#1 )
  [147] mul8u::a#1 = mul8u::a#2 >> 1
  [148] mul8u::mb#1 = mul8u::mb#2 << 1
  to:mul8u::@1
