/*
 *      Interactive disassembler (IDA).
 *      Copyright (c) 1990-2000 by Ilfak Guilfanov.
 *      ALL RIGHTS RESERVED.
 *                              E-mail: ig@datarescue.com
 *
 */

#include "st7.hpp"

//--------------------------------------------------------------------------
static const uchar primary[256] =
{
  ST7_btjt,  // btjt short, #0, brl   ; 5 3    00 XX XX
  ST7_btjf,  // btjf short, #0, brl   ; 5 3    01 XX XX
  ST7_btjt,  // btjt short, #1, brl   ; 5 3    02 XX XX
  ST7_btjf,  // btjf short, #1, brl   ; 5 3    03 XX XX
  ST7_btjt,  // btjt short, #2, brl   ; 5 3    04 XX XX
  ST7_btjf,  // btjf short, #2, brl   ; 5 3    05 XX XX
  ST7_btjt,  // btjt short, #3, brl   ; 5 3    06 XX XX
  ST7_btjf,  // btjf short, #3, brl   ; 5 3    07 XX XX
  ST7_btjt,  // btjt short, #4, brl   ; 5 3    08 XX XX
  ST7_btjf,  // btjf short, #4, brl   ; 5 3    09 XX XX
  ST7_btjt,  // btjt short, #5, brl   ; 5 3    0A XX XX
  ST7_btjf,  // btjf short, #5, brl   ; 5 3    0B XX XX
  ST7_btjt,  // btjt short, #6, brl   ; 5 3    0C XX XX
  ST7_btjf,  // btjf short, #6, brl   ; 5 3    0D XX XX
  ST7_btjt,  // btjt short, #7, brl   ; 5 3    0E XX XX
  ST7_btjf,  // btjf short, #7, brl   ; 5 3    0F XX XX
  ST7_bset,  // bset short, #0        ; 5 2    10 XX
  ST7_bres,  // bres short, #0        ; 5 2    11 XX
  ST7_bset,  // bset short, #1        ; 5 2    12 XX
  ST7_bres,  // bres short, #1        ; 5 2    13 XX
  ST7_bset,  // bset short, #2        ; 5 2    14 XX
  ST7_bres,  // bres short, #2        ; 5 2    15 XX
  ST7_bset,  // bset short, #3        ; 5 2    16 XX
  ST7_bres,  // bres short, #3        ; 5 2    17 XX
  ST7_bset,  // bset short, #4        ; 5 2    18 XX
  ST7_bres,  // bres short, #4        ; 5 2    19 XX
  ST7_bset,  // bset short, #5        ; 5 2    1A XX
  ST7_bres,  // bres short, #5        ; 5 2    1B XX
  ST7_bset,  // bset short, #6        ; 5 2    1C XX
  ST7_bres,  // bres short, #6        ; 5 2    1D XX
  ST7_bset,  // bset short, #7        ; 5 2    1E XX
  ST7_bres,  // bres short, #7        ; 5 2    1F XX
  ST7_jra,   // jra   rel             ; 3 2    20 XX
  ST7_jrf,   // jrf   rel             ; 3 2    21 XX
  ST7_jrugt, // jrugt rel             ; 3 2    22 XX
  ST7_jrule, // jrule rel             ; 3 2    23 XX
  ST7_jrnc,  // jrnc  rel             ; 3 2    24 XX
  ST7_jrc,   // jrc   rel             ; 3 2    25 XX
  ST7_jrne,  // jrne  rel             ; 3 2    26 XX
  ST7_jreq,  // jreq  rel             ; 3 2    27 XX
  ST7_jrnh,  // jrnh  rel             ; 3 2    28 XX
  ST7_jrh,   // jrh   rel             ; 3 2    29 XX
  ST7_jrpl,  // jrpl  rel             ; 3 2    2A XX
  ST7_jrmi,  // jrmi  rel             ; 3 2    2B XX
  ST7_jrnm,  // jrnm  rel             ; 3 2    2C XX
  ST7_jrm,   // jrm   rel             ; 3 2    2D XX
  ST7_jril,  // jril  rel             ; 3 2    2E XX
  ST7_jrih,  // jrih  rel             ; 3 2    2F XX
  ST7_neg,   // neg short             ; 5 2    30 XX
  ST7_null,  //                                31
  ST7_null,  //                                32
  ST7_cpl,   // cpl short             ; 5 2    33 XX
  ST7_srl,   // srl short             ; 5 2    34 XX
  ST7_null,  //                                35
  ST7_rrc,   // rrc short             ; 5 2    36 XX
  ST7_sra,   // sra short             ; 5 2    37 XX
  ST7_sll,   // sll short             ; 5 2    38 XX
  ST7_rlc,   // rlc short             ; 5 2    39 XX
  ST7_dec,   // dec short             ; 5 2    3A XX
  ST7_null,  //                                3B
  ST7_inc,   // inc short             ; 5 2    3C XX
  ST7_tnz,   // tnz short             ; 4 2    3D XX
  ST7_swap,  // swap short            ; 5 2    3E XX
  ST7_clr,   // clr short             ; 5 2    3F XX
  ST7_neg,   // neg a                 ; 3 1    40
  ST7_null,  //                                41
  ST7_mul,   // mul x, a              ;11 1    42
  ST7_cpl,   // cpl a                 ; 3 1    43
  ST7_srl,   // srl a                 ; 3 1    44
  ST7_null,  //                                45
  ST7_rrc,   // rrc a                 ; 3 1    46
  ST7_sra,   // sra a                 ; 3 1    47
  ST7_sll,   // sll a                 ; 3 1    48
  ST7_rlc,   // rlc a                 ; 3 1    49
  ST7_dec,   // dec a                 ; 3 1    4A
  ST7_null,  //                                4B
  ST7_inc,   // inc a                 ; 3 1    4C
  ST7_tnz,   // tnz a                 ; 3 1    4D
  ST7_swap,  // swap a                ; 3 1    4E
  ST7_clr,   // clr a                 ; 3 1    4F
  ST7_neg,   // neg x                 ; 3 1    50
  ST7_null,  //                                51
  ST7_null,  //                                52
  ST7_cpl,   // cpl x                 ; 3 1    53
  ST7_srl,   // srl x                 ; 3 1    54
  ST7_null,  //                                55
  ST7_rrc,   // rrc x                 ; 3 1    56
  ST7_sra,   // sra x                 ; 3 1    57
  ST7_sll,   // sll x                 ; 3 1    58
  ST7_rlc,   // rlc x                 ; 3 1    59
  ST7_dec,   // dec x                 ; 3 1    5A
  ST7_null,  //                                5B
  ST7_inc,   // inc x                 ; 3 1    5C
  ST7_tnz,   // tnz x                 ; 3 1    5D
  ST7_swap,  // swap x                ; 3 1    5E
  ST7_clr,   // clr x                 ; 3 1    5F
  ST7_neg,   // neg (short,x)         ; 6 2    60 XX
  ST7_null,  //                                61
  ST7_null,  //                                62
  ST7_cpl,   // cpl (short,x)         ; 6 2    63 XX
  ST7_srl,   // srl (short,x)         ; 6 2    64 XX
  ST7_null,  //                                65
  ST7_rrc,   // rrc (short,x)         ; 6 2    66 XX
  ST7_sra,   // sra (short,x)         ; 6 2    67 XX
  ST7_sll,   // sll (short,x)         ; 6 2    68 XX
  ST7_rlc,   // rlc (short,x)         ; 6 2    69 XX
  ST7_dec,   // dec (short,x)         ; 6 2    6A XX
  ST7_null,  //                                6B
  ST7_inc,   // inc (short,x)         ; 6 2    6C XX
  ST7_tnz,   // tnz (short,x)         ; 5 2    6D XX
  ST7_swap,  // swap (short,x)        ; 6 2    6E XX
  ST7_clr,   // clr (short,x)         ; 6 2    6F XX
  ST7_neg,   // neg (x)               ; 5 1    70
  ST7_null,  //                                71
  ST7_null,  //                                72
  ST7_cpl,   // cpl (x)               ; 5 1    73
  ST7_srl,   // srl (x)               ; 5 1    74
  ST7_null,  //                                75
  ST7_rrc,   // rrc (x)               ; 5 1    76
  ST7_sra,   // sra (x)               ; 5 1    77
  ST7_sll,   // sll (x)               ; 5 1    78
  ST7_rlc,   // rlc (x)               ; 5 1    79
  ST7_dec,   // dec (x)               ; 5 1    7A
  ST7_null,  //                                7B
  ST7_inc,   // inc (x)               ; 5 1    7C
  ST7_tnz,   // tnz (x)               ; 4 1    7D
  ST7_swap,  // swap (x)              ; 5 1    7E
  ST7_clr,   // clr (x)               ; 5 1    7F
  ST7_iret,  // iret                  ; 9 1    80
  ST7_ret,   // ret                   ; 6 1    81
  ST7_null,  //                                82
  ST7_trap,  // trap                  ; 1 1    83
  ST7_pop,   // pop a                 ; 4 1    84
  ST7_pop,   // pop x                 ; 4 1    85
  ST7_pop,   // pop cc                ; 4 1    86
  ST7_null,  //                                87
  ST7_push,  // push a                ; 3 1    88
  ST7_push,  // push x                ; 3 1    89
  ST7_push,  // push cc               ; 3 1    8A
  ST7_null,  //                                8B
  ST7_null,  //                                8C
  ST7_null,  //                                8D
  ST7_halt,  // halt                  ; 2 1    8E
  ST7_wfi,   // wfi                   ; 2 1    8F
  ST7_null,  //                                90
  ST7_null,  //                                91
  ST7_null,  //                                92
  ST7_ld,    // ld x, y               ; 2 1    93
  ST7_ld,    // ld s, x               ; 2 1    94
  ST7_ld,    // ld s, a               ; 2 1    95
  ST7_ld,    // ld x, s               ; 2 1    96
  ST7_ld,    // ld x, a               ; 2 1    97
  ST7_rcf,   // rcf                   ; 2 1    98
  ST7_scf,   // scf                   ; 2 1    99
  ST7_rim,   // rim                   ; 2 1    9A
  ST7_sim,   // sim                   ; 2 1    9B
  ST7_rsp,   // rsp                   ; 2 1    9C
  ST7_nop,   // nop                   ; 2 1    9D
  ST7_ld,    // ld a, s               ; 2 1    9E
  ST7_ld,    // ld a, x               ; 2 1    9F
  ST7_sub,   // sub a, #byte          ; 2 2    A0 XX
  ST7_cp,    // cp a, #byte           ; 2 2    A1 XX
  ST7_sbc,   // sbc a, #byte          ; 2 2    A2 XX
  ST7_cp,    // cp x, #byte           ; 2 2    A3 XX
  ST7_and,   // and a, #byte          ; 2 2    A4 XX
  ST7_bcp,   // bcp a, #byte          ; 2 2    A5 XX
  ST7_ld,    // ld a, #byte           ; 2 2    A6 XX
  ST7_null,  //                                A7
  ST7_xor,   // xor a, #byte          ; 2 2    A8 XX
  ST7_adc,   // adc a, #byte          ; 2 2    A9 XX
  ST7_or,    // or a, #byte           ; 2 2    AA XX
  ST7_add,   // add a, #byte          ; 2 2    AB XX
  ST7_null,  //                                AC
  ST7_callr, // callr callrl          ; 6 2    AD XX
  ST7_ld,    // ld x, #byte           ; 2 2    AE XX
  ST7_null,  //                                AF
  ST7_sub,   // sub a, short          ; 3 2    B0 XX
  ST7_cp,    // cp a, short           ; 3 2    B1 XX
  ST7_sbc,   // sbc a, short          ; 3 2    B2 XX
  ST7_cp,    // cp x, short           ; 3 2    B3 XX
  ST7_and,   // and a, short          ; 3 2    B4 XX
  ST7_bcp,   // bcp a, short          ; 3 2    B5 XX
  ST7_ld,    // ld a, short           ; 3 2    B6 XX
  ST7_ld,    // ld short, a           ; 4 2    B7 XX
  ST7_xor,   // xor a, short          ; 3 2    B8 XX
  ST7_adc,   // adc a, short          ; 3 2    B9 XX
  ST7_or,    // or a, short           ; 3 2    BA XX
  ST7_add,   // add a, short          ; 3 2    BB XX
  ST7_jp,    // jp short              ; 2 2    BC XX
  ST7_call,  // call short            ; 5 2    BD XX
  ST7_ld,    // ld x, short           ; 3 2    BE XX
  ST7_ld,    // ld short, x           ; 4 2    BF XX
  ST7_sub,   // sub a, long           ; 4 3    C0 MS LS
  ST7_cp,    // cp a, long            ; 4 3    C1 MS LS
  ST7_sbc,   // sbc a, long           ; 4 3    C2 MS LS
  ST7_cp,    // cp x, long            ; 4 3    C3 MS LS
  ST7_and,   // and a, long           ; 4 3    C4 MS LS
  ST7_bcp,   // bcp a, long           ; 4 3    C5 MS LS
  ST7_ld,    // ld a, long            ; 4 3    C6 MS LS
  ST7_ld,    // ld long, a            ; 5 3    C7 MS LS
  ST7_xor,   // xor a, long           ; 4 3    C8 MS LS
  ST7_adc,   // adc a, long           ; 4 3    C9 MS LS
  ST7_or,    // or a, long            ; 4 3    CA MS LS
  ST7_add,   // add a, long           ; 4 3    CB MS LS
  ST7_jp,    // jp long               ; 3 3    CC MS LS
  ST7_call,  // call long             ; 6 3    CD MS LS
  ST7_ld,    // ld x, long            ; 4 3    CE MS LS
  ST7_ld,    // ld long, x            ; 5 3    CF MS LS
  ST7_sub,   // sub a, (long,x)       ; 5 3    D0 MS LS
  ST7_cp,    // cp a, (long,x)        ; 5 3    D1 MS LS
  ST7_sbc,   // sbc a, (long,x)       ; 5 3    D2 MS LS
  ST7_cp,    // cp x, (long,x)        ; 5 3    D3 MS LS
  ST7_and,   // and a, (long,x)       ; 5 3    D4 MS LS
  ST7_bcp,   // bcp a, (long,x)       ; 5 3    D5 MS LS
  ST7_ld,    // ld a, (long,x)        ; 5 3    D6 MS LS
  ST7_ld,    // ld (long,x), a        ; 6 3    D7 MS LS
  ST7_xor,   // xor a, (long,x)       ; 5 3    D8 MS LS
  ST7_adc,   // adc a, (long,x)       ; 5 3    D9 MS LS
  ST7_or,    // or a, (long,x)        ; 5 3    DA MS LS
  ST7_add,   // add a, (long,x)       ; 5 3    DB MS LS
  ST7_jp,    // jp (long,x)           ; 4 3    DC MS LS
  ST7_call,  // call (long,x)         ; 7 3    DD MS LS
  ST7_ld,    // ld x, (long,x)        ; 5 3    DE MS LS
  ST7_ld,    // ld (long,x), x        ; 6 3    DF MS LS
  ST7_sub,   // sub a, (short,x)      ; 4 2    E0 XX
  ST7_cp,    // cp a, (short,x)       ; 4 2    E1 XX
  ST7_sbc,   // sbc a, (short,x)      ; 4 2    E2 XX
  ST7_cp,    // cp x, (short,x)       ; 4 2    E3 XX
  ST7_and,   // and a, (short,x)      ; 4 2    E4 XX
  ST7_bcp,   // bcp a, (short,x)      ; 4 2    E5 XX
  ST7_ld,    // ld a, (short,x)       ; 4 2    E6 XX
  ST7_ld,    // ld (short,x), a       ; 5 2    E7 XX
  ST7_xor,   // xor a, (short,x)      ; 4 2    E8 XX
  ST7_adc,   // adc a, (short,x)      ; 4 2    E9 XX
  ST7_or,    // or a, (short,x)       ; 4 2    EA XX
  ST7_add,   // add a, (short,x)      ; 4 2    EB XX
  ST7_jp,    // jp (short,x)          ; 3 2    EC XX
  ST7_call,  // call (short,x)        ; 6 2    ED XX
  ST7_ld,    // ld x, (short,x)       ; 4 2    EE XX
  ST7_ld,    // ld (short,x), x       ; 5 2    EF XX
  ST7_sub,   // sub a, (x)            ; 3 1    F0
  ST7_cp,    // cp a, (x)             ; 3 1    F1
  ST7_sbc,   // sbc a, (x)            ; 3 1    F2
  ST7_cp,    // cp x, (x)             ; 3 1    F3
  ST7_and,   // and a, (x)            ; 3 1    F4
  ST7_bcp,   // bcp a, (x)            ; 3 1    F5
  ST7_ld,    // ld a, (x)             ; 3 1    F6
  ST7_ld,    // ld (x), a             ; 4 1    F7
  ST7_xor,   // xor a, (x)            ; 3 1    F8
  ST7_adc,   // adc a, (x)            ; 3 1    F9
  ST7_or,    // or a, (x)             ; 3 1    FA
  ST7_add,   // add a, (x)            ; 3 1    FB
  ST7_jp,    // jp (x)                ; 2 1    FC
  ST7_call,  // call (x)              ; 5 1    FD
  ST7_ld,    // ld x, (x)             ; 3 1    FE
  ST7_ld,    // ld (x), x             ; 4 1    FF
};

