diff --git a/trunk/Arduino/KIMUNO/KIM Uno Manual v2.pdf b/trunk/Arduino/KIMUNO/KIM Uno Manual v2.pdf new file mode 100644 index 00000000..ff1bc612 Binary files /dev/null and b/trunk/Arduino/KIMUNO/KIM Uno Manual v2.pdf differ diff --git a/trunk/Arduino/KIMUNO/KIMUNO.ino b/trunk/Arduino/KIMUNO/KIMUNO.ino new file mode 100644 index 00000000..24807814 --- /dev/null +++ b/trunk/Arduino/KIMUNO/KIMUNO.ino @@ -0,0 +1,724 @@ +//version date: 20160907 +#include "Arduino.h" +#include +#include +#include +#include "x.h" + +//#define CH2_SPEAKERPIN 9 +#define WREG_OFFSET 0x0360 +#define AVRX // define on for Arduino, off for normal PC C compilers. + // in kimuno.ino, this only relates to some code segments that are shared with PC version + +extern uint8_t RAM[1024]; // main 1KB RAM 0x000-0x3FF +extern uint16_t pc; // 6502 pc +extern uint8_t SSTmode; +extern uint8_t useKeyboardLed; // 0 to use Serial port or 1 for HEX digits. +uint8_t curkey = 0; +uint8_t eepromProtect=1; // default is to write-protect EEPROM +int blitzMode=1; // microchess status variable. 1 speeds up chess moves (and dumbs down play) +uint8_t keyboardMode=0; // start with keyboard in KIM-1 mode. 1: calculator mode + +char threeHex[3][2]; // LED display + +byte aCols[8] = { A5, 2,3,4,5,6,7,8 }; // note col A5 is the extra one linked to DP +byte aRows[3] = { 9,10,11 }; +byte ledSelect[8] = { 12, 13, A0, A1, A2, A3, A7, A4 }; // note that A6 and A7 are not used at present. Can delete them. +byte ledSelect7[8] = { 12, 13, A0, A1, A4, A2, A3, A7 }; // note that A6 and A7 are not used at present. Can delete them. + +byte dig[19] = { +// bits 6543210 +// digits abcdefg + 0b01111110,//0 + 0b00110000,//1 + 0b01101101,//2 + 0b01111001,//3 + 0b00110011,//4 + 0b01011011,//5 + 0b01011111,//6 + 0b01110000,//7 + 0b01111111,//8 + 0b01111011,//9 + 0b01110111,//a + 0b00011111,//b + 0b01001110,//c + 0b00111101,//d + 0b01001111,//e + 0b01000111,//f + 0b00000001, //g printed as - + 0b00001000, //h printed as _ + 0b00000000 //i printed as +}; + + + +extern "C" { + // ---------- in cpu.c ------------------------------ + uint16_t getpc(); + uint8_t getop(); + void exec6502(int32_t tickcount); + void reset6502(); + void nmi6502(); + void initKIM(void); + void loadTestProgram(void); + extern void driveLEDs(); + //extern void driveCalcLEDs(uint8_t reg); +// extern void scanKeys(); +void scanKeys(); + + +// extern uint8_t getRegister(uint8_t reg, uint8_t *inVal); +// extern void setRegister(uint8_t reg, double regVal, uint8_t *inVal); + + // ---------- called from cpu.c ---------------------- + void serout(uint8_t val) { Serial.write(val); } + void serouthex(uint8_t val) { Serial.print(val, HEX); } + uint8_t getAkey() { return(curkey); } + void clearkey() { curkey = 0; } + void printhex(uint16_t val) { Serial.print(val, HEX); Serial.println(); } + + + + // getKIMkey() translates ASCII keypresses to codes the KIM ROM expects. + // note that, inefficiently, the KIM Uno board's key codes are first translated to ASCII, then routed through + // here just like key presses from the ASCII serial port are. That's inefficient but left like this + // for hysterical raisins. + + + uint8_t getKIMkey() { + //Serial.print('#'); Serial.print(curkey); Serial.print('#'); + +if (curkey==0) +return (0xFF); //0xFF: illegal keycode + + if ((curkey>='0') & (curkey <='9')) + return (curkey-'0'); + if ((curkey>='A') & (curkey <='F')) + return(curkey-'A'+10); + if ((curkey>='a') & (curkey <='f')) + return(curkey-'a'+10); + + if (curkey==1) // ctrlA + return(0x10); // AD address mode + if (curkey==4) // ctrlD + return(0x11); // DA data mode + if (curkey=='+') // + + return(0x12); // step + if (curkey==7) // ctrlG + return(0x13); // GO + if (curkey==16) // ctrlP + return(0x14); // PC mode + // curkey==ctrlR for hard reset (/RST) (KIM's RS key) is handled in main loop! + // curkey==ctrlT for ST key (/NMI) is handled in main loop! + return(curkey); // any other key, should not be hit but ignored by KIM + } + + uint8_t eepromread(uint16_t eepromaddress) { + return(EEPROM.read(eepromaddress)); // thanks to Malik Enes Safak for the bug fix 20160907 + } + void eepromwrite(uint16_t eepromaddress, uint8_t bytevalue) { + if (eepromProtect==0) + EEPROM.write(eepromaddress, bytevalue); + else + { Serial.println(F("ERROR: EEPROM STATE IS WRITE-PROTECTED. HIT '>' TO TOGGLE WRITE PROTECT")); + Serial.println(freeRam()); + } + } +} + +void setup () { + Serial.begin (9600); + Serial.println (); + + setupUno(); + + reset6502(); + initKIM(); // Enters 1c00 in KIM vectors 17FA and 17FE. Might consider doing 17FC as well???????? + loadTestProgram(); + + Serial.print(F("v23oct14 freeMemory()=")); // just a little check, to avoid running out of RAM! + Serial.println(freeRam()); +} + +void loop () { + int y; + + exec6502(100); //do 100 6502 instructions + + if (Serial.available()) + { curkey = Serial.read() & 0x7F; + interpretkeys(); + } + + scanKeys(); + if (xkeyPressed()!=0) //KIM Uno board input? + interpretkeys(); + + //driveLEDs(); // doing that here would cause a massive slowdown but keeps display on at all times +} + + +// check for out of RAM +int freeRam () { + extern int __heap_start, *__brkval; + int v; + return (int) &v - (__brkval == 0 ? (int) &__heap_start : (int) __brkval); +} + +// translate keyboard commands to KIM-I keycodes or emulator actions +void interpretkeys() +{ + // round 1: keys that always have the same meaning + switch (curkey) { + case 18: // CtrlR = RS key = hardware reset (RST) + reset6502(); clearkey(); Serial.print("RSet\n"); break; + case 20: // CtrlT = ST key = throw an NMI to stop execution of user program + nmi6502(); clearkey(); Serial.print("STop\n"); break; + } + + // round 1B: keys that always have the same meaning but are disabled in VTL-02 + if(keyboardMode!=2) + { + switch(curkey) { + case '[': // SST off + SSTmode = 0; clearkey(); + Serial.print(F(" SST OFF ")); + break; + case ']': // SST on + SSTmode = 1; clearkey(); + Serial.print(F(" SST ON ")); + break; + case 9: // TAB pressed, toggle between serial port and onboard keyboard/display + if (useKeyboardLed==0) + { useKeyboardLed=1; Serial.print(F(" Keyboard/Hex Digits Mode ")); } + else + { useKeyboardLed=0; Serial.print(F(" Serial Terminal Mode "));} + reset6502(); clearkey(); break; + case '>': // Toggle write protect on eeprom + if (eepromProtect==0) { + eepromProtect = 1; + Serial.print(F(" Eeprom R/O ")); + } else { + eepromProtect = 0; + Serial.print(F(" Eeprom R/W ")); + delay(20); + } + clearkey(); break; + } + } + + // round 2: keys in Calculator Mode + if (keyboardMode==1) { // in case of Calculator Mode + switch (curkey) { + case 'C': enterflt((uint8_t)0); if (!((curkey>='C') && (curkey<='F'))) break; // if statement allows roll-through to next reg entry + case 'D': enterflt((uint8_t)1); if (!((curkey>='C') && (curkey<='F'))) break; + case 'F': enteroperation(); break; + case 'E': enterflt((uint8_t)2); break; + + case 1: showflt(0); break; // AD + case 4: showflt(1); break; // DA + case 16: showflt(2); break; // PC + } + } +} + +// ================================================================================================= +// KIM Uno Board functions are bolted on from here +// ================================================================================================= + +void setupUno() { + int i; + // --------- initialse for scanning keyboard matrix ----------------- + // set columns to input with pullups + for (i=0;i<8;i++) + { pinMode(aCols[i], INPUT); // set pin to input + digitalWrite(aCols[i], HIGH); // turn on pullup resistors + } + // set rows to output, and set them High to be in Neutral position + for (i=0;i<3;i++) + { pinMode(aRows[i], OUTPUT); // set pin to output + digitalWrite(aRows[i], HIGH); // set to high + } + // --------- clear display buffer ------------------------------------ + for (i=0;i<3;i++) + { threeHex[i][0]=threeHex[i][0]=0; } + Serial.println(F("Ready")); +} + + +extern "C" { +void driveLEDs() +{ + int led, col, ledNo, currentBit, bitOn; + int byt,i; + + // 1. initialse for driving the 6 (now 8) 7segment LEDs + // ledSelect pins drive common anode for [all segments] in [one of 6 LEDs] + for (led=0;led<7;led++) + { pinMode(ledSelect[led], OUTPUT); // set led pins to output + digitalWrite(ledSelect[led], LOW); // LOW = not lit + } + // 2. switch column pins to output mode + // column pins are the cathode for the LED segments + // lame code to cycle through the 3 bytes of 2 digits each = 6 leds + for (byt=0;byt<3;byt++) + for (i=0;i<2;i++) + { + ledNo=byt*2+i; + for (col=0;col<8;col++) + { pinMode(aCols[col], OUTPUT); // set pin to output + //currentBit = (1<<(6-col)); // isolate the current bit in loop + currentBit = (1<<(7-col)); // isolate the current bit in loop + bitOn = (currentBit&dig[threeHex[byt][i]])==0; + digitalWrite(aCols[col], bitOn); // set the bit + } + digitalWrite(ledSelect[ledNo], HIGH); // Light this LED + delay(2); + digitalWrite(ledSelect[ledNo], LOW); // unLight this LED + } +} // end of function +} // end of C segment + +void driveCalcLEDs(uint8_t *numberStr, uint8_t decpt) +{ + uint8_t led, col, ledNo, currentBit, bitOn; + uint8_t digit,i; + + // 1. initialse for driving the 6 segment LEDs + for (led=0;led<7;led++) + { pinMode(ledSelect7[led], OUTPUT); // set led pins to output + digitalWrite(ledSelect7[led], LOW); // LOW = not lit + } + // 2. switch column pins to output mode + for (digit=0;digit<7;digit++) + { for (col=0;col<8;col++) + { pinMode(aCols[col], OUTPUT); // set pin to output + currentBit = (1<<(7-col)); // isolate the current bit in loop + bitOn = (currentBit&dig[numberStr[digit]-48])==0; + if (col==0 && digit==decpt) // show decimal point here? + bitOn=0; // 0 being light led. + digitalWrite(aCols[col], bitOn); // set the bit + } + digitalWrite(ledSelect7[digit], HIGH); // Light this LED + delay(2); + digitalWrite(ledSelect7[digit], LOW); // unLight this LED + } +} // end of function +//} // end of C segment + + +uint8_t parseChar(uint8_t n) // parse keycode to return its ASCII code +{ + uint8_t c; + + // KIM-I keys + switch (n-1) { //KIM Uno keyscan codes to ASCII codes used by emulator + case 7 : c = '0' ; break; // note: these are n-1 numbers! + case 6 : c = '1'; break; // + case 5 : c = '2'; break; // + case 4 : c = '3'; break; // + case 3 : c = '4'; break; // + case 2 : c = '5'; break; // + case 1 : c = '6'; break; // + case 0 : c = 20; break; // ST + + case 15 : c = '7' ; break; // + case 14 : c = '8'; break; // + case 13 : c = '9'; break; // + case 12 : c = 'A'; break; // + case 11 : c = 'B'; break; // + case 10 : c = 'C'; break; // + case 9 : c = 'D'; break; // + case 8 : c = 18; break; // RS + + case 23 : c = 'E'; break; // + case 22 : c = 'F'; break; // + case 21 : c = 1; break; // AD + case 20 : c = 4; break; // DA + case 19 : c = '+'; break; // + + case 18 : c = 7; break; // GO + case 17 : c = 16; break; // PC + case 16 : c = (SSTmode==0?']':'['); break; // SST toggle + } + return c; +} + +uint8_t xkeyPressed() // just see if there's any keypress waiting +{ return (curkey==0?0:1); } + + +extern "C" { // the extern C is to make function accessible from within cpu.c +void scanKeys() +{ + int led,row,col, noKeysScanned; + static int keyCode = -1, prevKey = 0; + static unsigned long timeFirstPressed = 0; + + // 0. disable driving the 7segment LEDs ----------------- + for (led=0;led<8;led++) + { pinMode(ledSelect[led], INPUT); // set led pins to input + // not really necessary, just to stop them + // from driving either high or low. + digitalWrite(ledSelect[led], HIGH); // Use builtin pullup resistors + } + // 1. initialise: set columns to input with pullups + for (col=0;col<8;col++) + { pinMode(aCols[col], INPUT); // set pin to input + digitalWrite(aCols[col], HIGH); // turn on pullup resistors + } + // 2. perform scanning + noKeysScanned=0; + + for (row=0; row<3; row++) + { digitalWrite(aRows[row], LOW); // activate this row + for (col=0;col<8;col++) + { if (digitalRead(aCols[col])==LOW) // key is pressed + { keyCode = col+row*8+1; + if (keyCode!=prevKey) + { //Serial.println(); + //Serial.print(" col: "); Serial.print(col, DEC); + //Serial.print(" row: "); Serial.print(row, DEC); + //Serial.print(" prevKey: "); Serial.print(prevKey, DEC); + //Serial.print(" KeyCode: "); Serial.println(keyCode, DEC); + prevKey = keyCode; + curkey = parseChar(keyCode); + //Serial.print(" curkey: "); Serial.print(curkey, DEC); + timeFirstPressed=millis(); // + } + else // if pressed for >1sec, it's a ModeShift key + { + if ((millis()-timeFirstPressed)>1000) // more than 1000 ms + { + if (keyCode==17) //it was the SST button + { + keyboardMode=(keyboardMode==0?1:0); // toggle +// Serial.print(F(" Eeprom R/O ")); + Serial.print(F(" keyboardMode: ")); Serial.print(keyboardMode, DEC); + SSTmode=0; + curkey=0; // don't do anything else with this keypress + } + if (keyCode==9) // it was RS button + curkey = '>'; // toggle eeprom write protect +// for VTL-02 + if (keyCode==1) // it was ST button + { + curkey = 0; // toggle eeprom write protect + keyboardMode=(keyboardMode==0?2:0); // toggle + Serial.print(F(" keyboardMode(VTL): ")); Serial.print(keyboardMode, DEC); + } +// ---------- + timeFirstPressed=millis(); // because otherwise you toggle right back! + + } + } + } + else + noKeysScanned++; // another row in which no keys were pressed + } + digitalWrite(aRows[row], HIGH); // de-activate this row + } + + if (noKeysScanned==24) // no keys detected in any row, 3 rows * 8 columns = 24. used to be 28. + prevKey=0; // allows you to enter same key twice +} // end of function +} // end C segment + +extern "C" { // the extern C is to make function accessible from within cpu.c +uint8_t enterflt(uint8_t reg) // result code -1 = cancel, 0 = good +{ + uint8_t fltstr[32]; // display string + uint8_t decpt = 0xFF, expt = 0xFF; // pointers to start of mantissa & exponent in string + uint8_t mntsign = 0, expsign = 0; // 1 means negative for mantissa/exponent + uint8_t strpos = 0, i, j; // strpos is position counter in string + uint8_t mntval = 0, expval = 0; // parsed value of mantissa & exponent + uint8_t carry = 0, addToExp; + int digit; + uint16_t offset; + uint8_t done=0; + + // init + offset = WREG_OFFSET + 8*reg; + for (i=0;i<8;i++) + #ifdef AVRX + fltstr[i]=65; + #else + fltstr[i]='_'; + #endif + + // input loop --------------------------------------------------------------- + do { + #ifdef AVRX + curkey=0; + driveCalcLEDs(fltstr, decpt); // xxxxxx decpt may be a problem + scanKeys(); + if (curkey!=0) { + #else + if (_kbhit()) {//} + curkey = _getch(); + #endif + + if (curkey=='+') { + if (expt==0xFF) { // not yet into exponent + mntsign = 1; strpos=0; + #ifdef AVRX + fltstr[strpos++] = 64; + #else + fltstr[strpos++] = '-'; + #endif + } else { // minus sign relates to exponent + expsign = 1; strpos=expt; + #ifdef AVRX + fltstr[strpos++] = 64; + #else + fltstr[strpos++] = '-'; + #endif + } + } + if ((curkey>='0') && (curkey<='9')) { + // temp protection against entering 0.025, which breaks this code. + // temp fix: do not allow entering a 0 after 0. + if ((curkey=='0') && (decpt==(strpos-1)) && (fltstr[strpos-1]=='0')) + { + // do nothing, that's the temp fix + } + else + // end of temp bug fix + fltstr[strpos++] = curkey; + } + if (curkey=='B') { + expt = strpos; + #ifdef AVRX + fltstr[strpos++] = 62; + #else + fltstr[strpos++] = 'E'; + #endif + } + if (curkey=='A') { + decpt = strpos-1; + } + + #ifdef AVRX + fltstr[strpos] = 65; + #else + fltstr[strpos]=0x00; // terminate into nice string + #endif + } + } while ((strpos<8) && (curkey!=7) && (curkey!=19) && (1!=(curkey>='C') && (curkey<='F'))); + + if (curkey==19) + return(-1); // cancel + + // parse into 8 byte fltpt65 format ----------------------------------------------------------------- + // Ugly, horrible code. But running out of Arduino memory means C library calls must be avoided. + + if (expt==0xFF) // if no E was entered, let it start at end of string and be 0 length + expt = strpos; + if (decpt==0xFF) // if no dec pt was entered, put it at end of mantissa, just before the E + decpt = expt-1; + addToExp = decpt - mntsign; // normalise mantissa: how much to add to exp to have 1.2345 format + + // Exponent 3: parse and adjust exponent value to get normalised 1.23 format using addToExp + if ((strpos-1)>expt) // user at least entered 1 exp digit + digit = (expsign==1?-1:1) * ((int) fltstr[strpos-1]-48) + (int) addToExp; //expsign*-1: deal with negative exps + else + digit = (int) addToExp; // user entered number without exp. So exp is 0. + if (digit<0) + digit = -(digit); // do not want to use abs() function-arduino out of memory space :) + RAM[offset+1] = (digit<=9?digit:digit-10); // store adjusted exp digit + addToExp = (digit<=9?0:1); // simple carry mechanism: add could overflow to 2nd sigit + + // Exponent 2: same thing. + if ((strpos-2)>expt) // user entered a second exp digit + digit = (expsign==1?-1:1) * ((int) fltstr[strpos-2]-48) + (int) addToExp; //expsign*-1: deal with negative exps + else + digit = (int) addToExp; // user entered number without exp. So exp is 0. + if (digit<0) + digit = -(digit); // do not want to use abs() function-arduino out of memory space :) + RAM[offset+1] |= (digit<=9?digit:digit-10)<<4; // store adjusted exp digit in upper nibble + addToExp = (digit<=9?0:1); // simple carry mechanism: add could overflow to 2nd sigit + + // Exponent 1: same thing. + if ((strpos-3)>expt) // user entered a second exp digit + digit = ((int) fltstr[strpos-3]-48) + (int) addToExp; // there is no carry or add to exp in digit 3 + else + digit = (int) addToExp; // user entered number without exp. So exp is 0. + if (digit<0) + digit = -(digit); // do not want to use abs() function-arduino out of memory space :) + RAM[offset+0] = (digit<=9?digit:digit-10); // store adjusted exp digit in lower nibble + + // Sign bits + RAM[offset+0] |= ((mntsign<<7) | (expsign<<6)); +// printf("%u %u ", (RAM[offset+0] & 0xF0)>>4, RAM[offset+0] & 0x0F); +// printf("%u %u \n", (RAM[offset+1] & 0xF0)>>4, RAM[offset+1] & 0x0F); + + // print mantissa + j = mntsign; + for (i=0;i<12;i++) + { + if (j>4, RAM[offset+2+i] & 0x0F); + } +// printf("\n"); + return (curkey); // return value, if not -1, can be used to jump to next register value entry call +} // end function +} // end C segment + +extern "C" { // the extern C is to make function accessible from within cpu.c +uint8_t showflt(uint8_t reg) // returns location of decimal point in string +{ + uint8_t fltstr[32]; // display string + uint8_t mntsign = 0, expsign = 0; // 1 means negative for mantissa/exponent + uint8_t cnt, expt, i; // decpt, + uint16_t offset; + int exp, decpt; + + // init + offset = WREG_OFFSET + 8*reg; + for (i=0;i<8;i++) + fltstr[i]='_'; // no longer necessary I think + // calculate exponent + exp = (RAM[offset+1] & 0x0F) + 10*((RAM[offset+1] & 0xF0)>>4) + 100*(RAM[offset+0] & 0x0F); +// printf("\n\nexp = %d\n", exp); + + // determine maximum exponent value we can show as normal number without E + mntsign = (RAM[offset+0] & 0x80)>>7; // negative mantissa: 1 + expsign = (RAM[offset+0] & 0x40)>>6; // negative exponent: 1 + decpt = (mntsign==0?0:1); // dec point is after digit0 (+ values) or digit1 (- values) + + // with pos numbers, any E between 0 and 7 can be polished away. If there's a '-', one less + if ((exp>0) && (exp<(7 - mntsign)) && (expsign==0)) + { // yes, we can polish E away + decpt +=exp; + expt = 0; + } +/* else // negative exponent + { decpt -=exp; + // need to ROR the string's digits or decpt gets to be negative! + + expt = 0; + } + } +*/ else // we need to show exponent, how many digits? + { expt = 0; + if (exp>0) + { expt = 2; //1; + fltstr[6] = (RAM[offset+1] & 0x0F) + 48; + } + if (exp>9) + { expt = 3; //2; + fltstr[5] = (uint8_t) ((RAM[offset+1] & 0xF0)>>4) + (uint8_t) 48; + } + if (exp>90) + { expt = 4; //3; + fltstr[4] = (RAM[offset+0] & 0x0F) + 48; + } + #ifdef AVRX + fltstr[7-expt] = (expsign==1?64:62); + #else + fltstr[7-expt] = (expsign==1?'-':'E'); + #endif + } + + // fill string with mantissa + cnt=0; + if (mntsign==1) + #ifdef AVRX + fltstr[0] = 64; + #else + fltstr[0]='-'; + #endif + + for (i=mntsign;i<(7-expt);i=i+2) + { + fltstr[i] = (uint8_t) ((RAM[offset + 2 + cnt ] & 0xF0)>>4) + (uint8_t) 48; +// printf(" %c ", (uint8_t) ((RAM[offset + 2 + cnt ] & 0xF0)>>4) + (uint8_t) 48); + if ((i+1)<(7-expt)) // bug fix 20141007 + { fltstr[i+1] = (RAM[offset + 2 + cnt ] & 0x0F) + 48; +// printf(" %c ", (RAM[offset + 2 + cnt ] & 0x0F) + 48); + } + cnt++; + } + fltstr[7]=0x00; // string terminator + +// printf("\n\n%s\n", fltstr); + + #ifdef AVRX + curkey=0; + do { driveCalcLEDs(fltstr, decpt); scanKeys(); + } while (curkey==0); + if ((curkey<'C') || (curkey>'F')) + curkey=0; // to clear any keypresses before returning to KIM + #else + // show number with dec point inserted + for (i=0;i<=decpt;i++) + printf("%c", fltstr[i]); + printf("."); + for (i=decpt+1;i<7;i++) + printf("%c", fltstr[i]); + printf("\n"); + #endif + + return decpt; // pointers to start of mantissa & exponent in string +} // end function +} // end C segment + + +extern "C" { // the extern C is to make function accessible from within cpu.c +uint8_t enteroperation(void) // result code -1 = cancel, 0 = good +{ + uint8_t fltstr[8]; // display string + uint8_t strpos = 4, i; // strpos is position counter in string + + // init + #ifdef AVRX + for (i=0;i<8;i++) fltstr[i]=66; + fltstr[4]=65; fltstr[5]=65; + #else + for (i=0;i<8;i++) fltstr[i]=' '; + fltstr[4]='_'; fltstr[5]='_'; + #endif + + // input loop --------------------------------------------------------------- + do { + #ifdef AVRX + curkey=0; + driveCalcLEDs(fltstr, 5); scanKeys(); + if (curkey!=0) { + #else + if (_kbhit()) { // } this curly brace is there so Arduino IDE does not miscount when it does { } highlighting + curkey = _getch(); + #endif + + if ((curkey>=48) && (curkey<=57)) //only allow dec digits + fltstr[strpos++] = curkey; + + #ifdef AVRX + fltstr[strpos] = 65; + #else + fltstr[strpos]=0x00; // terminate into nice string +// printf("> %s ms%u es%u expt%u decpt%u\r", fltstr, mntsign, expsign, expt, decpt); + #endif + } + } while ((strpos<6) && (curkey!=7) && (curkey!=19)); + + if (curkey==19) + return(-1); // cancel + + RAM[0x00F3]= (fltstr[4]-48)*10 + (fltstr[5]-48); // operation to go into 6502 A register + RAM[0x00EF] = (uint8_t) 0xE0; RAM[0x00F0] = (uint8_t) 0x6F; // set PC register to fltpt65 start address (0x6FE0, not 0x5000, we need to start with a JSR and end with a BRK) + curkey = 16; // PC + + return(RAM[0x00F3]); +} +} // end C segment + + diff --git a/trunk/Arduino/KIMUNO/cpu.c b/trunk/Arduino/KIMUNO/cpu.c new file mode 100644 index 00000000..f4512985 --- /dev/null +++ b/trunk/Arduino/KIMUNO/cpu.c @@ -0,0 +1,3271 @@ +/* KIM-I emulator for Arduino. + Most of this is the 6502 emulator from Mike Chambers, + http://forum.arduino.cc/index.php?topic=193216.0 + http://forum.arduino.cc/index.php?PHPSESSID=po7fh9f1tkuorr32n58jgofc61&action=dlattach;topic=193216.0;attach=56567 + KIM-I hacked in by Oscar + http://obsolescenceguaranteed.blogspot.ch/ +*/ + +#define AVRX // define on for Arduino, off for normal PC C compilers + +#include +#include + +#ifdef AVRX +// #define NULL (void *) 0 + #include + extern uint8_t eepromread(uint16_t eepromaddress); + extern void eepromwrite(uint16_t eepromaddress, uint8_t bytevalue); +#else + #include "cpu.h" + #include + #pragma warning(disable : 4996) // MS VC2008 does not like unsigned char -> signed char converts. +#endif + +//#define WREG_OFFSET 0x03DF +#define WREG_OFFSET 0x0360 +//#define DEBUGUNO + +#ifdef DEBUGUNO +//--------------- debug +extern FILE *fpx; +uint16_t debugPC; +// -------------- +#endif + + +// temporary: +//extern unsigned char calcRom[8160]; + +extern char threeHex[3][2]; // buffer for 3 hex digits +extern int blitzMode; // status variable only for microchess + +extern void printhex(uint16_t val); +extern void serout(uint8_t value); +extern void serouthex(uint8_t val); +extern uint8_t getAkey(void); // for serial port get normal ASCII keys +extern uint8_t getKIMkey(); // for emulation of KIM keypad +extern void clearkey(void); +extern void driveLEDs(); +extern void scanKeys(); + +void nmi6502(void); + +uint8_t useKeyboardLed=0x01; // set to 0 to use Serial port, to 1 to use onboard keyboard/LED display. +uint8_t iii; // counter for various purposes, declared here to avoid in-function delay in 6502 functions. +uint8_t nmiFlag=0; // added by OV to aid single-stepping SST mode on KIM-I +uint8_t SSTmode = 0; // SST switch in KIM-I: 1 = on. + + +#define FLAG_CARRY 0x01 +#define FLAG_ZERO 0x02 +#define FLAG_INTERRUPT 0x04 +#define FLAG_DECIMAL 0x08 +#define FLAG_BREAK 0x10 +#define FLAG_CONSTANT 0x20 +#define FLAG_OVERFLOW 0x40 +#define FLAG_SIGN 0x80 +#define BASE_STACK 0x100 + +#define saveaccum(n) a = (uint8_t)((n) & 0x00FF) + +//flag modifier macros +#define setcarry() cpustatus |= FLAG_CARRY +#define clearcarry() cpustatus &= (~FLAG_CARRY) +#define setzero() cpustatus |= FLAG_ZERO +#define clearzero() cpustatus &= (~FLAG_ZERO) +#define setinterrupt() cpustatus |= FLAG_INTERRUPT +#define clearinterrupt() cpustatus &= (~FLAG_INTERRUPT) +#define setdecimal() cpustatus |= FLAG_DECIMAL +#define cleardecimal() cpustatus &= (~FLAG_DECIMAL) +#define setoverflow() cpustatus |= FLAG_OVERFLOW +#define clearoverflow() cpustatus &= (~FLAG_OVERFLOW) +#define setsign() cpustatus |= FLAG_SIGN +#define clearsign() cpustatus &= (~FLAG_SIGN) + +//flag calculation macros +#define zerocalc(n) { if ((n) & 0x00FF) clearzero(); else setzero(); } +#define signcalc(n) { if ((n) & 0x0080) setsign(); else clearsign(); } +#define carrycalc(n) { if ((n) & 0xFF00) setcarry(); else clearcarry(); } +#define overflowcalc(n, m, o) { if (((n) ^ (uint16_t)(m)) & ((n) ^ (o)) & 0x0080) setoverflow(); else clearoverflow(); } + + +//6502 CPU registers +uint16_t pc; +uint8_t sp, a, x, y, cpustatus; +// BCD fix OV 20140915 - helper variables for adc and sbc +uint16_t lxx,hxx; +// end of BCD fix part 1 + +//helper variables +uint32_t instructions = 0; //keep track of total instructions executed +int32_t clockticks6502 = 0, clockgoal6502 = 0; +uint16_t oldpc, ea, reladdr, value, result; +uint8_t opcode, oldcpustatus, useaccum; + +// FLTPT65 SUPPORT ------------------------------------------------------------------ +void copyWreg(uint8_t a, uint8_t b); +void swapWreg(uint8_t a, uint8_t b); +extern uint8_t enterflt(uint8_t reg); +extern uint8_t showflt(uint8_t reg); +extern uint8_t enteroperation(void); + +// --- OVERVIEW OF KIM-1 MEMORY MAP ------------------------------------------------- +uint8_t RAM[1024]; // main 1KB RAM 0x0000-0x04FF +#ifndef AVRX +uint8_t RAM2[1024]; // on PC, ram in 0x0500-0x08FF instead of Arduino EEPROM +#endif // on Arduino, these are EEPROM functions +// empty 0x0900-0x13FF +// I/O and timer of 6530-003, free for user 0x1700-0x173F, not used in KIM ROM +// I/O and timer of 6530-002, used by KIM 0x1740-0x177F, used by LED/Keyboard +uint8_t RAM003[64]; // RAM from 6530-003 0x1780-0x17BF, free for user applications +uint8_t RAM002[64]; // RAM from 6530-002 0x17C0-0x17FF, free for user except 0x17E7-0x17FF +// rom003 is 0x1800-0x1BFF +// rom002 is 0x1C00-0x1FFF + +// note that above 8K map is not replicated 8 times to fill 64K, +// but INSTEAD, emulator mirrors last 6 bytes of ROM 002 to FFFB-FFFF: +// FFFA, FFFB - NMI Vector +// FFFC, FFFD - RST Vector +// FFFE, FFFF - IRQ Vector +// Application roms (mchess, calc) are above standard 8K of KIM-1 + + +// --- CRBond calculator RAM workspace: -------------------------------------------- +// - NOTE THAT UPPER 128 BYTES OF KIM RAM IS USED BY CALCULATOR AS WORKSPACE! +// - W1 starts at 3Df +// - W2 starts at 3E7 +// - W3 starts at 3EF +uint8_t getRegister(uint8_t reg, uint8_t *inVal); // returns place of decimal point + +uint8_t getRegister(uint8_t reg, uint8_t *inVal) +{ + uint16_t offset; +// uint8_t i; +// uint8_t *eptr; + + offset = WREG_OFFSET + reg*8; // place in RAM for W1/2/3/4 registers + +/* sprintf(inVal, "%c%c.%c%c%c%c%c%c%c%c%c%c%ce%c%c%c%c", + // mantissa sign + (RAM[0+offset]&(uint8_t)128)==0?'+':'-', + // mantissa + ((RAM[2+offset]&0xF0)>>4) + (uint8_t)48, (RAM[2+offset]&0x0F) + (uint8_t)48, + ((RAM[3+offset]&0xF0)>>4) + (uint8_t)48, (RAM[3+offset]&0x0F) + (uint8_t)48, + ((RAM[4+offset]&0xF0)>>4) + (uint8_t)48, (RAM[4+offset]&0x0F) + (uint8_t)48, + ((RAM[5+offset]&0xF0)>>4) + (uint8_t)48, (RAM[5+offset]&0x0F) + (uint8_t)48, + ((RAM[6+offset]&0xF0)>>4) + (uint8_t)48, (RAM[6+offset]&0x0F) + (uint8_t)48, + ((RAM[7+offset]&0xF0)>>4) + (uint8_t)48, (RAM[7+offset]&0x0F) + (uint8_t)48, + // exponent sign + (RAM[0+offset]&(uint8_t)64)==0?'+':'-', + // exponent + (RAM[0+offset]&0x0F) + (uint8_t)48, + ((RAM[1+offset]&0xF0)>>4) + (uint8_t)48, (RAM[1+offset]&0x0F) + (uint8_t)48 ); +*/ + + // print in most compact form + // 2. do we print a leading '-' cos mantissa negative? + if ((RAM[0+offset]&(uint8_t)128)==0) // mantissa positive, skip the + to save a digit + { + sprintf(inVal, "%c%c%c%c%c%c%c", + // mantissa sign + //(RAM[0+offset]&(uint8_t)128)==0?'+':'-', + // mantissa + ((RAM[2+offset]&0xF0)>>4) + (uint8_t)48, (RAM[2+offset]&0x0F) + (uint8_t)48, + ((RAM[3+offset]&0xF0)>>4) + (uint8_t)48, (RAM[3+offset]&0x0F) + (uint8_t)48, + //((RAM[4+offset]&0xF0)>>4) + (uint8_t)48, (RAM[4+offset]&0x0F) + (uint8_t)48, + //((RAM[5+offset]&0xF0)>>4) + (uint8_t)48, (RAM[5+offset]&0x0F) + (uint8_t)48, + //((RAM[6+offset]&0xF0)>>4) + (uint8_t)48, (RAM[6+offset]&0x0F) + (uint8_t)48, + //((RAM[7+offset]&0xF0)>>4) + (uint8_t)48, (RAM[7+offset]&0x0F) + (uint8_t)48, + // exponent sign + (RAM[0+offset]&(uint8_t)64)==0?(uint8_t)62:(uint8_t)64, // E, or G is printed as - + // exponent +/*!!!*/ //(RAM[0+offset]&0x0F) + (uint8_t)48, + ((RAM[1+offset]&0xF0)>>4) + (uint8_t)48, (RAM[1+offset]&0x0F) + (uint8_t)48 ); + return 0; // light dec point on first digit + } + else // mantissa negative, add a minus + { + sprintf(inVal, "%c%c%c%c%c%c%c", //G printed as - + // mantissa sign + 64, // G printed as - + //(RAM[0+offset]&(uint8_t)128)==0?'+':'-', + // mantissa + ((RAM[2+offset]&0xF0)>>4) + (uint8_t)48, (RAM[2+offset]&0x0F) + (uint8_t)48, + ((RAM[3+offset]&0xF0)>>4) + (uint8_t)48, //(RAM[3+offset]&0x0F) + (uint8_t)48, + //((RAM[4+offset]&0xF0)>>4) + (uint8_t)48, (RAM[4+offset]&0x0F) + (uint8_t)48, + //((RAM[5+offset]&0xF0)>>4) + (uint8_t)48, (RAM[5+offset]&0x0F) + (uint8_t)48, + //((RAM[6+offset]&0xF0)>>4) + (uint8_t)48, (RAM[6+offset]&0x0F) + (uint8_t)48, + //((RAM[7+offset]&0xF0)>>4) + (uint8_t)48, (RAM[7+offset]&0x0F) + (uint8_t)48, + // exponent sign + (RAM[0+offset]&(uint8_t)64)==0?(uint8_t)62:(uint8_t)64, //E or G printed as - + // exponent +/*!!!*/ //(RAM[0+offset]&0x0F) + (uint8_t)48, + ((RAM[1+offset]&0xF0)>>4) + (uint8_t)48, (RAM[1+offset]&0x0F) + (uint8_t)48 ); + + return 1; // light dec point on second digit (given 1st digit is a -) + } +} + + +// --- ROM CODE SECTION ------------------------------------------------------------ +// ROM1: KIM-1 ROM002 (monitor main code) $17C0 +// ROM2: KIM-1 ROM003 (tape and RS-232 code) $1780 +// mchess: the updated microchess version from www.benlo.com/microchess +// recompiled to start at $C000 +// calc: the 6502 floating point library from www.crbond.com/calc65.htm +// recompiled to start at $D000 +// disassembler: the famous Baum & Wozniak disassember +// 6502.org/documents/publications/6502notes/6502_user_notes_14.pdf at $2000 +// storage arrays that are copied to RAM are also here: +// relocate (first book of kim) to $0110 +// branch (first book of kim) to $01A5 +// movit (first book of kim) to $1780 +// --------------------------------------------------------------------------------- +#ifdef AVRX +const unsigned char rom002[1024] PROGMEM = { +#else +unsigned char rom002[1024] = { +#endif + 0x85, 0xF3, 0x68, 0x85, 0xF1, 0x68, 0x85, 0xEF, 0x85, 0xFA, 0x68, 0x85, + 0xF0, 0x85, 0xFB, 0x84, 0xF4, 0x86, 0xF5, 0xBA, 0x86, 0xF2, 0x20, 0x88, + 0x1E, 0x4C, 0x4F, 0x1C, 0x6C, 0xFA, 0x17, 0x6C, 0xFE, 0x17, 0xA2, 0xFF, + 0x9A, 0x86, 0xF2, 0x20, 0x88, 0x1E, 0xA9, 0xFF, 0x8D, 0xF3, 0x17, 0xA9, + 0x01, 0x2C, 0x40, 0x17, 0xD0, 0x19, 0x30, 0xF9, 0xA9, 0xFC, 0x18, 0x69, + 0x01, 0x90, 0x03, 0xEE, 0xF3, 0x17, 0xAC, 0x40, 0x17, 0x10, 0xF3, 0x8D, + 0xF2, 0x17, 0xA2, 0x08, 0x20, 0x6A, 0x1E, 0x20, 0x8C, 0x1E, 0xA9, 0x01, + 0x2C, 0x40, 0x17, 0xD0, 0x1E, 0x20, 0x2F, 0x1E, 0xA2, 0x0A, 0x20, 0x31, + 0x1E, 0x4C, 0xAF, 0x1D, 0xA9, 0x00, 0x85, 0xF8, 0x85, 0xF9, 0x20, 0x5A, + 0x1E, 0xC9, 0x01, 0xF0, 0x06, 0x20, 0xAC, 0x1F, 0x4C, 0xDB, 0x1D, 0x20, + 0x19, 0x1F, 0xD0, 0xD3, 0xA9, 0x01, 0x2C, 0x40, 0x17, 0xF0, 0xCC, 0x20, + 0x19, 0x1F, 0xF0, 0xF4, 0x20, 0x19, 0x1F, 0xF0, 0xEF, 0x20, 0x6A, 0x1F, + 0xC9, 0x15, 0x10, 0xBB, 0xC9, 0x14, 0xF0, 0x44, 0xC9, 0x10, 0xF0, 0x2C, + 0xC9, 0x11, 0xF0, 0x2C, 0xC9, 0x12, 0xF0, 0x2F, 0xC9, 0x13, 0xF0, 0x31, + 0x0A, 0x0A, 0x0A, 0x0A, 0x85, 0xFC, 0xA2, 0x04, 0xA4, 0xFF, 0xD0, 0x0A, + 0xB1, 0xFA, 0x06, 0xFC, 0x2A, 0x91, 0xFA, 0x4C, 0xC3, 0x1C, 0x0A, 0x26, + 0xFA, 0x26, 0xFB, 0xCA, 0xD0, 0xEA, 0xF0, 0x08, 0xA9, 0x01, 0xD0, 0x02, + 0xA9, 0x00, 0x85, 0xFF, 0x4C, 0x4F, 0x1C, 0x20, 0x63, 0x1F, 0x4C, 0x4F, + 0x1C, 0x4C, 0xC8, 0x1D, 0xA5, 0xEF, 0x85, 0xFA, 0xA5, 0xF0, 0x85, 0xFB, + 0x4C, 0x4F, 0x1C, 0x20, 0x5A, 0x1E, 0xC9, 0x3B, 0xD0, 0xF9, 0xA9, 0x00, + 0x85, 0xF7, 0x85, 0xF6, 0x20, 0x9D, 0x1F, 0xAA, 0x20, 0x91, 0x1F, 0x20, + 0x9D, 0x1F, 0x85, 0xFB, 0x20, 0x91, 0x1F, 0x20, 0x9D, 0x1F, 0x85, 0xFA, + 0x20, 0x91, 0x1F, 0x8A, 0xF0, 0x0F, 0x20, 0x9D, 0x1F, 0x91, 0xFA, 0x20, + 0x91, 0x1F, 0x20, 0x63, 0x1F, 0xCA, 0xD0, 0xF2, 0xE8, 0x20, 0x9D, 0x1F, + 0xC5, 0xF6, 0xD0, 0x17, 0x20, 0x9D, 0x1F, 0xC5, 0xF7, 0xD0, 0x13, 0x8A, + 0xD0, 0xB9, 0xA2, 0x0C, 0xA9, 0x27, 0x8D, 0x42, 0x17, 0x20, 0x31, 0x1E, + 0x4C, 0x4F, 0x1C, 0x20, 0x9D, 0x1F, 0xA2, 0x11, 0xD0, 0xEE, 0xA9, 0x00, + 0x85, 0xF8, 0x85, 0xF9, 0xA9, 0x00, 0x85, 0xF6, 0x85, 0xF7, 0x20, 0x2F, + 0x1E, 0xA9, 0x3B, 0x20, 0xA0, 0x1E, 0xA5, 0xFA, 0xCD, 0xF7, 0x17, 0xA5, + 0xFB, 0xED, 0xF8, 0x17, 0x90, 0x18, 0xA9, 0x00, 0x20, 0x3B, 0x1E, 0x20, + 0xCC, 0x1F, 0x20, 0x1E, 0x1E, 0xA5, 0xF6, 0x20, 0x3B, 0x1E, 0xA5, 0xF7, + 0x20, 0x3B, 0x1E, 0x4C, 0x64, 0x1C, 0xA9, 0x18, 0xAA, 0x20, 0x3B, 0x1E, + 0x20, 0x91, 0x1F, 0x20, 0x1E, 0x1E, 0xA0, 0x00, 0xB1, 0xFA, 0x20, 0x3B, + 0x1E, 0x20, 0x91, 0x1F, 0x20, 0x63, 0x1F, 0xCA, 0xD0, 0xF0, 0xA5, 0xF6, + 0x20, 0x3B, 0x1E, 0xA5, 0xF7, 0x20, 0x3B, 0x1E, 0xE6, 0xF8, 0xD0, 0x02, + 0xE6, 0xF9, 0x4C, 0x48, 0x1D, 0x20, 0xCC, 0x1F, 0x20, 0x2F, 0x1E, 0x20, + 0x1E, 0x1E, 0x20, 0x9E, 0x1E, 0xA0, 0x00, 0xB1, 0xFA, 0x20, 0x3B, 0x1E, + 0x20, 0x9E, 0x1E, 0x4C, 0x64, 0x1C, 0x20, 0x63, 0x1F, 0x4C, 0xAC, 0x1D, + 0xA6, 0xF2, 0x9A, 0xA5, 0xFB, 0x48, 0xA5, 0xFA, 0x48, 0xA5, 0xF1, 0x48, + 0xA6, 0xF5, 0xA4, 0xF4, 0xA5, 0xF3, 0x40, 0xC9, 0x20, 0xF0, 0xCA, 0xC9, + 0x7F, 0xF0, 0x1B, 0xC9, 0x0D, 0xF0, 0xDB, 0xC9, 0x0A, 0xF0, 0x1C, 0xC9, + 0x2E, 0xF0, 0x26, 0xC9, 0x47, 0xF0, 0xD5, 0xC9, 0x51, 0xF0, 0x0A, 0xC9, + 0x4C, 0xF0, 0x09, 0x4C, 0x6A, 0x1C, 0x4C, 0x4F, 0x1C, 0x4C, 0x42, 0x1D, + 0x4C, 0xE7, 0x1C, 0x38, 0xA5, 0xFA, 0xE9, 0x01, 0x85, 0xFA, 0xB0, 0x02, + 0xC6, 0xFB, 0x4C, 0xAC, 0x1D, 0xA0, 0x00, 0xA5, 0xF8, 0x91, 0xFA, 0x4C, + 0xC2, 0x1D, 0xA5, 0xFB, 0x20, 0x3B, 0x1E, 0x20, 0x91, 0x1F, 0xA5, 0xFA, + 0x20, 0x3B, 0x1E, 0x20, 0x91, 0x1F, 0x60, 0xA2, 0x07, 0xBD, 0xD5, 0x1F, + 0x20, 0xA0, 0x1E, 0xCA, 0x10, 0xF7, 0x60, 0x85, 0xFC, 0x4A, 0x4A, 0x4A, + 0x4A, 0x20, 0x4C, 0x1E, 0xA5, 0xFC, 0x20, 0x4C, 0x1E, 0xA5, 0xFC, 0x60, + 0x29, 0x0F, 0xC9, 0x0A, 0x18, 0x30, 0x02, 0x69, 0x07, 0x69, 0x30, 0x4C, + 0xA0, 0x1E, 0x86, 0xFD, 0xA2, 0x08, 0xA9, 0x01, 0x2C, 0x40, 0x17, 0xD0, + 0x22, 0x30, 0xF9, 0x20, 0xD4, 0x1E, 0x20, 0xEB, 0x1E, 0xAD, 0x40, 0x17, + 0x29, 0x80, 0x46, 0xFE, 0x05, 0xFE, 0x85, 0xFE, 0x20, 0xD4, 0x1E, 0xCA, + 0xD0, 0xEF, 0x20, 0xEB, 0x1E, 0xA6, 0xFD, 0xA5, 0xFE, 0x2A, 0x4A, 0x60, + 0xA2, 0x01, 0x86, 0xFF, 0xA2, 0x00, 0x8E, 0x41, 0x17, 0xA2, 0x3F, 0x8E, + 0x43, 0x17, 0xA2, 0x07, 0x8E, 0x42, 0x17, 0xD8, 0x78, 0x60, 0xA9, 0x20, + 0x85, 0xFE, 0x86, 0xFD, 0x20, 0xD4, 0x1E, 0xAD, 0x42, 0x17, 0x29, 0xFE, + 0x8D, 0x42, 0x17, 0x20, 0xD4, 0x1E, 0xA2, 0x08, 0xAD, 0x42, 0x17, 0x29, + 0xFE, 0x46, 0xFE, 0x69, 0x00, 0x8D, 0x42, 0x17, 0x20, 0xD4, 0x1E, 0xCA, + 0xD0, 0xEE, 0xAD, 0x42, 0x17, 0x09, 0x01, 0x8D, 0x42, 0x17, 0x20, 0xD4, + 0x1E, 0xA6, 0xFD, 0x60, 0xAD, 0xF3, 0x17, 0x8D, 0xF4, 0x17, 0xAD, 0xF2, + 0x17, 0x38, 0xE9, 0x01, 0xB0, 0x03, 0xCE, 0xF4, 0x17, 0xAC, 0xF4, 0x17, + 0x10, 0xF3, 0x60, 0xAD, 0xF3, 0x17, 0x8D, 0xF4, 0x17, 0xAD, 0xF2, 0x17, + 0x4A, 0x4E, 0xF4, 0x17, 0x90, 0xE3, 0x09, 0x80, 0xB0, 0xE0, 0xA0, 0x03, + 0xA2, 0x01, 0xA9, 0xFF, 0x8E, 0x42, 0x17, 0xE8, 0xE8, 0x2D, 0x40, 0x17, + 0x88, 0xD0, 0xF5, 0xA0, 0x07, 0x8C, 0x42, 0x17, 0x09, 0x80, 0x49, 0xFF, + 0x60, 0xA0, 0x00, 0xB1, 0xFA, 0x85, 0xF9, 0xA9, 0x7F, 0x8D, 0x41, 0x17, + 0xA2, 0x09, 0xA0, 0x03, 0xB9, 0xF8, 0x00, 0x4A, 0x4A, 0x4A, 0x4A, 0x20, + 0x48, 0x1F, 0xB9, 0xF8, 0x00, 0x29, 0x0F, 0x20, 0x48, 0x1F, 0x88, 0xD0, + 0xEB, 0x8E, 0x42, 0x17, 0xA9, 0x00, 0x8D, 0x41, 0x17, 0x4C, 0xFE, 0x1E, + 0x84, 0xFC, 0xA8, 0xB9, 0xE7, 0x1F, 0xA0, 0x00, 0x8C, 0x40, 0x17, 0x8E, + 0x42, 0x17, 0x8D, 0x40, 0x17, 0xA0, 0x7F, 0x88, 0xD0, 0xFD, 0xE8, 0xE8, + 0xA4, 0xFC, 0x60, 0xE6, 0xFA, 0xD0, 0x02, 0xE6, 0xFB, 0x60, 0xA2, 0x21, + 0xA0, 0x01, 0x20, 0x02, 0x1F, 0xD0, 0x07, 0xE0, 0x27, 0xD0, 0xF5, 0xA9, + 0x15, 0x60, 0xA0, 0xFF, 0x0A, 0xB0, 0x03, 0xC8, 0x10, 0xFA, 0x8A, 0x29, + 0x0F, 0x4A, 0xAA, 0x98, 0x10, 0x03, 0x18, 0x69, 0x07, 0xCA, 0xD0, 0xFA, + 0x60, 0x18, 0x65, 0xF7, 0x85, 0xF7, 0xA5, 0xF6, 0x69, 0x00, 0x85, 0xF6, + 0x60, 0x20, 0x5A, 0x1E, 0x20, 0xAC, 0x1F, 0x20, 0x5A, 0x1E, 0x20, 0xAC, + 0x1F, 0xA5, 0xF8, 0x60, 0xC9, 0x30, 0x30, 0x1B, 0xC9, 0x47, 0x10, 0x17, + 0xC9, 0x40, 0x30, 0x03, 0x18, 0x69, 0x09, 0x2A, 0x2A, 0x2A, 0x2A, 0xA0, + 0x04, 0x2A, 0x26, 0xF8, 0x26, 0xF9, 0x88, 0xD0, 0xF8, 0xA9, 0x00, 0x60, + 0xA5, 0xF8, 0x85, 0xFA, 0xA5, 0xF9, 0x85, 0xFB, 0x60, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x0A, 0x0D, 0x4D, 0x49, 0x4B, 0x20, 0x13, 0x52, 0x52, + 0x45, 0x20, 0x13, 0xBF, 0x86, 0xDB, 0xCF, 0xE6, 0xED, 0xFD, 0x87, 0xFF, + 0xEF, 0xF7, 0xFC, 0xB9, 0xDE, 0xF9, 0xF1, 0xFF, 0xFF, 0xFF, 0x1C, 0x1C, + 0x22, 0x1C, 0x1F, 0x1C +}; + +#ifdef AVRX +const unsigned char rom003[1024] PROGMEM = { +#else +unsigned char rom003[1024] = { +#endif + 0xA9, 0xAD, 0x8D, 0xEC, 0x17, 0x20, 0x32, 0x19, 0xA9, 0x27, 0x8D, 0x42, + 0x17, 0xA9, 0xBF, 0x8D, 0x43, 0x17, 0xA2, 0x64, 0xA9, 0x16, 0x20, 0x7A, + 0x19, 0xCA, 0xD0, 0xF8, 0xA9, 0x2A, 0x20, 0x7A, 0x19, 0xAD, 0xF9, 0x17, + 0x20, 0x61, 0x19, 0xAD, 0xF5, 0x17, 0x20, 0x5E, 0x19, 0xAD, 0xF6, 0x17, + 0x20, 0x5E, 0x19, 0xAD, 0xED, 0x17, 0xCD, 0xF7, 0x17, 0xAD, 0xEE, 0x17, + 0xED, 0xF8, 0x17, 0x90, 0x24, 0xA9, 0x2F, 0x20, 0x7A, 0x19, 0xAD, 0xE7, + 0x17, 0x20, 0x61, 0x19, 0xAD, 0xE8, 0x17, 0x20, 0x61, 0x19, 0xA2, 0x02, + 0xA9, 0x04, 0x20, 0x7A, 0x19, 0xCA, 0xD0, 0xF8, 0xA9, 0x00, 0x85, 0xFA, + 0x85, 0xFB, 0x4C, 0x4F, 0x1C, 0x20, 0xEC, 0x17, 0x20, 0x5E, 0x19, 0x20, + 0xEA, 0x19, 0x4C, 0x33, 0x18, 0x0F, 0x19, 0xA9, 0x8D, 0x8D, 0xEC, 0x17, + 0x20, 0x32, 0x19, 0xA9, 0x4C, 0x8D, 0xEF, 0x17, 0xAD, 0x71, 0x18, 0x8D, + 0xF0, 0x17, 0xAD, 0x72, 0x18, 0x8D, 0xF1, 0x17, 0xA9, 0x07, 0x8D, 0x42, + 0x17, 0xA9, 0xFF, 0x8D, 0xE9, 0x17, 0x20, 0x41, 0x1A, 0x4E, 0xE9, 0x17, + 0x0D, 0xE9, 0x17, 0x8D, 0xE9, 0x17, 0xAD, 0xE9, 0x17, 0xC9, 0x16, 0xD0, + 0xED, 0xA2, 0x0A, 0x20, 0x24, 0x1A, 0xC9, 0x16, 0xD0, 0xDF, 0xCA, 0xD0, + 0xF6, 0x20, 0x24, 0x1A, 0xC9, 0x2A, 0xF0, 0x06, 0xC9, 0x16, 0xD0, 0xD1, + 0xF0, 0xF3, 0x20, 0xF3, 0x19, 0xCD, 0xF9, 0x17, 0xF0, 0x0D, 0xAD, 0xF9, + 0x17, 0xC9, 0x00, 0xF0, 0x06, 0xC9, 0xFF, 0xF0, 0x17, 0xD0, 0x9C, 0x20, + 0xF3, 0x19, 0x20, 0x4C, 0x19, 0x8D, 0xED, 0x17, 0x20, 0xF3, 0x19, 0x20, + 0x4C, 0x19, 0x8D, 0xEE, 0x17, 0x4C, 0xF8, 0x18, 0x20, 0xF3, 0x19, 0x20, + 0x4C, 0x19, 0x20, 0xF3, 0x19, 0x20, 0x4C, 0x19, 0xA2, 0x02, 0x20, 0x24, + 0x1A, 0xC9, 0x2F, 0xF0, 0x14, 0x20, 0x00, 0x1A, 0xD0, 0x23, 0xCA, 0xD0, + 0xF1, 0x20, 0x4C, 0x19, 0x4C, 0xEC, 0x17, 0x20, 0xEA, 0x19, 0x4C, 0xF8, + 0x18, 0x20, 0xF3, 0x19, 0xCD, 0xE7, 0x17, 0xD0, 0x0C, 0x20, 0xF3, 0x19, + 0xCD, 0xE8, 0x17, 0xD0, 0x04, 0xA9, 0x00, 0xF0, 0x02, 0xA9, 0xFF, 0x85, + 0xFA, 0x85, 0xFB, 0x4C, 0x4F, 0x1C, 0xAD, 0xF5, 0x17, 0x8D, 0xED, 0x17, + 0xAD, 0xF6, 0x17, 0x8D, 0xEE, 0x17, 0xA9, 0x60, 0x8D, 0xEF, 0x17, 0xA9, + 0x00, 0x8D, 0xE7, 0x17, 0x8D, 0xE8, 0x17, 0x60, 0xA8, 0x18, 0x6D, 0xE7, + 0x17, 0x8D, 0xE7, 0x17, 0xAD, 0xE8, 0x17, 0x69, 0x00, 0x8D, 0xE8, 0x17, + 0x98, 0x60, 0x20, 0x4C, 0x19, 0xA8, 0x4A, 0x4A, 0x4A, 0x4A, 0x20, 0x6F, + 0x19, 0x98, 0x20, 0x6F, 0x19, 0x98, 0x60, 0x29, 0x0F, 0xC9, 0x0A, 0x18, + 0x30, 0x02, 0x69, 0x07, 0x69, 0x30, 0x8E, 0xE9, 0x17, 0x8C, 0xEA, 0x17, + 0xA0, 0x08, 0x20, 0x9E, 0x19, 0x4A, 0xB0, 0x06, 0x20, 0x9E, 0x19, 0x4C, + 0x91, 0x19, 0x20, 0xC4, 0x19, 0x20, 0xC4, 0x19, 0x88, 0xD0, 0xEB, 0xAE, + 0xE9, 0x17, 0xAC, 0xEA, 0x17, 0x60, 0xA2, 0x09, 0x48, 0x2C, 0x47, 0x17, + 0x10, 0xFB, 0xA9, 0x7E, 0x8D, 0x44, 0x17, 0xA9, 0xA7, 0x8D, 0x42, 0x17, + 0x2C, 0x47, 0x17, 0x10, 0xFB, 0xA9, 0x7E, 0x8D, 0x44, 0x17, 0xA9, 0x27, + 0x8D, 0x42, 0x17, 0xCA, 0xD0, 0xDF, 0x68, 0x60, 0xA2, 0x06, 0x48, 0x2C, + 0x47, 0x17, 0x10, 0xFB, 0xA9, 0xC3, 0x8D, 0x44, 0x17, 0xA9, 0xA7, 0x8D, + 0x42, 0x17, 0x2C, 0x47, 0x17, 0x10, 0xFB, 0xA9, 0xC3, 0x8D, 0x44, 0x17, + 0xA9, 0x27, 0x8D, 0x42, 0x17, 0xCA, 0xD0, 0xDF, 0x68, 0x60, 0xEE, 0xED, + 0x17, 0xD0, 0x03, 0xEE, 0xEE, 0x17, 0x60, 0x20, 0x24, 0x1A, 0x20, 0x00, + 0x1A, 0x20, 0x24, 0x1A, 0x20, 0x00, 0x1A, 0x60, 0xC9, 0x30, 0x30, 0x1E, + 0xC9, 0x47, 0x10, 0x1A, 0xC9, 0x40, 0x30, 0x03, 0x18, 0x69, 0x09, 0x2A, + 0x2A, 0x2A, 0x2A, 0xA0, 0x04, 0x2A, 0x2E, 0xE9, 0x17, 0x88, 0xD0, 0xF9, + 0xAD, 0xE9, 0x17, 0xA0, 0x00, 0x60, 0xC8, 0x60, 0x8E, 0xEB, 0x17, 0xA2, + 0x08, 0x20, 0x41, 0x1A, 0x4E, 0xEA, 0x17, 0x0D, 0xEA, 0x17, 0x8D, 0xEA, + 0x17, 0xCA, 0xD0, 0xF1, 0xAD, 0xEA, 0x17, 0x2A, 0x4A, 0xAE, 0xEB, 0x17, + 0x60, 0x2C, 0x42, 0x17, 0x10, 0xFB, 0xAD, 0x46, 0x17, 0xA0, 0xFF, 0x8C, + 0x46, 0x17, 0xA0, 0x14, 0x88, 0xD0, 0xFD, 0x2C, 0x42, 0x17, 0x30, 0xFB, + 0x38, 0xED, 0x46, 0x17, 0xA0, 0xFF, 0x8C, 0x46, 0x17, 0xA0, 0x07, 0x88, + 0xD0, 0xFD, 0x49, 0xFF, 0x29, 0x80, 0x60, 0xA9, 0x27, 0x8D, 0x42, 0x17, + 0xA9, 0xBF, 0x8D, 0x43, 0x17, 0x2C, 0x47, 0x17, 0x10, 0xFB, 0xA9, 0x9A, + 0x8D, 0x44, 0x17, 0xA9, 0xA7, 0x8D, 0x42, 0x17, 0x2C, 0x47, 0x17, 0x10, + 0xFB, 0xA9, 0x9A, 0x8D, 0x44, 0x17, 0xA9, 0x27, 0x8D, 0x42, 0x17, 0x4C, + 0x75, 0x1A, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x6B, 0x1A, + 0x6B, 0x1A, 0x6B, 0x1A}; + + +// Microchess at C000: +/* C:\temp27\KIM Uno\sw\KIM Uno 6502 ROM sources\microchess for KIM Uno\UCHESS7.BIN (15/09/2014 14:35:46) + StartOffset: 00000000, EndOffset: 00000570, Length: 00000571 */ + +#ifdef AVRX +const unsigned char mchess[1393] PROGMEM = { +#else +unsigned char mchess[1393] = { +#endif + 0xA9, 0x00, 0x85, 0xB7, 0x20, 0x54, 0xC4, 0xD8, 0xA2, 0xFF, 0x9A, 0xA2, + 0xC8, 0x86, 0xB2, 0x20, 0x78, 0xC3, 0x20, 0x49, 0xC4, 0xC9, 0x43, 0xD0, + 0x12, 0xA2, 0x1F, 0xBD, 0x14, 0xC5, 0x95, 0x50, 0xCA, 0x10, 0xF8, 0xA2, + 0x1B, 0x86, 0xDC, 0xA9, 0xCC, 0xD0, 0x19, 0xC9, 0x45, 0xD0, 0x0E, 0x20, + 0xC1, 0xC1, 0x38, 0xA9, 0x01, 0xE5, 0xB7, 0x85, 0xB7, 0xA9, 0xEE, 0xD0, + 0x07, 0xC9, 0x40, 0xD0, 0x0B, 0x20, 0xB5, 0xC2, 0x85, 0xFB, 0x85, 0xFA, + 0x85, 0xF9, 0xD0, 0xBB, 0xC9, 0x0D, 0xD0, 0x06, 0x20, 0x5B, 0xC2, 0x4C, + 0xFD, 0xC0, 0xC9, 0x41, 0xF0, 0x03, 0x4C, 0xF6, 0xC0, 0x4C, 0x00, 0xFF, + 0xA6, 0xB5, 0x30, 0x5C, 0xA5, 0xB0, 0xF0, 0x08, 0xE0, 0x08, 0xD0, 0x04, + 0xC5, 0xE6, 0xF0, 0x2E, 0xF6, 0xE3, 0xC9, 0x01, 0xD0, 0x02, 0xF6, 0xE3, + 0x50, 0x1E, 0xA0, 0x0F, 0xA5, 0xB1, 0xD9, 0x60, 0x00, 0xF0, 0x03, 0x88, + 0x10, 0xF8, 0xB9, 0x45, 0xC5, 0xD5, 0xE4, 0x90, 0x04, 0x94, 0xE6, 0x95, + 0xE4, 0x18, 0x08, 0x75, 0xE5, 0x95, 0xE5, 0x28, 0xE0, 0x04, 0xF0, 0x03, + 0x30, 0x31, 0x60, 0xA5, 0xE8, 0x85, 0xDD, 0xA9, 0x00, 0x85, 0xB5, 0x20, + 0x5B, 0xC2, 0x20, 0xC1, 0xC1, 0x20, 0x0F, 0xC1, 0x20, 0xC1, 0xC1, 0xA9, + 0x08, 0x85, 0xB5, 0x20, 0x18, 0xC1, 0x20, 0x41, 0xC2, 0x4C, 0x12, 0xC3, + 0xE0, 0xF9, 0xD0, 0x0B, 0xA5, 0x60, 0xC5, 0xB1, 0xD0, 0x04, 0xA9, 0x00, + 0x85, 0xB4, 0x60, 0x50, 0xFD, 0xA0, 0x07, 0xA5, 0xB1, 0xD9, 0x60, 0x00, + 0xF0, 0x05, 0x88, 0xF0, 0xF1, 0x10, 0xF6, 0xB9, 0x45, 0xC5, 0xD5, 0xE2, + 0x90, 0x02, 0x95, 0xE2, 0xC6, 0xB5, 0xA9, 0xFB, 0xC5, 0xB5, 0xF0, 0x03, + 0x20, 0x35, 0xC2, 0xE6, 0xB5, 0x60, 0xC9, 0x08, 0xB0, 0x12, 0x20, 0x02, + 0xC3, 0xA2, 0x1F, 0xB5, 0x50, 0xC5, 0xFA, 0xF0, 0x03, 0xCA, 0x10, 0xF7, + 0x86, 0xFB, 0x86, 0xB0, 0x4C, 0x07, 0xC0, 0xA2, 0x10, 0xA9, 0x00, 0x95, + 0xDE, 0xCA, 0x10, 0xFB, 0xA9, 0x10, 0x85, 0xB0, 0xC6, 0xB0, 0x10, 0x01, + 0x60, 0x20, 0x2E, 0xC2, 0xA4, 0xB0, 0xA2, 0x08, 0x86, 0xB6, 0xC0, 0x08, + 0x10, 0x41, 0xC0, 0x06, 0x10, 0x2E, 0xC0, 0x04, 0x10, 0x1F, 0xC0, 0x01, + 0xF0, 0x09, 0x10, 0x0E, 0x20, 0x9D, 0xC1, 0xD0, 0xFB, 0xF0, 0xD9, 0x20, + 0xAB, 0xC1, 0xD0, 0xFB, 0xF0, 0xD2, 0xA2, 0x04, 0x86, 0xB6, 0x20, 0xAB, + 0xC1, 0xD0, 0xFB, 0xF0, 0xC7, 0x20, 0xAB, 0xC1, 0xA5, 0xB6, 0xC9, 0x04, + 0xD0, 0xF7, 0xF0, 0xBC, 0xA2, 0x10, 0x86, 0xB6, 0x20, 0x9D, 0xC1, 0xA5, + 0xB6, 0xC9, 0x08, 0xD0, 0xF7, 0xF0, 0xAD, 0xA2, 0x06, 0x86, 0xB6, 0x20, + 0xD9, 0xC1, 0x50, 0x05, 0x30, 0x03, 0x20, 0x60, 0xC0, 0x20, 0x2E, 0xC2, + 0xC6, 0xB6, 0xA5, 0xB6, 0xC9, 0x05, 0xF0, 0xEB, 0x20, 0xD9, 0xC1, 0x70, + 0x8F, 0x30, 0x8D, 0x20, 0x60, 0xC0, 0xA5, 0xB1, 0x29, 0xF0, 0xC9, 0x20, + 0xF0, 0xEE, 0x4C, 0x1C, 0xC1, 0x20, 0xD9, 0xC1, 0x30, 0x03, 0x20, 0x60, + 0xC0, 0x20, 0x2E, 0xC2, 0xC6, 0xB6, 0x60, 0x20, 0xD9, 0xC1, 0x90, 0x02, + 0x50, 0xF9, 0x30, 0x07, 0x08, 0x20, 0x60, 0xC0, 0x28, 0x50, 0xF0, 0x20, + 0x2E, 0xC2, 0xC6, 0xB6, 0x60, 0xA2, 0x0F, 0x38, 0xB4, 0x60, 0xA9, 0x77, + 0xF5, 0x50, 0x95, 0x60, 0x94, 0x50, 0x38, 0xA9, 0x77, 0xF5, 0x50, 0x95, + 0x50, 0xCA, 0x10, 0xEB, 0x60, 0xA5, 0xB1, 0xA6, 0xB6, 0x18, 0x7D, 0x34, + 0xC5, 0x85, 0xB1, 0x29, 0x88, 0xD0, 0x42, 0xA5, 0xB1, 0xA2, 0x20, 0xCA, + 0x30, 0x0E, 0xD5, 0x50, 0xD0, 0xF9, 0xE0, 0x10, 0x30, 0x33, 0xA9, 0x7F, + 0x69, 0x01, 0x70, 0x01, 0xB8, 0xA5, 0xB5, 0x30, 0x24, 0xC9, 0x08, 0x10, + 0x20, 0x48, 0x08, 0xA9, 0xF9, 0x85, 0xB5, 0x85, 0xB4, 0x20, 0x5B, 0xC2, + 0x20, 0xC1, 0xC1, 0x20, 0x18, 0xC1, 0x20, 0x3E, 0xC2, 0x28, 0x68, 0x85, + 0xB5, 0xA5, 0xB4, 0x30, 0x04, 0x38, 0xA9, 0xFF, 0x60, 0x18, 0xA9, 0x00, + 0x60, 0xA9, 0xFF, 0x18, 0xB8, 0x60, 0xA6, 0xB0, 0xB5, 0x50, 0x85, 0xB1, + 0x60, 0x20, 0x5B, 0xC2, 0x20, 0xC1, 0xC1, 0x20, 0x18, 0xC1, 0x20, 0xC1, + 0xC1, 0xBA, 0x86, 0xB3, 0xA6, 0xB2, 0x9A, 0x68, 0x85, 0xB6, 0x68, 0x85, + 0xB0, 0xAA, 0x68, 0x95, 0x50, 0x68, 0xAA, 0x68, 0x85, 0xB1, 0x95, 0x50, + 0x4C, 0x80, 0xC2, 0xBA, 0x86, 0xB3, 0xA6, 0xB2, 0x9A, 0xA5, 0xB1, 0x48, + 0xA8, 0xA2, 0x1F, 0xD5, 0x50, 0xF0, 0x03, 0xCA, 0x10, 0xF9, 0xA9, 0xCC, + 0x95, 0x50, 0x8A, 0x48, 0xA6, 0xB0, 0xB5, 0x50, 0x94, 0x50, 0x48, 0x8A, + 0x48, 0xA5, 0xB6, 0x48, 0xBA, 0x86, 0xB2, 0xA6, 0xB3, 0x9A, 0x60, 0xA6, + 0xE4, 0xEC, 0x45, 0xC5, 0xD0, 0x04, 0xA9, 0x00, 0xF0, 0x0A, 0xA6, 0xE3, + 0xD0, 0x06, 0xA6, 0xEE, 0xD0, 0x02, 0xA9, 0xFF, 0xA2, 0x04, 0x86, 0xB5, + 0xC5, 0xFA, 0x90, 0x0C, 0xF0, 0x0A, 0x85, 0xFA, 0xA5, 0xB0, 0x85, 0xFB, + 0xA5, 0xB1, 0x85, 0xF9, 0xA9, 0x2E, 0x4C, 0x60, 0xC4, 0xA6, 0xDC, 0x30, + 0x1C, 0xA5, 0xF9, 0xDD, 0x55, 0xC5, 0xD0, 0x11, 0xCA, 0xBD, 0x55, 0xC5, + 0x85, 0xFB, 0xCA, 0xBD, 0x55, 0xC5, 0x85, 0xF9, 0xCA, 0x86, 0xDC, 0xD0, + 0x1C, 0xA9, 0xFF, 0x85, 0xDC, 0xA2, 0x0C, 0x86, 0xB5, 0x86, 0xFA, 0xA2, + 0x14, 0x20, 0x11, 0xC1, 0xA2, 0x04, 0x86, 0xB5, 0x20, 0x0F, 0xC1, 0xA6, + 0xFA, 0xE0, 0x0F, 0x90, 0x12, 0xA6, 0xFB, 0xB5, 0x50, 0x85, 0xFA, 0x86, + 0xB0, 0xA5, 0xF9, 0x85, 0xB1, 0x20, 0x5B, 0xC2, 0x4C, 0x07, 0xC0, 0xA9, + 0xFF, 0x60, 0xA2, 0x04, 0x06, 0xF9, 0x26, 0xFA, 0xCA, 0xD0, 0xF9, 0x05, + 0xF9, 0x85, 0xF9, 0x85, 0xB1, 0x60, 0x18, 0xA9, 0x80, 0x65, 0xEB, 0x65, + 0xEC, 0x65, 0xED, 0x65, 0xE1, 0x65, 0xDF, 0x38, 0xE5, 0xF0, 0xE5, 0xF1, + 0xE5, 0xE2, 0xE5, 0xE0, 0xE5, 0xDE, 0xE5, 0xEF, 0xE5, 0xE3, 0xB0, 0x02, + 0xA9, 0x00, 0x4A, 0x18, 0x69, 0x40, 0x65, 0xEC, 0x65, 0xED, 0x38, 0xE5, + 0xE4, 0x4A, 0x18, 0x69, 0x90, 0x65, 0xDD, 0x65, 0xDD, 0x65, 0xDD, 0x65, + 0xDD, 0x65, 0xE1, 0x38, 0xE5, 0xE4, 0xE5, 0xE4, 0xE5, 0xE5, 0xE5, 0xE5, + 0xE5, 0xE0, 0xA6, 0xB1, 0xE0, 0x33, 0xF0, 0x16, 0xE0, 0x34, 0xF0, 0x12, + 0xE0, 0x22, 0xF0, 0x0E, 0xE0, 0x25, 0xF0, 0x0A, 0xA6, 0xB0, 0xF0, 0x09, + 0xB4, 0x50, 0xC0, 0x10, 0x10, 0x03, 0x18, 0x69, 0x02, 0x4C, 0x87, 0xC2, + 0x20, 0x17, 0xC4, 0x20, 0x3B, 0xC4, 0x20, 0x22, 0xC4, 0xA0, 0x00, 0x20, + 0xE9, 0xC3, 0xA9, 0x7C, 0x20, 0x60, 0xC4, 0xA2, 0x1F, 0x98, 0xD5, 0x50, + 0xF0, 0x40, 0xCA, 0x10, 0xF8, 0x98, 0x29, 0x01, 0x85, 0xFC, 0x98, 0x4A, + 0x4A, 0x4A, 0x4A, 0x29, 0x01, 0x18, 0x65, 0xFC, 0x29, 0x01, 0xF0, 0x03, + 0xA9, 0x2A, 0x2C, 0xA9, 0x20, 0x20, 0x60, 0xC4, 0x20, 0x60, 0xC4, 0xC8, + 0x98, 0x29, 0x08, 0xF0, 0xCD, 0xA9, 0x7C, 0x20, 0x60, 0xC4, 0x20, 0x34, + 0xC4, 0x20, 0x17, 0xC4, 0x20, 0xE9, 0xC3, 0x18, 0x98, 0x69, 0x08, 0xA8, + 0xC0, 0x80, 0xF0, 0x2B, 0xD0, 0xB4, 0xA5, 0xB7, 0xF0, 0x05, 0xBD, 0xD3, + 0xC4, 0xD0, 0x03, 0xBD, 0xC3, 0xC4, 0x20, 0x60, 0xC4, 0xBD, 0xF3, 0xC4, + 0x20, 0x60, 0xC4, 0xD0, 0xCA, 0x8A, 0x48, 0xA2, 0x19, 0xA9, 0x2D, 0x20, + 0x60, 0xC4, 0xCA, 0xD0, 0xFA, 0x68, 0xAA, 0x20, 0x17, 0xC4, 0x60, 0x20, + 0x22, 0xC4, 0xA5, 0xFB, 0x20, 0x64, 0xC4, 0xA9, 0x20, 0x20, 0x60, 0xC4, + 0xA5, 0xFA, 0x20, 0x64, 0xC4, 0xA9, 0x20, 0x20, 0x60, 0xC4, 0xA5, 0xF9, + 0x20, 0x64, 0xC4, 0xA9, 0x0D, 0x20, 0x60, 0xC4, 0xA9, 0x0A, 0x20, 0x60, + 0xC4, 0x60, 0xA2, 0x00, 0xA9, 0x20, 0x20, 0x60, 0xC4, 0x8A, 0x20, 0x64, + 0xC4, 0xE8, 0xE0, 0x08, 0xD0, 0xF2, 0xF0, 0xE3, 0x98, 0x29, 0x70, 0x20, + 0x64, 0xC4, 0x60, 0xA2, 0x00, 0xBD, 0x8A, 0xC4, 0xF0, 0x06, 0x20, 0x60, + 0xC4, 0xE8, 0xD0, 0xF5, 0x60, 0xA9, 0x3F, 0x20, 0x60, 0xC4, 0x20, 0x55, + 0xC4, 0x29, 0x4F, 0x60, 0x60, 0xAD, 0xF3, 0xCF, 0xC5, 0x01, 0xF0, 0xF9, + 0xAD, 0xF4, 0xCF, 0x60, 0x8D, 0xF1, 0xCF, 0x60, 0x48, 0x4A, 0x4A, 0x4A, + 0x4A, 0x20, 0x6D, 0xC4, 0x68, 0x29, 0x0F, 0x84, 0xFF, 0xA8, 0xB9, 0x7A, + 0xC4, 0xA4, 0xFF, 0x4C, 0x60, 0xC4, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, + 0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x4D, 0x69, + 0x63, 0x72, 0x6F, 0x43, 0x68, 0x65, 0x73, 0x73, 0x20, 0x28, 0x63, 0x29, + 0x20, 0x31, 0x39, 0x39, 0x36, 0x2D, 0x32, 0x30, 0x30, 0x35, 0x20, 0x50, + 0x65, 0x74, 0x65, 0x72, 0x20, 0x4A, 0x65, 0x6E, 0x6E, 0x69, 0x6E, 0x67, + 0x73, 0x2C, 0x20, 0x77, 0x77, 0x77, 0x2E, 0x62, 0x65, 0x6E, 0x6C, 0x6F, + 0x2E, 0x63, 0x6F, 0x6D, 0x0D, 0x0A, 0x00, 0x57, 0x57, 0x57, 0x57, 0x57, + 0x57, 0x57, 0x57, 0x57, 0x57, 0x57, 0x57, 0x57, 0x57, 0x57, 0x57, 0x42, + 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, + 0x42, 0x42, 0x42, 0x57, 0x57, 0x57, 0x57, 0x57, 0x57, 0x57, 0x57, 0x57, + 0x57, 0x57, 0x57, 0x57, 0x57, 0x57, 0x57, 0x4B, 0x51, 0x52, 0x52, 0x42, + 0x42, 0x4E, 0x4E, 0x50, 0x50, 0x50, 0x50, 0x50, 0x50, 0x50, 0x50, 0x4B, + 0x51, 0x52, 0x52, 0x42, 0x42, 0x4E, 0x4E, 0x50, 0x50, 0x50, 0x50, 0x50, + 0x50, 0x50, 0x50, 0x00, 0x03, 0x04, 0x00, 0x07, 0x02, 0x05, 0x01, 0x06, + 0x10, 0x17, 0x11, 0x16, 0x12, 0x15, 0x14, 0x13, 0x73, 0x74, 0x70, 0x77, + 0x72, 0x75, 0x71, 0x76, 0x60, 0x67, 0x61, 0x66, 0x62, 0x65, 0x64, 0x63, + 0x00, 0xF0, 0xFF, 0x01, 0x10, 0x11, 0x0F, 0xEF, 0xF1, 0xDF, 0xE1, 0xEE, + 0xF2, 0x12, 0x0E, 0x1F, 0x21, 0x0B, 0x0A, 0x06, 0x06, 0x04, 0x04, 0x04, + 0x04, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x99, 0x25, 0x0B, + 0x25, 0x01, 0x00, 0x33, 0x25, 0x07, 0x36, 0x34, 0x0D, 0x34, 0x34, 0x0E, + 0x52, 0x25, 0x0D, 0x45, 0x35, 0x04, 0x55, 0x22, 0x06, 0x43, 0x33, 0x0F, + 0xCC +}; + +/* C:\temp27\KIM Uno\sw\KIM Uno 6502 ROM sources\fltpt65 for KIM Uno\fs6.bin (19/09/2014 17:17:16) + StartOffset: 00000000, EndOffset: 00001FDF, Length: 00001FE0 */ + +//unsigned char calcRom[8160] = { +#ifdef AVRX +const unsigned char calcRom[8164] PROGMEM = { +#else +unsigned char calcRom[8164] = { +#endif + +// 0xA2, 0xFF, 0x9A, 0xD8, 0x0A, 0x0A, 0x18, 0x69, 0x11, 0xAA, 0xA9, 0x50, + 0xA2, 0xFF, 0xEA, 0xD8, 0x0A, 0x0A, 0x18, 0x69, 0x11, 0xAA, 0xA9, 0x50, +// 0x69, 0x00, 0x48, 0x8A, 0x48, 0x60, 0x20, 0xB6, 0x50, 0x00, 0x20, 0xAE, + 0x69, 0x00, 0x48, 0x8A, 0x48, 0x60, 0x20, 0xB6, 0x50, 0x60, 0x20, 0xAE, +// 0x50, 0x00, 0x20, 0x78, 0x53, 0x00, 0x20, 0x35, 0x55, 0x00, 0x20, 0xE6, + 0x50, 0x60, 0x20, 0x78, 0x53, 0x60, 0x20, 0x35, 0x55, 0x60, 0x20, 0xE6, +// 0x56, 0x00, 0x20, 0x3E, 0x66, 0x00, 0x20, 0xE2, 0x66, 0x00, 0x20, 0x2B, + 0x56, 0x60, 0x20, 0x3E, 0x66, 0x60, 0x20, 0xE2, 0x66, 0x60, 0x20, 0x2B, +// 0x67, 0x00, 0x20, 0x54, 0x66, 0x00, 0x20, 0x66, 0x66, 0x00, 0x20, 0x0A, + 0x67, 0x60, 0x20, 0x54, 0x66, 0x60, 0x20, 0x66, 0x66, 0x60, 0x20, 0x0A, +// 0x59, 0x00, 0x20, 0x33, 0x59, 0x00, 0x20, 0x4C, 0x59, 0x00, 0x20, 0x91, + 0x59, 0x60, 0x20, 0x33, 0x59, 0x60, 0x20, 0x4C, 0x59, 0x60, 0x20, 0x91, +// 0x59, 0x00, 0x20, 0xB5, 0x58, 0x00, 0x20, 0x8C, 0x59, 0x00, 0x20, 0x96, + 0x59, 0x60, 0x20, 0xB5, 0x58, 0x60, 0x20, 0x8C, 0x59, 0x60, 0x20, 0x96, +// 0x5B, 0x00, 0x20, 0x7D, 0x5B, 0x00, 0x20, 0x2F, 0x5C, 0x00, 0x20, 0x4E, + 0x5B, 0x60, 0x20, 0x7D, 0x5B, 0x60, 0x20, 0x2F, 0x5C, 0x60, 0x20, 0x4E, +// 0x5E, 0x00, 0x20, 0x66, 0x5E, 0x00, 0x20, 0x7E, 0x5E, 0x00, 0x20, 0x96, + 0x5E, 0x60, 0x20, 0x66, 0x5E, 0x60, 0x20, 0x7E, 0x5E, 0x60, 0x20, 0x96, +// 0x5E, 0x00, 0x20, 0x35, 0x61, 0x00, 0x20, 0x13, 0x63, 0x00, 0x20, 0x54, + 0x5E, 0x60, 0x20, 0x35, 0x61, 0x60, 0x20, 0x13, 0x63, 0x60, 0x20, 0x54, +// 0x63, 0x00, 0x20, 0x8D, 0x63, 0x00, 0x20, 0x0D, 0x64, 0x00, 0x20, 0x25, + 0x63, 0x60, 0x20, 0x8D, 0x63, 0x60, 0x20, 0x0D, 0x64, 0x60, 0x20, 0x25, +// 0x64, 0x00, 0x20, 0x3D, 0x64, 0x00, 0x20, 0x55, 0x64, 0x00, 0x20, 0xAE, + 0x64, 0x60, 0x20, 0x3D, 0x64, 0x60, 0x20, 0x55, 0x64, 0x60, 0x20, 0xAE, +// 0x64, 0x00, 0x20, 0x07, 0x65, 0x00, 0x20, 0x74, 0x65, 0x00, 0x20, 0x95, + 0x64, 0x60, 0x20, 0x07, 0x65, 0x60, 0x20, 0x74, 0x65, 0x60, 0x20, 0x95, +// 0x65, 0x00, 0x20, 0xB6, 0x65, 0x00, 0x20, 0xD7, 0x65, 0x00, 0x20, 0xEF, + 0x65, 0x60, 0x20, 0xB6, 0x65, 0x60, 0x20, 0xD7, 0x65, 0x60, 0x20, 0xEF, +// 0x65, 0x00, 0x20, 0x07, 0x66, 0x00, 0xAD, 0x68, 0x03, 0x49, 0x80, 0x8D, + 0x65, 0x60, 0x20, 0x07, 0x66, 0x60, 0xAD, 0x68, 0x03, 0x49, 0x80, 0x8D, + + 0x68, 0x03, 0xF8, 0xAD, 0x62, 0x03, 0xD0, 0x09, 0xA9, 0x68, 0xA0, 0x03, + 0xA2, 0x70, 0x4C, 0x30, 0x52, 0xAD, 0x6A, 0x03, 0xD0, 0x09, 0xA9, 0x60, + 0xA0, 0x03, 0xA2, 0x70, 0x4C, 0x30, 0x52, 0xAD, 0x60, 0x03, 0x4D, 0x68, + 0x03, 0x10, 0x6C, 0x2C, 0x60, 0x03, 0x70, 0x07, 0x2C, 0x68, 0x03, 0x70, + 0x0A, 0x50, 0x42, 0x2C, 0x68, 0x03, 0x70, 0x4E, 0x20, 0x38, 0x53, 0x20, + 0xA3, 0x51, 0xA5, 0xC0, 0xF0, 0x09, 0xA9, 0x60, 0xA0, 0x03, 0xA2, 0x70, + 0x4C, 0x30, 0x52, 0xA5, 0xC1, 0xC9, 0x12, 0xB0, 0xF1, 0xA9, 0x00, 0x85, + 0xC2, 0x20, 0xF0, 0x51, 0x20, 0x5E, 0x52, 0xB0, 0x0D, 0x20, 0x38, 0x53, + 0xA9, 0x00, 0x85, 0xC2, 0x20, 0xF0, 0x51, 0x20, 0x5E, 0x52, 0xAD, 0x60, + 0x03, 0x49, 0x40, 0x85, 0xC0, 0x20, 0xAC, 0x52, 0x60, 0x20, 0xC2, 0x51, + 0xB0, 0x03, 0x20, 0x38, 0x53, 0xA5, 0xC0, 0xC9, 0x00, 0xD0, 0xBF, 0x4C, + 0xFF, 0x50, 0x20, 0xC2, 0x51, 0x90, 0xF2, 0x20, 0x38, 0x53, 0xA5, 0xC0, + 0x4C, 0x31, 0x51, 0x2C, 0x60, 0x03, 0x70, 0x07, 0x2C, 0x68, 0x03, 0x70, + 0x0A, 0x50, 0x34, 0x2C, 0x68, 0x03, 0x70, 0x40, 0x20, 0x38, 0x53, 0x20, + 0xA3, 0x51, 0xA5, 0xC0, 0xF0, 0x09, 0xA9, 0x60, 0xA0, 0x03, 0xA2, 0x70, + 0x4C, 0x30, 0x52, 0xA5, 0xC1, 0xC9, 0x12, 0xB0, 0xF1, 0xA9, 0x00, 0x85, + 0xC2, 0x20, 0xF0, 0x51, 0x20, 0x44, 0x52, 0x20, 0x8C, 0x52, 0xAD, 0x60, + 0x03, 0x85, 0xC0, 0x20, 0xAC, 0x52, 0x60, 0x20, 0xC2, 0x51, 0xB0, 0x03, + 0x20, 0x38, 0x53, 0xA5, 0xC0, 0xC9, 0x00, 0xD0, 0xCD, 0x4C, 0x6B, 0x51, + 0x20, 0xC2, 0x51, 0x90, 0xF2, 0x20, 0x38, 0x53, 0x4C, 0x8F, 0x51, 0xAD, + 0x60, 0x03, 0x29, 0x0F, 0x85, 0xC0, 0xAD, 0x68, 0x03, 0x29, 0x0F, 0x85, + 0xC1, 0x18, 0xAD, 0x61, 0x03, 0x6D, 0x69, 0x03, 0xAA, 0xA5, 0xC0, 0x65, + 0xC1, 0x85, 0xC0, 0x86, 0xC1, 0x60, 0xAD, 0x60, 0x03, 0x29, 0x0F, 0x85, + 0xC0, 0xAD, 0x68, 0x03, 0x29, 0x0F, 0x85, 0xC1, 0x38, 0xAD, 0x61, 0x03, + 0xED, 0x69, 0x03, 0xAA, 0xA5, 0xC0, 0xE5, 0xC1, 0xB0, 0x0D, 0x38, 0xAD, + 0x69, 0x03, 0xED, 0x61, 0x03, 0xAA, 0xA5, 0xC1, 0xE5, 0xC0, 0x18, 0x85, + 0xC0, 0x86, 0xC1, 0x60, 0xA0, 0x1F, 0xA9, 0x00, 0x99, 0x00, 0x03, 0x88, + 0x10, 0xFA, 0x18, 0xA5, 0xC1, 0x69, 0x11, 0xA8, 0xB9, 0x94, 0x6A, 0x4A, + 0xAA, 0xA0, 0x05, 0xB9, 0x62, 0x03, 0x99, 0x02, 0x03, 0xB9, 0x6A, 0x03, + 0x9D, 0x12, 0x03, 0xCA, 0x88, 0x10, 0xF0, 0xA5, 0xC1, 0x4A, 0x90, 0x13, + 0xA2, 0x0D, 0xA9, 0x00, 0xBC, 0x12, 0x03, 0x19, 0x54, 0x69, 0x9D, 0x12, + 0x03, 0xB9, 0xF4, 0x69, 0xCA, 0x10, 0xF1, 0x60, 0x84, 0xF3, 0x85, 0xF2, + 0x86, 0xF4, 0xA9, 0x03, 0x85, 0xF5, 0xA0, 0x07, 0xB1, 0xF2, 0x91, 0xF4, + 0x88, 0x10, 0xF9, 0x60, 0xA2, 0x06, 0x18, 0xBD, 0x01, 0x03, 0x7D, 0x11, + 0x03, 0x9D, 0x11, 0x03, 0xCA, 0x10, 0xF4, 0xAD, 0x11, 0x03, 0xF0, 0x05, + 0x20, 0x5F, 0x53, 0xE6, 0xC2, 0x60, 0xA2, 0x08, 0x38, 0xBD, 0x01, 0x03, + 0xFD, 0x11, 0x03, 0x9D, 0x11, 0x03, 0xCA, 0x10, 0xF4, 0x90, 0x1C, 0xA9, + 0x0C, 0x85, 0xC0, 0xAD, 0x12, 0x03, 0x29, 0xF0, 0xD0, 0x09, 0x20, 0x4B, + 0x53, 0xE6, 0xC2, 0xC6, 0xC0, 0xD0, 0xF0, 0xA4, 0xC2, 0xB9, 0x34, 0x6B, + 0x85, 0xC2, 0x38, 0x60, 0xA2, 0x07, 0xA9, 0x50, 0x18, 0x7D, 0x11, 0x03, + 0x9D, 0x11, 0x03, 0xA9, 0x00, 0xCA, 0x10, 0xF5, 0xAD, 0x11, 0x03, 0xF0, + 0x0A, 0x20, 0x5F, 0x53, 0x18, 0xA5, 0xC2, 0x69, 0x01, 0x85, 0xC2, 0x60, + 0xA2, 0x05, 0x18, 0xBD, 0x12, 0x03, 0x9D, 0x72, 0x03, 0xCA, 0x10, 0xF7, + 0xAD, 0x72, 0x03, 0xD0, 0x07, 0x8D, 0x71, 0x03, 0x8D, 0x70, 0x03, 0x60, + 0xAD, 0x61, 0x03, 0x8D, 0x71, 0x03, 0xAD, 0x60, 0x03, 0x29, 0x0F, 0x8D, + 0x70, 0x03, 0x24, 0xC0, 0x50, 0x2F, 0x38, 0xAD, 0x71, 0x03, 0xE5, 0xC2, + 0xAA, 0xAD, 0x70, 0x03, 0xE9, 0x00, 0xB0, 0x2D, 0x38, 0xA5, 0xC2, 0xED, + 0x71, 0x03, 0x8D, 0x71, 0x03, 0xA9, 0x00, 0xED, 0x70, 0x03, 0x8D, 0x70, + 0x03, 0xAD, 0x60, 0x03, 0x29, 0xC0, 0x49, 0x40, 0x0D, 0x70, 0x03, 0x29, + 0xCF, 0x8D, 0x70, 0x03, 0x60, 0x18, 0xAD, 0x61, 0x03, 0x65, 0xC2, 0xAA, + 0xAD, 0x60, 0x03, 0x69, 0x00, 0x8D, 0x70, 0x03, 0x8E, 0x71, 0x03, 0x0D, + 0x71, 0x03, 0xD0, 0x0E, 0xAD, 0x60, 0x03, 0x29, 0x80, 0x0D, 0x70, 0x03, + 0x29, 0xCF, 0x8D, 0x70, 0x03, 0x60, 0xAD, 0x60, 0x03, 0x29, 0xC0, 0x0D, + 0x70, 0x03, 0x29, 0xCF, 0x8D, 0x70, 0x03, 0x60, 0xA0, 0x07, 0xBE, 0x60, + 0x03, 0xB9, 0x68, 0x03, 0x99, 0x60, 0x03, 0x8A, 0x99, 0x68, 0x03, 0x88, + 0x10, 0xF0, 0x60, 0xA2, 0x07, 0xA9, 0x00, 0xBC, 0x11, 0x03, 0x19, 0x54, + 0x69, 0x9D, 0x11, 0x03, 0xB9, 0xF4, 0x69, 0xCA, 0x10, 0xF1, 0x60, 0xA2, + 0x07, 0xA9, 0x00, 0xBC, 0x11, 0x03, 0x19, 0x54, 0x69, 0x9D, 0x12, 0x03, + 0xB9, 0xF4, 0x69, 0xCA, 0x10, 0xF1, 0xA9, 0x00, 0x8D, 0x11, 0x03, 0x60, + 0xF8, 0xA2, 0x2F, 0xA9, 0x00, 0x9D, 0x00, 0x03, 0xCA, 0x10, 0xFA, 0x20, + 0xE2, 0x53, 0xAD, 0x60, 0x03, 0x4D, 0x68, 0x03, 0x29, 0x40, 0xF0, 0x0F, + 0x20, 0xC2, 0x51, 0xB0, 0x05, 0xAD, 0x68, 0x03, 0x90, 0x0B, 0xAD, 0x60, + 0x03, 0xB0, 0x06, 0x20, 0xA3, 0x51, 0xAD, 0x60, 0x03, 0x29, 0x40, 0x8D, + 0x70, 0x03, 0xA5, 0xC2, 0xF0, 0x11, 0xAD, 0x70, 0x03, 0xD0, 0x06, 0x20, + 0x19, 0x55, 0x4C, 0xBF, 0x53, 0x20, 0x27, 0x55, 0x4C, 0xBF, 0x53, 0xA5, + 0xC1, 0x8D, 0x71, 0x03, 0x05, 0xC0, 0xD0, 0x03, 0x8D, 0x70, 0x03, 0xA5, + 0xC0, 0x0D, 0x70, 0x03, 0x8D, 0x70, 0x03, 0xAD, 0x60, 0x03, 0x4D, 0x68, + 0x03, 0x29, 0x80, 0x0D, 0x70, 0x03, 0x8D, 0x70, 0x03, 0x60, 0xAD, 0x62, + 0x03, 0xF0, 0x18, 0xAD, 0x6A, 0x03, 0xF0, 0x13, 0x20, 0x4C, 0x54, 0x20, + 0x0A, 0x54, 0x20, 0x5E, 0x54, 0x20, 0xD5, 0x54, 0x20, 0x9B, 0x54, 0x20, + 0xE9, 0x54, 0x60, 0xA2, 0x07, 0xA9, 0x00, 0x9D, 0x70, 0x03, 0xCA, 0x10, + 0xF8, 0x60, 0xA9, 0x00, 0x85, 0xF0, 0xA9, 0x01, 0x85, 0xF1, 0x85, 0xF3, + 0x85, 0xF5, 0xA9, 0x10, 0x85, 0xF2, 0xA9, 0x20, 0x85, 0xF4, 0xA2, 0x07, + 0xBD, 0x09, 0x03, 0x9D, 0x10, 0x01, 0xCA, 0x10, 0xF7, 0xA2, 0x08, 0xA0, + 0x07, 0x18, 0xB1, 0xF2, 0x79, 0x10, 0x01, 0x91, 0xF4, 0x88, 0x10, 0xF6, + 0xD8, 0x18, 0xA5, 0xF2, 0x69, 0x10, 0x85, 0xF2, 0x18, 0xA5, 0xF4, 0x69, + 0x10, 0x85, 0xF4, 0xF8, 0xCA, 0xD0, 0xE0, 0x60, 0xA2, 0x05, 0xBD, 0x62, + 0x03, 0x9D, 0x0A, 0x03, 0xBD, 0x6A, 0x03, 0x9D, 0x1A, 0x03, 0xCA, 0x10, + 0xF1, 0x60, 0xA9, 0x03, 0x85, 0xF3, 0x85, 0xF5, 0xA9, 0x18, 0x85, 0xF2, + 0xA9, 0x28, 0x85, 0xF4, 0xA0, 0x07, 0xB1, 0xF2, 0x29, 0xF0, 0xF0, 0x09, + 0x85, 0xF0, 0xB1, 0xF0, 0x91, 0xF4, 0x88, 0x10, 0xF9, 0xA2, 0x06, 0xC6, + 0xF2, 0xC6, 0xF4, 0xA0, 0x07, 0xB1, 0xF2, 0x29, 0xF0, 0xF0, 0x0C, 0x85, + 0xF0, 0x18, 0xB1, 0xF0, 0x71, 0xF4, 0x91, 0xF4, 0x88, 0x10, 0xF7, 0xCA, + 0x10, 0xE5, 0x60, 0xA9, 0x19, 0x85, 0xF2, 0xA9, 0x29, 0x85, 0xF4, 0xA2, + 0x06, 0xC6, 0xF2, 0xC6, 0xF4, 0xA0, 0x07, 0xB1, 0xF2, 0x29, 0x0F, 0xF0, + 0x20, 0x0A, 0x0A, 0x0A, 0x0A, 0x85, 0xF0, 0x18, 0xB1, 0xF0, 0x71, 0xF4, + 0x91, 0xF4, 0x88, 0x10, 0xF7, 0x90, 0x0E, 0xA4, 0xF4, 0x88, 0xB9, 0x00, + 0x03, 0x69, 0x00, 0x99, 0x00, 0x03, 0x88, 0xB0, 0xF5, 0xCA, 0x10, 0xD1, + 0x60, 0xA2, 0x0F, 0xA9, 0x00, 0xBC, 0x20, 0x03, 0x19, 0x54, 0x69, 0x9D, + 0x20, 0x03, 0xB9, 0xF4, 0x69, 0xCA, 0x10, 0xF1, 0x60, 0xA9, 0x01, 0x85, + 0xC2, 0xAD, 0x23, 0x03, 0x29, 0xF0, 0xD0, 0x05, 0x20, 0x05, 0x55, 0xC6, + 0xC2, 0xA2, 0x05, 0xBD, 0x23, 0x03, 0x9D, 0x72, 0x03, 0xCA, 0x10, 0xF7, + 0x60, 0xA2, 0x06, 0xA9, 0x00, 0xBC, 0x22, 0x03, 0x19, 0x54, 0x69, 0x9D, + 0x22, 0x03, 0xB9, 0xF4, 0x69, 0xCA, 0x10, 0xF1, 0x60, 0x18, 0xA5, 0xC1, + 0x69, 0x01, 0x85, 0xC1, 0xA5, 0xC0, 0x69, 0x00, 0x85, 0xC0, 0x60, 0x38, + 0xA5, 0xC1, 0xE9, 0x01, 0x85, 0xC1, 0xA5, 0xC0, 0xE9, 0x00, 0x85, 0xC0, + 0x60, 0xF8, 0xAD, 0x6A, 0x03, 0xD0, 0x03, 0x4C, 0x47, 0x69, 0xAD, 0x62, + 0x03, 0xD0, 0x0B, 0xA9, 0x00, 0xA0, 0x07, 0x99, 0x70, 0x03, 0x88, 0x10, + 0xFA, 0x60, 0xA9, 0x00, 0xA2, 0x2F, 0x9D, 0x00, 0x03, 0xCA, 0x10, 0xFA, + 0xA2, 0x05, 0xBD, 0x6A, 0x03, 0x9D, 0x0A, 0x03, 0xBD, 0x62, 0x03, 0x9D, + 0x12, 0x03, 0xCA, 0x10, 0xF1, 0x20, 0x0A, 0x54, 0x20, 0xD2, 0x56, 0xA9, + 0x0F, 0x85, 0xC4, 0x20, 0x13, 0x56, 0xC6, 0xC4, 0xD0, 0xF9, 0xA9, 0x01, + 0x85, 0xC2, 0xAD, 0x18, 0x03, 0xF0, 0x12, 0x20, 0xD2, 0x56, 0xC6, 0xC2, + 0xA2, 0x05, 0xBD, 0x18, 0x03, 0x9D, 0x72, 0x03, 0xCA, 0x10, 0xF7, 0x30, + 0x0B, 0xA2, 0x05, 0xBD, 0x19, 0x03, 0x9D, 0x72, 0x03, 0xCA, 0x10, 0xF7, + 0xAD, 0x60, 0x03, 0x4D, 0x68, 0x03, 0x29, 0x40, 0xF0, 0x09, 0x20, 0xA3, + 0x51, 0xAD, 0x60, 0x03, 0x4C, 0xBD, 0x55, 0x20, 0xC2, 0x51, 0xAD, 0x68, + 0x03, 0xB0, 0x02, 0x49, 0x40, 0x29, 0x40, 0x8D, 0x70, 0x03, 0x2C, 0x70, + 0x03, 0x70, 0x19, 0xA5, 0xC2, 0xF0, 0x22, 0xA5, 0xC1, 0x05, 0xC0, 0xD0, + 0x19, 0xA9, 0x01, 0x85, 0xC1, 0xA9, 0x40, 0x0D, 0x70, 0x03, 0x8D, 0x70, + 0x03, 0x4C, 0xED, 0x55, 0xA5, 0xC2, 0xF0, 0x09, 0x20, 0x19, 0x55, 0x4C, + 0xED, 0x55, 0x20, 0x27, 0x55, 0xA5, 0xC1, 0x8D, 0x71, 0x03, 0xA5, 0xC0, + 0x0D, 0x70, 0x03, 0x8D, 0x70, 0x03, 0x29, 0x0F, 0x0D, 0x71, 0x03, 0xD0, + 0x03, 0x8D, 0x70, 0x03, 0xAD, 0x60, 0x03, 0x4D, 0x68, 0x03, 0x29, 0x80, + 0x0D, 0x70, 0x03, 0x8D, 0x70, 0x03, 0x60, 0xA9, 0x09, 0x85, 0xC3, 0xAD, + 0x10, 0x03, 0xAE, 0x11, 0x03, 0xCD, 0x90, 0x01, 0x90, 0x07, 0xD0, 0x7D, + 0xEC, 0x91, 0x01, 0xB0, 0x78, 0xC6, 0xC3, 0xCD, 0x80, 0x01, 0x90, 0x07, + 0xD0, 0x6F, 0xEC, 0x81, 0x01, 0xB0, 0x6A, 0xC6, 0xC3, 0xCD, 0x70, 0x01, + 0x90, 0x07, 0xD0, 0x61, 0xEC, 0x71, 0x01, 0xB0, 0x5C, 0xC6, 0xC3, 0xCD, + 0x60, 0x01, 0x90, 0x07, 0xD0, 0x53, 0xEC, 0x61, 0x01, 0xB0, 0x4E, 0xC6, + 0xC3, 0xCD, 0x50, 0x01, 0x90, 0x07, 0xD0, 0x45, 0xEC, 0x51, 0x01, 0xB0, + 0x40, 0xC6, 0xC3, 0xCD, 0x40, 0x01, 0x90, 0x07, 0xD0, 0x37, 0xEC, 0x41, + 0x01, 0xB0, 0x32, 0xC6, 0xC3, 0xCD, 0x30, 0x01, 0x90, 0x07, 0xD0, 0x29, + 0xEC, 0x31, 0x01, 0xB0, 0x24, 0xC6, 0xC3, 0xCD, 0x20, 0x01, 0x90, 0x07, + 0xD0, 0x1B, 0xEC, 0x21, 0x01, 0xB0, 0x16, 0xC6, 0xC3, 0xCD, 0x10, 0x01, + 0x90, 0x07, 0xD0, 0x0D, 0xEC, 0x11, 0x01, 0xB0, 0x08, 0xC6, 0xC3, 0x2D, + 0x1F, 0x03, 0x4C, 0xD2, 0x56, 0xAD, 0x1F, 0x03, 0x29, 0xF0, 0x05, 0xC3, + 0x8D, 0x1F, 0x03, 0x0A, 0x0A, 0x0A, 0x0A, 0x85, 0xF2, 0xA0, 0x07, 0x38, + 0xB9, 0x10, 0x03, 0xF1, 0xF2, 0x99, 0x10, 0x03, 0x88, 0x10, 0xF5, 0xB0, + 0x11, 0xCE, 0x1F, 0x03, 0xA0, 0x07, 0xB9, 0x10, 0x03, 0x79, 0x10, 0x01, + 0x99, 0x10, 0x03, 0x88, 0x10, 0xF4, 0xA2, 0x0F, 0xA9, 0x00, 0xBC, 0x10, + 0x03, 0x19, 0x54, 0x69, 0x9D, 0x10, 0x03, 0xB9, 0xF4, 0x69, 0xCA, 0x10, + 0xF1, 0x60, 0xF8, 0xAD, 0x62, 0x03, 0xD0, 0x0B, 0xA2, 0x07, 0xA9, 0x00, + 0x9D, 0x70, 0x03, 0xCA, 0x10, 0xFA, 0x60, 0x2C, 0x60, 0x03, 0x10, 0x03, + 0x4C, 0x23, 0x69, 0xA2, 0x0F, 0xA9, 0x00, 0x9D, 0x00, 0x03, 0xCA, 0x10, + 0xFA, 0xA2, 0x07, 0xBD, 0x62, 0x03, 0x9D, 0x02, 0x03, 0xCA, 0x10, 0xF7, + 0xAD, 0x61, 0x03, 0x29, 0x01, 0xD0, 0x13, 0xA2, 0x07, 0xA9, 0x00, 0xBC, + 0x00, 0x03, 0x19, 0x54, 0x69, 0x9D, 0x01, 0x03, 0xB9, 0xF4, 0x69, 0xCA, + 0x10, 0xF1, 0xA2, 0x07, 0x18, 0xBD, 0x01, 0x03, 0x7D, 0x01, 0x03, 0x9D, + 0x11, 0x03, 0xCA, 0x10, 0xF4, 0xA2, 0x07, 0x18, 0xBD, 0x11, 0x03, 0x7D, + 0x11, 0x03, 0x9D, 0x11, 0x03, 0xCA, 0x10, 0xF4, 0xA2, 0x07, 0x18, 0xBD, + 0x01, 0x03, 0x7D, 0x11, 0x03, 0x9D, 0x01, 0x03, 0xCA, 0x10, 0xF4, 0xA9, + 0x01, 0x85, 0xF2, 0xA9, 0x00, 0x8D, 0x10, 0x03, 0xA9, 0x06, 0x85, 0xC3, + 0xA6, 0xF2, 0xA9, 0x05, 0x9D, 0x10, 0x03, 0x20, 0xE4, 0x57, 0xC6, 0xC3, + 0x30, 0x06, 0x20, 0x31, 0x58, 0x4C, 0x68, 0x57, 0xA2, 0x07, 0xA9, 0x00, + 0xBC, 0x11, 0x03, 0x19, 0x54, 0x69, 0x9D, 0x11, 0x03, 0xB9, 0xF4, 0x69, + 0xCA, 0x10, 0xF1, 0xA2, 0x05, 0xBD, 0x11, 0x03, 0x9D, 0x72, 0x03, 0xCA, + 0x10, 0xF7, 0xAD, 0x61, 0x03, 0x8D, 0x71, 0x03, 0xAD, 0x60, 0x03, 0x29, + 0x0F, 0x8D, 0x70, 0x03, 0x4E, 0x70, 0x03, 0x6E, 0x71, 0x03, 0xAC, 0x70, + 0x03, 0xB9, 0x98, 0x6B, 0x8D, 0x70, 0x03, 0xAC, 0x71, 0x03, 0xB9, 0x98, + 0x6B, 0x8D, 0x71, 0x03, 0x2C, 0x60, 0x03, 0x50, 0x1E, 0xAD, 0x61, 0x03, + 0x29, 0x01, 0xF0, 0x0F, 0x18, 0x6D, 0x71, 0x03, 0x8D, 0x71, 0x03, 0xAD, + 0x70, 0x03, 0x69, 0x00, 0x8D, 0x70, 0x03, 0xA9, 0x40, 0x0D, 0x70, 0x03, + 0x8D, 0x70, 0x03, 0x60, 0xA6, 0xF2, 0x38, 0xBD, 0x00, 0x03, 0xFD, 0x10, + 0x03, 0x9D, 0x00, 0x03, 0xCA, 0x10, 0xF4, 0x90, 0x0D, 0xA6, 0xF2, 0x18, + 0xBD, 0x10, 0x03, 0x69, 0x10, 0x9D, 0x10, 0x03, 0x90, 0xE2, 0xA6, 0xF2, + 0xBD, 0x10, 0x03, 0x29, 0xF0, 0x09, 0x09, 0x9D, 0x10, 0x03, 0xA9, 0x50, + 0x9D, 0x11, 0x03, 0x20, 0x31, 0x58, 0xE6, 0xF2, 0xA6, 0xF2, 0x18, 0xBD, + 0x00, 0x03, 0x7D, 0x10, 0x03, 0x9D, 0x00, 0x03, 0xCA, 0x10, 0xF4, 0xB0, + 0x07, 0xA6, 0xF2, 0xDE, 0x0F, 0x03, 0x90, 0xE8, 0x60, 0xA2, 0x0F, 0xA9, + 0x00, 0xBC, 0x00, 0x03, 0x19, 0x54, 0x69, 0x9D, 0x00, 0x03, 0xB9, 0xF4, + 0x69, 0xCA, 0x10, 0xF1, 0x60, 0xF8, 0xC6, 0xC6, 0xA2, 0x07, 0xBD, 0x88, + 0x03, 0x9D, 0x60, 0x03, 0x9D, 0x68, 0x03, 0xCA, 0x10, 0xF4, 0x20, 0x78, + 0x53, 0xA2, 0x07, 0xBD, 0x70, 0x03, 0x9D, 0x88, 0x03, 0xCA, 0x10, 0xF7, + 0xA0, 0x07, 0xB1, 0xF8, 0x99, 0x70, 0x03, 0x88, 0x10, 0xF8, 0x20, 0x9D, + 0x58, 0x20, 0xA9, 0x58, 0x20, 0x78, 0x53, 0xD8, 0x18, 0xA5, 0xF8, 0x69, + 0x08, 0x85, 0xF8, 0x90, 0x02, 0xE6, 0xF9, 0xF8, 0x20, 0x92, 0x58, 0x20, + 0xA9, 0x58, 0x20, 0xB6, 0x50, 0xC6, 0xC6, 0xD0, 0xDD, 0x60, 0xA0, 0x07, + 0xB1, 0xF8, 0x99, 0x60, 0x03, 0x88, 0x10, 0xF8, 0x60, 0xA2, 0x07, 0xBD, + 0x88, 0x03, 0x9D, 0x60, 0x03, 0xCA, 0x10, 0xF7, 0x60, 0xA2, 0x07, 0xBD, + 0x70, 0x03, 0x9D, 0x68, 0x03, 0xCA, 0x10, 0xF7, 0x60, 0x20, 0x4C, 0x59, + 0xA9, 0x70, 0xA0, 0x03, 0xA2, 0x78, 0x20, 0x30, 0x52, 0xA9, 0x70, 0xA0, + 0x03, 0xA2, 0x60, 0x20, 0x30, 0x52, 0xA9, 0x70, 0xA0, 0x03, 0xA2, 0x68, + 0x20, 0x30, 0x52, 0x20, 0x78, 0x53, 0xA9, 0x70, 0xA0, 0x03, 0xA2, 0x68, + 0x20, 0x30, 0x52, 0xA9, 0xA0, 0xA0, 0x6D, 0xA2, 0x60, 0x20, 0x30, 0x52, + 0x20, 0xB6, 0x50, 0xA9, 0x70, 0xA0, 0x03, 0xA2, 0x60, 0x20, 0x30, 0x52, + 0x20, 0xE6, 0x56, 0xA5, 0xC9, 0xC9, 0x01, 0xF0, 0x0C, 0xC9, 0x04, 0xF0, + 0x08, 0xAD, 0x70, 0x03, 0x09, 0x80, 0x8D, 0x70, 0x03, 0x60, 0x20, 0xB5, + 0x58, 0xA9, 0x70, 0xA0, 0x03, 0xA2, 0x68, 0x20, 0x30, 0x52, 0xA9, 0x78, + 0xA0, 0x03, 0xA2, 0x60, 0x20, 0x30, 0x52, 0x20, 0x35, 0x55, 0xAD, 0x70, + 0x03, 0x29, 0x7F, 0xA6, 0xC9, 0xE0, 0x03, 0x90, 0x02, 0x09, 0x80, 0x8D, + 0x70, 0x03, 0x60, 0x20, 0xB5, 0x58, 0xA9, 0x70, 0xA0, 0x03, 0xA2, 0x68, + 0x20, 0x30, 0x52, 0xA9, 0xA0, 0xA0, 0x6D, 0xA2, 0x60, 0x20, 0x30, 0x52, + 0x20, 0x35, 0x55, 0x60, 0xA9, 0x00, 0x85, 0xCA, 0xF8, 0xA9, 0x00, 0x85, + 0xC8, 0x20, 0x57, 0x67, 0xA9, 0x70, 0xA0, 0x03, 0xA2, 0x60, 0x20, 0x30, + 0x52, 0xAD, 0x72, 0x03, 0xD0, 0x01, 0x60, 0x20, 0xA9, 0x59, 0xAD, 0x70, + 0x03, 0x05, 0xC8, 0x8D, 0x70, 0x03, 0xA5, 0xCA, 0xF0, 0x15, 0xA9, 0xA0, + 0xA0, 0x6D, 0xA2, 0x60, 0x20, 0x30, 0x52, 0xA9, 0x70, 0xA0, 0x03, 0xA2, + 0x68, 0x20, 0x30, 0x52, 0x20, 0x35, 0x55, 0x60, 0xA9, 0x01, 0x4C, 0x4E, + 0x59, 0x20, 0x0A, 0x59, 0xA9, 0x70, 0xA0, 0x03, 0xA2, 0x68, 0x20, 0x30, + 0x52, 0xA9, 0xA0, 0xA0, 0x6D, 0xA2, 0x60, 0x20, 0x30, 0x52, 0x4C, 0x35, + 0x55, 0xAD, 0x62, 0x03, 0xD0, 0x0B, 0xA9, 0x00, 0xA2, 0x07, 0x9D, 0x70, + 0x03, 0xCA, 0x10, 0xFA, 0x60, 0x2C, 0x60, 0x03, 0x50, 0x1A, 0xAD, 0x60, + 0x03, 0x29, 0x0F, 0xD0, 0x07, 0xAD, 0x61, 0x03, 0xC9, 0x08, 0x90, 0x0C, + 0xA2, 0x07, 0xBD, 0x60, 0x03, 0x9D, 0x70, 0x03, 0xCA, 0x10, 0xF7, 0x60, + 0xA2, 0x2F, 0xA9, 0x00, 0x9D, 0x00, 0x03, 0xCA, 0x10, 0xFA, 0xA9, 0x48, + 0x85, 0xF2, 0xA9, 0x6E, 0x85, 0xF3, 0xAD, 0x61, 0x03, 0x4A, 0xD8, 0x69, + 0x05, 0xF8, 0xAA, 0xA0, 0x05, 0xB9, 0x62, 0x03, 0x9D, 0x02, 0x03, 0xCA, + 0x88, 0x10, 0xF6, 0xAD, 0x61, 0x03, 0x29, 0x01, 0xF0, 0x13, 0xA2, 0x0C, + 0xA9, 0x00, 0xBC, 0x02, 0x03, 0x19, 0x54, 0x69, 0x9D, 0x02, 0x03, 0xB9, + 0xF4, 0x69, 0xCA, 0x10, 0xF1, 0x20, 0x24, 0x5B, 0x20, 0xC2, 0x5A, 0xA9, + 0x00, 0x8D, 0x60, 0x03, 0x8D, 0x61, 0x03, 0xA9, 0x08, 0x85, 0xC7, 0xAD, + 0x02, 0x03, 0x29, 0xF0, 0xD0, 0x2A, 0xA9, 0x40, 0x8D, 0x60, 0x03, 0xEE, + 0x61, 0x03, 0xA9, 0x00, 0xA2, 0x0C, 0xBC, 0x02, 0x03, 0x19, 0x54, 0x69, + 0x9D, 0x02, 0x03, 0xB9, 0xF4, 0x69, 0xCA, 0x10, 0xF1, 0xC6, 0xC7, 0xD0, + 0xDA, 0xA9, 0x00, 0xA2, 0x07, 0x9D, 0x70, 0x03, 0xCA, 0x10, 0xFA, 0x60, + 0xA2, 0x05, 0xBD, 0x02, 0x03, 0x9D, 0x62, 0x03, 0xCA, 0x10, 0xF7, 0xAD, + 0x11, 0x03, 0xF0, 0x0C, 0xA2, 0x07, 0xBD, 0x60, 0x03, 0x9D, 0x70, 0x03, + 0xCA, 0x10, 0xF7, 0x60, 0xA9, 0x08, 0x85, 0xC7, 0xA9, 0x40, 0x8D, 0x68, + 0x03, 0xA9, 0x00, 0x8D, 0x69, 0x03, 0xAD, 0x12, 0x03, 0x29, 0xF0, 0xD0, + 0x26, 0xEE, 0x69, 0x03, 0xA9, 0x00, 0xA2, 0x0A, 0xBC, 0x12, 0x03, 0x19, + 0x54, 0x69, 0x9D, 0x12, 0x03, 0xB9, 0xF4, 0x69, 0xCA, 0x10, 0xF1, 0xC6, + 0xC7, 0xD0, 0xDF, 0xA2, 0x07, 0xBD, 0x80, 0x6D, 0x9D, 0x70, 0x03, 0xCA, + 0x10, 0xF7, 0x60, 0xA2, 0x05, 0xBD, 0x12, 0x03, 0x9D, 0x6A, 0x03, 0xCA, + 0x10, 0xF7, 0x20, 0x35, 0x55, 0x60, 0xA2, 0x10, 0x8E, 0x12, 0x03, 0xA2, + 0x0A, 0xBD, 0x02, 0x03, 0x9D, 0x22, 0x03, 0xBD, 0x12, 0x03, 0x9D, 0x32, + 0x03, 0xCA, 0x10, 0xF1, 0xA9, 0x00, 0x85, 0xC5, 0xA6, 0xC5, 0xDE, 0x40, + 0x03, 0x30, 0x38, 0xF8, 0xA2, 0x0A, 0xBD, 0x02, 0x03, 0x9D, 0x22, 0x03, + 0xBD, 0x12, 0x03, 0x9D, 0x32, 0x03, 0xCA, 0x10, 0xF1, 0xA5, 0xC5, 0x20, + 0x87, 0x66, 0xA2, 0x0A, 0x38, 0xBD, 0x12, 0x03, 0xFD, 0x22, 0x03, 0x9D, + 0x12, 0x03, 0xCA, 0x10, 0xF4, 0xA2, 0x0A, 0x18, 0xBD, 0x02, 0x03, 0x7D, + 0x32, 0x03, 0x9D, 0x02, 0x03, 0xCA, 0x10, 0xF4, 0x4C, 0xDC, 0x5A, 0xE6, + 0xC5, 0xA9, 0x05, 0xC5, 0xC5, 0xB0, 0xB9, 0x60, 0xA9, 0x05, 0x85, 0xC5, + 0xA2, 0x00, 0x8E, 0x40, 0x03, 0xA0, 0x07, 0x38, 0xB9, 0x02, 0x03, 0xF1, + 0xF2, 0x99, 0x02, 0x03, 0x88, 0x10, 0xF5, 0x90, 0x06, 0xFE, 0x40, 0x03, + 0x4C, 0x2D, 0x5B, 0xA0, 0x07, 0x18, 0xB9, 0x02, 0x03, 0x71, 0xF2, 0x99, + 0x02, 0x03, 0x88, 0x10, 0xF5, 0xE8, 0xA9, 0x00, 0x9D, 0x40, 0x03, 0xD8, + 0x18, 0xA5, 0xF2, 0x69, 0x08, 0x85, 0xF2, 0x90, 0x02, 0xE6, 0xF3, 0xF8, + 0xC6, 0xC5, 0x10, 0xC5, 0x60, 0xA2, 0x09, 0xA9, 0x00, 0x9D, 0x30, 0x03, + 0xCA, 0x10, 0xFA, 0xA0, 0x07, 0xB1, 0xF4, 0x91, 0xF6, 0x88, 0x10, 0xF9, + 0x60, 0x20, 0x96, 0x5B, 0xA9, 0x70, 0xA0, 0x03, 0xA2, 0x68, 0x20, 0x30, + 0x52, 0xA9, 0x80, 0xA0, 0x6D, 0xA2, 0x60, 0x20, 0x30, 0x52, 0x20, 0xAE, + 0x50, 0x60, 0xAD, 0x62, 0x03, 0xD0, 0x03, 0x4C, 0x19, 0x69, 0xAD, 0x60, + 0x03, 0x29, 0x80, 0x85, 0xCC, 0xA9, 0x60, 0x29, 0x7F, 0x8D, 0x60, 0x03, + 0xA9, 0x60, 0x85, 0xF2, 0xA9, 0x03, 0x85, 0xF3, 0xA9, 0x90, 0x85, 0xF4, + 0xA9, 0x03, 0x85, 0xF5, 0x20, 0x04, 0x69, 0xA9, 0x60, 0xA0, 0x03, 0xA2, + 0x68, 0x20, 0x30, 0x52, 0x20, 0x78, 0x53, 0xA9, 0xA0, 0xA0, 0x6D, 0xA2, + 0x60, 0x20, 0x30, 0x52, 0xA9, 0x70, 0xA0, 0x03, 0xA2, 0x68, 0x20, 0x30, + 0x52, 0x20, 0xAE, 0x50, 0xAD, 0x72, 0x03, 0xF0, 0x08, 0xAD, 0x70, 0x03, + 0x10, 0x0F, 0x4C, 0x2F, 0x69, 0xA9, 0x80, 0xA0, 0x6D, 0xA2, 0x70, 0x20, + 0x30, 0x52, 0x4C, 0x26, 0x5C, 0xA9, 0x70, 0xA0, 0x03, 0xA2, 0x60, 0x20, + 0x30, 0x52, 0x20, 0xE6, 0x56, 0xA9, 0x90, 0xA0, 0x03, 0xA2, 0x60, 0x20, + 0x30, 0x52, 0xA9, 0x70, 0xA0, 0x03, 0xA2, 0x68, 0x20, 0x30, 0x52, 0x20, + 0x35, 0x55, 0xA9, 0x70, 0xA0, 0x03, 0xA2, 0x60, 0x20, 0x30, 0x52, 0x20, + 0x2F, 0x5C, 0xAD, 0x70, 0x03, 0x05, 0xCC, 0x8D, 0x70, 0x03, 0x60, 0xF8, + 0xA9, 0x00, 0x85, 0xCA, 0x85, 0xC8, 0x2C, 0x60, 0x03, 0x10, 0x0C, 0xA9, + 0x80, 0x85, 0xC8, 0xA9, 0x4F, 0x2D, 0x60, 0x03, 0x8D, 0x60, 0x03, 0x70, + 0x0E, 0x20, 0x3E, 0x66, 0xA9, 0x70, 0xA0, 0x03, 0xA2, 0x60, 0x20, 0x30, + 0x52, 0xE6, 0xCA, 0xAD, 0x60, 0x03, 0x29, 0x0F, 0xD0, 0x07, 0xAD, 0x61, + 0x03, 0xC9, 0x07, 0x90, 0x24, 0xA9, 0x00, 0xC5, 0xCA, 0xF0, 0x0C, 0xA9, + 0x80, 0xA0, 0x6D, 0xA2, 0x68, 0x20, 0x30, 0x52, 0x20, 0x35, 0x55, 0xA5, + 0xC8, 0x0D, 0x60, 0x03, 0x8D, 0x60, 0x03, 0xA9, 0x60, 0xA0, 0x03, 0xA2, + 0x70, 0x20, 0x30, 0x52, 0x60, 0xA2, 0x4F, 0xA9, 0x00, 0x9D, 0x00, 0x03, + 0xCA, 0x10, 0xFA, 0xAD, 0x61, 0x03, 0x4A, 0xD8, 0x18, 0x69, 0x05, 0xF8, + 0xAA, 0xA0, 0x05, 0xB9, 0x62, 0x03, 0x9D, 0x02, 0x03, 0xCA, 0x88, 0x10, + 0xF6, 0xAD, 0x61, 0x03, 0x29, 0x01, 0xF0, 0x16, 0xA2, 0x07, 0xA9, 0x00, + 0xBC, 0x02, 0x03, 0x19, 0x54, 0x69, 0x9D, 0x03, 0x03, 0xB9, 0xF4, 0x69, + 0xCA, 0x10, 0xF1, 0x8D, 0x02, 0x03, 0xA2, 0x00, 0x86, 0xC5, 0xA9, 0x10, + 0x8D, 0x12, 0x03, 0xA9, 0x00, 0x85, 0xC5, 0xA2, 0x06, 0xBD, 0x02, 0x03, + 0x9D, 0x22, 0x03, 0xBD, 0x12, 0x03, 0x9D, 0x32, 0x03, 0xCA, 0x10, 0xF1, + 0xA5, 0xC5, 0xF0, 0x03, 0x20, 0x87, 0x66, 0xF8, 0x38, 0xA2, 0x06, 0xBD, + 0x02, 0x03, 0xFD, 0x32, 0x03, 0x9D, 0x02, 0x03, 0xCA, 0x10, 0xF4, 0x90, + 0x17, 0x18, 0xA2, 0x06, 0xBD, 0x12, 0x03, 0x7D, 0x22, 0x03, 0x9D, 0x12, + 0x03, 0xCA, 0x10, 0xF4, 0xA6, 0xC5, 0xFE, 0x40, 0x03, 0x4C, 0xD3, 0x5C, + 0xA2, 0x06, 0x18, 0xBD, 0x02, 0x03, 0x7D, 0x32, 0x03, 0x9D, 0x02, 0x03, + 0xCA, 0x10, 0xF4, 0xE6, 0xC5, 0xA9, 0x06, 0xC5, 0xC5, 0xB0, 0xA8, 0xA9, + 0x0A, 0x85, 0xC7, 0xA9, 0x00, 0x8D, 0x61, 0x03, 0xA9, 0x40, 0x8D, 0x60, + 0x03, 0xA9, 0x00, 0x8D, 0x61, 0x03, 0xAD, 0x02, 0x03, 0x29, 0xF0, 0xD0, + 0x1A, 0xEE, 0x61, 0x03, 0xA9, 0x00, 0xA2, 0x0A, 0xBC, 0x02, 0x03, 0x19, + 0x54, 0x69, 0x9D, 0x02, 0x03, 0xB9, 0xF4, 0x69, 0xCA, 0x10, 0xF1, 0xC6, + 0xC7, 0xD0, 0xDF, 0xA2, 0x05, 0xBD, 0x02, 0x03, 0x9D, 0x62, 0x03, 0xCA, + 0x10, 0xF7, 0xA2, 0x07, 0xBD, 0x10, 0x03, 0x9D, 0x68, 0x03, 0xCA, 0x10, + 0xF7, 0x20, 0x35, 0x55, 0xA2, 0x0F, 0xA9, 0x00, 0x9D, 0x00, 0x03, 0xCA, + 0x10, 0xFA, 0xAD, 0x70, 0x03, 0x29, 0x0F, 0xD0, 0x35, 0xAD, 0x71, 0x03, + 0xC9, 0x09, 0xB0, 0x2E, 0x4A, 0x18, 0xD8, 0x69, 0x05, 0xAA, 0xA0, 0x05, + 0xB9, 0x72, 0x03, 0x9D, 0x02, 0x03, 0xCA, 0x88, 0x10, 0xF6, 0xA9, 0x61, + 0x29, 0x01, 0xF0, 0x16, 0xA2, 0x07, 0xA9, 0x00, 0xBC, 0x02, 0x03, 0x19, + 0x54, 0x69, 0x9D, 0x03, 0x03, 0xB9, 0xF4, 0x69, 0xCA, 0x10, 0xF1, 0x8D, + 0x02, 0x03, 0xA9, 0x48, 0x85, 0xF2, 0xA9, 0x6E, 0x85, 0xF3, 0xA2, 0x00, + 0x86, 0xC5, 0xDE, 0x40, 0x03, 0x30, 0x11, 0xA0, 0x07, 0xF8, 0x18, 0xB9, + 0x02, 0x03, 0x71, 0xF2, 0x99, 0x02, 0x03, 0x88, 0x10, 0xF5, 0x30, 0xEA, + 0xE6, 0xC5, 0xD8, 0x18, 0xA5, 0xF2, 0x69, 0x08, 0x85, 0xF2, 0x90, 0x02, + 0xE6, 0xF3, 0xA6, 0xC5, 0xE0, 0x07, 0x90, 0xD6, 0xA9, 0x00, 0x8D, 0x70, + 0x03, 0x8D, 0x71, 0x03, 0xAD, 0x02, 0x03, 0x29, 0xF0, 0xD0, 0x1E, 0xA9, + 0x40, 0x8D, 0x70, 0x03, 0xA2, 0x0F, 0xA9, 0x00, 0xBC, 0x02, 0x03, 0x19, + 0x54, 0x69, 0x9D, 0x02, 0x03, 0xB9, 0xF4, 0x69, 0xCA, 0x10, 0xF1, 0xEE, + 0x71, 0x03, 0x4C, 0xFC, 0x5D, 0xA2, 0x05, 0xBD, 0x02, 0x03, 0x9D, 0x72, + 0x03, 0xCA, 0x10, 0xF7, 0xA5, 0xCA, 0xF0, 0x15, 0xA9, 0x80, 0xA0, 0x6D, + 0xA2, 0x60, 0x20, 0x30, 0x52, 0xA9, 0x70, 0xA0, 0x03, 0xA2, 0x68, 0x20, + 0x30, 0x52, 0x20, 0xAE, 0x50, 0xAD, 0x70, 0x03, 0x05, 0xC8, 0x8D, 0x70, + 0x03, 0x60, 0xA9, 0x60, 0xA0, 0x03, 0xA2, 0x68, 0x20, 0x30, 0x52, 0xA9, + 0xA0, 0xA0, 0x6D, 0xA2, 0x60, 0x20, 0x30, 0x52, 0x20, 0x35, 0x55, 0x4C, + 0x96, 0x5B, 0xA9, 0x60, 0xA0, 0x03, 0xA2, 0x68, 0x20, 0x30, 0x52, 0xA9, + 0xA0, 0xA0, 0x6D, 0xA2, 0x60, 0x20, 0x30, 0x52, 0x20, 0x35, 0x55, 0x4C, + 0x7D, 0x5B, 0xA9, 0x60, 0xA0, 0x03, 0xA2, 0x68, 0x20, 0x30, 0x52, 0xA9, + 0xA0, 0xA0, 0x6D, 0xA2, 0x60, 0x20, 0x30, 0x52, 0x20, 0x35, 0x55, 0x4C, + 0x2F, 0x5C, 0xAD, 0x60, 0x03, 0x10, 0x03, 0x4C, 0x23, 0x69, 0xAD, 0x62, + 0x03, 0xD0, 0x03, 0x4C, 0x2F, 0x69, 0xA2, 0x07, 0xBD, 0x60, 0x03, 0x9D, + 0x90, 0x03, 0xCA, 0x10, 0xF7, 0xAD, 0x60, 0x03, 0xD0, 0x3A, 0xAD, 0x61, + 0x03, 0xD0, 0x35, 0xAD, 0x62, 0x03, 0xC9, 0x10, 0xD0, 0x2E, 0xA9, 0xA0, + 0xA0, 0x6D, 0xA2, 0x68, 0x20, 0x30, 0x52, 0x20, 0xAE, 0x50, 0xAD, 0x72, + 0x03, 0xD0, 0x03, 0x4C, 0x19, 0x69, 0xAD, 0x70, 0x03, 0xC9, 0x40, 0xD0, + 0x0A, 0xAD, 0x71, 0x03, 0xC9, 0x03, 0x90, 0x03, 0x4C, 0xD8, 0x60, 0xA9, + 0x90, 0xA0, 0x03, 0xA2, 0x60, 0x20, 0x30, 0x52, 0x20, 0x0E, 0x69, 0xA2, + 0x05, 0xBD, 0x62, 0x03, 0x9D, 0x02, 0x03, 0xCA, 0x10, 0xF7, 0xA9, 0x00, + 0x85, 0xC3, 0xA9, 0x06, 0x85, 0xC5, 0x20, 0x58, 0x60, 0xA5, 0xC3, 0x20, + 0x9C, 0x60, 0x20, 0x64, 0x60, 0xB0, 0x08, 0xA6, 0xC3, 0xFE, 0x30, 0x03, + 0x4C, 0x06, 0x5F, 0x20, 0x76, 0x60, 0xE6, 0xC3, 0xC6, 0xC5, 0xD0, 0xE2, + 0xA2, 0x06, 0x38, 0xA9, 0x00, 0xFD, 0x02, 0x03, 0x9D, 0x02, 0x03, 0xCA, + 0x10, 0xF5, 0xA2, 0x07, 0xA9, 0x00, 0xBC, 0x02, 0x03, 0x19, 0x54, 0x69, + 0x9D, 0x03, 0x03, 0xB9, 0xF4, 0x69, 0xCA, 0x10, 0xF1, 0x8D, 0x02, 0x03, + 0xA9, 0x00, 0x85, 0xF2, 0xA9, 0x6F, 0x85, 0xF3, 0xA9, 0x00, 0x85, 0xC3, + 0xA9, 0x06, 0x85, 0xC4, 0xA6, 0xC3, 0xDE, 0x30, 0x03, 0x30, 0x10, 0xA0, + 0x06, 0x18, 0xB9, 0x02, 0x03, 0x71, 0xF2, 0x99, 0x02, 0x03, 0x88, 0x10, + 0xF5, 0x30, 0xE9, 0xD8, 0x18, 0xA5, 0xF2, 0x69, 0x08, 0x85, 0xF2, 0x90, + 0x02, 0xE6, 0xF3, 0xF8, 0xE6, 0xC3, 0xC6, 0xC4, 0xD0, 0xD6, 0xAD, 0x02, + 0x03, 0x29, 0xF0, 0xD0, 0x07, 0x20, 0x88, 0x60, 0xE6, 0xC4, 0xD0, 0xF2, + 0xA2, 0x05, 0xBD, 0x02, 0x03, 0x9D, 0x9A, 0x03, 0xCA, 0x10, 0xF7, 0xA9, + 0x80, 0x8D, 0x98, 0x03, 0xA5, 0xC4, 0x8D, 0x99, 0x03, 0xF0, 0x08, 0xA9, + 0x40, 0x0D, 0x98, 0x03, 0x8D, 0x98, 0x03, 0x20, 0xEB, 0x5F, 0xA9, 0xA0, + 0xA0, 0x6D, 0xA2, 0x68, 0x20, 0x30, 0x52, 0x20, 0xB6, 0x50, 0xA9, 0x70, + 0xA0, 0x03, 0xA2, 0x60, 0x20, 0x30, 0x52, 0xA9, 0x38, 0xA0, 0x6D, 0xA2, + 0x68, 0x20, 0x30, 0x52, 0x20, 0x78, 0x53, 0xA2, 0x07, 0xBD, 0x98, 0x03, + 0x9D, 0x60, 0x03, 0xCA, 0x10, 0xF7, 0xA9, 0x70, 0xA0, 0x03, 0xA2, 0x68, + 0x20, 0x30, 0x52, 0x20, 0xB6, 0x50, 0x60, 0xA2, 0x05, 0xA9, 0x00, 0x9D, + 0x62, 0x03, 0xCA, 0x10, 0xFA, 0xAD, 0x60, 0x03, 0x29, 0x7F, 0x8D, 0x60, + 0x03, 0x29, 0x40, 0x0A, 0xAA, 0xAD, 0x60, 0x03, 0x29, 0x0F, 0xD0, 0x29, + 0x8E, 0x60, 0x03, 0xAD, 0x61, 0x03, 0x29, 0xF0, 0xD0, 0x13, 0xAD, 0x61, + 0x03, 0x0A, 0x0A, 0x0A, 0x0A, 0x8D, 0x62, 0x03, 0xA9, 0x00, 0x8D, 0x61, + 0x03, 0x8E, 0x60, 0x03, 0x60, 0x8D, 0x62, 0x03, 0xA9, 0x01, 0x8D, 0x61, + 0x03, 0x8E, 0x60, 0x03, 0x60, 0x0A, 0x0A, 0x0A, 0x0A, 0x8D, 0x62, 0x03, + 0xAD, 0x61, 0x03, 0x4A, 0x4A, 0x4A, 0x4A, 0x0D, 0x62, 0x03, 0x8D, 0x62, + 0x03, 0xAD, 0x61, 0x03, 0x0A, 0x0A, 0x0A, 0x0A, 0x8D, 0x63, 0x03, 0xA9, + 0x02, 0x8D, 0x61, 0x03, 0x8E, 0x60, 0x03, 0x60, 0xA0, 0x06, 0xB9, 0x02, + 0x03, 0x99, 0x22, 0x03, 0x88, 0x10, 0xF7, 0x60, 0xD8, 0x18, 0xA2, 0x07, + 0xF8, 0xBD, 0x02, 0x03, 0x7D, 0x22, 0x03, 0x9D, 0x02, 0x03, 0xCA, 0x10, + 0xF4, 0x60, 0xD8, 0x38, 0xF8, 0xA2, 0x07, 0xBD, 0x02, 0x03, 0xFD, 0x22, + 0x03, 0x9D, 0x02, 0x03, 0xCA, 0x10, 0xF4, 0x60, 0xA2, 0x08, 0xA9, 0x00, + 0xBC, 0x02, 0x03, 0x19, 0x54, 0x69, 0x9D, 0x02, 0x03, 0xB9, 0xF4, 0x69, + 0xCA, 0x10, 0xF1, 0x60, 0x85, 0xC4, 0x29, 0x01, 0xF0, 0x16, 0xA9, 0x00, + 0xA2, 0x07, 0xBC, 0x22, 0x03, 0x19, 0x54, 0x69, 0x9D, 0x23, 0x03, 0xB9, + 0xF4, 0x69, 0xCA, 0x10, 0xF1, 0x8D, 0x22, 0x03, 0xA5, 0xC4, 0x4A, 0xF0, + 0x1A, 0xD8, 0x18, 0x69, 0x07, 0xF8, 0xA8, 0xA2, 0x07, 0xBD, 0x22, 0x03, + 0x99, 0x22, 0x03, 0x88, 0xCA, 0x10, 0xF6, 0xA9, 0x00, 0x99, 0x22, 0x03, + 0x88, 0x10, 0xFA, 0x60, 0xA9, 0x80, 0x85, 0xF6, 0xA9, 0x6F, 0x85, 0xF7, + 0xA9, 0x03, 0x85, 0xC3, 0xA2, 0x07, 0xBD, 0x70, 0x03, 0x9D, 0x98, 0x03, + 0xCA, 0x10, 0xF7, 0xA0, 0x07, 0xB1, 0xF6, 0x99, 0x70, 0x03, 0x88, 0x10, + 0xF8, 0xA0, 0x07, 0xB9, 0x70, 0x03, 0x99, 0x60, 0x03, 0xB9, 0x98, 0x03, + 0x99, 0x68, 0x03, 0x88, 0x10, 0xF1, 0x20, 0x78, 0x53, 0xC6, 0xC3, 0x30, + 0x23, 0xD8, 0x18, 0xA5, 0xF6, 0x69, 0x08, 0x85, 0xF6, 0x90, 0x02, 0xE6, + 0xF7, 0xF8, 0xA0, 0x07, 0xB1, 0xF6, 0x99, 0x60, 0x03, 0xB9, 0x70, 0x03, + 0x99, 0x68, 0x03, 0x88, 0x10, 0xF2, 0x20, 0xB6, 0x50, 0x4C, 0xF9, 0x60, + 0x60, 0xA9, 0x00, 0x85, 0xCD, 0xAD, 0x60, 0x03, 0x29, 0x0F, 0xF0, 0x03, + 0x4C, 0x2F, 0x69, 0xAD, 0x62, 0x03, 0xD0, 0x09, 0xA9, 0xA0, 0xA0, 0x6D, + 0xA2, 0x70, 0x4C, 0x30, 0x52, 0x2C, 0x60, 0x03, 0x10, 0x0A, 0xA9, 0x80, + 0x85, 0xCD, 0x4D, 0x60, 0x03, 0x8D, 0x60, 0x03, 0x2C, 0x60, 0x03, 0x50, + 0x10, 0xAD, 0x60, 0x03, 0x29, 0x0F, 0xD0, 0xDC, 0xAD, 0x61, 0x03, 0xC9, + 0x12, 0xB0, 0xD5, 0x90, 0x12, 0xAD, 0x61, 0x03, 0xC9, 0x04, 0xB0, 0xC4, + 0xC9, 0x03, 0xD0, 0x07, 0xAD, 0x62, 0x03, 0xC9, 0x23, 0xB0, 0xB9, 0xA9, + 0x40, 0xA0, 0x6D, 0xA2, 0x68, 0x20, 0x30, 0x52, 0x20, 0x78, 0x53, 0xA9, + 0x70, 0xA0, 0x03, 0xA2, 0x90, 0x20, 0x30, 0x52, 0xA9, 0x70, 0xA0, 0x03, + 0xA2, 0x60, 0x20, 0x30, 0x52, 0x20, 0xE2, 0x66, 0xA9, 0x70, 0xA0, 0x03, + 0xA2, 0x68, 0x20, 0x30, 0x52, 0xA9, 0x70, 0xA0, 0x03, 0xA2, 0x98, 0x20, + 0x30, 0x52, 0x20, 0xAE, 0x50, 0xA9, 0x70, 0xA0, 0x03, 0xA2, 0x60, 0x20, + 0x30, 0x52, 0xA9, 0x38, 0xA0, 0x6D, 0xA2, 0x68, 0x20, 0x30, 0x52, 0x20, + 0x78, 0x53, 0xA9, 0x00, 0x85, 0xC0, 0x2C, 0x70, 0x03, 0x50, 0x10, 0xAD, + 0x71, 0x03, 0xC9, 0x12, 0x90, 0x03, 0x4C, 0x48, 0x61, 0xAA, 0xBD, 0x94, + 0x6A, 0x85, 0xC0, 0x20, 0x30, 0x62, 0xAC, 0x99, 0x03, 0xA9, 0x00, 0x8D, + 0x99, 0x03, 0xA2, 0x03, 0x0E, 0x9B, 0x03, 0x2E, 0x9A, 0x03, 0x2E, 0x99, + 0x03, 0x2E, 0x98, 0x03, 0xCA, 0x10, 0xF1, 0x88, 0x10, 0xEC, 0xAD, 0x98, + 0x03, 0x8D, 0x70, 0x03, 0xAD, 0x99, 0x03, 0x8D, 0x71, 0x03, 0x24, 0xCD, + 0x10, 0x15, 0xA9, 0x70, 0xA0, 0x03, 0xA2, 0x68, 0x20, 0x30, 0x52, 0xA9, + 0xA0, 0xA0, 0x6D, 0xA2, 0x60, 0x20, 0x30, 0x52, 0x20, 0x35, 0x55, 0x60, + 0x20, 0x0E, 0x69, 0xA2, 0x05, 0xA5, 0xC0, 0x4A, 0xD8, 0x18, 0x69, 0x05, + 0xA8, 0xBD, 0x72, 0x03, 0x99, 0x02, 0x03, 0x9D, 0x12, 0x03, 0x88, 0xCA, + 0x10, 0xF3, 0xA5, 0xC0, 0x8D, 0x40, 0x03, 0x4A, 0x90, 0x16, 0xA2, 0x08, + 0xA9, 0x00, 0xBC, 0x01, 0x03, 0x19, 0x54, 0x69, 0x9D, 0x02, 0x03, 0xB9, + 0xF4, 0x69, 0xCA, 0x10, 0xF1, 0x9D, 0x02, 0x03, 0xA9, 0x00, 0xA0, 0x6F, + 0x85, 0xF2, 0x84, 0xF3, 0xA9, 0x07, 0x85, 0xC1, 0xA9, 0x00, 0x85, 0xC3, + 0xA9, 0x00, 0xAA, 0xF8, 0x38, 0xA0, 0x07, 0xB9, 0x02, 0x03, 0xF1, 0xF2, + 0x99, 0x02, 0x03, 0x99, 0x22, 0x03, 0x88, 0x10, 0xF2, 0xE8, 0xB0, 0xEB, + 0xCA, 0x8A, 0xA6, 0xC3, 0x9D, 0x30, 0x03, 0xE6, 0xC3, 0x18, 0xA0, 0x07, + 0xB9, 0x02, 0x03, 0x71, 0xF2, 0x99, 0x02, 0x03, 0x88, 0x10, 0xF5, 0xD8, + 0x18, 0xA5, 0xF2, 0x69, 0x08, 0x85, 0xF2, 0x90, 0x02, 0xE6, 0xF3, 0xC6, + 0xC1, 0x10, 0xC1, 0xA9, 0x00, 0x85, 0xC3, 0xA9, 0x10, 0x8D, 0x02, 0x03, + 0xA2, 0x07, 0x86, 0xC5, 0xA2, 0x07, 0xBD, 0x02, 0x03, 0x9D, 0x22, 0x03, + 0xCA, 0x10, 0xF7, 0xA6, 0xC3, 0xDE, 0x30, 0x03, 0x30, 0x23, 0xA2, 0x07, + 0xBD, 0x00, 0x03, 0x9D, 0x20, 0x03, 0xCA, 0x10, 0xF7, 0xA5, 0xC3, 0x20, + 0x9C, 0x60, 0xF8, 0xA2, 0x05, 0x18, 0xBD, 0x02, 0x03, 0x7D, 0x22, 0x03, + 0x9D, 0x02, 0x03, 0xCA, 0x10, 0xF4, 0x4C, 0xCF, 0x62, 0xE6, 0xC3, 0xC6, + 0xC5, 0x10, 0xD0, 0xA2, 0x05, 0xBD, 0x02, 0x03, 0x9D, 0x72, 0x03, 0xCA, + 0x10, 0xF7, 0xA9, 0x00, 0x8D, 0x70, 0x03, 0x8D, 0x71, 0x03, 0x60, 0x20, + 0x35, 0x61, 0xA9, 0x70, 0xA0, 0x03, 0xA2, 0x68, 0x20, 0x30, 0x52, 0xA9, + 0xA0, 0xA0, 0x6D, 0xA2, 0x60, 0x20, 0x30, 0x52, 0x20, 0x35, 0x55, 0xA9, + 0x70, 0xA0, 0x03, 0xA2, 0x60, 0x20, 0x30, 0x52, 0xAD, 0x60, 0x03, 0x09, + 0x80, 0x8D, 0x60, 0x03, 0x20, 0xB6, 0x50, 0xA9, 0x70, 0xA0, 0x03, 0xA2, + 0x60, 0x20, 0x30, 0x52, 0xA9, 0xA8, 0xA0, 0x6D, 0xA2, 0x68, 0x20, 0x30, + 0x52, 0x4C, 0x78, 0x53, 0x20, 0x35, 0x61, 0xA9, 0x70, 0xA0, 0x03, 0xA2, + 0x68, 0x20, 0x30, 0x52, 0xA9, 0xA0, 0xA0, 0x6D, 0xA2, 0x60, 0x20, 0x30, + 0x52, 0x20, 0x35, 0x55, 0xA9, 0x70, 0xA0, 0x03, 0xA2, 0x60, 0x20, 0x30, + 0x52, 0x20, 0xB6, 0x50, 0xA9, 0x70, 0xA0, 0x03, 0xA2, 0x60, 0x20, 0x30, + 0x52, 0xA9, 0xA8, 0xA0, 0x6D, 0xA2, 0x68, 0x20, 0x30, 0x52, 0x4C, 0x78, + 0x53, 0x20, 0x35, 0x61, 0xA9, 0x70, 0xA0, 0x03, 0xA2, 0x68, 0x20, 0x30, + 0x52, 0xA2, 0x07, 0xBD, 0x70, 0x03, 0x9D, 0x98, 0x03, 0xCA, 0x10, 0xF7, + 0xA9, 0xA0, 0xA0, 0x6D, 0xA2, 0x60, 0x20, 0x30, 0x52, 0x20, 0x35, 0x55, + 0xA9, 0x70, 0xA0, 0x03, 0xA2, 0x68, 0x20, 0x30, 0x52, 0xA2, 0x07, 0xBD, + 0x70, 0x03, 0x9D, 0xA0, 0x03, 0xCA, 0x10, 0xF7, 0xA9, 0x98, 0xA0, 0x03, + 0xA2, 0x60, 0x20, 0x30, 0x52, 0x20, 0xAE, 0x50, 0xA2, 0x07, 0xBD, 0x98, + 0x03, 0x9D, 0x60, 0x03, 0xCA, 0x10, 0xF7, 0xA2, 0x07, 0xBD, 0xA0, 0x03, + 0x9D, 0x68, 0x03, 0xCA, 0x10, 0xF7, 0xA2, 0x07, 0xBD, 0x70, 0x03, 0x9D, + 0x98, 0x03, 0xCA, 0x10, 0xF7, 0x20, 0xB6, 0x50, 0xA2, 0x07, 0xBD, 0x70, + 0x03, 0x9D, 0x68, 0x03, 0xCA, 0x10, 0xF7, 0xA2, 0x07, 0xBD, 0x98, 0x03, + 0x9D, 0x60, 0x03, 0xCA, 0x10, 0xF7, 0x4C, 0x35, 0x55, 0x20, 0x13, 0x63, + 0xA9, 0x70, 0xA0, 0x03, 0xA2, 0x68, 0x20, 0x30, 0x52, 0xA9, 0xA0, 0xA0, + 0x6D, 0xA2, 0x60, 0x20, 0x30, 0x52, 0x4C, 0x35, 0x55, 0x20, 0x54, 0x63, + 0xA9, 0x70, 0xA0, 0x03, 0xA2, 0x68, 0x20, 0x30, 0x52, 0xA9, 0xA0, 0xA0, + 0x6D, 0xA2, 0x60, 0x20, 0x30, 0x52, 0x4C, 0x35, 0x55, 0x20, 0x8D, 0x63, + 0xA9, 0x70, 0xA0, 0x03, 0xA2, 0x68, 0x20, 0x30, 0x52, 0xA9, 0xA0, 0xA0, + 0x6D, 0xA2, 0x60, 0x20, 0x30, 0x52, 0x4C, 0x35, 0x55, 0xA2, 0x07, 0xBD, + 0x60, 0x03, 0x9D, 0x90, 0x03, 0xCA, 0x10, 0xF7, 0xA9, 0x60, 0xA0, 0x03, + 0xA2, 0x68, 0x20, 0x30, 0x52, 0x20, 0x78, 0x53, 0xA9, 0x70, 0xA0, 0x03, + 0xA2, 0x68, 0x20, 0x30, 0x52, 0xA9, 0xA0, 0xA0, 0x6D, 0xA2, 0x60, 0x20, + 0x30, 0x52, 0x20, 0xB6, 0x50, 0xA9, 0x70, 0xA0, 0x03, 0xA2, 0x60, 0x20, + 0x30, 0x52, 0x20, 0xE6, 0x56, 0xA9, 0x70, 0xA0, 0x03, 0xA2, 0x68, 0x20, + 0x30, 0x52, 0xA9, 0x90, 0xA0, 0x03, 0xA2, 0x60, 0x20, 0x30, 0x52, 0x20, + 0xB6, 0x50, 0xA9, 0x70, 0xA0, 0x03, 0xA2, 0x60, 0x20, 0x30, 0x52, 0x4C, + 0x96, 0x5E, 0xA2, 0x07, 0xBD, 0x60, 0x03, 0x9D, 0x90, 0x03, 0xCA, 0x10, + 0xF7, 0xA9, 0x60, 0xA0, 0x03, 0xA2, 0x68, 0x20, 0x30, 0x52, 0x20, 0x78, + 0x53, 0xA9, 0x70, 0xA0, 0x03, 0xA2, 0x60, 0x20, 0x30, 0x52, 0xA9, 0xA0, + 0xA0, 0x6D, 0xA2, 0x68, 0x20, 0x30, 0x52, 0x20, 0xAE, 0x50, 0xA9, 0x70, + 0xA0, 0x03, 0xA2, 0x60, 0x20, 0x30, 0x52, 0x20, 0xE6, 0x56, 0xA9, 0x70, + 0xA0, 0x03, 0xA2, 0x68, 0x20, 0x30, 0x52, 0xA9, 0x90, 0xA0, 0x03, 0xA2, + 0x60, 0x20, 0x30, 0x52, 0x20, 0xB6, 0x50, 0xA9, 0x70, 0xA0, 0x03, 0xA2, + 0x60, 0x20, 0x30, 0x52, 0x4C, 0x96, 0x5E, 0xA2, 0x07, 0xBD, 0x60, 0x03, + 0x9D, 0x90, 0x03, 0xCA, 0x10, 0xF7, 0xA9, 0xA0, 0xA0, 0x6D, 0xA2, 0x68, + 0x20, 0x30, 0x52, 0x20, 0xB6, 0x50, 0xA9, 0xA0, 0xA0, 0x6D, 0xA2, 0x60, + 0x20, 0x30, 0x52, 0xA9, 0x90, 0xA0, 0x03, 0xA2, 0x68, 0x20, 0x30, 0x52, + 0xA2, 0x07, 0xBD, 0x70, 0x03, 0x9D, 0x90, 0x03, 0xCA, 0x10, 0xF7, 0x20, + 0xAE, 0x50, 0xA9, 0x70, 0xA0, 0x03, 0xA2, 0x68, 0x20, 0x30, 0x52, 0xA9, + 0x90, 0xA0, 0x03, 0xA2, 0x60, 0x20, 0x30, 0x52, 0x20, 0x35, 0x55, 0xA9, + 0x70, 0xA0, 0x03, 0xA2, 0x60, 0x20, 0x30, 0x52, 0x20, 0x96, 0x5E, 0xA9, + 0x70, 0xA0, 0x03, 0xA2, 0x60, 0x20, 0x30, 0x52, 0xA9, 0xA8, 0xA0, 0x6D, + 0xA2, 0x68, 0x20, 0x30, 0x52, 0x4C, 0x78, 0x53, 0xA9, 0x60, 0xA0, 0x03, + 0xA2, 0x68, 0x20, 0x30, 0x52, 0xA9, 0xA0, 0xA0, 0x6D, 0xA2, 0x60, 0x20, + 0x30, 0x52, 0x20, 0x35, 0x55, 0xA9, 0x70, 0xA0, 0x03, 0xA2, 0x60, 0x20, + 0x30, 0x52, 0x4C, 0x55, 0x64, 0xA9, 0x60, 0xA0, 0x03, 0xA2, 0x68, 0x20, + 0x30, 0x52, 0xA9, 0xA0, 0xA0, 0x6D, 0xA2, 0x60, 0x20, 0x30, 0x52, 0x20, + 0x35, 0x55, 0xA9, 0x70, 0xA0, 0x03, 0xA2, 0x60, 0x20, 0x30, 0x52, 0x4C, + 0xAE, 0x64, 0xA9, 0x60, 0xA0, 0x03, 0xA2, 0x68, 0x20, 0x30, 0x52, 0xA9, + 0xA0, 0xA0, 0x6D, 0xA2, 0x60, 0x20, 0x30, 0x52, 0x20, 0x35, 0x55, 0xA9, + 0x70, 0xA0, 0x03, 0xA2, 0x60, 0x20, 0x30, 0x52, 0x4C, 0x07, 0x65, 0x20, + 0x96, 0x5E, 0xA9, 0x70, 0xA0, 0x03, 0xA2, 0x60, 0x20, 0x30, 0x52, 0xA9, + 0x30, 0xA0, 0x6D, 0xA2, 0x68, 0x20, 0x30, 0x52, 0x4C, 0x35, 0x55, 0x20, + 0x96, 0x5E, 0xA9, 0x70, 0xA0, 0x03, 0xA2, 0x60, 0x20, 0x30, 0x52, 0xA9, + 0x38, 0xA0, 0x6D, 0xA2, 0x68, 0x20, 0x30, 0x52, 0x4C, 0x35, 0x55, 0xA9, + 0x68, 0x85, 0xF2, 0xA9, 0x03, 0x85, 0xF3, 0xA9, 0xA0, 0x85, 0xF4, 0xA9, + 0x03, 0x85, 0xF5, 0x20, 0x04, 0x69, 0x20, 0x96, 0x5E, 0xA9, 0x70, 0xA0, + 0x03, 0xA2, 0x60, 0x20, 0x30, 0x52, 0xA9, 0xA0, 0xA0, 0x03, 0xA2, 0x68, + 0x20, 0x30, 0x52, 0x20, 0x78, 0x53, 0xA9, 0x70, 0xA0, 0x03, 0xA2, 0x60, + 0x20, 0x30, 0x52, 0x4C, 0x35, 0x61, 0xA9, 0x60, 0xA0, 0x03, 0xA2, 0x68, + 0x20, 0x30, 0x52, 0xA9, 0xA0, 0xA0, 0x6D, 0xA2, 0x60, 0x20, 0x30, 0x52, + 0x20, 0x35, 0x55, 0x60, 0xA9, 0x60, 0xA0, 0x03, 0xA2, 0x70, 0x20, 0x30, + 0x52, 0xAD, 0x70, 0x03, 0x29, 0x7F, 0x8D, 0x70, 0x03, 0x60, 0xA9, 0x60, + 0xA0, 0x03, 0xA2, 0x70, 0x20, 0x30, 0x52, 0xAD, 0x70, 0x03, 0x49, 0x80, + 0x8D, 0x70, 0x03, 0x60, 0xA0, 0x07, 0x18, 0xB9, 0x02, 0x03, 0x71, 0xF2, + 0x99, 0x02, 0x03, 0x88, 0x10, 0xF5, 0x60, 0x85, 0xC4, 0x29, 0x01, 0xF0, + 0x2C, 0xA9, 0x00, 0xA2, 0x07, 0xBC, 0x22, 0x03, 0x19, 0x54, 0x69, 0x9D, + 0x23, 0x03, 0xB9, 0xF4, 0x69, 0xCA, 0x10, 0xF1, 0x8D, 0x22, 0x03, 0xA9, + 0x00, 0xA2, 0x07, 0xBC, 0x32, 0x03, 0x19, 0x54, 0x69, 0x9D, 0x33, 0x03, + 0xB9, 0xF4, 0x69, 0xCA, 0x10, 0xF1, 0x8D, 0x32, 0x03, 0xA5, 0xC4, 0x4A, + 0xF0, 0x23, 0xD8, 0x18, 0x69, 0x07, 0xF8, 0xA8, 0xA2, 0x07, 0xBD, 0x22, + 0x03, 0x99, 0x22, 0x03, 0xBD, 0x32, 0x03, 0x99, 0x32, 0x03, 0x88, 0xCA, + 0x10, 0xF0, 0xA9, 0x00, 0x99, 0x22, 0x03, 0x99, 0x32, 0x03, 0x88, 0x10, + 0xF7, 0x60, 0xA9, 0x0F, 0x2C, 0x60, 0x03, 0x70, 0x2E, 0xD0, 0x36, 0x20, + 0x21, 0x67, 0xAE, 0x61, 0x03, 0xE0, 0x12, 0xB0, 0x21, 0xD8, 0xA9, 0x0B, + 0x38, 0xFD, 0x94, 0x6A, 0xF8, 0x4A, 0xF0, 0x0C, 0xAA, 0xA0, 0x05, 0xA9, + 0x00, 0x99, 0x72, 0x03, 0x88, 0xCA, 0xD0, 0xF9, 0x90, 0x08, 0xA9, 0xF0, + 0x39, 0x72, 0x03, 0x99, 0x72, 0x03, 0x60, 0xA9, 0x28, 0xA0, 0x6D, 0xA2, + 0x70, 0x20, 0x30, 0x52, 0x60, 0xA9, 0x60, 0xA0, 0x03, 0xA2, 0x70, 0x20, + 0x30, 0x52, 0x60, 0xA2, 0x07, 0xBD, 0x60, 0x03, 0x9D, 0xA0, 0x03, 0xCA, + 0x10, 0xF7, 0x20, 0xE2, 0x66, 0xA9, 0x70, 0xA0, 0x03, 0xA2, 0x68, 0x20, + 0x30, 0x52, 0xA9, 0xA0, 0xA0, 0x03, 0xA2, 0x60, 0x20, 0x30, 0x52, 0x20, + 0xAE, 0x50, 0xAD, 0x72, 0x03, 0xD0, 0x03, 0x8D, 0x70, 0x03, 0x60, 0xA9, + 0x60, 0x85, 0xF2, 0xA9, 0x6D, 0x85, 0xF3, 0xA9, 0x80, 0x85, 0xF4, 0xA9, + 0x03, 0x85, 0xF5, 0x20, 0x04, 0x69, 0x20, 0x52, 0x68, 0xAD, 0x70, 0x03, + 0x10, 0x15, 0xA9, 0x70, 0xA0, 0x03, 0xA2, 0x60, 0x20, 0x30, 0x52, 0xA9, + 0x60, 0xA0, 0x6D, 0xA2, 0x68, 0x20, 0x30, 0x52, 0x20, 0xB6, 0x50, 0xA9, + 0x90, 0x85, 0xF2, 0xA9, 0x6D, 0x85, 0xF3, 0xA9, 0x70, 0x85, 0xF4, 0xA9, + 0x03, 0x85, 0xF5, 0x20, 0x80, 0x68, 0x10, 0x07, 0xA9, 0x04, 0x85, 0xC9, + 0x4C, 0xCF, 0x67, 0xA9, 0x58, 0x85, 0xF2, 0xA9, 0x6D, 0x85, 0xF3, 0x20, + 0x80, 0x68, 0x10, 0x07, 0xA9, 0x03, 0x85, 0xC9, 0x4C, 0xCF, 0x67, 0xA9, + 0x80, 0x85, 0xF2, 0xA9, 0x6D, 0x85, 0xF3, 0x20, 0x80, 0x68, 0x10, 0x07, + 0xA9, 0x02, 0x85, 0xC9, 0x4C, 0xCF, 0x67, 0xA9, 0x01, 0x85, 0xC9, 0xA5, + 0xC9, 0x8D, 0x00, 0x03, 0xC9, 0x03, 0x90, 0x15, 0xA9, 0x70, 0xA0, 0x03, + 0xA2, 0x60, 0x20, 0x30, 0x52, 0xA9, 0x58, 0xA0, 0x6D, 0xA2, 0x68, 0x20, + 0x30, 0x52, 0x20, 0xAE, 0x50, 0xA5, 0xC9, 0x29, 0x01, 0xD0, 0x04, 0xA9, + 0x80, 0x85, 0xC8, 0xA9, 0x80, 0x85, 0xF2, 0xA9, 0x6D, 0x85, 0xF3, 0x20, + 0x80, 0x68, 0x10, 0x15, 0xA9, 0x70, 0xA0, 0x03, 0xA2, 0x60, 0x20, 0x30, + 0x52, 0xA9, 0x58, 0xA0, 0x6D, 0xA2, 0x68, 0x20, 0x30, 0x52, 0x20, 0xAE, + 0x50, 0xAD, 0x70, 0x03, 0x29, 0x7F, 0x8D, 0x70, 0x03, 0xA9, 0x70, 0x85, + 0xF4, 0xA9, 0x03, 0x85, 0xF5, 0xA9, 0x98, 0x85, 0xF2, 0xA9, 0x6D, 0x85, + 0xF3, 0x20, 0x80, 0x68, 0x10, 0x1B, 0xA9, 0x80, 0xA0, 0x6D, 0xA2, 0x60, + 0x20, 0x30, 0x52, 0xA9, 0x70, 0xA0, 0x03, 0xA2, 0x68, 0x20, 0x30, 0x52, + 0x20, 0xAE, 0x50, 0xA5, 0xCA, 0x49, 0x01, 0x85, 0xCA, 0x60, 0xA9, 0x80, + 0xA0, 0x03, 0xA2, 0x68, 0x20, 0x30, 0x52, 0x20, 0x35, 0x55, 0xA9, 0x70, + 0xA0, 0x03, 0xA2, 0x60, 0x20, 0x30, 0x52, 0x20, 0x2B, 0x67, 0xA9, 0x70, + 0xA0, 0x03, 0xA2, 0x60, 0x20, 0x30, 0x52, 0xA9, 0x80, 0xA0, 0x03, 0xA2, + 0x68, 0x20, 0x30, 0x52, 0x20, 0x78, 0x53, 0x60, 0xF8, 0xA0, 0x00, 0xB1, + 0xF2, 0x51, 0xF4, 0x10, 0x05, 0xB1, 0xF2, 0x09, 0x01, 0x60, 0x0A, 0x10, + 0x20, 0xB1, 0xF2, 0x30, 0x16, 0xA0, 0x02, 0xB1, 0xF2, 0xD0, 0x03, 0xA9, + 0x80, 0x60, 0xB1, 0xF4, 0xD0, 0x01, 0x60, 0xA0, 0x00, 0xB1, 0xF2, 0x0A, + 0x09, 0x01, 0x60, 0xB1, 0xF4, 0x0A, 0x09, 0x01, 0x60, 0xB1, 0xF2, 0x51, + 0xF4, 0xD0, 0x23, 0xC8, 0xB1, 0xF2, 0x51, 0xF4, 0xD0, 0x1C, 0xA0, 0x07, + 0xA2, 0x05, 0xA9, 0x00, 0x85, 0xC0, 0x38, 0xB1, 0xF4, 0xF1, 0xF2, 0xF0, + 0x02, 0xE6, 0xC0, 0x88, 0xCA, 0x10, 0xF4, 0x90, 0x20, 0xA5, 0xC0, 0xD0, + 0x19, 0x60, 0xA0, 0x01, 0x38, 0xB1, 0xF4, 0xF1, 0xF2, 0x88, 0xB1, 0xF4, + 0xF1, 0xF2, 0xB0, 0x10, 0xB1, 0xF2, 0x29, 0xC0, 0xF0, 0x07, 0xC9, 0xC0, + 0xF0, 0x03, 0xA9, 0x81, 0x60, 0xA9, 0x01, 0x60, 0xB1, 0xF4, 0x29, 0xC0, + 0xF0, 0xF4, 0xC9, 0xC0, 0xF0, 0xF0, 0xD0, 0xF1, 0xA0, 0x07, 0xB1, 0xF2, + 0x91, 0xF4, 0x88, 0x10, 0xF9, 0x60, 0xA2, 0x5F, 0xA9, 0x00, 0x9D, 0x00, + 0x03, 0xCA, 0x10, 0xFA, 0x60, 0xA9, 0x28, 0xA0, 0x6D, 0xA2, 0x70, 0x20, + 0x30, 0x52, 0x60, 0xA9, 0xD0, 0xA0, 0x6D, 0xA2, 0x70, 0x20, 0x30, 0x52, + 0x4C, 0x53, 0x69, 0xA9, 0xC8, 0xA0, 0x6D, 0xA2, 0x70, 0x20, 0x30, 0x52, + 0x4C, 0x53, 0x69, 0xA9, 0xC0, 0xA0, 0x6D, 0xA2, 0x70, 0x20, 0x30, 0x52, + 0x4C, 0x53, 0x69, 0xA9, 0xD8, 0xA0, 0x6D, 0xA2, 0x70, 0x20, 0x30, 0x52, + 0x4C, 0x53, 0x69, 0x00, 0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, + 0x80, 0x90, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x20, 0x30, + 0x40, 0x50, 0x60, 0x70, 0x80, 0x90, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, 0x80, 0x90, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, + 0x80, 0x90, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x20, 0x30, + 0x40, 0x50, 0x60, 0x70, 0x80, 0x90, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, 0x80, 0x90, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, + 0x80, 0x90, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x20, 0x30, + 0x40, 0x50, 0x60, 0x70, 0x80, 0x90, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, 0x80, 0x90, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, + 0x80, 0x90, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, + 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03, + 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, + 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, + 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, + 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x06, 0x06, 0x06, 0x06, + 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, + 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, + 0x07, 0x07, 0x07, 0x07, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, + 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x09, 0x09, 0x09, 0x09, + 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, + 0x12, 0x13, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x14, 0x15, 0x16, 0x17, + 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x1E, 0x1F, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, + 0x30, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x32, 0x33, 0x34, 0x35, + 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x3C, 0x3D, 0x3E, 0x3F, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, + 0x4E, 0x4F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50, 0x51, 0x52, 0x53, + 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F, 0x60, 0x61, 0x62, 0x63, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, + 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x30, 0x31, + 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x40, 0x41, 0x42, 0x43, + 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, + 0x56, 0x57, 0x58, 0x59, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, + 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, + 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x90, 0x91, + 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x00, 0x01, 0x02, 0x03, + 0x04, 0x05, 0x06, 0x07, 0x05, 0x06, 0x07, 0x08, 0x09, 0x00, 0x00, 0x00, + 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x15, 0x16, 0x17, 0x18, + 0x19, 0x00, 0x00, 0x00, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, + 0x25, 0x26, 0x27, 0x28, 0x29, 0x00, 0x00, 0x00, 0x30, 0x31, 0x32, 0x33, + 0x34, 0x35, 0x36, 0x37, 0x35, 0x36, 0x37, 0x38, 0x39, 0x00, 0x00, 0x00, + 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x45, 0x46, 0x47, 0x49, + 0x49, 0x00, 0x00, 0x00, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, + 0x55, 0x56, 0x57, 0x58, 0x59, 0x00, 0x00, 0x00, 0x60, 0x61, 0x62, 0x63, + 0x64, 0x65, 0x66, 0x67, 0x65, 0x66, 0x67, 0x68, 0x69, 0x00, 0x00, 0x00, + 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x75, 0x76, 0x77, 0x78, + 0x79, 0x00, 0x00, 0x00, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, + 0x55, 0x56, 0x57, 0x58, 0x59, 0x00, 0x00, 0x00, 0x60, 0x61, 0x62, 0x63, + 0x64, 0x65, 0x66, 0x67, 0x65, 0x66, 0x67, 0x68, 0x69, 0x00, 0x00, 0x00, + 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x75, 0x76, 0x77, 0x78, + 0x79, 0x00, 0x00, 0x00, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, + 0x85, 0x86, 0x87, 0x88, 0x89, 0x00, 0x00, 0x00, 0x90, 0x91, 0x92, 0x93, + 0x94, 0x95, 0x96, 0x97, 0x95, 0x96, 0x97, 0x98, 0x99, 0x00, 0x00, 0x00, + 0x00, 0x01, 0x02, 0x03, 0x04, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x10, 0x11, 0x12, 0x13, 0x14, 0x18, 0x19, 0x1A, + 0x1B, 0x1C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x21, 0x22, 0x23, + 0x24, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x30, 0x31, 0x32, 0x33, 0x34, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x40, 0x41, 0x42, 0x43, 0x44, 0x48, 0x49, 0x4A, + 0x4B, 0x4C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x81, 0x82, 0x83, + 0x84, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x90, 0x91, 0x92, 0x93, 0x94, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA8, 0xA9, 0xAA, + 0xAB, 0xAC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xB0, 0xB1, 0xB2, 0xB3, + 0xB4, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, + 0x38, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x30, 0x31, 0x32, 0x33, + 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x01, 0x69, 0x31, + 0x47, 0x18, 0x05, 0x60, 0x00, 0x00, 0x23, 0x02, 0x58, 0x50, 0x92, 0x99, + 0x40, 0x01, 0x43, 0x42, 0x94, 0x48, 0x19, 0x03, 0x00, 0x00, 0x27, 0x18, + 0x28, 0x18, 0x28, 0x46, 0x00, 0x00, 0x14, 0x14, 0x21, 0x35, 0x62, 0x37, + 0x00, 0x00, 0x31, 0x41, 0x59, 0x26, 0x53, 0x59, 0x00, 0x00, 0x62, 0x83, + 0x18, 0x53, 0x07, 0x18, 0x40, 0x01, 0x70, 0x71, 0x06, 0x78, 0x11, 0x87, + 0x40, 0x01, 0x31, 0x83, 0x09, 0x88, 0x61, 0x84, 0x40, 0x01, 0x15, 0x91, + 0x54, 0x94, 0x30, 0x92, 0x00, 0x00, 0x15, 0x70, 0x79, 0x63, 0x26, 0x79, + 0x80, 0x00, 0x15, 0x70, 0x79, 0x63, 0x26, 0x79, 0x00, 0x00, 0x47, 0x12, + 0x38, 0x89, 0x80, 0x38, 0x40, 0x01, 0x78, 0x53, 0x98, 0x16, 0x33, 0x98, + 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x01, 0x50, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x15, 0x70, 0x79, 0x00, 0x00, 0x00, 0x00, + 0x40, 0x02, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x29, 0x99, 0x99, 0x99, + 0x99, 0x99, 0x99, 0x99, 0x30, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x30, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x03, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x40, 0x05, 0x23, 0x15, 0x39, 0x31, 0x67, 0x00, + 0xC0, 0x03, 0x13, 0x85, 0x37, 0x04, 0x26, 0x40, 0x40, 0x02, 0x41, 0x66, + 0x35, 0x84, 0x67, 0x69, 0xC0, 0x01, 0x49, 0x99, 0x99, 0x05, 0x34, 0x55, + 0x40, 0x01, 0x99, 0x99, 0x99, 0x95, 0x34, 0x64, 0x40, 0x01, 0x78, 0x53, + 0x98, 0x16, 0x33, 0x97, 0x40, 0x02, 0x99, 0x66, 0x86, 0x52, 0x49, 0x12, + 0x40, 0x03, 0x99, 0x99, 0x66, 0x66, 0x86, 0x67, 0x40, 0x04, 0x99, 0x99, + 0x99, 0x66, 0x66, 0x67, 0x40, 0x05, 0x99, 0x99, 0x99, 0x99, 0x66, 0x67, + 0x40, 0x06, 0x99, 0x99, 0x99, 0x99, 0x99, 0x67, 0x40, 0x06, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x40, 0x07, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x07, 0x85, 0x39, 0x81, 0x63, 0x39, 0x74, 0x48, 0x00, 0x99, 0x66, 0x86, + 0x52, 0x49, 0x11, 0x62, 0x00, 0x09, 0x99, 0x96, 0x66, 0x68, 0x66, 0x65, + 0x00, 0x00, 0x99, 0x99, 0x99, 0x66, 0x66, 0x67, 0x00, 0x00, 0x09, 0x99, + 0x99, 0x99, 0x96, 0x67, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, + 0x40, 0x01, 0x69, 0x31, 0x47, 0x18, 0x05, 0x60, 0x40, 0x02, 0x95, 0x31, + 0x01, 0x79, 0x80, 0x43, 0x40, 0x03, 0x99, 0x50, 0x33, 0x08, 0x53, 0x17, + 0x40, 0x04, 0x99, 0x95, 0x00, 0x33, 0x30, 0x84, 0x40, 0x05, 0x99, 0x99, + 0x50, 0x00, 0x33, 0x33, 0x40, 0x06, 0x99, 0x99, 0x95, 0x00, 0x00, 0x33, + 0x40, 0x07, 0x99, 0x99, 0x99, 0x50, 0x00, 0x00, 0x40, 0x08, 0x99, 0x99, + 0x99, 0x95, 0x00, 0x00, 0x40, 0x09, 0x99, 0x99, 0x99, 0x99, 0x50, 0x00, + 0x40, 0x10, 0x99, 0x99, 0x99, 0x99, 0x95, 0x00, 0x40, 0x11, 0x99, 0x99, + 0x99, 0x99, 0x99, 0x50, 0x06, 0x93, 0x14, 0x71, 0x80, 0x55, 0x99, 0x45, + 0x00, 0x95, 0x31, 0x01, 0x79, 0x80, 0x43, 0x25, 0x00, 0x09, 0x95, 0x03, + 0x30, 0x85, 0x31, 0x68, 0x00, 0x00, 0x99, 0x95, 0x00, 0x33, 0x30, 0x84, + 0x00, 0x00, 0x09, 0x99, 0x95, 0x00, 0x03, 0x33, 0x00, 0x00, 0x00, 0x99, + 0x99, 0x95, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x99, 0x99, 0x95, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x99, 0x99, 0x99, 0x95, 0x00, 0x00, 0x00, 0x00, + 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, + 0xC0, 0x01, 0x25, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x01, 0x33, 0x33, + 0x33, 0x33, 0x33, 0x33, 0xC0, 0x01, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x80, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x80, 0x00, 0x00, 0x00, 0x00, 0x01, + 0x80, 0x01, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x12, 0x30, + 0x00, 0x00, 0x00, 0x00, 0x40, 0x01, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x40, 0x02, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x01, 0x33, 0x00, +// 0x00, 0x00, 0x00, 0x00, 0xC0, 0x02, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00 + 0x00, 0x00, 0x00, 0x00, 0xC0, 0x02, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x50, 0x00 +}; + +/* MOVIT utility, copied into RAM 1780-17E3. Length: decimal 102 */ +/* for use, see http://users.telenet.be/kim1-6502/6502/fbok.html#p114 */ +#ifdef AVRX +const unsigned char movit[100] PROGMEM = { +#else +unsigned char movit[95] = { +#endif + 0xD8, 0xA0, 0xFF, 0x38, 0xA5, 0xD2, 0xE5, 0xD0, 0x85, 0xD8, 0xA5, 0xD3, 0xE5, 0xD1, 0x85, 0xD9, + 0x18, 0xA5, 0xD8, 0x65, 0xD4, 0x85, 0xD6, /* 0x85, 0xFA, */ 0xA5, 0xD9, 0x65, 0xD5, 0x85, 0xD7, /* 0x85, 0xFB,*/ 0xE6, 0xD8, 0xE6, + 0xD9, 0x38, 0xA5, 0xD4, 0xE5, 0xD0, 0xA5, 0xD5, 0xE5, 0xD1, 0xA2, 0x00, 0x90, 0x02, 0xA2, 0x02, + 0xA1, 0xD0, 0x81, 0xD4, 0x90, 0x14, 0xC6, 0xD2, 0x98, 0x45, 0xD2, 0xD0, 0x02, 0xC6, 0xD3, 0xC6, + 0xD6, 0x98, 0x45, 0xD6, 0xD0, 0x02, 0xC6, 0xD7, 0xB0, 0x0C, 0xE6, 0xD0, 0xD0, 0x02, 0xE6, 0xD1, + 0xE6, 0xD4, 0xD0, 0x02, 0xE6, 0xD5, 0xC6, 0xD8, 0xD0, 0x02, 0xC6, 0xD9, 0xD0, 0xCC, 0x00 /*, 0x4C, 0x4F, 0x1C */ +}; + +/* RELOCATE utility, copied into RAM 0110-01A4. Length: decimal 149 */ +/* for use, see http://users.telenet.be/kim1-6502/6502/fbok.html#p114 */ +#ifdef AVRX +const unsigned char relocate[149] PROGMEM = { +#else +unsigned char relocate[149] = { +#endif + 0xD8, 0xA0, 0x00, 0xB1, 0xEA, 0xA8, 0xA2, 0x07, 0x98, 0x3D, 0x8E, 0x01, 0x5D, 0x95, 0x01, 0xF0, + 0x03, 0xCA, 0xD0, 0xF4, 0xBC, 0x9D, 0x01, 0x30, 0x0D, 0xF0, 0x22, 0xE6, 0xEA, 0xD0, 0x02, 0xE6, + 0xEB, 0x88, 0xD0, 0xF7, 0xF0, 0xDA, 0xC8, 0x30, 0xD9, 0xC8, 0xB1, 0xEA, 0xAA, 0xC8, 0xB1, 0xEA, + 0x20, 0x79, 0x01, 0x91, 0xEA, 0x88, 0x8A, 0x91, 0xEA, 0xA0, 0x03, 0x10, 0xDE, 0xC8, 0xA6, 0xEA, + 0xA5, 0xEB, 0x20, 0x79, 0x01, 0x86, 0xE0, 0xA2, 0xFF, 0xB1, 0xEA, 0x18, 0x69, 0x02, 0x30, 0x01, + 0xE8, 0x86, 0xE3, 0x18, 0x65, 0xEA, 0xAA, 0xA5, 0xE3, 0x65, 0xEB, 0x20, 0x79, 0x01, 0xCA, 0xCA, + 0x8A, 0x38, 0xE5, 0xE0, 0x91, 0xEA, 0xC8, 0x10, 0xB2, 0xC5, 0xE7, 0xB0, 0x11, 0xC5, 0xED, 0xD0, + 0x02, 0xE4, 0xEC, 0x90, 0x09, 0x48, 0x8A, 0x18, 0x65, 0xE8, 0xAA, 0x68, 0x65, 0xE9, 0x60, 0x0C, + 0X1F, 0x0D, 0x87, 0X1F, 0xFF, 0x03, 0x0C, 0x19, 0x08, 0x00, 0x10, 0x20, 0x03, 0x02, 0xFF, 0xFF, + 0x01, 0x01, 0x00, 0xFF, 0xFE +}; + +/* BRANCH calculation utility, to be copied into RAM anywhere you want (relocatable). Length: decimal 42 */ +/* for use, see http://users.telenet.be/kim1-6502/6502/fbok.html#p114 */ +#ifdef AVRX +const unsigned char branch[42] PROGMEM = { +#else +unsigned char branch[42] = { +#endif + 0xD8, 0x18, 0xA5, 0xFA, 0xE5, 0xFB, 0x85, 0xF9, 0xC6, 0xF9, 0x20, 0x1F, 0x1F, 0x20, 0x6A, 0x1F, + 0xC5, 0xF3, 0xF0, 0xEC, 0x85, 0xF3, 0xC9, 0x10, 0xB0, 0xE6, 0x0A, 0x0A, 0x0A, 0x0A, 0xA2, 0x04, + 0x0A, 0x26, 0xFA, 0x26, 0xFB, 0xCA, 0xD0, 0xF8, 0xF0, 0xD6 +}; + +/* C:\temp27\KIM Uno\sw\tools\WozBaum disasm\WozBaum disasm\dis2.bin (02/09/2014 23:58:36) + StartOffset: 00000000, EndOffset: 000001F8, Length: 000001F9 */ +#ifdef AVRX +const unsigned char disasm[505] PROGMEM = { +#else +unsigned char disasm[505] = { +#endif + 0x20, 0x0F, 0x20, 0x20, 0x9E, 0x1E, 0x20, 0x9E, 0x1E, 0x20, 0x9E, 0x1E, + 0x4C, 0x64, 0x1C, 0xA9, 0x0D, 0x85, 0x02, 0x20, 0x21, 0x20, 0x20, 0xFC, + 0x20, 0x85, 0x00, 0x84, 0x01, 0xC6, 0x02, 0xD0, 0xF2, 0x20, 0xE2, 0x20, + 0xA1, 0x00, 0xA8, 0x4A, 0x90, 0x0B, 0x4A, 0xB0, 0x17, 0xC9, 0x22, 0xF0, + 0x13, 0x29, 0x07, 0x09, 0x80, 0x4A, 0xAA, 0xBD, 0x1B, 0x21, 0xB0, 0x04, + 0x4A, 0x4A, 0x4A, 0x4A, 0x29, 0x0F, 0xD0, 0x04, 0xA0, 0x80, 0xA9, 0x00, + 0xAA, 0xBD, 0x5F, 0x21, 0x85, 0x03, 0x29, 0x03, 0x85, 0x04, 0x98, 0x29, + 0x8F, 0xAA, 0x98, 0xA0, 0x03, 0xE0, 0x8A, 0xF0, 0x0B, 0x4A, 0x90, 0x08, + 0x4A, 0x4A, 0x09, 0x20, 0x88, 0xD0, 0xFA, 0xC8, 0x88, 0xD0, 0xF2, 0x48, + 0xB1, 0x00, 0x20, 0x13, 0x21, 0xA2, 0x01, 0x20, 0xF3, 0x20, 0xC4, 0x04, + 0xC8, 0x90, 0xF1, 0xA2, 0x03, 0xC0, 0x04, 0x90, 0xF2, 0x68, 0xA8, 0xB9, + 0x79, 0x21, 0x85, 0x05, 0xB9, 0xB9, 0x21, 0x85, 0x06, 0xA9, 0x00, 0xA0, + 0x05, 0x06, 0x06, 0x26, 0x05, 0x2A, 0x88, 0xD0, 0xF8, 0x69, 0x3F, 0x20, + 0x0B, 0x21, 0xCA, 0xD0, 0xEC, 0x20, 0xF1, 0x20, 0xA2, 0x06, 0xE0, 0x03, + 0xD0, 0x12, 0xA4, 0x04, 0xF0, 0x0E, 0xA5, 0x03, 0xC9, 0xE8, 0xB1, 0x00, + 0xB0, 0x1C, 0x20, 0x13, 0x21, 0x88, 0xD0, 0xF2, 0x06, 0x03, 0x90, 0x0E, + 0xBD, 0x6C, 0x21, 0x20, 0x0B, 0x21, 0xBD, 0x72, 0x21, 0xF0, 0x03, 0x20, + 0x0B, 0x21, 0xCA, 0xD0, 0xD5, 0x60, 0x20, 0xFF, 0x20, 0xAA, 0xE8, 0xD0, + 0x01, 0xC8, 0x98, 0x20, 0x13, 0x21, 0x8A, 0x4C, 0x13, 0x21, 0x20, 0x2F, + 0x1E, 0xA5, 0x01, 0xA6, 0x00, 0x20, 0xDB, 0x20, 0xA9, 0x2D, 0x20, 0x0B, + 0x21, 0xA2, 0x03, 0xA9, 0x20, 0x20, 0x0B, 0x21, 0xCA, 0xD0, 0xF8, 0x60, + 0xA5, 0x04, 0x38, 0xA4, 0x01, 0xAA, 0x10, 0x01, 0x88, 0x65, 0x00, 0x90, + 0x01, 0xC8, 0x60, 0x84, 0x07, 0x20, 0xA0, 0x1E, 0xA4, 0x07, 0x60, 0x84, + 0x07, 0x20, 0x3B, 0x1E, 0xA4, 0x07, 0x60, 0x40, 0x02, 0x45, 0x03, 0xD0, + 0x08, 0x40, 0x09, 0x30, 0x22, 0x45, 0x33, 0xD0, 0x08, 0x40, 0x09, 0x40, + 0x02, 0x45, 0x33, 0xD0, 0x08, 0x40, 0x09, 0x40, 0x02, 0x45, 0xB3, 0xD0, + 0x08, 0x40, 0x09, 0x00, 0x22, 0x44, 0x33, 0xD0, 0x8C, 0x44, 0x00, 0x11, + 0x22, 0x44, 0x33, 0xD0, 0x8C, 0x44, 0x9A, 0x10, 0x22, 0x44, 0x33, 0xD0, + 0x08, 0x40, 0x09, 0x10, 0x22, 0x44, 0x33, 0xD0, 0x08, 0x40, 0x09, 0x62, + 0x13, 0x78, 0xA9, 0x00, 0x21, 0x01, 0x02, 0x00, 0x80, 0x59, 0x4D, 0x11, + 0x12, 0x06, 0x4A, 0x05, 0x1D, 0x2C, 0x29, 0x2C, 0x23, 0x28, 0x41, 0x59, + 0x00, 0x58, 0x00, 0x00, 0x00, 0x1C, 0x8A, 0x1C, 0x23, 0x5D, 0x8B, 0x1B, + 0xA1, 0x9D, 0x8A, 0x1D, 0x23, 0x9D, 0x8B, 0x1D, 0xA1, 0x00, 0x29, 0x19, + 0xAE, 0x69, 0xA8, 0x19, 0x23, 0x24, 0x53, 0x1B, 0x23, 0x24, 0x53, 0x19, + 0xA1, 0x00, 0x1A, 0x5B, 0x5B, 0xA5, 0x69, 0x24, 0x24, 0xAE, 0xAE, 0xA8, + 0xAD, 0x29, 0x00, 0x7C, 0x00, 0x15, 0x9C, 0x6D, 0x9C, 0xA5, 0x69, 0x29, + 0x53, 0x84, 0x13, 0x34, 0x11, 0xA5, 0x69, 0x23, 0xA0, 0xD8, 0x62, 0x5A, + 0x48, 0x26, 0x62, 0x94, 0x88, 0x54, 0x44, 0xC8, 0x54, 0x68, 0x44, 0xE8, + 0x94, 0x00, 0xB4, 0x08, 0x84, 0x74, 0xB4, 0x28, 0x6E, 0x74, 0xF4, 0xCC, + 0x4A, 0x72, 0xF2, 0xA4, 0x8A, 0x00, 0xAA, 0xA2, 0xA2, 0x74, 0x74, 0x74, + 0x72, 0x44, 0x68, 0xB2, 0x32, 0xB2, 0x00, 0x22, 0x00, 0x1A, 0x1A, 0x26, + 0x26, 0x72, 0x72, 0x88, 0xC8, 0xC4, 0xCA, 0x26, 0x48, 0x44, 0x44, 0xA2, + 0xC8 +}; + +/* VTL-02 interpreter */ +/* for use, see VTL-02 on github */ +#ifdef AVRX +const unsigned char vtl[1019] PROGMEM = { +#else +unsigned char vtl[1019] = { +#endif + 0xA9, 0x00, 0x85, 0xCC, 0xA9, 0x02, 0x85, 0xCD, 0xA9, 0x00, 0x85, 0xD4, + 0xA9, 0x04, 0x85, 0xD5, 0x38, 0xD8, 0xA2, 0xFF, 0x9A, 0x90, 0x10, 0x20, + 0x39, 0xFD, 0xA9, 0x4F, 0x20, 0xEB, 0xFF, 0xA9, 0x4B, 0x20, 0xEB, 0xFF, + 0x20, 0x39, 0xFD, 0x20, 0x64, 0xFF, 0xA2, 0xC6, 0x20, 0x2F, 0xFF, 0xF0, + 0x39, 0x18, 0xA5, 0xC6, 0x05, 0xC7, 0xD0, 0x41, 0x20, 0x10, 0xFD, 0xA2, + 0xD0, 0x20, 0x94, 0xFD, 0xA9, 0x20, 0x20, 0xEB, 0xFF, 0xA9, 0x00, 0x20, + 0x1A, 0xFD, 0xB0, 0xEC, 0xF0, 0x14, 0xA4, 0xD1, 0xA6, 0xD0, 0xC4, 0xC7, + 0xD0, 0x04, 0xE4, 0xC6, 0xF0, 0x0C, 0xE8, 0xD0, 0x01, 0xC8, 0x86, 0xC2, + 0x84, 0xC3, 0x2A, 0x49, 0x01, 0x6A, 0x20, 0x10, 0xFD, 0xC8, 0x08, 0x20, + 0x3E, 0xFD, 0x28, 0xA5, 0xC6, 0x05, 0xC7, 0x90, 0xD7, 0xF0, 0x9A, 0xD0, + 0xE9, 0x98, 0x48, 0x20, 0x84, 0xFF, 0xB0, 0x34, 0x45, 0xC6, 0xD0, 0x30, + 0xE4, 0xC7, 0xD0, 0x2C, 0xAA, 0xB1, 0x80, 0xA8, 0x49, 0xFF, 0x65, 0xCC, + 0x85, 0xCC, 0xB0, 0x02, 0xC6, 0xCD, 0xA5, 0x80, 0x85, 0xFC, 0xA5, 0x81, + 0x85, 0xFD, 0xA5, 0xFC, 0xC5, 0xCC, 0xA5, 0xFD, 0xE5, 0xCD, 0xB0, 0x0C, + 0xB1, 0xFC, 0x81, 0xFC, 0xE6, 0xFC, 0xD0, 0xEE, 0xE6, 0xFD, 0x90, 0xEA, + 0x68, 0xAA, 0xA5, 0xC6, 0x48, 0xA5, 0xC7, 0x48, 0xA0, 0x02, 0xE8, 0xC8, + 0xBD, 0x7F, 0x17, 0x48, 0xD0, 0xF8, 0xC0, 0x04, 0x90, 0x43, 0xAA, 0x98, + 0x18, 0x65, 0xCC, 0x85, 0xFC, 0x8A, 0x65, 0xCD, 0x85, 0xFD, 0xA5, 0xFC, + 0xC5, 0xD4, 0xA5, 0xFD, 0xE5, 0xD5, 0xB0, 0x2D, 0xA5, 0xCC, 0xD0, 0x02, + 0xC6, 0xCD, 0xC6, 0xCC, 0xA5, 0xCC, 0xC5, 0x80, 0xA5, 0xCD, 0xE5, 0x81, + 0x90, 0x06, 0xA1, 0xCC, 0x91, 0xCC, 0xB0, 0xE8, 0x98, 0xAA, 0x68, 0x88, + 0x91, 0x80, 0xD0, 0xFA, 0xA0, 0x02, 0x8A, 0x91, 0x80, 0xA5, 0xFC, 0x85, + 0xCC, 0xA5, 0xFD, 0x85, 0xCD, 0x4C, 0x11, 0xFC, 0x20, 0x84, 0xFF, 0xB0, + 0xF8, 0x85, 0xC6, 0x86, 0xC7, 0x60, 0xC8, 0xAA, 0x8A, 0xD1, 0x80, 0xF0, + 0x0A, 0xB1, 0x80, 0xF0, 0x06, 0x20, 0xEB, 0xFF, 0xC8, 0x10, 0xF1, 0xAA, + 0x20, 0xCC, 0xFF, 0x8A, 0xF0, 0x07, 0x20, 0xC2, 0xFF, 0xC9, 0x3B, 0xF0, + 0x4F, 0xA9, 0x0D, 0x4C, 0xEB, 0xFF, 0x20, 0xC3, 0xFF, 0xF0, 0x45, 0xC9, + 0x29, 0xF0, 0x41, 0xC8, 0xA2, 0xE0, 0x20, 0x31, 0xFE, 0x20, 0xC3, 0xFF, + 0x20, 0xC2, 0xFF, 0xC9, 0x22, 0xF0, 0xC3, 0xA2, 0xE2, 0x20, 0xBF, 0xFD, + 0xA5, 0xE2, 0xA0, 0x00, 0xA6, 0xE1, 0xD0, 0x12, 0xA6, 0xE0, 0xE0, 0x80, + 0xF0, 0x25, 0xE0, 0xC8, 0xF0, 0xCD, 0xE0, 0xFE, 0xF0, 0x20, 0xE0, 0xFC, + 0xF0, 0x13, 0x91, 0xE0, 0x65, 0xCF, 0x2A, 0xAA, 0xC8, 0xA5, 0xE3, 0x91, + 0xE0, 0x65, 0xCE, 0x2A, 0x85, 0xCF, 0x86, 0xCE, 0x60, 0xAA, 0xA5, 0xE3, + 0x6C, 0xC4, 0x00, 0x91, 0xF8, 0x60, 0xA2, 0xE2, 0xA5, 0xCA, 0x48, 0xA5, + 0xCB, 0x48, 0xA9, 0x00, 0x48, 0x95, 0x03, 0xA9, 0x0A, 0x95, 0x02, 0x20, + 0x04, 0xFF, 0xA5, 0xCA, 0x09, 0x30, 0x48, 0xB5, 0x00, 0x15, 0x01, 0xD0, + 0xF2, 0x68, 0x20, 0xEB, 0xFF, 0x68, 0xD0, 0xFA, 0x68, 0x85, 0xCB, 0x68, + 0x85, 0xCA, 0x60, 0xA9, 0x00, 0x95, 0x00, 0x95, 0x01, 0xA9, 0x2B, 0x48, + 0xE8, 0xE8, 0x20, 0xDE, 0xFD, 0xCA, 0xCA, 0x68, 0x20, 0x81, 0xFE, 0x20, + 0xC3, 0xFF, 0xF0, 0x05, 0xC8, 0xC9, 0x29, 0xD0, 0xEA, 0x60, 0x20, 0x2F, + 0xFF, 0xD0, 0x4D, 0x20, 0xC3, 0xFF, 0xC8, 0xC9, 0x3F, 0xD0, 0x17, 0x98, + 0x48, 0xA5, 0x80, 0x48, 0xA5, 0x81, 0x48, 0x20, 0x64, 0xFF, 0x20, 0xBF, + 0xFD, 0x68, 0x85, 0x81, 0x68, 0x85, 0x80, 0x68, 0xA8, 0x60, 0xC9, 0x24, + 0xD0, 0x05, 0x20, 0xDF, 0xFF, 0xB0, 0x23, 0xC9, 0x40, 0xD0, 0x0A, 0x84, + 0xC8, 0xA0, 0x00, 0xB1, 0xF8, 0xA4, 0xC8, 0xD0, 0x15, 0xC9, 0x28, 0xF0, + 0xA2, 0x20, 0x31, 0xFE, 0xA1, 0x00, 0x48, 0xF6, 0x00, 0xD0, 0x02, 0xF6, + 0x01, 0xA1, 0x00, 0x95, 0x01, 0x68, 0x95, 0x00, 0x60, 0xC9, 0x3A, 0xD0, + 0x11, 0x20, 0xBF, 0xFD, 0x16, 0x00, 0x36, 0x01, 0xA5, 0xCC, 0x95, 0x02, + 0xA5, 0xCD, 0x95, 0x03, 0xD0, 0x2D, 0x0A, 0x09, 0x80, 0x30, 0x72, 0xB5, + 0x00, 0x85, 0xFC, 0xB5, 0x01, 0x85, 0xFD, 0xA9, 0x00, 0x95, 0x00, 0x95, + 0x01, 0xA5, 0xFC, 0x05, 0xFD, 0xF0, 0x13, 0x46, 0xFD, 0x66, 0xFC, 0x90, + 0x03, 0x20, 0x73, 0xFE, 0x16, 0x02, 0x36, 0x03, 0xB5, 0x02, 0x15, 0x03, + 0xD0, 0xE7, 0x60, 0x18, 0xB5, 0x00, 0x75, 0x02, 0x95, 0x00, 0xB5, 0x01, + 0x75, 0x03, 0x95, 0x01, 0x60, 0xC9, 0x2B, 0xF0, 0xEE, 0xC9, 0x2A, 0xF0, + 0xC2, 0xC9, 0x2F, 0xF0, 0x77, 0xC9, 0x5B, 0xF0, 0x32, 0xC9, 0x5D, 0xF0, + 0x3C, 0xCA, 0xC9, 0x2D, 0xF0, 0x41, 0xC9, 0x7C, 0xF0, 0x52, 0xC9, 0x5E, + 0xF0, 0x58, 0xC9, 0x26, 0xF0, 0x40, 0x49, 0x3C, 0x85, 0xFC, 0x20, 0xDB, + 0xFE, 0xC6, 0xFC, 0xD0, 0x05, 0x15, 0x00, 0xF0, 0x04, 0x18, 0xA5, 0xFC, + 0x2A, 0x69, 0x00, 0x29, 0x01, 0x95, 0x00, 0xA9, 0x00, 0xF0, 0x20, 0xB5, + 0x00, 0x15, 0x01, 0xF0, 0x1C, 0xB5, 0x02, 0x95, 0x00, 0xB5, 0x03, 0xB0, + 0x12, 0xB5, 0x00, 0x15, 0x01, 0xF0, 0x9C, 0xA9, 0x00, 0xF0, 0xE2, 0x20, + 0xDF, 0xFE, 0xE8, 0xB5, 0x01, 0xF5, 0x03, 0x95, 0x01, 0x60, 0x20, 0xEA, + 0xFE, 0xE8, 0xB5, 0x01, 0x35, 0x03, 0xB0, 0xF3, 0x20, 0xF4, 0xFE, 0xE8, + 0xB5, 0x01, 0x15, 0x03, 0xB0, 0xE9, 0x20, 0xFE, 0xFE, 0xE8, 0xB5, 0x01, + 0x55, 0x03, 0xB0, 0xDF, 0xA9, 0x00, 0x85, 0xCA, 0x85, 0xCB, 0xA9, 0x10, + 0x85, 0xFC, 0x16, 0x00, 0x36, 0x01, 0x26, 0xCA, 0x26, 0xCB, 0xA5, 0xCA, + 0xD5, 0x02, 0xA5, 0xCB, 0xF5, 0x03, 0x90, 0x0A, 0x85, 0xCB, 0xA5, 0xCA, + 0xF5, 0x02, 0x85, 0xCA, 0xF6, 0x00, 0xC6, 0xFC, 0xD0, 0xE0, 0x60, 0xA9, + 0x00, 0x95, 0x00, 0x95, 0x01, 0x95, 0x03, 0x20, 0xC3, 0xFF, 0x84, 0xFE, + 0xB1, 0x80, 0x49, 0x30, 0xC9, 0x0A, 0xB0, 0x13, 0x48, 0xA9, 0x0A, 0x95, + 0x02, 0x20, 0x4B, 0xFE, 0x95, 0x03, 0x68, 0x95, 0x02, 0x20, 0x73, 0xFE, + 0xC8, 0x10, 0xE5, 0xC4, 0xFE, 0x60, 0xC9, 0x1B, 0xF0, 0x03, 0xC8, 0x10, + 0x10, 0x20, 0x39, 0xFD, 0xA0, 0x80, 0x84, 0x80, 0xA0, 0x17, 0x84, 0x81, + 0xA0, 0x01, 0x88, 0x30, 0xF0, 0x20, 0xDF, 0xFF, 0xC9, 0x08, 0xF0, 0xF6, + 0xC9, 0x0D, 0xD0, 0x02, 0xA9, 0x00, 0x91, 0x80, 0xD0, 0xD8, 0xA8, 0x60, + 0xA2, 0x02, 0xA9, 0x00, 0x90, 0x15, 0xA6, 0x81, 0xA0, 0x02, 0xA5, 0x80, + 0xC5, 0xCC, 0xA5, 0x81, 0xE5, 0xCD, 0xB0, 0x29, 0xA5, 0x80, 0x71, 0x80, + 0x90, 0x03, 0xE8, 0x86, 0x81, 0x85, 0x80, 0xA0, 0x00, 0xB1, 0x80, 0x85, + 0xD0, 0xC5, 0xC6, 0xC8, 0xB1, 0x80, 0x85, 0xD1, 0xE5, 0xC7, 0xC8, 0x90, + 0xD9, 0xA5, 0x80, 0xC5, 0xCC, 0xA5, 0x81, 0xE5, 0xCD, 0xA5, 0xD0, 0xA6, + 0xD1, 0x60, 0xC8, 0xB1, 0x80, 0xF0, 0x04, 0xC9, 0x20, 0xF0, 0xF7, 0x60, + 0xAD, 0xF5, 0xCF, 0xF0, 0x0D, 0xC9, 0x03, 0xF0, 0x13, 0xAD, 0xF5, 0xCF, + 0xF0, 0xFB, 0xC9, 0x03, 0xF0, 0x0A, 0x60, 0xAD, 0xF5, 0xCF, 0xF0, 0xFB, + 0xC9, 0x03, 0xD0, 0x03, 0x4C, 0x11, 0xFC, 0xC9, 0x0D, 0xD0, 0x07, 0xA9, + 0x0A, 0x8D, 0xF1, 0xCF, 0xA9, 0x0D, 0x8D, 0xF1, 0xCF, 0x38, 0x60 + +}; + +uint8_t read6502(uint16_t address) { + uint8_t tempval = 0; + + if (address < 0x0400) { // 0x0000-0x0400 is RAM + return(RAM[address]); + } + if (address < 0x0800) { + #ifdef AVRX + return(eepromread(address-0x0400)); // 0x0400-0x0800 is EEPROM for Arduino, + #else // ...but second RAM unit for PC + return(RAM2[address-0x0400]); + #endif + } // 0x0800-0x1700 is empty space, should not be read + if (address < 0x1700) { // read in empty space + serout('%'); serout('5'); // error code 5 - read in empty space + return(0); + } + if (address < 0x1740) { // 0x1700-0x1740 is IO space of RIOT 003 + serout('%'); serout('7'); // trap code 7 - read in I/O 003 + return(0); + } + if (address < 0x1780) { // 0x1740-0x1780 is IO space of RIOT 002 + if (address == 0x1747) return (0xFF); // CLKRDI =$1747,READ TIME OUT BIT,count is always complete... + if (address == 0x1740) return (useKeyboardLed); // returns 1 for Keyboard/LED or 0 for Serial terminal + serout('%'); serout('6'); // trap code 6 - read in I/O 002 + return(0); + } + if (address < 0x17C0) { // 0x1780-0x17C0 is RAM from RIOT 003 + return(RAM003[address-0x1780]); + } + if (address < 0x1800) { // 0x17C0-0x1800 is RAM from RIOT 002 + return(RAM002[address-0x17C0]); + } + if (address < 0x1C00) { // 0x1800-0x1C00 is ROM 003 + #ifdef AVRX + return(pgm_read_byte_near(rom003 + address - 0x1800)); + #else + return rom003[address - 0x1800]; + #endif + } + if (address < 0x2000) // 0x1C00-0x2000 is ROM 002. It needs some intercepting from emulator... + { + if (address == 0x1EA0) // intercept OUTCH (send char to serial) + { serout(a); // print A to serial + pc = 0x1ED3; // skip subroutine + return (0xEA); // and return from subroutine with a fake NOP instruction + } + if (address == 0x1E65) //intercept GETCH (get char from serial). used to be 0x1E5A, but intercept *within* routine just before get1 test + { a=getAkey(); // get A from main loop's curkey + if (a==0) { + pc=0x1E60; // cycle through GET1 loop for character start, let the 6502 runs through this loop in a fake way + return (0xEA); + } + clearkey(); + x = RAM[0x00FD]; // x is saved in TMPX by getch routine, we need to get it back in x; + pc = 0x1E87; // skip subroutine + return (0xEA); // and return from subroutine with a fake NOP instruction + } + if (address == 0x1C2A) // intercept DETCPS + { RAM002[0x17F3-0x17C0] = 1; // just store some random bps delay on TTY in CNTH30 + RAM002[0x17F2-0x17C0] = 1; // just store some random bps delay on TTY in CNTL30 + pc = 0x1C4F; // skip subroutine + return (0xEA); // and return from subroutine with a fake NOP instruction + } + if (address == 0x1F1F) // intercept SCANDS (display F9,FA,FB) + { + // light LEDs --------------------------------------------------------- + threeHex[0][0]= (RAM[0x00FB] & 0xF0) >> 4; + threeHex[0][1]= RAM[0x00FB] & 0xF; + threeHex[1][0]= (RAM[0x00FA] & 0xF0) >> 4; + threeHex[1][1]= RAM[0x00FA] & 0xF; + threeHex[2][0]= (RAM[0x00F9] & 0xF0) >> 4; + threeHex[2][1]= RAM[0x00F9] & 0xF; + + //#ifndef AVRX // remove this line to get led digits on serial for AVR too + serout(13); serout('>'); + for (iii=0;iii<3;iii++) + { serouthex(threeHex[iii][0]); serouthex(threeHex[iii][1]); serout(' '); + if (iii==1) serout (' '); + } + serout('<'); serout(13); + //#endif // remove this line to get led digits on serial for AVR too + #ifdef AVRX + driveLEDs(); + #endif + + pc = 0x1F45; // skip subroutine part that deals with LEDs + return (0xEA); // and return a fake NOP instruction for this first read in the subroutine, it'll now go to AK + } + if (address == 0x1EFE) // intercept AK (check for any key pressed) + { + a=getAkey(); // 0 means no key pressed - the important bit - but if a key is pressed is curkey the right value to send back? + //a= getKIMkey(); + if (a==0) a=0xFF; // that's how AK wants to see 'no key' + pc = 0x1F14; // skip subroutine + return (0xEA); // and return a fake NOP instruction for this first read in the subroutine, it'll now RTS at its end + } + if (address == 0x1F6A) // intercept GETKEY (get key from keyboard) + {// serout('-');serout('G');serout('K');serout('-'); + a=getKIMkey(); // curkey = the key code in the emulator's keyboard buffer + clearkey(); + pc = 0x1F90; // skip subroutine part that deals with LEDs + return (0xEA); // and return a fake NOP instruction for this first read in the subroutine, it'll now RTS at its end + } + // if we're still here, it's normal reading from the highest ROM 002. + #ifdef AVRX + return(pgm_read_byte_near(rom002 + address - 0x1C00)); // ROM 002 + #else + return rom002[address - 0x1C00]; + #endif + } + + if (address < 0x21F9) // 0x2000-0x21F8 is disasm + { + #ifdef AVRX + return(pgm_read_byte_near(disasm + address - 0x2000)); + #else + return disasm[address - 0x2000]; + #endif + } + + if ((address >= 0x5000) && (address <= 0x6FE3)) // 0x6FDF, plus 4 bytes for JSR manually added - Read to floating point library between $5000 and $6157 + { + #ifdef AVRX + return(pgm_read_byte_near(calcRom + address - 0xD000)); // mchess ROM + #else + return calcRom[address - 0x5000]; + #endif + } + if ((address>=0x7000) && (address <=0x7200)) // 6502 programmable calculator functions + { + switch (address) + { // 70Ax SERIES: ASK FOR A VALUE INTO REGISTER x + case 0x70A1: // Load W1 + enterflt((uint8_t)0); return(0x60); break; + case 0x70A2: // Load W2 + enterflt(1); return(0x60); break; + case 0x70A3: // Load W3 + enterflt(2); return(0x60); break; + case 0x70A4: // Load W4 + enterflt(3); return(0x60); break; + case 0x70AA: // Load A + a = enteroperation(); + serout(a); + if (a==0) + setzero(); + else + clearzero(); + return(0x60); + break; + + //70Dx SERIES: DISPLAY REGISTER x + case 0x70D1: // View W1 + showflt(0); return(0x60); break; + case 0x70D2: // View W2 + showflt(1); return(0x60); break; + case 0x70D3: // View W3 + showflt(2); return(0x60); break; + case 0x70D4: // View W4 + showflt(3); return(0x60); break; + + //71xy SERIES: SWAP REG x AND REG y + case 0x7113: // Swap W1-W3 + swapWreg(1,3); return(0x60); break; + case 0x7123: // Swap W2-W3 + swapWreg(2,3); return(0x60); break; + case 0x7114: // Swap W1-W4 + swapWreg(1,4); return(0x60); break; + case 0x7124: // Swap W2-W4 + swapWreg(2,4); return(0x60); break; + case 0x7112: // Swap W1-W2 + swapWreg(1,2); return(0x60); break; + case 0x7134: // Swap W3-W4 + swapWreg(3,4); return(0x60); break; + + //70xy SERIES: COPY REG x INTO REG y + case 0x7013: // Copy W1-W3 + copyWreg(1,3); return(0x60); break; + case 0x7023: // Copy W2-W3 + copyWreg(2,3); return(0x60); break; + + case 0x7031: // Copy W3-W1 +// serout('C'); + copyWreg(3,1); return(0x60); break; + case 0x7032: // Copy W3-W2 + copyWreg(3,2); return(0x60); break; + + + case 0x7014: // Copy W1-W4 + copyWreg(1,4); return(0x60); break; + case 0x7024: // Copy W2-W4 + copyWreg(2,4); return(0x60); break; + case 0x7034: // Copy W3-W4 + copyWreg(3,4); return(0x60); break; + + case 0x7041: // Copy W4-W1 + copyWreg(4,1); return(0x60); break; + case 0x7042: // Copy W4-W2 + copyWreg(4,2); return(0x60); break; + case 0x7043: // Copy W4-W3 + copyWreg(4,3); return(0x60); break; + + default: + serout('%'); serout('A'); // error code on serial port to warn of illegal address read + return (0x00); // DO A brk TO HALT PROGRAM IF ANY OTHER ADDRESS IS CALLED + } + } + + + if (address >= 0xC000 && address <=0xC571) // Read to Microchess ROM between $C000 and $C571 + { + if (address == 0xC202) // intercept C202: Blitz mode should return 0 instead of 8 + if (blitzMode==1) // This is the Blitz mode hack from the microchess manual. + return((uint8_t) 0x00); + + #ifdef AVRX + return(pgm_read_byte_near(mchess + address - 0xC000)); // mchess ROM + #else + return mchess[address - 0xC000]; + #endif + } + // I/O functions just for Microchess: --------------------------------------------------- + // $CFF3: 0 = no key pressed, 1 key pressed + // $CFF4: input from user + // (also, in write6502: $F001: output character to display) + if (address == 0xCFF4) //simulated keyboard input + { tempval = getAkey(); + clearkey(); + // translate KIM-1 button codes into ASCII code expected by this version of Microchess + switch (tempval) + { case 16: tempval = 'P'; break; // PC translated to P + case 'F': tempval = 13; break; // F translated to Return + case '+': tempval = 'W'; break; // + translated to W meaning Blitz mode toggle + } + if (tempval==0x57) // 'W'. If user presses 'W', he wants to enable Blitz mode. + { if (blitzMode==1) (blitzMode=0); + else (blitzMode=1); + serout('>'); serout( (blitzMode==1)?'B':'N' ); serout('<'); + } + return(tempval); + } + if (address == 0xCFF3) //simulated keyboard input 0=no key press, 1 = key press + { + // light LEDs --------------------------------------------------------- + threeHex[0][0]= (RAM[0x00FB] & 0xF0) >> 4; + threeHex[0][1]= RAM[0x00FB] & 0xF; + threeHex[1][0]= (RAM[0x00FA] & 0xF0) >> 4; + threeHex[1][1]= RAM[0x00FA] & 0xF; + threeHex[2][0]= (RAM[0x00F9] & 0xF0) >> 4; + threeHex[2][1]= RAM[0x00F9] & 0xF; + #ifdef AVRX + driveLEDs(); + #endif + + return(getAkey()==0?(uint8_t)0:(uint8_t)1); + } + +// inserted (hacked in) for VTL-02: CFF5 is CFF4 without Microchess key translations +if (address == 0xCFF5) //simulated keyboard input + { tempval = getAkey(); + clearkey(); + return(tempval); + } +// -------------------------------- + + if ((address >= 0xFC00) && (address <= 0xFFFA)) // VTL-02 + { + #ifdef AVRX + return(pgm_read_byte_near(vtl + address - 0xFC00)); // VTL-02 ROM + #else + return calcRom[vtl - 0x5000]; + #endif + } + + + if (address >= 0xFFFA) { // 6502 reset and interrupt vectors. Reroute to top of ROM002. + #ifdef AVRX + return(pgm_read_byte_near(rom002 + address - 0xFC00)); + #else + return rom002[address - 0xFC00]; + #endif + } +/* + if (address == 0x1D11) // intercept specific address for debug inspection + { + serout(':'); serout(x); serout(';'); + } +*/ + serout('%'); serout('9'); + return (0); // This should never be reached unless some addressing bug, so return 6502 BRK +} + + +void write6502(uint16_t address, uint8_t value) +{ + if (address < 0x0400) { + RAM[address]=value; + return; + } + if (address < 0x0800) { + #ifdef AVRX + eepromwrite(address-0x0400, value); // 0x0500-0x0900 is EEPROM for Arduino, + #else + RAM2[address-0x0400]=value; // ...but second RAM unit for PC + #endif + return; + } + if (address < 0x1700) { // illegal access + serout('%'); serout('1'); // error code 1 - write in empty space + return; + } + if (address < 0x1740) { // I/O 003 + serout('%'); serout('3'); // trap code 3 - io3 access + return; + } + if (address < 0x1780) { // I/O 002 +// serout('%'); serout('2'); // trap code 2 - io2 access + return; + } + if (address < 0x17C0) { // RAM 003 + RAM003[address-0x1780]=value; + return; + } + if (address < 0x1800) { // RAM002 + RAM002[address-0x17C0]=value; + return; + } + + if ((address >=0x5000) && (address <=0x6FDF)) { // illegal write in fltpt65 ROM +// printf("WARNING: WRITE TO ROM\n"); + serout('%'); serout('a'); + return; + } + + // Character out function for microchess only: write to display at $F001 + if (address == 0xCFF1) { // Character out for microchess only + serout(value); + return; + } + serout('%'); serout('4'); // error code 4 - write to ROM +} + +// two functions for fltpt65 support: copy/swap W registers +void copyWreg(uint8_t a, uint8_t b) +{ + uint8_t i; + for (i=0;i<8;i++) + RAM[WREG_OFFSET+8*(b-1)+i] = RAM[WREG_OFFSET+8*(a-1)+i]; +} +void swapWreg(uint8_t a, uint8_t b) +{ + uint8_t i, buffer; + for (i=0;i<8;i++) + { buffer = RAM[WREG_OFFSET+8*(a-1)+i]; + RAM[WREG_OFFSET+8*(a-1)+i] = RAM[WREG_OFFSET+8*(b-1)+i]; + RAM[WREG_OFFSET+8*(b-1)+i] = buffer; + } +} + +//a few general functions used by various other functions +void push16(uint16_t pushval) { + write6502(BASE_STACK + sp, (pushval >> 8) & 0xFF); + write6502(BASE_STACK + ((sp - 1) & 0xFF), pushval & 0xFF); + sp -= 2; +} + +void push8(uint8_t pushval) { + write6502(BASE_STACK + sp--, pushval); +} + +uint16_t pull16() { + uint16_t temp16; + temp16 = read6502(BASE_STACK + ((sp + 1) & 0xFF)) | ((uint16_t)read6502(BASE_STACK + ((sp + 2) & 0xFF)) << 8); + sp += 2; + return(temp16); +} + +uint8_t pull8() { + return (read6502(BASE_STACK + ++sp)); +} + +void reset6502() { +//printf ("test at reset: %x %x\n",0xFFFC, 0xFFFD); + + pc = (uint16_t)read6502(0xFFFC) | ((uint16_t)read6502(0xFFFD) << 8); +//pc = 0x1C22; +// printf ("pc: %x\n",pc); + a = 0; + x = 0; + y = 0; + sp = 0xFD; + cpustatus |= FLAG_CONSTANT; +} + +void initKIM() { // this is what user has to enter manually when powering KIM on. Why not do it here. + + uint16_t i; + + RAM002[(0x17FA)-(0x17C0)]=0x00; + RAM002[(0x17FB)-(0x17C0)]=0x1C; + RAM002[(0x17FE)-(0x17C0)]=0x00; + RAM002[(0x17FF)-(0x17C0)]=0x1C; + + // the code below copies movit (a copy routine) to 0x1780 in RAM. It can be overwritten by users - it's an extra + // note that the HTML version of the book contains OR scan codes, so don't take the bytes from there! + for (i=0;i<64;i++) { //64 of 102 program bytes + #ifdef AVRX + RAM003[i] = pgm_read_byte_near(movit + i); + #else + RAM003[i] = movit[i]; + #endif + } + for (i=0;i<(95-64);i++) { // movit spans into the second 64 byte memory segment... + #ifdef AVRX + RAM002[i] = pgm_read_byte_near(movit + i + 64); + #else + RAM002[i] = movit[i+64]; + #endif + } + + // the code below copies relocate to 0x0110 in RAM. It can be overwritten by users or by the stack pointer - it's an extra + for (i=0;i<149;i++) { + #ifdef AVRX + RAM[i+0x0110] = pgm_read_byte_near(relocate + i); + #else + RAM[i+0x0110] = relocate[i]; + #endif + } + + // the code below copies branch to 0x01A5 (not 0x17C0 anymore) in RAM. It can be overwritten by users - it's an extra + // note: the program can easily be damaged by the stack, because it ends at 1CF. Still, the monitor brings the stack down to no worse than 0x1FF-8. + for (i=0;i<42;i++) { + #ifdef AVRX + //RAM002[i] = pgm_read_byte_near(branch + i); + RAM[i+0x01A5] = pgm_read_byte_near(branch + i); + #else + //RAM002[i] = branch[i]; + RAM[i+0x01A5] = branch[i]; + #endif + } + +} + +void loadTestProgram() { // Call this from main() if you want a program preloaded. It's the first program from First Book of KIM... + uint8_t i; + + // the first program from First Book of KIM... + uint8_t fbkDemo[9] = { + 0xA5, 0x10, 0xA6, 0x11, 0x85, 0x11, 0x86, 0x10, 0x00 }; + for (i=0;i<9;i++) + RAM[i+0x0200]=fbkDemo[i]; + RAM[0x0010] = 0x10; + RAM[0x0011] = 0x11; + + // load fltpt65 demo program + uint8_t fltptDemo[31] = { + 0x20, 0xA1, 0x70, 0x20, 0xA2, 0x70, 0xA9, 0x02, 0x20, 0x00, 0x50, 0x20, 0xD3, 0x70, + 0x20, 0xAA, 0x70, + 0xF0, 0x08, + 0x20, 0x31, 0x70, 0xA9, 0x04, 0x20, 0x00, 0x50, 0x20, 0xD3, 0x70, 0x00 + }; + for (i=0x0;i<31;i++) + RAM[i+0x0210]=fltptDemo[i]; + +/* org=$0210 +JSR $6FF1 +JSR $6FF2 + +LDA #$02 +JSR $5000 +JSR $6FE3 +JSR $6FC1 +LDA #$04 + +JSR $5000 + +JSR $6FE3 +BRK */ + +/* uint8_t helloworld[0x28] = { // test program for Serial, prints hello world + 0xAE, 0x13, 0x02, 0xCA, 0x8E, 0x13, 0x02, 0xBD, + 0x14, 0x02, 0x20, 0xA0, 0x1E, 0xEC, 0x00, 0x00, + 0xD0, 0xEE, 0x00, 0x13, 0x0D, 0x0A, 0x0D, 0x0A, + 0x64, 0x6C, + 0x72, 0x6F, 0x77, 0x20, 0x2C, 0x6F, 0x6C, 0x6C, 0x65, 0x48, + 0x0D, 0x0A, 0x0D, 0x0A }; + + for (int iii=0x0200; iii<0x0224;iii++) + RAM[iii]=helloworld[iii-0x0200]; +*/ +} + +//addressing mode functions, calculates effective addresses +void imp() { //implied +} + +void acc() { //accumulator + useaccum = 1; +} + +void imm() { //immediate + ea = pc++; +} + +void zp() { //zero-page + ea = (uint16_t)read6502((uint16_t)pc++); +} + +void zpx() { //zero-page,X + ea = ((uint16_t)read6502((uint16_t)pc++) + (uint16_t)x) & 0xFF; //zero-page wraparound +} + +void zpy() { //zero-page,Y + ea = ((uint16_t)read6502((uint16_t)pc++) + (uint16_t)y) & 0xFF; //zero-page wraparound +} + +void rel() { //relative for branch ops (8-bit immediate value, sign-extended) + reladdr = (uint16_t)read6502(pc++); + if (reladdr & 0x80) reladdr |= 0xFF00; +} + +void abso() { //absolute + ea = (uint16_t)read6502(pc) | ((uint16_t)read6502(pc+1) << 8); + pc += 2; +} + +void absx() { //absolute,X + uint16_t startpage; + ea = ((uint16_t)read6502(pc) | ((uint16_t)read6502(pc+1) << 8)); + startpage = ea & 0xFF00; + ea += (uint16_t)x; + + pc += 2; +} + +void absy() { //absolute,Y + uint16_t startpage; + ea = ((uint16_t)read6502(pc) | ((uint16_t)read6502(pc+1) << 8)); + startpage = ea & 0xFF00; + ea += (uint16_t)y; + + pc += 2; +} + +void ind() { //indirect + uint16_t eahelp, eahelp2; + eahelp = (uint16_t)read6502(pc) | (uint16_t)((uint16_t)read6502(pc+1) << 8); + eahelp2 = (eahelp & 0xFF00) | ((eahelp + 1) & 0x00FF); //replicate 6502 page-boundary wraparound bug + ea = (uint16_t)read6502(eahelp) | ((uint16_t)read6502(eahelp2) << 8); + pc += 2; +} + +void indx() { // (indirect,X) + uint16_t eahelp; + eahelp = (uint16_t)(((uint16_t)read6502(pc++) + (uint16_t)x) & 0xFF); //zero-page wraparound for table pointer + ea = (uint16_t)read6502(eahelp & 0x00FF) | ((uint16_t)read6502((eahelp+1) & 0x00FF) << 8); +} + +void indy() { // (indirect),Y + uint16_t eahelp, eahelp2, startpage; + eahelp = (uint16_t)read6502(pc++); + eahelp2 = (eahelp & 0xFF00) | ((eahelp + 1) & 0x00FF); //zero-page wraparound + ea = (uint16_t)read6502(eahelp) | ((uint16_t)read6502(eahelp2) << 8); + startpage = ea & 0xFF00; + ea += (uint16_t)y; + +} + +static uint16_t getvalue() { + if (useaccum) return((uint16_t)a); + else return((uint16_t)read6502(ea)); +} + +/*static uint16_t getvalue16() { + return((uint16_t)read6502(ea) | ((uint16_t)read6502(ea+1) << 8)); +}*/ + +void putvalue(uint16_t saveval) { + if (useaccum) a = (uint8_t)(saveval & 0x00FF); + else write6502(ea, (saveval & 0x00FF)); +} + + +//instruction handler functions +void adc() { + value = getvalue(); + +// BCD fix OV 20140915 - adc + if ((cpustatus & FLAG_DECIMAL)==0) { + result = (uint16_t)a + value + (uint16_t)(cpustatus & FLAG_CARRY); + + carrycalc(result); + zerocalc(result); + overflowcalc(result, a, value); + signcalc(result); + } + else // #ifndef NES_CPU + { // Decimal mode + lxx = (a & 0x0f) + (value & 0x0f) + (uint16_t)(cpustatus & FLAG_CARRY); + if ((lxx & 0xFF) > 0x09) + lxx += 0x06; + hxx = (a >> 4) + (value >> 4) + (lxx > 15 ? 1 : 0); + if ((hxx & 0xff) > 9) + hxx += 6; + result = (lxx & 0x0f); + result += (hxx << 4); + result &= 0xff; + // deal with carry flag: + if (hxx>15) + setcarry(); + else + clearcarry(); + zerocalc(result); + clearsign(); // negative flag never set for decimal mode. + clearoverflow(); // overflow never set for decimal mode. +// end of BCD fix PART 2 + + clockticks6502++; + } +// #endif // of NES_CPU + + saveaccum(result); +} + +void op_and() { + value = getvalue(); + result = (uint16_t)a & value; + + zerocalc(result); + signcalc(result); + + saveaccum(result); +} + +void asl() { + value = getvalue(); + result = value << 1; + + carrycalc(result); + zerocalc(result); + signcalc(result); + + putvalue(result); +} + +void bcc() { + if ((cpustatus & FLAG_CARRY) == 0) { + oldpc = pc; + pc += reladdr; + if ((oldpc & 0xFF00) != (pc & 0xFF00)) clockticks6502 += 2; //check if jump crossed a page boundary + else clockticks6502++; + } +} + +void bcs() { + if ((cpustatus & FLAG_CARRY) == FLAG_CARRY) { + oldpc = pc; + pc += reladdr; + if ((oldpc & 0xFF00) != (pc & 0xFF00)) clockticks6502 += 2; //check if jump crossed a page boundary + else clockticks6502++; + } +} + +void beq() { + if ((cpustatus & FLAG_ZERO) == FLAG_ZERO) { + oldpc = pc; + pc += reladdr; + if ((oldpc & 0xFF00) != (pc & 0xFF00)) clockticks6502 += 2; //check if jump crossed a page boundary + else clockticks6502++; + } +} + +void op_bit() { + value = getvalue(); + result = (uint16_t)a & value; + + zerocalc(result); + cpustatus = (cpustatus & 0x3F) | (uint8_t)(value & 0xC0); +} + +void bmi() { + if ((cpustatus & FLAG_SIGN) == FLAG_SIGN) { + oldpc = pc; + pc += reladdr; + if ((oldpc & 0xFF00) != (pc & 0xFF00)) clockticks6502 += 2; //check if jump crossed a page boundary + else clockticks6502++; + } +} + +void bne() { + if ((cpustatus & FLAG_ZERO) == 0) { + oldpc = pc; + pc += reladdr; + if ((oldpc & 0xFF00) != (pc & 0xFF00)) clockticks6502 += 2; //check if jump crossed a page boundary + else clockticks6502++; + } +} + +void bpl() { + if ((cpustatus & FLAG_SIGN) == 0) { + oldpc = pc; + pc += reladdr; + if ((oldpc & 0xFF00) != (pc & 0xFF00)) clockticks6502 += 2; //check if jump crossed a page boundary + else clockticks6502++; + } +} + +void brk() { + pc++; + push16(pc); //push next instruction address onto stack + push8(cpustatus | FLAG_BREAK); //push CPU cpustatus to stack + setinterrupt(); //set interrupt flag + pc = (uint16_t)read6502(0xFFFE) | ((uint16_t)read6502(0xFFFF) << 8); +} + +void bvc() { + if ((cpustatus & FLAG_OVERFLOW) == 0) { + oldpc = pc; + pc += reladdr; + if ((oldpc & 0xFF00) != (pc & 0xFF00)) clockticks6502 += 2; //check if jump crossed a page boundary + else clockticks6502++; + } +} + +void bvs() { + if ((cpustatus & FLAG_OVERFLOW) == FLAG_OVERFLOW) { + oldpc = pc; + pc += reladdr; + if ((oldpc & 0xFF00) != (pc & 0xFF00)) clockticks6502 += 2; //check if jump crossed a page boundary + else clockticks6502++; + } +} + +void clc() { + clearcarry(); +} + +void cld() { + cleardecimal(); +} + +void cli() { + clearinterrupt(); +} + +void clv() { + clearoverflow(); +} + +void cmp() { + value = getvalue(); + result = (uint16_t)a - value; + + if (a >= (uint8_t)(value & 0x00FF)) setcarry(); + else clearcarry(); + if (a == (uint8_t)(value & 0x00FF)) setzero(); + else clearzero(); + signcalc(result); +} + +void cpx() { + value = getvalue(); + result = (uint16_t)x - value; + + if (x >= (uint8_t)(value & 0x00FF)) setcarry(); + else clearcarry(); + if (x == (uint8_t)(value & 0x00FF)) setzero(); + else clearzero(); + signcalc(result); +} + +void cpy() { + value = getvalue(); + result = (uint16_t)y - value; + + if (y >= (uint8_t)(value & 0x00FF)) setcarry(); + else clearcarry(); + if (y == (uint8_t)(value & 0x00FF)) setzero(); + else clearzero(); + signcalc(result); +} + +void dec() { + value = getvalue(); + result = value - 1; + + zerocalc(result); + signcalc(result); + + putvalue(result); +} + +void dex() { + x--; + + zerocalc(x); + signcalc(x); +} + +void dey() { + y--; + + zerocalc(y); + signcalc(y); +} + +void eor() { + value = getvalue(); + result = (uint16_t)a ^ value; + + zerocalc(result); + signcalc(result); + + saveaccum(result); +} + +void inc() { + value = getvalue(); + result = value + 1; + + zerocalc(result); + signcalc(result); + + putvalue(result); +} + +void inx() { + x++; + + zerocalc(x); + signcalc(x); +} + +void iny() { + y++; + + zerocalc(y); + signcalc(y); +} + +void jmp() { + pc = ea; +} + +void jsr() { + push16(pc - 1); + pc = ea; +} + +void lda() { + value = getvalue(); + a = (uint8_t)(value & 0x00FF); + + zerocalc(a); + signcalc(a); +} + +void ldx() { + value = getvalue(); + x = (uint8_t)(value & 0x00FF); + + zerocalc(x); + signcalc(x); +} + +void ldy() { + value = getvalue(); + y = (uint8_t)(value & 0x00FF); + + zerocalc(y); + signcalc(y); +} + +void lsr() { + value = getvalue(); + result = value >> 1; + + if (value & 1) setcarry(); + else clearcarry(); + zerocalc(result); + signcalc(result); + + putvalue(result); +} + +void nop() { +} + +void ora() { + value = getvalue(); + result = (uint16_t)a | value; + + zerocalc(result); + signcalc(result); + + saveaccum(result); +} + +void pha() { + push8(a); +} + +void php() { + push8(cpustatus | FLAG_BREAK); +} + +void pla() { + a = pull8(); + + zerocalc(a); + signcalc(a); +} + +void plp() { + cpustatus = pull8() | FLAG_CONSTANT; +} + +void rol() { + value = getvalue(); + result = (value << 1) | (cpustatus & FLAG_CARRY); + + carrycalc(result); + zerocalc(result); + signcalc(result); + + putvalue(result); +} + +void ror() { + value = getvalue(); + result = (value >> 1) | ((cpustatus & FLAG_CARRY) << 7); + + if (value & 1) setcarry(); + else clearcarry(); + zerocalc(result); + signcalc(result); + + putvalue(result); +} + +void rti() { + cpustatus = pull8(); + value = pull16(); + pc = value; +} + +void rts() { + value = pull16(); + pc = value + 1; +} + +void sbc() { +// BCD fix OV 20140915 - adc + if ((cpustatus & FLAG_DECIMAL)==0) { + value = getvalue() ^ 0x00FF; + result = (uint16_t)a + value + (uint16_t)(cpustatus & FLAG_CARRY); + + carrycalc(result); + zerocalc(result); + overflowcalc(result, a, value); + signcalc(result); + } + else // #ifndef NES_CPU + { // decimal mode + value = getvalue(); + lxx = (a & 0x0f) - (value & 0x0f) - (uint16_t)((cpustatus & FLAG_CARRY)?0:1); + if ((lxx & 0x10) != 0) + lxx -= 6; + hxx = (a >> 4) - (value >> 4) - ((lxx & 0x10) != 0 ? 1 : 0); + if ((hxx & 0x10) != 0) + hxx -= 6; + result = (lxx & 0x0f); + result += (hxx << 4); + result = (lxx & 0x0f) | (hxx << 4); + // deal with carry + if ((hxx & 0xff) < 15) + setcarry(); // right? I think so. Intended is setCarryFlag((hxx & 0xff) < 15); + else + clearcarry(); + zerocalc(result); // zero dec is zero hex, no problem? + clearsign(); // negative flag never set for decimal mode. That's a simplification, see http://www.6502.org/tutorials/decimal_mode.html + clearoverflow(); // overflow never set for decimal mode. + result = result & 0xff; +// end of BCD fix PART 3 (final part) + + clockticks6502++; + } +// #endif // of NES_CPU + + saveaccum(result); +} + +void sec() { + setcarry(); +} + +void sed() { + setdecimal(); +} + +void sei() { + setinterrupt(); +} + +void sta() { + putvalue(a); +} + +void stx() { + putvalue(x); +} + +void sty() { + putvalue(y); +} + +void tax() { + x = a; + + zerocalc(x); + signcalc(x); +} + +void tay() { + y = a; + + zerocalc(y); + signcalc(y); +} + +void tsx() { + x = sp; + + zerocalc(x); + signcalc(x); +} + +void txa() { + a = x; + + zerocalc(a); + signcalc(a); +} + +void txs() { + sp = x; +} + +void tya() { + a = y; + + zerocalc(a); + signcalc(a); +} + +//undocumented instructions +#ifdef UNDOCUMENTED + void lax() { + lda(); + ldx(); + } + + void sax() { + sta(); + stx(); + putvalue(a & x); + } + + void dcp() { + dec(); + cmp(); + } + + void isb() { + inc(); + sbc(); + } + + void slo() { + asl(); + ora(); + } + + void rla() { + rol(); + op_and(); + } + + void sre() { + lsr(); + eor(); + } + + void rra() { + ror(); + adc(); + } +#else + #define lax nop + #define sax nop + #define dcp nop + #define isb nop + #define slo nop + #define rla nop + #define sre nop + #define rra nop +#endif + + +void nmi6502() { + push16(pc); + push8(cpustatus); + cpustatus |= FLAG_INTERRUPT; +pc = (uint16_t)read6502(0xFFFA) | ((uint16_t)read6502(0xFFFB) << 8); +pc = 0x1C1C; +} + +void irq6502() { + push16(pc); + push8(cpustatus); + cpustatus |= FLAG_INTERRUPT; + pc = (uint16_t)read6502(0xFFFE) | ((uint16_t)read6502(0xFFFF) << 8); +// pc = 0x1C1F; +} + +#ifdef USE_TIMING +prog_char ticktable[256] PROGMEM = { +/* | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | A | B | C | D | E | F | */ +/* 0 */ 7, 6, 2, 8, 3, 3, 5, 5, 3, 2, 2, 2, 4, 4, 6, 6, /* 0 */ +/* 1 */ 2, 5, 2, 8, 4, 4, 6, 6, 2, 4, 2, 7, 4, 4, 7, 7, /* 1 */ +/* 2 */ 6, 6, 2, 8, 3, 3, 5, 5, 4, 2, 2, 2, 4, 4, 6, 6, /* 2 */ +/* 3 */ 2, 5, 2, 8, 4, 4, 6, 6, 2, 4, 2, 7, 4, 4, 7, 7, /* 3 */ +/* 4 */ 6, 6, 2, 8, 3, 3, 5, 5, 3, 2, 2, 2, 3, 4, 6, 6, /* 4 */ +/* 5 */ 2, 5, 2, 8, 4, 4, 6, 6, 2, 4, 2, 7, 4, 4, 7, 7, /* 5 */ +/* 6 */ 6, 6, 2, 8, 3, 3, 5, 5, 4, 2, 2, 2, 5, 4, 6, 6, /* 6 */ +/* 7 */ 2, 5, 2, 8, 4, 4, 6, 6, 2, 4, 2, 7, 4, 4, 7, 7, /* 7 */ +/* 8 */ 2, 6, 2, 6, 3, 3, 3, 3, 2, 2, 2, 2, 4, 4, 4, 4, /* 8 */ +/* 9 */ 2, 6, 2, 6, 4, 4, 4, 4, 2, 5, 2, 5, 5, 5, 5, 5, /* 9 */ +/* A */ 2, 6, 2, 6, 3, 3, 3, 3, 2, 2, 2, 2, 4, 4, 4, 4, /* A */ +/* B */ 2, 5, 2, 5, 4, 4, 4, 4, 2, 4, 2, 4, 4, 4, 4, 4, /* B */ +/* C */ 2, 6, 2, 8, 3, 3, 5, 5, 2, 2, 2, 2, 4, 4, 6, 6, /* C */ +/* D */ 2, 5, 2, 8, 4, 4, 6, 6, 2, 4, 2, 7, 4, 4, 7, 7, /* D */ +/* E */ 2, 6, 2, 8, 3, 3, 5, 5, 2, 2, 2, 2, 4, 4, 6, 6, /* E */ +/* F */ 2, 5, 2, 8, 4, 4, 6, 6, 2, 4, 2, 7, 4, 4, 7, 7 /* F */ +}; +#endif + +void exec6502(int32_t tickcount) { +#ifdef USE_TIMING + clockgoal6502 += tickcount; + + while (clockgoal6502 > 0) { +#else + while (tickcount--) { +#endif + +#ifdef DEBUGUNO + debugPC = pc; + int ii=0; + +#endif + +// part 1 of single stepping using NMI + if ((SSTmode==1) & (pc<0x1C00)) // no mni if running ROM code (K7), that would also single-step the monitor code! + nmiFlag=1; // handled after this instruction has completed. +// ------------- + + opcode = read6502(pc++); + cpustatus |= FLAG_CONSTANT; + + useaccum = 0; + + switch (opcode) { + case 0x0: + imp(); + brk(); + break; + case 0x1: + indx(); + ora(); + break; + case 0x5: + zp(); + ora(); + break; + case 0x6: + zp(); + asl(); + break; + case 0x8: + imp(); + php(); + break; + case 0x9: + imm(); + ora(); + break; + case 0xA: + acc(); + asl(); + break; + case 0xD: + abso(); + ora(); + break; + case 0xE: + abso(); + asl(); + break; + case 0x10: + rel(); + bpl(); + break; + case 0x11: + indy(); + ora(); + break; + case 0x15: + zpx(); + ora(); + break; + case 0x16: + zpx(); + asl(); + break; + case 0x18: + imp(); + clc(); + break; + case 0x19: + absy(); + ora(); + break; + case 0x1D: + absx(); + ora(); + break; + case 0x1E: + absx(); + asl(); + break; + case 0x20: + abso(); + jsr(); + break; + case 0x21: + indx(); + op_and(); + break; + case 0x24: + zp(); + op_bit(); + break; + case 0x25: + zp(); + op_and(); + break; + case 0x26: + zp(); + rol(); + break; + case 0x28: + imp(); + plp(); + break; + case 0x29: + imm(); + op_and(); + break; + case 0x2A: + acc(); + rol(); + break; + case 0x2C: + abso(); + op_bit(); + break; + case 0x2D: + abso(); + op_and(); + break; + case 0x2E: + abso(); + rol(); + break; + case 0x30: + rel(); + bmi(); + break; + case 0x31: + indy(); + op_and(); + break; + case 0x35: + zpx(); + op_and(); + break; + case 0x36: + zpx(); + rol(); + break; + case 0x38: + imp(); + sec(); + break; + case 0x39: + absy(); + op_and(); + break; + case 0x3D: + absx(); + op_and(); + break; + case 0x3E: + absx(); + rol(); + break; + case 0x40: + imp(); + rti(); + break; + case 0x41: + indx(); + eor(); + break; + case 0x45: + zp(); + eor(); + break; + case 0x46: + zp(); + lsr(); + break; + case 0x48: + imp(); + pha(); + break; + case 0x49: + imm(); + eor(); + break; + case 0x4A: + acc(); + lsr(); + break; + case 0x4C: + abso(); + jmp(); + break; + case 0x4D: + abso(); + eor(); + break; + case 0x4E: + abso(); + lsr(); + break; + case 0x50: + rel(); + bvc(); + break; + case 0x51: + indy(); + eor(); + break; + case 0x55: + zpx(); + eor(); + break; + case 0x56: + zpx(); + lsr(); + break; + case 0x58: + imp(); + cli(); + break; + case 0x59: + absy(); + eor(); + break; + case 0x5D: + absx(); + eor(); + break; + case 0x5E: + absx(); + lsr(); + break; + case 0x60: + imp(); + rts(); + break; + case 0x61: + indx(); + adc(); + break; + case 0x65: + zp(); + adc(); + break; + case 0x66: + zp(); + ror(); + break; + case 0x68: + imp(); + pla(); + break; + case 0x69: + imm(); + adc(); + break; + case 0x6A: + acc(); + ror(); + break; + case 0x6C: + ind(); + jmp(); + break; + case 0x6D: + abso(); + adc(); + break; + case 0x6E: + abso(); + ror(); + break; + case 0x70: + rel(); + bvs(); + break; + case 0x71: + indy(); + adc(); + break; + case 0x75: + zpx(); + adc(); + break; + case 0x76: + zpx(); + ror(); + break; + case 0x78: + imp(); + sei(); + break; + case 0x79: + absy(); + adc(); + break; + case 0x7D: + absx(); + adc(); + break; + case 0x7E: + absx(); + ror(); + break; + case 0x81: + indx(); + sta(); + break; + case 0x84: + zp(); + sty(); + break; + case 0x85: + zp(); + sta(); + break; + case 0x86: + zp(); + stx(); + break; + case 0x88: + imp(); + dey(); + break; + case 0x8A: + imp(); + txa(); + break; + case 0x8C: + abso(); + sty(); + break; + case 0x8D: + abso(); + sta(); + break; + case 0x8E: + abso(); + stx(); + break; + case 0x90: + rel(); + bcc(); + break; + case 0x91: + indy(); + sta(); + break; + case 0x94: + zpx(); + sty(); + break; + case 0x95: + zpx(); + sta(); + break; + case 0x96: + zpy(); + stx(); + break; + case 0x98: + imp(); + tya(); + break; + case 0x99: + absy(); + sta(); + break; + case 0x9A: + imp(); + txs(); + break; + case 0x9D: + absx(); + sta(); + break; + case 0xA0: + imm(); + ldy(); + break; + case 0xA1: + indx(); + lda(); + break; + case 0xA2: + imm(); + ldx(); + break; + case 0xA4: + zp(); + ldy(); + break; + case 0xA5: + zp(); + lda(); + break; + case 0xA6: + zp(); + ldx(); + break; + case 0xA8: + imp(); + tay(); + break; + case 0xA9: + imm(); + lda(); + break; + case 0xAA: + imp(); + tax(); + break; + case 0xAC: + abso(); + ldy(); + break; + case 0xAD: + abso(); + lda(); + break; + case 0xAE: + abso(); + ldx(); + break; + case 0xB0: + rel(); + bcs(); + break; + case 0xB1: + indy(); + lda(); + break; + case 0xB4: + zpx(); + ldy(); + break; + case 0xB5: + zpx(); + lda(); + break; + case 0xB6: + zpy(); + ldx(); + break; + case 0xB8: + imp(); + clv(); + break; + case 0xB9: + absy(); + lda(); + break; + case 0xBA: + imp(); + tsx(); + break; + case 0xBC: + absx(); + ldy(); + break; + case 0xBD: + absx(); + lda(); + break; + case 0xBE: + absy(); + ldx(); + break; + case 0xC0: + imm(); + cpy(); + break; + case 0xC1: + indx(); + cmp(); + break; + case 0xC4: + zp(); + cpy(); + break; + case 0xC5: + zp(); + cmp(); + break; + case 0xC6: + zp(); + dec(); + break; + case 0xC8: + imp(); + iny(); + break; + case 0xC9: + imm(); + cmp(); + break; + case 0xCA: + imp(); + dex(); + break; + case 0xCC: + abso(); + cpy(); + break; + case 0xCD: + abso(); + cmp(); + break; + case 0xCE: + abso(); + dec(); + break; + case 0xD0: + rel(); + bne(); + break; + case 0xD1: + indy(); + cmp(); + break; + case 0xD5: + zpx(); + cmp(); + break; + case 0xD6: + zpx(); + dec(); + break; + case 0xD8: + imp(); + cld(); + break; + case 0xD9: + absy(); + cmp(); + break; + case 0xDD: + absx(); + cmp(); + break; + case 0xDE: + absx(); + dec(); + break; + case 0xE0: + imm(); + cpx(); + break; + case 0xE1: + indx(); + sbc(); + break; + case 0xE4: + zp(); + cpx(); + break; + case 0xE5: + zp(); + sbc(); + break; + case 0xE6: + zp(); + inc(); + break; + case 0xE8: + imp(); + inx(); + break; + case 0xE9: + imm(); + sbc(); + break; + case 0xEB: + imm(); + sbc(); + break; + case 0xEC: + abso(); + cpx(); + break; + case 0xED: + abso(); + sbc(); + break; + case 0xEE: + abso(); + inc(); + break; + case 0xF0: + rel(); + beq(); + break; + case 0xF1: + indy(); + sbc(); + break; + case 0xF5: + zpx(); + sbc(); + break; + case 0xF6: + zpx(); + inc(); + break; + case 0xF8: + imp(); + sed(); + break; + case 0xF9: + absy(); + sbc(); + break; + case 0xFD: + absx(); + sbc(); + break; + case 0xFE: + absx(); + inc(); + break; + } + +#ifdef USE_TIMING + clockgoal6502 -= (int32_t)pgm_read_byte_near(ticktable + opcode); +#endif + instructions++; + + #ifdef DEBUGUNO + // ----------------------------- debug trace file + if (fpx!=NULL) + { + char flagName[]="CZIDB-VN"; + + fprintf(fpx, "%4x ", debugPC); + for (ii=0;ii<3;ii++) + if ((int)(pc-debugPC-ii)<0) + fprintf(fpx, " "); + else + fprintf(fpx, "%2x ", read6502(debugPC+ii)); + fprintf(fpx, " "); + fprintf(fpx, "A:%2x X:%2x Y:%2x F:%2x S:1%2x [", a, x, y, cpustatus, sp); + for (ii=7;ii>=6;ii--) + if (cpustatus & 1<=0;ii--) + if (cpustatus & 1<