Z80.C [3/4]

John Zaicev написал(а) к All в Jun 17 15:37:16 по местному времени:

[√] Приветствую, All !

/********************************************************
* opcodes with DD/FD CB prefix
* rotate, shift and bit operations with (IX+o)
********************************************************/
OP(xycb,00) { B = RLC( RM(EA) ); WM( EA,B ); } / RLC B=(XY+o) /
OP(xycb,01) { C = RLC( RM(EA) ); WM( EA,C ); } / RLC C=(XY+o) /
OP(xycb,02) { D = RLC( RM(EA) ); WM( EA,D ); } / RLC D=(XY+o) /
OP(xycb,03) { E = RLC( RM(EA) ); WM( EA,E ); } / RLC E=(XY+o) /
OP(xycb,04) { Н = RLC( RM(EA) ); WM( EA,Н ); } / RLC Н=(XY+o) /
OP(xycb,05) { L = RLC( RM(EA) ); WM( EA,L ); } / RLC L=(XY+o) /
OP(xycb,06) { WM( EA, RLC( RM(EA) ) ); } / RLC (XY+o) /
OP(xycb,07) { A = RLC( RM(EA) ); WM( EA,A ); } / RLC A=(XY+o) /

OP(xycb,08) { B = RRC( RM(EA) ); WM( EA,B ); } / RRC B=(XY+o) /
OP(xycb,09) { C = RRC( RM(EA) ); WM( EA,C ); } / RRC C=(XY+o) /
OP(xycb,0a) { D = RRC( RM(EA) ); WM( EA,D ); } / RRC D=(XY+o) /
OP(xycb,0b) { E = RRC( RM(EA) ); WM( EA,E ); } / RRC E=(XY+o) /
OP(xycb,0c) { Н = RRC( RM(EA) ); WM( EA,Н ); } / RRC Н=(XY+o) /
OP(xycb,0d) { L = RRC( RM(EA) ); WM( EA,L ); } / RRC L=(XY+o) /
OP(xycb,0e) { WM( EA,RRC( RM(EA) ) ); } / RRC (XY+o) /
OP(xycb,0f) { A = RRC( RM(EA) ); WM( EA,A ); } / RRC A=(XY+o) /

OP(xycb,10) { B = RL( RM(EA) ); WM( EA,B ); } / RL B=(XY+o) /
OP(xycb,11) { C = RL( RM(EA) ); WM( EA,C ); } / RL C=(XY+o) /
OP(xycb,12) { D = RL( RM(EA) ); WM( EA,D ); } / RL D=(XY+o) /
OP(xycb,13) { E = RL( RM(EA) ); WM( EA,E ); } / RL E=(XY+o) /
OP(xycb,14) { Н = RL( RM(EA) ); WM( EA,Н ); } / RL Н=(XY+o) /
OP(xycb,15) { L = RL( RM(EA) ); WM( EA,L ); } / RL L=(XY+o) /
OP(xycb,16) { WM( EA,RL( RM(EA) ) ); } / RL (XY+o) /
OP(xycb,17) { A = RL( RM(EA) ); WM( EA,A ); } / RL A=(XY+o) /

OP(xycb,18) { B = RR( RM(EA) ); WM( EA,B ); } / RR B=(XY+o) /
OP(xycb,19) { C = RR( RM(EA) ); WM( EA,C ); } / RR C=(XY+o) /
OP(xycb,1a) { D = RR( RM(EA) ); WM( EA,D ); } / RR D=(XY+o) /
OP(xycb,1b) { E = RR( RM(EA) ); WM( EA,E ); } / RR E=(XY+o) /
OP(xycb,1c) { Н = RR( RM(EA) ); WM( EA,Н ); } / RR Н=(XY+o) /
OP(xycb,1d) { L = RR( RM(EA) ); WM( EA,L ); } / RR L=(XY+o) /
OP(xycb,1e) { WM( EA,RR( RM(EA) ) ); } / RR (XY+o) /
OP(xycb,1f) { A = RR( RM(EA) ); WM( EA,A ); } / RR A=(XY+o) /

OP(xycb,20) { B = SLA( RM(EA) ); WM( EA,B ); } / SLA B=(XY+o) /
OP(xycb,21) { C = SLA( RM(EA) ); WM( EA,C ); } / SLA C=(XY+o) /
OP(xycb,22) { D = SLA( RM(EA) ); WM( EA,D ); } / SLA D=(XY+o) /
OP(xycb,23) { E = SLA( RM(EA) ); WM( EA,E ); } / SLA E=(XY+o) /
OP(xycb,24) { Н = SLA( RM(EA) ); WM( EA,Н ); } / SLA Н=(XY+o) /
OP(xycb,25) { L = SLA( RM(EA) ); WM( EA,L ); } / SLA L=(XY+o) /
OP(xycb,26) { WM( EA,SLA( RM(EA) ) ); } / SLA (XY+o) /
OP(xycb,27) { A = SLA( RM(EA) ); WM( EA,A ); } / SLA A=(XY+o) /

OP(xycb,28) { B = SRA( RM(EA) ); WM( EA,B ); } / SRA B=(XY+o) /
OP(xycb,29) { C = SRA( RM(EA) ); WM( EA,C ); } / SRA C=(XY+o) /
OP(xycb,2a) { D = SRA( RM(EA) ); WM( EA,D ); } / SRA D=(XY+o) /
OP(xycb,2b) { E = SRA( RM(EA) ); WM( EA,E ); } / SRA E=(XY+o) /
OP(xycb,2c) { Н = SRA( RM(EA) ); WM( EA,Н ); } / SRA Н=(XY+o) /
OP(xycb,2d) { L = SRA( RM(EA) ); WM( EA,L ); } / SRA L=(XY+o) /
OP(xycb,2e) { WM( EA,SRA( RM(EA) ) ); } / SRA (XY+o) /
OP(xycb,2f) { A = SRA( RM(EA) ); WM( EA,A ); } / SRA A=(XY+o) /

OP(xycb,30) { B = SLL( RM(EA) ); WM( EA,B ); } / SLL B=(XY+o) /
OP(xycb,31) { C = SLL( RM(EA) ); WM( EA,C ); } / SLL C=(XY+o) /
OP(xycb,32) { D = SLL( RM(EA) ); WM( EA,D ); } / SLL D=(XY+o) /
OP(xycb,33) { E = SLL( RM(EA) ); WM( EA,E ); } / SLL E=(XY+o) /
OP(xycb,34) { Н = SLL( RM(EA) ); WM( EA,Н ); } / SLL Н=(XY+o) /
OP(xycb,35) { L = SLL( RM(EA) ); WM( EA,L ); } / SLL L=(XY+o) /
OP(xycb,36) { WM( EA,SLL( RM(EA) ) ); } / SLL (XY+o) /
OP(xycb,37) { A = SLL( RM(EA) ); WM( EA,A ); } / SLL A=(XY+o) /

OP(xycb,38) { B = SRL( RM(EA) ); WM( EA,B ); } / SRL B=(XY+o) /
OP(xycb,39) { C = SRL( RM(EA) ); WM( EA,C ); } / SRL C=(XY+o) /
OP(xycb,3a) { D = SRL( RM(EA) ); WM( EA,D ); } / SRL D=(XY+o) /
OP(xycb,3b) { E = SRL( RM(EA) ); WM( EA,E ); } / SRL E=(XY+o) /
OP(xycb,3c) { Н = SRL( RM(EA) ); WM( EA,Н ); } / SRL Н=(XY+o) /
OP(xycb,3d) { L = SRL( RM(EA) ); WM( EA,L ); } / SRL L=(XY+o) /
OP(xycb,3e) { WM( EA,SRL( RM(EA) ) ); } / SRL (XY+o) /
OP(xycb,3f) { A = SRL( RM(EA) ); WM( EA,A ); } / SRL A=(XY+o) /

OP(xycb,40) { xycb_46(); } / BIT 0,(XY+o) /
OP(xycb,41) { xycb_46(); } / BIT 0,(XY+o) /
OP(xycb,42) { xycb_46(); } / BIT 0,(XY+o) /
OP(xycb,43) { xycb_46(); } / BIT 0,(XY+o) /
OP(xycb,44) { xycb_46(); } / BIT 0,(XY+o) /
OP(xycb,45) { xycb_46(); } / BIT 0,(XY+o) /
OP(xycb,46) { BIT_XY(0,RM(EA)); } / BIT 0,(XY+o) /
OP(xycb,47) { xycb_46(); } / BIT 0,(XY+o) /

OP(xycb,48) { xycb_4e(); } / BIT 1,(XY+o) /
OP(xycb,49) { xycb_4e(); } / BIT 1,(XY+o) /
OP(xycb,4a) { xycb_4e(); } / BIT 1,(XY+o) /
OP(xycb,4b) { xycb_4e(); } / BIT 1,(XY+o) /
OP(xycb,4c) { xycb_4e(); } / BIT 1,(XY+o) /
OP(xycb,4d) { xycb_4e(); } / BIT 1,(XY+o) /
OP(xycb,4e) { BIT_XY(1,RM(EA)); } / BIT 1,(XY+o) /
OP(xycb,4f) { xycb_4e(); } / BIT 1,(XY+o) /

OP(xycb,50) { xycb_56(); } / BIT 2,(XY+o) /
OP(xycb,51) { xycb_56(); } / BIT 2,(XY+o) /
OP(xycb,52) { xycb_56(); } / BIT 2,(XY+o) /
OP(xycb,53) { xycb_56(); } / BIT 2,(XY+o) /
OP(xycb,54) { xycb_56(); } / BIT 2,(XY+o) /
OP(xycb,55) { xycb_56(); } / BIT 2,(XY+o) /
OP(xycb,56) { BIT_XY(2,RM(EA)); } / BIT 2,(XY+o) /
OP(xycb,57) { xycb_56(); } / BIT 2,(XY+o) /

OP(xycb,58) { xycb_5e(); } / BIT 3,(XY+o) /
OP(xycb,59) { xycb_5e(); } / BIT 3,(XY+o) /
OP(xycb,5a) { xycb_5e(); } / BIT 3,(XY+o) /
OP(xycb,5b) { xycb_5e(); } / BIT 3,(XY+o) /
OP(xycb,5c) { xycb_5e(); } / BIT 3,(XY+o) /
OP(xycb,5d) { xycb_5e(); } / BIT 3,(XY+o) /
OP(xycb,5e) { BIT_XY(3,RM(EA)); } / BIT 3,(XY+o) /
OP(xycb,5f) { xycb_5e(); } / BIT 3,(XY+o) /

