Article 1790 of rec.games.vectrex:
Path: mri-gw!psinntp!psinntp!psinntp!uunet!europa.eng.gtefsd.com!howland.reston.ans.net!torn!newshost.uwo.ca!gaul.csd.uwo.ca!magundi
From: magundi@gaul.csd.uwo.ca (john macdonald)
Newsgroups: rec.games.vectrex
Subject: Exec Rom source
Date: 24 Aug 1994 14:24:53 GMT
Organization: Computer Science Dept., Univ. of Western Ontario, London, Canada
Lines: 4966
Distribution: world
Message-ID: <33fl7l$1go@falcon.ccs.uwo.ca>
NNTP-Posting-Host: obelix.gaul.csd.uwo.ca

From fred@hpcvusc.cv.hp.com Wed Aug 24 09:48 EDT 1994
Date: Wed, 24 Aug 1994 06:47:26 -0700
From: Fred Taft <fred@hpcvusc.cv.hp.com>
To: magundi@uwo.ca
Subject: Exec Rom source
Status: O

/*
 * This work was originally done by Fred Taft (fred@hp-pcd.cv.hp.com).
 * Please forward any comments, corrections or additions back to Fred.
 *
 * Exec Rom
 */


			.org  0xF000
		 /*
		  * The executive OS code starts running here, each time
		  * the system is reset or powered up.
		  */
		 start_of_OS_ROM:
F000   10CECBEA         lds   #0xCBEA;   /* Set up stack pointer. */
F004   BDF18B           jsr   $reinit; 
F007   CC7321           ldd   #0x7321;
F00A   10B3CBFE         cmpd  $CBFE;     /* See if cold start is necessary. */
F00E   275C             beq   PF06C;  
F010   FDCBFE           std   $CBFE;  
F013   7CC83B           inc   $C83B;  
F016   8ECBEB           ldx   #0xCBEB;
F019   BDF84F           jsr   $set_dft_score; 

		 /* Start of initial powerup loop */
		 powerup_loop:
F01C   BDF1AF           jsr   $dptoC8; 
F01F   DC25             ldd   0x25;   
F021   10830101         cmpd  #0x0101;  /* Once we have looped 257 time, */
F025   2602             bne   PF029;    /* flag that it is alright to start */
F027   D756             stb   0x56;     /* playing the intro music.      */

		 /* Load the line pattern used for drawing boundary lines */
F029   57        PF029: asrb;    
F02A   C403             andb  #0x03;  
F02C   8EF0FD           ldx   #line_patterns;
F02F   E685             ldb   b,x;    
F031   D729             stb   0x29;   
F033   C602             ldb   #0x02;  
F035   D724             stb   0x24;   

		 /* Play the introductory song */
F037   CEFD0D           ldu   #intro_music_block;
F03A   BDF687           jsr   $init_sound; 
F03D   BDF192           jsr   $waitrecal; 
F040   BDF289           jsr   $do_sound; 
	
		 /* Display the Vectrex power-up message */
F043   BDF2A9           jsr   $intensity_to_7F; 
F046   B6C826           lda   $C826;  
F049   CEF10C           ldu   #vectrex_string;
F04C   8520             bita  #0x20;     /* Determine if double or single */
F04E   2702             beq   PF052;     /* Vectrex string should be shown. */
F050   334C             leau  12,u;   
F052   BDF385    PF052: jsr   $printu; 

		 /* Draw the edge boundary boxes */
F055   8EF0E9           ldx   #intro_box;
F058   BDF308    PF058: jsr   $move_penFF; 
F05B   8603             lda   #0x03;  
F05D   BDF434           jsr   $dwp_with_count; 
F060   7AC824           dec   $C824;  
F063   26F3             bne   PF058;  
F065   B6C825           lda   $C825;  
F068   8101             cmpa  #0x01;  
F06A   23B0             bls   powerup_loop;  
		 /* End of initial powerup loop */

		 /* Prepare to check to see if a valid ROM is installed */
F06C   BDF1AF    PF06C: jsr   $dptoC8; 
F06F   86CC             lda   #0xCC;  
F071   9729             sta   0x29;   
F073   CCF101           ldd   #gce_copyright_string;
F076   DD39             std   0x39;   
F078   0F25             clr   0x25;   
F07A   0F26             clr   0x26;   

		 /* Check to see if a valid game ROM is installed */
F07C   CE0000           ldu   #0x0000;
F07F   8EF101           ldx   #gce_copyright_string;
F082   C60B             ldb   #0x0B;  
F084   A6C0      PF084: lda   ,u+;    
F086   A180             cmpa  ,x+;    
F088   270D             beq   PF097;  
F08A   C101             cmpb  #0x01;  
F08C   2704             beq   PF092;  
F08E   C105             cmpb  #0x05;  
F090   2305             bls   PF097;  
F092   CEE000    PF092: ldu   #0xE000;
F095   2007             bra   PF09E;  
F097   5A        PF097: decb;    
F098   26EA             bne   PF084;  
F09A   D739             stb   0x39;     /* Save address of game cartridge's */
F09C   D73A             stb   0x3A;     /* copyright string.                */

		 /* Prepare to play the game's introductory tune */
F09E   0C56      PF09E: inc   0x56;   
F0A0   DF37             stu   0x37;   
F0A2   EEC4             ldu   ,u;

		 /* Start of second powerup loop */
		 powerup_loop2:
F0A4   BDF1AF           jsr   $dptoC8; 
F0A7   CCF848           ldd   #0xF848;
F0AA   DD2A             std   0x2A;   

		 /* Start playing the tune */
F0AC   BDF687           jsr   $init_sound; 
F0AF   BDF192           jsr   $waitrecal; 
F0B2   BDF289           jsr   $do_sound; 

		 /* Display cartridges 'gce' copyright string */
F0B5   BDF2A9           jsr   $intensity_to_7F; 
F0B8   CCC0C0           ldd   #0xC0C0;
F0BB   FEC839           ldu   $C839;  
F0BE   BDF37A           jsr   $print_at_d; 

		 /* Display the current high score, if any */
F0C1   B6C83B           lda   $C83B;  
F0C4   260C             bne   PF0D2;  
F0C6   4A               deca;    
F0C7   CECBEB           ldu   #0xCBEB;
F0CA   A746             sta   6,u;    
F0CC   CC68D0           ldd   #0x68D0;
F0CF   BDF37A           jsr   $print_at_d; 

		 /* Display the name of the game cartridge */
F0D2   FEC837    PF0D2: ldu   $C837;  
F0D5   3342             leau  2,u;    
F0D7   BDF385           jsr   $printu; 
F0DA   B6C856           lda   $C856;  
F0DD   26C5             bne   powerup_loop2;  
F0DF   BEC825           ldx   $C825;  
F0E2   8C007D           cmpx  #0x007D;
F0E5   23BD             bls   powerup_loop2;  
		 /* End of second powerup loop */

		 /* Jump to the start of the current game */
F0E7   6E41             jmp   1,u;


		 /* Vector list (y,x) for outer boundary box */
		 intro_box:
F0E9   40               .byte 0x40,0xD6;
F0EB   00               .byte 0x00,0x56; 
F0ED   81               .byte 0x81,0x00; 
F0EF   00               .byte 0x00,0xA9; 
F0F1   7E               .byte 0x7E,0x00;

		 /* Vector list (y,x) for inner boundary box */
		 intro_box2:
F0F3   39               .byte 0x39,0xDC;
F0F5   8E               .byte 0x8E,0x00; 
F0F7   00               .byte 0x00,0x4A; 
F0F9   72               .byte 0x72,0x00;
F0FB   00               .byte 0x00,0xB6; 

		 /* Line patterns used when drawing boundary boxes */
		 line_patterns:
F0FD   E0               .byte 0xE0;  /* Pattern = 11100000 */
F0FE   38               .byte 0x38;  /* Pattern = 00111000 */
F0FF   0E               .byte 0x0E;  /* Pattern = 00001110 */
F100   03               .byte 0x03;  /* Pattern = 00000011 */

		 /* Copyright string used to check for valid game ROM */
		 gce_copyright_string:
F101   67               .byte "g GCE 1982",0x80;

		 /* Introductory Vectrex title string */
		 vectrex_string:
F10C   F1               .byte 0xF1; /* height */
F10D   60               .byte 0x60; /* width  */
F10E   27               .byte 0x27; /* rel y  */
F10F   CF               .byte 0xCF; /* rel x  */
F110   56               .byte "VECTREX",0x80; 
F118   F3               .byte 0xF3; /* height */
F119   60               .byte 0x60; /* width  */
F11A   26               .byte 0x26; /* rel y  */
F11B   CF               .byte 0xCF; /* rel x  */
F11C   56               .byte "VECTREX",0x80;
F124   FC               .byte 0xFC; /* height */
F125   60               .byte 0x60; /* width  */
F126   DF               .byte 0xDF; /* rel y  */
F127   E9               .byte 0xE9; /* rel x  */
F128   47               .byte "GCE",0x80;
F12C   FC               .byte 0xFC; /* height */
F12D   38               .byte 0x38; /* width  */
F12E   CC               .byte 0xCC; /* rel y  */
F12F   D1               .byte 0xD1; /* rel x  */
F130   45               .byte "ENTERTAINING",0x80;
F13D   FC               .byte 0xFC; /* height */
F13E   38               .byte 0x38; /* width  */
F13F   BC               .byte 0xBC; /* rel y  */
F140   DC               .byte 0xDC; /* rel x  */
F141   4E               .byte "NEW IDEAS",0x80, 0x00;


		 /*
		  * init_PIA_chip()
		  *
		  * This routine is invoked during powerup, to initialize
		  * the PIA chip.  Among other things, it initializes the
		  * scale factor to 0x7F, and set the direction for the 
		  * A and B data lines.
		  *
		  * At exit:
		  *	Dp will be set to D0.
		  */
		 init_PIA_chip:
F14C   8D5C             bsr   dptoD0;  
F14E   CC9FFF           ldd   #0x9FFF;
F151   DD02             std   0x02;   
F153   CC0100           ldd   #0x0100;
F156   DD00             std   0x00;   
F158   CC987F           ldd   #0x987F;
F15B   970B             sta   0x0B;   
F15D   D704             stb   0x04;   
F15F   BDF354           jsr   $reset0ref; 
F162   203E             bra   set_refresh;  


		 /*
		  * initialize_OS_RAM()
		  *
		  * This routine first clears the block of RAM in the
		  * range C800 to C87A, and then it initializes the 
		  * dot dwell time, the refresh time, and the joystick
		  * enable flags.
		  *
		  * At exit:
		  *	Dp will be set to C8.
		  */
		 initialize_OS_RAM:
F164   8D49             bsr   dptoC8;  
F166   C67A             ldb   #0x7A;
F168   8EC800           ldx   #0xC800;
F16B   BDF53F           jsr   $clear_blockxb; 
F16E   CCC87D           ldd   #0xC87D;
F171   DD7B             std   0x7B;   
		 init_flags1:
F173   0C7D             inc   0x7D;   
F175   27FC             beq   init_flags1;  
F177   8605             lda   #0x05;  
F179   9728             sta   0x28;   
F17B   CC3075           ldd   #0x3075;
F17E   DD3D             std   0x3D;   
F180   CC0103           ldd   #0x0103;
F183   DD1F             std   0x1F;   
F185   CC0507           ldd   #0x0507;
F188   DD21             std   0x21;   
F18A   39               rts;


		 /*
		  * reinit()
		  *
		  * This routine is responsible for setting up the initial
		  * system state, each time the system is either reset or
		  * powered up.  It will initialize the OS RAM area, 
		  * initialize the PIA chip, and then clear out all the
		  * registers on the sound chip.
		  *
		  * At exit:
		  *	Dp will be set to D0.
		  */
		 reinit:
F18B   8DD7             bsr   initialize_OS_RAM;  
F18D   8DBD             bsr   init_PIA_chip;  
F18F   7EF272           jmp   $clear_sound_chip; 


		 /*
		  * waitrecal()
		  *
		  * Wait for t2 (the refresh timer) to timeout, then restart
		  * it using the value ic C83D.  then, recalibrate the
		  * vector generators to the origin (0,0).  This routine
		  * MUST be called once every refresh cycle, or your vectors
		  * will get out of whack.  This routine calls reset0ref,
		  * so the integrators are left in zero mode.
		  *
		  * At exit:
		  *	Dp will be set to D0.
		  */
		 waitrecal:
F192   BEC825           ldx   $C825;  
F195   3001             leax  1,x;      /* Increment loop counter. */
F197   BFC825           stx   $C825;  
F19A   8D0E             bsr   dptoD0;  
F19C   8620             lda   #0x20;
F19E   950D      PF19E: bita  0x0D;   
F1A0   27FC             beq   PF19E;  


		 /*
		  * set_refresh()
		  *
		  * This routine loads the refresh timer (t2) with the value
		  * in C83D-C83E, and recalibrates the vector generators,
		  * thus causing the pen to be left at the origin (0,0).
		  * The high order byte for the timer is loaded from C83E,
		  * and the low order byte is loaded from C83D.  The 
		  * refresh rate is calculated as follows:
		  *
		  *   rate = (C83E)(C83D) / 1.5 mhz
		  *
		  * At entry:
		  *	Dp must be D0.
		  */
		  set_refresh:
F1A2   FCC83D           ldd   $C83D;  
F1A5   DD08             std   0x08;   
F1A7   7EF2E6           jmp   $PF2E6; 


		 /*
		  * dptoD0()
		  *
		  * Sets the dp register to D0, so that all direct addresses
		  * will start at D000 (the hardware I/O area).
		  *
		  * At exit:
		  *	Dp will be set to D0.
		  *	'a' will be trashed.
		  */
		 dptoD0:
F1AA   86D0             lda   #0xD0;  
F1AC   1F8B             tfr   a,dp;   
F1AE   39               rts;


		 /*
		  * dptoC8()
		  *
		  * Sets the Dp register to C8, so that all direct addresses
		  * start at C800 (OS RAM area).
		  *
		  * At exit:
		  *	Dp will be set to C8.
		  *	'a' will be trashed.
		  */
	 	 dptoC8:
F1AF   86C8             lda   #0xC8;  
F1B1   1F8B             tfr   a,dp;   
F1B3   39               rts;


		 /*
		  * read_switches()
		  * read_switches2()
		  *
		  * Both of these routines read the button states on the
		  * two consoles, and return their state in the following
		  * RAM locations:
		  *
		  *	console 1, button 1:	C812
		  *		   button 2:	C813
		  *		   button 3:	C814
		  *		   button 4:	C815
		  *	console 2, button 1:	C816
		  *		   button 2:	C817
		  *		   button 3:	C818
		  *		   button 4:	C819
		  *
		  * Also, these routines provide several other pieces of
		  * information which are useful:
		  *
		  *	C80F: Contains current state of all buttons;
		  *	      1 = depressed, 0 = not depressed
		  *
		  *	C810: Contains state of all buttons from LAST
		  *	      time these routines were called; if read_switches
		  *	      was invoked, then this is AND'ed with the
		  *	      passed in mask.
		  *
		  *	For the above 2 bytes, bit 1 is console1:button1.
		  *
		  * If read_switches2() is called, then the current state
		  * of all the buttons will be returned.
		  *
		  * If read_switches() is called, then a mask, passed in 
		  * in the 'a' register and having the following format,
		  * will be used to determine how the buttons state info
		  * is returned:
		  *
		  *	bit 0 = console1:button1
		  *	bit 1 = console1:button2
		  *	etc
		  *
		  * If a bit is 0, then the current state of the button is
		  * to be returned in the appropriate RAM location; 
		  * 0 = not pressed, and 1 = pressed.
		  *
		  * If a bit is 1, then the appropriate RAM location is set
		  * to 1 only on the depression transition of the button;
		  * additional calls will return 0, until the button is
		  * released and then depressed again.
		  *
		  * At entry:
		  *	Dp must be set to D0.
		  *	'a' must contain mask (for read_switches only)
		  */
		 read_switches:
F1B4   B4C80F           anda  $C80F;  
F1B7   B7C80F           sta   $C80F;  
		 read_switches2:
F1BA   8EC812           ldx   #0xC812;
F1BD   A61D             lda   -3,x;   
F1BF   A71E             sta   -2,x;   
F1C1   860E             lda   #0x0E;  
F1C3   9701             sta   0x01;   
F1C5   CC1901           ldd   #0x1901;
F1C8   9700             sta   0x00;   
F1CA   12               nop;
F1CB   D700             stb   0x00;   
F1CD   0F03             clr   0x03;   
F1CF   CC0901           ldd   #0x0901;
F1D2   9700             sta   0x00;   
F1D4   12               nop;
F1D5   9601             lda   0x01;   
F1D7   43               coma;    
F1D8   A71D             sta   -3,x;   
F1DA   D700             stb   0x00;   
F1DC   C6FF             ldb   #0xFF;  
F1DE   D703             stb   0x03;   
F1E0   43               coma;    
F1E1   AA1E             ora   -2,x;   
F1E3   43               coma;    
F1E4   A71F             sta   -1,x;   
F1E6   3402             pshs  a; 
F1E8   C601             ldb   #0x01;  
F1EA   1F98      PF1EA: tfr   b,a;    
F1EC   A4E4             anda  ,s;
F1EE   A780             sta   ,x+;    
F1F0   58               aslb;    
F1F1   26F7             bne   PF1EA;  
F1F3   3582             puls  a,pc;   


F1F5   7AC823    PF1F5: dec   $C823;  


		 /*
		  * read_jstick()
		  *
		  * This routine reads the current positions of the joysticks
		  * on the two consoles.  Before calling this routine, some
		  * prior setup is required.  Firstly, the joystick enable
		  * flags (C81F-C822) must be initialized to one of the
		  * following values:
		  *
		  *	0 - ignore; return no value.
		  *	1 - return state of console 1 left/right position.
		  *	3 - return state of console 1 up/down position.
		  *	5 - return state of console 2 left/right position.
		  *	7 - return state of console 2 up/down position.
		  *
		  * The joystick values are returned in C81B-C81E, where the
		  * value returned in C81B corresponds to the mask set in
		  * in C81F, and so on and so forth.
		  *
		  * Location C823 is used to determine what kind of input
		  * conversion should be performed, and how the data should
		  * be returned to the calling procedure.  Valid choices are:
		  *
		  *	>= 0	The return value will be:
		  *		  < 0 if joystick is left of down of center.
		  *		  = 0 if joystick is centered.
		  *		  > 0 if joystick is right or up of center.
		  *
		  *	< 0	A successive approximation algorithm is used
		  *		read the actual value of the joystick pot, a
		  *		signed value.  In this case, C81A must be set
		  *		to a power of 2, to control conversion
		  *		resolution; 0x80 is least accurate, and 0x00
		  *		is most accurate.
		  *
		  * At entry:
		  *	Dp must be set to D0.
		  *	
		  * At exit:
		  *	C823 is cleared.
		  */
		 read_jstick:
F1F8   8EC81F           ldx   #0xC81F;
		 next_pot:
F1FB   A680             lda   ,x+;    
F1FD   260C             bne   process_a_pot;  
		 check_4_done:
F1FF   8CC823           cmpx  #0xC823;
F202   26F7             bne   next_pot;  
F204   6F84             clr   ,x;
F206   8601             lda   #0x01;  
F208   9700             sta   0x00;   
F20A   39               rts;
		 process_a_pot:
F20B   9700             sta   0x00;   
F20D   0F01             clr   0x01;   
F20F   0A00             dec   0x00;   
F211   C660             ldb   #0x60; /* "`" */                                
F213   5C        PF213: incb;    
F214   2AFD             bpl   PF213;  
F216   B6C823           lda   $C823;  
F219   2B25             bmi   use_approx;  
F21B   8620             lda   #0x20; /* " " */                                
F21D   0C00             inc   0x00;   
F21F   9500             bita  0x00;   
F221   270A             beq   left_or_down;  
F223   C640             ldb   #0x40; /* "@" */                                
F225   D701             stb   0x01;   
F227   9500             bita  0x00;   
F229   260B             bne   save_jstick_state;  
F22B   2008             bra   centered;  
		 left_or_down:
F22D   C6C0             ldb   #0xC0;  
F22F   D701             stb   0x01;   
F231   9500             bita  0x00;   
F233   2701             beq   save_jstick_state;  
		 centered:
F235   5F               clrb;    
		 save_jstick_state:
F236   E71B             stb   -5,x;   
F238   20C5             bra   check_4_done;  
		 try_again:
F23A   1F98             tfr   b,a;    
F23C   9A01             ora   0x01;   
F23E   9701             sta   0x01;   
		 use_approx:
F240   8620             lda   #0x20;
F242   9500             bita  0x00;   
F244   2606             bne   check_resolution;  
F246   1F98             tfr   b,a;    
F248   9801             eora  0x01;   
F24A   9701             sta   0x01;   
		 check_resolution:
F24C   54               lsrb;    
F24D   F1C81A           cmpb  $C81A;  
F250   26E8             bne   try_again;  
F252   D601             ldb   0x01;   
F254   20E0             bra   save_jstick_state;  


		 /*
		  * byte_2_sound_chip()
		  * byte_2_sound_chip2()
		  *
		  * Both of these routines cause a byte of music data to
		  * be written to the music chip, and also stored in the
		  * the appropriate RAM location in the range C800-C80E.
		  * 
		  * At entry: (both)
		  * 	'a' = indicates which one of the 15 music registers
		  *	      is to be modified.
		  *	'b' = the byte of music data.
		  *
		  * At entry: (byte_2_sound_chip2 only)
		  *	'x' = base address of RAM area where a copy of music
		  *	      data is to be stored.
		  *
		  * For byte_2_sound_chip(), the base address is forced to
		  * be C800.
		  *
		  * At entry, Dp must be set to D0.
		  */
		 byte_2_sound_chip:
F256   8EC800           ldx   #0xC800;
		 byte_2_sound_chip2:
F259   E786             stb   a,x;    
F25B   9701             sta   0x01;   
F25D   8619             lda   #0x19;  
F25F   9700             sta   0x00;   
F261   8601             lda   #0x01;  
F263   9700             sta   0x00;   
F265   9601             lda   0x01;   
F267   D701             stb   0x01;   
F269   C611             ldb   #0x11;  
F26B   D700             stb   0x00;   
F26D   C601             ldb   #0x01;  
F26F   D700             stb   0x00;   
F271   39               rts;


		 /*
		  * clear_sound_chip()
		  *
		  * This routine clears the 15 registers on the music chip
		  * and the soft copy of their values (C800-C80E), by writing
		  * a byte of 0 to each register.  This causes the sound chip
		  * to not make any sounds.
		  *
		  * At entry:
		  *	Dp must be set to D0.
		  */
		 clear_sound_chip:
F272   CC0E00           ldd   #0x0E00;
F275   8DDF      PF275: bsr   byte_2_sound_chip;  
F277   4A               deca;    
F278   2AFB             bpl   PF275;  
F27A   7EF533           jmp   $init_music_buf; 


		 /*
		  * copy_bytes_2_sound_chip()
		  *
		  * This routine copies a block of sound information into
		  * the sound chip buffer (at C800-C80E) and into the 
		  * registers on the music chip.  The format for the block
		  * of sound data is as follows:
		  *
		  *   (register number), (music data),
		  *   (register number), (music data),
		  *         .                  .
		  *         .                  .
		  *       0xFF
		  *
		  * As long as the register number is >= 0, then the music
		  * data will be copied; however, as soon as a register
		  * number < 0 is encountered, the copy will stop.
		  *
		  * At entry:
		  *	'u' contains a pointer to the block of sound data.
		  *	
		  * Dp must be set to D0.
		  */
		 copy_bytes_2_sound_chip:
F27D   8EC800           ldx   #0xC800;
F280   2002             bra   PF284;  
F282   8DD5      PF282: bsr   byte_2_sound_chip2;  
F284   ECC1      PF284: ldd   ,u++;   
F286   2AFA             bpl   PF282;  
F288   39               rts;


		 /*
		  * do_sound()
		  *
		  * This routine will start/continue making the sound which
		  * was first set up by your call to init_sound().  This
		  * routine should normally be called right after your call
		  * to waitrecal().  It takes the next music information,
		  * contained in the music buffer C83F-C84C, and updates only
		  * those registers which differ from the last data written
		  * to the sound chip.
		  *
		  * At entry, Dp must be set to D0.
		  */
		 do_sound:
F289   8EC800           ldx   #0xC800;
F28C   CEC83F           ldu   #0xC83F;
F28F   860D             lda   #0x0D;  
F291   E6C0      PF291: ldb   ,u+;    
F293   E186             cmpb  a,x;    
F295   2702             beq   PF299;  
F297   8DC0             bsr   byte_2_sound_chip2;  
F299   4A        PF299: deca;    
F29A   2AF5             bpl   PF291;  
F29C   39               rts;


		 /*
		  * intensity_to_1F()
		  * intensity_to_3F()
		  * intensity_to_5F()
		  * intensity_to_7F()
		  * intensity_to_a()
		  *
		  * Each of these routines are responsible for setting the
		  * vector/dot intensity (commonly used to denote the z axis)
		  * to a specific value.  0x00 is the lowest intensity, and
		  * 0xFF is the brightest intensity.  The intensity must
		  * be reset to the desired value after each call to
		  * waitrecal(); however, it can also be changed at any other
		  * time.  A copy of the new intensity value is saved in
		  * C827.
		  *
		  * At entry: (for intensity_to_a() only)
		  *	'a' must contain the new intensity value.
		  *
		  * Dp must be set to D0.
		  */
		 intensity_to_1F:
F29D   861F             lda   #0x1F;  
F29F   200A             bra   intensity_to_a;  
		 intensity_to_3F:
F2A1   863F             lda   #0x3F;
F2A3   2006             bra   intensity_to_a;  
		 intensity_to_5F:
F2A5   865F             lda   #0x5F;
F2A7   2002             bra   intensity_to_a;  
		 intensity_to_7F:
F2A9   867F             lda   #0x7F;  
		 intensity_to_a:
F2AB   9701             sta   0x01;   
F2AD   B7C827           sta   $C827;  
F2B0   CC0504           ldd   #0x0504;
F2B3   9700             sta   0x00;   
F2B5   D700             stb   0x00;   
F2B7   D700             stb   0x00;   
F2B9   C601             ldb   #0x01;  
F2BB   D700             stb   0x00;   
F2BD   39               rts;


		 /*
		  * dotixb()
		  *
		  * This routine draws a dot at the relative y and
		  * relative x position pointed to by the 'x' register.
		  * Afterwards, the 'x' register is incremented by 2.
		  * The intensity to be used is passed in in the 'b'
		  * register, and this value is saved in C828.
		  *
		  * At entry:
		  *	'x' points to the (y,x) coordinate pair.
		  *	'b' contains intensity.
		  *
		  * At exit:
		  *	'x' has been incremented by 2.
		  *
		  * Dp must be set to D0.
		  */
		 dotixb:
F2BE   F7C828           stb   $C828;  


		 /*
		  * dotix()
		  *
		  * This routine draws a dot at the relative y and
		  * relative x position pointed to by the 'x' register.
		  * Afterwards, the 'x' register is incremented by 2.
		  * The intensity used is the value already stored in C828.
		  *
		  * At entry:
		  *	'x' points to the (y,x) coordinate pair.
		  *
		  * At exit:
		  *	'x' has been incremented by 2.
		  *
		  * Dp must be set to D0.
		  */
		 dotix:
F2C1   EC81             ldd   ,x++;   


		 /*
		  * dot_at_d()
		  *
		  * This routine draws a dot at the relative y and
		  * relative x position contained in the 'd' register.
		  * The intensity used is the value already stored in C828.
		  *
		  * At entry:
		  *	'a' contains the relative y coordinate.
		  *	'b' contains the relative x coordinate.
		  *
		  * Dp must be set to D0.
		  */
		 dot_at_d:
F2C3   8D4D             bsr   move_pen_d;  


		 /*
		  * dot_at_current_position()
		  *
		  * This routine draws a dot at the current pen position.
		  * The intensity used is the value already stored in C828.
		  *
		  * Dp must be set to D0.
		  */
		 dot_at_current_position:
F2C5   86FF             lda   #0xFF;  
F2C7   970A             sta   0x0A;   
F2C9   F6C828           ldb   $C828;  
F2CC   5A        PF2CC: decb;    
F2CD   26FD             bne   PF2CC;  
F2CF   0F0A             clr   0x0A;   
F2D1   39               rts;


		 /*
		  * dot_list()
		  *
		  * This routine draws a series of dots, using the intensity
		  * already set up in C828.  The format for the dot list, which
		  * is pointed to by the 'x' register, is:
		  *
		  *	( rel y, rel x), (rel y, rel x), .....
		  *
		  * The number of dots to draw is specified in C823.
		  *
		  * At entry:
		  *	'x' points to the list of dot coordinates.
		  *	C823 specifies the number of dots to draw.
		  *
		  * Dp must be set to D0.
		  */
		 next_dot:
F2D2   7AC823           dec   $C823;  
		 dot_list:
F2D5   8DEA             bsr   PF2C1;  
F2D7   B6C823           lda   $C823;  
F2DA   26F6             bne   next_dot;  
F2DC   2076             bra   reset0ref;  


		 /*
		  * dotix_then_reset()
		  *
		  * This routine draws a series of dots, specified by the
		  * list pointed to by the 'x' register.  The list has the
		  * following format:
		  *
		  *	mode, relative y, relative x,
		  *	mode, relative y, relative x,
		  *       .      .           .
		  *       .      .           .
		  *     mode, relative y, relative x
		  *
		  * This routine will continue to traverse the list, until
		  * a mode > 0 is encountered; at that point, it will reset
		  * the 0 reference (the integrators).
		  *
		  * At entry:
		  *	'x' points to the dot list.
		  *
		  * At exit:
		  *	'x' will point to the relative y coordinate associated
		  *	    with the mode which cause the routine to stop.
		  *
		  * Dp must be set to D0.
		  */
		 dotix_then_reset:
F2DE   A680             lda   ,x+;    
F2E0   2E72             bgt   reset0ref;  
F2E2   8DDD             bsr   PF2C1;  
F2E4   20F8             bra   dotix_then_reset;  


F2E6   8EF9F0    PF2E6: ldx   #0xF9F0;
F2E9   8D1D             bsr   move_penFF;  
F2EB   BDF36B           jsr   $PF36B; 
F2EE   8D20             bsr   move_pen;  
F2F0   2062             bra   reset0ref;  


		 /*
		  * move_pen_7F_no_inc()
		  *
		  * This routine forces the scale factor to 0x7F, and then
		  * moves the pen to the location pointed to by the 'x'
		  * register.  The relative y and relative x coordinates
		  * are both 2 byte quantities; however, only the most signicant
		  * byte of each is of any interest.  The values pointed to
		  * by the 'x' register have the following format:
		  *
		  * 	'x' => (rel y hi),(rel y lo), (rel x hi), (rel x lo)
		  *
		  * The position moved to is obtained by y=(0,x) & x=(2,x).
		  *
		  * At entry:
		  *	'x' points to double sized coordinate pair.
		  *
		  * Dp must be set to D0.
		  */
		 move_pen7F_no_inc:
F2F2   C67F             ldb   #0x7F;  
F2F4   D704             stb   0x04;   
F2F6   A684             lda   ,x;
F2F8   E602             ldb   2,x;    
F2FA   2016             bra   move_pen_d;  


		 /*
		  * move_pen7F_to_d()
		  *
		  * This routine forces the scale factor to 0x7F, and then
		  * moves the pen to the position specified in the 'd'
		  * register.
		  *
		  * At entry:
		  *	'a' must contain the relative y coordinate.
		  *	'b' must contain the relative x coordinate.
		  *
		  * Dp must be set to D0.
		  */
		 move_pen7F_to_d:
F2FC   9701             sta   0x01;   
F2FE   3406             pshs  a,b;    
F300   867F             lda   #0x7F;  
F302   9704             sta   0x04;   
F304   0F00             clr   0x00;   
F306   2010             bra   PF318;  


		 /*
		  * move_penFF()
		  * 
		  * This routine forces the scale factor to 0xFF, and then
		  * moves the pen to the (y,x) position pointed to by the
		  * 'x' register.  The 'x' register is then incremented by 2.
		  *
		  * At entry:
		  *	'x' points to the (y,x) coordinate pair.
		  *
		  * At exit:
		  *	'x' has been incremented by 2.
		  *
		  * Dp must be set to D0.
		  */
	 	 move_penFF:
F308   C6FF             ldb   #0xFF;  
F30A   2002             bra   set_scale_factor;  


		 /*
		  * move_pen7F()
		  * 
		  * This routine forces the scale factor to 0x7F, and then
		  * moves the pen to the (y,x) position pointed to by the
		  * 'x' register.  The 'x' register is then incremented by 2.
		  *
		  * At entry:
		  *	'x' points to the (y,x) coordinate pair.
		  *
		  * At exit:
		  *	'x' has been incremented by 2.
		  *
		  * Dp must be set to D0.
		  */
		 move_pen7F:
F30C   C67F             ldb   #0x7F;  
		 set_scale_factor:
F30E   D704             stb   0x04;   


		 /*
		  * This routine uses the current scale factor, and 
		  * moves the pen to the (y,x) position pointed to by the
		  * 'x' register.  The 'x' register is then incremented by 2.
		  *
		  * At entry:
		  *	'x' points to the (y,x) coordinate pair.
		  *
		  * At exit:
		  *	'x' has been incremented by 2.
		  *
		  * Dp must be set to D0.
		  */
		 move_pen:
F310   EC81             ldd   ,x++;   


		 /* move_pen_d()
		  *
		  * This routine uses the current scale factor, and 
		  * moves the pen to the (y,x) position specified in the
		  * 'd' register.  'a' contains the y coordinate, and 'b'
		  * contains the x coordinate.
		  *
		  * At entry:
		  *	'a' contains the y coordinate.
		  *	'b' contains the x coordinate.
		  *
		  * Dp must be set to D0.
		  */
		 move_pen_d:
F312   9701             sta   0x01;   
F314   0F00             clr   0x00;   
F316   3406             pshs  a,b;    
F318   86CE      PF318: lda   #0xCE;  
F31A   970C             sta   0x0C;   
F31C   0F0A             clr   0x0A;   
F31E   0C00             inc   0x00;   
F320   D701             stb   0x01;   
F322   0F05             clr   0x05;   
F324   3506             puls  a,b;    
F326   BDF584           jsr   $get_absolute_value_of_ab; 
F329   E77F             stb   -1,s;   
F32B   AA7F             ora   -1,s;   
F32D   C640             ldb   #0x40;
F32F   8140             cmpa  #0x40;
F331   2312             bls   PF345;
F333   8164             cmpa  #0x64;
F335   2304             bls   PF33B;  
F337   8608             lda   #0x08;  
F339   2002             bra   PF33D;  
F33B   8604      PF33B: lda   #0x04;  
F33D   D50D      PF33D: bitb  0x0D;   
F33F   27FC             beq   PF33D;  
F341   4A        PF341: deca;    
F342   26FD             bne   PF341;  
F344   39               rts;
F345   D50D      PF345: bitb  0x0D;   
F347   27FC             beq   PF345;  
F349   39               rts;

		 /*
		  * set_dp_and_reset0ref()
		  *
		  * This routine sets the Dp register to D0, and then
		  * resets the integrators.
		  *
		  * At exit:
		  *	Dp will be set to D0.
		  */
		 set_dp_and_reset0ref:
F34A   BDF1AA           jsr   $dptoD0; 
F34D   2005             bra   reset0ref;  


		 /*
		  * check0ref()
		  *
		  * This routine will check to see if the reset0ref enable
		  * flag (C824) is set, and if it is, then it will reset the
		  * integrators, by calling reset0ref().
		  *
		  * At entry:
		  *	Dp must be set to D0.
		  */
		 check0ref:
F34F   B6C824           lda   $C824;  
F352   2716             beq   PF36A;  

		 /*
		  * reset0ref()
		  *
		  * This routine zeros the integrators, and resets the pen
		  * back to the origin.  It leaves the integrators in zero
		  * mode, so nothing can be drawn until a move is done, or
		  * D00C is set to 0xCE.  This routine must be called every
		  * so often, to prevent your vectors from getting out of
		  * whack.
		  *
		  * At entry:
		  *	Dp must be set to D0.
		  */
		 reset0ref:
F354   CC00CC           ldd   #0x00CC;
F357   D70C             stb   0x0C;   
F359   970A             sta   0x0A;   
F35B   CC0302           ldd   #0x0302;
F35E   0F01             clr   0x01;   
F360   9700             sta   0x00;   
F362   D700             stb   0x00;   
F364   D700             stb   0x00;   
F366   C601             ldb   #0x01;  
F368   D700             stb   0x00;   
F36A   39        PF36A: rts;


F36B   CC00CC    PF36B: ldd   #0x00CC;
F36E   D70C             stb   0x0C;   
F370   970A             sta   0x0A;   
F372   39               rts;


		 /*
		  * print_1_string()
		  *
		  * This routine prints a single string (upto a 0x80).
		  * The parameter block describing the string is pointed
		  * to by the 'u' register.  The format for the parameter
		  * block is as follows:
		  *
		  *	height, width, rel y, rel x, string, 0x80
		  *	
		  * At entry:
		  * 	'u' points to the string parameter block.
		  *
		  * At exit:
		  *	'u' points to byte after terminating 0x80.
		  *
		  * Dp must be set to D0.
		  */
		 print_1_string:
F373   ECC1             ldd   ,u++;     /* Save height & width */
F375   FDC82A           std   $C82A;  


		 /*
		  * print_with_dft_hw()
		  *
		  * This routine prints a single string (upto a 0x80),
		  * using the default height and width, as stored in C82A.
		  * The parameter block describing the string is pointed
		  * to by the 'u' register.  The format for the parameter
		  * block is as follows:
		  *
		  *	rel y, rel x, string, 0x80
		  *	
		  * At entry:
		  * 	'u' points to the string parameter block.
		  *
		  * At exit:
		  *	'u' points to byte after the terminating 0x80.
		  *
		  * Dp must be set to D0.
		  */
		 print_with_dft_hw:
F378   ECC1             ldd   ,u++;     /* Get (y,x) position. */


		 /*
		  * print_at_d()
		  *
		  * This routine prints a single string (upto a 0x80),
		  * using the default height and width, as stored in C82A,
		  * and at the pen position specified in the 'd' register.
		  * The parameter block describing the string is pointed
		  * to by the 'u' register.  The format for the parameter
		  * block is as follows:
		  *
		  *	string, 0x80
		  *	
		  * At entry:
		  * 	'u' points to the string parameter block.
		  *	'a' contains relative y position.
		  *	'b' contains relative x position.
		  *
		  * At exit:
		  *	'u' points to byte after the terminating 0x80.
		  *
		  * Dp must be set to D0.
		  */
		 print_at_d:
F37A   BDF2FC           jsr   $move_pen7F_to_d; 
F37D   BDF575           jsr   $delay_b_1; 
F380   7EF495           jmp   $display_string; 


		 /*
		  * printu()
		  *
		  * This displays the group of strings described by the
		  * parameter block which is pointed to by the 'u' register.
		  * The string parameter block has the following format:
		  *
		  *	height, width, rel y, rel x, string, 0x80,
		  *	height, width, rel y, rel x, string, 0x80,
		  *	0x00
		  *
		  * At entry:
		  *	'u' points to string parameter block.
		  *
		  * Dp must be set to D0.
		  */
		 initiate_printing:
F383   8DEE             bsr   print_1_string;  
		 printu:
F385   A6C4             lda   ,u;
F387   26FA             bne   initiate_printing;  
F389   39               rts;


		 /*
		  * printu2()
		  * 
		  * This displays the group of strings described by the
		  * parameter block which is pointed to by the 'u' register.
		  * The string parameter block has the following format:
		  *
		  *	rel y, rel x, string, 0x80,
		  *	rel y, rel x, string, 0x80,
		  *	0x00
		  *
		  * The current string height and width to which the hardware
		  * is set will be used.
		  *
		  * This routine will first print the passed-in string, and
		  * THEN check for the end of the string block.
		  *
		  * At entry:
		  *	'u' points to string parameter block.
		  *
		  * Dp must be set to D0.
		  */
		 printu2:
F38A   8DEC             bsr   print_with_dft_hw;  


		 /*
		  * printu3()
		  * 
		  * This displays the group of strings described by the
		  * parameter block which is pointed to by the 'u' register.
		  * The string parameter block has the following format:
		  *
		  *	rel y, rel x, string, 0x80,
		  *	rel y, rel x, string, 0x80,
		  *	0x00
		  *
		  * The current string height and width to which the hardware
		  * is set will be used.
		  *
		  * This routine will first check for the end of the string
		  * block, and THEN will print the string if the end of the
		  * string block was not reached.
		  *
		  * At entry:
		  *	'u' points to string parameter block.
		  *
		  * Dp must be set to D0.
		  */
		 printu3:
F38C   A6C4             lda   ,u;
F38E   26FA             bne   printu2;  
F390   39               rts;


		 /*
		  * print_b_minus_a()
		  *
		  * This routine displays one of the following strings,
		  * depending upon the passed in value in the 'b' register,
		  * using the current string height and width values:
		  *
		  *	value of 'b' "-" value of 'a'
		  *
		  * If 'b' > 9, then the infinity symbol is displayed.
		  * The 'x' register points to the (y,x) coordinates
		  * for where the string is to be displayed.
		  *
		  * At entry:
		  *	'x' points to string coordinates.
		  *	'a' contains a printable digit.
		  *	'b' contains any value.
		  *
		  * Dp must be set to D0.
		  */
		 print_b_minus_a:
F391   AE84             ldx   ,x;


		 /*
		  * print_b_minus_a2()
		  *
		  * This routine displays one of the following strings,
		  * depending upon the passed in value in the 'b' register,
		  * using the current string height and width values:
		  *
		  *	value of 'b' "-" value of 'a'
		  *
		  * If 'b' > 9, then the infinity symbol is displayed.
		  * The 'x' register contains the (y,x) coordinates
		  * for where the string is to be displayed.
		  *
		  * At entry:
		  *	'x' contains the string coordinates.
		  *	'a' contains a printable digit.
		  *	'b' contains any value.
		  *
		  * Dp must be set to D0.
		  */
		 print_b_minus_a2:
F393   3404             pshs  b; 
F395   C680             ldb   #0x80;  
F397   3378             leau  -8,s;   
F399   3606             pshu  a,b;    
F39B   3502             puls  a; 
F39D   8109             cmpa  #0x09;  
F39F   2302             bls   PF3A3;  
F3A1   863C             lda   #0x3C; /* "<" */                                
F3A3   8B30      PF3A3: adda  #0x30; /* "0" */                                
F3A5   C62D             ldb   #0x2D; /* "-" */                                
F3A7   3606             pshu  a,b;    
F3A9   3610             pshu  x; 
F3AB   20CB             bra   print_with_dft_hw;  


		 /*
		  * move_then_draw_VL_with_count1()
		  *
		  * This routine moves to the first location specified in
		  * vector list, and then draws lines between the rest of
		  * coordinates in the list.  The number of vectors to draw
		  * is specified as the first byte in the vector list.  The
		  * current scale factor is used.  The vector list must have
		  * the following format:
		  *
		  *	count, rel y, rel x, rel y, rel x, ...
		  *
		  * At entry:
		  *	'x' points to the vector list.
		  *
		  * Dp must be set to D0.
		  */
		 move_then_draw_VL_with_count1:
F3AD   A680             lda   ,x+;    
F3AF   2008             bra   move_then_draw_VL_with_count6;  


		 /*
		  * move_then_draw_VL_with_count2()
		  *
		  * This routine moves to the first location specified in
		  * vector list, and then draws lines between the rest of
		  * coordinates in the list.  The number of vectors to draw
		  * must already be specified in C823.  The scale factor to
		  * use is specified in the 'b' register.  The vector list
		  * must have the following format:
		  *
		  *	rel y, rel x, rel y, rel x, ...
		  *
		  * At entry:
		  *	'x' points to the vector list.
		  *	'b' contains the scale factor.
		  *
		  * Dp must be set to D0.
		  */
		 move_then_draw_VL_with_count2:
F3B1   D704             stb   0x04;   
F3B3   2007             bra   move_then_draw_VL_with_count5;  


		 /*
		  * move_then_draw_VL_with_count3()
		  *
		  * This routine moves to the first location specified in
		  * vector list, and then draws lines between the rest of
		  * coordinates in the list.  The number of vectors to draw
		  * is specified as the first byte in the vector list, and the
		  * scale factor is the second byte in teh vector list.  The
		  * vector list must have the following format:
		  *
		  *	count, scale, rel y, rel x, rel y, rel x, ...
		  *
		  * At entry:
		  *	'x' points to the vector list.
		  *
		  * Dp must be set to D0.
		  */
		 move_then_draw_VL_with_count3:
F3B5   EC81             ldd   ,x++;   


		 /*
		  * move_then_draw_VL_with_count4()
		  *
		  * This routine moves to the first location specified in
		  * vector list, and then draws lines between the rest of
		  * coordinates in the list.  The number of vectors to draw
		  * is specified in the 'a' register, and the scale factor is
		  * specified in the 'b' register.  The vector list must have
		  * the following format:
		  *
		  *	rel y, rel x, rel y, rel x, ...
		  *
		  * At entry:
		  *	'x' points to the vector list.
		  *	'a' contains the number of vectors to draw.
		  *	'b' contains the scale factor to use.
		  *
		  * Dp must be set to D0.
		  */
		 move_then_draw_VL_with_count4:
F3B7   D704             stb   0x04;   


		 /*
		  * move_then_draw_VL_with_count6()
		  *
		  * This routine moves to the first location specified in
		  * vector list, and then draws lines between the rest of
		  * coordinates in the list.  The number of vectors to draw
		  * is specified in the 'a' register; the current scale factor
		  * is used.  The vector list must have the following format:
		  *
		  *	rel y, rel x, rel y, rel x, ...
		  *
		  * At entry:
		  *	'x' points to the vector list.
		  *	'a' contains the number of vectors to draw.
		  *
		  * Dp must be set to D0.
		  */
		 move_then_draw_VL_with_count6:
F3B9   B7C823           sta   $C823;  


		 /*
		  * move_then_draw_VL_with_count5()
		  *
		  * This routine moves to the first location specified in
		  * vector list, and then draws lines between the rest of
		  * coordinates in the list.  The number of vectors to draw
		  * must be specified C823, and the current scale factor is
		  * used.  The vector list must have the following format:
		  *
		  *	rel y, rel x, rel y, rel x, ...
		  *
		  * At entry:
		  *	'x' points to the vector list.
		  *
		  * Dp must be set to D0.
		  */
		 move_then_draw_VL_with_count5:
F3BC   EC84             ldd   ,x;
F3BE   9701             sta   0x01;   
F3C0   0F00             clr   0x00;   
F3C2   3002             leax  2,x;    
F3C4   12               nop;
F3C5   0C00             inc   0x00;   
F3C7   D701             stb   0x01;   
F3C9   CC0000           ldd   #0x0000;   /* Set line pattern to invisible. */
F3CC   201F             bra   PF3ED;  


		 /*
		  * draw_VL_with_count4()
		  *
		  * This routine draws vectors between the set of (y,x)
		  * points pointed to by the 'x' register.  The number
		  * of vectors to draw is specified as the first byte
		  * in the vector list.  The current scale factor is used.
		  * The vector list must have the following format:
		  *
		  *	count, rel y, rel x, rel y, rel x, ...
		  *
		  * At entry:
		  *	'x' must point to the vector list.
		  *
		  * Dp must be set to D0.
		  */
		 draw_VL_with_count4:
F3CE   A680             lda   ,x+;    
F3D0   2008             bra   draw_VL_with_count5;  


		 /*
		  * draw_VL_with_count3()
		  *
		  * This routine draws vectors between the set of (y,x)
		  * points pointed to by the 'x' register.  The number
		  * of vectors to draw must already be specified in C823.
		  * The scale factor to be used must be in the 'b' register.
		  * The vector list must have the following format:
		  *
		  *	rel y, rel x, rel y, rel x, ...
		  *
		  * At entry:
		  *	'x' must point to the vector list.
		  *	'b' contains the scale factor.
		  *
		  * Dp must be set to D0.
		  */
		 draw_VL_with_count3:
F3D2   D704             stb   0x04;   
F3D4   2007             bra   draw_VL_with_count1;  


		 /*
		  * draw_VL_with_count2()
		  *
		  * This routine draws vectors between the set of (y,x)
		  * points pointed to by the 'x' register.  The number
		  * of vectors to draw is specified as the first byte
		  * in the vector list.  The scale factor is specified as
		  * the second byte in the vector list.
		  * The vector list must have the following format:
		  *
		  *	count, scale, rel y, rel x, rel y, rel x, ...
		  *
		  * At entry:
		  *	'x' must point to the vector list.
		  *
		  * Dp must be set to D0.
		  */
		 draw_VL_with_count2:
F3D6   EC81             ldd   ,x++;   


		 /*
		  * draw_VL_with_count6()
		  *
		  * This routine draws vectors between the set of (y,x)
		  * points pointed to by the 'x' register.  The number
		  * of vectors to draw is specified in the 'a' register.
		  * The scale factor is specified in the 'b' register.
		  * The vector list must have the following format:
		  *
		  *	rel y, rel x, rel y, rel x, ...
		  *
		  * At entry:
		  *	'x' must point to the vector list.
		  *	'a' must contain the number of vectors to draw.
		  *	'b' contains the scale factor to use.
		  *
		  * Dp must be set to D0.
		  */
		 draw_VL_with_count6:
F3D8   D704             stb   0x04;   


		 /*
		  * draw_VL_with_count5()
		  *
		  * This routine draws vectors between the set of (y,x)
		  * points pointed to by the 'x' register.  The number
		  * of vectors to draw is specified in the 'a' register.
		  * The current scale factor is used. 
		  * The vector list must have the following format:
		  *
		  *	rel y, rel x, rel y, rel x, ...
		  *
		  * At entry:
		  *	'x' must point to the vector list.
		  *	'a' contains the number of vectors to draw.
		  *
		  * Dp must be set to D0.
		  */
		 draw_VL_with_count5:
F3DA   B7C823           sta   $C823;  


		 /*
		  * draw_VL_with_count1()
		  *
		  * This routine draws vectors between the set of (y,x)
		  * points pointed to by the 'x' register.  The number
		  * of vectors to draw must already be specified in C823.
		  * The current scale factor is used.
		  * The vector list must have the following format:
		  *
		  *	rel y, rel x, rel y, rel x, ...
		  *
		  * At entry:
		  *	'x' must point to the vector list.
		  *
		  * Dp must be set to D0.
		  */
		 draw_VL_with_count1:
F3DD   EC84             ldd   ,x;


		 /*
		  * draw_to_d()
		  *
		  * This routine will draw a line from the current pen
		  * position, to the point specified by the (y,x) pair
		  * specified in the 'd' register.  The current scale
		  * factor is used.  Before calling this routine, you
		  * should set C823 to 0, so that only the one vector
		  * will be drawn.
		  *
		  * At entry:
		  *	'a' contains relative y position.
		  *	'b' contains relative x position.
		  *
		  * Dp must be set to D0.
		  */
		 draw_to_d:
F3DF   9701             sta   0x01;   
F3E1   0F00             clr   0x00;   
F3E3   3002             leax  2,x;    
F3E5   12               nop;
F3E6   0C00             inc   0x00;   
F3E8   D701             stb   0x01;   
F3EA   CCFF00           ldd   #0xFF00;   /* Set up a solid line pattern. */
F3ED   970A      PF3ED: sta   0x0A;   
F3EF   D705             stb   0x05;   
F3F1   CC0040           ldd   #0x0040;
F3F4   D50D      PF3F4: bitb  0x0D;   
F3F6   27FC             beq   PF3F4;  
F3F8   12               nop;
F3F9   970A             sta   0x0A;   
F3FB   B6C823           lda   $C823;  
F3FE   4A               deca;    
F3FF   2AD9             bpl   draw_VL_with_count5;  
F401   7EF34F           jmp   $check0ref; 


		 /*
		  * drawl1_scale_FF()
		  * 
		  * This routine forces the scale factor to 0xFF, and then
		  * processes the vector list pointed to by the 'x' register.
		  * The vector list must have the following format:
		  *
		  *	mode, rel y, rel x
		  * 	mode, rel y, rel x
		  *      .      .      .
		  *      .      .      .
		  *	mode, rel y, rel x
		  *	0x01
		  *
		  * where mode can mean one of the following:
		  *
		  *	< 0   draw a line to the specified point.
		  *	= 0   move to the specified point.
		  *	> 0   end of vector list
		  *
		  * At entry:
		  *	'x' must point to the vector list.
		  *
		  * Dp must be set to D0.
		  */
		 drawl1_scale_FF:
F404   C6FF             ldb   #0xFF;  
F406   2006             bra   drawl1b;  


		 /*
		  * drawl1_scale_7F()
		  * 
		  * This routine forces the scale factor to 0x7F, and then
		  * processes the vector list pointed to by the 'x' register.
		  * The vector list must have the following format:
		  *
		  *	mode, rel y, rel x
		  * 	mode, rel y, rel x
		  *      .      .      .
		  *      .      .      .
		  *	mode, rel y, rel x
		  *	0x01
		  *
		  * where mode can mean one of the following:
		  *
		  *	< 0   draw a line to the specified point.
		  *	= 0   move to the specified point.
		  *	> 0   end of vector list
		  *
		  * At entry:
		  *	'x' must point to the vector list.
		  *
		  * Dp must be set to D0.
		  */
		 drawl1_scale_7F:
F408   C67F             ldb   #0x7F;  
F40A   2002             bra   drawl1b;  


		 /*
		  * drawl1()
		  * 
		  * This routine processes the vector list pointed to by the
		  * 'x' register.  The first byte in the vector list is the
		  * scale factor.  The vector list must have the following 
		  * format:
		  *
		  *	scale factor,
		  *	mode, rel y, rel x
		  * 	mode, rel y, rel x
		  *      .      .      .
		  *      .      .      .
		  *	mode, rel y, rel x
		  *	0x01
		  *
		  * where mode can mean one of the following:
		  *
		  *	< 0   draw a line to the specified point.
		  *	= 0   move to the specified point.
		  *	> 0   end of vector list
		  *
		  * At entry:
		  *	'x' must point to the vector list.
		  *
		  * Dp must be set to D0.
		  */
		 drawl1:
F40C   E680             ldb   ,x+;    


		 /*
		  * drawl1b()
		  * 
		  * This routine processes the vector list pointed to by the
		  * 'x' register.  The scale factor to use is passed in in the	
		  * 'b' register.  The vector list must have the following 
		  * format:
		  *
		  *	mode, rel y, rel x
		  * 	mode, rel y, rel x
		  *      .      .      .
		  *      .      .      .
		  *	mode, rel y, rel x
		  *	0x01
		  *
		  * where mode can mean one of the following:
		  *
		  *	< 0   draw a line to the specified point.
		  *	= 0   move to the specified point.
		  *	> 0   end of vector list
		  *
		  * At entry:
		  *	'x' must point to the vector list.
		  *	'b' contains scale factor to use.
		  *
		  * Dp must be set to D0.
		  */
		 drawl1b:
F40E   D704             stb   0x04;   


		 /*
		  * next_pt()
		  * 
		  * This routine processes the vector list pointed to by the
		  * 'x' register.  The current scale factor is used.
		  * The vector list must have the following format:
		  *
		  *	mode, rel y, rel x
		  * 	mode, rel y, rel x
		  *      .      .      .
		  *      .      .      .
		  *	mode, rel y, rel x
		  *	0x01
		  *
		  * where mode can mean one of the following:
		  *
		  *	< 0   draw a line to the specified point.
		  *	= 0   move to the specified point.
		  *	> 0   end of vector list
		  *
		  * At entry:
		  *	'x' must point to the vector list.
		  *
		  * Dp must be set to D0.
		  */
		 next_pt:
F410   EC01             ldd   1,x;    
F412   9701             sta   0x01;   
F414   0F00             clr   0x00;   
F416   A684             lda   ,x;
F418   3003             leax  3,x;    
F41A   0C00             inc   0x00;   
F41C   D701             stb   0x01;   
F41E   970A             sta   0x0A;   
F420   0F05             clr   0x05;   
F422   CC0040           ldd   #0x0040;
F425   D50D      PF425: bitb  0x0D;   
F427   27FC             beq   PF425;  
F429   12               nop;
F42A   970A             sta   0x0A;   
F42C   A684             lda   ,x;
F42E   2FE0             ble   next_pt;  
F430   7EF34F           jmp   $check0ref; 


		 /*
		  * dwp_with_count()
		  * draw_with_pattern()
		  *
		  * Both of these routines draw a series of patterned
		  * vectors.  The pattern to use must already be specified
		  * in C829.  When using draw_with_pattern(), the number
		  * of vectors to draw (minus 1) must be specified in C823;
		  * when using dwp_with_count(), the number of vectors to
		  * draw (minus 1) must be passed in in the 'a' register.
		  * The vector list, pointed to by the 'x' register, must
		  * have the following format:
		  *
		  *	rel y, rel x, rel y, rel x, ...
		  *
		  * At entry:
		  *	'x' points to the vector list.
		  *	'a' specifies number of vectors (dwp_with_count() only).
		  *
		  * Dp must be set to D0.
		  */
		 dwp_loop:
F433   4A               deca;    
		 dwp_with_count:
F434   B7C823           sta   $C823;  
		 draw_with_pattern:
F437   EC84             ldd   ,x;
F439   9701             sta   0x01;   
F43B   0F00             clr   0x00;   
F43D   3002             leax  2,x;    
F43F   0C00             inc   0x00;   
F441   D701             stb   0x01;   
F443   B6C829           lda   $C829;  
F446   C640             ldb   #0x40;
F448   970A             sta   0x0A;   
F44A   0F05             clr   0x05;   
F44C   F5D00D           bitb  $D00D;  
F44F   270B             beq   PF45C;  
F451   0F0A             clr   0x0A;   
F453   B6C823           lda   $C823;  
F456   26DB             bne   dwp_loop;  
F458   39               rts;
F459   B6C829    PF459: lda   $C829;  
F45C   970A      PF45C: sta   0x0A;   
F45E   12               nop;
F45F   D50D             bitb  0x0D;   
F461   27F6             beq   PF459;  
F463   B6C823           lda   $C823;  
F466   0F0A             clr   0x0A;   
F468   4D               tsta;    
F469   26C8             bne   dwp_loop;  
F46B   7EF34F           jmp   $check0ref; 


		 /*
		  * drawl2()
		  *
		  * This routine processes the vector list pointed to by
		  * the 'x' register.  The current scale factor is used.
		  * The vector list must have the following format:
		  *
		  *	mode, rel y, rel x,
		  *	mode, rel y, rel x,
		  *      .      .      .
		  *      .      .      .
		  * 	mode, rel y, rel x,
		  *	0x01
		  *
		  * where mode has the following meaning:
		  *
		  *	< 0  use the pattern in C829.
		  *	= 0  move to specified endpoint.
		  *	= 1  end of list, so return.
		  *	> 1  draw to specified endpoint.
		  *
		  * At entry:
		  *	'x' points to the vector list.
		  *	C829 may need to be set up with a line pattern.
		  *
		  * Dp must be set to D0.
		  */
		 drawl2:
F46E   B6C824           lda   $C824;  
F471   3402             pshs  a; 
F473   7FC824           clr   $C824;  
F476   A680      PF476: lda   ,x+;    
F478   2A04             bpl   PF47E;  
F47A   8DBB             bsr   draw_with_pattern;  
F47C   20F8             bra   PF476;  
F47E   2605      PF47E: bne   PF485;  
F480   BDF3BC           jsr   $move_then_draw_VL_with_count5; 
F483   20F1             bra   PF476;  
F485   4A        PF485: deca;    
F486   2705             beq   PF48D;  
F488   BDF3DD           jsr   $draw_VL_with_count1; 
F48B   20E9             bra   PF476;  
F48D   3502      PF48D: puls  a; 
F48F   B7C824           sta   $C824;  
F492   7EF34F           jmp   $check0ref; 


		 /*
		  * display_string()
		  *
		  * This is the routine which does the actual printing of a
		  * string.  The 'u' register points to the start of the
		  * string, while C82A contains the height of the character,
		  * cell, and C82B contains the width of the character cell.
		  * The end of the string must be terminated with a 0x80.
		  *
		  * The string is displayed by drawing 6 horizontal rows of
		  * dots.  The first row is drawn for each character, then
		  * the second, etc.  The character generation table is
		  * located at (0xF9D4 + 0x20).  Only characters 0x20-0x6F
		  * (upper case) are defined; the lower case character a-o
		  * produce special icons.
		  *
		  * At entry:
		  *	'u' points to the start of the string.
		  *	C82A contains character cell height.
		  *	C82B contains character cell width.
		  */
		 display_string:
F495   FFC82C           stu   $C82C;     /* Save pointer to start of string. */
F498   8EF9D4           ldx   #0xF9D4;
F49B   CC1883           ldd   #0x1883;
F49E   0F01             clr   0x01;   
F4A0   970B             sta   0x0B;   
F4A2   8EF9D4           ldx   #0xF9D4;
F4A5   D700      PF4A5: stb   0x00;   
F4A7   0A00             dec   0x00;   
F4A9   CC8081           ldd   #0x8081;
F4AC   12               nop;
F4AD   0C00             inc   0x00;   
F4AF   D700             stb   0x00;   
F4B1   9700             sta   0x00;   
F4B3   7DC800           tst   $C800;  
F4B6   0C00             inc   0x00;   
F4B8   B6C82B           lda   $C82B;    /* Get the string width. */
F4BB   9701             sta   0x01;   
F4BD   CC0100           ldd   #0x0100;
F4C0   FEC82C           ldu   $C82C;  
F4C3   9700             sta   0x00;   
F4C5   2004             bra   PF4CB;  
F4C7   A686      PF4C7: lda   a,x;    
F4C9   970A             sta   0x0A;   
F4CB   A6C0      PF4CB: lda   ,u+;    
F4CD   2AF8             bpl   PF4C7;    /* Display next row of pixels. */
F4CF   8681             lda   #0x81;  
F4D1   9700             sta   0x00;   
F4D3   0001             neg   0x01;   
F4D5   8601             lda   #0x01;  
F4D7   9700             sta   0x00;   
F4D9   8CFBB4           cmpx  #0xFBB4;  /* If not at end of char table, then */
F4DC   272C             beq   PF50A;    /* proceed to next row of pixels.    */
F4DE   308850           leax  0x50,x; 
F4E1   1F30             tfr   u,d;    
F4E3   B3C82C           subd  $C82C;    /* Point back to first character. */
F4E6   C002             subb  #0x02;  
F4E8   58               aslb;    
F4E9   2100             brn   PF4EB;  
F4EB   8681      PF4EB: lda   #0x81;  
F4ED   12               nop;
F4EE   5A               decb;    
F4EF   26FA             bne   PF4EB;  
F4F1   9700             sta   0x00;   
F4F3   F6C82A           ldb   $C82A;  
F4F6   D701             stb   0x01;   
F4F8   0A00             dec   0x00;   
F4FA   CC8101           ldd   #0x8101;
F4FD   12               nop;
F4FE   9700             sta   0x00;   
F500   0F01             clr   0x01;   
F502   D700             stb   0x00;   
F504   9700             sta   0x00;   
F506   C603             ldb   #0x03;  
F508   209B             bra   PF4A5;  
F50A   8698      PF50A: lda   #0x98;  
F50C   970B             sta   0x0B;   
F50E   7EF354           jmp   $reset0ref; 


		 /*
		  * get_random_a2()
		  *
		  * This routine generates a random 1-byte number, and places
		  * it in the 'a' register.  This uses a seed of 2 for the
		  * random number generator.
		  *
		  * At exit:
		  *	'a' contains the generated random number.
		  */
		 get_random_a2:
F511   3414             pshs  b,x;    
F513   C602             ldb   #0x02;  
F515   2003             bra   ran_start;  


		 /*
		  * get_random_a()
		  *
		  * This routine generates a random 1-byte number, and places
		  * it in the 'a' register.  This uses a seed of 0 for the
		  * random number generator.
		  *
		  * At exit:
		  *	'a' contains the generated random number.
		  */
		 get_random_a:
F517   3414             pshs  b,x;    
F519   5F               clrb;    
		 ran_start:
F51A   BEC87B           ldx   $C87B;  
		 ran_loop:
F51D   A601             lda   1,x;    
F51F   49               rola;    
F520   49               rola;    
F521   49               rola;    
F522   49               rola;    
F523   A802             eora  2,x;    
F525   46               rora;    
F526   6984             rol   ,x;
F528   6901             rol   1,x;    
F52A   6902             rol   2,x;    
F52C   5A               decb;    
F52D   2AEE             bpl   ran_loop;  
F52F   A684             lda   ,x;
F531   3594             puls  b,x,pc; 


		 /*
		  * init_music_buf()
		  *
		  * This routine clears out the music work buffer, located
		  * at C83F-C84C.
		  *
		  */
		 init_music_buf:
F533   C60D             ldb   #0x0D;  
F535   8EC83F           ldx   #0xC83F;
F538   8D05             bsr   clear_blockxb;  
F53A   863F             lda   #0x3F;
F53C   A706             sta   6,x;    
F53E   39               rts;


		 /*
		  * clear_blockxb()
		  *
		  * This routine clears to 0 the block of memory starting
		  * at the address contained in the 'x' register, and 
		  * continuing for the number of bytes specified by 'b'+1.
		  *
		  * At entry:
		  *	'x' points to the start of the RAM to be cleared.
		  *	'b' specifies number of bytes (minus 1) to clear.
		  */
		 clear_blockxb:
F53F   4F               clra;    
F540   2006             bra   clear_block;  


		 /*
		  * clear_C8_ram()
		  *
		  * This routine clears to 0 the block of memory in the
		  * range C800-C8FF.
		  */
		 clear_C8_ram:
F542   8EC800           ldx   #0xC800;


		 /*
		  * clear_256_bytes()
		  *
		  * This routine clears to 0 the 256 byte block of memory
		  * starting at the address contained in the 'x' register.
		  *
		  * At entry:
		  *	'x' points to the start of the RAM to be cleared.
		  */
		 clear_256_bytes:
F545   CC00FF           ldd   #0x00FF;
		 clear_block:
F548   6F8B             clr   d,x;    
F54A   830001           subd  #0x0001;
F54D   2AF9             bpl   clear_block;  
F54F   39               rts;

	
		 /*
		  * clear_block_to_0x80()
		  *
		  * This routine xsets to 0x80 the block of memory pointed to by
		  * the 'x' register.  The 'b' register specifies the number of
		  * bytes (minus 1) to be modified.
		  *
		  * At entry:
		  *	'x' specifies the start of the memory block.
		  *	'b' specifies the number of bytes (minus 1) to modify.
		  */
		 clear_block_to_0x80:
F550   8680             lda   #0x80;  


		 /*
		  * clear_block_to_a()
		  *
		  * This routine sets to the value specified in the 'a'
		  * register, the block of memory pointed to by the 'x'
		  * register.  The 'b' register specifies the number of
		  * bytes (minus 1) to be modified.
		  *
		  * At entry:
		  *	'x' specifies the start of the memory block.
		  *	'b' specifies the number of bytes (minus 1) to modify.
		  *	'a' specifies value to be written to the memory block.
		  */
		 clear_block_to_a:
F552   A785             sta   b,x;    
F554   5A               decb;    
F555   26FB             bne   clear_block_to_a;  
F557   A784             sta   ,x;
F559   39               rts;


		 /*
		  * decrement_counters_C82E_C830()
		  *
		  * This routine checks each of the 3 counters, and
		  * decrements those which are not already zero.
		  */
		 decrement_counters_C82E_C830:
F55A   C602             ldb   #0x02;  
F55C   2002             bra   PF560;  


		 /*
		  * decrement_counters_C82E_C833()
		  *
		  * This routine checks each of the 6 counters, and
		  * decrements those which are not already zero.
		  */
		 decrement_counters_C82E_C833:
F55E   C605             ldb   #0x05;  
F560   8EC82E    PF560: ldx   #0xC82E;
F563   6D85      PF563: tst   b,x;    
F565   2702             beq   PF569;  
F567   6A85             dec   b,x;    
F569   5A        PF569: decb;    
F56A   2AF7             bpl   PF563;  
F56C   39               rts;


		 /*
		  * delay_b_3()
		  * delay_b_2()
		  * delay_b_1()
		  * delay_b_0()
		  *
		  * Each of these routines loads the 'b' register with
		  * the indicated value, and then loops until the 'b'
		  * register value has decremented below zero.
		  */
		 delay_b_3:
F56D   C603             ldb   #0x03;  
F56F   2009             bra   start_b_delay;  
		 delay_b_2:
F571   C602             ldb   #0x02;  
F573   2005             bra   start_b_delay;  
		 delay_b_1:
F575   C601             ldb   #0x01;  
F577   2001             bra   start_b_delay;  
		 delay_b_0:
F579   5F               clrb;    
		 start_b_delay:
F57A   5A               decb;    
F57B   2AFD             bpl   start_b_delay;  
F57D   39               rts;


		 /*
		  * get_bit_mask()
		  *
		  * This routine takes a bit number, specified in the 'a'
		  * register, and returns a bit mask with only the specified
		  * bit set.  This is shown in the table below:
		  *
		  *	Entry		Exit
		  *     -----           -----
		  *	  0              0x01
		  *	  1              0x02
		  *	 etc             etc
		  *
		  * At entry:
		  *	'a' contains the bit number.
		  *
		  * At exit:
		  *	'a' contains the bit mask.
		  */
		 get_bit_mask:
F57E   8EF9DC           ldx   #bit_masks;
F581   A686             lda   a,x;    
F583   39               rts;


		 /*
		  * get_absolute_value_of_ab()
		  *
		  * This routine returns the absolute value of the two
		  * single byte numbers passed in in the 'a' and 'b' register.
		  * There is a special case: 0x80 is returned as 0x7F.
		  *
		  * At entry:
		  *	'a' contains value 1.
		  *	'b' contains value 2.
		  *
		  * At exit:
		  *	'a' contains absolute value of value 1.
		  *	'b' contains absolute value of value 2.
		  */
		 get_absolute_value_of_ab:
F584   4D               tsta;    
F585   2A04             bpl   PF58B;  
F587   40               nega;    
F588   2801             bvc   PF58B;  
F58A   4A               deca;    
F58B   5D        PF58B: tstb;    
F58C   2A04             bpl   PF592;  
F58E   50               negb;    
F58F   2801             bvc   PF592;  
F591   5A               decb;    
F592   39        PF592: rts;


		 /*
		  * convert_rise_run_to_angle()
		  *
		  * Given a (rise,run) pair, this routine calculates the 
		  * angle which corresponds to that (rise,run) pair.  The
		  * returned angle is relative to the x-axis (+ is CCW), so
		  * to convert it to a Vectrex angle (relative to the y-axis,
		  * + is CCW), you must subtract the number 0x10 (90 degrees)
		  * from the returned value.
		  *
		  * At entry:
		  *	'a' contains the rise value.
		  *	'b' contains the run value.
		  *
		  * At exit:
		  * 	'a' contains the angle from the x-axis.
		  *	'b' contains the angle from the x-axis.
		  *
		  * Dp must be set to C8.
		  */
		 convert_rise_run_to_angle:
F593   3410             pshs  x; 
F595   DD34             std   0x34;   
F597   59               rolb;    
F598   C600             ldb   #0x00;  
F59A   59               rolb;    
F59B   49               rola;    
F59C   59               rolb;    
F59D   58               aslb;    
F59E   D736             stb   0x36;   
F5A0   DC34             ldd   0x34;   
F5A2   8DE0             bsr   get_absolute_value_of_ab;  
F5A4   9734             sta   0x34;   
F5A6   D134             cmpb  0x34;   
F5A8   2308             bls   PF5B2;  
F5AA   0C36             inc   0x36;   
F5AC   1E89             exg   a,b;    
F5AE   2002             bra   PF5B2;  
F5B0   44        PF5B0: lsra;    
F5B1   54               lsrb;    
F5B2   8109      PF5B2: cmpa  #0x09;  
F5B4   22FA             bhi   PF5B0;  
F5B6   DD34             std   0x34;   
F5B8   D636             ldb   0x36;   
F5BA   8EFC24           ldx   #angle_data1;
F5BD   E685             ldb   b,x;    
F5BF   8EFC2C           ldx   #angle_data2;
F5C2   A686             lda   a,x;    
F5C4   9B35             adda  0x35;   
F5C6   8B0A             adda  #0x0A;  
F5C8   C501             bitb  #0x01;  
F5CA   2604             bne   PF5D0;  
F5CC   EB86             addb  a,x;    
F5CE   2003             bra   PF5D3;  
F5D0   5A        PF5D0: decb;    
F5D1   E086             subb  a,x;    
F5D3   D736      PF5D3: stb   0x36;   
F5D5   9636             lda   0x36;   
F5D7   3590             puls  x,pc;   


		 /*
		  * get_2nd_index_pair()
		  * get_1st_index_pair()
		  *
		  * These routines are responsible for generating the
		  * two index pairs which are required by the rest of
		  * the rotation routines.  Each index pair is two bytes
		  * long, and has the following format:
		  *
		  *	The high byte is obtained by masking the angle
		  *	with 0x1F (this forces the angle to be between
		  *	0 and 180 degrees), and then using this value to
		  *	index into the multiplier table.
		  *
		  *	The lower byte contains information about whether
		  *	the angle lies along either the x or y axis, and
		  *	whether the rise/run will be positive or negative.
		  *
		  *		0 => positive rise, not on an axis, or
		  *		     negative run, not on an axis.
		  *	     0x80 => negative rise, not on an axis, or
		  *	             positive run, not on an axis.
		  *          0x81 => negative rise, on an axis, or
		  *		     positive run, on an axis.
		  *		1 => positive rise, on an axis, or
		  *		     negative run, on an axis.
		  *
		  * get_1st_index_pair() returns the value for the run.
		  * get_2nd_index_pair() returns the value for the rise.
		  *
		  * At entry:
		  *	'a' must contain the angle value.
		  */
		 get_2nd_index_pair:
F5D9   8B10             adda  #0x10;  
		 get_1st_index_pair:
F5DB   8EFC6D           ldx   #rotation_pair_table;
F5DE   5F               clrb;    
F5DF   8520             bita  #0x20;  
F5E1   2702             beq   PF5E5;  
F5E3   C680             ldb   #0x80;  
F5E5   841F      PF5E5: anda  #0x1F;  
F5E7   8110             cmpa  #0x10;  
F5E9   2601             bne   PF5EC;  
F5EB   5C               incb;    
F5EC   A686      PF5EC: lda   a,x;    
F5EE   39               rts;


		 /*
		  * get_rotation_index_pairs()
		  *
		  * This routine gets the index pair for both the
		  * rise and run, using the passed-in angle value.
		  *
		  * At entry:
		  *	C836 must contain the angle value.
		  *
		  * At exit:
		  *	C837-C838 contains the index pair for the run.
		  *	C839-C83A contains the index pair for the rise.
		  *
		  * Dp must be set to C8.
		  */
		 get_rotation_index_pairs:
F5EF   3410             pshs  x; 
F5F1   9636             lda   0x36;   
F5F3   8DE6             bsr   get_1st_index_pair;  
F5F5   DD37             std   0x37;   
F5F7   9636             lda   0x36;   
F5F9   8DDE             bsr   get_2nd_index_pair;  
F5FB   DD39             std   0x39;   
F5FD   3590             puls  x,pc;   


		 /*
		  * convert_abs_angle_to_rise_run()
		  *
		  * This routine takes an angle value which is relative to
		  * the x-axis, converts it to an angle relative to the
		  * y-axis (by subtracting 0x10 [90 degrees] from the value),
		  * and then calculates the rise and run for that angle.
		  *
		  * At entry:
		  *	'b' contains the absolute angle value.
		  *	'a' contains the scalar velocity value.
		  *
		  * At exit:
		  *	'a' contains the rise value.
		  *	'b' contains the run value.
		  *
		  * Dp must be set to C8.
		  */
		 convert_abs_angle_to_rise_run:
F5FF   C010             subb  #0x10;  


		 /*
		  * convert_angle_to_rise_run()
		  *
		  * This routine takes an angle value which is relative to
		  * the y-axis, and calculates the rise and run for that angle,
		  * relative to a passed-in scalar velocity value.  A large
		  * scalar value will cause an object to move quickly, while
		  * a small scalar value will cause an object to move more
		  * slowly.
		  *
		  * Keep in mind that most games store x & y coordinates as
		  * 2 bytes each, with the upper byte being the actual
		  * coordinate, and the lower byte being that which is
		  * usually added to the rise/run value; when the lower
		  * byte overflows into the hi byte, then the object will
		  * 'move'.  The rise/run values returned here are meant
		  * to be added to the low byte -- NOT the hi byte!!
		  *
		  * At entry:
		  *	'b' contains the Vectrex angle value.
		  *	'a' contains the scalar velocity value.
		  *
		  * At exit:
		  *	'a' contains the rise value.
		  *	'b' contains the run value.
		  *
		  * Dp must be set to C8.
		  */
		 convert_angle_to_rise_run:
F601   D736             stb   0x36;   
F603   973B             sta   0x3B;   
F605   8DE8             bsr   get_rotation_index_pairs;  
F607   8D54             bsr   xform_a1;  
F609   40               nega;    
F60A   3402             pshs  a; 
F60C   8D55             bsr   xform_2a;  
F60E   3584             puls  b,pc;   


		 /*
		  * rotate_vector_list2()
		  *
		  * This routine rotates a vector list of length 'n+1', where
		  * 'n' is specified by the value in the 'b' register.  The
		  * 'a' register contains the rotation value, and the 'x'
		  * contains a pointer to the vector list.  The 'u' register
		  * contains a pointer to a buffer into which the transformed
		  * points are to be saved.  The vector list must have the
		  * following format:
		  *
		  *	rel y, rel x, rel y, rel x, ...
		  *
		  * At entry:
		  *	'x' points to vector list.
		  *	'u' points to buffer to hold transformed points.
		  *	'a' contains the rotation angle value.
		  *	'b' contains the number of points (minus 1).
		  */
		 rotate_vector_list2:
F610   B7C836           sta   $C836;  
F613   F7C823           stb   $C823;  
F616   3408             pshs  dp;
F618   BDF1AF           jsr   $dptoC8; 
F61B   8DD2             bsr   get_rotation_index_pairs;  
F61D   2018             bra   transform_next_point;  


		 /*
		  * rotate_vector_list1()
		  *
		  * This routine is responsible for rotation a vector list
		  * having the following format:
		  *
		  *	mode, rel y, rel x,
		  *	mode, rel y, rel x,
		  *	  .     .      .
		  *	  .	.      .
		  *	mode, rel y, rel x,
		  *	0x01
		  *
		  * The 'a' register contains the rotation value, and the 'x'
		  * contains a pointer to the vector list.  The 'u' register
		  * contains a pointer to a buffer into which the transformed
		  * points are to be saved.  
		  *
		  * At entry:
		  *	'x' points to vector list.
		  *	'u' points to buffer to hold transformed points.
		  *	'a' contains the rotation angle value.
		  */
		 rotate_vector_list1:
F61F   B7C836           sta   $C836;  
F622   3408             pshs  dp;
F624   BDF1AF           jsr   $dptoC8; 
F627   9723             sta   0x23;   
F629   8DC4             bsr   get_rotation_index_pairs;  
		 rotate_vl1_loop:
F62B   A680             lda   ,x+;      /* Copy the mode byte. */
F62D   A7C0             sta   ,u+;    
F62F   2F06             ble   transform_next_point;  
F631   0F23             clr   0x23;   
F633   3588             puls  dp,pc;  


		 /*
		  * transform_next_point()
		  *
		  * This routine does the actual transformation of the
		  * endpoint pointed to by the 'x' register.  After the
		  * point has been transformed, and save in the buffer
		  * pointed to by the 'u' register, a check will be made
		  * to see if there are any more endpoints left.  If C823
		  * is 0, then we are done; if C823 > 0, then we were called
		  * by rotate_vector_list2(), so we should transform the
		  * next point; however, if C823 < 0, then we were called
		  * by rotate_vector_list1(), and so we should return control
		  * to that procedure, so that it can look at the mode for
		  * the next endpoint, and thus decide whether to continue
		  * or stop.
		  *
		  * At entry:
		  *	C823 indicates both endpoint count & who called us.
		  *	'x' points to next set of endpoints.
		  *	'u' points to transformation buffer.
		  */
		 decrement_vl_counter:
F635   0A23             dec   0x23;   
		 transform_next_point:
F637   A680             lda   ,x+;      /* Get the y coordinate. */
F639   8D26             bsr   xform_2;  
F63B   A7C4             sta   ,u;
F63D   A684             lda   ,x;       /* Get the x coordinate. */
F63F   8D1A             bsr   xform_1;  
F641   ABC4             adda  ,u;
F643   A7C0             sta   ,u+;      /* Save transformed y coordinate. */
F645   A61F             lda   -1,x;     /* Get the y coordinate. */
F647   8D12             bsr   xform_1;  
F649   A7C4             sta   ,u;
F64B   A680             lda   ,x+;      /* Get the x coordinate. */
F64D   8D12             bsr   xform_2;  
F64F   A0C4             suba  ,u;
F651   A7C0             sta   ,u+;      /* Save transformed x coordinate. */
F653   9623             lda   0x23;   
F655   2BD4             bmi   rotate_vl1_loop;  
F657   26DC             bne   decrement_vl_counter;  
F659   3588             puls  dp,pc;  


		 /*
		  * xform_1()
		  * xform_1a()
		  *
		  * These two routines generate a rise/run value, using
		  * the index pair in C837-C838.  For xform_1() the scalar
		  * value is passed-in in the 'a' register, while for
		  * xform_1a(), the scalar value must already be in C83B.
		  * The transformed value is return in the 'a' register.
		  *
		  * Dp must be set to C8.
		  */
		 xform_1:
F65B   973B             sta   0x3B;   
		 xform_1a:
F65D   DC37             ldd   0x37;   
F65F   2004             bra   PF665;  


		 /*
		  * xform_2()
		  * xform_2a()
		  *
		  * These two routines generate a rise/run value, using
		  * the index pair in C839-C83A.  For xform_2() the scalar
		  * value is passed-in in the 'a' register, while for
		  * xform_2a(), the scalar value must already be in C83B.
		  * The transformed value is return in the 'a' register.
		  *
		  * Dp must be set to C8.
		  */
		 xform_2:
F661   973B             sta   0x3B;   
		 xform_2a:
F663   DC39             ldd   0x39;   
F665   D73C      PF665: stb   0x3C;   
F667   C501             bitb  #0x01;  
F669   2704             beq   PF66F;  
F66B   963B             lda   0x3B;   
F66D   200A             bra   PF679;  
F66F   D63B      PF66F: ldb   0x3B;   
F671   2A03             bpl   PF676;  
F673   033C             com   0x3C;   
F675   50               negb;    
F676   3D        PF676: mul;
F677   8900             adca  #0x00;  
F679   D63C      PF679: ldb   0x3C;   
F67B   2A01             bpl   PF67E;  
F67D   40               nega;    
F67E   39        PF67E: rts;


		 /*
		  * move_block()
		  *
		  * This routine copies a block of memory, starting at the
		  * hi address, and working down to the low address.  The
		  * base of the source address is specified in the 'u'
		  * register, and the base of the destination address is
		  * specified in the 'x' register.  The 'a' register contains
		  *  the number of bytes to copy (minus 1); 0x80 is the
		  * maximum value which can be specified.
		  *
		  * At entry:
		  *	'u' points to the source base.
		  *	'x' points to the destination base.
		  *	'a' contains the byte count (minus 1).
		  */
		 move_block:
F67F   E6C6             ldb   a,u;    
F681   E786             stb   a,x;    


		 /*
		  * move_block2()
		  *
		  * This routine copies a block of memory, starting at the
		  * hi address, and working down to the low address.  The
		  * base of the source address is specified in the 'u'
		  * register, and the base of the destination address is
		  * specified in the 'x' register.  The 'a' register contains
		  * the number of bytes to copy; 0x80 is the
		  * maximum value which can be specified.
		  *
		  * At entry:
		  *	'u' points to the source base.
		  *	'x' points to the destination base.
		  *	'a' contains the byte count.
		  */
		 move_block2:
F683   4A               deca;    
F684   2AF9             bpl   move_block;  
F686   39        PF686: rts;


		 /*
		  * init_sound()
		  * init_sound2()
		  *
		  * These routines are responsible for filling the music work
		  * buffer while a sound is being made.  It should be called
		  * once during each refresh cycle.  If you want to start a
		  * new sound, then you must set C856 to 0x01, and point the
		  * 'u' register to the sound block.  If no sound is in 
		  * progress (C856 = 0), then it returns immediately (unless
		  * you called init_sound2(), which does not make this check).
		  * When a sound is in progress, C856 will be set to 0x80.
		  *
		  * These routines process a single note at a time, and
		  * calculate the amplitude and course/fine tuning values for
		  * the 3 sound channels.  The values calculated stored in
		  * the music work buffer, at C83F-C84C.
		  *
		  * At entry:
		  *	C856 may need to be set.
		  *	'u' should point to the start of a music block.
		  *
		  * Dp must be set to C8.
		  */
		 init_sound:
F687   9656             lda   0x56;   
F689   2B28             bmi   continue_sound;  
F68B   27F9             beq   PF686;  
		 init_sound2:
F68D   8EFC8D           ldx   #music_routine_data;
F690   9F4D             stx   0x4D;   
F692   8680             lda   #0x80;  
F694   9756             sta   0x56;   
F696   ECC1             ldd   ,u++;   
F698   DD4F             std   0x4F;   
F69A   ECC1             ldd   ,u++;   
F69C   DD51             std   0x51;   
F69E   DF53             stu   0x53;   
F6A0   BDF533           jsr   $init_music_buf; 
F6A3   CC1F1F           ldd   #0x1F1F;
F6A6   DD5F             std   0x5F;   
F6A8   CC0000           ldd   #0x0000;
F6AB   DD63             std   0x63;   
F6AD   DD65             std   0x65;   
F6AF   9755             sta   0x55;   
F6B1   2039             bra   PF6EC;  
		 continue_sound:
F6B3   CEC85E           ldu   #0xC85E;
F6B6   C602             ldb   #0x02;  
F6B8   A6C5      PF6B8: lda   b,u;    
F6BA   811F             cmpa  #0x1F;  
F6BC   2702             beq   PF6C0;  
F6BE   6CC5             inc   b,u;    
F6C0   5A        PF6C0: decb;    
F6C1   2AF5             bpl   PF6B8;  
F6C3   9E51             ldx   0x51;   
F6C5   CEC858           ldu   #0xC858;
F6C8   8607             lda   #0x07;  
F6CA   6CC4      PF6CA: inc   ,u;
F6CC   A1C4             cmpa  ,u;
F6CE   2C02             bge   PF6D2;  
F6D0   6FC4             clr   ,u;
F6D2   E6C0      PF6D2: ldb   ,u+;    
F6D4   C407             andb  #0x07;  
F6D6   E685             ldb   b,x;    
F6D8   E7C0             stb   ,u+;    
F6DA   4C               inca;    
F6DB   8109             cmpa  #0x09;  
F6DD   23EB             bls   PF6CA;  
F6DF   0A57             dec   0x57;   
F6E1   266B             bne   PF74E;  
F6E3   9655      PF6E3: lda   0x55;     /* This is changing octaves, or */
F6E5   4A               deca;           /* something like that.         */
F6E6   2A02             bpl   PF6EA;  
F6E8   8602             lda   #0x02;  
F6EA   9755      PF6EA: sta   0x55;   
F6EC   E69FC853  PF6EC: ldb   [0xC853]; /* Grab the music note. */
F6F0   CEC85E           ldu   #0xC85E;
F6F3   6FC6             clr   a,u;    
F6F5   C540             bitb  #0x40; /* "@" */                                
F6F7   2719             beq   PF712;  
F6F9   8EF9E4           ldx   #music_stuff1;
F6FC   A686             lda   a,x;    
F6FE   9445             anda  0x45;   
F700   9745             sta   0x45;   
F702   9655             lda   0x55;   
F704   8B03             adda  #0x03;  
F706   A686             lda   a,x;    
F708   9A45             ora   0x45;   
F70A   9745             sta   0x45;   
F70C   C41F             andb  #0x1F;  
F70E   D746             stb   0x46;   
F710   2023             bra   PF735;  
F712   8EF9EA    PF712: ldx   #music_stuff2;
F715   A686             lda   a,x;    
F717   9445             anda  0x45;   
F719   9745             sta   0x45;   
F71B   9655             lda   0x55;   
F71D   8B03             adda  #0x03;  
F71F   A686             lda   a,x;    
F721   9A45             ora   0x45;   
F723   9745             sta   0x45;   
F725   9655             lda   0x55;   
F727   48               asla;    
F728   8B03             adda  #0x03;  
F72A   33C6             leau  a,u;    
F72C   C43F             andb  #0x3F; /* "?" */                                
F72E   58               aslb;    
F72F   9E4D             ldx   0x4D;   
F731   EC85             ldd   b,x;    
F733   EDC4             std   ,u;
F735   9E53      PF735: ldx   0x53;   
F737   E680             ldb   ,x+;    
F739   9F53             stx   0x53;   
F73B   5D               tstb;    
F73C   2BA5             bmi   PF6E3;  
F73E   E680             ldb   ,x+;    
F740   2A06             bpl   PF748;  
F742   BDF533           jsr   $init_music_buf; 
F745   0F56             clr   0x56;   
F747   39               rts;
F748   9F53      PF748: stx   0x53;   
F74A   C43F             andb  #0x3F; /* "?" */                                
F74C   D757             stb   0x57;   
F74E   109E4F    PF74E: ldy   0x4F;   
F751   CEC85E           ldu   #0xC85E;
F754   8EC842           ldx   #0xC842;
F757   8602             lda   #0x02;  
F759   E6C0      PF759: ldb   ,u+;    
F75B   C501             bitb  #0x01;  
F75D   2707             beq   PF766;  
F75F   54               lsrb;    
F760   E6A5             ldb   b,y;    
F762   C40F             andb  #0x0F;  
F764   2007             bra   PF76D;  
F766   54        PF766: lsrb;    
F767   E6A5             ldb   b,y;    
F769   54               lsrb;    
F76A   54               lsrb;    
F76B   54               lsrb;    
F76C   54               lsrb;    
F76D   E786      PF76D: stb   a,x;    
F76F   4A               deca;    
F770   2AE7             bpl   PF759;  
F772   CEC867           ldu   #0xC867;
F775   8EC847           ldx   #0xC847;
F778   ECC3      PF778: ldd   ,--u;   
F77A   6D58             tst   -8,u;   
F77C   2A0A             bpl   PF788;  
F77E   6058             neg   -8,u;   
F780   E058             subb  -8,u;   
F782   8200             sbca  #0x00;  
F784   6058             neg   -8,u;   
F786   2004             bra   PF78C;  
F788   EB58      PF788: addb  -8,u;   
F78A   8900             adca  #0x00;  
F78C   ED81      PF78C: std   ,x++;   
F78E   8CC84D           cmpx  #0xC84D;
F791   26E5             bne   PF778;    /* Temporarily stop when the work */
F793   39        PF793: rts;            /* buffer has been filled.        */


		 player_string:
F794   20               .byte 0x20; /* rel y for player number */
F795   C0               .byte 0xC0; /* rel x for player number  */
F796   40               .byte 0x40; /* rel y for player string  */
F797   C0               .byte 0xC0; /* rel x for player string  */
F798   50               .byte "PLAYER",0x80;

		 game_string:
F79F   E0               .byte 0xE0; /* rel y for game number */
F7A0   C0               .byte 0xC0; /* rel x for game number  */
F7A1   01               .byte 0x01; /* rel y for game string  */
F7A2   C0               .byte 0xC0; /* rel x for game string  */
F7A3   20               .byte " GAME",0x80;


		 /*
		  * get_players_game()
		  *
		  * This routine provides a game with the means for allowing
		  * the player to choose the game number he would like to 
		  * play, and the number of players.  The game indicates
		  * the number of game versions available, by placing the
		  * value in the 'b' register.  The number of players allowed
		  * is specified in the 'a' register.  If a parameter is
		  * passed in with a value of 0, then the corresponding
		  * question will not be asked.  The number of players
		  * selected is returned in C879, while the game number
		  * selected is returned in C87A.
		  *
		  * At entry:
		  *	'a' indicates maximum number of players allowed.
		  *	'b' indicates the number of game versions available.
		  *
		  * At exit:
		  *	C879 contains number of players selected.
		  *	C87A contains the game version selected.
		  *
		  * Dp must be set to C8.
		  */
		 get_players_game:
F7A9   FDC84F           std   $C84F;  
F7AC   4D               tsta;    
F7AD   2702             beq   PF7B1;  
F7AF   8601             lda   #0x01;  
F7B1   5D        PF7B1: tstb;    
F7B2   2702             beq   PF7B6;  
F7B4   C601             ldb   #0x01;  
F7B6   FDC879    PF7B6: std   $C879;  
F7B9   BDF1AF           jsr   $dptoC8; 
F7BC   CCF850           ldd   #0xF850;
F7BF   DD2A             std   0x2A;   
F7C1   973C             sta   0x3C;   
F7C3   2067             bra   handle_buttons;  


		 /*
		  * handle_buttons()
		  *
		  * This routine performs most of the work involved in
		  * allowing the player to select a game version and the
		  * number of players.  It displays the game # and player
		  * options, and allows the player a certain amount of time
		  * to modify their values.  Anytime one of the buttons is
		  * to modify a value, the timer will be restarted.  When
		  * a button is pressed, the associated value is modified,
		  * and then redisplayed on the screen.  This routine will
		  * return when either the timer expires, or button 4 is
		  * pressed.
		  *
		  * At entry:
		  *	C879 contains maximum number of players allowed.
		  *	C87A contains number of game versions available.
		  *
		  * At exit:
		  *	C879 contains the number of players selected.
		  *	C87A contains the game version selected.
		  */
		 button_handler_loop:
F7C5   BDF192           jsr   $waitrecal; 
F7C8   4F               clra;    
F7C9   BDF1B4           jsr   $read_switches; 
F7CC   BDF55A           jsr   $decrement_counters_C82E_C830; 
F7CF   BDF2A9           jsr   $intensity_to_7F; 
F7D2   B6C879           lda   $C879;  
F7D5   108EF794         ldy   #player_string;
F7D9   8D5A             bsr   display_option_string;  
F7DB   B6C87A           lda   $C87A;  
F7DE   108EF79F         ldy   #game_string;
F7E2   8D51             bsr   display_option_string;  
F7E4   BDF1AF           jsr   $dptoC8; 
F7E7   963C             lda   0x3C;   
F7E9   2706             beq   check_loop_counter;  
F7EB   960F             lda   0x0F;   
F7ED   263D             bne   handle_buttons;  
F7EF   0F3C             clr   0x3C;   
		 check_loop_counter:
F7F1   962F             lda   0x2F;   
F7F3   279E             beq   PF793;  
F7F5   962E             lda   0x2E;   
F7F7   26CC             bne   button_handler_loop;  
F7F9   9615             lda   0x15;    /* Start game if button 4 pressed. */
F7FB   2696             bne   PF793;  
F7FD   9612             lda   0x12;    /* Check button 1. */
F7FF   270F             beq   PF810;  
F801   9679             lda   0x79;   
F803   270B             beq   PF810;  
F805   4C               inca;          /* Increment player count. */
F806   914F             cmpa  0x4F;   
F808   2302             bls   PF80C;  
F80A   8601             lda   #0x01;  
F80C   9779      PF80C: sta   0x79;   
F80E   201C             bra   handle_buttons;  
F810   967A      PF810: lda   0x7A;   
F812   27B1             beq   button_handler_loop;  
F814   D613             ldb   0x13;     /* Check button 2. */
F816   2709             beq   PF821;  
F818   4C               inca;           /* Increment game number. */
F819   9150             cmpa  0x50;   
F81B   230D             bls   PF82A;  
F81D   8601             lda   #0x01;  
F81F   2009             bra   PF82A;  
F821   D614      PF821: ldb   0x14;     /* Check button 3. */
F823   27A0             beq   button_handler_loop;  
F825   4A               deca;           /* Decrement game number. */
F826   2602             bne   PF82A;  
F828   9650             lda   0x50;   
F82A   977A      PF82A: sta   0x7A;   

		 handle_buttons:
F82C   86F3             lda   #0xF3;    /* Reset loop counters. */
F82E   972F             sta   0x2F;   
F830   43               coma;    
F831   972E             sta   0x2E;   
F833   2090             bra   button_handler_loop;  


		 /*
		  * display_option_string()
		  *
		  * This routine displays the player or game option
		  * string, along with the current value for that
		  * option.  The 'a' register contains the value of
		  * the option, while the 'y' register must point
		  * to a block of the following form:
		  *
		  *	rel y, rel x,      ( for value )
		  *	rel y, rel x,      ( for option string)
		  *	option string,
		  *	0x80
		  *
		  * At entry:
		  *	'a' must contain option value.
		  *	'y' must point to string block.
		  */
		 display_option_string:
F835   8EC85E           ldx   #0xC85E;
F838   3402             pshs  a; 
F83A   8D13             bsr   set_dft_score;  
F83C   A6E0             lda   ,s+;    
F83E   270E             beq   PF84E;  
F840   8D1C             bsr   convert_a_to_bcd_and_add;  
F842   1F13             tfr   x,u;    
F844   ECA1             ldd   ,y++;   
F846   BDF37A           jsr   $print_at_d; 
F849   1F23             tfr   y,u;    
F84B   BDF378           jsr   $print_with_dft_hw; 
F84E   39        PF84E: rts;


		 /*
		  * set_dft_score()
		  *
		  * This routine will initialize the passed-in score string
		  * (pointed to by the 'x' register) to the following value:
		  *
		  *	"     0",0x80
		  *
		  * At entry:
		  *	'x' points to the string to be initialized.
		  */
		 set_dft_score:
F84F   CC2020           ldd   #0x2020;
F852   ED84             std   ,x;
F854   ED02             std   2,x;    
F856   A704             sta   4,x;    
F858   CC3080           ldd   #0x3080;
F85B   ED05             std   5,x;    
F85D   39               rts;


		 /*
		  * convert_a_to_bcd_and_add()
		  *
		  * This routine takes the binary value specified in the
		  * 'a' register, and converts it to a BCD representation.
		  * This BCD value is then added to the BCD value which
		  * is in the buffer pointed to by the 'x' register.
		  *
		  * At entry:
		  *	'a' contains value to be converted.
		  *	'x' points to BCD to which new value is to be added.
		  */
		 convert_a_to_bcd_and_add:
F85E   CE0000           ldu   #0x0000;
F861   8163      PF861: cmpa  #0x63;   /* 99 */
F863   2308             bls   PF86D;  
F865   8064             suba  #0x64;   /* 100 */
F867   33C90100         leau  0x0100,u;    
F86B   20F4             bra   PF861;  
F86D   8109      PF86D: cmpa  #0x09;   /* 9 */
F86F   2307             bls   PF878;  
F871   800A             suba  #0x0A;   /* 10 */
F873   33C810           leau  0x10,u; 
F876   20F5             bra   PF86D;  
F878   33C6      PF878: leau  a,u;    
F87A   1F30             tfr   u,d;    


		 /*
		  * add_d_to_x_in_bcd()
		  *
		  * This routine takes the BCD value in the 'd' register,
		  * and adds it to the BCD value pointed by the 'x' register.
		  * The result is store in the location pointed to by the
		  * 'x' register.
		  *
		  * At entry:
		  *	'd' contains a BCD value.
		  *	'x' points to a second BCD value.
		  */
		 add_d_to_x_in_bcd:
F87C   3402             pshs  a; 
F87E   3404             pshs  b; 
F880   C605             ldb   #0x05;  
F882   4F        PF882: clra;    
F883   C101             cmpb  #0x01;  
F885   2310             bls   PF897;  
F887   C501             bitb  #0x01;  
F889   2704             beq   PF88F;  
F88B   A6E4             lda   ,s;
F88D   2006             bra   PF895;  
F88F   A6E0      PF88F: lda   ,s+;    
F891   44               lsra;    
F892   44               lsra;    
F893   44               lsra;    
F894   44               lsra;    
F895   840F      PF895: anda  #0x0F;  
F897   BBC823    PF897: adda  $C823;  
F89A   7FC823           clr   $C823;  
F89D   AB85             adda  b,x;    
F89F   812F             cmpa  #0x2F;
F8A1   2E02             bgt   PF8A5;  
F8A3   8B10             adda  #0x10;  
F8A5   8139      PF8A5: cmpa  #0x39;  /* Check for digit overflow. */
F8A7   2305             bls   PF8AE;  
F8A9   800A             suba  #0x0A;  
F8AB   7CC823           inc   $C823;  
F8AE   A785      PF8AE: sta   b,x;    
F8B0   5A               decb;    
F8B1   2ACF             bpl   PF882;  
F8B3   7FC823           clr   $C823;  
F8B6   5F               clrb;    
F8B7   A685      PF8B7: lda   b,x;    /* Strip leading zero's. */
F8B9   8130             cmpa  #0x30; /* "0" */
F8BB   2609             bne   PF8C6;  
F8BD   8620             lda   #0x20;
F8BF   A785             sta   b,x;    
F8C1   5C               incb;    
F8C2   C105             cmpb  #0x05;  
F8C4   2DF1             blt   PF8B7;  
F8C6   39        PF8C6: rts;


		 /*
		  * compare_scores()
		  *
		  * This routine will compare two BCD score strings, to
		  * determine which one is higher.  The two strings are
		  * pointed to by the 'u' and 'x' registers.  Depending
		  * upon how the scores compare, one of the following 
		  * values will be returned in the 'a' register:
		  *
		  *	1) The scores are the same: a = 0
		  *	2) 'x' score > 'u' score:   a = 1
		  *	3) 'u' score > 'x' score:   a = 2
		  *
		  * At entry:
		  *	'x' points to first score string.
		  *	'u' points to second score string.
		  *
		  * At exit:
		  *	'a' returns result of the compare.
		  */
		 compare_scores:
F8C7   3450             pshs  x,u;    
F8C9   4F               clra;    
F8CA   E680      PF8CA: ldb   ,x+;    
F8CC   2B08             bmi   PF8D6;  
F8CE   E1C0             cmpb  ,u+;    
F8D0   27F8             beq   PF8CA;  
F8D2   2201             bhi   PF8D5;  
F8D4   4C               inca;    
F8D5   4C        PF8D5: inca;    
F8D6   35D0      PF8D6: puls  x,u,pc; 


		 /*
		  * check_4_new_hi_score()
		  *
		  * This routine compares a players score string, pointed
		  * to by the 'x' register, to the current hi score, pointed
		  * by the 'u' register.  If the player's score is higher
		  * than the currently saved hi score, then the player's
		  * score will be copied into the hi score buffer pointed
		  * to by the 'u' register.
		  *
		  * At entry:
		  *	'x' points to a players BCD score string.
		  *	'u' points to the current hi score for the game.
		  */
		 check_4_new_hi_score:
F8D8   8DED             bsr   compare_scores;  
F8DA   8101             cmpa  #0x01;  
F8DC   2606             bne   PF8E4;  
F8DE   A680      PF8DE: lda   ,x+;    
F8E0   A7C0             sta   ,u+;    
F8E2   2AFA             bpl   PF8DE;  
F8E4   39        PF8E4: rts;


		 /*
		  * modify_target_and_check_4_hit1()
		  *
		  * This routine first modifies the position of the target,
		  * and then it checks to see if the bullet has hit the
		  * target.  The 'y' register contains the (y,x) position
		  * of the target, the 'u' register contains a pointer to
		  * the (y,x) modification values, the 'x' register contains
		  * the bullet (y,x) position, and the 'd' register contains
		  * the (height/2, width/2) of the target.
		  *
		  * (0,u) is added to the y position of the target, and (1,u)
		  * is added to the x position.
		  *
		  * At entry:
		  *	'y' contains position of the target.
		  *	'x' contains position of the bullet.
		  *	'u' points to target modification values.
		  *	'd' contains (h/2, w/2) size of target.
		  *
		  * At exit:
		  *	Carry bit set if the target & bullet have collided,
		  *	otherwise, the carry bit will be cleared.
		  */
		 modify_target_and_check_4_hit1:
F8E5   3420             pshs  y; 
F8E7   3436             pshs  a,b,x,y;
F8E9   EC64             ldd   4,s;    
F8EB   ABC4             adda  ,u;
F8ED   EB41             addb  1,u;    
F8EF   ED64      PF8EF: std   4,s;    
F8F1   2010             bra   check_bullet_for_hit2;  


		 /*
		  * modify_target_and_check_4_hit2()
		  *
		  * This routine first modifies the position of the target,
		  * and then it checks to see if the bullet has hit the
		  * target.  The 'y' register contains the (y,x) position
		  * of the target, the 'u' register contains the (y,x)
		  * modification values, the 'x' register contains the
		  * bullet (y,x) position, and the 'd' register contains
		  * the (height/2, width/2) of the target.
		  *
		  * u(hi) is added to the y position of the target, and u(lo)
		  * is added to the x position.
		  *
		  * At entry:
		  *	'y' contains position of the target.
		  *	'x' contains position of the bullet.
		  *	'u' contains target modification values.
		  *	'd' contains (h/2, w/2) size of target.
		  *
		  * At exit:
		  *	Carry bit set if the target & bullet have collided,
		  *	otherwise, the carry bit will be cleared.
		  */
		 modify_target_and_check_4_hit2:
F8F3   3420             pshs  y; 
F8F5   3436             pshs  a,b,x,y;
F8F7   1F30             tfr   u,d;    
F8F9   AB64             adda  4,s;    
F8FB   EB65             addb  5,s;    
F8FD   20F0             bra   PF8EF;  


		 /*
		  * check_bullet_for_hit()
		  * check_bullet_for_hit2()
		  *
		  * These routines check to see if a bullet has bit a target.
		  * If the bulet has hit the target, then the carry bit will
		  * be set; otherwise, the carry bit will be cleared.  A hit
		  * is checked for in the following fashion:
		  *
		  *   if (target y-height/2) <= bullet y <= (target y+height/2)
		  *			        and
		  *      (target x-width/2)  <= bullet x <= (target x+width/x)
		  *
		  *   then the bulet hist, otherwise it missed.
		  *
		  * At entry:
		  *	'x' contains the bullet position.
		  *	'y' contains the target position.
		  *	'd' contains the (height/2, width/2) of target.
		  *
		  * At exit:
		  *	Carry bit will be set if the bullet hit the target;
		  *	otherwise, the carry bit will be cleared.
		  */
		 check_bullet_for_hit:
F8FF   3420             pshs  y; 
F901   3436             pshs  a,b,x,y;
		 check_bullet_for_hit2:
F903   1F41             tfr   sp,x;   
F905   5F               clrb;        /* Start with the y coordinate. */
		 check_bullet_loop:
F906   3A               abx;
F907   A604             lda   4,x;   /* Target y + height/2, or */
F909   AB84             adda  ,x;    /* Target x + width/2      */
F90B   2802             bvc   check_bullet_pt1;  
F90D   867F             lda   #0x7F;  /* Only goto edge of screen. */
		 check_bullet_pt1:
F90F   A102             cmpa  2,x;    
F911   2D15             blt   flag_a_miss;  
F913   A604             lda   4,x;    
F915   A084             suba  ,x;
F917   2802             bvc   check_bullet_pt2;  
F919   8680             lda   #0x80;  
		 check_bullet_pt2:
F91B   A102             cmpa  2,x;    
F91D   2E09             bgt   flag_a_miss;  
F91F   5C               incb;    
F920   C102             cmpb  #0x02;    /* Now, check x coordinate. */
F922   25E2             blo   check_bullet_loop;  
F924   1A01             orcc  #0x01;    /* A hit; so set carry bit. */
F926   2002             bra   PF92A;  
		 flag_a_miss:
F928   1CFE             andcc #0xFE;    /* A miss; so clear carry bit. */
F92A   3536      PF92A: puls  a,b,x,y;
F92C   35A0             puls  y,pc;   


		 /*
		  * generate_explosion_sound()
		  *
		  * This routine appears to generate some type of an
		  * explosion sound, dependent upon the 4 bytes which
		  * are pointed to by the 'u' register.
		  *
		  * At entry:
		  *	'u' must point to a block of 4 bytes of data, which
		  *	    somehow describe the type of sound to make.
		  *
		  * Dp must be set to C8.
		  */
		 generate_explosion_sound:
F92E   9667             lda   0x67;   
F930   2A29             bpl   PF95B;  
F932   847F             anda  #0x7F;  
F934   9767             sta   0x67;   
F936   8EC858           ldx   #0xC858;
F939   8604             lda   #0x04;  
F93B   BDF683           jsr   $move_block2; 
F93E   54               lsrb;    
F93F   54               lsrb;    
F940   54               lsrb;    
F941   DA58             orb   0x58;   
F943   C407             andb  #0x07;  
F945   D754             stb   0x54;   
F947   D658             ldb   0x58;   
F949   C438             andb  #0x38; /* "8" */                                
F94B   D753             stb   0x53;   
F94D   D658             ldb   0x58;   
F94F   C407             andb  #0x07;  
F951   D75D             stb   0x5D;   
F953   C602             ldb   #0x02;  
F955   D75C             stb   0x5C;   
F957   867F             lda   #0x7F;  
F959   200D             bra   PF968;  
F95B   9677      PF95B: lda   0x77;   
F95D   276A             beq   PF9C9;  
F95F   905B             suba  0x5B;   
F961   2A05             bpl   PF968;  
F963   5F               clrb;    
F964   D777             stb   0x77;   
F966   2062             bra   PF9CA;  
F968   9777      PF968: sta   0x77;   
F96A   44               lsra;    
F96B   44               lsra;    
F96C   D653             ldb   0x53;   
F96E   270D             beq   PF97D;  
F970   9746             sta   0x46;   
F972   D659             ldb   0x59;   
F974   2B05             bmi   PF97B;  
F976   2705             beq   PF97D;  
F978   1F89             tfr   a,b;    
F97A   53               comb;    
F97B   D746      PF97B: stb   0x46;   
F97D   44        PF97D: lsra;    
F97E   8107             cmpa  #0x07;  
F980   2305             bls   PF987;  
F982   810F             cmpa  #0x0F;  
F984   2701             beq   PF987;  
F986   4C               inca;    
F987   D65A      PF987: ldb   0x5A;   
F989   2B06             bmi   PF991;  
F98B   2702             beq   PF98F;  
F98D   880F             eora  #0x0F;  
F98F   1F89      PF98F: tfr   a,b;    
F991   8D37      PF991: bsr   PF9CA;  
F993   D65D             ldb   0x5D;   
F995   272B             beq   PF9C2;  
F997   965C      PF997: lda   0x5C;   
F999   4A               deca;    
F99A   2A02             bpl   PF99E;  
F99C   8602             lda   #0x02;  
F99E   975C      PF99E: sta   0x5C;   
F9A0   BDF57E           jsr   $get_bit_mask; 
F9A3   955D             bita  0x5D;   
F9A5   27F0             beq   PF997;  
F9A7   D65C             ldb   0x5C;   
F9A9   58               aslb;    
F9AA   50               negb;    
F9AB   8EC84B           ldx   #0xC84B;
F9AE   3085             leax  b,x;    
F9B0   BDF517           jsr   $get_random_a; 
F9B3   840F             anda  #0x0F;  
F9B5   8105             cmpa  #0x05;  
F9B7   2203             bhi   PF9BC;  
F9B9   48               asla;    
F9BA   8B05             adda  #0x05;  
F9BC   A784      PF9BC: sta   ,x;
F9BE   967E             lda   0x7E;   
F9C0   A701             sta   1,x;    
F9C2   9658      PF9C2: lda   0x58;   
F9C4   43               coma;    
F9C5   9445             anda  0x45;   
F9C7   9745             sta   0x45;   
F9C9   39        PF9C9: rts;
F9CA   9654      PF9CA: lda   0x54;   
F9CC   8EC845           ldx   #0xC845;
F9CF   4D        PF9CF: tsta;    
F9D0   2709             beq   PF9DB;  
F9D2   301F             leax  -1,x;   
F9D4   44        PF9D4: lsra;    
F9D5   24F8             bhs   PF9CF;  
F9D7   E784             stb   ,x;
F9D9   20F4             bra   PF9CF;  
F9DB   39        PF9DB: rts;


		 bit_masks:
F9DC   01               .byte 0x01; 
F9DD   02               .byte 0x02; 
F9DE   04               .byte 0x04; 
F9DF   08               .byte 0x08; 
F9E0   10               .byte 0x10; 
F9E1   20               .byte 0x20;
F9E2   40               .byte 0x40;
F9E3   80               .byte 0x80; 


		 music_stuff1:
F9E4   F7               .byte 0xF7; 
F9E5   EF               .byte 0xEF; 
F9E6   DF               .byte 0xDF; 
F9E7   01               .byte 0x01; 
F9E8   02               .byte 0x02; 
F9E9   04               .byte 0x04; 


		 music_stuff2:
F9EA   FE               .byte 0xFE; 
F9EB   FD               .byte 0xFD; 
F9EC   FB               .byte 0xFB; 
F9ED   08               .byte 0x08; 
F9EE   10               .byte 0x10; 
F9EF   20               .byte 0x20;


F9F0   7F        SF9F0: .byte 0x7F; 
F9F1   7F               .byte 0x7F; 
F9F2   80               .byte 0x80; 
F9F3   80               .byte 0x80; 


		 /*
		  * This is the start of the character generation table used
		  * by the string printing routine.  The table starts at
		  * F9F4, and goes for the next 480 bytes.
		  */
		 character_table:
F9F4   00               .byte 0x00;
F9F5   20               .byte 0x20;
F9F6   50               .byte 0x50;
F9F7   50               .byte 0x50;
F9F8   20               .byte 0x20;
F9F9   C8               .byte 0xC8;
F9FA   20               .byte 0x20;
F9FB   10               .byte 0x10;
F9FC   10               .byte 0x10;
F9FD   40               .byte 0x40;

F9FE   20               .byte 0x20;
F9FF   00               .byte 0x00;
FA00   00               .byte 0x00;
FA01   00               .byte 0x00;
FA02   00               .byte 0x00;
FA03   08               .byte 0x08;
FA04   30               .byte 0x30;
FA05   20               .byte 0x20;
FA06   70               .byte 0x70;
FA07   70               .byte 0x70;

FA08   10               .byte 0x10;
FA09   F8               .byte 0xF8;
FA0A   30               .byte 0x30;
FA0B   F8               .byte 0xF8;
FA0C   70               .byte 0x70;
FA0D   70               .byte 0x70;
FA0E   00               .byte 0x00;
FA0F   60               .byte 0x60;
FA10   00               .byte 0x00;
FA11   00               .byte 0x00;

FA12   00               .byte 0x00; 
FA13   70               .byte 0x70;
FA14   70               .byte 0x70;
FA15   20               .byte 0x20;
FA16   F0               .byte 0xF0;
FA17   70               .byte 0x70;
FA18   F0               .byte 0xF0;
FA19   F8               .byte 0xF8;
FA1A   F8               .byte 0xF8;
FA1B   78               .byte 0x78;

FA1C   88               .byte 0x88;
FA1D   70               .byte 0x70;
FA1E   08               .byte 0x08;
FA1F   88               .byte 0x88;
FA20   80               .byte 0x80;
FA21   88               .byte 0x88;
FA22   88               .byte 0x88;
FA23   F8               .byte 0xF8;
FA24   F0               .byte 0xF0;
FA25   70               .byte 0x70;

FA26   F0               .byte 0xF0;
FA27   70               .byte 0x70;
FA28   F8               .byte 0xF8;
FA29   88               .byte 0x88;
FA2A   88               .byte 0x88;
FA2B   88               .byte 0x88;
FA2C   88               .byte 0x88;
FA2D   88               .byte 0x88;
FA2E   F8               .byte 0xF8;
FA2F   70               .byte 0x70;

FA30   80               .byte 0x80;
FA31   70               .byte 0x70;
FA32   20               .byte 0x20;
FA33   00               .byte 0x00;
FA34   00               .byte 0x00;
FA35   20               .byte 0x20;
FA36   08               .byte 0x08;
FA37   20               .byte 0x20;
FA38   00               .byte 0x00;
FA39   00               .byte 0x00;

FA3A   00               .byte 0x00;
FA3B   38               .byte 0x38;
FA3C   10               .byte 0x10;
FA3D   20               .byte 0x20;
FA3E   44               .byte 0x44;
FA3F   44               .byte 0x44;
FA40   00               .byte 0x00;
FA41   FE               .byte 0xFE;
FA42   FF               .byte 0xFF;
FA43   FE               .byte 0xFE;

FA44   00               .byte 0x00;
FA45   70               .byte 0x70;
FA46   50               .byte 0x50;
FA47   50               .byte 0x50;
FA48   78               .byte 0x78;
FA49   C8               .byte 0xC8;
FA4A   50               .byte 0x50;
FA4B   20               .byte 0x20;
FA4C   20               .byte 0x20;
FA4D   20               .byte 0x20;

FA4E   A8               .byte 0xA8;
FA4F   20               .byte 0x20;
FA50   00               .byte 0x00;
FA51   00               .byte 0x00;
FA52   00               .byte 0x00;
FA53   08               .byte 0x08;
FA54   48               .byte 0x48;
FA55   60               .byte 0x60;
FA56   88               .byte 0x88;
FA57   88               .byte 0x88;

FA58   30               .byte 0x30;
FA59   80               .byte 0x80;
FA5A   40               .byte 0x40;
FA5B   08               .byte 0x08;
FA5C   88               .byte 0x88;
FA5D   88               .byte 0x88;
FA5E   60               .byte 0x60;
FA5F   60               .byte 0x60;
FA60   10               .byte 0x10;
FA61   00               .byte 0x00;

FA62   40               .byte 0x40;
FA63   88               .byte 0x88;
FA64   88               .byte 0x88;
FA65   50               .byte 0x50;
FA66   48               .byte 0x48;
FA67   88               .byte 0x88;
FA68   48               .byte 0x48;
FA69   80               .byte 0x80;
FA6A   80               .byte 0x80;
FA6B   80               .byte 0x80;

FA6C   88               .byte 0x88;
FA6D   20               .byte 0x20;
FA6E   08               .byte 0x08;
FA6F   90               .byte 0x90;
FA70   80               .byte 0x80;
FA71   D8               .byte 0xD8;
FA72   C8               .byte 0xC8;
FA73   88               .byte 0x88;
FA74   88               .byte 0x88;
FA75   88               .byte 0x88;

FA76   88               .byte 0x88;
FA77   88               .byte 0x88;
FA78   A8               .byte 0xA8;
FA79   88               .byte 0x88;
FA7A   88               .byte 0x88;
FA7B   88               .byte 0x88;
FA7C   88               .byte 0x88;
FA7D   88               .byte 0x88;
FA7E   08               .byte 0x08;
FA7F   40               .byte 0x40;

FA80   80               .byte 0x80;
FA81   08               .byte 0x08;
FA82   50               .byte 0x50;
FA83   00               .byte 0x00;
FA84   00               .byte 0x00;
FA85   70               .byte 0x70;
FA86   0C               .byte 0x0C;
FA87   20               .byte 0x20;
FA88   70               .byte 0x70;
FA89   70               .byte 0x70;

FA8A   00               .byte 0x00;
FA8B   44               .byte 0x44;
FA8C   10               .byte 0x10;
FA8D   70               .byte 0x70;
FA8E   00               .byte 0x00;
FA8F   00               .byte 0x00;
FA90   6C               .byte 0x6C;
FA91   82               .byte 0x82;
FA92   FF               .byte 0xFF;
FA93   FE               .byte 0xFE;

FA94   00               .byte 0x00;
FA95   70               .byte 0x70;
FA96   50               .byte 0x50;
FA97   F8               .byte 0xF8;
FA98   A0               .byte 0xA0;
FA99   10               .byte 0x10;
FA9A   50               .byte 0x50;
FA9B   40               .byte 0x40;
FA9C   40               .byte 0x40;
FA9D   10               .byte 0x10;

FA9E   70               .byte 0x70;
FA9F   20               .byte 0x20;
FAA0   00               .byte 0x00;
FAA1   00               .byte 0x00;
FAA2   00               .byte 0x00;
FAA3   10               .byte 0x10;
FAA4   48               .byte 0x48;
FAA5   20               .byte 0x20;
FAA6   08               .byte 0x08;
FAA7   08               .byte 0x08; 

FAA8   50               .byte 0x50; 
FAA9   F0               .byte 0xF0; 
FAAA   80               .byte 0x80; 
FAAB   10               .byte 0x10; 
FAAC   88               .byte 0x88; 
FAAD   88               .byte 0x88; 
FAAE   60               .byte 0x60; 
FAAF   00               .byte 0x00; 
FAB0   20               .byte 0x20; 
FAB1   78               .byte 0x78; 

FAB2   20               .byte 0x20; 
FAB3   08               .byte 0x08; 
FAB4   A8               .byte 0xA8; 
FAB5   88               .byte 0x88; 
FAB6   48               .byte 0x48; 
FAB7   80               .byte 0x80; 
FAB8   48               .byte 0x48; 
FAB9   80               .byte 0x80; 
FABA   80               .byte 0x80; 
FABB   80               .byte 0x80; 

FABC   88               .byte 0x88; 
FABD   20               .byte 0x20; 
FABE   08               .byte 0x08; 
FABF   A0               .byte 0xA0; 
FAC0   80               .byte 0x80; 
FAC1   A8               .byte 0xA8; 
FAC2   A8               .byte 0xA8; 
FAC3   88               .byte 0x88; 
FAC4   88               .byte 0x88; 
FAC5   88               .byte 0x88; 

FAC6   88               .byte 0x88; 
FAC7   40               .byte 0x40; 
FAC8   20               .byte 0x20; 
FAC9   88               .byte 0x88; 
FACA   88               .byte 0x88; 
FACB   88               .byte 0x88; 
FACC   50               .byte 0x50; 
FACD   50               .byte 0x50; 
FACE   10               .byte 0x10; 
FACF   40               .byte 0x40; 

FAD0   40               .byte 0x40; 
FAD1   08               .byte 0x08; 
FAD2   88               .byte 0x88; 
FAD3   00               .byte 0x00; 
FAD4   70               .byte 0x70; 
FAD5   A8               .byte 0xA8; 
FAD6   0A               .byte 0x0A; 
FAD7   20               .byte 0x20; 
FAD8   88               .byte 0x88; 
FAD9   F8               .byte 0xF8; 

FADA   60               .byte 0x60; 
FADB   BA               .byte 0xBA; 
FADC   38               .byte 0x38; 
FADD   20               .byte 0x20; 
FADE   00               .byte 0x00; 
FADF   00               .byte 0x00; 
FAE0   92               .byte 0x92; 
FAE1   82               .byte 0x82; 
FAE2   FF               .byte 0xFF; 
FAE3   FE               .byte 0xFE; 

FAE4   00               .byte 0x00; 
FAE5   20               .byte 0x20; 
FAE6   00               .byte 0x00; 
FAE7   50               .byte 0x50; 
FAE8   70               .byte 0x70; 
FAE9   20               .byte 0x20; 
FAEA   60               .byte 0x60; 
FAEB   00               .byte 0x00; 
FAEC   40               .byte 0x40; 
FAED   10               .byte 0x10; 

FAEE   A8               .byte 0xA8; 
FAEF   F8               .byte 0xF8; 
FAF0   00               .byte 0x00; 
FAF1   70               .byte 0x70; 
FAF2   00               .byte 0x00; 
FAF3   20               .byte 0x20; 
FAF4   48               .byte 0x48; 
FAF5   20               .byte 0x20; 
FAF6   70               .byte 0x70; 
FAF7   30               .byte 0x30; 

FAF8   90               .byte 0x90; 
FAF9   08               .byte 0x08; 
FAFA   F0               .byte 0xF0; 
FAFB   20               .byte 0x20; 
FAFC   70               .byte 0x70; 
FAFD   78               .byte 0x78; 
FAFE   00               .byte 0x00; 
FAFF   60               .byte 0x60; 
FB00   40               .byte 0x40; 
FB01   00               .byte 0x00; 

FB02   10               .byte 0x10; 
FB03   10               .byte 0x10; 
FB04   B8               .byte 0xB8; 
FB05   88               .byte 0x88; 
FB06   70               .byte 0x70; 
FB07   80               .byte 0x80; 
FB08   48               .byte 0x48; 
FB09   E0               .byte 0xE0; 
FB0A   E0               .byte 0xE0; 
FB0B   98               .byte 0x98; 

FB0C   F8               .byte 0xF8; 
FB0D   20               .byte 0x20; 
FB0E   08               .byte 0x08; 
FB0F   C0               .byte 0xC0; 
FB10   80               .byte 0x80; 
FB11   A8               .byte 0xA8; 
FB12   98               .byte 0x98; 
FB13   88               .byte 0x88; 
FB14   F0               .byte 0xF0; 
FB15   88               .byte 0x88; 

FB16   F0               .byte 0xF0; 
FB17   20               .byte 0x20; 
FB18   20               .byte 0x20; 
FB19   88               .byte 0x88; 
FB1A   50               .byte 0x50; 
FB1B   A8               .byte 0xA8; 
FB1C   20               .byte 0x20; 
FB1D   20               .byte 0x20; 
FB1E   20               .byte 0x20; 
FB1F   40               .byte 0x40; 

FB20   20               .byte 0x20; 
FB21   08               .byte 0x08; 
FB22   00               .byte 0x00; 
FB23   00               .byte 0x00; 
FB24   FE               .byte 0xFE; 
FB25   20               .byte 0x20; 
FB26   08               .byte 0x08; 
FB27   20               .byte 0x20; 
FB28   88               .byte 0x88; 
FB29   F8               .byte 0xF8; 

FB2A   F0               .byte 0xF0; 
FB2B   A2               .byte 0xA2; 
FB2C   38               .byte 0x38; 
FB2D   F8               .byte 0xF8; 
FB2E   82               .byte 0x82; 
FB2F   38               .byte 0x38; 
FB30   92               .byte 0x92; 
FB31   82               .byte 0x82; 
FB32   FF               .byte 0xFF; 
FB33   FE               .byte 0xFE; 

FB34   00               .byte 0x00; 
FB35   00               .byte 0x00; 
FB36   00               .byte 0x00; 
FB37   F8               .byte 0xF8; 
FB38   70               .byte 0x70; 
FB39   40               .byte 0x40; 
FB3A   A8               .byte 0xA8; 
FB3B   00               .byte 0x00; 
FB3C   40               .byte 0x40; 
FB3D   10               .byte 0x10; 

FB3E   A8               .byte 0xA8; 
FB3F   20               .byte 0x20; 
FB40   40               .byte 0x40; 
FB41   00               .byte 0x00; 
FB42   00               .byte 0x00; 
FB43   40               .byte 0x40; 
FB44   48               .byte 0x48; 
FB45   20               .byte 0x20; 
FB46   80               .byte 0x80; 
FB47   08               .byte 0x08; 

FB48   F8               .byte 0xF8; 
FB49   08               .byte 0x08; 
FB4A   88               .byte 0x88; 
FB4B   40               .byte 0x40; 
FB4C   88               .byte 0x88; 
FB4D   08               .byte 0x08; 
FB4E   60               .byte 0x60; 
FB4F   60               .byte 0x60; 
FB50   20               .byte 0x20; 
FB51   78               .byte 0x78; 

FB52   20               .byte 0x20; 
FB53   20               .byte 0x20; 
FB54   B0               .byte 0xB0; 
FB55   F8               .byte 0xF8; 
FB56   48               .byte 0x48; 
FB57   80               .byte 0x80; 
FB58   48               .byte 0x48; 
FB59   80               .byte 0x80; 
FB5A   80               .byte 0x80; 
FB5B   88               .byte 0x88; 

FB5C   88               .byte 0x88; 
FB5D   20               .byte 0x20; 
FB5E   08               .byte 0x08; 
FB5F   A0               .byte 0xA0; 
FB60   80               .byte 0x80; 
FB61   88               .byte 0x88; 
FB62   88               .byte 0x88; 
FB63   88               .byte 0x88; 
FB64   80               .byte 0x80; 
FB65   A8               .byte 0xA8; 

FB66   A0               .byte 0xA0; 
FB67   10               .byte 0x10; 
FB68   20               .byte 0x20; 
FB69   88               .byte 0x88; 
FB6A   50               .byte 0x50; 
FB6B   A8               .byte 0xA8; 
FB6C   50               .byte 0x50; 
FB6D   20               .byte 0x20; 
FB6E   40               .byte 0x40; 
FB6F   40               .byte 0x40; 

FB70   10               .byte 0x10; 
FB71   08               .byte 0x08; 
FB72   00               .byte 0x00; 
FB73   00               .byte 0x00; 
FB74   FE               .byte 0xFE; 
FB75   20               .byte 0x20; 
FB76   78               .byte 0x78; 
FB77   A8               .byte 0xA8; 
FB78   88               .byte 0x88; 
FB79   F8               .byte 0xF8; 

FB7A   F0               .byte 0xF0; 
FB7B   BA               .byte 0xBA; 
FB7C   7C               .byte 0x7C; 
FB7D   20               .byte 0x20; 
FB7E   44               .byte 0x44; 
FB7F   44               .byte 0x44; 
FB80   6C               .byte 0x6C; 
FB81   82               .byte 0x82; 
FB82   FF               .byte 0xFF; 
FB83   FE               .byte 0xFE; 

FB84   00               .byte 0x00; 
FB85   00               .byte 0x00; 
FB86   00               .byte 0x00; 
FB87   50               .byte 0x50; 
FB88   28               .byte 0x28; 
FB89   98               .byte 0x98; 
FB8A   90               .byte 0x90; 
FB8B   00               .byte 0x00; 
FB8C   20               .byte 0x20; 
FB8D   20               .byte 0x20; 

FB8E   00               .byte 0x00; 
FB8F   20               .byte 0x20; 
FB90   40               .byte 0x40; 
FB91   00               .byte 0x00; 
FB92   00               .byte 0x00; 
FB93   80               .byte 0x80; 
FB94   48               .byte 0x48; 
FB95   20               .byte 0x20; 
FB96   80               .byte 0x80; 
FB97   88               .byte 0x88; 

FB98   10               .byte 0x10; 
FB99   88               .byte 0x88; 
FB9A   88               .byte 0x88; 
FB9B   80               .byte 0x80; 
FB9C   88               .byte 0x88; 
FB9D   10               .byte 0x10; 
FB9E   60               .byte 0x60; 
FB9F   20               .byte 0x20; 
FBA0   10               .byte 0x10; 
FBA1   00               .byte 0x00; 

FBA2   40               .byte 0x40; 
FBA3   00               .byte 0x00; 
FBA4   80               .byte 0x80; 
FBA5   88               .byte 0x88; 
FBA6   48               .byte 0x48; 
FBA7   88               .byte 0x88; 
FBA8   48               .byte 0x48; 
FBA9   80               .byte 0x80; 
FBAA   80               .byte 0x80; 
FBAB   88               .byte 0x88; 

FBAC   88               .byte 0x88; 
FBAD   20               .byte 0x20; 
FBAE   88               .byte 0x88; 
FBAF   90               .byte 0x90; 
FBB0   88               .byte 0x88; 
FBB1   88               .byte 0x88; 
FBB2   88               .byte 0x88; 
FBB3   88               .byte 0x88; 
FBB4   80               .byte 0x80; 
FBB5   90               .byte 0x90; 

FBB6   90               .byte 0x90; 
FBB7   88               .byte 0x88; 
FBB8   20               .byte 0x20; 
FBB9   88               .byte 0x88; 
FBBA   20               .byte 0x20; 
FBBB   A8               .byte 0xA8; 
FBBC   88               .byte 0x88; 
FBBD   20               .byte 0x20; 
FBBE   80               .byte 0x80; 
FBBF   40               .byte 0x40; 

FBC0   08               .byte 0x08; 
FBC1   08               .byte 0x08; 
FBC2   00               .byte 0x00; 
FBC3   00               .byte 0x00; 
FBC4   48               .byte 0x48; 
FBC5   20               .byte 0x20; 
FBC6   F0               .byte 0xF0; 
FBC7   70               .byte 0x70; 
FBC8   70               .byte 0x70; 
FBC9   70               .byte 0x70; 

FBCA   60               .byte 0x60; 
FBCB   44               .byte 0x44; 
FBCC   6C               .byte 0x6C; 
FBCD   50               .byte 0x50; 
FBCE   38               .byte 0x38; 
FBCF   82               .byte 0x82; 
FBD0   00               .byte 0x00; 
FBD1   82               .byte 0x82; 
FBD2   FF               .byte 0xFF; 
FBD3   FE               .byte 0xFE; 

FBD4   00               .byte 0x00; 
FBD5   20               .byte 0x20; 
FBD6   00               .byte 0x00; 
FBD7   50               .byte 0x50; 
FBD8   F8               .byte 0xF8; 
FBD9   98               .byte 0x98; 
FBDA   68               .byte 0x68; 
FBDB   00               .byte 0x00; 
FBDC   10               .byte 0x10; 
FBDD   40               .byte 0x40; 

