Starglider

Some hidden easter egg (codes):

MY OWN VBLANK

* ENDLESS LOOP
WAIT rts

* BRA.S WAIT


MYKEY MOVE #$2500,SR
DC.W $4EF9
OLDKEY DS.L 1

sVBLANK MOVE.W D0,-(SP)
MOVE.W 2(SP),D0
AND.W #$FFFF-$700,D0
OR.W #$100,D0
* MOVE.W D0,2(SP)
MOVE.W (SP)+,D0

MOVE.B #0,$FFFA1B
VB0 MOVE.B #4,$FFFA21 * 3!??
CMPI.B #4,$FFFA21
BNE.S VB0
MOVE.B #8,$FFFA1B

MOVE.L A6,-(SP)
MOVE.W D0,-(SP)
* LEA MYVARS(PC),A6

ADDQ.B #1,FTIMER0(A6)
CMPI.B #24,FTIMER0(A6)
BNE.S VB1
CLR.B FTIMER0(A6)
ADDQ.B #$01,PF5+1(A6)
ADDQ.B #$01,PF6+1(A6)
VB1 BTST #0,FTIMER0(A6)
BEQ.S VB2
ADD.W #$100,PF6(A6)
SUB.W #$100,PF5(A6)
AND.W #$070

more hidden code:

* Horizontal is fast, but could be faster by using first & last MASKS
colrhori cmp.w #17,d2 * Optimised routine if long line!
bcs colrhor2

bra colrhor2

* Following routine is not debugged as yet!!!
* ----------
colrhor1 and.w #15,d4
move.w d4,d3 * Save starting bit position
asl.w #1,d4 * Make BitPos into a Word index
lea wordmask(pc),a1
move.w 0(a1,d4.w),d0 * Get Starting word mask
or.w d0,(a0)+ * Draw first Word's set of pixels

sub.w d3,d2 * Subtract no. of pixels already
subq.w #1,d2 * drawn!

move.w d2,d4 * no. of filled Words in d4
lsr.w #4,d4

and.w #15,d2

Last hidden code batch:

* Sets pixel (d1,d2) on the screen, d3 is Z coord!
* Be careful not to draw pixels offscreen!!!
*

drawpix move.l pixaddr(a6),a5
jmp (a5)

* Colour version of pixel draw...

pixcolr move.l scrnaddr(a6),a0
lsl.w #5,d2 * Multiply Y by 32
add.w d2,a0
lsl.w #2,d2 * Multiply Y by 4, to give y*128
add.w d2,a0 * Now Y*160 has been added

move.w d1,d2 * x div 2
lsr.w #1,d2
and.w #255-7,d2 * Lose ºplaneº bits
add.w d2,a0 * Now a0 has x offset added to give
move.l a0,a1 * plane 1 address
move.l a0,a2 * plane 2 address
move.l a0,a3 * plane 3 address

* Take into account the ColourPlane offsets here here...
add.w plane0(a6),a0
add.w plane1(a6),a1
add.w plane2(a6),a2
add.w plane3(a6),a3

not.b d1 * true bit position in the byte on screen
and.w #15,d1
moveq #0,d2
bset d1,d2

cmp.w #pixelz2,d3
bcc.s exitpix1

subq.w #1,d1 * Set pixel to the right of last one
bmi.s exitpix1

bset d1,d2

exitpix1 or.w d2,(a0) * Word modification!!
or.w d2,(a1)
or.w d2,(a2)
or.w d2,(a3)

cmp.w #pixelz1,d3 * Medium sized pixel!?
bcc.s exitpix2

or.w d2,160(a0)
or.w d2,160(a1)
or.w d2,160(a2)
or.w d2,160(a3)

tst.w d1 * Did the right pixel overflow Word
bpl.s exitpix2

move.w #32768,d2

or.w d2,8(a0)
or.w d2,8(a1)
or.w d2,8(a2)
or.w d2,8(a3)
or.w d2,168(a0)
or.w d2,168(a1)
or.w d2,168(a2)
or.w d2,168(a3)

