int Draw_Frame = 0; #include "types.h" #include "z80stub.h" #include "mspacman.h" #include "graphics.h" #ifdef NEVER // Here as documentation only: // From Pacman hardware (Galagino source code) but same as Ms Pacman // Orion *should* have made a call to access private flags for all of // these registers, similar to how my Tailgunner translation works. // It appears to have been relying on the exec procedure returning // frequently enough that the variables at 0x50XX would be updated // by the code in MSPac.c, but if the translated code is fully optimised // and running continuously in its own loop, those updates may not // happen frequently enough. I guess that confirms that we should // have the exec procedure run for exactly one frame at a time, as // I originally planned. static inline unsigned char pacman_RdZ80(unsigned short Addr) { Addr &= 0x7fff; // a15 is unused if(Addr < 16384) return pacman_rom[Addr]; if((Addr & 0xf000) == 0x4000) { // this includes spriteram 1 return memory[Addr - 0x4000]; } if((Addr & 0xf000) == 0x5000) { // get a mask of currently pressed keys unsigned char keymask = buttons_get(); if(Addr == 0x5080) // dip switch return PACMAN_DIP; if(Addr == 0x5000) { unsigned char retval = 0xff; if(keymask & BUTTON_UP) retval &= ~0x01; if(keymask & BUTTON_LEFT) retval &= ~0x02; if(keymask & BUTTON_RIGHT) retval &= ~0x04; if(keymask & BUTTON_DOWN) retval &= ~0x08; if(keymask & BUTTON_COIN) retval &= ~0x20; return retval; } if(Addr == 0x5040) { unsigned char retval = 0xff; // 0xef for service if(keymask & BUTTON_START) retval &= ~0x20; return retval; } } return 0xff; } static inline void pacman_WrZ80(unsigned short Addr, unsigned char Value) { Addr &= 0x7fff; // a15 is unused if((Addr & 0xf000) == 0x4000) { // writing 85 (U, first char of UP) to the top left corner // is an indication that the game has booted up <--- Good idea for Ms Pacman too. Suppress output and frame timing until first screen. // (as long as it is a trappable indirect write. Probably preferable to find actual code.) if(Addr == 0x4000 + 985 && Value == 85) game_started = 1; memory[Addr - 0x4000] = Value; return; } if((Addr & 0xff00) == 0x5000) { // 0x5060 to 0x506f writes through to ram (spriteram2) if((Addr & 0xfff0) == 0x5060) memory[Addr - 0x4000] = Value; if(Addr == 0x5000) irq_enable[0] = Value & 1; if((Addr & 0xffe0) == 0x5040) { if(soundregs[Addr - 0x5040] != Value & 0x0f) soundregs[Addr - 0x5040] = Value & 0x0f; } return; } // initial stack is at 0xf000 (0x6000 with a15 ignored), so catch that //if((Addr & 0xfffe) == 0x6ffe) // return; } #endif /* Precomputed flag tables */ const UINT16 sg_u16DAATable[0x800] = { 0x5400, 0x1001, 0x1002, 0x1403, 0x1004, 0x1405, 0x1406, 0x1007, 0x1008, 0x1409, 0x1010, 0x1411, 0x1412, 0x1013, 0x1414, 0x1015, 0x1010, 0x1411, 0x1412, 0x1013, 0x1414, 0x1015, 0x1016, 0x1417, 0x1418, 0x1019, 0x1020, 0x1421, 0x1422, 0x1023, 0x1424, 0x1025, 0x1020, 0x1421, 0x1422, 0x1023, 0x1424, 0x1025, 0x1026, 0x1427, 0x1428, 0x1029, 0x1430, 0x1031, 0x1032, 0x1433, 0x1034, 0x1435, 0x1430, 0x1031, 0x1032, 0x1433, 0x1034, 0x1435, 0x1436, 0x1037, 0x1038, 0x1439, 0x1040, 0x1441, 0x1442, 0x1043, 0x1444, 0x1045, 0x1040, 0x1441, 0x1442, 0x1043, 0x1444, 0x1045, 0x1046, 0x1447, 0x1448, 0x1049, 0x1450, 0x1051, 0x1052, 0x1453, 0x1054, 0x1455, 0x1450, 0x1051, 0x1052, 0x1453, 0x1054, 0x1455, 0x1456, 0x1057, 0x1058, 0x1459, 0x1460, 0x1061, 0x1062, 0x1463, 0x1064, 0x1465, 0x1460, 0x1061, 0x1062, 0x1463, 0x1064, 0x1465, 0x1466, 0x1067, 0x1068, 0x1469, 0x1070, 0x1471, 0x1472, 0x1073, 0x1474, 0x1075, 0x1070, 0x1471, 0x1472, 0x1073, 0x1474, 0x1075, 0x1076, 0x1477, 0x1478, 0x1079, 0x9080, 0x9481, 0x9482, 0x9083, 0x9484, 0x9085, 0x9080, 0x9481, 0x9482, 0x9083, 0x9484, 0x9085, 0x9086, 0x9487, 0x9488, 0x9089, 0x9490, 0x9091, 0x9092, 0x9493, 0x9094, 0x9495, 0x9490, 0x9091, 0x9092, 0x9493, 0x9094, 0x9495, 0x9496, 0x9097, 0x9098, 0x9499, 0x5500, 0x1101, 0x1102, 0x1503, 0x1104, 0x1505, 0x5500, 0x1101, 0x1102, 0x1503, 0x1104, 0x1505, 0x1506, 0x1107, 0x1108, 0x1509, 0x1110, 0x1511, 0x1512, 0x1113, 0x1514, 0x1115, 0x1110, 0x1511, 0x1512, 0x1113, 0x1514, 0x1115, 0x1116, 0x1517, 0x1518, 0x1119, 0x1120, 0x1521, 0x1522, 0x1123, 0x1524, 0x1125, 0x1120, 0x1521, 0x1522, 0x1123, 0x1524, 0x1125, 0x1126, 0x1527, 0x1528, 0x1129, 0x1530, 0x1131, 0x1132, 0x1533, 0x1134, 0x1535, 0x1530, 0x1131, 0x1132, 0x1533, 0x1134, 0x1535, 0x1536, 0x1137, 0x1138, 0x1539, 0x1140, 0x1541, 0x1542, 0x1143, 0x1544, 0x1145, 0x1140, 0x1541, 0x1542, 0x1143, 0x1544, 0x1145, 0x1146, 0x1547, 0x1548, 0x1149, 0x1550, 0x1151, 0x1152, 0x1553, 0x1154, 0x1555, 0x1550, 0x1151, 0x1152, 0x1553, 0x1154, 0x1555, 0x1556, 0x1157, 0x1158, 0x1559, 0x1560, 0x1161, 0x1162, 0x1563, 0x1164, 0x1565, 0x1560, 0x1161, 0x1162, 0x1563, 0x1164, 0x1565, 0x1566, 0x1167, 0x1168, 0x1569, 0x1170, 0x1571, 0x1572, 0x1173, 0x1574, 0x1175, 0x1170, 0x1571, 0x1572, 0x1173, 0x1574, 0x1175, 0x1176, 0x1577, 0x1578, 0x1179, 0x9180, 0x9581, 0x9582, 0x9183, 0x9584, 0x9185, 0x9180, 0x9581, 0x9582, 0x9183, 0x9584, 0x9185, 0x9186, 0x9587, 0x9588, 0x9189, 0x9590, 0x9191, 0x9192, 0x9593, 0x9194, 0x9595, 0x9590, 0x9191, 0x9192, 0x9593, 0x9194, 0x9595, 0x9596, 0x9197, 0x9198, 0x9599, 0x95a0, 0x91a1, 0x91a2, 0x95a3, 0x91a4, 0x95a5, 0x95a0, 0x91a1, 0x91a2, 0x95a3, 0x91a4, 0x95a5, 0x95a6, 0x91a7, 0x91a8, 0x95a9, 0x91b0, 0x95b1, 0x95b2, 0x91b3, 0x95b4, 0x91b5, 0x91b0, 0x95b1, 0x95b2, 0x91b3, 0x95b4, 0x91b5, 0x91b6, 0x95b7, 0x95b8, 0x91b9, 0x95c0, 0x91c1, 0x91c2, 0x95c3, 0x91c4, 0x95c5, 0x95c0, 0x91c1, 0x91c2, 0x95c3, 0x91c4, 0x95c5, 0x95c6, 0x91c7, 0x91c8, 0x95c9, 0x91d0, 0x95d1, 0x95d2, 0x91d3, 0x95d4, 0x91d5, 0x91d0, 0x95d1, 0x95d2, 0x91d3, 0x95d4, 0x91d5, 0x91d6, 0x95d7, 0x95d8, 0x91d9, 0x91e0, 0x95e1, 0x95e2, 0x91e3, 0x95e4, 0x91e5, 0x91e0, 0x95e1, 0x95e2, 0x91e3, 0x95e4, 0x91e5, 0x91e6, 0x95e7, 0x95e8, 0x91e9, 0x95f0, 0x91f1, 0x91f2, 0x95f3, 0x91f4, 0x95f5, 0x95f0, 0x91f1, 0x91f2, 0x95f3, 0x91f4, 0x95f5, 0x95f6, 0x91f7, 0x91f8, 0x95f9, 0x5500, 0x1101, 0x1102, 0x1503, 0x1104, 0x1505, 0x5500, 0x1101, 0x1102, 0x1503, 0x1104, 0x1505, 0x1506, 0x1107, 0x1108, 0x1509, 0x1110, 0x1511, 0x1512, 0x1113, 0x1514, 0x1115, 0x1110, 0x1511, 0x1512, 0x1113, 0x1514, 0x1115, 0x1116, 0x1517, 0x1518, 0x1119, 0x1120, 0x1521, 0x1522, 0x1123, 0x1524, 0x1125, 0x1120, 0x1521, 0x1522, 0x1123, 0x1524, 0x1125, 0x1126, 0x1527, 0x1528, 0x1129, 0x1530, 0x1131, 0x1132, 0x1533, 0x1134, 0x1535, 0x1530, 0x1131, 0x1132, 0x1533, 0x1134, 0x1535, 0x1536, 0x1137, 0x1138, 0x1539, 0x1140, 0x1541, 0x1542, 0x1143, 0x1544, 0x1145, 0x1140, 0x1541, 0x1542, 0x1143, 0x1544, 0x1145, 0x1146, 0x1547, 0x1548, 0x1149, 0x1550, 0x1151, 0x1152, 0x1553, 0x1154, 0x1555, 0x1550, 0x1151, 0x1152, 0x1553, 0x1154, 0x1555, 0x1556, 0x1157, 0x1158, 0x1559, 0x1560, 0x1161, 0x1162, 0x1563, 0x1164, 0x1565, 0x1406, 0x1007, 0x1008, 0x1409, 0x140a, 0x100b, 0x140c, 0x100d, 0x100e, 0x140f, 0x1010, 0x1411, 0x1412, 0x1013, 0x1414, 0x1015, 0x1016, 0x1417, 0x1418, 0x1019, 0x101a, 0x141b, 0x101c, 0x141d, 0x141e, 0x101f, 0x1020, 0x1421, 0x1422, 0x1023, 0x1424, 0x1025, 0x1026, 0x1427, 0x1428, 0x1029, 0x102a, 0x142b, 0x102c, 0x142d, 0x142e, 0x102f, 0x1430, 0x1031, 0x1032, 0x1433, 0x1034, 0x1435, 0x1436, 0x1037, 0x1038, 0x1439, 0x143a, 0x103b, 0x143c, 0x103d, 0x103e, 0x143f, 0x1040, 0x1441, 0x1442, 0x1043, 0x1444, 0x1045, 0x1046, 0x1447, 0x1448, 0x1049, 0x104a, 0x144b, 0x104c, 0x144d, 0x144e, 0x104f, 0x1450, 0x1051, 0x1052, 0x1453, 0x1054, 0x1455, 0x1456, 0x1057, 0x1058, 0x1459, 0x145a, 0x105b, 0x145c, 0x105d, 0x105e, 0x145f, 0x1460, 0x1061, 0x1062, 0x1463, 0x1064, 0x1465, 0x1466, 0x1067, 0x1068, 0x1469, 0x146a, 0x106b, 0x146c, 0x106d, 0x106e, 0x146f, 0x1070, 0x1471, 0x1472, 0x1073, 0x1474, 0x1075, 0x1076, 0x1477, 0x1478, 0x1079, 0x107a, 0x147b, 0x107c, 0x147d, 0x147e, 0x107f, 0x9080, 0x9481, 0x9482, 0x9083, 0x9484, 0x9085, 0x9086, 0x9487, 0x9488, 0x9089, 0x908a, 0x948b, 0x908c, 0x948d, 0x948e, 0x908f, 0x9490, 0x9091, 0x9092, 0x9493, 0x9094, 0x9495, 0x9496, 0x9097, 0x9098, 0x9499, 0x949a, 0x909b, 0x949c, 0x909d, 0x909e, 0x949f, 0x5500, 0x1101, 0x1102, 0x1503, 0x1104, 0x1505, 0x1506, 0x1107, 0x1108, 0x1509, 0x150a, 0x110b, 0x150c, 0x110d, 0x110e, 0x150f, 0x1110, 0x1511, 0x1512, 0x1113, 0x1514, 0x1115, 0x1116, 0x1517, 0x1518, 0x1119, 0x111a, 0x151b, 0x111c, 0x151d, 0x151e, 0x111f, 0x1120, 0x1521, 0x1522, 0x1123, 0x1524, 0x1125, 0x1126, 0x1527, 0x1528, 0x1129, 0x112a, 0x152b, 0x112c, 0x152d, 0x152e, 0x112f, 0x1530, 0x1131, 0x1132, 0x1533, 0x1134, 0x1535, 0x1536, 0x1137, 0x1138, 0x1539, 0x153a, 0x113b, 0x153c, 0x113d, 0x113e, 0x153f, 0x1140, 0x1541, 0x1542, 0x1143, 0x1544, 0x1145, 0x1146, 0x1547, 0x1548, 0x1149, 0x114a, 0x154b, 0x114c, 0x154d, 0x154e, 0x114f, 0x1550, 0x1151, 0x1152, 0x1553, 0x1154, 0x1555, 0x1556, 0x1157, 0x1158, 0x1559, 0x155a, 0x115b, 0x155c, 0x115d, 0x115e, 0x155f, 0x1560, 0x1161, 0x1162, 0x1563, 0x1164, 0x1565, 0x1566, 0x1167, 0x1168, 0x1569, 0x156a, 0x116b, 0x156c, 0x116d, 0x116e, 0x156f, 0x1170, 0x1571, 0x1572, 0x1173, 0x1574, 0x1175, 0x1176, 0x1577, 0x1578, 0x1179, 0x117a, 0x157b, 0x117c, 0x157d, 0x157e, 0x117f, 0x9180, 0x9581, 0x9582, 0x9183, 0x9584, 0x9185, 0x9186, 0x9587, 0x9588, 0x9189, 0x918a, 0x958b, 0x918c, 0x958d, 0x958e, 0x918f, 0x9590, 0x9191, 0x9192, 0x9593, 0x9194, 0x9595, 0x9596, 0x9197, 0x9198, 0x9599, 0x959a, 0x919b, 0x959c, 0x919d, 0x919e, 0x959f, 0x95a0, 0x91a1, 0x91a2, 0x95a3, 0x91a4, 0x95a5, 0x95a6, 0x91a7, 0x91a8, 0x95a9, 0x95aa, 0x91ab, 0x95ac, 0x91ad, 0x91ae, 0x95af, 0x91b0, 0x95b1, 0x95b2, 0x91b3, 0x95b4, 0x91b5, 0x91b6, 0x95b7, 0x95b8, 0x91b9, 0x91ba, 0x95bb, 0x91bc, 0x95bd, 0x95be, 0x91bf, 0x95c0, 0x91c1, 0x91c2, 0x95c3, 0x91c4, 0x95c5, 0x95c6, 0x91c7, 0x91c8, 0x95c9, 0x95ca, 0x91cb, 0x95cc, 0x91cd, 0x91ce, 0x95cf, 0x91d0, 0x95d1, 0x95d2, 0x91d3, 0x95d4, 0x91d5, 0x91d6, 0x95d7, 0x95d8, 0x91d9, 0x91da, 0x95db, 0x91dc, 0x95dd, 0x95de, 0x91df, 0x91e0, 0x95e1, 0x95e2, 0x91e3, 0x95e4, 0x91e5, 0x91e6, 0x95e7, 0x95e8, 0x91e9, 0x91ea, 0x95eb, 0x91ec, 0x95ed, 0x95ee, 0x91ef, 0x95f0, 0x91f1, 0x91f2, 0x95f3, 0x91f4, 0x95f5, 0x95f6, 0x91f7, 0x91f8, 0x95f9, 0x95fa, 0x91fb, 0x95fc, 0x91fd, 0x91fe, 0x95ff, 0x5500, 0x1101, 0x1102, 0x1503, 0x1104, 0x1505, 0x1506, 0x1107, 0x1108, 0x1509, 0x150a, 0x110b, 0x150c, 0x110d, 0x110e, 0x150f, 0x1110, 0x1511, 0x1512, 0x1113, 0x1514, 0x1115, 0x1116, 0x1517, 0x1518, 0x1119, 0x111a, 0x151b, 0x111c, 0x151d, 0x151e, 0x111f, 0x1120, 0x1521, 0x1522, 0x1123, 0x1524, 0x1125, 0x1126, 0x1527, 0x1528, 0x1129, 0x112a, 0x152b, 0x112c, 0x152d, 0x152e, 0x112f, 0x1530, 0x1131, 0x1132, 0x1533, 0x1134, 0x1535, 0x1536, 0x1137, 0x1138, 0x1539, 0x153a, 0x113b, 0x153c, 0x113d, 0x113e, 0x153f, 0x1140, 0x1541, 0x1542, 0x1143, 0x1544, 0x1145, 0x1146, 0x1547, 0x1548, 0x1149, 0x114a, 0x154b, 0x114c, 0x154d, 0x154e, 0x114f, 0x1550, 0x1151, 0x1152, 0x1553, 0x1154, 0x1555, 0x1556, 0x1157, 0x1158, 0x1559, 0x155a, 0x115b, 0x155c, 0x115d, 0x115e, 0x155f, 0x1560, 0x1161, 0x1162, 0x1563, 0x1164, 0x1565, 0x5600, 0x1201, 0x1202, 0x1603, 0x1204, 0x1605, 0x1606, 0x1207, 0x1208, 0x1609, 0x1204, 0x1605, 0x1606, 0x1207, 0x1208, 0x1609, 0x1210, 0x1611, 0x1612, 0x1213, 0x1614, 0x1215, 0x1216, 0x1617, 0x1618, 0x1219, 0x1614, 0x1215, 0x1216, 0x1617, 0x1618, 0x1219, 0x1220, 0x1621, 0x1622, 0x1223, 0x1624, 0x1225, 0x1226, 0x1627, 0x1628, 0x1229, 0x1624, 0x1225, 0x1226, 0x1627, 0x1628, 0x1229, 0x1630, 0x1231, 0x1232, 0x1633, 0x1234, 0x1635, 0x1636, 0x1237, 0x1238, 0x1639, 0x1234, 0x1635, 0x1636, 0x1237, 0x1238, 0x1639, 0x1240, 0x1641, 0x1642, 0x1243, 0x1644, 0x1245, 0x1246, 0x1647, 0x1648, 0x1249, 0x1644, 0x1245, 0x1246, 0x1647, 0x1648, 0x1249, 0x1650, 0x1251, 0x1252, 0x1653, 0x1254, 0x1655, 0x1656, 0x1257, 0x1258, 0x1659, 0x1254, 0x1655, 0x1656, 0x1257, 0x1258, 0x1659, 0x1660, 0x1261, 0x1262, 0x1663, 0x1264, 0x1665, 0x1666, 0x1267, 0x1268, 0x1669, 0x1264, 0x1665, 0x1666, 0x1267, 0x1268, 0x1669, 0x1270, 0x1671, 0x1672, 0x1273, 0x1674, 0x1275, 0x1276, 0x1677, 0x1678, 0x1279, 0x1674, 0x1275, 0x1276, 0x1677, 0x1678, 0x1279, 0x9280, 0x9681, 0x9682, 0x9283, 0x9684, 0x9285, 0x9286, 0x9687, 0x9688, 0x9289, 0x9684, 0x9285, 0x9286, 0x9687, 0x9688, 0x9289, 0x9690, 0x9291, 0x9292, 0x9693, 0x9294, 0x9695, 0x9696, 0x9297, 0x9298, 0x9699, 0x1334, 0x1735, 0x1736, 0x1337, 0x1338, 0x1739, 0x1340, 0x1741, 0x1742, 0x1343, 0x1744, 0x1345, 0x1346, 0x1747, 0x1748, 0x1349, 0x1744, 0x1345, 0x1346, 0x1747, 0x1748, 0x1349, 0x1750, 0x1351, 0x1352, 0x1753, 0x1354, 0x1755, 0x1756, 0x1357, 0x1358, 0x1759, 0x1354, 0x1755, 0x1756, 0x1357, 0x1358, 0x1759, 0x1760, 0x1361, 0x1362, 0x1763, 0x1364, 0x1765, 0x1766, 0x1367, 0x1368, 0x1769, 0x1364, 0x1765, 0x1766, 0x1367, 0x1368, 0x1769, 0x1370, 0x1771, 0x1772, 0x1373, 0x1774, 0x1375, 0x1376, 0x1777, 0x1778, 0x1379, 0x1774, 0x1375, 0x1376, 0x1777, 0x1778, 0x1379, 0x9380, 0x9781, 0x9782, 0x9383, 0x9784, 0x9385, 0x9386, 0x9787, 0x9788, 0x9389, 0x9784, 0x9385, 0x9386, 0x9787, 0x9788, 0x9389, 0x9790, 0x9391, 0x9392, 0x9793, 0x9394, 0x9795, 0x9796, 0x9397, 0x9398, 0x9799, 0x9394, 0x9795, 0x9796, 0x9397, 0x9398, 0x9799, 0x97a0, 0x93a1, 0x93a2, 0x97a3, 0x93a4, 0x97a5, 0x97a6, 0x93a7, 0x93a8, 0x97a9, 0x93a4, 0x97a5, 0x97a6, 0x93a7, 0x93a8, 0x97a9, 0x93b0, 0x97b1, 0x97b2, 0x93b3, 0x97b4, 0x93b5, 0x93b6, 0x97b7, 0x97b8, 0x93b9, 0x97b4, 0x93b5, 0x93b6, 0x97b7, 0x97b8, 0x93b9, 0x97c0, 0x93c1, 0x93c2, 0x97c3, 0x93c4, 0x97c5, 0x97c6, 0x93c7, 0x93c8, 0x97c9, 0x93c4, 0x97c5, 0x97c6, 0x93c7, 0x93c8, 0x97c9, 0x93d0, 0x97d1, 0x97d2, 0x93d3, 0x97d4, 0x93d5, 0x93d6, 0x97d7, 0x97d8, 0x93d9, 0x97d4, 0x93d5, 0x93d6, 0x97d7, 0x97d8, 0x93d9, 0x93e0, 0x97e1, 0x97e2, 0x93e3, 0x97e4, 0x93e5, 0x93e6, 0x97e7, 0x97e8, 0x93e9, 0x97e4, 0x93e5, 0x93e6, 0x97e7, 0x97e8, 0x93e9, 0x97f0, 0x93f1, 0x93f2, 0x97f3, 0x93f4, 0x97f5, 0x97f6, 0x93f7, 0x93f8, 0x97f9, 0x93f4, 0x97f5, 0x97f6, 0x93f7, 0x93f8, 0x97f9, 0x5700, 0x1301, 0x1302, 0x1703, 0x1304, 0x1705, 0x1706, 0x1307, 0x1308, 0x1709, 0x1304, 0x1705, 0x1706, 0x1307, 0x1308, 0x1709, 0x1310, 0x1711, 0x1712, 0x1313, 0x1714, 0x1315, 0x1316, 0x1717, 0x1718, 0x1319, 0x1714, 0x1315, 0x1316, 0x1717, 0x1718, 0x1319, 0x1320, 0x1721, 0x1722, 0x1323, 0x1724, 0x1325, 0x1326, 0x1727, 0x1728, 0x1329, 0x1724, 0x1325, 0x1326, 0x1727, 0x1728, 0x1329, 0x1730, 0x1331, 0x1332, 0x1733, 0x1334, 0x1735, 0x1736, 0x1337, 0x1338, 0x1739, 0x1334, 0x1735, 0x1736, 0x1337, 0x1338, 0x1739, 0x1340, 0x1741, 0x1742, 0x1343, 0x1744, 0x1345, 0x1346, 0x1747, 0x1748, 0x1349, 0x1744, 0x1345, 0x1346, 0x1747, 0x1748, 0x1349, 0x1750, 0x1351, 0x1352, 0x1753, 0x1354, 0x1755, 0x1756, 0x1357, 0x1358, 0x1759, 0x1354, 0x1755, 0x1756, 0x1357, 0x1358, 0x1759, 0x1760, 0x1361, 0x1362, 0x1763, 0x1364, 0x1765, 0x1766, 0x1367, 0x1368, 0x1769, 0x1364, 0x1765, 0x1766, 0x1367, 0x1368, 0x1769, 0x1370, 0x1771, 0x1772, 0x1373, 0x1774, 0x1375, 0x1376, 0x1777, 0x1778, 0x1379, 0x1774, 0x1375, 0x1376, 0x1777, 0x1778, 0x1379, 0x9380, 0x9781, 0x9782, 0x9383, 0x9784, 0x9385, 0x9386, 0x9787, 0x9788, 0x9389, 0x9784, 0x9385, 0x9386, 0x9787, 0x9788, 0x9389, 0x9790, 0x9391, 0x9392, 0x9793, 0x9394, 0x9795, 0x9796, 0x9397, 0x9398, 0x9799, 0x9394, 0x9795, 0x9796, 0x9397, 0x9398, 0x9799, 0x97fa, 0x93fb, 0x97fc, 0x93fd, 0x93fe, 0x97ff, 0x5600, 0x1201, 0x1202, 0x1603, 0x1204, 0x1605, 0x1606, 0x1207, 0x1208, 0x1609, 0x160a, 0x120b, 0x160c, 0x120d, 0x120e, 0x160f, 0x1210, 0x1611, 0x1612, 0x1213, 0x1614, 0x1215, 0x1216, 0x1617, 0x1618, 0x1219, 0x121a, 0x161b, 0x121c, 0x161d, 0x161e, 0x121f, 0x1220, 0x1621, 0x1622, 0x1223, 0x1624, 0x1225, 0x1226, 0x1627, 0x1628, 0x1229, 0x122a, 0x162b, 0x122c, 0x162d, 0x162e, 0x122f, 0x1630, 0x1231, 0x1232, 0x1633, 0x1234, 0x1635, 0x1636, 0x1237, 0x1238, 0x1639, 0x163a, 0x123b, 0x163c, 0x123d, 0x123e, 0x163f, 0x1240, 0x1641, 0x1642, 0x1243, 0x1644, 0x1245, 0x1246, 0x1647, 0x1648, 0x1249, 0x124a, 0x164b, 0x124c, 0x164d, 0x164e, 0x124f, 0x1650, 0x1251, 0x1252, 0x1653, 0x1254, 0x1655, 0x1656, 0x1257, 0x1258, 0x1659, 0x165a, 0x125b, 0x165c, 0x125d, 0x125e, 0x165f, 0x1660, 0x1261, 0x1262, 0x1663, 0x1264, 0x1665, 0x1666, 0x1267, 0x1268, 0x1669, 0x166a, 0x126b, 0x166c, 0x126d, 0x126e, 0x166f, 0x1270, 0x1671, 0x1672, 0x1273, 0x1674, 0x1275, 0x1276, 0x1677, 0x1678, 0x1279, 0x127a, 0x167b, 0x127c, 0x167d, 0x167e, 0x127f, 0x9280, 0x9681, 0x9682, 0x9283, 0x9684, 0x9285, 0x9286, 0x9687, 0x9688, 0x9289, 0x928a, 0x968b, 0x928c, 0x968d, 0x968e, 0x928f, 0x9690, 0x9291, 0x9292, 0x9693, 0x1334, 0x1735, 0x1736, 0x1337, 0x1338, 0x1739, 0x173a, 0x133b, 0x173c, 0x133d, 0x133e, 0x173f, 0x1340, 0x1741, 0x1742, 0x1343, 0x1744, 0x1345, 0x1346, 0x1747, 0x1748, 0x1349, 0x134a, 0x174b, 0x134c, 0x174d, 0x174e, 0x134f, 0x1750, 0x1351, 0x1352, 0x1753, 0x1354, 0x1755, 0x1756, 0x1357, 0x1358, 0x1759, 0x175a, 0x135b, 0x175c, 0x135d, 0x135e, 0x175f, 0x1760, 0x1361, 0x1362, 0x1763, 0x1364, 0x1765, 0x1766, 0x1367, 0x1368, 0x1769, 0x176a, 0x136b, 0x176c, 0x136d, 0x136e, 0x176f, 0x1370, 0x1771, 0x1772, 0x1373, 0x1774, 0x1375, 0x1376, 0x1777, 0x1778, 0x1379, 0x137a, 0x177b, 0x137c, 0x177d, 0x177e, 0x137f, 0x9380, 0x9781, 0x9782, 0x9383, 0x9784, 0x9385, 0x9386, 0x9787, 0x9788, 0x9389, 0x938a, 0x978b, 0x938c, 0x978d, 0x978e, 0x938f, 0x9790, 0x9391, 0x9392, 0x9793, 0x9394, 0x9795, 0x9796, 0x9397, 0x9398, 0x9799, 0x979a, 0x939b, 0x979c, 0x939d, 0x939e, 0x979f, 0x97a0, 0x93a1, 0x93a2, 0x97a3, 0x93a4, 0x97a5, 0x97a6, 0x93a7, 0x93a8, 0x97a9, 0x97aa, 0x93ab, 0x97ac, 0x93ad, 0x93ae, 0x97af, 0x93b0, 0x97b1, 0x97b2, 0x93b3, 0x97b4, 0x93b5, 0x93b6, 0x97b7, 0x97b8, 0x93b9, 0x93ba, 0x97bb, 0x93bc, 0x97bd, 0x97be, 0x93bf, 0x97c0, 0x93c1, 0x93c2, 0x97c3, 0x93c4, 0x97c5, 0x97c6, 0x93c7, 0x93c8, 0x97c9, 0x97ca, 0x93cb, 0x97cc, 0x93cd, 0x93ce, 0x97cf, 0x93d0, 0x97d1, 0x97d2, 0x93d3, 0x97d4, 0x93d5, 0x93d6, 0x97d7, 0x97d8, 0x93d9, 0x93da, 0x97db, 0x93dc, 0x97dd, 0x97de, 0x93df, 0x93e0, 0x97e1, 0x97e2, 0x93e3, 0x97e4, 0x93e5, 0x93e6, 0x97e7, 0x97e8, 0x93e9, 0x93ea, 0x97eb, 0x93ec, 0x97ed, 0x97ee, 0x93ef, 0x97f0, 0x93f1, 0x93f2, 0x97f3, 0x93f4, 0x97f5, 0x97f6, 0x93f7, 0x93f8, 0x97f9, 0x97fa, 0x93fb, 0x97fc, 0x93fd, 0x93fe, 0x97ff, 0x5700, 0x1301, 0x1302, 0x1703, 0x1304, 0x1705, 0x1706, 0x1307, 0x1308, 0x1709, 0x170a, 0x130b, 0x170c, 0x130d, 0x130e, 0x170f, 0x1310, 0x1711, 0x1712, 0x1313, 0x1714, 0x1315, 0x1316, 0x1717, 0x1718, 0x1319, 0x131a, 0x171b, 0x131c, 0x171d, 0x171e, 0x131f, 0x1320, 0x1721, 0x1722, 0x1323, 0x1724, 0x1325, 0x1326, 0x1727, 0x1728, 0x1329, 0x132a, 0x172b, 0x132c, 0x172d, 0x172e, 0x132f, 0x1730, 0x1331, 0x1332, 0x1733, 0x1334, 0x1735, 0x1736, 0x1337, 0x1338, 0x1739, 0x173a, 0x133b, 0x173c, 0x133d, 0x133e, 0x173f, 0x1340, 0x1741, 0x1742, 0x1343, 0x1744, 0x1345, 0x1346, 0x1747, 0x1748, 0x1349, 0x134a, 0x174b, 0x134c, 0x174d, 0x174e, 0x134f, 0x1750, 0x1351, 0x1352, 0x1753, 0x1354, 0x1755, 0x1756, 0x1357, 0x1358, 0x1759, 0x175a, 0x135b, 0x175c, 0x135d, 0x135e, 0x175f, 0x1760, 0x1361, 0x1362, 0x1763, 0x1364, 0x1765, 0x1766, 0x1367, 0x1368, 0x1769, 0x176a, 0x136b, 0x176c, 0x136d, 0x136e, 0x176f, 0x1370, 0x1771, 0x1772, 0x1373, 0x1774, 0x1375, 0x1376, 0x1777, 0x1778, 0x1379, 0x137a, 0x177b, 0x137c, 0x177d, 0x177e, 0x137f, 0x9380, 0x9781, 0x9782, 0x9383, 0x9784, 0x9385, 0x9386, 0x9787, 0x9788, 0x9389, 0x938a, 0x978b, 0x938c, 0x978d, 0x978e, 0x938f, 0x9790, 0x9391, 0x9392, 0x9793, 0x9394, 0x9795, 0x9796, 0x9397, 0x9398, 0x9799}; const UINT8 sg_u8INTTiming[3] = {13, 13, 19}; // Interrupt type timing static INT32 sg_s32StartCount; //static struct z80context Z80; static struct z80context Z80; // From 0x003b to 0x0041 (7 byte(s)) // Region 0x003b to 0x0041 (7 byte(s)) collapsed to 0x003b to 0x0040 (6 byte(s)) static const UINT8 sg_u8Region0[0x0006] = { 0x50, 0x32, 0x07, 0x50, 0xc3, 0x38 }; // From 0x0068 to 0x008c (37 byte(s)) // Region 0x0068 to 0x008c (37 byte(s)) collapsed to 0x0069 to 0x008c (36 byte(s)) static const UINT8 sg_u8Region1[0x0024] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x01, 0x03, 0x04, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x14 }; // From 0x0219 to 0x0220 (8 byte(s)) static const UINT8 sg_u8Region2[0x0008] = { 0x06, 0xa0, 0x0a, 0x60, 0x0a, 0x60, 0x0a, 0xa0 }; // From 0x0247 to 0x025a (20 byte(s)) static const UINT8 sg_u8Region3[0x0014] = { 0x94, 0x08, 0xa3, 0x06, 0x8e, 0x05, 0x72, 0x12, 0x00, 0x10, 0x0b, 0x10, 0x63, 0x02, 0x2b, 0x21, 0xf0, 0x21, 0xb9, 0x22 }; // From 0x03cc to 0x03d3 (8 byte(s)) static const UINT8 sg_u8Region4[0x0008] = { 0xd4, 0x03, 0xfe, 0x03, 0xe5, 0x05, 0xbe, 0x06 }; // From 0x03d8 to 0x03db (4 byte(s)) // Region 0x03d8 to 0x03db (4 byte(s)) collapsed to 0x03d8 to 0x03da (3 byte(s)) static const UINT8 sg_u8Region5[0x0003] = { 0xdc, 0x03, 0x0c }; // From 0x03dd to 0x03de (2 byte(s)) // Region 0x03dd to 0x03de (2 byte(s)) collapsed to 0x03df to 0x03de (0 byte(s)) // Region eliminated due to all 0x00 data // From 0x03e0 to 0x03e1 (2 byte(s)) // Region 0x03e0 to 0x03e1 (2 byte(s)) collapsed to 0x03e0 to 0x03e0 (1 byte(s)) static const UINT8 sg_u8Region6[0x0001] = { 0x06 }; // From 0x03e3 to 0x03e4 (2 byte(s)) // Region 0x03e3 to 0x03e4 (2 byte(s)) collapsed to 0x03e3 to 0x03e3 (1 byte(s)) static const UINT8 sg_u8Region7[0x0001] = { 0x01 }; // From 0x03e6 to 0x03e7 (2 byte(s)) // Region 0x03e6 to 0x03e7 (2 byte(s)) collapsed to 0x03e6 to 0x03e6 (1 byte(s)) static const UINT8 sg_u8Region8[0x0001] = { 0x14 }; // From 0x03e9 to 0x03ea (2 byte(s)) // Region 0x03e9 to 0x03ea (2 byte(s)) collapsed to 0x03e9 to 0x03e9 (1 byte(s)) static const UINT8 sg_u8Region9[0x0001] = { 0x18 }; // From 0x03ec to 0x03ed (2 byte(s)) // Region 0x03ec to 0x03ed (2 byte(s)) collapsed to 0x03ec to 0x03ec (1 byte(s)) static const UINT8 sg_u8Region10[0x0001] = { 0x04 }; // From 0x03ef to 0x03f0 (2 byte(s)) // Region 0x03ef to 0x03f0 (2 byte(s)) collapsed to 0x03ef to 0x03ef (1 byte(s)) static const UINT8 sg_u8Region11[0x0001] = { 0x1e }; // From 0x03f2 to 0x03f3 (2 byte(s)) // Region 0x03f2 to 0x03f3 (2 byte(s)) collapsed to 0x03f2 to 0x03f2 (1 byte(s)) static const UINT8 sg_u8Region12[0x0001] = { 0x07 }; // From 0x0416 to 0x045e (73 byte(s)) static const UINT8 sg_u8Region13[0x0049] = { 0xe7, 0x5f, 0x04, 0x0c, 0x00, 0x71, 0x04, 0x0c, 0x00, 0x7f, 0x04, 0x0c, 0x00, 0x85, 0x04, 0x0c, 0x00, 0x8b, 0x04, 0x0c, 0x00, 0x99, 0x04, 0x0c, 0x00, 0x9f, 0x04, 0x0c, 0x00, 0xa5, 0x04, 0x0c, 0x00, 0xb3, 0x04, 0x0c, 0x00, 0xb9, 0x04, 0x0c, 0x00, 0xbf, 0x04, 0x0c, 0x00, 0xcd, 0x04, 0x0c, 0x00, 0xd3, 0x04, 0x0c, 0x00, 0xd8, 0x04, 0x0c, 0x00, 0xe0, 0x04, 0x0c, 0x00, 0x1c, 0x05, 0x4b, 0x05, 0x56, 0x05, 0x61, 0x05, 0x6c, 0x05, 0x7c, 0x05 }; // From 0x0460 to 0x0461 (2 byte(s)) // Region 0x0460 to 0x0461 (2 byte(s)) collapsed to 0x0461 to 0x0461 (1 byte(s)) static const UINT8 sg_u8Region14[0x0001] = { 0x01 }; // From 0x0463 to 0x0464 (2 byte(s)) // Region 0x0463 to 0x0464 (2 byte(s)) collapsed to 0x0463 to 0x0463 (1 byte(s)) static const UINT8 sg_u8Region15[0x0001] = { 0x01 }; // From 0x0466 to 0x0467 (2 byte(s)) // Region 0x0466 to 0x0467 (2 byte(s)) collapsed to 0x0466 to 0x0466 (1 byte(s)) static const UINT8 sg_u8Region16[0x0001] = { 0x04 }; // From 0x0469 to 0x046a (2 byte(s)) // Region 0x0469 to 0x046a (2 byte(s)) collapsed to 0x0469 to 0x0469 (1 byte(s)) static const UINT8 sg_u8Region17[0x0001] = { 0x1e }; // From 0x04d3 to 0x04e8 (22 byte(s)) static const UINT8 sg_u8Region18[0x0016] = { 0x0e, 0x31, 0xc3, 0x80, 0x05, 0xef, 0x1c, 0x11, 0x0e, 0x12, 0xc3, 0x85, 0x05, 0x0e, 0x13, 0xcd, 0x85, 0x05, 0xcd, 0x79, 0x08, 0x35 }; // From 0x04ea to 0x04eb (2 byte(s)) // Region 0x04ea to 0x04eb (2 byte(s)) collapsed to 0x04ea to 0x04ea (1 byte(s)) static const UINT8 sg_u8Region19[0x0001] = { 0x11 }; // From 0x04ed to 0x04ee (2 byte(s)) static const UINT8 sg_u8Region20[0x0002] = { 0x05, 0x01 }; // From 0x04f0 to 0x04f1 (2 byte(s)) static const UINT8 sg_u8Region21[0x0002] = { 0x10, 0x14 }; // From 0x04f3 to 0x04f4 (2 byte(s)) static const UINT8 sg_u8Region22[0x0002] = { 0x04, 0x01 }; // From 0x054b to 0x057b (49 byte(s)) static const UINT8 sg_u8Region23[0x0031] = { 0x21, 0xa1, 0x4d, 0x06, 0x20, 0x3a, 0x32, 0x4d, 0xc3, 0x24, 0x05, 0x21, 0xa2, 0x4d, 0x06, 0x22, 0x3a, 0x32, 0x4d, 0xc3, 0x24, 0x05, 0x21, 0xa3, 0x4d, 0x06, 0x24, 0x3a, 0x32, 0x4d, 0xc3, 0x24, 0x05, 0x3a, 0xd0, 0x4d, 0x47, 0x3a, 0xd1, 0x4d, 0x80, 0xfe, 0x06, 0xca, 0x8e, 0x05, 0xc3, 0x2c, 0x05 }; // From 0x0580 to 0x0584 (5 byte(s)) static const UINT8 sg_u8Region24[0x0005] = { 0x3a, 0x75, 0x4e, 0x81, 0x4f }; // From 0x059e to 0x05a0 (3 byte(s)) // Region 0x059e to 0x05a0 (3 byte(s)) collapsed to 0x059e to 0x059f (2 byte(s)) static const UINT8 sg_u8Region25[0x0002] = { 0x45, 0x02 }; // From 0x05e9 to 0x05f2 (10 byte(s)) static const UINT8 sg_u8Region26[0x000a] = { 0xf3, 0x05, 0x1b, 0x06, 0x74, 0x06, 0x0c, 0x00, 0xa8, 0x06 }; // From 0x05f7 to 0x05f8 (2 byte(s)) // Region 0x05f7 to 0x05f8 (2 byte(s)) collapsed to 0x05f8 to 0x05f8 (1 byte(s)) static const UINT8 sg_u8Region27[0x0001] = { 0x01 }; // From 0x05fa to 0x05fb (2 byte(s)) // Region 0x05fa to 0x05fb (2 byte(s)) collapsed to 0x05fa to 0x05fa (1 byte(s)) static const UINT8 sg_u8Region28[0x0001] = { 0x01 }; // From 0x05fd to 0x05fe (2 byte(s)) static const UINT8 sg_u8Region29[0x0002] = { 0x1c, 0x07 }; // From 0x0600 to 0x0601 (2 byte(s)) static const UINT8 sg_u8Region30[0x0002] = { 0x1c, 0x0b }; // From 0x0603 to 0x0604 (2 byte(s)) // Region 0x0603 to 0x0604 (2 byte(s)) collapsed to 0x0603 to 0x0603 (1 byte(s)) static const UINT8 sg_u8Region31[0x0001] = { 0x1e }; // From 0x0615 to 0x0616 (2 byte(s)) static const UINT8 sg_u8Region32[0x0002] = { 0x1c, 0x0a }; // From 0x0618 to 0x0619 (2 byte(s)) // Region 0x0618 to 0x0619 (2 byte(s)) collapsed to 0x0618 to 0x0618 (1 byte(s)) static const UINT8 sg_u8Region33[0x0001] = { 0x1f }; // From 0x0675 to 0x0676 (2 byte(s)) // Region 0x0675 to 0x0676 (2 byte(s)) collapsed to 0x0676 to 0x0676 (1 byte(s)) static const UINT8 sg_u8Region34[0x0001] = { 0x01 }; // From 0x0678 to 0x0679 (2 byte(s)) static const UINT8 sg_u8Region35[0x0002] = { 0x01, 0x01 }; // From 0x067b to 0x067c (2 byte(s)) // Region 0x067b to 0x067c (2 byte(s)) collapsed to 0x067b to 0x067b (1 byte(s)) static const UINT8 sg_u8Region36[0x0001] = { 0x02 }; // From 0x067e to 0x067f (2 byte(s)) // Region 0x067e to 0x067f (2 byte(s)) collapsed to 0x067e to 0x067e (1 byte(s)) static const UINT8 sg_u8Region37[0x0001] = { 0x12 }; // From 0x0681 to 0x0682 (2 byte(s)) // Region 0x0681 to 0x0682 (2 byte(s)) collapsed to 0x0681 to 0x0681 (1 byte(s)) static const UINT8 sg_u8Region38[0x0001] = { 0x03 }; // From 0x0684 to 0x0685 (2 byte(s)) static const UINT8 sg_u8Region39[0x0002] = { 0x1c, 0x03 }; // From 0x0687 to 0x0688 (2 byte(s)) static const UINT8 sg_u8Region40[0x0002] = { 0x1c, 0x06 }; // From 0x068a to 0x068b (2 byte(s)) // Region 0x068a to 0x068b (2 byte(s)) collapsed to 0x068a to 0x068a (1 byte(s)) static const UINT8 sg_u8Region41[0x0001] = { 0x18 }; // From 0x068d to 0x068e (2 byte(s)) // Region 0x068d to 0x068e (2 byte(s)) collapsed to 0x068d to 0x068d (1 byte(s)) static const UINT8 sg_u8Region42[0x0001] = { 0x1b }; // From 0x069d to 0x069e (2 byte(s)) // Region 0x069d to 0x069e (2 byte(s)) collapsed to 0x069d to 0x069d (1 byte(s)) static const UINT8 sg_u8Region43[0x0001] = { 0x1a }; // From 0x06a0 to 0x06a2 (3 byte(s)) // Region 0x06a0 to 0x06a2 (3 byte(s)) collapsed to 0x06a0 to 0x06a1 (2 byte(s)) static const UINT8 sg_u8Region44[0x0002] = { 0x57, 0x01 }; // From 0x06c2 to 0x070d (76 byte(s)) static const UINT8 sg_u8Region45[0x004c] = { 0x79, 0x08, 0x99, 0x08, 0x0c, 0x00, 0xcd, 0x08, 0x0d, 0x09, 0x0c, 0x00, 0x40, 0x09, 0x0c, 0x00, 0x72, 0x09, 0x88, 0x09, 0x0c, 0x00, 0xd2, 0x09, 0xd8, 0x09, 0x0c, 0x00, 0xe8, 0x09, 0x0c, 0x00, 0xfe, 0x09, 0x0c, 0x00, 0x02, 0x0a, 0x0c, 0x00, 0x04, 0x0a, 0x0c, 0x00, 0x06, 0x0a, 0x0c, 0x00, 0x08, 0x0a, 0x0c, 0x00, 0x0a, 0x0a, 0x0c, 0x00, 0x0c, 0x0a, 0x0c, 0x00, 0x0e, 0x0a, 0x0c, 0x00, 0x2c, 0x0a, 0x0c, 0x00, 0x7c, 0x0a, 0xa0, 0x0a, 0x0c, 0x00, 0xa3, 0x0a }; // From 0x0796 to 0x0813 (126 byte(s)) static const UINT8 sg_u8Region46[0x007e] = { 0x03, 0x01, 0x01, 0x00, 0x02, 0x00, 0x04, 0x01, 0x02, 0x01, 0x03, 0x00, 0x04, 0x01, 0x03, 0x02, 0x04, 0x01, 0x04, 0x02, 0x03, 0x02, 0x05, 0x01, 0x05, 0x00, 0x03, 0x02, 0x06, 0x02, 0x05, 0x01, 0x03, 0x03, 0x03, 0x02, 0x05, 0x02, 0x03, 0x03, 0x06, 0x02, 0x05, 0x02, 0x03, 0x03, 0x06, 0x02, 0x05, 0x00, 0x03, 0x04, 0x07, 0x02, 0x05, 0x01, 0x03, 0x04, 0x03, 0x02, 0x05, 0x02, 0x03, 0x04, 0x06, 0x02, 0x05, 0x02, 0x03, 0x05, 0x07, 0x02, 0x05, 0x00, 0x03, 0x05, 0x07, 0x02, 0x05, 0x02, 0x03, 0x05, 0x05, 0x02, 0x05, 0x01, 0x03, 0x06, 0x07, 0x02, 0x05, 0x02, 0x03, 0x06, 0x07, 0x02, 0x05, 0x02, 0x03, 0x06, 0x08, 0x02, 0x05, 0x02, 0x03, 0x06, 0x07, 0x02, 0x05, 0x02, 0x03, 0x07, 0x08, 0x02, 0x05, 0x02, 0x03, 0x07, 0x08, 0x02, 0x06, 0x02, 0x03, 0x07, 0x08, 0x02 }; // From 0x0843 to 0x0878 (54 byte(s)) // Region 0x0843 to 0x0878 (54 byte(s)) collapsed to 0x0843 to 0x0877 (53 byte(s)) static const UINT8 sg_u8Region47[0x0035] = { 0x14, 0x1e, 0x46, 0x00, 0x1e, 0x3c, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00, 0x14, 0x0a, 0x1e, 0x0f, 0x28, 0x14, 0x32, 0x19, 0x3c, 0x1e, 0x50, 0x28, 0x64, 0x32, 0x78, 0x3c, 0x8c, 0x46, 0xc0, 0x03, 0x48, 0x03, 0xd0, 0x02, 0x58, 0x02, 0xe0, 0x01, 0x68, 0x01, 0xf0, 0x00, 0x78, 0x00, 0x01, 0x00, 0xf0, 0x00, 0xf0, 0x00, 0xb4 }; // From 0x08a6 to 0x08a7 (2 byte(s)) // Region 0x08a6 to 0x08a7 (2 byte(s)) collapsed to 0x08a6 to 0x08a6 (1 byte(s)) static const UINT8 sg_u8Region48[0x0001] = { 0x11 }; // From 0x08a9 to 0x08aa (2 byte(s)) static const UINT8 sg_u8Region49[0x0002] = { 0x1c, 0x83 }; // From 0x08ac to 0x08ad (2 byte(s)) // Region 0x08ac to 0x08ad (2 byte(s)) collapsed to 0x08ac to 0x08ac (1 byte(s)) static const UINT8 sg_u8Region50[0x0001] = { 0x04 }; // From 0x08af to 0x08b0 (2 byte(s)) // Region 0x08af to 0x08b0 (2 byte(s)) collapsed to 0x08af to 0x08af (1 byte(s)) static const UINT8 sg_u8Region51[0x0001] = { 0x05 }; // From 0x08b2 to 0x08b3 (2 byte(s)) // Region 0x08b2 to 0x08b3 (2 byte(s)) collapsed to 0x08b2 to 0x08b2 (1 byte(s)) static const UINT8 sg_u8Region52[0x0001] = { 0x10 }; // From 0x08b5 to 0x08b6 (2 byte(s)) // Region 0x08b5 to 0x08b6 (2 byte(s)) collapsed to 0x08b5 to 0x08b5 (1 byte(s)) static const UINT8 sg_u8Region53[0x0001] = { 0x1a }; // From 0x08b8 to 0x08ba (3 byte(s)) // Region 0x08b8 to 0x08ba (3 byte(s)) collapsed to 0x08b8 to 0x08b8 (1 byte(s)) static const UINT8 sg_u8Region54[0x0001] = { 0x54 }; // From 0x08bc to 0x08be (3 byte(s)) // Region 0x08bc to 0x08be (3 byte(s)) collapsed to 0x08bc to 0x08bd (2 byte(s)) static const UINT8 sg_u8Region55[0x0002] = { 0x54, 0x06 }; // From 0x08db to 0x08dc (2 byte(s)) // Region 0x08db to 0x08dc (2 byte(s)) collapsed to 0x08db to 0x08db (1 byte(s)) static const UINT8 sg_u8Region56[0x0001] = { 0x13 }; // From 0x08e4 to 0x08e4 (1 byte(s)) // Region 0x08e4 to 0x08e4 (1 byte(s)) collapsed to 0x08e5 to 0x08e4 (0 byte(s)) // Region eliminated due to all 0x00 data // From 0x0937 to 0x0938 (2 byte(s)) static const UINT8 sg_u8Region57[0x0002] = { 0x1c, 0x05 }; // From 0x093a to 0x093c (3 byte(s)) // Region 0x093a to 0x093c (3 byte(s)) collapsed to 0x093a to 0x093a (1 byte(s)) static const UINT8 sg_u8Region58[0x0001] = { 0x54 }; // From 0x0956 to 0x0957 (2 byte(s)) static const UINT8 sg_u8Region59[0x0002] = { 0x1c, 0x05 }; // From 0x0959 to 0x095b (3 byte(s)) // Region 0x0959 to 0x095b (3 byte(s)) collapsed to 0x0959 to 0x0959 (1 byte(s)) static const UINT8 sg_u8Region60[0x0001] = { 0x54 }; // From 0x0989 to 0x098a (2 byte(s)) // Region 0x0989 to 0x098a (2 byte(s)) collapsed to 0x098a to 0x098a (1 byte(s)) static const UINT8 sg_u8Region61[0x0001] = { 0x01 }; // From 0x098c to 0x098d (2 byte(s)) static const UINT8 sg_u8Region62[0x0002] = { 0x01, 0x01 }; // From 0x098f to 0x0990 (2 byte(s)) // Region 0x098f to 0x0990 (2 byte(s)) collapsed to 0x098f to 0x098f (1 byte(s)) static const UINT8 sg_u8Region63[0x0001] = { 0x02 }; // From 0x0992 to 0x0993 (2 byte(s)) // Region 0x0992 to 0x0993 (2 byte(s)) collapsed to 0x0992 to 0x0992 (1 byte(s)) static const UINT8 sg_u8Region64[0x0001] = { 0x11 }; // From 0x0995 to 0x0996 (2 byte(s)) // Region 0x0995 to 0x0996 (2 byte(s)) collapsed to 0x0995 to 0x0995 (1 byte(s)) static const UINT8 sg_u8Region65[0x0001] = { 0x13 }; // From 0x0998 to 0x0999 (2 byte(s)) // Region 0x0998 to 0x0999 (2 byte(s)) collapsed to 0x0998 to 0x0998 (1 byte(s)) static const UINT8 sg_u8Region66[0x0001] = { 0x03 }; // From 0x099b to 0x099c (2 byte(s)) // Region 0x099b to 0x099c (2 byte(s)) collapsed to 0x099b to 0x099b (1 byte(s)) static const UINT8 sg_u8Region67[0x0001] = { 0x04 }; // From 0x099e to 0x099f (2 byte(s)) // Region 0x099e to 0x099f (2 byte(s)) collapsed to 0x099e to 0x099e (1 byte(s)) static const UINT8 sg_u8Region68[0x0001] = { 0x05 }; // From 0x09a1 to 0x09a2 (2 byte(s)) // Region 0x09a1 to 0x09a2 (2 byte(s)) collapsed to 0x09a1 to 0x09a1 (1 byte(s)) static const UINT8 sg_u8Region69[0x0001] = { 0x10 }; // From 0x09a4 to 0x09a5 (2 byte(s)) // Region 0x09a4 to 0x09a5 (2 byte(s)) collapsed to 0x09a4 to 0x09a4 (1 byte(s)) static const UINT8 sg_u8Region70[0x0001] = { 0x1a }; // From 0x09a7 to 0x09a8 (2 byte(s)) static const UINT8 sg_u8Region71[0x0002] = { 0x1c, 0x06 }; // From 0x09b1 to 0x09b2 (2 byte(s)) static const UINT8 sg_u8Region72[0x0002] = { 0x1c, 0x05 }; // From 0x09b4 to 0x09b5 (2 byte(s)) // Region 0x09b4 to 0x09b5 (2 byte(s)) collapsed to 0x09b4 to 0x09b4 (1 byte(s)) static const UINT8 sg_u8Region73[0x0001] = { 0x1d }; // From 0x09b7 to 0x09b9 (3 byte(s)) // Region 0x09b7 to 0x09b9 (3 byte(s)) collapsed to 0x09b7 to 0x09b7 (1 byte(s)) static const UINT8 sg_u8Region74[0x0001] = { 0x54 }; // From 0x09c1 to 0x09c3 (3 byte(s)) // Region 0x09c1 to 0x09c3 (3 byte(s)) collapsed to 0x09c1 to 0x09c2 (2 byte(s)) static const UINT8 sg_u8Region75[0x0002] = { 0x54, 0x06 }; // From 0x09d9 to 0x09db (3 byte(s)) // Region 0x09d9 to 0x09db (3 byte(s)) collapsed to 0x09d9 to 0x09d9 (1 byte(s)) static const UINT8 sg_u8Region76[0x0001] = { 0x54 }; // From 0x09f0 to 0x09f2 (3 byte(s)) // Region 0x09f0 to 0x09f2 (3 byte(s)) collapsed to 0x09f0 to 0x09f0 (1 byte(s)) static const UINT8 sg_u8Region77[0x0001] = { 0x42 }; // From 0x0a0f to 0x0a10 (2 byte(s)) // Region 0x0a0f to 0x0a10 (2 byte(s)) collapsed to 0x0a10 to 0x0a10 (1 byte(s)) static const UINT8 sg_u8Region78[0x0001] = { 0x01 }; // From 0x0a12 to 0x0a13 (2 byte(s)) // Region 0x0a12 to 0x0a13 (2 byte(s)) collapsed to 0x0a12 to 0x0a12 (1 byte(s)) static const UINT8 sg_u8Region79[0x0001] = { 0x06 }; // From 0x0a15 to 0x0a16 (2 byte(s)) // Region 0x0a15 to 0x0a16 (2 byte(s)) collapsed to 0x0a15 to 0x0a15 (1 byte(s)) static const UINT8 sg_u8Region80[0x0001] = { 0x11 }; // From 0x0a18 to 0x0a19 (2 byte(s)) // Region 0x0a18 to 0x0a19 (2 byte(s)) collapsed to 0x0a18 to 0x0a18 (1 byte(s)) static const UINT8 sg_u8Region81[0x0001] = { 0x13 }; // From 0x0a1b to 0x0a1c (2 byte(s)) static const UINT8 sg_u8Region82[0x0002] = { 0x04, 0x01 }; // From 0x0a1e to 0x0a1f (2 byte(s)) static const UINT8 sg_u8Region83[0x0002] = { 0x05, 0x01 }; // From 0x0a21 to 0x0a22 (2 byte(s)) static const UINT8 sg_u8Region84[0x0002] = { 0x10, 0x13 }; // From 0x0a24 to 0x0a26 (3 byte(s)) // Region 0x0a24 to 0x0a26 (3 byte(s)) collapsed to 0x0a24 to 0x0a24 (1 byte(s)) static const UINT8 sg_u8Region85[0x0001] = { 0x43 }; // From 0x0a45 to 0x0a6e (42 byte(s)) static const UINT8 sg_u8Region86[0x002a] = { 0x6f, 0x0a, 0x08, 0x21, 0x6f, 0x0a, 0x6f, 0x0a, 0x9e, 0x21, 0x6f, 0x0a, 0x6f, 0x0a, 0x6f, 0x0a, 0x97, 0x22, 0x6f, 0x0a, 0x6f, 0x0a, 0x6f, 0x0a, 0x97, 0x22, 0x6f, 0x0a, 0x6f, 0x0a, 0x6f, 0x0a, 0x97, 0x22, 0x6f, 0x0a, 0x6f, 0x0a, 0x6f, 0x0a, 0x6f, 0x0a }; // From 0x0c24 to 0x0c32 (15 byte(s)) static const UINT8 sg_u8Region87[0x000f] = { 0x20, 0x02, 0x3e, 0x00, 0x77, 0x32, 0x78, 0x44, 0x32, 0x84, 0x47, 0x32, 0x98, 0x47, 0xc9 }; // From 0x0ef9 to 0x0efb (3 byte(s)) // Region 0x0ef9 to 0x0efb (3 byte(s)) collapsed to 0x0ef9 to 0x0efa (2 byte(s)) static const UINT8 sg_u8Region88[0x0002] = { 0x8a, 0x04 }; // From 0x0efd to 0x0fff (259 byte(s)) // Region 0x0efd to 0x0fff (259 byte(s)) collapsed to 0x0efe to 0x0fff (258 byte(s)) static const UINT8 sg_u8Region89[0x0102] = { 0x14, 0x06, 0x01, 0x0f, 0x07, 0x02, 0x15, 0x08, 0x02, 0x15, 0x08, 0x04, 0x14, 0x09, 0x04, 0x14, 0x09, 0x05, 0x17, 0x0a, 0x05, 0x17, 0x0a, 0x06, 0x09, 0x0b, 0x06, 0x09, 0x0b, 0x03, 0x16, 0x0c, 0x03, 0x16, 0x0c, 0x07, 0x16, 0x0d, 0x07, 0x16, 0x0d, 0x07, 0x16, 0x0d, 0x07, 0x16, 0x0d, 0x07, 0x16, 0x0d, 0x07, 0x16, 0x0d, 0x07, 0x16, 0x0d, 0x07, 0x16, 0x0d, 0x07, 0x16, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0xed, 0x0c, 0x14, 0x0a, 0x00, 0x08, 0x48, 0x36 }; // From 0x1005 to 0x100a (6 byte(s)) // Region 0x1005 to 0x100a (6 byte(s)) collapsed to 0x1007 to 0x100a (4 byte(s)) static const UINT8 sg_u8Region90[0x0004] = { 0x22, 0xd2, 0x4d, 0xc9 }; // From 0x100e to 0x1016 (9 byte(s)) static const UINT8 sg_u8Region91[0x0009] = { 0x3a, 0x00, 0x4e, 0x3d, 0xc8, 0xef, 0x1c, 0xa2, 0xc9 }; // From 0x1098 to 0x109d (6 byte(s)) static const UINT8 sg_u8Region92[0x0006] = { 0x0c, 0x00, 0xc0, 0x10, 0xd2, 0x10 }; // From 0x10a2 to 0x10a7 (6 byte(s)) static const UINT8 sg_u8Region93[0x0006] = { 0x0c, 0x00, 0x18, 0x11, 0x2a, 0x11 }; // From 0x10ac to 0x10b3 (8 byte(s)) static const UINT8 sg_u8Region94[0x0008] = { 0x0c, 0x00, 0x5c, 0x11, 0x6e, 0x11, 0x8f, 0x11 }; // From 0x10b8 to 0x10bf (8 byte(s)) static const UINT8 sg_u8Region95[0x0008] = { 0x0c, 0x00, 0xc9, 0x11, 0xdb, 0x11, 0xfc, 0x11 }; // From 0x1239 to 0x123e (6 byte(s)) static const UINT8 sg_u8Region96[0x0006] = { 0x3f, 0x12, 0x0c, 0x00, 0x3f, 0x12 }; // From 0x126f to 0x1271 (3 byte(s)) // Region 0x126f to 0x1271 (3 byte(s)) collapsed to 0x126f to 0x1270 (2 byte(s)) static const UINT8 sg_u8Region97[0x0002] = { 0x4a, 0x03 }; // From 0x1295 to 0x12b6 (34 byte(s)) static const UINT8 sg_u8Region98[0x0022] = { 0x0c, 0x00, 0xb7, 0x12, 0xb7, 0x12, 0xb7, 0x12, 0xb7, 0x12, 0xcb, 0x12, 0xf9, 0x12, 0x06, 0x13, 0x0e, 0x13, 0x16, 0x13, 0x1e, 0x13, 0x26, 0x13, 0x2e, 0x13, 0x36, 0x13, 0x3e, 0x13, 0x46, 0x13, 0x53, 0x13 }; // From 0x1514 to 0x151b (8 byte(s)) static const UINT8 sg_u8Region99[0x0008] = { 0x8c, 0x16, 0xb1, 0x16, 0xd6, 0x16, 0xf7, 0x16 }; // From 0x19b0 to 0x19b1 (2 byte(s)) static const UINT8 sg_u8Region100[0x0002] = { 0x20, 0x1b }; // From 0x19bd to 0x19c3 (7 byte(s)) static const UINT8 sg_u8Region101[0x0007] = { 0x1c, 0xcd, 0x42, 0x00, 0xcd, 0x04, 0x10 }; // From 0x19c5 to 0x19c7 (3 byte(s)) // Region 0x19c5 to 0x19c7 (3 byte(s)) collapsed to 0x19c5 to 0x19c6 (2 byte(s)) static const UINT8 sg_u8Region102[0x0002] = { 0x54, 0x05 }; // From 0x1a40 to 0x1a41 (2 byte(s)) // Region 0x1a40 to 0x1a41 (2 byte(s)) collapsed to 0x1a40 to 0x1a40 (1 byte(s)) static const UINT8 sg_u8Region103[0x0001] = { 0x17 }; // From 0x1c06 to 0x1c07 (2 byte(s)) // Region 0x1c06 to 0x1c07 (2 byte(s)) collapsed to 0x1c06 to 0x1c06 (1 byte(s)) static const UINT8 sg_u8Region104[0x0001] = { 0x0c }; // From 0x1c17 to 0x1c18 (2 byte(s)) // Region 0x1c17 to 0x1c18 (2 byte(s)) collapsed to 0x1c17 to 0x1c17 (1 byte(s)) static const UINT8 sg_u8Region105[0x0001] = { 0x08 }; // From 0x1cdd to 0x1cde (2 byte(s)) // Region 0x1cdd to 0x1cde (2 byte(s)) collapsed to 0x1cdd to 0x1cdd (1 byte(s)) static const UINT8 sg_u8Region106[0x0001] = { 0x0d }; // From 0x1cee to 0x1cef (2 byte(s)) // Region 0x1cee to 0x1cef (2 byte(s)) collapsed to 0x1cee to 0x1cee (1 byte(s)) static const UINT8 sg_u8Region107[0x0001] = { 0x09 }; // From 0x1db4 to 0x1db5 (2 byte(s)) // Region 0x1db4 to 0x1db5 (2 byte(s)) collapsed to 0x1db4 to 0x1db4 (1 byte(s)) static const UINT8 sg_u8Region108[0x0001] = { 0x0e }; // From 0x1dc5 to 0x1dc6 (2 byte(s)) // Region 0x1dc5 to 0x1dc6 (2 byte(s)) collapsed to 0x1dc5 to 0x1dc5 (1 byte(s)) static const UINT8 sg_u8Region109[0x0001] = { 0x0a }; // From 0x1e8b to 0x1e8c (2 byte(s)) // Region 0x1e8b to 0x1e8c (2 byte(s)) collapsed to 0x1e8b to 0x1e8b (1 byte(s)) static const UINT8 sg_u8Region110[0x0001] = { 0x0f }; // From 0x1e9c to 0x1e9d (2 byte(s)) // Region 0x1e9c to 0x1e9d (2 byte(s)) collapsed to 0x1e9c to 0x1e9c (1 byte(s)) static const UINT8 sg_u8Region111[0x0001] = { 0x0b }; // From 0x1f9a to 0x1f9a (1 byte(s)) static const UINT8 sg_u8Region112[0x0001] = { 0x21 }; // From 0x1fa9 to 0x1fff (87 byte(s)) // Region 0x1fa9 to 0x1fff (87 byte(s)) collapsed to 0x1ffe to 0x1fff (2 byte(s)) static const UINT8 sg_u8Region113[0x0002] = { 0x5d, 0xe1 }; // From 0x2063 to 0x2065 (3 byte(s)) // Region 0x2063 to 0x2065 (3 byte(s)) collapsed to 0x2064 to 0x2065 (2 byte(s)) static const UINT8 sg_u8Region114[0x0002] = { 0x02, 0xc9 }; // From 0x210c to 0x2119 (14 byte(s)) static const UINT8 sg_u8Region115[0x000e] = { 0x1a, 0x21, 0x40, 0x21, 0x4b, 0x21, 0x0c, 0x00, 0x70, 0x21, 0x7b, 0x21, 0x86, 0x21 }; // From 0x216a to 0x216c (3 byte(s)) // Region 0x216a to 0x216c (3 byte(s)) collapsed to 0x216a to 0x216b (2 byte(s)) static const UINT8 sg_u8Region116[0x0002] = { 0x45, 0x07 }; // From 0x2196 to 0x2198 (3 byte(s)) // Region 0x2196 to 0x2198 (3 byte(s)) collapsed to 0x2196 to 0x2196 (1 byte(s)) static const UINT8 sg_u8Region117[0x0001] = { 0x45 }; // From 0x21a6 to 0x21c3 (30 byte(s)) static const UINT8 sg_u8Region118[0x001e] = { 0xc2, 0x21, 0x0c, 0x00, 0xe1, 0x21, 0xf5, 0x21, 0x0c, 0x22, 0x1e, 0x22, 0x44, 0x22, 0x5d, 0x22, 0x0c, 0x00, 0x6a, 0x22, 0x0c, 0x00, 0x86, 0x22, 0x0c, 0x00, 0x8d, 0x22, 0x3e, 0x01 }; // From 0x21dc to 0x21de (3 byte(s)) // Region 0x21dc to 0x21de (3 byte(s)) collapsed to 0x21dc to 0x21dd (2 byte(s)) static const UINT8 sg_u8Region119[0x0002] = { 0x43, 0x08 }; // From 0x2265 to 0x2267 (3 byte(s)) // Region 0x2265 to 0x2267 (3 byte(s)) collapsed to 0x2265 to 0x2266 (2 byte(s)) static const UINT8 sg_u8Region120[0x0002] = { 0x4f, 0x08 }; // From 0x2280 to 0x2282 (3 byte(s)) // Region 0x2280 to 0x2282 (3 byte(s)) collapsed to 0x2280 to 0x2281 (2 byte(s)) static const UINT8 sg_u8Region121[0x0002] = { 0x4a, 0x08 }; // From 0x2287 to 0x2289 (3 byte(s)) // Region 0x2287 to 0x2289 (3 byte(s)) collapsed to 0x2287 to 0x2288 (2 byte(s)) static const UINT8 sg_u8Region122[0x0002] = { 0x54, 0x08 }; // From 0x229d to 0x22b8 (28 byte(s)) static const UINT8 sg_u8Region123[0x001c] = { 0xbe, 0x22, 0x0c, 0x00, 0xdd, 0x22, 0xf5, 0x22, 0xfe, 0x22, 0x3a, 0x3a, 0x4d, 0xd6, 0x25, 0xc2, 0x30, 0x21, 0x3c, 0x32, 0xa0, 0x4d, 0x32, 0xb7, 0x4d, 0xcd, 0x06, 0x05 }; // From 0x22d8 to 0x22da (3 byte(s)) // Region 0x22d8 to 0x22da (3 byte(s)) collapsed to 0x22d8 to 0x22d9 (2 byte(s)) static const UINT8 sg_u8Region124[0x0002] = { 0x4a, 0x09 }; // From 0x2303 to 0x2305 (3 byte(s)) // Region 0x2303 to 0x2305 (3 byte(s)) collapsed to 0x2303 to 0x2303 (1 byte(s)) static const UINT8 sg_u8Region125[0x0001] = { 0x45 }; // From 0x23a8 to 0x23e7 (64 byte(s)) static const UINT8 sg_u8Region126[0x0040] = { 0xed, 0x23, 0xd7, 0x24, 0x19, 0x24, 0x48, 0x24, 0x3d, 0x25, 0x8b, 0x26, 0x0d, 0x24, 0x98, 0x26, 0x30, 0x27, 0x6c, 0x27, 0xa9, 0x27, 0xf1, 0x27, 0x3b, 0x28, 0x65, 0x28, 0x8f, 0x28, 0xb9, 0x28, 0x0d, 0x00, 0xa2, 0x26, 0xc9, 0x24, 0x35, 0x2a, 0xd0, 0x26, 0x87, 0x24, 0xe8, 0x23, 0xe3, 0x28, 0xe0, 0x2a, 0x5a, 0x2a, 0x6a, 0x2b, 0xea, 0x2b, 0xe3, 0x95, 0xa1, 0x2b, 0x75, 0x26, 0xb2, 0x26 }; // From 0x23ef to 0x23f2 (4 byte(s)) static const UINT8 sg_u8Region127[0x0004] = { 0xf3, 0x23, 0x00, 0x24 }; // From 0x24b7 to 0x24c8 (18 byte(s)) static const UINT8 sg_u8Region128[0x0012] = { 0xed, 0xa0, 0x21, 0x78, 0x40, 0xed, 0xa0, 0x21, 0x84, 0x43, 0xed, 0xa0, 0x21, 0x98, 0x43, 0xed, 0xa0, 0xc9 }; // From 0x24e0 to 0x24e0 (1 byte(s)) static const UINT8 sg_u8Region129[0x0001] = { 0x10 }; // From 0x24fc to 0x2533 (56 byte(s)) static const UINT8 sg_u8Region130[0x0038] = { 0x06, 0x06, 0xdd, 0x21, 0xa0, 0x45, 0xdd, 0x77, 0x0c, 0xdd, 0x77, 0x18, 0xdd, 0x19, 0x10, 0xf6, 0x3e, 0x1b, 0x06, 0x05, 0xdd, 0x21, 0x40, 0x44, 0xdd, 0x77, 0x0e, 0xdd, 0x77, 0x0f, 0xdd, 0x77, 0x10, 0xdd, 0x19, 0x10, 0xf3, 0x06, 0x05, 0xdd, 0x21, 0x20, 0x47, 0xdd, 0x77, 0x0e, 0xdd, 0x77, 0x0f, 0xdd, 0x77, 0x10, 0xdd, 0x19, 0x10, 0xf3 }; // From 0x2728 to 0x272f (8 byte(s)) // Region 0x2728 to 0x272f (8 byte(s)) collapsed to 0x2728 to 0x272e (7 byte(s)) static const UINT8 sg_u8Region131[0x0007] = { 0x10, 0x15, 0x20, 0xff, 0x68, 0x00, 0x7d }; // From 0x2b17 to 0x2b32 (28 byte(s)) static const UINT8 sg_u8Region132[0x001c] = { 0x10, 0x00, 0x50, 0x00, 0x00, 0x02, 0x00, 0x04, 0x00, 0x08, 0x00, 0x16, 0x00, 0x01, 0x00, 0x02, 0x00, 0x05, 0x00, 0x07, 0x00, 0x10, 0x00, 0x20, 0x00, 0x50, 0x00, 0x50 }; // From 0x2bf7 to 0x2bf8 (2 byte(s)) static const UINT8 sg_u8Region133[0x0002] = { 0x2e, 0x2c }; // From 0x2c2e to 0x2c5d (48 byte(s)) static const UINT8 sg_u8Region134[0x0030] = { 0xfe, 0x13, 0x38, 0x02, 0x3e, 0x13, 0xd6, 0x07, 0x4f, 0x06, 0x00, 0x21, 0x08, 0x3b, 0x09, 0x09, 0xeb, 0x06, 0x07, 0xc3, 0xfd, 0x2b, 0x47, 0xe6, 0x0f, 0xc6, 0x00, 0x27, 0x4f, 0x78, 0xe6, 0xf0, 0x28, 0x0b, 0x0f, 0x0f, 0x0f, 0x0f, 0x47, 0xaf, 0xc6, 0x16, 0x27, 0x10, 0xfb, 0x81, 0x27, 0xc9 }; // From 0x2d65 to 0x2d65 (1 byte(s)) static const UINT8 sg_u8Region135[0x0001] = { 0x0c }; // From 0x2d85 to 0x2da4 (32 byte(s)) static const UINT8 sg_u8Region136[0x0020] = { 0x55, 0x2f, 0x65, 0x2f, 0x77, 0x2f, 0x89, 0x2f, 0x9b, 0x2f, 0x0c, 0x00, 0x0c, 0x00, 0x0c, 0x00, 0x0c, 0x00, 0x0c, 0x00, 0x0c, 0x00, 0x0c, 0x00, 0x0c, 0x00, 0x0c, 0x00, 0x0c, 0x00, 0xad, 0x2f }; // From 0x2f02 to 0x2f21 (32 byte(s)) static const UINT8 sg_u8Region137[0x0020] = { 0x22, 0x2f, 0x26, 0x2f, 0x2b, 0x2f, 0x3c, 0x2f, 0x43, 0x2f, 0x4a, 0x2f, 0x4b, 0x2f, 0x4c, 0x2f, 0x4d, 0x2f, 0x4e, 0x2f, 0x4f, 0x2f, 0x50, 0x2f, 0x51, 0x2f, 0x52, 0x2f, 0x53, 0x2f, 0x54, 0x2f }; // From 0x2fba to 0x2ffd (68 byte(s)) // Region 0x2fba to 0x2ffd (68 byte(s)) collapsed to 0x2ffe to 0x2ffd (0 byte(s)) // Region eliminated due to all 0x00 data // From 0x3031 to 0x3041 (17 byte(s)) static const UINT8 sg_u8Region138[0x0011] = { 0x25, 0x7c, 0xe6, 0xf0, 0x32, 0x07, 0x50, 0x0f, 0x0f, 0x0f, 0x0f, 0x5f, 0x06, 0x00, 0xc3, 0xbd, 0x30 }; // From 0x3154 to 0x3173 (32 byte(s)) // Region 0x3154 to 0x3173 (32 byte(s)) collapsed to 0x3155 to 0x3173 (31 byte(s)) static const UINT8 sg_u8Region139[0x001f] = { 0x4c, 0x0f, 0x04, 0x00, 0x4c, 0xf0, 0x04, 0x00, 0x40, 0x0f, 0x04, 0x00, 0x40, 0xf0, 0x04, 0x00, 0x44, 0x0f, 0x04, 0x00, 0x44, 0xf0, 0x04, 0x4f, 0x40, 0x41, 0x57, 0x41, 0x56, 0x41, 0x43 }; // From 0x32f9 to 0x3434 (316 byte(s)) static const UINT8 sg_u8Region140[0x013c] = { 0x30, 0x31, 0x35, 0x31, 0x30, 0x32, 0x00, 0xff, 0x01, 0x00, 0x00, 0x01, 0xff, 0x00, 0x00, 0xff, 0x01, 0x00, 0x00, 0x01, 0xff, 0x00, 0x55, 0x2a, 0x55, 0x2a, 0x55, 0x55, 0x55, 0x55, 0x55, 0x2a, 0x55, 0x2a, 0x52, 0x4a, 0xa5, 0x94, 0x25, 0x25, 0x25, 0x25, 0x22, 0x22, 0x22, 0x22, 0x01, 0x01, 0x01, 0x01, 0x58, 0x02, 0x08, 0x07, 0x60, 0x09, 0x10, 0x0e, 0x68, 0x10, 0x70, 0x17, 0x14, 0x19, 0x52, 0x4a, 0xa5, 0x94, 0xaa, 0x2a, 0x55, 0x55, 0x55, 0x2a, 0x55, 0x2a, 0x52, 0x4a, 0xa5, 0x94, 0x92, 0x24, 0x25, 0x49, 0x48, 0x24, 0x22, 0x91, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x55, 0x2a, 0x55, 0x2a, 0x55, 0x55, 0x55, 0x55, 0xaa, 0x2a, 0x55, 0x55, 0x55, 0x2a, 0x55, 0x2a, 0x52, 0x4a, 0xa5, 0x94, 0x48, 0x24, 0x22, 0x91, 0x21, 0x44, 0x44, 0x08, 0x58, 0x02, 0x34, 0x08, 0xd8, 0x09, 0xb4, 0x0f, 0x58, 0x11, 0x08, 0x16, 0x34, 0x17, 0x55, 0x55, 0x55, 0x55, 0xd5, 0x6a, 0xd5, 0x6a, 0xaa, 0x6a, 0x55, 0xd5, 0x55, 0x55, 0x55, 0x55, 0xaa, 0x2a, 0x55, 0x55, 0x92, 0x24, 0x92, 0x24, 0x22, 0x22, 0x22, 0x22, 0xa4, 0x01, 0x54, 0x06, 0xf8, 0x07, 0xa8, 0x0c, 0xd4, 0x0d, 0x84, 0x12, 0xb0, 0x13, 0xd5, 0x6a, 0xd5, 0x6a, 0xd6, 0x5a, 0xad, 0xb5, 0xd6, 0x5a, 0xad, 0xb5, 0xd5, 0x6a, 0xd5, 0x6a, 0xaa, 0x6a, 0x55, 0xd5, 0x92, 0x24, 0x25, 0x49, 0x48, 0x24, 0x22, 0x91, 0xa4, 0x01, 0x54, 0x06, 0xf8, 0x07, 0xa8, 0x0c, 0xd4, 0x0d, 0xfe, 0xff, 0xff, 0xff, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0xb6, 0x6d, 0x6d, 0xdb, 0x6d, 0x6d, 0x6d, 0x6d, 0xd6, 0x5a, 0xad, 0xb5, 0x25, 0x25, 0x25, 0x25, 0x92, 0x24, 0x92, 0x24, 0x2c, 0x01, 0xdc, 0x05, 0x08, 0x07, 0xb8, 0x0b, 0xe4, 0x0c, 0xfe, 0xff, 0xff, 0xff, 0xd5, 0x6a, 0xd5, 0x6a, 0xd5, 0x6a, 0xd5, 0x6a, 0xb6, 0x6d, 0x6d, 0xdb, 0x6d, 0x6d, 0x6d, 0x6d, 0xd6, 0x5a, 0xad, 0xb5, 0x48, 0x24, 0x22, 0x91, 0x92, 0x24, 0x92, 0x24, 0x2c, 0x01, 0xdc, 0x05, 0x08, 0x07, 0xb8, 0x0b, 0xe4, 0x0c, 0xfe, 0xff, 0xff, 0xff }; // From 0x343e to 0x343f (2 byte(s)) static const UINT8 sg_u8Region141[0x0002] = { 0x1c, 0x32 }; // From 0x3458 to 0x3459 (2 byte(s)) static const UINT8 sg_u8Region142[0x0002] = { 0x1c, 0x17 }; // From 0x3472 to 0x3473 (2 byte(s)) static const UINT8 sg_u8Region143[0x0002] = { 0x1c, 0x15 }; // From 0x35f5 to 0x35f6 (2 byte(s)) static const UINT8 sg_u8Region144[0x0002] = { 0x1c, 0x30 }; // From 0x3696 to 0x3af3 (1118 byte(s)) static const UINT8 sg_u8Region145[0x045e] = { 0x03, 0x04, 0x01, 0x02, 0x01, 0x01, 0x01, 0x01, 0x0c, 0x01, 0x01, 0x04, 0x01, 0x01, 0x01, 0x13, 0x37, 0x23, 0x37, 0x32, 0x37, 0x41, 0x37, 0x5a, 0x37, 0x6a, 0x37, 0x7a, 0x37, 0x86, 0x37, 0x9d, 0x37, 0xb1, 0x37, 0x21, 0x3d, 0x00, 0x3d, 0xfd, 0x37, 0x67, 0x3d, 0xe3, 0x3d, 0x86, 0x3d, 0x02, 0x3e, 0x4c, 0x38, 0x5a, 0x38, 0x3c, 0x3d, 0x57, 0x3d, 0xd3, 0x3d, 0x76, 0x3d, 0xf2, 0x3d, 0x01, 0x00, 0x02, 0x00, 0x03, 0x00, 0xbc, 0x38, 0xc4, 0x38, 0xce, 0x38, 0xd8, 0x38, 0xe2, 0x38, 0xec, 0x38, 0xf6, 0x38, 0x00, 0x39, 0x0a, 0x39, 0x1a, 0x39, 0x6f, 0x39, 0x2a, 0x39, 0x58, 0x39, 0x41, 0x39, 0x11, 0x3e, 0x86, 0x39, 0x97, 0x39, 0xb0, 0x39, 0xbd, 0x39, 0xca, 0x39, 0xa5, 0x3d, 0x21, 0x3e, 0xc6, 0x3d, 0x40, 0x3e, 0x95, 0x3d, 0x11, 0x3e, 0xb4, 0x3d, 0x30, 0x3e, 0xd4, 0x83, 0x48, 0x49, 0x47, 0x48, 0x40, 0x53, 0x43, 0x4f, 0x52, 0x45, 0x2f, 0x8f, 0x2f, 0x80, 0x3b, 0x80, 0x43, 0x52, 0x45, 0x44, 0x49, 0x54, 0x40, 0x40, 0x40, 0x2f, 0x8f, 0x2f, 0x80, 0x3b, 0x80, 0x46, 0x52, 0x45, 0x45, 0x40, 0x50, 0x4c, 0x41, 0x59, 0x2f, 0x8f, 0x2f, 0x80, 0x8c, 0x02, 0x50, 0x4c, 0x41, 0x59, 0x45, 0x52, 0x40, 0x4f, 0x4e, 0x45, 0x2f, 0x85, 0x2f, 0x10, 0x10, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x10, 0x10, 0x8c, 0x02, 0x50, 0x4c, 0x41, 0x59, 0x45, 0x52, 0x40, 0x54, 0x57, 0x4f, 0x2f, 0x85, 0x2f, 0x80, 0x92, 0x02, 0x47, 0x41, 0x4d, 0x45, 0x40, 0x40, 0x4f, 0x56, 0x45, 0x52, 0x2f, 0x81, 0x2f, 0x80, 0x52, 0x02, 0x52, 0x45, 0x41, 0x44, 0x59, 0x5b, 0x2f, 0x89, 0x2f, 0x90, 0xed, 0x02, 0x50, 0x55, 0x53, 0x48, 0x40, 0x53, 0x54, 0x41, 0x52, 0x54, 0x40, 0x42, 0x55, 0x54, 0x54, 0x4f, 0x4e, 0x2f, 0x87, 0x2f, 0x80, 0xaf, 0x02, 0x31, 0x40, 0x50, 0x4c, 0x41, 0x59, 0x45, 0x52, 0x40, 0x4f, 0x4e, 0x4c, 0x59, 0x40, 0x2f, 0x87, 0x2f, 0x80, 0xaf, 0x02, 0x31, 0x40, 0x4f, 0x52, 0x40, 0x32, 0x40, 0x50, 0x4c, 0x41, 0x59, 0x45, 0x52, 0x53, 0x2f, 0x87, 0x00, 0x2f, 0x00, 0x80, 0x00, 0x96, 0x03, 0x42, 0x4f, 0x4e, 0x55, 0x53, 0x40, 0x50, 0x55, 0x43, 0x4b, 0x4d, 0x41, 0x4e, 0x40, 0x46, 0x4f, 0x52, 0x40, 0x40, 0x40, 0x30, 0x30, 0x30, 0x40, 0x5d, 0x5e, 0x5f, 0x2f, 0x8e, 0x2f, 0x80, 0xba, 0x02, 0x5c, 0x40, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x40, 0x31, 0x39, 0x38, 0x30, 0x2f, 0x83, 0x2f, 0x80, 0x65, 0x03, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x26, 0x4d, 0x53, 0x40, 0x50, 0x41, 0x43, 0x3b, 0x4d, 0x41, 0x4e, 0x27, 0x40, 0x2f, 0x87, 0x2f, 0x80, 0x01, 0x26, 0x41, 0x4b, 0x41, 0x42, 0x45, 0x49, 0x26, 0x2f, 0x81, 0x2f, 0x80, 0x45, 0x01, 0x26, 0x4d, 0x41, 0x43, 0x4b, 0x59, 0x26, 0x2f, 0x81, 0x2f, 0x80, 0x48, 0x01, 0x26, 0x50, 0x49, 0x4e, 0x4b, 0x59, 0x26, 0x2f, 0x83, 0x2f, 0x80, 0x48, 0x01, 0x26, 0x4d, 0x49, 0x43, 0x4b, 0x59, 0x26, 0x2f, 0x83, 0x2f, 0x80, 0x76, 0x02, 0x10, 0x40, 0x31, 0x30, 0x40, 0x5d, 0x5e, 0x5f, 0x2f, 0x9f, 0x2f, 0x80, 0x78, 0x02, 0x14, 0x40, 0x35, 0x30, 0x40, 0x5d, 0x5e, 0x5f, 0x2f, 0x9f, 0x2f, 0x80, 0x5d, 0x02, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x83, 0x2f, 0x80, 0xc5, 0x02, 0x40, 0x4f, 0x49, 0x4b, 0x41, 0x4b, 0x45, 0x3b, 0x3b, 0x3b, 0x3b, 0x2f, 0x81, 0x2f, 0x80, 0xc5, 0x02, 0x40, 0x55, 0x52, 0x43, 0x48, 0x49, 0x4e, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x2f, 0x81, 0x2f, 0x80, 0xc8, 0x02, 0x40, 0x4d, 0x41, 0x43, 0x48, 0x49, 0x42, 0x55, 0x53, 0x45, 0x3b, 0x3b, 0x2f, 0x83, 0x2f, 0x80, 0xc8, 0x02, 0x40, 0x52, 0x4f, 0x4d, 0x50, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x2f, 0x83, 0x2f, 0x80, 0x25, 0x80, 0x81, 0x85, 0x2f, 0x81, 0x2f, 0x90, 0x6e, 0x02, 0x53, 0x55, 0x50, 0x45, 0x52, 0x40, 0x50, 0x41, 0x43, 0x3b, 0x4d, 0x41, 0x4e, 0x2f, 0x89, 0x2f, 0x80, 0x4d, 0x41, 0x4e, 0x2f, 0x89, 0x2f, 0x80, 0x2f, 0x90, 0x00, 0x00, 0x2e, 0x80, 0x86, 0x8b, 0x8d, 0x8e, 0x2f, 0x8f, 0x2f, 0x90, 0x30, 0x80, 0x40, 0x40, 0x40, 0x40, 0x2f, 0x94, 0x2f, 0x90, 0x32, 0x80, 0x89, 0x8a, 0x8d, 0x8e, 0x2f, 0x89, 0x2f, 0x90, 0x34, 0x80, 0x89, 0x8a, 0x8d, 0x8e, 0x2f, 0x89, 0x2f, 0x90, 0x04, 0x03, 0x4d, 0x45, 0x4d, 0x4f, 0x52, 0x59, 0x40, 0x40, 0x4f, 0x4b, 0x2f, 0x8f, 0x2f, 0x80, 0x04, 0x03, 0x42, 0x41, 0x44, 0x40, 0x40, 0x40, 0x40, 0x52, 0x40, 0x4d, 0x2f, 0x8f, 0x2f, 0x80, 0x08, 0x03, 0x31, 0x40, 0x43, 0x4f, 0x49, 0x4e, 0x40, 0x40, 0x31, 0x40, 0x43, 0x52, 0x45, 0x44, 0x49, 0x54, 0x40, 0x2f, 0x8f, 0x2f, 0x80, 0x08, 0x03, 0x32, 0x40, 0x43, 0x4f, 0x49, 0x4e, 0x53, 0x40, 0x31, 0x40, 0x43, 0x52, 0x45, 0x44, 0x49, 0x54, 0x40, 0x2f, 0x8f, 0x2f, 0x80, 0x08, 0x03, 0x31, 0x40, 0x43, 0x4f, 0x49, 0x4e, 0x40, 0x40, 0x32, 0x40, 0x43, 0x52, 0x45, 0x44, 0x49, 0x54, 0x53, 0x2f, 0x8f, 0x2f, 0x80, 0x08, 0x03, 0x46, 0x52, 0x45, 0x45, 0x40, 0x40, 0x50, 0x4c, 0x41, 0x59, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x2f, 0x8f, 0x2f, 0x80, 0x0a, 0x03, 0x42, 0x4f, 0x4e, 0x55, 0x53, 0x40, 0x40, 0x4e, 0x4f, 0x4e, 0x45, 0x2f, 0x8f, 0x2f, 0x80, 0x0a, 0x03, 0x42, 0x4f, 0x4e, 0x55, 0x53, 0x40, 0x2f, 0x8f, 0x2f, 0x80, 0x0c, 0x03, 0x50, 0x55, 0x43, 0x4b, 0x4d, 0x41, 0x4e, 0x2f, 0x8f, 0x2f, 0x80, 0x0e, 0x03, 0x54, 0x41, 0x42, 0x4c, 0x45, 0x40, 0x40, 0x2f, 0x8f, 0x2f, 0x80, 0x0e, 0x03, 0x55, 0x50, 0x52, 0x49, 0x47, 0x48, 0x54, 0x2f, 0x8f, 0x2f, 0x80, 0x0a, 0x02, 0x30, 0x30, 0x30, 0x2f, 0x8f, 0x2f, 0x80, 0x6b, 0x01, 0x26, 0x41, 0x4f, 0x53, 0x55, 0x4b, 0x45, 0x26, 0x2f, 0x85, 0x2f, 0x3d, 0x4f, 0x21, 0x00, 0x4d, 0xd7, 0xeb, 0x79, 0x21, 0xf2, 0x39, 0xd7, 0x12, 0x23, 0x13, 0x7e, 0x12, 0xc9, 0x2a, 0xda, 0x42, 0xda, 0x5a, 0xda, 0x72, 0xda, 0xef, 0x05, 0x01, 0xef, 0x10, 0x14, 0x3e, 0x01, 0x32, 0x14, 0x4e, 0xc9, 0x87, 0x2f, 0x80, 0xcb, 0x02, 0x40, 0x4b, 0x49, 0x4d, 0x41, 0x47, 0x55, 0x52, 0x45, 0x3b, 0x3b, 0x2f, 0x85, 0x2f, 0x80, 0xcb, 0x02, 0x40, 0x53, 0x54, 0x59, 0x4c, 0x49, 0x53, 0x54, 0x3b, 0x3b, 0x3b, 0x3b, 0x2f, 0x85, 0x2f, 0x80, 0xce, 0x02, 0x40, 0x4f, 0x54, 0x4f, 0x42, 0x4f, 0x4b, 0x45, 0x3b, 0x3b, 0x3b, 0x2f, 0x87, 0x2f, 0x80, 0xce, 0x02, 0x40, 0x43, 0x52, 0x59, 0x42, 0x41, 0x42, 0x59, 0x3b, 0x3b, 0x3b, 0x3b, 0x2f, 0x87, 0x2f, 0x80, 0x01, 0x01, 0x03, 0x01, 0x01, 0x01, 0x03, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x02, 0x04, 0x04, 0x04, 0x06, 0x02, 0x02, 0x02, 0x02, 0x04, 0x02, 0x04, 0x04, 0x04, 0x06, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x02, 0x04, 0x04, 0x04, 0x06, 0x02, 0x02, 0x02, 0x02, 0x06, 0x04, 0x05, 0x01, 0x01, 0x03, 0x01, 0x01, 0x01, 0x04, 0x01, 0x01, 0x01, 0x03, 0x01, 0x01, 0x04, 0x01, 0x01, 0x01, 0x6c, 0x05, 0x01, 0x01, 0x01, 0x18, 0x04, 0x04, 0x18, 0x05, 0x01, 0x01, 0x01, 0x17, 0x02, 0x03, 0x04, 0x16, 0x04, 0x03, 0x01, 0x01, 0x01, 0x76, 0x01, 0x01, 0x01, 0x01, 0x03, 0x01, 0x01, 0x01, 0x02, 0x04, 0x02, 0x04, 0x0e, 0x02, 0x04, 0x02, 0x04, 0x02, 0x04, 0x0b, 0x01, 0x01, 0x01, 0x02, 0x04, 0x02, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x0e, 0x02, 0x04, 0x02, 0x04, 0x02, 0x01, 0x02, 0x01, 0x0a, 0x01, 0x01, 0x01, 0x01, 0x03, 0x01, 0x01, 0x01, 0x03, 0x01, 0x01, 0x03, 0x04, 0x00, 0x02, 0x40, 0x01, 0x3e, 0x3d, 0x10, 0x40, 0x40, 0x0e, 0x3d, 0x3e, 0x10, 0xc2, 0x43, 0x01, 0x3e, 0x3d, 0x10 }; // From 0x3b08 to 0x3e5b (852 byte(s)) static const UINT8 sg_u8Region146[0x0354] = { 0x90, 0x14, 0x94, 0x0f, 0x98, 0x15, 0x9c, 0x07, 0xa0, 0x14, 0xa4, 0x17, 0xa8, 0x16, 0xac, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x9c, 0x16, 0x9c, 0x16, 0x9c, 0x16, 0x73, 0x20, 0x00, 0x0c, 0x00, 0x0a, 0x1f, 0x00, 0x72, 0x20, 0xfb, 0x87, 0x00, 0x02, 0x0f, 0x00, 0x59, 0x01, 0x06, 0x08, 0x00, 0x00, 0x02, 0x00, 0x59, 0x01, 0x06, 0x09, 0x00, 0x00, 0x02, 0x00, 0x59, 0x02, 0x06, 0x0a, 0x00, 0x00, 0x02, 0x00, 0x59, 0x03, 0x06, 0x0b, 0x00, 0x00, 0x02, 0x00, 0x59, 0x04, 0x06, 0x0c, 0x00, 0x06, 0x02, 0x00, 0x24, 0x00, 0x06, 0x08, 0x02, 0x00, 0x0a, 0x00, 0x36, 0x07, 0x87, 0x6f, 0x00, 0x00, 0x04, 0x00, 0x70, 0x04, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x1c, 0x70, 0x8b, 0x08, 0x00, 0x01, 0x06, 0x00, 0x1c, 0x70, 0x8b, 0x08, 0x00, 0x01, 0x06, 0x00, 0x56, 0x0c, 0xff, 0x8c, 0x00, 0x02, 0x08, 0x00, 0x56, 0x00, 0x02, 0x0a, 0x07, 0x03, 0x0c, 0x00, 0x36, 0x38, 0xfe, 0x12, 0xf8, 0x04, 0x0f, 0xfc, 0x22, 0x01, 0x01, 0x06, 0x00, 0x01, 0x07, 0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x00, 0x57, 0x5c, 0x61, 0x67, 0x6d, 0x74, 0x7b, 0x82, 0x8a, 0x92, 0x9a, 0xa3, 0xad, 0xb8, 0xc3, 0xd4, 0x3b, 0xf3, 0x3b, 0x58, 0x3c, 0x95, 0x3c, 0xde, 0x3c, 0xdf, 0x3c, 0xf1, 0x03, 0xf2, 0x03, 0xf3, 0x0a, 0xf4, 0x02, 0x90, 0x7c, 0x7b, 0x7a, 0x79, 0x79, 0x78, 0x97, 0x76, 0x75, 0x74, 0x73, 0x73, 0x72, 0x91, 0xa8, 0x88, 0x60, 0x4a, 0x4c, 0x91, 0x95, 0x88, 0x95, 0x91, 0x95, 0x88, 0x95, 0x91, 0x95, 0x88, 0x95, 0x95, 0x98, 0x94, 0x97, 0x93, 0x96, 0x88, 0x96, 0x93, 0x96, 0x88, 0x96, 0x93, 0x96, 0x88, 0x96, 0xb6, 0xb3, 0x75, 0x76, 0x77, 0x78, 0x78, 0x75, 0x73, 0x68, 0x91, 0x95, 0x88, 0x95, 0x91, 0x95, 0x88, 0x95, 0x86, 0x96, 0x95, 0x92, 0x93, 0x8c, 0x8a, 0x88, 0x86, 0x90, 0x90, 0x96, 0x95, 0x90, 0x90, 0x86, 0x90, 0x96, 0x90, 0x96, 0x91, 0x88, 0x81, 0xff, 0x47, 0x30, 0x4b, 0x10, 0x4c, 0x10, 0x4d, 0x10, 0x4e, 0x10, 0x77, 0x20, 0x4e, 0x10, 0x4d, 0x10, 0x4c, 0x10, 0x4a, 0x10, 0x47, 0x10, 0x46, 0x10, 0x65, 0x30, 0x66, 0x30, 0x67, 0x40, 0x70, 0xf0, 0xfb, 0x3b, 0xf1, 0x00, 0xf2, 0x02, 0xf3, 0x0a, 0xf4, 0x00, 0x88, 0x6c, 0x71, 0x72, 0x73, 0x73, 0x71, 0x93, 0x6c, 0x73, 0x75, 0x76, 0x76, 0x75, 0x96, 0x7c, 0x7a, 0x78, 0x76, 0x75, 0x96, 0x6c, 0x91, 0xa0, 0x88, 0x75, 0x76, 0x77, 0x78, 0x71, 0x73, 0x74, 0x75, 0x71, 0x75, 0x71, 0x68, 0x68, 0x65, 0x66, 0x67, 0xa8, 0xab, 0xac, 0x8c, 0x86, 0x76, 0x75, 0x6c, 0x71, 0x75, 0x73, 0x6b, 0x6c, 0x73, 0x76, 0x7a, 0x78, 0x78, 0x76, 0x73, 0x6c, 0xaa, 0xa8, 0x71, 0x73, 0x74, 0x75, 0x6a, 0x6b, 0x6c, 0x73, 0x75, 0x76, 0x77, 0x78, 0x71, 0x73, 0x74, 0x75, 0x71, 0x75, 0x71, 0x68, 0x48, 0x40, 0x68, 0x67, 0x68, 0xaa, 0xa9, 0xaa, 0x6a, 0x60, 0x8a, 0x76, 0x75, 0x73, 0x71, 0x71, 0x73, 0x95, 0x75, 0x73, 0x71, 0x68, 0x68, 0x61, 0x63, 0x6a, 0xa8, 0x6c, 0x76, 0x6a, 0x6c, 0x91, 0x90, 0x91, 0xff, 0x40, 0x26, 0x87, 0x70, 0xf0, 0x9d, 0x3c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x96, 0x03, 0x40, 0x41, 0x44, 0x44, 0x49, 0x54, 0x49, 0x4f, 0x4e, 0x41, 0x4c, 0x40, 0x40, 0x40, 0x40, 0x41, 0x54, 0x40, 0x40, 0x40, 0x30, 0x30, 0x30, 0x40, 0x5d, 0x5e, 0x5f, 0x2f, 0x95, 0x2f, 0x80, 0x5a, 0x02, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x2f, 0x07, 0x07, 0x07, 0x01, 0x01, 0x01, 0x01, 0x2f, 0x80, 0x50, 0x40, 0x40, 0x40, 0x2f, 0x87, 0x2f, 0x80, 0x5b, 0x02, 0x5c, 0x40, 0x4d, 0x49, 0x44, 0x57, 0x41, 0x59, 0x40, 0x4d, 0x46, 0x47, 0x40, 0x43, 0x4f, 0x40, 0x40, 0x40, 0x40, 0x2f, 0x81, 0x2f, 0x80, 0x2f, 0x80, 0xc5, 0x02, 0x3b, 0x4d, 0x41, 0x44, 0x40, 0x44, 0x4f, 0x47, 0x40, 0x40, 0x2f, 0x81, 0x2f, 0x80, 0x6e, 0x02, 0x40, 0x40, 0x40, 0x42, 0x4c, 0x49, 0x4e, 0x4b, 0x59, 0x2f, 0x81, 0x2f, 0x80, 0xc8, 0x02, 0x3b, 0x4b, 0x49, 0x4c, 0x4c, 0x45, 0x52, 0x40, 0x40, 0x40, 0x2f, 0x83, 0x2f, 0x80, 0x6e, 0x02, 0x40, 0x40, 0x40, 0x50, 0x49, 0x4e, 0x4b, 0x59, 0x40, 0x2f, 0x83, 0x2f, 0x80, 0x6e, 0x02, 0x4d, 0x53, 0x40, 0x50, 0x41, 0x43, 0x3b, 0x4d, 0x41, 0x4e, 0x2f, 0x89, 0x2f, 0x80, 0x6e, 0x02, 0x40, 0x40, 0x40, 0x49, 0x4e, 0x4b, 0x59, 0x40, 0x40, 0x2f, 0x85, 0x2f, 0x80, 0x3d, 0x02, 0x40, 0x40, 0x31, 0x39, 0x38, 0x30, 0x3a, 0x31, 0x39, 0x38, 0x31, 0x40, 0x2f, 0x81, 0x2f, 0x80, 0x6e, 0x02, 0x40, 0x40, 0x40, 0x40, 0x53, 0x55, 0x45, 0x2f, 0x87, 0x2f, 0x80, 0x6b, 0x02, 0x4a, 0x55, 0x4e, 0x49, 0x4f, 0x52, 0x40, 0x40, 0x40, 0x40, 0x2f, 0x8f, 0x2f, 0x80, 0x6b, 0x02, 0x57, 0x49, 0x54, 0x48, 0x40, 0x40, 0x40, 0x40, 0x40, 0x2f, 0x8f, 0x2f, 0x80, 0x6b, 0x02, 0x54, 0x48, 0x45, 0x40, 0x43, 0x48, 0x41, 0x53, 0x45, 0x40, 0x2f, 0x8f, 0x2f, 0x80, 0x6b, 0x02, 0x53, 0x54, 0x41, 0x52, 0x52, 0x49, 0x4e, 0x47, 0x40, 0x2f, 0x8f, 0x2f, 0x80, 0x0c, 0x03, 0x4d, 0x53, 0x40, 0x50, 0x41, 0x43, 0x3b, 0x4d, 0x45, 0x4e, 0x2f, 0x8f, 0x2f, 0x80, 0x6b, 0x02, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x2f, 0x85, 0x2f, 0x80, 0x6b, 0x02, 0x41, 0x43, 0x54, 0x40, 0x49, 0x49, 0x49, 0x26, 0x40, 0x40, 0x2f, 0x87, 0x2f, 0x80, 0x6b, 0x02, 0x54, 0x48, 0x45, 0x59, 0x40, 0x4d, 0x45, 0x45, 0x54, 0x2f, 0x8f, 0x2f, 0x80, 0x0c, 0x03, 0x4f, 0x54, 0x54, 0x4f, 0x4d, 0x45, 0x4e, 0x2f, 0x8f, 0x2f, 0x80 }; // From 0x3e68 to 0x3e89 (34 byte(s)) static const UINT8 sg_u8Region147[0x0022] = { 0x5f, 0x04, 0x96, 0x3e, 0x8b, 0x3e, 0x0c, 0x00, 0xbd, 0x3e, 0x9c, 0x3e, 0x83, 0x34, 0xa2, 0x3e, 0x88, 0x34, 0xab, 0x3e, 0x8d, 0x34, 0xb1, 0x3e, 0x92, 0x34, 0xc3, 0x3e, 0xb7, 0x3e, 0x97, 0x34, 0xc9, 0x3e }; // From 0x3e8c to 0x3e8d (2 byte(s)) static const UINT8 sg_u8Region148[0x0002] = { 0x1c, 0x0c }; // From 0x3e9d to 0x3e9e (2 byte(s)) static const UINT8 sg_u8Region149[0x0002] = { 0x1c, 0x0d }; // From 0x3ea3 to 0x3ea4 (2 byte(s)) static const UINT8 sg_u8Region150[0x0002] = { 0x1c, 0x30 }; // From 0x3ea6 to 0x3ea7 (2 byte(s)) static const UINT8 sg_u8Region151[0x0002] = { 0x1c, 0x0f }; // From 0x3eac to 0x3ead (2 byte(s)) static const UINT8 sg_u8Region152[0x0002] = { 0x1c, 0x2f }; // From 0x3eb2 to 0x3eb3 (2 byte(s)) static const UINT8 sg_u8Region153[0x0002] = { 0x1c, 0x31 }; // From 0x3eb8 to 0x3eb9 (2 byte(s)) static const UINT8 sg_u8Region154[0x0002] = { 0x1c, 0x33 }; // From 0x3ebe to 0x3ebf (2 byte(s)) static const UINT8 sg_u8Region155[0x0002] = { 0x1c, 0x0e }; // From 0x3ec4 to 0x3ec5 (2 byte(s)) static const UINT8 sg_u8Region156[0x0002] = { 0x1c, 0x10 }; // From 0x3f7f to 0x3fff (129 byte(s)) static const UINT8 sg_u8Region157[0x0081] = { 0xd0, 0x42, 0xb0, 0x42, 0x90, 0x42, 0x70, 0x42, 0x50, 0x42, 0x30, 0x42, 0x10, 0x42, 0xf0, 0x41, 0xd0, 0x41, 0xb0, 0x41, 0x90, 0x41, 0x70, 0x41, 0x50, 0x41, 0x30, 0x41, 0x10, 0x41, 0xf0, 0x40, 0xd0, 0x40, 0xb0, 0x40, 0xaf, 0x40, 0xae, 0x40, 0xad, 0x40, 0xac, 0x40, 0xab, 0x40, 0xaa, 0x40, 0xa9, 0x40, 0xc9, 0x40, 0xe9, 0x40, 0x09, 0x41, 0x29, 0x41, 0x49, 0x41, 0x69, 0x41, 0x89, 0x41, 0xa9, 0x41, 0xc9, 0x41, 0xe9, 0x41, 0x09, 0x42, 0x29, 0x42, 0x49, 0x42, 0x69, 0x42, 0x89, 0x42, 0xa9, 0x42, 0xc9, 0x42, 0xca, 0x42, 0xcb, 0x42, 0xcc, 0x42, 0xcd, 0x42, 0xce, 0x42, 0xcf, 0x42, 0xd0, 0x42, 0xc9, 0x42, 0xca, 0x42, 0xcb, 0x42, 0xcc, 0x42, 0xcd, 0x42, 0xce, 0x42, 0xcf, 0x42, 0xd0, 0x42, 0x42, 0xcf, 0x42, 0xd0, 0x42, 0x00, 0x4f, 0xc9, 0x00, 0x00, 0x30, 0x8d, 0x00, 0x75, 0x73 }; // From 0x8000 to 0x8000 (1 byte(s)) static const UINT8 sg_u8Region158[0x0001] = { 0xc9 }; // From 0x800f to 0x8012 (4 byte(s)) static const UINT8 sg_u8Region159[0x0004] = { 0x5f, 0xd2, 0x4d, 0xc9 }; // From 0x8016 to 0x8017 (2 byte(s)) // Region 0x8016 to 0x8017 (2 byte(s)) collapsed to 0x8016 to 0x8016 (1 byte(s)) static const UINT8 sg_u8Region160[0x0001] = { 0x3a }; // From 0x801c to 0x801f (4 byte(s)) static const UINT8 sg_u8Region161[0x0004] = { 0x1a, 0x21, 0x40, 0x21 }; // From 0x8025 to 0x8082 (94 byte(s)) // Region 0x8025 to 0x8082 (94 byte(s)) collapsed to 0x8027 to 0x8082 (92 byte(s)) static const UINT8 sg_u8Region162[0x005c] = { 0x22, 0x2a, 0x10, 0x4d, 0xcd, 0x5e, 0x95, 0x11, 0x40, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x4e, 0x36, 0x00, 0x3e, 0x3e, 0x11, 0x59, 0x01, 0x3a, 0x2c, 0x4d, 0xcd, 0x61, 0x95, 0xcd, 0x66, 0x21, 0x00, 0x40, 0xc3, 0x7c, 0x94, 0x4e, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x40, 0xc3 }; // From 0x808f to 0x808f (1 byte(s)) static const UINT8 sg_u8Region163[0x0001] = { 0xc9 }; // From 0x80b0 to 0x869b (1516 byte(s)) static const UINT8 sg_u8Region164[0x05ec] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0xfe, 0x02, 0x3e, 0x1f, 0xc3, 0x80, 0x95, 0x4d, 0xc3, 0xc5, 0x86, 0xc9, 0x38, 0x08, 0x1e, 0xd2, 0xc3, 0x97, 0x97, 0xdd, 0x21, 0xcc, 0x4e, 0x09, 0x07, 0xfd, 0x35, 0x00, 0xc9, 0x06, 0x19, 0x91, 0x4e, 0x21, 0x7d, 0x96, 0xdd, 0x21, 0xdc, 0xe3, 0x95, 0xa1, 0x2b, 0x75, 0x26, 0xb2, 0x26, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x08, 0x00, 0x16, 0x00, 0x01, 0x00, 0x02, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x50, 0x00, 0x50, 0x13, 0x6b, 0x62, 0x1b, 0xcb, 0x32, 0xbc, 0x4e, 0x18, 0x06, 0x32, 0xcc, 0x4e, 0x44, 0xc3, 0x24, 0x95, 0x20, 0x02, 0x3e, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x34, 0x4e, 0xc3, 0xec, 0x94, 0xed, 0xa0, 0x11, 0xc3, 0x6f, 0x36, 0x00, 0x02, 0xc9, 0xaf, 0x02, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x73, 0x02, 0xc3, 0x4e, 0x36, 0x0c, 0xdd, 0x35, 0xa7, 0xed, 0x52, 0xc0, 0xaf, 0x00, 0x3c, 0x32, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe5, 0x21, 0x64, 0x40, 0xc3, 0x04, 0x95, 0xed, 0xc9, 0xc3, 0xb1, 0x86, 0xc9, 0x07, 0xfe, 0x06, 0x2a, 0x0e, 0x4d, 0xcd, 0x59, 0x95, 0x11, 0x40, 0xa6, 0xcb, 0xc7, 0x77, 0xc9, 0xc3, 0xee, 0x86, 0x4e, 0xc3, 0x4f, 0x34, 0x41, 0xe7, 0xc2, 0x21, 0xcd, 0x00, 0x10, 0x18, 0x07, 0x1c, 0xcd, 0x42, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1a, 0xc3, 0xc3, 0x95, 0x06, 0x06, 0xdd, 0x21, 0x08, 0x4d, 0xc3, 0xd9, 0x86, 0xc9, 0x38, 0x05, 0x3a, 0x13, 0x4e, 0x3c, 0xc3, 0x93, 0x87, 0x2e, 0x4e, 0xc3, 0xa1, 0x94, 0x00, 0x21, 0x04, 0x4e, 0x32, 0x96, 0x4e, 0x21, 0x8d, 0x96, 0xdd, 0x21, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x51, 0x82, 0xa3, 0x82, 0x12, 0x83, 0x4c, 0x83, 0x69, 0x85, 0x7c, 0x85, 0x95, 0x83, 0xf0, 0x83, 0x2b, 0x85, 0x4a, 0x85, 0x69, 0x85, 0x7c, 0x85, 0x51, 0x84, 0x6d, 0x84, 0xcf, 0x84, 0xfd, 0x84, 0x89, 0x84, 0x7c, 0x85, 0x94, 0x85, 0x50, 0x82, 0x50, 0x82, 0x50, 0x82, 0x50, 0x82, 0x50, 0x82, 0x50, 0x82, 0xb0, 0x85, 0x50, 0x82, 0x50, 0x82, 0x50, 0x82, 0x50, 0x82, 0x50, 0x82, 0x50, 0x82, 0xcc, 0x85, 0x50, 0x82, 0x50, 0x82, 0x50, 0x82, 0x50, 0x82, 0x50, 0x82, 0x50, 0x82, 0xe8, 0x85, 0x50, 0x82, 0x50, 0x82, 0x50, 0x82, 0x50, 0x82, 0x50, 0x82, 0x50, 0x82, 0x04, 0x86, 0x50, 0x82, 0xff, 0xf1, 0x00, 0x00, 0xf3, 0x75, 0x86, 0xf2, 0x01, 0xf0, 0x00, 0x00, 0x16, 0xf1, 0xbd, 0x52, 0xf2, 0x28, 0xf6, 0xf2, 0x16, 0xf0, 0x00, 0x00, 0x16, 0xf2, 0x16, 0xf6, 0xf1, 0xff, 0x54, 0xf3, 0x14, 0x86, 0xf2, 0x7f, 0xf0, 0xf0, 0x00, 0x09, 0xf2, 0x7f, 0xf0, 0xf0, 0x00, 0x09, 0xf1, 0x00, 0x7f, 0xf3, 0x1d, 0x86, 0xf2, 0x75, 0xf0, 0x10, 0x00, 0x09, 0xf2, 0x04, 0xf0, 0x10, 0xf0, 0x09, 0xf3, 0x26, 0x86, 0xf2, 0x30, 0xf0, 0x00, 0xf0, 0x09, 0xf3, 0x1d, 0x86, 0xf2, 0x10, 0xf0, 0x00, 0x00, 0x09, 0xff, 0xf1, 0x00, 0x00, 0xf3, 0x7f, 0x86, 0xf2, 0x01, 0xf0, 0x00, 0x00, 0x16, 0xf1, 0xad, 0x52, 0xf2, 0x28, 0xf6, 0xf2, 0x16, 0xf0, 0x00, 0x00, 0x16, 0xf2, 0x16, 0xf6, 0xf1, 0xff, 0x54, 0xf3, 0x5c, 0x86, 0xf2, 0x2f, 0xf6, 0xf2, 0x70, 0xf0, 0xef, 0x00, 0x05, 0xf2, 0x74, 0xf0, 0xec, 0x00, 0x05, 0xf1, 0x00, 0x7f, 0xf3, 0x63, 0x86, 0xf2, 0x1c, 0xf6, 0xf2, 0x58, 0xf0, 0x16, 0x00, 0x05, 0xf5, 0x10, 0xf2, 0x06, 0xf0, 0xf8, 0xf8, 0x05, 0xf2, 0x06, 0xf0, 0xf8, 0x08, 0x05, 0xf2, 0x06, 0xf0, 0xf8, 0xf8, 0x05, 0xf2, 0x06, 0xf0, 0xf8, 0x08, 0x05, 0xf1, 0x00, 0x00, 0xf3, 0x73, 0x86, 0xf2, 0x01, 0xf0, 0x00, 0x00, 0x03, 0xf1, 0x7f, 0x3a, 0xf2, 0x40, 0xf0, 0x00, 0x00, 0x03, 0xff, 0xf2, 0x5a, 0xf6, 0xf1, 0x00, 0xa4, 0xf3, 0x41, 0x86, 0xf2, 0x7f, 0xf0, 0x10, 0x00, 0x09, 0xf2, 0x7f, 0xf0, 0x10, 0x00, 0x09, 0xf1, 0xff, 0x7f, 0xf3, 0x38, 0x86, 0xf2, 0x76, 0xf0, 0xf0, 0x00, 0x09, 0xf2, 0x04, 0xf0, 0xf0, 0xf0, 0x09, 0xf3, 0x4a, 0x86, 0xf2, 0x30, 0xf0, 0x00, 0xf0, 0x09, 0xf3, 0x38, 0x86, 0xf2, 0x10, 0xf0, 0x00, 0x00, 0x09, 0xff, 0xf2, 0x5f, 0xf6, 0xf1, 0x01, 0xa4, 0xf3, 0x63, 0x86, 0xf2, 0x2f, 0xf6, 0xf2, 0x70, 0xf0, 0x11, 0x00, 0x03, 0xf2, 0x74, 0xf0, 0x14, 0x00, 0x03, 0xf1, 0xff, 0x7f, 0xf3, 0x5c, 0x86, 0xf2, 0x1c, 0xf6, 0xf2, 0x58, 0xf0, 0xea, 0x00, 0x03, 0xf2, 0x06, 0xf0, 0x08, 0xf8, 0x03, 0xf2, 0x06, 0xf0, 0x08, 0x08, 0x03, 0xf2, 0x06, 0xf0, 0x08, 0xf8, 0x03, 0xf2, 0x06, 0xf0, 0x08, 0x08, 0x03, 0xf3, 0x71, 0x86, 0xf2, 0x10, 0xf0, 0x00, 0x00, 0x16, 0xff, 0xf2, 0x5a, 0xf6, 0xf1, 0xff, 0x34, 0xf3, 0x14, 0x86, 0xf2, 0x7f, 0xf6, 0xf2, 0x24, 0xf6, 0xf2, 0x68, 0xf0, 0xd8, 0x00, 0x09, 0xf2, 0x7f, 0xf6, 0xf2, 0x18, 0xf6, 0xf1, 0x00, 0x94, 0xf3, 0x41, 0x86, 0xf2, 0x68, 0xf0, 0x28, 0x00, 0x09, 0xf2, 0x7f, 0xf6, 0xf1, 0xfc, 0x7f, 0xf3, 0x14, 0x86, 0xf2, 0x18, 0xf6, 0xf2, 0x68, 0xf0, 0xd8, 0x00, 0x09, 0xf2, 0x7f, 0xf6, 0xf2, 0x18, 0xf6, 0xf1, 0x00, 0x54, 0xf3, 0x41, 0x86, 0xf2, 0x20, 0xf0, 0x70, 0x00, 0x09, 0xf1, 0xff, 0xb4, 0xf3, 0x14, 0x86, 0xf2, 0x10, 0xf6, 0xf2, 0x24, 0xf0, 0x90, 0x00, 0x09, 0xff, 0xf2, 0x63, 0xf6, 0xf1, 0xff, 0x34, 0xf3, 0x38, 0x86, 0xf2, 0x24, 0xf6, 0xf2, 0x7f, 0xf6, 0xf2, 0x18, 0xf6, 0xf2, 0x57, 0xf0, 0xd0, 0x00, 0x09, 0xf2, 0x7f, 0xf6, 0xf2, 0x28, 0xf6, 0xf1, 0x00, 0x94, 0xf3, 0x1d, 0x86, 0xf2, 0x58, 0xf0, 0x30, 0x00, 0x09, 0xf2, 0x7f, 0xf6, 0xf2, 0x24, 0xf6, 0xf1, 0xff, 0x7f, 0xf3, 0x38, 0x86, 0xf2, 0x58, 0xf0, 0xd0, 0x00, 0x09, 0xf2, 0x7f, 0xf6, 0xf2, 0x20, 0xf6, 0xf1, 0x00, 0x54, 0xf3, 0x1d, 0x86, 0xf2, 0x20, 0xf0, 0x70, 0x00, 0x09, 0xf1, 0xff, 0xb4, 0xf3, 0x38, 0x86, 0xf2, 0x10, 0xf6, 0xf2, 0x24, 0xf0, 0x90, 0x00, 0x09, 0xf2, 0x7f, 0xf6, 0xff, 0xf2, 0x5a, 0xf6, 0xf1, 0x00, 0x60, 0xf3, 0x8d, 0x86, 0xf2, 0x7f, 0xf0, 0x0a, 0x00, 0x16, 0xf2, 0x7f, 0xf0, 0x10, 0x00, 0x16, 0xf2, 0x30, 0xf0, 0x10, 0x00, 0x16, 0xff, 0xf2, 0x6f, 0xf6, 0xf1, 0x00, 0x60, 0xf3, 0x8f, 0x86, 0xf2, 0x6a, 0xf0, 0x0a, 0x00, 0x16, 0xf2, 0x7f, 0xf0, 0x10, 0x00, 0x16, 0xf2, 0x3a, 0xf0, 0x10, 0x00, 0x16, 0xff, 0xf3, 0x89, 0x86, 0xf2, 0x01, 0xf0, 0x00, 0x00, 0x16, 0xf1, 0xbd, 0x62, 0xf2, 0x5a, 0xf6, 0xf1, 0x05, 0x60, 0xf3, 0x98, 0x86, 0xf2, 0x7f, 0xf0, 0x0a, 0x00, 0x16, 0xf2, 0x7f, 0xf0, 0x06, 0x0c, 0x16, 0xf2, 0x06, 0xf0, 0x06, 0xf0, 0x16, 0xf2, 0x0c, 0xf0, 0x03, 0x09, 0x16, 0xf2, 0x05, 0xf0, 0x05, 0xf6, 0x16, 0xf2, 0x0a, 0xf0, 0x04, 0x03, 0x16, 0xf3, 0x9a, 0x86, 0xf2, 0x01, 0xf0, 0x00, 0x00, 0x16, 0xf2, 0x20, 0xf6, 0xff, 0xf1, 0x00, 0x00, 0xf3, 0x75, 0x86, 0xf2, 0x01, 0xf0, 0x00, 0x00, 0x16, 0xf1, 0xbd, 0x52, 0xf2, 0x28, 0xf6, 0xf2, 0x16, 0xf0, 0x00, 0x00, 0x16, 0xf2, 0x16, 0xf6, 0xf1, 0x00, 0x00, 0xf3, 0x38, 0x86, 0xf2, 0x01, 0xf0, 0x00, 0x00, 0x09, 0xf1, 0xc0, 0xc0, 0xf2, 0x30, 0xf6, 0xff, 0xf1, 0x00, 0x00, 0xf3, 0x7f, 0x86, 0xf2, 0x01, 0xf0, 0x00, 0x00, 0x16, 0xf1, 0xad, 0x52, 0xf2, 0x28, 0xf6, 0xf2, 0x16, 0xf0, 0x00, 0x00, 0x16, 0xf2, 0x16, 0xf6, 0xf1, 0x00, 0x00, 0xf3, 0x14, 0x86, 0xf2, 0x01, 0xf0, 0x00, 0x00, 0x09, 0xf1, 0xd0, 0xc0, 0xf2, 0x30, 0xf6, 0xff, 0xf1, 0x00, 0x00, 0xf3, 0x75, 0x86, 0xf2, 0x01, 0xf0, 0x00, 0x00, 0x16, 0xf1, 0xbd, 0x52, 0xf2, 0x28, 0xf6, 0xf2, 0x16, 0xf0, 0x00, 0x00, 0x16, 0xf2, 0x16, 0xf6, 0xf1, 0x00, 0x00, 0xff, 0xf1, 0x00, 0x00, 0xf3, 0x7f, 0x86, 0xf2, 0x01, 0xf0, 0x00, 0x00, 0x16, 0xf1, 0xad, 0x52, 0xf2, 0x28, 0xf6, 0xf2, 0x16, 0xf0, 0x00, 0x00, 0x16, 0xf2, 0x16, 0xf6, 0xf1, 0x00, 0x00, 0xff, 0xf3, 0x89, 0x86, 0xf2, 0x01, 0xf0, 0x00, 0x00, 0x16, 0xf1, 0xbd, 0x62, 0xf2, 0x5a, 0xf6, 0xf1, 0x00, 0x00, 0xff, 0xf3, 0x8b, 0x86, 0xf2, 0x01, 0xf0, 0x00, 0x00, 0x16, 0xf1, 0xad, 0x62, 0xf2, 0x39, 0xf6, 0xf7, 0xf2, 0x1e, 0xf6, 0xf8, 0xf1, 0x00, 0x00, 0xff, 0xf1, 0x00, 0x94, 0xf3, 0x63, 0x86, 0xf2, 0x70, 0xf0, 0x10, 0x00, 0x01, 0xf2, 0x50, 0xf0, 0x10, 0x00, 0x01, 0xf3, 0x6a, 0x86, 0xf2, 0x48, 0xf0, 0x00, 0xf0, 0x01, 0xff, 0xf1, 0x00, 0x94, 0xf3, 0x63, 0x86, 0xf2, 0x70, 0xf0, 0x10, 0x00, 0x03, 0xf2, 0x50, 0xf0, 0x10, 0x00, 0x03, 0xf3, 0x6a, 0x86, 0xf2, 0x38, 0xf0, 0x00, 0xf0, 0x03, 0xff, 0xf1, 0x00, 0x94, 0xf3, 0x63, 0x86, 0xf2, 0x70, 0xf0, 0x10, 0x00, 0x05, 0xf2, 0x50, 0xf0, 0x10, 0x00, 0x05, 0xf3, 0x6a, 0x86, 0xf2, 0x28, 0xf0, 0x00, 0xf0, 0x05, 0xff, 0xf1, 0x00, 0x94, 0xf3, 0x63, 0x86, 0xf2, 0x70, 0xf0, 0x10, 0x00, 0x07, 0xf2, 0x50, 0xf0, 0x10, 0x00, 0x07, 0xf3, 0x6a, 0x86, 0xf2, 0x18, 0xf0, 0x00, 0xf0, 0x07, 0xff, 0xf1, 0x00, 0x94, 0xf3, 0x41, 0x86, 0xf2, 0x72, 0xf0, 0x10, 0x00, 0x09, 0xf2, 0x7f, 0xf6, 0xff, 0x1b, 0x1b, 0x19, 0x19, 0x1b, 0x1b, 0x32, 0x32, 0xff, 0x9b, 0x9b, 0x99, 0x99, 0x9b, 0x9b, 0xb2, 0xb2, 0xff, 0x6e, 0x6e, 0x5a, 0x5a, 0x6e, 0x6e, 0x72, 0x72, 0xff, 0xee, 0xee, 0xda, 0xda, 0xee, 0xee, 0xf2, 0xf2, 0xff, 0x37, 0x37, 0x2d, 0x2d, 0x37, 0x37, 0x2f, 0x2f, 0xff, 0xb7, 0xb7, 0xad, 0xad, 0xb7, 0xb7, 0xaf, 0xaf, 0xff, 0x36, 0x36, 0xf1, 0xf1, 0x36, 0x36, 0xf3, 0xf3, 0xff, 0x34, 0x34, 0x31, 0x31, 0x34, 0x34, 0x33, 0x33, 0xff, 0xa4, 0xa4, 0xa4, 0xa5, 0xa5, 0xa5, 0xff, 0x24, 0x24, 0x24, 0x25, 0x25, 0x25, 0xff, 0x26, 0x26, 0x26, 0x27, 0x27, 0x27, 0xff, 0x1f, 0xff, 0x1e, 0xff, 0x10, 0x10, 0x10, 0x14, 0x14, 0x14, 0x16, 0x16, 0x16, 0xff, 0x11, 0x11, 0x11, 0x15, 0x15, 0x15, 0x17, 0x17, 0x17, 0xff, 0x12, 0xff, 0x13, 0xff, 0x30, 0xff, 0x18, 0x18, 0x18, 0x18, 0x2c, 0x2c, 0x2c, 0x2c, 0xff, 0x07, 0xff, 0x0f, 0xff }; // From 0x879d to 0x87b4 (24 byte(s)) // Region 0x879d to 0x87b4 (24 byte(s)) collapsed to 0x879e to 0x87b4 (23 byte(s)) static const UINT8 sg_u8Region165[0x0017] = { 0x14, 0x06, 0x01, 0x0f, 0x07, 0x02, 0x15, 0x08, 0x03, 0x07, 0x09, 0x04, 0x14, 0x0a, 0x05, 0x15, 0x0b, 0x06, 0x16, 0x0c, 0x07, 0x00, 0x0d }; // From 0x87f8 to 0x880f (24 byte(s)) static const UINT8 sg_u8Region166[0x0018] = { 0x4f, 0x8b, 0x40, 0x8e, 0x1a, 0x91, 0x0a, 0x94, 0x82, 0x8b, 0x73, 0x8e, 0x42, 0x91, 0x3c, 0x94, 0xfa, 0xff, 0x55, 0x55, 0x01, 0x80, 0xaa, 0x02 }; // From 0x8841 to 0x9469 (3113 byte(s)) static const UINT8 sg_u8Region167[0x0c29] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0xff, 0xfe, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xfe, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x01, 0xff, 0x01, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x40, 0xfc, 0xd0, 0xd2, 0xd2, 0xd2, 0xd2, 0xd4, 0xfc, 0xda, 0x02, 0xdc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xda, 0x02, 0xdc, 0xfc, 0xfc, 0xfc, 0xd0, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd4, 0xfc, 0xda, 0x05, 0xdc, 0xfc, 0xda, 0x02, 0xdc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xda, 0x02, 0xdc, 0xfc, 0xfc, 0xfc, 0xda, 0x08, 0xdc, 0xfc, 0xda, 0x02, 0xe6, 0xea, 0x02, 0xe7, 0xd2, 0xeb, 0x02, 0xe7, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xeb, 0x02, 0xe7, 0xd2, 0xd2, 0xd2, 0xeb, 0x02, 0xe6, 0xe8, 0xe8, 0xe8, 0xea, 0x02, 0xdc, 0xfc, 0xda, 0x02, 0xde, 0xe4, 0x15, 0xde, 0xc0, 0xc0, 0xc0, 0xe4, 0x02, 0xdc, 0xfc, 0xda, 0x02, 0xde, 0xe4, 0x02, 0xe6, 0xe8, 0xe8, 0xe8, 0xe8, 0xea, 0x02, 0xe6, 0xe8, 0xe8, 0xe8, 0xea, 0x02, 0xe6, 0xea, 0x02, 0xe6, 0xea, 0x02, 0xde, 0xc0, 0xc0, 0xc0, 0xe4, 0x02, 0xdc, 0xfc, 0xda, 0x02, 0xe7, 0xeb, 0x02, 0xe7, 0xe9, 0xe9, 0xe9, 0xf5, 0xe4, 0x02, 0xde, 0xf3, 0xe9, 0xe9, 0xeb, 0x02, 0xde, 0xe4, 0x02, 0xde, 0xe4, 0x02, 0xe7, 0xe9, 0xe9, 0xe9, 0xeb, 0x02, 0xdc, 0xfc, 0xda, 0x09, 0xde, 0xe4, 0x02, 0xde, 0xe4, 0x05, 0xde, 0xe4, 0x02, 0xde, 0xe4, 0x08, 0xdc, 0xfc, 0xfa, 0xe8, 0xe8, 0xea, 0x02, 0xe6, 0xe8, 0xea, 0x02, 0xde, 0xe4, 0x02, 0xde, 0xe4, 0x02, 0xe6, 0xe8, 0xe8, 0xf4, 0xe4, 0x02, 0xde, 0xe4, 0x02, 0xe6, 0xe8, 0xe8, 0xe8, 0xea, 0x02, 0xdc, 0xfc, 0xfb, 0xe9, 0xe9, 0xeb, 0x02, 0xde, 0xc0, 0xe4, 0x02, 0xe7, 0xeb, 0x02, 0xe7, 0xeb, 0x02, 0xe7, 0xe9, 0xe9, 0xf5, 0xe4, 0x02, 0xe7, 0xeb, 0x02, 0xde, 0xf3, 0xe9, 0xe9, 0xeb, 0x02, 0xdc, 0xfc, 0xda, 0x05, 0xde, 0xc0, 0xe4, 0x0b, 0xde, 0xe4, 0x05, 0xde, 0xe4, 0x05, 0xdc, 0xfc, 0xda, 0x02, 0xe6, 0xea, 0x02, 0xde, 0xc0, 0xe4, 0x02, 0xe6, 0xea, 0x02, 0xec, 0xd3, 0xd3, 0xd3, 0xee, 0x02, 0xde, 0xe4, 0x02, 0xe6, 0xea, 0x02, 0xde, 0xe4, 0x02, 0xe6, 0xea, 0x02, 0xdc, 0xfc, 0xda, 0x02, 0xde, 0xe4, 0x02, 0xe7, 0xe9, 0xeb, 0x02, 0xde, 0xe4, 0x02, 0xdc, 0xfc, 0xfc, 0xfc, 0xda, 0x02, 0xe7, 0xeb, 0x02, 0xde, 0xe4, 0x02, 0xe7, 0xeb, 0x02, 0xde, 0xe4, 0x02, 0xdc, 0xfc, 0xda, 0x02, 0xde, 0xe4, 0x06, 0xde, 0xe4, 0x02, 0xf0, 0xfc, 0xfc, 0xfc, 0xda, 0x05, 0xde, 0xe4, 0x05, 0xde, 0xe4, 0x02, 0xdc, 0xfc, 0xda, 0x02, 0xde, 0xe4, 0x02, 0xe6, 0xe8, 0xe8, 0xe8, 0xf4, 0xe4, 0x02, 0xce, 0xfc, 0xfc, 0xfc, 0xda, 0x02, 0xe6, 0xe8, 0xe8, 0xf4, 0xe4, 0x02, 0xe6, 0xe8, 0xe8, 0xf4, 0xe4, 0x02, 0xdc, 0x00, 0x62, 0x02, 0x01, 0x13, 0x01, 0x01, 0x01, 0x02, 0x01, 0x04, 0x03, 0x13, 0x06, 0x04, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x06, 0x04, 0x03, 0x10, 0x03, 0x06, 0x04, 0x03, 0x10, 0x03, 0x06, 0x04, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x0c, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x07, 0x04, 0x0c, 0x03, 0x06, 0x07, 0x04, 0x0c, 0x03, 0x06, 0x04, 0x01, 0x01, 0x01, 0x04, 0x0c, 0x01, 0x01, 0x01, 0x03, 0x01, 0x01, 0x01, 0x04, 0x03, 0x04, 0x0f, 0x03, 0x03, 0x04, 0x03, 0x04, 0x0f, 0x03, 0x03, 0x04, 0x03, 0x01, 0x01, 0x01, 0x01, 0x0f, 0x01, 0x01, 0x01, 0x03, 0x04, 0x03, 0x19, 0x04, 0x03, 0x19, 0x04, 0x03, 0x01, 0x01, 0x01, 0x01, 0x0f, 0x01, 0x01, 0x01, 0x03, 0x04, 0x03, 0x04, 0x0f, 0x03, 0x03, 0x04, 0x03, 0x04, 0x0f, 0x03, 0x03, 0x04, 0x01, 0x01, 0x01, 0x04, 0x0c, 0x01, 0x01, 0x01, 0x03, 0x01, 0x01, 0x01, 0x07, 0x04, 0x0c, 0x03, 0x06, 0x07, 0x04, 0x0c, 0x03, 0x06, 0x04, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x0c, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x04, 0x03, 0x10, 0x03, 0x06, 0x04, 0x03, 0x10, 0x03, 0x06, 0x04, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x06, 0x04, 0x03, 0x13, 0x06, 0x04, 0x02, 0x01, 0x13, 0x01, 0x01, 0x01, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x1d, 0x22, 0x1d, 0x39, 0x40, 0x20, 0x40, 0x3b, 0x63, 0x40, 0x7c, 0x40, 0x83, 0x43, 0x9c, 0x43, 0x49, 0x09, 0x17, 0x09, 0x17, 0x09, 0x0e, 0xe0, 0xe0, 0xe0, 0x29, 0x09, 0x17, 0x09, 0x17, 0x09, 0x00, 0x00, 0x63, 0x8b, 0x13, 0x94, 0x0c, 0x68, 0x8b, 0x22, 0x94, 0xf4, 0x71, 0x8b, 0x27, 0x4c, 0xf4, 0x7b, 0x8b, 0x1c, 0x4c, 0x0c, 0x80, 0xaa, 0xaa, 0xbf, 0xaa, 0x80, 0x0a, 0x54, 0x55, 0x55, 0x55, 0xff, 0x5f, 0x55, 0xea, 0xff, 0x57, 0x55, 0xf5, 0x57, 0xff, 0x15, 0x40, 0x55, 0xea, 0xaf, 0x02, 0xea, 0xff, 0xff, 0xaa, 0x94, 0x8b, 0x14, 0x00, 0x00, 0x99, 0x8b, 0x17, 0x00, 0x00, 0x9f, 0x8b, 0x1a, 0x00, 0x00, 0xa6, 0x8b, 0x1d, 0x55, 0x40, 0x55, 0x55, 0xbf, 0xaa, 0x80, 0xaa, 0xaa, 0xbf, 0xaa, 0xaa, 0x80, 0xaa, 0x02, 0x80, 0xaa, 0xaa, 0x55, 0x00, 0x00, 0x00, 0x55, 0x55, 0xfd, 0xaa, 0x40, 0xfc, 0xda, 0x02, 0xde, 0xd8, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd6, 0xd8, 0xd2, 0xd2, 0xd2, 0xd2, 0xd4, 0xfc, 0xfc, 0xfc, 0xfc, 0xda, 0x02, 0xde, 0xd8, 0xd2, 0xd2, 0xd2, 0xd2, 0xd4, 0xfc, 0xda, 0x02, 0xde, 0xe4, 0x08, 0xde, 0xe4, 0x05, 0xdc, 0xfc, 0xfc, 0xfc, 0xfc, 0xda, 0x02, 0xde, 0xe4, 0x05, 0xdc, 0xfc, 0xda, 0x02, 0xde, 0xe4, 0x02, 0xe6, 0xe8, 0xe8, 0xe8, 0xea, 0x02, 0xde, 0xe4, 0x02, 0xe6, 0xea, 0x02, 0xe7, 0xd2, 0xd2, 0xd2, 0xd2, 0xeb, 0x02, 0xe7, 0xeb, 0x02, 0xe6, 0xea, 0x02, 0xdc, 0xfc, 0xda, 0x02, 0xde, 0xe4, 0x02, 0xde, 0xf3, 0xe9, 0xe9, 0xeb, 0x02, 0xde, 0xe4, 0x02, 0xde, 0xe4, 0x0c, 0xde, 0xe4, 0x02, 0xdc, 0xfc, 0xda, 0x02, 0xde, 0xe4, 0x02, 0xde, 0xe4, 0x05, 0xde, 0xe4, 0x02, 0xde, 0xf2, 0xe8, 0xe8, 0xe8, 0xea, 0x02, 0xe6, 0xea, 0x02, 0xe6, 0xe8, 0xe8, 0xf4, 0xe4, 0x02, 0xdc, 0xfc, 0xda, 0x02, 0xe7, 0xeb, 0x02, 0xde, 0xe4, 0x02, 0xe6, 0xea, 0x02, 0xe7, 0xeb, 0x02, 0xe7, 0xe9, 0xe9, 0xe9, 0xe9, 0xeb, 0x02, 0xde, 0xe4, 0x02, 0xe7, 0xe9, 0xe9, 0xe9, 0xeb, 0x02, 0xdc, 0xfc, 0xda, 0x05, 0xde, 0xe4, 0x02, 0xde, 0xe4, 0x0c, 0xde, 0xe4, 0x08, 0xdc, 0xfc, 0xfa, 0xe8, 0xe8, 0xea, 0x02, 0xde, 0xe4, 0x02, 0xde, 0xf2, 0xe8, 0xe8, 0xe8, 0xe8, 0xea, 0x02, 0xe6, 0xe8, 0xe8, 0xea, 0x02, 0xde, 0xf2, 0xe8, 0xe8, 0xea, 0x02, 0xe6, 0xea, 0x02, 0xdc, 0xfc, 0xfb, 0xe9, 0xe9, 0xeb, 0x02, 0xe7, 0xeb, 0x02, 0xe7, 0xe9, 0xe9, 0xe9, 0xe9, 0xe9, 0xeb, 0x02, 0xe7, 0xe9, 0xf5, 0xe4, 0x02, 0xde, 0xf3, 0xe9, 0xe9, 0xeb, 0x02, 0xde, 0xe4, 0x02, 0xdc, 0xfc, 0xda, 0x12, 0xde, 0xe4, 0x02, 0xde, 0xe4, 0x05, 0xde, 0xe4, 0x02, 0xdc, 0xfc, 0xda, 0x02, 0xe6, 0xea, 0x02, 0xe6, 0xe8, 0xe8, 0xe8, 0xe8, 0xea, 0x02, 0xec, 0xd3, 0xd3, 0xd3, 0xee, 0x02, 0xe7, 0xeb, 0x02, 0xe7, 0xeb, 0x02, 0xe6, 0xea, 0x02, 0xde, 0xe4, 0x02, 0xdc, 0xfc, 0xda, 0x02, 0xde, 0xe4, 0x02, 0xe7, 0xe9, 0xe9, 0xe9, 0xf5, 0xe4, 0x02, 0xdc, 0xfc, 0xfc, 0xfc, 0xda, 0x08, 0xde, 0xe4, 0x02, 0xe7, 0xeb, 0x02, 0xdc, 0xfc, 0xda, 0x02, 0xde, 0xe4, 0x06, 0xde, 0xe4, 0x02, 0xf0, 0xfc, 0xfc, 0xfc, 0xda, 0x02, 0xe6, 0xe8, 0xe8, 0xe8, 0xea, 0x02, 0xde, 0xe4, 0x05, 0xdc, 0xfc, 0xda, 0x02, 0xde, 0xf2, 0xe8, 0xe8, 0xe8, 0xea, 0x02, 0xde, 0xe4, 0x02, 0xce, 0xfc, 0xfc, 0xfc, 0xda, 0x02, 0xde, 0xc0, 0xc0, 0xc0, 0xe4, 0x02, 0xde, 0xf2, 0xe8, 0xe8, 0xea, 0x02, 0xdc, 0x00, 0x00, 0x00, 0x00, 0x66, 0x01, 0x01, 0x01, 0x01, 0x01, 0x03, 0x01, 0x01, 0x01, 0x0b, 0x01, 0x01, 0x07, 0x06, 0x03, 0x03, 0x0a, 0x03, 0x07, 0x06, 0x03, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x03, 0x07, 0x03, 0x01, 0x01, 0x01, 0x03, 0x07, 0x03, 0x06, 0x07, 0x03, 0x03, 0x03, 0x07, 0x03, 0x06, 0x07, 0x03, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x07, 0x03, 0x0d, 0x06, 0x03, 0x07, 0x03, 0x0d, 0x06, 0x03, 0x04, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x0d, 0x03, 0x01, 0x01, 0x01, 0x03, 0x04, 0x03, 0x10, 0x03, 0x03, 0x03, 0x04, 0x03, 0x10, 0x01, 0x01, 0x01, 0x03, 0x03, 0x04, 0x03, 0x01, 0x01, 0x01, 0x01, 0x12, 0x01, 0x01, 0x01, 0x04, 0x07, 0x15, 0x04, 0x07, 0x15, 0x04, 0x03, 0x01, 0x01, 0x01, 0x01, 0x12, 0x01, 0x01, 0x01, 0x04, 0x03, 0x10, 0x01, 0x01, 0x01, 0x03, 0x03, 0x04, 0x03, 0x10, 0x03, 0x03, 0x03, 0x04, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x0d, 0x03, 0x01, 0x01, 0x01, 0x03, 0x07, 0x03, 0x0d, 0x06, 0x03, 0x07, 0x03, 0x0d, 0x06, 0x03, 0x07, 0x03, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x07, 0x03, 0x03, 0x03, 0x07, 0x03, 0x06, 0x07, 0x03, 0x01, 0x01, 0x01, 0x03, 0x07, 0x03, 0x06, 0x07, 0x06, 0x03, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x03, 0x07, 0x06, 0x03, 0x03, 0x0a, 0x03, 0x08, 0x01, 0x01, 0x01, 0x01, 0x01, 0x03, 0x01, 0x01, 0x01, 0x0b, 0x01, 0x01, 0xf4, 0x1d, 0x22, 0x1d, 0x39, 0x40, 0x20, 0x40, 0x3b, 0x65, 0x40, 0x7b, 0x40, 0x85, 0x43, 0x9b, 0x43, 0x42, 0x16, 0x0a, 0x16, 0x0a, 0x16, 0x0a, 0x20, 0x20, 0x20, 0xde, 0xe0, 0x22, 0x20, 0x20, 0x20, 0x20, 0x16, 0x0a, 0x16, 0x0a, 0x16, 0x00, 0x00, 0x54, 0x8e, 0x13, 0xc4, 0x0c, 0x59, 0x8e, 0x1e, 0xc4, 0xf4, 0x61, 0x8e, 0x26, 0x14, 0xf4, 0x6b, 0x8e, 0x1d, 0x14, 0x0c, 0x02, 0xaa, 0xaa, 0x80, 0x2a, 0x02, 0x40, 0x55, 0x7f, 0x55, 0x15, 0x50, 0x05, 0xea, 0xff, 0x57, 0x55, 0xf5, 0xff, 0x57, 0x7f, 0x55, 0x05, 0xea, 0xff, 0xff, 0xff, 0xea, 0xaf, 0xaa, 0x02, 0x87, 0x8e, 0x12, 0x00, 0x00, 0x8c, 0x8e, 0x1d, 0x00, 0x00, 0x94, 0x8e, 0x21, 0x00, 0x00, 0x9d, 0x8e, 0x2c, 0x00, 0x00, 0x55, 0x7f, 0x55, 0xd5, 0xff, 0xaa, 0xbf, 0xaa, 0x2a, 0xa0, 0xea, 0xff, 0xff, 0xaa, 0x2a, 0xa0, 0x02, 0x00, 0x00, 0xa0, 0xaa, 0x02, 0x55, 0x15, 0xa0, 0x2a, 0x00, 0x54, 0x05, 0x00, 0x00, 0x55, 0xfd, 0x40, 0xfc, 0xd0, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd6, 0xe4, 0x02, 0xe7, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd6, 0xd8, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd4, 0xfc, 0xda, 0x07, 0xde, 0xe4, 0x0d, 0xde, 0xe4, 0x08, 0xdc, 0xfc, 0xda, 0x02, 0xe6, 0xe8, 0xe8, 0xea, 0x02, 0xde, 0xe4, 0x02, 0xe6, 0xe8, 0xe8, 0xea, 0x02, 0xe6, 0xe8, 0xe8, 0xe8, 0xea, 0x02, 0xe7, 0xeb, 0x02, 0xe6, 0xea, 0x02, 0xe6, 0xea, 0x02, 0xdc, 0xfc, 0xda, 0x02, 0xde, 0xf3, 0xe9, 0xeb, 0x02, 0xe7, 0xeb, 0x02, 0xe7, 0xe9, 0xf5, 0xe4, 0x02, 0xe7, 0xe9, 0xe9, 0xf5, 0xe4, 0x05, 0xde, 0xe4, 0x02, 0xde, 0xe4, 0x02, 0xdc, 0xfc, 0xda, 0x02, 0xde, 0xe4, 0x09, 0xde, 0xe4, 0x05, 0xde, 0xe4, 0x02, 0xe6, 0xe8, 0xe8, 0xf4, 0xe4, 0x02, 0xde, 0xe4, 0x02, 0xdc, 0xfc, 0xda, 0x02, 0xde, 0xe4, 0x02, 0xe6, 0xe8, 0xe8, 0xe8, 0xe8, 0xea, 0x02, 0xe7, 0xeb, 0x02, 0xe6, 0xea, 0x02, 0xe7, 0xeb, 0x02, 0xe7, 0xe9, 0xe9, 0xe9, 0xeb, 0x02, 0xe7, 0xeb, 0x02, 0xdc, 0xfc, 0xda, 0x02, 0xde, 0xe4, 0x02, 0xe7, 0xe9, 0xe9, 0xe9, 0xf5, 0xe4, 0x05, 0xde, 0xe4, 0x0e, 0xdc, 0xfc, 0xda, 0x02, 0xde, 0xe4, 0x06, 0xde, 0xe4, 0x02, 0xe6, 0xe8, 0xe8, 0xf4, 0xe4, 0x02, 0xe6, 0xe8, 0xe8, 0xe8, 0xea, 0x02, 0xe6, 0xe8, 0xe8, 0xe8, 0xe8, 0xe8, 0xf4, 0xfc, 0xda, 0x02, 0xe7, 0xeb, 0x02, 0xe6, 0xe8, 0xea, 0x02, 0xe7, 0xeb, 0x02, 0xe7, 0xe9, 0xe9, 0xe9, 0xeb, 0x02, 0xde, 0xf3, 0xe9, 0xe9, 0xeb, 0x02, 0xde, 0xf3, 0xe9, 0xe9, 0xe9, 0xe9, 0xf5, 0xfc, 0xda, 0x05, 0xde, 0xc0, 0xe4, 0x0b, 0xde, 0xe4, 0x05, 0xde, 0xe4, 0x05, 0xdc, 0xfc, 0xfa, 0xe8, 0xe8, 0xea, 0x02, 0xde, 0xc0, 0xe4, 0x02, 0xe6, 0xea, 0x02, 0xec, 0xd3, 0xd3, 0xd3, 0xee, 0x02, 0xde, 0xe4, 0x02, 0xe6, 0xea, 0x02, 0xde, 0xe4, 0x02, 0xe6, 0xea, 0x02, 0xdc, 0xfc, 0xfb, 0xe9, 0xe9, 0xeb, 0x02, 0xe7, 0xe9, 0xeb, 0x02, 0xde, 0xe4, 0x02, 0xdc, 0xfc, 0xfc, 0xfc, 0xda, 0x02, 0xe7, 0xeb, 0x02, 0xde, 0xe4, 0x02, 0xe7, 0xeb, 0x02, 0xde, 0xe4, 0x02, 0xdc, 0xfc, 0xda, 0x09, 0xde, 0xe4, 0x02, 0xf0, 0xfc, 0xfc, 0xfc, 0xda, 0x05, 0xde, 0xe4, 0x05, 0xde, 0xe4, 0x02, 0xdc, 0xfc, 0xda, 0x02, 0xe6, 0xe8, 0xe8, 0xe8, 0xe8, 0xea, 0x02, 0xde, 0xe4, 0x02, 0xce, 0xfc, 0xfc, 0xfc, 0xda, 0x02, 0xe6, 0xe8, 0xe8, 0xf4, 0xe4, 0x02, 0xe6, 0xe8, 0xe8, 0xf4, 0xe4, 0x02, 0xdc, 0x00, 0x00, 0x00, 0x00, 0x62, 0x01, 0x02, 0x01, 0x01, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x04, 0x01, 0x01, 0x01, 0x01, 0x01, 0x04, 0x05, 0x03, 0x0b, 0x03, 0x03, 0x03, 0x04, 0x05, 0x03, 0x0b, 0x01, 0x01, 0x01, 0x03, 0x03, 0x04, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x0b, 0x06, 0x03, 0x04, 0x03, 0x10, 0x06, 0x03, 0x04, 0x03, 0x10, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x04, 0x03, 0x01, 0x01, 0x01, 0x01, 0x0f, 0x0a, 0x03, 0x04, 0x0f, 0x0a, 0x01, 0x01, 0x01, 0x04, 0x0c, 0x01, 0x01, 0x01, 0x03, 0x01, 0x01, 0x01, 0x07, 0x04, 0x0c, 0x03, 0x03, 0x03, 0x07, 0x04, 0x0c, 0x03, 0x03, 0x03, 0x04, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x0c, 0x03, 0x01, 0x01, 0x01, 0x03, 0x04, 0x07, 0x15, 0x04, 0x07, 0x15, 0x04, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x0c, 0x03, 0x01, 0x01, 0x01, 0x03, 0x07, 0x04, 0x0c, 0x03, 0x03, 0x03, 0x07, 0x04, 0x0c, 0x03, 0x03, 0x03, 0x04, 0x01, 0x01, 0x01, 0x04, 0x0c, 0x01, 0x01, 0x01, 0x03, 0x01, 0x01, 0x01, 0x04, 0x03, 0x04, 0x0f, 0x0a, 0x03, 0x01, 0x01, 0x01, 0x01, 0x0f, 0x0a, 0x03, 0x10, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x04, 0x03, 0x10, 0x06, 0x03, 0x04, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x0b, 0x06, 0x03, 0x04, 0x05, 0x03, 0x0b, 0x01, 0x01, 0x01, 0x03, 0x03, 0x04, 0x05, 0x03, 0x0b, 0x03, 0x03, 0x03, 0x04, 0x01, 0x02, 0x01, 0x01, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x04, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0xf2, 0x40, 0x2d, 0x1d, 0x22, 0x1d, 0x39, 0x40, 0x20, 0x64, 0x40, 0x78, 0x40, 0x84, 0x43, 0x98, 0x43, 0x2e, 0x91, 0x15, 0x54, 0x0c, 0x34, 0x91, 0x1e, 0x54, 0xf4, 0x34, 0x91, 0x1e, 0x54, 0xf4, 0x3c, 0x91, 0x15, 0x54, 0x0c, 0xea, 0xff, 0xab, 0xfa, 0xaa, 0xaa, 0xea, 0xff, 0x57, 0x55, 0x55, 0xd5, 0x57, 0x55, 0xaa, 0xaa, 0xbf, 0xfa, 0xbf, 0xaa, 0x56, 0x91, 0x22, 0x00, 0x00, 0x5f, 0x91, 0x25, 0x00, 0x00, 0x5f, 0x91, 0x25, 0x00, 0x00, 0x6f, 0x91, 0x28, 0x00, 0x00, 0x05, 0x00, 0x00, 0x54, 0x05, 0x54, 0x7f, 0xf5, 0x0b, 0x0a, 0x00, 0x00, 0xa8, 0x0a, 0xa8, 0xbf, 0xfa, 0xab, 0xaa, 0xaa, 0x82, 0xaa, 0x00, 0xa0, 0xaa, 0x55, 0x41, 0x55, 0x00, 0xa0, 0x02, 0x40, 0xf5, 0x57, 0xbf, 0x40, 0xfc, 0xd0, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd4, 0xfc, 0xfc, 0xda, 0x02, 0xde, 0xe4, 0x02, 0xdc, 0xfc, 0xfc, 0xfc, 0xfc, 0xd0, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd4, 0xfc, 0xda, 0x09, 0xdc, 0xfc, 0xfc, 0xda, 0x02, 0xde, 0xe4, 0x02, 0xdc, 0xfc, 0xfc, 0xfc, 0xfc, 0xda, 0x08, 0xdc, 0xfc, 0xda, 0x02, 0xe6, 0xe8, 0xe8, 0xe8, 0xe8, 0xea, 0x02, 0xe7, 0xd2, 0xd2, 0xeb, 0x02, 0xde, 0xe4, 0x02, 0xe7, 0xd2, 0xd2, 0xd2, 0xd2, 0xeb, 0x02, 0xe6, 0xe8, 0xe8, 0xe8, 0xea, 0x02, 0xdc, 0xfc, 0xda, 0x02, 0xe7, 0xe9, 0xe9, 0xe9, 0xf5, 0xe4, 0x07, 0xde, 0xe4, 0x09, 0xde, 0xf3, 0xe9, 0xe9, 0xeb, 0x02, 0xdc, 0xfc, 0xda, 0x06, 0xde, 0xe4, 0x02, 0xe6, 0xea, 0x02, 0xe6, 0xe8, 0xf4, 0xf2, 0xe8, 0xea, 0x02, 0xe6, 0xe8, 0xe8, 0xea, 0x02, 0xde, 0xe4, 0x05, 0xdc, 0xfc, 0xda, 0x02, 0xe6, 0xe8, 0xea, 0x02, 0xe7, 0xeb, 0x02, 0xde, 0xe4, 0x02, 0xe7, 0xe9, 0xe9, 0xe9, 0xe9, 0xeb, 0x02, 0xe7, 0xe9, 0xf5, 0xe4, 0x02, 0xe7, 0xeb, 0x02, 0xe6, 0xea, 0x02, 0xdc, 0xfc, 0xda, 0x02, 0xde, 0xc0, 0xe4, 0x05, 0xde, 0xe4, 0x0b, 0xde, 0xe4, 0x05, 0xde, 0xe4, 0x02, 0xdc, 0xfc, 0xda, 0x02, 0xde, 0xc0, 0xe4, 0x02, 0xe6, 0xe8, 0xe8, 0xf4, 0xf2, 0xe8, 0xe8, 0xea, 0x02, 0xe6, 0xe8, 0xe8, 0xe8, 0xea, 0x02, 0xde, 0xe4, 0x02, 0xe6, 0xe8, 0xe8, 0xf4, 0xe4, 0x02, 0xdc, 0xfc, 0xda, 0x02, 0xe7, 0xe9, 0xeb, 0x02, 0xe7, 0xe9, 0xe9, 0xf5, 0xf3, 0xe9, 0xe9, 0xeb, 0x02, 0xe7, 0xe9, 0xe9, 0xf5, 0xe4, 0x02, 0xe7, 0xeb, 0x02, 0xe7, 0xe9, 0xe9, 0xf5, 0xe4, 0x02, 0xdc, 0xfc, 0xda, 0x09, 0xde, 0xe4, 0x08, 0xde, 0xe4, 0x08, 0xde, 0xe4, 0x02, 0xdc, 0xfc, 0xda, 0x02, 0xe6, 0xe8, 0xe8, 0xe8, 0xe8, 0xea, 0x02, 0xde, 0xe4, 0x02, 0xec, 0xd3, 0xd3, 0xd3, 0xee, 0x02, 0xde, 0xe4, 0x02, 0xe6, 0xe8, 0xe8, 0xe8, 0xea, 0x02, 0xde, 0xe4, 0x02, 0xdc, 0xfc, 0xda, 0x02, 0xde, 0xf3, 0xe9, 0xe9, 0xe9, 0xeb, 0x02, 0xe7, 0xeb, 0x02, 0xdc, 0xfc, 0xfc, 0xfc, 0xda, 0x02, 0xe7, 0xeb, 0x02, 0xe7, 0xe9, 0xe9, 0xf5, 0xe4, 0x02, 0xe7, 0xeb, 0x02, 0xdc, 0xfc, 0xda, 0x02, 0xde, 0xe4, 0x09, 0xf0, 0xfc, 0xfc, 0xfc, 0xda, 0x08, 0xde, 0xe4, 0x05, 0xdc, 0xfc, 0xda, 0x02, 0xde, 0xe4, 0x02, 0xe6, 0xe8, 0xe8, 0xe8, 0xe8, 0xea, 0x02, 0xce, 0xfc, 0xfc, 0xfc, 0xda, 0x02, 0xe6, 0xe8, 0xe8, 0xe8, 0xea, 0x02, 0xde, 0xe4, 0x02, 0xe6, 0xe8, 0xe8, 0xf4, 0x00, 0x00, 0x00, 0x00, 0x62, 0x01, 0x02, 0x01, 0x01, 0x01, 0x01, 0x0f, 0x01, 0x01, 0x01, 0x02, 0x01, 0x04, 0x07, 0x0f, 0x06, 0x04, 0x07, 0x01, 0x01, 0x01, 0x07, 0x01, 0x01, 0x01, 0x01, 0x01, 0x06, 0x04, 0x01, 0x01, 0x01, 0x01, 0x03, 0x03, 0x07, 0x05, 0x03, 0x01, 0x01, 0x01, 0x04, 0x04, 0x03, 0x03, 0x07, 0x05, 0x03, 0x03, 0x04, 0x04, 0x01, 0x01, 0x01, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x03, 0x01, 0x01, 0x01, 0x03, 0x04, 0x04, 0x0f, 0x03, 0x06, 0x04, 0x04, 0x0f, 0x03, 0x06, 0x04, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x0c, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x03, 0x04, 0x07, 0x12, 0x03, 0x04, 0x07, 0x12, 0x03, 0x04, 0x03, 0x01, 0x01, 0x01, 0x01, 0x12, 0x01, 0x01, 0x01, 0x04, 0x03, 0x16, 0x07, 0x03, 0x16, 0x07, 0x03, 0x01, 0x01, 0x01, 0x01, 0x12, 0x01, 0x01, 0x01, 0x04, 0x07, 0x12, 0x03, 0x04, 0x07, 0x12, 0x03, 0x04, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x0c, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x03, 0x04, 0x04, 0x0f, 0x03, 0x06, 0x04, 0x04, 0x0f, 0x03, 0x06, 0x04, 0x04, 0x01, 0x01, 0x01, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x03, 0x01, 0x01, 0x01, 0x03, 0x04, 0x04, 0x03, 0x03, 0x07, 0x05, 0x03, 0x03, 0x04, 0x01, 0x01, 0x01, 0x01, 0x03, 0x03, 0x07, 0x05, 0x03, 0x01, 0x01, 0x01, 0x04, 0x07, 0x01, 0x01, 0x01, 0x07, 0x01, 0x01, 0x01, 0x01, 0x01, 0x06, 0x04, 0x07, 0x0f, 0x06, 0x04, 0x01, 0x02, 0x01, 0x01, 0x01, 0x01, 0x0f, 0x01, 0x01, 0x01, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xee, 0x64, 0x40, 0x7c, 0x40, 0x84, 0x43, 0x9c, 0x43, 0x1d, 0x22, 0x40, 0x20, 0x1d, 0x39, 0x40, 0x3b, 0x1e, 0x94, 0x14, 0x8c, 0x0c, 0x23, 0x94, 0x1d, 0x8c, 0xf4, 0x2b, 0x94, 0x2a, 0x74, 0xf4, 0x36, 0x94, 0x15, 0x74, 0x0c, 0x80, 0xaa, 0xbe, 0xfa, 0xaa, 0x00, 0x50, 0xfd, 0x55, 0xf5, 0xd5, 0x57, 0x55, 0xea, 0xff, 0x57, 0xd5, 0x5f, 0xfd, 0x15, 0x50, 0x01, 0x50, 0x55, 0xea, 0xaf, 0xfe, 0x2a, 0xa8, 0xaa, 0x50, 0x94, 0x15, 0x00, 0x00, 0x56, 0x94, 0x18, 0x00, 0x00, 0x5c, 0x94, 0x19, 0x00, 0x00, 0x63, 0x94, 0x1c, 0x00, 0x00, 0x55, 0x50, 0x41, 0x55, 0xfd, 0xaa, 0xaa, 0xa0, 0x82, 0xaa, 0xfe, 0xaa, 0xaa, 0xaf, 0x02, 0x2a, 0xa0, 0xaa, 0xaa, 0x55, 0x5f, 0x01, 0x00, 0x50, 0x55, 0xbf }; // From 0x9474 to 0x947b (8 byte(s)) static const UINT8 sg_u8Region168[0x0008] = { 0xc1, 0x88, 0xae, 0x8b, 0xa8, 0x8e, 0x79, 0x91 }; // From 0x9499 to 0x94a0 (8 byte(s)) static const UINT8 sg_u8Region169[0x0008] = { 0x3b, 0x8a, 0x27, 0x8d, 0x18, 0x90, 0xec, 0x92 }; // From 0x94df to 0x94eb (13 byte(s)) // Region 0x94df to 0x94eb (13 byte(s)) collapsed to 0x94e1 to 0x94eb (11 byte(s)) static const UINT8 sg_u8Region170[0x000b] = { 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03 }; // From 0x951c to 0x9523 (8 byte(s)) static const UINT8 sg_u8Region171[0x0008] = { 0x35, 0x8b, 0x20, 0x8e, 0x12, 0x91, 0xfa, 0x93 }; // From 0x9578 to 0x957f (8 byte(s)) static const UINT8 sg_u8Region172[0x0008] = { 0x2d, 0x8b, 0x18, 0x8e, 0x0a, 0x91, 0x02, 0x94 }; // From 0x95ae to 0x95c2 (21 byte(s)) static const UINT8 sg_u8Region173[0x0015] = { 0x1d, 0x1d, 0x16, 0x16, 0x16, 0x14, 0x14, 0x14, 0x14, 0x07, 0x07, 0x07, 0x07, 0x18, 0x18, 0x18, 0x18, 0x1d, 0x1d, 0x1d, 0x1d }; // From 0x9616 to 0x9617 (2 byte(s)) static const UINT8 sg_u8Region174[0x0002] = { 0x09, 0x20 }; // From 0x9643 to 0x9644 (2 byte(s)) static const UINT8 sg_u8Region175[0x0002] = { 0x1c, 0x13 }; // From 0x9646 to 0x9647 (2 byte(s)) static const UINT8 sg_u8Region176[0x0002] = { 0x1c, 0x35 }; // From 0x967d to 0x9796 (282 byte(s)) static const UINT8 sg_u8Region177[0x011a] = { 0x95, 0x96, 0xd6, 0x96, 0x58, 0x3c, 0x4f, 0x97, 0xb6, 0x96, 0x19, 0x97, 0xd4, 0x3b, 0x72, 0x97, 0x96, 0x97, 0x96, 0x97, 0x96, 0x97, 0x96, 0x97, 0xf1, 0x00, 0xf2, 0x02, 0xf3, 0x0a, 0xf4, 0x00, 0x41, 0x43, 0x45, 0x86, 0x8a, 0x88, 0x8b, 0x6a, 0x6b, 0x71, 0x6a, 0x88, 0x8b, 0x6a, 0x6b, 0x71, 0x6a, 0x6b, 0x71, 0x73, 0x75, 0x96, 0x95, 0x96, 0xff, 0xf1, 0x02, 0xf2, 0x03, 0xf3, 0x0a, 0xf4, 0x02, 0x50, 0x70, 0x86, 0x90, 0x81, 0x90, 0x86, 0x90, 0x68, 0x6a, 0x6b, 0x68, 0x6a, 0x68, 0x66, 0x6a, 0x68, 0x66, 0x65, 0x68, 0x86, 0x81, 0x86, 0xff, 0xf1, 0x00, 0xf2, 0x02, 0xf3, 0x0a, 0xf4, 0x00, 0x69, 0x6b, 0x69, 0x86, 0x61, 0x64, 0x65, 0x86, 0x86, 0x64, 0x66, 0x64, 0x61, 0x69, 0x6b, 0x69, 0x86, 0x61, 0x64, 0x64, 0xa1, 0x70, 0x71, 0x74, 0x75, 0x35, 0x76, 0x30, 0x50, 0x35, 0x76, 0x30, 0x50, 0x54, 0x56, 0x54, 0x51, 0x6b, 0x69, 0x6b, 0x69, 0x6b, 0x91, 0x6b, 0x69, 0x66, 0xf2, 0x01, 0x74, 0x76, 0x74, 0x71, 0x74, 0x71, 0x6b, 0x69, 0xa6, 0xa6, 0xff, 0xf1, 0x03, 0xf2, 0x03, 0xf3, 0x0a, 0xf4, 0x02, 0x70, 0x66, 0x70, 0x46, 0x50, 0x86, 0x90, 0x70, 0x66, 0x70, 0x46, 0x50, 0x86, 0x90, 0x70, 0x66, 0x70, 0x46, 0x50, 0x86, 0x90, 0x70, 0x61, 0x70, 0x41, 0x50, 0x81, 0x90, 0xf4, 0x00, 0xa6, 0xa4, 0xa2, 0xa1, 0xf4, 0x01, 0x86, 0x89, 0x8b, 0x81, 0x74, 0x71, 0x6b, 0x69, 0xa6, 0xff, 0xf1, 0x00, 0xf2, 0x02, 0xf3, 0x0a, 0xf4, 0x00, 0x65, 0x64, 0x65, 0x88, 0x67, 0x88, 0x61, 0x63, 0x64, 0x85, 0x64, 0x85, 0x6a, 0x69, 0x6a, 0x8c, 0x75, 0x93, 0x90, 0x91, 0x90, 0x91, 0x70, 0x8a, 0x68, 0x71, 0xff, 0xf1, 0x02, 0xf2, 0x03, 0xf3, 0x0a, 0xf4, 0x02, 0x65, 0x90, 0x68, 0x70, 0x68, 0x67, 0x66, 0x65, 0x90, 0x61, 0x70, 0x61, 0x65, 0x68, 0x66, 0x90, 0x63, 0x90, 0x86, 0x90, 0x85, 0x90, 0x85, 0x70, 0x86, 0x68, 0x65, 0xff, 0xff }; // From 0x97c4 to 0x9fff (2108 byte(s)) static const UINT8 sg_u8Region178[0x083c] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x47, 0x45, 0x4e, 0x45, 0x52, 0x41, 0x4c, 0x20, 0x43, 0x4f, 0x4d, 0x50, 0x55, 0x54, 0x45, 0x52, 0x20, 0x20, 0x43, 0x4f, 0x52, 0x50, 0x4f, 0x52, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x20, 0x20, 0x20, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x2c, 0x20, 0x4e, 0x61, 0x6b, 0x61, 0x6d, 0x75, 0x72, 0x61, 0x21, 0x82, 0x8b, 0x73, 0x8e, 0x42, 0x91, 0x3c, 0x94, 0xfa, 0xff, 0x55, 0x55, 0x01, 0x80, 0xaa, 0x02, 0x3e, 0x00, 0x32, 0x0d, 0x4c, 0xc3, 0x00, 0x10, 0xf5, 0xed, 0x5b, 0xd2, 0x4d, 0x7c, 0x92, 0xc6, 0x03, 0xfe, 0x06, 0x30, 0x18, 0x7d, 0x93, 0xc6, 0x03, 0xfe, 0x06, 0x30, 0x10, 0x3e, 0x01, 0x32, 0x0d, 0x4c, 0xf1, 0xc6, 0x02, 0x32, 0x0c, 0x4c, 0xd6, 0x02, 0xc3, 0xb2, 0x19, 0xf1, 0xc3, 0xcd, 0x19, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0xff, 0xfe, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xfe, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x01, 0xff, 0x01, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x40, 0xfc, 0xd0, 0xd2, 0xd2, 0xd2, 0xd2, 0xd4, 0xfc, 0xda, 0x02, 0xdc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xda, 0x02, 0xdc, 0xfc, 0xfc, 0xfc, 0xd0, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd4, 0xfc, 0xda, 0x05, 0xdc, 0xfc, 0xda, 0x02, 0xdc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xda, 0x02, 0xdc, 0xfc, 0xfc, 0xfc, 0xda, 0x08, 0xdc, 0xfc, 0xda, 0x02, 0xe6, 0xea, 0x02, 0xe7, 0xd2, 0xeb, 0x02, 0xe7, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xeb, 0x02, 0xe7, 0xd2, 0xd2, 0xd2, 0xeb, 0x02, 0xe6, 0xe8, 0xe8, 0xe8, 0xea, 0x02, 0xdc, 0xfc, 0xda, 0x02, 0xde, 0xe4, 0x15, 0xde, 0xc0, 0xc0, 0xc0, 0xe4, 0x02, 0xdc, 0xfc, 0xda, 0x02, 0xde, 0xe4, 0x02, 0xe6, 0xe8, 0xe8, 0xe8, 0xe8, 0xea, 0x02, 0xe6, 0xe8, 0xe8, 0xe8, 0xea, 0x02, 0xe6, 0xea, 0x02, 0xe6, 0xea, 0x02, 0xde, 0xc0, 0xc0, 0xc0, 0xe4, 0x02, 0xdc, 0xfc, 0xda, 0x02, 0xe7, 0xeb, 0x02, 0xe7, 0xe9, 0xe9, 0xe9, 0xf5, 0xe4, 0x02, 0xde, 0xf3, 0xe9, 0xe9, 0xeb, 0x02, 0xde, 0xe4, 0x02, 0xde, 0xe4, 0x02, 0xe7, 0xe9, 0xe9, 0xe9, 0xeb, 0x02, 0xdc, 0xfc, 0xda, 0x09, 0xde, 0xe4, 0x02, 0xde, 0xe4, 0x05, 0xde, 0xe4, 0x02, 0xde, 0xe4, 0x08, 0xdc, 0xfc, 0xfa, 0xe8, 0xe8, 0xea, 0x02, 0xe6, 0xe8, 0xea, 0x02, 0xde, 0xe4, 0x02, 0xde, 0xe4, 0x02, 0xe6, 0xe8, 0xe8, 0xf4, 0xe4, 0x02, 0xde, 0xe4, 0x02, 0xe6, 0xe8, 0xe8, 0xe8, 0xea, 0x02, 0xdc, 0xfc, 0xfb, 0xe9, 0xe9, 0xeb, 0x02, 0xde, 0xc0, 0xe4, 0x02, 0xe7, 0xeb, 0x02, 0xe7, 0xeb, 0x02, 0xe7, 0xe9, 0xe9, 0xf5, 0xe4, 0x02, 0xe7, 0xeb, 0x02, 0xde, 0xf3, 0xe9, 0xe9, 0xeb, 0x02, 0xdc, 0xfc, 0xda, 0x05, 0xde, 0xc0, 0xe4, 0x0b, 0xde, 0xe4, 0x05, 0xde, 0xe4, 0x05, 0xdc, 0xfc, 0xda, 0x02, 0xe6, 0xea, 0x02, 0xde, 0xc0, 0xe4, 0x02, 0xe6, 0xea, 0x02, 0xec, 0xd3, 0xd3, 0xd3, 0xee, 0x02, 0xde, 0xe4, 0x02, 0xe6, 0xea, 0x02, 0xde, 0xe4, 0x02, 0xe6, 0xea, 0x02, 0xdc, 0xfc, 0xda, 0x02, 0xde, 0xe4, 0x02, 0xe7, 0xe9, 0xeb, 0x02, 0xde, 0xe4, 0x02, 0xdc, 0xfc, 0xfc, 0xfc, 0xda, 0x02, 0xe7, 0xeb, 0x02, 0xde, 0xe4, 0x02, 0xe7, 0xeb, 0x02, 0xde, 0xe4, 0x02, 0xdc, 0xfc, 0xda, 0x02, 0xde, 0xe4, 0x06, 0xde, 0xe4, 0x02, 0xf0, 0xfc, 0xfc, 0xfc, 0xda, 0x05, 0xde, 0xe4, 0x05, 0xde, 0xe4, 0x02, 0xdc, 0xfc, 0xda, 0x02, 0xde, 0xe4, 0x02, 0xe6, 0xe8, 0xe8, 0xe8, 0xf4, 0xe4, 0x02, 0xce, 0xfc, 0xfc, 0xfc, 0xda, 0x02, 0xe6, 0xe8, 0xe8, 0xf4, 0xe4, 0x02, 0xe6, 0xe8, 0xe8, 0xf4, 0xe4, 0x02, 0xdc, 0x00, 0x62, 0x02, 0x01, 0x13, 0x01, 0x01, 0x01, 0x02, 0x01, 0x04, 0x03, 0x13, 0x06, 0x04, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x06, 0x04, 0x03, 0x10, 0x03, 0x06, 0x04, 0x03, 0x10, 0x03, 0x06, 0x04, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x0c, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x07, 0x04, 0x0c, 0x03, 0x06, 0x07, 0x04, 0x0c, 0x03, 0x06, 0x04, 0x01, 0x01, 0x01, 0x04, 0x0c, 0x01, 0x01, 0x01, 0x03, 0x01, 0x01, 0x01, 0x04, 0x03, 0x04, 0x0f, 0x03, 0x03, 0x04, 0x03, 0x04, 0x0f, 0x03, 0x03, 0x04, 0x03, 0x01, 0x01, 0x01, 0x01, 0x0f, 0x01, 0x01, 0x01, 0x03, 0x04, 0x03, 0x19, 0x04, 0x03, 0x19, 0x04, 0x03, 0x01, 0x01, 0x01, 0x01, 0x0f, 0x01, 0x01, 0x01, 0x03, 0x04, 0x03, 0x04, 0x0f, 0x03, 0x03, 0x04, 0x03, 0x04, 0x0f, 0x03, 0x03, 0x04, 0x01, 0x01, 0x01, 0x04, 0x0c, 0x01, 0x01, 0x01, 0x03, 0x01, 0x01, 0x01, 0x07, 0x04, 0x0c, 0x03, 0x06, 0x07, 0x04, 0x0c, 0x03, 0x06, 0x04, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x0c, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x04, 0x03, 0x10, 0x03, 0x06, 0x04, 0x03, 0x10, 0x03, 0x06, 0x04, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x06, 0x04, 0x03, 0x13, 0x06, 0x04, 0x02, 0x01, 0x13, 0x01, 0x01, 0x01, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x1d, 0x22, 0x1d, 0x39, 0x40, 0x20, 0x40, 0x3b, 0x63, 0x40, 0x7c, 0x40, 0x83, 0x43, 0x9c, 0x43, 0x49, 0x09, 0x17, 0x09, 0x17, 0x09, 0x0e, 0xe0, 0xe0, 0xe0, 0x29, 0x09, 0x17, 0x09, 0x17, 0x09, 0x00, 0x00, 0x63, 0x8b, 0x13, 0x94, 0x0c, 0x68, 0x8b, 0x22, 0x94, 0xf4, 0x71, 0x8b, 0x27, 0x4c, 0xf4, 0x7b, 0x8b, 0x1c, 0x4c, 0x0c, 0x80, 0xaa, 0xaa, 0xbf, 0xaa, 0x80, 0x0a, 0x54, 0x55, 0x55, 0x55, 0xff, 0x5f, 0x55, 0xea, 0xff, 0x57, 0x55, 0xf5, 0x57, 0xff, 0x15, 0x40, 0x55, 0xea, 0xaf, 0x02, 0xea, 0xff, 0xff, 0xaa, 0x94, 0x8b, 0x14, 0x00, 0x00, 0x99, 0x8b, 0x17, 0x00, 0x00, 0x9f, 0x8b, 0x1a, 0x00, 0x00, 0xa6, 0x8b, 0x1d, 0x55, 0x40, 0x55, 0x55, 0xbf, 0xaa, 0x80, 0xaa, 0xaa, 0xbf, 0xaa, 0xaa, 0x80, 0xaa, 0x02, 0x80, 0xaa, 0xaa, 0x55, 0x00, 0x00, 0x00, 0x55, 0x55, 0xfd, 0xaa, 0x40, 0xfc, 0xda, 0x02, 0xde, 0xd8, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd6, 0xd8, 0xd2, 0xd2, 0xd2, 0xd2, 0xd4, 0xfc, 0xfc, 0xfc, 0xfc, 0xda, 0x02, 0xde, 0xd8, 0xd2, 0xd2, 0xd2, 0xd2, 0xd4, 0xfc, 0xda, 0x02, 0xde, 0xe4, 0x08, 0xde, 0xe4, 0x05, 0xdc, 0xfc, 0xfc, 0xfc, 0xfc, 0xda, 0x02, 0xde, 0xe4, 0x05, 0xdc, 0xfc, 0xda, 0x02, 0xde, 0xe4, 0x02, 0xe6, 0xe8, 0xe8, 0xe8, 0xea, 0x02, 0xde, 0xe4, 0x02, 0xe6, 0xea, 0x02, 0xe7, 0xd2, 0xd2, 0xd2, 0xd2, 0xeb, 0x02, 0xe7, 0xeb, 0x02, 0xe6, 0xea, 0x02, 0xdc, 0xfc, 0xda, 0x02, 0xde, 0xe4, 0x02, 0xde, 0xf3, 0xe9, 0xe9, 0xeb, 0x02, 0xde, 0xe4, 0x02, 0xde, 0xe4, 0x0c, 0xde, 0xe4, 0x02, 0xdc, 0xfc, 0xda, 0x02, 0xde, 0xe4, 0x02, 0xde, 0xe4, 0x05, 0xde, 0xe4, 0x02, 0xde, 0xf2, 0xe8, 0xe8, 0xe8, 0xea, 0x02, 0xe6, 0xea, 0x02, 0xe6, 0xe8, 0xe8, 0xf4, 0xe4, 0x02, 0xdc, 0xfc, 0xda, 0x02, 0xe7, 0xeb, 0x02, 0xde, 0xe4, 0x02, 0xe6, 0xea, 0x02, 0xe7, 0xeb, 0x02, 0xe7, 0xe9, 0xe9, 0xe9, 0xe9, 0xeb, 0x02, 0xde, 0xe4, 0x02, 0xe7, 0xe9, 0xe9, 0xe9, 0xeb, 0x02, 0xdc, 0xfc, 0xda, 0x05, 0xde, 0xe4, 0x02, 0xde, 0xe4, 0x0c, 0xde, 0xe4, 0x08, 0xdc, 0xfc, 0xfa, 0xe8, 0xe8, 0xea, 0x02, 0xde, 0xe4, 0x02, 0xde, 0xf2, 0xe8, 0xe8, 0xe8, 0xe8, 0xea, 0x02, 0xe6, 0xe8, 0xe8, 0xea, 0x02, 0xde, 0xf2, 0xe8, 0xe8, 0xea, 0x02, 0xe6, 0xea, 0x02, 0xdc, 0xfc, 0xfb, 0xe9, 0xe9, 0xeb, 0x02, 0xe7, 0xeb, 0x02, 0xe7, 0xe9, 0xe9, 0xe9, 0xe9, 0xe9, 0xeb, 0x02, 0xe7, 0xe9, 0xf5, 0xe4, 0x02, 0xde, 0xf3, 0xe9, 0xe9, 0xeb, 0x02, 0xde, 0xe4, 0x02, 0xdc, 0xfc, 0xda, 0x12, 0xde, 0xe4, 0x02, 0xde, 0xe4, 0x05, 0xde, 0xe4, 0x02, 0xdc, 0xfc, 0xda, 0x02, 0xe6, 0xea, 0x02, 0xe6, 0xe8, 0xe8, 0xe8, 0xe8, 0xea, 0x02, 0xec, 0xd3, 0xd3, 0xd3, 0xee, 0x02, 0xe7, 0xeb, 0x02, 0xe7, 0xeb, 0x02, 0xe6, 0xea, 0x02, 0xde, 0xe4, 0x02, 0xdc, 0xfc, 0xda, 0x02, 0xde, 0xe4, 0x02, 0xe7, 0xe9, 0xe9, 0xe9, 0xf5, 0xe4, 0x02, 0xdc, 0xfc, 0xfc, 0xfc, 0xda, 0x08, 0xde, 0xe4, 0x02, 0xe7, 0xeb, 0x02, 0xdc, 0xfc, 0xda, 0x02, 0xde, 0xe4, 0x06, 0xde, 0xe4, 0x02, 0xf0, 0xfc, 0xfc, 0xfc, 0xda, 0x02, 0xe6, 0xe8, 0xe8, 0xe8, 0xea, 0x02, 0xde, 0xe4, 0x05, 0xdc, 0xfc, 0xda, 0x02, 0xde, 0xf2, 0xe8, 0xe8, 0xe8, 0xea, 0x02, 0xde, 0xe4, 0x02, 0xce, 0xfc, 0xfc, 0xfc, 0xda, 0x02, 0xde, 0xc0, 0xc0, 0xc0, 0xe4, 0x02, 0xde, 0xf2, 0xe8, 0xe8, 0xea, 0x02, 0xdc, 0x00, 0x00, 0x00, 0x00, 0x66, 0x01, 0x01, 0x01, 0x01, 0x01, 0x03, 0x01, 0x01, 0x01, 0x0b, 0x01, 0x01, 0x07, 0x06, 0x03, 0x03, 0x0a, 0x03, 0x07, 0x06, 0x03, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x03, 0x07, 0x03, 0x01, 0x01, 0x01, 0x03, 0x07, 0x03, 0x06, 0x07, 0x03, 0x03, 0x03, 0x07, 0x03, 0x06, 0x07, 0x03, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x07, 0x03, 0x0d, 0x06, 0x03, 0x07, 0x03, 0x0d, 0x06, 0x03, 0x04, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x0d, 0x03, 0x01, 0x01, 0x01, 0x03, 0x04, 0x03, 0x10, 0x03, 0x03, 0x03, 0x04, 0x03, 0x10, 0x01, 0x01, 0x01, 0x03, 0x03, 0x04, 0x03, 0x01, 0x01, 0x01, 0x01, 0x12, 0x01, 0x01, 0x01, 0x04, 0x07, 0x15, 0x04, 0x07, 0x15, 0x04, 0x03, 0x01, 0x01, 0x01, 0x01, 0x12, 0x01, 0x01, 0x01, 0x04, 0x03, 0x10, 0x01, 0x01, 0x01, 0x03, 0x03, 0x04, 0x03, 0x10, 0x03, 0x03, 0x03, 0x04, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x0d, 0x03, 0x01, 0x01, 0x01, 0x03, 0x07, 0x03, 0x0d, 0x06, 0x03, 0x07, 0x03, 0x0d, 0x06, 0x03, 0x07, 0x03, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x07, 0x03, 0x03, 0x03, 0x07, 0x03, 0x06, 0x07, 0x03, 0x01, 0x01, 0x01, 0x03, 0x07, 0x03, 0x06, 0x07, 0x06, 0x03, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x03, 0x07, 0x06, 0x03, 0x03, 0x0a, 0x03, 0x08, 0x01, 0x01, 0x01, 0x01, 0x01, 0x03, 0x01, 0x01, 0x01, 0x0b, 0x01, 0x01, 0xf4, 0x1d, 0x22, 0x1d, 0x39, 0x40, 0x20, 0x40, 0x3b, 0x65, 0x40, 0x7b, 0x40, 0x85, 0x43, 0x9b, 0x43, 0x42, 0x16, 0x0a, 0x16, 0x0a, 0x16, 0x0a, 0x20, 0x20, 0x20, 0xde, 0xe0, 0x22, 0x20, 0x20, 0x20, 0x20, 0x16, 0x0a, 0x16, 0x0a, 0x16, 0x00, 0x00, 0x54, 0x8e, 0x13, 0xc4, 0x0c, 0x59, 0x8e, 0x1e, 0xc4, 0xf4, 0x61, 0x8e, 0x26, 0x14, 0xf4, 0x6b, 0x8e, 0x1d, 0x14, 0x0c, 0x02, 0xaa, 0xaa, 0x80, 0x2a, 0x02, 0x40, 0x55, 0x7f, 0x55, 0x15, 0x50, 0x05, 0xea, 0xff, 0x57, 0x55, 0xf5, 0xff, 0x57, 0x7f, 0x55, 0x05, 0xea, 0xff, 0xff, 0xff, 0xea, 0xaf, 0xaa, 0x02, 0x87, 0x8e, 0x12, 0x00, 0x00, 0x8c, 0x8e, 0x1d, 0x00, 0x00, 0x94, 0x8e, 0x21, 0x00, 0x00, 0x9d, 0x8e, 0x2c, 0x00, 0x00, 0x55, 0x7f, 0x55, 0xd5, 0xff, 0xaa, 0xbf, 0xaa, 0x2a, 0xa0, 0xea, 0xff, 0xff, 0xaa, 0x2a, 0xa0, 0x02, 0x00, 0x00, 0xa0, 0xaa, 0x02, 0x55, 0x15, 0xa0, 0x2a, 0x00, 0x54, 0x05, 0x00, 0x00, 0x55, 0xfd, 0x40, 0xfc, 0xd0, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd6, 0xe4, 0x02, 0xe7, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd6, 0xd8, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd4, 0xfc, 0xda, 0x07, 0xde, 0xe4, 0x0d, 0xde, 0xe4, 0x08, 0xdc, 0xfc, 0xda, 0x02, 0xe6, 0xe8, 0xe8, 0xea, 0x02, 0xde, 0xe4, 0x02, 0xe6, 0xe8, 0xe8, 0xea, 0x02, 0xe6, 0xe8, 0xe8, 0xe8, 0xea, 0x02, 0xe7, 0xeb, 0x02, 0xe6, 0xea, 0x02, 0xe6, 0xea, 0x02, 0xdc, 0xfc, 0xda, 0x02, 0xde, 0xf3, 0xe9, 0xeb, 0x02, 0xe7, 0xeb, 0x02, 0xe7, 0xe9, 0xf5, 0xe4, 0x02, 0xe7, 0xe9, 0xe9, 0xf5, 0xe4, 0x05, 0xde, 0xe4, 0x02, 0xde, 0xe4, 0x02, 0xdc, 0xfc, 0xda, 0x02, 0xde, 0xe4, 0x09, 0xde, 0xe4, 0x05, 0xde, 0xe4, 0x02, 0xe6, 0xe8, 0xe8, 0xf4, 0xe4, 0x02, 0xde, 0xe4, 0x02, 0xdc, 0xfc, 0xda, 0x02, 0xde, 0xe4, 0x02, 0xe6, 0xe8, 0xe8, 0xe8, 0xe8, 0xea, 0x02, 0xe7, 0xeb, 0x02, 0xe6, 0xea, 0x02, 0xe7, 0xeb, 0x02, 0xe7, 0xe9, 0xe9, 0xe9, 0xeb, 0x02, 0xe7, 0xeb, 0x02, 0xdc, 0xfc, 0xda, 0x02, 0xde, 0xe4, 0x02, 0xe7, 0xe9, 0xe9, 0xe9, 0xf5, 0xe4, 0x05, 0xde, 0xe4, 0x0e, 0xdc, 0xfc, 0xda, 0x02, 0xde, 0xe4, 0x06, 0xde, 0xe4, 0x02, 0xe6, 0xe8, 0xe8, 0xf4, 0xe4, 0x02, 0xe6, 0xe8, 0xe8, 0xe8, 0xea, 0x02, 0xe6, 0xe8, 0xe8, 0xe8, 0xe8, 0xe8, 0xf4, 0xfc, 0xda, 0x02, 0xe7, 0xeb, 0x02, 0xe6, 0xe8, 0xea, 0x02, 0xe7, 0xeb, 0x02, 0xe7, 0xe9, 0xe9, 0xe9, 0xeb, 0x02, 0xde, 0xf3, 0xe9, 0xe9, 0xeb, 0x02, 0xde, 0xf3, 0xe9, 0xe9, 0xe9, 0xe9, 0xf5, 0xfc, 0xda, 0x05, 0xde, 0xc0, 0xe4, 0x0b, 0xde, 0xe4, 0x05, 0xde, 0xe4, 0x05, 0xdc, 0xfc, 0xfa, 0xe8, 0xe8, 0xea, 0x02, 0xde, 0xc0, 0xe4, 0x02, 0xe6, 0xea, 0x02, 0xec, 0xd3, 0xd3, 0xd3, 0xee, 0x02, 0xde, 0xe4, 0x02, 0xe6, 0xea, 0x02, 0xde, 0xe4, 0x02, 0xe6, 0xea, 0x02, 0xdc, 0xfc, 0xfb, 0xe9, 0xe9, 0xeb, 0x02, 0xe7, 0xe9, 0xeb, 0x02, 0xde, 0xe4, 0x02, 0xdc, 0xfc, 0xfc, 0xfc, 0xda, 0x02, 0xe7, 0xeb, 0x02, 0xde, 0xe4, 0x02, 0xe7, 0xeb, 0x02, 0xde, 0xe4, 0x02, 0xdc, 0xfc, 0xda, 0x09, 0xde, 0xe4, 0x02, 0xf0, 0xfc, 0xfc, 0xfc, 0xda, 0x05, 0xde, 0xe4, 0x05, 0xde, 0xe4, 0x02, 0xdc, 0xfc, 0xda, 0x02, 0xe6, 0xe8, 0xe8, 0xe8, 0xe8, 0xea, 0x02, 0xde, 0xe4 }; // Total data size is 11163 bytes UINT8 mem[0x10000]; void mspacman_init(void) { memset((void *) mem, 0, sizeof(mem)); memcpy((void *) &mem[0x3b], sg_u8Region0, sizeof(sg_u8Region0)); memcpy((void *) &mem[0x69], sg_u8Region1, sizeof(sg_u8Region1)); memcpy((void *) &mem[0x219], sg_u8Region2, sizeof(sg_u8Region2)); memcpy((void *) &mem[0x247], sg_u8Region3, sizeof(sg_u8Region3)); memcpy((void *) &mem[0x3cc], sg_u8Region4, sizeof(sg_u8Region4)); memcpy((void *) &mem[0x3d8], sg_u8Region5, sizeof(sg_u8Region5)); memcpy((void *) &mem[0x3e0], sg_u8Region6, sizeof(sg_u8Region6)); memcpy((void *) &mem[0x3e3], sg_u8Region7, sizeof(sg_u8Region7)); memcpy((void *) &mem[0x3e6], sg_u8Region8, sizeof(sg_u8Region8)); memcpy((void *) &mem[0x3e9], sg_u8Region9, sizeof(sg_u8Region9)); memcpy((void *) &mem[0x3ec], sg_u8Region10, sizeof(sg_u8Region10)); memcpy((void *) &mem[0x3ef], sg_u8Region11, sizeof(sg_u8Region11)); memcpy((void *) &mem[0x3f2], sg_u8Region12, sizeof(sg_u8Region12)); memcpy((void *) &mem[0x416], sg_u8Region13, sizeof(sg_u8Region13)); memcpy((void *) &mem[0x461], sg_u8Region14, sizeof(sg_u8Region14)); memcpy((void *) &mem[0x463], sg_u8Region15, sizeof(sg_u8Region15)); memcpy((void *) &mem[0x466], sg_u8Region16, sizeof(sg_u8Region16)); memcpy((void *) &mem[0x469], sg_u8Region17, sizeof(sg_u8Region17)); memcpy((void *) &mem[0x4d3], sg_u8Region18, sizeof(sg_u8Region18)); memcpy((void *) &mem[0x4ea], sg_u8Region19, sizeof(sg_u8Region19)); memcpy((void *) &mem[0x4ed], sg_u8Region20, sizeof(sg_u8Region20)); memcpy((void *) &mem[0x4f0], sg_u8Region21, sizeof(sg_u8Region21)); memcpy((void *) &mem[0x4f3], sg_u8Region22, sizeof(sg_u8Region22)); memcpy((void *) &mem[0x54b], sg_u8Region23, sizeof(sg_u8Region23)); memcpy((void *) &mem[0x580], sg_u8Region24, sizeof(sg_u8Region24)); memcpy((void *) &mem[0x59e], sg_u8Region25, sizeof(sg_u8Region25)); memcpy((void *) &mem[0x5e9], sg_u8Region26, sizeof(sg_u8Region26)); memcpy((void *) &mem[0x5f8], sg_u8Region27, sizeof(sg_u8Region27)); memcpy((void *) &mem[0x5fa], sg_u8Region28, sizeof(sg_u8Region28)); memcpy((void *) &mem[0x5fd], sg_u8Region29, sizeof(sg_u8Region29)); memcpy((void *) &mem[0x600], sg_u8Region30, sizeof(sg_u8Region30)); memcpy((void *) &mem[0x603], sg_u8Region31, sizeof(sg_u8Region31)); memcpy((void *) &mem[0x615], sg_u8Region32, sizeof(sg_u8Region32)); memcpy((void *) &mem[0x618], sg_u8Region33, sizeof(sg_u8Region33)); memcpy((void *) &mem[0x676], sg_u8Region34, sizeof(sg_u8Region34)); memcpy((void *) &mem[0x678], sg_u8Region35, sizeof(sg_u8Region35)); memcpy((void *) &mem[0x67b], sg_u8Region36, sizeof(sg_u8Region36)); memcpy((void *) &mem[0x67e], sg_u8Region37, sizeof(sg_u8Region37)); memcpy((void *) &mem[0x681], sg_u8Region38, sizeof(sg_u8Region38)); memcpy((void *) &mem[0x684], sg_u8Region39, sizeof(sg_u8Region39)); memcpy((void *) &mem[0x687], sg_u8Region40, sizeof(sg_u8Region40)); memcpy((void *) &mem[0x68a], sg_u8Region41, sizeof(sg_u8Region41)); memcpy((void *) &mem[0x68d], sg_u8Region42, sizeof(sg_u8Region42)); memcpy((void *) &mem[0x69d], sg_u8Region43, sizeof(sg_u8Region43)); memcpy((void *) &mem[0x6a0], sg_u8Region44, sizeof(sg_u8Region44)); memcpy((void *) &mem[0x6c2], sg_u8Region45, sizeof(sg_u8Region45)); memcpy((void *) &mem[0x796], sg_u8Region46, sizeof(sg_u8Region46)); memcpy((void *) &mem[0x843], sg_u8Region47, sizeof(sg_u8Region47)); memcpy((void *) &mem[0x8a6], sg_u8Region48, sizeof(sg_u8Region48)); memcpy((void *) &mem[0x8a9], sg_u8Region49, sizeof(sg_u8Region49)); memcpy((void *) &mem[0x8ac], sg_u8Region50, sizeof(sg_u8Region50)); memcpy((void *) &mem[0x8af], sg_u8Region51, sizeof(sg_u8Region51)); memcpy((void *) &mem[0x8b2], sg_u8Region52, sizeof(sg_u8Region52)); memcpy((void *) &mem[0x8b5], sg_u8Region53, sizeof(sg_u8Region53)); memcpy((void *) &mem[0x8b8], sg_u8Region54, sizeof(sg_u8Region54)); memcpy((void *) &mem[0x8bc], sg_u8Region55, sizeof(sg_u8Region55)); memcpy((void *) &mem[0x8db], sg_u8Region56, sizeof(sg_u8Region56)); memcpy((void *) &mem[0x937], sg_u8Region57, sizeof(sg_u8Region57)); memcpy((void *) &mem[0x93a], sg_u8Region58, sizeof(sg_u8Region58)); memcpy((void *) &mem[0x956], sg_u8Region59, sizeof(sg_u8Region59)); memcpy((void *) &mem[0x959], sg_u8Region60, sizeof(sg_u8Region60)); memcpy((void *) &mem[0x98a], sg_u8Region61, sizeof(sg_u8Region61)); memcpy((void *) &mem[0x98c], sg_u8Region62, sizeof(sg_u8Region62)); memcpy((void *) &mem[0x98f], sg_u8Region63, sizeof(sg_u8Region63)); memcpy((void *) &mem[0x992], sg_u8Region64, sizeof(sg_u8Region64)); memcpy((void *) &mem[0x995], sg_u8Region65, sizeof(sg_u8Region65)); memcpy((void *) &mem[0x998], sg_u8Region66, sizeof(sg_u8Region66)); memcpy((void *) &mem[0x99b], sg_u8Region67, sizeof(sg_u8Region67)); memcpy((void *) &mem[0x99e], sg_u8Region68, sizeof(sg_u8Region68)); memcpy((void *) &mem[0x9a1], sg_u8Region69, sizeof(sg_u8Region69)); memcpy((void *) &mem[0x9a4], sg_u8Region70, sizeof(sg_u8Region70)); memcpy((void *) &mem[0x9a7], sg_u8Region71, sizeof(sg_u8Region71)); memcpy((void *) &mem[0x9b1], sg_u8Region72, sizeof(sg_u8Region72)); memcpy((void *) &mem[0x9b4], sg_u8Region73, sizeof(sg_u8Region73)); memcpy((void *) &mem[0x9b7], sg_u8Region74, sizeof(sg_u8Region74)); memcpy((void *) &mem[0x9c1], sg_u8Region75, sizeof(sg_u8Region75)); memcpy((void *) &mem[0x9d9], sg_u8Region76, sizeof(sg_u8Region76)); memcpy((void *) &mem[0x9f0], sg_u8Region77, sizeof(sg_u8Region77)); memcpy((void *) &mem[0xa10], sg_u8Region78, sizeof(sg_u8Region78)); memcpy((void *) &mem[0xa12], sg_u8Region79, sizeof(sg_u8Region79)); memcpy((void *) &mem[0xa15], sg_u8Region80, sizeof(sg_u8Region80)); memcpy((void *) &mem[0xa18], sg_u8Region81, sizeof(sg_u8Region81)); memcpy((void *) &mem[0xa1b], sg_u8Region82, sizeof(sg_u8Region82)); memcpy((void *) &mem[0xa1e], sg_u8Region83, sizeof(sg_u8Region83)); memcpy((void *) &mem[0xa21], sg_u8Region84, sizeof(sg_u8Region84)); memcpy((void *) &mem[0xa24], sg_u8Region85, sizeof(sg_u8Region85)); memcpy((void *) &mem[0xa45], sg_u8Region86, sizeof(sg_u8Region86)); memcpy((void *) &mem[0xc24], sg_u8Region87, sizeof(sg_u8Region87)); memcpy((void *) &mem[0xef9], sg_u8Region88, sizeof(sg_u8Region88)); memcpy((void *) &mem[0xefe], sg_u8Region89, sizeof(sg_u8Region89)); memcpy((void *) &mem[0x1007], sg_u8Region90, sizeof(sg_u8Region90)); memcpy((void *) &mem[0x100e], sg_u8Region91, sizeof(sg_u8Region91)); memcpy((void *) &mem[0x1098], sg_u8Region92, sizeof(sg_u8Region92)); memcpy((void *) &mem[0x10a2], sg_u8Region93, sizeof(sg_u8Region93)); memcpy((void *) &mem[0x10ac], sg_u8Region94, sizeof(sg_u8Region94)); memcpy((void *) &mem[0x10b8], sg_u8Region95, sizeof(sg_u8Region95)); memcpy((void *) &mem[0x1239], sg_u8Region96, sizeof(sg_u8Region96)); memcpy((void *) &mem[0x126f], sg_u8Region97, sizeof(sg_u8Region97)); memcpy((void *) &mem[0x1295], sg_u8Region98, sizeof(sg_u8Region98)); memcpy((void *) &mem[0x1514], sg_u8Region99, sizeof(sg_u8Region99)); memcpy((void *) &mem[0x19b0], sg_u8Region100, sizeof(sg_u8Region100)); memcpy((void *) &mem[0x19bd], sg_u8Region101, sizeof(sg_u8Region101)); memcpy((void *) &mem[0x19c5], sg_u8Region102, sizeof(sg_u8Region102)); memcpy((void *) &mem[0x1a40], sg_u8Region103, sizeof(sg_u8Region103)); memcpy((void *) &mem[0x1c06], sg_u8Region104, sizeof(sg_u8Region104)); memcpy((void *) &mem[0x1c17], sg_u8Region105, sizeof(sg_u8Region105)); memcpy((void *) &mem[0x1cdd], sg_u8Region106, sizeof(sg_u8Region106)); memcpy((void *) &mem[0x1cee], sg_u8Region107, sizeof(sg_u8Region107)); memcpy((void *) &mem[0x1db4], sg_u8Region108, sizeof(sg_u8Region108)); memcpy((void *) &mem[0x1dc5], sg_u8Region109, sizeof(sg_u8Region109)); memcpy((void *) &mem[0x1e8b], sg_u8Region110, sizeof(sg_u8Region110)); memcpy((void *) &mem[0x1e9c], sg_u8Region111, sizeof(sg_u8Region111)); memcpy((void *) &mem[0x1f9a], sg_u8Region112, sizeof(sg_u8Region112)); memcpy((void *) &mem[0x1ffe], sg_u8Region113, sizeof(sg_u8Region113)); memcpy((void *) &mem[0x2064], sg_u8Region114, sizeof(sg_u8Region114)); memcpy((void *) &mem[0x210c], sg_u8Region115, sizeof(sg_u8Region115)); memcpy((void *) &mem[0x216a], sg_u8Region116, sizeof(sg_u8Region116)); memcpy((void *) &mem[0x2196], sg_u8Region117, sizeof(sg_u8Region117)); memcpy((void *) &mem[0x21a6], sg_u8Region118, sizeof(sg_u8Region118)); memcpy((void *) &mem[0x21dc], sg_u8Region119, sizeof(sg_u8Region119)); memcpy((void *) &mem[0x2265], sg_u8Region120, sizeof(sg_u8Region120)); memcpy((void *) &mem[0x2280], sg_u8Region121, sizeof(sg_u8Region121)); memcpy((void *) &mem[0x2287], sg_u8Region122, sizeof(sg_u8Region122)); memcpy((void *) &mem[0x229d], sg_u8Region123, sizeof(sg_u8Region123)); memcpy((void *) &mem[0x22d8], sg_u8Region124, sizeof(sg_u8Region124)); memcpy((void *) &mem[0x2303], sg_u8Region125, sizeof(sg_u8Region125)); memcpy((void *) &mem[0x23a8], sg_u8Region126, sizeof(sg_u8Region126)); memcpy((void *) &mem[0x23ef], sg_u8Region127, sizeof(sg_u8Region127)); memcpy((void *) &mem[0x24b7], sg_u8Region128, sizeof(sg_u8Region128)); memcpy((void *) &mem[0x24e0], sg_u8Region129, sizeof(sg_u8Region129)); memcpy((void *) &mem[0x24fc], sg_u8Region130, sizeof(sg_u8Region130)); memcpy((void *) &mem[0x2728], sg_u8Region131, sizeof(sg_u8Region131)); memcpy((void *) &mem[0x2b17], sg_u8Region132, sizeof(sg_u8Region132)); memcpy((void *) &mem[0x2bf7], sg_u8Region133, sizeof(sg_u8Region133)); memcpy((void *) &mem[0x2c2e], sg_u8Region134, sizeof(sg_u8Region134)); memcpy((void *) &mem[0x2d65], sg_u8Region135, sizeof(sg_u8Region135)); memcpy((void *) &mem[0x2d85], sg_u8Region136, sizeof(sg_u8Region136)); memcpy((void *) &mem[0x2f02], sg_u8Region137, sizeof(sg_u8Region137)); memcpy((void *) &mem[0x3031], sg_u8Region138, sizeof(sg_u8Region138)); memcpy((void *) &mem[0x3155], sg_u8Region139, sizeof(sg_u8Region139)); memcpy((void *) &mem[0x32f9], sg_u8Region140, sizeof(sg_u8Region140)); memcpy((void *) &mem[0x343e], sg_u8Region141, sizeof(sg_u8Region141)); memcpy((void *) &mem[0x3458], sg_u8Region142, sizeof(sg_u8Region142)); memcpy((void *) &mem[0x3472], sg_u8Region143, sizeof(sg_u8Region143)); memcpy((void *) &mem[0x35f5], sg_u8Region144, sizeof(sg_u8Region144)); memcpy((void *) &mem[0x3696], sg_u8Region145, sizeof(sg_u8Region145)); memcpy((void *) &mem[0x3b08], sg_u8Region146, sizeof(sg_u8Region146)); memcpy((void *) &mem[0x3e68], sg_u8Region147, sizeof(sg_u8Region147)); memcpy((void *) &mem[0x3e8c], sg_u8Region148, sizeof(sg_u8Region148)); memcpy((void *) &mem[0x3e9d], sg_u8Region149, sizeof(sg_u8Region149)); memcpy((void *) &mem[0x3ea3], sg_u8Region150, sizeof(sg_u8Region150)); memcpy((void *) &mem[0x3ea6], sg_u8Region151, sizeof(sg_u8Region151)); memcpy((void *) &mem[0x3eac], sg_u8Region152, sizeof(sg_u8Region152)); memcpy((void *) &mem[0x3eb2], sg_u8Region153, sizeof(sg_u8Region153)); memcpy((void *) &mem[0x3eb8], sg_u8Region154, sizeof(sg_u8Region154)); memcpy((void *) &mem[0x3ebe], sg_u8Region155, sizeof(sg_u8Region155)); memcpy((void *) &mem[0x3ec4], sg_u8Region156, sizeof(sg_u8Region156)); memcpy((void *) &mem[0x3f7f], sg_u8Region157, sizeof(sg_u8Region157)); memcpy((void *) &mem[0x8000], sg_u8Region158, sizeof(sg_u8Region158)); memcpy((void *) &mem[0x800f], sg_u8Region159, sizeof(sg_u8Region159)); memcpy((void *) &mem[0x8016], sg_u8Region160, sizeof(sg_u8Region160)); memcpy((void *) &mem[0x801c], sg_u8Region161, sizeof(sg_u8Region161)); memcpy((void *) &mem[0x8027], sg_u8Region162, sizeof(sg_u8Region162)); memcpy((void *) &mem[0x808f], sg_u8Region163, sizeof(sg_u8Region163)); memcpy((void *) &mem[0x80b0], sg_u8Region164, sizeof(sg_u8Region164)); memcpy((void *) &mem[0x879e], sg_u8Region165, sizeof(sg_u8Region165)); memcpy((void *) &mem[0x87f8], sg_u8Region166, sizeof(sg_u8Region166)); memcpy((void *) &mem[0x8841], sg_u8Region167, sizeof(sg_u8Region167)); memcpy((void *) &mem[0x9474], sg_u8Region168, sizeof(sg_u8Region168)); memcpy((void *) &mem[0x9499], sg_u8Region169, sizeof(sg_u8Region169)); memcpy((void *) &mem[0x94e1], sg_u8Region170, sizeof(sg_u8Region170)); memcpy((void *) &mem[0x951c], sg_u8Region171, sizeof(sg_u8Region171)); memcpy((void *) &mem[0x9578], sg_u8Region172, sizeof(sg_u8Region172)); memcpy((void *) &mem[0x95ae], sg_u8Region173, sizeof(sg_u8Region173)); memcpy((void *) &mem[0x9616], sg_u8Region174, sizeof(sg_u8Region174)); memcpy((void *) &mem[0x9643], sg_u8Region175, sizeof(sg_u8Region175)); memcpy((void *) &mem[0x9646], sg_u8Region176, sizeof(sg_u8Region176)); memcpy((void *) &mem[0x967d], sg_u8Region177, sizeof(sg_u8Region177)); memcpy((void *) &mem[0x97c4], sg_u8Region178, sizeof(sg_u8Region178)); } void mspacmanIndirectWrite8(UINT32 u32Address, UINT8 u8Data) { if (u32Address >= 0x4000 && u32Address <= 0x47ff) { MSPacVideoWrite(u32Address, u8Data); return; } else if (u32Address >= 0x5000 && u32Address <= 0x505f) { MSStuffWrite(u32Address, u8Data); return; } else if (u32Address >= 0x507f && u32Address <= 0x50ff) { MSNothingWrite(u32Address, u8Data); return; } else if (u32Address >= 0xc000 && u32Address <= 0xc7ff) { MSPacVideoWrite(u32Address, u8Data); return; } else { mem[u32Address] = u8Data; } #ifdef USE_NCURSES_GRAPHICS graphics_monitor(u32Address); #endif } //void mspacmanIndirectIOWrite8(UINT32 u32Address, UINT8 u8Data) //{ // if (0x0000 == u32Address) // { // MSIOWrite(u32Address, u8Data); // return; // } //} UINT32 mspacman_GetElapsedTicks(BOOL bClear) { UINT32 u32Temp = Z80clockticks; if (bClear) { Z80clockticks = 0; } return(u32Temp); } void mspacman_reset(void) { Z80AF = 0x0040; Z80halted = 0; Z80BC = 0; Z80DE = 0; Z80HL = 0; Z80afprime = 0; Z80bcprime = 0; Z80deprime = 0; Z80hlprime = 0; Z80i = 0; Z80r = 0; Z80IX = 0xffff; Z80IY = 0xffff; Z80PC = 0; Z80SP = 0xffff; Z80interruptMode = 0; Z80intAddr = 0x38; Z80nmiAddr = 0x66; Z80Base = mem; } void mspacman_SetCPUContext(struct z80context *psContext) { memcpy((void *)&Z80, psContext, sizeof(*psContext)); Z80Base = mem; } UINT32 mspacman_int(UINT8 u8AddressLSB) { UINT8 *pu8SP; Z80halted = 0; if (0 == (Z80iff & Z80_FLAG_IFF1)) { return(0xffffffff); // Interrupt not taken } Z80iff &= ~(Z80_FLAG_IFF1 | Z80_FLAG_IFF2); pu8SP = (mem + Z80SP - 1); *pu8SP-- = (UINT8) (Z80PC >> 8); *pu8SP = (UINT8) (Z80PC & 0xFF); Z80SP -= 2; if (2 == Z80interruptMode) { Z80PC = ((UINT16) Z80i << 8) | (u8AddressLSB); Z80PC = ((UINT16) mem[Z80PC + 1] << 8) | mem[Z80PC]; } else { Z80PC = Z80intAddr; } Z80clockticks += sg_u8INTTiming[Z80interruptMode]; return(0); } void mspacman_nmi(void) { UINT8 *pu8SP; Z80halted = 0; pu8SP = (mem + Z80SP - 1); *pu8SP-- = (UINT8) (Z80PC >> 8); *pu8SP = (UINT8) (Z80PC & 0xFF); Z80SP -= 2; Z80PC = Z80nmiAddr; Z80clockticks += 11; Z80iff &= (~Z80_FLAG_IFF1); } void XXmspacman_SetNMIAddress(UINT32 u32Address) { Z80nmiAddr = u32Address; } void XXmspacman_SetINTAddress(UINT32 u32Address) { Z80intAddr = u32Address; } void mspacman_GetCPUContext(struct z80context *psContext) { memcpy((void *) psContext, (void *) &Z80, sizeof(*psContext)); } // The optimised version of the Ms Pacman static binary translation does // not count cycles, so it cannot handle the FPS correctly that way. // There are however some vestiges of the cycle handling remaining in // this code which you can find below by searching for s32CyclesRemaining, // sg_s32StartCount, z80clockticks, and Z80rCounter (the r counter being the // z80's dynamic ram refresh counter which is also used here as a hardware // source of random numbers to control the appearance of the random fruits). // Right now I'm actually quite baffled as to how the SDL code is enforcing // a frame rate. Nothing I have changed has speeded it up at all, even // though it is only using less than 15% of the CPU and presumably can go // faster. It is just possible that there's a bottleneck in the X Windows // connection to my Windows PC which runs Xming but I don't think that's // the issue. asciipac however plays much faster than the SDL version. // Ideally I want to restructure the code so that the exec() call runs for // exactly one frame, and returns, allowing the caller to then update the // display (and read the inputs which are then saved to the ram at 0x50XX) // I will also need to understand better which interrupts are used and how // they are handled, eg the watchdog and (presumably) vblank for frame timing. UINT32 mspacman_exec(register INT32 s32CyclesRemaining) { register UINT8 u8Flags = Z80F; static int init = 0; static void *mspacmanLabelTable[0x10000]; if (init == 0) { // Has to be initialised here where the actual labels are in scope. int i; for (i = 0; i < 0x10000; i++) mspacmanLabelTable[i] = &&badOp; init = 1; // I had to write a little utility to extract all the labels and case statements from the // translated source in order to recreate the jump table array. Orion seems to have gotten // it badly wrong. Previously we were running on the more portable switch-based version, // but this executes code much faster. mspacmanLabelTable[0x0000] = &&L0000; mspacmanLabelTable[0x0008] = &&L0008; mspacmanLabelTable[0x000c] = &&L000c; mspacmanLabelTable[0x000d] = &&L000d; mspacmanLabelTable[0x0010] = &&L0010; mspacmanLabelTable[0x0017] = &&L0017; mspacmanLabelTable[0x0018] = &&L0018; mspacmanLabelTable[0x001b] = &&L001b; mspacmanLabelTable[0x0020] = &&L0020; mspacmanLabelTable[0x0023] = &&L0023; mspacmanLabelTable[0x0028] = &&L0028; mspacmanLabelTable[0x0030] = &&L0030; mspacmanLabelTable[0x0038] = &&L0038; mspacmanLabelTable[0x0042] = &&L0042; mspacmanLabelTable[0x004d] = &&L004d; mspacmanLabelTable[0x0051] = &&L0051; mspacmanLabelTable[0x005b] = &&L005b; mspacmanLabelTable[0x005e] = &&L005e; mspacmanLabelTable[0x0065] = &&L0065; mspacmanLabelTable[0x008d] = &&L008d; mspacmanLabelTable[0x00a0] = &&L00a0; mspacmanLabelTable[0x00b4] = &&L00b4; mspacmanLabelTable[0x00c3] = &&L00c3; mspacmanLabelTable[0x00d2] = &&L00d2; mspacmanLabelTable[0x013e] = &&L013e; mspacmanLabelTable[0x0153] = &&L0153; mspacmanLabelTable[0x0176] = &&L0176; mspacmanLabelTable[0x018f] = &&L018f; mspacmanLabelTable[0x0192] = &&L0192; mspacmanLabelTable[0x0195] = &&L0195; mspacmanLabelTable[0x019e] = &&L019e; mspacmanLabelTable[0x01a1] = &&L01a1; mspacmanLabelTable[0x01a4] = &&L01a4; mspacmanLabelTable[0x01a7] = &&L01a7; mspacmanLabelTable[0x01aa] = &&L01aa; mspacmanLabelTable[0x01ad] = &&L01ad; mspacmanLabelTable[0x01b9] = &&L01b9; mspacmanLabelTable[0x01bc] = &&L01bc; mspacmanLabelTable[0x01bf] = &&L01bf; mspacmanLabelTable[0x01d4] = &&L01d4; mspacmanLabelTable[0x01dc] = &&L01dc; mspacmanLabelTable[0x01e9] = &&L01e9; mspacmanLabelTable[0x0204] = &&L0204; mspacmanLabelTable[0x0221] = &&L0221; mspacmanLabelTable[0x022a] = &&L022a; mspacmanLabelTable[0x025b] = &&L025b; mspacmanLabelTable[0x025d] = &&L025d; mspacmanLabelTable[0x0263] = &&L0263; mspacmanLabelTable[0x0264] = &&L0264; mspacmanLabelTable[0x0266] = &&L0266; mspacmanLabelTable[0x0267] = &&L0267; mspacmanLabelTable[0x0286] = &&L0286; mspacmanLabelTable[0x029a] = &&L029a; mspacmanLabelTable[0x02ad] = &&L02ad; mspacmanLabelTable[0x02c4] = &&L02c4; mspacmanLabelTable[0x02ce] = &&L02ce; mspacmanLabelTable[0x02df] = &&L02df; mspacmanLabelTable[0x02f6] = &&L02f6; mspacmanLabelTable[0x02fd] = &&L02fd; mspacmanLabelTable[0x031b] = &&L031b; mspacmanLabelTable[0x031e] = &&L031e; mspacmanLabelTable[0x0325] = &&L0325; mspacmanLabelTable[0x0340] = &&L0340; mspacmanLabelTable[0x0343] = &&L0343; mspacmanLabelTable[0x0344] = &&L0344; mspacmanLabelTable[0x0353] = &&L0353; mspacmanLabelTable[0x0356] = &&L0356; mspacmanLabelTable[0x0359] = &&L0359; mspacmanLabelTable[0x035e] = &&L035e; mspacmanLabelTable[0x0361] = &&L0361; mspacmanLabelTable[0x0368] = &&L0368; mspacmanLabelTable[0x0369] = &&L0369; mspacmanLabelTable[0x0376] = &&L0376; mspacmanLabelTable[0x0383] = &&L0383; mspacmanLabelTable[0x0390] = &&L0390; mspacmanLabelTable[0x039d] = &&L039d; mspacmanLabelTable[0x03c8] = &&L03c8; mspacmanLabelTable[0x03d4] = &&L03d4; mspacmanLabelTable[0x03dc] = &&L03dc; mspacmanLabelTable[0x03df] = &&L03df; mspacmanLabelTable[0x03e2] = &&L03e2; mspacmanLabelTable[0x03e5] = &&L03e5; mspacmanLabelTable[0x03e8] = &&L03e8; mspacmanLabelTable[0x03eb] = &&L03eb; mspacmanLabelTable[0x03ee] = &&L03ee; mspacmanLabelTable[0x03f1] = &&L03f1; mspacmanLabelTable[0x03f4] = &&L03f4; mspacmanLabelTable[0x03fe] = &&L03fe; mspacmanLabelTable[0x0401] = &&L0401; mspacmanLabelTable[0x0413] = &&L0413; mspacmanLabelTable[0x045f] = &&L045f; mspacmanLabelTable[0x0462] = &&L0462; mspacmanLabelTable[0x0465] = &&L0465; mspacmanLabelTable[0x0468] = &&L0468; mspacmanLabelTable[0x046b] = &&L046b; mspacmanLabelTable[0x0470] = &&L0470; mspacmanLabelTable[0x0471] = &&L0471; mspacmanLabelTable[0x0479] = &&L0479; mspacmanLabelTable[0x047e] = &&L047e; mspacmanLabelTable[0x047f] = &&L047f; mspacmanLabelTable[0x0484] = &&L0484; mspacmanLabelTable[0x0485] = &&L0485; mspacmanLabelTable[0x048a] = &&L048a; mspacmanLabelTable[0x048b] = &&L048b; mspacmanLabelTable[0x0493] = &&L0493; mspacmanLabelTable[0x0498] = &&L0498; mspacmanLabelTable[0x0499] = &&L0499; mspacmanLabelTable[0x049e] = &&L049e; mspacmanLabelTable[0x049f] = &&L049f; mspacmanLabelTable[0x04a4] = &&L04a4; mspacmanLabelTable[0x04a5] = &&L04a5; mspacmanLabelTable[0x04ad] = &&L04ad; mspacmanLabelTable[0x04b2] = &&L04b2; mspacmanLabelTable[0x04b3] = &&L04b3; mspacmanLabelTable[0x04b8] = &&L04b8; mspacmanLabelTable[0x04b9] = &&L04b9; mspacmanLabelTable[0x04be] = &&L04be; mspacmanLabelTable[0x04bf] = &&L04bf; mspacmanLabelTable[0x04c7] = &&L04c7; mspacmanLabelTable[0x04cc] = &&L04cc; mspacmanLabelTable[0x04cd] = &&L04cd; mspacmanLabelTable[0x04d2] = &&L04d2; mspacmanLabelTable[0x04e9] = &&L04e9; mspacmanLabelTable[0x04ec] = &&L04ec; mspacmanLabelTable[0x04ef] = &&L04ef; mspacmanLabelTable[0x04f2] = &&L04f2; mspacmanLabelTable[0x04f5] = &&L04f5; mspacmanLabelTable[0x0506] = &&L0506; mspacmanLabelTable[0x0511] = &&L0511; mspacmanLabelTable[0x051c] = &&L051c; mspacmanLabelTable[0x052c] = &&L052c; mspacmanLabelTable[0x052f] = &&L052f; mspacmanLabelTable[0x0532] = &&L0532; mspacmanLabelTable[0x0535] = &&L0535; mspacmanLabelTable[0x0538] = &&L0538; mspacmanLabelTable[0x053b] = &&L053b; mspacmanLabelTable[0x053e] = &&L053e; mspacmanLabelTable[0x0541] = &&L0541; mspacmanLabelTable[0x0544] = &&L0544; mspacmanLabelTable[0x0547] = &&L0547; mspacmanLabelTable[0x054a] = &&L054a; mspacmanLabelTable[0x057c] = &&L057c; mspacmanLabelTable[0x057f] = &&L057f; mspacmanLabelTable[0x0585] = &&L0585; mspacmanLabelTable[0x058a] = &&L058a; mspacmanLabelTable[0x058b] = &&L058b; mspacmanLabelTable[0x058e] = &&L058e; mspacmanLabelTable[0x0593] = &&L0593; mspacmanLabelTable[0x059d] = &&L059d; mspacmanLabelTable[0x05a1] = &&L05a1; mspacmanLabelTable[0x05a4] = &&L05a4; mspacmanLabelTable[0x05a5] = &&L05a5; mspacmanLabelTable[0x05bb] = &&L05bb; mspacmanLabelTable[0x05bf] = &&L05bf; mspacmanLabelTable[0x05e5] = &&L05e5; mspacmanLabelTable[0x05f3] = &&L05f3; mspacmanLabelTable[0x05f6] = &&L05f6; mspacmanLabelTable[0x05f9] = &&L05f9; mspacmanLabelTable[0x05fc] = &&L05fc; mspacmanLabelTable[0x05ff] = &&L05ff; mspacmanLabelTable[0x0602] = &&L0602; mspacmanLabelTable[0x0605] = &&L0605; mspacmanLabelTable[0x0617] = &&L0617; mspacmanLabelTable[0x061a] = &&L061a; mspacmanLabelTable[0x061b] = &&L061b; mspacmanLabelTable[0x061e] = &&L061e; mspacmanLabelTable[0x0629] = &&L0629; mspacmanLabelTable[0x062c] = &&L062c; mspacmanLabelTable[0x0642] = &&L0642; mspacmanLabelTable[0x0649] = &&L0649; mspacmanLabelTable[0x065b] = &&L065b; mspacmanLabelTable[0x0664] = &&L0664; mspacmanLabelTable[0x0674] = &&L0674; mspacmanLabelTable[0x0677] = &&L0677; mspacmanLabelTable[0x067a] = &&L067a; mspacmanLabelTable[0x067d] = &&L067d; mspacmanLabelTable[0x0680] = &&L0680; mspacmanLabelTable[0x0683] = &&L0683; mspacmanLabelTable[0x0686] = &&L0686; mspacmanLabelTable[0x0689] = &&L0689; mspacmanLabelTable[0x068c] = &&L068c; mspacmanLabelTable[0x068f] = &&L068f; mspacmanLabelTable[0x069f] = &&L069f; mspacmanLabelTable[0x06a3] = &&L06a3; mspacmanLabelTable[0x06a8] = &&L06a8; mspacmanLabelTable[0x06af] = &&L06af; mspacmanLabelTable[0x06be] = &&L06be; mspacmanLabelTable[0x070e] = &&L070e; mspacmanLabelTable[0x0716] = &&L0716; mspacmanLabelTable[0x073a] = &&L073a; mspacmanLabelTable[0x0750] = &&L0750; mspacmanLabelTable[0x0795] = &&L0795; mspacmanLabelTable[0x0814] = &&L0814; mspacmanLabelTable[0x083a] = &&L083a; mspacmanLabelTable[0x0879] = &&L0879; mspacmanLabelTable[0x0880] = &&L0880; mspacmanLabelTable[0x0883] = &&L0883; mspacmanLabelTable[0x0894] = &&L0894; mspacmanLabelTable[0x0899] = &&L0899; mspacmanLabelTable[0x08a5] = &&L08a5; mspacmanLabelTable[0x08a8] = &&L08a8; mspacmanLabelTable[0x08ab] = &&L08ab; mspacmanLabelTable[0x08ae] = &&L08ae; mspacmanLabelTable[0x08b1] = &&L08b1; mspacmanLabelTable[0x08b4] = &&L08b4; mspacmanLabelTable[0x08b7] = &&L08b7; mspacmanLabelTable[0x08bb] = &&L08bb; mspacmanLabelTable[0x08bf] = &&L08bf; mspacmanLabelTable[0x08cd] = &&L08cd; mspacmanLabelTable[0x08dd] = &&L08dd; mspacmanLabelTable[0x08de] = &&L08de; mspacmanLabelTable[0x08e5] = &&L08e5; mspacmanLabelTable[0x08eb] = &&L08eb; mspacmanLabelTable[0x08ee] = &&L08ee; mspacmanLabelTable[0x08f1] = &&L08f1; mspacmanLabelTable[0x08f4] = &&L08f4; mspacmanLabelTable[0x08f7] = &&L08f7; mspacmanLabelTable[0x08fa] = &&L08fa; mspacmanLabelTable[0x08fd] = &&L08fd; mspacmanLabelTable[0x0900] = &&L0900; mspacmanLabelTable[0x0903] = &&L0903; mspacmanLabelTable[0x0906] = &&L0906; mspacmanLabelTable[0x0909] = &&L0909; mspacmanLabelTable[0x090c] = &&L090c; mspacmanLabelTable[0x090d] = &&L090d; mspacmanLabelTable[0x0915] = &&L0915; mspacmanLabelTable[0x0936] = &&L0936; mspacmanLabelTable[0x0939] = &&L0939; mspacmanLabelTable[0x093d] = &&L093d; mspacmanLabelTable[0x093e] = &&L093e; mspacmanLabelTable[0x0940] = &&L0940; mspacmanLabelTable[0x094c] = &&L094c; mspacmanLabelTable[0x0955] = &&L0955; mspacmanLabelTable[0x0958] = &&L0958; mspacmanLabelTable[0x095c] = &&L095c; mspacmanLabelTable[0x0961] = &&L0961; mspacmanLabelTable[0x0964] = &&L0964; mspacmanLabelTable[0x096c] = &&L096c; mspacmanLabelTable[0x0972] = &&L0972; mspacmanLabelTable[0x0988] = &&L0988; mspacmanLabelTable[0x098b] = &&L098b; mspacmanLabelTable[0x098e] = &&L098e; mspacmanLabelTable[0x0991] = &&L0991; mspacmanLabelTable[0x0994] = &&L0994; mspacmanLabelTable[0x0997] = &&L0997; mspacmanLabelTable[0x099a] = &&L099a; mspacmanLabelTable[0x099d] = &&L099d; mspacmanLabelTable[0x09a0] = &&L09a0; mspacmanLabelTable[0x09a3] = &&L09a3; mspacmanLabelTable[0x09a6] = &&L09a6; mspacmanLabelTable[0x09a9] = &&L09a9; mspacmanLabelTable[0x09b3] = &&L09b3; mspacmanLabelTable[0x09b6] = &&L09b6; mspacmanLabelTable[0x09ba] = &&L09ba; mspacmanLabelTable[0x09c4] = &&L09c4; mspacmanLabelTable[0x09d2] = &&L09d2; mspacmanLabelTable[0x09d8] = &&L09d8; mspacmanLabelTable[0x09dc] = &&L09dc; mspacmanLabelTable[0x09e8] = &&L09e8; mspacmanLabelTable[0x09ea] = &&L09ea; mspacmanLabelTable[0x09ef] = &&L09ef; mspacmanLabelTable[0x09f3] = &&L09f3; mspacmanLabelTable[0x09f9] = &&L09f9; mspacmanLabelTable[0x09fe] = &&L09fe; mspacmanLabelTable[0x0a02] = &&L0a02; mspacmanLabelTable[0x0a04] = &&L0a04; mspacmanLabelTable[0x0a06] = &&L0a06; mspacmanLabelTable[0x0a08] = &&L0a08; mspacmanLabelTable[0x0a0a] = &&L0a0a; mspacmanLabelTable[0x0a0c] = &&L0a0c; mspacmanLabelTable[0x0a0e] = &&L0a0e; mspacmanLabelTable[0x0a11] = &&L0a11; mspacmanLabelTable[0x0a14] = &&L0a14; mspacmanLabelTable[0x0a17] = &&L0a17; mspacmanLabelTable[0x0a1a] = &&L0a1a; mspacmanLabelTable[0x0a1d] = &&L0a1d; mspacmanLabelTable[0x0a20] = &&L0a20; mspacmanLabelTable[0x0a23] = &&L0a23; mspacmanLabelTable[0x0a27] = &&L0a27; mspacmanLabelTable[0x0a2c] = &&L0a2c; mspacmanLabelTable[0x0a35] = &&L0a35; mspacmanLabelTable[0x0a3b] = &&L0a3b; mspacmanLabelTable[0x0a44] = &&L0a44; mspacmanLabelTable[0x0a6f] = &&L0a6f; mspacmanLabelTable[0x0a7c] = &&L0a7c; mspacmanLabelTable[0x0a89] = &&L0a89; mspacmanLabelTable[0x0a8c] = &&L0a8c; mspacmanLabelTable[0x0aa0] = &&L0aa0; mspacmanLabelTable[0x0aa3] = &&L0aa3; mspacmanLabelTable[0x0aa6] = &&L0aa6; mspacmanLabelTable[0x0ab0] = &&L0ab0; mspacmanLabelTable[0x0ac3] = &&L0ac3; mspacmanLabelTable[0x0afb] = &&L0afb; mspacmanLabelTable[0x0afe] = &&L0afe; mspacmanLabelTable[0x0b1a] = &&L0b1a; mspacmanLabelTable[0x0b21] = &&L0b21; mspacmanLabelTable[0x0b2f] = &&L0b2f; mspacmanLabelTable[0x0b33] = &&L0b33; mspacmanLabelTable[0x0b4f] = &&L0b4f; mspacmanLabelTable[0x0b56] = &&L0b56; mspacmanLabelTable[0x0b64] = &&L0b64; mspacmanLabelTable[0x0b68] = &&L0b68; mspacmanLabelTable[0x0b84] = &&L0b84; mspacmanLabelTable[0x0b8b] = &&L0b8b; mspacmanLabelTable[0x0b99] = &&L0b99; mspacmanLabelTable[0x0b9d] = &&L0b9d; mspacmanLabelTable[0x0bb9] = &&L0bb9; mspacmanLabelTable[0x0bc0] = &&L0bc0; mspacmanLabelTable[0x0bce] = &&L0bce; mspacmanLabelTable[0x0bd2] = &&L0bd2; mspacmanLabelTable[0x0bd6] = &&L0bd6; mspacmanLabelTable[0x0be2] = &&L0be2; mspacmanLabelTable[0x0bf0] = &&L0bf0; mspacmanLabelTable[0x0bfa] = &&L0bfa; mspacmanLabelTable[0x0c04] = &&L0c04; mspacmanLabelTable[0x0c0d] = &&L0c0d; mspacmanLabelTable[0x0c33] = &&L0c33; mspacmanLabelTable[0x0c3d] = &&L0c3d; mspacmanLabelTable[0x0c42] = &&L0c42; mspacmanLabelTable[0x0c61] = &&L0c61; mspacmanLabelTable[0x0c90] = &&L0c90; mspacmanLabelTable[0x0ca5] = &&L0ca5; mspacmanLabelTable[0x0caa] = &&L0caa; mspacmanLabelTable[0x0cbb] = &&L0cbb; mspacmanLabelTable[0x0cc1] = &&L0cc1; mspacmanLabelTable[0x0ccc] = &&L0ccc; mspacmanLabelTable[0x0cfb] = &&L0cfb; mspacmanLabelTable[0x0d10] = &&L0d10; mspacmanLabelTable[0x0d15] = &&L0d15; mspacmanLabelTable[0x0d26] = &&L0d26; mspacmanLabelTable[0x0d2c] = &&L0d2c; mspacmanLabelTable[0x0d3f] = &&L0d3f; mspacmanLabelTable[0x0d59] = &&L0d59; mspacmanLabelTable[0x0d64] = &&L0d64; mspacmanLabelTable[0x0d93] = &&L0d93; mspacmanLabelTable[0x0da6] = &&L0da6; mspacmanLabelTable[0x0dab] = &&L0dab; mspacmanLabelTable[0x0dbc] = &&L0dbc; mspacmanLabelTable[0x0dc0] = &&L0dc0; mspacmanLabelTable[0x0dd3] = &&L0dd3; mspacmanLabelTable[0x0dea] = &&L0dea; mspacmanLabelTable[0x0df5] = &&L0df5; mspacmanLabelTable[0x0e23] = &&L0e23; mspacmanLabelTable[0x0e36] = &&L0e36; mspacmanLabelTable[0x0e6c] = &&L0e6c; mspacmanLabelTable[0x0e77] = &&L0e77; mspacmanLabelTable[0x0e89] = &&L0e89; mspacmanLabelTable[0x0e93] = &&L0e93; mspacmanLabelTable[0x0e9d] = &&L0e9d; mspacmanLabelTable[0x0ea7] = &&L0ea7; mspacmanLabelTable[0x0ead] = &&L0ead; mspacmanLabelTable[0x0eb0] = &&L0eb0; mspacmanLabelTable[0x0ecc] = &&L0ecc; mspacmanLabelTable[0x0ed5] = &&L0ed5; mspacmanLabelTable[0x0ee7] = &&L0ee7; mspacmanLabelTable[0x0eeb] = &&L0eeb; mspacmanLabelTable[0x0efc] = &&L0efc; mspacmanLabelTable[0x1000] = &&L1000; mspacmanLabelTable[0x100b] = &&L100b; mspacmanLabelTable[0x1017] = &&L1017; mspacmanLabelTable[0x101a] = &&L101a; mspacmanLabelTable[0x1022] = &&L1022; mspacmanLabelTable[0x1025] = &&L1025; mspacmanLabelTable[0x1028] = &&L1028; mspacmanLabelTable[0x102b] = &&L102b; mspacmanLabelTable[0x102e] = &&L102e; mspacmanLabelTable[0x1038] = &&L1038; mspacmanLabelTable[0x1039] = &&L1039; mspacmanLabelTable[0x103c] = &&L103c; mspacmanLabelTable[0x103f] = &&L103f; mspacmanLabelTable[0x1047] = &&L1047; mspacmanLabelTable[0x104a] = &&L104a; mspacmanLabelTable[0x104d] = &&L104d; mspacmanLabelTable[0x1050] = &&L1050; mspacmanLabelTable[0x1053] = &&L1053; mspacmanLabelTable[0x105c] = &&L105c; mspacmanLabelTable[0x105f] = &&L105f; mspacmanLabelTable[0x1062] = &&L1062; mspacmanLabelTable[0x1065] = &&L1065; mspacmanLabelTable[0x1066] = &&L1066; mspacmanLabelTable[0x1076] = &&L1076; mspacmanLabelTable[0x1081] = &&L1081; mspacmanLabelTable[0x108c] = &&L108c; mspacmanLabelTable[0x1094] = &&L1094; mspacmanLabelTable[0x109e] = &&L109e; mspacmanLabelTable[0x10a8] = &&L10a8; mspacmanLabelTable[0x10b4] = &&L10b4; mspacmanLabelTable[0x10c0] = &&L10c0; mspacmanLabelTable[0x10c3] = &&L10c3; mspacmanLabelTable[0x10d2] = &&L10d2; mspacmanLabelTable[0x10dd] = &&L10dd; mspacmanLabelTable[0x1101] = &&L1101; mspacmanLabelTable[0x1118] = &&L1118; mspacmanLabelTable[0x111b] = &&L111b; mspacmanLabelTable[0x112a] = &&L112a; mspacmanLabelTable[0x1135] = &&L1135; mspacmanLabelTable[0x115c] = &&L115c; mspacmanLabelTable[0x115f] = &&L115f; mspacmanLabelTable[0x116e] = &&L116e; mspacmanLabelTable[0x1179] = &&L1179; mspacmanLabelTable[0x118f] = &&L118f; mspacmanLabelTable[0x119a] = &&L119a; mspacmanLabelTable[0x11c9] = &&L11c9; mspacmanLabelTable[0x11cc] = &&L11cc; mspacmanLabelTable[0x11db] = &&L11db; mspacmanLabelTable[0x11e6] = &&L11e6; mspacmanLabelTable[0x11fc] = &&L11fc; mspacmanLabelTable[0x1207] = &&L1207; mspacmanLabelTable[0x1235] = &&L1235; mspacmanLabelTable[0x123f] = &&L123f; mspacmanLabelTable[0x1265] = &&L1265; mspacmanLabelTable[0x1272] = &&L1272; mspacmanLabelTable[0x1277] = &&L1277; mspacmanLabelTable[0x1291] = &&L1291; mspacmanLabelTable[0x12b7] = &&L12b7; mspacmanLabelTable[0x12cb] = &&L12cb; mspacmanLabelTable[0x12d1] = &&L12d1; mspacmanLabelTable[0x12d6] = &&L12d6; mspacmanLabelTable[0x12e5] = &&L12e5; mspacmanLabelTable[0x12f9] = &&L12f9; mspacmanLabelTable[0x1306] = &&L1306; mspacmanLabelTable[0x130e] = &&L130e; mspacmanLabelTable[0x1316] = &&L1316; mspacmanLabelTable[0x131e] = &&L131e; mspacmanLabelTable[0x1326] = &&L1326; mspacmanLabelTable[0x132e] = &&L132e; mspacmanLabelTable[0x1336] = &&L1336; mspacmanLabelTable[0x133e] = &&L133e; mspacmanLabelTable[0x1346] = &&L1346; mspacmanLabelTable[0x1353] = &&L1353; mspacmanLabelTable[0x1371] = &&L1371; mspacmanLabelTable[0x1376] = &&L1376; mspacmanLabelTable[0x1398] = &&L1398; mspacmanLabelTable[0x13a7] = &&L13a7; mspacmanLabelTable[0x13b1] = &&L13b1; mspacmanLabelTable[0x13bb] = &&L13bb; mspacmanLabelTable[0x13c5] = &&L13c5; mspacmanLabelTable[0x13dd] = &&L13dd; mspacmanLabelTable[0x13ee] = &&L13ee; mspacmanLabelTable[0x140b] = &&L140b; mspacmanLabelTable[0x1415] = &&L1415; mspacmanLabelTable[0x141e] = &&L141e; mspacmanLabelTable[0x141f] = &&L141f; mspacmanLabelTable[0x1490] = &&L1490; mspacmanLabelTable[0x14fe] = &&L14fe; mspacmanLabelTable[0x151c] = &&L151c; mspacmanLabelTable[0x152e] = &&L152e; mspacmanLabelTable[0x153e] = &&L153e; mspacmanLabelTable[0x1548] = &&L1548; mspacmanLabelTable[0x154b] = &&L154b; mspacmanLabelTable[0x156c] = &&L156c; mspacmanLabelTable[0x1575] = &&L1575; mspacmanLabelTable[0x1581] = &&L1581; mspacmanLabelTable[0x158a] = &&L158a; mspacmanLabelTable[0x1596] = &&L1596; mspacmanLabelTable[0x159f] = &&L159f; mspacmanLabelTable[0x15ab] = &&L15ab; mspacmanLabelTable[0x15b4] = &&L15b4; mspacmanLabelTable[0x15b7] = &&L15b7; mspacmanLabelTable[0x15ba] = &&L15ba; mspacmanLabelTable[0x15bd] = &&L15bd; mspacmanLabelTable[0x15e6] = &&L15e6; mspacmanLabelTable[0x15f9] = &&L15f9; mspacmanLabelTable[0x1601] = &&L1601; mspacmanLabelTable[0x1609] = &&L1609; mspacmanLabelTable[0x160b] = &&L160b; mspacmanLabelTable[0x162d] = &&L162d; mspacmanLabelTable[0x163e] = &&L163e; mspacmanLabelTable[0x1652] = &&L1652; mspacmanLabelTable[0x1663] = &&L1663; mspacmanLabelTable[0x168c] = &&L168c; mspacmanLabelTable[0x168f] = &&L168f; mspacmanLabelTable[0x1690] = &&L1690; mspacmanLabelTable[0x169a] = &&L169a; mspacmanLabelTable[0x16a3] = &&L16a3; mspacmanLabelTable[0x16ac] = &&L16ac; mspacmanLabelTable[0x16b1] = &&L16b1; mspacmanLabelTable[0x16b4] = &&L16b4; mspacmanLabelTable[0x16b5] = &&L16b5; mspacmanLabelTable[0x16ba] = &&L16ba; mspacmanLabelTable[0x16bf] = &&L16bf; mspacmanLabelTable[0x16c8] = &&L16c8; mspacmanLabelTable[0x16d1] = &&L16d1; mspacmanLabelTable[0x16d6] = &&L16d6; mspacmanLabelTable[0x16dc] = &&L16dc; mspacmanLabelTable[0x16dd] = &&L16dd; mspacmanLabelTable[0x16df] = &&L16df; mspacmanLabelTable[0x16e1] = &&L16e1; mspacmanLabelTable[0x16e7] = &&L16e7; mspacmanLabelTable[0x16ef] = &&L16ef; mspacmanLabelTable[0x16f7] = &&L16f7; mspacmanLabelTable[0x16fd] = &&L16fd; mspacmanLabelTable[0x16fe] = &&L16fe; mspacmanLabelTable[0x1700] = &&L1700; mspacmanLabelTable[0x1705] = &&L1705; mspacmanLabelTable[0x170b] = &&L170b; mspacmanLabelTable[0x1711] = &&L1711; mspacmanLabelTable[0x1719] = &&L1719; mspacmanLabelTable[0x171d] = &&L171d; mspacmanLabelTable[0x1732] = &&L1732; mspacmanLabelTable[0x1742] = &&L1742; mspacmanLabelTable[0x1752] = &&L1752; mspacmanLabelTable[0x1762] = &&L1762; mspacmanLabelTable[0x1763] = &&L1763; mspacmanLabelTable[0x1783] = &&L1783; mspacmanLabelTable[0x1789] = &&L1789; mspacmanLabelTable[0x17b4] = &&L17b4; mspacmanLabelTable[0x17ce] = &&L17ce; mspacmanLabelTable[0x17e8] = &&L17e8; mspacmanLabelTable[0x1802] = &&L1802; mspacmanLabelTable[0x1806] = &&L1806; mspacmanLabelTable[0x1811] = &&L1811; mspacmanLabelTable[0x182f] = &&L182f; mspacmanLabelTable[0x1843] = &&L1843; mspacmanLabelTable[0x1864] = &&L1864; mspacmanLabelTable[0x1883] = &&L1883; mspacmanLabelTable[0x1886] = &&L1886; mspacmanLabelTable[0x1899] = &&L1899; mspacmanLabelTable[0x18ab] = &&L18ab; mspacmanLabelTable[0x18c5] = &&L18c5; mspacmanLabelTable[0x18c8] = &&L18c8; mspacmanLabelTable[0x18e4] = &&L18e4; mspacmanLabelTable[0x18ef] = &&L18ef; mspacmanLabelTable[0x190b] = &&L190b; mspacmanLabelTable[0x1916] = &&L1916; mspacmanLabelTable[0x191d] = &&L191d; mspacmanLabelTable[0x1935] = &&L1935; mspacmanLabelTable[0x1940] = &&L1940; mspacmanLabelTable[0x1950] = &&L1950; mspacmanLabelTable[0x195b] = &&L195b; mspacmanLabelTable[0x1971] = &&L1971; mspacmanLabelTable[0x1975] = &&L1975; mspacmanLabelTable[0x1984] = &&L1984; mspacmanLabelTable[0x1985] = &&L1985; mspacmanLabelTable[0x198b] = &&L198b; mspacmanLabelTable[0x19b2] = &&L19b2; mspacmanLabelTable[0x19b8] = &&L19b8; mspacmanLabelTable[0x19bb] = &&L19bb; mspacmanLabelTable[0x19c4] = &&L19c4; mspacmanLabelTable[0x19c8] = &&L19c8; mspacmanLabelTable[0x19cd] = &&L19cd; mspacmanLabelTable[0x19d8] = &&L19d8; mspacmanLabelTable[0x19e0] = &&L19e0; mspacmanLabelTable[0x19f6] = &&L19f6; mspacmanLabelTable[0x19fd] = &&L19fd; mspacmanLabelTable[0x1a03] = &&L1a03; mspacmanLabelTable[0x1a06] = &&L1a06; mspacmanLabelTable[0x1a14] = &&L1a14; mspacmanLabelTable[0x1a19] = &&L1a19; mspacmanLabelTable[0x1a2e] = &&L1a2e; mspacmanLabelTable[0x1a38] = &&L1a38; mspacmanLabelTable[0x1a3d] = &&L1a3d; mspacmanLabelTable[0x1a42] = &&L1a42; mspacmanLabelTable[0x1a4d] = &&L1a4d; mspacmanLabelTable[0x1a5c] = &&L1a5c; mspacmanLabelTable[0x1a67] = &&L1a67; mspacmanLabelTable[0x1a6a] = &&L1a6a; mspacmanLabelTable[0x1a70] = &&L1a70; mspacmanLabelTable[0x1ac9] = &&L1ac9; mspacmanLabelTable[0x1ad9] = &&L1ad9; mspacmanLabelTable[0x1ae8] = &&L1ae8; mspacmanLabelTable[0x1af8] = &&L1af8; mspacmanLabelTable[0x1b08] = &&L1b08; mspacmanLabelTable[0x1b14] = &&L1b14; mspacmanLabelTable[0x1b25] = &&L1b25; mspacmanLabelTable[0x1b31] = &&L1b31; mspacmanLabelTable[0x1b36] = &&L1b36; mspacmanLabelTable[0x1b43] = &&L1b43; mspacmanLabelTable[0x1b4c] = &&L1b4c; mspacmanLabelTable[0x1b6a] = &&L1b6a; mspacmanLabelTable[0x1b88] = &&L1b88; mspacmanLabelTable[0x1ba6] = &&L1ba6; mspacmanLabelTable[0x1bc4] = &&L1bc4; mspacmanLabelTable[0x1bd8] = &&L1bd8; mspacmanLabelTable[0x1bed] = &&L1bed; mspacmanLabelTable[0x1bf7] = &&L1bf7; mspacmanLabelTable[0x1bfc] = &&L1bfc; mspacmanLabelTable[0x1c08] = &&L1c08; mspacmanLabelTable[0x1c0b] = &&L1c0b; mspacmanLabelTable[0x1c11] = &&L1c11; mspacmanLabelTable[0x1c19] = &&L1c19; mspacmanLabelTable[0x1c1c] = &&L1c1c; mspacmanLabelTable[0x1c27] = &&L1c27; mspacmanLabelTable[0x1c36] = &&L1c36; mspacmanLabelTable[0x1c41] = &&L1c41; mspacmanLabelTable[0x1c47] = &&L1c47; mspacmanLabelTable[0x1c4b] = &&L1c4b; mspacmanLabelTable[0x1c5f] = &&L1c5f; mspacmanLabelTable[0x1c7d] = &&L1c7d; mspacmanLabelTable[0x1c9b] = &&L1c9b; mspacmanLabelTable[0x1caf] = &&L1caf; mspacmanLabelTable[0x1cc4] = &&L1cc4; mspacmanLabelTable[0x1cce] = &&L1cce; mspacmanLabelTable[0x1cd3] = &&L1cd3; mspacmanLabelTable[0x1cdf] = &&L1cdf; mspacmanLabelTable[0x1ce2] = &&L1ce2; mspacmanLabelTable[0x1ce8] = &&L1ce8; mspacmanLabelTable[0x1cf0] = &&L1cf0; mspacmanLabelTable[0x1cf3] = &&L1cf3; mspacmanLabelTable[0x1cfe] = &&L1cfe; mspacmanLabelTable[0x1d0d] = &&L1d0d; mspacmanLabelTable[0x1d18] = &&L1d18; mspacmanLabelTable[0x1d1e] = &&L1d1e; mspacmanLabelTable[0x1d22] = &&L1d22; mspacmanLabelTable[0x1d36] = &&L1d36; mspacmanLabelTable[0x1d54] = &&L1d54; mspacmanLabelTable[0x1d72] = &&L1d72; mspacmanLabelTable[0x1d86] = &&L1d86; mspacmanLabelTable[0x1d9b] = &&L1d9b; mspacmanLabelTable[0x1da5] = &&L1da5; mspacmanLabelTable[0x1daa] = &&L1daa; mspacmanLabelTable[0x1db6] = &&L1db6; mspacmanLabelTable[0x1db9] = &&L1db9; mspacmanLabelTable[0x1dbf] = &&L1dbf; mspacmanLabelTable[0x1dc7] = &&L1dc7; mspacmanLabelTable[0x1dca] = &&L1dca; mspacmanLabelTable[0x1dd5] = &&L1dd5; mspacmanLabelTable[0x1de4] = &&L1de4; mspacmanLabelTable[0x1def] = &&L1def; mspacmanLabelTable[0x1df5] = &&L1df5; mspacmanLabelTable[0x1df9] = &&L1df9; mspacmanLabelTable[0x1e0d] = &&L1e0d; mspacmanLabelTable[0x1e2b] = &&L1e2b; mspacmanLabelTable[0x1e49] = &&L1e49; mspacmanLabelTable[0x1e5d] = &&L1e5d; mspacmanLabelTable[0x1e72] = &&L1e72; mspacmanLabelTable[0x1e7c] = &&L1e7c; mspacmanLabelTable[0x1e81] = &&L1e81; mspacmanLabelTable[0x1e8d] = &&L1e8d; mspacmanLabelTable[0x1e90] = &&L1e90; mspacmanLabelTable[0x1e96] = &&L1e96; mspacmanLabelTable[0x1e9e] = &&L1e9e; mspacmanLabelTable[0x1ea1] = &&L1ea1; mspacmanLabelTable[0x1eac] = &&L1eac; mspacmanLabelTable[0x1ebb] = &&L1ebb; mspacmanLabelTable[0x1ec6] = &&L1ec6; mspacmanLabelTable[0x1ecc] = &&L1ecc; mspacmanLabelTable[0x1ed0] = &&L1ed0; mspacmanLabelTable[0x1ee3] = &&L1ee3; mspacmanLabelTable[0x1eed] = &&L1eed; mspacmanLabelTable[0x1efc] = &&L1efc; mspacmanLabelTable[0x1efe] = &&L1efe; mspacmanLabelTable[0x1f14] = &&L1f14; mspacmanLabelTable[0x1f25] = &&L1f25; mspacmanLabelTable[0x1f2e] = &&L1f2e; mspacmanLabelTable[0x1f3b] = &&L1f3b; mspacmanLabelTable[0x1f4c] = &&L1f4c; mspacmanLabelTable[0x1f55] = &&L1f55; mspacmanLabelTable[0x1f62] = &&L1f62; mspacmanLabelTable[0x1f73] = &&L1f73; mspacmanLabelTable[0x1f7c] = &&L1f7c; mspacmanLabelTable[0x1f89] = &&L1f89; mspacmanLabelTable[0x1f9b] = &&L1f9b; mspacmanLabelTable[0x1fa5] = &&L1fa5; mspacmanLabelTable[0x2000] = &&L2000; mspacmanLabelTable[0x200f] = &&L200f; mspacmanLabelTable[0x2012] = &&L2012; mspacmanLabelTable[0x2015] = &&L2015; mspacmanLabelTable[0x2018] = &&L2018; mspacmanLabelTable[0x202d] = &&L202d; mspacmanLabelTable[0x2052] = &&L2052; mspacmanLabelTable[0x2055] = &&L2055; mspacmanLabelTable[0x205a] = &&L205a; mspacmanLabelTable[0x205d] = &&L205d; mspacmanLabelTable[0x2066] = &&L2066; mspacmanLabelTable[0x2069] = &&L2069; mspacmanLabelTable[0x207e] = &&L207e; mspacmanLabelTable[0x2086] = &&L2086; mspacmanLabelTable[0x208c] = &&L208c; mspacmanLabelTable[0x20a1] = &&L20a1; mspacmanLabelTable[0x20a9] = &&L20a9; mspacmanLabelTable[0x20af] = &&L20af; mspacmanLabelTable[0x20c9] = &&L20c9; mspacmanLabelTable[0x20d1] = &&L20d1; mspacmanLabelTable[0x20d7] = &&L20d7; mspacmanLabelTable[0x20f4] = &&L20f4; mspacmanLabelTable[0x2108] = &&L2108; mspacmanLabelTable[0x210b] = &&L210b; mspacmanLabelTable[0x211a] = &&L211a; mspacmanLabelTable[0x212b] = &&L212b; mspacmanLabelTable[0x2130] = &&L2130; mspacmanLabelTable[0x2133] = &&L2133; mspacmanLabelTable[0x2136] = &&L2136; mspacmanLabelTable[0x2139] = &&L2139; mspacmanLabelTable[0x213c] = &&L213c; mspacmanLabelTable[0x213f] = &&L213f; mspacmanLabelTable[0x2140] = &&L2140; mspacmanLabelTable[0x214b] = &&L214b; mspacmanLabelTable[0x2156] = &&L2156; mspacmanLabelTable[0x2160] = &&L2160; mspacmanLabelTable[0x216d] = &&L216d; mspacmanLabelTable[0x2170] = &&L2170; mspacmanLabelTable[0x217b] = &&L217b; mspacmanLabelTable[0x2186] = &&L2186; mspacmanLabelTable[0x2189] = &&L2189; mspacmanLabelTable[0x218c] = &&L218c; mspacmanLabelTable[0x2195] = &&L2195; mspacmanLabelTable[0x2199] = &&L2199; mspacmanLabelTable[0x219e] = &&L219e; mspacmanLabelTable[0x21a4] = &&L21a4; mspacmanLabelTable[0x21c2] = &&L21c2; mspacmanLabelTable[0x21c4] = &&L21c4; mspacmanLabelTable[0x21d3] = &&L21d3; mspacmanLabelTable[0x21df] = &&L21df; mspacmanLabelTable[0x21e1] = &&L21e1; mspacmanLabelTable[0x21f0] = &&L21f0; mspacmanLabelTable[0x21f5] = &&L21f5; mspacmanLabelTable[0x2201] = &&L2201; mspacmanLabelTable[0x220a] = &&L220a; mspacmanLabelTable[0x220c] = &&L220c; mspacmanLabelTable[0x221e] = &&L221e; mspacmanLabelTable[0x2237] = &&L2237; mspacmanLabelTable[0x223a] = &&L223a; mspacmanLabelTable[0x223d] = &&L223d; mspacmanLabelTable[0x2240] = &&L2240; mspacmanLabelTable[0x2243] = &&L2243; mspacmanLabelTable[0x2244] = &&L2244; mspacmanLabelTable[0x224b] = &&L224b; mspacmanLabelTable[0x225d] = &&L225d; mspacmanLabelTable[0x2268] = &&L2268; mspacmanLabelTable[0x226a] = &&L226a; mspacmanLabelTable[0x2283] = &&L2283; mspacmanLabelTable[0x2286] = &&L2286; mspacmanLabelTable[0x228a] = &&L228a; mspacmanLabelTable[0x228d] = &&L228d; mspacmanLabelTable[0x2297] = &&L2297; mspacmanLabelTable[0x22b9] = &&L22b9; mspacmanLabelTable[0x22be] = &&L22be; mspacmanLabelTable[0x22ca] = &&L22ca; mspacmanLabelTable[0x22d7] = &&L22d7; mspacmanLabelTable[0x22db] = &&L22db; mspacmanLabelTable[0x22dd] = &&L22dd; mspacmanLabelTable[0x22e4] = &&L22e4; mspacmanLabelTable[0x22f5] = &&L22f5; mspacmanLabelTable[0x22fc] = &&L22fc; mspacmanLabelTable[0x22fe] = &&L22fe; mspacmanLabelTable[0x2306] = &&L2306; mspacmanLabelTable[0x230b] = &&L230b; mspacmanLabelTable[0x2311] = &&L2311; mspacmanLabelTable[0x231a] = &&L231a; mspacmanLabelTable[0x2322] = &&L2322; mspacmanLabelTable[0x232b] = &&L232b; mspacmanLabelTable[0x2334] = &&L2334; mspacmanLabelTable[0x234b] = &&L234b; mspacmanLabelTable[0x2359] = &&L2359; mspacmanLabelTable[0x235f] = &&L235f; mspacmanLabelTable[0x2360] = &&L2360; mspacmanLabelTable[0x2361] = &&L2361; mspacmanLabelTable[0x2362] = &&L2362; mspacmanLabelTable[0x2368] = &&L2368; mspacmanLabelTable[0x236e] = &&L236e; mspacmanLabelTable[0x2376] = &&L2376; mspacmanLabelTable[0x2387] = &&L2387; mspacmanLabelTable[0x238d] = &&L238d; mspacmanLabelTable[0x23a0] = &&L23a0; mspacmanLabelTable[0x23e8] = &&L23e8; mspacmanLabelTable[0x23ed] = &&L23ed; mspacmanLabelTable[0x23f3] = &&L23f3; mspacmanLabelTable[0x23fb] = &&L23fb; mspacmanLabelTable[0x23fc] = &&L23fc; mspacmanLabelTable[0x2400] = &&L2400; mspacmanLabelTable[0x2408] = &&L2408; mspacmanLabelTable[0x2409] = &&L2409; mspacmanLabelTable[0x240d] = &&L240d; mspacmanLabelTable[0x2414] = &&L2414; mspacmanLabelTable[0x2415] = &&L2415; mspacmanLabelTable[0x2419] = &&L2419; mspacmanLabelTable[0x241f] = &&L241f; mspacmanLabelTable[0x242c] = &&L242c; mspacmanLabelTable[0x2448] = &&L2448; mspacmanLabelTable[0x244e] = &&L244e; mspacmanLabelTable[0x2453] = &&L2453; mspacmanLabelTable[0x2457] = &&L2457; mspacmanLabelTable[0x245c] = &&L245c; mspacmanLabelTable[0x2465] = &&L2465; mspacmanLabelTable[0x2475] = &&L2475; mspacmanLabelTable[0x2487] = &&L2487; mspacmanLabelTable[0x248d] = &&L248d; mspacmanLabelTable[0x2492] = &&L2492; mspacmanLabelTable[0x2496] = &&L2496; mspacmanLabelTable[0x2498] = &&L2498; mspacmanLabelTable[0x24a3] = &&L24a3; mspacmanLabelTable[0x24c9] = &&L24c9; mspacmanLabelTable[0x24d1] = &&L24d1; mspacmanLabelTable[0x24d6] = &&L24d6; mspacmanLabelTable[0x24d7] = &&L24d7; mspacmanLabelTable[0x24e1] = &&L24e1; mspacmanLabelTable[0x24e7] = &&L24e7; mspacmanLabelTable[0x24e8] = &&L24e8; mspacmanLabelTable[0x24f3] = &&L24f3; mspacmanLabelTable[0x2534] = &&L2534; mspacmanLabelTable[0x253d] = &&L253d; mspacmanLabelTable[0x260f] = &&L260f; mspacmanLabelTable[0x2662] = &&L2662; mspacmanLabelTable[0x2675] = &&L2675; mspacmanLabelTable[0x267e] = &&L267e; mspacmanLabelTable[0x268b] = &&L268b; mspacmanLabelTable[0x2698] = &&L2698; mspacmanLabelTable[0x26a2] = &&L26a2; mspacmanLabelTable[0x26a6] = &&L26a6; mspacmanLabelTable[0x26b1] = &&L26b1; mspacmanLabelTable[0x26b2] = &&L26b2; mspacmanLabelTable[0x26d0] = &&L26d0; mspacmanLabelTable[0x26de] = &&L26de; mspacmanLabelTable[0x26f6] = &&L26f6; mspacmanLabelTable[0x2704] = &&L2704; mspacmanLabelTable[0x271a] = &&L271a; mspacmanLabelTable[0x2730] = &&L2730; mspacmanLabelTable[0x274e] = &&L274e; mspacmanLabelTable[0x2751] = &&L2751; mspacmanLabelTable[0x2758] = &&L2758; mspacmanLabelTable[0x2765] = &&L2765; mspacmanLabelTable[0x276c] = &&L276c; mspacmanLabelTable[0x2784] = &&L2784; mspacmanLabelTable[0x2787] = &&L2787; mspacmanLabelTable[0x278e] = &&L278e; mspacmanLabelTable[0x27a2] = &&L27a2; mspacmanLabelTable[0x27a9] = &&L27a9; mspacmanLabelTable[0x27be] = &&L27be; mspacmanLabelTable[0x27c4] = &&L27c4; mspacmanLabelTable[0x27cb] = &&L27cb; mspacmanLabelTable[0x27ea] = &&L27ea; mspacmanLabelTable[0x27f1] = &&L27f1; mspacmanLabelTable[0x2800] = &&L2800; mspacmanLabelTable[0x2806] = &&L2806; mspacmanLabelTable[0x280c] = &&L280c; mspacmanLabelTable[0x2813] = &&L2813; mspacmanLabelTable[0x281e] = &&L281e; mspacmanLabelTable[0x2834] = &&L2834; mspacmanLabelTable[0x283b] = &&L283b; mspacmanLabelTable[0x284e] = &&L284e; mspacmanLabelTable[0x2855] = &&L2855; mspacmanLabelTable[0x285e] = &&L285e; mspacmanLabelTable[0x2865] = &&L2865; mspacmanLabelTable[0x2878] = &&L2878; mspacmanLabelTable[0x287f] = &&L287f; mspacmanLabelTable[0x2888] = &&L2888; mspacmanLabelTable[0x288f] = &&L288f; mspacmanLabelTable[0x28a2] = &&L28a2; mspacmanLabelTable[0x28a9] = &&L28a9; mspacmanLabelTable[0x28b2] = &&L28b2; mspacmanLabelTable[0x28b9] = &&L28b9; mspacmanLabelTable[0x28cc] = &&L28cc; mspacmanLabelTable[0x28d3] = &&L28d3; mspacmanLabelTable[0x28dc] = &&L28dc; mspacmanLabelTable[0x28e3] = &&L28e3; mspacmanLabelTable[0x28f7] = &&L28f7; mspacmanLabelTable[0x28fe] = &&L28fe; mspacmanLabelTable[0x2917] = &&L2917; mspacmanLabelTable[0x291e] = &&L291e; mspacmanLabelTable[0x2929] = &&L2929; mspacmanLabelTable[0x293d] = &&L293d; mspacmanLabelTable[0x2947] = &&L2947; mspacmanLabelTable[0x2957] = &&L2957; mspacmanLabelTable[0x2966] = &&L2966; mspacmanLabelTable[0x2988] = &&L2988; mspacmanLabelTable[0x2992] = &&L2992; mspacmanLabelTable[0x2998] = &&L2998; mspacmanLabelTable[0x29ae] = &&L29ae; mspacmanLabelTable[0x29c6] = &&L29c6; mspacmanLabelTable[0x29ea] = &&L29ea; mspacmanLabelTable[0x29f9] = &&L29f9; mspacmanLabelTable[0x29fc] = &&L29fc; mspacmanLabelTable[0x2a0c] = &&L2a0c; mspacmanLabelTable[0x2a0f] = &&L2a0f; mspacmanLabelTable[0x2a12] = &&L2a12; mspacmanLabelTable[0x2a19] = &&L2a19; mspacmanLabelTable[0x2a1e] = &&L2a1e; mspacmanLabelTable[0x2a23] = &&L2a23; mspacmanLabelTable[0x2a35] = &&L2a35; mspacmanLabelTable[0x2a38] = &&L2a38; mspacmanLabelTable[0x2a53] = &&L2a53; mspacmanLabelTable[0x2a5a] = &&L2a5a; mspacmanLabelTable[0x2a64] = &&L2a64; mspacmanLabelTable[0x2a68] = &&L2a68; mspacmanLabelTable[0x2a86] = &&L2a86; mspacmanLabelTable[0x2a89] = &&L2a89; mspacmanLabelTable[0x2a91] = &&L2a91; mspacmanLabelTable[0x2a9b] = &&L2a9b; mspacmanLabelTable[0x2a9e] = &&L2a9e; mspacmanLabelTable[0x2aaf] = &&L2aaf; mspacmanLabelTable[0x2abe] = &&L2abe; mspacmanLabelTable[0x2ac6] = &&L2ac6; mspacmanLabelTable[0x2aca] = &&L2aca; mspacmanLabelTable[0x2ace] = &&L2ace; mspacmanLabelTable[0x2ad6] = &&L2ad6; mspacmanLabelTable[0x2add] = &&L2add; mspacmanLabelTable[0x2ae0] = &&L2ae0; mspacmanLabelTable[0x2ae5] = &&L2ae5; mspacmanLabelTable[0x2aec] = &&L2aec; mspacmanLabelTable[0x2af8] = &&L2af8; mspacmanLabelTable[0x2b0b] = &&L2b0b; mspacmanLabelTable[0x2b33] = &&L2b33; mspacmanLabelTable[0x2b4a] = &&L2b4a; mspacmanLabelTable[0x2b57] = &&L2b57; mspacmanLabelTable[0x2b5c] = &&L2b5c; mspacmanLabelTable[0x2b61] = &&L2b61; mspacmanLabelTable[0x2b66] = &&L2b66; mspacmanLabelTable[0x2b6a] = &&L2b6a; mspacmanLabelTable[0x2b73] = &&L2b73; mspacmanLabelTable[0x2b78] = &&L2b78; mspacmanLabelTable[0x2b7e] = &&L2b7e; mspacmanLabelTable[0x2b80] = &&L2b80; mspacmanLabelTable[0x2b8f] = &&L2b8f; mspacmanLabelTable[0x2ba1] = &&L2ba1; mspacmanLabelTable[0x2bad] = &&L2bad; mspacmanLabelTable[0x2bb2] = &&L2bb2; mspacmanLabelTable[0x2bc2] = &&L2bc2; mspacmanLabelTable[0x2bcd] = &&L2bcd; mspacmanLabelTable[0x2bdd] = &&L2bdd; mspacmanLabelTable[0x2bdf] = &&L2bdf; mspacmanLabelTable[0x2bea] = &&L2bea; mspacmanLabelTable[0x2bf9] = &&L2bf9; mspacmanLabelTable[0x2c02] = &&L2c02; mspacmanLabelTable[0x2c06] = &&L2c06; mspacmanLabelTable[0x2c0f] = &&L2c0f; mspacmanLabelTable[0x2c19] = &&L2c19; mspacmanLabelTable[0x2c1e] = &&L2c1e; mspacmanLabelTable[0x2c26] = &&L2c26; mspacmanLabelTable[0x2c5e] = &&L2c5e; mspacmanLabelTable[0x2c62] = &&L2c62; mspacmanLabelTable[0x2c7c] = &&L2c7c; mspacmanLabelTable[0x2c84] = &&L2c84; mspacmanLabelTable[0x2c92] = &&L2c92; mspacmanLabelTable[0x2c93] = &&L2c93; mspacmanLabelTable[0x2c9a] = &&L2c9a; mspacmanLabelTable[0x2ca4] = &&L2ca4; mspacmanLabelTable[0x2cac] = &&L2cac; mspacmanLabelTable[0x2cbb] = &&L2cbb; mspacmanLabelTable[0x2cc1] = &&L2cc1; mspacmanLabelTable[0x2cc4] = &&L2cc4; mspacmanLabelTable[0x2ccf] = &&L2ccf; mspacmanLabelTable[0x2cda] = &&L2cda; mspacmanLabelTable[0x2ce8] = &&L2ce8; mspacmanLabelTable[0x2cf3] = &&L2cf3; mspacmanLabelTable[0x2d01] = &&L2d01; mspacmanLabelTable[0x2d0c] = &&L2d0c; mspacmanLabelTable[0x2d1a] = &&L2d1a; mspacmanLabelTable[0x2d2b] = &&L2d2b; mspacmanLabelTable[0x2d3c] = &&L2d3c; mspacmanLabelTable[0x2d44] = &&L2d44; mspacmanLabelTable[0x2d50] = &&L2d50; mspacmanLabelTable[0x2d59] = &&L2d59; mspacmanLabelTable[0x2d66] = &&L2d66; mspacmanLabelTable[0x2d6c] = &&L2d6c; mspacmanLabelTable[0x2d72] = &&L2d72; mspacmanLabelTable[0x2da5] = &&L2da5; mspacmanLabelTable[0x2dad] = &&L2dad; mspacmanLabelTable[0x2db9] = &&L2db9; mspacmanLabelTable[0x2dc6] = &&L2dc6; mspacmanLabelTable[0x2dd4] = &&L2dd4; mspacmanLabelTable[0x2dd7] = &&L2dd7; mspacmanLabelTable[0x2de5] = &&L2de5; mspacmanLabelTable[0x2dee] = &&L2dee; mspacmanLabelTable[0x2df4] = &&L2df4; mspacmanLabelTable[0x2e1b] = &&L2e1b; mspacmanLabelTable[0x2e20] = &&L2e20; mspacmanLabelTable[0x2e29] = &&L2e29; mspacmanLabelTable[0x2e6e] = &&L2e6e; mspacmanLabelTable[0x2e89] = &&L2e89; mspacmanLabelTable[0x2ead] = &&L2ead; mspacmanLabelTable[0x2ecd] = &&L2ecd; mspacmanLabelTable[0x2ee4] = &&L2ee4; mspacmanLabelTable[0x2ee5] = &&L2ee5; mspacmanLabelTable[0x2ee8] = &&L2ee8; mspacmanLabelTable[0x2f22] = &&L2f22; mspacmanLabelTable[0x2f26] = &&L2f26; mspacmanLabelTable[0x2f2b] = &&L2f2b; mspacmanLabelTable[0x2f30] = &&L2f30; mspacmanLabelTable[0x2f34] = &&L2f34; mspacmanLabelTable[0x2f3c] = &&L2f3c; mspacmanLabelTable[0x2f43] = &&L2f43; mspacmanLabelTable[0x2f4a] = &&L2f4a; mspacmanLabelTable[0x2f4b] = &&L2f4b; mspacmanLabelTable[0x2f4c] = &&L2f4c; mspacmanLabelTable[0x2f4d] = &&L2f4d; mspacmanLabelTable[0x2f4e] = &&L2f4e; mspacmanLabelTable[0x2f4f] = &&L2f4f; mspacmanLabelTable[0x2f50] = &&L2f50; mspacmanLabelTable[0x2f51] = &&L2f51; mspacmanLabelTable[0x2f52] = &&L2f52; mspacmanLabelTable[0x2f53] = &&L2f53; mspacmanLabelTable[0x2f54] = &&L2f54; mspacmanLabelTable[0x2f55] = &&L2f55; mspacmanLabelTable[0x2f65] = &&L2f65; mspacmanLabelTable[0x2f77] = &&L2f77; mspacmanLabelTable[0x2f89] = &&L2f89; mspacmanLabelTable[0x2f9b] = &&L2f9b; mspacmanLabelTable[0x2fad] = &&L2fad; mspacmanLabelTable[0x2ffe] = &&L2ffe; mspacmanLabelTable[0x3000] = &&L3000; mspacmanLabelTable[0x3003] = &&L3003; mspacmanLabelTable[0x3006] = &&L3006; mspacmanLabelTable[0x3009] = &&L3009; mspacmanLabelTable[0x3042] = &&L3042; mspacmanLabelTable[0x3045] = &&L3045; mspacmanLabelTable[0x3047] = &&L3047; mspacmanLabelTable[0x304a] = &&L304a; mspacmanLabelTable[0x304d] = &&L304d; mspacmanLabelTable[0x3072] = &&L3072; mspacmanLabelTable[0x3075] = &&L3075; mspacmanLabelTable[0x30b5] = &&L30b5; mspacmanLabelTable[0x30bd] = &&L30bd; mspacmanLabelTable[0x30c6] = &&L30c6; mspacmanLabelTable[0x30c9] = &&L30c9; mspacmanLabelTable[0x30d6] = &&L30d6; mspacmanLabelTable[0x30db] = &&L30db; mspacmanLabelTable[0x30e4] = &&L30e4; mspacmanLabelTable[0x30e9] = &&L30e9; mspacmanLabelTable[0x30f8] = &&L30f8; mspacmanLabelTable[0x30fb] = &&L30fb; mspacmanLabelTable[0x3108] = &&L3108; mspacmanLabelTable[0x3122] = &&L3122; mspacmanLabelTable[0x3147] = &&L3147; mspacmanLabelTable[0x3174] = &&L3174; mspacmanLabelTable[0x3179] = &&L3179; mspacmanLabelTable[0x3188] = &&L3188; mspacmanLabelTable[0x31a5] = &&L31a5; mspacmanLabelTable[0x31b3] = &&L31b3; mspacmanLabelTable[0x31be] = &&L31be; mspacmanLabelTable[0x31c9] = &&L31c9; mspacmanLabelTable[0x31d4] = &&L31d4; mspacmanLabelTable[0x31df] = &&L31df; mspacmanLabelTable[0x31ea] = &&L31ea; mspacmanLabelTable[0x31fc] = &&L31fc; mspacmanLabelTable[0x31ff] = &&L31ff; mspacmanLabelTable[0x3207] = &&L3207; mspacmanLabelTable[0x320c] = &&L320c; mspacmanLabelTable[0x321c] = &&L321c; mspacmanLabelTable[0x322a] = &&L322a; mspacmanLabelTable[0x3232] = &&L3232; mspacmanLabelTable[0x323e] = &&L323e; mspacmanLabelTable[0x324f] = &&L324f; mspacmanLabelTable[0x3258] = &&L3258; mspacmanLabelTable[0x325b] = &&L325b; mspacmanLabelTable[0x325f] = &&L325f; mspacmanLabelTable[0x326a] = &&L326a; mspacmanLabelTable[0x3281] = &&L3281; mspacmanLabelTable[0x3284] = &&L3284; mspacmanLabelTable[0x3286] = &&L3286; mspacmanLabelTable[0x329a] = &&L329a; mspacmanLabelTable[0x329d] = &&L329d; mspacmanLabelTable[0x32a9] = &&L32a9; mspacmanLabelTable[0x32ab] = &&L32ab; mspacmanLabelTable[0x32b1] = &&L32b1; mspacmanLabelTable[0x32b7] = &&L32b7; mspacmanLabelTable[0x32ba] = &&L32ba; mspacmanLabelTable[0x32d3] = &&L32d3; mspacmanLabelTable[0x32d5] = &&L32d5; mspacmanLabelTable[0x32df] = &&L32df; mspacmanLabelTable[0x32ed] = &&L32ed; mspacmanLabelTable[0x32f3] = &&L32f3; mspacmanLabelTable[0x3435] = &&L3435; mspacmanLabelTable[0x3440] = &&L3440; mspacmanLabelTable[0x344f] = &&L344f; mspacmanLabelTable[0x345a] = &&L345a; mspacmanLabelTable[0x3469] = &&L3469; mspacmanLabelTable[0x3474] = &&L3474; mspacmanLabelTable[0x3483] = &&L3483; mspacmanLabelTable[0x3488] = &&L3488; mspacmanLabelTable[0x348d] = &&L348d; mspacmanLabelTable[0x3492] = &&L3492; mspacmanLabelTable[0x3497] = &&L3497; mspacmanLabelTable[0x349c] = &&L349c; mspacmanLabelTable[0x34a3] = &&L34a3; mspacmanLabelTable[0x34a9] = &&L34a9; mspacmanLabelTable[0x34de] = &&L34de; mspacmanLabelTable[0x34e2] = &&L34e2; mspacmanLabelTable[0x34e7] = &&L34e7; mspacmanLabelTable[0x34ec] = &&L34ec; mspacmanLabelTable[0x34f0] = &&L34f0; mspacmanLabelTable[0x34f1] = &&L34f1; mspacmanLabelTable[0x34f9] = &&L34f9; mspacmanLabelTable[0x34fe] = &&L34fe; mspacmanLabelTable[0x3503] = &&L3503; mspacmanLabelTable[0x3508] = &&L3508; mspacmanLabelTable[0x3509] = &&L3509; mspacmanLabelTable[0x3512] = &&L3512; mspacmanLabelTable[0x3515] = &&L3515; mspacmanLabelTable[0x3519] = &&L3519; mspacmanLabelTable[0x351d] = &&L351d; mspacmanLabelTable[0x3526] = &&L3526; mspacmanLabelTable[0x352d] = &&L352d; mspacmanLabelTable[0x3533] = &&L3533; mspacmanLabelTable[0x3545] = &&L3545; mspacmanLabelTable[0x354b] = &&L354b; mspacmanLabelTable[0x3556] = &&L3556; mspacmanLabelTable[0x3568] = &&L3568; mspacmanLabelTable[0x356a] = &&L356a; mspacmanLabelTable[0x356b] = &&L356b; mspacmanLabelTable[0x356f] = &&L356f; mspacmanLabelTable[0x3577] = &&L3577; mspacmanLabelTable[0x357d] = &&L357d; mspacmanLabelTable[0x358a] = &&L358a; mspacmanLabelTable[0x358d] = &&L358d; mspacmanLabelTable[0x3597] = &&L3597; mspacmanLabelTable[0x359e] = &&L359e; mspacmanLabelTable[0x35a4] = &&L35a4; mspacmanLabelTable[0x35a9] = &&L35a9; mspacmanLabelTable[0x35b4] = &&L35b4; mspacmanLabelTable[0x35c8] = &&L35c8; mspacmanLabelTable[0x35cb] = &&L35cb; mspacmanLabelTable[0x35d0] = &&L35d0; mspacmanLabelTable[0x35f3] = &&L35f3; mspacmanLabelTable[0x35f7] = &&L35f7; mspacmanLabelTable[0x35fd] = &&L35fd; mspacmanLabelTable[0x3607] = &&L3607; mspacmanLabelTable[0x3611] = &&L3611; mspacmanLabelTable[0x361f] = &&L361f; mspacmanLabelTable[0x3640] = &&L3640; mspacmanLabelTable[0x3641] = &&L3641; mspacmanLabelTable[0x364a] = &&L364a; mspacmanLabelTable[0x364e] = &&L364e; mspacmanLabelTable[0x3659] = &&L3659; mspacmanLabelTable[0x366a] = &&L366a; mspacmanLabelTable[0x366b] = &&L366b; mspacmanLabelTable[0x366f] = &&L366f; mspacmanLabelTable[0x3678] = &&L3678; mspacmanLabelTable[0x367f] = &&L367f; mspacmanLabelTable[0x3692] = &&L3692; mspacmanLabelTable[0x3af4] = &&L3af4; mspacmanLabelTable[0x3afa] = &&L3afa; mspacmanLabelTable[0x3e5c] = &&L3e5c; mspacmanLabelTable[0x3e64] = &&L3e64; mspacmanLabelTable[0x3e8a] = &&L3e8a; mspacmanLabelTable[0x3e8b] = &&L3e8b; mspacmanLabelTable[0x3e8e] = &&L3e8e; mspacmanLabelTable[0x3e96] = &&L3e96; mspacmanLabelTable[0x3e99] = &&L3e99; mspacmanLabelTable[0x3e9c] = &&L3e9c; mspacmanLabelTable[0x3e9f] = &&L3e9f; mspacmanLabelTable[0x3ea2] = &&L3ea2; mspacmanLabelTable[0x3ea5] = &&L3ea5; mspacmanLabelTable[0x3ea8] = &&L3ea8; mspacmanLabelTable[0x3eab] = &&L3eab; mspacmanLabelTable[0x3eae] = &&L3eae; mspacmanLabelTable[0x3eb1] = &&L3eb1; mspacmanLabelTable[0x3eb4] = &&L3eb4; mspacmanLabelTable[0x3eb7] = &&L3eb7; mspacmanLabelTable[0x3eba] = &&L3eba; mspacmanLabelTable[0x3ebd] = &&L3ebd; mspacmanLabelTable[0x3ec0] = &&L3ec0; mspacmanLabelTable[0x3ec3] = &&L3ec3; mspacmanLabelTable[0x3ec6] = &&L3ec6; mspacmanLabelTable[0x3ec9] = &&L3ec9; mspacmanLabelTable[0x3ed0] = &&L3ed0; mspacmanLabelTable[0x3f19] = &&L3f19; mspacmanLabelTable[0x3f21] = &&L3f21; mspacmanLabelTable[0x8001] = &&L8001; mspacmanLabelTable[0x8007] = &&L8007; mspacmanLabelTable[0x800b] = &&L800b; mspacmanLabelTable[0x800e] = &&L800e; mspacmanLabelTable[0x8013] = &&L8013; mspacmanLabelTable[0x8018] = &&L8018; mspacmanLabelTable[0x801b] = &&L801b; mspacmanLabelTable[0x8020] = &&L8020; mspacmanLabelTable[0x8083] = &&L8083; mspacmanLabelTable[0x8090] = &&L8090; mspacmanLabelTable[0x8094] = &&L8094; mspacmanLabelTable[0x8097] = &&L8097; mspacmanLabelTable[0x80a5] = &&L80a5; mspacmanLabelTable[0x869c] = &&L869c; mspacmanLabelTable[0x86ad] = &&L86ad; mspacmanLabelTable[0x86b1] = &&L86b1; mspacmanLabelTable[0x86c1] = &&L86c1; mspacmanLabelTable[0x86c5] = &&L86c5; mspacmanLabelTable[0x86d5] = &&L86d5; mspacmanLabelTable[0x86d9] = &&L86d9; mspacmanLabelTable[0x86ea] = &&L86ea; mspacmanLabelTable[0x86ee] = &&L86ee; mspacmanLabelTable[0x8709] = &&L8709; mspacmanLabelTable[0x872f] = &&L872f; mspacmanLabelTable[0x8735] = &&L8735; mspacmanLabelTable[0x873c] = &&L873c; mspacmanLabelTable[0x8747] = &&L8747; mspacmanLabelTable[0x8758] = &&L8758; mspacmanLabelTable[0x875b] = &&L875b; mspacmanLabelTable[0x876c] = &&L876c; mspacmanLabelTable[0x8770] = &&L8770; mspacmanLabelTable[0x8777] = &&L8777; mspacmanLabelTable[0x878a] = &&L878a; mspacmanLabelTable[0x8793] = &&L8793; mspacmanLabelTable[0x87b5] = &&L87b5; mspacmanLabelTable[0x87cd] = &&L87cd; mspacmanLabelTable[0x87d0] = &&L87d0; mspacmanLabelTable[0x87db] = &&L87db; mspacmanLabelTable[0x87e4] = &&L87e4; mspacmanLabelTable[0x87ed] = &&L87ed; mspacmanLabelTable[0x8810] = &&L8810; mspacmanLabelTable[0x8818] = &&L8818; mspacmanLabelTable[0x883d] = &&L883d; mspacmanLabelTable[0x946a] = &&L946a; mspacmanLabelTable[0x9470] = &&L9470; mspacmanLabelTable[0x947c] = &&L947c; mspacmanLabelTable[0x9481] = &&L9481; mspacmanLabelTable[0x9484] = &&L9484; mspacmanLabelTable[0x948b] = &&L948b; mspacmanLabelTable[0x94a1] = &&L94a1; mspacmanLabelTable[0x94a8] = &&L94a8; mspacmanLabelTable[0x94b5] = &&L94b5; mspacmanLabelTable[0x94bd] = &&L94bd; mspacmanLabelTable[0x94c6] = &&L94c6; mspacmanLabelTable[0x94ca] = &&L94ca; mspacmanLabelTable[0x94d4] = &&L94d4; mspacmanLabelTable[0x94d6] = &&L94d6; mspacmanLabelTable[0x94ec] = &&L94ec; mspacmanLabelTable[0x94f2] = &&L94f2; mspacmanLabelTable[0x94f7] = &&L94f7; mspacmanLabelTable[0x9504] = &&L9504; mspacmanLabelTable[0x950a] = &&L950a; mspacmanLabelTable[0x950f] = &&L950f; mspacmanLabelTable[0x9524] = &&L9524; mspacmanLabelTable[0x952c] = &&L952c; mspacmanLabelTable[0x953c] = &&L953c; mspacmanLabelTable[0x9559] = &&L9559; mspacmanLabelTable[0x955e] = &&L955e; mspacmanLabelTable[0x9561] = &&L9561; mspacmanLabelTable[0x956a] = &&L956a; mspacmanLabelTable[0x9571] = &&L9571; mspacmanLabelTable[0x9580] = &&L9580; mspacmanLabelTable[0x9590] = &&L9590; mspacmanLabelTable[0x9598] = &&L9598; mspacmanLabelTable[0x95a3] = &&L95a3; mspacmanLabelTable[0x95a5] = &&L95a5; mspacmanLabelTable[0x95c3] = &&L95c3; mspacmanLabelTable[0x95d1] = &&L95d1; mspacmanLabelTable[0x95d4] = &&L95d4; mspacmanLabelTable[0x95db] = &&L95db; mspacmanLabelTable[0x95df] = &&L95df; mspacmanLabelTable[0x95e3] = &&L95e3; mspacmanLabelTable[0x95e9] = &&L95e9; mspacmanLabelTable[0x95ee] = &&L95ee; mspacmanLabelTable[0x95f3] = &&L95f3; mspacmanLabelTable[0x95f6] = &&L95f6; mspacmanLabelTable[0x95fb] = &&L95fb; mspacmanLabelTable[0x960b] = &&L960b; mspacmanLabelTable[0x9613] = &&L9613; mspacmanLabelTable[0x9618] = &&L9618; mspacmanLabelTable[0x9627] = &&L9627; mspacmanLabelTable[0x963b] = &&L963b; mspacmanLabelTable[0x963c] = &&L963c; mspacmanLabelTable[0x9642] = &&L9642; mspacmanLabelTable[0x9645] = &&L9645; mspacmanLabelTable[0x9648] = &&L9648; mspacmanLabelTable[0x9654] = &&L9654; mspacmanLabelTable[0x9797] = &&L9797; mspacmanLabelTable[0x97a9] = &&L97a9; mspacmanLabelTable[0x97be] = &&L97be; } if (Z80halted) { if (0 == s32CyclesRemaining) { s32CyclesRemaining = 4; } Z80clockticks += s32CyclesRemaining; Z80rCounter += s32CyclesRemaining; sg_s32StartCount = 0; return(0); } sg_s32StartCount = s32CyclesRemaining; goToPC: // Surely this is the place to check for interrupts? goto *mspacmanLabelTable[Z80PC]; // 0000: di ; Disable interrupts // rst 0 - initialization // init L0000: Z80iff &= 0xfe; // 0001: ld a, 00h ; 0 -> a Z80A = (UINT8) (0); // 0003: ld i, a ; Clear interrupt status register Z80i = (UINT8) (Z80A); // 0005: jp 230bh ; startup test goto L230b; // 0008: ld (hl), a // rst 8 - memset() // Fill 'hl' to 'hl+b' with 'a' L0008: mspacmanIndirectWrite8(Z80HL, Z80A); // 0009: inc hl Z80HL = (UINT16) (Z80HL + 1); // 000a: djnz 08h Z80B = (UINT8) (Z80B - 1); if (Z80B != 0) { goto L0008; } L000c: // 000c: ret goto returnInstruction; L000d: // 000d: jp 070eh ; junk goto L070e; L0010: // Replaced code from 0x0010-0x0016 with the following: Z80HL = (UINT16) (Z80HL + Z80A); Z80A = mem[Z80HL]; // 0x0011 Replaced // 0x0012 Replaced // 0x0014 Replaced // 0x0015 Replaced // 0x0016 Replaced L0017: // 0017: ret goto returnInstruction; // 0018: ld a, b // rst 18 (for dereferencing pointers to words) // hl = hl + 2*b, (hl) -> e, (++hl) -> d, de -> hl // HL = base address of table // B = index // after the call, DE gets the data in HL+(2*B) // modified: DE, A L0018: Z80A = (UINT8) (Z80B); { UINT16 u16Temp0; // 0019: add a, a u16Temp0 = Z80A + Z80A; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80A))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80A ^ Z80A ^ 0x80) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 001a: rst 10h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x1b; goto L0010; L001b: // 001b: ld e, a Z80E = (UINT8) (Z80A); // 001c: inc hl Z80HL = (UINT16) (Z80HL + 1); // 001d: ld d, (hl) Z80D = (UINT8) (mem[Z80HL]); { UINT16 u16Temp0; // 001e: ex de, hl u16Temp0 = Z80HL; Z80HL = (UINT16) (Z80DE); Z80DE = (UINT16) (u16Temp0); } // 001f: ret goto returnInstruction; // 0020: pop hl // rst 20 (for dereferencing pointers to pointers to functions) L0020: Z80L = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); Z80H = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); { UINT16 u16Temp0; // 0021: add a, a u16Temp0 = Z80A + Z80A; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80A))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80A ^ Z80A ^ 0x80) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 0022: rst 10h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x23; goto L0010; L0023: // 0023: ld e, a Z80E = (UINT8) (Z80A); // 0024: inc hl Z80HL = (UINT16) (Z80HL + 1); // 0025: ld d, (hl) Z80D = (UINT8) (mem[Z80HL]); { UINT16 u16Temp0; // 0026: ex de, hl u16Temp0 = Z80HL; Z80HL = (UINT16) (Z80DE); Z80DE = (UINT16) (u16Temp0); } // 0027: jp (hl) Z80PC = (UINT16) (Z80HL); goto goToPC; // 0028: pop hl ; next byte after call // rst 28 // this is completely baffling me L0028: Z80L = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); Z80H = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); // 0029: ld b, (hl) Z80B = (UINT8) (mem[Z80HL]); // 002a: inc hl Z80HL = (UINT16) (Z80HL + 1); // 002b: ld c, (hl) Z80C = (UINT8) (mem[Z80HL]); // 002c: inc hl ; bc gets the word after the call Z80HL = (UINT16) (Z80HL + 1); // 002d: push hl ; adjust return value Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80H; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80L; // 002e: jr 42h goto L0042; // 0030: ld de, 4c90h // rst 30 L0030: Z80DE = (UINT16) (0x4c90); // 0033: ld b, 10h Z80B = (UINT8) (0x10); // 0035: jp 0051h goto L0051; // 0038: jp 1f9bh ; patched jump from pacman. // rst 38 (vblank) // Interrupt mode 1 handler L0038: Draw_Frame = 1; Z80PC = 0x1f9b; goto adjustTimingCounter; // return(0); goto L1f9b; // 0042: ld hl, (4c80h) ; hl = (4c80) // continuation of rst 28 L0042: Z80L = (UINT8) (mem[0x4c80]); Z80H = (UINT8) (mem[0x4c81]); // 0045: ld (hl), b mspacmanIndirectWrite8(Z80HL, Z80B); // 0046: inc l Z80L = (UINT8) (Z80L + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80L == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80L & 0x80) ? 0x80 : 0); if ((Z80L & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80L == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 0047: ld (hl), c mspacmanIndirectWrite8(Z80HL, Z80C); // 0048: inc l ; ((4c80), (4c81)) = bc Z80L = (UINT8) (Z80L + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80L == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80L & 0x80) ? 0x80 : 0); if ((Z80L & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80L == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 0049: jr nz, 4dh if (((u8Flags & 0x40) >> 6) != 1) { goto L004d; } // 004b: ld L, 0c0h ; if( c==00 ) l = c0 (spins c0-ff) Z80L = (UINT8) (0xc0); // 004d: ld (4c80h), hl ; (4c80, 4c81) = hl L004d: mem[0x4c80] = Z80L; mem[0x4c81] = Z80H; // 0050: ret goto returnInstruction; // 0051: ld a, (de) // rst 30 continuation L0051: Z80A = (UINT8) (mem[Z80DE]); // 0052: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 0053: jr z, 5bh if (((u8Flags & 0x40) >> 6) == 1) { goto L005b; } // 0055: inc e Z80E = (UINT8) (Z80E + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80E == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80E & 0x80) ? 0x80 : 0); if ((Z80E & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80E == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 0056: inc e Z80E = (UINT8) (Z80E + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80E == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80E & 0x80) ? 0x80 : 0); if ((Z80E & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80E == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 0057: inc e Z80E = (UINT8) (Z80E + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80E == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80E & 0x80) ? 0x80 : 0); if ((Z80E & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80E == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 0058: djnz 51h Z80B = (UINT8) (Z80B - 1); if (Z80B != 0) { goto L0051; } // 005a: ret goto returnInstruction; // 005b: pop hl L005b: Z80L = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); Z80H = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); // 005c: ld b, 03h Z80B = (UINT8) (0x03); // 005e: ld a, (hl) L005e: Z80A = (UINT8) (mem[Z80HL]); // 005f: ld (de), a mspacmanIndirectWrite8(Z80DE, Z80A); // 0060: inc hl Z80HL = (UINT16) (Z80HL + 1); // 0061: inc e Z80E = (UINT8) (Z80E + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80E == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80E & 0x80) ? 0x80 : 0); if ((Z80E & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80E == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 0062: djnz 5eh Z80B = (UINT8) (Z80B - 1); if (Z80B != 0) { goto L005e; } // 0064: jp (hl) Z80PC = (UINT16) (Z80HL); goto goToPC; // 0065: jp 202dh // this is a common call L0065: goto L202d; // 008d: push af // part of the interrupt routine (non-test) // continuation of RST 38 partially... (vblank) // (gets called from the 1f9b test subroutine) L008d: Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80A; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = u8Flags; // 008e: ld (Wdog), a ; kick the dog MSNothingWrite(0x50c0,Z80A); // 0091: xor a, a ; 0 -> a Z80A = (UINT8) (0); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 0092: ld (IRQEn), a ; disable hardware interrupts MSStuffWrite(0x5000,Z80A); // 0095: di ; disable cpu interrupts Z80iff &= 0xfe; // 0096: push bc Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80B; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80C; // 0097: push de Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80D; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80E; // 0098: push hl Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80H; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80L; // 0099: push ix Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80XH; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80XL; // 009b: push iy Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80YH; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80YL; // 009d: ld hl, 4e8ch ; write freq/volume for sound regs // load the sound into the hardware Z80HL = (UINT16) (0x4e8c); L00a0: // 00a0: ld de, V1Frq ; sound voice frequency Z80DE = (UINT16) (0x5050); // 00a3: ld bc, 0010h ; bc = 10 Z80BC = (UINT16) (0x10); // 00a6: ldir UniqueLabel0: mspacmanIndirectWrite8(Z80DE, mem[Z80HL]); Z80HL = (UINT16) (Z80HL + 1); Z80DE = (UINT16) (Z80DE + 1); Z80BC = (UINT16) (Z80BC - 1); if (Z80BC != 0) { goto UniqueLabel0; } u8Flags &= 0xef; u8Flags &= 0xfd; if (Z80BC == 0) { u8Flags &= 0xfb; } else { u8Flags |= 0x04; } // 00a8: ld a, (4ecch) Z80A = (UINT8) (mem[0x4ecc]); // 00ab: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 00ac: ld a, (4ecfh) // write sound waveforms Z80A = (UINT8) (mem[0x4ecf]); // 00af: jr nz, 0b4h if (((u8Flags & 0x40) >> 6) != 1) { goto L00b4; } // 00b1: ld a, (4e9fh) Z80A = (UINT8) (mem[0x4e9f]); // 00b4: ld (V1Wav), a ; sound voice 1 waveform L00b4: MSStuffWrite(0x5045,Z80A); // 00b7: ld a, (4edch) Z80A = (UINT8) (mem[0x4edc]); // 00ba: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 00bb: ld a, (4edfh) Z80A = (UINT8) (mem[0x4edf]); // 00be: jr nz, 0c3h if (((u8Flags & 0x40) >> 6) != 1) { goto L00c3; } // 00c0: ld a, (4eafh) // jp here from table Z80A = (UINT8) (mem[0x4eaf]); // 00c3: ld (V2Wav), a ; sound voice 2 waveform L00c3: MSStuffWrite(0x504a,Z80A); // 00c6: ld a, (4eech) Z80A = (UINT8) (mem[0x4eec]); // 00c9: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 00ca: ld a, (4eefh) Z80A = (UINT8) (mem[0x4eef]); // 00cd: jr nz, 0d2h if (((u8Flags & 0x40) >> 6) != 1) { goto L00d2; } // 00cf: ld a, (4ebfh) Z80A = (UINT8) (mem[0x4ebf]); // 00d2: ld (V3Wav), a ; sound voice 3 waveform L00d2: MSStuffWrite(0x504f,Z80A); // 00d5: ld hl, 4c02h Z80HL = (UINT16) (0x4c02); // 00d8: ld de, 4c22h Z80DE = (UINT16) (0x4c22); // 00db: ld bc, 001ch Z80BC = (UINT16) (0x1c); // 00de: ldir UniqueLabel1: mspacmanIndirectWrite8(Z80DE, mem[Z80HL]); Z80HL = (UINT16) (Z80HL + 1); Z80DE = (UINT16) (Z80DE + 1); Z80BC = (UINT16) (Z80BC - 1); if (Z80BC != 0) { goto UniqueLabel1; } u8Flags &= 0xef; u8Flags &= 0xfd; if (Z80BC == 0) { u8Flags &= 0xfb; } else { u8Flags |= 0x04; } // 00e0: ld ix, 4c20h Z80IX = (UINT16) (0x4c20); // 00e4: ld a, (ix+02h) Z80A = (UINT8) (mem[Z80IX + 0x02]); // 00e7: rlca u8Flags = (u8Flags & ~0x01) | ((Z80A & 0x80) ? 0x01 : 0); Z80A = (UINT8) (((Z80A << 1) | (Z80A >> 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 00e8: rlca u8Flags = (u8Flags & ~0x01) | ((Z80A & 0x80) ? 0x01 : 0); Z80A = (UINT8) (((Z80A << 1) | (Z80A >> 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 00e9: ld (ix+02h), a mspacmanIndirectWrite8(Z80IX + 0x02, Z80A); // 00ec: ld a, (ix+04h) Z80A = (UINT8) (mem[Z80IX + 0x04]); // 00ef: rlca u8Flags = (u8Flags & ~0x01) | ((Z80A & 0x80) ? 0x01 : 0); Z80A = (UINT8) (((Z80A << 1) | (Z80A >> 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 00f0: rlca u8Flags = (u8Flags & ~0x01) | ((Z80A & 0x80) ? 0x01 : 0); Z80A = (UINT8) (((Z80A << 1) | (Z80A >> 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 00f1: ld (ix+04h), a mspacmanIndirectWrite8(Z80IX + 0x04, Z80A); // 00f4: ld a, (ix+06h) Z80A = (UINT8) (mem[Z80IX + 0x06]); // 00f7: rlca u8Flags = (u8Flags & ~0x01) | ((Z80A & 0x80) ? 0x01 : 0); Z80A = (UINT8) (((Z80A << 1) | (Z80A >> 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 00f8: rlca u8Flags = (u8Flags & ~0x01) | ((Z80A & 0x80) ? 0x01 : 0); Z80A = (UINT8) (((Z80A << 1) | (Z80A >> 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 00f9: ld (ix+06h), a mspacmanIndirectWrite8(Z80IX + 0x06, Z80A); // 00fc: ld a, (ix+08h) Z80A = (UINT8) (mem[Z80IX + 0x08]); // 00ff: rlca u8Flags = (u8Flags & ~0x01) | ((Z80A & 0x80) ? 0x01 : 0); Z80A = (UINT8) (((Z80A << 1) | (Z80A >> 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 0100: rlca u8Flags = (u8Flags & ~0x01) | ((Z80A & 0x80) ? 0x01 : 0); Z80A = (UINT8) (((Z80A << 1) | (Z80A >> 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 0101: ld (ix+08h), a mspacmanIndirectWrite8(Z80IX + 0x08, Z80A); // 0104: ld a, (ix+0ah) Z80A = (UINT8) (mem[Z80IX + 0x0a]); // 0107: rlca u8Flags = (u8Flags & ~0x01) | ((Z80A & 0x80) ? 0x01 : 0); Z80A = (UINT8) (((Z80A << 1) | (Z80A >> 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 0108: rlca u8Flags = (u8Flags & ~0x01) | ((Z80A & 0x80) ? 0x01 : 0); Z80A = (UINT8) (((Z80A << 1) | (Z80A >> 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 0109: ld (ix+0ah), a mspacmanIndirectWrite8(Z80IX + 0x0a, Z80A); // 010c: ld a, (ix+0ch) Z80A = (UINT8) (mem[Z80IX + 0x0c]); // 010f: rlca u8Flags = (u8Flags & ~0x01) | ((Z80A & 0x80) ? 0x01 : 0); Z80A = (UINT8) (((Z80A << 1) | (Z80A >> 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 0110: rlca u8Flags = (u8Flags & ~0x01) | ((Z80A & 0x80) ? 0x01 : 0); Z80A = (UINT8) (((Z80A << 1) | (Z80A >> 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 0111: ld (ix+0ch), a mspacmanIndirectWrite8(Z80IX + 0x0c, Z80A); // 0114: ld a, (4dd1h) Z80A = (UINT8) (mem[0x4dd1]); { UINT16 u16Temp0; // 0117: cp a, 01h u16Temp0 = Z80A - 1; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 1))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((1 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 0119: jr nz, 0153h if (((u8Flags & 0x40) >> 6) != 1) { goto L0153; } // 011b: ld ix, 4c20h Z80IX = (UINT16) (0x4c20); // 011f: ld a, (4da4h) Z80A = (UINT8) (mem[0x4da4]); { UINT16 u16Temp0; // 0122: add a, a u16Temp0 = Z80A + Z80A; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80A))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80A ^ Z80A ^ 0x80) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 0123: ld e, a Z80E = (UINT8) (Z80A); // 0124: ld d, 00h Z80D = (UINT8) (0); { UINT32 u32Temp0; // 0126: add ix, de u32Temp0 = Z80IX + Z80DE; u8Flags = (u8Flags & ~0x10) | ((((Z80IX ^ u32Temp0 ^ Z80DE) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80IX = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 0128: ld hl, (4c24h) Z80L = (UINT8) (mem[0x4c24]); Z80H = (UINT8) (mem[0x4c25]); // 012b: ld de, (4c34h) Z80E = (UINT8) (mem[0x4c34]); Z80D = (UINT8) (mem[0x4c35]); // 012f: ld a, (ix+00h) Z80A = (UINT8) (mem[Z80IX]); // 0132: ld (4c24h), a mem[0x4c24] = Z80A; // 0135: ld a, (ix+01h) Z80A = (UINT8) (mem[Z80IX + 1]); // 0138: ld (4c25h), a mem[0x4c25] = Z80A; // 013b: ld a, (ix+10h) Z80A = (UINT8) (mem[Z80IX + 0x10]); L013e: // 013e: ld (4c34h), a mem[0x4c34] = Z80A; // 0141: ld a, (ix+11h) Z80A = (UINT8) (mem[Z80IX + 0x11]); // 0144: ld (4c35h), a mem[0x4c35] = Z80A; // 0147: ld (ix+00h), l mspacmanIndirectWrite8(Z80IX, Z80L); // 014a: ld (ix+01h), h mspacmanIndirectWrite8(Z80IX + 1, Z80H); // 014d: ld (ix+10h), e mspacmanIndirectWrite8(Z80IX + 0x10, Z80E); // 0150: ld (ix+11h), d mspacmanIndirectWrite8(Z80IX + 0x11, Z80D); // 0153: ld a, (4da6h) L0153: Z80A = (UINT8) (mem[0x4da6]); // 0156: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 0157: jp z, 0176h if (((u8Flags & 0x40) >> 6) == 1) { goto L0176; } // 015a: ld bc, (4c22h) Z80C = (UINT8) (mem[0x4c22]); Z80B = (UINT8) (mem[0x4c23]); // 015e: ld de, (4c32h) Z80E = (UINT8) (mem[0x4c32]); Z80D = (UINT8) (mem[0x4c33]); // 0162: ld hl, (4c2ah) Z80L = (UINT8) (mem[0x4c2a]); Z80H = (UINT8) (mem[0x4c2b]); // 0165: ld (4c22h), hl mem[0x4c22] = Z80L; mem[0x4c23] = Z80H; // 0168: ld hl, (4c3ah) Z80L = (UINT8) (mem[0x4c3a]); Z80H = (UINT8) (mem[0x4c3b]); // 016b: ld (4c32h), hl mem[0x4c32] = Z80L; mem[0x4c33] = Z80H; // 016e: ld (4c2ah), bc mem[0x4c2a] = Z80C; mem[0x4c2b] = Z80B; // 0172: ld (4c3ah), de mem[0x4c3a] = Z80E; mem[0x4c3b] = Z80D; // 0176: ld hl, 4c22h L0176: Z80HL = (UINT16) (0x4c22); // 0179: ld de, 4ff2h Z80DE = (UINT16) (0x4ff2); // 017c: ld bc, 000ch Z80BC = (UINT16) (0x0c); // 017f: ldir UniqueLabel2: mspacmanIndirectWrite8(Z80DE, mem[Z80HL]); Z80HL = (UINT16) (Z80HL + 1); Z80DE = (UINT16) (Z80DE + 1); Z80BC = (UINT16) (Z80BC - 1); if (Z80BC != 0) { goto UniqueLabel2; } u8Flags &= 0xef; u8Flags &= 0xfd; if (Z80BC == 0) { u8Flags &= 0xfb; } else { u8Flags |= 0x04; } // 0181: ld hl, 4c32h Z80HL = (UINT16) (0x4c32); // 0184: ld de, 5062h Z80DE = (UINT16) (0x5062); // 0187: ld bc, 000ch Z80BC = (UINT16) (0x0c); // 018a: ldir UniqueLabel3: mspacmanIndirectWrite8(Z80DE, mem[Z80HL]); Z80HL = (UINT16) (Z80HL + 1); Z80DE = (UINT16) (Z80DE + 1); Z80BC = (UINT16) (Z80BC - 1); if (Z80BC != 0) { goto UniqueLabel3; } u8Flags &= 0xef; u8Flags &= 0xfd; if (Z80BC == 0) { u8Flags &= 0xfb; } else { u8Flags |= 0x04; } // 018c: call 01dch ; controls the game play - // core game loop Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 1; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x8f; goto L01dc; L018f: // 018f: call 0221h ; controls the moving sprites Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 1; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x92; goto L0221; L0192: // 0192: call 03c8h ; enable sound out and other stuff - Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 1; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x95; goto L03c8; L0195: // 0195: ld a, (4e00h) ; check game mode Z80A = (UINT8) (mem[0x4e00]); // 0198: and a, a ; set flags u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 0199: jr z, 01adh ; skip over next calls if no players if (((u8Flags & 0x40) >> 6) == 1) { goto L01ad; } // 019b: call 039dh ; displays 'READY!' Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 1; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x9e; goto L039d; L019e: // 019e: call 1490h ; display sprites in intro and game Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 1; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xa1; goto L1490; L01a1: // 01a1: call 141fh ; ? Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 1; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xa4; goto L141f; L01a4: // 01a4: call 0267h ; debounce rack input / add credits Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 1; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xa7; goto L0267; L01a7: // 01a7: call 02adh ; debounce coin input / add credits Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 1; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xaa; goto L02ad; L01aa: // 01aa: call 02fdh ; blink coin lights Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 1; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xad; goto L02fd; // 01ad: ld a, (4e00h) ; nplayers L01ad: Z80A = (UINT8) (mem[0x4e00]); // 01b0: dec a Z80A = (UINT8) (Z80A - 1); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); if ((Z80A & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80A == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 01b1: jr nz, 01b9h ; skip if intro mode if (((u8Flags & 0x40) >> 6) != 1) { goto L01b9; } // 01b3: ld (4each), a mem[0x4eac] = Z80A; // 01b6: ld (4ebch), a mem[0x4ebc] = Z80A; // 01b9: call 2d0ch ; something with sound? L01b9: Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 1; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xbc; goto L2d0c; L01bc: // 01bc: call 2cc1h ; something with sound? Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 1; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xbf; goto L2cc1; L01bf: // 01bf: pop iy Z80YL = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); Z80YH = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); // 01c1: pop ix Z80XL = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); Z80XH = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); // 01c3: pop hl Z80L = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); Z80H = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); // 01c4: pop de Z80E = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); Z80D = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); // 01c5: pop bc Z80C = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); Z80B = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); // 01c6: ld a, (4e00h) ; check players Z80A = (UINT8) (mem[0x4e00]); // 01c9: and a, a ; set flags u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 01ca: jr z, 01d4h if (((u8Flags & 0x40) >> 6) == 1) { goto L01d4; } // 01cc: ld a, (V1Acc) ; IN1 Z80A = (UINT8) (mem[0x5040]); // 01cf: and a, 10h ; rack TEST Z80A = (UINT8) (Z80A & 0x10); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 01d1: jp z, Start ; reset if TEST is set if (((u8Flags & 0x40) >> 6) == 1) { goto L0000; } // 01d4: ld a, 01h ; a=1 L01d4: Z80A = (UINT8) (1); // 01d6: ld (IRQEn), a ; reenable hardware interrupts MSStuffWrite(0x5000,Z80A); // 01d9: ei ; enable cpu interrupts Z80iff |= 0x01; Z80iff |= 0x02; s32CyclesRemaining = s32CyclesRemaining - 0x04; // 01da: pop af u8Flags = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); Z80A = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); // 01db: ret ; end goto returnInstruction; // 01dc: ld hl, 4c84h // controls the game play // (stops on game screen when disabled) L01dc: Z80HL = (UINT16) (0x4c84); { UINT8 u8Temp0; // 01df: inc (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 01e0: inc hl Z80HL = (UINT16) (Z80HL + 1); { UINT8 u8Temp0; // 01e1: dec (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] - 1); u8Temp0 = mem[Z80HL]; u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 01e2: inc hl Z80HL = (UINT16) (Z80HL + 1); // 01e3: ld de, 0219h Z80DE = (UINT16) (0x0219); // 01e6: ld bc, 0401h Z80BC = (UINT16) (0x0401); { UINT8 u8Temp0; // 01e9: inc (hl) L01e9: mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 01ea: ld a, (hl) Z80A = (UINT8) (mem[Z80HL]); // 01eb: and a, 0fh Z80A = (UINT8) (Z80A & 0x0f); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); { UINT16 u16Temp0; // 01ed: ex de, hl u16Temp0 = Z80HL; Z80HL = (UINT16) (Z80DE); Z80DE = (UINT16) (u16Temp0); } { UINT16 u16Temp0; UINT8 u8Temp0; // 01ee: cp a, (hl) u8Temp0 = mem[Z80HL]; u16Temp0 = Z80A - u8Temp0; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ u8Temp0))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((u8Temp0 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 01ef: jr nz, 0204h if (((u8Flags & 0x40) >> 6) != 1) { goto L0204; } // 01f1: inc c Z80C = (UINT8) (Z80C + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80C == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80C & 0x80) ? 0x80 : 0); if ((Z80C & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80C == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 01f2: ld a, (de) Z80A = (UINT8) (mem[Z80DE]); { UINT16 u16Temp0; // 01f3: add a, 10h u16Temp0 = Z80A + 0x10; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x10))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x10 ^ Z80A ^ 0x80) & (0x10 ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 01f5: and a, 0f0h Z80A = (UINT8) (Z80A & 0xf0); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 01f7: ld (de), a mspacmanIndirectWrite8(Z80DE, Z80A); // 01f8: inc hl Z80HL = (UINT16) (Z80HL + 1); { UINT16 u16Temp0; UINT8 u8Temp0; // 01f9: cp a, (hl) u8Temp0 = mem[Z80HL]; u16Temp0 = Z80A - u8Temp0; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ u8Temp0))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((u8Temp0 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 01fa: jr nz, 0204h if (((u8Flags & 0x40) >> 6) != 1) { goto L0204; } // 01fc: inc c Z80C = (UINT8) (Z80C + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80C == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80C & 0x80) ? 0x80 : 0); if ((Z80C & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80C == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } { UINT16 u16Temp0; // 01fd: ex de, hl u16Temp0 = Z80HL; Z80HL = (UINT16) (Z80DE); Z80DE = (UINT16) (u16Temp0); } // 01fe: ld (hl), 00h mspacmanIndirectWrite8(Z80HL, 0); // 0200: inc hl Z80HL = (UINT16) (Z80HL + 1); // 0201: inc de Z80DE = (UINT16) (Z80DE + 1); // 0202: djnz 01e9h Z80B = (UINT8) (Z80B - 1); if (Z80B != 0) { goto L01e9; } // 0204: ld hl, 4c8ah L0204: Z80HL = (UINT16) (0x4c8a); // 0207: ld (hl), c mspacmanIndirectWrite8(Z80HL, Z80C); // 0208: inc l Z80L = (UINT8) (Z80L + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80L == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80L & 0x80) ? 0x80 : 0); if ((Z80L & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80L == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 0209: ld a, (hl) Z80A = (UINT8) (mem[Z80HL]); { UINT16 u16Temp0; // 020a: add a, a u16Temp0 = Z80A + Z80A; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80A))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80A ^ Z80A ^ 0x80) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } { UINT16 u16Temp0; // 020b: add a, a u16Temp0 = Z80A + Z80A; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80A))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80A ^ Z80A ^ 0x80) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } { UINT16 u16Temp0; UINT8 u8Temp0; // 020c: add a, (hl) u8Temp0 = mem[Z80HL]; u16Temp0 = Z80A + u8Temp0; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ u8Temp0))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((u8Temp0 ^ Z80A ^ 0x80) & (u8Temp0 ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 020d: inc a Z80A = (UINT8) (Z80A + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); if ((Z80A & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80A == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 020e: ld (hl), a mspacmanIndirectWrite8(Z80HL, Z80A); // 020f: inc l Z80L = (UINT8) (Z80L + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80L == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80L & 0x80) ? 0x80 : 0); if ((Z80L & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80L == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 0210: ld a, (hl) Z80A = (UINT8) (mem[Z80HL]); { UINT16 u16Temp0; // 0211: add a, a u16Temp0 = Z80A + Z80A; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80A))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80A ^ Z80A ^ 0x80) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } { UINT16 u16Temp0; UINT8 u8Temp0; // 0212: add a, (hl) u8Temp0 = mem[Z80HL]; u16Temp0 = Z80A + u8Temp0; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ u8Temp0))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((u8Temp0 ^ Z80A ^ 0x80) & (u8Temp0 ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } { UINT16 u16Temp0; // 0213: add a, a u16Temp0 = Z80A + Z80A; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80A))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80A ^ Z80A ^ 0x80) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } { UINT16 u16Temp0; // 0214: add a, a u16Temp0 = Z80A + Z80A; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80A))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80A ^ Z80A ^ 0x80) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } { UINT16 u16Temp0; UINT8 u8Temp0; // 0215: add a, (hl) u8Temp0 = mem[Z80HL]; u16Temp0 = Z80A + u8Temp0; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ u8Temp0))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((u8Temp0 ^ Z80A ^ 0x80) & (u8Temp0 ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 0216: inc a Z80A = (UINT8) (Z80A + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); if ((Z80A & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80A == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 0217: ld (hl), a mspacmanIndirectWrite8(Z80HL, Z80A); // 0218: ret goto returnInstruction; // 0221: ld hl, 4c90h // controls the moving sprites L0221: Z80HL = (UINT16) (0x4c90); // 0224: ld a, (4c8ah) Z80A = (UINT8) (mem[0x4c8a]); // 0227: ld c, a Z80C = (UINT8) (Z80A); // 0228: ld b, 10h Z80B = (UINT8) (0x10); // 022a: ld a, (hl) L022a: Z80A = (UINT8) (mem[Z80HL]); // 022b: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 022c: jr z, 025dh if (((u8Flags & 0x40) >> 6) == 1) { goto L025d; } // 022e: and a, 0c0h Z80A = (UINT8) (Z80A & 0xc0); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 0230: rlca u8Flags = (u8Flags & ~0x01) | ((Z80A & 0x80) ? 0x01 : 0); Z80A = (UINT8) (((Z80A << 1) | (Z80A >> 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 0231: rlca u8Flags = (u8Flags & ~0x01) | ((Z80A & 0x80) ? 0x01 : 0); Z80A = (UINT8) (((Z80A << 1) | (Z80A >> 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; { UINT16 u16Temp0; // 0232: cp a, c u16Temp0 = Z80A - Z80C; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80C))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80C ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 0233: jr nc, 025dh if (((u8Flags & 0x01) >> 0) != 1) { goto L025d; } { UINT8 u8Temp0; // 0235: dec (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] - 1); u8Temp0 = mem[Z80HL]; u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 0236: ld a, (hl) Z80A = (UINT8) (mem[Z80HL]); // 0237: and a, 3fh Z80A = (UINT8) (Z80A & 0x3f); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 0239: jr nz, 025dh if (((u8Flags & 0x40) >> 6) != 1) { goto L025d; } // 023b: ld (hl), a mspacmanIndirectWrite8(Z80HL, Z80A); // 023c: push bc Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80B; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80C; // 023d: push hl Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80H; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80L; // 023e: inc l Z80L = (UINT8) (Z80L + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80L == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80L & 0x80) ? 0x80 : 0); if ((Z80L & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80L == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 023f: ld a, (hl) Z80A = (UINT8) (mem[Z80HL]); // 0240: inc l Z80L = (UINT8) (Z80L + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80L == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80L & 0x80) ? 0x80 : 0); if ((Z80L & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80L == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 0241: ld b, (hl) Z80B = (UINT8) (mem[Z80HL]); // 0242: ld hl, 025bh Z80HL = (UINT16) (0x025b); // 0245: push hl Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80H; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80L; // 0246: rst 20h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x02; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x47; goto L0020; L025b: // 025b: pop hl Z80L = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); Z80H = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); // 025c: pop bc Z80C = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); Z80B = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); // 025d: inc l L025d: Z80L = (UINT8) (Z80L + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80L == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80L & 0x80) ? 0x80 : 0); if ((Z80L & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80L == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 025e: inc l Z80L = (UINT8) (Z80L + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80L == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80L & 0x80) ? 0x80 : 0); if ((Z80L & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80L == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 025f: inc l Z80L = (UINT8) (Z80L + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80L == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80L & 0x80) ? 0x80 : 0); if ((Z80L & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80L == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 0260: djnz 022ah Z80B = (UINT8) (Z80B - 1); if (Z80B != 0) { goto L022a; } // 0262: ret goto returnInstruction; L0263: // 0263: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x02; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x64; goto L0028; L0264: // 0264: inc e Z80E = (UINT8) (Z80E + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80E == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80E & 0x80) ? 0x80 : 0); if ((Z80E & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80E == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } { UINT16 u16Temp0; UINT8 u8Temp0; // 0265: add a, (hl) u8Temp0 = mem[Z80HL]; u16Temp0 = Z80A + u8Temp0; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ u8Temp0))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((u8Temp0 ^ Z80A ^ 0x80) & (u8Temp0 ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } L0266: // 0266: ret goto returnInstruction; // 0267: ld a, (credits) ; number of current credits // debounce rack input / add credits (if 99 or over, return) L0267: Z80A = (UINT8) (mem[0x4e6e]); { UINT16 u16Temp0; // 026a: cp a, 99h ; max coins u16Temp0 = Z80A - 0x99; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x99))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x99 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } { UINT8 u8Temp0; // 026c: rla ; then lockout u8Temp0 = ((u8Flags & 0x01) >> 0); u8Flags = (u8Flags & ~0x01) | ((Z80A & 0x80) ? 0x01 : 0); Z80A = (UINT8) (((Z80A << 1) | u8Temp0)); u8Flags &= 0xfd; u8Flags &= 0xef; } // 026d: ld (coinlk), a ; coin lockout MSStuffWrite(0x5006,Z80A); { UINT8 u8Temp0; // 0270: rra u8Temp0 = ((u8Flags & 0x01) >> 0) << 0x07; u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (((Z80A >> 1) | u8Temp0)); u8Flags &= 0xfd; u8Flags &= 0xef; } // 0271: ret nc ; return if 99 credits if (((u8Flags & 0x01) >> 0) != 1) { goto returnInstruction; } // 0272: ld a, (IRQEn) ; check IN0 input Z80A = (UINT8) (mem[0x5000]); // 0275: ld b, a ; b=a Z80B = (UINT8) (Z80A); // 0276: rlc b ; rotate left u8Flags = (u8Flags & ~0x01) | ((Z80B & 0x80) ? 0x01 : 0); Z80B = (UINT8) (((Z80B << 1) | (Z80B >> 0x07))); u8Flags = (u8Flags & ~0x80) | ((Z80B & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x40) | ((Z80B == 0) ? 0x40 : 0); u8Flags &= 0xef; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x04) | (((((((Z80B >> 0x07) & 1) + ((Z80B >> 0x06) & 1) + ((Z80B >> 0x05) & 1) + ((Z80B >> 0x04) & 1) + ((Z80B >> 0x03) & 1) + ((Z80B >> 0x02) & 1) + ((Z80B >> 1) & 1) + ((Z80B >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 0278: ld a, (4e66h) ; ? Z80A = (UINT8) (mem[0x4e66]); { UINT8 u8Temp0; // 027b: rla ; rotate left with carry u8Temp0 = ((u8Flags & 0x01) >> 0); u8Flags = (u8Flags & ~0x01) | ((Z80A & 0x80) ? 0x01 : 0); Z80A = (UINT8) (((Z80A << 1) | u8Temp0)); u8Flags &= 0xfd; u8Flags &= 0xef; } // 027c: and a, 0fh ; and it with 0f Z80A = (UINT8) (Z80A & 0x0f); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 027e: ld (4e66h), a ; put it back mem[0x4e66] = Z80A; { UINT16 u16Temp0; // 0281: sub a, 0ch ; a=a-$C u16Temp0 = Z80A - 0x0c; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x0c))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x0c ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 0283: call z, 02dfh ; call $2df if a==0 ; add coin if (((u8Flags & 0x40) >> 6) == 1) { Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x02; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x86; goto L02df; } L0286: // 0286: rlc b u8Flags = (u8Flags & ~0x01) | ((Z80B & 0x80) ? 0x01 : 0); Z80B = (UINT8) (((Z80B << 1) | (Z80B >> 0x07))); u8Flags = (u8Flags & ~0x80) | ((Z80B & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x40) | ((Z80B == 0) ? 0x40 : 0); u8Flags &= 0xef; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x04) | (((((((Z80B >> 0x07) & 1) + ((Z80B >> 0x06) & 1) + ((Z80B >> 0x05) & 1) + ((Z80B >> 0x04) & 1) + ((Z80B >> 0x03) & 1) + ((Z80B >> 0x02) & 1) + ((Z80B >> 1) & 1) + ((Z80B >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 0288: ld a, (4e67h) Z80A = (UINT8) (mem[0x4e67]); { UINT8 u8Temp0; // 028b: rla u8Temp0 = ((u8Flags & 0x01) >> 0); u8Flags = (u8Flags & ~0x01) | ((Z80A & 0x80) ? 0x01 : 0); Z80A = (UINT8) (((Z80A << 1) | u8Temp0)); u8Flags &= 0xfd; u8Flags &= 0xef; } // 028c: and a, 0fh Z80A = (UINT8) (Z80A & 0x0f); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 028e: ld (4e67h), a mem[0x4e67] = Z80A; { UINT16 u16Temp0; // 0291: sub a, 0ch u16Temp0 = Z80A - 0x0c; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x0c))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x0c ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 0293: jp nz, 029ah if (((u8Flags & 0x40) >> 6) != 1) { goto L029a; } // 0296: ld hl, 4e69h ; increment credits Z80HL = (UINT16) (0x4e69); { UINT8 u8Temp0; // 0299: inc (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 029a: rlc b L029a: u8Flags = (u8Flags & ~0x01) | ((Z80B & 0x80) ? 0x01 : 0); Z80B = (UINT8) (((Z80B << 1) | (Z80B >> 0x07))); u8Flags = (u8Flags & ~0x80) | ((Z80B & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x40) | ((Z80B == 0) ? 0x40 : 0); u8Flags &= 0xef; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x04) | (((((((Z80B >> 0x07) & 1) + ((Z80B >> 0x06) & 1) + ((Z80B >> 0x05) & 1) + ((Z80B >> 0x04) & 1) + ((Z80B >> 0x03) & 1) + ((Z80B >> 0x02) & 1) + ((Z80B >> 1) & 1) + ((Z80B >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 029c: ld a, (4e68h) Z80A = (UINT8) (mem[0x4e68]); { UINT8 u8Temp0; // 029f: rla u8Temp0 = ((u8Flags & 0x01) >> 0); u8Flags = (u8Flags & ~0x01) | ((Z80A & 0x80) ? 0x01 : 0); Z80A = (UINT8) (((Z80A << 1) | u8Temp0)); u8Flags &= 0xfd; u8Flags &= 0xef; } // 02a0: and a, 0fh Z80A = (UINT8) (Z80A & 0x0f); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 02a2: ld (4e68h), a mem[0x4e68] = Z80A; { UINT16 u16Temp0; // 02a5: sub a, 0ch u16Temp0 = Z80A - 0x0c; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x0c))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x0c ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 02a7: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 02a8: ld hl, 4e69h Z80HL = (UINT16) (0x4e69); { UINT8 u8Temp0; // 02ab: inc (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 02ac: ret goto returnInstruction; // 02ad: ld a, (4e69h) ; increment credits // debounce coin input / add credits L02ad: Z80A = (UINT8) (mem[0x4e69]); // 02b0: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 02b1: ret z ; if it's zero, return if (((u8Flags & 0x40) >> 6) == 1) { goto returnInstruction; } // 02b2: ld b, a Z80B = (UINT8) (Z80A); // 02b3: ld a, (4e6ah) Z80A = (UINT8) (mem[0x4e6a]); // 02b6: ld e, a Z80E = (UINT8) (Z80A); { UINT16 u16Temp0; // 02b7: cp a, 00h u16Temp0 = Z80A; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 02b9: jp nz, 02c4h if (((u8Flags & 0x40) >> 6) != 1) { goto L02c4; } // 02bc: ld a, 01h Z80A = (UINT8) (1); // 02be: ld (coinct), a MSStuffWrite(0x5007,Z80A); // 02c1: call 02dfh Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x02; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xc4; goto L02df; // 02c4: ld a, e L02c4: Z80A = (UINT8) (Z80E); { UINT16 u16Temp0; // 02c5: cp a, 08h u16Temp0 = Z80A - 0x08; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x08))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x08 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 02c7: jp nz, 02ceh if (((u8Flags & 0x40) >> 6) != 1) { goto L02ce; } // 02ca: xor a, a Z80A = (UINT8) (0); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 02cb: ld (coinct), a ; coin counter MSStuffWrite(0x5007,Z80A); // 02ce: inc e L02ce: Z80E = (UINT8) (Z80E + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80E == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80E & 0x80) ? 0x80 : 0); if ((Z80E & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80E == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 02cf: ld a, e Z80A = (UINT8) (Z80E); // 02d0: ld (4e6ah), a ; credit memory = a mem[0x4e6a] = Z80A; { UINT16 u16Temp0; // 02d3: sub a, 10h u16Temp0 = Z80A - 0x10; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x10))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x10 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 02d5: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 02d6: ld (4e6ah), a mem[0x4e6a] = Z80A; // 02d9: dec b Z80B = (UINT8) (Z80B - 1); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((Z80B == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80B & 0x80) ? 0x80 : 0); if ((Z80B & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80B == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 02da: ld a, b Z80A = (UINT8) (Z80B); // 02db: ld (4e69h), a mem[0x4e69] = Z80A; // 02de: ret goto returnInstruction; // 02df: ld a, (xcoin) ; #coins per #credits // coins -> credits routine L02df: Z80A = (UINT8) (mem[0x4e6b]); // 02e2: ld hl, 4e6ch ; leftover coins Z80HL = (UINT16) (0x4e6c); { UINT8 u8Temp0; // 02e5: inc (hl) ; add 1 mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } { UINT16 u16Temp0; UINT8 u8Temp0; // 02e6: sub a, (hl) u8Temp0 = mem[Z80HL]; u16Temp0 = Z80A - u8Temp0; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ u8Temp0))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((u8Temp0 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 02e7: ret nz ; not enough coins for credits if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 02e8: ld (hl), a ; store leftover coins mspacmanIndirectWrite8(Z80HL, Z80A); // 02e9: ld a, (xcred) ; #credits per #coins Z80A = (UINT8) (mem[0x4e6d]); // 02ec: ld hl, credits ; #credits Z80HL = (UINT16) (0x4e6e); { UINT16 u16Temp0; UINT8 u8Temp0; // 02ef: add a, (hl) ; add # credits u8Temp0 = mem[Z80HL]; u16Temp0 = Z80A + u8Temp0; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ u8Temp0))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((u8Temp0 ^ Z80A ^ 0x80) & (u8Temp0 ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } { UINT16 u16Temp0; // 02f0: daa u16Temp0 = (Z80A | (((u8Flags & 0x01) >> 0) << 0x08) | (((u8Flags & 0x10) >> 4) << 0x09) | (((u8Flags & 0x02) >> 1) << 0x0a)); u8Flags = (UINT8) (sg_u16DAATable[u16Temp0] >> 0x08); Z80A = (UINT8) (sg_u16DAATable[u16Temp0] & 0xff); } // 02f1: jp nc, 02f6h if (((u8Flags & 0x01) >> 0) != 1) { goto L02f6; } // 02f4: ld a, 99h Z80A = (UINT8) (0x99); // 02f6: ld (hl), a ; store #credits, max 99 L02f6: mspacmanIndirectWrite8(Z80HL, Z80A); // 02f7: ld hl, 4e9ch Z80HL = (UINT16) (0x4e9c); // 02fa: set 1, (hl) ; set bit 1 of 4e9c (play a sound) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] | 0x02); // 02fc: ret goto returnInstruction; // 02fd: ld hl, 4dceh // blink coin lights, print player 1 and player 2, check for mode 3 L02fd: Z80HL = (UINT16) (0x4dce); { UINT8 u8Temp0; // 0300: inc (hl) ; increment whats in $4dce mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 0301: ld a, (hl) ; a = alue in 4cf Z80A = (UINT8) (mem[Z80HL]); // 0302: and a, 0fh ; and with $0f Z80A = (UINT8) (Z80A & 0x0f); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 0304: jr nz, 0325h ; if not 0, jump if (((u8Flags & 0x40) >> 6) != 1) { goto L0325; } // 0306: ld a, (hl) ; shift right Z80A = (UINT8) (mem[Z80HL]); // 0307: rrca u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (((Z80A >> 1) | (Z80A << 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 0308: rrca u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (((Z80A >> 1) | (Z80A << 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 0309: rrca u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (((Z80A >> 1) | (Z80A << 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 030a: rrca u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (((Z80A >> 1) | (Z80A << 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 030b: ld b, a ; b=a Z80B = (UINT8) (Z80A); // 030c: ld a, (4dd6h) // blink coin lights to pellets ; HACK11 Z80A = (UINT8) (mem[0x4dd6]); // 030f: cpl ; compliment Z80A = (UINT8) (Z80A ^ 0xff); u8Flags |= 0x10; u8Flags |= 0x02; // 0310: or a, b ; or b Z80A = (UINT8) (Z80A | Z80B); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 0311: ld c, a ; c=a Z80C = (UINT8) (Z80A); // 0312: ld a, (credits) ; a = number of credits Z80A = (UINT8) (mem[0x4e6e]); { UINT16 u16Temp0; // 0315: sub a, 01h ; subtract one from it. u16Temp0 = Z80A - 1; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 1))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((1 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 0317: jr nc, 031bh ; if carry not 0 then jump if (((u8Flags & 0x01) >> 0) != 1) { goto L031b; } // 0319: xor a, a Z80A = (UINT8) (0); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 031a: ld c, a Z80C = (UINT8) (Z80A); // 031b: jr z, SetStartLamps L031b: if (((u8Flags & 0x40) >> 6) == 1) { goto L031e; } // 031d: ld a, c Z80A = (UINT8) (Z80C); // 031e: ld (p2lamp), a ; player 2 start lamp L031e: MSStuffWrite(0x5005,Z80A); // 0321: ld a, c Z80A = (UINT8) (Z80C); // 0322: ld (p1lamp), a ; player 1 start lamp MSStuffWrite(0x5004,Z80A); // 0325: ld ix, 43d8h L0325: Z80IX = (UINT16) (0x43d8); // 0329: ld iy, 43c5h Z80IY = (UINT16) (0x43c5); // 032d: ld a, (4e00h) ; game mode? // determine 1p or 2p Z80A = (UINT8) (mem[0x4e00]); { UINT16 u16Temp0; // 0330: cp a, 03h u16Temp0 = Z80A - 0x03; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x03))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x03 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 0332: jp z, 0344h ; Jump if 1 or 2 players if (((u8Flags & 0x40) >> 6) == 1) { goto L0344; } // 0335: ld a, (4e03h) Z80A = (UINT8) (mem[0x4e03]); { UINT16 u16Temp0; // 0338: cp a, 02h u16Temp0 = Z80A - 0x02; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x02))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x02 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 033a: jp nc, 0344h if (((u8Flags & 0x01) >> 0) != 1) { goto L0344; } // 033d: call 0369h ; draw '1UP' Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x03; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x40; goto L0369; L0340: // 0340: call 0376h ; draw '2UP' Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x03; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x43; goto L0376; L0343: // 0343: ret goto returnInstruction; // 0344: ld a, (4e09h) // display and blink 1UP/2UP depending on player up L0344: Z80A = (UINT8) (mem[0x4e09]); // 0347: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 0348: ld a, (4dceh) Z80A = (UINT8) (mem[0x4dce]); // 034b: jp nz, 0359h if (((u8Flags & 0x40) >> 6) != 1) { goto L0359; } // 034e: bit 4, a u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0x10) == 0)) ? 0x40 : 0); u8Flags |= 0x10; u8Flags &= 0xfd; // 0350: call z, 0369h ; draw '1UP' if (((u8Flags & 0x40) >> 6) == 1) { Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x03; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x53; goto L0369; } L0353: // 0353: call nz, 0383h ; clear '1UP' if (((u8Flags & 0x40) >> 6) != 1) { Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x03; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x56; goto L0383; } L0356: // 0356: jp 0361h goto L0361; // 0359: bit 4, a L0359: u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0x10) == 0)) ? 0x40 : 0); u8Flags |= 0x10; u8Flags &= 0xfd; // 035b: call z, 0376h ; draw '1UP' if (((u8Flags & 0x40) >> 6) == 1) { Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x03; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x5e; goto L0376; } L035e: // 035e: call nz, 0390h ; clear '2UP' if (((u8Flags & 0x40) >> 6) != 1) { Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x03; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x61; goto L0390; } // 0361: ld a, (coincrd) ; players 0=1 1=2 L0361: Z80A = (UINT8) (mem[0x4e70]); // 0364: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 0365: call z, 0390h ; clear '2UP' if (((u8Flags & 0x40) >> 6) == 1) { Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x03; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x68; goto L0390; } L0368: // 0368: ret goto returnInstruction; // 0369: ld (ix+00h), 50h ; 'P' // draw '1UP' L0369: mspacmanIndirectWrite8(Z80IX, 0x50); // 036d: ld (ix+01h), 55h ; 'U' mspacmanIndirectWrite8(Z80IX + 1, 0x55); // 0371: ld (ix+02h), 31h ; '1' mspacmanIndirectWrite8(Z80IX + 0x02, 0x31); // 0375: ret goto returnInstruction; // 0376: ld (iy+00h), 50h ; 'P' // draw '2UP' L0376: mspacmanIndirectWrite8(Z80IY, 0x50); // 037a: ld (iy+01h), 55h ; 'U' mspacmanIndirectWrite8(Z80IY + 1, 0x55); // 037e: ld (iy+02h), 32h ; '2' mspacmanIndirectWrite8(Z80IY + 0x02, 0x32); // 0382: ret goto returnInstruction; // 0383: ld (ix+00h), 40h ; ' ' // clear '1UP' L0383: mspacmanIndirectWrite8(Z80IX, 0x40); // 0387: ld (ix+01h), 40h ; ' ' mspacmanIndirectWrite8(Z80IX + 1, 0x40); // 038b: ld (ix+02h), 40h ; ' ' mspacmanIndirectWrite8(Z80IX + 0x02, 0x40); // 038f: ret goto returnInstruction; // 0390: ld (iy+00h), 40h ; ' ' // clear '2UP' L0390: mspacmanIndirectWrite8(Z80IY, 0x40); // 0394: ld (iy+01h), 40h ; ' ' mspacmanIndirectWrite8(Z80IY + 1, 0x40); // 0398: ld (iy+02h), 40h ; ' ' mspacmanIndirectWrite8(Z80IY + 0x02, 0x40); // 039c: ret goto returnInstruction; // 039d: ld a, (4e06h) ; if 4e06 is <5, normal pac // draws big pacman in intermission L039d: Z80A = (UINT8) (mem[0x4e06]); { UINT16 u16Temp0; // 03a0: sub a, 05h u16Temp0 = Z80A - 0x05; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x05))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x05 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 03a2: ret c if (((u8Flags & 0x01) >> 0) == 1) { goto returnInstruction; } // 03a3: ld hl, (4d08h) // draw big pac Z80L = (UINT8) (mem[0x4d08]); Z80H = (UINT8) (mem[0x4d09]); // 03a6: ld b, 08h Z80B = (UINT8) (0x08); // 03a8: ld c, 10h Z80C = (UINT8) (0x10); // 03aa: ld a, l Z80A = (UINT8) (Z80L); // 03ab: ld (4d06h), a mem[0x4d06] = Z80A; // 03ae: ld (4dd2h), a mem[0x4dd2] = Z80A; { UINT16 u16Temp0; // 03b1: sub a, c u16Temp0 = Z80A - Z80C; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80C))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80C ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 03b2: ld (4d02h), a mem[0x4d02] = Z80A; // 03b5: ld (4d04h), a mem[0x4d04] = Z80A; // 03b8: ld a, h Z80A = (UINT8) (Z80H); { UINT16 u16Temp0; // 03b9: add a, b u16Temp0 = Z80A + Z80B; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80B))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80B ^ Z80A ^ 0x80) & (Z80B ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 03ba: ld (4d03h), a mem[0x4d03] = Z80A; // 03bd: ld (4d07h), a mem[0x4d07] = Z80A; { UINT16 u16Temp0; // 03c0: sub a, c u16Temp0 = Z80A - Z80C; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80C))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80C ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 03c1: ld (4d05h), a mem[0x4d05] = Z80A; // 03c4: ld (4dd3h), a mem[0x4dd3] = Z80A; // 03c7: ret goto returnInstruction; // 03c8: ld a, (4e00h) ; game mode // enable sound out and other stuff L03c8: Z80A = (UINT8) (mem[0x4e00]); // 03cb: rst 20h ; stack = program counter @ rst 20 Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x03; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xcc; goto L0020; L03d4: // 03d4: ld a, (4e01h) Z80A = (UINT8) (mem[0x4e01]); // 03d7: rst 20h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x03; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xd8; goto L0020; L03dc: // 03dc: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x03; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xdd; goto L0028; L03df: // 03df: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x03; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xe0; goto L0028; L03e2: // 03e2: rst 28h // this seems to execute oddly. Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x03; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xe3; goto L0028; L03e5: // 03e5: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x03; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xe6; goto L0028; L03e8: // 03e8: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x03; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xe9; goto L0028; L03eb: // 03eb: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x03; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xec; goto L0028; L03ee: // 03ee: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x03; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xef; goto L0028; L03f1: // 03f1: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x03; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xf2; goto L0028; L03f4: // 03f4: ld hl, 4e01h Z80HL = (UINT16) (0x4e01); { UINT8 u8Temp0; // 03f7: inc (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 03f8: ld hl, SndEn ; enable sound Z80HL = (UINT16) (0x5001); // 03fb: ld (hl), 01h ; output mspacmanIndirectWrite8(Z80HL, 1); // 03fd: ret goto returnInstruction; L03fe: // 03fe: call 2ba1h ; write #credits on screen // cant find a jump to here... Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x04; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 1; goto L2ba1; L0401: // 0401: ld a, (credits) ; get credits Z80A = (UINT8) (mem[0x4e6e]); // 0404: and a, a ; set flags u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 0405: jr z, 0413h ; no credits -> 0x13 if (((u8Flags & 0x40) >> 6) == 1) { goto L0413; } // 0407: xor a, a Z80A = (UINT8) (0); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 0408: ld (4e04h), a ; level complete register mem[0x4e04] = Z80A; // 040b: ld (gmemode), a mem[0x4e02] = Z80A; // 040e: ld hl, 4e00h Z80HL = (UINT16) (0x4e00); { UINT8 u8Temp0; // 0411: inc (hl) ; start game mode mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 0412: ret goto returnInstruction; // 0413: jp 3e5ch ; no credits? // table lookup (mspac patch) L0413: goto L3e5c; L045f: // 045f: rst 28h // code resumes here Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x04; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x60; goto L0028; L0462: // 0462: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x04; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x63; goto L0028; L0465: // 0465: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x04; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x66; goto L0028; L0468: // 0468: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x04; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x69; goto L0028; L046b: // 046b: ld c, 0ch Z80C = (UINT8) (0x0c); // 046d: call 0585h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x04; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x70; goto L0585; L0470: // 0470: ret goto returnInstruction; L0471: // 0471: ld hl, 4304h Z80HL = (UINT16) (0x4304); // 0474: ld a, 01h Z80A = (UINT8) (1); // 0476: call 05bfh Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x04; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x79; goto L05bf; L0479: // 0479: ld c, 0ch Z80C = (UINT8) (0x0c); // 047b: call 0585h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x04; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x7e; goto L0585; L047e: // 047e: ret goto returnInstruction; L047f: // 047f: ld c, 14h Z80C = (UINT8) (0x14); // 0481: call 0593h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x04; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x84; goto L0593; L0484: // 0484: ret goto returnInstruction; L0485: // 0485: ld c, 0dh Z80C = (UINT8) (0x0d); // 0487: call 0593h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x04; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x8a; goto L0593; L048a: // 048a: ret goto returnInstruction; L048b: // 048b: ld hl, 4307h Z80HL = (UINT16) (0x4307); // 048e: ld a, 03h Z80A = (UINT8) (0x03); // 0490: call 05bfh Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x04; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x93; goto L05bf; L0493: // 0493: ld c, 0ch Z80C = (UINT8) (0x0c); // 0495: call 0585h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x04; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x98; goto L0585; L0498: // 0498: ret goto returnInstruction; L0499: // 0499: ld c, 16h Z80C = (UINT8) (0x16); // 049b: call 0593h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x04; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x9e; goto L0593; L049e: // 049e: ret goto returnInstruction; L049f: // 049f: ld c, 0fh Z80C = (UINT8) (0x0f); // 04a1: call 0593h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x04; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xa4; goto L0593; L04a4: // 04a4: ret goto returnInstruction; L04a5: // 04a5: ld hl, 430ah Z80HL = (UINT16) (0x430a); // 04a8: ld a, 05h Z80A = (UINT8) (0x05); // 04aa: call 05bfh Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x04; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xad; goto L05bf; L04ad: // 04ad: ld c, 0ch Z80C = (UINT8) (0x0c); // 04af: call 0585h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x04; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xb2; goto L0585; L04b2: // 04b2: ret goto returnInstruction; L04b3: // 04b3: ld c, 33h Z80C = (UINT8) (0x33); // 04b5: call 0593h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x04; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xb8; goto L0593; L04b8: // 04b8: ret goto returnInstruction; L04b9: // 04b9: ld c, 2fh Z80C = (UINT8) (0x2f); // 04bb: call 0593h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x04; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xbe; goto L0593; L04be: // 04be: ret goto returnInstruction; L04bf: // 04bf: ld hl, 430dh Z80HL = (UINT16) (0x430d); // 04c2: ld a, 07h Z80A = (UINT8) (0x07); // 04c4: call 05bfh Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x04; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xc7; goto L05bf; L04c7: // 04c7: ld c, 0ch Z80C = (UINT8) (0x0c); // 04c9: call 0585h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x04; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xcc; goto L0585; L04cc: // 04cc: ret goto returnInstruction; L04cd: // 04cd: ld c, 35h Z80C = (UINT8) (0x35); // 04cf: call 0593h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x04; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xd2; goto L0593; L04d2: // 04d2: ret goto returnInstruction; L04e9: // 04e9: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x04; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xea; goto L0028; L04ec: // 04ec: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x04; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xed; goto L0028; L04ef: // 04ef: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x04; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xf0; goto L0028; L04f2: // 04f2: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x04; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xf3; goto L0028; L04f5: // 04f5: ld a, 01h Z80A = (UINT8) (1); // 04f7: ld (lives), a ; number of lives left mem[0x4e14] = Z80A; // 04fa: xor a, a Z80A = (UINT8) (0); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 04fb: ld (coincrd), a ; number of players 0=1 1=2 mem[0x4e70] = Z80A; // 04fe: ld (scrlves), a ; number of lives displayed mem[0x4e15] = Z80A; // 0501: ld hl, 4332h Z80HL = (UINT16) (0x4332); // 0504: ld (hl), 14h mspacmanIndirectWrite8(Z80HL, 0x14); // 0506: ld a, 0fch L0506: Z80A = (UINT8) (0xfc); // 0508: ld de, 0020h Z80DE = (UINT16) (0x20); // 050b: ld b, 1ch Z80B = (UINT8) (0x1c); // 050d: ld ix, 4040h Z80IX = (UINT16) (0x4040); // 0511: ld (ix+11h), a L0511: mspacmanIndirectWrite8(Z80IX + 0x11, Z80A); // 0514: ld (ix+13h), a mspacmanIndirectWrite8(Z80IX + 0x13, Z80A); { UINT32 u32Temp0; // 0517: add ix, de u32Temp0 = Z80IX + Z80DE; u8Flags = (u8Flags & ~0x10) | ((((Z80IX ^ u32Temp0 ^ Z80DE) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80IX = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 0519: djnz 0511h Z80B = (UINT8) (Z80B - 1); if (Z80B != 0) { goto L0511; } // 051b: ret goto returnInstruction; L051c: // 051c: ld hl, 4da0h // check for moving through a tunnel? Z80HL = (UINT16) (0x4da0); // 051f: ld b, 21h Z80B = (UINT8) (0x21); // 0521: ld a, (4d3ah) Z80A = (UINT8) (mem[0x4d3a]); { UINT16 u16Temp0; // 0524: sub a, b ; pac going through a tunnel? u16Temp0 = Z80A - Z80B; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80B))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80B ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 0525: jr nz, 052ch if (((u8Flags & 0x40) >> 6) != 1) { goto L052c; } // 0527: ld (hl), 01h mspacmanIndirectWrite8(Z80HL, 1); // 0529: jp 058eh goto L058e; // 052c: call 1017h // another core game loop? L052c: Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x05; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x2f; goto L1017; L052f: // 052f: call 1017h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x05; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x32; goto L1017; L0532: // 0532: call 0e23h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x05; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x35; goto L0e23; L0535: // 0535: call 0c0dh Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x05; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x38; goto L0c0d; L0538: // 0538: call 0bd6h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x05; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x3b; goto L0bd6; L053b: // 053b: call 05a5h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x05; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x3e; goto L05a5; L053e: // 053e: call 1efeh Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x05; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x41; goto L1efe; L0541: // 0541: call 1f25h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x05; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x44; goto L1f25; L0544: // 0544: call 1f4ch Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x05; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x47; goto L1f4c; L0547: // 0547: call 1f73h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x05; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x4a; goto L1f73; L054a: // 054a: ret goto returnInstruction; // 057c: call 06beh L057c: Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x05; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x7f; goto L06be; L057f: // 057f: ret goto returnInstruction; // 0585: ld b, 1ch L0585: Z80B = (UINT8) (0x1c); // 0587: call 0042h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x05; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x8a; goto L0042; L058a: // 058a: rst 30h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x05; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x8b; goto L0030; L058b: // 058b: ld c, d Z80C = (UINT8) (Z80D); // 058c: ld (bc), a mspacmanIndirectWrite8(Z80BC, Z80A); // 058d: nop // 058e: ld hl, gmemode L058e: Z80HL = (UINT16) (0x4e02); { UINT8 u8Temp0; // 0591: inc (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 0592: ret goto returnInstruction; // 0593: ld a, (4e75h) L0593: Z80A = (UINT8) (mem[0x4e75]); { UINT16 u16Temp0; // 0596: add a, c u16Temp0 = Z80A + Z80C; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80C))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80C ^ Z80A ^ 0x80) & (Z80C ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 0597: ld c, a Z80C = (UINT8) (Z80A); // 0598: ld b, 1ch Z80B = (UINT8) (0x1c); // 059a: call 0042h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x05; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x9d; goto L0042; L059d: // 059d: rst 30h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x05; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x9e; goto L0030; L05a1: // 05a1: call 058eh Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x05; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xa4; goto L058e; L05a4: // 05a4: ret goto returnInstruction; // 05a5: ld a, (4db5h) L05a5: Z80A = (UINT8) (mem[0x4db5]); // 05a8: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 05a9: ret z if (((u8Flags & 0x40) >> 6) == 1) { goto returnInstruction; } // 05aa: xor a, a Z80A = (UINT8) (0); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 05ab: ld (4db5h), a mem[0x4db5] = Z80A; // 05ae: ld a, (4d30h) Z80A = (UINT8) (mem[0x4d30]); // 05b1: xor a, 02h Z80A = (UINT8) (Z80A ^ 0x02); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 05b3: ld (4d3ch), a mem[0x4d3c] = Z80A; // 05b6: ld b, a Z80B = (UINT8) (Z80A); // 05b7: ld hl, 32ffh Z80HL = (UINT16) (0x32ff); // 05ba: rst 18h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x05; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xbb; goto L0018; L05bb: // 05bb: ld (4d26h), hl mem[0x4d26] = Z80L; mem[0x4d27] = Z80H; // 05be: ret goto returnInstruction; // 05bf: ld (hl), 0b1h L05bf: mspacmanIndirectWrite8(Z80HL, 0xb1); // 05c1: inc l Z80L = (UINT8) (Z80L + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80L == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80L & 0x80) ? 0x80 : 0); if ((Z80L & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80L == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 05c2: ld (hl), 0b3h mspacmanIndirectWrite8(Z80HL, 0xb3); // 05c4: inc l Z80L = (UINT8) (Z80L + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80L == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80L & 0x80) ? 0x80 : 0); if ((Z80L & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80L == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 05c5: ld (hl), 0b5h mspacmanIndirectWrite8(Z80HL, 0xb5); // 05c7: ld bc, 001eh Z80BC = (UINT16) (0x1e); { UINT32 u32Temp0; // 05ca: add hl, bc u32Temp0 = Z80HL + Z80BC; u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80BC) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 05cb: ld (hl), 0b0h mspacmanIndirectWrite8(Z80HL, 0xb0); // 05cd: inc l Z80L = (UINT8) (Z80L + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80L == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80L & 0x80) ? 0x80 : 0); if ((Z80L & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80L == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 05ce: ld (hl), 0b2h mspacmanIndirectWrite8(Z80HL, 0xb2); // 05d0: inc l Z80L = (UINT8) (Z80L + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80L == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80L & 0x80) ? 0x80 : 0); if ((Z80L & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80L == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 05d1: ld (hl), 0b4h mspacmanIndirectWrite8(Z80HL, 0xb4); // 05d3: ld de, 0400h Z80DE = (UINT16) (0x0400); { UINT32 u32Temp0; // 05d6: add hl, de u32Temp0 = Z80HL + Z80DE; u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80DE) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 05d7: ld (hl), a mspacmanIndirectWrite8(Z80HL, Z80A); // 05d8: dec l Z80L = (UINT8) (Z80L - 1); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((Z80L == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80L & 0x80) ? 0x80 : 0); if ((Z80L & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80L == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 05d9: ld (hl), a mspacmanIndirectWrite8(Z80HL, Z80A); // 05da: dec l Z80L = (UINT8) (Z80L - 1); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((Z80L == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80L & 0x80) ? 0x80 : 0); if ((Z80L & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80L == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 05db: ld (hl), a mspacmanIndirectWrite8(Z80HL, Z80A); // 05dc: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); { UINT32 u32Temp0; // 05dd: sbc hl, bc u32Temp0 = (Z80HL - Z80BC - ((u8Flags & 0x01) >> 0)); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80BC) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | (((((Z80BC ^ Z80HL) & (Z80HL ^ u32Temp0) & 0x8000))) ? 0x04 : 0); Z80HL = (UINT16) (u32Temp0); u8Flags = (u8Flags & ~0x40) | ((Z80HL == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80HL & 0x8000) ? 0x80 : 0); u8Flags |= 0x02; } // 05df: ld (hl), a mspacmanIndirectWrite8(Z80HL, Z80A); // 05e0: dec l Z80L = (UINT8) (Z80L - 1); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((Z80L == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80L & 0x80) ? 0x80 : 0); if ((Z80L & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80L == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 05e1: ld (hl), a mspacmanIndirectWrite8(Z80HL, Z80A); // 05e2: dec l Z80L = (UINT8) (Z80L - 1); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((Z80L == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80L & 0x80) ? 0x80 : 0); if ((Z80L & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80L == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 05e3: ld (hl), a mspacmanIndirectWrite8(Z80HL, Z80A); // 05e4: ret goto returnInstruction; L05e5: // 05e5: ld a, (4e03h) Z80A = (UINT8) (mem[0x4e03]); // 05e8: rst 20h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x05; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xe9; goto L0020; L05f3: // 05f3: call 2ba1h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x05; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xf6; goto L2ba1; L05f6: // 05f6: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x05; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xf7; goto L0028; L05f9: // 05f9: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x05; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xfa; goto L0028; L05fc: // 05fc: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x05; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xfd; goto L0028; L05ff: // 05ff: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x06; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0; goto L0028; L0602: // 0602: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x06; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x03; goto L0028; L0605: // 0605: ld hl, 4e03h Z80HL = (UINT16) (0x4e03); { UINT8 u8Temp0; // 0608: inc (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 0609: ld a, 01h Z80A = (UINT8) (1); // 060b: ld (4dd6h), a mem[0x4dd6] = Z80A; // 060e: ld a, (bonusk) Z80A = (UINT8) (mem[0x4e71]); { UINT16 u16Temp0; // 0611: cp a, 0ffh u16Temp0 = Z80A - 0xff; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0xff))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0xff ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 0613: ret z if (((u8Flags & 0x40) >> 6) == 1) { goto returnInstruction; } // 0614: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x06; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x15; goto L0028; L0617: // 0617: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x06; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x18; goto L0028; L061a: // 061a: ret goto returnInstruction; L061b: // 061b: call 2ba1h // can't find a jump to here // display 1/2 player and check start buttons Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x06; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x1e; goto L2ba1; L061e: // 061e: ld a, (credits) ; credits Z80A = (UINT8) (mem[0x4e6e]); { UINT16 u16Temp0; // 0621: cp a, 01h ; is it 1? u16Temp0 = Z80A - 1; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 1))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((1 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 0623: ld b, 09h ; msg #9: 1 OR 2 PLAYERS Z80B = (UINT8) (0x09); // 0625: jr nz, 0629h ; >2 credits if (((u8Flags & 0x40) >> 6) != 1) { goto L0629; } // 0627: ld b, 08h ; msg #8: 1 PLAYER ONLY Z80B = (UINT8) (0x08); // 0629: call 2c5eh ; print message L0629: Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x06; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x2c; goto L2c5e; L062c: // 062c: ld a, (credits) ; get credits Z80A = (UINT8) (mem[0x4e6e]); { UINT16 u16Temp0; // 062f: cp a, 01h ; 1 credit u16Temp0 = Z80A - 1; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 1))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((1 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 0631: ld a, (V1Acc) ; check in1 Z80A = (UINT8) (mem[0x5040]); // 0634: jr z, 0642h ; don't check p2 with 1 credit if (((u8Flags & 0x40) >> 6) == 1) { goto L0642; } // 0636: bit 6, a u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0x40) == 0)) ? 0x40 : 0); u8Flags |= 0x10; u8Flags &= 0xfd; // 0638: jr nz, 0642h if (((u8Flags & 0x40) >> 6) != 1) { goto L0642; } // 063a: ld a, 01h ; set 2 players Z80A = (UINT8) (1); // 063c: ld (coincrd), a ; players 0=1 1=2 players mem[0x4e70] = Z80A; // 063f: jp 0649h goto L0649; // 0642: bit 5, a L0642: u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0x20) == 0)) ? 0x40 : 0); u8Flags |= 0x10; u8Flags &= 0xfd; // 0644: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 0645: xor a, a Z80A = (UINT8) (0); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 0646: ld (coincrd), a mem[0x4e70] = Z80A; // 0649: ld a, (xcoin) L0649: Z80A = (UINT8) (mem[0x4e6b]); // 064c: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 064d: jr z, 0664h ; one coin per game or two? if (((u8Flags & 0x40) >> 6) == 1) { goto L0664; } // 064f: ld a, (coincrd) Z80A = (UINT8) (mem[0x4e70]); // 0652: and a, a ; 0 means 1 coin per game u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 0653: ld a, (credits) ; number of credits Z80A = (UINT8) (mem[0x4e6e]); // 0656: jr z, OnePerGame if (((u8Flags & 0x40) >> 6) == 1) { goto L065b; } { UINT16 u16Temp0; // 0658: add a, 99h ; subtract 1 in BCD u16Temp0 = Z80A + 0x99; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x99))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x99 ^ Z80A ^ 0x80) & (0x99 ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } { UINT16 u16Temp0; // 065a: daa u16Temp0 = (Z80A | (((u8Flags & 0x01) >> 0) << 0x08) | (((u8Flags & 0x10) >> 4) << 0x09) | (((u8Flags & 0x02) >> 1) << 0x0a)); u8Flags = (UINT8) (sg_u16DAATable[u16Temp0] >> 0x08); Z80A = (UINT8) (sg_u16DAATable[u16Temp0] & 0xff); } { UINT16 u16Temp0; // 065b: add a, 99h ; second coin L065b: u16Temp0 = Z80A + 0x99; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x99))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x99 ^ Z80A ^ 0x80) & (0x99 ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } { UINT16 u16Temp0; // 065d: daa u16Temp0 = (Z80A | (((u8Flags & 0x01) >> 0) << 0x08) | (((u8Flags & 0x10) >> 4) << 0x09) | (((u8Flags & 0x02) >> 1) << 0x0a)); u8Flags = (UINT8) (sg_u16DAATable[u16Temp0] >> 0x08); Z80A = (UINT8) (sg_u16DAATable[u16Temp0] & 0xff); } // 065e: ld (credits), a ; resave credits mem[0x4e6e] = Z80A; // 0661: call 2ba1h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x06; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x64; goto L2ba1; // 0664: ld hl, 4e03h L0664: Z80HL = (UINT16) (0x4e03); { UINT8 u8Temp0; // 0667: inc (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 0668: xor a, a Z80A = (UINT8) (0); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 0669: ld (4dd6h), a mem[0x4dd6] = Z80A; // 066c: inc a Z80A = (UINT8) (Z80A + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); if ((Z80A & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80A == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 066d: ld (4ecch), a mem[0x4ecc] = Z80A; // 0670: ld (4edch), a mem[0x4edc] = Z80A; // 0673: ret goto returnInstruction; L0674: // 0674: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x06; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x75; goto L0028; L0677: // 0677: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x06; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x78; goto L0028; L067a: // 067a: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x06; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x7b; goto L0028; L067d: // 067d: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x06; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x7e; goto L0028; L0680: // 0680: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x06; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x81; goto L0028; L0683: // 0683: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x06; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x84; goto L0028; L0686: // 0686: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x06; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x87; goto L0028; L0689: // 0689: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x06; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x8a; goto L0028; L068c: // 068c: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x06; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x8d; goto L0028; L068f: // 068f: xor a, a Z80A = (UINT8) (0); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 0690: ld (boardno), a ; current board level = 0 mem[0x4e13] = Z80A; // 0693: ld a, (inlives) ; number of lives to start Z80A = (UINT8) (mem[0x4e6f]); // 0696: ld (lives), a ; number of lives mem[0x4e14] = Z80A; // 0699: ld (scrlves), a ; number of lives displayed mem[0x4e15] = Z80A; // 069c: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x06; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x9d; goto L0028; L069f: // 069f: rst 30h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x06; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xa0; goto L0030; L06a3: // 06a3: ld hl, 4e03h Z80HL = (UINT16) (0x4e03); { UINT8 u8Temp0; // 06a6: inc (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 06a7: ret goto returnInstruction; L06a8: // 06a8: ld hl, scrlves ; hl= lives displayed on screen loc // draw lives displayed onto the screen Z80HL = (UINT16) (0x4e15); { UINT8 u8Temp0; // 06ab: dec (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] - 1); u8Temp0 = mem[Z80HL]; u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 06ac: call 2b6ah Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x06; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xaf; goto L2b6a; L06af: // 06af: xor a, a Z80A = (UINT8) (0); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 06b0: ld (4e03h), a mem[0x4e03] = Z80A; // 06b3: ld (gmemode), a mem[0x4e02] = Z80A; // 06b6: ld (4e04h), a ; level complete register mem[0x4e04] = Z80A; // 06b9: ld hl, 4e00h ; inc game mode Z80HL = (UINT16) (0x4e00); { UINT8 u8Temp0; // 06bc: inc (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 06bd: ret goto returnInstruction; // 06be: ld a, (4e04h) L06be: Z80A = (UINT8) (mem[0x4e04]); // 06c1: rst 20h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x06; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xc2; goto L0020; // 070e: ld a, b L070e: Z80A = (UINT8) (Z80B); // 070f: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 0710: jr nz, 0716h if (((u8Flags & 0x40) >> 6) != 1) { goto L0716; } // 0712: ld hl, (4e0ah) Z80L = (UINT8) (mem[0x4e0a]); Z80H = (UINT8) (mem[0x4e0b]); // 0715: ld a, (hl) Z80A = (UINT8) (mem[Z80HL]); // 0716: ld ix, 0796h L0716: Z80IX = (UINT16) (0x0796); // 071a: ld b, a Z80B = (UINT8) (Z80A); { UINT16 u16Temp0; // 071b: add a, a u16Temp0 = Z80A + Z80A; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80A))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80A ^ Z80A ^ 0x80) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } { UINT16 u16Temp0; // 071c: add a, a u16Temp0 = Z80A + Z80A; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80A))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80A ^ Z80A ^ 0x80) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } { UINT16 u16Temp0; // 071d: add a, b u16Temp0 = Z80A + Z80B; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80B))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80B ^ Z80A ^ 0x80) & (Z80B ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } { UINT16 u16Temp0; // 071e: add a, b u16Temp0 = Z80A + Z80B; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80B))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80B ^ Z80A ^ 0x80) & (Z80B ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 071f: ld e, a Z80E = (UINT8) (Z80A); // 0720: ld d, 00h Z80D = (UINT8) (0); { UINT32 u32Temp0; // 0722: add ix, de u32Temp0 = Z80IX + Z80DE; u8Flags = (u8Flags & ~0x10) | ((((Z80IX ^ u32Temp0 ^ Z80DE) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80IX = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 0724: ld a, (ix+00h) Z80A = (UINT8) (mem[Z80IX]); { UINT16 u16Temp0; // 0727: add a, a u16Temp0 = Z80A + Z80A; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80A))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80A ^ Z80A ^ 0x80) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 0728: ld b, a Z80B = (UINT8) (Z80A); { UINT16 u16Temp0; // 0729: add a, a u16Temp0 = Z80A + Z80A; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80A))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80A ^ Z80A ^ 0x80) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } { UINT16 u16Temp0; // 072a: add a, a u16Temp0 = Z80A + Z80A; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80A))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80A ^ Z80A ^ 0x80) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 072b: ld c, a Z80C = (UINT8) (Z80A); { UINT16 u16Temp0; // 072c: add a, a u16Temp0 = Z80A + Z80A; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80A))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80A ^ Z80A ^ 0x80) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } { UINT16 u16Temp0; // 072d: add a, a u16Temp0 = Z80A + Z80A; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80A))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80A ^ Z80A ^ 0x80) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } { UINT16 u16Temp0; // 072e: add a, c u16Temp0 = Z80A + Z80C; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80C))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80C ^ Z80A ^ 0x80) & (Z80C ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } { UINT16 u16Temp0; // 072f: add a, b u16Temp0 = Z80A + Z80B; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80B))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80B ^ Z80A ^ 0x80) & (Z80B ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 0730: ld e, a Z80E = (UINT8) (Z80A); // 0731: ld d, 00h Z80D = (UINT8) (0); // 0733: ld hl, 330fh Z80HL = (UINT16) (0x330f); { UINT32 u32Temp0; // 0736: add hl, de u32Temp0 = Z80HL + Z80DE; u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80DE) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 0737: call 0814h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x07; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x3a; goto L0814; L073a: // 073a: ld a, (ix+01h) Z80A = (UINT8) (mem[Z80IX + 1]); // 073d: ld (4db0h), a mem[0x4db0] = Z80A; // 0740: ld a, (ix+02h) Z80A = (UINT8) (mem[Z80IX + 0x02]); // 0743: ld b, a Z80B = (UINT8) (Z80A); { UINT16 u16Temp0; // 0744: add a, a u16Temp0 = Z80A + Z80A; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80A))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80A ^ Z80A ^ 0x80) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } { UINT16 u16Temp0; // 0745: add a, b u16Temp0 = Z80A + Z80B; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80B))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80B ^ Z80A ^ 0x80) & (Z80B ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 0746: ld e, a Z80E = (UINT8) (Z80A); // 0747: ld d, 00h Z80D = (UINT8) (0); // 0749: ld hl, 0843h ; hard/easy data table check Z80HL = (UINT16) (0x0843); { UINT32 u32Temp0; // 074c: add hl, de u32Temp0 = Z80HL + Z80DE; u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80DE) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 074d: call 083ah Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x07; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x50; goto L083a; L0750: // 0750: ld a, (ix+03h) Z80A = (UINT8) (mem[Z80IX + 0x03]); { UINT16 u16Temp0; // 0753: add a, a u16Temp0 = Z80A + Z80A; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80A))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80A ^ Z80A ^ 0x80) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 0754: ld e, a Z80E = (UINT8) (Z80A); // 0755: ld d, 00h Z80D = (UINT8) (0); // 0757: ld iy, 084fh ; another data table check Z80IY = (UINT16) (0x084f); { UINT32 u32Temp0; // 075b: add iy, de u32Temp0 = Z80IY + Z80DE; u8Flags = (u8Flags & ~0x10) | ((((Z80IY ^ u32Temp0 ^ Z80DE) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80IY = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 075d: ld l, (iy+00h) Z80L = (UINT8) (mem[Z80IY]); // 0760: ld h, (iy+01h) Z80H = (UINT8) (mem[Z80IY + 1]); // 0763: ld (4dbbh), hl mem[0x4dbb] = Z80L; mem[0x4dbc] = Z80H; // 0766: ld a, (ix+04h) Z80A = (UINT8) (mem[Z80IX + 0x04]); { UINT16 u16Temp0; // 0769: add a, a u16Temp0 = Z80A + Z80A; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80A))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80A ^ Z80A ^ 0x80) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 076a: ld e, a Z80E = (UINT8) (Z80A); // 076b: ld d, 00h Z80D = (UINT8) (0); // 076d: ld iy, 0861h Z80IY = (UINT16) (0x0861); { UINT32 u32Temp0; // 0771: add iy, de u32Temp0 = Z80IY + Z80DE; u8Flags = (u8Flags & ~0x10) | ((((Z80IY ^ u32Temp0 ^ Z80DE) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80IY = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 0773: ld l, (iy+00h) Z80L = (UINT8) (mem[Z80IY]); // 0776: ld h, (iy+01h) Z80H = (UINT8) (mem[Z80IY + 1]); // 0779: ld (4dbdh), hl mem[0x4dbd] = Z80L; mem[0x4dbe] = Z80H; // 077c: ld a, (ix+05h) Z80A = (UINT8) (mem[Z80IX + 0x05]); { UINT16 u16Temp0; // 077f: add a, a u16Temp0 = Z80A + Z80A; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80A))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80A ^ Z80A ^ 0x80) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 0780: ld e, a Z80E = (UINT8) (Z80A); // 0781: ld d, 00h Z80D = (UINT8) (0); // 0783: ld iy, 0873h Z80IY = (UINT16) (0x0873); { UINT32 u32Temp0; // 0787: add iy, de u32Temp0 = Z80IY + Z80DE; u8Flags = (u8Flags & ~0x10) | ((((Z80IY ^ u32Temp0 ^ Z80DE) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80IY = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 0789: ld l, (iy+00h) Z80L = (UINT8) (mem[Z80IY]); // 078c: ld h, (iy+01h) Z80H = (UINT8) (mem[Z80IY + 1]); // 078f: ld (4d95h), hl mem[0x4d95] = Z80L; mem[0x4d96] = Z80H; // 0792: call 2beah Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x07; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x95; goto L2bea; L0795: // 0795: ret goto returnInstruction; // 0814: ld de, 4d46h L0814: Z80DE = (UINT16) (0x4d46); // 0817: ld bc, 001ch Z80BC = (UINT16) (0x1c); // 081a: ldir UniqueLabel4: mspacmanIndirectWrite8(Z80DE, mem[Z80HL]); Z80HL = (UINT16) (Z80HL + 1); Z80DE = (UINT16) (Z80DE + 1); Z80BC = (UINT16) (Z80BC - 1); if (Z80BC != 0) { goto UniqueLabel4; } u8Flags &= 0xef; u8Flags &= 0xfd; if (Z80BC == 0) { u8Flags &= 0xfb; } else { u8Flags |= 0x04; } // 081c: ld bc, 000ch Z80BC = (UINT16) (0x0c); // 081f: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); { UINT32 u32Temp0; // 0820: sbc hl, bc u32Temp0 = (Z80HL - Z80BC - ((u8Flags & 0x01) >> 0)); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80BC) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | (((((Z80BC ^ Z80HL) & (Z80HL ^ u32Temp0) & 0x8000))) ? 0x04 : 0); Z80HL = (UINT16) (u32Temp0); u8Flags = (u8Flags & ~0x40) | ((Z80HL == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80HL & 0x8000) ? 0x80 : 0); u8Flags |= 0x02; } // 0822: ldir UniqueLabel5: mspacmanIndirectWrite8(Z80DE, mem[Z80HL]); Z80HL = (UINT16) (Z80HL + 1); Z80DE = (UINT16) (Z80DE + 1); Z80BC = (UINT16) (Z80BC - 1); if (Z80BC != 0) { goto UniqueLabel5; } u8Flags &= 0xef; u8Flags &= 0xfd; if (Z80BC == 0) { u8Flags &= 0xfb; } else { u8Flags |= 0x04; } // 0824: ld bc, 000ch Z80BC = (UINT16) (0x0c); // 0827: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); { UINT32 u32Temp0; // 0828: sbc hl, bc u32Temp0 = (Z80HL - Z80BC - ((u8Flags & 0x01) >> 0)); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80BC) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | (((((Z80BC ^ Z80HL) & (Z80HL ^ u32Temp0) & 0x8000))) ? 0x04 : 0); Z80HL = (UINT16) (u32Temp0); u8Flags = (u8Flags & ~0x40) | ((Z80HL == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80HL & 0x8000) ? 0x80 : 0); u8Flags |= 0x02; } // 082a: ldir UniqueLabel6: mspacmanIndirectWrite8(Z80DE, mem[Z80HL]); Z80HL = (UINT16) (Z80HL + 1); Z80DE = (UINT16) (Z80DE + 1); Z80BC = (UINT16) (Z80BC - 1); if (Z80BC != 0) { goto UniqueLabel6; } u8Flags &= 0xef; u8Flags &= 0xfd; if (Z80BC == 0) { u8Flags &= 0xfb; } else { u8Flags |= 0x04; } // 082c: ld bc, 000ch Z80BC = (UINT16) (0x0c); // 082f: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); { UINT32 u32Temp0; // 0830: sbc hl, bc u32Temp0 = (Z80HL - Z80BC - ((u8Flags & 0x01) >> 0)); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80BC) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | (((((Z80BC ^ Z80HL) & (Z80HL ^ u32Temp0) & 0x8000))) ? 0x04 : 0); Z80HL = (UINT16) (u32Temp0); u8Flags = (u8Flags & ~0x40) | ((Z80HL == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80HL & 0x8000) ? 0x80 : 0); u8Flags |= 0x02; } // 0832: ldir UniqueLabel7: mspacmanIndirectWrite8(Z80DE, mem[Z80HL]); Z80HL = (UINT16) (Z80HL + 1); Z80DE = (UINT16) (Z80DE + 1); Z80BC = (UINT16) (Z80BC - 1); if (Z80BC != 0) { goto UniqueLabel7; } u8Flags &= 0xef; u8Flags &= 0xfd; if (Z80BC == 0) { u8Flags &= 0xfb; } else { u8Flags |= 0x04; } // 0834: ld bc, 000eh Z80BC = (UINT16) (0x0e); // 0837: ldir UniqueLabel8: mspacmanIndirectWrite8(Z80DE, mem[Z80HL]); Z80HL = (UINT16) (Z80HL + 1); Z80DE = (UINT16) (Z80DE + 1); Z80BC = (UINT16) (Z80BC - 1); if (Z80BC != 0) { goto UniqueLabel8; } u8Flags &= 0xef; u8Flags &= 0xfd; if (Z80BC == 0) { u8Flags &= 0xfb; } else { u8Flags |= 0x04; } // 0839: ret goto returnInstruction; // 083a: ld de, 4db8h L083a: Z80DE = (UINT16) (0x4db8); // 083d: ld bc, 0003h Z80BC = (UINT16) (0x03); // 0840: ldir UniqueLabel9: mspacmanIndirectWrite8(Z80DE, mem[Z80HL]); Z80HL = (UINT16) (Z80HL + 1); Z80DE = (UINT16) (Z80DE + 1); Z80BC = (UINT16) (Z80BC - 1); if (Z80BC != 0) { goto UniqueLabel9; } u8Flags &= 0xef; u8Flags &= 0xfd; if (Z80BC == 0) { u8Flags &= 0xfb; } else { u8Flags |= 0x04; } // 0842: ret goto returnInstruction; L0879: // 0879: ld hl, 4e09h Z80HL = (UINT16) (0x4e09); // 087c: xor a, a Z80A = (UINT8) (0); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 087d: ld b, 0bh Z80B = (UINT8) (0x0b); // 087f: rst 08h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x08; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x80; goto L0008; L0880: // 0880: call 24c9h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x08; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x83; goto L24c9; L0883: // 0883: ld hl, (difftyp) ; difficulty Z80L = (UINT8) (mem[0x4e73]); Z80H = (UINT8) (mem[0x4e74]); // 0886: ld (4e0ah), hl mem[0x4e0a] = Z80L; mem[0x4e0b] = Z80H; // 0889: ld hl, 4e0ah Z80HL = (UINT16) (0x4e0a); // 088c: ld de, 4e38h Z80DE = (UINT16) (0x4e38); // 088f: ld bc, 002eh Z80BC = (UINT16) (0x2e); // 0892: ldir UniqueLabel10: mspacmanIndirectWrite8(Z80DE, mem[Z80HL]); Z80HL = (UINT16) (Z80HL + 1); Z80DE = (UINT16) (Z80DE + 1); Z80BC = (UINT16) (Z80BC - 1); if (Z80BC != 0) { goto UniqueLabel10; } u8Flags &= 0xef; u8Flags &= 0xfd; if (Z80BC == 0) { u8Flags &= 0xfb; } else { u8Flags |= 0x04; } // 0894: ld hl, 4e04h ; inc level complete register L0894: Z80HL = (UINT16) (0x4e04); { UINT8 u8Temp0; // 0897: inc (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 0898: ret goto returnInstruction; L0899: // 0899: ld a, (4e00h) ; game mode Z80A = (UINT8) (mem[0x4e00]); // 089c: dec a ; check mode Z80A = (UINT8) (Z80A - 1); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); if ((Z80A & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80A == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 089d: jr nz, 08a5h ; jump if not in intro mode if (((u8Flags & 0x40) >> 6) != 1) { goto L08a5; } // 089f: ld a, 09h Z80A = (UINT8) (0x09); // 08a1: ld (4e04h), a ; set intro mode? mem[0x4e04] = Z80A; // 08a4: ret goto returnInstruction; // 08a5: rst 28h L08a5: Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x08; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xa6; goto L0028; L08a8: // 08a8: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x08; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xa9; goto L0028; L08ab: // 08ab: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x08; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xac; goto L0028; L08ae: // 08ae: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x08; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xaf; goto L0028; L08b1: // 08b1: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x08; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xb2; goto L0028; L08b4: // 08b4: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x08; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xb5; goto L0028; L08b7: // 08b7: rst 30h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x08; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xb8; goto L0030; L08bb: // 08bb: rst 30h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x08; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xbc; goto L0030; L08bf: // 08bf: ld a, (cabtype) ; cocktail or upright Z80A = (UINT8) (mem[0x4e72]); // 08c2: ld b, a Z80B = (UINT8) (Z80A); // 08c3: ld a, (4e09h) Z80A = (UINT8) (mem[0x4e09]); // 08c6: and a, b Z80A = (UINT8) (Z80A & Z80B); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 08c7: ld (flpscr), a ; flip screen MSStuffWrite(0x5003,Z80A); // 08ca: jp 0894h goto L0894; L08cd: // 08cd: ld a, (IRQEn) Z80A = (UINT8) (mem[0x5000]); // 08d0: bit 4, a ; rack test u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0x10) == 0)) ? 0x40 : 0); u8Flags |= 0x10; u8Flags &= 0xfd; // 08d2: jp nz, 08deh ; not on then continue game if (((u8Flags & 0x40) >> 6) != 1) { goto L08de; } // 08d5: ld hl, 4e04h ; rack switch on, so advance Z80HL = (UINT16) (0x4e04); // 08d8: ld (hl), 0eh ; level complete register gets $0E?? mspacmanIndirectWrite8(Z80HL, 0x0e); // 08da: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x08; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xdb; goto L0028; L08dd: // 08dd: ret goto returnInstruction; // 08de: ld a, (peleatn) ; number of pellets eaten // routine to determine the number of pellets must be eaten L08de: Z80A = (UINT8) (mem[0x4e0e]); // 08e1: jp 94a1h ; jump to check routine goto L94a1; // 08e5: ld hl, 4e04h // returns here L08e5: Z80HL = (UINT16) (0x4e04); // 08e8: ld (hl), 0ch mspacmanIndirectWrite8(Z80HL, 0x0c); // 08ea: ret goto returnInstruction; // 08eb: call 1017h // another core game loop? L08eb: Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x08; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xee; goto L1017; L08ee: // 08ee: call 1017h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x08; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xf1; goto L1017; L08f1: // 08f1: call 13ddh Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x08; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xf4; goto L13dd; L08f4: // 08f4: call 0c42h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x08; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xf7; goto L0c42; L08f7: // 08f7: call 0e23h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x08; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xfa; goto L0e23; L08fa: // 08fa: call 0e36h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x08; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xfd; goto L0e36; L08fd: // 08fd: call 0ac3h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x09; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0; goto L0ac3; L0900: // 0900: call 0bd6h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x09; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x03; goto L0bd6; L0903: // 0903: call 0c0dh Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x09; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x06; goto L0c0d; L0906: // 0906: call 0e6ch Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x09; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x09; goto L0e6c; L0909: // 0909: call 0eadh Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x09; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x0c; goto L0ead; L090c: // 090c: ret goto returnInstruction; L090d: // 090d: ld a, 01h Z80A = (UINT8) (1); // 090f: ld (4e12h), a mem[0x4e12] = Z80A; // 0912: call 2487h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x09; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x15; goto L2487; L0915: // 0915: ld hl, 4e04h Z80HL = (UINT16) (0x4e04); { UINT8 u8Temp0; // 0918: inc (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 0919: ld a, (lives) ; number of lives left Z80A = (UINT8) (mem[0x4e14]); // 091c: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 091d: jr nz, 093eh if (((u8Flags & 0x40) >> 6) != 1) { goto L093e; } // 091f: ld a, (coincrd) Z80A = (UINT8) (mem[0x4e70]); // 0922: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 0923: jr z, 093eh if (((u8Flags & 0x40) >> 6) == 1) { goto L093e; } // 0925: ld a, (4e42h) Z80A = (UINT8) (mem[0x4e42]); // 0928: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 0929: jr z, 093eh if (((u8Flags & 0x40) >> 6) == 1) { goto L093e; } // 092b: ld a, (4e09h) Z80A = (UINT8) (mem[0x4e09]); { UINT16 u16Temp0; // 092e: add a, 03h u16Temp0 = Z80A + 0x03; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x03))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x03 ^ Z80A ^ 0x80) & (0x03 ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 0930: ld c, a Z80C = (UINT8) (Z80A); // 0931: ld b, 1ch Z80B = (UINT8) (0x1c); // 0933: call 0042h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x09; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x36; goto L0042; L0936: // 0936: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x09; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x37; goto L0028; L0939: // 0939: rst 30h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x09; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x3a; goto L0030; L093d: // 093d: ret goto returnInstruction; { UINT8 u8Temp0; // 093e: inc (hl) L093e: mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 093f: ret goto returnInstruction; L0940: // 0940: ld a, (coincrd) ; number of players Z80A = (UINT8) (mem[0x4e70]); // 0943: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 0944: jr z, 094ch ; jump if 1 player if (((u8Flags & 0x40) >> 6) == 1) { goto L094c; } // 0946: ld a, (4e42h) Z80A = (UINT8) (mem[0x4e42]); // 0949: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 094a: jr nz, 0961h if (((u8Flags & 0x40) >> 6) != 1) { goto L0961; } // 094c: ld a, (lives) ; number of lives left L094c: Z80A = (UINT8) (mem[0x4e14]); // 094f: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 0950: jr nz, 096ch ; jump if lives left // change 0950 to // for never-ending pac goodness if (((u8Flags & 0x40) >> 6) != 1) { goto L096c; } // 0952: call 2ba1h ; draw # credits or free play Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x09; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x55; goto L2ba1; L0955: // 0955: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x09; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x56; goto L0028; L0958: // 0958: rst 30h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x09; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x59; goto L0030; L095c: // 095c: ld hl, 4e04h Z80HL = (UINT16) (0x4e04); { UINT8 u8Temp0; // 095f: inc (hl) ; increment level cleared mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 0960: ret goto returnInstruction; // 0961: call 0aa6h L0961: Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x09; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x64; goto L0aa6; L0964: // 0964: ld a, (4e09h) Z80A = (UINT8) (mem[0x4e09]); // 0967: xor a, 01h Z80A = (UINT8) (Z80A ^ 1); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 0969: ld (4e09h), a mem[0x4e09] = Z80A; // 096c: ld a, 09h L096c: Z80A = (UINT8) (0x09); // 096e: ld (4e04h), a mem[0x4e04] = Z80A; // 0971: ret goto returnInstruction; L0972: // 0972: xor a, a // zero some important variables Z80A = (UINT8) (0); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 0973: ld (gmemode), a mem[0x4e02] = Z80A; // 0976: ld (4e04h), a mem[0x4e04] = Z80A; // 0979: ld (coincrd), a mem[0x4e70] = Z80A; // 097c: ld (4e09h), a mem[0x4e09] = Z80A; // 097f: ld (flpscr), a ; flip screen MSStuffWrite(0x5003,Z80A); // 0982: ld a, 01h Z80A = (UINT8) (1); // 0984: ld (4e00h), a mem[0x4e00] = Z80A; // 0987: ret goto returnInstruction; // 0988: rst 28h L0988: Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x09; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x89; goto L0028; L098b: // 098b: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x09; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x8c; goto L0028; L098e: // 098e: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x09; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x8f; goto L0028; L0991: // 0991: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x09; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x92; goto L0028; L0994: // 0994: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x09; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x95; goto L0028; L0997: // 0997: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x09; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x98; goto L0028; L099a: // 099a: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x09; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x9b; goto L0028; L099d: // 099d: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x09; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x9e; goto L0028; L09a0: // 09a0: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x09; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xa1; goto L0028; L09a3: // 09a3: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x09; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xa4; goto L0028; L09a6: // 09a6: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x09; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xa7; goto L0028; L09a9: // 09a9: ld a, (4e00h) Z80A = (UINT8) (mem[0x4e00]); { UINT16 u16Temp0; // 09ac: cp a, 03h u16Temp0 = Z80A - 0x03; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x03))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x03 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 09ae: jr z, 09b6h if (((u8Flags & 0x40) >> 6) == 1) { goto L09b6; } // 09b0: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x09; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xb1; goto L0028; L09b3: // 09b3: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x09; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xb4; goto L0028; // 09b6: rst 30h L09b6: Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x09; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xb7; goto L0030; L09ba: // 09ba: ld a, (4e00h) Z80A = (UINT8) (mem[0x4e00]); // 09bd: dec a Z80A = (UINT8) (Z80A - 1); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); if ((Z80A & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80A == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 09be: jr z, 09c4h if (((u8Flags & 0x40) >> 6) == 1) { goto L09c4; } // 09c0: rst 30h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x09; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xc1; goto L0030; // 09c4: ld a, (cabtype) L09c4: Z80A = (UINT8) (mem[0x4e72]); // 09c7: ld b, a Z80B = (UINT8) (Z80A); // 09c8: ld a, (4e09h) Z80A = (UINT8) (mem[0x4e09]); // 09cb: and a, b Z80A = (UINT8) (Z80A & Z80B); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 09cc: ld (flpscr), a ; flip screen MSStuffWrite(0x5003,Z80A); // 09cf: jp 0894h goto L0894; // 09d2: ld a, 03h L09d2: Z80A = (UINT8) (0x03); // 09d4: ld (4e04h), a mem[0x4e04] = Z80A; // 09d7: ret goto returnInstruction; L09d8: // 09d8: rst 30h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x09; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xd9; goto L0030; L09dc: // 09dc: ld hl, 4e04h Z80HL = (UINT16) (0x4e04); { UINT8 u8Temp0; // 09df: inc (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 09e0: xor a, a Z80A = (UINT8) (0); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 09e1: ld (4each), a mem[0x4eac] = Z80A; // 09e4: ld (4ebch), a mem[0x4ebc] = Z80A; // 09e7: ret goto returnInstruction; // 09e8: ld c, 02h L09e8: Z80C = (UINT8) (0x02); // 09ea: ld b, 01h L09ea: Z80B = (UINT8) (1); // 09ec: call 0042h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x09; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xef; goto L0042; L09ef: // 09ef: rst 30h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x09; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xf0; goto L0030; L09f3: // 09f3: ld hl, 0000h Z80HL = (UINT16) (0); // 09f6: call 267eh Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x09; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xf9; goto L267e; L09f9: // 09f9: ld hl, 4e04h Z80HL = (UINT16) (0x4e04); { UINT8 u8Temp0; // 09fc: inc (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 09fd: ret goto returnInstruction; // 09fe: ld c, 00h L09fe: Z80C = (UINT8) (0); // 0a00: jr 09eah goto L09ea; L0a02: // 0a02: jr 09e8h goto L09e8; L0a04: // 0a04: jr 09feh goto L09fe; L0a06: // 0a06: jr 09e8h goto L09e8; L0a08: // 0a08: jr 09feh goto L09fe; L0a0a: // 0a0a: jr 09e8h goto L09e8; L0a0c: // 0a0c: jr 09feh goto L09fe; L0a0e: // 0a0e: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x0a; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x0f; goto L0028; L0a11: // 0a11: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x0a; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x12; goto L0028; L0a14: // 0a14: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x0a; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x15; goto L0028; L0a17: // 0a17: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x0a; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x18; goto L0028; L0a1a: // 0a1a: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x0a; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x1b; goto L0028; L0a1d: // 0a1d: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x0a; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x1e; goto L0028; L0a20: // 0a20: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x0a; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x21; goto L0028; L0a23: // 0a23: rst 30h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x0a; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x24; goto L0030; L0a27: // 0a27: ld hl, 4e04h Z80HL = (UINT16) (0x4e04); { UINT8 u8Temp0; // 0a2a: inc (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 0a2b: ret goto returnInstruction; L0a2c: // 0a2c: xor a, a Z80A = (UINT8) (0); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 0a2d: ld (4each), a mem[0x4eac] = Z80A; // 0a30: ld (4ebch), a mem[0x4ebc] = Z80A; // 0a33: jr 0a3bh goto L0a3b; L0a35: // 0a35: ld (4ecch), a mem[0x4ecc] = Z80A; // 0a38: ld (4edch), a mem[0x4edc] = Z80A; // 0a3b: ld a, (boardno) ; current board level L0a3b: Z80A = (UINT8) (mem[0x4e13]); { UINT16 u16Temp0; // 0a3e: cp a, 14h u16Temp0 = Z80A - 0x14; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x14))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x14 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 0a40: jr c, 0a44h if (((u8Flags & 0x01) >> 0) == 1) { goto L0a44; } // 0a42: ld a, 14h Z80A = (UINT8) (0x14); // 0a44: rst 20h L0a44: Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x0a; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x45; goto L0020; L0a6f: // 0a6f: ld hl, 4e04h // increment level state and stop sound Z80HL = (UINT16) (0x4e04); { UINT8 u8Temp0; // 0a72: inc (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } { UINT8 u8Temp0; // 0a73: inc (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 0a74: xor a, a Z80A = (UINT8) (0); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 0a75: ld (4ecch), a mem[0x4ecc] = Z80A; // 0a78: ld (4edch), a mem[0x4edc] = Z80A; // 0a7b: ret goto returnInstruction; L0a7c: // 0a7c: xor a, a // we're about to start the next board, (it's about to be drawn) Z80A = (UINT8) (0); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 0a7d: ld (4ecch), a mem[0x4ecc] = Z80A; // 0a80: ld (4edch), a mem[0x4edc] = Z80A; // 0a83: ld b, 07h Z80B = (UINT8) (0x07); // 0a85: ld hl, 4e0ch Z80HL = (UINT16) (0x4e0c); // 0a88: rst 08h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x0a; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x89; goto L0008; L0a89: // 0a89: call 24c9h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x0a; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x8c; goto L24c9; L0a8c: // 0a8c: ld hl, 4e04h Z80HL = (UINT16) (0x4e04); { UINT8 u8Temp0; // 0a8f: inc (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 0a90: ld hl, boardno ; current board level // level 255 pac fix ; HACK8 // level 141 mspac fix ; HACK9 Z80HL = (UINT16) (0x4e13); { UINT8 u8Temp0; // 0a93: inc (hl) ; increment board level mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 0a94: ld hl, (4e0ah) Z80L = (UINT8) (mem[0x4e0a]); Z80H = (UINT8) (mem[0x4e0b]); // 0a97: ld a, (hl) Z80A = (UINT8) (mem[Z80HL]); { UINT16 u16Temp0; // 0a98: cp a, 14h u16Temp0 = Z80A - 0x14; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x14))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x14 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 0a9a: ret z if (((u8Flags & 0x40) >> 6) == 1) { goto returnInstruction; } // 0a9b: inc hl Z80HL = (UINT16) (Z80HL + 1); // 0a9c: ld (4e0ah), hl mem[0x4e0a] = Z80L; mem[0x4e0b] = Z80H; // 0a9f: ret goto returnInstruction; L0aa0: // 0aa0: jp 0988h goto L0988; L0aa3: // 0aa3: jp 09d2h goto L09d2; // 0aa6: ld b, 2eh L0aa6: Z80B = (UINT8) (0x2e); // 0aa8: ld ix, 4e0ah Z80IX = (UINT16) (0x4e0a); // 0aac: ld iy, 4e38h Z80IY = (UINT16) (0x4e38); // 0ab0: ld d, (ix+00h) L0ab0: Z80D = (UINT8) (mem[Z80IX]); // 0ab3: ld e, (iy+00h) Z80E = (UINT8) (mem[Z80IY]); // 0ab6: ld (iy+00h), d mspacmanIndirectWrite8(Z80IY, Z80D); // 0ab9: ld (ix+00h), e mspacmanIndirectWrite8(Z80IX, Z80E); // 0abc: inc ix Z80IX = (UINT16) (Z80IX + 1); // 0abe: inc iy Z80IY = (UINT16) (Z80IY + 1); // 0ac0: djnz 0ab0h Z80B = (UINT8) (Z80B - 1); if (Z80B != 0) { goto L0ab0; } // 0ac2: ret goto returnInstruction; // 0ac3: ld a, (4da4h) L0ac3: Z80A = (UINT8) (mem[0x4da4]); // 0ac6: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 0ac7: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 0ac8: ld ix, 4c00h Z80IX = (UINT16) (0x4c00); // 0acc: ld iy, 4dc8h Z80IY = (UINT16) (0x4dc8); // 0ad0: ld de, 0100h Z80DE = (UINT16) (0x0100); { UINT16 u16Temp0; // 0ad3: cp a, (iy+00h) u16Temp0 = Z80A - mem[Z80IY]; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ mem[Z80IY]))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((mem[Z80IY] ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 0ad6: jp nz, 0bd2h if (((u8Flags & 0x40) >> 6) != 1) { goto L0bd2; } // 0ad9: ld (iy+00h), 0eh mspacmanIndirectWrite8(Z80IY, 0x0e); // 0add: ld a, (4da6h) Z80A = (UINT8) (mem[0x4da6]); // 0ae0: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 0ae1: jr z, 0afeh if (((u8Flags & 0x40) >> 6) == 1) { goto L0afe; } // 0ae3: ld hl, (4dcbh) Z80L = (UINT8) (mem[0x4dcb]); Z80H = (UINT8) (mem[0x4dcc]); // 0ae6: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); { UINT32 u32Temp0; // 0ae7: sbc hl, de u32Temp0 = (Z80HL - Z80DE - ((u8Flags & 0x01) >> 0)); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80DE) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | (((((Z80DE ^ Z80HL) & (Z80HL ^ u32Temp0) & 0x8000))) ? 0x04 : 0); Z80HL = (UINT16) (u32Temp0); u8Flags = (u8Flags & ~0x40) | ((Z80HL == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80HL & 0x8000) ? 0x80 : 0); u8Flags |= 0x02; } // 0ae9: jr nc, 0afeh if (((u8Flags & 0x01) >> 0) != 1) { goto L0afe; } // 0aeb: ld hl, 4each Z80HL = (UINT16) (0x4eac); // 0aee: set 7, (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] | 0x80); // 0af0: ld a, 09h Z80A = (UINT8) (0x09); { UINT16 u16Temp0; // 0af2: cp a, (ix+0bh) u16Temp0 = Z80A - mem[Z80IX + 0x0b]; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ mem[Z80IX + 0x0b]))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((mem[Z80IX + 0x0b] ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 0af5: jr nz, 0afbh if (((u8Flags & 0x40) >> 6) != 1) { goto L0afb; } // 0af7: res 7, (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] & 0x7f); // 0af9: ld a, 09h Z80A = (UINT8) (0x09); // 0afb: ld (4c0bh), a L0afb: mem[0x4c0b] = Z80A; // 0afe: ld a, (4da7h) L0afe: Z80A = (UINT8) (mem[0x4da7]); // 0b01: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 0b02: jr z, 0b21h if (((u8Flags & 0x40) >> 6) == 1) { goto L0b21; } // 0b04: ld hl, (4dcbh) Z80L = (UINT8) (mem[0x4dcb]); Z80H = (UINT8) (mem[0x4dcc]); // 0b07: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); { UINT32 u32Temp0; // 0b08: sbc hl, de u32Temp0 = (Z80HL - Z80DE - ((u8Flags & 0x01) >> 0)); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80DE) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | (((((Z80DE ^ Z80HL) & (Z80HL ^ u32Temp0) & 0x8000))) ? 0x04 : 0); Z80HL = (UINT16) (u32Temp0); u8Flags = (u8Flags & ~0x40) | ((Z80HL == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80HL & 0x8000) ? 0x80 : 0); u8Flags |= 0x02; } // 0b0a: jr nc, 0b33h if (((u8Flags & 0x01) >> 0) != 1) { goto L0b33; } // 0b0c: ld a, 11h Z80A = (UINT8) (0x11); { UINT16 u16Temp0; // 0b0e: cp a, (ix+03h) u16Temp0 = Z80A - mem[Z80IX + 0x03]; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ mem[Z80IX + 0x03]))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((mem[Z80IX + 0x03] ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 0b11: jr z, 0b1ah if (((u8Flags & 0x40) >> 6) == 1) { goto L0b1a; } // 0b13: ld (ix+03h), 11h mspacmanIndirectWrite8(Z80IX + 0x03, 0x11); // 0b17: jp 0b33h goto L0b33; // 0b1a: ld (ix+03h), 12h L0b1a: mspacmanIndirectWrite8(Z80IX + 0x03, 0x12); // 0b1e: jp 0b33h goto L0b33; // 0b21: ld a, 01h L0b21: Z80A = (UINT8) (1); { UINT16 u16Temp0; // 0b23: cp a, (ix+03h) u16Temp0 = Z80A - mem[Z80IX + 0x03]; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ mem[Z80IX + 0x03]))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((mem[Z80IX + 0x03] ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 0b26: jr z, 0b2fh if (((u8Flags & 0x40) >> 6) == 1) { goto L0b2f; } // 0b28: ld (ix+03h), 01h mspacmanIndirectWrite8(Z80IX + 0x03, 1); // 0b2c: jp 0b33h goto L0b33; // 0b2f: ld (ix+03h), 01h L0b2f: mspacmanIndirectWrite8(Z80IX + 0x03, 1); // 0b33: ld a, (4da8h) L0b33: Z80A = (UINT8) (mem[0x4da8]); // 0b36: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 0b37: jr z, 0b56h if (((u8Flags & 0x40) >> 6) == 1) { goto L0b56; } // 0b39: ld hl, (4dcbh) Z80L = (UINT8) (mem[0x4dcb]); Z80H = (UINT8) (mem[0x4dcc]); // 0b3c: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); { UINT32 u32Temp0; // 0b3d: sbc hl, de u32Temp0 = (Z80HL - Z80DE - ((u8Flags & 0x01) >> 0)); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80DE) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | (((((Z80DE ^ Z80HL) & (Z80HL ^ u32Temp0) & 0x8000))) ? 0x04 : 0); Z80HL = (UINT16) (u32Temp0); u8Flags = (u8Flags & ~0x40) | ((Z80HL == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80HL & 0x8000) ? 0x80 : 0); u8Flags |= 0x02; } // 0b3f: jr nc, 0b68h if (((u8Flags & 0x01) >> 0) != 1) { goto L0b68; } // 0b41: ld a, 11h Z80A = (UINT8) (0x11); { UINT16 u16Temp0; // 0b43: cp a, (ix+05h) u16Temp0 = Z80A - mem[Z80IX + 0x05]; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ mem[Z80IX + 0x05]))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((mem[Z80IX + 0x05] ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 0b46: jr z, 0b4fh if (((u8Flags & 0x40) >> 6) == 1) { goto L0b4f; } // 0b48: ld (ix+05h), 11h mspacmanIndirectWrite8(Z80IX + 0x05, 0x11); // 0b4c: jp 0b68h goto L0b68; // 0b4f: ld (ix+05h), 12h L0b4f: mspacmanIndirectWrite8(Z80IX + 0x05, 0x12); // 0b53: jp 0b68h goto L0b68; // 0b56: ld a, 03h L0b56: Z80A = (UINT8) (0x03); { UINT16 u16Temp0; // 0b58: cp a, (ix+05h) u16Temp0 = Z80A - mem[Z80IX + 0x05]; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ mem[Z80IX + 0x05]))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((mem[Z80IX + 0x05] ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 0b5b: jr z, 0b64h if (((u8Flags & 0x40) >> 6) == 1) { goto L0b64; } // 0b5d: ld (ix+05h), 03h mspacmanIndirectWrite8(Z80IX + 0x05, 0x03); // 0b61: jp 0b68h goto L0b68; // 0b64: ld (ix+05h), 03h L0b64: mspacmanIndirectWrite8(Z80IX + 0x05, 0x03); // 0b68: ld a, (4da9h) L0b68: Z80A = (UINT8) (mem[0x4da9]); // 0b6b: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 0b6c: jr z, 0b8bh if (((u8Flags & 0x40) >> 6) == 1) { goto L0b8b; } // 0b6e: ld hl, (4dcbh) Z80L = (UINT8) (mem[0x4dcb]); Z80H = (UINT8) (mem[0x4dcc]); // 0b71: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); { UINT32 u32Temp0; // 0b72: sbc hl, de u32Temp0 = (Z80HL - Z80DE - ((u8Flags & 0x01) >> 0)); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80DE) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | (((((Z80DE ^ Z80HL) & (Z80HL ^ u32Temp0) & 0x8000))) ? 0x04 : 0); Z80HL = (UINT16) (u32Temp0); u8Flags = (u8Flags & ~0x40) | ((Z80HL == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80HL & 0x8000) ? 0x80 : 0); u8Flags |= 0x02; } // 0b74: jr nc, 0b9dh if (((u8Flags & 0x01) >> 0) != 1) { goto L0b9d; } // 0b76: ld a, 11h Z80A = (UINT8) (0x11); { UINT16 u16Temp0; // 0b78: cp a, (ix+07h) u16Temp0 = Z80A - mem[Z80IX + 0x07]; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ mem[Z80IX + 0x07]))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((mem[Z80IX + 0x07] ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 0b7b: jr z, 0b84h if (((u8Flags & 0x40) >> 6) == 1) { goto L0b84; } // 0b7d: ld (ix+07h), 11h mspacmanIndirectWrite8(Z80IX + 0x07, 0x11); // 0b81: jp 0b9dh goto L0b9d; // 0b84: ld (ix+07h), 12h L0b84: mspacmanIndirectWrite8(Z80IX + 0x07, 0x12); // 0b88: jp 0b9dh goto L0b9d; // 0b8b: ld a, 05h L0b8b: Z80A = (UINT8) (0x05); { UINT16 u16Temp0; // 0b8d: cp a, (ix+07h) u16Temp0 = Z80A - mem[Z80IX + 0x07]; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ mem[Z80IX + 0x07]))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((mem[Z80IX + 0x07] ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 0b90: jr z, 0b99h if (((u8Flags & 0x40) >> 6) == 1) { goto L0b99; } // 0b92: ld (ix+07h), 05h mspacmanIndirectWrite8(Z80IX + 0x07, 0x05); // 0b96: jp 0b9dh goto L0b9d; // 0b99: ld (ix+07h), 05h L0b99: mspacmanIndirectWrite8(Z80IX + 0x07, 0x05); // 0b9d: ld a, (4daah) L0b9d: Z80A = (UINT8) (mem[0x4daa]); // 0ba0: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 0ba1: jr z, 0bc0h if (((u8Flags & 0x40) >> 6) == 1) { goto L0bc0; } // 0ba3: ld hl, (4dcbh) Z80L = (UINT8) (mem[0x4dcb]); Z80H = (UINT8) (mem[0x4dcc]); // 0ba6: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); { UINT32 u32Temp0; // 0ba7: sbc hl, de u32Temp0 = (Z80HL - Z80DE - ((u8Flags & 0x01) >> 0)); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80DE) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | (((((Z80DE ^ Z80HL) & (Z80HL ^ u32Temp0) & 0x8000))) ? 0x04 : 0); Z80HL = (UINT16) (u32Temp0); u8Flags = (u8Flags & ~0x40) | ((Z80HL == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80HL & 0x8000) ? 0x80 : 0); u8Flags |= 0x02; } // 0ba9: jr nc, 0bd2h if (((u8Flags & 0x01) >> 0) != 1) { goto L0bd2; } // 0bab: ld a, 11h Z80A = (UINT8) (0x11); { UINT16 u16Temp0; // 0bad: cp a, (ix+09h) u16Temp0 = Z80A - mem[Z80IX + 0x09]; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ mem[Z80IX + 0x09]))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((mem[Z80IX + 0x09] ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 0bb0: jr z, 0bb9h if (((u8Flags & 0x40) >> 6) == 1) { goto L0bb9; } // 0bb2: ld (ix+09h), 11h mspacmanIndirectWrite8(Z80IX + 0x09, 0x11); // 0bb6: jp 0bd2h goto L0bd2; // 0bb9: ld (ix+09h), 12h L0bb9: mspacmanIndirectWrite8(Z80IX + 0x09, 0x12); // 0bbd: jp 0bd2h goto L0bd2; // 0bc0: ld a, 07h L0bc0: Z80A = (UINT8) (0x07); { UINT16 u16Temp0; // 0bc2: cp a, (ix+09h) u16Temp0 = Z80A - mem[Z80IX + 0x09]; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ mem[Z80IX + 0x09]))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((mem[Z80IX + 0x09] ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 0bc5: jr z, 0bceh if (((u8Flags & 0x40) >> 6) == 1) { goto L0bce; } // 0bc7: ld (ix+09h), 07h mspacmanIndirectWrite8(Z80IX + 0x09, 0x07); // 0bcb: jp 0bd2h goto L0bd2; // 0bce: ld (ix+09h), 07h L0bce: mspacmanIndirectWrite8(Z80IX + 0x09, 0x07); { UINT8 u8Temp0; // 0bd2: dec (iy+00h) L0bd2: mspacmanIndirectWrite8(Z80IY, mem[Z80IY] - 1); u8Temp0 = mem[Z80IY]; u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 0bd5: ret goto returnInstruction; // 0bd6: ld b, 19h L0bd6: Z80B = (UINT8) (0x19); // 0bd8: ld a, (gmemode) Z80A = (UINT8) (mem[0x4e02]); { UINT16 u16Temp0; // 0bdb: cp a, 22h u16Temp0 = Z80A - 0x22; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x22))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x22 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 0bdd: jp nz, 0be2h if (((u8Flags & 0x40) >> 6) != 1) { goto L0be2; } // 0be0: ld b, 00h Z80B = (UINT8) (0); // 0be2: ld ix, 4c00h L0be2: Z80IX = (UINT16) (0x4c00); // 0be6: ld a, (4dach) Z80A = (UINT8) (mem[0x4dac]); // 0be9: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 0bea: jp z, 0bf0h if (((u8Flags & 0x40) >> 6) == 1) { goto L0bf0; } // 0bed: ld (ix+03h), b mspacmanIndirectWrite8(Z80IX + 0x03, Z80B); // 0bf0: ld a, (4dadh) L0bf0: Z80A = (UINT8) (mem[0x4dad]); // 0bf3: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 0bf4: jp z, 0bfah if (((u8Flags & 0x40) >> 6) == 1) { goto L0bfa; } // 0bf7: ld (ix+05h), b mspacmanIndirectWrite8(Z80IX + 0x05, Z80B); // 0bfa: ld a, (4daeh) L0bfa: Z80A = (UINT8) (mem[0x4dae]); // 0bfd: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 0bfe: jp z, 0c04h if (((u8Flags & 0x40) >> 6) == 1) { goto L0c04; } // 0c01: ld (ix+07h), b mspacmanIndirectWrite8(Z80IX + 0x07, Z80B); // 0c04: ld a, (4dafh) L0c04: Z80A = (UINT8) (mem[0x4daf]); // 0c07: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 0c08: ret z if (((u8Flags & 0x40) >> 6) == 1) { goto returnInstruction; } // 0c09: ld (ix+09h), b mspacmanIndirectWrite8(Z80IX + 0x09, Z80B); // 0c0c: ret goto returnInstruction; // 0c0d: ld hl, 4dcfh L0c0d: Z80HL = (UINT16) (0x4dcf); { UINT8 u8Temp0; // 0c10: inc (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 0c11: ld a, 0ah Z80A = (UINT8) (0x0a); { UINT16 u16Temp0; UINT8 u8Temp0; // 0c13: cp a, (hl) u8Temp0 = mem[Z80HL]; u16Temp0 = Z80A - u8Temp0; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ u8Temp0))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((u8Temp0 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 0c14: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 0c15: ld (hl), 00h mspacmanIndirectWrite8(Z80HL, 0); // 0c17: ld a, (4e04h) Z80A = (UINT8) (mem[0x4e04]); { UINT16 u16Temp0; // 0c1a: cp a, 03h u16Temp0 = Z80A - 0x03; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x03))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x03 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 0c1c: jr nz, 0c33h if (((u8Flags & 0x40) >> 6) != 1) { goto L0c33; } // 0c1e: ld hl, 4464h Z80HL = (UINT16) (0x4464); // 0c21: jp 9524h goto L9524; // 0c33: ld hl, 4732h L0c33: Z80HL = (UINT16) (0x4732); // 0c36: ld a, 10h Z80A = (UINT8) (0x10); { UINT16 u16Temp0; UINT8 u8Temp0; // 0c38: cp a, (hl) u8Temp0 = mem[Z80HL]; u16Temp0 = Z80A - u8Temp0; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ u8Temp0))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((u8Temp0 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 0c39: jr nz, 0c3dh if (((u8Flags & 0x40) >> 6) != 1) { goto L0c3d; } // 0c3b: ld a, 00h Z80A = (UINT8) (0); // 0c3d: ld (hl), a L0c3d: mspacmanIndirectWrite8(Z80HL, Z80A); // 0c3e: ld (4678h), a MSPacVideoWrite(0x4678,Z80A); // 0c41: ret goto returnInstruction; // 0c42: ld a, (4da4h) L0c42: Z80A = (UINT8) (mem[0x4da4]); // 0c45: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 0c46: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 0c47: ld a, (4d94h) Z80A = (UINT8) (mem[0x4d94]); // 0c4a: rlca u8Flags = (u8Flags & ~0x01) | ((Z80A & 0x80) ? 0x01 : 0); Z80A = (UINT8) (((Z80A << 1) | (Z80A >> 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 0c4b: ld (4d94h), a mem[0x4d94] = Z80A; // 0c4e: ret nc if (((u8Flags & 0x01) >> 0) != 1) { goto returnInstruction; } // 0c4f: ld a, (4da0h) Z80A = (UINT8) (mem[0x4da0]); // 0c52: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 0c53: jp nz, 0c90h if (((u8Flags & 0x40) >> 6) != 1) { goto L0c90; } // 0c56: ld ix, 3305h Z80IX = (UINT16) (0x3305); // 0c5a: ld iy, 4d00h Z80IY = (UINT16) (0x4d00); // 0c5e: call 2000h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x0c; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x61; goto L2000; L0c61: // 0c61: ld (4d00h), hl mem[0x4d00] = Z80L; mem[0x4d01] = Z80H; // 0c64: ld a, 03h Z80A = (UINT8) (0x03); // 0c66: ld (4d28h), a mem[0x4d28] = Z80A; // 0c69: ld (4d2ch), a mem[0x4d2c] = Z80A; // 0c6c: ld a, (4d00h) Z80A = (UINT8) (mem[0x4d00]); { UINT16 u16Temp0; // 0c6f: cp a, 64h u16Temp0 = Z80A - 0x64; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x64))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x64 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 0c71: jp nz, 0c90h if (((u8Flags & 0x40) >> 6) != 1) { goto L0c90; } // 0c74: ld hl, 2e2ch Z80HL = (UINT16) (0x2e2c); // 0c77: ld (4d0ah), hl mem[0x4d0a] = Z80L; mem[0x4d0b] = Z80H; // 0c7a: ld hl, 0100h Z80HL = (UINT16) (0x0100); // 0c7d: ld (4d14h), hl mem[0x4d14] = Z80L; mem[0x4d15] = Z80H; // 0c80: ld (4d1eh), hl mem[0x4d1e] = Z80L; mem[0x4d1f] = Z80H; // 0c83: ld a, 02h Z80A = (UINT8) (0x02); // 0c85: ld (4d28h), a mem[0x4d28] = Z80A; // 0c88: ld (4d2ch), a mem[0x4d2c] = Z80A; // 0c8b: ld a, 01h Z80A = (UINT8) (1); // 0c8d: ld (4da0h), a mem[0x4da0] = Z80A; // 0c90: ld a, (4da1h) L0c90: Z80A = (UINT8) (mem[0x4da1]); { UINT16 u16Temp0; // 0c93: cp a, 01h u16Temp0 = Z80A - 1; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 1))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((1 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 0c95: jp z, 0cfbh if (((u8Flags & 0x40) >> 6) == 1) { goto L0cfb; } { UINT16 u16Temp0; // 0c98: cp a, 00h u16Temp0 = Z80A; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 0c9a: jp nz, 0cc1h if (((u8Flags & 0x40) >> 6) != 1) { goto L0cc1; } // 0c9d: ld a, (4d02h) Z80A = (UINT8) (mem[0x4d02]); { UINT16 u16Temp0; // 0ca0: cp a, 78h u16Temp0 = Z80A - 0x78; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x78))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x78 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 0ca2: call z, 1f2eh if (((u8Flags & 0x40) >> 6) == 1) { Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x0c; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xa5; goto L1f2e; } L0ca5: { UINT16 u16Temp0; // 0ca5: cp a, 80h u16Temp0 = Z80A - 0x80; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x80))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x80 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 0ca7: call z, 1f2eh if (((u8Flags & 0x40) >> 6) == 1) { Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x0c; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xaa; goto L1f2e; } L0caa: // 0caa: ld a, (4d2dh) Z80A = (UINT8) (mem[0x4d2d]); // 0cad: ld (4d29h), a mem[0x4d29] = Z80A; // 0cb0: ld ix, 4d20h Z80IX = (UINT16) (0x4d20); // 0cb4: ld iy, 4d02h Z80IY = (UINT16) (0x4d02); // 0cb8: call 2000h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x0c; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xbb; goto L2000; L0cbb: // 0cbb: ld (4d02h), hl mem[0x4d02] = Z80L; mem[0x4d03] = Z80H; // 0cbe: jp 0cfbh goto L0cfb; // 0cc1: ld ix, 3305h L0cc1: Z80IX = (UINT16) (0x3305); // 0cc5: ld iy, 4d02h Z80IY = (UINT16) (0x4d02); // 0cc9: call 2000h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x0c; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xcc; goto L2000; L0ccc: // 0ccc: ld (4d02h), hl mem[0x4d02] = Z80L; mem[0x4d03] = Z80H; // 0ccf: ld a, 03h Z80A = (UINT8) (0x03); // 0cd1: ld (4d2dh), a mem[0x4d2d] = Z80A; // 0cd4: ld (4d29h), a mem[0x4d29] = Z80A; // 0cd7: ld a, (4d02h) Z80A = (UINT8) (mem[0x4d02]); { UINT16 u16Temp0; // 0cda: cp a, 64h u16Temp0 = Z80A - 0x64; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x64))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x64 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 0cdc: jp nz, 0cfbh if (((u8Flags & 0x40) >> 6) != 1) { goto L0cfb; } // 0cdf: ld hl, 2e2ch Z80HL = (UINT16) (0x2e2c); // 0ce2: ld (4d0ch), hl mem[0x4d0c] = Z80L; mem[0x4d0d] = Z80H; // 0ce5: ld hl, 0100h Z80HL = (UINT16) (0x0100); // 0ce8: ld (4d16h), hl mem[0x4d16] = Z80L; mem[0x4d17] = Z80H; // 0ceb: ld (4d20h), hl mem[0x4d20] = Z80L; mem[0x4d21] = Z80H; // 0cee: ld a, 02h Z80A = (UINT8) (0x02); // 0cf0: ld (4d29h), a mem[0x4d29] = Z80A; // 0cf3: ld (4d2dh), a mem[0x4d2d] = Z80A; // 0cf6: ld a, 01h Z80A = (UINT8) (1); // 0cf8: ld (4da1h), a mem[0x4da1] = Z80A; // 0cfb: ld a, (4da2h) L0cfb: Z80A = (UINT8) (mem[0x4da2]); { UINT16 u16Temp0; // 0cfe: cp a, 01h u16Temp0 = Z80A - 1; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 1))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((1 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 0d00: jp z, 0d93h if (((u8Flags & 0x40) >> 6) == 1) { goto L0d93; } { UINT16 u16Temp0; // 0d03: cp a, 00h u16Temp0 = Z80A; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 0d05: jp nz, 0d2ch if (((u8Flags & 0x40) >> 6) != 1) { goto L0d2c; } // 0d08: ld a, (4d04h) Z80A = (UINT8) (mem[0x4d04]); { UINT16 u16Temp0; // 0d0b: cp a, 78h u16Temp0 = Z80A - 0x78; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x78))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x78 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 0d0d: call z, 1f55h if (((u8Flags & 0x40) >> 6) == 1) { Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x0d; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x10; goto L1f55; } L0d10: { UINT16 u16Temp0; // 0d10: cp a, 80h u16Temp0 = Z80A - 0x80; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x80))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x80 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 0d12: call z, 1f55h if (((u8Flags & 0x40) >> 6) == 1) { Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x0d; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x15; goto L1f55; } L0d15: // 0d15: ld a, (4d2eh) Z80A = (UINT8) (mem[0x4d2e]); // 0d18: ld (4d2ah), a mem[0x4d2a] = Z80A; // 0d1b: ld ix, 4d22h Z80IX = (UINT16) (0x4d22); // 0d1f: ld iy, 4d04h Z80IY = (UINT16) (0x4d04); // 0d23: call 2000h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x0d; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x26; goto L2000; L0d26: // 0d26: ld (4d04h), hl mem[0x4d04] = Z80L; mem[0x4d05] = Z80H; // 0d29: jp 0d93h goto L0d93; // 0d2c: ld a, (4da2h) L0d2c: Z80A = (UINT8) (mem[0x4da2]); { UINT16 u16Temp0; // 0d2f: cp a, 03h u16Temp0 = Z80A - 0x03; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x03))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x03 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 0d31: jp nz, 0d59h if (((u8Flags & 0x40) >> 6) != 1) { goto L0d59; } // 0d34: ld ix, 32ffh Z80IX = (UINT16) (0x32ff); // 0d38: ld iy, 4d04h Z80IY = (UINT16) (0x4d04); // 0d3c: call 2000h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x0d; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x3f; goto L2000; L0d3f: // 0d3f: ld (4d04h), hl mem[0x4d04] = Z80L; mem[0x4d05] = Z80H; // 0d42: xor a, a Z80A = (UINT8) (0); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 0d43: ld (4d2ah), a mem[0x4d2a] = Z80A; // 0d46: ld (4d2eh), a mem[0x4d2e] = Z80A; // 0d49: ld a, (4d05h) Z80A = (UINT8) (mem[0x4d05]); { UINT16 u16Temp0; // 0d4c: cp a, 80h u16Temp0 = Z80A - 0x80; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x80))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x80 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 0d4e: jp nz, 0d93h if (((u8Flags & 0x40) >> 6) != 1) { goto L0d93; } // 0d51: ld a, 02h Z80A = (UINT8) (0x02); // 0d53: ld (4da2h), a mem[0x4da2] = Z80A; // 0d56: jp 0d93h goto L0d93; // 0d59: ld ix, 3305h L0d59: Z80IX = (UINT16) (0x3305); // 0d5d: ld iy, 4d04h Z80IY = (UINT16) (0x4d04); // 0d61: call 2000h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x0d; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x64; goto L2000; L0d64: // 0d64: ld (4d04h), hl mem[0x4d04] = Z80L; mem[0x4d05] = Z80H; // 0d67: ld a, 03h Z80A = (UINT8) (0x03); // 0d69: ld (4d2ah), a mem[0x4d2a] = Z80A; // 0d6c: ld (4d2eh), a mem[0x4d2e] = Z80A; // 0d6f: ld a, (4d04h) Z80A = (UINT8) (mem[0x4d04]); { UINT16 u16Temp0; // 0d72: cp a, 64h u16Temp0 = Z80A - 0x64; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x64))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x64 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 0d74: jp nz, 0d93h if (((u8Flags & 0x40) >> 6) != 1) { goto L0d93; } // 0d77: ld hl, 2e2ch Z80HL = (UINT16) (0x2e2c); // 0d7a: ld (4d0eh), hl mem[0x4d0e] = Z80L; mem[0x4d0f] = Z80H; // 0d7d: ld hl, 0100h Z80HL = (UINT16) (0x0100); // 0d80: ld (4d18h), hl mem[0x4d18] = Z80L; mem[0x4d19] = Z80H; // 0d83: ld (4d22h), hl mem[0x4d22] = Z80L; mem[0x4d23] = Z80H; // 0d86: ld a, 02h Z80A = (UINT8) (0x02); // 0d88: ld (4d2ah), a mem[0x4d2a] = Z80A; // 0d8b: ld (4d2eh), a mem[0x4d2e] = Z80A; // 0d8e: ld a, 01h Z80A = (UINT8) (1); // 0d90: ld (4da2h), a mem[0x4da2] = Z80A; // 0d93: ld a, (4da3h) L0d93: Z80A = (UINT8) (mem[0x4da3]); { UINT16 u16Temp0; // 0d96: cp a, 01h u16Temp0 = Z80A - 1; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 1))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((1 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 0d98: ret z if (((u8Flags & 0x40) >> 6) == 1) { goto returnInstruction; } { UINT16 u16Temp0; // 0d99: cp a, 00h u16Temp0 = Z80A; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 0d9b: jp nz, 0dc0h if (((u8Flags & 0x40) >> 6) != 1) { goto L0dc0; } // 0d9e: ld a, (4d06h) Z80A = (UINT8) (mem[0x4d06]); { UINT16 u16Temp0; // 0da1: cp a, 78h u16Temp0 = Z80A - 0x78; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x78))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x78 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 0da3: call z, 1f7ch if (((u8Flags & 0x40) >> 6) == 1) { Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x0d; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xa6; goto L1f7c; } L0da6: { UINT16 u16Temp0; // 0da6: cp a, 80h u16Temp0 = Z80A - 0x80; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x80))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x80 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 0da8: call z, 1f7ch if (((u8Flags & 0x40) >> 6) == 1) { Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x0d; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xab; goto L1f7c; } L0dab: // 0dab: ld a, (4d2fh) Z80A = (UINT8) (mem[0x4d2f]); // 0dae: ld (4d2bh), a mem[0x4d2b] = Z80A; // 0db1: ld ix, 4d24h Z80IX = (UINT16) (0x4d24); // 0db5: ld iy, 4d06h Z80IY = (UINT16) (0x4d06); // 0db9: call 2000h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x0d; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xbc; goto L2000; L0dbc: // 0dbc: ld (4d06h), hl mem[0x4d06] = Z80L; mem[0x4d07] = Z80H; // 0dbf: ret goto returnInstruction; // 0dc0: ld a, (4da3h) L0dc0: Z80A = (UINT8) (mem[0x4da3]); { UINT16 u16Temp0; // 0dc3: cp a, 03h u16Temp0 = Z80A - 0x03; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x03))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x03 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 0dc5: jp nz, 0deah if (((u8Flags & 0x40) >> 6) != 1) { goto L0dea; } // 0dc8: ld ix, 3303h Z80IX = (UINT16) (0x3303); // 0dcc: ld iy, 4d06h Z80IY = (UINT16) (0x4d06); // 0dd0: call 2000h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x0d; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xd3; goto L2000; L0dd3: // 0dd3: ld (4d06h), hl mem[0x4d06] = Z80L; mem[0x4d07] = Z80H; // 0dd6: ld a, 02h Z80A = (UINT8) (0x02); // 0dd8: ld (4d2bh), a mem[0x4d2b] = Z80A; // 0ddb: ld (4d2fh), a mem[0x4d2f] = Z80A; // 0dde: ld a, (4d07h) Z80A = (UINT8) (mem[0x4d07]); { UINT16 u16Temp0; // 0de1: cp a, 80h u16Temp0 = Z80A - 0x80; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x80))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x80 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 0de3: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 0de4: ld a, 02h Z80A = (UINT8) (0x02); // 0de6: ld (4da3h), a mem[0x4da3] = Z80A; // 0de9: ret goto returnInstruction; // 0dea: ld ix, 3305h L0dea: Z80IX = (UINT16) (0x3305); // 0dee: ld iy, 4d06h Z80IY = (UINT16) (0x4d06); // 0df2: call 2000h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x0d; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xf5; goto L2000; L0df5: // 0df5: ld (4d06h), hl mem[0x4d06] = Z80L; mem[0x4d07] = Z80H; // 0df8: ld a, 03h Z80A = (UINT8) (0x03); // 0dfa: ld (4d2bh), a mem[0x4d2b] = Z80A; // 0dfd: ld (4d2fh), a mem[0x4d2f] = Z80A; // 0e00: ld a, (4d06h) Z80A = (UINT8) (mem[0x4d06]); { UINT16 u16Temp0; // 0e03: cp a, 64h u16Temp0 = Z80A - 0x64; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x64))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x64 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 0e05: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 0e06: ld hl, 2e2ch Z80HL = (UINT16) (0x2e2c); // 0e09: ld (4d10h), hl mem[0x4d10] = Z80L; mem[0x4d11] = Z80H; // 0e0c: ld hl, 0100h Z80HL = (UINT16) (0x0100); // 0e0f: ld (4d1ah), hl mem[0x4d1a] = Z80L; mem[0x4d1b] = Z80H; // 0e12: ld (4d24h), hl mem[0x4d24] = Z80L; mem[0x4d25] = Z80H; // 0e15: ld a, 02h Z80A = (UINT8) (0x02); // 0e17: ld (4d2bh), a mem[0x4d2b] = Z80A; // 0e1a: ld (4d2fh), a mem[0x4d2f] = Z80A; // 0e1d: ld a, 01h Z80A = (UINT8) (1); // 0e1f: ld (4da3h), a mem[0x4da3] = Z80A; // 0e22: ret goto returnInstruction; // 0e23: ld hl, 4dc4h L0e23: Z80HL = (UINT16) (0x4dc4); { UINT8 u8Temp0; // 0e26: inc (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 0e27: ld a, 08h Z80A = (UINT8) (0x08); { UINT16 u16Temp0; UINT8 u8Temp0; // 0e29: cp a, (hl) u8Temp0 = mem[Z80HL]; u16Temp0 = Z80A - u8Temp0; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ u8Temp0))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((u8Temp0 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 0e2a: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 0e2b: ld (hl), 00h mspacmanIndirectWrite8(Z80HL, 0); // 0e2d: ld a, (4dc0h) Z80A = (UINT8) (mem[0x4dc0]); // 0e30: xor a, 01h Z80A = (UINT8) (Z80A ^ 1); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 0e32: ld (4dc0h), a mem[0x4dc0] = Z80A; // 0e35: ret goto returnInstruction; // 0e36: ld a, (4da6h) L0e36: Z80A = (UINT8) (mem[0x4da6]); // 0e39: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 0e3a: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 0e3b: ld a, (4dc1h) Z80A = (UINT8) (mem[0x4dc1]); { UINT16 u16Temp0; // 0e3e: cp a, 07h u16Temp0 = Z80A - 0x07; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x07))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x07 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 0e40: ret z if (((u8Flags & 0x40) >> 6) == 1) { goto returnInstruction; } { UINT16 u16Temp0; // 0e41: add a, a u16Temp0 = Z80A + Z80A; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80A))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80A ^ Z80A ^ 0x80) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 0e42: ld hl, (4dc2h) Z80L = (UINT8) (mem[0x4dc2]); Z80H = (UINT8) (mem[0x4dc3]); // 0e45: inc hl Z80HL = (UINT16) (Z80HL + 1); // 0e46: ld (4dc2h), hl mem[0x4dc2] = Z80L; mem[0x4dc3] = Z80H; // 0e49: ld e, a Z80E = (UINT8) (Z80A); // 0e4a: ld d, 00h Z80D = (UINT8) (0); // 0e4c: ld ix, 4d86h Z80IX = (UINT16) (0x4d86); { UINT32 u32Temp0; // 0e50: add ix, de u32Temp0 = Z80IX + Z80DE; u8Flags = (u8Flags & ~0x10) | ((((Z80IX ^ u32Temp0 ^ Z80DE) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80IX = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 0e52: ld e, (ix+00h) Z80E = (UINT8) (mem[Z80IX]); // 0e55: ld d, (ix+01h) Z80D = (UINT8) (mem[Z80IX + 1]); // 0e58: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); { UINT32 u32Temp0; // 0e59: sbc hl, de u32Temp0 = (Z80HL - Z80DE - ((u8Flags & 0x01) >> 0)); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80DE) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | (((((Z80DE ^ Z80HL) & (Z80HL ^ u32Temp0) & 0x8000))) ? 0x04 : 0); Z80HL = (UINT16) (u32Temp0); u8Flags = (u8Flags & ~0x40) | ((Z80HL == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80HL & 0x8000) ? 0x80 : 0); u8Flags |= 0x02; } // 0e5b: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 0e5c: xor a, a Z80A = (UINT8) (0); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 0e5d: nop // 0e5e: inc a Z80A = (UINT8) (Z80A + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); if ((Z80A & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80A == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 0e5f: ld (4dc1h), a mem[0x4dc1] = Z80A; // 0e62: ld hl, 0101h Z80HL = (UINT16) (0x0101); // 0e65: ld (4db1h), hl mem[0x4db1] = Z80L; mem[0x4db2] = Z80H; // 0e68: ld (4db3h), hl mem[0x4db3] = Z80L; mem[0x4db4] = Z80H; // 0e6b: ret goto returnInstruction; // 0e6c: ld a, (4da5h) L0e6c: Z80A = (UINT8) (mem[0x4da5]); // 0e6f: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 0e70: jr z, 0e77h if (((u8Flags & 0x40) >> 6) == 1) { goto L0e77; } // 0e72: xor a, a Z80A = (UINT8) (0); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 0e73: ld (4each), a mem[0x4eac] = Z80A; // 0e76: ret goto returnInstruction; // 0e77: ld hl, 4each L0e77: Z80HL = (UINT16) (0x4eac); // 0e7a: ld b, 0e0h Z80B = (UINT8) (0xe0); // 0e7c: ld a, (peleatn) Z80A = (UINT8) (mem[0x4e0e]); { UINT16 u16Temp0; // 0e7f: cp a, 0e4h u16Temp0 = Z80A - 0xe4; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0xe4))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0xe4 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 0e81: jr c, 0e89h if (((u8Flags & 0x01) >> 0) == 1) { goto L0e89; } // 0e83: ld a, b Z80A = (UINT8) (Z80B); // 0e84: and a, (hl) Z80A = (UINT8) (Z80A & mem[Z80HL]); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 0e85: set 4, a Z80A = (UINT8) (Z80A | 0x10); // 0e87: ld (hl), a mspacmanIndirectWrite8(Z80HL, Z80A); // 0e88: ret goto returnInstruction; { UINT16 u16Temp0; // 0e89: cp a, 0d4h L0e89: u16Temp0 = Z80A - 0xd4; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0xd4))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0xd4 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 0e8b: jr c, 0e93h if (((u8Flags & 0x01) >> 0) == 1) { goto L0e93; } // 0e8d: ld a, b Z80A = (UINT8) (Z80B); // 0e8e: and a, (hl) Z80A = (UINT8) (Z80A & mem[Z80HL]); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 0e8f: set 3, a Z80A = (UINT8) (Z80A | 0x08); // 0e91: ld (hl), a mspacmanIndirectWrite8(Z80HL, Z80A); // 0e92: ret goto returnInstruction; { UINT16 u16Temp0; // 0e93: cp a, 0b4h L0e93: u16Temp0 = Z80A - 0xb4; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0xb4))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0xb4 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 0e95: jr c, 0e9dh if (((u8Flags & 0x01) >> 0) == 1) { goto L0e9d; } // 0e97: ld a, b Z80A = (UINT8) (Z80B); // 0e98: and a, (hl) Z80A = (UINT8) (Z80A & mem[Z80HL]); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 0e99: set 2, a Z80A = (UINT8) (Z80A | 0x04); // 0e9b: ld (hl), a mspacmanIndirectWrite8(Z80HL, Z80A); // 0e9c: ret goto returnInstruction; { UINT16 u16Temp0; // 0e9d: cp a, 74h L0e9d: u16Temp0 = Z80A - 0x74; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x74))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x74 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 0e9f: jr c, 0ea7h if (((u8Flags & 0x01) >> 0) == 1) { goto L0ea7; } // 0ea1: ld a, b Z80A = (UINT8) (Z80B); // 0ea2: and a, (hl) Z80A = (UINT8) (Z80A & mem[Z80HL]); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 0ea3: set 1, a Z80A = (UINT8) (Z80A | 0x02); // 0ea5: ld (hl), a mspacmanIndirectWrite8(Z80HL, Z80A); // 0ea6: ret goto returnInstruction; // 0ea7: ld a, b L0ea7: Z80A = (UINT8) (Z80B); // 0ea8: and a, (hl) Z80A = (UINT8) (Z80A & mem[Z80HL]); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 0ea9: set 0, a Z80A = (UINT8) (Z80A | 1); // 0eab: ld (hl), a mspacmanIndirectWrite8(Z80HL, Z80A); // 0eac: ret goto returnInstruction; // 0ead: jp 86eeh L0ead: goto L86ee; L0eb0: // 0eb0: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 0eb1: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 0eb2: ld a, (frbonus) Z80A = (UINT8) (mem[0x4dd4]); // 0eb5: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 0eb6: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 0eb7: ld a, (peleatn) Z80A = (UINT8) (mem[0x4e0e]); { UINT16 u16Temp0; // 0eba: cp a, 46h u16Temp0 = Z80A - 0x46; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x46))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x46 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 0ebc: jr z, 0ecch if (((u8Flags & 0x40) >> 6) == 1) { goto L0ecc; } { UINT16 u16Temp0; // 0ebe: cp a, 0aah u16Temp0 = Z80A - 0xaa; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0xaa))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0xaa ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 0ec0: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 0ec1: ld a, (4e0dh) Z80A = (UINT8) (mem[0x4e0d]); // 0ec4: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 0ec5: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 0ec6: ld hl, 4e0dh Z80HL = (UINT16) (0x4e0d); { UINT8 u8Temp0; // 0ec9: inc (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 0eca: jr 0ed5h goto L0ed5; // 0ecc: ld a, (4e0ch) L0ecc: Z80A = (UINT8) (mem[0x4e0c]); // 0ecf: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 0ed0: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 0ed1: ld hl, 4e0ch Z80HL = (UINT16) (0x4e0c); { UINT8 u8Temp0; // 0ed4: inc (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 0ed5: ld hl, 8094h L0ed5: Z80HL = (UINT16) (0x8094); // 0ed8: ld (4dd2h), hl mem[0x4dd2] = Z80L; mem[0x4dd3] = Z80H; // 0edb: ld hl, 0efdh Z80HL = (UINT16) (0x0efd); // 0ede: ld a, (boardno) ; compare board level with Z80A = (UINT8) (mem[0x4e13]); { UINT16 u16Temp0; // 0ee1: cp a, 14h ; 14 u16Temp0 = Z80A - 0x14; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x14))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x14 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 0ee3: jr c, 0ee7h if (((u8Flags & 0x01) >> 0) == 1) { goto L0ee7; } // 0ee5: ld a, 14h Z80A = (UINT8) (0x14); // 0ee7: ld b, a L0ee7: Z80B = (UINT8) (Z80A); { UINT16 u16Temp0; // 0ee8: add a, a u16Temp0 = Z80A + Z80A; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80A))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80A ^ Z80A ^ 0x80) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } { UINT16 u16Temp0; // 0ee9: add a, b u16Temp0 = Z80A + Z80B; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80B))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80B ^ Z80A ^ 0x80) & (Z80B ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 0eea: rst 10h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x0e; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xeb; goto L0010; L0eeb: // 0eeb: ld (frshape), a mem[0x4c0c] = Z80A; // 0eee: inc hl Z80HL = (UINT16) (Z80HL + 1); // 0eef: ld a, (hl) Z80A = (UINT8) (mem[Z80HL]); // 0ef0: ld (frcol), a // $0efd - 0f3b = table for fruit shapes, colors, point value. // (the 3 bytes are stored in the above order) // offset 0 1 2 3 4 5 6 7 8 9 a b c d e f mem[0x4c0d] = Z80A; // 0ef3: inc hl Z80HL = (UINT16) (Z80HL + 1); // 0ef4: ld a, (hl) Z80A = (UINT8) (mem[Z80HL]); // 0ef5: ld (frbonus), a mem[0x4dd4] = Z80A; // 0ef8: rst 30h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x0e; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xf9; goto L0030; L0efc: // 0efc: ret goto returnInstruction; // 1000: xor a, a L1000: Z80A = (UINT8) (0); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1001: ld (frbonus), a mem[0x4dd4] = Z80A; // 1004: ret goto returnInstruction; L100b: // 100b: jp 3678h goto L3678; // 1017: call 1291h L1017: Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x10; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x1a; goto L1291; L101a: // 101a: ld a, (4da5h) Z80A = (UINT8) (mem[0x4da5]); // 101d: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 101e: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 101f: call 1066h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x10; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x22; goto L1066; L1022: // 1022: call 1094h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x10; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x25; goto L1094; L1025: // 1025: call 109eh Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x10; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x28; goto L109e; L1028: // 1028: call 10a8h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x10; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x2b; goto L10a8; L102b: // 102b: call 10b4h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x10; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x2e; goto L10b4; L102e: // 102e: ld a, (4da4h) Z80A = (UINT8) (mem[0x4da4]); // 1031: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1032: jp z, 1039h if (((u8Flags & 0x40) >> 6) == 1) { goto L1039; } // 1035: call 1235h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x10; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x38; goto L1235; L1038: // 1038: ret goto returnInstruction; // 1039: call 171dh L1039: Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x10; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x3c; goto L171d; L103c: // 103c: call 1789h ; check for collision with blue ghost Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x10; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x3f; goto L1789; L103f: // 103f: ld a, (4da4h) Z80A = (UINT8) (mem[0x4da4]); // 1042: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1043: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 1044: call 1806h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x10; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x47; goto L1806; L1047: // 1047: call 1b36h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x10; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x4a; goto L1b36; L104a: // 104a: call 1c4bh Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x10; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x4d; goto L1c4b; L104d: // 104d: call 1d22h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x10; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x50; goto L1d22; L1050: // 1050: call 1df9h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x10; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x53; goto L1df9; L1053: // 1053: ld a, (4e04h) Z80A = (UINT8) (mem[0x4e04]); { UINT16 u16Temp0; // 1056: cp a, 03h u16Temp0 = Z80A - 0x03; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x03))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x03 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 1058: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 1059: call 1376h ; control blue time Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x10; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x5c; goto L1376; L105c: // 105c: call 2069h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x10; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x5f; goto L2069; L105f: // 105f: call 208ch Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x10; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x62; goto L208c; L1062: // 1062: call 20afh Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x10; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x65; goto L20af; L1065: // 1065: ret goto returnInstruction; // 1066: ld a, (4dabh) L1066: Z80A = (UINT8) (mem[0x4dab]); // 1069: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 106a: ret z if (((u8Flags & 0x40) >> 6) == 1) { goto returnInstruction; } // 106b: dec a Z80A = (UINT8) (Z80A - 1); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); if ((Z80A & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80A == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 106c: jr nz, 01076h if (((u8Flags & 0x40) >> 6) != 1) { goto L1076; } // 106e: ld (4dabh), a mem[0x4dab] = Z80A; // 1071: inc a Z80A = (UINT8) (Z80A + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); if ((Z80A & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80A == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 1072: ld (4dach), a mem[0x4dac] = Z80A; // 1075: ret goto returnInstruction; // 1076: dec a L1076: Z80A = (UINT8) (Z80A - 1); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); if ((Z80A & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80A == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 1077: jr nz, 01081h if (((u8Flags & 0x40) >> 6) != 1) { goto L1081; } // 1079: ld (4dabh), a mem[0x4dab] = Z80A; // 107c: inc a Z80A = (UINT8) (Z80A + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); if ((Z80A & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80A == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 107d: ld (4dadh), a mem[0x4dad] = Z80A; // 1080: ret goto returnInstruction; // 1081: dec a L1081: Z80A = (UINT8) (Z80A - 1); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); if ((Z80A & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80A == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 1082: jr nz, 0108ch if (((u8Flags & 0x40) >> 6) != 1) { goto L108c; } // 1084: ld (4dabh), a mem[0x4dab] = Z80A; // 1087: inc a Z80A = (UINT8) (Z80A + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); if ((Z80A & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80A == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 1088: ld (4daeh), a mem[0x4dae] = Z80A; // 108b: ret goto returnInstruction; // 108c: ld (4dafh), a L108c: mem[0x4daf] = Z80A; // 108f: dec a Z80A = (UINT8) (Z80A - 1); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); if ((Z80A & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80A == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 1090: ld (4dabh), a mem[0x4dab] = Z80A; // 1093: ret goto returnInstruction; // 1094: ld a, (4dach) L1094: Z80A = (UINT8) (mem[0x4dac]); // 1097: rst 20h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x10; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x98; goto L0020; // 109e: ld a, (4dadh) L109e: Z80A = (UINT8) (mem[0x4dad]); // 10a1: rst 20h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x10; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xa2; goto L0020; // 10a8: ld a, (4daeh) L10a8: Z80A = (UINT8) (mem[0x4dae]); // 10ab: rst 20h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x10; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xac; goto L0020; // 10b4: ld a, (4dafh) L10b4: Z80A = (UINT8) (mem[0x4daf]); // 10b7: rst 20h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x10; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xb8; goto L0020; L10c0: // 10c0: call 1bd8h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x10; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xc3; goto L1bd8; L10c3: // 10c3: ld hl, (4d00h) Z80L = (UINT8) (mem[0x4d00]); Z80H = (UINT8) (mem[0x4d01]); // 10c6: ld de, 8064h Z80DE = (UINT16) (0x8064); // 10c9: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); { UINT32 u32Temp0; // 10ca: sbc hl, de u32Temp0 = (Z80HL - Z80DE - ((u8Flags & 0x01) >> 0)); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80DE) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | (((((Z80DE ^ Z80HL) & (Z80HL ^ u32Temp0) & 0x8000))) ? 0x04 : 0); Z80HL = (UINT16) (u32Temp0); u8Flags = (u8Flags & ~0x40) | ((Z80HL == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80HL & 0x8000) ? 0x80 : 0); u8Flags |= 0x02; } // 10cc: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 10cd: ld hl, 4dach Z80HL = (UINT16) (0x4dac); { UINT8 u8Temp0; // 10d0: inc (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 10d1: ret goto returnInstruction; L10d2: // 10d2: ld ix, 3301h Z80IX = (UINT16) (0x3301); // 10d6: ld iy, 4d00h Z80IY = (UINT16) (0x4d00); // 10da: call 2000h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x10; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xdd; goto L2000; L10dd: // 10dd: ld (4d00h), hl mem[0x4d00] = Z80L; mem[0x4d01] = Z80H; // 10e0: ld a, 01h Z80A = (UINT8) (1); // 10e2: ld (4d28h), a mem[0x4d28] = Z80A; // 10e5: ld (4d2ch), a mem[0x4d2c] = Z80A; // 10e8: ld a, (4d00h) Z80A = (UINT8) (mem[0x4d00]); { UINT16 u16Temp0; // 10eb: cp a, 80h u16Temp0 = Z80A - 0x80; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x80))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x80 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 10ed: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 10ee: ld hl, 2e2fh Z80HL = (UINT16) (0x2e2f); // 10f1: ld (4d0ah), hl mem[0x4d0a] = Z80L; mem[0x4d0b] = Z80H; // 10f4: ld (4d31h), hl mem[0x4d31] = Z80L; mem[0x4d32] = Z80H; // 10f7: xor a, a Z80A = (UINT8) (0); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 10f8: ld (4da0h), a mem[0x4da0] = Z80A; // 10fb: ld (4dach), a mem[0x4dac] = Z80A; // 10fe: ld (4da7h), a mem[0x4da7] = Z80A; // 1101: ld ix, 4dach L1101: Z80IX = (UINT16) (0x4dac); // 1105: or a, (ix+00h) Z80A = (UINT8) (Z80A | mem[Z80IX]); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1108: or a, (ix+01h) Z80A = (UINT8) (Z80A | mem[Z80IX + 1]); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 110b: or a, (ix+02h) Z80A = (UINT8) (Z80A | mem[Z80IX + 0x02]); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 110e: or a, (ix+03h) Z80A = (UINT8) (Z80A | mem[Z80IX + 0x03]); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1111: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 1112: ld hl, 4each Z80HL = (UINT16) (0x4eac); // 1115: res 6, (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] & 0xbf); // 1117: ret goto returnInstruction; L1118: // 1118: call 1cafh Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x11; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x1b; goto L1caf; L111b: // 111b: ld hl, (4d02h) Z80L = (UINT8) (mem[0x4d02]); Z80H = (UINT8) (mem[0x4d03]); // 111e: ld de, 8064h Z80DE = (UINT16) (0x8064); // 1121: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); { UINT32 u32Temp0; // 1122: sbc hl, de u32Temp0 = (Z80HL - Z80DE - ((u8Flags & 0x01) >> 0)); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80DE) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | (((((Z80DE ^ Z80HL) & (Z80HL ^ u32Temp0) & 0x8000))) ? 0x04 : 0); Z80HL = (UINT16) (u32Temp0); u8Flags = (u8Flags & ~0x40) | ((Z80HL == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80HL & 0x8000) ? 0x80 : 0); u8Flags |= 0x02; } // 1124: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 1125: ld hl, 4dadh Z80HL = (UINT16) (0x4dad); { UINT8 u8Temp0; // 1128: inc (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 1129: ret goto returnInstruction; L112a: // 112a: ld ix, 3301h Z80IX = (UINT16) (0x3301); // 112e: ld iy, 4d02h Z80IY = (UINT16) (0x4d02); // 1132: call 2000h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x11; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x35; goto L2000; L1135: // 1135: ld (4d02h), hl mem[0x4d02] = Z80L; mem[0x4d03] = Z80H; // 1138: ld a, 01h Z80A = (UINT8) (1); // 113a: ld (4d29h), a mem[0x4d29] = Z80A; // 113d: ld (4d2dh), a mem[0x4d2d] = Z80A; // 1140: ld a, (4d02h) Z80A = (UINT8) (mem[0x4d02]); { UINT16 u16Temp0; // 1143: cp a, 80h u16Temp0 = Z80A - 0x80; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x80))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x80 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 1145: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 1146: ld hl, 2e2fh Z80HL = (UINT16) (0x2e2f); // 1149: ld (4d0ch), hl mem[0x4d0c] = Z80L; mem[0x4d0d] = Z80H; // 114c: ld (4d33h), hl mem[0x4d33] = Z80L; mem[0x4d34] = Z80H; // 114f: xor a, a Z80A = (UINT8) (0); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1150: ld (4da1h), a mem[0x4da1] = Z80A; // 1153: ld (4dadh), a mem[0x4dad] = Z80A; // 1156: ld (4da8h), a mem[0x4da8] = Z80A; // 1159: jp 1101h goto L1101; L115c: // 115c: call 1d86h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x11; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x5f; goto L1d86; L115f: // 115f: ld hl, (4d04h) Z80L = (UINT8) (mem[0x4d04]); Z80H = (UINT8) (mem[0x4d05]); // 1162: ld de, 8064h Z80DE = (UINT16) (0x8064); // 1165: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); { UINT32 u32Temp0; // 1166: sbc hl, de u32Temp0 = (Z80HL - Z80DE - ((u8Flags & 0x01) >> 0)); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80DE) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | (((((Z80DE ^ Z80HL) & (Z80HL ^ u32Temp0) & 0x8000))) ? 0x04 : 0); Z80HL = (UINT16) (u32Temp0); u8Flags = (u8Flags & ~0x40) | ((Z80HL == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80HL & 0x8000) ? 0x80 : 0); u8Flags |= 0x02; } // 1168: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 1169: ld hl, 4daeh Z80HL = (UINT16) (0x4dae); { UINT8 u8Temp0; // 116c: inc (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 116d: ret goto returnInstruction; L116e: // 116e: ld ix, 3301h Z80IX = (UINT16) (0x3301); // 1172: ld iy, 4d04h Z80IY = (UINT16) (0x4d04); // 1176: call 2000h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x11; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x79; goto L2000; L1179: // 1179: ld (4d04h), hl mem[0x4d04] = Z80L; mem[0x4d05] = Z80H; // 117c: ld a, 01h Z80A = (UINT8) (1); // 117e: ld (4d2ah), a mem[0x4d2a] = Z80A; // 1181: ld (4d2eh), a mem[0x4d2e] = Z80A; // 1184: ld a, (4d04h) Z80A = (UINT8) (mem[0x4d04]); { UINT16 u16Temp0; // 1187: cp a, 80h u16Temp0 = Z80A - 0x80; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x80))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x80 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 1189: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 118a: ld hl, 4daeh Z80HL = (UINT16) (0x4dae); { UINT8 u8Temp0; // 118d: inc (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 118e: ret goto returnInstruction; L118f: // 118f: ld ix, 3303h Z80IX = (UINT16) (0x3303); // 1193: ld iy, 4d04h Z80IY = (UINT16) (0x4d04); // 1197: call 2000h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x11; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x9a; goto L2000; L119a: // 119a: ld (4d04h), hl mem[0x4d04] = Z80L; mem[0x4d05] = Z80H; // 119d: ld a, 02h Z80A = (UINT8) (0x02); // 119f: ld (4d2ah), a mem[0x4d2a] = Z80A; // 11a2: ld (4d2eh), a mem[0x4d2e] = Z80A; // 11a5: ld a, (4d05h) Z80A = (UINT8) (mem[0x4d05]); { UINT16 u16Temp0; // 11a8: cp a, 90h u16Temp0 = Z80A - 0x90; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x90))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x90 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 11aa: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 11ab: ld hl, 302fh Z80HL = (UINT16) (0x302f); // 11ae: ld (4d0eh), hl mem[0x4d0e] = Z80L; mem[0x4d0f] = Z80H; // 11b1: ld (4d35h), hl mem[0x4d35] = Z80L; mem[0x4d36] = Z80H; // 11b4: ld a, 01h Z80A = (UINT8) (1); // 11b6: ld (4d2ah), a mem[0x4d2a] = Z80A; // 11b9: ld (4d2eh), a mem[0x4d2e] = Z80A; // 11bc: xor a, a Z80A = (UINT8) (0); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 11bd: ld (4da2h), a mem[0x4da2] = Z80A; // 11c0: ld (4daeh), a mem[0x4dae] = Z80A; // 11c3: ld (4da9h), a mem[0x4da9] = Z80A; // 11c6: jp 1101h goto L1101; L11c9: // 11c9: call 1e5dh Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x11; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xcc; goto L1e5d; L11cc: // 11cc: ld hl, (4d06h) Z80L = (UINT8) (mem[0x4d06]); Z80H = (UINT8) (mem[0x4d07]); // 11cf: ld de, 8064h Z80DE = (UINT16) (0x8064); // 11d2: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); { UINT32 u32Temp0; // 11d3: sbc hl, de u32Temp0 = (Z80HL - Z80DE - ((u8Flags & 0x01) >> 0)); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80DE) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | (((((Z80DE ^ Z80HL) & (Z80HL ^ u32Temp0) & 0x8000))) ? 0x04 : 0); Z80HL = (UINT16) (u32Temp0); u8Flags = (u8Flags & ~0x40) | ((Z80HL == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80HL & 0x8000) ? 0x80 : 0); u8Flags |= 0x02; } // 11d5: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 11d6: ld hl, 4dafh Z80HL = (UINT16) (0x4daf); { UINT8 u8Temp0; // 11d9: inc (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 11da: ret goto returnInstruction; L11db: // 11db: ld ix, 3301h Z80IX = (UINT16) (0x3301); // 11df: ld iy, 4d06h Z80IY = (UINT16) (0x4d06); // 11e3: call 2000h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x11; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xe6; goto L2000; L11e6: // 11e6: ld (4d06h), hl mem[0x4d06] = Z80L; mem[0x4d07] = Z80H; // 11e9: ld a, 01h Z80A = (UINT8) (1); // 11eb: ld (4d2bh), a mem[0x4d2b] = Z80A; // 11ee: ld (4d2fh), a mem[0x4d2f] = Z80A; // 11f1: ld a, (4d06h) Z80A = (UINT8) (mem[0x4d06]); { UINT16 u16Temp0; // 11f4: cp a, 80h u16Temp0 = Z80A - 0x80; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x80))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x80 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 11f6: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 11f7: ld hl, 4dafh Z80HL = (UINT16) (0x4daf); { UINT8 u8Temp0; // 11fa: inc (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 11fb: ret goto returnInstruction; L11fc: // 11fc: ld ix, 32ffh Z80IX = (UINT16) (0x32ff); // 1200: ld iy, 4d06h Z80IY = (UINT16) (0x4d06); // 1204: call 2000h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x12; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x07; goto L2000; L1207: // 1207: ld (4d06h), hl mem[0x4d06] = Z80L; mem[0x4d07] = Z80H; // 120a: xor a, a Z80A = (UINT8) (0); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 120b: ld (4d2bh), a mem[0x4d2b] = Z80A; // 120e: ld (4d2fh), a mem[0x4d2f] = Z80A; // 1211: ld a, (4d07h) Z80A = (UINT8) (mem[0x4d07]); { UINT16 u16Temp0; // 1214: cp a, 70h u16Temp0 = Z80A - 0x70; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x70))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x70 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 1216: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 1217: ld hl, 2c2fh Z80HL = (UINT16) (0x2c2f); // 121a: ld (4d10h), hl mem[0x4d10] = Z80L; mem[0x4d11] = Z80H; // 121d: ld (4d37h), hl mem[0x4d37] = Z80L; mem[0x4d38] = Z80H; // 1220: ld a, 01h Z80A = (UINT8) (1); // 1222: ld (4d2bh), a mem[0x4d2b] = Z80A; // 1225: ld (4d2fh), a mem[0x4d2f] = Z80A; // 1228: xor a, a Z80A = (UINT8) (0); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1229: ld (4da3h), a mem[0x4da3] = Z80A; // 122c: ld (4dafh), a mem[0x4daf] = Z80A; // 122f: ld (4daah), a mem[0x4daa] = Z80A; // 1232: jp 1101h goto L1101; // 1235: ld a, (4dd1h) L1235: Z80A = (UINT8) (mem[0x4dd1]); // 1238: rst 20h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x12; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x39; goto L0020; L123f: // 123f: ld hl, 4c00h Z80HL = (UINT16) (0x4c00); // 1242: ld a, (4da4h) Z80A = (UINT8) (mem[0x4da4]); { UINT16 u16Temp0; // 1245: add a, a u16Temp0 = Z80A + Z80A; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80A))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80A ^ Z80A ^ 0x80) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 1246: ld e, a Z80E = (UINT8) (Z80A); // 1247: ld d, 00h Z80D = (UINT8) (0); { UINT32 u32Temp0; // 1249: add hl, de u32Temp0 = Z80HL + Z80DE; u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80DE) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 124a: ld a, (4dd1h) Z80A = (UINT8) (mem[0x4dd1]); // 124d: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 124e: jr nz, 01277h if (((u8Flags & 0x40) >> 6) != 1) { goto L1277; } // 1250: ld a, (4dd0h) Z80A = (UINT8) (mem[0x4dd0]); // 1253: ld b, 27h Z80B = (UINT8) (0x27); { UINT16 u16Temp0; // 1255: add a, b u16Temp0 = Z80A + Z80B; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80B))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80B ^ Z80A ^ 0x80) & (Z80B ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 1256: ld b, a Z80B = (UINT8) (Z80A); // 1257: ld a, (cabtype) Z80A = (UINT8) (mem[0x4e72]); // 125a: ld c, a Z80C = (UINT8) (Z80A); // 125b: ld a, (4e09h) Z80A = (UINT8) (mem[0x4e09]); // 125e: and a, c Z80A = (UINT8) (Z80A & Z80C); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 125f: jr z, 01265h if (((u8Flags & 0x40) >> 6) == 1) { goto L1265; } // 1261: set 6, b Z80B = (UINT8) (Z80B | 0x40); // 1263: set 7, b Z80B = (UINT8) (Z80B | 0x80); // 1265: ld (hl), b L1265: mspacmanIndirectWrite8(Z80HL, Z80B); // 1266: inc hl Z80HL = (UINT16) (Z80HL + 1); // 1267: ld (hl), 18h mspacmanIndirectWrite8(Z80HL, 0x18); // 1269: ld a, 00h Z80A = (UINT8) (0); // 126b: ld (4c0bh), a mem[0x4c0b] = Z80A; // 126e: rst 30h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x12; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x6f; goto L0030; L1272: // 1272: ld hl, 4dd1h Z80HL = (UINT16) (0x4dd1); { UINT8 u8Temp0; // 1275: inc (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 1276: ret goto returnInstruction; // 1277: ld (hl), 20h L1277: mspacmanIndirectWrite8(Z80HL, 0x20); // 1279: ld a, 09h Z80A = (UINT8) (0x09); // 127b: ld (4c0bh), a mem[0x4c0b] = Z80A; // 127e: ld a, (4da4h) Z80A = (UINT8) (mem[0x4da4]); // 1281: ld (4dabh), a mem[0x4dab] = Z80A; // 1284: xor a, a Z80A = (UINT8) (0); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1285: ld (4da4h), a mem[0x4da4] = Z80A; // 1288: ld (4dd1h), a mem[0x4dd1] = Z80A; // 128b: ld hl, 4each Z80HL = (UINT16) (0x4eac); // 128e: set 6, (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] | 0x40); // 1290: ret goto returnInstruction; // 1291: ld a, (4da5h) L1291: Z80A = (UINT8) (mem[0x4da5]); // 1294: rst 20h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x12; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x95; goto L0020; L12b7: // 12b7: ld hl, (4dc5h) Z80L = (UINT8) (mem[0x4dc5]); Z80H = (UINT8) (mem[0x4dc6]); // 12ba: inc hl Z80HL = (UINT16) (Z80HL + 1); // 12bb: ld (4dc5h), hl mem[0x4dc5] = Z80L; mem[0x4dc6] = Z80H; // 12be: ld de, 0078h Z80DE = (UINT16) (0x78); // 12c1: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); { UINT32 u32Temp0; // 12c2: sbc hl, de u32Temp0 = (Z80HL - Z80DE - ((u8Flags & 0x01) >> 0)); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80DE) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | (((((Z80DE ^ Z80HL) & (Z80HL ^ u32Temp0) & 0x8000))) ? 0x04 : 0); Z80HL = (UINT16) (u32Temp0); u8Flags = (u8Flags & ~0x40) | ((Z80HL == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80HL & 0x8000) ? 0x80 : 0); u8Flags |= 0x02; } // 12c4: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 12c5: ld a, 05h Z80A = (UINT8) (0x05); // 12c7: ld (4da5h), a mem[0x4da5] = Z80A; // 12ca: ret goto returnInstruction; L12cb: // 12cb: ld hl, 0000h // adjust mspac sprite animation? Z80HL = (UINT16) (0); // 12ce: call 267eh Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x12; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xd1; goto L267e; L12d1: // 12d1: ld a, 34h Z80A = (UINT8) (0x34); // 12d3: ld de, 00b4h Z80DE = (UINT16) (0xb4); // 12d6: ld c, a L12d6: Z80C = (UINT8) (Z80A); // 12d7: ld a, (cabtype) Z80A = (UINT8) (mem[0x4e72]); // 12da: ld b, a Z80B = (UINT8) (Z80A); // 12db: ld a, (4e09h) Z80A = (UINT8) (mem[0x4e09]); // 12de: and a, b Z80A = (UINT8) (Z80A & Z80B); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 12df: jr z, 012e5h if (((u8Flags & 0x40) >> 6) == 1) { goto L12e5; } // 12e1: ld a, 0c0h Z80A = (UINT8) (0xc0); // 12e3: or a, c Z80A = (UINT8) (Z80A | Z80C); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 12e4: ld c, a Z80C = (UINT8) (Z80A); // 12e5: ld a, c L12e5: Z80A = (UINT8) (Z80C); // 12e6: ld (4c0ah), a ; mspac sprite number mem[0x4c0a] = Z80A; // 12e9: ld hl, (4dc5h) Z80L = (UINT8) (mem[0x4dc5]); Z80H = (UINT8) (mem[0x4dc6]); // 12ec: inc hl Z80HL = (UINT16) (Z80HL + 1); // 12ed: ld (4dc5h), hl mem[0x4dc5] = Z80L; mem[0x4dc6] = Z80H; // 12f0: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); { UINT32 u32Temp0; // 12f1: sbc hl, de u32Temp0 = (Z80HL - Z80DE - ((u8Flags & 0x01) >> 0)); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80DE) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | (((((Z80DE ^ Z80HL) & (Z80HL ^ u32Temp0) & 0x8000))) ? 0x04 : 0); Z80HL = (UINT16) (u32Temp0); u8Flags = (u8Flags & ~0x40) | ((Z80HL == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80HL & 0x8000) ? 0x80 : 0); u8Flags |= 0x02; } // 12f3: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 12f4: ld hl, 4da5h Z80HL = (UINT16) (0x4da5); { UINT8 u8Temp0; // 12f7: inc (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 12f8: ret goto returnInstruction; L12f9: // 12f9: ld hl, 4ebch Z80HL = (UINT16) (0x4ebc); // 12fc: set 4, (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] | 0x10); // 12fe: ld a, 35h Z80A = (UINT8) (0x35); // 1300: ld de, 00c3h Z80DE = (UINT16) (0xc3); // 1303: jp 12d6h goto L12d6; L1306: // 1306: ld a, 36h Z80A = (UINT8) (0x36); // 1308: ld de, 00d2h Z80DE = (UINT16) (0xd2); // 130b: jp 12d6h goto L12d6; L130e: // 130e: ld a, 37h Z80A = (UINT8) (0x37); // 1310: ld de, 00e1h Z80DE = (UINT16) (0xe1); // 1313: jp 12d6h goto L12d6; L1316: // 1316: ld a, 38h Z80A = (UINT8) (0x38); // 1318: ld de, 00f0h Z80DE = (UINT16) (0xf0); // 131b: jp 12d6h goto L12d6; L131e: // 131e: ld a, 39h Z80A = (UINT8) (0x39); // 1320: ld de, 00ffh Z80DE = (UINT16) (0xff); // 1323: jp 12d6h goto L12d6; L1326: // 1326: ld a, 3ah Z80A = (UINT8) (0x3a); // 1328: ld de, 010eh Z80DE = (UINT16) (0x010e); // 132b: jp 12d6h goto L12d6; L132e: // 132e: ld a, 3bh Z80A = (UINT8) (0x3b); // 1330: ld de, 011dh Z80DE = (UINT16) (0x011d); // 1333: jp 12d6h goto L12d6; L1336: // 1336: ld a, 3ch Z80A = (UINT8) (0x3c); // 1338: ld de, 012ch Z80DE = (UINT16) (0x012c); // 133b: jp 12d6h goto L12d6; L133e: // 133e: ld a, 3dh Z80A = (UINT8) (0x3d); // 1340: ld de, 013bh Z80DE = (UINT16) (0x013b); // 1343: jp 12d6h goto L12d6; L1346: // 1346: ld hl, 4ebch Z80HL = (UINT16) (0x4ebc); // 1349: ld (hl), 00h mspacmanIndirectWrite8(Z80HL, 0); // 134b: ld a, 3eh Z80A = (UINT8) (0x3e); // 134d: ld de, 0159h Z80DE = (UINT16) (0x0159); // 1350: jp 12d6h goto L12d6; L1353: // 1353: ld a, 3fh // game end tests? Z80A = (UINT8) (0x3f); // 1355: ld (4c0ah), a ; mspac sprite number mem[0x4c0a] = Z80A; // 1358: ld hl, (4dc5h) Z80L = (UINT8) (mem[0x4dc5]); Z80H = (UINT8) (mem[0x4dc6]); // 135b: inc hl Z80HL = (UINT16) (Z80HL + 1); // 135c: ld (4dc5h), hl mem[0x4dc5] = Z80L; mem[0x4dc6] = Z80H; // 135f: ld de, 01b8h Z80DE = (UINT16) (0x01b8); // 1362: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); { UINT32 u32Temp0; // 1363: sbc hl, de u32Temp0 = (Z80HL - Z80DE - ((u8Flags & 0x01) >> 0)); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80DE) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | (((((Z80DE ^ Z80HL) & (Z80HL ^ u32Temp0) & 0x8000))) ? 0x04 : 0); Z80HL = (UINT16) (u32Temp0); u8Flags = (u8Flags & ~0x40) | ((Z80HL == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80HL & 0x8000) ? 0x80 : 0); u8Flags |= 0x02; } // 1365: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 1366: ld hl, lives ; hl = number of lives left // decrement lives // this gets called after the death animation, but before the // screen gets redrawn. // -- probably a good hook point for 'insert coin to contunue' -- Z80HL = (UINT16) (0x4e14); { UINT8 u8Temp0; // 1369: dec (hl) ; subtract 1 mspacmanIndirectWrite8(Z80HL, mem[Z80HL] - 1); u8Temp0 = mem[Z80HL]; u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 136a: ld hl, scrlves ; hl = number of lives on screen Z80HL = (UINT16) (0x4e15); { UINT8 u8Temp0; // 136d: dec (hl) ; subtract 1 mspacmanIndirectWrite8(Z80HL, mem[Z80HL] - 1); u8Temp0 = mem[Z80HL]; u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 136e: call 2675h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x13; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x71; goto L2675; L1371: // 1371: ld hl, 4e04h ; 3=ghost move 2=ghost wait Z80HL = (UINT16) (0x4e04); { UINT8 u8Temp0; // 1374: inc (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 1375: ret goto returnInstruction; // 1376: ld a, (4da6h) // routine to control blue time // ret immediately to make ghosts stay blue till eaten L1376: Z80A = (UINT8) (mem[0x4da6]); // 1379: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 137a: ret z if (((u8Flags & 0x40) >> 6) == 1) { goto returnInstruction; } // 137b: ld ix, 4da7h Z80IX = (UINT16) (0x4da7); // 137f: ld a, (ix+00h) Z80A = (UINT8) (mem[Z80IX]); // 1382: or a, (ix+01h) Z80A = (UINT8) (Z80A | mem[Z80IX + 1]); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1385: or a, (ix+02h) Z80A = (UINT8) (Z80A | mem[Z80IX + 0x02]); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1388: or a, (ix+03h) Z80A = (UINT8) (Z80A | mem[Z80IX + 0x03]); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 138b: jp z, 1398h if (((u8Flags & 0x40) >> 6) == 1) { goto L1398; } // 138e: ld hl, (4dcbh) Z80L = (UINT8) (mem[0x4dcb]); Z80H = (UINT8) (mem[0x4dcc]); // 1391: dec hl Z80HL = (UINT16) (Z80HL - 1); // 1392: ld (4dcbh), hl mem[0x4dcb] = Z80L; mem[0x4dcc] = Z80H; // 1395: ld a, h Z80A = (UINT8) (Z80H); // 1396: or a, l Z80A = (UINT8) (Z80A | Z80L); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1397: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 1398: ld hl, 4c0bh L1398: Z80HL = (UINT16) (0x4c0b); // 139b: ld (hl), 09h mspacmanIndirectWrite8(Z80HL, 0x09); // 139d: ld a, (4dach) Z80A = (UINT8) (mem[0x4dac]); // 13a0: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 13a1: jp nz, 13a7h if (((u8Flags & 0x40) >> 6) != 1) { goto L13a7; } // 13a4: ld (4da7h), a mem[0x4da7] = Z80A; // 13a7: ld a, (4dadh) L13a7: Z80A = (UINT8) (mem[0x4dad]); // 13aa: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 13ab: jp nz, 13b1h if (((u8Flags & 0x40) >> 6) != 1) { goto L13b1; } // 13ae: ld (4da8h), a mem[0x4da8] = Z80A; // 13b1: ld a, (4daeh) L13b1: Z80A = (UINT8) (mem[0x4dae]); // 13b4: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 13b5: jp nz, 13bbh if (((u8Flags & 0x40) >> 6) != 1) { goto L13bb; } // 13b8: ld (4da9h), a mem[0x4da9] = Z80A; // 13bb: ld a, (4dafh) L13bb: Z80A = (UINT8) (mem[0x4daf]); // 13be: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 13bf: jp nz, 13c5h if (((u8Flags & 0x40) >> 6) != 1) { goto L13c5; } // 13c2: ld (4daah), a mem[0x4daa] = Z80A; // 13c5: xor a, a L13c5: Z80A = (UINT8) (0); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 13c6: ld (4dcbh), a mem[0x4dcb] = Z80A; // 13c9: ld (4dcch), a mem[0x4dcc] = Z80A; // 13cc: ld (4da6h), a mem[0x4da6] = Z80A; // 13cf: ld (4dc8h), a mem[0x4dc8] = Z80A; // 13d2: ld (4dd0h), a mem[0x4dd0] = Z80A; // 13d5: ld hl, 4each Z80HL = (UINT16) (0x4eac); // 13d8: res 5, (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] & 0xdf); // 13da: res 7, (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] & 0x7f); // 13dc: ret goto returnInstruction; // 13dd: ld hl, 4d9eh L13dd: Z80HL = (UINT16) (0x4d9e); // 13e0: ld a, (peleatn) Z80A = (UINT8) (mem[0x4e0e]); { UINT16 u16Temp0; UINT8 u8Temp0; // 13e3: cp a, (hl) u8Temp0 = mem[Z80HL]; u16Temp0 = Z80A - u8Temp0; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ u8Temp0))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((u8Temp0 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 13e4: jp z, 13eeh if (((u8Flags & 0x40) >> 6) == 1) { goto L13ee; } // 13e7: ld hl, 0000h Z80HL = (UINT16) (0); // 13ea: ld (4d97h), hl mem[0x4d97] = Z80L; mem[0x4d98] = Z80H; // 13ed: ret goto returnInstruction; // 13ee: ld hl, (4d97h) L13ee: Z80L = (UINT8) (mem[0x4d97]); Z80H = (UINT8) (mem[0x4d98]); // 13f1: inc hl Z80HL = (UINT16) (Z80HL + 1); // 13f2: ld (4d97h), hl mem[0x4d97] = Z80L; mem[0x4d98] = Z80H; // 13f5: ld de, (4d95h) Z80E = (UINT8) (mem[0x4d95]); Z80D = (UINT8) (mem[0x4d96]); // 13f9: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); { UINT32 u32Temp0; // 13fa: sbc hl, de u32Temp0 = (Z80HL - Z80DE - ((u8Flags & 0x01) >> 0)); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80DE) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | (((((Z80DE ^ Z80HL) & (Z80HL ^ u32Temp0) & 0x8000))) ? 0x04 : 0); Z80HL = (UINT16) (u32Temp0); u8Flags = (u8Flags & ~0x40) | ((Z80HL == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80HL & 0x8000) ? 0x80 : 0); u8Flags |= 0x02; } // 13fc: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 13fd: ld hl, 0000h Z80HL = (UINT16) (0); // 1400: ld (4d97h), hl mem[0x4d97] = Z80L; mem[0x4d98] = Z80H; // 1403: ld a, (4da1h) Z80A = (UINT8) (mem[0x4da1]); // 1406: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1407: push af Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80A; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = u8Flags; // 1408: call z, 2086h if (((u8Flags & 0x40) >> 6) == 1) { Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x14; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x0b; goto L2086; } L140b: // 140b: pop af u8Flags = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); Z80A = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); // 140c: ret z if (((u8Flags & 0x40) >> 6) == 1) { goto returnInstruction; } // 140d: ld a, (4da2h) Z80A = (UINT8) (mem[0x4da2]); // 1410: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1411: push af Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80A; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = u8Flags; // 1412: call z, 20a9h if (((u8Flags & 0x40) >> 6) == 1) { Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x14; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x15; goto L20a9; } L1415: // 1415: pop af u8Flags = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); Z80A = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); // 1416: ret z if (((u8Flags & 0x40) >> 6) == 1) { goto returnInstruction; } // 1417: ld a, (4da3h) Z80A = (UINT8) (mem[0x4da3]); // 141a: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 141b: call z, 20d1h if (((u8Flags & 0x40) >> 6) == 1) { Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x14; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x1e; goto L20d1; } L141e: // 141e: ret goto returnInstruction; // 141f: ld a, (cabtype) L141f: Z80A = (UINT8) (mem[0x4e72]); // 1422: ld b, a Z80B = (UINT8) (Z80A); // 1423: ld a, (4e09h) Z80A = (UINT8) (mem[0x4e09]); // 1426: and a, b Z80A = (UINT8) (Z80A & Z80B); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1427: ret z if (((u8Flags & 0x40) >> 6) == 1) { goto returnInstruction; } // 1428: ld b, a Z80B = (UINT8) (Z80A); // 1429: ld ix, 4c00h Z80IX = (UINT16) (0x4c00); // 142d: ld e, 08h Z80E = (UINT8) (0x08); // 142f: ld c, 08h Z80C = (UINT8) (0x08); // 1431: ld d, 07h Z80D = (UINT8) (0x07); // 1433: ld a, (4d00h) // this looks to be some kind of data? it's ver repetitions till 1500 Z80A = (UINT8) (mem[0x4d00]); { UINT16 u16Temp0; // 1436: add a, e u16Temp0 = Z80A + Z80E; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80E))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80E ^ Z80A ^ 0x80) & (Z80E ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 1437: ld (ix+13h), a mspacmanIndirectWrite8(Z80IX + 0x13, Z80A); // 143a: ld a, (4d01h) Z80A = (UINT8) (mem[0x4d01]); // 143d: cpl Z80A = (UINT8) (Z80A ^ 0xff); u8Flags |= 0x10; u8Flags |= 0x02; { UINT16 u16Temp0; // 143e: add a, d u16Temp0 = Z80A + Z80D; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80D))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80D ^ Z80A ^ 0x80) & (Z80D ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 143f: ld (ix+12h), a mspacmanIndirectWrite8(Z80IX + 0x12, Z80A); // 1442: ld a, (4d02h) Z80A = (UINT8) (mem[0x4d02]); { UINT16 u16Temp0; // 1445: add a, e u16Temp0 = Z80A + Z80E; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80E))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80E ^ Z80A ^ 0x80) & (Z80E ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 1446: ld (ix+15h), a mspacmanIndirectWrite8(Z80IX + 0x15, Z80A); // 1449: ld a, (4d03h) Z80A = (UINT8) (mem[0x4d03]); // 144c: cpl Z80A = (UINT8) (Z80A ^ 0xff); u8Flags |= 0x10; u8Flags |= 0x02; { UINT16 u16Temp0; // 144d: add a, d u16Temp0 = Z80A + Z80D; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80D))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80D ^ Z80A ^ 0x80) & (Z80D ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 144e: ld (ix+14h), a mspacmanIndirectWrite8(Z80IX + 0x14, Z80A); // 1451: ld a, (4d04h) Z80A = (UINT8) (mem[0x4d04]); { UINT16 u16Temp0; // 1454: add a, e u16Temp0 = Z80A + Z80E; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80E))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80E ^ Z80A ^ 0x80) & (Z80E ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 1455: ld (ix+17h), a mspacmanIndirectWrite8(Z80IX + 0x17, Z80A); // 1458: ld a, (4d05h) Z80A = (UINT8) (mem[0x4d05]); // 145b: cpl Z80A = (UINT8) (Z80A ^ 0xff); u8Flags |= 0x10; u8Flags |= 0x02; { UINT16 u16Temp0; // 145c: add a, c u16Temp0 = Z80A + Z80C; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80C))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80C ^ Z80A ^ 0x80) & (Z80C ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 145d: ld (ix+16h), a mspacmanIndirectWrite8(Z80IX + 0x16, Z80A); // 1460: ld a, (4d06h) Z80A = (UINT8) (mem[0x4d06]); { UINT16 u16Temp0; // 1463: add a, e u16Temp0 = Z80A + Z80E; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80E))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80E ^ Z80A ^ 0x80) & (Z80E ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 1464: ld (ix+19h), a mspacmanIndirectWrite8(Z80IX + 0x19, Z80A); // 1467: ld a, (4d07h) Z80A = (UINT8) (mem[0x4d07]); // 146a: cpl Z80A = (UINT8) (Z80A ^ 0xff); u8Flags |= 0x10; u8Flags |= 0x02; { UINT16 u16Temp0; // 146b: add a, c u16Temp0 = Z80A + Z80C; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80C))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80C ^ Z80A ^ 0x80) & (Z80C ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 146c: ld (ix+18h), a mspacmanIndirectWrite8(Z80IX + 0x18, Z80A); // 146f: ld a, (4d08h) Z80A = (UINT8) (mem[0x4d08]); { UINT16 u16Temp0; // 1472: add a, e u16Temp0 = Z80A + Z80E; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80E))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80E ^ Z80A ^ 0x80) & (Z80E ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 1473: ld (ix+1bh), a mspacmanIndirectWrite8(Z80IX + 0x1b, Z80A); // 1476: ld a, (4d09h) Z80A = (UINT8) (mem[0x4d09]); // 1479: cpl Z80A = (UINT8) (Z80A ^ 0xff); u8Flags |= 0x10; u8Flags |= 0x02; { UINT16 u16Temp0; // 147a: add a, c u16Temp0 = Z80A + Z80C; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80C))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80C ^ Z80A ^ 0x80) & (Z80C ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 147b: ld (ix+1ah), a mspacmanIndirectWrite8(Z80IX + 0x1a, Z80A); // 147e: ld a, (4dd2h) Z80A = (UINT8) (mem[0x4dd2]); { UINT16 u16Temp0; // 1481: add a, e u16Temp0 = Z80A + Z80E; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80E))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80E ^ Z80A ^ 0x80) & (Z80E ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 1482: ld (ix+1dh), a mspacmanIndirectWrite8(Z80IX + 0x1d, Z80A); // 1485: ld a, (4dd3h) Z80A = (UINT8) (mem[0x4dd3]); // 1488: cpl Z80A = (UINT8) (Z80A ^ 0xff); u8Flags |= 0x10; u8Flags |= 0x02; { UINT16 u16Temp0; // 1489: add a, c u16Temp0 = Z80A + Z80C; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80C))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80C ^ Z80A ^ 0x80) & (Z80C ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 148a: ld (ix+1ch), a mspacmanIndirectWrite8(Z80IX + 0x1c, Z80A); // 148d: jp 14feh goto L14fe; // 1490: ld a, (cabtype) // display the sprites in the intro and game L1490: Z80A = (UINT8) (mem[0x4e72]); // 1493: ld b, a Z80B = (UINT8) (Z80A); // 1494: ld a, (4e09h) Z80A = (UINT8) (mem[0x4e09]); // 1497: and a, b Z80A = (UINT8) (Z80A & Z80B); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1498: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 1499: ld b, a Z80B = (UINT8) (Z80A); // 149a: ld e, 09h Z80E = (UINT8) (0x09); // 149c: ld c, 07h Z80C = (UINT8) (0x07); // 149e: ld d, 06h Z80D = (UINT8) (0x06); // 14a0: ld ix, 4c00h Z80IX = (UINT16) (0x4c00); // 14a4: ld a, (4d00h) Z80A = (UINT8) (mem[0x4d00]); // 14a7: cpl Z80A = (UINT8) (Z80A ^ 0xff); u8Flags |= 0x10; u8Flags |= 0x02; { UINT16 u16Temp0; // 14a8: add a, e u16Temp0 = Z80A + Z80E; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80E))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80E ^ Z80A ^ 0x80) & (Z80E ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 14a9: ld (ix+13h), a mspacmanIndirectWrite8(Z80IX + 0x13, Z80A); // 14ac: ld a, (4d01h) Z80A = (UINT8) (mem[0x4d01]); { UINT16 u16Temp0; // 14af: add a, d u16Temp0 = Z80A + Z80D; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80D))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80D ^ Z80A ^ 0x80) & (Z80D ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 14b0: ld (ix+12h), a mspacmanIndirectWrite8(Z80IX + 0x12, Z80A); // 14b3: ld a, (4d02h) Z80A = (UINT8) (mem[0x4d02]); // 14b6: cpl Z80A = (UINT8) (Z80A ^ 0xff); u8Flags |= 0x10; u8Flags |= 0x02; { UINT16 u16Temp0; // 14b7: add a, e u16Temp0 = Z80A + Z80E; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80E))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80E ^ Z80A ^ 0x80) & (Z80E ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 14b8: ld (ix+15h), a mspacmanIndirectWrite8(Z80IX + 0x15, Z80A); // 14bb: ld a, (4d03h) Z80A = (UINT8) (mem[0x4d03]); { UINT16 u16Temp0; // 14be: add a, d u16Temp0 = Z80A + Z80D; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80D))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80D ^ Z80A ^ 0x80) & (Z80D ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 14bf: ld (ix+14h), a mspacmanIndirectWrite8(Z80IX + 0x14, Z80A); // 14c2: ld a, (4d04h) Z80A = (UINT8) (mem[0x4d04]); // 14c5: cpl Z80A = (UINT8) (Z80A ^ 0xff); u8Flags |= 0x10; u8Flags |= 0x02; { UINT16 u16Temp0; // 14c6: add a, e u16Temp0 = Z80A + Z80E; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80E))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80E ^ Z80A ^ 0x80) & (Z80E ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 14c7: ld (ix+17h), a mspacmanIndirectWrite8(Z80IX + 0x17, Z80A); // 14ca: ld a, (4d05h) Z80A = (UINT8) (mem[0x4d05]); { UINT16 u16Temp0; // 14cd: add a, c u16Temp0 = Z80A + Z80C; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80C))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80C ^ Z80A ^ 0x80) & (Z80C ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 14ce: ld (ix+16h), a mspacmanIndirectWrite8(Z80IX + 0x16, Z80A); // 14d1: ld a, (4d06h) Z80A = (UINT8) (mem[0x4d06]); // 14d4: cpl Z80A = (UINT8) (Z80A ^ 0xff); u8Flags |= 0x10; u8Flags |= 0x02; { UINT16 u16Temp0; // 14d5: add a, e u16Temp0 = Z80A + Z80E; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80E))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80E ^ Z80A ^ 0x80) & (Z80E ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 14d6: ld (ix+19h), a mspacmanIndirectWrite8(Z80IX + 0x19, Z80A); // 14d9: ld a, (4d07h) Z80A = (UINT8) (mem[0x4d07]); { UINT16 u16Temp0; // 14dc: add a, c u16Temp0 = Z80A + Z80C; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80C))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80C ^ Z80A ^ 0x80) & (Z80C ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 14dd: ld (ix+18h), a mspacmanIndirectWrite8(Z80IX + 0x18, Z80A); // 14e0: ld a, (4d08h) Z80A = (UINT8) (mem[0x4d08]); // 14e3: cpl Z80A = (UINT8) (Z80A ^ 0xff); u8Flags |= 0x10; u8Flags |= 0x02; { UINT16 u16Temp0; // 14e4: add a, e u16Temp0 = Z80A + Z80E; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80E))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80E ^ Z80A ^ 0x80) & (Z80E ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 14e5: ld (ix+1bh), a mspacmanIndirectWrite8(Z80IX + 0x1b, Z80A); // 14e8: ld a, (4d09h) Z80A = (UINT8) (mem[0x4d09]); { UINT16 u16Temp0; // 14eb: add a, c u16Temp0 = Z80A + Z80C; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80C))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80C ^ Z80A ^ 0x80) & (Z80C ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 14ec: ld (ix+1ah), a mspacmanIndirectWrite8(Z80IX + 0x1a, Z80A); // 14ef: ld a, (4dd2h) Z80A = (UINT8) (mem[0x4dd2]); // 14f2: cpl Z80A = (UINT8) (Z80A ^ 0xff); u8Flags |= 0x10; u8Flags |= 0x02; { UINT16 u16Temp0; // 14f3: add a, e u16Temp0 = Z80A + Z80E; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80E))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80E ^ Z80A ^ 0x80) & (Z80E ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 14f4: ld (ix+1dh), a mspacmanIndirectWrite8(Z80IX + 0x1d, Z80A); // 14f7: ld a, (4dd3h) Z80A = (UINT8) (mem[0x4dd3]); { UINT16 u16Temp0; // 14fa: add a, c u16Temp0 = Z80A + Z80C; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80C))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80C ^ Z80A ^ 0x80) & (Z80C ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 14fb: ld (ix+1ch), a mspacmanIndirectWrite8(Z80IX + 0x1c, Z80A); // 14fe: ld a, (4da5h) L14fe: Z80A = (UINT8) (mem[0x4da5]); // 1501: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1502: jp nz, 154bh if (((u8Flags & 0x40) >> 6) != 1) { goto L154b; } // 1505: ld a, (4da4h) Z80A = (UINT8) (mem[0x4da4]); // 1508: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1509: jp nz, 15b4h if (((u8Flags & 0x40) >> 6) != 1) { goto L15b4; } // 150c: ld hl, 151ch Z80HL = (UINT16) (0x151c); // 150f: push hl Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80H; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80L; // 1510: ld a, (4d30h) Z80A = (UINT8) (mem[0x4d30]); // 1513: rst 20h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x15; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x14; goto L0020; L151c: // 151c: ld a, b Z80A = (UINT8) (Z80B); // 151d: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 151e: jr z, 0154bh if (((u8Flags & 0x40) >> 6) == 1) { goto L154b; } // 1520: ld c, 0c0h Z80C = (UINT8) (0xc0); // 1522: ld a, (4c0ah) ; mspac sprite number Z80A = (UINT8) (mem[0x4c0a]); // 1525: ld d, a Z80D = (UINT8) (Z80A); // 1526: and a, c Z80A = (UINT8) (Z80A & Z80C); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1527: jr nz, 0152eh if (((u8Flags & 0x40) >> 6) != 1) { goto L152e; } // 1529: ld a, d Z80A = (UINT8) (Z80D); // 152a: or a, c Z80A = (UINT8) (Z80A | Z80C); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 152b: jp 1548h goto L1548; // 152e: ld a, (4d30h) L152e: Z80A = (UINT8) (mem[0x4d30]); { UINT16 u16Temp0; // 1531: cp a, 02h u16Temp0 = Z80A - 0x02; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x02))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x02 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 1533: jr nz, 0153eh if (((u8Flags & 0x40) >> 6) != 1) { goto L153e; } // 1535: bit 7, d u8Flags = (u8Flags & ~0x40) | ((((Z80D & 0x80) == 0)) ? 0x40 : 0); u8Flags |= 0x10; u8Flags &= 0xfd; // 1537: jr z, 0154bh if (((u8Flags & 0x40) >> 6) == 1) { goto L154b; } // 1539: ld a, d Z80A = (UINT8) (Z80D); // 153a: xor a, c Z80A = (UINT8) (Z80A ^ Z80C); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 153b: jp 1548h goto L1548; { UINT16 u16Temp0; // 153e: cp a, 03h L153e: u16Temp0 = Z80A - 0x03; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x03))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x03 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 1540: jr nz, 0154bh if (((u8Flags & 0x40) >> 6) != 1) { goto L154b; } // 1542: bit 6, d u8Flags = (u8Flags & ~0x40) | ((((Z80D & 0x40) == 0)) ? 0x40 : 0); u8Flags |= 0x10; u8Flags &= 0xfd; // 1544: jr z, 0154bh if (((u8Flags & 0x40) >> 6) == 1) { goto L154b; } // 1546: ld a, d Z80A = (UINT8) (Z80D); // 1547: xor a, c Z80A = (UINT8) (Z80A ^ Z80C); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1548: ld (4c0ah), a ; mspac sprite number L1548: mem[0x4c0a] = Z80A; // 154b: ld hl, 4dc0h L154b: Z80HL = (UINT16) (0x4dc0); // 154e: ld d, (hl) Z80D = (UINT8) (mem[Z80HL]); // 154f: ld a, 1ch Z80A = (UINT8) (0x1c); { UINT16 u16Temp0; // 1551: add a, d u16Temp0 = Z80A + Z80D; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80D))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80D ^ Z80A ^ 0x80) & (Z80D ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 1552: ld (ix+02h), a mspacmanIndirectWrite8(Z80IX + 0x02, Z80A); // 1555: ld (ix+04h), a mspacmanIndirectWrite8(Z80IX + 0x04, Z80A); // 1558: ld (ix+06h), a mspacmanIndirectWrite8(Z80IX + 0x06, Z80A); // 155b: ld (ix+08h), a mspacmanIndirectWrite8(Z80IX + 0x08, Z80A); // 155e: ld c, 20h Z80C = (UINT8) (0x20); // 1560: ld a, (4dach) Z80A = (UINT8) (mem[0x4dac]); // 1563: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1564: jr nz, 0156ch if (((u8Flags & 0x40) >> 6) != 1) { goto L156c; } // 1566: ld a, (4da7h) Z80A = (UINT8) (mem[0x4da7]); // 1569: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 156a: jr nz, 01575h if (((u8Flags & 0x40) >> 6) != 1) { goto L1575; } // 156c: ld a, (4d2ch) L156c: Z80A = (UINT8) (mem[0x4d2c]); { UINT16 u16Temp0; // 156f: add a, a u16Temp0 = Z80A + Z80A; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80A))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80A ^ Z80A ^ 0x80) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } { UINT16 u16Temp0; // 1570: add a, d u16Temp0 = Z80A + Z80D; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80D))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80D ^ Z80A ^ 0x80) & (Z80D ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } { UINT16 u16Temp0; // 1571: add a, c u16Temp0 = Z80A + Z80C; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80C))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80C ^ Z80A ^ 0x80) & (Z80C ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 1572: ld (ix+02h), a mspacmanIndirectWrite8(Z80IX + 0x02, Z80A); // 1575: ld a, (4dadh) L1575: Z80A = (UINT8) (mem[0x4dad]); // 1578: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1579: jr nz, 01581h if (((u8Flags & 0x40) >> 6) != 1) { goto L1581; } // 157b: ld a, (4da8h) Z80A = (UINT8) (mem[0x4da8]); // 157e: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 157f: jr nz, 0158ah if (((u8Flags & 0x40) >> 6) != 1) { goto L158a; } // 1581: ld a, (4d2dh) L1581: Z80A = (UINT8) (mem[0x4d2d]); { UINT16 u16Temp0; // 1584: add a, a u16Temp0 = Z80A + Z80A; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80A))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80A ^ Z80A ^ 0x80) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } { UINT16 u16Temp0; // 1585: add a, d u16Temp0 = Z80A + Z80D; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80D))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80D ^ Z80A ^ 0x80) & (Z80D ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } { UINT16 u16Temp0; // 1586: add a, c u16Temp0 = Z80A + Z80C; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80C))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80C ^ Z80A ^ 0x80) & (Z80C ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 1587: ld (ix+04h), a mspacmanIndirectWrite8(Z80IX + 0x04, Z80A); // 158a: ld a, (4daeh) L158a: Z80A = (UINT8) (mem[0x4dae]); // 158d: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 158e: jr nz, 01596h if (((u8Flags & 0x40) >> 6) != 1) { goto L1596; } // 1590: ld a, (4da9h) Z80A = (UINT8) (mem[0x4da9]); // 1593: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1594: jr nz, 0159fh if (((u8Flags & 0x40) >> 6) != 1) { goto L159f; } // 1596: ld a, (4d2eh) L1596: Z80A = (UINT8) (mem[0x4d2e]); { UINT16 u16Temp0; // 1599: add a, a u16Temp0 = Z80A + Z80A; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80A))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80A ^ Z80A ^ 0x80) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } { UINT16 u16Temp0; // 159a: add a, d u16Temp0 = Z80A + Z80D; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80D))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80D ^ Z80A ^ 0x80) & (Z80D ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } { UINT16 u16Temp0; // 159b: add a, c u16Temp0 = Z80A + Z80C; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80C))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80C ^ Z80A ^ 0x80) & (Z80C ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 159c: ld (ix+06h), a mspacmanIndirectWrite8(Z80IX + 0x06, Z80A); // 159f: ld a, (4dafh) L159f: Z80A = (UINT8) (mem[0x4daf]); // 15a2: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 15a3: jr nz, 015abh if (((u8Flags & 0x40) >> 6) != 1) { goto L15ab; } // 15a5: ld a, (4daah) Z80A = (UINT8) (mem[0x4daa]); // 15a8: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 15a9: jr nz, 015b4h if (((u8Flags & 0x40) >> 6) != 1) { goto L15b4; } // 15ab: ld a, (4d2fh) L15ab: Z80A = (UINT8) (mem[0x4d2f]); { UINT16 u16Temp0; // 15ae: add a, a u16Temp0 = Z80A + Z80A; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80A))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80A ^ Z80A ^ 0x80) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } { UINT16 u16Temp0; // 15af: add a, d u16Temp0 = Z80A + Z80D; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80D))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80D ^ Z80A ^ 0x80) & (Z80D ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } { UINT16 u16Temp0; // 15b0: add a, c u16Temp0 = Z80A + Z80C; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80C))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80C ^ Z80A ^ 0x80) & (Z80C ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 15b1: ld (ix+08h), a mspacmanIndirectWrite8(Z80IX + 0x08, Z80A); // 15b4: call 15e6h L15b4: Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x15; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xb7; goto L15e6; L15b7: // 15b7: call 162dh Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x15; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xba; goto L162d; L15ba: // 15ba: call 1652h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x15; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xbd; goto L1652; L15bd: // 15bd: ld a, b Z80A = (UINT8) (Z80B); // 15be: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 15bf: ret z if (((u8Flags & 0x40) >> 6) == 1) { goto returnInstruction; } // 15c0: ld c, 0c0h Z80C = (UINT8) (0xc0); // 15c2: ld a, (4c02h) Z80A = (UINT8) (mem[0x4c02]); // 15c5: or a, c Z80A = (UINT8) (Z80A | Z80C); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 15c6: ld (4c02h), a mem[0x4c02] = Z80A; // 15c9: ld a, (4c04h) Z80A = (UINT8) (mem[0x4c04]); // 15cc: or a, c Z80A = (UINT8) (Z80A | Z80C); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 15cd: ld (4c04h), a mem[0x4c04] = Z80A; // 15d0: ld a, (4c06h) Z80A = (UINT8) (mem[0x4c06]); // 15d3: or a, c Z80A = (UINT8) (Z80A | Z80C); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 15d4: ld (4c06h), a mem[0x4c06] = Z80A; // 15d7: ld a, (4c08h) Z80A = (UINT8) (mem[0x4c08]); // 15da: or a, c Z80A = (UINT8) (Z80A | Z80C); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 15db: ld (4c08h), a mem[0x4c08] = Z80A; // 15de: ld a, (frshape) Z80A = (UINT8) (mem[0x4c0c]); // 15e1: or a, c Z80A = (UINT8) (Z80A | Z80C); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 15e2: ld (frshape), a mem[0x4c0c] = Z80A; // 15e5: ret goto returnInstruction; // 15e6: ld a, (4e06h) L15e6: Z80A = (UINT8) (mem[0x4e06]); { UINT16 u16Temp0; // 15e9: sub a, 05h u16Temp0 = Z80A - 0x05; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x05))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x05 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 15eb: ret c if (((u8Flags & 0x01) >> 0) == 1) { goto returnInstruction; } // 15ec: ld a, (4d09h) Z80A = (UINT8) (mem[0x4d09]); // 15ef: and a, 0fh Z80A = (UINT8) (Z80A & 0x0f); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); { UINT16 u16Temp0; // 15f1: cp a, 0ch u16Temp0 = Z80A - 0x0c; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x0c))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x0c ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 15f3: jr c, 015f9h if (((u8Flags & 0x01) >> 0) == 1) { goto L15f9; } // 15f5: ld d, 18h Z80D = (UINT8) (0x18); // 15f7: jr 0160bh goto L160b; { UINT16 u16Temp0; // 15f9: cp a, 08h L15f9: u16Temp0 = Z80A - 0x08; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x08))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x08 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 15fb: jr c, 01601h if (((u8Flags & 0x01) >> 0) == 1) { goto L1601; } // 15fd: ld d, 14h Z80D = (UINT8) (0x14); // 15ff: jr 0160bh goto L160b; { UINT16 u16Temp0; // 1601: cp a, 04h L1601: u16Temp0 = Z80A - 0x04; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x04))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x04 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 1603: jr c, 01609h if (((u8Flags & 0x01) >> 0) == 1) { goto L1609; } // 1605: ld d, 10h Z80D = (UINT8) (0x10); // 1607: jr 0160bh goto L160b; // 1609: ld d, 14h L1609: Z80D = (UINT8) (0x14); // 160b: ld (ix+04h), d L160b: mspacmanIndirectWrite8(Z80IX + 0x04, Z80D); // 160e: inc d Z80D = (UINT8) (Z80D + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80D == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80D & 0x80) ? 0x80 : 0); if ((Z80D & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80D == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 160f: ld (ix+06h), d mspacmanIndirectWrite8(Z80IX + 0x06, Z80D); // 1612: inc d Z80D = (UINT8) (Z80D + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80D == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80D & 0x80) ? 0x80 : 0); if ((Z80D & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80D == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 1613: ld (ix+08h), d mspacmanIndirectWrite8(Z80IX + 0x08, Z80D); // 1616: inc d Z80D = (UINT8) (Z80D + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80D == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80D & 0x80) ? 0x80 : 0); if ((Z80D & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80D == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 1617: ld (ix+0ch), d mspacmanIndirectWrite8(Z80IX + 0x0c, Z80D); // 161a: ld (ix+0ah), 3fh mspacmanIndirectWrite8(Z80IX + 0x0a, 0x3f); // 161e: ld d, 16h Z80D = (UINT8) (0x16); // 1620: ld (ix+05h), d mspacmanIndirectWrite8(Z80IX + 0x05, Z80D); // 1623: ld (ix+07h), d mspacmanIndirectWrite8(Z80IX + 0x07, Z80D); // 1626: ld (ix+09h), d mspacmanIndirectWrite8(Z80IX + 0x09, Z80D); // 1629: ld (ix+0dh), d mspacmanIndirectWrite8(Z80IX + 0x0d, Z80D); // 162c: ret goto returnInstruction; // 162d: ld a, (4e07h) L162d: Z80A = (UINT8) (mem[0x4e07]); // 1630: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1631: ret z if (((u8Flags & 0x40) >> 6) == 1) { goto returnInstruction; } // 1632: ld d, a // check for pac moving though the other tunnel? Z80D = (UINT8) (Z80A); // 1633: ld a, (4d3ah) Z80A = (UINT8) (mem[0x4d3a]); { UINT16 u16Temp0; // 1636: sub a, 3dh u16Temp0 = Z80A - 0x3d; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x3d))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x3d ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 1638: jr nz, 0163eh if (((u8Flags & 0x40) >> 6) != 1) { goto L163e; } // 163a: ld (ix+0bh), 00h mspacmanIndirectWrite8(Z80IX + 0x0b, 0); // 163e: ld a, d L163e: Z80A = (UINT8) (Z80D); { UINT16 u16Temp0; // 163f: cp a, 0ah u16Temp0 = Z80A - 0x0a; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x0a))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x0a ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 1641: ret c if (((u8Flags & 0x01) >> 0) == 1) { goto returnInstruction; } // 1642: ld (ix+02h), 32h mspacmanIndirectWrite8(Z80IX + 0x02, 0x32); // 1646: ld (ix+03h), 1dh mspacmanIndirectWrite8(Z80IX + 0x03, 0x1d); { UINT16 u16Temp0; // 164a: cp a, 0ch u16Temp0 = Z80A - 0x0c; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x0c))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x0c ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 164c: ret c if (((u8Flags & 0x01) >> 0) == 1) { goto returnInstruction; } // 164d: ld (ix+02h), 33h mspacmanIndirectWrite8(Z80IX + 0x02, 0x33); // 1651: ret goto returnInstruction; // 1652: ld a, (4e08h) ; partial difficulty? L1652: Z80A = (UINT8) (mem[0x4e08]); // 1655: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1656: ret z if (((u8Flags & 0x40) >> 6) == 1) { goto returnInstruction; } // 1657: ld d, a Z80D = (UINT8) (Z80A); // 1658: ld a, (4d3ah) Z80A = (UINT8) (mem[0x4d3a]); { UINT16 u16Temp0; // 165b: sub a, 3dh u16Temp0 = Z80A - 0x3d; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x3d))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x3d ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 165d: jr nz, 01663h if (((u8Flags & 0x40) >> 6) != 1) { goto L1663; } // 165f: ld (ix+0bh), 00h mspacmanIndirectWrite8(Z80IX + 0x0b, 0); // 1663: ld a, d L1663: Z80A = (UINT8) (Z80D); { UINT16 u16Temp0; // 1664: cp a, 01h u16Temp0 = Z80A - 1; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 1))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((1 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 1666: ret c if (((u8Flags & 0x01) >> 0) == 1) { goto returnInstruction; } // 1667: ld a, (4dc0h) Z80A = (UINT8) (mem[0x4dc0]); // 166a: ld e, 08h Z80E = (UINT8) (0x08); { UINT16 u16Temp0; // 166c: add a, e u16Temp0 = Z80A + Z80E; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80E))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80E ^ Z80A ^ 0x80) & (Z80E ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 166d: ld (ix+02h), a mspacmanIndirectWrite8(Z80IX + 0x02, Z80A); // 1670: ld a, d Z80A = (UINT8) (Z80D); { UINT16 u16Temp0; // 1671: cp a, 03h u16Temp0 = Z80A - 0x03; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x03))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x03 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 1673: ret c if (((u8Flags & 0x01) >> 0) == 1) { goto returnInstruction; } // 1674: ld a, (4d01h) Z80A = (UINT8) (mem[0x4d01]); // 1677: and a, 08h Z80A = (UINT8) (Z80A & 0x08); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1679: rrca u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (((Z80A >> 1) | (Z80A << 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 167a: rrca u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (((Z80A >> 1) | (Z80A << 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 167b: rrca u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (((Z80A >> 1) | (Z80A << 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 167c: ld e, 0ah Z80E = (UINT8) (0x0a); { UINT16 u16Temp0; // 167e: add a, e u16Temp0 = Z80A + Z80E; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80E))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80E ^ Z80A ^ 0x80) & (Z80E ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 167f: ld (ix+0ch), a mspacmanIndirectWrite8(Z80IX + 0x0c, Z80A); // 1682: inc a Z80A = (UINT8) (Z80A + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); if ((Z80A & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80A == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 1683: inc a Z80A = (UINT8) (Z80A + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); if ((Z80A & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80A == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 1684: ld (ix+02h), a mspacmanIndirectWrite8(Z80IX + 0x02, Z80A); // 1687: ld (ix+0dh), 1eh mspacmanIndirectWrite8(Z80IX + 0x0d, 0x1e); // 168b: ret goto returnInstruction; L168c: // 168c: jp 869ch goto L869c; L168f: // 168f: ret goto returnInstruction; L1690: // 1690: rlca u8Flags = (u8Flags & ~0x01) | ((Z80A & 0x80) ? 0x01 : 0); Z80A = (UINT8) (((Z80A << 1) | (Z80A >> 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; { UINT16 u16Temp0; // 1691: cp a, 06h u16Temp0 = Z80A - 0x06; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x06))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x06 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 1693: jr c, 0169ah if (((u8Flags & 0x01) >> 0) == 1) { goto L169a; } // 1695: ld (ix+0ah), 30h mspacmanIndirectWrite8(Z80IX + 0x0a, 0x30); // 1699: ret goto returnInstruction; { UINT16 u16Temp0; // 169a: cp a, 04h L169a: u16Temp0 = Z80A - 0x04; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x04))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x04 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 169c: jr c, 016a3h if (((u8Flags & 0x01) >> 0) == 1) { goto L16a3; } // 169e: ld (ix+0ah), 2eh mspacmanIndirectWrite8(Z80IX + 0x0a, 0x2e); // 16a2: ret goto returnInstruction; { UINT16 u16Temp0; // 16a3: cp a, 02h L16a3: u16Temp0 = Z80A - 0x02; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x02))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x02 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 16a5: jr c, 016ach if (((u8Flags & 0x01) >> 0) == 1) { goto L16ac; } // 16a7: ld (ix+0ah), 2ch mspacmanIndirectWrite8(Z80IX + 0x0a, 0x2c); // 16ab: ret goto returnInstruction; // 16ac: ld (ix+0ah), 2eh L16ac: mspacmanIndirectWrite8(Z80IX + 0x0a, 0x2e); // 16b0: ret goto returnInstruction; L16b1: // 16b1: jp 86b1h goto L86b1; L16b4: // 16b4: ret goto returnInstruction; L16b5: // 16b5: rlca u8Flags = (u8Flags & ~0x01) | ((Z80A & 0x80) ? 0x01 : 0); Z80A = (UINT8) (((Z80A << 1) | (Z80A >> 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; { UINT16 u16Temp0; // 16b6: cp a, 06h u16Temp0 = Z80A - 0x06; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x06))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x06 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 16b8: jr c, 016bfh if (((u8Flags & 0x01) >> 0) == 1) { goto L16bf; } L16ba: // 16ba: ld (ix+0ah), 2fh mspacmanIndirectWrite8(Z80IX + 0x0a, 0x2f); // 16be: ret goto returnInstruction; L16bf: { UINT16 u16Temp0; // 16bf: cp a, 04h u16Temp0 = Z80A - 0x04; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x04))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x04 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 16c1: jr c, 016c8h if (((u8Flags & 0x01) >> 0) == 1) { goto L16c8; } // 16c3: ld (ix+0ah), 2dh mspacmanIndirectWrite8(Z80IX + 0x0a, 0x2d); // 16c7: ret goto returnInstruction; { UINT16 u16Temp0; // 16c8: cp a, 02h L16c8: u16Temp0 = Z80A - 0x02; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x02))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x02 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 16ca: jr c, 016d1h if (((u8Flags & 0x01) >> 0) == 1) { goto L16d1; } // 16cc: ld (ix+0ah), 2fh mspacmanIndirectWrite8(Z80IX + 0x0a, 0x2f); // 16d0: ret goto returnInstruction; // 16d1: ld (ix+0ah), 30h L16d1: mspacmanIndirectWrite8(Z80IX + 0x0a, 0x30); // 16d5: ret goto returnInstruction; L16d6: // 16d6: ld a, (4d09h) Z80A = (UINT8) (mem[0x4d09]); // 16d9: jp 86c5h goto L86c5; L16dc: // 16dc: ret goto returnInstruction; L16dd: // 16dd: jr c, 016e7h if (((u8Flags & 0x01) >> 0) == 1) { goto L16e7; } // 16df: ld e, 2eh L16df: Z80E = (UINT8) (0x2e); // 16e1: set 7, e L16e1: Z80E = (UINT8) (Z80E | 0x80); // 16e3: ld (ix+0ah), e mspacmanIndirectWrite8(Z80IX + 0x0a, Z80E); // 16e6: ret goto returnInstruction; { UINT16 u16Temp0; // 16e7: cp a, 04h L16e7: u16Temp0 = Z80A - 0x04; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x04))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x04 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 16e9: jr c, 016efh if (((u8Flags & 0x01) >> 0) == 1) { goto L16ef; } // 16eb: ld e, 2ch Z80E = (UINT8) (0x2c); // 16ed: jr 016e1h goto L16e1; { UINT16 u16Temp0; // 16ef: cp a, 02h L16ef: u16Temp0 = Z80A - 0x02; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x02))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x02 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 16f1: jr nc, 016dfh if (((u8Flags & 0x01) >> 0) != 1) { goto L16df; } // 16f3: ld e, 30h Z80E = (UINT8) (0x30); // 16f5: jr 016e1h goto L16e1; L16f7: // 16f7: ld a, (4d08h) Z80A = (UINT8) (mem[0x4d08]); // 16fa: jp 86d9h goto L86d9; L16fd: // 16fd: ret goto returnInstruction; L16fe: // 16fe: jr c, 01705h if (((u8Flags & 0x01) >> 0) == 1) { goto L1705; } L1700: // 1700: ld (ix+0ah), 30h mspacmanIndirectWrite8(Z80IX + 0x0a, 0x30); // 1704: ret goto returnInstruction; L1705: { UINT16 u16Temp0; // 1705: cp a, 04h u16Temp0 = Z80A - 0x04; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x04))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x04 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 1707: jr c, 01711h if (((u8Flags & 0x01) >> 0) == 1) { goto L1711; } // 1709: ld e, 2fh Z80E = (UINT8) (0x2f); // 170b: set 6, e L170b: Z80E = (UINT8) (Z80E | 0x40); // 170d: ld (ix+0ah), e mspacmanIndirectWrite8(Z80IX + 0x0a, Z80E); // 1710: ret goto returnInstruction; L1711: { UINT16 u16Temp0; // 1711: cp a, 02h u16Temp0 = Z80A - 0x02; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x02))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x02 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 1713: jr c, 01719h if (((u8Flags & 0x01) >> 0) == 1) { goto L1719; } // 1715: ld e, 2dh Z80E = (UINT8) (0x2d); // 1717: jr 0170bh goto L170b; // 1719: ld e, 2fh L1719: Z80E = (UINT8) (0x2f); // 171b: jr 0170bh goto L170b; // 171d: ld b, 04h // normal ghost collision detect L171d: Z80B = (UINT8) (0x04); // 171f: ld de, (4d39h) Z80E = (UINT8) (mem[0x4d39]); Z80D = (UINT8) (mem[0x4d3a]); // 1723: ld a, (4dafh) Z80A = (UINT8) (mem[0x4daf]); // 1726: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1727: jr nz, 01732h if (((u8Flags & 0x40) >> 6) != 1) { goto L1732; } // 1729: ld hl, (4d37h) Z80L = (UINT8) (mem[0x4d37]); Z80H = (UINT8) (mem[0x4d38]); // 172c: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); { UINT32 u32Temp0; // 172d: sbc hl, de u32Temp0 = (Z80HL - Z80DE - ((u8Flags & 0x01) >> 0)); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80DE) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | (((((Z80DE ^ Z80HL) & (Z80HL ^ u32Temp0) & 0x8000))) ? 0x04 : 0); Z80HL = (UINT16) (u32Temp0); u8Flags = (u8Flags & ~0x40) | ((Z80HL == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80HL & 0x8000) ? 0x80 : 0); u8Flags |= 0x02; } // 172f: jp z, 1763h ; check for collision with ghost if (((u8Flags & 0x40) >> 6) == 1) { goto L1763; } // 1732: dec b L1732: Z80B = (UINT8) (Z80B - 1); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((Z80B == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80B & 0x80) ? 0x80 : 0); if ((Z80B & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80B == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 1733: ld a, (4daeh) Z80A = (UINT8) (mem[0x4dae]); // 1736: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1737: jr nz, 01742h if (((u8Flags & 0x40) >> 6) != 1) { goto L1742; } // 1739: ld hl, (4d35h) Z80L = (UINT8) (mem[0x4d35]); Z80H = (UINT8) (mem[0x4d36]); // 173c: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); { UINT32 u32Temp0; // 173d: sbc hl, de u32Temp0 = (Z80HL - Z80DE - ((u8Flags & 0x01) >> 0)); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80DE) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | (((((Z80DE ^ Z80HL) & (Z80HL ^ u32Temp0) & 0x8000))) ? 0x04 : 0); Z80HL = (UINT16) (u32Temp0); u8Flags = (u8Flags & ~0x40) | ((Z80HL == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80HL & 0x8000) ? 0x80 : 0); u8Flags |= 0x02; } // 173f: jp z, 1763h if (((u8Flags & 0x40) >> 6) == 1) { goto L1763; } // 1742: dec b L1742: Z80B = (UINT8) (Z80B - 1); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((Z80B == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80B & 0x80) ? 0x80 : 0); if ((Z80B & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80B == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 1743: ld a, (4dadh) Z80A = (UINT8) (mem[0x4dad]); // 1746: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1747: jr nz, 01752h if (((u8Flags & 0x40) >> 6) != 1) { goto L1752; } // 1749: ld hl, (4d33h) Z80L = (UINT8) (mem[0x4d33]); Z80H = (UINT8) (mem[0x4d34]); // 174c: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); { UINT32 u32Temp0; // 174d: sbc hl, de u32Temp0 = (Z80HL - Z80DE - ((u8Flags & 0x01) >> 0)); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80DE) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | (((((Z80DE ^ Z80HL) & (Z80HL ^ u32Temp0) & 0x8000))) ? 0x04 : 0); Z80HL = (UINT16) (u32Temp0); u8Flags = (u8Flags & ~0x40) | ((Z80HL == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80HL & 0x8000) ? 0x80 : 0); u8Flags |= 0x02; } // 174f: jp z, 1763h if (((u8Flags & 0x40) >> 6) == 1) { goto L1763; } // 1752: dec b L1752: Z80B = (UINT8) (Z80B - 1); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((Z80B == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80B & 0x80) ? 0x80 : 0); if ((Z80B & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80B == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 1753: ld a, (4dach) Z80A = (UINT8) (mem[0x4dac]); // 1756: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1757: jr nz, 01762h if (((u8Flags & 0x40) >> 6) != 1) { goto L1762; } // 1759: ld hl, (4d31h) Z80L = (UINT8) (mem[0x4d31]); Z80H = (UINT8) (mem[0x4d32]); // 175c: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); { UINT32 u32Temp0; // 175d: sbc hl, de u32Temp0 = (Z80HL - Z80DE - ((u8Flags & 0x01) >> 0)); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80DE) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | (((((Z80DE ^ Z80HL) & (Z80HL ^ u32Temp0) & 0x8000))) ? 0x04 : 0); Z80HL = (UINT16) (u32Temp0); u8Flags = (u8Flags & ~0x40) | ((Z80HL == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80HL & 0x8000) ? 0x80 : 0); u8Flags |= 0x02; } // 175f: jp z, 1763h if (((u8Flags & 0x40) >> 6) == 1) { goto L1763; } // 1762: dec b L1762: Z80B = (UINT8) (Z80B - 1); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((Z80B == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80B & 0x80) ? 0x80 : 0); if ((Z80B & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80B == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 1763: ld a, b ; collision detection routine L1763: Z80A = (UINT8) (Z80B); // 1764: ld (4da4h), a mem[0x4da4] = Z80A; // 1767: ld (4da5h), a // invincibility check ; HACK3 mem[0x4da5] = Z80A; // 176a: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 176b: ret z if (((u8Flags & 0x40) >> 6) == 1) { goto returnInstruction; } // 176c: ld hl, 4da6h ; check Z80HL = (UINT16) (0x4da6); // 176f: ld e, a Z80E = (UINT8) (Z80A); // 1770: ld d, 00h Z80D = (UINT8) (0); { UINT32 u32Temp0; // 1772: add hl, de u32Temp0 = Z80HL + Z80DE; u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80DE) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 1773: ld a, (hl) Z80A = (UINT8) (mem[Z80HL]); // 1774: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1775: ret z if (((u8Flags & 0x40) >> 6) == 1) { goto returnInstruction; } // 1776: xor a, a Z80A = (UINT8) (0); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1777: ld (4da5h), a mem[0x4da5] = Z80A; // 177a: ld hl, 4dd0h Z80HL = (UINT16) (0x4dd0); { UINT8 u8Temp0; // 177d: inc (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 177e: ld b, (hl) Z80B = (UINT8) (mem[Z80HL]); // 177f: inc b Z80B = (UINT8) (Z80B + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80B == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80B & 0x80) ? 0x80 : 0); if ((Z80B & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80B == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 1780: call 2a5ah Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x17; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x83; goto L2a5a; L1783: // 1783: ld hl, 4ebch Z80HL = (UINT16) (0x4ebc); // 1786: set 3, (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] | 0x08); // 1788: ret goto returnInstruction; // 1789: ld a, (4da4h) // end normal ghost collision detect // blue ghost collision detect L1789: Z80A = (UINT8) (mem[0x4da4]); // 178c: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 178d: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 178e: ld a, (4da6h) Z80A = (UINT8) (mem[0x4da6]); // 1791: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1792: ret z if (((u8Flags & 0x40) >> 6) == 1) { goto returnInstruction; } // 1793: ld c, 04h Z80C = (UINT8) (0x04); // 1795: ld b, 04h Z80B = (UINT8) (0x04); // 1797: ld ix, 4d08h Z80IX = (UINT16) (0x4d08); // 179b: ld a, (4dafh) Z80A = (UINT8) (mem[0x4daf]); // 179e: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 179f: jr nz, 017b4h if (((u8Flags & 0x40) >> 6) != 1) { goto L17b4; } // 17a1: ld a, (4d06h) Z80A = (UINT8) (mem[0x4d06]); { UINT16 u16Temp0; // 17a4: sub a, (ix+00h) u16Temp0 = Z80A - mem[Z80IX]; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ mem[Z80IX]))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((mem[Z80IX] ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } { UINT16 u16Temp0; // 17a7: cp a, c u16Temp0 = Z80A - Z80C; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80C))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80C ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 17a8: jr nc, 017b4h if (((u8Flags & 0x01) >> 0) != 1) { goto L17b4; } // 17aa: ld a, (4d07h) Z80A = (UINT8) (mem[0x4d07]); { UINT16 u16Temp0; // 17ad: sub a, (ix+01h) u16Temp0 = Z80A - mem[Z80IX + 1]; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ mem[Z80IX + 1]))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((mem[Z80IX + 1] ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } { UINT16 u16Temp0; // 17b0: cp a, c u16Temp0 = Z80A - Z80C; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80C))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80C ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 17b1: jp c, 1763h ; collision detection routine if (((u8Flags & 0x01) >> 0) == 1) { goto L1763; } // 17b4: dec b L17b4: Z80B = (UINT8) (Z80B - 1); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((Z80B == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80B & 0x80) ? 0x80 : 0); if ((Z80B & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80B == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 17b5: ld a, (4daeh) Z80A = (UINT8) (mem[0x4dae]); // 17b8: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 17b9: jr nz, 017ceh if (((u8Flags & 0x40) >> 6) != 1) { goto L17ce; } // 17bb: ld a, (4d04h) Z80A = (UINT8) (mem[0x4d04]); { UINT16 u16Temp0; // 17be: sub a, (ix+00h) u16Temp0 = Z80A - mem[Z80IX]; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ mem[Z80IX]))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((mem[Z80IX] ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } { UINT16 u16Temp0; // 17c1: cp a, c u16Temp0 = Z80A - Z80C; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80C))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80C ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 17c2: jr nc, 017ceh if (((u8Flags & 0x01) >> 0) != 1) { goto L17ce; } // 17c4: ld a, (4d05h) Z80A = (UINT8) (mem[0x4d05]); { UINT16 u16Temp0; // 17c7: sub a, (ix+01h) u16Temp0 = Z80A - mem[Z80IX + 1]; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ mem[Z80IX + 1]))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((mem[Z80IX + 1] ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } { UINT16 u16Temp0; // 17ca: cp a, c u16Temp0 = Z80A - Z80C; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80C))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80C ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 17cb: jp c, 1763h ; collision detection routine if (((u8Flags & 0x01) >> 0) == 1) { goto L1763; } // 17ce: dec b L17ce: Z80B = (UINT8) (Z80B - 1); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((Z80B == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80B & 0x80) ? 0x80 : 0); if ((Z80B & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80B == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 17cf: ld a, (4dadh) Z80A = (UINT8) (mem[0x4dad]); // 17d2: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 17d3: jr nz, 017e8h if (((u8Flags & 0x40) >> 6) != 1) { goto L17e8; } // 17d5: ld a, (4d02h) Z80A = (UINT8) (mem[0x4d02]); { UINT16 u16Temp0; // 17d8: sub a, (ix+00h) u16Temp0 = Z80A - mem[Z80IX]; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ mem[Z80IX]))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((mem[Z80IX] ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } { UINT16 u16Temp0; // 17db: cp a, c u16Temp0 = Z80A - Z80C; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80C))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80C ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 17dc: jr nc, 017e8h if (((u8Flags & 0x01) >> 0) != 1) { goto L17e8; } // 17de: ld a, (4d03h) Z80A = (UINT8) (mem[0x4d03]); { UINT16 u16Temp0; // 17e1: sub a, (ix+01h) u16Temp0 = Z80A - mem[Z80IX + 1]; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ mem[Z80IX + 1]))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((mem[Z80IX + 1] ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } { UINT16 u16Temp0; // 17e4: cp a, c u16Temp0 = Z80A - Z80C; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80C))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80C ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 17e5: jp c, 1763h ; check for collision with ghost if (((u8Flags & 0x01) >> 0) == 1) { goto L1763; } // 17e8: dec b L17e8: Z80B = (UINT8) (Z80B - 1); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((Z80B == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80B & 0x80) ? 0x80 : 0); if ((Z80B & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80B == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 17e9: ld a, (4dach) Z80A = (UINT8) (mem[0x4dac]); // 17ec: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 17ed: jr nz, 01802h if (((u8Flags & 0x40) >> 6) != 1) { goto L1802; } // 17ef: ld a, (4d00h) Z80A = (UINT8) (mem[0x4d00]); { UINT16 u16Temp0; // 17f2: sub a, (ix+00h) u16Temp0 = Z80A - mem[Z80IX]; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ mem[Z80IX]))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((mem[Z80IX] ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } { UINT16 u16Temp0; // 17f5: cp a, c u16Temp0 = Z80A - Z80C; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80C))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80C ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 17f6: jr nc, 01802h if (((u8Flags & 0x01) >> 0) != 1) { goto L1802; } // 17f8: ld a, (4d01h) Z80A = (UINT8) (mem[0x4d01]); { UINT16 u16Temp0; // 17fb: sub a, (ix+01h) u16Temp0 = Z80A - mem[Z80IX + 1]; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ mem[Z80IX + 1]))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((mem[Z80IX + 1] ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } { UINT16 u16Temp0; // 17fe: cp a, c u16Temp0 = Z80A - Z80C; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80C))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80C ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 17ff: jp c, 1763h ; check for collision with ghost if (((u8Flags & 0x01) >> 0) == 1) { goto L1763; } // 1802: dec b L1802: Z80B = (UINT8) (Z80B - 1); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((Z80B == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80B & 0x80) ? 0x80 : 0); if ((Z80B & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80B == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 1803: jp 1763h ; check for collision with ghost goto L1763; // 1806: ld hl, 4d9dh L1806: Z80HL = (UINT16) (0x4d9d); // 1809: ld a, 0ffh Z80A = (UINT8) (0xff); { UINT16 u16Temp0; UINT8 u8Temp0; // 180b: cp a, (hl) u8Temp0 = mem[Z80HL]; u16Temp0 = Z80A - u8Temp0; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ u8Temp0))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((u8Temp0 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 180c: jp z, 1811h // set 0xbe to 0x01 for fast cheat. ; HACK2 if (((u8Flags & 0x40) >> 6) == 1) { goto L1811; } { UINT8 u8Temp0; // 180f: dec (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] - 1); u8Temp0 = mem[Z80HL]; u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 1810: ret goto returnInstruction; // 1811: ld a, (4da6h) L1811: Z80A = (UINT8) (mem[0x4da6]); // 1814: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1815: jp z, 182fh if (((u8Flags & 0x40) >> 6) == 1) { goto L182f; } // 1818: ld hl, (4d4ch) Z80L = (UINT8) (mem[0x4d4c]); Z80H = (UINT8) (mem[0x4d4d]); { UINT32 u32Temp0; // 181b: add hl, hl u32Temp0 = Z80HL + Z80HL; u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80HL) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 181c: ld (4d4ch), hl mem[0x4d4c] = Z80L; mem[0x4d4d] = Z80H; // 181f: ld hl, (4d4ah) Z80L = (UINT8) (mem[0x4d4a]); Z80H = (UINT8) (mem[0x4d4b]); { UINT32 u32Temp0; // 1822: adc hl, hl u32Temp0 = (Z80HL + Z80HL + ((u8Flags & 0x01) >> 0)); u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80HL) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80HL ^ Z80HL ^ 0x8000) & (Z80HL ^ u32Temp0) & 0x8000)) ? 0x04 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80HL == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80HL & 0x8000) ? 0x80 : 0); } // 1824: ld (4d4ah), hl mem[0x4d4a] = Z80L; mem[0x4d4b] = Z80H; // 1827: ret nc if (((u8Flags & 0x01) >> 0) != 1) { goto returnInstruction; } // 1828: ld hl, 4d4ch Z80HL = (UINT16) (0x4d4c); { UINT8 u8Temp0; // 182b: inc (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 182c: jp 1843h goto L1843; // 182f: ld hl, (4d48h) L182f: Z80L = (UINT8) (mem[0x4d48]); Z80H = (UINT8) (mem[0x4d49]); { UINT32 u32Temp0; // 1832: add hl, hl u32Temp0 = Z80HL + Z80HL; u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80HL) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 1833: ld (4d48h), hl mem[0x4d48] = Z80L; mem[0x4d49] = Z80H; // 1836: ld hl, (4d46h) Z80L = (UINT8) (mem[0x4d46]); Z80H = (UINT8) (mem[0x4d47]); { UINT32 u32Temp0; // 1839: adc hl, hl u32Temp0 = (Z80HL + Z80HL + ((u8Flags & 0x01) >> 0)); u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80HL) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80HL ^ Z80HL ^ 0x8000) & (Z80HL ^ u32Temp0) & 0x8000)) ? 0x04 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80HL == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80HL & 0x8000) ? 0x80 : 0); } // 183b: ld (4d46h), hl mem[0x4d46] = Z80L; mem[0x4d47] = Z80H; // 183e: ret nc if (((u8Flags & 0x01) >> 0) != 1) { goto returnInstruction; } // 183f: ld hl, 4d48h Z80HL = (UINT16) (0x4d48); { UINT8 u8Temp0; // 1842: inc (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 1843: ld a, (peleatn) L1843: Z80A = (UINT8) (mem[0x4e0e]); // 1846: ld (4d9eh), a mem[0x4d9e] = Z80A; // 1849: ld a, (cabtype) Z80A = (UINT8) (mem[0x4e72]); // 184c: ld c, a Z80C = (UINT8) (Z80A); // 184d: ld a, (4e09h) Z80A = (UINT8) (mem[0x4e09]); // 1850: and a, c Z80A = (UINT8) (Z80A & Z80C); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1851: ld c, a Z80C = (UINT8) (Z80A); // 1852: ld hl, 4d3ah Z80HL = (UINT16) (0x4d3a); // 1855: ld a, (hl) Z80A = (UINT8) (mem[Z80HL]); // 1856: ld b, 21h Z80B = (UINT8) (0x21); { UINT16 u16Temp0; // 1858: sub a, b u16Temp0 = Z80A - Z80B; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80B))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80B ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 1859: jr c, 01864h if (((u8Flags & 0x01) >> 0) == 1) { goto L1864; } // 185b: ld a, (hl) Z80A = (UINT8) (mem[Z80HL]); // 185c: ld b, 3bh Z80B = (UINT8) (0x3b); { UINT16 u16Temp0; // 185e: sub a, b u16Temp0 = Z80A - Z80B; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80B))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80B ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 185f: jr nc, 01864h if (((u8Flags & 0x01) >> 0) != 1) { goto L1864; } // 1861: jp 18abh goto L18ab; // 1864: ld a, 01h L1864: Z80A = (UINT8) (1); // 1866: ld (4dbfh), a mem[0x4dbf] = Z80A; // 1869: ld a, (4e00h) Z80A = (UINT8) (mem[0x4e00]); { UINT16 u16Temp0; // 186c: cp a, 01h u16Temp0 = Z80A - 1; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 1))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((1 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 186e: jp z, 1a19h if (((u8Flags & 0x40) >> 6) == 1) { goto L1a19; } // 1871: ld a, (4e04h) Z80A = (UINT8) (mem[0x4e04]); { UINT16 u16Temp0; // 1874: cp a, 10h u16Temp0 = Z80A - 0x10; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x10))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x10 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 1876: jp nc, 1a19h if (((u8Flags & 0x01) >> 0) != 1) { goto L1a19; } // 1879: ld a, c Z80A = (UINT8) (Z80C); // 187a: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 187b: jr z, 01883h if (((u8Flags & 0x40) >> 6) == 1) { goto L1883; } // 187d: ld a, (V1Acc) ; check in1 (p2) // check player 1 or player 2 depending on who is playing Z80A = (UINT8) (mem[0x5040]); // 1880: jp 1886h goto L1886; // 1883: ld a, (IRQEn) ; check in0 (p1) L1883: Z80A = (UINT8) (mem[0x5000]); // 1886: bit 1, a ; left L1886: u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0x02) == 0)) ? 0x40 : 0); u8Flags |= 0x10; u8Flags &= 0xfd; // 1888: jp nz, 1899h if (((u8Flags & 0x40) >> 6) != 1) { goto L1899; } // 188b: ld hl, (3303h) Z80L = (UINT8) (0); Z80H = (UINT8) (1); // 188e: ld a, 02h Z80A = (UINT8) (0x02); // 1890: ld (4d30h), a mem[0x4d30] = Z80A; // 1893: ld (4d1ch), hl mem[0x4d1c] = Z80L; mem[0x4d1d] = Z80H; // 1896: jp 1950h goto L1950; // 1899: bit 2, a ; right L1899: u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0x04) == 0)) ? 0x40 : 0); u8Flags |= 0x10; u8Flags &= 0xfd; // 189b: jp nz, 1950h if (((u8Flags & 0x40) >> 6) != 1) { goto L1950; } // 189e: ld hl, (32ffh) Z80L = (UINT8) (0); Z80H = (UINT8) (0xff); // 18a1: xor a, a Z80A = (UINT8) (0); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 18a2: ld (4d30h), a mem[0x4d30] = Z80A; // 18a5: ld (4d1ch), hl mem[0x4d1c] = Z80L; mem[0x4d1d] = Z80H; // 18a8: jp 1950h goto L1950; // 18ab: ld a, (4e00h) L18ab: Z80A = (UINT8) (mem[0x4e00]); { UINT16 u16Temp0; // 18ae: cp a, 01h u16Temp0 = Z80A - 1; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 1))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((1 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 18b0: jp z, 1a19h if (((u8Flags & 0x40) >> 6) == 1) { goto L1a19; } // 18b3: ld a, (4e04h) Z80A = (UINT8) (mem[0x4e04]); { UINT16 u16Temp0; // 18b6: cp a, 10h u16Temp0 = Z80A - 0x10; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x10))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x10 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 18b8: jp nc, 1a19h if (((u8Flags & 0x01) >> 0) != 1) { goto L1a19; } // 18bb: ld a, c Z80A = (UINT8) (Z80C); // 18bc: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 18bd: jr z, 018c5h if (((u8Flags & 0x40) >> 6) == 1) { goto L18c5; } // 18bf: ld a, (V1Acc) ; check in1 // p2 movement check Z80A = (UINT8) (mem[0x5040]); // 18c2: jp 18c8h goto L18c8; // 18c5: ld a, (IRQEn) ; a = IN0 // p1 movement check L18c5: Z80A = (UINT8) (mem[0x5000]); // 18c8: bit 1, a ; left L18c8: u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0x02) == 0)) ? 0x40 : 0); u8Flags |= 0x10; u8Flags &= 0xfd; // 18ca: jp z, 1ac9h if (((u8Flags & 0x40) >> 6) == 1) { goto L1ac9; } // 18cd: bit 2, a ; right u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0x04) == 0)) ? 0x40 : 0); u8Flags |= 0x10; u8Flags &= 0xfd; // 18cf: jp z, 1ad9h if (((u8Flags & 0x40) >> 6) == 1) { goto L1ad9; } // 18d2: bit 0, a ; up u8Flags = (u8Flags & ~0x40) | ((((Z80A & 1) == 0)) ? 0x40 : 0); u8Flags |= 0x10; u8Flags &= 0xfd; // 18d4: jp z, 1ae8h if (((u8Flags & 0x40) >> 6) == 1) { goto L1ae8; } // 18d7: bit 3, a ; down u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0x08) == 0)) ? 0x40 : 0); u8Flags |= 0x10; u8Flags &= 0xfd; // 18d9: jp z, 1af8h if (((u8Flags & 0x40) >> 6) == 1) { goto L1af8; } // 18dc: ld hl, (4d1ch) // no movement Z80L = (UINT8) (mem[0x4d1c]); Z80H = (UINT8) (mem[0x4d1d]); // 18df: ld (4d26h), hl mem[0x4d26] = Z80L; mem[0x4d27] = Z80H; // 18e2: ld b, 01h Z80B = (UINT8) (1); // 18e4: ld ix, 4d26h // movement checks return to here L18e4: Z80IX = (UINT16) (0x4d26); // 18e8: ld iy, 4d39h Z80IY = (UINT16) (0x4d39); // 18ec: call 200fh Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x18; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xef; goto L200f; L18ef: // 18ef: and a, 0c0h Z80A = (UINT8) (Z80A & 0xc0); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); { UINT16 u16Temp0; // 18f1: sub a, 0c0h u16Temp0 = Z80A - 0xc0; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0xc0))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0xc0 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 18f3: jr nz, 01940h if (((u8Flags & 0x40) >> 6) != 1) { goto L1940; } // 18f5: dec b Z80B = (UINT8) (Z80B - 1); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((Z80B == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80B & 0x80) ? 0x80 : 0); if ((Z80B & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80B == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 18f6: jp nz, 1916h if (((u8Flags & 0x40) >> 6) != 1) { goto L1916; } // 18f9: ld a, (4d30h) Z80A = (UINT8) (mem[0x4d30]); // 18fc: rrca u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (((Z80A >> 1) | (Z80A << 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 18fd: jp c, 190bh if (((u8Flags & 0x01) >> 0) == 1) { goto L190b; } // 1900: ld a, (4d09h) Z80A = (UINT8) (mem[0x4d09]); // 1903: and a, 07h Z80A = (UINT8) (Z80A & 0x07); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); { UINT16 u16Temp0; // 1905: cp a, 04h u16Temp0 = Z80A - 0x04; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x04))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x04 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 1907: ret z if (((u8Flags & 0x40) >> 6) == 1) { goto returnInstruction; } // 1908: jp 1940h goto L1940; // 190b: ld a, (4d08h) L190b: Z80A = (UINT8) (mem[0x4d08]); // 190e: and a, 07h Z80A = (UINT8) (Z80A & 0x07); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); { UINT16 u16Temp0; // 1910: cp a, 04h u16Temp0 = Z80A - 0x04; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x04))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x04 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 1912: ret z if (((u8Flags & 0x40) >> 6) == 1) { goto returnInstruction; } // 1913: jp 1940h goto L1940; // 1916: ld ix, 4d1ch L1916: Z80IX = (UINT16) (0x4d1c); // 191a: call 200fh ; calls 2000 and 0065 Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x19; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x1d; goto L200f; L191d: // 191d: and a, 0c0h Z80A = (UINT8) (Z80A & 0xc0); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); { UINT16 u16Temp0; // 191f: sub a, 0c0h u16Temp0 = Z80A - 0xc0; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0xc0))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0xc0 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 1921: jr nz, 01950h if (((u8Flags & 0x40) >> 6) != 1) { goto L1950; } // 1923: ld a, (4d30h) Z80A = (UINT8) (mem[0x4d30]); // 1926: rrca u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (((Z80A >> 1) | (Z80A << 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 1927: jp c, 1935h if (((u8Flags & 0x01) >> 0) == 1) { goto L1935; } // 192a: ld a, (4d09h) Z80A = (UINT8) (mem[0x4d09]); // 192d: and a, 07h Z80A = (UINT8) (Z80A & 0x07); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); { UINT16 u16Temp0; // 192f: cp a, 04h u16Temp0 = Z80A - 0x04; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x04))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x04 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 1931: ret z if (((u8Flags & 0x40) >> 6) == 1) { goto returnInstruction; } // 1932: jp 1950h goto L1950; // 1935: ld a, (4d08h) L1935: Z80A = (UINT8) (mem[0x4d08]); // 1938: and a, 07h Z80A = (UINT8) (Z80A & 0x07); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); { UINT16 u16Temp0; // 193a: cp a, 04h u16Temp0 = Z80A - 0x04; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x04))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x04 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 193c: ret z if (((u8Flags & 0x40) >> 6) == 1) { goto returnInstruction; } // 193d: jp 1950h goto L1950; // 1940: ld hl, (4d26h) L1940: Z80L = (UINT8) (mem[0x4d26]); Z80H = (UINT8) (mem[0x4d27]); // 1943: ld (4d1ch), hl mem[0x4d1c] = Z80L; mem[0x4d1d] = Z80H; // 1946: dec b Z80B = (UINT8) (Z80B - 1); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((Z80B == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80B & 0x80) ? 0x80 : 0); if ((Z80B & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80B == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 1947: jp z, 1950h if (((u8Flags & 0x40) >> 6) == 1) { goto L1950; } // 194a: ld a, (4d3ch) Z80A = (UINT8) (mem[0x4d3c]); // 194d: ld (4d30h), a mem[0x4d30] = Z80A; // 1950: ld ix, 4d1ch L1950: Z80IX = (UINT16) (0x4d1c); // 1954: ld iy, 4d08h Z80IY = (UINT16) (0x4d08); // 1958: call 2000h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x19; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x5b; goto L2000; L195b: // 195b: ld a, (4d30h) Z80A = (UINT8) (mem[0x4d30]); // 195e: rrca u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (((Z80A >> 1) | (Z80A << 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 195f: jp c, 1975h if (((u8Flags & 0x01) >> 0) == 1) { goto L1975; } // 1962: ld a, l Z80A = (UINT8) (Z80L); // 1963: and a, 07h Z80A = (UINT8) (Z80A & 0x07); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); { UINT16 u16Temp0; // 1965: cp a, 04h u16Temp0 = Z80A - 0x04; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x04))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x04 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 1967: jp z, 1985h if (((u8Flags & 0x40) >> 6) == 1) { goto L1985; } // 196a: jp c, 1971h if (((u8Flags & 0x01) >> 0) == 1) { goto L1971; } // 196d: dec l Z80L = (UINT8) (Z80L - 1); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((Z80L == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80L & 0x80) ? 0x80 : 0); if ((Z80L & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80L == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 196e: jp 1985h goto L1985; // 1971: inc l L1971: Z80L = (UINT8) (Z80L + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80L == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80L & 0x80) ? 0x80 : 0); if ((Z80L & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80L == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 1972: jp 1985h goto L1985; // 1975: ld a, h L1975: Z80A = (UINT8) (Z80H); // 1976: and a, 07h Z80A = (UINT8) (Z80A & 0x07); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); { UINT16 u16Temp0; // 1978: cp a, 04h u16Temp0 = Z80A - 0x04; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x04))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x04 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 197a: jp z, 1985h if (((u8Flags & 0x40) >> 6) == 1) { goto L1985; } // 197d: jp c, 1984h if (((u8Flags & 0x01) >> 0) == 1) { goto L1984; } // 1980: dec h Z80H = (UINT8) (Z80H - 1); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((Z80H == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80H & 0x80) ? 0x80 : 0); if ((Z80H & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80H == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 1981: jp 1985h goto L1985; // 1984: inc h L1984: Z80H = (UINT8) (Z80H + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80H == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80H & 0x80) ? 0x80 : 0); if ((Z80H & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80H == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 1985: ld (4d08h), hl L1985: mem[0x4d08] = Z80L; mem[0x4d09] = Z80H; // 1988: call 2018h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x19; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x8b; goto L2018; L198b: // 198b: ld (4d39h), hl mem[0x4d39] = Z80L; mem[0x4d3a] = Z80H; // 198e: ld ix, 4dbfh Z80IX = (UINT16) (0x4dbf); // 1992: ld a, (ix+00h) Z80A = (UINT8) (mem[Z80IX]); // 1995: ld (ix+00h), 00h mspacmanIndirectWrite8(Z80IX, 0); // 1999: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 199a: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 199b: ld a, (4dd2h) Z80A = (UINT8) (mem[0x4dd2]); // 199e: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 199f: jr z, 019cdh if (((u8Flags & 0x40) >> 6) == 1) { goto L19cd; } // 19a1: ld a, (frbonus) Z80A = (UINT8) (mem[0x4dd4]); // 19a4: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 19a5: jr z, 019cdh if (((u8Flags & 0x40) >> 6) == 1) { goto L19cd; } // 19a7: ld hl, (4d08h) Z80L = (UINT8) (mem[0x4d08]); Z80H = (UINT8) (mem[0x4d09]); // 19aa: ld de, 8094h Z80DE = (UINT16) (0x8094); // 19ad: jp 8818h goto L8818; // 19b2: ld b, 19h L19b2: Z80B = (UINT8) (0x19); // 19b4: ld c, a Z80C = (UINT8) (Z80A); // 19b5: call 0042h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x19; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xb8; goto L0042; L19b8: // 19b8: call 1000h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x19; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xbb; goto L1000; L19bb: // 19bb: jr 019c4h goto L19c4; // 19c4: rst 30h L19c4: Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x19; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xc5; goto L0030; L19c8: // 19c8: ld hl, 4ebch Z80HL = (UINT16) (0x4ebc); // 19cb: set 2, (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] | 0x04); // 19cd: ld a, 0ffh L19cd: Z80A = (UINT8) (0xff); // 19cf: ld (4d9dh), a mem[0x4d9d] = Z80A; // 19d2: ld hl, (4d39h) Z80L = (UINT8) (mem[0x4d39]); Z80H = (UINT8) (mem[0x4d3a]); // 19d5: call 0065h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x19; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xd8; goto L0065; L19d8: // 19d8: ld a, (hl) Z80A = (UINT8) (mem[Z80HL]); { UINT16 u16Temp0; // 19d9: cp a, 10h u16Temp0 = Z80A - 0x10; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x10))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x10 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 19db: jr z, 019e0h if (((u8Flags & 0x40) >> 6) == 1) { goto L19e0; } { UINT16 u16Temp0; // 19dd: cp a, 14h u16Temp0 = Z80A - 0x14; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x14))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x14 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 19df: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 19e0: ld ix, peleatn L19e0: Z80IX = (UINT16) (0x4e0e); { UINT8 u8Temp0; // 19e4: inc (ix+00h) mspacmanIndirectWrite8(Z80IX, mem[Z80IX] + 1); u8Temp0 = mem[Z80IX]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 19e7: and a, 0fh Z80A = (UINT8) (Z80A & 0x0f); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 19e9: srl a u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (Z80A >> 1); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags &= 0xef; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 19eb: ld b, 40h Z80B = (UINT8) (0x40); // 19ed: ld (hl), b mspacmanIndirectWrite8(Z80HL, Z80B); // 19ee: ld b, 19h Z80B = (UINT8) (0x19); // 19f0: ld c, a Z80C = (UINT8) (Z80A); // 19f1: srl c u8Flags = (u8Flags & ~0x01) | ((Z80C & 1) ? 0x01 : 0); Z80C = (UINT8) (Z80C >> 1); u8Flags = (u8Flags & ~0x80) | ((Z80C & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x40) | ((Z80C == 0) ? 0x40 : 0); u8Flags &= 0xef; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x04) | (((((((Z80C >> 0x07) & 1) + ((Z80C >> 0x06) & 1) + ((Z80C >> 0x05) & 1) + ((Z80C >> 0x04) & 1) + ((Z80C >> 0x03) & 1) + ((Z80C >> 0x02) & 1) + ((Z80C >> 1) & 1) + ((Z80C >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 19f3: call 0042h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x19; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xf6; goto L0042; L19f6: // 19f6: inc a Z80A = (UINT8) (Z80A + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); if ((Z80A & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80A == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } { UINT16 u16Temp0; // 19f7: cp a, 01h u16Temp0 = Z80A - 1; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 1))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((1 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 19f9: jp z, 19fdh if (((u8Flags & 0x40) >> 6) == 1) { goto L19fd; } { UINT16 u16Temp0; // 19fc: add a, a u16Temp0 = Z80A + Z80A; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80A))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80A ^ Z80A ^ 0x80) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 19fd: ld (4d9dh), a L19fd: mem[0x4d9d] = Z80A; // 1a00: call 1b08h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x1a; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x03; goto L1b08; L1a03: // 1a03: call 1a6ah Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x1a; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x06; goto L1a6a; L1a06: // 1a06: ld hl, 4ebch Z80HL = (UINT16) (0x4ebc); // 1a09: ld a, (peleatn) Z80A = (UINT8) (mem[0x4e0e]); // 1a0c: rrca u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (((Z80A >> 1) | (Z80A << 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 1a0d: jr c, 01a14h if (((u8Flags & 0x01) >> 0) == 1) { goto L1a14; } // 1a0f: set 0, (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] | 1); // 1a11: res 1, (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] & 0xfd); // 1a13: ret goto returnInstruction; // 1a14: res 0, (hl) L1a14: mspacmanIndirectWrite8(Z80HL, mem[Z80HL] & 0xfe); // 1a16: set 1, (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] | 0x02); // 1a18: ret goto returnInstruction; // 1a19: ld hl, 4d1ch L1a19: Z80HL = (UINT16) (0x4d1c); // 1a1c: ld a, (hl) Z80A = (UINT8) (mem[Z80HL]); // 1a1d: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1a1e: jp z, 1a2eh if (((u8Flags & 0x40) >> 6) == 1) { goto L1a2e; } // 1a21: ld a, (4d08h) Z80A = (UINT8) (mem[0x4d08]); // 1a24: and a, 07h Z80A = (UINT8) (Z80A & 0x07); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); { UINT16 u16Temp0; // 1a26: cp a, 04h u16Temp0 = Z80A - 0x04; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x04))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x04 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 1a28: jp z, 1a38h if (((u8Flags & 0x40) >> 6) == 1) { goto L1a38; } // 1a2b: jp 1a5ch goto L1a5c; // 1a2e: ld a, (4d09h) L1a2e: Z80A = (UINT8) (mem[0x4d09]); // 1a31: and a, 07h Z80A = (UINT8) (Z80A & 0x07); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); { UINT16 u16Temp0; // 1a33: cp a, 04h u16Temp0 = Z80A - 0x04; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x04))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x04 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 1a35: jp nz, 1a5ch if (((u8Flags & 0x40) >> 6) != 1) { goto L1a5c; } // 1a38: ld a, 05h L1a38: Z80A = (UINT8) (0x05); // 1a3a: call 1ed0h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x1a; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x3d; goto L1ed0; L1a3d: // 1a3d: jr c, 01a42h if (((u8Flags & 0x01) >> 0) == 1) { goto L1a42; } // 1a3f: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x1a; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x40; goto L0028; // 1a42: ld ix, 4d26h L1a42: Z80IX = (UINT16) (0x4d26); // 1a46: ld iy, 4d12h Z80IY = (UINT16) (0x4d12); // 1a4a: call 2000h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x1a; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x4d; goto L2000; L1a4d: // 1a4d: ld (4d12h), hl mem[0x4d12] = Z80L; mem[0x4d13] = Z80H; // 1a50: ld hl, (4d26h) Z80L = (UINT8) (mem[0x4d26]); Z80H = (UINT8) (mem[0x4d27]); // 1a53: ld (4d1ch), hl mem[0x4d1c] = Z80L; mem[0x4d1d] = Z80H; // 1a56: ld a, (4d3ch) Z80A = (UINT8) (mem[0x4d3c]); // 1a59: ld (4d30h), a mem[0x4d30] = Z80A; // 1a5c: ld ix, 4d1ch L1a5c: Z80IX = (UINT16) (0x4d1c); // 1a60: ld iy, 4d08h Z80IY = (UINT16) (0x4d08); // 1a64: call 2000h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x1a; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x67; goto L2000; L1a67: // 1a67: jp 1985h goto L1985; // 1a6a: ld a, (4d9dh) L1a6a: Z80A = (UINT8) (mem[0x4d9d]); { UINT16 u16Temp0; // 1a6d: cp a, 06h u16Temp0 = Z80A - 0x06; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x06))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x06 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 1a6f: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 1a70: ld hl, (4dbdh) L1a70: Z80L = (UINT8) (mem[0x4dbd]); Z80H = (UINT8) (mem[0x4dbe]); // 1a73: ld (4dcbh), hl mem[0x4dcb] = Z80L; mem[0x4dcc] = Z80H; // 1a76: ld a, 01h Z80A = (UINT8) (1); // 1a78: ld (4da6h), a mem[0x4da6] = Z80A; // 1a7b: ld (4da7h), a mem[0x4da7] = Z80A; // 1a7e: ld (4da8h), a mem[0x4da8] = Z80A; // 1a81: ld (4da9h), a mem[0x4da9] = Z80A; // 1a84: ld (4daah), a mem[0x4daa] = Z80A; // 1a87: ld (4db1h), a mem[0x4db1] = Z80A; // 1a8a: ld (4db2h), a mem[0x4db2] = Z80A; // 1a8d: ld (4db3h), a mem[0x4db3] = Z80A; // 1a90: ld (4db4h), a mem[0x4db4] = Z80A; // 1a93: ld (4db5h), a mem[0x4db5] = Z80A; // 1a96: xor a, a Z80A = (UINT8) (0); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1a97: ld (4dc8h), a mem[0x4dc8] = Z80A; // 1a9a: ld (4dd0h), a mem[0x4dd0] = Z80A; // 1a9d: ld ix, 4c00h Z80IX = (UINT16) (0x4c00); // 1aa1: ld (ix+02h), 1ch mspacmanIndirectWrite8(Z80IX + 0x02, 0x1c); // 1aa5: ld (ix+04h), 1ch mspacmanIndirectWrite8(Z80IX + 0x04, 0x1c); // 1aa9: ld (ix+06h), 1ch mspacmanIndirectWrite8(Z80IX + 0x06, 0x1c); // 1aad: ld (ix+08h), 1ch mspacmanIndirectWrite8(Z80IX + 0x08, 0x1c); // 1ab1: ld (ix+03h), 11h mspacmanIndirectWrite8(Z80IX + 0x03, 0x11); // 1ab5: ld (ix+05h), 11h mspacmanIndirectWrite8(Z80IX + 0x05, 0x11); // 1ab9: ld (ix+07h), 11h mspacmanIndirectWrite8(Z80IX + 0x07, 0x11); // 1abd: ld (ix+09h), 11h mspacmanIndirectWrite8(Z80IX + 0x09, 0x11); // 1ac1: ld hl, 4each Z80HL = (UINT16) (0x4eac); // 1ac4: set 5, (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] | 0x20); // 1ac6: res 7, (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] & 0x7f); // 1ac8: ret goto returnInstruction; // 1ac9: ld hl, (3303h) // Player move Left L1ac9: Z80L = (UINT8) (0); Z80H = (UINT8) (1); // 1acc: ld a, 02h Z80A = (UINT8) (0x02); // 1ace: ld (4d3ch), a mem[0x4d3c] = Z80A; // 1ad1: ld (4d26h), hl mem[0x4d26] = Z80L; mem[0x4d27] = Z80H; // 1ad4: ld b, 00h Z80B = (UINT8) (0); // 1ad6: jp 18e4h goto L18e4; // 1ad9: ld hl, (32ffh) // player move Right L1ad9: Z80L = (UINT8) (0); Z80H = (UINT8) (0xff); // 1adc: xor a, a Z80A = (UINT8) (0); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1add: ld (4d3ch), a mem[0x4d3c] = Z80A; // 1ae0: ld (4d26h), hl mem[0x4d26] = Z80L; mem[0x4d27] = Z80H; // 1ae3: ld b, 00h Z80B = (UINT8) (0); // 1ae5: jp 18e4h goto L18e4; // 1ae8: ld hl, (3305h) // player move Up L1ae8: Z80L = (UINT8) (0xff); Z80H = (UINT8) (0); // 1aeb: ld a, 03h Z80A = (UINT8) (0x03); // 1aed: ld (4d3ch), a mem[0x4d3c] = Z80A; // 1af0: ld (4d26h), hl mem[0x4d26] = Z80L; mem[0x4d27] = Z80H; // 1af3: ld b, 00h Z80B = (UINT8) (0); // 1af5: jp 18e4h goto L18e4; // 1af8: ld hl, (3301h) // player move Down L1af8: Z80L = (UINT8) (1); Z80H = (UINT8) (0); // 1afb: ld a, 01h Z80A = (UINT8) (1); // 1afd: ld (4d3ch), a mem[0x4d3c] = Z80A; // 1b00: ld (4d26h), hl mem[0x4d26] = Z80L; mem[0x4d27] = Z80H; // 1b03: ld b, 00h Z80B = (UINT8) (0); // 1b05: jp 18e4h goto L18e4; // 1b08: ld a, (4e12h) L1b08: Z80A = (UINT8) (mem[0x4e12]); // 1b0b: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1b0c: jp z, 1b14h if (((u8Flags & 0x40) >> 6) == 1) { goto L1b14; } // 1b0f: ld hl, 4d9fh Z80HL = (UINT16) (0x4d9f); { UINT8 u8Temp0; // 1b12: inc (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 1b13: ret goto returnInstruction; // 1b14: ld a, (4da3h) L1b14: Z80A = (UINT8) (mem[0x4da3]); // 1b17: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1b18: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 1b19: ld a, (4da2h) Z80A = (UINT8) (mem[0x4da2]); // 1b1c: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1b1d: jp z, 1b25h if (((u8Flags & 0x40) >> 6) == 1) { goto L1b25; } // 1b20: ld hl, 4e11h Z80HL = (UINT16) (0x4e11); { UINT8 u8Temp0; // 1b23: inc (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 1b24: ret goto returnInstruction; // 1b25: ld a, (4da1h) L1b25: Z80A = (UINT8) (mem[0x4da1]); // 1b28: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1b29: jp z, 1b31h if (((u8Flags & 0x40) >> 6) == 1) { goto L1b31; } // 1b2c: ld hl, 4e10h Z80HL = (UINT16) (0x4e10); { UINT8 u8Temp0; // 1b2f: inc (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 1b30: ret goto returnInstruction; // 1b31: ld hl, 4e0fh L1b31: Z80HL = (UINT16) (0x4e0f); { UINT8 u8Temp0; // 1b34: inc (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 1b35: ret goto returnInstruction; // 1b36: ld a, (4da0h) L1b36: Z80A = (UINT8) (mem[0x4da0]); // 1b39: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1b3a: ret z if (((u8Flags & 0x40) >> 6) == 1) { goto returnInstruction; } // 1b3b: ld a, (4dach) Z80A = (UINT8) (mem[0x4dac]); // 1b3e: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1b3f: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 1b40: call 20d7h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x1b; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x43; goto L20d7; L1b43: // 1b43: ld hl, (4d31h) Z80L = (UINT8) (mem[0x4d31]); Z80H = (UINT8) (mem[0x4d32]); // 1b46: ld bc, 4d99h Z80BC = (UINT16) (0x4d99); // 1b49: call 205ah Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x1b; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x4c; goto L205a; L1b4c: // 1b4c: ld a, (4d99h) Z80A = (UINT8) (mem[0x4d99]); // 1b4f: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1b50: jp z, 1b6ah if (((u8Flags & 0x40) >> 6) == 1) { goto L1b6a; } // 1b53: ld hl, (4d60h) Z80L = (UINT8) (mem[0x4d60]); Z80H = (UINT8) (mem[0x4d61]); { UINT32 u32Temp0; // 1b56: add hl, hl u32Temp0 = Z80HL + Z80HL; u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80HL) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 1b57: ld (4d60h), hl mem[0x4d60] = Z80L; mem[0x4d61] = Z80H; // 1b5a: ld hl, (4d5eh) Z80L = (UINT8) (mem[0x4d5e]); Z80H = (UINT8) (mem[0x4d5f]); { UINT32 u32Temp0; // 1b5d: adc hl, hl u32Temp0 = (Z80HL + Z80HL + ((u8Flags & 0x01) >> 0)); u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80HL) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80HL ^ Z80HL ^ 0x8000) & (Z80HL ^ u32Temp0) & 0x8000)) ? 0x04 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80HL == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80HL & 0x8000) ? 0x80 : 0); } // 1b5f: ld (4d5eh), hl mem[0x4d5e] = Z80L; mem[0x4d5f] = Z80H; // 1b62: ret nc if (((u8Flags & 0x01) >> 0) != 1) { goto returnInstruction; } // 1b63: ld hl, 4d60h Z80HL = (UINT16) (0x4d60); { UINT8 u8Temp0; // 1b66: inc (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 1b67: jp 1bd8h goto L1bd8; // 1b6a: ld a, (4da7h) L1b6a: Z80A = (UINT8) (mem[0x4da7]); // 1b6d: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1b6e: jp z, 1b88h if (((u8Flags & 0x40) >> 6) == 1) { goto L1b88; } // 1b71: ld hl, (4d5ch) Z80L = (UINT8) (mem[0x4d5c]); Z80H = (UINT8) (mem[0x4d5d]); { UINT32 u32Temp0; // 1b74: add hl, hl u32Temp0 = Z80HL + Z80HL; u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80HL) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 1b75: ld (4d5ch), hl mem[0x4d5c] = Z80L; mem[0x4d5d] = Z80H; // 1b78: ld hl, (4d5ah) Z80L = (UINT8) (mem[0x4d5a]); Z80H = (UINT8) (mem[0x4d5b]); { UINT32 u32Temp0; // 1b7b: adc hl, hl u32Temp0 = (Z80HL + Z80HL + ((u8Flags & 0x01) >> 0)); u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80HL) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80HL ^ Z80HL ^ 0x8000) & (Z80HL ^ u32Temp0) & 0x8000)) ? 0x04 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80HL == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80HL & 0x8000) ? 0x80 : 0); } // 1b7d: ld (4d5ah), hl mem[0x4d5a] = Z80L; mem[0x4d5b] = Z80H; // 1b80: ret nc if (((u8Flags & 0x01) >> 0) != 1) { goto returnInstruction; } // 1b81: ld hl, 4d5ch Z80HL = (UINT16) (0x4d5c); { UINT8 u8Temp0; // 1b84: inc (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 1b85: jp 1bd8h goto L1bd8; // 1b88: ld a, (4db7h) L1b88: Z80A = (UINT8) (mem[0x4db7]); // 1b8b: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1b8c: jp z, 1ba6h if (((u8Flags & 0x40) >> 6) == 1) { goto L1ba6; } // 1b8f: ld hl, (4d50h) Z80L = (UINT8) (mem[0x4d50]); Z80H = (UINT8) (mem[0x4d51]); { UINT32 u32Temp0; // 1b92: add hl, hl u32Temp0 = Z80HL + Z80HL; u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80HL) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 1b93: ld (4d50h), hl mem[0x4d50] = Z80L; mem[0x4d51] = Z80H; // 1b96: ld hl, (4d4eh) Z80L = (UINT8) (mem[0x4d4e]); Z80H = (UINT8) (mem[0x4d4f]); { UINT32 u32Temp0; // 1b99: adc hl, hl u32Temp0 = (Z80HL + Z80HL + ((u8Flags & 0x01) >> 0)); u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80HL) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80HL ^ Z80HL ^ 0x8000) & (Z80HL ^ u32Temp0) & 0x8000)) ? 0x04 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80HL == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80HL & 0x8000) ? 0x80 : 0); } // 1b9b: ld (4d4eh), hl mem[0x4d4e] = Z80L; mem[0x4d4f] = Z80H; // 1b9e: ret nc if (((u8Flags & 0x01) >> 0) != 1) { goto returnInstruction; } // 1b9f: ld hl, 4d50h Z80HL = (UINT16) (0x4d50); { UINT8 u8Temp0; // 1ba2: inc (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 1ba3: jp 1bd8h goto L1bd8; // 1ba6: ld a, (4db6h) L1ba6: Z80A = (UINT8) (mem[0x4db6]); // 1ba9: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1baa: jp z, 1bc4h if (((u8Flags & 0x40) >> 6) == 1) { goto L1bc4; } // 1bad: ld hl, (4d54h) Z80L = (UINT8) (mem[0x4d54]); Z80H = (UINT8) (mem[0x4d55]); { UINT32 u32Temp0; // 1bb0: add hl, hl u32Temp0 = Z80HL + Z80HL; u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80HL) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 1bb1: ld (4d54h), hl mem[0x4d54] = Z80L; mem[0x4d55] = Z80H; // 1bb4: ld hl, (4d52h) Z80L = (UINT8) (mem[0x4d52]); Z80H = (UINT8) (mem[0x4d53]); { UINT32 u32Temp0; // 1bb7: adc hl, hl u32Temp0 = (Z80HL + Z80HL + ((u8Flags & 0x01) >> 0)); u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80HL) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80HL ^ Z80HL ^ 0x8000) & (Z80HL ^ u32Temp0) & 0x8000)) ? 0x04 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80HL == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80HL & 0x8000) ? 0x80 : 0); } // 1bb9: ld (4d52h), hl mem[0x4d52] = Z80L; mem[0x4d53] = Z80H; // 1bbc: ret nc if (((u8Flags & 0x01) >> 0) != 1) { goto returnInstruction; } // 1bbd: ld hl, 4d54h Z80HL = (UINT16) (0x4d54); { UINT8 u8Temp0; // 1bc0: inc (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 1bc1: jp 1bd8h goto L1bd8; // 1bc4: ld hl, (4d58h) L1bc4: Z80L = (UINT8) (mem[0x4d58]); Z80H = (UINT8) (mem[0x4d59]); { UINT32 u32Temp0; // 1bc7: add hl, hl u32Temp0 = Z80HL + Z80HL; u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80HL) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 1bc8: ld (4d58h), hl mem[0x4d58] = Z80L; mem[0x4d59] = Z80H; // 1bcb: ld hl, (4d56h) Z80L = (UINT8) (mem[0x4d56]); Z80H = (UINT8) (mem[0x4d57]); { UINT32 u32Temp0; // 1bce: adc hl, hl u32Temp0 = (Z80HL + Z80HL + ((u8Flags & 0x01) >> 0)); u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80HL) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80HL ^ Z80HL ^ 0x8000) & (Z80HL ^ u32Temp0) & 0x8000)) ? 0x04 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80HL == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80HL & 0x8000) ? 0x80 : 0); } // 1bd0: ld (4d56h), hl mem[0x4d56] = Z80L; mem[0x4d57] = Z80H; // 1bd3: ret nc if (((u8Flags & 0x01) >> 0) != 1) { goto returnInstruction; } // 1bd4: ld hl, 4d58h Z80HL = (UINT16) (0x4d58); { UINT8 u8Temp0; // 1bd7: inc (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 1bd8: ld hl, 4d14h L1bd8: Z80HL = (UINT16) (0x4d14); // 1bdb: ld a, (hl) Z80A = (UINT8) (mem[Z80HL]); // 1bdc: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1bdd: jp z, 1bedh if (((u8Flags & 0x40) >> 6) == 1) { goto L1bed; } // 1be0: ld a, (4d00h) Z80A = (UINT8) (mem[0x4d00]); // 1be3: and a, 07h Z80A = (UINT8) (Z80A & 0x07); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); { UINT16 u16Temp0; // 1be5: cp a, 04h u16Temp0 = Z80A - 0x04; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x04))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x04 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 1be7: jp z, 1bf7h if (((u8Flags & 0x40) >> 6) == 1) { goto L1bf7; } // 1bea: jp 1c36h goto L1c36; // 1bed: ld a, (4d01h) L1bed: Z80A = (UINT8) (mem[0x4d01]); // 1bf0: and a, 07h Z80A = (UINT8) (Z80A & 0x07); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); { UINT16 u16Temp0; // 1bf2: cp a, 04h u16Temp0 = Z80A - 0x04; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x04))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x04 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 1bf4: jp nz, 1c36h if (((u8Flags & 0x40) >> 6) != 1) { goto L1c36; } // 1bf7: ld a, 01h L1bf7: Z80A = (UINT8) (1); // 1bf9: call 1ed0h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x1b; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xfc; goto L1ed0; L1bfc: // 1bfc: jr c, 01c19h if (((u8Flags & 0x01) >> 0) == 1) { goto L1c19; } // 1bfe: ld a, (4da7h) Z80A = (UINT8) (mem[0x4da7]); // 1c01: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1c02: jp z, 1c0bh if (((u8Flags & 0x40) >> 6) == 1) { goto L1c0b; } // 1c05: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x1c; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x06; goto L0028; L1c08: // 1c08: jp 1c19h goto L1c19; // 1c0b: ld hl, (4d0ah) L1c0b: Z80L = (UINT8) (mem[0x4d0a]); Z80H = (UINT8) (mem[0x4d0b]); // 1c0e: call 2052h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x1c; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x11; goto L2052; L1c11: // 1c11: ld a, (hl) Z80A = (UINT8) (mem[Z80HL]); { UINT16 u16Temp0; // 1c12: cp a, 1ah u16Temp0 = Z80A - 0x1a; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x1a))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x1a ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 1c14: jr z, 01c19h if (((u8Flags & 0x40) >> 6) == 1) { goto L1c19; } // 1c16: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x1c; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x17; goto L0028; // 1c19: call 1efeh L1c19: Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x1c; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x1c; goto L1efe; L1c1c: // 1c1c: ld ix, 4d1eh Z80IX = (UINT16) (0x4d1e); // 1c20: ld iy, 4d0ah Z80IY = (UINT16) (0x4d0a); // 1c24: call 2000h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x1c; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x27; goto L2000; L1c27: // 1c27: ld (4d0ah), hl mem[0x4d0a] = Z80L; mem[0x4d0b] = Z80H; // 1c2a: ld hl, (4d1eh) Z80L = (UINT8) (mem[0x4d1e]); Z80H = (UINT8) (mem[0x4d1f]); // 1c2d: ld (4d14h), hl mem[0x4d14] = Z80L; mem[0x4d15] = Z80H; // 1c30: ld a, (4d2ch) Z80A = (UINT8) (mem[0x4d2c]); // 1c33: ld (4d28h), a mem[0x4d28] = Z80A; // 1c36: ld ix, 4d14h L1c36: Z80IX = (UINT16) (0x4d14); // 1c3a: ld iy, 4d00h Z80IY = (UINT16) (0x4d00); // 1c3e: call 2000h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x1c; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x41; goto L2000; L1c41: // 1c41: ld (4d00h), hl mem[0x4d00] = Z80L; mem[0x4d01] = Z80H; // 1c44: call 2018h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x1c; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x47; goto L2018; L1c47: // 1c47: ld (4d31h), hl mem[0x4d31] = Z80L; mem[0x4d32] = Z80H; // 1c4a: ret goto returnInstruction; // 1c4b: ld a, (4da1h) L1c4b: Z80A = (UINT8) (mem[0x4da1]); { UINT16 u16Temp0; // 1c4e: cp a, 01h u16Temp0 = Z80A - 1; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 1))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((1 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 1c50: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 1c51: ld a, (4dadh) Z80A = (UINT8) (mem[0x4dad]); // 1c54: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1c55: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 1c56: ld hl, (4d33h) Z80L = (UINT8) (mem[0x4d33]); Z80H = (UINT8) (mem[0x4d34]); // 1c59: ld bc, 4d9ah Z80BC = (UINT16) (0x4d9a); // 1c5c: call 205ah Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x1c; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x5f; goto L205a; L1c5f: // 1c5f: ld a, (4d9ah) Z80A = (UINT8) (mem[0x4d9a]); // 1c62: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1c63: jp z, 1c7dh if (((u8Flags & 0x40) >> 6) == 1) { goto L1c7d; } // 1c66: ld hl, (4d6ch) Z80L = (UINT8) (mem[0x4d6c]); Z80H = (UINT8) (mem[0x4d6d]); { UINT32 u32Temp0; // 1c69: add hl, hl u32Temp0 = Z80HL + Z80HL; u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80HL) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 1c6a: ld (4d6ch), hl mem[0x4d6c] = Z80L; mem[0x4d6d] = Z80H; // 1c6d: ld hl, (4d6ah) Z80L = (UINT8) (mem[0x4d6a]); Z80H = (UINT8) (mem[0x4d6b]); { UINT32 u32Temp0; // 1c70: adc hl, hl u32Temp0 = (Z80HL + Z80HL + ((u8Flags & 0x01) >> 0)); u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80HL) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80HL ^ Z80HL ^ 0x8000) & (Z80HL ^ u32Temp0) & 0x8000)) ? 0x04 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80HL == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80HL & 0x8000) ? 0x80 : 0); } // 1c72: ld (4d6ah), hl mem[0x4d6a] = Z80L; mem[0x4d6b] = Z80H; // 1c75: ret nc if (((u8Flags & 0x01) >> 0) != 1) { goto returnInstruction; } // 1c76: ld hl, 4d6ch Z80HL = (UINT16) (0x4d6c); { UINT8 u8Temp0; // 1c79: inc (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 1c7a: jp 1cafh goto L1caf; // 1c7d: ld a, (4da8h) L1c7d: Z80A = (UINT8) (mem[0x4da8]); // 1c80: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1c81: jp z, 1c9bh if (((u8Flags & 0x40) >> 6) == 1) { goto L1c9b; } // 1c84: ld hl, (4d68h) Z80L = (UINT8) (mem[0x4d68]); Z80H = (UINT8) (mem[0x4d69]); { UINT32 u32Temp0; // 1c87: add hl, hl u32Temp0 = Z80HL + Z80HL; u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80HL) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 1c88: ld (4d68h), hl mem[0x4d68] = Z80L; mem[0x4d69] = Z80H; // 1c8b: ld hl, (4d66h) Z80L = (UINT8) (mem[0x4d66]); Z80H = (UINT8) (mem[0x4d67]); { UINT32 u32Temp0; // 1c8e: adc hl, hl u32Temp0 = (Z80HL + Z80HL + ((u8Flags & 0x01) >> 0)); u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80HL) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80HL ^ Z80HL ^ 0x8000) & (Z80HL ^ u32Temp0) & 0x8000)) ? 0x04 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80HL == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80HL & 0x8000) ? 0x80 : 0); } // 1c90: ld (4d66h), hl mem[0x4d66] = Z80L; mem[0x4d67] = Z80H; // 1c93: ret nc if (((u8Flags & 0x01) >> 0) != 1) { goto returnInstruction; } // 1c94: ld hl, 4d68h Z80HL = (UINT16) (0x4d68); { UINT8 u8Temp0; // 1c97: inc (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 1c98: jp 1cafh goto L1caf; // 1c9b: ld hl, (4d64h) L1c9b: Z80L = (UINT8) (mem[0x4d64]); Z80H = (UINT8) (mem[0x4d65]); { UINT32 u32Temp0; // 1c9e: add hl, hl u32Temp0 = Z80HL + Z80HL; u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80HL) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 1c9f: ld (4d64h), hl mem[0x4d64] = Z80L; mem[0x4d65] = Z80H; // 1ca2: ld hl, (4d62h) Z80L = (UINT8) (mem[0x4d62]); Z80H = (UINT8) (mem[0x4d63]); { UINT32 u32Temp0; // 1ca5: adc hl, hl u32Temp0 = (Z80HL + Z80HL + ((u8Flags & 0x01) >> 0)); u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80HL) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80HL ^ Z80HL ^ 0x8000) & (Z80HL ^ u32Temp0) & 0x8000)) ? 0x04 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80HL == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80HL & 0x8000) ? 0x80 : 0); } // 1ca7: ld (4d62h), hl mem[0x4d62] = Z80L; mem[0x4d63] = Z80H; // 1caa: ret nc if (((u8Flags & 0x01) >> 0) != 1) { goto returnInstruction; } // 1cab: ld hl, 4d64h Z80HL = (UINT16) (0x4d64); { UINT8 u8Temp0; // 1cae: inc (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 1caf: ld hl, 4d16h L1caf: Z80HL = (UINT16) (0x4d16); // 1cb2: ld a, (hl) Z80A = (UINT8) (mem[Z80HL]); // 1cb3: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1cb4: jp z, 1cc4h if (((u8Flags & 0x40) >> 6) == 1) { goto L1cc4; } // 1cb7: ld a, (4d02h) Z80A = (UINT8) (mem[0x4d02]); // 1cba: and a, 07h Z80A = (UINT8) (Z80A & 0x07); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); { UINT16 u16Temp0; // 1cbc: cp a, 04h u16Temp0 = Z80A - 0x04; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x04))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x04 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 1cbe: jp z, 1cceh if (((u8Flags & 0x40) >> 6) == 1) { goto L1cce; } // 1cc1: jp 1d0dh goto L1d0d; // 1cc4: ld a, (4d03h) L1cc4: Z80A = (UINT8) (mem[0x4d03]); // 1cc7: and a, 07h Z80A = (UINT8) (Z80A & 0x07); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); { UINT16 u16Temp0; // 1cc9: cp a, 04h u16Temp0 = Z80A - 0x04; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x04))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x04 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 1ccb: jp nz, 1d0dh if (((u8Flags & 0x40) >> 6) != 1) { goto L1d0d; } // 1cce: ld a, 02h L1cce: Z80A = (UINT8) (0x02); // 1cd0: call 1ed0h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x1c; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xd3; goto L1ed0; L1cd3: // 1cd3: jr c, 01cf0h if (((u8Flags & 0x01) >> 0) == 1) { goto L1cf0; } // 1cd5: ld a, (4da8h) Z80A = (UINT8) (mem[0x4da8]); // 1cd8: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1cd9: jp z, 1ce2h if (((u8Flags & 0x40) >> 6) == 1) { goto L1ce2; } // 1cdc: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x1c; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xdd; goto L0028; L1cdf: // 1cdf: jp 1cf0h goto L1cf0; // 1ce2: ld hl, (4d0ch) L1ce2: Z80L = (UINT8) (mem[0x4d0c]); Z80H = (UINT8) (mem[0x4d0d]); // 1ce5: call 2052h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x1c; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xe8; goto L2052; L1ce8: // 1ce8: ld a, (hl) Z80A = (UINT8) (mem[Z80HL]); { UINT16 u16Temp0; // 1ce9: cp a, 1ah u16Temp0 = Z80A - 0x1a; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x1a))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x1a ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 1ceb: jr z, 01cf0h if (((u8Flags & 0x40) >> 6) == 1) { goto L1cf0; } // 1ced: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x1c; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xee; goto L0028; // 1cf0: call 1f25h L1cf0: Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x1c; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xf3; goto L1f25; L1cf3: // 1cf3: ld ix, 4d20h Z80IX = (UINT16) (0x4d20); // 1cf7: ld iy, 4d0ch Z80IY = (UINT16) (0x4d0c); // 1cfb: call 2000h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x1c; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xfe; goto L2000; L1cfe: // 1cfe: ld (4d0ch), hl mem[0x4d0c] = Z80L; mem[0x4d0d] = Z80H; // 1d01: ld hl, (4d20h) Z80L = (UINT8) (mem[0x4d20]); Z80H = (UINT8) (mem[0x4d21]); // 1d04: ld (4d16h), hl mem[0x4d16] = Z80L; mem[0x4d17] = Z80H; // 1d07: ld a, (4d2dh) Z80A = (UINT8) (mem[0x4d2d]); // 1d0a: ld (4d29h), a mem[0x4d29] = Z80A; // 1d0d: ld ix, 4d16h L1d0d: Z80IX = (UINT16) (0x4d16); // 1d11: ld iy, 4d02h Z80IY = (UINT16) (0x4d02); // 1d15: call 2000h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x1d; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x18; goto L2000; L1d18: // 1d18: ld (4d02h), hl mem[0x4d02] = Z80L; mem[0x4d03] = Z80H; // 1d1b: call 2018h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x1d; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x1e; goto L2018; L1d1e: // 1d1e: ld (4d33h), hl mem[0x4d33] = Z80L; mem[0x4d34] = Z80H; // 1d21: ret goto returnInstruction; // 1d22: ld a, (4da2h) L1d22: Z80A = (UINT8) (mem[0x4da2]); { UINT16 u16Temp0; // 1d25: cp a, 01h u16Temp0 = Z80A - 1; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 1))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((1 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 1d27: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 1d28: ld a, (4daeh) Z80A = (UINT8) (mem[0x4dae]); // 1d2b: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1d2c: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 1d2d: ld hl, (4d35h) Z80L = (UINT8) (mem[0x4d35]); Z80H = (UINT8) (mem[0x4d36]); // 1d30: ld bc, 4d9bh Z80BC = (UINT16) (0x4d9b); // 1d33: call 205ah Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x1d; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x36; goto L205a; L1d36: // 1d36: ld a, (4d9bh) Z80A = (UINT8) (mem[0x4d9b]); // 1d39: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1d3a: jp z, 1d54h if (((u8Flags & 0x40) >> 6) == 1) { goto L1d54; } // 1d3d: ld hl, (4d78h) Z80L = (UINT8) (mem[0x4d78]); Z80H = (UINT8) (mem[0x4d79]); { UINT32 u32Temp0; // 1d40: add hl, hl u32Temp0 = Z80HL + Z80HL; u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80HL) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 1d41: ld (4d78h), hl mem[0x4d78] = Z80L; mem[0x4d79] = Z80H; // 1d44: ld hl, (4d76h) Z80L = (UINT8) (mem[0x4d76]); Z80H = (UINT8) (mem[0x4d77]); { UINT32 u32Temp0; // 1d47: adc hl, hl u32Temp0 = (Z80HL + Z80HL + ((u8Flags & 0x01) >> 0)); u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80HL) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80HL ^ Z80HL ^ 0x8000) & (Z80HL ^ u32Temp0) & 0x8000)) ? 0x04 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80HL == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80HL & 0x8000) ? 0x80 : 0); } // 1d49: ld (4d76h), hl mem[0x4d76] = Z80L; mem[0x4d77] = Z80H; // 1d4c: ret nc if (((u8Flags & 0x01) >> 0) != 1) { goto returnInstruction; } // 1d4d: ld hl, 4d78h Z80HL = (UINT16) (0x4d78); { UINT8 u8Temp0; // 1d50: inc (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 1d51: jp 1d86h goto L1d86; // 1d54: ld a, (4da9h) L1d54: Z80A = (UINT8) (mem[0x4da9]); // 1d57: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1d58: jp z, 1d72h if (((u8Flags & 0x40) >> 6) == 1) { goto L1d72; } // 1d5b: ld hl, (4d74h) Z80L = (UINT8) (mem[0x4d74]); Z80H = (UINT8) (mem[0x4d75]); { UINT32 u32Temp0; // 1d5e: add hl, hl u32Temp0 = Z80HL + Z80HL; u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80HL) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 1d5f: ld (4d74h), hl mem[0x4d74] = Z80L; mem[0x4d75] = Z80H; // 1d62: ld hl, (4d72h) Z80L = (UINT8) (mem[0x4d72]); Z80H = (UINT8) (mem[0x4d73]); { UINT32 u32Temp0; // 1d65: adc hl, hl u32Temp0 = (Z80HL + Z80HL + ((u8Flags & 0x01) >> 0)); u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80HL) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80HL ^ Z80HL ^ 0x8000) & (Z80HL ^ u32Temp0) & 0x8000)) ? 0x04 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80HL == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80HL & 0x8000) ? 0x80 : 0); } // 1d67: ld (4d72h), hl mem[0x4d72] = Z80L; mem[0x4d73] = Z80H; // 1d6a: ret nc if (((u8Flags & 0x01) >> 0) != 1) { goto returnInstruction; } // 1d6b: ld hl, 4d74h Z80HL = (UINT16) (0x4d74); { UINT8 u8Temp0; // 1d6e: inc (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 1d6f: jp 1d86h goto L1d86; // 1d72: ld hl, (4d70h) L1d72: Z80L = (UINT8) (mem[0x4d70]); Z80H = (UINT8) (mem[0x4d71]); { UINT32 u32Temp0; // 1d75: add hl, hl u32Temp0 = Z80HL + Z80HL; u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80HL) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 1d76: ld (4d70h), hl mem[0x4d70] = Z80L; mem[0x4d71] = Z80H; // 1d79: ld hl, (4d6eh) Z80L = (UINT8) (mem[0x4d6e]); Z80H = (UINT8) (mem[0x4d6f]); { UINT32 u32Temp0; // 1d7c: adc hl, hl u32Temp0 = (Z80HL + Z80HL + ((u8Flags & 0x01) >> 0)); u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80HL) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80HL ^ Z80HL ^ 0x8000) & (Z80HL ^ u32Temp0) & 0x8000)) ? 0x04 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80HL == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80HL & 0x8000) ? 0x80 : 0); } // 1d7e: ld (4d6eh), hl mem[0x4d6e] = Z80L; mem[0x4d6f] = Z80H; // 1d81: ret nc if (((u8Flags & 0x01) >> 0) != 1) { goto returnInstruction; } // 1d82: ld hl, 4d70h Z80HL = (UINT16) (0x4d70); { UINT8 u8Temp0; // 1d85: inc (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 1d86: ld hl, 4d18h L1d86: Z80HL = (UINT16) (0x4d18); // 1d89: ld a, (hl) Z80A = (UINT8) (mem[Z80HL]); // 1d8a: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1d8b: jp z, 1d9bh if (((u8Flags & 0x40) >> 6) == 1) { goto L1d9b; } // 1d8e: ld a, (4d04h) Z80A = (UINT8) (mem[0x4d04]); // 1d91: and a, 07h Z80A = (UINT8) (Z80A & 0x07); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); { UINT16 u16Temp0; // 1d93: cp a, 04h u16Temp0 = Z80A - 0x04; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x04))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x04 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 1d95: jp z, 1da5h if (((u8Flags & 0x40) >> 6) == 1) { goto L1da5; } // 1d98: jp 1de4h goto L1de4; // 1d9b: ld a, (4d05h) L1d9b: Z80A = (UINT8) (mem[0x4d05]); // 1d9e: and a, 07h Z80A = (UINT8) (Z80A & 0x07); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); { UINT16 u16Temp0; // 1da0: cp a, 04h u16Temp0 = Z80A - 0x04; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x04))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x04 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 1da2: jp nz, 1de4h if (((u8Flags & 0x40) >> 6) != 1) { goto L1de4; } // 1da5: ld a, 03h L1da5: Z80A = (UINT8) (0x03); // 1da7: call 1ed0h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x1d; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xaa; goto L1ed0; L1daa: // 1daa: jr c, 01dc7h if (((u8Flags & 0x01) >> 0) == 1) { goto L1dc7; } // 1dac: ld a, (4da9h) Z80A = (UINT8) (mem[0x4da9]); // 1daf: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1db0: jp z, 1db9h if (((u8Flags & 0x40) >> 6) == 1) { goto L1db9; } // 1db3: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x1d; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xb4; goto L0028; L1db6: // 1db6: jp 1dc7h goto L1dc7; // 1db9: ld hl, (4d0eh) L1db9: Z80L = (UINT8) (mem[0x4d0e]); Z80H = (UINT8) (mem[0x4d0f]); // 1dbc: call 2052h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x1d; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xbf; goto L2052; L1dbf: // 1dbf: ld a, (hl) Z80A = (UINT8) (mem[Z80HL]); { UINT16 u16Temp0; // 1dc0: cp a, 1ah u16Temp0 = Z80A - 0x1a; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x1a))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x1a ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 1dc2: jr z, 01dc7h if (((u8Flags & 0x40) >> 6) == 1) { goto L1dc7; } // 1dc4: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x1d; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xc5; goto L0028; // 1dc7: call 1f4ch L1dc7: Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x1d; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xca; goto L1f4c; L1dca: // 1dca: ld ix, 4d22h Z80IX = (UINT16) (0x4d22); // 1dce: ld iy, 4d0eh Z80IY = (UINT16) (0x4d0e); // 1dd2: call 2000h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x1d; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xd5; goto L2000; L1dd5: // 1dd5: ld (4d0eh), hl mem[0x4d0e] = Z80L; mem[0x4d0f] = Z80H; // 1dd8: ld hl, (4d22h) Z80L = (UINT8) (mem[0x4d22]); Z80H = (UINT8) (mem[0x4d23]); // 1ddb: ld (4d18h), hl mem[0x4d18] = Z80L; mem[0x4d19] = Z80H; // 1dde: ld a, (4d2eh) Z80A = (UINT8) (mem[0x4d2e]); // 1de1: ld (4d2ah), a mem[0x4d2a] = Z80A; // 1de4: ld ix, 4d18h L1de4: Z80IX = (UINT16) (0x4d18); // 1de8: ld iy, 4d04h Z80IY = (UINT16) (0x4d04); // 1dec: call 2000h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x1d; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xef; goto L2000; L1def: // 1def: ld (4d04h), hl mem[0x4d04] = Z80L; mem[0x4d05] = Z80H; // 1df2: call 2018h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x1d; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xf5; goto L2018; L1df5: // 1df5: ld (4d35h), hl mem[0x4d35] = Z80L; mem[0x4d36] = Z80H; // 1df8: ret goto returnInstruction; // 1df9: ld a, (4da3h) L1df9: Z80A = (UINT8) (mem[0x4da3]); { UINT16 u16Temp0; // 1dfc: cp a, 01h u16Temp0 = Z80A - 1; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 1))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((1 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 1dfe: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 1dff: ld a, (4dafh) Z80A = (UINT8) (mem[0x4daf]); // 1e02: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1e03: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 1e04: ld hl, (4d37h) Z80L = (UINT8) (mem[0x4d37]); Z80H = (UINT8) (mem[0x4d38]); // 1e07: ld bc, 4d9ch Z80BC = (UINT16) (0x4d9c); // 1e0a: call 205ah Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x1e; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x0d; goto L205a; L1e0d: // 1e0d: ld a, (4d9ch) Z80A = (UINT8) (mem[0x4d9c]); // 1e10: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1e11: jp z, 1e2bh if (((u8Flags & 0x40) >> 6) == 1) { goto L1e2b; } // 1e14: ld hl, (4d84h) Z80L = (UINT8) (mem[0x4d84]); Z80H = (UINT8) (mem[0x4d85]); { UINT32 u32Temp0; // 1e17: add hl, hl u32Temp0 = Z80HL + Z80HL; u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80HL) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 1e18: ld (4d84h), hl mem[0x4d84] = Z80L; mem[0x4d85] = Z80H; // 1e1b: ld hl, (4d82h) Z80L = (UINT8) (mem[0x4d82]); Z80H = (UINT8) (mem[0x4d83]); { UINT32 u32Temp0; // 1e1e: adc hl, hl u32Temp0 = (Z80HL + Z80HL + ((u8Flags & 0x01) >> 0)); u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80HL) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80HL ^ Z80HL ^ 0x8000) & (Z80HL ^ u32Temp0) & 0x8000)) ? 0x04 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80HL == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80HL & 0x8000) ? 0x80 : 0); } // 1e20: ld (4d82h), hl mem[0x4d82] = Z80L; mem[0x4d83] = Z80H; // 1e23: ret nc if (((u8Flags & 0x01) >> 0) != 1) { goto returnInstruction; } // 1e24: ld hl, 4d84h Z80HL = (UINT16) (0x4d84); { UINT8 u8Temp0; // 1e27: inc (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 1e28: jp 1e5dh goto L1e5d; // 1e2b: ld a, (4daah) L1e2b: Z80A = (UINT8) (mem[0x4daa]); // 1e2e: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1e2f: jp z, 1e49h if (((u8Flags & 0x40) >> 6) == 1) { goto L1e49; } // 1e32: ld hl, (4d80h) Z80L = (UINT8) (mem[0x4d80]); Z80H = (UINT8) (mem[0x4d81]); { UINT32 u32Temp0; // 1e35: add hl, hl u32Temp0 = Z80HL + Z80HL; u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80HL) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 1e36: ld (4d80h), hl mem[0x4d80] = Z80L; mem[0x4d81] = Z80H; // 1e39: ld hl, (4d7eh) Z80L = (UINT8) (mem[0x4d7e]); Z80H = (UINT8) (mem[0x4d7f]); { UINT32 u32Temp0; // 1e3c: adc hl, hl u32Temp0 = (Z80HL + Z80HL + ((u8Flags & 0x01) >> 0)); u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80HL) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80HL ^ Z80HL ^ 0x8000) & (Z80HL ^ u32Temp0) & 0x8000)) ? 0x04 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80HL == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80HL & 0x8000) ? 0x80 : 0); } // 1e3e: ld (4d7eh), hl mem[0x4d7e] = Z80L; mem[0x4d7f] = Z80H; // 1e41: ret nc if (((u8Flags & 0x01) >> 0) != 1) { goto returnInstruction; } // 1e42: ld hl, 4d80h Z80HL = (UINT16) (0x4d80); { UINT8 u8Temp0; // 1e45: inc (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 1e46: jp 1e5dh goto L1e5d; // 1e49: ld hl, (4d7ch) L1e49: Z80L = (UINT8) (mem[0x4d7c]); Z80H = (UINT8) (mem[0x4d7d]); { UINT32 u32Temp0; // 1e4c: add hl, hl u32Temp0 = Z80HL + Z80HL; u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80HL) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 1e4d: ld (4d7ch), hl mem[0x4d7c] = Z80L; mem[0x4d7d] = Z80H; // 1e50: ld hl, (4d7ah) Z80L = (UINT8) (mem[0x4d7a]); Z80H = (UINT8) (mem[0x4d7b]); { UINT32 u32Temp0; // 1e53: adc hl, hl u32Temp0 = (Z80HL + Z80HL + ((u8Flags & 0x01) >> 0)); u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80HL) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80HL ^ Z80HL ^ 0x8000) & (Z80HL ^ u32Temp0) & 0x8000)) ? 0x04 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80HL == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80HL & 0x8000) ? 0x80 : 0); } // 1e55: ld (4d7ah), hl mem[0x4d7a] = Z80L; mem[0x4d7b] = Z80H; // 1e58: ret nc if (((u8Flags & 0x01) >> 0) != 1) { goto returnInstruction; } // 1e59: ld hl, 4d7ch Z80HL = (UINT16) (0x4d7c); { UINT8 u8Temp0; // 1e5c: inc (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 1e5d: ld hl, 4d1ah L1e5d: Z80HL = (UINT16) (0x4d1a); // 1e60: ld a, (hl) Z80A = (UINT8) (mem[Z80HL]); // 1e61: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1e62: jp z, 1e72h if (((u8Flags & 0x40) >> 6) == 1) { goto L1e72; } // 1e65: ld a, (4d06h) Z80A = (UINT8) (mem[0x4d06]); // 1e68: and a, 07h Z80A = (UINT8) (Z80A & 0x07); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); { UINT16 u16Temp0; // 1e6a: cp a, 04h u16Temp0 = Z80A - 0x04; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x04))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x04 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 1e6c: jp z, 1e7ch if (((u8Flags & 0x40) >> 6) == 1) { goto L1e7c; } // 1e6f: jp 1ebbh goto L1ebb; // 1e72: ld a, (4d07h) L1e72: Z80A = (UINT8) (mem[0x4d07]); // 1e75: and a, 07h Z80A = (UINT8) (Z80A & 0x07); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); { UINT16 u16Temp0; // 1e77: cp a, 04h u16Temp0 = Z80A - 0x04; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x04))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x04 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 1e79: jp nz, 1ebbh if (((u8Flags & 0x40) >> 6) != 1) { goto L1ebb; } // 1e7c: ld a, 04h L1e7c: Z80A = (UINT8) (0x04); // 1e7e: call 1ed0h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x1e; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x81; goto L1ed0; L1e81: // 1e81: jr c, 01e9eh if (((u8Flags & 0x01) >> 0) == 1) { goto L1e9e; } // 1e83: ld a, (4daah) Z80A = (UINT8) (mem[0x4daa]); // 1e86: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1e87: jp z, 1e90h if (((u8Flags & 0x40) >> 6) == 1) { goto L1e90; } // 1e8a: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x1e; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x8b; goto L0028; L1e8d: // 1e8d: jp 1e9eh goto L1e9e; // 1e90: ld hl, (4d10h) L1e90: Z80L = (UINT8) (mem[0x4d10]); Z80H = (UINT8) (mem[0x4d11]); // 1e93: call 2052h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x1e; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x96; goto L2052; L1e96: // 1e96: ld a, (hl) Z80A = (UINT8) (mem[Z80HL]); { UINT16 u16Temp0; // 1e97: cp a, 1ah u16Temp0 = Z80A - 0x1a; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x1a))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x1a ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 1e99: jr z, 01e9eh if (((u8Flags & 0x40) >> 6) == 1) { goto L1e9e; } // 1e9b: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x1e; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x9c; goto L0028; // 1e9e: call 1f73h L1e9e: Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x1e; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xa1; goto L1f73; L1ea1: // 1ea1: ld ix, 4d24h Z80IX = (UINT16) (0x4d24); // 1ea5: ld iy, 4d10h Z80IY = (UINT16) (0x4d10); // 1ea9: call 2000h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x1e; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xac; goto L2000; L1eac: // 1eac: ld (4d10h), hl mem[0x4d10] = Z80L; mem[0x4d11] = Z80H; // 1eaf: ld hl, (4d24h) Z80L = (UINT8) (mem[0x4d24]); Z80H = (UINT8) (mem[0x4d25]); // 1eb2: ld (4d1ah), hl mem[0x4d1a] = Z80L; mem[0x4d1b] = Z80H; // 1eb5: ld a, (4d2fh) Z80A = (UINT8) (mem[0x4d2f]); // 1eb8: ld (4d2bh), a mem[0x4d2b] = Z80A; // 1ebb: ld ix, 4d1ah L1ebb: Z80IX = (UINT16) (0x4d1a); // 1ebf: ld iy, 4d06h Z80IY = (UINT16) (0x4d06); // 1ec3: call 2000h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x1e; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xc6; goto L2000; L1ec6: // 1ec6: ld (4d06h), hl mem[0x4d06] = Z80L; mem[0x4d07] = Z80H; // 1ec9: call 2018h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x1e; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xcc; goto L2018; L1ecc: // 1ecc: ld (4d37h), hl mem[0x4d37] = Z80L; mem[0x4d38] = Z80H; // 1ecf: ret goto returnInstruction; { UINT16 u16Temp0; // 1ed0: add a, a L1ed0: u16Temp0 = Z80A + Z80A; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80A))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80A ^ Z80A ^ 0x80) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 1ed1: ld c, a Z80C = (UINT8) (Z80A); // 1ed2: ld b, 00h Z80B = (UINT8) (0); // 1ed4: ld hl, 4d09h Z80HL = (UINT16) (0x4d09); { UINT32 u32Temp0; // 1ed7: add hl, bc u32Temp0 = Z80HL + Z80BC; u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80BC) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 1ed8: ld a, (hl) Z80A = (UINT8) (mem[Z80HL]); { UINT16 u16Temp0; // 1ed9: cp a, 1dh u16Temp0 = Z80A - 0x1d; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x1d))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x1d ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 1edb: jp nz, 1ee3h if (((u8Flags & 0x40) >> 6) != 1) { goto L1ee3; } // 1ede: ld (hl), 3dh mspacmanIndirectWrite8(Z80HL, 0x3d); // 1ee0: jp 1efch goto L1efc; { UINT16 u16Temp0; // 1ee3: cp a, 3eh L1ee3: u16Temp0 = Z80A - 0x3e; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x3e))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x3e ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 1ee5: jp nz, 1eedh if (((u8Flags & 0x40) >> 6) != 1) { goto L1eed; } // 1ee8: ld (hl), 1eh mspacmanIndirectWrite8(Z80HL, 0x1e); // 1eea: jp 1efch goto L1efc; // 1eed: ld b, 21h L1eed: Z80B = (UINT8) (0x21); { UINT16 u16Temp0; // 1eef: sub a, b u16Temp0 = Z80A - Z80B; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80B))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80B ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 1ef0: jp c, 1efch if (((u8Flags & 0x01) >> 0) == 1) { goto L1efc; } // 1ef3: ld a, (hl) Z80A = (UINT8) (mem[Z80HL]); // 1ef4: ld b, 3bh Z80B = (UINT8) (0x3b); { UINT16 u16Temp0; // 1ef6: sub a, b u16Temp0 = Z80A - Z80B; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80B))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80B ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 1ef7: jp nc, 1efch if (((u8Flags & 0x01) >> 0) != 1) { goto L1efc; } // 1efa: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1efb: ret goto returnInstruction; // 1efc: scf L1efc: u8Flags |= 0x01; u8Flags &= 0xfd; u8Flags &= 0xef; // 1efd: ret goto returnInstruction; // 1efe: ld a, (4db1h) L1efe: Z80A = (UINT8) (mem[0x4db1]); // 1f01: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1f02: ret z if (((u8Flags & 0x40) >> 6) == 1) { goto returnInstruction; } // 1f03: xor a, a Z80A = (UINT8) (0); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1f04: ld (4db1h), a mem[0x4db1] = Z80A; // 1f07: ld hl, 32ffh Z80HL = (UINT16) (0x32ff); // 1f0a: ld a, (4d28h) Z80A = (UINT8) (mem[0x4d28]); // 1f0d: xor a, 02h Z80A = (UINT8) (Z80A ^ 0x02); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1f0f: ld (4d2ch), a mem[0x4d2c] = Z80A; // 1f12: ld b, a Z80B = (UINT8) (Z80A); // 1f13: rst 18h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x1f; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x14; goto L0018; L1f14: // 1f14: ld (4d1eh), hl mem[0x4d1e] = Z80L; mem[0x4d1f] = Z80H; // 1f17: ld a, (gmemode) Z80A = (UINT8) (mem[0x4e02]); { UINT16 u16Temp0; // 1f1a: cp a, 22h u16Temp0 = Z80A - 0x22; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x22))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x22 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 1f1c: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 1f1d: ld (4d14h), hl mem[0x4d14] = Z80L; mem[0x4d15] = Z80H; // 1f20: ld a, b Z80A = (UINT8) (Z80B); // 1f21: ld (4d28h), a mem[0x4d28] = Z80A; // 1f24: ret goto returnInstruction; // 1f25: ld a, (4db2h) L1f25: Z80A = (UINT8) (mem[0x4db2]); // 1f28: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1f29: ret z if (((u8Flags & 0x40) >> 6) == 1) { goto returnInstruction; } // 1f2a: xor a, a Z80A = (UINT8) (0); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1f2b: ld (4db2h), a mem[0x4db2] = Z80A; // 1f2e: ld hl, 32ffh L1f2e: Z80HL = (UINT16) (0x32ff); // 1f31: ld a, (4d29h) Z80A = (UINT8) (mem[0x4d29]); // 1f34: xor a, 02h Z80A = (UINT8) (Z80A ^ 0x02); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1f36: ld (4d2dh), a mem[0x4d2d] = Z80A; // 1f39: ld b, a Z80B = (UINT8) (Z80A); // 1f3a: rst 18h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x1f; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x3b; goto L0018; L1f3b: // 1f3b: ld (4d20h), hl mem[0x4d20] = Z80L; mem[0x4d21] = Z80H; // 1f3e: ld a, (gmemode) Z80A = (UINT8) (mem[0x4e02]); { UINT16 u16Temp0; // 1f41: cp a, 22h u16Temp0 = Z80A - 0x22; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x22))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x22 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 1f43: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 1f44: ld (4d16h), hl mem[0x4d16] = Z80L; mem[0x4d17] = Z80H; // 1f47: ld a, b Z80A = (UINT8) (Z80B); // 1f48: ld (4d29h), a mem[0x4d29] = Z80A; // 1f4b: ret goto returnInstruction; // 1f4c: ld a, (4db3h) L1f4c: Z80A = (UINT8) (mem[0x4db3]); // 1f4f: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1f50: ret z if (((u8Flags & 0x40) >> 6) == 1) { goto returnInstruction; } // 1f51: xor a, a Z80A = (UINT8) (0); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1f52: ld (4db3h), a mem[0x4db3] = Z80A; // 1f55: ld hl, 32ffh L1f55: Z80HL = (UINT16) (0x32ff); // 1f58: ld a, (4d2ah) Z80A = (UINT8) (mem[0x4d2a]); // 1f5b: xor a, 02h Z80A = (UINT8) (Z80A ^ 0x02); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1f5d: ld (4d2eh), a mem[0x4d2e] = Z80A; // 1f60: ld b, a Z80B = (UINT8) (Z80A); // 1f61: rst 18h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x1f; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x62; goto L0018; L1f62: // 1f62: ld (4d22h), hl mem[0x4d22] = Z80L; mem[0x4d23] = Z80H; // 1f65: ld a, (gmemode) Z80A = (UINT8) (mem[0x4e02]); { UINT16 u16Temp0; // 1f68: cp a, 22h u16Temp0 = Z80A - 0x22; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x22))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x22 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 1f6a: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 1f6b: ld (4d18h), hl mem[0x4d18] = Z80L; mem[0x4d19] = Z80H; // 1f6e: ld a, b Z80A = (UINT8) (Z80B); // 1f6f: ld (4d2ah), a mem[0x4d2a] = Z80A; // 1f72: ret goto returnInstruction; // 1f73: ld a, (4db4h) L1f73: Z80A = (UINT8) (mem[0x4db4]); // 1f76: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1f77: ret z if (((u8Flags & 0x40) >> 6) == 1) { goto returnInstruction; } // 1f78: xor a, a Z80A = (UINT8) (0); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1f79: ld (4db4h), a mem[0x4db4] = Z80A; // 1f7c: ld hl, 32ffh L1f7c: Z80HL = (UINT16) (0x32ff); // 1f7f: ld a, (4d2bh) Z80A = (UINT8) (mem[0x4d2b]); // 1f82: xor a, 02h Z80A = (UINT8) (Z80A ^ 0x02); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1f84: ld (4d2fh), a mem[0x4d2f] = Z80A; // 1f87: ld b, a Z80B = (UINT8) (Z80A); // 1f88: rst 18h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x1f; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x89; goto L0018; L1f89: // 1f89: ld (4d24h), hl mem[0x4d24] = Z80L; mem[0x4d25] = Z80H; // 1f8c: ld a, (gmemode) Z80A = (UINT8) (mem[0x4e02]); { UINT16 u16Temp0; // 1f8f: cp a, 22h u16Temp0 = Z80A - 0x22; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x22))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x22 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 1f91: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 1f92: ld (4d1ah), hl mem[0x4d1a] = Z80L; mem[0x4d1b] = Z80H; // 1f95: ld a, b Z80A = (UINT8) (Z80B); // 1f96: ld (4d2bh), a mem[0x4d2b] = Z80A; // 1f99: ret goto returnInstruction; // 1f9b: push af // new for ms-pacman // rst 38 continuation (vblank) L1f9b: Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80A; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = u8Flags; // 1f9c: ld a, i Z80A = (UINT8) (Z80i); u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags &= 0xef; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x04) | ((((Z80iff & 0x02) >> 1)) ? 0x04 : 0); // 1f9e: or a, a ; check to see if we're in test mode u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 1f9f: jr z, 01fa5h ; jp if yes if (((u8Flags & 0x40) >> 6) == 1) { goto L1fa5; } // 1fa1: pop af // not in test mode u8Flags = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); Z80A = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); // 1fa2: jp 008dh ; continue the normal handler goto L008d; // 1fa5: pop af // in test mode L1fa5: u8Flags = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); Z80A = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); // 1fa6: jp 3000h ; we're in init, continue testing goto L3000; // 2000: ld a, (iy+00h) // fast/invincibilty checksum ; HACK3 // fast intermission fix ; HACK10 // this is a common function as well. L2000: Z80A = (UINT8) (mem[Z80IY]); { UINT16 u16Temp0; // 2003: add a, (ix+00h) u16Temp0 = Z80A + mem[Z80IX]; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ mem[Z80IX]))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((mem[Z80IX] ^ Z80A ^ 0x80) & (mem[Z80IX] ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 2006: ld l, a Z80L = (UINT8) (Z80A); // 2007: ld a, (iy+01h) Z80A = (UINT8) (mem[Z80IY + 1]); { UINT16 u16Temp0; // 200a: add a, (ix+01h) u16Temp0 = Z80A + mem[Z80IX + 1]; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ mem[Z80IX + 1]))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((mem[Z80IX + 1] ^ Z80A ^ 0x80) & (mem[Z80IX + 1] ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 200d: ld h, a Z80H = (UINT8) (Z80A); // 200e: ret goto returnInstruction; // 200f: call 2000h L200f: Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x20; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x12; goto L2000; L2012: // 2012: call 0065h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x20; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x15; goto L0065; L2015: // 2015: ld a, (hl) Z80A = (UINT8) (mem[Z80HL]); // 2016: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2017: ret goto returnInstruction; // 2018: ld a, l L2018: Z80A = (UINT8) (Z80L); // 2019: srl a u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (Z80A >> 1); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags &= 0xef; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 201b: srl a u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (Z80A >> 1); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags &= 0xef; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 201d: srl a u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (Z80A >> 1); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags &= 0xef; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); { UINT16 u16Temp0; // 201f: add a, 20h u16Temp0 = Z80A + 0x20; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x20))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x20 ^ Z80A ^ 0x80) & (0x20 ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 2021: ld l, a Z80L = (UINT8) (Z80A); // 2022: ld a, h Z80A = (UINT8) (Z80H); // 2023: srl a u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (Z80A >> 1); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags &= 0xef; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2025: srl a u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (Z80A >> 1); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags &= 0xef; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2027: srl a u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (Z80A >> 1); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags &= 0xef; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); { UINT16 u16Temp0; // 2029: add a, 1eh u16Temp0 = Z80A + 0x1e; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x1e))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x1e ^ Z80A ^ 0x80) & (0x1e ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 202b: ld h, a Z80H = (UINT8) (Z80A); // 202c: ret goto returnInstruction; // 202d: push af // this does something that happens often. // same as 'call $0065' L202d: Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80A; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = u8Flags; // 202e: push bc Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80B; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80C; // 202f: ld a, l Z80A = (UINT8) (Z80L); { UINT16 u16Temp0; // 2030: sub a, 20h u16Temp0 = Z80A - 0x20; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x20))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x20 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 2032: ld l, a Z80L = (UINT8) (Z80A); // 2033: ld a, h Z80A = (UINT8) (Z80H); { UINT16 u16Temp0; // 2034: sub a, 20h u16Temp0 = Z80A - 0x20; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x20))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x20 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 2036: ld h, a Z80H = (UINT8) (Z80A); // 2037: ld b, 00h Z80B = (UINT8) (0); // 2039: sla h u8Flags = (u8Flags & ~0x01) | ((Z80H & 0x80) ? 0x01 : 0); Z80H = (UINT8) (Z80H << 1); u8Flags = (u8Flags & ~0x80) | ((Z80H & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x40) | ((Z80H == 0) ? 0x40 : 0); u8Flags &= 0xef; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x04) | (((((((Z80H >> 0x07) & 1) + ((Z80H >> 0x06) & 1) + ((Z80H >> 0x05) & 1) + ((Z80H >> 0x04) & 1) + ((Z80H >> 0x03) & 1) + ((Z80H >> 0x02) & 1) + ((Z80H >> 1) & 1) + ((Z80H >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 203b: sla h u8Flags = (u8Flags & ~0x01) | ((Z80H & 0x80) ? 0x01 : 0); Z80H = (UINT8) (Z80H << 1); u8Flags = (u8Flags & ~0x80) | ((Z80H & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x40) | ((Z80H == 0) ? 0x40 : 0); u8Flags &= 0xef; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x04) | (((((((Z80H >> 0x07) & 1) + ((Z80H >> 0x06) & 1) + ((Z80H >> 0x05) & 1) + ((Z80H >> 0x04) & 1) + ((Z80H >> 0x03) & 1) + ((Z80H >> 0x02) & 1) + ((Z80H >> 1) & 1) + ((Z80H >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 203d: sla h u8Flags = (u8Flags & ~0x01) | ((Z80H & 0x80) ? 0x01 : 0); Z80H = (UINT8) (Z80H << 1); u8Flags = (u8Flags & ~0x80) | ((Z80H & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x40) | ((Z80H == 0) ? 0x40 : 0); u8Flags &= 0xef; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x04) | (((((((Z80H >> 0x07) & 1) + ((Z80H >> 0x06) & 1) + ((Z80H >> 0x05) & 1) + ((Z80H >> 0x04) & 1) + ((Z80H >> 0x03) & 1) + ((Z80H >> 0x02) & 1) + ((Z80H >> 1) & 1) + ((Z80H >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 203f: sla h u8Flags = (u8Flags & ~0x01) | ((Z80H & 0x80) ? 0x01 : 0); Z80H = (UINT8) (Z80H << 1); u8Flags = (u8Flags & ~0x80) | ((Z80H & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x40) | ((Z80H == 0) ? 0x40 : 0); u8Flags &= 0xef; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x04) | (((((((Z80H >> 0x07) & 1) + ((Z80H >> 0x06) & 1) + ((Z80H >> 0x05) & 1) + ((Z80H >> 0x04) & 1) + ((Z80H >> 0x03) & 1) + ((Z80H >> 0x02) & 1) + ((Z80H >> 1) & 1) + ((Z80H >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); { UINT8 u8Temp0; // 2041: rl b u8Temp0 = Z80B; Z80B = (UINT8) (((Z80B << 1) | ((u8Flags & 0x01) >> 0))); u8Flags = (u8Flags & ~0x01) | ((u8Temp0 & 0x80) ? 0x01 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80B & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x40) | ((Z80B == 0) ? 0x40 : 0); u8Flags &= 0xef; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x04) | (((((((Z80B >> 0x07) & 1) + ((Z80B >> 0x06) & 1) + ((Z80B >> 0x05) & 1) + ((Z80B >> 0x04) & 1) + ((Z80B >> 0x03) & 1) + ((Z80B >> 0x02) & 1) + ((Z80B >> 1) & 1) + ((Z80B >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); } // 2043: sla h u8Flags = (u8Flags & ~0x01) | ((Z80H & 0x80) ? 0x01 : 0); Z80H = (UINT8) (Z80H << 1); u8Flags = (u8Flags & ~0x80) | ((Z80H & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x40) | ((Z80H == 0) ? 0x40 : 0); u8Flags &= 0xef; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x04) | (((((((Z80H >> 0x07) & 1) + ((Z80H >> 0x06) & 1) + ((Z80H >> 0x05) & 1) + ((Z80H >> 0x04) & 1) + ((Z80H >> 0x03) & 1) + ((Z80H >> 0x02) & 1) + ((Z80H >> 1) & 1) + ((Z80H >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); { UINT8 u8Temp0; // 2045: rl b u8Temp0 = Z80B; Z80B = (UINT8) (((Z80B << 1) | ((u8Flags & 0x01) >> 0))); u8Flags = (u8Flags & ~0x01) | ((u8Temp0 & 0x80) ? 0x01 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80B & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x40) | ((Z80B == 0) ? 0x40 : 0); u8Flags &= 0xef; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x04) | (((((((Z80B >> 0x07) & 1) + ((Z80B >> 0x06) & 1) + ((Z80B >> 0x05) & 1) + ((Z80B >> 0x04) & 1) + ((Z80B >> 0x03) & 1) + ((Z80B >> 0x02) & 1) + ((Z80B >> 1) & 1) + ((Z80B >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); } // 2047: ld c, h Z80C = (UINT8) (Z80H); // 2048: ld h, 00h Z80H = (UINT8) (0); { UINT32 u32Temp0; // 204a: add hl, bc u32Temp0 = Z80HL + Z80BC; u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80BC) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 204b: ld bc, 4040h Z80BC = (UINT16) (0x4040); { UINT32 u32Temp0; // 204e: add hl, bc u32Temp0 = Z80HL + Z80BC; u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80BC) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 204f: pop bc Z80C = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); Z80B = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); // 2050: pop af u8Flags = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); Z80A = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); // 2051: ret goto returnInstruction; // 2052: call 0065h L2052: Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x20; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x55; goto L0065; L2055: // 2055: ld de, 0400h Z80DE = (UINT16) (0x0400); { UINT32 u32Temp0; // 2058: add hl, de u32Temp0 = Z80HL + Z80DE; u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80DE) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 2059: ret goto returnInstruction; // 205a: call 2052h L205a: Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x20; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x5d; goto L2052; L205d: // 205d: ld a, (hl) Z80A = (UINT8) (mem[Z80HL]); { UINT16 u16Temp0; // 205e: cp a, 1bh u16Temp0 = Z80A - 0x1b; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x1b))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x1b ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 2060: jp 366fh goto L366f; // 2066: xor a, a L2066: Z80A = (UINT8) (0); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2067: ld (bc), a mspacmanIndirectWrite8(Z80BC, Z80A); // 2068: ret goto returnInstruction; // 2069: ld a, (4da1h) L2069: Z80A = (UINT8) (mem[0x4da1]); // 206c: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 206d: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 206e: ld a, (4e12h) Z80A = (UINT8) (mem[0x4e12]); // 2071: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2072: jp z, 207eh if (((u8Flags & 0x40) >> 6) == 1) { goto L207e; } // 2075: ld a, (4d9fh) Z80A = (UINT8) (mem[0x4d9f]); { UINT16 u16Temp0; // 2078: cp a, 07h u16Temp0 = Z80A - 0x07; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x07))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x07 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 207a: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 207b: jp 2086h goto L2086; // 207e: ld hl, 4db8h L207e: Z80HL = (UINT16) (0x4db8); // 2081: ld a, (4e0fh) Z80A = (UINT8) (mem[0x4e0f]); { UINT16 u16Temp0; UINT8 u8Temp0; // 2084: cp a, (hl) u8Temp0 = mem[Z80HL]; u16Temp0 = Z80A - u8Temp0; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ u8Temp0))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((u8Temp0 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 2085: ret c if (((u8Flags & 0x01) >> 0) == 1) { goto returnInstruction; } // 2086: ld a, 02h L2086: Z80A = (UINT8) (0x02); // 2088: ld (4da1h), a mem[0x4da1] = Z80A; // 208b: ret goto returnInstruction; // 208c: ld a, (4da2h) L208c: Z80A = (UINT8) (mem[0x4da2]); // 208f: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2090: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 2091: ld a, (4e12h) Z80A = (UINT8) (mem[0x4e12]); // 2094: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2095: jp z, 20a1h if (((u8Flags & 0x40) >> 6) == 1) { goto L20a1; } // 2098: ld a, (4d9fh) Z80A = (UINT8) (mem[0x4d9f]); { UINT16 u16Temp0; // 209b: cp a, 11h u16Temp0 = Z80A - 0x11; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x11))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x11 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 209d: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 209e: jp 20a9h goto L20a9; // 20a1: ld hl, 4db9h L20a1: Z80HL = (UINT16) (0x4db9); // 20a4: ld a, (4e10h) Z80A = (UINT8) (mem[0x4e10]); { UINT16 u16Temp0; UINT8 u8Temp0; // 20a7: cp a, (hl) u8Temp0 = mem[Z80HL]; u16Temp0 = Z80A - u8Temp0; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ u8Temp0))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((u8Temp0 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 20a8: ret c if (((u8Flags & 0x01) >> 0) == 1) { goto returnInstruction; } // 20a9: ld a, 03h L20a9: Z80A = (UINT8) (0x03); // 20ab: ld (4da2h), a mem[0x4da2] = Z80A; // 20ae: ret goto returnInstruction; // 20af: ld a, (4da3h) L20af: Z80A = (UINT8) (mem[0x4da3]); // 20b2: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 20b3: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 20b4: ld a, (4e12h) Z80A = (UINT8) (mem[0x4e12]); // 20b7: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 20b8: jp z, 20c9h if (((u8Flags & 0x40) >> 6) == 1) { goto L20c9; } // 20bb: ld a, (4d9fh) Z80A = (UINT8) (mem[0x4d9f]); { UINT16 u16Temp0; // 20be: cp a, 20h u16Temp0 = Z80A - 0x20; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x20))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x20 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 20c0: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 20c1: xor a, a Z80A = (UINT8) (0); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 20c2: ld (4e12h), a mem[0x4e12] = Z80A; // 20c5: ld (4d9fh), a mem[0x4d9f] = Z80A; // 20c8: ret goto returnInstruction; // 20c9: ld hl, 4dbah L20c9: Z80HL = (UINT16) (0x4dba); // 20cc: ld a, (4e11h) Z80A = (UINT8) (mem[0x4e11]); { UINT16 u16Temp0; UINT8 u8Temp0; // 20cf: cp a, (hl) u8Temp0 = mem[Z80HL]; u16Temp0 = Z80A - u8Temp0; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ u8Temp0))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((u8Temp0 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 20d0: ret c if (((u8Flags & 0x01) >> 0) == 1) { goto returnInstruction; } // 20d1: ld a, 03h L20d1: Z80A = (UINT8) (0x03); // 20d3: ld (4da3h), a mem[0x4da3] = Z80A; // 20d6: ret goto returnInstruction; // 20d7: ld a, (4da3h) L20d7: Z80A = (UINT8) (mem[0x4da3]); // 20da: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 20db: ret z if (((u8Flags & 0x40) >> 6) == 1) { goto returnInstruction; } // 20dc: ld hl, peleatn ; number of pellets eaten Z80HL = (UINT16) (0x4e0e); // 20df: ld a, (4db6h) Z80A = (UINT8) (mem[0x4db6]); // 20e2: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 20e3: jp nz, 20f4h if (((u8Flags & 0x40) >> 6) != 1) { goto L20f4; } // 20e6: ld a, 0f4h Z80A = (UINT8) (0xf4); { UINT16 u16Temp0; UINT8 u8Temp0; // 20e8: sub a, (hl) u8Temp0 = mem[Z80HL]; u16Temp0 = Z80A - u8Temp0; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ u8Temp0))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((u8Temp0 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 20e9: ld b, a Z80B = (UINT8) (Z80A); // 20ea: ld a, (4dbbh) Z80A = (UINT8) (mem[0x4dbb]); { UINT16 u16Temp0; // 20ed: sub a, b u16Temp0 = Z80A - Z80B; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80B))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80B ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 20ee: ret c if (((u8Flags & 0x01) >> 0) == 1) { goto returnInstruction; } // 20ef: ld a, 01h Z80A = (UINT8) (1); // 20f1: ld (4db6h), a mem[0x4db6] = Z80A; // 20f4: ld a, (4db7h) L20f4: Z80A = (UINT8) (mem[0x4db7]); // 20f7: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 20f8: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 20f9: ld a, 0f4h Z80A = (UINT8) (0xf4); { UINT16 u16Temp0; UINT8 u8Temp0; // 20fb: sub a, (hl) u8Temp0 = mem[Z80HL]; u16Temp0 = Z80A - u8Temp0; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ u8Temp0))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((u8Temp0 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 20fc: ld b, a Z80B = (UINT8) (Z80A); // 20fd: ld a, (4dbch) Z80A = (UINT8) (mem[0x4dbc]); { UINT16 u16Temp0; // 2100: sub a, b u16Temp0 = Z80A - Z80B; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80B))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80B ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 2101: ret c if (((u8Flags & 0x01) >> 0) == 1) { goto returnInstruction; } // 2102: ld a, 01h Z80A = (UINT8) (1); // 2104: ld (4db7h), a mem[0x4db7] = Z80A; // 2107: ret goto returnInstruction; L2108: // 2108: jp 3435h goto L3435; L210b: // 210b: rst 20h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x21; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x0c; goto L0020; L211a: // 211a: ld a, (4d3ah) Z80A = (UINT8) (mem[0x4d3a]); { UINT16 u16Temp0; // 211d: sub a, 21h u16Temp0 = Z80A - 0x21; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x21))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x21 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 211f: jr nz, 02130h if (((u8Flags & 0x40) >> 6) != 1) { goto L2130; } // 2121: inc a Z80A = (UINT8) (Z80A + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); if ((Z80A & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80A == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 2122: ld (4da0h), a mem[0x4da0] = Z80A; // 2125: ld (4db7h), a mem[0x4db7] = Z80A; // 2128: call 0506h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x21; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x2b; goto L0506; // 212b: ld hl, 4e06h L212b: Z80HL = (UINT16) (0x4e06); { UINT8 u8Temp0; // 212e: inc (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 212f: ret goto returnInstruction; // 2130: call 1806h L2130: Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x21; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x33; goto L1806; L2133: // 2133: call 1806h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x21; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x36; goto L1806; // 2136: call 1b36h L2136: Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x21; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x39; goto L1b36; L2139: // 2139: call 1b36h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x21; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x3c; goto L1b36; L213c: // 213c: call 0e23h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x21; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x3f; goto L0e23; L213f: // 213f: ret goto returnInstruction; L2140: // 2140: ld a, (4d3ah) Z80A = (UINT8) (mem[0x4d3a]); { UINT16 u16Temp0; // 2143: sub a, 1eh u16Temp0 = Z80A - 0x1e; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x1e))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x1e ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 2145: jp nz, 2130h if (((u8Flags & 0x40) >> 6) != 1) { goto L2130; } // 2148: jp 212bh goto L212b; L214b: // 214b: ld a, (4d32h) Z80A = (UINT8) (mem[0x4d32]); { UINT16 u16Temp0; // 214e: sub a, 1eh u16Temp0 = Z80A - 0x1e; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x1e))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x1e ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 2150: jp nz, 2136h if (((u8Flags & 0x40) >> 6) != 1) { goto L2136; } // 2153: call 1a70h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x21; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x56; goto L1a70; L2156: // 2156: xor a, a Z80A = (UINT8) (0); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2157: ld (4each), a mem[0x4eac] = Z80A; // 215a: ld (4ebch), a mem[0x4ebc] = Z80A; // 215d: call 05a5h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x21; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x60; goto L05a5; L2160: // 2160: ld (4d1ch), hl mem[0x4d1c] = Z80L; mem[0x4d1d] = Z80H; // 2163: ld a, (4d3ch) Z80A = (UINT8) (mem[0x4d3c]); // 2166: ld (4d30h), a // text lookup table? mem[0x4d30] = Z80A; // 2169: rst 30h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x21; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x6a; goto L0030; L216d: // 216d: jp 212bh goto L212b; L2170: // 2170: ld a, (4d32h) Z80A = (UINT8) (mem[0x4d32]); { UINT16 u16Temp0; // 2173: sub a, 2fh u16Temp0 = Z80A - 0x2f; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x2f))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x2f ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 2175: jp nz, 2136h if (((u8Flags & 0x40) >> 6) != 1) { goto L2136; } // 2178: jp 212bh goto L212b; L217b: // 217b: ld a, (4d32h) Z80A = (UINT8) (mem[0x4d32]); { UINT16 u16Temp0; // 217e: sub a, 3dh u16Temp0 = Z80A - 0x3d; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x3d))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x3d ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 2180: jp nz, 2130h if (((u8Flags & 0x40) >> 6) != 1) { goto L2130; } // 2183: jp 212bh goto L212b; L2186: // 2186: call 1806h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x21; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x89; goto L1806; L2189: // 2189: call 1806h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x21; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x8c; goto L1806; L218c: // 218c: ld a, (4d3ah) Z80A = (UINT8) (mem[0x4d3a]); { UINT16 u16Temp0; // 218f: sub a, 3dh u16Temp0 = Z80A - 0x3d; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x3d))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x3d ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 2191: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 2192: ld (4e06h), a mem[0x4e06] = Z80A; // 2195: rst 30h L2195: Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x21; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x96; goto L0030; L2199: // 2199: ld hl, 4e04h Z80HL = (UINT16) (0x4e04); { UINT8 u8Temp0; // 219c: inc (hl) ; add one to level cleared register? mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 219d: ret goto returnInstruction; L219e: // 219e: ld a, (4e07h) Z80A = (UINT8) (mem[0x4e07]); // 21a1: jp 344fh goto L344f; L21a4: // 21a4: ld b, c Z80B = (UINT8) (Z80C); // 21a5: rst 20h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x21; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xa6; goto L0020; L21c2: // no label was generated. L21c4: // 21c4: ld (45d2h), a MSPacVideoWrite(0x45d2,Z80A); // 21c7: ld (45d3h), a MSPacVideoWrite(0x45d3,Z80A); // 21ca: ld (45f2h), a MSPacVideoWrite(0x45f2,Z80A); // 21cd: ld (45f3h), a MSPacVideoWrite(0x45f3,Z80A); // 21d0: call 0506h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x21; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xd3; goto L0506; L21d3: // 21d3: ld (iy+00h), 60h mspacmanIndirectWrite8(Z80IY, 0x60); // 21d7: ld (iy+01h), 61h mspacmanIndirectWrite8(Z80IY + 1, 0x61); // 21db: rst 30h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x21; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xdc; goto L0030; L21df: // 21df: jr 021f0h goto L21f0; L21e1: // 21e1: ld a, (4d3ah) Z80A = (UINT8) (mem[0x4d3a]); { UINT16 u16Temp0; // 21e4: sub a, 2ch u16Temp0 = Z80A - 0x2c; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x2c))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x2c ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 21e6: jp nz, 2130h if (((u8Flags & 0x40) >> 6) != 1) { goto L2130; } // 21e9: inc a Z80A = (UINT8) (Z80A + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); if ((Z80A & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80A == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 21ea: ld (4da0h), a mem[0x4da0] = Z80A; // 21ed: ld (4db7h), a mem[0x4db7] = Z80A; // 21f0: ld hl, 4e07h L21f0: Z80HL = (UINT16) (0x4e07); { UINT8 u8Temp0; // 21f3: inc (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 21f4: ret goto returnInstruction; L21f5: // 21f5: ld a, (4d01h) Z80A = (UINT8) (mem[0x4d01]); { UINT16 u16Temp0; // 21f8: cp a, 77h u16Temp0 = Z80A - 0x77; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x77))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x77 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 21fa: jr z, 02201h if (((u8Flags & 0x40) >> 6) == 1) { goto L2201; } { UINT16 u16Temp0; // 21fc: cp a, 78h u16Temp0 = Z80A - 0x78; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x78))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x78 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 21fe: jp nz, 2130h if (((u8Flags & 0x40) >> 6) != 1) { goto L2130; } // 2201: ld hl, 2084h L2201: Z80HL = (UINT16) (0x2084); // 2204: ld (4d4eh), hl mem[0x4d4e] = Z80L; mem[0x4d4f] = Z80H; // 2207: ld (4d50h), hl mem[0x4d50] = Z80L; mem[0x4d51] = Z80H; L220a: // 220a: jr 021f0h goto L21f0; L220c: // 220c: ld a, (4d01h) Z80A = (UINT8) (mem[0x4d01]); { UINT16 u16Temp0; // 220f: sub a, 78h u16Temp0 = Z80A - 0x78; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x78))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x78 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 2211: jp nz, 2237h if (((u8Flags & 0x40) >> 6) != 1) { goto L2237; } // 2214: ld (iy+00h), 62h mspacmanIndirectWrite8(Z80IY, 0x62); // 2218: ld (iy+01h), 63h mspacmanIndirectWrite8(Z80IY + 1, 0x63); // 221c: jr 021f0h goto L21f0; L221e: // 221e: ld a, (4d01h) Z80A = (UINT8) (mem[0x4d01]); { UINT16 u16Temp0; // 2221: sub a, 7bh u16Temp0 = Z80A - 0x7b; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x7b))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x7b ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 2223: jr nz, 02237h if (((u8Flags & 0x40) >> 6) != 1) { goto L2237; } // 2225: ld (iy+00h), 64h mspacmanIndirectWrite8(Z80IY, 0x64); // 2229: ld (iy+01h), 65h mspacmanIndirectWrite8(Z80IY + 1, 0x65); // 222d: ld (iy+20h), 66h mspacmanIndirectWrite8(Z80IY + 0x20, 0x66); // 2231: ld (iy+21h), 67h mspacmanIndirectWrite8(Z80IY + 0x21, 0x67); // 2235: jr 021f0h goto L21f0; // 2237: call 1806h L2237: Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x22; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x3a; goto L1806; L223a: // 223a: call 1806h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x22; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x3d; goto L1806; L223d: // 223d: call 1b36h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x22; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x40; goto L1b36; L2240: // 2240: call 0e23h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x22; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x43; goto L0e23; L2243: // 2243: ret goto returnInstruction; L2244: // 2244: ld a, (4d01h) Z80A = (UINT8) (mem[0x4d01]); { UINT16 u16Temp0; // 2247: sub a, 7eh u16Temp0 = Z80A - 0x7e; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x7e))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x7e ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 2249: jr nz, 02237h if (((u8Flags & 0x40) >> 6) != 1) { goto L2237; } L224b: // 224b: ld (iy+00h), 68h mspacmanIndirectWrite8(Z80IY, 0x68); // 224f: ld (iy+01h), 69h mspacmanIndirectWrite8(Z80IY + 1, 0x69); // 2253: ld (iy+20h), 6ah mspacmanIndirectWrite8(Z80IY + 0x20, 0x6a); // 2257: ld (iy+21h), 6bh mspacmanIndirectWrite8(Z80IY + 0x21, 0x6b); // 225b: jr 021f0h goto L21f0; L225d: // 225d: ld a, (4d01h) Z80A = (UINT8) (mem[0x4d01]); { UINT16 u16Temp0; // 2260: sub a, 80h u16Temp0 = Z80A - 0x80; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x80))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x80 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 2262: jr nz, 02237h if (((u8Flags & 0x40) >> 6) != 1) { goto L2237; } // 2264: rst 30h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x22; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x65; goto L0030; L2268: // 2268: jr 021f0h goto L21f0; L226a: // 226a: ld hl, 4d01h Z80HL = (UINT16) (0x4d01); { UINT8 u8Temp0; // 226d: inc (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } { UINT8 u8Temp0; // 226e: inc (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 226f: ld (iy+00h), 6ch mspacmanIndirectWrite8(Z80IY, 0x6c); // 2273: ld (iy+01h), 6dh mspacmanIndirectWrite8(Z80IY + 1, 0x6d); // 2277: ld (iy+20h), 40h mspacmanIndirectWrite8(Z80IY + 0x20, 0x40); // 227b: ld (iy+21h), 40h mspacmanIndirectWrite8(Z80IY + 0x21, 0x40); // 227f: rst 30h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x22; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x80; goto L0030; L2283: // 2283: jp 21f0h goto L21f0; L2286: // 2286: rst 30h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x22; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x87; goto L0030; L228a: // 228a: jp 21f0h goto L21f0; L228d: // 228d: xor a, a Z80A = (UINT8) (0); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 228e: ld (4e07h), a mem[0x4e07] = Z80A; // 2291: ld hl, 4e04h Z80HL = (UINT16) (0x4e04); { UINT8 u8Temp0; // 2294: inc (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } { UINT8 u8Temp0; // 2295: inc (hl) ; add 2 to level cleared register? mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 2296: ret goto returnInstruction; L2297: // 2297: ld a, (4e08h) Z80A = (UINT8) (mem[0x4e08]); // 229a: jp 3469h goto L3469; // 22b9: ld hl, 4e08h L22b9: Z80HL = (UINT16) (0x4e08); { UINT8 u8Temp0; // 22bc: inc (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 22bd: ret goto returnInstruction; L22be: // 22be: ld a, (4d01h) Z80A = (UINT8) (mem[0x4d01]); { UINT16 u16Temp0; // 22c1: cp a, 0ffh u16Temp0 = Z80A - 0xff; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0xff))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0xff ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 22c3: jr z, 022cah if (((u8Flags & 0x40) >> 6) == 1) { goto L22ca; } { UINT16 u16Temp0; // 22c5: cp a, 0feh u16Temp0 = Z80A - 0xfe; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0xfe))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0xfe ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 22c7: jp nz, 2130h if (((u8Flags & 0x40) >> 6) != 1) { goto L2130; } // 22ca: inc a L22ca: Z80A = (UINT8) (Z80A + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); if ((Z80A & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80A == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 22cb: inc a Z80A = (UINT8) (Z80A + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); if ((Z80A & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80A == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 22cc: ld (4d01h), a mem[0x4d01] = Z80A; // 22cf: ld a, 01h Z80A = (UINT8) (1); // 22d1: ld (4db1h), a mem[0x4db1] = Z80A; // 22d4: call 1efeh Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x22; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xd7; goto L1efe; L22d7: // 22d7: rst 30h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x22; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xd8; goto L0030; L22db: // 22db: jr 022b9h goto L22b9; L22dd: // 22dd: ld a, (4d32h) Z80A = (UINT8) (mem[0x4d32]); { UINT16 u16Temp0; // 22e0: sub a, 2dh u16Temp0 = Z80A - 0x2d; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x2d))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x2d ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 22e2: jr z, 022b9h if (((u8Flags & 0x40) >> 6) == 1) { goto L22b9; } // 22e4: ld a, (4d00h) L22e4: Z80A = (UINT8) (mem[0x4d00]); // 22e7: ld (4dd2h), a mem[0x4dd2] = Z80A; // 22ea: ld a, (4d01h) Z80A = (UINT8) (mem[0x4d01]); { UINT16 u16Temp0; // 22ed: sub a, 08h u16Temp0 = Z80A - 0x08; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x08))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x08 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 22ef: ld (4dd3h), a mem[0x4dd3] = Z80A; // 22f2: jp 2130h goto L2130; L22f5: // 22f5: ld a, (4d32h) Z80A = (UINT8) (mem[0x4d32]); { UINT16 u16Temp0; // 22f8: sub a, 1eh u16Temp0 = Z80A - 0x1e; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x1e))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x1e ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 22fa: jr z, 022b9h if (((u8Flags & 0x40) >> 6) == 1) { goto L22b9; } L22fc: // 22fc: jr 022e4h goto L22e4; L22fe: // 22fe: xor a, a Z80A = (UINT8) (0); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 22ff: ld (4e08h), a mem[0x4e08] = Z80A; // 2302: rst 30h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x23; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x03; goto L0030; L2306: // 2306: ld hl, 4e04h Z80HL = (UINT16) (0x4e04); { UINT8 u8Temp0; // 2309: inc (hl) ; add 1 to level clared register mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 230a: ret goto returnInstruction; // 230b: ld hl, IRQEn // Main program start (reset) // 0 -> 5000 - 5007 (special registers) // irq off, sound off, flip off, etc. L230b: Z80HL = (UINT16) (0x5000); // 230e: ld b, 08h Z80B = (UINT8) (0x08); // 2310: xor a, a ; 0 -> a Z80A = (UINT8) (0); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2311: ld (hl), a L2311: mspacmanIndirectWrite8(Z80HL, Z80A); // 2312: inc l Z80L = (UINT8) (Z80L + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80L == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80L & 0x80) ? 0x80 : 0); if ((Z80L & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80L == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 2313: djnz 02311h Z80B = (UINT8) (Z80B - 1); if (Z80B != 0) { goto L2311; } // 2315: ld hl, 4000h // Clear screen // 40 -> 4000-43ff (Video RAM) Z80HL = (UINT16) (0x4000); // 2318: ld b, 04h Z80B = (UINT8) (0x04); // 231a: ld (Wdog), a ; kick the dog L231a: MSNothingWrite(0x50c0,Z80A); // 231d: ld (coinct), a ; kick coin counter? MSStuffWrite(0x5007,Z80A); // 2320: ld a, 40h Z80A = (UINT8) (0x40); // 2322: ld (hl), a L2322: mspacmanIndirectWrite8(Z80HL, Z80A); // 2323: inc l Z80L = (UINT8) (Z80L + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80L == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80L & 0x80) ? 0x80 : 0); if ((Z80L & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80L == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 2324: jr nz, 02322h ; loop if (((u8Flags & 0x40) >> 6) != 1) { goto L2322; } // 2326: inc h Z80H = (UINT8) (Z80H + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80H == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80H & 0x80) ? 0x80 : 0); if ((Z80H & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80H == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 2327: djnz 0231ah ; loop Z80B = (UINT8) (Z80B - 1); if (Z80B != 0) { goto L231a; } // 2329: ld b, 04h // 0f -> 4400 - 47ff (Color RAM) Z80B = (UINT8) (0x04); // 232b: ld (Wdog), a ; kick the dog L232b: MSNothingWrite(0x50c0,Z80A); // 232e: xor a, a ; 0 -> a Z80A = (UINT8) (0); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 232f: ld (coinct), a ; kick coin counter? MSStuffWrite(0x5007,Z80A); // 2332: ld a, 0fh Z80A = (UINT8) (0x0f); // 2334: ld (hl), a L2334: mspacmanIndirectWrite8(Z80HL, Z80A); // 2335: inc l Z80L = (UINT8) (Z80L + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80L == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80L & 0x80) ? 0x80 : 0); if ((Z80L & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80L == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 2336: jr nz, 02334h ; loop if (((u8Flags & 0x40) >> 6) != 1) { goto L2334; } // 2338: inc h Z80H = (UINT8) (Z80H + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80H == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80H & 0x80) ? 0x80 : 0); if ((Z80H & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80H == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 2339: djnz 0232bh ; loop Z80B = (UINT8) (Z80B - 1); if (Z80B != 0) { goto L232b; } // 233b: im 1 ; set interrupt mode 1 // test the interrupt hardware now Z80interruptMode = (UINT8) (1); // 233d: nop ; interrupt vector hardware not set // 233e: nop // 233f: nop // 2340: nop // 2341: xor a, a ; a = 0 // Pac's routine: Z80A = (UINT8) (0); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2342: ld (coinct), a ; clear coin counter MSStuffWrite(0x5007,Z80A); // 2345: inc a ; a = 1 (a++) Z80A = (UINT8) (Z80A + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); if ((Z80A & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80A == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 2346: ld (IRQEn), a ; Enable interrupts (pcb) MSStuffWrite(0x5000,Z80A); // 2349: ei ; Enable interrupts (cpu) Z80iff |= 0x01; Z80iff |= 0x02; s32CyclesRemaining = s32CyclesRemaining - 0x04; // 234a: halt ; WAIT for interrupt then jump 0x0038 Z80halted = 1; s32CyclesRemaining = s32CyclesRemaining - 0x04; if (s32CyclesRemaining >= 0) { s32CyclesRemaining = (s32CyclesRemaining - ((s32CyclesRemaining + 0x03) & 0xfffffffc)); } goto Exit234b; // 234b: ld (Wdog), a ; kick dog // main program init // perhaps a contiuation from 3295 L234b: MSNothingWrite(0x50c0,Z80A); // 234e: ld sp, 4fc0h ; set stack pointer Z80SP = (UINT16) (0x4fc0); // 2351: xor a, a // reset custom registers. Set them to 0 Z80A = (UINT8) (0); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2352: ld hl, IRQEn ; from $5000 Z80HL = (UINT16) (0x5000); // 2355: ld bc, 0808h ; for $0808 bytes Z80BC = (UINT16) (0x0808); // 2358: rst 08h ; disable all Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x23; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x59; goto L0008; L2359: // 2359: ld hl, 4c00h // clear ram Z80HL = (UINT16) (0x4c00); // 235c: ld b, 0beh Z80B = (UINT8) (0xbe); // 235e: rst 08h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x23; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x5f; goto L0008; L235f: // 235f: rst 08h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x23; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x60; goto L0008; L2360: // 2360: rst 08h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x23; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x61; goto L0008; L2361: // 2361: rst 08h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x23; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x62; goto L0008; L2362: // 2362: ld hl, V1Acc // clear sound registers, sprite positions Z80HL = (UINT16) (0x5040); // 2365: ld b, 40h Z80B = (UINT8) (0x40); // 2367: rst 08h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x23; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x68; goto L0008; L2368: // 2368: ld (Wdog), a ; kick dog MSNothingWrite(0x50c0,Z80A); // 236b: call 240dh ; clear color ram Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x23; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x6e; goto L240d; L236e: // 236e: ld (Wdog), a ; kick dog MSNothingWrite(0x50c0,Z80A); // 2371: ld b, 00h Z80B = (UINT8) (0); // 2373: call 23edh Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x23; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x76; goto L23ed; L2376: // 2376: ld (Wdog), a ; kick dog MSNothingWrite(0x50c0,Z80A); // 2379: ld hl, 4cc0h Z80HL = (UINT16) (0x4cc0); // 237c: ld (4c80h), hl mem[0x4c80] = Z80L; mem[0x4c81] = Z80H; // 237f: ld (4c82h), hl mem[0x4c82] = Z80L; mem[0x4c83] = Z80H; // 2382: ld a, 0ffh // 0xff -> 4cc0-4cff Z80A = (UINT8) (0xff); // 2384: ld b, 40h Z80B = (UINT8) (0x40); // 2386: rst 08h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x23; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x87; goto L0008; L2387: // 2387: ld a, 01h Z80A = (UINT8) (1); // 2389: ld (IRQEn), a ; enable interrupts MSStuffWrite(0x5000,Z80A); // 238c: ei ; enable interrupts Z80iff |= 0x01; Z80iff |= 0x02; s32CyclesRemaining = s32CyclesRemaining - 0x04; // 238d: ld hl, (4c82h) L238d: Z80L = (UINT8) (mem[0x4c82]); Z80H = (UINT8) (mem[0x4c83]); // 2390: ld a, (hl) Z80A = (UINT8) (mem[Z80HL]); // 2391: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // Replaced code from 0x2392-0x2394 with the following: if (Z80A & 0x80) { Z80PC = 0x238d; Z80clockticks += 45; Z80rCounter += 45; goto adjustTimingCounter; } // 2395: ld (hl), 0ffh mspacmanIndirectWrite8(Z80HL, 0xff); // 2397: inc l Z80L = (UINT8) (Z80L + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80L == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80L & 0x80) ? 0x80 : 0); if ((Z80L & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80L == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 2398: ld b, (hl) Z80B = (UINT8) (mem[Z80HL]); // 2399: ld (hl), 0ffh mspacmanIndirectWrite8(Z80HL, 0xff); // 239b: inc l Z80L = (UINT8) (Z80L + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80L == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80L & 0x80) ? 0x80 : 0); if ((Z80L & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80L == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 239c: jr nz, 023a0h if (((u8Flags & 0x40) >> 6) != 1) { goto L23a0; } // 239e: ld L, 0c0h Z80L = (UINT8) (0xc0); // 23a0: ld (4c82h), hl L23a0: mem[0x4c82] = Z80L; mem[0x4c83] = Z80H; // 23a3: ld hl, 238dh Z80HL = (UINT16) (0x238d); // 23a6: push hl Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80H; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80L; // 23a7: rst 20h ; where does it jmp from here? Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x23; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xa8; goto L0020; L23e8: // 23e8: ld hl, 4e04h Z80HL = (UINT16) (0x4e04); { UINT8 u8Temp0; // 23eb: inc (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 23ec: ret goto returnInstruction; // 23ed: ld a, b // subroutine L23ed: Z80A = (UINT8) (Z80B); // 23ee: rst 20h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x23; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xef; goto L0020; L23f3: // 23f3: ld a, 40h Z80A = (UINT8) (0x40); // 23f5: ld bc, 0004h Z80BC = (UINT16) (0x04); // 23f8: ld hl, 4000h ; start of video ram Z80HL = (UINT16) (0x4000); // 23fb: rst 08h L23fb: Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x23; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xfc; goto L0008; L23fc: // 23fc: dec c Z80C = (UINT8) (Z80C - 1); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((Z80C == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80C & 0x80) ? 0x80 : 0); if ((Z80C & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80C == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 23fd: jr nz, 023fbh if (((u8Flags & 0x40) >> 6) != 1) { goto L23fb; } // 23ff: ret goto returnInstruction; L2400: // 2400: ld a, 40h // set video ram to 0x40 ; just before boxes Z80A = (UINT8) (0x40); // 2402: ld hl, 4040h Z80HL = (UINT16) (0x4040); // 2405: ld bc, 8004h Z80BC = (UINT16) (0x8004); // 2408: rst 08h L2408: Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x24; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x09; goto L0008; L2409: // 2409: dec c Z80C = (UINT8) (Z80C - 1); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((Z80C == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80C & 0x80) ? 0x80 : 0); if ((Z80C & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80C == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 240a: jr nz, 02408h if (((u8Flags & 0x40) >> 6) != 1) { goto L2408; } // 240c: ret goto returnInstruction; // 240d: xor a, a // set color ram to 0x00 L240d: Z80A = (UINT8) (0); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 240e: ld bc, 0004h Z80BC = (UINT16) (0x04); // 2411: ld hl, 4400h ; start of color ram Z80HL = (UINT16) (0x4400); // 2414: rst 08h L2414: Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x24; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x15; goto L0008; L2415: // 2415: dec c Z80C = (UINT8) (Z80C - 1); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((Z80C == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80C & 0x80) ? 0x80 : 0); if ((Z80C & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80C == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 2416: jr nz, 02414h if (((u8Flags & 0x40) >> 6) != 1) { goto L2414; } // 2418: ret goto returnInstruction; L2419: // 2419: ld hl, 4000h ; start of video ram // this is probably the routine that draws the power pellets on // the screen. It calls 94ec, which probably draws the pellets // in the proper locations according to the ms-pac mazes. // Draw out the maze to the screen Z80HL = (UINT16) (0x4000); // 241c: call 946ah ; patch to retreive map info Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x24; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x1f; goto L946a; // 241f: ld a, (bc) ; get data L241f: Z80A = (UINT8) (mem[Z80BC]); // 2420: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2421: ret z ; 0 is the end of the level data if (((u8Flags & 0x40) >> 6) == 1) { goto returnInstruction; } // 2422: jp m, 242ch ; if it's < 0x80, data is an offset if (((u8Flags & 0x80) >> 7) == 1) { goto L242c; } // 2425: ld e, a Z80E = (UINT8) (Z80A); // 2426: ld d, 00h Z80D = (UINT8) (0); { UINT32 u32Temp0; // 2428: add hl, de ; adjust VRAM pointer u32Temp0 = Z80HL + Z80DE; u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80DE) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 2429: dec hl Z80HL = (UINT16) (Z80HL - 1); // 242a: inc bc ; point to next data Z80BC = (UINT16) (Z80BC + 1); // 242b: ld a, (bc) ; load data and store in VRAM Z80A = (UINT8) (mem[Z80BC]); // 242c: inc hl L242c: Z80HL = (UINT16) (Z80HL + 1); // 242d: ld (hl), a mspacmanIndirectWrite8(Z80HL, Z80A); // 242e: push af Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80A; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = u8Flags; // 242f: push hl Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80H; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80L; // 2430: ld de, 83e0h ; calculate mirror position Z80DE = (UINT16) (0x83e0); // 2433: ld a, l Z80A = (UINT8) (Z80L); // 2434: and a, 1fh Z80A = (UINT8) (Z80A & 0x1f); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); { UINT16 u16Temp0; // 2436: add a, a u16Temp0 = Z80A + Z80A; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80A))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80A ^ Z80A ^ 0x80) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 2437: ld h, 00h Z80H = (UINT8) (0); // 2439: ld l, a Z80L = (UINT8) (Z80A); { UINT32 u32Temp0; // 243a: add hl, de u32Temp0 = Z80HL + Z80DE; u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80DE) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 243b: pop de Z80E = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); Z80D = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); // 243c: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); { UINT32 u32Temp0; // 243d: sbc hl, de u32Temp0 = (Z80HL - Z80DE - ((u8Flags & 0x01) >> 0)); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80DE) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | (((((Z80DE ^ Z80HL) & (Z80HL ^ u32Temp0) & 0x8000))) ? 0x04 : 0); Z80HL = (UINT16) (u32Temp0); u8Flags = (u8Flags & ~0x40) | ((Z80HL == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80HL & 0x8000) ? 0x80 : 0); u8Flags |= 0x02; } // 243f: pop af u8Flags = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); Z80A = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); // 2440: xor a, 01h ; calculate reflected title Z80A = (UINT8) (Z80A ^ 1); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2442: ld (hl), a ; store reflected title in position mspacmanIndirectWrite8(Z80HL, Z80A); { UINT16 u16Temp0; // 2443: ex de, hl u16Temp0 = Z80HL; Z80HL = (UINT16) (Z80DE); Z80DE = (UINT16) (u16Temp0); } // 2444: inc bc ; next data Z80BC = (UINT16) (Z80BC + 1); // 2445: jp 241fh ; keep going goto L241f; L2448: // 2448: ld hl, 4000h ; start of video ram // draw out the player pills Z80HL = (UINT16) (0x4000); // 244b: jp 947ch ; patch goto L947c; L244e: // 244e: ld c, (hl) ; junk Z80C = (UINT8) (mem[Z80HL]); // 244f: ld iy, 35b5h ; points to pill data Z80IY = (UINT16) (0x35b5); L2453: // 2453: ld d, 00h Z80D = (UINT8) (0); // 2455: ld b, 1eh ; total # pills entries Z80B = (UINT8) (0x1e); // 2457: ld c, 08h ; 8x L2457: Z80C = (UINT8) (0x08); // 2459: ld a, (ix+00h) ; get current pill entry Z80A = (UINT8) (mem[Z80IX]); // 245c: ld e, (iy+00h) ; get current offset L245c: Z80E = (UINT8) (mem[Z80IY]); { UINT32 u32Temp0; // 245f: add hl, de ; adjust vram u32Temp0 = Z80HL + Z80DE; u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80DE) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 2460: rlca ; get current byte u8Flags = (u8Flags & ~0x01) | ((Z80A & 0x80) ? 0x01 : 0); Z80A = (UINT8) (((Z80A << 1) | (Z80A >> 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 2461: jr nc, 02465h ; skip pill if no carry if (((u8Flags & 0x01) >> 0) != 1) { goto L2465; } // 2463: ld (hl), 10h ; draw pill mspacmanIndirectWrite8(Z80HL, 0x10); // 2465: inc iy ; next entry L2465: Z80IY = (UINT16) (Z80IY + 1); // 2467: dec c Z80C = (UINT8) (Z80C - 1); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((Z80C == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80C & 0x80) ? 0x80 : 0); if ((Z80C & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80C == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 2468: jr nz, 0245ch ; keep testing all the bits if (((u8Flags & 0x40) >> 6) != 1) { goto L245c; } // 246a: inc ix ; go to next pill entry Z80IX = (UINT16) (Z80IX + 1); // 246c: dec b Z80B = (UINT8) (Z80B - 1); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((Z80B == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80B & 0x80) ? 0x80 : 0); if ((Z80B & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80B == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 246d: jr nz, 02457h ; keep drawing pills if (((u8Flags & 0x40) >> 6) != 1) { goto L2457; } // 246f: ld hl, brdno2 ; copy big pill Z80HL = (UINT16) (0x4e34); // 2472: jp 94ech ; pellet check routine goto L94ec; L2475: // 2475: ldi // pac's version: // junk: mspacmanIndirectWrite8(Z80DE, mem[Z80HL]); Z80HL = (UINT16) (Z80HL + 1); Z80DE = (UINT16) (Z80DE + 1); Z80BC = (UINT16) (Z80BC - 1); u8Flags &= 0xef; u8Flags &= 0xfd; if (Z80BC == 0) { u8Flags &= 0xfb; } else { u8Flags |= 0x04; } // 2477: ld de, 4078h ; power pellet address (lower right) Z80DE = (UINT16) (0x4078); // 247a: ldi mspacmanIndirectWrite8(Z80DE, mem[Z80HL]); Z80HL = (UINT16) (Z80HL + 1); Z80DE = (UINT16) (Z80DE + 1); Z80BC = (UINT16) (Z80BC - 1); u8Flags &= 0xef; u8Flags &= 0xfd; if (Z80BC == 0) { u8Flags &= 0xfb; } else { u8Flags |= 0x04; } // 247c: ld de, 4384h ; power pellet address (upper left) Z80DE = (UINT16) (0x4384); // 247f: ldi mspacmanIndirectWrite8(Z80DE, mem[Z80HL]); Z80HL = (UINT16) (Z80HL + 1); Z80DE = (UINT16) (Z80DE + 1); Z80BC = (UINT16) (Z80BC - 1); u8Flags &= 0xef; u8Flags &= 0xfd; if (Z80BC == 0) { u8Flags &= 0xfb; } else { u8Flags |= 0x04; } // 2481: ld de, 4398h ; power pellet address (lower left) Z80DE = (UINT16) (0x4398); // 2484: ldi mspacmanIndirectWrite8(Z80DE, mem[Z80HL]); Z80HL = (UINT16) (Z80HL + 1); Z80DE = (UINT16) (Z80DE + 1); Z80BC = (UINT16) (Z80BC - 1); u8Flags &= 0xef; u8Flags &= 0xfd; if (Z80BC == 0) { u8Flags &= 0xfb; } else { u8Flags |= 0x04; } // 2486: ret goto returnInstruction; // 2487: ld hl, 4000h ; start of work ram // update the current screen pill config to work ram L2487: Z80HL = (UINT16) (0x4000); // 248a: jp 9481h goto L9481; L248d: // 248d: ld c, (hl) Z80C = (UINT8) (mem[Z80HL]); // 248e: ld iy, 35b5h ; start of some data // pac's version: Z80IY = (UINT16) (0x35b5); L2492: // 2492: ld d, 00h Z80D = (UINT8) (0); // 2494: ld b, 1eh Z80B = (UINT8) (0x1e); // 2496: ld c, 08h L2496: Z80C = (UINT8) (0x08); // 2498: ld e, (iy+00h) L2498: Z80E = (UINT8) (mem[Z80IY]); { UINT32 u32Temp0; // 249b: add hl, de u32Temp0 = Z80HL + Z80DE; u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80DE) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 249c: ld a, (hl) Z80A = (UINT8) (mem[Z80HL]); { UINT16 u16Temp0; // 249d: cp a, 10h u16Temp0 = Z80A - 0x10; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x10))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x10 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 249f: scf u8Flags |= 0x01; u8Flags &= 0xfd; u8Flags &= 0xef; // 24a0: jr z, 024a3h if (((u8Flags & 0x40) >> 6) == 1) { goto L24a3; } // 24a2: ccf u8Flags = (u8Flags & ~0x10) | ((((u8Flags & 0x01) >> 0)) ? 0x10 : 0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x01) | ((((u8Flags & 0x01) >> 0) ^ 1) ? 0x01 : 0); { UINT8 u8Temp0; // 24a3: rl (ix+00h) L24a3: u8Temp0 = mem[Z80IX]; mspacmanIndirectWrite8(Z80IX, (u8Temp0 << 1) | ((u8Flags & 0x01) >> 0)); u8Flags = (u8Flags & ~0x01) | ((u8Temp0 & 0x80) ? 0x01 : 0); u8Temp0 = mem[Z80IX]; u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags &= 0xef; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x04) | (((((((u8Temp0 >> 0x07) & 1) + ((u8Temp0 >> 0x06) & 1) + ((u8Temp0 >> 0x05) & 1) + ((u8Temp0 >> 0x04) & 1) + ((u8Temp0 >> 0x03) & 1) + ((u8Temp0 >> 0x02) & 1) + ((u8Temp0 >> 1) & 1) + ((u8Temp0 >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); } // 24a7: inc iy Z80IY = (UINT16) (Z80IY + 1); // 24a9: dec c Z80C = (UINT8) (Z80C - 1); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((Z80C == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80C & 0x80) ? 0x80 : 0); if ((Z80C & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80C == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 24aa: jr nz, 02498h if (((u8Flags & 0x40) >> 6) != 1) { goto L2498; } // 24ac: inc ix Z80IX = (UINT16) (Z80IX + 1); // 24ae: dec b Z80B = (UINT8) (Z80B - 1); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((Z80B == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80B & 0x80) ? 0x80 : 0); if ((Z80B & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80B == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 24af: jr nz, 02496h if (((u8Flags & 0x40) >> 6) != 1) { goto L2496; } // 24b1: ld hl, 4064h ; power pellet address Z80HL = (UINT16) (0x4064); // 24b4: jp 9504h ; pellet check routine goto L9504; // 24c9: ld hl, 4e16h L24c9: Z80HL = (UINT16) (0x4e16); // 24cc: ld a, 0ffh Z80A = (UINT8) (0xff); // 24ce: ld b, 1eh Z80B = (UINT8) (0x1e); // 24d0: rst 08h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x24; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xd1; goto L0008; L24d1: // 24d1: ld a, 14h Z80A = (UINT8) (0x14); // 24d3: ld b, 04h Z80B = (UINT8) (0x04); // 24d5: rst 08h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x24; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xd6; goto L0008; L24d6: // 24d6: ret goto returnInstruction; L24d7: // 24d7: ld e, b // sets up the maze color Z80E = (UINT8) (Z80B); // 24d8: ld a, b Z80A = (UINT8) (Z80B); { UINT16 u16Temp0; // 24d9: cp a, 02h u16Temp0 = Z80A - 0x02; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x02))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x02 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 24db: ld a, 1fh Z80A = (UINT8) (0x1f); // 24dd: jp 9580h goto L9580; // 24e1: ld hl, 4440h ; draw color to screen L24e1: Z80HL = (UINT16) (0x4440); // 24e4: ld bc, 8004h Z80BC = (UINT16) (0x8004); // 24e7: rst 08h L24e7: Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x24; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xe8; goto L0008; L24e8: // 24e8: dec c Z80C = (UINT8) (Z80C - 1); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((Z80C == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80C & 0x80) ? 0x80 : 0); if ((Z80C & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80C == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 24e9: jr nz, 024e7h if (((u8Flags & 0x40) >> 6) != 1) { goto L24e7; } // 24eb: ld a, 0fh Z80A = (UINT8) (0x0f); // 24ed: ld b, 40h Z80B = (UINT8) (0x40); // 24ef: ld hl, 47c0h Z80HL = (UINT16) (0x47c0); // 24f2: rst 08h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x24; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xf3; goto L0008; L24f3: // 24f3: ld a, e Z80A = (UINT8) (Z80E); { UINT16 u16Temp0; // 24f4: cp a, 01h u16Temp0 = Z80A - 1; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 1))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((1 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 24f6: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 24f7: ld a, 1ah Z80A = (UINT8) (0x1a); // 24f9: jp 95c3h goto L95c3; // 2534: ld a, 18h L2534: Z80A = (UINT8) (0x18); // 2536: ld (45edh), a MSPacVideoWrite(0x45ed,Z80A); // 2539: ld (460dh), a MSPacVideoWrite(0x460d,Z80A); // 253c: ret goto returnInstruction; L253d: // 253d: ld ix, 4c00h // this is strange... possibly data of some kind? Z80IX = (UINT16) (0x4c00); // 2541: ld (ix+02h), 20h mspacmanIndirectWrite8(Z80IX + 0x02, 0x20); // 2545: ld (ix+04h), 20h mspacmanIndirectWrite8(Z80IX + 0x04, 0x20); // 2549: ld (ix+06h), 20h mspacmanIndirectWrite8(Z80IX + 0x06, 0x20); // 254d: ld (ix+08h), 20h mspacmanIndirectWrite8(Z80IX + 0x08, 0x20); // 2551: ld (ix+0ah), 2ch mspacmanIndirectWrite8(Z80IX + 0x0a, 0x2c); // 2555: ld (ix+0ch), 3fh mspacmanIndirectWrite8(Z80IX + 0x0c, 0x3f); // 2559: ld (ix+03h), 01h mspacmanIndirectWrite8(Z80IX + 0x03, 1); // 255d: ld (ix+05h), 03h mspacmanIndirectWrite8(Z80IX + 0x05, 0x03); // 2561: ld (ix+07h), 05h mspacmanIndirectWrite8(Z80IX + 0x07, 0x05); // 2565: ld (ix+09h), 07h mspacmanIndirectWrite8(Z80IX + 0x09, 0x07); // 2569: ld (ix+0bh), 09h mspacmanIndirectWrite8(Z80IX + 0x0b, 0x09); // 256d: ld (ix+0dh), 00h mspacmanIndirectWrite8(Z80IX + 0x0d, 0); // 2571: ld a, b Z80A = (UINT8) (Z80B); // 2572: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2573: jp nz, 260fh if (((u8Flags & 0x40) >> 6) != 1) { goto L260f; } // 2576: ld hl, 8064h Z80HL = (UINT16) (0x8064); // 2579: ld (4d00h), hl mem[0x4d00] = Z80L; mem[0x4d01] = Z80H; // 257c: ld hl, 807ch Z80HL = (UINT16) (0x807c); // 257f: ld (4d02h), hl mem[0x4d02] = Z80L; mem[0x4d03] = Z80H; // 2582: ld hl, 907ch Z80HL = (UINT16) (0x907c); // 2585: ld (4d04h), hl mem[0x4d04] = Z80L; mem[0x4d05] = Z80H; // 2588: ld hl, 707ch Z80HL = (UINT16) (0x707c); // 258b: ld (4d06h), hl mem[0x4d06] = Z80L; mem[0x4d07] = Z80H; // 258e: ld hl, 80c4h Z80HL = (UINT16) (0x80c4); // 2591: ld (4d08h), hl mem[0x4d08] = Z80L; mem[0x4d09] = Z80H; // 2594: ld hl, 2e2ch Z80HL = (UINT16) (0x2e2c); // 2597: ld (4d0ah), hl mem[0x4d0a] = Z80L; mem[0x4d0b] = Z80H; // 259a: ld (4d31h), hl mem[0x4d31] = Z80L; mem[0x4d32] = Z80H; // 259d: ld hl, 2e2fh Z80HL = (UINT16) (0x2e2f); // 25a0: ld (4d0ch), hl mem[0x4d0c] = Z80L; mem[0x4d0d] = Z80H; // 25a3: ld (4d33h), hl mem[0x4d33] = Z80L; mem[0x4d34] = Z80H; // 25a6: ld hl, 302fh Z80HL = (UINT16) (0x302f); // 25a9: ld (4d0eh), hl mem[0x4d0e] = Z80L; mem[0x4d0f] = Z80H; // 25ac: ld (4d35h), hl mem[0x4d35] = Z80L; mem[0x4d36] = Z80H; // 25af: ld hl, 2c2fh Z80HL = (UINT16) (0x2c2f); // 25b2: ld (4d10h), hl mem[0x4d10] = Z80L; mem[0x4d11] = Z80H; // 25b5: ld (4d37h), hl mem[0x4d37] = Z80L; mem[0x4d38] = Z80H; // 25b8: ld hl, 2e38h Z80HL = (UINT16) (0x2e38); // 25bb: ld (4d12h), hl mem[0x4d12] = Z80L; mem[0x4d13] = Z80H; // 25be: ld (4d39h), hl mem[0x4d39] = Z80L; mem[0x4d3a] = Z80H; // 25c1: ld hl, 0100h Z80HL = (UINT16) (0x0100); // 25c4: ld (4d14h), hl mem[0x4d14] = Z80L; mem[0x4d15] = Z80H; // 25c7: ld (4d1eh), hl mem[0x4d1e] = Z80L; mem[0x4d1f] = Z80H; // 25ca: ld hl, 0001h Z80HL = (UINT16) (1); // 25cd: ld (4d16h), hl mem[0x4d16] = Z80L; mem[0x4d17] = Z80H; // 25d0: ld (4d20h), hl mem[0x4d20] = Z80L; mem[0x4d21] = Z80H; // 25d3: ld hl, 00ffh Z80HL = (UINT16) (0xff); // 25d6: ld (4d18h), hl mem[0x4d18] = Z80L; mem[0x4d19] = Z80H; // 25d9: ld (4d22h), hl mem[0x4d22] = Z80L; mem[0x4d23] = Z80H; // 25dc: ld hl, 00ffh Z80HL = (UINT16) (0xff); // 25df: ld (4d1ah), hl mem[0x4d1a] = Z80L; mem[0x4d1b] = Z80H; // 25e2: ld (4d24h), hl mem[0x4d24] = Z80L; mem[0x4d25] = Z80H; // 25e5: ld hl, 0100h Z80HL = (UINT16) (0x0100); // 25e8: ld (4d1ch), hl mem[0x4d1c] = Z80L; mem[0x4d1d] = Z80H; // 25eb: ld (4d26h), hl mem[0x4d26] = Z80L; mem[0x4d27] = Z80H; // 25ee: ld hl, 0102h Z80HL = (UINT16) (0x0102); // 25f1: ld (4d28h), hl mem[0x4d28] = Z80L; mem[0x4d29] = Z80H; // 25f4: ld (4d2ch), hl mem[0x4d2c] = Z80L; mem[0x4d2d] = Z80H; // 25f7: ld hl, 0303h Z80HL = (UINT16) (0x0303); // 25fa: ld (4d2ah), hl mem[0x4d2a] = Z80L; mem[0x4d2b] = Z80H; // 25fd: ld (4d2eh), hl mem[0x4d2e] = Z80L; mem[0x4d2f] = Z80H; // 2600: ld a, 02h Z80A = (UINT8) (0x02); // 2602: ld (4d30h), a mem[0x4d30] = Z80A; // 2605: ld (4d3ch), a mem[0x4d3c] = Z80A; // 2608: ld hl, 0000h Z80HL = (UINT16) (0); // 260b: ld (4dd2h), hl mem[0x4dd2] = Z80L; mem[0x4dd3] = Z80H; // 260e: ret goto returnInstruction; // 260f: ld hl, 0094h L260f: Z80HL = (UINT16) (0x94); // 2612: ld (4d00h), hl mem[0x4d00] = Z80L; mem[0x4d01] = Z80H; // 2615: ld (4d02h), hl mem[0x4d02] = Z80L; mem[0x4d03] = Z80H; // 2618: ld (4d04h), hl mem[0x4d04] = Z80L; mem[0x4d05] = Z80H; // 261b: ld (4d06h), hl mem[0x4d06] = Z80L; mem[0x4d07] = Z80H; // 261e: ld hl, 1e32h Z80HL = (UINT16) (0x1e32); // 2621: ld (4d0ah), hl mem[0x4d0a] = Z80L; mem[0x4d0b] = Z80H; // 2624: ld (4d0ch), hl mem[0x4d0c] = Z80L; mem[0x4d0d] = Z80H; // 2627: ld (4d0eh), hl mem[0x4d0e] = Z80L; mem[0x4d0f] = Z80H; // 262a: ld (4d10h), hl mem[0x4d10] = Z80L; mem[0x4d11] = Z80H; // 262d: ld (4d31h), hl mem[0x4d31] = Z80L; mem[0x4d32] = Z80H; // 2630: ld (4d33h), hl mem[0x4d33] = Z80L; mem[0x4d34] = Z80H; // 2633: ld (4d35h), hl mem[0x4d35] = Z80L; mem[0x4d36] = Z80H; // 2636: ld (4d37h), hl mem[0x4d37] = Z80L; mem[0x4d38] = Z80H; // 2639: ld hl, 0100h Z80HL = (UINT16) (0x0100); // 263c: ld (4d14h), hl mem[0x4d14] = Z80L; mem[0x4d15] = Z80H; // 263f: ld (4d16h), hl mem[0x4d16] = Z80L; mem[0x4d17] = Z80H; // 2642: ld (4d18h), hl mem[0x4d18] = Z80L; mem[0x4d19] = Z80H; // 2645: ld (4d1ah), hl mem[0x4d1a] = Z80L; mem[0x4d1b] = Z80H; // 2648: ld (4d1eh), hl mem[0x4d1e] = Z80L; mem[0x4d1f] = Z80H; // 264b: ld (4d20h), hl mem[0x4d20] = Z80L; mem[0x4d21] = Z80H; // 264e: ld (4d22h), hl mem[0x4d22] = Z80L; mem[0x4d23] = Z80H; // 2651: ld (4d24h), hl mem[0x4d24] = Z80L; mem[0x4d25] = Z80H; // 2654: ld (4d1ch), hl mem[0x4d1c] = Z80L; mem[0x4d1d] = Z80H; // 2657: ld (4d26h), hl mem[0x4d26] = Z80L; mem[0x4d27] = Z80H; // 265a: ld hl, 4d28h Z80HL = (UINT16) (0x4d28); // 265d: ld a, 02h Z80A = (UINT8) (0x02); // 265f: ld b, 09h Z80B = (UINT8) (0x09); // 2661: rst 08h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x26; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x62; goto L0008; L2662: // 2662: ld (4d3ch), a mem[0x4d3c] = Z80A; // 2665: ld hl, 0894h Z80HL = (UINT16) (0x0894); // 2668: ld (4d08h), hl mem[0x4d08] = Z80L; mem[0x4d09] = Z80H; // 266b: ld hl, 1f32h Z80HL = (UINT16) (0x1f32); // 266e: ld (4d12h), hl mem[0x4d12] = Z80L; mem[0x4d13] = Z80H; // 2671: ld (4d39h), hl mem[0x4d39] = Z80L; mem[0x4d3a] = Z80H; // 2674: ret goto returnInstruction; // 2675: ld hl, 0000h L2675: Z80HL = (UINT16) (0); // 2678: ld (4dd2h), hl mem[0x4dd2] = Z80L; mem[0x4dd3] = Z80H; // 267b: ld (4d08h), hl mem[0x4d08] = Z80L; mem[0x4d09] = Z80H; // 267e: ld (4d00h), hl L267e: mem[0x4d00] = Z80L; mem[0x4d01] = Z80H; // 2681: ld (4d02h), hl mem[0x4d02] = Z80L; mem[0x4d03] = Z80H; // 2684: ld (4d04h), hl mem[0x4d04] = Z80L; mem[0x4d05] = Z80H; // 2687: ld (4d06h), hl mem[0x4d06] = Z80L; mem[0x4d07] = Z80H; // 268a: ret goto returnInstruction; L268b: // 268b: ld a, 55h Z80A = (UINT8) (0x55); // 268d: ld (4d94h), a mem[0x4d94] = Z80A; // 2690: dec b Z80B = (UINT8) (Z80B - 1); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((Z80B == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80B & 0x80) ? 0x80 : 0); if ((Z80B & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80B == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 2691: ret z if (((u8Flags & 0x40) >> 6) == 1) { goto returnInstruction; } // 2692: ld a, 01h Z80A = (UINT8) (1); // 2694: ld (4da0h), a mem[0x4da0] = Z80A; // 2697: ret goto returnInstruction; L2698: // 2698: ld a, 01h ; set intro mode Z80A = (UINT8) (1); // 269a: ld (4e00h), a mem[0x4e00] = Z80A; // 269d: xor a, a Z80A = (UINT8) (0); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 269e: ld (4e01h), a mem[0x4e01] = Z80A; // 26a1: ret goto returnInstruction; L26a2: // 26a2: xor a, a Z80A = (UINT8) (0); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 26a3: ld de, 4d00h Z80DE = (UINT16) (0x4d00); // 26a6: ld hl, 4e00h ; game mode L26a6: Z80HL = (UINT16) (0x4e00); // 26a9: ld (de), a mspacmanIndirectWrite8(Z80DE, Z80A); // 26aa: inc de Z80DE = (UINT16) (Z80DE + 1); // 26ab: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); { UINT32 u32Temp0; // 26ac: sbc hl, de u32Temp0 = (Z80HL - Z80DE - ((u8Flags & 0x01) >> 0)); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80DE) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | (((((Z80DE ^ Z80HL) & (Z80HL ^ u32Temp0) & 0x8000))) ? 0x04 : 0); Z80HL = (UINT16) (u32Temp0); u8Flags = (u8Flags & ~0x40) | ((Z80HL == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80HL & 0x8000) ? 0x80 : 0); u8Flags |= 0x02; } // 26ae: jp nz, 26a6h if (((u8Flags & 0x40) >> 6) != 1) { goto L26a6; } L26b1: // 26b1: ret goto returnInstruction; L26b2: // 26b2: ld ix, 4136h Z80IX = (UINT16) (0x4136); // 26b6: ld a, (bonusk) Z80A = (UINT8) (mem[0x4e71]); // 26b9: and a, 0fh Z80A = (UINT8) (Z80A & 0x0f); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); { UINT16 u16Temp0; // 26bb: add a, 30h u16Temp0 = Z80A + 0x30; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x30))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x30 ^ Z80A ^ 0x80) & (0x30 ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 26bd: ld (ix+00h), a mspacmanIndirectWrite8(Z80IX, Z80A); // 26c0: ld a, (bonusk) Z80A = (UINT8) (mem[0x4e71]); // 26c3: rrca u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (((Z80A >> 1) | (Z80A << 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 26c4: rrca u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (((Z80A >> 1) | (Z80A << 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 26c5: rrca u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (((Z80A >> 1) | (Z80A << 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 26c6: rrca u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (((Z80A >> 1) | (Z80A << 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 26c7: and a, 0fh Z80A = (UINT8) (Z80A & 0x0f); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 26c9: ret z if (((u8Flags & 0x40) >> 6) == 1) { goto returnInstruction; } { UINT16 u16Temp0; // 26ca: add a, 30h u16Temp0 = Z80A + 0x30; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x30))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x30 ^ Z80A ^ 0x80) & (0x30 ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 26cc: ld (ix+20h), a mspacmanIndirectWrite8(Z80IX + 0x20, Z80A); // 26cf: ret goto returnInstruction; L26d0: // 26d0: ld a, (5080h) ; check in0 for free play Z80A = (UINT8) (mem[0x5080]); // 26d3: ld b, a Z80B = (UINT8) (Z80A); // 26d4: and a, 03h ; free play switch Z80A = (UINT8) (Z80A & 0x03); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 26d6: jp nz, 26deh if (((u8Flags & 0x40) >> 6) != 1) { goto L26de; } // 26d9: ld hl, credits ; credit memory Z80HL = (UINT16) (0x4e6e); // 26dc: ld (hl), 0ffh ; store $FF for free play mspacmanIndirectWrite8(Z80HL, 0xff); // 26de: ld c, a L26de: Z80C = (UINT8) (Z80A); { UINT8 u8Temp0; // 26df: rra u8Temp0 = ((u8Flags & 0x01) >> 0) << 0x07; u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (((Z80A >> 1) | u8Temp0)); u8Flags &= 0xfd; u8Flags &= 0xef; } { UINT16 u16Temp0; // 26e0: adc a, 00h u16Temp0 = Z80A + ((u8Flags & 0x01) >> 0); u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0 ^ Z80A ^ 0x80) & (0 ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 26e2: ld (xcoin), a mem[0x4e6b] = Z80A; // 26e5: and a, 02h Z80A = (UINT8) (Z80A & 0x02); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 26e7: xor a, c Z80A = (UINT8) (Z80A ^ Z80C); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 26e8: ld (xcred), a mem[0x4e6d] = Z80A; // 26eb: ld a, b Z80A = (UINT8) (Z80B); // 26ec: rrca u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (((Z80A >> 1) | (Z80A << 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 26ed: rrca u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (((Z80A >> 1) | (Z80A << 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 26ee: and a, 03h Z80A = (UINT8) (Z80A & 0x03); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 26f0: inc a Z80A = (UINT8) (Z80A + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); if ((Z80A & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80A == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } { UINT16 u16Temp0; // 26f1: cp a, 04h u16Temp0 = Z80A - 0x04; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x04))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x04 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 26f3: jr nz, 026f6h if (((u8Flags & 0x40) >> 6) != 1) { goto L26f6; } // 26f5: inc a Z80A = (UINT8) (Z80A + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); if ((Z80A & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80A == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 26f6: ld (inlives), a L26f6: mem[0x4e6f] = Z80A; // 26f9: ld a, b Z80A = (UINT8) (Z80B); // 26fa: rrca u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (((Z80A >> 1) | (Z80A << 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 26fb: rrca u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (((Z80A >> 1) | (Z80A << 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 26fc: rrca u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (((Z80A >> 1) | (Z80A << 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 26fd: rrca u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (((Z80A >> 1) | (Z80A << 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 26fe: and a, 03h Z80A = (UINT8) (Z80A & 0x03); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2700: ld hl, 2728h Z80HL = (UINT16) (0x2728); // 2703: rst 10h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x27; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x04; goto L0010; L2704: // 2704: ld (bonusk), a mem[0x4e71] = Z80A; // 2707: ld a, b Z80A = (UINT8) (Z80B); // 2708: rlca u8Flags = (u8Flags & ~0x01) | ((Z80A & 0x80) ? 0x01 : 0); Z80A = (UINT8) (((Z80A << 1) | (Z80A >> 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 2709: cpl Z80A = (UINT8) (Z80A ^ 0xff); u8Flags |= 0x10; u8Flags |= 0x02; // 270a: and a, 01h Z80A = (UINT8) (Z80A & 1); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 270c: ld (4e75h), a mem[0x4e75] = Z80A; // 270f: ld a, b Z80A = (UINT8) (Z80B); // 2710: rlca u8Flags = (u8Flags & ~0x01) | ((Z80A & 0x80) ? 0x01 : 0); Z80A = (UINT8) (((Z80A << 1) | (Z80A >> 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 2711: rlca u8Flags = (u8Flags & ~0x01) | ((Z80A & 0x80) ? 0x01 : 0); Z80A = (UINT8) (((Z80A << 1) | (Z80A >> 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 2712: cpl Z80A = (UINT8) (Z80A ^ 0xff); u8Flags |= 0x10; u8Flags |= 0x02; // 2713: and a, 01h Z80A = (UINT8) (Z80A & 1); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2715: ld b, a Z80B = (UINT8) (Z80A); // 2716: ld hl, 272ch Z80HL = (UINT16) (0x272c); // 2719: rst 18h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x27; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x1a; goto L0018; L271a: // 271a: ld (difftyp), hl ; difficulty mem[0x4e73] = Z80L; mem[0x4e74] = Z80H; // 271d: ld a, (V1Acc) ; check in1 Z80A = (UINT8) (mem[0x5040]); // 2720: rlca u8Flags = (u8Flags & ~0x01) | ((Z80A & 0x80) ? 0x01 : 0); Z80A = (UINT8) (((Z80A << 1) | (Z80A >> 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 2721: cpl Z80A = (UINT8) (Z80A ^ 0xff); u8Flags |= 0x10; u8Flags |= 0x02; // 2722: and a, 01h Z80A = (UINT8) (Z80A & 1); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2724: ld (cabtype), a mem[0x4e72] = Z80A; // 2727: ret goto returnInstruction; L2730: // 2730: ld a, (4dc1h) ; 0= random movement 1= normal movement // red ghost logic: Z80A = (UINT8) (mem[0x4dc1]); // 2733: bit 0, a u8Flags = (u8Flags & ~0x40) | ((((Z80A & 1) == 0)) ? 0x40 : 0); u8Flags |= 0x10; u8Flags &= 0xfd; // 2735: jp nz, 2758h ; get norm red movement if (((u8Flags & 0x40) >> 6) != 1) { goto L2758; } // 2738: ld a, (4db6h) ; 0=normal 1= faster ghost,most dots Z80A = (UINT8) (mem[0x4db6]); // 273b: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 273c: jr nz, 02758h ; get norm red direction (below) if (((u8Flags & 0x40) >> 6) != 1) { goto L2758; } // 273e: ld a, (4e04h) ; 3=ghost move, 2=ghost wait for start Z80A = (UINT8) (mem[0x4e04]); { UINT16 u16Temp0; // 2741: cp a, 03h u16Temp0 = Z80A - 0x03; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x03))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x03 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 2743: jr nz, 02758h ; get norm red direction (below) if (((u8Flags & 0x40) >> 6) != 1) { goto L2758; } // 2745: ld hl, (4d0ah) ; read red ghost location YY XX Z80L = (UINT8) (mem[0x4d0a]); Z80H = (UINT8) (mem[0x4d0b]); // 2748: ld a, (4d2ch) ; read direction Z80A = (UINT8) (mem[0x4d2c]); // 274b: call 9561h ; pick a quadrant for the destination Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x27; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x4e; goto L9561; L274e: // 274e: call 2966h ; get dir. by finding shortest distance Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x27; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x51; goto L2966; L2751: // 2751: ld (4d1eh), hl ; store offset mem[0x4d1e] = Z80L; mem[0x4d1f] = Z80H; // 2754: ld (4d2ch), a ; store direction mem[0x4d2c] = Z80A; // 2757: ret goto returnInstruction; // 2758: ld hl, (4d0ah) ; red ghost location YY XX // normal movement get direction for red ghost L2758: Z80L = (UINT8) (mem[0x4d0a]); Z80H = (UINT8) (mem[0x4d0b]); // 275b: ld de, (4d39h) ; ms pac location YY XX Z80E = (UINT8) (mem[0x4d39]); Z80D = (UINT8) (mem[0x4d3a]); // 275f: ld a, (4d2ch) ; current direction Z80A = (UINT8) (mem[0x4d2c]); // 2762: call 2966h ; get dir. by finding shortest distance Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x27; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x65; goto L2966; L2765: // 2765: ld (4d1eh), hl mem[0x4d1e] = Z80L; mem[0x4d1f] = Z80H; // 2768: ld (4d2ch), a mem[0x4d2c] = Z80A; // 276b: ret ; HL= offset for direction, a= dir. goto returnInstruction; L276c: // 276c: ld a, (4dc1h) Z80A = (UINT8) (mem[0x4dc1]); // 276f: bit 0, a u8Flags = (u8Flags & ~0x40) | ((((Z80A & 1) == 0)) ? 0x40 : 0); u8Flags |= 0x10; u8Flags &= 0xfd; // 2771: jp nz, 278eh if (((u8Flags & 0x40) >> 6) != 1) { goto L278e; } // 2774: ld a, (4e04h) ; level cleared register Z80A = (UINT8) (mem[0x4e04]); { UINT16 u16Temp0; // 2777: cp a, 03h u16Temp0 = Z80A - 0x03; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x03))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x03 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 2779: jr nz, 0278eh ; jump if not 3 if (((u8Flags & 0x40) >> 6) != 1) { goto L278e; } // 277b: ld hl, (4d0ch) Z80L = (UINT8) (mem[0x4d0c]); Z80H = (UINT8) (mem[0x4d0d]); // 277e: ld a, (4d2dh) Z80A = (UINT8) (mem[0x4d2d]); // 2781: call 9561h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x27; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x84; goto L9561; L2784: // 2784: call 2966h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x27; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x87; goto L2966; L2787: // 2787: ld (4d20h), hl mem[0x4d20] = Z80L; mem[0x4d21] = Z80H; // 278a: ld (4d2dh), a mem[0x4d2d] = Z80A; // 278d: ret goto returnInstruction; // 278e: ld de, (4d39h) L278e: Z80E = (UINT8) (mem[0x4d39]); Z80D = (UINT8) (mem[0x4d3a]); // 2792: ld hl, (4d1ch) Z80L = (UINT8) (mem[0x4d1c]); Z80H = (UINT8) (mem[0x4d1d]); { UINT32 u32Temp0; // 2795: add hl, hl // hard hack: HACK6 u32Temp0 = Z80HL + Z80HL; u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80HL) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } { UINT32 u32Temp0; // 2796: add hl, hl u32Temp0 = Z80HL + Z80HL; u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80HL) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } { UINT32 u32Temp0; // 2797: add hl, de u32Temp0 = Z80HL + Z80DE; u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80DE) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } { UINT16 u16Temp0; // 2798: ex de, hl u16Temp0 = Z80HL; Z80HL = (UINT16) (Z80DE); Z80DE = (UINT16) (u16Temp0); } // 2799: ld hl, (4d0ch) Z80L = (UINT8) (mem[0x4d0c]); Z80H = (UINT8) (mem[0x4d0d]); // 279c: ld a, (4d2dh) Z80A = (UINT8) (mem[0x4d2d]); // 279f: call 2966h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x27; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xa2; goto L2966; L27a2: // 27a2: ld (4d20h), hl mem[0x4d20] = Z80L; mem[0x4d21] = Z80H; // 27a5: ld (4d2dh), a mem[0x4d2d] = Z80A; // 27a8: ret goto returnInstruction; L27a9: // 27a9: ld a, (4dc1h) Z80A = (UINT8) (mem[0x4dc1]); // 27ac: bit 0, a u8Flags = (u8Flags & ~0x40) | ((((Z80A & 1) == 0)) ? 0x40 : 0); u8Flags |= 0x10; u8Flags &= 0xfd; // 27ae: jp nz, 27cbh if (((u8Flags & 0x40) >> 6) != 1) { goto L27cb; } // 27b1: ld a, (4e04h) ; level cleared register Z80A = (UINT8) (mem[0x4e04]); { UINT16 u16Temp0; // 27b4: cp a, 03h u16Temp0 = Z80A - 0x03; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x03))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x03 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 27b6: jr nz, 027cbh ; jump if not 3 if (((u8Flags & 0x40) >> 6) != 1) { goto L27cb; } // 27b8: ld hl, (4d0eh) Z80L = (UINT8) (mem[0x4d0e]); Z80H = (UINT8) (mem[0x4d0f]); // 27bb: call 9559h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x27; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xbe; goto L9559; L27be: // 27be: ld de, 2040h Z80DE = (UINT16) (0x2040); // 27c1: call 2966h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x27; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xc4; goto L2966; L27c4: // 27c4: ld (4d22h), hl mem[0x4d22] = Z80L; mem[0x4d23] = Z80H; // 27c7: ld (4d2eh), a mem[0x4d2e] = Z80A; // 27ca: ret goto returnInstruction; // 27cb: ld bc, (4d0ah) L27cb: Z80C = (UINT8) (mem[0x4d0a]); Z80B = (UINT8) (mem[0x4d0b]); // 27cf: ld de, (4d39h) Z80E = (UINT8) (mem[0x4d39]); Z80D = (UINT8) (mem[0x4d3a]); // 27d3: ld hl, (4d1ch) Z80L = (UINT8) (mem[0x4d1c]); Z80H = (UINT8) (mem[0x4d1d]); { UINT32 u32Temp0; // 27d6: add hl, hl u32Temp0 = Z80HL + Z80HL; u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80HL) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } { UINT32 u32Temp0; // 27d7: add hl, de u32Temp0 = Z80HL + Z80DE; u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80DE) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 27d8: ld a, l Z80A = (UINT8) (Z80L); { UINT16 u16Temp0; // 27d9: add a, a u16Temp0 = Z80A + Z80A; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80A))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80A ^ Z80A ^ 0x80) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } { UINT16 u16Temp0; // 27da: sub a, c u16Temp0 = Z80A - Z80C; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80C))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80C ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 27db: ld l, a Z80L = (UINT8) (Z80A); // 27dc: ld a, h Z80A = (UINT8) (Z80H); { UINT16 u16Temp0; // 27dd: add a, a u16Temp0 = Z80A + Z80A; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80A))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80A ^ Z80A ^ 0x80) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } { UINT16 u16Temp0; // 27de: sub a, b u16Temp0 = Z80A - Z80B; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80B))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80B ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 27df: ld h, a Z80H = (UINT8) (Z80A); { UINT16 u16Temp0; // 27e0: ex de, hl u16Temp0 = Z80HL; Z80HL = (UINT16) (Z80DE); Z80DE = (UINT16) (u16Temp0); } // 27e1: ld hl, (4d0eh) Z80L = (UINT8) (mem[0x4d0e]); Z80H = (UINT8) (mem[0x4d0f]); // 27e4: ld a, (4d2eh) Z80A = (UINT8) (mem[0x4d2e]); // 27e7: call 2966h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x27; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xea; goto L2966; L27ea: // 27ea: ld (4d22h), hl mem[0x4d22] = Z80L; mem[0x4d23] = Z80H; // 27ed: ld (4d2eh), a mem[0x4d2e] = Z80A; // 27f0: ret goto returnInstruction; L27f1: // 27f1: ld a, (4dc1h) Z80A = (UINT8) (mem[0x4dc1]); // 27f4: bit 0, a u8Flags = (u8Flags & ~0x40) | ((((Z80A & 1) == 0)) ? 0x40 : 0); u8Flags |= 0x10; u8Flags &= 0xfd; // 27f6: jp nz, 2813h if (((u8Flags & 0x40) >> 6) != 1) { goto L2813; } // 27f9: ld a, (4e04h) ; level cleared register Z80A = (UINT8) (mem[0x4e04]); { UINT16 u16Temp0; // 27fc: cp a, 03h u16Temp0 = Z80A - 0x03; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x03))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x03 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 27fe: jr nz, 02813h ; jump if not 3 if (((u8Flags & 0x40) >> 6) != 1) { goto L2813; } // 2800: ld hl, (4d10h) L2800: Z80L = (UINT8) (mem[0x4d10]); Z80H = (UINT8) (mem[0x4d11]); // 2803: call 955eh Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x28; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x06; goto L955e; L2806: // 2806: ld de, 3b40h Z80DE = (UINT16) (0x3b40); // 2809: call 2966h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x28; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x0c; goto L2966; L280c: // 280c: ld (4d24h), hl mem[0x4d24] = Z80L; mem[0x4d25] = Z80H; // 280f: ld (4d2fh), a mem[0x4d2f] = Z80A; // 2812: ret goto returnInstruction; // 2813: ld ix, 4d39h L2813: Z80IX = (UINT16) (0x4d39); // 2817: ld iy, 4d10h Z80IY = (UINT16) (0x4d10); // 281b: call 29eah Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x28; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x1e; goto L29ea; L281e: // 281e: ld de, 0040h Z80DE = (UINT16) (0x40); // 2821: and a, a // hard hack: HACK6 u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); { UINT32 u32Temp0; // 2822: sbc hl, de u32Temp0 = (Z80HL - Z80DE - ((u8Flags & 0x01) >> 0)); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80DE) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | (((((Z80DE ^ Z80HL) & (Z80HL ^ u32Temp0) & 0x8000))) ? 0x04 : 0); Z80HL = (UINT16) (u32Temp0); u8Flags = (u8Flags & ~0x40) | ((Z80HL == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80HL & 0x8000) ? 0x80 : 0); u8Flags |= 0x02; } // 2824: jp c, 2800h if (((u8Flags & 0x01) >> 0) == 1) { goto L2800; } // 2827: ld hl, (4d10h) Z80L = (UINT8) (mem[0x4d10]); Z80H = (UINT8) (mem[0x4d11]); // 282a: ld de, (4d39h) Z80E = (UINT8) (mem[0x4d39]); Z80D = (UINT8) (mem[0x4d3a]); // 282e: ld a, (4d2fh) Z80A = (UINT8) (mem[0x4d2f]); // 2831: call 2966h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x28; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x34; goto L2966; L2834: // 2834: ld (4d24h), hl mem[0x4d24] = Z80L; mem[0x4d25] = Z80H; // 2837: ld (4d2fh), a mem[0x4d2f] = Z80A; // 283a: ret goto returnInstruction; L283b: // 283b: ld a, (4dach) Z80A = (UINT8) (mem[0x4dac]); // 283e: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 283f: jp z, 2855h if (((u8Flags & 0x40) >> 6) == 1) { goto L2855; } // 2842: ld de, 2e2ch Z80DE = (UINT16) (0x2e2c); // 2845: ld hl, (4d0ah) Z80L = (UINT8) (mem[0x4d0a]); Z80H = (UINT8) (mem[0x4d0b]); // 2848: ld a, (4d2ch) Z80A = (UINT8) (mem[0x4d2c]); // 284b: call 2966h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x28; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x4e; goto L2966; L284e: // 284e: ld (4d1eh), hl mem[0x4d1e] = Z80L; mem[0x4d1f] = Z80H; // 2851: ld (4d2ch), a mem[0x4d2c] = Z80A; // 2854: ret goto returnInstruction; // 2855: ld hl, (4d0ah) L2855: Z80L = (UINT8) (mem[0x4d0a]); Z80H = (UINT8) (mem[0x4d0b]); // 2858: ld a, (4d2ch) Z80A = (UINT8) (mem[0x4d2c]); // 285b: call 291eh Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x28; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x5e; goto L291e; L285e: // 285e: ld (4d1eh), hl mem[0x4d1e] = Z80L; mem[0x4d1f] = Z80H; // 2861: ld (4d2ch), a mem[0x4d2c] = Z80A; // 2864: ret goto returnInstruction; L2865: // 2865: ld a, (4dadh) Z80A = (UINT8) (mem[0x4dad]); // 2868: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2869: jp z, 287fh if (((u8Flags & 0x40) >> 6) == 1) { goto L287f; } // 286c: ld de, 2e2ch Z80DE = (UINT16) (0x2e2c); // 286f: ld hl, (4d0ch) Z80L = (UINT8) (mem[0x4d0c]); Z80H = (UINT8) (mem[0x4d0d]); // 2872: ld a, (4d2dh) Z80A = (UINT8) (mem[0x4d2d]); // 2875: call 2966h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x28; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x78; goto L2966; L2878: // 2878: ld (4d20h), hl mem[0x4d20] = Z80L; mem[0x4d21] = Z80H; // 287b: ld (4d2dh), a mem[0x4d2d] = Z80A; // 287e: ret goto returnInstruction; // 287f: ld hl, (4d0ch) L287f: Z80L = (UINT8) (mem[0x4d0c]); Z80H = (UINT8) (mem[0x4d0d]); // 2882: ld a, (4d2dh) Z80A = (UINT8) (mem[0x4d2d]); // 2885: call 291eh Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x28; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x88; goto L291e; L2888: // 2888: ld (4d20h), hl mem[0x4d20] = Z80L; mem[0x4d21] = Z80H; // 288b: ld (4d2dh), a mem[0x4d2d] = Z80A; // 288e: ret goto returnInstruction; L288f: // 288f: ld a, (4daeh) Z80A = (UINT8) (mem[0x4dae]); // 2892: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2893: jp z, 28a9h if (((u8Flags & 0x40) >> 6) == 1) { goto L28a9; } // 2896: ld de, 2e2ch Z80DE = (UINT16) (0x2e2c); // 2899: ld hl, (4d0eh) Z80L = (UINT8) (mem[0x4d0e]); Z80H = (UINT8) (mem[0x4d0f]); // 289c: ld a, (4d2eh) Z80A = (UINT8) (mem[0x4d2e]); // 289f: call 2966h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x28; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xa2; goto L2966; L28a2: // 28a2: ld (4d22h), hl mem[0x4d22] = Z80L; mem[0x4d23] = Z80H; // 28a5: ld (4d2eh), a mem[0x4d2e] = Z80A; // 28a8: ret goto returnInstruction; // 28a9: ld hl, (4d0eh) L28a9: Z80L = (UINT8) (mem[0x4d0e]); Z80H = (UINT8) (mem[0x4d0f]); // 28ac: ld a, (4d2eh) Z80A = (UINT8) (mem[0x4d2e]); // 28af: call 291eh Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x28; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xb2; goto L291e; L28b2: // 28b2: ld (4d22h), hl mem[0x4d22] = Z80L; mem[0x4d23] = Z80H; // 28b5: ld (4d2eh), a mem[0x4d2e] = Z80A; // 28b8: ret goto returnInstruction; L28b9: // 28b9: ld a, (4dafh) Z80A = (UINT8) (mem[0x4daf]); // 28bc: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 28bd: jp z, 28d3h if (((u8Flags & 0x40) >> 6) == 1) { goto L28d3; } // 28c0: ld de, 2e2ch Z80DE = (UINT16) (0x2e2c); // 28c3: ld hl, (4d10h) Z80L = (UINT8) (mem[0x4d10]); Z80H = (UINT8) (mem[0x4d11]); // 28c6: ld a, (4d2fh) Z80A = (UINT8) (mem[0x4d2f]); // 28c9: call 2966h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x28; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xcc; goto L2966; L28cc: // 28cc: ld (4d24h), hl mem[0x4d24] = Z80L; mem[0x4d25] = Z80H; // 28cf: ld (4d2fh), a mem[0x4d2f] = Z80A; // 28d2: ret goto returnInstruction; // 28d3: ld hl, (4d10h) L28d3: Z80L = (UINT8) (mem[0x4d10]); Z80H = (UINT8) (mem[0x4d11]); // 28d6: ld a, (4d2fh) Z80A = (UINT8) (mem[0x4d2f]); // 28d9: call 291eh Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x28; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xdc; goto L291e; L28dc: // 28dc: ld (4d24h), hl mem[0x4d24] = Z80L; mem[0x4d25] = Z80H; // 28df: ld (4d2fh), a mem[0x4d2f] = Z80A; // 28e2: ret goto returnInstruction; L28e3: // 28e3: ld a, (4da7h) Z80A = (UINT8) (mem[0x4da7]); // 28e6: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 28e7: jp z, 28feh if (((u8Flags & 0x40) >> 6) == 1) { goto L28fe; } // 28ea: ld hl, (4d12h) Z80L = (UINT8) (mem[0x4d12]); Z80H = (UINT8) (mem[0x4d13]); // 28ed: ld de, (4d0ch) Z80E = (UINT8) (mem[0x4d0c]); Z80D = (UINT8) (mem[0x4d0d]); // 28f1: ld a, (4d3ch) Z80A = (UINT8) (mem[0x4d3c]); // 28f4: call 2966h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x28; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xf7; goto L2966; L28f7: // 28f7: ld (4d26h), hl mem[0x4d26] = Z80L; mem[0x4d27] = Z80H; // 28fa: ld (4d3ch), a mem[0x4d3c] = Z80A; // 28fd: ret goto returnInstruction; // 28fe: ld hl, (4d39h) L28fe: Z80L = (UINT8) (mem[0x4d39]); Z80H = (UINT8) (mem[0x4d3a]); // 2901: ld bc, (4d0ch) Z80C = (UINT8) (mem[0x4d0c]); Z80B = (UINT8) (mem[0x4d0d]); // 2905: ld a, l Z80A = (UINT8) (Z80L); { UINT16 u16Temp0; // 2906: add a, a u16Temp0 = Z80A + Z80A; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80A))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80A ^ Z80A ^ 0x80) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } { UINT16 u16Temp0; // 2907: sub a, c u16Temp0 = Z80A - Z80C; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80C))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80C ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 2908: ld l, a Z80L = (UINT8) (Z80A); // 2909: ld a, h Z80A = (UINT8) (Z80H); { UINT16 u16Temp0; // 290a: add a, a u16Temp0 = Z80A + Z80A; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80A))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80A ^ Z80A ^ 0x80) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } { UINT16 u16Temp0; // 290b: sub a, b u16Temp0 = Z80A - Z80B; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80B))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80B ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 290c: ld h, a Z80H = (UINT8) (Z80A); { UINT16 u16Temp0; // 290d: ex de, hl u16Temp0 = Z80HL; Z80HL = (UINT16) (Z80DE); Z80DE = (UINT16) (u16Temp0); } // 290e: ld hl, (4d12h) Z80L = (UINT8) (mem[0x4d12]); Z80H = (UINT8) (mem[0x4d13]); // 2911: ld a, (4d3ch) Z80A = (UINT8) (mem[0x4d3c]); // 2914: call 2966h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x29; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x17; goto L2966; L2917: // 2917: ld (4d26h), hl mem[0x4d26] = Z80L; mem[0x4d27] = Z80H; // 291a: ld (4d3ch), a mem[0x4d3c] = Z80A; // 291d: ret goto returnInstruction; // 291e: ld (4d3eh), hl L291e: mem[0x4d3e] = Z80L; mem[0x4d3f] = Z80H; // 2921: xor a, 02h Z80A = (UINT8) (Z80A ^ 0x02); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2923: ld (4d3dh), a mem[0x4d3d] = Z80A; // 2926: call 2a23h ; get a random number Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x29; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x29; goto L2a23; L2929: // 2929: and a, 03h Z80A = (UINT8) (Z80A & 0x03); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 292b: ld hl, 4d3bh Z80HL = (UINT16) (0x4d3b); // 292e: ld (hl), a mspacmanIndirectWrite8(Z80HL, Z80A); { UINT16 u16Temp0; // 292f: add a, a u16Temp0 = Z80A + Z80A; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80A))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80A ^ Z80A ^ 0x80) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 2930: ld e, a Z80E = (UINT8) (Z80A); // 2931: ld d, 00h Z80D = (UINT8) (0); // 2933: ld ix, 32ffh Z80IX = (UINT16) (0x32ff); { UINT32 u32Temp0; // 2937: add ix, de u32Temp0 = Z80IX + Z80DE; u8Flags = (u8Flags & ~0x10) | ((((Z80IX ^ u32Temp0 ^ Z80DE) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80IX = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 2939: ld iy, 4d3eh Z80IY = (UINT16) (0x4d3e); // 293d: ld a, (4d3dh) L293d: Z80A = (UINT8) (mem[0x4d3d]); { UINT16 u16Temp0; UINT8 u8Temp0; // 2940: cp a, (hl) u8Temp0 = mem[Z80HL]; u16Temp0 = Z80A - u8Temp0; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ u8Temp0))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((u8Temp0 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 2941: jp z, 2957h if (((u8Flags & 0x40) >> 6) == 1) { goto L2957; } // 2944: call 200fh Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x29; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x47; goto L200f; L2947: // 2947: and a, 0c0h Z80A = (UINT8) (Z80A & 0xc0); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); { UINT16 u16Temp0; // 2949: sub a, 0c0h u16Temp0 = Z80A - 0xc0; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0xc0))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0xc0 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 294b: jr z, 02957h ; (10) if (((u8Flags & 0x40) >> 6) == 1) { goto L2957; } // 294d: ld l, (ix+00h) Z80L = (UINT8) (mem[Z80IX]); // 2950: ld h, (ix+01h) Z80H = (UINT8) (mem[Z80IX + 1]); // 2953: ld a, (4d3bh) Z80A = (UINT8) (mem[0x4d3b]); // 2956: ret goto returnInstruction; // 2957: inc ix L2957: Z80IX = (UINT16) (Z80IX + 1); // 2959: inc ix Z80IX = (UINT16) (Z80IX + 1); // 295b: ld hl, 4d3bh Z80HL = (UINT16) (0x4d3b); // 295e: ld a, (hl) Z80A = (UINT8) (mem[Z80HL]); // 295f: inc a Z80A = (UINT8) (Z80A + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); if ((Z80A & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80A == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 2960: and a, 03h Z80A = (UINT8) (Z80A & 0x03); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2962: ld (hl), a mspacmanIndirectWrite8(Z80HL, Z80A); // 2963: jp 293dh goto L293d; // 2966: ld (4d3eh), hl // distance check. (used for ghost logic) L2966: mem[0x4d3e] = Z80L; mem[0x4d3f] = Z80H; // 2969: ld (4d40h), de mem[0x4d40] = Z80E; mem[0x4d41] = Z80D; // 296d: ld (4d3bh), a mem[0x4d3b] = Z80A; // 2970: xor a, 02h Z80A = (UINT8) (Z80A ^ 0x02); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2972: ld (4d3dh), a mem[0x4d3d] = Z80A; // 2975: ld hl, 0ffffh Z80HL = (UINT16) (0xffff); // 2978: ld (4d44h), hl mem[0x4d44] = Z80L; mem[0x4d45] = Z80H; // 297b: ld ix, 32ffh Z80IX = (UINT16) (0x32ff); // 297f: ld iy, 4d3eh Z80IY = (UINT16) (0x4d3e); // 2983: ld hl, 4dc7h Z80HL = (UINT16) (0x4dc7); // 2986: ld (hl), 00h mspacmanIndirectWrite8(Z80HL, 0); // 2988: ld a, (4d3dh) L2988: Z80A = (UINT8) (mem[0x4d3d]); { UINT16 u16Temp0; UINT8 u8Temp0; // 298b: cp a, (hl) u8Temp0 = mem[Z80HL]; u16Temp0 = Z80A - u8Temp0; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ u8Temp0))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((u8Temp0 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 298c: jp z, 29c6h if (((u8Flags & 0x40) >> 6) == 1) { goto L29c6; } // 298f: call 2000h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x29; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x92; goto L2000; L2992: // 2992: ld (4d42h), hl mem[0x4d42] = Z80L; mem[0x4d43] = Z80H; // 2995: call 0065h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x29; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x98; goto L0065; L2998: // 2998: ld a, (hl) Z80A = (UINT8) (mem[Z80HL]); // 2999: and a, 0c0h Z80A = (UINT8) (Z80A & 0xc0); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); { UINT16 u16Temp0; // 299b: sub a, 0c0h u16Temp0 = Z80A - 0xc0; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0xc0))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0xc0 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 299d: jr z, 029c6h ; (39) if (((u8Flags & 0x40) >> 6) == 1) { goto L29c6; } // 299f: push ix Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80XH; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80XL; // 29a1: push iy Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80YH; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80YL; // 29a3: ld ix, 4d40h Z80IX = (UINT16) (0x4d40); // 29a7: ld iy, 4d42h Z80IY = (UINT16) (0x4d42); // 29ab: call 29eah Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x29; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xae; goto L29ea; L29ae: // 29ae: pop iy Z80YL = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); Z80YH = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); // 29b0: pop ix Z80XL = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); Z80XH = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); { UINT16 u16Temp0; // 29b2: ex de, hl u16Temp0 = Z80HL; Z80HL = (UINT16) (Z80DE); Z80DE = (UINT16) (u16Temp0); } // 29b3: ld hl, (4d44h) Z80L = (UINT8) (mem[0x4d44]); Z80H = (UINT8) (mem[0x4d45]); // 29b6: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); { UINT32 u32Temp0; // 29b7: sbc hl, de u32Temp0 = (Z80HL - Z80DE - ((u8Flags & 0x01) >> 0)); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80DE) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | (((((Z80DE ^ Z80HL) & (Z80HL ^ u32Temp0) & 0x8000))) ? 0x04 : 0); Z80HL = (UINT16) (u32Temp0); u8Flags = (u8Flags & ~0x40) | ((Z80HL == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80HL & 0x8000) ? 0x80 : 0); u8Flags |= 0x02; } // 29b9: jp c, 29c6h if (((u8Flags & 0x01) >> 0) == 1) { goto L29c6; } // 29bc: ld (4d44h), de mem[0x4d44] = Z80E; mem[0x4d45] = Z80D; // 29c0: ld a, (4dc7h) Z80A = (UINT8) (mem[0x4dc7]); // 29c3: ld (4d3bh), a mem[0x4d3b] = Z80A; // 29c6: inc ix L29c6: Z80IX = (UINT16) (Z80IX + 1); // 29c8: inc ix Z80IX = (UINT16) (Z80IX + 1); // 29ca: ld hl, 4dc7h Z80HL = (UINT16) (0x4dc7); { UINT8 u8Temp0; // 29cd: inc (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 29ce: ld a, 04h Z80A = (UINT8) (0x04); { UINT16 u16Temp0; UINT8 u8Temp0; // 29d0: cp a, (hl) u8Temp0 = mem[Z80HL]; u16Temp0 = Z80A - u8Temp0; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ u8Temp0))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((u8Temp0 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 29d1: jp nz, 2988h if (((u8Flags & 0x40) >> 6) != 1) { goto L2988; } // 29d4: ld a, (4d3bh) Z80A = (UINT8) (mem[0x4d3b]); { UINT16 u16Temp0; // 29d7: add a, a u16Temp0 = Z80A + Z80A; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80A))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80A ^ Z80A ^ 0x80) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 29d8: ld e, a Z80E = (UINT8) (Z80A); // 29d9: ld d, 00h Z80D = (UINT8) (0); // 29db: ld ix, 32ffh Z80IX = (UINT16) (0x32ff); { UINT32 u32Temp0; // 29df: add ix, de u32Temp0 = Z80IX + Z80DE; u8Flags = (u8Flags & ~0x10) | ((((Z80IX ^ u32Temp0 ^ Z80DE) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80IX = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 29e1: ld l, (ix+00h) Z80L = (UINT8) (mem[Z80IX]); // 29e4: ld h, (ix+01h) Z80H = (UINT8) (mem[Z80IX + 1]); // 29e7: srl a u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (Z80A >> 1); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags &= 0xef; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 29e9: ret goto returnInstruction; // 29ea: ld a, (ix+00h) L29ea: Z80A = (UINT8) (mem[Z80IX]); // 29ed: ld b, (iy+00h) Z80B = (UINT8) (mem[Z80IY]); { UINT16 u16Temp0; // 29f0: sub a, b u16Temp0 = Z80A - Z80B; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80B))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80B ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 29f1: jp nc, 29f9h if (((u8Flags & 0x01) >> 0) != 1) { goto L29f9; } // 29f4: ld a, b Z80A = (UINT8) (Z80B); // 29f5: ld b, (ix+00h) Z80B = (UINT8) (mem[Z80IX]); { UINT16 u16Temp0; // 29f8: sub a, b u16Temp0 = Z80A - Z80B; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80B))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80B ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 29f9: call 2a12h L29f9: Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x29; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xfc; goto L2a12; L29fc: // 29fc: push hl Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80H; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80L; // 29fd: ld a, (ix+01h) Z80A = (UINT8) (mem[Z80IX + 1]); // 2a00: ld b, (iy+01h) Z80B = (UINT8) (mem[Z80IY + 1]); { UINT16 u16Temp0; // 2a03: sub a, b u16Temp0 = Z80A - Z80B; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80B))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80B ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 2a04: jp nc, 2a0ch if (((u8Flags & 0x01) >> 0) != 1) { goto L2a0c; } // 2a07: ld a, b Z80A = (UINT8) (Z80B); // 2a08: ld b, (ix+01h) Z80B = (UINT8) (mem[Z80IX + 1]); { UINT16 u16Temp0; // 2a0b: sub a, b u16Temp0 = Z80A - Z80B; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80B))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80B ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 2a0c: call 2a12h L2a0c: Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x2a; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x0f; goto L2a12; L2a0f: // 2a0f: pop bc Z80C = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); Z80B = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); { UINT32 u32Temp0; // 2a10: add hl, bc u32Temp0 = Z80HL + Z80BC; u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80BC) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 2a11: ret goto returnInstruction; // 2a12: ld h, a L2a12: Z80H = (UINT8) (Z80A); // 2a13: ld e, a Z80E = (UINT8) (Z80A); // 2a14: ld L, 00h Z80L = (UINT8) (0); // 2a16: ld d, l Z80D = (UINT8) (Z80L); // 2a17: ld c, 08h Z80C = (UINT8) (0x08); { UINT32 u32Temp0; // 2a19: add hl, hl L2a19: u32Temp0 = Z80HL + Z80HL; u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80HL) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 2a1a: jp nc, 2a1eh if (((u8Flags & 0x01) >> 0) != 1) { goto L2a1e; } { UINT32 u32Temp0; // 2a1d: add hl, de u32Temp0 = Z80HL + Z80DE; u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80DE) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 2a1e: dec c L2a1e: Z80C = (UINT8) (Z80C - 1); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((Z80C == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80C & 0x80) ? 0x80 : 0); if ((Z80C & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80C == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 2a1f: jp nz, 2a19h if (((u8Flags & 0x40) >> 6) != 1) { goto L2a19; } // 2a22: ret goto returnInstruction; // 2a23: ld hl, (4dc9h) // Random number generator L2a23: Z80L = (UINT8) (mem[0x4dc9]); Z80H = (UINT8) (mem[0x4dca]); // 2a26: ld d, h Z80D = (UINT8) (Z80H); // 2a27: ld e, l Z80E = (UINT8) (Z80L); { UINT32 u32Temp0; // 2a28: add hl, hl u32Temp0 = Z80HL + Z80HL; u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80HL) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } { UINT32 u32Temp0; // 2a29: add hl, hl u32Temp0 = Z80HL + Z80HL; u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80HL) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } { UINT32 u32Temp0; // 2a2a: add hl, de u32Temp0 = Z80HL + Z80DE; u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80DE) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 2a2b: inc hl Z80HL = (UINT16) (Z80HL + 1); // 2a2c: ld a, h Z80A = (UINT8) (Z80H); // 2a2d: and a, 1fh Z80A = (UINT8) (Z80A & 0x1f); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2a2f: ld h, a Z80H = (UINT8) (Z80A); // 2a30: ld a, (hl) Z80A = (UINT8) (mem[Z80HL]); // 2a31: ld (4dc9h), hl mem[0x4dc9] = Z80L; mem[0x4dca] = Z80H; // 2a34: ret goto returnInstruction; L2a35: // 2a35: ld de, 4040h Z80DE = (UINT16) (0x4040); // 2a38: ld hl, 43c0h L2a38: Z80HL = (UINT16) (0x43c0); // 2a3b: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); { UINT32 u32Temp0; // 2a3c: sbc hl, de u32Temp0 = (Z80HL - Z80DE - ((u8Flags & 0x01) >> 0)); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80DE) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | (((((Z80DE ^ Z80HL) & (Z80HL ^ u32Temp0) & 0x8000))) ? 0x04 : 0); Z80HL = (UINT16) (u32Temp0); u8Flags = (u8Flags & ~0x40) | ((Z80HL == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80HL & 0x8000) ? 0x80 : 0); u8Flags |= 0x02; } // 2a3e: ret z if (((u8Flags & 0x40) >> 6) == 1) { goto returnInstruction; } // 2a3f: ld a, (de) Z80A = (UINT8) (mem[Z80DE]); { UINT16 u16Temp0; // 2a40: cp a, 10h u16Temp0 = Z80A - 0x10; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x10))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x10 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 2a42: jp z, 2a53h if (((u8Flags & 0x40) >> 6) == 1) { goto L2a53; } { UINT16 u16Temp0; // 2a45: cp a, 12h u16Temp0 = Z80A - 0x12; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x12))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x12 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 2a47: jp z, 2a53h if (((u8Flags & 0x40) >> 6) == 1) { goto L2a53; } { UINT16 u16Temp0; // 2a4a: cp a, 14h u16Temp0 = Z80A - 0x14; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x14))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x14 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 2a4c: jp z, 2a53h if (((u8Flags & 0x40) >> 6) == 1) { goto L2a53; } // 2a4f: inc de Z80DE = (UINT16) (Z80DE + 1); // 2a50: jp 2a38h goto L2a38; // 2a53: ld a, 40h L2a53: Z80A = (UINT8) (0x40); // 2a55: ld (de), a mspacmanIndirectWrite8(Z80DE, Z80A); // 2a56: inc de Z80DE = (UINT16) (Z80DE + 1); // 2a57: jp 2a38h goto L2a38; // 2a5a: ld a, (4e00h) ; game mode L2a5a: Z80A = (UINT8) (mem[0x4e00]); { UINT16 u16Temp0; // 2a5d: cp a, 01h u16Temp0 = Z80A - 1; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 1))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((1 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 2a5f: ret z ; return if intro mode if (((u8Flags & 0x40) >> 6) == 1) { goto returnInstruction; } // 2a60: ld hl, 2b17h // this updates the score when something is eaten // (from the above table at 2b17) // load a with the item eaten Z80HL = (UINT16) (0x2b17); // 2a63: rst 18h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x2a; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x64; goto L0018; L2a64: { UINT16 u16Temp0; // 2a64: ex de, hl u16Temp0 = Z80HL; Z80HL = (UINT16) (Z80DE); Z80DE = (UINT16) (u16Temp0); } // 2a65: call 2b0bh Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x2a; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x68; goto L2b0b; L2a68: // 2a68: ld a, e Z80A = (UINT8) (Z80E); { UINT16 u16Temp0; UINT8 u8Temp0; // 2a69: add a, (hl) u8Temp0 = mem[Z80HL]; u16Temp0 = Z80A + u8Temp0; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ u8Temp0))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((u8Temp0 ^ Z80A ^ 0x80) & (u8Temp0 ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } { UINT16 u16Temp0; // 2a6a: daa u16Temp0 = (Z80A | (((u8Flags & 0x01) >> 0) << 0x08) | (((u8Flags & 0x10) >> 4) << 0x09) | (((u8Flags & 0x02) >> 1) << 0x0a)); u8Flags = (UINT8) (sg_u16DAATable[u16Temp0] >> 0x08); Z80A = (UINT8) (sg_u16DAATable[u16Temp0] & 0xff); } // 2a6b: ld (hl), a mspacmanIndirectWrite8(Z80HL, Z80A); // 2a6c: inc hl Z80HL = (UINT16) (Z80HL + 1); // 2a6d: ld a, d Z80A = (UINT8) (Z80D); { UINT16 u16Temp0; UINT8 u8Temp0; // 2a6e: adc a, (hl) u8Temp0 = mem[Z80HL]; u16Temp0 = (Z80A + ((u8Flags & 0x01) >> 0) + u8Temp0); u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ u8Temp0))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((u8Temp0 ^ Z80A ^ 0x80) & (u8Temp0 ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } { UINT16 u16Temp0; // 2a6f: daa u16Temp0 = (Z80A | (((u8Flags & 0x01) >> 0) << 0x08) | (((u8Flags & 0x10) >> 4) << 0x09) | (((u8Flags & 0x02) >> 1) << 0x0a)); u8Flags = (UINT8) (sg_u16DAATable[u16Temp0] >> 0x08); Z80A = (UINT8) (sg_u16DAATable[u16Temp0] & 0xff); } // 2a70: ld (hl), a mspacmanIndirectWrite8(Z80HL, Z80A); // 2a71: ld e, a Z80E = (UINT8) (Z80A); // 2a72: inc hl Z80HL = (UINT16) (Z80HL + 1); // 2a73: ld a, 00h Z80A = (UINT8) (0); { UINT16 u16Temp0; UINT8 u8Temp0; // 2a75: adc a, (hl) u8Temp0 = mem[Z80HL]; u16Temp0 = (Z80A + ((u8Flags & 0x01) >> 0) + u8Temp0); u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ u8Temp0))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((u8Temp0 ^ Z80A ^ 0x80) & (u8Temp0 ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } { UINT16 u16Temp0; // 2a76: daa u16Temp0 = (Z80A | (((u8Flags & 0x01) >> 0) << 0x08) | (((u8Flags & 0x10) >> 4) << 0x09) | (((u8Flags & 0x02) >> 1) << 0x0a)); u8Flags = (UINT8) (sg_u16DAATable[u16Temp0] >> 0x08); Z80A = (UINT8) (sg_u16DAATable[u16Temp0] & 0xff); } // 2a77: ld (hl), a mspacmanIndirectWrite8(Z80HL, Z80A); // 2a78: ld d, a Z80D = (UINT8) (Z80A); { UINT16 u16Temp0; // 2a79: ex de, hl u16Temp0 = Z80HL; Z80HL = (UINT16) (Z80DE); Z80DE = (UINT16) (u16Temp0); } { UINT32 u32Temp0; // 2a7a: add hl, hl u32Temp0 = Z80HL + Z80HL; u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80HL) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } { UINT32 u32Temp0; // 2a7b: add hl, hl u32Temp0 = Z80HL + Z80HL; u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80HL) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } { UINT32 u32Temp0; // 2a7c: add hl, hl u32Temp0 = Z80HL + Z80HL; u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80HL) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } { UINT32 u32Temp0; // 2a7d: add hl, hl u32Temp0 = Z80HL + Z80HL; u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80HL) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 2a7e: ld a, (bonusk) ; bonus life Z80A = (UINT8) (mem[0x4e71]); // 2a81: dec a Z80A = (UINT8) (Z80A - 1); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); if ((Z80A & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80A == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } { UINT16 u16Temp0; // 2a82: cp a, h u16Temp0 = Z80A - Z80H; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80H))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80H ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 2a83: call c, 2b33h if (((u8Flags & 0x01) >> 0) == 1) { Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x2a; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x86; goto L2b33; } L2a86: // 2a86: call 2aafh Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x2a; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x89; goto L2aaf; L2a89: // 2a89: inc de Z80DE = (UINT16) (Z80DE + 1); // 2a8a: inc de Z80DE = (UINT16) (Z80DE + 1); // 2a8b: inc de Z80DE = (UINT16) (Z80DE + 1); // 2a8c: ld hl, topsc2 ; msb high score ram area Z80HL = (UINT16) (0x4e8a); // 2a8f: ld b, 03h Z80B = (UINT8) (0x03); // 2a91: ld a, (de) L2a91: Z80A = (UINT8) (mem[Z80DE]); { UINT16 u16Temp0; UINT8 u8Temp0; // 2a92: cp a, (hl) u8Temp0 = mem[Z80HL]; u16Temp0 = Z80A - u8Temp0; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ u8Temp0))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((u8Temp0 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 2a93: ret c ; return if high score not beat? if (((u8Flags & 0x01) >> 0) == 1) { goto returnInstruction; } // 2a94: jr nz, 02a9bh ; jump if not even // perhaps this part draws the new high score atop the screen // if it is higher than the current high score? if (((u8Flags & 0x40) >> 6) != 1) { goto L2a9b; } // 2a96: dec de Z80DE = (UINT16) (Z80DE - 1); // 2a97: dec hl Z80HL = (UINT16) (Z80HL - 1); // 2a98: djnz 02a91h Z80B = (UINT8) (Z80B - 1); if (Z80B != 0) { goto L2a91; } // 2a9a: ret goto returnInstruction; // 2a9b: call 2b0bh // possibly checking the high score? L2a9b: Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x2a; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x9e; goto L2b0b; L2a9e: // 2a9e: ld de, topsc0 ; lsb high score memory Z80DE = (UINT16) (0x4e88); // 2aa1: ld bc, 0003h Z80BC = (UINT16) (0x03); // 2aa4: ldir UniqueLabel11: mspacmanIndirectWrite8(Z80DE, mem[Z80HL]); Z80HL = (UINT16) (Z80HL + 1); Z80DE = (UINT16) (Z80DE + 1); Z80BC = (UINT16) (Z80BC - 1); if (Z80BC != 0) { goto UniqueLabel11; } u8Flags &= 0xef; u8Flags &= 0xfd; if (Z80BC == 0) { u8Flags &= 0xfb; } else { u8Flags |= 0x04; } // 2aa6: dec de Z80DE = (UINT16) (Z80DE - 1); // 2aa7: ld bc, 0304h Z80BC = (UINT16) (0x0304); // 2aaa: ld hl, 43f2h Z80HL = (UINT16) (0x43f2); // 2aad: jr 02abeh goto L2abe; // 2aaf: ld a, (4e09h) L2aaf: Z80A = (UINT8) (mem[0x4e09]); // 2ab2: ld bc, 0304h Z80BC = (UINT16) (0x0304); // 2ab5: ld hl, 43fch ; screen pos for current score Z80HL = (UINT16) (0x43fc); // 2ab8: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2ab9: jr z, 02abeh if (((u8Flags & 0x40) >> 6) == 1) { goto L2abe; } // 2abb: ld hl, 43e9h ; screen pos for high score Z80HL = (UINT16) (0x43e9); // 2abe: ld a, (de) // draw the score to the screen? L2abe: Z80A = (UINT8) (mem[Z80DE]); // 2abf: rrca u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (((Z80A >> 1) | (Z80A << 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 2ac0: rrca u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (((Z80A >> 1) | (Z80A << 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 2ac1: rrca u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (((Z80A >> 1) | (Z80A << 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 2ac2: rrca u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (((Z80A >> 1) | (Z80A << 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 2ac3: call 2aceh Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x2a; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xc6; goto L2ace; L2ac6: // 2ac6: ld a, (de) Z80A = (UINT8) (mem[Z80DE]); // 2ac7: call 2aceh Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x2a; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xca; goto L2ace; L2aca: // 2aca: dec de Z80DE = (UINT16) (Z80DE - 1); // 2acb: djnz 02abeh Z80B = (UINT8) (Z80B - 1); if (Z80B != 0) { goto L2abe; } // 2acd: ret goto returnInstruction; // 2ace: and a, 0fh L2ace: Z80A = (UINT8) (Z80A & 0x0f); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2ad0: jr z, 02ad6h if (((u8Flags & 0x40) >> 6) == 1) { goto L2ad6; } // 2ad2: ld c, 00h Z80C = (UINT8) (0); // 2ad4: jr 02addh goto L2add; // 2ad6: ld a, c L2ad6: Z80A = (UINT8) (Z80C); // 2ad7: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2ad8: jr z, 02addh if (((u8Flags & 0x40) >> 6) == 1) { goto L2add; } // 2ada: ld a, 40h Z80A = (UINT8) (0x40); // 2adc: dec c Z80C = (UINT8) (Z80C - 1); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((Z80C == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80C & 0x80) ? 0x80 : 0); if ((Z80C & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80C == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 2add: ld (hl), a L2add: mspacmanIndirectWrite8(Z80HL, Z80A); // 2ade: dec hl Z80HL = (UINT16) (Z80HL - 1); // 2adf: ret goto returnInstruction; L2ae0: // 2ae0: ld b, 00h // something with the player 1 score Z80B = (UINT8) (0); // 2ae2: call 2c5eh ; print HIGH SCORE Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x2a; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xe5; goto L2c5e; L2ae5: // 2ae5: xor a, a Z80A = (UINT8) (0); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2ae6: ld hl, p1sc0 Z80HL = (UINT16) (0x4e80); // 2ae9: ld b, 08h Z80B = (UINT8) (0x08); // 2aeb: rst 08h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x2a; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xec; goto L0008; L2aec: // 2aec: ld bc, 0304h Z80BC = (UINT16) (0x0304); // 2aef: ld de, p1sc2 ; p1 msb of score Z80DE = (UINT16) (0x4e82); // 2af2: ld hl, 43fch ; screen pos for p1 current score Z80HL = (UINT16) (0x43fc); // 2af5: call 2abeh Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x2a; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xf8; goto L2abe; L2af8: // 2af8: ld bc, 0304h Z80BC = (UINT16) (0x0304); // 2afb: ld de, p2sc2 ; high score Z80DE = (UINT16) (0x4e86); // 2afe: ld hl, 43e9h ; screen pos for high score Z80HL = (UINT16) (0x43e9); // 2b01: ld a, (coincrd) Z80A = (UINT8) (mem[0x4e70]); // 2b04: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2b05: jr nz, 02abeh if (((u8Flags & 0x40) >> 6) != 1) { goto L2abe; } // 2b07: ld c, 06h Z80C = (UINT8) (0x06); // 2b09: jr 02abeh goto L2abe; // 2b0b: ld a, (4e09h) L2b0b: Z80A = (UINT8) (mem[0x4e09]); // 2b0e: ld hl, p1sc0 Z80HL = (UINT16) (0x4e80); // 2b11: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2b12: ret z if (((u8Flags & 0x40) >> 6) == 1) { goto returnInstruction; } // 2b13: ld hl, p2sc0 Z80HL = (UINT16) (0x4e84); // 2b16: ret goto returnInstruction; // 2b33: inc de L2b33: Z80DE = (UINT16) (Z80DE + 1); // 2b34: ld l, e // [The 8th fruit is a legacy thing from pacman, which // used 8 bonus items. it is not used in mspac] Z80L = (UINT8) (Z80E); // 2b35: ld h, d Z80H = (UINT8) (Z80D); // 2b36: dec de Z80DE = (UINT16) (Z80DE - 1); // 2b37: bit 0, (hl) u8Flags = (u8Flags & ~0x40) | ((((mem[Z80HL] & 1) == 0)) ? 0x40 : 0); u8Flags |= 0x10; u8Flags &= 0xfd; // 2b39: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 2b3a: set 0, (hl) // bonus life routine mspacmanIndirectWrite8(Z80HL, mem[Z80HL] | 1); // 2b3c: ld hl, 4e9ch ; set sound 0 Z80HL = (UINT16) (0x4e9c); // 2b3f: set 0, (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] | 1); // 2b41: ld hl, lives ; number of lives left Z80HL = (UINT16) (0x4e14); { UINT8 u8Temp0; // 2b44: inc (hl) ; inc lives left mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 2b45: ld hl, scrlves ; number of lives on the screen Z80HL = (UINT16) (0x4e15); { UINT8 u8Temp0; // 2b48: inc (hl) ; inc lives displayed mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 2b49: ld b, (hl) ; number of lives on the screen Z80B = (UINT8) (mem[Z80HL]); // 2b4a: ld hl, 401ah ; screen location L2b4a: Z80HL = (UINT16) (0x401a); // 2b4d: ld c, 05h Z80C = (UINT8) (0x05); // 2b4f: ld a, b Z80A = (UINT8) (Z80B); // 2b50: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2b51: jr z, 02b61h if (((u8Flags & 0x40) >> 6) == 1) { goto L2b61; } { UINT16 u16Temp0; // 2b53: cp a, 06h u16Temp0 = Z80A - 0x06; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x06))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x06 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 2b55: jr nc, 02b61h if (((u8Flags & 0x01) >> 0) != 1) { goto L2b61; } // 2b57: ld a, 20h // draw the pacs on the screen (or another 4 character string) L2b57: Z80A = (UINT8) (0x20); // 2b59: call 2b8fh Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x2b; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x5c; goto L2b8f; L2b5c: // 2b5c: dec hl Z80HL = (UINT16) (Z80HL - 1); // 2b5d: dec hl Z80HL = (UINT16) (Z80HL - 1); // 2b5e: dec c Z80C = (UINT8) (Z80C - 1); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((Z80C == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80C & 0x80) ? 0x80 : 0); if ((Z80C & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80C == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 2b5f: djnz 02b57h Z80B = (UINT8) (Z80B - 1); if (Z80B != 0) { goto L2b57; } // 2b61: dec c // perhaps display the number of lives left on the screen? L2b61: Z80C = (UINT8) (Z80C - 1); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((Z80C == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80C & 0x80) ? 0x80 : 0); if ((Z80C & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80C == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 2b62: ret M if (((u8Flags & 0x80) >> 7) == 1) { goto returnInstruction; } // 2b63: call 2b7eh Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x2b; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x66; goto L2b7e; L2b66: // 2b66: dec hl Z80HL = (UINT16) (Z80HL - 1); // 2b67: dec hl Z80HL = (UINT16) (Z80HL - 1); // 2b68: jr 02b61h goto L2b61; // 2b6a: ld a, (4e00h) ; game mode L2b6a: Z80A = (UINT8) (mem[0x4e00]); { UINT16 u16Temp0; // 2b6d: cp a, 01h u16Temp0 = Z80A - 1; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 1))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((1 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 2b6f: ret z ; return if intro mode if (((u8Flags & 0x40) >> 6) == 1) { goto returnInstruction; } // 2b70: call 2bcdh Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x2b; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x73; goto L2bcd; L2b73: // 2b73: ld (de), a mspacmanIndirectWrite8(Z80DE, Z80A); // 2b74: ld b, h Z80B = (UINT8) (Z80H); { UINT32 u32Temp0; // 2b75: add hl, bc u32Temp0 = Z80HL + Z80BC; u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80BC) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 2b76: ld a, (bc) Z80A = (UINT8) (mem[Z80BC]); // 2b77: ld (bc), a mspacmanIndirectWrite8(Z80BC, Z80A); L2b78: // 2b78: ld hl, scrlves ; number of lives to display Z80HL = (UINT16) (0x4e15); // 2b7b: ld b, (hl) Z80B = (UINT8) (mem[Z80HL]); // 2b7c: jr 02b4ah goto L2b4a; // 2b7e: ld a, 40h ; Used to draw clear value L2b7e: Z80A = (UINT8) (0x40); // 2b80: push hl ; Save HL // draw [a] to 2x2 char square L2b80: Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80H; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80L; // 2b81: push de ; Save DE Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80D; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80E; // 2b82: ld (hl), a ; Draw color into first part mspacmanIndirectWrite8(Z80HL, Z80A); // 2b83: inc hl ; Set location to second part of fruit Z80HL = (UINT16) (Z80HL + 1); // 2b84: ld (hl), a ; Draw color into second part mspacmanIndirectWrite8(Z80HL, Z80A); // 2b85: ld de, 001fh ; Offset is used for third part Z80DE = (UINT16) (0x1f); { UINT32 u32Temp0; // 2b88: add hl, de ; Set location to third part of fruit u32Temp0 = Z80HL + Z80DE; u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80DE) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 2b89: ld (hl), a ; Draw color into third part mspacmanIndirectWrite8(Z80HL, Z80A); // 2b8a: inc hl ; Set location to fourth part of fruit Z80HL = (UINT16) (Z80HL + 1); // 2b8b: ld (hl), a ; Draw color into fourth part mspacmanIndirectWrite8(Z80HL, Z80A); // 2b8c: pop de ; Restore DE Z80E = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); Z80D = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); // 2b8d: pop hl ; Restore HL Z80L = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); Z80H = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); // 2b8e: ret ; Return goto returnInstruction; // 2b8f: push hl ; Save HL // draw fruit L2b8f: Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80H; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80L; // 2b90: push de ; Save DE Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80D; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80E; // 2b91: ld de, 001fh ; this offset is added later for third part of f Z80DE = (UINT16) (0x1f); // 2b94: ld (hl), a ; Draw first part of fruit code into screen memo mspacmanIndirectWrite8(Z80HL, Z80A); // 2b95: inc a ; Point to second part of fruit Z80A = (UINT8) (Z80A + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); if ((Z80A & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80A == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 2b96: inc hl ; Increment screen memory for second part of fru Z80HL = (UINT16) (Z80HL + 1); // 2b97: ld (hl), a ; Draw second part of fruit code into screen mem mspacmanIndirectWrite8(Z80HL, Z80A); // 2b98: inc a ; Point to third part of fruit Z80A = (UINT8) (Z80A + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); if ((Z80A & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80A == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } { UINT32 u32Temp0; // 2b99: add hl, de ; Add offset for third part of fruit u32Temp0 = Z80HL + Z80DE; u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80DE) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 2b9a: ld (hl), a ; Draw third part of fruit code into screen memo mspacmanIndirectWrite8(Z80HL, Z80A); // 2b9b: inc a ; Point to fourth part of fruit Z80A = (UINT8) (Z80A + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); if ((Z80A & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80A == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 2b9c: inc hl ; Increment screen memory for fourth part of fru Z80HL = (UINT16) (Z80HL + 1); // 2b9d: ld (hl), a ; Draw fourth part of fruit code into screen mem mspacmanIndirectWrite8(Z80HL, Z80A); // 2b9e: pop de ; Restore DE Z80E = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); Z80D = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); // 2b9f: pop hl ; Restore HL Z80L = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); Z80H = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); // 2ba0: ret ; Return goto returnInstruction; // 2ba1: ld a, (credits) ; number of credits in ram // display number of credits L2ba1: Z80A = (UINT8) (mem[0x4e6e]); { UINT16 u16Temp0; // 2ba4: cp a, 0ffh ; set for free play? u16Temp0 = Z80A - 0xff; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0xff))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0xff ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 2ba6: jr nz, 02badh ; no? then jump if (((u8Flags & 0x40) >> 6) != 1) { goto L2bad; } // 2ba8: ld b, 02h ; 'FREE PLAY' Z80B = (UINT8) (0x02); // 2baa: jp 2c5eh ; print FREE PLAY goto L2c5e; // 2bad: ld b, 01h L2bad: Z80B = (UINT8) (1); // 2baf: call 2c5eh ; print CREDIT Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x2b; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xb2; goto L2c5e; L2bb2: // 2bb2: ld a, (credits) ; number of credits in ram Z80A = (UINT8) (mem[0x4e6e]); // 2bb5: and a, 0f0h ; bigger than 9? Z80A = (UINT8) (Z80A & 0xf0); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2bb7: jr z, 02bc2h ; yes, only inc 1 position if (((u8Flags & 0x40) >> 6) == 1) { goto L2bc2; } // 2bb9: rrca u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (((Z80A >> 1) | (Z80A << 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 2bba: rrca u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (((Z80A >> 1) | (Z80A << 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 2bbb: rrca ; increment tens u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (((Z80A >> 1) | (Z80A << 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 2bbc: rrca u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (((Z80A >> 1) | (Z80A << 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; { UINT16 u16Temp0; // 2bbd: add a, 30h u16Temp0 = Z80A + 0x30; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x30))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x30 ^ Z80A ^ 0x80) & (0x30 ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 2bbf: ld (4034h), a ; put number of credits on screen MSPacVideoWrite(0x4034,Z80A); // 2bc2: ld a, (credits) ; number of credits in ram L2bc2: Z80A = (UINT8) (mem[0x4e6e]); // 2bc5: and a, 0fh ; strip Z80A = (UINT8) (Z80A & 0x0f); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); { UINT16 u16Temp0; // 2bc7: add a, 30h u16Temp0 = Z80A + 0x30; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x30))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x30 ^ Z80A ^ 0x80) & (0x30 ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 2bc9: ld (4033h), a ; put number of credits on screen MSPacVideoWrite(0x4033,Z80A); // 2bcc: ret goto returnInstruction; // 2bcd: pop hl L2bcd: Z80L = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); Z80H = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); // 2bce: ld e, (hl) Z80E = (UINT8) (mem[Z80HL]); // 2bcf: inc hl Z80HL = (UINT16) (Z80HL + 1); // 2bd0: ld d, (hl) Z80D = (UINT8) (mem[Z80HL]); // 2bd1: inc hl Z80HL = (UINT16) (Z80HL + 1); // 2bd2: ld c, (hl) Z80C = (UINT8) (mem[Z80HL]); // 2bd3: inc hl Z80HL = (UINT16) (Z80HL + 1); // 2bd4: ld b, (hl) Z80B = (UINT8) (mem[Z80HL]); // 2bd5: inc hl Z80HL = (UINT16) (Z80HL + 1); // 2bd6: ld a, (hl) Z80A = (UINT8) (mem[Z80HL]); // 2bd7: inc hl Z80HL = (UINT16) (Z80HL + 1); // 2bd8: push hl Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80H; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80L; { UINT16 u16Temp0; // 2bd9: ex de, hl u16Temp0 = Z80HL; Z80HL = (UINT16) (Z80DE); Z80DE = (UINT16) (u16Temp0); } // 2bda: ld de, 0020h Z80DE = (UINT16) (0x20); // 2bdd: push hl L2bdd: Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80H; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80L; // 2bde: push bc Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80B; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80C; // 2bdf: ld (hl), c L2bdf: mspacmanIndirectWrite8(Z80HL, Z80C); // 2be0: inc hl Z80HL = (UINT16) (Z80HL + 1); // 2be1: djnz 02bdfh Z80B = (UINT8) (Z80B - 1); if (Z80B != 0) { goto L2bdf; } // 2be3: pop bc Z80C = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); Z80B = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); // 2be4: pop hl Z80L = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); Z80H = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); { UINT32 u32Temp0; // 2be5: add hl, de u32Temp0 = Z80HL + Z80DE; u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80DE) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 2be6: dec a Z80A = (UINT8) (Z80A - 1); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); if ((Z80A & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80A == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 2be7: jr nz, 02bddh if (((u8Flags & 0x40) >> 6) != 1) { goto L2bdd; } // 2be9: ret goto returnInstruction; // 2bea: ld a, (4e00h) ; game mode L2bea: Z80A = (UINT8) (mem[0x4e00]); { UINT16 u16Temp0; // 2bed: cp a, 01h u16Temp0 = Z80A - 1; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 1))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((1 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 2bef: ret z ; return if intro mode if (((u8Flags & 0x40) >> 6) == 1) { goto returnInstruction; } // 2bf0: ld a, (boardno) ; Load A with level number // new board, increment? Z80A = (UINT8) (mem[0x4e13]); // 2bf3: inc a ; Increase by one Z80A = (UINT8) (Z80A + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); if ((Z80A & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80A == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 2bf4: jp 8793h ; Is this level < 8 ? goto L8793; // 2bf9: ld de, 3b08h ; Yes, load DE with address of cherry in fruit t // returns here from 8793... L2bf9: Z80DE = (UINT16) (0x3b08); // 2bfc: ld b, a ; For B = 1 to level number Z80B = (UINT8) (Z80A); // 2bfd: ld c, 07h ; C is 7 = the total number of locations to draw Z80C = (UINT8) (0x07); // 2bff: ld hl, 4004h ; Load HL with the start of video memory Z80HL = (UINT16) (0x4004); // 2c02: ld a, (de) ; Load A with value from fruit table L2c02: Z80A = (UINT8) (mem[Z80DE]); // 2c03: call 2b8fh ; Draw fruit subroutine Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x2c; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x06; goto L2b8f; L2c06: // 2c06: ld a, 04h ; v Z80A = (UINT8) (0x04); { UINT16 u16Temp0; // 2c08: add a, h ; Add 400 to HL u16Temp0 = Z80A + Z80H; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80H))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80H ^ Z80A ^ 0x80) & (Z80H ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 2c09: ld h, a ; HL now points to color memory Z80H = (UINT8) (Z80A); // 2c0a: inc de ; DE now points to color code in fruit table Z80DE = (UINT16) (Z80DE + 1); // 2c0b: ld a, (de) ; Load A with color code from fruit table Z80A = (UINT8) (mem[Z80DE]); // 2c0c: call 2b80h ; Draw color subroutine Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x2c; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x0f; goto L2b80; L2c0f: // 2c0f: ld a, 0fch Z80A = (UINT8) (0xfc); { UINT16 u16Temp0; // 2c11: add a, h ; Subtract 4 from H u16Temp0 = Z80A + Z80H; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80H))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80H ^ Z80A ^ 0x80) & (Z80H ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 2c12: ld h, a ; HL now points back to video memory Z80H = (UINT8) (Z80A); // 2c13: inc de ; Increase pointer to next fruit in table Z80DE = (UINT16) (Z80DE + 1); // 2c14: inc hl Z80HL = (UINT16) (Z80HL + 1); // 2c15: inc hl ; Next starting point is 2 bytes higher Z80HL = (UINT16) (Z80HL + 1); // 2c16: dec c ; Count down how many clears to draw Z80C = (UINT8) (Z80C - 1); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((Z80C == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80C & 0x80) ? 0x80 : 0); if ((Z80C & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80C == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 2c17: djnz 02c02h ; Next B – loop back and draw next fruit Z80B = (UINT8) (Z80B - 1); if (Z80B != 0) { goto L2c02; } // 2c19: dec c ; Count down C. Did C just turn negative? L2c19: Z80C = (UINT8) (Z80C - 1); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((Z80C == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80C & 0x80) ? 0x80 : 0); if ((Z80C & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80C == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 2c1a: ret M ; Yes, return to game, we are done if (((u8Flags & 0x80) >> 7) == 1) { goto returnInstruction; } // 2c1b: call 2b7eh ; No, call subroutine to draw a clear Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x2c; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x1e; goto L2b7e; L2c1e: // 2c1e: ld a, 04h Z80A = (UINT8) (0x04); { UINT16 u16Temp0; // 2c20: add a, h u16Temp0 = Z80A + Z80H; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80H))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80H ^ Z80A ^ 0x80) & (Z80H ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 2c21: ld h, a ; Increase HL by 400 for color value to be clear Z80H = (UINT8) (Z80A); // 2c22: xor a, a ; Load A with 0, the code for black color Z80A = (UINT8) (0); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2c23: call 2b80h ; Draw color subroutine – draws black color Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x2c; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x26; goto L2b80; L2c26: // 2c26: ld a, 0fch Z80A = (UINT8) (0xfc); { UINT16 u16Temp0; // 2c28: add a, h ; Subtract 4 from H u16Temp0 = Z80A + Z80H; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80H))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80H ^ Z80A ^ 0x80) & (Z80H ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 2c29: ld h, a ; HL now points back to video memory Z80H = (UINT8) (Z80A); // 2c2a: inc hl Z80HL = (UINT16) (Z80HL + 1); // 2c2b: inc hl ; Set next starting point to be 2 bytes more Z80HL = (UINT16) (Z80HL + 1); // 2c2c: jr 02c19h ; Jump back and draw next clear goto L2c19; // 2c5e: ld hl, 36a5h ; 36a5 is the text string lookup table // Renders messages from a table with // coordinates and message data // b=message # in table L2c5e: Z80HL = (UINT16) (0x36a5); // 2c61: rst 18h ; (hl+2*b) -> hl Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x2c; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x62; goto L0018; L2c62: // 2c62: ld e, (hl) Z80E = (UINT8) (mem[Z80HL]); // 2c63: inc hl Z80HL = (UINT16) (Z80HL + 1); // 2c64: ld d, (hl) ; de contains start offset Z80D = (UINT8) (mem[Z80HL]); // 2c65: ld ix, 4400h ; start of color RAM Z80IX = (UINT16) (0x4400); { UINT32 u32Temp0; // 2c69: add ix, de ; calculate start pos in CRAM u32Temp0 = Z80IX + Z80DE; u8Flags = (u8Flags & ~0x10) | ((((Z80IX ^ u32Temp0 ^ Z80DE) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80IX = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 2c6b: push ix ; 4400 + (hl) -> stack Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80XH; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80XL; // 2c6d: ld de, 0fc00h Z80DE = (UINT16) (0xfc00); { UINT32 u32Temp0; // 2c70: add ix, de ; calc start pos in VRAM u32Temp0 = Z80IX + Z80DE; u8Flags = (u8Flags & ~0x10) | ((((Z80IX ^ u32Temp0 ^ Z80DE) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80IX = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 2c72: ld de, 0ffffh ; offset for normal text Z80DE = (UINT16) (0xffff); // 2c75: bit 7, (hl) u8Flags = (u8Flags & ~0x40) | ((((mem[Z80HL] & 0x80) == 0)) ? 0x40 : 0); u8Flags |= 0x10; u8Flags &= 0xfd; // 2c77: jr nz, 02c7ch if (((u8Flags & 0x40) >> 6) != 1) { goto L2c7c; } // 2c79: ld de, 0ffe0h ; offset for top + bot 2 lines Z80DE = (UINT16) (0xffe0); // 2c7c: inc hl L2c7c: Z80HL = (UINT16) (Z80HL + 1); // 2c7d: ld a, b ; b -> a Z80A = (UINT8) (Z80B); // 2c7e: ld bc, 0000h ; 0 -> b,c Z80BC = (UINT16) (0); { UINT16 u16Temp0; // 2c81: add a, a ; 2*a -> a u16Temp0 = Z80A + Z80A; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80A))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80A ^ Z80A ^ 0x80) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 2c82: jr c, 02cach ; special draw for entries 80+ if (((u8Flags & 0x01) >> 0) == 1) { goto L2cac; } // 2c84: ld a, (hl) ; read next char L2c84: Z80A = (UINT8) (mem[Z80HL]); { UINT16 u16Temp0; // 2c85: cp a, 2fh ; #2f is end of text u16Temp0 = Z80A - 0x2f; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x2f))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x2f ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 2c87: jr z, 02c92h ; done with VRAM if (((u8Flags & 0x40) >> 6) == 1) { goto L2c92; } // 2c89: ld (ix+00h), a ; write char to screen mspacmanIndirectWrite8(Z80IX, Z80A); // 2c8c: inc hl ; next char Z80HL = (UINT16) (Z80HL + 1); { UINT32 u32Temp0; // 2c8d: add ix, de ; calc next VRAM pos u32Temp0 = Z80IX + Z80DE; u8Flags = (u8Flags & ~0x10) | ((((Z80IX ^ u32Temp0 ^ Z80DE) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80IX = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 2c8f: inc b ; inc char count Z80B = (UINT8) (Z80B + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80B == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80B & 0x80) ? 0x80 : 0); if ((Z80B & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80B == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 2c90: jr 02c84h ; loop goto L2c84; // 2c92: inc hl L2c92: Z80HL = (UINT16) (Z80HL + 1); // 2c93: pop ix ; get CRAM start pos L2c93: Z80XL = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); Z80XH = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); // 2c95: ld a, (hl) ; get color Z80A = (UINT8) (mem[Z80HL]); // 2c96: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2c97: jp m, 2ca4h ; jump if > #80 if (((u8Flags & 0x80) >> 7) == 1) { goto L2ca4; } // 2c9a: ld a, (hl) ; get color L2c9a: Z80A = (UINT8) (mem[Z80HL]); // 2c9b: ld (ix+00h), a ; drop in CRAM mspacmanIndirectWrite8(Z80IX, Z80A); // 2c9e: inc hl ; next color Z80HL = (UINT16) (Z80HL + 1); { UINT32 u32Temp0; // 2c9f: add ix, de ; calc next CRAM pos u32Temp0 = Z80IX + Z80DE; u8Flags = (u8Flags & ~0x10) | ((((Z80IX ^ u32Temp0 ^ Z80DE) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80IX = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 2ca1: djnz 02c9ah ; loop until b=0 Z80B = (UINT8) (Z80B - 1); if (Z80B != 0) { goto L2c9a; } // 2ca3: ret goto returnInstruction; // 2ca4: ld (ix+00h), a ; drop in CRAM // same as above, but all the same color L2ca4: mspacmanIndirectWrite8(Z80IX, Z80A); { UINT32 u32Temp0; // 2ca7: add ix, de ; calc next CRAM pos u32Temp0 = Z80IX + Z80DE; u8Flags = (u8Flags & ~0x10) | ((((Z80IX ^ u32Temp0 ^ Z80DE) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80IX = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 2ca9: djnz 02ca4h ; loop until b=0 Z80B = (UINT8) (Z80B - 1); if (Z80B != 0) { goto L2ca4; } // 2cab: ret goto returnInstruction; // 2cac: ld a, (hl) ; read next char // message # > 80 (erase prev message?) use 2nd color code L2cac: Z80A = (UINT8) (mem[Z80HL]); { UINT16 u16Temp0; // 2cad: cp a, 2fh u16Temp0 = Z80A - 0x2f; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x2f))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x2f ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 2caf: jr z, 02cbbh ; done with vram if (((u8Flags & 0x40) >> 6) == 1) { goto L2cbb; } // 2cb1: ld (ix+00h), 40h ; write 40 to vram mspacmanIndirectWrite8(Z80IX, 0x40); // 2cb5: inc hl ; next char Z80HL = (UINT16) (Z80HL + 1); { UINT32 u32Temp0; // 2cb6: add ix, de ; next screen pos u32Temp0 = Z80IX + Z80DE; u8Flags = (u8Flags & ~0x10) | ((((Z80IX ^ u32Temp0 ^ Z80DE) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80IX = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 2cb8: inc b ; inc char count Z80B = (UINT8) (Z80B + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80B == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80B & 0x80) ? 0x80 : 0); if ((Z80B & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80B == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 2cb9: jr 02cach ; loop goto L2cac; // 2cbb: inc hl ; next char L2cbb: Z80HL = (UINT16) (Z80HL + 1); // 2cbc: inc b ; inc char count Z80B = (UINT8) (Z80B + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80B == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80B & 0x80) ? 0x80 : 0); if ((Z80B & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80B == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } { UINT8 u8Temp0; // 2cbd: cpir ; loop until [hl] = 2f UniqueLabel12: u8Temp0 = mem[Z80HL]; Z80HL = (UINT16) (Z80HL + 1); Z80BC = (UINT16) (Z80BC - 1); if (Z80BC && (Z80A != u8Temp0) && ((s32CyclesRemaining = s32CyclesRemaining - 0x15) >= 0)) { goto UniqueLabel12; } u8Flags &= 0xfd; if (Z80A != u8Temp0) { u8Flags &= 0xbf; } else { u8Flags |= 0x40; } if (Z80BC == 0) { u8Flags &= 0xfb; } else { u8Flags |= 0x04; } } // 2cbf: jr 02c93h ; do CRAM goto L2c93; // 2cc1: jp 9797h ; does something with sprites/cocktail // prep for sound routine? L2cc1: goto L9797; // 2cc4: ld ix, 4ecch L2cc4: Z80IX = (UINT16) (0x4ecc); // 2cc8: ld iy, 4e8ch Z80IY = (UINT16) (0x4e8c); // 2ccc: call 2d44h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x2c; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xcf; goto L2d44; L2ccf: // 2ccf: ld b, a Z80B = (UINT8) (Z80A); // 2cd0: ld a, (4ecch) Z80A = (UINT8) (mem[0x4ecc]); // 2cd3: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2cd4: jr z, 02cdah if (((u8Flags & 0x40) >> 6) == 1) { goto L2cda; } // 2cd6: ld a, b Z80A = (UINT8) (Z80B); // 2cd7: ld (4e91h), a mem[0x4e91] = Z80A; // 2cda: ld hl, 967dh L2cda: Z80HL = (UINT16) (0x967d); // 2cdd: ld ix, 4edch Z80IX = (UINT16) (0x4edc); // 2ce1: ld iy, 4e92h Z80IY = (UINT16) (0x4e92); // 2ce5: call 2d44h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x2c; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xe8; goto L2d44; L2ce8: // 2ce8: ld b, a Z80B = (UINT8) (Z80A); // 2ce9: ld a, (4edch) Z80A = (UINT8) (mem[0x4edc]); // 2cec: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2ced: jr z, 02cf3h if (((u8Flags & 0x40) >> 6) == 1) { goto L2cf3; } // 2cef: ld a, b Z80A = (UINT8) (Z80B); // 2cf0: ld (4e96h), a mem[0x4e96] = Z80A; // 2cf3: ld hl, 968dh L2cf3: Z80HL = (UINT16) (0x968d); // 2cf6: ld ix, 4eech Z80IX = (UINT16) (0x4eec); // 2cfa: ld iy, 4e97h Z80IY = (UINT16) (0x4e97); // 2cfe: call 2d44h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x2d; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 1; goto L2d44; L2d01: // 2d01: ld b, a Z80B = (UINT8) (Z80A); // 2d02: ld a, (4eech) Z80A = (UINT8) (mem[0x4eec]); // 2d05: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2d06: ret z if (((u8Flags & 0x40) >> 6) == 1) { goto returnInstruction; } // 2d07: ld a, b Z80A = (UINT8) (Z80B); // 2d08: ld (4e9bh), a mem[0x4e9b] = Z80A; // 2d0b: ret goto returnInstruction; // 2d0c: ld hl, 3b30h // sound routine... L2d0c: Z80HL = (UINT16) (0x3b30); // 2d0f: ld ix, 4e9ch ; register 1 for sound Z80IX = (UINT16) (0x4e9c); // 2d13: ld iy, 4e8ch ; register 2 for sound Z80IY = (UINT16) (0x4e8c); // 2d17: call 2deeh Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x2d; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x1a; goto L2dee; L2d1a: // 2d1a: ld (4e91h), a mem[0x4e91] = Z80A; // 2d1d: ld hl, 3b40h Z80HL = (UINT16) (0x3b40); // 2d20: ld ix, 4each Z80IX = (UINT16) (0x4eac); // 2d24: ld iy, 4e92h Z80IY = (UINT16) (0x4e92); // 2d28: call 2deeh Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x2d; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x2b; goto L2dee; L2d2b: // 2d2b: ld (4e96h), a mem[0x4e96] = Z80A; // 2d2e: ld hl, 3b80h Z80HL = (UINT16) (0x3b80); // 2d31: ld ix, 4ebch Z80IX = (UINT16) (0x4ebc); // 2d35: ld iy, 4e97h Z80IY = (UINT16) (0x4e97); // 2d39: call 2deeh Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x2d; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x3c; goto L2dee; L2d3c: // 2d3c: ld (4e9bh), a mem[0x4e9b] = Z80A; // 2d3f: xor a, a Z80A = (UINT8) (0); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2d40: ld (4e90h), a mem[0x4e90] = Z80A; // 2d43: ret goto returnInstruction; // 2d44: ld a, (ix+00h) L2d44: Z80A = (UINT8) (mem[Z80IX]); // 2d47: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2d48: jp z, 2df4h if (((u8Flags & 0x40) >> 6) == 1) { goto L2df4; } // 2d4b: ld c, a Z80C = (UINT8) (Z80A); // 2d4c: ld b, 08h Z80B = (UINT8) (0x08); // 2d4e: ld e, 80h Z80E = (UINT8) (0x80); // 2d50: ld a, e L2d50: Z80A = (UINT8) (Z80E); // 2d51: and a, c Z80A = (UINT8) (Z80A & Z80C); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2d52: jr nz, 02d59h if (((u8Flags & 0x40) >> 6) != 1) { goto L2d59; } // 2d54: srl e u8Flags = (u8Flags & ~0x01) | ((Z80E & 1) ? 0x01 : 0); Z80E = (UINT8) (Z80E >> 1); u8Flags = (u8Flags & ~0x80) | ((Z80E & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x40) | ((Z80E == 0) ? 0x40 : 0); u8Flags &= 0xef; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x04) | (((((((Z80E >> 0x07) & 1) + ((Z80E >> 0x06) & 1) + ((Z80E >> 0x05) & 1) + ((Z80E >> 0x04) & 1) + ((Z80E >> 0x03) & 1) + ((Z80E >> 0x02) & 1) + ((Z80E >> 1) & 1) + ((Z80E >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2d56: djnz 02d50h Z80B = (UINT8) (Z80B - 1); if (Z80B != 0) { goto L2d50; } // 2d58: ret goto returnInstruction; // 2d59: ld a, (ix+02h) L2d59: Z80A = (UINT8) (mem[Z80IX + 0x02]); // 2d5c: and a, e Z80A = (UINT8) (Z80A & Z80E); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2d5d: jr nz, 02d66h if (((u8Flags & 0x40) >> 6) != 1) { goto L2d66; } // 2d5f: ld (ix+02h), e mspacmanIndirectWrite8(Z80IX + 0x02, Z80E); // 2d62: jp 364eh goto L364e; { UINT8 u8Temp0; // 2d66: dec (ix+0ch) L2d66: mspacmanIndirectWrite8(Z80IX + 0x0c, mem[Z80IX + 0x0c] - 1); u8Temp0 = mem[Z80IX + 0x0c]; u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 2d69: jp nz, 2dd7h if (((u8Flags & 0x40) >> 6) != 1) { goto L2dd7; } L2d6c: // 2d6c: ld l, (ix+06h) Z80L = (UINT8) (mem[Z80IX + 0x06]); // 2d6f: ld h, (ix+07h) Z80H = (UINT8) (mem[Z80IX + 0x07]); // 2d72: ld a, (hl) L2d72: Z80A = (UINT8) (mem[Z80HL]); // 2d73: inc hl Z80HL = (UINT16) (Z80HL + 1); // 2d74: ld (ix+06h), l mspacmanIndirectWrite8(Z80IX + 0x06, Z80L); // 2d77: ld (ix+07h), h mspacmanIndirectWrite8(Z80IX + 0x07, Z80H); { UINT16 u16Temp0; // 2d7a: cp a, 0f0h u16Temp0 = Z80A - 0xf0; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0xf0))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0xf0 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 2d7c: jr c, 02da5h if (((u8Flags & 0x01) >> 0) == 1) { goto L2da5; } // 2d7e: ld hl, 2d6ch Z80HL = (UINT16) (0x2d6c); // 2d81: push hl Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80H; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80L; // 2d82: and a, 0fh Z80A = (UINT8) (Z80A & 0x0f); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2d84: rst 20h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x2d; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x85; goto L0020; // 2da5: ld b, a L2da5: Z80B = (UINT8) (Z80A); // 2da6: and a, 1fh Z80A = (UINT8) (Z80A & 0x1f); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2da8: jr z, 02dadh if (((u8Flags & 0x40) >> 6) == 1) { goto L2dad; } // 2daa: ld (ix+0dh), b mspacmanIndirectWrite8(Z80IX + 0x0d, Z80B); // 2dad: ld c, (ix+09h) L2dad: Z80C = (UINT8) (mem[Z80IX + 0x09]); // 2db0: ld a, (ix+0bh) Z80A = (UINT8) (mem[Z80IX + 0x0b]); // 2db3: and a, 08h Z80A = (UINT8) (Z80A & 0x08); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2db5: jr z, 02db9h if (((u8Flags & 0x40) >> 6) == 1) { goto L2db9; } // 2db7: ld c, 00h Z80C = (UINT8) (0); // 2db9: ld (ix+0fh), c L2db9: mspacmanIndirectWrite8(Z80IX + 0x0f, Z80C); // 2dbc: ld a, b Z80A = (UINT8) (Z80B); // 2dbd: rlca u8Flags = (u8Flags & ~0x01) | ((Z80A & 0x80) ? 0x01 : 0); Z80A = (UINT8) (((Z80A << 1) | (Z80A >> 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 2dbe: rlca u8Flags = (u8Flags & ~0x01) | ((Z80A & 0x80) ? 0x01 : 0); Z80A = (UINT8) (((Z80A << 1) | (Z80A >> 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 2dbf: rlca u8Flags = (u8Flags & ~0x01) | ((Z80A & 0x80) ? 0x01 : 0); Z80A = (UINT8) (((Z80A << 1) | (Z80A >> 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 2dc0: and a, 07h Z80A = (UINT8) (Z80A & 0x07); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2dc2: ld hl, 3bb0h Z80HL = (UINT16) (0x3bb0); // 2dc5: rst 10h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x2d; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xc6; goto L0010; L2dc6: // 2dc6: ld (ix+0ch), a mspacmanIndirectWrite8(Z80IX + 0x0c, Z80A); // 2dc9: ld a, b Z80A = (UINT8) (Z80B); // 2dca: and a, 1fh Z80A = (UINT8) (Z80A & 0x1f); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2dcc: jr z, 02dd7h if (((u8Flags & 0x40) >> 6) == 1) { goto L2dd7; } // 2dce: and a, 0fh Z80A = (UINT8) (Z80A & 0x0f); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2dd0: ld hl, 3bb8h Z80HL = (UINT16) (0x3bb8); // 2dd3: rst 10h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x2d; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xd4; goto L0010; L2dd4: // 2dd4: ld (ix+0eh), a mspacmanIndirectWrite8(Z80IX + 0x0e, Z80A); // 2dd7: ld l, (ix+0eh) L2dd7: Z80L = (UINT8) (mem[Z80IX + 0x0e]); // 2dda: ld h, 00h Z80H = (UINT8) (0); // 2ddc: ld a, (ix+0dh) Z80A = (UINT8) (mem[Z80IX + 0x0d]); // 2ddf: and a, 10h Z80A = (UINT8) (Z80A & 0x10); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2de1: jr z, 02de5h if (((u8Flags & 0x40) >> 6) == 1) { goto L2de5; } // 2de3: ld a, 01h Z80A = (UINT8) (1); { UINT16 u16Temp0; // 2de5: add a, (ix+04h) L2de5: u16Temp0 = Z80A + mem[Z80IX + 0x04]; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ mem[Z80IX + 0x04]))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((mem[Z80IX + 0x04] ^ Z80A ^ 0x80) & (mem[Z80IX + 0x04] ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 2de8: jp z, 2ee8h if (((u8Flags & 0x40) >> 6) == 1) { goto L2ee8; } // 2deb: jp 2ee4h goto L2ee4; // 2dee: ld a, (ix+00h) // do something with playing the sound sound L2dee: Z80A = (UINT8) (mem[Z80IX]); // 2df1: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2df2: jr nz, 02e1bh if (((u8Flags & 0x40) >> 6) != 1) { goto L2e1b; } // 2df4: ld a, (ix+02h) L2df4: Z80A = (UINT8) (mem[Z80IX + 0x02]); // 2df7: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2df8: ret z if (((u8Flags & 0x40) >> 6) == 1) { goto returnInstruction; } // 2df9: ld (ix+02h), 00h ; this is where the score is zeroed? mspacmanIndirectWrite8(Z80IX + 0x02, 0); // 2dfd: ld (ix+0dh), 00h mspacmanIndirectWrite8(Z80IX + 0x0d, 0); // 2e01: ld (ix+0eh), 00h mspacmanIndirectWrite8(Z80IX + 0x0e, 0); // 2e05: ld (ix+0fh), 00h mspacmanIndirectWrite8(Z80IX + 0x0f, 0); // 2e09: ld (iy+00h), 00h mspacmanIndirectWrite8(Z80IY, 0); // 2e0d: ld (iy+01h), 00h mspacmanIndirectWrite8(Z80IY + 1, 0); // 2e11: ld (iy+02h), 00h mspacmanIndirectWrite8(Z80IY + 0x02, 0); // 2e15: ld (iy+03h), 00h mspacmanIndirectWrite8(Z80IY + 0x03, 0); // 2e19: xor a, a Z80A = (UINT8) (0); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2e1a: ret goto returnInstruction; // 2e1b: ld c, a // do something with playing a sound L2e1b: Z80C = (UINT8) (Z80A); // 2e1c: ld b, 08h Z80B = (UINT8) (0x08); // 2e1e: ld e, 80h Z80E = (UINT8) (0x80); // 2e20: ld a, e L2e20: Z80A = (UINT8) (Z80E); // 2e21: and a, c Z80A = (UINT8) (Z80A & Z80C); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2e22: jr nz, 02e29h if (((u8Flags & 0x40) >> 6) != 1) { goto L2e29; } // 2e24: srl e u8Flags = (u8Flags & ~0x01) | ((Z80E & 1) ? 0x01 : 0); Z80E = (UINT8) (Z80E >> 1); u8Flags = (u8Flags & ~0x80) | ((Z80E & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x40) | ((Z80E == 0) ? 0x40 : 0); u8Flags &= 0xef; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x04) | (((((((Z80E >> 0x07) & 1) + ((Z80E >> 0x06) & 1) + ((Z80E >> 0x05) & 1) + ((Z80E >> 0x04) & 1) + ((Z80E >> 0x03) & 1) + ((Z80E >> 0x02) & 1) + ((Z80E >> 1) & 1) + ((Z80E >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2e26: djnz 02e20h Z80B = (UINT8) (Z80B - 1); if (Z80B != 0) { goto L2e20; } // 2e28: ret goto returnInstruction; // 2e29: ld a, (ix+02h) // do something with playing a sound L2e29: Z80A = (UINT8) (mem[Z80IX + 0x02]); // 2e2c: and a, e Z80A = (UINT8) (Z80A & Z80E); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2e2d: jr nz, 02e6eh if (((u8Flags & 0x40) >> 6) != 1) { goto L2e6e; } // 2e2f: ld (ix+02h), e mspacmanIndirectWrite8(Z80IX + 0x02, Z80E); // 2e32: dec b Z80B = (UINT8) (Z80B - 1); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((Z80B == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80B & 0x80) ? 0x80 : 0); if ((Z80B & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80B == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 2e33: ld a, b Z80A = (UINT8) (Z80B); // 2e34: rlca u8Flags = (u8Flags & ~0x01) | ((Z80A & 0x80) ? 0x01 : 0); Z80A = (UINT8) (((Z80A << 1) | (Z80A >> 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 2e35: rlca u8Flags = (u8Flags & ~0x01) | ((Z80A & 0x80) ? 0x01 : 0); Z80A = (UINT8) (((Z80A << 1) | (Z80A >> 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 2e36: rlca u8Flags = (u8Flags & ~0x01) | ((Z80A & 0x80) ? 0x01 : 0); Z80A = (UINT8) (((Z80A << 1) | (Z80A >> 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 2e37: ld c, a Z80C = (UINT8) (Z80A); // 2e38: ld b, 00h Z80B = (UINT8) (0); // 2e3a: push hl Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80H; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80L; { UINT32 u32Temp0; // 2e3b: add hl, bc u32Temp0 = Z80HL + Z80BC; u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80BC) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 2e3c: push ix Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80XH; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80XL; // 2e3e: pop de Z80E = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); Z80D = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); // 2e3f: inc de Z80DE = (UINT16) (Z80DE + 1); // 2e40: inc de Z80DE = (UINT16) (Z80DE + 1); // 2e41: inc de Z80DE = (UINT16) (Z80DE + 1); // 2e42: ld bc, 0008h Z80BC = (UINT16) (0x08); // 2e45: ldir UniqueLabel13: mspacmanIndirectWrite8(Z80DE, mem[Z80HL]); Z80HL = (UINT16) (Z80HL + 1); Z80DE = (UINT16) (Z80DE + 1); Z80BC = (UINT16) (Z80BC - 1); if (Z80BC != 0) { goto UniqueLabel13; } u8Flags &= 0xef; u8Flags &= 0xfd; if (Z80BC == 0) { u8Flags &= 0xfb; } else { u8Flags |= 0x04; } // 2e47: pop hl Z80L = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); Z80H = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); // 2e48: ld a, (ix+06h) Z80A = (UINT8) (mem[Z80IX + 0x06]); // 2e4b: and a, 7fh Z80A = (UINT8) (Z80A & 0x7f); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2e4d: ld (ix+0ch), a mspacmanIndirectWrite8(Z80IX + 0x0c, Z80A); // 2e50: ld a, (ix+04h) Z80A = (UINT8) (mem[Z80IX + 0x04]); // 2e53: ld (ix+0eh), a mspacmanIndirectWrite8(Z80IX + 0x0e, Z80A); // 2e56: ld a, (ix+09h) Z80A = (UINT8) (mem[Z80IX + 0x09]); // 2e59: ld b, a Z80B = (UINT8) (Z80A); // 2e5a: rrca u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (((Z80A >> 1) | (Z80A << 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 2e5b: rrca u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (((Z80A >> 1) | (Z80A << 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 2e5c: rrca u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (((Z80A >> 1) | (Z80A << 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 2e5d: rrca u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (((Z80A >> 1) | (Z80A << 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 2e5e: and a, 0fh Z80A = (UINT8) (Z80A & 0x0f); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2e60: ld (ix+0bh), a mspacmanIndirectWrite8(Z80IX + 0x0b, Z80A); // 2e63: and a, 08h Z80A = (UINT8) (Z80A & 0x08); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2e65: jr nz, 02e6eh if (((u8Flags & 0x40) >> 6) != 1) { goto L2e6e; } // 2e67: ld (ix+0fh), b mspacmanIndirectWrite8(Z80IX + 0x0f, Z80B); // 2e6a: ld (ix+0dh), 00h mspacmanIndirectWrite8(Z80IX + 0x0d, 0); { UINT8 u8Temp0; // 2e6e: dec (ix+0ch) L2e6e: mspacmanIndirectWrite8(Z80IX + 0x0c, mem[Z80IX + 0x0c] - 1); u8Temp0 = mem[Z80IX + 0x0c]; u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 2e71: jr nz, 02ecdh if (((u8Flags & 0x40) >> 6) != 1) { goto L2ecd; } // 2e73: ld a, (ix+08h) Z80A = (UINT8) (mem[Z80IX + 0x08]); // 2e76: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2e77: jr z, 02e89h if (((u8Flags & 0x40) >> 6) == 1) { goto L2e89; } { UINT8 u8Temp0; // 2e79: dec (ix+08h) mspacmanIndirectWrite8(Z80IX + 0x08, mem[Z80IX + 0x08] - 1); u8Temp0 = mem[Z80IX + 0x08]; u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 2e7c: jr nz, 02e89h if (((u8Flags & 0x40) >> 6) != 1) { goto L2e89; } // 2e7e: ld a, e Z80A = (UINT8) (Z80E); // 2e7f: cpl Z80A = (UINT8) (Z80A ^ 0xff); u8Flags |= 0x10; u8Flags |= 0x02; // 2e80: and a, (ix+00h) Z80A = (UINT8) (Z80A & mem[Z80IX]); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2e83: ld (ix+00h), a mspacmanIndirectWrite8(Z80IX, Z80A); // 2e86: jp 2deeh goto L2dee; // 2e89: ld a, (ix+06h) L2e89: Z80A = (UINT8) (mem[Z80IX + 0x06]); // 2e8c: and a, 7fh Z80A = (UINT8) (Z80A & 0x7f); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2e8e: ld (ix+0ch), a mspacmanIndirectWrite8(Z80IX + 0x0c, Z80A); // 2e91: bit 7, (ix+06h) u8Flags = (u8Flags & ~0x40) | ((((mem[Z80IX + 0x06] & 0x80) == 0)) ? 0x40 : 0); u8Flags |= 0x10; u8Flags &= 0xfd; // 2e95: jr z, 02eadh if (((u8Flags & 0x40) >> 6) == 1) { goto L2ead; } // 2e97: ld a, (ix+05h) Z80A = (UINT8) (mem[Z80IX + 0x05]); { UINT16 u16Temp0; // 2e9a: neg u16Temp0 = 0 - Z80A; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0 ^ Z80A) & (0 ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); } // 2e9c: ld (ix+05h), a mspacmanIndirectWrite8(Z80IX + 0x05, Z80A); // 2e9f: bit 0, (ix+0dh) u8Flags = (u8Flags & ~0x40) | ((((mem[Z80IX + 0x0d] & 1) == 0)) ? 0x40 : 0); u8Flags |= 0x10; u8Flags &= 0xfd; // 2ea3: set 0, (ix+0dh) mspacmanIndirectWrite8((Z80IX + 0x0d), mem[(Z80IX + 0x0d)] | 1); // 2ea7: jr z, 02ecdh if (((u8Flags & 0x40) >> 6) == 1) { goto L2ecd; } // 2ea9: res 0, (ix+0dh) mspacmanIndirectWrite8((Z80IX + 0x0d), mem[(Z80IX + 0x0d)] & 0xfe); // 2ead: ld a, (ix+04h) L2ead: Z80A = (UINT8) (mem[Z80IX + 0x04]); { UINT16 u16Temp0; // 2eb0: add a, (ix+07h) u16Temp0 = Z80A + mem[Z80IX + 0x07]; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ mem[Z80IX + 0x07]))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((mem[Z80IX + 0x07] ^ Z80A ^ 0x80) & (mem[Z80IX + 0x07] ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 2eb3: ld (ix+04h), a mspacmanIndirectWrite8(Z80IX + 0x04, Z80A); // 2eb6: ld (ix+0eh), a mspacmanIndirectWrite8(Z80IX + 0x0e, Z80A); // 2eb9: ld a, (ix+09h) Z80A = (UINT8) (mem[Z80IX + 0x09]); { UINT16 u16Temp0; // 2ebc: add a, (ix+0ah) u16Temp0 = Z80A + mem[Z80IX + 0x0a]; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ mem[Z80IX + 0x0a]))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((mem[Z80IX + 0x0a] ^ Z80A ^ 0x80) & (mem[Z80IX + 0x0a] ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 2ebf: ld (ix+09h), a mspacmanIndirectWrite8(Z80IX + 0x09, Z80A); // 2ec2: ld b, a Z80B = (UINT8) (Z80A); // 2ec3: ld a, (ix+0bh) Z80A = (UINT8) (mem[Z80IX + 0x0b]); // 2ec6: and a, 08h Z80A = (UINT8) (Z80A & 0x08); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2ec8: jr nz, 02ecdh if (((u8Flags & 0x40) >> 6) != 1) { goto L2ecd; } // 2eca: ld (ix+0fh), b mspacmanIndirectWrite8(Z80IX + 0x0f, Z80B); // 2ecd: ld a, (ix+0eh) L2ecd: Z80A = (UINT8) (mem[Z80IX + 0x0e]); { UINT16 u16Temp0; // 2ed0: add a, (ix+05h) u16Temp0 = Z80A + mem[Z80IX + 0x05]; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ mem[Z80IX + 0x05]))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((mem[Z80IX + 0x05] ^ Z80A ^ 0x80) & (mem[Z80IX + 0x05] ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 2ed3: ld (ix+0eh), a mspacmanIndirectWrite8(Z80IX + 0x0e, Z80A); // 2ed6: ld l, a Z80L = (UINT8) (Z80A); // 2ed7: ld h, 00h Z80H = (UINT8) (0); // 2ed9: ld a, (ix+03h) Z80A = (UINT8) (mem[Z80IX + 0x03]); // 2edc: and a, 70h Z80A = (UINT8) (Z80A & 0x70); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2ede: jr z, 02ee8h if (((u8Flags & 0x40) >> 6) == 1) { goto L2ee8; } // 2ee0: rrca u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (((Z80A >> 1) | (Z80A << 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 2ee1: rrca u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (((Z80A >> 1) | (Z80A << 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 2ee2: rrca u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (((Z80A >> 1) | (Z80A << 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 2ee3: rrca u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (((Z80A >> 1) | (Z80A << 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 2ee4: ld b, a L2ee4: Z80B = (UINT8) (Z80A); { UINT32 u32Temp0; // 2ee5: add hl, hl L2ee5: u32Temp0 = Z80HL + Z80HL; u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80HL) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 2ee6: djnz 02ee5h Z80B = (UINT8) (Z80B - 1); if (Z80B != 0) { goto L2ee5; } // 2ee8: ld (iy+00h), l L2ee8: mspacmanIndirectWrite8(Z80IY, Z80L); // 2eeb: ld a, l Z80A = (UINT8) (Z80L); // 2eec: rrca u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (((Z80A >> 1) | (Z80A << 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 2eed: rrca u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (((Z80A >> 1) | (Z80A << 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 2eee: rrca u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (((Z80A >> 1) | (Z80A << 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 2eef: rrca u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (((Z80A >> 1) | (Z80A << 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 2ef0: ld (iy+01h), a mspacmanIndirectWrite8(Z80IY + 1, Z80A); // 2ef3: ld (iy+02h), h mspacmanIndirectWrite8(Z80IY + 0x02, Z80H); // 2ef6: ld a, h Z80A = (UINT8) (Z80H); // 2ef7: rrca u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (((Z80A >> 1) | (Z80A << 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 2ef8: rrca u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (((Z80A >> 1) | (Z80A << 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 2ef9: rrca u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (((Z80A >> 1) | (Z80A << 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 2efa: rrca u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (((Z80A >> 1) | (Z80A << 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 2efb: ld (iy+03h), a mspacmanIndirectWrite8(Z80IY + 0x03, Z80A); // 2efe: ld a, (ix+0bh) Z80A = (UINT8) (mem[Z80IX + 0x0b]); // 2f01: rst 20h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x2f; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x02; goto L0020; L2f22: // 2f22: ld a, (ix+0fh) Z80A = (UINT8) (mem[Z80IX + 0x0f]); // 2f25: ret goto returnInstruction; L2f26: // 2f26: ld a, (ix+0fh) Z80A = (UINT8) (mem[Z80IX + 0x0f]); // 2f29: jr 02f34h goto L2f34; L2f2b: // 2f2b: ld a, (4c84h) Z80A = (UINT8) (mem[0x4c84]); // 2f2e: and a, 01h Z80A = (UINT8) (Z80A & 1); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2f30: ld a, (ix+0fh) L2f30: Z80A = (UINT8) (mem[Z80IX + 0x0f]); // 2f33: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 2f34: and a, 0fh L2f34: Z80A = (UINT8) (Z80A & 0x0f); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2f36: ret z if (((u8Flags & 0x40) >> 6) == 1) { goto returnInstruction; } // 2f37: dec a Z80A = (UINT8) (Z80A - 1); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); if ((Z80A & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80A == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 2f38: ld (ix+0fh), a mspacmanIndirectWrite8(Z80IX + 0x0f, Z80A); // 2f3b: ret goto returnInstruction; L2f3c: // 2f3c: ld a, (4c84h) Z80A = (UINT8) (mem[0x4c84]); // 2f3f: and a, 03h Z80A = (UINT8) (Z80A & 0x03); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2f41: jr 02f30h goto L2f30; L2f43: // 2f43: ld a, (4c84h) Z80A = (UINT8) (mem[0x4c84]); // 2f46: and a, 07h Z80A = (UINT8) (Z80A & 0x07); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2f48: jr 02f30h goto L2f30; L2f4a: // 2f4a: ret goto returnInstruction; L2f4b: // 2f4b: ret goto returnInstruction; L2f4c: // 2f4c: ret goto returnInstruction; L2f4d: // 2f4d: ret goto returnInstruction; L2f4e: // 2f4e: ret goto returnInstruction; L2f4f: // 2f4f: ret goto returnInstruction; L2f50: // 2f50: ret goto returnInstruction; L2f51: // 2f51: ret goto returnInstruction; L2f52: // 2f52: ret goto returnInstruction; L2f53: // 2f53: ret goto returnInstruction; L2f54: // 2f54: ret goto returnInstruction; L2f55: // 2f55: ld l, (ix+06h) Z80L = (UINT8) (mem[Z80IX + 0x06]); // 2f58: ld h, (ix+07h) Z80H = (UINT8) (mem[Z80IX + 0x07]); // 2f5b: ld a, (hl) Z80A = (UINT8) (mem[Z80HL]); // 2f5c: ld (ix+06h), a mspacmanIndirectWrite8(Z80IX + 0x06, Z80A); // 2f5f: inc hl Z80HL = (UINT16) (Z80HL + 1); // 2f60: ld a, (hl) Z80A = (UINT8) (mem[Z80HL]); // 2f61: ld (ix+07h), a mspacmanIndirectWrite8(Z80IX + 0x07, Z80A); // 2f64: ret goto returnInstruction; L2f65: // 2f65: ld l, (ix+06h) Z80L = (UINT8) (mem[Z80IX + 0x06]); // 2f68: ld h, (ix+07h) Z80H = (UINT8) (mem[Z80IX + 0x07]); // 2f6b: ld a, (hl) Z80A = (UINT8) (mem[Z80HL]); // 2f6c: inc hl Z80HL = (UINT16) (Z80HL + 1); // 2f6d: ld (ix+06h), l mspacmanIndirectWrite8(Z80IX + 0x06, Z80L); // 2f70: ld (ix+07h), h mspacmanIndirectWrite8(Z80IX + 0x07, Z80H); // 2f73: ld (ix+03h), a mspacmanIndirectWrite8(Z80IX + 0x03, Z80A); // 2f76: ret goto returnInstruction; L2f77: // 2f77: ld l, (ix+06h) Z80L = (UINT8) (mem[Z80IX + 0x06]); // 2f7a: ld h, (ix+07h) Z80H = (UINT8) (mem[Z80IX + 0x07]); // 2f7d: ld a, (hl) Z80A = (UINT8) (mem[Z80HL]); // 2f7e: inc hl Z80HL = (UINT16) (Z80HL + 1); // 2f7f: ld (ix+06h), l mspacmanIndirectWrite8(Z80IX + 0x06, Z80L); // 2f82: ld (ix+07h), h mspacmanIndirectWrite8(Z80IX + 0x07, Z80H); // 2f85: ld (ix+04h), a mspacmanIndirectWrite8(Z80IX + 0x04, Z80A); // 2f88: ret goto returnInstruction; L2f89: // 2f89: ld l, (ix+06h) Z80L = (UINT8) (mem[Z80IX + 0x06]); // 2f8c: ld h, (ix+07h) Z80H = (UINT8) (mem[Z80IX + 0x07]); // 2f8f: ld a, (hl) Z80A = (UINT8) (mem[Z80HL]); // 2f90: inc hl Z80HL = (UINT16) (Z80HL + 1); // 2f91: ld (ix+06h), l mspacmanIndirectWrite8(Z80IX + 0x06, Z80L); // 2f94: ld (ix+07h), h mspacmanIndirectWrite8(Z80IX + 0x07, Z80H); // 2f97: ld (ix+09h), a mspacmanIndirectWrite8(Z80IX + 0x09, Z80A); // 2f9a: ret goto returnInstruction; L2f9b: // 2f9b: ld l, (ix+06h) Z80L = (UINT8) (mem[Z80IX + 0x06]); // 2f9e: ld h, (ix+07h) Z80H = (UINT8) (mem[Z80IX + 0x07]); // 2fa1: ld a, (hl) Z80A = (UINT8) (mem[Z80HL]); // 2fa2: inc hl Z80HL = (UINT16) (Z80HL + 1); // 2fa3: ld (ix+06h), l mspacmanIndirectWrite8(Z80IX + 0x06, Z80L); // 2fa6: ld (ix+07h), h mspacmanIndirectWrite8(Z80IX + 0x07, Z80H); // 2fa9: ld (ix+0bh), a mspacmanIndirectWrite8(Z80IX + 0x0b, Z80A); // 2fac: ret goto returnInstruction; L2fad: // 2fad: ld a, (ix+02h) Z80A = (UINT8) (mem[Z80IX + 0x02]); // 2fb0: cpl Z80A = (UINT8) (Z80A ^ 0xff); u8Flags |= 0x10; u8Flags |= 0x02; // 2fb1: and a, (ix+00h) Z80A = (UINT8) (Z80A & mem[Z80IX]); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 2fb4: ld (ix+00h), a mspacmanIndirectWrite8(Z80IX, Z80A); // 2fb7: jp 2df4h goto L2df4; L2ffe: { UINT16 u16Temp0; // 2ffe: add a, e u16Temp0 = Z80A + Z80E; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80E))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80E ^ Z80A ^ 0x80) & (Z80E ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 2fff: ld c, h Z80C = (UINT8) (Z80H); // 3000: ld hl, 0000h // rst 38 continuation (initalization routine portion) // the rom checksum routine L3000: Z80HL = (UINT16) (0); // 3003: ld bc, 1000h L3003: Z80BC = (UINT16) (0x1000); // 3006: ld (Wdog), a ; kick the dog // reclaim a lot of romspace by skipping self test ; HACK4 L3006: MSNothingWrite(0x50c0,Z80A); // 3009: ld a, c ; a=0 L3009: Z80A = (UINT8) (Z80C); { UINT16 u16Temp0; UINT8 u8Temp0; // 300a: add a, (hl) u8Temp0 = mem[Z80HL]; u16Temp0 = Z80A + u8Temp0; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ u8Temp0))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((u8Temp0 ^ Z80A ^ 0x80) & (u8Temp0 ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 300b: ld c, a Z80C = (UINT8) (Z80A); // 300c: ld a, l Z80A = (UINT8) (Z80L); { UINT16 u16Temp0; // 300d: add a, 02h u16Temp0 = Z80A + 0x02; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x02))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x02 ^ Z80A ^ 0x80) & (0x02 ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 300f: ld l, a Z80L = (UINT8) (Z80A); { UINT16 u16Temp0; // 3010: cp a, 02h u16Temp0 = Z80A - 0x02; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x02))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x02 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 3012: jp nc, 3009h if (((u8Flags & 0x01) >> 0) != 1) { goto L3009; } // 3015: inc h Z80H = (UINT8) (Z80H + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80H == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80H & 0x80) ? 0x80 : 0); if ((Z80H & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80H == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 3016: djnz 03006h Z80B = (UINT8) (Z80B - 1); if (Z80B != 0) { goto L3006; } // 3018: ld a, c Z80A = (UINT8) (Z80C); // 3019: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 301a: nop ; this is a hack to disregard bad csums // 301b: nop ; this is a hack to disregard bad csums // 301c: ld (coinct), a ; clear coin MSStuffWrite(0x5007,Z80A); // 301f: ld a, h Z80A = (UINT8) (Z80H); { UINT16 u16Temp0; // 3020: cp a, 30h u16Temp0 = Z80A - 0x30; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x30))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x30 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 3022: jp nz, 3003h ; continue for other roms if (((u8Flags & 0x40) >> 6) != 1) { goto L3003; } // 3025: ld h, 00h Z80H = (UINT8) (0); // 3027: inc l Z80L = (UINT8) (Z80L + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80L == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80L & 0x80) ? 0x80 : 0); if ((Z80L & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80L == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 3028: ld a, l Z80A = (UINT8) (Z80L); { UINT16 u16Temp0; // 3029: cp a, 02h u16Temp0 = Z80A - 0x02; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x02))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x02 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 302b: jp c, 3003h if (((u8Flags & 0x01) >> 0) == 1) { goto L3003; } // 302e: jp 3042h goto L3042; // 3042: ld sp, 3154h // RAM TEST (4c00) L3042: Z80SP = (UINT16) (0x3154); // 3045: ld b, 0ffh L3045: Z80B = (UINT8) (0xff); // 3047: pop hl ; 4c00 (first time) L3047: Z80L = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); Z80H = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); // 3048: pop de ; 040f (first time) Z80E = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); Z80D = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); // 3049: ld c, b ; 0xff -> c Z80C = (UINT8) (Z80B); // 304a: ld (Wdog), a ; kick the dog // write stuff to ram L304a: MSNothingWrite(0x50c0,Z80A); // 304d: ld a, c ; 0xff -> a L304d: Z80A = (UINT8) (Z80C); // 304e: and a, e ; e -> a Z80A = (UINT8) (Z80A & Z80E); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 304f: ld (hl), a mspacmanIndirectWrite8(Z80HL, Z80A); { UINT16 u16Temp0; // 3050: add a, 33h u16Temp0 = Z80A + 0x33; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x33))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x33 ^ Z80A ^ 0x80) & (0x33 ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 3052: ld c, a Z80C = (UINT8) (Z80A); // 3053: inc l Z80L = (UINT8) (Z80L + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80L == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80L & 0x80) ? 0x80 : 0); if ((Z80L & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80L == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 3054: ld a, l Z80A = (UINT8) (Z80L); // 3055: and a, 0fh Z80A = (UINT8) (Z80A & 0x0f); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 3057: jp nz, 304dh if (((u8Flags & 0x40) >> 6) != 1) { goto L304d; } // 305a: ld a, c Z80A = (UINT8) (Z80C); { UINT16 u16Temp0; // 305b: add a, a u16Temp0 = Z80A + Z80A; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80A))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80A ^ Z80A ^ 0x80) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } { UINT16 u16Temp0; // 305c: add a, a u16Temp0 = Z80A + Z80A; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80A))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80A ^ Z80A ^ 0x80) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } { UINT16 u16Temp0; // 305d: add a, c u16Temp0 = Z80A + Z80C; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80C))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80C ^ Z80A ^ 0x80) & (Z80C ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } { UINT16 u16Temp0; // 305e: add a, 31h u16Temp0 = Z80A + 0x31; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x31))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x31 ^ Z80A ^ 0x80) & (0x31 ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 3060: ld c, a Z80C = (UINT8) (Z80A); // 3061: ld a, l Z80A = (UINT8) (Z80L); // 3062: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 3063: jp nz, 304dh if (((u8Flags & 0x40) >> 6) != 1) { goto L304d; } // 3066: inc h Z80H = (UINT8) (Z80H + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80H == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80H & 0x80) ? 0x80 : 0); if ((Z80H & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80H == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 3067: dec d Z80D = (UINT8) (Z80D - 1); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((Z80D == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80D & 0x80) ? 0x80 : 0); if ((Z80D & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80D == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 3068: jp nz, 304ah if (((u8Flags & 0x40) >> 6) != 1) { goto L304a; } // 306b: dec sp Z80SP = (UINT16) (Z80SP - 1); // 306c: dec sp Z80SP = (UINT16) (Z80SP - 1); // 306d: dec sp Z80SP = (UINT16) (Z80SP - 1); // 306e: dec sp Z80SP = (UINT16) (Z80SP - 1); // 306f: pop hl Z80L = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); Z80H = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); // 3070: pop de ; 4c00 Z80E = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); Z80D = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); // 3071: ld c, b ; 040f Z80C = (UINT8) (Z80B); // 3072: ld (Wdog), a ; kick the dog // check ram again L3072: MSNothingWrite(0x50c0,Z80A); // 3075: ld a, c L3075: Z80A = (UINT8) (Z80C); // 3076: and a, e Z80A = (UINT8) (Z80A & Z80E); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 3077: ld c, a Z80C = (UINT8) (Z80A); // 3078: ld a, (hl) Z80A = (UINT8) (mem[Z80HL]); // 3079: and a, e Z80A = (UINT8) (Z80A & Z80E); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); { UINT16 u16Temp0; // 307a: cp a, c u16Temp0 = Z80A - Z80C; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80C))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80C ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 307b: jp nz, 30b5h ; ram test failed if (((u8Flags & 0x40) >> 6) != 1) { goto L30b5; } { UINT16 u16Temp0; // 307e: add a, 33h u16Temp0 = Z80A + 0x33; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x33))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x33 ^ Z80A ^ 0x80) & (0x33 ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 3080: ld c, a Z80C = (UINT8) (Z80A); // 3081: inc l Z80L = (UINT8) (Z80L + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80L == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80L & 0x80) ? 0x80 : 0); if ((Z80L & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80L == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 3082: ld a, l Z80A = (UINT8) (Z80L); // 3083: and a, 0fh Z80A = (UINT8) (Z80A & 0x0f); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 3085: jp nz, 3075h if (((u8Flags & 0x40) >> 6) != 1) { goto L3075; } // 3088: ld a, c Z80A = (UINT8) (Z80C); { UINT16 u16Temp0; // 3089: add a, a u16Temp0 = Z80A + Z80A; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80A))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80A ^ Z80A ^ 0x80) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } { UINT16 u16Temp0; // 308a: add a, a u16Temp0 = Z80A + Z80A; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80A))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80A ^ Z80A ^ 0x80) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } { UINT16 u16Temp0; // 308b: add a, c u16Temp0 = Z80A + Z80C; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80C))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80C ^ Z80A ^ 0x80) & (Z80C ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } { UINT16 u16Temp0; // 308c: add a, 31h u16Temp0 = Z80A + 0x31; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x31))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x31 ^ Z80A ^ 0x80) & (0x31 ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 308e: ld c, a Z80C = (UINT8) (Z80A); // 308f: ld a, l Z80A = (UINT8) (Z80L); // 3090: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 3091: jp nz, 3075h if (((u8Flags & 0x40) >> 6) != 1) { goto L3075; } // 3094: inc h Z80H = (UINT8) (Z80H + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80H == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80H & 0x80) ? 0x80 : 0); if ((Z80H & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80H == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 3095: dec d Z80D = (UINT8) (Z80D - 1); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((Z80D == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80D & 0x80) ? 0x80 : 0); if ((Z80D & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80D == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 3096: jp nz, 3072h if (((u8Flags & 0x40) >> 6) != 1) { goto L3072; } // 3099: dec sp Z80SP = (UINT16) (Z80SP - 1); // 309a: dec sp Z80SP = (UINT16) (Z80SP - 1); // 309b: dec sp Z80SP = (UINT16) (Z80SP - 1); // 309c: dec sp Z80SP = (UINT16) (Z80SP - 1); // 309d: ld a, b Z80A = (UINT8) (Z80B); { UINT16 u16Temp0; // 309e: sub a, 10h u16Temp0 = Z80A - 0x10; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x10))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x10 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 30a0: ld b, a Z80B = (UINT8) (Z80A); // 30a1: djnz 03047h Z80B = (UINT8) (Z80B - 1); if (Z80B != 0) { goto L3047; } // 30a3: pop af ; 4c00 u8Flags = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); Z80A = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); // 30a4: pop de Z80E = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); Z80D = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); { UINT16 u16Temp0; // 30a5: cp a, 44h u16Temp0 = Z80A - 0x44; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x44))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x44 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 30a7: jp nz, 3045h ; check if 0x44xx done if (((u8Flags & 0x40) >> 6) != 1) { goto L3045; } // 30aa: ld a, e Z80A = (UINT8) (Z80E); // 30ab: xor a, 0f0h Z80A = (UINT8) (Z80A ^ 0xf0); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 30ad: jp nz, 3045h ; check if totally done if (((u8Flags & 0x40) >> 6) != 1) { goto L3045; } // 30b0: ld b, 01h Z80B = (UINT8) (1); // 30b2: jp 30bdh goto L30bd; // 30b5: ld a, e // display bad ram L30b5: Z80A = (UINT8) (Z80E); // 30b6: and a, 01h Z80A = (UINT8) (Z80A & 1); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 30b8: xor a, 01h Z80A = (UINT8) (Z80A ^ 1); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 30ba: ld e, a Z80E = (UINT8) (Z80A); // 30bb: ld b, 00h Z80B = (UINT8) (0); // 30bd: ld sp, 4fc0h // display bad rom L30bd: Z80SP = (UINT16) (0x4fc0); { UINT16 u16Temp0; // 30c0: exx ; swap register pairs u16Temp0 = Z80hlprime; Z80hlprime = (UINT16) (Z80HL); Z80HL = (UINT16) (u16Temp0); u16Temp0 = Z80deprime; Z80deprime = (UINT16) (Z80DE); Z80DE = (UINT16) (u16Temp0); u16Temp0 = Z80bcprime; Z80bcprime = (UINT16) (Z80BC); Z80BC = (UINT16) (u16Temp0); } // 30c1: ld hl, 4c00h // clear all program ram Z80HL = (UINT16) (0x4c00); // 30c4: ld b, 04h Z80B = (UINT8) (0x04); // 30c6: ld (Wdog), a ; kick the dog L30c6: MSNothingWrite(0x50c0,Z80A); // 30c9: ld (hl), 00h L30c9: mspacmanIndirectWrite8(Z80HL, 0); // 30cb: inc l Z80L = (UINT8) (Z80L + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80L == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80L & 0x80) ? 0x80 : 0); if ((Z80L & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80L == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 30cc: jr nz, 030c9h if (((u8Flags & 0x40) >> 6) != 1) { goto L30c9; } // 30ce: inc h Z80H = (UINT8) (Z80H + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80H == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80H & 0x80) ? 0x80 : 0); if ((Z80H & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80H == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 30cf: djnz 030c6h Z80B = (UINT8) (Z80B - 1); if (Z80B != 0) { goto L30c6; } // 30d1: ld hl, 4000h // set all video ram to 0x40 - clear screen Z80HL = (UINT16) (0x4000); // 30d4: ld b, 04h Z80B = (UINT8) (0x04); // 30d6: ld (Wdog), a ; kick the dog L30d6: MSNothingWrite(0x50c0,Z80A); // 30d9: ld a, 40h Z80A = (UINT8) (0x40); // 30db: ld (hl), a L30db: mspacmanIndirectWrite8(Z80HL, Z80A); // 30dc: inc l Z80L = (UINT8) (Z80L + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80L == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80L & 0x80) ? 0x80 : 0); if ((Z80L & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80L == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 30dd: jr nz, 030dbh if (((u8Flags & 0x40) >> 6) != 1) { goto L30db; } // 30df: inc h Z80H = (UINT8) (Z80H + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80H == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80H & 0x80) ? 0x80 : 0); if ((Z80H & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80H == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 30e0: djnz 030d6h Z80B = (UINT8) (Z80B - 1); if (Z80B != 0) { goto L30d6; } // 30e2: ld b, 04h // set all color ram to 0x0f Z80B = (UINT8) (0x04); // 30e4: ld (Wdog), a ; kick the dog L30e4: MSNothingWrite(0x50c0,Z80A); // 30e7: ld a, 0fh Z80A = (UINT8) (0x0f); // 30e9: ld (hl), a L30e9: mspacmanIndirectWrite8(Z80HL, Z80A); // 30ea: inc l Z80L = (UINT8) (Z80L + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80L == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80L & 0x80) ? 0x80 : 0); if ((Z80L & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80L == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 30eb: jr nz, 030e9h if (((u8Flags & 0x40) >> 6) != 1) { goto L30e9; } // 30ed: inc h Z80H = (UINT8) (Z80H + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80H == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80H & 0x80) ? 0x80 : 0); if ((Z80H & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80H == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 30ee: djnz 030e4h Z80B = (UINT8) (Z80B - 1); if (Z80B != 0) { goto L30e4; } { UINT16 u16Temp0; // 30f0: exx ; reswap register pairs u16Temp0 = Z80hlprime; Z80hlprime = (UINT16) (Z80HL); Z80HL = (UINT16) (u16Temp0); u16Temp0 = Z80deprime; Z80deprime = (UINT16) (Z80DE); Z80DE = (UINT16) (u16Temp0); u16Temp0 = Z80bcprime; Z80bcprime = (UINT16) (Z80BC); Z80BC = (UINT16) (u16Temp0); } // 30f1: djnz 030fbh ; (8) b=1 -> no errors Z80B = (UINT8) (Z80B - 1); if (Z80B != 0) { goto L30fb; } // 30f3: ld b, 23h Z80B = (UINT8) (0x23); // 30f5: call 2c5eh ; print MEMORY OK // eliminate startup tests ; HACK7 Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x30; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xf8; goto L2c5e; L30f8: // 30f8: jp 3174h ; run the game! goto L3174; // 30fb: ld a, e ; bad rom # => a L30fb: Z80A = (UINT8) (Z80E); { UINT16 u16Temp0; // 30fc: add a, 30h u16Temp0 = Z80A + 0x30; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x30))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x30 ^ Z80A ^ 0x80) & (0x30 ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 30fe: ld (4184h), a ; write to screen MSPacVideoWrite(0x4184,Z80A); // 3101: push bc ; ff0f Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80B; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80C; // 3102: push hl ; 4c00 Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80H; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80L; // 3103: ld b, 24h ; 'BAD R M' Z80B = (UINT8) (0x24); // 3105: call 2c5eh ; print Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x31; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x08; goto L2c5e; L3108: // 3108: pop hl Z80L = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); Z80H = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); // 3109: ld a, h Z80A = (UINT8) (Z80H); { UINT16 u16Temp0; // 310a: cp a, 40h u16Temp0 = Z80A - 0x40; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x40))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x40 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 310c: ld hl, (316ch) Z80L = (UINT8) (0x4f); Z80H = (UINT8) (0x40); // 310f: jr c, 03122h if (((u8Flags & 0x01) >> 0) == 1) { goto L3122; } { UINT16 u16Temp0; // 3111: cp a, 4ch u16Temp0 = Z80A - 0x4c; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x4c))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x4c ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 3113: ld hl, (316eh) Z80L = (UINT8) (0x41); Z80H = (UINT8) (0x57); // 3116: jr nc, 03122h if (((u8Flags & 0x01) >> 0) != 1) { goto L3122; } { UINT16 u16Temp0; // 3118: cp a, 44h u16Temp0 = Z80A - 0x44; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x44))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x44 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 311a: ld hl, (3170h) Z80L = (UINT8) (0x41); Z80H = (UINT8) (0x56); // 311d: jr c, 03122h if (((u8Flags & 0x01) >> 0) == 1) { goto L3122; } // 311f: ld hl, (3172h) Z80L = (UINT8) (0x41); Z80H = (UINT8) (0x43); // 3122: ld a, l L3122: Z80A = (UINT8) (Z80L); // 3123: ld (4204h), a MSPacVideoWrite(0x4204,Z80A); // 3126: ld a, h Z80A = (UINT8) (Z80H); // 3127: ld (4264h), a MSPacVideoWrite(0x4264,Z80A); // 312a: ld a, (IRQEn) ; in0 // check player 1 Z80A = (UINT8) (mem[0x5000]); // 312d: ld b, a Z80B = (UINT8) (Z80A); // 312e: ld a, (V1Acc) ; in1 // check player 2 Z80A = (UINT8) (mem[0x5040]); // 3131: or a, b ; check for both sticks up? Z80A = (UINT8) (Z80A | Z80B); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 3132: and a, 01h Z80A = (UINT8) (Z80A & 1); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 3134: jr nz, 03147h if (((u8Flags & 0x40) >> 6) != 1) { goto L3147; } // 3136: pop bc Z80C = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); Z80B = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); // 3137: ld a, c Z80A = (UINT8) (Z80C); // 3138: and a, 0fh Z80A = (UINT8) (Z80A & 0x0f); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 313a: ld b, a Z80B = (UINT8) (Z80A); // 313b: ld a, c Z80A = (UINT8) (Z80C); // 313c: and a, 0f0h Z80A = (UINT8) (Z80A & 0xf0); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 313e: rrca u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (((Z80A >> 1) | (Z80A << 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 313f: rrca u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (((Z80A >> 1) | (Z80A << 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 3140: rrca u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (((Z80A >> 1) | (Z80A << 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 3141: rrca u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (((Z80A >> 1) | (Z80A << 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 3142: ld c, a Z80C = (UINT8) (Z80A); // 3143: ld (4185h), bc MSPacVideoWrite(0x4185,Z80C); MSPacVideoWrite(0x4186,Z80B); // 3147: ld (Wdog), a ; kick the dog L3147: MSNothingWrite(0x50c0,Z80A); // 314a: ld a, (V1Acc) ; check in1 Z80A = (UINT8) (mem[0x5040]); // 314d: and a, 10h Z80A = (UINT8) (Z80A & 0x10); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 314f: jr z, 03147h if (((u8Flags & 0x40) >> 6) == 1) { goto L3147; } // 3151: jp 230bh goto L230b; // 3174: ld hl, coinlk // start the main section... (tests first) L3174: Z80HL = (UINT16) (0x5006); // 3177: ld a, 01h Z80A = (UINT8) (1); // 3179: ld (hl), a ; enable all L3179: mspacmanIndirectWrite8(Z80HL, Z80A); // 317a: dec l Z80L = (UINT8) (Z80L - 1); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((Z80L == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80L & 0x80) ? 0x80 : 0); if ((Z80L & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80L == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 317b: jr nz, 03179h if (((u8Flags & 0x40) >> 6) != 1) { goto L3179; } // 317d: xor a, a ; 0x00->a Z80A = (UINT8) (0); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 317e: ld (flpscr), a ; unflip screen MSStuffWrite(0x5003,Z80A); { UINT16 u16Temp0; // 3181: sub a, 04h ; 0xfc->a u16Temp0 = Z80A - 0x04; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x04))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x04 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 3183: ld i, a ; set vector Z80i = (UINT8) (Z80A); // 3185: ld sp, 4fc0h // pac: Z80SP = (UINT16) (0x4fc0); // 3188: ld (Wdog), a ; kick the dog L3188: MSNothingWrite(0x50c0,Z80A); // 318b: xor a, a ; 0x00->a Z80A = (UINT8) (0); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 318c: ld (4e00h), a ; set service mode // Skip test mode: HACK7 mem[0x4e00] = Z80A; // 318f: inc a ; 0x01->a Z80A = (UINT8) (Z80A + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); if ((Z80A & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80A == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 3190: ld (4e01h), a mem[0x4e01] = Z80A; // 3193: ld (IRQEn), a ; enable interrupts MSStuffWrite(0x5000,Z80A); // 3196: ei ; enable interrupts Z80iff |= 0x01; Z80iff |= 0x02; s32CyclesRemaining = s32CyclesRemaining - 0x04; // 3197: ld a, (IRQEn) // test mode sound checks // this gets called if the test switch is on at bootup Z80A = (UINT8) (mem[0x5000]); // 319a: cpl Z80A = (UINT8) (Z80A ^ 0xff); u8Flags |= 0x10; u8Flags |= 0x02; // 319b: ld b, a Z80B = (UINT8) (Z80A); // 319c: and a, 0e0h ; check coin/credit inputs Z80A = (UINT8) (Z80A & 0xe0); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 319e: jr z, 031a5h if (((u8Flags & 0x40) >> 6) == 1) { goto L31a5; } // 31a0: ld a, 02h ; SOUND: pellet eat Z80A = (UINT8) (0x02); // 31a2: ld (4e9ch), a ; choose sound 2 mem[0x4e9c] = Z80A; // 31a5: ld a, (V1Acc) ; check in1 L31a5: Z80A = (UINT8) (mem[0x5040]); // 31a8: cpl Z80A = (UINT8) (Z80A ^ 0xff); u8Flags |= 0x10; u8Flags |= 0x02; // 31a9: ld c, a Z80C = (UINT8) (Z80A); // 31aa: and a, 60h ; check p1/p2 start Z80A = (UINT8) (Z80A & 0x60); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 31ac: jr z, 031b3h if (((u8Flags & 0x40) >> 6) == 1) { goto L31b3; } // 31ae: ld a, 01h ; SOUND: extra base Z80A = (UINT8) (1); // 31b0: ld (4e9ch), a ; choose sound 1 mem[0x4e9c] = Z80A; // 31b3: ld a, b L31b3: Z80A = (UINT8) (Z80B); // 31b4: or a, c Z80A = (UINT8) (Z80A | Z80C); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 31b5: and a, 01h ; check up Z80A = (UINT8) (Z80A & 1); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 31b7: jr z, 031beh if (((u8Flags & 0x40) >> 6) == 1) { goto L31be; } // 31b9: ld a, 08h ; SOUND: fruit eat Z80A = (UINT8) (0x08); // 31bb: ld (4ebch), a ; choose sound 8 mem[0x4ebc] = Z80A; // 31be: ld a, b L31be: Z80A = (UINT8) (Z80B); // 31bf: or a, c Z80A = (UINT8) (Z80A | Z80C); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 31c0: and a, 02h ; check left Z80A = (UINT8) (Z80A & 0x02); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 31c2: jr z, 031c9h if (((u8Flags & 0x40) >> 6) == 1) { goto L31c9; } // 31c4: ld a, 04h ; SOUND: Pellet eat Z80A = (UINT8) (0x04); // 31c6: ld (4ebch), a ; choose sound 4 mem[0x4ebc] = Z80A; // 31c9: ld a, b L31c9: Z80A = (UINT8) (Z80B); // 31ca: or a, c Z80A = (UINT8) (Z80A | Z80C); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 31cb: and a, 04h ; check right Z80A = (UINT8) (Z80A & 0x04); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 31cd: jr z, 031d4h if (((u8Flags & 0x40) >> 6) == 1) { goto L31d4; } // 31cf: ld a, 10h ; SOUND: death Z80A = (UINT8) (0x10); // 31d1: ld (4ebch), a ; choose sound 16 mem[0x4ebc] = Z80A; // 31d4: ld a, b L31d4: Z80A = (UINT8) (Z80B); // 31d5: or a, c Z80A = (UINT8) (Z80A | Z80C); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 31d6: and a, 08h ; check down Z80A = (UINT8) (Z80A & 0x08); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 31d8: jr z, 031dfh if (((u8Flags & 0x40) >> 6) == 1) { goto L31df; } // 31da: ld a, 20h ; SOUND: bassy noise Z80A = (UINT8) (0x20); // 31dc: ld (4ebch), a ; choose sound 32 mem[0x4ebc] = Z80A; // 31df: ld a, (5080h) ; read dips L31df: Z80A = (UINT8) (mem[0x5080]); // 31e2: and a, 03h ; mask coin info Z80A = (UINT8) (Z80A & 0x03); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); { UINT16 u16Temp0; // 31e4: add a, 25h u16Temp0 = Z80A + 0x25; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x25))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x25 ^ Z80A ^ 0x80) & (0x25 ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 31e6: ld b, a Z80B = (UINT8) (Z80A); // 31e7: call 2c5eh ; print FREE PLAY Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x31; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xea; goto L2c5e; L31ea: // 31ea: ld a, (5080h) ; read dips Z80A = (UINT8) (mem[0x5080]); // 31ed: rrca u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (((Z80A >> 1) | (Z80A << 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 31ee: rrca u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (((Z80A >> 1) | (Z80A << 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 31ef: rrca u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (((Z80A >> 1) | (Z80A << 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 31f0: rrca u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (((Z80A >> 1) | (Z80A << 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 31f1: and a, 03h ; mask extras Z80A = (UINT8) (Z80A & 0x03); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); { UINT16 u16Temp0; // 31f3: cp a, 03h u16Temp0 = Z80A - 0x03; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x03))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x03 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 31f5: jr nz, 031ffh if (((u8Flags & 0x40) >> 6) != 1) { goto L31ff; } // 31f7: ld b, 2ah ; 'BONUS NONE' Z80B = (UINT8) (0x2a); // 31f9: call 2c5eh ; print Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x31; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xfc; goto L2c5e; L31fc: // 31fc: jp 321ch goto L321c; // 31ff: rlca L31ff: u8Flags = (u8Flags & ~0x01) | ((Z80A & 0x80) ? 0x01 : 0); Z80A = (UINT8) (((Z80A << 1) | (Z80A >> 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 3200: ld e, a Z80E = (UINT8) (Z80A); // 3201: push de Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80D; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80E; // 3202: ld b, 2bh ; 'BONUS' Z80B = (UINT8) (0x2b); // 3204: call 2c5eh ; print Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x32; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x07; goto L2c5e; L3207: // 3207: ld b, 2eh ; '000' Z80B = (UINT8) (0x2e); // 3209: call 2c5eh ; print Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x32; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x0c; goto L2c5e; L320c: // 320c: pop de Z80E = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); Z80D = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); // 320d: ld d, 00h Z80D = (UINT8) (0); // 320f: ld hl, 32f9h Z80HL = (UINT16) (0x32f9); { UINT32 u32Temp0; // 3212: add hl, de u32Temp0 = Z80HL + Z80DE; u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80DE) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 3213: ld a, (hl) Z80A = (UINT8) (mem[Z80HL]); // 3214: ld (422ah), a MSPacVideoWrite(0x422a,Z80A); // 3217: inc hl Z80HL = (UINT16) (Z80HL + 1); // 3218: ld a, (hl) Z80A = (UINT8) (mem[Z80HL]); // 3219: ld (424ah), a MSPacVideoWrite(0x424a,Z80A); // 321c: ld a, (5080h) ; check in0 L321c: Z80A = (UINT8) (mem[0x5080]); // 321f: rrca u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (((Z80A >> 1) | (Z80A << 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 3220: rrca u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (((Z80A >> 1) | (Z80A << 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 3221: and a, 03h Z80A = (UINT8) (Z80A & 0x03); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); { UINT16 u16Temp0; // 3223: add a, 31h u16Temp0 = Z80A + 0x31; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x31))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x31 ^ Z80A ^ 0x80) & (0x31 ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } { UINT16 u16Temp0; // 3225: cp a, 34h u16Temp0 = Z80A - 0x34; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x34))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x34 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 3227: jr nz, 0322ah if (((u8Flags & 0x40) >> 6) != 1) { goto L322a; } // 3229: inc a Z80A = (UINT8) (Z80A + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); if ((Z80A & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80A == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 322a: ld (41ach), a L322a: MSPacVideoWrite(0x41ac,Z80A); // 322d: ld b, 29h ; 'MS. PAC-MEN' // pac: Z80B = (UINT8) (0x29); // 322f: call 2c5eh ; print Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x32; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x32; goto L2c5e; L3232: // 3232: ld a, (V1Acc) ; check dips Z80A = (UINT8) (mem[0x5040]); // 3235: rlca u8Flags = (u8Flags & ~0x01) | ((Z80A & 0x80) ? 0x01 : 0); Z80A = (UINT8) (((Z80A << 1) | (Z80A >> 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 3236: and a, 01h ; upright or cocktail Z80A = (UINT8) (Z80A & 1); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); { UINT16 u16Temp0; // 3238: add a, 2ch u16Temp0 = Z80A + 0x2c; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x2c))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x2c ^ Z80A ^ 0x80) & (0x2c ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 323a: ld b, a ; 'TABLE'/'UPRIGHT' Z80B = (UINT8) (Z80A); // 323b: call 2c5eh ; print Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x32; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x3e; goto L2c5e; L323e: // 323e: ld a, (V1Acc) ; check in1 Z80A = (UINT8) (mem[0x5040]); // 3241: and a, 10h Z80A = (UINT8) (Z80A & 0x10); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 3243: jp z, 3188h if (((u8Flags & 0x40) >> 6) == 1) { goto L3188; } // 3246: xor a, a Z80A = (UINT8) (0); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 3247: ld (IRQEn), a MSStuffWrite(0x5000,Z80A); // 324a: di ; disable interrupts Z80iff &= 0xfe; // 324b: ld hl, coinct Z80HL = (UINT16) (0x5007); // 324e: xor a, a Z80A = (UINT8) (0); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 324f: ld (hl), a L324f: mspacmanIndirectWrite8(Z80HL, Z80A); // 3250: dec l Z80L = (UINT8) (Z80L - 1); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((Z80L == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80L & 0x80) ? 0x80 : 0); if ((Z80L & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80L == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 3251: jr nz, 0324fh if (((u8Flags & 0x40) >> 6) != 1) { goto L324f; } // 3253: ld sp, 3ae2h // eliminate just the test grid: HACK7 (alternate) // preload the stack with some data for the grid test // prep for the test grid Z80SP = (UINT16) (0x3ae2); // 3256: ld b, 03h Z80B = (UINT8) (0x03); { UINT16 u16Temp0; // 3258: exx L3258: u16Temp0 = Z80hlprime; Z80hlprime = (UINT16) (Z80HL); Z80HL = (UINT16) (u16Temp0); u16Temp0 = Z80deprime; Z80deprime = (UINT16) (Z80DE); Z80DE = (UINT16) (u16Temp0); u16Temp0 = Z80bcprime; Z80bcprime = (UINT16) (Z80BC); Z80BC = (UINT16) (u16Temp0); } // 3259: pop hl ; $3ae2 goes into HL Z80L = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); Z80H = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); // 325a: pop de ; $3ae2-2 into de Z80E = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); Z80D = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); // 325b: ld (Wdog), a ; kick the dog L325b: MSNothingWrite(0x50c0,Z80A); // 325e: pop bc ; $3ae2-4 into bc? Z80C = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); Z80B = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); // 325f: ld a, 3ch ; upper right // draw the test grid to the screen L325f: Z80A = (UINT8) (0x3c); // 3261: ld (hl), a mspacmanIndirectWrite8(Z80HL, Z80A); // 3262: inc hl Z80HL = (UINT16) (Z80HL + 1); // 3263: ld (hl), d ; lower right mspacmanIndirectWrite8(Z80HL, Z80D); // 3264: inc hl Z80HL = (UINT16) (Z80HL + 1); // 3265: djnz 0325fh Z80B = (UINT8) (Z80B - 1); if (Z80B != 0) { goto L325f; } // 3267: dec sp Z80SP = (UINT16) (Z80SP - 1); // 3268: dec sp Z80SP = (UINT16) (Z80SP - 1); // 3269: pop bc Z80C = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); Z80B = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); // 326a: ld (hl), c ; upper right L326a: mspacmanIndirectWrite8(Z80HL, Z80C); // 326b: inc hl Z80HL = (UINT16) (Z80HL + 1); // 326c: ld a, 3fh ; lower left Z80A = (UINT8) (0x3f); // 326e: ld (hl), a mspacmanIndirectWrite8(Z80HL, Z80A); // 326f: inc hl Z80HL = (UINT16) (Z80HL + 1); // 3270: djnz 0326ah Z80B = (UINT8) (Z80B - 1); if (Z80B != 0) { goto L326a; } // 3272: dec sp Z80SP = (UINT16) (Z80SP - 1); // 3273: dec sp Z80SP = (UINT16) (Z80SP - 1); // 3274: dec e Z80E = (UINT8) (Z80E - 1); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((Z80E == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80E & 0x80) ? 0x80 : 0); if ((Z80E & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80E == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 3275: jp nz, 325bh if (((u8Flags & 0x40) >> 6) != 1) { goto L325b; } // 3278: pop af u8Flags = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); Z80A = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); { UINT16 u16Temp0; // 3279: exx u16Temp0 = Z80hlprime; Z80hlprime = (UINT16) (Z80HL); Z80HL = (UINT16) (u16Temp0); u16Temp0 = Z80deprime; Z80deprime = (UINT16) (Z80DE); Z80DE = (UINT16) (u16Temp0); u16Temp0 = Z80bcprime; Z80bcprime = (UINT16) (Z80BC); Z80BC = (UINT16) (u16Temp0); } // 327a: djnz 03258h Z80B = (UINT8) (Z80B - 1); if (Z80B != 0) { goto L3258; } // 327c: ld sp, 4fc0h Z80SP = (UINT16) (0x4fc0); // 327f: ld b, 08h ; delay for 8 times Z80B = (UINT8) (0x08); // 3281: call 32edh ; call the delay routine L3281: Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x32; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x84; goto L32ed; L3284: // 3284: djnz 03281h ; decrement B, delay again if B not 0 Z80B = (UINT8) (Z80B - 1); if (Z80B != 0) { goto L3281; } // 3286: ld (Wdog), a ; kick the dog // loop until service switch turned off. L3286: MSNothingWrite(0x50c0,Z80A); // 3289: ld a, (V1Acc) ; check in1 Z80A = (UINT8) (mem[0x5040]); // 328c: and a, 10h ; check service switch Z80A = (UINT8) (Z80A & 0x10); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 328e: jr z, 03286h ; loop until test switch is off if (((u8Flags & 0x40) >> 6) == 1) { goto L3286; } // 3290: ld a, (V1Acc) ; check in1 // check the condition to display the easter egg Z80A = (UINT8) (mem[0x5040]); // 3293: and a, 60h Z80A = (UINT8) (Z80A & 0x60); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 3295: jp nz, 234bh ; main if (((u8Flags & 0x40) >> 6) != 1) { goto L234b; } // 3298: ld b, 08h Z80B = (UINT8) (0x08); // 329a: call 32edh L329a: Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x32; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x9d; goto L32ed; L329d: // 329d: djnz 0329ah Z80B = (UINT8) (Z80B - 1); if (Z80B != 0) { goto L329a; } // 329f: ld a, (V1Acc) ; check in1 Z80A = (UINT8) (mem[0x5040]); // 32a2: and a, 10h Z80A = (UINT8) (Z80A & 0x10); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 32a4: jp nz, 234bh ; main if (((u8Flags & 0x40) >> 6) != 1) { goto L234b; } // 32a7: ld e, 01h Z80E = (UINT8) (1); // 32a9: ld b, 04h L32a9: Z80B = (UINT8) (0x04); // 32ab: ld (Wdog), a ; kick the dog L32ab: MSNothingWrite(0x50c0,Z80A); // 32ae: call 32edh Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x32; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xb1; goto L32ed; L32b1: // 32b1: ld a, (IRQEn) Z80A = (UINT8) (mem[0x5000]); // 32b4: and a, e Z80A = (UINT8) (Z80A & Z80E); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 32b5: jr nz, 032abh if (((u8Flags & 0x40) >> 6) != 1) { goto L32ab; } // 32b7: call 32edh L32b7: Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x32; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xba; goto L32ed; L32ba: // 32ba: ld (Wdog), a ; kick the dog MSNothingWrite(0x50c0,Z80A); // 32bd: ld a, (IRQEn) ; IN0 Z80A = (UINT8) (mem[0x5000]); // 32c0: xor a, 0ffh Z80A = (UINT8) (Z80A ^ 0xff); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 32c2: jr nz, 032b7h if (((u8Flags & 0x40) >> 6) != 1) { goto L32b7; } // 32c4: djnz 032abh Z80B = (UINT8) (Z80B - 1); if (Z80B != 0) { goto L32ab; } // 32c6: rlc e u8Flags = (u8Flags & ~0x01) | ((Z80E & 0x80) ? 0x01 : 0); Z80E = (UINT8) (((Z80E << 1) | (Z80E >> 0x07))); u8Flags = (u8Flags & ~0x80) | ((Z80E & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x40) | ((Z80E == 0) ? 0x40 : 0); u8Flags &= 0xef; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x04) | (((((((Z80E >> 0x07) & 1) + ((Z80E >> 0x06) & 1) + ((Z80E >> 0x05) & 1) + ((Z80E >> 0x04) & 1) + ((Z80E >> 0x03) & 1) + ((Z80E >> 0x02) & 1) + ((Z80E >> 1) & 1) + ((Z80E >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 32c8: ld a, e Z80A = (UINT8) (Z80E); { UINT16 u16Temp0; // 32c9: cp a, 10h u16Temp0 = Z80A - 0x10; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x10))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x10 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 32cb: jp c, 32a9h if (((u8Flags & 0x01) >> 0) == 1) { goto L32a9; } // 32ce: ld hl, 4000h // draw the 'Made By Namco' easter egg // clear the screen... Z80HL = (UINT16) (0x4000); // 32d1: ld b, 04h Z80B = (UINT8) (0x04); // 32d3: ld a, 40h L32d3: Z80A = (UINT8) (0x40); // 32d5: ld (hl), a L32d5: mspacmanIndirectWrite8(Z80HL, Z80A); // 32d6: inc l Z80L = (UINT8) (Z80L + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80L == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80L & 0x80) ? 0x80 : 0); if ((Z80L & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80L == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 32d7: jr nz, 032d5h if (((u8Flags & 0x40) >> 6) != 1) { goto L32d5; } // 32d9: inc h Z80H = (UINT8) (Z80H + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80H == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80H & 0x80) ? 0x80 : 0); if ((Z80H & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80H == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 32da: djnz 032d3h Z80B = (UINT8) (Z80B - 1); if (Z80B != 0) { goto L32d3; } // 32dc: call 3af4h // draw the egg to the screen Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x32; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xdf; goto L3af4; // 32df: ld (Wdog), a ; kick the dog // wait for service switch to be off L32df: MSNothingWrite(0x50c0,Z80A); // 32e2: ld a, (V1Acc) ; check in1 Z80A = (UINT8) (mem[0x5040]); // 32e5: and a, 10h ; service Z80A = (UINT8) (Z80A & 0x10); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 32e7: jp z, 32dfh if (((u8Flags & 0x40) >> 6) == 1) { goto L32df; } // 32ea: jp 234bh ; main program run goto L234b; // 32ed: ld (Wdog), a ; kick the dog // delay timer L32ed: MSNothingWrite(0x50c0,Z80A); // 32f0: ld hl, 2800h Z80HL = (UINT16) (0x2800); // 32f3: dec hl L32f3: Z80HL = (UINT16) (Z80HL - 1); // 32f4: ld a, h Z80A = (UINT8) (Z80H); // 32f5: or a, l Z80A = (UINT8) (Z80A | Z80L); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 32f6: jr nz, 032f3h if (((u8Flags & 0x40) >> 6) != 1) { goto L32f3; } // 32f8: ret goto returnInstruction; // 3435: ld a, (4f00h) // Maze information... 0x3436 (it is for pac-man...) L3435: Z80A = (UINT8) (mem[0x4f00]); { UINT16 u16Temp0; // 3438: cp a, 01h u16Temp0 = Z80A - 1; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 1))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((1 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 343a: jp z, 349ch if (((u8Flags & 0x40) >> 6) == 1) { goto L349c; } // 343d: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x34; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x3e; goto L0028; L3440: // 3440: ld a, 01h Z80A = (UINT8) (1); // 3442: ld (42ach), a MSPacVideoWrite(0x42ac,Z80A); // 3445: ld a, 16h Z80A = (UINT8) (0x16); // 3447: ld (46ach), a MSPacVideoWrite(0x46ac,Z80A); // 344a: ld c, 00h Z80C = (UINT8) (0); // 344c: jp 349ch goto L349c; // 344f: ld a, (4f00h) L344f: Z80A = (UINT8) (mem[0x4f00]); { UINT16 u16Temp0; // 3452: cp a, 01h u16Temp0 = Z80A - 1; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 1))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((1 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 3454: jp z, 349ch if (((u8Flags & 0x40) >> 6) == 1) { goto L349c; } // 3457: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x34; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x58; goto L0028; L345a: // 345a: ld a, 02h Z80A = (UINT8) (0x02); // 345c: ld (42ach), a MSPacVideoWrite(0x42ac,Z80A); // 345f: ld a, 16h Z80A = (UINT8) (0x16); // 3461: ld (46ach), a MSPacVideoWrite(0x46ac,Z80A); // 3464: ld c, 0ch Z80C = (UINT8) (0x0c); // 3466: jp 349ch goto L349c; // 3469: ld a, (4f00h) L3469: Z80A = (UINT8) (mem[0x4f00]); { UINT16 u16Temp0; // 346c: cp a, 01h u16Temp0 = Z80A - 1; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 1))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((1 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 346e: jp z, 349ch if (((u8Flags & 0x40) >> 6) == 1) { goto L349c; } // 3471: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x34; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x72; goto L0028; L3474: // 3474: ld a, 03h Z80A = (UINT8) (0x03); // 3476: ld (42ach), a MSPacVideoWrite(0x42ac,Z80A); // 3479: ld a, 16h Z80A = (UINT8) (0x16); // 347b: ld (46ach), a MSPacVideoWrite(0x46ac,Z80A); // 347e: ld c, 18h Z80C = (UINT8) (0x18); // 3480: jp 349ch goto L349c; L3483: // 3483: ld c, 24h Z80C = (UINT8) (0x24); // 3485: jp 349ch goto L349c; L3488: // 3488: ld c, 30h Z80C = (UINT8) (0x30); // 348a: jp 349ch goto L349c; L348d: // 348d: ld c, 3ch Z80C = (UINT8) (0x3c); // 348f: jp 349ch goto L349c; L3492: // 3492: ld c, 48h Z80C = (UINT8) (0x48); // 3494: jp 349ch goto L349c; L3497: // 3497: ld c, 54h Z80C = (UINT8) (0x54); // 3499: jp 349ch goto L349c; // 349c: ld a, (4f00h) L349c: Z80A = (UINT8) (mem[0x4f00]); // 349f: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 34a0: call z, 3611h if (((u8Flags & 0x40) >> 6) == 1) { Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x34; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xa3; goto L3611; } L34a3: // 34a3: ld b, 06h Z80B = (UINT8) (0x06); // 34a5: ld ix, 4f0ch Z80IX = (UINT16) (0x4f0c); // 34a9: ld l, (ix+00h) L34a9: Z80L = (UINT8) (mem[Z80IX]); // 34ac: ld h, (ix+01h) Z80H = (UINT8) (mem[Z80IX + 1]); // 34af: ld a, (hl) Z80A = (UINT8) (mem[Z80HL]); { UINT16 u16Temp0; // 34b0: cp a, 0f0h u16Temp0 = Z80A - 0xf0; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0xf0))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0xf0 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 34b2: jp z, 34deh if (((u8Flags & 0x40) >> 6) == 1) { goto L34de; } { UINT16 u16Temp0; // 34b5: cp a, 0f1h u16Temp0 = Z80A - 0xf1; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0xf1))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0xf1 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 34b7: jp z, 356bh if (((u8Flags & 0x40) >> 6) == 1) { goto L356b; } { UINT16 u16Temp0; // 34ba: cp a, 0f2h u16Temp0 = Z80A - 0xf2; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0xf2))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0xf2 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 34bc: jp z, 3597h if (((u8Flags & 0x40) >> 6) == 1) { goto L3597; } { UINT16 u16Temp0; // 34bf: cp a, 0f3h u16Temp0 = Z80A - 0xf3; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0xf3))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0xf3 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 34c1: jp z, 3577h if (((u8Flags & 0x40) >> 6) == 1) { goto L3577; } { UINT16 u16Temp0; // 34c4: cp a, 0f5h u16Temp0 = Z80A - 0xf5; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0xf5))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0xf5 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 34c6: jp z, 3607h if (((u8Flags & 0x40) >> 6) == 1) { goto L3607; } { UINT16 u16Temp0; // 34c9: cp a, 0f6h u16Temp0 = Z80A - 0xf6; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0xf6))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0xf6 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 34cb: jp z, 35a4h if (((u8Flags & 0x40) >> 6) == 1) { goto L35a4; } { UINT16 u16Temp0; // 34ce: cp a, 0f7h u16Temp0 = Z80A - 0xf7; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0xf7))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0xf7 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 34d0: jp z, 35f3h if (((u8Flags & 0x40) >> 6) == 1) { goto L35f3; } { UINT16 u16Temp0; // 34d3: cp a, 0f8h u16Temp0 = Z80A - 0xf8; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0xf8))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0xf8 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 34d5: jp z, 35fdh if (((u8Flags & 0x40) >> 6) == 1) { goto L35fd; } { UINT16 u16Temp0; // 34d8: cp a, 0ffh u16Temp0 = Z80A - 0xff; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0xff))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0xff ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 34da: jp z, 35cbh if (((u8Flags & 0x40) >> 6) == 1) { goto L35cb; } // 34dd: halt Z80halted = 1; s32CyclesRemaining = s32CyclesRemaining - 0x04; if (s32CyclesRemaining >= 0) { s32CyclesRemaining = (s32CyclesRemaining - ((s32CyclesRemaining + 0x03) & 0xfffffffc)); } goto Exit34de; // 34de: push hl L34de: Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80H; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80L; // 34df: ld a, 01h Z80A = (UINT8) (1); // 34e1: rst 10h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x34; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xe2; goto L0010; L34e2: // 34e2: ld c, a Z80C = (UINT8) (Z80A); // 34e3: ld hl, 4f2eh Z80HL = (UINT16) (0x4f2e); // 34e6: rst 18h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x34; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xe7; goto L0018; L34e7: // 34e7: ld a, c Z80A = (UINT8) (Z80C); { UINT16 u16Temp0; // 34e8: add a, h u16Temp0 = Z80A + Z80H; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80H))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80H ^ Z80A ^ 0x80) & (Z80H ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 34e9: call 3556h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x34; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xec; goto L3556; L34ec: // 34ec: ld (de), a mspacmanIndirectWrite8(Z80DE, Z80A); // 34ed: call 3641h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x34; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xf0; goto L3641; L34f0: // 34f0: rst 18h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x34; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xf1; goto L0018; L34f1: // 34f1: ld a, h Z80A = (UINT8) (Z80H); { UINT16 u16Temp0; // 34f2: add a, c u16Temp0 = Z80A + Z80C; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80C))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80C ^ Z80A ^ 0x80) & (Z80C ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 34f3: ld (de), a mspacmanIndirectWrite8(Z80DE, Z80A); // 34f4: pop hl Z80L = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); Z80H = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); // 34f5: push hl Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80H; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80L; // 34f6: ld a, 02h Z80A = (UINT8) (0x02); // 34f8: rst 10h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x34; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xf9; goto L0010; L34f9: // 34f9: ld c, a Z80C = (UINT8) (Z80A); // 34fa: ld hl, 4f2eh Z80HL = (UINT16) (0x4f2e); // 34fd: rst 18h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x34; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xfe; goto L0018; L34fe: // 34fe: ld a, c Z80A = (UINT8) (Z80C); { UINT16 u16Temp0; // 34ff: add a, l u16Temp0 = Z80A + Z80L; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80L))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80L ^ Z80A ^ 0x80) & (Z80L ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 3500: call 3556h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x35; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x03; goto L3556; L3503: // 3503: dec de Z80DE = (UINT16) (Z80DE - 1); // 3504: ld (de), a mspacmanIndirectWrite8(Z80DE, Z80A); // 3505: call 3641h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x35; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x08; goto L3641; L3508: // 3508: rst 18h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x35; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x09; goto L0018; L3509: // 3509: ld a, l Z80A = (UINT8) (Z80L); { UINT16 u16Temp0; // 350a: add a, c u16Temp0 = Z80A + Z80C; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80C))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80C ^ Z80A ^ 0x80) & (Z80C ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 350b: dec de Z80DE = (UINT16) (Z80DE - 1); // 350c: ld (de), a mspacmanIndirectWrite8(Z80DE, Z80A); // 350d: ld hl, 4f0fh Z80HL = (UINT16) (0x4f0f); // 3510: ld a, b Z80A = (UINT8) (Z80B); // 3511: rst 10h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x35; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x12; goto L0010; L3512: // 3512: push hl Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80H; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80L; // 3513: inc a Z80A = (UINT8) (Z80A + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); if ((Z80A & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80A == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 3514: ld c, a Z80C = (UINT8) (Z80A); // 3515: ld hl, 4f3eh L3515: Z80HL = (UINT16) (0x4f3e); // 3518: rst 18h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x35; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x19; goto L0018; L3519: // 3519: ld a, c Z80A = (UINT8) (Z80C); // 351a: sra a u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) ((Z80A >> 1 | (Z80A & 0x80))); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags &= 0xef; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 351c: rst 10h ; dereference sprite number for intro Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x35; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x1d; goto L0010; L351d: { UINT16 u16Temp0; // 351d: cp a, 0ffh u16Temp0 = Z80A - 0xff; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0xff))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0xff ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 351f: jp nz, 3526h if (((u8Flags & 0x40) >> 6) != 1) { goto L3526; } // 3522: ld c, 00h Z80C = (UINT8) (0); // 3524: jr 03515h goto L3515; // 3526: pop hl L3526: Z80L = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); Z80H = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); // 3527: ld (hl), c mspacmanIndirectWrite8(Z80HL, Z80C); // 3528: ld e, a Z80E = (UINT8) (Z80A); // 3529: pop hl Z80L = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); Z80H = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); // 352a: ld a, 03h Z80A = (UINT8) (0x03); // 352c: rst 10h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x35; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x2d; goto L0010; L352d: // 352d: ld d, a Z80D = (UINT8) (Z80A); // 352e: push de Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80D; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80E; // 352f: ld hl, 4f4eh Z80HL = (UINT16) (0x4f4e); // 3532: rst 18h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x35; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x33; goto L0018; L3533: // 3533: pop hl Z80L = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); Z80H = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); { UINT16 u16Temp0; // 3534: ex de, hl u16Temp0 = Z80HL; Z80HL = (UINT16) (Z80DE); Z80DE = (UINT16) (u16Temp0); } // 3535: ld (hl), d mspacmanIndirectWrite8(Z80HL, Z80D); // 3536: dec hl Z80HL = (UINT16) (Z80HL - 1); // 3537: ld a, (4e09h) Z80A = (UINT8) (mem[0x4e09]); // 353a: ld c, a Z80C = (UINT8) (Z80A); // 353b: ld a, (cabtype) Z80A = (UINT8) (mem[0x4e72]); // 353e: and a, c Z80A = (UINT8) (Z80A & Z80C); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 353f: jr z, 03545h if (((u8Flags & 0x40) >> 6) == 1) { goto L3545; } // 3541: ld a, 0c0h Z80A = (UINT8) (0xc0); // 3543: xor a, e Z80A = (UINT8) (Z80A ^ Z80E); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 3544: ld e, a Z80E = (UINT8) (Z80A); // 3545: ld (hl), e L3545: mspacmanIndirectWrite8(Z80HL, Z80E); // 3546: ld hl, 4f17h Z80HL = (UINT16) (0x4f17); // 3549: ld a, b Z80A = (UINT8) (Z80B); // 354a: rst 10h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x35; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x4b; goto L0010; L354b: // 354b: dec a Z80A = (UINT8) (Z80A - 1); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); if ((Z80A & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80A == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 354c: ld (hl), a mspacmanIndirectWrite8(Z80HL, Z80A); // 354d: ld de, 0000h Z80DE = (UINT16) (0); // 3550: jr nz, 035b4h if (((u8Flags & 0x40) >> 6) != 1) { goto L35b4; } // 3552: ld e, 04h Z80E = (UINT8) (0x04); // 3554: jr 035b4h goto L35b4; // 3556: ld c, a L3556: Z80C = (UINT8) (Z80A); // 3557: sra c u8Flags = (u8Flags & ~0x01) | ((Z80C & 1) ? 0x01 : 0); Z80C = (UINT8) ((Z80C >> 1 | (Z80C & 0x80))); u8Flags = (u8Flags & ~0x80) | ((Z80C & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x40) | ((Z80C == 0) ? 0x40 : 0); u8Flags &= 0xef; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x04) | (((((((Z80C >> 0x07) & 1) + ((Z80C >> 0x06) & 1) + ((Z80C >> 0x05) & 1) + ((Z80C >> 0x04) & 1) + ((Z80C >> 0x03) & 1) + ((Z80C >> 0x02) & 1) + ((Z80C >> 1) & 1) + ((Z80C >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 3559: sra c u8Flags = (u8Flags & ~0x01) | ((Z80C & 1) ? 0x01 : 0); Z80C = (UINT8) ((Z80C >> 1 | (Z80C & 0x80))); u8Flags = (u8Flags & ~0x80) | ((Z80C & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x40) | ((Z80C == 0) ? 0x40 : 0); u8Flags &= 0xef; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x04) | (((((((Z80C >> 0x07) & 1) + ((Z80C >> 0x06) & 1) + ((Z80C >> 0x05) & 1) + ((Z80C >> 0x04) & 1) + ((Z80C >> 0x03) & 1) + ((Z80C >> 0x02) & 1) + ((Z80C >> 1) & 1) + ((Z80C >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 355b: sra c u8Flags = (u8Flags & ~0x01) | ((Z80C & 1) ? 0x01 : 0); Z80C = (UINT8) ((Z80C >> 1 | (Z80C & 0x80))); u8Flags = (u8Flags & ~0x80) | ((Z80C & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x40) | ((Z80C == 0) ? 0x40 : 0); u8Flags &= 0xef; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x04) | (((((((Z80C >> 0x07) & 1) + ((Z80C >> 0x06) & 1) + ((Z80C >> 0x05) & 1) + ((Z80C >> 0x04) & 1) + ((Z80C >> 0x03) & 1) + ((Z80C >> 0x02) & 1) + ((Z80C >> 1) & 1) + ((Z80C >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 355d: sra c u8Flags = (u8Flags & ~0x01) | ((Z80C & 1) ? 0x01 : 0); Z80C = (UINT8) ((Z80C >> 1 | (Z80C & 0x80))); u8Flags = (u8Flags & ~0x80) | ((Z80C & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x40) | ((Z80C == 0) ? 0x40 : 0); u8Flags &= 0xef; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x04) | (((((((Z80C >> 0x07) & 1) + ((Z80C >> 0x06) & 1) + ((Z80C >> 0x05) & 1) + ((Z80C >> 0x04) & 1) + ((Z80C >> 0x03) & 1) + ((Z80C >> 0x02) & 1) + ((Z80C >> 1) & 1) + ((Z80C >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 355f: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 3560: jp p, 3568h if (((u8Flags & 0x80) >> 7) != 1) { goto L3568; } // 3563: or a, 0f0h Z80A = (UINT8) (Z80A | 0xf0); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 3565: inc c Z80C = (UINT8) (Z80C + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80C == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80C & 0x80) ? 0x80 : 0); if ((Z80C & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80C == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 3566: jr 0356ah goto L356a; // 3568: and a, 0fh L3568: Z80A = (UINT8) (Z80A & 0x0f); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 356a: ret L356a: goto returnInstruction; { UINT16 u16Temp0; // 356b: ex de, hl L356b: u16Temp0 = Z80HL; Z80HL = (UINT16) (Z80DE); Z80DE = (UINT16) (u16Temp0); } // 356c: call 3641h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x35; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x6f; goto L3641; L356f: { UINT16 u16Temp0; // 356f: ex de, hl u16Temp0 = Z80HL; Z80HL = (UINT16) (Z80DE); Z80DE = (UINT16) (u16Temp0); } // 3570: push de Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80D; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80E; // 3571: inc hl Z80HL = (UINT16) (Z80HL + 1); // 3572: ld d, (hl) Z80D = (UINT8) (mem[Z80HL]); // 3573: inc hl Z80HL = (UINT16) (Z80HL + 1); // 3574: ld e, (hl) Z80E = (UINT8) (mem[Z80HL]); // 3575: jr 0358ah goto L358a; { UINT16 u16Temp0; // 3577: ex de, hl L3577: u16Temp0 = Z80HL; Z80HL = (UINT16) (Z80DE); Z80DE = (UINT16) (u16Temp0); } // 3578: ld hl, 4f0fh Z80HL = (UINT16) (0x4f0f); // 357b: ld a, b Z80A = (UINT8) (Z80B); // 357c: rst 10h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x35; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x7d; goto L0010; L357d: // 357d: ld (hl), 00h mspacmanIndirectWrite8(Z80HL, 0); { UINT16 u16Temp0; // 357f: ex de, hl u16Temp0 = Z80HL; Z80HL = (UINT16) (Z80DE); Z80DE = (UINT16) (u16Temp0); } // 3580: ld de, 4f3eh Z80DE = (UINT16) (0x4f3e); // 3583: push de Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80D; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80E; // 3584: inc hl Z80HL = (UINT16) (Z80HL + 1); // 3585: ld e, (hl) Z80E = (UINT8) (mem[Z80HL]); // 3586: inc hl Z80HL = (UINT16) (Z80HL + 1); // 3587: ld d, (hl) Z80D = (UINT8) (mem[Z80HL]); // 3588: jr 0358ah goto L358a; // 358a: pop hl L358a: Z80L = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); Z80H = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); // 358b: push de Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80D; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80E; // 358c: rst 18h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x35; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x8d; goto L0018; L358d: { UINT16 u16Temp0; // 358d: ex de, hl u16Temp0 = Z80HL; Z80HL = (UINT16) (Z80DE); Z80DE = (UINT16) (u16Temp0); } // 358e: pop de Z80E = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); Z80D = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); // 358f: ld (hl), d mspacmanIndirectWrite8(Z80HL, Z80D); // 3590: dec hl Z80HL = (UINT16) (Z80HL - 1); // 3591: ld (hl), e mspacmanIndirectWrite8(Z80HL, Z80E); // 3592: ld de, 0003h Z80DE = (UINT16) (0x03); // 3595: jr 035b4h goto L35b4; // 3597: inc hl L3597: Z80HL = (UINT16) (Z80HL + 1); // 3598: ld c, (hl) Z80C = (UINT8) (mem[Z80HL]); // 3599: ld hl, 4f17h Z80HL = (UINT16) (0x4f17); // 359c: ld a, b Z80A = (UINT8) (Z80B); // 359d: rst 10h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x35; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x9e; goto L0010; L359e: // 359e: ld (hl), c mspacmanIndirectWrite8(Z80HL, Z80C); // 359f: ld de, 0002h Z80DE = (UINT16) (0x02); // 35a2: jr 035b4h goto L35b4; // 35a4: ld hl, 4f17h L35a4: Z80HL = (UINT16) (0x4f17); // 35a7: ld a, b Z80A = (UINT8) (Z80B); // 35a8: rst 10h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x35; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xa9; goto L0010; L35a9: // 35a9: dec a Z80A = (UINT8) (Z80A - 1); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); if ((Z80A & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80A == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 35aa: ld (hl), a mspacmanIndirectWrite8(Z80HL, Z80A); // 35ab: ld de, 0000h Z80DE = (UINT16) (0); // 35ae: jr nz, 035b4h if (((u8Flags & 0x40) >> 6) != 1) { goto L35b4; } // 35b0: ld e, 01h Z80E = (UINT8) (1); // 35b2: jr 035b4h goto L35b4; // 35b4: ld l, (ix+00h) // 35b5 overlay for pac-man L35b4: Z80L = (UINT8) (mem[Z80IX]); // 35b7: ld h, (ix+01h) Z80H = (UINT8) (mem[Z80IX + 1]); { UINT32 u32Temp0; // 35ba: add hl, de u32Temp0 = Z80HL + Z80DE; u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80DE) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 35bb: ld (ix+00h), l mspacmanIndirectWrite8(Z80IX, Z80L); // 35be: ld (ix+01h), h mspacmanIndirectWrite8(Z80IX + 1, Z80H); // 35c1: dec ix Z80IX = (UINT16) (Z80IX - 1); // 35c3: dec ix Z80IX = (UINT16) (Z80IX - 1); // 35c5: djnz 035c8h Z80B = (UINT8) (Z80B - 1); if (Z80B != 0) { goto L35c8; } // 35c7: ret goto returnInstruction; // 35c8: jp 34a9h L35c8: goto L34a9; // 35cb: ld hl, 4f1fh L35cb: Z80HL = (UINT16) (0x4f1f); // 35ce: ld a, b Z80A = (UINT8) (Z80B); // 35cf: rst 10h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x35; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xd0; goto L0010; L35d0: // 35d0: ld (hl), 01h mspacmanIndirectWrite8(Z80HL, 1); // 35d2: ld hl, 4f20h Z80HL = (UINT16) (0x4f20); // 35d5: ld a, (hl) Z80A = (UINT8) (mem[Z80HL]); // 35d6: inc hl Z80HL = (UINT16) (Z80HL + 1); // 35d7: and a, (hl) Z80A = (UINT8) (Z80A & mem[Z80HL]); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 35d8: inc hl Z80HL = (UINT16) (Z80HL + 1); // 35d9: and a, (hl) Z80A = (UINT8) (Z80A & mem[Z80HL]); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 35da: inc hl Z80HL = (UINT16) (Z80HL + 1); // 35db: and a, (hl) Z80A = (UINT8) (Z80A & mem[Z80HL]); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 35dc: inc hl Z80HL = (UINT16) (Z80HL + 1); // 35dd: and a, (hl) Z80A = (UINT8) (Z80A & mem[Z80HL]); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 35de: inc hl Z80HL = (UINT16) (Z80HL + 1); // 35df: and a, (hl) Z80A = (UINT8) (Z80A & mem[Z80HL]); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 35e0: ld de, 0000h Z80DE = (UINT16) (0); // 35e3: jr z, 035b4h if (((u8Flags & 0x40) >> 6) == 1) { goto L35b4; } // 35e5: ld a, (gmemode) Z80A = (UINT8) (mem[0x4e02]); // 35e8: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 35e9: jp z, 2195h if (((u8Flags & 0x40) >> 6) == 1) { goto L2195; } // 35ec: xor a, a Z80A = (UINT8) (0); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 35ed: ld (4f00h), a mem[0x4f00] = Z80A; // 35f0: jp 058eh goto L058e; // 35f3: ld a, b L35f3: Z80A = (UINT8) (Z80B); // 35f4: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x35; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xf5; goto L0028; L35f7: // 35f7: ld b, a Z80B = (UINT8) (Z80A); // 35f8: ld de, 0001h Z80DE = (UINT16) (1); // 35fb: jr 035b4h goto L35b4; // 35fd: ld a, 40h L35fd: Z80A = (UINT8) (0x40); // 35ff: ld (42ach), a MSPacVideoWrite(0x42ac,Z80A); // 3602: ld de, 0001h Z80DE = (UINT16) (1); // 3605: jr 035b4h goto L35b4; // 3607: inc hl L3607: Z80HL = (UINT16) (Z80HL + 1); // 3608: ld a, (hl) Z80A = (UINT8) (mem[Z80HL]); // 3609: ld (4ebch), a mem[0x4ebc] = Z80A; // 360c: ld de, 0002h Z80DE = (UINT16) (0x02); // 360f: jr 035b4h goto L35b4; // 3611: ld a, (gmemode) L3611: Z80A = (UINT8) (mem[0x4e02]); // 3614: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 3615: jr nz, 0361fh if (((u8Flags & 0x40) >> 6) != 1) { goto L361f; } // 3617: ld a, 02h Z80A = (UINT8) (0x02); // 3619: ld (4ecch), a mem[0x4ecc] = Z80A; // 361c: ld (4edch), a mem[0x4edc] = Z80A; // 361f: ld hl, 81f0h ; map table? L361f: Z80HL = (UINT16) (0x81f0); // 3622: ld b, 00h Z80B = (UINT8) (0); { UINT32 u32Temp0; // 3624: add hl, bc u32Temp0 = Z80HL + Z80BC; u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80BC) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 3625: ld de, 4f02h Z80DE = (UINT16) (0x4f02); // 3628: ld bc, 000ch Z80BC = (UINT16) (0x0c); // 362b: ldir UniqueLabel14: mspacmanIndirectWrite8(Z80DE, mem[Z80HL]); Z80HL = (UINT16) (Z80HL + 1); Z80DE = (UINT16) (Z80DE + 1); Z80BC = (UINT16) (Z80BC - 1); if (Z80BC != 0) { goto UniqueLabel14; } u8Flags &= 0xef; u8Flags &= 0xfd; if (Z80BC == 0) { u8Flags &= 0xfb; } else { u8Flags |= 0x04; } // 362d: ld a, 01h Z80A = (UINT8) (1); // 362f: ld (4f00h), a mem[0x4f00] = Z80A; // 3632: ld (4da4h), a mem[0x4da4] = Z80A; // 3635: ld hl, 4f1fh Z80HL = (UINT16) (0x4f1f); // 3638: ld a, 00h Z80A = (UINT8) (0); // 363a: ld (4da5h), a mem[0x4da5] = Z80A; // 363d: ld b, 14h Z80B = (UINT8) (0x14); // 363f: rst 08h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x36; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x40; goto L0008; L3640: // 3640: ret goto returnInstruction; // 3641: ld a, b L3641: Z80A = (UINT8) (Z80B); { UINT16 u16Temp0; // 3642: cp a, 06h u16Temp0 = Z80A - 0x06; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x06))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x06 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 3644: jr nz, 0364ah if (((u8Flags & 0x40) >> 6) != 1) { goto L364a; } // 3646: ld hl, 4dc6h Z80HL = (UINT16) (0x4dc6); // 3649: ret goto returnInstruction; // 364a: ld hl, 4cfeh L364a: Z80HL = (UINT16) (0x4cfe); // 364d: ret goto returnInstruction; // 364e: dec b L364e: Z80B = (UINT8) (Z80B - 1); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((Z80B == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80B & 0x80) ? 0x80 : 0); if ((Z80B & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80B == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 364f: push bc Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80B; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80C; // 3650: ld a, b Z80A = (UINT8) (Z80B); { UINT16 u16Temp0; // 3651: cp a, 01h u16Temp0 = Z80A - 1; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 1))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((1 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 3653: jr z, 03659h if (((u8Flags & 0x40) >> 6) == 1) { goto L3659; } // 3655: ld b, 00h Z80B = (UINT8) (0); // 3657: jr 0366ah goto L366a; // 3659: ld a, (boardno) L3659: Z80A = (UINT8) (mem[0x4e13]); // 365c: ld b, 01h Z80B = (UINT8) (1); { UINT16 u16Temp0; // 365e: cp a, 01h u16Temp0 = Z80A - 1; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 1))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((1 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 3660: jr z, 0366ah if (((u8Flags & 0x40) >> 6) == 1) { goto L366a; } // 3662: ld b, 02h Z80B = (UINT8) (0x02); { UINT16 u16Temp0; // 3664: cp a, 04h u16Temp0 = Z80A - 0x04; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x04))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x04 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 3666: jr z, 0366ah if (((u8Flags & 0x40) >> 6) == 1) { goto L366a; } // 3668: ld b, 03h Z80B = (UINT8) (0x03); // 366a: rst 18h L366a: Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x36; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x6b; goto L0018; L366b: // 366b: pop bc Z80C = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); Z80B = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); // 366c: jp 2d72h goto L2d72; // 366f: bit 6, a L366f: u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0x40) == 0)) ? 0x40 : 0); u8Flags |= 0x10; u8Flags &= 0xfd; // 3671: jp z, 2066h if (((u8Flags & 0x40) >> 6) == 1) { goto L2066; } // 3674: ld a, 01h Z80A = (UINT8) (1); // 3676: ld (bc), a mspacmanIndirectWrite8(Z80BC, Z80A); // 3677: ret goto returnInstruction; // 3678: ld hl, 0000h L3678: Z80HL = (UINT16) (0); // 367b: ld (4dd2h), hl mem[0x4dd2] = Z80L; mem[0x4dd3] = Z80H; // 367e: ret goto returnInstruction; L367f: // 367f: ld a, (4d08h) Z80A = (UINT8) (mem[0x4d08]); // 3682: and a, 0fh Z80A = (UINT8) (Z80A & 0x0f); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 3684: srl a u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (Z80A >> 1); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags &= 0xef; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 3686: srl a u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (Z80A >> 1); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags &= 0xef; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 3688: cpl Z80A = (UINT8) (Z80A ^ 0xff); u8Flags |= 0x10; u8Flags |= 0x02; // 3689: ld e, 1ch Z80E = (UINT8) (0x1c); { UINT16 u16Temp0; // 368b: add a, e u16Temp0 = Z80A + Z80E; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80E))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80E ^ Z80A ^ 0x80) & (Z80E ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } { UINT16 u16Temp0; // 368c: cp a, 18h u16Temp0 = Z80A - 0x18; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x18))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x18 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 368e: jr nz, 03692h if (((u8Flags & 0x40) >> 6) != 1) { goto L3692; } // 3690: ld a, 36h Z80A = (UINT8) (0x36); // 3692: ld (4c0ah), a ; mspac sprite number L3692: mem[0x4c0a] = Z80A; // 3695: ret goto returnInstruction; // 3af4: ld hl, 40a2h ; video ram start position // Draw the 'Made By Namco' text (egg) L3af4: Z80HL = (UINT16) (0x40a2); // 3af7: ld de, 3a4fh ; pellet data start Z80DE = (UINT16) (0x3a4f); // 3afa: ld (hl), 14h ; set the screen to pellet (14) L3afa: mspacmanIndirectWrite8(Z80HL, 0x14); // 3afc: ld a, (de) ; a = value to use Z80A = (UINT8) (mem[Z80DE]); // 3afd: and a, a ; bit test u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 3afe: ret z ; if 0, we're done... if (((u8Flags & 0x40) >> 6) == 1) { goto returnInstruction; } // 3aff: inc de ; get the next pellet Z80DE = (UINT16) (Z80DE + 1); { UINT16 u16Temp0; // 3b00: add a, l u16Temp0 = Z80A + Z80L; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80L))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80L ^ Z80A ^ 0x80) & (Z80L ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 3b01: ld l, a Z80L = (UINT8) (Z80A); // 3b02: jp nc, 3afah ; next byte if some condition if (((u8Flags & 0x01) >> 0) != 1) { goto L3afa; } // 3b05: inc h Z80H = (UINT8) (Z80H + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80H == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80H & 0x80) ? 0x80 : 0); if ((Z80H & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80H == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 3b06: jr 03afah goto L3afa; // 3e5c: ld a, (gmemode) L3e5c: Z80A = (UINT8) (mem[0x4e02]); { UINT16 u16Temp0; // 3e5f: cp a, 10h u16Temp0 = Z80A - 0x10; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x10))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x10 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 3e61: call nz, 3ed0h if (((u8Flags & 0x40) >> 6) != 1) { Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x3e; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x64; goto L3ed0; } L3e64: // 3e64: ld a, (gmemode) Z80A = (UINT8) (mem[0x4e02]); // 3e67: rst 20h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x3e; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x68; goto L0020; L3e8a: // 3e8a: ret goto returnInstruction; L3e8b: // 3e8b: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x3e; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x8c; goto L0028; L3e8e: // 3e8e: ld a, 60h Z80A = (UINT8) (0x60); // 3e90: ld (4f01h), a mem[0x4f01] = Z80A; // 3e93: jp 058eh goto L058e; L3e96: // 3e96: call 9642h // draw the midway logo and cprt for the attract screen Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x3e; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x99; goto L9642; L3e99: // 3e99: jp 058eh goto L058e; L3e9c: // 3e9c: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x3e; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x9d; goto L0028; L3e9f: // 3e9f: jp 058eh goto L058e; L3ea2: // 3ea2: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x3e; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xa3; goto L0028; L3ea5: // 3ea5: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x3e; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xa6; goto L0028; L3ea8: // 3ea8: jp 058eh goto L058e; L3eab: // 3eab: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x3e; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xac; goto L0028; L3eae: // 3eae: jp 058eh goto L058e; L3eb1: // 3eb1: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x3e; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xb2; goto L0028; L3eb4: // 3eb4: jp 058eh goto L058e; L3eb7: // 3eb7: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x3e; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xb8; goto L0028; L3eba: // 3eba: jp 058eh goto L058e; L3ebd: // 3ebd: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x3e; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xbe; goto L0028; L3ec0: // 3ec0: jp 058eh goto L058e; L3ec3: // 3ec3: rst 28h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x3e; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xc4; goto L0028; L3ec6: // 3ec6: jp 058eh goto L058e; L3ec9: // 3ec9: xor a, a Z80A = (UINT8) (0); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 3eca: ld (lives), a mem[0x4e14] = Z80A; // 3ecd: jp 057ch goto L057c; // 3ed0: ld a, (4f01h) L3ed0: Z80A = (UINT8) (mem[0x4f01]); // 3ed3: inc a Z80A = (UINT8) (Z80A + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); if ((Z80A & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80A == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 3ed4: and a, 0fh Z80A = (UINT8) (Z80A & 0x0f); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 3ed6: ld (4f01h), a mem[0x4f01] = Z80A; // 3ed9: ld c, a Z80C = (UINT8) (Z80A); // 3eda: res 0, c Z80C = (UINT8) (Z80C & 0xfe); // 3edc: ld b, 00h Z80B = (UINT8) (0); // 3ede: ld ix, 3f81h Z80IX = (UINT16) (0x3f81); // 3ee2: bit 0, a u8Flags = (u8Flags & ~0x40) | ((((Z80A & 1) == 0)) ? 0x40 : 0); u8Flags |= 0x10; u8Flags &= 0xfd; // 3ee4: jr z, 03f19h if (((u8Flags & 0x40) >> 6) == 1) { goto L3f19; } { UINT32 u32Temp0; // 3ee6: add ix, bc u32Temp0 = Z80IX + Z80BC; u8Flags = (u8Flags & ~0x10) | ((((Z80IX ^ u32Temp0 ^ Z80BC) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80IX = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 3ee8: ld l, (ix+00h) Z80L = (UINT8) (mem[Z80IX]); // 3eeb: ld h, (ix+01h) Z80H = (UINT8) (mem[Z80IX + 1]); // 3eee: ld (hl), 87h mspacmanIndirectWrite8(Z80HL, 0x87); // 3ef0: ld l, (ix+10h) Z80L = (UINT8) (mem[Z80IX + 0x10]); // 3ef3: ld h, (ix+11h) Z80H = (UINT8) (mem[Z80IX + 0x11]); // 3ef6: ld (hl), 87h mspacmanIndirectWrite8(Z80HL, 0x87); // 3ef8: ld l, (ix+20h) Z80L = (UINT8) (mem[Z80IX + 0x20]); // 3efb: ld h, (ix+21h) Z80H = (UINT8) (mem[Z80IX + 0x21]); // 3efe: ld (hl), 8ah mspacmanIndirectWrite8(Z80HL, 0x8a); // 3f00: ld l, (ix+30h) Z80L = (UINT8) (mem[Z80IX + 0x30]); // 3f03: ld h, (ix+31h) Z80H = (UINT8) (mem[Z80IX + 0x31]); // 3f06: ld (hl), 81h mspacmanIndirectWrite8(Z80HL, 0x81); // 3f08: ld l, (ix+40h) Z80L = (UINT8) (mem[Z80IX + 0x40]); // 3f0b: ld h, (ix+41h) Z80H = (UINT8) (mem[Z80IX + 0x41]); // 3f0e: ld (hl), 81h mspacmanIndirectWrite8(Z80HL, 0x81); // 3f10: ld l, (ix+50h) Z80L = (UINT8) (mem[Z80IX + 0x50]); // 3f13: ld h, (ix+51h) Z80H = (UINT8) (mem[Z80IX + 0x51]); // 3f16: ld (hl), 84h mspacmanIndirectWrite8(Z80HL, 0x84); // 3f18: ret goto returnInstruction; // 3f19: dec c L3f19: Z80C = (UINT8) (Z80C - 1); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((Z80C == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80C & 0x80) ? 0x80 : 0); if ((Z80C & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80C == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 3f1a: xor a, a Z80A = (UINT8) (0); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); { UINT16 u16Temp0; // 3f1b: cp a, c u16Temp0 = Z80A - Z80C; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80C))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80C ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 3f1c: jp m, 3f21h if (((u8Flags & 0x80) >> 7) == 1) { goto L3f21; } // 3f1f: ld b, 0ffh Z80B = (UINT8) (0xff); // 3f21: dec c L3f21: Z80C = (UINT8) (Z80C - 1); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((Z80C == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80C & 0x80) ? 0x80 : 0); if ((Z80C & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80C == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } { UINT32 u32Temp0; // 3f22: add ix, bc u32Temp0 = Z80IX + Z80BC; u8Flags = (u8Flags & ~0x10) | ((((Z80IX ^ u32Temp0 ^ Z80BC) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80IX = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 3f24: ld l, (ix+00h) Z80L = (UINT8) (mem[Z80IX]); // 3f27: ld h, (ix+01h) Z80H = (UINT8) (mem[Z80IX + 1]); { UINT8 u8Temp0; // 3f2a: dec (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] - 1); u8Temp0 = mem[Z80HL]; u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 3f2b: ld l, (ix+02h) Z80L = (UINT8) (mem[Z80IX + 0x02]); // 3f2e: ld h, (ix+03h) Z80H = (UINT8) (mem[Z80IX + 0x03]); // 3f31: ld (hl), 88h mspacmanIndirectWrite8(Z80HL, 0x88); // 3f33: ld l, (ix+10h) Z80L = (UINT8) (mem[Z80IX + 0x10]); // 3f36: ld h, (ix+11h) Z80H = (UINT8) (mem[Z80IX + 0x11]); { UINT8 u8Temp0; // 3f39: dec (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] - 1); u8Temp0 = mem[Z80HL]; u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 3f3a: ld l, (ix+12h) Z80L = (UINT8) (mem[Z80IX + 0x12]); // 3f3d: ld h, (ix+13h) Z80H = (UINT8) (mem[Z80IX + 0x13]); // 3f40: ld (hl), 88h mspacmanIndirectWrite8(Z80HL, 0x88); // 3f42: ld l, (ix+20h) Z80L = (UINT8) (mem[Z80IX + 0x20]); // 3f45: ld h, (ix+21h) Z80H = (UINT8) (mem[Z80IX + 0x21]); { UINT8 u8Temp0; // 3f48: dec (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] - 1); u8Temp0 = mem[Z80HL]; u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 3f49: ld l, (ix+22h) Z80L = (UINT8) (mem[Z80IX + 0x22]); // 3f4c: ld h, (ix+23h) Z80H = (UINT8) (mem[Z80IX + 0x23]); // 3f4f: ld (hl), 8bh mspacmanIndirectWrite8(Z80HL, 0x8b); // 3f51: ld l, (ix+30h) Z80L = (UINT8) (mem[Z80IX + 0x30]); // 3f54: ld h, (ix+31h) Z80H = (UINT8) (mem[Z80IX + 0x31]); { UINT8 u8Temp0; // 3f57: dec (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] - 1); u8Temp0 = mem[Z80HL]; u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 3f58: ld l, (ix+32h) Z80L = (UINT8) (mem[Z80IX + 0x32]); // 3f5b: ld h, (ix+33h) Z80H = (UINT8) (mem[Z80IX + 0x33]); // 3f5e: ld (hl), 82h mspacmanIndirectWrite8(Z80HL, 0x82); // 3f60: ld l, (ix+40h) Z80L = (UINT8) (mem[Z80IX + 0x40]); // 3f63: ld h, (ix+41h) Z80H = (UINT8) (mem[Z80IX + 0x41]); { UINT8 u8Temp0; // 3f66: dec (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] - 1); u8Temp0 = mem[Z80HL]; u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 3f67: ld l, (ix+42h) Z80L = (UINT8) (mem[Z80IX + 0x42]); // 3f6a: ld h, (ix+43h) Z80H = (UINT8) (mem[Z80IX + 0x43]); // 3f6d: ld (hl), 82h mspacmanIndirectWrite8(Z80HL, 0x82); // 3f6f: ld l, (ix+50h) Z80L = (UINT8) (mem[Z80IX + 0x50]); // 3f72: ld h, (ix+51h) Z80H = (UINT8) (mem[Z80IX + 0x51]); { UINT8 u8Temp0; // 3f75: dec (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] - 1); u8Temp0 = mem[Z80HL]; u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 3f76: ld l, (ix+52h) Z80L = (UINT8) (mem[Z80IX + 0x52]); // 3f79: ld h, (ix+53h) Z80H = (UINT8) (mem[Z80IX + 0x53]); // 3f7c: ld (hl), 83h mspacmanIndirectWrite8(Z80HL, 0x83); // 3f7e: ret goto returnInstruction; L8001: // 8001: ld hl, 4000h Z80HL = (UINT16) (0x4000); // 8004: call 946ah Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x80; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x07; goto L946a; L8007: // 8007: ld a, (bc) Z80A = (UINT8) (mem[Z80BC]); // 8008: ld c, (hl) Z80C = (UINT8) (mem[Z80HL]); { UINT8 u8Temp0; // 8009: inc (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 800a: ret goto returnInstruction; L800b: // 800b: jp 3e5ch goto L3e5c; L800e: // 800e: rst 20h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x80; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x0f; goto L0020; L8013: // 8013: jp 3678h goto L3678; L8018: // 8018: jp 3435h goto L3435; L801b: // 801b: rst 20h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x80; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x1c; goto L0020; L8020: // 8020: xor a, a Z80A = (UINT8) (0); u8Flags &= 0xef; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 8021: ld (frbonus), a mem[0x4dd4] = Z80A; // 8024: ret goto returnInstruction; L8083: { UINT16 u16Temp0; // 8083: add a, c u16Temp0 = Z80A + Z80C; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80C))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80C ^ Z80A ^ 0x80) & (Z80C ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } { UINT16 u16Temp0; // 8084: sub a, h u16Temp0 = Z80A - Z80H; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80H))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80H ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 8085: ld c, (hl) Z80C = (UINT8) (mem[Z80HL]); // 8086: ld iy, 0d36h Z80IY = (UINT16) (0x0d36); // 808a: ld e, 0c9h Z80E = (UINT8) (0xc9); // 808c: jp 869ch goto L869c; L8090: // 8090: ld c, l Z80C = (UINT8) (Z80L); // 8091: call 9561h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x80; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x94; goto L9561; L8094: // 8094: call 2966h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x80; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x97; goto L2966; L8097: // 8097: ld (0d132h), hl mem[0xd132] = Z80L; mem[0xd133] = Z80H; // 809a: ld c, l Z80C = (UINT8) (Z80L); // 809b: ld hl, 4each Z80HL = (UINT16) (0x4eac); // 809e: set 6, (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] | 0x40); { UINT16 u16Temp0; // 80a0: ex af, af' u16Temp0 = Z80afprime; Z80afprime = (UINT16) (Z80AF); Z80AF = (UINT16) (u16Temp0); } // 80a1: ld c, (hl) Z80C = (UINT8) (mem[Z80HL]); // 80a2: jp 3469h goto L3469; L80a5: { UINT16 u16Temp0; UINT8 u8Temp0; // 80a5: cp a, (hl) u8Temp0 = mem[Z80HL]; u16Temp0 = Z80A - u8Temp0; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ u8Temp0))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((u8Temp0 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 80a6: ld (080ch), hl // Removed instruction - writes to code @ 0x080c // Removed instruction - writes to code @ 0x080d // 80a9: ld c, l Z80C = (UINT8) (Z80L); // 80aa: ld de, 8094h Z80DE = (UINT16) (0x8094); // 80ad: jp 8818h goto L8818; // 869c: ld a, (4d09h) L869c: Z80A = (UINT8) (mem[0x4d09]); // 869f: and a, 07h Z80A = (UINT8) (Z80A & 0x07); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 86a1: srl a u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (Z80A >> 1); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags &= 0xef; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 86a3: cpl Z80A = (UINT8) (Z80A ^ 0xff); u8Flags |= 0x10; u8Flags |= 0x02; // 86a4: ld e, 30h Z80E = (UINT8) (0x30); { UINT16 u16Temp0; // 86a6: add a, e u16Temp0 = Z80A + Z80E; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80E))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80E ^ Z80A ^ 0x80) & (Z80E ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 86a7: bit 0, a u8Flags = (u8Flags & ~0x40) | ((((Z80A & 1) == 0)) ? 0x40 : 0); u8Flags |= 0x10; u8Flags &= 0xfd; // 86a9: jr nz, 086adh if (((u8Flags & 0x40) >> 6) != 1) { goto L86ad; } // 86ab: ld a, 37h Z80A = (UINT8) (0x37); // 86ad: ld (4c0ah), a ; mspac sprite number L86ad: mem[0x4c0a] = Z80A; // 86b0: ret goto returnInstruction; // 86b1: ld a, (4d08h) L86b1: Z80A = (UINT8) (mem[0x4d08]); // 86b4: and a, 07h Z80A = (UINT8) (Z80A & 0x07); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 86b6: srl a u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (Z80A >> 1); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags &= 0xef; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 86b8: ld e, 30h Z80E = (UINT8) (0x30); { UINT16 u16Temp0; // 86ba: add a, e u16Temp0 = Z80A + Z80E; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80E))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80E ^ Z80A ^ 0x80) & (Z80E ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 86bb: bit 0, a u8Flags = (u8Flags & ~0x40) | ((((Z80A & 1) == 0)) ? 0x40 : 0); u8Flags |= 0x10; u8Flags &= 0xfd; // 86bd: jr nz, 086c1h if (((u8Flags & 0x40) >> 6) != 1) { goto L86c1; } // 86bf: ld a, 34h Z80A = (UINT8) (0x34); // 86c1: ld (4c0ah), a ; mspac sprite number L86c1: mem[0x4c0a] = Z80A; // 86c4: ret goto returnInstruction; // 86c5: ld a, (4d09h) L86c5: Z80A = (UINT8) (mem[0x4d09]); // 86c8: and a, 07h Z80A = (UINT8) (Z80A & 0x07); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 86ca: srl a u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (Z80A >> 1); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags &= 0xef; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 86cc: ld e, 0ach Z80E = (UINT8) (0xac); { UINT16 u16Temp0; // 86ce: add a, e u16Temp0 = Z80A + Z80E; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80E))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80E ^ Z80A ^ 0x80) & (Z80E ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 86cf: bit 0, a u8Flags = (u8Flags & ~0x40) | ((((Z80A & 1) == 0)) ? 0x40 : 0); u8Flags |= 0x10; u8Flags &= 0xfd; // 86d1: jr nz, 086d5h if (((u8Flags & 0x40) >> 6) != 1) { goto L86d5; } // 86d3: ld a, 35h Z80A = (UINT8) (0x35); // 86d5: ld (4c0ah), a ; mspac sprite number L86d5: mem[0x4c0a] = Z80A; // 86d8: ret goto returnInstruction; // 86d9: ld a, (4d08h) L86d9: Z80A = (UINT8) (mem[0x4d08]); // 86dc: and a, 07h Z80A = (UINT8) (Z80A & 0x07); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 86de: srl a u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (Z80A >> 1); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags &= 0xef; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 86e0: cpl Z80A = (UINT8) (Z80A ^ 0xff); u8Flags |= 0x10; u8Flags |= 0x02; // 86e1: ld e, 0f4h Z80E = (UINT8) (0xf4); { UINT16 u16Temp0; // 86e3: add a, e u16Temp0 = Z80A + Z80E; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80E))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80E ^ Z80A ^ 0x80) & (Z80E ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 86e4: bit 0, a u8Flags = (u8Flags & ~0x40) | ((((Z80A & 1) == 0)) ? 0x40 : 0); u8Flags |= 0x10; u8Flags &= 0xfd; // 86e6: jr nz, 086eah if (((u8Flags & 0x40) >> 6) != 1) { goto L86ea; } // 86e8: ld a, 36h Z80A = (UINT8) (0x36); // 86ea: ld (4c0ah), a ; mspac sprite number L86ea: mem[0x4c0a] = Z80A; // 86ed: ret goto returnInstruction; // 86ee: ld a, (4da4h) L86ee: Z80A = (UINT8) (mem[0x4da4]); // 86f1: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 86f2: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 86f3: ld a, (frbonus) Z80A = (UINT8) (mem[0x4dd4]); // 86f6: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 86f7: jp z, 8747h if (((u8Flags & 0x40) >> 6) == 1) { goto L8747; } // 86fa: ld a, (4dd2h) Z80A = (UINT8) (mem[0x4dd2]); // 86fd: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 86fe: jp z, 8747h if (((u8Flags & 0x40) >> 6) == 1) { goto L8747; } // 8701: ld a, (4c41h) Z80A = (UINT8) (mem[0x4c41]); // 8704: ld b, a Z80B = (UINT8) (Z80A); // 8705: ld hl, 8841h Z80HL = (UINT16) (0x8841); // 8708: rst 18h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x87; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x09; goto L0018; L8709: // 8709: ld de, (4dd2h) Z80E = (UINT8) (mem[0x4dd2]); Z80D = (UINT8) (mem[0x4dd3]); { UINT32 u32Temp0; // 870d: add hl, de u32Temp0 = Z80HL + Z80DE; u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80DE) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 870e: ld (4dd2h), hl mem[0x4dd2] = Z80L; mem[0x4dd3] = Z80H; // 8711: ld hl, 4c41h Z80HL = (UINT16) (0x4c41); { UINT8 u8Temp0; // 8714: inc (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 8715: ld a, (hl) Z80A = (UINT8) (mem[Z80HL]); // 8716: and a, 0fh Z80A = (UINT8) (Z80A & 0x0f); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 8718: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 8719: ld hl, 4c40h Z80HL = (UINT16) (0x4c40); { UINT8 u8Temp0; // 871c: dec (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] - 1); u8Temp0 = mem[Z80HL]; u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 871d: jp m, 87b5h if (((u8Flags & 0x80) >> 7) == 1) { goto L87b5; } // 8720: ld a, (hl) Z80A = (UINT8) (mem[Z80HL]); // 8721: ld d, a Z80D = (UINT8) (Z80A); // 8722: srl a u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (Z80A >> 1); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags &= 0xef; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 8724: srl a u8Flags = (u8Flags & ~0x01) | ((Z80A & 1) ? 0x01 : 0); Z80A = (UINT8) (Z80A >> 1); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags &= 0xef; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 8726: ld hl, 4ebch Z80HL = (UINT16) (0x4ebc); // 8729: set 5, (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] | 0x20); // 872b: ld hl, (4c42h) Z80L = (UINT8) (mem[0x4c42]); Z80H = (UINT8) (mem[0x4c43]); // 872e: rst 10h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x87; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x2f; goto L0010; L872f: // 872f: ld c, a Z80C = (UINT8) (Z80A); // 8730: ld a, 03h Z80A = (UINT8) (0x03); // 8732: and a, d Z80A = (UINT8) (Z80A & Z80D); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 8733: jr z, 0873ch if (((u8Flags & 0x40) >> 6) == 1) { goto L873c; } // 8735: srl c L8735: u8Flags = (u8Flags & ~0x01) | ((Z80C & 1) ? 0x01 : 0); Z80C = (UINT8) (Z80C >> 1); u8Flags = (u8Flags & ~0x80) | ((Z80C & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x40) | ((Z80C == 0) ? 0x40 : 0); u8Flags &= 0xef; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x04) | (((((((Z80C >> 0x07) & 1) + ((Z80C >> 0x06) & 1) + ((Z80C >> 0x05) & 1) + ((Z80C >> 0x04) & 1) + ((Z80C >> 0x03) & 1) + ((Z80C >> 0x02) & 1) + ((Z80C >> 1) & 1) + ((Z80C >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 8737: srl c u8Flags = (u8Flags & ~0x01) | ((Z80C & 1) ? 0x01 : 0); Z80C = (UINT8) (Z80C >> 1); u8Flags = (u8Flags & ~0x80) | ((Z80C & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x40) | ((Z80C == 0) ? 0x40 : 0); u8Flags &= 0xef; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x04) | (((((((Z80C >> 0x07) & 1) + ((Z80C >> 0x06) & 1) + ((Z80C >> 0x05) & 1) + ((Z80C >> 0x04) & 1) + ((Z80C >> 0x03) & 1) + ((Z80C >> 0x02) & 1) + ((Z80C >> 1) & 1) + ((Z80C >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 8739: dec a Z80A = (UINT8) (Z80A - 1); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); if ((Z80A & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80A == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } // 873a: jr nz, 08735h if (((u8Flags & 0x40) >> 6) != 1) { goto L8735; } // 873c: ld a, 03h L873c: Z80A = (UINT8) (0x03); // 873e: and a, c Z80A = (UINT8) (Z80A & Z80C); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 873f: rlca u8Flags = (u8Flags & ~0x01) | ((Z80A & 0x80) ? 0x01 : 0); Z80A = (UINT8) (((Z80A << 1) | (Z80A >> 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 8740: rlca u8Flags = (u8Flags & ~0x01) | ((Z80A & 0x80) ? 0x01 : 0); Z80A = (UINT8) (((Z80A << 1) | (Z80A >> 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 8741: rlca u8Flags = (u8Flags & ~0x01) | ((Z80A & 0x80) ? 0x01 : 0); Z80A = (UINT8) (((Z80A << 1) | (Z80A >> 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 8742: rlca u8Flags = (u8Flags & ~0x01) | ((Z80A & 0x80) ? 0x01 : 0); Z80A = (UINT8) (((Z80A << 1) | (Z80A >> 0x07))); u8Flags &= 0xef; u8Flags &= 0xfd; // 8743: ld (4c41h), a mem[0x4c41] = Z80A; // 8746: ret goto returnInstruction; // 8747: ld a, (peleatn) L8747: Z80A = (UINT8) (mem[0x4e0e]); { UINT16 u16Temp0; // 874a: cp a, 40h u16Temp0 = Z80A - 0x40; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x40))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x40 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 874c: jp z, 8758h if (((u8Flags & 0x40) >> 6) == 1) { goto L8758; } { UINT16 u16Temp0; // 874f: cp a, 0b0h u16Temp0 = Z80A - 0xb0; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0xb0))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0xb0 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 8751: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 8752: ld hl, 4e0dh Z80HL = (UINT16) (0x4e0d); // 8755: jp 875bh goto L875b; // 8758: ld hl, 4e0ch L8758: Z80HL = (UINT16) (0x4e0c); // 875b: ld a, (hl) L875b: Z80A = (UINT8) (mem[Z80HL]); // 875c: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 875d: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } { UINT8 u8Temp0; // 875e: inc (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] + 1); u8Temp0 = mem[Z80HL]; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((u8Temp0 == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u8Temp0 & 0x80) ? 0x80 : 0); if ((u8Temp0 & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (u8Temp0 == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } } // 875f: ld a, (boardno) ; Load the board # (cherry = 0) // Ms. Pacman Random Fruit Probabilities // (c) 2002 Mark Spaeth // http://rgvac.978.org/files/MsPacFruit.txt Z80A = (UINT8) (mem[0x4e13]); { UINT16 u16Temp0; // 8762: cp a, 07h ; Compare it to 7 u16Temp0 = Z80A - 0x07; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x07))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x07 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 8764: jr c, 08770h ; If less than 7, use board # as fruit if (((u8Flags & 0x01) >> 0) == 1) { goto L8770; } // 8766: ld b, 07h Z80B = (UINT8) (0x07); { UINT32 u32Temp0; // 8768: ld a, r ; Load the DRAM refresh counter // selector for random fruits // uses r register to get a random number u8Flags = (u8Flags & ~0x04) | ((((Z80iff & 0x02) >> 1)) ? 0x04 : 0); u8Flags &= 0xef; u8Flags &= 0xfd; u32Temp0 = sg_s32StartCount - s32CyclesRemaining; Z80r = (UINT32) (Z80r + u32Temp0); Z80clockticks = (UINT32) (Z80clockticks + u32Temp0); sg_s32StartCount = sg_s32StartCount - u32Temp0; Z80A = (UINT8) (((Z80r & 0x80) | ((Z80rCounter >> 0x02) & 0x7f))); u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 876a: and a, 1fh ; Mask off the bottom 5 bits Z80A = (UINT8) (Z80A & 0x1f); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); { UINT16 u16Temp0; // 876c: sub a, b ; Subtract 7 // Compute ((R % 32) % 7) L876c: u16Temp0 = Z80A - Z80B; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80B))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80B ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 876d: jr nc, 0876ch ; If >=0 loop if (((u8Flags & 0x01) >> 0) != 1) { goto L876c; } { UINT16 u16Temp0; // 876f: add a, b ; Add 7 back u16Temp0 = Z80A + Z80B; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80B))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80B ^ Z80A ^ 0x80) & (Z80B ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 8770: ld hl, 879dh ; Level / fruit data table L8770: Z80HL = (UINT16) (0x879d); // 8773: ld b, a ; 3 * a -> a Z80B = (UINT8) (Z80A); { UINT16 u16Temp0; // 8774: add a, a u16Temp0 = Z80A + Z80A; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80A))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80A ^ Z80A ^ 0x80) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } { UINT16 u16Temp0; // 8775: add a, b u16Temp0 = Z80A + Z80B; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80B))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80B ^ Z80A ^ 0x80) & (Z80B ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 8776: rst 10h ; hl + a -> hl, (hl) -> a [table look] Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x87; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x77; goto L0010; L8777: // 8777: ld (frshape), a ; Write 3 fruit data bytes (shape code) mem[0x4c0c] = Z80A; // 877a: inc hl Z80HL = (UINT16) (Z80HL + 1); // 877b: ld a, (hl) Z80A = (UINT8) (mem[Z80HL]); // 877c: ld (frcol), a ; Color code mem[0x4c0d] = Z80A; // 877f: inc hl Z80HL = (UINT16) (Z80HL + 1); // 8780: ld a, (hl) Z80A = (UINT8) (mem[Z80HL]); // 8781: ld (frbonus), a ; Score table offset mem[0x4dd4] = Z80A; // 8784: ld hl, 87f8h // select the proper fruit path from the table at 87f8 Z80HL = (UINT16) (0x87f8); // 8787: call 87cdh Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x87; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x8a; goto L87cd; L878a: // 878a: inc hl Z80HL = (UINT16) (Z80HL + 1); // 878b: ld e, (hl) Z80E = (UINT8) (mem[Z80HL]); // 878c: inc hl Z80HL = (UINT16) (Z80HL + 1); // 878d: ld d, (hl) Z80D = (UINT8) (mem[Z80HL]); // 878e: ld (4dd2h), de // fruit shape/color/points table // offset 0 1 2 3 4 5 6 7 8 9 a b c d e f mem[0x4dd2] = Z80E; mem[0x4dd3] = Z80D; // 8792: ret goto returnInstruction; { UINT16 u16Temp0; // 8793: cp a, 08h ; if <= 8 // new board increment routine L8793: u16Temp0 = Z80A - 0x08; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x08))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x08 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 8795: jp c, 2bf9h ; return if (((u8Flags & 0x01) >> 0) == 1) { goto L2bf9; } // 8798: ld a, 07h ; set to 7 Z80A = (UINT8) (0x07); // 879a: jp 2bf9h ; return goto L2bf9; // 87b5: ld a, (4dd3h) // For reference, the score table is at 0x2b17 L87b5: Z80A = (UINT8) (mem[0x4dd3]); { UINT16 u16Temp0; // 87b8: add a, 20h u16Temp0 = Z80A + 0x20; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x20))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x20 ^ Z80A ^ 0x80) & (0x20 ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } { UINT16 u16Temp0; // 87ba: cp a, 40h u16Temp0 = Z80A - 0x40; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x40))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x40 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 87bc: jr c, 08810h if (((u8Flags & 0x01) >> 0) == 1) { goto L8810; } // 87be: ld hl, (4c42h) Z80L = (UINT8) (mem[0x4c42]); Z80H = (UINT8) (mem[0x4c43]); // 87c1: ld de, 8808h Z80DE = (UINT16) (0x8808); // 87c4: scf u8Flags |= 0x01; u8Flags &= 0xfd; u8Flags &= 0xef; // 87c5: ccf u8Flags = (u8Flags & ~0x10) | ((((u8Flags & 0x01) >> 0)) ? 0x10 : 0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x01) | ((((u8Flags & 0x01) >> 0) ^ 1) ? 0x01 : 0); { UINT32 u32Temp0; // 87c6: sbc hl, de u32Temp0 = (Z80HL - Z80DE - ((u8Flags & 0x01) >> 0)); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80DE) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | (((((Z80DE ^ Z80HL) & (Z80HL ^ u32Temp0) & 0x8000))) ? 0x04 : 0); Z80HL = (UINT16) (u32Temp0); u8Flags = (u8Flags & ~0x40) | ((Z80HL == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80HL & 0x8000) ? 0x80 : 0); u8Flags |= 0x02; } // 87c8: jr nz, 087edh if (((u8Flags & 0x40) >> 6) != 1) { goto L87ed; } // 87ca: ld hl, 8800h Z80HL = (UINT16) (0x8800); // 87cd: call 94bdh L87cd: Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x87; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xd0; goto L94bd; L87d0: // 87d0: ld l, c Z80L = (UINT8) (Z80C); // 87d1: ld h, b Z80H = (UINT8) (Z80B); { UINT32 u32Temp0; // 87d2: ld a, r u8Flags = (u8Flags & ~0x04) | ((((Z80iff & 0x02) >> 1)) ? 0x04 : 0); u8Flags &= 0xef; u8Flags &= 0xfd; u32Temp0 = sg_s32StartCount - s32CyclesRemaining; Z80r = (UINT32) (Z80r + u32Temp0); Z80clockticks = (UINT32) (Z80clockticks + u32Temp0); sg_s32StartCount = sg_s32StartCount - u32Temp0; Z80A = (UINT8) (((Z80r & 0x80) | ((Z80rCounter >> 0x02) & 0x7f))); u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 87d4: and a, 03h Z80A = (UINT8) (Z80A & 0x03); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 87d6: ld b, a Z80B = (UINT8) (Z80A); { UINT16 u16Temp0; // 87d7: add a, a u16Temp0 = Z80A + Z80A; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80A))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80A ^ Z80A ^ 0x80) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } { UINT16 u16Temp0; // 87d8: add a, a u16Temp0 = Z80A + Z80A; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80A))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80A ^ Z80A ^ 0x80) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } { UINT16 u16Temp0; // 87d9: add a, b u16Temp0 = Z80A + Z80B; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80B))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80B ^ Z80A ^ 0x80) & (Z80B ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 87da: rst 10h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x87; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xdb; goto L0010; L87db: // 87db: ld e, a Z80E = (UINT8) (Z80A); // 87dc: inc hl Z80HL = (UINT16) (Z80HL + 1); // 87dd: ld d, (hl) Z80D = (UINT8) (mem[Z80HL]); // 87de: ld (4c42h), de mem[0x4c42] = Z80E; mem[0x4c43] = Z80D; // 87e2: inc hl Z80HL = (UINT16) (Z80HL + 1); // 87e3: ld a, (hl) Z80A = (UINT8) (mem[Z80HL]); // 87e4: ld (4c40h), a L87e4: mem[0x4c40] = Z80A; // 87e7: ld a, 1fh Z80A = (UINT8) (0x1f); // 87e9: ld (4c41h), a mem[0x4c41] = Z80A; // 87ec: ret goto returnInstruction; // 87ed: ld hl, 8808h L87ed: Z80HL = (UINT16) (0x8808); // 87f0: ld (4c42h), hl mem[0x4c42] = Z80L; mem[0x4c43] = Z80H; // 87f3: ld a, 1dh Z80A = (UINT8) (0x1d); // 87f5: jp 87e4h goto L87e4; // 8810: ld a, 00h L8810: Z80A = (UINT8) (0); // 8812: ld (frcol), a mem[0x4c0d] = Z80A; // 8815: jp 1000h goto L1000; // 8818: push af L8818: Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80A; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = u8Flags; // 8819: ld de, (4dd2h) Z80E = (UINT8) (mem[0x4dd2]); Z80D = (UINT8) (mem[0x4dd3]); // 881d: ld a, h Z80A = (UINT8) (Z80H); { UINT16 u16Temp0; // 881e: sub a, d u16Temp0 = Z80A - Z80D; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80D))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80D ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } { UINT16 u16Temp0; // 881f: add a, 03h u16Temp0 = Z80A + 0x03; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x03))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x03 ^ Z80A ^ 0x80) & (0x03 ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } { UINT16 u16Temp0; // 8821: cp a, 06h u16Temp0 = Z80A - 0x06; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x06))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x06 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 8823: jr nc, 0883dh if (((u8Flags & 0x01) >> 0) != 1) { goto L883d; } // 8825: ld a, l Z80A = (UINT8) (Z80L); { UINT16 u16Temp0; // 8826: sub a, e u16Temp0 = Z80A - Z80E; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80E))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80E ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } { UINT16 u16Temp0; // 8827: add a, 03h u16Temp0 = Z80A + 0x03; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x03))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x03 ^ Z80A ^ 0x80) & (0x03 ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } { UINT16 u16Temp0; // 8829: cp a, 06h u16Temp0 = Z80A - 0x06; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x06))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x06 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 882b: jr nc, 0883dh if (((u8Flags & 0x01) >> 0) != 1) { goto L883d; } // 882d: ld a, 01h Z80A = (UINT8) (1); // 882f: ld (frcol), a mem[0x4c0d] = Z80A; // 8832: pop af u8Flags = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); Z80A = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); { UINT16 u16Temp0; // 8833: add a, 02h u16Temp0 = Z80A + 0x02; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x02))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x02 ^ Z80A ^ 0x80) & (0x02 ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 8835: ld (frshape), a mem[0x4c0c] = Z80A; { UINT16 u16Temp0; // 8838: sub a, 02h u16Temp0 = Z80A - 0x02; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x02))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x02 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 883a: jp 19b2h goto L19b2; // 883d: pop af L883d: u8Flags = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); Z80A = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); // 883e: jp 19cdh goto L19cd; // 946a: ld hl, 9474h ; maze table number // select the proper maze L946a: Z80HL = (UINT16) (0x9474); // 946d: call 94bdh Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x94; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x70; goto L94bd; L9470: // 9470: ld hl, 4000h Z80HL = (UINT16) (0x4000); // 9473: ret goto returnInstruction; // 947c: ld hl, 2453h // pellet crossreference routine patch L947c: Z80HL = (UINT16) (0x2453); // 947f: jr 09484h goto L9484; // 9481: ld hl, 2492h L9481: Z80HL = (UINT16) (0x2492); // 9484: push hl L9484: Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80H; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80L; // 9485: ld hl, 9499h ; select pellet map based on map Z80HL = (UINT16) (0x9499); // 9488: call 94bdh Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x94; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x8b; goto L94bd; L948b: // 948b: ld iy, 0000h Z80IY = (UINT16) (0); { UINT32 u32Temp0; // 948f: add iy, bc u32Temp0 = Z80IY + Z80BC; u8Flags = (u8Flags & ~0x10) | ((((Z80IY ^ u32Temp0 ^ Z80BC) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80IY = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 9491: ld hl, 4000h Z80HL = (UINT16) (0x4000); // 9494: ld ix, 4e16h Z80IX = (UINT16) (0x4e16); // 9498: ret goto returnInstruction; // 94a1: push bc L94a1: Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80B; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80C; // 94a2: ld hl, 94b5h ; pellet count table Z80HL = (UINT16) (0x94b5); // 94a5: call 94bdh Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x94; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xa8; goto L94bd; L94a8: // 94a8: ld a, (bc) Z80A = (UINT8) (mem[Z80BC]); // 94a9: ld b, a Z80B = (UINT8) (Z80A); // 94aa: ld a, (peleatn) Z80A = (UINT8) (mem[0x4e0e]); { UINT16 u16Temp0; // 94ad: cp a, b u16Temp0 = Z80A - Z80B; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80B))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80B ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 94ae: pop bc Z80C = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); Z80B = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); // 94af: jp nz, 08ebh ; return to the game loop? if (((u8Flags & 0x40) >> 6) != 1) { goto L08eb; } // 94b2: jp 08e5h ; return to the clear pellet check goto L08e5; L94b5: // 94b5: inc l ; number of pellets for board 0 // data for pellet count information Z80L = (UINT8) (Z80L + 1); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80L == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80L & 0x80) ? 0x80 : 0); if ((Z80L & 0x0f) == 0) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80L == 0x80) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } { UINT16 u16Temp0; // 94b6: adc a, e u16Temp0 = (Z80A + ((u8Flags & 0x01) >> 0) + Z80E); u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80E))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80E ^ Z80A ^ 0x80) & (Z80E ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } { UINT8 u8Temp0; // 94b7: rla ; number of pellets for board 1 u8Temp0 = ((u8Flags & 0x01) >> 0); u8Flags = (u8Flags & ~0x01) | ((Z80A & 0x80) ? 0x01 : 0); Z80A = (UINT8) (((Z80A << 1) | u8Temp0)); u8Flags &= 0xfd; u8Flags &= 0xef; } { UINT16 u16Temp0; UINT8 u8Temp0; // 94b8: adc a, (hl) ; number of pellets for board 2 u8Temp0 = mem[Z80HL]; u16Temp0 = (Z80A + ((u8Flags & 0x01) >> 0) + u8Temp0); u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ u8Temp0))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((u8Temp0 ^ Z80A ^ 0x80) & (u8Temp0 ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } { UINT32 u32Temp0; // 94b9: add hl, bc u32Temp0 = Z80HL + Z80BC; u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80BC) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } { UINT16 u16Temp0; // 94ba: sub a, c u16Temp0 = Z80A - Z80C; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80C))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80C ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 94bb: ld sp, hl ; number of pellets for board 3 Z80SP = (UINT16) (Z80HL); { UINT16 u16Temp0; // 94bc: sub a, e u16Temp0 = Z80A - Z80E; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80E))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80E ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 94bd: ld a, (boardno) ; board number // perhaps a routine to calculate variables according // to the current ms-pac maze number? L94bd: Z80A = (UINT8) (mem[0x4e13]); // 94c0: push hl Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80H; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80L; { UINT16 u16Temp0; // 94c1: cp a, 0dh u16Temp0 = Z80A - 0x0d; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x0d))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x0d ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 94c3: jp p, 94d4h if (((u8Flags & 0x80) >> 7) != 1) { goto L94d4; } // 94c6: ld hl, 94dfh ; map order table L94c6: Z80HL = (UINT16) (0x94df); // 94c9: rst 10h ; a now contains the map number Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x94; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xca; goto L0010; L94ca: // 94ca: pop hl Z80L = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); Z80H = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); { UINT16 u16Temp0; // 94cb: add a, a u16Temp0 = Z80A + Z80A; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80A))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80A ^ Z80A ^ 0x80) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 94cc: ld c, a Z80C = (UINT8) (Z80A); // 94cd: ld b, 00h Z80B = (UINT8) (0); { UINT32 u32Temp0; // 94cf: add hl, bc u32Temp0 = Z80HL + Z80BC; u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80BC) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 94d0: ld c, (hl) // map order table... (order that boards are played) // offset 0 1 2 3 4 5 6 7 8 9 a b c d e f Z80C = (UINT8) (mem[Z80HL]); // 94d1: inc hl Z80HL = (UINT16) (Z80HL + 1); // 94d2: ld b, (hl) Z80B = (UINT8) (mem[Z80HL]); // 94d3: ret goto returnInstruction; { UINT16 u16Temp0; // 94d4: sub a, 0dh L94d4: u16Temp0 = Z80A - 0x0d; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x0d))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x0d ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } { UINT16 u16Temp0; // 94d6: sub a, 08h L94d6: u16Temp0 = Z80A - 0x08; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x08))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x08 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 94d8: jp p, 94d6h if (((u8Flags & 0x80) >> 7) != 1) { goto L94d6; } { UINT16 u16Temp0; // 94db: add a, 0dh u16Temp0 = Z80A + 0x0d; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x0d))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x0d ^ Z80A ^ 0x80) & (0x0d ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 94dd: jr 094c6h goto L94c6; // 94ec: ld hl, 951ch // draw routine for the ms-pac power pellets L94ec: Z80HL = (UINT16) (0x951c); // 94ef: call 94bdh ; retrieve values Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x94; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xf2; goto L94bd; L94f2: // 94f2: ld de, brdno2 Z80DE = (UINT16) (0x4e34); // 94f5: ld l, c Z80L = (UINT8) (Z80C); // 94f6: ld h, b ; hl = table offset Z80H = (UINT8) (Z80B); // 94f7: ld c, (hl) L94f7: Z80C = (UINT8) (mem[Z80HL]); // 94f8: inc hl Z80HL = (UINT16) (Z80HL + 1); // 94f9: ld b, (hl) Z80B = (UINT8) (mem[Z80HL]); // 94fa: inc hl ; bc = table loc Z80HL = (UINT16) (Z80HL + 1); // 94fb: ld a, (de) Z80A = (UINT8) (mem[Z80DE]); // 94fc: ld (bc), a mspacmanIndirectWrite8(Z80BC, Z80A); // 94fd: inc de Z80DE = (UINT16) (Z80DE + 1); // 94fe: ld a, 03h Z80A = (UINT8) (0x03); // 9500: and a, e Z80A = (UINT8) (Z80A & Z80E); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 9501: jr nz, 094f7h if (((u8Flags & 0x40) >> 6) != 1) { goto L94f7; } // 9503: ret goto returnInstruction; // 9504: ld hl, 951ch ; pellet lookup table per map // pellet routine? L9504: Z80HL = (UINT16) (0x951c); // 9507: call 94bdh Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x95; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x0a; goto L94bd; L950a: // 950a: ld de, brdno2 Z80DE = (UINT16) (0x4e34); // 950d: ld l, c Z80L = (UINT8) (Z80C); // 950e: ld h, b Z80H = (UINT8) (Z80B); // 950f: ld c, (hl) L950f: Z80C = (UINT8) (mem[Z80HL]); // 9510: inc hl Z80HL = (UINT16) (Z80HL + 1); // 9511: ld b, (hl) Z80B = (UINT8) (mem[Z80HL]); // 9512: inc hl Z80HL = (UINT16) (Z80HL + 1); // 9513: ld a, (bc) Z80A = (UINT8) (mem[Z80BC]); // 9514: ld (de), a mspacmanIndirectWrite8(Z80DE, Z80A); // 9515: inc de Z80DE = (UINT16) (Z80DE + 1); // 9516: ld a, 03h Z80A = (UINT8) (0x03); // 9518: and a, e Z80A = (UINT8) (Z80A & Z80E); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 9519: jr nz, 0950fh if (((u8Flags & 0x40) >> 6) != 1) { goto L950f; } // 951b: ret goto returnInstruction; // 9524: push bc L9524: Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80B; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80C; // 9525: push de Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80D; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80E; // 9526: ld hl, 951ch ; pellet lookup table Z80HL = (UINT16) (0x951c); // 9529: call 94bdh Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x95; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x2c; goto L94bd; L952c: // 952c: ld h, b Z80H = (UINT8) (Z80B); // 952d: ld l, c Z80L = (UINT8) (Z80C); // 952e: ld e, (hl) Z80E = (UINT8) (mem[Z80HL]); // 952f: inc hl Z80HL = (UINT16) (Z80HL + 1); // 9530: ld d, (hl) Z80D = (UINT8) (mem[Z80HL]); { UINT16 u16Temp0; // 9531: ex de, hl u16Temp0 = Z80HL; Z80HL = (UINT16) (Z80DE); Z80DE = (UINT16) (u16Temp0); } // 9532: set 2, h Z80H = (UINT8) (Z80H | 0x04); // 9534: ld a, (447eh) Z80A = (UINT8) (mem[0x447e]); { UINT16 u16Temp0; UINT8 u8Temp0; // 9537: cp a, (hl) u8Temp0 = mem[Z80HL]; u16Temp0 = Z80A - u8Temp0; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ u8Temp0))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((u8Temp0 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 9538: jr nz, 0953ch if (((u8Flags & 0x40) >> 6) != 1) { goto L953c; } // 953a: ld a, 00h Z80A = (UINT8) (0); // 953c: ld (hl), a L953c: mspacmanIndirectWrite8(Z80HL, Z80A); { UINT16 u16Temp0; // 953d: ex de, hl u16Temp0 = Z80HL; Z80HL = (UINT16) (Z80DE); Z80DE = (UINT16) (u16Temp0); } // 953e: inc hl Z80HL = (UINT16) (Z80HL + 1); // 953f: ld e, (hl) Z80E = (UINT8) (mem[Z80HL]); // 9540: inc hl Z80HL = (UINT16) (Z80HL + 1); // 9541: ld d, (hl) Z80D = (UINT8) (mem[Z80HL]); // 9542: set 2, d Z80D = (UINT8) (Z80D | 0x04); // 9544: ld (de), a mspacmanIndirectWrite8(Z80DE, Z80A); // 9545: inc hl Z80HL = (UINT16) (Z80HL + 1); // 9546: ld e, (hl) Z80E = (UINT8) (mem[Z80HL]); // 9547: inc hl Z80HL = (UINT16) (Z80HL + 1); // 9548: ld d, (hl) Z80D = (UINT8) (mem[Z80HL]); // 9549: set 2, d Z80D = (UINT8) (Z80D | 0x04); // 954b: ld (de), a mspacmanIndirectWrite8(Z80DE, Z80A); // 954c: inc hl Z80HL = (UINT16) (Z80HL + 1); // 954d: ld e, (hl) Z80E = (UINT8) (mem[Z80HL]); // 954e: inc hl Z80HL = (UINT16) (Z80HL + 1); // 954f: ld d, (hl) Z80D = (UINT8) (mem[Z80HL]); // 9550: set 2, d Z80D = (UINT8) (Z80D | 0x04); // 9552: ld (de), a mspacmanIndirectWrite8(Z80DE, Z80A); // 9553: pop de Z80E = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); Z80D = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); // 9554: pop bc Z80C = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); Z80B = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); // 9555: ld a, 10h Z80A = (UINT8) (0x10); { UINT16 u16Temp0; UINT8 u8Temp0; // 9557: cp a, (hl) u8Temp0 = mem[Z80HL]; u16Temp0 = Z80A - u8Temp0; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ u8Temp0))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((u8Temp0 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 9558: ret goto returnInstruction; // 9559: ld a, (4d2eh) L9559: Z80A = (UINT8) (mem[0x4d2e]); // 955c: jr 09561h goto L9561; // 955e: ld a, (4d2fh) L955e: Z80A = (UINT8) (mem[0x4d2f]); // 9561: push af // pick a quadrant for the destination of a ghost L9561: Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80A; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = u8Flags; // 9562: push bc Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80B; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80C; // 9563: push hl Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80H; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80L; // 9564: ld hl, 9578h ; ghost destination table Z80HL = (UINT16) (0x9578); // 9567: call 94bdh Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x95; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x6a; goto L94bd; L956a: // 956a: ld l, c Z80L = (UINT8) (Z80C); // 956b: ld h, b Z80H = (UINT8) (Z80B); { UINT32 u32Temp0; // 956c: ld a, r u8Flags = (u8Flags & ~0x04) | ((((Z80iff & 0x02) >> 1)) ? 0x04 : 0); u8Flags &= 0xef; u8Flags &= 0xfd; u32Temp0 = sg_s32StartCount - s32CyclesRemaining; Z80r = (UINT32) (Z80r + u32Temp0); Z80clockticks = (UINT32) (Z80clockticks + u32Temp0); sg_s32StartCount = sg_s32StartCount - u32Temp0; Z80A = (UINT8) (((Z80r & 0x80) | ((Z80rCounter >> 0x02) & 0x7f))); u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 956e: and a, 06h Z80A = (UINT8) (Z80A & 0x06); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 9570: rst 10h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x95; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x71; goto L0010; // 9571: ld e, a L9571: Z80E = (UINT8) (Z80A); // 9572: inc hl Z80HL = (UINT16) (Z80HL + 1); // 9573: ld d, (hl) Z80D = (UINT8) (mem[Z80HL]); // 9574: pop hl Z80L = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); Z80H = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); // 9575: pop bc Z80C = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); Z80B = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); // 9576: pop af u8Flags = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); Z80A = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); // 9577: ret goto returnInstruction; // 9580: jp z, 24e1h // maze color code (jp from 24dd) L9580: if (((u8Flags & 0x40) >> 6) == 1) { goto L24e1; } // 9583: ld a, (gmemode) Z80A = (UINT8) (mem[0x4e02]); // 9586: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 9587: jr z, 09590h if (((u8Flags & 0x40) >> 6) == 1) { goto L9590; } { UINT16 u16Temp0; // 9589: cp a, 10h u16Temp0 = Z80A - 0x10; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x10))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x10 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 958b: ld a, 01h Z80A = (UINT8) (1); // 958d: jp nz, 24e1h if (((u8Flags & 0x40) >> 6) != 1) { goto L24e1; } // 9590: ld a, (boardno) L9590: Z80A = (UINT8) (mem[0x4e13]); { UINT16 u16Temp0; // 9593: cp a, 15h u16Temp0 = Z80A - 0x15; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x15))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x15 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 9595: jp p, 95a3h if (((u8Flags & 0x80) >> 7) != 1) { goto L95a3; } // 9598: ld c, a L9598: Z80C = (UINT8) (Z80A); // 9599: ld b, 00h Z80B = (UINT8) (0); // 959b: ld hl, 95aeh ; map color table Z80HL = (UINT16) (0x95ae); { UINT32 u32Temp0; // 959e: add hl, bc u32Temp0 = Z80HL + Z80BC; u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80BC) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 959f: ld a, (hl) ; a contains the maze color Z80A = (UINT8) (mem[Z80HL]); // 95a0: jp 24e1h // color palette table for the first 21 mazes // offset 0 1 2 3 4 5 6 7 8 9 a b c d e f goto L24e1; { UINT16 u16Temp0; // 95a3: sub a, 15h L95a3: u16Temp0 = Z80A - 0x15; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x15))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x15 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } { UINT16 u16Temp0; // 95a5: sub a, 10h L95a5: u16Temp0 = Z80A - 0x10; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x10))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x10 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 95a7: jp p, 95a5h if (((u8Flags & 0x80) >> 7) != 1) { goto L95a5; } { UINT16 u16Temp0; // 95aa: add a, 15h u16Temp0 = Z80A + 0x15; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x15))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x15 ^ Z80A ^ 0x80) & (0x15 ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 95ac: jr 09598h goto L9598; // 95c3: ld a, (boardno) ; current board number L95c3: Z80A = (UINT8) (mem[0x4e13]); { UINT16 u16Temp0; // 95c6: cp a, 03h u16Temp0 = Z80A - 0x03; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x03))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x03 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 95c8: jp p, 2534h if (((u8Flags & 0x80) >> 7) != 1) { goto L2534; } // 95cb: ld hl, 95dfh ; Unknown table A/B Z80HL = (UINT16) (0x95df); // 95ce: call 94bdh Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x95; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xd1; goto L94bd; L95d1: // 95d1: ld hl, 4400h Z80HL = (UINT16) (0x4400); // 95d4: ld a, (bc) L95d4: Z80A = (UINT8) (mem[Z80BC]); // 95d5: inc bc Z80BC = (UINT16) (Z80BC + 1); // 95d6: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 95d7: jp z, 2534h if (((u8Flags & 0x40) >> 6) == 1) { goto L2534; } // 95da: rst 10h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x95; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xdb; goto L0010; L95db: // 95db: set 6, (hl) mspacmanIndirectWrite8(Z80HL, mem[Z80HL] | 0x40); // 95dd: jr 095d4h goto L95d4; L95df: // 95df: dec a ; unknown Table A // table Z80A = (UINT8) (Z80A - 1); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); if ((Z80A & 0x0f) == 0x0f) { u8Flags |= 0x10; } else { u8Flags &= 0xef; } if (Z80A == 0x7f) { u8Flags |= 0x04; } else { u8Flags &= 0xfb; } { UINT16 u16Temp0; // 95e0: adc a, e u16Temp0 = (Z80A + ((u8Flags & 0x01) >> 0) + Z80E); u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ Z80E))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((Z80E ^ Z80A ^ 0x80) & (Z80E ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 95e1: jr z, 09571h ; unknown Table B if (((u8Flags & 0x40) >> 6) == 1) { goto L9571; } L95e3: // 95e3: ld a, b Z80A = (UINT8) (Z80B); { UINT16 u16Temp0; // 95e4: cp a, 0ah u16Temp0 = Z80A - 0x0a; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x0a))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x0a ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 95e6: call z, 960bh if (((u8Flags & 0x40) >> 6) == 1) { Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x95; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xe9; goto L960b; } L95e9: { UINT16 u16Temp0; // 95e9: cp a, 0bh u16Temp0 = Z80A - 0x0b; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x0b))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x0b ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 95eb: call z, 95f6h if (((u8Flags & 0x40) >> 6) == 1) { Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x95; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xee; goto L95f6; } L95ee: { UINT16 u16Temp0; // 95ee: cp a, 06h u16Temp0 = Z80A - 0x06; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x06))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x06 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 95f0: call z, 963ch if (((u8Flags & 0x40) >> 6) == 1) { Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x95; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xf3; goto L963c; } L95f3: // 95f3: jp 2c5eh ; print goto L2c5e; // 95f6: push bc // draw the midway logo and text for the 'press start' screen L95f6: Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80B; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80C; // 95f7: push hl Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80H; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80L; // 95f8: call 9642h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x95; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0xfb; goto L9642; L95fb: // 95fb: pop hl Z80L = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); Z80H = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); // 95fc: pop bc Z80C = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); Z80B = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); // 95fd: ld a, (5080h) ; check in0 // check for start button press Z80A = (UINT8) (mem[0x5080]); // 9600: and a, 30h Z80A = (UINT8) (Z80A & 0x30); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); { UINT16 u16Temp0; // 9602: cp a, 30h u16Temp0 = Z80A - 0x30; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x30))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x30 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 9604: ld a, b Z80A = (UINT8) (Z80B); // 9605: ret nz if (((u8Flags & 0x40) >> 6) != 1) { goto returnInstruction; } // 9606: ld a, 20h Z80A = (UINT8) (0x20); // 9608: ld b, 20h Z80B = (UINT8) (0x20); // 960a: ret goto returnInstruction; // 960b: push bc L960b: Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80B; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80C; // 960c: push hl Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80H; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80L; // 960d: ld hl, 9616h Z80HL = (UINT16) (0x9616); // 9610: call 9627h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x96; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x13; goto L9627; L9613: // 9613: pop hl Z80L = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); Z80H = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); // 9614: pop bc Z80C = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); Z80B = (UINT8) (mem[Z80SP]); Z80SP = (UINT16) (Z80SP + 1); // 9615: ret goto returnInstruction; L9618: // 9618: push af Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = Z80A; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = u8Flags; // 9619: ld b, c Z80B = (UINT8) (Z80C); { UINT32 u32Temp0; // 961a: add hl, bc u32Temp0 = Z80HL + Z80BC; u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80BC) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 961b: ld hl, 4215h Z80HL = (UINT16) (0x4215); { UINT32 u32Temp0; // 961e: add hl, bc u32Temp0 = Z80HL + Z80BC; u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80BC) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 961f: ld (41f6h), hl MSPacVideoWrite(0x41f6,Z80L); MSPacVideoWrite(0x41f7,Z80H); { UINT32 u32Temp0; // 9622: add hl, bc u32Temp0 = Z80HL + Z80BC; u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80BC) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 9623: inc hl Z80HL = (UINT16) (Z80HL + 1); // 9624: ld d, 42h Z80D = (UINT8) (0x42); // 9626: rst 38h Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x96; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x27; goto L0038; // 9627: ld a, (hl) L9627: Z80A = (UINT8) (mem[Z80HL]); { UINT16 u16Temp0; // 9628: cp a, 0ffh u16Temp0 = Z80A - 0xff; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0xff))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0xff ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 962a: jr z, 0963bh if (((u8Flags & 0x40) >> 6) == 1) { goto L963b; } // 962c: ld b, a Z80B = (UINT8) (Z80A); // 962d: inc hl Z80HL = (UINT16) (Z80HL + 1); // 962e: ld a, (hl) Z80A = (UINT8) (mem[Z80HL]); // 962f: inc hl Z80HL = (UINT16) (Z80HL + 1); // 9630: ld e, (hl) Z80E = (UINT8) (mem[Z80HL]); // 9631: inc hl Z80HL = (UINT16) (Z80HL + 1); // 9632: ld d, (hl) Z80D = (UINT8) (mem[Z80HL]); // 9633: ld (de), a mspacmanIndirectWrite8(Z80DE, Z80A); // 9634: ld a, b Z80A = (UINT8) (Z80B); // 9635: set 2, d Z80D = (UINT8) (Z80D | 0x04); // 9637: ld (de), a mspacmanIndirectWrite8(Z80DE, Z80A); // 9638: inc hl Z80HL = (UINT16) (Z80HL + 1); // 9639: jr 09627h goto L9627; // 963b: ret L963b: goto returnInstruction; // 963c: ld a, 00h L963c: Z80A = (UINT8) (0); // 963e: ld (4f00h), a mem[0x4f00] = Z80A; // 9641: ret goto returnInstruction; // 9642: rst 28h ; Midway mfg co // dereferencing for title screen logo and text L9642: Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x96; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x43; goto L0028; L9645: // 9645: rst 28h ; 1980/1981 Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x96; Z80SP = (UINT16) (Z80SP - 1); mem[Z80SP] = 0x46; goto L0028; L9648: // 9648: ld hl, 429ah ; somehow, this also calls the below // draw the Midway logo out to the screen Z80HL = (UINT16) (0x429a); // 964b: ld a, 0bfh // this draws vertical strips, starting with the rightmost Z80A = (UINT8) (0xbf); // 964d: and a, a u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 964e: ld de, 001dh Z80DE = (UINT16) (0x1d); // 9651: ld bc, 0400h Z80BC = (UINT16) (0x0400); // 9654: ld (hl), a L9654: mspacmanIndirectWrite8(Z80HL, Z80A); { UINT32 u32Temp0; // 9655: add hl, bc u32Temp0 = Z80HL + Z80BC; u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80BC) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 9656: ld (hl), 01h mspacmanIndirectWrite8(Z80HL, 1); { UINT32 u32Temp0; // 9658: sbc hl, bc u32Temp0 = (Z80HL - Z80BC - ((u8Flags & 0x01) >> 0)); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80BC) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | (((((Z80BC ^ Z80HL) & (Z80HL ^ u32Temp0) & 0x8000))) ? 0x04 : 0); Z80HL = (UINT16) (u32Temp0); u8Flags = (u8Flags & ~0x40) | ((Z80HL == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80HL & 0x8000) ? 0x80 : 0); u8Flags |= 0x02; } // 965a: inc hl Z80HL = (UINT16) (Z80HL + 1); { UINT16 u16Temp0; // 965b: sub a, 04h u16Temp0 = Z80A - 0x04; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x04))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x04 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 965d: ld (hl), a mspacmanIndirectWrite8(Z80HL, Z80A); { UINT32 u32Temp0; // 965e: add hl, bc u32Temp0 = Z80HL + Z80BC; u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80BC) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 965f: ld (hl), 01h mspacmanIndirectWrite8(Z80HL, 1); { UINT32 u32Temp0; // 9661: sbc hl, bc u32Temp0 = (Z80HL - Z80BC - ((u8Flags & 0x01) >> 0)); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80BC) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | (((((Z80BC ^ Z80HL) & (Z80HL ^ u32Temp0) & 0x8000))) ? 0x04 : 0); Z80HL = (UINT16) (u32Temp0); u8Flags = (u8Flags & ~0x40) | ((Z80HL == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80HL & 0x8000) ? 0x80 : 0); u8Flags |= 0x02; } // 9663: inc hl Z80HL = (UINT16) (Z80HL + 1); { UINT16 u16Temp0; // 9664: sub a, 04h u16Temp0 = Z80A - 0x04; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x04))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x04 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 9666: ld (hl), a mspacmanIndirectWrite8(Z80HL, Z80A); { UINT32 u32Temp0; // 9667: add hl, bc u32Temp0 = Z80HL + Z80BC; u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80BC) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 9668: ld (hl), 01h mspacmanIndirectWrite8(Z80HL, 1); { UINT32 u32Temp0; // 966a: sbc hl, bc u32Temp0 = (Z80HL - Z80BC - ((u8Flags & 0x01) >> 0)); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80BC) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | (((((Z80BC ^ Z80HL) & (Z80HL ^ u32Temp0) & 0x8000))) ? 0x04 : 0); Z80HL = (UINT16) (u32Temp0); u8Flags = (u8Flags & ~0x40) | ((Z80HL == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80HL & 0x8000) ? 0x80 : 0); u8Flags |= 0x02; } // 966c: inc hl Z80HL = (UINT16) (Z80HL + 1); { UINT16 u16Temp0; // 966d: sub a, 04h u16Temp0 = Z80A - 0x04; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x04))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x04 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((Z80A & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } // 966f: ld (hl), a mspacmanIndirectWrite8(Z80HL, Z80A); { UINT32 u32Temp0; // 9670: add hl, bc u32Temp0 = Z80HL + Z80BC; u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80BC) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } // 9671: ld (hl), 01h mspacmanIndirectWrite8(Z80HL, 1); { UINT32 u32Temp0; // 9673: sbc hl, bc u32Temp0 = (Z80HL - Z80BC - ((u8Flags & 0x01) >> 0)); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80BC) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | (((((Z80BC ^ Z80HL) & (Z80HL ^ u32Temp0) & 0x8000))) ? 0x04 : 0); Z80HL = (UINT16) (u32Temp0); u8Flags = (u8Flags & ~0x40) | ((Z80HL == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80HL & 0x8000) ? 0x80 : 0); u8Flags |= 0x02; } { UINT32 u32Temp0; // 9675: add hl, de u32Temp0 = Z80HL + Z80DE; u8Flags = (u8Flags & ~0x10) | ((((Z80HL ^ u32Temp0 ^ Z80DE) & 0x1000)) ? 0x10 : 0); u8Flags = (u8Flags & ~0x01) | ((u32Temp0 & 0x00010000) ? 0x01 : 0); Z80HL = (UINT16) (u32Temp0 & 0xffff); u8Flags &= 0xfd; } { UINT16 u16Temp0; // 9676: add a, 0bh u16Temp0 = Z80A + 0x0b; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x0b))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x0b ^ Z80A ^ 0x80) & (0x0b ^ u16Temp0) & 0x80)) ? 0x04 : 0); Z80A = (UINT8) (u16Temp0); u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); } { UINT16 u16Temp0; // 9678: cp a, 0bbh u16Temp0 = Z80A - 0xbb; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0xbb))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0xbb ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 967a: jr nz, 09654h if (((u8Flags & 0x40) >> 6) != 1) { goto L9654; } // 967c: ret goto returnInstruction; // 9797: ld a, (4f00h) L9797: Z80A = (UINT8) (mem[0x4f00]); { UINT16 u16Temp0; // 979a: cp a, 00h u16Temp0 = Z80A; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0 ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 979c: jr z, 097a9h if (((u8Flags & 0x40) >> 6) == 1) { goto L97a9; } // 979e: ld de, 4c02h Z80DE = (UINT16) (0x4c02); // 97a1: ld hl, 4f50h Z80HL = (UINT16) (0x4f50); // 97a4: ld bc, 000ch Z80BC = (UINT16) (0x0c); // 97a7: ldir UniqueLabel15: mspacmanIndirectWrite8(Z80DE, mem[Z80HL]); Z80HL = (UINT16) (Z80HL + 1); Z80DE = (UINT16) (Z80DE + 1); Z80BC = (UINT16) (Z80BC - 1); if (Z80BC != 0) { goto UniqueLabel15; } u8Flags &= 0xef; u8Flags &= 0xfd; if (Z80BC == 0) { u8Flags &= 0xfb; } else { u8Flags |= 0x04; } // 97a9: ld a, (4e09h) L97a9: Z80A = (UINT8) (mem[0x4e09]); // 97ac: ld hl, cabtype Z80HL = (UINT16) (0x4e72); // 97af: and a, (hl) Z80A = (UINT8) (Z80A & mem[Z80HL]); u8Flags |= 0x10; u8Flags &= 0xfe; u8Flags &= 0xfd; u8Flags = (u8Flags & ~0x40) | ((Z80A == 0) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((Z80A & 0x80) ? 0x80 : 0); u8Flags = (u8Flags & ~0x04) | (((((((Z80A >> 0x07) & 1) + ((Z80A >> 0x06) & 1) + ((Z80A >> 0x05) & 1) + ((Z80A >> 0x04) & 1) + ((Z80A >> 0x03) & 1) + ((Z80A >> 0x02) & 1) + ((Z80A >> 1) & 1) + ((Z80A >> 0) & 1)) & 1) != 1)) ? 0x04 : 0); // 97b0: jr z, 097beh if (((u8Flags & 0x40) >> 6) == 1) { goto L97be; } // 97b2: ld a, (4c0ah) ; mspac sprite number Z80A = (UINT8) (mem[0x4c0a]); { UINT16 u16Temp0; // 97b5: cp a, 3fh u16Temp0 = Z80A - 0x3f; u8Flags = (u8Flags & ~0x01) | ((u16Temp0 & 0x0100) ? 0x01 : 0); u8Flags = (u8Flags & ~0x10) | (((0x10 & (Z80A ^ u16Temp0 ^ 0x3f))) ? 0x10 : 0); u8Flags = (u8Flags & ~0x04) | ((((0x3f ^ Z80A) & (Z80A ^ u16Temp0) & 0x80)) ? 0x04 : 0); u8Flags |= 0x02; u8Flags = (u8Flags & ~0x40) | ((((u16Temp0 & 0xff) == 0)) ? 0x40 : 0); u8Flags = (u8Flags & ~0x80) | ((u16Temp0 & 0x80) ? 0x80 : 0); } // 97b7: jr nz, 097beh if (((u8Flags & 0x40) >> 6) != 1) { goto L97be; } // 97b9: ld a, 0ffh Z80A = (UINT8) (0xff); // 97bb: ld (4c0ah), a ; mspac sprite number mem[0x4c0a] = Z80A; // 97be: ld hl, 9685h L97be: Z80HL = (UINT16) (0x9685); // 97c1: jp 2cc4h goto L2cc4; badOp: /* Invalid/unsupported instruction*/ return(Z80PC); Exit234b: Z80PC = 0x234b; goto adjustTimingCounter; //Exit2cbd: // Z80PC = 0x2cbd; // goto adjustTimingCounter; Exit34de: Z80PC = 0x34de; //goto adjustTimingCounter; adjustTimingCounter: Z80clockticks += (UINT32) (sg_s32StartCount - s32CyclesRemaining); Z80rCounter += (UINT32) (sg_s32StartCount - s32CyclesRemaining); Z80F = u8Flags; // testing a scheme where we *only* return once per frame, which currently is being guessed at as calls to rst 38 // (handled by adding "Draw_Frame = 1; Z80PC = 0x1f9b; goto adjustTimingCounter;" above) //goto goToPC; return(0); //returnButExit: // Z80PC = mem[Z80SP++]; // Z80PC |= ((UINT16) mem[Z80SP++] << 8); // goto adjustTimingCounter; returnInstruction: Z80PC = mem[Z80SP++]; Z80PC |= ((UINT16) mem[Z80SP++] << 8); goto goToPC; //goto adjustTimingCounter; }