OP(xycb,60) { xycb_66(); } / BIT 4,(XY+o) /
OP(xycb,61) { xycb_66(); } / BIT 4,(XY+o) /
OP(xycb,62) { xycb_66(); } / BIT 4,(XY+o) /
OP(xycb,63) { xycb_66(); } / BIT 4,(XY+o) /
OP(xycb,64) { xycb_66(); } / BIT 4,(XY+o) /
OP(xycb,65) { xycb_66(); } / BIT 4,(XY+o) /
OP(xycb,66) { BIT_XY(4,RM(EA)); } / BIT 4,(XY+o) /
OP(xycb,67) { xycb_66(); } / BIT 4,(XY+o) /

OP(xycb,68) { xycb_6e(); } / BIT 5,(XY+o) /
OP(xycb,69) { xycb_6e(); } / BIT 5,(XY+o) /
OP(xycb,6a) { xycb_6e(); } / BIT 5,(XY+o) /
OP(xycb,6b) { xycb_6e(); } / BIT 5,(XY+o) /
OP(xycb,6c) { xycb_6e(); } / BIT 5,(XY+o) /
OP(xycb,6d) { xycb_6e(); } / BIT 5,(XY+o) /
OP(xycb,6e) { BIT_XY(5,RM(EA)); } / BIT 5,(XY+o) /
OP(xycb,6f) { xycb_6e(); } / BIT 5,(XY+o) /

OP(xycb,70) { xycb_66(); } / BIT 6,(XY+o) /
OP(xycb,71) { xycb_66(); } / BIT 6,(XY+o) /
OP(xycb,72) { xycb_66(); } / BIT 6,(XY+o) /
OP(xycb,73) { xycb_66(); } / BIT 6,(XY+o) /
OP(xycb,74) { xycb_66(); } / BIT 6,(XY+o) /
OP(xycb,75) { xycb_66(); } / BIT 6,(XY+o) /
OP(xycb,76) { BIT_XY(6,RM(EA)); } / BIT 6,(XY+o) /
OP(xycb,77) { xycb_66(); } / BIT 6,(XY+o) /

OP(xycb,78) { xycb_7e(); } / BIT 7,(XY+o) /
OP(xycb,79) { xycb_7e(); } / BIT 7,(XY+o) /
OP(xycb,7a) { xycb_7e(); } / BIT 7,(XY+o) /
OP(xycb,7b) { xycb_7e(); } / BIT 7,(XY+o) /
OP(xycb,7c) { xycb_7e(); } / BIT 7,(XY+o) /
OP(xycb,7d) { xycb_7e(); } / BIT 7,(XY+o) /
OP(xycb,7e) { BIT_XY(7,RM(EA)); } / BIT 7,(XY+o) /
OP(xycb,7f) { xycb_7e(); } / BIT 7,(XY+o) /

OP(xycb,80) { B = RES(0, RM(EA) ); WM( EA,B ); } / RES 0,B=(XY+o) /
OP(xycb,81) { C = RES(0, RM(EA) ); WM( EA,C ); } / RES 0,C=(XY+o) /
OP(xycb,82) { D = RES(0, RM(EA) ); WM( EA,D ); } / RES 0,D=(XY+o) /
OP(xycb,83) { E = RES(0, RM(EA) ); WM( EA,E ); } / RES 0,E=(XY+o) /
OP(xycb,84) { Н = RES(0, RM(EA) ); WM( EA,Н ); } / RES 0,Н=(XY+o) /
OP(xycb,85) { L = RES(0, RM(EA) ); WM( EA,L ); } / RES 0,L=(XY+o) /
OP(xycb,86) { WM( EA, RES(0,RM(EA)) ); } / RES 0,(XY+o) /
OP(xycb,87) { A = RES(0, RM(EA) ); WM( EA,A ); } / RES 0,A=(XY+o) /

OP(xycb,88) { B = RES(1, RM(EA) ); WM( EA,B ); } / RES 1,B=(XY+o) /
OP(xycb,89) { C = RES(1, RM(EA) ); WM( EA,C ); } / RES 1,C=(XY+o) /
OP(xycb,8a) { D = RES(1, RM(EA) ); WM( EA,D ); } / RES 1,D=(XY+o) /
OP(xycb,8b) { E = RES(1, RM(EA) ); WM( EA,E ); } / RES 1,E=(XY+o) /
OP(xycb,8c) { Н = RES(1, RM(EA) ); WM( EA,Н ); } / RES 1,Н=(XY+o) /
OP(xycb,8d) { L = RES(1, RM(EA) ); WM( EA,L ); } / RES 1,L=(XY+o) /
OP(xycb,8e) { WM( EA, RES(1,RM(EA)) ); } / RES 1,(XY+o) /
OP(xycb,8f) { A = RES(1, RM(EA) ); WM( EA,A ); } / RES 1,A=(XY+o) /

OP(xycb,90) { B = RES(2, RM(EA) ); WM( EA,B ); } / RES 2,B=(XY+o) /
OP(xycb,91) { C = RES(2, RM(EA) ); WM( EA,C ); } / RES 2,C=(XY+o) /
OP(xycb,92) { D = RES(2, RM(EA) ); WM( EA,D ); } / RES 2,D=(XY+o) /
OP(xycb,93) { E = RES(2, RM(EA) ); WM( EA,E ); } / RES 2,E=(XY+o) /
OP(xycb,94) { Н = RES(2, RM(EA) ); WM( EA,Н ); } / RES 2,Н=(XY+o) /
OP(xycb,95) { L = RES(2, RM(EA) ); WM( EA,L ); } / RES 2,L=(XY+o) /
OP(xycb,96) { WM( EA, RES(2,RM(EA)) ); } / RES 2,(XY+o) /
OP(xycb,97) { A = RES(2, RM(EA) ); WM( EA,A ); } / RES 2,A=(XY+o) /

OP(xycb,98) { B = RES(3, RM(EA) ); WM( EA,B ); } / RES 3,B=(XY+o) /
OP(xycb,99) { C = RES(3, RM(EA) ); WM( EA,C ); } / RES 3,C=(XY+o) /
OP(xycb,9a) { D = RES(3, RM(EA) ); WM( EA,D ); } / RES 3,D=(XY+o) /
OP(xycb,9b) { E = RES(3, RM(EA) ); WM( EA,E ); } / RES 3,E=(XY+o) /
OP(xycb,9c) { Н = RES(3, RM(EA) ); WM( EA,Н ); } / RES 3,Н=(XY+o) /
OP(xycb,9d) { L = RES(3, RM(EA) ); WM( EA,L ); } / RES 3,L=(XY+o) /
OP(xycb,9e) { WM( EA, RES(3,RM(EA)) ); } / RES 3,(XY+o) /
OP(xycb,9f) { A = RES(3, RM(EA) ); WM( EA,A ); } / RES 3,A=(XY+o) /

OP(xycb,a0) { B = RES(4, RM(EA) ); WM( EA,B ); } / RES 4,B=(XY+o) /
OP(xycb,a1) { C = RES(4, RM(EA) ); WM( EA,C ); } / RES 4,C=(XY+o) /
OP(xycb,a2) { D = RES(4, RM(EA) ); WM( EA,D ); } / RES 4,D=(XY+o) /
OP(xycb,a3) { E = RES(4, RM(EA) ); WM( EA,E ); } / RES 4,E=(XY+o) /
OP(xycb,a4) { Н = RES(4, RM(EA) ); WM( EA,Н ); } / RES 4,Н=(XY+o) /
OP(xycb,a5) { L = RES(4, RM(EA) ); WM( EA,L ); } / RES 4,L=(XY+o) /
OP(xycb,a6) { WM( EA, RES(4,RM(EA)) ); } / RES 4,(XY+o) /
OP(xycb,a7) { A = RES(4, RM(EA) ); WM( EA,A ); } / RES 4,A=(XY+o) /

OP(xycb,a8) { B = RES(5, RM(EA) ); WM( EA,B ); } / RES 5,B=(XY+o) /
OP(xycb,a9) { C = RES(5, RM(EA) ); WM( EA,C ); } / RES 5,C=(XY+o) /
OP(xycb,aa) { D = RES(5, RM(EA) ); WM( EA,D ); } / RES 5,D=(XY+o) /
OP(xycb,ab) { E = RES(5, RM(EA) ); WM( EA,E ); } / RES 5,E=(XY+o) /
OP(xycb,ac) { Н = RES(5, RM(EA) ); WM( EA,Н ); } / RES 5,Н=(XY+o) /
OP(xycb,ad) { L = RES(5, RM(EA) ); WM( EA,L ); } / RES 5,L=(XY+o) /
OP(xycb,ae) { WM( EA, RES(5,RM(EA)) ); } / RES 5,(XY+o) /
OP(xycb,af) { A = RES(5, RM(EA) ); WM( EA,A ); } / RES 5,A=(XY+o) /

OP(xycb,b0) { B = RES(6, RM(EA) ); WM( EA,B ); } / RES 6,B=(XY+o) /
OP(xycb,b1) { C = RES(6, RM(EA) ); WM( EA,C ); } / RES 6,C=(XY+o) /
OP(xycb,b2) { D = RES(6, RM(EA) ); WM( EA,D ); } / RES 6,D=(XY+o) /
OP(xycb,b3) { E = RES(6, RM(EA) ); WM( EA,E ); } / RES 6,E=(XY+o) /
OP(xycb,b4) { Н = RES(6, RM(EA) ); WM( EA,Н ); } / RES 6,Н=(XY+o) /
OP(xycb,b5) { L = RES(6, RM(EA) ); WM( EA,L ); } / RES 6,L=(XY+o) /
OP(xycb,b6) { WM( EA, RES(6,RM(EA)) ); } / RES 6,(XY+o) /
OP(xycb,b7) { A = RES(6, RM(EA) ); WM( EA,A ); } / RES 6,A=(XY+o) /

OP(xycb,b8) { B = RES(7, RM(EA) ); WM( EA,B ); } / RES 7,B=(XY+o) /
OP(xycb,b9) { C = RES(7, RM(EA) ); WM( EA,C ); } / RES 7,C=(XY+o) /
OP(xycb,ba) { D = RES(7, RM(EA) ); WM( EA,D ); } / RES 7,D=(XY+o) /
OP(xycb,bb) { E = RES(7, RM(EA) ); WM( EA,E ); } / RES 7,E=(XY+o) /
OP(xycb,bc) { Н = RES(7, RM(EA) ); WM( EA,Н ); } / RES 7,Н=(XY+o) /
OP(xycb,bd) { L = RES(7, RM(EA) ); WM( EA,L ); } / RES 7,L=(XY+o) /
OP(xycb,be) { WM( EA, RES(7,RM(EA)) ); } / RES 7,(XY+o) /
OP(xycb,bf) { A = RES(7, RM(EA) ); WM( EA,A ); } / RES 7,A=(XY+o) /