struct opcode_t
{
  uchar itype;
  uchar opcode;
};

static const opcode_t pre90[] =
{
  { ST7_mul,   0x42 },  // mul y, a              ; 90 42
  { ST7_neg,   0x50 },  // neg y                 ; 90 50
  { ST7_cpl,   0x53 },  // cpl y                 ; 90 53
  { ST7_srl,   0x54 },  // srl y                 ; 90 54
  { ST7_rrc,   0x56 },  // rrc y                 ; 90 56
  { ST7_sra,   0x57 },  // sra y                 ; 90 57
//  { ST7_sla,   0x58 },  // sla y                 ; 90 58
  { ST7_sll,   0x58 },  // sll y                 ; 90 58
  { ST7_rlc,   0x59 },  // rlc y                 ; 90 59
  { ST7_dec,   0x5A },  // dec y                 ; 90 5A
  { ST7_inc,   0x5C },  // inc y                 ; 90 5C
  { ST7_tnz,   0x5D },  // tnz y                 ; 90 5D
  { ST7_swap,  0x5E },  // swap y                ; 90 5E
  { ST7_clr,   0x5F },  // clr y                 ; 90 5F
  { ST7_neg,   0x60 },  // neg (short,y)         ; 90 60 XX
  { ST7_cpl,   0x63 },  // cpl (short,y)         ; 90 63 XX
  { ST7_srl,   0x64 },  // srl (short,y)         ; 90 64 XX
  { ST7_rrc,   0x66 },  // rrc (short,y)         ; 90 66 XX
  { ST7_sra,   0x67 },  // sra (short,y)         ; 90 67 XX
//  { ST7_sla,   0x68 },  // sla (short,y)         ; 90 68 XX
  { ST7_sll,   0x68 },  // sll (short,y)         ; 90 68 XX
  { ST7_rlc,   0x69 },  // rlc (short,y)         ; 90 69 XX
  { ST7_dec,   0x6A },  // dec (short,y)         ; 90 6A XX
  { ST7_inc,   0x6C },  // inc (short,y)         ; 90 6C XX
  { ST7_tnz,   0x6D },  // tnz (short,y)         ; 90 6D XX
  { ST7_swap,  0x6E },  // swap (short,y)        ; 90 6E XX
  { ST7_clr,   0x6F },  // clr (short,y)         ; 90 6F XX
  { ST7_neg,   0x70 },  // neg (y)               ; 90 70
  { ST7_cpl,   0x73 },  // cpl (y)               ; 90 73
  { ST7_srl,   0x74 },  // srl (y)               ; 90 74
  { ST7_rrc,   0x76 },  // rrc (y)               ; 90 76
  { ST7_sra,   0x77 },  // sra (y)               ; 90 77
//  { ST7_sla,   0x78 },  // sla (y)               ; 90 78
  { ST7_sll,   0x78 },  // sll (y)               ; 90 78
  { ST7_rlc,   0x79 },  // rlc (y)               ; 90 79
  { ST7_dec,   0x7A },  // dec (y)               ; 90 7A
  { ST7_inc,   0x7C },  // inc (y)               ; 90 7C
  { ST7_tnz,   0x7D },  // tnz (y)               ; 90 7D
  { ST7_swap,  0x7E },  // swap (y)              ; 90 7E
  { ST7_clr,   0x7F },  // clr (y)               ; 90 7F
  { ST7_pop,   0x85 },  // pop y                 ; 90 85
  { ST7_push,  0x89 },  // push y                ; 90 89
  { ST7_ld,    0x93 },  // ld y, x               ; 90 93
  { ST7_ld,    0x94 },  // ld s, y               ; 90 94
  { ST7_ld,    0x96 },  // ld y, s               ; 90 96
  { ST7_ld,    0x97 },  // ld y, a               ; 90 97
  { ST7_ld,    0x9F },  // ld a, y               ; 90 9F
  { ST7_cp,    0xA3 },  // cp y, #byte           ; 90 A3 XX
  { ST7_ld,    0xAE },  // ld y, #byte           ; 90 AE XX
  { ST7_cp,    0xB3 },  // cp y, short           ; 90 B3 XX
  { ST7_ld,    0xBE },  // ld y, short           ; 90 BE XX
  { ST7_ld,    0xBF },  // ld short, y           ; 90 BF XX
  { ST7_cp,    0xC3 },  // cp y, long            ; 90 C3 MS LS
  { ST7_ld,    0xCE },  // ld y, long            ; 90 CE MS LS
  { ST7_ld,    0xCF },  // ld long, y            ; 90 CF MS LS
  { ST7_sub,   0xD0 },  // sub a, (long,y)       ; 90 D0 MS LS
  { ST7_cp,    0xD1 },  // cp a, (long,y)        ; 90 D1 MS LS
  { ST7_sbc,   0xD2 },  // sbc a, (long,y)       ; 90 D2 MS LS
  { ST7_cp,    0xD3 },  // cp y, (long,y)        ; 90 D3 MS LS
  { ST7_and,   0xD4 },  // and a, (long,y)       ; 90 D4 MS LS
  { ST7_bcp,   0xD5 },  // bcp a, (long,y)       ; 90 D5 MS LS
  { ST7_ld,    0xD6 },  // ld a, (long,y)        ; 90 D6 MS LS
  { ST7_ld,    0xD7 },  // ld (long,y), a        ; 90 D7 MS LS
  { ST7_xor,   0xD8 },  // xor a, (long,y)       ; 90 D8 MS LS
  { ST7_adc,   0xD9 },  // adc a, (long,y)       ; 90 D9 MS LS
  { ST7_or,    0xDA },  // or a, (long,y)        ; 90 DA MS LS
  { ST7_add,   0xDB },  // add a, (long,y)       ; 90 DB MS LS
  { ST7_jp,    0xDC },  // jp (long,y)           ; 90 DC MS LS
  { ST7_call,  0xDD },  // call (long,y)         ; 90 DD MS LS
  { ST7_ld,    0xDE },  // ld y, (long,y)        ; 90 DE MS LS
  { ST7_ld,    0xDF },  // ld (long,y), y        ; 90 DF MS LS
  { ST7_sub,   0xE0 },  // sub a, (short,y)      ; 90 E0 XX
  { ST7_cp,    0xE1 },  // cp a, (short,y)       ; 90 E1 XX
  { ST7_sbc,   0xE2 },  // sbc a, (short,y)      ; 90 E2 XX
  { ST7_cp,    0xE3 },  // cp y, (short,y)       ; 90 E3 XX
  { ST7_and,   0xE4 },  // and a, (short,y)      ; 90 E4 XX
  { ST7_bcp,   0xE5 },  // bcp a, (short,y)      ; 90 E5 XX
  { ST7_ld,    0xE6 },  // ld a, (short,y)       ; 90 E6 XX
  { ST7_ld,    0xE7 },  // ld (short,y), a       ; 90 E7 XX
  { ST7_xor,   0xE8 },  // xor a, (short,y)      ; 90 E8 XX
  { ST7_adc,   0xE9 },  // adc a, (short,y)      ; 90 E9 XX
  { ST7_or,    0xEA },  // or a, (short,y)       ; 90 EA XX
  { ST7_add,   0xEB },  // add a, (short,y)      ; 90 EB XX
  { ST7_jp,    0xEC },  // jp (short,y)          ; 90 EC XX
  { ST7_call,  0xED },  // call (short,y)        ; 90 ED XX
  { ST7_ld,    0xEE },  // ld y, (short,y)       ; 90 EE XX
  { ST7_ld,    0xEF },  // ld (short,y), y       ; 90 EF XX
  { ST7_sub,   0xF0 },  // sub a, (y)            ; 90 F0
  { ST7_cp,    0xF1 },  // cp a, (y)             ; 90 F1
  { ST7_sbc,   0xF2 },  // sbc a, (y)            ; 90 F2
  { ST7_cp,    0xF3 },  // cp y, (y)             ; 90 F3
  { ST7_and,   0xF4 },  // and a, (y)            ; 90 F4
  { ST7_bcp,   0xF5 },  // bcp a, (y)            ; 90 F5
  { ST7_ld,    0xF6 },  // ld a, (y)             ; 90 F6
  { ST7_ld,    0xF7 },  // ld (y), a             ; 90 F7
  { ST7_xor,   0xF8 },  // xor a, (y)            ; 90 F8
  { ST7_adc,   0xF9 },  // adc a, (y)            ; 90 F9
  { ST7_or,    0xFA },  // or a, (y)             ; 90 FA
  { ST7_add,   0xFB },  // add a, (y)            ; 90 FB
  { ST7_jp,    0xFC },  // jp (y)                ; 90 FC
  { ST7_call,  0xFD },  // call (y)              ; 90 FD
  { ST7_ld,    0xFE },  // ld y, (y)             ; 90 FE
  { ST7_ld,    0xFF },  // ld (y), y             ; 90 FF
};

