   opt  l-
*  Tumbling Tots - by David Hanley
*  Amazing Computing  -  August 1988.
*  Painstakingly entered compliments of Tom Eshelman  OHS825
*  Made it case sensitive while at it, to render code more legible.


   incdir   "df0:include/"

   include  exec/types.i
   include  exec/nodes.i
   include  exec/lists.i
   include  exec/memory.i
   include  exec/io.i
   include  exec/ports.i
   include  exec/tasks.i
   include  exec/libraries.i
   include  exec/exec_lib.i
   include  graphics/gfx.i
   include  graphics/view.i
   include  graphics/graphics_lib.i
   include  intuition/intuition.i
   include  intuition/intuition_lib.i
   include  libraries/dosextens.i
   include  libraries/dos_lib.i
   include  workbench/workbench.i
   include  workbench/startup.i
   include  devices/audio.i
   include  hardware/custom.i


HARDWARE    EQU   $dff000
DEPTH       EQU   3
NOMCOLS     EQU   8
EXTRAX      EQU   50
EXTRAY      EQU   15
DISTANCE    EQU   20
SCOREX      EQU   250
SCOREY      EQU   15
SPEED       EQU   6
MAXBABS     EQU   8
TITLEX      EQU   150
TITLEY      EQU   40
MEN1X       EQU   34
MEN2X       EQU   124
MEN3X       EQU   214
MENY        EQU   175
SPLATY      EQU   MENY+17
NAMEX       EQU   160
NAMEY       EQU   80
TRUCKX      EQU   290
TRUCKY      EQU   157
BUILDX      EQU   0
BUILDY      EQU   18


   STRUCTURE operation,0               Blitter buffer (exec/types.i macro)
      SHORT op_bltcon0
      SHORT op_bltcon1
      SHORT op_bltamod
      SHORT op_bltbmod
      SHORT op_bltcmod
      SHORT op_bltdmod
      LONG  op_bltaflwm
      LONG  op_bltapt
      LONG  op_bltbpt
      LONG  op_bltcpt
      LONG  op_bltdpt
      SHORT op_bltsize
   LABEL    opsize                     34 bytes


nds:     MACRO
soffset: set      soffset-\2
\1:      equ      soffset
   ENDM


*  All the local variables.  These are on the user stack, WORKING BACKWARDS.
*  The first argument is the name.  The second is its size.

soffset:  set  0

   nds   execbase,4
   nds   dosbase,4
   nds   gfxbase,4
   nds   intbase,4
   nds   mytask,4
   nds   numberops,2
   nds   nextop,4
   nds   operations,opsize*10          10 packs of blitter register values.
   nds   memory,4
   nds   babyscreen,4
   nds   myplanes,4
   nds   state,4
   nds   changes,4
   nds   count,2
   nds   seed,4
   nds   sizetemp,4
   nds   planelength,4
   nds   babywindow,4
   nds   codekey,2
   nds   uport,4
   nds   place,2
   nds   timer,2
   nds   old,2
   nds   babies,2
   nds   saved,2
   nds   temp,2
   nds   cycle1,4
   nds   cycle2,4
   nds   wave,2
   nds   attract,2
   nds   babieson,2
   nds   soundport,MP_SIZE
   nds   soundio,ioa_SIZEOF
   nds   io2,ioa_SIZEOF
   nds   allocated,4
   nds   returnmsg,4
workspce:   equ   soffset                    -656 bytes, or thereabouts.


start:

   link     a5,#workspce            Steal variable storage from stack.

   move.l   4,execbase(a5)
   move.l   4,a6

   suba.l   a1,a1                   No name known, so clear a1.
   jsr      _LVOFindTask(a6)

   move.l   d0,mytask(a5)

   lea      intuiname(pc),a1        Pre-initialized variables off the pc.
   moveq    #0,d0
   jsr      _LVOOpenLibrary(a6)

   move.l   d0,intbase(a5)

   lea      gfxname(pc),a1
   moveq    #0,d0
   jsr      _LVOOpenLibrary(a6)

   move.l   d0,gfxbase(a5)

   lea      dosnam(pc),a1
   moveq    #0,d0
   jsr      _LVOOpenLibrary(a6)

   move.l   d0,dosbase(a5)

   clr.l    returnmsg(a5)

   move.l   mytask(a5),a4
   tst.l    pr_CLI(a4)
   bne      nowb


   lea      pr_MsgPort(a4),a0
   jsr      _LVOWaitPort(a6)        We must wait for WB to give a go-ahead.

   lea      pr_MsgPort(a4),a0
   jsr      _LVOGetMsg(a6)          Received.  Get it off said port.

   move.l   d0,returnmsg(a5)

   move.l   d0,a4
   move.l   sm_ArgList(a4),d0
   beq      nowb                    This should never happen.

   move.l   d0,a4
   move.l   wa_Lock(a4),d1

   move.l   dosbase(a5),a6
   jsr      _LVOCurrentDir

nowb:

   bsr      tots                    Call program proper.

   move.l   4,a6                    We wish to quit now.
   move.l   returnmsg(a5),d4        Retrieve the message.
   beq      nowb2                   If none, we  came from the CLI.

   jsr      _LVOForbid(a6)          Otherwise, Forbid.  No multitask please!

   move.l   d4,a1
   jsr      _LVOReplyMsg(a6)        Reply to the WorkBench!

nowb2:

   move.l   dosbase(a5),a1          In all events, close your libraries.
   jsr      _LVOCloseLibrary(a6)

   move.l   gfxbase(a5),a1
   jsr      _LVOCloseLibrary(a6)

   move.l   intbase(a5),a1
   jsr      _LVOCloseLibrary(a6)

   unlk     a5                      Release variable memory
   rts                              Return to system.


*******           End main.

tots:

   lea      datastart(pc),a1        Get base of all data.

   move.l   execbase(a5),a6
   jsr      _LVOTypeOfMem(a6)       Was it defined as 'section CHIP'?

   moveq    #MEMF_CHIP,d1
   and.l    d0,d1
   beq      notchip

   lea      datastart(pc),a1        If already chip ram (512K) all is OK.
   move.l   a1,memory(a5)           Save pointer to the buffer on user stk.
   clr.l    allocated(a5)           Just clear this variable.
   bra      inchip

notchip:

   move.l   #dataend-datastart,d0   Calculate required number of bytes.
   moveq    #MEMF_CHIP,d1
   jsr      _LVOAllocMem(a6)        Allocate chip memory.

   move.l   d0,memory(a5)           Save buffer pointer here.
   move.l   d0,allocated(a5)
   beq      nomem

   move.l   d0,a1
   lea      datastart(pc),a0              Pointer to data.
   move     #(dataend-datastart)/2,d0     Length in WORDS.  (Save steps).

copymem:

   move     (a0)+,(a1)+             Copy to chip in word increments.
   subq     #1,d0
   bne      copymem

inchip:

   lea      nscreen(pc),a0
   move.l   intbase(a5),a6
   jsr      _LVOOpenScreen(a6)

   move.l   d0,babyscreen(a5)
   beq      noscreen

   lea      nwindow+nw_Screen(pc),a0      NOTE TECHNIQUE.
   move.l   d0,(a0)                       Attach screen to NewWindow.

   move.l   d0,a0

   lea      sc_BitMap+bm_Planes(a0),a1
   move.l   a1,myplanes(a5)               Save bitplanes pointer for blitops.

   lea      nwindow(pc),a0
   jsr      _LVOOpenWindow(a6)

   move.l   d0,babywindow(a5)
   beq      nowindow

   move.l   d0,a0
   move.l   wd_UserPort(a0),uport(a5)

   lea      soundio(a5),a0
   moveq    #ioa_SIZEOF,d0
   bsr      clearmem

   lea      soundport(a5),a0
   moveq    #MP_SIZE,d0
   bsr      clearmem

   lea      audname(pc),a0
   lea      soundio(a5),a1
   moveq    #0,d0
   moveq    #0,d1
   move.l   execbase(a5),a6
*                                                end col 1, page 74
   jsr      _LVOOpenDevice(a6)

   moveq    #-1,d0
   jsr      _LVOAllocSignal(a6)

   lea      soundport(a5),a0                    Now he prepares his ioaReq.
   clr.l    LN_NAME(a0)
   clr.b    LN_PRI(a0)
   move.b   #NT_MSGPORT,LN_TYPE(a0)
   move.b   #PA_SIGNAL,MP_FLAGS(a0)
   move.b   d0,MP_SIGBIT(a0)

   move.l   mytask(a5),MP_SIGTASK(a0)
   move.l   a0,(a0)
   addq.l   #LH_TAIL,(a0)
   clr.l    LH_TAIL(a0)
   move.l   a0,LH_TAILPRED(a0)

   lea      soundio(a5),a1
   move.l   a0,MN_REPLYPORT(a1)
   move     #ADCMD_ALLOCATE,IO_COMMAND(a1)

   lea      audiomap(pc),a0
   move.l   a0,ioa_Data(a1)
   moveq    #4,d0
   move.l   d0,ioa_Length(a1)
   move.b   #ADIOF_NOWAIT,IO_FLAGS(a1)

   move.l   IO_DEVICE(a1),a6
   jsr      DEV_BEGINIO(a6)

*   tst.l    d0
*   bne      error

   lea      soundio(a5),a0                      Here, we copy the relevant
   lea      io2(a5),a1                          data from the master ioReq
   move.l   IO_DEVICE(a0),IO_DEVICE(a1)         to a slave ioReq.
   move     ioa_AllocKey(a0),ioa_AllocKey(a1)
   move.l   MN_REPLYPORT(a0),MN_REPLYPORT(a1)   Note which four elements are
   move.l   IO_UNIT(a0),IO_UNIT(a1)             deemed vital.

   move.l   babyscreen(a5),a0
   lea      sc_ViewPort(a0),a0                  Get address screen's ViewPort

   lea      ctable(pc),a1                       Locate the colortable.
   moveq    #NOMCOLS,d0

   move.l   gfxbase(a5),a6
   jsr      _LVOLoadRGB4(a6)                    Load the color registers.

   bsr      clearops                      Clear blitter ops.  34 bit vars.

   move.b   #$da,seed(a5)                 Select random seed.
   clr.l    state(a5)                     Clear 32 'baby' bits.

   move     #MENY,d1                      Draw firemen.
   move     #MEN1X,d0

   move     d0,place(a5)                  Begin with men on left.
   moveq    #0,d2
   bsr      figure                        Put men.

   bsr      doops                         Do blitter operations.

   moveq    #100,d4                       Load counter for next routine.