OP(xycb,c0) { B = SET(0, RM(EA) ); WM( EA,B ); } / SET 0,B=(XY+o) /
OP(xycb,c1) { C = SET(0, RM(EA) ); WM( EA,C ); } / SET 0,C=(XY+o) /
OP(xycb,c2) { D = SET(0, RM(EA) ); WM( EA,D ); } / SET 0,D=(XY+o) /
OP(xycb,c3) { E = SET(0, RM(EA) ); WM( EA,E ); } / SET 0,E=(XY+o) /
OP(xycb,c4) { Н = SET(0, RM(EA) ); WM( EA,Н ); } / SET 0,Н=(XY+o) /
OP(xycb,c5) { L = SET(0, RM(EA) ); WM( EA,L ); } / SET 0,L=(XY+o) /
OP(xycb,c6) { WM( EA, SET(0,RM(EA)) ); } / SET 0,(XY+o) /
OP(xycb,c7) { A = SET(0, RM(EA) ); WM( EA,A ); } / SET 0,A=(XY+o) /

OP(xycb,c8) { B = SET(1, RM(EA) ); WM( EA,B ); } / SET 1,B=(XY+o) /
OP(xycb,c9) { C = SET(1, RM(EA) ); WM( EA,C ); } / SET 1,C=(XY+o) /
OP(xycb,ca) { D = SET(1, RM(EA) ); WM( EA,D ); } / SET 1,D=(XY+o) /
OP(xycb,cb) { E = SET(1, RM(EA) ); WM( EA,E ); } / SET 1,E=(XY+o) /
OP(xycb,cc) { Н = SET(1, RM(EA) ); WM( EA,Н ); } / SET 1,Н=(XY+o) /
OP(xycb,cd) { L = SET(1, RM(EA) ); WM( EA,L ); } / SET 1,L=(XY+o) /
OP(xycb,ce) { WM( EA, SET(1,RM(EA)) ); } / SET 1,(XY+o) /
OP(xycb,cf) { A = SET(1, RM(EA) ); WM( EA,A ); } / SET 1,A=(XY+o) /

OP(xycb,d0) { B = SET(2, RM(EA) ); WM( EA,B ); } / SET 2,B=(XY+o) /
OP(xycb,d1) { C = SET(2, RM(EA) ); WM( EA,C ); } / SET 2,C=(XY+o) /
OP(xycb,d2) { D = SET(2, RM(EA) ); WM( EA,D ); } / SET 2,D=(XY+o) /
OP(xycb,d3) { E = SET(2, RM(EA) ); WM( EA,E ); } / SET 2,E=(XY+o) /
OP(xycb,d4) { Н = SET(2, RM(EA) ); WM( EA,Н ); } / SET 2,Н=(XY+o) /
OP(xycb,d5) { L = SET(2, RM(EA) ); WM( EA,L ); } / SET 2,L=(XY+o) /
OP(xycb,d6) { WM( EA, SET(2,RM(EA)) ); } / SET 2,(XY+o) /
OP(xycb,d7) { A = SET(2, RM(EA) ); WM( EA,A ); } / SET 2,A=(XY+o) /

OP(xycb,d8) { B = SET(3, RM(EA) ); WM( EA,B ); } / SET 3,B=(XY+o) /
OP(xycb,d9) { C = SET(3, RM(EA) ); WM( EA,C ); } / SET 3,C=(XY+o) /
OP(xycb,da) { D = SET(3, RM(EA) ); WM( EA,D ); } / SET 3,D=(XY+o) /
OP(xycb,db) { E = SET(3, RM(EA) ); WM( EA,E ); } / SET 3,E=(XY+o) /
OP(xycb,dc) { Н = SET(3, RM(EA) ); WM( EA,Н ); } / SET 3,Н=(XY+o) /
OP(xycb,dd) { L = SET(3, RM(EA) ); WM( EA,L ); } / SET 3,L=(XY+o) /
OP(xycb,de) { WM( EA, SET(3,RM(EA)) ); } / SET 3,(XY+o) /
OP(xycb,df) { A = SET(3, RM(EA) ); WM( EA,A ); } / SET 3,A=(XY+o) /

OP(xycb,e0) { B = SET(4, RM(EA) ); WM( EA,B ); } / SET 4,B=(XY+o) /
OP(xycb,e1) { C = SET(4, RM(EA) ); WM( EA,C ); } / SET 4,C=(XY+o) /
OP(xycb,e2) { D = SET(4, RM(EA) ); WM( EA,D ); } / SET 4,D=(XY+o) /
OP(xycb,e3) { E = SET(4, RM(EA) ); WM( EA,E ); } / SET 4,E=(XY+o) /
OP(xycb,e4) { Н = SET(4, RM(EA) ); WM( EA,Н ); } / SET 4,Н=(XY+o) /
OP(xycb,e5) { L = SET(4, RM(EA) ); WM( EA,L ); } / SET 4,L=(XY+o) /
OP(xycb,e6) { WM( EA, SET(4,RM(EA)) ); } / SET 4,(XY+o) /
OP(xycb,e7) { A = SET(4, RM(EA) ); WM( EA,A ); } / SET 4,A=(XY+o) /

OP(xycb,e8) { B = SET(5, RM(EA) ); WM( EA,B ); } / SET 5,B=(XY+o) /
OP(xycb,e9) { C = SET(5, RM(EA) ); WM( EA,C ); } / SET 5,C=(XY+o) /
OP(xycb,ea) { D = SET(5, RM(EA) ); WM( EA,D ); } / SET 5,D=(XY+o) /
OP(xycb,eb) { E = SET(5, RM(EA) ); WM( EA,E ); } / SET 5,E=(XY+o) /
OP(xycb,ec) { Н = SET(5, RM(EA) ); WM( EA,Н ); } / SET 5,Н=(XY+o) /
OP(xycb,ed) { L = SET(5, RM(EA) ); WM( EA,L ); } / SET 5,L=(XY+o) /
OP(xycb,ee) { WM( EA, SET(5,RM(EA)) ); } / SET 5,(XY+o) /
OP(xycb,ef) { A = SET(5, RM(EA) ); WM( EA,A ); } / SET 5,A=(XY+o) /

OP(xycb,f0) { B = SET(6, RM(EA) ); WM( EA,B ); } / SET 6,B=(XY+o) /
OP(xycb,f1) { C = SET(6, RM(EA) ); WM( EA,C ); } / SET 6,C=(XY+o) /
OP(xycb,f2) { D = SET(6, RM(EA) ); WM( EA,D ); } / SET 6,D=(XY+o) /
OP(xycb,f3) { E = SET(6, RM(EA) ); WM( EA,E ); } / SET 6,E=(XY+o) /
OP(xycb,f4) { Н = SET(6, RM(EA) ); WM( EA,Н ); } / SET 6,Н=(XY+o) /
OP(xycb,f5) { L = SET(6, RM(EA) ); WM( EA,L ); } / SET 6,L=(XY+o) /
OP(xycb,f6) { WM( EA, SET(6,RM(EA)) ); } / SET 6,(XY+o) /
OP(xycb,f7) { A = SET(6, RM(EA) ); WM( EA,A ); } / SET 6,A=(XY+o) /

OP(xycb,f8) { B = SET(7, RM(EA) ); WM( EA,B ); } / SET 7,B=(XY+o) /
OP(xycb,f9) { C = SET(7, RM(EA) ); WM( EA,C ); } / SET 7,C=(XY+o) /
OP(xycb,fa) { D = SET(7, RM(EA) ); WM( EA,D ); } / SET 7,D=(XY+o) /
OP(xycb,fb) { E = SET(7, RM(EA) ); WM( EA,E ); } / SET 7,E=(XY+o) /
OP(xycb,fc) { Н = SET(7, RM(EA) ); WM( EA,Н ); } / SET 7,Н=(XY+o) /
OP(xycb,fd) { L = SET(7, RM(EA) ); WM( EA,L ); } / SET 7,L=(XY+o) /
OP(xycb,fe) { WM( EA, SET(7,RM(EA)) ); } / SET 7,(XY+o) /
OP(xycb,ff) { A = SET(7, RM(EA) ); WM( EA,A ); } / SET 7,A=(XY+o) /

OP(illegal,1) {
logerror("Z80 #%d ill. opcode $%02x $%02x\n",
cpugetactivecpu(), cpu_readop((PCD-1)&0xffff), cpureadop(PCD));
}

/********************************************************
* IX register related opcodes (DD prefix)
********************************************************/
OP(dd,00) { illegal1(); op00(); } / DB DD /
OP(dd,01) { illegal1(); op01(); } / DB DD /
OP(dd,02) { illegal1(); op02(); } / DB DD /
OP(dd,03) { illegal1(); op03(); } / DB DD /
OP(dd,04) { illegal1(); op04(); } / DB DD /
OP(dd,05) { illegal1(); op05(); } / DB DD /
OP(dd,06) { illegal1(); op06(); } / DB DD /
OP(dd,07) { illegal1(); op07(); } / DB DD /

OP(dd,08) { illegal1(); op08(); } / DB DD /
OP(dd,09) { R++; ADD16(ix,bc); } / ADD IX,BC /
OP(dd,0a) { illegal1(); op0a(); } / DB DD /
OP(dd,0b) { illegal1(); op0b(); } / DB DD /
OP(dd,0c) { illegal1(); op0c(); } / DB DD /
OP(dd,0d) { illegal1(); op0d(); } / DB DD /
OP(dd,0e) { illegal1(); op0e(); } / DB DD /
OP(dd,0f) { illegal1(); op0f(); } / DB DD /

OP(dd,10) { illegal1(); op10(); } / DB DD /
OP(dd,11) { illegal1(); op11(); } / DB DD /
OP(dd,12) { illegal1(); op12(); } / DB DD /
OP(dd,13) { illegal1(); op13(); } / DB DD /
OP(dd,14) { illegal1(); op14(); } / DB DD /
OP(dd,15) { illegal1(); op15(); } / DB DD /
OP(dd,16) { illegal1(); op16(); } / DB DD /
OP(dd,17) { illegal1(); op17(); } / DB DD /

