                ' Z80 Coloss \U 1.2 + Tasword  Copyright(c)1997
                ' Concept and coded by Oleg N. Cher o'Myth Corp.
 #org 26400
@ assm , double , ;
@@ dis , txtadr , wrdptr , text , struct , strptr , code ,
   macro , lopstk , label , procs , ifthel , cclstk , pasII ,
   vars , write , start , rel , cicle , while ;

^ main clear $ #CD $$ 64330 ^ mans { !! | % } ifNZ mod ! 0 ret ;
 $ #CD $$ #E6EB = !! ! ++  proc mod [ 62216 ] + !! ++ = ramtop
ret  ^ curs clear $ #CD $$ 64333 gto mans
  proc clear } % endstr  _ ramtop #7D00 goto #E6DA
$$ #73ED  $$ stack
{  0 = assm  #=  = double
}  [ 62216 ]  =  txtadr  3604  =  wrdptr

   ramtop ] 0 ++ = struct = start , + 8 = strptr
   #5B00 = vars ,, { ] 0 } ^^ +++  ! 8  $$ #B0ED
         0  =  dis     =  cicle    =  while
         ++            =  code     =  macro
            =  lopstk  =  label    =  procs
            =  ifthel  =  cclstk   =  pasII
            =  write   =  rel

{  ! 2 putlast ~rnd $$ #5FED ~13  begin  scan  translate  again

: base  {  < 21 $$ code do ;  [] 83 5F 23
                              [] 8A 57 23  loop > } :

proc gettxt  } txtadr
begin  { [] . 32 if } ++ again then
       {    \\   if { ! 7 } % struct base %=
                    ^ pas  =  wrdptr
                 { [] \\ if ? $ 0 ; ! 3 search if  ! 4 search if
            begin [] } ++ { . 32 until } ++ ++ [] = txtadr ? $ 1
                                { ; ! ++ ;
                     } [] { [[]] ^^ } +++ { [[]] } +++ ,,,
                     { = D ]E %
          { [[]] -- if lrljr } ,, ++ ++ gto pas ;
          {      ++ ifNZ !! \\ ifNZ #CD = [[]] ; } +++ ;
          ! dis + !! { L = [[]] } +++ { H = [[]] } ,, ++ ++

       gto pas then  % #4000  { ! 0 }
 begin               = txtadr
         { [] . 32  if !! \\ retZ [] then
              . 126 if !! #= = !! [] then
              = [[]] } +++ txtadr ++
 again

proc cmp  }  ,,  % wrdptr  { [[]]
          begin  . []  if  } ++ +++ { [[]] . 32  until
              0  . []  gtoNZ cskip  goto ; then  0  ^ cskip
          begin  . []  } ++ {  until  --  goto ;

proc scan  } wrdptr
      begin  { [] . 32 } ++  until  = wrdptr  { [] \\ retNZ
^ ctrl  } #4000 = wrdptr = text
    begin gettxt  { 32 = [[]] } +++ { 0 = [[]] cmp ~'~ if
     begin gettxt  { 32 = [[]] } +++ { 0 = [[]] cmp ~'~ until
    again then  { [ #4000 ] . 126 retZ

  ^ process               } struct + code
   ^ find                 % text
 begin  { [[]] . [] if }  ++ +++  { . 32  until }  , text
  begin  { [[]] = [] }  ++ +++  { \\  until = !!  } % text ,, --
  begin  ++ { [] . 1  if double    = !! again then

                 . 2  if double #= = !! again then
                 . 3  if ! 0            again then
                 . 13 gtoZ process  !! \\  until  [] } , vv +++
          ^ ins  { % [] = [] vv } ++ { \\ gtoNZ ins = [] } ,,
  again then
begin { [] } ++  { . 13 until [] \\ gtoNZ find
begin [[]] } +++ { . 32 until } == text { [[]] \\ gtoNZ process
[ #4000 ] \\ retNZ goto ctrl

proc putln  { ,,, } ,  % ramtop  base  -- --  ] ++ if ++ ]  ++ ;
  ,,, strptr -= = !! _ endstr #CCFF - strptr if ? $ 2 then
      strptr ++ = strptr  -- --  $$ #B8ED   ,,,, ,, { ,,,,  ret

proc getln  { ,,, }    % ramtop  base  -- --  {  []  -  1  =  []
            ifC  } ++ {  [] - 1 = [] ifC  ? $ 3 then then
  } --- { [[]] , }
  strptr -- = strptr  -= = !! vv ++  $$ #B0ED  { ,, ,,,,  ret

proc putadr  }  ramtop + code
proc putnum  {  putln  L = [[]]  putln  H = [[]]  ret
proc getnum  {  getln  ,  getln  =  L  ,,  =  H  ret

proc putword  } wrdptr
    begin  putln  { [] = [[]]  } ++ {  [] \\ until  ret
proc putlast  } ,,
    begin  putln  { [] = [[]]  } ++ {  [] \\ until  goto ;

proc search  } % struct base
 begin  wrdptr { [[]] \\ retZ
  begin  [[]] . []  if } ++ +++ { . 32  until \\ } %= { ret then
  begin  [[]] } +++ { . 32  until } +++ +++
 again

proc byte  } wrdptr  { [] } ++ {
    . """ if ! [] ret then  ! 0
    . "#" if assm \\ gtoNZ decbyt  ^ hexbyt
             [] begin  - "0" retC  . 10 ifNC - 7 . 10 retC
                       . 16 gtoNC lex then
                       ^^ !! ** ** ** ** += = !! } ++ {
             [] . 32  until ret then
    . "-" if cbyte ifNC !! $$ #44ED = !! \\ then ret then

} --
proc cbyte { assm \\ gtoNZ hexbyt  ^ decbyt
             [] begin  - "0" retC . 10 ifNC  ^ lex || ret then
                       ^^ !! ** ** ** + !! + !! += = !! } ++ {
             [] . 32  until ret

proc number  } cmp ~"~ if  scan byte ifC ^ syntax ? $ 4 then
                   ]L !! , scan byte gtoC  syntax ,, ]H !!
                   ret then  % wrdptr  { [[]] } +++ {

    . """ if [[]] }} ret then  0  { ! 0
    . "#" if assm \\ gtoNZ decnum  ^ hexnum
             [[]] begin  - "0" retC  . 10 ifNC - 7 . 10 retC
                         . 16 ^ NClex gtoNC lex then
                         ^^ } ** ** ** ** + !! +++ {
                         [[]] . 32  until ret then
    . "-" if cnumber ifNC } %= 0 -= { \\ then ret then

} ---
proc cnumber { assm \\ gtoNZ hexnum  ^ decnum
               [[]] begin  - "0" retC . 10 gtoNC NClex
               } ** = !! ** ** + !! { ^^ ! 0 } + !! +++ {
               [[]] . 32  until ret

: comp compi $ :  proc compi } ,, { ! 1 putln [] = [[]] ret
: com  val $ :  proc val } ,, { ! 1 putln [] = [[]] } ++ goto ;
proc compile  } ,, {  % []  ! 1  } ++
 begin  { putln [] = [[]] } ++ { % --  until  goto ;

proc direct   { number ifNC  ! 1 goto putnum  then
proc indirect { cmp ~[~ if  scan number ifNC ! 1 putnum
              ^ clos  scan cmp ~]~ retZ  goto syntax ;
                            ident  gto clos ;
proc ident  { ! 3 search if  ! 4 search if  ! 8 putword
 ^ post putadr } txtadr { putnum ! 1  } 0  goto putnum ; ;
              [] + dis  { ! 1  goto putnum

proc doind  index  goto syntax
proc index  { ,
      cmp ~++~ if  ! 1 putln ,, - #42 = [[]] ,, ret  ;
      cmp ~--~ if  ! 1 putln ,, - #41 = [[]] ,, ret
proc value  { ,  then
      byte ifNC ,, ,,, , ! 1 putln ,, xor #40 = [[]]
                             putln ,,         = [[]] ,, ret

proc alter  { ,  then
      cmp ~!!~ if  ! 1 putln ,, -  6  = [[]] ,, ret  ;
      cmp ~%~  if  ! 1 putln ,, -  5  = [[]] ,, ret  ;
      cmp ~D~  if  ! 1 putln ,, -  4  = [[]] ,, ret  ;
      cmp ~E~  if  ! 1 putln ,, -  3  = [[]] ,, ret  ;
      cmp ~H~  if  ! 1 putln ,, -- -- = [[]] ,, ret  ;
      cmp ~L~  if  ! 1 putln ,,  --   = [[]] ,, ret  ;
                                             ,, ret

proc regist  index  gto para
proc argum   value    ^ para  { ,
      cmp ~[]~ if  ! 1 putln ,,       = [[]]    ret  ;
      cmp ~(~  if  ^ x com #DD putln ,, = [[]]
                 scan byte gotoC syntax ,,, ! 1 putln ,, = [[]]
 scan cmp ~)~         retZ goto  syntax ;

      cmp ~((~ if  ^ y com #FD putln ,, = [[]]
                 scan byte gotoC syntax ,,, ! 1 putln ,, = [[]]
 scan cmp ~))~        retZ goto  syntax ;
      com #21  cmp ~[~ if  scan number gotoC syntax
                          ! 1 putnum putln ,, = [[]] goto clos ;
                         ident putln ,, = [[]]  ret

proc dest  { , number ifNC  ! 1 putln  ,, = [[]]  goto putnum ;
             cmp ~[~ if  scan
               number ifC  ! 1 putln ,, = [[]] ident goto clos ;
             ,, cmplx goto clos ; ,,
proc cmplx  { . #01 if  compile $ 2 $$ #4BED  gto swtch  ;
              . #11 if  compile $ 2 $$ #5BED  gto swtch  ;
          com #2A  ^ swtch  number gotoC ident  ! 1 goto putnum

: format double \\ if :  ^ for ? $ 5
: only_big double \\ gotoZ for :
: only_sml double \\ gotoNZ for :

    proc translate { cmp ~0~ if assm \\ if format comp #AF ; ; ;
 assm   \\ ifNZ ^ bcom byte gtoC constr ,,, assm \\ if com #3E ;
                  ! 1 putln ,, = [[]]  ret ;
 double \\ gtoZ bcom number gtoC constr } ,            com #21
                  ,, goto putnum
        ^ constr  wrdptr  { [] . "$" gotoNC first

cmp ~!~        if scan format #46 goto regist ;
                  cmp ~%~  if compile $ 2 $$ #424B  ret ;
                  cmp ~++~ if comp #03 ;
                  cmp ~--~ if comp #0B ;
                  cmp ~[]~ 1 gotoNZ dest
                              compile $ 3 < 4E 23 46 >  ret ;

cmp ~!!~       if format comp #78 ; compile $ 2 $$ #6069  ret ;
cmp ~#~        if 0 gto dcl ;
cmp ~##~       if #23 ^ dcl  = inr } ramtop + code , begin scan

          ,, proc define , cmp ~;~ if ,, ret ;
                           cmp ~[~ untilNZ cmp ~]~ untilNZ
                           cmp ~,~ if ,, _ inr  ++ ++ , again ;
                           number ifNC ,,,, += , again ;
             {  ! 3 search  gotoNZ syntax  ! 4 putword
                                     } ,, , {  putnum  again ;

cmp ~#=~       if format comp #2F ;
                        compile $ 6 < 7D 2F 6F 7C 2F 67 > ret ;
cmp ~#inline~  if scan number gotoC syntax  } ,
                  scan number gotoC syntax  %%  { ! 1
          begin putln [] = [[]] } ++ ,,,, --- ,,, { E | D until
                ,,  ret ;

cmp ~#macro~   if #2A = process  ret ;
cmp ~#org~     if scan number gotoC syntax
                  } - struct = dis {  ret ;
cmp ~#rel~     if #FF = rel  ret ;
cmp ~#skip~    if scan number gotoC syntax  ! 1
          begin putln  0 = [[]] } -- \\ { until  ret ;

cmp ~#start~   if } ramtop + code = start {  ret ;
cmp ~#unmacro~ if #C9 = process  ret ;
cmp ~#unrel~   if 0 = rel  ret ;
cmp ~#unwrite~ if       #FF = write  ret ;
cmp ~#write~ gotoNZ ncon  0 = write  ret

                      ^ first  . "(" gotoNC second
cmp ~$~        if scan  assm ,  0 = assm  byte gotoC syntax
                  ,,  = assm ,,,  ! 1 putln  ,, = [[]]  ret ;
cmp ~$$~       if scan  assm ,  0 = assm direct ,, = assm ret ;

cmp ~%~        if scan format #4E goto regist ;
                  cmp ~!!~ if compile $ 2 $$ #5059  ret ;
                  cmp ~++~ if comp #13 ;
                  cmp ~--~ if comp #1B ;
                  cmp ~[]~ #11 gotoNZ dest
                              compile $ 3 < 5E 23 56 >  ret ;

cmp ~%%~       if format  comp #D9 ;  comp #E3 ;
cmp ~%=~       if format  comp #08 ;  comp #EB ;
cmp ~&~        if only_sml scan #A6 goto argum ;
cmp ~&&~       if comp #3F ;
cmp ~&=~     gotoNZ ncon  format comp #A1 ;
                          compile $ 6 < 7D A3 6F 7C A2 67 >  ret
                     ^ second  . "*" gotoNC dum

cmp ~(~        if only_sml #7E ,  goto x ;
cmp ~((~       if only_sml #7E ,  goto y ;
cmp ~(())~     if compile $ 2 $$ #E5FD  ret ;
cmp ~()~       if compile $ 2 $$ #E5DD  ret ;

cmp ~)~        if com #DD  ^ indy  scan
                       cmp ~+=~ if comp #19 ;
                       cmp ~**~ if comp #29 ;
                       cmp ~++~ if comp #23 ;
                       cmp ~--~ if comp #2B ;
                       cmp ~+~  if scan
                           cmp ~!!~ if            comp #09 ;
                           cmp ~%~  gotoNZ syntax comp #19 ;
                       cmp ~=~  #21 gotoNZ dest
                                scan com #22 goto indirect ;

cmp ~)(~       if         compile $ 2 $$ #E1DD  ret ;
cmp ~))~       if com #FD goto indy ;
cmp ~))((~   gotoNZ ncon  compile $ 2 $$ #E1FD  ret
                        ^ dum  . "-" gotoNC third

cmp ~*~        if "*" ^ glob  = propr  only_big scan #11 dest
                              com #CD ! 8 putlast ^ propr ~*= ~
                              goto post ;
cmp ~**~       if format  comp #87 ;  comp #29 ;
cmp ~+~        if scan format #86 goto argum ;
                  cmp ~!!~ if              comp #09 ;
                  cmp ~%~  ifNZ #11 dest ; comp #19 ;

cmp ~++~       if format  comp #3C ;  comp #23 ;
cmp ~+=~       if format  comp #81 ;  comp #19 ;
cmp ~+++~      if format  comp #0C ;  comp #13 ;
cmp ~+loop~    if com #10 goto rljplb ;
cmp ~,~        if format  comp #F5 ;  comp #E5 ;
cmp ~,,~       if format  comp #F1 ;  comp #E1 ;
cmp ~,,,~      if format  comp #C5 ;  comp #D5 ;
cmp ~,,,,~   gotoNZ ncon format comp #C1 ; comp #D1

                      ^ third  . ";" gotoNC four
cmp ~-~        if scan format #96 goto argum ;
          proc minus cmp ~!!~ if compile $ 3 < A7 ED 42 > ret ;
                     cmp ~%~  ifNZ #11 dest ;
                         ^ subD  compile $ 3 < A7 ED 52 > ret ;
cmp ~--~       if format  comp #3D ;  comp #2B ;
cmp ~-=~       if double \\ gtoNZ subD comp #91 ;

cmp ~---~      if format  comp #0D ;  comp #1B ;
cmp ~.~        if scan format #BE goto argum ;
                  com #E5  minus  comp #E1 ;
cmp ~/~        if "/" goto glob ;
cmp ~//~       if format compile $ 2 $$ #3FCB  ret ;
                  ^ roll compile $ 4 < CB 3C CB 1D >  ret ;

cmp ~:~      gotoNZ ncon  process ,  #C9 = process
         begin scan ! 2 cmp ~?{~ if putln  1 = [[]] again ;
                        cmp ~?}~ if putln  2 = [[]] again ;
                        cmp ~}{~ if putln  3 = [[]] again ;
                        cmp ~:~  if putln 13 = [[]] ,,
                                           = process  ret ;
                        putword  again

                       ^ four  . "@" gotoNC five
cmp ~;~        gotoZ then
cmp ~<~        if assm \\ gotoZ form  ? $ 5 ;
cmp ~<<~       if format comp #07 ;
                         compile $ 4 < CB 25 CB 14 >  ret ;
cmp ~=~        gotoNZ Neq scan double \\ gotoNZ dob

                  cmp ~!!~ if comp #47 ;  cmp ~%~ if comp #4F ;
                  cmp ~D~  if comp #57 ;  cmp ~E~ if comp #5F ;
                  cmp ~H~  if comp #67 ;  cmp ~L~ if comp #6F ;
                  cmp ~[]~     if comp #77 ;
                  cmp ~[[]]~   if comp #12 ;
                  cmp ~[[[]]]~ if comp #02 ;
                  cmp ~(~      if #77 , goto x ;
                  cmp ~((~     if #77 , goto y ;
                  cmp ~!~      if comp #D7 ;
                  com #32  goto indirect

             ^ dob  cmp ~!!~ if compile $ 2 $$ #444D  ret ;
                    cmp ~%~  if compile $ 2 $$ #545D  ret ;
                    cmp ~!~  if com #CD ! 8 putlast ~writenum ~
                                                goto post ;
                    com #22  goto indirect  ^ Neq

cmp ~==~       if only_big scan compile $ 2 $$ #53ED
                                            goto indirect ;
cmp ~===~      if only_big scan compile $ 2 $$ #43ED
                                            goto indirect ;
cmp ~>~        if assm \\ gotoZ for  ^ form  #= = assm  ret ;
cmp ~>>~     gotoNZ ncon  double \\ gotoNZ roll  comp #0F
                       ^ five  . "[" gotoNC six

cmp ~@~        if 0 gto data ;
cmp ~@@~       if #23 ^ data  = inr scan
                        number ifNC  } = vars scan ;
                        vars - dis define + dis = vars {  ret ;
cmp ~D~        if        only_sml comp #7A ;
cmp ~E~        if        only_sml comp #7B ;
cmp ~H~        if        only_sml comp #7C ;
cmp ~L~      gotoNZ ncon only_sml comp #7D

                        ^ six  . "a" gotoNC seven
cmp ~[~        if double \\ #21 gotoNZ dest
                                scan com #3A number gotoC syntax
                                ! 1 putnum goto clos ;
cmp ~[]~       if format comp #7E ;
                         compile $ 4 < 7E 23 66 6F >  ret ;
cmp ~[[]]~     if only_sml comp #1A ;
cmp ~[[[]]]~   if only_sml comp #0A ;
cmp ~\~        if "\" goto glob ;
cmp ~\\~       if format comp #B7 ; compile $ 2 $$ #B47D  ret ;

cmp ~]~        if scan cmp ~(~  if com #DD
                  scan byte gotoC syntax ,,,
                  scan cmp ~)~
             ^ xy gotoNZ syntax scan #76 doind putln } ,,, byte
                  ,, ,,,, ] D retC -- { [] ] D } ++ { = [] ret ;
                       cmp ~((~ if com #FD
                  scan byte gotoC syntax ,,,
                  scan cmp ~))~ gto xy ;
             #76 index cmp ~[]~ gotoNZ syntax comp #76 ;

cmp ~]D~       if scan #56 goto regist ;
cmp ~]E~       if scan #5E goto regist ;
cmp ~]H~       if scan #66 goto regist ;
cmp ~]L~       if scan #6E goto regist ;
cmp ~^~        if        scan ! 3 search gotoNZ syntax
                              ! 4 putword  goto putadr ;
cmp ~^^~       if format comp #4F ; compile $ 2 $$ #545D  ret ;
cmp ~_~      gotoNZ ncon scan ! 3 search gotoNZ syntax
                              ! 4 putword  } struct + code {
                             goto putnum

                      ^ seven  . "g" gotoNC eight
cmp ~again~    if rel \\ ifNZ com #18 endcicl goto reljmp ;
                              com #C3 goto rpt ;
cmp ~begin~    if ! 7  } putadr = while {  ret ;
cmp ~di~       if comp #F3 ;
cmp ~do~       if scan cmp ~;~ ifNZ  #46 argum ;
                  ! 3  } putadr = cicle {  ret ;

cmp ~ei~       if comp #FB ;
cmp ~else~   gotoNZ ncon compile $ 2 $$ #18  ! 6 getnum } --
                    , ramtop + code putnum ,,,, goto lrljr {
                      ^ eight  . "i" gotoNC nine
cmp ~goto~     if scan cmp ~;~  if comp #E9 ;
                       cmp ~)~  if compile $ 2 $$ #E9DD  ret ;
                       cmp ~))~ if compile $ 2 $$ #E9FD  ret ;
                       com #C3 goto direct ;

cmp ~gotoC~    if scan com #DA goto direct ;
cmp ~gotoNC~   if scan com #D2 goto direct ;
cmp ~gotoNZ~   if scan com #C2 goto direct ;
cmp ~gotoZ~    if scan com #CA goto direct ;
cmp ~gto~      if com #18  ^ rljplb scan byte
                           ifC ! 3 search if ! 4 search if
             ! 8  putword  putadr } txtadr { putnum comp 1 ; ;
                           } [] {  ^ reljmp  ! 1 putln
                                proc lrljr   } --

                  = !! -=  ifC %= , - !!  . 129 ifNC
                                             ^ longjp ? $ 6 ;
                  {{ } ,, { $$ #44ED  { = []  ret ;
                                        } ! 128 , - !! ,,
                      gtoNC longjp {{ = [[]]  ret ;
                     ,,, ! 1 putln ,, = [[]]  ret ;

cmp ~gtoC~     if        com #38  gto rljplb ;
cmp ~gtoNC~    if        com #30 goto rljplb ;
cmp ~gtoNZ~    if        com #20 goto rljplb ;
cmp ~gtoZ~   gotoNZ ncon com #28 goto rljplb
                       ^ nine  . "p" gotoNC ten
cmp ~if~       if com #20   ^ if com 0  ! 6 goto putadr ;
cmp ~ifC~      if com #30 gto if ;
cmp ~ifNC~     if com #38 gto if ;
cmp ~ifNZ~     if com #28 gto if ;

cmp ~in~       if        scan com #DB byte gotoC syntax
                  ,,, ! 1 putln ,, = [[]]  ret ;
cmp ~loop~     if com #10  } lopstk -- \\
                            ifNZ { ! 3 } getnum = cicle ;
                                    cicle goto reljmp { ;
cmp ~out~    gotoNZ ncon scan com #D3 byte gotoC syntax
                  ,,, ! 1 putln ,, = [[]]  ret
                        ^ ten  . "u" gotoNC eleven

cmp ~proc~     if scan number ifC  ! 4 search gotoNZ syntax
                                   ! 5 putword goto putadr ; }
                - dis , { scan ! 4 search gotoNZ syntax
                               ! 5 putword } ,, goto putnum ; {
cmp ~ret~      if comp #C9 ;
cmp ~retC~     if comp #D8 ;
cmp ~retNC~    if comp #D0 ;
cmp ~retNZ~    if comp #C0 ;
cmp ~retZ~     if comp #C8 ;
cmp ~then~   gotoNZ ncon   ^ then ! 6 getnum  } --
                             , ramtop + code ,,,, goto lrljr

             proc endcicl  } cclstk -- \\
                            ifNZ { ! 7 } getnum = while  ret ;
                                                  while {  ret
                     ^ eleven  . "{" gotoNC twelve
cmp ~until~    if rel \\ ifNZ com #20 endcicl goto reljmp ;
                              com #C2 ^ rpt endcicl } + dis
                                        { ! 1 goto putnum ;

cmp ~untilC~   if rel \\ ifNZ com #30 endcicl goto reljmp ;
                              com #D2 gto rpt ;
cmp ~untilNC~  if rel \\ ifNZ com #38 endcicl goto reljmp ;
                              com #DA gto rpt ;
cmp ~untilNZ~  if rel \\ ifNZ com #28 endcicl goto reljmp ;
                              com #CA gto rpt ;
cmp ~vv~       if format comp #79 ; compile $ 2 $$ #626B  ret ;

cmp ~xor~    gotoNZ ncon only_sml scan #AE goto argum
                     ^ twelve  . 126 gotoZ lap
cmp ~{~        if 0 = double  ret ;
cmp ~{{~       if 0 = double comp #7D ;
cmp ~|~        if only_sml scan #B6 goto argum ;
cmp ~|=~       if      format comp #B1 ;
                       compile $ 6 < 7D B3 6F 7C B2 67 >  ret ;
cmp ~||~       if comp #37 ;
cmp ~}~        if ^ big  #FF = double  ret ;
cmp ~}}~       if compile $ 3 < 6F 26 00 > gto big ;

             ^ ncon  ! 3 search ifNZ } % [] dis += , {
              format com #3A else com #2A ; } ,, goto putnum { ;
                     ! 4 search ifNZ } % [] dis += ,
                       com #CD                ,, goto putnum { ;
                     ! 8 putword putadr } txtadr { putnum
              format com #3A else com #2A ; compile $ 2 $$ 0 ret
             ^ lap } ! #100 ++
 begin { [] . 126 if vv #= ^^ } ++ { again ;
            . 32  if vv \\ gtoZ add } = wrdptr { assm \\ retNZ

                                   comp 0 ;
                    vv \\ if ^ add putln [] = [[]] } ++ again ;
      { [] - "0" gotoC syntax . 10 gotoNC syntax = E
 ^ cf } ++ {
        [] - "0" gtoC  putch  . 10 gtoNC  putch  = D
                              E ** ** ** + E + E + D = E gto cf
 ^ putch E , putln ,, = [[]]
again
proc ? } txtadr - [ 62216 ] $ #CD $$ #F46D
,,  { % [] ! 0  $ #31  ^ stack $$ 0  ret

