
void main()
main: scope:[main]  from
  [0] phi()
  [1] call print_cls
  to:main::@1
main::@1: scope:[main]  from main
  [2] *BG_COLOR = GREEN
  [3] call test_bytes
  to:main::@2
main::@2: scope:[main]  from main::@1
  [4] phi()
  [5] call test_sbytes
  to:main::@return
main::@return: scope:[main]  from main::@2
  [6] return 
  to:@return

void print_cls()
print_cls: scope:[print_cls]  from main
  [7] phi()
  [8] call memset
  to:print_cls::@return
print_cls::@return: scope:[print_cls]  from print_cls
  [9] return 
  to:@return

void test_bytes()
test_bytes: scope:[test_bytes]  from main::@1
  [10] phi()
  [11] call assert_byte
  to:test_bytes::@1
test_bytes::@1: scope:[test_bytes]  from test_bytes
  [12] print_char_cursor#98 = print_line_cursor#0
  [13] call assert_byte
  to:test_bytes::@2
test_bytes::@2: scope:[test_bytes]  from test_bytes::@1
  [14] print_char_cursor#99 = print_line_cursor#0
  [15] call assert_byte
  to:test_bytes::@return
test_bytes::@return: scope:[test_bytes]  from test_bytes::@2
  [16] return 
  to:@return

void test_sbytes()
test_sbytes: scope:[test_sbytes]  from main::@2
  [17] phi()
  [18] call assert_sbyte
  to:test_sbytes::@1
test_sbytes::@1: scope:[test_sbytes]  from test_sbytes
  [19] phi()
  [20] call assert_sbyte
  to:test_sbytes::@2
test_sbytes::@2: scope:[test_sbytes]  from test_sbytes::@1
  [21] phi()
  [22] call assert_sbyte
  to:test_sbytes::@3
test_sbytes::@3: scope:[test_sbytes]  from test_sbytes::@2
  [23] phi()
  [24] call assert_sbyte
  to:test_sbytes::@4
test_sbytes::@4: scope:[test_sbytes]  from test_sbytes::@3
  [25] phi()
  [26] call assert_sbyte
  to:test_sbytes::@return
test_sbytes::@return: scope:[test_sbytes]  from test_sbytes::@4
  [27] return 
  to:@return

void * memset(void *str , char c , unsigned int num)
memset: scope:[memset]  from print_cls
  [28] phi()
  to:memset::@1