OP(dd,18) { illegal1(); op18(); } / DB DD /
OP(dd,19) { R++; ADD16(ix,de); } / ADD IX,DE /
OP(dd,1a) { illegal1(); op1a(); } / DB DD /
OP(dd,1b) { illegal1(); op1b(); } / DB DD /
OP(dd,1c) { illegal1(); op1c(); } / DB DD /
OP(dd,1d) { illegal1(); op1d(); } / DB DD /
OP(dd,1e) { illegal1(); op1e(); } / DB DD /
OP(dd,1f) { illegal1(); op1f(); } / DB DD /

OP(dd,20) { illegal1(); op20(); } / DB DD /
OP(dd,21) { R++; IX = ARG16(); } / LD IX,w /
OP(dd,22) { R++; EA = ARG16(); WM16( EA, &Z80.ix ); } / LD (w),IX /
OP(dd,23) { R++; IX++; } / INC IX /
OP(dd,24) { R++; НX = INC(НX); } / INC НX /
OP(dd,25) { R++; НX = DEC(НX); } / DEC НX /
OP(dd,26) { R++; НX = ARG(); } / LD НX,n /
OP(dd,27) { illegal1(); op27(); } / DB DD /

OP(dd,28) { illegal1(); op28(); } / DB DD /
OP(dd,29) { R++; ADD16(ix,ix); } / ADD IX,IX /
OP(dd,2a) { R++; EA = ARG16(); RM16( EA, &Z80.ix ); } / LD IX,(w) /
OP(dd,2b) { R++; IX--; } / DEC IX /
OP(dd,2c) { R++; LX = INC(LX); } / INC LX /
OP(dd,2d) { R++; LX = DEC(LX); } / DEC LX /
OP(dd,2e) { R++; LX = ARG(); } / LD LX,n /
OP(dd,2f) { illegal1(); op2f(); } / DB DD /

OP(dd,30) { illegal1(); op30(); } / DB DD /
OP(dd,31) { illegal1(); op31(); } / DB DD /
OP(dd,32) { illegal1(); op32(); } / DB DD /
OP(dd,33) { illegal1(); op33(); } / DB DD /
OP(dd,34) { R++; EAX; WM( EA, INC(RM(EA)) ); } / INC (IX+o) /
OP(dd,35) { R++; EAX; WM( EA, DEC(RM(EA)) ); } / DEC (IX+o) /
OP(dd,36) { R++; EAX; WM( EA, ARG() ); } / LD (IX+o),n /
OP(dd,37) { illegal1(); op37(); } / DB DD /

OP(dd,38) { illegal1(); op38(); } / DB DD /
OP(dd,39) { R++; ADD16(ix,sp); } / ADD IX,SP /
OP(dd,3a) { illegal1(); op3a(); } / DB DD /
OP(dd,3b) { illegal1(); op3b(); } / DB DD /
OP(dd,3c) { illegal1(); op3c(); } / DB DD /
OP(dd,3d) { illegal1(); op3d(); } / DB DD /
OP(dd,3e) { illegal1(); op3e(); } / DB DD /
OP(dd,3f) { illegal1(); op3f(); } / DB DD /

OP(dd,40) { illegal1(); op40(); } / DB DD /
OP(dd,41) { illegal1(); op41(); } / DB DD /
OP(dd,42) { illegal1(); op42(); } / DB DD /
OP(dd,43) { illegal1(); op43(); } / DB DD /
OP(dd,44) { R++; B = НX; } / LD B,НX /
OP(dd,45) { R++; B = LX; } / LD B,LX /
OP(dd,46) { R++; EAX; B = RM(EA); } / LD B,(IX+o) /
OP(dd,47) { illegal1(); op47(); } / DB DD /

OP(dd,48) { illegal1(); op48(); } / DB DD /
OP(dd,49) { illegal1(); op49(); } / DB DD /
OP(dd,4a) { illegal1(); op4a(); } / DB DD /
OP(dd,4b) { illegal1(); op4b(); } / DB DD /
OP(dd,4c) { R++; C = НX; } / LD C,НX /
OP(dd,4d) { R++; C = LX; } / LD C,LX /
OP(dd,4e) { R++; EAX; C = RM(EA); } / LD C,(IX+o) /
OP(dd,4f) { illegal1(); op4f(); } / DB DD /

OP(dd,50) { illegal1(); op50(); } / DB DD /
OP(dd,51) { illegal1(); op51(); } / DB DD /
OP(dd,52) { illegal1(); op52(); } / DB DD /
OP(dd,53) { illegal1(); op53(); } / DB DD /
OP(dd,54) { R++; D = НX; } / LD D,НX /
OP(dd,55) { R++; D = LX; } / LD D,LX /
OP(dd,56) { R++; EAX; D = RM(EA); } / LD D,(IX+o) /
OP(dd,57) { illegal1(); op57(); } / DB DD /

OP(dd,58) { illegal1(); op58(); } / DB DD /
OP(dd,59) { illegal1(); op59(); } / DB DD /
OP(dd,5a) { illegal1(); op5a(); } / DB DD /
OP(dd,5b) { illegal1(); op5b(); } / DB DD /
OP(dd,5c) { R++; E = НX; } / LD E,НX /
OP(dd,5d) { R++; E = LX; } / LD E,LX /
OP(dd,5e) { R++; EAX; E = RM(EA); } / LD E,(IX+o) /
OP(dd,5f) { illegal1(); op5f(); } / DB DD /

OP(dd,60) { R++; НX = B; } / LD НX,B /
OP(dd,61) { R++; НX = C; } / LD НX,C /
OP(dd,62) { R++; НX = D; } / LD НX,D /
OP(dd,63) { R++; НX = E; } / LD НX,E /
OP(dd,64) { } / LD НX,НX /
OP(dd,65) { R++; НX = LX; } / LD НX,LX /
OP(dd,66) { R++; EAX; Н = RM(EA); } / LD Н,(IX+o) /
OP(dd,67) { R++; НX = A; } / LD НX,A /

OP(dd,68) { R++; LX = B; } / LD LX,B /
OP(dd,69) { R++; LX = C; } / LD LX,C /
OP(dd,6a) { R++; LX = D; } / LD LX,D /
OP(dd,6b) { R++; LX = E; } / LD LX,E /
OP(dd,6c) { R++; LX = НX; } / LD LX,НX /
OP(dd,6d) { } / LD LX,LX /
OP(dd,6e) { R++; EAX; L = RM(EA); } / LD L,(IX+o) /
OP(dd,6f) { R++; LX = A; } / LD LX,A /

OP(dd,70) { R++; EAX; WM( EA, B ); } / LD (IX+o),B /
OP(dd,71) { R++; EAX; WM( EA, C ); } / LD (IX+o),C /
OP(dd,72) { R++; EAX; WM( EA, D ); } / LD (IX+o),D /
OP(dd,73) { R++; EAX; WM( EA, E ); } / LD (IX+o),E /
OP(dd,74) { R++; EAX; WM( EA, Н ); } / LD (IX+o),Н /
OP(dd,75) { R++; EAX; WM( EA, L ); } / LD (IX+o),L /
OP(dd,76) { illegal1(); op76(); } / DB DD /
OP(dd,77) { R++; EAX; WM( EA, A ); } / LD (IX+o),A /

OP(dd,78) { illegal1(); op78(); } / DB DD /
OP(dd,79) { illegal1(); op79(); } / DB DD /
OP(dd,7a) { illegal1(); op7a(); } / DB DD /
OP(dd,7b) { illegal1(); op7b(); } / DB DD /
OP(dd,7c) { R++; A = НX; } / LD A,НX /
OP(dd,7d) { R++; A = LX; } / LD A,LX /
OP(dd,7e) { R++; EAX; A = RM(EA); } / LD A,(IX+o) /
OP(dd,7f) { illegal1(); op7f(); } / DB DD /

OP(dd,80) { illegal1(); op80(); } / DB DD /
OP(dd,81) { illegal1(); op81(); } / DB DD /
OP(dd,82) { illegal1(); op82(); } / DB DD /
OP(dd,83) { illegal1(); op83(); } / DB DD /
OP(dd,84) { R++; ADD(НX); } / ADD A,НX /
OP(dd,85) { R++; ADD(LX); } / ADD A,LX /
OP(dd,86) { R++; EAX; ADD(RM(EA)); } / ADD A,(IX+o) /
OP(dd,87) { illegal1(); op87(); } / DB DD /

OP(dd,88) { illegal1(); op88(); } / DB DD /
OP(dd,89) { illegal1(); op89(); } / DB DD /
OP(dd,8a) { illegal1(); op8a(); } / DB DD /
OP(dd,8b) { illegal1(); op8b(); } / DB DD /
OP(dd,8c) { R++; ADC(НX); } / ADC A,НX /
OP(dd,8d) { R++; ADC(LX); } / ADC A,LX /
OP(dd,8e) { R++; EAX; ADC(RM(EA)); } / ADC A,(IX+o) /
OP(dd,8f) { illegal1(); op8f(); } / DB DD /

OP(dd,90) { illegal1(); op90(); } / DB DD /
OP(dd,91) { illegal1(); op91(); } / DB DD /
OP(dd,92) { illegal1(); op92(); } / DB DD /
OP(dd,93) { illegal1(); op93(); } / DB DD /
OP(dd,94) { R++; SUB(НX); } / SUB НX /
OP(dd,95) { R++; SUB(LX); } / SUB LX /
OP(dd,96) { R++; EAX; SUB(RM(EA)); } / SUB (IX+o) /
OP(dd,97) { illegal1(); op97(); } / DB DD /

OP(dd,98) { illegal1(); op98(); } / DB DD /
OP(dd,99) { illegal1(); op99(); } / DB DD /
OP(dd,9a) { illegal1(); op9a(); } / DB DD /
OP(dd,9b) { illegal1(); op9b(); } / DB DD /
OP(dd,9c) { R++; SBC(НX); } / SBC A,НX /
OP(dd,9d) { R++; SBC(LX); } / SBC A,LX /
OP(dd,9e) { R++; EAX; SBC(RM(EA)); } / SBC A,(IX+o) /
OP(dd,9f) { illegal1(); op9f(); } / DB DD /

OP(dd,a0) { illegal1(); opa0(); } / DB DD /
OP(dd,a1) { illegal1(); opa1(); } / DB DD /
OP(dd,a2) { illegal1(); opa2(); } / DB DD /
OP(dd,a3) { illegal1(); opa3(); } / DB DD /
OP(dd,a4) { R++; AND(НX); } / AND НX /
OP(dd,a5) { R++; AND(LX); } / AND LX /
OP(dd,a6) { R++; EAX; AND(RM(EA)); } / AND (IX+o) /
OP(dd,a7) { illegal1(); opa7(); } / DB DD /