random:

   bsr      rnd                           toss 100 random numbers

   subq     #1,d4
   bne      random

   move     #TRUCKX,d0                    setup for truck
   move     #TRUCKY,d1
   moveq    #18,d2
   bsr      figure                        put truck

   bsr      doops                         do blits

   moveq    #BUILDX,d0                    setup for building
   move     #BUILDY,d1

   moveq    #19,d2
   bsr      figure                        put building

   bsr      doops                         do blits

   move     #5,babies(a5)                 5 extra babies
   move     #1,wave(a5)                   wave 1
   clr      saved(a5)                     saved = 0

restart2:

   move     #1,attract(a5)                game in attract mode
   move     #TITLEX,d0                    setup for title
   moveq    #TITLEY,d1
   moveq    #15,d2
   bsr      figure                        put title

   bsr      doops                         do blits

   move     #NAMEX,d0                     setup for name
   moveq    #NAMEY,d1
   moveq    #17,d2
   bsr      figure                        put name

   bsr      doops                         do blits

restart:

   moveq    #0,d0
   bsr      update                        update = all babies off

   move     #SPLATY,d1                    clear all splats
   move     #MEN1X+24,d0
   moveq    #16,d2
   bsr      erase                         erase splat 1

   move     #MEN2X+24,d0
   bsr      erase                         erase splat 2

   move     #MEN3X+24,d0
   bsr      erase                         erase splat 3

   bsr      doops                         do blits

   moveq    #EXTRAX,d0                    set up for extras
   moveq    #EXTRAY,d1
   moveq    #1,d2
   move     babies(a5),count(a5)          temporary counter

   subq     #1,babies(a5)

extralp:

   bsr      figure                        put extra baby
   bsr      doops                         do blits

   addi     #DISTANCE,d0                  move to next extra
   subq     #1,count(a5)                  decrement count

   bne      extralp
*                                         end page 74
   move     #SPEED,timer(a5)              initialize timer
   move     #SCOREX-50,d0                 wavex = SCOREX - 50
   moveq    #SCOREY,d1
   bsr      clearnum                      blank out wave number

   move     wave(a5),d2
   move     #SCOREX-50,d0
   moveq    #SCOREY,d1
   bsr      putnum                        put up wave number

   move     #SCOREX,d0
   moveq    #SCOREY,d1
   bsr      clearnum                      blank out score

   move     saved(a5),d2
   move     #SCOREX,d0
   moveq    #SCOREY,d1
   bsr      putnum                        put score

   clr.l    cycle1(a5)                    clear 64 baby bits
   clr.l    cycle2(a5)
   clr      babieson(a5)                  clear display bits

loop:

   move.l   gfxbase(a5),a6
   jsr      _LVOWaitTOF(a6)
   bsr      what                          any keyboard activity?

   move     codekey(a5),d0                get code of last key
   tst      attract(a5)                   are we in attract?
   beq      normplay                      if not, behave normally

   cmpi     #$45,d0                       was it an ESC?
   beq      exit

   tst      d0                            if zero, no key was hit
   beq      atrmode                       continue attract

   cmpi     #10,d0                        was it a digit key?
   bcc      nowavset                      if >= 10, was not

   move     d0,wave(a5)                   < 10, so store in wave
   bra      waveset                       set which wave

nowavset:

   cmpi     #$40,d0                       was it a space?
   bne      atrmode                       if not, ignore and continue

   move     #1,wave(a5)                   space means wave 1

*                                         waveset = a game is starting.
*                                         do setups.
waveset:

   clr      attract(a5)                   no longer attract mode
   clr      saved(a5)                     zero out score
   move     #5,babies(a5)                 5 extra babies
   move     #TITLEX,d0                    setup for title erase
   moveq    #TITLEY,d1
   moveq    #15,d2
   bsr      erase                         erase title

   bsr      doops                         do blits

   move     #NAMEX,d0                     set up for name erase
   moveq    #NAMEY,d1
   moveq    #17,d2
   bsr      erase                         erase name
   bsr      doops                         doops

   bra      restart                       go to restart

atrmode:

   bsr      computer

normplay:

   tst      d0
   bmi      nohit                         ignore negatives

   cmpi     #$45,d0                       ESC?
   beq      exit

   subi     #$1d,d0                       try keypads 123
   bcs      nohit                         not 123 or 46

   cmpi     #3,d0
   bcs      absvalue                      yes.  Was 123

   subi     #$10,d0                       try 46
   bcs      nohit                         not 46

   beq      tryleft                       if it was a 4

   cmpi     #2,d0                         is it 6?
   beq      tryright                      yes

   bra      nohit                         ignore otherwise

tryleft:

   cmpi     #MEN1X,place(a5)              try to go left
   beq      nohit                         already on left side

   move     place(a5),d0                  not on left.  so ok.
   subi     #90,d0                        move left one
   bra      delta                         continue

tryright:

   cmpi     #MEN3X,place(a5)              try to go right
   beq      nohit                         already on right side

   move     place(a5),d0                  not on right.  ok
   addi     #90,d0                        move right one
   bra      delta                         continue

absvalue:

   mulu     #90,d0                        an absolute, 012 x 90
   addi     #MEN1X,d0                     add in left man's x

delta:

   move     place(a5),d1                  see if any change
   cmp      d1,d0
   beq      nohit                         if same, don't bother

   move     d0,place(a5)                  update fireman's place
   move     d1,d0                         set up to erase old
   move     #MENY,d1
   moveq    #0,d2                         figure 0 is fireman
   bsr      erase                         erase old

   move     place(a5),d0                  set up for new
   bsr      figure                        put new

   bsr      doops                         do blits

nohit:

   bsr      sndchnge                      perhaps change sound

   subq     #1,timer(a5)
   bne      loop                          not 0.  no change in babies

   move     #SPEED,timer(a5)              restore timer

*                                                            end of page 75
   tst      attract(a5)                   in attract mode?
   beq      noattr                        if not, skip

   btst     #0,state+3(a5)                did a baby make it?
   beq      nodecbab                      if not, skip

   subq     #1,babieson(a5)               one fewer in cycle

nodecbab:

   cmpi     #MAXBABS,babieson(a5)         are there too many?
   bcc      ordinary                      if so, skip

   addq     #1,babieson(a5)               we will add one

   move.l   cycle1(a5),d4
   move.l   cycle2(a5),d5
   moveq    #1,d6                         add only one baby
   bra      pickloop                      go and pick one

noattr:

   tst.l    cycle1(a5)                    are there more
   bne      ordinary                      yes.  keep going

   tst.l    cycle2(a5)                    are there more
   bne      ordinary                      yes.  keep going

   tst.l    state(a5)                     are we in demo mode?
   bne      ordinary                      if so, keep going

*  Following code:  d4 and d5 consist of a 64 bit 'word' which
*     represents the baby cycle.

   moveq    #1,d5                         always first baby here
   moveq    #0,d4                         clear out upper 32 bits
   move     wave(a5),d6                   how many babies to put

waveput:

   subq     #1,d6                         sub one from counter
   beq      cycmade                       if zero, we are done

pickloop:

   bsr      rnd                           get a random number

   andi     #$3f,d0                       make 0 - 63
   tst      attract(a5)                   if attract, confine to > 14.

   beq      under14                       not attract, so skip

   cmpi     #14,d0
   bcs      pickloop                      if < 14, try again

under14:

   cmpi     #32,d0                        which 32 bits?
   bcs      inlow32                       less than 32 means d5

   btst     d0,d4                         otherwise, check d4
   bra      inhigh32

inlow32:

   btst     d0,d5                         check d5

inhigh32:

   bne      pickloop                      a one bit means baby

*  The following code checks for an impossible baby situation, where
*  the firement would have to be in two places at once.

   lea      bitlocs(pc),a0                prepare for check
   moveq    #6,d2                         there are 6 possible
   moveq    #0,d3                         collision count is zero.

bitcheck:

   move     d0,d1
   add.b    (a0)+,d1                      bit # plus offset == test
   cmpi.b   #64,d1                        off scale?
   bcc      noincr                        yes.  don't check.

   cmpi.b   #32,d1                        which 32 bits?
   bcs      low32                         < 32 means low 32

   btst     d1,d4                         otherwise, check upper
   bra      high32

low32:

   btst     d1,d5                         check d5

high32:

   beq      noincr                        zero bit means empty.

   addq     #1,d3                         a collision!  increment count.

noincr:

   subq     #1,d2                         any checks left?
   bne      bitcheck                      if so, continue

   tst      d3                            must be zero for ok
   bne      pickloop                      if > 0, try again

   cmpi     #32,d0                        which 32 bits
   bcs      low32set                      if < 32, is low 32.

   bset     d0,d4                         otherwise, put in high 32
   bra      hig32set

low32set:

   bset     d0,d5                         put in low 32

hig32set:

   bra      waveput                       continue with loop

cycmade:

   move.l   d4,cycle1(a5)                 we are all done
   move.l   d5,cycle2(a5)                 store the cycle

ordinary:

   moveq    #0,d0                         now comes updating
   roxr     #1,d0                         clear extend flag
   roxr     cycle1(a5)                    shift entire cycle
   roxr     cycle1+2(a5)                  one bit right in time
   roxr     cycle2(a5)
   roxr     cycle2+2(a5)
   move.l   state(a5),d0                  now, shift into visible
   roxr.l   #1,d0
   moveq    #16,d1                        place for first bounce
   btst     d1,d0                         any baby there?
   beq      no1                           if bit is zero, none.

   moveq    #MEN1X,d2                     where men should be
   cmp      place(a5),d2                  compare with place
   beq      bounce1                       good.  a bounced baby.

   cmp      old(a5),d2                    compare with last
   beq      bounce1                       last is good, too

   bclr     d1,d0                         player lost one
   bsr      death                         baby is paste

   bra      no1                           don't make sound

