@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 print_cls 
  to:main::@1
main::@1: scope:[main]  from main main::@7
  [6] (byte*) print_line_cursor#28 ← phi( main/(byte*) 1024 main::@7/(byte*) print_line_cursor#23 )
  [6] (byte) main::s#7 ← phi( main/(byte) 0 main::@7/(byte) main::s#10 )
  [6] (byte*) print_char_cursor#81 ← phi( main/(byte*) 1024 main::@7/(byte*) print_char_cursor#72 )
  [6] (byte) main::i#2 ← phi( main/(byte) 0 main::@7/(byte) main::i#1 )
  [7] (byte~) main::$8 ← (byte) main::i#2 << (byte) 1
  [8] (signed word) main::w1#0 ← *((const signed word*) swords + (byte~) main::$8)
  to:main::@2
main::@2: scope:[main]  from main::@1 main::@6
  [9] (byte*) print_line_cursor#26 ← phi( main::@1/(byte*) print_line_cursor#28 main::@6/(byte*) print_line_cursor#23 )
  [9] (byte) main::s#5 ← phi( main::@1/(byte) main::s#7 main::@6/(byte) main::s#10 )
  [9] (byte*) print_char_cursor#71 ← phi( main::@1/(byte*) print_char_cursor#81 main::@6/(byte*) print_char_cursor#72 )
  [9] (byte) main::j#2 ← phi( main::@1/(byte) 0 main::@6/(byte) main::j#1 )
  [10] (byte~) main::$9 ← (byte) main::j#2 << (byte) 1
  [11] (signed word) main::w2#0 ← *((const signed word*) swords + (byte~) main::$9)
  to:main::@3
main::@3: scope:[main]  from main::@2 main::@4
  [12] (byte*) print_line_cursor#19 ← phi( main::@2/(byte*) print_line_cursor#26 main::@4/(byte*) print_line_cursor#23 )
  [12] (byte) main::s#3 ← phi( main::@2/(byte) main::s#5 main::@4/(byte) main::s#10 )
  [12] (byte*) print_char_cursor#64 ← phi( main::@2/(byte*) print_char_cursor#71 main::@4/(byte*) print_char_cursor#72 )
  [12] (byte) main::op#2 ← phi( main::@2/(byte) 0 main::@4/(byte) main::op#1 )
  [13] (signed word) compare::w1#0 ← (signed word) main::w1#0
  [14] (signed word) compare::w2#0 ← (signed word) main::w2#0
  [15] (byte) compare::op#0 ← (byte) main::op#2
  [16] call compare 
  to:main::@9