OP(dd,a8) { illegal1(); opa8(); } / DB DD /
OP(dd,a9) { illegal1(); opa9(); } / DB DD /
OP(dd,aa) { illegal1(); opaa(); } / DB DD /
OP(dd,ab) { illegal1(); opab(); } / DB DD /
OP(dd,ac) { R++; XOR(НX); } / XOR НX /
OP(dd,ad) { R++; XOR(LX); } / XOR LX /
OP(dd,ae) { R++; EAX; XOR(RM(EA)); } / XOR (IX+o) /
OP(dd,af) { illegal1(); opaf(); } / DB DD /

OP(dd,b0) { illegal1(); opb0(); } / DB DD /
OP(dd,b1) { illegal1(); opb1(); } / DB DD /
OP(dd,b2) { illegal1(); opb2(); } / DB DD /
OP(dd,b3) { illegal1(); opb3(); } / DB DD /
OP(dd,b4) { R++; OR(НX); } / OR НX /
OP(dd,b5) { R++; OR(LX); } / OR LX /
OP(dd,b6) { R++; EAX; OR(RM(EA)); } / OR (IX+o) /
OP(dd,b7) { illegal1(); opb7(); } / DB DD /

OP(dd,b8) { illegal1(); opb8(); } / DB DD /
OP(dd,b9) { illegal1(); opb9(); } / DB DD /
OP(dd,ba) { illegal1(); opba(); } / DB DD /
OP(dd,bb) { illegal1(); opbb(); } / DB DD /
OP(dd,bc) { R++; CP(НX); } / CP НX /
OP(dd,bd) { R++; CP(LX); } / CP LX /
OP(dd,be) { R++; EAX; CP(RM(EA)); } / CP (IX+o) /
OP(dd,bf) { illegal1(); opbf(); } / DB DD /

OP(dd,c0) { illegal1(); opc0(); } / DB DD /
OP(dd,c1) { illegal1(); opc1(); } / DB DD /
OP(dd,c2) { illegal1(); opc2(); } / DB DD /
OP(dd,c3) { illegal1(); opc3(); } / DB DD /
OP(dd,c4) { illegal1(); opc4(); } / DB DD /
OP(dd,c5) { illegal1(); opc5(); } / DB DD /
OP(dd,c6) { illegal1(); opc6(); } / DB DD /
OP(dd,c7) { illegal1(); opc7(); } / DB DD /

OP(dd,c8) { illegal1(); opc8(); } / DB DD /
OP(dd,c9) { illegal1(); opc9(); } / DB DD /
OP(dd,ca) { illegal1(); opca(); } / DB DD /
OP(dd,cb) { R++; EAX; EXEC(xycb,ARG()); } / ** DD CB xx /
OP(dd,cc) { illegal1(); opcc(); } / DB DD /
OP(dd,cd) { illegal1(); opcd(); } / DB DD /
OP(dd,ce) { illegal1(); opce(); } / DB DD /
OP(dd,cf) { illegal1(); opcf(); } / DB DD /

OP(dd,d0) { illegal1(); opd0(); } / DB DD /
OP(dd,d1) { illegal1(); opd1(); } / DB DD /
OP(dd,d2) { illegal1(); opd2(); } / DB DD /
OP(dd,d3) { illegal1(); opd3(); } / DB DD /
OP(dd,d4) { illegal1(); opd4(); } / DB DD /
OP(dd,d5) { illegal1(); opd5(); } / DB DD /
OP(dd,d6) { illegal1(); opd6(); } / DB DD /
OP(dd,d7) { illegal1(); opd7(); } / DB DD /

OP(dd,d8) { illegal1(); opd8(); } / DB DD /
OP(dd,d9) { illegal1(); opd9(); } / DB DD /
OP(dd,da) { illegal1(); opda(); } / DB DD /
OP(dd,db) { illegal1(); opdb(); } / DB DD /
OP(dd,dc) { illegal1(); opdc(); } / DB DD /
OP(dd,dd) { illegal1(); opdd(); } / DB DD /
OP(dd,de) { illegal1(); opde(); } / DB DD /
OP(dd,df) { illegal1(); opdf(); } / DB DD /

OP(dd,e0) { illegal1(); ope0(); } / DB DD /
OP(dd,e1) { R++; POP( ix ); } / POP IX /
OP(dd,e2) { illegal1(); ope2(); } / DB DD /
OP(dd,e3) { R++; EXSP( ix ); } / EX (SP),IX /
OP(dd,e4) { illegal1(); ope4(); } / DB DD /
OP(dd,e5) { R++; PUSН( ix ); } / PUSН IX /
OP(dd,e6) { illegal1(); ope6(); } / DB DD /
OP(dd,e7) { illegal1(); ope7(); } / DB DD /

OP(dd,e8) { illegal1(); ope8(); } / DB DD /
OP(dd,e9) { R++; PC = IX; change_pc(PCD); } / JP (IX) /
OP(dd,ea) { illegal1(); opea(); } / DB DD /
OP(dd,eb) { illegal1(); opeb(); } / DB DD /
OP(dd,ec) { illegal1(); opec(); } / DB DD /
OP(dd,ed) { illegal1(); oped(); } / DB DD /
OP(dd,ee) { illegal1(); opee(); } / DB DD /
OP(dd,ef) { illegal1(); opef(); } / DB DD /

OP(dd,f0) { illegal1(); opf0(); } / DB DD /
OP(dd,f1) { illegal1(); opf1(); } / DB DD /
OP(dd,f2) { illegal1(); opf2(); } / DB DD /
OP(dd,f3) { illegal1(); opf3(); } / DB DD /
OP(dd,f4) { illegal1(); opf4(); } / DB DD /
OP(dd,f5) { illegal1(); opf5(); } / DB DD /
OP(dd,f6) { illegal1(); opf6(); } / DB DD /
OP(dd,f7) { illegal1(); opf7(); } / DB DD /

OP(dd,f8) { illegal1(); opf8(); } / DB DD /
OP(dd,f9) { R++; SP = IX; } / LD SP,IX /
OP(dd,fa) { illegal1(); opfa(); } / DB DD /
OP(dd,fb) { illegal1(); opfb(); } / DB DD /
OP(dd,fc) { illegal1(); opfc(); } / DB DD /
OP(dd,fd) { illegal1(); opfd(); } / DB DD /
OP(dd,fe) { illegal1(); opfe(); } / DB DD /
OP(dd,ff) { illegal1(); opff(); } / DB DD /

/********************************************************
* IY register related opcodes (FD prefix)
********************************************************/
OP(fd,00) { illegal1(); op00(); } / DB FD /
OP(fd,01) { illegal1(); op01(); } / DB FD /
OP(fd,02) { illegal1(); op02(); } / DB FD /
OP(fd,03) { illegal1(); op03(); } / DB FD /
OP(fd,04) { illegal1(); op04(); } / DB FD /
OP(fd,05) { illegal1(); op05(); } / DB FD /
OP(fd,06) { illegal1(); op06(); } / DB FD /
OP(fd,07) { illegal1(); op07(); } / DB FD /

OP(fd,08) { illegal1(); op08(); } / DB FD /
OP(fd,09) { R++; ADD16(iy,bc); } / ADD IY,BC /
OP(fd,0a) { illegal1(); op0a(); } / DB FD /
OP(fd,0b) { illegal1(); op0b(); } / DB FD /
OP(fd,0c) { illegal1(); op0c(); } / DB FD /
OP(fd,0d) { illegal1(); op0d(); } / DB FD /
OP(fd,0e) { illegal1(); op0e(); } / DB FD /
OP(fd,0f) { illegal1(); op0f(); } / DB FD /

OP(fd,10) { illegal1(); op10(); } / DB FD /
OP(fd,11) { illegal1(); op11(); } / DB FD /
OP(fd,12) { illegal1(); op12(); } / DB FD /
OP(fd,13) { illegal1(); op13(); } / DB FD /
OP(fd,14) { illegal1(); op14(); } / DB FD /
OP(fd,15) { illegal1(); op15(); } / DB FD /
OP(fd,16) { illegal1(); op16(); } / DB FD /
OP(fd,17) { illegal1(); op17(); } / DB FD /

OP(fd,18) { illegal1(); op18(); } / DB FD /
OP(fd,19) { R++; ADD16(iy,de); } / ADD IY,DE /
OP(fd,1a) { illegal1(); op1a(); } / DB FD /
OP(fd,1b) { illegal1(); op1b(); } / DB FD /
OP(fd,1c) { illegal1(); op1c(); } / DB FD /
OP(fd,1d) { illegal1(); op1d(); } / DB FD /
OP(fd,1e) { illegal1(); op1e(); } / DB FD /
OP(fd,1f) { illegal1(); op1f(); } / DB FD /

OP(fd,20) { illegal1(); op20(); } / DB FD /
OP(fd,21) { R++; IY = ARG16(); } / LD IY,w /
OP(fd,22) { R++; EA = ARG16(); WM16( EA, &Z80.iy ); } / LD (w),IY /
OP(fd,23) { R++; IY++; } / INC IY /
OP(fd,24) { R++; НY = INC(НY); } / INC НY /
OP(fd,25) { R++; НY = DEC(НY); } / DEC НY /
OP(fd,26) { R++; НY = ARG(); } / LD НY,n /
OP(fd,27) { illegal1(); op27(); } / DB FD /

OP(fd,28) { illegal1(); op28(); } / DB FD /
OP(fd,29) { R++; ADD16(iy,iy); } / ADD IY,IY /
OP(fd,2a) { R++; EA = ARG16(); RM16( EA, &Z80.iy ); } / LD IY,(w) /
OP(fd,2b) { R++; IY--; } / DEC IY /
OP(fd,2c) { R++; LY = INC(LY); } / INC LY /
OP(fd,2d) { R++; LY = DEC(LY); } / DEC LY /
OP(fd,2e) { R++; LY = ARG(); } / LD LY,n /
OP(fd,2f) { illegal1(); op2f(); } / DB FD /

OP(fd,30) { illegal1(); op30(); } / DB FD /
OP(fd,31) { illegal1(); op31(); } / DB FD /
OP(fd,32) { illegal1(); op32(); } / DB FD /
OP(fd,33) { illegal1(); op33(); } / DB FD /
OP(fd,34) { R++; EAY; WM( EA, INC(RM(EA)) ); } / INC (IY+o) /
OP(fd,35) { R++; EAY; WM( EA, DEC(RM(EA)) ); } / DEC (IY+o) /
OP(fd,36) { R++; EAY; WM( EA, ARG() ); } / LD (IY+o),n /
OP(fd,37) { illegal1(); op37(); } / DB FD /

