@begin: scope:[]  from
  [0] phi()
  to:@1
@1: scope:[]  from @begin
  [1] phi()
  [2] call main 
  to:@end
@end: scope:[]  from @1
  [3] phi()

(signed word()) main()
main: scope:[main]  from @1
  [4] *((const byte*) VICBANK) ← (byte) $17
  [5] *((const byte*) zp1) ← (byte) 0
  to:main::@1
main::@1: scope:[main]  from main main::@14
  [6] (word) main::v#12 ← phi( main/(word) 0 main::@14/(word) main::v#11 )
  [6] (word) main::u#15 ← phi( main/(word) $6e85 main::@14/(word) main::u#3 )
  [7] if(*((const byte*) zp1)<(byte) $a) goto main::@2
  to:main::@3
main::@3: scope:[main]  from main::@1
  [8] *((const byte*) zp1) ← (byte) 0
  to:main::@7
main::@7: scope:[main]  from main::@17 main::@3
  [9] (word) main::v#10 ← phi( main::@3/(word) main::v#12 main::@17/(word) main::v#13 )
  [9] (word) main::u#17 ← phi( main::@3/(word) $6e85 main::@17/(word) main::u#4 )
  [10] if(*((const byte*) zp1)<(byte) $a) goto main::@8
  to:main::@return
main::@return: scope:[main]  from main::@7
  [11] return 
  to:@return
main::@8: scope:[main]  from main::@7
  [12] *((const byte*) TIMEHI) ← (byte) 0
  [13] *((const byte*) TIMELO) ← (byte) 0
  [14] *((const byte*) zp2) ← (byte) 0
  to:main::@9
main::@9: scope:[main]  from main::@15 main::@8
  [15] (word) main::v#13 ← phi( main::@8/(word) main::v#10 main::@15/(word) main::v#2 )
  [16] if(*((const byte*) zp2)<(byte) $c8) goto main::@10
  to:main::@11
main::@11: scope:[main]  from main::@9
  [17] (word~) main::$12 ← (word)*((const byte*) TIMEHI)
  [18] (word~) main::$13 ← (word~) main::$12 << (byte) 8
  [19] (word~) main::$14 ← (word)*((const byte*) TIMELO)
  [20] (word) myprintf::w3#1 ← (word~) main::$13 + (word~) main::$14
  [21] (word) myprintf::w1#1 ← (word) main::u#17
  [22] (word) myprintf::w2#1 ← (word) main::v#13
  [23] call myprintf 
  to:main::@16
main::@16: scope:[main]  from main::@11
  [24] phi()
  [25] call Print 
  to:main::@17
main::@17: scope:[main]  from main::@16
  [26] (word) main::u#4 ← (word) main::u#17 - (word) $4d2
  [27] *((const byte*) zp1) ← ++ *((const byte*) zp1)
  to:main::@7
main::@10: scope:[main]  from main::@9
  [28] (word) div10::val#4 ← (word) main::u#17
  [29] call div10 
  [30] (word) div10::return#2 ← (word) div10::return#0
  to:main::@15
main::@15: scope:[main]  from main::@10
  [31] (word) main::v#2 ← (word) div10::return#2
  [32] *((const byte*) zp2) ← ++ *((const byte*) zp2)
  to:main::@9
main::@2: scope:[main]  from main::@1
  [33] *((const byte*) TIMEHI) ← (byte) 0
  [34] *((const byte*) TIMELO) ← (byte) 0
  [35] *((const byte*) zp2) ← (byte) 0
  to:main::@4
main::@4: scope:[main]  from main::@12 main::@2
  [36] (word) main::v#11 ← phi( main::@2/(word) main::v#12 main::@12/(word) main::v#1 )
  [37] if(*((const byte*) zp2)<(byte) $c8) goto main::@5
  to:main::@6
main::@6: scope:[main]  from main::@4
  [38] (word~) main::$3 ← (word)*((const byte*) TIMEHI)
  [39] (word~) main::$4 ← (word~) main::$3 << (byte) 8
  [40] (word~) main::$5 ← (word)*((const byte*) TIMELO)
  [41] (word) myprintf::w3#0 ← (word~) main::$4 + (word~) main::$5
  [42] (word) myprintf::w1#0 ← (word) main::u#15
  [43] (word) myprintf::w2#0 ← (word) main::v#11
  [44] call myprintf 
  to:main::@13
main::@13: scope:[main]  from main::@6
  [45] phi()
  [46] call Print 
  to:main::@14
main::@14: scope:[main]  from main::@13
  [47] (word) main::u#3 ← (word) main::u#15 - (word) $4d2
  [48] *((const byte*) zp1) ← ++ *((const byte*) zp1)
  to:main::@1