FBDE   00               .byte 0x00; 
FBDF   00               .byte 0x00; 
FBE0   80               .byte 0x80; 
FBE1   00               .byte 0x00; 
FBE2   80               .byte 0x80; 
FBE3   80               .byte 0x80; 
FBE4   30               .byte 0x30; 
FBE5   70               .byte 0x70; 
FBE6   F8               .byte 0xF8; 
FBE7   70               .byte 0x70; 

FBE8   10               .byte 0x10; 
FBE9   70               .byte 0x70; 
FBEA   70               .byte 0x70; 
FBEB   80               .byte 0x80; 
FBEC   70               .byte 0x70; 
FBED   60               .byte 0x60; 
FBEE   00               .byte 0x00; 
FBEF   40               .byte 0x40; 
FBF0   00               .byte 0x00; 
FBF1   00               .byte 0x00; 

FBF2   00               .byte 0x00; 
FBF3   20               .byte 0x20; 
FBF4   78               .byte 0x78; 
FBF5   88               .byte 0x88; 
FBF6   F0               .byte 0xF0; 
FBF7   70               .byte 0x70; 
FBF8   F0               .byte 0xF0; 
FBF9   F8               .byte 0xF8; 
FBFA   80               .byte 0x80; 
FBFB   78               .byte 0x78; 

FBFC   88               .byte 0x88; 
FBFD   70               .byte 0x70; 
FBFE   70               .byte 0x70; 
FBFF   88               .byte 0x88; 
FC00   F8               .byte 0xF8; 
FC01   88               .byte 0x88; 
FC02   88               .byte 0x88; 
FC03   F8               .byte 0xF8; 
FC04   80               .byte 0x80; 
FC05   68               .byte 0x68; 

FC06   88               .byte 0x88; 
FC07   70               .byte 0x70; 
FC08   20               .byte 0x20; 
FC09   70               .byte 0x70; 
FC0A   20               .byte 0x20; 
FC0B   50               .byte 0x50; 
FC0C   88               .byte 0x88; 
FC0D   20               .byte 0x20; 
FC0E   F8               .byte 0xF8; 
FC0F   70               .byte 0x70; 

FC10   08               .byte 0x08; 
FC11   70               .byte 0x70; 
FC12   00               .byte 0x00; 
FC13   F8               .byte 0xF8; 
FC14   00               .byte 0x00; 
FC15   20               .byte 0x20; 
FC16   60               .byte 0x60; 
FC17   20               .byte 0x20; 
FC18   00               .byte 0x00; 
FC19   00               .byte 0x00; 

FC1A   00               .byte 0x00; 
FC1B   38               .byte 0x38; 
FC1C   82               .byte 0x82; 
FC1D   88               .byte 0x88; 
FC1E   00               .byte 0x00; 
FC1F   00               .byte 0x00; 
FC20   00               .byte 0x00; 
FC21   FE               .byte 0xFE; 
FC22   FF               .byte 0xFF; 
FC23   FE               .byte 0xFE; 

 
		 angle_data1:
FC24   00               .byte 0x00; 
FC25   11               .byte 0x11; 
FC26   41               .byte 0x41;
FC27   30               .byte 0x30;
FC28   21               .byte 0x21;
FC29   10               .byte 0x10; 
FC2A   20               .byte 0x20;
FC2B   31               .byte 0x31;

		 angle_data2:
FC2C   00               .byte 0x00; 
FC2D   01               .byte 0x01; 
FC2E   03               .byte 0x03; 
FC2F   06               .byte 0x06; 
FC30   0A               .byte 0x0A; 
FC31   0F               .byte 0x0F; 
FC32   15               .byte 0x15; 
FC33   1C               .byte 0x1C; 
FC34   24               .byte 0x24;
FC35   2D               .byte 0x2D;


FC36   08               .byte 0x08; 
FC37   10               .byte 0x10; 
FC38   08        SFC38: .byte 0x08; 
FC39   10               .byte 0x10; 
FC3A   0B               .byte 0x0B; 
FC3B   08               .byte 0x08; 
FC3C   10               .byte 0x10; 
FC3D   0D               .byte 0x0D; 
FC3E   0A               .byte 0x0A; 
FC3F   08               .byte 0x08; 
FC40   10               .byte 0x10; 
FC41   0E               .byte 0x0E; 
FC42   0B               .byte 0x0B; 
FC43   09               .byte 0x09; 
FC44   08               .byte 0x08; 
FC45   10               .byte 0x10; 
FC46   0E               .byte 0x0E; 
FC47   0C               .byte 0x0C; 
FC48   0A               .byte 0x0A; 
FC49   09               .byte 0x09; 
FC4A   08               .byte 0x08; 
FC4B   10               .byte 0x10; 
FC4C   0E               .byte 0x0E; 
FC4D   0D               .byte 0x0D; 
FC4E   0B               .byte 0x0B; 
FC4F   0A               .byte 0x0A; 
FC50   09               .byte 0x09; 
FC51   08               .byte 0x08; 
FC52   10               .byte 0x10; 
FC53   0F               .byte 0x0F; 
FC54   0D               .byte 0x0D; 
FC55   0C               .byte 0x0C; 
FC56   0B               .byte 0x0B; 
FC57   0A               .byte 0x0A; 
FC58   09               .byte 0x09; 
FC59   08               .byte 0x08; 
FC5A   10               .byte 0x10; 
FC5B   0F               .byte 0x0F; 
FC5C   0E               .byte 0x0E; 
FC5D   0C               .byte 0x0C; 
FC5E   0B               .byte 0x0B; 
FC5F   0A               .byte 0x0A; 
FC60   09               .byte 0x09; 
FC61   09               .byte 0x09; 
FC62   08               .byte 0x08; 
FC63   10               .byte 0x10; 
FC64   0F               .byte 0x0F; 
FC65   0E               .byte 0x0E; 
FC66   0D               .byte 0x0D; 
FC67   0C               .byte 0x0C; 
FC68   0B               .byte 0x0B; 
FC69   0A               .byte 0x0A; 
FC6A   09               .byte 0x09; 
FC6B   09               .byte 0x09; 
FC6C   08               .byte 0x08; 

		 rotation_pair_table:
FC6D   00               .byte 0x00; 
FC6E   19               .byte 0x19; 
FC6F   32               .byte 0x32; 
FC70   4A               .byte 0x4A; 
FC71   62               .byte 0x62; 
FC72   79               .byte 0x79; 
FC73   8E               .byte 0x8E; 
FC74   A2               .byte 0xA2; 
FC75   B5               .byte 0xB5; 
FC76   C6               .byte 0xC6; 
FC77   D5               .byte 0xD5; 
FC78   E2               .byte 0xE2; 
FC79   ED               .byte 0xED; 
FC7A   F5               .byte 0xF5; 
FC7B   FB               .byte 0xFB; 
FC7C   FF               .byte 0xFF; 
FC7D   FF               .byte 0xFF; 
FC7E   FF               .byte 0xFF; 
FC7F   FB               .byte 0xFB; 
FC80   F5               .byte 0xF5; 
FC81   ED               .byte 0xED; 
FC82   E2               .byte 0xE2; 
FC83   D5               .byte 0xD5; 
FC84   C6               .byte 0xC6; 
FC85   B5               .byte 0xB5; 
FC86   A2               .byte 0xA2; 
FC87   8E               .byte 0x8E; 
FC88   79               .byte 0x79; 
FC89   62               .byte 0x62; 
FC8A   4A               .byte 0x4A; 
FC8B   32               .byte 0x32; 
FC8C   19               .byte 0x19; 

		 music_routine_data:
FC8D   03               .byte 0x03; 
FC8E   BD               .byte 0xBD; 
FC8F   03               .byte 0x03; 
FC90   87               .byte 0x87; 
FC91   03               .byte 0x03; 
FC92   54               .byte 0x54; 
FC93   03               .byte 0x03; 
FC94   24               .byte 0x24; 
FC95   02               .byte 0x02; 
FC96   F7               .byte 0xF7; 
FC97   02               .byte 0x02; 
FC98   CD               .byte 0xCD; 
FC99   02               .byte 0x02; 
FC9A   A4               .byte 0xA4; 
FC9B   02               .byte 0x02; 
FC9C   7E               .byte 0x7E; 
FC9D   02               .byte 0x02; 
FC9E   5B               .byte 0x5B; 
FC9F   02               .byte 0x02; 
FCA0   39               .byte 0x39; 
FCA1   02               .byte 0x02; 
FCA2   19               .byte 0x19; 
FCA3   01               .byte 0x01; 
FCA4   FB               .byte 0xFB; 
FCA5   01               .byte 0x01; 
FCA6   DE               .byte 0xDE; 
FCA7   01               .byte 0x01; 
FCA8   C3               .byte 0xC3; 
FCA9   01               .byte 0x01; 
FCAA   AA               .byte 0xAA; 
FCAB   01               .byte 0x01; 
FCAC   92               .byte 0x92; 
FCAD   01               .byte 0x01; 
FCAE   7C               .byte 0x7C; 
FCAF   01               .byte 0x01; 
FCB0   66               .byte 0x66; 
FCB1   01               .byte 0x01; 
FCB2   52               .byte 0x52; 
FCB3   01               .byte 0x01; 
FCB4   3F               .byte 0x3F; 
FCB5   01               .byte 0x01; 
FCB6   2D               .byte 0x2D; 
FCB7   01               .byte 0x01; 
FCB8   1C               .byte 0x1C; 
FCB9   01               .byte 0x01; 
FCBA   0C               .byte 0x0C; 
FCBB   00               .byte 0x00; 
FCBC   FD               .byte 0xFD; 
FCBD   00               .byte 0x00; 
FCBE   EF               .byte 0xEF; 
FCBF   00               .byte 0x00; 
FCC0   E2               .byte 0xE2; 
FCC1   00               .byte 0x00; 
FCC2   D5               .byte 0xD5; 
FCC3   00               .byte 0x00; 
FCC4   C9               .byte 0xC9; 
FCC5   00               .byte 0x00; 
FCC6   BE               .byte 0xBE; 
FCC7   00               .byte 0x00; 
FCC8   B3               .byte 0xB3; 
FCC9   00               .byte 0x00; 
FCCA   A9               .byte 0xA9; 
FCCB   00               .byte 0x00; 
FCCC   A0               .byte 0xA0; 
FCCD   00               .byte 0x00; 
FCCE   97               .byte 0x97; 
FCCF   00               .byte 0x00; 
FCD0   8E               .byte 0x8E; 
FCD1   00               .byte 0x00; 
FCD2   86               .byte 0x86; 
FCD3   00               .byte 0x00; 
FCD4   7F               .byte 0x7F; 
FCD5   00               .byte 0x00; 
FCD6   78               .byte 0x78; 
FCD7   00               .byte 0x00; 
FCD8   71               .byte 0x71; 
FCD9   00               .byte 0x00; 
FCDA   6B               .byte 0x6B; 
FCDB   00               .byte 0x00; 
FCDC   65               .byte 0x65; 
FCDD   00               .byte 0x00; 
FCDE   5F               .byte 0x5F; 
FCDF   00               .byte 0x00; 
FCE0   5A               .byte 0x5A; 
FCE1   00               .byte 0x00; 
FCE2   55               .byte 0x55; 
FCE3   00               .byte 0x00; 
FCE4   50               .byte 0x50; 
FCE5   00               .byte 0x00; 
FCE6   4B               .byte 0x4B; 
FCE7   00               .byte 0x00; 
FCE8   47               .byte 0x47; 
FCE9   00               .byte 0x00; 
FCEA   43               .byte 0x43; 
FCEB   00               .byte 0x00; 
FCEC   3F               .byte 0x3F; 
FCED   00               .byte 0x00; 
FCEE   3C               .byte 0x3C; 
FCEF   00               .byte 0x00; 
FCF0   38               .byte 0x38; 
FCF1   00               .byte 0x00; 
FCF2   35               .byte 0x35; 
FCF3   00               .byte 0x00; 
FCF4   32               .byte 0x32; 
FCF5   00               .byte 0x00; 
FCF6   2F               .byte 0x2F; 
FCF7   00               .byte 0x00; 
FCF8   2D               .byte 0x2D; 
FCF9   00               .byte 0x00; 
FCFA   2A               .byte 0x2A; 
FCFB   00               .byte 0x00; 
FCFC   28               .byte 0x28; 
FCFD   00               .byte 0x00; 
FCFE   26               .byte 0x26; 
FCFF   00               .byte 0x00; 
FD00   24               .byte 0x24; 
FD01   00               .byte 0x00; 
FD02   22               .byte 0x22; 
FD03   00               .byte 0x00; 
FD04   20               .byte 0x20; 
FD05   00               .byte 0x00; 
FD06   1E               .byte 0x1E; 
FD07   00               .byte 0x00; 
FD08   1C               .byte 0x1C; 
FD09   00               .byte 0x00; 
FD0A   1B               .byte 0x1B; 
FD0B   00               .byte 0x00; 
FD0C   00               .byte 0x00; 

		 intro_music_block:
FD0D   FEE8             .word music_header1b; 
FD0F   FEB6             .word music_header2a; 
FD11   93               .byte 0x93; 
FD12   1F               .byte 0x1F; 
FD13   0C               .byte 0x0C; 
FD14   93               .byte 0x93; 
FD15   1F               .byte 0x1F; 
FD16   06               .byte 0x06; 
FD17   98               .byte 0x98; 
FD18   9F               .byte 0x9F; 
FD19   24               .byte 0x24; 
FD1A   3C               .byte 0x3C; 
FD1B   11               .byte 0x11; 
FD1C   80               .byte 0x80; 

		berzerk_music_block:
FD1D   FD69             .word music_header1a; 
FD1F   FD79             .word music_header2b; 
FD21   21               .byte 0x21; 
FD22   07               .byte 0x07; 
FD23   21               .byte 0x21; 
FD24   07               .byte 0x07; 
FD25   21               .byte 0x21; 
FD26   07               .byte 0x07; 
FD27   21               .byte 0x21; 
FD28   07               .byte 0x07; 
FD29   21               .byte 0x21; 
FD2A   07               .byte 0x07; 
FD2B   21               .byte 0x21; 
FD2C   07               .byte 0x07; 
FD2D   21               .byte 0x21; 
FD2E   0E               .byte 0x0E; 
FD2F   99               .byte 0x99; 
FD30   9F               .byte 0x9F; 
FD31   24               .byte 0x24; 
FD32   0E               .byte 0x0E; 
FD33   95               .byte 0x95; 
FD34   9B               .byte 0x9B; 
FD35   20               .byte 0x20; 
FD36   0E               .byte 0x0E; 
FD37   21               .byte 0x21; 
FD38   07               .byte 0x07; 
FD39   21               .byte 0x21; 
FD3A   07               .byte 0x07; 
FD3B   21               .byte 0x21; 
FD3C   07               .byte 0x07; 
FD3D   21               .byte 0x21; 
FD3E   07               .byte 0x07; 
FD3F   21               .byte 0x21; 
FD40   07               .byte 0x07; 
FD41   21               .byte 0x21; 
FD42   07               .byte 0x07; 
FD43   9D               .byte 0x9D; 
FD44   A3               .byte 0xA3; 
FD45   28               .byte 0x28; 
FD46   0E               .byte 0x0E; 
FD47   A0               .byte 0xA0; 
FD48   A6               .byte 0xA6; 
FD49   2B               .byte 0x2B; 
FD4A   0E               .byte 0x0E; 
FD4B   22               .byte 0x22; 
FD4C   02               .byte 0x02; 
FD4D   28               .byte 0x28; 
FD4E   02               .byte 0x02; 
FD4F   2D               .byte 0x2D; 
FD50   02               .byte 0x02; 
FD51   28               .byte 0x28; 
FD52   02               .byte 0x02; 
FD53   22               .byte 0x22; 
FD54   02               .byte 0x02; 
FD55   28               .byte 0x28; 
FD56   02               .byte 0x02; 
FD57   2D               .byte 0x2D; 
FD58   02               .byte 0x02; 
FD59   28               .byte 0x28; 
FD5A   02               .byte 0x02; 
FD5B   22               .byte 0x22; 
FD5C   02               .byte 0x02; 
FD5D   28               .byte 0x28; 
FD5E   02               .byte 0x02; 
FD5F   2D               .byte 0x2D; 
FD60   02               .byte 0x02; 
FD61   28               .byte 0x28; 
FD62   02               .byte 0x02; 
FD63   2E               .byte 0x2E; 
FD64   02               .byte 0x02; 
FD65   2D               .byte 0x2D; 
FD66   28               .byte 0x28; 
FD67   21               .byte 0x21; 
FD68   80               .byte 0x80; 

		 music_header1a:
FD69   EF               .byte 0xEF; 
FD6A   FF               .byte 0xFF; 
FD6B   FE               .byte 0xFE; 
FD6C   DC               .byte 0xDC; 
FD6D   BA               .byte 0xBA; 
FD6E   00               .byte 0x00; 
FD6F   00               .byte 0x00; 
FD70   00               .byte 0x00; 
FD71   00               .byte 0x00; 
FD72   00               .byte 0x00; 
FD73   00               .byte 0x00; 
FD74   00               .byte 0x00; 
FD75   00               .byte 0x00; 
FD76   00               .byte 0x00; 
FD77   00               .byte 0x00; 
FD78   00               .byte 0x00; 

		 music_header2b:
FD79   00               .byte 0x00; 
FD7A   01               .byte 0x01; 
FD7B   02               .byte 0x02; 
FD7C   01               .byte 0x01; 
FD7D   00               .byte 0x00; 
FD7E   FF               .byte 0xFF; 
FD7F   FE               .byte 0xFE; 
FD80   FF               .byte 0xFF; 
FD81   FD               .byte 0xFD; 
FD82   C3               .byte 0xC3; 
FD83   FE               .byte 0xFE; 
FD84   B6               .byte 0xB6; 
FD85   51               .byte 0x51; 
FD86   24               .byte 0x24; 
FD87   50               .byte 0x50; 
FD88   06               .byte 0x06; 
FD89   50               .byte 0x50; 
FD8A   06               .byte 0x06; 
FD8B   50               .byte 0x50; 
FD8C   0C               .byte 0x0C; 
FD8D   50               .byte 0x50; 
FD8E   06               .byte 0x06; 
FD8F   50               .byte 0x50; 
FD90   06               .byte 0x06; 
FD91   50               .byte 0x50; 
FD92   04               .byte 0x04; 
FD93   50               .byte 0x50; 
FD94   04               .byte 0x04; 
FD95   50               .byte 0x50; 
FD96   04               .byte 0x04; 
FD97   50               .byte 0x50; 
FD98   18               .byte 0x18; 
FD99   50               .byte 0x50; 
FD9A   04               .byte 0x04; 
FD9B   50               .byte 0x50; 
FD9C   04               .byte 0x04; 
FD9D   50               .byte 0x50; 
FD9E   04               .byte 0x04; 
FD9F   50               .byte 0x50; 
FDA0   0C               .byte 0x0C; 
FDA1   50               .byte 0x50; 
FDA2   0C               .byte 0x0C; 
FDA3   50               .byte 0x50; 
FDA4   24               .byte 0x24; 
FDA5   50               .byte 0x50; 
FDA6   06               .byte 0x06; 
FDA7   50               .byte 0x50; 
FDA8   06               .byte 0x06; 
FDA9   50               .byte 0x50; 
FDAA   0C               .byte 0x0C; 
FDAB   50               .byte 0x50; 
FDAC   06               .byte 0x06; 
FDAD   50               .byte 0x50; 
FDAE   06               .byte 0x06; 
FDAF   50               .byte 0x50; 
FDB0   04               .byte 0x04; 
FDB1   50               .byte 0x50; 
FDB2   04               .byte 0x04; 
FDB3   50               .byte 0x50; 
FDB4   04               .byte 0x04; 
FDB5   50               .byte 0x50; 
FDB6   18               .byte 0x18; 
FDB7   50               .byte 0x50; 
FDB8   04               .byte 0x04; 
FDB9   50               .byte 0x50; 
FDBA   04               .byte 0x04; 
FDBB   50               .byte 0x50; 
FDBC   04               .byte 0x04; 
FDBD   50               .byte 0x50; 
FDBE   0C               .byte 0x0C; 
FDBF   50               .byte 0x50; 
FDC0   18               .byte 0x18; 
FDC1   26               .byte 0x26; 
FDC2   80               .byte 0x80; 
FDC3   FD               .byte 0xFD; 
FDC4   BA               .byte 0xBA; 
FDC5   98               .byte 0x98; 
FDC6   76               .byte 0x76; 
FDC7   55               .byte 0x55; 
FDC8   44               .byte 0x44; 
FDC9   33               .byte 0x33; 
FDCA   22               .byte 0x22; 
FDCB   11               .byte 0x11; 
FDCC   00               .byte 0x00; 
FDCD   00               .byte 0x00; 
FDCE   00               .byte 0x00; 
FDCF   00               .byte 0x00; 
FDD0   00               .byte 0x00; 
FDD1   00               .byte 0x00; 
FDD2   00               .byte 0x00; 
FDD3   FE               .byte 0xFE; 
FDD4   28               .byte 0x28; 
FDD5   FD               .byte 0xFD; 
FDD6   79               .byte 0x79; 
FDD7   98               .byte 0x98; 
FDD8   1C               .byte 0x1C; 
FDD9   10               .byte 0x10; 
FDDA   3F               .byte 0x3F; 
FDDB   08               .byte 0x08; 
FDDC   98               .byte 0x98; 
FDDD   1C               .byte 0x1C; 
FDDE   04               .byte 0x04; 
FDDF   98               .byte 0x98; 
FDE0   1C               .byte 0x1C; 
FDE1   04               .byte 0x04; 
FDE2   98               .byte 0x98; 
FDE3   1C               .byte 0x1C; 
FDE4   10               .byte 0x10; 
FDE5   3F               .byte 0x3F; 
FDE6   08               .byte 0x08; 
FDE7   98               .byte 0x98; 
FDE8   1C               .byte 0x1C; 
FDE9   04               .byte 0x04; 
FDEA   98               .byte 0x98; 
FDEB   1C               .byte 0x1C; 
FDEC   04               .byte 0x04; 
FDED   98               .byte 0x98; 
FDEE   1C               .byte 0x1C; 
FDEF   08               .byte 0x08; 
FDF0   93               .byte 0x93; 
FDF1   18               .byte 0x18; 
FDF2   08               .byte 0x08; 
FDF3   98               .byte 0x98; 
FDF4   1C               .byte 0x1C; 
FDF5   08               .byte 0x08; 
FDF6   9C               .byte 0x9C; 
FDF7   1F               .byte 0x1F; 
FDF8   08               .byte 0x08; 
FDF9   98               .byte 0x98; 
FDFA   1C               .byte 0x1C; 
FDFB   08               .byte 0x08; 
FDFC   93               .byte 0x93; 
FDFD   18               .byte 0x18; 
FDFE   08               .byte 0x08; 
FDFF   98               .byte 0x98; 
FE00   1C               .byte 0x1C; 
FE01   08               .byte 0x08; 
FE02   93               .byte 0x93; 
FE03   18               .byte 0x18; 
FE04   08               .byte 0x08; 
FE05   98               .byte 0x98; 
FE06   1C               .byte 0x1C; 
FE07   08               .byte 0x08; 
FE08   9C               .byte 0x9C; 
FE09   1F               .byte 0x1F; 
FE0A   08               .byte 0x08; 
FE0B   98               .byte 0x98; 
FE0C   1C               .byte 0x1C; 
FE0D   08               .byte 0x08; 
FE0E   93               .byte 0x93; 
FE0F   18               .byte 0x18; 
FE10   08               .byte 0x08; 
FE11   98               .byte 0x98; 
FE12   1C               .byte 0x1C; 
FE13   08               .byte 0x08; 
FE14   93               .byte 0x93; 
FE15   18               .byte 0x18; 
FE16   08               .byte 0x08; 
FE17   98               .byte 0x98; 
FE18   1C               .byte 0x1C; 
FE19   08               .byte 0x08; 
FE1A   9C               .byte 0x9C; 
FE1B   1F               .byte 0x1F; 
FE1C   08               .byte 0x08; 
FE1D   98               .byte 0x98; 
FE1E   1C               .byte 0x1C; 
FE1F   08               .byte 0x08; 
FE20   93               .byte 0x93; 
FE21   18               .byte 0x18; 
FE22   08               .byte 0x08; 
FE23   9C               .byte 0x9C; 
FE24   1F               .byte 0x1F; 
FE25   30               .byte 0x30; 
FE26   1A               .byte 0x1A; 
FE27   80               .byte 0x80; 
FE28   FF               .byte 0xFF; 
FE29   FE               .byte 0xFE; 
FE2A   DC               .byte 0xDC; 
FE2B   BA               .byte 0xBA; 
FE2C   98               .byte 0x98; 
FE2D   76               .byte 0x76; 
FE2E   54               .byte 0x54; 
FE2F   32               .byte 0x32; 
FE30   10               .byte 0x10; 
FE31   00               .byte 0x00; 
FE32   00               .byte 0x00; 
FE33   00               .byte 0x00; 
FE34   00               .byte 0x00; 
FE35   00               .byte 0x00; 
FE36   00               .byte 0x00; 
FE37   00               .byte 0x00; 
FE38   FE               .byte 0xFE; 
FE39   66               .byte 0x66; 
FE3A   FE               .byte 0xFE; 
FE3B   B6               .byte 0xB6; 
FE3C   0C               .byte 0x0C; 
FE3D   18               .byte 0x18; 
FE3E   11               .byte 0x11; 
FE3F   18               .byte 0x18; 
FE40   0C               .byte 0x0C; 
FE41   18               .byte 0x18; 
FE42   11               .byte 0x11; 
FE43   18               .byte 0x18; 
FE44   0C               .byte 0x0C; 
FE45   18               .byte 0x18; 
FE46   11               .byte 0x11; 
FE47   18               .byte 0x18; 
FE48   0C               .byte 0x0C; 
FE49   12               .byte 0x12; 
FE4A   0C               .byte 0x0C; 
FE4B   06               .byte 0x06; 
FE4C   11               .byte 0x11; 
FE4D   18               .byte 0x18; 
FE4E   9D               .byte 0x9D; 
FE4F   21               .byte 0x21; 
FE50   18               .byte 0x18; 
FE51   9F               .byte 0x9F; 
FE52   23               .byte 0x23; 
FE53   18               .byte 0x18; 
FE54   A1               .byte 0xA1; 
FE55   24               .byte 0x24; 
FE56   18               .byte 0x18; 
FE57   A3               .byte 0xA3; 
FE58   26               .byte 0x26; 
FE59   18               .byte 0x18; 
FE5A   9F               .byte 0x9F; 
FE5B   A4               .byte 0xA4; 
FE5C   28               .byte 0x28; 
FE5D   18               .byte 0x18; 
FE5E   07               .byte 0x07; 
FE5F   12               .byte 0x12; 
FE60   07               .byte 0x07; 
FE61   06               .byte 0x06; 
FE62   00               .byte 0x00; 
FE63   3C               .byte 0x3C; 
FE64   18               .byte 0x18; 
FE65   80               .byte 0x80; 
FE66   DE               .byte 0xDE; 
FE67   EF               .byte 0xEF; 
FE68   FE               .byte 0xFE; 
FE69   DC               .byte 0xDC; 
FE6A   BA               .byte 0xBA; 
FE6B   00               .byte 0x00; 
FE6C   00               .byte 0x00; 
FE6D   00               .byte 0x00; 
FE6E   00               .byte 0x00; 
FE6F   00               .byte 0x00; 
FE70   00               .byte 0x00; 
FE71   00               .byte 0x00; 
FE72   00               .byte 0x00; 
FE73   00               .byte 0x00; 
FE74   00               .byte 0x00; 
FE75   00               .byte 0x00; 
FE76   FE               .byte 0xFE; 
FE77   B2               .byte 0xB2; 
FE78   FE               .byte 0xFE; 
FE79   B6               .byte 0xB6; 
FE7A   18               .byte 0x18; 
FE7B   06               .byte 0x06; 
FE7C   1A               .byte 0x1A; 
FE7D   06               .byte 0x06; 
FE7E   1C               .byte 0x1C; 
FE7F   0C               .byte 0x0C; 
FE80   18               .byte 0x18; 
FE81   0C               .byte 0x0C; 
FE82   1A               .byte 0x1A; 
FE83   24               .byte 0x24; 
FE84   23               .byte 0x23; 
FE85   18               .byte 0x18; 
FE86   17               .byte 0x17; 
FE87   06               .byte 0x06; 
FE88   18               .byte 0x18; 
FE89   06               .byte 0x06; 
FE8A   1A               .byte 0x1A; 
FE8B   0C               .byte 0x0C; 
FE8C   17               .byte 0x17; 
FE8D   0C               .byte 0x0C; 
FE8E   18               .byte 0x18; 
FE8F   24               .byte 0x24; 
FE90   24               .byte 0x24; 
FE91   18               .byte 0x18; 
FE92   A4               .byte 0xA4; 
FE93   28               .byte 0x28; 
FE94   0C               .byte 0x0C; 
FE95   A3               .byte 0xA3; 
FE96   26               .byte 0x26; 
FE97   0C               .byte 0x0C; 
FE98   A1               .byte 0xA1; 
FE99   24               .byte 0x24; 
FE9A   0C               .byte 0x0C; 
FE9B   9F               .byte 0x9F; 
FE9C   23               .byte 0x23; 
FE9D   0C               .byte 0x0C; 
FE9E   9D               .byte 0x9D; 
FE9F   21               .byte 0x21; 
FEA0   18               .byte 0x18; 
FEA1   9A               .byte 0x9A; 
FEA2   1F               .byte 0x1F; 
FEA3   18               .byte 0x18; 
FEA4   17               .byte 0x17; 
FEA5   06               .byte 0x06; 
FEA6   18               .byte 0x18; 
FEA7   06               .byte 0x06; 
FEA8   1A               .byte 0x1A; 
FEA9   0C               .byte 0x0C; 
FEAA   17               .byte 0x17; 
FEAB   0C               .byte 0x0C; 
FEAC   18               .byte 0x18; 
FEAD   24               .byte 0x24; 
FEAE   24               .byte 0x24; 
FEAF   24               .byte 0x24; 
FEB0   18               .byte 0x18; 
FEB1   80               .byte 0x80; 
FEB2   FF               .byte 0xFF; 
FEB3   EE               .byte 0xEE; 
FEB4   DD               .byte 0xDD; 
FEB5   CC               .byte 0xCC; 

		 music_header2a:
FEB6   00               .byte 0x00; 
FEB7   00               .byte 0x00; 
FEB8   00               .byte 0x00; 
FEB9   00               .byte 0x00; 
FEBA   00               .byte 0x00; 
FEBB   00               .byte 0x00; 
FEBC   00               .byte 0x00; 
FEBD   00               .byte 0x00; 
FEBE   00               .byte 0x00; 
FEBF   00               .byte 0x00; 
FEC0   00               .byte 0x00; 
FEC1   00               .byte 0x00; 
FEC2   00               .byte 0x00; 
FEC3   00               .byte 0x00; 
FEC4   00               .byte 0x00; 
FEC5   00               .byte 0x00; 
FEC6   FE               .byte 0xFE; 
FEC7   E8               .byte 0xE8; 
FEC8   FE               .byte 0xFE; 
FEC9   B6               .byte 0xB6; 
FECA   96               .byte 0x96; 
FECB   9A               .byte 0x9A; 
FECC   1D               .byte 0x1D; 
FECD   1E               .byte 0x1E; 
FECE   91               .byte 0x91; 
FECF   95               .byte 0x95; 
FED0   18               .byte 0x18; 
FED1   1E               .byte 0x1E; 
FED2   94               .byte 0x94; 
FED3   98               .byte 0x98; 
FED4   1B               .byte 0x1B; 
FED5   1E               .byte 0x1E; 
FED6   8F               .byte 0x8F; 
FED7   94               .byte 0x94; 
FED8   18               .byte 0x18; 
FED9   14               .byte 0x14; 
FEDA   16               .byte 0x16; 
FEDB   0A               .byte 0x0A; 
FEDC   8C               .byte 0x8C; 
FEDD   91               .byte 0x91; 
FEDE   15               .byte 0x15; 
FEDF   14               .byte 0x14; 
FEE0   16               .byte 0x16; 
FEE1   0A               .byte 0x0A; 
FEE2   91               .byte 0x91; 
FEE3   95               .byte 0x95; 
FEE4   18               .byte 0x18; 
FEE5   32               .byte 0x32; 
FEE6   18               .byte 0x18; 
FEE7   80               .byte 0x80; 

		 music_header1b:
FEE8   EE               .byte 0xEE; 
FEE9   FF               .byte 0xFF; 
FEEA   FF               .byte 0xFF; 
FEEB   EE               .byte 0xEE; 
FEEC   EE               .byte 0xEE; 
FEED   DD               .byte 0xDD; 
FEEE   CC               .byte 0xCC; 
FEEF   BB               .byte 0xBB; 
FEF0   AA               .byte 0xAA; 
FEF1   99               .byte 0x99; 
FEF2   88               .byte 0x88; 
FEF3   88               .byte 0x88; 
FEF4   88               .byte 0x88; 
FEF5   88               .byte 0x88; 
FEF6   88               .byte 0x88; 
FEF7   88               .byte 0x88; 
FEF8   FF               .byte 0xFF; 
FEF9   16               .byte 0x16; 
FEFA   FE               .byte 0xFE; 
FEFB   B6               .byte 0xB6; 
FEFC   1C               .byte 0x1C; 
FEFD   06               .byte 0x06; 
FEFE   1F               .byte 0x1F; 
FEFF   06               .byte 0x06; 
FF00   1C               .byte 0x1C; 
FF01   06               .byte 0x06; 
FF02   18               .byte 0x18; 
FF03   06               .byte 0x06; 
FF04   1A               .byte 0x1A; 
FF05   06               .byte 0x06; 
FF06   18               .byte 0x18; 
FF07   06               .byte 0x06; 
FF08   15               .byte 0x15; 
FF09   06               .byte 0x06; 
FF0A   13               .byte 0x13; 
FF0B   06               .byte 0x06; 
FF0C   18               .byte 0x18; 
FF0D   06               .byte 0x06; 
FF0E   13               .byte 0x13; 
FF0F   06               .byte 0x06; 
FF10   17               .byte 0x17; 
FF11   06               .byte 0x06; 
FF12   18               .byte 0x18; 
FF13   1E               .byte 0x1E; 
FF14   18               .byte 0x18; 
FF15   80               .byte 0x80; 
FF16   FF               .byte 0xFF; 
FF17   FF               .byte 0xFF; 
FF18   EE               .byte 0xEE; 
FF19   EE               .byte 0xEE; 
FF1A   DD               .byte 0xDD; 
FF1B   DD               .byte 0xDD; 
FF1C   CC               .byte 0xCC; 
FF1D   CC               .byte 0xCC; 
FF1E   00               .byte 0x00; 
FF1F   00               .byte 0x00; 
FF20   00               .byte 0x00; 
FF21   00               .byte 0x00; 
FF22   00               .byte 0x00; 
FF23   00               .byte 0x00; 
FF24   00               .byte 0x00; 
FF25   00               .byte 0x00; 
FF26   FE               .byte 0xFE; 
FF27   28               .byte 0x28; 
FF28   FE               .byte 0xFE; 
FF29   B6               .byte 0xB6; 
FF2A   16               .byte 0x16; 
FF2B   0F               .byte 0x0F; 
FF2C   16               .byte 0x16; 
FF2D   05               .byte 0x05; 
FF2E   16               .byte 0x16; 
FF2F   05               .byte 0x05; 
FF30   16               .byte 0x16; 
FF31   05               .byte 0x05; 
FF32   1A               .byte 0x1A; 
FF33   0F               .byte 0x0F; 
FF34   16               .byte 0x16; 
FF35   0F               .byte 0x0F; 
FF36   1D               .byte 0x1D; 
FF37   0F               .byte 0x0F; 
FF38   1D               .byte 0x1D; 
FF39   05               .byte 0x05; 
FF3A   1D               .byte 0x1D; 
FF3B   05               .byte 0x05; 
FF3C   1D               .byte 0x1D; 
FF3D   05               .byte 0x05; 
FF3E   21               .byte 0x21; 
FF3F   0F               .byte 0x0F; 
FF40   1D               .byte 0x1D; 
FF41   32               .byte 0x32; 
FF42   1D               .byte 0x1D; 
FF43   80               .byte 0x80; 
FF44   FE               .byte 0xFE; 
FF45   28               .byte 0x28; 
FF46   FE               .byte 0xFE; 
FF47   B6               .byte 0xB6; 
FF48   16               .byte 0x16; 
FF49   06               .byte 0x06; 
FF4A   16               .byte 0x16; 
FF4B   02               .byte 0x02; 
FF4C   16               .byte 0x16; 
FF4D   02               .byte 0x02; 
FF4E   16               .byte 0x16; 
FF4F   02               .byte 0x02; 
FF50   1A               .byte 0x1A; 
FF51   06               .byte 0x06; 
FF52   16               .byte 0x16; 
FF53   06               .byte 0x06; 
FF54   1D               .byte 0x1D; 
FF55   06               .byte 0x06; 
FF56   1D               .byte 0x1D; 
FF57   02               .byte 0x02; 
FF58   1D               .byte 0x1D; 
FF59   02               .byte 0x02; 
FF5A   1D               .byte 0x1D; 
FF5B   02               .byte 0x02; 
FF5C   21               .byte 0x21; 
FF5D   06               .byte 0x06; 
FF5E   1D               .byte 0x1D; 
FF5F   32               .byte 0x32; 
FF60   11               .byte 0x11; 
FF61   80               .byte 0x80; 
FF62   FE               .byte 0xFE; 
FF63   28               .byte 0x28; 
FF64   FE               .byte 0xFE; 
FF65   B6               .byte 0xB6; 
FF66   1B               .byte 0x1B; 
FF67   0F               .byte 0x0F; 
FF68   16               .byte 0x16; 
FF69   05               .byte 0x05; 
FF6A   16               .byte 0x16; 
FF6B   05               .byte 0x05; 
FF6C   16               .byte 0x16; 
FF6D   05               .byte 0x05; 
FF6E   17               .byte 0x17; 
FF6F   30               .byte 0x30; 
FF70   16               .byte 0x16; 
FF71   05               .byte 0x05; 
FF72   16               .byte 0x16; 
FF73   05               .byte 0x05; 
FF74   16               .byte 0x16; 
FF75   05               .byte 0x05; 
FF76   17               .byte 0x17; 
FF77   30               .byte 0x30; 
FF78   16               .byte 0x16; 
FF79   80               .byte 0x80; 
FF7A   FD               .byte 0xFD; 
FF7B   69               .byte 0x69; 
FF7C   FE               .byte 0xFE; 
FF7D   B6               .byte 0xB6; 
FF7E   A0               .byte 0xA0; 
FF7F   23               .byte 0x23; 
FF80   12               .byte 0x12; 
FF81   A0               .byte 0xA0; 
FF82   23               .byte 0x23; 
FF83   0C               .byte 0x0C; 
FF84   9C               .byte 0x9C; 
FF85   20               .byte 0x20; 
FF86   06               .byte 0x06; 
FF87   9E               .byte 0x9E; 
FF88   21               .byte 0x21; 
FF89   12               .byte 0x12; 
FF8A   9C               .byte 0x9C; 
FF8B   20               .byte 0x20; 
FF8C   32               .byte 0x32; 
FF8D   13               .byte 0x13; 
FF8E   80               .byte 0x80; 
FF8F   FD               .byte 0xFD; 
FF90   C3               .byte 0xC3; 
FF91   FE               .byte 0xFE; 
FF92   B6               .byte 0xB6; 
FF93   16               .byte 0x16; 
FF94   04               .byte 0x04; 
FF95   16               .byte 0x16; 
FF96   04               .byte 0x04; 
FF97   16               .byte 0x16; 
FF98   04               .byte 0x04; 
FF99   16               .byte 0x16; 
FF9A   04               .byte 0x04; 
FF9B   1A               .byte 0x1A; 
FF9C   08               .byte 0x08; 
FF9D   1C               .byte 0x1C; 
FF9E   80               .byte 0x80; 
FF9F   A6               .byte 0xA6; 
FFA0   A0               .byte 0xA0; 
FFA1   20               .byte 0x20; 
FFA2   08               .byte 0x08; 
FFA3   BD               .byte 0xBD; 
FFA4   F3               .byte 0xF3; 
FFA5   BE               .byte 0xBE; 
FFA6   B6               .byte 0xB6; 
FFA7   C8               .byte 0xC8; 
FFA8   80               .byte 0x80; 
FFA9   84               .byte 0x84; 
FFAA   7F               .byte 0x7F; 
FFAB   B7               .byte 0xB7; 
FFAC   C8               .byte 0xC8; 
FFAD   80               .byte 0x80; 
FFAE   7A               .byte 0x7A; 
FFAF   C8               .byte 0xC8; 
FFB0   80               .byte 0x80; 
FFB1   A6               .byte 0xA6; 
FFB2   A4               .byte 0xA4; 
FFB3   47               .byte 0x47; 
FFB4   84               .byte 0x84; 
FFB5   F8               .byte 0xF8; 
FFB6   E6               .byte 0xE6; 
FFB7   A0               .byte 0xA0; 
FFB8   58               .byte 0x58; 
FFB9   58               .byte 0x58; 
FFBA   58               .byte 0x58; 
FFBB   58               .byte 0x58; 
FFBC   57               .byte 0x57; 
FFBD   C4               .byte 0xC4; 
FFBE   F8               .byte 0xF8; 
FFBF   7D               .byte 0x7D; 
FFC0   C8               .byte 0xC8; 
FFC1   80               .byte 0x80; 
FFC2   2B               .byte 0x2B; 
FFC3   DF               .byte 0xDF; 
FFC4   BD               .byte 0xBD; 
FFC5   F3               .byte 0xF3; 
FFC6   DF               .byte 0xDF; 
FFC7   B6               .byte 0xB6; 
FFC8   C8               .byte 0xC8; 
FFC9   80               .byte 0x80; 
FFCA   85               .byte 0x85; 
FFCB   0F               .byte 0x0F; 
FFCC   26               .byte 0x26; 
FFCD   E0               .byte 0xE0; 
FFCE   85               .byte 0x85; 
FFCF   20               .byte 0x20; 
FFD0   27               .byte 0x27; 
FFD1   CD               .byte 0xCD; 
FFD2   39               .byte 0x39; /* "9" */ 
FFD3   4B               .byte 0x4B; /* "K" */ 
FFD4   41               .byte 0x41; /* "A" */ 
FFD5   52               .byte 0x52; /* "R" */ 
FFD6   52               .byte 0x52; /* "R" */ 
FFD7   53               .byte 0x53; /* "S" */ 
FFD8   4F               .byte 0x4F; /* "O" */ 
FFD9   46               .byte 0x46; /* "F" */ 
FFDA   54               .byte 0x54; /* "T" */ 
FFDB   38               .byte 0x38; /* "8" */ 
FFDC   32               .byte 0x32; /* "2" */ 
FFDD   4C               .byte 0x4C; /* "L" */ 
FFDE   44               .byte 0x44; /* "D" */ 
FFDF   4D               .byte 0x4D; /* "M" */ 
FFE0   43               .byte 0x43; /* "C" */ 
FFE1   42               .byte 0x42; /* "B" */ 
FFE2   43               .byte 0x43; /* "C" */ 
FFE3   4A               .byte 0x4A; /* "J" */ 
FFE4   54               .byte 0x54; /* "T" */ 
FFE5   38               .byte 0x38; /* "8" */ 
FFE6   32               .byte 0x32; /* "2" */ 
FFE7   4C               .byte 0x4C; /* "L" */ 
FFE8   44               .byte 0x44; /* "D" */ 
FFE9   4D               .byte 0x4D; /* "M" */ 
FFEA   43               .byte 0x43; /* "C" */ 
FFEB   42               .byte 0x42; /* "B" */ 
FFEC   43               .byte 0x43; /* "C" */ 
FFED   4A               .byte 0x4A; /* "J" */ 

		 /* 6809 interrupt and startup vectors */
FFEE   0000             .word 0x0000;  
FFF0   0000             .word 0x0000; 
FFF2   CBF2             .word 0xCBF2;   /* SW3 */
FFF4   CBF2             .word 0xCBF2;   /* SW2 */
FFF6   CBF5             .word 0xCBF5;   /* FIRQ */
FFF8   CBF8             .word 0xCBF8;   /* IRQ */
FFFA   CBFB             .word 0xCBFB;   /* SW1 */
FFFC   CBFB             .word 0xCBFB;   /* NMI */
FFFE   F000             .word start_of_OS_ROM;  /* RESET */