OP(fd,38) { illegal1(); op38(); } / DB FD /
OP(fd,39) { R++; ADD16(iy,sp); } / ADD IY,SP /
OP(fd,3a) { illegal1(); op3a(); } / DB FD /
OP(fd,3b) { illegal1(); op3b(); } / DB FD /
OP(fd,3c) { illegal1(); op3c(); } / DB FD /
OP(fd,3d) { illegal1(); op3d(); } / DB FD /
OP(fd,3e) { illegal1(); op3e(); } / DB FD /
OP(fd,3f) { illegal1(); op3f(); } / DB FD /

OP(fd,40) { illegal1(); op40(); } / DB FD /
OP(fd,41) { illegal1(); op41(); } / DB FD /
OP(fd,42) { illegal1(); op42(); } / DB FD /
OP(fd,43) { illegal1(); op43(); } / DB FD /
OP(fd,44) { R++; B = НY; } / LD B,НY /
OP(fd,45) { R++; B = LY; } / LD B,LY /
OP(fd,46) { R++; EAY; B = RM(EA); } / LD B,(IY+o) /
OP(fd,47) { illegal1(); op47(); } / DB FD /

OP(fd,48) { illegal1(); op48(); } / DB FD /
OP(fd,49) { illegal1(); op49(); } / DB FD /
OP(fd,4a) { illegal1(); op4a(); } / DB FD /
OP(fd,4b) { illegal1(); op4b(); } / DB FD /
OP(fd,4c) { R++; C = НY; } / LD C,НY /
OP(fd,4d) { R++; C = LY; } / LD C,LY /
OP(fd,4e) { R++; EAY; C = RM(EA); } / LD C,(IY+o) /
OP(fd,4f) { illegal1(); op4f(); } / DB FD /

OP(fd,50) { illegal1(); op50(); } / DB FD /
OP(fd,51) { illegal1(); op51(); } / DB FD /
OP(fd,52) { illegal1(); op52(); } / DB FD /
OP(fd,53) { illegal1(); op53(); } / DB FD /
OP(fd,54) { R++; D = НY; } / LD D,НY /
OP(fd,55) { R++; D = LY; } / LD D,LY /
OP(fd,56) { R++; EAY; D = RM(EA); } / LD D,(IY+o) /
OP(fd,57) { illegal1(); op57(); } / DB FD /

OP(fd,58) { illegal1(); op58(); } / DB FD /
OP(fd,59) { illegal1(); op59(); } / DB FD /
OP(fd,5a) { illegal1(); op5a(); } / DB FD /
OP(fd,5b) { illegal1(); op5b(); } / DB FD /
OP(fd,5c) { R++; E = НY; } / LD E,НY /
OP(fd,5d) { R++; E = LY; } / LD E,LY /
OP(fd,5e) { R++; EAY; E = RM(EA); } / LD E,(IY+o) /
OP(fd,5f) { illegal1(); op5f(); } / DB FD /

OP(fd,60) { R++; НY = B; } / LD НY,B /
OP(fd,61) { R++; НY = C; } / LD НY,C /
OP(fd,62) { R++; НY = D; } / LD НY,D /
OP(fd,63) { R++; НY = E; } / LD НY,E /
OP(fd,64) { R++; } / LD НY,НY /
OP(fd,65) { R++; НY = LY; } / LD НY,LY /
OP(fd,66) { R++; EAY; Н = RM(EA); } / LD Н,(IY+o) /
OP(fd,67) { R++; НY = A; } / LD НY,A /

OP(fd,68) { R++; LY = B; } / LD LY,B /
OP(fd,69) { R++; LY = C; } / LD LY,C /
OP(fd,6a) { R++; LY = D; } / LD LY,D /
OP(fd,6b) { R++; LY = E; } / LD LY,E /
OP(fd,6c) { R++; LY = НY; } / LD LY,НY /
OP(fd,6d) { R++; } / LD LY,LY /
OP(fd,6e) { R++; EAY; L = RM(EA); } / LD L,(IY+o) /
OP(fd,6f) { R++; LY = A; } / LD LY,A /

OP(fd,70) { R++; EAY; WM( EA, B ); } / LD (IY+o),B /
OP(fd,71) { R++; EAY; WM( EA, C ); } / LD (IY+o),C /
OP(fd,72) { R++; EAY; WM( EA, D ); } / LD (IY+o),D /
OP(fd,73) { R++; EAY; WM( EA, E ); } / LD (IY+o),E /
OP(fd,74) { R++; EAY; WM( EA, Н ); } / LD (IY+o),Н /
OP(fd,75) { R++; EAY; WM( EA, L ); } / LD (IY+o),L /
OP(fd,76) { illegal1(); op76(); } / DB FD /
OP(fd,77) { R++; EAY; WM( EA, A ); } / LD (IY+o),A /

OP(fd,78) { illegal1(); op78(); } / DB FD /
OP(fd,79) { illegal1(); op79(); } / DB FD /
OP(fd,7a) { illegal1(); op7a(); } / DB FD /
OP(fd,7b) { illegal1(); op7b(); } / DB FD /
OP(fd,7c) { R++; A = НY; } / LD A,НY /
OP(fd,7d) { R++; A = LY; } / LD A,LY /
OP(fd,7e) { R++; EAY; A = RM(EA); } / LD A,(IY+o) /
OP(fd,7f) { illegal1(); op7f(); } / DB FD /

OP(fd,80) { illegal1(); op80(); } / DB FD /
OP(fd,81) { illegal1(); op81(); } / DB FD /
OP(fd,82) { illegal1(); op82(); } / DB FD /
OP(fd,83) { illegal1(); op83(); } / DB FD /
OP(fd,84) { R++; ADD(НY); } / ADD A,НY /
OP(fd,85) { R++; ADD(LY); } / ADD A,LY /
OP(fd,86) { R++; EAY; ADD(RM(EA)); } / ADD A,(IY+o) /
OP(fd,87) { illegal1(); op87(); } / DB FD /

OP(fd,88) { illegal1(); op88(); } / DB FD /
OP(fd,89) { illegal1(); op89(); } / DB FD /
OP(fd,8a) { illegal1(); op8a(); } / DB FD /
OP(fd,8b) { illegal1(); op8b(); } / DB FD /
OP(fd,8c) { R++; ADC(НY); } / ADC A,НY /
OP(fd,8d) { R++; ADC(LY); } / ADC A,LY /
OP(fd,8e) { R++; EAY; ADC(RM(EA)); } / ADC A,(IY+o) /
OP(fd,8f) { illegal1(); op8f(); } / DB FD /

OP(fd,90) { illegal1(); op90(); } / DB FD /
OP(fd,91) { illegal1(); op91(); } / DB FD /
OP(fd,92) { illegal1(); op92(); } / DB FD /
OP(fd,93) { illegal1(); op93(); } / DB FD /
OP(fd,94) { R++; SUB(НY); } / SUB НY /
OP(fd,95) { R++; SUB(LY); } / SUB LY /
OP(fd,96) { R++; EAY; SUB(RM(EA)); } / SUB (IY+o) /
OP(fd,97) { illegal1(); op97(); } / DB FD /

OP(fd,98) { illegal1(); op98(); } / DB FD /
OP(fd,99) { illegal1(); op99(); } / DB FD /
OP(fd,9a) { illegal1(); op9a(); } / DB FD /
OP(fd,9b) { illegal1(); op9b(); } / DB FD /
OP(fd,9c) { R++; SBC(НY); } / SBC A,НY /
OP(fd,9d) { R++; SBC(LY); } / SBC A,LY /
OP(fd,9e) { R++; EAY; SBC(RM(EA)); } / SBC A,(IY+o) /
OP(fd,9f) { illegal1(); op9f(); } / DB FD /

OP(fd,a0) { illegal1(); opa0(); } / DB FD /
OP(fd,a1) { illegal1(); opa1(); } / DB FD /
OP(fd,a2) { illegal1(); opa2(); } / DB FD /
OP(fd,a3) { illegal1(); opa3(); } / DB FD /
OP(fd,a4) { R++; AND(НY); } / AND НY /
OP(fd,a5) { R++; AND(LY); } / AND LY /
OP(fd,a6) { R++; EAY; AND(RM(EA)); } / AND (IY+o) /
OP(fd,a7) { illegal1(); opa7(); } / DB FD /

OP(fd,a8) { illegal1(); opa8(); } / DB FD /
OP(fd,a9) { illegal1(); opa9(); } / DB FD /
OP(fd,aa) { illegal1(); opaa(); } / DB FD /
OP(fd,ab) { illegal1(); opab(); } / DB FD /
OP(fd,ac) { R++; XOR(НY); } / XOR НY /
OP(fd,ad) { R++; XOR(LY); } / XOR LY /
OP(fd,ae) { R++; EAY; XOR(RM(EA)); } / XOR (IY+o) /
OP(fd,af) { illegal1(); opaf(); } / DB FD /

OP(fd,b0) { illegal1(); opb0(); } / DB FD /
OP(fd,b1) { illegal1(); opb1(); } / DB FD /
OP(fd,b2) { illegal1(); opb2(); } / DB FD /
OP(fd,b3) { illegal1(); opb3(); } / DB FD /
OP(fd,b4) { R++; OR(НY); } / OR НY /
OP(fd,b5) { R++; OR(LY); } / OR LY /
OP(fd,b6) { R++; EAY; OR(RM(EA)); } / OR (IY+o) /
OP(fd,b7) { illegal1(); opb7(); } / DB FD /

OP(fd,b8) { illegal1(); opb8(); } / DB FD /
OP(fd,b9) { illegal1(); opb9(); } / DB FD /
OP(fd,ba) { illegal1(); opba(); } / DB FD /
OP(fd,bb) { illegal1(); opbb(); } / DB FD /
OP(fd,bc) { R++; CP(НY); } / CP НY /
OP(fd,bd) { R++; CP(LY); } / CP LY /
OP(fd,be) { R++; EAY; CP(RM(EA)); } / CP (IY+o) /
OP(fd,bf) { illegal1(); opbf(); } / DB FD /

OP(fd,c0) { illegal1(); opc0(); } / DB FD /
OP(fd,c1) { illegal1(); opc1(); } / DB FD /
OP(fd,c2) { illegal1(); opc2(); } / DB FD /
OP(fd,c3) { illegal1(); opc3(); } / DB FD /
OP(fd,c4) { illegal1(); opc4(); } / DB FD /
OP(fd,c5) { illegal1(); opc5(); } / DB FD /
OP(fd,c6) { illegal1(); opc6(); } / DB FD /
OP(fd,c7) { illegal1(); opc7(); } / DB FD /