main::@5: scope:[main]  from main::@4
  [49] (word) div16u::dividend#0 ← (word) main::u#15
  [50] call div16u 
  [51] (word) div16u::return#2 ← (word) div16u::return#0
  to:main::@12
main::@12: scope:[main]  from main::@5
  [52] (word) main::v#1 ← (word) div16u::return#2
  [53] *((const byte*) zp2) ← ++ *((const byte*) zp2)
  to:main::@4

(word()) div16u((word) div16u::dividend , (word) div16u::divisor)
div16u: scope:[div16u]  from main::@5
  [54] (word) divr16u::dividend#1 ← (word) div16u::dividend#0
  [55] call divr16u 
  [56] (word) divr16u::return#2 ← (word) divr16u::return#0
  to:div16u::@1
div16u::@1: scope:[div16u]  from div16u
  [57] (word) div16u::return#0 ← (word) divr16u::return#2
  to:div16u::@return
div16u::@return: scope:[div16u]  from div16u::@1
  [58] return 
  to:@return

(word()) divr16u((word) divr16u::dividend , (word) divr16u::divisor , (word) divr16u::rem)
divr16u: scope:[divr16u]  from div16u
  [59] phi()
  to:divr16u::@1
divr16u::@1: scope:[divr16u]  from divr16u divr16u::@3
  [60] (byte) divr16u::i#2 ← phi( divr16u/(byte) 0 divr16u::@3/(byte) divr16u::i#1 )
  [60] (word) divr16u::quotient#3 ← phi( divr16u/(byte) 0 divr16u::@3/(word) divr16u::return#0 )
  [60] (word) divr16u::dividend#2 ← phi( divr16u/(word) divr16u::dividend#1 divr16u::@3/(word) divr16u::dividend#0 )
  [60] (word) divr16u::rem#4 ← phi( divr16u/(byte) 0 divr16u::@3/(word) divr16u::rem#9 )
  [61] (word) divr16u::rem#0 ← (word) divr16u::rem#4 << (byte) 1
  [62] (byte~) divr16u::$1 ← > (word) divr16u::dividend#2
  [63] (byte~) divr16u::$2 ← (byte~) divr16u::$1 & (byte) $80
  [64] if((byte~) divr16u::$2==(byte) 0) goto divr16u::@2
  to:divr16u::@4
divr16u::@4: scope:[divr16u]  from divr16u::@1
  [65] (word) divr16u::rem#1 ← (word) divr16u::rem#0 | (byte) 1
  to:divr16u::@2