exitpix2 rts

* Draws pixels in 3 sizes!
pixmono move.l scrnaddr(a6),a0
lsl.w #4,d2 * Multiply Y by 16
add.w d2,a0
lsl.w #2,d2 * Multiply Y by 4, to give y*64
add.w d2,a0 * Now Y*80 has been added

move.w d1,d2 * x div 8
lsr.w #3,d2
add.w d2,a0 * Now a0 has x offset added to give
not.b d1 * true byte position on screen
and.w #7,d1

* First Pixel, always set
bset d1,(a0) * Byte modification!! << 1st pixel

* Is Z nearer than pixelz1
cmp.w #pixelz1,d3
bcc.s exitpix

bset d1,80(a0) * Set pixel immediately underneath too

cmp.w #pixelz2,d3
bcc.s exitpix

subq.w #1,d1 * next pixel
bpl.s nnxtbt1
bset #7,1(a0) * First pixel on next location
bset #7,81(a0) * and pixel underneath too
exitpix rts

nnxtbt1 bset d1,(a0) * pixel next to it...
bset d1,80(a0) * and underneath
rts


*
* Sprite - High Level interface to DrawSprite
* Entry: d1 X coordinate (0 - 319)
* d2 Y coordinate (0 - 199)
* a0 shape data.
*
* All registers lost.
*

sprite move.l spriteaddr(a6),a5
jmp (a5)


csprite move.w (a0)+,temp(a6) * Number of Words wide
move.w (a0)+,d6 * Number of Lines deep
sub.w (a0)+,d1 * Incorporate Centre of object
sub.w (a0)+,d2

move.l scrnaddr(a6),a1 * Determine Screen Memory
lsl.w #5,d2 * Multiply Y by 32
add.w d2,a1 * And update screen pointer
lsl.w #2,d2 * Multiply Y by 4, to give y*128
add.w d2,a1 * Now Y*160 has been added

move.w d1,d2 * Restore x
lsr.w #1,d2 * Divide by 2
and.w #255-7,d2 * Lose ºplaneº bits
add.w d2,a1 * A1 now has x and y offsets added

move.w d1,d5 * Restore X
and.w #15,d5 * Determine alignment position

* ... fall through, into DrawSprite

*
* DrawSprite - Low Level Colour DBRA
bmi.s nosprite
subq.w #1,d6 *  ¡¡ûove.w temp(a6
add.w a3,a1 * Bump
Monochrome
û2,a1 * A1 now has x and y offsets added

move.w d1,d5
move.w temp(a)

* ... fall through, into DrawSprite