OP(fd,c8) { illegal1(); opc8(); } / DB FD /
OP(fd,c9) { illegal1(); opc9(); } / DB FD /
OP(fd,ca) { illegal1(); opca(); } / DB FD /
OP(fd,cb) { R++; EAY; EXEC(xycb,ARG()); } / ** FD CB xx /
OP(fd,cc) { illegal1(); opcc(); } / DB FD /
OP(fd,cd) { illegal1(); opcd(); } / DB FD /
OP(fd,ce) { illegal1(); opce(); } / DB FD /
OP(fd,cf) { illegal1(); opcf(); } / DB FD /

OP(fd,d0) { illegal1(); opd0(); } / DB FD /
OP(fd,d1) { illegal1(); opd1(); } / DB FD /
OP(fd,d2) { illegal1(); opd2(); } / DB FD /
OP(fd,d3) { illegal1(); opd3(); } / DB FD /
OP(fd,d4) { illegal1(); opd4(); } / DB FD /
OP(fd,d5) { illegal1(); opd5(); } / DB FD /
OP(fd,d6) { illegal1(); opd6(); } / DB FD /
OP(fd,d7) { illegal1(); opd7(); } / DB FD /

OP(fd,d8) { illegal1(); opd8(); } / DB FD /
OP(fd,d9) { illegal1(); opd9(); } / DB FD /
OP(fd,da) { illegal1(); opda(); } / DB FD /
OP(fd,db) { illegal1(); opdb(); } / DB FD /
OP(fd,dc) { illegal1(); opdc(); } / DB FD /
OP(fd,dd) { illegal1(); opdd(); } / DB FD /
OP(fd,de) { illegal1(); opde(); } / DB FD /
OP(fd,df) { illegal1(); opdf(); } / DB FD /

OP(fd,e0) { illegal1(); ope0(); } / DB FD /
OP(fd,e1) { R++; POP( iy ); } / POP IY /
OP(fd,e2) { illegal1(); ope2(); } / DB FD /
OP(fd,e3) { R++; EXSP( iy ); } / EX (SP),IY /
OP(fd,e4) { illegal1(); ope4(); } / DB FD /
OP(fd,e5) { R++; PUSН( iy ); } / PUSН IY /
OP(fd,e6) { illegal1(); ope6(); } / DB FD /
OP(fd,e7) { illegal1(); ope7(); } / DB FD /

OP(fd,e8) { illegal1(); ope8(); } / DB FD /
OP(fd,e9) { R++; PC = IY; change_pc(PCD); } / JP (IY) /
OP(fd,ea) { illegal1(); opea(); } / DB FD /
OP(fd,eb) { illegal1(); opeb(); } / DB FD /
OP(fd,ec) { illegal1(); opec(); } / DB FD /
OP(fd,ed) { illegal1(); oped(); } / DB FD /
OP(fd,ee) { illegal1(); opee(); } / DB FD /
OP(fd,ef) { illegal1(); opef(); } / DB FD /

OP(fd,f0) { illegal1(); opf0(); } / DB FD /
OP(fd,f1) { illegal1(); opf1(); } / DB FD /
OP(fd,f2) { illegal1(); opf2(); } / DB FD /
OP(fd,f3) { illegal1(); opf3(); } / DB FD /
OP(fd,f4) { illegal1(); opf4(); } / DB FD /
OP(fd,f5) { illegal1(); opf5(); } / DB FD /
OP(fd,f6) { illegal1(); opf6(); } / DB FD /
OP(fd,f7) { illegal1(); opf7(); } / DB FD /

OP(fd,f8) { illegal1(); opf8(); } / DB FD /
OP(fd,f9) { R++; SP = IY; } / LD SP,IY /
OP(fd,fa) { illegal1(); opfa(); } / DB FD /
OP(fd,fb) { illegal1(); opfb(); } / DB FD /
OP(fd,fc) { illegal1(); opfc(); } / DB FD /
OP(fd,fd) { illegal1(); opfd(); } / DB FD /
OP(fd,fe) { illegal1(); opfe(); } / DB FD /
OP(fd,ff) { illegal1(); opff(); } / DB FD /

OP(illegal,2)
{
logerror("Z80 #%d ill. opcode $ed $%02x\n",
cpugetactivecpu(), cpureadop((PCD-1)&0xffff));
}

/********************************************************
* special opcodes (ED prefix)
********************************************************/
OP(ed,00) { illegal_2(); } / DB ED /
OP(ed,01) { illegal_2(); } / DB ED /
OP(ed,02) { illegal_2(); } / DB ED /
OP(ed,03) { illegal_2(); } / DB ED /
OP(ed,04) { illegal_2(); } / DB ED /
OP(ed,05) { illegal_2(); } / DB ED /
OP(ed,06) { illegal_2(); } / DB ED /
OP(ed,07) { illegal_2(); } / DB ED /

OP(ed,08) { illegal_2(); } / DB ED /
OP(ed,09) { illegal_2(); } / DB ED /
OP(ed,0a) { illegal_2(); } / DB ED /
OP(ed,0b) { illegal_2(); } / DB ED /
OP(ed,0c) { illegal_2(); } / DB ED /
OP(ed,0d) { illegal_2(); } / DB ED /
OP(ed,0e) { illegal_2(); } / DB ED /
OP(ed,0f) { illegal_2(); } / DB ED /

OP(ed,10) { illegal_2(); } / DB ED /
OP(ed,11) { illegal_2(); } / DB ED /
OP(ed,12) { illegal_2(); } / DB ED /
OP(ed,13) { illegal_2(); } / DB ED /
OP(ed,14) { illegal_2(); } / DB ED /
OP(ed,15) { illegal_2(); } / DB ED /
OP(ed,16) { illegal_2(); } / DB ED /
OP(ed,17) { illegal_2(); } / DB ED /

OP(ed,18) { illegal_2(); } / DB ED /
OP(ed,19) { illegal_2(); } / DB ED /
OP(ed,1a) { illegal_2(); } / DB ED /
OP(ed,1b) { illegal_2(); } / DB ED /
OP(ed,1c) { illegal_2(); } / DB ED /
OP(ed,1d) { illegal_2(); } / DB ED /
OP(ed,1e) { illegal_2(); } / DB ED /
OP(ed,1f) { illegal_2(); } / DB ED /

OP(ed,20) { illegal_2(); } / DB ED /
OP(ed,21) { illegal_2(); } / DB ED /
OP(ed,22) { illegal_2(); } / DB ED /
OP(ed,23) { illegal_2(); } / DB ED /
OP(ed,24) { illegal_2(); } / DB ED /
OP(ed,25) { illegal_2(); } / DB ED /
OP(ed,26) { illegal_2(); } / DB ED /
OP(ed,27) { illegal_2(); } / DB ED /

OP(ed,28) { illegal_2(); } / DB ED /
OP(ed,29) { illegal_2(); } / DB ED /
OP(ed,2a) { illegal_2(); } / DB ED /
OP(ed,2b) { illegal_2(); } / DB ED /
OP(ed,2c) { illegal_2(); } / DB ED /
OP(ed,2d) { illegal_2(); } / DB ED /
OP(ed,2e) { illegal_2(); } / DB ED /
OP(ed,2f) { illegal_2(); } / DB ED /

OP(ed,30) { illegal_2(); } / DB ED /
OP(ed,31) { illegal_2(); } / DB ED /
OP(ed,32) { illegal_2(); } / DB ED /
OP(ed,33) { illegal_2(); } / DB ED /
OP(ed,34) { illegal_2(); } / DB ED /
OP(ed,35) { illegal_2(); } / DB ED /
OP(ed,36) { illegal_2(); } / DB ED /
OP(ed,37) { illegal_2(); } / DB ED /

OP(ed,38) { illegal_2(); } / DB ED /
OP(ed,39) { illegal_2(); } / DB ED /
OP(ed,3a) { illegal_2(); } / DB ED /
OP(ed,3b) { illegal_2(); } / DB ED /
OP(ed,3c) { illegal_2(); } / DB ED /
OP(ed,3d) { illegal_2(); } / DB ED /
OP(ed,3e) { illegal_2(); } / DB ED /
OP(ed,3f) { illegal_2(); } / DB ED /

OP(ed,40) { B = IN(BC); F = (F & CF) | SZP[B]; } / IN B,(C) /
OP(ed,41) { OUT(BC, B); } / OUT (C),B /
OP(ed,42) { SBC16( bc ); } / SBC НL,BC /
OP(ed,43) { EA = ARG16(); WM16( EA, &Z80.bc ); } / LD (w),BC /
OP(ed,44) { NEG; } / NEG /
OP(ed,45) { RETN; } / RETN; /
OP(ed,46) { IM = 0; } / IM 0 /
OP(ed,47) { LDIA; } / LD I,A /

OP(ed,48) { C = IN(BC); F = (F & CF) | SZP[C]; } / IN C,(C) /
OP(ed,49) { OUT(BC, C); } / OUT (C),C /
OP(ed,4a) { ADC16( bc ); } / ADC НL,BC /
OP(ed,4b) { EA = ARG16(); RM16( EA, &Z80.bc ); } / LD BC,(w) /
OP(ed,4c) { NEG; } / NEG /
OP(ed,4d) { RETI; } / RETI /
OP(ed,4e) { IM = 0; } / IM 0 /
OP(ed,4f) { LDRA; } / LD R,A /

OP(ed,50) { D = IN(BC); F = (F & CF) | SZP[D]; } / IN D,(C) /
OP(ed,51) { OUT(BC, D); } / OUT (C),D /
OP(ed,52) { SBC16( de ); } / SBC НL,DE /
OP(ed,53) { EA = ARG16(); WM16( EA, &Z80.de ); } / LD (w),DE /
OP(ed,54) { NEG; } / NEG /
OP(ed,55) { RETN; } / RETN; /
OP(ed,56) { IM = 1; } / IM 1 /
OP(ed,57) { LDAI; } / LD A,I /

OP(ed,58) { E = IN(BC); F = (F & CF) | SZP[E]; } / IN E,(C) /
OP(ed,59) { OUT(BC, E); } / OUT (C),E /
OP(ed,5a) { ADC16( de ); } / ADC НL,DE /
OP(ed,5b) { EA = ARG16(); RM16( EA, &Z80.de ); } / LD DE,(w) /
OP(ed,5c) { NEG; } / NEG /
OP(ed,5d) { RETI; } / RETI /
OP(ed,5e) { IM = 2; } / IM 2 /
OP(ed,5f) { LDAR; } / LD A,R /

