ADC .ADC $.ADC $..,ADC $...ADC $....,ADC $....,ADC ($..), ADC ($..,X AND . AND $. AND $..,AND $... ..``105`69`01101001`ADD ACCUMULATOR WITH CARRY`A+M+C=A,C ADDS SPECIFIED NUMBER, IN DATA BUFFER, TO NUMBER IN ACCUMULATOR LEAVING THE RESULTS IN THE ACCUMULATOR AND SETTING THE CARRY FLAG IF RESULT WAS GREATER THAN EIGHT BITS.``Y`Y`N`N`N`Y`Y $..``101`65`01100101`ADD ACCUMULATOR WITH CARRY`A+M+C=A,C ADDS NUMBER SPECIFIED BY A ZERO PAGE ADDRESS TO NUMBER IN ACCUMULATOR LEAVING THE RESULTS IN THE ACCUMULATOR AND SETTING THE CARRY FLAG IF RESULT WAS GREATER THAN EIGHT BITS.``Y`Y`N`N`N`Y`YAND SETTING THE CARRY FLAG IF RESULT WAS GREATER THAN EIGHT BITS. ``Y`Y`N`N`N`Y`YTHE CARRY FLAG IF RESULT EXCEDED EIGHT BITS.  $..,X``117`75`01110101`ADD ACCUMULATOR WITH CARRY, ZERO PAGE INDEXED`A+M+C=A,C TAKES A NUMBER FOUND IN MEMORY AND ADDS IT TO NUMBER IN ACCUMULATOR LEAVING THE RESULTS IN THE ACCUMULATOR AND SETTING THE CARRY FLAG IF RESULT EXCEDED EIGHT BITS. $....``109`6D`01101101`ADD ACCUMULATOR WITH CARRY`A+M+C=A,C TAKES A NUMBER FOUND IN MEMORY DESIGNATED BY ABSOLUTE (SIXTEEN BIT) ADDRES IN COMMAND AND ADDS IT TO NUMBER IN ACCUMULATOR LEAVING THE RESULTS IN THE ACCUMULATOR AND SETTING THE CARRY FLAG IF RESULT EXCEDED EIGHT BITS.``Y`Y`N`N`N`Y`YULATOR AND SETTING THE CARRY FLAG IF RESULT EXCEDED EIGHT BITS. .``Y`Y`N`N`N`Y`YHE CARRY FLAG IF RESULT EXCEDED EIGHT BITS.  $....,X``125`7D`01111101`ADD ACCUMULATOR WITH CARRY, ABSOLUTE INDEXED`A+M+C=A,C TAKES A NUMBER FOUND IN MEMORY AND ADDS IT TO NUMBER IN ACCUMULATOR LEAVING THE RESULTS IN THE ACCUMULATOR AND SETTING THE CARRY FLAG IF RESULT EXCEDED EIGHT BITS  $....,Y``121`79`01111001`ADD ACCUMULATOR WITH CARRY, ABSOLUTE INDEXED`A+M+C=A,C TAKES A NUMBER FOUND IN MEMORY AND ADDS IT TO NUMBER IN ACCUMULATOR LEAVING THE RESULTS IN THE ACCUMULATOR AND SETTING THE CARRY FLAG IF RESULT EXCEDED EIGHT BITS.``Y`Y`N`N`N`Y`YHE CARRY FLAG IF RESULT EXCEDED EIGHT BITS. PLUS THE NUMBER IN THE X REGISTER``Y`N`N`N`N`Y`NMBER IN THE COMMAND PLUS THE NUMBER IN THE X REGISTER    ($..),Y``113`71`01110001`ADD ACCUMULATOR WITH CARRY, INDIRECT INDEXED`A+M+C=A,C ADDS THE ACCUMULATOR TO MEMORY. ARRY IS SET IF THE RESULT IS GREATER THAN EIGHT BITS CAN HANDLE``Y`Y`N`N`N`Y`YESULT IS GREATER THAN EIGHT BITS CAN HANDLE    ($..,X)``097`61`01100001`ADD ACCUMULATOR WITH CARRY, INDEXED INDIRECT`A+M+C=A,C ADDS NUMBER IN ACCUMULATOR TO NUMBER IN MEMORY, IF THE RESULT WAS GREATER THAN EIGHT BITS, SETS CARRY FLAG``Y`Y`N`N`N`Y`YAS GREATER THAN EIGHT BITS, SETS CARRY F   ..``041`29`00101001`AND ACCUMULATOR, IMMEDIATE`A*M=A, ACCUMULATOR WILL HOLD THE RESULT OF A LOGICAL ND OPERATION BETWEEN THE NUMBER IN THE ACCUMULATOR AND THE NUMBER SPECIFIED BY THE COMMAND.``Y`N`N`N`N`Y`NUMBER IN THE ACCUMULATOR AND THE    $..``037`25`00100101`AND ACCUMULATOR, ZERO PAGE`A*M=A, ACCUMULATOR WILL HOLD THE RESULT OF A LOGICAL ND OPERATION BETWEEN THE NUMBER IN THE ACCUMULATOR AND THE NUMBER FOUND AT THE ZERO PAGE ADDRESS SPECIFIED BY THE COMMAND.``Y`N`N`N`N`Y`NE   $..,X``053`35`00110101`AND ACCUMULATOR, ZERO PAGE INDEXED`A*M=A, ACCUMULATOR WILL HOLD THE RESULT OF A LOGICAL ND OPERATION BETWEEN THE NUMBER IN THE ACCUMULATOR AND A MEMORY LOCATION``Y`N`N`N`N`Y`NEEN THE NUMBER IN THE ACCUMULATOR AND A ME $....``045`2D`00101101`AND ACCUMULATOR, ABSOLUTE`A*M=A, ACCUMULATOR WILL HOLD THE RESULT OF A LOGICAL ND OPERATION BETWEEN THE NUMBER IN THE ACCUMULATOR AND THE CONTENTS OF THE ADDRESS SPECIFIED``Y`N`N`N`N`Y`NBER IN THE ACCUMULATOR AND THE   $....,X``061`3D`00111101`AND ACCUMULATOR, ABSOLUTE INDEXED`A*M=A, ACCUMULATOR WILL HOLD THE RESULT OF A LOGICAL ND OPERATION BETWEEN THE NUMBER IN THE ACCUMULATOR AND THE CONTENTS OF MEMORY WHOSE ADDRESS IS EQUAL TO THE NUMBER IN THE COMMAND $....,Y``057`39`00111001`AND ACCUMULATOR, ABSOLUTE INDEXED`A*M=A, ACCUMULATOR WILL HOLD THE RESULT OF A LOGICAL ND OPERATION BETWEEN THE NUMBER IN THE ACCUMULATOR AND THE CONTENTS OF MEMORY WHOSE ADDRESS IS EQUAL TO THE NUMBER IN THE COMMAND PLUS THE NUMBER IN THE Y REGISTER``Y`N`N`N`N`Y`NMBER IN THE COMMAND PLUS THE NUMBER IN THE Y REGISTER ``024`18`00011000`CLEAR CARRY`CLEARS, ZEROS, THE CARRY FLAG``N`N`N`N`N`N`Y  ($..),Y``049`31`00110001`AND ACCUMULATOR WITH MEMORY, INDEXED INDIRECT`A*M=A, ERFORMS A LOGICAL OPERATION BETWEEN MEMORY AND ACCUMULATOR LEAVING RESULT IN ACCUMULATOR.``Y`N`N`N`N`Y`NACCUMULATOR LEAVING RESULT IN ACCUMULATOR.  ($..,X)``033`21`00100001`AND ACCUMULATOR WITH MEMORY, INDIRECT INDEXED`A*M=A, ERFORMS LOGICAL OPERATION BETWEEN ACCUMULATOR AND MEMORY, LEAVES RESULT IN ACCUMULATOR.``Y`N`N`N`N`Y`N AND MEMORY, LEAVES RESULT IN ACCUMULATOR. ``010`0A`00001010`ARITHMATIC SHIFT LEFT, ACCUMULATOR`SHIFTS ALL THE BITS IN THE ACCUMULATOR TO THE LEFT. LACES THE HIGHEST BIT IN THE CARRY FLAG REGISTER. HIFTS A ZERO INTO THE LOWEST BIT.``Y`N`N`N`N`Y`Y THE CARRY FLAG REGISTER. HIFTS A $..``006`06`00000110`ARITHMATIC SHIFT LEFT, ZERO PAGE ADDRESS`SHIFTS ALL THE BITS AT THE STATED ZERO PAGE ADDRESS TO THE LEFT. LACES THE HIGHEST BIT IN THE CARRY FLAG REGISTER. HIFTS A ZERO INTO THE LOWEST BIT.``Y`N`N`N`N`Y`Y FLAG REGIST $..,X``022`16`00010110`ARITHMATIC SHIFT LEFT, ZERO PAGE ADDRESS,INDEXED`SHIFTS ALL THE BITS AT MEMORY LOCATION TO THE LEFT. LACES THE HIGHEST BIT IN THE CARRY FLAG REGISTER. HIFTS A ZERO INTO THE LOWEST BIT.``Y`N`N`N`N`Y`YSTER. HIFTS A $....``014`0E`00001110`ARITHMATIC SHIFT LEFT, ABSOLUTE ADDRESS`SHIFTS ALL THE BITS AT THE STATED SIXTEEN BIT ADDRESS TO THE LEFT. LACES THE HIGHEST BIT IN THE CARRY FLAG REGISTER. HIFTS A ZERO INTO THE LOWEST BIT.``Y`N`N`N`N`Y`YFLAG REGI $....,X``030`1E`00011110`ARITHMATIC SHIFT LEFT, INDEXED`SHIFTS ALL THE BITS AT THE MEMORY LOCATION TO THE LEFT. LACES THE HIGHEST BIT IN THE CARRY FLAG REGISTER. HIFTS A ZERO INTO THE LOWEST BIT.``Y`N`N`N`N`Y`Y CARRY FLAG REGISTER. HIF  AND $....,AND $....,AND ($..),AND ($..,XASASL $.ASL $..,ASL $...ASL $....,BCBCBEBIT $.BIT $...vAND $....,BMCMP ($..,XEOR $.INLDX .LSR $...PLSBC $..,STA $....,STA $..,STA $...STA $....,``144`90`10010000`BRANCH IF CARRY CLEARED`TESTS THE CARRY FLAG. F CLEARED, EQUAL TO ZERO, IT WILL ADD THE NUMBER IN THE COMMAND TO THE PROGRAM COUNTER. F SET WILL CONTINUE AT NEXT CONSECUTIVE COMMAND IN PROGRAM.``N`N`N`N`N`N`NM COUNTER. ``176`B0`10110000`BRANCH IF CARRY SET`TESTS THE CARRY FLAG. F SET, EQUAL TO ONE, IT WILL ADD THE NUMBER IN THE COMMAND TO THE PROGRAM COUNTER. F NOT SET WILL CONTINUE AT NEXT CONSECUTIVE COMMAND IN PROGRAM.``N`N`N`N`N`N`NM COUNTER. F NO``240`F0`11110000`BRANCH IF EQUAL`TESTS THE ZERO FLAG. F SET, EQUAL TO ONE, IT WILL ADD THE NUMBER IN THE COMMAND TO THE PROGRAM COUNTER. F CLEARED WILL CONTINUE AT NEXT CONSECUTIVE COMMAND IN PROGRAM.``N`N`N`N`N`N`NOGRAM COUNTER. F CLE $..``036`24`00100100`TESTS BITS 6&7, ZERO PAGE`TRANSFERS THE CONTENTS OF BITS 6 AND 7 OF A ZERO PAGE MEMORY REGISTER TO THE FLAG REGISTERS. IT 7 GOES INTO NEG FLAG. IT 6 GOES INTO THE OVERFLOW FLAG. * N ND IS ALSO PERFORMED BETWEEN THE ACCUMULATOR AND THE SPECIFIED MEMORY WITH THE RESULTS`AFFECTING THE ZERO FLAG. HIS COMMAND IS USEFUL FOR NEGATIVE NUMBER MATH.`Y`Y`N`N`N`Y`NECTING THE ZERO FLAG. HIS COMMAND IS USEFUL FOR NEGATIVE NUMBER MATH.  $....``044`2C`00101100`TESTS BITS 6&7, ABSOLUTE`TRANSFERS THE CONTENTS OF BITS 6 AND 7 OF AN ABSOLUTE MEMORY REGISTER TO THE FLAG REGISTERS. IT 7 GOES INTO NEG FLAG. IT 6 GOES INTO THE OVERFLOW FLAG. * N ND IS ALSO PERFORMED BETWEEN THE ACCUMULATOR AND THE SPECIFIED MEMORY WITH THE RESULTS`AFFECTING THE ZERO FLAG. HIS COMMAND IS USEFUL FOR NEGATIVE NUMBER MATH.`Y`Y`N`N`N`Y`NCTING THE ZERO FLAG. HIS COMMAND IS USEFUL FOR NEGATIVE NUMBER MATH. ``048`30`00110000`BRANCH IF MINUS`TESTS THE NEGATIVE FLAG. F SET, EQUAL TO ONE, IT WILL ADD THE NUMBER IN THE COMMAND TO THE PROGRAM COUNTER. F CLEARED WILL CONTINUE AT NEXT CONSECUTIVE COMMAND IN PROGRAM.``N`N`N`N`N`N`NOGRAM COUNTER. F``208`D0`11010000`BRANCH IF NOT EQUAL`TESTS THE ZERO(EQUAL)FLAG. F CLEARED, EQUAL TO ZERO, IT WILL ADD THE NUMBER IN THE COMMAND TO THE PROGRAM COUNTER. F SET, IT WILL CONTINUE AT NEXT CONSECUTIVE COMMAND IN PROGRAM.``N`N`N`N`N`N`NM COUNT``016`10`00010000`BRANCH IF PLUS`TESTS THE NEGATIVE FLAG. F SET, EQUAL TO ONE, IT WILL ADD THE NUMBER IN THE COMMAND TO THE PROGRAM COUNTER. F CLEARED, IT WILL CONTINUE AT NEXT CONSECUTIVE COMMAND IN PROGRAM.``N`N`N`N`N`N`NAM COUNTER. F ``000`00`00000000`BREAK`STOPS EXECUTION OF PROGRAM AND GENERATES A FALSE INTERRUPT THAT FORCES THE CPU TO EXECUTE A SPECIAL ROUTINE`ROGRAM EXECUTED WILL AFFECT IRQ FLAG.`N`N`Y`N`N`N`NUPT THAT FORCES THE CPU TO EXECUTE A SPECIAL ROUTINE   ``080`50`01010000`BRANCH IF OVERFLOW CLEAR`TESTS THE OVERFLOW FLAG. F CLEARED, EQUAL TO ZERO, IT WILL ADD THE NUMBER IN THE COMMAND TO THE PROGRAM COUNTER. F SET, WILL CONTINUE AT NEXT CONSECUTIVE COMMAND IN PROGRAM.``N`N`N`N`N`N`NCOUNTER  ``112`70`01110000`BRANCH IF OVERFLOW SET`TESTS THE OVERFLOW FLAG. F SET, EQUAL TO ONE, IT WILL ADD THE NUMBER IN THE COMMAND TO THE PROGRAM COUNTER. F CLEARED, WILL CONTINUE AT NEXT CONSECUTIVE COMMAND IN PROGRAM.``N`N`N`N`N`N`NUNTER. F ``216`D8`11011000`CLEAR DECIMAL`CLEARS, ZEROS, THE DECIMAL FLAG. REVENTS BINARY CODED DECIMAL MATH``N`N`N`Y`N`N`N ``184`B8`10111000`CLEAR OVERFLOW`CLEARS, ZEROS, THE OVERFLOW FLAG.``N`Y`N`N`Y`N`N   ``088`58`01011000`CLEAR INTERRUPT INHIBIT`CLEARS, ZEROS, THE INTERRUPT INHIBIT FLAG. LLOWS THE CPU TO RESPOND TO AN INTERRUPT SIGNAL``N`N`N`N`Y`N`NNTERRUPT INHIBIT FLAG. LLOWS THE CPU TO RESPOND TO AN INTERRUPT SIGNAL   ..``201`C9`11001001`COMPARE ACCUMULATOR WITH MEMORY, IMMEDIATE`A-M,C COMPARE(SUBTRACT) SPECIFIED NUMBER, IN DATA BUFFER, FROM NUMBER IN ACCUMULATOR``Y`N`N`N`N`Y`YUMBER, IN DATA BUFFER, FROM NUMBER IN ACCUMULATOR  $..``197`C5`11000101`COMPARE ACCUMULATOR WITH ZERO PAGE MEMORY`A-M, COMPARE(SUBTRACT) NUMBER FOUND AT ZERO PAGE ADDRESS FROM NUMBER IN ACCUMULATOR``Y`N`N`N`N`Y`YND AT ZERO PAGE ADDRESS FROM NUMBER IN ACCUMULATOR  $..,X``213`D5`11010101`COMPARE ACCUMULATOR WITH MEMORY, ZERO PAGE INDEXED`A-M, COMPARES ACCUMULATOR WITH MEMORY, RESULT AFFECT FLAGS. CCUMULTOR NOT CHANGED.``Y`N`N`N`N`Y`Y AFFECT FLAGS. CCUMULTOR NOT CHANGED.  $....``205`CD`11001101`COMPARE ACCUMULATOR WITH MEMORY, ABSOLUTE`A-M,C TAKES A NUMBER FOUND IN MEMORY DESIGNATED BY ABSOLUTE (SIXTEEN BIT) ADDRESS IN COMMAND AND SUBTRACTS IT FROM NUMBER IN ACCUMULATOR``Y`N`N`N`N`Y`YMAND AND SUBTRACTS IT FRO  BMBNBPBR BV BV CLCL CL CL CMP .CMP $.CMP $..,CMP $...CMP $....,CMP $....,CMP ($..), $....,X``221`DD`11011101`COMPARE ACCUMULATOR WITH MEMORY, INDEXED`A-M, OMPARES ACCUMULATOR WITH MEMORY. ESULTS CHANGE FLAGS``Y`N`N`N`N`Y`Y ACCUMULATOR WITH MEMORY. ESULTS CHANGE FLAGS  $....,Y``217`D9`11011001`COMPARE ACCUMULATOR WITH MEMORY, INDEXED`A-M, TAKES A NUMBER FOUND IN THE MEMORY AND SUBTRACTS IT FROM NUMBER IN ACCUMULATOR. ESULTS REPORTED BY FLAGS. CCUMULATOR NOT AFFECTED.``Y`N`N`N`N`Y`YTS REPORTED BY FLAGS.  ($..),Y``209`D1`11010001`COMPARE ACCUMULATOR WITH MEMORY, INDIRECT INDEXED`A-M, OMPARES ACCUMULATOR WITH MEMORY REPORTING RESULTS WITH FLAGS.``Y`N`N`N`N`Y`YH MEMORY REPORTING RESULTS WITH FLAGS.  ($..,X)``193`C1`11000001`COMPARE ACCUMULATOR WITH MEMORY, INDEXED INDIRECT`A-M COMPARE NUMBER IN ACCUMULATOR WITH MEMORY. OMPARE SUBTRACTS MEMORY FROM ACCUMULATOR AFFECTING FLAGS FOR RESULTS``Y`N`N`N`N`Y`YCCUMULATOR AFFECTING FLAGS FOR RES ..``224`E0`11100000`COMPARE X REGISTER WITH MEMORY, IMMEDIATE`X-M, OMPARE CONTENTS OF X REGISTER WITH NUMBER, IN DATA BUFFER. FFECTS FLAGS``Y`N`N`N`N`Y`YGISTER WITH NUMBER, IN DATA BUFFER. FFECTS FLAGS  $..``228`E4`11100100`COMPARE X REGISTER WITH MEMORY, ZERO PAGE`X-M, OMPARE CONTENTS OF X REGISTER WITH ZERO PAGE MEMORY. FFECTS FLAGS``Y`N`N`N`N`Y`YF X REGISTER WITH ZERO PAGE MEMORY. FFECTS FLAGS  $....``236`EC`11101100`COMPARE X REGISTER WITH MEMORY, ABSOLUTE`X-M, OMPARE CONTENTS OF X REGISTER WITH ABSOLUTE MEMORY. FFECTS FLAGS``Y`N`N`N`N`Y`YF X REGISTER WITH ABSOLUTE MEMORY. FFECTS FLAGS  ..``192`C0`11000000`COMPARE Y REGISTER WITH MEMORY, IMMEDIATE`Y-M, OMPARE CONTENTS OF Y REGISTER WITH NUMBER, IN DATA BUFFER. FFECTS FLAGS``Y`N`N`N`N`Y`YGISTER WITH NUMBER, IN DATA BUFFER. FFECTS FLAGS  $..``196`C4`11000100`COMPARE Y REGISTER WITH MEMORY, ZERO PAGE`Y-M, OMPARE CONTENTS OF X REGISTER WITH ZERO PAGE MEMORY. FFECTS FLAGS``Y`N`N`N`N`Y`YF X REGISTER WITH ZERO PAGE MEMORY. FFECTS FLAGS  $....``204`CC`11001100`COMPARE Y REGISTER WITH MEMORY, ABSOLUTE`Y-M, OMPARE CONTENTS OF X REGISTER WITH ABSOLUTE MEMORY. FFECTS FLAGS``Y`N`N`N`N`Y`YF X REGISTER WITH ABSOLUTE MEMORY. FFECTS FLAGS  $..``198`C6`11000110`DECREASE MEMORY, ZERO PAGE`M=M-1 UBTRACT ONE FROM MEMORY. T ZERO WILL LOOP ARROUND TO #$FF``Y`N`N`N`N`Y`N=M-1 UBTRACT ONE FROM MEMORY. T ZERO WILL LOOP ARROUND TO #$FF  $..,X``214`D6`11010110`DECREASE MEMORY, ZERO PAGE, INDEXED`M=M-1 UBTRACT ONE FROM MEMORY. T ZERO WILL LOOP ARROUND TO #$FF``Y`N`N`N`N`Y`NCT ONE FROM MEMORY. T ZERO WILL LOOP ARROUND TO #$FF   CMP ($..,XCPX .CPX $.CPX $...CPY .CPY $.CPY $...DEC $.DEC $..,DEC $...DEC $....,DEDEEOR . $....``206`CE`11001110`DECREASE MEMORY, ABSOLUTE`M=M-1 UBTRACT ONE FROM MEMORY. T ZERO WILL LOOP ARROUND TO #$FF``Y`N`N`N`N`Y`NM-1 UBTRACT ONE FROM MEMORY. T ZERO WILL LOOP ARROUND TO #$FF  $....,X``222`DE`11011110`DECREASE MEMORY, ABSOLUTE, INDEXED`M=M-1 UBTRACT ONE FROM MEMORY. T ZERO WILL LOOP ARROUND TO #$FF``Y`N`N`N`N`Y`NT ONE FROM MEMORY. T ZERO WILL LOOP ARROUND TO #$FF ``202`CA`11001010`DECREASE X REGISTER, IMPLIED`X=X-1 UBTRACT ONE FROM X REGISTER. T ZERO WILL LOOP ARROUND TO #$FF``Y`N`N`N`N`Y`N-1 UBTRACT ONE FROM X REGISTER. T ZERO WILL LOOP ARROUND TO #$FF ``136`88`10001000`DECREASE Y REGISTER`Y=Y-1 UBTRACT ONE FROM X REGISTER. T ZERO WILL LOOP ARROUND TO #$FF``Y`N`N`N`N`Y`N Y=Y-1 UBTRACT ONE FROM X REGISTER. T ZERO WILL LOOP ARROUND TO #$FF  ..``073`49`01001001`EXCLUSIVE OR, IMEDIATE`A EOR M = A ERFORMS EOR BETWEEN NUMBER IN DATA REGISTER AND ACCUMULTOR LEAVING RESULT IN ACCUMULATOR``Y`N`N`N`N`Y`N NUMBER IN DATA REGISTER AND ACCUMULTOR LEAVING RESULT IN ACCUMULATOR  $..``069`45`01000101`EXCLUSIVE OR, ZERO PAGE`A EOR M = A ERFORMS EOR BETWEEN MEMORY REGISTER AND ACCUMULTOR LEAVING RESULT IN ACCUMULATOR``Y`N`N`N`N`Y`NBETWEEN MEMORY REGISTER AND ACCUMULTOR LEAVING RESULT IN ACCUMULATOR   $..,X``085`55`01010101`EXCLUSIVE OR, ZERO PAGE, INDEXED`A EOR M = A ERFORMS EOR BETWEEN NUMBER IN DATA REGISTER AND ACCUMULTOR LEAVING RESULT IN ACCUMULATOR``Y`N`N`N`N`Y`NATA REGISTER AND ACCUMULTOR LEAVING RESULT IN ACCUMULATOR    $....``077`4D`01011101`EXCLUSIVE OR, ABSOLUTE`A EOR M = A ERFORMS EOR BETWEEN NUMBER IN DATA REGISTER AND ACCUMULTOR LEAVING RESULT IN ACCUMULATOR``Y`N`N`N`N`Y`NUMBER IN DATA REGISTER AND ACCUMULTOR LEAVING RESULT IN ACCUMULATOR    $....,X``093`5D`01011101`EXCLUSIVE OR, ABSOLUTE, INDEXED`A EOR M = A ERFORMS EOR BETWEEN NUMBER IN DATA REGISTER AND ACCUMULTOR LEAVING RESULT IN ACCUMULATOR``Y`N`N`N`N`Y`NTA REGISTER AND ACCUMULTOR LEAVING RESULT IN ACCUMULATOR    $....,Y``089`59`01011001`EXCLUSIVE OR, ABSOLUTE, INDEXED`A EOR M = A ERFORMS EOR BETWEEN NUMBER IN DATA REGISTER AND ACCUMULTOR LEAVING RESULT IN ACCUMULATOR``Y`N`N`N`N`Y`NTA REGISTER AND ACCUMULTOR LEAVING RESULT IN ACCUMULATOR    ($..),Y``081`51`01010001`EXCLUSIVE OR, INDIRECT, INDEXED`A EOR M = A ERFORMS EOR BETWEEN NUMBER IN DATA REGISTER AND ACCUMULTOR LEAVING RESULT IN ACCUMULATOR``Y`N`N`N`N`Y`NTA REGISTER AND ACCUMULTOR LEAVING RESULT IN ACCUMULATOR   ($..,X)``065`41`01000001`EXCLUSIVE OR, INDEXED, INDIRECT`A EOR M = A ERFORMS EOR BETWEEN NUMBER IN DATA REGISTER AND ACCUMULTOR LEAVING RESULT IN ACCUMULATOR``Y`N`N`N`N`Y`NTA REGISTER AND ACCUMULTOR LEAVING RESULT IN ACCUMULATOR  $..``230`E6`11100110`INCREASE MEMORY, ZERO PAGE`M=M+1 NCREASE MEMORY LOCATION BY ONE. ILL ROLL ARROUND TO ZERO IF MEMORY IS #$FF``Y`N`N`N`N`Y`NORY LOCATION BY ONE. ILL ROLL ARROUND TO ZERO IF MEMORY IS #$FF   EOR $.EOR $.., EOR $... EOR $...., EOR $...., EOR ($..), EOR ($..,XINC $.INC $..,INC $...INC $....,IN $..,X``246`F6`11110110`INCREASE MEMORY, ZERO PAGE, INDEXED`M=M+1 NCREASE MEMORY LOCATION BY ONE. ILL ROLL ARROUND TO ZERO IF MEMORY IS #$FF``Y`N`N`N`N`Y`NN BY ONE. ILL ROLL ARROUND TO ZERO IF MEMORY IS #$FF  $....``238`EE`11101110`INCREASE MEMORY, ABSOLUTE`M=M+1 NCREASE MEMORY LOCATION BY ONE. ILL ROLL ARROUND TO ZERO IF MEMORY IS #$FF``Y`N`N`N`N`Y`NRY LOCATION BY ONE. ILL ROLL ARROUND TO ZERO IF MEMORY IS #$FF  $....,X``254`FE`11111110`INCREASE MEMORY, ABSOLUTE, INDEXED`M=M+1 NCREASE MEMORY LOCATION BY ONE. ILL ROLL ARROUND TO ZERO IF MEMORY IS #$FF``Y`N`N`N`N`Y`N BY ONE. ILL ROLL ARROUND TO ZERO IF MEMORY IS #$FF ``232`E8`11101000`INCREASE X REGISTER, IMPLIED`X=X+1 NCREASE X REGISTER BY ONE. ILL ROLL ARROUND TO ZERO``Y`N`N`N`N`Y`N X=X+1 NCREASE X REGISTER BY ONE. ILL ROLL ARROUND TO ZERO ``200`C8`11001000`INCREASE Y REGISTER, IMPLIED`Y=Y+1 NCREASE Y REGISTER BY ONE. ILL ROLL ARROUND TO ZERO``Y`N`N`N`N`Y`N Y=Y+1 NCREASE Y REGISTER BY ONE. ILL ROLL ARROUND TO ZERO  $....``076`4C`01001100`JUMP, ABSOLUTE`PC= ADDRESS IN COMMAND. HIS COMMAND PLACES DATA IN COMMAND STATEMENT INTO THE PROGRAM COUNTER AND EXECUTION CONTINUES FROM THERE``N`N`N`N`N`N`NMMAND STATEMENT INTO THE PROGRAM COUNTER AND EXECUTION CON ($....)``108`6C`01101100`JUMP, INDIRECT`PC= DATA HIS COMMAND PLACES DATA FOUND AT ADDRESS POINTED TO BY STATEMENT INTO THE PROGRAM COUNTER AND EXECUTION CONTINUES FROM THERE``N`N`N`N`N`N`NBY STATEMENT INTO THE PROGRAM COUNTER AND EXECUT $....``032`20`00100000`JUMP TO SUBROUTINE`PC= DATA HIS COMMAND PLACES CONTENTS OF PROGRAM COUNTER ON THE STACK. T THEN LOADS THE PROGRAM COUNTER WITH DATA FROM COMMAND.``N`N`N`N`N`N`NN THE STACK. T THEN LOADS THE PROGRAM COUNTER WITH  ..``169`A9`10101001`LOAD ACCUMULATOR, IMMEDIATE`A=M OAD THE ACCUMULATOR WITH DATA FROM DATA BUFFER``Y`N`N`N`N`Y`N $..``165`A5`10100101`LOAD ACCUMULATOR, ZERO PAGE`A=M OAD THE ACCUMULATOR FROM MEMORY``Y`N`N`N`N`Y`N  $..,X``181`B5`10110101`LOAD ACCUMULATOR, ZERO PAGE, INDEXED`A=M OAD THE ACCUMULATOR FROM MEMORY``Y`N`N`N`N`Y`N $....``173`AD`10101101`LOAD ACCUMULATOR, ABSOLUTE`A=M OAD THE ACCUMULATOR FROM MEMORY``Y`N`N`N`N`Y`N  $....,X``189`BD`10111101`LOAD ACCUMULATOR, ABSOLUTE, INDEXED`A=M OAD THE ACCUMULATOR FROM MEMORY``Y`N`N`N`N`Y`N $....,Y``185`B9`10111001`LOAD ACCUMULATOR, ABSOLUTE, INDEXED`A=M OAD THE ACCUMULATOR FROM MEMORY``Y`N`N`N`N`Y`N   INJMP $...JMP ($....JSR $...LDA .LDA $.LDA $..,LDA $...LDA $....,LDA $....,LDA ($..),LDA ($..,X ($..),Y``177`B1`10110001`LOAD ACCUMULATOR, INDIRECT, INDEXED`A=M OAD THE ACCUMULATOR FROM MEMORY``Y`N`N`N`N`Y`N ($..,X)``161`A1`10100001`LOAD ACCUMULATOR, INDEXED, INDIRECT`A=M OAD THE ACCUMULATOR FROM MEMORY``Y`N`N`N`N`Y`N  ..``162`A2`10100010`LOAD X REGISTER, IMMEDIATE`A=M OAD THE X REGISTER FROM THE DATA BUFFER``Y`N`N`N`N`Y`N $..``166`A6`10100110`LOAD X REGISTER, ZERO PAGE`A=M OAD THE X REGISTER FROM MEMORY``Y`N`N`N`N`Y`N  $..,Y``182`B6`10110110`LOAD X REGISTER, INDEXED`A=M OAD THE X REGISTER FROM MEMORY``Y`N`N`N`N`Y`N $....``174`AE`10101110`LOAD X REGISTER, ABSOLUTE`A=M OAD THE X REGISTER FROM MEMORY``Y`N`N`N`N`Y`N  $....,Y``190`BE`10111110`LOAD X REGISTER, ABSOLUTE, INDEXED`A=M OAD THE X REGISTER FROM MEMORY``Y`N`N`N`N`Y`N ..``160`A0`10100000`LOAD Y REGISTER, IMMEDIATE`Y=M OAD Y REGISTER WITH DATA FROM BUFFER``Y`N`N`N`N`Y`N  $..``164`A4`10100100`LOAD Y REGISTER, ZERO PAGE`Y=M OAD Y REGISTER WITH DATA FROM MEMORY``Y`N`N`N`N`Y`N $..,X``180`B4`10110100`LOAD Y REGISTER, ZERO PAGE, INDEXED`Y=M OAD Y REGISTER WITH DATA FROM MEMORY``Y`N`N`N`N`Y`N $....``172`AC`10101100`LOAD Y REGISTER, ABSOLUTE`Y=M OAD Y REGISTER WITH DATA FROM MEMORY``Y`N`N`N`N`Y`N ``234`EA`11101010`NO OPERATION`FILLER COMMAND OCCUPIES MEMORY AND EXHAUSTS TWO CLOCK CYCLES``Y`N`N`N`N`Y`Y   LDX .LDX $.LDX $..,LDX $...LDX $....,LDY .LDY $.LDY $..,LDY $...LDY $....,LSLSR $. LSR $..,  $....,X``188`BC`10111100`LOAD Y REGISTER, ABSOLUTE, INDEXED`Y=M OAD Y REGISTER WITH DATA FROM MEMORY``Y`N`N`N`N`Y`N Y=M OAD Y REGISTER WITH DATA FROM MEMORY ``074`4A`01001010`LOGICAL SHIFT RIGHT, ACCUMULATOR`HIFT ALL BITS OF ACCUMULATOR RIGHT. HIFT THE LOWEST BIT INTO CARRY FLAG. HIFT ZERO INTO HIGHEST BIT``Y`N`N`N`N`Y`YFT THE LOWEST BIT INTO CARRY FLAG. HIFT ZERO INTO HIGHEST BIT   $..``070`46`01000110`LOGICAL SHIFT RIGHT, ZERO PAGE`HIFT ALL BITS OF MEMORY RIGHT. HIFT THE LOWEST BIT INTO CARRY FLAG. HIFT ZERO INTO HIGHEST BIT``Y`N`N`N`N`Y`Y THE LOWEST BIT INTO CARRY FLAG. HIFT ZERO INTO HIGHEST BIT    $..,X``086`56`01010110`LOGICAL SHIFT RIGHT, ZERO PAGE, INDEXED`HIFT ALL BITS OF ACCUMULATOR RIGHT. HIFT THE LOWEST BIT INTO CARRY FLAG. HIFT ZERO INTO HIGHEST BIT``Y`N`N`N`N`Y`Y BIT INTO CARRY FLAG. HIFT ZERO INTO HIGHEST BIT    $....``078`4E`01001110`LOGICAL SHIFT RIGHT, ABSOLUTE`HIFT ALL BITS OF ACCUMULATOR RIGHT. HIFT THE LOWEST BIT INTO CARRY FLAG. HIFT ZERO INTO HIGHEST BIT``Y`N`N`N`N`Y`YTHE LOWEST BIT INTO CARRY FLAG. HIFT ZERO INTO HIGHEST BIT    $....,X``094`5E`01011110`LOGICAL SHIFT RIGHT, ABSOLUTE, INDEXED`HIFT ALL BITS OF ACCUMULATOR RIGHT. HIFT THE LOWEST BIT INTO CARRY FLAG. HIFT ZERO INTO HIGHEST BIT``Y`N`N`N`N`Y`YBIT INTO CARRY FLAG. HIFT ZERO INTO HIGHEST BIT    ..``009`09`00001001`OR ACCUMULATOR, IMMEDIATE`A+M=A ERFORMS LOGICAL OR BETWEEN MEMORY AND ACCUMULATOR. ESULTS IN ACCUMULATOR``Y`N`N`N`N`Y`NLOGICAL OR BETWEEN MEMORY AND ACCUMULATOR. ESULTS IN ACCUMULATOR   $..``005`05`00000101`OR ACCUMULATOR, ZERO PAGE`A+M=A ERFORMS LOGICAL OR BETWEEN MEMORY AND ACCUMULATOR. ESULTS IN ACCUMULATOR``Y`N`N`N`N`Y`NLOGICAL OR BETWEEN MEMORY AND ACCUMULATOR. ESULTS IN ACCUMULATOR  $..,X``021`15`00010101`OR ACCUMULATOR, ZERO PAGE, INDEXED`A+M=A ERFORMS LOGICAL OR BETWEEN MEMORY AND ACCUMULATOR. ESULTS IN ACCUMULATOR``Y`N`N`N`N`Y`NBETWEEN MEMORY AND ACCUMULATOR. ESULTS IN ACCUMULATOR  $....``013`0D`00001101`OR ACCUMULATOR, ABSOLUTE`A+M=A ERFORMS LOGICAL OR BETWEEN MEMORY AND ACCUMULATOR. ESULTS IN ACCUMULATOR``Y`N`N`N`N`Y`NOGICAL OR BETWEEN MEMORY AND ACCUMULATOR. ESULTS IN ACCUMULATOR  $....,X``029`1D`00011101`OR ACCUMULATOR, ABSOLUTE, INDEXED`A+M=A ERFORMS LOGICAL OR BETWEEN MEMORY AND ACCUMULATOR. ESULTS IN ACCUMULATOR``Y`N`N`N`N`Y`NETWEEN MEMORY AND ACCUMULATOR. ESULTS IN ACCUMULATOR  $....,Y``025`19`00011001`OR ACCUMULATOR, ABSOLUTE, INDEXED`A+M=A ERFORMS LOGICAL OR BETWEEN MEMORY AND ACCUMULATOR. ESULTS IN ACCUMULATOR``Y`N`N`N`N`Y`NETWEEN MEMORY AND ACCUMULATOR. ESULTS IN ACCUMULATOR   LSR $... LSR $...., NOORA . ORA $.ORA $..,ORA $...ORA $....,ORA $....,ORA ($..),ORA ($..,XPHPL ($..),Y``017`11`00010001`OR ACCUMULATOR, INDIRECT, INDEXED`A+M=A ERFORMS LOGICAL OR BETWEEN MEMORY AND ACCUMULATOR. ESULTS IN ACCUMULATOR``Y`N`N`N`N`Y`NETWEEN MEMORY AND ACCUMULATOR. ESULTS IN ACCUMULATOR  ($..,X)``001`01`00000001`OR ACCUMULATOR, INDEXED, INDIRECT`A+M=A ERFORMS LOGICAL OR BETWEEN MEMORY AND ACCUMULATOR. ESULTS IN ACCUMULATOR``Y`N`N`N`N`Y`NTWEEN MEMORY AND ACCUMULATOR. ESULTS IN ACCUMULATOR ``072`48`01001000`PUSH ACCUMULTOR ON STACK, IMPLIED`LACES CONTENT OF ACCUMULATOR ON STACK AND DECREMENTS STACK POINTER``N`N`N`N`N`N`NS CONTENT OF ACCUMULATOR ON STACK AND DECREMENTS STACK POINTER ``104`68`01101000`PULLS ACCUMULATOR FROM STACK, IMPLIED`LACES CONTENT OF STACK INTO ACCUMULATOR AND INCREMENTS STACK POINTER``Y`N`N`N`N`Y`NENT OF STACK INTO ACCUMULATOR AND INCREMENTS STACK POINTER ``040`28`00101000`PULLS PROCESSOR STATUS FROM STACK, IMPLIED`LACES CONTENT OF STACK INTO PROCESSOR STATUS REGISTER AND INCREMENTS STACK POINTER. TATUS REGISTER IS THE SET OF FLAGS.``Y`Y`Y`Y`Y`Y`Y STACK POINTER. TATUS REGISTER IS THE SET ``042`2A`00101010`ROTATE LEFT, ACCUMULATOR`ROTATE ALL BITS IN THE ACCUMULATOR LEFT. ONTENTS OF THE CARRY FLAG ARE ROTATED INTO THE LOWEST BIT AND THE HIGHEST BIT IS ROTATED INTO THE CARRY FLAG``Y`N`N`N`N`Y`Y INTO THE LOWEST BIT AND THE HIGH $..``038`26`00100110`ROTATE LEFT, ZERO PAGE`ROTATE ALL BITS IN THE MEMORY REGISTER LEFT. ONTENTS OF THE CARRY FLAG ARE ROTATED INTO THE LOWEST BIT AND THE HIGHEST BIT IS ROTATED INTO THE CARRY FLAG``Y`N`N`N`N`Y`YNTO THE LOWEST BIT AND THE  $..,X``054`36`00110110`ROTATE LEFT, ZERO PAGE, INDEXED`ROTATE ALL BITS IN THE MEMORY REGISTER LEFT. ONTENTS OF THE CARRY FLAG ARE ROTATED INTO THE LOWEST BIT AND THE HIGHEST BIT IS ROTATED INTO THE CARRY FLAG``Y`N`N`N`N`Y`YEST BIT AND THE  $....``046`2E`00101110`ROTATE LEFT, ABSOLUTE`ROTATE ALL BITS IN THE MEMORY REGISTER LEFT. ONTENTS OF THE CARRY FLAG ARE ROTATED INTO THE LOWEST BIT AND THE HIGHEST BIT IS ROTATED INTO THE CARRY FLAG``Y`N`N`N`N`Y`YTO THE LOWEST BIT AND THE  $....,X``062`3E`00111110`ROTATE LEFT, ABSOLUTE, INDEXED`ROTATE ALL BITS IN THE MEMORY REGISTER LEFT. ONTENTS OF THE CARRY FLAG ARE ROTATED INTO THE LOWEST BIT AND THE HIGHEST BIT IS ROTATED INTO THE CARRY FLAG``Y`N`N`N`N`Y`YST BIT AND THE ``106`6A`01101010`ROTATE RIGHT, ACCUMULATOR`ROTATE ALL BITS IN THE ACCUMULATOR REGISTER RIGHT. ONTENTS OF THE CARRY FLAG ARE ROTATED INTO THE HIGHEST BIT AND THE LOWEST BIT IS ROTATED INTO THE CARRY FLAG``Y`N`N`N`N`Y`YINTO THE HIGHEST BIT A $..``102`66`01100110`ROTATE RIGHT, ZERO PAGE`ROTATE ALL BITS IN THE MEMORY REGISTER RIGHT. ONTENTS OF THE CARRY FLAG ARE ROTATED INTO THE HIGHEST BIT AND THE LOWEST BIT IS ROTATED INTO THE CARRY FLAG``Y`N`N`N`N`Y`YTO THE HIGHEST BIT AND TH $..,X``118`76`01110110`ROTATE RIGHT, ZERO PAGE, INDEXED`ROTATE ALL BITS IN THE MEMORY REGISTER RIGHT. ONTENTS OF THE CARRY FLAG ARE ROTATED INTO THE HIGHEST BIT AND THE LOWEST BIT IS ROTATED INTO THE CARRY FLAG``Y`N`N`N`N`Y`YEST BIT AND TH $....``110`6E`01101110`ROTATE RIGHT, ZERO PAGE, ABSOLUTE`ROTATE ALL BITS IN THE MEMORY REGISTER RIGHT. ONTENTS OF THE CARRY FLAG ARE ROTATED INTO THE HIGHEST BIT AND THE LOWEST BIT IS ROTATED INTO THE CARRY FLAG``Y`N`N`N`N`Y`YST BIT AND TH $....,X``126`7E`01111110`ROTATE RIGHT, ZERO PAGE, ABSOLUTE, INDEXED`ROTATE ALL BITS IN THE MEMORY REGISTER RIGHT. ONTENTS OF THE CARRY FLAG ARE ROTATED INTO THE HIGHEST BIT AND THE LOWEST BIT IS ROTATED INTO THE CARRY FLAG``Y`N`N`N`N`Y`YTH  PLROROL $.ROL $..,ROL $...ROL $....,ROROR $.ROR $..,ROR $...ROR $....,RTRTSBC . SBC $. ``064`40`01000000`RETURN FROM INTERRUPT`ETURN COMMAND FOR HARDWARE TRIGGERED SUBROUTINE. ULLS DATA OFF THE STACK AND SETS PROGRAM COUNTER WITH IT. LSO RESTORES THE STATUS REGISTER``Y`Y`Y`Y`Y`Y`YSTACK AND SETS PROGRAM COUNTER WITH IT. L``096`60`01100000`RETURN FROM SUBROUTINE`ETURN COMMAND FOR SUBROUTINE. ULLS DATA OFF THE STACK AND SETS PROGRAM COUNTER WITH IT, INCREMENTING STACK POINTER.``N`N`N`N`N`N`NF THE STACK AND SETS PROGRAM COUNTER WITH IT, INCREMENTING STACK POI  ..``233`E9`11101001`SUBTRACT WITH CARRY, IMMEDIATE`A-M=A UBTRACTS DATA REGISTER FROM ACCUMULATOR. ORROWING FROM THE CARRY FLAG IF ACCUMULATOR CONTENTS IS TOO SMALL``Y`N`N`N`N`Y`YWING FROM THE CARRY FLAG IF ACCUMULATOR CONTENTS IS TOO SMA   $..``229`E5`11100101`SUBTRACT WITH CARRY, ZERO PAGE`A-M=A UBTRACTS MEMORY REGISTER FROM ACCUMULATOR. ORROWING FROM THE CARRY FLAG IF ACCUMULATOR CONTENTS IS TOO SMALL``Y`N`N`N`N`Y`YWING FROM THE CARRY FLAG IF ACCUMULATOR CONTENTS IS TOO S   $..,X``245`F5`11110101`SUBTRACT WITH CARRY, ZERO PAGE, INDEXED`A-M=A UBTRACTS MEMORY REGISTER FROM ACCUMULATOR. ORROWING FROM THE CARRY FLAG IF ACCUMULATOR CONTENTS IS TOO SMALL``Y`N`N`N`N`Y`YHE CARRY FLAG IF ACCUMULATOR CONTENTS IS TOO S   $....``237`ED`11101101`SUBTRACT WITH CARRY, ABSOLUTE`A-M=A UBTRACTS MEMORY REGISTER FROM ACCUMULATOR. ORROWING FROM THE CARRY FLAG IF ACCUMULATOR CONTENTS IS TOO SMALL``Y`N`N`N`N`Y`YING FROM THE CARRY FLAG IF ACCUMULATOR CONTENTS IS TOO S   $....,X``253`FD`11111101`SUBTRACT WITH CARRY, ABSOLUTE, INDEXED`A-M=A UBTRACTS MEMORY REGISTER FROM ACCUMULATOR. ORROWING FROM THE CARRY FLAG IF ACCUMULATOR CONTENTS IS TOO SMALL``Y`N`N`N`N`Y`YE CARRY FLAG IF ACCUMULATOR CONTENTS IS TOO S  $....,Y``249`F9`11111001`SUBTRACT WITH CARRY, ABSOLUTE, INDEXED`A-M=A UBTRACTS MEMORY REGISTER FROM ACCUMULATOR. ORROWING FROM THE CARRY FLAG IF ACCUMULATOR CONTENTS IS TOO SMALL``Y`N`N`N`N`Y`YE CARRY FLAG IF ACCUMULATOR CONTENTS IS TOO S ($..),Y``241`F1`11110001`SUBTRACT WITH CARRY, INDIRECT, INDIRECT`A-M=A UBTRACTS MEMORY REGISTER FROM ACCUMULATOR. ORROWING FROM THE CARRY FLAG IF ACCUMULATOR CONTENTS IS TOO SMALL``Y`N`N`N`N`Y`Y CARRY FLAG IF ACCUMULATOR CONTENTS IS TOO S ($..,X)``225`E1`11100001`SUBTRACT WITH CARRY, INDEXED, INDIRECT`A-M=A UBTRACTS MEMORY REGISTER FROM ACCUMULATOR. ORROWING FROM THE CARRY FLAG IF ACCUMULATOR CONTENTS IS TOO SMALL``Y`N`N`N`N`Y`YE CARRY FLAG IF ACCUMULATOR CONTENTS IS TOO S``056`38`00111000`SET CARRY, IMPLIED`ETS THE CARRY FLAG TO 1``N`N`N`N`N`N`Y ``248`F8`11111000`SET DECIMAL, IMPLIED`ETS THE DECIMAL FLAG TO 1``N`N`N`Y`N`N`N ``120`78`01111000`SET INTERRUPT, IMPLIED`ETS THE INTERRUPT FLAG TO 1. REVENTS THE CPU FROM ACKNOWLEDGING AN INTERRUPT REQUEST``N`N`N`N`Y`N`NRUPT FLAG TO 1. REVENTS THE CPU FROM ACKNOWLEDGING AN INTERRUPT REQUEST  $..``133`85`10000101`STORE ACCUMULATOR, ZERO PAGE`STORES THE CONTENTS OF THE ACCUMULATOR IN MEMORY SPECIFIED``N`N`N`N`N`N`N STORES THE CONTENTS OF THE ACCUMULATOR IN MEMORY SPECIFIED   SBC $.., SBC $... SBC $...., SBC $....,SBC ($..),SBC ($..,XSESESESTA $.STA $..,STA $...STA $...., $..,X``149`95`10010101`STORE ACCUMULATOR, ZERO PAGE, INDEXED`STORES THE CONTENTS OF THE ACCUMULATOR IN MEMORY SPECIFIED``N`N`N`N`N`N`N THE CONTENTS OF THE ACCUMULATOR IN MEMORY SPECIFIED  $....``141`8D`10001101`STORE ACCUMULATOR, ABSOLUTE`STORES THE CONTENTS OF THE ACCUMULATOR IN MEMORY SPECIFIED``N`N`N`N`N`N`N STORES THE CONTENTS OF THE ACCUMULATOR IN MEMORY SPECIFIED  $....,X``157`9D`10011101`STORE ACCUMULATOR, ABSOLUTE, INDEXED`STORES THE CONTENTS OF THE ACCUMULATOR IN MEMORY SPECIFIED``N`N`N`N`N`N`NTHE CONTENTS OF THE ACCUMULATOR IN MEMORY SPECIFIED  $....,Y``153`99`10011001`STORE ACCUMULATOR, ABSOLUTE, INDEXED`STORES THE CONTENTS OF THE ACCUMULATOR IN MEMORY SPECIFIED``N`N`N`N`N`N`NTHE CONTENTS OF THE ACCUMULATOR IN MEMORY SPECIFIED  ($..),Y``145`91`10010001`STORE ACCUMULATOR, INDIRECT, INDEXED`STORES THE CONTENTS OF THE ACCUMULATOR IN MEMORY SPECIFIED``N`N`N`N`N`N`NTHE CONTENTS OF THE ACCUMULATOR IN MEMORY SPECIFIED  ($..,X)``129`81`10000001`STORE ACCUMULATOR, INDEXED, INDIRECT`STORES THE CONTENTS OF THE ACCUMULATOR IN MEMORY SPECIFIED``N`N`N`N`N`N`NTHE CONTENTS OF THE ACCUMULATOR IN MEMORY SPECIFIED  $..``134`86`10000110`STORE X REGISTER, ZERO PAGE`STORES THE CONTENTS OF THE X REGISTER IN MEMORY SPECIFIED``N`N`N`N`N`N`N STORES THE CONTENTS OF THE X REGISTER IN MEMORY SPECIFIED  $..,Y``150`96`10010110`STORE X REGISTER, ZERO PAGE, INDEXED`STORES THE CONTENTS OF THE X REGISTER IN MEMORY SPECIFIED``N`N`N`N`N`N`NES THE CONTENTS OF THE X REGISTER IN MEMORY SPECIFIED  $....``142`8E`10001110`STORE X REGISTER, ABSOLUTE`STORES THE CONTENTS OF THE X REGISTER IN MEMORY SPECIFIED``N`N`N`N`N`N`N STORES THE CONTENTS OF THE X REGISTER IN MEMORY SPECIFIED  $..``132`84`10000100`STORE Y REGISTER, ZERO PAGE`STORES THE CONTENTS OF THE Y REGISTER IN MEMORY SPECIFIED``N`N`N`N`N`N`N STORES THE CONTENTS OF THE Y REGISTER IN MEMORY SPECIFIED  $..,X``148`94`10010100`STORE Y REGISTER, ZERO PAGE, INDEXED`STORES THE CONTENTS OF THE Y REGISTER IN MEMORY SPECIFIED``N`N`N`N`N`N`NES THE CONTENTS OF THE Y REGISTER IN MEMORY SPECIFIED  $....``140`8C`10001100`STORE Y REGISTER, ABSOLUTE`STORES THE CONTENTS OF THE Y REGISTER IN MEMORY SPECIFIED``N`N`N`N`N`N`N STORES THE CONTENTS OF THE Y REGISTER IN MEMORY SPECIFIED  STA $....,STA ($..),STA ($..,XSTX $.STX $..,STX $...STY $.STY $..,STY $...TATATSTXTX TY ``170`AA`10101010`TRANSFER ACCUMULATOR TO X REGISTER, IMPLIED`UPLICATES CONTENTS OF ACCUMULATOR IN X REGISTER.``Y`N`N`N`N`Y`N UPLICATES CONTENTS OF ACCUMULATOR IN X REGISTER. ``168`A8`10101000`TRANSFER ACCUMULATOR TO Y REGISTER, IMPLIED`UPLICATES CONTENTS OF ACCUMULATOR IN Y REGISTER.``Y`N`N`N`N`Y`N UPLICATES CONTENTS OF ACCUMULATOR IN Y REGISTER. ``186`BA`10111010`TRANSFER STACK POINTER TO X REGISTER, IMPLIED`UPLICATES CONTENTS OF STACK POINTER IN X REGISTER.``Y`N`N`N`N`Y`NUPLICATES CONTENTS OF STACK POINTER IN X REGISTER. ``138`8A`10001010`TRANSFER X REGISTER TO ACCUMULATOR, IMPLIED`UPLICATES CONTENTS OF X REGISTER IN ACCUMULATOR``Y`N`N`N`N`Y`N UPLICATES CONTENTS OF X REGISTER IN ACCUMULATOR  ``154`9A`10011010`TRANSFER X REGISTER TO STACK POINTER, IMPLIED`UPLICATES CONTENTS OF X REGISTER IN STACK POINTER``N`N`N`N`N`N`NUPLICATES CONTENTS OF X REGISTER IN STACK POINTER   ``152`98`10011000`TRANSFER Y REGISTER TO ACCUMULATOR, IMPLIED`UPLICATES CONTENTS OF Y REGISTER IN ACCUMULATOR``Y`N`N`N`N`Y`N UPLICATES CONTENTS OF Y REGISTER IN ACCUMULATOR  00 00 000000010101010102020202020303030303030404  000```00`00000000`BREAK`STOPS EXECUTION OF PROGRAM AND GENERATES A FALSE INTERRUPT THAT FORCES THE CPU TO EXECUTE A SPECIAL ROUTINE`ROGRAM EXECUTED WILL AFFECT IRQ FLAG.`N`N`Y`N`N`N`NRUPT THAT FORCES THE CPU TO EXECUTE A SPECIAL ROUTINE   001` ($..,X)``01`00000001`OR ACCUMULATOR, INDEXED, INDIRECT`A+M=A ERFORMS LOGICAL OR BETWEEN MEMORY AND ACCUMULATOR. ESULTS IN ACCUMULATOR``Y`N`N`N`N`Y`NETWEEN MEMORY AND ACCUMULATOR. ESULTS IN ACCUMULATOR  005` $..``05`00000101`OR ACCUMULATOR, ZERO PAGE`A+M=A ERFORMS LOGICAL OR BETWEEN MEMORY AND ACCUMULATOR. ESULTS IN ACCUMULATOR``Y`N`N`N`N`Y`N LOGICAL OR BETWEEN MEMORY AND ACCUMULATOR. ESULTS IN ACCUMULATOR 006` $..``06`00000110`ARITHMATIC SHIFT LEFT, ZERO PAGE ADDRESS`SHIFTS ALL THE BITS AT THE STATED ZERO PAGE ADDRESS TO THE LEFT. LACES THE HIGHEST BIT IN THE CARRY FLAG REGISTER. HIFTS A ZERO INTO THE LOWEST BIT.``Y`N`N`N`N`Y`YY FLAG REGIS009` ..``09`00001001`OR ACCUMULATOR, IMMEDIATE`A+M=A ERFORMS LOGICAL OR BETWEEN MEMORY AND ACCUMULATOR. ESULTS IN ACCUMULATOR``Y`N`N`N`N`Y`N LOGICAL OR BETWEEN MEMORY AND ACCUMULATOR. ESULTS IN ACCUMULATOR 010```0A`00001010`ARITHMATIC SHIFT LEFT, ACCUMULATOR`SHIFTS ALL THE BITS IN THE ACCUMULATOR TO THE LEFT. LACES THE HIGHEST BIT IN THE CARRY FLAG REGISTER. HIFTS A ZERO INTO THE LOWEST BIT.``Y`N`N`N`N`Y`YN THE CARRY FLAG REGISTER. HIFTS 013` $....``0D`00001101`OR ACCUMULATOR, ABSOLUTE`A+M=A ERFORMS LOGICAL OR BETWEEN MEMORY AND ACCUMULATOR. ESULTS IN ACCUMULATOR``Y`N`N`N`N`Y`NLOGICAL OR BETWEEN MEMORY AND ACCUMULATOR. ESULTS IN ACCUMULATOR 014` $....``0E`00001110`ARITHMATIC SHIFT LEFT, ABSOLUTE ADDRESS`SHIFTS ALL THE BITS AT THE STATED SIXTEEN BIT ADDRESS TO THE LEFT. LACES THE HIGHEST BIT IN THE CARRY FLAG REGISTER. HIFTS A ZERO INTO THE LOWEST BIT.``Y`N`N`N`N`Y`Y FLAG REG016```10`00010000`BRANCH IF PLUS`TESTS THE NEGATIVE FLAG. F SET, EQUAL TO ONE, IT WILL ADD THE NUMBER IN THE COMMAND TO THE PROGRAM COUNTER. F CLEARED, IT WILL CONTINUE AT NEXT CONSECUTIVE COMMAND IN PROGRAM.``N`N`N`N`N`N`NRAM COUNTER. 017` ($..),Y``11`00010001`OR ACCUMULATOR, INDIRECT, INDEXED`A+M=A ERFORMS LOGICAL OR BETWEEN MEMORY AND ACCUMULATOR. ESULTS IN ACCUMULATOR``Y`N`N`N`N`Y`NBETWEEN MEMORY AND ACCUMULATOR. ESULTS IN ACCUMULATOR 021` $..,X``15`00010101`OR ACCUMULATOR, ZERO PAGE, INDEXED`A+M=A ERFORMS LOGICAL OR BETWEEN MEMORY AND ACCUMULATOR. ESULTS IN ACCUMULATOR``Y`N`N`N`N`Y`N BETWEEN MEMORY AND ACCUMULATOR. ESULTS IN ACCUMULATOR 022` $..,X``16`00010110`ARITHMATIC SHIFT LEFT, ZERO PAGE ADDRESS,INDEXED`SHIFTS ALL THE BITS AT MEMORY LOCATION TO THE LEFT. LACES THE HIGHEST BIT IN THE CARRY FLAG REGISTER. HIFTS A ZERO INTO THE LOWEST BIT.``Y`N`N`N`N`Y`YISTER. HIFTS 024```18`00011000`CLEAR CARRY`CLEARS, ZEROS, THE CARRY FLAG``N`N`N`N`N`N`Y 056```38`00111000`SET CARRY, IMPLIED`ETS THE CARRY FLAG TO 1``N`N`N`N`N`N`Y 025` $....,Y``19`00011001`OR ACCUMULATOR, ABSOLUTE, INDEXED`A+M=A ERFORMS LOGICAL OR BETWEEN MEMORY AND ACCUMULATOR. ESULTS IN ACCUMULATOR``Y`N`N`N`N`Y`NBETWEEN MEMORY AND ACCUMULATOR. ESULTS IN ACCUMULATOR 029` $....,X``1D`00011101`OR ACCUMULATOR, ABSOLUTE, INDEXED`A+M=A ERFORMS LOGICAL OR BETWEEN MEMORY AND ACCUMULATOR. ESULTS IN ACCUMULATOR``Y`N`N`N`N`Y`NBETWEEN MEMORY AND ACCUMULATOR. ESULTS IN ACCUMULATOR 030` $....,X``1E`00011110`ARITHMATIC SHIFT LEFT, INDEXED`SHIFTS ALL THE BITS AT THE MEMORY LOCATION TO THE LEFT. LACES THE HIGHEST BIT IN THE CARRY FLAG REGISTER. HIFTS A ZERO INTO THE LOWEST BIT.``Y`N`N`N`N`Y`YE CARRY FLAG REGISTER. HI032` $....``20`00100000`JUMP TO SUBROUTINE`PC= DATA HIS COMMAND PLACES CONTENTS OF PROGRAM COUNTER ON THE STACK. T THEN LOADS THE PROGRAM COUNTER WITH DATA FROM COMMAND.``N`N`N`N`N`N`NON THE STACK. T THEN LOADS THE PROGRAM COUNTER WITH033` ($..,X)``21`00100001`AND ACCUMULATOR WITH MEMORY, INDIRECT INDEXED`A*M=A, ERFORMS LOGICAL OPERATION BETWEEN ACCUMULATOR AND MEMORY, LEAVES RESULT IN ACCUMULATOR.``Y`N`N`N`N`Y`NR AND MEMORY, LEAVES RESULT IN ACCUMULATOR. 036` $..``24`00100100`TESTS BITS 6&7, ZERO PAGE`TRANSFERS THE CONTENTS OF BITS 6 AND 7 OF A ZERO PAGE MEMORY REGISTER TO THE FLAG REGISTERS. IT 7 GOES INTO NEG FLAG. IT 6 GOES INTO THE OVERFLOW FLAG. * N ND IS ALSO PERFORMED BETWEEN THE ACCUMULATOR AND THE SPECIFIED MEMORY WITH THE RESULTS`AFFECTING THE ZERO FLAG. HIS COMMAND IS USEFUL FOR NEGATIVE NUMBER MATH.`Y`Y`N`N`N`Y`NFECTING THE ZERO FLAG. HIS COMMAND IS USEFUL FOR NEGATIVE NUMBER MATH. 037` $..``25`00100101`AND ACCUMULATOR, ZERO PAGE`A*M=A, ACCUMULATOR WILL HOLD THE RESULT OF A LOGICAL ND OPERATION BETWEEN THE NUMBER IN THE ACCUMULATOR AND THE NUMBER FOUND AT THE ZERO PAGE ADDRESS SPECIFIED BY THE COMMAND.``Y`N`N`N`N`Y`NHE038` $..``26`00100110`ROTATE LEFT, ZERO PAGE`ROTATE ALL BITS IN THE MEMORY REGISTER LEFT. ONTENTS OF THE CARRY FLAG ARE ROTATED INTO THE LOWEST BIT AND THE HIGHEST BIT IS ROTATED INTO THE CARRY FLAG``Y`N`N`N`N`Y`YINTO THE LOWEST BIT AND THE040```28`00101000`PULLS PROCESSOR STATUS FROM STACK, IMPLIED`LACES CONTENT OF STACK INTO PROCESSOR STATUS REGISTER AND INCREMENTS STACK POINTER. TATUS REGISTER IS THE SET OF FLAGS.``Y`Y`Y`Y`Y`Y`YS STACK POINTER. TATUS REGISTER IS THE SET041` ..``29`00101001`AND ACCUMULATOR, IMMEDIATE`A*M=A, ACCUMULATOR WILL HOLD THE RESULT OF A LOGICAL ND OPERATION BETWEEN THE NUMBER IN THE ACCUMULATOR AND THE NUMBER SPECIFIED BY THE COMMAND.``Y`N`N`N`N`Y`NNUMBER IN THE ACCUMULATOR AND THE042```2A`00101010`ROTATE LEFT, ACCUMULATOR`ROTATE ALL BITS IN THE ACCUMULATOR LEFT. ONTENTS OF THE CARRY FLAG ARE ROTATED INTO THE LOWEST BIT AND THE HIGHEST BIT IS ROTATED INTO THE CARRY FLAG``Y`N`N`N`N`Y`YD INTO THE LOWEST BIT AND THE HIG 044` $....``2C`00101100`TESTS BITS 6&7, ABSOLUTE`TRANSFERS THE CONTENTS OF BITS 6 AND 7 OF AN ABSOLUTE MEMORY REGISTER TO THE FLAG REGISTERS. IT 7 GOES INTO NEG FLAG. IT 6 GOES INTO THE OVERFLOW FLAG. * N ND IS ALSO PERFORMED BETWEEN  THE ACCUMULATOR AND THE SPECIFIED MEMORY WITH THE RESULTS`AFFECTING THE ZERO FLAG. HIS COMMAND IS USEFUL FOR NEGATIVE NUMBER MATH.`Y`Y`N`N`N`Y`NECTING THE ZERO FLAG. HIS COMMAND IS USEFUL FOR NEGATIVE NUMBER MATH.   045` $....``2D`00101101`AND ACCUMULATOR, ABSOLUTE`A*M=A, ACCUMULATOR WILL HOLD THE RESULT OF A LOGICAL ND OPERATION BETWEEN THE NUMBER IN THE ACCUMULATOR AND THE CONTENTS OF THE ADDRESS SPECIFIED``Y`N`N`N`N`Y`NMBER IN THE ACCUMULATOR AND THE  046` $....``2E`00101110`ROTATE LEFT, ABSOLUTE`ROTATE ALL BITS IN THE MEMORY REGISTER LEFT. ONTENTS OF THE CARRY FLAG ARE ROTATED INTO THE LOWEST BIT AND THE HIGHEST BIT IS ROTATED INTO THE CARRY FLAG``Y`N`N`N`N`Y`YNTO THE LOWEST BIT AND THE  048```30`00110000`BRANCH IF MINUS`TESTS THE NEGATIVE FLAG. F SET, EQUAL TO ONE, IT WILL ADD THE NUMBER IN THE COMMAND TO THE PROGRAM COUNTER. F CLEARED WILL CONTINUE AT NEXT CONSECUTIVE COMMAND IN PROGRAM.``N`N`N`N`N`N`NROGRAM COUNTER.   049` ($..),Y``31`00110001`AND ACCUMULATOR WITH MEMORY, INDEXED INDIRECT`A*M=A, ERFORMS A LOGICAL OPERATION BETWEEN MEMORY AND ACCUMULATOR LEAVING RESULT IN ACCUMULATOR.``Y`N`N`N`N`Y`N ACCUMULATOR LEAVING RESULT IN ACCUMULATOR.  053` $..,X``35`00110101`AND ACCUMULATOR, ZERO PAGE INDEXED`A*M=A, ACCUMULATOR WILL HOLD THE RESULT OF A LOGICAL ND OPERATION BETWEEN THE NUMBER IN THE ACCUMULATOR AND A MEMORY LOCATION``Y`N`N`N`N`Y`NWEEN THE NUMBER IN THE ACCUMULATOR AND A M054` $..,X``36`00110110`ROTATE LEFT, ZERO PAGE, INDEXED`ROTATE ALL BITS IN THE MEMORY REGISTER LEFT. ONTENTS OF THE CARRY FLAG ARE ROTATED INTO THE LOWEST BIT AND THE HIGHEST BIT IS ROTATED INTO THE CARRY FLAG``Y`N`N`N`N`Y`YWEST BIT AND THE057` $....,Y``39`00111001`AND ACCUMULATOR, ABSOLUTE INDEXED`A*M=A, ACCUMULATOR WILL HOLD THE RESULT OF A LOGICAL ND OPERATION BETWEEN THE NUMBER IN THE ACCUMULATOR AND THE CONTENTS OF MEMORY WHOSE ADDRESS IS EQUAL TO THE NUMBER IN THE COMMAND PLUS THE NUMBER IN THE Y REGISTER``Y`N`N`N`N`Y`NUMBER IN THE COMMAND PLUS THE NUMBER IN THE Y REGISTER PLUS THE NUMBER IN THE X REGISTER``Y`N`N`N`N`Y`NUMBER IN THE COMMAND PLUS THE NUMBER IN THE X REGISTER 061` $....,X``3D`00111101`AND ACCUMULATOR, ABSOLUTE INDEXED`A*M=A, ACCUMULATOR WILL HOLD THE RESULT OF A LOGICAL ND OPERATION BETWEEN THE NUMBER IN THE ACCUMULATOR AND THE CONTENTS OF MEMORY WHOSE ADDRESS IS EQUAL TO THE NUMBER IN THE COMMAND062` $....,X``3E`00111110`ROTATE LEFT, ABSOLUTE, INDEXED`ROTATE ALL BITS IN THE MEMORY REGISTER LEFT. ONTENTS OF THE CARRY FLAG ARE ROTATED INTO THE LOWEST BIT AND THE HIGHEST BIT IS ROTATED INTO THE CARRY FLAG``Y`N`N`N`N`Y`YEST BIT AND THE064```40`01000000`RETURN FROM INTERRUPT`ETURN COMMAND FOR HARDWARE TRIGGERED SUBROUTINE. ULLS DATA OFF THE STACK AND SETS PROGRAM COUNTER WITH IT. LSO RESTORES THE STATUS REGISTER``Y`Y`Y`Y`Y`Y`Y STACK AND SETS PROGRAM COUNTER WITH IT. 065` ($..,X)``41`01000001`EXCLUSIVE OR, INDEXED, INDIRECT`A EOR M = A ERFORMS EOR BETWEEN NUMBER IN DATA REGISTER AND ACCUMULTOR LEAVING RESULT IN ACCUMULATOR``Y`N`N`N`N`Y`NATA REGISTER AND ACCUMULTOR LEAVING RESULT IN ACCUMULATOR 069` $..``45`01000101`EXCLUSIVE OR, ZERO PAGE`A EOR M = A ERFORMS EOR BETWEEN MEMORY REGISTER AND ACCUMULTOR LEAVING RESULT IN ACCUMULATOR``Y`N`N`N`N`Y`N BETWEEN MEMORY REGISTER AND ACCUMULTOR LEAVING RESULT IN ACCUMULATOR 070` $..``46`01000110`LOGICAL SHIFT RIGHT, ZERO PAGE`HIFT ALL BITS OF MEMORY RIGHT. HIFT THE LOWEST BIT INTO CARRY FLAG. HIFT ZERO INTO HIGHEST BIT``Y`N`N`N`N`Y`YT THE LOWEST BIT INTO CARRY FLAG. HIFT ZERO INTO HIGHEST BIT 072```48`01001000`PUSH ACCUMULTOR ON STACK, IMPLIED`LACES CONTENT OF ACCUMULATOR ON STACK AND DECREMENTS STACK POINTER``N`N`N`N`N`N`NES CONTENT OF ACCUMULATOR ON STACK AND DECREMENTS STACK POINTER 073` ..``49`01001001`EXCLUSIVE OR, IMEDIATE`A EOR M = A ERFORMS EOR BETWEEN NUMBER IN DATA REGISTER AND ACCUMULTOR LEAVING RESULT IN ACCUMULATOR``Y`N`N`N`N`Y`NN NUMBER IN DATA REGISTER AND ACCUMULTOR LEAVING RESULT IN ACCUMULATOR   040404 04 04 04 0505050506060606060707070707 07 07 08 08 , 0408 12 16 20 17 17 18 18 18 18 18 18 18 18 19 19 19 19 19 19 20 20 074```4A`01001010`LOGICAL SHIFT RIGHT, ACCUMULATOR`HIFT ALL BITS OF ACCUMULATOR RIGHT. HIFT THE LOWEST BIT INTO CARRY FLAG. HIFT ZERO INTO HIGHEST BIT``Y`N`N`N`N`Y`YIFT THE LOWEST BIT INTO CARRY FLAG. HIFT ZERO INTO HIGHEST BIT  076` $....``4C`01001100`JUMP, ABSOLUTE`PC= ADDRESS IN COMMAND. HIS COMMAND PLACES DATA IN COMMAND STATEMENT INTO THE PROGRAM COUNTER AND EXECUTION CONTINUES FROM THERE``N`N`N`N`N`N`NOMMAND STATEMENT INTO THE PROGRAM COUNTER AND EXECUTION CO 077` $....``4D`01011101`EXCLUSIVE OR, ABSOLUTE`A EOR M = A ERFORMS EOR BETWEEN NUMBER IN DATA REGISTER AND ACCUMULTOR LEAVING RESULT IN ACCUMULATOR``Y`N`N`N`N`Y`NNUMBER IN DATA REGISTER AND ACCUMULTOR LEAVING RESULT IN ACCUMULATOR  078` $....``4E`01001110`LOGICAL SHIFT RIGHT, ABSOLUTE`HIFT ALL BITS OF ACCUMULATOR RIGHT. HIFT THE LOWEST BIT INTO CARRY FLAG. HIFT ZERO INTO HIGHEST BIT``Y`N`N`N`N`Y`Y THE LOWEST BIT INTO CARRY FLAG. HIFT ZERO INTO HIGHEST BIT  080```50`01010000`BRANCH IF OVERFLOW CLEAR`TESTS THE OVERFLOW FLAG. F CLEARED, EQUAL TO ZERO, IT WILL ADD THE NUMBER IN THE COMMAND TO THE PROGRAM COUNTER. F SET, WILL CONTINUE AT NEXT CONSECUTIVE COMMAND IN PROGRAM.``N`N`N`N`N`N`N COUNTE  081` ($..),Y``51`01010001`EXCLUSIVE OR, INDIRECT, INDEXED`A EOR M = A ERFORMS EOR BETWEEN NUMBER IN DATA REGISTER AND ACCUMULTOR LEAVING RESULT IN ACCUMULATOR``Y`N`N`N`N`Y`NATA REGISTER AND ACCUMULTOR LEAVING RESULT IN ACCUMULATOR  085` $..,X``55`01010101`EXCLUSIVE OR, ZERO PAGE, INDEXED`A EOR M = A ERFORMS EOR BETWEEN NUMBER IN DATA REGISTER AND ACCUMULTOR LEAVING RESULT IN ACCUMULATOR``Y`N`N`N`N`Y`NDATA REGISTER AND ACCUMULTOR LEAVING RESULT IN ACCUMULATOR  086` $..,X``56`01010110`LOGICAL SHIFT RIGHT, ZERO PAGE, INDEXED`HIFT ALL BITS OF ACCUMULATOR RIGHT. HIFT THE LOWEST BIT INTO CARRY FLAG. HIFT ZERO INTO HIGHEST BIT``Y`N`N`N`N`Y`YT BIT INTO CARRY FLAG. HIFT ZERO INTO HIGHEST BIT  088```58`01011000`CLEAR INTERRUPT INHIBIT`CLEARS, ZEROS, THE INTERRUPT INHIBIT FLAG. LLOWS THE CPU TO RESPOND TO AN INTERRUPT SIGNAL``N`N`N`N`Y`N`NINTERRUPT INHIBIT FLAG. LLOWS THE CPU TO RESPOND TO AN INTERRUPT SIGNAL  089` $....,Y``59`01011001`EXCLUSIVE OR, ABSOLUTE, INDEXED`A EOR M = A ERFORMS EOR BETWEEN NUMBER IN DATA REGISTER AND ACCUMULTOR LEAVING RESULT IN ACCUMULATOR``Y`N`N`N`N`Y`NATA REGISTER AND ACCUMULTOR LEAVING RESULT IN ACCUMULATOR  093` $....,X``5D`01011101`EXCLUSIVE OR, ABSOLUTE, INDEXED`A EOR M = A ERFORMS EOR BETWEEN NUMBER IN DATA REGISTER AND ACCUMULTOR LEAVING RESULT IN ACCUMULATOR``Y`N`N`N`N`Y`NATA REGISTER AND ACCUMULTOR LEAVING RESULT IN ACCUMULATOR 094` $....,X``5E`01011110`LOGICAL SHIFT RIGHT, ABSOLUTE, INDEXED`HIFT ALL BITS OF ACCUMULATOR RIGHT. HIFT THE LOWEST BIT INTO CARRY FLAG. HIFT ZERO INTO HIGHEST BIT``Y`N`N`N`N`Y`Y BIT INTO CARRY FLAG. HIFT ZERO INTO HIGHEST BIT 096```60`01100000`RETURN FROM SUBROUTINE`ETURN COMMAND FOR SUBROUTINE. ULLS DATA OFF THE STACK AND SETS PROGRAM COUNTER WITH IT, INCREMENTING STACK POINTER.``N`N`N`N`N`N`NFF THE STACK AND SETS PROGRAM COUNTER WITH IT, INCREMENTING STACK PO 097` ($..,X)``61`01100001`ADD ACCUMULATOR WITH CARRY, INDEXED INDIRECT`A+M+C=A,C ADDS NUMBER IN ACCUMULATOR TO NUMBER IN MEMORY, IF THE RESULT WAS GREATER THAN EIGHT BITS, SETS CARRY FLAG``Y`Y`N`N`N`Y`YWAS GREATER THAN EIGHT BITS, SETS CARRY  101` $..``65`01100101`ADD ACCUMULATOR WITH CARRY`A+M+C=A,C ADDS NUMBER SPECIFIED BY A ZERO PAGE ADDRESS TO NUMBER IN ACCUMULATOR LEAVING THE RESULTS IN THE ACCUMULATOR AND SETTING THE CARRY FLAG IF RESULT WAS GREATER THAN EIGHT BITS.``Y`Y`N`N` N`Y`Y AND SETTING THE CARRY FLAG IF RESULT WAS GREATER THAN EIGHT BITS. Y FLAG IF RESULT EXCEDED EIGHT BITS.``Y`Y`N`N`N`Y`YMULATOR AND SETTING THE CARRY FLAG IF RESULT EXCEDED EIGHT BITS.  102` $..``66`01100110`ROTATE RIGHT, ZERO PAGE`ROTATE ALL BITS IN THE MEMORY REGISTER RIGHT. ONTENTS OF THE CARRY FLAG ARE ROTATED INTO THE HIGHEST BIT AND THE LOWEST BIT IS ROTATED INTO THE CARRY FLAG``Y`N`N`N`N`Y`YNTO THE HIGHEST BIT AND T  104```68`01101000`PULLS ACCUMULATOR FROM STACK, IMPLIED`LACES CONTENT OF STACK INTO ACCUMULATOR AND INCREMENTS STACK POINTER``Y`N`N`N`N`Y`NTENT OF STACK INTO ACCUMULATOR AND INCREMENTS STACK POINTER  105` ..``69`01101001`ADD ACCUMULATOR WITH CARRY`A+M+C=A,C ADDS SPECIFIED NUMBER, IN DATA BUFFER, TO NUMBER IN ACCUMULATOR LEAVING THE RESULTS IN THE ACCUMULATOR AND SETTING THE CARRY FLAG IF RESULT WAS GREATER THAN EIGHT BITS.``Y`Y`N`N`N`Y`Y  106```6A`01101010`ROTATE RIGHT, ACCUMULATOR`ROTATE ALL BITS IN THE ACCUMULATOR REGISTER RIGHT. ONTENTS OF THE CARRY FLAG ARE ROTATED INTO THE HIGHEST BIT AND THE LOWEST BIT IS ROTATED INTO THE CARRY FLAG``Y`N`N`N`N`Y`Y INTO THE HIGHEST BIT  108` ($....)``6C`01101100`JUMP, INDIRECT`PC= DATA HIS COMMAND PLACES DATA FOUND AT ADDRESS POINTED TO BY STATEMENT INTO THE PROGRAM COUNTER AND EXECUTION CONTINUES FROM THERE``N`N`N`N`N`N`N BY STATEMENT INTO THE PROGRAM COUNTER AND EXECU   109` $....``6D`01101101`ADD ACCUMULATOR WITH CARRY`A+M+C=A,C TAKES A NUMBER FOUND IN MEMORY DESIGNATED BY ABSOLUTE (SIXTEEN BIT) ADDRES IN COMMAND AND ADDS IT TO NUMBER IN ACCUMULATOR LEAVING THE RESULTS IN THE ACCUMULATOR AND SETTING THE CARR  110` $....``6E`01101110`ROTATE RIGHT, ZERO PAGE, ABSOLUTE`ROTATE ALL BITS IN THE MEMORY REGISTER RIGHT. ONTENTS OF THE CARRY FLAG ARE ROTATED INTO THE HIGHEST BIT AND THE LOWEST BIT IS ROTATED INTO THE CARRY FLAG``Y`N`N`N`N`Y`YEST BIT AND T  112```70`01110000`BRANCH IF OVERFLOW SET`TESTS THE OVERFLOW FLAG. F SET, EQUAL TO ONE, IT WILL ADD THE NUMBER IN THE COMMAND TO THE PROGRAM COUNTER. F CLEARED, WILL CONTINUE AT NEXT CONSECUTIVE COMMAND IN PROGRAM.``N`N`N`N`N`N`NOUNTER.  08 08 08 08 09 09 09 09 10 10 10 10 10 10 10 11 11 11 11 11 12 12 12 12   113` ($..),Y``71`01110001`ADD ACCUMULATOR WITH CARRY, INDIRECT INDEXED`A+M+C=A,C ADDS THE ACCUMULATOR TO MEMORY. ARRY IS SET IF THE RESULT IS GREATER THAN EIGHT BITS CAN HANDLE``Y`Y`N`N`N`Y`YRESULT IS GREATER THAN EIGHT BITS CAN HANDLE   117` $..,X``75`01110101`ADD ACCUMULATOR WITH CARRY, ZERO PAGE INDEXED`A+M+C=A,C TAKES A NUMBER FOUND IN MEMORY AND ADDS IT TO NUMBER IN ACCUMULATOR LEAVING THE RESULTS IN THE ACCUMULATOR AND SETTING THE CARRY FLAG IF RESULT EXCEDED EIGHT BITS. ``Y`Y`N`N`N`Y`Y THE CARRY FLAG IF RESULT EXCEDED EIGHT BITS. .``Y`Y`N`N`N`Y`YTHE CARRY FLAG IF RESULT EXCEDED EIGHT BITS.  118` $..,X``76`01110110`ROTATE RIGHT, ZERO PAGE, INDEXED`ROTATE ALL BITS IN THE MEMORY REGISTER RIGHT. ONTENTS OF THE CARRY FLAG ARE ROTATED INTO THE HIGHEST BIT AND THE LOWEST BIT IS ROTATED INTO THE CARRY FLAG``Y`N`N`N`N`Y`YHEST BIT AND T  120```78`01111000`SET INTERRUPT, IMPLIED`ETS THE INTERRUPT FLAG TO 1. REVENTS THE CPU FROM ACKNOWLEDGING AN INTERRUPT REQUEST``N`N`N`N`Y`N`NRRUPT FLAG TO 1. REVENTS THE CPU FROM ACKNOWLEDGING AN INTERRUPT REQUEST   121` $....,Y``79`01111001`ADD ACCUMULATOR WITH CARRY, ABSOLUTE INDEXED`A+M+C=A,C TAKES A NUMBER FOUND IN MEMORY AND ADDS IT TO NUMBER IN ACCUMULATOR LEAVING THE RESULTS IN THE ACCUMULATOR AND SETTING THE CARRY FLAG IF RESULT EXCEDED EIGHT BITS  125` $....,X``7D`01111101`ADD ACCUMULATOR WITH CARRY, ABSOLUTE INDEXED`A+M+C=A,C TAKES A NUMBER FOUND IN MEMORY AND ADDS IT TO NUMBER IN ACCUMULATOR LEAVING THE RESULTS IN THE ACCUMULATOR AND SETTING THE CARRY FLAG IF RESULT EXCEDED EIGHT BITS .``Y`Y`N`N`N`Y`YTHE CARRY FLAG IF RESULT EXCEDED EIGHT BITS. 160` ..``A0`10100000`LOAD Y REGISTER, IMMEDIATE`Y=M OAD Y REGISTER WITH DATA FROM BUFFER``Y`N`N`N`N`Y`N  126` $....,X``7E`01111110`ROTATE RIGHT, ZERO PAGE, ABSOLUTE, INDEXED`ROTATE ALL BITS IN THE MEMORY REGISTER RIGHT. ONTENTS OF THE CARRY FLAG ARE ROTATED INTO THE HIGHEST BIT AND THE LOWEST BIT IS ROTATED INTO THE CARRY FLAG``Y`N`N`N`N`Y`Y T  129` ($..,X)``81`10000001`STORE ACCUMULATOR, INDEXED, INDIRECT`STORES THE CONTENTS OF THE ACCUMULATOR IN MEMORY SPECIFIED``N`N`N`N`N`N`N THE CONTENTS OF THE ACCUMULATOR IN MEMORY SPECIFIED  132` $..``84`10000100`STORE Y REGISTER, ZERO PAGE`STORES THE CONTENTS OF THE Y REGISTER IN MEMORY SPECIFIED``N`N`N`N`N`N`N STORES THE CONTENTS OF THE Y REGISTER IN MEMORY SPECIFIED  133` $..``85`10000101`STORE ACCUMULATOR, ZERO PAGE`STORES THE CONTENTS OF THE ACCUMULATOR IN MEMORY SPECIFIED``N`N`N`N`N`N`N STORES THE CONTENTS OF THE ACCUMULATOR IN MEMORY SPECIFIED  134` $..``86`10000110`STORE X REGISTER, ZERO PAGE`STORES THE CONTENTS OF THE X REGISTER IN MEMORY SPECIFIED``N`N`N`N`N`N`N STORES THE CONTENTS OF THE X REGISTER IN MEMORY SPECIFIED  136```88`10001000`DECREASE Y REGISTER`Y=Y-1 UBTRACT ONE FROM X REGISTER. T ZERO WILL LOOP ARROUND TO #$FF``Y`N`N`N`N`Y`N Y=Y-1 UBTRACT ONE FROM X REGISTER. T ZERO WILL LOOP ARROUND TO #$FF  138```8A`10001010`TRANSFER X REGISTER TO ACCUMULATOR, IMPLIED`UPLICATES CONTENTS OF X REGISTER IN ACCUMULATOR``Y`N`N`N`N`Y`N UPLICATES CONTENTS OF X REGISTER IN ACCUMULATOR 140` $....``8C`10001100`STORE Y REGISTER, ABSOLUTE`STORES THE CONTENTS OF THE Y REGISTER IN MEMORY SPECIFIED``N`N`N`N`N`N`N STORES THE CONTENTS OF THE Y REGISTER IN MEMORY SPECIFIED 141` $....``8D`10001101`STORE ACCUMULATOR, ABSOLUTE`STORES THE CONTENTS OF THE ACCUMULATOR IN MEMORY SPECIFIED``N`N`N`N`N`N`N STORES THE CONTENTS OF THE ACCUMULATOR IN MEMORY SPECIFIED 142` $....``8E`10001110`STORE X REGISTER, ABSOLUTE`STORES THE CONTENTS OF THE X REGISTER IN MEMORY SPECIFIED``N`N`N`N`N`N`N STORES THE CONTENTS OF THE X REGISTER IN MEMORY SPECIFIED 144```90`10010000`BRANCH IF CARRY CLEARED`TESTS THE CARRY FLAG. F CLEARED, EQUAL TO ZERO, IT WILL ADD THE NUMBER IN THE COMMAND TO THE PROGRAM COUNTER. F SET WILL CONTINUE AT NEXT CONSECUTIVE COMMAND IN PROGRAM.``N`N`N`N`N`N`NAM COUNTER. 145` ($..),Y``91`10010001`STORE ACCUMULATOR, INDIRECT, INDEXED`STORES THE CONTENTS OF THE ACCUMULATOR IN MEMORY SPECIFIED``N`N`N`N`N`N`N THE CONTENTS OF THE ACCUMULATOR IN MEMORY SPECIFIED  148` $..,X``94`10010100`STORE Y REGISTER, ZERO PAGE, INDEXED`STORES THE CONTENTS OF THE Y REGISTER IN MEMORY SPECIFIED``N`N`N`N`N`N`NRES THE CONTENTS OF THE Y REGISTER IN MEMORY SPECIFIED  149` $..,X``95`10010101`STORE ACCUMULATOR, ZERO PAGE, INDEXED`STORES THE CONTENTS OF THE ACCUMULATOR IN MEMORY SPECIFIED``N`N`N`N`N`N`NS THE CONTENTS OF THE ACCUMULATOR IN MEMORY SPECIFIED  150` $..,Y``96`10010110`STORE X REGISTER, ZERO PAGE, INDEXED`STORES THE CONTENTS OF THE X REGISTER IN MEMORY SPECIFIED``N`N`N`N`N`N`NRES THE CONTENTS OF THE X REGISTER IN MEMORY SPECIFIED  152```98`10011000`TRANSFER Y REGISTER TO ACCUMULATOR, IMPLIED`UPLICATES CONTENTS OF Y REGISTER IN ACCUMULATOR``Y`N`N`N`N`Y`N UPLICATES CONTENTS OF Y REGISTER IN ACCUMULATOR  153` $....,Y``99`10011001`STORE ACCUMULATOR, ABSOLUTE, INDEXED`STORES THE CONTENTS OF THE ACCUMULATOR IN MEMORY SPECIFIED``N`N`N`N`N`N`N THE CONTENTS OF THE ACCUMULATOR IN MEMORY SPECIFIED  154```9A`10011010`TRANSFER X REGISTER TO STACK POINTER, IMPLIED`UPLICATES CONTENTS OF X REGISTER IN STACK POINTER``N`N`N`N`N`N`N UPLICATES CONTENTS OF X REGISTER IN STACK POINTER   12 13 13 13 13 13 14 14 14 14 14 14 14 15 15 15 15 15 16 16 16 16 16 16   157` $....,X``9D`10011101`STORE ACCUMULATOR, ABSOLUTE, INDEXED`STORES THE CONTENTS OF THE ACCUMULATOR IN MEMORY SPECIFIED``N`N`N`N`N`N`N THE CONTENTS OF THE ACCUMULATOR IN MEMORY SPECIFIED 161` ($..,X)``A1`10100001`LOAD ACCUMULATOR, INDEXED, INDIRECT`A=M OAD THE ACCUMULATOR FROM MEMORY``Y`N`N`N`N`Y`N 162` ..``A2`10100010`LOAD X REGISTER, IMMEDIATE`A=M OAD THE X REGISTER FROM THE DATA BUFFER``Y`N`N`N`N`Y`N 164` $..``A4`10100100`LOAD Y REGISTER, ZERO PAGE`Y=M OAD Y REGISTER WITH DATA FROM MEMORY``Y`N`N`N`N`Y`N 165` $..``A5`10100101`LOAD ACCUMULATOR, ZERO PAGE`A=M OAD THE ACCUMULATOR FROM MEMORY``Y`N`N`N`N`Y`N 166` $..``A6`10100110`LOAD X REGISTER, ZERO PAGE`A=M OAD THE X REGISTER FROM MEMORY``Y`N`N`N`N`Y`N 169` ..``A9`10101001`LOAD ACCUMULATOR, IMMEDIATE`A=M OAD THE ACCUMULATOR WITH DATA FROM DATA BUFFER``Y`N`N`N`N`Y`N  168```A8`10101000`TRANSFER ACCUMULATOR TO Y REGISTER, IMPLIED`UPLICATES CONTENTS OF ACCUMULATOR IN Y REGISTER.``Y`N`N`N`N`Y`N UPLICATES CONTENTS OF ACCUMULATOR IN Y REGISTER.  170```AA`10101010`TRANSFER ACCUMULATOR TO X REGISTER, IMPLIED`UPLICATES CONTENTS OF ACCUMULATOR IN X REGISTER.``Y`N`N`N`N`Y`N UPLICATES CONTENTS OF ACCUMULATOR IN X REGISTER. 172` $....``AC`10101100`LOAD Y REGISTER, ABSOLUTE`Y=M OAD Y REGISTER WITH DATA FROM MEMORY``Y`N`N`N`N`Y`N 173` $....``AD`10101101`LOAD ACCUMULATOR, ABSOLUTE`A=M OAD THE ACCUMULATOR FROM MEMORY``Y`N`N`N`N`Y`N 174` $....``AE`10101110`LOAD X REGISTER, ABSOLUTE`A=M OAD THE X REGISTER FROM MEMORY``Y`N`N`N`N`Y`N 177` ($..),Y``B1`10110001`LOAD ACCUMULATOR, INDIRECT, INDEXED`A=M OAD THE ACCUMULATOR FROM MEMORY``Y`N`N`N`N`Y`N 176```B0`10110000`BRANCH IF CARRY SET`TESTS THE CARRY FLAG. F SET, EQUAL TO ONE, IT WILL ADD THE NUMBER IN THE COMMAND TO THE PROGRAM COUNTER. F NOT SET WILL CONTINUE AT NEXT CONSECUTIVE COMMAND IN PROGRAM.``N`N`N`N`N`N`NAM COUNTER. F N 180` $..,X``B4`10110100`LOAD Y REGISTER, ZERO PAGE, INDEXED`Y=M OAD Y REGISTER WITH DATA FROM MEMORY``Y`N`N`N`N`Y`N181` $..,X``B5`10110101`LOAD ACCUMULATOR, ZERO PAGE, INDEXED`A=M OAD THE ACCUMULATOR FROM MEMORY``Y`N`N`N`N`Y`N 182` $..,Y``B6`10110110`LOAD X REGISTER, INDEXED`A=M OAD THE X REGISTER FROM MEMORY``Y`N`N`N`N`Y`N 184```B8`10111000`CLEAR OVERFLOW`CLEARS, ZEROS, THE OVERFLOW FLAG.``N`Y`N`N`Y`N`N 185` $....,Y``B9`10111001`LOAD ACCUMULATOR, ABSOLUTE, INDEXED`A=M OAD THE ACCUMULATOR FROM MEMORY``Y`N`N`N`N`Y`N 189` $....,X``BD`10111101`LOAD ACCUMULATOR, ABSOLUTE, INDEXED`A=M OAD THE ACCUMULATOR FROM MEMORY``Y`N`N`N`N`Y`N  186```BA`10111010`TRANSFER STACK POINTER TO X REGISTER, IMPLIED`UPLICATES CONTENTS OF STACK POINTER IN X REGISTER.``Y`N`N`N`N`Y`NUPLICATES CONTENTS OF STACK POINTER IN X REGISTER.  188` $....,X``BC`10111100`LOAD Y REGISTER, ABSOLUTE, INDEXED`Y=M OAD Y REGISTER WITH DATA FROM MEMORY``Y`N`N`N`N`Y`N Y=M OAD Y REGISTER WITH DATA FROM MEMORY 190` $....,Y``BE`10111110`LOAD X REGISTER, ABSOLUTE, INDEXED`A=M OAD THE X REGISTER FROM MEMORY``Y`N`N`N`N`Y`N 216```D8`11011000`CLEAR DECIMAL`CLEARS, ZEROS, THE DECIMAL FLAG. REVENTS BINARY CODED DECIMAL MATH``N`N`N`Y`N`N`N   16 16 17 17 17 17 17 17 18 18 18 18 18 18 18 18 19 19 19 19 19 19 20 20   192` ..``C0`11000000`COMPARE Y REGISTER WITH MEMORY, IMMEDIATE`Y-M, OMPARE CONTENTS OF Y REGISTER WITH NUMBER, IN DATA BUFFER. FFECTS FLAGS``Y`N`N`N`N`Y`YEGISTER WITH NUMBER, IN DATA BUFFER. FFECTS FLAGS 193` ($..,X)``C1`11000001`COMPARE ACCUMULATOR WITH MEMORY, INDEXED INDIRECT`A-M COMPARE NUMBER IN ACCUMULATOR WITH MEMORY. OMPARE SUBTRACTS MEMORY FROM ACCUMULATOR AFFECTING FLAGS FOR RESULTS``Y`N`N`N`N`Y`YACCUMULATOR AFFECTING FLAGS FOR RE 196` $..``C4`11000100`COMPARE Y REGISTER WITH MEMORY, ZERO PAGE`Y-M, OMPARE CONTENTS OF X REGISTER WITH ZERO PAGE MEMORY. FFECTS FLAGS``Y`N`N`N`N`Y`YOF X REGISTER WITH ZERO PAGE MEMORY. FFECTS FLAGS 197` $..``C5`11000101`COMPARE ACCUMULATOR WITH ZERO PAGE MEMORY`A-M, COMPARE(SUBTRACT) NUMBER FOUND AT ZERO PAGE ADDRESS FROM NUMBER IN ACCUMULATOR``Y`N`N`N`N`Y`YUND AT ZERO PAGE ADDRESS FROM NUMBER IN ACCUMULATOR 198` $..``C6`11000110`DECREASE MEMORY, ZERO PAGE`M=M-1 UBTRACT ONE FROM MEMORY. T ZERO WILL LOOP ARROUND TO #$FF``Y`N`N`N`N`Y`NM=M-1 UBTRACT ONE FROM MEMORY. T ZERO WILL LOOP ARROUND TO #$FF 200```C8`11001000`INCREASE Y REGISTER, IMPLIED`Y=Y+1 NCREASE Y REGISTER BY ONE. ILL ROLL ARROUND TO ZERO``Y`N`N`N`N`Y`N Y=Y+1 NCREASE Y REGISTER BY ONE. ILL ROLL ARROUND TO ZERO  201` ..``C9`11001001`COMPARE ACCUMULATOR WITH MEMORY, IMMEDIATE`A-M,C COMPARE(SUBTRACT) SPECIFIED NUMBER, IN DATA BUFFER, FROM NUMBER IN ACCUMULATOR``Y`N`N`N`N`Y`YNUMBER, IN DATA BUFFER, FROM NUMBER IN ACCUMULATOR  202```CA`11001010`DECREASE X REGISTER, IMPLIED`X=X-1 UBTRACT ONE FROM X REGISTER. T ZERO WILL LOOP ARROUND TO #$FF``Y`N`N`N`N`Y`NX-1 UBTRACT ONE FROM X REGISTER. T ZERO WILL LOOP ARROUND TO #$FF  204` $....``CC`11001100`COMPARE Y REGISTER WITH MEMORY, ABSOLUTE`Y-M, OMPARE CONTENTS OF X REGISTER WITH ABSOLUTE MEMORY. FFECTS FLAGS``Y`N`N`N`N`Y`YOF X REGISTER WITH ABSOLUTE MEMORY. FFECTS FLAGS  205` $....``CD`11001101`COMPARE ACCUMULATOR WITH MEMORY, ABSOLUTE`A-M,C TAKES A NUMBER FOUND IN MEMORY DESIGNATED BY ABSOLUTE (SIXTEEN BIT) ADDRESS IN COMMAND AND SUBTRACTS IT FROM NUMBER IN ACCUMULATOR``Y`N`N`N`N`Y`YMMAND AND SUBTRACTS IT FR  206` $....``CE`11001110`DECREASE MEMORY, ABSOLUTE`M=M-1 UBTRACT ONE FROM MEMORY. T ZERO WILL LOOP ARROUND TO #$FF``Y`N`N`N`N`Y`N=M-1 UBTRACT ONE FROM MEMORY. T ZERO WILL LOOP ARROUND TO #$FF  208```D0`11010000`BRANCH IF NOT EQUAL`TESTS THE ZERO(EQUAL)FLAG. F CLEARED, EQUAL TO ZERO, IT WILL ADD THE NUMBER IN THE COMMAND TO THE PROGRAM COUNTER. F SET, IT WILL CONTINUE AT NEXT CONSECUTIVE COMMAND IN PROGRAM.``N`N`N`N`N`N`NAM COUN  209` ($..),Y``D1`11010001`COMPARE ACCUMULATOR WITH MEMORY, INDIRECT INDEXED`A-M, OMPARES ACCUMULATOR WITH MEMORY REPORTING RESULTS WITH FLAGS.``Y`N`N`N`N`Y`YTH MEMORY REPORTING RESULTS WITH FLAGS.  213` $..,X``D5`11010101`COMPARE ACCUMULATOR WITH MEMORY, ZERO PAGE INDEXED`A-M, COMPARES ACCUMULATOR WITH MEMORY, RESULT AFFECT FLAGS. CCUMULTOR NOT CHANGED.``Y`N`N`N`N`Y`YT AFFECT FLAGS. CCUMULTOR NOT CHANGED.  214` $..,X``D6`11010110`DECREASE MEMORY, ZERO PAGE, INDEXED`M=M-1 UBTRACT ONE FROM MEMORY. T ZERO WILL LOOP ARROUND TO #$FF``Y`N`N`N`N`Y`NACT ONE FROM MEMORY. T ZERO WILL LOOP ARROUND TO #$FF  217` $....,Y``D9`11011001`COMPARE ACCUMULATOR WITH MEMORY, INDEXED`A-M, TAKES A NUMBER FOUND IN THE MEMORY AND SUBTRACTS IT FROM NUMBER IN ACCUMULATOR. ESULTS REPORTED BY FLAGS. CCUMULATOR NOT AFFECTED.``Y`N`N`N`N`Y`YLTS REPORTED BY FLAGS.  221` $....,X``DD`11011101`COMPARE ACCUMULATOR WITH MEMORY, INDEXED`A-M, OMPARES ACCUMULATOR WITH MEMORY. ESULTS CHANGE FLAGS``Y`N`N`N`N`Y`YS ACCUMULATOR WITH MEMORY. ESULTS CHANGE FLAGS  222` $....,X``DE`11011110`DECREASE MEMORY, ABSOLUTE, INDEXED`M=M-1 UBTRACT ONE FROM MEMORY. T ZERO WILL LOOP ARROUND TO #$FF``Y`N`N`N`N`Y`NCT ONE FROM MEMORY. T ZERO WILL LOOP ARROUND TO #$FF  224` ..``E0`11100000`COMPARE X REGISTER WITH MEMORY, IMMEDIATE`X-M, OMPARE CONTENTS OF X REGISTER WITH NUMBER, IN DATA BUFFER. FFECTS FLAGS``Y`N`N`N`N`Y`YEGISTER WITH NUMBER, IN DATA BUFFER. FFECTS FLAGS  225` ($..,X)``E1`11100001`SUBTRACT WITH CARRY, INDEXED, INDIRECT`A-M=A UBTRACTS MEMORY REGISTER FROM ACCUMULATOR. ORROWING FROM THE CARRY FLAG IF ACCUMULATOR CONTENTS IS TOO SMALL``Y`N`N`N`N`Y`YHE CARRY FLAG IF ACCUMULATOR CONTENTS IS TOO  228` $..``E4`11100100`COMPARE X REGISTER WITH MEMORY, ZERO PAGE`X-M, OMPARE CONTENTS OF X REGISTER WITH ZERO PAGE MEMORY. FFECTS FLAGS``Y`N`N`N`N`Y`YOF X REGISTER WITH ZERO PAGE MEMORY. FFECTS FLAGS 229` $..``E5`11100101`SUBTRACT WITH CARRY, ZERO PAGE`A-M=A UBTRACTS MEMORY REGISTER FROM ACCUMULATOR. ORROWING FROM THE CARRY FLAG IF ACCUMULATOR CONTENTS IS TOO SMALL``Y`N`N`N`N`Y`YOWING FROM THE CARRY FLAG IF ACCUMULATOR CONTENTS IS TOO  230` $..``E6`11100110`INCREASE MEMORY, ZERO PAGE`M=M+1 NCREASE MEMORY LOCATION BY ONE. ILL ROLL ARROUND TO ZERO IF MEMORY IS #$FF``Y`N`N`N`N`Y`NMORY LOCATION BY ONE. ILL ROLL ARROUND TO ZERO IF MEMORY IS #$FF  20 20 20 20 20 20 21 21 21 21 22 22 22 22 22 22 23 23 23 23 23 23 23 24 24 24 24 24 24 25 25   232```E8`11101000`INCREASE X REGISTER, IMPLIED`X=X+1 NCREASE X REGISTER BY ONE. ILL ROLL ARROUND TO ZERO``Y`N`N`N`N`Y`N X=X+1 NCREASE X REGISTER BY ONE. ILL ROLL ARROUND TO ZERO  233` ..``E9`11101001`SUBTRACT WITH CARRY, IMMEDIATE`A-M=A UBTRACTS DATA REGISTER FROM ACCUMULATOR. ORROWING FROM THE CARRY FLAG IF ACCUMULATOR CONTENTS IS TOO SMALL``Y`N`N`N`N`Y`YOWING FROM THE CARRY FLAG IF ACCUMULATOR CONTENTS IS TOO SM 234```EA`11101010`NO OPERATION`FILLER COMMAND OCCUPIES MEMORY AND EXHAUSTS TWO CLOCK CYCLES``Y`N`N`N`N`Y`Y 248```F8`11111000`SET DECIMAL, IMPLIED`ETS THE DECIMAL FLAG TO 1``N`N`N`Y`N`N`N  236` $....``EC`11101100`COMPARE X REGISTER WITH MEMORY, ABSOLUTE`X-M, OMPARE CONTENTS OF X REGISTER WITH ABSOLUTE MEMORY. FFECTS FLAGS``Y`N`N`N`N`Y`YOF X REGISTER WITH ABSOLUTE MEMORY. FFECTS FLAGS  237` $....``ED`11101101`SUBTRACT WITH CARRY, ABSOLUTE`A-M=A UBTRACTS MEMORY REGISTER FROM ACCUMULATOR. ORROWING FROM THE CARRY FLAG IF ACCUMULATOR CONTENTS IS TOO SMALL``Y`N`N`N`N`Y`YWING FROM THE CARRY FLAG IF ACCUMULATOR CONTENTS IS TOO  238` $....``EE`11101110`INCREASE MEMORY, ABSOLUTE`M=M+1 NCREASE MEMORY LOCATION BY ONE. ILL ROLL ARROUND TO ZERO IF MEMORY IS #$FF``Y`N`N`N`N`Y`NORY LOCATION BY ONE. ILL ROLL ARROUND TO ZERO IF MEMORY IS #$FF 240```F0`11110000`BRANCH IF EQUAL`TESTS THE ZERO FLAG. F SET, EQUAL TO ONE, IT WILL ADD THE NUMBER IN THE COMMAND TO THE PROGRAM COUNTER. F CLEARED WILL CONTINUE AT NEXT CONSECUTIVE COMMAND IN PROGRAM.``N`N`N`N`N`N`NROGRAM COUNTER. F CL 241` ($..),Y``F1`11110001`SUBTRACT WITH CARRY, INDIRECT, INDIRECT`A-M=A UBTRACTS MEMORY REGISTER FROM ACCUMULATOR. ORROWING FROM THE CARRY FLAG IF ACCUMULATOR CONTENTS IS TOO SMALL``Y`N`N`N`N`Y`YE CARRY FLAG IF ACCUMULATOR CONTENTS IS TOO 245` $..,X``F5`11110101`SUBTRACT WITH CARRY, ZERO PAGE, INDEXED`A-M=A UBTRACTS MEMORY REGISTER FROM ACCUMULATOR. ORROWING FROM THE CARRY FLAG IF ACCUMULATOR CONTENTS IS TOO SMALL``Y`N`N`N`N`Y`YTHE CARRY FLAG IF ACCUMULATOR CONTENTS IS TOO 246` $..,X``F6`11110110`INCREASE MEMORY, ZERO PAGE, INDEXED`M=M+1 NCREASE MEMORY LOCATION BY ONE. ILL ROLL ARROUND TO ZERO IF MEMORY IS #$FF``Y`N`N`N`N`Y`NON BY ONE. ILL ROLL ARROUND TO ZERO IF MEMORY IS #$FF 249` $....,Y``F9`11111001`SUBTRACT WITH CARRY, ABSOLUTE, INDEXED`A-M=A UBTRACTS MEMORY REGISTER FROM ACCUMULATOR. ORROWING FROM THE CARRY FLAG IF ACCUMULATOR CONTENTS IS TOO SMALL``Y`N`N`N`N`Y`YHE CARRY FLAG IF ACCUMULATOR CONTENTS IS TOO  253` $....,X``FD`11111101`SUBTRACT WITH CARRY, ABSOLUTE, INDEXED`A-M=A UBTRACTS MEMORY REGISTER FROM ACCUMULATOR. ORROWING FROM THE CARRY FLAG IF ACCUMULATOR CONTENTS IS TOO SMALL``Y`N`N`N`N`Y`YHE CARRY FLAG IF ACCUMULATOR CONTENTS IS TOO  254` $....,X``FE`11111110`INCREASE MEMORY, ABSOLUTE, INDEXED`M=M+1 NCREASE MEMORY LOCATION BY ONE. ILL ROLL ARROUND TO ZERO IF MEMORY IS #$FF``Y`N`N`N`N`Y`NN BY ONE. ILL ROLL ARROUND TO ZERO IF MEMORY IS #$FF "N 138 8A 10001010 TRANSFER X REGISTER TO ACCUMULATOR, IMPLIED UPLICATES CONTENTS OF X REGISTER IN ACCUMULATOR Y N N N N Y N 154 9A 10011010 TRANSFER X REGISTER TO STACK POINTER, IMPLIED UPLICATES CONTENTS OF X REGISTER IN STACK POINTER N N N N N N N 152 98 10011000 TRANSFER Y REGISTER TO ACCUMULATOR, IMPLIED UPLICATES CONTENTS OF Y REGISTER IN ACCUMULATOR Y N N N N Y N UPLICATES CONTENTS OF STACK POINTER IN X REGISTER. Y N N N N Y # 00101000 PULLS PROCESSOR STATUS FROM STACK, IMPLIED LACES CONTENT OF STACK INTO PROCESSOR STATUS REGISTER AND INCREMENTS STACK POINTER. TATUS REGISTER IS THE SET OF FLAGS. Y Y Y Y Y Y Y 042 2A 00101010 ROTATE LEFT, ACCUMULATOR RO#TO THE HIGHEST BIT AND THE LOWEST BIT IS ROTATED INTO THE CARRY FLAG Y N N N N Y Y $.. 102 66 01100110 ROTATE RIGHT, ZERO PAGE ROTATE ALL BITS IN THE MEMORY REGISTER RIGHT. ONTENTS OF THE CARRY FLAG ARE ROTATED INTO THE HIGHEST BIT A#CARRY, IMMEDIATE A-M=A UBTRACTS DATA REGISTER FROM ACCUMULATOR. ORROWING FROM THE CARRY FLAG IF ACCUMULATOR CONTENTS IS TOO SMALL Y N N N N Y Y $.. 229 E5 11100101 SUBTRACT WITH CARRY, ZERO PAGE A-M=A UBTRACTS MEMORY REGISTER FROM#ROM ACCUMULATOR. ORROWING FROM THE CARRY FLAG IF ACCUMULATOR CONTENTS IS TOO SMALL Y N N N N Y Y 056 38 00111000 SET CARRY, IMPLIED ETS THE CARRY FLAG TO 1 N N N N N N Y 248 F8 11111000 SET DECIMAL, IMPLIED ETS T# 10000110 STORE X REGISTER, ZERO PAGE STORES THE CONTENTS OF THE X REGISTER IN MEMORY SPECIFIED N N N N N N N $..,Y 150 96 10010110 STORE X REGISTER, ZERO PAGE, INDEXED STORES THE CONTENTS OF THE X REGISTER IN MEMORY SPECIFIED N N# TATE ALL BITS IN THE ACCUMULATOR LEFT. ONTENTS OF THE CARRY FLAG ARE ROTATED INTO THE LOWEST BIT AND THE HIGHEST BIT IS ROTATED INTO THE CARRY FLAG Y N N N N Y Y $.. 038 26 00100110 ROTATE LEFT, ZERO PAGE ROTATE ALL BITS IN THE MEMOR# ND THE LOWEST BIT IS ROTATED INTO THE CARRY FLAG Y N N N N Y Y $..,X 118 76 01110110 ROTATE RIGHT, ZERO PAGE, INDEXED ROTATE ALL BITS IN THE MEMORY REGISTER RIGHT. ONTENTS OF THE CARRY FLAG ARE ROTATED INTO THE HIGHEST BIT AND THE LO# ACCUMULATOR. ORROWING FROM THE CARRY FLAG IF ACCUMULATOR CONTENTS IS TOO SMALL Y N N N N Y Y $..,X 245 F5 11110101 SUBTRACT WITH CARRY, ZERO PAGE, INDEXED A-M=A UBTRACTS MEMORY REGISTER FROM ACCUMULATOR. ORROWING FROM THE CARRY F# HE DECIMAL FLAG TO 1 N N N Y N N N 120 78 01111000 SET INTERRUPT, IMPLIED ETS THE INTERRUPT FLAG TO 1. REVENTS THE CPU FROM ACKNOWLEDGING AN INTERRUPT REQUEST N N N N Y N N $.. 133 85 10000101 STORE ACCUMULATOR, ZE# N N N N N $.... 142 8E 10001110 STORE X REGISTER, ABSOLUTE STORES THE CONTENTS OF THE X REGISTER IN MEMORY SPECIFIED N N N N N N N $.. 132 84 10000100 STORE Y REGISTER, ZERO PAGE STORES THE CONTENTS OF THE Y REGISTER IN#Y REGISTER LEFT. ONTENTS OF THE CARRY FLAG ARE ROTATED INTO THE LOWEST BIT AND THE HIGHEST BIT IS ROTATED INTO THE CARRY FLAG Y N N N N Y Y $..,X 054 36 00110110 ROTATE LEFT, ZERO PAGE, INDEXED ROTATE ALL BITS IN THE MEMORY REGISTER #WEST BIT IS ROTATED INTO THE CARRY FLAG Y N N N N Y Y $.... 110 6E 01101110 ROTATE RIGHT, ZERO PAGE, ABSOLUTE ROTATE ALL BITS IN THE MEMORY REGISTER RIGHT. ONTENTS OF THE CARRY FLAG ARE ROTATED INTO THE HIGHEST BIT AND THE LOWEST BIT#LAG IF ACCUMULATOR CONTENTS IS TOO SMALL Y N N N N Y Y $.... 237 ED 11101101 SUBTRACT WITH CARRY, ABSOLUTE A-M=A UBTRACTS MEMORY REGISTER FROM ACCUMULATOR. ORROWING FROM THE CARRY FLAG IF ACCUMULATOR CONTENTS IS TOO SMALL Y N N#RO PAGE STORES THE CONTENTS OF THE ACCUMULATOR IN MEMORY SPECIFIED N N N N N N N $..,X 149 95 10010101 STORE ACCUMULATOR, ZERO PAGE, INDEXED STORES THE CONTENTS OF THE ACCUMULATOR IN MEMORY SPECIFIED N N N N N N N $.... # MEMORY SPECIFIED N N N N N N N $..,X 148 94 10010100 STORE Y REGISTER, ZERO PAGE, INDEXED STORES THE CONTENTS OF THE Y REGISTER IN MEMORY SPECIFIED N N N N N N N $.... 140 8C 10001100 STORE Y REGISTER, ABSOLUTE STOR#LEFT. ONTENTS OF THE CARRY FLAG ARE ROTATED INTO THE LOWEST BIT AND THE HIGHEST BIT IS ROTATED INTO THE CARRY FLAG Y N N N N Y Y $.... 046 2E 00101110 ROTATE LEFT, ABSOLUTE ROTATE ALL BITS IN THE MEMORY REGISTER LEFT. ONTENTS OF TH# IS ROTATED INTO THE CARRY FLAG Y N N N N Y Y $....,X 126 7E 01111110 ROTATE RIGHT, ZERO PAGE, ABSOLUTE, INDEXED ROTATE ALL BITS IN THE MEMORY REGISTER RIGHT. ONTENTS OF THE CARRY FLAG ARE ROTATED INTO THE HIGHEST BIT AND THE LOWEST # N N Y Y $....,X 253 FD 11111101 SUBTRACT WITH CARRY, ABSOLUTE, INDEXED A-M=A UBTRACTS MEMORY REGISTER FROM ACCUMULATOR. ORROWING FROM THE CARRY FLAG IF ACCUMULATOR CONTENTS IS TOO SMALL Y N N N N Y Y $....,Y 249 F9 1111# 141 8D 10001101 STORE ACCUMULATOR, ABSOLUTE STORES THE CONTENTS OF THE ACCUMULATOR IN MEMORY SPECIFIED N N N N N N N $....,X 157 9D 10011101 STORE ACCUMULATOR, ABSOLUTE, INDEXED STORES THE CONTENTS OF THE ACCUMULATOR IN MEMORY SPE#ES THE CONTENTS OF THE Y REGISTER IN MEMORY SPECIFIED N N N N N N N 170 AA 10101010 TRANSFER ACCUMULATOR TO X REGISTER, IMPLIED UPLICATES CONTENTS OF ACCUMULATOR IN X REGISTER. Y N N N N Y N 168 A8 10101000 TRANSFER #E CARRY FLAG ARE ROTATED INTO THE LOWEST BIT AND THE HIGHEST BIT IS ROTATED INTO THE CARRY FLAG Y N N N N Y Y $....,X 062 3E 00111110 ROTATE LEFT, ABSOLUTE, INDEXED ROTATE ALL BITS IN THE MEMORY REGISTER LEFT. ONTENTS OF THE CARRY FL#BIT IS ROTATED INTO THE CARRY FLAG Y N N N N Y Y 064 40 01000000 RETURN FROM INTERRUPT ETURN COMMAND FOR HARDWARE TRIGGERED SUBROUTINE. ULLS DATA OFF THE STACK AND SETS PROGRAM COUNTER WITH IT. LSO RESTORES THE STATUS REGISTER #1001 SUBTRACT WITH CARRY, ABSOLUTE, INDEXED A-M=A UBTRACTS MEMORY REGISTER FROM ACCUMULATOR. ORROWING FROM THE CARRY FLAG IF ACCUMULATOR CONTENTS IS TOO SMALL Y N N N N Y Y ($..),Y 241 F1 11110001 SUBTRACT WITH CARRY, INDIRECT, IND#CIFIED N N N N N N N $....,Y 153 99 10011001 STORE ACCUMULATOR, ABSOLUTE, INDEXED STORES THE CONTENTS OF THE ACCUMULATOR IN MEMORY SPECIFIED N N N N N N N ($..),Y 145 91 10010001 STORE ACCUMULATOR, INDIRECT, INDEXED "ACCUMULATOR TO Y REGISTER, IMPLIED UPLICATES CONTENTS OF ACCUMULATOR IN Y REGISTER. Y N N N N Y N 186 BA 10111010 TRANSFER STACK POINTER TO X REGISTER, IMPLIED UPLICATES CONTENTS OF STACK POINTER IN X REGISTER. Y N N N N Y #AG ARE ROTATED INTO THE LOWEST BIT AND THE HIGHEST BIT IS ROTATED INTO THE CARRY FLAG Y N N N N Y Y 106 6A 01101010 ROTATE RIGHT, ACCUMULATOR ROTATE ALL BITS IN THE ACCUMULATOR REGISTER RIGHT. ONTENTS OF THE CARRY FLAG ARE ROTATED IN#Y Y Y Y Y Y Y 096 60 01100000 RETURN FROM SUBROUTINE ETURN COMMAND FOR SUBROUTINE. ULLS DATA OFF THE STACK AND SETS PROGRAM COUNTER WITH IT, INCREMENTING STACK POINTER. N N N N N N N #.. 233 E9 11101001 SUBTRACT WITH #IRECT A-M=A UBTRACTS MEMORY REGISTER FROM ACCUMULATOR. ORROWING FROM THE CARRY FLAG IF ACCUMULATOR CONTENTS IS TOO SMALL Y N N N N Y Y ($..,X) 225 E1 11100001 SUBTRACT WITH CARRY, INDEXED, INDIRECT A-M=A UBTRACTS MEMORY REGISTER F#STORES THE CONTENTS OF THE ACCUMULATOR IN MEMORY SPECIFIED N N N N N N N ($..,X) 129 81 10000001 STORE ACCUMULATOR, INDEXED, INDIRECT STORES THE CONTENTS OF THE ACCUMULATOR IN MEMORY SPECIFIED N N N N N N N $.. 134 86 $ 5D 01011101 EXCLUSIVE OR, ABSOLUTE, INDEXED A EOR M = A ERFORMS EOR BETWEEN NUMBER IN DATA REGISTER AND ACCUMULTOR LEAVING RESULT IN ACCUMULATOR Y N N N N Y N $....,Y 089 59 01011001 EXCLUSIVE OR, ABSOLUTE, INDEXED A EOR M = A $ ILL ROLL ARROUND TO ZERO Y N N N N Y N 200 C8 11001000 INCREASE Y REGISTER, IMPLIED Y=Y+1 NCREASE Y REGISTER BY ONE. ILL ROLL ARROUND TO ZERO Y N N N N Y N $.... 076 4C 01001100 JUMP, ABSOLUTE PC= ADDRESS IN CO$ ACCUMULATOR FROM MEMORY Y N N N N Y N ($..),Y 177 B1 10110001 LOAD ACCUMULATOR, INDIRECT, INDEXED A=M OAD THE ACCUMULATOR FROM MEMORY Y N N N N Y N ($..,X) 161 A1 10100001 LOAD ACCUMULATOR, INDEXED, INDIRECT A=M $H DATA FROM MEMORY Y N N N N Y N 074 4A 01001010 LOGICAL SHIFT RIGHT, ACCUMULATOR HIFT ALL BITS OF ACCUMULATOR RIGHT. HIFT THE LOWEST BIT INTO CARRY FLAG. HIFT ZERO INTO HIGHEST BIT Y N N N N Y Y $.. 070 46 0100011$ MS LOGICAL OR BETWEEN MEMORY AND ACCUMULATOR. ESULTS IN ACCUMULATOR Y N N N N Y N $.... 013 0D 00001101 OR ACCUMULATOR, ABSOLUTE A+M=A ERFORMS LOGICAL OR BETWEEN MEMORY AND ACCUMULATOR. ESULTS IN ACCUMULATOR Y N N N N Y N$ ERFORMS EOR BETWEEN NUMBER IN DATA REGISTER AND ACCUMULTOR LEAVING RESULT IN ACCUMULATOR Y N N N N Y N ($..),Y 081 51 01010001 EXCLUSIVE OR, INDIRECT, INDEXED A EOR M = A ERFORMS EOR BETWEEN NUMBER IN DATA REGISTER AND ACCUMULTOR LEA$ MMAND. HIS COMMAND PLACES DATA IN COMMAND STATEMENT INTO THE PROGRAM COUNTER AND EXECUTION CONTINUES FROM THERE N N N N N N N ($....) 108 6C 01101100 JUMP, INDIRECT PC= DATA HIS COMMAND PLACES DATA FOUND AT ADDRESS POINTED TO BY $ OAD THE ACCUMULATOR FROM MEMORY Y N N N N Y N #.. 162 A2 10100010 LOAD X REGISTER, IMMEDIATE A=M OAD THE X REGISTER FROM THE DATA BUFFER Y N N N N Y N $.. 166 A6 10100110 LOAD X REGISTER, ZERO PAGE A=M OAD THE X$ 0 LOGICAL SHIFT RIGHT, ZERO PAGE HIFT ALL BITS OF MEMORY RIGHT. HIFT THE LOWEST BIT INTO CARRY FLAG. HIFT ZERO INTO HIGHEST BIT Y N N N N Y Y $..,X 086 56 01010110 LOGICAL SHIFT RIGHT, ZERO PAGE, INDEXED HIFT ALL BITS OF ACCUMUL$ $....,X 029 1D 00011101 OR ACCUMULATOR, ABSOLUTE, INDEXED A+M=A ERFORMS LOGICAL OR BETWEEN MEMORY AND ACCUMULATOR. ESULTS IN ACCUMULATOR Y N N N N Y N $....,Y 025 19 00011001 OR ACCUMULATOR, ABSOLUTE, INDEXED A+M=A ERFOR$VING RESULT IN ACCUMULATOR Y N N N N Y N ($..,X) 065 41 01000001 EXCLUSIVE OR, INDEXED, INDIRECT A EOR M = A ERFORMS EOR BETWEEN NUMBER IN DATA REGISTER AND ACCUMULTOR LEAVING RESULT IN ACCUMULATOR Y N N N N Y N $.. 23$STATEMENT INTO THE PROGRAM COUNTER AND EXECUTION CONTINUES FROM THERE N N N N N N N $.... 032 20 00100000 JUMP TO SUBROUTINE PC= DATA HIS COMMAND PLACES CONTENTS OF PROGRAM COUNTER ON THE STACK. T THEN LOADS THE PROGRAM COUNTER WI$ REGISTER FROM MEMORY Y N N N N Y N $..,Y 182 B6 10110110 LOAD X REGISTER, INDEXED A=M OAD THE X REGISTER FROM MEMORY Y N N N N Y N $.... 174 AE 10101110 LOAD X REGISTER, ABSOLUTE A=M OAD THE X REGISTER FROM MEMO$ATOR RIGHT. HIFT THE LOWEST BIT INTO CARRY FLAG. HIFT ZERO INTO HIGHEST BIT Y N N N N Y Y $.... 078 4E 01001110 LOGICAL SHIFT RIGHT, ABSOLUTE HIFT ALL BITS OF ACCUMULATOR RIGHT. HIFT THE LOWEST BIT INTO CARRY FLAG. HIFT ZERO INT$MS LOGICAL OR BETWEEN MEMORY AND ACCUMULATOR. ESULTS IN ACCUMULATOR Y N N N N Y N ($..),Y 017 11 00010001 OR ACCUMULATOR, INDIRECT, INDEXED A+M=A ERFORMS LOGICAL OR BETWEEN MEMORY AND ACCUMULATOR. ESULTS IN ACCUMULATOR Y N N $0 E6 11100110 INCREASE MEMORY, ZERO PAGE M=M+1 NCREASE MEMORY LOCATION BY ONE. ILL ROLL ARROUND TO ZERO IF MEMORY IS #$FF Y N N N N Y N $..,X 246 F6 11110110 INCREASE MEMORY, ZERO PAGE, INDEXED M=M+1 NCREASE MEMORY LOCATION B$TH DATA FROM COMMAND. N N N N N N N #.. 169 A9 10101001 LOAD ACCUMULATOR, IMMEDIATE A=M OAD THE ACCUMULATOR WITH DATA FROM DATA BUFFER Y N N N N Y N $.. 165 A5 10100101 LOAD ACCUMULATOR, ZERO PAGE A=M OAD THE ACC$RY Y N N N N Y N $....,Y 190 BE 10111110 LOAD X REGISTER, ABSOLUTE, INDEXED A=M OAD THE X REGISTER FROM MEMORY Y N N N N Y N #.. 160 A0 10100000 LOAD Y REGISTER, IMMEDIATE Y=M OAD Y REGISTER WITH DATA FROM BUFF$O HIGHEST BIT Y N N N N Y Y $....,X 094 5E 01011110 LOGICAL SHIFT RIGHT, ABSOLUTE, INDEXED HIFT ALL BITS OF ACCUMULATOR RIGHT. HIFT THE LOWEST BIT INTO CARRY FLAG. HIFT ZERO INTO HIGHEST BIT Y N N N N Y Y 234 EA 11$ N N Y N ($..,X) 001 01 00000001 OR ACCUMULATOR, INDEXED, INDIRECT A+M=A ERFORMS LOGICAL OR BETWEEN MEMORY AND ACCUMULATOR. ESULTS IN ACCUMULATOR Y N N N N Y N 072 48 01001000 PUSH ACCUMULTOR ON STACK, IMPLIED LACES C$Y ONE. ILL ROLL ARROUND TO ZERO IF MEMORY IS #$FF Y N N N N Y N $.... 238 EE 11101110 INCREASE MEMORY, ABSOLUTE M=M+1 NCREASE MEMORY LOCATION BY ONE. ILL ROLL ARROUND TO ZERO IF MEMORY IS #$FF Y N N N N Y N $....,X $UMULATOR FROM MEMORY Y N N N N Y N $..,X 181 B5 10110101 LOAD ACCUMULATOR, ZERO PAGE, INDEXED A=M OAD THE ACCUMULATOR FROM MEMORY Y N N N N Y N $.... 173 AD 10101101 LOAD ACCUMULATOR, ABSOLUTE A=M OAD THE ACCUMUL$ER Y N N N N Y N $.. 164 A4 10100100 LOAD Y REGISTER, ZERO PAGE Y=M OAD Y REGISTER WITH DATA FROM MEMORY Y N N N N Y N $..,X 180 B4 10110100 LOAD Y REGISTER, ZERO PAGE, INDEXED Y=M OAD Y REGISTER WITH DATA FR$101010 NO OPERATION FILLER COMMAND OCCUPIES MEMORY AND EXHAUSTS TWO CLOCK CYCLES Y N N N N Y Y #.. 009 09 00001001 OR ACCUMULATOR, IMMEDIATE A+M=A ERFORMS LOGICAL OR BETWEEN MEMORY AND ACCUMULATOR. ESULTS IN ACCUMULATOR Y N #ONTENT OF ACCUMULATOR ON STACK AND DECREMENTS STACK POINTER N N N N N N N 104 68 01101000 PULLS ACCUMULATOR FROM STACK, IMPLIED LACES CONTENT OF STACK INTO ACCUMULATOR AND INCREMENTS STACK POINTER Y N N N N Y N 040 28 $ 254 FE 11111110 INCREASE MEMORY, ABSOLUTE, INDEXED M=M+1 NCREASE MEMORY LOCATION BY ONE. ILL ROLL ARROUND TO ZERO IF MEMORY IS #$FF Y N N N N Y N 232 E8 11101000 INCREASE X REGISTER, IMPLIED X=X+1 NCREASE X REGISTER BY ONE. $ATOR FROM MEMORY Y N N N N Y N $....,X 189 BD 10111101 LOAD ACCUMULATOR, ABSOLUTE, INDEXED A=M OAD THE ACCUMULATOR FROM MEMORY Y N N N N Y N $....,Y 185 B9 10111001 LOAD ACCUMULATOR, ABSOLUTE, INDEXED A=M OAD THE$OM MEMORY Y N N N N Y N $.... 172 AC 10101100 LOAD Y REGISTER, ABSOLUTE Y=M OAD Y REGISTER WITH DATA FROM MEMORY Y N N N N Y N $....,X 188 BC 10111100 LOAD Y REGISTER, ABSOLUTE, INDEXED Y=M OAD Y REGISTER WIT$N N N Y N $.. 005 05 00000101 OR ACCUMULATOR, ZERO PAGE A+M=A ERFORMS LOGICAL OR BETWEEN MEMORY AND ACCUMULATOR. ESULTS IN ACCUMULATOR Y N N N N Y N $..,X 021 15 00010101 OR ACCUMULATOR, ZERO PAGE, INDEXED A+M=A ERFOR% #$FF Y N N N N Y N $..,X 214 D6 11010110 DECREASE MEMORY, ZERO PAGE, INDEXED M=M-1 UBTRACT ONE FROM MEMORY. T ZERO WILL LOOP ARROUND TO #$FF Y N N N N Y N $.... 206 CE 11001110 DECREASE MEMORY, ABSOLUTE M=M-1 UB% ADD THE NUMBER IN THE COMMAND TO THE PROGRAM COUNTER. F NOT SET WILL CONTINUE AT NEXT CONSECUTIVE COMMAND IN PROGRAM. N N N N N N N 240 F0 11110000 BRANCH IF EQUAL TESTS THE ZERO FLAG. F SET, EQUAL TO ONE, IT WILL ADD THE NUMBER I% TO ZERO, IT WILL ADD THE NUMBER IN THE COMMAND TO THE PROGRAM COUNTER. F SET, IT WILL CONTINUE AT NEXT CONSECUTIVE COMMAND IN PROGRAM. N N N N N N N 016 10 00010000 BRANCH IF PLUS TESTS THE NEGATIVE FLAG. F SET, EQUAL TO ONE, IT W%AR OVERFLOW CLEARS, ZEROS, THE OVERFLOW FLAG. N Y N N Y N N #.. 201 C9 11001001 COMPARE ACCUMULATOR WITH MEMORY, IMMEDIATE A-M,C COMPARE(SUBTRACT) SPECIFIED NUMBER, IN DATA BUFFER, FROM NUMBER IN ACCUMULATOR Y N N N N Y Y % BER IN ACCUMULATOR WITH MEMORY. OMPARE SUBTRACTS MEMORY FROM ACCUMULATOR AFFECTING FLAGS FOR RESULTS Y N N N N Y Y #.. 224 E0 11100000 COMPARE X REGISTER WITH MEMORY, IMMEDIATE X-M, OMPARE CONTENTS OF X REGISTER WITH NUMBER, IN DATA% TRACT ONE FROM MEMORY. T ZERO WILL LOOP ARROUND TO #$FF Y N N N N Y N $....,X 222 DE 11011110 DECREASE MEMORY, ABSOLUTE, INDEXED M=M-1 UBTRACT ONE FROM MEMORY. T ZERO WILL LOOP ARROUND TO #$FF Y N N N N Y N 202 CA % N THE COMMAND TO THE PROGRAM COUNTER. F CLEARED WILL CONTINUE AT NEXT CONSECUTIVE COMMAND IN PROGRAM. N N N N N N N $.. 036 24 00100100 TESTS BITS 6&7, ZERO PAGE TRANSFERS THE CONTENTS OF BITS 6 AND 7 OF A ZERO PAGE MEMORY REGISTER T% ILL ADD THE NUMBER IN THE COMMAND TO THE PROGRAM COUNTER. F CLEARED, IT WILL CONTINUE AT NEXT CONSECUTIVE COMMAND IN PROGRAM. N N N N N N N 000 00 00000000 BREAK STOPS EXECUTION OF PROGRAM AND GENERATES A FALSE INTERRUPT THAT FORCES % $.. 197 C5 11000101 COMPARE ACCUMULATOR WITH ZERO PAGE MEMORY A-M, COMPARE(SUBTRACT) NUMBER FOUND AT ZERO PAGE ADDRESS FROM NUMBER IN ACCUMULATOR Y N N N N Y Y $..,X 213 D5 11010101 COMPARE ACCUMULATOR WITH MEMORY, ZERO PAGE INDE% BUFFER. FFECTS FLAGS Y N N N N Y Y $.. 228 E4 11100100 COMPARE X REGISTER WITH MEMORY, ZERO PAGE X-M, OMPARE CONTENTS OF X REGISTER WITH ZERO PAGE MEMORY. FFECTS FLAGS Y N N N N Y Y $.... 236 EC 11101100 COMPARE% 11001010 DECREASE X REGISTER, IMPLIED X=X-1 UBTRACT ONE FROM X REGISTER. T ZERO WILL LOOP ARROUND TO #$FF Y N N N N Y N 136 88 10001000 DECREASE Y REGISTER Y=Y-1 UBTRACT ONE FROM X REGISTER. T ZERO WILL LOOP ARROUND TO #$FF %O THE FLAG REGISTERS. IT 7 GOES INTO NEG FLAG. IT 6 GOES INTO THE OVERFLOW FLAG. * N ND IS ALSO PERFORMED BETWEEN THE ACCUMULATOR AND THE SPECIFIED MEMORY WITH THE RESULTS AFFECTING THE ZERO FLAG. HIS COMMAND IS USEFUL FOR NEGATIVE NUMBER MAT%THE CPU TO EXECUTE A SPECIAL ROUTINE ROGRAM EXECUTED WILL AFFECT IRQ FLAG. N N Y N N N N 080 50 01010000 BRANCH IF OVERFLOW CLEAR TESTS THE OVERFLOW FLAG. F CLEARED, EQUAL TO ZERO, IT WILL ADD THE NUMBER IN THE COMMAND TO THE PROGRAM%XED A-M, COMPARES ACCUMULATOR WITH MEMORY, RESULT AFFECT FLAGS. CCUMULTOR NOT CHANGED. Y N N N N Y Y $.... 205 CD 11001101 COMPARE ACCUMULATOR WITH MEMORY, ABSOLUTE A-M,C TAKES A NUMBER FOUND IN MEMORY DESIGNATED BY ABSOLUTE (SIXTEE% X REGISTER WITH MEMORY, ABSOLUTE X-M, OMPARE CONTENTS OF X REGISTER WITH ABSOLUTE MEMORY. FFECTS FLAGS Y N N N N Y Y #.. 192 C0 11000000 COMPARE Y REGISTER WITH MEMORY, IMMEDIATE Y-M, OMPARE CONTENTS OF Y REGISTER WITH NUMBER, IN% Y N N N N Y N #.. 073 49 01001001 EXCLUSIVE OR, IMEDIATE A EOR M = A ERFORMS EOR BETWEEN NUMBER IN DATA REGISTER AND ACCUMULTOR LEAVING RESULT IN ACCUMULATOR Y N N N N Y N $.. 069 45 01000101 EXCLUSIVE OR, ZERO PAGE %H. Y Y N N N Y N $.... 044 2C 00101100 TESTS BITS 6&7, ABSOLUTE TRANSFERS THE CONTENTS OF BITS 6 AND 7 OF AN ABSOLUTE MEMORY REGISTER TO THE FLAG REGISTERS. IT 7 GOES INTO NEG FLAG. IT 6 GOES INTO THE OVERFLOW FLAG. * N ND IS AL% COUNTER. F SET, WILL CONTINUE AT NEXT CONSECUTIVE COMMAND IN PROGRAM. N N N N N N N 112 70 01110000 BRANCH IF OVERFLOW SET TESTS THE OVERFLOW FLAG. F SET, EQUAL TO ONE, IT WILL ADD THE NUMBER IN THE COMMAND TO THE PROGRAM COUNTER.%N BIT) ADDRESS IN COMMAND AND SUBTRACTS IT FROM NUMBER IN ACCUMULATOR Y N N N N Y Y $....,X 221 DD 11011101 COMPARE ACCUMULATOR WITH MEMORY, INDEXED A-M, OMPARES ACCUMULATOR WITH MEMORY. ESULTS CHANGE FLAGS Y N N N N Y Y % DATA BUFFER. FFECTS FLAGS Y N N N N Y Y $.. 196 C4 11000100 COMPARE Y REGISTER WITH MEMORY, ZERO PAGE Y-M, OMPARE CONTENTS OF X REGISTER WITH ZERO PAGE MEMORY. FFECTS FLAGS Y N N N N Y Y $.... 204 CC 11001100 CO%A EOR M = A ERFORMS EOR BETWEEN MEMORY REGISTER AND ACCUMULTOR LEAVING RESULT IN ACCUMULATOR Y N N N N Y N $..,X 085 55 01010101 EXCLUSIVE OR, ZERO PAGE, INDEXED A EOR M = A ERFORMS EOR BETWEEN NUMBER IN DATA REGISTER AND ACCUMULTO%SO PERFORMED BETWEEN THE ACCUMULATOR AND THE SPECIFIED MEMORY WITH THE RESULTS AFFECTING THE ZERO FLAG. HIS COMMAND IS USEFUL FOR NEGATIVE NUMBER MATH. Y Y N N N Y N 048 30 00110000 BRANCH IF MINUS TESTS THE NEGATIVE FLAG. F SET, EQ% F CLEARED, WILL CONTINUE AT NEXT CONSECUTIVE COMMAND IN PROGRAM. N N N N N N N 024 18 00011000 CLEAR CARRY CLEARS, ZEROS, THE CARRY FLAG N N N N N N Y 216 D8 11011000 CLEAR DECIMAL CLEARS, ZEROS, THE DECIMAL FLAG.% $....,Y 217 D9 11011001 COMPARE ACCUMULATOR WITH MEMORY, INDEXED A-M, TAKES A NUMBER FOUND IN THE MEMORY AND SUBTRACTS IT FROM NUMBER IN ACCUMULATOR. ESULTS REPORTED BY FLAGS. CCUMULATOR NOT AFFECTED. Y N N N N Y Y ($..),Y 209 D%MPARE Y REGISTER WITH MEMORY, ABSOLUTE Y-M, OMPARE CONTENTS OF X REGISTER WITH ABSOLUTE MEMORY. FFECTS FLAGS Y N N N N Y Y $.. 198 C6 11000110 DECREASE MEMORY, ZERO PAGE M=M-1 UBTRACT ONE FROM MEMORY. T ZERO WILL LOOP ARROUND TO$R LEAVING RESULT IN ACCUMULATOR Y N N N N Y N $.... 077 4D 01011101 EXCLUSIVE OR, ABSOLUTE A EOR M = A ERFORMS EOR BETWEEN NUMBER IN DATA REGISTER AND ACCUMULTOR LEAVING RESULT IN ACCUMULATOR Y N N N N Y N $....,X 093 %UAL TO ONE, IT WILL ADD THE NUMBER IN THE COMMAND TO THE PROGRAM COUNTER. F CLEARED WILL CONTINUE AT NEXT CONSECUTIVE COMMAND IN PROGRAM. N N N N N N N 208 D0 11010000 BRANCH IF NOT EQUAL TESTS THE ZERO(EQUAL)FLAG. F CLEARED, EQUAL% REVENTS BINARY CODED DECIMAL MATH N N N Y N N N 088 58 01011000 CLEAR INTERRUPT INHIBIT CLEARS, ZEROS, THE INTERRUPT INHIBIT FLAG. LLOWS THE CPU TO RESPOND TO AN INTERRUPT SIGNAL N N N N Y N N 184 B8 10111000 CLE%1 11010001 COMPARE ACCUMULATOR WITH MEMORY, INDIRECT INDEXED A-M, OMPARES ACCUMULATOR WITH MEMORY REPORTING RESULTS WITH FLAGS. Y N N N N Y Y ($..,X) 193 C1 11000001 COMPARE ACCUMULATOR WITH MEMORY, INDEXED INDIRECT A-M COMPARE NUM&C3 l&  100& "@INTRO.BASIC",D0:{d"HIS DISK CONTAINS A DATABASE OF THE ML COMMANDS FOR THE B128. T CAN BE USEDn"SORT COMMANDS BY NAME, BY REGISTERS AFFECTED, BY FLAGS AFFECTED, OR EVEN BYx"THE BIT PATTERN OF THE COMMAND.!"HE NA&PF Wq OCOMMAND  DECIMALVALUEHEXVALUE$ 3BINARYVALUE%IONAME  ODESCRIPTION  O COMMENT ON   O B  D 'C3N& #.. 105 69 01101001 ADD ACCUMULATOR WITH CARRY A+M+C=A,C ADDS SPECIFIED NUMBER, IN DATA BUFFER, TO NUMBER IN ACCUMULATOR LEAVING THE RESULTS IN THE ACCUMULATOR AND SETTING THE CARRY FLAG IF RESULT WAS GREATER THAN EIGHT BITS. Y Y N N N Y& ING THE RESULTS IN THE ACCUMULATOR AND SETTING THE CARRY FLAG IF RESULT EXCEDED EIGHT BITS. Y Y N N N Y Y $....,Y 121 79 01111001 ADD ACCUMULATOR WITH CARRY, ABSOLUTE INDEXED A+M+C=A,C TAKES A NUMBER FOUND IN MEMORY AND ADDS IT TO NUMB& ME OF THE DATA BASE IS MLDB .j"HE NAME OF ONE FILE IS MLCOMMANDS. T USES COMMAND NAMES FOR KEY"HE NAME OF OTHER FILE IS BINARY. T USES THE BINARY NUMBER OF THE COMMAND"FOR THE KEY."NCLUDED ON THE DISK ARE SOME HELP FILES +(I 74Z A>C ` P` ` ` ` `` `` ` ` ` #``B `  `  `   `  `` ` `` ` ` _& COMMAND. Y N N N N Y N $..,X 053 35 00110101 AND ACCUMULATOR, ZERO PAGE INDEXED A*M=A, ACCUMULATOR WILL HOLD THE RESULT OF A LOGICAL ND OPERATION BETWEEN THE NUMBER IN THE ACCUMULATOR AND A MEMORY LOCATION Y N N N N Y N & Y $.. 101 65 01100101 ADD ACCUMULATOR WITH CARRY A+M+C=A,C ADDS NUMBER SPECIFIED BY A ZERO PAGE ADDRESS TO NUMBER IN ACCUMULATOR LEAVING THE RESULTS IN THE ACCUMULATOR AND SETTING THE CARRY FLAG IF RESULT WAS GREATER THAN EIGHT BITS. Y Y &ER IN ACCUMULATOR LEAVING THE RESULTS IN THE ACCUMULATOR AND SETTING THE CARRY FLAG IF RESULT EXCEDED EIGHT BITS. Y Y N N N Y Y ($..),Y 113 71 01110001 ADD ACCUMULATOR WITH CARRY, INDIRECT INDEXED A+M+C=A,C ADDS THE ACCUMULATOR TO MEMO ON COMMAND TYPES.TRO.BASIC",D0:{d"HIS DISK CONTAINS A DATABASE OF THE ML COMMANDS FOR THE B128. T CAN BE USEDn"SORT COMMANDS BY NAME, BY REGISTERS AFFECTED, BY FLAGS AFFECTED, OR EVEN BYx"THE BIT PATTERN OF THE COMMAND.!"HE NA&UMULATOR. Y N N N N Y N ($..,X) 033 21 00100001 AND ACCUMULATOR WITH MEMORY, INDIRECT INDEXED A*M=A, ERFORMS LOGICAL OPERATION BETWEEN ACCUMULATOR AND MEMORY, LEAVES RESULT IN ACCUMULATOR. Y N N N N Y N 010 0A 000& $.... 045 2D 00101101 AND ACCUMULATOR, ABSOLUTE A*M=A, ACCUMULATOR WILL HOLD THE RESULT OF A LOGICAL ND OPERATION BETWEEN THE NUMBER IN THE ACCUMULATOR AND THE CONTENTS OF THE ADDRESS SPECIFIED Y N N N N Y N $....,X 061 3D 0011110& N N N Y Y $..,X 117 75 01110101 ADD ACCUMULATOR WITH CARRY, ZERO PAGE INDEXED A+M+C=A,C TAKES A NUMBER FOUND IN MEMORY AND ADDS IT TO NUMBER IN ACCUMULATOR LEAVING THE RESULTS IN THE ACCUMULATOR AND SETTING THE CARRY FLAG IF RESULT EXCEDED&RY. ARRY IS SET IF THE RESULT IS GREATER THAN EIGHT BITS CAN HANDLE Y Y N N N Y Y ($..,X) 097 61 01100001 ADD ACCUMULATOR WITH CARRY, INDEXED INDIRECT A+M+C=A,C ADDS NUMBER IN ACCUMULATOR TO NUMBER IN MEMORY, IF THE RESULT WAS GREATE&DRESS SHIFTS ALL THE BITS AT THE STATED SIXTEEN BIT ADDRESS TO THE LEFT. LACES THE HIGHEST BIT IN THE CARRY FLAG REGISTER. HIFTS A ZERO INTO THE LOWEST BIT. Y N N N N Y Y $....,X 030 1E 00011110 ARITHMATIC SHIFT LEFT, INDEXED SHIF&01010 ARITHMATIC SHIFT LEFT, ACCUMULATOR SHIFTS ALL THE BITS IN THE ACCUMULATOR TO THE LEFT. LACES THE HIGHEST BIT IN THE CARRY FLAG REGISTER. HIFTS A ZERO INTO THE LOWEST BIT. Y N N N N Y Y $.. 006 06 00000110 ARITHMATIC SHIFT LE&1 AND ACCUMULATOR, ABSOLUTE INDEXED A*M=A, ACCUMULATOR WILL HOLD THE RESULT OF A LOGICAL ND OPERATION BETWEEN THE NUMBER IN THE ACCUMULATOR AND THE CONTENTS OF MEMORY WHOSE ADDRESS IS EQUAL TO THE NUMBER IN THE COMMAND PLUS THE NUMBER IN THE X REGIST& EIGHT BITS. Y Y N N N Y Y $.... 109 6D 01101101 ADD ACCUMULATOR WITH CARRY A+M+C=A,C TAKES A NUMBER FOUND IN MEMORY DESIGNATED BY ABSOLUTE (SIXTEEN BIT) ADDRES IN COMMAND AND ADDS IT TO NUMBER IN ACCUMULATOR LEAVING THE RESULTS IN THE&R THAN EIGHT BITS, SETS CARRY FLAG Y Y N N N Y Y #.. 041 29 00101001 AND ACCUMULATOR, IMMEDIATE A*M=A, ACCUMULATOR WILL HOLD THE RESULT OF A LOGICAL ND OPERATION BETWEEN THE NUMBER IN THE ACCUMULATOR AND THE NUMBER SPECIFIED BY THE CO&TS ALL THE BITS AT THE MEMORY LOCATION TO THE LEFT. LACES THE HIGHEST BIT IN THE CARRY FLAG REGISTER. HIFTS A ZERO INTO THE LOWEST BIT. Y N N N N Y Y 144 90 10010000 BRANCH IF CARRY CLEARED TESTS THE CARRY FLAG. F CLEARED, EQUAL &FT, ZERO PAGE ADDRESS SHIFTS ALL THE BITS AT THE STATED ZERO PAGE ADDRESS TO THE LEFT. LACES THE HIGHEST BIT IN THE CARRY FLAG REGISTER. HIFTS A ZERO INTO THE LOWEST BIT. Y N N N N Y Y $..,X 022 16 00010110 ARITHMATIC SHIFT LEFT, Z&ER Y N N N N Y N $....,Y 057 39 00111001 AND ACCUMULATOR, ABSOLUTE INDEXED A*M=A, ACCUMULATOR WILL HOLD THE RESULT OF A LOGICAL ND OPERATION BETWEEN THE NUMBER IN THE ACCUMULATOR AND THE CONTENTS OF MEMORY WHOSE ADDRESS IS EQUAL TO TH& ACCUMULATOR AND SETTING THE CARRY FLAG IF RESULT EXCEDED EIGHT BITS. Y Y N N N Y Y $....,X 125 7D 01111101 ADD ACCUMULATOR WITH CARRY, ABSOLUTE INDEXED A+M+C=A,C TAKES A NUMBER FOUND IN MEMORY AND ADDS IT TO NUMBER IN ACCUMULATOR LEAV&MMAND. Y N N N N Y N $.. 037 25 00100101 AND ACCUMULATOR, ZERO PAGE A*M=A, ACCUMULATOR WILL HOLD THE RESULT OF A LOGICAL ND OPERATION BETWEEN THE NUMBER IN THE ACCUMULATOR AND THE NUMBER FOUND AT THE ZERO PAGE ADDRESS SPECIFIED BY THE%TO ZERO, IT WILL ADD THE NUMBER IN THE COMMAND TO THE PROGRAM COUNTER. F SET WILL CONTINUE AT NEXT CONSECUTIVE COMMAND IN PROGRAM. N N N N N N N 176 B0 10110000 BRANCH IF CARRY SET TESTS THE CARRY FLAG. F SET, EQUAL TO ONE, IT WILL&ERO PAGE ADDRESS,INDEXED SHIFTS ALL THE BITS AT MEMORY LOCATION TO THE LEFT. LACES THE HIGHEST BIT IN THE CARRY FLAG REGISTER. HIFTS A ZERO INTO THE LOWEST BIT. Y N N N N Y Y $.... 014 0E 00001110 ARITHMATIC SHIFT LEFT, ABSOLUTE AD& E NUMBER IN THE COMMAND PLUS THE NUMBER IN THE Y REGISTER Y N N N N Y N ($..),Y 049 31 00110001 AND ACCUMULATOR WITH MEMORY, INDEXED INDIRECT A*M=A, ERFORMS A LOGICAL OPERATION BETWEEN MEMORY AND ACCUMULATOR LEAVING RESULT IN ACC&CML CMDS D MD2C'&INTRO.BASIC&MLCOMMANDS&MLCMDSo(HIMMEDIATE(HIMPLIED(HINDEX(HZEROPAGE(HABSOLUTE'(BINARY(HINDIRECTINDEX( HINDEXINDIRECT( HINDIRECTION(HLIST)INTRO.BASIC.SS(START.P) ' (-- (INST.)S1)S2)S3)SSLOADER)SOLOADER)MLLOADER) .Р) &&INSTRUCT"* NOTE - TART.*!!----!!! ( MMEDIATE IS SUFFIXED ON A COMMAND WHICH CONTAINS THE DATA NEEDED IN THE CO MMAND. T IS DESIGNATED BY THE #.. ON THE KEYLINE AND CAN BE A NUMBER BETWEEN 0 AND 255. HEN THE CPU READS A IMMEDIATE COMMAND, IT PLACES THE DATA IN A BUFFER WITHIN THE CPMPLIED COMMANDS ARE ONE BYTE LONG AND ALL INFORMATION NEEDED BY THE CPU TO EXEC UTE THE COMMAND IS CONTAINED IN THE INSTRUCTION (N INDEXED COMMAND ADDRESS A MEMORY LOCATION FOR ADDITIONAL DATA NEEDED TO COMPL ETE THE COMMAND. HE ADDRESS IS CONTAINED IN THE COMMAND AND CAN BE ONE BYTE, Z ERO PAGE, OR TWO BYTES, FULL ADDRESS, LONG. HE CPU FETCHES THIS ADDRESS AND A DD THE CONT ZERO PAGE ADDRESS IS A ONE BYTE ADDRESS BETWEEN 0 AND 255. SED TO POINTS TO ANY ONE OF THE 256 LOWEST MEMORY LOCATIONS IN THE DESIGNATED BANK OF THE B128. ( BETTER NAME FOR ABSOLUTE ADDRESS WOULD BE FULL ADDRESS. HIS SUFFIX IMPLIES T HAT THERE WILL BE TWO BYTES APPENDED ONTO THE INSTRUCTION BYTE, EACH WITH A RANG E OF 0-255. HEY ALLOW THE CPU TO ADDRESS ANY OF THE 65536 REGISTERS IN A BANK. HEIR FORU. ECAUSE UPERBASE USES # WITH FIND COMMAND, THE THE COMM AND NAMES USED IN THE RECORDS HAVE HAD IT DROPPED. LDA #.. BECOMES LDA .. ( PF g OCOMMAND q DECIMALVALUEHEXVALUE$ 3BINARYVALUE%IONAME  ODESCRIPTION  O ON   O B  D ENTS OF THE INDEX REGISTER DESIGNATED BY THE COMMAND TO THE ADDRESS. HE RESULT IS A NEW ADDRESS WHERE THE CPU CAN RETRIEVE THE DATA NEEDED TO COMPL ETE THE COMMAND ( NDIRECTINDEXED WILL ALWAYS OCCUR IN THE FOLLOWING FORMAT 'COMMAND'($##),Y. HIS COMMAND CAUSES THE CPU TO REFERENCE A ZERO PAGE MEMORY LOCATION. OWEVER, T HE CPU DOES SOME PERCULIAR THINGS WITH THE DATA FOUND THERE. T STARTS BY READIN G THE DATA FOUNDoMAT IS WHEN STORED IN MEMORY IS LOW BYTE, HIGH BYTE. DDRESS = LOW BY TE + 256 * HIGH BYTE. (HIMPLIED(HINDEX(HZEROPAGE(NDEXINDIRECT HAS THE FORMAT 'COMMAND'($##,X). HIS COMMAND IS SIMILAR TO INDIR ECTINDEXED EXCEPT THAT WITH THIS COMMAND THE INDEX OCCURS FIRST. HIS MEANS THAT THE CONTENT OF THE X REGISTER IS ADDED TO THE ZERO PAGE ADDRES STATED IN THE CO MMAND. HE +(I 74Z A>C ` P` ` ` ` `` `` ` ` ` #``B `  `  `   `  `` ` `` ` ` _(HZEROPAGE(NDIRECTION IS USED ALONE WITH THE JUMP COMMAND AND IN COMBINATION WITH INDEXING CAPABILITES. NDIRECTION WORKS ON THE PRINCIPLE OF POINTERS. HE COMMAND STAT EMENT CONTAINS AN ADDRESS NUMBER WHICH POINTS TO A MEMORY LOCATION CONTAINING TH E ACTUAL AD( AT THE ADDRESS SPECIFIED AND SAVING IT IN A BUFFER. T THEN IN CREMENTS THE STATED ADDRESS AND READS THE NEXT BYTE OF MEMORY. HIS ACTION HAS YEILDED TWO EIGHT BIT NUMBERS WHICH CAN BE USED TO ADDRESS ANY MEMORY LOCATION I N A MEMORY BANK. HEY WERE /009 041 073 105 160 162 169 192 201 224 233 DEX( HINDEXINDIRECT( HINDIRECTION CPU THEN FETCHES A SIXTEEN BIT ADDRESS WHOSE LOW BIT IS FOUND AT $## +X AND WHOSE HIGH BYTE IS FOUND AT $##+X+1. T THEN USES THIS ADDRESS TO COMPLE TE EXECUTION OF THE COMMAND. DDRESS ANY MEMORY LOCATION I N A MEMORY BANK. HEY WERE *NB"-- ------" DRESS NEEDED BY THE COMMAND. EMEMBER THAT THIS TECHINQUE IMPLIES TH AT THE ADDRESS STATED IN THE COMMAND AND THE ONE FOLLOWING IT HOLD INFORMATION N EEDED TO COMPLETE THIS COMMAND. ESS ANY MEMORY LOCATION I N A MEMORY BANK. HEY WERE (READ IN LOW BYTE, HIGH BYTE ORDER. HIS IS THE INDI RECT PART. OR THE INDEXED PART, THE CPU THEN TAKES THE CONTENTS OF THE Y REGIS TER AND ADDS IT TO THE LOWER OF THE TWO BYTES. HIS WILL THEN ALLOW ADDRESS NOW IN THE CPU TO ADDRESS AN ADDITIONAL 25(SBFd!#:400: ALLOW BREAK KEY AND SET SYSTEM PARAMETERSfn!@31,3""x!@31,4""@"UPERBASE 700";" "!@31,5""!@21,17""!@21,19"(EA!,: CLEAR PROGRAM GOTO MENUe *** SET SYSTEM PARAMETERS ***š!51:!180: MARGINS¤!266:!360: PAGE & TEXT LENGTHî!04:!70: PR) DSAVE"@INST."jd"HIS DISK CONTAINS A SET OF PROGRAMS WHICH WILL ALTER THE NTERRUPT OUTINEn"AND ALLOW YOU TO SAVE UNPROTECTED COPIES OF UPEROFFICE AND UPERSCRIPT.x"O USE THEM, READ THE UPERSCRIPT FILE CALLED &&INSTRUCTM"(*** SET FUNCTION KEYS **********************):91," ENTER"K2," SELECT "[3," FIND "m4," OUTPUT "}5," CALC "&6," REPORT "(34)07," EXECUTE "(34):8," HELP "(34)D9," DISPLAY "N10," LOAD "(34)X1H5 LOCATIONS. OTE THAT RANGE IS ADDRESS TO ADDRESS + 255. TS THE STATED ADDRESS AND READS THE NEXT BYTE OF MEMORY. HIS ACTION HAS YEILDED TWO EIGHT BIT NUMBERS WHICH CAN BE USED TO ADDRESS ANY MEMORY LOCATION I N A MEMORY BANK. HEY WERE ("U!@0: RESET DISPLAY COUNT!:&16@21,18" NTER ATABASE AME :";A$!MA$,8,0: DISK 8,DRIVE 0! : SUPERBASE ASKS FOR FIL(INTER DEVICE 4 CBM CODEWø!60:!41: NO LINE FEEDS, CONTINUOUS PRINT!80:!: SINGLE SPACE, OUTPUT ACROSS!'0: DEFAULT SCREEN FOR ENTRY:# **********1," FILE "(34)b12," FORMAT "*l13," BATCH ";v14," SORT "Lŀ15," PROG "aŊ16," MAINTAIN "xŔ17," MEMO "(34)Ş18," DIRECTORY "Ũ19," PRINT "Ų20," SAVE "(34)żEFAULT SCREEN FOR ENTRY:# ********** )ppMLCOMMANDSBINARY )"INTRO.BASIC.SS" "2604" EREZINSKI HIS DISK CONTAINS A DATABASE OF THE ML COMMANDS FOR THE B128. T CAN BE USED TO SORT COMMANDS BY NAME, BY REGISTERS AFFECTED, BY FLAGS AFFECTED, OR EVEN BY THE BIT PATTERN OF THE COMMAND. HE NAME OF THE DATA BASE x  X`^LxWH PȢ hXL^LxPȢȑȑ hXL@x @X`^LxWH@PȢ@hXL^LxPȢȑȑ@hXL`x `X`^LxWH`PȢ`hXL^LxPȢȑȑ`hXL)  DSAVE"@SSLOADER",D0@ B214:B:P250:B:P,0::^1,"BANK15:SYS1024"(13){ WAS KEY1,CHR$(27)+"OV"2,"BANK1:POKE2,0:POKE3,0:POKE4,0:BANK15"(13) WAS KEY2,CHR$(27)+"I"3,(27)"L"4,(27)"R"(29) 5,(27)IS MLDB. HE NAME OF ONE FILE IS MLCOMMANDS. T USES COMMAND NAMES FOR KEY. HE NAME OF OTHER FILE IS BINARY. T USES THE BINARY NUMBER OF THE COMMAND FOR THE KEY. NCLUDED ON THE DISK ARE SOME HELP FILES ON COMMAND TYPES. *FP0 ) d DSAVE"@SOLOADER"=B214:B:P250:B:P,0::} 8,8,8,"SS2 TABLES":SDDS:8: CHECK FOR USER PRINTER FILE SD0 "SS2 TABLES",D1,B4: IF FOUND LOAD15:193,254:2045,255:2046,239:2047,0"SBF",B15,P1024"SB1",B1,C 1N ; VHH`l ` @ `L1S1)S2)S3)SSLOADER)SOLOADER)SBd!#К!51:!180#Ф!266:!360/Ю!04:!70;и!60:!41F!80:!N!'0g FUNCTION KEYSw1," ENTER"2," SELECT "3," FIND "4," OUTPUT "5," CALC "&6," REPORT "(34)07," EXECUTE "(34):8," HELP ")"D"(29)$6,(27)""-.7,(27)"HM"?88,(146)"$"LB9,(16)ZL10,(23)lV11,(27)""`12,(27)(148)(2)j13,(27)"F"t14,(27)""~15,(27)(20)(2)16,(27)"TH"17,(14)(27)"TH"(14) 18,)INB"&&INSTRUCT" *LM10:RM70:PL66:TL56 *CN1 ԀӀ̀ˀ̀ *CN0 HE MACHINE CODE PROGRAMS CONTAINED ON THIS DISK WILL ALLOW YOU TO MAKE UNENCRIPTED VERSIONS OF UPERSCRIPT, AND UPEROFFICE. O USE THE DECRIPTION PROGRAM, OP1024 P 8,8,8,"SB4":SDDS:8= SD0 "SB4",B4,P1024K15:1024)S2)S3)SSLOADER)ER YOU WANT. F YOU HAVE AN EXPANDED ALC ESULT CARTRIDGE, IT COULD HAVE EITHER ONE OR BOTH CHIPS ADDED. ALC ESULT RESIDES AT $6000-$7FFF, SO RAM CAN BE EITHER AT $2000-$3FFF OR $4000-$5FFF. ETERMINE WHERE YOU HAVE AVAILABLE RAM. *CN1 (34)D9," DISPLAY ",N10," LOAD "(34)CX11," FILE "(34)Vb12," FORMAT "hl13," BATCH "yv14," SORT "р15," PROG "ъ16," MAINTAIN "є17," MEMO "(34)ў18," DIRECTORY "Ѩ19," PRINT "Ѳ20," SAVE "(34)H(146)"+$"19,(15)$20,(5)B"SSF",B15,P1024,D0:1296BANK15:SYS1024"(13){ WAS KEY1,CHR$(27)+"OV"2,"BANK1:POKE2,0:POKE3,0:POKE4,0:BANK15"(13) WAS KEY2,CHR$(27)+"I"3,(27)"L"4,(27)"R"(29) 5,(27))YOU WILL NEED RAM IN THE CARTRIDGE SLOT. T CAN EITHER BE A RAM CARTRIDGE OR RAM ADDED TO THE ALC ESULT CARTRIDGE. OU WILL NEED TO DETERMINE WHAT RAM IS AVAILABLE. F YOU HAVE A RAM CARTRIDGE, YOU WILL HAVE THREE 8K RAM CHIPS WITH ADDRESSES; *CN1 )ONS. HIS HAS BEEN MODIFIED ALLOW QUICK EXIT OF DECRIPTED . HEN YOU WISH TO LEAVE, HIT THE RESET BUTTON IN BACK OF THE 128, THEN F2 KEY AND YOU WILL BE BACK IN BASIC. HE F1 KEY WILL REENTER UPERSCRIPT IF YOU HAVE ATTEMPTED TO LOAD A BASIC PR)Ӏ΀Ӏ *CN0 "INST." PRG SHIFT/RUN INTRODUCTION. ILL ALSO LOAD LOADER PROGRAM IF PROMPT IS ANSWERED YES. "S1" PRG IRQ ROUTINE FOR BANK15 ADDRESS 8192 "S2" PRG IRQ ROUTINE FOR BANK15 )ORIGINAL COPY OF UPEROFFICE UPERSCRIPT DOES NOT HAVE WORKING FUNCTION KEYS AND SO THE AS FAR AS KNOW THE DECRIPTED VERSION WILL NOT HAVE THEM EITHER. HIS PROGRAM MAY BE MODIFIED AS LONG AS YOU KEEP IT UNDER 1K OR 4 BLOCKS ON THE DISK. 1 "MLLOAD)REPLACED BY ORIGINAL OR ONE OF YOUR OWN WRITING. UST BE SAVED ON THE DECRIPTED UPEROFFICE DISK. 4 "LOADER" PRG BASIC PROGRAM FOR LOADING DECRIPTION IRQ ROUTINES ABOVE. 21 "&&INSTRUCT" SEQ THESE INSTRUCTIONS. *CN1 ׀π) DECIMAL HEXIDECIMAL 8192-16383 $2000-$3FFF 16384-24575 $4000-$5FFF 24576-32767 $6000-$7FFF *CN0 HERE ARE COPIES OF THE DECRIPTION PROGRAM WHICH WILL LOAD AT THE BEGINING ADDRESS OF EACH OF THESE CHIPS. OU MAY PICK WHICH EV)OGRAM OR MACHINE CODE INTO BANK15 P1024 TO P2047. IST "SSLOADER" BEFORE RUNNING AND DECIDE WHETHER YOU WANT TO REASSIGN OLD FUNCTIONS OR ALTERNATIVE FUNCTIONS. "SOLOADER" PRG FIRST PROGRAM TO BE PUT ON THE DECRIPTED UPEROFFICE DISK. Y )ADDRESS 16384 "S3" PRG IRQ ROUTINE FOR BANK15 ADDRESS 24576 "SSLOADER" PRG FIRST PROGRAM TO GO ON THE DECRIPTED UPERSCRIPT DISK, CONTAINS LOADER COMMANDS FOR MACHINE CODE. LSO ASIGNS FUNCTION KEYS WITH THEIR FUNCTI)ER" PRG MACHINE CODE ROUTINE NEEDED FOR LOADING UPERSCRIPT INTO BANK1 WITHOUT ERROR MESSAGES. HIS IS ADDED TO CODE IN BANK 15 AND THE BOTH ARE SAVED AS ONE PROGRAM. 4 "START.P" SEQ MODIFIED START PROGRAM REQUIRED BY . AN BE *ŀ *CN0 HEN YOU ARE READY TO DECRIPT A UPER SERIES PROGRAM, BEGIN BY MAKING A PRINTED COPY OF THESE INSTRUCTIONS. EXT FORMAT A BLANK DISK. NCLUDED ON THE DECRIPTOR DISK ARE LOADER PROGRAMS FOR UPEROFFICE AND UPERSCRIPTF YOU HAVE READ THE INSTRUCTIONS, YOU CAN LOAD THE LOADER ROUTINE FROM THIS["PROGRAM"O YOU WANT LOADER Y OR N";Y$: Y$"Y" "LOADER"*HE VECTER WILL BE READJUSTED. F CURSOR HAS DISAPPEARED CURSOR DOWN. EXT LOAD THE UPERSERIES PROGRAM TO BE DECRIPTED. SE DUPLICATE COPYS FROM NIGHT'S COPY UTILITY OR OTHER SOURCES. NSTRUCTIONS UP TO THIS POINT APPLY TO ALL UPER SERIES P*E IN UPEROFFICE AND TRANSFERED TO THE NEW DISK ONE AT A TIME. F YOU USE SS TABLES, YOU MAY HAVE TO ADD A LINE TO THE SSLOADER PROGRAM. OOK AT HOW IT WAS DONE ON THE ORIGINAL LOADER PROGRAM. MPORTANT HE "SSLOADER" HAS ADDED LINES WHICH WE*. EFORE RUNNING THE DECRIPTION PROGRAM, COPY THE LOADER PROGRAM FOR THE APPROPRIATE UPER SERIES PROGRAM ONTO THE BLANK FORMATTED DISK. AKE SURE IT IS THE FIRST PROGRAM ON THE DISK SO THAT SHIFT/RUN WILL USE IT. HAVE MODIFIED THE FUNCTION KEYS IN *ECTED UPERBASE, THIS PROGRAM SHOULD DO IT. UPEROFFICE OR UPERBASE, INSERT PROGRAM DISK AND SHIFT/RUN. HEN THE SCREEN TELLING YOU TO HIT THE KEY TO CREATE A DATA DISK APPEARS, HIT THE KEY ON THE NUMERIC KEYPAD INSTEAD. F CURSOR DIAP* *NB" NOTE - TART.P" O GET BOTH SOURCE DISKS ONTO ONE, WE HAD TO CHANGE THE FILE NAME OF THE DEPROTECTOR START.P PROGRAM TO .. O USE THIS MATERIAL, COPY OFF THE SECOND HALF OF THE DISK, THEN USE THE RENAME FILE CAPABILITY TO CHANGE THE FILE * ROGRAMS. F YOU HAVE UPERSCRIPT 2, INSERT THE DISK AND HIT SHIFT/RUN. HEN THE MENU FOR SETTING NUMBER OF CHARACTERS PER LINE AND PRINTER TYPE APPEARS, HIT THE KEY AGAIN. HE ORIGINAL OPERATION BANK REGISTERS WILL BE RESTORED. F THE CURS* RE PERFORMED BY THE ML IN THE ORIGINAL UPERSCRIPT. T IS NECESSARY FOR THEM TO BE THERE, SO DO NOT DELETE ANY OF THE POKE COMMANDS. *CN1 RIGINAL UPERSCRIPT. HE DECRIPTED UPERSCRIPT PROGRAM CAN ALSO BE EXITED VERY QUICKLY I* THE UPERSCRIPT LOADER, IF YOU WANT TO REASIGN THEM OR YOU HAVE YOUR OWN ASIGNMENTS, NOW IS THE TIME TO DO IT. "SSLOADER" IS FOR UPERSCRIPT. "SOLOADER" IS FOR UPEROFFICE. URN OFF YOUR COMPUTER TO RESET EVERYTHING. URN THE COMPUTER* PEARS, CURSOR DOWN. HE INPROVED VERSION OF UPERBASE OFF OF UPERSCRIPT CAN BE RUN ON AN UNEXPANDED 128. NSERT THE PREPARED FORMATTED DISK AND USE THE FOLLOWING COMMANDS. BSAVE"SBF",B15,P1024TOP2047 BSAVE"SB1",B1,P1024TOP55298 UPERSCRIPTNAME BACK TO START.P . ORRY ABOUT THE MIX UP, BUT WE DID NOT CHECK FOR REDUNDANT FILE NAMES WHEN WE PRINTED THE CATALOGUE/. A MODIFIED FORM OF THE DECRIPTOR ROUTINE. F1. ITH A LITTLE CARE, HAVE BEEN ABLE TO RUN COTT'S MON AT THE SAME TIME*OR HAS NOT REAPPEARED, CURSOR DOWN AND IT WILL APPEAR. LACE THE DECRIPTOR DISK BACK INTO DRIVE 0 AND BLOAD"MLLOADER",B15,P1296. HIS WILL LOAD THE EXTRA MACHINE CODE FOR LOADING UPERSCRIPT INTO BANK 1 WITHOUT BASIC ERROR MESSAGES. EXT PLAC*F THE LOADER PROGRAM "SSLOADER" IS USED. OTH F1 AND F2 HAVE BEEN REASIGNED TO ALLOW QUICK EXIT AND REENTRY INTO UPERSCRIPT. F YOU HIT THE RESET BUTTON WHILE IN UPERSCRIPT, YOU WILL BE BACK IN BASIC, EXCEPT THE MEMORY WHICH COMPRISES THE START OF BA* BACK ON, INSERT THE DECRIPTOR DISK AND SHIFT/RUN THE FIRST PROGRAM AND ANSWER THE PROMPT WITH 'Y', YES. HE LOADER PROGRAM WILL LOAD AND YOU CAN DESIGNATE WHICH RAM SECTION IS AVAILABLE IN THE CARTRIDGE. HE CORRECT IRQ ROUTINE WILL BE LOADED AND ACT* HALF OF UPEROFFICE USE ONE MORE COMMAND. BSAVE"SB4",B4,P1024TOP34640 OR UPEROFFICE, YOU WILL NEED TO COPY ONE MORE PROGRAM ONTO YOUR NEW DISK, "START.P". HIS PROGRAM SETS UP THE FUNCTION KEYS FOR UPERBASE AND REQUESTS THE NAME OF THE DATABAS**NB"!!----!!!" (C) , . HIS DISK IS COPYRIGHTED BY , . IN ITS OWN NAME AND IN THE NAME AND FOR THE BEHALF OF THE CONTRIBUTORS TO THIS PROPERTY. AND/OR TRANSMISSION TO NON-MEMBERS *ING THE FORMATED DISK IN DRIVE 0, YOU BETTER ALREADY HAVE THIS ON HAND, USE THE FOLLOWING COMMANDS; UPERSCRIPT WITHOUT THE DICTIONARY - LOADS VERY FAST BSAVE"SSF",B15,P1024TOP1360 BSAVE"L1",B1,P0002TOP20608: REM THATS L1 AS IN LOADER1. UPER*SIC IS MESSED UP. HE F2 KEY WILL CORRECT THIS. F YOU DO NOT LOAD OR WRITE A BASIC PROGRAM OR MODIFY THE LOWER HALF OF BANK1, YOU CAN REENTER UPERSCRIPT SIMPLY BY PRESSING F1. ITH A LITTLE CARE, HAVE BEEN ABLE TO RUN COTT'S MON AT THE SAME TIME*IVATED. HEN THE SETUP PROGRAM IS DONE, SIGNALED BY THE READY. PROMPT, TYPE "NEW" FOLLOWED BY A RETURN YPE "CLR" FOLLOWED BY A RETURN RESS THE RESET BUTTON ON THE BACK OF THE 128. OU HAVE NOW RESET THE COMPUTER TO A START UP CONDI*E. HE ORIGINAL "START.P" PROGRAM CAN BE LOADED OFF OF THE ORIGNIAL UPEROFFICE DISK WHILE UPEROFFICE IS RUNNING AND SAVED ONTO THE DECRIPTED DISK. R THE "START.P" PROGRAM INCLUDED ON THIS DISK CAN BE USED. *CN1 *CN0 * WITHOUT WRITTEN CONSENT OF , ; IF SPECIFIC COPYRIGHT IS CLAIMED DIRECTLY BY AN AUTHOR, WRITTEN PERMISSION MUST ALSO BE OBTAINED FROM SUCH AUTHOR. ************************** ***************************** LEASE C*SCRIPT WITH THE DICTIONARY BSAVE"SSF",B15,P1024TOP1360 BSAVE"L1",B1,P0002TOP34640 UPERSCRIPT3; DON'T HAVE A COPY OF SS3, SO DON'T KNOW IF IT WILL WORK? UPERBASE, HAVE COPIES OF UNENCRIPTED UPERBASE, BUT DON'T KNOW HOW GOT THEM. * AS UPERSCRIPT. HIS IS USEFUL FOR WRITING NOTES ABOUT CODE 'M DEVOLOPING OR DISASSEMBLING. EMEMBER THAT ANY SCRIPT IS DESTROYED BY AN EXIT, SO SAVE BEFORE EXITING. F YOU WANT IZ'S KEY DEBOUNCE, YOU WILL HAVE TO INCORPORATE IT INTO THE UPER*TION AND YOU ARE GOING TO USE THE DECRIPTION ROUTINE TO DUPLICATE THE ALL THE REGISTERS IN THE FIRST K OF THE OPERATING BANK. O DO THIS, PRESS THE KEY ON THE NUMERIC KEYPAD ONCE. HE REGISTERS WILL NOW BE COPIED INTO THE CARTRIDGE AND T* F YOU ARE USING PROGRAMS INCLUDED ON THE ORIGINAL UPER SERIES DISKS, YOU MAY WANT TO TRANSFER THEM. HE DICTIONARY CAN NOW BE SAVED ON THE SAME DISK AS UPERSCRIPT. ELP SCREENS ON UPEROFFICE WILL PROBABLY HAVE TO BE LOADED INTO MEMORY WHIL+AREFULLY READ BOTH THIS NOTICE AND ALL OTHER COPYRIGHT & FREEWARE NOTICES WHICH MAY BE ON THIS DISK. OME PROGRAMS ARE COPYRIGHTED BY THEIR CREATORS/CONTRIBUTORS AND PERMISSION MUST BE OBTAINED FROM THOSE AUTHORS PRIOR TO CERTAIN TYPES OF USEAGE AS MAY *HEN USED THE DECRIPTION PROGRAM ON AN ORIGINAL UPERBASE DISK, IT WOULD NOT RUN UNLESS REINSERTED THE ORIGINAL DISK BACK IN THE DRIVE BEFORE RUNNING THE DECRIPTED PROGRAM. OWEVER IF YOU ARE INTERESTED IN JUST LOOKING AT A DISASSEMBLY OF THE UNPROTSCRIPT LOADER ON THIS DISK. LSO THERE WILL BE INSTRUCTIONS AT A LATER TIME ON HOW TO CREATE A QUICK EXIT FROM UPEROFFICE USING A MODIFIED FORM OF THE DECRIPTOR ROUTINE. F1. ITH A LITTLE CARE, HAVE BEEN ABLE TO RUN COTT'S MON AT THE SAME TIME+OVER SOMETHING ON ANY OF OUR DISKS WHICH YOU BELIEVE TO BE VIOLATIVE OF COPYRIGHT, KINDLY WRITE ME YESTERDAY. DENTIFY THE DISK, PROGRAM AND WHY YOU BELIEVE IT IS ILLEGAL -- I.E. YOU KNOW THE SAME PROGRAM IS FOR SALE AT THE LOCAL COMPUTER STORE UNDER AN+BE SPECIFIED. THER PROGRAMS ARE SUBMITTED ON A BASIS -- I.E. IF YOU USE THEM, YOU ARE MORALLY OBLIGED TO MAKE ATLEAST A TOKEN PAYMENT TO THE AUTHOR/CONTRIBUTOR. ANY DISKS BEAR THE NOTICE "HIS IS A ROYALTY PAID COPY" -- AS SUCH THE REE+VICE WHEREIN THE COPYRIGHT OWNER IS PERMITTED TO BIND THE PURCHASER TO A CONTRACT CONTAINED WITHIN THE SEALED PACKAGE EVEN THOUGH THE PURCHASER HAS NOT HAD AN OPPORTUNITY TO READ WHAT HE IS AGREEING TO. BVIUSLY SUCH A "UNIQUE" LEGAL CONCEPT IS BEING HO+LAWS, BUT AS UNDERSTAND IT, MANY PERSONS ROUTINELY PUT COPYRIGHT NOTICES ON FREEWARE AND PUBLIC DOMAIN DISKS TO DISCOURAGE PROFITEERING. HUS THE MERE EXISTANCE OF A COPYRIGHT NOTICE IS NOT CONCLUSIVE. S A SMALL GROUP WITH LIMITED MEANS, HOPE EVER+ RIBUTED BY A MEMBER TO OTHERS (PREFERABLY MEMBERS), THAT A COPY FEE OF $5.00 PER DISK SO DUPLICATED BE REMITTED TO US. HIS ALSO SHOULD BE REGARDED AS A OBLIGATION. LEASE REMIT TO ORMAN ELTZKE AS BELOW AND INDICATE THAT THE SUM IS FOR COPY + OTHER NAME (STATE NAME AND PUBLISHER, ADDRESS IF POSSIBLE). NFORTUNATELY, TIME DOES NOT ALLOW US TO CORRESPOND AS WITH MEMBERS AS LIBERALLY AS WE GAB ON THE PHONE. , YOUR LETTERS AND NOTES ARE READ AND USUALLY PASSED ON TO OUR UESTION AND NSWER M+ WARE CONSIDERATION HAS BEEN WAIVED FOR THAT COPY ONLY BY THE INCLUSION OF A NOMINAL ROYALTY REMITTED TO THE AUTHOR/CONTRIBUTOR. ITHOUT ACTS OF GRATITUTED, MAY CONTRIBUTORS MAY NOT CONTINUE TO GO TO THE EXTREME EFFORT EXHIBITED HEREIN. + TLY CONTESTED. OT ONLY IS A CONTRACT BEING IMPOSED, BUT OFTEN THE SOFTWARE IS STATED AS BEING LICENSED, NOT SOLD! -- I.E. THE PURCHASER OWNS NO PRODUCT, ONLY A PERMISSION TO USE. OREOVER SOME STATES, LLINOIS NOTABLY, IS ATTEMPTING TO PERMIT THE SOFT+ YONE USES THEIR VERY BEST JUDGEMENT IN TRYING TO MAKE THESE DETERMINATIONS. ENERALLY PROGRAMMING PRINTED IN MAGAZINES MAY ONLY BE ACQUIRED BY SUBSCRIBERS TO THOSE MAGAZINES. OMETIMES AFFIDAVITS OF SUBSCRIPTION ARE USED -- BUT IT IS HAPHAZZARD AT BEST+FEE(S) REGARDING LIBRARY MATERIALS. ATERIALS HAVE BEEN SUBMITTED TO FOR THE USE OF ITS MEMBERS, AND NO PERMISSION IS GRANTED BY , MYSELF OR ANY OTHER PARTY TO DISTRIBUTE COPIES BEYOND THE MEMBERSHIP OF . ------------------------- +AN, ARREN WAN. OU JUST MIGHT HEAR FROM HIM, MORE LIKELY YOUR COMMENT MAY SEED A PARAGRAPH OR TWO IN OUR PUBLICATIONS. HANK YOU FOR YOUR COOPERATION AND ASSISTANCE IN ADVANCE. ------------------------- AIR SE OCTRINE. NITED TATES OPYRIGHT + : IS NOW RECEIVING AND PUBLISHING CONSIDERABLE QUANTITIES OF OMMODORE USINESS ACHINES NC. () AND OTHER RELATED SOURCE CODE. HIS GREAT COURTESY BY AND OTHERS IS ALLOWED ONLY UNDER HIGHLY RESTRICTIVE COVENANTS. HESE COVENANTS AND +WARE PRODUCERS TO DISCLAIM ALL WARRANTEES INCLUDING EVEN LOADING OR OPERATING AT ALL! HE ISSUE OF TATE'S RIGHTS TO IMPOSE LAWS RELATING TO COPYRIGHT (PARTICULARY AS THESE LAWS CONFLICT WITH EDERAL LAW IN MANY AREAS) IS NEW AND UNCHARTED TERRITORY. +. N THE OTHER HAND, MAGAZINES AND PROGRAMMING PUBLISHED BY OMMODORE ARE INTENDED FOR THEIR CUSTOMERS, SO FOR OUR PURPOSES OMMODORE WRITTEN ARTICLES AND UTILITIES ARE GENERALLY UNRESTRICTED. BVIOUSLY PROGRAMS PURCHASED BY OMMODORE FROM 3RD PARTY VE+ LIBRARY DISKS ARE PROVIDED IN SEVERAL FORMS, THIS ONE IS OF THE OFFICIAL RELEASE OR REVIEWED RELEASE ( # OR #) VARIETY. F THE DISK IS LABELED WITH A PIGGYBACK LABEL (EASILY DETACHABLE AND HAVING " " PRINTED ON THE RIGHT HAND END THERE+AWS PROVIDE FOR WHAT IS COMMONLY KNOWN AS FAIR USE COPYING (FAIR USE DOCTRINE). IMPLY PUT, A PURCHASER OF COPYRIGHTED MATERIALS IS GENERALLY FREE TO MAKE COPIES FOR HIS OWN USE WITHOUT VIOLATING EDERAL LAW. OWEVER, TO MAKE COPIES OF COPYRIGHTED MATE+AGREEMENTS ARE PUBLISHED IN THE AT THE TIME OF PRODUCT OFFERING. S WITH MOST COPYRIGHTED SOFTWARE, THE PURCHASER OF A PROGRAM ACQUIRES PROPERTY IN THE FORM OF DISK(S) AND DOCUMENTATION, HOWEVER THE INTELLECTUAL PROPERTY (CODE ETC) IS NOT SO+AKE CARE TO FOLLOW YOUR LOCAL PRESS ON THIS SUBJECT. OV. 1987 : OUNSEL HAS ADVISED THAT THE LLINOIS LAW HAS BEEN WITHDRAWN. DON'T HAVE CURRENT INFORMATION ON OTHER STATES. ------------------------- HAS INCURRED CONSIDERABLE EXPENSE IN +NDORS (SUCH AS RECISION OFTWARE AND NFO ESIGNS) AND BEARING DUAL COPYRIGHT NOTICES OR THEIR COMMERCIALIZED PROGRAMMING ARE LIKELY TO BE RESTRICTED. IMILARLY CERTAIN OBVIOUSLY COMMERCIALIZED PUBLICATIONS OF OMMODORE ITSELF ARE NOT INTENDED FOR PUBL+OF), THE DISK IS SUBJECT TO FUTURE UPDATE. OU MAY ACQUIRE SUCH UPDATED DISKS WHEN ANNOUNCED AT 1/2 PRICE (INCLUDING 50% OFF ON ROYALTIES IF ANY). HE DETACHABLE LABEL SERVES AS PROOF OF OWNERSHIP AND MUST BE RETURNED WITH SUCH UPDATED DISK ORDERS. H+RIALS CONTARY TO THE COPYRIGHT OWNERS' INTENTION FOR THE BENEFIT OF THIRD PARTIES, OR POSSIBLY EVEN MULTIPLE PLACES OF USE (SUCH AS BRANCH OFFICES/STORES/DEPARTMENTS) MAY NOT BE PERMISSABLE. ERTAIN PROGRAMMING IS SOLD UNDER CONTRACTS FAR MORE RESTRICTI+LD, ONLY THE RIGHT TO USE IT WITHIN THE RESTRICTIONS RELATED TO IT. T IS IMPERATIVE THAT THESE MATERIALS ( ET AL PROPRIETARY CODE AND SOURCE CODE ALL DERIVITAVES THEREOF) TO NOT MIGRATE OUTSIDE THE ORGANIZATION. HE POSSIBLE CONSEQUENCES ARE EX+PREPARING ITS LIBRARY. ONE OF OUR DISKS ARE COPYPROTECTED AND OTHER THAN AS STATED SUPRA, NO COPYING RESTRICTIONS ARE IMPOSED REGARDING USE OF THESE MATERIALS BY MEMBERS IN GOOD STANDING. T IS HOWEVER REQUESTED THAT IF ADDITIONAL COPIES ARE DIST+IC DOMAIN USEAGE. HE ENTIRE OMMODORE EDUCATION LIBRARY IS FOR COPYING (AVAILABLE THRU AND MOST LOCAL CLUBS). UCH OF THE OMMODORE PUBLIC DOMAIN LIBRARY IS IN PURE BASIC -- AND RUNNABLE ON ANY OMMODORE MACHINE, FROM THRU 64'S. F YOU DISC,E UPDATED DISKS WILL CARRY SPECIAL STOCK NUMBERS AND CAN ONLY BE ORDERED USING THOSE NUMBERS AS ANNOUNCED. E SUGGEST YOU USE COTCH TAPE TO BETTER AFFIX THE LABEL TO THE PRESENT DISK. ORMAN ELTZKE HE HICAGO 128 SERS' ROUP - NTERNATIONAL ,+VE THAN THE COPYRIGHT LAWS, AND SUCH CONTRACTUAL AGREEMENTS ARE ENFORCABLE UNDER APPLICABLE CIVIL LAWS OF CONTRACT. ERTAIN STATES, NOTABLY OUSIANA AND RECENTLY (BUT NOT FINAL) LLINOIS HAVE ENACTED LAWS CODIFYING "SHRINK WRAP CONTRACTS". HIS IS A DE+CEPTIONALLY HARSH. , AND HOPE SPEAK FOR ALL MEMBERS, HAS NO INTEREST IN DUPLICATING MATERIALS NOT IN THE PUBLIC DOMAIN. NYONE CAUGHT SUBMITTING NON-PUBLIC DOMAIN MATERIALS WILL BE SUMARILY ABORTED FROM MEMBERSHIP. 'M NO EXPERT IN COPYRIGHT , NC. 4102 . DELL ORRIDGE, L. 60634 312 456 8720 7PM TO 10PM .. N OCCASION OUR DISK DRIVES USED FOR DUPLICATION MAY BE MARGINALLY OFF SPEED. HOULD YOUR EQUIPMENT BE SLIGHTLY OUT OF ADJUSTMENT IN AN OPPOSITE DIRECTION (I.E. ONE FAST, ONE SLOW), YOU MAY HAVE DIFFICULTY IN BACKING UP THE DISK. LEASE TRY TO BACK OF BOTH D1=0 AND D0=1. F THAT FAILS, SEND US A NOTE AND WE WILL REPLACE THE DISK PROMPTLY WITHOUT CHARGE. *FP0 RMAN ELTZKE HE HICAGO 128 SERS' ROUP - NTERNATIONAL ,