static const opcode_t pre91[] =
{
  { ST7_neg,   0x60 },  // neg ([short],y)       ; 91 60 XX
  { ST7_cpl,   0x63 },  // cpl ([short],y)       ; 91 63 XX
  { ST7_srl,   0x64 },  // srl ([short],y)       ; 91 64 XX
  { ST7_rrc,   0x66 },  // rrc ([short],y)       ; 91 66 XX
  { ST7_sra,   0x67 },  // sra ([short],y)       ; 91 67 XX
//  { ST7_sla,   0x68 },  // sla ([short],y)       ; 91 68 XX
  { ST7_sll,   0x68 },  // sll ([short],y)       ; 91 68 XX
  { ST7_rlc,   0x69 },  // rlc ([short],y)       ; 91 69 XX
  { ST7_dec,   0x6A },  // dec ([short],y)       ; 91 6A XX
  { ST7_inc,   0x6C },  // inc ([short],y)       ; 91 6C XX
  { ST7_tnz,   0x6D },  // tnz ([short],y)       ; 91 6D XX
  { ST7_swap,  0x6E },  // swap ([short],y)      ; 91 6E XX
  { ST7_clr,   0x6F },  // clr ([short],y)       ; 91 6F XX
  { ST7_cp,    0xB3 },  // cp y, [short]         ; 91 B3 XX
  { ST7_ld,    0xBE },  // ld y, [short]         ; 91 BE XX
  { ST7_ld,    0xBF },  // ld [short], y         ; 91 BF XX
  { ST7_cp,    0xC3 },  // cp y, [short.w]       ; 91 C3 XX
  { ST7_ld,    0xCE },  // ld y, [short.w]       ; 91 CE XX
  { ST7_ld,    0xCF },  // ld [short.w], y       ; 91 CF XX
  { ST7_sub,   0xD0 },  // sub a, ([short.w],y)  ; 91 D0 XX
  { ST7_cp,    0xD1 },  // cp a, ([short.w],y)   ; 91 D1 XX
  { ST7_sbc,   0xD2 },  // sbc a, ([short.w],y)  ; 91 D2 XX
  { ST7_cp,    0xD3 },  // cp y, ([short.w],y)   ; 91 D3 XX
  { ST7_and,   0xD4 },  // and a, ([short.w],y)  ; 91 D4 XX
  { ST7_bcp,   0xD5 },  // bcp a, ([short.w],y)  ; 91 D5 XX
  { ST7_ld,    0xD6 },  // ld a, ([short.w],y)   ; 91 D6 XX
  { ST7_ld,    0xD7 },  // ld ([short.w],y), a   ; 91 D7 XX
  { ST7_xor,   0xD8 },  // xor a, ([short.w],y)  ; 91 D8 XX
  { ST7_adc,   0xD9 },  // adc a, ([short.w],y)  ; 91 D9 XX
  { ST7_or,    0xDA },  // or a, ([short.w],y)   ; 91 DA XX
  { ST7_add,   0xDB },  // add a, ([short.w],y)  ; 91 DB XX
  { ST7_jp,    0xDC },  // jp ([short.w],y)      ; 91 DC XX
  { ST7_call,  0xDD },  // call ([short.w],y)    ; 91 DD XX
  { ST7_ld,    0xDE },  // ld y, ([short.w],y)   ; 91 DE XX
  { ST7_ld,    0xDF },  // ld ([short.w],y), y   ; 91 DF XX
  { ST7_sub,   0xE0 },  // sub a, ([short],y)    ; 91 E0 XX
  { ST7_cp,    0xE1 },  // cp a, ([short],y)     ; 91 E1 XX
  { ST7_sbc,   0xE2 },  // sbc a, ([short],y)    ; 91 E2 XX
  { ST7_cp,    0xE3 },  // cp y, ([short],y)     ; 91 E3 XX
  { ST7_and,   0xE4 },  // and a, ([short],y)    ; 91 E4 XX
  { ST7_bcp,   0xE5 },  // bcp a, ([short],y)    ; 91 E5 XX
  { ST7_ld,    0xE6 },  // ld a, ([short],y)     ; 91 E6 XX
  { ST7_ld,    0xE7 },  // ld ([short],y), a     ; 91 E7 XX
  { ST7_xor,   0xE8 },  // xor a, ([short],y)    ; 91 E8 XX
  { ST7_adc,   0xE9 },  // adc a, ([short],y)    ; 91 E9 XX
  { ST7_or,    0xEA },  // or a, ([short],y)     ; 91 EA XX
  { ST7_add,   0xEB },  // add a, ([short],y)    ; 91 EB XX
  { ST7_jp,    0xEC },  // jp ([short],y)        ; 91 EC XX
  { ST7_call,  0xED },  // call ([short],y)      ; 91 ED XX
  { ST7_ld,    0xEE },  // ld y, ([short],y)     ; 91 EE XX
  { ST7_ld,    0xEF },  // ld ([short],y), y     ; 91 EF XX
};