bounce1:

   bsr      sound                         make a bounce sound

no1:

   moveq    #8,d1                         second bounce place
   btst     d1,d0                         any baby there?
   beq      no2                           none, so skip

   move     #MEN2X,d2                     where men should be
   cmp      place(a5),d2                  are they there?
   beq      bounce2                       yes baby got bounced.

*                                                  end first column, page 76
   cmp      old(a5),d2                    were they there?
   beq      bounce2                       yes, baby bounced

   bclr     d1,d0                         clear baby bit
   bsr      death                         kill baby

   bra      no2                           skip sound

bounce2:

   bsr      sound                         make a bounce sound

no2:

   moveq    #2,d1                         last place for baby
   btst     d1,d0                         is baby there?
   beq      no3                           if not, skip

   move     #MEN3X,d2                     men should be
   cmp      place(a5),d2                  are they here
   beq      bounce3                       yes, baby bounced

   cmp      old(a5),d2                    were they there
   beq      bounce3                       yes.  baby bounced

   bclr     d1,d0                         clear baby
   bsr      death                         kill baby

   bra      no3                           no sound

bounce3:

   bsr      sound                         make bounce sound

no3:

   bsr      update                        update display

   move     place(a5),old(a5)             old == place
   btst     #0,state+3(a5)                did a baby make it?
   beq      loop                          no.  continue.

   tst      attract(a5)                   are we in attract mode?
   bne      loop                          if so, continue

   addq     #1,saved(a5)      ,d2         another baby saved.
   move     saved(a5),d2                  prepare to show score.
   move     #SCOREX,d0
   moveq    #SCOREY,d1
   bsr      putnum                        put up score

*  This next check is to see if we are in a new wave.  wavelens is a table
*  of the changeover points for new waves.

   move     wave(a5),d0                   see if we are in a new wave
   lea      wavelens-2(pc),a0
   adda     d0,a0
   adda     d0,a0
   move     (a0),d0                       get count for next
   cmp      saved(a5),d0                  are we far enough
   bcc      loop                          not far enough

   addq     #1,wave(a5)                   we are in new wave
   move     wave(a5),d2                   prepare to show new wave
   move     #SCOREX-50,d0
   moveq    #SCOREY,d1
   bsr      putnum                        put new wave number

   bra      loop                          continue

exit:

   move.l   execbase(a5),a6               game over.  close up
   lea      soundio(a5),a1
   jsr      _LVOCloseDevice(a6)

   move.b   soundport+MP_SIGBIT(a5),d0
   jsr      _LVOFreeSignal(a6)

   move.l   babywindow(a5),a0
   move.l   intbase(a5),a6
   jsr      _LVOCloseWindow(a6)

nowindow:

   move.l   babyscreen(a5),a0
   move.l   intbase(a5),a6
   jsr      _LVOCloseScreen(a6)

noscreen:

   move.l   allocated(a5),d1                    free CHIP mem if there
   beq      nomem                               zero means didn't get

   move.l   d1,a1
   move.l   #dataend-datastart,d0               size of it
   move.l   execbase(a5),a6
   jsr      _LVOFreeMem(a6)                     free it

nomem:

   rts

*  This handles a baby's death.  Put a splat and decrement extra babies,
*  perhaps end game.  Enters with d2 the X to put the splay.  d0 is the
*  visible portion of the cycle, so preserve it.

death:

   move.l   d0,-(sp)                      set up for splat
   move     d2,d0
   addi     #24,d0
   move     #SPLATY,d1
   moveq    #16,d2
   bsr      figure                        put splat

   bsr      doops                         do blits

   move     babies(a5),d1                 get # of babies
   beq      toobad                        if zero, game over

   subq     #1,babies(a5)                 one fewer
   mulu     #DISTANCE,d1                  compute where to erase
   moveq    #EXTRAX,d0
   add      d1,d0
   moveq    #EXTRAY,d1
   moveq    #1,d2
   bsr      erase                         erase an extra baby

   bsr      doops                         do blits

   move.l   (sp)+,d0
   rts

*  The game is over.  Do not restore d0, and do not return.
*  Throw away things on the stack.

toobad:

   addq     #8,a7                         d0 and retad
   move     #1,babies(a5)
   bra      restart2                      restart

*  This routine puts a number.  d2 is the number, d0 = x and d1 = y.
*  We print it from right to left, dividing by 10 and printing the modulus.

putnum:

   move     d2,temp(a5)                   put in temp storage
   move     #4,count(a5)                  never more than four
*                                                            end of page 76
numberlp:

   move     temp(a5),d2
   ext.l    d2
   divu     #10,d2

   move     d2,temp(a5)                   put back in temp
   swap     d2
   addq     #5,d2                         make it a digit
   bsr      figure                        put it

   bsr      doops                         do blits

   tst      temp(a5)                      any more digits?
   beq      alldigs                       if zero, we're done.

   subq     #8,d0                         move left one place
   subq     #1,count(a5)                  did we print a 4 yet?
   bne      numberlp                      if not, continue.

alldigs:

   rts

*  Clear out where a number is to be displayed.  d0 = x, d1 = y.

clearnum:

   move     #4,count(a5)
   moveq    #5,d2                         do 5 just to be sure

clearlp:

   bsr      erase                         blank out

   bsr      doops                         do blits

   subq     #8,d0                         move left one
   subq     #1,count(a5)                  any left?
   bne      clearlp                       if so, continue.

   rts

*  This routine updates the visible portion of the cycle.
*  It will erase babies when they are turned off, and
*  Display babies when they are turned on.
*  If bits stay the same, nothing is done.
*  Enter with d0 the new state.

update:

   move.l   state(a5),d1                  get old state
   move.l   d0,state(a5)                  update state
   eor.l    d0,d1                         get changing bits
   move.l   d1,changes(a5)                save in changes
   clr      count(a5)                     clear counter

updatelp:

   move     count(a5),d2                  get counter
   move.l   changes(a5),d1                get changes
   btst     d2,d1                         is this bit one?
   beq      updated                       if not, skip

   moveq    #25,d0                        25-bit which is baby
   move.l   state(a5),d1                  get new state
   btst     d2,d1                         see if on or off
   beq      babyoff                       if zero, erase baby

   sub      d2,d0                         compute 25-bit number
   bsr      putbaby                       put baby

   bra      babydone                      skip

babyoff:

   sub      d2,d0                         compute 25-bit number
   bsr      erasbaby                      erase baby

babydone:

   bsr      doops                         do blits

updated:

   addq     #1,count(a5)                  move to next bit
   cmpi     #26,count(a5)                 are we done?
   bne      updatelp                      if not, continue

   rts


*  This routine is the brains of the demo mode.  It handles where to put
*  the firemen to make sure all babies survive.  It returns a number in d0
*  which is like a keycode, so other code is unaware of who is controlling
*  the men.

computer:

   moveq    #$1d,d0                       default is left side
   moveq    #3,d1                         place on right
   moveq    #9,d2                         place in middle
   moveq    #17,d3                        place on left
   move.l   state(a5),d5                  get state

aheadlp:

   btst     d1,d5                         baby on right?
   bne      returnlf                      if so, return a '3'

   btst     d2,d5                         baby in middle?
   bne      returnle                      if so, return a '2'

   btst     d3,d5                         baby on left?
   bne      returnld                      if so, return a '1'

   lsr.l    #1,d5                         move forward in time
   bne      aheadlp                       keep going if any more

   rts                                    default case,  left side.


returnld:

   moveq    #$1d,d0
   rts

returnle:

   moveq    #$1e,d0
   rts

returnlf:

   moveq    #$1f,d0
   rts


what:

   move.l   execbase(a5),a6
   move     #-1,codekey(a5)               default case
   move.l   uport(a5),a0                  get reply port
   move.b   MP_SIGBIT(a0),d1              get signal bit
   moveq    #1,d0
   asl.l    d1,d0                         make mask
   move.l   mytask(a5),a0                 get our task block handle
   move.l   TC_SIGRECVD(a0),d1            get our signals
   and.l    d0,d1                         apply mask
   beq      none                          if zero, none there.

   jsr      _LVOWait(a6)                  let exec clear it

msgloop:

   move.l   uport(a5),a0
   jsr      _LVOGetMsg(a6)                get a message

   tst.l    d0
   beq      donelp                        if zero, we are done.

   move.l   d0,-(sp)                      push message
   pea      nextmsg(pc)                   push return address
   move.l   d0,a4
*                                                             end of page 77
   move.l   im_Class(a4),d0               look at Class
   cmpi.l   #RAWKEY,d0                    RAWKEY?
   beq      rkey

donelp:
none:

   rts                                    sloppy.  various uses this rts

nextmsg:

   move.l   (sp)+,a1                      get the message
   jsr      _LVOReplyMsg(a6)

   bra      msgloop                       continue

rkey:

   move     im_Code(a4),d0
   tst.b    d0                            key up?
   bmi      notdown                       if so, ignore

   move     d0,codekey(a5)                save in code

notdown:

   rts

*  Routine to clear d0 bytes at a0

clearmem:

   clr.b    (a0)+
   subq     #1,d0
   bne      clearmem
   rts

*  Routine to make a bounce sound

sound:

   tst      attract(a5)                   attract mode is quiet
   bne      dontsnd

   move.l   d0,-(sp)                      save
   lea      soundio(a5),a1                get io block
   move.l   execbase(a5),a6
   jsr      _LVOCheckIO(a6)               are we busy?

   tst.l    d0
   bne      quiet                         if not zero, ok

   lea      soundio(a5),a1
   move.l   IO_DEVICE(a1),a6
   jsr      DEV_ABORTIO(a6)               abort sound

