A000 : LDS   #$20FF	             	S = 20FF
A003 : LDAA  #$01     			A = 0x01
A005 : STAA  $103D    			$103D    = 0x01				| Set CR0 in option register - Watchdog divided by 2^17 (8Mhz=65.5ms,12Mhz=43.7,ms,16Mhz=32.8ms)
A008 : LDAA  #$98 	    		A = 0x98
A00A : STAA  $1039    			$1039    = 0x98				| Options Register - ADPU=1,DLY=1,CME=1, DLY=1 4000E-clock cycles delay from power save
A00D : LDAA  #$03     			A = 0x03				| 	CME=1 Enable clock monitor (reset if clock is off),ADPU=1 Power Up A/D convertor
A00F : STAA  $1024    			$1024    = 0x03				| Timer Interrupt Mask 2 - PR1=1, PR0=1 - Divide Timer interrupt by 16.
A012 : LDAA  #$15     			A = 0x15				|
A014 : STAA  $103C    			$103C    = 0x15				| High Pri Interrupt and misc reg - IRV=1, PSEL2=1,PSEL0=1, Set SPI Serial Transfer Complete 
A017 : LDAA  #$60     			A = 0x60				| 	as highest priority interrupt.  IRV does not look significant.
A019 : STAA  $1001    			$1001    = 0x60				| Port A - Data Direction Register - DDA6, DDA5 are output, DDA7,DDA4,DDA3,DDA2,DDA1,DDA0 input
A01C : LDAA  #$2F     			A = 0x2F					
A01E : STAA  $1003    			$1003    = 0x2F				| Port G - Data Direction Register - DDG5, DDG3,DDG2,DDG1,DDG0 are output, DDG7,DDG6,DDG4 are input
A021 : LDAA  #$3C     			A = 0x3C				
A023 : STAA  $1009    			$1009    = 0x3C				| Port D - Data Direction Register - DDD5, DDD4, DDD3, DDD2 are output, DDD7,DDD6,DDD1,DDD0 are input
A026 : CLRA           			A = 0x0
A027 : STAA  $1000    			$1000    = 0x0				| Set port A to 0
A02A : STAA  $1002    			$1002    = 0x0				| Set port G to 0
A02D : LDAA  #$20     			A = 0x20
A02F : STAA  $1008    			$1008    = 0x20				| Set port D to 0x20
A032 : LDAA  #$04     			A = 0x04
A034 : STAA  $102B    			$102B    = 0x04				| Set SCI Baud Rate - SCR2=1, Divide baud rate scaler by 16, input is already clock/64.
A037 : LDAA  #$05     			A = 0x05
A039 : STAA  $105D  	 		$105D    = 0x05				| Chip Select Control Register - CSPROG enabled - used Bit 7 Port G,
A03C : LDAA  #$13			A = 0x13				| 	Program Chip size select - 32k, Maps at $8000-$FFFF
A03E : STAA  $1021		   	$1021    = 0x13				| Timer Control 2 - Input Capture Edge Control -  Timer #4 - Nothing, Time #1-Falling Edge
A041 : LDAA  #$CE			A = 0xCE				| 	Time #2 - Nothing, Time #3 - Both Rising and Falling edges
A043 : STAA  $105F			$105F    = 0xCE				| CSGSIZ - IO chips select 1 and 2 are active during address valid time, Chip size is 0K
A046 : LDAA  #$40			A = 40
A048 : STAA  $105E 	 		$105E    = 40				
A04B : CLRA  				A = 0
A04C : STAA  $105C			$105C    = 0
A04F : STAA  $1038			$1038    = 0				| System Config Register - GWOM normal, CWOM normal
A052 : LDAA  #$44			A = 44
A054 : STAA  $1028			$1028    = 44				| Serial Perf. Control Register - SPE, CPHA=1,SPI interrupt enable, Clock Phase Set
A057 : LDAA  #$FF			A = FF				
A059 : STAA  $4001			$4001    = FF				|
A05C : LDAA  #$31			A = 31
A05E : STAA  $4003			$4003    = 31				
A061 : LDAA  #$00			A = 0
A063 : STAA  $4005			$4005    = 0				
A066 : LDAA  #$03			A = 03	
A068 : STAA  $4007			$4007    = 03			
A06B : LDX   #$1FFF			X = 1FFF
A06E : STX   $400E			$400E = 1FFF				$400E = 1FFF  (word)
A071 : LDX   #$F93A			X = F93A
A074 : STX   $3FFC			$3FFC = F93A				| M[$3FFC] = 0xF93A
A077 : LDX   #$3FC0			X = 3FC0                            <=|
A07A : LDD   #$0000			D = 0000                              |
A07D : STD   $00,X			$X = 0				      |	for (x=3FC0;x<3FFA;x+=2)
A07F : INX   				x++  				      |	  M[$x] = 0
A080 : INX   				x++                                   |
A081 : CPX   #$3FFA			compare x with 3FFA                   |
A084 : BNE   $A07D			branch if not equal $A07D           <=|
A086 : LDX   #$10C0			X = 10C0                            <=|
A089 : LDD   #$0000			D = 0				      | for (x=10C0;x<10FA;x+=2)
A08C : STD   $00,X			$X = 0				      |	  M[$x] = 0
A08E : INX   				x++				      |
A08F : INX   				x++				      |	
A090 : CPX   #$10FA			compare x with 10FA		      |	
A093 : BNE   $A08C			Branck if not equal $A08C	    <=|		
A095 : LDD   #$8000             	D = 8000
A098 : STD   $10F0			M[$10F0] = 8000  
A09B : STD   $10CC			M[$10CC] = 8000
A09E : STD   $10C8			M[$10C8] = 8000
A0A1 : LDD   #$0002			D = 0002
A0A4 : STD   $10C0			M[$10C0] = 0002
A0A7 : LDAB  #$04			B = 04  (D = 0004)
A0A9 : STD   $10C2			M[$10C2] = 8004
A0AC : LDAB  #$06			B = 06  (D = 0006)
A0AE : STD   $10C4			M[$10C4] = 8006
A0B1 : LDD   #$FFF6			D = FFF6
A0B4 : STD   $10C6			M[$10C6] = FFF6
A0B7 : CLRA  				A = 0   (D = 00F6)
A0B8 : LDAB  #$0A			B = 0A  (D = 000A)
A0BA : LDX   #$8019			X = 8019
A0BD : BRCLR $00,X,00100000B,$A0C3      if (bit 0x20 of $8019 == 0) then goto A0C3   ($8019 = 45, so no goto, ROM)
A0C1 : ORAA  #$01                       A = A OR 01                           	|Sets lowest bit of A
A0C3 : STD   $10FC			M[$10FC] = D
A0C6 : LDD   #$FEFA			D = FEFA
A0C9 : STD   $10E6			$10E6 = FEFA
A0CC : LDD   #$FFD8			D = FFD8
A0CF : STD   $10E8			$10E8 = FFD8
A0D2 : LDAB  $82E7			B = $82E7			     	| B = M[$82EF] (value 01)   				
A0D5 : COMB  				Complement B				
A0D6 : LDAA  #$FF			A = FF					| A = FF
A0D8 : ADDD  #$0001			D = 0001				| D = 0001
A0DB : STD   $10EA			$10EA = 0001				| M[$10EA] = 0001
A0DE : LDAA  $0047			A = $0047    (unknown what is at $0047) | A = M[$0047]
A0E0 : INCA  				A ++					| A ++
A0E1 : BEQ   $A0E5								| if A = 0 then goto A0E5
A0E3 : STAA  $0047			$0047 = A      (unknown)		| M[$0047] = A
A0E5 : LDAA  $0047			A = $0047      (unknown)		| A = M[$0047]						|
A0E7 : CMPA  #$01			Compare A with 01			|							|
A0E9 : BHI   $A0EF			Branch if higher to A0EF		| if (A (M[$0047]) > 01) then goto A0EF			| if (M[$0047] > 01) then goto A0EF
A0EB : BRCLR $0002,00001000B,$A109						| if  (M[$0002] || 00001000) = 0 then goto A109		| if (M[$1002] || 00001000) == 0) then goto A109
A0EF : LDAA  $103F			A = $103F				| A = M[$103F]						|
A0F2 : CMPA  #$0B			Compare A with 0B			|							| 
A0F4 : BEQ   $A0FA								| if ( A (M[$103F]) = 0B) then goto A0FA		| if (M[$103F] == 0B) then goto A0FA
A0F6 : CMPA  #$7B			Compare A with 7B			|							|
A0F8 : BNE   $A117								| if (A != 7B) then goto A117				| if (M[$103F] != 7B) then goto A117 
A0FA : LDD   #$7FF8			D = 7FF8				| D = 7FF8						| D = 7FF8
A0FD : LDX   #$8008			X = 8008				| X = 8008 						| A = 8008
A100 : JSR   $FC31			Jump to subroutine at FC31		| gosub FC31						
A103 : CPY   $8006			Compare Y with $8006			|							|
A107 : BNE   $A110								| if (Y != M[$8006]) then goto A110  			| if (Y != M[$8006]) then goto A110
A109 : LDAA  $8008			A = $8008				| A = M[$8008]						|
A10C : CMPA  #$DA			Compare  A with DA			| if (A (M[$8008]) == DA) then goto A127		| if (M[$8008] == DA) then goto A127
A10E : BEQ   $A127			Branch if equal to A127			|							|
A110 : LDAA  $8008			A = $8008				| A = M[$8008]						|
A113 : CMPA  #$AA			compare A with AA			|							| if (M[$8008] == AA) then goto A127
A115 : BEQ   $A127			Branch if equal to A127			| if (A (M[$8008]) == AA) then goto A127                |
A117 : BSET  $0002,00001000B		Set 00001000B of $0002										| M[$0002] = M[$0002] | 00001000B
A11A : BSET  $0005,00000001B		Set 00000001B of $0005										| M[$0005] = M[$0005] | 00000001B
A11D : JSR   $FAB5			Jump to subroutine FAB5										| gosub FAB5 (Addup $0002 -> $0007 + 01 into D)
A120 : STD   $0011			Store D to $0011										| M[$0011] = D
A122 : CLR   $0010			Clear $0010											| M[$0010] = 0
A125 : BRA   $A125			Branch always $A125										| goto A125 (goto yourself) (Checksum is bad)
A127 : BCLR  $0002,00001000B		Clear bit 00001000B of $0002									| M[$0002] = M[$0002] & 11110111
A12A : LDAA  $4006			Load A with $4006			| A = M[$4006]					     B<=|
A12D : ORAA  #$80			Or A with 80				| A = A | 80					       =| M[$4006] = M[$4006] | 80
A12F : STAA  $4006			Store A to $4006			| M[$4006] = A					     E<=|
A132 : LDX   #$4002			Load X with 4002			| X = 4002					     B<=|
A135 : BCLR  $00,X,00000001B		Clear Bit 00000001 of $X		| A = A & 11111110				     E<=| A = M[$4002] & 11111110
A138 : LDX   #$02DE			Load X with 02DE			| X = 02DE						| X = 02DE
A13B : LDAA  $8019			Load A with $8019			| A = M[$8019]					     B<=|
A13E : BITA  #$01			Test bit 00000001 of A			|						       =|
A140 : BNE   $A145			Branch if not equal to A145		| 						     E<=| if ((M[$8019] & 00000001) == 1) then goto A145
A142 : LDX   #$03FF			Load X with 03FF			| X = M[$03FF]					     B<=|
A145 : CLR   $00,X			Clear $X				| $X =0           				       =| for (x =03ff;x!=0048;x--)
A147 : DEX   				Decrement X				| X = X - 1					       =|   M[$X] = 0
A148 : CPX   #$0048			Compare X to 0048			| compare X to $0048				       =|
A14B : BNE   $A145			Branch if not equal to A145		| if (X != $0048) then goto A145		     E<=|
A14D : CLR   $2000			Clear $2000				| M[$2000] = 0						| M[$2000] = 0
A150 : LDAA  $4002			Load A with $4002			| A = M[$4002]					     B<=| 
A153 : ANDA  #$CE			And a with CE				| A = A && CE					       =| M[$0048] = M[$4002] & CE
A155 : STAA  $004B			Store A to $0048			| M[$0048] = A					     E<=| 
A157 : LDAA  $4004			Load A with $4004			| A = M[$4004]					     B<=|
A15A : STAA  $004C			Store A to $004C			| M[$004C] = A					     E<=| M[$4004] = M[$0048]
A15C : BCLR  $0066,10000000B            Clear bit 10000000 of $0066		|							| M[$0066] = M[$0066] & 01111111
A15F : LDAA  $801B			Load A with $801B			| A = M[$801B]					     B<=|
A162 : BITA  #$04			Bit 04 of A test			| compare bit 04 of A				       =|
A164 : BNE   $A16C			Branch if not equal A16C		| Branch if not equal to A16C			     E<=| if (M[$8018] & 04) == 0) then goto A16C
A166 : BRCLR $004C,00000100B,$A170	Branch if $004C bit 00000100 to A170    | 							| if (M[$004C] & 04) == 0) then goto A170
A16A : BRA   $A173			Branch to A173				|							| goto A173
A16C : BRCLR $004C,00000100B,$A173	Branch if $004C bit 00000100 to A173	| 							| if (M[$004C] & 04) == 0) then goto A173
A170 : BSET  $0066,10000000B		Set 100000000 of $0066			|							| M[$0066] = M[$0066] | 80
A173 : LDAA  #$03			Load A with 03				| A = 03                                             B<=| 
A175 : STAA  $004D			Store A to $004D			| M[$004D] = A					     E<=| M[$004D] = 03
A177 : JSR   $FAC3			Jump to subroutine FAC3			| 							| gosub FAC3
A17A : LDX   #$4000			Load X with 4000			| X = 4000					        |
A17D : BCLR  $00,X,00011100B		Clear Bit 00011100 of $X		| M[$X] = 11100011 & M[$X]			        | 
A180 : LDAA  #$08			Load A with 08				| A = 08                                                |
A182 : ORAA  $00,X			Or $X with A				| A = $X || A					        |
A184 : STAA  $00,X			Store A to $X				| $X = A
A186 : CLR   $1030			Clear $1030				| M[$1030] = 0
A189 : LDX   #$1000			Load X with 1000			| X = 1000
A18C : LDAB  #$0C			Load B with 0C				| B = 0C					     B<=| for (B=0C;B!=0;B--)
A18E : BRSET $30,X,10000000B,$A198	Branch if $(X+30) bit 10000000 to A198  | if ((M[$(X+30)] & 10000000) == 1) then goto A198     =|   if ((M[$(X+30)] & 80) == 1) then goto A198
A192 : DECB  				Decrement B				| B = B - 1					       =|
A193 : BNE   $A18E			Branch if not equal to A18E		| if (B != 0) then goto A18E                         E<=|
A195 : BSET  $0059,00000001B		Set Bit 01 of $0059			| M[$0059] = M[$0059] | 00000001
A198 : LDAA  $1034			Load A with $1034			| A = M[$1034]					     B<=| M[$00D3] = M[$1034]
A19B : STAA  $00DE			Store A to $00DE			| M[$00D3] = A					     E<=|
A19D : JSR   $DC3E			Jump to $DC3E				| gosub DC3E
A1A0 : BCLR  $0054,00010000B            Clear Bit 10 of $0054			| M[$0054] = M[$0054] & 11101111
A1A3 : LDAA  $01AC			Load A with $01AC			| A = M[$01AC]
A1A6 : LDX   #$8029			Load X with 8029			| X = 8029
A1A9 : JSR   $FC14			Jump to subroutine FC14			| 							|gosub FC14
A1AC : SUBA  $8028			Sub A from $8028			| A = A - M[$8028]
A1AF : STAA  $0108			Store A to $0108			| M[$0108] = A
A1B2 : LDAA  $01A9			Load A with $01A9			| A = M[$01A9]
A1B5 : LSRA  				Shift right Logical A			| A = A >> 1
A1B6 : LDX   #$8078			Load X with 8078			| X = 8078
A1B9 : JSR   $FC14			Jump subroutine $FC14			| gosub FC14
A1BC : STAA  $0109			Store A to $0109			| M[$0109] = A
A1BF : CLRA  				Clear A					| A = 0
A1C0 : LDAB  #$59			Load B with 59				| B = 59
A1C2 : SUBB  $0108			Subtract $0108 from B			| B = B - M[$0108]
A1C5 : LDX   #$8019			Load X with 8019			| X = 8019
A1C8 : BRCLR $00,X,00100000B,$A1E6	Branch if M[$X] 00100000=0 to A1E6      | if ((M[$X] & 0x20) == 0) then goto A1E6
A1CC : STD   $10D6			Store D to $10D6			| M[$10D6] = D
A1CF : STD   $10D8								| M[$10D8] = D
A1D2 : STD   $10DA								| M[$10DA] = D
A1D5 : STD   $10DC								| M[$10DC] = D
A1D8 : STD   $10DE								| M[$10DE] = D
A1DB : STD   $10E0								| M[$10E0] = D
A1DE : STD   $10E2								| M[$10E2] = D
A1E1 : STD   $10E4								| M[$10E4] = D
A1E4 : BRA   $A1E9			Branch Always A1E9			| goto A1E9
A1E6 : STD   $10F2			Store D to $10F2			| M[$10F2] = D
A1E9 : LDX   #$4000			Load X with 4000			| X = 4000
A1EC : BCLR  $00,X,00011100B		clear bits 00011100 of M[$X]            | M[$X] = M[$X] & 11100011
A1EF : LDAA  #$1C			Load A with 1C				| A = 1C					     B<=|
A1F1 : ORAA  $00,X			Or A and M[$X]				| A = A || M[X]					       =|M[$X] = M[$X] | 1C
A1F3 : STAA  $00,X			Store A to M[$X]			| M[$X] = A					     E<=|
A1F5 : CLR   $1030			Clear $1030				| M[$1030] = 0
A1F8 : LDX   #$1000			Load X with 1000			| X = 1000
A1FB : LDAB  #$0C			Load B with 0C				| B = 0C
A1FD : BRSET $30,X,10000000B,$A207	Branch if bit 10000000 of $X+30 to $A207| if ((M[$(X+30)] & 0x80 ) > 0) then goto A207
A201 : DECB  				Decrement B				| B = B - 1
A202 : BNE   $A1FD			Branch if not equal (zero) to A1FD	| if (B != 0) then goto A1FD
A204 : BSET  $0059,00000001B		Set 00000001 of $0059			| M[$0059] = M[$0059] | 01
A207 : LDAA  $1034			Load A with $1034			| A = M[$1034]
A20A : STAA  $00D6			Store A to $00D6			| M[$00D6] = A
A20C : CMPA  #$64			Compare A with 64		     B<=| if (A >= 64) then goto A22D			     B<=|
A20E : BCC   $A22D			Branch if carry clear to A22D 	     E<=|						       =| if ((A >= 64) || (A < 28)) then goto A22D
A210 : CMPA  #$28			Compare A with 28		     B<=| if (A < 28) then goto A22D			       =|
A212 : BCS   $A22D			Branch if carry is set to A22D	     E<=|						     E<=|
A214 : LDAA  $00DB			Load A with $00DB		     	| A = M[$00DB] 					     B<=|
A216 : CMPA  #$06			Compare A with 06			| 						       =| if (M[$00DB] > 06) then goto A22D
A218 : BHI   $A22D			Branch if High to $A22D			| if (A > 06) then goto A22D			     E<=|
A21A : LDAA  $00D4			Load A with $00D4			| A = M[$00D4]					     B<=|
A21C : CMPA  #$F9			Compare A with F9			|						       =| if (M[$00D4] < F9) then goto A22D
A21E : BCS   $A22D			Branch if carry set to A22D		| if (A < F9) then goto A22D			     E<=|
A220 : LDAA  $00D5			Load A with $00D5			| A = M[$00D5]
A222 : COMA  				Complement A
A223 : CMPA  #$F9			Compare A
A225 : BCS   $A22D			Branch if carry is set to A22D
A227 : BSET  $006A,00010000B		Set 00010000 of $006A			| M[$006A] = M[$006A] | 00010000
A22A : JMP   $A617			goto A617				| goto A617
A22D : LDAA  #$08			Load A with 08				| A = 08					     B<=|  
A22F : STAA  $5000			Store A to $5000			| M[$5000] = A					     E<=| M[$5000] = 08
A232 : LDAB  $8022			Load A with $8022			| A = M[$8022]
A235 : BPL   $A23A			Branch if positive to A23A		| if (A >= 0) then goto A23A
A237 : NEGB  				Negate B
A238 : LDAA  #$80			Load A with 80				| A = 80					     B<=|
A23A : PSHB  				Push B											       =| A = B
A23B : TAB   				Transfer Accumulator			| B = A						       =| B = 80
A23C : PULA  				Pull A					| 						     E<=|
A23D : STD   $0448			Store D to $0448			| D = M[$0448]
A240 : JSR   $FAB5			Jump to subroutine FAB5			| gosub FAB5
A243 : CPD   $0011			Compare D to $0011		     B<=| if (D != M[$0011] then goto A266
A246 : BNE   $A266			Branch if not equal to A266	     E<=|
A248 : LDX   #$0026			Load X with 0026			| X = 0026					     B<=| 
A24B : LDAA  $14,X			Load A with $X+14			| A = M[$(X+14)]				       =|
A24D : CMPA  $87AD			Compare A with $87AD			| Compare A with M[$87AD]			       =|
A250 : BCC   $A257			Branch if carry is clear		| 						     E<=| if (M[$(0026+14)] >= M[$87AD]) then goto A257
A252 : LDAB  $87AD			Load B with $87AD			| B = M[$87AD] (0x7A) (122)
A255 : BRA   $A25F			Branch always to $A25F			| goto A25F
A257 : CMPA  $87AE			Compare A with $87AE		     B<=| 
A25A : BLS   $A261			Branch if less or = than to A261     E<=| if (A <= M[$87AE] then goto A261
A25C : LDAB  $87AE			Load B with $87AE			| B = M[$87AE]	(0x86) (134)				     B<=|
A25F : STAB  $14,X			Store B $X+14				| M[$(X+14)] = B				     E<=| M[$(X+14)] = M[$87AE]
A261 : DEX   				Decrement X				| X = X - 1
A262 : BNE   $A24B			Branch if Not Equal to A24B		| if (X != 0) then goto A24B
A264 : BRA   $A295			Branch Always to A295			| Goto A295
A266 : LDX   #$0048			Load X with 48				| X = 0x48
A269 : CLR   $00,X			Clear $X				| M[$X] = 0
A26B : DEX   				Decrement X				| X = X - 1
A26C : BNE   $A269			Branch if Not equal to A269		| if (X != 0) then goto A269
A26E : LDX   #$03FF			Load X with 03ff			| X = 0x03FF
A271 : CLR   $00,X			Clear $X				| M[$X] = 0
A273 : DEX   				Decrement X				| X = X - 1
A274 : CPX   #$02DE			Compare X with  02DE		     B=>| 
A277 : BNE   $A271			Branch if not equal to A271	     E=>| if (X != 02DE) then goto A271
A279 : JSR   $FAB5			Jump to service routine FAB5		| gosub FAB5
A27C : STD   $0011			Store D to 0011				| M[$0011] = D
A27E : LDAA  $88B3			Load A with $88B3			| A = M[$88B3]
A281 : STAA  $003B			Store A to $003B			| M[$003B] = A      Store IAC motor counts
A283 : BSET  $0056,01000000B		Set bit 01000000 of $0056		| M[$0056] = M[$0056] | 0x40
A286 : LDAA  $892C			Load A with $892C			| A = M[$892C]
A289 : STAA  $003C			Store A to $003C			| M[$003C] = A
A28B : LDAA  #$80			Load A with 80				| A = 0x80
A28D : LDX   #$0026			Load X with 26				| X = 0x26
A290 : STAA  $14,X			Store A to $(X+14)			| M[$(X+14)] = A
A292 : DEX   				Decrement X				| X = X - 1
A293 : BNE   $A290			Branch if Not equal to A290		| if ( X != 0 ) then goto A290
A295 : LDAA  $00D5			Load A with $00D5			| A = M[$00D5]
A297 : COMA  				Complement A				| A = A XOR 0xFF
A298 : STAA  $0234			Store A to $0234			| M[$0234] = A
A29B : LDX   #$FCDF			Load X with FCDF			| X = FCDF
A29E : JSR   $FC14			Jump to service routine FC14		| gosub FC14
A2A1 : STAA  $0235			Store A to $0235			| M[$0235] = A
A2A4 : STAA  $0236			Store A to $0236			| M[$0236] = A
A2A7 : TAB   				B = A					| B = A
A2A8 : CLRA  				A = 0					| A = 0
A2A9 : ASLD  				Shift D left 1	D is (AB) 		| D = D << 1
A2AA : ASLD  				Shift D left 1				| D = D << 1
A2AB : ASLD  				Shift D left 1				| D = D << 1
A2AC : STD   $023C			Store D to $023C			| M[$023C] = D
A2AF : STD   $023E			Store D to $023E			| M[$023E] = D
A2B2 : STD   $0240			Store D to $0240			| M[$0240] = D
A2B5 : STD   $0242			Store D to $0242			| M[$0242] = D
A2B8 : STD   $0244			Store D to $0244			| M[$0244] = D
A2BB : STD   $0246			Store D to $0246			| M[$0246] = D
A2BE : STD   $0248			Store D to $0248			| M[$0248] = D
A2C1 : STD   $024A			Store D to $024A			| M[$024A] = D
A2C4 : BRSET $0001,00001000B,$A307      Branch if 08 of $0001 is set to A307	| if ((M[$0001] & 0x08) > 0) then goto A307 
A2C8 : LDAA  $0235			Load A with $0235		     B=>| A = M[$0235]
A2CB : CMPA  $84F0			Compare A with 84F0		       =| 
A2CE : BLS   $A2D3			Branch if less than or = to A2D3     E=>| if (A <= M[$84F0]) then goto A2D3
A2D0 : BSET  $0051,10000000B		Set 10000000 of $0051			| M[$0051] = M[$0051] & 0x80
A2D3 : LDX   #$86E4			Load X th 86E4				| X = 0x86E4
A2D6 : LDAA  $01AC			Load A with 01Ac			| A = M[$01AC]
A2D9 : JSR   $FC14			Jump to service routine			| gosub FC14
A2DC : TAB   
A2DD : LDAA  $0235
A2E0 : LDX   #$872B
A2E3 : JSR   $FC14
A2E6 : ABA   
A2E7 : BCC   $A2EB
A2E9 : LDAA  #$FF
A2EB : CLRB  
A2EC : STD   $0008
A2EE : LDX   #$8317
A2F1 : LDAA  $01AC
A2F4 : JSR   $FC14
A2F7 : SUBA  $8316
A2FA : STAA  $000C
A2FC : LDAA  $0235
A2FF : LDX   #$8641
A302 : JSR   $FC14
A305 : STAA  $003E
A307 : LDX   #$8700
A30A : LDAA  $01AC
A30D : JSR   $FC14
A310 : STAA  $00D2
A312 : LDX   #$871D
A315 : LDAA  $01AC
A318 : JSR   $FC14
A31B : STAA  $01B4
A31E : LDX   #$870E
A321 : LDAA  $01AC
A324 : JSR   $FC14
A327 : STAA  $00D1
A329 : LDAA  $01A9
A32C : LDX   #$8390
A32F : JSR   $FC14
A332 : STAA  $00FD
A334 : LDAA  $01A9
A337 : LSRA  
A338 : LDX   #$8081
A33B : JSR   $FC14
A33E : STAA  $020A
A341 : LDX   #$8623
A344 : LDAA  $01AC
A347 : JSR   $FC14
A34A : LDX   #$8621
A34D : JSR   $FB83			| Routine returns D = AIN (byte)  * M[$X] (word)
A350 : STD   $01B8
A353 : STD   $009A
A355 : LDAA  $01AB
A358 : CMPA  $809E
A35B : BCS   $A360
A35D : BSET  $0001,00000010B
A360 : CLRB  
A361 : LDAA  $8684
A364 : STAA  $0175
A367 : STAA  $0179
A36A : STAA  $0173
A36D : STAA  $0177
A370 : LDAA  $8680
A373 : STAA  $016B
A376 : JSR   $F43B
A379 : LDAA  $0164
A37C : STAA  $0199
A37F : STAA  $0254
A382 : LDAA  $00DC		|A = M[$00DC]
A384 : CMPA  #$30		|	
A386 : BCC   $A38B		|if (A >= 0x30) goto A38B
A388 : LSRA  			|A = A / 2
A389 : BRA   $A39D		|goto A39D
A38B : CMPA  #$94		|
A38D : BCC   $A394		|if (A >= 0x94) then goto A394
A38F : SUBA  #$24		|A = A - 0x24
A391 : ASLA  			|A = A * 2
A392 : BRA   $A39D		|goto A39D
A394 : CMPA  #$C4		|Compare A with 0xC4
A396 : BLS   $A39A		|if (A <= 0xC4) then goto A39A
A398 : LDAA  #$C4		|A = 0xC4 (Limit A to 0xC4 max, 196d)
A39A : LSRA  			|Shift A right -> A = A / 2
A39B : ADDA  #$96		|A = A + 0x96  (150 decimal)
A39D : LDX   #$8699		|X = 0x8699
A3A0 : JSR   $FC09		|Table index, table row size 8x8699 0x20, table start 0x869A
A3A3 : STAA  $00CC		|Store value from table M[$00CC]
A3A5 : TAB   			|B = A
A3A6 : CLRA  			|A = 0
A3A7 : ASLD  			|D = D * 2
A3A8 : ASLD  			|D = D * 2
A3A9 : STD   $00CD		|M[$00CD] = D (DWORD)
A3AB : LDAA  $00DA		|A = M[$00DA]
A3AD : STAA  $015D
A3B0 : STAA  $015E
A3B3 : STAA  $015F
A3B6 : STAA  $014E
A3B9 : STAA  $019B
A3BC : SUBA  #$1A
A3BE : LDAB  #$97
A3C0 : JSR   $FC65
A3C3 : STAA  $0150
A3C6 : STAA  $025B
A3C9 : STAA  $0151
A3CC : STAA  $0152
A3CF : LDAA  $00DA
A3D1 : CMPA  $003F
A3D3 : BLS   $A3D7
A3D5 : STAA  $003F
A3D7 : LDAA  $003F
A3D9 : SUBA  #$0D
A3DB : LDAB  #$97
A3DD : MUL   
A3DE : ADCA  #$00
A3E0 : CMPA  #$8F
A3E2 : BLS   $A3E6
A3E4 : LDAA  #$8F
A3E6 : STAA  $0158
A3E9 : LDAB  $003F
A3EB : CLRA  
A3EC : LDX   #$02B6
A3EF : FDIV  
A3F0 : PSHX  
A3F1 : PULA  
A3F2 : PULB  
A3F3 : ADDD  #$0A57
A3F6 : STD   $0156
A3F9 : LDAA  $0158		|A = M[$0158]
A3FC : LDAB  #$50		|B = 0x50
A3FE : LDX   #$8300		|X = 0x8300
A401 : JSR   $FC10		|gosub FC10
A404 : STAA  $0160		|M[$0160] = A
A407 : LDAA  $0158		|A = M[$0158]
A40A : LDAB  #$50		|B = 0x50
A40C : LDX   #$830F		|X = 0x830F
A40F : JSR   $FC10		|gosub FC10
A412 : STAA  $0161		|M[$0161] = A
A415 : LDAA  $0158		|A = M[$0158]
A418 : LDAB  #$50		|B = 0x50
A41A : LDX   #$8D70		|X = 0x8D70
A41D : JSR   $FC10		|gosub FC10
A420 : STAA  $0162		|M[$0162] = A
A423 : LDAA  $0158		|A = M[$0158]
A426 : LDAB  #$50		|B = 0x50
A428 : LDX   #$884C		|X = 0x884C
A42B : JSR   $FC10		|gosub FC10
A42E : STAA  $0163		|M[$0163] = A
A431 : LDAA  $003E		|A = M[$003E]
A433 : BEQ   $A43A
A435 : LDD   #$0000
A438 : BRA   $A461
A43A : LDX   #$8633		|X = 0x8633
A43D : LDAA  $01AC		|A = 0x01AC
A440 : JSR   $FC14		|gosub FC14
A443 : LDX   #$8621		|X = 0x8621
A446 : JSR   $FB83		|gosub FBB3		| Routine returns D = AIN (byte)  * M[$X] (word)
A449 : PSHB  
A44A : PSHA  
A44B : LDAA  $0158
A44E : LDAB  #$50
A450 : LDX   #$8652
A453 : JSR   $FC10
A456 : TSX   
A457 : JSR   $FB83			| Routine returns D = AIN (byte)  * M[$X] (word)
A45A : PULX  
A45B : ASLD  
A45C : BCC   $A461
A45E : LDD   #$FFFF
A461 : STD   $01BE
A464 : LDAA  #$80			| A = 0x80
A466 : STAA  $0147			| M[$0147] = A   Reset Left Block Learn Multipler
A469 : STAA  $0148			| M[$0148] = A   Reset Right Block Learn Multiplier
A46C : STAA  $0146			| M[$0146] = A
A46F : STAA  $0145			| M[$0145] = A
A472 : STAA  $0144			| M[$0144] = A   Reset Left Integrator
A475 : STAA  $0143			| M[$0143] = A   Reset Right Integrator
A478 : CLRB  				| B = 0
A479 : LDAA  $01A9			| M[$01A9] = A   Coolent temp lag filtered
A47C : CMPA  $85B5			| compare A with M[$85B5] (0xA7) (185.45 degrees Far.)
A47F : BCS   $A484			| if ( A < M[$85B5] (0xA7) ) then goto A484
A481 : LDAB  $85B6			| B = M[$85B6] (0x21)
A484 : STAB  $027B			| M[$027B] = B 
A487 : LDAB  $0040
A489 : LDX   #$FD5D
A48C : ANDB  #$03
A48E : ABX   
A48F : LDAA  $1002
A492 : ANDA  #$FC
A494 : ADDA  $00,X
A496 : STAA  $1002
A499 : BRSET $0001,00001000B,$A4C5
A49D : LDAA  $00D7
A49F : CMPA  $84D9
A4A2 : BCS   $A4C5
A4A4 : LDAA  $01A9			| A = M[$01A9]  - Coolent temp lag filtered
A4A7 : CMPA  $84DB			| compare A with M[$84DB] (0x
A4AA : BHI   $A4C5			| if ( A > M[$84DB] (0x85) (140 degrees F) then goto A4C5
A4AC : BRSET $0006,00000100B,$A4C5	| if ( bit 0x02 of M[$0006] is set ) then goto A4C5 (C.V. IV A/C Compressor Fault)
A4B0 : BRCLR $0007,00111110B,$A4B6
A4B4 : BRA   $A4C5
A4B6 : LDAA  $00DC
A4B8 : CMPA  $84DC
A4BB : BCS   $A4C5
A4BD : LDD   #$7FFF
A4C0 : STD   $400A
A4C3 : BRA   $A4CB
A4C5 : BSET  $0056,00000001B
A4C8 : BSET  $0050,00100000B
A4CB : LDAA  #$FF
A4CD : STAA  $0104
A4D0 : STAA  $019E
A4D3 : LDAB  $0008
A4D5 : CLRA  
A4D6 : ADDB  $871C
A4D9 : ADCA  #$00
A4DB : ADDB  $01B4
A4DE : ADCA  #$00
A4E0 : PSHB  
A4E1 : PSHA  
A4E2 : LDAA  $0150
A4E5 : LDX   #$86D3
A4E8 : JSR   $FC14
A4EB : TAB   
A4EC : CLRA  
A4ED : TSX   
A4EE : ADDD  $00,X
A4F0 : PULX  
A4F1 : XGDX  
A4F2 : CLRA  
A4F3 : LDAB  $867B
A4F6 : FDIV  
A4F7 : STX   $01B0
A4FA : STX   $01AE
A4FD : LDAA  $0235
A500 : LDAB  $801B
A503 : BITB  #$02
A505 : BEQ   $A50A
A507 : LDAA  $01A9			| A = M[$01A9] - Collent temp lag filtered.
A50A : LDX   #$8935
A50D : JSR   $FC14
A510 : STAA  $011D
A513 : LDAA  $003C
A515 : CMPA  $8930
A518 : BHI   $A51F
A51A : CMPA  $892F
A51D : BCC   $A527
A51F : BSET  $0056,01000000B
A522 : LDAA  $892C
A525 : STAA  $003C
A527 : LDX   #$891E
A52A : LDAA  $01AC
A52D : JSR   $FC14
A530 : ADDA  $011D
A533 : BCS   $A539
A535 : ADDA  $003C
A537 : BCC   $A53B
A539 : LDAA  #$FF
A53B : STAA  $0118
A53E : LDAA  #$0E		| A = 0x0E
A540 : STAA  $0049		| M[$0049] = A
A542 : LDAA  #$27
A544 : STAA  $01A1
A547 : LDAA  #$FF
A549 : STAA  $0134
A54C : LDAA  $003B
A54E : STAA  $010C
A551 : LDAA  $00DC
A553 : CMPA  #$AB
A555 : BHI   $A55D
A557 : LDX   #$1002
A55A : BSET  $00,X,00000100B
A55D : LDAA  #$FF
A55F : STAA  $021C
A562 : LDX   #$FFFF
A565 : STX   $007D
A567 : LDAA  $800F
A56A : STAA  $0217
A56D : LDX   #$8008
A570 : STX   $0282
A573 : LDAA  $01AC
A576 : LDX   #$8946
A579 : JSR   $FC14
A57C : PSHA  
A57D : LDAA  $0158		|A = 0x0158
A580 : LDAB  #$50		|B = 0x50
A582 : LDX   #$8954		|X = 0x8954
A585 : JSR   $FC10		|gosub FC10
A588 : PULB  			|Pull B
A589 : MUL   			|D = A * B
A58A : ASLD  			|D = D * 2
A58B : BCC   $A58F		
A58D : LDAA  #$FF
A58F : STAA  $0121
A592 : LDAA  $801A
A595 : BITA  #$10
A597 : BEQ   $A5AD
A599 : LDAA  $01A9			| A = M[$01A9]  - Coolent temp lag filtered
A59C : LSRA  				| A = A / 2
A59D : LDX   #$83A6			| X = 0x83A6
A5A0 : JSR   $FC14
A5A3 : LDAB  $0048
A5A5 : MUL   
A5A6 : ADCA  #$00
A5A8 : STAA  $01D9
A5AB : BRA   $A5B0
A5AD : CLR   $0048
A5B0 : BRCLR $0001,00000100B,$A617
A5B4 : LDAA  $8008
A5B7 : CMPA  #$AA
A5B9 : BNE   $A5C1
A5BB : LDAA  $00DE
A5BD : CMPA  #$10
A5BF : BCS   $A617
A5C1 : BCLR  $0001,00000100B
A5C4 : LDX   $01BE
A5C7 : CPX   $8817
A5CA : BCS   $A617
A5CC : LDX   #$1000
A5CF : BSET  $20,X,00110000B
A5D2 : LDD   $0E,X
A5D4 : ADDD  #$0002
A5D7 : STD   $1A,X
A5D9 : ADDD  $01BE
A5DC : ADDD  $00CD
A5DE : NOP  
A5DF : NOP  
A5E0 : NOP  
A5E1 : NOP  
A5E2 : NOP  
A5E3 : NOP  
A5E4 : BCLR  $20,X,00010000B
A5E7 : STD   $1A,X
A5E9 : BSET  $20,X,11000000B
A5EC : LDD   $0E,X
A5EE : ADDD  #$0002
A5F1 : STD   $18,X
A5F3 : ADDD  $01BE
A5F6 : ADDD  $00CD
A5F8 : NOP  
A5F9 : NOP  
A5FA : NOP  
A5FB : NOP  
A5FC : NOP  
A5FD : NOP  
A5FE : BCLR  $20,X,01000000B
A601 : STD   $18,X
A603 : LDD   $0042
A605 : ADDD  $01BE
A608 : BCC   $A60D
A60A : INC   $0041
A60D : ADDD  $01BE
A610 : BCC   $A615
A612 : INC   $0041
A615 : STD   $0042
A617 : LDX   #$4000
A61A : BSET  $00,X,00000010B
A61D : LDAA  #$55
A61F : STAA  $103A
A622 : LDAA  #$AA
A624 : STAA  $103A
A627 : LDAA  $4006
A62A : ANDA  #$7F
A62C : STAA  $4006
A62F : ORAA  #$80
A631 : STAA  $4006
A634 : LDAA  #$FF
A636 : STAA  $1023
A639 : LDAA  $102E			| Serial Communications Status reg
A63C : LDAA  $102F			| Serial Communications data register
A63F : LDAA  #$26
A641 : STAA  $102D			| Serial Communications Control reg #2
A644 : LDD   $100E
A647 : ADDD  #$0008
A64A : STD   $101C
A64D : LDAA  #$15
A64F : STAA  $1022
A652 : JMP   $CECE
#
# Timer output compare interrupt #4
# 
A655 : LDD   $101C
A658 : ADDD  #$019A
A65B : STD   $101C
A65E : LDAA  #$10
A660 : STAA  $1023
A663 : BRSET $0057,01000000B,$A681
A667 : BSET  $0057,01000000B
A66A : BRSET $006A,00010000B,$A680
A66E : LDAA  $801B
A671 : BITA  #$40
A673 : BEQ   $A680
A675 : BRSET $0070,00000100B,$A67D
A679 : BRSET $0070,00001000B,$A680
A67D : JSR   $F258
A680 : RTI
*
* This seems to be the fuel routine - it appears to be very long.
*   
A681 : BCLR  $0057,01000000B
A684 : LDD   $10FC
A687 : ORAA  #$08
A689 : STD   $10FC
A68C : BRSET $004F,00000010B,$A69C
A690 : BRCLR $0052,00000100B,$A69C
A694 : LDAA  $0049			| A = M[$0049]
A696 : STAA  $01FE			| M[$01FE] = A
A699 : BSET  $004F,00000010B
A69C : BSET  $0052,00000100B
A69F : CLI   
A6A0 : LDAA  $0049			| A = M[$0049]
A6A2 : INCA  				| A = A + 1
A6A3 : STAA  $0049			| M[$0049] = A
A6A5 : CMPA  #$A0			| compare A with 0xA0
A6A7 : BNE   $A6AC			| if (A != 0xA0 ) then goto A6AC
A6A9 : CLR   $0049			| M[$0049] = 0
A6AC : BRCLR $006A,00010000B,$A6B3	| if ( bit 0x10 of M[$006A] is clear) then goto A6B3 (set if ALDL command of 0x01, 0x02, 0x03 was input)
A6B0 : JMP   $F858			| goto F858
A6B3 : TSX   
A6B4 : LDS   #$20FF
A6B7 : CPX   #$20F7
A6BA : BEQ   $A6BF
A6BC : BSET  $004F,00000001B
A6BF : JSR   $F251
A6C2 : LDD   $3FFA
A6C5 : BITA  #$08
A6C7 : BEQ   $A6E3
A6C9 : LDX   $3FC0
A6CC : CPX   #$0088
A6CF : BHI   $A6DC
A6D1 : LDAA  $01F6
A6D4 : INCA  
A6D5 : BEQ   $A6E3
A6D7 : STAA  $01F6
A6DA : BRA   $A6E3
A6DC : BSET  $005C,00000001B
A6DF : BRSET $005A,01000000B,$A6E6
A6E3 : JMP   $A7AA
A6E6 : LDX   $3FC0
A6E9 : BRSET $0050,00000001B,$A6F0
A6ED : LDX   #$FFFF
A6F0 : STX   $007D
A6F2 : BSET  $0050,00000001B
A6F5 : BSET  $0052,10000000B
A6F8 : LDAB  $021C
A6FB : LDAA  #$1F
A6FD : STD   $400E
A700 : CLR   $021A
A703 : BRCLR $003E,11111111B,$A70D
A707 : DEC   $003E
A70A : JMP   $A7AA
A70D : BRCLR $0050,10000000B,$A714
A711 : JMP   $A7AA
A714 : LDAA  $01BD
A717 : INCA  
A718 : BNE   $A71C
A71A : LDAA  #$FF
A71C : STAA  $01BD
A71F : LDAB  $01BC
A722 : ANDB  #$0F
A724 : LDX   #$8657
A727 : BRCLR $0060,00000001B,$A730
A72B : ANDB  #$07
A72D : LDX   #$8667
A730 : ABX   
A731 : LDAA  $01BC
A734 : CMPA  #$0F
A736 : BCS   $A73B
A738 : BSET  $0060,00000001B
A73B : INC   $01BC
A73E : LDD   $009A
A740 : BEQ   $A7AA
A742 : LDAA  $00,X
A744 : BEQ   $A7AA
A746 : LDX   #$009A
A749 : JSR   $FB83			| Routine returns D = AIN (byte)  * M[$X] (word)
A74C : STD   $01BA
A74F : LDD   $0042
A751 : ADDD  $01BA
A754 : BCC   $A759
A756 : INC   $0041
A759 : ADDD  $01BA
A75C : BCC   $A761
A75E : INC   $0041
A761 : STD   $0042
A763 : LDX   #$1000
A766 : BSET  $20,X,00110000B
A769 : BRSET $00,X,00100000B,$A77E
A76D : LDD   $0E,X
A76F : ADDD  #$0002
A772 : STD   $1A,X
A774 : ADDD  $00CD
A776 : NOP  
A777 : NOP  
A778 : NOP  
A779 : NOP  
A77A : NOP  
A77B : NOP  
A77C : BRA   $A780
A77E : LDD   $1A,X
A780 : ADDD  $01BA
A783 : BCLR  $20,X,00010000B
A786 : STD   $1A,X
A788 : BSET  $20,X,11000000B
A78B : BRSET $00,X,01000000B,$A7A0
A78F : LDD   $0E,X
A791 : ADDD  #$0002
A794 : STD   $18,X
A796 : ADDD  $00CD
A798 : NOP  
A799 : NOP  
A79A : NOP  
A79B : NOP  
A79C : NOP  
A79D : NOP  
A79E : BRA   $A7A2
A7A0 : LDD   $18,X
A7A2 : ADDD  $01BA
A7A5 : BCLR  $20,X,01000000B
A7A8 : STD   $18,X
A7AA : BRCLR $0052,10000000B,$A7B7
A7AE : BCLR  $0052,10000000B
A7B1 : BSET  $0051,00000100B
A7B4 : INC   $0257
A7B7 : JSR   $FAC3
A7BA : JSR   $F43B
A7BD : LDAA  $00DA
A7BF : BRSET $0058,00000100B,$A7ED
A7C3 : CMPA  $8411
A7C6 : BCC   $A7ED
A7C8 : LDAB  $0261
A7CB : CMPB  $8414
A7CE : BCC   $A7E5
A7D0 : LDAB  $0127
A7D3 : CMPB  $8412
A7D6 : BCS   $A7E0
A7D8 : LDAB  $0164
A7DB : CMPB  $8413
A7DE : BLS   $A7ED
A7E0 : INC   $0261
A7E3 : BRA   $A7F3
A7E5 : BSET  $0072,00000001B
A7E8 : BSET  $005B,00000010B
A7EB : BRA   $A7F3
A7ED : CLR   $0261
A7F0 : BCLR  $005B,00000010B
A7F3 : BRCLR $005B,00000011B,$A831
A7F7 : LDAA  $8415			| A = M[$8415] (0xD8)
A7FA : BRCLR $0050,10000000B,$A81F	| if ( bit 0x80 of M[$0050] is clear) then goto A81F if (engine is not running (spark)) then goto A81F
A7FE : LDAA  $8416			| A = M[$8416] (0x86)
A801 : LDAB  $0164			| B = M[$0164]  - throttle load axis variable
A804 : MUL   				| D = B * A
A805 : ASLD  				| D = D * 2
A806 : BCS   $A815			| if ( D > 0xFFFF ) then goto A815
A808 : TAB   				| B = A
A809 : LDAA  $0125			| A = M[$0125] 
A80C : LDX   #$8417			| X = 0x8417
A80F : JSR   $FC14			| gosub FC14
A812 : ABA   				| A = A + B
A813 : BCC   $A817			| if ( A <= 0xFF ) then goto A817
A815 : LDAA  #$FF			| A = 0xFF
A817 : CMPA  $8415			| compare A with M[$8415] (0xD8)
A81A : BLS   $A81F			| if ( A <= M[$8415] (0xD8)) then goto A81F
A81C : LDAA  $8415			| A = M[$8415] (0xD8)
A81F : STAA  $015C			| M[$015C] = A
A822 : STAA  $015B			| M[$015B] = A
A825 : STAA  $015D			| M[$015D] = A
A828 : STAA  $015E			| M[$015E] = A
A82B : STAA  $015F			| M[$015F] = A
A82E : JMP   $A89C			| goto A89C
A831 : STAA  $015C			| M[$015C] = A
A834 : BCLR  $0052,00100000B		| clear bit 0x20 of M[$0052]
A837 : LDAB  #$03			| B = 0x03
A839 : MUL   				| D = A * B
A83A : ADDB  $015D			| B = B + M[$015D]
A83D : ADCA  #$00			| A = A + 0 (add carry)
A83F : SUBB  $015E			| B = B - M[$015E] 
A842 : SBCA  #$00			| A = A - 0x00 (subtract carry)
A844 : SUBB  $015F			| B = B - M[$015F]
A847 : SBCA  #$00			| A = A - 0x00 (subtract carry)
A849 : SUBB  $015F			| B = B - M[$015F]
A84C : SBCA  #$00			| A = A - 0x00 (subtract carry)
A84E : SUBB  $015F			| B = B - M[$015F]
A851 : SBCA  #$00			| A = A - 0x00 (subtract carry)
A853 : BPL   $A85C			| if ( A < 0x00 ) then goto A85C
A855 : NEGA  				| A = 0x00 - A
A856 : NEGB  				| B = 0x00 - B
A857 : SBCA  #$00			| A = A - 0x00 (add carry)
A859 : BSET  $0052,00100000B		| set bit 0x20 of M[$0052] (value is negative?)
A85C : ASLD  				| D = D * 2
A85D : ASLD  				| D = D * 2
A85E : ASLD  				| D = D * 2
A85F : PSHB  				| push B
A860 : PSHA  				| push A
A861 : LDX   #$8B22			| X = 0x8B22
A864 : LDAA  $0164			| A = M[$0164]   - Throttle load axis variable
A867 : LDAB  $00,X			| B = M[$X]
A869 : CMPB  #$02			| compare B with 0x02
A86B : BEQ   $A874			| if ( B == 0x02 ) then goto A874
A86D : LDD   $00C4			| D = M[$00C4]
A86F : ASLD  				| D = D * 2
A870 : BCC   $A874			| if ( D < 0xFFFF ) then goto A874
A872 : LDAA  #$FF			| A = 0xFF
A874 : INX   				| X ++
A875 : JSR   $FC14			| gosub FC14 (table lookup)
A878 : TSX   				| X = SP
A879 : JSR   $FB83			| gosub FB83		| Routine returns D = AIN (byte)  * M[$X] (word)
A87C : PULX  				| pull X
A87D : TSTA  				| test A
A87E : BEQ   $A882			| if (A == 0) then goto A882
*
A880 : LDAB  #$FF			| B = 0xFF
*
A882 : PSHB  				| Push B
A883 : BRSET $0052,00100000B,$A891	| if ( bit 0x20 of M[$0052] is set) then goto A891 (value is negative?)
*
A887 : PULA  				| Pull A
A888 : ADDA  $015C			| A = A + M[$015C]
A88B : BCC   $A899			| if ( A > 0xFF ) then goto A899
A88D : LDAA  #$FF			| A = 0xFF
*
A88F : BRA   $A899			| goto A899
*
*
A891 : PULB  				| Pull B
A892 : LDAA  $015C			| A = M[$015C]
A895 : SBA   				| A = A - B
A896 : BCC   $A899			| if ( A >= 0 ) then goto A899
*
A898 : CLRA  				| A = 0
*
A899 : STAA  $015B			| M[$015B] = A
A89C : LDAA  $015B			| A = M[$015B]
A89F : LDAB  $8B21			| B = M[$8B21] (0x28)
A8A2 : LDX   $014E			| X = M[$014E]
A8A5 : JSR   $FB63			| D = X + ( 256 * A - X ) * B
A8A8 : STD   $014E			| M[$014E] = D
A8AB : LDAA  $015E			| M[$015E] = A
A8AE : STAA  $015F			| M[$015F] = A
A8B1 : LDD   $015C			| D = M[$015C]
A8B4 : STD   $015D			| M[$015D] = D
A8B7 : LDD   $014E			| D = M[$014E]
A8BA : LSRD  				| D = D / 2
A8BB : LDX   #$AD82			| X = 0xAD82 
A8BE : FDIV  				| D / X ; X is quotient; D is remainder; value is X/65536
A8BF : XGDX  				| Swap X and D
A8C0 : LSRD  				| D = D / 2
A8C1 : ADCB  #$55			| B = B + 0x55 (LSB)
A8C3 : ADCA  #$0A			| A = A + 0x0A (MSB)
A8C5 : STD   $0154			| M[$0154] = D

A8C8 : LDD   $014E
A8CB : ADDD  #$0080
A8CE : LDAB  #$97
A8D0 : SUBA  #$1A
A8D2 : JSR   $FC61
A8D5 : STAA  $0150
A8D8 : LDAA  $003F
A8DA : SUBA  $014E
A8DD : BCC   $A8E0
A8DF : CLRA  
A8E0 : ADDA  #$1D
A8E2 : BCC   $A8E6
A8E4 : LDAA  #$FF
A8E6 : STAA  $0159
A8E9 : LDD   #$F697
A8EC : SUBA  $0159
A8EF : JSR   $FC61
A8F2 : STAA  $015A
A8F5 : CLRA  
A8F6 : LDAB  $01FF
A8F9 : BEQ   $A912
A8FB : LDAA  $015A			|A = M[$015A]
A8FE : LSRA  				|A = A / 2
A8FF : LDX   #$8D3C			|X = $8D3C
A902 : JSR   $FC14			|gosub FC14
A905 : MUL   				|D = A * B
A906 : PSHB  				|Push B
A907 : PSHA  				|Push A
A908 : TSX   				|X = SP (pointer to D)
A909 : LDAA  $0200			|A = M[$0200]
A90C : JSR   $FB83			|gosub FB83 		| Routine returns D = AIN (byte)  * M[$X] (word)
A90F : PULX  				|Pull X (X = D)
A910 : LSRD 	 			|D = D / 2
A911 : LSRD  				|D = D / 2
A912 : STD   $00C2			|M[$00C2] = D
A914 : ASLD  				|D = D * 2
A915 : ASLD  				|D = D * 2
A916 : ADDD  #$0080			|D = D + 0x0080
A919 : LDAB  #$CD			|B = 0xCD
A91B : MUL   				|D = A * B
A91C : ADCA  #$00			|Add Carry
A91E : TAB   				|B = A
A91F : LDAA  $0150			|A = M[$0150]
A922 : SBA   				|A = A - B
A923 : BCC   $A926			|Branch if carry is clear to A926
A925 : CLRA  				|A = 0
A926 : STAA  $0153			|M[$0153] = A
A929 : LDAA  $00DC			|A = M[$00DC]
A92B : CMPA  #$30			|
A92D : BCC   $A932			|if ( A >= 0x30 ) then goto A932
A92F : LSRA  				|A = A / 2
A930 : BRA   $A944			|goto A944
A932 : CMPA  #$94			|
A934 : BCC   $A93B			|if (A >= 0x94) then goto A93B
A936 : SUBA  #$24			|A = A - 0x24
A938 : ASLA  				|A = A * 2
A939 : BRA   $A944			|goto A944
A93B : CMPA  #$C4			|
A93D : BLS   $A941			|if (A <= 0xC4) then goto A941
A93F : LDAA  #$C4			|A = 0xC4
A941 : LSRA  				|A = A / 2
A942 : ADDA  #$96			|A = A + 0x96
A944 : LDX   #$8699			|X = 0x8699
A947 : JSR   $FC09			|gosub FC09
A94A : STAA  $00CC			|M[$00CC] = A
A94C : TAB   				| B = A
A94D : CLRA  				| A = 0
A94E : ASLD  				| D = D * 2
A94F : ASLD  				| D = D * 2
A950 : STD   $00CD			| M[$00CD] = D
*
* $00CD calculation - added to injector pulsewidths.
*
A952 : BRSET $0050,10000000B,$A959
A956 : JMP   $ABEB
A959 : BRSET $0002,00100000B,$A965
A95D : LDAA  $01F4
A960 : CMPA  $8014
A963 : BCC   $A9A4
A965 : BRSET $004F,00010000B,$A9A4
A969 : BRSET $0060,00000010B,$A9A4
A96D : LDX   #$868A
A970 : BRCLR $0060,01000000B,$A977
A974 : LDX   #$8691
A977 : LDAA  $00CF
A979 : CMPA  $00,X
A97B : BHI   $A990
A97D : BRSET $0067,00100000B,$A989
A981 : INX   
A982 : INX   
A983 : BRSET $0067,10000000B,$A989
A987 : INX   
A988 : INX   
A989 : LDD   $007D
A98B : CPD   $01,X
A98E : BCC   $A99D
A990 : LDAA  $0164
A993 : CMPA  $8698
A996 : BLS   $A99D
A998 : BSET  $0060,01000000B
A99B : BRA   $A9A4
A99D : BCLR  $0060,01000000B
A9A0 : BRCLR $005C,00000110B,$A9C4
A9A4 : LDD   #$0000			| X = 0x0000
A9A7 : STD   $0092			
A9A9 : STD   $0096
A9AB : STD   $0098
A9AD : STD   $009A
A9AF : STD   $009C			| M[$009C] = D   - Save D to left injector pulsewidth
A9B1 : STD   $009E
A9B3 : STD   $00A0
A9B5 : STD   $00A2
A9B7 : STD   $00A4
A9B9 : STD   $00A6
A9BB : STD   $00A8			| M[$00A8] = D  - Save D to right injector pulsewidth
A9BD : STD   $00AA
A9BF : STD   $00AC
A9C1 : JMP   $ABEB
A9C4 : LDAB  $0153			| B = M[$0153]  ( MAP pressure?)
A9C7 : LDAA  $0124			| A = M[$0124]  ( RPM / 12.5 )
A9CA : CMPA  #$A0			| if ( A > 0xA0 (2000 rpm)) then goto A9D9
A9CC : BCC   $A9D9			| branch if carry clear
A9CE : LDX   #$8B38			| X = 0x8B38
A9D1 : SUBA  #$20			| A = A - 0x20  (subtract 400 rpm)
A9D3 : BCC   $A9D6			| if ( A > 0 ) then goto A9D6
A9D5 : CLRA  				| A = 0
A9D6 : ASLA  				| A = A * 2  (A =((RPM-400)/6.25))
A9D7 : BRA   $A9F0			| goto A9F0
A9D9 : LDX   #$8C5C			| X = $8C5C
A9DC : LDAA  $0122			| A = M[$0122] ( RPM odd scaling )
A9DF : SUBA  #$80			| A = A - 0x80
A9E1 : CMPA  #$60			| if ( A <= 0x60 ) then goto A9F0
A9E3 : BLS   $A9F0			| branch if less than or same to A9F0
A9E5 : LDAA  $0125			| A = M[$0125] ( rpm / 31.25)
A9E8 : SUBA  #$20			| A = A - 0x20
A9EA : CMPA  #$C0			| if ( A <= 0xC0 ) then goto A9F0 
A9EC : BLS   $A9F0			| branch if less than or same to A9F0
A9EE : LDAA  #$C0			| A = 0xC0
A9F0 : JSR   $FB97			| gosub FB97
A9F3 : STAA  $00BC
A9F5 : LDAB  $0162
A9F8 : MUL   
A9F9 : ASLD  
A9FA : BCS   $AA01
A9FC : ADDD  #$0080			| D = D + 0x0080
A9FF : BCC   $AA03			| if ( D did not roll over ) then goto AA03
AA01 : LDAA  #$FF			| A = 0xFF
AA03 : LDAB  $0164			| B = M[$0164]  (throttle load axis variable)
AA06 : CMPB  $8B36			| compare B with M[$8B36] (0x03)
AA09 : BCC   $AA13			| if ( B > M[$8B36] (0x03) ) then goto AA13
AA0B : LDAB  $0123			| B = M[$0123]  ( engine rpm )
AA0E : CMPB  $8B35			| compare B with M[$8B35] (0x30) ( 1200 rpm )
AA11 : BLS   $AA16			| if ( B (engine rpm ) <= 0x30 (1200rpm)) then goto AA16
AA13 : CLRB  				| B = 0
AA14 : BRA   $AA20			| goto AA20
AA16 : LDX   $00BA			| X = M[$00BA] (engine rpm lag filtered)
AA18 : BEQ   $AA20			| if ( X == 0 ) then goto AA20
AA1A : LDAB  $8B37			| B = M[$8B37] (0x06) 
AA1D : JSR   $FB63			| D = X + ( 256 * A - X ) * B
AA20 : STD   $00BA			| M[$00BA] = D
AA22 : LDX   $0237
AA25 : LDD   $0154
AA28 : SUBD  $00C2
AA2A : BCC   $AA2F
AA2C : LDD   #$0000
AA2F : FDIV  
AA30 : PSHX  
AA31 : TSX   
AA32 : LDAA  $8B34			| A = M[$8B34] - cylinder volume?
AA35 : JSR   $FB83			| Routine returns D = AIN (byte)  * M[$X] (word)
AA38 : PULX  
AA39 : STD   $00B8
AA3B : LDD   $00BA
AA3D : ADDD  #$0080
AA40 : LDX   #$00B8
AA43 : JSR   $FB83			| Routine returns D = AIN (byte)  * M[$X] (word)
AA46 : STD   $008C	
AA48 : LDD   $008C
AA4A : LDX   $007D			| X = M[$007D]
AA4C : IDIV				| D / X ; X = quotient ; D = remainder  
AA4D : PSHX  				| push X
AA4E : LDX   $007D			| X = M[$007D] (current minor loop reference period)
AA50 : FDIV  				| D / X ; X is quotient; D is remainder; value is X/65536
AA51 : XGDX  				| Swap X and D
AA52 : TAB   				| B = A
AA53 : PULA  				| pull A
AA54 : TSTA  				| test A
AA55 : PULA  				| pull A
AA56 : BNE   $AA5B			| if ( A != 0 ) then goto AA5B
AA58 : ASLD  				| D = D * 2
AA59 : BCC   $AA5E			| if ( D <= 0xFFFF ) then goto AA5E
AA5B : LDD   #$FFFF			| D = 0xFFFF
AA5E : STD   $00C4			| M[$00C4] = D
*
* Injector divisor calc.
*
AA60 : LDX   $01AE			| X = M[$01AE]
AA63 : LDD   $008C			| D = M[$008C]
AA65 : LSRD  				| D = D / 2
AA66 : LSRD  				| D = D / 2
AA67 : FDIV  				| D / X ; X = quotient ; D = remainder
AA68 : XGDX  				| Swap D and X
AA69 : LDX   $867C			| X = M[$867C]  (0x0C4E)
AA6C : IDIV  				| D / X ; X = quotient ; D = remainder
AA6D : PSHX  				| push X
AA6E : LDX   $867C			| X = M[$867C]  (0x0C4E)
AA71 : FDIV  				| D / X ; X = quotient ; D = remainder
AA72 : XGDX  				| Swap D and X
AA73 : TAB   				| B = A
AA74 : PULA  				| Pull A
AA75 : TSTA  				| test A
AA76 : PULA  				| Pull A
AA77 : BEQ   $AA7C			| if  ( A == 0 ) then goto AA7C
AA79 : LDD   #$FFFF			| D = 0xFFFF
AA7C : STD   $008E			| M[$008E] = D
AA7E : LDX   #$008E			| X = 0x008E
AA81 : LDAA  $019E			| A = M[$019E]
AA84 : JSR   $FB83			| Routine returns D = AIN (byte)  * M[$X] (word)
AA87 : STD   $0090			| D = M[$0090]
AA89 : LDAA  $025A			| A = M[$025A]
AA8C : BRCLR $005F,00000010B,$AAA0	| if ( bit 0x02 of M[$005F] is clear ) then goto AAA0
AA90 : BRCLR $005F,00000100B,$AAA0	| if ( bit 0x04 of M[$005F] is clear ) then goto AAA0
AA94 : SUBA  $025D			| A = A - M[$025D]
AA97 : BCC   $AA9D			| if ( A >= 0 ) then goto AA9D
AA99 : CLRA  				| A = 0
AA9A : BCLR  $005F,00001000B		| clear bit 0x08 of M[$005F]
AA9D : STAA  $025A			| M[$025A] = A
AAA0 : BCLR  $005F,00000100B		| clear bit 0x04 of M[$005F]
AAA3 : BSET  $005F,00000010B		| set bit 0x02 of M[$005F]
*
* This calc is used in both left and right injectors.
*
AAA6 : LDX   #$0090			| X = 0x0090
AAA9 : JSR   $FB83			| Routine returns D = AIN (byte)  * M[$X] (word)
AAAC : ADDD  $0090			| D = D + M[$0090]
AAAE : BCC   $AAB3			| if ( D <= 0xFFFF ) then goto AAB3
AAB0 : LDD   #$FFFF			| D = 0xFFFF
AAB3 : STD   $0092			| M[$0092] = D
AAB5 : ASLD  				| D = D * 2
AAB6 : BCC   $AABB			| if ( D <= 0xFFFF ) then goto AABB
AAB8 : LDD   #$FFFF			| D = 0xFFFF
AABB : STD   $0094			| M[$0094] = D
*
* Left injector calc part.
*
AABD : LDX   #$0094			| X = 0x0094
AAC0 : LDAA  $0147			| A = M[$0147]  - Left Block Learn Multiplier
AAC3 : PSHA  				| push A
AAC4 : LDAB  $01,X			| B = M[$(X+0x01)]
AAC6 : MUL   				| D = A * B    - LeftBLM * B
AAC7 : ADCA  #$00			| A = A + 0x00 (add carry)
AAC9 : PULB  				| pull B
AACA : PSHA  				| push A
AACB : LDAA  $00,X			| A = M[$X]
AACD : MUL   				| D = A * B
AACE : TSX   				| X = SP
AACF : ADDB  $00,X			| B = B + M[$X]
AAD1 : ADCA  #$00			| A = A + 0x00 (add carry)
AAD3 : INS   				| SP ++ (remove byte off stack)
AAD4 : STD   $0096			| M[$0096] = D
*
* Right injector calc part
*
AAD6 : LDX   #$0094			| X = 0x0094
AAD9 : LDAA  $0148			| A = M[$0148]  - Right Block Learn Multiplier
AADC : PSHA  				| push A
AADD : LDAB  $01,X			| B = M[$(X+0x01)]
AADF : MUL   				| D = B * A
AAE0 : ADCA  #$00			| A = A + 0x00 (add carry)
AAE2 : PULB  				| pull B
AAE3 : PSHA  				| push A
AAE4 : LDAA  $00,X			| A = M[$X]
AAE6 : MUL   				| D = B * A
AAE7 : TSX   				| X = SP
AAE8 : ADDB  $00,X			| B = B + M[$X]
AAEA : ADCA  #$00			| A = A + 0x00 (add carry)
AAEC : INS   				| SP ++
AAED : STD   $00A2			| M[$00A2] = D
*
* Right injector calc part.
*
AAEF : LDAA  $0145			| A = M[$0145] - 
AAF2 : SUBA  #$80			| A = A - 0x80
AAF4 : BCC   $AB06			| if ( A >= 0x00 ) then goto AB06
AAF6 : NEGA  				| A = -A
AAF7 : LDX   #$00A2			| X = 0x00A2
AAFA : JSR   $FB83			| Routine returns D = AIN (byte)  * M[$X] (word)
AAFD : LSRD  				| D = D / 2
AAFE : STD   $00CA			| M[$00CA] = D
AB00 : LDD   $00A2			| D = M[$00A2]
AB02 : SUBD  $00CA			| D = D - M[$00CA]
AB04 : BRA   $AB11			| goto AB11
AB06 : LDX   #$00A2			| X = 0x00A2
AB09 : JSR   $FB83			| Routine returns D = AIN (byte)  * M[$X] (word)
AB0C : LSRD  				| D = D / 2
AB0D : STD   $00CA			| M[$00CA] = D
AB0F : ADDD  $00A2			| D = D + M[$00A2]
AB11 : STD   $00A4			| M[$00A4] = D
*
* Left injector calc. part.
*
AB13 : LDAA  $0146			| A = M[$0146]
AB16 : SUBA  #$80			| A = A - 0x80
AB18 : BCC   $AB2A			| if ( A >= 0x00 ) then goto AB2A
AB1A : NEGA  				| A = -A
AB1B : LDX   #$0096			| X = 0x0096
AB1E : JSR   $FB83			| Routine returns D = AIN (byte)  * M[$X] (word)
AB21 : LSRD  				| D = D / 2
AB22 : STD   $00C8			| M[$00C8] = D
AB24 : LDD   $0096			| D = M[$0096]
AB26 : SUBD  $00C8			| D = D - M[$00C8]
AB28 : BRA   $AB35			| goto AB35
AB2A : LDX   #$0096			| X = 0x0096
AB2D : JSR   $FB83			| Routine returns D = AIN (byte)  * M[$X] (word)
AB30 : LSRD  				| D = D / 2
AB31 : STD   $00C8			| M[$00C8] = D
AB33 : ADDD  $0096			| D = D + M[$0096]
AB35 : STD   $0098			| M[$0098] = D
*
*  Left injector routine
*
AB37 : LDX   $0098			| X = M[$0098]
AB39 : CPX   #$0100			| compare X with 0x0100
AB3C : BHI   $AB59			| if ( X > 0x0100 ) then goto AB59
AB3E : XGDX  				| Swap X AND D
AB3F : SUBD  #$0040			| D = D - 0x0040
AB42 : BCC   $AB45			| if ( D < 0x00 ) then goto AB45
AB44 : CLRB  				| B = 0x00
AB45 : LSRB  				| B = B / 2
AB46 : LSRB  				| B = B / 2
AB47 : LSRB  				| B = B / 2
AB48 : LDX   #$86BA			| X = 0x86BA
AB4B : ABX   				| X = X + B
AB4C : LDAB  $00,X			| B = M[$X]
AB4E : LDX   $0098			| X = M[$0098]
AB50 : ABX   				| X = X + B
AB51 : CPX   $8685			| compare X with M[$8685] (0x0000)
AB54 : BHI   $AB59			| if ( X > M[$8685] (0x0000) ) then goto AB59
AB56 : LDX   $8687			| X = M[$8687] (0x0000)
AB59 : STX   $009A			| M[$009A] = X
AB5B : XGDX  				| Swap D and X
AB5C : ADDD  $00CD			| D = D + M[$00CD]
AB5E : STD   $009C			| M[$009C] = D   - Save D to left injector pulsewidth
*
* Right injector code
*
AB60 : LDX   $00A4			| X = M[$00A4]
AB62 : CPX   #$0100			| compare X with 0x0100
AB65 : BHI   $AB82			| if ( X > 0x0100 ) then goto AB82
AB67 : XGDX  				| Swap X and D
AB68 : SUBD  #$0040			| D = D - 0x40
AB6B : BCC   $AB6E			| if ( D > 0 ) then goto AB6E
AB6D : CLRB  				| B = 0
AB6E : LSRB  				| B = B / 2
AB6F : LSRB  				| B = B / 2
AB70 : LSRB  				| B = B / 2
AB71 : LDX   #$86BA			| X = 0x86BA
AB74 : ABX   				| X = X + B
AB75 : LDAB  $00,X			| B = M[$X]
AB77 : LDX   $00A4			| X = M[$00A4]
AB79 : ABX   				| X = X + B
AB7A : CPX   $8685			| compare X to M[$8685] (0x0000)
AB7D : BHI   $AB82			| if ( X > M[$8685] (0x0000)) then goto AB82
AB7F : LDX   $8687			| X = M[$8687]  (0x0000)
AB82 : STX   $00A6			| M[$00A6] = X
AB84 : XGDX  				| Swap X and D
AB85 : ADDD  $00CD			| D = D + M[$00CD]
AB87 : STD   $00A8			| M[$00A8] = D   - Save D to left injector Pulsewidth
* Injectors stuff appears to be done?
*
*
AB89 : LDAA  $8677			| A = M[$8677]  (0x80)
AB8C : CLRB  				| B = 0x00
AB8D : XGDX  				| Swap X and D
AB8E : LDD   $00A4			| D = D + M[$00A4]
AB90 : FDIV  				| X (quot) = D / X ; D is remainder
AB91 : STX   $00AA			| M[$00AA] = X
AB93 : LDAA  $8677			| A = M[$8677]  (0x80)
AB96 : CLRB  				| B = 0x00
AB97 : XGDX  				| Swap X and D
AB98 : LDD   $0098			| D = M[$0098]
AB9A : FDIV  				| X (quot) = D / X ; D is remainder
AB9B : STX   $009E			| M[$009E] = D
AB9D : LDX   $009E			| X = M[$009E] 
AB9F : CPX   #$0100			| compare X with 0x0100
ABA2 : BHI   $ABBF			| if ( X > 0x0100 ) then goto ABBF
ABA4 : XGDX  				| swap D and X
ABA5 : SUBD  #$0040			| D = D - 0x0040
ABA8 : BCC   $ABAB			| if ( X >= 0x0000 ) then goto ABAB
ABAA : CLRB  				| B = 0
ABAB : LSRB  				| B = B * 2
ABAC : LSRB  				| B = B * 2
ABAD : LSRB  				| B = B * 2
ABAE : LDX   #$86BA			| X = 0x86BA
ABB1 : ABX   				| X = X + B
ABB2 : LDAB  $00,X			| B = M[$X]
ABB4 : LDX   $009E			| X = M[$009E]
ABB6 : ABX   				| X = X + B
ABB7 : CPX   $8685			| compare X with M[$8685] (0x00)
ABBA : BHI   $ABBF			| if ( A > 0x00 ) then goto ABBF
ABBC : LDX   $8687			| X = 0x00
ABBF : XGDX  				| Swap D and X
ABC0 : ADDD  $00CD			| D = D + M[$00CD]
ABC2 : STD   $00A0			| M[$00A0] = D
ABC4 : LDX   $00AA			| X = M[$00AA]
ABC6 : CPX   #$0100			| compare X with 0x0100
ABC9 : BHI   $ABE6			| if ( X > 0x0100 ) then goto ABE3
ABCB : XGDX  				| swap X and D
ABCC : SUBD  #$0040			| D = D - 0x0040
ABCF : BCC   $ABD2			| if ( D <= 0x00 ) then goto ABD2
ABD1 : CLRB  				| B = 0
ABD2 : LSRB  				| B = B / 2
ABD3 : LSRB  				| B = B / 2
ABD4 : LSRB  				| B = B / 2
ABD5 : LDX   #$86BA			| X = 0x86BA
ABD8 : ABX   				| X = X + B
ABD9 : LDAB  $00,X			| D = M[$X]
ABDB : LDX   $00AA			| X = M[$00AA]
ABDD : ABX   				| X = X + B
ABDE : CPX   $8685			| compare X with M[$8685] (0x00)   <---- coding error should be M[$8687] maybe?
ABE1 : BHI   $ABE6			| if ( A > 0x00 ) then goto ABE6
ABE3 : LDX   $8687			| X = M[$8687]
ABE6 : XGDX  				| swap X and D
ABE7 : ADDD  $00CD			| D = D + M[$00CD]
ABE9 : STD   $00AC			| M[$00AC] = D
ABEB : SEI   				| set interrupts
ABEC : LDAA  $004A
ABEE : STAA  $4000				
ABF1 : LDAA  $4002
ABF4 : ANDA  #$DE
ABF6 : LDAB  $004B
ABF8 : ANDB  #$21
ABFA : ABA   
ABFB : TAB   
ABFC : ANDA  #$31
ABFE : STAA  $4002				| M[$4002] = A
AC01 : STAB  $004B				| M[$004B] = A
AC03 : LDAA  $4004				| A = 0x4004
AC06 : STAA  $004C				| M[$004C] = A
AC08 : CLI   
AC09 : BCLR  $0057,00010000B			| Clear A/C requested bit A/C is not requested (1 is requested)
AC0C : LDAB  $801B
AC0F : BITB  #$01
AC11 : BEQ   $AC19
AC13 : BRSET $004C,01000000B,$AC20		| A/C is not requested, requested is 0
AC17 : BRA   $AC1D				| A/C is requested
AC19 : BRCLR $004B,01000000B,$AC20		| D, R Car A/C Request is not set
AC1D : BSET  $0057,00010000B
AC20 : BCLR  $0066,10000000B			| 
AC23 : LDAA  $801B
AC26 : BITA  #$04
AC28 : BNE   $AC30
AC2A : BRCLR $004C,00000100B,$AC34		| Branch if car is in 4th gear (0 is in 4th gear)
AC2E : BRA   $AC37
AC30 : BRCLR $004C,00000100B,$AC37		| Branch if car is in 4th gear (0 is in 4th gear)
AC34 : BSET  $0066,10000000B			| Set bit that indicates in fourth gear
AC37 : LDAA  $004D
AC39 : STAA  $4007
AC3C : LDAA  $1000
AC3F : STAA  $0213
AC42 : LDD   $10F0
AC45 : STAB  $0214
AC48 : LDD   $3FC0
AC4B : STD   $0215
AC4E : BRSET $0068,00100000B,$AC55
AC52 : JMP   $AD10
AC55 : LDAA  $02AC
AC58 : CMPA  #$0A
AC5A : BNE   $AC8F
AC5C : BRSET $0052,00000010B,$AC92
AC60 : BSET  $0052,00000010B
AC63 : BCLR  $005A,01000000B			| Clear MALF 36 indicated and latched (hi ref failure) bit
AC66 : BCLR  $005B,10000000B
AC69 : BCLR  $0059,01000000B
AC6C : CLR   $01E9
AC6F : CLR   $01EA
AC72 : CLR   $01EB
AC75 : CLR   $01F7
AC78 : CLR   $01F8				
AC7B : BCLR  $0051,00100000B			| Clear A/D disabled due to compressor fault detected bit
AC7E : LDD   #$0000				| Load D with 0x0000
AC81 : STD   $0003				| Clear many codes bits 0x0003,0x0004
AC83 : STD   $0005				| Clear many more code bits 0x0005, 0x0006
AC85 : STAA  $0007				| Clear the last code byte 0x0007
AC87 : LDD   #$0001				
AC8A : STD   $0011
AC8C : JMP   $AD1F
AC8F : BCLR  $0052,00000010B
AC92 : LDAA  $02AC
AC95 : CMPA  #$04
AC97 : BNE   $AD10
AC99 : LDD   $02BE
AC9C : BNE   $AD10
AC9E : BSET  $006A,00001000B
ACA1 : LDX   #$02AF
ACA4 : BRCLR $00,X,01000000B,$ACDA
ACA8 : BRSET $006A,00000001B,$ACDD
ACAC : BSET  $006A,00000001B
ACAF : BCLR  $005A,01000000B			| Clear MALF 36 - Indicated and latched (HI Ref fault)
ACB2 : BCLR  $005B,10000000B
ACB5 : BCLR  $0059,01000000B
ACB8 : CLR   $01E9
ACBB : CLR   $01EA
ACBE : CLR   $01EB
ACC1 : CLR   $01F7
ACC4 : CLR   $01F8
ACC7 : BCLR  $0051,00100000B			| Clear A/C enabled due to compressor fault.
ACCA : LDD   #$0000
ACCD : STD   $0003
ACCF : STD   $0005
ACD1 : STAA  $0007
ACD3 : LDD   #$0001
ACD6 : STD   $0011
ACD8 : BRA   $ACDD
ACDA : BCLR  $006A,00000001B
ACDD : BRCLR $00,X,00100000B,$ACF1
ACE1 : BRSET $006A,00000010B,$ACF4
ACE5 : BSET  $006A,00000010B
ACE8 : BSET  $0070,00000100B
ACEB : LDAB  #$FF
ACED : STAB  $003B
ACEF : BRA   $ACF4
ACF1 : BCLR  $006A,00000010B
ACF4 : BRCLR $00,X,00010000B,$AD0B
ACF8 : BRSET $006A,00000100B,$AD1F
ACFC : BSET  $006A,00000100B
ACFF : LDAA  #$80
AD01 : LDX   #$0026
AD04 : STAA  $14,X
AD06 : DEX   
AD07 : BNE   $AD04
AD09 : BRA   $AD1F
AD0B : BCLR  $006A,00000100B
AD0E : BRA   $AD1F
AD10 : BRCLR $006A,00001000B,$AD1F
AD14 : LDAA  $02AC
AD17 : BNE   $AD1F
AD19 : BCLR  $006A,00001111B
AD1C : BCLR  $0052,00000010B
AD1F : LDAA  $0049
AD21 : BEQ   $AD26
AD23 : JMP   $ADA5
AD26 : BRCLR $0050,10000000B,$AD3A		| Branch if engine is not running (spark) to $AD3A
AD2A : LDX   $0013
AD2C : INX   
AD2D : BEQ   $AD31
AD2F : STX   $0013
AD31 : LDX   $020D
AD34 : INX   
AD35 : BEQ   $AD3A
AD37 : STX   $020D
AD3A : LDAA  $0217
AD3D : BEQ   $AD43
AD3F : DECA  
AD40 : STAA  $0217
AD43 : LDAA  $02B9
AD46 : INCA  
AD47 : BEQ   $AD50
AD49 : STAA  $02B9
AD4C : CMPA  #$05
AD4E : BCS   $AD73
AD50 : CLR   $02AC
AD53 : BCLR  $0068,00100000B
AD56 : BCLR  $0053,01000000B
AD59 : BCLR  $0052,00000010B
AD5C : BCLR  $006A,01001111B
AD5F : LDX   #$4002
AD62 : BCLR  $00,X,00010000B
AD65 : LDAA  #$26
AD67 : STAA  $102D				| Serial communications Control Reg #2
AD6A : LDD   #$0000				| Load D with 0x0000
AD6D : STD   $0288				| Clear SCI variables - address of next pointer to output
AD70 : STD   $0286				| Clear more SCI variables - num bytes, and checksum.
AD73 : BRCLR $006A,00001000B,$AD8E
AD77 : LDX   $02BC
AD7A : INX   
AD7B : STX   $02BC
AD7E : CPX   $8B1D
AD81 : BCS   $ADA5
AD83 : BCLR  $006A,00001000B
AD86 : LDX   #$0001
AD89 : STX   $02BE
AD8C : BRA   $ADA5
AD8E : LDX   $02BE
AD91 : BEQ   $ADA5
AD93 : INX   
AD94 : STX   $02BE
AD97 : CPX   $8B1F
AD9A : BCS   $ADA5
AD9C : LDD   #$0000
AD9F : STD   $02BE
ADA2 : STD   $02BC
ADA5 : LDX   $0254			| X = M[$0254]
ADA8 : LDAA  $0164			| A = M[$0164]  - Load A with throttle load axis variable
ADAB : LDAB  $8819			| B = M[$8819]  (0x24)
ADAE : JSR   $FB63   			| gosub FB63  - D = X + ( 256 * A - X ) * B
ADB1 : CMPA  $0164			| Compare A with M[$0164] - throttle load axis variable
ADB4 : BLS   $ADB9			| if ( A < M[$0164] (% throttle ) ) then goto ADB9
ADB6 : LDAA  $0164			| A = M[$0164]  - Load A with throttle load axis variable
ADB9 : STD   $0254			| M[$0254] = D
ADBC : LDAA  $0164			| A = M[$0164] - Load A with throttle load axis variable
ADBF : SUBA  $0254			| A = A - M[$0254]
ADC2 : STAA  $0252			| M[$0252] = A
ADC5 : BRCLR $0050,10000000B,$AE10	| if ( bit 0x80 of M[$0050] is clear) then goto AE10  - Branch if engine is not Running to AE10
ADC9 : LDAA  $0058
ADCB : BITA  #$24
ADCD : BNE   $AE10
ADCF : BRCLR $005F,10000000B,$AE08
ADD3 : LDAB  $0257
ADD6 : CMPB  $881B
ADD9 : BCC   $AE10
ADDB : LDAA  $0164			| Load A with throttle Load axis variable
ADDE : SUBA  $0165
ADE1 : BCC   $ADEB
ADE3 : COMA  
ADE4 : CMPA  $8823
ADE7 : BCC   $AE10
ADE9 : BRA   $ADFE
ADEB : CMPA  $8821
ADEE : BLS   $ADFE
ADF0 : LDAA  $8822
ADF3 : CMPA  $0256
ADF6 : BCC   $ADFB
ADF8 : STAA  $0256
ADFB : CLR   $0257
ADFE : LDAA  $0252
AE01 : CMPA  $8820
AE04 : BLS   $AE10
AE06 : BRA   $AE26
AE08 : LDAA  $0252
AE0B : CMPA  $881A
AE0E : BHI   $AE1C
AE10 : CLR   $0256
AE13 : CLR   $0257
AE16 : BCLR  $005F,10000000B
AE19 : JMP   $AE99
AE1C : CLR   $0257
AE1F : LDD   $00B6
AE21 : ADDD  $8815
AE24 : STD   $00B6
AE26 : BSET  $005F,10000000B		
AE29 : LDX   #$0092
AE2C : LDAA  $881F
AE2F : JSR   $FB83			| Routine returns D = AIN (byte)  * M[$X] (word)
AE32 : STD   $0258
AE35 : LDAA  $881C
AE38 : CMPA  $0252
AE3B : BCS   $AE40
AE3D : LDAA  $0252
AE40 : LDAB  $0163
AE43 : MUL   
AE44 : PSHB  
AE45 : PSHA  
AE46 : LDAA  $0252
AE49 : ASLA  
AE4A : BCC   $AE4E
AE4C : LDAA  #$FF
AE4E : LDX   #$882C
AE51 : JSR   $FC14
AE54 : TSX   
AE55 : JSR   $FB83			| Routine returns D = AIN (byte)  * M[$X] (word)
AE58 : PULX  
AE59 : LSRD  
AE5A : ADDD  $0258
AE5D : PSHB  
AE5E : PSHA  
AE5F : LDAB  $0256
AE62 : INC   $0256
AE65 : CMPB  #$07
AE67 : BLS   $AE6B
AE69 : LDAB  #$07
AE6B : LDX   #$8824
AE6E : ABX   
AE6F : LDAA  $00,X
AE71 : TSX   
AE72 : JSR   $FB83			| Routine returns D = AIN (byte)  * M[$X] (word)
AE75 : PULX  
AE76 : ASLD  
AE77 : ASLD  
AE78 : BCC   $AE7D
AE7A : LDD   #$FFFF
AE7D : STD   $00B4
AE7F : LDAA  $0253
AE82 : LDX   #$00B4
AE85 : JSR   $FB83			| Routine returns D = AIN (byte)  * M[$X] (word)
AE88 : ASLD  
AE89 : BCC   $AE8E
AE8B : LDD   #$FFFF
AE8E : STD   $00B4
AE90 : ADDD  $00B6
AE92 : BCC   $AE97
AE94 : LDD   #$FFFF
AE97 : STD   $00B6
AE99 : LDAA  $0164			| Load A with throttle Load axis variable
AE9C : STAA  $0165
AE9F : JSR   $F4C7
AEA2 : LDX   #$8018
AEA5 : BRCLR $00,X,00010000B,$AECD
AEA9 : BRCLR $02,X,01000000B,$AEB3
AEAD : BRSET $0002,00100000B,$AECD	| branch if Fuel enabled via feds or frequency bit set to AECD
AEB1 : BRA   $AED5
AEB3 : LDD   $3FC4
AEB6 : PSHB  
AEB7 : PSHA  
AEB8 : SUBD  $020B
AEBB : PULX  
AEBC : BEQ   $AED5
AEBE : STX   $020B
AEC1 : CPD   $8010
AEC5 : BHI   $AED5
AEC7 : CPD   $8012
AECB : BCS   $AED5
AECD : BSET  $0002,00100000B		| Set fuel enabled via feds or frequency bit
AED0 : CLR   $01F4
AED3 : BRA   $AEFC
AED5 : LDAA  $01F4
AED8 : BRSET $0049,00000001B,$AEE2 	| if ( bit 0x01 of M[$0049] is set) then goto AEE2	
AEDC : INCA  
AEDD : BEQ   $AEE2
AEDF : STAA  $01F4
AEE2 : LDAA  $01F4
AEE5 : CMPA  $8438
AEE8 : BLS   $AEFC
AEEA : LDX   #$83CB
AEED : BRCLR $00,X,00000010B,$AEFC	
AEF1 : BSET  $0005,00000010B		| Set Fuel Enable Failure bit
AEF4 : CLR   $0010
AEF7 : JSR   $FAB5
AEFA : STD   $0011
AEFC : LDAA  $00CF			| Load A with Vehicle Speed
AEFE : CMPA  $801E			| Compare A with 0x801E which is byte 0x00
AF01 : BHI   $AF0D      		| Branch if higher than 0x00 to 0xAF0D
AF03 : CMPA  $801F			| Compare A with 0x801F which is byte 0x00
AF06 : BCC   $AF10      		| branch if greater than 0x00 to 0xAF10
AF08 : BSET  $0051,00010000B    	| Set reverse inhibit bit - Enables reverse
AF0B : BRA   $AF10			| goto AF10
AF0D : BCLR  $0051,00010000B    	| Clear reverse inhibit bit - Reverse inhibited
AF10 : LDX   #$0000			| X = 0x0000
AF13 : BRCLR $0050,10000000B,$AF1D      | Branch to AF1D if engine is running to AF1D
AF17 : LDD   #$000F			 
AF1A : LDX   $007D
AF1C : FDIV  
AF1D : STX   $012F
AF20 : LDAA  $8018
AF23 : BITA  #$01
AF25 : BNE   $AF2A
AF27 : JMP   $AFE0
AF2A : BRSET $0066,00100000B,$AF67	| Branch if 1-2 upshift in progress to AF67
AF2E : BRCLR $0066,01000000B,$AF35	| Branch if 2-3 upshift is not in progress to AF35
AF32 : JMP   $AFA1
AF35 : BRCLR $004C,00001000B,$AF84	| Branch if not in low, 3rd or 4th gear to AF84
AF39 : BRSET $004E,00001000B,$AF6C
AF3D : LDAA  $0164			| A = M[$0164] - throttle load axis variable
AF40 : CMPA  $82EB			| compare A with M[$82EB] 
AF43 : BLS   $AF84			| if ( A < M[$82EB] ) then goto AF84
AF45 : LDAA  $0123			|A = M[$0123] - Engine speed - rpm = value * 25
AF48 : CMPA  $82EA			|Compare with 82EA value is 0xC0 (4800 rpm?)
AF4B : BLS   $AF84			|if ( A <= M[$82EA] (Value is 0xC0 - 4800 rpm)) then goto AF84
AF4D : SUBA  #$B8			|A = A - 0xB8 ( subtract 4600 rpm)
AF4F : BCC   $AF52			|if ( A >= 0) then goto AF52
AF51 : CLRA  				|A = 0
AF52 : ASLA  				|A = A * 2
AF53 : LDX   #$82F6			|X = 0x82F6
AF56 : JSR   $FC14			|gosub FC14
AF59 : SUBA  $0160
AF5C : BCC   $AF5F
AF5E : CLRA  
AF5F : STAA  $00FF
AF61 : BSET  $0066,00100000B		| sets 1-2 upshift in progress.
AF64 : CLR   $0210
AF67 : LDX   #$82EE
AF6A : BRA   $AFA4
AF6C : BRCLR $004C,00000010B,$AF84
AF70 : BRSET $004E,00000010B,$AF84
AF74 : LDAA  $0164
AF77 : CMPA  $82ED
AF7A : BLS   $AF84
AF7C : LDAA  $0123			|A = M[$0123]
AF7F : CMPA  $82EC			|
AF82 : BHI   $AF87			|If ( A <= M[$82EC) then goto AFDD
AF84 : JMP   $AFDD			|
AF87 : SUBA  #$B8			|A = A - 0xB8
AF89 : BCC   $AF8C			|if ( A < 0) then A = 0
AF8B : CLRA  				|
AF8C : ASLA  				|A = A * 2
AF8D : LDX   #$8305			|X = 0x8305
AF90 : JSR   $FC14			|gosub FC14
AF93 : SUBA  $0161			|A = A - M[$0161]
AF96 : BCC   $AF99			|if ( A < 0) then A = 0
AF98 : CLRA  				|
AF99 : STAA  $00FF			|M[$00FF] = A
AF9B : BSET  $0066,01000000B
AF9E : CLR   $0210
AFA1 : LDX   #$82F2
AFA4 : LDAA  $0210
AFA7 : BEQ   $AFAA
AFA9 : INX   
AFAA : LDAB  $00,X
AFAC : CLRA  
AFAD : STD   $0100
AFB0 : LDD   $0131
AFB3 : SUBD  $012F
AFB6 : BCS   $AFE0
AFB8 : CPD   $0100
AFBC : BLS   $AFE0
AFBE : INX   
AFBF : LDAA  $0210
AFC2 : BNE   $AFC5
AFC4 : INX   
AFC5 : LDAA  $00,X
AFC7 : INC   $0210
AFCA : CMPA  $0210
AFCD : BHI   $AFE0
AFCF : INX   
AFD0 : LDAA  $00,X
AFD2 : CMPA  $0210
AFD5 : BCS   $AFDD
AFD7 : LDAA  $00FF
AFD9 : STAA  $00FE
AFDB : BRA   $AFE3
AFDD : BCLR  $0066,01100000B
AFE0 : CLR   $00FE
AFE3 : LDAA  $004C
AFE5 : STAA  $004E
AFE7 : LDD   $012F
AFEA : STD   $0131
AFED : LDAA  $02C4
AFF0 : BEQ   $AFF5
AFF2 : DEC   $02C4
AFF5 : BRCLR $0049,00000001B,$AFFC		| if ( bit 0x01 of M[$0049] is clear ) then goto AFFC
AFF9 : JMP   $C312				| goto C312
AFFC : BCLR  $0054,00001000B
AFFF : BRCLR $006A,00001000B,$B00D
B003 : LDAA  $02AF
B006 : BPL   $B00D
B008 : BSET  $0054,00001000B
B00B : BRA   $B012
B00D : SEI   
B00E : JSR   $FB5A
B011 : CLI   
B012 : JMP   $B4A8
B015 : BSET  $0000,00000010B
B018 : LDD   $10FA
B01B : ORAB  #$0C
B01D : STD   $10FA
B020 : BITA  #$20
B022 : BEQ   $B084
B024 : BRSET $006A,00010000B,$B06A
B028 : LDD   $10F4
B02B : STD   $0266
B02E : BCLR  $005C,00001000B
B031 : BRCLR $005A,01000000B,$B038
B035 : JMP   $B247
B038 : LDX   $3FC0
B03B : BRSET $0050,00000001B,$B059
B03F : LDAB  #$0A
B041 : CLRA  
B042 : STD   $007F
B044 : LDAA  #$5A
B046 : SBA   
B047 : TAB   
B048 : CLRA  
B049 : STD   $10EC
B04C : LDD   $10D0
B04F : SUBD  $007F
B051 : STD   $10D2
B054 : LDX   #$FFFF
B057 : BRA   $B070
B059 : CPX   #$0088
B05C : BHI   $B06D
B05E : BSET  $0054,00100000B
B061 : LDAA  $01F5
B064 : INCA  
B065 : BEQ   $B06A
B067 : STAA  $01F5
B06A : JMP   $B247
B06D : BCLR  $0054,00100000B
B070 : LDD   $10FC
B073 : ORAA  #$20
B075 : STD   $10FC
B078 : STX   $007D
B07A : BSET  $0052,10000000B
B07D : BSET  $0050,00000001B
B080 : BRCLR $004F,00010000B,$B087
B084 : JMP   $B247
B087 : LDAB  $021C
B08A : LDAA  #$1F
B08C : STD   $400E
B08F : CLR   $021A
B092 : LDAA  $016F
B095 : ADDA  #$01
B097 : SBCA  #$00
B099 : STAA  $016F
B09C : BRCLR $003E,11111111B,$B0A6
B0A0 : DEC   $003E
B0A3 : JMP   $B247
B0A6 : BRCLR $0050,10000000B,$B0AD
B0AA : JMP   $B146
B0AD : LDAA  $01BD
B0B0 : INCA  
B0B1 : BNE   $B0B5
B0B3 : LDAA  #$FF
B0B5 : STAA  $01BD
B0B8 : LDAB  $01BC
B0BB : ANDB  #$0F
B0BD : LDX   #$8657
B0C0 : BRCLR $0060,00000001B,$B0C9
B0C4 : ANDB  #$07
B0C6 : LDX   #$8667
B0C9 : ABX   
B0CA : LDAA  $01BC
B0CD : CMPA  #$0F
B0CF : BCS   $B0D4
B0D1 : BSET  $0060,00000001B
B0D4 : INC   $01BC
B0D7 : LDD   $009A
B0D9 : BEQ   $B143
B0DB : LDAA  $00,X
B0DD : BEQ   $B143
B0DF : LDX   #$009A
B0E2 : JSR   $FB83			| Routine returns D = AIN (byte)  * M[$X] (word)
B0E5 : STD   $01BA
B0E8 : LDD   $0042
B0EA : ADDD  $01BA
B0ED : BCC   $B0F2
B0EF : INC   $0041
B0F2 : ADDD  $01BA
B0F5 : BCC   $B0FA
B0F7 : INC   $0041
B0FA : STD   $0042
B0FC : LDX   #$1000
B0FF : BSET  $20,X,00110000B
B102 : BRSET $00,X,00100000B,$B117
B106 : LDD   $0E,X
B108 : ADDD  #$0002
B10B : STD   $1A,X
B10D : ADDD  $00CD
B10F : NOP  
B110 : NOP  
B111 : NOP  
B112 : NOP  
B113 : NOP  
B114 : NOP  
B115 : BRA   $B119
B117 : LDD   $1A,X
B119 : ADDD  $01BA
B11C : BCLR  $20,X,00010000B
B11F : STD   $1A,X
B121 : BSET  $20,X,11000000B
B124 : BRSET $00,X,01000000B,$B139
B128 : LDD   $0E,X
B12A : ADDD  #$0002
B12D : STD   $18,X
B12F : ADDD  $00CD
B131 : NOP  
B132 : NOP  
B133 : NOP  
B134 : NOP  
B135 : NOP  
B136 : NOP  
B137 : BRA   $B13B
B139 : LDD   $18,X
B13B : ADDD  $01BA
B13E : BCLR  $20,X,01000000B
B141 : STD   $18,X
B143 : JMP   $B247
B146 : LDX   #$1000
B149 : BCLR  $0C,X,01100000B
B14C : BSET  $20,X,10100000B
B14F : LDX   $0098
B151 : CPX   $00A4
B153 : BLS   $B157
B155 : LDX   $00A4
B157 : CPX   $8675
B15A : BRSET $0062,00000001B,$B161
B15E : CPX   $8673
B161 : BCS   $B16B
B163 : BCLR  $0062,00000001B
B166 : CLR   $0089
B169 : BRA   $B17A
B16B : LDAA  $0089
B16D : CMPA  $867A
B170 : BCC   $B177
B172 : INC   $0089
B175 : BRA   $B17A
B177 : BSET  $0062,00000001B
B17A : LDD   $10F0
B17D : CMPB  $866F
B180 : BEQ   $B1A7
B182 : CMPB  $8671
B185 : BEQ   $B18A
B187 : JMP   $B247
B18A : LDAA  $8672
B18D : LDX   #$007D
B190 : JSR   $FB83			| Routine returns D = AIN (byte)  * M[$X] (word)
B193 : LDX   #$1000		
B196 : ASLD  
B197 : STD   $008A
B199 : BRCLR $0062,00000001B,$B1A2
B19D : BSET  $0064,10000000B
B1A0 : BRA   $B1C2
B1A2 : BCLR  $0063,10000000B
B1A5 : BRA   $B1C2
B1A7 : LDAA  $8670
B1AA : LDX   #$007D
B1AD : JSR   $FB83			| Routine returns D = AIN (byte)  * M[$X] (word)
B1B0 : LDX   #$1000
B1B3 : ASLD  
B1B4 : STD   $008A
B1B6 : BRCLR $0062,00000001B,$B1BF
B1BA : BSET  $0063,10000000B
B1BD : BRA   $B1C2
B1BF : BCLR  $0064,10000000B
B1C2 : LDD   $10F0
B1C5 : CMPB  $866F
B1C8 : BEQ   $B1CE
B1CA : BRSET $0063,10000000B,$B201
B1CE : LDD   $008A
B1D0 : CPD   #$0006
B1D4 : BCC   $B1D9
B1D6 : LDD   #$0006
B1D9 : ADDD  $0E,X
B1DB : STD   $0081
B1DD : BSET  $22,X,00100000B
B1E0 : PSHA  
B1E1 : LDAA  #$20
B1E3 : STAA  $1023
B1E6 : PULA  
B1E7 : BRCLR $00,X,00100000B,$B1F9
B1EB : CPD   $1A,X
B1EE : BPL   $B1FE
B1F0 : BRSET $0063,00001000B,$B1F9
B1F4 : BSET  $0063,00001000B
B1F7 : BRA   $B201
B1F9 : BSET  $20,X,00010000B
B1FC : STD   $1A,X
B1FE : BCLR  $0063,00001000B
B201 : LDD   $10F0
B204 : CMPB  $8671
B207 : BEQ   $B20D
B209 : BRSET $0064,10000000B,$B247
B20D : LDD   $008A
B20F : BRSET $005F,00000001B,$B216
B213 : ADDD  $8678
B216 : CPD   #$0006
B21A : BCC   $B21F
B21C : LDD   #$0006
B21F : ADDD  $0E,X
B221 : STD   $0083
B223 : BSET  $22,X,01000000B
B226 : PSHA  
B227 : LDAA  #$40
B229 : STAA  $1023
B22C : PULA  
B22D : BRCLR $00,X,01000000B,$B23F
B231 : CPD   $18,X
B234 : BPL   $B244
B236 : BRSET $0064,00001000B,$B23F
B23A : BSET  $0064,00001000B
B23D : BRA   $B247
B23F : BSET  $20,X,01000000B
B242 : STD   $18,X
B244 : BCLR  $0064,00001000B
B247 : RTI
*
* Timer input capture #3 interrupt routine
*
B248 : LDX   #$1000
B24B : LDAA  #$01
B24D : STAA  $1023
B250 : LDAA  $83CB
B253 : BITA  #$20
B255 : BEQ   $B27F
B257 : LDAA  $1022
B25A : BITA  #$04
B25C : BEQ   $B27F
B25E : LDAA  $01DD
B261 : INCA  
B262 : BNE   $B265
B264 : DECA  
B265 : STAA  $01DD
B268 : CMPA  #$05
B26A : BCC   $B271
B26C : BCLR  $005C,00000100B
B26F : BRA   $B27F
B271 : BSET  $005C,00000100B
B274 : BSET  $0005,00100000B
B277 : JSR   $FAB5
B27A : STD   $0011
B27C : CLR   $0010
B27F : LDAA  $0054
B281 : BSET  $0054,00000010B
B284 : BITA  #$02
B286 : BEQ   $B28E
B288 : BCLR  $0054,00000010B
B28B : INC   $0046
B28E : BRSET $0050,10000000B,$B295
B292 : JMP   $B36B
B295 : BRCLR $005A,01000000B,$B2DA
B299 : BSET  $005F,00000100B
B29C : LDD   $009C			| D = M[$009C]  - Load D with left injector pulsewidth
B29E : BEQ   $B2DA			| if ( D == 0 ) then goto B2DA
B2A0 : LDD   $00A8			| D = M[$00A8]  - Load D with right injector pulsewidth
B2A2 : BEQ   $B2DA			| if ( D == 0 ) then goto B2DA
B2A4 : LDX   #$1000			| X = 0x1000
B2A7 : BSET  $20,X,11110000B		| set bit 0xF0 of M[$(X+0x20)] - Timer control - set OM2, OL2, OM3, OL3 to 1
B2AA : LDD   $0E,X			| D = M[$(X + 0x0E)] - Load D with Timer counter
B2AC : ADDD  #$0002			| D = D + 0x02
B2AF : STD   $1A,X			| M[$(X+0x1A)] = D - Load timer output #3 compare register
B2B1 : STD   $18,X			| M[$(X+0x18)] = D - Load timer output #2 compare register
B2B3 : LDD   $009C			| D = M[$009C]  - Load D with left injector Pulsewidth
B2B5 : ADDD  $1A,X			| D = D + M[$(X+0x1A)]  - Add timer output #3 compare register to D
B2B7 : NOP  				|
B2B8 : NOP  				|
B2B9 : NOP  				|
B2BA : BCLR  $20,X,00010000B		| Clear bit 0x10 of M[$(X+0x20)] - set output level #3 to 0
B2BD : STD   $1A,X			| D = M[$(X+0x1A)]  - Timer output #3 compare register.
B2BF : LDD   $00A8			| D = M[$00A8]  - Load D with right injector Pulsewidth
B2C1 : ADDD  $18,X			| D = D + M[$(X+0x18)]  - Add timer output #2 compare register to D
B2C3 : BCLR  $20,X,01000000B		| clear bit 0x40 of M[$(X+0x20)] - set output level #2 to 0
B2C6 : STD   $18,X			| M[$(X+0x18) = D
B2C8 : LDD   $0042			| D = M[$0042]
B2CA : ADDD  $0098			| D = D + M[$0098]
B2CC : BCC   $B2D1			| if (D < 0xFFFF) then goto B2D1
B2CE : INC   $0041			| M[$0041] ++  (upper byte of three byte number)
B2D1 : ADDD  $00A4			| D = D + M[$00A4]
B2D3 : BCC   $B2D8			| if (D < 0xFFFF) then goto B2D8
B2D5 : INC   $0041			| M[$0041] ++  (upper byte of three byte number)
B2D8 : STD   $0042			| M[$0042] = D
B2DA : CLR   $0256			| M[$0256] = 0
B2DD : CLRB  				| B = 0
B2DE : BRCLR $0057,10000000B,$B2EA	| if bit 0x80 of M[$0057] then goto B2EA  - if ( excel enleanment not enabled) then goto B2EA
B2E2 : LDAB  $019D			| B = M[$019D]
B2E5 : INCB  				| B = B + 1
B2E6 : CMPB  #$10			| Compare B with 0x10
B2E8 : BHI   $B2ED			| if ( B > 0x10 ) then goto B2ED
B2EA : STAB  $019D			| M[$019D] = B
B2ED : BSET  $0060,00001000B		| set bit 0x08 of M[$0060]
B2F0 : BRCLR $0070,00001000B,$B30C
B2F4 : LDAA  $011D
B2F7 : BEQ   $B30C
B2F9 : LDAA  $011E
B2FC : BEQ   $B303
B2FE : DEC   $011E
B301 : BRA   $B30C
B303 : DEC   $011D
B306 : LDAA  $8931
B309 : STAA  $011E
B30C : BRCLR $0008,11111111B,$B335
B310 : LDD   $000A
B312 : BEQ   $B31B
B314 : SUBD  #$0001
B317 : STD   $000A
B319 : BRA   $B335
B31B : LDAA  $00D0
B31D : BEQ   $B324
B31F : DECA  
B320 : STAA  $00D0
B322 : BRA   $B335
B324 : LDAA  $00D2
B326 : STAA  $00D0
B328 : LDD   $0008
B32A : SUBB  $00D1
B32C : SBCA  #$00
B32E : BCC   $B333
B330 : LDD   #$0000
B333 : STD   $0008
B335 : BRCLR $000C,11111111B,$B36B
B339 : LDD   $000E
B33B : BEQ   $B344
B33D : SUBD  #$0001
B340 : STD   $000E
B342 : BRA   $B36B
B344 : LDAA  $00D3
B346 : BEQ   $B34D
B348 : DECA  
B349 : STAA  $00D3
B34B : BRA   $B36B
B34D : LDAA  $8314
B350 : STAA  $00D3
B352 : LDD   $000C
B354 : BPL   $B35F
B356 : ADDB  $8315
B359 : ADCA  #$00
B35B : BCS   $B366
B35D : BRA   $B369
B35F : SUBB  $8315
B362 : SBCA  #$00
B364 : BCC   $B369
B366 : LDD   #$0000
B369 : STD   $000C
B36B : RTI
*
* Timer Output Compare #3 interrupt
*
B36C : LDX   #$1000
B36F : LDAA  #$20
B371 : STAA  $1023
B374 : BRCLR $0050,10000000B,$B3C6
B378 : LDAA  $1000
B37B : BITA  #$20
B37D : BNE   $B392
B37F : BSET  $20,X,00010000B		| set bit 0x01 of M[$(X+0x20)] (set timer output level #3) (turn on left injectors ?)
B382 : LDD   $0E,X			| D = M[$(X+0x0E)]  (timer counter register)
B384 : ADDD  #$0002			| D = D + 0x02
B387 : CPD   $0081			| compare D with M[$0081]
B38A : BPL   $B38E			| if ( D > M[$0081] ) then goto B38E
B38C : LDD   $0081			| D = M[$0081]
B38E : STD   $1A,X			| M[$(X+0x1A)] = D  (set timer counter register #3 - for left injector)
B390 : BRA   $B3C6			| goto B3C6
B392 : BCLR  $22,X,00100000B		| clear bit 0x20 of M[$(X+0x22)] (Disable Interrupt for output compare #3)
B395 : BCLR  $20,X,00010000B		| clear bit 0x10 of M[$(X+0x20)] (clear Timer output level #3) (turn off left injector ?)
B398 : LDD   $009C			| D = M[$009C]   - Load D with Left injector pulse width
B39A : BRCLR $0063,10000000B,$B3A0	| if (bit 0x80 of M[$0063] is clear) then goto B3A0
B39E : LDD   $00A0			| D = M[$00A0]
B3A0 : ADDD  $1A,X			| D = D + M[$(X + 0x1A)] - Add left injector pulse width to timer output compare register #3 (left injector control)
B3A2 : STD   $0085			| M[$0085] = D
B3A4 : LDD   $0E,X			| D = M[$(X+0x0E)]
B3A6 : ADDD  #$0002			| D = D + 0x02
B3A9 : CPD   $0085			
B3AC : BPL   $B3B0
B3AE : LDD   $0085
B3B0 : STD   $1A,X
B3B2 : LDD   $0098
B3B4 : BRCLR $0063,10000000B,$B3BA
B3B8 : LDD   $009E
B3BA : ADDD  $0042
B3BC : BCC   $B3C1
B3BE : INC   $0041
B3C1 : STD   $0042
B3C3 : BSET  $005F,00000100B
B3C6 : RTI
*
* Timer output compare #2 interrupt
*   
B3C7 : LDX   #$1000
B3CA : LDAA  #$40
B3CC : STAA  $1023
B3CF : BRCLR $0050,10000000B,$B421
B3D3 : LDAA  $1000
B3D6 : BITA  #$40
B3D8 : BNE   $B3ED
B3DA : BSET  $20,X,01000000B		| set bit 0x40 of M[$(X+0x20)] (set timer output level #2) (turn on right injectors ?)
B3DD : LDD   $0E,X
B3DF : ADDD  #$0002
B3E2 : CPD   $0083
B3E5 : BPL   $B3E9
B3E7 : LDD   $0083
B3E9 : STD   $18,X
B3EB : BRA   $B421
B3ED : BCLR  $22,X,01000000B		| clear bit 0x40 of M[$(X+0x22)] (Disable interrupt for output compare #2)
B3F0 : BCLR  $20,X,01000000B		| clear bit 0x40 of M[$(X+0x20)] (clear timer output level #2) (turn off right injector ?)
B3F3 : LDD   $00A8			| D = M[$00A8]  - Load D with right injector pulsewidth
B3F5 : BRCLR $0064,10000000B,$B3FB	| if ( bit 0x80 of M[$0064] is clear ) then goto B3FB
B3F9 : LDD   $00AC			| D = M[$00AC]
B3FB : ADDD  $18,X			| D = D + M[$(X+0x18)]
B3FD : STD   $0087			| M[$0087] = D
B3FF : LDD   $0E,X			| D = M[$(X+0x0E)]
B401 : ADDD  #$0002			| D = D + 0x0002
B404 : CPD   $0087			| compare D with M[$0087]
B407 : BPL   $B40B
B409 : LDD   $0087
B40B : STD   $18,X
B40D : LDD   $00A4
B40F : BRCLR $0064,10000000B,$B418
B413 : LDD   $00AA
B415 : BSET  $005F,00000100B
B418 : ADDD  $0042
B41A : BCC   $B41F
B41C : INC   $0041
B41F : STD   $0042
B421 : RTI
*
* Timer input capture #1 interrupt
*   
B422 : BRSET $006A,00010000B,$B440
B426 : CLR   $01DD
B429 : LDAA  $83CB
B42C : BITA  #$40
B42E : BEQ   $B440
B430 : LDX   #$1000
B433 : BCLR  $0C,X,11111000B
B436 : LDD   $0E,X
B438 : ADDD  #$002F
B43B : STD   $16,X
B43D : BSET  $22,X,10000000B
B440 : LDAA  #$84
B442 : STAA  $1023
B445 : RTI   
*
* Timer output compare #1 interrupt
*
B446 : LDX   #$4000			Load X with 0x4000			| X = 0x4000
B449 : BCLR  $00,X,00011100B		clear bit 0x1C of M[$X]
B44C : LDAA  #$14			Load A with 0x14			| A = 0x14						|
B44E : ORAA  $00,X			Or A with $X				| A = A | M[$X]						| M[$X] = M[$X] | 0x14
B450 : STAA  $00,X			Store A to $X				| M[$X] = A						|
B452 : CLR   $1030			Clear $1030				| Write to ADCTL - Initiates a conversion.
B455 : LDX   #$1000			Load X with $0x1000			| X = 0x1000
B458 : LDAB  #$0C			Load B with 0x0C			| C = 0x0C
B45A : BRSET $30,X,10000000B,$B464	if bit 0x80 of M[$(X+30)] set goto B464 | Wait until CCF is set (A/D conversion complete)
B45E : DECB  				Decrement B				| B = B - 1
B45F : BNE   $B45A			Branch not equal to B45A		| if ( B != 0 ) then goto B45A
B461 : BSET  $0059,00000001B		Set bit 0x01 of N[$0059]		| Conversion Failed?  Bit 0x01 of M[$0059] error bit?
B464 : LDAA  $1034			Load A with $1034			| A = M[$1034] 	ADR4 - Fourth A/D Register
B467 : STAA  $00E0			Store A to $00E0			| M[$00E0] = A  ADR4 - Fourth A/D Register
B469 : LDAA  #$80			Load A with 0x80			| A = 0x80
B46B : STAA  $1023			Store A to $1023			| M[$1023] = A (0x80)  Sets OC1F - Output compare flag for timer #1
B46E : LDAA  $1022			Load A with $1022			| A = M[$1022]  Timer Interrupt Mask #1
B471 : ANDA  #$7F			And A with 0x7F				| A = A & 0x7F - Reset OC1I - Disable Output Timer #1 interrupt
B473 : STAA  $1022			Store A to $1022			| M[$1022] = A  
B476 : BRSET $005C,00010000B,$B481	if bit 0x10 of $005C then goto B481
B47A : LDAA  $00E0			Load A with $00E0			| A = M[$00E0]  A/D Register #4
B47C : CMPA  $842C			Compare A with $842C			| $842C = 0xEB
B47F : BCC   $B486			if A >= 0xEB then goto B486		| if (A >= 0xEB) then goto B486
B481 : CLR   $01DC			Clear $10DC				| M[$10DC] = 0
B484 : BRA   $B494			Branch Always B494			| goto B494
B486 : LDAA  $01DC			Load A with $10DC			| A = M[$10DC]
B489 : INCA  				Increment A				| A += 1
B48A : BNE   $B48D			Branch if not equal to B48D		| if A != 0 then goto B48D
B48C : DECA  				Decrement A				| A -= 1
B48D : STAA  $01DC			Store A $01DC				| M[$01DC] = A
B490 : CMPA  #$14			Compare A with $0x14			| A = 0x14
B492 : BCC   $B499			Branch if carry is clear to B499	| if ( A >= 0x14) then goto B499
B494 : BCLR  $005C,00000010B		clear bit 0x02 of $005C			| clear bit of 0x02 of M[$005C]
B497 : BRA   $B4A7			Branch always $B4A7			| goto B4A7
B499 : BSET  $005C,00000010B		Set bit 0x02 of $005C			| set bit 0x02 of M[$005C]
B49C : BSET  $0005,01000000B		Set bit 0x40 of $0005			| set bit 0x40 of M[$0005]
B49F : JSR   $FAB5			Jump to service $FAB5			| gosub FAB5
B4A2 : STD   $0011			Store D to $0011			| M[$0011] = D
B4A4 : CLR   $0010			Clear $0010				| M[$0010] = 0
B4A7 : RTI   				Return from interrupt
*
* 
*
B4A8 : BRCLR $0051,00000100B,$B4F9	| if ( bit 0x04 of M[$0051] is clear ) then goto B4F9  - Reference Pulse occured 6.25 ms
*
B4AC : LDD   $00E4			| D = M[$00E4]
B4AE : LSRD  				| D = D / 2
B4AF : LSRD  				| D = D / 2
B4B0 : LSRD  				| D = D / 2
B4B1 : COMA  				| A = A EOR 0xFF
B4B2 : COMB  				| B = B EOR 0xFF
B4B3 : ADDD  $00E4			| D = D + M[$00E4]
B4B5 : BPL   $B4BA			| if ( D >= 0 ) then goto B4BA
*
B4B7 : LDD   #$0000			| D = 0x00
*
B4BA : STD   $00E4			| M[$00E4] = D
B4BC : CLR   $00F7			| M[$00F7] = 0
B4BF : BRSET $0050,10000000B,$B533	| if ( bit 0x80 of M[$0050] is set ) then goto B533  - if ( engine running - spark ) then goto B533
*
B4C3 : LDAA  $01A9			| A = M[$01A9]
B4C6 : LSRA  				| A = A / 2
B4C7 : LDX   #$8093			| X = 0x8093
B4CA : JSR   $FC14			| gosub FC14
B4CD : CLRB  				| B = 0 
B4CE : LSRD  				| D = D / 2
B4CF : LSRD  				| D = D / 2
B4D0 : STD   $0206			| M[$0206] = D
B4D3 : CPD   $007D			| compare D with M[$007D]
B4D6 : BHI   $B4DD			| if ( D > M[$007D] ) then goto B4DD
*
B4D8 : CLR   $0208			| M[$0208] = D
B4DB : BRA   $B51C			| goto B51C
*
B4DD : LDAA  $01A9			| A = M[$01A9]  - Coolent temp lag filtered
B4E0 : LSRA  				| A = A / 2
B4E1 : LDX   #$808A			| X = 0x808A
B4E4 : JSR   $FC14			| gosub FC14
B4E7 : CMPA  $0208			| compare A with M[$0208]
B4EA : BLS   $B4F1			| if ( A <= M[$0208] ) then goto B4F1
*
B4EC : INC   $0208			| M[$0208] ++
B4EF : BRA   $B51C			| goto B51C
*
B4F1 : BSET  $0050,10000000B		| set bit 0x80 of M[$0050]  - engine running - spark
B4F4 : BSET  $0001,00001000B		| set bit 0x08 of M[$0001]
B4F7 : BRA   $B533			| goto B533
*
B4F9 : LDAA  $021A			| A = M[$021A] 
B4FC : CMPA  #$4E			| compare A with 0x4E
B4FE : BLS   $B50E			| if ( A <= 0x4E ) then goto B50E
*
B500 : CLR   $0209			| M[$0209] = 0
B503 : BCLR  $0051,00000010B		| clear bit 0x02 of M[$0051]  - clear Run spark enabled
B506 : BCLR  $0050,00000001B		| clear bit 0x01 of M[$0050]  - clear first reference pulse has been detected
B509 : LDX   #$FFFF			| X = 0xFFFF
B50C : STX   $007D			| M[$007D] = X
*
B50E : LDAA  $00F7			| A = M[$00F7]
B510 : CMPA  #$17			| compare A with 0x17
B512 : BCS   $B518			| if ( A < 0x17 ) then goto B518
*
B514 : CLR   $0047			| M[$0047] = 0
B517 : SWI   				| Enable Software Interrupt
*
*
B518 : BRSET $0050,10000000B,$B530	| if ( bit 0x80 of M[$0050] is set ) then goto B530  - if (engine running - spark ) then goto B530
B51C : LDD   #$0000			| D = 0x0000
B51F : STD   $020D			| M[$020D] = D
B522 : BRSET $0001,00001000B,$B528	| if ( bit 0x08 of M[$0001] is set ) then goto B528
*
B526 : STD   $0013			| M[$0013] = D  ( Engine running time in seconds )
*
B528 : STAB  $0112			| M[$0112] = B  ( lsb of engine running time)
B52B : STAB  $025A			| M[$025A] = B	( lsb of engine running time)
B52E : BRA   $B533			| goto B533
*
B530 : INCA  				| A = A + 1
B531 : STAA  $00F7			| M[$00F7] = A
*
*
*
B533 : LDD   $007D			| D = M[$007D]  - Minor loop reference peroid - MSEC = (MSB*256 + LSB)/65.536
B535 : ASLD  				| D = D * 2
B536 : BCC   $B53B			| if ( D < 0xFFFF ) then goto B53B
B538 : LDD   #$FFFF			| D = 0xFFFF
B53B : PSHB  				| push B
B53C : PSHA  				| push A
B53D : PULX  				| pull X
B53E : PSHX  				| push X
B53F : LDD   #$0133			| D = 0x0133
B542 : FDIV  				| D / X ; X is quotient ; D is remainder; X is X/65536
B543 : PSHX  				| push X
B544 : TSX   				| X = SP
B545 : LDD   $00,X			| D = M[$X]  - MSB of D is unrounded RPM in 25rpm per count
B547 : CMPA  #$60			| compare A with 0x60
B549 : BCS   $B554			| if ( A < 0x60 ) then goto B554  ( ~2400 rpm )
B54B : ADDD  #$4080			| D = D + 0x4080  ( ~1600 rpm )
B54E : BCC   $B55B			| if ( D < 0xFFFF ) then goto B55B
B550 : LDAA  #$FF			| A = 0xFF
B552 : BRA   $B55B			| goto B55B
B554 : ASLD  				| D = D * 2  
B555 : SUBD  #$1F80			| D = D - 0x1F80  (subtracts equivalent to ~400 rpm, 800 after multiply )
B558 : BCC   $B55B			| if ( D > 0 ) then goto B55B
B55A : CLRA  				| A = 0
B55B : STAA  $0122			| M[$0122] = A ( rpm with odd offset and odd scaling )
B55E : LDD   $00,X			| D = M[$X]  - MSB of D is unrounded RPM in 25 rpm per count
B560 : ADDD  #$0080			| D = D + 0x0080
B563 : BCC   $B567			| if ( D < 0xFFFF ) then goto B567
B565 : LDAA  #$FF			| A = 0xFF
B567 : STAA  $0123			| M[$0123] = A  (this is engine rpm with 25 rpm per count)
B56A : LDD   $00,X			| D = M[$X]  - MSB of D is unrounded RPM in 25 rpm per count
B56C : ASLD  				| D = D * 2
B56D : BCS   $B574			| if ( D > 0xFFFF ) then goto BF74
56F : ADDD  #$0080			| D = D + 0x80
B572 : BCC   $B576			| if ( D < 0xFFFF ) then goto B576
B574 : LDAA  #$FF			| A = 0xFF
B576 : STAA  $0124			| M[$0124] = A ( rpm with 12.5 rpm per count )
B579 : CLRB  				| B = 0
B57A : LDX   $0127			| X = M[$0127]
B57D : BEQ   $B585			| if ( X == 0 ) then goto B585
B57F : LDAB  $88B2			| B = M[$88B2] (0x33)
B582 : JSR   $FB63			| D = X + ( 256 * A - X ) * B
B585 : STD   $0127			| M[$0127] = D  ( lag filtered M[$0124] value )
B588 : LDAA  $0124			| A = M[$0124]
B58B : CLRB  				| B = 0
B58C : LDX   $012D			| X = M[$012D]
B58F : BEQ   $B597			| if ( X == 0 ) then goto B597
B591 : LDAB  $8852			| B = M[$8852] (0x0A)
B594 : JSR   $FB63			| D = X + ( 256 * A - X ) * B
B597 : STD   $012D			| M[$012D] = D  ( lag filtered M[$0124] value )
B59A : PULX  				| Pull X
B59B : PULX  				| pull X
B59C : LDD   #$00F6			| D = 0x00F6
B59F : FDIV  				| D / X ; X is quotient; D is remainder; value is X/65536
B5A0 : PSHX  				| push X
B5A1 : PULA  				| pull A
B5A2 : PULB  				| pull B
B5A3 : ADDD  #$0080			| D = D + 0x80  (rounding)
B5A6 : BCC   $B5AA			| if ( D < 0xFFFF ) then goto B5AA
B5A8 : LDAA  #$FF			| A = 0xFF
B5AA : STAA  $0125			| M[$0125] = A  ( rpm with 31.25 rpm per count )
B5AD : BRSET $0051,00000100B,$B5B4
*
*
B5B1 : JMP   $B6DC
*
B5B4 : BCLR  $0051,00000100B
B5B7 : BRSET $0068,00100000B,$B5C4
*
B5BB : BRCLR $004F,11000000B,$B5C1
*
B5BF : BRA   $B5C4			| jump here if diag stuff is enabled - should never be used.
*
B5C1 : JMP   $B6BC
*
B5C4 : LDX   $007D
B5C6 : LDD   #$03C0
B5C9 : FDIV  
B5CA : XGDX  
B5CB : ADDD  #$0080
B5CE : BCC   $B5D3
*
B5D0 : JMP   $B6AA
*
B5D3 : STAA  $0133
B5D6 : CMPA  $0134
B5D9 : BCC   $B5DE
*
B5DB : STAA  $0134
*
B5DE : TAB   
B5DF : LDX   $0135
B5E2 : ABX   
B5E3 : STX   $0135
B5E6 : MUL   
B5E7 : ADDD  $0138
B5EA : BCC   $B5EF
*
B5EC : INC   $0137
*
B5EF : STD   $0138
B5F2 : INC   $013A
B5F5 : LDAA  $013A
B5F8 : CMPA  $8021
B5FB : BEQ   $B600
B5FD : JMP   $B6BC
B600 : CLRB  
B601 : XGDX  
B602 : FDIV  
B603 : STX   $013B
B606 : XGDX  
B607 : LDAB  $0136
B60A : MUL   
B60B : XGDX  
B60C : LDAB  $0135
B60F : LDAA  $013B
B612 : MUL   
B613 : PSHX  
B614 : TSX   
B615 : ADDB  $00,X
B617 : ADCA  #$00
B619 : INS   
B61A : PSHB  
B61B : PSHA  
B61C : LDAA  $013C
B61F : LDAB  $0136
B622 : MUL   
B623 : ADCA  #$00
B625 : PSHA  
B626 : LDAA  $013C
B629 : LDAB  $0135
B62C : MUL   
B62D : TSX   
B62E : ADDB  $00,X
B630 : ADCA  #$00
B632 : INS   
B633 : TSX   
B634 : ADDD  $01,X
B636 : BCC   $B63A
B638 : INC   $00,X
B63A : STD   $01,X
B63C : LDD   $0138
B63F : SUBD  $01,X
B641 : STD   $01,X
B643 : LDAA  $0137
B646 : SBCA  $00,X
B648 : INS   
B649 : PULX  
B64A : BEQ   $B654
B64C : LDD   #$FFFF
B64F : STD   $013F
B652 : BRA   $B694
B654 : CLRA  
B655 : LDAB  $8021
B658 : DECB  
B659 : LSRB  
B65A : LSRB  
B65B : XGDX  
B65C : IDIV  
B65D : STX   $013D
B660 : BNE   $B667
B662 : STX   $013F
B665 : BRA   $B689
B667 : LDAA  #$04
B669 : STAA  $013A
B66C : LDD   #$0300
B66F : STD   $013F
B672 : XGDX  
B673 : FDIV  
B674 : XGDX  
B675 : ADDD  $013F
B678 : RORA  
B679 : RORB  
B67A : STD   $013F
B67D : LDX   $013D
B680 : DEC   $013A
B683 : BNE   $B672
B685 : LDX   $013B
B688 : FDIV  
B689 : XGDX  
B68A : ASLD  
B68B : BCS   $B692
B68D : ADDD  #$0080
B690 : BCC   $B694
B692 : LDAA  #$FF
B694 : STAA  $0141
B697 : LDAA  $0134
B69A : CLRB  
B69B : LDX   $013B
B69E : FDIV  
B69F : XGDX  
B6A0 : ADDD  #$0080
B6A3 : BCC   $B6A7
B6A5 : LDAA  #$FF
B6A7 : STAA  $0142
B6AA : CLRA  
B6AB : CLRB  
B6AC : STAA  $013A
B6AF : STD   $0135
B6B2 : STD   $0137
B6B5 : STAA  $0139
B6B8 : DECA  
B6B9 : STAA  $0134
B6BC : LDAA  $0127
B6BF : CMPA  $0109
B6C2 : BCC   $B6CC
B6C4 : BCLR  $0051,00000010B
B6C7 : CLR   $0209
B6CA : BRA   $B6DC
B6CC : LDAA  $0209
B6CF : CMPA  $020A
B6D2 : BCC   $B6D9
B6D4 : INC   $0209
B6D7 : BRA   $B6DC
B6D9 : BSET  $0051,00000010B
B6DC : LDAA  #$FF
B6DE : LDAB  $0150
B6E1 : SUBB  $0152
B6E4 : BCS   $B6EA
B6E6 : CMPB  #$20
B6E8 : BCC   $B702
B6EA : LDD   #$4000
B6ED : CPD   $007D
B6F0 : BLS   $B704
B6F2 : CPD   $00E2
B6F5 : BLS   $B704
B6F7 : LDD   $00E2
B6F9 : SUBD  $007D
B6FB : ASLD  
B6FC : SUBD  $00E4
B6FE : BMI   $B704
B700 : ADDD  $00E4
B702 : STD   $00E4
B704 : LDD   $0150
B707 : STD   $0151
B70A : LDD   $007D
B70C : LSRD  
B70D : LSRD  
B70E : LSRD  
B70F : CPD   $00E4
B712 : BCC   $B716
B714 : STD   $00E4
B716 : LDD   $007D
B718 : STD   $00E2
B71A : LDD   #$0000
B71D : BRSET $0051,00000010B,$B72B
B721 : LDD   $82E8
B724 : BRCLR $005A,01000000B,$B72B
B728 : ADDD  $842A
B72B : PSHB  
B72C : PSHA  
B72D : LDAB  $00DC
B72F : CMPB  #$2D
B731 : BCC   $B735
B733 : LDAB  #$2D
B735 : SUBB  #$14
B737 : CLRA  
B738 : XGDX  
B739 : LDD   #$8000
B73C : IDIV  
B73D : LDD   $007D
B73F : CPD   #$01AB
B743 : BHI   $B756
B745 : LSRD  
B746 : LDAA  #$D6
B748 : SBA   
B749 : TAB   
B74A : CLRA  
B74B : STD   $00EA
B74D : XGDX  
B74E : SUBD  $00EA
B750 : BCC   $B755
B752 : LDD   #$0000
B755 : XGDX  
B756 : STX   $00E8
B758 : LDD   $007D
B75A : LSRD  
B75B : LSRD  
B75C : LSRD  
B75D : LSRD  
B75E : TSX   
B75F : ADDD  $00,X
B761 : PULX  
B762 : ADDD  $00E4
B764 : ADDD  $00E8
B766 : STD   $00E6
B768 : LDD   $007D
B76A : SUBD  #$0028
B76D : CPD   $00E6
B770 : BCC   $B774
B772 : STD   $00E6
B774 : LDD   $007D
B776 : LSRD  
B777 : LSRD  
B778 : LSRD  
B779 : LSRD  
B77A : PSHB  
B77B : PSHA  
B77C : LDD   $00E6
B77E : TSX   
B77F : SUBD  $00,X
B781 : PULX  
B782 : CPD   $00E8
B785 : BLS   $B789
B787 : LDD   $00E8
B789 : COMA  
B78A : COMB  
B78B : ADDD  #$0001
B78E : BNE   $B793
B790 : LDD   #$FFFF
B793 : STD   $10E6
B796 : LDX   $007D
B798 : CPX   #$FFFF
B79B : BNE   $B7A2
B79D : LDD   #$000A
B7A0 : BRA   $B7B3
B7A2 : LDD   $00E6
B7A4 : FDIV  
B7A5 : XGDX  
B7A6 : LDAB  #$5A
B7A8 : MUL   
B7A9 : ADCA  #$00
B7AB : TAB   
B7AC : CLRA  
B7AD : CMPB  #$01
B7AF : BCC   $B7B3
B7B1 : LDAB  #$01
B7B3 : STD   $007F
B7B5 : LDAA  #$5A
B7B7 : SBA   
B7B8 : TAB   
B7B9 : CLRA  
B7BA : STD   $10EC
B7BD : LDY   #$0000
B7C1 : BCLR  $0054,10000000B
B7C4 : LDAA  $8018
B7C7 : BITA  #$80
B7C9 : BEQ   $B7EA
B7CB : BRCLR $0053,00001000B,$B7EA
B7CF : LDAA  $00CF			| Load A with Vehicle speed
B7D1 : CMPA  $834B			| Compare vehicle speed with 834B - byte is 0xFF
B7D4 : BCC   $B7EA
B7D6 : BSET  $0054,10000000B
B7D9 : LDAA  $0123			|A = M[$0123] - Engine speed
B7DC : CMPA  #$C0			|Compare 0xC0 - 4800 rpm
B7DE : BLS   $B7E2			|if ( A > 0xC0) then A = 0xC0 (4800 rpm)
B7E0 : LDAA  #$C0			|Load a with 0xC0
B7E2 : LDX   #$834C			|X = 0x834C
B7E5 : JSR   $FC14			|gosub FC14
B7E8 : BRA   $B832			|goto B832
B7EA : LDX   #$80A1			| X = 0x80A1 ??? spark table info - from chipsbyal.
B7ED : BRSET $0001,00000010B,$B808
B7F1 : LDAB  $01A9			| B = M[$01A9]  - Coolent temp lag filtered
B7F4 : CMPB  $809E			| compare B with M[$809E] (0x00)
B7F7 : BCC   $B803			| if ( B > M[$809E] (0x00) ) then goto B803
B7F9 : SUBB  $01AD			| B = B - M[$01AD] 
B7FC : BCS   $B80D			| if ( B < 0 ) then goto B80D
B7FE : CMPB  $809F			| compare B with M[$809F] (0xFF)
B801 : BCS   $B80D			| if ( B < M[$809F] (0xFF) ) then goto B80D
B803 : BSET  $0054,01000000B		| set bit 0x40 of M[$0054] - kwarm kickdown requested.
B806 : BRA   $B80D			| goto B80D
B808 : LDAB  $0150			| B = M[$0150]
B80B : BRA   $B80F			| goto B80F
B80D : LDAB  #$FF			| B = 0xFF
B80F : LDAA  $0123			| A = M[$0123]  - engine rpm
B812 : CMPA  #$A0			| compare A with 0xA0 (4000 rpm)
B814 : BCC   $B821			| if ( A > 0xA0 (4000 rpm) ) then goto B821
B816 : ADDA  #$60			| A = A + 0x60
B818 : CMPA  #$C0			| compare A with 0xC0 (2400 rpm before 0x60 was added)
B81A : BCC   $B82F			| if ( A < 0xC0 (2400 rpm before add)) then goto B82F
B81C : LDAA  $0124
B81F : BRA   $B82F
B821 : LDAA  $0125
B824 : CMPA  #$F0
B826 : BLS   $B82A
B828 : LDAA  #$F0
B82A : SUBA  #$80
B82C : LDX   #$81B4
B82F : JSR   $FB97
B832 : STAA  $0105
B835 : TAB   
B836 : ABY   
B838 : LDX   #$8238
B83B : LDAB  $0150
B83E : CMPB  #$A0
B840 : BLS   $B844
B842 : LDAB  #$A0
B844 : LDAA  $01AC
B847 : JSR   $FB97
B84A : STAA  $0106
B84D : TAB   
B84E : ABY   
B850 : LDAA  $01FF
B853 : BEQ   $B882
B855 : LDAA  $015A
B858 : LDAB  $0123
B85B : CMPB  #$50
B85D : BLS   $B861
B85F : LDAB  #$50
B861 : LDX   #$82A8
B864 : JSR   $FB97
B867 : LDAB  $01FF
B86A : MUL   
B86B : ADCA  #$00
B86D : LDAB  $010B
B870 : ADDB  $82A7
B873 : BCC   $B877
B875 : LDAB  #$FF
B877 : STAB  $010B
B87A : MUL   
B87B : ADCA  #$00
B87D : TAB   
B87E : ABY   
B880 : BRA   $B885
B882 : CLR   $010B
B885 : BCLR  $0053,10000000B
B888 : LDD   $3FCA
B88B : PSHB  
B88C : PSHA  
B88D : SUBD  $00F8
B88F : TSTA  
B890 : BEQ   $B894
B892 : LDAB  #$FF
B894 : SUBB  $00FD
B896 : BCC   $B899
B898 : CLRB  
B899 : PULX  
B89A : STAB  $00FA
B89C : STX   $00F8
B89E : CLRA  
B89F : BRSET $0002,10000000B,$B8BD
B8A3 : LDAB  $01A9			| B = M[$01A9]
B8A6 : SUBB  $01AD			| B = B - M[$01AD]
B8A9 : BLS   $B8B5			| if ( B < 0 ) then goto B8B5
B8AB : CMPB  $835C			| compare B with M[$835C] (0x35) 
B8AE : BLS   $B8B5			| if ( B < M[$835C] (0x35) ) then goto B8B5
B8B0 : BSET  $0002,10000000B		| set bit 0x80 of M[$0002] ( sets esc enabled by delta coolent )
B8B3 : BRA   $B8BD			| goto B8BD
B8B5 : LDAB  $01A9			| B = M[$01A9]  (coolent temp lag filtered )
B8B8 : CMPB  $835B			| compare B with M[$835B] (0x30)
B8BB : BCS   $B90E			| if ( B < M[$835B] (0x30) ) then goto B90E
B8BD : LDAB  $0127
B8C0 : CMPB  $8359
B8C3 : BCC   $B8CC
B8C5 : LDAB  $00CF			| B = M[$00CF]   - vehicle speed.
B8C7 : CMPB  $835A			| compare M[$835A] (0x02) with B  - with vehicle speed.
B8CA : BCS   $B90E			| if ( B < 0x02 ) then goto B90E
B8CC : BRCLR $0060,00100000B,$B8DE
B8D0 : LDX   #$837F			|X = 0x837F
B8D3 : LDAA  $0123			|A = M[$0123] - Engine Speed. - rpm = * 25
B8D6 : LSRA  				|A = A / 2
B8D7 : LDAB  #$10			|B = 0x10
B8D9 : JSR   $FC10			|gosub FC10
B8DC : BRA   $B8E8			|goto B8E8
B8DE : LDX   #$8387			|X = 0x8387
B8E1 : LDAA  $0150			|A = M[$0150]
B8E4 : LSRA  				|A = A / 2
B8E5 : JSR   $FC14			|gosub FC14
B8E8 : STAA  $00FC			|M[$00FC] = A
B8EA : BRCLR $005C,11100000B,$B8F0	|If (bits 0xE0 of M[$005C] are clear) then goto B8F0
					| if Malf 43D (esc sensor grounded) is not set
					| and  Malf 43C (Esc sensor open) is not set
					| and Malf 43A (one esc sensor open - not used on f-body) is not set goto B8F0
B8EE : BRA   $B90B			|goto B90B
*
* Knock Sensor is functioning.
*
B8F0 : LDAA  $0123			|A = M[$0123] - Engine speed - rpm = * 25
B8F3 : LDX   #$835D			|X = 0x835D
B8F6 : JSR   $FC14			|gosub FC14
B8F9 : LDAB  $00FA			|B = M[$00FA]
B8FB : MUL   				|D = A * B
B8FC : ASLD  				|D = D * 2
B8FD : ADDA  $00FB			|A = A + M[$00FB] - 0x00FB is retard due to knock 
B8FF : BCC   $B903			|if ( A >= 0xFF ) then A = 0xFF
B901 : LDAA  #$FF			|
B903 : CMPA  $00FC			|
B905 : BLS   $B90E			|if ( A > M[$00FC] ) then A = M[$00FC]
B907 : LDAA  $00FC			|
B909 : BRA   $B90E			|goto B90E
*
* Knock Sensor is broken
*
B90B : BSET  $0053,10000000B		|Set bit 0x80 of M[$0053] - Knock sensor failure
B90E : STAA  $00FB			|M[$00FB] = A
B910 : LSRA  
B911 : TAB   
B912 : LDX   #$0000
B915 : BRCLR $004F,11000000B,$B91D
B919 : BRSET $006E,00000001B,$B91E
B91D : ABX   
B91E : LDAB  $80A0
B921 : ABX   
B922 : LDAB  $8237
B925 : ABX   
B926 : LDAA  $801B
B929 : BITA  #$01
B92B : BNE   $B930
B92D : JMP   $B98D
B930 : PSHX  
B931 : BRCLR $004B,01000000B,$B941	| Branch if D,R car A/C request is cleared then goto B941
B935 : BRSET $0053,00010000B,$B948	
B939 : LDAA  $897B
B93C : STAA  $024C
B93F : BRA   $B950
B941 : LDAA  $024C
B944 : BEQ   $B96C
B946 : BRA   $B94D
B948 : LDAA  $024C
B94B : BEQ   $B950
B94D : DEC   $024C
B950 : LDX   $024D
B953 : INX   
B954 : BEQ   $B959
B956 : STX   $024D
B959 : LDX   $024D
B95C : CPX   $8979
B95F : BHI   $B972
B961 : LDAA  $0123				| A = M[$0123]    - Engine RPM
B964 : LDX   #$897C				| X = 0x897C
B967 : JSR   $FC14				| gosub FC14
B96A : BRA   $B97B				| goto B97B
B96C : LDX   #$0000				| X = 0x0000
B96F : STX   $024D				| M[$024D] = 0
B972 : LDAA  $024F				| A = M[$024F]
B975 : SUBA  $8978				| A = A - M[$8978]
B978 : BCC   $B97B				| if ( A < 0) then A = 0
B97A : CLRA  					|
B97B : STAA  $024F				| M[$024F] = A
B97E : TAB   					| B = A
B97F : LSRB  					| B = B / 2
B980 : LSRB  					| B = B / 2
B981 : PULX  					| Pull X 
B982 : ABX   					| X = X + B
B983 : BCLR  $0053,00010000B
B986 : BRCLR $004B,01000000B,$B98D		| if D, R car A/C request is requested then goto B98D
B98A : BSET  $0053,00010000B
B98D : CLRB  
B98E : BCLR  $0055,00000010B
B991 : BRSET $0001,00100000B,$B9B2
B995 : LDAA  $01AD
B998 : CMPA  $809C
B99B : BCS   $B9AF
B99D : LDAA  $0014				| Load A with LSB of engine running time (in seconds)
B99F : CMPA  $8912				| compare A with M[$8912]
B9A2 : BCC   $B9AF
B9A4 : LDAB  $809D
B9A7 : BEQ   $B9B2
B9A9 : BSET  $0055,00000010B
B9AC : ABX   
B9AD : BRA   $B9B2
B9AF : BSET  $0001,00100000B
B9B2 : STAB  $0107
B9B5 : BRCLR $0066,00010000B,$B9C6		| Branch if TCC locked for pass-by noise is cleared to B9C6
B9B9 : LDAB  $021F
B9BC : CMPB  $8566
B9BF : BCC   $B9C5
B9C1 : INCB  
B9C2 : STAB  $021F
B9C5 : ABX   
B9C6 : LDAB  $00FE
B9C8 : ABX   
B9C9 : PSHX  
B9CA : LDAA  $0123			| A = M[$0123] - Engine speed rpm
B9CD : LSRA  				| A = A / 2
B9CE : LDX   #$83AF			| X = 0x83AF
B9D1 : JSR   $FC14			| gosub FC14
B9D4 : TAB   				| B = A
B9D5 : LDAA  $0150			| A = M[$0150]
B9D8 : LDX   #$83B8			| X = 0x83B8
B9DB : JSR   $FC14			| gosub FC14
B9DE : MUL   				| D = A * B
B9DF : ADCA  #$00			| add carry
B9E1 : LDAB  $01D9			| B = M[$01D9]
B9E4 : MUL   				| D = A * B
B9E5 : ADCA  #$00			| add carry
B9E7 : STAA  $01DA			| M[$01DA] = A
B9EA : TAB   				| B = A
B9EB : PULX  				| Pull X
B9EC : ABX   				| X = X + B
B9ED : LDAB  $000C
B9EF : BPL   $B9F5
B9F1 : NEGB  
B9F2 : ABX   
B9F3 : BRA   $B9F7
B9F5 : ABY   
B9F7 : XGDY  
B9F9 : PSHX  
B9FA : TSX   
B9FB : SUBD  $00,X
B9FD : STD   $00,X
B9FF : BCLR  $0050,00000110B		| Clear idle spark high gain mode enabled and
					|       idle spark low gain mode enabled
BA02 : BRCLR $0058,00100100B,$BA0A
BA06 : LDAA  $00CF			| Load A with vehicle speed.
BA08 : BNE   $BA30			| if vehicle speed is not zero then goto BA30
BA0A : BRCLR $004F,11000000B,$BA12
BA0E : BRSET $006E,00010000B,$BA30
BA12 : BRCLR $006A,00001000B,$BA21
BA16 : LDAA  $02B3
BA19 : BITA  #$01
BA1B : BEQ   $BA21
BA1D : BITA  #$02
BA1F : BEQ   $BA30
BA21 : BRCLR $0053,00001000B,$BA30
BA25 : BRSET $006F,00000100B,$BA33
BA29 : LDX   $0013			| Load X with Engine running time.
BA2B : CPX   #$000A			| compare X with 0x000A (10 seconds)
BA2E : BHI   $BA33			| if it has been running more than 10 seconds then goto BA33
BA30 : JMP   $BAD4			| running less than 10 seconds goto BAD4
BA33 : LDAA  $00CF			| Load A with vehicle speed.
BA35 : BNE   $BA45			| if vehicle speed is not equal to zero then goto BA45
BA37 : BRSET $006F,00010000B,$BA50	
BA3B : LDAB  $0110			| Load B with desired idle speed - rpm = B * 12.5
BA3E : CMPB  $8333			| compare B with 0x8333 (value is 0x50) or 1000 rpm.
BA41 : BCS   $BA5B			| if rpm is less than 0x50 then goto BA5B
BA43 : BRA   $BA50			| rpm is greater than 0x50 goto BA50
BA45 : LDAA  $0154
BA48 : CMPA  $8338
BA4B : BHI   $BA50
BA4D : JMP   $BAD4
BA50 : LDAB  $8334
BA53 : STAB  $020F
BA56 : BSET  $0050,00000100B		| set Idle spark low gain mode to enabled
BA59 : BRA   $BA6B
BA5B : LDAB  $020F
BA5E : BEQ   $BA68
BA60 : DEC   $020F
BA63 : BSET  $0050,00000100B		| set idle spark low gain mode enabled
BA66 : BRA   $BA6B
BA68 : BSET  $0050,00000010B		| set idle spark high gain mode enabled
BA6B : LDAA  $0124			
BA6E : LDAB  $0110			| load b with desired idle speed.
BA71 : BRCLR $00CF,11111111B,$BA7C      | branch if vehicle speed is 0 to BA7C
BA75 : ADDB  $8337			| Add M[$8337] (0x02) to desired idle speed.
BA78 : BCC   $BA7C			| if B + M[$8337] did not overflow goto BA7C
BA7A : LDAB  #$FF			| limit B to 0xFF (3187 rpm)
BA7C : SBA   				
BA7D : LDX   #$8339
BA80 : BCLR  $0050,00001000B		| clear underspeed (used by idle spark logic) flag
BA83 : BCC   $BA8C
BA85 : NEGA  
BA86 : BSET  $0050,00001000B		| Set underspeed (used by idle spark logic) flag.
BA89 : LDX   #$833E			| X = 0x833E
BA8C : CMPA  #$10			| 		
BA8E : BLS   $BA92			| if ( A > 0x10) then A = 0x10
BA90 : LDAA  #$10		        | 	
BA92 : ASLA  				|
BA93 : ASLA  				| A = A * 4
BA94 : JSR   $FC14			| gosub FC14
BA97 : PSHA  				| push A
BA98 : LDX   #$8343			| X = 0x8343
BA9B : BRCLR $0050,00001000B,$BAA2	| if ( bits 0x08 of M[$0050] are clear) then goto BAA2
					| if underspeed is cleared then goto BAA2
BA9F : LDX   #$8347			| X = 0x8347
BAA2 : LDAA  $0150			| A = 0x0150
BAA5 : CMPA  #$60			|
BAA7 : BLS   $BAAB			| if ( A > 0x60) then A = 0x60
BAA9 : LDAA  #$60			|
BAAB : LSRA  				| A = A / 2
BAAC : JSR   $FC14			| gosub FC14
BAAF : PULB  				| pull B
BAB0 : MUL   				| D = A * B
BAB1 : ADCA  #$00			| Add carry
BAB3 : BRCLR $0050,00000100B,$BAC4	| branch if idle spark low gain mode cleared to BAC4
BAB7 : LDAB  $8335
BABA : BRSET $0050,00001000B,$BAC1	| branch if underspeed is set to BAC1
BABE : LDAB  $8336
BAC1 : MUL   
BAC2 : ADCA  #$00
BAC4 : TAB   
BAC5 : CLRA  
BAC6 : BRSET $0050,00001000B,$BACE	| branch if underspeed is set to BACE
BACA : NEGA  
BACB : NEGB  
BACC : SBCA  #$00
BACE : TSX   
BACF : ADDD  $00,X
BAD1 : PULX  
BAD2 : BRA   $BAD6
BAD4 : PULA  
BAD5 : PULB  
BAD6 : TSTA  
BAD7 : BPL   $BAE0
BAD9 : TSTB  
BADA : BMI   $BAE5
BADC : LDAB  #$80
BADE : BRA   $BAE5
BAE0 : TSTB  
BAE1 : BPL   $BAE5
BAE3 : LDAB  #$7F
BAE5 : STAB  $0102
BAE8 : BRCLR $004F,10000000B,$BAF1
BAEC : JSR   $5103
BAEF : BRA   $BAF8
BAF1 : BRCLR $004F,01000000B,$BAF8
BAF5 : JSR   $5803
BAF8 : BRCLR $006A,00001000B,$BB2A
BAFC : LDX   #$02B3
BAFF : BRCLR $00,X,00001000B,$BB2A
BB03 : BRSET $00,X,00010000B,$BB15
BB07 : LDAA  $03,X
BB09 : LDAB  #$5A
BB0B : MUL   
BB0C : ADCA  #$00
BB0E : BRCLR $00,X,00100000B,$BB35
BB12 : NEGA  
BB13 : BRA   $BB35
BB15 : LDAA  $03,X
BB17 : LDAB  #$5A
BB19 : MUL   
BB1A : ADCA  #$00
BB1C : TAB   
BB1D : LDAA  $0102
BB20 : BRSET $00,X,00100000B,$BB27
BB24 : ABA   
BB25 : BRA   $BB35
BB27 : SBA   
BB28 : BRA   $BB35
BB2A : LDAA  $0102
BB2D : BMI   $BB35
BB2F : LDAB  $0104
BB32 : MUL   
BB33 : ADCA  #$00
BB35 : SUBA  $8022
BB38 : PSHA  
BB39 : LDAA  $8024
BB3C : LDAB  $024F
BB3F : BEQ   $BB44
BB41 : LDAA  $8025
BB44 : STAA  $010A
BB47 : PULA  
BB48 : LDX   #$8019
BB4B : BRSET $00,X,00100000B,$BB52
BB4F : JMP   $BC6A
BB52 : STAA  $00ED
BB54 : TAB   
BB55 : SUBB  $8037
BB58 : LDAA  $0123			| A = M[$0123]
BB5B : CMPA  #$70			|
BB5D : BLS   $BB61			| if (A > 0x70) then A = 0x70
BB5F : LDAA  #$70			|
BB61 : LDX   #$8038			| X = 0x8038
BB64 : JSR   $FC14			| gosub FC14
BB67 : ABA   				| A = A + B
BB68 : CMPA  $8023			|
BB6B : BLE   $BB70			| if ( A > M[$8023] (value is 0x2E ) then A = M[$8023]
BB6D : LDAA  $8023			|
BB70 : CMPA  $010A			|
BB73 : BGE   $BB78			| if ( A < M[$010A] ) then A = M[$010A]
BB75 : LDAA  $010A			|
BB78 : STAA  $00EE			| M[$00EE] = A
BB7A : LDAA  $0123			| A = M[$0123]
BB7D : CMPA  #$70			|
BB7F : BLS   $BB83			| if ( A > 0x70) then A = 0x70
BB81 : LDAA  #$70			|
BB83 : LDX   #$8040			| X = 0x8040
BB86 : JSR   $FC14			| gosub FC14
BB89 : ABA   				| A = A + B
BB8A : CMPA  $8023			| 
BB8D : BLE   $BB92			| if (A > M[$8023] ) then A = M[$8023]
BB8F : LDAA  $8023			|
BB92 : CMPA  $010A			| 
BB95 : BGE   $BB9A			| if (A < M[$010A] ) then A = M[$010A]
BB97 : LDAA  $010A			| 
BB9A : STAA  $00EF			| M[$00EF] = A
BB9C : LDAA  $0123			| A = M[$0123]
BB9F : CMPA  #$70			|
BBA1 : BLS   $BBA5			| if ( A > 0x70) then A = 0x70
BBA3 : LDAA  #$70			| 
BBA5 : LDX   #$8048			| X = 0x8048
BBA8 : JSR   $FC14			| gosub FC14
BBAB : ABA   				| A = A + B
BBAC : CMPA  $8023			| 
BBAF : BLE   $BBB4			| if (A > M[$8023]) then A = M[$8023]
BBB1 : LDAA  $8023			|
BBB4 : CMPA  $010A			|
BBB7 : BGE   $BBBC			| if (A < M[$010A]) then A = M[$010A]
BBB9 : LDAA  $010A			| 
BBBC : STAA  $00F0			| M[$00F0] = A 
BBBE : LDAA  $0123
BBC1 : CMPA  #$70
BBC3 : BLS   $BBC7
BBC5 : LDAA  #$70
BBC7 : LDX   #$8050
BBCA : JSR   $FC14
BBCD : ABA   
BBCE : CMPA  $8023
BBD1 : BLE   $BBD6
BBD3 : LDAA  $8023
BBD6 : CMPA  $010A
BBD9 : BGE   $BBDE
BBDB : LDAA  $010A
BBDE : STAA  $00F1
BBE0 : LDAA  $0123
BBE3 : CMPA  #$70
BBE5 : BLS   $BBE9
BBE7 : LDAA  #$70
BBE9 : LDX   #$8058
BBEC : JSR   $FC14
BBEF : ABA   
BBF0 : CMPA  $8023
BBF3 : BLE   $BBF8
BBF5 : LDAA  $8023
BBF8 : CMPA  $010A
BBFB : BGE   $BC00
BBFD : LDAA  $010A
BC00 : STAA  $00F2
BC02 : LDAA  $0123
BC05 : CMPA  #$70
BC07 : BLS   $BC0B
BC09 : LDAA  #$70
BC0B : LDX   #$8060
BC0E : JSR   $FC14
BC11 : ABA   
BC12 : CMPA  $8023
BC15 : BLE   $BC1A
BC17 : LDAA  $8023
BC1A : CMPA  $010A
BC1D : BGE   $BC22
BC1F : LDAA  $010A
BC22 : STAA  $00F3
BC24 : LDAA  $0123
BC27 : CMPA  #$70
BC29 : BLS   $BC2D
BC2B : LDAA  #$70
BC2D : LDX   #$8068
BC30 : JSR   $FC14
BC33 : ABA   
BC34 : CMPA  $8023
BC37 : BLE   $BC3C
BC39 : LDAA  $8023
BC3C : CMPA  $010A
BC3F : BGE   $BC44
BC41 : LDAA  $010A
BC44 : STAA  $00F4
BC46 : LDAA  $0123
BC49 : CMPA  #$70
BC4B : BLS   $BC4F
BC4D : LDAA  #$70
BC4F : LDX   #$8070
BC52 : JSR   $FC14
BC55 : ABA   
BC56 : CMPA  $8023
BC59 : BLE   $BC5E
BC5B : LDAA  $8023
BC5E : CMPA  $010A
BC61 : BGE   $BC66
BC63 : LDAA  $010A
BC66 : STAA  $00F5
BC68 : LDAA  $00ED
BC6A : CMPA  $8023
BC6D : BLE   $BC72
BC6F : LDAA  $8023
BC72 : CMPA  $010A
BC75 : BGE   $BC7A
BC77 : LDAA  $010A
BC7A : STAA  $00EC
BC7C : LDAB  $00EC
BC7E : BRSET $0051,00000010B,$BC9C
BC82 : LDAB  $0108
BC85 : LDX   #$8019
BC88 : BRCLR $00,X,00100000B,$BC9C
BC8C : STAB  $00EE
BC8E : STAB  $00EF
BC90 : STAB  $00F0
BC92 : STAB  $00F1
BC94 : STAB  $00F2
BC96 : STAB  $00F3
BC98 : STAB  $00F4
BC9A : STAB  $00F5
BC9C : BRCLR $005A,01000000B,$BCA3
BCA0 : JMP   $BD27
BCA3 : PSHB  
BCA4 : LDX   $007D
BCA6 : LDD   $8026
BCA9 : IDIV  
BCAA : XGDX  
BCAB : LSRD  
BCAC : ADCB  #$00
BCAE : STAB  $00F6
BCB0 : LDX   #$8019
BCB3 : BRCLR $00,X,00100000B,$BD1A
BCB7 : INS   
BCB8 : LDAB  $00EE
BCBA : ADDB  $00F6
BCBC : LDAA  #$59
BCBE : SBA   
BCBF : TAB   
BCC0 : CLRA  
BCC1 : STD   $10D6
BCC4 : LDAB  $00EF
BCC6 : ADDB  $00F6
BCC8 : LDAA  #$59
BCCA : SBA   
BCCB : TAB   
BCCC : CLRA  
BCCD : STD   $10D8
BCD0 : LDAB  $00F0
BCD2 : ADDB  $00F6
BCD4 : LDAA  #$59
BCD6 : SBA   
BCD7 : TAB   
BCD8 : CLRA  
BCD9 : STD   $10DA
BCDC : LDAB  $00F1
BCDE : ADDB  $00F6
BCE0 : LDAA  #$59
BCE2 : SBA   
BCE3 : TAB   
BCE4 : CLRA  
BCE5 : STD   $10DC
BCE8 : LDAB  $00F2
BCEA : ADDB  $00F6
BCEC : LDAA  #$59
BCEE : SBA   
BCEF : TAB   
BCF0 : CLRA  
BCF1 : STD   $10DE
BCF4 : LDAB  $00F3
BCF6 : ADDB  $00F6
BCF8 : LDAA  #$59
BCFA : SBA   
BCFB : TAB   
BCFC : CLRA  
BCFD : STD   $10E0
BD00 : LDAB  $00F4
BD02 : ADDB  $00F6
BD04 : LDAA  #$59
BD06 : SBA   
BD07 : TAB   
BD08 : CLRA  
BD09 : STD   $10E2
BD0C : LDAB  $00F5
BD0E : ADDB  $00F6
BD10 : LDAA  #$59
BD12 : SBA   
BD13 : TAB   
BD14 : CLRA  
BD15 : STD   $10E4
BD18 : BRA   $BD99
BD1A : PULB  
BD1B : ADDB  $00F6
BD1D : LDAA  #$59
BD1F : SBA   
BD20 : TAB   
BD21 : CLRA  
BD22 : STD   $10F2
BD25 : BRA   $BD99
BD27 : TSTB  
BD28 : BPL   $BD38
BD2A : NEGB  
BD2B : LDAA  #$B6
BD2D : MUL   
BD2E : ASLD  
BD2F : ASLD  
BD30 : LDX   #$007D
BD33 : JSR   $FB83			| Routine returns D = AIN (byte)  * M[$X] (word)
BD36 : BRA   $BD47
BD38 : LDAA  #$B6
BD3A : MUL   
BD3B : ASLD  
BD3C : ASLD  
BD3D : LDX   #$007D
BD40 : JSR   $FB83			| Routine returns D = AIN (byte)  * M[$X] (word)
BD43 : NEGA  
BD44 : NEGB  
BD45 : SBCA  #$00
BD47 : PSHA  
BD48 : PSHB  
BD49 : LDD   $8026
BD4C : LDX   #$B400
BD4F : FDIV  
BD50 : XGDX  
BD51 : ADDD  #$0080
BD54 : TAB   
BD55 : PULA  
BD56 : SBA   
BD57 : TAB   
BD58 : PULA  
BD59 : SBCA  #$00
BD5B : PSHB  
BD5C : PSHA  
BD5D : TSX   
BD5E : LDD   #$0000
BD61 : SUBD  $007D
BD63 : LSRD  
BD64 : LSRD  
BD65 : LSRD  
BD66 : LSRD  
BD67 : ORAA  #$F0
BD69 : ADDD  $3FF6
BD6C : CPD   $00,X
BD6F : BMI   $BD73
BD71 : STD   $00,X
BD73 : LDD   $00,X
BD75 : SUBD  $3FF6
BD78 : NOP  
BD79 : NOP  
BD7A : NOP  
BD7B : NOP  
BD7C : STD   $3FE8
BD7F : NOP  
BD80 : NOP  
BD81 : NOP  
BD82 : NOP  
BD83 : ADDD  $3FDC
BD86 : SUBD  $00E6
BD88 : BRN   $BD8D
BD8A : STD   $3FE6
BD8D : NOP  
BD8E : NOP  
BD8F : LDD   $00E6
BD91 : STD   $3FDC
BD94 : PULA  
BD95 : PULB  
BD96 : STD   $3FF6
BD99 : LDAA  #$AA
BD9B : STAA  $103A
BD9E : BRSET $0068,00100000B,$BE04
BDA2 : LDX   #$898E			| X = 0x898E
BDA5 : LDAB  $0049			| B = M[$0049]
BDA7 : ANDB  #$1F			| B = B & 0x1F
BDA9 : ABX   				| X = X + B
BDAA : LDX   $00,X			| X = M[$X]
BDAC : BEQ   $BE04			| if ( X == 0 ) then goto BE04
BDAE : LDAA  $02,X			| A = M[$(X+0x02)]
BDB0 : BEQ   $BE04			| if ( A == 0) then goto BE04
BDB2 : BRSET $006A,01000000B,$BDF7
BDB6 : BSET  $006A,01000000B
BDB9 : STX   $0288			| M[$0288] = X
BDBC : LDAB  $102E			| Serial communications status register
BDBF : STAA  $102F			| Serial communications data register
BDC2 : STAA  $0287			| SCI checksum
BDC5 : LDAB  $04,X
BDC7 : STAB  $02B8
BDCA : BEQ   $BDDF
BDCC : LDY   $05,X
BDCF : PSHX  
BDD0 : LDX   $09,X
BDD2 : LDAA  $00,X
BDD4 : STAA  $00,Y
BDD7 : INY   
BDD9 : PULX  
BDDA : INX   
BDDB : INX   
BDDC : DECB  
BDDD : BNE   $BDCF
BDDF : LDAB  #$01
BDE1 : STAB  $0286
BDE4 : SEI   
BDE5 : LDX   #$4002
BDE8 : BSET  $00,X,00010000B
BDEB : BRSET $0068,00100000B,$BDF0
BDEF : CLI   
BDF0 : LDAA  #$88
BDF2 : STAA  $102D				| Serial Communications Control reg #2
BDF5 : BRA   $BE04
BDF7 : BRSET $006A,00100000B,$BE04
BDFB : BSET  $006A,00100000B
BDFE : BSET  $004F,00001000B
BE01 : STAB  $02BA
BE04 : BRSET $0070,00000100B,$BE12
BE08 : BRSET $0001,00010000B,$BE29
BE0C : BRCLR $004F,00010000B,$BE29
BE10 : BRA   $BE1B
BE12 : LDAA  $003B
BE14 : BNE   $BE22
BE16 : BSET  $0001,00010000B
BE19 : BRA   $BE2D
BE1B : BSET  $0070,00000100B
BE1E : LDAA  #$FF
BE20 : STAA  $003B
BE22 : LDAA  #$FF
BE24 : STAA  $010F
BE27 : BRA   $BE5F
BE29 : BRSET $0050,10000000B,$BE68
BE2D : BRCLR $0056,01000000B,$BE36
BE31 : LDAB  $8500
BE34 : STAB  $003D
BE36 : LDAB  $88B3
BE39 : BRSET $004F,00010000B,$BE47
BE3D : LDAB  $0118
BE40 : ADDB  $0121
BE43 : BCC   $BE47
BE45 : LDAB  #$FF
BE47 : JSR   $FAA3
BE4A : LDAA  #$FF
BE4C : STAA  $0116
BE4F : STAA  $0110				| M[$0110] = A  (desired idle speed)
BE52 : LDAA  #$80
BE54 : STAA  $006F
BE56 : CLRA  
BE57 : BRSET $004C,00000001B,$BE5D
BE5B : LDAA  #$90
BE5D : STAA  $0070
BE5F : CLR   $0113
BE62 : BCLR  $006F,00010000B
BE65 : JMP   $C309
BE68 : LDAA  $00D7
BE6A : LDX   #$8515
BE6D : JSR   $FC14
BE70 : STAA  $022D
BE73 : LDAA  $0169
BE76 : STAA  $016A
BE79 : LDAA  $0164
BE7C : TAB   
BE7D : SUBB  $0169
BE80 : BCC   $BE83
BE82 : NEGB  
BE83 : CMPB  $88D8
BE86 : BLS   $BE8B
BE88 : STAA  $0169
BE8B : BRCLR $0058,00100100B,$BE96
BE8F : LDAA  $88D7
BE92 : ASLA  
BE93 : STAA  $0169
BE96 : BRCLR $0070,00001000B,$BF10
BE9A : BRSET $0065,00000001B,$BEA2		| branch if Fan 1 is enabled
BE9E : BRSET $0065,00000100B,$BECA		| branch if fan 1 is requested
BEA2 : BRSET $0065,00001000B,$BEAA		| branch if fan 2 is enabled
BEA6 : BRSET $0065,00010000B,$BECA		| branch if fan 2 is requested.
BEAA : BRSET $0001,00000010B,$BF06		
BEAE : BRCLR $0054,01000000B,$BF06
BEB2 : LDAA  $88B4
BEB5 : ASLA  
BEB6 : SUBA  $011A
BEB9 : BHI   $BEC6
BEBB : BSET  $0001,00000010B
BEBE : BCLR  $0054,01000000B
BEC1 : LDAA  $88F5
BEC4 : BRA   $BF03
BEC6 : LDAA  #$82
BEC8 : BRA   $BEEB
BECA : LDAA  $00DC
BECC : CMPA  #$5A
BECE : BLS   $BEF6
BED0 : LDAA  $0169
BED3 : CMPA  $88D7
BED6 : BCC   $BEF6
BED8 : LDAA  $01A0
BEDB : CMPA  $88DA
BEDE : BHI   $BEF6
BEE0 : LDAA  $84C5
BEE3 : ASLA  
BEE4 : SUBA  $011A
BEE7 : BLS   $BEF6
BEE9 : LDAA  #$02
BEEB : STAA  $010F
BEEE : BSET  $006F,00001000B
BEF1 : BCLR  $006F,00010000B
BEF4 : BRA   $BF10
BEF6 : BSET  $0065,00000001B			| set bit to enable fan #1
BEF9 : BRCLR $0065,00010000B,$BF00		| branch if fan #2 is not requested
BEFD : BSET  $0065,00001000B			| set bit to enable fan #2
BF00 : LDAA  $88F4
BF03 : STAA  $0117
BF06 : BCLR  $006F,00001000B
BF09 : CLR   $011A
BF0C : BRCLR $0070,00100000B,$BF13
BF10 : JMP   $C04C
BF13 : LDAA  $0169
BF16 : BRCLR $0056,00010000B,$BF28
BF1A : LDAB  $011C
BF1D : BEQ   $BF28
BF1F : DECB  
BF20 : STAB  $011C
BF23 : ADDA  $87F7
BF26 : BCS   $BF3A
BF28 : BRCLR $0060,00000010B,$BF31
BF2C : ADDA  $87FE
BF2F : BCS   $BF3A
BF31 : BRCLR $0057,10000000B,$BF3C
BF35 : ADDA  $87B8
BF38 : BCC   $BF3C
BF3A : LDAA  #$FF
BF3C : CMPA  $88D7
BF3F : BHI   $BF5E
BF41 : LDAA  $016A
BF44 : CMPA  $88D7
BF47 : BLS   $BF4F
BF49 : LDAA  $88F3
BF4C : STAA  $0117
BF4F : CLRA  
BF50 : BRCLR $006F,01010000B,$BF56
BF54 : BRA   $BF6E
BF56 : TST   $0113
BF59 : BNE   $BF5E
BF5B : JMP   $C001
BF5E : LDAB  $88ED
BF61 : MUL   
BF62 : ASLD  
BF63 : BCC   $BF67
BF65 : LDAA  #$FF
BF67 : LDAB  $88EE
BF6A : CBA   
BF6B : BLS   $BF6E
BF6D : TBA   
BF6E : BRSET $006F,10000000B,$BF92
BF72 : LDAB  $003D
BF74 : CMPB  $8501
BF77 : BHI   $BF7E
BF79 : CMPB  $8502
BF7C : BCC   $BF86
BF7E : LDAB  $8500
BF81 : STAB  $003D
BF83 : BSET  $0056,01000000B
BF86 : ABA   
BF87 : BCS   $BF8E
BF89 : ADDA  $022D
BF8C : BCC   $BF99
BF8E : LDAA  #$FF
BF90 : BRA   $BF99
BF92 : BRCLR $006F,01000000B,$BF99
BF96 : BSET  $006F,00100000B
BF99 : BRCLR $0070,10000000B,$BFA5
BF9D : LDAB  $88EF
BFA0 : MUL   
BFA1 : ADCA  #$00
BFA3 : BRA   $BFC4
BFA5 : LDAB  $01A0
BFA8 : CMPB  $88DA
BFAB : BLS   $BFC4
BFAD : PSHA  
BFAE : LDAA  $00CF			| A = M[$00CF]   - Load A with vehicle speed
BFB0 : ASLA  				| A = A * 2   - SPeed = speed * 2
BFB1 : BCS   $BFB6			| if ( A > 255 ) then goto BFB6  - if overflow (speed * 2 > 255) then goto BFB6
BFB3 : ASLA  				| A = A * 2   - speed = speed * 2
BFB4 : BCC   $BFB8			| if ( A < 255 ) then goto BFB8  - if overflow (speed * 4 < 255> then goto BFB8
BFB6 : LDAA  #$FF			| A = 0xFF
BFB8 : LDX   #$8901			| X = 0x8901
BFBB : JSR   $FC14			| gosub FC14
BFBE : PULB  				| pull B
BFBF : ABA   
BFC0 : BCC   $BFC4
BFC2 : LDAA  #$FF
BFC4 : BSET  $006F,00010000B
BFC7 : SUBA  $0113
BFCA : BCS   $BFD2
BFCC : BPL   $BFE3
BFCE : LDAA  #$7F
BFD0 : BRA   $BFE3
BFD2 : NEGA  
BFD3 : BPL   $BFD7
BFD5 : LDAA  #$7F
BFD7 : CMPA  #$03
BFD9 : BCC   $BFE1
BFDB : LDAB  $88F3
BFDE : STAB  $0117
BFE1 : ORAA  #$80
BFE3 : STAA  $010F
BFE6 : ASLA  
BFE7 : BEQ   $BFF7
BFE9 : BCS   $C04C
BFEB : LDAA  $003B			| Load IAC motor counts
BFED : CMPA  $88FE			| Compare with M[88FE]
BFF0 : BCS   $C04C			| if iac counts is higher than M[$88FE]
BFF2 : BCLR  $006F,00010000B
BFF5 : BRA   $C001
BFF7 : BCLR  $006F,00110000B
BFFA : BRCLR $006F,10000000B,$C001
BFFE : BCLR  $0000,01000001B
C001 : BRCLR $006A,00001000B,$C019
C005 : LDAA  $02AF
C008 : BITA  #$02
C00A : BEQ   $C019
C00C : BCLR  $006F,00000100B
C00F : LDAA  $02B0
C012 : BITA  #$02
C014 : BNE   $C04C
C016 : BSET  $006F,00000100B
C019 : BRSET $006F,00000100B,$C04C
C01D : LDAA  $01A0
C020 : BNE   $C048
C022 : LDAA  $0169
C025 : CMPA  $88D7
C028 : BCC   $C048
C02A : LDAA  $0127
C02D : CMPA  $0110
C030 : BLS   $C039
C032 : LDAA  #$82
C034 : BSET  $006F,00000010B
C037 : BRA   $C049
C039 : LDAA  #$02
C03B : BRCLR $006F,00000010B,$C049
C03F : BSET  $006F,00000100B
C042 : LDAA  $88F2
C045 : STAA  $0117
C048 : CLRA  
C049 : STAA  $010F
C04C : BRCLR $0049,00000111B,$C053		| if ( bit 0x07 of M[$0049] is clear ) then goto C053
C050 : JMP   $C30F				| goto C30F
C053 : PSHX  
C054 : PSHX  
C055 : PSHX  
C056 : PSHX  
C057 : TSY   
C059 : BCLR  $0070,00100000B
C05C : LDX   #$88B8			| X = 0x88B8
C05F : BRCLR $0070,10000000B,$C066	| if ( bit 0x80 of M[$0070] is clear) then goto C066
C063 : LDX   #$88C6			| X = 0x88C6
C066 : LDAA  $01AC			| A = M[$01AC] - Coolent temp Lag filtered limited to 0xD0
C069 : JSR   $FC14			| gosub FC14 - Table lookup, looks up using upper nibble, and interpolate
C06C : LDAB  $801B			| B = 0x801B
C06F : BITB  #$20			| Test bit 0x20 of B
C071 : BEQ   $C07E			| if ( bit 0x20 of B (M[$801B] (0x5A)) then goto C07E (branch should be taken)
C073 : BRSET $0070,00000010B,$C082
C077 : BRCLR $004C,00100000B,$C07E
C07B : BSET  $0070,00000010B
C07E : BRCLR $0057,00010000B,$C085	| if (bit 0x10 of M[$0057] is clear) then goto C085  -  if ( AC is not requested ) then goto C085
C082 : ADDA  $88B7			| A = A + M[$88B7] (0x00)
C085 : BRCLR $0055,00000010B,$C08C	| if (bit 0x02 of M[$0055] is clear) then goto C08C
C089 : ADDA  $8913			| A = A + M[$8913] (0x0A)
C08C : BRCLR $006A,00001000B,$C09E	| if (bit 0x08 of M[$006A] is clear) then goto C09E  - set if certain ALDL message was input
C090 : LDAB  $02B3			| B = M[$02B3] - input aldl message
C093 : BITB  #$01			| test bit 0x01 of B
C095 : BEQ   $C09E			| if ( bit 0x01 of B is clear) then goto C09E
C097 : BITB  #$02			| test bit 0x02 of B
C099 : BEQ   $C09E			| if ( bit 0x02 of B is clear) then goto C09E
C09B : LDAA  $02B4			| A = M[$02B4] - force idle rpm to this value - input from aldl port.
C09E : STAA  $0110			| M[$0110] = A   - Store desired idle speed.
C0A1 : CMPA  $0127
C0A4 : BCC   $C0A9
C0A6 : BSET  $006F,00000010B
C0A9 : LDD   $010D
C0AC : SUBD  $0127
C0AF : RORA  
C0B0 : RORB  
C0B1 : ASRA  
C0B2 : RORB  
C0B3 : ASRA  
C0B4 : RORB  
C0B5 : ASRA  
C0B6 : RORB  
C0B7 : BSR   $C10B
C0B9 : STAB  $010D
C0BC : LDD   #$0000
C0BF : STD   $00,Y
C0C2 : LDAB  $0127
C0C5 : STD   $04,Y
C0C8 : LDAB  $0110
C0CB : SUBD  $04,Y
C0CE : BSR   $C10B
C0D0 : STAB  $04,Y
C0D3 : TBA   
C0D4 : BPL   $C0D7
C0D6 : NEGA  
C0D7 : STAA  $02,Y
C0DA : CMPA  $88D6
C0DD : BLS   $C0E2
C0DF : CLRA  
C0E0 : BRA   $C0E8
C0E2 : LDAA  $0114
C0E5 : INCA  
C0E6 : BEQ   $C0EB
C0E8 : STAA  $0114
C0EB : LDAA  $0117
C0EE : BEQ   $C0F4
C0F0 : DECA  
C0F1 : STAA  $0117
C0F4 : LDAA  $0169
C0F7 : CMPA  $88D7
C0FA : BCC   $C104
C0FC : LDAA  $01A0
C0FF : CMPA  $88DA
C102 : BLS   $C11C
C104 : BCLR  $006F,00000001B
C107 : TBA   
C108 : JMP   $C197
C10B : ASLD  
C10C : BCC   $C115
C10E : INCA  
C10F : BEQ   $C11A
C111 : CLRB  
C112 : SEC   
C113 : BRA   $C11A
C115 : TSTA  
C116 : BEQ   $C11A
C118 : LDAB  #$FF
C11A : RORB  
C11B : RTS   
*
* Start of this subroutine 
*
C11C : TST   $01A0
C11F : BNE   $C18E
C121 : BRCLR $0070,10000000B,$C131
C125 : BRSET $0070,00010000B,$C149
C129 : BSET  $0070,00010000B
C12C : CLR   $0117
C12F : BRA   $C146
C131 : BRCLR $0070,00010000B,$C149
C135 : BCLR  $0070,00010000B
C138 : LDAA  $01A9			| A = M[$01A9]  - coolent temp lag filtered
C13B : LSRA  				| A = A / 2 
C13C : LSRA  				| A = A / 2
C13D : LDX   #$88F6			| X = 0x88F6
C140 : JSR   $FC14			| gosub FC14
C143 : STAA  $0117			| M[$0117] = A
C146 : CLR   $0114
C149 : LDAA  $0117
C14C : BNE   $C196
C14E : PSHB  
C14F : LDAA  $0114
C152 : CMPA  $8505
C155 : BLS   $C18D
C157 : BRSET $0070,00000001B,$C18D
C15B : BRSET $0055,00000010B,$C18D
C15F : LDAB  $801A
C162 : BITB  #$20
C164 : BNE   $C16C
C166 : BRSET $0049,00011000B,$C16C		| if ( bit 0x18 of M[$0049] is set ) then goot C16C
C16A : BRA   $C18D				| goto C18D
C16C : LDAA  $0116
C16F : LDAB  $011B
C172 : BEQ   $C18D
C174 : BMI   $C181
C176 : INCA  
C177 : CMPA  $0118
C17A : BLS   $C187
C17C : LDAA  $0118
C17F : BRA   $C18A
C181 : DECA  
C182 : BNE   $C187
C184 : INCA  
C185 : BRA   $C18A
C187 : CLR   $0120
C18A : STAA  $0116
C18D : PULB  
C18E : BRCLR $006F,00000100B,$C19A
C192 : BRCLR $006F,00011000B,$C1DE
C196 : TBA   
C197 : TSTA  
C198 : BPL   $C1CC
C19A : CLR   $0114
C19D : LDAB  $0169
C1A0 : CMPB  $88D9
C1A3 : BCS   $C1C9
C1A5 : LDAB  $01A0
C1A8 : CMPB  $88DA
C1AB : BLS   $C1C9
C1AD : LDAB  $011B
C1B0 : BLE   $C1C9
C1B2 : LDAA  $0049			| A = M[$0049]
C1B4 : ANDA  #$18			| A = A & 0x18
C1B6 : CMPA  #$18			| compare A with 0x18
C1B8 : BNE   $C1C9			| if ( A != 0x18 ) then goto C1C9
C1BA : BRSET $006F,00001000B,$C1C9
C1BE : BCLR  $006F,00010000B
C1C1 : LDAB  #$81
C1C3 : STAB  $010F
C1C6 : BSET  $0070,00100000B
C1C9 : JMP   $C305
C1CC : LDAB  $8900
C1CF : BEQ   $C1D6
C1D1 : LDAB  $01A0
C1D4 : BNE   $C19A
C1D6 : CMPA  $88DB
C1D9 : BLS   $C19A
C1DB : BCLR  $006F,00011000B
C1DE : LDX   #$88B2
C1E1 : BRSET $0070,10000000B,$C1E6
C1E5 : INX   
C1E6 : LDAA  $22,X
C1E8 : STAA  $05,Y
C1EB : LDAA  $34,X
C1ED : LDAB  $32,X
C1EF : STD   $06,Y
C1F2 : LDAB  $04,Y
C1F5 : LDX   #$88B2
C1F8 : LDAA  $02,Y
C1FB : CMPA  $05,Y
C1FE : BLS   $C231
C200 : TSTB  
C201 : BMI   $C219
C203 : LDAA  $2A,X
C205 : CMPB  $2C,X
C207 : BLS   $C222
C209 : ADDA  $2D,X
C20B : BCC   $C222
C20D : PSHB  
C20E : MUL   
C20F : ADCA  #$00
C211 : PULB  
C212 : ABA   
C213 : BPL   $C225
C215 : LDAA  #$7F
C217 : BRA   $C225
C219 : LDAA  $2B,X
C21B : NEGB  
C21C : MUL   
C21D : ADCA  #$00
C21F : NEGA  
C220 : BRA   $C225
C222 : MUL   
C223 : ADCA  #$00
C225 : TAB   
C226 : CLRA  
C227 : TSTB  
C228 : BPL   $C22B
C22A : COMA  
C22B : ADDD  $00,Y
C22E : STD   $00,Y
C231 : CPX   #$88B6
C234 : BEQ   $C24B
C236 : LDX   #$88B6
C239 : LDAB  $010D
C23C : TBA   
C23D : BPL   $C240
C23F : NEGA  
C240 : STAA  $03,Y
C243 : CMPA  $88FF
C246 : BCC   $C200
C248 : LDD   $00,Y
C24B : JSR   $C10B
C24E : STAB  $00,Y
C251 : BPL   $C254
C253 : NEGB  
C254 : TBA   
C255 : BRCLR $0070,10000000B,$C25F
C259 : LDAB  $88E8
C25C : MUL   
C25D : ADCA  #$00
C25F : CMPA  $88F1
C262 : BCS   $C26F
C264 : CLR   $0111
C267 : LDAB  $00,Y
C26A : STAB  $04,Y
C26D : BRA   $C2B4
C26F : LDAB  $03,Y
C272 : CMPB  $06,Y
C275 : BLS   $C27A
C277 : JMP   $C2FF
C27A : LDAB  $07,Y
C27D : LDAA  $02,Y
C280 : CMPA  $05,Y
C283 : BHI   $C294
C285 : CMPA  $88FD
C288 : BLS   $C2FF
C28A : LDAB  $88FB
C28D : BRSET $0070,10000000B,$C294
C291 : LDAB  $88FC
C294 : MUL   
C295 : ASLD  
C296 : LDAB  $04,Y
C299 : BPL   $C29C
C29B : NEGA  
C29C : ADDA  $0111
C29F : BVC   $C2A6
C2A1 : LDAA  #$7F
C2A3 : BCC   $C2A6
C2A5 : NEGA  
C2A6 : STAA  $04,Y
C2A9 : STAA  $0111
C2AC : BPL   $C2AF
C2AE : NEGA  
C2AF : CMPA  $88F1
C2B2 : BCS   $C302
C2B4 : LDAB  $88F0
C2B7 : MUL   
C2B8 : ADCA  #$00
C2BA : STD   $06,Y
C2BD : LDAA  $88F1
C2C0 : MUL   
C2C1 : ADCA  #$00
C2C3 : BPL   $C2C7
C2C5 : LDAA  #$7F
C2C7 : STAA  $05,Y
C2CA : LDX   #$8914			| X = 0x8914
C2CD : LDAA  $01A9			| A = M[$01A9]  - coolent temp lag filtered
C2D0 : JSR   $FC09			| gosub FC09
C2D3 : PSHY  
C2D5 : PULX  
C2D6 : LDAB  #$06
C2D8 : ABX   
C2D9 : JSR   $FB83			| Routine returns D = AIN (byte)  * M[$X] (word)
C2DC : LSLB  
C2DD : ADCA  #$00
C2DF : TAB   
C2E0 : LDAA  $04,Y
C2E3 : ROLA  
C2E4 : LDAA  $05,Y
C2E7 : BCC   $C2EC
C2E9 : NEGA  
C2EA : ORAB  #$80
C2EC : STAB  $010F
C2EF : LSLB  
C2F0 : BEQ   $C2F5
C2F2 : BSET  $0070,00100000B
C2F5 : LDAB  $0111
C2F8 : BEQ   $C305
C2FA : STAA  $0111
C2FD : BRA   $C305
C2FF : CLR   $0111
C302 : CLR   $010F
C305 : PULX  
C306 : PULX  
C307 : PULX  
C308 : PULX  
C309 : LDD   $0127
C30C : STD   $010D
C30F : JMP   $CEBE			| goto CEBE
C312 : BCLR  $0056,00000100B
C315 : LDAB  $0164
C318 : CMPB  $873F
C31B : BHI   $C328
C31D : LDAB  $01A0
C320 : CMPB  $8740
C323 : BHI   $C328
C325 : BSET  $0056,00000100B
C328 : LDX   $0203
C32B : BRSET $004F,00010000B,$C332
C32F : JMP   $C3CC
C332 : CPX   #$0008
C335 : BCC   $C33A
C337 : JMP   $C3CF
C33A : BCLR  $0001,11101011B
C33D : BCLR  $0002,11011111B
C340 : LDAA  $801A
C343 : BITA  #$40
C345 : BNE   $C34A
C347 : BCLR  $0002,00100000B
C34A : BCLR  $0053,01000000B
C34D : LDAA  $800F
C350 : STAA  $0217
C353 : CLR   $01F4
C356 : CPX   $8015
C359 : BCS   $C393
C35B : LDAA  $01A0
C35E : BNE   $C36A
C360 : BRCLR $005B,00000011B,$C366
C364 : BRA   $C36A
C366 : LDAA  $00DA
C368 : STAA  $003F
C36A : LDAA  #$50
C36C : TAP   
C36D : LDX   #$1002
C370 : BCLR  $00,X,00000100B
C373 : LDAA  $4006
C376 : EORA  #$80
C378 : STAA  $4006
C37B : EORA  #$80
C37D : STAA  $4006
C380 : LDX   #$01A4
C383 : NOP  
C384 : NOP  
C385 : DEX   
C386 : BNE   $C383
C388 : CLR   $0047
C38B : LDAB  #$08
C38D : STAB  $1039
C390 : STOP  
C391 : BRA   $C391
C393 : INX   
C394 : STX   $0203
C397 : LDD   #$0000
C39A : STD   $0013
C39C : STD   $020D
C39F : STD   $024D
C3A2 : BCLR  $0051,00000010B
C3A5 : CLR   $0209
C3A8 : BCLR  $0050,10000000B
C3AB : CLR   $0208
C3AE : BCLR  $0070,01000010B
C3B1 : LDAA  $0235
C3B4 : LDX   #$8641
C3B7 : JSR   $FC14
C3BA : STAA  $003E
C3BC : CLR   $01BC
C3BF : BCLR  $0060,00000001B
C3C2 : LDD   #$FFFF
C3C5 : STD   $007D
C3C7 : BCLR  $0050,00000001B
C3CA : BRA   $C3D3
C3CC : LDX   #$FFFF
C3CF : INX   
C3D0 : STX   $0203
C3D3 : BRCLR $0050,10000000B,$C3DA
C3D7 : JMP   $C44E
C3DA : BRSET $004F,00010000B,$C434
C3DE : BRSET $0002,00100000B,$C3EA
C3E2 : LDAA  $01F4
C3E5 : CMPA  $8014
C3E8 : BCC   $C434
C3EA : LDD   $007D
C3EC : CPD   $861B
C3F0 : BRCLR $0061,00000100B,$C3F8
C3F4 : CPD   $861D
C3F8 : BLS   $C407
C3FA : BSET  $0061,00000100B
C3FD : LDAA  $01BD
C400 : CMPA  $861F
C403 : BCS   $C40D
C405 : BRA   $C434
C407 : BCLR  $0061,00000100B
C40A : CLR   $01BD
C40D : BRCLR $005C,00000110B,$C413
C411 : BRA   $C434
C413 : LDAA  $0164
C416 : CMPA  $8620
C419 : BHI   $C434
C41B : LDAA  $0158			|A = M[$0158]
C41E : LDAB  #$50			|B = 0x50
C420 : LDX   #$8652		 	|X = 0x8652
C423 : JSR   $FC10			|gosub FC10
C426 : LDX   #$01B8			|X = 0x01B8
C429 : JSR   $FB83			|gosub FB83 | Routine returns D = AIN (byte)  * M[$X] (word)
C42C : ASLD  				|D = D * 2
C42D : BCC   $C437			|if (D > 0) then goto C437
C42F : LDD   #$FFFF			|D = 0xFFFF
C432 : BRA   $C437			
C434 : LDD   #$0000
C437 : STD   $0092
C439 : STD   $009A
C43B : STD   $00A6
C43D : BEQ   $C441
C43F : ADDD  $00CD
C441 : STD   $00B2
C443 : STD   $009C			| M[$009C] = D   - Left injector pulsewidth
C445 : STD   $00A8			| M[$00A8] = D   - Right Injector pulsewidth
C447 : STD   $00A0
C449 : STD   $00AC
C44B : JMP   $CCE9
C44E : LDAA  $0164			| A = throttle load axis variable 
C451 : SUBA  $0166			| A = A - M[$0166]
C454 : BCS   $C470			| if (A < 0) then goto C470
C456 : BRCLR $0066,00000001B,$C470	| if TCC is not set then goto C470
C45A : LDAB  $8569			| B = M[$8569] (byte is 0x09)
C45D : BRSET $0066,10000000B,$C464	| if we are in 4th gear then goto C464
C461 : LDAB  $8568			| B = M[$8568] (byte is 0x06)
C464 : CBA   				| set flags based on A - B
C465 : BLS   $C470			| if ( A <= B ) then goto C470
C467 : BCLR  $0066,00000001B		| unlock torque convertor
C46A : LDAA  $856A			| A = M[$856A] (byte is 0x1D)
C46D : STAA  $0226			| M[$0226] = A
C470 : LDAA  $0164
C473 : STAA  $0166
C476 : LDAA  $00DA			| A = M[$00DA] (manifold pressure sensor input)
C478 : LDAB  $87B5			| B = M[$87B5] (0x04)
C47B : LDX   $019B			| X = M[$019B]
C47E : JSR   $FB63			| D = X + ( 256 * A - X ) * B
C481 : STD   $019B			| M[$019B] = D
C484 : LDAA  $0164			| A = M[$0164] (throttle load axis variable)
C487 : LDAB  $87B7			| B = M[$87B7] (0x08)
C48A : LDX   $0199			| X = M[$0199]
C48D : JSR   $FB63			| D = X + ( 256 * A - X ) * B
C490 : STD   $0199			| M[$0199] = D
C493 : BRSET $0060,00000010B,$C4EA
C497 : LDAA  $0199
C49A : SUBA  $0164
C49D : BCS   $C4EA
C49F : CMPA  $87B3
C4A2 : BLS   $C4EA
C4A4 : LDAA  $019B
C4A7 : SUBA  $00DA
C4A9 : BCS   $C4EA
C4AB : CMPA  $87B4
C4AE : BLS   $C4EA
C4B0 : STAA  $019F
C4B3 : LDX   #$87CA
C4B6 : JSR   $FC14
C4B9 : LDAB  $019D
C4BC : LDX   #$87B9
C4BF : ABX   
C4C0 : LDAB  $00,X
C4C2 : ABA   
C4C3 : BCC   $C4C7
C4C5 : LDAA  #$FF
C4C7 : TAB   
C4C8 : LDAA  $01A9			| A = M[$01A9]   - coolent temp lag filtered
C4CB : LDX   #$87DB			| X = 0x87DB
C4CE : JSR   $FC14			| gosub FC14
C4D1 : MUL   
C4D2 : ASLD  
C4D3 : BCS   $C4D8
C4D5 : ASLD  
C4D6 : BCC   $C4DA
C4D8 : LDAA  #$FF
C4DA : BRCLR $0066,00000001B,$C4E4
C4DE : LDAB  $87B6
C4E1 : MUL   
C4E2 : ADCA  #$00
C4E4 : COMA  
C4E5 : BSET  $0057,10000000B
C4E8 : BRA   $C4F2
C4EA : BCLR  $0057,10000000B
C4ED : CLR   $019F
C4F0 : LDAA  #$FF
C4F2 : STAA  $019E
C4F5 : LDAA  $0164				| A = M[$0164]
C4F8 : CMPA  #$80				| 
C4FA : BLS   $C4FE				| if (A > 0x80) then A = 0x80
C4FC : LDAA  #$80				|
C4FE : LDX   #$880C				| X = M[$880C]
C501 : JSR   $FC14				| gosub FC14
C504 : STAA  $0198				| M[$0198] = A
C507 : LDAA  $01A9			| A = M[$01A9]  - coolent temp lag filtered.
C50A : CMPA  $87F4			| compare A with M[$87F4]
C50D : BCS   $C552			| if ( A < M[$87F4] (0x0D) (-22 degrees F) ) then goto C552
C50F : BRSET $0070,10000000B,$C552	
C513 : BRCLR $005B,00000011B,$C526
C517 : BRCLR $0058,00100100B,$C51D
C51B : BRA   $C552
C51D : LDAA  $00CF			| A = M[$00CF]   - vehicle Speed
C51F : CMPA  $87F6			| compare vehicle speed with $87F6; value is 0x28 - 40 mph
C522 : BLS   $C552			| if vehicle speed is less or equal to then goto C552
C524 : BRA   $C531			| goto C531
C526 : BRSET $0069,00001000B,$C531
C52A : LDAA  $00CF			| load a with vehicle speed
C52C : CMPA  $87F5			| compare vehicle speed with $87F5; value is 0x1E - 30 mph
C52F : BLS   $C552			| if vehicle speed is less or equal to then goto C552
C531 : BRCLR $0058,00100100B,$C537
C535 : BRA   $C554
C537 : LDAA  $0123			| load A with engine rpm 
C53A : CMPA  #$90			| compare A with 0x90 - 3600 rpm
C53C : BLS   $C540			| if engine rpm is less than or equal to 3600 rpm then goto C540
C53E : LDAA  #$90			| A = 0x90 (3600 rpm)
C540 : LDX   #$8802			
C543 : JSR   $FC14
C546 : BRCLR $0060,00000010B,$C54D
C54A : ADDA  $8801
C54D : CMPA  $0164			| compare A with throttle load axis variable
C550 : BCC   $C554			
C552 : BRA   $C5CB
C554 : LDAA  $012C
C557 : SUBA  $0127
C55A : BCS   $C568
C55C : CMPA  $87F0
C55F : BCS   $C568
C561 : LDAA  #$FF
C563 : STAA  $0104
C566 : BRA   $C5CB
C568 : BRCLR $005B,00000011B,$C56E
C56C : BRA   $C57D
C56E : LDAB  $87EE
C571 : BRCLR $0060,00000010B,$C578
C575 : LDAB  $87EF
C578 : CMPB  $0154
C57B : BCS   $C5CB
C57D : LDAB  $87EC
C580 : BRCLR $0060,00000010B,$C587
C584 : LDAB  $87ED			| load B with 0x87ED (value is 0x20, 800 rpm)
C587 : CMPB  $0123			| compare B with engine rpm
C58A : BCC   $C5CB			
C58C : LDAB  $0197
C58F : BEQ   $C59A
C591 : LDAA  $0049			| A = M[$0049]
C593 : ANDA  #$0E			| A = A & 0x0E
C595 : BNE   $C5D5			| if ( A != 0x0E ) then goto C5D5
C597 : DECB  				| B = B - 1
C598 : BRA   $C5D5			| goto C5D5
C59A : BRSET $0060,00000010B,$C5C0
C59E : LDX   $0194
C5A1 : BNE   $C5CB
C5A3 : BRCLR $0060,00001000B,$C5EC
C5A7 : LDAA  $0104
C5AA : SUBA  $8800
C5AD : STAA  $0104
C5B0 : BCS   $C5B7
C5B2 : CMPA  $87FF
C5B5 : BCC   $C5EC
C5B7 : LDAA  $87FF
C5BA : STAA  $0104
C5BD : BSET  $0060,00000010B
C5C0 : BCLR  $0056,00010000B
C5C3 : LDX   $87FC
C5C6 : STX   $0194
C5C9 : BRA   $C61A
C5CB : LDAB  $87F2
C5CE : BRCLR $0061,01000000B,$C5D5	| if Catalytic convertor overtemp is disabled then goto C5D5
C5D2 : LDAB  $87F3
C5D5 : STAB  $0197
C5D8 : BRCLR $0060,00001000B,$C5E9
C5DC : LDAA  $0104
C5DF : ADDA  $0198
C5E2 : BCC   $C5E6
C5E4 : LDAA  #$FF
C5E6 : STAA  $0104
C5E9 : BCLR  $0060,00000010B
C5EC : LDX   $0194
C5EF : BNE   $C5F6
C5F1 : BCLR  $0056,00010000B
C5F4 : BRA   $C61A
C5F6 : DEX   
C5F7 : STX   $0194
C5FA : LDAB  $012C
C5FD : SUBB  $0127
C600 : BCS   $C61A
C602 : CMPB  $87F1
C605 : BCS   $C61A
C607 : BRSET $0056,00010000B,$C61A
C60B : BSET  $0056,00010000B
C60E : LDAA  $87F9
C611 : STAA  $0196
C614 : LDAA  $87F8
C617 : STAA  $011C
C61A : LDD   $012A			| D = M[$012A]
C61D : STD   $012B			| M[$012B] = D
C620 : LDAA  $0129			| A = M[$0129]
C623 : STAA  $012A			| M[$012A] = A
C626 : LDAA  $0127			| A = M[$0127]
C629 : STAA  $0129			| M[$0129] = A
C62C : BCLR  $0060,00001000B
C62F : LDX   $025B
C632 : LDAA  $0150
C635 : LDAB  $8851
C638 : JSR   $FB63			| D = X + ( 256 * A - X ) * B
C63B : STD   $025B
C63E : BCLR  $0056,00100000B
C641 : LDAA  $0150
C644 : SUBA  $025B
C647 : BCC   $C64F
C649 : CLR   $025E
C64C : CLRA  
C64D : BRA   $C6A5
C64F : STAA  $025E
C652 : LDAA  $0164
C655 : CMPA  #$80
C657 : BCS   $C65B
C659 : LDAA  #$80
C65B : LSRA  
C65C : LDX   #$886F
C65F : JSR   $FC14
C662 : BRCLR $0056,00000100B,$C67D
C666 : LDAB  $0124
C669 : SUBB  $012D
C66C : BCC   $C67D
C66E : NEGB  
C66F : CMPB  $8853
C672 : BCS   $C67D
C674 : BSET  $0056,00100000B
C677 : LDAB  $8854
C67A : MUL   
C67B : ADCA  #$00
C67D : TAB   
C67E : LDAA  $025E
C681 : SBA   
C682 : BCC   $C687
C684 : CLRA  
C685 : BRA   $C69E
C687 : BSET  $005F,00001001B
C68A : CMPA  #$A0
C68C : BLS   $C690
C68E : LDAA  #$A0
C690 : LSRA  
C691 : LDX   #$8855
C694 : JSR   $FC14
C697 : LDAB  $025F
C69A : MUL   
C69B : ASLD  
C69C : BCS   $C6A3
C69E : ADDA  $025A
C6A1 : BCC   $C6A5
C6A3 : LDAA  #$FF
C6A5 : STAA  $025A
C6A8 : BNE   $C6AD
C6AA : BCLR  $005F,00001111B
*
* Loads table for coolent temp < 240 degrees F, this is wot to open loop table.
*
C6AD : LDX   #$8879			| X = 0x8879
C6B0 : LDAB  $01A9			| B = M[$01A9]   - coolent temp lag filtered
C6B3 : CMPB  $8878			| compare B with M[$8878] (0xD1) (240 degrees F)
C6B6 : BCS   $C6BB			| if ( B < M[$8878] (0xD1) ) then goto C6BB
C6B8 : LDX   #$888A			| X = 0x888A
*
* Loads table for coolent temp > 240 degrees F, this is wot to open loop table.
*
C6BB : LDAA  $0123			| A = M[$0123]
C6BE : JSR   $FC14			| gosub FC14 - table indexing into wot tps percentage to open loop
C6C1 : BRCLR $0060,00100000B,$C6CA	| if ( bit 0x20 of M[$0060] is clear ) then goto C6CA
C6C5 : SUBA  $8877			| A = A - M[$8877] (0x10)
* subtracts wot 0x10 from percentage from table.
C6C8 : BCS   $C6D3			| if ( A < 0 ) then goto C6D3
C6CA : BRCLR $0061,01000000B,$C6D4	| if ( bit 0x40 of M[$0061] is clear ) then goto C6D4 (if catalytic convertor overtemp disabled then goto C6D4)
C6CE : SUBA  $8876			| A = A - M[$8876] (0x0D)
C6D1 : BCC   $C6D4			| if ( A >= 0 ) then goto C4D4
C6D3 : CLRA  				| A = 0
C6D4 : CMPA  $0164			| compare A with M[$0164]
C6D7 : BHI   $C6ED			| if ( A > M[$0164] ) then goto C6ED if WOT open loop table value is less than tps.
*
* Used if throttle percentage is greater than tabled value
*
C6D9 : LDAA  $8874			| A = M[$8874] (0x0F)
C6DC : BRCLR $0060,00100000B,$C6E3	| if bit 0x20 of M[$0060] is clear then goto C6E3 if we were not open loop last pass then goto C6E3 (A will be 0x0F)
* We were open loop last pass.
C6E0 : SUBA  $8875			| A -= M[$8875] (0x06)  ( A will be 0x10)
C6E3 : CMPA  $0154			| compare A with M[$0154] 
C6E6 : BHI   $C6ED			| if ( A > M[$0154] ) then goto C6ED
C6E8 : BSET  $0060,00100000B		| set bit 0x20 of M[$0060] - set open loop last pass bit.
C6EB : BRA   $C6F0			| goto C6F0
*
* Used if throttle percentage is lower than tabled value
*
C6ED : BCLR  $0060,00100000B 		| bit 0x20 of M[$0060] is cleared if tps is less than tabled value
*  

C6F0 : CLR   $01B6
C6F3 : BRCLR $006A,00001000B,$C70B
C6F7 : LDAA  $02B3
C6FA : BITA  #$04
C6FC : BEQ   $C70B
C6FE : LDAA  $02B5
C701 : CLRB  
C702 : STD   $01AE			| M[$01AE] = D
C705 : BCLR  $0060,00100000B		| clear bit 0x20 of M[$0060]
C708 : JMP   $C78F			| goto C78F
C70B : LDX   #$0000			| X = 0x0000
C70E : LDAB  $871C			| B = M[$871C] (0xDD)
C711 : ABX   				| X = X + B
C712 : LDAB  $01B4			| B = M[$01B4]
C715 : ABX   				| X = X + B
C716 : BRCLR $0061,10000000B,$C71D	| if (bit 0x80 of M[$0061] is clear (engine is not closed loop)) then goto C71D
C71A : LDX   #$0100			| X = 0x0100
C71D : LDAB  $0008			| B = M[$0008]
C71F : ABX   				| X = X + B
C720 : PSHX  				| push X
C721 : BRSET $0061,10000000B,$C731	| if (bit 0x80 of M[$0061] is set (engine is closed loop)) then goto C731
C725 : LDAA  $0150			| A = M[$0150]
C728 : LDX   #$86D3			| X = 0x86D3
C72B : JSR   $FC14			| gosub FC14
C72E : STAA  $01B6			| M[$01B6] = A
C731 : PULA  				| Pull A
C732 : PULB  				| pull B
C733 : ADDB  $01B6			| B = B + M[$01B6]
C736 : ADCA  #$00			| A = A + 0 (Add with carry from last operation)
C738 : XGDX  				| Exchange X and D
C739 : CLRA  				| A = 0
C73A : LDAB  $867B			| B = M[$867B] (0x93)
C73D : FDIV  				| D / X ( X is quot, D is remainder, value will be X/65536)
C73E : STX   $01B0			| M[$01B0] = X
C741 : BRCLR $0060,00100000B,$C778	| If ( bit 0x20 of M[$0060] is clear) then goto C778 (clear means computer is not in open loop)
*
* Open Loop Fuel Code
*
C745 : LDX   #$88A1			| X = 0x88A1  - WOT tables.
C748 : LDAA  $0123			| A = M[$0123] (engine rpm 1 count / 25 rpm )
C74B : CMPA  #$A0			| Compare A with 0xA0
C74D : BHI   $C756			| if ( A > 0xA0 ) then goto C756 (rpm is greater than 4000)
C74F : SUBA  #$10			| A = A - 0x10
C751 : BCC   $C75F			| if ( A >= 0 ) then goto C75F
C753 : CLRA  				| A = 0
C754 : BRA   $C75F			| goto C75F
*
* RPM is greater than 4000
*
C756 : LDAA  $0125			| A = M[$0125] ( engine rpm 1 count / 31.5 rpm )
C759 : ADDA  #$10			| A = A + 0x10
C75B : BCC   $C75F			| if ( A <= 0xFF ) then goto C75F
C75D : LDAA  #$FF			| A = 0xFF
*
C75F : JSR   $FC14			| gosub FC14
C762 : TAB   				| B = A
C763 : LDX   #$0080			| X = 0x0080
C766 : ABX   				| X = X + B
C767 : LDAB  $01B5			| B = M[$01B5]
C76A : ABX   				| X = X + B
C76B : LDAB  $867B			| B = M[$867B] (0x93)
C76E : CLRA  				| A = 0
C76F : FDIV  				| D / X (X is quot, D is remainder, value will be X/65536)
C770 : CPX   $01B0			| compare X with M[$01B0]
C773 : BCS   $C778			| if ( X < M[$01B0] ) then goto C778
C775 : LDX   $01B0			| X = M[$01B0]
*
*
C778 : STX   $01B2			| M[$01B2] = X
C77B : BRCLR $0061,01000000B,$C789	| if (bit 0x40 of M[$0061] is clear) then goto C789 (catalytic convertor overtemp disabled)
*
* Catalytic convertor is overtemp?
*
C77F : LDAA  $867E			| A = M[$867E] (0x7A)
C782 : CLRB  				| B = 0
C783 : CPD   $01B2			| compare D to M[$01B2]
C787 : BLS   $C78C			| if ( D <= M[$01B2] ) then goto C78C
*
* Back to normal code
*
C789 : LDD   $01B2			| D = M[$01B2]
C78C : STD   $01AE			| M[$01AE] = D
C78F : BRCLR $004F,10000000B,$C798	| if ( bit 0x80 of M[$004F] is clear) then goto C798
C793 : JSR   $5100			| gosub $5100 ??????
C796 : BRA   $C79F			| goto C79F
*
*
C798 : BRCLR $004F,01000000B,$C79F	| if ( bit 0x40 of M[$004F] is clear) then goto C79F
C79C : JSR   $5800			| gosub $5800 ??????
*
*
C79F : BCLR  $0060,00000100B		| clear bit 0x04 of M[$0060]
C7A2 : LDAA  $8496			| A = M[$8496] ( 0x0C)
C7A5 : CMPA  $01FB			| compare A with M[$01FB]
C7A8 : BLS   $C7E2			| if ( A <= M[$01FB] ) then goto C7E2 (purge duty cycle)
C7AA : CMPA  $01FC			| compare A with M[$01FC]
C7AD : BLS   $C7E2			| if < A <= M[$01FC] ) then goto C7E2 
C7AF : LDAB  #$10			| B = 0x10
C7B1 : LDAA  $00CF			| A = M[$00CF]  - load A with vehicle speed
C7B3 : BNE   $C7B9			| if ( A != 0) then goto C7B9  - if vehicle speed is not equal to zero then goto C7B9
C7B5 : BRSET $0053,00001000B,$C7DF	| if ( bit 0x08 of M[$0053] is set) then goto C7DF
C7B9 : LDAA  $87A0			| A = M[$87A0] (0x20)
C7BC : LDAB  $0149			| B = M[$0149]   - load B with block learn multipler cell number
C7BF : CMPB  #$10			| compare b with 0x10 (16)
C7C1 : BLS   $C7D6			| if ( B <= 0x10 (16)) then goto C7D6
C7C3 : CMPB  #$11			| compare B with 0x11 (17)
C7C5 : BEQ   $C7CF			| if ( B == 0x11 (17)) then goto C7CF
					| must be cell 18.
C7C7 : SUBA  $87A4			| A = A - M[$87A4] (0x02) 
C7CA : BCC   $C7D6			| if ( A >= 0 ) then goto C7D6
C7CC : CLRA  				| A = 0
C7CD : BRA   $C7D6			| goto C7D6
*
*
C7CF : ADDA  $87A4			| A = A + M[$87A4] (0x02)
C7D2 : BCC   $C7D6			| if ( A >= 0 ) then goto C7D6
C7D4 : LDAA  #$FF			| A = 0xFF
*
C7D6 : LDAB  #$11			| B = 0x11
C7D8 : CMPA  $0154			| Compare A with M[$0154]
C7DB : BCC   $C7DF			| if ( A >= M[$0154] ) then goto C7DF
C7DD : LDAB  #$12			| B = 0x12
C7DF : JMP   $C86E			| goto C86E
*
*
C7E2 : LDAA  $0149			| A = M[$0149]  - Load A with block learn multipler cell number
C7E5 : CMPA  #$0F			| compare A with 0x0F 
C7E7 : BHI   $C840			| if ( A > 0x0F ) then goto C840 
C7E9 : LDAB  $0149			| B = M[$0149] - load B with block learn multipler cell number
C7EC : ANDB  #$03			| B = B & 0x03
C7EE : LDX   #$879C			| X = 0x879C
C7F1 : ABX   				| X = X + B
C7F2 : TSTB  				| test B
C7F3 : BEQ   $C805			| if ( B == 0 ) then goto C805
C7F5 : LDAA  $00,X			| A = M[$X]
C7F7 : SUBA  $87A3			| A = A - M[$87A3] (0x04)
C7FA : BCS   $C801			| if ( A < 0 ) then goto C801
C7FC : CMPA  $0123			| compare A with engine rpm
C7FF : BHI   $C840			| if ( A > M[$0123] (engine rpm)) then goto C840
C801 : CMPB  #$03			| Compare B with 0x03
C803 : BEQ   $C811			| if ( B == 0x03) then goto C811
C805 : LDAA  $01,X			| A = M[$(X+0x01)]
C807 : ADDA  $87A3			| A = A + M[$87A3] (0x04)
C80A : BCS   $C811			| if ( A > 255 ) then goto C811
C80C : CMPA  $0123			| compare A with M[$0123] (engine rpm)
C80F : BCS   $C840			| if ( A < M[$0123] (engine rpm) ) then goto C840
C811 : LDAB  $0149			| B = M[$0149] (block learn cell multiplier)
C814 : ANDB  #$0C			| B = B & 0x0C
C816 : LSRB  				| B = B / 2
C817 : LSRB  				| B = B / 2
C818 : LDX   #$879F			| X = 0x879F
C81B : ABX   				| X = X + B
C81C : TSTB  				| Test B
C81D : BEQ   $C82F			| if ( B == 0) then goto C82F
C81F : LDAA  $00,X			| A = M[$X]
C821 : SUBA  $87A4			| A = A - M[$87A4] (0x02)
C824 : BCS   $C82B			| if (A < 0) then goto C82B
C826 : CMPA  $0154			| compare A with M[$0154]
C829 : BHI   $C840			| if ( A > M[$0154]) then goto C840
C82B : CMPB  #$03			| Compare B with 0x03
C82D : BEQ   $C83B			| if ( B == 0x03) then goto C83B
C82F : LDAA  $01,X			| A = M[$(X+0x01)]
C831 : ADDA  $87A4			| A = A + M[$87A4] (0x02)
C834 : BCS   $C83B			| if ( A > 255 ) then goto C83B
C836 : CMPA  $0154			| compare A with M[$0154]
C839 : BCS   $C840			| if ( A < M[$0154] ) then goto C840
C83B : LDAB  $0149			| B = M[$0149] (Block learn cell multipler)
C83E : BRA   $C86E			| goto C86E
*
*
C840 : CLRB  				| B = 0
C841 : LDAA  $0123			| A = M[$0123] (engine speed - rpm)
C844 : CMPA  $879D			| Compare A with M[$879D] (0x1C)
C847 : BCS   $C856			| if ( A < M[$879D] (0x1C)(700rpm)) then goto C856
C849 : INCB  				| B = B + 1
C84A : CMPA  $879E			| Compare A with M[$879E] (0x30) (1200 rpm)
C84D : BCS   $C856			| if ( A < M[$879E] (0x30) (1200 rpm)) then goto C856
C84F : INCB  				| B = B + 1
C850 : CMPA  $879F			| Compare A with M[$879F] (0x50) (2000 rpm)
C853 : BCS   $C856			| if ( A < M[$879F] (0x50) (2000 rpm) ) then goto C856
C855 : INCB  				| B = B + 1
*
*
C856 : LDAA  $0154			| A = M[$0154]
C859 : CMPA  $87A0			| Compare A with M[$87A0] (0x20)
C85C : BCS   $C86E			| if (A < M[$87A0] (0x20)) then goto C86E
C85E : ADDB  #$04			| B = B + 0x04
C860 : CMPA  $87A1			| Compare A with M[$87A1] (0x32)
C863 : BCS   $C86E			| if (A < M[$87A1] (0x32)) then goto C86E
C865 : ADDB  #$04			| B = B + 0x04
C867 : CMPA  $87A2			| Compare A with M[$87A2] (0x50)
C86A : BCS   $C86E			| if (A < M[$8742] (0x00)) then goto C86E
C86C : ADDB  #$04			| B = B + 0x04
*
*
C86E : CMPB  $0149			| compare B with BLM cell number
C871 : BEQ   $C879			| if ( B = M[$0149] (BLM Cell Number) then goto C879
* BLM cell has changed.
C873 : STAB  $0149			| Store B to M[$0149] - Block Learn Cell Number
C876 : BSET  $0060,00000100B		| Set bit 0x04 of M[$0060]
*
C879 : LDX   #$0015			| X = 0x0015
C87C : ABX   				| X = X + B
C87D : LDAA  $00,X			| A = M[X]
C87F : CMPA  $87AB			| Compare A with M[$87AB] (0xA0)
C882 : BHI   $C889			| if ( A > M[$87AB] (0xA0)) then goto C889
C884 : CMPA  $87AC			| Compare A with M[$87AC] (0x6C)
C887 : BCC   $C88C			| if ( A >= M[$87AC] (0x6C)) then goto C88C
C889 : JMP   $C935			| goto C935
*
*
C88C : CMPA  $0147			| Compare A with M[$0147] - Left bank block learn multipler
C88F : BNE   $C896			| if (A != M[$0147] (left bank block learn multipler)) then goto C896
C891 : CLR   $014C			| M[$014C] = 0x00
C894 : BRA   $C8C8			| goto C8C8
*
*
C896 : BHI   $C8BB			| if (A > M[$0147] (left bank block learn multipler)) then goto C8BB
C898 : LDAB  $801B			| B = M[$801B] (0x5A)
C89B : BITB  #$08			| compare bit 0x08 of B
C89D : BEQ   $C8BB			| if ( bit 0x08 of B is clear) then goto C8BB
C89F : LDAB  $014C			| B = M[$014C]
C8A2 : BEQ   $C8A9			| if ( B == 0) then goto C8A9
C8A4 : DEC   $014C			| M[$014C] --
C8A7 : BRA   $C8C8			| goto C8C8
*
*
C8A9 : LDAB  $87B1			| B = M[$87B1] (0x01)
C8AC : STAB  $014C			| M[$014C] = B
C8AF : LDAB  $0147			| B = M[$0147] (load from left bank block learn multiplier)
C8B2 : SUBB  $87B2			| B = B - M[$87B2] (0x01)
C8B5 : BCS   $C8BB			| if ( B < 0 ) then goto C8BB
C8B7 : CBA   				| Compare A to B (A - B)
C8B8 : BCC   $C8BB			| if ( A >= B) then goto C8BB
C8BA : TBA   				| A = B
C8BB : STAA  $0147			| M[$0147] = A (store to left bank block learn multiplier)
C8BE : BRCLR $0060,00000100B,$C8C8	| if ( bit 0x04 if M[$0060] is clear) then goto C8C8
C8C2 : BSET  $0061,00001000B		| set bit 0x08 of M[$0061] - set Left bank blm integrator reset flag.
C8C5 : CLR   $014A			| M[$014A] = 0
*
*
C8C8 : LDAA  $0147			| A = M[$0147]   - Left Block Learn Multiplier
C8CB : BMI   $C8CF			| if ( Left BLM > 128 ) then goto C8CF (changed to BEQ to cause WOT to always be 128)
C8CD : LDAA  #$80			| A = 0x80
C8CF : BRCLR $0060,00100000B,$C8D6	| if ( bit 0x20 of M[$0060] is clear) then goto C8D6 (this is set if open loop mode is being used)
C8D3 : STAA  $0147			| M[$0147] = A  - Left Block Learn Multiplier
*
C8D6 : LDX   #$0028			| X = 0x0028
C8D9 : LDAB  $0149			| B = M[$0149]   - Block Learn Multiplier Cell
C8DC : ABX   				| X = X + B
C8DD : LDAA  $00,X			| A = M[$X]
C8DF : CMPA  $87AB			| compare A with M[$87AB] (0xA0)
C8E2 : BHI   $C935			| if ( A > M[$87AB] (0xA0) ) then goto C935
C8E4 : CMPA  $87AC			| compare A with M[$87AC] (0x6C)
C8E7 : BCS   $C935			| if ( A < M[$87AC] (0x6C) ) then goto C935
C8E9 : CMPA  $0148			| Compare A with M[$0148] - Right Block Learn Multiplier
C8EC : BNE   $C8F3			| if ( A != M[$0148] (Right BLM)) then goto C8F3
C8EE : CLR   $014D
C8F1 : BRA   $C925
*
*
C8F3 : BHI   $C918
C8F5 : LDAB  $801B
C8F8 : BITB  #$08
C8FA : BEQ   $C918
C8FC : LDAB  $014D
C8FF : BEQ   $C906
C901 : DEC   $014D
C904 : BRA   $C925
*
*
C906 : LDAB  $87B1
C909 : STAB  $014D
C90C : LDAB  $0148			| B = M[$0148]   - Right Block Learn Multiplier
C90F : SUBB  $87B2
C912 : BCS   $C918
C914 : CBA   
C915 : BCC   $C918
C917 : TBA   
C918 : STAA  $0148			| M[$0148] = A   - Right Block Learn Multiplier
C91B : BRCLR $0060,00000100B,$C925
C91F : BSET  $0061,00010000B
C922 : CLR   $014B
*
*
C925 : LDAA  $0148			| A = M[$0148]   - Right Block Learn Multiplier
C928 : BMI   $C92C			| jump to $C92C if Right BLM > 128  (Change to BEQ to make 128 always be used WOT)
C92A : LDAA  #$80			| A = 128
C92C : BRCLR $0060,00100000B,$C948
C930 : STAA  $0148			| M[$0148] = A   - Right Block Learn Multiplier
C933 : BRA   $C948			| goto $C948
*
*
C935 : BSET  $0056,01000000B
C938 : LDAA  #$80
C93A : LDX   #$0026			| X = 0x0026
C93D : STAA  $14,X			| M[$(X+0x14)] = A
C93F : DEX   				| X = X - 1
C940 : BNE   $C93D			| if ( X != 0 ) then goto C93D
C942 : STAA  $0147			| M[$0147] = A   - Left Block Learn Multiplier
C945 : STAA  $0148			| M[$0148] = A	 - Right Block Learn Multiplier
*
*
C948 : CLRA  				| A = 0
C949 : BRSET $0056,00000100B,$C969
C94D : LDD   $00C4
C94F : ASLD  
C950 : BCS   $C955
C952 : ASLD  
C953 : BCC   $C957
C955 : LDAA  #$FF
C957 : LDAB  $8741
C95A : MUL   
C95B : ADCA  #$00
C95D : CMPA  #$10
C95F : BCC   $C963
C961 : LDAA  #$10
C963 : CMPA  #$40
C965 : BLS   $C969
C967 : LDAA  #$40
C969 : STAA  $0193
C96C : LDAA  $0193
C96F : LDX   #$874E
C972 : JSR   $FC14
C975 : STAA  $0182
C978 : LDAA  $0193
C97B : LDX   #$8753
C97E : JSR   $FC14
C981 : STAA  $0183
C984 : LDAA  $0193
C987 : LDX   #$8758
C98A : JSR   $FC14
C98D : STAA  $0181
C990 : LDAA  $0193
C993 : LDX   #$875D
C996 : JSR   $FC14
C999 : STAA  $0185
C99C : LDAA  $0193
C99F : LDX   #$8762
C9A2 : JSR   $FC14
C9A5 : STAA  $0186
C9A8 : LDAA  $0193
C9AB : LDX   #$8767
C9AE : JSR   $FC14
C9B1 : STAA  $0184
C9B4 : LDAA  $0193
C9B7 : LDX   #$876C
C9BA : JSR   $FC14
C9BD : STAA  $018C
C9C0 : LDAA  $0193			| A = M[$0193]
C9C3 : LDX   #$8771			| X = 0x8771
C9C6 : JSR   $FC14			| gosub FC14
C9C9 : STAA  $0187			| M[$0187] = A
C9CC : LDAA  $0193			| A = M[$0193]
C9CF : LDX   #$8776			| X = 0x8776
C9D2 : JSR   $FC14			| gosub FC14
C9D5 : STAA  $0188			| M[$0188] = A
C9D8 : LDAA  $0193
C9DB : LDAB  $01A0
C9DE : CMPB  $874C
C9E1 : BCC   $C9EC
C9E3 : LDAB  $0150
C9E6 : CMPB  $874D
C9E9 : BCC   $C9EC
C9EB : CLRA  
C9EC : LDX   #$877B
C9EF : JSR   $FC14
C9F2 : STAA  $0189
C9F5 : LDAA  $00D9			| A = M[$00D9] - Left O2 sensor voltage
C9F7 : LDX   $0175			| X = M[$0175]
C9FA : LDAB  $0187			| B = M[$0187]
C9FD : JSR   $FB63			| D = X + ( 256 * A - X ) * B
CA00 : STD   $0175			| M[$0175] = D
CA03 : LDAA  $00D8			| A = M[$00D8] - Right O2 sensor voltage
CA05 : LDX   $0173			| X = M[$0173] 
CA08 : LDAB  $0188			| B = M[$0188]
CA0B : JSR   $FB63			| D = X + ( 256 * A - X ) * B
CA0E : STD   $0173			| M[$0173] = D
CA11 : LDD   $8745
CA14 : CMPA  $00D9
CA16 : BCS   $CA1C
CA18 : CMPB  $00D9
CA1A : BLS   $CA22
CA1C : CLR   $017E
CA1F : BSET  $0063,00000001B
CA22 : LDAA  $0181
CA25 : LDAB  $8742
CA28 : ABA   
CA29 : CMPA  $00D9
CA2B : BCS   $CA3A
CA2D : SBA   
CA2E : SBA   
CA2F : CMPA  $00D9
CA31 : BHI   $CA3F
CA33 : LDAA  $016E
CA36 : CMPA  $00D9
CA38 : BCC   $CA3F
CA3A : BSET  $0063,00000010B
CA3D : BRA   $CA42
*
*
CA3F : BCLR  $0063,00000010B
CA42 : BRSET $0063,00000110B,$CA50
CA46 : BRCLR $0063,00000110B,$CA50
CA4A : BSET  $0063,00100000B
CA4D : INC   $0272
CA50 : LDD   $8745
CA53 : CMPA  $00D8
CA55 : BCS   $CA5B
CA57 : CMPB  $00D8
CA59 : BLS   $CA61
CA5B : CLR   $017D
CA5E : BSET  $0064,00000001B
CA61 : LDAA  $0184
CA64 : LDAB  $8742
CA67 : ABA   
CA68 : CMPA  $00D8
CA6A : BCS   $CA79
CA6C : SBA   
CA6D : SBA   
CA6E : CMPA  $00D8
CA70 : BHI   $CA7E
CA72 : LDAA  $016D
CA75 : CMPA  $00D8
CA77 : BCC   $CA7E
CA79 : BSET  $0064,00000010B
CA7C : BRA   $CA81
*
*
CA7E : BCLR  $0064,00000010B
*
*
CA81 : BRSET $0064,00000110B,$CA8F
CA85 : BRCLR $0064,00000110B,$CA8F
CA89 : BSET  $0064,00100000B
CA8C : INC   $026D
*
CA8F : BRSET $0063,00000010B,$CA98
CA93 : BCLR  $0063,00000100B
CA96 : BRA   $CA9B
*
*
CA98 : BSET  $0063,00000100B
*
*
CA9B : BRSET $0064,00000010B,$CAA4
CA9F : BCLR  $0064,00000100B
CAA2 : BRA   $CAA7
*
*
CAA4 : BSET  $0064,00000100B
CAA7 : BRCLR $006A,00001000B,$CAB9
CAAB : LDX   #$02AF
CAAE : BRCLR $00,X,00000001B,$CAB9
CAB2 : BRCLR $01,X,00000001B,$CAF3
CAB6 : JMP   $CB0D
*
*
CAB9 : BRCLR $0061,10000000B,$CAF3
CABD : BRSET $0060,00000010B,$CAF3
CAC1 : LDAA  $0144			| A = M[$0144]   - Left Integrator
CAC4 : BPL   $CAD9
CAC6 : BRCLR $0063,00000010B,$CAD0
CACA : CMPA  #$80
CACC : BEQ   $CAD9
CACE : BRA   $CAD4
*
*
CAD0 : BRSET $0057,10000000B,$CAF3
CAD4 : BCLR  $0061,00001000B
CAD7 : BRA   $CB0D
*
*
CAD9 : BRSET $0061,00001000B,$CAF3
CADD : BRSET $0060,00100000B,$CAF3
CAE1 : BRSET $0061,01000000B,$CAF3
CAE5 : BRCLR $005F,10000000B,$CB0D
CAE9 : BSET  $005A,00000101B
CAEC : LDAA  $801A
CAEF : BITA  #$02
CAF1 : BEQ   $CB0D
*
*
CAF3 : LDAA  $0181
CAF6 : STAA  $0175
CAF9 : LDAA  #$80
CAFB : STAA  $0144			| M[$0144] = A   - Left Integrator
CAFE : STAA  $0146
CB01 : CLR   $0180
CB04 : BCLR  $0061,00001000B
CB07 : BSET  $005A,00000101B
CB0A : JMP   $CBC3
*
*
CB0D : LDAA  $0175
CB10 : SUBA  $0183
CB13 : BHI   $CB22
*
*
CB15 : LDAA  $0182
CB18 : SUBA  $0175
CB1B : BHI   $CB2D
*
*
CB1D : CLR   $0191
CB20 : BRA   $CB39
*
*
CB22 : BSET  $0063,01000000B
CB25 : LDAB  $8744
CB28 : MUL   
CB29 : ADCA  #$00
CB2B : BRA   $CB30
*
*
CB2D : BCLR  $0063,01000000B
*
*
CB30 : CMPA  #$58
CB32 : BLS   $CB36
*
*
CB34 : LDAA  #$58
*
*
CB36 : STAA  $0191
CB39 : LDAA  $0191
CB3C : CMPA  $8743
CB3F : BCS   $CB49
*
*
CB41 : BRSET $0063,01000010B,$CB4E
CB45 : BRCLR $0063,01000010B,$CB4E
*
*
CB49 : CLR   $0180
CB4C : BRA   $CB97
*
*
CB4E : ASLA  
CB4F : LDX   #$878C
CB52 : JSR   $FC14
CB55 : STAA  $018D
CB58 : LDAB  $018C
CB5B : MUL   
CB5C : ADCA  #$00
CB5E : STAA  $0190
CB61 : CMPA  $0180
CB64 : BLS   $CB6B
*
*
CB66 : INC   $0180
CB69 : BRA   $CB97
*
*
CB6B : CLR   $0180
CB6E : LDAA  $0144			| M[$0144] = A   - Left Integrator
CB71 : BRCLR $0063,01000000B,$CB85
*
*
CB75 : SUBA  $8747
CB78 : BCC   $CB7B
CB7A : CLRA  
CB7B : CMPA  $874A
CB7E : BCC   $CB94
*
*
CB80 : LDAA  $874A
CB83 : BRA   $CB94
*
*
CB85 : ADDA  $8748
CB88 : BCC   $CB8C
CB8A : LDAA  #$FF
*
*
CB8C : CMPA  $8749
CB8F : BLS   $CB94
CB91 : LDAA  $8749
*
*
CB94 : STAA  $0144			| M[$0144] = A   - Left Integrator
CB97 : LDAA  $0191
CB9A : ASLA  
CB9B : LDX   #$8780
CB9E : JSR   $FC14
CBA1 : STAA  $018A
CBA4 : LDAB  $0189
CBA7 : MUL   
CBA8 : ADCA  #$00
CBAA : TAB   
CBAB : STAB  $017C
CBAE : LDAA  $0144			| A = M[$0144]   - Left Integrator
CBB1 : BRCLR $0063,00000010B,$CBBB
*
*
CBB5 : SBA   
CBB6 : BCC   $CBC0
CBB8 : CLRA  
CBB9 : BRA   $CBC0
*
*
CBBB : ABA   
CBBC : BCC   $CBC0
CBBE : LDAA  #$FF
*
*
CBC0 : STAA  $0146
CBC3 : BRCLR $006A,00001000B,$CBD5
CBC7 : LDX   #$02AF
CBCA : BRCLR $00,X,00000001B,$CBD5
CBCE : BRCLR $01,X,00000001B,$CC0F
CBD2 : JMP   $CC29
*
*
CBD5 : BRCLR $0061,10000000B,$CC0F
CBD9 : BRSET $0060,00000010B,$CC0F
CBDD : LDAA  $0143			| A = M[$0143]   - Right Integrator
CBE0 : BPL   $CBF5
*
*
CBE2 : BRCLR $0064,00000010B,$CBEC
CBE6 : CMPA  #$80
CBE8 : BEQ   $CBF5
*
*
CBEA : BRA   $CBF0
*
*
CBEC : BRSET $0057,10000000B,$CC0F
CBF0 : BCLR  $0061,00010000B
CBF3 : BRA   $CC29
*
*
CBF5 : BRSET $0061,00010000B,$CC0F
CBF9 : BRSET $0060,00100000B,$CC0F
CBFD : BRSET $0061,01000000B,$CC0F
CC01 : BRCLR $005F,10000000B,$CC29
*
*
CC05 : BSET  $005A,00000101B
CC08 : LDAA  $801A
CC0B : BITA  #$02
CC0D : BEQ   $CC29
*
*
CC0F : LDAA  $0184
CC12 : STAA  $0173
CC15 : LDAA  #$80
CC17 : STAA  $0143			| M[$0143] = A   - Right Integrator
CC1A : STAA  $0145			| M[$0145] = A   
CC1D : CLR   $017F			| M[$017F] = 0
CC20 : BCLR  $0061,00010000B		| clear bit 0x10 of M[$0061] - Clear right bank blm change integrator reset flag.
CC23 : BSET  $005A,00000101B		| set bits 0x05 of M[$005A] - set more than 100 ms for SPI, reference pulse occured.
CC26 : JMP   $CCDF			| goto CCDF
*
*
CC29 : LDAA  $0173			| A = M[$0173]
CC2C : SUBA  $0186			| A = A - M[$0186]
CC2F : BHI   $CC3E			| if ( A > 0 ) then goto CC3E
*
*
CC31 : LDAA  $0185
CC34 : SUBA  $0173
CC37 : BHI   $CC49
*
*
CC39 : CLR   $0192
CC3C : BRA   $CC55
*
*
CC3E : BSET  $0064,01000000B		| set bit 0x40 of M[$0064] - Right integrator needs to go down
CC41 : LDAB  $8744			| B = M[$8744] (0xFF)
CC44 : MUL   				| D = A * B
CC45 : ADCA  #$00			| A = A + 0 (add carry)
CC47 : BRA   $CC4C			| goto CC4C
*
*
CC49 : BCLR  $0064,01000000B		| Clear bit 0x40 of M[$0064] - Right integrator needs to go up
*
*
CC4C : CMPA  #$58
CC4E : BLS   $CC52
*
*
CC50 : LDAA  #$58
*
*
CC52 : STAA  $0192
CC55 : LDAA  $0192
CC58 : CMPA  $8743
CC5B : BCS   $CC65
*
*
CC5D : BRSET $0064,01000010B,$CC6A
CC61 : BRCLR $0064,01000010B,$CC6A
*
*
CC65 : CLR   $017F
CC68 : BRA   $CCB3
*
*
CC6A : ASLA  
CC6B : LDX   #$878C
CC6E : JSR   $FC14
CC71 : STAA  $018E
CC74 : LDAB  $018C
CC77 : MUL   
CC78 : ADCA  #$00
CC7A : STAA  $018F
CC7D : CMPA  $017F
CC80 : BLS   $CC87
*
*
CC82 : INC   $017F
CC85 : BRA   $CCB3
*
*
CC87 : CLR   $017F
CC8A : LDAA  $0143			| A = M[$0143]   - Right Integrator
CC8D : BRCLR $0064,01000000B,$CCA1	| if ( bit 0x40 of M[$0064] is clear) then goto CCA1
CC91 : SUBA  $8747			| A = A - M[$8747] (0x02)
CC94 : BCC   $CC97			| if ( A > 0 ) then goto CC97
*
*
CC96 : CLRA  				| A = 0
*
*
CC97 : CMPA  $874A			| compare A with M[$874A] (0x01)
CC9A : BCC   $CCB0			| if ( A > M[$874A] (0x01) ) then goto CCB0
*
*
CC9C : LDAA  $874A			| A = M[$874A] (0x01)
CC9F : BRA   $CCB0			| goto CCB0
*
*
CCA1 : ADDA  $8748			| A = A + M[$8748] (0x02)
CCA4 : BCC   $CCA8			| if ( A < 256 ) then goto CCA8
*
*
CCA6 : LDAA  #$FF			| A = 0xFF
CCA8 : CMPA  $8749			| compare A with M[$8749] (0xFE)
CCAB : BLS   $CCB0			| if ( A <= M[$8749] (0xFE) ) then goto CCB0
*
*
CCAD : LDAA  $8749			| A = M[$8749] (0xFE)
*
*
CCB0 : STAA  $0143			| M[$0143] = A   - Right Integrator
*
*
CCB3 : LDAA  $0192
CCB6 : ASLA  
CCB7 : LDX   #$8780
CCBA : JSR   $FC14
CCBD : STAA  $018B
CCC0 : LDAB  $0189
CCC3 : MUL   
CCC4 : ADCA  #$00
CCC6 : TAB   
CCC7 : STAB  $017B
CCCA : LDAA  $0143			| A = M[$0143]   - Right Integrator
CCCD : BRCLR $0064,00000010B,$CCD7
*
*
CCD1 : SBA   
CCD2 : BCC   $CCDC
*
*
CCD4 : CLRA  
CCD5 : BRA   $CCDC
*
*
CCD7 : ABA   
CCD8 : BCC   $CCDC
*
*
CCDA : LDAA  #$FF
*
*
CCDC : STAA  $0145
CCDF : LDAA  $00D9
CCE1 : STAA  $016E
CCE4 : LDAA  $00D8
CCE6 : STAA  $016D
CCE9 : LDAA  $021A
CCEC : INCA  
CCED : CMPA  #$A0
CCEF : BLS   $CD02
*
*
CCF1 : BRSET $0060,10000000B,$CD05
*
*
CCF5 : LDX   #$1F00
CCF8 : STX   $400E
CCFB : LDAA  #$FF
CCFD : STAA  $021C
CD00 : BRA   $CD10
*
*
CD02 : STAA  $021A
CD05 : LDX   #$1FFF
CD08 : STX   $400E
CD0B : LDAA  #$FF
CD0D : STAA  $021C
CD10 : BRCLR $0049,00000010B,$CD17	| if ( bit 0x02 of M[$0049] is clear ) then goto CD17
*
*
CD14 : JMP   $CDF0			| goto CDF0
*
*
CD17 : LDAA  $004A			| A = M[$004A]
CD19 : ANDA  #$1F			| A = A & 0x1F
CD1B : ORAA  $801D			| A = A | M[$801D] (0x00)
CD1E : STAA  $004A			| M[$004A] = A
CD20 : LDX   $3FC2
CD23 : PSHX  
CD24 : NOP  
CD25 : NOP  
CD26 : LDD   $3FE0
CD29 : NOP  
CD2A : NOP  
CD2B : NOP  
CD2C : NOP  
CD2D : CPX   $3FC2
CD30 : BEQ   $CD3C
*
*
CD32 : PULX  
CD33 : LDX   $3FC2
CD36 : PSHX  
CD37 : NOP  
CD38 : NOP  
CD39 : LDD   $3FE0
*
*
CD3C : PSHB  
CD3D : PSHA  
CD3E : SUBD  $01A6
CD41 : BNE   $CD77
*
*
CD43 : PULX  
CD44 : PULX  
CD45 : LDAA  $01A1
CD48 : INCA  
CD49 : CMPA  #$27
CD4B : BCS   $CD5C
*
*
CD4D : BCLR  $0050,00010000B
CD50 : CLR   $00CF
CD53 : LDAA  #$27
CD55 : STAA  $01A1
CD58 : CLRA  
CD59 : JMP   $CDE5
*
*
CD5C : STAA  $01A1
CD5F : TAB   
CD60 : CLRA  
CD61 : LDX   #$0028
CD64 : FDIV  
CD65 : CPX   $01A4
CD68 : BHI   $CD70
*
*
CD6A : LDAA  $01A0
CD6D : JMP   $CDE5
*
*
CD70 : LDAB  $801C
CD73 : CLRA  
CD74 : FDIV  
CD75 : BRA   $CDC3
*
*
CD77 : BRSET $0050,00010000B,$CD8F
*
*
CD7B : BSET  $0050,00010000B
CD7E : LDAB  #$01
CD80 : STAB  $01A8
CD83 : PULX  
CD84 : STX   $01A6
CD87 : LDD   #$FFFF
CD8A : INC   $0205
CD8D : BRA   $CDA4
*
*
CD8F : PULX  
CD90 : STX   $01A6
CD93 : STAB  $01A8
CD96 : PSHB  
CD97 : ADDB  $0205
CD9A : STAB  $0205
CD9D : TSX   
CD9E : LDD   $01,X
CDA0 : SUBD  $01A2
CDA3 : INS   
CDA4 : STD   $01A4
CDA7 : PULX  
CDA8 : STX   $01A2
CDAB : LDAA  $01A1
CDAE : CLR   $01A1
CDB1 : CMPA  #$27
CDB3 : BCS   $CDB8
*
*
CDB5 : CLRA  
CDB6 : BRA   $CDE5
*
*
CDB8 : LDAB  $01A8
CDBB : LDAA  $801C
CDBE : MUL   
CDBF : LDX   $01A4
CDC2 : FDIV  
CDC3 : PSHX  
CDC4 : PSHX  
CDC5 : PULA  
CDC6 : PULB  
CDC7 : LSLB  
CDC8 : ADCA  #$00
CDCA : BCC   $CDCE
*
*
CDCC : LDAA  #$FF
*
*
CDCE : STAA  $00CF
CDD0 : PULA  
CDD1 : PULB  
CDD2 : CPD   #$3BE0
CDD6 : BLS   $CDDB
*
*
CDD8 : LDD   #$3BE0
CDDB : ADDD  #$0020
CDDE : ASLD  
CDDF : ASLD  
CDE0 : LDAB  #$CD
CDE2 : MUL   
CDE3 : ADCA  #$00
CDE5 : BRCLR $0069,00001000B,$CDED
*
*
CDE9 : LDAA  $88DA
CDEC : INCA  
*
*
CDED : STAA  $01A0
CDF0 : BRCLR $0049,00000110B,$CDF7	| if ( bit 0x06 of M[$0049] is clear ) then goto CDF7
*
*
CDF4 : JMP   $CEB9			| goto CEB9
*
*
CDF7 : BRSET $0061,00000010B,$CDFE	| if ( bit 0x02 of M[$0061] is set ) then goto CDFE ( if learn control is enabled then goto CDFE
CDFB : JMP   $CEB3			| goto CEB3
*
* Goes here is learn control is enabled.
*
CDFE : LDX   #$0015			| X = 0x0015
CE01 : LDAB  $0149			| B = M[$0149]    - BLM Cell Number
CE04 : ABX   				| X = X + B
CE05 : LDAA  $00,X			| A = M[$X]   (BLM's are stored 0x0015 - 0x0025?? or so.
CE07 : CMPA  $0147			| Compare A with M[$0147] (Current Left BLM)
CE0A : BNE   $CE56			| if ( A != M[$0147] ) then goto CE56
*
*
CE0C : LDAB  $014A			| B = M[$014A]
CE0F : INCB  				| B = B + 1
CE10 : BNE   $CE13			| if ( B != 0 (0xFF before increment)) then goto CE13
*
*
CE12 : DECB  				| B = B - 1 (keep it at 0xFF)
CE13 : STAB  $014A			| B = M[$014A]
CE16 : CMPB  $87A9			| compare B with M[$87A9] (0x0C)
CE19 : BCS   $CE59			| if ( B < 0x0C ) then goto CE59 
*
*
CE1B : LDAB  $0144			| B = M[$0144]  - Left Integrator
CE1E : SUBB  #$80			| B = B - 0x80
CE20 : BCS   $CE3A			| if ( B < 0 ) then goto CE3A
*
*
CE22 : CMPB  $87AF			| compare B with M[$87AF] (0x06)
CE25 : BLS   $CE56			| if ( B <= 0x06 ) then goto CE56
*
*
CE27 : BRSET $0063,00000010B,$CE59	| if ( bit 0x02 of M[$0063] is set ) then goto CE59
*
*
CE2B : ADDA  $87AA			| A = A + M[$87AA] (0x01)
CE2E : BCS   $CE35			| if ( A > 255 ) then goto CE35
*
*
CE30 : CMPA  $87AB			| compare A with M[$87AB] (0xA0) (160)
CE33 : BLS   $CE51			| if ( A < M[$87AB] (0xA0)) then got CE51 (160)
*
*
CE35 : LDAA  $87AB			| A = M[$87AB] (0xA0) (160)
CE38 : BRA   $CE51			| goto CE51
*
* Left integrator is less than 0x80.
*
CE3A : NEGB  				| B = 0xFF - B
CE3B : CMPB  $87B0			| compare B with M[$87B0] ( 0x06 )
CE3E : BLS   $CE56			| if ( B <= 0x06 ) then goto CE56
*
*
CE40 : BRCLR $0063,00000010B,$CE59	| if ( bit 0x02 of M[$0063] is clear ) then goto CE59
*
*
CE44 : SUBA  $87AA			| A = A - M[$87AA] (0x01, amount to lower Block learns by)
CE47 : BCS   $CE4E			| if ( A < 0 ) then goto CE4E
*
*
CE49 : CMPA  $87AC			| compare A with M[$87AC] (0x6C, dec 108)
CE4C : BHI   $CE51			| if ( A > M[$87AC] (0x6C) ) then goto CE51
*
*
CE4E : LDAA  $87AC			| A = M[$87AC] ( 0x6C, dec 108, BLM bottom limit)
CE51 : STAA  $00,X			| Store adjusted BLM back to the long term BLM cell
CE53 : STAA  $0147			| M[$0147] = A   - Left Block Learn Multiplier
CE56 : CLR   $014A			| M[$014A] = 0  - Reset Left BLM cell timer.

CE59 : LDX   #$0028			| X = 0x0028  - beginning of right blm long term storage tables.
CE5C : LDAB  $0149			| B = M[$0149]  - Block Learn Multiplier Cell
CE5F : ABX   				| X = X + B
CE60 : LDAA  $00,X			| A = M[$X]
CE62 : CMPA  $0148			| compare A with M[$0148] (right block learn multiplier)
CE65 : BNE   $CEB6			| if ( A != M[$0148] (right block learn multiplier)) then goto CEB6
*
*
CE67 : LDAB  $014B
CE6A : INCB  
CE6B : BNE   $CE6E			| if ( B != 0 (or B was 0xFF before increment)) then goto CE6E
*
*
CE6D : DECB  				| B = B - 1
CE6E : STAB  $014B			| B = M[$014B] ( Right BLM timer)
CE71 : CMPB  $87A9			| compare B with M[$87A9] (0x0C)
CE74 : BCS   $CEB9			| if (B < 0x0C ) then goto CEB9
*
*
CE76 : LDAB  $0143			| B = M[$0143]   - Right Integrator
CE79 : SUBB  #$80			| B = B - 0x80
CE7B : BCS   $CE95			| if ( B < 0 ) then goto CE95
*
*
CE7D : CMPB  $87AF			| compare B with M[$87AF] (0x06)
CE80 : BLS   $CEB6			| if ( B <= M[$87AF] (0x06) ) then goto CEB6
*
*
CE82 : BRSET $0064,00000010B,$CEB9	| set bit 0x02 of M[$0064] ( Right blm needs to be adjusted)
*
*
CE86 : ADDA  $87AA
CE89 : BCS   $CE90
*
*
CE8B : CMPA  $87AB
CE8E : BLS   $CEAC
*
*
CE90 : LDAA  $87AB
CE93 : BRA   $CEAC
*
*
CE95 : NEGB  
CE96 : CMPB  $87B0
CE99 : BLS   $CEB6
*
*
CE9B : BRCLR $0064,00000010B,$CEB9
*
*
CE9F : SUBA  $87AA
CEA2 : BCS   $CEA9
*
*
CEA4 : CMPA  $87AC
CEA7 : BHI   $CEAC
*
*
CEA9 : LDAA  $87AC
CEAC : STAA  $00,X
CEAE : STAA  $0148			| M[$0148] = A   - Right Block Learn Multiplier
CEB1 : BRA   $CEB6
*
*
CEB3 : CLR   $014A
CEB6 : CLR   $014B
CEB9 : LDAA  #$55
CEBB : STAA  $103A
CEBE : LDAB  $0049			| B = M[$0049] 
CEC0 : ANDB  #$0F			| B = B & 0x0F
CEC2 : LDX   #$CF54			| X = 0xCF54
CEC5 : LSLB  				| B = B * 2
CEC6 : ABX   				| X = X + B
CEC7 : LDX   $00,X			| X = M[$X] 
Table at CF54

CEC9 : JSR   $00,X
CECB : BCLR  $0052,00000100B
CECE : CLI   
CECF : BRCLR $0049,00000011B,$CF3D
CED3 : LDX   $0282
CED6 : LDY   $0284
CEDA : LDD   $00,X
CEDC : ABY   
CEDE : TAB   
CEDF : ABY   
CEE1 : LDD   $02,X
CEE3 : ABY   
CEE5 : TAB   
CEE6 : ABY   
CEE8 : LDD   $04,X
CEEA : ABY   
CEEC : TAB   
CEED : ABY   
CEEF : LDD   $06,X
CEF1 : ABY   
CEF3 : TAB   
CEF4 : ABY   
CEF6 : LDAB  #$07			| B = 0x07
CEF8 : ABX   				| B = B + X
CEF9 : INX   				| X = X + 1
CEFA : BEQ   $CF07			| if ( X == 0 ) then goto CF07
CEFC : SEI   
CEFD : STX   $0282
CF00 : STY   $0284
CF04 : CLI   
CF05 : BRA   $CEDA
CF07 : LDAA  $8008			| A = M[$8008] (prom disable byte)
CF0A : CMPA  #$AA			| compare A with 0xAA
CF0C : BEQ   $CF23			| if ( A == 0xAA ) then CF23 (goto prom checksum is disabled)
CF0E : CMPA  #$DA			| compare A with 0xDA
CF10 : BNE   $CF2C			| if ( A != 0xDA ) then goto CF2C (goto set prom failure routine)
CF12 : CPY   $8006			| compare Y with M[$8006]
CF16 : BNE   $CF2C			| if ( Y != M[$8006] ) then CF2C (goto set prom failure routine) 
CF18 : LDAA  $103F			| A = M[$103F] (register?)
CF1B : CMPA  #$0B			| compare A with 0x0B
CF1D : BEQ   $CF23			| if (A == 0x0B ) then goto CF23 (goto prom checksum is disabled)
CF1F : CMPA  #$7B			| compare A with 0x7B
CF21 : BNE   $CF2C			| if ( A != 0x7B ) then goto CF2C (goto set prom failure routine)
CF23 : LDX   #$8008
CF26 : LDY   #$0000
CF2A : BRA   $CEFC
CF2C : SEI   
CF2D : BSET  $0002,00001000B		| set bit 0x08 of M[$0002] (Pluggable memory failure)
CF30 : BSET  $0005,00000001B		| set bit 0x01 of M[$0005] (PROM Error code 51 )
CF33 : JSR   $FAB5
CF36 : STD   $0011
CF38 : CLR   $0010
CF3B : BRA   $CF3B
CF3D : LDX   $0201
CF40 : BEQ   $CF4F
CF42 : DEX   
CF43 : DEX   
CF44 : SEI   
CF45 : LDD   $00,X
CF47 : STD   $00,X
CF49 : CLI   
CF4A : STX   $0201
CF4D : BNE   $CF42
CF4F : LDX   #$02DE
CF52 : BRA   $CF44
*
* Start of TABLE
*
CF54 : STOP  
CF55 : NOTDEF
CF56 : STOP  
CF57 : LDAA  #$D2
CF59 : STS   $00D5			| store stack pointer M[$00D5]
CF5B : NOTDEF
CF5C : STAB  $0004
CF5E : ORAB  $0066
CF60 : LDD   $003E
CF62 : STD   $0010
CF64 : SBCB  $06,X
CF66 : SBCB  $D4,X
CF68 : ANDB  $B6,X
CF6A : LDAB  $48,X
CF6C : EORB  $BB,X
CF6E : STD   $05,X
CF70 : STX   $38,X
CF72 : CMPB  $3239
*
* End OF TABLE
*
CF75 : BRCLR $004F,10000000B,$CF7E
CF79 : JSR   $510C
CF7C : BRA   $CF85
*
*
CF7E : BRCLR $004F,01000000B,$CF85
CF82 : JSR   $580F
CF85 : RTS   
*
*


CF86 : SEI   
CF87 : BCLR  $005C,00010000B			| Clear bit 0x10 - supposely not used - some malf code?
CF8A : LDX   #$4000				| X = 0x4000
CF8D : BCLR  $00,X,00011100B			| clear bit 0x1C of 0x4000 - unknown what 0x4000 is.
CF90 : LDAA  #$18				| A = 0x18
CF92 : ORAA  $00,X				| A = A OR M[$4000]
CF94 : STAA  $00,X				| M[$4000] = A
CF96 : CLR   $1030				| Clear $1030 A/D control/Status Register
						| Reset, perform 4 conversions on a single channel channel #0
						| TPS?
CF99 : LDX   #$1000				| X = 0x1000
CF9C : LDAB  #$0C				| B = 0x0C
CF9E : BRSET $30,X,10000000B,$CFA8		| If bit 0x80 of M[$(X+0x30)] is set then CFA8 (wait until A/D is done)
CFA2 : DECB  					| B = B - 1
CFA3 : BNE   $CF9E				| if (B != 0) then goto CF9E
CFA5 : BSET  $0059,00000001B			| Set 0x01 of M[$0059] - A/D Error conversion Flag
CFA8 : LDAA  $1034				| A = M[$1034] - 
CFAB : CMPA  $83D4				| compare A to $83D4 (0x19)
CFAE : BLS   $CFB3				| if ( A <= M[$83D4] (0x19)) then goto CFB3
CFB0 : BSET  $005C,00010000B			| set bit 0x10 of M[$005C]
CFB3 : CLI   					| Clear Interrupts
CFB4 : BRSET $005C,00010000B,$CFD5		| if (bit 0x01 of M[$005C] is set) then goto CFD5
CFB8 : LDAA  $00DC				| A = M[$00DC] (TPS output data)
CFBA : CMPA  #$AB				| compare A with 0xAB (17.1 voltes)
CFBC : BCS   $CFD5				| if ( A < 0xAB) then goto CFD5
CFBE : BRCLR $0051,01000000B,$CFD0		| if ( bit 0x40 of M[$0051] is clear) then goto CFD0 (if not high battery voltage)
CFC2 : BSET  $0074,01000000B			| set bit 0x40 of M[$0074]
CFC5 : BSET  $005A,00001000B			| set bit 0x08 of M[$005A] - Code M53 Voltage > 17 or voltage > 8)
CFC8 : LDD   #$7F00				| D = 0xF700
CFCB : STD   $400A				| M[$400A] = D
CFCE : BRA   $CFFA				| goto CFFA
CFD0 : BSET  $0051,01000000B			| Set bit 0x40 of M[$0051] (high battery voltage)
CFD3 : BRA   $CFDB				| goto CFD8
CFD5 : BCLR  $0051,01000000B			| Clear 
CFD8 : BCLR  $005A,00001000B
CFDB : BRCLR $0050,10000000B,$CFE2
CFDF : JMP   $D0A3
CFE2 : BRCLR $006A,00001000B,$CFE9
CFE6 : JMP   $D0C0
CFE9 : BRSET $005A,10000000B,$D021
CFED : LDX   #$7F00
CFF0 : BRSET $0050,00100000B,$CFF7
CFF4 : LDX   #$7FFF
CFF7 : STX   $400A
CFFA : BCLR  $004B,00100000B
CFFD : LDD   $3FFC
D000 : ANDB  #$FB
D002 : LDX   #$D000
D005 : BRN   $D00A
D007 : STD   $3FFC
D00A : SEI   
D00B : LDD   $10FC
D00E : ORAB  #$08
D010 : STD   $10FC
D013 : CLI   
D014 : STX   $3FCC
D017 : NOP  
D018 : NOP  
D019 : NOP  
D01A : NOP  
D01B : LDY   #$7F00
D01F : BRA   $D04D
D021 : BSET  $004B,00100000B
D024 : LDD   $3FFC
D027 : ORAB  #$04
D029 : LDX   #$D000
D02C : STX   $3FCC
D02F : NOP  
D030 : NOP  
D031 : NOP  
D032 : NOP  
D033 : LDX   #$DFFF
D036 : BRN   $D03B
D038 : STD   $3FFC
D03B : SEI   
D03C : LDD   $10FC
D03F : ANDB  #$F7
D041 : STD   $10FC
D044 : CLI   
D045 : LDY   #$7FFF
D049 : STY   $400A
D04D : STX   $3FDA
D050 : NOP  
D051 : NOP  
D052 : NOP  
D053 : NOP  
D054 : STX   $3FEA
D057 : STX   $3FD8
D05A : LDAA  $801A
D05D : BITA  #$04
D05F : BEQ   $D068
D061 : LDAA  $801B
D064 : BITA  #$01
D066 : BEQ   $D06E
D068 : STY   $4008
D06C : BRA   $D08E
D06E : BITA  #$80
D070 : BEQ   $D076
D072 : STY   $4008
D076 : LDAA  $1002
D079 : BRSET $005A,10000000B,$D089
D07D : BRCLR $0051,00010000B,$D089
D081 : BRSET $005A,00001000B,$D089
D085 : ORAA  #$08
D087 : BRA   $D08B
D089 : ANDA  #$F7
D08B : STAA  $1002
D08E : LDAA  $8018
D091 : BITA  #$40
D093 : BEQ   $D09D
D095 : PSHX  
D096 : PULA  
D097 : ANDA  #$0F
D099 : ORAA  #$B0
D09B : PSHA  
D09C : PULX  
D09D : STX   $3FD6
D0A0 : JMP   $D292
*
*
D0A3 : LDAA  $00DC
D0A5 : CMPA  #$50
D0A7 : BCC   $D0B5
D0A9 : BRCLR $0059,10000000B,$D0BD
D0AD : BSET  $005A,00001000B
D0B0 : BSET  $0074,01000000B
D0B3 : BRA   $D0C0
D0B5 : BCLR  $005A,00001000B
D0B8 : BCLR  $0059,10000000B
D0BB : BRA   $D0C0
D0BD : BSET  $0059,10000000B
D0C0 : CLRA  
D0C1 : BRCLR $006A,00001000B,$D0C8
D0C5 : LDAA  $02B1
D0C8 : STAA  $007C
D0CA : CLRA  
D0CB : BRCLR $006A,00001000B,$D0D2
D0CF : LDAA  $02AD
D0D2 : STAA  $007B
D0D4 : CLRB  
D0D5 : BRCLR $007B,00001000B,$D0E4
D0D9 : LDAA  $02AE
D0DC : BITA  #$08
D0DE : BEQ   $D0F4
D0E0 : LDAB  #$FF
D0E2 : BRA   $D0F4
D0E4 : BRCLR $007C,00001000B,$D0ED
D0E8 : LDAB  $02B2
D0EB : BRA   $D0F4
D0ED : BRCLR $0050,10000000B,$D0F4
D0F1 : LDAB  $01FB
D0F4 : LDAA  $801A
D0F7 : BITA  #$80
D0F9 : BNE   $D0FC
D0FB : COMB  
D0FC : LDAA  $8018
D0FF : BITA  #$40
D101 : BNE   $D109
D103 : LDAA  #$34
D105 : ASLD  
D106 : ASLD  
D107 : BRA   $D10E
D109 : LDAA  #$16
D10B : ASLD  
D10C : ASLD  
D10D : ASLD  
D10E : STD   $3FD6
D111 : CLRB  
D112 : BRCLR $007C,00000001B,$D11B
D116 : LDAB  $02B2
D119 : BRA   $D126
D11B : BRCLR $0050,10000000B,$D126
D11F : BRSET $005B,01000000B,$D126
D123 : LDAB  $01FF
D126 : LDAA  $8019
D129 : BITA  #$80
D12B : BEQ   $D12E
D12D : COMB  
D12E : LDAA  #$34
D130 : ASLD  
D131 : ASLD  
D132 : ORAB  #$03
D134 : STD   $3FD8
D137 : LDD   $10FC
D13A : ORAB  #$08
D13C : BRCLR $007B,00000010B,$D14B
D140 : PSHB  
D141 : LDAB  $02AE
D144 : BITB  #$02
D146 : PULB  
D147 : BEQ   $D155
D149 : BRA   $D153
D14B : BRCLR $0050,10000000B,$D155
D14F : BRCLR $0065,00000001B,$D155		| branch if fan #1 is not enabled
D153 : ANDB  #$F7
D155 : STD   $10FC
D158 : LDX   #$7F00
D15B : BRSET $0050,00100000B,$D162
D15F : LDX   #$7FFF
D162 : STX   $400A
D165 : LDAB  $8019
D168 : BITB  #$04
D16A : BNE   $D184
D16C : LDX   #$D000
D16F : BRCLR $007B,00100000B,$D17C
D173 : LDAB  $02AE
D176 : BITB  #$20
D178 : BEQ   $D187
D17A : BRA   $D184
D17C : BRCLR $0050,10000000B,$D187
D180 : BRCLR $0057,00000100B,$D187
D184 : LDX   #$DFFF
D187 : STX   $3FDA
D18A : LDX   #$D000
D18D : BRCLR $007B,00010000B,$D19A
D191 : LDAB  $02AE
D194 : BITB  #$10
D196 : BEQ   $D1A5
D198 : BRA   $D1A2
D19A : BRCLR $0050,10000000B,$D1A5
D19E : BRCLR $0057,00000010B,$D1A5
D1A2 : LDX   #$DFFF
D1A5 : STX   $3FCC
D1A8 : LDD   $3FFC
D1AB : ANDB  #$FB
D1AD : BRCLR $007B,10000000B,$D1BC
D1B1 : PSHB  
D1B2 : LDAB  $02AE
D1B5 : BITB  #$80
D1B7 : PULB  
D1B8 : BEQ   $D1C6
D1BA : BRA   $D1C4
D1BC : BRCLR $0050,10000000B,$D1C6
D1C0 : BRCLR $0065,00001000B,$D1C6		| branch if fan #2 is not enabled
D1C4 : ORAB  #$04				
D1C6 : STD   $3FFC				| M[$3FFC] = D   - bit 0x04 controls fan #2?
D1C9 : LDX   #$7F00				| X = 0x7F00
D1CC : LDAB  #$FF				| B = 0xFF
D1CE : BRCLR $007B,00000100B,$D1DB		| if ( bit 0x04 of M[$007B] is clear ) then goto D1DB
D1D2 : LDAA  $02AE				| A = M[$02AE]
D1D5 : BITA  #$04				| compare bit 0x04 of A
D1D7 : BNE   $D200				| if ( bit 0x04 of M[$02AE] is set ) then goto D200
D1D9 : BRA   $D1FF				| goto D1FF
D1DB : LDAA  $801A				| A = M[$801A]  (0xB3)
D1DE : BITA  #$04				| compare bit 0x04 of A
D1E0 : BEQ   $D1F7				| if ( bit 0x04 of M[$801A] (0xB3) is clear ) then goto D1F7
D1E2 : LDAA  $801B				| A = M[$801B]  (0x5A)
D1E5 : BITA  #$01				| compare bit 0x01 of A
D1E7 : BNE   $D1ED				| if ( bit 0x01 of M[$001B] (0x5A) is set ) then goto D1ED
D1E9 : BITA  #$80				| compare bit 0x80 of A
D1EB : BEQ   $D200				| if ( bit 0x80 of M[$801B] (0x5A) is clear ) then goto D200
D1ED : BRCLR $0050,10000000B,$D1FF		| if ( bit 0x80 of M[$0050] is clear ) then goto D1FF - if (Engine is not running ) then goto D1FF
D1F1 : BRSET $0067,00000010B,$D200		| if ( bit 0x02 of M[$0067] is set ) then goto D1FF  - if (CARS active ) then goto D200
D1F5 : BRA   $D1FF				| goto D1FF
D1F7 : BRCLR $0050,10000000B,$D1FF		| if ( bit 0x80 of M[$0050] is clear ) then goto D1FF - if (engine is not running ) then goto D1FF
D1FB : BRSET $0066,00000001B,$D200		| if ( bit 0x01 of M[$0066] is set ) then goto D200 - if (torque converter is locked) then goto D200
D1FF : CLRB  					| B = 0
D200 : ABX   					| X = X + B
D201 : STX   $4008				| M[$4008] = X  (TCC PWM?)
D204 : LDX   #$1002				| X = 0x1002
D207 : LDAA  $801B				| A = M[$801B] (0x5A)
D20A : BITA  #$01				| compare bit 0x01 of A
D20C : BNE   $D233				| if ( bit 0x01 of M[$801B] (0x5A) is set ) then goto D233
D20E : LDAB  $801A				| B = M[$801A] (0xB3)
D211 : BITB  #$04				| compare bit 0x04 of A
D213 : BEQ   $D233				| if ( bit 0x04 of M[$801A] (0xB3) is clear ) then goto D233
D215 : BRCLR $006A,00001000B,$D226		| if ( bit 0x08 of M[$006A] is clear) then goto D226
D219 : LDAA  $02B0
D21C : BITA  #$20
D21E : BEQ   $D226
D220 : BRSET $007C,00100000B,$D233
D224 : BRA   $D22E
D226 : BRCLR $0050,10000000B,$D22E
D22A : BRSET $0051,00010000B,$D233
D22E : BCLR  $00,X,00001000B
D231 : BRA   $D236
D233 : BSET  $00,X,00001000B
D236 : BRCLR $006A,00001000B,$D247
D23A : LDAA  $02B0
D23D : BITA  #$10
D23F : BEQ   $D247
D241 : BRSET $007C,00010000B,$D254
D245 : BRA   $D24F
D247 : BRCLR $0050,10000000B,$D24F
D24B : BRSET $0067,00000010B,$D254		|
D24F : BCLR  $004B,00100000B			| clear bit 0x20 of M[$004B] - C.A.R.S Light off
D252 : BRA   $D257				| goto D257
D254 : BSET  $004B,00100000B			| set bit 0x20 of M[$004B]  - C.A.R.S. Light on
D257 : LDX   #$DFFF				| X = 0xDFFF
D25A : BRCLR $006A,00001000B,$D26B		| if ( bit 0x08 of M[$006A] is clear ) then goto D26B
D25E : LDAA  $02B0				| A = M[$02B0]
D261 : BITA  #$04				| compare bit 0x04 of A
D263 : BEQ   $D26B				| if ( bit 0x04 of M[$02B0] is clear ) then goto D26B
D265 : BRSET $007C,00000100B,$D276
D269 : BRA   $D273
D26B : BRCLR $0050,10000000B,$D273
D26F : BRSET $0068,10000000B,$D276
D273 : LDX   #$D000
D276 : STX   $3FEA
D279 : LDX   #$F0FF
D27C : STX   $3FD4
D27F : LDX   #$7FFF
D282 : STX   $400C
D285 : BRCLR $007B,00000001B,$D292
D289 : LDAB  $02AE
D28C : BITB  #$01
D28E : BEQ   $D29B
D290 : BRA   $D296
D292 : BRCLR $0068,01000000B,$D29B
D296 : BSET  $004B,00000001B
D299 : BRA   $D29E
D29B : BCLR  $004B,00000001B
D29E : RTS   
*
*
*
D29F : LDAA  $01A9 			| A = M[$01A9]   - coolent temp lag filtered
D2A2 : CMPA  $8542			| compare A with M[$8542] (0xFF)
D2A5 : BLS   $D2E9			| if ( A <= M[$8542] (0xFF) ) then goto D2E9
D2A7 : LDAA  $00CF			| A = M[$00CF]   - vehicle speed
D2A9 : CMPA  $8543			| compare A with M[$8543] (0xFF)
D2AC : BLS   $D328			| if ( A <= M[$8543] (0xFF) ) then goto D328
D2AE : LDAA  $0164			| A = M[$0164]   - throttle axis load variable
D2B1 : CMPA  $8544			| compare A with M[$8544] (0xFF)
D2B4 : BCS   $D328			| if ( A < M[$8544] (0xFF) ) then goto D328
D2B6 : LDAA  $0154			
D2B9 : CMPA  $8545
D2BC : BLS   $D328
D2BE : LDAA  $0250
D2C1 : CMPA  $8538
D2C4 : BLS   $D328
D2C6 : LDAA  $0123			| A = M[$0123]   - engine rpm
D2C9 : LDX   #$8546			| X = 0x8546 
D2CC : BRCLR $0068,10000000B,$D2D3
D2D0 : LDX   #$854F
D2D3 : CMPA  $00,X
D2D5 : BLS   $D328
D2D7 : CMPA  $01,X
D2D9 : BLS   $D2EB
D2DB : LDX   #$0000
D2DE : STX   $0220
D2E1 : BSET  $0068,10000000B
D2E4 : BSET  $0051,00001000B
D2E7 : BRA   $D32E
D2E9 : BRA   $D328
D2EB : CMPA  #$E0
D2ED : BLS   $D2F1
D2EF : LDAA  #$E0
D2F1 : LSRA  
D2F2 : LDAB  #$10
D2F4 : INX   
D2F5 : INX   
D2F6 : JSR   $FC10
D2F9 : CMPA  $0164
D2FC : BCS   $D328
D2FE : BRSET $0051,00001000B,$D31A
D302 : BSET  $0051,00001000B
D305 : LDAA  $0164
D308 : BPL   $D30C
D30A : LDAA  #$80
D30C : LSRA  
D30D : LDX   #$8559
D310 : JSR   $FC14
D313 : LDAB  $8558
D316 : MUL   
D317 : STD   $0220
D31A : BSET  $0068,10000000B
D31D : LDX   $0220
D320 : BEQ   $D32E
D322 : DEX   
D323 : STX   $0220
D326 : BRA   $D32B
D328 : BCLR  $0051,00001000B
D32B : BCLR  $0068,10000000B
D32E : BRSET $0049,00010000B,$D335
D332 : JMP   $D3EA
D335 : LDAA  $0122
D338 : CMPA  #$E0
D33A : BCC   $D343
D33C : SUBA  #$10
D33E : BCC   $D34C
D340 : CLRA  
D341 : BRA   $D34C
D343 : LDAA  $0125			| A = M[$0125]
D346 : ADDA  #$50			| A = A + 0x50
D348 : BCC   $D34C			| if ( A < 0xFF ) then goto D34C
D34A : LDAA  #$FF			| A = 0xFF
D34C : STAA  $0126			| M[$0126] = A
*
*
*
D34F : LDAA  $0126
D352 : LSRA  
D353 : LSRA  
D354 : LSRA  
D355 : LSRA  
D356 : ADCA  #$00
D358 : LDAB  #$11
D35A : MUL   
D35B : ADDD  #$02DF
D35E : PSHB  
D35F : PSHA  
D360 : LDAB  $0153
D363 : LSRB  
D364 : LSRB  
D365 : LSRB  
D366 : LSRB  
D367 : ADCB  #$00
D369 : PULX  
D36A : ABX   
D36B : CPX   $00BF
D36D : BNE   $D3DE
D36F : BRCLR $0061,00000010B,$D3DE
D373 : LDAA  $0144			| A = M[$0144]  - Left Integrator
D376 : SUBA  #$80			| A = A - 0x80
D378 : BCC   $D382			| if (A >= 0) then goto D382
D37A : NEGA  				| A = -A (A is negative)
D37B : CMPA  $87B0			| compare A with M[$87B0] (0x06)
D37E : BHI   $D3DE			| if ( A > M[$87B0] (0x06) ) then goto D3DE
D380 : BRA   $D387			| goto D387
D382 : CMPA  $87AF			| compare A with M[$87AF] (0x06)
D385 : BHI   $D3DE			| if ( A > M[$87AF] (0x06) ) then goto D3DE
D387 : LDAA  $0143			| A = M[$0143]   - Right Integrator
D38A : SUBA  #$80			| A = A - 0x80
D38C : BCC   $D396			| if ( A >= 0) then goto D396
D38E : NEGA  				| A = -A (A is negative)
D38F : CMPA  $87B0			| compare A with M[$87B0] (0x06)
D392 : BHI   $D3DE			| if ( A > M[$87B0] (0x06)) then goto D3DE
D394 : BRA   $D39B			| goto D39B
D396 : CMPA  $87AF
D399 : BHI   $D3DE
D39B : LDAA  $00BE
D39D : CMPA  #$05
D39F : BCC   $D3A6
D3A1 : INC   $00BE
D3A4 : BRA   $D3E1
D3A6 : LDAA  $0147			| A = M[$0147]   - Left Block Learn Multiplier
D3A9 : ADDA  $0148			| A = A + M[$0148]  - Right Block Learn Multiplier
D3AC : BCC   $D3B9			
D3AE : LDAB  $00BA
D3B0 : MUL   
D3B1 : ADCA  $00BA
D3B3 : BCC   $D3BE
D3B5 : LDAA  #$FF
D3B7 : BRA   $D3BE
D3B9 : LDAB  $00BA
D3BB : MUL   
D3BC : ADCA  #$00
D3BE : STAA  $00BD
D3C0 : LDAB  $0126
D3C3 : ANDB  #$0F
D3C5 : CMPB  #$0C
D3C7 : BCC   $D3CD
D3C9 : CMPB  #$04
D3CB : BHI   $D3E6
D3CD : LDAB  $0153
D3D0 : ANDB  #$0F
D3D2 : CMPB  #$0C
D3D4 : BCC   $D3DA
D3D6 : CMPB  #$04
D3D8 : BHI   $D3E6
D3DA : STAA  $00,X
D3DC : BRA   $D3E6
D3DE : CLR   $00BE
D3E1 : CLR   $00BD
D3E4 : STX   $00BF
D3E6 : LDAA  $00,X
D3E8 : STAA  $00C1
D3EA : CLRA  
D3EB : BRCLR $0002,00100000B,$D3F1
D3EF : ORAA  #$01
D3F1 : BRCLR $004C,00100000B,$D3F7
D3F5 : ORAA  #$02
D3F7 : BRCLR $0058,00100100B,$D3FD
D3FB : ORAA  #$04
D3FD : BRCLR $005B,00000011B,$D403
D401 : ORAA  #$08
D403 : BRSET $0060,00010000B,$D40B
D407 : BRCLR $0059,00000010B,$D40D
D40B : ORAA  #$10
D40D : BRCLR $0058,10000000B,$D413
D411 : ORAA  #$20
D413 : BRCLR $0058,01000000B,$D419
D417 : ORAA  #$40
D419 : BRCLR $0068,00010000B,$D41F
D41D : ORAA  #$80
D41F : STAA  $006B
D421 : CLRA  
D422 : LDAB  $024F
D425 : BEQ   $D429
D427 : ORAA  #$01
D429 : BRCLR $0066,00000001B,$D42F		| branch if torque convertor is not locked
D42D : ORAA  #$02
D42F : BRCLR $0050,10000000B,$D435
D433 : ORAA  #$04
D435 : STAA  $006C
D437 : LDD   $0041
D439 : ASLD  
D43A : STD   $0044
D43C : LDAA  $8008
D43F : CMPA  #$AA
D441 : BNE   $D4A1
D443 : BRCLR $005A,10000000B,$D454
D447 : BSET  $005A,00100000B
D44A : LDAA  $0212
D44D : BNE   $D495
D44F : CLR   $0211
D452 : BRA   $D4A7
D454 : BRCLR $005A,00100000B,$D495
D458 : BCLR  $005A,00100000B
D45B : INC   $0212
D45E : LDAA  $0212
D461 : CMPA  #$05
D463 : BCC   $D479
D465 : CMPA  #$03
D467 : BCS   $D495
D469 : LDD   #$0000
D46C : STD   $0003
D46E : STD   $0005
D470 : STAA  $0007
D472 : LDD   #$0001
D475 : STD   $0011
D477 : BRA   $D495
D479 : LDX   #$0048
D47C : CLR   $00,X
D47E : DEX   
D47F : BNE   $D47C
D481 : LDAA  #$80
D483 : LDX   #$0026
D486 : STAA  $14,X
D488 : DEX   
D489 : BNE   $D486
D48B : LDD   #$0001
D48E : STD   $0011
D490 : BSET  $0056,01000000B
D493 : BRA   $D4A1
D495 : LDAA  $0211
D498 : CMPA  #$50
D49A : BCC   $D4A1
D49C : INC   $0211
D49F : BRA   $D4A7
D4A1 : BCLR  $005A,00100000B
D4A4 : CLR   $0212
D4A7 : LDX   #$83CB
D4AA : BRCLR $00,X,10000000B,$D503
D4AE : BRCLR $005C,00000001B,$D4BB
D4B2 : CLR   $01DB
D4B5 : BRSET $005A,01000000B,$D4FD
D4B9 : BRA   $D4CE
D4BB : LDAA  $01DB
D4BE : INCA  
D4BF : BNE   $D4C2
D4C1 : DECA  
D4C2 : STAA  $01DB
D4C5 : CMPA  #$04
D4C7 : BCS   $D503
D4C9 : BCLR  $005A,01000000B
D4CC : BRA   $D4EB
D4CE : BRSET $004F,00010000B,$D4EB
D4D2 : LDD   $10F4
D4D5 : SUBD  $0262
D4D8 : STD   $0264
D4DB : LDAB  $8428
D4DE : CLRA  
D4DF : LDX   $3FC0
D4E2 : FDIV  
D4E3 : STX   $026B
D4E6 : CPX   $0264
D4E9 : BHI   $D4F0
D4EB : CLR   $026A
D4EE : BRA   $D503
D4F0 : LDAA  $026A
D4F3 : CMPA  $8429
D4F6 : BCC   $D4FD
D4F8 : INC   $026A
D4FB : BRA   $D503
D4FD : BSET  $005A,01000000B
D500 : BSET  $0073,10000000B
D503 : LDD   $10F4
D506 : STD   $0262
D509 : BCLR  $005C,00000001B
D50C : LDX   #$83C9
D50F : BRCLR $00,X,00001000B,$D540   	| if bit 0x04 of M[$83C9] is clear then RTS
D513 : SEI   				|
D514 : LDD   $10F4			| D = M[$10F4]
D517 : SUBD  $0266			| D = D - M[$0266]
D51A : STD   $0268			| M[$0268] = D
D51D : CLI   				|
D51E : CPD   $83E1			| if D <= M[$83E1] (0x??) then goto D540
D522 : BLS   $D540			|
D524 : BRSET $005C,00001000B,$D535	| if bit 0x04 of M[$005C] is set then goto D535
D528 : BSET  $005C,00001000B		| set bit 0x04 of M[$005C] - set code malf 16 first pass has occured.
D52B : SEI   
D52C : LDD   $10F4
D52F : STD   $0266
D532 : CLI   
D533 : BRA   $D540
D535 : BSET  $0003,00001000B
D538 : JSR   $FAB5
D53B : STD   $0011
D53D : CLR   $0010
D540 : RTS   
D541 : BRCLR $004F,10000000B,$D548
D545 : JSR   $510F
D548 : LDAA  #$F7
D54A : STAA  $5000
D54D : BRCLR $004F,01000000B,$D554
D551 : JSR   $5812
D554 : LDAA  $2000
D557 : BEQ   $D55C
D559 : BSET  $004F,00000100B
D55C : LDX   #$1000
D55F : CLRA  
D560 : STAA  $2C,X
D562 : STAA  $0B,X
D564 : STAA  $28,X
D566 : STAA  $5C,X
D568 : STAA  $38,X
D56A : BSET  $21,X,00000011B
D56D : BCLR  $21,X,00100000B
D570 : LDAA  #$60
D572 : STAA  $01,X
D574 : LDAA  #$2F
D576 : STAA  $03,X
D578 : LDAA  #$3C
D57A : STAA  $09,X
D57C : LDAA  #$04
D57E : STAA  $2B,X
D580 : BSET  $22,X,00010001B
D583 : LDAA  $83CB
D586 : BITA  #$60
D588 : BEQ   $D59A
D58A : LDAA  $0123
D58D : CMPA  $842D
D590 : BHI   $D59A
D592 : BSET  $22,X,00000100B
D595 : BSET  $21,X,00010000B
D598 : BRA   $D5A0
D59A : BCLR  $22,X,00000100B
D59D : BCLR  $21,X,00010000B
D5A0 : LDAA  #$15
D5A2 : STAA  $3C,X
D5A4 : LDAA  #$05
D5A6 : STAA  $5D,X
D5A8 : LDAA  #$CE
D5AA : STAA  $5F,X
D5AC : LDAA  #$40
D5AE : STAA  $5E,X
D5B0 : LDAA  #$FF
D5B2 : STAA  $4001
D5B5 : LDAA  #$31
D5B7 : STAA  $4003
D5BA : LDAA  #$00
D5BC : STAA  $4005
D5BF : BSET  $004A,00000010B
D5C2 : BCLR  $004D,00000010B
D5C5 : BRSET $005A,01000000B,$D5CC
D5C9 : BSET  $004D,00000010B
D5CC : LDD   $3FFC
D5CF : ANDB  #$FE
D5D1 : ORAB  #$12
D5D3 : ORAA  #$F9
D5D5 : STD   $3FFC
D5D8 : LDD   #$0002
D5DB : STD   $10C0
D5DE : LDAB  #$04
D5E0 : STD   $10C2
D5E3 : LDAB  #$06
D5E5 : STD   $10C4
D5E8 : LDD   #$FFF6
D5EB : STD   $10C6
D5EE : LDD   #$FFD8
D5F1 : STD   $10E8
D5F4 : LDAB  $82E7
D5F7 : COMB  
D5F8 : LDAA  #$FF
D5FA : ADDD  #$0001
D5FD : STD   $10EA
D600 : SEI   
D601 : LDD   $10FC
D604 : ANDB  #$EE
D606 : ORAB  #$02
D608 : ANDA  #$FE
D60A : BRCLR $005A,01000000B,$D610
D60E : ORAA  #$01
D610 : LDX   #$8019
D613 : BRCLR $00,X,00100000B,$D619
D617 : ORAA  #$01
D619 : ORAA  #$08
D61B : STD   $10FC
D61E : CLI   
D61F : BRSET $0050,10000000B,$D652	| if ( bit 0x80 of M[$0050] is set ) then goto D652  - if (engine running (spark)) then goto D652
D623 : BCLR  $0060,00100010B		
D626 : BCLR  $0061,00011000B		| clear bit 0x18 of M[$0061]   - clear left and right bank blm change integrator reset flag
D629 : LDAA  $01A9			| A = M[$01A9]   - Coolent temp lag filtered
D62C : STAA  $01AD			| M[$01AD] = A   -
D62F : BRSET $0001,00000010B,$D63B
D633 : CMPA  $809E
D636 : BCS   $D63B
D638 : BSET  $0001,00000010B
D63B : CLRB  
D63C : LDAA  $8684
D63F : STD   $0177
D642 : STAA  $0173
D645 : STAA  $00D8
D647 : STD   $0179
D64A : STD   $0175
D64D : STAA  $00D9
D64F : JMP   $D703
D652 : BCLR  $0001,00010000B
D655 : LDX   $0179			| X = M[$0179]
D658 : LDAA  $00D9			| A = M[$00D9]  - Left O2 sensor
D65A : LDAB  $83D3			| B = M[$83D3] (0x05)
D65D : JSR   $FB63			| D = X + ( 256 * A - X ) * 0x05
D660 : STD   $0179			| M[$0179] = D
D663 : LDX   $0177			| X = M[$0177]
D666 : LDAA  $00D8			| A = M[$00D8]  - Right O2 sensor
D668 : LDAB  $83D3			| B = M[$83D3] (0x05)
D66B : JSR   $FB63			| D = X + ( 256 * A - X ) * 0x05
D66E : STD   $0177			| M[$0177] = D
D671 : LDX   $020D
D674 : CPX   $8631
D677 : BLS   $D67C
D679 : BSET  $0001,00000100B
D67C : LDAA  $0164
D67F : BNE   $D6FD
D681 : LDAA  $01A0
D684 : CMPA  $8934
D687 : BCS   $D68C
D689 : BSET  $0070,01000000B
D68C : LDAA  $01A0
D68F : BNE   $D6FD
D691 : LDAA  $0114
D694 : CMPA  $8505
D697 : BLS   $D6FD
D699 : LDAA  $01A9
D69C : CMPA  $892D
D69F : BLS   $D703
D6A1 : CMPA  $892E
D6A4 : BCC   $D703
D6A6 : LDAA  $011D
D6A9 : BNE   $D703
D6AB : BRSET $0055,00000010B,$D703
D6AF : BRCLR $0070,01000000B,$D703
D6B3 : LDAA  $0120
D6B6 : CMPA  $8933
D6B9 : BCC   $D6C3
D6BB : INCA  
D6BC : BEQ   $D703
D6BE : STAA  $0120
D6C1 : BRA   $D703
D6C3 : CLR   $0120
D6C6 : LDAA  $003C
D6C8 : CMPA  $0116
D6CB : BEQ   $D703
D6CD : BCS   $D6DA
D6CF : DECA  
D6D0 : CMPA  $892F
D6D3 : BCC   $D6E3
D6D5 : LDAA  $892F
D6D8 : BRA   $D6E3
D6DA : INCA  
D6DB : CMPA  $8930
D6DE : BLS   $D6E3
D6E0 : LDAA  $8930
D6E3 : PSHA  
D6E4 : SUBA  $003C
D6E6 : BCC   $D6E9
D6E8 : NEGA  
D6E9 : ADDA  $011F
D6EC : BCC   $D6F0
D6EE : LDAA  #$FF
D6F0 : STAA  $011F
D6F3 : CMPA  $8932
D6F6 : PULA  
D6F7 : BHI   $D703
D6F9 : STAA  $003C
D6FB : BRA   $D703
D6FD : CLR   $011F
D700 : CLR   $0120
D703 : RTS   
D704 : LDX   #$4000
D707 : SEI   
D708 : BCLR  $00,X,00011100B
D70B : LDAA  #$1C
D70D : ORAA  $00,X
D70F : STAA  $00,X
D711 : CLR   $1030
D714 : LDX   #$1000
D717 : LDAB  #$0C
D719 : BRSET $30,X,10000000B,$D723
D71D : DECB  
D71E : BNE   $D719
D720 : BSET  $0059,00000001B
D723 : LDAA  $1034
D726 : CLI   
D727 : STAA  $00D6
D729 : BCLR  $0068,00010000B
D72C : BCLR  $0060,10000000B
D72F : CMPA  #$28
D731 : BCS   $D751
D733 : CMPA  $8017
D736 : BCC   $D754
D738 : CMPA  #$64
D73A : BCS   $D754
D73C : LDAA  $021B
D73F : CMPA  #$1E
D741 : BHI   $D757
D743 : BSET  $0060,10000000B
D746 : LDAA  $0049
D748 : CMPA  #$04
D74A : BNE   $D757
D74C : INC   $021B
D74F : BRA   $D757
D751 : BSET  $0068,00010000B
D754 : CLR   $021B
D757 : BRCLR $0050,10000000B,$D75F
D75B : BRCLR $0068,00010000B,$D762
D75F : JMP   $DA65
D762 : LDX   #$83CC
D765 : BRCLR $00,X,00000100B,$D790
D769 : BRCLR $0058,00001000B,$D790
D76D : BRSET $0057,00010000B,$D77A
D771 : CLRA  
D772 : STAA  $01EE
D775 : STAA  $01EF
D778 : BRA   $D790
D77A : LDAA  $01EE
D77D : INCA  
D77E : BNE   $D781
D780 : DECA  
D781 : STAA  $01EE
D784 : CMPA  $843F
D787 : BLS   $D790
D789 : BRSET $004C,00100000B,$D792
D78D : CLR   $01EF
D790 : BRA   $D7FF
D792 : LDAA  $00CF
D794 : CMPA  $8440
D797 : BLS   $D7FF
D799 : CMPA  #$60
D79B : BLS   $D79F
D79D : LDAA  #$60
D79F : ASLA  
D7A0 : LDX   #$8444
D7A3 : JSR   $FC14
D7A6 : TAB   
D7A7 : LDAA  $022F
D7AA : CMPA  #$C0
D7AC : BLS   $D7B0
D7AE : LDAA  #$C0
D7B0 : LDX   #$8451
D7B3 : JSR   $FC14
D7B6 : ABA   
D7B7 : BCS   $D7CB
D7B9 : TAB   
D7BA : LDAA  $00D7
D7BC : CMPA  #$B0
D7BE : BLS   $D7C2
D7C0 : LDAA  #$B0
D7C2 : LDX   #$845E
D7C5 : JSR   $FC14
D7C8 : ABA   
D7C9 : BCC   $D7CD
D7CB : LDAA  #$FF
D7CD : STAA  $0281
D7D0 : CMPA  $8441
D7D3 : BCC   $D7DF
D7D5 : LDAB  $01EF
D7D8 : INCB  
D7D9 : BNE   $D7DC
D7DB : DECB  
D7DC : STAB  $01EF
D7DF : CMPA  $8442
D7E2 : BLS   $D7E9
D7E4 : CLR   $01EF
D7E7 : BRA   $D7FF
D7E9 : LDAA  $01EF
D7EC : CMPA  $8443
D7EF : BLS   $D7FF
D7F1 : BSET  $0006,00000100B
D7F4 : JSR   $FAB5
D7F7 : STD   $0011
D7F9 : CLR   $0010
D7FC : BSET  $0051,00100000B
D7FF : BRCLR $0058,00100100B,$D805
D803 : BRA   $D83D
D805 : LDX   $0013
D807 : CPX   $83D6
D80A : BCS   $D83D
D80C : LDAA  $01E5
D80F : LDAB  $00D8
D811 : CMPB  $83D9
D814 : BHI   $D83D
D816 : CMPB  $83D8
D819 : BLS   $D83D
D81B : CMPA  $83DB
D81E : BHI   $D840
D820 : BRCLR $0058,00010000B,$D846
D824 : LDAB  $01A9
D827 : CMPB  $83D5
D82A : BLS   $D846
D82C : LDAB  $0164
D82F : CMPB  $83DA
D832 : BHI   $D83A
D834 : TSTA  
D835 : BEQ   $D846
D837 : DECA  
D838 : BRA   $D846
D83A : INCA  
D83B : BRA   $D846
D83D : CLRA  
D83E : BRA   $D846
D840 : BSET  $0074,00000001B
D843 : BSET  $005B,00000100B
D846 : STAA  $01E5
D849 : BCLR  $005B,00001000B
D84C : LDAA  $01E3
D84F : LDAB  $0177
D852 : CMPB  $8432
D855 : BHI   $D86B
D857 : CMPA  $8433
D85A : BHI   $D86E
D85C : BRCLR $0061,10000000B,$D86B
D860 : BRSET $005A,00000100B,$D86B
D864 : BRCLR $0058,00001000B,$D874
D868 : INCA  
D869 : BRA   $D874
D86B : CLRA  
D86C : BRA   $D874
D86E : BSET  $0075,10000000B
D871 : BSET  $005B,00001000B
D874 : STAA  $01E3
D877 : LDAA  $01E4
D87A : CMPB  $8434
D87D : BLS   $D8A6
D87F : CMPA  $8435
D882 : BHI   $D8A9
D884 : BRCLR $005B,00000011B,$D88A
D888 : BRA   $D8A6
D88A : BRCLR $0061,10000000B,$D8A6
D88E : BRSET $005A,00000100B,$D8A6
D892 : LDAB  $0164
D895 : CMPB  $8436
D898 : BHI   $D89F
D89A : CMPB  $8437
D89D : BCC   $D8A6
D89F : BRCLR $0058,00001000B,$D8AF
D8A3 : INCA  
D8A4 : BRA   $D8AF
D8A6 : CLRA  
D8A7 : BRA   $D8AF
D8A9 : BSET  $0075,01000000B
D8AC : BSET  $005B,00001000B
D8AF : STAA  $01E4
D8B2 : BCLR  $005A,00000100B
D8B5 : LDX   #$83CD
D8B8 : BRCLR $00,X,00100000B,$D8E0
D8BC : LDAA  $00D7
D8BE : CMPA  $846B
D8C1 : BCS   $D8C8
D8C3 : CMPA  $846C
D8C6 : BLS   $D8E0
D8C8 : LDAA  $01F0
D8CB : CMPA  $846D
D8CE : BCC   $D8E8
D8D0 : LDAA  $801B
D8D3 : BITA  #$01
D8D5 : BNE   $D8DB
D8D7 : BRCLR $0057,00010000B,$D8E0
D8DB : INC   $01F0
D8DE : BRA   $D8F6
D8E0 : BCLR  $0059,00010000B
D8E3 : CLR   $01F0
D8E6 : BRA   $D8F6
D8E8 : BSET  $0059,00010000B
D8EB : BSET  $0007,00100000B
D8EE : JSR   $FAB5
D8F1 : STD   $0011
D8F3 : CLR   $0010
D8F6 : LDX   #$83CD
D8F9 : BRCLR $00,X,00010000B,$D95D
D8FD : BRSET $0058,00000001B,$D960
D901 : BRCLR $004C,00100000B,$D941
D905 : CLR   $0233
D908 : BRCLR $0059,00100000B,$D960
D90C : LDAA  $00D7
D90E : SUBA  $022E
D911 : BCC   $D914
D913 : NEGA  
D914 : CMPA  $846E
D917 : BCS   $D921
D919 : BSET  $0058,00000001B
D91C : BCLR  $0059,01100000B
D91F : BRA   $D960
D921 : LDAA  $0232
D924 : CMPA  $846F
D927 : BCC   $D92E
D929 : INC   $0232
D92C : BRA   $D960
D92E : BSET  $0058,00000001B
D931 : BSET  $0059,01000000B
D934 : BSET  $0007,00010000B
D937 : JSR   $FAB5
D93A : STD   $0011
D93C : CLR   $0010
D93F : BRA   $D960
D941 : CLR   $0232
D944 : LDAA  $00D7
D946 : STAA  $022E
D949 : LDAA  $0233
D94C : INCA  
D94D : BNE   $D950
D94F : DECA  
D950 : STAA  $0233
D953 : CMPA  $8470
D956 : BCS   $D95D
D958 : BSET  $0059,00100000B
D95B : BRA   $D960
D95D : BCLR  $0059,00100000B
D960 : LDAA  $83CD
D963 : BITA  #$08
D965 : BEQ   $D9A5
D967 : LDAA  $01F7
D96A : CMPA  $8471
D96D : BHI   $D98B
D96F : BCLR  $005D,00001000B
D972 : BRCLR $004C,00100000B,$D986
D976 : LDAA  $400B
D979 : BNE   $D986
D97B : LDAA  $01F7
D97E : INCA  
D97F : BEQ   $D9A5
D981 : STAA  $01F7
D984 : BRA   $D9A5
D986 : CLR   $01F7
D989 : BRA   $D9A5
D98B : BSET  $005D,00001000B
D98E : LDAA  $8019
D991 : BITA  #$02
D993 : BEQ   $D99A
D995 : BSET  $0075,00001000B
D998 : BRA   $D9A5
D99A : BSET  $0007,00001000B
D99D : JSR   $FAB5
D9A0 : STD   $0011
D9A2 : CLR   $0010
D9A5 : BRSET $0054,00001000B,$D9E2
D9A9 : LDAA  $83CD
D9AC : BITA  #$04
D9AE : BEQ   $D9E2
D9B0 : LDAA  $01F8
D9B3 : CMPA  $8472
D9B6 : BLS   $D9C8
D9B8 : BSET  $005D,00010000B
D9BB : BSET  $0007,00000100B
D9BE : JSR   $FAB5
D9C1 : STD   $0011
D9C3 : CLR   $0010
D9C6 : BRA   $D9E2
D9C8 : BCLR  $005D,00010000B
D9CB : BRSET $004C,00100000B,$D9DF
D9CF : LDAA  $400B
D9D2 : BEQ   $D9DF
D9D4 : LDAA  $01F8
D9D7 : INCA  
D9D8 : BEQ   $D9E2
D9DA : STAA  $01F8
D9DD : BRA   $D9E2
D9DF : CLR   $01F8
D9E2 : LDAA  $83CD
D9E5 : BITA  #$01
D9E7 : BEQ   $DA65
D9E9 : LDAA  $00CF
D9EB : CMPA  $8477
D9EE : BCC   $DA01
D9F0 : BRCLR $004C,00001010B,$D9F9
D9F4 : BSET  $005D,00000001B
D9F7 : BRA   $DA4A
D9F9 : BCLR  $005D,00000111B
D9FC : CLR   $01FA
D9FF : BRA   $DA65
DA01 : BRCLR $0058,00001000B,$DA1C
DA05 : BRCLR $004C,00000010B,$DA19
DA09 : BRSET $004C,00001000B,$DA19
DA0D : BRSET $005D,00000100B,$DA16
DA11 : BSET  $005D,00000100B
DA14 : BRA   $DA1C
DA16 : BSET  $005D,00000001B
DA19 : BCLR  $005D,00000100B
DA1C : BRCLR $005D,00000001B,$DA4A
DA20 : LDAA  $00CF
DA22 : CMPA  $8478
DA25 : BLS   $DA4A
DA27 : LDAA  $0164
DA2A : CMPA  $8479
DA2D : BLS   $DA4A
DA2F : LDAA  $0123
DA32 : CMPA  $847A
DA35 : BLS   $DA4A
DA37 : LDAA  $01FA
DA3A : CMPA  $847B
DA3D : BHI   $DA47
DA3F : INCA  
DA40 : BEQ   $DA4A
DA42 : STAA  $01FA
DA45 : BRA   $DA4A
DA47 : BSET  $005D,00000010B
DA4A : BRCLR $005D,00000010B,$DA65
DA4E : LDAA  $8018
DA51 : BITA  #$04
DA53 : BEQ   $DA5A
DA55 : BSET  $0075,00000001B
DA58 : BRA   $DA65
DA5A : BSET  $0007,00000001B
DA5D : CLR   $0010
DA60 : JSR   $FAB5
DA63 : STD   $0011
DA65 : RTS   
DA66 : LDD   $020D
DA69 : CPD   $8497
DA6D : BCS   $DAD0
DA6F : BRSET $0060,00000010B,$DAD0
DA73 : BRSET $004F,00010000B,$DACA
DA77 : LDAA  $01A9
DA7A : CMPA  $8495
DA7D : BLS   $DAD0
DA7F : LDX   #$8499
DA82 : BRCLR $0054,00000001B,$DA89
DA86 : LDX   #$849C
DA89 : LDAB  $01A0
DA8C : LDAA  $01FB
DA8F : CMPB  $00,X
DA91 : BLS   $DACA
DA93 : LDAB  $0164
DA96 : CMPB  $01,X
DA98 : BCC   $DAC3
DA9A : LDAB  $8018
DA9D : BITB  #$08
DA9F : BNE   $DACA
DAA1 : BRSET $0069,00001000B,$DACA
DAA5 : LDAB  $01A0
DAA8 : CMPB  $8492
DAAB : BLS   $DACA
DAAD : LDAB  $0147			| B = M[$0147]   - Left Block learn Multiplier
DAB0 : CMPB  $0148			| Compare B to M[$0148] - Right Block Learn Multiplier
DAB3 : BCS   $DAB8			| if ( B (left blm) < M[$0148] (right block learn multiplier)) then  goto DAB8
DAB5 : LDAB  $0148			| B = M[$0148]   - Right Block Learn Multiplier
DAB8 : CMPB  $8494
DABB : BLS   $DACA
DABD : BRSET $0055,00000100B,$DAD0
DAC1 : BRA   $DACA
DAC3 : LDAB  $0154
DAC6 : CMPB  $02,X
DAC8 : BCC   $DAD3
DACA : BCLR  $0055,00000100B
DACD : CLR   $01FC
DAD0 : JMP   $DB90
DAD3 : BRCLR $0055,00000100B,$DADD
DAD7 : LDAA  $01FC
DADA : STAA  $01FB
DADD : LDAB  $015A
DAE0 : CMPB  $848B
DAE3 : BHI   $DB25
DAE5 : BRCLR $005F,10001000B,$DAEB
DAE9 : BRA   $DB25
DAEB : LDAB  $01FD
DAEE : CMPB  $848C
DAF1 : BCC   $DAF9
DAF3 : INC   $01FD
DAF6 : JMP   $DB94
DAF9 : LDAB  $0144			| B = M[$0144]   - Left Integrator
DAFC : CMPB  $0143			| compare B with M[$0143]  - Right Integrator
DAFF : BCS   $DB04			| if ( (left integrator) B < M[$0143] (right integrator) ) then got DB04
DB01 : LDAB  $0143
DB04 : CMPB  $848D
DB07 : BCC   $DB1E
DB09 : CMPB  $848E
DB0C : BCC   $DB25
DB0E : SUBA  $8490
DB11 : BCC   $DB14
DB13 : CLRA  
DB14 : CMPA  $8496
DB17 : BHI   $DB25
DB19 : LDAA  $8496
DB1C : BRA   $DB25
DB1E : ADDA  $848F
DB21 : BCC   $DB25
DB23 : LDAA  #$FF
DB25 : CLRB  
DB26 : STAB  $01FD
DB29 : BRSET $0061,10000000B,$DB37
DB2D : BCLR  $0055,00000100B
DB30 : LDAB  $8018
DB33 : BITB  #$20
DB35 : BEQ   $DB90
DB37 : PSHA  
DB38 : LDAA  $01FB
DB3B : CMPA  $8491
DB3E : BLS   $DB61
DB40 : LDAB  $01A0
DB43 : CMPB  $8492
DB46 : BLS   $DB61
DB48 : LDAB  $0147
DB4B : CMPB  $0148
DB4E : BCS   $DB53
DB50 : LDAB  $0148
DB53 : CMPB  $8493
DB56 : BLS   $DB61
DB58 : BSET  $0055,00000100B
DB5B : PULA  
DB5C : STAA  $01FC
DB5F : BRA   $DB94
DB61 : BCLR  $0055,00000100B
DB64 : CLR   $01FC
DB67 : LDD   $00C4
DB69 : CMPA  #$20
DB6B : BCS   $DB70
DB6D : LDD   #$FFFF
DB70 : ASLD  
DB71 : ASLD  
DB72 : ASLD  
DB73 : LDX   #$849F
DB76 : JSR   $FC09
DB79 : TAB   
DB7A : LDAA  $0235
DB7D : LDX   #$84A9
DB80 : JSR   $FC14
DB83 : MUL   
DB84 : ASLD  
DB85 : BCC   $DB89
DB87 : LDAA  #$FF
DB89 : PULB  
DB8A : CBA   
DB8B : BCS   $DB94
DB8D : TBA   
DB8E : BRA   $DB94
DB90 : CLRA  
DB91 : CLR   $01FD
DB94 : BCLR  $0054,00000001B
DB97 : STAA  $01FB
DB9A : BEQ   $DB9F
DB9C : BSET  $0054,00000001B
DB9F : LDAA  $0049
DBA1 : CMPA  #$05
DBA3 : BNE   $DBA9
DBA5 : BRSET $0050,10000000B,$DBAC
DBA9 : JMP   $DC3D
DBAC : LDAA  $00C4
DBAE : CMPA  #$80
DBB0 : BLS   $DBB4
DBB2 : LDAA  #$80
DBB4 : TAB   
DBB5 : LDX   #$85B7
DBB8 : JSR   $FC14
DBBB : STAA  $027D
DBBE : LDAA  $0123
DBC1 : LSRA  
DBC2 : LDX   #$85C7
DBC5 : JSR   $FB97
DBC8 : STAA  $027F
DBCB : LDAA  $01AE
DBCE : CMPA  #$9B
DBD0 : BLS   $DBD4
DBD2 : LDAA  #$9B
DBD4 : SUBA  #$6B
DBD6 : BCC   $DBD9
DBD8 : CLRA  
DBD9 : ASLA  
DBDA : LDX   #$85C0
DBDD : JSR   $FC14
DBE0 : STAA  $027E
DBE3 : SUBA  #$80
DBE5 : BMI   $DBF0
DBE7 : ADDA  $027F
DBEA : BCC   $DBF6
DBEC : LDAA  #$FF
DBEE : BRA   $DBF6
DBF0 : ADDA  $027F
DBF3 : BCS   $DBF6
DBF5 : CLRA  
DBF6 : STAA  $0280
DBF9 : LDAA  $0280
DBFC : LDAB  $027D
DBFF : LDX   $027B
DC02 : JSR   $FB63				| D = X + ( 256 * A - X ) * B
DC05 : STD   $027B
DC08 : BRCLR $0061,10000000B,$DC35
DC0C : BRSET $0053,10000000B,$DC3A
DC10 : LDAB  $85AF
DC13 : LDAA  $003F
DC15 : CMPA  $85B0
DC18 : BCS   $DC25
DC1A : LDAB  $85B1
DC1D : CMPA  $85B2
DC20 : BCS   $DC25
DC22 : LDAB  $85B3
DC25 : CMPB  $027B
DC28 : BCS   $DC3A
DC2A : SUBB  $85B4
DC2D : BCC   $DC30
DC2F : CLRB  
DC30 : CMPB  $027B
DC33 : BCS   $DC3D
DC35 : BCLR  $0061,01000000B
DC38 : BRA   $DC3D
DC3A : BSET  $0061,01000000B
DC3D : RTS   
DC3E : LDX   $5100
DC41 : CPX   #$7E51
DC44 : BNE   $DC52
DC46 : JSR   $5426
DC49 : BRCLR $004F,10000000B,$DC52
DC4D : BCLR  $004F,01000000B
DC50 : BRA   $DC5D
DC52 : LDX   $5800
DC55 : CPX   #$7E58
DC58 : BNE   $DC5D
DC5A : JSR   $59BC
DC5D : LDX   #$4000
DC60 : SEI   
DC61 : BCLR  $00,X,00011100B
DC64 : LDAA  #$04
DC66 : ORAA  $00,X
DC68 : STAA  $00,X
DC6A : CLR   $1030
DC6D : LDX   #$1000
DC70 : LDAB  #$0C
DC72 : BRSET $30,X,10000000B,$DC7C
DC76 : DECB  
DC77 : BNE   $DC72
DC79 : BSET  $0059,00000001B
DC7C : LDAA  $1034
DC7F : CLI   
DC80 : STAA  $00DB
DC82 : LDX   #$FCAC
DC85 : BRSET $0055,10000000B,$DC92
DC89 : BRSET $004D,00000001B,$DC92
DC8D : LDX   #$FCBD
DC90 : BRA   $DC98
DC92 : ADDA  #$0A
DC94 : BCC   $DC98
DC96 : LDAA  #$FF
DC98 : JSR   $FC14
DC9B : STAA  $01AB
DC9E : CMPA  #$78
DCA0 : BHI   $DCAB
DCA2 : CMPA  #$6A
DCA4 : BHI   $DCAE
DCA6 : BSET  $004D,00000001B
DCA9 : BRA   $DCAE
DCAB : BCLR  $004D,00000001B
DCAE : BCLR  $0055,10000000B
DCB1 : LDAA  $00DB
DCB3 : BCLR  $0058,01000000B
DCB6 : BCLR  $0068,00000010B
DCB9 : BCLR  $0069,01000000B
DCBC : BRSET $0054,00001000B,$DCEA
DCC0 : LDAB  #$10
DCC2 : CMPA  $83E0
DCC5 : BHI   $DCD1
DCC7 : LDAA  $01AB
DCCA : LDAB  #$20
DCCC : CMPA  $83DC
DCCF : BCS   $DCED
DCD1 : LDX   $0013
DCD3 : CPX   $83DE
DCD6 : BLS   $DCE2
DCD8 : BSET  $0068,00000010B
DCDB : BSET  $0069,01000000B
DCDE : ORAB  $0071
DCE0 : STAB  $0071
DCE2 : LDAA  $83DD
DCE5 : BSET  $0058,01000000B
DCE8 : BRA   $DD02
DCEA : LDAA  $01AB			| A = M[$01AB]  ( Coolent Temp 1.35 N - 40 = degrees F )
DCED : BRCLR $0054,00010000B,$DCFC      | if ( bit 0x10 of M[$0054] is clear ) then goto DCFC   - if (A/C is not requested F-car)
DCF1 : LDAB  $8682			| B = M[$8682] (0x10)
DCF4 : LDX   $01A9			| X = M[$01A9]
DCF7 : JSR   $FB63			| gosub FB63   -  D = X + ( 256 * A - X ) * 0x10
DCFA : BRA   $DD03			| goto DD03
DCFC : STAA  $01AD			| M[$01AD] = A
DCFF : BSET  $0054,00010000B		| set bit 0x10 of M[$0054] (A/C requested F-car)
DD02 : CLRB  				| B = 0
DD03 : STD   $01A9			| M[$01A9] = D
DD06 : CMPA  #$D0			| compare A with 0xD0
DD08 : BLS   $DD0C			| if ( A < 0xD0 ) then goto DD0C
DD0A : LDAA  #$D0			| A = 0xD0
DD0C : STAA  $01AC			| M[$01AC] = A
DD0F : RTS   
DD10 : BCLR  $0058,00011000B
DD13 : LDAB  $0049
DD15 : ANDB  #$F0
DD17 : BNE   $DD23
DD19 : BSET  $0058,00001000B
DD1C : BRCLR $0014,00000001B,$DD23
DD20 : BSET  $0058,00010000B
DD23 : BRSET $0058,00000010B,$DD4A
DD27 : BSET  $0058,00000010B
DD2A : INC   $0010
DD2D : LDAA  $0010
DD2F : CMPA  $83CE
DD32 : BLS   $DD4A
DD34 : CLRA  
DD35 : LDX   #$0003
DD38 : LDAB  #$05
DD3A : STAA  $00,X
DD3C : INX   
DD3D : DECB  
DD3E : BNE   $DD3A
DD40 : STAA  $0010
DD42 : STAA  $005E
DD44 : STAA  $01C2
DD47 : INCB  
DD48 : STD   $0011
DD4A : BRCLR $0068,00010000B,$DD68
DD4E : BSET  $005A,10000000B
DD51 : BRCLR $0050,10000000B,$DD60
DD55 : JSR   $DECD
DD58 : CLRA  
DD59 : STAA  $005E
DD5B : STAA  $01C2
DD5E : BRA   $DDA8
DD60 : BCLR  $0055,00001000B
DD63 : JSR   $DDB5
DD66 : BRA   $DDA8
DD68 : BCLR  $005A,10000000B
DD6B : CLRA  
DD6C : STAA  $005E
DD6E : STAA  $01C2
DD71 : BCLR  $0055,00001000B
DD74 : BRCLR $0050,10000000B,$DD99
DD78 : JSR   $DF23
DD7B : LDY   #$83CD
DD7F : LDX   #$0005
DD82 : BCLR  $0059,00001000B
DD85 : LDAA  $70,X
DD87 : ANDA  $00,Y
DD8A : BEQ   $DD8F
DD8C : BSET  $0059,00001000B
DD8F : DEY   
DD91 : DEX   
DD92 : BNE   $DD85
DD94 : JSR   $DE3A
DD97 : BRA   $DDA8
DD99 : BSET  $0068,01000000B
DD9C : LDAB  #$12
DD9E : CLRA  
DD9F : LDX   #$01DF
DDA2 : STAA  $00,X
DDA4 : INX   
DDA5 : DECB  
DDA6 : BNE   $DDA2
DDA8 : LDAB  #$05
DDAA : CLRA  
DDAB : LDX   #$0071
DDAE : STAA  $00,X
DDB0 : INX   
DDB1 : DECB  
DDB2 : BNE   $DDAE
DDB4 : RTS   
DDB5 : BRCLR $005E,01000000B,$DE18
DDB9 : DEC   $01C4
DDBC : BNE   $DE39
DDBE : LDAB  #$04
DDC0 : BRSET $0068,01000000B,$DE33
DDC4 : LDX   #$01C0
DDC7 : BRCLR $005E,00100000B,$DDCC
DDCB : INX   
DDCC : DEC   $00,X
DDCE : BMI   $DDDA
DDD0 : BSET  $0068,01000000B
DDD3 : LDAB  #$04
DDD5 : STAB  $01C4
DDD8 : BRA   $DE39
DDDA : BRSET $005E,00100000B,$DDE5
DDDE : BSET  $005E,00100000B
DDE1 : LDAB  #$08
DDE3 : BRA   $DE33
DDE5 : BCLR  $005E,00100000B
DDE8 : BRCLR $005E,00000011B,$DDF1
DDEC : DEC   $005E
DDEF : BRA   $DE1B
DDF1 : LDAB  $01C2
DDF4 : CMPB  #$27
DDF6 : BLS   $DE00
DDF8 : CLR   $01C2
DDFB : BCLR  $005E,01000000B
DDFE : BRA   $DE36
DE00 : BITB  #$07
DE02 : BNE   $DE10
DE04 : LSRB  
DE05 : LSRB  
DE06 : LSRB  
DE07 : LDX   #$0003
DE0A : ABX   
DE0B : LDAB  $00,X
DE0D : STAB  $01C3
DE10 : INC   $01C2
DE13 : ASL   $01C3
DE16 : BCC   $DDF1
DE18 : BSET  $005E,00000010B
DE1B : LDAB  $01C2
DE1E : LDX   #$FD61
DE21 : ABX   
DE22 : LDAA  $00,X
DE24 : TAB   
DE25 : ANDB  #$0F
DE27 : LSRA  
DE28 : LSRA  
DE29 : LSRA  
DE2A : LSRA  
DE2B : STD   $01C0
DE2E : LDAB  #$1C
DE30 : BSET  $005E,01000000B
DE33 : STAB  $01C4
DE36 : BCLR  $0068,01000000B
DE39 : RTS   
DE3A : LDY   #$83CD
DE3E : CLRA  
DE3F : LDX   #$0005
DE42 : ORAA  $75,X
DE44 : DEX   
DE45 : BNE   $DE42
DE47 : TSTA  
DE48 : BNE   $DE6B
DE4A : LDX   #$0005
DE4D : LDAA  $70,X
DE4F : ANDA  $00,Y
DE52 : STAA  $75,X
DE54 : DEY   
DE56 : DEX   
DE57 : BNE   $DE4D
DE59 : LDAA  $01F3
DE5C : BEQ   $DE63
DE5E : DEC   $01F3
DE61 : BRA   $DECC
DE63 : BCLR  $0068,01000000B
DE66 : BCLR  $0054,00000100B
DE69 : BRA   $DECC
DE6B : LDX   #$0005
DE6E : CLRA  
DE6F : LDAB  $70,X
DE71 : ANDB  $75,X
DE73 : ANDB  $00,Y
DE76 : STAB  $75,X
DE78 : ORAA  $75,X
DE7A : DEY   
DE7C : DEX   
DE7D : BNE   $DE6F
DE7F : INC   $01F3
DE82 : LDX   #$83CF
DE85 : BRCLR $0068,01000000B,$DE8B
DE89 : INX   
DE8A : INX   
DE8B : TSTA  
DE8C : BEQ   $DE8F
DE8E : INX   
DE8F : LDAB  $00,X
DE91 : CMPB  $01F3
DE94 : BCC   $DECC
DE96 : STAB  $01F3
DE99 : TSTA  
DE9A : BEQ   $DECC
DE9C : LDAA  $83D1
DE9F : STAA  $01F3
DEA2 : CLRB  
DEA3 : LDY   #$01C9
DEA7 : LDX   #$0005
DEAA : LDAA  $02,X
DEAC : ORAA  $75,X
DEAE : STAA  $02,X
DEB0 : LDAA  $00,Y
DEB3 : ORAA  $75,X
DEB5 : STAA  $00,Y
DEB8 : STAB  $75,X
DEBA : DEY   
DEBC : DEX   
DEBD : BNE   $DEAA
DEBF : STAB  $0010
DEC1 : JSR   $FAB5
DEC4 : STD   $0011
DEC6 : BSET  $0068,01000000B
DEC9 : BSET  $0054,00000100B
DECC : RTS   
DECD : BRCLR $0061,10000000B,$DED9
DED1 : BRSET $0055,00001000B,$DEE7
DED5 : BRSET $0058,00001000B,$DF00
DED9 : LDAA  $0055
DEDB : ANDA  #$F7
DEDD : EORA  #$40
DEDF : STAA  $0055
DEE1 : BRCLR $0055,01000000B,$DF13
DEE5 : BRA   $DF1F
DEE7 : BRCLR $0058,00001000B,$DF1F
DEEB : BRSET $0063,00100000B,$DEF4
DEEF : BCLR  $0064,00100000B
DEF2 : BRA   $DF03
DEF4 : BCLR  $0063,00100000B
DEF7 : BRCLR $0064,00100000B,$DF03
DEFB : BCLR  $0064,00100000B
DEFE : BRA   $DF13
DF00 : BSET  $0055,00001000B
DF03 : BRSET $0063,00000010B,$DF0D
DF07 : BRCLR $0064,00000010B,$DF17
DF0B : BRA   $DF1F
DF0D : BRSET $0064,00000010B,$DF1C
DF11 : BRA   $DF1F
DF13 : BRCLR $0068,01000000B,$DF1C
DF17 : BCLR  $0068,01000000B
DF1A : BRA   $DF1F
DF1C : BSET  $0068,01000000B
DF1F : BCLR  $005E,11111111B
DF22 : RTS   
DF23 : BRCLR $0058,00100100B,$DF29
DF27 : BRA   $DF61
DF29 : LDX   $0013
DF2B : CPX   $83D6
DF2E : BCS   $DF61
DF30 : LDAA  $01E2
DF33 : LDAB  $00D9
DF35 : CMPB  $83D9
DF38 : BHI   $DF61
DF3A : CMPB  $83D8
DF3D : BLS   $DF61
DF3F : CMPA  $83DB
DF42 : BHI   $DF64
DF44 : BRCLR $0058,00010000B,$DF6A
DF48 : LDAB  $01A9
DF4B : CMPB  $83D5
DF4E : BLS   $DF6A
DF50 : LDAB  $0164
DF53 : CMPB  $83DA
DF56 : BHI   $DF5E
DF58 : TSTA  
DF59 : BEQ   $DF6A
DF5B : DECA  
DF5C : BRA   $DF6A
DF5E : INCA  
DF5F : BRA   $DF6A
DF61 : CLRA  
DF62 : BRA   $DF6A
DF64 : BSET  $0071,01000000B
DF67 : BSET  $005A,00010000B
DF6A : STAA  $01E2
DF6D : LDAA  $01DF
DF70 : LDAB  $00D4
DF72 : CMPB  $83E4
DF75 : BLS   $DF86
DF77 : CMPA  $83E5
DF7A : BHI   $DF8C
DF7C : LDAB  $00C4
DF7E : CMPB  $83E6
DF81 : BCC   $DF89
DF83 : INCA  
DF84 : BRA   $DF92
DF86 : BCLR  $0058,00000100B
DF89 : CLRA  
DF8A : BRA   $DF92
DF8C : BSET  $0071,00000100B
DF8F : BSET  $0058,00000100B
DF92 : STAA  $01DF
DF95 : BCLR  $0069,00001000B
DF98 : LDAA  $01E6
DF9B : LDAB  $00CF
DF9D : CMPB  $83EF
DFA0 : BHI   $DFCA
DFA2 : CMPA  $83F4
DFA5 : BHI   $DFD4
DFA7 : LDAB  $0154
DFAA : CMPB  $83F3
DFAD : BCC   $DFCA
DFAF : BRCLR $0058,00100100B,$DFB5
DFB3 : BRA   $DFCA
DFB5 : LDAB  $0164
DFB8 : CMPB  $83F2
DFBB : BCC   $DFCA
DFBD : LDAB  $0122
DFC0 : CMPB  $83F0
DFC3 : BLS   $DFCA
DFC5 : CMPB  $83F1
DFC8 : BLS   $DFCD
DFCA : CLRA  
DFCB : BRA   $DFDA
DFCD : BRCLR $0058,00001000B,$DFDA
DFD1 : INCA  
DFD2 : BRA   $DFDA
DFD4 : BSET  $0072,10000000B
DFD7 : BSET  $0069,00001000B
DFDA : STAA  $01E6
DFDD : BRCLR $005A,00001000B,$DFE4
DFE1 : JMP   $E06B
DFE4 : LDAA  $83CA
DFE7 : BITA  #$20
DFE9 : BEQ   $E004
DFEB : LDAA  $01E9
DFEE : CMPA  $83FA
DFF1 : BHI   $E001
DFF3 : BRSET $004B,00000010B,$DFFC
DFF7 : INC   $01E9
DFFA : BRA   $E004
DFFC : CLR   $01E9
DFFF : BRA   $E004
E001 : BSET  $0072,00100000B
E004 : LDAA  $83CA
E007 : BITA  #$10
E009 : BEQ   $E038
E00B : LDAA  $01EA
E00E : CMPA  $83FB
E011 : BHI   $E02D
E013 : BRSET $004B,00000100B,$E028
E017 : LDAA  $801A
E01A : BITA  #$04
E01C : BNE   $E023
E01E : LDAA  $4009
E021 : BEQ   $E028
E023 : INC   $01EA
E026 : BRA   $E038
E028 : CLR   $01EA
E02B : BRA   $E038
E02D : BSET  $0004,00010000B
E030 : CLR   $0010
E033 : JSR   $FAB5
E036 : STD   $0011
E038 : LDAA  $83CA
E03B : BITA  #$08
E03D : BEQ   $E06B
E03F : LDAA  $01EB
E042 : CMPA  $83FC
E045 : BHI   $E060
E047 : BRSET $004B,00001000B,$E05B
E04B : LDAA  $801B
E04E : BITA  #$01
E050 : BNE   $E056
E052 : BRCLR $0057,00010000B,$E05B
E056 : INC   $01EB
E059 : BRA   $E06B
E05B : CLR   $01EB
E05E : BRA   $E06B
E060 : BSET  $0004,00001000B
E063 : CLR   $0010
E066 : JSR   $FAB5
E069 : STD   $0011
E06B : LDX   #$83CA
E06E : BRCLR $00,X,00000100B,$E0E4
E072 : BRSET $005A,00001000B,$E0E4
E076 : BRCLR $0061,00000010B,$E0E4
E07A : BRSET $005B,00100000B,$E0E4
E07E : BRSET $005B,00010000B,$E090
E082 : LDAA  $01EC
E085 : CMPA  $83FE
E088 : BCS   $E0EA
E08A : BSET  $005B,00010000B
E08D : CLR   $01EC
E090 : BRSET $006A,00001000B,$E0E4
E094 : LDAA  $01FF
E097 : CMPA  $83FD
E09A : BCS   $E0E4
E09C : LDAA  $015A
E09F : CMPA  $8400
E0A2 : BLS   $E0E4
E0A4 : CMPA  $8401
E0A7 : BHI   $E0E4
E0A9 : LDAA  $0164
E0AC : CMPA  $8402
E0AF : BLS   $E0E4
E0B1 : CMPA  $8403
E0B4 : BHI   $E0E4
E0B6 : SUBA  $0168
E0B9 : BCC   $E0BC
E0BB : NEGA  
E0BC : CMPA  $8405
E0BF : BHI   $E0E4
E0C1 : LDAA  $00CF
E0C3 : CMPA  $8408
E0C6 : BCS   $E0E4
E0C8 : BRCLR $0061,10000000B,$E0E4
E0CC : BRSET $005A,00000001B,$E0E4
E0D0 : LDAA  $0144
E0D3 : BRSET $005B,01000000B,$E100
E0D7 : STAA  $01F1
E0DA : SUBA  #$80
E0DC : BCC   $E0DF
E0DE : NEGA  
E0DF : CMPA  $8404
E0E2 : BLS   $E0F3
E0E4 : BRCLR $005B,01000000B,$E140
E0E8 : BRA   $E13D
E0EA : BRCLR $0058,00001000B,$E146
E0EE : INC   $01EC
E0F1 : BRA   $E146
E0F3 : LDAA  $01EC
E0F6 : CMPA  $840A
E0F9 : BLS   $E0EE
E0FB : BSET  $005B,01000000B
E0FE : BRA   $E143
E100 : SUBA  $01F1
E103 : BCS   $E10A
E105 : CMPA  $8407
E108 : BCC   $E124
E10A : LDAA  $01EC
E10D : CMPA  $8406
E110 : BCS   $E0EE
E112 : LDAA  $01F2
E115 : INCA  
E116 : CMPA  $840B
E119 : BLS   $E11F
E11B : BSET  $005B,10000000B
E11E : DECA  
E11F : STAA  $01F2
E122 : BRA   $E13D
E124 : LDAA  $01F2
E127 : SUBA  $8409
E12A : BCC   $E11F
E12C : CLRA  
E12D : BCLR  $005B,10000000B
E130 : STAA  $01F2
E133 : LDAA  $8019
E136 : BITA  #$40
E138 : BEQ   $E13D
E13A : BSET  $005B,00100000B
E13D : BCLR  $005B,00010000B
E140 : BCLR  $005B,01000000B
E143 : CLR   $01EC
E146 : BRCLR $005B,10000000B,$E14D
E14A : BSET  $0072,00000100B
E14D : BCLR  $005A,00000001B
E150 : LDAA  $0164
E153 : STAA  $0168
E156 : LDAA  $0058
E158 : BITA  #$24
E15A : BNE   $E18A
E15C : LDAA  $840C
E15F : BRSET $0050,00100000B,$E166
E163 : LDAA  $840D
E166 : CMPA  $00DA
E168 : BCC   $E187
E16A : LDAA  $0260
E16D : CMPA  $8410
E170 : BCC   $E18F
E172 : LDAA  $0164
E175 : CMPA  $840E
E178 : BCC   $E18A
E17A : LDAA  $0123
E17D : CMPA  $840F
E180 : BLS   $E18A
E182 : INC   $0260
E185 : BRA   $E195
E187 : BCLR  $005B,00000001B
E18A : CLR   $0260
E18D : BRA   $E195
E18F : BSET  $0072,00000010B
E192 : BSET  $005B,00000001B
E195 : BRCLR $005C,11100000B,$E19C		| if (knock sensor is OK) then goto E19C
E199 : BSET  $0073,00010000B
E19C : BCLR  $005A,00000010B
E19F : LDAA  $01E0
E1A2 : LDAB  $0179
E1A5 : CMPB  $8432
E1A8 : BHI   $E1BE
E1AA : CMPA  $8433
E1AD : BHI   $E1C1
E1AF : BRCLR $0061,10000000B,$E1BE
E1B3 : BRSET $005A,00000100B,$E1BE
E1B7 : BRCLR $0058,00001000B,$E1C7
E1BB : INCA  
E1BC : BRA   $E1C7
E1BE : CLRA  
E1BF : BRA   $E1C7
E1C1 : BSET  $0073,00001000B
E1C4 : BSET  $005A,00000010B
E1C7 : STAA  $01E0
E1CA : LDAA  $01E1
E1CD : CMPB  $8434
E1D0 : BLS   $E1F9
E1D2 : CMPA  $8435
E1D5 : BHI   $E1FC
E1D7 : BRCLR $005B,00000011B,$E1DD
E1DB : BRA   $E1F9
E1DD : BRCLR $0061,10000000B,$E1F9
E1E1 : BRSET $005A,00000100B,$E1F9
E1E5 : LDAB  $0164
E1E8 : CMPB  $8436
E1EB : BHI   $E1F2
E1ED : CMPB  $8437
E1F0 : BCC   $E1F9
E1F2 : BRCLR $0058,00001000B,$E202
E1F6 : INCA  
E1F7 : BRA   $E202
E1F9 : CLRA  
E1FA : BRA   $E202
E1FC : BSET  $0073,00000100B
E1FF : BSET  $005A,00000010B
E202 : STAA  $01E1
E205 : RTS   
E206 : BCLR  $0058,10000000B
E209 : LDX   #$4000
E20C : SEI   
E20D : BCLR  $00,X,00011100B
E210 : LDAA  #$0C
E212 : ORAA  $00,X
E214 : STAA  $00,X
E216 : CLR   $1030
E219 : LDX   #$1000
E21C : LDAB  #$0C
E21E : BRSET $30,X,10000000B,$E228
E222 : DECB  
E223 : BNE   $E21E
E225 : BSET  $0059,00000001B
E228 : LDAA  $1034
E22B : CLI   
E22C : STAA  $00DD
E22E : LDX   #$FCCE
E231 : JSR   $FC14
E234 : LDAB  $8683
E237 : LDX   $01D7
E23A : BEQ   $E23F
E23C : JSR   $FB63			| D = X + ( 256 * A - X ) * B
E23F : STD   $01D7
E242 : LDAA  $00DD
E244 : BCLR  $0068,00000100B
E247 : LDAB  #$80
E249 : CMPA  $843B
E24C : BHI   $E257
E24E : LDAA  $00DD
E250 : LDAB  #$02
E252 : CMPA  $846A
E255 : BHI   $E268
E257 : LDX   $0013
E259 : CPX   $8439
E25C : BLS   $E268
E25E : BSET  $0068,00000100B
E261 : BSET  $0058,10000000B
E264 : ORAB  $0074
E266 : STAB  $0074
E268 : LDAA  $0049
E26A : CMPA  #$08
E26C : BNE   $E2D3
E26E : LDAB  $0048
E270 : BRCLR $0050,10000000B,$E2D0
E274 : BRCLR $005C,11100000B,$E27A		| if (knock sensor is OK) then goto E27A
E278 : BRA   $E2B6
E27A : LDAA  $0150
E27D : CMPA  $83A1
E280 : BCS   $E2D0
E282 : SUBA  $0152
E285 : BCS   $E28C
E287 : CMPA  $83A2
E28A : BHI   $E2D0
E28C : LDAA  $00FB
E28E : BEQ   $E2AA
E290 : CMPA  $83A3
E293 : BLS   $E2D0
E295 : BRSET $0053,00000001B,$E2A1
E299 : BSET  $0053,00000001B
E29C : BCLR  $0053,00000010B
E29F : BRA   $E2BC
E2A1 : ADDB  $83A4
E2A4 : BCC   $E2BC
E2A6 : LDAB  #$FF
E2A8 : BRA   $E2BC
E2AA : BRSET $0053,00000010B,$E2B6
E2AE : BSET  $0053,00000010B
E2B1 : BCLR  $0053,00000001B
E2B4 : BRA   $E2BC
E2B6 : SUBB  $83A5
E2B9 : BCC   $E2BC
E2BB : CLRB  
E2BC : STAB  $0048
E2BE : LDAA  $01A9
E2C1 : LSRA  
E2C2 : LDX   #$83A6
E2C5 : JSR   $FC14
E2C8 : MUL   
E2C9 : ADCA  #$00
E2CB : STAA  $01D9
E2CE : BRA   $E2D3
E2D0 : BCLR  $0053,00000011B
E2D3 : RTS   
E2D4 : BRCLR $0061,10000000B,$E2DB
E2D8 : BSET  $0056,10000000B
E2DB : LDX   $020D
E2DE : CPX   $8534
E2E1 : BHI   $E2FD
E2E3 : BRSET $0061,01000000B,$E2FD
E2E7 : LDAB  $01A9
E2EA : LDAA  $8019
E2ED : BITA  #$08
E2EF : BEQ   $E2F4
E2F1 : LDAB  $0235
E2F4 : CMPB  $8532
E2F7 : BCS   $E2FD
E2F9 : BRCLR $0054,00000100B,$E300
E2FD : JMP   $E3D3
E300 : BRCLR $0061,10000000B,$E30F
E304 : CLR   $01D1
E307 : LDAA  $8533
E30A : STAA  $01D2
E30D : BRA   $E33C
E30F : BRCLR $0056,10000000B,$E31B
E313 : LDAA  $01D2
E316 : BEQ   $E2FD
E318 : DEC   $01D2
E31B : BRCLR $0050,10000000B,$E33C
E31F : LDAB  $01D1
E322 : LDAA  $01D0
E325 : SUBA  $0154
E328 : BLS   $E332
E32A : CMPA  $8531
E32D : BLS   $E332
E32F : LDAB  $852D
E332 : TSTB  
E333 : BEQ   $E33C
E335 : DECB  
E336 : STAB  $01D1
E339 : JMP   $E3C4
E33C : CLRB  
E33D : LDAA  $0122
E340 : CMPA  $852C
E343 : BLS   $E350
E345 : LDAB  $01CA
E348 : CMPB  $8527
E34B : BHI   $E37B
E34D : INCB  
E34E : BEQ   $E353
E350 : STAB  $01CA
E353 : BRCLR $0060,00100000B,$E365
E357 : LDAB  $01CF
E35A : CMPB  $8526
E35D : BEQ   $E37B
E35F : INCB  
E360 : STAB  $01CF
E363 : BRA   $E3BF
E365 : CLR   $01CF
E368 : LDX   $01CB
E36B : LDAB  $00D8
E36D : CMPB  $8528
E370 : BLS   $E37D
E372 : CPX   $852A
E375 : INX   
E376 : BCS   $E383
E378 : BSET  $0061,00000001B
E37B : BRA   $E3D3
E37D : LDX   $01CB
E380 : BEQ   $E388
E382 : DEX   
E383 : STX   $01CB
E386 : BRA   $E38B
E388 : BCLR  $0061,00000001B
E38B : LDX   #$0000
E38E : BRSET $0061,00000001B,$E3D3
E392 : CMPB  $8529
E395 : BCC   $E3A4
E397 : BRCLR $0061,10000000B,$E3A4
E39B : LDX   $01CD
E39E : CPX   $852A
E3A1 : BHI   $E3D3
E3A3 : INX   
E3A4 : STX   $01CD
E3A7 : LDAA  $0154
E3AA : CMPA  $852E
E3AD : BCS   $E3D3
E3AF : CMPA  $852F
E3B2 : BLS   $E3BB
E3B4 : LDAA  $00CF
E3B6 : CMPA  $8530
E3B9 : BHI   $E3D3
E3BB : BRSET $0056,10000000B,$E3C4
E3BF : BSET  $0057,00000110B
E3C2 : BRA   $E3D6
E3C4 : LDAA  $8019
E3C7 : BITA  #$10
E3C9 : BEQ   $E3D3
E3CB : BCLR  $0057,00000100B
E3CE : BSET  $0057,00000010B
E3D1 : BRA   $E3D6
E3D3 : BCLR  $0057,00000110B
E3D6 : LDAA  $0154
E3D9 : STAA  $01D0
E3DC : BRSET $0049,00010000B,$E3E3
E3E0 : JMP   $E4B5
E3E3 : BRSET $0050,10000000B,$E3EB
E3E7 : BRCLR $0001,00001000B,$E3F9
E3EB : BRSET $005A,00000010B,$E3F3
E3EF : BRCLR $005B,00001000B,$E3FC
E3F3 : CLR   $017D
E3F6 : CLR   $017E
E3F9 : JMP   $E475
E3FC : BRCLR $006A,00001000B,$E40E
E400 : LDX   #$02AF
E403 : BRCLR $00,X,00000001B,$E40E
E407 : BRCLR $01,X,00000001B,$E475
E40B : JMP   $E47A
E40E : BRSET $0002,00000010B,$E42E
E412 : LDD   $0013
E414 : LSRD  
E415 : LDX   #$879A
E418 : LDAA  $01AD
E41B : CMPA  $8799
E41E : BLS   $E427
E420 : INX   
E421 : CMPA  $8798
E424 : BLS   $E427
E426 : INX   
E427 : CMPB  $00,X
E429 : BCS   $E475
E42B : BSET  $0002,00000010B
E42E : LDAA  $873D
E431 : LDAB  $0235
E434 : CMPB  $873E
E437 : BCS   $E43C
E439 : LDAA  $873C
E43C : CMPA  $01A9
E43F : BHI   $E475
E441 : BRCLR $004F,11000000B,$E44B
E445 : BRCLR $006E,01100000B,$E44B
E449 : BRA   $E475
E44B : LDAA  $017E
E44E : CMPA  $874B
E451 : BCC   $E459
E453 : INCA  
E454 : STAA  $017E
E457 : BRA   $E45C
E459 : BCLR  $0063,00000001B
E45C : LDAA  $017D
E45F : CMPA  $874B
E462 : BCC   $E46A
E464 : INCA  
E465 : STAA  $017D
E468 : BRA   $E46D
E46A : BCLR  $0064,00000001B
E46D : BRCLR $0064,00000001B,$E475
E471 : BRSET $0063,00000001B,$E47A
E475 : BCLR  $0061,10000000B
E478 : BRA   $E47D
E47A : BSET  $0061,10000000B
E47D : BRCLR $0061,10000000B,$E4B2
E481 : BSET  $0061,00000010B
E484 : LDAA  $01A9
E487 : CMPA  $87A5
E48A : BLS   $E4B2
E48C : CMPA  $87A6
E48F : BHI   $E4B2
E491 : LDAA  $0235
E494 : CMPA  $87A7
E497 : BLS   $E4A0
E499 : LDAA  $0149
E49C : CMPA  #$0F
E49E : BHI   $E4B2
E4A0 : LDAA  $867B
E4A3 : CLRB  
E4A4 : CPD   $01AE
E4A8 : BNE   $E4B2
E4AA : LDAA  $0154
E4AD : CMPA  $87A8
E4B0 : BCC   $E4B5
E4B2 : BCLR  $0061,00000010B
E4B5 : RTS   
*
*
*
E4B6 : BRCLR $004C,00000001B,$E519
E4BA : LDAA  $01A9
E4BD : CMPA  $8489
E4C0 : BLS   $E519
E4C2 : LDAA  $00C6
E4C4 : CMPA  $8488
E4C7 : BCS   $E519
E4C9 : LDX   #$847C
E4CC : LDAA  $01FF
E4CF : BNE   $E4D4
E4D1 : LDX   #$8482
E4D4 : LDAB  $00CF
E4D6 : CMPB  $00,X
E4D8 : BCS   $E519
E4DA : LDAA  $0123
E4DD : CMPA  $01,X
E4DF : BCS   $E519
E4E1 : LDAB  $0164
E4E4 : CMPB  $02,X
E4E6 : BCS   $E519
E4E8 : BRSET $0060,00100000B,$E519
E4EC : CMPA  $03,X
E4EE : BCC   $E519
E4F0 : LDAB  $015A
E4F3 : CMPB  $04,X
E4F5 : BLS   $E519
E4F7 : CMPB  $05,X
E4F9 : BCC   $E519
E4FB : LDAA  #$FF
E4FD : BRCLR $0066,00000001B,$E507		| branch if torque convertor is not locked
E501 : LDAB  $8567
E504 : MUL   
E505 : ADCA  #$00
E507 : BRCLR $004F,10000000B,$E510
E50B : JSR   $5109
E50E : BRA   $E51A
E510 : BRCLR $004F,01000000B,$E51A
E514 : JSR   $5809
E517 : BRA   $E51A
E519 : CLRA  
E51A : STAA  $01FF
E51D : BEQ   $E52E
E51F : LDAA  $0200
E522 : ADDA  $848A
E525 : BCC   $E529
E527 : LDAA  #$FF
E529 : STAA  $0200
E52C : BRA   $E531
E52E : CLR   $0200
E531 : LDD   $009A
E533 : ADDD  $00A6
E535 : LSRD  
E536 : PSHB  
E537 : PSHA  
E538 : TSX   
E539 : LDAA  $0125
E53C : JSR   $FB83			| Routine returns D = AIN (byte)  * M[$X] (word)
E53F : STD   $021D
E542 : PULX  
E543 : CPD   $843D
E547 : BLS   $E570
E549 : BRCLR $0061,10000000B,$E570
E54D : BRCLR $0060,00100000B,$E570
E551 : BRCLR $0063,00000010B,$E559
E555 : BRSET $0064,00000010B,$E570
E559 : LDAA  $01ED
E55C : INCA  
E55D : BNE   $E560
E55F : DECA  
E560 : STAA  $01ED
E563 : CMPA  $843C
E566 : BLS   $E573
E568 : BSET  $0074,00010000B
E56B : BSET  $0059,00000100B
E56E : BRA   $E576
E570 : CLR   $01ED
E573 : BCLR  $0059,00000100B
E576 : BRSET $004F,00010000B,$E582
E57A : BRCLR $0050,10000000B,$E582
E57E : BRCLR $005B,00000011B,$E585
E582 : JMP   $E641
E585 : LDAA  $0164
E588 : SUBA  $0167
E58B : BCS   $E5B0
E58D : CMPA  $895A
E590 : BHI   $E5B0
E592 : LDAA  $0164
E595 : CMPA  $8959
E598 : BCS   $E5B0
E59A : LDAA  $0150
E59D : SUBA  $0152
E5A0 : BCC   $E5A3
E5A2 : NEGA  
E5A3 : CMPA  $895B
E5A6 : BCC   $E5B0
E5A8 : LDAA  $0123
E5AB : CMPA  $895C
E5AE : BLS   $E5B3
E5B0 : JMP   $E641
E5B3 : LDAB  #$55
E5B5 : MUL   
E5B6 : ADCA  #$00
E5B8 : CMPA  #$30
E5BA : BLS   $E5BE
E5BC : LDAA  #$30
E5BE : LDAB  $0164
E5C1 : LSRB  
E5C2 : LDX   #$895E
E5C5 : JSR   $FB97
E5C8 : CMPA  $895D
E5CB : BCC   $E641
E5CD : PSHA  			Push A
E5CE : LDAA  $0158		A = M[$0158]
E5D1 : LDAB  #$50		B = 0x58
E5D3 : LDX   #$8973		X = 0x8973
E5D6 : JSR   $FC10		gosub FC10
E5D9 : PULB  			Pull B
E5DA : MUL   			D = A * B
E5DB : ASLD  			D = D * 2
E5DC : BCC   $E5E0
E5DE : LDAA  #$FF
E5E0 : ADDA  $00DA
E5E2 : BCC   $E5E6
E5E4 : LDAA  #$FF
E5E6 : STAA  $003F
E5E8 : TAB   
E5E9 : CLRA  
E5EA : LDX   #$02B6
E5ED : FDIV  
E5EE : PSHX  
E5EF : PULA  
E5F0 : PULB  
E5F1 : ADDD  #$0A57
E5F4 : STD   $0156
E5F7 : LDAA  $003F
E5F9 : SUBA  #$0D
E5FB : LDAB  #$97
E5FD : MUL   
E5FE : ADCA  #$00
E600 : CMPA  #$8F
E602 : BLS   $E606
E604 : LDAA  #$8F
E606 : STAA  $0158
E609 : LDAA  $0158			|A = M[$0158]
E60C : LDAB  #$50			|B = 0x50
E60E : LDX   #$8300			|X = 0x8300
E611 : JSR   $FC10			|gosub FC10
E614 : STAA  $0160			|M[$0160] = A
E617 : LDAA  $0158			|A = M[$0158]
E61A : LDAB  #$50			|B = 0x50
E61C : LDX   #$830F			|X = 0x830F
E61F : JSR   $FC10			|gosub FC10
E622 : STAA  $0161			|M[$0161] = A
E625 : LDAA  $0158			|A = M[$0158]
E628 : LDAB  #$50			|B = 0x50
E62A : LDX   #$8D70			|X = 0x8D70
E62D : JSR   $FC10			|gosub FC10
E630 : STAA  $0162			|M[$0162] = 8D70
E633 : LDAA  $0158			|A = M[$0158]
E636 : LDAB  #$50			|B = 0x50
E638 : LDX   #$884C			|X = 0x884C
E63B : JSR   $FC10			|gosub FC10
E63E : STAA  $0163			|M[$0163] = A
E641 : LDAA  $0164			
E644 : STAA  $0167
E647 : RTS   

*
* Subroutine - messes with knock sensor stuff
* 
E648 : BRSET $0049,00010000B,$E665
E64C : LDAA  $0123
E64F : LDX   #$836E
E652 : JSR   $FC14
E655 : LDAB  $00FB
E657 : MUL   
E658 : ADCA  #$00
E65A : NEGA  
E65B : BNE   $E65E
E65D : DECA  
E65E : ADDA  $00FB
E660 : BCS   $E663
E662 : CLRA  
E663 : STAA  $00FB
E665 : LDAA  $83CB
E668 : BITA  #$10
E66A : BEQ   $E6D1
E66C : BRSET $0054,00001000B,$E6D1
E670 : LDX   #$4000
E673 : SEI   
E674 : BCLR  $00,X,00011100B
E677 : LDAA  #$10
E679 : ORAA  $00,X
E67B : STAA  $00,X
E67D : CLR   $1030			Clear $1030				| M[$1030] = 0x00
E680 : LDX   #$1000			Load X with 0x1000			| X = 0x1000
E683 : LDAB  #$0C			Load B with 0x0c			| B = 0x0C
E685 : BRSET $30,X,10000000B,$E68F	if bit 0x10 of $1030 goto E68F		| Wait until convertion is done
E689 : DECB  				Decrement B				|
E68A : BNE   $E685			if B != 0 goto E685			|
E68C : BSET  $0059,00000001B		Set 0x01 of $0059  			| Error Flag - A/D conversion error
E68F : LDAA  $1034			Load A with $1034			| A = M[$1034]
E692 : CLI   				Clear Interrupts			| Clear interrupts
E693 : STAA  $00DF			Store A to $00DF			| M[$00DF] = A
E695 : BRSET $005C,00010000B,$E6CB      if 0x10 of $005C is set goto E6CB
E699 : CMPA  $8430			Compare A with $8430			|
E69C : BLS   $E6A6			branch less than or equal E6A6		| if (A <= M[$8430]) then goto E6A6
E69E : BSET  $005C,01000000B		Set bit 0x40 of $005C
E6A1 : BCLR  $005C,10100000B		clear bit 0xA0 of $005C
E6A4 : BRA   $E6BE			branch always E6BE			| goto E6BE
E6A6 : CMPA  $842F			Compare M[$842F]			| 
E6A9 : BLS   $E6B3			Branch less than or equal E6B3		| if ( A <= M[$842F]) then goto E6B3
E6AB : BSET  $005C,00100000B		set bit 0x20 of $005C
E6AE : BCLR  $005C,11000000B		clear bit 0xC0 of $005C
E6B1 : BRA   $E6BE			branch always to E6BE			| goto E6BE
E6B3 : CMPA  $8431			Compare A with $8431			|
E6B6 : BCC   $E6CB			Branch if carry is clear to E6CB	| if (A >= M[$8431]) then goto E6CB
E6B8 : BSET  $005C,10000000B		Set 0x80 of $005C			
E6BB : BCLR  $005C,01100000B		Clear 0x60 of $005C
E6BE : LDAA  $01DE			Load A with $01DE			| A = M[$01DE]
E6C1 : CMPA  $842E			Compare A with $842E			| 
E6C4 : BHI   $E6D1			Branch if higher than to E6D1		| if ( A > M[$842E]) then goto E6D1
E6C6 : INC   $01DE			Increment $01DE				| M[$01DE] ++
E6C9 : BRA   $E6CE			Branch Always to E6CE			| goto E6CE
E6CB : CLR   $01DE			Clear $01DE				| M[$01DE] = 0
E6CE : BCLR  $005C,11100000B		clear bits 0xE0 of 0x005C		
E6D1 : LDAA  $00D5			Load A with $00D5			| A = M[$00D5]
E6D3 : COMA  				Compliment A
E6D4 : STAA  $0234			Store A $0234				| M[$0234] = A
E6D7 : LDAA  $0049			Load A with $0049			| A = M[$0049]
E6D9 : CMPA  #$0B			Compare A with 0x0B
E6DB : BNE   $E71E			Branch if not equal to E71E		| if (A != 0x0B) then goto E71E
E6DD : LDAA  $0234			Load A with $0234			| A = M[$0234]
E6E0 : CMPA  $83E9			Compare A with $83E9			|
E6E3 : BCC   $E713			Branch if carry is clear to E713	| if ( A >= M[$83E9] then goto E713
E6E5 : LDAA  $01E7			Load A with $01E7			| A = M[$01E7]
E6E8 : CMPA  $83EA			Compare A with $83EA			|
E6EB : BHI   $E71B			branch if higher to E71B		| if ( A > M[$83EA] then goto E71B
E6ED : BRSET $0058,01000000B,$E6FB	if bit 0x40 of $0058 set goto E6FB	
E6F1 : LDAA  $01A9			Load A with $01A9			| A = M[$01A9]
E6F4 : CMPA  $83EB			compare a with $83EB			|
E6F7 : BHI   $E702			Branch if high to E702			| if ( A > M[$83EB]) then goto E702
E6F9 : BRA   $E713			Branch always E713			| goto E713
E6FB : LDX   $0013			Load X with $0013			| X = M[$0013]
E6FD : CPX   $83EC			compare X with 83EC			|
E700 : BLS   $E713			branch if less than or equal to E713	| if (X <= M[$83EC]) then goto E713
E702 : LDAA  $0164			Load A with $0164			| A = M[$0164]
E705 : CMPA  $88D7			Compare A with 88D7			|
E708 : BHI   $E713			branch if high E713			| if (A > M[$88D7]) then goto E713
E70A : LDAA  $00CF			Load A with $00CF			| A = M[$00CF]
E70C : BNE   $E713			Branch if not equal to E713		| if (A != 0) then goto E713
E70E : INC   $01E7			increment $01E7				| M[$01E7]++
E711 : BRA   $E71E			Branch Always E71E			| goto E71E
E713 : CLR   $01E7			Clear 01E7				| M[$01E7] = 0
E716 : BCLR  $0060,00010000B		Clear bit 0x10 of $0060	
E719 : BRA   $E71E			Branch Always E71E			| goto E71E
E71B : BSET  $0060,00010000B		Set Bit 0x10 of $0060
E71E : LDAA  $0234			Load A with $0234			| A = M[$0234]
E721 : CMPA  $83F5			Compare A with $83F5			|
E724 : BCS   $E748			Branch if carry set to E748		| if (A < M[$83F5] (value is 0xF3)) then goto E748
E726 : LDAA  $01E8			Load A with $01E8			| A = M[$01E8]
E729 : CMPA  $83F6			Compare A with $83F6			|
E72C : BHI   $E750			Branch if higher E750			| if (A > M[$83F6] (value is 0x78)) then goto E750
E72E : LDAA  $00CF			Load A with $00CF			| A = M[$00CF]
E730 : BNE   $E73E			Branch if not equal to E73E		| if (A != 0) then goto E73E
E732 : LDX   $0013			Load X with $0013			| X = M[$0013]
E734 : CPX   $83F7			Compare X with $83F7			|
E737 : BLS   $E753			Branch if less than or equal to E753	| if ( X <= M[$83F7] (value is 0x003C)) then goto E753
E739 : INC   $01E8
E73C : BRA   $E753
E73E : CMPA  $83F9
E741 : BLS   $E748
E743 : INC   $01E8
E746 : BRA   $E753
E748 : BCLR  $0059,00000010B
E74B : CLR   $01E8
E74E : BRA   $E753
E750 : BSET  $0059,00000010B
E753 : BRSET $0060,00010000B,$E760
E757 : BRCLR $0059,00000010B,$E769
E75B : BSET  $0072,01000000B
E75E : BRA   $E763
E760 : BSET  $0071,00000001B
E763 : LDAA  $83EE
E766 : STAA  $0234
E769 : LDAA  $0234
E76C : LDX   #$FCDF
E76F : JSR   $FC14
E772 : STAA  $0236
E775 : LDAB  $801B
E778 : BITB  #$10
E77A : BNE   $E782
E77C : STAA  $0235
E77F : JMP   $E864
E782 : BRSET $0060,00010000B,$E78A
E786 : BRCLR $0059,00000010B,$E7A7
E78A : TAB   
E78B : CLRA  
E78C : ASLD  
E78D : ASLD  
E78E : ASLD  
E78F : STD   $023C
E792 : STD   $023E
E795 : STD   $0240
E798 : STD   $0242
E79B : STD   $0244
E79E : STD   $0246
E7A1 : STD   $0248
E7A4 : STD   $024A
E7A7 : LDX   $023A
E7AA : LDAB  $0236
E7AD : ABX   
E7AE : STX   $023A
E7B1 : LDAA  $0239
E7B4 : CMPA  #$07
E7B6 : BCC   $E7BE
E7B8 : INC   $0239
E7BB : JMP   $E864
E7BE : CLR   $0239
E7C1 : BCLR  $0053,00100000B
E7C4 : XGDX  
E7C5 : ASLD  
E7C6 : ASLD  
E7C7 : ADDD  $023C
E7CA : ADDD  $023C
E7CD : ADDD  $023C
E7D0 : ADDD  $023E
E7D3 : ADDD  $023E
E7D6 : ADDD  $0240
E7D9 : SUBD  $0244
E7DC : SUBD  $0246
E7DF : SUBD  $0246
E7E2 : SUBD  $0248
E7E5 : SUBD  $0248
E7E8 : SUBD  $0248
E7EB : SUBD  $024A
E7EE : SUBD  $024A
E7F1 : SUBD  $024A
E7F4 : SUBD  $024A
E7F7 : BPL   $E800
E7F9 : NEGA  
E7FA : NEGB  
E7FB : SBCA  #$00
E7FD : BSET  $0053,00100000B
E800 : PSHB  
E801 : PSHA  
E802 : TSX   
E803 : LDAA  $8020
E806 : JSR   $FB83			| Routine returns D = AIN (byte)  * M[$X] (word)
E809 : STD   $00,X
E80B : LDD   $0248
E80E : STD   $024A
E811 : LDD   $0246
E814 : STD   $0248
E817 : LDD   $0244
E81A : STD   $0246
E81D : LDD   $0242
E820 : STD   $0244
E823 : LDD   $0240
E826 : STD   $0242
E829 : LDD   $023E
E82C : STD   $0240
E82F : LDD   $023C
E832 : STD   $023E
E835 : LDD   $023A
E838 : STD   $023C
E83B : BRSET $0053,00100000B,$E848
E83F : ADDD  $00,X
E841 : BCC   $E84F
E843 : LDD   #$FFFF
E846 : BRA   $E84F
E848 : SUBD  $00,X
E84A : BCC   $E84F
E84C : LDD   #$0000
E84F : PULX  
E850 : LSRD  
E851 : LSRD  
E852 : LSRD  
E853 : ADCB  #$00
E855 : ADCA  #$00
E857 : BEQ   $E85B
E859 : LDAB  #$FF
E85B : STAB  $0235
E85E : LDD   #$0000
E861 : STD   $023A
E864 : LDAA  $0235
E867 : LDX   #$801A
E86A : BRCLR $00,X,00000001B,$E88F
E86E : LDD   $00C4
E870 : ASLD  
E871 : BCC   $E875
E873 : LDAA  #$FF
E875 : LDX   #$8D56
E878 : JSR   $FC14
E87B : LDAB  $01A9
E87E : SUBB  $0235
E881 : BCC   $E884
E883 : CLRB  
E884 : MUL   
E885 : ASLD  
E886 : BCS   $E88D
E888 : ADDA  $0235
E88B : BCC   $E88F
E88D : LDAA  #$FF
E88F : PSHA  
E890 : LDAA  $00C4
E892 : CMPA  #$80
E894 : BLS   $E898
E896 : LDAA  #$80
E898 : LDX   #$8D67
E89B : JSR   $FC14
E89E : TAB   
E89F : PULA  
E8A0 : LDX   $00C6
E8A2 : BEQ   $E8A9
E8A4 : JSR   $FB63			| D = X + ( 256 * A - X ) * B
E8A7 : BRA   $E8AA
E8A9 : CLRB  
E8AA : STD   $00C6
E8AC : LDX   #$8D45
E8AF : JSR   $FC14
E8B2 : CLRB  
E8B3 : LSRD  
E8B4 : ADDD  #$7480
E8B7 : STD   $0237
E8BA : RTS

*
*
*   
E8BB : LDAA  $83CD
E8BE : BITA  #$02
E8C0 : BEQ   $E8F4
E8C2 : BRCLR $0057,00010000B,$E8D2
E8C6 : LDAA  $00E1
E8C8 : CMPA  $8474
E8CB : BHI   $E8D7
E8CD : CMPA  $8473
E8D0 : BCS   $E8D7
E8D2 : CLR   $01F9
E8D5 : BRA   $E8F4
E8D7 : LDAA  $01F9
E8DA : CMPA  $8475
E8DD : BCC   $E8E4
E8DF : INC   $01F9
E8E2 : BRA   $E8F4
E8E4 : BSET  $0007,00000010B
E8E7 : CLR   $0010
E8EA : JSR   $FAB5
E8ED : STD   $0011
E8EF : LDAA  $8476
E8F2 : BRA   $E907
E8F4 : LDAB  $00E1
E8F6 : SUBB  #$38
E8F8 : BCC   $E8FB
E8FA : CLRB  
E8FB : CMPB  #$6C
E8FD : BLS   $E901
E8FF : LDAB  #$6C
E901 : LDX   #$FCF0
E904 : ABX   
E905 : LDAA  $00,X
E907 : STAA  $022F
E90A : BRCLR $007B,01000000B,$E918
E90E : LDAB  $02AE
E911 : BITB  #$40
E913 : BEQ   $E982
E915 : JMP   $EA41
E918 : BRSET $0056,00000001B,$E953
E91C : LDAA  $016F
E91F : CMPA  $84DA
E922 : BCC   $E944
E924 : LDAA  $00D7
E926 : CMPA  $84D9
E929 : BCS   $E944
E92B : LDAA  $01A9
E92E : CMPA  $84DB
E931 : BHI   $E944
E933 : BRSET $0006,00000100B,$E944
E937 : BRCLR $0007,00111110B,$E93D
E93B : BRA   $E944
E93D : LDAA  $00DC
E93F : CMPA  $84DC
E942 : BCC   $E949
E944 : BSET  $0056,00000001B
E947 : BRA   $E953
E949 : LDAA  $021A
E94C : CMPA  #$A0
E94E : BCC   $E953
E950 : JMP   $EA84
E953 : BRCLR $0050,10000000B,$E9D5
E957 : BRCLR $0057,00010000B,$E9D5
E95B : BRSET $0070,00000100B,$E9D5
E95F : BRCLR $0070,00001000B,$E9D5
E963 : LDAB  $0235
E966 : SUBB  #$50
E968 : BCC   $E96B
E96A : CLRB  
E96B : CMPB  #$90
E96D : BLS   $E971
E96F : LDAB  #$90
E971 : LSRB  
E972 : LSRB  
E973 : LSRB  
E974 : LSRB  
E975 : LDX   #$84F6
E978 : ABX   
E979 : LDAB  $00,X
E97B : CLRA  
E97C : CPD   $020D
E980 : BLS   $E984
E982 : BRA   $E9D5
E984 : LDAA  $84F3
E987 : BRSET $0050,00100000B,$E9A6
E98B : BRCLR $0051,10000000B,$E9A3
E98F : LDX   $0230
E992 : CPX   $84F4
E995 : BCC   $E9A0
E997 : INX   
E998 : STX   $0230
E99B : LDAA  $84F1
E99E : BRA   $E9A6
E9A0 : BCLR  $0051,10000000B
E9A3 : LDAA  $84F2
E9A6 : CMPA  $022F
E9A9 : BHI   $E9D5
E9AB : LDX   #$84EA
E9AE : BRCLR $0050,00100000B,$E9B5
E9B2 : LDX   #$84ED
E9B5 : LDAA  $00D7
E9B7 : CMPA  $00,X
E9B9 : BHI   $E9D5
E9BB : CMPA  $01,X
E9BD : BCS   $E9D5
E9BF : BRCLR $0059,01010000B,$E9C5
E9C3 : BRA   $E9D5
E9C5 : BRCLR $005D,00011000B,$E9CB
E9C9 : BRA   $E9D5
E9CB : BRSET $0051,00100000B,$E9D5
E9CF : LDAA  $00DC
E9D1 : CMPA  $02,X
E9D3 : BCC   $E9D8
E9D5 : JMP   $EA8F
E9D8 : LDAA  $84DD
E9DB : BRCLR $0050,00100000B,$E9E1
E9DF : SUBA  #$10
E9E1 : CMPA  $0169
E9E4 : BCS   $EA29
E9E6 : LDAA  $84DE
E9E9 : BRCLR $0050,00100000B,$E9EF
E9ED : SUBA  #$07
E9EF : CMPA  $01A9
E9F2 : BLS   $EA29
E9F4 : LDAA  $84DF
E9F7 : BRCLR $0050,00100000B,$E9FE
E9FB : SUBA  $84E0
E9FE : CMPA  $01D7
EA01 : BLS   $EA29
EA03 : LDAA  $00CF
EA05 : CMPA  $84E1
EA08 : BCS   $EA30
EA0A : BRSET $0052,00001000B,$EA19
EA0E : BSET  $0052,00001000B
EA11 : LDD   $0013
EA13 : ADDD  $84E2
EA16 : STD   $0228
EA19 : LDX   $0013
EA1B : CPX   $0228
EA1E : BCS   $EA2B
EA20 : BSET  $0052,00010000B
EA23 : LDAA  $84E4
EA26 : STAA  $022A
EA29 : BRA   $EA8F
EA2B : BCLR  $0052,00010000B
EA2E : BRA   $EA41
EA30 : BRCLR $0052,00010000B,$EA3E
EA34 : LDAA  $022A
EA37 : BEQ   $EA3E
EA39 : DEC   $022A
EA3C : BRA   $EA8F
EA3E : BCLR  $0052,00001000B
EA41 : LDAA  $0123
EA44 : BRCLR $0050,00100000B,$EA69
EA48 : CMPA  $84E5
EA4B : BCC   $EA8F
EA4D : LDAB  $01A0
EA50 : CMPB  #$60
EA52 : BLS   $EA56
EA54 : LDAB  #$60
EA56 : LSRB  
EA57 : LSRB  
EA58 : LSRB  
EA59 : LDX   #$8508
EA5C : ABX   
EA5D : LDAA  $00,X
EA5F : CMPA  $022B
EA62 : BLS   $EA84
EA64 : INC   $022B
EA67 : BRA   $EAB9
EA69 : CMPA  $84E6
EA6C : BCC   $EA73
EA6E : CLR   $022C
EA71 : BRA   $EA84
EA73 : LDAA  $022C
EA76 : INCA  
EA77 : BEQ   $EA7C
EA79 : STAA  $022C
EA7C : LDAA  $022C
EA7F : CMPA  $84E7
EA82 : BHI   $EA8F
EA84 : CLR   $022B
EA87 : BCLR  $0052,00010000B
EA8A : BCLR  $0050,00100000B
EA8D : BRA   $EAB9
EA8F : BRSET $0050,00100000B,$EA9E
EA93 : LDAA  $022B
EA96 : CMPA  $8507
EA99 : BCS   $EAA3
EA9B : BSET  $0050,00100000B
EA9E : CLR   $022B
EAA1 : BRA   $EAA6
EAA3 : INC   $022B
EAA6 : BCLR  $006F,00000001B
EAA9 : BRCLR $006F,10000000B,$EAB0
EAAD : JMP   $EB3B
EAB0 : BSET  $006F,00100000B
EAB3 : CLR   $0114
EAB6 : JMP   $EB3B
EAB9 : BCLR  $006F,00100000B
EABC : BSET  $006F,01000000B
EABF : BRCLR $006F,10000001B,$EADB
EAC3 : LDAA  $0114
EAC6 : CMPA  $8505
EAC9 : BCS   $EADB
EACB : LDAA  $006F
EACD : EORA  #$01
EACF : STAA  $006F
EAD1 : BPL   $EADD
EAD3 : LDAA  $003B
EAD5 : STAA  $0115
EAD8 : CLR   $0114
EADB : BRA   $EB36
EADD : LDAA  $003B
EADF : SUBA  $0115
EAE2 : BCS   $EAE9
EAE4 : SUBA  $022D
EAE7 : BCC   $EAEA
EAE9 : CLRA  
EAEA : BRCLR $0070,10000000B,$EAF3
EAEE : LDAB  $8506
EAF1 : MUL   
EAF2 : ASLD  
EAF3 : LDAB  $8501
EAF6 : CBA   
EAF7 : BLS   $EAFA
EAF9 : TBA   
EAFA : LDAB  $8502
EAFD : CBA   
EAFE : BHI   $EB01
EB00 : TBA   
EB01 : TAB   
EB02 : SUBA  $003D
EB04 : BCC   $EB13
EB06 : CMPA  $8504
EB09 : BGE   $EB1E
EB0B : LDAB  $8504
EB0E : TBA   
EB0F : ADDB  $003D
EB11 : BRA   $EB1E
EB13 : CMPA  $8503
EB16 : BLS   $EB1E
EB18 : LDAB  $8503
EB1B : TBA   
EB1C : ADDB  $003D
EB1E : STAB  $003D
EB20 : BRCLR $0070,10000000B,$EB30
EB24 : LDAB  $88EF
EB27 : TSTA  
EB28 : BPL   $EB2F
EB2A : NEGA  
EB2B : MUL   
EB2C : NEGA  
EB2D : BRA   $EB30
EB2F : MUL   
EB30 : ADDA  $0113
EB33 : STAA  $0113
EB36 : BCLR  $006F,10000000B
EB39 : BRA   $EB3E
EB3B : BSET  $006F,10000000B
EB3E : BRSET $0049,00010000B,$EB45
EB42 : JMP   $ECB3
EB45 : BRCLR $0059,00001000B,$EB4C
EB49 : JMP   $EBFF
EB4C : BRCLR $005C,00010000B,$EB53
EB50 : JMP   $EBFF
EB53 : LDAA  $0123
EB56 : CMPA  $84C9
EB59 : BCS   $EB70
EB5B : LDAA  $01D6
EB5E : CMPA  $84CA
EB61 : BCC   $EB68
EB63 : INC   $01D6
EB66 : BRA   $EB73
EB68 : BSET  $0065,01000000B			| Set high rpm fan enable bit
EB6B : LDAA  $84C7
EB6E : BRA   $EB79
EB70 : CLR   $01D6
EB73 : BCLR  $0065,01000000B			| clear high rpm fan enable
EB76 : LDAA  $84C6
EB79 : BRCLR $0065,00100000B,$EB80		
EB7D : SUBA  $84C8
EB80 : CMPA  $01D7
EB83 : BHI   $EB8A
EB85 : BSET  $0065,00100000B
EB88 : BRA   $EBFF
EB8A : BCLR  $0065,00100000B
EB8D : LDD   $020D
EB90 : CPD   $84D7
EB94 : BCS   $EBA9
EB96 : BRCLR $004C,00100000B,$EBA9
EB9A : LDAA  $00CF
EB9C : CMPA  $84CB
EB9F : BCC   $EBA9
EBA1 : LDAA  $84C3
EBA4 : STAA  $01D3
EBA7 : BRA   $EBFF
EBA9 : LDX   #$84CF			| X = 0x84CF
EBAC : BRCLR $0065,00000001B,$EBB3	| if (fan #1 is not enabled) then goto EBB3		
EBB0 : LDX   #$84D1			| X = 0x84D1
EBB3 : LDAB  $00CF			| B = M[$00CF]  (Vehicle Speed in mph)
EBB5 : LDAA  $00D7			| A = M[$00D7]  (AC pressure transducer)
EBB7 : CMPA  $00,X			| compare A with M[$84D1] (0x79) (121 dec)
EBB9 : BLS   $EBBF			| if ( AC Pressure <= M[$84D1] (121) ) then goto EBBF
EBBB : CMPB  $01,X			| compare B with M[$84D2] (0xFF) (255)
EBBD : BCS   $EBFF			| if ( Vehicle Speed < M[$84D2] (255)  ) then goto EBBF
EBBF : LDAA  $84BA			| A = M[$84BA]
EBC2 : BRCLR $0050,00100000B,$EBCE	| if ( AC Clutch is on ) then goto EBCE
EBC6 : CMPB  $84BE			| compare B with M[$84BE] (value 0x00)
EBC9 : BCS   $EBCE			| if ( Vehicle Speed < M[$84BE] (0) ) then goto EBCE
EBCB : LDAA  $84BB			| A = M[$84BB]  (0xA7, or 167)   temp for fan #1 on low speed.
EBCE : BRSET $0065,00000001B,$EBE1	| if fan #1 is enabled the goto EBE1
EBD2 : LDX   $020D			| X = M[$020D]
EBD5 : CPX   $84C1			| compare X with M[$84C1] (0)
EBD8 : BCS   $EC02			| if ( X < M[$84C1] (0) ) then goto EC02
EBDA : CMPA  $01A9			| compare a with M[$01A9] (lag filtered coolent temp)
EBDD : BCS   $EBFF			| if ( A (temp limit) < M[$01A9] (lag filtered coolent temp)
EBDF : BRA   $EC02
EBE1 : LDAB  $84BF
EBE4 : CMPA  $84BA
EBE7 : BEQ   $EBEC
EBE9 : LDAB  $84C0
EBEC : SBA   
EBED : CMPA  $01A9
EBF0 : BLS   $EC02
EBF2 : LDAA  $01D3
EBF5 : BNE   $EC02
EBF7 : BCLR  $0065,00100101B		| clear fan #1 enable, fan #1 requested, fan #1 enabled by high oil temp
EBFA : CLR   $01D5
EBFD : BRA   $EC02
EBFF : BSET  $0065,00000100B		| set fan #1 requested.
EC02 : BRSET $0065,00000001B,$EC0F	| if fan #1 is requested then goto EC0F
EC06 : LDAA  $84C3
EC09 : STAA  $01D3
EC0C : JMP   $EC90
EC0F : LDAA  $0049			| A = M[$0049]
EC11 : CMPA  #$1C			| compare A with 0x1C  (18 ?)
EC13 : BNE   $EC1E			| if ( M[$0049] != 0x1C ) then goto EC1E
EC15 : LDAA  $01D3
EC18 : BEQ   $EC1E
EC1A : DECA  
EC1B : STAA  $01D3
EC1E : LDAA  $01D5
EC21 : CMPA  $84C4
EC24 : BCC   $EC2C
EC26 : INC   $01D5
EC29 : JMP   $EC90
EC2C : BRSET $0059,00001000B,$EC95
EC30 : BRSET $005C,00010000B,$EC95
EC34 : LDX   #$84D3
EC37 : BRCLR $0065,00001000B,$EC3E		| if fan #2 is not enabled then goto EC3E
EC3B : LDX   #$84D5				| X = 0x84D5
EC3E : LDAB  $00CF				| B = M[$00CF]   - Vehicle Speed
EC40 : LDAA  $00D7				| A = M[$00D7]   - A/C pressure transducer
EC42 : CMPA  $00,X				| compare A with M[$84D5] value is 0x79
EC44 : BLS   $EC4A				| if (A <= M[$84D5]) then goto EC4A
EC46 : CMPB  $01,X				| compare B with M[$84D6] value is 0x24 == 36 mph?
EC48 : BLS   $EC95				| if (B <= M[$84d6]) then goto EC95
EC4A : LDAA  $84CD
EC4D : BRSET $0065,01000000B,$EC54
EC51 : LDAA  $84CC
EC54 : BRCLR $0065,00001000B,$EC5B
EC58 : SUBA  $84C8
EC5B : CMPA  $01D7
EC5E : BLS   $EC95
EC60 : LDAA  $84BC
EC63 : BRCLR $0050,00100000B,$EC6F
EC67 : CMPB  $84BE
EC6A : BCS   $EC6F
EC6C : LDAA  $84BD
EC6F : BRSET $0065,00001000B,$EC7A
EC73 : CMPA  $01A9
EC76 : BCS   $EC95
EC78 : BRA   $EC98
EC7A : LDAB  $84BF
EC7D : CMPA  $84BC
EC80 : BEQ   $EC85
EC82 : LDAB  $84C0
EC85 : SBA   
EC86 : CMPA  $01A9
EC89 : BLS   $EC98
EC8B : LDAA  $01D4
EC8E : BNE   $EC98
EC90 : BCLR  $0065,00011000B
EC93 : BRA   $EC98
EC95 : BSET  $0065,00010000B			| request fan #2.
EC98 : BRSET $0065,00001000B,$ECA4		| if fan #2 is enabled then goto ECA4
EC9C : LDAA  $84CE
EC9F : STAA  $01D4
ECA2 : BRA   $ECB3
ECA4 : LDAA  $0049
ECA6 : CMPA  #$1C
ECA8 : BNE   $ECB3
ECAA : LDAA  $01D4
ECAD : BEQ   $ECB3
ECAF : DECA  
ECB0 : STAA  $01D4
ECB3 : LDAA  $0049
ECB5 : ANDA  #$F0
ECB7 : CMPA  #$40
ECB9 : BEQ   $ECC2
ECBB : CMPA  #$90
ECBD : BEQ   $ECC2
ECBF : JMP   $ED04
ECC2 : LDX   #$0000
ECC5 : LDAB  $0272
ECC8 : SUBB  $0276
ECCB : ABX   
ECCC : ABX   
ECCD : LDAB  $0273
ECD0 : SUBB  $0275
ECD3 : ABX   
ECD4 : STX   $0279
ECD7 : LDD   $0274
ECDA : STD   $0275
ECDD : LDD   $0272
ECE0 : STD   $0273
ECE3 : LDX   #$0000
ECE6 : LDAB  $026D
ECE9 : SUBB  $0271
ECEC : ABX   
ECED : ABX   
ECEE : LDAB  $026E
ECF1 : SUBB  $0270
ECF4 : ABX   
ECF5 : STX   $0277
ECF8 : LDD   $026F
ECFB : STD   $0270
ECFE : LDD   $026D
ED01 : STD   $026E
ED04 : RTS

*
*
*   
ED05 : LDAA  $00CF
ED07 : CLRB  
ED08 : PSHB  
ED09 : PSHA  
ED0A : PULX  
ED0B : LDAA  $0123
ED0E : LDAB  #$19
ED10 : MUL   
ED11 : FDIV  
ED12 : XGDX  
ED13 : STAA  $0250
ED16 : BCLR  $0067,10110000B
ED19 : LDAA  $0250
ED1C : CMPA  $8536
ED1F : BLS   $ED26
ED21 : BSET  $0067,00100000B
ED24 : BRA   $ED50
ED26 : CMPA  $8689
ED29 : BLS   $ED2E
ED2B : BSET  $0067,10000000B
ED2E : CMPA  $8538
ED31 : BCS   $ED4D
ED33 : CMPA  $8537
ED36 : BHI   $ED4D
ED38 : LDAB  $0251
ED3B : CMPB  $8539
ED3E : BHI   $ED48
ED40 : INCB  
ED41 : BEQ   $ED50
ED43 : STAB  $0251
ED46 : BRA   $ED50
ED48 : BSET  $0067,00010000B
ED4B : BRA   $ED50
ED4D : CLR   $0251
ED50 : LDAA  $801A
ED53 : BITA  #$04
ED55 : BNE   $ED5A
ED57 : JMP   $EDD3
ED5A : BRCLR $0050,10000000B,$EDCC
ED5E : LDAA  $8540
ED61 : LDAB  $0067
ED63 : BCLR  $0067,00000001B
ED66 : BITB  #$01
ED68 : BEQ   $ED6D
ED6A : LDAA  $8541
ED6D : CMPA  $0156
ED70 : BLS   $ED77
ED72 : BSET  $0067,01000001B
ED75 : BRA   $EDCC
ED77 : LDAA  $00CF
ED79 : CMPA  $853D
ED7C : BCC   $EDCC
ED7E : LDAB  $0123
ED81 : CMPB  $853E
ED84 : BLS   $ED93
ED86 : LDAB  $0164
ED89 : CMPB  $853F
ED8C : BLS   $ED93
ED8E : BSET  $0067,01000000B
ED91 : BRA   $EDCC
ED93 : CMPA  $853B
ED96 : BLS   $EDC9
ED98 : BRSET $0067,01000000B,$EDB8
ED9C : CMPA  $853C
ED9F : BCS   $EDD2
EDA1 : LDAB  $01A9
EDA4 : CMPB  $853A
EDA7 : BLS   $EDD2
EDA9 : BSET  $0067,01000000B
EDAC : BRCLR $0067,00100000B,$EDD2		| if (not in 1st gear) then goto EDD2
EDB0 : BSET  $0067,00000010B			| set bit 0x02 of M[$0067] -  Cars active
EDB3 : BSET  $0068,00000001B
EDB6 : BRA   $EDD2
EDB8 : ADDA  #$02
EDBA : BCC   $EDBE
EDBC : LDAA  #$FF
EDBE : CMPA  $853C
EDC1 : BCS   $EDCC
EDC3 : BRSET $0067,00010000B,$EDCC
EDC7 : BRA   $EDD2
EDC9 : BCLR  $0067,01000000B
EDCC : BCLR  $0067,00000010B
EDCF : BCLR  $0068,00000001B
EDD2 : RTS   
*
* This subroutine controls TCC lockup, and is flowcharted.
* see the disassembly notes.
EDD3 : LDX   $0224				| load X with M[$0224]
EDD6 : BNE   $EE0D				| if M[$0224] != 0 then goto EE0D
EDD8 : LDAA  $0164				| A = M[$0164] - Throttle load axis variable
EDDB : CMPA  $855E				| compare A with M[$855E] - byte is 0xFF
EDDE : BCS   $EE05				| if ( A < 0xFF ) then goto EE05
EDE0 : LDAA  $00CF				| A = M[$00CF] ; vehicle speed
EDE2 : CMPA  $855F				| compare A to M[$855F] (byte is 0xFE)
EDE5 : BLS   $EE05				| if ( A <= M[$855F) (0xFE)) goto EE05
EDE7 : CMPA  $8560				| compare A with M[$8560] (byte is 0xFF)
EDEA : BHI   $EE05				| if ( A > 0xFF) then goto EE05
EDEC : LDAA  $0123				| A = M[$0123] ; load A with engine rpm
EDEF : CMPA  $8561				| compare A with M[$8561] (byte is 0xFF)
EDF2 : BCS   $EE05				| if ( A < 0xFF) then goto EE05 (always in this case)
EDF4 : LDX   $0222				| X = M[$0222]
EDF7 : CPX   $8562				| compare X with M[$8562] (value is 0xFFFF)
EDFA : BHI   $EDFF				| if ( X > 0xFFFF) then goto EDFF
EDFC : INX   					| X = X + 1
EDFD : BRA   $EE08				| goto EE08
EDFF : LDX   $8564				| X  = M[$8564] ; value is 0x00F0
EE02 : STX   $0224				| M[$0224] = X
EE05 : LDX   #$0000				| X = 0x0000
EE08 : STX   $0222				| M[$0222] = X
EE0B : BRA   $EE19				| goto EE19
EE0D : DEX   					| X = X - 1
EE0E : STX   $0224				| M[$0224] = X
EE11 : BEQ   $EE19				| if (M[$0224] == 0 ) then goto EE19
EE13 : BSET  $0066,00010001B			| set torque convertor locked, and TCC locked for by-pass noise.
EE16 : JMP   $EF2D				| goto EF2D
EE19 : BCLR  $0066,00010000B			| clear TCC locked for by-pass noise. torque convertor should still be locked.
EE1C : LDAA  $01A9				| A = M[$01A9]
EE1F : CMPA  $856B				| compare A with M[$856B] (value is 0x78 ) 
EE22 : BCS   $EE8B				| if ( A < M[$856B] (value is 0x78)) then goto EE8B
EE24 : BRCLR $004C,10000000B,$EE8B		| if traction control is active then goto EE8B
EE28 : LDAA  $801A				| A = M[$801A] (byte is 0xB3)
EE2B : BITA  #$08				| test bit 0x08 of A
EE2D : BEQ   $EE33				| if bit 0x08 of A is clear then goto EE33
EE2F : BRSET $0060,00000010B,$EE8B	
EE33 : LDAB  $856C				| load B with $856C - Byte is 0x20
EE36 : BRSET $0066,00000010B,$EE3E		| Kcoasts coasts release TPS threshold in use (hi mph)
EE3A : ADDB  #$05				| B = B + 0x05
EE3C : BCS   $EE42				| if B > 0xFF then goto EE42 - should not ever happen normally
EE3E : CMPB  $00CF				| compare with M[$00CF] - vehicle speed.
EE40 : BLS   $EE4A				| if M[$856C] + 0x05 < M[$00CF] then goto EE48
EE42 : BCLR  $0066,00000010B			| Clear Kcoasts release TPS threshold in use (hi mph)
EE45 : LDAB  $856D				| B = M[$856D] (value is 0x08)
EE48 : BRA   $EE50				| goto EE50
EE4A : BSET  $0066,00000010B			| set Kcoast coasts release TPS threshold is use (hi mph).
EE4D : LDAB  $856E				| B = M[$856E] (value is 0x00)
EE50 : BRCLR $0066,00000001B,$EE5A		| if torque convertor is unlocked then goto EE5A
EE54 : SUBB  $856F				| B = B - M[$856F] (value is 0x03)
EE57 : BCC   $EE5A				| if ( B >= 0) then goto EE5A
EE59 : CLRB  					| B = 0
EE5A : CMPB  $0164				| compare B with 0x0164 (throttle axis load variable)
EE5D : BLS   $EE62				| if ( B <= 0x0164 ) then goto EE62
EE5F : JMP   $EF07				| goto EF07
EE62 : LDX   #$8593				| X = 0x8593 
EE65 : BRSET $0066,10000000B,$EE6C		| if in fourth gear then goto EE6C
EE69 : LDX   #$8577				| X = 0x8577
EE6C : LDAB  #$0F				| B = 0x0F
EE6E : BRCLR $0066,00000001B,$EE76		| if torque convertor is not locked then goto EE76
EE72 : INX   					| X = X + 1
EE73 : INX   					| X = X + 1
EE74 : LDAB  #$01				| B = 0x01
EE76 : LDAA  $00CF				| A = M[$00CF] (vehicle speed)
EE78 : BRSET $004C,00000010B,$EE82		| if in 3rd or 4th gear then goto EE82
EE7C : SUBA  $8576				| A = A - M[$8576] (value is 0x00)
EE7F : BCC   $EE82				| if (A >= 0) then goto EE82
EE81 : CLRA  					| A = 0
EE82 : CMPA  $00,X				| compare A to M[$X]
EE84 : BCS   $EE8B				| if (A < M[$X]) then goto EE8B
EE86 : INX   					| X = X + 1
EE87 : CMPA  $00,X				| compare A with M[$X]
EE89 : BCS   $EE8E				| if (A < M[$X]) then goto EE8E
EE8B : JMP   $EF1A				| goto EF1A
EE8E : BRCLR $0061,01000000B,$EEA3		| if catalytic convertor overtemp is not enabled then goto EEA3
EE92 : LDAA  $8570				| A = M[$8570] (value is 0x00)
EE95 : BRSET $0066,00000001B,$EE9E		| if (torque convertor is locked) then goto EE93
EE99 : SUBA  #$0D				| A = A - 0x0D
EE9B : BCC   $EE9E				| If (A >= 0) then goto EE9E
EE9D : CLRA  					| A = 0
EE9E : CMPA  $0164				| comapre A with M[$0164] (throttle load axis variable)
EEA1 : BHI   $EEFF				| if (A > M[$0164]) then goto EEFF
EEA3 : ABX   					| X = X + B
EEA4 : BRCLR $0066,00000001B,$EEBC		| if (torque convertor is not locked) then goto EEBC
EEA8 : LDAB  $8018				| B = M[$8018] (value is 0xD0)
EEAB : BITB  #$02				| compare bit 0x02 of B
EEAD : BEQ   $EEBC				| if bit 0x02 of B is 0 then goto EEBC
EEAF : LDAB  #$10				| B = 0x10
EEB1 : LDAA  $0123				| A = M[$0123] (engine rpm)
EEB4 : CMPA  #$C0				| compare A with 0xC0 (192, 4800 rpm)
EEB6 : BCS   $EEC7				| if ( A < 0xC0 (4800rpm) ) then goto EEC7
EEB8 : LDAA  #$C0				| A = 0xC0
EEBA : BRA   $EEC7				| goto EEC7
EEBC : LDAB  #$18				| B = 0x18
EEBE : LDAA  $00CF				| A = M[$00Cf] (vehicle speed)
EEC0 : CMPA  #$64				| compare A with 0x64 (100 mph)
EEC2 : BCS   $EEC6				| if (A < 0x64 (100mph)) then goto EEC6
EEC4 : LDAA  #$64				| A = 0x64
EEC6 : ASLA  					| A = A * 2
EEC7 : JSR   $FC10				| gosub FC10
EECA : BEQ   $EF1A				
EECC : CMPA  $0164				| compare A with M[$0164] (throttle load axis variable)
EECF : BCS   $EF1A				| if ( A < M[$0164]) then goto EF1A
EED1 : BRCLR $0066,00000100B,$EEDF		| if ( 4-3/4-2 downshift is not in progress) then goto EEDF
EED5 : DEC   $0227				| M[$0227] = M[$0227] - 1
EED8 : BNE   $EEFF				| if (M[$0227] != 0) then goto EEFF
EEDA : BCLR  $0066,00000100B			| Clear 4-3/4-2 downshift in progress bit
EEDD : BRA   $EEFF				| goto EEFF
EEDF : BRSET $0066,10000000B,$EEFF		| if in 4th gear then goto EEFF
EEE3 : BRCLR $0066,00001000B,$EEFF		| if not status of fourth gear last pass then goto EEFF
EEE7 : BSET  $0066,00000100B			| set 4-3/4-2 downshift in progress bit
EEEA : LDAA  $8571				| A = M[$8571] (value is 0x05)
EEED : BNE   $EEF4				| if (A != 0) then goto EEF4
EEEF : BCLR  $0066,00000100B			| clear 4-3/4-2 downshift in progress bit
EEF2 : BRA   $EEFF				| goto EEFF
EEF4 : STAA  $0227				| M[$0227] = A
EEF7 : CMPA  $0226				| compare A with M[$0226]
EEFA : BLS   $EEFF				| if ( A <= M[$0226] ) then goto EEFF
EEFC : STAA  $0226				| M[$0226] = A
EEFF : LDAA  $0226				| A = M[$0226]
EF02 : BEQ   $EF2A				| if ( A == 0 ) then goto EF2A
EF04 : DECA  					| A = A - 1
EF05 : BRA   $EF1B				| goto EF1B
EF07 : LDAA  $00CF				| A = M[$00CF] load vehicle speed 
EF09 : CMPA  $8574				| compare A with $8574 (byte is 0x00)
EF0C : BCS   $EF1A				| branch if A < M[$8573] (value is $0x00) goto EF1A (never happens)
EF0E : LDAA  $8573				| A = M[$8573] (byte is 0x00)
EF11 : BRSET $0066,10000000B,$EF1B		| if we are in 4th gear then goto EF1B
EF15 : LDAA  $8572				| A = M[$8572] (byte is 0x00)
EF18 : BRA   $EF1B				| goto EF1B
EF1A : CLRA  					| A = 0x00
EF1B : STAA  $0226				| M[$226] = A
EF1E : LDAA  $00CF				| A = M[$00CF] load vehicle speed
EF20 : CMPA  $8575				| compare A with $8575 (byte is 5F or about 95 mph)
EF23 : BCC   $EF2A				| if (A > $95) then goto EF2A (engage TCC)
EF25 : BCLR  $0066,00000001B			| clear TCC
EF28 : BRA   $EF2D				| goto EF2D
EF2A : BSET  $0066,00000001B			| engage TCC
EF2D : BCLR  $0066,00001000B			| clear noise bypass - TCC is really on from TCC code.
EF30 : BRCLR $0066,10000000B,$EF37		| if not in 4th gear then goto EF37
EF34 : BSET  $0066,00001000B			| set Status of 4th gear last pass
EF37 : RTS   					| return from subroutine
*
*
*
EF38 : LDAA  $01A9
EF3B : CMPA  #$E0
EF3D : BLS   $EF41
EF3F : LDAA  #$E0
EF41 : LDX   #$883D
EF44 : JSR   $FC14
EF47 : STAA  $0253
EF4A : LDAA  $01AC
EF4D : LDX   #$8623
EF50 : JSR   $FC14
EF53 : LDX   #$8621
EF56 : JSR   $FB83			| Routine returns D = AIN (byte)  * M[$X] (word)
EF59 : STD   $01B8
EF5C : LDAA  $01A9
EF5F : LDX   #$889B
EF62 : JSR   $FC09
EF65 : STAA  $01B5
EF68 : LDAA  $01A9
EF6B : LDX   #$8390
EF6E : JSR   $FC14
EF71 : STAA  $00FD
EF73 : LDAA  $01A9
EF76 : LSRA  
EF77 : LDX   #$8081
EF7A : JSR   $FC14
EF7D : STAA  $020A
EF80 : BRCLR $006D,00000001B,$EF87
EF84 : JMP   $F131
EF87 : LDAA  $02C6
EF8A : CMPA  #$96
EF8C : BLS   $EF91
EF8E : JMP   $F11E
EF91 : INC   $02C6
EF94 : LDAA  $02C4
EF97 : BEQ   $EF9C
EF99 : JMP   $F131
EF9C : BRCLR $006D,00000010B,$F007
EFA0 : BRSET $006D,00000100B,$EFB1
EFA4 : BRSET $0051,00000001B,$EFAE
EFA8 : BSET  $0051,00000001B
EFAB : JMP   $F131
EFAE : JMP   $F11A
EFB1 : BCLR  $0051,00000001B
EFB4 : LDAA  $02C7
EFB7 : CMPA  #$F0
EFB9 : BEQ   $EFC1
EFBB : BSET  $006D,00001000B
EFBE : JMP   $F11A
EFC1 : LDAA  $02C3
EFC4 : CLR   $02C3
EFC7 : INCA  
EFC8 : CMPA  $02D2
EFCB : BEQ   $EFD3
EFCD : BSET  $006D,00010000B
EFD0 : JMP   $F11A
EFD3 : BCLR  $006D,00000100B
EFD6 : LDAA  $02C8
EFD9 : CMPA  #$04
EFDB : BNE   $EFF5
EFDD : BRSET $006D,01000000B,$EFE5
EFE1 : BRSET $006D,10000000B,$F00A
EFE5 : LDX   $02C9
EFE8 : CPX   #$FFFF
EFEB : BEQ   $F00F
EFED : CPX   $8EF8
EFF0 : BNE   $F00F
EFF2 : JMP   $F073
EFF5 : CMPA  #$03
EFF7 : BEQ   $F016
EFF9 : CMPA  #$02
EFFB : BEQ   $F003
EFFD : BSET  $006D,00100000B
F000 : JMP   $F11A
F003 : BRCLR $006D,01000000B,$F00A
F007 : JMP   $F098
F00A : INC   $02C5
F00D : BRA   $F016
F00F : BRCLR $006D,01000000B,$F016
F013 : JMP   $F11A
F016 : BSET  $006D,10000000B
F019 : LDAA  $02C5
F01C : STAA  $02D5
F01F : PSHA  
F020 : LDAB  #$08
F022 : MUL   
F023 : ADDD  #$8D75
F026 : CPD   #$8EF6
F02A : BCS   $F02F
F02C : BSET  $006D,01000000B
F02F : XGDX  
F030 : PULA  
F031 : LDAB  #$F0
F033 : STAB  $02D3
F036 : ABA   
F037 : LDAB  #$01
F039 : STAB  $02D4
F03C : ABA   
F03D : LDAB  $00,X
F03F : STAB  $02D6
F042 : ABA   
F043 : LDAB  $01,X
F045 : STAB  $02D7
F048 : ABA   
F049 : LDAB  $02,X
F04B : STAB  $02D8
F04E : ABA   
F04F : LDAB  $03,X
F051 : STAB  $02D9
F054 : ABA   
F055 : LDAB  $04,X
F057 : STAB  $02DA
F05A : ABA   
F05B : LDAB  $05,X
F05D : STAB  $02DB
F060 : ABA   
F061 : LDAB  $06,X
F063 : STAB  $02DC
F066 : ABA   
F067 : LDAB  $07,X
F069 : STAB  $02DD
F06C : ABA   
F06D : INCA  
F06E : STAA  $02DE
F071 : BRA   $F0D1
F073 : CLRA  
F074 : LDAB  #$F0
F076 : STAB  $02D3
F079 : ABA   
F07A : LDAB  #$00
F07C : STAB  $02D4
F07F : ABA   
F080 : INCA  
F081 : STAA  $02DE
F084 : LDD   #$0000
F087 : STD   $02D7
F08A : STD   $02D9
F08D : STD   $02DB
F090 : STAA  $02DD
F093 : BSET  $006D,00000001B
F096 : BRA   $F0D1
F098 : CLRA  
F099 : LDAB  #$F0
F09B : STAB  $02D3
F09E : ABA   
F09F : LDAB  #$04
F0A1 : STAB  $02D4
F0A4 : ABA   
F0A5 : LDX   $8EF8
F0A8 : CPX   #$FFFF
F0AB : BNE   $F0B0
F0AD : LDX   #$0000
F0B0 : STX   $02D5
F0B3 : PSHX  
F0B4 : PULB  
F0B5 : ABA   
F0B6 : PULB  
F0B7 : ABA   
F0B8 : INCA  
F0B9 : STAA  $02DE
F0BC : LDD   #$0000
F0BF : STD   $02D7
F0C2 : STD   $02D9
F0C5 : STD   $02DB
F0C8 : STAA  $02DD
F0CB : CLR   $02C5
F0CE : BSET  $006D,00000010B
F0D1 : SEI   
F0D2 : CLR   $1028
F0D5 : LDAA  #$D4
F0D7 : STAA  $1028
F0DA : LDAA  $1008
F0DD : ANDA  #$DF
F0DF : STAA  $1008
F0E2 : LDAA  $1029
F0E5 : LDAA  $02D3
F0E8 : STAA  $102A
F0EB : LDAA  #$01
F0ED : STAA  $02C2
F0F0 : BRN   $F0F0
F0F2 : LDAA  $1008
F0F5 : ORAA  #$20
F0F7 : STAA  $1008
F0FA : LDAA  $1029
F0FD : LDAA  $102A
F100 : STAA  $02C7
F103 : ADDA  $02C3
F106 : STAA  $02C3
F109 : CLR   $1028
F10C : LDAA  #$C4
F10E : STAA  $1028
F111 : LDAA  $02D4
F114 : STAA  $102A
F117 : CLI   
F118 : BRA   $F131
F11A : BRCLR $0050,01000000B,$F126
F11E : BSET  $006D,00000001B
F121 : BSET  $0065,00000010B
F124 : BRA   $F131
F126 : BSET  $0050,01000000B
F129 : LDAA  #$40
F12B : STAA  $02C4
F12E : BCLR  $006D,11111110B
F131 : RTS
*
*
*
F132 : BRSET $0049,00010000B,$F139
F136 : JMP   $F250
F139 : LDAA  $01A9
F13C : LDX   #$885B
F13F : JSR   $FC09
F142 : STAA  $025F
F145 : BRSET $0050,10000000B,$F195
F149 : BRSET $0001,00001000B,$F197
F14D : LDAA  $01AC
F150 : LDX   #$86E4
F153 : JSR   $FC14
F156 : TAB   
F157 : LDAA  $0235
F15A : LDX   #$872B
F15D : JSR   $FC14
F160 : ABA   
F161 : BCC   $F165
F163 : LDAA  #$FF
F165 : CLRB  
F166 : STD   $0008
F168 : LDX   #$8317
F16B : LDAA  $01AC
F16E : JSR   $FC14
F171 : SUBA  $8316
F174 : STAA  $000C
F176 : LDX   #$8325
F179 : LDAA  $01AC
F17C : JSR   $FC14
F17F : TAB   
F180 : CLRA  
F181 : ASLD  
F182 : ASLD  
F183 : STD   $000E
F185 : LDX   #$86F2
F188 : LDAA  $01AC
F18B : JSR   $FC14
F18E : TAB   
F18F : CLRA  
F190 : ASLD  
F191 : STD   $000A
F193 : BRA   $F197
F195 : BRA   $F1AD
F197 : LDX   #$870E
F19A : LDAA  $01AC
F19D : JSR   $FC14
F1A0 : STAA  $00D1
F1A2 : LDX   #$8700
F1A5 : LDAA  $01AC
F1A8 : JSR   $FC14
F1AB : STAA  $00D2
F1AD : BRSET $0070,00001000B,$F1C7
F1B1 : LDAA  $0235
F1B4 : LDAB  $801B
F1B7 : BITB  #$02
F1B9 : BEQ   $F1BE
F1BB : LDAA  $01A9
F1BE : LDX   #$8935
F1C1 : JSR   $FC14
F1C4 : STAA  $011D
F1C7 : LDX   #$871D
F1CA : LDAA  $01AC
F1CD : JSR   $FC14
F1D0 : STAA  $01B4
F1D3 : LDX   #$8865
F1D6 : LDAA  $01A9
F1D9 : JSR   $FC09
F1DC : STAA  $025D
F1DF : LDAA  $01AC
F1E2 : LDX   #$8029
F1E5 : JSR   $FC14
F1E8 : SUBA  $8028
F1EB : STAA  $0108
F1EE : LDAA  $01A9
F1F1 : LSRA  
F1F2 : LDX   #$8078
F1F5 : JSR   $FC14
F1F8 : STAA  $0109
F1FB : LDAA  $003C
F1FD : CMPA  $8930
F200 : BHI   $F207
F202 : CMPA  $892F
F205 : BCC   $F20F
F207 : BSET  $0056,01000000B
F20A : LDAA  $892C
F20D : STAA  $003C
F20F : LDX   #$891E
F212 : LDAA  $01AC
F215 : JSR   $FC14
F218 : ADDA  $003C
F21A : BCS   $F221
F21C : ADDA  $011D
F21F : BCC   $F223
F221 : LDAA  #$FF
F223 : STAA  $0118
F226 : LDAA  $01AC
F229 : LDX   #$8946
F22C : JSR   $FC14
F22F : PSHA  				|Push A 
F230 : LDAA  $0158			|A = M[$0158]
F233 : LDAB  #$50			|B = 0x50
F235 : LDX   #$8954			|X = 0x8954
F238 : JSR   $FC10			|gosub FC10
F23B : PULB  				|Pull B
F23C : MUL   				|D = A * B
F23D : ASLD  				|D = D * 2
F23E : BCC   $F242			| if (D >= 0xFFFF) then A = 0xFF 
F240 : LDAA  #$FF			|
F242 : STAA  $0121			| M[$0123] = A
F245 : LDAA  $0118
F248 : CMPA  $0116
F24B : BCC   $F250
F24D : STAA  $0116
F250 : RTS
*
*
*   
F251 : BRCLR $004F,01000000B,$F258
F255 : JSR   $5815
F258 : BCLR  $0070,10000000B
F25B : BRSET $004C,00000001B,$F262
F25F : BSET  $0070,10000000B
F262 : BRSET $005C,00010000B,$F278
F266 : LDAA  $00DC
F268 : CMPA  #$AB
F26A : BLS   $F278
F26C : BCLR  $004F,00100000B
F26F : LDX   #$1002
F272 : BCLR  $00,X,00000100B
F275 : JMP   $F3F8
F278 : BRSET $004F,00100000B,$F288
F27C : BSET  $004F,00100000B
F27F : LDX   #$1002
F282 : BSET  $00,X,00000100B
F285 : JMP   $F3F8
F288 : BRSET $0070,00000100B,$F2A3
F28C : BRSET $004F,00010000B,$F2AE
F290 : LDAB  $00DC
F292 : CMPB  #$5A
F294 : BLS   $F2BF
F296 : BRSET $0050,10000000B,$F2B1
F29A : BRCLR $005A,10000000B,$F2AE
F29E : LDAB  #$81
F2A0 : STAB  $010F
F2A3 : LDAA  $801B
F2A6 : BITA  #$40
F2A8 : BNE   $F2AE
F2AA : BRCLR $0049,00000011B,$F2BF
F2AE : JMP   $F349
F2B1 : BRSET $0070,00001000B,$F2E8
F2B5 : LDAA  $0127
F2B8 : CMPA  $0110
F2BB : BHI   $F2C2
F2BD : BRA   $F2D7
F2BF : JMP   $F3F8
F2C2 : LDAB  $0118
F2C5 : LDAA  $0112
F2C8 : CMPA  $88B6
F2CB : BCC   $F2D4
F2CD : ADDB  $0121
F2D0 : BCC   $F2D4
F2D2 : LDAB  #$FF
F2D4 : JSR   $FAA3
F2D7 : LDAA  $0112
F2DA : INCA  
F2DB : CMPA  $88B5
F2DE : BLS   $F346
F2E0 : BSET  $0070,00001000B
F2E3 : CLR   $0112
F2E6 : BRA   $F309
F2E8 : BRSET $0070,00100000B,$F349
F2EC : BRSET $006F,00010000B,$F2F8
F2F0 : BRSET $006F,00001000B,$F349
F2F4 : BRSET $006F,00000100B,$F309
F2F8 : LDAA  $010F
F2FB : BPL   $F309
F2FD : BRSET $006F,00100000B,$F309
F301 : DEC   $0112
F304 : BEQ   $F309
F306 : JMP   $F42A
F309 : LDAA  $88E9
F30C : BRSET $0070,10000000B,$F324
F310 : LDAA  $00CF
F312 : CMPA  #$20
F314 : BCS   $F318
F316 : LDAA  #$FF
F318 : ASLA  
F319 : ASLA  
F31A : ASLA  
F31B : LDAB  $88EB
F31E : MUL   
F31F : ADDA  $88EA
F322 : BCS   $F341
F324 : BRSET $006F,00000100B,$F346
F328 : ASLA  
F329 : BCS   $F341
F32B : PSHA  
F32C : LDAB  $0127
F32F : SUBB  $0110
F332 : CLRA  
F333 : ASLD  
F334 : ASLD  
F335 : TSTA  
F336 : BNE   $F345
F338 : COMB  
F339 : LDAA  $88EC
F33C : MUL   
F33D : PULB  
F33E : ABA   
F33F : BCC   $F346
F341 : LDAA  #$FF
F343 : BRA   $F346
F345 : PULA  
F346 : STAA  $0112
F349 : BCLR  $0070,00000001B
F34C : BRCLR $004F,10000000B,$F355
F350 : JSR   $5106
F353 : BRA   $F35C
F355 : BRCLR $004F,01000000B,$F35C
F359 : JSR   $5806
F35C : BRCLR $006A,00001000B,$F381
F360 : LDAA  $02B3
F363 : BITA  #$01
F365 : BEQ   $F381
F367 : BITA  #$02
F369 : BNE   $F381
F36B : LDAA  $003B
F36D : SUBA  $02B4
F370 : BCC   $F373
F372 : NEGA  
F373 : BPL   $F377
F375 : LDAA  #$7F
F377 : BCS   $F37B
F379 : ORAA  #$80
F37B : STAA  $010F
F37E : BSET  $0070,00000001B
F381 : LDAB  $010F
F384 : LSLB  
F385 : BEQ   $F3D3
F387 : DEC   $010F
F38A : LDAB  $003B
F38C : BCC   $F3A6
F38E : BRCLR $0057,00000001B,$F39B
F392 : BRSET $0057,00100000B,$F39B
F396 : INC   $010F
F399 : BRA   $F3F8
F39B : BEQ   $F39E
F39D : DECB  
F39E : DEC   $0040
F3A1 : BSET  $0057,00100000B
F3A4 : BRA   $F3C0
F3A6 : BRCLR $0057,00000001B,$F3B3
F3AA : BRCLR $0057,00100000B,$F3B3
F3AE : INC   $010F
F3B1 : BRA   $F3F8
F3B3 : CMPB  $88FE
F3B6 : BCC   $F3D3
F3B8 : INCB  
F3B9 : INC   $0040
F3BC : BCLR  $0057,00100000B
F3BF : CLC   
F3C0 : STAB  $003B
F3C2 : BRCLR $006F,00010000B,$F3D3
F3C6 : LDAB  $0113
F3C9 : INCB  
F3CA : BCC   $F3D0
F3CC : DECB  
F3CD : BEQ   $F3D0
F3CF : DECB  
F3D0 : STAB  $0113
F3D3 : BRCLR $006F,00001000B,$F3DA
F3D7 : INC   $011A
F3DA : LDAB  $003B
F3DC : CMPB  $88FE
F3DF : BLS   $F3E6
F3E1 : LDAB  $010F
F3E4 : BPL   $F3F8
F3E6 : LDAB  $0040
F3E8 : LDX   #$FD5D
F3EB : ANDB  #$03
F3ED : ABX   
F3EE : LDAA  $1002
F3F1 : ANDA  #$FC
F3F3 : ADDA  $00,X
F3F5 : STAA  $1002
F3F8 : LDAB  $0116
F3FB : ADDB  $0113
F3FE : BCC   $F402
F400 : LDAB  #$FF
F402 : TBA   
F403 : LDAB  $011A
F406 : BRCLR $0054,01000000B,$F40B
F40A : NEGB  
F40B : ABA   
F40C : TAB   
F40D : LDAA  $003B
F40F : SBA   
F410 : STAA  $011B
F413 : LDAB  $003B
F415 : SUBB  $011B
F418 : LDAB  #$80
F41A : BCC   $F422
F41C : CBA   
F41D : BHI   $F427
F41F : INCB  
F420 : BRA   $F426
F422 : CBA   
F423 : BCS   $F427
F425 : DECB  
F426 : TBA   
F427 : STAA  $011B
F42A : BCLR  $0057,00000001B
F42D : LDAB  $003B
F42F : CMPB  $010C
F432 : BEQ   $F437
F434 : BSET  $0057,00000001B
F437 : STAB  $010C
F43A : RTS   

*
* Throttle Load axis variable calculation and throttle input voltage limit check subroutine
* This routine has been flowcharted.  See the disassembly notes.
*
F43B : LDAA  $00D4			| A = M[$00D4] (Throttle Input Voltage)
F43D : LDAB  $83C9			| B = M[$83C9] (0xFF)
F440 : BITB  #$04			| Compare Bit 0x04 of B (bit is set)
F442 : BEQ   $F44F			| if (Bit 0x04 of M[$83C9] is clear) then goto F44F (will not happen)
F444 : CMPA  $83E3			| Compare A with M[$83E3] (0xF6)
F447 : BLS   $F44F			| if (A < M[$83E3] (0xF6) ) then goto F44F
F449 : BSET  $0058,00000100B		| Set bit 0x04 of M[$0058]
F44C : BSET  $0071,00000100B		| Set bit 0x04 of M[$0071]
F44F : BRCLR $0058,00100100B,$F456	| if bit 0x24 of M[$0058] is clear then goto F456
F453 : LDAA  $83E7			| A = M[$83E7] (0x38)
F456 : PSHA  				| Push A
F457 : LDD   $016B			| D = M[$016B]
F45A : ADDD  #$0080			| D += 0x0080
F45D : TAB   				| B = A
F45E : PULA  				| Pull A
F45F : PSHA  				| Push A
F460 : CBA   				| Compare A to B ( A - B )
F461 : BHI   $F46F			| if (A > B) then goto F46F
F463 : LDX   $016B			| X = M[$016B]
F466 : LDAB  $8681			| B = M[$8681] (0x01)
F469 : JSR   $FB63			| gosub FB63 Routine does: D = X + ( 256 * A - X ) * 0x01
F46C : STD   $016B			| M[$016B] = D
F46F : LDD   $016B			| D = M[$016B]
F472 : ADDD  #$0080			| D += 0x0080
F475 : TAB   				| B = A
F476 : PULA  				| Pull A
F477 : SBA   				| A = A - B
F478 : BCC   $F47B			| if ( A > 0 ) then goto F47B
F47A : CLRA  				| A = 0
F47B : LDAB  $867F			| B = M[$867F] (0x6F)
F47E : MUL   				| D = A * B (A is MSB)
F47F : ADDD  #$0020			| D += 0x0020
F482 : ASLD  				| D = D * 2
F483 : BCS   $F488			| if ( D > 0xFFFF ) then goto F488
F485 : ASLD  				| D = D * 2
F486 : BCC   $F48A			| if ( D < 0xFFFF ) then goto F48A
F488 : LDAA  #$FF			| A = 0xFF
F48A : STAA  $0164			| M[$0164] = A
F48D : LDAA  $88D7			| A = M[$88D7] (0x02)
F490 : BRCLR $0053,00001000B,$F495	| if (bit 0x08 of M[$0053] is clear) then goto F495
F494 : INCA  				| A ++
F495 : BSET  $0053,00001000B		| Set bit 0x08 of M[$0053]
F498 : CMPA  $0164			| Compare A with M[$0164]
F49B : BCC   $F4A0			| if ( A > M[$0164]) then goto F4A0
F49D : BCLR  $0053,00001000B		| Clear bit 0x08 of M[$0053]
F4A0 : BCLR  $0058,00100000B		| clear bit 0x20 of M[$0058]
F4A3 : BRCLR $0050,10000000B,$F4BD	| if (bit 0x80 of M[$0050] is clear ) then goto F4BD
F4A7 : LDAA  $83C9			| A = M[$83C9] (0xFF)
F4AA : BITA  #$02			| Compare bit 0x02 of A
F4AC : BEQ   $F4C6			| if (bit 0x02 of A is clear) then goto F4C6
F4AE : LDAA  $00D4			| A = M[$00D4] (Throttle input voltage)
F4B0 : CMPA  $83E8			| compare A with M[$83E8] (0x0C)
F4B3 : BCC   $F4C6			| if ( A > M[$83E8] ) then goto F4C6
F4B5 : BSET  $0071,00000010B		| set bit 0x02 of M[$0071]
F4B8 : BSET  $0058,00100000B		| set bit 0x20 of M[$0058]
F4BB : BRA   $F4C6			| goto F4C6
F4BD : LDAA  $8680			| A = M[$8680] (0x30)
F4C0 : STAA  $016B			| M[$016B] = A
F4C3 : CLR   $016C			| M[$016C] = 0
F4C6 : RTS   				| Return from subroutine
*
*
*
F4C7 : BCLR  $005F,00010000B
F4CA : BRCLR $004C,00100000B,$F4DE
F4CE : BRSET $005F,00100000B,$F4E1
F4D2 : BSET  $005F,00110000B
F4D5 : LDD   $84E8
F4D8 : ADDD  $00B6
F4DA : STD   $00B6
F4DC : BRA   $F4E1
F4DE : BCLR  $005F,00100000B
F4E1 : BRCLR $0056,00010000B,$F4F6
F4E5 : LDAA  $0196
F4E8 : BEQ   $F4F6
F4EA : DEC   $0196
F4ED : LDD   $87FA
F4F0 : ADDD  $00B6
F4F2 : STD   $00B6
F4F4 : BRA   $F4FA
F4F6 : BRCLR $005F,10010000B,$F565
F4FA : LDX   $881D
F4FD : CPX   $00B6
F4FF : BCC   $F503
F501 : STX   $00B6
F503 : LDX   $00B6
F505 : CPX   $8817
F508 : BCS   $F56A
F50A : SEI   
F50B : LDX   #$1000
F50E : BSET  $20,X,00010000B
F511 : BRSET $00,X,00100000B,$F526
F515 : LDD   $0E,X
F517 : ADDD  #$0002
F51A : STD   $1A,X
F51C : ADDD  $00CD
F51E : NOP  
F51F : NOP  
F520 : NOP  
F521 : NOP  
F522 : NOP  
F523 : NOP  
F524 : BRA   $F528
F526 : LDD   $1A,X
F528 : ADDD  $00B6
F52A : BCLR  $20,X,00010000B
F52D : STD   $1A,X
F52F : BSET  $20,X,01000000B
F532 : BRSET $00,X,01000000B,$F547
F536 : LDD   $0E,X
F538 : ADDD  #$0002
F53B : STD   $18,X
F53D : ADDD  $00CD
F53F : NOP  
F540 : NOP  
F541 : NOP  
F542 : NOP  
F543 : NOP  
F544 : NOP  
F545 : BRA   $F549
F547 : LDD   $18,X
F549 : ADDD  $00B6
F54B : BCLR  $20,X,01000000B
F54E : STD   $18,X
F550 : CLI   
F551 : SEI   
F552 : LDD   $0042
F554 : ADDD  $00B6
F556 : BCC   $F55B
F558 : INC   $0041
F55B : ADDD  $00B6
F55D : BCC   $F562
F55F : INC   $0041
F562 : STD   $0042
F564 : CLI   
F565 : LDX   #$0000
F568 : STX   $00B6
F56A : RTS   
#
# 	SPI serial transfer Complete Interrupt - Flowcharted.
#
F56B : LDAA  $006D			Load A with $006D			| A = M[$006D]
F56D : BITA  #$38			Bit A with 0x38				| A & 0x38
F56F : BNE   $F5D6			Branch if not equal $F5D6		| If (M[$006D] & 0x38) == 0) then goto $F5D6
F571 : LDY   #$1000			Load Y with 1000			| Y = 0x1000
F575 : LDX   #$02C7			Load X with 02C7			| X = 0x02C7
F578 : LDAB  $02C2			Load B with M[$02C2]			| B = M[$02C2]
F57B : ABX   				Add accumulator B to X			| X = X + B
F57C : LDAA  $1029			Load A with M[$1029]			| A = M[$1029]						| Read Serial Perf Status Reg
F57F : CMPB  #$0B			Compare B with 0x0B			|							| Low bits are supposed to be zero ????
F581 : BCS   $F58A			Branch if Carry Set to $F58A		| if (B < 0x0B) then goto F58A
F583 : LDAA  $102A			Load A with M[$102A]			| A = M[$102A]						| Read in Data from SPI
F586 : STAA  $00,X			Store A to M[$X]			| M[$X] = A						| Store the data to M[$X]
F588 : BRA   $F5C0			Branch Always F5C0			| goto F5C0						| goto F5C0
F58A : CLR   $1028			Clear M[$1028]				| M[$1028] = 0						| Clear Serial Peripheral Control Register
F58D : LDAA  #$D4			Load A with D4				| A = 0xD4						| Set Serial Peripheral Control Register to 0xD4
F58F : STAA  $1028			Store A to M[$1028]			| M[$1028] = A						| 	SPIE,DWOM,MSTR,CPHA=1
F592 : BCLR  $08,Y,00100000B		Clear 0x20 of M[$(Y+$08)]		| M[$(Y+0x08)] = M[$(Y+0x08)] | 0xDF
F596 : LDAA  $0D,X			Load X to M[$(X+$0D)]			| A = M[$(X+$0D)]
F598 : STAA  $102A			Store A to $102A			| M[$102A] = A						| Send data to the SPI interface
F59B : LDAA  $102A			Load A from $102A			| A = M[$102A]						| Read data from the SPI interface
F59E : STAA  $00,X			Store A to M[$X]			| M[$X] = A						| Move to $X
F5A0 : ADDA  $02C3			Add A to $02C3				| A = A + $02C3						|  
F5A3 : STAA  $02C3			Store A to $02C3			| M[$02C3] = A
F5A6 : ADDB  #$02			Add B to $02				| B = B + 0x02
F5A8 : BSET  $08,Y,00100000B		Set 0x20 of M[$(Y+08)]			| M[$(Y+0x08)] = M[$(Y+0x08)] | 0x20
F5AC : CLR   $1028			Clear M[$1028]				| M[$1028] = 0						| Clear Serial Peripheral Control Register
F5AF : LDAA  #$C4			Load A with $C4				| A = 0xC4						| Set Serial Peripheral Control Register to 0xC4
F5B1 : STAA  $1028			Store A to $1024			| M[$1024] = 0xC4					| 	SPIE,DWOM,CPHA=1
F5B4 : LDAA  $1029			Load A with $1029			| A = M[$1029]						| Read Serial Peripheral Status Register
F5B7 : LDAA  $102A			Load A wiht $102A			| A = M[$102A]						| reading $1029 and then $102A clrs SPIF (interrupt)
F5BA : STAA  $01,X			Store A to M[$(X+01)]			| M[$(X+01)] = A		
F5BC : CMPB  #$0C			Compare B with 0x0C			| 
F5BE : BCS   $F5C8			Branch if carry is set to F5C8		| if (B < 0x0C) then goto F5C8
F5C0 : BSET  $006D,00000100B		Set M[$006D] Bit 0x04			| 
F5C3 : CLRB  				Clear B					| B = 0
F5C4 : LDAA  #$F0			Load A with 0xF0			| A = 0xF0
F5C6 : BRA   $F5D0			Branch Always F5D0			| goto F5D0
F5C8 : ADDA  $02C3			Add A to M[$02C3]			| A = A + M[$02C3]
F5CB : STAA  $02C3			Store A to M[$02C3]			| M[$02C3] = A
F5CE : LDAA  $0E,X			Load A with M[$X+0x0E)			| A = M[$(X+0x0E)]
F5D0 : STAA  $102A			Store A to $102A			| M[$102A] = A						| Write Serial Per. Data Register - Data out.
F5D3 : STAB  $02C2			Store B to $02C2			| M[$02C2] = B
F5D6 : RTI   				Return From Interrupt			| Return
#
# 	SCI Serial System - Flowcharted.
#
F5D7 : LDX   #$1000			Load X with 0x1000			| X = 0x1000  (SCI serial system interrupt vector)
F5DA : BRCLR $2D,X,00100000B,$F5E6	if M[$102D] bit 0x20 clr goto $F5E6	| if ReceiverInterruptEnable(SCI) is disabled goto $F5E6
F5DE : BRCLR $2E,X,00100000B,$F607	if M[$102E] bit 0x20 clr goto $F607	| if ReceiverDataRegisterFull(SCI) is empty goto $F607 (RTI)
F5E2 : JSR   $F608			Jump to service routine $F608		| goto $F608
F5E5 : RTI   				Return from interrupt			| RTI
*
*
*
F5E6 : BRCLR $2D,X,10000000B,$F5F2	if M[$102D] bit 0x80 clr goto $F5F2	| if TransmitInterruptEnable(SCI) is disabled goto $F5F2
F5EA : BRCLR $2E,X,10000000B,$F607	if M[$102E] bit 0x80 clr goto $F607	| if TransmitDataRegisterEmpty(SCI) is full goto $F607 (RTI)
F5EE : JSR   $F783			Jump to service routine $F783		| goto $F783
F5F1 : RTI   				Return from interrupt			| RTI
*
*
*
F5F2 : BRCLR $2D,X,01000000B,$F607	if M[$102D] bit 0x40 clr goto $F607	| if TransmitCompleteInterruptEnable(SCI) is disabled goto $F607 (RTI)
F5F6 : BRCLR $2E,X,01000000B,$F607	if M[$102E] bit 0x40 clr goto $F607	| if TransmitCompleteFlag(SCI) is busy goto $F607 (RTI)
F5FA : LDAA  #$26			Load A with 0x26			| A = 0x26
F5FC : STAA  $2D,X			Store A to M[$102D]			| M[$102D] = 0x26		| serial communications control reg #2
F5FE : BCLR  $006A,01000000B		Clear 0x40 of M[$006A]
F601 : LDX   #$4002			Load X with $4002			| X = 0x4002
F604 : BCLR  $00,X,00010000B		Clear bit 0x10 of X			| 
F607 : RTI   				Return from interrupt
#
#	Reciever Buffer Full Interrupt
#	This routine has been flowcharted to F782
F608 : LDAB  $102E			Load B with M[$102E]			| B = M[$102E] 						| Read SCI Status Register
F60B : LDAA  $102F			Load A with M[$102F]			| A = M[$102F]						| Read SCI Receiver Buffer
F60E : LDX   $0288			Load X with M[$0288]			| X = M[$0288]
F611 : CLR   $02B9			Clear M[$02B9]				| M[$02B9] = 0
F614 : BITB  #$0E			Bit if ($0E & B )			|
F616 : BNE   $F690			if SCI transmitcomplete(idle) or recievedataregisterfull(full) or idlelinedetect(idle) goto F690
F618 : TAB   				B = A					| B = A
F619 : ADDB  $0287			Add B to M[$0287]			|						| SCI checksum
F61C : STAB  $0287			Store B to M[$0287]			| M[$0287] += B					| SCI checksum
F61F : LDAB  $0286			Load B with M[$0286]			| B = M[$0286]
F622 : BNE   $F64C			if B != 0 goto F64C			| if (B != 0) then goto F64C
F624 : LDX   #$89E7			Load X with 89E7			| X = 0x89E7
F627 : BRCLR $006A,00010000B,$F62E	if M[$006A] bit 0x10 clr goto F62E	
F62B : LDX   #$FA5D			Load X with FA5D			| X = 0xFA5D
F62E : CMPA  $02,X			Compare A with M[$(X+0x02)]		| 
F630 : BEQ   $F638			branch if equal to F638 		| if (A == M[$(X+0x02)] goto F638  ($FA5F = 0x01)
F632 : LDX   $00,X			Load X with M[$X]			| X = M[$X]  (X=FA5D?)  Value of $X is FA66?
F634 : BNE   $F62E			Branch if not equal to $F62E		| if X != 0 then goto F62E
F636 : BRA   $F690			Branch Always F690			| goto F690
F638 : BCLR  $0052,01000000B		Clear 0x40 of M[$0052]			| Clear 0x40 of M[$0052]
F63B : CMPA  #$F4			Compare A with 0xF4			|
F63D : BNE   $F642			Branch if not equal to F642		| if ( A != 0xF4 ) then goto F642
F63F : BSET  $0052,01000000B		Set 0x40 of M[$0052]			| Set 0x40 of M[$0052]
F642 : STX   $0288			Store X to M[$0288]			| M[$0288] = X
F645 : LDAA  #$24			Load A with 0x24			| A = 0x24
F647 : STAA  $102D			Store A to $102D (0x24)			| set ReceiverInterruptEnable and Receiverenable
F64A : BRA   $F685			Branch Always $F685			| goto F685
F64C : DECB  				Decrement B				| B --
F64D : BNE   $F658			branch if not equal F658		| if (B != 0) then goto F658
F64F : SUBA  #$55			Subtract 0x55 from A			| A -= 0x55
F651 : BCS   $F690			branch if carry is set to F690		| if (A < 0) then goto F690
F653 : STAA  $02B8			Store A to M[$02B8]			| M[$02B8] = A
F656 : BRA   $F685			Branch Always F685			| goto F685
F658 : DECB  				Decrement B				| B -- 
F659 : CMPB  $02B8			Compare B with $02B8			| 
F65C : BCC   $F68B			Branch if Carry is clear to F68B	| if ( B >= M[$02B8] ) then goto F68B
F65E : TSTB  				Test B					|
F65F : BNE   $F680			Branch if not equal to F680		| if (B != 0) then goto F680
F661 : BRCLR $0052,01000000B,$F680	if Bit 0x40 of M[$0052] = 0 goto F680	| if bit 0x40 if M[$0052] = 0 then goto F680
F665 : LDX   #$8AD1			Load X with 0x8AD1			| X = 0x8AD1
F668 : CMPA  #$0A			Compare A with 0x0A			|
F66A : BHI   $F690			Branch if high to F690			| if ( A > 0x0A ) then goto F690
F66C : BEQ   $F67B			Branch if equal to F67B			| if ( A == 0x0A ) then goto FA7B
F66E : CMPA  #$04			Compare A with 0x04			|
F670 : BHI   $F690			Branch if high to F690			| if ( A > 0x04 ) then goto F690
F672 : PSHB  				Push B					| Push B
F673 : TAB   				B = A					| B = A
F674 : LSLB  				Logical Shift Left B			| B << 1  ( B = B * 2, carry flag is set on overflow)
F675 : ABX   				Add B to X				| X += B
F676 : PULB  				Pull B					| pull B  (Variable being decremented)
F677 : LDX   $00,X			Load X with M[$X]			| X = M[$X]
F679 : BRA   $F67D			Branch always to F67D			| goto F67D
F67B : LDX   $0A,X			Load X with M[$X+0x0A]			| X = M[$(X+0x0A)]
F67D : STX   $0288			Store X to M[$0288]			| M[$0288] = X
F680 : LDX   $07,X			Load X with M[$X+0x07]			| X = M[$(X+0x07)]
F682 : ABX   				Add B to X				| X += B
F683 : STAA  $00,X			Store A to $X				| M[$X] = A
F685 : INC   $0286			Increment $0286				| M[$0286] ++
F688 : JMP   $F782			Jump to F782				| goto F782
F68B : LDAB  $0287			Load B with M[0287]			| B = M[$0287]					| SCI checksum
F68E : BEQ   $F693			Branch if equal to F693			| if (B == 0) then goto F693
F690 : JMP   $F774			Jump to F774				| goto F774
F693 : BSET  $0052,00000001B		Set 0x01 of M[$0052]			| set bit 0x01 of M[$0052]
F696 : LDAA  $02,X			Load A with M[$(X+0x02)]		| A = M[$(X+0x02)]
F698 : STAA  $02B7			Store A to $02B7			| M[$02B7] = A
F69B : CMPA  #$40			Compare A to $40			|
F69D : BEQ   $F6A7			branch if equal to F6A7			| if ( A == 0x40 ) then goto F6A7
F69F : ANDA  #$F0			And A with 0xF0				| A = A & 0xF0
F6A1 : CMPA  #$40			Compare A with $40			| 
F6A3 : BNE   $F713			branch if not equal to F713		| if ( A != 40 ) then goto F713
F6A5 : BRA   $F708			Branch always to F708			| goto F708
F6A7 : LDD   $0203			Load D with M[$0203]			| D = M[$0203]
F6AA : CPD   #$0008			Compare D with 0x0008			|
F6AE : BCS   $F6B3			branch if carry set to F6B3		| if ( D < 0x0008 ) then goto F6B3 
F6B0 : BCLR  $0002,00100000B		Clear 0x20 of M[$0002]			| Clear bit 0x20 of M[$0002]
F6B3 : BRSET $0002,00100000B,$F6D7	Branch if 0x20 of M[$0002] set F6D7	| if ( bit 0x20 of M[$0002] == 1) then goto F6D7 
F6B7 : LDAA  $0217			Load A with M[$0217]			|
F6BA : BNE   $F6C4			Branch if not equal to F6C4		| if ( A != 0 ) then goto F6C4
F6BC : LDD   #$0000			Load D with 0x0000			| D = 0
F6BF : STD   $02C0			Store D to M[$02C0]			| M[$02C0] = 0 (word)
F6C2 : BRA   $F708			Branch always to F708			| goto F708
F6C4 : BRCLR $0053,01000000B,$F6DF      Branch if 0x40 of $0053 clr to F6DF	| if ( bit 0x40 of M[$0052] == 0) then goto F6DF
F6C8 : LDX   $07,X			Load X with X+07			| X = M[$(X+0x07)]
F6CA : LDX   $00,X			Load X with X				| X = M[$X]
F6CC : CPX   $0218
F6CF : BNE   $F6E2
F6D1 : BSET  $0002,00100000B
F6D4 : BSET  $006B,00000001B
F6D7 : LDD   #$FFFF
F6DA : STD   $02C0
F6DD : BRA   $F708
F6DF : BSET  $0053,01000000B
F6E2 : LDD   $100E
F6E5 : STD   $02C0
F6E8 : ASRB  
F6E9 : ROLA  
F6EA : RORB  
F6EB : STD   $0218
F6EE : ROLA  
F6EF : RORB  
F6F0 : ROLA  
F6F1 : ANDB  #$3F
F6F3 : LDX   #$8ADD
F6F6 : ABX   
F6F7 : TAB   
F6F8 : LDAA  $00,X
F6FA : ANDB  #$3F
F6FC : LDX   #$8ADD
F6FF : ABX   
F700 : LDAB  $00,X
F702 : ADDD  $0218
F705 : STD   $0218
F708 : BCLR  $0068,00100000B
F70B : CLR   $02AC
F70E : BCLR  $006A,00001000B
F711 : BRA   $F746
F713 : BCLR  $0052,00000001B
F716 : BCLR  $0068,00100000B
F719 : LDAA  $028A
F71C : STAA  $02AC
F71F : BEQ   $F746
F721 : BSET  $0068,00100000B
F724 : CMPA  #$04
F726 : BNE   $F746
F728 : LDD   $028B
F72B : STD   $02AD
F72E : LDD   $028D
F731 : STD   $02AF
F734 : LDD   $028F
F737 : STD   $02B1
F73A : LDD   $0291
F73D : STD   $02B3
F740 : LDD   $0293
F743 : STD   $02B5
F746 : LDX   $0288
F749 : BRSET $04,X,10000000B,$F774
F74D : LDAB  $102E			| serial communications status reg
F750 : LDAA  $02,X
F752 : BRCLR $0052,00000001B,$F757
F756 : INCA  
F757 : STAA  $102F			| Serial Communications data register
F75A : STAA  $0287			| SCI checksum
F75D : LDAB  #$01
F75F : STAB  $0286
F762 : LDX   #$4002
F765 : BSET  $00,X,00010000B
F768 : LDAA  #$80
F76A : STAA  $102D			| Serial communications control reg #2
F76D : LDAA  #$88
F76F : STAA  $102D			| Serial communications control reg #2
F772 : BRA   $F782
F774 : LDD   #$0000
F777 : STD   $0288
F77A : STD   $0286
F77D : LDAA  #$26
F77F : STAA  $102D			| Serial communications control reg #2
F782 : RTS   
# 
#	SCI Transmit Buffer is empty and transmitting is enabled
#	This routine has been flowcharted to F857
F783 : LDX   $0288			| X = M[$0x0288]
F786 : LDAB  $0286			| B = M[$0x0286]
F789 : DECB  				| B = B - 1
F78A : BNE   $F7AB			| if (B != 0) then goto $F7AB
F78C : LDAA  $04,X			| A = M[$(X + 0x04)]
F78E : BRCLR $0068,00100000B,$F7A3	| if bit 0x20 of M[$0068] is clear then goto $F7A3
F792 : LDAB  $02AC			| B = M[$0x02AC]
F795 : SUBB  #$02			| B = B - 0x02
F797 : BLS   $F7A3			| if (B <= 0) then goto $F7A3
F799 : LDAA  $02B8			| A = M[$0x02B8]
F79C : DECA  				| A = A - 1
F79D : DECB  				| B = B - 1 
F79E : BEQ   $F7A1			| if (B == 0) then goto $F7A1
F7A0 : CLRA  				| A = 0
F7A1 : ASRA  				| A = A >> 1  ( A = A / 2 )
F7A2 : INCA  				| A = A + 1
F7A3 : STAA  $02B8			| M[$0x02B8] = A
F7A6 : ADDA  #$55			| A = A + 0x55
F7A8 : JMP   $F832			| goto $F832
F7AB : DECB  				| B = B - 1
F7AC : BNE   $F7B5			| if (B != 0) then goto $F7B5
F7AE : LDAA  $02AC			| A = M[$0x02AC]
F7B1 : BRSET $0068,00100000B,$F832	| if bix 0x20 of M[$0068] is set then goto $F832
F7B5 : CMPB  $02B8			| 
F7B8 : BCC   $F82C			| if (B >= M[$0x02B8]) then goto $F82C
F7BA : BRSET $006A,10000000B,$F820	| if bit 0x80 of M[$006A] is set then goto $F820
F7BE : BRSET $03,X,10000000B,$F7CD	| if bit 0x80 of M[$(X+0x03)] is set then goto $F7CD
F7C2 : BRSET $03,X,01000000B,$F7D8	| if bit 0x40 of M[$(X+0x03)] is set then goto $F7D8
F7C6 : LDX   $05,X			| X = M[$(X+0x05)]
F7C8 : ABX   				| X = X + B
F7C9 : LDAA  $00,X			| A = M[$X]
F7CB : BRA   $F832			| goto $F832
F7CD : BRSET $0052,00000001B,$F7D2	| if (bit 0x01 of M[$0052] is set then goto $F7D2
F7D1 : DECB  				| B = B - 1
F7D2 : LSLB  				| B = B << 1 (B = B * 2)
F7D3 : ABX   				| X = X + B
F7D4 : LDX   $09,X			| X = M[$(X+0x09)]
F7D6 : BRA   $F7F6			| goto $F7F6
F7D8 : BRSET $0052,00000001B,$F7DD	| if bit 0x01 of M[$0052] is set then goto $F7DD
F7DC : DECB  				| B = B - 1
F7DD : LDX   $05,X			| X = M[$(X+0x05)]
F7DF : LDAA  $02AC			| A = M[$02AC]
F7E2 : BRSET $0068,00100000B,$F7E7	| if bit 0x20 of M[$0068] is set then goto $F7E7
F7E6 : CLRA  				| A = 0
F7E7 : CMPA  #$02			| 
F7E9 : BEQ   $F7F2			| if (A == 0x02) then goto $F7F2
F7EB : LSLB  				| B = B << 1  ( B = B * 2 )
F7EC : INCB  				| B = B + 1
F7ED : ABX   				| X = X + B
F7EE : LDX   $00,X			| X = M[$X]
F7F0 : BRA   $F7F6			| goto $F7F6
F7F2 : INX   				| X = X + 1
F7F3 : LDX   $00,X			| X = M[$X]
F7F5 : ABX   				| X = X + B
F7F6 : CPX   #$3000			|
F7F9 : BCS   $F828			| if ( X < 0x3000 ) then goto $F828
F7FB : CPX   #$6FFF			| 
F7FE : BHI   $F828			| if ( X > 0x6FFF ) then goto $F828
F800 : PSHX  				| Push X
F801 : PULA  				| Pull A
F802 : BITA  #$20			| test bit 0x20 of A
F804 : BEQ   $F812			| If bit 0x20 is clear then goto $F812
F806 : BITA  #$08			| 
F808 : BNE   $F80E			| if bit 0x08 is set then goto $F80E
F80A : ANDA  #$03			| A = A & 0x03
F80C : BRA   $F814			| goto $F814
F80E : ANDA  #$20			| A = A & 0x20
F810 : BRA   $F814			| goto $F814
F812 : ANDA  #$11			| A = A & 0x11
F814 : PSHA  				| Push A
F815 : PULX  				| Pull X
F816 : LDD   $00,X			| D = M[$X]
F818 : STAB  $02BB			| M[$02BB] = B 
F81B : BSET  $006A,10000000B		| set bit 0x80 of M[$006A]
F81E : BRA   $F832			| goto $F832
F820 : BCLR  $006A,10000000B		| clear bit 0x80 of M[$006A]
F823 : LDAA  $02BB			| A = M[$02BB]
F826 : BRA   $F832			| goto $F832
F828 : LDAA  $00,X			| D = M[$X]
F82A : BRA   $F832			| goto $F832
F82C : BNE   $F840			| ???? where from
F82E : LDAA  $0287			| A = M[$0287]			SCI checksum
F831 : NEGA  				| A = $0x00 - A
F832 : STAA  $102F			| M[$102F] = A			SCDR - Serial communications Data register
F835 : ADDA  $0287			| A = A + M[$0287]		$0287 - Must be the checksum
F838 : STAA  $0287			| M[$0287] = A			SCI checksum
F83B : INC   $0286			| M[$0286] = M[$0286] + 1
F83E : BRA   $F857			| goto $F857
F840 : LDD   #$0000			| D = 0x0000
F843 : BCLR  $006A,10000000B		| Clear bit 0x80 of M[$006A]
F846 : STD   $0286			| M[$0286] = D 
F849 : STD   $0288			| M[$0288] = D
F84C : LDAA  $102E			| A = M[$102E]			SCSR - SCI status register
F84F : LDAA  $102F			| A = M[$102F]			SCDR - Serial Communications Data Register
F852 : LDAA  #$40			| A = 0x40
F854 : STAA  $102D			| M[$102D] = 0x40		SCCR2 - Serial Comm. Control Reg #2 - Transmit complete Interrupt Enable
F857 : RTS   				| Return from subroutine
*
*
*
F858 : LDS   #$20FF			| S = 0x20FF
F85B : LDX   #$4000			| X = 0x4000
F85E : BCLR  $00,X,00011100B		| Clear 0x1C of M[$X]
F861 : LDAA  #$00			| A = 0x00
F863 : ORAA  $00,X			| A = A OR M[$X]
F865 : STAA  $00,X			| M[$X] = A
F867 : CLR   $1030			| M[$1030] = 0
F86A : LDX   #$1000			| X = 0x1000
F86D : LDAB  #$0C			| B = 0x0C
F86F : BRSET $30,X,10000000B,$F879	| if bit 0x80 of M[$(X+0x30) is set then goto $F879
F873 : DECB  				| B = B - 1
F874 : BNE   $F86F			| if ( B != 0) then goto $F86F
F876 : BSET  $0059,00000001B		| set bit 0x01 of M[$0059]
F879 : LDAA  $1034			| A = M[$1034]  
F87C : CMPA  #$28			|
F87E : BCC   $F88A			| if ( A >= 0x28 ) then goto $F88A
F880 : BRSET $007F,00000010B,$F889	| if bit 0x02 of M[$007F] then goto $F889
F884 : BSET  $007F,00000010B		| set bit 0x02 of M[$007F]
F887 : BRA   $F88D			| goto $F88D
F889 : SWI   				| Software Interrupt
F88A : BCLR  $007F,00000010B		| Clear bit 0x02 of M[$007F]
F88D : LDX   #$4000			| X = 0x4000
F890 : BCLR  $00,X,00011100B		| Clear bit 0x1C of M[$X]
F893 : LDAA  #$1C			| A = 0x1C
F895 : ORAA  $00,X			| A = A OR M[$X]
F897 : STAA  $00,X			| M[$X] = A
F899 : CLR   $1030			Clear $1030				| M[$1030] = A  Clear the A/D control register
F89C : LDX   #$1000			Load X with $1000			| X = 0x1000
F89F : LDAB  #$0C			Load B with 0x0C			| B = 0x0C
F8A1 : BRSET $30,X,10000000B,$F8AB	if bit 0x80 of $1030 is set to F8AB	| goto F8AB when A/D conversion is complete
F8A5 : DECB  				Decrement B				| B --
F8A6 : BNE   $F8A1			Branch if not equal to F8A1		| if ( B != 0) then F8A1
F8A8 : BSET  $0059,00000001B		Set bit 0x01 of $0059			
F8AB : LDAA  $1034			Load A with $1034			| A = M[$1034]
F8AE : CMPA  #$64			Compare A with 0x64			
F8B0 : BCC   $F8B6			branch if carry clear to F8B6		| if ( A < 0x64 ) then goto F8B6
F8B2 : CMPA  #$28			Compare A with 0x28
F8B4 : BCC   $F8B7			Branch if carry clear to F8B7		| if ( A < 0x28 ) then goto F8B7
F8B6 : SWI   				Software interrupt 
F8B7 : CLI   				Clear Interrupts
F8B8 : LDAA  #$AA			Load A with 0xAA			| A = 0xAA
F8BA : STAA  $103A			Store A to $103A			| M[$103A] = 0xAA
F8BD : LDAA  #$55			Load A with $0x55			| A = 0x55
F8BF : STAA  $103A			Store A to $103A			| M[$103A] = 0x55
F8C2 : LDAB  $02B7			Load B with $02B7
F8C5 : CMPB  #$02
F8C7 : BEQ   $F8D4
F8C9 : JSR   $FB5A
F8CC : CMPB  #$03
F8CE : BNE   $F8DE
F8D0 : BRCLR $007F,00000001B,$F8DE
F8D4 : BSET  $007F,00000001B
F8D7 : LDX   $028A
F8DA : JSR   $00,X
F8DC : BRA   $F8FC
F8DE : CMPB  #$01
F8E0 : BNE   $F8FF
F8E2 : BCLR  $007F,00000001B
F8E5 : LDX   $028A
F8E8 : LDY   #$028C
F8EC : LDAB  #$20
F8EE : LDAA  $00,Y
F8F1 : STAA  $00,X
F8F3 : INY   
F8F5 : INX   
F8F6 : DECB  
F8F7 : BNE   $F8EE
F8F9 : COM   $02B7
F8FC : JMP   $FA5A
F8FF : LDX   #$FA98
F902 : TSTB  
F903 : BNE   $F90E
F905 : LDY   #$4004
F909 : BRSET $00,Y,00100000B,$F911
F90E : JMP   $F997
F911 : LDX   #$1000
F914 : LDAA  #$60
F916 : STAA  $0C,X
F918 : STAA  $0D,X
F91A : LDAA  #$80
F91C : STAA  $0B,X
F91E : LDD   $0E,X
F920 : ADDD  #$0189
F923 : STD   $16,X
F925 : BCLR  $0D,X,01100000B
F928 : LDX   #$FFF1
F92B : STX   $3FF6
F92E : LDX   #$0042
F931 : NOP  
F932 : NOP  
F933 : NOP  
F934 : STX   $3FDC
F937 : LDAA  #$FD
F939 : STAA  $4007
F93C : LDD   $3FFC
F93F : ORAB  #$10
F941 : NOP  
F942 : NOP  
F943 : NOP  
F944 : STD   $3FFC
F947 : LDAB  $0049
F949 : CMPB  #$7F
F94B : BLS   $F94E
F94D : CLRB  
F94E : STAB  $0049
F950 : BITB  #$0F
F952 : BNE   $F8FC
F954 : PSHB  
F955 : LDAA  $1002
F958 : TAB   
F959 : ANDA  #$03
F95B : BEQ   $F965
F95D : CMPA  #$03
F95F : BEQ   $F965
F961 : EORB  #$02
F963 : BRA   $F967
F965 : EORB  #$01
F967 : STAB  $1002
F96A : LDX   #$1002
F96D : BSET  $00,X,00000100B
F970 : PULB  
F971 : LSRB  
F972 : LSRB  
F973 : LSRB  
F974 : LSRB  
F975 : LDAA  #$04
F977 : MUL   
F978 : LDX   #$FA78
F97B : ABX   
F97C : LDAA  $4000
F97F : ANDA  #$1F
F981 : LDY   #$FA9C
F985 : LDAB  $007E
F987 : ABY   
F989 : INCB  
F98A : CMPB  #$07
F98C : BCS   $F98F
F98E : CLRB  
F98F : STAB  $007E
F991 : ORAA  $00,Y
F994 : STAA  $4000
F997 : LDAA  $4002
F99A : ANDA  #$DE
F99C : ORAA  $00,X
F99E : STAA  $4002
F9A1 : LDAA  $1002
F9A4 : ANDA  #$F7
F9A6 : ORAA  $01,X
F9A8 : STAA  $1002
F9AB : LDD   $10FC
F9AE : ANDB  #$F3
F9B0 : ORAB  $02,X
F9B2 : STD   $10FC
F9B5 : LDD   $3FFC
F9B8 : ANDB  #$FB
F9BA : ORAB  $03,X
F9BC : STD   $3FFC
F9BF : CPX   #$FA98
F9C2 : BNE   $F9F2
F9C4 : LDX   #$D000
F9C7 : STX   $3FD6
F9CA : STX   $4008
F9CD : STX   $400A
F9D0 : STX   $3FD8
F9D3 : STX   $400C
F9D6 : NOP  
F9D7 : NOP  
F9D8 : STX   $3FDA
F9DB : NOP  
F9DC : NOP  
F9DD : NOP  
F9DE : NOP  
F9DF : STX   $3FCC
F9E2 : NOP  
F9E3 : NOP  
F9E4 : NOP  
F9E5 : NOP  
F9E6 : STX   $3FEA
F9E9 : NOP  
F9EA : NOP  
F9EB : NOP  
F9EC : NOP  
F9ED : STX   $3FD4
F9F0 : BRA   $FA5A
F9F2 : LDX   #$D0CC
F9F5 : STX   $3FD6
F9F8 : LDX   #$7F80
F9FB : STX   $4008
F9FE : LDX   #$7F73
FA01 : STX   $400E
FA04 : LDX   #$D066
FA07 : STX   $3FD8
FA0A : LDX   #$7F4C
FA0D : STX   $400A
FA10 : LDX   #$D100
FA13 : STX   $3FDA
FA16 : LDX   #$7F66
FA19 : STX   $400C
FA1C : LDX   #$D099
FA1F : STX   $3FCC
FA22 : NOP  
FA23 : NOP  
FA24 : NOP  
FA25 : LDX   #$D166
FA28 : STX   $3FEA
FA2B : NOP  
FA2C : NOP  
FA2D : NOP  
FA2E : LDX   #$D233
FA31 : STX   $3FD4
FA34 : LDX   #$FA66
FA37 : STX   $0288
FA3A : LDAB  $102E			| Serial communications status register
FA3D : LDAA  $02,X
FA3F : STAA  $102F			| Serial communications data register
FA42 : STAA  $0287			| SCI checksum
FA45 : LDAB  #$01
FA47 : STAB  $0286
FA4A : LDX   #$4002
FA4D : BSET  $00,X,00010000B
FA50 : LDAA  #$80
FA52 : STAA  $102D			| serial communications control reg #2
FA55 : LDAA  #$88
FA57 : STAA  $102D			| serial communications control reg #2
FA5A : BRA   $FA5A
FA5C : RTS
*
*
*   
FA5D : ORAB  $6601
FA60 : TEST  
FA61 : TEST  
FA62 : IDIV  
FA63 : ORAA  #$02
FA65 : ORAA  #$FA
FA67 : CLR   $02,X
FA69 : TEST  
FA6A : TEST  
FA6B : IDIV  
FA6C : ORAA  #$02
FA6E : ORAA  #$00
FA70 : TEST  
FA71 : FDIV  
FA72 : TEST  
FA73 : BRA   $FA77
FA75 : ORAA  #$02
FA77 : ORAA  #$00
FA79 : TEST  
FA7A : CLV   
FA7B : TEST  
FA7C : TEST  
FA7D : TEST  
FA7E : IDIV  
FA7F : TEST  
FA80 : TEST  
FA81 : TEST  
FA82 : INX   
FA83 : LSRD  
FA84 : NOP  
FA85 : TEST  
FA86 : INX   
FA87 : TEST  
FA88 : TEST  
FA89 : TEST  
FA8A : INX   
FA8B : TEST  
FA8C : TEST  
FA8D : INX   
FA8E : INX   
FA8F : TEST  
FA90 : BRA   $FA92
FA92 : INX   
FA93 : TEST  
FA94 : TEST  
FA95 : TEST  
FA96 : CLC   
FA97 : TEST  
FA98 : TEST  
FA99 : TEST  
FA9A : INX   
FA9B : TEST  
FA9C : TEST  
FA9D : SUBA  #$40
FA9F : SUBB  #$20
FAA1 : SUBA  $60,X
FAA3 : LDAA  $003B			Load A with $003B			| A = M[$003B]
FAA5 : SBA   				Subtract B from A 			| A = A - B
FAA6 : BCC   $FAA9			Branch if Carry is clear to FAA9	|
FAA8 : NEGA  				Negate A				| A is below zero; A = -A 
FAA9 : BPL   $FAAD			Branch if positive to FAAD		| goto FAAD
FAAB : LDAA  #$7F			Load A with 0x7F			| A = 0x7F
FAAD : BCS   $FAB1			Branch if carry is set to FAB1		| 
FAAF : ORAA  #$80			Or A with 0x80
FAB1 : STAA  $010F			Store A with $010F
FAB4 : RTS   				Return from subroutine
*
*
*
FAB5 : LDX   #$0005			Load X with 0x0005			| X = 0x0005					     B<=|
FAB8 : LDD   #$0001			Load D with 0x0001			| D = 0x0001					       =|for (x = 0x0005;x!=0x0000;x--)
FABB : ADDB  $02,X			Add B to M[$(X+02)]			| B = B + M[$(X+02]]				       =|D = D + M[$(X+02)]
FABD : ADCA  #$00			Add A with carry			| A = A + carry					       =|return
FABF : DEX   				Decrenent X				| X = X - 1					       =|
FAC0 : BNE   $FABB			Branch if not equal to FABB		| if (X != 0) then goto FABB			       =|
FAC2 : RTS   				Return					| Return					     E<=|
*
*
*
FAC3 : LDX   #$4000			Load X with 0x4000			| X = 0x4000
FAC6 : SEI   				Set maskable interrupts off		| no interrupts
FAC7 : BCLR  $00,X,00011100B		Clear M[$X], bits 0x1A			| M[$X] = M[$X] && 0xE3
FACA : LDAA  #$00			Load a with 0				| A = 0
FACC : ORAA  $00,X			Or A with M[$X]				| A = A | M[$X]
FACE : STAA  $00,X			Store A to M[$X]			| M[$X] = A
FAD0 : LDAA  #$10			Load A with 0x10			| A = 0x10
FAD2 : STAA  $1030			Store A to $1030			| M[$0x1030] = A    A/D convertor control - Mult channel - Channels 0-3 are live
FAD5 : LDX   #$1000			Load X with 1000			| X = 0x1000
FAD8 : LDAB  #$0C			LoadB with 0x0C				| B = 0x0C
FADA : BRSET $30,X,10000000B,$FAE4	if M[$(X+30)] bit 0x80 set goto FAE4	| if (M[$(X+0x30)] & 0x80) > 0) then goto 0xFAE4
FADE : DECB  				Decrement B				| B -- 
FADF : BNE   $FADA			Branch if B != 0 to FADA		| if (B != 0) then goto 0xFADA				| Wait until A/D conversion is complete
FAE1 : BSET  $0059,00000001B		Set bit 0x01 of $0x0059			| M[$0x0059] = M[$0x0059] | 0x01			| Error - 0x59 bit 0x01
FAE4 : LDAA  $1031			Load A with $1031			| A = M[$0x1031]
FAE7 : BRCLR $005C,00010000B,$FAF1	if M[$(0x005C) bit 0x10 clear goto FAF1 | if (M[$0x005C] & 0x10 == 0) then goto FAF1
FAEB : CMPA  #$AA			Compare A with 0xAA			| Compare A with 0xAA
FAED : BLS   $FAF1			Branch if less than or equal to $FAF1	| if (A <= 0xAA) then goto 0xFAF1
FAEF : LDAA  #$AA			Load A with AA				| A = $0xAA
FAF1 : STAA  $00DC			Store A to M[$00DC]			| M[$0x00DC] = A
FAF3 : LDAA  $1032			Load A from M[$1032]			| A = M[$0x1032]
FAF6 : STAA  $00D4			Store A to M[$00D4]			| M[$0x00D4] = A
FAF8 : LDAA  $1033			Load A from M[$1033]			| A = M[$0x1033]
FAFB : STAA  $00D5			Store A to M[$00D5]			| M[$0x00D5] = A
FAFD : LDAA  $1034			Load A from M[$1034]			| A = M[$0x1034]
FB00 : CLI   				set maskable interrupts on
FB01 : STAA  $00E1			Store A to M[$00E1]			| M[$0x00E1] = A
FB03 : LDAA  #$14			Load A with 0x14			| A = 0x14
FB05 : SEI   				set maskable interrupts off									| $1030 is A/D control
FB06 : STAA  $1030			Store A to $1030			| M[$1030] = A	Sets MULT=1,CC=1,Channels 4-7 are live
FB09 : LDAB  #$0C			Load A with 0c				| A = 0x0C
FB0B : BRSET $30,X,10000000B,$FB15
FB0F : DECB  				Decrement B				| B = B - 1
FB10 : BNE   $FB0B			Branch if not equal to FB0B		| If (B != 0) then goto $FB0B  Wait until A/D is done
FB12 : BSET  $0059,00000001B		Set bit 0x01 of $0059			| 0x59 bit 0x01 seems to be an error flag
FB15 : LDAA  $1031			Load A with $1031			| A = M[$0x1031]
FB18 : STAA  $00D7			Store A to $00D7			| M[$0x00D7] = A
FB1A : LDAA  $1032			Load A with $1032			| A = M[$0x1032]  
FB1D : STAA  $00D8			Store A to $00D8			| M[$0x00D8] = A
FB1F : LDAA  $1033			Load A with $1033			| A = M[$0x1033]
FB22 : STAA  $00D9			Store A to $00D9			| M[$0x00D9] = A
FB24 : LDAA  $1034			Load A with $1034			| A = M[$0x1034]
FB27 : CLI   				Set maskable interrupts on
FB28 : STAA  $00DA			Store A to $00DA			| M[$0x00DA] = A
FB2A : LDAA  $00DC			Load A with $00DC			| A = M[$0x00DC]
FB2C : CMPA  #$1E			Compare A with 0x1E			|
FB2E : BCS   $FB39			Branch if carry is set to FB39		| if (A < 0x1E) then goto FB39
FB30 : CMPA  #$5A			Compare A with 0x5A			
FB32 : BCS   $FB3C			Branch if carry is set to FB3C		| if (A < 0x5A) then goto FB3C
FB34 : BCLR  $004F,00010000B		Clear bit 0x10 of $004F			
FB37 : BRA   $FB3C			Branch Always FB4C
FB39 : BSET  $004F,00010000B		Set bit 0x10 of $004F
FB3C : RTS   				Return from subroutine
*
*
*
FB3D : STAA  $1030			Store A to $1030			| M[$1030] = A  (1030 is A/D control)		        |
FB40 : LDAB  #$0C			Load B with 0x0C			| B = 0x0C					     B<=|
FB42 : BRSET $30,X,10000000B,$FB4C	If bit 0x80 of (X+30) is set go $FB4C   | if (M[$(X+30)] && 0x80) > 0) then goto $FB4C	       =| for (B=0x0C;B>0;B--)	
FB46 : DECB  				Decrement B				| B --						       =|   if M[$(X+30)] && 0x80) > 0) goto $FB4C
FB47 : BNE   $FB42			Branch if not equal to FB42		| if B == 0 then goto FB42			     E<=|
FB49 : BSET  $0059,00000001B		Set 0x01 of $0059			| M[$0x0059] = M[$0x0059] | 0x01		        | M[$0x0059] = M[$0x0059] | 0x01 ! Set an error flag?
FB4C : RTS   				Return 					| Return						| Return
*
*
*
FB4D : LDX   #$4000			Load X with 0x4000			| X = 0x4000
FB50 : BCLR  $00,X,00011100B		clear bit 0x1C of M[$X] 
FB53 : ASLA  				Arith. Shift Left A
FB54 : ASLA  				Arith. Shift Left A
FB55 : ORAA  $00,X			Or A with m[$X]				
FB57 : STAA  $00,X			Store A to M[$X]
FB59 : RTS   				Return from subroutine
*
*
*
FB5A : LDAA  $4006			Load a with $4006
FB5D : EORA  #$80			Exclusive or A with 0x80		| Negate M[$4006]
FB5F : STAA  $4006			Store A with $4006
FB62 : RTS   				Return from subroutine

*
*  XOUT = XIN + ( 256 * AIN - XIN ) * BIN
*
FB63 : PSHB  			| Push B
FB64 : PSHX  			| Push X
FB65 : TSX   			| X = SP (Stack Pointer)
FB66 : SUBA  $00,X		| A -= M[$X]
FB68 : BCS   $FB6D		| if ( A < 0 ) then goto FB6D
FB6A : MUL   			| D = A * B (A is MSB)
FB6B : BRA   $FB70		| goto FB70
FB6D : MUL   			| D = A * B (A is MSB)
FB6E : SUBA  $02,X		| A -= M[$(X + 0x02)]
FB70 : PSHA  			| Push A
FB71 : PSHB  			| Push B
FB72 : LDD   $01,X		| D = M[$(X + 0x01)]
FB74 : NEGB  			| B = 0x00 - B
FB75 : BEQ   $FB7A		| if ( B == 0) then goto FB7A
FB77 : MUL   			| D = A * B (A is MSB)
FB78 : ADCA  #$00		| Add carry to A (proprogate carry)
FB7A : PULB  			| Pull B
FB7B : ABA   			| A += B
FB7C : TAB   			| B = A
FB7D : PULA  			| Pull A
FB7E : ADCA  $00,X		| A += M[$X] (with carry)
FB80 : PULX  			| Pull X
FB81 : INS   			| SP ++
FB82 : RTS   			| Return from subroutine
*
* Routine returns D = AIN (byte)  * M[$X] (word)
*
FB83 : PSHA  			| push A
FB84 : LDAB  $01,X		| B = M[$(X+0x01)]
FB86 : MUL   			| D = A * B
FB87 : ADCA  #$00		| A = A + 0x00 (add carry)
FB89 : PULB  			| pull B
FB8A : PSHA  			| push A
FB8B : LDAA  $00,X		| A = M[$X]
FB8D : MUL   			| D = A * B
FB8E : PSHX  			| push X
FB8F : TSX   			| X = SP
FB90 : ADDB  $02,X		| B = B + M[$(X+0x02)]
FB92 : ADCA  #$00		| A = A + 0x00 (add carry)
FB94 : PULX  			| pull X
FB95 : INS   			| SP ++
FB96 : RTS			| return from subrotine
*
*
*   
FB97 : PSHY 			| push Y 
FB99 : PSHB  			| push B
FB9A : PSHX  			| push X
FB9B : SUBA  $00,X		| A = A - M[$X]  (under 2000 X=0x83B8, above X=0x8C5C)
FB9D : BCC   $FBA0		| if ( A > 0 ) then goot $FBA0
FB9F : CLRA  			| A = 0
FBA0 : SUBB  $01,X		| B = B - M[$X+0x01] 
FBA2 : BCC   $FBA5		| if ( B > 0 ) then goto FBA5
FBA4 : CLRB  			| B = 0
FBA5 : PSHX  			| push X
FBA6 : PULY  			| pull Y     Y = X
FBA8 : PSHA  			| push A
FBA9 : LDAA  #$10		| A = 0x10
FBAB : MUL   			
FBAC : PSHB  
FBAD : TAB   
FBAE : ABX   
FBAF : PULA  
FBB0 : PULB  
FBB1 : PSHA  
FBB2 : LDAA  #$10
FBB4 : MUL   
FBB5 : PSHB  
FBB6 : LDAB  $02,Y
FBB9 : MUL   
FBBA : ABX   
FBBB : PSHX  
FBBC : LDAB  $02,Y
FBBF : ABX   
FBC0 : TSY   
FBC2 : LDD   $03,X
FBC4 : SBA   
FBC5 : LDAB  $03,Y
FBC8 : BCC   $FBD0
FBCA : NEGA  
FBCB : MUL   
FBCC : ADCA  $03,X
FBCE : BRA   $FBD6
FBD0 : MUL   
FBD1 : ADCA  #$00
FBD3 : NEGA  
FBD4 : ADDA  $03,X
FBD6 : PULX  
FBD7 : PSHA  
FBD8 : LDD   $03,X
FBDA : SBA   
FBDB : LDAB  $03,Y
FBDE : BCC   $FBE6
FBE0 : NEGA  
FBE1 : MUL   
FBE2 : ADCA  $03,X
FBE4 : BRA   $FBEC
FBE6 : MUL   
FBE7 : ADCA  #$00
FBE9 : NEGA  
FBEA : ADDA  $03,X
FBEC : PULB  
FBED : PSHA  
FBEE : SBA   
FBEF : LDAB  $02,Y
FBF2 : BCC   $FBFB
FBF4 : NEGA  
FBF5 : MUL   
FBF6 : ADCA  $01,Y
FBF9 : BRA   $FC02
FBFB : MUL   
FBFC : ADCA  #$00
FBFE : NEGA  
FBFF : ADDA  $01,Y
FC02 : INS   
FC03 : PULX  				Pull X
FC04 : PULX  				Pull X
FC05 : PULB  				Pull B
FC06 : PULY  				Pull Y
FC08 : RTS   				Return from Subroutine
*
* Subroutine: Index into arrays.
* 	FC10:   Addresses into array.  X + MSB of (AIN - BIN)*0x10
*		also interpolates based on value, value+1 and what the value of B is.
*	FC14:   Addresses into array   Shift 4 and interpolate.
* 
FC09 : PSHX  				Push X					| Push X
FC0A : PSHB  				Push B					| Push B
FC0B : LDAB  $00,X			Load B with M[$X]			| B = M[$X]
FC0D : INX   				Increment X				| X = X + 1
FC0E : BRA   $FC18			Branch Always FC18			| goto FC18
FC10 : SBA   				Subtract B from A			| A = A - B
FC11 : BCC   $FC14			Branch if no carry FC14			| if (B <= A before subtract) goto FC14
FC13 : CLRA  				Clear A					| A = 0
FC14 : PSHX  				Push X					| Push X
FC15 : PSHB  				Push B					| Push B
FC16 : LDAB  #$10			Load B with 10				| B = 0x10
FC18 : MUL   				Multiple  A X B				| D = A * B
FC19 : PSHB  				Push B					| Push B
FC1A : TAB   				Tab					| B = A
FC1B : ABX   				Add B to X				| X = X + B
FC1C : LDD   $00,X			Load D with $X				| D = M[$X]
FC1E : SBA   				Subtract B from A			| A = A - B
FC1F : PULB  				Pull B					| Pull B
FC20 : BCC   $FC28			Branch if Carry Clear to FC28		| If (A >= B from before sba) goto FC28
FC22 : NEGA  				Negate A				| A is negative.
FC23 : MUL   				Multiply A X B				| D = A * B
FC24 : ADCA  $00,X			Add with carry $X (Carry is msb of B)	| A = A + M[$X]
FC26 : BRA   $FC2E			Branch Always FC2E			| Goto FC2E
FC28 : MUL   				Multiple A X B				| D = A * B
FC29 : ADCA  #$00			Add with carry 0x0 (carry is msb of B)  | A = A + 0
FC2B : NEGA  				Negate A				| A = -A
FC2C : ADDA  $00,X			Add A to M[$X]				| A = A + M[$X]
FC2E : PULB  				Pull B					| Pull B
FC2F : PULX  				Pull X					| Pull X
FC30 : RTS   				Return from subroutine			| Return


Checksum subroutine
	basically input X = starting address  (0x8008)
		  	D = Bytes to checksum (0x7FF8)
		 output Y = checksum
		
	Code is:
		A = ($D / 2) mod 256
		for (i=$X to $X + $D step 2)
		 	{
			if ($A == 0) then 
				{
				stroke the watchdog;
				A = 255
				if ($I == 0) then exit subroutine; # Taken care of by for loop main
				}
			Y = Y + M[$[i]]
			Y = Y + M[$[i+1]]
			}



FC31 : PSHX  				Push X					| Push X
FC32 : PSHB  				Push B					| Push B
FC33 : PSHA  				Push A					| Push A
FC34 : LSRD  				Left Shift D				| D = D / 2					| D = 0x7FF8 / 2
FC35 : PSHA  				Push A					| Push A					| Store MSB out
FC36 : LDY   #$0000			Load Y with 0000			| Y = 0x0000					| Clear Checksum
FC3A : TBA   				Transfer B to A				| A = B						| A = LSB of D
FC3B : BEQ   $FC4B			Branch if equal to FC48			| If (A == 0) then goto FC48			| if LSB is zero stroke watchdog
FC3D : LDAB  $00,X			Load B with $X				| B = M[$x]					
FC3F : ABY   				Add B to Y				| Y = Y + B
FC41 : LDAB  $01,X			Load B with $(X+01)			| B = M[$(X+0x01)]
FC43 : ABY   				Add B to Y				| Y = Y + B					
FC45 : LDAB  #$02			Load B with 0x02			| B = 0x02					|
FC47 : ABX   				Add B to X				| X = X + B					| X = X + 0x02
FC48 : DECA  				Decrement A				| A = A - 1
FC49 : BNE   $FC3D			Branch if not equal to FC3D		| if (A != 0) then goto FC3D 
FC4B : LDAB  #$55			Load B with 55				| B = 0x55					| Hit the watchdog
FC4D : STAB  $103A			Store B	to $103A			| M[$103A] = B					|
FC50 : LDAB  #$AA			Load B with 0xAA			| B = 0xAA					|
FC52 : STAB  $103A			Store B to $103A			| M[$103A] = B					|
FC55 : PSHX  				Push X					| Push X					
FC56 : TSX   				X = SP + 1				| X = SP + 1 (Pointer to value of X)		|
FC57 : DEC   $02,X			Decrement M[X+0x02]			| Decrement Value from push A (FC35)		| 
FC59 : PULX  				Pull X					| Pull X					|
FC5A : BPL   $FC3D			Branch if M[X+0x02] (from FC57) >0 FC3D | 						| If MSB is not zero continue.
FC5C : INS   				SP = SP + 1				| Remove one value from stack and send it to null
FC5D : PULA  				Pull A					| Pull A
FC5E : PULB  				Pull B					| Pull B
FC5F : PULX  				Pull X					| Pull X
FC60 : RTS   				Return					| Return
*
*
*
FC61 : BCC   $FC65
FC63 : CLRA  
FC64 : RTS
*
*
*   
FC65 : MUL   
FC66 : ASLD  
FC67 : BCS   $FC6F
FC69 : TSTB  
FC6A : BPL   $FC71
FC6C : INCA  
FC6D : BNE   $FC71
FC6F : LDAA  #$FF
FC71 : RTS
*
*
*   
FC72 : BSET  $0000,00001000B
FC75 : BRA   $FC75
FC77 : BSET  $0000,00000100B
FC7A : PULA  
FC7B : ORAA  #$40
FC7D : PSHA  
FC7E : RTI   				Return From Interrupt
*
*
*
FC7F : BSET  $0000,00010000B		Set 0x10 of M[$0000]
FC82 : BRA   $FC82			Loop Forever (????)			
FC84 : BSET  $0000,00100000B		Set 0x20 of M[$0000]
FC87 : JMP   $FC93			Goto A000				| Start over
FC8A : BSET  $0000,01000000B		Set 0x40 of M[$0000]
FC8D : JMP   $FC93			Goto A000				| Start over
FC90 : BSET  $0000,10000000B		Set 0x80 of M[$0000]
FC93 : JMP   $A000			Goto A000				| Start over
FC96 : LDAA  #$20			Load A with 0x20			| A = 0x20						| This interrupt is Real-time Interrupt
FC98 : STAA  $1022			Store A to $1022			| M[$1022] = A						| Set Timer Output Compare #3 Interrupt (B36C)
FC9B : LDAA  #$DF			Load A with $Df				| A = 0xDF
FC9D : STAA  $1023			Store A to $1023			| M[$1023] = A 						| Reset timer output compare #3 bit
FCA0 : RTI   				Return from interrupt			|							| Return from interrupt
*
*
*
FCA1 : LDAA  #$03			Load A with 0x03			| A = 0x03
FCA3 : STAA  $1024			Store A to $1024			| M[$1024] = A						| Set timer prescaler to 16
FCA6 : LDAA  #$FF			Load A with 0xFF			| A = 0xFF
FCA8 : STAA  $1025			Store A to $1025			| M[$1025] = A 						| Clear timer interrupt flag #2 (cleared with ff)
FCAB : RTI   				Return From Interrupt
*
*
*
FCAC : STX   $D79B
FCAF : ANDA  #$75
FCB1 : DEC   $61,X
FCB3 : LSLB  
FCB4 : NOTDEF
FCB5 : DECA  
FCB6 : COMA  
FCB7 : PSHX  
FCB8 : DES   
FCB9 : BGE   $FCDD
FCBB : TAB   
FCBC : TEST  
FCBD : STX   $FFFA
FCC0 : SUBB  $CD,X
FCC2 : STS   $B2A7
FCC5 : JSR   $0093
FCC7 : ADCA  #$7F
FCC9 : LSR   $6757
FCCC : MUL   
FCCD : TEST  
FCCE : STX   $FFEA
FCD1 : SBCB  $00C0
FCD3 : SUBD  $A79D
FCD6 : SUBD  $0089
FCD8 : CMPA  #$77
FCDA : TST   $60,X
FCDC : NOTDEF
FCDD : RTS
*
*
*   
FCDE : TEST  
FCDF : TEST  
FCE0 : BPL   $FD1F
FCE2 : NOTDEF
FCE3 : NOTDEF
FCE4 : CLRB  
FCE5 : ASR   $6F,X
FCE7 : ASL   $8089
FCEA : ANDA  $00A1
FCEC : SUBA  $C7E3
FCEF : STX   $B4B3
FCF2 : CMPA  $AFAD
FCF5 : ADDA  $A9,X
FCF7 : EORA  $A6,X
FCF9 : ANDA  $A2,X
FCFB : CMPA  $9F,X
FCFD : JSR   $009C
FCFF : ORAA  $0099
FD01 : STAA  $0095
FD03 : ANDA  $0092
FD05 : CMPA  $008F
FD07 : LDS   #$8C8B
FD0A : ORAA  #$88
FD0C : NOTDEF
FD0D : BITA  #$84
FD0F : SUBD  #$8180
FD12 : JMP   $7D7C
FD15 : DEC   $7978
FD18 : ASR   $7574
FD1B : COM   $7170
FD1E : CLR   $6E,X
FD20 : INC   $6B,X
FD22 : DEC   $69,X
FD24 : ASL   $66,X
FD26 : NOTDEF
FD27 : LSR   $63,X
FD29 : NOTDEF
FD2A : NEG   $5F,X
FD2C : NOTDEF
FD2D : TSTB  
FD2E : INCB  
FD2F : NOTDEF
FD30 : ROLB  
FD31 : LSLB  
FD32 : ASRB  
FD33 : RORB  
FD34 : NOTDEF
FD35 : LSRB  
FD36 : COMB  
FD37 : NOTDEF
FD38 : NEGB  
FD39 : CLRA  
FD3A : NOTDEF
FD3B : TSTA  
FD3C : INCA  
FD3D : NOTDEF
FD3E : DECA  
FD3F : ASLA  
FD40 : ASRA  
FD41 : RORA  
FD42 : NOTDEF
FD43 : LSRA  
FD44 : COMA  
FD45 : NOTDEF
FD46 : NOTDEF
FD47 : SWI   
FD48 : WAI   
FD49 : MUL   
FD4A : PSHX  
FD4B : RTI   
*
*
*
FD4C : ABX   
FD4D : RTS
*
*
*   
FD4E : PULX  
FD4F : PSHB  
FD50 : TXS   
FD51 : DES   
FD52 : PULB  
FD53 : PULA  
FD54 : INS   
FD55 : TSX   
FD56 : BLE   $FD86
FD58 : BGE   $FD85
FD5A : BPL   $FD85
FD5C : BVC   $FD5E
FD5E : NOP  
FD5F : FDIV  
FD60 : IDIV  
FD61 : BRSET $0012,00010011B,$FD79
FD65 : BCLR  $0016,00100001B
FD68 : BHI   $FD8D
FD6A : BCC   $FD91
FD6C : BNE   $FD95
FD6E : BVC   $FDA2
FD70 : PULB  
FD71 : DES   
FD72 : PSHA  
FD73 : NOTDEF
FD74 : NOTDEF
FD75 : COMA  
FD76 : LSRA  
FD77 : NOTDEF
FD78 : RORA  
FD79 : NOTDEF
FD7A : NOTDEF
FD7B : COMB  
FD7C : LSRB  
FD7D : NOTDEF
FD7E : RORB  
FD7F : NOTDEF
FD80 : NOTDEF
FD81 : COM   $64,X
FD83 : NOTDEF
FD84 : ROR   $67,X
FD86 : ASL   $69,X
FD88 : NOTDEF
FD89 : NOTDEF
FD8A : TEST  
FD8B : TEST  
FD8C : TEST  
FD8D : TEST  
FD8E : TEST  
FD8F : TEST  
FD90 : TEST  
FD91 : TEST  
FD92 : TEST  
FD93 : TEST  
FD94 : TEST  
FD95 : TEST  
FD96 : TEST  
FD97 : TEST  
FD98 : TEST  
FD99 : TEST  
FD9A : TEST  
FD9B : TEST  
FD9C : TEST  
FD9D : TEST  
FD9E : TEST  
FD9F : TEST  
FDA0 : TEST  
FDA1 : TEST  
FDA2 : TEST  
FDA3 : TEST  
FDA4 : TEST  
FDA5 : TEST  
FDA6 : TEST  
FDA7 : TEST  
FDA8 : TEST  
FDA9 : TEST  
FDAA : TEST  
FDAB : TEST  
FDAC : TEST  
FDAD : TEST  
FDAE : TEST  
FDAF : TEST  
FDB0 : TEST  
FDB1 : TEST  
FDB2 : TEST  
FDB3 : TEST  
FDB4 : TEST  
FDB5 : TEST  
FDB6 : TEST  
FDB7 : TEST  
FDB8 : TEST  
FDB9 : TEST  
FDBA : TEST  
FDBB : TEST  
FDBC : TEST  
FDBD : TEST  
FDBE : TEST  
FDBF : TEST  
FDC0 : TEST  
FDC1 : TEST  
FDC2 : TEST  
FDC3 : TEST  
FDC4 : TEST  
FDC5 : TEST  
FDC6 : TEST  
FDC7 : TEST  
FDC8 : TEST  
FDC9 : TEST  
FDCA : TEST  
FDCB : TEST  
FDCC : TEST  
FDCD : TEST  
FDCE : TEST  
FDCF : TEST  
FDD0 : TEST  
FDD1 : TEST  
FDD2 : TEST  
FDD3 : TEST  
FDD4 : TEST  
FDD5 : TEST  
FDD6 : TEST  
FDD7 : TEST  
FDD8 : TEST  
FDD9 : TEST  
FDDA : TEST  
FDDB : TEST  
FDDC : TEST  
FDDD : TEST  
FDDE : TEST  
FDDF : TEST  
FDE0 : TEST  
FDE1 : TEST  
FDE2 : TEST  
FDE3 : TEST  
FDE4 : TEST  
FDE5 : TEST  
FDE6 : TEST  
FDE7 : TEST  
FDE8 : TEST  
FDE9 : TEST  
FDEA : TEST  
FDEB : TEST  
FDEC : TEST  
FDED : TEST  
FDEE : TEST  
FDEF : TEST  
FDF0 : TEST  
FDF1 : TEST  
FDF2 : TEST  
FDF3 : TEST  
FDF4 : TEST  
FDF5 : TEST  
FDF6 : TEST  
FDF7 : TEST  
FDF8 : TEST  
FDF9 : TEST  
FDFA : TEST  
FDFB : TEST  
FDFC : TEST  
FDFD : TEST  
FDFE : TEST  
FDFF : TEST  
FE00 : TEST  
FE01 : TEST  
FE02 : TEST  
FE03 : TEST  
FE04 : TEST  
FE05 : TEST  
FE06 : TEST  
FE07 : TEST  
FE08 : TEST  
FE09 : TEST  
FE0A : TEST  
FE0B : TEST  
FE0C : TEST  
FE0D : TEST  
FE0E : TEST  
FE0F : TEST  
FE10 : TEST  
FE11 : TEST  
FE12 : TEST  
FE13 : TEST  
FE14 : TEST  
FE15 : TEST  
FE16 : TEST  
FE17 : TEST  
FE18 : TEST  
FE19 : TEST  
FE1A : TEST  
FE1B : TEST  
FE1C : TEST  
FE1D : TEST  
FE1E : TEST  
FE1F : TEST  
FE20 : TEST  
FE21 : TEST  
FE22 : TEST  
FE23 : TEST  
FE24 : TEST  
FE25 : TEST  
FE26 : TEST  
FE27 : TEST  
FE28 : TEST  
FE29 : TEST  
FE2A : TEST  
FE2B : TEST  
FE2C : TEST  
FE2D : TEST  
FE2E : TEST  
FE2F : TEST  
FE30 : TEST  
FE31 : TEST  
FE32 : TEST  
FE33 : TEST  
FE34 : TEST  
FE35 : TEST  
FE36 : TEST  
FE37 : TEST  
FE38 : TEST  
FE39 : TEST  
FE3A : TEST  
FE3B : TEST  
FE3C : TEST  
FE3D : TEST  
FE3E : TEST  
FE3F : TEST  
FE40 : TEST  
FE41 : TEST  
FE42 : TEST  
FE43 : TEST  
FE44 : TEST  
FE45 : TEST  
FE46 : TEST  
FE47 : TEST  
FE48 : TEST  
FE49 : TEST  
FE4A : TEST  
FE4B : TEST  
FE4C : TEST  
FE4D : TEST  
FE4E : TEST  
FE4F : TEST  
FE50 : TEST  
FE51 : TEST  
FE52 : TEST  
FE53 : TEST  
FE54 : TEST  
FE55 : TEST  
FE56 : TEST  
FE57 : TEST  
FE58 : TEST  
FE59 : TEST  
FE5A : TEST  
FE5B : TEST  
FE5C : TEST  
FE5D : TEST  
FE5E : TEST  
FE5F : TEST  
FE60 : TEST  
FE61 : TEST  
FE62 : TEST  
FE63 : TEST  
FE64 : TEST  
FE65 : TEST  
FE66 : TEST  
FE67 : TEST  
FE68 : TEST  
FE69 : TEST  
FE6A : TEST  
FE6B : TEST  
FE6C : TEST  
FE6D : TEST  
FE6E : TEST  
FE6F : TEST  
FE70 : TEST  
FE71 : TEST  
FE72 : TEST  
FE73 : TEST  
FE74 : TEST  
FE75 : TEST  
FE76 : TEST  
FE77 : TEST  
FE78 : TEST  
FE79 : TEST  
FE7A : TEST  
FE7B : TEST  
FE7C : TEST  
FE7D : TEST  
FE7E : TEST  
FE7F : TEST  
FE80 : TEST  
FE81 : TEST  
FE82 : TEST  
FE83 : TEST  
FE84 : TEST  
FE85 : TEST  
FE86 : TEST  
FE87 : TEST  
FE88 : TEST  
FE89 : TEST  
FE8A : TEST  
FE8B : TEST  
FE8C : TEST  
FE8D : TEST  
FE8E : TEST  
FE8F : TEST  
FE90 : TEST  
FE91 : TEST  
FE92 : TEST  
FE93 : TEST  
FE94 : TEST  
FE95 : TEST  
FE96 : TEST  
FE97 : TEST  
FE98 : TEST  
FE99 : TEST  
FE9A : TEST  
FE9B : TEST  
FE9C : TEST  
FE9D : TEST  
FE9E : TEST  
FE9F : TEST  
FEA0 : TEST  
FEA1 : TEST  
FEA2 : TEST  
FEA3 : TEST  
FEA4 : TEST  
FEA5 : TEST  
FEA6 : TEST  
FEA7 : TEST  
FEA8 : TEST  
FEA9 : TEST  
FEAA : TEST  
FEAB : TEST  
FEAC : TEST  
FEAD : TEST  
FEAE : TEST  
FEAF : TEST  
FEB0 : TEST  
FEB1 : TEST  
FEB2 : TEST  
FEB3 : TEST  
FEB4 : TEST  
FEB5 : TEST  
FEB6 : TEST  
FEB7 : TEST  
FEB8 : TEST  
FEB9 : TEST  
FEBA : TEST  
FEBB : TEST  
FEBC : TEST  
FEBD : TEST  
FEBE : TEST  
FEBF : TEST  
FEC0 : TEST  
FEC1 : TEST  
FEC2 : TEST  
FEC3 : TEST  
FEC4 : TEST  
FEC5 : TEST  
FEC6 : TEST  
FEC7 : TEST  
FEC8 : TEST  
FEC9 : TEST  
FECA : TEST  
FECB : TEST  
FECC : TEST  
FECD : TEST  
FECE : TEST  
FECF : TEST  
FED0 : TEST  
FED1 : TEST  
FED2 : TEST  
FED3 : TEST  
FED4 : TEST  
FED5 : TEST  
FED6 : TEST  
FED7 : TEST  
FED8 : TEST  
FED9 : TEST  
FEDA : TEST  
FEDB : TEST  
FEDC : TEST  
FEDD : TEST  
FEDE : TEST  
FEDF : TEST  
FEE0 : TEST  
FEE1 : TEST  
FEE2 : TEST  
FEE3 : TEST  
FEE4 : TEST  
FEE5 : TEST  
FEE6 : TEST  
FEE7 : TEST  
FEE8 : TEST  
FEE9 : TEST  
FEEA : TEST  
FEEB : TEST  
FEEC : TEST  
FEED : TEST  
FEEE : TEST  
FEEF : TEST  
FEF0 : TEST  
FEF1 : TEST  
FEF2 : TEST  
FEF3 : TEST  
FEF4 : TEST  
FEF5 : TEST  
FEF6 : TEST  
FEF7 : TEST  
FEF8 : TEST  
FEF9 : TEST  
FEFA : TEST  
FEFB : TEST  
FEFC : TEST  
FEFD : TEST  
FEFE : TEST  
FEFF : TEST  
FF00 : TEST  
FF01 : TEST  
FF02 : TEST  
FF03 : TEST  
FF04 : TEST  
FF05 : TEST  
FF06 : TEST  
FF07 : TEST  
FF08 : TEST  
FF09 : TEST  
FF0A : TEST  
FF0B : TEST  
FF0C : TEST  
FF0D : TEST  
FF0E : TEST  
FF0F : TEST  
FF10 : TEST  
FF11 : TEST  
FF12 : TEST  
FF13 : TEST  
FF14 : TEST  
FF15 : TEST  
FF16 : TEST  
FF17 : TEST  
FF18 : TEST  
FF19 : TEST  
FF1A : TEST  
FF1B : TEST  
FF1C : TEST  
FF1D : TEST  
FF1E : TEST  
FF1F : TEST  
FF20 : TEST  
FF21 : TEST  
FF22 : TEST  
FF23 : TEST  
FF24 : TEST  
FF25 : TEST  
FF26 : TEST  
FF27 : TEST  
FF28 : TEST  
FF29 : TEST  
FF2A : TEST  
FF2B : TEST  
FF2C : TEST  
FF2D : TEST  
FF2E : TEST  
FF2F : TEST  
FF30 : TEST  
FF31 : TEST  
FF32 : TEST  
FF33 : TEST  
FF34 : TEST  
FF35 : TEST  
FF36 : TEST  
FF37 : TEST  
FF38 : TEST  
FF39 : TEST  
FF3A : TEST  
FF3B : TEST  
FF3C : TEST  
FF3D : TEST  
FF3E : TEST  
FF3F : TEST  
FF40 : TEST  
FF41 : TEST  
FF42 : TEST  
FF43 : TEST  
FF44 : TEST  
FF45 : TEST  
FF46 : TEST  
FF47 : TEST  
FF48 : TEST  
FF49 : TEST  
FF4A : TEST  
FF4B : TEST  
FF4C : TEST  
FF4D : TEST  
FF4E : TEST  
FF4F : TEST  
FF50 : TEST  
FF51 : TEST  
FF52 : TEST  
FF53 : TEST  
FF54 : TEST  
FF55 : TEST  
FF56 : TEST  
FF57 : TEST  
FF58 : TEST  
FF59 : TEST  
FF5A : TEST  
FF5B : TEST  
FF5C : TEST  
FF5D : TEST  
FF5E : TEST  
FF5F : TEST  
FF60 : TEST  
FF61 : TEST  
FF62 : TEST  
FF63 : TEST  
FF64 : TEST  
FF65 : TEST  
FF66 : TEST  
FF67 : TEST  
FF68 : TEST  
FF69 : TEST  
FF6A : TEST  
FF6B : TEST  
FF6C : TEST  
FF6D : TEST  
FF6E : TEST  
FF6F : TEST  
FF70 : TEST  
FF71 : TEST  
FF72 : TEST  
FF73 : TEST  
FF74 : TEST  
FF75 : TEST  
FF76 : TEST  
FF77 : TEST  
FF78 : TEST  
FF79 : TEST  
FF7A : TEST  
FF7B : TEST  
FF7C : TEST  
FF7D : TEST  
FF7E : TEST  
FF7F : TEST  
FF80 : TEST  
FF81 : TEST  
FF82 : TEST  
FF83 : TEST  
FF84 : TEST  
FF85 : TEST  
FF86 : TEST  
FF87 : TEST  
FF88 : TEST  
FF89 : TEST  
FF8A : TEST  
FF8B : TEST  
FF8C : TEST  
FF8D : TEST  
FF8E : TEST  
FF8F : TEST  
FF90 : TEST  
FF91 : TEST  
FF92 : TEST  
FF93 : TEST  
FF94 : TEST  
FF95 : TEST  
FF96 : TEST  
FF97 : TEST  
FF98 : TEST  
FF99 : TEST  
FF9A : TEST  
FF9B : TEST  
FF9C : TEST  
FF9D : TEST  
FF9E : TEST  
FF9F : TEST  
FFA0 : ADDB  $3DFB
FFA3 : TSTA  
FFA4 : ADDB  $5A00
FFA7 : ASLA  
FFA8 : IDIV  
FFA9 : ORAA  #$00
FFAB : TEST  
FFAC : TEST  
FFAD : TEST  
FFAE : TEST  
FFAF : TEST  
FFB0 : TEST  
FFB1 : TEST  
FFB2 : TEST  
FFB3 : TEST  
FFB4 : TEST  
FFB5 : TEST  
FFB6 : ORAA  #$2F
FFB8 : NOP  
FFB9 : PULB  
FFBA : TEST  
FFBB : TEST  
FFBC : TEST  
FFBD : TEST  
FFBE : TEST  
FFBF : TEST  
FFC0 : LDD   $ABFC
FFC3 : ADDA  $FC,X
FFC5 : ADDA  $FC,X
FFC7 : ADDA  $FC,X
FFC9 : ADDA  $FC,X
FFCB : ADDA  $FC,X
FFCD : ADDA  $FC,X
FFCF : ADDA  $FC,X
FFD1 : ADDA  $FC,X
FFD3 : ADDA  $FC,X
FFD5 : ADDA  $F5,X
FFD7 : STAB  $00F5
FFD9 : NOTDEF
FFDA : LDD   $A1FC
FFDD : CMPA  $FC,X
FFDF : CMPA  $FC,X
FFE1 : LDAA  $00A6
FFE3 : NOTDEF
FFE4 : SUBD  $6CB3
FFE7 : NOTDEF
FFE8 : ANDA  $46B2
FFEB : ASLA  
FFEC : LDD   $96B4
FFEF : BHI   $FFED
FFF1 : LDAA  $00B0
FFF3 : BCLR  $00FC,01110111B
FFF6 : LDD   $72FC
FFF9 : CLR   $FC84
FFFC : LDD   $8AFC
FFFF : TEST