static const opcode_t pre92[] =
{
  { ST7_btjt,  0x00 },  // btjt [short], #0, br  ; 92 00 XX XX
  { ST7_btjf,  0x01 },  // btjf [short], #0, br  ; 92 01 XX XX
  { ST7_btjt,  0x02 },  // btjt [short], #1, br  ; 92 02 XX XX
  { ST7_btjf,  0x03 },  // btjf [short], #1, br  ; 92 03 XX XX
  { ST7_btjt,  0x04 },  // btjt [short], #2, br  ; 92 04 XX XX
  { ST7_btjf,  0x05 },  // btjf [short], #2, br  ; 92 05 XX XX
  { ST7_btjt,  0x06 },  // btjt [short], #3, br  ; 92 06 XX XX
  { ST7_btjf,  0x07 },  // btjf [short], #3, br  ; 92 07 XX XX
  { ST7_btjt,  0x08 },  // btjt [short], #4, br  ; 92 08 XX XX
  { ST7_btjf,  0x09 },  // btjf [short], #4, br  ; 92 09 XX XX
  { ST7_btjt,  0x0A },  // btjt [short], #5, br  ; 92 0A XX XX
  { ST7_btjf,  0x0B },  // btjf [short], #5, br  ; 92 0B XX XX
  { ST7_btjt,  0x0C },  // btjt [short], #6, br  ; 92 0C XX XX
  { ST7_btjf,  0x0D },  // btjf [short], #6, br  ; 92 0D XX XX
  { ST7_btjt,  0x0E },  // btjt [short], #7, br  ; 92 0E XX XX
  { ST7_btjf,  0x0F },  // btjf [short], #7, br  ; 92 0F XX XX
  { ST7_bset,  0x10 },  // bset [short], #0      ; 92 10 XX
  { ST7_bres,  0x11 },  // bres [short], #0      ; 92 11 XX
  { ST7_bset,  0x12 },  // bset [short], #1      ; 92 12 XX
  { ST7_bres,  0x13 },  // bres [short], #1      ; 92 13 XX
  { ST7_bset,  0x14 },  // bset [short], #2      ; 92 14 XX
  { ST7_bres,  0x15 },  // bres [short], #2      ; 92 15 XX
  { ST7_bset,  0x16 },  // bset [short], #3      ; 92 16 XX
  { ST7_bres,  0x17 },  // bres [short], #3      ; 92 17 XX
  { ST7_bset,  0x18 },  // bset [short], #4      ; 92 18 XX
  { ST7_bres,  0x19 },  // bres [short], #4      ; 92 19 XX
  { ST7_bset,  0x1A },  // bset [short], #5      ; 92 1A XX
  { ST7_bres,  0x1B },  // bres [short], #5      ; 92 1B XX
  { ST7_bset,  0x1C },  // bset [short], #6      ; 92 1C XX
  { ST7_bres,  0x1D },  // bres [short], #6      ; 92 1D XX
  { ST7_bset,  0x1E },  // bset [short], #7      ; 92 1E XX
  { ST7_bres,  0x1F },  // bres [short], #7      ; 92 1F XX
  { ST7_jra,   0x20 },  // jra   [rel8]          ; 92 20 XX
  { ST7_jrf,   0x21 },  // jrf   [rel8]          ; 92 21 XX
  { ST7_jrugt, 0x22 },  // jrugt [rel8]          ; 92 22 XX
  { ST7_jrule, 0x23 },  // jrule [rel8]          ; 92 23 XX
  { ST7_jrnc,  0x24 },  // jrnc  [rel8]          ; 92 24 XX
  { ST7_jrc,   0x25 },  // jrc   [rel8]          ; 92 25 XX
  { ST7_jrne,  0x26 },  // jrne  [rel8]          ; 92 26 XX
  { ST7_jreq,  0x27 },  // jreq  [rel8]          ; 92 27 XX
  { ST7_jrnh,  0x28 },  // jrnh  [rel8]          ; 92 28 XX
  { ST7_jrh,   0x29 },  // jrh   [rel8]          ; 92 29 XX
  { ST7_jrpl,  0x2A },  // jrpl  [rel8]          ; 92 2A XX
  { ST7_jrmi,  0x2B },  // jrmi  [rel8]          ; 92 2B XX
  { ST7_jrnm,  0x2C },  // jrnm  [rel8]          ; 92 2C XX
  { ST7_jrm,   0x2D },  // jrm   [rel8]          ; 92 2D XX
  { ST7_jril,  0x2E },  // jril  [rel8]          ; 92 2E XX
  { ST7_jrih,  0x2F },  // jrih  [rel8]          ; 92 2F XX
  { ST7_neg,   0x30 },  // neg [short]           ; 92 30 XX
  { ST7_cpl,   0x33 },  // cpl [short]           ; 92 33 XX
  { ST7_srl,   0x34 },  // srl [short]           ; 92 34 XX
  { ST7_rrc,   0x36 },  // rrc [short]           ; 92 36 XX
  { ST7_sra,   0x37 },  // sra [short]           ; 92 37 XX
//  { ST7_sla,   0x38 },  // sla [short]           ; 92 38 XX
  { ST7_sll,   0x38 },  // sll [short]           ; 92 38 XX
  { ST7_rlc,   0x39 },  // rlc [short]           ; 92 39 XX
  { ST7_dec,   0x3A },  // dec [short]           ; 92 3A XX
  { ST7_inc,   0x3C },  // inc [short]           ; 92 3C XX
  { ST7_tnz,   0x3D },  // tnz [short]           ; 92 3D XX
  { ST7_swap,  0x3E },  // swap [short]          ; 92 3E XX
  { ST7_clr,   0x3F },  // clr [short]           ; 92 3F XX
  { ST7_neg,   0x60 },  // neg ([short],x)       ; 92 60 XX
  { ST7_cpl,   0x63 },  // cpl ([short],x)       ; 92 63 XX
  { ST7_srl,   0x64 },  // srl ([short],x)       ; 92 64 XX
  { ST7_rrc,   0x66 },  // rrc ([short],x)       ; 92 66 XX
  { ST7_sra,   0x67 },  // sra ([short],x)       ; 92 67 XX
//  { ST7_sla,   0x68 },  // sla ([short],x)       ; 92 68 XX
  { ST7_sll,   0x68 },  // sll ([short],x)       ; 92 68 XX
  { ST7_rlc,   0x69 },  // rlc ([short],x)       ; 92 69 XX
  { ST7_dec,   0x6A },  // dec ([short],x)       ; 92 6A XX
  { ST7_inc,   0x6C },  // inc ([short],x)       ; 92 6C XX
  { ST7_tnz,   0x6D },  // tnz ([short],x)       ; 92 6D XX
  { ST7_swap,  0x6E },  // swap ([short],x)      ; 92 6E XX
  { ST7_clr,   0x6F },  // clr ([short],x)       ; 92 6F XX
  { ST7_callr, 0xAD },  // callr [short]         ; 92 AD XX
  { ST7_sub,   0xB0 },  // sub a, [short]        ; 92 B0 XX
  { ST7_cp,    0xB1 },  // cp a, [short]         ; 92 B1 XX
  { ST7_sbc,   0xB2 },  // sbc a, [short]        ; 92 B2 XX
  { ST7_cp,    0xB3 },  // cp x, [short]         ; 92 B3 XX
  { ST7_and,   0xB4 },  // and a, [short]        ; 92 B4 XX
  { ST7_bcp,   0xB5 },  // bcp a, [short]        ; 92 B5 XX
  { ST7_ld,    0xB6 },  // ld a, [short]         ; 92 B6 XX
  { ST7_ld,    0xB7 },  // ld [short], a         ; 92 B7 XX
  { ST7_xor,   0xB8 },  // xor a, [short]        ; 92 B8 XX
  { ST7_adc,   0xB9 },  // adc a, [short]        ; 92 B9 XX
  { ST7_or,    0xBA },  // or a, [short]         ; 92 BA XX
  { ST7_add,   0xBB },  // add a, [short]        ; 92 BB XX
  { ST7_jp,    0xBC },  // jp [short]            ; 92 BC XX
  { ST7_call,  0xBD },  // call [short]          ; 92 BD XX
  { ST7_ld,    0xBE },  // ld x, [short]         ; 92 BE XX
  { ST7_ld,    0xBF },  // ld [short], x         ; 92 BF XX
  { ST7_sub,   0xC0 },  // sub a, [short.w]      ; 92 C0 XX
  { ST7_cp,    0xC1 },  // cp a, [short.w]       ; 92 C1 XX
  { ST7_sbc,   0xC2 },  // sbc a, [short.w]      ; 92 C2 XX
  { ST7_cp,    0xC3 },  // cp x, [short.w]       ; 92 C3 XX
  { ST7_and,   0xC4 },  // and a, [short.w]      ; 92 C4 XX
  { ST7_bcp,   0xC5 },  // bcp a, [short.w]      ; 92 C5 XX
  { ST7_ld,    0xC6 },  // ld a, [short.w]       ; 92 C6 XX
  { ST7_ld,    0xC7 },  // ld [short.w], a       ; 92 C7 XX
  { ST7_xor,   0xC8 },  // xor a, [short.w]      ; 92 C8 XX
  { ST7_adc,   0xC9 },  // adc a, [short.w]      ; 92 C9 XX
  { ST7_or,    0xCA },  // or a, [short.w]       ; 92 CA XX
  { ST7_add,   0xCB },  // add a, [short.w]      ; 92 CB XX
  { ST7_jp,    0xCC },  // jp [short.w]          ; 92 CC XX
  { ST7_call,  0xCD },  // call [short.w]        ; 92 CD XX
  { ST7_ld,    0xCE },  // ld x, [short.w]       ; 92 CE XX
  { ST7_ld,    0xCF },  // ld [short.w], x       ; 92 CF XX
  { ST7_sub,   0xD0 },  // sub a, ([short.w],x)  ; 92 D0 XX
  { ST7_cp,    0xD1 },  // cp a, ([short.w],x)   ; 92 D1 XX
  { ST7_sbc,   0xD2 },  // sbc a, ([short.w],x)  ; 92 D2 XX
  { ST7_cp,    0xD3 },  // cp x, ([short.w],x)   ; 92 D3 XX
  { ST7_and,   0xD4 },  // and a, ([short.w],x)  ; 92 D4 XX
  { ST7_bcp,   0xD5 },  // bcp a, ([short.w],x)  ; 92 D5 XX
  { ST7_ld,    0xD6 },  // ld a, ([short.w],x)   ; 92 D6 XX
  { ST7_ld,    0xD7 },  // ld ([short.w],x), a   ; 92 D7 XX
  { ST7_xor,   0xD8 },  // xor a, ([short.w],x)  ; 92 D8 XX
  { ST7_adc,   0xD9 },  // adc a, ([short.w],x)  ; 92 D9 XX
  { ST7_or,    0xDA },  // or a, ([short.w],x)   ; 92 DA XX
  { ST7_add,   0xDB },  // add a, ([short.w],x)  ; 92 DB XX
  { ST7_jp,    0xDC },  // jp ([short.w],x)      ; 92 DC XX
  { ST7_call,  0xDD },  // call ([short.w],x)    ; 92 DD XX
  { ST7_ld,    0xDE },  // ld x, ([short.w],x)   ; 92 DE XX
  { ST7_ld,    0xDF },  // ld ([short.w],x), x   ; 92 DF XX
  { ST7_sub,   0xE0 },  // sub a, ([short],x)    ; 92 E0 XX
  { ST7_cp,    0xE1 },  // cp a, ([short],x)     ; 92 E1 XX
  { ST7_sbc,   0xE2 },  // sbc a, ([short],x)    ; 92 E2 XX
  { ST7_cp,    0xE3 },  // cp x, ([short],x)     ; 92 E3 XX
  { ST7_and,   0xE4 },  // and a, ([short],x)    ; 92 E4 XX
  { ST7_bcp,   0xE5 },  // bcp a, ([short],x)    ; 92 E5 XX
  { ST7_ld,    0xE6 },  // ld a, ([short],x)     ; 92 E6 XX
  { ST7_ld,    0xE7 },  // ld ([short],x), a     ; 92 E7 XX
  { ST7_xor,   0xE8 },  // xor a, ([short],x)    ; 92 E8 XX
  { ST7_adc,   0xE9 },  // adc a, ([short],x)    ; 92 E9 XX
  { ST7_or,    0xEA },  // or a, ([short],x)     ; 92 EA XX
  { ST7_add,   0xEB },  // add a, ([short],x)    ; 92 EB XX
  { ST7_jp,    0xEC },  // jp ([short],x)        ; 92 EC XX
  { ST7_call,  0xED },  // call ([short],x)      ; 92 ED XX
  { ST7_ld,    0xEE },  // ld x, ([short],x)     ; 92 EE XX
  { ST7_ld,    0xEF },  // ld ([short],x), x     ; 92 EF XX
};