quiet:

   lea      soundio(a5),a1
   move     #CMD_WRITE,IO_COMMAND(a1)
   move.l   memory(a5),a0                 get chip start
   adda     #soundbuf-datastart,a0        add offset
   move.l   a0,ioa_Data(a1)               point to waveform
   moveq    #2,d0                         length is two bytes
   move.l   d0,ioa_Length(a1)
   move     #80,ioa_Cycles(a1)
   move.b   #ADIOF_PERVOL,IO_FLAGS(a1)
   move     #2590,ioa_Period(a1)
   move     #64,ioa_Volume(a1)

   move.l   IO_DEVICE(a1),a6
   jsr      DEV_BEGINIO(a6)

   lea      soundio(a5),a0                copy over
*                                                   end first column page 78
   lea      io2(a5),a1                    to secondary io block
   move     ioa_Period(a0),ioa_Period(a1)
   move     ioa_Volume(a0),ioa_Volume(a1)    more copying
   move.l   (sp)+,d0

dontsnd:

   rts

sndchnge:

   move.l   execbase(a5),a6
   lea      soundio(a5),a1                get io block
   jsr      _LVOCheckIO(a6)

   tst.l    d0
   bne      nosound

   lea      io2(a5),a1                    modify sound
   move     #ADCMD_PERVOL,IO_COMMAND(a1)
   move.b   #ADIOF_SYNCCYCLE,IO_FLAGS(a1)
   subi     #150,ioa_Period(a1)           raise frequency
   move.l   IO_DEVICE(a1),a6
   jsr      DEV_BEGINIO(a6)

nosound:

   rts

*  This routine sets up d0,d1 and d2 for a baby operation.  d0 = x.
*  d1 = y,  d2 = which of four babies, each 90 degree-possibility.

setbaby:

   mulu     #6,d0                      each entry is 6 bytes
   lea      locs(pc),a0                get start of a table
   adda     d0,a0                      move out to entry
   move     (a0)+,d0                   get data
   move     (a0)+,d1
   move     (a0)+,d2
   rts

*  Put a baby.  This falls through the comments to figure routine.

putbaby:

   bsr      setbaby



*  This is a complicated blitter routine.  It will do any 'size' blits.
*  This routine lines up all data for up to 10 consecutive blits, to be
*  handled by the doops routine.

*  The 'size' is based on which figure to put.  d0 = x, d1 = y, d2 = figure #.
*  It looks in the "moving:" table of the offset into the chip memory block.

*  The first word of each of the images in the data section of this program,
*  the hex value, is a pre-calclation of what to put into BLTSIZE.

*  The second word, in decimal,  is what to put into BLTMODS, C (source)
*  and D (destination).

*  The third word, also decimal, is how many bytes per bitplane.

*  The fourth word is a stencil or mask.  It has the bits set where the blit
*  is to have an effect.