divr16u::@2: scope:[divr16u]  from divr16u::@1 divr16u::@4
  [66] (word) divr16u::rem#5 ← phi( divr16u::@1/(word) divr16u::rem#0 divr16u::@4/(word) divr16u::rem#1 )
  [67] (word) divr16u::dividend#0 ← (word) divr16u::dividend#2 << (byte) 1
  [68] (word) divr16u::quotient#1 ← (word) divr16u::quotient#3 << (byte) 1
  [69] if((word) divr16u::rem#5<(const word) div16u::divisor#0) goto divr16u::@3
  to:divr16u::@5
divr16u::@5: scope:[divr16u]  from divr16u::@2
  [70] (word) divr16u::quotient#2 ← ++ (word) divr16u::quotient#1
  [71] (word) divr16u::rem#2 ← (word) divr16u::rem#5 - (const word) div16u::divisor#0
  to:divr16u::@3
divr16u::@3: scope:[divr16u]  from divr16u::@2 divr16u::@5
  [72] (word) divr16u::return#0 ← phi( divr16u::@2/(word) divr16u::quotient#1 divr16u::@5/(word) divr16u::quotient#2 )
  [72] (word) divr16u::rem#9 ← phi( divr16u::@2/(word) divr16u::rem#5 divr16u::@5/(word) divr16u::rem#2 )
  [73] (byte) divr16u::i#1 ← ++ (byte) divr16u::i#2
  [74] if((byte) divr16u::i#1!=(byte) $10) goto divr16u::@1
  to:divr16u::@return
divr16u::@return: scope:[divr16u]  from divr16u::@3
  [75] return 
  to:@return

(void()) Print()
Print: scope:[Print]  from main::@13 main::@16
  asm { ldy#0 loop: ldastrTemp,y beqdone jsr$FFD2 iny jmploop done:  }
  to:Print::@return
Print::@return: scope:[Print]  from Print
  [77] return 
  to:@return

(byte()) myprintf((byte*) myprintf::dst , (byte*) myprintf::str , (word) myprintf::w1 , (word) myprintf::w2 , (word) myprintf::w3)
myprintf: scope:[myprintf]  from main::@11 main::@6
  [78] (word) myprintf::w3#8 ← phi( main::@11/(word) myprintf::w3#1 main::@6/(word) myprintf::w3#0 )
  [78] (word) myprintf::w2#8 ← phi( main::@11/(word) myprintf::w2#1 main::@6/(word) myprintf::w2#0 )
  [78] (word) myprintf::w1#7 ← phi( main::@11/(word) myprintf::w1#1 main::@6/(word) myprintf::w1#0 )
  [78] (byte*) myprintf::str#6 ← phi( main::@11/(const string) main::str1 main::@6/(const string) main::str )
  to:myprintf::@1
myprintf::@1: scope:[myprintf]  from myprintf myprintf::@32
  [79] (byte) myprintf::bLeadZero#11 ← phi( myprintf/(byte) 0 myprintf::@32/(byte) myprintf::bLeadZero#20 )
  [79] (byte) myprintf::bDigits#16 ← phi( myprintf/(byte) 0 myprintf::@32/(byte) myprintf::bDigits#28 )
  [79] (byte) myprintf::bTrailing#11 ← phi( myprintf/(byte) 0 myprintf::@32/(byte) myprintf::bTrailing#24 )
  [79] (word) myprintf::w#10 ← phi( myprintf/(word) 0 myprintf::@32/(word) myprintf::w#18 )
  [79] (byte) myprintf::bArg#10 ← phi( myprintf/(byte) 0 myprintf::@32/(byte) myprintf::bArg#11 )
  [79] (byte) myprintf::bLen#10 ← phi( myprintf/(byte) 0 myprintf::@32/(byte) myprintf::bLen#28 )
  [79] (byte) myprintf::bFormat#10 ← phi( myprintf/(byte) 0 myprintf::@32/(byte) myprintf::bFormat#5 )
  [79] (byte*) myprintf::str#10 ← phi( myprintf/(byte*) myprintf::str#6 myprintf::@32/(byte*) myprintf::str#0 )
  [80] if(*((byte*) myprintf::str#10)!=(byte) 0) goto myprintf::@2
  to:myprintf::@3
myprintf::@3: scope:[myprintf]  from myprintf::@1
  [81] *((const byte[$64]) strTemp + (byte) myprintf::bLen#10) ← (byte) 0
  to:myprintf::@return
myprintf::@return: scope:[myprintf]  from myprintf::@3
  [82] return 
  to:@return
myprintf::@2: scope:[myprintf]  from myprintf::@1
  [83] (byte) myprintf::b#1 ← *((byte*) myprintf::str#10)
  [84] if((byte) myprintf::bFormat#10==(byte) 0) goto myprintf::@4
  to:myprintf::@38
myprintf::@38: scope:[myprintf]  from myprintf::@2
  [85] if((byte) myprintf::b#1!=(byte) '0') goto myprintf::@5
  to:myprintf::@32
myprintf::@32: scope:[myprintf]  from myprintf::@27 myprintf::@28 myprintf::@36 myprintf::@37 myprintf::@38 myprintf::@6
  [86] (byte) myprintf::bLeadZero#20 ← phi( myprintf::@27/(byte) myprintf::bLeadZero#11 myprintf::@28/(byte) myprintf::bLeadZero#11 myprintf::@6/(byte) myprintf::bLeadZero#11 myprintf::@36/(byte) 0 myprintf::@37/(byte) myprintf::bLeadZero#11 myprintf::@38/(byte) 1 )
  [86] (byte) myprintf::bDigits#28 ← phi( myprintf::@27/(byte) myprintf::bDigits#29 myprintf::@28/(byte) myprintf::bDigits#1 myprintf::@6/(byte) myprintf::bDigits#16 myprintf::@36/(byte) 1 myprintf::@37/(byte) myprintf::bDigits#16 myprintf::@38/(byte) myprintf::bDigits#16 )
  [86] (byte) myprintf::bTrailing#24 ← phi( myprintf::@27/(byte) myprintf::bTrailing#11 myprintf::@28/(byte) myprintf::bTrailing#11 myprintf::@6/(byte) 1 myprintf::@36/(byte) 0 myprintf::@37/(byte) myprintf::bTrailing#11 myprintf::@38/(byte) myprintf::bTrailing#11 )
  [86] (word) myprintf::w#18 ← phi( myprintf::@27/(word) myprintf::w#10 myprintf::@28/(word) myprintf::w#10 myprintf::@6/(word) myprintf::w#10 myprintf::@36/(word) myprintf::w#22 myprintf::@37/(word) myprintf::w#10 myprintf::@38/(word) myprintf::w#10 )
  [86] (byte) myprintf::bArg#11 ← phi( myprintf::@27/(byte) myprintf::bArg#10 myprintf::@28/(byte) myprintf::bArg#10 myprintf::@6/(byte) myprintf::bArg#10 myprintf::@36/(byte) myprintf::bArg#1 myprintf::@37/(byte) myprintf::bArg#10 myprintf::@38/(byte) myprintf::bArg#10 )
  [86] (byte) myprintf::bLen#28 ← phi( myprintf::@27/(byte) myprintf::bLen#36 myprintf::@28/(byte) myprintf::bLen#10 myprintf::@6/(byte) myprintf::bLen#10 myprintf::@36/(byte) myprintf::bLen#10 myprintf::@37/(byte) myprintf::bLen#7 myprintf::@38/(byte) myprintf::bLen#10 )
  [86] (byte) myprintf::bFormat#5 ← phi( myprintf::@27/(byte) 0 myprintf::@28/(byte) myprintf::bFormat#10 myprintf::@6/(byte) myprintf::bFormat#10 myprintf::@36/(byte) 1 myprintf::@37/(byte) myprintf::bFormat#10 myprintf::@38/(byte) myprintf::bFormat#10 )
  [87] (byte*) myprintf::str#0 ← ++ (byte*) myprintf::str#10
  to:myprintf::@1
myprintf::@5: scope:[myprintf]  from myprintf::@38
  [88] if((byte) myprintf::b#1<(byte) '1') goto myprintf::@6
  to:myprintf::@43
myprintf::@43: scope:[myprintf]  from myprintf::@5
  [89] if((byte) myprintf::b#1<=(byte) '9') goto myprintf::@28
  to:myprintf::@6
myprintf::@6: scope:[myprintf]  from myprintf::@43 myprintf::@5
  [90] if((byte) myprintf::b#1!=(byte) '-') goto myprintf::@7
  to:myprintf::@32
myprintf::@7: scope:[myprintf]  from myprintf::@6
  [91] if((byte) myprintf::b#1==(byte) 'c') goto myprintf::@8
  to:myprintf::@29
myprintf::@29: scope:[myprintf]  from myprintf::@7
  [92] if((byte) myprintf::b#1==(byte) 'd') goto myprintf::@9
  to:myprintf::@30
myprintf::@30: scope:[myprintf]  from myprintf::@29
  [93] if((byte) myprintf::b#1==(byte) 'x') goto myprintf::@31
  to:myprintf::@44
myprintf::@44: scope:[myprintf]  from myprintf::@30
  [94] if((byte) myprintf::b#1==(byte) 'X') goto myprintf::@31
  to:myprintf::@27
myprintf::@27: scope:[myprintf]  from myprintf::@13 myprintf::@24 myprintf::@25 myprintf::@44 myprintf::@46 myprintf::@8
  [95] (byte) myprintf::bDigits#29 ← phi( myprintf::@13/(byte) myprintf::bDigits#16 myprintf::@24/(byte) myprintf::bDigits#18 myprintf::@25/(byte) myprintf::bDigits#10 myprintf::@44/(byte) myprintf::bDigits#16 myprintf::@8/(byte) myprintf::bDigits#16 )
  [95] (byte) myprintf::bLen#36 ← phi( myprintf::@13/(byte) myprintf::bLen#3 myprintf::@24/(byte) myprintf::bLen#13 myprintf::@25/(byte) myprintf::bLen#14 myprintf::@44/(byte) myprintf::bLen#10 myprintf::@8/(byte) myprintf::bLen#1 )
  to:myprintf::@32
myprintf::@31: scope:[myprintf]  from myprintf::@30 myprintf::@44
  [96] (byte~) myprintf::$18 ← (byte)(word) myprintf::w#10
  [97] (byte~) myprintf::$19 ← (byte~) myprintf::$18 >> (byte) 4
  [98] (byte) myprintf::b#15 ← (byte~) myprintf::$19 & (byte) $f
  [99] if((byte) myprintf::b#15<(byte) $a) goto myprintf::@10
  to:myprintf::@11
myprintf::@10: scope:[myprintf]  from myprintf::@31
  [100] phi()
  to:myprintf::@11
myprintf::@11: scope:[myprintf]  from myprintf::@10 myprintf::@31
  [101] (byte~) myprintf::$24 ← phi( myprintf::@10/(byte) '0' myprintf::@31/(byte) $57 )
  [102] (byte~) myprintf::$25 ← (byte~) myprintf::$24 + (byte) myprintf::b#15
  [103] *((const byte[$64]) strTemp + (byte) myprintf::bLen#10) ← (byte~) myprintf::$25
  [104] (byte) myprintf::bLen#11 ← ++ (byte) myprintf::bLen#10
  [105] (byte~) myprintf::$26 ← (byte)(word) myprintf::w#10
  [106] (byte) myprintf::b#16 ← (byte~) myprintf::$26 & (byte) $f
  [107] if((byte) myprintf::b#16<(byte) $a) goto myprintf::@12
  to:myprintf::@13
myprintf::@12: scope:[myprintf]  from myprintf::@11
  [108] phi()
  to:myprintf::@13
myprintf::@13: scope:[myprintf]  from myprintf::@11 myprintf::@12
  [109] (byte~) myprintf::$31 ← phi( myprintf::@12/(byte) '0' myprintf::@11/(byte) $57 )
  [110] (byte~) myprintf::$32 ← (byte~) myprintf::$31 + (byte) myprintf::b#16
  [111] *((const byte[$64]) strTemp + (byte) myprintf::bLen#11) ← (byte~) myprintf::$32
  [112] (byte) myprintf::bLen#3 ← ++ (byte) myprintf::bLen#11
  to:myprintf::@27
myprintf::@9: scope:[myprintf]  from myprintf::@29
  [113] (word) utoa::value#4 ← (word) myprintf::w#10
  [114] call utoa 
  to:myprintf::@14
myprintf::@14: scope:[myprintf]  from myprintf::@15 myprintf::@9
  [115] (byte) myprintf::b#17 ← phi( myprintf::@15/(byte) myprintf::b#5 myprintf::@9/(byte) 1 )
  [116] if(*((const byte[6]) myprintf::buf6 + (byte) myprintf::b#17)!=(byte) 0) goto myprintf::@15
  to:myprintf::@16
myprintf::@16: scope:[myprintf]  from myprintf::@14
  [117] if((byte) myprintf::bTrailing#11!=(byte) 0) goto myprintf::@17
  to:myprintf::@45
myprintf::@45: scope:[myprintf]  from myprintf::@16
  [118] if((byte) myprintf::bDigits#16<=(byte) myprintf::b#17) goto myprintf::@17
  to:myprintf::@18
myprintf::@18: scope:[myprintf]  from myprintf::@21 myprintf::@45
  [119] (byte) myprintf::bLen#12 ← phi( myprintf::@45/(byte) myprintf::bLen#10 myprintf::@21/(byte) myprintf::bLen#4 )
  [119] (byte) myprintf::bDigits#12 ← phi( myprintf::@45/(byte) myprintf::bDigits#16 myprintf::@21/(byte) myprintf::bDigits#2 )
  [120] if((byte) myprintf::bDigits#12>(byte) myprintf::b#17) goto myprintf::@19
  to:myprintf::@17
myprintf::@17: scope:[myprintf]  from myprintf::@16 myprintf::@18 myprintf::@45
  [121] (byte) myprintf::bDigits#18 ← phi( myprintf::@16/(byte) myprintf::bDigits#16 myprintf::@18/(byte) myprintf::bDigits#12 )
  [121] (byte) myprintf::bLen#32 ← phi( myprintf::@16/(byte) myprintf::bLen#10 myprintf::@18/(byte) myprintf::bLen#12 )
  to:myprintf::@22
myprintf::@22: scope:[myprintf]  from myprintf::@17 myprintf::@23
  [122] (byte) myprintf::bLen#13 ← phi( myprintf::@17/(byte) myprintf::bLen#32 myprintf::@23/(byte) myprintf::bLen#5 )
  [122] (byte) myprintf::digit#3 ← phi( myprintf::@17/(byte) 0 myprintf::@23/(byte) myprintf::digit#2 )
  [123] if((byte) myprintf::digit#3<(byte) myprintf::b#17) goto myprintf::@23
  to:myprintf::@24
myprintf::@24: scope:[myprintf]  from myprintf::@22
  [124] if((byte) myprintf::bTrailing#11==(byte) 0) goto myprintf::@27
  to:myprintf::@46
myprintf::@46: scope:[myprintf]  from myprintf::@24
  [125] if((byte) myprintf::bDigits#18<=(byte) myprintf::b#17) goto myprintf::@27
  to:myprintf::@25
myprintf::@25: scope:[myprintf]  from myprintf::@26 myprintf::@46
  [126] (byte) myprintf::bLen#14 ← phi( myprintf::@46/(byte) myprintf::bLen#13 myprintf::@26/(byte) myprintf::bLen#6 )
  [126] (byte) myprintf::bDigits#10 ← phi( myprintf::@46/(byte) myprintf::bDigits#18 myprintf::@26/(byte) myprintf::bDigits#3 )
  [127] if((byte) myprintf::bDigits#10>(byte) myprintf::b#17) goto myprintf::@26
  to:myprintf::@27
myprintf::@26: scope:[myprintf]  from myprintf::@25
  [128] *((const byte[$64]) strTemp + (byte) myprintf::bLen#14) ← (byte) ' '
  [129] (byte) myprintf::bLen#6 ← ++ (byte) myprintf::bLen#14
  [130] (byte) myprintf::bDigits#3 ← -- (byte) myprintf::bDigits#10
  to:myprintf::@25
myprintf::@23: scope:[myprintf]  from myprintf::@22
  [131] *((const byte[$64]) strTemp + (byte) myprintf::bLen#13) ← *((const byte[6]) myprintf::buf6 + (byte) myprintf::digit#3)
  [132] (byte) myprintf::bLen#5 ← ++ (byte) myprintf::bLen#13
  [133] (byte) myprintf::digit#2 ← ++ (byte) myprintf::digit#3
  to:myprintf::@22
myprintf::@19: scope:[myprintf]  from myprintf::@18
  [134] if((byte) myprintf::bLeadZero#11==(byte) 0) goto myprintf::@20
  to:myprintf::@21
myprintf::@20: scope:[myprintf]  from myprintf::@19
  [135] phi()
  to:myprintf::@21
myprintf::@21: scope:[myprintf]  from myprintf::@19 myprintf::@20
  [136] (byte~) myprintf::$43 ← phi( myprintf::@20/(byte) ' ' myprintf::@19/(byte) '0' )
  [137] *((const byte[$64]) strTemp + (byte) myprintf::bLen#12) ← (byte~) myprintf::$43
  [138] (byte) myprintf::bLen#4 ← ++ (byte) myprintf::bLen#12
  [139] (byte) myprintf::bDigits#2 ← -- (byte) myprintf::bDigits#12
  to:myprintf::@18
myprintf::@15: scope:[myprintf]  from myprintf::@14
  [140] (byte) myprintf::b#5 ← ++ (byte) myprintf::b#17
  to:myprintf::@14
myprintf::@8: scope:[myprintf]  from myprintf::@7
  [141] (byte~) myprintf::$50 ← (byte)(word) myprintf::w#10
  [142] *((const byte[$64]) strTemp + (byte) myprintf::bLen#10) ← (byte~) myprintf::$50
  [143] (byte) myprintf::bLen#1 ← ++ (byte) myprintf::bLen#10
  to:myprintf::@27
myprintf::@28: scope:[myprintf]  from myprintf::@43
  [144] (byte) myprintf::bDigits#1 ← (byte) myprintf::b#1 - (byte) '0'
  to:myprintf::@32
myprintf::@4: scope:[myprintf]  from myprintf::@2
  [145] if((byte) myprintf::b#1!=(byte) '%') goto myprintf::@33
  to:myprintf::@39
myprintf::@39: scope:[myprintf]  from myprintf::@4
  [146] if((byte) myprintf::bArg#10==(byte) 0) goto myprintf::@34
  to:myprintf::@40
myprintf::@40: scope:[myprintf]  from myprintf::@39
  [147] if((byte) myprintf::bArg#10==(byte) 1) goto myprintf::@35
  to:myprintf::@41
myprintf::@41: scope:[myprintf]  from myprintf::@40
  [148] (word~) myprintf::w#55 ← (word) myprintf::w3#8
  to:myprintf::@36
myprintf::@36: scope:[myprintf]  from myprintf::@34 myprintf::@35 myprintf::@41
  [149] (word) myprintf::w#22 ← phi( myprintf::@34/(word~) myprintf::w#53 myprintf::@35/(word~) myprintf::w#54 myprintf::@41/(word~) myprintf::w#55 )
  [150] (byte) myprintf::bArg#1 ← ++ (byte) myprintf::bArg#10
  to:myprintf::@32
myprintf::@35: scope:[myprintf]  from myprintf::@40
  [151] (word~) myprintf::w#54 ← (word) myprintf::w2#8
  to:myprintf::@36
myprintf::@34: scope:[myprintf]  from myprintf::@39
  [152] (word~) myprintf::w#53 ← (word) myprintf::w1#7
  to:myprintf::@36
myprintf::@33: scope:[myprintf]  from myprintf::@4
  [153] if((byte) myprintf::b#1<(byte) $41) goto myprintf::@37
  to:myprintf::@47
myprintf::@47: scope:[myprintf]  from myprintf::@33
  [154] if((byte) myprintf::b#1>=(byte) $5a+(byte) 1) goto myprintf::@37
  to:myprintf::@42
myprintf::@42: scope:[myprintf]  from myprintf::@47
  [155] (byte) myprintf::b#6 ← (byte) myprintf::b#1 + (byte) $20
  to:myprintf::@37
myprintf::@37: scope:[myprintf]  from myprintf::@33 myprintf::@42 myprintf::@47
  [156] (byte) myprintf::b#25 ← phi( myprintf::@33/(byte) myprintf::b#1 myprintf::@42/(byte) myprintf::b#6 )
  [157] *((const byte[$64]) strTemp + (byte) myprintf::bLen#10) ← (byte) myprintf::b#25
  [158] (byte) myprintf::bLen#7 ← ++ (byte) myprintf::bLen#10
  to:myprintf::@32

(void()) utoa((word) utoa::value , (byte*) utoa::dst)
utoa: scope:[utoa]  from myprintf::@9
  [159] phi()
  to:utoa::@13
utoa::@13: scope:[utoa]  from utoa
  [160] if((word) utoa::value#4>=(word) $2710) goto utoa::@5
  to:utoa::@1
utoa::@1: scope:[utoa]  from utoa::@13 utoa::@9
  [161] (byte*) utoa::dst#16 ← phi( utoa::@13/(const byte[6]) myprintf::buf6 utoa::@9/++(const byte[6]) myprintf::buf6 )
  [161] (word) utoa::value#6 ← phi( utoa::@13/(word) utoa::value#4 utoa::@9/(word) utoa::value#0 )
  [161] (byte) utoa::bStarted#5 ← phi( utoa::@13/(byte) 0 utoa::@9/(byte) 1 )
  [162] if((byte) utoa::bStarted#5==(byte) 1) goto utoa::@6
  to:utoa::@14
utoa::@14: scope:[utoa]  from utoa::@1
  [163] if((word) utoa::value#6>=(word) $3e8) goto utoa::@6
  to:utoa::@2
utoa::@2: scope:[utoa]  from utoa::@10 utoa::@14
  [164] (byte*) utoa::dst#10 ← phi( utoa::@14/(byte*) utoa::dst#16 utoa::@10/(byte*) utoa::dst#1 )
  [164] (word) utoa::value#11 ← phi( utoa::@14/(word) utoa::value#6 utoa::@10/(word) utoa::value#1 )
  [164] (byte) utoa::bStarted#6 ← phi( utoa::@14/(byte) utoa::bStarted#5 utoa::@10/(byte) 1 )
  [165] if((byte) utoa::bStarted#6==(byte) 1) goto utoa::@7
  to:utoa::@15
utoa::@15: scope:[utoa]  from utoa::@2
  [166] if((word) utoa::value#11>=(byte) $64) goto utoa::@7
  to:utoa::@3
utoa::@3: scope:[utoa]  from utoa::@11 utoa::@15
  [167] (byte*) utoa::dst#13 ← phi( utoa::@11/(byte*) utoa::dst#2 utoa::@15/(byte*) utoa::dst#10 )
  [167] (word) utoa::value#10 ← phi( utoa::@11/(word) utoa::value#2 utoa::@15/(word) utoa::value#11 )
  [167] (byte) utoa::bStarted#7 ← phi( utoa::@11/(byte) 1 utoa::@15/(byte) utoa::bStarted#6 )
  [168] if((byte) utoa::bStarted#7==(byte) 1) goto utoa::@8
  to:utoa::@16
utoa::@16: scope:[utoa]  from utoa::@3
  [169] if((word) utoa::value#10>=(byte) $a) goto utoa::@8
  to:utoa::@4
utoa::@4: scope:[utoa]  from utoa::@12 utoa::@16
  [170] (byte*) utoa::dst#12 ← phi( utoa::@12/(byte*) utoa::dst#4 utoa::@16/(byte*) utoa::dst#13 )
  [170] (word) utoa::value#12 ← phi( utoa::@12/(word) utoa::value#3 utoa::@16/(word) utoa::value#10 )
  [171] (byte~) utoa::$16 ← (byte)(word) utoa::value#12
  [172] (byte~) utoa::$17 ← (byte) '0' + (byte~) utoa::$16
  [173] *((byte*) utoa::dst#12) ← (byte~) utoa::$17
  [174] (byte*) utoa::dst#3 ← ++ (byte*) utoa::dst#12
  [175] *((byte*) utoa::dst#3) ← (byte) 0
  to:utoa::@return
utoa::@return: scope:[utoa]  from utoa::@4
  [176] return 
  to:@return
utoa::@8: scope:[utoa]  from utoa::@16 utoa::@3
  [177] (byte*) append::dst#3 ← (byte*) utoa::dst#13
  [178] (word) append::value#4 ← (word) utoa::value#10
  [179] call append 
  [180] (word) append::return#10 ← (word) append::value#5
  to:utoa::@12
utoa::@12: scope:[utoa]  from utoa::@8
  [181] (word) utoa::value#3 ← (word) append::return#10
  [182] (byte*) utoa::dst#4 ← ++ (byte*) utoa::dst#13
  to:utoa::@4
utoa::@7: scope:[utoa]  from utoa::@15 utoa::@2
  [183] (byte*) append::dst#2 ← (byte*) utoa::dst#10
  [184] (word) append::value#3 ← (word) utoa::value#11
  [185] call append 
  [186] (word) append::return#4 ← (word) append::value#5
  to:utoa::@11
utoa::@11: scope:[utoa]  from utoa::@7
  [187] (word) utoa::value#2 ← (word) append::return#4
  [188] (byte*) utoa::dst#2 ← ++ (byte*) utoa::dst#10
  to:utoa::@3
utoa::@6: scope:[utoa]  from utoa::@1 utoa::@14
  [189] (byte*) append::dst#1 ← (byte*) utoa::dst#16
  [190] (word) append::value#2 ← (word) utoa::value#6
  [191] call append 
  [192] (word) append::return#3 ← (word) append::value#5
  to:utoa::@10
utoa::@10: scope:[utoa]  from utoa::@6
  [193] (word) utoa::value#1 ← (word) append::return#3
  [194] (byte*) utoa::dst#1 ← ++ (byte*) utoa::dst#16
  to:utoa::@2
utoa::@5: scope:[utoa]  from utoa::@13
  [195] (word) append::value#1 ← (word) utoa::value#4
  [196] call append 
  [197] (word) append::return#2 ← (word) append::value#5
  to:utoa::@9
utoa::@9: scope:[utoa]  from utoa::@5
  [198] (word) utoa::value#0 ← (word) append::return#2
  to:utoa::@1

(word()) append((byte*) append::dst , (word) append::value , (word) append::sub)
append: scope:[append]  from utoa::@5 utoa::@6 utoa::@7 utoa::@8
  [199] (word) append::sub#6 ← phi( utoa::@5/(word) $2710 utoa::@6/(word) $3e8 utoa::@7/(byte) $64 utoa::@8/(byte) $a )
  [199] (word) append::value#8 ← phi( utoa::@5/(word) append::value#1 utoa::@6/(word) append::value#2 utoa::@7/(word) append::value#3 utoa::@8/(word) append::value#4 )
  [199] (byte*) append::dst#4 ← phi( utoa::@5/(const byte[6]) myprintf::buf6 utoa::@6/(byte*) append::dst#1 utoa::@7/(byte*) append::dst#2 utoa::@8/(byte*) append::dst#3 )
  [200] *((byte*) append::dst#4) ← (byte) '0'
  to:append::@1
append::@1: scope:[append]  from append append::@2
  [201] (word) append::value#5 ← phi( append/(word) append::value#8 append::@2/(word) append::value#0 )
  [202] if((word) append::value#5>=(word) append::sub#6) goto append::@2
  to:append::@return
append::@return: scope:[append]  from append::@1
  [203] return 
  to:@return
append::@2: scope:[append]  from append::@1
  [204] *((byte*) append::dst#4) ← ++ *((byte*) append::dst#4)
  [205] (word) append::value#0 ← (word) append::value#5 - (word) append::sub#6
  to:append::@1

(word()) div10((word) div10::val)
div10: scope:[div10]  from main::@10
  [206] (word~) div10::$0 ← (word) div10::val#4 >> (byte) 1
  [207] (word) div10::val#0 ← (word~) div10::$0 + (byte) 1
  [208] (word~) div10::$2 ← (word) div10::val#0 << (byte) 1
  [209] (word) div10::val#1 ← (word) div10::val#0 + (word~) div10::$2
  [210] (word~) div10::$3 ← (word) div10::val#1 >> (byte) 4
  [211] (word) div10::val#2 ← (word) div10::val#1 + (word~) div10::$3
  [212] (word~) div10::$4 ← (word) div10::val#2 >> (byte) 8
  [213] (word) div10::val#3 ← (word) div10::val#2 + (word~) div10::$4
  [214] (word) div10::return#0 ← (word) div10::val#3 >> (byte) 4
  to:div10::@return
div10::@return: scope:[div10]  from div10
  [215] return 
  to:@return