//--------------------------------------------------------------------------
static int NT_CDECL cmp_opcodes(const void *a, const void *b)
{
  const opcode_t *x = (const opcode_t *)a;
  const opcode_t *y = (const opcode_t *)b;
  return x->opcode - y->opcode;
}

static uchar find_opcode(uchar code, const opcode_t *table, size_t size)
{
  opcode_t key;
  key.opcode = code;
  opcode_t *op = (opcode_t *)bsearch(&key, table, size, sizeof(opcode_t), cmp_opcodes);
  return op ? op->itype : ST7_null;
}

//--------------------------------------------------------------------------
inline void opmem(op_t &x, char dtyp)
{
  x.type = o_mem;
  x.dtyp = dtyp;
  x.offb = (uchar)cmd.size;
  x.addr = ua_next_byte();
}

inline void opimm(op_t &x, uint32 value, char dtyp)
{
  x.type = o_imm;
  x.dtyp = dtyp;
  x.value = value;
}

inline void oprel(op_t &x)
{
  x.type = o_near;
  x.dtyp = dt_code;
  x.offb = (uchar)cmd.size;
  int32 disp = char(ua_next_byte());
  x.addr = cmd.ip + cmd.size + disp;
}

inline void opreg(op_t &x, uchar reg)
{
  x.type = o_reg;
  x.dtyp = dt_byte;
  x.reg  = reg;
}

inline void opdsp(op_t &x, uchar reg, char dtyp)
{
  x.type = o_displ;
  x.dtyp = dtyp;
  x.reg  = reg;
  x.offb = (uchar)cmd.size;
  x.addr = ua_next_byte();
}

inline void oplng(op_t &x)
{
  opmem(x, dt_word);
  if ( (cmd.auxpref & aux_indir) == 0 )
  {
    cmd.auxpref |= aux_16;
    x.dtyp = dt_byte;
    x.addr <<= 8;
    x.addr |= ua_next_byte();
  }
  else
  {
    cmd.auxpref |= aux_long;
  }
}

enum ndx_t { ndx_short, ndx_long, ndx_none };

static void opndx(op_t &x, int type, uchar index)
{
  switch ( type )
  {
    case ndx_short:
      opmem(x, dt_byte);
      break;
    case ndx_long:
      oplng(x);
      break;
    case ndx_none:
      x.type = o_phrase;
      x.dtyp = dt_byte;
      break;
  }
  if ( index )
  {
    if ( type != ndx_none && (cmd.auxpref & aux_indir) == 0 )
      x.type = o_displ;
    cmd.auxpref |= aux_index;
    x.reg = index;
  }
}

