diff --git a/dlowres_mode7/Makefile b/dlowres_mode7/Makefile
new file mode 100644
index 00000000..a0202ffd
--- /dev/null
+++ b/dlowres_mode7/Makefile
@@ -0,0 +1,27 @@
+include ../Makefile.inc
+
+DOS33 = ../dos33fs-utils/dos33
+PNG2GR = ../gr-utils/png2gr
+PNG2RLE = ../gr-utils/png2rle
+
+all:	dlowres_mode7.dsk
+
+$(DOS33):	
+	cd ../dos33fs-utils && make
+
+dlowres_mode7.dsk:	$(DOS33) DLOWRES_MODE7
+	$(DOS33) -y dlowres_mode7.dsk BSAVE -a 0x1000 DLOWRES_MODE7
+
+###
+
+DLOWRES_MODE7:	dlowres_mode7.o
+	ld65 -o DLOWRES_MODE7 dlowres_mode7.o -C ./apple2_1000.inc
+
+dlowres_mode7.o:	dlowres_mode7.s \
+	dlowres_flying.s fast_multiply.s \
+	dlowres_utils.s dlowres_zp.inc
+	ca65 -o dlowres_mode7.o dlowres_mode7.s -l dlowres_mode7.lst
+
+clean:	
+	rm -f *~ *.o *.lst
+
diff --git a/dlowres_mode7/apple2_1000.inc b/dlowres_mode7/apple2_1000.inc
new file mode 100644
index 00000000..e22976de
--- /dev/null
+++ b/dlowres_mode7/apple2_1000.inc
@@ -0,0 +1,12 @@
+MEMORY {
+       ZP: start = $00, size = $1A, type = rw;
+       RAM: start = $1000, size = $8E00, file = %O;
+}
+
+SEGMENTS {
+CODE: load = RAM, type = ro;
+RODATA: load = RAM, type = ro;
+DATA: load = RAM, type = rw;
+BSS: load = RAM, type = bss, define = yes;
+ZEROPAGE: load = ZP, type = zp;
+}
diff --git a/dlowres_mode7/dlowres_flying.s b/dlowres_mode7/dlowres_flying.s
new file mode 100644
index 00000000..9435f8eb
--- /dev/null
+++ b/dlowres_mode7/dlowres_flying.s
@@ -0,0 +1,1256 @@
+;===========
+; CONSTANTS
+;===========
+CONST_SHIPX	EQU	15
+CONST_TILE_W	EQU	64
+CONST_TILE_H	EQU	64
+CONST_MAP_MASK_X	EQU	(CONST_TILE_W - 1)
+CONST_MAP_MASK_Y	EQU	(CONST_TILE_H - 1)
+CONST_LOWRES_W	EQU	40
+CONST_LOWRES_H	EQU	40
+CONST_BETA_I	EQU	$ff
+CONST_BETA_F	EQU	$80
+CONST_SCALE_I	EQU	$14
+CONST_SCALE_F	EQU	$00
+CONST_LOWRES_HALF_I	EQU	$ec	; -(LOWRES_W/2)
+CONST_LOWRES_HALF_F	EQU	$00
+
+flying_start:
+
+	;===================
+	; Clear screen/pages
+	;===================
+
+	jsr	clear_screens
+;	jsr     set_gr_page0
+
+	;=====================
+	; Set Up Double Lowres
+	;=====================
+
+	lda	SET_GR		; graphics C050
+	lda	LORES		; lores    C056
+	lda	TEXTGR		; mixset   C053
+	sta	EIGHTYSTORE_OFF	; 80store  C001
+	sta	EIGHTYCOL	; 80col    C00d
+	lda	AN3		; AN3      C05E
+
+
+	jsr	init_multiply_tables
+
+	;===============
+	; Init Variables
+	;===============
+	lda	#20
+	sta	SHIPY
+	lda	#0
+	sta	TURNING
+	sta	ANGLE
+	sta	SPACEX_I
+	sta	SPACEY_I
+	sta	CX_I
+	sta	CX_F
+	sta	CY_I
+	sta	CY_F
+	sta	DRAW_SPLASH
+	sta	SPEED
+	sta	SPLASH_COUNT
+
+	lda	#1
+	sta	ANGLE
+
+	lda	#2		; initialize sky both pages
+	sta	DRAW_SKY
+
+	lda	#4		; starts out at 4.5
+	sta	SPACEZ_I
+	lda	#$80
+	sta	SPACEZ_F
+
+	jsr	update_z_factor
+
+flying_loop:
+
+	lda	SPLASH_COUNT						; 3
+	beq	flying_keyboard						; 2nt/3
+	dec	SPLASH_COUNT	; decrement splash count		; 5
+
+flying_keyboard:
+
+	jsr	get_key		; get keypress				; 6
+
+	lda	LASTKEY							; 3
+
+;	cmp	#('Q')		; if quit, then return
+;	bne	skipskip
+;	rts
+
+;skipskip:
+
+	cmp	#('W')							; 2
+	bne	check_down						; 3/2nt
+
+	;===========
+	; UP PRESSED
+	;===========
+
+	lda	SHIPY
+	cmp	#17
+	bcc	check_down	; bgt, if shipy>16
+	dec	SHIPY
+	dec	SHIPY		; move ship up
+	inc	SPACEZ_I	; incement height
+	jsr	update_z_factor
+	lda	#0
+	sta	SPLASH_COUNT
+
+check_down:
+	cmp	#('S')
+	bne	check_left
+
+	;=============
+	; DOWN PRESSED
+	;=============
+
+	lda	SHIPY
+	cmp	#28
+	bcs	splashy		; ble, if shipy < 28
+	inc	SHIPY
+	inc	SHIPY		; move ship down
+	dec	SPACEZ_I	; decrement height
+	jsr	update_z_factor
+	bcc	check_left
+
+splashy:
+	lda	#10
+	sta	SPLASH_COUNT
+
+check_left:
+	cmp	#('A')
+	bne	check_right
+
+	;=============
+	; LEFT PRESSED
+	;=============
+
+	lda	TURNING
+	bmi	turn_left
+	beq	turn_left
+
+	lda	#$0
+	sta	TURNING
+	clv
+	bvc	check_right
+
+turn_left:
+	lda	#253	; -3
+	sta	TURNING
+
+	dec	ANGLE
+
+check_right:
+	cmp	#('D')
+	bne	check_speedup
+
+	;==============
+	; RIGHT PRESSED
+	;==============
+
+	lda	TURNING		;; FIXME: optimize me
+	bpl	turn_right
+	lda	#0
+	sta	TURNING
+	clv
+	bvc	check_speedup
+
+turn_right:
+	lda	#3
+	sta	TURNING
+
+	inc	ANGLE
+
+check_speedup:
+	cmp	#('Z')
+	bne	check_speeddown
+
+	;=========
+	; SPEED UP
+	;=========
+	lda	#$8
+	cmp	SPEED
+	beq	check_speeddown
+	inc	SPEED
+
+check_speeddown:
+	cmp	#('X')
+	bne	check_brake
+
+	;===========
+	; SPEED DOWN
+	;===========
+
+	lda	SPEED
+	beq	check_brake
+	dec	SPEED
+
+check_brake:
+	cmp	#(' '+128)
+	bne	check_land
+
+	;============
+	; BRAKE
+	;============
+	lda	#$0
+	sta	SPEED
+
+check_land:
+	cmp	#13
+	bne	check_help
+
+	;=====
+	; LAND
+	;=====
+
+	; finds value in space_x.i,space_y.i
+	; returns color in A
+	lda	CX_I
+	sta	SPACEX_I
+	lda	CY_I
+	sta	SPACEY_I
+
+	jsr	lookup_map
+
+	cmp	#COLOR_BOTH_LIGHTGREEN
+	bne	must_land_on_grass
+
+landing_loop:
+
+	jsr	draw_background_mode7
+
+	; Draw Shadow
+	lda     #>shadow_forward
+        sta     INH
+        lda     #<shadow_forward
+        sta     INL
+	lda	#(CONST_SHIPX+3)
+	sta	XPOS
+	clc
+	lda	SPACEZ_I
+	adc	#31
+	and	#$fe			; make sure it's even
+	sta	YPOS
+	jsr	put_sprite
+
+	lda     #>ship_forward
+        sta     INH
+        lda     #<ship_forward
+        sta     INL
+
+	lda	#CONST_SHIPX
+	sta	XPOS
+	lda	SHIPY
+	sta	YPOS
+	jsr	put_sprite
+
+	jsr	page_flip
+
+	dec	SPACEZ_I
+	jsr	update_z_factor
+	lda	SPACEZ_I
+
+	bpl	landing_loop
+
+
+	rts			; finish flying
+
+must_land_on_grass:
+	lda     #10
+	sta	CH		; HTAB 11
+
+	lda	#21
+	sta	CV		; VTAB 22
+
+	lda	#>(grass_string)
+	sta	OUTH
+	lda	#<(grass_string)
+	sta	OUTL
+
+	jsr	print_both_pages	; "NEED TO LAND ON GRASS!"
+
+check_help:
+	cmp	#('H')
+	bne	check_done
+
+	;=====
+	; HELP
+	;=====
+
+;	jsr	print_help
+
+	lda	#2
+	sta	DRAW_SKY
+
+check_done:
+
+	;================
+	; Wrap the Angle
+	;================
+	; FIXME: only do this in right/left routine?
+	lda	ANGLE							; 3
+	and	#$f							; 2
+	sta	ANGLE							; 3
+
+	;================
+	; Handle Movement
+	;================
+
+speed_move:
+	ldx	SPEED							; 3
+	beq	draw_background						; 2nt/3
+								;=============
+	lda	ANGLE	; dx.i=fixed_sin[(angle+4)&0xf].i; // cos()	; 3
+	clc								; 2
+	adc	#4							; 2
+	and	#$f							; 2
+	asl								; 2
+	tay								; 2
+	lda	fixed_sin_scale,Y					; 4
+	sta	DX_I							; 3
+	iny		; dx.f=fixed_sin[(angle+4)&0xf].f; // cos()	; 2
+	lda	fixed_sin_scale,Y					; 4
+	sta	DX_F							; 3
+
+	lda	ANGLE	; dy.i=fixed_sin[angle&0xf].i; // sin()		; 3
+	and	#$f							; 2
+	asl								; 2
+	tay								; 2
+	lda	fixed_sin_scale,Y					; 4
+	sta	DY_I							; 3
+	iny		; dx.f=fixed_sin[angle&0xf].f; // sin()		; 2
+	lda	fixed_sin_scale,Y					; 4
+	sta	DY_F							; 3
+								;============
+								;	 54
+speed_loop:
+
+	clc			; fixed_add(&cx,&dx,&cx);		; 2
+	lda	CX_F							; 3
+	adc	DX_F							; 3
+	sta	CX_F							; 3
+	lda	CX_I							; 3
+	adc	DX_I							; 3
+	sta	CX_I							; 3
+
+	clc			; fixed_add(&cy,&dy,&cy);		; 2
+	lda	CY_F							; 3
+	adc	DY_F							; 3
+	sta	CY_F							; 3
+	lda	CY_I							; 3
+	adc	DY_I							; 3
+	sta	CY_I							; 3
+
+	dex								; 2
+	bne	speed_loop						; 2nt/3
+								;============
+								;	45
+
+	;====================
+	; Draw the background
+	;====================
+draw_background:
+	jsr	draw_background_mode7					; 6
+
+check_over_water:
+	;	See if we are over water
+	lda	CX_I							; 3
+	sta	SPACEX_I						; 3
+	lda	CY_I							; 3
+	sta	SPACEY_I						; 3
+
+	jsr	lookup_map						; 6
+
+	sec								; 2
+	sbc	#COLOR_BOTH_DARKBLUE					; 2
+	sta	OVER_LAND						; 3
+								;===========
+								;	31
+
+	; Calculate whether to draw the splash
+
+	lda	#0			; set splash drawing to 0	; 2
+	sta	DRAW_SPLASH						; 3
+
+	lda	SPEED			; if speed==0, no splash	; 3
+	beq	no_splash						; 2nt/3
+
+	lda	TURNING							; 3
+	beq	no_turning_splash					; 2nt/3
+
+	lda	SHIPY							; 3
+	cmp	#27							; 2
+	bcc	no_turning_splash	; blt if shipy<25 skip		; 2nt/3
+
+	lda	#1							; 2
+	sta	SPLASH_COUNT						; 3
+
+no_turning_splash:
+	lda	OVER_LAND	; no splash if over land		; 3
+	bne	no_splash						; 2nt/3
+
+	lda	SPLASH_COUNT	; no splash if splash_count expired	; 3
+	beq	no_splash						; 2nt/3
+
+	lda	#1							; 2
+	sta	DRAW_SPLASH						; 3
+
+no_splash:
+
+	;==============
+	; Draw the ship
+	;==============
+
+	clv								; 2
+	lda	TURNING							; 3
+	beq	draw_ship_forward					; 2nt/3
+	bpl	draw_ship_right						; 2nt/3
+	bmi	draw_ship_left		;; FIXME: optimize order	; 2nt/3
+
+draw_ship_forward:
+	lda	DRAW_SPLASH						; 2
+	beq	no_forward_splash					; 2nt/3
+
+	; Draw Splash
+	lda     #>splash_forward					; 2
+        sta     INH							; 3
+        lda     #<splash_forward					; 2
+        sta     INL							; 3
+	lda	#(CONST_SHIPX+1)					; 2
+	sta	XPOS							; 3
+	clc								; 2
+	lda	SHIPY							; 3
+	adc	#9							; 2
+	and	#$fe			; make sure it's even		; 2
+	sta	YPOS							; 3
+	jsr	put_sprite						; 6
+								;==========
+								;	33
+no_forward_splash:
+	; Draw Shadow
+	lda     #>shadow_forward					; 2
+        sta     INH							; 3
+        lda     #<shadow_forward					; 2
+        sta     INL							; 3
+	lda	#(CONST_SHIPX+3)					; 2
+	sta	XPOS							; 3
+	clc								; 2
+	lda	SPACEZ_I						; 3
+	adc	#31							; 2
+	and	#$fe			; make sure it's even		; 2
+	sta	YPOS							; 3
+	jsr	put_sprite						; 6
+
+	lda     #>ship_forward						; 2
+        sta     INH							; 3
+        lda     #<ship_forward						; 2
+        sta     INL							; 3
+	bvc	draw_ship						; 3
+								;===========
+								;	46
+draw_ship_right:
+	lda	DRAW_SPLASH						; 3
+	beq	no_right_splash						; 2nt/3
+
+	; Draw Splash
+	lda     #>splash_right						; 2
+        sta     INH							; 3
+        lda     #<splash_right						; 2
+        sta     INL							; 3
+	lda	#(CONST_SHIPX+1)					; 2
+	sta	XPOS							; 3
+	clc								; 2
+	lda	#36							; 2
+	sta	YPOS							; 3
+	jsr	put_sprite						; 6
+								;===========
+								;	28
+no_right_splash:
+
+	; Draw Shadow
+	lda     #>shadow_right						; 2
+        sta     INH							; 3
+        lda     #<shadow_right						; 2
+        sta     INL							; 3
+	lda	#(CONST_SHIPX+3)					; 2
+	sta	XPOS							; 3
+	clc								; 2
+	lda	SPACEZ_I						; 3
+	adc	#31							; 2
+	and	#$fe			; make sure it's even		; 2
+	sta	YPOS							; 3
+	jsr	put_sprite						; 6
+
+	lda     #>ship_right						; 2
+        sta     INH							; 3
+        lda     #<ship_right						; 2
+        sta     INL							; 3
+
+	dec	TURNING							; 5
+
+	bvc	draw_ship						; 3
+								;==========
+								;	51
+draw_ship_left:
+	lda	DRAW_SPLASH						; 3
+	beq	no_left_splash						; 2nt/3
+
+	; Draw Splash
+	lda     #>splash_left						; 2
+        sta     INH							; 3
+        lda     #<splash_left						; 2
+        sta     INL							; 3
+	lda	#(CONST_SHIPX+1)					; 2
+	sta	XPOS							; 3
+	clc								; 2
+	lda	#36							; 2
+	sta	YPOS							; 3
+	jsr	put_sprite						; 6
+								;===========
+								;	 28
+no_left_splash:
+
+	; Draw Shadow
+	lda     #>shadow_left						; 2
+        sta     INH							; 3
+        lda     #<shadow_left						; 2
+        sta     INL							; 3
+	lda	#(CONST_SHIPX+3)					; 2
+	sta	XPOS							; 3
+	clc								; 2
+	lda	SPACEZ_I						; 3
+	adc	#31							; 2
+	and	#$fe			; make sure it's even		; 2
+	sta	YPOS							; 3
+	jsr	put_sprite						; 6
+
+	lda     #>ship_left						; 2
+        sta     INH							; 3
+        lda     #<ship_left						; 2
+        sta     INL							; 3
+
+	inc	TURNING							; 5
+								;==========
+								;	 48
+
+draw_ship:
+	lda	#CONST_SHIPX						; 2
+	sta	XPOS							; 3
+	lda	SHIPY							; 3
+	sta	YPOS							; 3
+	jsr	put_sprite						; 6
+								;===========
+								;	17
+
+	;==================
+	; flip pages
+	;==================
+
+	jsr	page_flip						; 6
+
+	;==================
+	; loop forever
+	;==================
+
+	jmp	flying_loop						; 3
+
+
+update_z_factor:
+
+	; we only do the following if Z changes
+
+	; fixed_mul(&space_z,&BETA,&factor);
+;mul1
+	lda	SPACEZ_I						; 3
+	sta	NUM1H							; 3
+
+	; interlude, update SPACEZ_SHIFTED
+	asl								; 2
+	asl								; 2
+	asl								; 2
+	asl								; 2
+	asl								; 2
+	sec								; 2
+	sbc	#8							; 2
+	sta	spacez_shifted+1					; 4
+
+
+	lda	SPACEZ_F						; 3
+	sta	NUM1L							; 3
+
+	lda	#CONST_BETA_I	; BETA_I				; 2
+	sta	NUM2H							; 3
+	lda	#CONST_BETA_F	; BETA_F				; 2
+	sta	NUM2L							; 3
+
+	sec			; don't reuse old values		; 2
+	jsr	multiply						; 6
+
+	stx	FACTOR_I						; 3
+	sta	FACTOR_F						; 3
+
+	rts								; 6
+								;===========
+								;        60
+
+
+;===========================
+; Draw the Mode7 Background
+;===========================
+
+draw_background_mode7:
+
+	; Only draw sky if necessary
+	; (at start, or if we have switched to text, we never overwrite it)
+
+	lda	DRAW_SKY						; 3
+	beq	no_draw_sky						;^2nt/3
+								;==============
+								;	  6
+	; Draw Sky
+	; not performance critical as this happens rarely
+
+	dec	DRAW_SKY	; usually 2 as we redraw both pages	; 5
+	lda	#COLOR_BOTH_MEDIUMBLUE	; MEDIUMBLUE color		; 2
+	sta	COLOR							; 3
+	lda	#0							; 2
+								;===========
+								;	 11
+
+sky_loop:				; draw line across screen
+	ldy	#39			; from y=0 to y=6		; 2
+	sty	V2							; 3
+	ldy	#0							; 2
+	pha								; 3
+	jsr	hlin_double		; hlin y,V2 at A	; 63+(X*16)
+	pla								; 4
+	clc								; 2
+	adc	#2							; 2
+	cmp	#6							; 2
+	bne	sky_loop						; 3/2nt
+								;=============
+								; (23+63+(X*16))*5
+	; Draw Hazy Horizon
+
+	lda	#COLOR_BOTH_GREY	; Horizon is Grey		; 2
+	sta	COLOR							; 3
+	lda	#6			; draw single line at 6/7	; 2
+	ldy	#39							; 2
+	sty	V2			; hlin	Y,V2 at A		; 3
+	ldy	#0							; 2
+	jsr	hlin_double		; hlin	0,40 at 6	; 63+(X*16)
+								;===========
+								; 63+(X*16)+14
+
+no_draw_sky:
+
+	; setup initial odd/even color mask
+	lda	#$f0							; 2
+	sta	COLOR_MASK						; 3
+
+	; start Y at 8 (below horizon line)
+	lda	#8							; 2
+	sta	SCREEN_Y						; 3
+								;=============
+								;	 10
+
+screeny_loop:
+	and	#$fe		; be sure SCREEN_Y used later is even	; 2
+	tay			; put in Y for lookup table later	; 2
+
+	lda	COLOR_MASK	; flip mask for odd/even row plotting	; 3
+	eor	#$ff							; 2
+	sta	COLOR_MASK						; 3
+	sta	mask_label+1	; setup self-modifying code		; 4
+
+	eor	#$ff		; setup self-modifying branch later	; 2
+	bmi	odd_branch	; beq is $f0 (too clever FIXME)		; 2nt/3
+	lda	#$d0		; bne is $d0				; 2
+odd_branch:
+	sta	mask_branch_label	; actually update branch	; 4
+								;============
+								;	 27
+
+setup_gr_addr:
+	lda	gr_offsets,Y	; lookup low-res memory row address	; 4
+	sta	GBASL		; store in GBASL zero-page pointer	; 3
+	iny			; point to high part of address		; 2
+
+	lda	gr_offsets,Y	; load high part of address		; 4
+	clc			; clear carry for add			; 2
+	adc	DRAW_PAGE       ; add in draw page offset               ; 3
+	sta	GBASH		; store in GBASH zero-page pointer	; 3
+
+								;=============
+								;	 21
+
+calc_horizontal_scale:
+
+	; Calculate the horizontal scale using a lookup table
+
+	; horizontal_scale.i *ALWAYS* = 0
+
+	;	unsigned char horizontal_lookup[7][32];
+	;horizontal_scale.f=
+	;	horizontal_lookup[space_z.i&0xf][(screen_y-8)/2];
+	;		horizontal_lookup[(space_z<<5)+(screen_y-8)]
+
+
+	clc								; 2
+	lda	SCREEN_Y						; 3
+spacez_shifted:
+	adc	#0	; self-modify, loads (spacez<<5)-8		; 2
+	tay								; 2
+	lda	horizontal_lookup,Y					; 4
+	sta	NUM1L	; HORIZ_SCALE_F is input to next mul		; 3
+								;============
+								;	 16
+
+; mul2
+	; calculate the distance of the line we are drawing
+	; fixed_mul(&horizontal_scale,&scale,&distance);
+	lda	#0	; HORIZ_SCALE_I is always zero			; 2
+	sta	NUM1H							; 3
+	; NUM1L was set to HORIZ_SCALE_F previously			;
+	lda	#CONST_SCALE_I	; SCALE_I				; 2
+	sta	NUM2H							; 3
+	lda	#CONST_SCALE_F	; SCALE_F				; 2
+	sta	NUM2L							; 3
+	sec			; don't reuse previous settings		; 2
+	jsr	multiply						; 6
+	stx	DISTANCE_I						; 2
+	sta	DISTANCE_F						; 2
+								;==========
+								;	 27
+
+	; calculate the dx and dy to add to points in space
+	; we add to the starting values on each row to get the next
+	; space values
+
+	; dx.i=fixed_sin[(angle+8)&0xf].i	// -sin()
+	lda	ANGLE							; 3
+	clc								; 2
+	adc	#8							; 2
+	and	#$f							; 2
+	asl								; 2
+	tay								; 2
+	lda	fixed_sin,Y	; load integer half			; 4
+	sta	NUM2H		; use as source in upcomnig mul		; 3
+
+
+	; dx.f=fixed_sin[(angle+8)&0xf].f; 	// -sin()
+	iny			; point to float half			; 2
+	lda	fixed_sin,Y	; load it from lookup table		; 4
+	sta	NUM2L		; use as source in upcoming mul		; 3
+								;==========
+								;	 29
+
+;mul3
+	; fixed_mul(&dx,&horizontal_scale,&dx);
+
+				; DX_I:DX_F already set in NUM2H:NUM2L
+	clc			; reuse HORIZ_SCALE in NUM1		; 2
+	jsr	multiply						; 6
+	stx	DX_I							; 3
+	sta	DX_F							; 3
+								;==========
+								;	 14
+
+	; dy.i=fixed_sin[(angle+4)&0xf].i; // cos()
+
+	lda	ANGLE							; 3
+	clc								; 2
+	adc	#4							; 2
+	and	#$f							; 2
+	asl								; 2
+	tay								; 2
+	lda	fixed_sin,Y	; load integer half			; 4
+	sta	NUM2H		; use as source in upcoming mul		; 3
+
+	; dy.f=fixed_sin[(angle+4)&0xf].f; // cos()
+
+	iny			; point to float half			; 2
+	lda	fixed_sin,Y	; load from lookup table		; 4
+	sta	NUM2L		; use as source in upcoming mul		; 3
+								;==========
+								;	 29
+;mul4
+	; fixed_mul(&dy,&horizontal_scale,&dy);
+
+				; DY_I:DY_F already in NUM2H:NUM2L
+	clc			; reuse horiz_scale in num1		; 2
+	jsr	multiply						; 6
+	stx	DY_I							; 3
+	sta	DY_F							; 3
+								;==========
+								;	 14
+
+	;=================================
+	; calculate the starting position
+	;=================================
+
+			; fixed_add(&distance,&factor,&space_x);
+	clc		; fixed_add(&distance,&factor,&space_y);	; 2
+	lda	DISTANCE_F						; 3
+	adc	FACTOR_F						; 3
+	sta	SPACEY_F						; 3
+	sta	SPACEX_F						; 3
+
+	lda	DISTANCE_I						; 3
+	adc	FACTOR_I						; 3
+	sta	SPACEY_I						; 3
+	sta	SPACEX_I						; 3
+								;==========
+								;	 26
+
+
+	; temp.i=fixed_sin[(angle+4)&0xf].i; // cos()
+
+	lda	ANGLE							; 3
+	clc								; 2
+	adc	#4							; 2
+	and	#$f							; 2
+	asl								; 2
+	tay								; 2
+	lda	fixed_sin,Y						; 4
+	sta	NUM2H	; store as source for next mul			; 3
+
+
+	; temp.f=fixed_sin[(angle+4)&0xf].f; // cos()
+	iny								; 2
+	lda	fixed_sin,Y						; 4
+	sta	NUM2L	; store as source for next mul			; 3
+								;==========
+								;	 29
+
+; mul5
+	; fixed_mul(&space_x,&temp,&space_x);
+	lda	SPACEX_I						; 3
+	sta	NUM1H							; 3
+	lda	SPACEX_F						; 3
+	sta	NUM1L							; 3
+			; NUM2H:NUM2L already set above
+	sec		; don't reuse previous NUM1			; 2
+	jsr	multiply						; 6
+			; SPACEX_I in X					;
+			; SPACEX_F in A					;
+								;==========
+								;	 20
+
+	; fixed_add(&space_x,&cx,&space_x);
+	clc								; 2
+			; SPACEX_F still in A				;
+	adc	CX_F							; 3
+	sta	SPACEX_F						; 3
+	txa		; SPACEX_I was in X				; 2
+	adc	CX_I							; 3
+	sta	SPACEX_I						; 3
+								;===========
+								;	 16
+
+
+	; temp.i=fixed_sin[angle&0xf].i; // sin()
+	lda	ANGLE							; 3
+	and	#$f							; 2
+	asl								; 2
+	tay								; 2
+	lda	fixed_sin,Y						; 4
+	sta	NUM2H		; store for next mul			; 3
+
+	; fixed_temp.f=fixed_sin[angle&0xf].f; // sin()
+	iny								; 2
+	lda	fixed_sin,Y						; 4
+	sta	NUM2L		; store for next mul			; 3
+								;==========
+								;	 25
+
+;mul6
+	; fixed_mul(&space_y,&fixed_temp,&space_y);
+	lda	SPACEY_I						; 3
+	sta	NUM1H							; 3
+	lda	SPACEY_F						; 3
+	sta	NUM1L							; 3
+				; NUM2H:NUM2L already set
+	sec			; don't reuse previous num1		; 2
+	jsr	multiply						; 6
+				; SPACEY_I in X				;
+				; SPACEY_F in A				;
+								;==========
+								;	 20
+
+	; fixed_add(&space_y,&cy,&space_y);
+	clc								; 2
+				; SPACEY_F in A
+	adc	CY_F							; 3
+	sta	SPACEY_F						; 3
+	txa			; SPACEY_I in X				; 2
+	adc	CY_I							; 3
+	sta	SPACEY_I						; 3
+								;==========
+								;	 16
+; mul7
+	; fixed_mul(&lowres_half,&dx,&temp);
+	lda	#CONST_LOWRES_HALF_I					; 2
+	sta	NUM1H							; 3
+	lda	#CONST_LOWRES_HALF_F					; 2
+	sta	NUM1L							; 3
+	lda	DX_I							; 3
+	sta	NUM2H							; 3
+	sta	dxi_label+1	; for self modify			; 4
+	lda	DX_F							; 3
+	sta	dxf_label+1	; for self modify			; 4
+	sta	NUM2L							; 3
+	sec			; don't reuse previous num1		; 2
+	jsr	multiply						; 6
+				; TEMP_I in X				;
+				; TEMP_F in A				;
+								;==========
+								;	 38
+
+
+	; fixed_add(&space_x,&temp,&space_x);
+	clc								; 2
+				; TEMP_F in A
+	adc	SPACEX_F						; 3
+	sta	SPACEX_F						; 3
+	txa			; TEMP_I in X				; 2
+	adc	SPACEX_I						; 3
+	sta	SPACEX_I						; 3
+								;==========
+								;	 16
+
+;mul8
+	; fixed_mul(&fixed_temp,&dy,&fixed_temp);
+	lda	DY_I							; 3
+	sta	NUM2H							; 3
+	sta	dyi_label+1	; for self modify			; 4
+	lda	DY_F							; 3
+	sta	NUM2L							; 3
+	sta	dyf_label+1	; for self modify			; 4
+	clc	; reuse CONST_LOWRES_HALF from last time		; 2
+	jsr	multiply						; 6
+			; TEMP_I in X
+			; TEMP_F in A
+								;==========
+								;	 28
+
+	; fixed_add(&space_y,&temp,&space_y);
+	clc								; 2
+			; TEMP_F in A
+	adc	SPACEY_F						; 3
+	sta	SPACEY_F						; 3
+
+	txa		; TEMP_I in X					; 2
+	adc	SPACEY_I						; 3
+	sta	SPACEY_I						; 3
+
+								;==========
+								;	 16
+
+
+	ldx	#40	; was SCREEN_X					; 2
+								;==========
+								;	  2
+	;===================================================
+	; SCREEN_X LOOP!!!!
+	;   every cycle in here counts for 32*40=1280 cycles
+	;===================================================
+screenx_loop:
+
+
+nomatch:
+	;====================================
+	; do a full lookup, takes much longer
+	; used to be a separate function but we inlined it here
+
+	;====================
+	; lookup_map
+	;====================
+	; finds value in space_x.i,space_y.i
+	; returns color in A
+	; CLOBBERS: A,Y
+
+	lda	SPACEX_I						; 3
+	sta	spacex_label+1	; self modifying code, LAST_SPACEX_I	; 4
+	and	#CONST_MAP_MASK_X	; wrap at 64			; 2
+	sta	SPACEX_I		; store i patch out		; 3
+	tay				; copy to Y for later		; 2
+
+	lda	SPACEY_I						; 3
+	sta	spacey_label+1	; self modifying code, LAST_SPACEY_I	; 4
+	and	#CONST_MAP_MASK_Y	; wrap to 64x64 grid		; 2
+	sta	SPACEY_I						; 3
+
+	asl								; 2
+	asl								; 2
+	asl				; multiply by 8			; 2
+	clc								; 2
+	adc	SPACEX_I		; add in X value		; 3
+					; only valid if x<8 and y<8
+
+	; SPACEX_I is also in y
+	cpy	#$8							; 2
+								;============
+								;	 39
+
+	bcs	ocean_color		; bgt 8				; 2nt/3
+	ldy	SPACEY_I						; 3
+	cpy	#$8							; 2
+								;=============
+								;	  7
+
+	bcs	ocean_color		; bgt 8				; 2nt/3
+
+	tay								; 2
+	lda	flying_map,Y		; load from array		; 4
+
+	bcc	update_cache						; 3
+								;============
+								;	11
+ocean_color:
+	and	#$1f							; 2
+	tay								; 2
+	lda	water_map,Y		; the color of the sea		; 4
+								;===========
+								;	  8
+
+update_cache:
+	sta	map_color_label+1	; self-modifying		; 4
+
+								;===========
+								;	  4
+
+;	rts								; 6
+
+
+
+;	jsr	lookup_map		; get color in A		; 6
+;								;============
+								;	  6
+match:
+
+mask_label:
+	and	#0	; COLOR_MASK (self modifying)			; 2
+
+	ldy	#0							; 2
+mask_branch_label:
+	beq	big_bottom	; this branch is modified based on odd/even
+				; F0=beq, D0=bne			; 2nt/3
+
+	ora	(GBASL),Y	; we're odd, or the bottom in		; 5
+big_bottom:
+
+	sta	(GBASL),Y	; plot double height pixel		; 6
+	inc	GBASL		; point to next pixel			; 5
+								;============
+								;	22/18
+
+
+
+	; advance to the next position in space
+
+	; fixed_add(&space_x,&dx,&space_x);
+
+	clc								; 2
+	lda	SPACEX_F						; 3
+dxf_label:
+	adc	#0	; self modifying, is DX_F			; 2
+	sta	SPACEX_F						; 3
+	lda	SPACEX_I						; 3
+dxi_label:
+	adc	#0	; self modifying, is DX_I			; 2
+	sta	SPACEX_I						; 3
+								;==========
+								;	 18
+
+	; fixed_add(&space_y,&dy,&space_y);
+
+	clc								; 2
+	lda	SPACEY_F						; 3
+dyf_label:
+	adc	#0	; self modifyig, is DY_F			; 2
+	sta	SPACEY_F						; 3
+	lda	SPACEY_I						; 3
+dyi_label:
+	adc	#0	; self mofidying is DY_I			; 2
+	sta	SPACEY_I						; 3
+								;============
+								;	 18
+
+	dex	; decrement	SCREEN_X				; 2
+	beq	done_screenx_loop	; branch until we've done 40	; 2nt/3
+								;=============
+								;	4/5
+
+
+	; cache color and return if same as last time
+	lda	SPACEY_I						; 3
+spacey_label:
+	cmp	#0	; self modify, LAST_SPACEY_I			; 2
+	bne	nomatch							; 2nt/3
+	lda	SPACEX_I						; 3
+spacex_label:
+	cmp	#0	; self modify, LAST_SPACEX_I			; 2
+	bne	nomatch							; 2nt/3
+map_color_label:
+	lda	#0	; self modify, LAST_MAP_COLOR			; 2
+	jmp	match							; 3
+
+done_screenx_loop:
+	inc	SCREEN_Y						; 5
+	lda	SCREEN_Y						; 3
+	cmp	#40			; LOWRES height			; 2
+	beq	done_screeny						; 2nt/3
+	jmp	screeny_loop		; too far to branch		; 3
+								;=============
+								;	 15
+done_screeny:
+	rts								; 6
+
+
+	;====================
+	; lookup_map
+	;====================
+	; finds value in space_x.i,space_y.i
+	; returns color in A
+	; CLOBBERS: A,Y
+	; this is used to check if above water or grass
+	; the high-performance per-pixel version has been inlined
+lookup_map:
+	lda	SPACEX_I						; 3
+	and	#CONST_MAP_MASK_X					; 2
+	sta	SPACEX_I						; 3
+	tay								; 2
+
+	lda	SPACEY_I						; 3
+	and	#CONST_MAP_MASK_Y	; wrap to 64x64 grid		; 2
+	sta	SPACEY_I						; 3
+
+	asl								; 2
+	asl								; 2
+	asl				; multiply by 8			; 2
+	clc								; 2
+	adc	SPACEX_I		; add in X value		; 3
+					; only valid if x<8 and y<8
+
+	; SPACEX_I is in y
+	cpy	#$8							; 2
+								;============
+								;	 31
+
+	bcs	ocean_color_outline	; bgt 8				;^2nt/3
+	ldy	SPACEY_I						; 3
+	cpy	#$8							; 2
+	bcs	ocean_color_outline	; bgt 8				; 2nt/3
+
+	tay								; 2
+	lda	flying_map,Y		; load from array		; 4
+
+	bcc	update_cache_outline					; 3
+
+ocean_color_outline:
+	and	#$1f							; 2
+	tay								; 2
+	lda	water_map,Y		; the color of the sea		; 4
+
+update_cache_outline:
+	rts								; 6
+
+
+flying_map:
+	.byte $22,$ff,$ff,$ff, $ff,$ff,$ff,$22
+	.byte $dd,$cc,$cc,$88, $44,$44,$00,$dd
+	.byte $dd,$cc,$cc,$cc, $88,$44,$44,$dd
+	.byte $dd,$cc,$cc,$88, $44,$44,$44,$dd
+	.byte $dd,$cc,$99,$99, $88,$44,$44,$dd
+	.byte $dd,$cc,$99,$88, $44,$44,$44,$dd
+	.byte $dd,$cc,$99,$99, $11,$44,$44,$dd
+	.byte $22,$dd,$dd,$dd, $dd,$dd,$dd,$22
+
+
+water_map:
+	.byte $22,$22,$22,$22,  $22,$22,$22,$22
+	.byte $ee,$22,$22,$22,  $22,$22,$22,$22
+	.byte $22,$22,$22,$22,  $22,$22,$22,$22
+	.byte $22,$22,$22,$22,  $ee,$22,$22,$22
+
+.include "fast_multiply.s"
+
+
+; 8.8 fixed point
+; should we store as two arrays, one I one F?
+fixed_sin:
+	.byte $00,$00 ;  0.000000=00.00
+	.byte $00,$61 ;  0.382683=00.61
+	.byte $00,$b5 ;  0.707107=00.b5
+	.byte $00,$ec ;  0.923880=00.ec
+	.byte $01,$00 ;  1.000000=01.00
+	.byte $00,$ec ;  0.923880=00.ec
+	.byte $00,$b5 ;  0.707107=00.b5
+	.byte $00,$61 ;  0.382683=00.61
+	.byte $00,$00 ;  0.000000=00.00
+	.byte $ff,$9f ; -0.382683=ff.9f
+	.byte $ff,$4b ; -0.707107=ff.4b
+	.byte $ff,$14 ; -0.923880=ff.14
+	.byte $ff,$00 ; -1.000000=ff.00
+	.byte $ff,$14 ; -0.923880=ff.14
+	.byte $ff,$4b ; -0.707107=ff.4b
+	.byte $ff,$9f ; -0.382683=ff.9f
+
+fixed_sin_scale:
+	.byte $00,$00
+	.byte $00,$0c
+	.byte $00,$16
+	.byte $00,$1d
+	.byte $00,$20
+	.byte $00,$1d
+	.byte $00,$16
+	.byte $00,$0c
+	.byte $00,$00
+	.byte $ff,$f4
+	.byte $ff,$ea
+	.byte $ff,$e3
+	.byte $ff,$e0
+	.byte $ff,$e3
+	.byte $ff,$ea
+	.byte $ff,$f4
+
+;horizontal_lookup_20:
+;	.byte $0C,$0A,$09,$08,$07,$06,$05,$05,$04,$04,$04,$04,$03,$03,$03,$03
+;	.byte $26,$20,$1B,$18,$15,$13,$11,$10,$0E,$0D,$0C,$0C,$0B,$0A,$0A,$09
+;	.byte $40,$35,$2D,$28,$23,$20,$1D,$1A,$18,$16,$15,$14,$12,$11,$10,$10
+;	.byte $59,$4A,$40,$38,$31,$2C,$28,$25,$22,$20,$1D,$1C,$1A,$18,$17,$16
+;	.byte $73,$60,$52,$48,$40,$39,$34,$30,$2C,$29,$26,$24,$21,$20,$1E,$1C
+;	.byte $8C,$75,$64,$58,$4E,$46,$40,$3A,$36,$32,$2E,$2C,$29,$27,$25,$23
+;	.byte $A6,$8A,$76,$68,$5C,$53,$4B,$45,$40,$3B,$37,$34,$30,$2E,$2B,$29
+
+	; we can guarantee 4 cycle indexed reads if we page-aligned this
+.align 256
+horizontal_lookup:
+	.byte $0C,$0B,$0A,$09,$09,$08,$08,$07,$07,$06,$06,$06,$05,$05,$05,$05
+	.byte $04,$04,$04,$04,$04,$04,$04,$03,$03,$03,$03,$03,$03,$03,$03,$03
+	.byte $26,$22,$20,$1D,$1B,$19,$18,$16,$15,$14,$13,$12,$11,$10,$10,$0F
+	.byte $0E,$0E,$0D,$0D,$0C,$0C,$0C,$0B,$0B,$0A,$0A,$0A,$0A,$09,$09,$09
+	.byte $40,$3A,$35,$31,$2D,$2A,$28,$25,$23,$21,$20,$1E,$1D,$1B,$1A,$19
+	.byte $18,$17,$16,$16,$15,$14,$14,$13,$12,$12,$11,$11,$10,$10,$10,$0F
+	.byte $59,$51,$4A,$44,$40,$3B,$38,$34,$31,$2F,$2C,$2A,$28,$26,$25,$23
+	.byte $22,$21,$20,$1E,$1D,$1C,$1C,$1B,$1A,$19,$18,$18,$17,$16,$16,$15
+	.byte $73,$68,$60,$58,$52,$4C,$48,$43,$40,$3C,$39,$36,$34,$32,$30,$2E
+	.byte $2C,$2A,$29,$27,$26,$25,$24,$22,$21,$20,$20,$1F,$1E,$1D,$1C,$1C
+	.byte $8C,$80,$75,$6C,$64,$5D,$58,$52,$4E,$4A,$46,$43,$40,$3D,$3A,$38
+	.byte $36,$34,$32,$30,$2E,$2D,$2C,$2A,$29,$28,$27,$26,$25,$24,$23,$22
+	.byte $A6,$97,$8A,$80,$76,$6E,$68,$61,$5C,$57,$53,$4F,$4B,$48,$45,$42
+	.byte $40,$3D,$3B,$39,$37,$35,$34,$32,$30,$2F,$2E,$2C,$2B,$2A,$29,$28
+
+
+
+grass_string:
+	.asciiz "NEED TO LAND ON GRASS!"
diff --git a/dlowres_mode7/dlowres_mode7.dsk b/dlowres_mode7/dlowres_mode7.dsk
new file mode 100644
index 00000000..78a9a396
Binary files /dev/null and b/dlowres_mode7/dlowres_mode7.dsk differ
diff --git a/dlowres_mode7/dlowres_mode7.s b/dlowres_mode7/dlowres_mode7.s
new file mode 100644
index 00000000..2f5e55ed
--- /dev/null
+++ b/dlowres_mode7/dlowres_mode7.s
@@ -0,0 +1,83 @@
+.include "dlowres_zp.inc"
+
+	;================================
+	; Clear screen and setup graphics
+	;================================
+
+	jsr	HOME
+	jsr	set_gr_page0
+
+	;================================
+	; Set up Double Low-res
+	;================================
+;	lda	SET_GR		; graphics C050
+;	lda	LORES		; lores	   C056
+;	lda	TEXTGR		; mixset   C053
+;	sta	EIGHTYSTORE_OFF	; 80store  C001
+;	sta	EIGHTYCOL	; 80col	   C00d
+;	lda	AN3		; AN3	   C05E
+
+	lda	#0
+	sta	DISP_PAGE	; Forgot to set initially
+				; real hardware and AppleWin default
+				; to different values
+
+	;===================================
+	; zero out the zero page that we use
+	;===================================
+
+	; memset()
+
+	;===================================
+	; Clear top/bottom of page 0 and 1
+	;===================================
+
+	jsr	clear_screens
+
+	;=====================
+	; Flying
+	;=====================
+
+	jsr	flying_start
+
+	;=====================
+	; All finished
+	;=====================
+exit:
+
+	lda	#$4
+	sta	BASH
+	lda	#$0
+	sta	BASL			; restore to 0x400 (page 0)
+					; copy to 0x400 (page 0)
+
+	; call home
+	jsr	HOME
+
+
+	; Return to BASIC?
+	rts
+
+
+;===============================================
+; External modules
+;===============================================
+
+.include "dlowres_utils.s"
+.include "dlowres_flying.s"
+
+.include "dlowres_sprites.inc"
+
+;===============================================
+; Variables
+;===============================================
+
+	; waste memory with a lookup table
+	; maybe faster than using GBASCALC?
+
+gr_offsets:
+	.word	$400,$480,$500,$580,$600,$680,$700,$780
+	.word 	$428,$4a8,$528,$5a8,$628,$6a8,$728,$7a8
+	.word	$450,$4d0,$550,$5d0,$650,$6d0,$750,$7d0
+
+
diff --git a/dlowres_mode7/dlowres_sprites.inc b/dlowres_mode7/dlowres_sprites.inc
new file mode 100644
index 00000000..28334c3e
--- /dev/null
+++ b/dlowres_mode7/dlowres_sprites.inc
@@ -0,0 +1,60 @@
+;================
+; Ship Sprites
+;================
+
+splash_forward:
+	.byte $7,$2
+	.byte $00,$ee,$00,$00,$00,$ee,$00
+	.byte $ee,$00,$00,$00,$00,$00,$ee
+
+splash_right:
+	.byte $7,$2
+	.byte $00,$00,$00,$00,$00,$ee,$00
+	.byte $00,$00,$00,$00,$00,$00,$ee
+
+
+splash_left:
+	.byte $7,$2
+	.byte $00,$ee,$00,$00,$00,$00,$00
+	.byte $ee,$00,$00,$00,$00,$00,$00
+
+shadow_forward:
+	.byte $3,$2
+	.byte $00,$aa,$00
+	.byte $a0,$aa,$a0
+
+shadow_right:
+	.byte $3,$2
+	.byte $a0,$00,$aa
+	.byte $00,$0a,$a0
+
+shadow_left:
+	.byte $3,$2
+	.byte $aa,$00,$a0
+	.byte $a0,$0a,$00
+
+ship_forward:
+	.byte $9,$5
+	.byte $00,$00,$00,$00,$ff,$00,$00,$00,$00
+	.byte $00,$00,$00,$66,$ff,$66,$00,$00,$00
+	.byte $00,$00,$70,$2f,$12,$2f,$70,$00,$00
+	.byte $f0,$f7,$f7,$f2,$d9,$f2,$f7,$f7,$f0
+	.byte $00,$00,$00,$00,$0d,$00,$00,$00,$00
+
+ship_right:
+	.byte $9,$5
+	.byte $00,$00,$00,$00,$00,$60,$60,$f0,$00
+	.byte $00,$f0,$70,$70,$f6,$f6,$6f,$66,$00
+	.byte $00,$07,$ff,$2f,$12,$27,$f6,$00,$00
+	.byte $00,$00,$00,$dd,$d9,$f2,$77,$00,$00
+	.byte $00,$00,$00,$00,$00,$0f,$ff,$70,$00
+
+ship_left:
+	.byte $9,$5
+	.byte $00,$f0,$60,$60,$00,$00,$00,$00,$00
+	.byte $00,$66,$6f,$f6,$f6,$70,$70,$f0,$00
+	.byte $00,$00,$f6,$27,$12,$2f,$ff,$07,$00
+	.byte $00,$00,$77,$f2,$d9,$dd,$00,$00,$00
+	.byte $00,$70,$ff,$0f,$00,$00,$00,$00,$00
+
+
diff --git a/dlowres_mode7/dlowres_utils.s b/dlowres_mode7/dlowres_utils.s
new file mode 100644
index 00000000..57182a52
--- /dev/null
+++ b/dlowres_mode7/dlowres_utils.s
@@ -0,0 +1,753 @@
+;=====================================================================
+;= ROUTINES
+;=====================================================================
+
+
+clear_screens:
+	;===================================
+	; Clear top/bottom of page 0
+	;===================================
+
+	lda     #$0
+	sta     DRAW_PAGE
+	jsr     clear_top
+	jsr     clear_bottom
+
+	;===================================
+	; Clear top/bottom of page 1
+	;===================================
+
+	lda     #$4
+	sta     DRAW_PAGE
+	jsr     clear_top
+	jsr     clear_bottom
+
+	rts
+
+	;==========
+	; page_flip
+	;==========
+
+page_flip:
+	lda	DISP_PAGE						; 3
+	beq	page_flip_show_1					; 2nt/3
+page_flip_show_0:
+        bit	PAGE0							; 4
+	lda	#4							; 2
+	sta	DRAW_PAGE	; DRAW_PAGE=1				; 3
+	lda	#0							; 2
+	sta	DISP_PAGE	; DISP_PAGE=0				; 3
+	rts								; 6
+page_flip_show_1:
+	bit	PAGE1							; 4
+	sta	DRAW_PAGE	; DRAW_PAGE=0				; 3
+	lda	#1							; 2
+	sta	DISP_PAGE	; DISP_PAGE=1				; 3
+	rts								; 6
+							;====================
+							; DISP_PAGE=0 	26
+							; DISP_PAGE=1	24
+
+	;======================
+	; memset
+	;======================
+	; a=value
+	; x=length
+	; MEMPTRL/MEMPTRH is address
+memset:
+	ldy	#0
+memset_loop:
+	sta	MEMPTRL,Y
+	iny
+	dex
+	bne	memset_loop
+	rts
+
+
+	;=================
+	; load RLE image
+	;=================
+	; Output is BASH/BASL
+	; Input is in GBASH/GBASL
+load_rle_gr:
+	lda	#$0
+	tax
+	tay				; init X and Y to 0
+
+	sta	CV			; ycoord=0
+
+	lda	(GBASL),y		; load xsize
+	sta	CH
+	iny				; (we should check if we had
+					;  bad luck and overflows page)
+
+	iny				; skip ysize
+
+rle_loop:
+	lda	(GBASL),y		; load run value
+	cmp	#$ff			; if 0xff
+	beq	rle_done		; we are done
+	sta	RUN
+	iny				; point to next value
+	bne	rle_yskip1		; if overflow, increment address
+	inc	GBASH
+rle_yskip1:
+	lda	(GBASL),y		; load value to write
+	iny
+	bne	rle_yskip2
+	inc	GBASH
+rle_yskip2:
+	sty	TEMP2			; save y for later
+	pha
+	lda	#$0
+	tay
+	pla				; convoluted way to set y to 0
+
+rle_run_loop:
+	sta	(BASL),y		; write out the value
+	inc	BASL			; increment the pointer
+	bne	rle_skip3		; if wrapped
+	inc	BASH			; then increment the high value
+rle_skip3:
+	inx				; increment the X value
+	cpx	CH			; compare against the image width
+	bcc	rle_not_eol		; if less then keep going
+
+	pha				; save out value on stack
+
+	lda	BASL			; cheat to avoid a 16-bit add
+	cmp	#$a7			; we are adding 0x58 to get
+	bcc	rle_add_skip		; to the next line
+	inc	BASH
+rle_add_skip:
+	clc
+	adc	#$58			; actually do the 0x58 add
+	sta	BASL			; and store it back
+
+	inc	CV			; add 2 to ypos
+	inc	CV			; each "line" is two high
+
+	lda	CV			; load value
+	cmp	#15			; if it's greater than 14 it wraps
+	bcc	rle_no_wrap		; Thanks Woz
+
+	lda	#$0			; we wrapped, so set to zero
+	sta	CV
+
+					; when wrapping have to sub 0x3d8
+	sec				; this is a 16-bit subtract routine
+	lda	BASL
+	sbc	#$d8			; LSB
+	sta	BASL
+	lda	BASH			; MSB
+	sbc	#$3			;
+	sta	BASH
+
+rle_no_wrap:
+	lda	#$0			; set X value back to zero
+	tax
+	pla				; restore value to write from stack
+
+rle_not_eol:
+	dec	RUN			; decrement run value
+	bne	rle_run_loop		; if not zero, keep looping
+
+	ldy	TEMP2			; restore the input pointer
+	sec
+	bcs	rle_loop		; and branch always
+
+rle_done:
+	lda	#$15			; move the cursor somewhere sane
+	sta	CV
+	rts
+
+
+	;==========================================================
+	; set_text_page0
+	;==========================================================
+	;
+set_text_page0:
+	bit	PAGE0			; set page0
+	bit	TEXT			; set text mode
+	rts
+
+	;==========================================================
+	; set_gr_page0
+	;==========================================================
+	;
+set_gr_page0:
+	;lda	#4
+	;sta	GR_PAGE
+	bit	PAGE0			; set page 0
+	bit	LORES			; Lo-res graphics
+	bit	TEXTGR			; mixed gr/text mode
+	bit	SET_GR			; set graphics
+	rts
+
+	;=========================================================
+	; gr_copy_to_current
+	;=========================================================
+	; copy 0xc00 to DRAW_PAGE
+	; 2 + 8*38 + 4*80*23 + 4*120*26 + 13 = 20,159 = 20ms = 50Hz
+	;
+gr_copy_to_current:
+	ldx	#0		; set y to zero				; 2
+
+gr_copy_loop:
+	stx	TEMP		; save y				; 3
+	txa			; move to A				; 2
+	asl			; mult by 2				; 2
+	tay			; put into Y				; 2
+	lda	gr_offsets,Y	; lookup low byte for line addr		; 5
+	sta	OUTL		; out and in are the same		; 3
+	sta	INL							; 3
+	lda	gr_offsets+1,Y	; lookup high byte for line addr	; 5
+	adc	DRAW_PAGE
+	sta	OUTH							; 3
+	lda	gr_offsets+1,Y	; lookup high byte for line addr	; 5
+	adc	#$8		; for now, fixed 0xc			; 2
+	sta	INH							; 3
+	ldx	TEMP		; restore y				; 3
+
+	ldy	#0		; set X counter to 0			; 2
+gr_copy_line:
+	lda     (INL),Y		; load a byte				; 5
+	sta     (OUTL),Y	; store a byte				; 6
+	iny			; increment pointer			; 2
+
+	cpx	#$4		; don't want to copy bottom 4*40	; 2
+	bcs	gr_copy_above4						; 3
+
+gr_copy_below4:
+	cpy	#120		; for early ones, copy 120 bytes	; 2
+	bne	gr_copy_line						; 3
+	beq	gr_copy_line_done					; 3
+
+gr_copy_above4:			; for last four, just copy 80 bytes
+	cpy	#80							; 2
+	bne	gr_copy_line						; 3
+
+gr_copy_line_done:
+	inx			; increment y value			; 2
+	cpx	#8		; there are 8 of them			; 2
+	bne	gr_copy_loop	; if not, loop				; 3
+	rts								; 6
+
+	;==========================================================
+	; Wait until keypressed
+	;==========================================================
+	;
+
+wait_until_keypressed:
+	lda	KEYPRESS			; check if keypressed
+	bpl	wait_until_keypressed		; if not, loop
+	jmp     figure_out_key
+
+
+	;==========================================================
+	; Get Key
+	;==========================================================
+	;
+
+get_key:
+
+check_paddle_button:
+
+	; check for paddle button
+
+	bit	PADDLE_BUTTON0						; 4
+	bpl	no_button						; 2nt/3
+	lda	#' '+128						; 2
+	jmp	save_key						; 3
+
+no_button:
+	lda	KEYPRESS						; 3
+	bpl	no_key							; 2nt/3
+
+figure_out_key:
+	cmp	#' '+128		; the mask destroys space	; 2
+	beq	save_key		; so handle it specially	; 2nt/3
+
+	and	#$5f			; mask, to make upper-case	; 2
+check_right_arrow:
+	cmp	#$15							; 2
+	bne	check_left_arrow					; 2nt/3
+	lda	#'D'							; 2
+check_left_arrow:
+	cmp	#$08							; 2
+	bne	check_up_arrow						; 2nt/3
+	lda	#'A'							; 2
+check_up_arrow:
+	cmp	#$0B							; 2
+	bne	check_down_arrow					; 2nt/3
+	lda	#'W'							; 2
+check_down_arrow:
+	cmp	#$0A							; 2
+	bne	check_escape						; 2nt/3
+	lda	#'S'							; 2
+check_escape:
+        cmp	#$1B							; 2
+	bne	save_key						; 2nt/3
+	lda	#'Q'							; 2
+	jmp	save_key						; 3
+
+no_key:
+	bit	PADDLE_STATUS						; 3
+	bpl	no_key_store						; 2nt/3
+
+	; check for paddle action
+	; code from http://web.pdx.edu/~heiss/technotes/aiie/tn.aiie.06.html
+
+	inc	PADDLE_STATUS						; 5
+	lda	PADDLE_STATUS						; 3
+	and	#$03							; 2
+	beq	check_paddles						; 2nt/3
+	jmp	no_key_store						; 3
+
+check_paddles:
+	lda	PADDLE_STATUS						; 3
+	and	#$80							; 2
+	sta	PADDLE_STATUS						; 3
+
+	ldx	#$0							; 2
+	LDA	PTRIG		;TRIGGER PADDLES			; 4
+	LDY	#0		;INIT COUNTER				; 2
+	NOP			;COMPENSATE FOR 1ST COUNT		; 2
+	NOP								; 2
+PREAD2:	LDA	PADDL0,X	;COUNT EVERY 11 uSEC.			; 4
+	BPL	RTS2D		;BRANCH WHEN TIMED OUT			; 2nt/3
+	INY			;INCREMENT COUNTER			; 2
+	BNE	PREAD2		;CONTINUE COUNTING			; 2nt/3
+	DEY			;COUNTER OVERFLOWED			; 2
+RTS2D:				;RETURN W/VALUE 0-255
+
+        cpy	#96							; 2
+        bmi	paddle_left						; 2nt/3
+	cpy	#160							; 2
+	bmi	no_key_store						; 2nt/3
+	lda	#'D'							; 2
+	jmp	save_key						; 3
+paddle_left:
+	lda	#'A'							; 2
+	jmp	save_key						; 3
+
+no_key_store:
+	lda	#0			; no key, so save a zero	; 2
+
+save_key:
+	sta	LASTKEY			; save the key to our buffer	; 2
+	bit	KEYRESET		; clear the keyboard buffer	; 4
+	rts								; 6
+								;============
+								; 33=nokey
+								; 48=worstkey
+
+
+	;=============================================
+	; put_sprite
+	;=============================================
+	; Sprite to display in INH,INL
+	; Location is XPOS,YPOS
+	; Note, only works if YPOS is multiple of two?
+
+put_sprite:
+
+	ldy	#0		; byte 0 is xsize			; 2
+	lda	(INL),Y							; 5
+	sta	CH		; xsize is in CH			; 3
+	iny								; 2
+
+	lda	(INL),Y		; byte 1 is ysize			; 5
+	sta	CV		; ysize is in CV			; 3
+	iny								; 2
+
+	lda	YPOS		; make a copy of ypos			; 3
+	sta	TEMPY		; as we modify it			; 3
+								;===========
+								;	28
+put_sprite_loop:
+	sty	TEMP		; save sprite pointer			; 3
+
+	ldy	TEMPY							; 3
+	lda	gr_offsets,Y	; lookup low-res memory address		; 5
+	clc								; 2
+	adc	XPOS		; add in xpos				; 3
+	sta	OUTL		; store out low byte of addy		; 3
+	lda	gr_offsets+1,Y	; look up high byte			; 5
+	adc	DRAW_PAGE	;					; 3
+	sta	OUTH		; and store it out			; 3
+	ldy	TEMP		; restore sprite pointer		; 3
+
+				; OUTH:OUTL now points at right place
+
+	ldx	CH		; load xsize into x			; 3
+								;===========
+								;	36
+put_sprite_pixel:
+	lda	(INL),Y			; get sprite colors		; 5
+	iny				; increment sprite pointer	; 2
+
+	sty	TEMP			; save sprite pointer		; 3
+	ldy	#$0							; 2
+
+	; check if completely transparent
+	; if so, skip
+
+	cmp	#$0			; if all zero, transparent	; 2
+	beq	put_sprite_done_draw	; don't draw it			; 2nt/3
+					; FIXME: use BIT?	;==============
+								;	 17
+
+	sta	COLOR			; save color for later		; 3
+
+	; check if top pixel transparent
+
+	and	#$f0			; check if top nibble zero	; 2
+	bne	put_sprite_bottom	; if not skip ahead		; 2nt/3
+
+	lda	#$f0			; setup mask			; 2
+	sta	MASK							; 3
+	bmi	put_sprite_mask						; 2nt/3
+
+put_sprite_bottom:
+	lda	COLOR			; re-load color			; 3
+	and	#$0f			; check if bottom nibble zero	; 2
+	bne	put_sprite_all		; if not, skip ahead		; 2nt/3
+	lda	#$0f							; 2
+	sta	MASK			; setup mask			; 3
+
+put_sprite_mask:
+	lda	(OUTL),Y		; get color at output		; 5
+	and	MASK			; mask off unneeded part	; 3
+	ora	COLOR			; or the color in		; 3
+	sta	(OUTL),Y		; store it back			; 5
+
+	jmp	put_sprite_done_draw	; we are done			; 3
+
+put_sprite_all:
+	lda	COLOR			; load color			; 3
+	sta	(OUTL),Y		; and write it out		; 5
+
+
+put_sprite_done_draw:
+
+	ldy	TEMP			; restore sprite pointer	; 3
+
+	inc	OUTL			; increment output pointer	; 5
+	dex				; decrement x counter		; 2
+	bne	put_sprite_pixel	; if not done, keep looping	; 2nt/3
+
+	inc	TEMPY			; each line has two y vars	; 5
+	inc	TEMPY							; 5
+	dec	CV			; decemenet total y count	; 5
+	bne	put_sprite_loop		; loop if not done		; 2nt/3
+
+	rts				; return			; 6
+
+
+	;================================
+	; htab_vtab
+	;================================
+	; move to CH/CV
+htab_vtab:
+	lda	CV
+	asl
+	tay
+	lda	gr_offsets,Y    ; lookup low-res memory address
+	clc
+	adc	CH		; add in xpos
+	sta	BASL		; store out low byte of addy
+
+	lda	gr_offsets+1,Y	; look up high byte
+	adc	DRAW_PAGE	;
+	sta	BASH		; and store it out
+				; BASH:BASL now points at right place
+
+	rts
+
+	;================================
+	; move_and_print
+	;================================
+	; move to CH/CV
+move_and_print:
+	jsr	htab_vtab
+
+	;================================
+	; print_string
+	;================================
+
+print_string:
+	ldy	#0
+print_string_loop:
+	lda	(OUTL),Y
+	beq	done_print_string
+	ora	#$80
+	sta	(BASL),Y
+	iny
+	bne	print_string_loop
+done_print_string:
+	rts
+
+	;====================
+	; point_to_end_string
+	;====================
+point_to_end_string:
+	iny
+	tya
+	clc
+	adc	OUTL
+	sta	OUTL
+	lda	#0
+	adc	OUTH
+	sta	OUTH
+
+	rts
+
+
+	;================================
+	; print_both_pages
+	;================================
+print_both_pages:
+	lda	DRAW_PAGE
+	pha
+
+	lda	#0
+	sta	DRAW_PAGE
+	jsr	move_and_print
+
+	lda	#4
+	sta	DRAW_PAGE
+	jsr	move_and_print
+
+	pla
+	sta	DRAW_PAGE
+
+	rts	; oops forgot this initially
+		; explains the weird vertical stripes on the screen
+
+	;=========================================
+	; vlin
+	;=========================================
+	; X, V2 at Y
+vlin:
+
+	sty	TEMPY		; save Y (x location)
+vlin_loop:
+
+	txa			; a=x	(get first y)
+	and	#$fe		; Clear bottom bit
+	tay			;
+	lda	gr_offsets,Y	; lookup low-res memory address low
+	sta	GBASL		; put it into our indirect pointer
+	iny
+	lda	gr_offsets,Y	; lookup low-res memory address high
+	clc
+	adc	DRAW_PAGE	; add in draw page offset
+	sta	GBASH		; put into top of indirect
+
+	ldy	TEMPY		; load back in y (x offset)
+
+	txa			; load back in x (current y)
+	lsr			; check the low bit
+	bcc	vlin_low	; if not set, skip to low
+
+vlin_high:
+	lda	#$F0		; setup masks
+	sta	MASK
+	lda	#$0f
+	bcs	vlin_too_slow
+
+vlin_low:			; setup masks
+	lda	#$0f
+	sta	MASK
+	lda	#$f0
+vlin_too_slow:
+
+	and	(GBASL),Y	; mask current byte
+	sta	(GBASL),Y	; and store back
+
+	lda	MASK		; mask the color
+	and	COLOR
+	ora	(GBASL),Y	; or into the right place
+	sta	(GBASL),Y	; store it
+
+	inx			; increment X (current y)
+	cpx	V2		; compare to the limit
+	bcc	vlin_loop	; if <= then loop
+
+	rts			; return
+
+
+	;================================
+	; hlin_setup
+	;================================
+	; put address in GBASL/GBASH
+	; Ycoord in A, Xcoord in Y
+hlin_setup:
+	sty	TEMPY							; 3
+	tay			; y=A					; 2
+	lda	gr_offsets,Y	; lookup low-res memory address		; 4
+	clc								; 2
+	adc	TEMPY							; 3
+	sta	GBASL							; 3
+	iny								; 2
+
+	lda	gr_offsets,Y						; 4
+	adc	DRAW_PAGE	; add in draw page offset		; 3
+	sta	GBASH							; 3
+	rts								; 6
+								;===========
+								;	35
+	;================================
+	; hlin_double:
+	;================================
+	; HLIN Y, V2 AT A
+	; Y, X, A trashed
+	; start at Y, draw up to and including X
+hlin_double:
+;int hlin_double(int page, int x1, int x2, int at) {
+
+	jsr	hlin_setup						; 41
+
+	sec								; 2
+	lda	V2							; 3
+	sbc	TEMPY							; 3
+
+	tax								; 2
+	inx								; 2
+								;===========
+								;	53
+	; fallthrough
+
+	;=================================
+	; hlin_double_continue:  width
+	;=================================
+	; width in X
+
+hlin_double_continue:
+
+	ldy	#0							; 2
+	lda	COLOR							; 3
+hlin_double_loop:
+	sta	(GBASL),Y						; 6
+	inc	GBASL							; 5
+	dex								; 2
+	bne	hlin_double_loop					; 2nt/3
+
+	rts								; 6
+								;=============
+								; 53+5+X*16+5
+
+	;================================
+	; hlin_single:
+	;================================
+	; HLIN Y, V2 AT A
+	; Y, X, A trashed
+hlin_single:
+
+	jsr	hlin_setup
+
+	sec
+	lda	V2
+	sbc	TEMPY
+
+	tax
+
+	; fallthrough
+
+	;=================================
+	; hlin_single_continue:  width
+	;=================================
+	; width in X
+
+hlin_single_continue:
+
+hlin_single_top:
+	lda	COLOR
+	and	#$f0
+	sta	COLOR
+
+hlin_single_top_loop:
+	ldy	#0
+	lda	(GBASL),Y
+	and	#$0f
+	ora	COLOR
+	sta	(GBASL),Y
+	inc	GBASL
+	dex
+	bne	hlin_single_top_loop
+
+	rts
+
+hlin_single_bottom:
+
+	lda	COLOR
+	and	#$0f
+	sta	COLOR
+
+hlin_single_bottom_loop:
+	ldy	#0
+	lda	(GBASL),Y
+	and	#$f0
+	sta	(GBASL),Y
+	inc	GBASL
+	dex
+	bne	hlin_single_bottom_loop
+
+	rts
+
+
+	;=============================
+	; clear_top
+	;=============================
+clear_top:
+	lda	#$00
+
+	;=============================
+	; clear_top_a
+	;=============================
+clear_top_a:
+
+	sta	COLOR
+
+	; VLIN Y, V2 AT A
+
+	lda	#40
+	sta	V2
+
+	lda	#0
+
+clear_top_loop:
+	ldy	#0
+	pha
+
+	jsr	hlin_double
+
+	pla
+	clc
+	adc	#$2
+	cmp	#40
+	bne	clear_top_loop
+
+	rts
+
+clear_bottom:
+	lda	#$a0	; NORMAL space
+	sta	COLOR
+
+	lda	#40
+	sta	V2
+
+clear_bottom_loop:
+	ldy	#0
+	pha
+
+	jsr	hlin_double
+
+	pla
+	clc
+	adc	#$2
+	cmp	#48
+	bne	clear_bottom_loop
+
+	rts
diff --git a/dlowres_mode7/dlowres_zp.inc b/dlowres_mode7/dlowres_zp.inc
new file mode 100644
index 00000000..ec422f23
--- /dev/null
+++ b/dlowres_mode7/dlowres_zp.inc
@@ -0,0 +1,194 @@
+.define EQU =
+
+;; Zero page monitor routines addresses
+
+WNDLFT	EQU $20
+WNDWDTH	EQU $21
+WNDTOP	EQU $22
+WNDBTM	EQU $23
+CH	EQU $24
+CV	EQU $25
+GBASL	EQU $26
+GBASH	EQU $27
+BASL	EQU $28
+BASH	EQU $29
+H2	EQU $2C
+V2	EQU $2D
+MASK	EQU $2E
+COLOR	EQU $30
+INVFLG	EQU $32
+
+; More zero-page addresses
+; we try not to conflict with anything DOS, MONITOR or BASIC related
+
+COLOR1		EQU	$E0
+COLOR2		EQU	$E1
+MATCH		EQU	$E2
+XX		EQU	$E3
+YY		EQU	$E4
+YADD		EQU	$E5
+LOOP		EQU	$E6
+MEMPTRL		EQU	$E7
+MEMPTRH		EQU	$E8
+NAMEL		EQU	$E9
+NAMEH		EQU	$EA
+NAMEX		EQU	$EB
+CHAR		EQU	$EC
+DISP_PAGE       EQU	$ED
+DRAW_PAGE       EQU	$EE
+
+FIRST		EQU	$F0
+LASTKEY		EQU	$F1
+PADDLE_STATUS	EQU	$F2
+XPOS		EQU	$F3
+YPOS		EQU	$F4
+TEMP		EQU	$FA
+RUN		EQU	$FA
+TEMP2		EQU	$FB
+TEMPY		EQU	$FB
+INL		EQU	$FC
+INH		EQU	$FD
+OUTL		EQU	$FE
+OUTH		EQU	$FF
+
+
+;; Flying Routine Only
+
+TURNING		EQU	$60
+;SCREEN_X	EQU	$61		; not used?
+SCREEN_Y	EQU	$62
+ANGLE		EQU	$63
+HORIZ_SCALE_I	EQU	$64
+HORIZ_SCALE_F	EQU	$65
+FACTOR_I	EQU	$66
+FACTOR_F	EQU	$67
+DX_I		EQU	$68
+DX_F		EQU	$69
+SPACEX_I	EQU	$6A
+SPACEX_F	EQU	$6B
+CX_I		EQU	$6C
+CX_F		EQU	$6D
+DY_I		EQU	$6E
+DY_F		EQU	$6F
+SPACEY_I	EQU	$70
+SPACEY_F	EQU	$71
+CY_I		EQU	$72
+CY_F		EQU	$73
+TEMP_I		EQU	$74
+TEMP_F		EQU	$75
+DISTANCE_I	EQU	$76
+DISTANCE_F	EQU	$77
+SPACEZ_I	EQU	$78
+SPACEZ_F	EQU	$79
+DRAW_SPLASH	EQU	$7A
+SPEED		EQU	$7B
+SPLASH_COUNT	EQU	$7C
+OVER_LAND	EQU	$7D
+NUM1L		EQU	$7E
+NUM1H		EQU	$7F
+NUM2L		EQU	$80
+NUM2H		EQU	$81
+RESULT		EQU	$82 ; 83,84,85
+NEGATE		EQU	$86			; UNUSED?
+LAST_SPACEX_I	EQU	$87
+LAST_SPACEY_I	EQU	$88
+LAST_MAP_COLOR	EQU	$89
+DRAW_SKY	EQU	$8A
+COLOR_MASK	EQU	$8B
+
+SHIPY           EQU     $E4
+
+;; World Map Only
+
+ODD             EQU     $7B
+DIRECTION       EQU     $7C
+REFRESH         EQU     $7D
+ON_BIRD         EQU     $7E
+MOVED           EQU     $7F
+STEPS           EQU     $80
+TFV_X           EQU     $81
+TFV_Y           EQU     $82
+NEWX            EQU     $83
+NEWY            EQU     $84
+MAP_X           EQU     $85
+GROUND_COLOR    EQU     $86
+
+
+
+
+KEYPRESS	EQU	$C000
+KEYRESET	EQU	$C010
+
+;; SOFT SWITCHES
+EIGHTYSTORE_ON	EQU	$C000
+EIGHTYSTORE_OFF	EQU	$C001
+EIGHTYCOL	EQU	$C00D
+SET_GR		EQU	$C050
+SET_TEXT	EQU	$C051
+FULLGR		EQU	$C052
+TEXTGR		EQU	$C053
+PAGE0		EQU	$C054
+PAGE1		EQU	$C055
+LORES		EQU	$C056
+HIRES		EQU	$C057
+AN3		EQU	$C05E
+
+PADDLE_BUTTON0	EQU	$C061
+PADDL0		EQU	$C064
+PTRIG		EQU	$C070
+
+;; BASIC ROUTINES
+
+NORMAL	EQU	$F273
+
+;; MONITOR ROUTINES
+
+HLINE	EQU $F819			;; HLINE Y,$2C at A
+VLINE	EQU $F828			;; VLINE A,$2D at Y
+CLRSCR	EQU $F832			;; Clear low-res screen
+CLRTOP	EQU $F836			;; clear only top of low-res screen
+SETCOL	EQU $F864			;; COLOR=A
+TEXT	EQU $FB36
+TABV	EQU $FB5B			;; VTAB to A
+BASCALC	EQU $FBC1			;;
+VTAB	EQU $FC22			;; VTAB to CV
+HOME	EQU $FC58			;; Clear the text screen
+WAIT	EQU $FCA8			;; delay 1/2(26+27A+5A^2) us
+SETINV	EQU $FE80			;; INVERSE
+SETNORM	EQU $FE84			;; NORMAL
+COUT	EQU $FDED			;; output A to screen
+COUT1	EQU $FDF0			;; output A to screen
+
+
+
+
+
+
+COLOR_BLACK		EQU	0
+COLOR_RED		EQU	1
+COLOR_DARKBLUE		EQU	2
+COLOR_PURPLE		EQU	3
+COLOR_DARKGREEN		EQU	4
+COLOR_GREY		EQU	5
+COLOR_MEDIUMBLUE	EQU	6
+COLOR_LIGHTBLUE		EQU	7
+COLOR_BROWN		EQU	8
+COLOR_ORANGE		EQU	9
+COLOR_GREY2		EQU	10
+COLOR_PINK		EQU	11
+COLOR_LIGHTGREEN	EQU	12
+COLOR_YELLOW		EQU	13
+COLOR_AQUA		EQU	14
+COLOR_WHITE		EQU	15
+
+COLOR_BOTH_RED		EQU	$11
+COLOR_BOTH_DARKBLUE	EQU	$22
+COLOR_BOTH_DARKGREEN	EQU	$44
+COLOR_BOTH_GREY		EQU	$55
+COLOR_BOTH_MEDIUMBLUE	EQU	$66
+COLOR_BOTH_LIGHTBLUE	EQU	$77
+COLOR_BOTH_BROWN	EQU	$88
+COLOR_BOTH_ORANGE	EQU	$99
+COLOR_BOTH_LIGHTGREEN	EQU	$CC
+COLOR_BOTH_YELLOW	EQU	$DD
+COLOR_BOTH_WHITE	EQU	$FF
diff --git a/dlowres_mode7/fast_multiply.s b/dlowres_mode7/fast_multiply.s
new file mode 100644
index 00000000..294b3840
--- /dev/null
+++ b/dlowres_mode7/fast_multiply.s
@@ -0,0 +1,349 @@
+; Fast mutiply
+
+
+; Note for our purposes we only care about 8.8 x 8.8 fixed point
+; with 8.8 result, which means we only care about the middle two bytes
+; of the 32 bit result.  So we disable generation of the high and low byte
+; to save some cycles.
+
+;
+; The old routine took around 700 cycles for a 16bitx16bit=32bit mutiply
+; This routine, at an expense of 2kB of looku tables, takes around 250
+;	If you reuse a term the next time this drops closer to 200
+
+; This routine was described by Stephen Judd and found
+;	in The Fridge and in the C=Hacking magazine
+; http://codebase64.org/doku.php?id=base:seriously_fast_multiplication
+
+; The key thing to note is that
+;	       (a+b)^2     (a-b)^2
+;       a*b =  -------  -  --------
+;                 4           4
+; So if you have tables of the squares of 0..511 you can lookup and subtract
+; instead of multiplying.
+
+; Table generation: I:0..511
+;                   square1_lo = <((I*I)/4)
+;                   square1_hi = >((I*I)/4)
+;                   square2_lo = <(((I-255)*(I-255))/4)
+;                   square2_hi = >(((I-255)*(I-255))/4)
+
+; Note: DOS3.3 starts at $9600
+
+square1_lo	EQU	$8E00
+square1_hi	EQU	$9000
+square2_lo	EQU	$9200
+square2_hi	EQU	$9400
+
+;	for(i=0;i<512;i++) {
+;		square1_lo[i]=((i*i)/4)&0xff;
+;		square1_hi[i]=(((i*i)/4)>>8)&0xff;
+;		square2_lo[i]=( ((i-255)*(i-255))/4)&0xff;
+;		square2_hi[i]=(( ((i-255)*(i-255))/4)>>8)&0xff;
+;	}
+
+init_multiply_tables:
+
+	; Build the add tables
+
+	ldx	#$00
+	txa
+	.byte $c9   ; CMP #immediate - skip TYA and clear carry flag
+lb1:	tya
+	adc	#$00			; 0
+ml1:	sta	square1_hi,x		; square1_hi[0]=0
+	tay				; y=0
+	cmp	#$40			; subtract 64 and update flags (c=0)
+	txa				; a=0
+	ror				; rotate
+ml9:	adc	#$00			; add 0
+	sta	ml9+1			; update add value
+	inx				; x=1
+ml0:	sta	square1_lo,x		; square1_lo[0]=1
+	bne	lb1			; if not zero, loop
+	inc	ml0+2			; increment values
+	inc	ml1+2			; increment values
+	clc				; c=0
+	iny				; y=1
+	bne	lb1			; loop
+
+	; Build the subtract tables based on the existing one
+
+	ldx	#$00
+	ldy	#$ff
+second_table:
+	lda	square1_hi+1,x
+	sta	square2_hi+$100,x
+	lda	square1_hi,x
+	sta	square2_hi,y
+	lda	square1_lo+1,x
+	sta	square2_lo+$100,x
+	lda	square1_lo,x
+	sta	square2_lo,y
+	dey
+	inx
+	bne second_table
+
+
+	rts
+
+
+; Fast 16x16 bit unsigned multiplication, 32-bit result
+; Input: NUM1H:NUM1L * NUM2H:NUM2L
+; Result: RESULT3:RESULT2:RESULT1:RESULT0
+;
+; Does self-modifying code to hard-code NUM1H:NUM1L into the code
+;  carry=0: re-use previous NUM1H:NUM1L
+;  carry=1: reload NUM1H:NUM1L (58 cycles slower)
+;
+; clobbered: RESULT, X, A, C
+; Allocation setup: T1,T2 and RESULT preferably on Zero-page.
+;
+; NUM1H (x_i), NUM1L (x_f)
+; NUM2H (y_i), NUM2L (y_f)
+
+;	NUM1L * NUM2L = AAaa
+;	NUM1L * NUM2H = BBbb
+;	NUM1H * NUM2L = CCcc
+;	NUM1H * NUM2H = DDdd
+;
+;	       AAaa
+;	     BBbb
+;	     CCcc
+;	 + DDdd
+;	 ----------
+;	   RESULT
+
+;fixed_16x16_mul_unsigned:
+
+multiply:
+
+	bcc	num1_same_as_last_time					; 2nt/3
+
+	;============================
+	; Set up self-modifying code
+	; this changes the code to be hard-coded to multiply by NUM1H:NUM1L
+	;============================
+
+	lda	NUM1L	; load the low byte				; 3
+	sta	sm1a+1							; 3
+	sta	sm3a+1							; 3
+	sta	sm5a+1							; 3
+	sta	sm7a+1							; 3
+	eor	#$ff	; invert the bits for subtracting		; 2
+	sta	sm2a+1							; 3
+	sta	sm4a+1							; 3
+	sta	sm6a+1							; 3
+	sta	sm8a+1							; 3
+	lda	NUM1H	; load the high byte				; 3
+	sta	sm1b+1							; 3
+	sta	sm3b+1							; 3
+	sta	sm5b+1							; 3
+;	sta	sm7b+1							;
+	eor	#$ff	; invert the bits for subtractin		; 2
+	sta	sm2b+1							; 3
+	sta	sm4b+1							; 3
+	sta	sm6b+1							; 3
+;	sta	sm8b+1							;
+								;===========
+								;	 52
+
+num1_same_as_last_time:
+
+	;==========================
+	; Perform NUM1L * NUM2L = AAaa
+	;==========================
+
+	ldx	NUM2L	; (low le)					; 3
+	sec								; 2
+sm1a:
+	lda	square1_lo,x						; 4
+sm2a:
+	sbc	square2_lo,x						; 4
+
+	; a is _aa
+
+;	sta	RESULT+0						;
+
+sm3a:
+	lda	square1_hi,x						; 4
+sm4a:
+	sbc	square2_hi,x						; 4
+	; a is _AA
+	sta	_AA+1							; 3
+								;===========
+								;	24
+
+	; Perform NUM1H * NUM2L = CCcc
+	sec								; 2
+sm1b:
+	lda	square1_lo,x						; 4
+sm2b:
+	sbc	square2_lo,x						; 4
+	; a is _cc
+	sta	_cc+1							; 3
+sm3b:
+	lda	square1_hi,x						; 4
+sm4b:
+	sbc square2_hi,x						; 4
+	; a is _CC
+	sta	_CC+1							; 3
+								;===========
+								;	 24
+
+	;==========================
+	; Perform NUM1L * NUM2H = BBbb
+	;==========================
+	ldx	NUM2H							; 3
+	sec								; 2
+sm5a:
+	lda	square1_lo,x						; 4
+sm6a:
+	sbc	square2_lo,x						; 4
+	; a is _bb
+	sta	_bb+1							; 3
+
+sm7a:
+	lda	square1_hi,x						; 4
+sm8a:
+	sbc	square2_hi,x						; 4
+	; a is _BB
+	sta	_BB+1							; 3
+								;===========
+								;	 27
+
+	;==========================
+	; Perform NUM1H * NUM2H = DDdd
+	;==========================
+	sec								; 2
+sm5b:
+	lda	square1_lo,x						; 4
+sm6b:
+	sbc	square2_lo,x						; 4
+	; a is _dd
+	sta	_dd+1							; 3
+;sm7b:
+;	lda	square1_hi,x						;
+;sm8b:
+;	sbc	square2_hi,x						;
+	; a = _DD
+;	sta	RESULT+3						;
+								;===========
+								; 	 13
+
+	;===========================================
+	; Add the separate multiplications together
+	;===========================================
+
+	clc								; 2
+_AA:
+	lda	#0		; loading _AA				; 2
+_bb:
+	adc	#0		; adding in _bb				; 2
+	sta	RESULT+1						; 3
+								;==========
+								;	  9
+	; product[2]=_BB+_CC+c
+
+_BB:
+	lda	#0		; loading _BB				; 2
+_CC:
+	adc	#0		; adding in _CC				; 2
+	sta RESULT+2							; 3
+								;===========
+								;	  7
+
+	;  product[3]=_DD+c
+
+;	bcc	dd_no_carry1						;
+;	inc	RESULT+3						;
+	clc								; 2
+								;=============
+								;	  2
+dd_no_carry1:
+
+	; product[1]=_AA+_bb+_cc
+
+_cc:
+	lda	#0		; load _cc				; 2
+	adc	RESULT+1						; 3
+	sta	RESULT+1						; 3
+
+	; product[2]=_BB+_CC+_dd+c
+
+_dd:
+	lda	#0		; load _dd				; 2
+	adc	RESULT+2						; 3
+	sta	RESULT+2						; 3
+
+								;===========
+								;	 16
+	; product[3]=_DD+c
+
+
+;	bcc	dd_no_carry2						;
+;	inc	RESULT+3						;
+
+								;=============
+								;	 0
+
+dd_no_carry2:
+
+;	*z_i=product[1];
+;	*z_f=product[0];
+
+;	rts								; 6
+
+
+	;=================
+	; Signed multiply
+	;=================
+
+;multiply:
+
+;	jsr fixed_16x16_mul_unsigned					; 6
+
+	lda	NUM1H		; x_i					; 3
+								;===========
+								;	 12
+
+
+	bpl	x_positive						;^3/2nt
+
+	sec								; 2
+	lda	RESULT+2						; 3
+	sbc	NUM2L							; 3
+	sta	RESULT+2						; 3
+;	lda	RESULT+3						;
+;	sbc	NUM2H							;
+;	sta	RESULT+3						;
+								;============
+								;	 10
+
+x_positive:
+
+	lda	NUM2H		; y_i					; 3
+								;============
+								;	; 6
+
+	bpl	y_positive						;^3/2nt
+
+
+	sec								; 2
+	lda	RESULT+2						; 3
+	sbc	NUM1L							; 3
+	sta	RESULT+2						; 3
+;	lda	RESULT+3						;
+;	sbc	NUM1H							;
+;	sta	RESULT+3						;
+								;===========
+								;	 10
+
+y_positive:
+	ldx	RESULT+2	;	*z_i=product[2];		; 3
+	lda	RESULT+1	;	*z_f=product[1];		; 3
+
+	rts								; 6
+								;==========
+								;	 12
+