use crate::*;
use std::ops::*;

pub struct Processor<D> {
    pub mem: Memory,
    pub wst: Stack,
    pub rst: Stack,
    pub dev: D,
    pub cycles: usize,
}

impl<D: DeviceBus> Processor<D> {
    pub fn new(device_bus: D) -> Self {
        Self {
            mem: Memory::new(),
            wst: Stack::new(),
            rst: Stack::new(),
            dev: device_bus,
            cycles: 0,
        }
    }

    pub fn load_program(&mut self, bytecode: &[u8]) {
        self.mem.load_program(bytecode);
    }

    pub fn evaluate(&mut self, num_cycles: usize) -> Option<Signal> {
        macro_rules! w_psh_8    { ($v:expr) => { self.wst.push_u8($v)  }; }
        macro_rules! r_psh_8    { ($v:expr) => { self.rst.push_u8($v)  }; }
        macro_rules! w_psh_16   { ($v:expr) => { self.wst.push_u16($v) }; }
        macro_rules! r_psh_16   { ($v:expr) => { self.rst.push_u16($v) }; }
        macro_rules! w_pop_8    { ($v:ident) => { let $v = self.wst.pop_u8();  }; }
        macro_rules! r_pop_8    { ($v:ident) => { let $v = self.rst.pop_u8();  }; }
        macro_rules! w_pop_16   { ($v:ident) => { let $v = self.wst.pop_u16(); }; }
        macro_rules! r_pop_16   { ($v:ident) => { let $v = self.rst.pop_u16(); }; }
        macro_rules! w_get_8    { ($v:ident) => { let $v = self.wst.get_u8();  }; }
        macro_rules! r_get_8    { ($v:ident) => { let $v = self.rst.get_u8();  }; }
        macro_rules! w_get_16   { ($v:ident) => { let $v = self.wst.get_u16(); }; }
        macro_rules! r_get_16   { ($v:ident) => { let $v = self.rst.get_u16(); }; }
        macro_rules! m_read_8   { ($a:expr) => { self.mem.read_u8($a)  }; }
        macro_rules! m_read_16  { ($a:expr) => { self.mem.read_u16($a) }; }
        macro_rules! m_lit_8    { ($l:ident) => { let $l = self.mem.read_u8_next();  }; }
        macro_rules! m_lit_16   { ($l:ident) => { let $l = self.mem.read_u16_next(); }; }
        macro_rules! m_write_8  { ($v:expr,$a:expr) => { self.mem.write_u8($v,$a);  }; }
        macro_rules! m_write_16 { ($v:expr,$a:expr) => { self.mem.write_u16($v,$a); }; }
        macro_rules! d_read_8   { ($p:expr) => { self.dev.read_u8($p)  }; }
        macro_rules! d_read_16  { ($p:expr) => { self.dev.read_u16($p) }; }
        macro_rules! d_write_8  { ($v:expr,$p:expr) => { let s = self.dev.write_u8( $v, $p); if s.is_some() { return s }; }; }
        macro_rules! d_write_16 { ($v:expr,$p:expr) => { let s = self.dev.write_u16($v, $p); if s.is_some() { return s }; }; }
        macro_rules! jump       { ($a:expr) => { self.mem.write_pc($a) }; }
        macro_rules! pc         { ()        => { self.mem.read_pc()    }; }
        macro_rules! truth      { ($x:expr) => { if $x {0xff} else {0x00} }; }
        macro_rules! nyb        { ($v:expr=>$h:ident,$l:ident) => { let $h=($v>>4); let $l=($v&0x0f); } }
        macro_rules! shf        { ($x:expr,$y:expr) => { { nyb!($y=>l,r); $x.checked_shr(r as u32).unwrap_or(0).checked_shl(l as u32).unwrap_or(0) } } ; }
        macro_rules! shc        { ($x:expr,$y:expr) => { { nyb!($y=>l,r); $x.rotate_right(r as u32).rotate_left(l as u32) } }; }

        for _ in 0..num_cycles {
            self.cycles += 1;

            match self.mem.read_u8_next() {
                /* HLT    */ 0x00 => { return Some(Signal::Halt); }
                /* JMP    */ 0x01 => { w_pop_16!(a); jump!(a); }
                /* JCN    */ 0x02 => { w_pop_16!(a); w_pop_8!(t); if t!=0 {jump!(a)}; }
                /* JCK    */ 0x03 => { w_pop_16!(a); w_get_8!(t); if t!=0 {jump!(a)}; }
                /* LDA    */ 0x04 => { w_pop_16!(a); w_psh_8!(m_read_8!(a)); }
                /* STA    */ 0x05 => { w_pop_16!(a); w_pop_8!(v); m_write_8!(v,a); }
                /* LDD    */ 0x06 => { w_pop_8!(p); w_psh_8!(d_read_8!(p)); }
                /* STD    */ 0x07 => { w_pop_8!(p); w_pop_8!(v); d_write_8!(v,p); }
                /* PSH    */ 0x08 => { r_pop_8!(x); w_psh_8!(x); }
                /* POP    */ 0x09 => { w_pop_8!(_x); }
                /* CPY    */ 0x0A => { r_get_8!(x); w_psh_8!(x); }
                /* SPL    */ 0x0B => { w_pop_8!(x); nyb!(x=>a,b); w_psh_8!(a); w_psh_8!(b); }
                /* DUP    */ 0x0C => { w_get_8!(x); w_psh_8!(x); }
                /* OVR    */ 0x0D => { w_pop_8!(y); w_get_8!(x); w_psh_8!(y); w_psh_8!(x); }
                /* SWP    */ 0x0E => { w_pop_8!(y); w_pop_8!(x); w_psh_8!(y); w_psh_8!(x); }
                /* ROT    */ 0x0F => { w_pop_8!(z); w_pop_8!(y); w_pop_8!(x); w_psh_8!(y); w_psh_8!(z); w_psh_8!(x); }
                /* ADD    */ 0x10 => { w_pop_8!(y); w_pop_8!(x); w_psh_8!(x.wrapping_add(y)); }
                /* SUB    */ 0x11 => { w_pop_8!(y); w_pop_8!(x); w_psh_8!(x.wrapping_sub(y)); }
                /* INC    */ 0x12 => { w_pop_8!(x); w_psh_8!(x.wrapping_add(1)); }
                /* DEC    */ 0x13 => { w_pop_8!(x); w_psh_8!(x.wrapping_sub(1)); }
                /* LTH    */ 0x14 => { w_pop_8!(y); w_pop_8!(x); w_psh_8!(truth!(x < y)); }
                /* GTH    */ 0x15 => { w_pop_8!(y); w_pop_8!(x); w_psh_8!(truth!(x > y)); }
                /* EQU    */ 0x16 => { w_pop_8!(y); w_pop_8!(x); w_psh_8!(truth!(x==y)); }
                /* NQK    */ 0x17 => { w_pop_8!(y); w_get_8!(x); w_psh_8!(y); w_psh_8!(truth!(x!=y)); }
                /* IOR    */ 0x18 => { w_pop_8!(y); w_pop_8!(x); w_psh_8!(x.bitor(y)); }
                /* XOR    */ 0x19 => { w_pop_8!(y); w_pop_8!(x); w_psh_8!(x.bitxor(y)); }
                /* AND    */ 0x1A => { w_pop_8!(y); w_pop_8!(x); w_psh_8!(x.bitand(y)); }
                /* NOT    */ 0x1B => { w_pop_8!(x); w_psh_8!(x.not()); }
                /* SHF    */ 0x1C => { w_pop_8!(y); w_pop_8!(x); w_psh_8!(shf!(x,y)); }
                /* SHC    */ 0x1D => { w_pop_8!(y); w_pop_8!(x); w_psh_8!(shc!(x,y)); }
                /* TAL    */ 0x1E => { w_pop_8!(x); w_psh_8!(x.count_ones() as u8); }
                /* REV    */ 0x1F => { w_pop_8!(x); w_psh_8!(x.reverse_bits()); }

                /* NOP    */ 0x20 => { }
                /* JMS    */ 0x21 => { w_pop_16!(a); r_psh_16!(pc!()); jump!(a); }
                /* JCS    */ 0x22 => { w_pop_16!(a); w_pop_8!(t); if t!=0 {r_psh_16!(pc!()); jump!(a)}; }
                /* JCK*   */ 0x23 => { w_pop_16!(a); w_get_16!(t); if t!=0 {jump!(a)}; }
                /* LDA*   */ 0x24 => { w_pop_16!(a); w_psh_16!(m_read_16!(a)); }
                /* STA*   */ 0x25 => { w_pop_16!(a); w_pop_16!(v); m_write_16!(v,a); }
                /* LDD*   */ 0x26 => { w_pop_8!(p); w_psh_16!(d_read_16!(p)); }
                /* STD*   */ 0x27 => { w_pop_8!(p); w_pop_16!(v); d_write_16!(v,p); }
                /* PSH*   */ 0x28 => { r_pop_16!(x); w_psh_16!(x); }
                /* POP*   */ 0x29 => { w_pop_16!(_x); }
                /* CPY*   */ 0x2A => { r_get_16!(x); w_psh_16!(x); }
                /* SPL*   */ 0x2B => { w_pop_8!(y); w_pop_8!(x); nyb!(x=>a,b); nyb!(y=>c,d); w_psh_8!(a); w_psh_8!(b); w_psh_8!(c); w_psh_8!(d); }
                /* DUP*   */ 0x2C => { w_get_16!(x); w_psh_16!(x); }
                /* OVR*   */ 0x2D => { w_pop_16!(y); w_get_16!(x); w_psh_16!(y); w_psh_16!(x); }
                /* SWP*   */ 0x2E => { w_pop_16!(y); w_pop_16!(x); w_psh_16!(y); w_psh_16!(x); }
                /* ROT*   */ 0x2F => { w_pop_16!(z); w_pop_16!(y); w_pop_16!(x); w_psh_16!(y); w_psh_16!(z); w_psh_16!(x); }
                /* ADD*   */ 0x30 => { w_pop_16!(y); w_pop_16!(x); w_psh_16!(x.wrapping_add(y)); }
                /* SUB*   */ 0x31 => { w_pop_16!(y); w_pop_16!(x); w_psh_16!(x.wrapping_sub(y)); }
                /* INC*   */ 0x32 => { w_pop_16!(x); w_psh_16!(x.wrapping_add(1)); }
                /* DEC*   */ 0x33 => { w_pop_16!(x); w_psh_16!(x.wrapping_sub(1)); }
                /* LTH*   */ 0x34 => { w_pop_16!(y); w_pop_16!(x); w_psh_8!(truth!(x < y)); }
                /* GTH*   */ 0x35 => { w_pop_16!(y); w_pop_16!(x); w_psh_8!(truth!(x > y)); }
                /* EQU*   */ 0x36 => { w_pop_16!(y); w_pop_16!(x); w_psh_8!(truth!(x==y)); }
                /* NQK*   */ 0x37 => { w_pop_16!(y); w_get_16!(x); w_psh_16!(y); w_psh_8!(truth!(x!=y)); }
                /* IOR*   */ 0x38 => { w_pop_16!(y); w_pop_16!(x); w_psh_16!(x.bitor(y)); }
                /* XOR*   */ 0x39 => { w_pop_16!(y); w_pop_16!(x); w_psh_16!(x.bitxor(y)); }
                /* AND*   */ 0x3A => { w_pop_16!(y); w_pop_16!(x); w_psh_16!(x.bitand(y)); }
                /* NOT*   */ 0x3B => { w_pop_16!(x); w_psh_16!(x.not()); }
                /* SHF*   */ 0x3C => { w_pop_8!(y); w_pop_16!(x); w_psh_16!(shf!(x,y)); }
                /* SHC*   */ 0x3D => { w_pop_8!(y); w_pop_16!(x); w_psh_16!(shc!(x,y)); }
                /* TAL*   */ 0x3E => { w_pop_16!(x); w_psh_8!(x.count_ones() as u8); }
                /* REV*   */ 0x3F => { w_pop_16!(x); w_psh_16!(x.reverse_bits()); }

                /* DB1    */ 0x40 => { return Some(Signal::Debug(DebugVariant::DB1)); }
                /* JMP:   */ 0x41 => { m_lit_16!(a); jump!(a); }
                /* JCN:   */ 0x42 => { m_lit_16!(a); w_pop_8!(t); if t!=0 {jump!(a)}; }
                /* JCK:   */ 0x43 => { m_lit_16!(a); w_get_8!(t); if t!=0 {jump!(a)}; }
                /* LDA:   */ 0x44 => { m_lit_16!(a); w_psh_8!(m_read_8!(a)); }
                /* STA:   */ 0x45 => { m_lit_16!(a); w_pop_8!(v); m_write_8!(v,a); }
                /* LDD:   */ 0x46 => { m_lit_8!(p); w_psh_8!(d_read_8!(p)); }
                /* STD:   */ 0x47 => { m_lit_8!(p); w_pop_8!(v); d_write_8!(v,p); }
                /* PSH:   */ 0x48 => { m_lit_8!(x); w_psh_8!(x); }
                /* POP:   */ 0x49 => { m_lit_8!(_x); }
                /* CPY:   */ 0x4A => { m_lit_8!(x); w_psh_8!(x); r_psh_8!(x); }
                /* SPL:   */ 0x4B => { m_lit_8!(x); nyb!(x=>a,b); w_psh_8!(a); w_psh_8!(b); }
                /* DUP:   */ 0x4C => { m_lit_8!(x); w_psh_8!(x); w_psh_8!(x); }
                /* OVR:   */ 0x4D => { m_lit_8!(y); w_get_8!(x); w_psh_8!(y); w_psh_8!(x); }
                /* SWP:   */ 0x4E => { m_lit_8!(y); w_pop_8!(x); w_psh_8!(y); w_psh_8!(x); }
                /* ROT:   */ 0x4F => { m_lit_8!(z); w_pop_8!(y); w_pop_8!(x); w_psh_8!(y); w_psh_8!(z); w_psh_8!(x); }
                /* ADD:   */ 0x50 => { m_lit_8!(y); w_pop_8!(x); w_psh_8!(x.wrapping_add(y)); }
                /* SUB:   */ 0x51 => { m_lit_8!(y); w_pop_8!(x); w_psh_8!(x.wrapping_sub(y)); }
                /* INC:   */ 0x52 => { m_lit_8!(x); w_psh_8!(x.wrapping_add(1)); }
                /* DEC:   */ 0x53 => { m_lit_8!(x); w_psh_8!(x.wrapping_sub(1)); }
                /* LTH:   */ 0x54 => { m_lit_8!(y); w_pop_8!(x); w_psh_8!(truth!(x < y)); }
                /* GTH:   */ 0x55 => { m_lit_8!(y); w_pop_8!(x); w_psh_8!(truth!(x > y)); }
                /* EQU:   */ 0x56 => { m_lit_8!(y); w_pop_8!(x); w_psh_8!(truth!(x==y)); }
                /* NQK:   */ 0x57 => { m_lit_8!(y); w_get_8!(x); w_psh_8!(y); w_psh_8!(truth!(x!=y)); }
                /* IOR:   */ 0x58 => { m_lit_8!(y); w_pop_8!(x); w_psh_8!(x.bitor(y)); }
                /* XOR:   */ 0x59 => { m_lit_8!(y); w_pop_8!(x); w_psh_8!(x.bitxor(y)); }
                /* AND:   */ 0x5A => { m_lit_8!(y); w_pop_8!(x); w_psh_8!(x.bitand(y)); }
                /* NOT:   */ 0x5B => { m_lit_8!(x); w_psh_8!(x.not()); }
                /* SHF:   */ 0x5C => { m_lit_8!(y); w_pop_8!(x); w_psh_8!(shf!(x,y)); }
                /* SHC:   */ 0x5D => { m_lit_8!(y); w_pop_8!(x); w_psh_8!(shc!(x,y)); }
                /* TAL:   */ 0x5E => { m_lit_8!(x); w_psh_8!(x.count_ones() as u8); }
                /* REV:   */ 0x5F => { m_lit_8!(x); w_psh_8!(x.reverse_bits()); }

                /* DB2    */ 0x60 => { return Some(Signal::Debug(DebugVariant::DB2)); }
                /* JMS:   */ 0x61 => { m_lit_16!(a); r_psh_16!(pc!()); jump!(a); }
                /* JCS:   */ 0x62 => { m_lit_16!(a); w_pop_8!(t); if t!=0 {r_psh_16!(pc!()); jump!(a)}; }
                /* JCK*:  */ 0x63 => { m_lit_16!(a); w_get_16!(t); if t!=0 {jump!(a)}; }
                /* LDA*:  */ 0x64 => { m_lit_16!(a); w_psh_16!(m_read_16!(a)); }
                /* STA*:  */ 0x65 => { m_lit_16!(a); w_pop_16!(v); m_write_16!(v,a); }
                /* LDD*:  */ 0x66 => { m_lit_8!(p); w_psh_16!(d_read_16!(p)); }
                /* STD*:  */ 0x67 => { m_lit_8!(p); w_pop_16!(v); d_write_16!(v,p); }
                /* PSH*:  */ 0x68 => { m_lit_16!(x); w_psh_16!(x); }
                /* POP*:  */ 0x69 => { m_lit_16!(_x); }
                /* CPY*:  */ 0x6A => { m_lit_16!(x); w_psh_16!(x); r_psh_16!(x); }
                /* SPL*:  */ 0x6B => { m_lit_8!(x); m_lit_8!(y); nyb!(x=>a,b); nyb!(y=>c,d); w_psh_8!(a); w_psh_8!(b); w_psh_8!(c); w_psh_8!(d); }
                /* DUP*:  */ 0x6C => { m_lit_16!(x); w_psh_16!(x); w_psh_16!(x); }
                /* OVR*:  */ 0x6D => { m_lit_16!(y); w_get_16!(x); w_psh_16!(y); w_psh_16!(x); }
                /* SWP*:  */ 0x6E => { m_lit_16!(y); w_pop_16!(x); w_psh_16!(y); w_psh_16!(x); }
                /* ROT*:  */ 0x6F => { m_lit_16!(z); w_pop_16!(y); w_pop_16!(x); w_psh_16!(y); w_psh_16!(z); w_psh_16!(x); }
                /* ADD*:  */ 0x70 => { m_lit_16!(y); w_pop_16!(x); w_psh_16!(x.wrapping_add(y)); }
                /* SUB*:  */ 0x71 => { m_lit_16!(y); w_pop_16!(x); w_psh_16!(x.wrapping_sub(y)); }
                /* INC*:  */ 0x72 => { m_lit_16!(x); w_psh_16!(x.wrapping_add(1)); }
                /* DEC*:  */ 0x73 => { m_lit_16!(x); w_psh_16!(x.wrapping_sub(1)); }
                /* LTH*:  */ 0x74 => { m_lit_16!(y); w_pop_16!(x); w_psh_8!(truth!(x < y)); }
                /* GTH*:  */ 0x75 => { m_lit_16!(y); w_pop_16!(x); w_psh_8!(truth!(x > y)); }
                /* EQU*:  */ 0x76 => { m_lit_16!(y); w_pop_16!(x); w_psh_8!(truth!(x==y)); }
                /* NQK*:  */ 0x77 => { m_lit_16!(y); w_get_16!(x); w_psh_16!(y); w_psh_8!(truth!(x!=y)); }
                /* IOR*:  */ 0x78 => { m_lit_16!(y); w_pop_16!(x); w_psh_16!(x.bitor(y)); }
                /* XOR*:  */ 0x79 => { m_lit_16!(y); w_pop_16!(x); w_psh_16!(x.bitxor(y)); }
                /* AND*:  */ 0x7A => { m_lit_16!(y); w_pop_16!(x); w_psh_16!(x.bitand(y)); }
                /* NOT*:  */ 0x7B => { m_lit_16!(x); w_psh_16!(x.not()); }
                /* SHF*:  */ 0x7C => { m_lit_8!(y); w_pop_16!(x); w_psh_16!(shf!(x,y)); }
                /* SHC*:  */ 0x7D => { m_lit_8!(y); w_pop_16!(x); w_psh_16!(shc!(x,y)); }
                /* TAL*:  */ 0x7E => { m_lit_16!(x); w_psh_8!(x.count_ones() as u8); }
                /* REV*:  */ 0x7F => { m_lit_16!(x); w_psh_16!(x.reverse_bits()); }

                /* DB3    */ 0x80 => { return Some(Signal::Debug(DebugVariant::DB3)); }
                /* JMPr   */ 0x81 => { r_pop_16!(a); jump!(a); }
                /* JCNr   */ 0x82 => { r_pop_16!(a); r_pop_8!(t); if t!=0 {jump!(a)}; }
                /* JCKr   */ 0x83 => { r_pop_16!(a); r_get_8!(t); if t!=0 {jump!(a)}; }
                /* LDAr   */ 0x84 => { r_pop_16!(a); r_psh_8!(m_read_8!(a)); }
                /* STAr   */ 0x85 => { r_pop_16!(a); r_pop_8!(v); m_write_8!(v,a); }
                /* LDDr   */ 0x86 => { r_pop_8!(p); r_psh_8!(d_read_8!(p)); }
                /* STDr   */ 0x87 => { r_pop_8!(p); r_pop_8!(v); d_write_8!(v,p); }
                /* PSHr   */ 0x88 => { w_pop_8!(x); r_psh_8!(x); }
                /* POPr   */ 0x89 => { r_pop_8!(_x); }
                /* CPYr   */ 0x8A => { w_get_8!(x); r_psh_8!(x); }
                /* SPLr   */ 0x8B => { r_pop_8!(x); nyb!(x=>a,b); r_psh_8!(a); r_psh_8!(b); }
                /* DUPr   */ 0x8C => { r_get_8!(x); r_psh_8!(x); }
                /* OVRr   */ 0x8D => { r_pop_8!(y); r_get_8!(x); r_psh_8!(y); r_psh_8!(x); }
                /* SWPr   */ 0x8E => { r_pop_8!(y); r_pop_8!(x); r_psh_8!(y); r_psh_8!(x); }
                /* ROTr   */ 0x8F => { r_pop_8!(z); r_pop_8!(y); r_pop_8!(x); r_psh_8!(y); r_psh_8!(z); r_psh_8!(x); }
                /* ADDr   */ 0x90 => { r_pop_8!(y); r_pop_8!(x); r_psh_8!(x.wrapping_add(y)); }
                /* SUBr   */ 0x91 => { r_pop_8!(y); r_pop_8!(x); r_psh_8!(x.wrapping_sub(y)); }
                /* INCr   */ 0x92 => { r_pop_8!(x); r_psh_8!(x.wrapping_add(1)); }
                /* DECr   */ 0x93 => { r_pop_8!(x); r_psh_8!(x.wrapping_sub(1)); }
                /* LTHr   */ 0x94 => { r_pop_8!(y); r_pop_8!(x); r_psh_8!(truth!(x < y)); }
                /* GTHr   */ 0x95 => { r_pop_8!(y); r_pop_8!(x); r_psh_8!(truth!(x > y)); }
                /* EQUr   */ 0x96 => { r_pop_8!(y); r_pop_8!(x); r_psh_8!(truth!(x==y)); }
                /* NQKr   */ 0x97 => { r_pop_8!(y); r_get_8!(x); r_psh_8!(y); r_psh_8!(truth!(x!=y)); }
                /* IORr   */ 0x98 => { r_pop_8!(y); r_pop_8!(x); r_psh_8!(x.bitor(y)); }
                /* XORr   */ 0x99 => { r_pop_8!(y); r_pop_8!(x); r_psh_8!(x.bitxor(y)); }
                /* ANDr   */ 0x9A => { r_pop_8!(y); r_pop_8!(x); r_psh_8!(x.bitand(y)); }
                /* NOTr   */ 0x9B => { r_pop_8!(x); r_psh_8!(x.not()); }
                /* SHFr   */ 0x9C => { r_pop_8!(y); r_pop_8!(x); r_psh_8!(shf!(x,y)); }
                /* SHCr   */ 0x9D => { r_pop_8!(y); r_pop_8!(x); r_psh_8!(shc!(x,y)); }
                /* TALr   */ 0x9E => { r_pop_8!(x); r_psh_8!(x.count_ones() as u8); }
                /* REVr   */ 0x9F => { r_pop_8!(x); r_psh_8!(x.reverse_bits()); }

                /* DB4    */ 0xA0 => { return Some(Signal::Debug(DebugVariant::DB4)); }
                /* JMSr   */ 0xA1 => { r_pop_16!(a); w_psh_16!(pc!()); jump!(a); }
                /* JCSr   */ 0xA2 => { r_pop_16!(a); r_pop_8!(t); if t!=0 {w_psh_16!(pc!()); jump!(a)}; }
                /* JCKr*  */ 0xA3 => { r_pop_16!(a); r_get_16!(t); if t!=0 {jump!(a)}; }
                /* LDAr*  */ 0xA4 => { r_pop_16!(a); r_psh_16!(m_read_16!(a)); }
                /* STAr*  */ 0xA5 => { r_pop_16!(a); r_pop_16!(v); m_write_16!(v,a); }
                /* LDDr*  */ 0xA6 => { r_pop_8!(p); r_psh_16!(d_read_16!(p)); }
                /* STDr*  */ 0xA7 => { r_pop_8!(p); r_pop_16!(v); d_write_16!(v,p); }
                /* PSHr*  */ 0xA8 => { w_pop_16!(x); r_psh_16!(x); }
                /* POPr*  */ 0xA9 => { r_pop_16!(_x); }
                /* CPYr*  */ 0xAA => { w_get_16!(x); r_psh_16!(x); }
                /* SPLr*  */ 0xAB => { r_pop_8!(y); r_pop_8!(x); nyb!(x=>a,b); nyb!(y=>c,d); r_psh_8!(a); r_psh_8!(b); r_psh_8!(c); r_psh_8!(d); }
                /* DUPr*  */ 0xAC => { r_get_16!(x); r_psh_16!(x); }
                /* OVRr*  */ 0xAD => { r_pop_16!(y); r_get_16!(x); r_psh_16!(y); r_psh_16!(x); }
                /* SWPr*  */ 0xAE => { r_pop_16!(y); r_pop_16!(x); r_psh_16!(y); r_psh_16!(x); }
                /* ROTr*  */ 0xAF => { r_pop_16!(z); r_pop_16!(y); r_pop_16!(x); r_psh_16!(y); r_psh_16!(z); r_psh_16!(x); }
                /* ADDr*  */ 0xB0 => { r_pop_16!(y); r_pop_16!(x); r_psh_16!(x.wrapping_add(y)); }
                /* SUBr*  */ 0xB1 => { r_pop_16!(y); r_pop_16!(x); r_psh_16!(x.wrapping_sub(y)); }
                /* INCr*  */ 0xB2 => { r_pop_16!(x); r_psh_16!(x.wrapping_add(1)); }
                /* DECr*  */ 0xB3 => { r_pop_16!(x); r_psh_16!(x.wrapping_sub(1)); }
                /* LTHr*  */ 0xB4 => { r_pop_16!(y); r_pop_16!(x); r_psh_8!(truth!(x < y)); }
                /* GTHr*  */ 0xB5 => { r_pop_16!(y); r_pop_16!(x); r_psh_8!(truth!(x > y)); }
                /* EQUr*  */ 0xB6 => { r_pop_16!(y); r_pop_16!(x); r_psh_8!(truth!(x==y)); }
                /* NQKr*  */ 0xB7 => { r_pop_16!(y); r_get_16!(x); r_psh_16!(y); r_psh_8!(truth!(x!=y)); }
                /* IORr*  */ 0xB8 => { r_pop_16!(y); r_pop_16!(x); r_psh_16!(x.bitor(y)); }
                /* XORr*  */ 0xB9 => { r_pop_16!(y); r_pop_16!(x); r_psh_16!(x.bitxor(y)); }
                /* ANDr*  */ 0xBA => { r_pop_16!(y); r_pop_16!(x); r_psh_16!(x.bitand(y)); }
                /* NOTr*  */ 0xBB => { r_pop_16!(x); r_psh_16!(x.not()); }
                /* SHFr*  */ 0xBC => { r_pop_8!(y); r_pop_16!(x); r_psh_16!(shf!(x,y)); }
                /* SHCr*  */ 0xBD => { r_pop_8!(y); r_pop_16!(x); r_psh_16!(shc!(x,y)); }
                /* TALr*  */ 0xBE => { r_pop_16!(x); r_psh_8!(x.count_ones() as u8); }
                /* REV*   */ 0xBF => { r_pop_16!(x); r_psh_16!(x.reverse_bits()); }

                /* DB5    */ 0xC0 => { return Some(Signal::Debug(DebugVariant::DB5)); }
                /* JMPr:  */ 0xC1 => { m_lit_16!(a); jump!(a); }
                /* JCNr:  */ 0xC2 => { m_lit_16!(a); r_pop_8!(t); if t!=0 {jump!(a)}; }
                /* JCKr:  */ 0xC3 => { m_lit_16!(a); r_get_8!(t); if t!=0 {jump!(a)}; }
                /* LDAr:  */ 0xC4 => { m_lit_16!(a); r_psh_8!(m_read_8!(a)); }
                /* STAr:  */ 0xC5 => { m_lit_16!(a); r_pop_8!(v); m_write_8!(v,a); }
                /* LDDr:  */ 0xC6 => { m_lit_8!(p); r_psh_8!(d_read_8!(p)); }
                /* STDr:  */ 0xC7 => { m_lit_8!(p); r_pop_8!(v); d_write_8!(v,p); }
                /* PSHr:  */ 0xC8 => { m_lit_8!(x); r_psh_8!(x); }
                /* POPr:  */ 0xC9 => { m_lit_8!(_x); }
                /* CPYr:  */ 0xCA => { m_lit_8!(x); w_psh_8!(x); r_psh_8!(x); }
                /* SPLr:  */ 0xCB => { m_lit_8!(x); nyb!(x=>a,b); r_psh_8!(a); r_psh_8!(b); }
                /* DUPr:  */ 0xCC => { m_lit_8!(x); r_psh_8!(x); r_psh_8!(x); }
                /* OVRr:  */ 0xCD => { m_lit_8!(y); r_get_8!(x); r_psh_8!(y); r_psh_8!(x); }
                /* SWPr:  */ 0xCE => { m_lit_8!(y); r_pop_8!(x); r_psh_8!(y); r_psh_8!(x); }
                /* ROTr:  */ 0xCF => { m_lit_8!(z); r_pop_8!(y); r_pop_8!(x); r_psh_8!(y); r_psh_8!(z); r_psh_8!(x); }
                /* ADDr:  */ 0xD0 => { m_lit_8!(y); r_pop_8!(x); r_psh_8!(x.wrapping_add(y)); }
                /* SUBr:  */ 0xD1 => { m_lit_8!(y); r_pop_8!(x); r_psh_8!(x.wrapping_sub(y)); }
                /* INCr:  */ 0xD2 => { m_lit_8!(x); r_psh_8!(x.wrapping_add(1)); }
                /* DECr:  */ 0xD3 => { m_lit_8!(x); r_psh_8!(x.wrapping_sub(1)); }
                /* LTHr:  */ 0xD4 => { m_lit_8!(y); r_pop_8!(x); r_psh_8!(truth!(x < y)); }
                /* GTHr:  */ 0xD5 => { m_lit_8!(y); r_pop_8!(x); r_psh_8!(truth!(x > y)); }
                /* EQUr:  */ 0xD6 => { m_lit_8!(y); r_pop_8!(x); r_psh_8!(truth!(x==y)); }
                /* NQKr:  */ 0xD7 => { m_lit_8!(y); r_get_8!(x); r_psh_8!(y); r_psh_8!(truth!(x!=y)); }
                /* IORr:  */ 0xD8 => { m_lit_8!(y); r_pop_8!(x); r_psh_8!(x.bitor(y)); }
                /* XORr:  */ 0xD9 => { m_lit_8!(y); r_pop_8!(x); r_psh_8!(x.bitxor(y)); }
                /* ANDr:  */ 0xDA => { m_lit_8!(y); r_pop_8!(x); r_psh_8!(x.bitand(y)); }
                /* NOTr:  */ 0xDB => { m_lit_8!(x); r_psh_8!(x.not()); }
                /* SHFr:  */ 0xDC => { m_lit_8!(y); r_pop_8!(x); r_psh_8!(shf!(x,y)); }
                /* SHCr:  */ 0xDD => { m_lit_8!(y); r_pop_8!(x); r_psh_8!(shc!(x,y)); }
                /* TALr:  */ 0xDE => { m_lit_8!(x); r_psh_8!(x.count_ones() as u8); }
                /* REVr:  */ 0xDF => { m_lit_8!(x); r_psh_8!(x.reverse_bits()); }

                /* DB6    */ 0xE0 => { return Some(Signal::Debug(DebugVariant::DB6)); }
                /* JMSr:  */ 0xE1 => { m_lit_16!(a); w_psh_16!(pc!()); jump!(a); }
                /* JCSr:  */ 0xE2 => { m_lit_16!(a); r_pop_8!(t); if t!=0 {w_psh_16!(pc!()); jump!(a)}; }
                /* JCKr*: */ 0xE3 => { m_lit_16!(a); r_get_16!(t); if t!=0 {jump!(a)}; }
                /* LDAr*: */ 0xE4 => { m_lit_16!(a); r_psh_16!(m_read_16!(a)); }
                /* STAr*: */ 0xE5 => { m_lit_16!(a); r_pop_16!(v); m_write_16!(v,a); }
                /* LDDr*: */ 0xE6 => { m_lit_8!(p); r_psh_16!(d_read_16!(p)); }
                /* STDr*: */ 0xE7 => { m_lit_8!(p); r_pop_16!(v); d_write_16!(v,p); }
                /* PSHr*: */ 0xE8 => { m_lit_16!(x); r_psh_16!(x); }
                /* POPr*: */ 0xE9 => { m_lit_16!(_x); }
                /* CPYr*: */ 0xEA => { m_lit_16!(x); w_psh_16!(x); r_psh_16!(x); }
                /* SPLr*: */ 0xEB => { m_lit_8!(x); m_lit_8!(y); nyb!(x=>a,b); nyb!(y=>c,d); r_psh_8!(a); r_psh_8!(b); r_psh_8!(c); r_psh_8!(d); }
                /* DUPr*: */ 0xEC => { m_lit_16!(x); r_psh_16!(x); r_psh_16!(x); }
                /* OVRr*: */ 0xED => { m_lit_16!(y); r_get_16!(x); r_psh_16!(y); r_psh_16!(x); }
                /* SWPr*: */ 0xEE => { m_lit_16!(y); r_pop_16!(x); r_psh_16!(y); r_psh_16!(x); }
                /* ROTr*: */ 0xEF => { m_lit_16!(z); r_pop_16!(y); r_pop_16!(x); r_psh_16!(y); r_psh_16!(z); r_psh_16!(x); }
                /* ADDr*: */ 0xF0 => { m_lit_16!(y); r_pop_16!(x); r_psh_16!(x.wrapping_add(y)); }
                /* SUBr*: */ 0xF1 => { m_lit_16!(y); r_pop_16!(x); r_psh_16!(x.wrapping_sub(y)); }
                /* INCr*: */ 0xF2 => { m_lit_16!(x); r_psh_16!(x.wrapping_add(1)); }
                /* DECr*: */ 0xF3 => { m_lit_16!(x); r_psh_16!(x.wrapping_sub(1)); }
                /* LTHr*: */ 0xF4 => { m_lit_16!(y); r_pop_16!(x); r_psh_8!(truth!(x < y)); }
                /* GTHr*: */ 0xF5 => { m_lit_16!(y); r_pop_16!(x); r_psh_8!(truth!(x > y)); }
                /* EQUr*: */ 0xF6 => { m_lit_16!(y); r_pop_16!(x); r_psh_8!(truth!(x==y)); }
                /* NQKr*: */ 0xF7 => { m_lit_16!(y); r_get_16!(x); r_psh_16!(y); r_psh_8!(truth!(x!=y)); }
                /* IORr*: */ 0xF8 => { m_lit_16!(y); r_pop_16!(x); r_psh_16!(x.bitor(y)); }
                /* XORr*: */ 0xF9 => { m_lit_16!(y); r_pop_16!(x); r_psh_16!(x.bitxor(y)); }
                /* ANDr*: */ 0xFA => { m_lit_16!(y); r_pop_16!(x); r_psh_16!(x.bitand(y)); }
                /* NOTr*: */ 0xFB => { m_lit_16!(x); r_psh_16!(x.not()); }
                /* SHFr*: */ 0xFC => { m_lit_8!(y); r_pop_16!(x); r_psh_16!(shf!(x,y)); }
                /* SHCr*: */ 0xFD => { m_lit_8!(y); r_pop_16!(x); r_psh_16!(shc!(x,y)); }
                /* TALr*: */ 0xFE => { m_lit_16!(x); r_psh_8!(x.count_ones() as u8); }
                /* REVr*: */ 0xFF => { m_lit_16!(x); r_psh_16!(x.reverse_bits()); }
            }
        }

        return None;
    }
}