//--------------------------------------------------------------------------
int idaapi ana(void)
{
  uchar code = ua_next_byte();
  bool y = false;
  switch ( code )
  {
    case 0x90:
      y = true;
      code = ua_next_byte();
      cmd.itype = find_opcode(code, pre90, qnumber(pre90));
      break;
    case 0x91:
      y = true;
      cmd.auxpref |= aux_indir;
      code = ua_next_byte();
      cmd.itype = find_opcode(code, pre91, qnumber(pre91));
      break;
    case 0x92:
      cmd.auxpref |= aux_indir;
      code = ua_next_byte();
      cmd.itype = find_opcode(code, pre92, qnumber(pre92));
      break;
    default:
      cmd.itype = primary[code];
      break;
  }
  if ( cmd.itype == ST7_null ) return 0;
  uchar xy = y ? Y : X;
  uchar index;
  int ndx;
  switch ( code >> 4 )
  {
    case 0x0:
//        btjt short, #p, brl   ; 5 3    0n XX XX (n=00+2*p)
//        btjt [short], #p, br  ; 7 4 92 0n XX XX (n=00+2*p)
//        btjf short, #p, brl   ; 5 3    0n XX XX (n=01+2*p)
//        btjf [short], #p, br  ; 7 4 92 0n XX XX (n=01+2*p)
      opmem(cmd.Op1, dt_byte);
      opimm(cmd.Op2, (code>>1) & 7, dt_byte);
      oprel(cmd.Op3);
      break;

    case 0x1:
//        bset short, #p        ; 5 2    1n XX    (n=10+2*p)
//        bset [short], #p      ; 7 3 92 1n XX    (n=10+2*p)
//        bres short, #p        ; 5 2    1n XX    (n=11+2*p)
//        bres [short], #p      ; 7 3 92 1n XX    (n=11+2*p)
      opmem(cmd.Op1, dt_byte);
      opimm(cmd.Op2, (code>>1) & 7, dt_byte);
      break;

    case 0x2:
//        jra   rel             ; 3 2    20 XX
//        jrt   rel             ; 3 2    20 XX
//        jra   [rel8]          ; 5 3 92 20 XX
//        jrt   [rel8]          ; 5 3 92 20 XX
//        jrf   rel             ; 3 2    21 XX
//        jrf   [rel8]          ; 5 3 92 21 XX
//        jrugt rel             ; 3 2    22 XX
//        jrugt [rel8]          ; 5 3 92 22 XX
//        jrule rel             ; 3 2    23 XX
//        jrule [rel8]          ; 5 3 92 23 XX
//        jrnc  rel             ; 3 2    24 XX
//        jruge rel             ; 3 2    24 XX
//        jrnc  [rel8]          ; 5 3 92 24 XX
//        jruge [rel8]          ; 5 3 92 24 XX
//        jrc   rel             ; 3 2    25 XX
//        jrult rel             ; 3 2    25 XX
//        jrc   [rel8]          ; 5 3 92 25 XX
//        jrult [rel8]          ; 5 3 92 25 XX
//        jrne  rel             ; 3 2    26 XX
//        jrne  [rel8]          ; 5 3 92 26 XX
//        jreq  rel             ; 3 2    27 XX
//        jreq  [rel8]          ; 5 3 92 27 XX
//        jrnh  rel             ; 3 2    28 XX
//        jrnh  [rel8]          ; 5 3 92 28 XX
//        jrh   rel             ; 3 2    29 XX
//        jrh   [rel8]          ; 5 3 92 29 XX
//        jrpl  rel             ; 3 2    2A XX
//        jrpl  [rel8]          ; 5 3 92 2A XX
//        jrmi  rel             ; 3 2    2B XX
//        jrmi  [rel8]          ; 5 3 92 2B XX
//        jrnm  rel             ; 3 2    2C XX
//        jrnm  [rel8]          ; 5 3 92 2C XX
//        jrm   rel             ; 3 2    2D XX
//        jrm   [rel8]          ; 5 3 92 2D XX
//        jril  rel             ; 3 2    2E XX
//        jril  [rel8]          ; 5 3 92 2E XX
//        jrih  rel             ; 3 2    2F XX
//        jrih  [rel8]          ; 5 3 92 2F XX
REL:
      if ( cmd.auxpref & aux_indir )
        opmem(cmd.Op1, dt_word);
      else
        oprel(cmd.Op1);
      break;

    case 0x3:
//        neg short             ; 5 2    30 XX
//        neg [short]           ; 7 3 92 30 XX
//        cpl short             ; 5 2    33 XX
//        cpl [short]           ; 7 3 92 33 XX
//        srl short             ; 5 2    34 XX
//        srl [short]           ; 7 3 92 34 XX
//        rrc short             ; 5 2    36 XX
//        rrc [short]           ; 7 3 92 36 XX
//        sra short             ; 5 2    37 XX
//        sra [short]           ; 7 3 92 37 XX
//        sla short             ; 5 2    38 XX
//        sll short             ; 5 2    38 XX
//        sla [short]           ; 7 3 92 38 XX
//        sll [short]           ; 7 3 92 38 XX
//        rlc short             ; 5 2    39 XX
//        rlc [short]           ; 7 3 92 39 XX
//        dec short             ; 5 2    3A XX
//        dec [short]           ; 7 3 92 3A XX
//        inc short             ; 5 2    3C XX
//        inc [short]           ; 7 3 92 3C XX
//        tnz short             ; 4 2    3D XX
//        tnz [short]           ; 6 3 92 3D XX
//        swap short            ; 5 2    3E XX
//        swap [short]          ; 7 3 92 3E XX
//        clr short             ; 5 2    3F XX
//        clr [short]           ; 7 3 92 3F XX
      opmem(cmd.Op1, dt_byte);
      break;

    case 0x4:
//        neg a                 ; 3 1    40
//        mul x, a              ;11 1    42
//        mul y, a              ;12 2 90 42
//        cpl a                 ; 3 1    43
//        srl a                 ; 3 1    44
//        rrc a                 ; 3 1    46
//        sra a                 ; 3 1    47
//        sla a                 ; 3 1    48
//        sll a                 ; 3 1    48
//        rlc a                 ; 3 1    49
//        dec a                 ; 3 1    4A
//        inc a                 ; 3 1    4C
//        tnz a                 ; 3 1    4D
//        swap a                ; 3 1    4E
//        clr a                 ; 3 1    4F
      if ( cmd.itype == ST7_mul )
      {
        opreg(cmd.Op1, xy);
        opreg(cmd.Op2, A);
      }
      else
      {
        opreg(cmd.Op1, A);
      }
      break;

    case 0x5:
//        neg x                 ; 3 1    50
//        neg y                 ; 4 2 90 50
//        cpl x                 ; 3 1    53
//        cpl y                 ; 4 2 90 53
//        srl x                 ; 3 1    54
//        srl y                 ; 4 2 90 54
//        rrc x                 ; 3 1    56
//        rrc y                 ; 4 2 90 56
//        sra x                 ; 3 1    57
//        sra y                 ; 4 2 90 57
//        sla x                 ; 3 1    58
//        sll x                 ; 3 1    58
//        sla y                 ; 4 2 90 58
//        sll y                 ; 4 2 90 58
//        rlc x                 ; 3 1    59
//        rlc y                 ; 4 2 90 59
//        dec x                 ; 3 1    5A
//        dec y                 ; 4 2 90 5A
//        inc x                 ; 3 1    5C
//        inc y                 ; 4 2 90 5C
//        tnz x                 ; 3 1    5D
//        tnz y                 ; 4 2 90 5D
//        swap x                ; 3 1    5E
//        swap y                ; 4 2 90 5E
//        clr x                 ; 3 1    5F
//        clr y                 ; 4 2 90 5F
      opreg(cmd.Op1, xy);
      break;

    case 0x6:
//        neg (short,x)         ; 6 2    60 XX
//        neg (short,y)         ; 7 3 90 60 XX
//        neg ([short],y)       ; 8 3 91 60 XX
//        neg ([short],x)       ; 8 3 92 60 XX
//        cpl (short,x)         ; 6 2    63 XX
//        cpl (short,y)         ; 7 3 90 63 XX
//        cpl ([short],y)       ; 8 3 91 63 XX
//        cpl ([short],x)       ; 8 3 92 63 XX
//        srl (short,x)         ; 6 2    64 XX
//        srl (short,y)         ; 7 3 90 64 XX
//        srl ([short],y)       ; 8 3 91 64 XX
//        srl ([short],x)       ; 8 3 92 64 XX
//        rrc (short,x)         ; 6 2    66 XX
//        rrc (short,y)         ; 7 3 90 66 XX
//        rrc ([short],y)       ; 8 3 91 66 XX
//        rrc ([short],x)       ; 8 3 92 66 XX
//        sra (short,x)         ; 6 2    67 XX
//        sra (short,y)         ; 7 3 90 67 XX
//        sra ([short],y)       ; 8 3 91 67 XX
//        sra ([short],x)       ; 8 3 92 67 XX
//        sla (short,x)         ; 6 2    68 XX
//        sll (short,x)         ; 6 2    68 XX
//        sla (short,y)         ; 7 3 90 68 XX
//        sll (short,y)         ; 7 3 90 68 XX
//        sla ([short],y)       ; 8 3 91 68 XX
//        sll ([short],y)       ; 8 3 91 68 XX
//        sla ([short],x)       ; 8 3 92 68 XX
//        sll ([short],x)       ; 8 3 92 68 XX
//        rlc (short,x)         ; 6 2    69 XX
//        rlc (short,y)         ; 7 3 90 69 XX
//        rlc ([short],y)       ; 8 3 91 69 XX
//        rlc ([short],x)       ; 8 3 92 69 XX
//        dec (short,x)         ; 6 2    6A XX
//        dec (short,y)         ; 7 3 90 6A XX
//        dec ([short],y)       ; 8 3 91 6A XX
//        dec ([short],x)       ; 8 3 92 6A XX
//        inc (short,x)         ; 6 2    6C XX
//        inc (short,y)         ; 7 3 90 6C XX
//        inc ([short],y)       ; 8 3 91 6C XX
//        inc ([short],x)       ; 8 3 92 6C XX
//        tnz (short,x)         ; 5 2    6D XX
//        tnz (short,y)         ; 6 3 90 6D XX
//        tnz ([short],y)       ; 7 3 91 6D XX
//        tnz ([short],x)       ; 7 3 92 6D XX
//        swap (short,x)        ; 6 2    6E XX
//        swap (short,y)        ; 7 3 90 6E XX
//        swap ([short],y)      ; 8 3 91 6E XX
//        swap ([short],x)      ; 8 3 92 6E XX
//        clr (short,x)         ; 6 2    6F XX
//        clr (short,y)         ; 7 3 90 6F XX
//        clr ([short],y)       ; 8 3 91 6F XX
//        clr ([short],x)       ; 8 3 92 6F XX
// o_displ Short     Direct   Indexed  ld A,($10,X)             00..1FE                + 1
// o_mem   Short     Indirect Indexed  ld A,([$10],X)           00..1FE    00..FF byte + 2
      if ( cmd.auxpref & aux_indir )
      {
        opmem(cmd.Op1, dt_byte);
        cmd.auxpref |= aux_index;
        cmd.Op1.reg = xy;
      }
      else
      {
        opdsp(cmd.Op1, xy, dt_byte);
      }
      break;

    case 0x7:
//        neg (x)               ; 5 1    70
//        neg (y)               ; 6 2 90 70
//        cpl (x)               ; 5 1    73
//        cpl (y)               ; 6 2 90 73
//        srl (x)               ; 5 1    74
//        srl (y)               ; 6 2 90 74
//        rrc (x)               ; 5 1    76
//        rrc (y)               ; 6 2 90 76
//        sra (x)               ; 5 1    77
//        sra (y)               ; 6 2 90 77
//        sla (x)               ; 5 1    78
//        sll (x)               ; 5 1    78
//        sla (y)               ; 6 2 90 78
//        sll (y)               ; 6 2 90 78
//        rlc (x)               ; 5 1    79
//        rlc (y)               ; 6 2 90 79
//        dec (x)               ; 5 1    7A
//        dec (y)               ; 6 2 90 7A
//        inc (x)               ; 5 1    7C
//        inc (y)               ; 6 2 90 7C
//        tnz (x)               ; 4 1    7D
//        tnz (y)               ; 5 2 90 7D
//        swap (x)              ; 5 1    7E
//        swap (y)              ; 6 2 90 7E
//        clr (x)               ; 5 1    7F
//        clr (y)               ; 6 2 90 7F
      cmd.Op1.type = o_phrase;
      cmd.Op1.dtyp = dt_byte;
      cmd.Op1.reg  = xy;
      break;

    case 0x8:
//        iret                  ; 9 1    80
//        ret                   ; 6 1    81
//        trap                  ; 1 1    83
//        pop a                 ; 4 1    84
//        pop x                 ; 4 1    85
//        pop y                 ; 5 2 90 85
//        pop cc                ; 4 1    86
//        push a                ; 3 1    88
//        push x                ; 3 1    89
//        push y                ; 4 2 90 89
//        push cc               ; 3 1    8A
//        halt                  ; 2 1    8E
//        wfi                   ; 2 1    8F
      if ( cmd.itype == ST7_pop || cmd.itype == ST7_push )
      {
        uchar c = (code - 0x84) & 3;
        if ( c == 2 ) c = CC;
        if ( c == 1 ) c = xy;
        opreg(cmd.Op1, c);
      }
      break;

    case 0x9:
      switch ( code )
      {
        case 0x93:
//        ld x, y               ; 2 1    93
//        ld y, x               ; 3 2 90 93
          opreg(cmd.Op1, y ? Y : X);
          opreg(cmd.Op2, y ? X : Y);
          break;
        case 0x94:
//        ld s, x               ; 2 1    94
//        ld s, y               ; 3 2 90 94
          opreg(cmd.Op1, S);
          opreg(cmd.Op2, xy);
          break;
        case 0x95:
//        ld s, a               ; 2 1    95
          opreg(cmd.Op1, S);
          opreg(cmd.Op2, A);
          break;
        case 0x96:
//        ld x, s               ; 2 1    96
//        ld y, s               ; 3 2 90 96
          opreg(cmd.Op1, xy);
          opreg(cmd.Op2, S);
          break;
        case 0x97:
//        ld x, a               ; 2 1    97
//        ld y, a               ; 3 2 90 97
          opreg(cmd.Op1, xy);
          opreg(cmd.Op2, A);
          break;
        default:
//        rcf                   ; 2 1    98
//        scf                   ; 2 1    99
//        rim                   ; 2 1    9A
//        sim                   ; 2 1    9B
//        rsp                   ; 2 1    9C
//        nop                   ; 2 1    9D
          break;
        case 0x9E:
//        ld a, s               ; 2 1    9E
          opreg(cmd.Op1, A);
          opreg(cmd.Op2, S);
          break;
        case 0x9F:
//        ld a, x               ; 2 1    9F
//        ld a, y               ; 3 2 90 9F
          opreg(cmd.Op1, A);
          opreg(cmd.Op2, xy);
          break;
      }
      break;

    case 0xA:
//        sub a, #byte          ; 2 2    A0 XX
//        cp a, #byte           ; 2 2    A1 XX
//        sbc a, #byte          ; 2 2    A2 XX
//        cp x, #byte           ; 2 2    A3 XX
//        cp y, #byte           ; 3 3 90 A3 XX
//        and a, #byte          ; 2 2    A4 XX
//        bcp a, #byte          ; 2 2    A5 XX
//        ld a, #byte           ; 2 2    A6 XX
//        xor a, #byte          ; 2 2    A8 XX
//        adc a, #byte          ; 2 2    A9 XX
//        or a, #byte           ; 2 2    AA XX
//        add a, #byte          ; 2 2    AB XX
//        callr callrl          ; 6 2    AD XX
//        callr [short]         ; 8 3 92 AD XX
//        ld x, #byte           ; 2 2    AE XX
//        ld y, #byte           ; 3 3 90 AE XX
      if ( cmd.itype == ST7_callr ) goto REL;
      opreg(cmd.Op1, (code==0xA3 || code==0xAE) ? xy : A);
      opimm(cmd.Op2, ua_next_byte(), dt_byte);
      break;

    case 0xB:
      switch ( code )
      {
        case 0xB0:
        case 0xB1:
        case 0xB2:
        case 0xB4:
        case 0xB5:
        case 0xB6:
        case 0xB8:
        case 0xB9:
        case 0xBA:
        case 0xBB:
//        sub a, short          ; 3 2    B0 XX
//        sub a, [short]        ; 5 3 92 B0 XX
//        cp a, short           ; 3 2    B1 XX
//        cp a, [short]         ; 5 3 92 B1 XX
//        sbc a, short          ; 3 2    B2 XX
//        sbc a, [short]        ; 5 3 92 B2 XX
//        and a, short          ; 3 2    B4 XX
//        and a, [short]        ; 5 3 92 B4 XX
//        bcp a, short          ; 3 2    B5 XX
//        bcp a, [short]        ; 5 3 92 B5 XX
//        ld a, short           ; 3 2    B6 XX
//        ld a, [short]         ; 5 3 92 B6 XX
//        xor a, short          ; 3 2    B8 XX
//        xor a, [short]        ; 5 3 92 B8 XX
//        adc a, short          ; 3 2    B9 XX
//        adc a, [short]        ; 5 3 92 B9 XX
//        or a, short           ; 3 2    BA XX
//        or a, [short]         ; 5 3 92 BA XX
//        add a, short          ; 3 2    BB XX
//        add a, [short]        ; 5 3 92 BB XX
          opreg(cmd.Op1, A);
          opmem(cmd.Op2, dt_byte);
          break;
        case 0xB3:
        case 0xBE:
//        cp x, short           ; 3 2    B3 XX
//        cp y, short           ; 4 3 90 B3 XX
//        cp y, [short]         ; 5 3 91 B3 XX
//        cp x, [short]         ; 5 3 92 B3 XX
//        ld x, short           ; 3 2    BE XX
//        ld y, short           ; 4 3 90 BE XX
//        ld y, [short]         ; 5 3 91 BE XX
//        ld x, [short]         ; 5 3 92 BE XX
          opreg(cmd.Op1, xy);
          opmem(cmd.Op2, dt_byte);
          break;
        case 0xB7:
//        ld short, a           ; 4 2    B7 XX
//        ld [short], a         ; 6 3 92 B7 XX
          opmem(cmd.Op1, dt_byte);
          opreg(cmd.Op2, A);
          break;
        case 0xBC:
        case 0xBD:
//        jp short              ; 2 2    BC XX
//        jp [short]            ; 4 3 92 BC XX
//        call short            ; 5 2    BD XX
//        call [short]          ; 7 3 92 BD XX
          opmem(cmd.Op1, dt_word);
          if ( (cmd.auxpref & aux_indir) == 0 )
          {
            cmd.Op1.type = o_near;
            cmd.Op1.dtyp = dt_code;
          }
          break;
        case 0xBF:
//        ld short, x           ; 4 2    BF XX
//        ld short, y           ; 5 3 90 BF XX
//        ld [short], y         ; 6 3 91 BF XX
//        ld [short], x         ; 6 3 92 BF XX
          opmem(cmd.Op1, dt_byte);
          opreg(cmd.Op2, xy);
          break;
      }
      break;

    case 0xC:
      index = 0;
      ndx = ndx_long;
      goto COMMON;
//        sub a, long           ; 4 3    C0 MS LS
//        sub a, [short.w]      ; 6 3 92 C0 XX
//        cp a, long            ; 4 3    C1 MS LS
//        cp a, [short.w]       ; 6 3 92 C1 XX
//        sbc a, long           ; 4 3    C2 MS LS
//        sbc a, [short.w]      ; 6 3 92 C2 XX
//        and a, long           ; 4 3    C4 MS LS
//        and a, [short.w]      ; 6 3 92 C4 XX
//        bcp a, long           ; 4 3    C5 MS LS
//        bcp a, [short.w]      ; 6 3 92 C5 XX
//        ld a, long            ; 4 3    C6 MS LS
//        ld a, [short.w]       ; 6 3 92 C6 XX
//        xor a, long           ; 4 3    C8 MS LS
//        xor a, [short.w]      ; 6 3 92 C8 XX
//        adc a, long           ; 4 3    C9 MS LS
//        adc a, [short.w]      ; 6 3 92 C9 XX
//        or a, long            ; 4 3    CA MS LS
//        or a, [short.w]       ; 6 3 92 CA XX
//        add a, long           ; 4 3    CB MS LS
//        add a, [short.w]      ; 6 3 92 CB XX
//        cp x, long            ; 4 3    C3 MS LS
//        cp y, long            ; 5 4 90 C3 MS LS
//        cp y, [short.w]       ; 6 3 91 C3 XX
//        cp x, [short.w]       ; 6 3 92 C3 XX
//        ld x, long            ; 4 3    CE MS LS
//        ld y, long            ; 5 4 90 CE MS LS
//        ld y, [short.w]       ; 6 3 91 CE XX
//        ld x, [short.w]       ; 6 3 92 CE XX
//        ld long, a            ; 5 3    C7 MS LS
//        ld [short.w], a       ; 7 3 92 C7 XX
//        jp long               ; 3 3    CC MS LS
//        jp [short.w]          ; 5 3 92 CC XX
//        call long             ; 6 3    CD MS LS
//        call [short.w]        ; 8 3 92 CD XX
//        ld long, x            ; 5 3    CF MS LS
//        ld long, y            ; 6 4 90 CF MS LS
//        ld [short.w], y       ; 7 3 91 CF XX
//        ld [short.w], x       ; 7 3 92 CF XX

    case 0xD:
      index = xy;
      ndx = ndx_long;
COMMON:
      switch ( code & 0xF )
      {
        case 0x0:
        case 0x1:
        case 0x2:
        case 0x4:
        case 0x5:
        case 0x6:
        case 0x8:
        case 0x9:
        case 0xA:
        case 0xB:
//        sub a, (long,x)       ; 5 3    D0 MS LS
//        sub a, (long,y)       ; 6 4 90 D0 MS LS
//        sub a, ([short.w],y)  ; 7 3 91 D0 XX
//        sub a, ([short.w],x)  ; 7 3 92 D0 XX
//        cp a, (long,x)        ; 5 3    D1 MS LS
//        cp a, (long,y)        ; 6 4 90 D1 MS LS
//        cp a, ([short.w],y)   ; 7 3 91 D1 XX
//        cp a, ([short.w],x)   ; 7 3 92 D1 XX
//        sbc a, (long,x)       ; 5 3    D2 MS LS
//        sbc a, (long,y)       ; 6 4 90 D2 MS LS
//        sbc a, ([short.w],y)  ; 7 3 91 D2 XX
//        sbc a, ([short.w],x)  ; 7 3 92 D2 XX
//        and a, (long,x)       ; 5 3    D4 MS LS
//        and a, (long,y)       ; 6 4 90 D4 MS LS
//        and a, ([short.w],y)  ; 7 3 91 D4 XX
//        and a, ([short.w],x)  ; 7 3 92 D4 XX
//        bcp a, (long,x)       ; 5 3    D5 MS LS
//        bcp a, (long,y)       ; 6 4 90 D5 MS LS
//        bcp a, ([short.w],y)  ; 7 3 91 D5 XX
//        bcp a, ([short.w],x)  ; 7 3 92 D5 XX
//        ld a, (long,x)        ; 5 3    D6 MS LS
//        ld a, (long,y)        ; 6 4 90 D6 MS LS
//        ld a, ([short.w],y)   ; 7 3 91 D6 XX
//        ld a, ([short.w],x)   ; 7 3 92 D6 XX
//        xor a, (long,x)       ; 5 3    D8 MS LS
//        xor a, (long,y)       ; 6 4 90 D8 MS LS
//        xor a, ([short.w],y)  ; 7 3 91 D8 XX
//        xor a, ([short.w],x)  ; 7 3 92 D8 XX
//        adc a, (long,x)       ; 5 3    D9 MS LS
//        adc a, (long,y)       ; 6 4 90 D9 MS LS
//        adc a, ([short.w],y)  ; 7 3 91 D9 XX
//        adc a, ([short.w],x)  ; 7 3 92 D9 XX
//        or a, (long,x)        ; 5 3    DA MS LS
//        or a, (long,y)        ; 6 4 90 DA MS LS
//        or a, ([short.w],y)   ; 7 3 91 DA XX
//        or a, ([short.w],x)   ; 7 3 92 DA XX
//        add a, (long,x)       ; 5 3    DB MS LS
//        add a, (long,y)       ; 6 4 90 DB MS LS
//        add a, ([short.w],y)  ; 7 3 91 DB XX
//        add a, ([short.w],x)  ; 7 3 92 DB XX
          opreg(cmd.Op1, A);
          opndx(cmd.Op2, ndx, index);
          break;
        case 0x3:
        case 0xE:
//        cp x, (long,x)        ; 5 3    D3 MS LS
//        cp y, (long,y)        ; 6 4 90 D3 MS LS
//        cp y, ([short.w],y)   ; 7 3 91 D3 XX
//        cp x, ([short.w],x)   ; 7 3 92 D3 XX
//        ld x, (long,x)        ; 5 3    DE MS LS
//        ld y, (long,y)        ; 6 4 90 DE MS LS
//        ld y, ([short.w],y)   ; 7 3 91 DE XX
//        ld x, ([short.w],x)   ; 7 3 92 DE XX
          opreg(cmd.Op1, xy);
          opndx(cmd.Op2, ndx, index);
          break;
        case 0x7:
//        ld (long,x), a        ; 6 3    D7 MS LS
//        ld (long,y), a        ; 7 4 90 D7 MS LS
//        ld ([short.w],y), a   ; 8 3 91 D7 XX
//        ld ([short.w],x), a   ; 8 3 92 D7 XX
          opndx(cmd.Op1, ndx, index);
          opreg(cmd.Op2, A);
          break;
        case 0xC:
        case 0xD:
//        jp (long,x)           ; 4 3    DC MS LS
//        jp (long,y)           ; 5 4 90 DC MS LS
//        jp ([short.w],y)      ; 6 3 91 DC XX
//        jp ([short.w],x)      ; 6 3 92 DC XX
//        call (long,x)         ; 7 3    DD MS LS
//        call (long,y)         ; 8 4 90 DD MS LS
//        call ([short.w],y)    ; 9 3 91 DD XX
//        call ([short.w],x)    ; 9 3 92 DD XX
          opndx(cmd.Op1, ndx, index);
          if ( (cmd.auxpref & aux_indir) == 0 && !index )
          {
            cmd.Op1.type = o_near;
            cmd.Op1.dtyp = dt_code;
          }
          break;
        case 0xF:
//        ld (long,x), x        ; 6 3    DF MS LS
//        ld (long,y), y        ; 7 4 90 DF MS LS
//        ld ([short.w],y), y   ; 8 3 91 DF XX
//        ld ([short.w],x), x   ; 8 3 92 DF XX
          opndx(cmd.Op1, ndx, index);
          opreg(cmd.Op2, xy);
          break;
      }
      break;

    case 0xE:
      index = xy;
      ndx = ndx_short;
      goto COMMON;
//        sub a, (short,x)      ; 4 2    E0 XX
//        sub a, (short,y)      ; 5 3 90 E0 XX
//        sub a, ([short],y)    ; 6 3 91 E0 XX
//        sub a, ([short],x)    ; 6 3 92 E0 XX
//        cp a, (short,x)       ; 4 2    E1 XX
//        cp a, (short,y)       ; 5 3 90 E1 XX
//        cp a, ([short],y)     ; 6 3 91 E1 XX
//        cp a, ([short],x)     ; 6 3 92 E1 XX
//        sbc a, (short,x)      ; 4 2    E2 XX
//        sbc a, (short,y)      ; 5 3 90 E2 XX
//        sbc a, ([short],y)    ; 6 3 91 E2 XX
//        sbc a, ([short],x)    ; 6 3 92 E2 XX
//        cp x, (short,x)       ; 4 2    E3 XX
//        cp y, (short,y)       ; 5 3 90 E3 XX
//        cp y, ([short],y)     ; 6 3 91 E3 XX
//        cp x, ([short],x)     ; 6 3 92 E3 XX
//        and a, (short,x)      ; 4 2    E4 XX
//        and a, (short,y)      ; 5 3 90 E4 XX
//        and a, ([short],y)    ; 6 3 91 E4 XX
//        and a, ([short],x)    ; 6 3 92 E4 XX
//        bcp a, (short,x)      ; 4 2    E5 XX
//        bcp a, (short,y)      ; 5 3 90 E5 XX
//        bcp a, ([short],y)    ; 6 3 91 E5 XX
//        bcp a, ([short],x)    ; 6 3 92 E5 XX
//        ld a, (short,x)       ; 4 2    E6 XX
//        ld a, (short,y)       ; 5 3 90 E6 XX
//        ld a, ([short],y)     ; 6 3 91 E6 XX
//        ld a, ([short],x)     ; 6 3 92 E6 XX
//        ld (short,x), a       ; 5 2    E7 XX
//        ld (short,y), a       ; 6 3 90 E7 XX
//        ld ([short],y), a     ; 7 3 91 E7 XX
//        ld ([short],x), a     ; 7 3 92 E7 XX
//        xor a, (short,x)      ; 4 2    E8 XX
//        xor a, (short,y)      ; 5 3 90 E8 XX
//        xor a, ([short],y)    ; 6 3 91 E8 XX
//        xor a, ([short],x)    ; 6 3 92 E8 XX
//        adc a, (short,x)      ; 4 2    E9 XX
//        adc a, (short,y)      ; 5 3 90 E9 XX
//        adc a, ([short],y)    ; 6 3 91 E9 XX
//        adc a, ([short],x)    ; 6 3 92 E9 XX
//        or a, (short,x)       ; 4 2    EA XX
//        or a, (short,y)       ; 5 3 90 EA XX
//        or a, ([short],y)     ; 6 3 91 EA XX
//        or a, ([short],x)     ; 6 3 92 EA XX
//        add a, (short,x)      ; 4 2    EB XX
//        add a, (short,y)      ; 5 3 90 EB XX
//        add a, ([short],y)    ; 6 3 91 EB XX
//        add a, ([short],x)    ; 6 3 92 EB XX
//        jp (short,x)          ; 3 2    EC XX
//        jp (short,y)          ; 4 3 90 EC XX
//        jp ([short],y)        ; 5 3 91 EC XX
//        jp ([short],x)        ; 5 3 92 EC XX
//        call (short,x)        ; 6 2    ED XX
//        call (short,y)        ; 7 3 90 ED XX
//        call ([short],y)      ; 8 3 91 ED XX
//        call ([short],x)      ; 8 3 92 ED XX
//        ld x, (short,x)       ; 4 2    EE XX
//        ld y, (short,y)       ; 5 3 90 EE XX
//        ld y, ([short],y)     ; 6 3 91 EE XX
//        ld x, ([short],x)     ; 6 3 92 EE XX
//        ld (short,x), x       ; 5 2    EF XX
//        ld (short,y), y       ; 6 3 90 EF XX
//        ld ([short],y), y     ; 7 3 91 EF XX
//        ld ([short],x), x     ; 7 3 92 EF XX

    case 0xF:
      index = xy;
      ndx = ndx_none;
      goto COMMON;
//        sub a, (x)            ; 3 1    F0
//        sub a, (y)            ; 4 2 90 F0
//        cp a, (x)             ; 3 1    F1
//        cp a, (y)             ; 4 2 90 F1
//        sbc a, (x)            ; 3 1    F2
//        sbc a, (y)            ; 4 2 90 F2
//        cp x, (x)             ; 3 1    F3
//        cp y, (y)             ; 4 2 90 F3
//        and a, (x)            ; 3 1    F4
//        and a, (y)            ; 4 2 90 F4
//        bcp a, (x)            ; 3 1    F5
//        bcp a, (y)            ; 4 2 90 F5
//        ld a, (x)             ; 3 1    F6
//        ld a, (y)             ; 4 2 90 F6
//        ld (x), a             ; 4 1    F7
//        ld (y), a             ; 5 2 90 F7
//        xor a, (x)            ; 3 1    F8
//        xor a, (y)            ; 4 2 90 F8
//        adc a, (x)            ; 3 1    F9
//        adc a, (y)            ; 4 2 90 F9
//        or a, (x)             ; 3 1    FA
//        or a, (y)             ; 4 2 90 FA
//        add a, (x)            ; 3 1    FB
//        add a, (y)            ; 4 2 90 FB
//        jp (x)                ; 2 1    FC
//        jp (y)                ; 3 2 90 FC
//        call (x)              ; 5 1    FD
//        call (y)              ; 6 2 90 FD
//        ld x, (x)             ; 3 1    FE
//        ld y, (y)             ; 4 2 90 FE
//        ld (x), x             ; 4 1    FF
//        ld (y), y             ; 5 2 90 FF
  }
  return cmd.size;
}

//--------------------------------------------------------------------------
void interr(const char *module)
{
  const char *name = NULL;
  if ( cmd.itype < ph.instruc_end )
    name = Instructions[cmd.itype].name;
  else
    cmd.itype = uint16(ph.instruc_start);
  warning("%a(%s): internal error in %s", cmd.ea, name, module);
}