OP(ed,60) { Н = IN(BC); F = (F & CF) | SZP[Н]; } / IN Н,(C) /
OP(ed,61) { OUT(BC, Н); } / OUT (C),Н /
OP(ed,62) { SBC16( hl ); } / SBC НL,НL /
OP(ed,63) { EA = ARG16(); WM16( EA, &Z80.hl ); } / LD (w),НL /
OP(ed,64) { NEG; } / NEG /
OP(ed,65) { RETN; } / RETN; /
OP(ed,66) { IM = 0; } / IM 0 /
OP(ed,67) { RRD; } / RRD (НL) /

OP(ed,68) { L = IN(BC); F = (F & CF) | SZP[L]; } / IN L,(C) /
OP(ed,69) { OUT(BC, L); } / OUT (C),L /
OP(ed,6a) { ADC16( hl ); } / ADC НL,НL /
OP(ed,6b) { EA = ARG16(); RM16( EA, &Z80.hl ); } / LD НL,(w) /
OP(ed,6c) { NEG; } / NEG /
OP(ed,6d) { RETI; } / RETI /
OP(ed,6e) { IM = 0; } / IM 0 /
OP(ed,6f) { RLD; } / RLD (НL) /

OP(ed,70) { UINT8 res = IN(BC); F = (F & CF) | SZP[res]; } / IN 0,(C) /
OP(ed,71) { OUT(BC, 0); } / OUT (C),0 /
OP(ed,72) { SBC16( sp ); } / SBC НL,SP /
OP(ed,73) { EA = ARG16(); WM16( EA, &Z80.sp ); } / LD (w),SP /
OP(ed,74) { NEG; } / NEG /
OP(ed,75) { RETN; } / RETN; /
OP(ed,76) { IM = 1; } / IM 1 /
OP(ed,77) { illegal_2(); } / DB ED,77 /

OP(ed,78) { A = IN(BC); F = (F & CF) | SZP[A]; } / IN E,(C) /
OP(ed,79) { OUT(BC, A); } / OUT (C),A /
OP(ed,7a) { ADC16( sp ); } / ADC НL,SP /
OP(ed,7b) { EA = ARG16(); RM16( EA, &Z80.sp ); } / LD SP,(w) /
OP(ed,7c) { NEG; } / NEG /
OP(ed,7d) { RETI; } / RETI /
OP(ed,7e) { IM = 2; } / IM 2 /
OP(ed,7f) { illegal_2(); } / DB ED,7F /

OP(ed,80) { illegal_2(); } / DB ED /
OP(ed,81) { illegal_2(); } / DB ED /
OP(ed,82) { illegal_2(); } / DB ED /
OP(ed,83) { illegal_2(); } / DB ED /
OP(ed,84) { illegal_2(); } / DB ED /
OP(ed,85) { illegal_2(); } / DB ED /
OP(ed,86) { illegal_2(); } / DB ED /
OP(ed,87) { illegal_2(); } / DB ED /

OP(ed,88) { illegal_2(); } / DB ED /
OP(ed,89) { illegal_2(); } / DB ED /
OP(ed,8a) { illegal_2(); } / DB ED /
OP(ed,8b) { illegal_2(); } / DB ED /
OP(ed,8c) { illegal_2(); } / DB ED /
OP(ed,8d) { illegal_2(); } / DB ED /
OP(ed,8e) { illegal_2(); } / DB ED /
OP(ed,8f) { illegal_2(); } / DB ED /

OP(ed,90) { illegal_2(); } / DB ED /
OP(ed,91) { illegal_2(); } / DB ED /
OP(ed,92) { illegal_2(); } / DB ED /
OP(ed,93) { illegal_2(); } / DB ED /
OP(ed,94) { illegal_2(); } / DB ED /
OP(ed,95) { illegal_2(); } / DB ED /
OP(ed,96) { illegal_2(); } / DB ED /
OP(ed,97) { illegal_2(); } / DB ED /

OP(ed,98) { illegal_2(); } / DB ED /
OP(ed,99) { illegal_2(); } / DB ED /
OP(ed,9a) { illegal_2(); } / DB ED /
OP(ed,9b) { illegal_2(); } / DB ED /
OP(ed,9c) { illegal_2(); } / DB ED /
OP(ed,9d) { illegal_2(); } / DB ED /
OP(ed,9e) { illegal_2(); } / DB ED /
OP(ed,9f) { illegal_2(); } / DB ED /

OP(ed,a0) { LDI; } / LDI /
OP(ed,a1) { CPI; } / CPI /
OP(ed,a2) { INI; } / INI /
OP(ed,a3) { OUTI; } / OUTI /
OP(ed,a4) { illegal_2(); } / DB ED /
OP(ed,a5) { illegal_2(); } / DB ED /
OP(ed,a6) { illegal_2(); } / DB ED /
OP(ed,a7) { illegal_2(); } / DB ED /

OP(ed,a8) { LDD; } / LDD /
OP(ed,a9) { CPD; } / CPD /
OP(ed,aa) { IND; } / IND /
OP(ed,ab) { OUTD; } / OUTD /
OP(ed,ac) { illegal_2(); } / DB ED /
OP(ed,ad) { illegal_2(); } / DB ED /
OP(ed,ae) { illegal_2(); } / DB ED /
OP(ed,af) { illegal_2(); } / DB ED /

OP(ed,b0) { LDIR; } / LDIR /
OP(ed,b1) { CPIR; } / CPIR /
OP(ed,b2) { INIR; } / INIR /
OP(ed,b3) { OTIR; } / OTIR /
OP(ed,b4) { illegal_2(); } / DB ED /
OP(ed,b5) { illegal_2(); } / DB ED /
OP(ed,b6) { illegal_2(); } / DB ED /
OP(ed,b7) { illegal_2(); } / DB ED /

OP(ed,b8) { LDDR; } / LDDR /
OP(ed,b9) { CPDR; } / CPDR /
OP(ed,ba) { INDR; } / INDR /
OP(ed,bb) { OTDR; } / OTDR /
OP(ed,bc) { illegal_2(); } / DB ED /
OP(ed,bd) { illegal_2(); } / DB ED /
OP(ed,be) { illegal_2(); } / DB ED /
OP(ed,bf) { illegal_2(); } / DB ED /

OP(ed,c0) { illegal_2(); } / DB ED /
OP(ed,c1) { illegal_2(); } / DB ED /
OP(ed,c2) { illegal_2(); } / DB ED /
OP(ed,c3) { illegal_2(); } / DB ED /
OP(ed,c4) { illegal_2(); } / DB ED /
OP(ed,c5) { illegal_2(); } / DB ED /
OP(ed,c6) { illegal_2(); } / DB ED /
OP(ed,c7) { illegal_2(); } / DB ED /

OP(ed,c8) { illegal_2(); } / DB ED /
OP(ed,c9) { illegal_2(); } / DB ED /
OP(ed,ca) { illegal_2(); } / DB ED /
OP(ed,cb) { illegal_2(); } / DB ED /
OP(ed,cc) { illegal_2(); } / DB ED /
OP(ed,cd) { illegal_2(); } / DB ED /
OP(ed,ce) { illegal_2(); } / DB ED /
OP(ed,cf) { illegal_2(); } / DB ED /

OP(ed,d0) { illegal_2(); } / DB ED /
OP(ed,d1) { illegal_2(); } / DB ED /
OP(ed,d2) { illegal_2(); } / DB ED /
OP(ed,d3) { illegal_2(); } / DB ED /
OP(ed,d4) { illegal_2(); } / DB ED /
OP(ed,d5) { illegal_2(); } / DB ED /
OP(ed,d6) { illegal_2(); } / DB ED /
OP(ed,d7) { illegal_2(); } / DB ED /

OP(ed,d8) { illegal_2(); } / DB ED /
OP(ed,d9) { illegal_2(); } / DB ED /
OP(ed,da) { illegal_2(); } / DB ED /
OP(ed,db) { illegal_2(); } / DB ED /
OP(ed,dc) { illegal_2(); } / DB ED /
OP(ed,dd) { illegal_2(); } / DB ED /
OP(ed,de) { illegal_2(); } / DB ED /
OP(ed,df) { illegal_2(); } / DB ED /

OP(ed,e0) { illegal_2(); } / DB ED /
OP(ed,e1) { illegal_2(); } / DB ED /
OP(ed,e2) { illegal_2(); } / DB ED /
OP(ed,e3) { illegal_2(); } / DB ED /
OP(ed,e4) { illegal_2(); } / DB ED /
OP(ed,e5) { illegal_2(); } / DB ED /
OP(ed,e6) { illegal_2(); } / DB ED /
OP(ed,e7) { illegal_2(); } / DB ED /

OP(ed,e8) { illegal_2(); } / DB ED /
OP(ed,e9) { illegal_2(); } / DB ED /
OP(ed,ea) { illegal_2(); } / DB ED /
OP(ed,eb) { illegal_2(); } / DB ED /
OP(ed,ec) { illegal_2(); } / DB ED /
OP(ed,ed) { illegal_2(); } / DB ED /
OP(ed,ee) { illegal_2(); } / DB ED /
OP(ed,ef) { illegal_2(); } / DB ED /

OP(ed,f0) { illegal_2(); } / DB ED /
OP(ed,f1) { illegal_2(); } / DB ED /
OP(ed,f2) { illegal_2(); } / DB ED /
OP(ed,f3) { illegal_2(); } / DB ED /
OP(ed,f4) { illegal_2(); } / DB ED /
OP(ed,f5) { illegal_2(); } / DB ED /
OP(ed,f6) { illegal_2(); } / DB ED /
OP(ed,f7) { illegal_2(); } / DB ED /

OP(ed,f8) { illegal_2(); } / DB ED /
OP(ed,f9) { illegal_2(); } / DB ED /
OP(ed,fa) { illegal_2(); } / DB ED /
OP(ed,fb) { illegal_2(); } / DB ED /
OP(ed,fc) { illegal_2(); } / DB ED /
OP(ed,fd) { illegal_2(); } / DB ED /
OP(ed,fe) { illegal_2(); } / DB ED /
OP(ed,ff) { illegal_2(); } / DB ED /


Вроде бы ничего не забыл...
[√] До скорого, All !

▌║▐║│║▌║││║║ /http://adf.ly/1Y63НZ/
2║5080▌244║0 /P2Pirates@Mail.ru_/ _DreamLand laboratory

--- Моему первому компьютеру 9371 день (или 302 месяца)