*  Then come the bitplanes for each blit:
*  A  points to the stencil
*  B  points to a bitplane
*  C and D point to the background and destination. (Dave's video bitplanes)

figure:

   move.l   nextop(a5),a2                 get op pointer
   move     d0,d4
   andi     #$000f,d4                     mask so low 4 of X
   ror      #4,d4                         rotate to upper four

   move     d4,op_bltcon1(a2)             put in bltcon1 for shifts
   ori      #$0fca,d4                     OR in MinTerm

   move     d4,op_bltcon0(a2)             put in bltcon0
   moveq    #-2,d4                        mods for a and b = -2

   move     d4,op_bltamod(a2)
   move     d4,op_bltbmod(a2)
   move.l   #$ffff0000,op_bltaflwm(a2)    throw away last.  keep all first.

   move     d0,d4
   lsr      #4,d4                         compute word
   add      d4,d4                         double for byte address
   move     d1,d3

   mulu     #40,d3                        compute line
   add      d3,d4                         compute word offset into bitplane

   lea      moving(pc),a3                 start of figure table
   adda     d2,a3
   adda     d2,a3
   move     (a3),d3                       get element

   move.l   memory(a5),a3
   adda     d3,a3                         add to chip offset

   move     (a3)+,sizetemp(a5)            bltsize for later
   move     (a3)+,d3                      mods for video's C&D
   move     d3,op_bltcmod(a2)
   move     d3,op_bltdmod(a2)
   move     (a3)+,d3                      get size of a bitplane

   move.l   a3,op_bltapt(a2)              stencil follows

   move.l   myplanes(a5),a1               table of bitplanes

   moveq    #opsize,d5                    size of an operation

   moveq    #DEPTH,d6                     depth operations

figurelp:

   adda     d3,a3                         skip to new bitplane
   move.l   a3,op_bltbpt(a2)
   move.l   (a1)+,a0                      next vidio bitplane
   adda     d4,a0                         add offset

   move.l   a0,op_bltcpt(a2)              put in C and D
   move.l   a0,op_bltdpt(a2)

   move     sizetemp(a5),op_bltsize(a2)

*  The following moves copy data that doesn't change into the next
*  operation.  The last copy is wasted as it is written over by the next
*  figure.

   move.l   op_bltapt(a2),opsize+op_bltapt(a2)
   move.l   op_bltcon0(a2),opsize+op_bltcon0(a2)
   move.l   op_bltamod(a2),opsize+op_bltamod(a2)
   move.l   op_bltcmod(a2),opsize+op_bltcmod(a2)
*                                                  end page 78
   move.l   op_bltaflwm(a2),opsize+op_bltaflwm(a2)
   adda     d5,a2                               skip to new operation
   subq     #1,d6                               depth counter
   bne      figurelp                            if more, continue.

   move.l   a2,nextop(a5)                       save for future
   addq     #DEPTH,numberops(a5)                just did 'depth' ops

   rts


erasbaby:

   bsr      setbaby

*  The following routine erases a figure.  The only differences from the
*  routine above are:
*  No B needed because not copying... only clearing.
*  Different MinTerm.

erase:

   move.l   nextop(a5),a2                 get op pointer
   move     d0,d4
   andi     #$000f,d4                     mask so low 4 of X
   ror      #4,d4                         rotate to upper four

   clr      op_bltcon1(a2)
   ori      #$0b0a,d4                     OR in MinTerm

   move     d4,op_bltcon0(a2)             put in bltcon0
   moveq    #-2,d4                        mods for a and b = -2

   move     d4,op_bltamod(a2)
   move.l   #$ffff0000,op_bltaflwm(a2)    throw away last.  keep all first.

   move     d0,d4
   lsr      #4,d4                         compute word
   add      d4,d4                         double for byte address
   move     d1,d3

   mulu     #40,d3                        compute line
   add      d3,d4                         compute word offset into bitplane

   lea      moving(pc),a3                 start of figure table
   adda     d2,a3
   adda     d2,a3
   move     (a3),d3                       get element

   move.l   memory(a5),a3
   adda     d3,a3                         add to chip offset

   move     (a3)+,sizetemp(a5)            bltsize for later
   move     (a3)+,d3                      mods for video's C&D
   move     d3,op_bltcmod(a2)
   move     d3,op_bltdmod(a2)
   move     (a3)+,d3                      get size of a bitplane

   move.l   a3,op_bltapt(a2)              stencil follows

   move.l   myplanes(a5),a1               table of bitplanes

   moveq    #opsize,d5                    size of an operation

   moveq    #DEPTH,d6                     depth operations

eraselp:

   move.l   (a1)+,a0                      next vidio bitplane
   adda     d4,a0                         add offset

   move.l   a0,op_bltcpt(a2)              put in C and D
   move.l   a0,op_bltdpt(a2)

   move     sizetemp(a5),op_bltsize(a2)
   move.l   op_bltapt(a2),opsize+op_bltapt(a2)
   move.l   op_bltcon0(a2),opsize+op_bltcon0(a2)
   move.l   op_bltamod(a2),opsize+op_bltamod(a2)
   move.l   op_bltcmod(a2),opsize+op_bltcmod(a2)
   move.l   op_bltaflwm(a2),opsize+op_bltaflwm(a2)
   adda     d5,a2                               skip to new operation
   subq     #1,d6                               depth counter
   bne      eraselp                             if more, continue.

   move.l   a2,nextop(a5)                       save for future
   addq     #DEPTH,numberops(a5)                just did depth ops
   rts

*  Do all blitter operations that have been stored, if any.  An operation
*  consists of all the registers to be loaded into the blitter.  We do an
*  OwnBlitter() to make sure we don't mess up someone else's operations.

doops:

   move     numberops(a5),d3              How many bitplanes did we blit?
   beq      noops                         None, stupid!

   move.l   execbase(a5),a6
   jsr      _LVOForbid(a6)                Stop all multi-tasking.

   move.l   gfxbase(a5),a6
   jsr      _LVOOwnBlitter(a6)            Lock blitter to this task.

*  'operations' is where we allocated enough space to store all writes to
*  all blitter registers for a total of 10 different sequences.

   lea      operations(a5),a1             Load our blitter register package.
   move.l   #HARDWARE,a0                  Load the hardware base. ($dff000)

*  'dmacon' is the correct designation for the dma control - Write register.
*  RKM calls it, 'DMACONW'.  By setting bit 10, we set the BLTPRI bit and
*  lock the CPU from the memory bus.  To cause the reaction, we must also
*  set bit 15.  Hence, the move.w  #$8400.

   move.w   #$8400,dmacon(a0)

*  We check to see if the blitter is busy, just in case.  Supposedly,
*  OwnBlitter() does this, but a bug in Intuition's OpenScreen routine
*  causes an early return.  Best be careful!

*  The 14th bit of dmacon is called BBUSY, is read-only, and is known as the
*  blitter-busy status bit.  Sounds like the Max HeadRoom bit, to me.


   move.w   #$4000,d7                     Move 0100 0000 0000 0000 to d7.

waitblit2:

   move.w   dmaconr(a0),d6                Copy the blitter READ register.
   and      d7,d6                         AND its contents to see if 14 set.
   bne      waitblit2                     If so, busy-wait!

dooplp:

   move.l   (a1)+,bltcon0(a0)          Load the blitter registers for the
   move     (a1)+,bltamod(a0)          operation on one of the planes.
   move     (a1)+,bltbmod(a0)          Behold the use of LONGS.  bltcon1
   move     (a1)+,bltcmod(a0)          thus goes right with bltcon0, and
   move     (a1)+,bltdmod(a0)          other junkers, held holy by the RKM,
   move.l   (a1)+,bltafwm(a0)          are treated as one LONG instead of
   move.l   (a1)+,bltapt(a0)           'low-order' and 'high-order' words.
   move.l   (a1)+,bltbpt(a0)
*                                                      end column 1, page 79
   move.l   (a1)+,bltcpt(a0)           Post increment preps for next blit.
   move.l   (a1)+,bltdpt(a0)
   move     (a1)+,bltsize(a0)          Once this loads, 'EL BLITO!!!!'

*  This next check is not exactly like busy-waiting, which is bad.
*  Since the blitter is nasty, the 68000 will get almost no cycles.  Hence,
*  this code will probably execute few times, if any.

waitblit:

   move     dmaconr(a0),d6                A repeat of waitblit2.
   and      d7,d6                         You may whistle 'Dixie' while
   bne      waitblit                      waiting for this loop to execute.

   subq     #1,d3                         Test for pending blits.
   bne      dooplp                        Loop if true.

   jsr      _LVODisownBlitter(a6)         Release blitter.

   move.l   execbase(a5),a6
   jsr      _LVOPermit(a6)                Return to multi-tasking.

clearops:

   lea      operations(a5),a0             Make the first op (blit) the
   move.l   a0,nextop(a5)                 next one.
   clr      numberops(a5)                 Reset counter.

noops:

   rts


*  This routine makes a random 8-bit number in d0.  It performs a shift
*  where the new bit is the exclusive-or of two high bits.


rnd:

   move.l   seed(a5),d0
   moveq    #8,d2                         Will do 8 times

rtop:

   move.b   d0,d1
   ror.b    #3,d1                         get 5th bit
   eor.b    d0,d1                         eor with the 2nd bit
   roxr.b   #2,d1                         put in X flag
   roxr.l   #1,d0                         shift in to seed
   subq     #1,d2                         any more?
   bne      rtop                          loop if so

   move.l   d0,seed(a5)                   restore seed
   rts


*****  End of Code as such.

*  Table of changeover points for the waves.

wavelens:

   dc.w   14,42,84,140,210,294,392,504,630,770,924,9999

nscreen:

   dc.w  0,0,320,200,DEPTH
   dc.b  1,0
   dc.w  V_SPRITES
   dc.w  CUSTOMSCREEN
   dc.l  0,0,0,0

nwindow:

   dc.w  0,0,320,200
   dc.b  0,0
   dc.l  RAWKEY
   dc.l  ACTIVATE+BORDERLESS+SMART_REFRESH+REPORTMOUSE+BACKDROP
   dc.l  0,0,0,0,0
   dc.w  0,0,0,0
   dc.w  CUSTOMSCREEN

ctable:

   dc.w  $000,$fff,$f00,$00f,$f0f,$00f,$fff,$f00

*  Places to be checked for a baby collision

bitlocs:

   dc.b  -14,-8,-6,6,8,14


audiomap:

   dc.b  1,2,4,8

audname:
   dc.b  'audio.device',0
   EVEN

intuiname:
   dc.b  'intuition.library',0
   EVEN

gfxname:
   dc.b  'graphics.library',0
   EVEN

dosnam:
   dc.b  'dos.library',0
   EVEN

*  This is the loction table for all babies.
*  Format:  X, Y, Baby# 1 - 4.      You have 26 babies in the table.

locs:

   dc.w  1,32,1,28,34,2,41,48,3,50,64,4
   dc.w  55,82,1,60,110,2,62,127,3,60,152,4
   dc.w  62,171,1,77,160,2,86,141,3,93,122,4
   dc.w  111,108,1,127,122,2,136,141,3,147,157,4
   dc.w  152,171,1,167,153,2,180,140,3,197,129,4
   dc.w  214,140,1,228,157,3,242,171,1,256,152,1
   dc.w  271,134,3,300,139,1


*  This is the table of offsets into the CHIP memory block for the figures.

moving:

   dc.w  firemen-datastart    0
   dc.w  baby1-datastart      1
   dc.w  baby2-datastart      2
   dc.w  baby3-datastart      3
   dc.w  baby4-datastart      4
   dc.w  digit0-datastart     5
   dc.w  digit1-datastart
   dc.w  digit2-datastart
   dc.w  digit3-datastart
   dc.w  digit4-datastart
   dc.w  digit5-datastart
   dc.w  digit6-datastart
   dc.w  digit7-datastart
   dc.w  digit8-datastart
   dc.w  digit9-datastart
   dc.w  title-datastart      15
   dc.w  splat-datastart      16
   dc.w  dash-datastart       17
   dc.w  truck-datastart      18
   dc.w  building-datastart   19


*  This is the start of the data that must be in CHIP memory.  If already
*  in chip, we will not bother to allocte and copy.

datastart:

soundbuf:

   dc.w     $807f


*  We begin the figures for blitter copies.

baby1:

   dc.w  $0402,36,32
   dc.w  $0700,$0f80,$0f80,$0700,$0700,$1fc0,$bfe8,$6fb0
   dc.w  $0f80,$0700,$0f80,$4f90,$7ff0,$1fc0,$0000,$0000
   dc.w  $0000,$0500,$0000,$0200,$0000,$0000,$0000,$0000
   dc.w  $0000,$0000,$0f80,$0f80,$0700,$0700,$0000,$0000
   dc.w  $0700,$0a80,$0f80,$0500,$0700,$1fc0,$bfe8,$6fb0
   dc.w  $0f80,$0700,$0000,$4010,$78f0,$18c0,$0000,$0000
   dc.w  $ffff,$ffff,$ffff,$ffff,$ffff,$ffff,$ffff,$ffff
   dc.w  $ffff,$ffff,$ffff,$ffff,$ffff,$ffff,$ffff,$ffff

baby3:

   dc.w  $0402,36,32
   dc.w  $0000,$0000,$1fc0,$7ff0,$4f90,$0f80,$0700,$0f80
   dc.w  $6fb0,$bfe8,$1fc0,$0700,$0700,$0f80,$0f80,$0700
   dc.w  $0000,$0000,$0700,$0700,$0f80,$0f80,$0000,$0000
   dc.w  $0000,$0000,$0000,$0000,$0200,$0000,$0500,$0000
   dc.w  $0000,$0000,$18c0,$78f0,$4010,$0000,$0700,$0f80
   dc.w  $6fb0,$bfe8,$1fc0,$0700,$0500,$0f80,$0a80,$0700
   dc.w  $ffff,$ffff,$ffff,$ffff,$ffff,$ffff,$ffff,$ffff
   dc.w  $ffff,$ffff,$ffff,$ffff,$ffff,$ffff,$ffff,$ffff

baby2:

   dc.w  $0402,36,32
   dc.w  $0080,$3100,$2180,$60c0,$7bcc,$7ffe,$7ffe,$7ffe
   dc.w  $7bcc,$60c0,$2180,$3100,$0080,$0000,$0000,$0000
   dc.w  $0000,$0000,$0000,$0000,$1800,$7804,$7810,$7804
   dc.w  $1800,$0000,$0000,$0000,$0000,$0000,$0000,$0000
   dc.w  $0080,$3100,$2180,$60c0,$63cc,$07fa,$07ee,$07fa
   dc.w  $63cc,$60c0,$2180,$3100,$0080,$0000,$0000,$0000
   dc.w  $ffff,$ffff,$ffff,$ffff,$ffff,$ffff,$ffff,$ffff
   dc.w  $ffff,$ffff,$ffff,$ffff,$ffff,$ffff,$ffff,$ffff

baby4:

   dc.w  $0402,36,32
   dc.w  $0100,$008c,$0184,$0306,$33de,$7ffe,$7ff3,$7ffe
   dc.w  $33de,$0306,$0184,$008c,$0100,$0000,$0000,$0000
   dc.w  $0000,$0000,$0000,$0000,$0018,$201e,$081e,$201e
   dc.w  $0018,$0000,$0000,$0000,$0000,$0000,$0000,$0000
   dc.w  $0100,$008c,$0184,$0306,$33c6,$5fe0,$77e0,$5fe0
   dc.w  $33c6,$0306,$0184,$008c,$0100,$0000,$0000,$0000
   dc.w  $ffff,$ffff,$ffff,$ffff,$ffff,$ffff,$ffff,$ffff
   dc.w  $ffff,$ffff,$ffff,$ffff,$ffff,$ffff,$ffff,$ffff

firemen:

   dc.w  $0546,28,210

* stencil

   dc.w  $0ff0,$0000,$0000,$01fe,$0000
   dc.w  $3ff0,$0000,$0000,$01ff,$8000
   dc.w  $fff8,$0000,$0000,$03ff,$e000
   dc.w  $07e0,$0000,$0000,$00fc,$0000
   dc.w  $07f8,$0000,$0000,$03fc,$0000
   dc.w  $03e0,$0000,$0000,$00f8,$0000
   dc.w  $01c0,$0000,$0000,$0070,$0000
   dc.w  $03e0,$0000,$0000,$00f8,$0000
   dc.w  $07f8,$0000,$0000,$03fc,$0000
   dc.w  $07fe,$0000,$0000,$0ffc,$0000
   dc.w  $07ff,$ffff,$ffff,$fffc,$0000
   dc.w  $03fb,$ffff,$ffff,$fbf8,$0000
   dc.w  $03f8,$e000,$0000,$e3f8,$0000
   dc.w  $07f0,$0000,$0000,$01fc,$0000
   dc.w  $07f0,$0000,$0000,$01fc,$0000
   dc.w  $07f8,$0000,$0000,$03fc,$0000
   dc.w  $03f8,$0000,$0000,$03f8,$0000
   dc.w  $03fc,$0000,$0000,$07f8,$0000
   dc.w  $07bc,$0000,$0000,$07bc,$0000
   dc.w  $0f1e,$0000,$0000,$0f1e,$0000
   dc.w  $1f1f,$0000,$0000,$1f1f,$0000

* plane0

   dc.w  $0fe0,$0000,$0000,$00fe,$0000
   dc.w  $3ff0,$0000,$0000,$01ff,$8000
   dc.w  $fff8,$0000,$0000,$03ff,$e000
   dc.w  $0020,$0000,$0000,$0080,$0000
   dc.w  $0000,$0000,$0000,$0000,$0000
   dc.w  $0000,$0000,$0000,$0000,$0000
   dc.w  $0000,$0000,$0000,$0000,$0000
   dc.w  $03e0,$0000,$0000,$00f8,$0000
   dc.w  $07f8,$0000,$0000,$03fc,$0000
   dc.w  $07fe,$0000,$0000,$0ffc,$0000
   dc.w  $07fc,$0000,$0000,$07fc,$0000
   dc.w  $03f8,$0000,$0000,$03f8,$0000
   dc.w  $03f8,$0000,$0000,$03f8,$0000
   dc.w  $07f0,$0000,$0000,$01fc,$0000
   dc.w  $07f0,$0000,$0000,$01fc,$0000
   dc.w  $07f8,$0000,$0000,$03fc,$0000
   dc.w  $03f8,$0000,$0000,$03f8,$0000
   dc.w  $03fc,$0000,$0000,$07f8,$0000
   dc.w  $07bc,$0000,$0000,$07bc,$0000
   dc.w  $0f1e,$0000,$0000,$0f1e,$0000
   dc.w  $1f1f,$0000,$0000,$1f1f,$0000

* plane1

   dc.w  $0ff0,$0000,$0000,$01fe,$0000
   dc.w  $3ff0,$0000,$0000,$01ff,$8000
   dc.w  $fff8,$0000,$0000,$03ff,$e000
   dc.w  $07c0,$0000,$0000,$007c,$0000
   dc.w  $07f8,$0000,$0000,$03fc,$0000
   dc.w  $03e0,$0000,$0000,$00f8,$0000
   dc.w  $01c0,$0000,$0000,$0070,$0000
   dc.w  $03e0,$0000,$0000,$00f8,$0000
   dc.w  $07f8,$0000,$0000,$03fc,$0000
   dc.w  $07fe,$0000,$0000,$0ffc,$0000
   dc.w  $07fc,$7fff,$ffff,$c7fc,$0000
   dc.w  $03f8,$1fff,$ffff,$03f8,$0000
   dc.w  $03f8,$0000,$0000,$03f8,$0000
   dc.w  $07f0,$0000,$0000,$01fc,$0000
   dc.w  $0000,$0000,$0000,$0000,$0000
   dc.w  $0000,$0000,$0000,$0000,$0000
   dc.w  $0000,$0000,$0000,$0000,$0000
   dc.w  $0000,$0000,$0000,$0000,$0000
   dc.w  $0000,$0000,$0000,$0000,$0000
   dc.w  $0000,$0000,$0000,$0000,$0000
   dc.w  $0000,$0000,$0000,$0000,$0000

* plane2

   dc.w  $0ff0,$0000,$0000,$01fe,$0000
   dc.w  $3ff0,$0000,$0000,$01ff,$8000
   dc.w  $fff8,$0000,$0000,$03ff,$e000
   dc.w  $07e0,$0000,$0000,$00fc,$0000
   dc.w  $07f8,$0000,$0000,$03fc,$0000
   dc.w  $03e0,$0000,$0000,$00f8,$0000
   dc.w  $01c0,$0000,$0000,$0070,$0000
   dc.w  $03e0,$0000,$0000,$00f8,$0000
   dc.w  $07f8,$0000,$0000,$03fc,$0000
   dc.w  $07fe,$0000,$0000,$0ffc,$0000
   dc.w  $07ff,$ffff,$ffff,$fffc,$0000
   dc.w  $03fb,$ffff,$ffff,$fbf8,$0000
   dc.w  $03f8,$e000,$0000,$e3f8,$0000
   dc.w  $07f0,$0000,$0000,$01fc,$0000
   dc.w  $07f0,$0000,$0000,$01fc,$0000
   dc.w  $07f8,$0000,$0000,$03fc,$0000
   dc.w  $03f8,$0000,$0000,$03f8,$0000
   dc.w  $03fc,$0000,$0000,$07f8,$0000
   dc.w  $07bc,$0000,$0000,$07bc,$0000
   dc.w  $0f1e,$0000,$0000,$0f1e,$0000
   dc.w  $1f1f,$0000,$0000,$1f1f,$0000

digit0:

   dc.w  $01c2,36,14
   dc.w  $f800,$f800,$f800,$f800,$f800,$f800,$f800
   dc.w  $7000,$8800,$8800,$8800,$8800,$8800,$7000
   dc.w  $0000,$0000,$0000,$0000,$0000,$0000,$0000
   dc.w  $0000,$0000,$0000,$0000,$0000,$0000,$0000

digit1:

   dc.w  $01c2,36,14
   dc.w  $f800,$f800,$f800,$f800,$f800,$f800,$f800
   dc.w  $2000,$6000,$2000,$2000,$2000,$2000,$7000
   dc.w  $0000,$0000,$0000,$0000,$0000,$0000,$0000
   dc.w  $0000,$0000,$0000,$0000,$0000,$0000,$0000

digit2:

   dc.w  $01c2,36,14
   dc.w  $f800,$f800,$f800,$f800,$f800,$f800,$f800
   dc.w  $7000,$8800,$0800,$1000,$2000,$4000,$f800
   dc.w  $0000,$0000,$0000,$0000,$0000,$0000,$0000
   dc.w  $0000,$0000,$0000,$0000,$0000,$0000,$0000

digit3:

   dc.w  $01c2,36,14
   dc.w  $f800,$f800,$f800,$f800,$f800,$f800,$f800
   dc.w  $7000,$8800,$0800,$3000,$0800,$8800,$7000
   dc.w  $0000,$0000,$0000,$0000,$0000,$0000,$0000
   dc.w  $0000,$0000,$0000,$0000,$0000,$0000,$0000

digit4:

   dc.w  $01c2,36,14
   dc.w  $f800,$f800,$f800,$f800,$f800,$f800,$f800
   dc.w  $8800,$8800,$8800,$f800,$0800,$0800,$0800
   dc.w  $0000,$0000,$0000,$0000,$0000,$0000,$0000
   dc.w  $0000,$0000,$0000,$0000,$0000,$0000,$0000

digit5:

   dc.w  $01c2,36,14
   dc.w  $f800,$f800,$f800,$f800,$f800,$f800,$f800
   dc.w  $f800,$8000,$8000,$f000,$0800,$8800,$7000
   dc.w  $0000,$0000,$0000,$0000,$0000,$0000,$0000
   dc.w  $0000,$0000,$0000,$0000,$0000,$0000,$0000

digit6:

   dc.w  $01c2,36,14
   dc.w  $f800,$f800,$f800,$f800,$f800,$f800,$f800
   dc.w  $7000,$8800,$8000,$f000,$8800,$8800,$7000
   dc.w  $0000,$0000,$0000,$0000,$0000,$0000,$0000
   dc.w  $0000,$0000,$0000,$0000,$0000,$0000,$0000

digit7:

   dc.w  $01c2,36,14
   dc.w  $f800,$f800,$f800,$f800,$f800,$f800,$f800
   dc.w  $f800,$0800,$1000,$2000,$4000,$8000,$8000
   dc.w  $0000,$0000,$0000,$0000,$0000,$0000,$0000
   dc.w  $0000,$0000,$0000,$0000,$0000,$0000,$0000

digit8:

   dc.w  $01c2,36,14
   dc.w  $f800,$f800,$f800,$f800,$f800,$f800,$f800
   dc.w  $7000,$8800,$8800,$7000,$8800,$8800,$7000
   dc.w  $0000,$0000,$0000,$0000,$0000,$0000,$0000
   dc.w  $0000,$0000,$0000,$0000,$0000,$0000,$0000

digit9:

   dc.w  $01c2,36,14
   dc.w  $f800,$f800,$f800,$f800,$f800,$f800,$f800
   dc.w  $7000,$8800,$8800,$7800,$0800,$0800,$0800
   dc.w  $0000,$0000,$0000,$0000,$0000,$0000,$0000
   dc.w  $0000,$0000,$0000,$0000,$0000,$0000,$0000

splat:

   dc.w  $0103,34,16

   dc.w  $03ff,$8000,$07ff,$8000
   dc.w  $1fff,$f000,$ffff,$fc00

   dc.w  $00ce,$8000,$061f,$0000
   dc.w  $1189,$8000,$ffff,$fc00

   dc.w  $03f1,$8000,$07f1,$8000
   dc.w  $1ff7,$f000,$ffff,$fc00

   dc.w  $03ff,$8000,$07ff,$8000
   dc.w  $1fff,$f000,$ffff,$fc00

dash:

   dc.w  $0209,22,128

   dc.w  $fc00,$f8,$0,$180e,$18,$e0,$3800,$0
   dc.w  $6600,$6c,$0,$6,$3c,$60,$1800,$0
   dc.w  $6666,$66,$3c66,$3836,$3c,$3e6c,$183c,$6600
   dc.w  $7c66,$66,$666,$186e,$66,$6076,$1866,$6600
   dc.w  $6666,$66,$1e66,$1866,$7e,$3c66,$187e,$6600
   dc.w  $663c,$6c,$663c,$1866,$c3,$666,$1860,$3c00
   dc.w  $fc18,$f8,$3b18,$3c3b,$c3,$7ce6,$3c3c,$1800
   dc.w  $70,$0,$0,$0,$0,$0,$0,$7000

   dc.w  $fc00,$f8,$0,$180e,$18,$e0,$3800,$0
   dc.w  $6600,$6c,$0,$6,$3c,$60,$1800,$0
   dc.w  $6666,$66,$3c66,$3836,$3c,$3e6c,$183c,$6600
   dc.w  $7c66,$66,$666,$186e,$66,$6076,$1866,$6600
   dc.w  $6666,$66,$1e66,$1866,$7e,$3c66,$187e,$6600
   dc.w  $663c,$6c,$663c,$1866,$c3,$666,$1860,$3c00
   dc.w  $fc18,$f8,$3b18,$3c3b,$c3,$7ce6,$3c3c,$1800
   dc.w  $70,$0,$0,$0,$0,$0,$0,$7000

   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0

   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0

truck:

   dc.w  $0ac3,34,172

   dc.w  $ffff,$fffc,$ffff,$fffc,$ffff,$fffc
   dc.w  $ffff,$fffc,$ffff,$fffc,$ffff,$fffc
   dc.w  $ffff,$fffc,$ffff,$fffc,$ffff,$fffc
   dc.w  $ffff,$fffc,$ffff,$fffc,$ffff,$fffc
   dc.w  $ffff,$fffc,$ffff,$fffc,$ffff,$fffc
   dc.w  $ffff,$fffc,$ffff,$fffc,$ffff,$fffc
   dc.w  $ffff,$fffc,$ffff,$fffc,$ffff,$fffc
   dc.w  $ffff,$fffc,$ffff,$fffc,$ffff,$fffc
   dc.w  $ffff,$fffc,$ffff,$fffc,$ffff,$fffc
   dc.w  $ffff,$fffc,$ffff,$fffc,$ffff,$fffc
   dc.w  $ffff,$fffc,$ffff,$fffc,$ffff,$fffc
   dc.w  $ffff,$fffc,$fffd,$7ffc,$fffb,$bffc
   dc.w  $7f,$fc00,$7b,$bc00,$7d,$7c00
   dc.w  $3f,$f800,$3f,$f800,$1f,$f000
   dc.w  $7,$c000

*plane0

   dc.w  $ffff,$fffc,$ffff,$fffc,$ffff,$fffc
   dc.w  $ffff,$fffc,$ffff,$fffc,$ffff,$fffc
   dc.w  $ffe0,$fffc,$ffe0,$fffc,$ffe0,$fffc
   dc.w  $ffe0,$fffc,$ffe0,$fffc,$ffe0,$fffc
   dc.w  $ffe0,$fffc,$ffe0,$fffc,$e000,$fc
   dc.w  $e000,$fc,$e000,$fc,$e000,$fc
   dc.w  $ffe0,$fffc,$ffe0,$fffc,$ffe0,$fffc
   dc.w  $ffe0,$fffc,$ffe0,$fffc,$ffe0,$fffc
   dc.w  $ffe0,$fffc,$ffe0,$fffc,$ffff,$fffc
   dc.w  $ffff,$fffc,$ffff,$fffc,$ffff,$fffc
   dc.w  $ffff,$fffc,$ffff,$fffc,$ffff,$fffc
   dc.w  $ffff,$fffc,$fffd,$7ffc,$fffb,$bffc
   dc.w  $7f,$fc00,$7b,$bc00,$7d,$7c00
   dc.w  $3f,$f800,$3f,$f800,$1f,$f000
   dc.w  $7,$c000

   dc.w  $0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $1f,$0,$1f,$0,$1f,$0,$1f,$0,$1f,$0
   dc.w  $1f,$0,$1f,$0,$1f,$0,$1fff,$ff00
   dc.w  $1fff,$ff00,$1fff,$ff00,$1fff,$ff00
   dc.w  $1f,$0,$1f,$0,$1f,$0,$1f,$0,$1f,$0
   dc.w  $1f,$0,$1f,$0,$1f,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$7,$c000,$1f,$f000
   dc.w  $3f,$f800,$3f,$f800,$7d,$7c00,$7b,$bc00
   dc.w  $7f,$fc00,$7b,$bc00,$7d,$7c00,$3f,$f800
   dc.w  $3f,$f800,$1f,$f000,$7,$c000

   dc.w  $0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0

title:

   dc.w  $0909,22,576

   dc.w  $7fff,$7003,$b000,$1bff,$e00,$3b00,$703f,$c000
   dc.w  $fffe,$f007,$f800,$3fff,$de00,$7f80,$f0ff,$e000
   dc.w  $3c0,$f007,$fc00,$7f83,$fe00,$7fc0,$f3c0,$c000
   dc.w  $3c0,$f007,$fe00,$ff81,$fe00,$7fe0,$f700,$0
   dc.w  $3c0,$f007,$ff01,$ff81,$fe00,$7ff0,$ff00,$0
   dc.w  $3c0,$f007,$ff83,$ff81,$de00,$7ff8,$ff00,$0
   dc.w  $3c0,$f007,$ffc7,$7fff,$9e00,$7ffc,$ff03,$f000
   dc.w  $3c0,$f007,$fbee,$7fff,$de00,$7fbe,$ff07,$f000
   dc.w  $3c0,$f007,$f9fc,$7f83,$fe00,$7f9f,$ff00,$f000
   dc.w  $3c0,$f007,$f8f8,$7f81,$fe00,$7f8f,$ff00,$f000
   dc.w  $3c0,$f007,$f870,$7f81,$fe00,$7f87,$ff00,$f000
   dc.w  $3c0,$f807,$7820,$7f81,$fe00,$7f83,$ff80,$f000
   dc.w  $3c0,$7c0e,$7800,$7f81,$de00,$7f81,$f7c0,$e000
   dc.w  $3c0,$3ffc,$7800,$7fff,$9fff,$ff80,$f3ff,$c000
   dc.w  $380,$ff0,$7000,$77fe,$1fff,$7700,$60ff,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$3,$fff8,$3fc1,$fffc,$3fe0,$0,$0
   dc.w  $0,$7,$fff0,$fff3,$fff8,$fff8,$0,$0
   dc.w  $0,$0,$1e01,$c0f8,$f01,$c078,$0,$0
   dc.w  $0,$0,$1e03,$807c,$f03,$c030,$0,$0
   dc.w  $0,$0,$1e07,$803c,$f03,$c000,$0,$0
   dc.w  $0,$0,$1e07,$803c,$f03,$f000,$0,$0
   dc.w  $0,$0,$1e07,$803c,$f01,$fe00,$0,$0
   dc.w  $0,$0,$1e07,$803c,$f00,$3fc0,$0,$0
   dc.w  $0,$0,$1e07,$803c,$f00,$ff0,$0,$0
   dc.w  $0,$0,$1e07,$803c,$f00,$1f8,$0,$0
   dc.w  $0,$0,$1e07,$803c,$f00,$78,$0,$0
   dc.w  $0,$0,$1e07,$c038,$f01,$8078,$0,$0
   dc.w  $0,$0,$1e03,$e070,$f03,$c070,$0,$0
   dc.w  $0,$0,$1e01,$ffe0,$f03,$ffe0,$0,$0
   dc.w  $0,$0,$1c00,$7f80,$e00,$ff80,$0,$0

*plane0

   dc.w  $7fff,$7003,$b000,$1bff,$e00,$3b00,$703f,$c000
   dc.w  $0,$1000,$9800,$801,$c200,$980,$1080,$6000
   dc.w  $40,$1000,$8c00,$880,$6200,$8c0,$1200,$0
   dc.w  $40,$1000,$8600,$880,$2200,$860,$1000,$0
   dc.w  $40,$1000,$8300,$880,$2200,$830,$1100,$0
   dc.w  $40,$1000,$8180,$880,$200,$818,$1100,$0
   dc.w  $40,$1000,$88c0,$8fc,$200,$88c,$1103,$f000
   dc.w  $40,$1000,$8860,$800,$c200,$886,$1100,$1000
   dc.w  $40,$1000,$8820,$880,$6200,$883,$1100,$1000
   dc.w  $40,$1000,$8800,$880,$2200,$881,$1100,$1000
   dc.w  $40,$1000,$8800,$880,$2200,$880,$1100,$1000
   dc.w  $40,$1800,$800,$880,$2200,$880,$1180,$1000
   dc.w  $40,$c00,$800,$880,$200,$880,$10c0,$0
   dc.w  $40,$7e0,$800,$8fc,$3ff,$8880,$107e,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$3,$fff8,$3fc1,$fffc,$3fe0,$0,$0
   dc.w  $0,$7,$fff0,$fff3,$fff8,$fff8,$0,$0
   dc.w  $0,$0,$1e01,$c0f8,$f01,$c078,$0,$0
   dc.w  $0,$0,$1e03,$807c,$f03,$c030,$0,$0
   dc.w  $0,$0,$1e07,$803c,$f03,$c000,$0,$0
   dc.w  $0,$0,$1e07,$803c,$f03,$f000,$0,$0
   dc.w  $0,$0,$1e07,$803c,$f01,$fe00,$0,$0
   dc.w  $0,$0,$1e07,$803c,$f00,$3fc0,$0,$0
   dc.w  $0,$0,$1e07,$803c,$f00,$ff0,$0,$0
   dc.w  $0,$0,$1e07,$803c,$f00,$1f8,$0,$0
   dc.w  $0,$0,$1e07,$803c,$f00,$78,$0,$0
   dc.w  $0,$0,$1e07,$c038,$f01,$8078,$0,$0
   dc.w  $0,$0,$1e03,$e070,$f03,$c070,$0,$0
   dc.w  $0,$0,$1e01,$ffe0,$f03,$ffe0,$0,$0
   dc.w  $0,$0,$1c00,$7f80,$e00,$ff80,$0,$0

*plane1

   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $fffe,$e007,$6000,$37fe,$1c00,$7600,$e07f,$8000
   dc.w  $380,$e007,$7000,$7703,$9c00,$7700,$e1c0,$c000
   dc.w  $380,$e007,$f800,$f701,$dc00,$7780,$e700,$0
   dc.w  $380,$e007,$7c01,$f701,$dc00,$77c0,$ee00,$0
   dc.w  $380,$e007,$7e03,$f701,$dc00,$77e0,$ee00,$0
   dc.w  $380,$e007,$7707,$7703,$9c00,$7770,$ee00,$0
   dc.w  $380,$e007,$738e,$77ff,$1c00,$7738,$ee07,$e000
   dc.w  $380,$e007,$71dc,$7703,$9c00,$771c,$ee00,$e000
   dc.w  $380,$e007,$70f8,$7701,$dc00,$770e,$ee00,$e000
   dc.w  $380,$e007,$7070,$7701,$dc00,$7707,$ee00,$e000
   dc.w  $380,$ee07,$7020,$7701,$dc00,$7703,$ee80,$e000
   dc.w  $380,$700e,$7000,$7701,$dc00,$7701,$e700,$e000
   dc.w  $380,$381c,$7000,$7703,$9c00,$7700,$e381,$c000
   dc.w  $380,$ff0,$7000,$77fe,$1fff,$7700,$60ff,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$7,$fff0,$7f83,$fff8,$7fc0,$0,$0
   dc.w  $0,$0,$1c01,$c0e0,$e01,$c070,$0,$0
   dc.w  $0,$0,$1c03,$8070,$e03,$8030,$0,$0
   dc.w  $0,$0,$1c07,$38,$e03,$8000,$0,$0
   dc.w  $0,$0,$1c07,$38,$e03,$8000,$0,$0
   dc.w  $0,$0,$1c07,$38,$e01,$e000,$0,$0
   dc.w  $0,$0,$1c07,$38,$e00,$3c00,$0,$0
   dc.w  $0,$0,$1c07,$38,$e00,$f80,$0,$0
   dc.w  $0,$0,$1c07,$38,$e00,$1e0,$0,$0
   dc.w  $0,$0,$1c07,$38,$e00,$70,$0,$0
   dc.w  $0,$0,$1c07,$38,$e00,$70,$0,$0
   dc.w  $0,$0,$1c03,$8070,$e03,$70,$0,$0
   dc.w  $0,$0,$1c01,$c0e0,$e03,$80e0,$0,$0
   dc.w  $0,$0,$1c00,$7f80,$e00,$ff80,$0,$0

*plane2

   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0,$0,$0

building:

   dc.w  $2c83,34,178*2*2

   dc.w  $ffff,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $1,$ff00,$1,$ff00,$1,$ff00
   dc.w  $1,$ff00,$1,$ff00,$1,$ff00
   dc.w  $1,$ff00,$1,$ff00,$1,$ff00
   dc.w  $1,$ff00,$1,$ff00,$1,$ff00
   dc.w  $1,$ff00,$1,$ff00,$1,$ff00
   dc.w  $1,$ff00,$1,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$4001,$ff00
   dc.w  $7801,$ff00,$3e01,$ff00,$1f01,$ff00
   dc.w  $9f01,$ff00,$fe01,$ff00,$fe41,$ff00
   dc.w  $7e61,$ff00,$fce1,$ff00,$f8e1,$ff00
   dc.w  $fbc9,$ff00,$7f99,$ff00,$3f39,$ff00
   dc.w  $fff1,$ff00,$ffe1,$ff00,$7fc1,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $1001,$ff00,$1e01,$ff00,$8f81,$ff00
   dc.w  $c7c1,$ff00,$67c1,$ff00,$7f81,$ff00
   dc.w  $3f91,$ff00,$1f99,$ff00,$3f39,$ff00
   dc.w  $be39,$ff00,$3ef3,$ff00,$9fe7,$ff00
   dc.w  $cfcf,$ff00,$fffd,$ff00,$3ff9,$ff00
   dc.w  $1ff1,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$1001,$ff00,$1e01,$ff00
   dc.w  $8f81,$ff00,$c7c1,$ff00,$67c1,$ff00
   dc.w  $7f81,$ff00,$3f91,$ff00,$1f99,$ff00
   dc.w  $3f39,$ff00,$be39,$ff00,$3ef3,$ff00
   dc.w  $9fe7,$ff00,$cfcf,$ff00,$fffd,$ff00
   dc.w  $3ff9,$ff00,$1ff1,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$2001,$ff00,$3c01,$ff00
   dc.w  $1f01,$ff00,$8f81,$ff00,$cf81,$ff00
   dc.w  $ff01,$ff00,$7f21,$ff00,$3f31,$ff00
   dc.w  $7e71,$ff00,$7c71,$ff00,$7de5,$ff00
   dc.w  $3fcd,$ff00,$9f9d,$ff00,$fff9,$ff00
   dc.w  $7ff1,$ff00,$3fe1,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00

*plane0

   dc.w  $ffff,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $1,$ff00,$1,$ff00,$1,$ff00
   dc.w  $1,$ff00,$1,$ff00,$1,$ff00
   dc.w  $1,$ff00,$1,$ff00,$1,$ff00
   dc.w  $1,$ff00,$1,$ff00,$1,$ff00
   dc.w  $1,$ff00,$1,$ff00,$1,$ff00
   dc.w  $1,$ff00,$1,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$1,$ff00
   dc.w  $1,$ff00,$1,$ff00,$1,$ff00
   dc.w  $1,$ff00,$1,$ff00,$1,$ff00
   dc.w  $1,$ff00,$1,$ff00,$1,$ff00
   dc.w  $1,$ff00,$1,$ff00,$1,$ff00
   dc.w  $1,$ff00,$1,$ff00,$1,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $1,$ff00,$1,$ff00,$1,$ff00
   dc.w  $1,$ff00,$1,$ff00,$1,$ff00
   dc.w  $1,$ff00,$1,$ff00,$1,$ff00
   dc.w  $1,$ff00,$1,$ff00,$1,$ff00
   dc.w  $1,$ff00,$1,$ff00,$1,$ff00
   dc.w  $1,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$1,$ff00,$1,$ff00
   dc.w  $1,$ff00,$1,$ff00,$1,$ff00
   dc.w  $1,$ff00,$1,$ff00,$1,$ff00
   dc.w  $1,$ff00,$1,$ff00,$1,$ff00
   dc.w  $1,$ff00,$1,$ff00,$1,$ff00
   dc.w  $1,$ff00,$1,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$1,$ff00,$1,$ff00
   dc.w  $1,$ff00,$1,$ff00,$1,$ff00
   dc.w  $1,$ff00,$1,$ff00,$1,$ff00
   dc.w  $1,$ff00,$1,$ff00,$1,$ff00
   dc.w  $1,$ff00,$1,$ff00,$1,$ff00
   dc.w  $1,$ff00,$1,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$0,$7f00
   dc.w  $0,$7f00,$0,$7f00,$0,$7f00
   dc.w  $7e7e,$7f00,$7e7e,$7f00,$7e7e,$7f00
   dc.w  $7e7e,$7f00,$7e7e,$7f00,$0,$7f00
   dc.w  $0,$7f00,$0,$7f00,$0,$7f00
   dc.w  $0,$7f00,$6,$7f00,$6,$7f00
   dc.w  $0,$7f00,$0,$7f00,$0,$7f00
   dc.w  $0,$7f00,$0,$7f00,$0,$7f00
   dc.w  $0,$7f00,$0,$7f00,$0,$7f00
   dc.w  $0,$7f00

*plane1

   dc.w  $ffff,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$0,$ff00
   dc.w  $0,$ff00,$0,$ff00,$0,$ff00
   dc.w  $0,$ff00,$0,$ff00,$0,$ff00
   dc.w  $0,$ff00,$0,$ff00,$0,$ff00
   dc.w  $0,$ff00,$0,$ff00,$0,$ff00
   dc.w  $0,$ff00,$0,$ff00,$0,$ff00
   dc.w  $0,$ff00,$0,$ff00,$0,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$0,$ff00,$4001,$ff00

   dc.w  $7800,$ff00,$3e00,$ff00,$1f00,$ff00
   dc.w  $9f00,$ff00,$fe00,$ff00,$fe40,$ff00
   dc.w  $7e60,$ff00,$fce0,$ff00,$f8e0,$ff00
   dc.w  $fbc8,$ff00,$7f98,$ff00,$3f38,$ff00
   dc.w  $fff0,$ff00,$ffe0,$ff00,$7fc0,$ff00
   dc.w  $0,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$0,$ff00
   dc.w  $1000,$ff00,$1e00,$ff00,$8f80,$ff00
   dc.w  $c7c0,$ff00,$67c0,$ff00,$7f80,$ff00
   dc.w  $3f90,$ff00,$1f98,$ff00,$3f38,$ff00
   dc.w  $be38,$ff00,$3ef2,$ff00,$9fe6,$ff00
   dc.w  $cfce,$ff00,$fffc,$ff00,$3ff8,$ff00
   dc.w  $1ff0,$ff00,$0,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $0,$ff00,$1000,$ff00,$1e00,$ff00
   dc.w  $8f80,$ff00,$c7c0,$ff00,$67c0,$ff00
   dc.w  $7f80,$ff00,$3f90,$ff00,$1f98,$ff00
   dc.w  $3f38,$ff00,$be38,$ff00,$3ef2,$ff00
   dc.w  $9fe6,$ff00,$cfce,$ff00,$fffc,$ff00
   dc.w  $3ff8,$ff00,$1ff0,$ff00,$0,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $0,$ff00,$2000,$ff00,$3c00,$ff00
   dc.w  $1f00,$ff00,$8f80,$ff00,$cf80,$ff00
   dc.w  $ff00,$ff00,$7f20,$ff00,$3f30,$ff00
   dc.w  $7e70,$ff00,$7c70,$ff00,$7de4,$ff00
   dc.w  $3fcc,$ff00,$9f9c,$ff00,$fff8,$ff00
   dc.w  $7ff0,$ff00,$3fe0,$ff00,$0,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$ffff,$ff00,$ffff,$ff00
   dc.w  $ffff,$ff00,$0,$3f00,$ffff,$bf00
   dc.w  $ffff,$bf00,$ffff,$bf00,$ffff,$bf00
   dc.w  $8181,$bf00,$bdbd,$bf00,$bdbd,$bf00
   dc.w  $bdbd,$bf00,$8181,$bf00,$ffff,$bf00
   dc.w  $ffff,$bf00,$ffff,$bf00,$ffff,$bf00
   dc.w  $ffff,$bf00,$fff9,$bf00,$fff9,$bf00
   dc.w  $ffff,$bf00,$ffff,$bf00,$ffff,$bf00
   dc.w  $ffff,$bf00,$ffff,$bf00,$ffff,$bf00
   dc.w  $ffff,$bf00,$ffff,$bf00,$ffff,$bf00
   dc.w  $ffff,$bf00

*plane2

   dc.w  $0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0
   dc.w  $0,$0,$0,$0,$0,$0
   dc.w  $0,$0

*  End of data that must be in CHIP

dataend:

                                 end