memset::@1: scope:[memset]  from memset memset::@2
  [29] memset::dst#2 = phi( memset/(char *)memset::str#0, memset::@2/memset::dst#1 )
  [30] if(memset::dst#2!=memset::end#0) goto memset::@2
  to:memset::@return
memset::@return: scope:[memset]  from memset::@1
  [31] return 
  to:@return
memset::@2: scope:[memset]  from memset::@1
  [32] *memset::dst#2 = memset::c#0
  [33] memset::dst#1 = ++ memset::dst#2
  to:memset::@1

void assert_byte(char *msg , char b , char c)
assert_byte: scope:[assert_byte]  from test_bytes test_bytes::@1 test_bytes::@2
  [34] print_line_cursor#52 = phi( test_bytes/print_screen#0, test_bytes::@1/print_line_cursor#0, test_bytes::@2/print_line_cursor#0 )
  [34] assert_byte::c#3 = phi( test_bytes/0, test_bytes::@1/2, test_bytes::@2/$fe )
  [34] assert_byte::b#3 = phi( test_bytes/test_bytes::bb, test_bytes::@1/test_bytes::bc#0, test_bytes::@2/test_bytes::bd#0 )
  [34] print_char_cursor#77 = phi( test_bytes/print_screen#0, test_bytes::@1/print_char_cursor#98, test_bytes::@2/print_char_cursor#99 )
  [34] assert_byte::msg#3 = phi( test_bytes/msg, test_bytes::@1/msg1, test_bytes::@2/test_bytes::msg2 )
  [35] print_str::str#1 = assert_byte::msg#3
  [36] call print_str
  to:assert_byte::@4
assert_byte::@4: scope:[assert_byte]  from assert_byte
  [37] phi()
  [38] call print_str
  to:assert_byte::@5
assert_byte::@5: scope:[assert_byte]  from assert_byte::@4
  [39] if(assert_byte::b#3!=assert_byte::c#3) goto assert_byte::@1
  to:assert_byte::@3
assert_byte::@3: scope:[assert_byte]  from assert_byte::@5
  [40] phi()
  [41] call print_str
  to:assert_byte::@2
assert_byte::@2: scope:[assert_byte]  from assert_byte::@1 assert_byte::@3
  [42] phi()
  [43] call print_ln
  to:assert_byte::@return
assert_byte::@return: scope:[assert_byte]  from assert_byte::@2
  [44] return 
  to:@return
assert_byte::@1: scope:[assert_byte]  from assert_byte::@5
  [45] *BG_COLOR = RED
  [46] call print_str
  to:assert_byte::@2

void assert_sbyte(char *msg , signed char b , signed char c)
assert_sbyte: scope:[assert_sbyte]  from test_sbytes test_sbytes::@1 test_sbytes::@2 test_sbytes::@3 test_sbytes::@4
  [47] assert_sbyte::c#5 = phi( test_sbytes/0, test_sbytes::@1/2, test_sbytes::@2/-2, test_sbytes::@3/2, test_sbytes::@4/2 )
  [47] assert_sbyte::b#5 = phi( test_sbytes/test_sbytes::bb, test_sbytes::@1/test_sbytes::bc#0, test_sbytes::@2/test_sbytes::bd#0, test_sbytes::@3/test_sbytes::be#0, test_sbytes::@4/test_sbytes::bf )
  [47] assert_sbyte::msg#5 = phi( test_sbytes/msg, test_sbytes::@1/msg1, test_sbytes::@2/test_sbytes::msg2, test_sbytes::@3/test_sbytes::msg3, test_sbytes::@4/test_sbytes::msg4 )
  [48] print_str::str#5 = assert_sbyte::msg#5
  [49] print_char_cursor#92 = print_line_cursor#0
  [50] call print_str
  to:assert_sbyte::@4
assert_sbyte::@4: scope:[assert_sbyte]  from assert_sbyte
  [51] phi()
  [52] call print_str
  to:assert_sbyte::@5
assert_sbyte::@5: scope:[assert_sbyte]  from assert_sbyte::@4
  [53] if(assert_sbyte::b#5!=assert_sbyte::c#5) goto assert_sbyte::@1
  to:assert_sbyte::@3
assert_sbyte::@3: scope:[assert_sbyte]  from assert_sbyte::@5
  [54] phi()
  [55] call print_str
  to:assert_sbyte::@2
assert_sbyte::@2: scope:[assert_sbyte]  from assert_sbyte::@1 assert_sbyte::@3
  [56] phi()
  [57] call print_ln
  to:assert_sbyte::@return
assert_sbyte::@return: scope:[assert_sbyte]  from assert_sbyte::@2
  [58] return 
  to:@return
assert_sbyte::@1: scope:[assert_sbyte]  from assert_sbyte::@5
  [59] *BG_COLOR = RED
  [60] call print_str
  to:assert_sbyte::@2

void print_str(char *str)
print_str: scope:[print_str]  from assert_byte assert_byte::@1 assert_byte::@3 assert_byte::@4 assert_sbyte assert_sbyte::@1 assert_sbyte::@3 assert_sbyte::@4
  [61] print_char_cursor#87 = phi( assert_byte/print_char_cursor#77, assert_byte::@1/print_char_cursor#1, assert_byte::@3/print_char_cursor#1, assert_byte::@4/print_char_cursor#1, assert_sbyte/print_char_cursor#92, assert_sbyte::@1/print_char_cursor#1, assert_sbyte::@3/print_char_cursor#1, assert_sbyte::@4/print_char_cursor#1 )
  [61] print_str::str#12 = phi( assert_byte/print_str::str#1, assert_byte::@1/str1, assert_byte::@3/str2, assert_byte::@4/str, assert_sbyte/print_str::str#5, assert_sbyte::@1/str1, assert_sbyte::@3/str2, assert_sbyte::@4/str )
  to:print_str::@1
print_str::@1: scope:[print_str]  from print_str print_str::@3
  [62] print_char_cursor#1 = phi( print_str/print_char_cursor#87, print_str::@3/print_char_cursor#4 )
  [62] print_str::str#10 = phi( print_str/print_str::str#12, print_str::@3/print_str::str#0 )
  [63] if(0!=*print_str::str#10) goto print_str::@2
  to:print_str::@return
print_str::@return: scope:[print_str]  from print_str::@1
  [64] return 
  to:@return
print_str::@2: scope:[print_str]  from print_str::@1
  [65] print_char::ch#0 = *print_str::str#10
  [66] call print_char
  to:print_str::@3
print_str::@3: scope:[print_str]  from print_str::@2
  [67] print_str::str#0 = ++ print_str::str#10
  to:print_str::@1

void print_ln()
print_ln: scope:[print_ln]  from assert_byte::@2 assert_sbyte::@2
  [68] print_line_cursor#49 = phi( assert_byte::@2/print_line_cursor#52, assert_sbyte::@2/print_line_cursor#0 )
  to:print_ln::@1
print_ln::@1: scope:[print_ln]  from print_ln print_ln::@1
  [69] print_line_cursor#25 = phi( print_ln/print_line_cursor#49, print_ln::@1/print_line_cursor#0 )
  [70] print_line_cursor#0 = print_line_cursor#25 + $28
  [71] if(print_line_cursor#0<print_char_cursor#1) goto print_ln::@1
  to:print_ln::@return
print_ln::@return: scope:[print_ln]  from print_ln::@1
  [72] return 
  to:@return

void print_char(char ch)
print_char: scope:[print_char]  from print_str::@2
  [73] *print_char_cursor#1 = print_char::ch#0
  [74] print_char_cursor#4 = ++ print_char_cursor#1
  to:print_char::@return
print_char::@return: scope:[print_char]  from print_char
  [75] return 
  to:@return
