void cineExecute0000()
{
for (;;) {
switch(register_PC)
{
case 0x0000:
flag_C = acc_a0 = register_A;
cmp_old = register_B; /* step back cmp flag */
register_B = cmp_new = 0;
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0f00;
cmp_old = register_A; cmp_new = 0x01;
register_A = flag_C = acc_a0 = 0x0f01;
register_J = 0x0008;
register_P = 0x0; /* set page register */
case 0x0008:
ram[register_I = (register_P << 4) + 0x0] = register_A; /* store acc to RAM */
register_I = ram[(register_P << 4) + 0x00]&0xff; /* set/mask new register_I */
ram[register_I] = register_B; /* store acc */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x0008; continue;};
ram[register_I = (register_P << 4) + 0x0] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_new = 0x1; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x0001;
reset_coin_counter(1);
register_J = 0x0904;
{register_PC = 0x0904; continue;};
case 0x0026:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0900;
cmp_old = register_A; cmp_new = 0x1c;
register_A = flag_C = acc_a0 = 0x091c;
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (cmp_new = ram[register_I]))) & 0xFFF;
set_watchdog();
cmp_old = register_A; register_A = cmp_new = rom[register_A]; /* new acc value */
ram[register_I] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0200;
cmp_old = register_A; cmp_new = 0xd3;
register_A = flag_C = acc_a0 = 0x02d3;
register_P = 0x8; /* set page register */
ram[register_I = 0x83] = 0x2d3; /* store acc to RAM */
register_P = 0x2; /* set page register */
ram[register_I = 0x22] = 0x2d3; /* store acc to RAM */
ram[register_I = 0x23] = 0x2d3; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
ram[register_I = 0x2c] = 0x000; /* store acc to RAM */
ram[register_I = 0x2d] = 0x000; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_P = 0x6; /* set page register */
ram[register_I = 0x62] = 0x000; /* store acc to RAM */
ram[register_I = 0x60] = 0x000; /* store acc to RAM */
ram[register_I = 0x6a] = 0x000; /* store acc to RAM */
ram[register_I = 0x6c] = 0x000; /* store acc to RAM */
ram[register_I = 0x69] = 0x000; /* store acc to RAM */
cmp_new = 0x1; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x0001;
ram[register_I = 0x61] = 0x001; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = get_io_startbutton();
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
register_J = 0x0058;
if (cmp_new == cmp_old) {register_PC = 0x0058; continue;};
register_J = 0x0000;
register_P = 0x2; /* set page register */
register_PC = 0x1000; /* rom offset */
{register_PC = 0x1000; continue;};
case 0x004a:
register_A = (flag_C = ((acc_a0 = cmp_old = register_A) + (cmp_new = 0x001f))) & 0xFFF; /* add values */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0x3]) ^ 0xFFF) + 1 + register_A);
register_J = 0x0056;
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x0056; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = ram[register_I];
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
ram[register_I] = register_A; /* store acc */
register_J = 0x0058;
{register_PC = 0x0058; continue;};
case 0x0056:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
ram[register_I] = register_A; /* store acc */
case 0x0058:
flag_C = acc_a0 = register_A;
cmp_old = register_B; /* step back cmp flag */
register_B = cmp_new = 0x0300;
cmp_new = 0x0EEE; cmp_old = acc_a0 = register_A; flag_C = (0x0EEE + register_A);
register_A = (register_A >> 1) | ((register_B & 1) << 11);
register_B = (register_B >> 1) | (register_B & 0x800);
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0200;
register_J = 0x0060;
FromX = register_A & 0xFFF; /* regA goes to x-coord */
FromY = register_B & 0xFFF; /* regB goes to y-coord */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = acc_a0 = register_A; /* back up regA */
register_A = (flag_C = (register_A + (((cmp_new = 0x12) ^ 0xFFF) + 1))) & 0xFFF; /* add */
case 0x0065:
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
register_J = 0x0065;
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x0065; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_new = 0xb; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x000b;
flag_C = acc_a0 = register_A;
cmp_old = register_B; /* step back cmp flag */
register_B = cmp_new = 0;
{int temp_byte = 0;
for (;;) {
if ( ((((register_A >> 8) & 0x0A) != 0) && ((((register_A >> 8) & 0x0A) ^ 0x0A)) != 0)
|| ((((register_B >> 8) & 0x0A) != 0) && ((((register_B >> 8) & 0x0A) ^ 0x0A)) != 0) ) break;
register_A <<= 1; register_B <<= 1;
temp_byte = (temp_byte+1) & 0xff; if (temp_byte == 0) break /* This may not be correct */;
}
vgShiftLength = temp_byte & 0xfff; register_A &= 0x0FFF; register_B &= 0x0FFF;
}
/* wait for a tick on the watchdog */
CinemaClearScreen();
bNewFrame = 1;
bailOut = TRUE;
register_PC = 0x006f;
break; /* NOT REALLY A JUMP - ACTUALLY FOR GETTING BACK TO POLLING LOOP - NEEDS WORK */
case 0x006f:
/* wait for a tick on the watchdog */
CinemaClearScreen();
bNewFrame = 1;
bailOut = TRUE;
register_PC = 0x0070;
break; /* NOT REALLY A JUMP - ACTUALLY FOR GETTING BACK TO POLLING LOOP - NEEDS WORK */
case 0x0070:
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (cmp_new = ram[register_I]))) & 0xFFF;
set_watchdog();
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_P = 0x6; /* set page register */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x69]) ^ 0xFFF) + 1 + register_A);
register_J = 0x00be;
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x00be; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x1e;
register_A = flag_C = acc_a0 = 0x001e;
set_sound_data(0);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_A(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_B(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_C(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x1a;
register_A = flag_C = acc_a0 = 0x001a;
set_sound_data(0);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_A(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_B(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_C(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x18;
register_A = flag_C = acc_a0 = 0x0018;
set_sound_data(0);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_A(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_B(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_C(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x16;
register_A = flag_C = acc_a0 = 0x0016;
set_sound_data(0);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_A(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_B(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_C(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x14;
register_A = flag_C = acc_a0 = 0x0014;
set_sound_data(0);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_A(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_B(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_C(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
case 0x00be:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x17;
register_A = flag_C = acc_a0 = 0x0017;
register_P = 0x3; /* set page register */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x37]) ^ 0xFFF) + 1 + register_A);
register_J = 0x00df;
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x00df; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0100;
cmp_old = register_A; cmp_new = 0x15;
register_A = flag_C = acc_a0 = 0x0115;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x33]) ^ 0xFFF) + 1 + register_A);
register_J = 0x00e2;
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x00e2; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x30]) ^ 0xFFF) + 1 + register_A);
if (cmp_new == cmp_old) {register_PC = 0x00e2; continue;};
register_P = 0x6; /* set page register */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x69]; /* set I register */
register_J = 0x00df;
if (cmp_new == cmp_old) {register_PC = 0x00df; continue;};
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (((cmp_new = 0x1) ^ 0xFFF) + 1))) & 0xFFF; /* 1's-comp add */
ram[0x69] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_new = 0xf; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x000f;
register_P = 0x7; /* set page register */
ram[register_I = 0x72] = 0x00f; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x73]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
ram[0x73] = register_A; /* store acc */
case 0x00df:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_P = 0x3; /* set page register */
ram[register_I = 0x30] = 0x000; /* store acc to RAM */
case 0x00e2:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x17;
register_A = flag_C = acc_a0 = 0x0017;
register_P = 0x4; /* set page register */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x47]) ^ 0xFFF) + 1 + register_A);
register_J = 0x0103;
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x0103; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0100;
cmp_old = register_A; cmp_new = 0x15;
register_A = flag_C = acc_a0 = 0x0115;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x43]) ^ 0xFFF) + 1 + register_A);
register_J = 0x0106;
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x0106; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x40]) ^ 0xFFF) + 1 + register_A);
if (cmp_new == cmp_old) {register_PC = 0x0106; continue;};
register_P = 0x6; /* set page register */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x69]; /* set I register */
register_J = 0x0103;
if (cmp_new == cmp_old) {register_PC = 0x0103; continue;};
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (((cmp_new = 0x1) ^ 0xFFF) + 1))) & 0xFFF; /* 1's-comp add */
ram[0x69] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_new = 0xf; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x000f;
register_P = 0x7; /* set page register */
ram[register_I = 0x72] = 0x00f; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x73]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
ram[0x73] = register_A; /* store acc */
case 0x0103:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_P = 0x4; /* set page register */
ram[register_I = 0x40] = 0x000; /* store acc to RAM */
case 0x0106:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x17;
register_A = flag_C = acc_a0 = 0x0017;
register_P = 0x5; /* set page register */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x57]) ^ 0xFFF) + 1 + register_A);
register_J = 0x0127;
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x0127; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0100;
cmp_old = register_A; cmp_new = 0x15;
register_A = flag_C = acc_a0 = 0x0115;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x53]) ^ 0xFFF) + 1 + register_A);
register_J = 0x012a;
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x012a; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x50]) ^ 0xFFF) + 1 + register_A);
if (cmp_new == cmp_old) {register_PC = 0x012a; continue;};
register_P = 0x6; /* set page register */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x69]; /* set I register */
register_J = 0x0127;
if (cmp_new == cmp_old) {register_PC = 0x0127; continue;};
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (((cmp_new = 0x1) ^ 0xFFF) + 1))) & 0xFFF; /* 1's-comp add */
ram[0x69] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_new = 0xf; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x000f;
register_P = 0x7; /* set page register */
ram[register_I = 0x72] = 0x00f; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x73]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
ram[0x73] = register_A; /* store acc */
case 0x0127:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_P = 0x5; /* set page register */
ram[register_I = 0x50] = 0x000; /* store acc to RAM */
case 0x012a:
register_P = 0x7; /* set page register */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x73]; /* set I register */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_J = 0x013e;
if (cmp_new < cmp_old) {register_PC = 0x013e; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x14;
register_A = flag_C = acc_a0 = 0x0014;
set_sound_data(0);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_A(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_B(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_C(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
case 0x013e:
register_J = 0x0140;
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
vgColour = 0x07;
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0xa0;
register_A = flag_C = acc_a0 = 0x00a0;
register_P = 0xc; /* set page register */
ram[register_I = 0xc1] = 0x0a0; /* store acc to RAM */
case 0x0148:
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x01]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
ram[register_I = (register_P << 4) + 0x2] = register_A; /* store acc to RAM */
case 0x014b:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0400;
cmp_new = 0x8; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x0408;
register_I = ram[(register_P << 4) + 0x01]&0xff; /* set/mask new register_I */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
ram[register_I = (register_P << 4) + 0x5] = register_A; /* store acc to RAM */
flag_C = acc_a0 = register_A;
cmp_old = register_B; /* step back cmp flag */
register_B = cmp_new = 0x0300;
cmp_new = 0x0EEE; cmp_old = acc_a0 = register_A; flag_C = (0x0EEE + register_A);
register_A = (register_A >> 1) | ((register_B & 1) << 11);
register_B = (register_B >> 1) | (register_B & 0x800);
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0200;
register_J = 0x015b;
FromX = register_A & 0xFFF; /* regA goes to x-coord */
FromY = register_B & 0xFFF; /* regB goes to y-coord */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0800;
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x05]; /* set I register */
register_J = 0x0164;
if (cmp_new < cmp_old) {register_PC = 0x0164; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
case 0x0164:
ram[register_I = (register_P << 4) + 0x8] = register_A; /* store acc to RAM */
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
register_P = 0x7; /* set page register */
ram[register_I = 0x70] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_new = 0x4; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x0004;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x73]) ^ 0xFFF) + 1 + register_A);
register_J = 0x018b;
if (cmp_new < cmp_old) {register_PC = 0x018b; continue;};
flag_C = acc_a0 = register_A;
cmp_old = register_B; /* step back cmp flag */
register_B = cmp_new = 0;
acc_a0 = register_A;
register_B = (flag_C = ((cmp_old = register_B) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
cmp_new = 0x0EEE; cmp_old = acc_a0 = register_A; flag_C = (0x0EEE + register_A);
register_A = (register_A >> 1) | ((register_B & 1) << 11);
register_B = (register_B >> 1) | (register_B & 0x800);
acc_a0 = register_A;
register_B = (flag_C = ((cmp_old = register_B) + ((cmp_new = 0x1) ^ 0xFFF) + 1)) & 0xFFF; /* 1's-comp add */
register_P = 0xc; /* set page register */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0xc5]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x2))) & 0xFFF; /* add values, save carry */
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
register_P = 0x7; /* set page register */
ram[register_I = 0x74] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_J = 0x0181;
case 0x0181:
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (cmp_new = ram[register_I]))) & 0xFFF;
set_watchdog();
acc_a0 = register_A; /* save old accA bit0 */
cmp_old = register_B; /* store old acc for later */
register_B = (flag_C = (register_B + (cmp_new = 0x01))) & 0xFFF; /* add values */
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x0181; continue;};
register_P = 0xc; /* set page register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = 0xc5]))) & 0xFFF; /* do acc operation */
ram[0xc5] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_new = 0x1; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x0001;
vgColour = 0x0f;
case 0x018b:
register_P = 0xc; /* set page register */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0xc5]; /* set I register */
register_I = ram[0xc1]&0xff; /* set new register_I (8 bits) */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (cmp_new = ram[register_I]))) & 0xFFF;
set_watchdog();
ram[register_I] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0300;
cmp_new = 0x8; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x0308;
register_I = ram[0xc2]&0xff; /* set new register_I (8 bits) */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
ram[register_I = 0xc6] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0800;
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = ram[register_I];
register_J = 0x01a1;
if (cmp_new < cmp_old) {register_PC = 0x01a1; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
case 0x01a1:
ram[register_I = (register_P << 4) + 0x9] = register_A; /* store acc to RAM */
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
register_P = 0x7; /* set page register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = 0x70]))) & 0xFFF; /* do acc operation */
ram[0x70] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_new = 0x4; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x0004;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x73]) ^ 0xFFF) + 1 + register_A);
register_J = 0x01c6;
if (cmp_new < cmp_old) {register_PC = 0x01c6; continue;};
flag_C = acc_a0 = register_A;
cmp_old = register_B; /* step back cmp flag */
register_B = cmp_new = 0;
acc_a0 = register_A;
register_B = (flag_C = ((cmp_old = register_B) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
cmp_new = 0x0EEE; cmp_old = acc_a0 = register_A; flag_C = (0x0EEE + register_A);
register_A = (register_A >> 1) | ((register_B & 1) << 11);
register_B = (register_B >> 1) | (register_B & 0x800);
acc_a0 = register_A;
register_B = (flag_C = ((cmp_old = register_B) + ((cmp_new = 0x1) ^ 0xFFF) + 1)) & 0xFFF; /* 1's-comp add */
register_P = 0xc; /* set page register */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0xc6]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x2))) & 0xFFF; /* add values, save carry */
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
register_P = 0x7; /* set page register */
ram[register_I = 0x74] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_J = 0x01bf;
case 0x01bf:
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (cmp_new = ram[register_I]))) & 0xFFF;
set_watchdog();
acc_a0 = register_A; /* save old accA bit0 */
cmp_old = register_B; /* store old acc for later */
register_B = (flag_C = (register_B + (cmp_new = 0x01))) & 0xFFF; /* add values */
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x01bf; continue;};
register_P = 0xc; /* set page register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = 0xc6]))) & 0xFFF; /* do acc operation */
ram[0xc6] = register_A; /* store acc */
case 0x01c6:
register_P = 0xc; /* set page register */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0xc6]; /* set I register */
register_I = ram[0xc2]&0xff; /* set new register_I (8 bits) */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (cmp_new = ram[register_I]))) & 0xFFF;
set_watchdog();
ram[register_I] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0900;
register_I = ram[0xc1]&0xff; /* set new register_I (8 bits) */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
register_J = 0x020f;
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x020f; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0700;
register_I = ram[0xc2]&0xff; /* set new register_I (8 bits) */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x020f; continue;};
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0xc8]; /* set I register */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (((cmp_new = 0x4) ^ 0xFFF) + 1))) & 0xFFF; /* 1's-comp add */
register_J = 0x01df;
if (cmp_new < cmp_old) {register_PC = 0x01df; continue;};
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0xc9]; /* set I register */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (((cmp_new = 0x5) ^ 0xFFF) + 1))) & 0xFFF; /* 1's-comp add */
register_J = 0x020f;
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x020f; continue;};
case 0x01df:
register_I = ram[(register_P << 4) + 0x02]&0xff; /* set/mask new register_I */
flag_C = acc_a0 = register_A;
cmp_old = register_B;
register_B = cmp_new = ram[register_I];
cmp_new = 0x0EEE; cmp_old = acc_a0 = register_A; flag_C = (0x0EEE + register_A);
register_A = (register_A >> 1) | ((register_B & 1) << 11);
register_B = (register_B >> 1) | (register_B & 0x800);
register_I = ram[(register_P << 4) + 0x01]&0xff; /* set/mask new register_I */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = ram[register_I];
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
FromX = register_A & 0xFFF; /* regA goes to x-coord */
FromY = register_B & 0xFFF; /* regB goes to y-coord */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = acc_a0 = register_A; /* back up regA */
register_A = (flag_C = (register_A + (((cmp_new = 0x4e) ^ 0xFFF) + 1))) & 0xFFF; /* add */
case 0x01ea:
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
register_J = 0x01ea;
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x01ea; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0200;
cmp_old = register_A; cmp_new = 0x66;
register_A = flag_C = acc_a0 = 0x0266;
register_P = 0x7; /* set page register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = 0x70]))) & 0xFFF; /* do acc operation */
cmp_old = register_A; register_A = cmp_new = rom[register_A]; /* new acc value */
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
flag_C = acc_a0 = register_A;
cmp_old = register_B; /* step back cmp flag */
register_B = cmp_new = 0;
{int temp_byte = 0;
for (;;) {
if ( ((((register_A >> 8) & 0x0A) != 0) && ((((register_A >> 8) & 0x0A) ^ 0x0A)) != 0)
|| ((((register_B >> 8) & 0x0A) != 0) && ((((register_B >> 8) & 0x0A) ^ 0x0A)) != 0) ) break;
register_A <<= 1; register_B <<= 1;
temp_byte = (temp_byte+1) & 0xff; if (temp_byte == 0) break /* This may not be correct */;
}
vgShiftLength = temp_byte & 0xfff; register_A &= 0x0FFF; register_B &= 0x0FFF;
}
register_P = 0xc; /* set page register */
register_I = ram[0xc2]&0xff; /* set new register_I (8 bits) */
flag_C = acc_a0 = register_A;
cmp_old = register_B;
register_B = cmp_new = ram[register_I];
cmp_new = 0x0EEE; cmp_old = acc_a0 = register_A; flag_C = (0x0EEE + register_A);
register_A = (register_A >> 1) | ((register_B & 1) << 11);
register_B = (register_B >> 1) | (register_B & 0x800);
register_I = ram[0xc1]&0xff; /* set new register_I (8 bits) */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = ram[register_I];
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
{
/* set ending points and draw the vector, or buffer for a later draw. */
int ToX = register_A & 0xFFF;
int ToY = register_B & 0xFFF;
/* Sign extend from 20 bit CCPU to 32bit target machine */
FromX = SEX(FromX);
ToX = SEX(ToX);
FromY = SEX(FromY);
ToY = SEX(ToY);
/* figure out the vector */
ToX -= FromX;
ToX = ((int)(((int)ToX) >> (int)((vgShiftLength)&31))) /* SAR */;
ToX += FromX;
ToY -= FromY;
ToY = ((int)(((int)ToY) >> (int)((vgShiftLength)&31))) /* SAR */;
ToY += FromY;
/* render the line */
CinemaVectorData (FromX, FromY, ToX, ToY, vgColour);
}
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0xc1]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x2))) & 0xFFF; /* add values, save carry */
ram[0xc1] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0xc0;
register_A = flag_C = acc_a0 = 0x00c0;
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = ram[register_I];
register_J = 0x0148;
if (cmp_new < cmp_old) {register_PC = 0x0148; continue;};
register_J = 0x08b6;
{register_PC = 0x08b6; continue;};
case 0x020f:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x3f;
register_A = flag_C = acc_a0 = 0x003f;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0x7]) ^ 0xFFF) + 1 + register_A);
cmp_old = flag_C = acc_a0 = register_A;
register_A &= (cmp_new = ram[register_I]);
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x2))) & 0xFFF; /* add values, save carry */
ram[register_I] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0200;
cmp_old = register_A; cmp_new = 0x74;
register_A = flag_C = acc_a0 = 0x0274;
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = (register_P << 4) + 0x7]))) & 0xFFF; /* do acc operation */
ram[register_I = (register_P << 4) + 0x5] = register_A; /* store acc to RAM */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
cmp_old = register_A; register_A = cmp_new = rom[register_A]; /* new acc value */
cmp_old = acc_a0 = register_A; /* back up regA */
register_A = (flag_C = (register_A + (((cmp_new = 0x80) ^ 0xFFF) + 1))) & 0xFFF; /* add */
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
ram[register_I = (register_P << 4) + 0x6] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x05]; /* set I register */
cmp_old = register_A; register_A = cmp_new = rom[register_A]; /* new acc value */
cmp_old = acc_a0 = register_A; /* back up regA */
register_A = (flag_C = (register_A + (((cmp_new = 0x80) ^ 0xFFF) + 1))) & 0xFFF; /* add */
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
ram[register_I] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x00]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
ram[register_I] = register_A; /* store acc */
cmp_old = register_A; register_A = cmp_new = rom[register_A]; /* new acc value */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (cmp_new = ram[register_I]))) & 0xFFF;
set_watchdog();
cmp_old = register_A; register_A = cmp_new = rom[register_A]; /* new acc value */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (cmp_new = ram[register_I]))) & 0xFFF;
set_watchdog();
ram[register_I = (register_P << 4) + 0x3] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x7f;
register_A = flag_C = acc_a0 = 0x007f;
cmp_old = flag_C = acc_a0 = register_A;
register_A &= (cmp_new = ram[register_I]);
ram[register_I] = register_A; /* store acc */
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
register_J = 0x0243;
if ((acc_a0 & 0x01) != 0) {register_PC = 0x0243; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
ram[register_I] = register_A; /* store acc */
case 0x0243:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0400;
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (cmp_new = ram[register_I]))) & 0xFFF;
set_watchdog();
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = (register_P << 4) + 0x5]))) & 0xFFF; /* do acc operation */
register_I = ram[(register_P << 4) + 0x01]&0xff; /* set/mask new register_I */
ram[register_I] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x00]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
ram[register_I] = register_A; /* store acc */
cmp_old = register_A; register_A = cmp_new = rom[register_A]; /* new acc value */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (cmp_new = ram[register_I]))) & 0xFFF;
set_watchdog();
cmp_old = register_A; register_A = cmp_new = rom[register_A]; /* new acc value */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (cmp_new = ram[register_I]))) & 0xFFF;
set_watchdog();
ram[register_I = (register_P << 4) + 0x3] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x7f;
register_A = flag_C = acc_a0 = 0x007f;
cmp_old = flag_C = acc_a0 = register_A;
register_A &= (cmp_new = ram[register_I]);
ram[register_I] = register_A; /* store acc */
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
register_J = 0x025e;
if ((acc_a0 & 0x01) != 0) {register_PC = 0x025e; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
ram[register_I] = register_A; /* store acc */
case 0x025e:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0300;
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (cmp_new = ram[register_I]))) & 0xFFF;
set_watchdog();
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = (register_P << 4) + 0x6]))) & 0xFFF; /* do acc operation */
register_I = ram[(register_P << 4) + 0x02]&0xff; /* set/mask new register_I */
ram[register_I] = register_A; /* store acc */
register_J = 0x014b;
{register_PC = 0x014b; continue;};
case 0x02b6:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = ram[register_I];
cmp_old = acc_a0 = register_A; /* back up regA */
register_A = (flag_C = (register_A + (((cmp_new = 0x1f) ^ 0xFFF) + 1))) & 0xFFF; /* add */
register_J = 0x02dc;
if (cmp_new < cmp_old) {register_PC = 0x02dc; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_new = 0x2; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x0002;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0xd]) ^ 0xFFF) + 1 + register_A);
register_J = 0x08ed;
if (cmp_new < cmp_old) {register_PC = 0x08ed; continue;};
cmp_new = 0x5; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x0007;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0xd]) ^ 0xFFF) + 1 + register_A);
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x08ed; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = get_io_bit(0xf);
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
register_P = 0x7; /* set page register */
ram[register_I = 0x75] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_new = 0x1; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x0001;
cmp_old = flag_C = acc_a0 = register_A;
register_A &= (cmp_new = ram[register_I]);
register_A = (flag_C = ((acc_a0 = cmp_old = register_A) + (cmp_new = 0x001e))) & 0xFFF; /* add values */
set_sound_data(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_A(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_B(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_C(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
register_J = 0x08fb;
{register_PC = 0x08fb; continue;};
case 0x02dc:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
ram[register_I] = register_A; /* store acc */
case 0x02de:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_P = 0x7; /* set page register */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x73]) ^ 0xFFF) + 1 + register_A);
register_J = 0x02ed;
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x02ed; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0300;
cmp_old = register_A; cmp_new = 0x08;
register_A = flag_C = acc_a0 = 0x0308;
register_P = 0x1; /* set page register */
ram[register_I = 0x1f] = 0x308; /* store acc to RAM */
register_J = 0x0dc0;
register_P = 0x2; /* set page register */
register_PC = 0x1dc0; /* rom offset */
{register_PC = 0x1dc0; continue;};
case 0x02ed:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_P = 0x6; /* set page register */
ram[register_I = 0x62] = 0x000; /* store acc to RAM */
ram[register_I = 0x60] = 0x000; /* store acc to RAM */
cmp_new = 0x5; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x0005;
register_P = 0x7; /* set page register */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x73]) ^ 0xFFF) + 1 + register_A);
register_J = 0x004a;
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x004a; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x15;
register_A = flag_C = acc_a0 = 0x0015;
set_sound_data(1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_A(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_B(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_C(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_new = 0x5; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x0005;
{register_PC = 0x004a; continue;};
case 0x0308:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_P = 0x3; /* set page register */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x37]) ^ 0xFFF) + 1 + register_A);
register_J = 0x0319;
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x0319; continue;};
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x3d]; /* set I register */
if (cmp_new == cmp_old) {register_PC = 0x0319; continue;};
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = 0x33]))) & 0xFFF; /* do acc operation */
ram[0x33] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0f00;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x33]) ^ 0xFFF) + 1 + register_A);
if (cmp_new < cmp_old) {register_PC = 0x0319; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
ram[register_I = 0x30] = 0x000; /* store acc to RAM */
ram[register_I = 0x3d] = 0x000; /* store acc to RAM */
case 0x0319:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_P = 0x4; /* set page register */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x47]) ^ 0xFFF) + 1 + register_A);
register_J = 0x0329;
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x0329; continue;};
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x4d]; /* set I register */
if (cmp_new == cmp_old) {register_PC = 0x0329; continue;};
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = 0x43]))) & 0xFFF; /* do acc operation */
ram[0x43] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0f00;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x43]) ^ 0xFFF) + 1 + register_A);
if (cmp_new < cmp_old) {register_PC = 0x0329; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
ram[register_I = 0x40] = 0x000; /* store acc to RAM */
ram[register_I = 0x4d] = 0x000; /* store acc to RAM */
case 0x0329:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_P = 0x5; /* set page register */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x57]) ^ 0xFFF) + 1 + register_A);
register_J = 0x0339;
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x0339; continue;};
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x5d]; /* set I register */
if (cmp_new == cmp_old) {register_PC = 0x0339; continue;};
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = 0x53]))) & 0xFFF; /* do acc operation */
ram[0x53] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0f00;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x53]) ^ 0xFFF) + 1 + register_A);
if (cmp_new < cmp_old) {register_PC = 0x0339; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
ram[register_I = 0x50] = 0x000; /* store acc to RAM */
ram[register_I = 0x5d] = 0x000; /* store acc to RAM */
case 0x0339:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_P = 0x6; /* set page register */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x69]) ^ 0xFFF) + 1 + register_A);
register_J = 0x086f;
if (cmp_new == cmp_old) {register_PC = 0x086f; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = get_io_shields();
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
register_J = 0x086f;
if (cmp_new == cmp_old) {register_PC = 0x086f; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_P = 0x8; /* set page register */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x81]) ^ 0xFFF) + 1 + register_A);
if (cmp_new == cmp_old) {register_PC = 0x086f; continue;};
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x80]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
ram[0x80] = register_A; /* store acc */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (((cmp_new = 0x8) ^ 0xFFF) + 1))) & 0xFFF; /* 1's-comp add */
register_J = 0x0377;
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x0377; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
ram[0x80] = 0x000; /* store acc */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x81]; /* set I register */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_J = 0x0373;
if (cmp_new == cmp_old) {register_PC = 0x0373; continue;};
cmp_old = register_A; cmp_new = 0xff;
register_A = flag_C = acc_a0 = 0x00ff;
cmp_old = flag_C = acc_a0 = register_A;
register_A &= (cmp_new = ram[register_I]);
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_J = 0x036d;
if (cmp_new == cmp_old) {register_PC = 0x036d; continue;};
cmp_new = 0xf; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x000f;
cmp_old = flag_C = acc_a0 = register_A;
register_A &= (cmp_new = ram[register_I]);
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_J = 0x0368;
if (cmp_new == cmp_old) {register_PC = 0x0368; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = ram[register_I];
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (((cmp_new = 0x1) ^ 0xFFF) + 1))) & 0xFFF; /* 1's-comp add */
register_J = 0x0376;
{register_PC = 0x0376; continue;};
case 0x0368:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = ram[register_I];
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (((cmp_new = 0x7) ^ 0xFFF) + 1))) & 0xFFF; /* 1's-comp add */
register_J = 0x0376;
{register_PC = 0x0376; continue;};
case 0x036d:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = ram[register_I];
cmp_old = acc_a0 = register_A; /* back up regA */
register_A = (flag_C = (register_A + (((cmp_new = 0x67) ^ 0xFFF) + 1))) & 0xFFF; /* add */
register_J = 0x0376;
{register_PC = 0x0376; continue;};
case 0x0373:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0900;
cmp_old = register_A; cmp_new = 0x99;
register_A = flag_C = acc_a0 = 0x0999;
case 0x0376:
ram[register_I] = register_A; /* store acc */
case 0x0377:
flag_C = acc_a0 = register_A;
cmp_old = register_B; /* step back cmp flag */
register_B = cmp_new = 0x0300;
cmp_new = 0x0EEE; cmp_old = acc_a0 = register_A; flag_C = (0x0EEE + register_A);
register_A = (register_A >> 1) | ((register_B & 1) << 11);
register_B = (register_B >> 1) | (register_B & 0x800);
register_P = 0x1; /* set page register */
ram[register_I = (register_P << 4) + 0x1] = register_B; /* set I register and store B to ram */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0200;
ram[register_I = 0x10] = 0x200; /* store acc to RAM */
register_J = 0x0381;
FromX = register_A & 0xFFF; /* regA goes to x-coord */
FromY = register_B & 0xFFF; /* regB goes to y-coord */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = acc_a0 = register_A; /* back up regA */
register_A = (flag_C = (register_A + (((cmp_new = 0x43) ^ 0xFFF) + 1))) & 0xFFF; /* add */
case 0x0386:
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
register_J = 0x0386;
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x0386; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0300;
cmp_old = register_A; cmp_new = 0xcb;
register_A = flag_C = acc_a0 = 0x03cb;
ram[register_I = (register_P << 4) + 0x6] = 0x3cb; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0xff;
register_A = flag_C = acc_a0 = 0x00ff;
ram[register_I = (register_P << 4) + 0x8] = 0x0ff; /* store acc to RAM */
case 0x0392:
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x00]; /* set I register */
flag_C = acc_a0 = register_A;
cmp_old = register_B; /* store old acc */
register_B = cmp_new = ram[register_I = (register_P << 4) + 0x01]; /* new acc value */
FromX = register_A & 0xFFF; /* regA goes to x-coord */
FromY = register_B & 0xFFF; /* regB goes to y-coord */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x06]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x2))) & 0xFFF; /* add values, save carry */
ram[register_I] = register_A; /* store acc */
cmp_old = register_A; register_A = cmp_new = rom[register_A]; /* new acc value */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0x8]) ^ 0xFFF) + 1 + register_A);
register_J = 0x03e6;
if (cmp_new == cmp_old) {register_PC = 0x03e6; continue;};
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = (register_P << 4) + 0x0]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
ram[register_I = (register_P << 4) + 0x3] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x06]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
cmp_old = register_A; register_A = cmp_new = rom[register_A]; /* new acc value */
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = (register_P << 4) + 0x1]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
ram[register_I = (register_P << 4) + 0x4] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x03]; /* set I register */
flag_C = acc_a0 = register_A;
cmp_old = register_B; /* store old acc */
register_B = cmp_new = ram[register_I = (register_P << 4) + 0x04]; /* new acc value */
{int temp_byte = 0;
for (;;) {
if ( ((((register_A >> 8) & 0x0A) != 0) && ((((register_A >> 8) & 0x0A) ^ 0x0A)) != 0)
|| ((((register_B >> 8) & 0x0A) != 0) && ((((register_B >> 8) & 0x0A) ^ 0x0A)) != 0) ) break;
register_A <<= 1; register_B <<= 1;
temp_byte = (temp_byte+1) & 0xff; if (temp_byte == 0) break /* This may not be correct */;
}
vgShiftLength = temp_byte & 0xfff; register_A &= 0x0FFF; register_B &= 0x0FFF;
}
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = (register_P << 4) + 0x0]))) & 0xFFF; /* do acc operation */
acc_a0 = register_A; /* store old acc value */
register_B = (flag_C = ((cmp_old = register_B) + (cmp_new = ram[register_I = (register_P << 4) + 0x01]))) & 0xFFF; /* do acc operation */
{
/* set ending points and draw the vector, or buffer for a later draw. */
int ToX = register_A & 0xFFF;
int ToY = register_B & 0xFFF;
/* Sign extend from 20 bit CCPU to 32bit target machine */
FromX = SEX(FromX);
ToX = SEX(ToX);
FromY = SEX(FromY);
ToY = SEX(ToY);
/* figure out the vector */
ToX -= FromX;
ToX = ((int)(((int)ToX) >> (int)((vgShiftLength)&31))) /* SAR */;
ToX += FromX;
ToY -= FromY;
ToY = ((int)(((int)ToY) >> (int)((vgShiftLength)&31))) /* SAR */;
ToY += FromY;
/* render the line */
CinemaVectorData (FromX, FromY, ToX, ToY, vgColour);
}
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x03]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = (register_P << 4) + 0x0]))) & 0xFFF; /* do acc operation */
ram[register_I] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x04]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = (register_P << 4) + 0x1]))) & 0xFFF; /* do acc operation */
ram[register_I] = register_A; /* store acc */
register_P = 0x8; /* set page register */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x83]) ^ 0xFFF) + 1 + register_A);
register_J = 0x03bd;
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
flag_C = acc_a0 = register_A;
cmp_old = register_B;
register_B = cmp_new = ram[register_I];
cmp_new = 0x0EEE; cmp_old = acc_a0 = register_A; flag_C = (0x0EEE + register_A);
register_A = (register_A >> 1) | ((register_B & 1) << 11);
register_B = (register_B >> 1) | (register_B & 0x800);
cmp_new = 0x0EEE; cmp_old = acc_a0 = register_A; flag_C = (0x0EEE + register_A);
register_A = (register_A >> 1) | ((register_B & 1) << 11);
register_B = (register_B >> 1) | (register_B & 0x800);
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (cmp_new = ram[0x83]))) & 0xFFF;
set_watchdog();
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (cmp_new = ram[0x83]))) & 0xFFF;
set_watchdog();
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
ram[0x83] = register_A; /* store acc */
vgColour = (register_A & 0x01) != 0 ? 0x0f: 0x07;
register_P = 0x1; /* set page register */
register_J = 0x0392;
{register_PC = 0x0392; continue;};
case 0x03e6:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x19;
register_A = flag_C = acc_a0 = 0x0019;
set_sound_data(1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_A(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_B(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_C(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x16;
register_A = flag_C = acc_a0 = 0x0016;
set_sound_data(0);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_A(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_B(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_C(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
register_PC = 0x0400; return;
default: return; // Switch banks
}
}
}
/*********************************************************/
void cineExecute0400()
{
for (;;) {
switch (register_PC)
{
case 0x0400:
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_P = 0x6; /* set page register */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x69]) ^ 0xFFF) + 1 + register_A);
register_J = 0x045e;
if (cmp_new == cmp_old) {register_PC = 0x045e; continue;};
register_P = 0x3; /* set page register */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x30]) ^ 0xFFF) + 1 + register_A);
register_J = 0x0424;
if (cmp_new == cmp_old) {register_PC = 0x0424; continue;};
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x3d]) ^ 0xFFF) + 1 + register_A);
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x0424; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0200;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x33]) ^ 0xFFF) + 1 + register_A);
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x0424; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x4d;
register_A = flag_C = acc_a0 = 0x004d;
ram[register_I = 0x3d] = 0x04d; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x17;
register_A = flag_C = acc_a0 = 0x0017;
set_sound_data(1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_A(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_B(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_C(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
case 0x0424:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_P = 0x4; /* set page register */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x40]) ^ 0xFFF) + 1 + register_A);
register_J = 0x0441;
if (cmp_new == cmp_old) {register_PC = 0x0441; continue;};
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x4d]) ^ 0xFFF) + 1 + register_A);
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x0441; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0200;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x43]) ^ 0xFFF) + 1 + register_A);
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x0441; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x4d;
register_A = flag_C = acc_a0 = 0x004d;
ram[register_I = 0x4d] = 0x04d; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x17;
register_A = flag_C = acc_a0 = 0x0017;
set_sound_data(1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_A(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_B(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_C(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
case 0x0441:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_P = 0x5; /* set page register */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x50]) ^ 0xFFF) + 1 + register_A);
register_J = 0x045e;
if (cmp_new == cmp_old) {register_PC = 0x045e; continue;};
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x5d]) ^ 0xFFF) + 1 + register_A);
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x045e; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0200;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x53]) ^ 0xFFF) + 1 + register_A);
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x045e; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x4d;
register_A = flag_C = acc_a0 = 0x004d;
ram[register_I = 0x5d] = 0x04d; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x17;
register_A = flag_C = acc_a0 = 0x0017;
set_sound_data(1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_A(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_B(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_C(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
case 0x045e:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_P = 0x6; /* set page register */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x69]) ^ 0xFFF) + 1 + register_A);
register_J = 0x0586;
if (cmp_new == cmp_old) {register_PC = 0x0586; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = get_io_bit(0xe);
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_J = 0x04d7;
if (cmp_new == cmp_old) {register_PC = 0x04d7; continue;};
register_P = 0x2; /* set page register */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
put_io_bit(/*bitno*/0x7, /*set or clr*/0x0);
register_J = 0x046e;
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x2a]; /* set I register */
ram[register_I = 0x28] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0400;
cmp_old = register_A; cmp_new = 0x78;
register_A = flag_C = acc_a0 = 0x0478;
ram[register_I = 0x2d] = 0x478; /* store acc to RAM */
register_J = 0x0495;
{register_PC = 0x0495; continue;};
case 0x0495:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0800;
register_P = 0x2; /* set page register */
ram[register_I = 0x2f] = 0x800; /* store acc to RAM */
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
ram[register_I = 0x2e] = register_A; /* store acc to RAM */
register_J = 0x049c;
case 0x049d:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0800;
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = (register_P << 4) + 0xf]))) & 0xFFF; /* do acc operation */
FromX = register_A & 0xFFF; /* regA goes to x-coord */
FromY = register_B & 0xFFF; /* regB goes to y-coord */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
flag_C = acc_a0 = register_A;
cmp_old = register_B; /* step back cmp flag */
register_B = cmp_new = 0x0100;
{int temp_byte = 0;
for (;;) {
if ( ((((register_A >> 8) & 0x0A) != 0) && ((((register_A >> 8) & 0x0A) ^ 0x0A)) != 0)
|| ((((register_B >> 8) & 0x0A) != 0) && ((((register_B >> 8) & 0x0A) ^ 0x0A)) != 0) ) break;
register_A <<= 1; register_B <<= 1;
temp_byte = (temp_byte+1) & 0xff; if (temp_byte == 0) break /* This may not be correct */;
}
vgShiftLength = temp_byte & 0xfff; register_A &= 0x0FFF; register_B &= 0x0FFF;
}
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = acc_a0 = register_A; /* back up regA */
register_A = (flag_C = (register_A + (((cmp_new = 0x11) ^ 0xFFF) + 1))) & 0xFFF; /* add */
case 0x04a7:
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
register_J = 0x04a7;
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x04a7; continue;};
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0f]; /* set I register */
register_J = 0x04b3;
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = (register_P << 4) + 0xe]))) & 0xFFF; /* do acc operation */
register_J = 0x04b4;
{register_PC = 0x04b4; continue;};
case 0x04b4:
ram[register_I = (register_P << 4) + 0xf] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_new = 0x2; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x0002;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0xe]) ^ 0xFFF) + 1 + register_A);
register_J = 0x04c1;
if (cmp_new == cmp_old) {register_PC = 0x04c1; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = ram[register_I];
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
ram[register_I] = register_A; /* store acc */
register_J = 0x049d;
{register_PC = 0x049d; continue;};
case 0x04c1:
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0f]; /* set I register */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = (register_P << 4) + 0x8]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
ram[register_I = (register_P << 4) + 0xe] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0800;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0xe]) ^ 0xFFF) + 1 + register_A);
register_J = 0x04cc;
if (cmp_new < cmp_old) {register_PC = 0x04cc; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = (register_P << 4) + 0xe]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
ram[register_I] = register_A; /* store acc */
case 0x04cc:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_new = 0x7; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x0007;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0xe]) ^ 0xFFF) + 1 + register_A);
register_J = 0x04d4;
if (cmp_new < cmp_old) {register_PC = 0x04d4; continue;};
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0f]; /* set I register */
ram[register_I = (register_P << 4) + 0x8] = register_A; /* store acc to RAM */
case 0x04d4:
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0xd]) ^ 0xFFF) + 1 + register_A);
/* load J reg from value at last dir addr */
register_J = ram[register_I];
if ((register_J & (~0xfff)) != 0) ERROR("Ram value must have been > 12 bits!\n");
{register_PC = register_J; continue;};
case 0x04d7:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = get_io_moveright();
register_P = 0x2; /* set page register */
ram[register_I = 0x2f] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = get_io_moveleft();
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = 0x2a]))) & 0xFFF; /* do acc operation */
ram[0x2a] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0200;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x2a]) ^ 0xFFF) + 1 + register_A);
register_J = 0x04f6;
if (cmp_new < cmp_old) {register_PC = 0x04f6; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0e00;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x2a]) ^ 0xFFF) + 1 + register_A);
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x04f6; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0800;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x2a]) ^ 0xFFF) + 1 + register_A);
register_J = 0x04f4;
if (cmp_new < cmp_old) {register_PC = 0x04f4; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0e00;
ram[0x2a] = 0xe00; /* store acc */
register_J = 0x04f6;
{register_PC = 0x04f6; continue;};
case 0x04f4:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0200;
ram[register_I] = register_A; /* store acc */
case 0x04f6:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = ram[register_I];
ram[register_I = (register_P << 4) + 0xc] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = get_io_moveup();
register_P = 0x2; /* set page register */
ram[register_I = 0x2f] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = get_io_movedown();
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = 0x2b]))) & 0xFFF; /* do acc operation */
ram[0x2b] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0300;
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x2b]) ^ 0xFFF) + 1 + register_A);
register_J = 0x051b;
if (cmp_new < cmp_old) {register_PC = 0x051b; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0d00;
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x2b]) ^ 0xFFF) + 1 + register_A);
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x051b; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0800;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x2b]) ^ 0xFFF) + 1 + register_A);
register_J = 0x0518;
if (cmp_new < cmp_old) {register_PC = 0x0518; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0d00;
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
ram[0x2b] = register_A; /* store acc */
register_J = 0x051b;
{register_PC = 0x051b; continue;};
case 0x0518:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0300;
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
ram[register_I] = register_A; /* store acc */
case 0x051b:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = ram[register_I];
ram[register_I = (register_P << 4) + 0xd] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0100;
cmp_old = register_A; cmp_new = 0xa4;
register_A = flag_C = acc_a0 = 0x01a4;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0xc]) ^ 0xFFF) + 1 + register_A);
register_J = 0x0537;
if (cmp_new < cmp_old) {register_PC = 0x0537; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0800;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0xc]) ^ 0xFFF) + 1 + register_A);
register_J = 0x0533;
if (cmp_new < cmp_old) {register_PC = 0x0533; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0e00;
cmp_old = register_A; cmp_new = 0x84;
register_A = flag_C = acc_a0 = 0x0e84;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0xc]) ^ 0xFFF) + 1 + register_A);
register_J = 0x0536;
if (cmp_new < cmp_old) {register_PC = 0x0536; continue;};
register_J = 0x0537;
{register_PC = 0x0537; continue;};
case 0x0533:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0100;
cmp_old = register_A; cmp_new = 0xa4;
register_A = flag_C = acc_a0 = 0x01a4;
case 0x0536:
ram[register_I = (register_P << 4) + 0xc] = register_A; /* store acc to RAM */
case 0x0537:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0100;
cmp_old = register_A; cmp_new = 0x2c;
register_A = flag_C = acc_a0 = 0x012c;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0xd]) ^ 0xFFF) + 1 + register_A);
register_J = 0x0551;
if (cmp_new < cmp_old) {register_PC = 0x0551; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0800;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0xd]) ^ 0xFFF) + 1 + register_A);
register_J = 0x054d;
if (cmp_new < cmp_old) {register_PC = 0x054d; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0e00;
cmp_old = register_A; cmp_new = 0xd4;
register_A = flag_C = acc_a0 = 0x0ed4;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0xd]) ^ 0xFFF) + 1 + register_A);
register_J = 0x0550;
if (cmp_new < cmp_old) {register_PC = 0x0550; continue;};
register_J = 0x0551;
{register_PC = 0x0551; continue;};
case 0x054d:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0100;
cmp_old = register_A; cmp_new = 0x2c;
register_A = flag_C = acc_a0 = 0x012c;
case 0x0550:
ram[register_I = (register_P << 4) + 0xd] = register_A; /* store acc to RAM */
case 0x0551:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0300;
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = (register_P << 4) + 0xd]))) & 0xFFF; /* do acc operation */
register_P = 0x6; /* set page register */
ram[register_I = 0x64] = register_A; /* store acc to RAM */
flag_C = acc_a0 = register_A;
cmp_old = register_B;
register_B = cmp_new = ram[register_I];
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0200;
register_P = 0x2; /* set page register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = 0x2c]))) & 0xFFF; /* do acc operation */
register_P = 0x6; /* set page register */
ram[register_I = 0x63] = register_A; /* store acc to RAM */
cmp_old = acc_a0 = register_A; /* back up regA */
register_A = (flag_C = (register_A + (((cmp_new = 0x1e) ^ 0xFFF) + 1))) & 0xFFF; /* add */
register_J = 0x055f;
FromX = register_A & 0xFFF; /* regA goes to x-coord */
FromY = register_B & 0xFFF; /* regB goes to y-coord */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
vgColour = 0x07;
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = get_io_fire();
ram[register_I = 0x6f] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x60]) ^ 0xFFF) + 1 + register_A);
register_J = 0x0573;
if (cmp_new == cmp_old) {register_PC = 0x0573; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = ram[register_I];
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (((cmp_new = 0x1) ^ 0xFFF) + 1))) & 0xFFF; /* 1's-comp add */
ram[0x60] = register_A; /* store acc */
register_J = 0x0584;
{register_PC = 0x0584; continue;};
case 0x0573:
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0xf]) ^ 0xFFF) + 1 + register_A);
register_J = 0x0584;
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x0584; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = get_io_shields();
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
if (cmp_new == cmp_old) {register_PC = 0x0584; continue;};
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0f]; /* set I register */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0x1]) ^ 0xFFF) + 1 + register_A);
register_J = 0x0584;
if (cmp_new == cmp_old) {register_PC = 0x0584; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_new = 0x9; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x0009;
ram[register_I = (register_P << 4) + 0x2] = 0x009; /* store acc to RAM */
cmp_new = 0x3; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x000c;
ram[register_I = (register_P << 4) + 0x0] = 0x00c; /* store acc to RAM */
case 0x0584:
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0f]; /* set I register */
ram[register_I = (register_P << 4) + 0x1] = register_A; /* store acc to RAM */
case 0x0586:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_P = 0x3; /* set page register */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x30]) ^ 0xFFF) + 1 + register_A);
register_J = 0x05af;
if (cmp_new == cmp_old) {register_PC = 0x05af; continue;};
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x37]) ^ 0xFFF) + 1 + register_A);
register_J = 0x0599;
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x0599; continue;};
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x3d]) ^ 0xFFF) + 1 + register_A);
if (cmp_new == cmp_old) {register_PC = 0x0599; continue;};
ram[register_I = 0x36] = 0x000; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x34]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
ram[0x34] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x35]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x2))) & 0xFFF; /* add values, save carry */
ram[0x35] = register_A; /* store acc */
case 0x0599:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_new = 0x2; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x0002;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0x7]) ^ 0xFFF) + 1 + register_A);
register_J = 0x05ac;
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x05ac; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0500;
cmp_old = register_A; cmp_new = 0xb6;
register_A = flag_C = acc_a0 = 0x05b6;
register_P = 0x0; /* set page register */
ram[register_I = 0x00] = 0x5b6; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x31;
register_A = flag_C = acc_a0 = 0x0031;
register_P = 0x1; /* set page register */
ram[register_I = 0x19] = 0x031; /* store acc to RAM */
register_J = 0x0c00;
{register_PC = 0x0c00; continue;};
case 0x05ac:
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x07]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
ram[register_I] = register_A; /* store acc */
case 0x05af:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = acc_a0 = register_A; /* back up regA */
register_A = (flag_C = (register_A + (((cmp_new = 0x64) ^ 0xFFF) + 1))) & 0xFFF; /* add */
case 0x05b2:
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
register_J = 0x05b2;
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x05b2; continue;};
case 0x05b6:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_P = 0x6; /* set page register */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x69]) ^ 0xFFF) + 1 + register_A);
register_J = 0x0648;
if (cmp_new == cmp_old) {register_PC = 0x0648; continue;};
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x63]; /* set I register */
register_P = 0x1; /* set page register */
ram[register_I = 0x10] = register_A; /* store acc to RAM */
cmp_old = acc_a0 = register_A; /* back up regA */
register_A = (flag_C = (register_A + (((cmp_new = 0x1e) ^ 0xFFF) + 1))) & 0xFFF; /* add */
ram[register_I = 0x13] = register_A; /* store acc to RAM */
register_P = 0x6; /* set page register */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x64]; /* set I register */
register_P = 0x1; /* set page register */
ram[register_I = 0x11] = register_A; /* store acc to RAM */
ram[register_I = 0x14] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0600;
cmp_old = register_A; cmp_new = 0x15;
register_A = flag_C = acc_a0 = 0x0615;
ram[register_I = 0x16] = 0x615; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0xff;
register_A = flag_C = acc_a0 = 0x00ff;
ram[register_I = 0x18] = 0x0ff; /* store acc to RAM */
case 0x05d0:
register_J = 0x05d0;
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x03]; /* set I register */
flag_C = acc_a0 = register_A;
cmp_old = register_B; /* store old acc */
register_B = cmp_new = ram[register_I = (register_P << 4) + 0x04]; /* new acc value */
FromX = register_A & 0xFFF; /* regA goes to x-coord */
FromY = register_B & 0xFFF; /* regB goes to y-coord */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x06]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x2))) & 0xFFF; /* add values, save carry */
ram[register_I] = register_A; /* store acc */
cmp_old = register_A; register_A = cmp_new = rom[register_A]; /* new acc value */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0x8]) ^ 0xFFF) + 1 + register_A);
register_J = 0x05ff;
if (cmp_new == cmp_old) {register_PC = 0x05ff; continue;};
cmp_old = acc_a0 = register_A; /* back up regA */
register_A = (flag_C = (register_A + (((cmp_new = 0x80) ^ 0xFFF) + 1))) & 0xFFF; /* add */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = (register_P << 4) + 0x3]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = (register_P << 4) + 0x0]))) & 0xFFF; /* do acc operation */
ram[register_I = (register_P << 4) + 0xc] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x06]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
cmp_old = register_A; register_A = cmp_new = rom[register_A]; /* new acc value */
cmp_old = acc_a0 = register_A; /* back up regA */
register_A = (flag_C = (register_A + (((cmp_new = 0x80) ^ 0xFFF) + 1))) & 0xFFF; /* add */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = (register_P << 4) + 0x4]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = (register_P << 4) + 0x1]))) & 0xFFF; /* do acc operation */
ram[register_I = (register_P << 4) + 0xd] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0c]; /* set I register */
flag_C = acc_a0 = register_A;
cmp_old = register_B; /* store old acc */
register_B = cmp_new = ram[register_I = (register_P << 4) + 0x0d]; /* new acc value */
{int temp_byte = 0;
for (;;) {
if ( ((((register_A >> 8) & 0x0A) != 0) && ((((register_A >> 8) & 0x0A) ^ 0x0A)) != 0)
|| ((((register_B >> 8) & 0x0A) != 0) && ((((register_B >> 8) & 0x0A) ^ 0x0A)) != 0) ) break;
register_A <<= 1; register_B <<= 1;
temp_byte = (temp_byte+1) & 0xff; if (temp_byte == 0) break /* This may not be correct */;
}
vgShiftLength = temp_byte & 0xfff; register_A &= 0x0FFF; register_B &= 0x0FFF;
}
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = (register_P << 4) + 0x3]))) & 0xFFF; /* do acc operation */
acc_a0 = register_A; /* store old acc value */
register_B = (flag_C = ((cmp_old = register_B) + (cmp_new = ram[register_I = (register_P << 4) + 0x04]))) & 0xFFF; /* do acc operation */
{
/* set ending points and draw the vector, or buffer for a later draw. */
int ToX = register_A & 0xFFF;
int ToY = register_B & 0xFFF;
/* Sign extend from 20 bit CCPU to 32bit target machine */
FromX = SEX(FromX);
ToX = SEX(ToX);
FromY = SEX(FromY);
ToY = SEX(ToY);
/* figure out the vector */
ToX -= FromX;
ToX = ((int)(((int)ToX) >> (int)((vgShiftLength)&31))) /* SAR */;
ToX += FromX;
ToY -= FromY;
ToY = ((int)(((int)ToY) >> (int)((vgShiftLength)&31))) /* SAR */;
ToY += FromY;
/* render the line */
CinemaVectorData (FromX, FromY, ToX, ToY, vgColour);
}
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0c]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = (register_P << 4) + 0x3]))) & 0xFFF; /* do acc operation */
ram[register_I] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0d]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = (register_P << 4) + 0x4]))) & 0xFFF; /* do acc operation */
ram[register_I] = register_A; /* store acc */
register_J = 0x05d0;
{register_PC = 0x05d0; continue;};
case 0x05ff:
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x06]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
ram[register_I] = register_A; /* store acc */
cmp_old = register_A; register_A = cmp_new = rom[register_A]; /* new acc value */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0x8]) ^ 0xFFF) + 1 + register_A);
register_J = 0x0648;
if (cmp_new == cmp_old) {register_PC = 0x0648; continue;};
cmp_old = acc_a0 = register_A; /* back up regA */
register_A = (flag_C = (register_A + (((cmp_new = 0x80) ^ 0xFFF) + 1))) & 0xFFF; /* add */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = (register_P << 4) + 0x0]))) & 0xFFF; /* do acc operation */
ram[register_I = (register_P << 4) + 0x3] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x06]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
cmp_old = register_A; register_A = cmp_new = rom[register_A]; /* new acc value */
cmp_old = acc_a0 = register_A; /* back up regA */
register_A = (flag_C = (register_A + (((cmp_new = 0x80) ^ 0xFFF) + 1))) & 0xFFF; /* add */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = (register_P << 4) + 0x1]))) & 0xFFF; /* do acc operation */
ram[register_I = (register_P << 4) + 0x4] = register_A; /* store acc to RAM */
register_J = 0x05d0;
{register_PC = 0x05d0; continue;};
case 0x0648:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_P = 0x6; /* set page register */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x62]) ^ 0xFFF) + 1 + register_A);
register_J = 0x06b9;
if (cmp_new == cmp_old) {register_PC = 0x06b9; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = get_io_bit(0x8);
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_J = 0x065d;
if (cmp_new == cmp_old) {register_PC = 0x065d; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_new = 0x6; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x0006;
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = ram[register_I];
if (cmp_new < cmp_old) {register_PC = 0x065d; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_new = 0x1; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x0001;
cmp_old = flag_C = acc_a0 = register_A;
register_A &= (cmp_new = ram[register_I]);
register_J = 0x065f;
{register_PC = 0x065f; continue;};
case 0x065d:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_new = 0x1; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x0001;
case 0x065f:
register_A = (flag_C = ((acc_a0 = cmp_old = register_A) + (cmp_new = 0x001a))) & 0xFFF; /* add values */
set_sound_data(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_A(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_B(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_C(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x02]; /* set I register */
flag_C = acc_a0 = register_A;
cmp_old = register_B; /* step back cmp flag */
register_B = cmp_new = 0;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0x3]) ^ 0xFFF) + 1 + register_A);
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = 0x0EEE; cmp_old = acc_a0 = register_A; flag_C = (0x0EEE + register_A);
register_A = (register_A >> 1) | ((register_B & 1) << 11);
register_B = (register_B >> 1) | (register_B & 0x800);
ram[register_I = (register_P << 4) + 0x5] = register_B; /* set I register and store B to ram */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x03]; /* set I register */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = (register_P << 4) + 0x5]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
register_P = 0x0; /* set page register */
ram[register_I = 0x0a] = register_A; /* store acc to RAM */
flag_C = acc_a0 = register_A;
cmp_old = register_B; /* step back cmp flag */
register_B = cmp_new = 0;
register_P = 0x6; /* set page register */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x62]; /* set I register */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x64]) ^ 0xFFF) + 1 + register_A);
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = 0x0EEE; cmp_old = acc_a0 = register_A; flag_C = (0x0EEE + register_A);
register_A = (register_A >> 1) | ((register_B & 1) << 11);
register_B = (register_B >> 1) | (register_B & 0x800);
ram[register_I = (register_P << 4) + 0x6] = register_B; /* set I register and store B to ram */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x64]; /* set I register */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = 0x66]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
register_P = 0x0; /* set page register */
ram[register_I = 0x0b] = register_A; /* store acc to RAM */
flag_C = acc_a0 = register_A;
cmp_old = register_B;
register_B = cmp_new = ram[register_I];
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x0a]; /* set I register */
register_J = 0x0691;
FromX = register_A & 0xFFF; /* regA goes to x-coord */
FromY = register_B & 0xFFF; /* regB goes to y-coord */
case 0x0693:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_P = 0x4; /* set page register */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x40]) ^ 0xFFF) + 1 + register_A);
register_J = 0x06cd;
if (cmp_new == cmp_old) {register_PC = 0x06cd; continue;};
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x47]) ^ 0xFFF) + 1 + register_A);
register_J = 0x06a6;
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x06a6; continue;};
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x4d]) ^ 0xFFF) + 1 + register_A);
if (cmp_new == cmp_old) {register_PC = 0x06a6; continue;};
ram[register_I = 0x46] = 0x000; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x44]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x2))) & 0xFFF; /* add values, save carry */
ram[0x44] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x45]; /* set I register */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (((cmp_new = 0x1) ^ 0xFFF) + 1))) & 0xFFF; /* 1's-comp add */
ram[0x45] = register_A; /* store acc */
case 0x06a6:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_new = 0x2; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x0002;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0x7]) ^ 0xFFF) + 1 + register_A);
register_J = 0x06ca;
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x06ca; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0600;
cmp_old = register_A; cmp_new = 0xd4;
register_A = flag_C = acc_a0 = 0x06d4;
register_P = 0x0; /* set page register */
ram[register_I = 0x00] = 0x6d4; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x41;
register_A = flag_C = acc_a0 = 0x0041;
register_P = 0x1; /* set page register */
ram[register_I = 0x19] = 0x041; /* store acc to RAM */
register_J = 0x0c00;
{register_PC = 0x0c00; continue;};
case 0x06b9:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x1a;
register_A = flag_C = acc_a0 = 0x001a;
set_sound_data(0);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_A(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_B(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_C(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
register_J = 0x0693;
{register_PC = 0x0693; continue;};
case 0x06ca:
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x07]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
ram[register_I] = register_A; /* store acc */
case 0x06cd:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = acc_a0 = register_A; /* back up regA */
register_A = (flag_C = (register_A + (((cmp_new = 0x64) ^ 0xFFF) + 1))) & 0xFFF; /* add */
case 0x06d0:
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
register_J = 0x06d0;
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x06d0; continue;};
case 0x06d4:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_P = 0x6; /* set page register */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x62]) ^ 0xFFF) + 1 + register_A);
register_J = 0x07bd;
if (cmp_new == cmp_old) {register_PC = 0x07bd; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = get_io_bit(0xd);
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
register_J = 0x0724;
if (cmp_new == cmp_old) {register_PC = 0x0724; continue;};
vgColour = (register_A & 0x01) != 0 ? 0x0f: 0x07;
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0f00;
cmp_old = register_A; cmp_new = 0xc0;
register_A = flag_C = acc_a0 = 0x0fc0;
register_P = 0x0; /* set page register */
ram[register_I = 0x05] = 0xfc0; /* store acc to RAM */
flag_C = acc_a0 = register_A;
cmp_old = register_B; /* step back cmp flag */
register_B = cmp_new = 0;
register_P = 0x6; /* set page register */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x62]; /* set I register */
register_P = 0x0; /* set page register */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x05]) ^ 0xFFF) + 1 + register_A);
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = 0x0EEE; cmp_old = acc_a0 = register_A; flag_C = (0x0EEE + register_A);
register_A = (register_A >> 1) | ((register_B & 1) << 11);
register_B = (register_B >> 1) | (register_B & 0x800);
acc_a0 = register_A; /* store old acc value */
register_B = (flag_C = ((cmp_old = register_B) + (cmp_new = ram[register_I = 0x0a]))) & 0xFFF; /* do acc operation */
ram[register_I = (register_P << 4) + 0x5] = register_B; /* set I register and store B to ram */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x0b]; /* set I register */
ram[register_I = 0x06] = register_A; /* store acc to RAM */
flag_C = acc_a0 = register_A;
cmp_old = register_B;
register_B = cmp_new = ram[register_I];
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x05]; /* set I register */
FromX = register_A & 0xFFF; /* regA goes to x-coord */
FromY = register_B & 0xFFF; /* regB goes to y-coord */
register_P = 0x6; /* set page register */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = 0x63]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
register_P = 0x0; /* set page register */
ram[register_I = 0x07] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0800;
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = ram[register_I];
register_J = 0x0706;
if (cmp_new < cmp_old) {register_PC = 0x0706; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
case 0x0706:
ram[register_I = (register_P << 4) + 0xe] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x06]; /* set I register */
register_P = 0x6; /* set page register */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = 0x64]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
register_P = 0x0; /* set page register */
ram[register_I = 0x08] = register_A; /* store acc to RAM */
flag_C = acc_a0 = register_A;
cmp_old = register_B;
register_B = cmp_new = ram[register_I];
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0800;
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = ram[register_I];
register_J = 0x0716;
if (cmp_new < cmp_old) {register_PC = 0x0716; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
case 0x0716:
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = (register_P << 4) + 0xe]))) & 0xFFF; /* do acc operation */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (((cmp_new = 0x3) ^ 0xFFF) + 1))) & 0xFFF; /* 1's-comp add */
register_J = 0x07a4;
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x07a4; continue;};
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x07]; /* set I register */
{int temp_byte = 0;
for (;;) {
if ( ((((register_A >> 8) & 0x0A) != 0) && ((((register_A >> 8) & 0x0A) ^ 0x0A)) != 0)
|| ((((register_B >> 8) & 0x0A) != 0) && ((((register_B >> 8) & 0x0A) ^ 0x0A)) != 0) ) break;
register_A <<= 1; register_B <<= 1;
temp_byte = (temp_byte+1) & 0xff; if (temp_byte == 0) break /* This may not be correct */;
}
vgShiftLength = temp_byte & 0xfff; register_A &= 0x0FFF; register_B &= 0x0FFF;
}
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = (register_P << 4) + 0x5]))) & 0xFFF; /* do acc operation */
acc_a0 = register_A; /* store old acc value */
register_B = (flag_C = ((cmp_old = register_B) + (cmp_new = ram[register_I = (register_P << 4) + 0x06]))) & 0xFFF; /* do acc operation */
{
/* set ending points and draw the vector, or buffer for a later draw. */
int ToX = register_A & 0xFFF;
int ToY = register_B & 0xFFF;
/* Sign extend from 20 bit CCPU to 32bit target machine */
FromX = SEX(FromX);
ToX = SEX(ToX);
FromY = SEX(FromY);
ToY = SEX(ToY);
/* figure out the vector */
ToX -= FromX;
ToX = ((int)(((int)ToX) >> (int)((vgShiftLength)&31))) /* SAR */;
ToX += FromX;
ToY -= FromY;
ToY = ((int)(((int)ToY) >> (int)((vgShiftLength)&31))) /* SAR */;
ToY += FromY;
/* render the line */
CinemaVectorData (FromX, FromY, ToX, ToY, vgColour);
}
register_J = 0x07a4;
{register_PC = 0x07a4; continue;};
case 0x0724:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_new = 0x1; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x0001;
vgColour = 0x0f;
register_P = 0x0; /* set page register */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x0a]; /* set I register */
register_P = 0x6; /* set page register */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = 0x63]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
register_P = 0x0; /* set page register */
ram[register_I = 0x07] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x0b]; /* set I register */
register_P = 0x6; /* set page register */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = 0x64]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
register_P = 0x0; /* set page register */
ram[register_I = 0x08] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x07]; /* set I register */
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
ram[register_I = 0x0e] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0700;
cmp_old = register_A; cmp_new = 0xa4;
register_A = flag_C = acc_a0 = 0x07a4;
case 0x073b:
ram[register_I = (register_P << 4) + 0x1] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0a]; /* set I register */
ram[register_I = (register_P << 4) + 0x2] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0b]; /* set I register */
ram[register_I = (register_P << 4) + 0x3] = register_A; /* store acc to RAM */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = (register_P << 4) + 0x8]))) & 0xFFF; /* do acc operation */
ram[register_I = (register_P << 4) + 0x9] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0a]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = (register_P << 4) + 0x7]))) & 0xFFF; /* do acc operation */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = (register_P << 4) + 0xe]))) & 0xFFF; /* do acc operation */
ram[register_I = (register_P << 4) + 0x4] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0700;
cmp_old = register_A; cmp_new = 0x81;
register_A = flag_C = acc_a0 = 0x0781;
ram[register_I = (register_P << 4) + 0xc] = 0x781; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x02]; /* set I register */
flag_C = acc_a0 = register_A;
cmp_old = register_B; /* store old acc */
register_B = cmp_new = ram[register_I = (register_P << 4) + 0x03]; /* new acc value */
register_J = 0x074f;
FromX = register_A & 0xFFF; /* regA goes to x-coord */
FromY = register_B & 0xFFF; /* regB goes to y-coord */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = acc_a0 = register_A; /* back up regA */
register_A = (flag_C = (register_A + (((cmp_new = 0x0b) ^ 0xFFF) + 1))) & 0xFFF; /* add */
case 0x0754:
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
register_J = 0x0754;
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x0754; continue;};
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x09]; /* set I register */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = (register_P << 4) + 0x3]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
ram[register_I = (register_P << 4) + 0xd] = register_A; /* store acc to RAM */
flag_C = acc_a0 = register_A;
cmp_old = register_B;
register_B = cmp_new = ram[register_I];
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0800;
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = ram[register_I];
register_J = 0x0764;
if (cmp_new < cmp_old) {register_PC = 0x0764; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
case 0x0764:
ram[register_I] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x04]; /* set I register */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = (register_P << 4) + 0x2]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
ram[register_I = (register_P << 4) + 0xf] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0800;
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = ram[register_I];
register_J = 0x076f;
if (cmp_new < cmp_old) {register_PC = 0x076f; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
case 0x076f:
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = (register_P << 4) + 0xd]))) & 0xFFF; /* do acc operation */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (((cmp_new = 0x3) ^ 0xFFF) + 1))) & 0xFFF; /* 1's-comp add */
register_J = 0x077a;
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x077a; continue;};
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0f]; /* set I register */
{int temp_byte = 0;
for (;;) {
if ( ((((register_A >> 8) & 0x0A) != 0) && ((((register_A >> 8) & 0x0A) ^ 0x0A)) != 0)
|| ((((register_B >> 8) & 0x0A) != 0) && ((((register_B >> 8) & 0x0A) ^ 0x0A)) != 0) ) break;
register_A <<= 1; register_B <<= 1;
temp_byte = (temp_byte+1) & 0xff; if (temp_byte == 0) break /* This may not be correct */;
}
vgShiftLength = temp_byte & 0xfff; register_A &= 0x0FFF; register_B &= 0x0FFF;
}
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = (register_P << 4) + 0x2]))) & 0xFFF; /* do acc operation */
acc_a0 = register_A; /* store old acc value */
register_B = (flag_C = ((cmp_old = register_B) + (cmp_new = ram[register_I = (register_P << 4) + 0x03]))) & 0xFFF; /* do acc operation */
{
/* set ending points and draw the vector, or buffer for a later draw. */
int ToX = register_A & 0xFFF;
int ToY = register_B & 0xFFF;
/* Sign extend from 20 bit CCPU to 32bit target machine */
FromX = SEX(FromX);
ToX = SEX(ToX);
FromY = SEX(FromY);
ToY = SEX(ToY);
/* figure out the vector */
ToX -= FromX;
ToX = ((int)(((int)ToX) >> (int)((vgShiftLength)&31))) /* SAR */;
ToX += FromX;
ToY -= FromY;
ToY = ((int)(((int)ToY) >> (int)((vgShiftLength)&31))) /* SAR */;
ToY += FromY;
/* render the line */
CinemaVectorData (FromX, FromY, ToX, ToY, vgColour);
}
case 0x077a:
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x04]; /* set I register */
ram[register_I = (register_P << 4) + 0x2] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x09]; /* set I register */
ram[register_I = (register_P << 4) + 0x3] = register_A; /* store acc to RAM */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0xc]) ^ 0xFFF) + 1 + register_A);
/* load J reg from value at last dir addr */
register_J = ram[register_I];
if ((register_J & (~0xfff)) != 0) ERROR("Ram value must have been > 12 bits!\n");
{register_PC = register_J; continue;};
case 0x07a4:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0400;
register_P = 0x6; /* set page register */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = 0x63]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
ram[register_I = 0x65] = register_A; /* store acc to RAM */
flag_C = acc_a0 = register_A;
cmp_old = register_B; /* step back cmp flag */
register_B = cmp_new = 0;
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x62]; /* set I register */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x65]) ^ 0xFFF) + 1 + register_A);
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = 0x0EEE; cmp_old = acc_a0 = register_A; flag_C = (0x0EEE + register_A);
register_A = (register_A >> 1) | ((register_B & 1) << 11);
register_B = (register_B >> 1) | (register_B & 0x800);
ram[register_I = (register_P << 4) + 0x5] = register_B; /* set I register and store B to ram */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = ram[register_I];
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = 0x63]))) & 0xFFF; /* do acc operation */
register_P = 0x0; /* set page register */
ram[register_I = 0x0a] = register_A; /* store acc to RAM */
flag_C = acc_a0 = register_A;
cmp_old = register_B; /* store old acc */
register_B = cmp_new = ram[register_I = (register_P << 4) + 0x0b]; /* new acc value */
register_J = 0x07bb;
FromX = register_A & 0xFFF; /* regA goes to x-coord */
FromY = register_B & 0xFFF; /* regB goes to y-coord */
case 0x07bd:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_P = 0x5; /* set page register */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x50]) ^ 0xFFF) + 1 + register_A);
register_J = 0x07e6;
if (cmp_new == cmp_old) {register_PC = 0x07e6; continue;};
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x57]) ^ 0xFFF) + 1 + register_A);
register_J = 0x07d0;
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x07d0; continue;};
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x5d]) ^ 0xFFF) + 1 + register_A);
if (cmp_new == cmp_old) {register_PC = 0x07d0; continue;};
ram[register_I = 0x56] = 0x000; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x54]; /* set I register */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (((cmp_new = 0x2) ^ 0xFFF) + 1))) & 0xFFF; /* 1's-comp add */
ram[0x54] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x55]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
ram[0x55] = register_A; /* store acc */
case 0x07d0:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_new = 0x2; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x0002;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0x7]) ^ 0xFFF) + 1 + register_A);
register_J = 0x07e3;
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x07e3; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0700;
cmp_old = register_A; cmp_new = 0xed;
register_A = flag_C = acc_a0 = 0x07ed;
register_P = 0x0; /* set page register */
ram[register_I = 0x00] = 0x7ed; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x51;
register_A = flag_C = acc_a0 = 0x0051;
register_P = 0x1; /* set page register */
ram[register_I = 0x19] = 0x051; /* store acc to RAM */
register_J = 0x0c00;
{register_PC = 0x0c00; continue;};
case 0x07e3:
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x07]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
ram[register_I] = register_A; /* store acc */
case 0x07e6:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = acc_a0 = register_A; /* back up regA */
register_A = (flag_C = (register_A + (((cmp_new = 0x64) ^ 0xFFF) + 1))) & 0xFFF; /* add */
case 0x07e9:
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
register_J = 0x07e9;
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x07e9; continue;};
case 0x07ed:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_P = 0x6; /* set page register */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x62]) ^ 0xFFF) + 1 + register_A);
register_J = 0x0855;
if (cmp_new == cmp_old) {register_PC = 0x0855; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = get_io_bit(0xd);
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
register_J = 0x083e;
if (cmp_new == cmp_old) {register_PC = 0x083e; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x40;
register_A = flag_C = acc_a0 = 0x0040;
register_P = 0x0; /* set page register */
ram[register_I = 0x05] = 0x040; /* store acc to RAM */
flag_C = acc_a0 = register_A;
cmp_old = register_B; /* step back cmp flag */
register_B = cmp_new = 0;
register_P = 0x6; /* set page register */
register_PC = 0x0800; return;
default: return; // Switch banks
}
}
}
/*********************************************************/
void cineExecute0800()
{
for (;;) {
switch (register_PC)
{
case 0x0800:
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x62]; /* set I register */
register_P = 0x0; /* set page register */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x05]) ^ 0xFFF) + 1 + register_A);
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = 0x0EEE; cmp_old = acc_a0 = register_A; flag_C = (0x0EEE + register_A);
register_A = (register_A >> 1) | ((register_B & 1) << 11);
register_B = (register_B >> 1) | (register_B & 0x800);
acc_a0 = register_A; /* store old acc value */
register_B = (flag_C = ((cmp_old = register_B) + (cmp_new = ram[register_I = 0x0a]))) & 0xFFF; /* do acc operation */
ram[register_I = (register_P << 4) + 0x5] = register_B; /* set I register and store B to ram */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x0b]; /* set I register */
ram[register_I = 0x06] = register_A; /* store acc to RAM */
flag_C = acc_a0 = register_A;
cmp_old = register_B;
register_B = cmp_new = ram[register_I];
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x05]; /* set I register */
FromX = register_A & 0xFFF; /* regA goes to x-coord */
FromY = register_B & 0xFFF; /* regB goes to y-coord */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x05]; /* set I register */
register_P = 0x6; /* set page register */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = 0x63]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
register_P = 0x0; /* set page register */
ram[register_I = 0x07] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0800;
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = ram[register_I];
register_J = 0x0820;
if (cmp_new < cmp_old) {register_PC = 0x0820; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
case 0x0820:
ram[register_I = (register_P << 4) + 0xe] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x06]; /* set I register */
register_P = 0x6; /* set page register */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = 0x64]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
register_P = 0x0; /* set page register */
ram[register_I = 0x08] = register_A; /* store acc to RAM */
flag_C = acc_a0 = register_A;
cmp_old = register_B;
register_B = cmp_new = ram[register_I];
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0800;
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = ram[register_I];
register_J = 0x0830;
if (cmp_new < cmp_old) {register_PC = 0x0830; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
case 0x0830:
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = (register_P << 4) + 0xe]))) & 0xFFF; /* do acc operation */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (((cmp_new = 0x3) ^ 0xFFF) + 1))) & 0xFFF; /* 1's-comp add */
register_J = 0x0855;
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x0855; continue;};
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x07]; /* set I register */
{int temp_byte = 0;
for (;;) {
if ( ((((register_A >> 8) & 0x0A) != 0) && ((((register_A >> 8) & 0x0A) ^ 0x0A)) != 0)
|| ((((register_B >> 8) & 0x0A) != 0) && ((((register_B >> 8) & 0x0A) ^ 0x0A)) != 0) ) break;
register_A <<= 1; register_B <<= 1;
temp_byte = (temp_byte+1) & 0xff; if (temp_byte == 0) break /* This may not be correct */;
}
vgShiftLength = temp_byte & 0xfff; register_A &= 0x0FFF; register_B &= 0x0FFF;
}
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = (register_P << 4) + 0x5]))) & 0xFFF; /* do acc operation */
acc_a0 = register_A; /* store old acc value */
register_B = (flag_C = ((cmp_old = register_B) + (cmp_new = ram[register_I = (register_P << 4) + 0x06]))) & 0xFFF; /* do acc operation */
{
/* set ending points and draw the vector, or buffer for a later draw. */
int ToX = register_A & 0xFFF;
int ToY = register_B & 0xFFF;
/* Sign extend from 20 bit CCPU to 32bit target machine */
FromX = SEX(FromX);
ToX = SEX(ToX);
FromY = SEX(FromY);
ToY = SEX(ToY);
/* figure out the vector */
ToX -= FromX;
ToX = ((int)(((int)ToX) >> (int)((vgShiftLength)&31))) /* SAR */;
ToX += FromX;
ToY -= FromY;
ToY = ((int)(((int)ToY) >> (int)((vgShiftLength)&31))) /* SAR */;
ToY += FromY;
/* render the line */
CinemaVectorData (FromX, FromY, ToX, ToY, vgColour);
}
register_J = 0x0855;
{register_PC = 0x0855; continue;};
case 0x083e:
register_P = 0x0; /* set page register */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x0a]; /* set I register */
register_P = 0x6; /* set page register */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = 0x63]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
register_P = 0x0; /* set page register */
ram[register_I = 0x07] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x0b]; /* set I register */
register_P = 0x6; /* set page register */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = 0x64]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
register_P = 0x0; /* set page register */
ram[register_I = 0x08] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x07]; /* set I register */
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
ram[register_I = 0x0e] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0800;
cmp_old = register_A; cmp_new = 0x55;
register_A = flag_C = acc_a0 = 0x0855;
register_J = 0x073b;
{register_PC = 0x073b; continue;};
case 0x0855:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_P = 0x6; /* set page register */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x62]; /* set I register */
register_J = 0x085d;
if (cmp_new == cmp_old) {register_PC = 0x085d; continue;};
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (((cmp_new = 0x1) ^ 0xFFF) + 1))) & 0xFFF; /* 1's-comp add */
ram[0x62] = register_A; /* store acc */
case 0x085d:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_P = 0x6; /* set page register */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x69]) ^ 0xFFF) + 1 + register_A);
register_J = 0x08ed;
if (cmp_new == cmp_old) {register_PC = 0x08ed; continue;};
cmp_new = 0x2; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x0002;
register_P = 0x3; /* set page register */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x37]) ^ 0xFFF) + 1 + register_A);
register_J = 0x088e;
if (cmp_new < cmp_old) {register_PC = 0x088e; continue;};
cmp_new = 0x5; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x0007;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x37]) ^ 0xFFF) + 1 + register_A);
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x088e; continue;};
register_J = 0x0898;
{register_PC = 0x0898; continue;};
case 0x086f:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x18;
register_A = flag_C = acc_a0 = 0x0018;
set_sound_data(0);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_A(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_B(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_C(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x16;
register_A = flag_C = acc_a0 = 0x0016;
set_sound_data(0);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_A(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_B(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_C(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
register_J = 0x045e;
{register_PC = 0x045e; continue;};
case 0x088e:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_new = 0x2; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x0002;
register_P = 0x4; /* set page register */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x47]) ^ 0xFFF) + 1 + register_A);
register_J = 0x08a9;
if (cmp_new < cmp_old) {register_PC = 0x08a9; continue;};
cmp_new = 0x5; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x0007;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x47]) ^ 0xFFF) + 1 + register_A);
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x08a9; continue;};
case 0x0898:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x1f;
register_A = flag_C = acc_a0 = 0x001f;
set_sound_data(1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_A(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_B(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_C(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
register_J = 0x08fb;
{register_PC = 0x08fb; continue;};
case 0x08a9:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_new = 0x2; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x0002;
register_P = 0x5; /* set page register */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x57]) ^ 0xFFF) + 1 + register_A);
register_J = 0x08ed;
if (cmp_new < cmp_old) {register_PC = 0x08ed; continue;};
cmp_new = 0x5; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x0007;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x57]) ^ 0xFFF) + 1 + register_A);
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x08ed; continue;};
register_J = 0x0898;
{register_PC = 0x0898; continue;};
case 0x08b6:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_P = 0x7; /* set page register */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x7a]) ^ 0xFFF) + 1 + register_A);
register_J = 0x08ed;
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x08ed; continue;};
register_P = 0x3; /* set page register */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x30]) ^ 0xFFF) + 1 + register_A);
register_J = 0x0308;
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x0308; continue;};
register_P = 0x4; /* set page register */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x40]) ^ 0xFFF) + 1 + register_A);
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x0308; continue;};
register_P = 0x5; /* set page register */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x50]) ^ 0xFFF) + 1 + register_A);
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x0308; continue;};
register_P = 0x7; /* set page register */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x7d]) ^ 0xFFF) + 1 + register_A);
register_J = 0x02b6;
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x02b6; continue;};
register_P = 0x6; /* set page register */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x69]) ^ 0xFFF) + 1 + register_A);
register_J = 0x02de;
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x02de; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x14;
register_A = flag_C = acc_a0 = 0x0014;
set_sound_data(0);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_A(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_B(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_C(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_P = 0x7; /* set page register */
ram[register_I = 0x73] = 0x000; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0f00;
ram[register_I = 0x7e] = 0xf00; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x10;
register_A = flag_C = acc_a0 = 0x0010;
ram[register_I = 0x7c] = 0x010; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_new = 0x1; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x0001;
ram[register_I = 0x7d] = 0x001; /* store acc to RAM */
case 0x08ed:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x1e;
register_A = flag_C = acc_a0 = 0x001e;
set_sound_data(0);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_A(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_B(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_C(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
case 0x08fb:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0600;
cmp_old = register_A; cmp_new = 0x00;
register_A = flag_C = acc_a0 = 0x0600;
register_P = 0x0; /* set page register */
ram[register_I = 0x00] = 0x600; /* store acc to RAM */
register_J = 0x0080;
register_P = 0x2; /* set page register */
register_PC = 0x1080; /* rom offset */
{register_PC = 0x1080; continue;};
case 0x0904:
flag_C = acc_a0 = register_A;
cmp_old = register_B; /* save old accB */
register_B = cmp_new = get_shield_bit2();
cmp_new = 0x0CEC; acc_a0 = register_A; cmp_old = register_B; flag_C = (0x0CEC + register_B);
register_B = (register_B << 1) & 0xFFF;
register_P = 0x8; /* set page register */
ram[register_I = (register_P << 4) + 0x2] = register_B; /* set I register and store B to ram */
flag_C = acc_a0 = register_A;
cmp_old = register_B; /* save old accB */
register_B = cmp_new = get_shield_bit1();
acc_a0 = register_A;
cmp_old = register_B;
register_B = (flag_C = (register_B + (cmp_new = ram[register_I]))) & 0xFFF;
set_watchdog();
cmp_new = 0x0CEC; acc_a0 = register_A; cmp_old = register_B; flag_C = (0x0CEC + register_B);
register_B = (register_B << 1) & 0xFFF;
ram[register_I] = register_B; /* store acc */
flag_C = acc_a0 = register_A;
cmp_old = register_B; /* save old accB */
register_B = cmp_new = get_shield_bit0();
acc_a0 = register_A;
cmp_old = register_B;
register_B = (flag_C = (register_B + (cmp_new = ram[register_I]))) & 0xFFF;
set_watchdog();
ram[register_I] = register_B; /* store acc */
register_J = 0x0026;
{register_PC = 0x0026; continue;};
register_PC = 0x0c00; return;
default: return; // Switch banks
}
}
}
/*********************************************************/
void cineExecute0c00()
{
for (;;) {
switch (register_PC)
{
case 0x0c00:
register_P = 0x1; /* set page register */
register_I = ram[0x19]&0xff; /* set new register_I (8 bits) */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = ram[register_I];
ram[register_I = 0x10] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x19]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
ram[0x19] = register_A; /* store acc */
register_I = ram[0x19]&0xff; /* set new register_I (8 bits) */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = ram[register_I];
ram[register_I = 0x11] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x19]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
ram[0x19] = register_A; /* store acc */
register_I = ram[0x19]&0xff; /* set new register_I (8 bits) */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = ram[register_I];
ram[register_I = 0x12] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x19]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
ram[0x19] = register_A; /* store acc */
register_I = ram[0x19]&0xff; /* set new register_I (8 bits) */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = ram[register_I];
ram[register_I = 0x13] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x19]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
ram[0x19] = register_A; /* store acc */
register_I = ram[0x19]&0xff; /* set new register_I (8 bits) */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = ram[register_I];
ram[register_I = 0x14] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x19]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
ram[0x19] = register_A; /* store acc */
register_I = ram[0x19]&0xff; /* set new register_I (8 bits) */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = ram[register_I];
ram[register_I = 0x15] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x19]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x2))) & 0xFFF; /* add values, save carry */
ram[0x19] = register_A; /* store acc */
register_I = ram[0x19]&0xff; /* set new register_I (8 bits) */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = ram[register_I];
ram[register_I = 0x1a] = register_A; /* store acc to RAM */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = 0x10]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
ram[register_I = 0x16] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x1e;
register_A = flag_C = acc_a0 = 0x001e;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x16]) ^ 0xFFF) + 1 + register_A);
register_J = 0x0c48;
if (cmp_new < cmp_old) {register_PC = 0x0c48; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0800;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x16]) ^ 0xFFF) + 1 + register_A);
register_J = 0x0c44;
if (cmp_new < cmp_old) {register_PC = 0x0c44; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = acc_a0 = register_A; /* back up regA */
register_A = (flag_C = (register_A + (((cmp_new = 0x1e) ^ 0xFFF) + 1))) & 0xFFF; /* add */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x16]) ^ 0xFFF) + 1 + register_A);
register_J = 0x0c47;
if (cmp_new < cmp_old) {register_PC = 0x0c47; continue;};
register_J = 0x0c48;
{register_PC = 0x0c48; continue;};
case 0x0c44:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x1e;
register_A = flag_C = acc_a0 = 0x001e;
case 0x0c47:
ram[register_I = (register_P << 4) + 0x6] = register_A; /* store acc to RAM */
case 0x0c48:
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x09]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
ram[register_I] = register_A; /* store acc */
register_I = ram[(register_P << 4) + 0x09]&0xff; /* set/mask new register_I */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = ram[register_I];
ram[register_I = (register_P << 4) + 0xb] = register_A; /* store acc to RAM */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = (register_P << 4) + 0x1]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
ram[register_I = (register_P << 4) + 0x7] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x1e;
register_A = flag_C = acc_a0 = 0x001e;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0x7]) ^ 0xFFF) + 1 + register_A);
register_J = 0x0c6e;
if (cmp_new < cmp_old) {register_PC = 0x0c6e; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0800;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0x7]) ^ 0xFFF) + 1 + register_A);
register_J = 0x0c6a;
if (cmp_new < cmp_old) {register_PC = 0x0c6a; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = acc_a0 = register_A; /* back up regA */
register_A = (flag_C = (register_A + (((cmp_new = 0x1e) ^ 0xFFF) + 1))) & 0xFFF; /* add */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0x7]) ^ 0xFFF) + 1 + register_A);
register_J = 0x0c6d;
if (cmp_new < cmp_old) {register_PC = 0x0c6d; continue;};
register_J = 0x0c6e;
{register_PC = 0x0c6e; continue;};
case 0x0c6a:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x1e;
register_A = flag_C = acc_a0 = 0x001e;
case 0x0c6d:
ram[register_I = (register_P << 4) + 0x7] = register_A; /* store acc to RAM */
case 0x0c6e:
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x09]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
ram[register_I] = register_A; /* store acc */
register_I = ram[(register_P << 4) + 0x09]&0xff; /* set/mask new register_I */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = ram[register_I];
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0x2]) ^ 0xFFF) + 1 + register_A);
register_J = 0x0c81;
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x0c81; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x40;
register_A = flag_C = acc_a0 = 0x0040;
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = (register_P << 4) + 0x6]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
ram[register_I] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x40;
register_A = flag_C = acc_a0 = 0x0040;
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = (register_P << 4) + 0x7]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
ram[register_I] = register_A; /* store acc */
case 0x0c81:
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x09]; /* set I register */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (((cmp_new = 0x6) ^ 0xFFF) + 1))) & 0xFFF; /* 1's-comp add */
ram[register_I] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x06]; /* set I register */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = (register_P << 4) + 0x3]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
ram[register_I = (register_P << 4) + 0xe] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x7f;
register_A = flag_C = acc_a0 = 0x007f;
cmp_old = flag_C = acc_a0 = register_A;
register_A &= (cmp_new = ram[register_I]);
ram[register_I] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0xe]) ^ 0xFFF) + 1 + register_A);
register_J = 0x0c9e;
if (cmp_new == cmp_old) {register_PC = 0x0c9e; continue;};
cmp_old = register_A; cmp_new = 0x40;
register_A = flag_C = acc_a0 = 0x0040;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0xe]) ^ 0xFFF) + 1 + register_A);
register_J = 0x0c9c;
if (cmp_new < cmp_old) {register_PC = 0x0c9c; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (((cmp_new = 0x1) ^ 0xFFF) + 1))) & 0xFFF; /* 1's-comp add */
register_J = 0x0c9e;
{register_PC = 0x0c9e; continue;};
case 0x0c9c:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_new = 0x1; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x0001;
case 0x0c9e:
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = (register_P << 4) + 0x3]))) & 0xFFF; /* do acc operation */
ram[register_I = (register_P << 4) + 0xe] = register_A; /* store acc to RAM */
register_I = ram[(register_P << 4) + 0x09]&0xff; /* set/mask new register_I */
ram[register_I] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0c00;
cmp_old = register_A; cmp_new = 0xa9;
register_A = flag_C = acc_a0 = 0x0ca9;
ram[register_I = (register_P << 4) + 0xf] = 0xca9; /* store acc to RAM */
register_J = 0x0eeb;
{register_PC = 0x0eeb; continue;};
case 0x0ca9:
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0a]; /* set I register */
ram[register_I = (register_P << 4) + 0xc] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0b]; /* set I register */
ram[register_I = (register_P << 4) + 0xd] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x09]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
ram[register_I] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x07]; /* set I register */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = (register_P << 4) + 0x4]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
ram[register_I = (register_P << 4) + 0xe] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x7f;
register_A = flag_C = acc_a0 = 0x007f;
cmp_old = flag_C = acc_a0 = register_A;
register_A &= (cmp_new = ram[register_I]);
ram[register_I] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0xe]) ^ 0xFFF) + 1 + register_A);
register_J = 0x0cca;
if (cmp_new == cmp_old) {register_PC = 0x0cca; continue;};
cmp_old = register_A; cmp_new = 0x40;
register_A = flag_C = acc_a0 = 0x0040;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0xe]) ^ 0xFFF) + 1 + register_A);
register_J = 0x0cc8;
if (cmp_new < cmp_old) {register_PC = 0x0cc8; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (((cmp_new = 0x1) ^ 0xFFF) + 1))) & 0xFFF; /* 1's-comp add */
register_J = 0x0cca;
{register_PC = 0x0cca; continue;};
case 0x0cc8:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_new = 0x1; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x0001;
case 0x0cca:
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = (register_P << 4) + 0x4]))) & 0xFFF; /* do acc operation */
ram[register_I = (register_P << 4) + 0xe] = register_A; /* store acc to RAM */
register_I = ram[(register_P << 4) + 0x09]&0xff; /* set/mask new register_I */
ram[register_I] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0c00;
cmp_old = register_A; cmp_new = 0xd5;
register_A = flag_C = acc_a0 = 0x0cd5;
ram[register_I = (register_P << 4) + 0xf] = 0xcd5; /* store acc to RAM */
register_J = 0x0eeb;
{register_PC = 0x0eeb; continue;};
case 0x0cd5:
flag_C = acc_a0 = register_A;
cmp_old = register_B; /* step back cmp flag */
register_B = cmp_new = 0;
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0800;
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0c]; /* set I register */
register_J = 0x0cde;
if (cmp_new < cmp_old) {register_PC = 0x0cde; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
case 0x0cde:
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0xb]) ^ 0xFFF) + 1 + register_A);
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0800;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0xc]) ^ 0xFFF) + 1 + register_A);
ram[register_I = (register_P << 4) + 0x3] = register_B; /* set I register and store B to ram */
register_J = 0x0cf2;
if (cmp_new < cmp_old) {register_PC = 0x0cf2; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = (register_P << 4) + 0x3]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
ram[register_I] = register_A; /* store acc */
case 0x0cf2:
flag_C = acc_a0 = register_A;
cmp_old = register_B; /* step back cmp flag */
register_B = cmp_new = 0;
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0800;
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x03]; /* set I register */
register_J = 0x0cfb;
if (cmp_new < cmp_old) {register_PC = 0x0cfb; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
case 0x0cfb:
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0x5]) ^ 0xFFF) + 1 + register_A);
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0800;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0x3]) ^ 0xFFF) + 1 + register_A);
ram[register_I = (register_P << 4) + 0x3] = register_B; /* set I register and store B to ram */
register_J = 0x0d0f;
if (cmp_new < cmp_old) {register_PC = 0x0d0f; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = (register_P << 4) + 0x3]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
ram[register_I] = register_A; /* store acc */
case 0x0d0f:
flag_C = acc_a0 = register_A;
cmp_old = register_B; /* step back cmp flag */
register_B = cmp_new = 0;
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0800;
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0a]; /* set I register */
register_J = 0x0d18;
if (cmp_new < cmp_old) {register_PC = 0x0d18; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
case 0x0d18:
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0x5]) ^ 0xFFF) + 1 + register_A);
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0800;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0xa]) ^ 0xFFF) + 1 + register_A);
ram[register_I = (register_P << 4) + 0x4] = register_B; /* set I register and store B to ram */
register_J = 0x0d2c;
if (cmp_new < cmp_old) {register_PC = 0x0d2c; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = (register_P << 4) + 0x4]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
ram[register_I] = register_A; /* store acc */
case 0x0d2c:
flag_C = acc_a0 = register_A;
cmp_old = register_B; /* step back cmp flag */
register_B = cmp_new = 0;
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0800;
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0d]; /* set I register */
register_J = 0x0d35;
if (cmp_new < cmp_old) {register_PC = 0x0d35; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
case 0x0d35:
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0xb]) ^ 0xFFF) + 1 + register_A);
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0800;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0xd]) ^ 0xFFF) + 1 + register_A);
ram[register_I = (register_P << 4) + 0xf] = register_B; /* set I register and store B to ram */
register_J = 0x0d49;
if (cmp_new < cmp_old) {register_PC = 0x0d49; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = (register_P << 4) + 0xf]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
ram[register_I] = register_A; /* store acc */
case 0x0d49:
flag_C = acc_a0 = register_A;
cmp_old = register_B; /* step back cmp flag */
register_B = cmp_new = 0;
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0800;
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0f]; /* set I register */
register_J = 0x0d52;
if (cmp_new < cmp_old) {register_PC = 0x0d52; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
case 0x0d52:
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0x5]) ^ 0xFFF) + 1 + register_A);
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0800;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0xf]) ^ 0xFFF) + 1 + register_A);
ram[register_I = (register_P << 4) + 0x5] = register_B; /* set I register and store B to ram */
register_J = 0x0d66;
if (cmp_new < cmp_old) {register_PC = 0x0d66; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = (register_P << 4) + 0x5]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
ram[register_I] = register_A; /* store acc */
case 0x0d66:
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x09]; /* set I register */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (((cmp_new = 0x4) ^ 0xFFF) + 1))) & 0xFFF; /* 1's-comp add */
ram[register_I] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x03]; /* set I register */
register_I = ram[(register_P << 4) + 0x09]&0xff; /* set/mask new register_I */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (cmp_new = ram[register_I]))) & 0xFFF;
set_watchdog();
ram[register_I] = register_A; /* store acc */
ram[register_I = (register_P << 4) + 0x0] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x09]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
ram[register_I] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x04]; /* set I register */
register_I = ram[(register_P << 4) + 0x09]&0xff; /* set/mask new register_I */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (cmp_new = ram[register_I]))) & 0xFFF;
set_watchdog();
ram[register_I] = register_A; /* store acc */
ram[register_I = (register_P << 4) + 0x1] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x09]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
ram[register_I] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = (register_P << 4) + 0x5]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
register_I = ram[(register_P << 4) + 0x09]&0xff; /* set/mask new register_I */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (cmp_new = ram[register_I]))) & 0xFFF;
set_watchdog();
ram[register_I] = register_A; /* store acc */
ram[register_I = (register_P << 4) + 0x2] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x09]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x9))) & 0xFFF; /* add values, save carry */
ram[register_I] = register_A; /* store acc */
register_P = 0x1; /* set page register */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x12]; /* set I register */
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
register_P = 0x0; /* set page register */
ram[register_I = 0x09] = register_A; /* store acc to RAM */
register_P = 0x1; /* set page register */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x10]; /* set I register */
register_P = 0x0; /* set page register */
ram[register_I = 0x05] = register_A; /* store acc to RAM */
register_P = 0x1; /* set page register */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x11]; /* set I register */
register_P = 0x0; /* set page register */
ram[register_I = 0x06] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0200;
ram[register_I = 0x0d] = 0x200; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
ram[register_I = 0x04] = 0x000; /* store acc to RAM */
case 0x0d93:
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0d]; /* set I register */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0x9]) ^ 0xFFF) + 1 + register_A);
register_J = 0x0e03;
if (cmp_new < cmp_old) {register_PC = 0x0e03; continue;};
flag_C = acc_a0 = register_A;
cmp_old = register_B; /* step back cmp flag */
register_B = cmp_new = 0;
cmp_new = 0x0FEF; cmp_old = acc_a0 = register_A; flag_C = (0x0FEF + register_A);
register_A = (register_A << 1) & 0xFFF; register_B = (register_B << 1) & 0xFFF;
acc_a0 = register_A; /* save old accA bit0 */
cmp_old = register_B; /* store old acc for later */
register_B = (flag_C = (register_B + (cmp_new = 0x01))) & 0xFFF; /* add values */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
register_J = 0x0da4;
if (cmp_new < cmp_old) {register_PC = 0x0da4; continue;};
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (cmp_new = ram[register_I]))) & 0xFFF;
set_watchdog();
acc_a0 = register_A;
register_B = (flag_C = ((cmp_old = register_B) + ((cmp_new = 0x1) ^ 0xFFF) + 1)) & 0xFFF; /* 1's-comp add */
case 0x0da4:
cmp_new = 0x0FEF; cmp_old = acc_a0 = register_A; flag_C = (0x0FEF + register_A);
register_A = (register_A << 1) & 0xFFF; register_B = (register_B << 1) & 0xFFF;
acc_a0 = register_A; /* save old accA bit0 */
cmp_old = register_B; /* store old acc for later */
register_B = (flag_C = (register_B + (cmp_new = 0x01))) & 0xFFF; /* add values */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
register_J = 0x0dae;
if (cmp_new < cmp_old) {register_PC = 0x0dae; continue;};
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (cmp_new = ram[register_I]))) & 0xFFF;
set_watchdog();
acc_a0 = register_A;
register_B = (flag_C = ((cmp_old = register_B) + ((cmp_new = 0x1) ^ 0xFFF) + 1)) & 0xFFF; /* 1's-comp add */
case 0x0dae:
cmp_new = 0x0FEF; cmp_old = acc_a0 = register_A; flag_C = (0x0FEF + register_A);
register_A = (register_A << 1) & 0xFFF; register_B = (register_B << 1) & 0xFFF;
acc_a0 = register_A; /* save old accA bit0 */
cmp_old = register_B; /* store old acc for later */
register_B = (flag_C = (register_B + (cmp_new = 0x01))) & 0xFFF; /* add values */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
register_J = 0x0db8;
if (cmp_new < cmp_old) {register_PC = 0x0db8; continue;};
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (cmp_new = ram[register_I]))) & 0xFFF;
set_watchdog();
acc_a0 = register_A;
register_B = (flag_C = ((cmp_old = register_B) + ((cmp_new = 0x1) ^ 0xFFF) + 1)) & 0xFFF; /* 1's-comp add */
case 0x0db8:
cmp_new = 0x0FEF; cmp_old = acc_a0 = register_A; flag_C = (0x0FEF + register_A);
register_A = (register_A << 1) & 0xFFF; register_B = (register_B << 1) & 0xFFF;
acc_a0 = register_A; /* save old accA bit0 */
cmp_old = register_B; /* store old acc for later */
register_B = (flag_C = (register_B + (cmp_new = 0x01))) & 0xFFF; /* add values */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
register_J = 0x0dc2;
if (cmp_new < cmp_old) {register_PC = 0x0dc2; continue;};
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (cmp_new = ram[register_I]))) & 0xFFF;
set_watchdog();
case 0x0dc0:
acc_a0 = register_A;
register_B = (flag_C = ((cmp_old = register_B) + ((cmp_new = 0x1) ^ 0xFFF) + 1)) & 0xFFF; /* 1's-comp add */
case 0x0dc2:
cmp_new = 0x0FEF; cmp_old = acc_a0 = register_A; flag_C = (0x0FEF + register_A);
register_A = (register_A << 1) & 0xFFF; register_B = (register_B << 1) & 0xFFF;
acc_a0 = register_A; /* save old accA bit0 */
cmp_old = register_B; /* store old acc for later */
register_B = (flag_C = (register_B + (cmp_new = 0x01))) & 0xFFF; /* add values */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
register_J = 0x0dcc;
if (cmp_new < cmp_old) {register_PC = 0x0dcc; continue;};
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (cmp_new = ram[register_I]))) & 0xFFF;
set_watchdog();
acc_a0 = register_A;
register_B = (flag_C = ((cmp_old = register_B) + ((cmp_new = 0x1) ^ 0xFFF) + 1)) & 0xFFF; /* 1's-comp add */
case 0x0dcc:
cmp_new = 0x0FEF; cmp_old = acc_a0 = register_A; flag_C = (0x0FEF + register_A);
register_A = (register_A << 1) & 0xFFF; register_B = (register_B << 1) & 0xFFF;
acc_a0 = register_A; /* save old accA bit0 */
cmp_old = register_B; /* store old acc for later */
register_B = (flag_C = (register_B + (cmp_new = 0x01))) & 0xFFF; /* add values */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
register_J = 0x0dd6;
if (cmp_new < cmp_old) {register_PC = 0x0dd6; continue;};
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (cmp_new = ram[register_I]))) & 0xFFF;
set_watchdog();
acc_a0 = register_A;
register_B = (flag_C = ((cmp_old = register_B) + ((cmp_new = 0x1) ^ 0xFFF) + 1)) & 0xFFF; /* 1's-comp add */
case 0x0dd6:
cmp_new = 0x0FEF; cmp_old = acc_a0 = register_A; flag_C = (0x0FEF + register_A);
register_A = (register_A << 1) & 0xFFF; register_B = (register_B << 1) & 0xFFF;
acc_a0 = register_A; /* save old accA bit0 */
cmp_old = register_B; /* store old acc for later */
register_B = (flag_C = (register_B + (cmp_new = 0x01))) & 0xFFF; /* add values */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
register_J = 0x0de0;
if (cmp_new < cmp_old) {register_PC = 0x0de0; continue;};
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (cmp_new = ram[register_I]))) & 0xFFF;
set_watchdog();
acc_a0 = register_A;
register_B = (flag_C = ((cmp_old = register_B) + ((cmp_new = 0x1) ^ 0xFFF) + 1)) & 0xFFF; /* 1's-comp add */
case 0x0de0:
cmp_new = 0x0FEF; cmp_old = acc_a0 = register_A; flag_C = (0x0FEF + register_A);
register_A = (register_A << 1) & 0xFFF; register_B = (register_B << 1) & 0xFFF;
acc_a0 = register_A; /* save old accA bit0 */
cmp_old = register_B; /* store old acc for later */
register_B = (flag_C = (register_B + (cmp_new = 0x01))) & 0xFFF; /* add values */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
register_J = 0x0dea;
if (cmp_new < cmp_old) {register_PC = 0x0dea; continue;};
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (cmp_new = ram[register_I]))) & 0xFFF;
set_watchdog();
acc_a0 = register_A;
register_B = (flag_C = ((cmp_old = register_B) + ((cmp_new = 0x1) ^ 0xFFF) + 1)) & 0xFFF; /* 1's-comp add */
case 0x0dea:
cmp_new = 0x0FEF; cmp_old = acc_a0 = register_A; flag_C = (0x0FEF + register_A);
register_A = (register_A << 1) & 0xFFF; register_B = (register_B << 1) & 0xFFF;
acc_a0 = register_A; /* save old accA bit0 */
cmp_old = register_B; /* store old acc for later */
register_B = (flag_C = (register_B + (cmp_new = 0x01))) & 0xFFF; /* add values */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
register_J = 0x0df4;
if (cmp_new < cmp_old) {register_PC = 0x0df4; continue;};
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (cmp_new = ram[register_I]))) & 0xFFF;
set_watchdog();
acc_a0 = register_A;
register_B = (flag_C = ((cmp_old = register_B) + ((cmp_new = 0x1) ^ 0xFFF) + 1)) & 0xFFF; /* 1's-comp add */
case 0x0df4:
cmp_new = 0x0FEF; cmp_old = acc_a0 = register_A; flag_C = (0x0FEF + register_A);
register_A = (register_A << 1) & 0xFFF; register_B = (register_B << 1) & 0xFFF;
acc_a0 = register_A; /* save old accA bit0 */
cmp_old = register_B; /* store old acc for later */
register_B = (flag_C = (register_B + (cmp_new = 0x01))) & 0xFFF; /* add values */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
register_J = 0x0dfe;
if (cmp_new < cmp_old) {register_PC = 0x0dfe; continue;};
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (cmp_new = ram[register_I]))) & 0xFFF;
set_watchdog();
acc_a0 = register_A;
register_B = (flag_C = ((cmp_old = register_B) + ((cmp_new = 0x1) ^ 0xFFF) + 1)) & 0xFFF; /* 1's-comp add */
case 0x0dfe:
ram[register_I = (register_P << 4) + 0x9] = register_B; /* set I register and store B to ram */
register_J = 0x0e0b;
{register_PC = 0x0e0b; continue;};
case 0x0e03:
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
ram[register_I = (register_P << 4) + 0xd] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x04]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
ram[register_I] = register_A; /* store acc */
register_J = 0x0d93;
{register_PC = 0x0d93; continue;};
case 0x0e0b:
flag_C = acc_a0 = register_A;
cmp_old = register_B; /* step back cmp flag */
register_B = cmp_new = 0;
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0800;
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x05]; /* set I register */
register_J = 0x0e14;
if (cmp_new < cmp_old) {register_PC = 0x0e14; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
case 0x0e14:
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0x9]) ^ 0xFFF) + 1 + register_A);
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
ram[register_I = (register_P << 4) + 0x7] = register_B; /* set I register and store B to ram */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0800;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0x5]) ^ 0xFFF) + 1 + register_A);
register_J = 0x0e2a;
if (cmp_new < cmp_old) {register_PC = 0x0e2a; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = (register_P << 4) + 0x7]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
ram[register_I] = register_A; /* store acc */
case 0x0e2a:
flag_C = acc_a0 = register_A;
cmp_old = register_B; /* step back cmp flag */
register_B = cmp_new = 0;
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0800;
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x06]; /* set I register */
register_J = 0x0e33;
if (cmp_new < cmp_old) {register_PC = 0x0e33; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
case 0x0e33:
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0x9]) ^ 0xFFF) + 1 + register_A);
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
ram[register_I = (register_P << 4) + 0x8] = register_B; /* set I register and store B to ram */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0800;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0x6]) ^ 0xFFF) + 1 + register_A);
register_J = 0x0e49;
if (cmp_new < cmp_old) {register_PC = 0x0e49; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = (register_P << 4) + 0x8]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
ram[register_I] = register_A; /* store acc */
case 0x0e49:
flag_C = acc_a0 = register_A;
cmp_old = register_B; /* step back cmp flag */
register_B = cmp_new = 0;
acc_a0 = register_A;
register_B = (flag_C = ((cmp_old = register_B) + ((cmp_new = ram[register_I = (register_P << 4) + 0x04]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
register_J = 0x0e5b;
if (cmp_new == cmp_old) {register_PC = 0x0e5b; continue;};
register_J = 0x0e52;
case 0x0e52:
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x05]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = (register_P << 4) + 0x7]))) & 0xFFF; /* do acc operation */
ram[register_I] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x06]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = (register_P << 4) + 0x8]))) & 0xFFF; /* do acc operation */
ram[register_I] = register_A; /* store acc */
acc_a0 = register_A; /* save old accA bit0 */
cmp_old = register_B; /* store old acc for later */
register_B = (flag_C = (register_B + (cmp_new = 0x01))) & 0xFFF; /* add values */
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x0e52; continue;};
case 0x0e5b:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0300;
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = (register_P << 4) + 0x8]))) & 0xFFF; /* do acc operation */
register_P = 0x1; /* set page register */
register_I = ram[0x19]&0xff; /* set new register_I (8 bits) */
ram[register_I] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x19]; /* set I register */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (((cmp_new = 0x1) ^ 0xFFF) + 1))) & 0xFFF; /* 1's-comp add */
ram[0x19] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0200;
register_P = 0x0; /* set page register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = 0x07]))) & 0xFFF; /* do acc operation */
register_P = 0x1; /* set page register */
register_I = ram[0x19]&0xff; /* set new register_I (8 bits) */
ram[register_I] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_P = 0x6; /* set page register */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x62]) ^ 0xFFF) + 1 + register_A);
register_J = 0x0ee7;
if (cmp_new == cmp_old) {register_PC = 0x0ee7; continue;};
cmp_new = 0x3; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x0003;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x62]) ^ 0xFFF) + 1 + register_A);
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x0ee7; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0200;
register_P = 0x1; /* set page register */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x12]) ^ 0xFFF) + 1 + register_A);
if (cmp_new < cmp_old) {register_PC = 0x0ee7; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
register_A = (flag_C = ((acc_a0 = cmp_old = register_A) + (cmp_new = 0x0016))) & 0xFFF; /* add values */
register_P = 0x0; /* set page register */
ram[register_I = 0x09] = register_A; /* store acc to RAM */
register_P = 0x2; /* set page register */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x2c]; /* set I register */
register_P = 0x0; /* set page register */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = 0x07]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
ram[0x07] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0800;
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = ram[register_I];
register_J = 0x0e90;
if (cmp_new < cmp_old) {register_PC = 0x0e90; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
case 0x0e90:
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = (register_P << 4) + 0x9]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
register_J = 0x0ee7;
if (cmp_new < cmp_old) {register_PC = 0x0ee7; continue;};
register_P = 0x2; /* set page register */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x2d]; /* set I register */
register_P = 0x0; /* set page register */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = 0x08]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
ram[0x08] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0800;
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x08]; /* set I register */
register_J = 0x0ea0;
if (cmp_new < cmp_old) {register_PC = 0x0ea0; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
case 0x0ea0:
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = (register_P << 4) + 0x9]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
register_J = 0x0ee7;
if (cmp_new < cmp_old) {register_PC = 0x0ee7; continue;};
register_P = 0x1; /* set page register */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x19]; /* set I register */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (((cmp_new = 0x4) ^ 0xFFF) + 1))) & 0xFFF; /* 1's-comp add */
ram[0x19] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_new = 0x3; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x0003;
register_I = ram[0x19]&0xff; /* set new register_I (8 bits) */
ram[register_I] = register_A; /* store acc */
case 0x0eac:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_P = 0x6; /* set page register */
ram[register_I = 0x6f] = 0x000; /* store acc to RAM */
cmp_new = 0xf; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x000f;
register_P = 0x7; /* set page register */
ram[register_I = 0x71] = 0x00f; /* store acc to RAM */
register_P = 0x2; /* set page register */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x24]) ^ 0xFFF) + 1 + register_A);
cmp_old = flag_C = acc_a0 = register_A;
register_A &= (cmp_new = ram[register_I]);
register_P = 0x6; /* set page register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = 0x6b]))) & 0xFFF; /* do acc operation */
ram[0x6b] = register_A; /* store acc */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (((cmp_new = 0xa) ^ 0xFFF) + 1))) & 0xFFF; /* 1's-comp add */
register_J = 0x0ec0;
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x0ec0; continue;};
ram[0x6b] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_new = 0x1; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x0001;
ram[register_I = 0x6f] = 0x001; /* store acc to RAM */
case 0x0ec0:
register_P = 0x2; /* set page register */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x24]; /* set I register */
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
register_P = 0x6; /* set page register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = 0x6f]))) & 0xFFF; /* do acc operation */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = 0x6a]))) & 0xFFF; /* do acc operation */
ram[0x6a] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_new = 0xf; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x000f;
cmp_old = flag_C = acc_a0 = register_A;
register_A &= (cmp_new = ram[register_I]);
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (((cmp_new = 0xa) ^ 0xFFF) + 1))) & 0xFFF; /* 1's-comp add */
register_J = 0x0edf;
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x0edf; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = ram[register_I];
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x6))) & 0xFFF; /* add values, save carry */
ram[0x6a] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0xf0;
register_A = flag_C = acc_a0 = 0x00f0;
cmp_old = flag_C = acc_a0 = register_A;
register_A &= (cmp_new = ram[register_I]);
cmp_old = acc_a0 = register_A; /* back up regA */
register_A = (flag_C = (register_A + (((cmp_new = 0xa0) ^ 0xFFF) + 1))) & 0xFFF; /* add */
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x0edf; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = ram[register_I];
register_A = (flag_C = ((acc_a0 = cmp_old = register_A) + (cmp_new = 0x0060))) & 0xFFF; /* add values */
ram[0x6a] = register_A; /* store acc */
case 0x0edf:
register_P = 0x2; /* set page register */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x29]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
ram[0x29] = register_A; /* store acc */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (((cmp_new = 0x3) ^ 0xFFF) + 1))) & 0xFFF; /* 1's-comp add */
register_J = 0x0eac;
if (cmp_new == cmp_old) {register_PC = 0x0eac; continue;};
case 0x0ee7:
register_P = 0x0; /* set page register */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x00]) ^ 0xFFF) + 1 + register_A);
/* load J reg from value at last dir addr */
register_J = ram[0x00];
if ((register_J & (~0xfff)) != 0) ERROR("Ram value must have been > 12 bits!\n");
{register_PC = register_J; continue;};
case 0x0eeb:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x7f;
register_A = flag_C = acc_a0 = 0x007f;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0xe]) ^ 0xFFF) + 1 + register_A);
cmp_old = flag_C = acc_a0 = register_A;
register_A &= (cmp_new = ram[register_I]);
ram[register_I] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0f00;
cmp_old = register_A; cmp_new = 0x6c;
register_A = flag_C = acc_a0 = 0x0f6c;
ram[register_I = (register_P << 4) + 0xa] = 0xf6c; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x20;
register_A = flag_C = acc_a0 = 0x0020;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0xe]) ^ 0xFFF) + 1 + register_A);
register_J = 0x0f15;
if (cmp_new < cmp_old) {register_PC = 0x0f15; continue;};
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0xe]) ^ 0xFFF) + 1 + register_A);
register_J = 0x0f21;
if (cmp_new < cmp_old) {register_PC = 0x0f21; continue;};
register_A = (flag_C = ((acc_a0 = cmp_old = register_A) + (cmp_new = 0x0020))) & 0xFFF; /* add values */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0xe]) ^ 0xFFF) + 1 + register_A);
register_J = 0x0f35;
if (cmp_new < cmp_old) {register_PC = 0x0f35; continue;};
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0a]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = (register_P << 4) + 0xe]))) & 0xFFF; /* do acc operation */
cmp_old = acc_a0 = register_A; /* back up regA */
register_A = (flag_C = (register_A + (((cmp_new = 0x80) ^ 0xFFF) + 1))) & 0xFFF; /* add */
cmp_old = register_A; register_A = cmp_new = rom[register_A]; /* new acc value */
ram[register_I = (register_P << 4) + 0xb] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0a]; /* set I register */
register_A = (flag_C = ((acc_a0 = cmp_old = register_A) + (cmp_new = 0x0060))) & 0xFFF; /* add values */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = (register_P << 4) + 0xe]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
register_J = 0x0f43;
{register_PC = 0x0f43; continue;};
case 0x0f15:
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0a]; /* set I register */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = (register_P << 4) + 0xe]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
cmp_old = register_A; register_A = cmp_new = rom[register_A]; /* new acc value */
ram[register_I = (register_P << 4) + 0xb] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0f00;
cmp_old = register_A; cmp_new = 0x4c;
register_A = flag_C = acc_a0 = 0x0f4c;
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = (register_P << 4) + 0xe]))) & 0xFFF; /* do acc operation */
register_J = 0x0f2f;
{register_PC = 0x0f2f; continue;};
case 0x0f21:
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0a]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = (register_P << 4) + 0xe]))) & 0xFFF; /* do acc operation */
cmp_old = acc_a0 = register_A; /* back up regA */
register_A = (flag_C = (register_A + (((cmp_new = 0x40) ^ 0xFFF) + 1))) & 0xFFF; /* add */
cmp_old = register_A; register_A = cmp_new = rom[register_A]; /* new acc value */
ram[register_I = (register_P << 4) + 0xb] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
ram[register_I] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0a]; /* set I register */
register_A = (flag_C = ((acc_a0 = cmp_old = register_A) + (cmp_new = 0x0020))) & 0xFFF; /* add values */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = (register_P << 4) + 0xe]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
case 0x0f2f:
cmp_old = register_A; register_A = cmp_new = rom[register_A]; /* new acc value */
ram[register_I = (register_P << 4) + 0xa] = register_A; /* store acc to RAM */
register_J = 0x0f49;
{register_PC = 0x0f49; continue;};
case 0x0f35:
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0a]; /* set I register */
register_A = (flag_C = ((acc_a0 = cmp_old = register_A) + (cmp_new = 0x0040))) & 0xFFF; /* add values */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = (register_P << 4) + 0xe]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
cmp_old = register_A; register_A = cmp_new = rom[register_A]; /* new acc value */
ram[register_I = (register_P << 4) + 0xb] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
ram[register_I] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0a]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = (register_P << 4) + 0xe]))) & 0xFFF; /* do acc operation */
cmp_old = acc_a0 = register_A; /* back up regA */
register_A = (flag_C = (register_A + (((cmp_new = 0x60) ^ 0xFFF) + 1))) & 0xFFF; /* add */
case 0x0f43:
cmp_old = register_A; register_A = cmp_new = rom[register_A]; /* new acc value */
ram[register_I = (register_P << 4) + 0xa] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
ram[register_I] = register_A; /* store acc */
case 0x0f49:
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0xf]) ^ 0xFFF) + 1 + register_A);
/* load J reg from value at last dir addr */
register_J = ram[register_I];
if ((register_J & (~0xfff)) != 0) ERROR("Ram value must have been > 12 bits!\n");
{register_PC = register_J; continue;};
register_PC = 0x1000; return;
default: return; // Switch banks
}
}
}
/*********************************************************/
void cineExecute1000()
{
for (;;) {
switch (register_PC)
{
case 0x1000:
state = state_A; /* Even if it's not! :-) */
register_J = 0x0d70;
{register_PC = 0x1d70; continue;};
case 0x1005:
/* wait for a tick on the watchdog */
CinemaClearScreen();
bNewFrame = 1;
bailOut = TRUE;
register_PC = 0x1006;
break; /* NOT REALLY A JUMP - ACTUALLY FOR GETTING BACK TO POLLING LOOP - NEEDS WORK */
case 0x1006:
/* wait for a tick on the watchdog */
CinemaClearScreen();
bNewFrame = 1;
bailOut = TRUE;
register_PC = 0x1007;
break; /* NOT REALLY A JUMP - ACTUALLY FOR GETTING BACK TO POLLING LOOP - NEEDS WORK */
case 0x1007:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
vgColour = 0x07;
register_P = 0x1; /* set page register */
ram[register_I = 0x10] = 0x000; /* store acc to RAM */
ram[register_I = 0x11] = 0x000; /* store acc to RAM */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (cmp_new = ram[0x11]))) & 0xFFF;
set_watchdog();
flag_C = acc_a0 = register_A;
cmp_old = register_B; /* step back cmp flag */
register_B = cmp_new = 0x0300;
cmp_new = 0x0EEE; cmp_old = acc_a0 = register_A; flag_C = (0x0EEE + register_A);
register_A = (register_A >> 1) | ((register_B & 1) << 11);
register_B = (register_B >> 1) | (register_B & 0x800);
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0200;
FromX = register_A & 0xFFF; /* regA goes to x-coord */
FromY = register_B & 0xFFF; /* regB goes to y-coord */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = acc_a0 = register_A; /* back up regA */
register_A = (flag_C = (register_A + (((cmp_new = 0x38) ^ 0xFFF) + 1))) & 0xFFF; /* add */
case 0x1015:
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
register_J = 0x0015;
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x1015; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0100;
ram[register_I = (register_P << 4) + 0x2] = 0x100; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
ram[register_I = (register_P << 4) + 0xc] = 0x000; /* store acc to RAM */
ram[register_I = (register_P << 4) + 0xa] = 0x000; /* store acc to RAM */
cmp_old = register_A; cmp_new = 0xff;
register_A = flag_C = acc_a0 = 0x00ff;
ram[register_I = (register_P << 4) + 0xd] = 0x0ff; /* store acc to RAM */
ram[register_I = (register_P << 4) + 0xb] = 0x0ff; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x31;
register_A = flag_C = acc_a0 = 0x0031;
ram[register_I = (register_P << 4) + 0x6] = 0x031; /* store acc to RAM */
cmp_old = register_A; cmp_new = 0x2e;
register_A = flag_C = acc_a0 = 0x005f;
ram[register_I = (register_P << 4) + 0x7] = 0x05f; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x05;
register_A = flag_C = acc_a0 = 0x0005;
register_P = 0x2; /* set page register */
ram[register_I = 0x2f] = 0x005; /* store acc to RAM */
register_J = 0x0128;
{register_PC = 0x1128; continue;};
case 0x1058:
{register_PC = 0x1128; continue;};
case 0x1072:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = ram[register_I];
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
vgColour = 0x07;
register_J = 0x0128;
if (cmp_new == cmp_old) {register_PC = 0x1128; continue;};
cmp_new = 0x1; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x0001;
vgColour = 0x0f;
{register_PC = 0x1128; continue;};
case 0x1080:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_P = 0x3; /* set page register */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x30]) ^ 0xFFF) + 1 + register_A);
register_J = 0x0094;
if (cmp_new == cmp_old) {register_PC = 0x1094; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x3b;
register_A = flag_C = acc_a0 = 0x003b;
register_P = 0x1; /* set page register */
ram[register_I = 0x19] = 0x03b; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x94;
register_A = flag_C = acc_a0 = 0x0094;
register_P = 0x2; /* set page register */
ram[register_I = 0x2f] = 0x094; /* store acc to RAM */
register_J = 0x00b7;
{register_PC = 0x10b7; continue;};
case 0x1094:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_P = 0x4; /* set page register */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x40]) ^ 0xFFF) + 1 + register_A);
register_J = 0x00a7;
if (cmp_new == cmp_old) {register_PC = 0x10a7; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x4b;
register_A = flag_C = acc_a0 = 0x004b;
register_P = 0x1; /* set page register */
ram[register_I = 0x19] = 0x04b; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0xa7;
register_A = flag_C = acc_a0 = 0x00a7;
register_P = 0x2; /* set page register */
ram[register_I = 0x2f] = 0x0a7; /* store acc to RAM */
register_J = 0x00b7;
{register_PC = 0x10b7; continue;};
case 0x10a7:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_P = 0x5; /* set page register */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x50]) ^ 0xFFF) + 1 + register_A);
register_J = 0x047d;
if (cmp_new == cmp_old) {register_PC = 0x147d; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x5b;
register_A = flag_C = acc_a0 = 0x005b;
register_P = 0x1; /* set page register */
ram[register_I = 0x19] = 0x05b; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0400;
cmp_old = register_A; cmp_new = 0x7d;
register_A = flag_C = acc_a0 = 0x047d;
register_P = 0x2; /* set page register */
ram[register_I = 0x2f] = 0x47d; /* store acc to RAM */
case 0x10b7:
register_P = 0x1; /* set page register */
register_I = ram[0x19]&0xff; /* set new register_I (8 bits) */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = ram[register_I];
register_P = 0x2; /* set page register */
ram[register_I = 0x26] = register_A; /* store acc to RAM */
register_P = 0x1; /* set page register */
ram[register_I = 0x13] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0400;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x13]) ^ 0xFFF) + 1 + register_A);
register_J = 0x0479;
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x1479; continue;};
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x19]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
ram[0x19] = register_A; /* store acc */
register_I = ram[0x19]&0xff; /* set new register_I (8 bits) */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = ram[register_I];
register_P = 0x2; /* set page register */
ram[register_I = 0x27] = register_A; /* store acc to RAM */
flag_C = acc_a0 = register_A;
cmp_old = register_B;
register_B = cmp_new = ram[register_I];
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0300;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x27]) ^ 0xFFF) + 1 + register_A);
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x1479; continue;};
register_P = 0x1; /* set page register */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x13]; /* set I register */
register_J = 0x00d3;
FromX = register_A & 0xFFF; /* regA goes to x-coord */
FromY = register_B & 0xFFF; /* regB goes to y-coord */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x19]; /* set I register */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (((cmp_new = 0xc) ^ 0xFFF) + 1))) & 0xFFF; /* 1's-comp add */
ram[0x19] = register_A; /* store acc */
register_I = ram[0x19]&0xff; /* set new register_I (8 bits) */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = ram[register_I];
ram[register_I = 0x17] = register_A; /* store acc to RAM */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x2))) & 0xFFF; /* add values, save carry */
ram[register_I = 0x16] = register_A; /* store acc to RAM */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (((cmp_new = 0x1) ^ 0xFFF) + 1))) & 0xFFF; /* 1's-comp add */
cmp_old = register_A; register_A = cmp_new = rom[0x1000 | register_A]; /* new acc value */
ram[register_I = (register_P << 4) + 0xf] = register_A; /* store acc to RAM */
flag_C = acc_a0 = register_A;
cmp_old = register_B;
register_B = cmp_new = ram[register_I];
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x07]; /* set I register */
cmp_old = register_A; register_A = cmp_new = rom[0x1000 | register_A]; /* new acc value */
ram[register_I] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_new = 0x0EEE; cmp_old = acc_a0 = register_A; flag_C = (0x0EEE + register_A);
register_A = (register_A >> 1) | ((register_B & 1) << 11);
register_B = (register_B >> 1) | (register_B & 0x800);
cmp_new = 0x0EEE; cmp_old = acc_a0 = register_A; flag_C = (0x0EEE + register_A);
register_A = (register_A >> 1) | ((register_B & 1) << 11);
register_B = (register_B >> 1) | (register_B & 0x800);
cmp_new = 0x0EEE; cmp_old = acc_a0 = register_A; flag_C = (0x0EEE + register_A);
register_A = (register_A >> 1) | ((register_B & 1) << 11);
register_B = (register_B >> 1) | (register_B & 0x800);
cmp_new = 0x0EEE; cmp_old = acc_a0 = register_A; flag_C = (0x0EEE + register_A);
register_A = (register_A >> 1) | ((register_B & 1) << 11);
register_B = (register_B >> 1) | (register_B & 0x800);
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (cmp_new = ram[register_I]))) & 0xFFF;
set_watchdog();
ram[register_I] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x09]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
ram[register_I] = register_A; /* store acc */
register_I = ram[(register_P << 4) + 0x09]&0xff; /* set/mask new register_I */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = ram[register_I];
ram[register_I = (register_P << 4) + 0x0] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x09]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
ram[register_I] = register_A; /* store acc */
register_I = ram[(register_P << 4) + 0x09]&0xff; /* set/mask new register_I */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = ram[register_I];
ram[register_I = (register_P << 4) + 0x1] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x09]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
ram[register_I] = register_A; /* store acc */
register_I = ram[(register_P << 4) + 0x09]&0xff; /* set/mask new register_I */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = ram[register_I];
ram[register_I = (register_P << 4) + 0x2] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x09]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
ram[register_I] = register_A; /* store acc */
register_I = ram[(register_P << 4) + 0x09]&0xff; /* set/mask new register_I */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = ram[register_I];
ram[register_I = (register_P << 4) + 0xe] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0100;
cmp_old = register_A; cmp_new = 0x0d;
register_A = flag_C = acc_a0 = 0x010d;
ram[register_I = (register_P << 4) + 0xf] = 0x10d; /* store acc to RAM */
register_J = 0x0575;
{register_PC = 0x1575; continue;};
case 0x110d:
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0a]; /* set I register */
ram[register_I = (register_P << 4) + 0xc] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0b]; /* set I register */
ram[register_I = (register_P << 4) + 0xd] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x09]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
ram[register_I] = register_A; /* store acc */
register_I = ram[(register_P << 4) + 0x09]&0xff; /* set/mask new register_I */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = ram[register_I];
ram[register_I = (register_P << 4) + 0xe] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0100;
cmp_old = register_A; cmp_new = 0x1e;
register_A = flag_C = acc_a0 = 0x011e;
ram[register_I = (register_P << 4) + 0xf] = 0x11e; /* store acc to RAM */
register_J = 0x0575;
{register_PC = 0x1575; continue;};
case 0x111e:
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x09]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x2))) & 0xFFF; /* add values, save carry */
ram[register_I] = register_A; /* store acc */
register_I = ram[(register_P << 4) + 0x09]&0xff; /* set/mask new register_I */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = ram[register_I];
ram[register_I = (register_P << 4) + 0x9] = register_A; /* store acc to RAM */
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
register_J = 0x0072;
{register_PC = 0x1072; continue;};
case 0x1128:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0xff;
register_A = flag_C = acc_a0 = 0x00ff;
register_P = 0x1; /* set page register */
ram[register_I = 0x18] = 0x0ff; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x16]; /* set I register */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (((cmp_new = 0x3) ^ 0xFFF) + 1))) & 0xFFF; /* 1's-comp add */
ram[0x16] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (((cmp_new = 0x2) ^ 0xFFF) + 1))) & 0xFFF; /* 1's-comp add */
register_P = 0x0; /* set page register */
ram[register_I = 0x03] = register_A; /* store acc to RAM */
case 0x1134:
register_P = 0x0; /* set page register */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x03]; /* set I register */
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
register_J = 0x039c;
if ((acc_a0 & 0x01) != 0) {register_PC = 0x139c; continue;};
register_P = 0x1; /* set page register */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x16]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x3))) & 0xFFF; /* add values, save carry */
ram[0x16] = register_A; /* store acc */
cmp_old = register_A; register_A = cmp_new = rom[0x1000 | register_A]; /* new acc value */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0x8]) ^ 0xFFF) + 1 + register_A);
register_J = 0x0471;
if (cmp_new == cmp_old) {register_PC = 0x1471; continue;};
cmp_old = acc_a0 = register_A; /* back up regA */
register_A = (flag_C = (register_A + (((cmp_new = 0x80) ^ 0xFFF) + 1))) & 0xFFF; /* add */
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
ram[register_I = (register_P << 4) + 0x3] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x06]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
cmp_old = register_A; register_A = cmp_new = rom[0x1000 | register_A]; /* new acc value */
cmp_old = acc_a0 = register_A; /* back up regA */
register_A = (flag_C = (register_A + (((cmp_new = 0x80) ^ 0xFFF) + 1))) & 0xFFF; /* add */
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
ram[register_I = (register_P << 4) + 0x4] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x06]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x2))) & 0xFFF; /* add values, save carry */
cmp_old = register_A; register_A = cmp_new = rom[0x1000 | register_A]; /* new acc value */
cmp_old = acc_a0 = register_A; /* back up regA */
register_A = (flag_C = (register_A + (((cmp_new = 0x80) ^ 0xFFF) + 1))) & 0xFFF; /* add */
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
ram[register_I = (register_P << 4) + 0x5] = register_A; /* store acc to RAM */
register_P = 0x0; /* set page register */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x03]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x2))) & 0xFFF; /* add values, save carry */
ram[0x03] = register_A; /* store acc */
register_P = 0x1; /* set page register */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x13]; /* set I register */
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
ram[0x13] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x14]; /* set I register */
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
ram[0x14] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x1c]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = 0x1d]))) & 0xFFF; /* do acc operation */
ram[register_I = 0x1f] = register_A; /* store acc to RAM */
flag_C = acc_a0 = register_A;
cmp_old = register_B; /* step back cmp flag */
register_B = cmp_new = 0;
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0800;
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x1f]; /* set I register */
register_J = 0x0172;
if (cmp_new < cmp_old) {register_PC = 0x1172; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
case 0x1172:
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0x3]) ^ 0xFFF) + 1 + register_A);
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0800;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0xf]) ^ 0xFFF) + 1 + register_A);
ram[register_I = (register_P << 4) + 0xf] = register_B; /* set I register and store B to ram */
register_J = 0x0186;
if (cmp_new < cmp_old) {register_PC = 0x1186; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = (register_P << 4) + 0xf]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
ram[register_I] = register_A; /* store acc */
case 0x1186:
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x04]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = (register_P << 4) + 0x3]))) & 0xFFF; /* do acc operation */
ram[register_I] = register_A; /* store acc */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = (register_P << 4) + 0x4]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
ram[register_I] = register_A; /* store acc */
flag_C = acc_a0 = register_A;
cmp_old = register_B; /* step back cmp flag */
register_B = cmp_new = 0;
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0800;
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0c]; /* set I register */
register_J = 0x0195;
if (cmp_new < cmp_old) {register_PC = 0x1195; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
case 0x1195:
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0x3]) ^ 0xFFF) + 1 + register_A);
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0800;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0xc]) ^ 0xFFF) + 1 + register_A);
ram[register_I = (register_P << 4) + 0x3] = register_B; /* set I register and store B to ram */
register_J = 0x01a9;
if (cmp_new < cmp_old) {register_PC = 0x11a9; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = (register_P << 4) + 0x3]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
ram[register_I] = register_A; /* store acc */
case 0x11a9:
flag_C = acc_a0 = register_A;
cmp_old = register_B; /* step back cmp flag */
register_B = cmp_new = 0;
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0800;
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0d]; /* set I register */
register_J = 0x01b2;
if (cmp_new < cmp_old) {register_PC = 0x11b2; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
case 0x11b2:
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0x4]) ^ 0xFFF) + 1 + register_A);
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0800;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0xd]) ^ 0xFFF) + 1 + register_A);
ram[register_I = (register_P << 4) + 0x4] = register_B; /* set I register and store B to ram */
register_J = 0x01c6;
if (cmp_new < cmp_old) {register_PC = 0x11c6; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = (register_P << 4) + 0x4]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
ram[register_I] = register_A; /* store acc */
case 0x11c6:
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0f]; /* set I register */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = (register_P << 4) + 0x3]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
ram[register_I] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0f]; /* set I register */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = (register_P << 4) + 0x4]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
ram[register_I] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x04]; /* set I register */
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
ram[register_I] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x05]; /* set I register */
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
ram[register_I] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0a]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = (register_P << 4) + 0xb]))) & 0xFFF; /* do acc operation */
ram[register_I = (register_P << 4) + 0xf] = register_A; /* store acc to RAM */
flag_C = acc_a0 = register_A;
cmp_old = register_B; /* step back cmp flag */
register_B = cmp_new = 0;
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0800;
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0f]; /* set I register */
register_J = 0x01e0;
if (cmp_new < cmp_old) {register_PC = 0x11e0; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
case 0x11e0:
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0x4]) ^ 0xFFF) + 1 + register_A);
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0800;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0xf]) ^ 0xFFF) + 1 + register_A);
ram[register_I = (register_P << 4) + 0xf] = register_B; /* set I register and store B to ram */
register_J = 0x01f4;
if (cmp_new < cmp_old) {register_PC = 0x11f4; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = (register_P << 4) + 0xf]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
ram[register_I] = register_A; /* store acc */
case 0x11f4:
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x05]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = (register_P << 4) + 0x4]))) & 0xFFF; /* do acc operation */
ram[register_I] = register_A; /* store acc */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = (register_P << 4) + 0x5]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
ram[register_I] = register_A; /* store acc */
flag_C = acc_a0 = register_A;
cmp_old = register_B; /* step back cmp flag */
register_B = cmp_new = 0;
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0800;
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0a]; /* set I register */
register_J = 0x0203;
if (cmp_new < cmp_old) {register_PC = 0x1203; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
case 0x1203:
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0x4]) ^ 0xFFF) + 1 + register_A);
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0800;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0xa]) ^ 0xFFF) + 1 + register_A);
ram[register_I = (register_P << 4) + 0x4] = register_B; /* set I register and store B to ram */
register_J = 0x0217;
if (cmp_new < cmp_old) {register_PC = 0x1217; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = (register_P << 4) + 0x4]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
ram[register_I] = register_A; /* store acc */
case 0x1217:
flag_C = acc_a0 = register_A;
cmp_old = register_B; /* step back cmp flag */
register_B = cmp_new = 0;
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0800;
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0b]; /* set I register */
register_J = 0x0220;
if (cmp_new < cmp_old) {register_PC = 0x1220; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
case 0x1220:
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0x5]) ^ 0xFFF) + 1 + register_A);
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0800;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0xb]) ^ 0xFFF) + 1 + register_A);
ram[register_I = (register_P << 4) + 0x5] = register_B; /* set I register and store B to ram */
register_J = 0x0234;
if (cmp_new < cmp_old) {register_PC = 0x1234; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = (register_P << 4) + 0x5]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
ram[register_I] = register_A; /* store acc */
case 0x1234:
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0f]; /* set I register */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = (register_P << 4) + 0x4]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
ram[register_I] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0f]; /* set I register */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = (register_P << 4) + 0x5]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
ram[register_I] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x03]; /* set I register */
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
ram[register_I] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x05]; /* set I register */
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
ram[register_I] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0c]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = (register_P << 4) + 0xd]))) & 0xFFF; /* do acc operation */
ram[register_I = (register_P << 4) + 0xf] = register_A; /* store acc to RAM */
flag_C = acc_a0 = register_A;
cmp_old = register_B; /* step back cmp flag */
register_B = cmp_new = 0;
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0800;
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0f]; /* set I register */
register_J = 0x024e;
if (cmp_new < cmp_old) {register_PC = 0x124e; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
case 0x124e:
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0x3]) ^ 0xFFF) + 1 + register_A);
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0800;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0xf]) ^ 0xFFF) + 1 + register_A);
ram[register_I = (register_P << 4) + 0xf] = register_B; /* set I register and store B to ram */
register_J = 0x0262;
if (cmp_new < cmp_old) {register_PC = 0x1262; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = (register_P << 4) + 0xf]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
ram[register_I] = register_A; /* store acc */
case 0x1262:
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x05]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = (register_P << 4) + 0x3]))) & 0xFFF; /* do acc operation */
ram[register_I] = register_A; /* store acc */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = (register_P << 4) + 0x5]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
ram[register_I] = register_A; /* store acc */
flag_C = acc_a0 = register_A;
cmp_old = register_B; /* step back cmp flag */
register_B = cmp_new = 0;
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0800;
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0c]; /* set I register */
register_J = 0x0271;
if (cmp_new < cmp_old) {register_PC = 0x1271; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
case 0x1271:
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0x3]) ^ 0xFFF) + 1 + register_A);
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0800;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0xc]) ^ 0xFFF) + 1 + register_A);
ram[register_I = (register_P << 4) + 0x3] = register_B; /* set I register and store B to ram */
register_J = 0x0285;
if (cmp_new < cmp_old) {register_PC = 0x1285; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = (register_P << 4) + 0x3]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
ram[register_I] = register_A; /* store acc */
case 0x1285:
flag_C = acc_a0 = register_A;
cmp_old = register_B; /* step back cmp flag */
register_B = cmp_new = 0;
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0800;
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0d]; /* set I register */
register_J = 0x028e;
if (cmp_new < cmp_old) {register_PC = 0x128e; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
case 0x128e:
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0x5]) ^ 0xFFF) + 1 + register_A);
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0800;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0xd]) ^ 0xFFF) + 1 + register_A);
ram[register_I = (register_P << 4) + 0x5] = register_B; /* set I register and store B to ram */
register_J = 0x02a2;
if (cmp_new < cmp_old) {register_PC = 0x12a2; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = (register_P << 4) + 0x5]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
ram[register_I] = register_A; /* store acc */
case 0x12a2:
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0f]; /* set I register */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = (register_P << 4) + 0x3]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
ram[register_I] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0f]; /* set I register */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = (register_P << 4) + 0x5]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
ram[register_I] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x03]; /* set I register */
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = (register_P << 4) + 0x0]))) & 0xFFF; /* do acc operation */
register_P = 0x0; /* set page register */
ram[register_I = 0x05] = register_A; /* store acc to RAM */
register_P = 0x1; /* set page register */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x14]; /* set I register */
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = 0x11]))) & 0xFFF; /* do acc operation */
register_P = 0x0; /* set page register */
ram[register_I = 0x06] = register_A; /* store acc to RAM */
register_P = 0x1; /* set page register */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x15]; /* set I register */
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = 0x12]))) & 0xFFF; /* do acc operation */
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
register_P = 0x0; /* set page register */
ram[register_I = 0x09] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0200;
ram[register_I = 0x0d] = 0x200; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
ram[register_I = 0x04] = 0x000; /* store acc to RAM */
case 0x12c3:
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0d]; /* set I register */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0x9]) ^ 0xFFF) + 1 + register_A);
register_J = 0x0333;
if (cmp_new < cmp_old) {register_PC = 0x1333; continue;};
flag_C = acc_a0 = register_A;
cmp_old = register_B; /* step back cmp flag */
register_B = cmp_new = 0;
cmp_new = 0x0FEF; cmp_old = acc_a0 = register_A; flag_C = (0x0FEF + register_A);
register_A = (register_A << 1) & 0xFFF; register_B = (register_B << 1) & 0xFFF;
acc_a0 = register_A; /* save old accA bit0 */
cmp_old = register_B; /* store old acc for later */
register_B = (flag_C = (register_B + (cmp_new = 0x01))) & 0xFFF; /* add values */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
register_J = 0x02d4;
if (cmp_new < cmp_old) {register_PC = 0x12d4; continue;};
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (cmp_new = ram[register_I]))) & 0xFFF;
set_watchdog();
acc_a0 = register_A;
register_B = (flag_C = ((cmp_old = register_B) + ((cmp_new = 0x1) ^ 0xFFF) + 1)) & 0xFFF; /* 1's-comp add */
case 0x12d4:
cmp_new = 0x0FEF; cmp_old = acc_a0 = register_A; flag_C = (0x0FEF + register_A);
register_A = (register_A << 1) & 0xFFF; register_B = (register_B << 1) & 0xFFF;
acc_a0 = register_A; /* save old accA bit0 */
cmp_old = register_B; /* store old acc for later */
register_B = (flag_C = (register_B + (cmp_new = 0x01))) & 0xFFF; /* add values */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
register_J = 0x02de;
if (cmp_new < cmp_old) {register_PC = 0x12de; continue;};
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (cmp_new = ram[register_I]))) & 0xFFF;
set_watchdog();
acc_a0 = register_A;
register_B = (flag_C = ((cmp_old = register_B) + ((cmp_new = 0x1) ^ 0xFFF) + 1)) & 0xFFF; /* 1's-comp add */
case 0x12de:
cmp_new = 0x0FEF; cmp_old = acc_a0 = register_A; flag_C = (0x0FEF + register_A);
register_A = (register_A << 1) & 0xFFF; register_B = (register_B << 1) & 0xFFF;
acc_a0 = register_A; /* save old accA bit0 */
cmp_old = register_B; /* store old acc for later */
register_B = (flag_C = (register_B + (cmp_new = 0x01))) & 0xFFF; /* add values */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
register_J = 0x02e8;
if (cmp_new < cmp_old) {register_PC = 0x12e8; continue;};
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (cmp_new = ram[register_I]))) & 0xFFF;
set_watchdog();
acc_a0 = register_A;
register_B = (flag_C = ((cmp_old = register_B) + ((cmp_new = 0x1) ^ 0xFFF) + 1)) & 0xFFF; /* 1's-comp add */
case 0x12e8:
cmp_new = 0x0FEF; cmp_old = acc_a0 = register_A; flag_C = (0x0FEF + register_A);
register_A = (register_A << 1) & 0xFFF; register_B = (register_B << 1) & 0xFFF;
acc_a0 = register_A; /* save old accA bit0 */
cmp_old = register_B; /* store old acc for later */
register_B = (flag_C = (register_B + (cmp_new = 0x01))) & 0xFFF; /* add values */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
register_J = 0x02f2;
if (cmp_new < cmp_old) {register_PC = 0x12f2; continue;};
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (cmp_new = ram[register_I]))) & 0xFFF;
set_watchdog();
acc_a0 = register_A;
register_B = (flag_C = ((cmp_old = register_B) + ((cmp_new = 0x1) ^ 0xFFF) + 1)) & 0xFFF; /* 1's-comp add */
case 0x12f2:
cmp_new = 0x0FEF; cmp_old = acc_a0 = register_A; flag_C = (0x0FEF + register_A);
register_A = (register_A << 1) & 0xFFF; register_B = (register_B << 1) & 0xFFF;
acc_a0 = register_A; /* save old accA bit0 */
cmp_old = register_B; /* store old acc for later */
register_B = (flag_C = (register_B + (cmp_new = 0x01))) & 0xFFF; /* add values */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
register_J = 0x02fc;
if (cmp_new < cmp_old) {register_PC = 0x12fc; continue;};
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (cmp_new = ram[register_I]))) & 0xFFF;
set_watchdog();
acc_a0 = register_A;
register_B = (flag_C = ((cmp_old = register_B) + ((cmp_new = 0x1) ^ 0xFFF) + 1)) & 0xFFF; /* 1's-comp add */
case 0x12fc:
cmp_new = 0x0FEF; cmp_old = acc_a0 = register_A; flag_C = (0x0FEF + register_A);
register_A = (register_A << 1) & 0xFFF; register_B = (register_B << 1) & 0xFFF;
acc_a0 = register_A; /* save old accA bit0 */
cmp_old = register_B; /* store old acc for later */
register_B = (flag_C = (register_B + (cmp_new = 0x01))) & 0xFFF; /* add values */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
register_J = 0x0306;
if (cmp_new < cmp_old) {register_PC = 0x1306; continue;};
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (cmp_new = ram[register_I]))) & 0xFFF;
set_watchdog();
acc_a0 = register_A;
register_B = (flag_C = ((cmp_old = register_B) + ((cmp_new = 0x1) ^ 0xFFF) + 1)) & 0xFFF; /* 1's-comp add */
case 0x1306:
cmp_new = 0x0FEF; cmp_old = acc_a0 = register_A; flag_C = (0x0FEF + register_A);
register_A = (register_A << 1) & 0xFFF; register_B = (register_B << 1) & 0xFFF;
acc_a0 = register_A; /* save old accA bit0 */
cmp_old = register_B; /* store old acc for later */
register_B = (flag_C = (register_B + (cmp_new = 0x01))) & 0xFFF; /* add values */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
register_J = 0x0310;
if (cmp_new < cmp_old) {register_PC = 0x1310; continue;};
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (cmp_new = ram[register_I]))) & 0xFFF;
set_watchdog();
acc_a0 = register_A;
register_B = (flag_C = ((cmp_old = register_B) + ((cmp_new = 0x1) ^ 0xFFF) + 1)) & 0xFFF; /* 1's-comp add */
case 0x1310:
cmp_new = 0x0FEF; cmp_old = acc_a0 = register_A; flag_C = (0x0FEF + register_A);
register_A = (register_A << 1) & 0xFFF; register_B = (register_B << 1) & 0xFFF;
acc_a0 = register_A; /* save old accA bit0 */
cmp_old = register_B; /* store old acc for later */
register_B = (flag_C = (register_B + (cmp_new = 0x01))) & 0xFFF; /* add values */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
register_J = 0x031a;
if (cmp_new < cmp_old) {register_PC = 0x131a; continue;};
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (cmp_new = ram[register_I]))) & 0xFFF;
set_watchdog();
acc_a0 = register_A;
register_B = (flag_C = ((cmp_old = register_B) + ((cmp_new = 0x1) ^ 0xFFF) + 1)) & 0xFFF; /* 1's-comp add */
case 0x131a:
cmp_new = 0x0FEF; cmp_old = acc_a0 = register_A; flag_C = (0x0FEF + register_A);
register_A = (register_A << 1) & 0xFFF; register_B = (register_B << 1) & 0xFFF;
acc_a0 = register_A; /* save old accA bit0 */
cmp_old = register_B; /* store old acc for later */
register_B = (flag_C = (register_B + (cmp_new = 0x01))) & 0xFFF; /* add values */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
register_J = 0x0324;
if (cmp_new < cmp_old) {register_PC = 0x1324; continue;};
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (cmp_new = ram[register_I]))) & 0xFFF;
set_watchdog();
acc_a0 = register_A;
register_B = (flag_C = ((cmp_old = register_B) + ((cmp_new = 0x1) ^ 0xFFF) + 1)) & 0xFFF; /* 1's-comp add */
case 0x1324:
cmp_new = 0x0FEF; cmp_old = acc_a0 = register_A; flag_C = (0x0FEF + register_A);
register_A = (register_A << 1) & 0xFFF; register_B = (register_B << 1) & 0xFFF;
acc_a0 = register_A; /* save old accA bit0 */
cmp_old = register_B; /* store old acc for later */
register_B = (flag_C = (register_B + (cmp_new = 0x01))) & 0xFFF; /* add values */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
register_J = 0x032e;
if (cmp_new < cmp_old) {register_PC = 0x132e; continue;};
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (cmp_new = ram[register_I]))) & 0xFFF;
set_watchdog();
acc_a0 = register_A;
register_B = (flag_C = ((cmp_old = register_B) + ((cmp_new = 0x1) ^ 0xFFF) + 1)) & 0xFFF; /* 1's-comp add */
case 0x132e:
ram[register_I = (register_P << 4) + 0x9] = register_B; /* set I register and store B to ram */
register_J = 0x033b;
{register_PC = 0x133b; continue;};
case 0x1333:
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
ram[register_I = (register_P << 4) + 0xd] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x04]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
ram[register_I] = register_A; /* store acc */
register_J = 0x02c3;
{register_PC = 0x12c3; continue;};
case 0x133b:
flag_C = acc_a0 = register_A;
cmp_old = register_B; /* step back cmp flag */
register_B = cmp_new = 0;
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0800;
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x05]; /* set I register */
register_J = 0x0344;
if (cmp_new < cmp_old) {register_PC = 0x1344; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
case 0x1344:
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0x9]) ^ 0xFFF) + 1 + register_A);
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
ram[register_I = (register_P << 4) + 0x7] = register_B; /* set I register and store B to ram */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0800;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0x5]) ^ 0xFFF) + 1 + register_A);
register_J = 0x035a;
if (cmp_new < cmp_old) {register_PC = 0x135a; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = (register_P << 4) + 0x7]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
ram[register_I] = register_A; /* store acc */
case 0x135a:
flag_C = acc_a0 = register_A;
cmp_old = register_B; /* step back cmp flag */
register_B = cmp_new = 0;
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0800;
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x06]; /* set I register */
register_J = 0x0363;
if (cmp_new < cmp_old) {register_PC = 0x1363; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
case 0x1363:
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0x9]) ^ 0xFFF) + 1 + register_A);
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
ram[register_I = (register_P << 4) + 0x8] = register_B; /* set I register and store B to ram */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0800;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0x6]) ^ 0xFFF) + 1 + register_A);
register_J = 0x0379;
if (cmp_new < cmp_old) {register_PC = 0x1379; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = (register_P << 4) + 0x8]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
ram[register_I] = register_A; /* store acc */
case 0x1379:
flag_C = acc_a0 = register_A;
cmp_old = register_B; /* step back cmp flag */
register_B = cmp_new = 0;
acc_a0 = register_A;
register_B = (flag_C = ((cmp_old = register_B) + ((cmp_new = ram[register_I = (register_P << 4) + 0x04]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
register_J = 0x038b;
if (cmp_new == cmp_old) {register_PC = 0x138b; continue;};
register_J = 0x0382;
case 0x1382:
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x05]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = (register_P << 4) + 0x7]))) & 0xFFF; /* do acc operation */
ram[register_I] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x06]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = (register_P << 4) + 0x8]))) & 0xFFF; /* do acc operation */
ram[register_I] = register_A; /* store acc */
acc_a0 = register_A; /* save old accA bit0 */
cmp_old = register_B; /* store old acc for later */
register_B = (flag_C = (register_B + (cmp_new = 0x01))) & 0xFFF; /* add values */
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x1382; continue;};
case 0x138b:
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x03]; /* set I register */
register_A = (flag_C = ((acc_a0 = cmp_old = register_A) + (cmp_new = 0x00e0))) & 0xFFF; /* add values */
ram[register_I = (register_P << 4) + 0xe] = register_A; /* store acc to RAM */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
ram[register_I = (register_P << 4) + 0xf] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0200;
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = (register_P << 4) + 0x7]))) & 0xFFF; /* do acc operation */
ram[register_I] = register_A; /* store acc */
register_I = ram[(register_P << 4) + 0x0e]&0xff; /* set/mask new register_I */
ram[register_I] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0300;
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = (register_P << 4) + 0x8]))) & 0xFFF; /* do acc operation */
ram[register_I] = register_A; /* store acc */
register_I = ram[(register_P << 4) + 0x0f]&0xff; /* set/mask new register_I */
ram[register_I] = register_A; /* store acc */
case 0x139c:
register_P = 0x1; /* set page register */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x17]; /* set I register */
cmp_old = register_A; register_A = cmp_new = rom[0x1000 | register_A]; /* new acc value */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0x8]) ^ 0xFFF) + 1 + register_A);
register_J = 0x0479;
if (cmp_new == cmp_old) {register_PC = 0x1479; continue;};
register_J = 0x0134;
register_P = 0x0; /* set page register */
ram[register_I = 0x0b] = register_A; /* store acc to RAM */
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x03]) ^ 0xFFF) + 1 + register_A);
if (cmp_new < cmp_old) {register_PC = 0x1134; continue;};
ram[register_I = 0x0a] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_new = 0xf; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x000f;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x0b]) ^ 0xFFF) + 1 + register_A);
cmp_old = flag_C = acc_a0 = register_A;
register_A &= (cmp_new = ram[register_I]);
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
ram[0x0b] = register_A; /* store acc */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x03]) ^ 0xFFF) + 1 + register_A);
if (cmp_new < cmp_old) {register_PC = 0x1134; continue;};
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x0a]; /* set I register */
register_A = (flag_C = ((acc_a0 = cmp_old = register_A) + (cmp_new = 0x00e0))) & 0xFFF; /* add values */
ram[register_I = 0x0e] = register_A; /* store acc to RAM */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
ram[register_I = 0x0f] = register_A; /* store acc to RAM */
register_I = ram[0x0f]&0xff; /* set new register_I (8 bits) */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = ram[register_I];
ram[register_I = 0x06] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0300;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x06]) ^ 0xFFF) + 1 + register_A);
register_J = 0x0454;
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x1454; continue;};
register_I = ram[0x0e]&0xff; /* set new register_I (8 bits) */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = ram[register_I];
ram[register_I = 0x05] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0400;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x05]) ^ 0xFFF) + 1 + register_A);
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x1454; continue;};
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x0b]; /* set I register */
register_A = (flag_C = ((acc_a0 = cmp_old = register_A) + (cmp_new = 0x00e0))) & 0xFFF; /* add values */
ram[register_I = 0x0e] = register_A; /* store acc to RAM */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
ram[register_I = 0x0f] = register_A; /* store acc to RAM */
register_I = ram[0x0f]&0xff; /* set new register_I (8 bits) */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = ram[register_I];
ram[register_I = 0x08] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0300;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x08]) ^ 0xFFF) + 1 + register_A);
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x1454; continue;};
register_I = ram[0x0e]&0xff; /* set new register_I (8 bits) */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = ram[register_I];
ram[register_I = 0x07] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0400;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x07]) ^ 0xFFF) + 1 + register_A);
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x1454; continue;};
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x08]; /* set I register */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = 0x06]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
ram[register_I = 0x08] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x07]; /* set I register */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = 0x05]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
ram[register_I = 0x07] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_new = 0x2; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x0002;
register_P = 0x1; /* set page register */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x19]) ^ 0xFFF) + 1 + register_A);
register_J = 0x041e;
if (cmp_new < cmp_old) {register_PC = 0x141e; continue;};
register_P = 0x0; /* set page register */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x05]; /* set I register */
register_P = 0x2; /* set page register */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = 0x26]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
register_P = 0x0; /* set page register */
ram[register_I = 0x0c] = register_A; /* store acc to RAM */
flag_C = acc_a0 = register_A;
cmp_old = register_B; /* step back cmp flag */
register_B = cmp_new = 0;
register_P = 0x1; /* set page register */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x19]; /* set I register */
register_P = 0x0; /* set page register */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x0c]) ^ 0xFFF) + 1 + register_A);
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
register_P = 0x2; /* set page register */
register_PC = 0x1400; return;
default: return; // Switch banks
}
}
}
/*********************************************************/
void cineExecute1400()
{
for (;;) {
switch (register_PC)
{
case 0x1400:
acc_a0 = register_A; /* store old acc value */
register_B = (flag_C = ((cmp_old = register_B) + (cmp_new = ram[register_I = 0x26]))) & 0xFFF; /* do acc operation */
register_P = 0x0; /* set page register */
ram[register_I = (register_P << 4) + 0x5] = register_B; /* set I register and store B to ram */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x06]; /* set I register */
register_P = 0x2; /* set page register */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = 0x27]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
register_P = 0x0; /* set page register */
ram[register_I = 0x0c] = register_A; /* store acc to RAM */
flag_C = acc_a0 = register_A;
cmp_old = register_B; /* step back cmp flag */
register_B = cmp_new = 0;
register_P = 0x1; /* set page register */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x19]; /* set I register */
register_P = 0x0; /* set page register */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x0c]) ^ 0xFFF) + 1 + register_A);
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
cmp_new = ram[register_I];
register_B <<= 4; /* get sign bit 15 */
register_B |= (register_A >> 8); /* bring in A high nibble */
register_A = ((register_A & 0xFF) << 8) | (0xe3); /* pick up opcode */
if (register_A & 0x100) /* 1bit shifted out? */ {
acc_a0 = register_A = (register_A >> 8) | ((register_B & 0xFF) << 8);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((4)&31))) /* SAR */;
cmp_old = register_B & 0x0F;
register_B = ((int)(((int)register_B) >> (int)((1)&31))) /* SAR */;
register_B &= 0xFFF;
flag_C = (register_B += cmp_new);
register_B &= 0xFFF;
} else {
register_A = (register_A >> 8) | /* Bhigh | Alow */ ((register_B & 0xFF) << 8);
cmp_old = acc_a0 = register_A & 0xFFF;
flag_C = (cmp_old + cmp_new);
register_A >>= 1;
register_A &= 0xFFF;
register_B = ((int)(((int)register_B) >> (int)((5)&31))) /* SAR */;
register_B &= 0xFFF;
}
register_P = 0x2; /* set page register */
acc_a0 = register_A; /* store old acc value */
register_B = (flag_C = ((cmp_old = register_B) + (cmp_new = ram[register_I = 0x27]))) & 0xFFF; /* do acc operation */
register_P = 0x0; /* set page register */
ram[register_I = (register_P << 4) + 0x6] = register_B; /* set I register and store B to ram */
case 0x141e:
register_P = 0x0; /* set page register */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x05]; /* set I register */
flag_C = acc_a0 = register_A;
cmp_old = register_B; /* store old acc */
register_B = cmp_new = ram[register_I = (register_P << 4) + 0x06]; /* new acc value */
register_J = 0x0422;
FromX = register_A & 0xFFF; /* regA goes to x-coord */
FromY = register_B & 0xFFF; /* regB goes to y-coord */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0800;
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x07]; /* set I register */
register_J = 0x042d;
if (cmp_new < cmp_old) {register_PC = 0x142d; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
case 0x142d:
ram[register_I = (register_P << 4) + 0xc] = register_A; /* store acc to RAM */
ram[register_I = (register_P << 4) + 0xe] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0800;
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x08]; /* set I register */
register_J = 0x0436;
if (cmp_new < cmp_old) {register_PC = 0x1436; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
case 0x1436:
ram[register_I = (register_P << 4) + 0xf] = register_A; /* store acc to RAM */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = (register_P << 4) + 0xe]))) & 0xFFF; /* do acc operation */
ram[register_I] = register_A; /* store acc */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (((cmp_new = 0x3) ^ 0xFFF) + 1))) & 0xFFF; /* 1's-comp add */
register_J = 0x0454;
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x1454; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = acc_a0 = register_A; /* back up regA */
register_A = (flag_C = (register_A + (((cmp_new = 0x08) ^ 0xFFF) + 1))) & 0xFFF; /* add */
case 0x1440:
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
register_J = 0x0440;
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x1440; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0200;
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (((cmp_new = 0x7) ^ 0xFFF) + 1))) & 0xFFF; /* 1's-comp add */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0xf]) ^ 0xFFF) + 1 + register_A);
register_J = 0x045b;
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x145b; continue;};
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0xc]) ^ 0xFFF) + 1 + register_A);
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x145b; continue;};
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x07]; /* set I register */
flag_C = acc_a0 = register_A;
cmp_old = register_B; /* store old acc */
register_B = cmp_new = ram[register_I = (register_P << 4) + 0x08]; /* new acc value */
{int temp_byte = 0;
for (;;) {
if ( ((((register_A >> 8) & 0x0A) != 0) && ((((register_A >> 8) & 0x0A) ^ 0x0A)) != 0)
|| ((((register_B >> 8) & 0x0A) != 0) && ((((register_B >> 8) & 0x0A) ^ 0x0A)) != 0) ) break;
register_A <<= 1; register_B <<= 1;
temp_byte = (temp_byte+1) & 0xff; if (temp_byte == 0) break /* This may not be correct */;
}
vgShiftLength = temp_byte & 0xfff; register_A &= 0x0FFF; register_B &= 0x0FFF;
}
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = (register_P << 4) + 0x5]))) & 0xFFF; /* do acc operation */
acc_a0 = register_A; /* store old acc value */
register_B = (flag_C = ((cmp_old = register_B) + (cmp_new = ram[register_I = (register_P << 4) + 0x06]))) & 0xFFF; /* do acc operation */
{
/* set ending points and draw the vector, or buffer for a later draw. */
int ToX = register_A & 0xFFF;
int ToY = register_B & 0xFFF;
/* Sign extend from 20 bit CCPU to 32bit target machine */
FromX = SEX(FromX);
ToX = SEX(ToX);
FromY = SEX(FromY);
ToY = SEX(ToY);
/* figure out the vector */
ToX -= FromX;
ToX = ((int)(((int)ToX) >> (int)((vgShiftLength)&31))) /* SAR */;
ToX += FromX;
ToY -= FromY;
ToY = ((int)(((int)ToY) >> (int)((vgShiftLength)&31))) /* SAR */;
ToY += FromY;
/* render the line */
CinemaVectorData (FromX, FromY, ToX, ToY, vgColour);
}
case 0x1454:
register_P = 0x1; /* set page register */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x17]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
ram[0x17] = register_A; /* store acc */
register_J = 0x039c;
{register_PC = 0x139c; continue;};
case 0x145b:
flag_C = acc_a0 = register_A;
cmp_old = register_B; /* store old acc */
register_B = cmp_new = ram[register_I = (register_P << 4) + 0x08]; /* new acc value */
cmp_new = 0x0EEE; cmp_old = acc_a0 = register_A; flag_C = (0x0EEE + register_A);
register_A = (register_A >> 1) | ((register_B & 1) << 11);
register_B = (register_B >> 1) | (register_B & 0x800);
ram[register_I] = register_B; /* store acc */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x07]; /* set I register */
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
ram[register_I] = register_A; /* store acc */
{int temp_byte = 0;
for (;;) {
if ( ((((register_A >> 8) & 0x0A) != 0) && ((((register_A >> 8) & 0x0A) ^ 0x0A)) != 0)
|| ((((register_B >> 8) & 0x0A) != 0) && ((((register_B >> 8) & 0x0A) ^ 0x0A)) != 0) ) break;
register_A <<= 1; register_B <<= 1;
temp_byte = (temp_byte+1) & 0xff; if (temp_byte == 0) break /* This may not be correct */;
}
vgShiftLength = temp_byte & 0xfff; register_A &= 0x0FFF; register_B &= 0x0FFF;
}
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = (register_P << 4) + 0x5]))) & 0xFFF; /* do acc operation */
acc_a0 = register_A; /* store old acc value */
register_B = (flag_C = ((cmp_old = register_B) + (cmp_new = ram[register_I = (register_P << 4) + 0x06]))) & 0xFFF; /* do acc operation */
{
/* set ending points and draw the vector, or buffer for a later draw. */
int ToX = register_A & 0xFFF;
int ToY = register_B & 0xFFF;
/* Sign extend from 20 bit CCPU to 32bit target machine */
FromX = SEX(FromX);
ToX = SEX(ToX);
FromY = SEX(FromY);
ToY = SEX(ToY);
/* figure out the vector */
ToX -= FromX;
ToX = ((int)(((int)ToX) >> (int)((vgShiftLength)&31))) /* SAR */;
ToX += FromX;
ToY -= FromY;
ToY = ((int)(((int)ToY) >> (int)((vgShiftLength)&31))) /* SAR */;
ToY += FromY;
/* render the line */
CinemaVectorData (FromX, FromY, ToX, ToY, vgColour);
}
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x08]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = (register_P << 4) + 0x6]))) & 0xFFF; /* do acc operation */
ram[register_I] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x07]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = (register_P << 4) + 0x5]))) & 0xFFF; /* do acc operation */
ram[register_I] = register_A; /* store acc */
register_J = 0x041e;
{register_PC = 0x141e; continue;};
case 0x1471:
register_P = 0x0; /* set page register */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x03]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
ram[0x03] = register_A; /* store acc */
register_P = 0x1; /* set page register */
register_J = 0x039c;
{register_PC = 0x139c; continue;};
case 0x1479:
register_P = 0x2; /* set page register */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x2f]) ^ 0xFFF) + 1 + register_A);
/* load J reg from value at last dir addr */
register_J = ram[0x2f];
if ((register_J & (~0xfff)) != 0) ERROR("Ram value must have been > 12 bits!\n");
{register_PC = 0x1000 | register_J; continue;};
case 0x147d:
register_P = 0x0; /* set page register */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x00]) ^ 0xFFF) + 1 + register_A);
/* load J reg from value at last dir addr */
register_J = ram[0x00];
if ((register_J & (~0xfff)) != 0) ERROR("Ram value must have been > 12 bits!\n");
{register_PC = 0x1000 | register_J; continue;};
case 0x1575:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x7f;
register_A = flag_C = acc_a0 = 0x007f;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0xe]) ^ 0xFFF) + 1 + register_A);
cmp_old = flag_C = acc_a0 = register_A;
register_A &= (cmp_new = ram[register_I]);
ram[register_I] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0500;
cmp_old = register_A; cmp_new = 0xf6;
register_A = flag_C = acc_a0 = 0x05f6;
ram[register_I = (register_P << 4) + 0xa] = 0x5f6; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x20;
register_A = flag_C = acc_a0 = 0x0020;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0xe]) ^ 0xFFF) + 1 + register_A);
register_J = 0x059f;
if (cmp_new < cmp_old) {register_PC = 0x159f; continue;};
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0xe]) ^ 0xFFF) + 1 + register_A);
register_J = 0x05ab;
if (cmp_new < cmp_old) {register_PC = 0x15ab; continue;};
register_A = (flag_C = ((acc_a0 = cmp_old = register_A) + (cmp_new = 0x0020))) & 0xFFF; /* add values */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0xe]) ^ 0xFFF) + 1 + register_A);
register_J = 0x05bf;
if (cmp_new < cmp_old) {register_PC = 0x15bf; continue;};
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0a]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = (register_P << 4) + 0xe]))) & 0xFFF; /* do acc operation */
cmp_old = acc_a0 = register_A; /* back up regA */
register_A = (flag_C = (register_A + (((cmp_new = 0x80) ^ 0xFFF) + 1))) & 0xFFF; /* add */
cmp_old = register_A; register_A = cmp_new = rom[0x1000 | register_A]; /* new acc value */
ram[register_I = (register_P << 4) + 0xb] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0a]; /* set I register */
register_A = (flag_C = ((acc_a0 = cmp_old = register_A) + (cmp_new = 0x0060))) & 0xFFF; /* add values */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = (register_P << 4) + 0xe]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
register_J = 0x05cd;
{register_PC = 0x15cd; continue;};
case 0x159f:
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0a]; /* set I register */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = (register_P << 4) + 0xe]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
cmp_old = register_A; register_A = cmp_new = rom[0x1000 | register_A]; /* new acc value */
ram[register_I = (register_P << 4) + 0xb] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0500;
cmp_old = register_A; cmp_new = 0xd6;
register_A = flag_C = acc_a0 = 0x05d6;
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = (register_P << 4) + 0xe]))) & 0xFFF; /* do acc operation */
register_J = 0x05b9;
{register_PC = 0x15b9; continue;};
case 0x15ab:
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0a]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = (register_P << 4) + 0xe]))) & 0xFFF; /* do acc operation */
cmp_old = acc_a0 = register_A; /* back up regA */
register_A = (flag_C = (register_A + (((cmp_new = 0x40) ^ 0xFFF) + 1))) & 0xFFF; /* add */
cmp_old = register_A; register_A = cmp_new = rom[0x1000 | register_A]; /* new acc value */
ram[register_I = (register_P << 4) + 0xb] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
ram[register_I] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0a]; /* set I register */
register_A = (flag_C = ((acc_a0 = cmp_old = register_A) + (cmp_new = 0x0020))) & 0xFFF; /* add values */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = (register_P << 4) + 0xe]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
case 0x15b9:
cmp_old = register_A; register_A = cmp_new = rom[0x1000 | register_A]; /* new acc value */
ram[register_I = (register_P << 4) + 0xa] = register_A; /* store acc to RAM */
register_J = 0x05d3;
{register_PC = 0x15d3; continue;};
case 0x15bf:
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0a]; /* set I register */
register_A = (flag_C = ((acc_a0 = cmp_old = register_A) + (cmp_new = 0x0040))) & 0xFFF; /* add values */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = (register_P << 4) + 0xe]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
cmp_old = register_A; register_A = cmp_new = rom[0x1000 | register_A]; /* new acc value */
ram[register_I = (register_P << 4) + 0xb] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
ram[register_I] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0a]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = (register_P << 4) + 0xe]))) & 0xFFF; /* do acc operation */
cmp_old = acc_a0 = register_A; /* back up regA */
register_A = (flag_C = (register_A + (((cmp_new = 0x60) ^ 0xFFF) + 1))) & 0xFFF; /* add */
case 0x15cd:
cmp_old = register_A; register_A = cmp_new = rom[0x1000 | register_A]; /* new acc value */
ram[register_I = (register_P << 4) + 0xa] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
ram[register_I] = register_A; /* store acc */
case 0x15d3:
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0xf]) ^ 0xFFF) + 1 + register_A);
/* load J reg from value at last dir addr */
register_J = ram[register_I];
if ((register_J & (~0xfff)) != 0) ERROR("Ram value must have been > 12 bits!\n");
{register_PC = 0x1000 | register_J; continue;};
case 0x1600:
flag_C = acc_a0 = register_A;
cmp_old = register_B; /* step back cmp flag */
register_B = cmp_new = 0x0200;
cmp_old = register_B; acc_a0 = register_A; /* save old accA bit0 */
cmp_new = 0x76;
register_B = flag_C = 0x0276; cmp_new = 0x76; /* No carry */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0xa0;
register_A = flag_C = acc_a0 = 0x00a0;
register_J = 0x060b;
FromX = register_A & 0xFFF; /* regA goes to x-coord */
FromY = register_B & 0xFFF; /* regB goes to y-coord */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = acc_a0 = register_A; /* back up regA */
register_A = (flag_C = (register_A + (((cmp_new = 0x38) ^ 0xFFF) + 1))) & 0xFFF; /* add */
case 0x1610:
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
register_J = 0x0610;
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x1610; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_P = 0x6; /* set page register */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x69]) ^ 0xFFF) + 1 + register_A);
register_J = 0x063a;
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x163a; continue;};
vgColour = 0x07;
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x96;
register_A = flag_C = acc_a0 = 0x0096;
register_P = 0x0; /* set page register */
ram[register_I = 0x03] = 0x096; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0200;
cmp_old = register_A; cmp_new = 0x8a;
register_A = flag_C = acc_a0 = 0x028a;
ram[register_I = 0x04] = 0x28a; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x11;
register_A = flag_C = acc_a0 = 0x0011;
ram[register_I = 0x0e] = 0x011; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
ram[register_I = 0x0f] = 0x000; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0600;
cmp_old = register_A; cmp_new = 0x33;
register_A = flag_C = acc_a0 = 0x0633;
ram[register_I = 0x05] = 0x633; /* store acc to RAM */
cmp_old = register_A; cmp_new = 0x07;
register_A = flag_C = acc_a0 = 0x063a;
ram[register_I = 0x00] = 0x63a; /* store acc to RAM */
register_J = 0x0af3;
{register_PC = 0x1af3; continue;};
case 0x163a:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_P = 0x7; /* set page register */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x71]; /* set I register */
register_J = 0x0644;
if (cmp_new == cmp_old) {register_PC = 0x1644; continue;};
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (((cmp_new = 0x1) ^ 0xFFF) + 1))) & 0xFFF; /* 1's-comp add */
ram[0x71] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_new = 0x1; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x0001;
case 0x1644:
vgColour = (register_A & 0x01) != 0 ? 0x0f: 0x07;
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x10;
register_A = flag_C = acc_a0 = 0x0010;
set_sound_data(0);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_A(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_B(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_C(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0xa0;
register_A = flag_C = acc_a0 = 0x00a0;
register_P = 0x0; /* set page register */
ram[register_I = 0x03] = 0x0a0; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0200;
cmp_old = register_A; cmp_new = 0x58;
register_A = flag_C = acc_a0 = 0x0258;
ram[register_I = 0x04] = 0x258; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x07;
register_A = flag_C = acc_a0 = 0x0007;
ram[register_I = 0x0e] = 0x007; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_new = 0x3; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x0003;
ram[register_I = 0x0f] = 0x003; /* store acc to RAM */
cmp_old = register_A; cmp_new = 0x01;
register_A = flag_C = acc_a0 = 0x0004;
ram[register_I = 0x02] = 0x004; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x6a;
register_A = flag_C = acc_a0 = 0x006a;
ram[register_I = 0x05] = 0x06a; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0600;
cmp_old = register_A; cmp_new = 0x71;
register_A = flag_C = acc_a0 = 0x0671;
ram[register_I = 0x00] = 0x671; /* store acc to RAM */
register_J = 0x0af3;
{register_PC = 0x1af3; continue;};
case 0x1671:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0xb8;
register_A = flag_C = acc_a0 = 0x00b8;
register_P = 0x0; /* set page register */
ram[register_I = 0x03] = 0x0b8; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0200;
cmp_old = register_A; cmp_new = 0x58;
register_A = flag_C = acc_a0 = 0x0258;
ram[register_I = 0x04] = 0x258; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x07;
register_A = flag_C = acc_a0 = 0x0007;
ram[register_I = 0x0e] = 0x007; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_new = 0x3; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x0003;
ram[register_I = 0x0f] = 0x003; /* store acc to RAM */
cmp_old = register_A; cmp_new = 0x01;
register_A = flag_C = acc_a0 = 0x0004;
ram[register_I = 0x02] = 0x004; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x6b;
register_A = flag_C = acc_a0 = 0x006b;
ram[register_I = 0x05] = 0x06b; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0600;
cmp_old = register_A; cmp_new = 0x8f;
register_A = flag_C = acc_a0 = 0x068f;
ram[register_I = 0x00] = 0x68f; /* store acc to RAM */
register_J = 0x0af3;
{register_PC = 0x1af3; continue;};
case 0x168f:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_P = 0x2; /* set page register */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x20]; /* set I register */
register_J = 0x069a;
if (cmp_new == cmp_old) {register_PC = 0x169a; continue;};
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (((cmp_new = 0x1) ^ 0xFFF) + 1))) & 0xFFF; /* 1's-comp add */
ram[0x20] = register_A; /* store acc */
register_J = 0x0704;
{register_PC = 0x1704; continue;};
case 0x169a:
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x05]; /* set I register */
register_P = 0x3; /* set page register */
ram[register_I = 0x3f] = register_A; /* store acc to RAM */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x3))) & 0xFFF; /* add values, save carry */
register_P = 0x4; /* set page register */
ram[register_I = 0x4f] = register_A; /* store acc to RAM */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x3))) & 0xFFF; /* add values, save carry */
register_P = 0x5; /* set page register */
ram[register_I = 0x5f] = register_A; /* store acc to RAM */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x4))) & 0xFFF; /* add values, save carry */
register_P = 0x2; /* set page register */
ram[register_I = 0x25] = register_A; /* store acc to RAM */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (((cmp_new = 0x1) ^ 0xFFF) + 1))) & 0xFFF; /* 1's-comp add */
cmp_old = register_A; register_A = cmp_new = rom[0x1000 | register_A]; /* new acc value */
ram[register_I = (register_P << 4) + 0x0] = register_A; /* store acc to RAM */
cmp_old = acc_a0 = register_A; /* back up regA */
register_A = (flag_C = (register_A + (((cmp_new = 0xff) ^ 0xFFF) + 1))) & 0xFFF; /* add */
register_J = 0x06b3;
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x16b3; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0200;
cmp_old = register_A; cmp_new = 0xff;
register_A = flag_C = acc_a0 = 0x02ff;
ram[register_I] = register_A; /* store acc */
case 0x16b3:
register_P = 0x3; /* set page register */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x3f]; /* set I register */
cmp_old = register_A; register_A = cmp_new = rom[0x1000 | register_A]; /* new acc value */
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
ram[register_I = (register_P << 4) + 0x8] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0f]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
cmp_old = register_A; register_A = cmp_new = rom[0x1000 | register_A]; /* new acc value */
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
ram[register_I = (register_P << 4) + 0x9] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0f]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x2))) & 0xFFF; /* add values, save carry */
cmp_old = register_A; register_A = cmp_new = rom[0x1000 | register_A]; /* new acc value */
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
ram[register_I = (register_P << 4) + 0xa] = register_A; /* store acc to RAM */
register_P = 0x4; /* set page register */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x4f]; /* set I register */
cmp_old = register_A; register_A = cmp_new = rom[0x1000 | register_A]; /* new acc value */
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
ram[register_I = (register_P << 4) + 0x8] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0f]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
cmp_old = register_A; register_A = cmp_new = rom[0x1000 | register_A]; /* new acc value */
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
ram[register_I = (register_P << 4) + 0x9] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0f]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x2))) & 0xFFF; /* add values, save carry */
cmp_old = register_A; register_A = cmp_new = rom[0x1000 | register_A]; /* new acc value */
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
ram[register_I = (register_P << 4) + 0xa] = register_A; /* store acc to RAM */
register_P = 0x5; /* set page register */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x5f]; /* set I register */
cmp_old = register_A; register_A = cmp_new = rom[0x1000 | register_A]; /* new acc value */
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
ram[register_I = (register_P << 4) + 0x8] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0f]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
cmp_old = register_A; register_A = cmp_new = rom[0x1000 | register_A]; /* new acc value */
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
ram[register_I = (register_P << 4) + 0x9] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0f]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x2))) & 0xFFF; /* add values, save carry */
cmp_old = register_A; register_A = cmp_new = rom[0x1000 | register_A]; /* new acc value */
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
ram[register_I = (register_P << 4) + 0xa] = register_A; /* store acc to RAM */
case 0x1704:
register_P = 0x8; /* set page register */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x89]; /* set I register */
register_P = 0x7; /* set page register */
ram[register_I = 0x7a] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0800;
ram[register_I = 0x78] = 0x800; /* store acc to RAM */
flag_C = acc_a0 = register_A;
cmp_old = register_B; /* save old accB */
register_B = cmp_new = get_coin_state(); /* apparently not used in tailgunner??? */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_new = 0x1; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x0001;
reset_coin_counter(1);
cmp_new = 0x0EEE; cmp_old = acc_a0 = register_A; flag_C = (0x0EEE + register_A);
register_A = (register_A >> 1) | ((register_B & 1) << 11);
register_B = (register_B >> 1) | (register_B & 0x800);
reset_coin_counter(register_A&1);
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x78]) ^ 0xFFF) + 1 + register_A);
register_J = 0x072e;
if (cmp_new == cmp_old) {register_PC = 0x172e; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_new = 0x1; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x0001;
ram[0x78] = 0x001; /* store acc */
flag_C = acc_a0 = register_A;
cmp_old = register_B; /* save old accB */
register_B = cmp_new = get_quarters_per_game(); /* 1 => 1q/game, 0 => 2q/game */
acc_a0 = register_A;
flag_C = ((((cmp_new = ram[register_I = (register_P << 4) + 0x8]) ^ 0xFFF) + 1) + (cmp_old = register_B)); /* ones compliment */
register_J = 0x072b;
if (cmp_new == cmp_old) {register_PC = 0x172b; continue;};
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x79]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
ram[0x79] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_new = 0x1; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x0001;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x79]) ^ 0xFFF) + 1 + register_A);
register_J = 0x072e;
if (cmp_new == cmp_old) {register_PC = 0x172e; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
ram[0x79] = 0x000; /* store acc */
case 0x172b:
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0a]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
ram[register_I] = register_A; /* store acc */
case 0x172e:
register_P = 0x7; /* set page register */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x7a]; /* set I register */
register_P = 0x8; /* set page register */
ram[register_I = 0x89] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_P = 0x7; /* set page register */
ram[register_I = 0x7a] = 0x000; /* store acc to RAM */
register_P = 0x6; /* set page register */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x69]) ^ 0xFFF) + 1 + register_A);
register_J = 0x07b9;
if (cmp_new == cmp_old) {register_PC = 0x17b9; continue;};
vgColour = 0x07;
register_P = 0x8; /* set page register */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x81]; /* set I register */
register_J = 0x0749;
if (cmp_new == cmp_old) {register_PC = 0x1749; continue;};
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (((cmp_new = 0xa) ^ 0xFFF) + 1))) & 0xFFF; /* 1's-comp add */
if (cmp_new < cmp_old) {register_PC = 0x1749; continue;};
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x8b]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
ram[0x8b] = register_A; /* store acc */
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
vgColour = (register_A & 0x01) != 0 ? 0x0f: 0x07;
case 0x1749:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0100;
cmp_old = register_A; cmp_new = 0xcc;
register_A = flag_C = acc_a0 = 0x01cc;
register_P = 0x0; /* set page register */
ram[register_I = 0x03] = 0x1cc; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0200;
cmp_old = register_A; cmp_new = 0x8a;
register_A = flag_C = acc_a0 = 0x028a;
ram[register_I = 0x04] = 0x28a; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x21;
register_A = flag_C = acc_a0 = 0x0021;
ram[register_I = 0x0e] = 0x021; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_new = 0x3; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x0003;
ram[register_I = 0x0f] = 0x003; /* store acc to RAM */
cmp_old = register_A; cmp_new = 0x01;
register_A = flag_C = acc_a0 = 0x0004;
ram[register_I = 0x02] = 0x004; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x81;
register_A = flag_C = acc_a0 = 0x0081;
ram[register_I = 0x05] = 0x081; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0700;
cmp_old = register_A; cmp_new = 0x67;
register_A = flag_C = acc_a0 = 0x0767;
ram[register_I = 0x00] = 0x767; /* store acc to RAM */
register_J = 0x0af3;
{register_PC = 0x1af3; continue;};
case 0x1767:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_P = 0x7; /* set page register */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x72]; /* set I register */
register_J = 0x0771;
if (cmp_new == cmp_old) {register_PC = 0x1771; continue;};
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (((cmp_new = 0x1) ^ 0xFFF) + 1))) & 0xFFF; /* 1's-comp add */
ram[0x72] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_new = 0x1; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x0001;
case 0x1771:
vgColour = (register_A & 0x01) != 0 ? 0x0f: 0x07;
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_new = 0xa; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x000a;
register_P = 0x6; /* set page register */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = 0x69]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
ram[0x69] = register_A; /* store acc */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (((cmp_new = 0x9) ^ 0xFFF) + 1))) & 0xFFF; /* 1's-comp add */
register_J = 0x0784;
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x1784; continue;};
register_P = 0x7; /* set page register */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x7b]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
ram[0x7b] = register_A; /* store acc */
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
vgColour = (register_A & 0x01) != 0 ? 0x0f: 0x07;
case 0x1784:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0300;
cmp_old = register_A; cmp_new = 0x20;
register_A = flag_C = acc_a0 = 0x0320;
register_P = 0x0; /* set page register */
ram[register_I = 0x03] = 0x320; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0200;
cmp_old = register_A; cmp_new = 0x58;
register_A = flag_C = acc_a0 = 0x0258;
ram[register_I = 0x04] = 0x258; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x21;
register_A = flag_C = acc_a0 = 0x0021;
ram[register_I = 0x0e] = 0x021; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_new = 0x3; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x0003;
ram[register_I = 0x0f] = 0x003; /* store acc to RAM */
cmp_old = register_A; cmp_new = 0x01;
register_A = flag_C = acc_a0 = 0x0004;
ram[register_I = 0x02] = 0x004; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x69;
register_A = flag_C = acc_a0 = 0x0069;
ram[register_I = 0x05] = 0x069; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0700;
cmp_old = register_A; cmp_new = 0xa2;
register_A = flag_C = acc_a0 = 0x07a2;
ram[register_I = 0x00] = 0x7a2; /* store acc to RAM */
register_J = 0x0af3;
{register_PC = 0x1af3; continue;};
case 0x17a2:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_new = 0xa; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x000a;
register_P = 0x6; /* set page register */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = 0x69]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
ram[0x69] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x1d;
register_A = flag_C = acc_a0 = 0x001d;
set_sound_data(1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_A(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_B(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_C(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
register_J = 0x0058;
register_P = 0x1; /* set page register */
register_PC = 0x0058; /* rom offset */
{register_PC = 0x0058; continue;};
case 0x17b9:
register_P = 0x6; /* set page register */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x6a]; /* set I register */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x6c]) ^ 0xFFF) + 1 + register_A);
register_J = 0x07cb;
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x17cb; continue;};
register_J = 0x07c5;
if (cmp_new == cmp_old) {register_PC = 0x17c5; continue;};
ram[0x6c] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x6b]; /* set I register */
ram[register_I = 0x6d] = register_A; /* store acc to RAM */
case 0x17c5:
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0b]; /* set I register */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0xd]) ^ 0xFFF) + 1 + register_A);
register_J = 0x07cb;
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x17cb; continue;};
ram[register_I] = register_A; /* store acc */
case 0x17cb:
flag_C = acc_a0 = register_A;
cmp_old = register_B; /* step back cmp flag */
register_B = cmp_new = 0x0200;
cmp_old = register_B; acc_a0 = register_A; /* save old accA bit0 */
cmp_new = 0x76;
register_B = flag_C = 0x0276; cmp_new = 0x76; /* No carry */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0200;
cmp_old = register_A; cmp_new = 0xda;
register_A = flag_C = acc_a0 = 0x02da;
FromX = register_A & 0xFFF; /* regA goes to x-coord */
FromY = register_B & 0xFFF; /* regB goes to y-coord */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
vgColour = 0x07;
cmp_new = 0x1; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x0001;
register_P = 0x6; /* set page register */
ram[register_I = 0x61] = 0x001; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
ram[register_I = 0x62] = 0x000; /* store acc to RAM */
ram[register_I = 0x60] = 0x000; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x1c;
register_A = flag_C = acc_a0 = 0x001c;
set_sound_data(0);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_A(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_B(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_C(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0200;
cmp_old = register_A; cmp_new = 0xbc;
register_A = flag_C = acc_a0 = 0x02bc;
register_P = 0x0; /* set page register */
ram[register_I = 0x03] = 0x2bc; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0200;
cmp_old = register_A; cmp_new = 0x8a;
register_A = flag_C = acc_a0 = 0x028a;
ram[register_I = 0x04] = 0x28a; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x21;
register_A = flag_C = acc_a0 = 0x0021;
ram[register_I = 0x0e] = 0x021; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
ram[register_I = 0x0f] = 0x000; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0800;
cmp_old = register_A; cmp_new = 0x03;
register_A = flag_C = acc_a0 = 0x0803;
ram[register_I = 0x05] = 0x803; /* store acc to RAM */
cmp_old = register_A; cmp_new = 0x0c;
register_A = flag_C = acc_a0 = 0x080f;
register_PC = 0x1800; return;
default: return; // Switch banks
}
}
}
/*********************************************************/
void cineExecute1800()
{
for (;;) {
switch (register_PC)
{
case 0x1800:
ram[register_I = 0x00] = 0x80f; /* store acc to RAM */
register_J = 0x0af3;
{register_PC = 0x1af3; continue;};
case 0x180f:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0200;
cmp_old = register_A; cmp_new = 0xf8;
register_A = flag_C = acc_a0 = 0x02f8;
register_P = 0x0; /* set page register */
ram[register_I = 0x03] = 0x2f8; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0200;
cmp_old = register_A; cmp_new = 0x58;
register_A = flag_C = acc_a0 = 0x0258;
ram[register_I = 0x04] = 0x258; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x07;
register_A = flag_C = acc_a0 = 0x0007;
ram[register_I = 0x0e] = 0x007; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_new = 0x3; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x0003;
ram[register_I = 0x0f] = 0x003; /* store acc to RAM */
cmp_old = register_A; cmp_new = 0x01;
register_A = flag_C = acc_a0 = 0x0004;
ram[register_I = 0x02] = 0x004; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x6c;
register_A = flag_C = acc_a0 = 0x006c;
ram[register_I = 0x05] = 0x06c; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0800;
cmp_old = register_A; cmp_new = 0x2d;
register_A = flag_C = acc_a0 = 0x082d;
ram[register_I = 0x00] = 0x82d; /* store acc to RAM */
register_J = 0x0af3;
{register_PC = 0x1af3; continue;};
case 0x182d:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0300;
cmp_old = register_A; cmp_new = 0x10;
register_A = flag_C = acc_a0 = 0x0310;
register_P = 0x0; /* set page register */
ram[register_I = 0x03] = 0x310; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0200;
cmp_old = register_A; cmp_new = 0x58;
register_A = flag_C = acc_a0 = 0x0258;
ram[register_I = 0x04] = 0x258; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x07;
register_A = flag_C = acc_a0 = 0x0007;
ram[register_I = 0x0e] = 0x007; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_new = 0x3; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x0003;
ram[register_I = 0x0f] = 0x003; /* store acc to RAM */
cmp_old = register_A; cmp_new = 0x01;
register_A = flag_C = acc_a0 = 0x0004;
ram[register_I = 0x02] = 0x004; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x6d;
register_A = flag_C = acc_a0 = 0x006d;
ram[register_I = 0x05] = 0x06d; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0800;
cmp_old = register_A; cmp_new = 0x4b;
register_A = flag_C = acc_a0 = 0x084b;
ram[register_I = 0x00] = 0x84b; /* store acc to RAM */
register_J = 0x0af3;
{register_PC = 0x1af3; continue;};
case 0x184b:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_P = 0x8; /* set page register */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x89]) ^ 0xFFF) + 1 + register_A);
register_J = 0x095c;
if (cmp_new == cmp_old) {register_PC = 0x195c; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
vgColour = 0x07;
cmp_new = 0x1; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x0001;
register_P = 0x7; /* set page register */
ram[register_I = 0x7a] = 0x001; /* store acc to RAM */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (cmp_new = ram[0x7a]))) & 0xFFF;
set_watchdog();
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0100;
cmp_old = register_A; cmp_new = 0x90;
register_A = flag_C = acc_a0 = 0x0190;
register_P = 0x0; /* set page register */
ram[register_I = 0x03] = 0x190; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x32;
register_A = flag_C = acc_a0 = 0x0032;
ram[register_I = 0x04] = 0x032; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x4d;
register_A = flag_C = acc_a0 = 0x004d;
ram[register_I = 0x0e] = 0x04d; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
ram[register_I = 0x0f] = 0x000; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0800;
cmp_old = register_A; cmp_new = 0x6f;
register_A = flag_C = acc_a0 = 0x086f;
ram[register_I = 0x05] = 0x86f; /* store acc to RAM */
cmp_old = register_A; cmp_new = 0x09;
register_A = flag_C = acc_a0 = 0x0878;
ram[register_I = 0x00] = 0x878; /* store acc to RAM */
register_J = 0x0af3;
{register_PC = 0x1af3; continue;};
case 0x1878:
register_P = 0x8; /* set page register */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x89]; /* set I register */
ram[register_I = 0x8c] = register_A; /* store acc to RAM */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (((cmp_new = 0x9) ^ 0xFFF) + 1))) & 0xFFF; /* 1's-comp add */
register_J = 0x0882;
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x1882; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_new = 0x9; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x0009;
ram[0x8c] = 0x009; /* store acc */
case 0x1882:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0200;
cmp_old = register_A; cmp_new = 0x58;
register_A = flag_C = acc_a0 = 0x0258;
register_P = 0x0; /* set page register */
ram[register_I = 0x03] = 0x258; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x32;
register_A = flag_C = acc_a0 = 0x0032;
ram[register_I = 0x04] = 0x032; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x0b;
register_A = flag_C = acc_a0 = 0x000b;
ram[register_I = 0x0e] = 0x00b; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_new = 0x3; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x0003;
ram[register_I = 0x0f] = 0x003; /* store acc to RAM */
cmp_old = register_A; cmp_new = 0x01;
register_A = flag_C = acc_a0 = 0x0004;
ram[register_I = 0x02] = 0x004; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x8c;
register_A = flag_C = acc_a0 = 0x008c;
ram[register_I = 0x05] = 0x08c; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0800;
cmp_old = register_A; cmp_new = 0xa0;
register_A = flag_C = acc_a0 = 0x08a0;
ram[register_I = 0x00] = 0x8a0; /* store acc to RAM */
register_J = 0x0af3;
{register_PC = 0x1af3; continue;};
case 0x18a0:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x1e;
register_A = flag_C = acc_a0 = 0x001e;
set_sound_data(0);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_A(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_B(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_C(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x1a;
register_A = flag_C = acc_a0 = 0x001a;
set_sound_data(0);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_A(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_B(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_C(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x14;
register_A = flag_C = acc_a0 = 0x0014;
set_sound_data(0);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_A(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_B(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_C(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x16;
register_A = flag_C = acc_a0 = 0x0016;
set_sound_data(0);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_A(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_B(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_C(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x18;
register_A = flag_C = acc_a0 = 0x0018;
set_sound_data(0);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_A(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_B(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_C(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
register_P = 0x7; /* set page register */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x7b]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
ram[0x7b] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_new = 0x8; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x0008;
cmp_old = flag_C = acc_a0 = register_A;
register_A &= (cmp_new = ram[register_I]);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
vgColour = (register_A & 0x01) != 0 ? 0x0f: 0x07;
register_A = (flag_C = ((acc_a0 = cmp_old = register_A) + (cmp_new = 0x0012))) & 0xFFF; /* add values */
set_sound_data(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_A(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_B(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_C(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (cmp_new = ram[0x7b]))) & 0xFFF;
set_watchdog();
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0100;
cmp_old = register_A; cmp_new = 0x90;
register_A = flag_C = acc_a0 = 0x0190;
register_P = 0x0; /* set page register */
ram[register_I = 0x03] = 0x190; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0100;
cmp_old = register_A; cmp_new = 0x90;
register_A = flag_C = acc_a0 = 0x0190;
ram[register_I = 0x04] = 0x190; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x2c;
register_A = flag_C = acc_a0 = 0x002c;
ram[register_I = 0x0e] = 0x02c; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
ram[register_I = 0x0f] = 0x000; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0900;
cmp_old = register_A; cmp_new = 0x17;
register_A = flag_C = acc_a0 = 0x0917;
ram[register_I = 0x05] = 0x917; /* store acc to RAM */
cmp_old = register_A; cmp_new = 0x0c;
register_A = flag_C = acc_a0 = 0x0923;
ram[register_I = 0x00] = 0x923; /* store acc to RAM */
register_J = 0x0af3;
{register_PC = 0x1af3; continue;};
case 0x1923:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = get_io_startbutton();
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
register_J = 0x09c3;
if (cmp_new == cmp_old) {register_PC = 0x19c3; continue;};
register_P = 0x8; /* set page register */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x89]; /* set I register */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (((cmp_new = 0x1) ^ 0xFFF) + 1))) & 0xFFF; /* 1's-comp add */
ram[0x89] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x12;
register_A = flag_C = acc_a0 = 0x0012;
set_sound_data(0);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_A(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_B(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_C(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_P = 0x2; /* set page register */
ram[register_I = 0x2a] = 0x000; /* store acc to RAM */
ram[register_I = 0x2b] = 0x000; /* store acc to RAM */
register_P = 0x7; /* set page register */
ram[register_I = 0x7a] = 0x000; /* store acc to RAM */
ram[register_I = 0x7d] = 0x000; /* store acc to RAM */
register_P = 0x6; /* set page register */
ram[register_I = 0x6a] = 0x000; /* store acc to RAM */
ram[register_I = 0x6b] = 0x000; /* store acc to RAM */
register_P = 0x3; /* set page register */
ram[register_I = 0x30] = 0x000; /* store acc to RAM */
register_P = 0x4; /* set page register */
ram[register_I = 0x40] = 0x000; /* store acc to RAM */
register_P = 0x5; /* set page register */
ram[register_I = 0x50] = 0x000; /* store acc to RAM */
register_P = 0x7; /* set page register */
ram[register_I = 0x7b] = 0x000; /* store acc to RAM */
register_P = 0x8; /* set page register */
ram[register_I = 0x80] = 0x000; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x82]; /* set I register */
ram[register_I = 0x81] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_new = 0xa; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x000a;
register_P = 0x6; /* set page register */
ram[register_I = 0x69] = 0x00a; /* store acc to RAM */
register_P = 0x8; /* set page register */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x8a]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
ram[0x8a] = register_A; /* store acc */
register_J = 0x0058;
register_P = 0x1; /* set page register */
register_PC = 0x0058; /* rom offset */
{register_PC = 0x0058; continue;};
case 0x195c:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x12;
register_A = flag_C = acc_a0 = 0x0012;
set_sound_data(0);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_A(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_B(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_C(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_P = 0x7; /* set page register */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x7d]; /* set I register */
register_J = 0x09c3;
if (cmp_new == cmp_old) {register_PC = 0x19c3; continue;};
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
vgColour = (register_A & 0x01) != 0 ? 0x0f: 0x07;
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_P = 0x1; /* set page register */
ram[register_I = 0x19] = 0x000; /* store acc to RAM */
ram[register_I = 0x10] = 0x000; /* store acc to RAM */
ram[register_I = 0x11] = 0x000; /* store acc to RAM */
ram[register_I = 0x1c] = 0x000; /* store acc to RAM */
cmp_old = register_A; cmp_new = 0xff;
register_A = flag_C = acc_a0 = 0x00ff;
ram[register_I = 0x1d] = 0x0ff; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_new = 0x2; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x0002;
register_P = 0x7; /* set page register */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x7d]) ^ 0xFFF) + 1 + register_A);
register_J = 0x09b2;
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x19b2; continue;};
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x7c]; /* set I register */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (((cmp_new = 0x3) ^ 0xFFF) + 1))) & 0xFFF; /* 1's-comp add */
ram[0x7c] = register_A; /* store acc */
register_P = 0x1; /* set page register */
ram[register_I = 0x1e] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0900;
cmp_old = register_A; cmp_new = 0x8f;
register_A = flag_C = acc_a0 = 0x098f;
ram[register_I = 0x1f] = 0x98f; /* store acc to RAM */
register_J = 0x0575;
{register_PC = 0x1575; continue;};
case 0x198f:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0200;
register_P = 0x7; /* set page register */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x7e]) ^ 0xFFF) + 1 + register_A);
register_J = 0x0998;
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x1998; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_new = 0x3; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x0003;
ram[register_I = 0x7d] = 0x003; /* store acc to RAM */
case 0x1998:
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0e]; /* set I register */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (((cmp_new = 0xb) ^ 0xFFF) + 1))) & 0xFFF; /* 1's-comp add */
ram[register_I] = register_A; /* store acc */
register_P = 0x1; /* set page register */
ram[register_I = 0x12] = register_A; /* store acc to RAM */
case 0x199d:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0900;
cmp_old = register_A; cmp_new = 0xc3;
register_A = flag_C = acc_a0 = 0x09c3;
register_P = 0x0; /* set page register */
ram[register_I = 0x00] = 0x9c3; /* store acc to RAM */
flag_C = acc_a0 = register_A;
cmp_old = register_B; /* step back cmp flag */
register_B = cmp_new = 0x0300;
cmp_new = 0x0EEE; cmp_old = acc_a0 = register_A; flag_C = (0x0EEE + register_A);
register_A = (register_A >> 1) | ((register_B & 1) << 11);
register_B = (register_B >> 1) | (register_B & 0x800);
cmp_old = register_B; acc_a0 = register_A; /* save old accA bit0 */
register_B = (flag_C = (register_B + (cmp_new = 0x32))) & 0xFFF; /* add values */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0200;
cmp_old = acc_a0 = register_A; /* back up regA */
register_A = (flag_C = (register_A + (((cmp_new = 0x32) ^ 0xFFF) + 1))) & 0xFFF; /* add */
register_J = 0x09ad;
FromX = register_A & 0xFFF; /* regA goes to x-coord */
FromY = register_B & 0xFFF; /* regB goes to y-coord */
register_J = 0x09c7;
{register_PC = 0x19c7; continue;};
case 0x19b2:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = ram[register_I];
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
ram[register_I] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0e]; /* set I register */
register_P = 0x1; /* set page register */
ram[register_I = 0x12] = register_A; /* store acc to RAM */
register_P = 0x7; /* set page register */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x7c]; /* set I register */
register_P = 0x1; /* set page register */
ram[register_I = 0x1e] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0900;
cmp_old = register_A; cmp_new = 0x9d;
register_A = flag_C = acc_a0 = 0x099d;
ram[register_I = 0x1f] = 0x99d; /* store acc to RAM */
register_J = 0x0575;
{register_PC = 0x1575; continue;};
case 0x19c3:
register_J = 0x0058;
register_P = 0x1; /* set page register */
register_PC = 0x0058; /* rom offset */
{register_PC = 0x0058; continue;};
case 0x19c7:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0a00;
cmp_old = register_A; cmp_new = 0x1b;
register_A = flag_C = acc_a0 = 0x0a1b;
register_P = 0x1; /* set page register */
ram[register_I = 0x16] = 0xa1b; /* store acc to RAM */
cmp_old = register_A; cmp_new = 0x1a;
register_A = flag_C = acc_a0 = 0x0a35;
ram[register_I = 0x17] = 0xa35; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0900;
cmp_old = register_A; cmp_new = 0xd7;
register_A = flag_C = acc_a0 = 0x09d7;
register_P = 0x2; /* set page register */
ram[register_I = 0x2f] = 0x9d7; /* store acc to RAM */
register_J = 0x0128;
{register_PC = 0x1128; continue;};
case 0x19d7:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x7f;
register_A = flag_C = acc_a0 = 0x007f;
register_P = 0x7; /* set page register */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x7c]) ^ 0xFFF) + 1 + register_A);
cmp_old = flag_C = acc_a0 = register_A;
register_A &= (cmp_new = ram[register_I]);
ram[0x7c] = register_A; /* store acc */
cmp_old = acc_a0 = register_A; /* back up regA */
register_A = (flag_C = (register_A + (((cmp_new = 0x20) ^ 0xFFF) + 1))) & 0xFFF; /* add */
register_J = 0x09eb;
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x19eb; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x60;
register_A = flag_C = acc_a0 = 0x0060;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x7c]) ^ 0xFFF) + 1 + register_A);
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x19eb; continue;};
register_J = 0x047d;
{register_PC = 0x147d; continue;};
case 0x19eb:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0a00;
cmp_old = register_A; cmp_new = 0x3e;
register_A = flag_C = acc_a0 = 0x0a3e;
register_P = 0x1; /* set page register */
ram[register_I = 0x16] = 0xa3e; /* store acc to RAM */
cmp_old = register_A; cmp_new = 0x32;
register_A = flag_C = acc_a0 = 0x0a70;
ram[register_I = 0x17] = 0xa70; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0900;
cmp_old = register_A; cmp_new = 0xfb;
register_A = flag_C = acc_a0 = 0x09fb;
register_P = 0x2; /* set page register */
ram[register_I = 0x2f] = 0x9fb; /* store acc to RAM */
register_J = 0x0128;
{register_PC = 0x1128; continue;};
case 0x19fb:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0a00;
cmp_old = register_A; cmp_new = 0x7a;
register_A = flag_C = acc_a0 = 0x0a7a;
register_P = 0x1; /* set page register */
ram[register_I = 0x16] = 0xa7a; /* store acc to RAM */
cmp_old = register_A; cmp_new = 0x32;
register_A = flag_C = acc_a0 = 0x0aac;
ram[register_I = 0x17] = 0xaac; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0a00;
cmp_old = register_A; cmp_new = 0x0b;
register_A = flag_C = acc_a0 = 0x0a0b;
register_P = 0x2; /* set page register */
ram[register_I = 0x2f] = 0xa0b; /* store acc to RAM */
register_J = 0x0128;
{register_PC = 0x1128; continue;};
case 0x1a0b:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0a00;
cmp_old = register_A; cmp_new = 0xb8;
register_A = flag_C = acc_a0 = 0x0ab8;
register_P = 0x1; /* set page register */
ram[register_I = 0x16] = 0xab8; /* store acc to RAM */
cmp_old = register_A; cmp_new = 0x2f;
register_A = flag_C = acc_a0 = 0x0ae7;
ram[register_I = 0x17] = 0xae7; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0400;
cmp_old = register_A; cmp_new = 0x7d;
register_A = flag_C = acc_a0 = 0x047d;
register_P = 0x2; /* set page register */
ram[register_I = 0x2f] = 0x47d; /* store acc to RAM */
register_J = 0x0128;
{register_PC = 0x1128; continue;};
case 0x1af3:
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x03]; /* set I register */
flag_C = acc_a0 = register_A;
cmp_old = register_B; /* store old acc */
register_B = cmp_new = ram[register_I = (register_P << 4) + 0x04]; /* new acc value */
register_J = 0x0af6;
FromX = register_A & 0xFFF; /* regA goes to x-coord */
FromY = register_B & 0xFFF; /* regB goes to y-coord */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = (register_P << 4) + 0xe]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (((cmp_new = 0x1) ^ 0xFFF) + 1))) & 0xFFF; /* 1's-comp add */
case 0x1afd:
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
register_J = 0x0afd;
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x1afd; continue;};
ram[register_I = (register_P << 4) + 0xe] = register_A; /* store acc to RAM */
register_A = (flag_C = ((acc_a0 = cmp_old = register_A) + (cmp_new = 0x0018))) & 0xFFF; /* add values */
ram[register_I = (register_P << 4) + 0x6] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0xff;
register_A = flag_C = acc_a0 = 0x00ff;
ram[register_I = (register_P << 4) + 0x1] = 0x0ff; /* store acc to RAM */
case 0x1b09:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0xf]) ^ 0xFFF) + 1 + register_A);
register_J = 0x0b21;
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x1b21; continue;};
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x05]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
ram[register_I] = register_A; /* store acc */
cmp_old = register_A; register_A = cmp_new = rom[0x1000 | register_A]; /* new acc value */
case 0x1b13:
ram[register_I = (register_P << 4) + 0x7] = register_A; /* store acc to RAM */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0x1]) ^ 0xFFF) + 1 + register_A);
register_J = 0x0b6b;
if (cmp_new == cmp_old) {register_PC = 0x1b6b; continue;};
cmp_old = acc_a0 = register_A; /* back up regA */
register_A = (flag_C = (register_A + (((cmp_new = 0x40) ^ 0xFFF) + 1))) & 0xFFF; /* add */
register_J = 0x0b6e;
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x1b6e; continue;};
register_A = (flag_C = ((acc_a0 = cmp_old = register_A) + (cmp_new = 0x0039))) & 0xFFF; /* add values */
ram[register_I = (register_P << 4) + 0x7] = register_A; /* store acc to RAM */
{register_PC = 0x1b6e; continue;};
case 0x1b21:
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x02]; /* set I register */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (((cmp_new = 0x1) ^ 0xFFF) + 1))) & 0xFFF; /* 1's-comp add */
register_J = 0x0b6b;
if (cmp_new == cmp_old) {register_PC = 0x1b6b; continue;};
ram[register_I] = register_A; /* store acc */
register_I = ram[(register_P << 4) + 0x05]&0xff; /* set/mask new register_I */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = ram[register_I];
ram[register_I = (register_P << 4) + 0x7] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0f]; /* set I register */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (((cmp_new = 0x1) ^ 0xFFF) + 1))) & 0xFFF; /* 1's-comp add */
ram[register_I] = register_A; /* store acc */
register_J = 0x0b63;
if (cmp_new == cmp_old) {register_PC = 0x1b63; continue;};
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (((cmp_new = 0x1) ^ 0xFFF) + 1))) & 0xFFF; /* 1's-comp add */
register_J = 0x0b3c;
if (cmp_new == cmp_old) {register_PC = 0x1b3c; continue;};
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x07]; /* set I register */
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
register_J = 0x0b3d;
{register_PC = 0x1b3d; continue;};
case 0x1b3c:
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x07]; /* set I register */
case 0x1b3d:
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
ram[register_I] = register_A; /* store acc */
case 0x1b42:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_new = 0xf; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x000f;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0x7]) ^ 0xFFF) + 1 + register_A);
cmp_old = flag_C = acc_a0 = register_A;
register_A &= (cmp_new = ram[register_I]);
ram[register_I] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0e]; /* set I register */
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
register_J = 0x0b52;
if ((acc_a0 & 0x01) != 0) {register_PC = 0x1b52; continue;};
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0x7]) ^ 0xFFF) + 1 + register_A);
register_J = 0x0b58;
if (cmp_new == cmp_old) {register_PC = 0x1b58; continue;};
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
ram[register_I = (register_P << 4) + 0xe] = register_A; /* store acc to RAM */
case 0x1b52:
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x07]; /* set I register */
register_A = (flag_C = ((acc_a0 = cmp_old = register_A) + (cmp_new = 0x0030))) & 0xFFF; /* add values */
register_J = 0x0b13;
{register_PC = 0x1b13; continue;};
case 0x1b58:
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x02]; /* set I register */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (((cmp_new = 0x1) ^ 0xFFF) + 1))) & 0xFFF; /* 1's-comp add */
register_J = 0x0b52;
if (cmp_new == cmp_old) {register_PC = 0x1b52; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x5b;
register_A = flag_C = acc_a0 = 0x005b;
register_J = 0x0b13;
{register_PC = 0x1b13; continue;};
case 0x1b63:
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x3))) & 0xFFF; /* add values, save carry */
ram[register_I = (register_P << 4) + 0xf] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x05]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
ram[register_I] = register_A; /* store acc */
register_J = 0x0b42;
{register_PC = 0x1b42; continue;};
case 0x1b6b:
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0x0]) ^ 0xFFF) + 1 + register_A);
/* load J reg from value at last dir addr */
register_J = ram[register_I];
if ((register_J & (~0xfff)) != 0) ERROR("Ram value must have been > 12 bits!\n");
{register_PC = 0x1000 | register_J; continue;};
case 0x1b6e:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0c00;
cmp_old = register_A; cmp_new = 0x29;
register_A = flag_C = acc_a0 = 0x0c29;
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = (register_P << 4) + 0x7]))) & 0xFFF; /* do acc operation */
cmp_old = register_A; register_A = cmp_new = rom[0x1000 | register_A]; /* new acc value */
ram[register_I] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0b00;
cmp_old = register_A; cmp_new = 0xef;
register_A = flag_C = acc_a0 = 0x0bef;
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (cmp_new = ram[register_I]))) & 0xFFF;
set_watchdog();
ram[register_I] = register_A; /* store acc */
case 0x1b7a:
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x07]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
ram[register_I] = register_A; /* store acc */
cmp_old = register_A; register_A = cmp_new = rom[0x1000 | register_A]; /* new acc value */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0x1]) ^ 0xFFF) + 1 + register_A);
register_J = 0x0bc1;
if (cmp_new == cmp_old) {register_PC = 0x1bc1; continue;};
ram[register_I = (register_P << 4) + 0xd] = register_A; /* store acc to RAM */
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
ram[register_I = (register_P << 4) + 0xc] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0b00;
cmp_old = register_A; cmp_new = 0xd2;
register_A = flag_C = acc_a0 = 0x0bd2;
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (cmp_new = ram[register_I]))) & 0xFFF;
set_watchdog();
ram[register_I] = register_A; /* store acc */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
cmp_old = register_A; register_A = cmp_new = rom[0x1000 | register_A]; /* new acc value */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = (register_P << 4) + 0x4]))) & 0xFFF; /* do acc operation */
ram[register_I = (register_P << 4) + 0x9] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0c]; /* set I register */
cmp_old = register_A; register_A = cmp_new = rom[0x1000 | register_A]; /* new acc value */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = (register_P << 4) + 0x3]))) & 0xFFF; /* do acc operation */
ram[register_I = (register_P << 4) + 0x8] = register_A; /* store acc to RAM */
flag_C = acc_a0 = register_A;
cmp_old = register_B; /* store old acc */
register_B = cmp_new = ram[register_I = (register_P << 4) + 0x09]; /* new acc value */
register_J = 0x0b9b;
FromX = register_A & 0xFFF; /* regA goes to x-coord */
FromY = register_B & 0xFFF; /* regB goes to y-coord */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_new = 0xf; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x000f;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = (register_P << 4) + 0xd]) ^ 0xFFF) + 1 + register_A);
cmp_old = flag_C = acc_a0 = register_A;
register_A &= (cmp_new = ram[register_I]);
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
ram[register_I] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0b00;
cmp_old = register_A; cmp_new = 0xd2;
register_A = flag_C = acc_a0 = 0x0bd2;
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (cmp_new = ram[register_I]))) & 0xFFF;
set_watchdog();
ram[register_I] = register_A; /* store acc */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
cmp_old = register_A; register_A = cmp_new = rom[0x1000 | register_A]; /* new acc value */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = (register_P << 4) + 0x4]))) & 0xFFF; /* do acc operation */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = (register_P << 4) + 0x9]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
ram[register_I = (register_P << 4) + 0xb] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0d]; /* set I register */
cmp_old = register_A; register_A = cmp_new = rom[0x1000 | register_A]; /* new acc value */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = (register_P << 4) + 0x3]))) & 0xFFF; /* do acc operation */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = (register_P << 4) + 0x8]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
ram[register_I = (register_P << 4) + 0xa] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0a]; /* set I register */
flag_C = acc_a0 = register_A;
cmp_old = register_B; /* store old acc */
register_B = cmp_new = ram[register_I = (register_P << 4) + 0x0b]; /* new acc value */
{int temp_byte = 0;
for (;;) {
if ( ((((register_A >> 8) & 0x0A) != 0) && ((((register_A >> 8) & 0x0A) ^ 0x0A)) != 0)
|| ((((register_B >> 8) & 0x0A) != 0) && ((((register_B >> 8) & 0x0A) ^ 0x0A)) != 0) ) break;
register_A <<= 1; register_B <<= 1;
temp_byte = (temp_byte+1) & 0xff; if (temp_byte == 0) break /* This may not be correct */;
}
vgShiftLength = temp_byte & 0xfff; register_A &= 0x0FFF; register_B &= 0x0FFF;
}
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = (register_P << 4) + 0x8]))) & 0xFFF; /* do acc operation */
acc_a0 = register_A; /* store old acc value */
register_B = (flag_C = ((cmp_old = register_B) + (cmp_new = ram[register_I = (register_P << 4) + 0x09]))) & 0xFFF; /* do acc operation */
{
/* set ending points and draw the vector, or buffer for a later draw. */
int ToX = register_A & 0xFFF;
int ToY = register_B & 0xFFF;
/* Sign extend from 20 bit CCPU to 32bit target machine */
FromX = SEX(FromX);
ToX = SEX(ToX);
FromY = SEX(FromY);
ToY = SEX(ToY);
/* figure out the vector */
ToX -= FromX;
ToX = ((int)(((int)ToX) >> (int)((vgShiftLength)&31))) /* SAR */;
ToX += FromX;
ToY -= FromY;
ToY = ((int)(((int)ToY) >> (int)((vgShiftLength)&31))) /* SAR */;
ToY += FromY;
/* render the line */
CinemaVectorData (FromX, FromY, ToX, ToY, vgColour);
}
register_J = 0x0b7a;
{register_PC = 0x1b7a; continue;};
case 0x1bc1:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_new = 0x9; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x0009;
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = (register_P << 4) + 0x4]))) & 0xFFF; /* do acc operation */
ram[register_I = (register_P << 4) + 0x9] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x06]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = (register_P << 4) + 0x3]))) & 0xFFF; /* do acc operation */
ram[register_I] = register_A; /* store acc */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x3))) & 0xFFF; /* add values, save carry */
flag_C = acc_a0 = register_A;
cmp_old = register_B; /* store old acc */
register_B = cmp_new = ram[register_I = (register_P << 4) + 0x09]; /* new acc value */
register_J = 0x0bcb;
FromX = register_A & 0xFFF; /* regA goes to x-coord */
FromY = register_B & 0xFFF; /* regB goes to y-coord */
register_J = 0x0b09;
{register_PC = 0x1b09; continue;};
register_PC = 0x1d70; return;
default: return; // Switch banks
}
}
}
/*********************************************************/
void cineExecute1c00()
{
for (;;) {
switch (register_PC)
{
case 0x1d70:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x1a;
register_A = flag_C = acc_a0 = 0x001a;
set_sound_data(0);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_A(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_B(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_C(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x14;
register_A = flag_C = acc_a0 = 0x0014;
set_sound_data(0);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_A(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_B(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_C(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x1c;
register_A = flag_C = acc_a0 = 0x001c;
set_sound_data(0);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_A(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_B(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_C(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x18;
register_A = flag_C = acc_a0 = 0x0018;
set_sound_data(0);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_A(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_B(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_C(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
register_J = 0x0005;
{register_PC = 0x1005; continue;};
case 0x1dc0:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_P = 0x6; /* set page register */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x69]) ^ 0xFFF) + 1 + register_A);
register_J = 0x0dd5;
if (cmp_new == cmp_old) {register_PC = 0x1dd5; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x11;
register_A = flag_C = acc_a0 = 0x0011;
set_sound_data(1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_A(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_B(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
set_sound_addr_C(register_A&1);
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((register_A&1) != 0) strobe_sound_on(); else strobe_sound_off();
case 0x1dd5:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_P = 0x2; /* set page register */
ram[register_I = 0x29] = 0x000; /* store acc to RAM */
register_P = 0x7; /* set page register */
ram[register_I = 0x73] = 0x000; /* store acc to RAM */
register_P = 0x3; /* set page register */
ram[register_I = 0x37] = 0x000; /* store acc to RAM */
ram[register_I = 0x39] = 0x000; /* store acc to RAM */
ram[register_I = 0x3d] = 0x000; /* store acc to RAM */
register_P = 0x4; /* set page register */
ram[register_I = 0x47] = 0x000; /* store acc to RAM */
ram[register_I = 0x49] = 0x000; /* store acc to RAM */
ram[register_I = 0x4d] = 0x000; /* store acc to RAM */
register_P = 0x5; /* set page register */
ram[register_I = 0x57] = 0x000; /* store acc to RAM */
ram[register_I = 0x59] = 0x000; /* store acc to RAM */
ram[register_I = 0x5d] = 0x000; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0f00;
register_P = 0x3; /* set page register */
ram[register_I = 0x33] = 0xf00; /* store acc to RAM */
register_P = 0x4; /* set page register */
ram[register_I = 0x43] = 0xf00; /* store acc to RAM */
register_P = 0x5; /* set page register */
ram[register_I = 0x53] = 0xf00; /* store acc to RAM */
register_P = 0x2; /* set page register */
flag_C = acc_a0 = register_A;
cmp_old = register_B; /* store old acc */
register_B = cmp_new = ram[register_I = (register_P << 4) + 0x03]; /* new acc value */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_new = 0x0EEE; cmp_old = acc_a0 = register_A; flag_C = (0x0EEE + register_A);
register_A = (register_A >> 1) | ((register_B & 1) << 11);
register_B = (register_B >> 1) | (register_B & 0x800);
cmp_new = 0x0EEE; cmp_old = acc_a0 = register_A; flag_C = (0x0EEE + register_A);
register_A = (register_A >> 1) | ((register_B & 1) << 11);
register_B = (register_B >> 1) | (register_B & 0x800);
cmp_new = 0x0EEE; cmp_old = acc_a0 = register_A; flag_C = (0x0EEE + register_A);
register_A = (register_A >> 1) | ((register_B & 1) << 11);
register_B = (register_B >> 1) | (register_B & 0x800);
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = 0x22]))) & 0xFFF; /* do acc operation */
flag_C = acc_a0 = register_A;
cmp_old = register_B;
register_B = cmp_new = ram[register_I];
ram[0x22] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0200;
cmp_old = flag_C = acc_a0 = register_A;
register_A &= (cmp_new = ram[register_I]);
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
ram[0x22] = register_A; /* store acc */
acc_a0 = register_A;
cmp_old = register_B;
register_B = (flag_C = (register_B + (cmp_new = ram[register_I]))) & 0xFFF;
set_watchdog();
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x23]; /* set I register */
cmp_new = 0x0EEE; cmp_old = acc_a0 = register_A; flag_C = (0x0EEE + register_A);
register_A = (register_A >> 1) | ((register_B & 1) << 11);
register_B = (register_B >> 1) | (register_B & 0x800);
ram[0x23] = register_A; /* store acc */
ram[register_I = (register_P << 4) + 0x2] = register_B; /* set I register and store B to ram */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0xff;
register_A = flag_C = acc_a0 = 0x00ff;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x23]) ^ 0xFFF) + 1 + register_A);
cmp_old = flag_C = acc_a0 = register_A;
register_A &= (cmp_new = ram[register_I]);
register_A = (flag_C = ((acc_a0 = cmp_old = register_A) + (cmp_new = 0x00ff))) & 0xFFF; /* add values */
register_P = 0x5; /* set page register */
ram[register_I = 0x58] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_P = 0x3; /* set page register */
ram[register_I = 0x38] = 0x000; /* store acc to RAM */
register_P = 0x5; /* set page register */
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + ((cmp_new = ram[register_I = 0x58]) ^ 0xFFF) + 1)) & 0xFFF; /* set regI addr */
register_P = 0x4; /* set page register */
ram[register_I = 0x48] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0c00;
ram[register_I = 0x4a] = 0xc00; /* store acc to RAM */
register_P = 0x5; /* set page register */
ram[register_I = 0x5a] = 0xc00; /* store acc to RAM */
register_P = 0x3; /* set page register */
ram[register_I = 0x3a] = 0xc00; /* store acc to RAM */
register_P = 0x2; /* set page register */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x22]; /* set I register */
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
register_J = 0x0e9d;
if ((acc_a0 & 0x01) != 0) {register_PC = 0x1e9d; continue;};
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
if ((acc_a0 & 0x01) != 0) {register_PC = 0x1e9d; continue;};
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x23]; /* set I register */
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
register_J = 0x0e5b;
if ((acc_a0 & 0x01) != 0) {register_PC = 0x1e5b; continue;};
register_P = 0x3; /* set page register */
ram[register_I = 0x32] = register_A; /* store acc to RAM */
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (cmp_new = ram[0x32]))) & 0xFFF;
set_watchdog();
ram[0x32] = register_A; /* store acc */
cmp_old = acc_a0 = register_A; /* back up regA */
register_A = (flag_C = (register_A + (((cmp_new = 0x7f) ^ 0xFFF) + 1))) & 0xFFF; /* add */
register_P = 0x4; /* set page register */
ram[register_I = 0x42] = register_A; /* store acc to RAM */
register_A = (flag_C = ((acc_a0 = cmp_old = register_A) + (cmp_new = 0x00fe))) & 0xFFF; /* add values */
register_P = 0x5; /* set page register */
ram[register_I = 0x52] = register_A; /* store acc to RAM */
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
ram[register_I = 0x55] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
ram[0x55] = register_A; /* store acc */
register_P = 0x4; /* set page register */
ram[register_I = 0x45] = register_A; /* store acc to RAM */
register_P = 0x3; /* set page register */
ram[register_I = 0x35] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0800;
register_P = 0x2; /* set page register */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x23]) ^ 0xFFF) + 1 + register_A);
register_J = 0x0e88;
if (cmp_new < cmp_old) {register_PC = 0x1e88; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0900;
register_P = 0x3; /* set page register */
ram[register_I = 0x31] = 0x900; /* store acc to RAM */
cmp_old = register_A; cmp_new = 0xff;
register_A = flag_C = acc_a0 = 0x09ff;
register_P = 0x4; /* set page register */
ram[register_I = 0x41] = 0x9ff; /* store acc to RAM */
register_P = 0x5; /* set page register */
ram[register_I = 0x51] = 0x9ff; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x20;
register_A = flag_C = acc_a0 = 0x0020;
register_J = 0x0e94;
{register_PC = 0x1e94; continue;};
case 0x1e5b:
register_P = 0x3; /* set page register */
ram[register_I = 0x31] = register_A; /* store acc to RAM */
cmp_old = acc_a0 = register_A; /* back up regA */
register_A = (flag_C = (register_A + (((cmp_new = 0x7f) ^ 0xFFF) + 1))) & 0xFFF; /* add */
register_P = 0x4; /* set page register */
ram[register_I = 0x41] = register_A; /* store acc to RAM */
register_A = (flag_C = ((acc_a0 = cmp_old = register_A) + (cmp_new = 0x00fe))) & 0xFFF; /* add values */
register_P = 0x5; /* set page register */
ram[register_I = 0x51] = register_A; /* store acc to RAM */
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
ram[register_I = 0x54] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
ram[0x54] = register_A; /* store acc */
register_P = 0x4; /* set page register */
ram[register_I = 0x44] = register_A; /* store acc to RAM */
register_P = 0x3; /* set page register */
ram[register_I = 0x34] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0700;
register_P = 0x4; /* set page register */
ram[register_I = 0x42] = 0x700; /* store acc to RAM */
register_P = 0x5; /* set page register */
ram[register_I = 0x52] = 0x700; /* store acc to RAM */
cmp_old = acc_a0 = register_A; /* back up regA */
register_A = (flag_C = (register_A + (((cmp_new = 0xff) ^ 0xFFF) + 1))) & 0xFFF; /* add */
register_P = 0x3; /* set page register */
ram[register_I = 0x32] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0f00;
cmp_old = register_A; cmp_new = 0xe0;
register_A = flag_C = acc_a0 = 0x0fe0;
ram[register_I = 0x35] = 0xfe0; /* store acc to RAM */
register_P = 0x5; /* set page register */
ram[register_I = 0x55] = 0xfe0; /* store acc to RAM */
register_P = 0x4; /* set page register */
ram[register_I = 0x45] = 0xfe0; /* store acc to RAM */
register_J = 0x0e9a;
{register_PC = 0x1e9a; continue;};
case 0x1e88:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0700;
register_P = 0x3; /* set page register */
ram[register_I = 0x31] = 0x700; /* store acc to RAM */
cmp_old = acc_a0 = register_A; /* back up regA */
register_A = (flag_C = (register_A + (((cmp_new = 0xff) ^ 0xFFF) + 1))) & 0xFFF; /* add */
register_P = 0x4; /* set page register */
ram[register_I = 0x41] = register_A; /* store acc to RAM */
register_P = 0x5; /* set page register */
ram[register_I = 0x51] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0f00;
cmp_old = register_A; cmp_new = 0xe0;
register_A = flag_C = acc_a0 = 0x0fe0;
case 0x1e94:
register_P = 0x3; /* set page register */
ram[register_I = 0x34] = register_A; /* store acc to RAM */
register_P = 0x4; /* set page register */
ram[register_I = 0x44] = register_A; /* store acc to RAM */
register_P = 0x5; /* set page register */
ram[register_I = 0x54] = register_A; /* store acc to RAM */
case 0x1e9a:
register_J = 0x0ef8;
{register_PC = 0x1ef8; continue;};
case 0x1e9d:
register_P = 0x2; /* set page register */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x23]; /* set I register */
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
register_P = 0x4; /* set page register */
ram[register_I = 0x42] = register_A; /* store acc to RAM */
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (cmp_new = ram[0x42]))) & 0xFFF;
set_watchdog();
ram[0x42] = register_A; /* store acc */
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
ram[register_I = 0x45] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
ram[0x45] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0900;
ram[register_I = 0x41] = 0x900; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x18;
register_A = flag_C = acc_a0 = 0x0018;
ram[register_I = 0x44] = 0x018; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0700;
register_P = 0x3; /* set page register */
ram[register_I = 0x32] = 0x700; /* store acc to RAM */
register_P = 0x5; /* set page register */
ram[register_I = 0x51] = 0x700; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0f00;
cmp_old = register_A; cmp_new = 0xe8;
register_A = flag_C = acc_a0 = 0x0fe8;
ram[register_I = 0x54] = 0xfe8; /* store acc to RAM */
register_P = 0x3; /* set page register */
ram[register_I = 0x35] = 0xfe8; /* store acc to RAM */
register_P = 0x2; /* set page register */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x22]; /* set I register */
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
register_P = 0x3; /* set page register */
ram[register_I = 0x31] = register_A; /* store acc to RAM */
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
ram[register_I = 0x34] = register_A; /* store acc to RAM */
register_P = 0x2; /* set page register */
flag_C = acc_a0 = register_A;
cmp_old = register_B; /* store old acc */
register_B = cmp_new = ram[register_I = (register_P << 4) + 0x03]; /* new acc value */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_new = 0x0EEE; cmp_old = acc_a0 = register_A; flag_C = (0x0EEE + register_A);
register_A = (register_A >> 1) | ((register_B & 1) << 11);
register_B = (register_B >> 1) | (register_B & 0x800);
cmp_new = 0x0EEE; cmp_old = acc_a0 = register_A; flag_C = (0x0EEE + register_A);
register_A = (register_A >> 1) | ((register_B & 1) << 11);
register_B = (register_B >> 1) | (register_B & 0x800);
cmp_new = 0x0EEE; cmp_old = acc_a0 = register_A; flag_C = (0x0EEE + register_A);
register_A = (register_A >> 1) | ((register_B & 1) << 11);
register_B = (register_B >> 1) | (register_B & 0x800);
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = 0x22]))) & 0xFFF; /* do acc operation */
flag_C = acc_a0 = register_A;
cmp_old = register_B;
register_B = cmp_new = ram[register_I];
ram[0x22] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0200;
cmp_old = flag_C = acc_a0 = register_A;
register_A &= (cmp_new = ram[register_I]);
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
ram[0x22] = register_A; /* store acc */
acc_a0 = register_A;
cmp_old = register_B;
register_B = (flag_C = (register_B + (cmp_new = ram[register_I]))) & 0xFFF;
set_watchdog();
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x23]; /* set I register */
cmp_new = 0x0EEE; cmp_old = acc_a0 = register_A; flag_C = (0x0EEE + register_A);
register_A = (register_A >> 1) | ((register_B & 1) << 11);
register_B = (register_B >> 1) | (register_B & 0x800);
ram[0x23] = register_A; /* store acc */
ram[register_I = (register_P << 4) + 0x2] = register_B; /* set I register and store B to ram */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x23]; /* set I register */
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
register_P = 0x5; /* set page register */
ram[register_I = 0x52] = register_A; /* store acc to RAM */
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (cmp_new = ram[0x52]))) & 0xFFF;
set_watchdog();
ram[0x52] = register_A; /* store acc */
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
cmp_new = 0xDED; cmp_old = flag_C = acc_a0 = register_A;
register_A = SEX(register_A); /* make signed */
register_A = (((int)(((int)register_A) >> (int)((1)&31))) /* SAR */) & 0xFFF;
ram[register_I = 0x55] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + ((cmp_new = ram[register_I]) ^ 0xFFF) + 1)) & 0xFFF; /* ones compliment */
ram[0x55] = register_A; /* store acc */
case 0x1ef8:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x20;
register_A = flag_C = acc_a0 = 0x0020;
register_P = 0x2; /* set page register */
ram[register_I = 0x2e] = 0x020; /* store acc to RAM */
register_P = 0x6; /* set page register */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x6a]) ^ 0xFFF) + 1 + register_A);
register_J = 0x0f48;
if (cmp_new < cmp_old) {register_PC = 0x1f48; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0200;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x6a]) ^ 0xFFF) + 1 + register_A);
register_J = 0x0f3e;
if (cmp_new < cmp_old) {register_PC = 0x1f3e; continue;};
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x6a]) ^ 0xFFF) + 1 + register_A);
register_J = 0x0f30;
if (cmp_new < cmp_old) {register_PC = 0x1f30; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0600;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x6a]) ^ 0xFFF) + 1 + register_A);
register_J = 0x0f21;
if (cmp_new < cmp_old) {register_PC = 0x1f21; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x3c;
register_A = flag_C = acc_a0 = 0x003c;
register_P = 0x2; /* set page register */
ram[register_I = 0x2e] = 0x03c; /* store acc to RAM */
register_P = 0x6; /* set page register */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x6a]; /* set I register */
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
cmp_old = acc_a0 = register_A; /* back up regA */
register_A = (flag_C = (register_A + (((cmp_new = 0x60) ^ 0xFFF) + 1))) & 0xFFF; /* add */
register_J = 0x0f41;
{register_PC = 0x1f41; continue;};
case 0x1f21:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x38;
register_A = flag_C = acc_a0 = 0x0038;
register_P = 0x2; /* set page register */
ram[register_I = 0x2e] = 0x038; /* store acc to RAM */
register_P = 0x6; /* set page register */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x6a]; /* set I register */
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
cmp_old = acc_a0 = register_A; /* back up regA */
register_A = (flag_C = (register_A + (((cmp_new = 0x80) ^ 0xFFF) + 1))) & 0xFFF; /* add */
register_J = 0x0f41;
{register_PC = 0x1f41; continue;};
case 0x1f30:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x30;
register_A = flag_C = acc_a0 = 0x0030;
register_P = 0x2; /* set page register */
ram[register_I = 0x2e] = 0x030; /* store acc to RAM */
register_P = 0x6; /* set page register */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x6a]; /* set I register */
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
cmp_old = acc_a0 = register_A; /* back up regA */
register_A = (flag_C = (register_A + (((cmp_new = 0x80) ^ 0xFFF) + 1))) & 0xFFF; /* add */
register_J = 0x0f41;
{register_PC = 0x1f41; continue;};
case 0x1f3e:
register_P = 0x6; /* set page register */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x6a]; /* set I register */
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
case 0x1f41:
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
register_P = 0x2; /* set page register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = 0x2e]))) & 0xFFF; /* do acc operation */
ram[0x2e] = register_A; /* store acc */
case 0x1f48:
register_P = 0x2; /* set page register */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x23]; /* set I register */
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
register_J = 0x0f6c;
if ((acc_a0 & 0x01) != 0) {register_PC = 0x1f6c; continue;};
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
register_J = 0x0f5f;
if ((acc_a0 & 0x01) != 0) {register_PC = 0x1f5f; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x23;
register_A = flag_C = acc_a0 = 0x0023;
ram[register_I = 0x24] = 0x023; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x2e]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0xc))) & 0xFFF; /* add values, save carry */
ram[0x2e] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0500;
cmp_old = register_A; cmp_new = 0x39;
register_A = flag_C = acc_a0 = 0x0539;
register_J = 0x0f83;
{register_PC = 0x1f83; continue;};
case 0x1f5f:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x17;
register_A = flag_C = acc_a0 = 0x0017;
ram[register_I = (register_P << 4) + 0x4] = 0x017; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0e]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x8))) & 0xFFF; /* add values, save carry */
ram[register_I] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0500;
cmp_old = register_A; cmp_new = 0x03;
register_A = flag_C = acc_a0 = 0x0503;
register_J = 0x0f83;
{register_PC = 0x1f83; continue;};
case 0x1f6c:
cmp_new = 0x0BEB; cmp_old = acc_a0 = register_A; flag_C = (0x0BEB + register_A);
register_A >>= 1;
register_J = 0x0f7d;
if ((acc_a0 & 0x01) != 0) {register_PC = 0x1f7d; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_old = register_A; cmp_new = 0x11;
register_A = flag_C = acc_a0 = 0x0011;
ram[register_I = (register_P << 4) + 0x4] = 0x011; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0e]; /* set I register */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x4))) & 0xFFF; /* add values, save carry */
ram[register_I] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0400;
cmp_old = register_A; cmp_new = 0xc7;
register_A = flag_C = acc_a0 = 0x04c7;
register_J = 0x0f83;
{register_PC = 0x1f83; continue;};
case 0x1f7d:
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_new = 0x7; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x0007;
ram[register_I = (register_P << 4) + 0x4] = 0x007; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0400;
cmp_old = register_A; cmp_new = 0x81;
register_A = flag_C = acc_a0 = 0x0481;
case 0x1f83:
register_P = 0x3; /* set page register */
ram[register_I = 0x30] = register_A; /* store acc to RAM */
register_P = 0x4; /* set page register */
ram[register_I = 0x40] = register_A; /* store acc to RAM */
register_P = 0x5; /* set page register */
ram[register_I = 0x50] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
register_P = 0x6; /* set page register */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x69]) ^ 0xFFF) + 1 + register_A);
register_J = 0x0f99;
if (cmp_new == cmp_old) {register_PC = 0x1f99; continue;};
cmp_old = register_A; cmp_new = 0x10;
register_A = flag_C = acc_a0 = 0x0010;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x6a]) ^ 0xFFF) + 1 + register_A);
if ((flag_C & CARRYBIT) == 0) {register_PC = 0x1f99; continue;};
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = ram[register_I];
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0xf))) & 0xFFF; /* add values, save carry */
register_P = 0x2; /* set page register */
ram[register_I = 0x2e] = register_A; /* store acc to RAM */
case 0x1f99:
register_P = 0x2; /* set page register */
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = 0x2e]; /* set I register */
register_P = 0x3; /* set page register */
ram[register_I = 0x36] = register_A; /* store acc to RAM */
register_P = 0x4; /* set page register */
ram[register_I = 0x46] = register_A; /* store acc to RAM */
register_P = 0x5; /* set page register */
ram[register_I = 0x56] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0x0c00;
cmp_old = register_A; cmp_new = 0x7e;
register_A = flag_C = acc_a0 = 0x0c7e;
register_P = 0x2; /* set page register */
ram[register_I = 0x2e] = 0xc7e; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_new = 0x7; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x0007;
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x22]) ^ 0xFFF) + 1 + register_A);
cmp_old = flag_C = acc_a0 = register_A;
register_A &= (cmp_new = ram[register_I]);
cmp_new = 0x0CEC;
cmp_old = acc_a0 = register_A;
flag_C = (0x0CEC + register_A);
register_A = (register_A << 1) & 0x0FFF;
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = ram[register_I = 0x2e]))) & 0xFFF; /* do acc operation */
ram[0x2e] = register_A; /* store acc */
register_A = (flag_C = ((cmp_old = acc_a0 = register_A) + (cmp_new = 0x1))) & 0xFFF; /* add values, save carry */
cmp_old = register_A; register_A = cmp_new = rom[0x1000 | register_A]; /* new acc value */
ram[register_I = (register_P << 4) + 0x5] = register_A; /* store acc to RAM */
flag_C = acc_a0 = register_A;
cmp_old = register_B;
register_B = cmp_new = ram[register_I];
cmp_old = flag_C = acc_a0 = register_A; /* store old acc */
register_A = cmp_new = ram[register_I = (register_P << 4) + 0x0e]; /* set I register */
cmp_old = register_A; register_A = cmp_new = rom[0x1000 | register_A]; /* new acc value */
ram[register_I] = register_A; /* store acc */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_new = 0x0EEE; cmp_old = acc_a0 = register_A; flag_C = (0x0EEE + register_A);
register_A = (register_A >> 1) | ((register_B & 1) << 11);
register_B = (register_B >> 1) | (register_B & 0x800);
cmp_new = 0x0EEE; cmp_old = acc_a0 = register_A; flag_C = (0x0EEE + register_A);
register_A = (register_A >> 1) | ((register_B & 1) << 11);
register_B = (register_B >> 1) | (register_B & 0x800);
cmp_new = 0x0EEE; cmp_old = acc_a0 = register_A; flag_C = (0x0EEE + register_A);
register_A = (register_A >> 1) | ((register_B & 1) << 11);
register_B = (register_B >> 1) | (register_B & 0x800);
cmp_new = 0x0EEE; cmp_old = acc_a0 = register_A; flag_C = (0x0EEE + register_A);
register_A = (register_A >> 1) | ((register_B & 1) << 11);
register_B = (register_B >> 1) | (register_B & 0x800);
cmp_old = acc_a0 = register_A;
register_A = (flag_C = (register_A + (cmp_new = ram[register_I]))) & 0xFFF;
set_watchdog();
ram[register_I = (register_P << 4) + 0x5] = register_A; /* store acc to RAM */
cmp_old = flag_C = acc_a0 = register_A;
register_A = cmp_new = 0;
cmp_new = 0x7; cmp_old = acc_a0 = register_A; register_A = flag_C = 0x0007;
ram[register_I = (register_P << 4) + 0x0] = 0x007; /* store acc to RAM */
register_P = 0x1; /* set page register */
cmp_old = acc_a0 = register_A; /* backup old acc */
flag_C = (((cmp_new = ram[register_I = 0x1f]) ^ 0xFFF) + 1 + register_A);
case 0x1fc5:
/* load J reg from value at last dir addr */
register_J = ram[register_I];
if ((register_J & (~0xfff)) != 0) ERROR("Ram value must have been > 12 bits!\n");
register_P = 0x1; /* set page register */
register_PC = register_J + 0x0000; /* rom offset */
/* WARNING: UNKNOWN JUMP DESTINATION - MAY FOUL UP CODE OPTIMISATIONS */
{register_PC = (register_PC & 0xf000) | register_J; continue;};
default: return;
}
}
}