main::@9: scope:[main]  from main::@3
  [17] (byte) main::s#1 ← ++ (byte) main::s#3
  [18] if((byte) main::s#1!=(byte) 3) goto main::@4
  to:main::@5
main::@5: scope:[main]  from main::@9
  [19] phi()
  [20] call print_ln 
  to:main::@10
main::@10: scope:[main]  from main::@5
  [21] (byte*) print_char_cursor#115 ← (byte*) print_line_cursor#1
  to:main::@4
main::@4: scope:[main]  from main::@10 main::@9
  [22] (byte*) print_line_cursor#23 ← phi( main::@9/(byte*) print_line_cursor#19 main::@10/(byte*) print_line_cursor#1 )
  [22] (byte) main::s#10 ← phi( main::@9/(byte) main::s#1 main::@10/(byte) 0 )
  [22] (byte*) print_char_cursor#72 ← phi( main::@9/(byte*) print_char_cursor#15 main::@10/(byte*) print_char_cursor#115 )
  [23] (byte) main::op#1 ← ++ (byte) main::op#2
  [24] if((byte) main::op#1!=(byte) 6) goto main::@3
  to:main::@6
main::@6: scope:[main]  from main::@4
  [25] (byte) main::j#1 ← ++ (byte) main::j#2
  [26] if((byte) main::j#1!=(byte) 3) goto main::@2
  to:main::@7
main::@7: scope:[main]  from main::@6
  [27] (byte) main::i#1 ← ++ (byte) main::i#2
  [28] if((byte) main::i#1!=(byte) 3) goto main::@1
  to:main::@8
main::@8: scope:[main]  from main::@7 main::@8
  [29] phi()
  to:main::@8

(void()) print_ln()
print_ln: scope:[print_ln]  from main::@5
  [30] phi()
  to:print_ln::@1
print_ln::@1: scope:[print_ln]  from print_ln print_ln::@1
  [31] (byte*) print_line_cursor#9 ← phi( print_ln/(byte*) print_line_cursor#19 print_ln::@1/(byte*) print_line_cursor#1 )
  [32] (byte*) print_line_cursor#1 ← (byte*) print_line_cursor#9 + (byte) $28
  [33] if((byte*) print_line_cursor#1<(byte*) print_char_cursor#15) goto print_ln::@1
  to:print_ln::@return
print_ln::@return: scope:[print_ln]  from print_ln::@1
  [34] return 
  to:@return

(void()) compare((signed word) compare::w1 , (signed word) compare::w2 , (byte) compare::op)
compare: scope:[compare]  from main::@3
  [35] if((byte) compare::op#0==(const byte) LT) goto compare::@1
  to:compare::@7
compare::@7: scope:[compare]  from compare
  [36] if((byte) compare::op#0==(const byte) LE) goto compare::@2
  to:compare::@8
compare::@8: scope:[compare]  from compare::@7
  [37] if((byte) compare::op#0==(const byte) GT) goto compare::@3
  to:compare::@9
compare::@9: scope:[compare]  from compare::@8
  [38] if((byte) compare::op#0==(const byte) GE) goto compare::@4
  to:compare::@10
compare::@10: scope:[compare]  from compare::@9
  [39] if((byte) compare::op#0==(const byte) EQ) goto compare::@5
  to:compare::@11
compare::@11: scope:[compare]  from compare::@10
  [40] if((byte) compare::op#0!=(const byte) NE) goto compare::@6
  to:compare::@12
compare::@12: scope:[compare]  from compare::@11
  [41] if((signed word) compare::w1#0==(signed word) compare::w2#0) goto compare::@19
  to:compare::@13
compare::@13: scope:[compare]  from compare::@12
  [42] phi()
  to:compare::@19
compare::@19: scope:[compare]  from compare::@12 compare::@13
  [43] (byte) compare::r#12 ← phi( compare::@12/(const byte) FF compare::@13/(const byte) TT )
  to:compare::@6
compare::@6: scope:[compare]  from compare::@11 compare::@19 compare::@20 compare::@21 compare::@22 compare::@23 compare::@24
  [44] (byte) compare::r#10 ← phi( compare::@11/(const byte) FF compare::@19/(byte) compare::r#12 compare::@20/(byte) compare::r#13 compare::@21/(byte) compare::r#14 compare::@22/(byte) compare::r#15 compare::@23/(byte) compare::r#16 compare::@24/(byte) compare::r#17 )
  [44] (byte*) compare::ops#7 ← phi( compare::@11/(byte*) 0 compare::@19/(const byte*) compare::ops#1 compare::@20/(const byte*) compare::ops#2 compare::@21/(const byte*) compare::ops#3 compare::@22/(const byte*) compare::ops#4 compare::@23/(const byte*) compare::ops#5 compare::@24/(const byte*) compare::ops#6 )
  [45] (signed word) print_sword::w#1 ← (signed word) compare::w1#0
  [46] call print_sword 
  to:compare::@25
compare::@25: scope:[compare]  from compare::@6
  [47] (byte*) print_str::str#1 ← (byte*) compare::ops#7
  [48] call print_str 
  to:compare::@26
compare::@26: scope:[compare]  from compare::@25
  [49] (signed word) print_sword::w#2 ← (signed word) compare::w2#0
  [50] call print_sword 
  to:compare::@27
compare::@27: scope:[compare]  from compare::@26
  [51] (byte) print_char::ch#4 ← (byte) compare::r#10
  [52] call print_char 
  to:compare::@return
compare::@return: scope:[compare]  from compare::@27
  [53] return 
  to:@return
compare::@5: scope:[compare]  from compare::@10
  [54] if((signed word) compare::w1#0!=(signed word) compare::w2#0) goto compare::@20
  to:compare::@14
compare::@14: scope:[compare]  from compare::@5
  [55] phi()
  to:compare::@20
compare::@20: scope:[compare]  from compare::@14 compare::@5
  [56] (byte) compare::r#13 ← phi( compare::@14/(const byte) TT compare::@5/(const byte) FF )
  to:compare::@6
compare::@4: scope:[compare]  from compare::@9
  [57] if((signed word) compare::w1#0<(signed word) compare::w2#0) goto compare::@21
  to:compare::@15
compare::@15: scope:[compare]  from compare::@4
  [58] phi()
  to:compare::@21
compare::@21: scope:[compare]  from compare::@15 compare::@4
  [59] (byte) compare::r#14 ← phi( compare::@15/(const byte) TT compare::@4/(const byte) FF )
  to:compare::@6
compare::@3: scope:[compare]  from compare::@8
  [60] if((signed word) compare::w1#0<=(signed word) compare::w2#0) goto compare::@22
  to:compare::@16
compare::@16: scope:[compare]  from compare::@3
  [61] phi()
  to:compare::@22
compare::@22: scope:[compare]  from compare::@16 compare::@3
  [62] (byte) compare::r#15 ← phi( compare::@16/(const byte) TT compare::@3/(const byte) FF )
  to:compare::@6
compare::@2: scope:[compare]  from compare::@7
  [63] if((signed word) compare::w1#0>(signed word) compare::w2#0) goto compare::@23
  to:compare::@17
compare::@17: scope:[compare]  from compare::@2
  [64] phi()
  to:compare::@23
compare::@23: scope:[compare]  from compare::@17 compare::@2
  [65] (byte) compare::r#16 ← phi( compare::@2/(const byte) FF compare::@17/(const byte) TT )
  to:compare::@6
compare::@1: scope:[compare]  from compare
  [66] if((signed word) compare::w1#0>=(signed word) compare::w2#0) goto compare::@24
  to:compare::@18
compare::@18: scope:[compare]  from compare::@1
  [67] phi()
  to:compare::@24
compare::@24: scope:[compare]  from compare::@1 compare::@18
  [68] (byte) compare::r#17 ← phi( compare::@1/(const byte) FF compare::@18/(const byte) TT )
  to:compare::@6

(void()) print_char((byte) print_char::ch)
print_char: scope:[print_char]  from compare::@27 print_byte print_byte::@1 print_sword::@1 print_sword::@3
  [69] (byte*) print_char_cursor#43 ← phi( compare::@27/(byte*) print_char_cursor#15 print_byte/(byte*) print_char_cursor#15 print_byte::@1/(byte*) print_char_cursor#15 print_sword::@1/(byte*) print_char_cursor#58 print_sword::@3/(byte*) print_char_cursor#58 )
  [69] (byte) print_char::ch#5 ← phi( compare::@27/(byte) print_char::ch#4 print_byte/(byte) print_char::ch#2 print_byte::@1/(byte) print_char::ch#3 print_sword::@1/(byte) '-' print_sword::@3/(byte) ' ' )
  [70] *((byte*) print_char_cursor#43) ← (byte) print_char::ch#5
  [71] (byte*) print_char_cursor#15 ← ++ (byte*) print_char_cursor#43
  to:print_char::@return
print_char::@return: scope:[print_char]  from print_char
  [72] return 
  to:@return

(void()) print_sword((signed word) print_sword::w)
print_sword: scope:[print_sword]  from compare::@26 compare::@6
  [73] (byte*) print_char_cursor#58 ← phi( compare::@6/(byte*) print_char_cursor#64 compare::@26/(byte*) print_char_cursor#2 )
  [73] (signed word) print_sword::w#3 ← phi( compare::@6/(signed word) print_sword::w#1 compare::@26/(signed word) print_sword::w#2 )
  [74] if((signed word) print_sword::w#3<(signed byte) 0) goto print_sword::@1
  to:print_sword::@3
print_sword::@3: scope:[print_sword]  from print_sword
  [75] phi()
  [76] call print_char 
  to:print_sword::@2
print_sword::@2: scope:[print_sword]  from print_sword::@3 print_sword::@4
  [77] (signed word) print_sword::w#5 ← phi( print_sword::@4/(signed word) print_sword::w#0 print_sword::@3/(signed word) print_sword::w#3 )
  [78] (word) print_word::w#0 ← (word)(signed word) print_sword::w#5
  [79] call print_word 
  to:print_sword::@return
print_sword::@return: scope:[print_sword]  from print_sword::@2
  [80] return 
  to:@return
print_sword::@1: scope:[print_sword]  from print_sword
  [81] phi()
  [82] call print_char 
  to:print_sword::@4
print_sword::@4: scope:[print_sword]  from print_sword::@1
  [83] (signed word) print_sword::w#0 ← - (signed word) print_sword::w#3
  to:print_sword::@2

(void()) print_word((word) print_word::w)
print_word: scope:[print_word]  from print_sword::@2
  [84] (byte) print_byte::b#0 ← > (word) print_word::w#0
  [85] call print_byte 
  to:print_word::@1
print_word::@1: scope:[print_word]  from print_word
  [86] (byte) print_byte::b#1 ← < (word) print_word::w#0
  [87] call print_byte 
  to:print_word::@return
print_word::@return: scope:[print_word]  from print_word::@1
  [88] return 
  to:@return

(void()) print_byte((byte) print_byte::b)
print_byte: scope:[print_byte]  from print_word print_word::@1
  [89] (byte) print_byte::b#2 ← phi( print_word/(byte) print_byte::b#0 print_word::@1/(byte) print_byte::b#1 )
  [90] (byte~) print_byte::$0 ← (byte) print_byte::b#2 >> (byte) 4
  [91] (byte) print_char::ch#2 ← *((const byte*) print_hextab + (byte~) print_byte::$0)
  [92] call print_char 
  to:print_byte::@1
print_byte::@1: scope:[print_byte]  from print_byte
  [93] (byte~) print_byte::$2 ← (byte) print_byte::b#2 & (byte) $f
  [94] (byte) print_char::ch#3 ← *((const byte*) print_hextab + (byte~) print_byte::$2)
  [95] call print_char 
  to:print_byte::@return
print_byte::@return: scope:[print_byte]  from print_byte::@1
  [96] return 
  to:@return

(void()) print_str((byte*) print_str::str)
print_str: scope:[print_str]  from compare::@25
  [97] phi()
  to:print_str::@1
print_str::@1: scope:[print_str]  from print_str print_str::@2
  [98] (byte*) print_char_cursor#2 ← phi( print_str/(byte*) print_char_cursor#15 print_str::@2/(byte*) print_char_cursor#1 )
  [98] (byte*) print_str::str#2 ← phi( print_str/(byte*) print_str::str#1 print_str::@2/(byte*) print_str::str#0 )
  [99] 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
  [100] return 
  to:@return
print_str::@2: scope:[print_str]  from print_str::@1
  [101] *((byte*) print_char_cursor#2) ← *((byte*) print_str::str#2)
  [102] (byte*) print_char_cursor#1 ← ++ (byte*) print_char_cursor#2
  [103] (byte*) print_str::str#0 ← ++ (byte*) print_str::str#2
  to:print_str::@1

(void()) print_cls()
print_cls: scope:[print_cls]  from main
  [104] phi()
  [105] call memset 
  to:print_cls::@return
print_cls::@return: scope:[print_cls]  from print_cls
  [106] return 
  to:@return

(void*()) memset((void*) memset::str , (byte) memset::c , (word) memset::num)
memset: scope:[memset]  from print_cls
  [107] phi()
  to:memset::@1
memset::@1: scope:[memset]  from memset memset::@2
  [108] (byte*) memset::dst#2 ← phi( memset/(byte*)(const void*) memset::str#0 memset::@2/(byte*) memset::dst#1 )
  [109] if((byte*) memset::dst#2!=(const byte*) memset::end#0) goto memset::@2
  to:memset::@return
memset::@return: scope:[memset]  from memset::@1
  [110] return 
  to:@return
memset::@2: scope:[memset]  from memset::@1
  [111] *((byte*) memset::dst#2) ← (const byte) memset::c#0
  [112] (byte*) memset::dst#1 ← ++ (byte*) memset::dst#2
  to:memset::@1