*
* DrawSprite - Low Level Colour Sprite routine.
* Entry: a0 points to shape data
* a1 points to screen
* d7 number of words across (multiples of 4)
* d6 number of lines down
* d5 pixel offset from aligned word (0 - 15)
*
* Exit: All registers stomped on (Serve's Em Right!!)
*

cdrawsprite
move.w #bytecolr,a3 * Bytes per line in colour mode
sub.w temp(a6),a3 * Amount to move down a line
sub.w temp(a6),a3 * ... in bytes!

subq.w #1,temp(a6) * Setup for DBRA
bmi.s nosprite
subq.w #1,d6 * Setup for DBRA
bmi.s nosprite

lea sprmask(pc),a2 * Determine alignment masks
move.w d5,d1 * Save the bit modulo
add.w d5,d5 * Prepare for indexing tables
move.w 0(a2,d5.w),d3 * Usable alignment mask
move.w 32(a2,d5.w),d4 * Overflow alignment mask
move.w d1,d5 * Restore the bit modulo
clr.w d1 * Bitplane modulo counter
lea bitplanes(PC),a2 * Bitplane Alignment overflow list

tst.w d5 * Normally aligned?
beq spriteal1

spritelp move.w temp(a6),d7
clr.l (a2) * Initialise the list
clr.l 4(a2) * .. some more

spritel2 move.w (a0)+,d0 * Get some Sprite data
ror.w d5,d0 * De-Align the data
move.w d0,d2 * Retain for later use
and.w d3,d0 * Mask data leaving useful bits
and.w d4,d2 * Mask data leaving overflow bits
or.w 0(a2,d1.w),d0 * Insert previous overflow bits
move.w d2,0(a2,d1.w) * Provide new overflow bits
addq.w #2,d1 * Increment bitplane modulo
and.w #7,d1 * Ensure it remains a modulo!
move.w d0,(a1)+ * Shove Sprite data onto Screen
dbra d7,spritel2 * Go back for rest of line

move.w (a2),(a1) * Final Overflow becomes last word
move.w 2(a2),2(a1) * plane 1
move.w 4(a2),4(a1) * plane 2
move.w d2,6(a1) * plane 3
add.w a3,a1 * Bump Screen to next scanline
dbra d6,spritelp * Do more sprite lines

nosprite rts

* Normally aligned sprite...
spriteal1
move.w temp(a6),d7
spriteal2
move.w (a0)+,(a1)+ * Get some Sprite data on screen
dbra d7,spriteal2 * Go back for rest of line
add.w a3,a1 * Bump Screen to next scanline
dbra d6,spriteal1 * Do more sprite lines

rts



bitplanes dc.w 0,0,0,0 * Temporary storage of bitplane modulo's


* Sprite masks for usable portion of a data word
sprmask dc.w $ffff,$7fff,$3fff,$1fff,$0fff,$07ff,$03ff,$01ff
dc.w $00ff,$007f,$003f,$001f,$000f,$0007,$0003,$0001
* Masks for overflow portion of a data word
dc.w $0000,$8000,$c000,$e000,$f000,$f800,$fc00,$fe00
dc.w $ff00,$ff80,$ffc0,$ffe0,$fff0,$fff8,$fffc,$fffe




*
* Draw a Monochrome Sprite..
*

msprite move.w (a0)+,temp(a6) * Number of Words wide
move.w (a0)+,d6 * Number of Lines deep
sub.w (a0)+,d1 * Incorporate Centre of object
sub.w (a0)+,d2

move.l scrnaddr(a6),a1 * Determine Screen Memory
lsl.w #4,d2 * Multiply Y by 16
add.w d2,a1 * And update screen pointer
lsl.w #2,d2 * Multiply Y by 4, to give y*64
add.w d2,a1 * Now Y*80 has been added

move.w d1,d2 * Restore x
lsr.w #3,d2 * Divide by 8
and.w #126,d2 * bottom bit lost!
add.w d2,a1 * A1 now has x and y offsets added

move.w d1,d5 * Restore X
and.w #15,d5 * Determine alignment position

* ... fall through, into DrawSprite

*
* DrawSprite - Low Level Mono Sprite routine.
* Entry: a0 points to shape data
* a1 points to screen
* d7 number of words across
* d6 number of lines down
* d5 pixel offset from aligned word (0 - 15)
*
* Exit: All registers stomped on (Serve's Em Right!!)
*

mdrawsprite
move.w #bytemono,a3 * Bytes per line in colour mode
sub.w temp(a6),a3 * Amount to move down a line
sub.w temp(a6),a3 * ... in bytes!

subq.w #1,temp(a6) * Setup for DBRA
bmi.s mnosprite
subq.w #1,d6 * Setup for DBRA
bmi.s mnosprite

lea sprmask(pc),a2 * Determine alignment masks
move.w d5,d1 * Save the bit modulo
add.w d5,d5 * Prepare for indexing tables
move.w 0(a2,d5.w),d3 * Usable alignment mask
move.w 32(a2,d5.w),d4 * Overflow alignment mask
move.w d1,d5 * Restore the bit modulo

tst.w d5 * Normally aligned?
beq mspriteal1

mspritelp
move.w temp(a6),d7
clr.w overflo(a6)

mspritel2
move.w (a0)+,d0 * Get some Sprite data
ror.w d5,d0 * De-Align the data
move.w d0,d2 * Retain for later use
and.w d3,d0 * Mask data leaving useful bits
and.w d4,d2 * Mask data leaving overflow bits
or.w overflo(a6),d0 * Insert previous overflow bits
move.w d2,overflo(a6) * Provide new overflow bits
move.w d0,(a1)+ * Shove Sprite data onto Screen
dbra d7,mspritel2 * Go back for rest of line

move.w overflo(a6),(a1) * Final Overflow becomes last word
add.w a3,a1 * Bump Screen to next scanline
dbra d6,mspritelp * Do more sprite lines

mnosprite
rts

* Normally aligned sprite...
mspriteal1
move.w temp(a6),d7
mspriteal2
move.w (a0)+,(a1)+ * Get some Sprite data on screen
dbra d7,mspriteal2 * Go back for rest of line
add.w a3,a1 * Bump Screen to next scanline
dbra d6,mspriteal1 * Do more sprite lines

rts



ifeq 1

*
* Polygon Clip subroutine...
* (Havent eevn started this one yet.. .but soon)
*
* Make sure Y`s are right way round... ** Optimize this!
* has n-1 elements than each previous pass, so its
* quite quick.

move.w numedgs(a6ove.w 2(a4,d3.w),2(a4,d2.w)
move.w d4,2(a4,d3.w)

move.w 4(a4,d2.w),d4
move.w 4(a4,d3.w),4(a4,d2.w)
move.w d4,4(a4,d3.w)

move.w 4(a4,d2.w),d4
move.w 4(a4,d3.w),4(a4,d2.w)
move.w d4,4(a4,d3.w)

addq.w #8,d2 * Point to next start of edge list
dbra d7,psort1 * Next pass ... n

* Continues...

no saved reggies etc.


* Not quite right, must OR the first and last ones on.

* Entry: Nothing special, No registers required.
* Exit: All registers lost, for speed.

sub.l a4,a4
move.w #16,a6 * Amount to skip, each scanline

movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5

movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5

movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5

movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 +
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5

movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5

movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5

movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5

movem.l d1-d7/a0-a4,-(a5) *
*

polyclip rts



* Polygon draw subroutine (yea yea, we`ve all heard the dead parrot joke)
* Draws a filled polygon at coordinates specified by the edges provided.
*
* Entry: edgaddr(a6) points to list of edges, and numedges is how many there are.
* Exit: All registers preserved.
*
* Edge List contains X,Y lines in Words.

polyfill movem.l d0-d7/a0-a5,-(sp)

* Polygon EDGE pre-processing...

move.w numedgs(a6),d0
subq.w #1,d0
move.l edgaddr(a6),a4
moveq #0,d1

* Make sure Y`s are right way round... ** Optimize this!
presort move.w 0(a4,d1.w),d4 * x1
move.w 2(a4,d1.w),d5 * y1
move.w 4(a4,d1.w),d6 * x2
move.w 6(a4,d1.w),d7 * y2
cmp.w d5,d7 * y1 > y2?
bpl.s bdntswp
move.w d4,4(a4,d1.w) * Swap p1 & p2
move.w d5,6(a4,d1.w)
move.w d6,0(a4,d1.w)
move.w d7,2(a4,d1.w)
addq.w #8,d1 * Bump index
bdntswp dbra d0,presort

* Now perform Insertion Sort of ascending Y coords
* Takes N passes for N elements, to sort them properly.
* However, each pass has n-1 elements than each previous pass, so its
* quite quick.
move.w numedgs(a6),d7
subq.w #1,d7
moveq #0,d2 * Zero the Front index

psort1 move.w numedgs(a6),d0 * Do one iteration.
subq.w #1,d0
move.w d2,d1 * Point index to front of edge list
moveq #0,d3 * Ptr to minimum element
move.w #$7fff,d5 * The ongoing minimum set to temp(a6)orary max

psort2 cmp.w 2(a4,d1.w),d5 * Is y of p1 smaller than my minimum?
blt.s notamin
* Set a new minimum, and pointer
move.w 2(a4,d1.w),d5 * Make element the new minimum
move.w d1,d3 * Ptr to minimum element
notamin addq.w #8,d1 * Find next edge
dbra d0,psort2 * Fulfill the current pass

* Okay, we now have a minimum, so time to do the swapsies...
* (Swap the Front element of the list with the minimum one),
* and increment the pointer to signify a new `front` which bypasses
* the element we just added.
move.w 0(a4,d2.w),d4 * temp(a6)orary Front element
move.w 0(a4,d3.w),0(a4,d2.w)
move.w d4,0(a4,d3.w)

move.w 2(a4,d2.w),d4
move.w 2(a4,d3.w),2(a4,d2.w)
move.w d4,2(a4,d3.w)

move.w 4(a4,d2.w),d4
move.w 4(a4,d3.w),4(a4,d2.w)
move.w d4,4(a4,d3.w)

move.w 4(a4,d2.w),d4
move.w 4(a4,d3.w),4(a4,d2.w)
move.w d4,4(a4,d3.w)

addq.w #8,d2 * Point to next start of edge list
dbra d7,psort1 * Next pass ... n

* Continues...

movem.l (sp)+,d0-d7/a5
rts

* Draws a scanline`s worth of polygon
* Entry: a1 points to memory start, and d1 is start mask
* d2 is number of words to fill
* Exit: Nothing special, no saved reggies etc.


* Not quite right, must OR the first and last ones on.
oneline move.w #$ffff,d3 * Fill pattern, all 1`s
move.w d1,(a1)+
subq.w #1,d2
bmi.s finiline
beq.s lastline
onelin2: move.w d3,(a1)+
dbra d2,onelin2
lastline move.w d4,(a1)+
finiline rts

endc



* *******************************************
* * CLEAR WINDOW/SCREEN routines *
* *******************************************

* Clear the graphics area of the screen very quickly... 23840 bytes to 0
* Entry: Nothing special, No registers required.
* Exit: All registers lost, for speed.

clsgraf move.l clsaddr(a6),a5
jmp (a5)


*
* Colour clear graphics area
*

clscolr move.l a6,-(sp)
move.l scrnaddr(a6),a5
add.w #colrlen+152,a5 * Ensure Positive!
moveq #2,d0

moveq #0,d1
moveq #0,d2 * Zero 12 registers in all
moveq #0,d3 * to allow 48 bytes zeroed each.
moveq #0,d4
moveq #0,d5
moveq #0,d6
moveq #0,d7
sub.l a0,a0
sub.l a1,a1
sub.l a2,a2
sub.l a3,a3
sub.l a4,a4
move.w #16,a6 * Amount to skip, each scanline

clsqlp1 movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5

movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5

movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5


movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5

movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5

movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5

movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48

sub.w a6,a5

movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5

movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5

movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5

movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5

movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5

movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5

movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5

movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5

movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5

movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5

movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5)
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5

movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5

movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5

movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5


movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5

movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5

dbra d0,clsqlp1

movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5

movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) *
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5

movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5

movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5

movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5

movem.l d1-d7/a0-a4,-(a5)
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5

movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5

movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5

movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5

movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5

movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5

movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5

movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5

movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5

movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)
sub.w a6,a5

movem.l d1-d7/a0-a4,-(a5) * Every 3 is 144 bytes
movem.l d1-d7/a0-a4,-(a5) * ie: 48 + 48 + 48
movem.l d1-d7/a0-a4,-(a5)