package miggy.cpupoet;

import static miggy.cpupoet.Core.dbrr;
import static miggy.cpupoet.Core.ea_adr16d16;
import static miggy.cpupoet.Core.ea_adr16d32;
import static miggy.cpupoet.Core.ea_adr16d8;
import static miggy.cpupoet.Core.ea_adr16s16;
import static miggy.cpupoet.Core.ea_adr16s16_read;
import static miggy.cpupoet.Core.ea_adr16s32;
import static miggy.cpupoet.Core.ea_adr16s32_read;
import static miggy.cpupoet.Core.ea_adr16s8;
import static miggy.cpupoet.Core.ea_adr16s8_read;
import static miggy.cpupoet.Core.ea_adr32d16;
import static miggy.cpupoet.Core.ea_adr32d32;
import static miggy.cpupoet.Core.ea_adr32d8;
import static miggy.cpupoet.Core.ea_adr32s16;
import static miggy.cpupoet.Core.ea_adr32s16_read;
import static miggy.cpupoet.Core.ea_adr32s32;
import static miggy.cpupoet.Core.ea_adr32s32_read;
import static miggy.cpupoet.Core.ea_adr32s8;
import static miggy.cpupoet.Core.ea_adr32s8_read;
import static miggy.cpupoet.Core.ea_aid16;
import static miggy.cpupoet.Core.ea_aid32;
import static miggy.cpupoet.Core.ea_aid8;
import static miggy.cpupoet.Core.ea_aipd16;
import static miggy.cpupoet.Core.ea_aipd16_read;
import static miggy.cpupoet.Core.ea_aipd32;
import static miggy.cpupoet.Core.ea_aipd32_read;
import static miggy.cpupoet.Core.ea_aipd8;
import static miggy.cpupoet.Core.ea_aipd8_read;
import static miggy.cpupoet.Core.ea_aips16;
import static miggy.cpupoet.Core.ea_aips16_read;
import static miggy.cpupoet.Core.ea_aips32;
import static miggy.cpupoet.Core.ea_aips32_read;
import static miggy.cpupoet.Core.ea_aips8;
import static miggy.cpupoet.Core.ea_aips8_read;
import static miggy.cpupoet.Core.ea_ais16;
import static miggy.cpupoet.Core.ea_ais16_read;
import static miggy.cpupoet.Core.ea_ais32;
import static miggy.cpupoet.Core.ea_ais32_read;
import static miggy.cpupoet.Core.ea_ais8;
import static miggy.cpupoet.Core.ea_ais8_read;
import static miggy.cpupoet.Core.ea_dad16;
import static miggy.cpupoet.Core.ea_dad32;
import static miggy.cpupoet.Core.ea_dad8;
import static miggy.cpupoet.Core.ea_daid16;
import static miggy.cpupoet.Core.ea_daid32;
import static miggy.cpupoet.Core.ea_daid8;
import static miggy.cpupoet.Core.ea_dais16;
import static miggy.cpupoet.Core.ea_dais16_read;
import static miggy.cpupoet.Core.ea_dais32;
import static miggy.cpupoet.Core.ea_dais32_read;
import static miggy.cpupoet.Core.ea_dais8;
import static miggy.cpupoet.Core.ea_dais8_read;
import static miggy.cpupoet.Core.ea_das16;
import static miggy.cpupoet.Core.ea_das16_read;
import static miggy.cpupoet.Core.ea_das32;
import static miggy.cpupoet.Core.ea_das32_read;
import static miggy.cpupoet.Core.ea_das8;
import static miggy.cpupoet.Core.ea_das8_read;
import static miggy.cpupoet.Core.ea_dpc16;
import static miggy.cpupoet.Core.ea_dpc16_read;
import static miggy.cpupoet.Core.ea_dpc32;
import static miggy.cpupoet.Core.ea_dpc32_read;
import static miggy.cpupoet.Core.ea_dpc8_read;
import static miggy.cpupoet.Core.ea_dpci16;
import static miggy.cpupoet.Core.ea_dpci16_read;
import static miggy.cpupoet.Core.ea_dpci32;
import static miggy.cpupoet.Core.ea_dpci32_read;
import static miggy.cpupoet.Core.ea_dpci8_read;
import static miggy.cpupoet.Core.ea_imm16_read;
import static miggy.cpupoet.Core.ea_imm32_read;
import static miggy.cpupoet.Core.ea_imm8_read;
import static miggy.cpupoet.Core.ea_paid16;
import static miggy.cpupoet.Core.ea_paid16_read;
import static miggy.cpupoet.Core.ea_paid32;
import static miggy.cpupoet.Core.ea_paid32_read;
import static miggy.cpupoet.Core.ea_paid8;
import static miggy.cpupoet.Core.ea_paid8_read;
import static miggy.cpupoet.Core.ea_pais16;
import static miggy.cpupoet.Core.ea_pais16_read;
import static miggy.cpupoet.Core.ea_pais32;
import static miggy.cpupoet.Core.ea_pais32_read;
import static miggy.cpupoet.Core.ea_pais8;
import static miggy.cpupoet.Core.ea_pais8_read;
import static miggy.cpupoet.Core.gen_abcdb_ds_dd;
import static miggy.cpupoet.Core.gen_abcdb_im_ea;
import static miggy.cpupoet.Core.gen_addb_dd_ea;
import static miggy.cpupoet.Core.gen_addb_ds_dd;
import static miggy.cpupoet.Core.gen_addb_dt_dd;
import static miggy.cpupoet.Core.gen_addb_dt_ds;
import static miggy.cpupoet.Core.gen_addb_im_ea;
import static miggy.cpupoet.Core.gen_addb_ir_ds;
import static miggy.cpupoet.Core.gen_addb_ir_ea;
import static miggy.cpupoet.Core.gen_addl_as_ad;
import static miggy.cpupoet.Core.gen_addl_as_dd;
import static miggy.cpupoet.Core.gen_addl_dd_ea;
import static miggy.cpupoet.Core.gen_addl_ds_ad;
import static miggy.cpupoet.Core.gen_addl_ds_dd;
import static miggy.cpupoet.Core.gen_addl_dt_ad;
import static miggy.cpupoet.Core.gen_addl_dt_dd;
import static miggy.cpupoet.Core.gen_addl_dt_ds;
import static miggy.cpupoet.Core.gen_addl_im_ea;
import static miggy.cpupoet.Core.gen_addl_ir_as;
import static miggy.cpupoet.Core.gen_addl_ir_ds;
import static miggy.cpupoet.Core.gen_addl_ir_ea;
import static miggy.cpupoet.Core.gen_addw_as_ad;
import static miggy.cpupoet.Core.gen_addw_as_dd;
import static miggy.cpupoet.Core.gen_addw_dd_ea;
import static miggy.cpupoet.Core.gen_addw_ds_ad;
import static miggy.cpupoet.Core.gen_addw_ds_dd;
import static miggy.cpupoet.Core.gen_addw_dt_ad;
import static miggy.cpupoet.Core.gen_addw_dt_dd;
import static miggy.cpupoet.Core.gen_addw_dt_ds;
import static miggy.cpupoet.Core.gen_addw_im_ea;
import static miggy.cpupoet.Core.gen_addw_ir_as;
import static miggy.cpupoet.Core.gen_addw_ir_ds;
import static miggy.cpupoet.Core.gen_addw_ir_ea;
import static miggy.cpupoet.Core.gen_addxb_ds_dd;
import static miggy.cpupoet.Core.gen_addxb_im_ea;
import static miggy.cpupoet.Core.gen_addxl_ds_dd;
import static miggy.cpupoet.Core.gen_addxl_im_ea;
import static miggy.cpupoet.Core.gen_addxw_ds_dd;
import static miggy.cpupoet.Core.gen_addxw_im_ea;
import static miggy.cpupoet.Core.gen_andb_dd_ea;
import static miggy.cpupoet.Core.gen_andb_ds_dd;
import static miggy.cpupoet.Core.gen_andb_dt_ccr;
import static miggy.cpupoet.Core.gen_andb_dt_dd;
import static miggy.cpupoet.Core.gen_andb_dt_ds;
import static miggy.cpupoet.Core.gen_andb_im_ea;
import static miggy.cpupoet.Core.gen_andl_dd_ea;
import static miggy.cpupoet.Core.gen_andl_ds_dd;
import static miggy.cpupoet.Core.gen_andl_dt_dd;
import static miggy.cpupoet.Core.gen_andl_dt_ds;
import static miggy.cpupoet.Core.gen_andl_im_ea;
import static miggy.cpupoet.Core.gen_andw_dd_ea;
import static miggy.cpupoet.Core.gen_andw_ds_dd;
import static miggy.cpupoet.Core.gen_andw_dt_dd;
import static miggy.cpupoet.Core.gen_andw_dt_ds;
import static miggy.cpupoet.Core.gen_andw_dt_sr;
import static miggy.cpupoet.Core.gen_andw_im_ea;
import static miggy.cpupoet.Core.gen_aslb_dd_ds;
import static miggy.cpupoet.Core.gen_aslb_ir_ds;
import static miggy.cpupoet.Core.gen_asll_dd_ds;
import static miggy.cpupoet.Core.gen_asll_ir_ds;
import static miggy.cpupoet.Core.gen_aslw_dd_ds;
import static miggy.cpupoet.Core.gen_aslw_ea;
import static miggy.cpupoet.Core.gen_aslw_ir_ds;
import static miggy.cpupoet.Core.gen_asrb_dd_ds;
import static miggy.cpupoet.Core.gen_asrb_ir_ds;
import static miggy.cpupoet.Core.gen_asrl_dd_ds;
import static miggy.cpupoet.Core.gen_asrl_ir_ds;
import static miggy.cpupoet.Core.gen_asrw_dd_ds;
import static miggy.cpupoet.Core.gen_asrw_ea;
import static miggy.cpupoet.Core.gen_asrw_ir_ds;
import static miggy.cpupoet.Core.gen_bchgb_dd_ea;
import static miggy.cpupoet.Core.gen_bchgb_im_ea;
import static miggy.cpupoet.Core.gen_bchgl_dd_ds;
import static miggy.cpupoet.Core.gen_bchgl_dt_ds;
import static miggy.cpupoet.Core.gen_bclrb_dd_ea;
import static miggy.cpupoet.Core.gen_bclrb_im_ea;
import static miggy.cpupoet.Core.gen_bclrl_dd_ds;
import static miggy.cpupoet.Core.gen_bclrl_dt_ds;
import static miggy.cpupoet.Core.gen_bsetb_dd_ea;
import static miggy.cpupoet.Core.gen_bsetb_im_ea;
import static miggy.cpupoet.Core.gen_bsetl_dd_ds;
import static miggy.cpupoet.Core.gen_bsetl_dt_ds;
import static miggy.cpupoet.Core.gen_btstb_dd_ea;
import static miggy.cpupoet.Core.gen_btstb_im_ea;
import static miggy.cpupoet.Core.gen_btstl_dd_ds;
import static miggy.cpupoet.Core.gen_btstl_dt_ds;
import static miggy.cpupoet.Core.gen_cmpb_ds_dd;
import static miggy.cpupoet.Core.gen_cmpb_dt_dd;
import static miggy.cpupoet.Core.gen_cmpb_dt_ds;
import static miggy.cpupoet.Core.gen_cmpb_im_ea;
import static miggy.cpupoet.Core.gen_cmpl_as_ad;
import static miggy.cpupoet.Core.gen_cmpl_as_dd;
import static miggy.cpupoet.Core.gen_cmpl_ds_ad;
import static miggy.cpupoet.Core.gen_cmpl_ds_dd;
import static miggy.cpupoet.Core.gen_cmpl_dt_ad;
import static miggy.cpupoet.Core.gen_cmpl_dt_dd;
import static miggy.cpupoet.Core.gen_cmpl_dt_ds;
import static miggy.cpupoet.Core.gen_cmpl_im_ea;
import static miggy.cpupoet.Core.gen_cmpmb_im_ea;
import static miggy.cpupoet.Core.gen_cmpml_im_ea;
import static miggy.cpupoet.Core.gen_cmpmw_im_ea;
import static miggy.cpupoet.Core.gen_cmpw_as_ad;
import static miggy.cpupoet.Core.gen_cmpw_as_dd;
import static miggy.cpupoet.Core.gen_cmpw_ds_ad;
import static miggy.cpupoet.Core.gen_cmpw_ds_dd;
import static miggy.cpupoet.Core.gen_cmpw_dt_ad;
import static miggy.cpupoet.Core.gen_cmpw_dt_dd;
import static miggy.cpupoet.Core.gen_cmpw_dt_ds;
import static miggy.cpupoet.Core.gen_cmpw_im_ea;
import static miggy.cpupoet.Core.gen_eorb_dd_ds;
import static miggy.cpupoet.Core.gen_eorb_dd_ea;
import static miggy.cpupoet.Core.gen_eorb_dt_ccr;
import static miggy.cpupoet.Core.gen_eorb_dt_ds;
import static miggy.cpupoet.Core.gen_eorb_im_ea;
import static miggy.cpupoet.Core.gen_eorl_dd_ds;
import static miggy.cpupoet.Core.gen_eorl_dd_ea;
import static miggy.cpupoet.Core.gen_eorl_dt_ds;
import static miggy.cpupoet.Core.gen_eorl_im_ea;
import static miggy.cpupoet.Core.gen_eorw_dd_ds;
import static miggy.cpupoet.Core.gen_eorw_dd_ea;
import static miggy.cpupoet.Core.gen_eorw_dt_ds;
import static miggy.cpupoet.Core.gen_eorw_dt_sr;
import static miggy.cpupoet.Core.gen_eorw_im_ea;
import static miggy.cpupoet.Core.gen_lslb_dd_ds;
import static miggy.cpupoet.Core.gen_lslb_ir_ds;
import static miggy.cpupoet.Core.gen_lsll_dd_ds;
import static miggy.cpupoet.Core.gen_lsll_ir_ds;
import static miggy.cpupoet.Core.gen_lslw_dd_ds;
import static miggy.cpupoet.Core.gen_lslw_ea;
import static miggy.cpupoet.Core.gen_lslw_ir_ds;
import static miggy.cpupoet.Core.gen_lsrb_dd_ds;
import static miggy.cpupoet.Core.gen_lsrb_ir_ds;
import static miggy.cpupoet.Core.gen_lsrl_dd_ds;
import static miggy.cpupoet.Core.gen_lsrl_ir_ds;
import static miggy.cpupoet.Core.gen_lsrw_dd_ds;
import static miggy.cpupoet.Core.gen_lsrw_ea;
import static miggy.cpupoet.Core.gen_lsrw_ir_ds;
import static miggy.cpupoet.Core.gen_moveb_ds_dd;
import static miggy.cpupoet.Core.gen_moveb_ds_ea;
import static miggy.cpupoet.Core.gen_moveb_dt_dd;
import static miggy.cpupoet.Core.gen_moveb_dt_ea;
import static miggy.cpupoet.Core.gen_movel_as_ad;
import static miggy.cpupoet.Core.gen_movel_as_dd;
import static miggy.cpupoet.Core.gen_movel_as_ea;
import static miggy.cpupoet.Core.gen_movel_ds_ad;
import static miggy.cpupoet.Core.gen_movel_ds_dd;
import static miggy.cpupoet.Core.gen_movel_ds_ea;
import static miggy.cpupoet.Core.gen_movel_dt_ad;
import static miggy.cpupoet.Core.gen_movel_dt_dd;
import static miggy.cpupoet.Core.gen_movel_dt_ea;
import static miggy.cpupoet.Core.gen_movel_im_dd;
import static miggy.cpupoet.Core.gen_movew_as_ad;
import static miggy.cpupoet.Core.gen_movew_as_dd;
import static miggy.cpupoet.Core.gen_movew_as_ea;
import static miggy.cpupoet.Core.gen_movew_ccr_ds;
import static miggy.cpupoet.Core.gen_movew_ccr_ea;
import static miggy.cpupoet.Core.gen_movew_ds_ad;
import static miggy.cpupoet.Core.gen_movew_ds_ccr;
import static miggy.cpupoet.Core.gen_movew_ds_dd;
import static miggy.cpupoet.Core.gen_movew_ds_ea;
import static miggy.cpupoet.Core.gen_movew_ds_sr;
import static miggy.cpupoet.Core.gen_movew_dt_ad;
import static miggy.cpupoet.Core.gen_movew_dt_ccr;
import static miggy.cpupoet.Core.gen_movew_dt_dd;
import static miggy.cpupoet.Core.gen_movew_dt_ea;
import static miggy.cpupoet.Core.gen_movew_dt_sr;
import static miggy.cpupoet.Core.gen_movew_sr_ds;
import static miggy.cpupoet.Core.gen_movew_sr_ea;
import static miggy.cpupoet.Core.gen_nbcdb_ds;
import static miggy.cpupoet.Core.gen_nbcdb_ea;
import static miggy.cpupoet.Core.gen_negb_ds;
import static miggy.cpupoet.Core.gen_negb_ea;
import static miggy.cpupoet.Core.gen_negl_ds;
import static miggy.cpupoet.Core.gen_negl_ea;
import static miggy.cpupoet.Core.gen_negw_ds;
import static miggy.cpupoet.Core.gen_negxb_ds;
import static miggy.cpupoet.Core.gen_negxb_ea;
import static miggy.cpupoet.Core.gen_negxl_ds;
import static miggy.cpupoet.Core.gen_negxl_ea;
import static miggy.cpupoet.Core.gen_negxw_ds;
import static miggy.cpupoet.Core.gen_negxw_ea;
import static miggy.cpupoet.Core.gen_notb_ds;
import static miggy.cpupoet.Core.gen_notb_ea;
import static miggy.cpupoet.Core.gen_notl_ds;
import static miggy.cpupoet.Core.gen_notl_ea;
import static miggy.cpupoet.Core.gen_notw_ds;
import static miggy.cpupoet.Core.gen_notw_ea;
import static miggy.cpupoet.Core.gen_orb_dd_ea;
import static miggy.cpupoet.Core.gen_orb_ds_dd;
import static miggy.cpupoet.Core.gen_orb_dt_ccr;
import static miggy.cpupoet.Core.gen_orb_dt_dd;
import static miggy.cpupoet.Core.gen_orb_dt_ds;
import static miggy.cpupoet.Core.gen_orb_im_ea;
import static miggy.cpupoet.Core.gen_orl_dd_ea;
import static miggy.cpupoet.Core.gen_orl_ds_dd;
import static miggy.cpupoet.Core.gen_orl_dt_dd;
import static miggy.cpupoet.Core.gen_orl_dt_ds;
import static miggy.cpupoet.Core.gen_orl_im_ea;
import static miggy.cpupoet.Core.gen_orw_dd_ea;
import static miggy.cpupoet.Core.gen_orw_ds_dd;
import static miggy.cpupoet.Core.gen_orw_dt_dd;
import static miggy.cpupoet.Core.gen_orw_dt_ds;
import static miggy.cpupoet.Core.gen_orw_dt_sr;
import static miggy.cpupoet.Core.gen_orw_im_ea;
import static miggy.cpupoet.Core.gen_rolb_dd_ds;
import static miggy.cpupoet.Core.gen_rolb_ir_ds;
import static miggy.cpupoet.Core.gen_roll_dd_ds;
import static miggy.cpupoet.Core.gen_roll_ir_ds;
import static miggy.cpupoet.Core.gen_rolw_dd_ds;
import static miggy.cpupoet.Core.gen_rolw_ea;
import static miggy.cpupoet.Core.gen_rolw_ir_ds;
import static miggy.cpupoet.Core.gen_rorb_dd_ds;
import static miggy.cpupoet.Core.gen_rorb_ir_ds;
import static miggy.cpupoet.Core.gen_rorl_dd_ds;
import static miggy.cpupoet.Core.gen_rorl_ir_ds;
import static miggy.cpupoet.Core.gen_rorw_dd_ds;
import static miggy.cpupoet.Core.gen_rorw_ea;
import static miggy.cpupoet.Core.gen_rorw_ir_ds;
import static miggy.cpupoet.Core.gen_sbcdb_ds_dd;
import static miggy.cpupoet.Core.gen_sbcdb_im_ea;
import static miggy.cpupoet.Core.gen_subb_dd_ea;
import static miggy.cpupoet.Core.gen_subb_ds_dd;
import static miggy.cpupoet.Core.gen_subb_dt_dd;
import static miggy.cpupoet.Core.gen_subb_dt_ds;
import static miggy.cpupoet.Core.gen_subb_im_ea;
import static miggy.cpupoet.Core.gen_subb_ir_ds;
import static miggy.cpupoet.Core.gen_subb_ir_ea;
import static miggy.cpupoet.Core.gen_subl_as_ad;
import static miggy.cpupoet.Core.gen_subl_as_dd;
import static miggy.cpupoet.Core.gen_subl_dd_ea;
import static miggy.cpupoet.Core.gen_subl_ds_ad;
import static miggy.cpupoet.Core.gen_subl_ds_dd;
import static miggy.cpupoet.Core.gen_subl_dt_ad;
import static miggy.cpupoet.Core.gen_subl_dt_dd;
import static miggy.cpupoet.Core.gen_subl_dt_ds;
import static miggy.cpupoet.Core.gen_subl_im_ea;
import static miggy.cpupoet.Core.gen_subl_ir_as;
import static miggy.cpupoet.Core.gen_subl_ir_ds;
import static miggy.cpupoet.Core.gen_subl_ir_ea;
import static miggy.cpupoet.Core.gen_subw_as_ad;
import static miggy.cpupoet.Core.gen_subw_as_dd;
import static miggy.cpupoet.Core.gen_subw_dd_ea;
import static miggy.cpupoet.Core.gen_subw_ds_ad;
import static miggy.cpupoet.Core.gen_subw_ds_dd;
import static miggy.cpupoet.Core.gen_subw_dt_ad;
import static miggy.cpupoet.Core.gen_subw_dt_dd;
import static miggy.cpupoet.Core.gen_subw_dt_ds;
import static miggy.cpupoet.Core.gen_subw_im_ea;
import static miggy.cpupoet.Core.gen_subw_ir_as;
import static miggy.cpupoet.Core.gen_subw_ir_ds;
import static miggy.cpupoet.Core.gen_subw_ir_ea;
import static miggy.cpupoet.Core.gen_subxb_ds_dd;
import static miggy.cpupoet.Core.gen_subxb_im_ea;
import static miggy.cpupoet.Core.gen_subxl_ds_dd;
import static miggy.cpupoet.Core.gen_subxl_im_ea;
import static miggy.cpupoet.Core.gen_subxw_ds_dd;
import static miggy.cpupoet.Core.gen_subxw_im_ea;
import static miggy.cpupoet.Core.gen_tstb_ds;
import static miggy.cpupoet.Core.gen_tstb_ea;
import static miggy.cpupoet.Core.gen_tstl_ds;
import static miggy.cpupoet.Core.gen_tstl_ea;
import static miggy.cpupoet.Core.gen_tstw_ds;
import static miggy.cpupoet.Core.gen_tstw_ea;
import static miggy.cpupoet.Core.op_bcc16;
import static miggy.cpupoet.Core.op_bcc32;
import static miggy.cpupoet.Core.op_bcc8;
import static miggy.cpupoet.Core.op_bkpt;
import static miggy.cpupoet.Core.op_bra16;
import static miggy.cpupoet.Core.op_bra32;
import static miggy.cpupoet.Core.op_bra8;
import static miggy.cpupoet.Core.op_bsr16;
import static miggy.cpupoet.Core.op_bsr32;
import static miggy.cpupoet.Core.op_bsr8;
import static miggy.cpupoet.Core.op_chk_w_ds;
import static miggy.cpupoet.Core.op_chk_w_ea;
import static miggy.cpupoet.Core.op_clrb_ds;
import static miggy.cpupoet.Core.op_clrb_ea;
import static miggy.cpupoet.Core.op_clrl_ds;
import static miggy.cpupoet.Core.op_clrl_ea;
import static miggy.cpupoet.Core.op_clrw_ds;
import static miggy.cpupoet.Core.op_clrw_ea;
import static miggy.cpupoet.Core.op_dbcc;
import static miggy.cpupoet.Core.op_exg_ad_as;
import static miggy.cpupoet.Core.op_exg_dd_as;
import static miggy.cpupoet.Core.op_exg_dd_ds;
import static miggy.cpupoet.Core.op_extbl_ds;
import static miggy.cpupoet.Core.op_extl_ds;
import static miggy.cpupoet.Core.op_extw_ds;
import static miggy.cpupoet.Core.op_illegal;
import static miggy.cpupoet.Core.op_imm16;
import static miggy.cpupoet.Core.op_imm32;
import static miggy.cpupoet.Core.op_jmp;
import static miggy.cpupoet.Core.op_jsr;
import static miggy.cpupoet.Core.op_lea_ea_ad;
import static miggy.cpupoet.Core.op_linea;
import static miggy.cpupoet.Core.op_linef;
import static miggy.cpupoet.Core.op_link_as_imm16;
import static miggy.cpupoet.Core.op_link_as_imm32;
import static miggy.cpupoet.Core.op_move_as_usp;
import static miggy.cpupoet.Core.op_move_usp_as;
import static miggy.cpupoet.Core.op_movec_cr_rz;
import static miggy.cpupoet.Core.op_movec_rz_cr;
import static miggy.cpupoet.Core.op_moveml_aips_rr;
import static miggy.cpupoet.Core.op_moveml_ea_rr;
import static miggy.cpupoet.Core.op_moveml_rr_ea;
import static miggy.cpupoet.Core.op_moveml_rr_pais;
import static miggy.cpupoet.Core.op_movemw_aips_rr;
import static miggy.cpupoet.Core.op_movemw_ea_rr;
import static miggy.cpupoet.Core.op_movemw_rr_ea;
import static miggy.cpupoet.Core.op_movemw_rr_pais;
import static miggy.cpupoet.Core.op_movepl_das_dd;
import static miggy.cpupoet.Core.op_movepl_dd_das;
import static miggy.cpupoet.Core.op_movepw_das_dd;
import static miggy.cpupoet.Core.op_movepw_dd_das;
import static miggy.cpupoet.Core.op_nop;
import static miggy.cpupoet.Core.op_pea;
import static miggy.cpupoet.Core.op_reset;
import static miggy.cpupoet.Core.op_rte;
import static miggy.cpupoet.Core.op_rtr;
import static miggy.cpupoet.Core.op_rts;
import static miggy.cpupoet.Core.op_scc_b_ds;
import static miggy.cpupoet.Core.op_scc_b_ea;
import static miggy.cpupoet.Core.op_stop;
import static miggy.cpupoet.Core.op_swap_ds;
import static miggy.cpupoet.Core.op_trap;
import static miggy.cpupoet.Core.op_trapcc;
import static miggy.cpupoet.Core.op_trapcc16;
import static miggy.cpupoet.Core.op_trapcc32;
import static miggy.cpupoet.Core.op_trapv;
import static miggy.cpupoet.Core.op_unlk_as;

public enum MacroPLA {
  ori_b_imm8_ds(0x0000, 0xfff8, op_imm16, gen_orb_dt_ds, dbrr),

  ori_b_imm8_ais(0x0010, 0xfff8, op_imm16, ea_ais8_read, gen_orb_im_ea),

  ori_b_imm8_aips(0x0018, 0xfff8, op_imm16, ea_aips8_read, gen_orb_im_ea),

  ori_b_imm8_pais(0x0020, 0xfff8, op_imm16, ea_pais8_read, gen_orb_im_ea),

  ori_b_imm8_das(0x0028, 0xfff8, op_imm16, ea_das8_read, gen_orb_im_ea),

  ori_b_imm8_dais(0x0030, 0xfff8, op_imm16, ea_dais8_read, gen_orb_im_ea),

  ori_b_imm8_adr16(0x0038, 0xffff, op_imm16, ea_adr16s8_read, gen_orb_im_ea),

  ori_b_imm8_adr32(0x0039, 0xffff, op_imm16, ea_adr32s8_read, gen_orb_im_ea),

  ori_imm8_ccr(0x003c, 0xffff, op_imm16, gen_orb_dt_ccr, dbrr),

  ori_w_imm16_ds(0x0040, 0xfff8, op_imm16, gen_orw_dt_ds, dbrr),

  ori_w_imm16_ais(0x0050, 0xfff8, op_imm16, ea_ais16_read, gen_orw_im_ea),

  ori_w_imm16_aips(0x0058, 0xfff8, op_imm16, ea_aips16_read, gen_orw_im_ea),

  ori_w_imm16_pais(0x0060, 0xfff8, op_imm16, ea_pais16_read, gen_orw_im_ea),

  ori_w_imm16_das(0x0068, 0xfff8, op_imm16, ea_das16_read, gen_orw_im_ea),

  ori_w_imm16_dais(0x0070, 0xfff8, op_imm16, ea_dais16_read, gen_orw_im_ea),

  ori_w_imm16_adr16(0x0078, 0xffff, op_imm16, ea_adr16s16_read, gen_orw_im_ea),

  ori_w_imm16_adr32(0x0079, 0xffff, op_imm16, ea_adr32s16_read, gen_orw_im_ea),

  ori_i16u_sr(0x007c, 0xffff, op_imm16, gen_orw_dt_sr, dbrr),

  ori_l_imm32_ds(0x0080, 0xfff8, op_imm32, gen_orl_dt_ds, dbrr),

  ori_l_imm32_ais(0x0090, 0xfff8, op_imm32, ea_ais32_read, gen_orl_im_ea),

  ori_l_imm32_aips(0x0098, 0xfff8, op_imm32, ea_aips32_read, gen_orl_im_ea),

  ori_l_imm32_pais(0x00a0, 0xfff8, op_imm32, ea_pais32_read, gen_orl_im_ea),

  ori_l_imm32_das(0x00a8, 0xfff8, op_imm32, ea_das32_read, gen_orl_im_ea),

  ori_l_imm32_dais(0x00b0, 0xfff8, op_imm32, ea_dais32_read, gen_orl_im_ea),

  ori_l_imm32_adr16(0x00b8, 0xffff, op_imm32, ea_adr16s32_read, gen_orl_im_ea),

  ori_l_imm32_adr32(0x00b9, 0xffff, op_imm32, ea_adr32s32_read, gen_orl_im_ea),

  btst_dd_ds(0x0100, 0xf1f8, gen_btstl_dd_ds, dbrr, dbrr),

  movep_w_das_dd(0x0108, 0xf1f8, ea_das16, dbrr, op_movepw_das_dd),

  btst_dd_ais(0x0110, 0xf1f8, ea_ais8_read, dbrr, gen_btstb_dd_ea),

  btst_dd_aips(0x0118, 0xf1f8, ea_aips8_read, dbrr, gen_btstb_dd_ea),

  btst_dd_pais(0x0120, 0xf1f8, ea_pais8_read, dbrr, gen_btstb_dd_ea),

  btst_dd_das(0x0128, 0xf1f8, ea_das8_read, dbrr, gen_btstb_dd_ea),

  btst_dd_dais(0x0130, 0xf1f8, ea_dais8_read, dbrr, gen_btstb_dd_ea),

  btst_dd_adr16(0x0138, 0xf1ff, ea_adr16s8_read, dbrr, gen_btstb_dd_ea),

  btst_dd_adr32(0x0139, 0xf1ff, ea_adr32s8_read, dbrr, gen_btstb_dd_ea),

  btst_dd_dpc(0x013a, 0xf1ff, ea_dpc8_read, dbrr, gen_btstb_dd_ea),

  btst_dd_dpci(0x013b, 0xf1ff, ea_dpci8_read, dbrr, gen_btstb_dd_ea),

  btst_dd_imm8(0x013c, 0xf1ff, ea_imm8_read, dbrr, gen_btstb_dd_ea),

  bchg_dd_ds(0x0140, 0xf1f8, gen_bchgl_dd_ds, dbrr, dbrr),

  movep_l_das_dd(0x0148, 0xf1f8, ea_das32, dbrr, op_movepl_das_dd),

  bchg_dd_ais(0x0150, 0xf1f8, ea_ais8_read, dbrr, gen_bchgb_dd_ea),

  bchg_dd_aips(0x0158, 0xf1f8, ea_aips8_read, dbrr, gen_bchgb_dd_ea),

  bchg_dd_pais(0x0160, 0xf1f8, ea_pais8_read, dbrr, gen_bchgb_dd_ea),

  bchg_dd_das(0x0168, 0xf1f8, ea_das8_read, dbrr, gen_bchgb_dd_ea),

  bchg_dd_dais(0x0170, 0xf1f8, ea_dais8_read, dbrr, gen_bchgb_dd_ea),

  bchg_dd_adr16(0x0178, 0xf1ff, ea_adr16s8_read, dbrr, gen_bchgb_dd_ea),

  bchg_dd_adr32(0x0179, 0xf1ff, ea_adr32s8_read, dbrr, gen_bchgb_dd_ea),

  bclr_dd_ds(0x0180, 0xf1f8, gen_bclrl_dd_ds, dbrr, dbrr),

  movep_w_dd_das(0x0188, 0xf1f8, ea_das16, dbrr, op_movepw_dd_das),

  bclr_dd_ais(0x0190, 0xf1f8, ea_ais8_read, dbrr, gen_bclrb_dd_ea),

  bclr_dd_aips(0x0198, 0xf1f8, ea_aips8_read, dbrr, gen_bclrb_dd_ea),

  bclr_dd_pais(0x01a0, 0xf1f8, ea_pais8_read, dbrr, gen_bclrb_dd_ea),

  bclr_dd_das(0x01a8, 0xf1f8, ea_das8_read, dbrr, gen_bclrb_dd_ea),

  bclr_dd_dais(0x01b0, 0xf1f8, ea_dais8_read, dbrr, gen_bclrb_dd_ea),

  bclr_dd_adr16(0x01b8, 0xf1ff, ea_adr16s8_read, dbrr, gen_bclrb_dd_ea),

  bclr_dd_adr32(0x01b9, 0xf1ff, ea_adr32s8_read, dbrr, gen_bclrb_dd_ea),

  bset_dd_ds(0x01c0, 0xf1f8, gen_bsetl_dd_ds, dbrr, dbrr),

  movep_l_dd_das(0x01c8, 0xf1f8, ea_das32, dbrr, op_movepl_dd_das),

  bset_dd_ais(0x01d0, 0xf1f8, ea_ais8_read, dbrr, gen_bsetb_dd_ea),

  bset_dd_aips(0x01d8, 0xf1f8, ea_aips8_read, dbrr, gen_bsetb_dd_ea),

  bset_dd_pais(0x01e0, 0xf1f8, ea_pais8_read, dbrr, gen_bsetb_dd_ea),

  bset_dd_das(0x01e8, 0xf1f8, ea_das8_read, dbrr, gen_bsetb_dd_ea),

  bset_dd_dais(0x01f0, 0xf1f8, ea_dais8_read, dbrr, gen_bsetb_dd_ea),

  bset_dd_adr16(0x01f8, 0xf1ff, ea_adr16s8_read, dbrr, gen_bsetb_dd_ea),

  bset_dd_adr32(0x01f9, 0xf1ff, ea_adr32s8_read, dbrr, gen_bsetb_dd_ea),

  andi_b_imm8_ds(0x0200, 0xfff8, op_imm16, gen_andb_dt_ds, dbrr),

  andi_b_imm8_ais(0x0210, 0xfff8, op_imm16, ea_ais8_read, gen_andb_im_ea),

  andi_b_imm8_aips(0x0218, 0xfff8, op_imm16, ea_aips8_read, gen_andb_im_ea),

  andi_b_imm8_pais(0x0220, 0xfff8, op_imm16, ea_pais8_read, gen_andb_im_ea),

  andi_b_imm8_das(0x0228, 0xfff8, op_imm16, ea_das8_read, gen_andb_im_ea),

  andi_b_imm8_dais(0x0230, 0xfff8, op_imm16, ea_dais8_read, gen_andb_im_ea),

  andi_b_imm8_adr16(0x0238, 0xffff, op_imm16, ea_adr16s8_read, gen_andb_im_ea),

  andi_b_imm8_adr32(0x0239, 0xffff, op_imm16, ea_adr32s8_read, gen_andb_im_ea),

  andi_imm8_ccr(0x023c, 0xffff, op_imm16, gen_andb_dt_ccr, dbrr),

  andi_w_imm16_ds(0x0240, 0xfff8, op_imm16, gen_andw_dt_ds, dbrr),

  andi_w_imm16_ais(0x0250, 0xfff8, op_imm16, ea_ais16_read, gen_andw_im_ea),

  andi_w_imm16_aips(0x0258, 0xfff8, op_imm16, ea_aips16_read, gen_andw_im_ea),

  andi_w_imm16_pais(0x0260, 0xfff8, op_imm16, ea_pais16_read, gen_andw_im_ea),

  andi_w_imm16_das(0x0268, 0xfff8, op_imm16, ea_das16_read, gen_andw_im_ea),

  andi_w_imm16_dais(0x0270, 0xfff8, op_imm16, ea_dais16_read, gen_andw_im_ea),

  andi_w_imm16_adr16(0x0278, 0xffff, op_imm16, ea_adr16s16_read, gen_andw_im_ea),

  andi_w_imm16_adr32(0x0279, 0xffff, op_imm16, ea_adr32s16_read, gen_andw_im_ea),

  andi_i16u_sr(0x027c, 0xffff, op_imm16, gen_andw_dt_sr, dbrr),

  andi_l_imm32_ds(0x0280, 0xfff8, op_imm32, gen_andl_dt_ds, dbrr),

  andi_l_imm32_ais(0x0290, 0xfff8, op_imm32, ea_ais32_read, gen_andl_im_ea),

  andi_l_imm32_aips(0x0298, 0xfff8, op_imm32, ea_aips32_read, gen_andl_im_ea),

  andi_l_imm32_pais(0x02a0, 0xfff8, op_imm32, ea_pais32_read, gen_andl_im_ea),

  andi_l_imm32_das(0x02a8, 0xfff8, op_imm32, ea_das32_read, gen_andl_im_ea),

  andi_l_imm32_dais(0x02b0, 0xfff8, op_imm32, ea_dais32_read, gen_andl_im_ea),

  andi_l_imm32_adr16(0x02b8, 0xffff, op_imm32, ea_adr16s32_read, gen_andl_im_ea),

  andi_l_imm32_adr32(0x02b9, 0xffff, op_imm32, ea_adr32s32_read, gen_andl_im_ea),

  subi_b_imm8_ds(0x0400, 0xfff8, op_imm16, gen_subb_dt_ds, dbrr),

  subi_b_imm8_ais(0x0410, 0xfff8, op_imm16, ea_ais8_read, gen_subb_im_ea),

  subi_b_imm8_aips(0x0418, 0xfff8, op_imm16, ea_aips8_read, gen_subb_im_ea),

  subi_b_imm8_pais(0x0420, 0xfff8, op_imm16, ea_pais8_read, gen_subb_im_ea),

  subi_b_imm8_das(0x0428, 0xfff8, op_imm16, ea_das8_read, gen_subb_im_ea),

  subi_b_imm8_dais(0x0430, 0xfff8, op_imm16, ea_dais8_read, gen_subb_im_ea),

  subi_b_imm8_adr16(0x0438, 0xffff, op_imm16, ea_adr16s8_read, gen_subb_im_ea),

  subi_b_imm8_adr32(0x0439, 0xffff, op_imm16, ea_adr32s8_read, gen_subb_im_ea),

  subi_w_imm16_ds(0x0440, 0xfff8, op_imm16, gen_subw_dt_ds, dbrr),

  subi_w_imm16_ais(0x0450, 0xfff8, op_imm16, ea_ais16_read, gen_subw_im_ea),

  subi_w_imm16_aips(0x0458, 0xfff8, op_imm16, ea_aips16_read, gen_subw_im_ea),

  subi_w_imm16_pais(0x0460, 0xfff8, op_imm16, ea_pais16_read, gen_subw_im_ea),

  subi_w_imm16_das(0x0468, 0xfff8, op_imm16, ea_das16_read, gen_subw_im_ea),

  subi_w_imm16_dais(0x0470, 0xfff8, op_imm16, ea_dais16_read, gen_subw_im_ea),

  subi_w_imm16_adr16(0x0478, 0xffff, op_imm16, ea_adr16s16_read, gen_subw_im_ea),

  subi_w_imm16_adr32(0x0479, 0xffff, op_imm16, ea_adr32s16_read, gen_subw_im_ea),

  subi_l_imm32_ds(0x0480, 0xfff8, op_imm32, gen_subl_dt_ds, dbrr),

  subi_l_imm32_ais(0x0490, 0xfff8, op_imm32, ea_ais32_read, gen_subl_im_ea),

  subi_l_imm32_aips(0x0498, 0xfff8, op_imm32, ea_aips32_read, gen_subl_im_ea),

  subi_l_imm32_pais(0x04a0, 0xfff8, op_imm32, ea_pais32_read, gen_subl_im_ea),

  subi_l_imm32_das(0x04a8, 0xfff8, op_imm32, ea_das32_read, gen_subl_im_ea),

  subi_l_imm32_dais(0x04b0, 0xfff8, op_imm32, ea_dais32_read, gen_subl_im_ea),

  subi_l_imm32_adr16(0x04b8, 0xffff, op_imm32, ea_adr16s32_read, gen_subl_im_ea),

  subi_l_imm32_adr32(0x04b9, 0xffff, op_imm32, ea_adr32s32_read, gen_subl_im_ea),

  addi_b_imm8_ds(0x0600, 0xfff8, op_imm16, gen_addb_dt_ds, dbrr),

  addi_b_imm8_ais(0x0610, 0xfff8, op_imm16, ea_ais8_read, gen_addb_im_ea),

  addi_b_imm8_aips(0x0618, 0xfff8, op_imm16, ea_aips8_read, gen_addb_im_ea),

  addi_b_imm8_pais(0x0620, 0xfff8, op_imm16, ea_pais8_read, gen_addb_im_ea),

  addi_b_imm8_das(0x0628, 0xfff8, op_imm16, ea_das8_read, gen_addb_im_ea),

  addi_b_imm8_dais(0x0630, 0xfff8, op_imm16, ea_dais8_read, gen_addb_im_ea),

  addi_b_imm8_adr16(0x0638, 0xffff, op_imm16, ea_adr16s8_read, gen_addb_im_ea),

  addi_b_imm8_adr32(0x0639, 0xffff, op_imm16, ea_adr32s8_read, gen_addb_im_ea),

  addi_w_imm16_ds(0x0640, 0xfff8, op_imm16, gen_addw_dt_ds, dbrr),

  addi_w_imm16_ais(0x0650, 0xfff8, op_imm16, ea_ais16_read, gen_addw_im_ea),

  addi_w_imm16_aips(0x0658, 0xfff8, op_imm16, ea_aips16_read, gen_addw_im_ea),

  addi_w_imm16_pais(0x0660, 0xfff8, op_imm16, ea_pais16_read, gen_addw_im_ea),

  addi_w_imm16_das(0x0668, 0xfff8, op_imm16, ea_das16_read, gen_addw_im_ea),

  addi_w_imm16_dais(0x0670, 0xfff8, op_imm16, ea_dais16_read, gen_addw_im_ea),

  addi_w_imm16_adr16(0x0678, 0xffff, op_imm16, ea_adr16s16_read, gen_addw_im_ea),

  addi_w_imm16_adr32(0x0679, 0xffff, op_imm16, ea_adr32s16_read, gen_addw_im_ea),

  addi_l_imm32_ds(0x0680, 0xfff8, op_imm32, gen_addl_dt_ds, dbrr),

  addi_l_imm32_ais(0x0690, 0xfff8, op_imm32, ea_ais32_read, gen_addl_im_ea),

  addi_l_imm32_aips(0x0698, 0xfff8, op_imm32, ea_aips32_read, gen_addl_im_ea),

  addi_l_imm32_pais(0x06a0, 0xfff8, op_imm32, ea_pais32_read, gen_addl_im_ea),

  addi_l_imm32_das(0x06a8, 0xfff8, op_imm32, ea_das32_read, gen_addl_im_ea),

  addi_l_imm32_dais(0x06b0, 0xfff8, op_imm32, ea_dais32_read, gen_addl_im_ea),

  addi_l_imm32_adr16(0x06b8, 0xffff, op_imm32, ea_adr16s32_read, gen_addl_im_ea),

  addi_l_imm32_adr32(0x06b9, 0xffff, op_imm32, ea_adr32s32_read, gen_addl_im_ea),

  btst_imm8_ds(0x0800, 0xfff8, op_imm16, gen_btstl_dt_ds, dbrr),

  btst_imm8_ais(0x0810, 0xfff8, op_imm16, ea_ais8_read, gen_btstb_im_ea),

  btst_imm8_aips(0x0818, 0xfff8, op_imm16, ea_aips8_read, gen_btstb_im_ea),

  btst_imm8_pais(0x0820, 0xfff8, op_imm16, ea_pais8_read, gen_btstb_im_ea),

  btst_imm8_das(0x0828, 0xfff8, op_imm16, ea_das8_read, gen_btstb_im_ea),

  btst_imm8_dais(0x0830, 0xfff8, op_imm16, ea_dais8_read, gen_btstb_im_ea),

  btst_imm8_adr16(0x0838, 0xffff, op_imm16, ea_adr16s8_read, gen_btstb_im_ea),

  btst_imm8_adr32(0x0839, 0xffff, op_imm16, ea_adr32s8_read, gen_btstb_im_ea),

  btst_imm8_dpc(0x083a, 0xffff, op_imm16, ea_dpc8_read, gen_btstb_im_ea),

  btst_imm8_dpci(0x083b, 0xffff, op_imm16, ea_dpci8_read, gen_btstb_im_ea),

  bchg_imm8_ds(0x0840, 0xfff8, op_imm16, gen_bchgl_dt_ds, dbrr),

  bchg_imm8_ais(0x0850, 0xfff8, op_imm16, ea_ais8_read, gen_bchgb_im_ea),

  bchg_imm8_aips(0x0858, 0xfff8, op_imm16, ea_aips8_read, gen_bchgb_im_ea),

  bchg_imm8_pais(0x0860, 0xfff8, op_imm16, ea_pais8_read, gen_bchgb_im_ea),

  bchg_imm8_das(0x0868, 0xfff8, op_imm16, ea_das8_read, gen_bchgb_im_ea),

  bchg_imm8_dais(0x0870, 0xfff8, op_imm16, ea_dais8_read, gen_bchgb_im_ea),

  bchg_imm8_adr16(0x0878, 0xffff, op_imm16, ea_adr16s8_read, gen_bchgb_im_ea),

  bchg_imm8_adr32(0x0879, 0xffff, op_imm16, ea_adr32s8_read, gen_bchgb_im_ea),

  bclr_imm8_ds(0x0880, 0xfff8, op_imm16, gen_bclrl_dt_ds, dbrr),

  bclr_imm8_ais(0x0890, 0xfff8, op_imm16, ea_ais8_read, gen_bclrb_im_ea),

  bclr_imm8_aips(0x0898, 0xfff8, op_imm16, ea_aips8_read, gen_bclrb_im_ea),

  bclr_imm8_pais(0x08a0, 0xfff8, op_imm16, ea_pais8_read, gen_bclrb_im_ea),

  bclr_imm8_das(0x08a8, 0xfff8, op_imm16, ea_das8_read, gen_bclrb_im_ea),

  bclr_imm8_dais(0x08b0, 0xfff8, op_imm16, ea_dais8_read, gen_bclrb_im_ea),

  bclr_imm8_adr16(0x08b8, 0xffff, op_imm16, ea_adr16s8_read, gen_bclrb_im_ea),

  bclr_imm8_adr32(0x08b9, 0xffff, op_imm16, ea_adr32s8_read, gen_bclrb_im_ea),

  bset_imm8_ds(0x08c0, 0xfff8, op_imm16, gen_bsetl_dt_ds, dbrr),

  bset_imm8_ais(0x08d0, 0xfff8, op_imm16, ea_ais8_read, gen_bsetb_im_ea),

  bset_imm8_aips(0x08d8, 0xfff8, op_imm16, ea_aips8_read, gen_bsetb_im_ea),

  bset_imm8_pais(0x08e0, 0xfff8, op_imm16, ea_pais8_read, gen_bsetb_im_ea),

  bset_imm8_das(0x08e8, 0xfff8, op_imm16, ea_das8_read, gen_bsetb_im_ea),

  bset_imm8_dais(0x08f0, 0xfff8, op_imm16, ea_dais8_read, gen_bsetb_im_ea),

  bset_imm8_adr16(0x08f8, 0xffff, op_imm16, ea_adr16s8_read, gen_bsetb_im_ea),

  bset_imm8_adr32(0x08f9, 0xffff, op_imm16, ea_adr32s8_read, gen_bsetb_im_ea),

  eori_b_imm8_ds(0x0a00, 0xfff8, op_imm16, gen_eorb_dt_ds, dbrr),

  eori_b_imm8_ais(0x0a10, 0xfff8, op_imm16, ea_ais8_read, gen_eorb_im_ea),

  eori_b_imm8_aips(0x0a18, 0xfff8, op_imm16, ea_aips8_read, gen_eorb_im_ea),

  eori_b_imm8_pais(0x0a20, 0xfff8, op_imm16, ea_pais8_read, gen_eorb_im_ea),

  eori_b_imm8_das(0x0a28, 0xfff8, op_imm16, ea_das8_read, gen_eorb_im_ea),

  eori_b_imm8_dais(0x0a30, 0xfff8, op_imm16, ea_dais8_read, gen_eorb_im_ea),

  eori_b_imm8_adr16(0x0a38, 0xffff, op_imm16, ea_adr16s8_read, gen_eorb_im_ea),

  eori_b_imm8_adr32(0x0a39, 0xffff, op_imm16, ea_adr32s8_read, gen_eorb_im_ea),

  eori_imm8_ccr(0x0a3c, 0xffff, op_imm16, gen_eorb_dt_ccr, dbrr),

  eori_w_imm16_ds(0x0a40, 0xfff8, op_imm16, gen_eorw_dt_ds, dbrr),

  eori_w_imm16_ais(0x0a50, 0xfff8, op_imm16, ea_ais16_read, gen_eorw_im_ea),

  eori_w_imm16_aips(0x0a58, 0xfff8, op_imm16, ea_aips16_read, gen_eorw_im_ea),

  eori_w_imm16_pais(0x0a60, 0xfff8, op_imm16, ea_pais16_read, gen_eorw_im_ea),

  eori_w_imm16_das(0x0a68, 0xfff8, op_imm16, ea_das16_read, gen_eorw_im_ea),

  eori_w_imm16_dais(0x0a70, 0xfff8, op_imm16, ea_dais16_read, gen_eorw_im_ea),

  eori_w_imm16_adr16(0x0a78, 0xffff, op_imm16, ea_adr16s16_read, gen_eorw_im_ea),

  eori_w_imm16_adr32(0x0a79, 0xffff, op_imm16, ea_adr32s16_read, gen_eorw_im_ea),

  eori_i16u_sr(0x0a7c, 0xffff, op_imm16, gen_eorw_dt_sr, dbrr),

  eori_l_imm32_ds(0x0a80, 0xfff8, op_imm32, gen_eorl_dt_ds, dbrr),

  eori_l_imm32_ais(0x0a90, 0xfff8, op_imm32, ea_ais32_read, gen_eorl_im_ea),

  eori_l_imm32_aips(0x0a98, 0xfff8, op_imm32, ea_aips32_read, gen_eorl_im_ea),

  eori_l_imm32_pais(0x0aa0, 0xfff8, op_imm32, ea_pais32_read, gen_eorl_im_ea),

  eori_l_imm32_das(0x0aa8, 0xfff8, op_imm32, ea_das32_read, gen_eorl_im_ea),

  eori_l_imm32_dais(0x0ab0, 0xfff8, op_imm32, ea_dais32_read, gen_eorl_im_ea),

  eori_l_imm32_adr16(0x0ab8, 0xffff, op_imm32, ea_adr16s32_read, gen_eorl_im_ea),

  eori_l_imm32_adr32(0x0ab9, 0xffff, op_imm32, ea_adr32s32_read, gen_eorl_im_ea),

  cmpi_b_imm8_ds(0x0c00, 0xfff8, op_imm16, gen_cmpb_dt_ds, dbrr),

  cmpi_b_imm8_ais(0x0c10, 0xfff8, op_imm16, ea_ais8_read, gen_cmpb_im_ea),

  cmpi_b_imm8_aips(0x0c18, 0xfff8, op_imm16, ea_aips8_read, gen_cmpb_im_ea),

  cmpi_b_imm8_pais(0x0c20, 0xfff8, op_imm16, ea_pais8_read, gen_cmpb_im_ea),

  cmpi_b_imm8_das(0x0c28, 0xfff8, op_imm16, ea_das8_read, gen_cmpb_im_ea),

  cmpi_b_imm8_dais(0x0c30, 0xfff8, op_imm16, ea_dais8_read, gen_cmpb_im_ea),

  cmpi_b_imm8_adr16(0x0c38, 0xffff, op_imm16, ea_adr16s8_read, gen_cmpb_im_ea),

  cmpi_b_imm8_adr32(0x0c39, 0xffff, op_imm16, ea_adr32s8_read, gen_cmpb_im_ea),

  cmpi_w_imm16_ds(0x0c40, 0xfff8, op_imm16, gen_cmpw_dt_ds, dbrr),

  cmpi_w_imm16_ais(0x0c50, 0xfff8, op_imm16, ea_ais16_read, gen_cmpw_im_ea),

  cmpi_w_imm16_aips(0x0c58, 0xfff8, op_imm16, ea_aips16_read, gen_cmpw_im_ea),

  cmpi_w_imm16_pais(0x0c60, 0xfff8, op_imm16, ea_pais16_read, gen_cmpw_im_ea),

  cmpi_w_imm16_das(0x0c68, 0xfff8, op_imm16, ea_das16_read, gen_cmpw_im_ea),

  cmpi_w_imm16_dais(0x0c70, 0xfff8, op_imm16, ea_dais16_read, gen_cmpw_im_ea),

  cmpi_w_imm16_adr16(0x0c78, 0xffff, op_imm16, ea_adr16s16_read, gen_cmpw_im_ea),

  cmpi_w_imm16_adr32(0x0c79, 0xffff, op_imm16, ea_adr32s16_read, gen_cmpw_im_ea),

  cmpi_l_imm32_ds(0x0c80, 0xfff8, op_imm32, gen_cmpl_dt_ds, dbrr),

  cmpi_l_imm32_ais(0x0c90, 0xfff8, op_imm32, ea_ais32_read, gen_cmpl_im_ea),

  cmpi_l_imm32_aips(0x0c98, 0xfff8, op_imm32, ea_aips32_read, gen_cmpl_im_ea),

  cmpi_l_imm32_pais(0x0ca0, 0xfff8, op_imm32, ea_pais32_read, gen_cmpl_im_ea),

  cmpi_l_imm32_das(0x0ca8, 0xfff8, op_imm32, ea_das32_read, gen_cmpl_im_ea),

  cmpi_l_imm32_dais(0x0cb0, 0xfff8, op_imm32, ea_dais32_read, gen_cmpl_im_ea),

  cmpi_l_imm32_adr16(0x0cb8, 0xffff, op_imm32, ea_adr16s32_read, gen_cmpl_im_ea),

  cmpi_l_imm32_adr32(0x0cb9, 0xffff, op_imm32, ea_adr32s32_read, gen_cmpl_im_ea),

  move_b_ds_dd(0x1000, 0xf1f8, gen_moveb_ds_dd, dbrr, dbrr),

  move_b_ais_dd(0x1010, 0xf1f8, ea_ais8_read, dbrr, gen_moveb_dt_dd),

  move_b_aips_dd(0x1018, 0xf1f8, ea_aips8_read, dbrr, gen_moveb_dt_dd),

  move_b_pais_dd(0x1020, 0xf1f8, ea_pais8_read, dbrr, gen_moveb_dt_dd),

  move_b_das_dd(0x1028, 0xf1f8, ea_das8_read, dbrr, gen_moveb_dt_dd),

  move_b_dais_dd(0x1030, 0xf1f8, ea_dais8_read, dbrr, gen_moveb_dt_dd),

  move_b_adr16_dd(0x1038, 0xf1ff, ea_adr16s8_read, dbrr, gen_moveb_dt_dd),

  move_b_adr32_dd(0x1039, 0xf1ff, ea_adr32s8_read, dbrr, gen_moveb_dt_dd),

  move_b_dpc_dd(0x103a, 0xf1ff, ea_dpc8_read, dbrr, gen_moveb_dt_dd),

  move_b_dpci_dd(0x103b, 0xf1ff, ea_dpci8_read, dbrr, gen_moveb_dt_dd),

  move_b_imm8_dd(0x103c, 0xf1ff, ea_imm8_read, dbrr, gen_moveb_dt_dd),

  move_b_ds_aid(0x1080, 0xf1f8, ea_aid8, gen_moveb_ds_ea, dbrr),

  move_b_ais_aid(0x1090, 0xf1f8, ea_ais8_read, gen_moveb_dt_ea, ea_aid8),

  move_b_aips_aid(0x1098, 0xf1f8, ea_aips8_read, gen_moveb_dt_ea, ea_aid8),

  move_b_pais_aid(0x10a0, 0xf1f8, ea_pais8_read, gen_moveb_dt_ea, ea_aid8),

  move_b_das_aid(0x10a8, 0xf1f8, ea_das8_read, gen_moveb_dt_ea, ea_aid8),

  move_b_dais_aid(0x10b0, 0xf1f8, ea_dais8_read, gen_moveb_dt_ea, ea_aid8),

  move_b_adr16_aid(0x10b8, 0xf1ff, ea_adr16s8_read, gen_moveb_dt_ea, ea_aid8),

  move_b_adr32_aid(0x10b9, 0xf1ff, ea_adr32s8_read, gen_moveb_dt_ea, ea_aid8),

  move_b_dpc_aid(0x10ba, 0xf1ff, ea_dpc8_read, gen_moveb_dt_ea, ea_aid8),

  move_b_dpci_aid(0x10bb, 0xf1ff, ea_dpci8_read, gen_moveb_dt_ea, ea_aid8),

  move_b_imm8_aid(0x10bc, 0xf1ff, ea_imm8_read, gen_moveb_dt_ea, ea_aid8),

  move_b_ds_aipd(0x10c0, 0xf1f8, ea_aipd8, gen_moveb_ds_ea, dbrr),

  move_b_ais_aipd(0x10d0, 0xf1f8, ea_ais8_read, gen_moveb_dt_ea, ea_aipd8),

  move_b_aips_aipd(0x10d8, 0xf1f8, ea_aips8_read, gen_moveb_dt_ea, ea_aipd8),

  move_b_pais_aipd(0x10e0, 0xf1f8, ea_pais8_read, gen_moveb_dt_ea, ea_aipd8),

  move_b_das_aipd(0x10e8, 0xf1f8, ea_das8_read, gen_moveb_dt_ea, ea_aipd8),

  move_b_dais_aipd(0x10f0, 0xf1f8, ea_dais8_read, gen_moveb_dt_ea, ea_aipd8),

  move_b_adr16_aipd(0x10f8, 0xf1ff, ea_adr16s8_read, gen_moveb_dt_ea, ea_aipd8),

  move_b_adr32_aipd(0x10f9, 0xf1ff, ea_adr32s8_read, gen_moveb_dt_ea, ea_aipd8),

  move_b_dpc_aipd(0x10fa, 0xf1ff, ea_dpc8_read, gen_moveb_dt_ea, ea_aipd8),

  move_b_dpci_aipd(0x10fb, 0xf1ff, ea_dpci8_read, gen_moveb_dt_ea, ea_aipd8),

  move_b_imm8_aipd(0x10fc, 0xf1ff, ea_imm8_read, gen_moveb_dt_ea, ea_aipd8),

  move_b_ds_paid(0x1100, 0xf1f8, ea_paid8, gen_moveb_ds_ea, dbrr),

  move_b_ais_paid(0x1110, 0xf1f8, ea_ais8_read, gen_moveb_dt_ea, ea_paid8),

  move_b_aips_paid(0x1118, 0xf1f8, ea_aips8_read, gen_moveb_dt_ea, ea_paid8),

  move_b_pais_paid(0x1120, 0xf1f8, ea_pais8_read, gen_moveb_dt_ea, ea_paid8),

  move_b_das_paid(0x1128, 0xf1f8, ea_das8_read, gen_moveb_dt_ea, ea_paid8),

  move_b_dais_paid(0x1130, 0xf1f8, ea_dais8_read, gen_moveb_dt_ea, ea_paid8),

  move_b_adr16_paid(0x1138, 0xf1ff, ea_adr16s8_read, gen_moveb_dt_ea, ea_paid8),

  move_b_adr32_paid(0x1139, 0xf1ff, ea_adr32s8_read, gen_moveb_dt_ea, ea_paid8),

  move_b_dpc_paid(0x113a, 0xf1ff, ea_dpc8_read, gen_moveb_dt_ea, ea_paid8),

  move_b_dpci_paid(0x113b, 0xf1ff, ea_dpci8_read, gen_moveb_dt_ea, ea_paid8),

  move_b_imm8_paid(0x113c, 0xf1ff, ea_imm8_read, gen_moveb_dt_ea, ea_paid8),

  move_b_ds_dad(0x1140, 0xf1f8, ea_dad8, gen_moveb_ds_ea, dbrr),

  move_b_ais_dad(0x1150, 0xf1f8, ea_ais8_read, gen_moveb_dt_ea, ea_dad8),

  move_b_aips_dad(0x1158, 0xf1f8, ea_aips8_read, gen_moveb_dt_ea, ea_dad8),

  move_b_pais_dad(0x1160, 0xf1f8, ea_pais8_read, gen_moveb_dt_ea, ea_dad8),

  move_b_das_dad(0x1168, 0xf1f8, ea_das8_read, gen_moveb_dt_ea, ea_dad8),

  move_b_dais_dad(0x1170, 0xf1f8, ea_dais8_read, gen_moveb_dt_ea, ea_dad8),

  move_b_adr16_dad(0x1178, 0xf1ff, ea_adr16s8_read, gen_moveb_dt_ea, ea_dad8),

  move_b_adr32_dad(0x1179, 0xf1ff, ea_adr32s8_read, gen_moveb_dt_ea, ea_dad8),

  move_b_dpc_dad(0x117a, 0xf1ff, ea_dpc8_read, gen_moveb_dt_ea, ea_dad8),

  move_b_dpci_dad(0x117b, 0xf1ff, ea_dpci8_read, gen_moveb_dt_ea, ea_dad8),

  move_b_imm8_dad(0x117c, 0xf1ff, ea_imm8_read, gen_moveb_dt_ea, ea_dad8),

  move_b_ds_daid(0x1180, 0xf1f8, ea_daid8, gen_moveb_ds_ea, dbrr),

  move_b_ais_daid(0x1190, 0xf1f8, ea_ais8_read, gen_moveb_dt_ea, ea_daid8),

  move_b_aips_daid(0x1198, 0xf1f8, ea_aips8_read, gen_moveb_dt_ea, ea_daid8),

  move_b_pais_daid(0x11a0, 0xf1f8, ea_pais8_read, gen_moveb_dt_ea, ea_daid8),

  move_b_das_daid(0x11a8, 0xf1f8, ea_das8_read, gen_moveb_dt_ea, ea_daid8),

  move_b_dais_daid(0x11b0, 0xf1f8, ea_dais8_read, gen_moveb_dt_ea, ea_daid8),

  move_b_adr16_daid(0x11b8, 0xf1ff, ea_adr16s8_read, gen_moveb_dt_ea, ea_daid8),

  move_b_adr32_daid(0x11b9, 0xf1ff, ea_adr32s8_read, gen_moveb_dt_ea, ea_daid8),

  move_b_dpc_daid(0x11ba, 0xf1ff, ea_dpc8_read, gen_moveb_dt_ea, ea_daid8),

  move_b_dpci_daid(0x11bb, 0xf1ff, ea_dpci8_read, gen_moveb_dt_ea, ea_daid8),

  move_b_imm8_daid(0x11bc, 0xf1ff, ea_imm8_read, gen_moveb_dt_ea, ea_daid8),

  move_b_ds_adr16(0x11c0, 0xfff8, ea_adr16d8, gen_moveb_ds_ea, dbrr),

  move_b_ais_adr16(0x11d0, 0xfff8, ea_ais8_read, gen_moveb_dt_ea, ea_adr16d8),

  move_b_aips_adr16(0x11d8, 0xfff8, ea_aips8_read, gen_moveb_dt_ea, ea_adr16d8),

  move_b_pais_adr16(0x11e0, 0xfff8, ea_pais8_read, gen_moveb_dt_ea, ea_adr16d8),

  move_b_das_adr16(0x11e8, 0xfff8, ea_das8_read, gen_moveb_dt_ea, ea_adr16d8),

  move_b_dais_adr16(0x11f0, 0xfff8, ea_dais8_read, gen_moveb_dt_ea, ea_adr16d8),

  move_b_adr16_adr16(0x11f8, 0xffff, ea_adr16s8_read, gen_moveb_dt_ea, ea_adr16d8),

  move_b_adr32_adr16(0x11f9, 0xffff, ea_adr32s8_read, gen_moveb_dt_ea, ea_adr16d8),

  move_b_dpc_adr16(0x11fa, 0xffff, ea_dpc8_read, gen_moveb_dt_ea, ea_adr16d8),

  move_b_dpci_adr16(0x11fb, 0xffff, ea_dpci8_read, gen_moveb_dt_ea, ea_adr16d8),

  move_b_imm8_adr16(0x11fc, 0xffff, ea_imm8_read, gen_moveb_dt_ea, ea_adr16d8),

  move_b_ds_adr32(0x13c0, 0xfff8, ea_adr32d8, gen_moveb_ds_ea, dbrr),

  move_b_ais_adr32(0x13d0, 0xfff8, ea_ais8_read, gen_moveb_dt_ea, ea_adr32d8),

  move_b_aips_adr32(0x13d8, 0xfff8, ea_aips8_read, gen_moveb_dt_ea, ea_adr32d8),

  move_b_pais_adr32(0x13e0, 0xfff8, ea_pais8_read, gen_moveb_dt_ea, ea_adr32d8),

  move_b_das_adr32(0x13e8, 0xfff8, ea_das8_read, gen_moveb_dt_ea, ea_adr32d8),

  move_b_dais_adr32(0x13f0, 0xfff8, ea_dais8_read, gen_moveb_dt_ea, ea_adr32d8),

  move_b_adr16_adr32(0x13f8, 0xffff, ea_adr16s8_read, gen_moveb_dt_ea, ea_adr32d8),

  move_b_adr32_adr32(0x13f9, 0xffff, ea_adr32s8_read, gen_moveb_dt_ea, ea_adr32d8),

  move_b_dpc_adr32(0x13fa, 0xffff, ea_dpc8_read, gen_moveb_dt_ea, ea_adr32d8),

  move_b_dpci_adr32(0x13fb, 0xffff, ea_dpci8_read, gen_moveb_dt_ea, ea_adr32d8),

  move_b_imm8_adr32(0x13fc, 0xffff, ea_imm8_read, gen_moveb_dt_ea, ea_adr32d8),

  move_l_ds_dd(0x2000, 0xf1f8, gen_movel_ds_dd, dbrr, dbrr),

  move_l_as_dd(0x2008, 0xf1f8, gen_movel_as_dd, dbrr, dbrr),

  move_l_ais_dd(0x2010, 0xf1f8, ea_ais32_read, dbrr, gen_movel_dt_dd),

  move_l_aips_dd(0x2018, 0xf1f8, ea_aips32_read, dbrr, gen_movel_dt_dd),

  move_l_pais_dd(0x2020, 0xf1f8, ea_pais32_read, dbrr, gen_movel_dt_dd),

  move_l_das_dd(0x2028, 0xf1f8, ea_das32_read, dbrr, gen_movel_dt_dd),

  move_l_dais_dd(0x2030, 0xf1f8, ea_dais32_read, dbrr, gen_movel_dt_dd),

  move_l_adr16_dd(0x2038, 0xf1ff, ea_adr16s32_read, dbrr, gen_movel_dt_dd),

  move_l_adr32_dd(0x2039, 0xf1ff, ea_adr32s32_read, dbrr, gen_movel_dt_dd),

  move_l_dpc_dd(0x203a, 0xf1ff, ea_dpc32_read, dbrr, gen_movel_dt_dd),

  move_l_dpci_dd(0x203b, 0xf1ff, ea_dpci32_read, dbrr, gen_movel_dt_dd),

  move_l_imm32_dd(0x203c, 0xf1ff, ea_imm32_read, dbrr, gen_movel_dt_dd),

  movea_l_ds_ad(0x2040, 0xf1f8, gen_movel_ds_ad, dbrr, dbrr),

  movea_l_as_ad(0x2048, 0xf1f8, gen_movel_as_ad, dbrr, dbrr),

  movea_l_ais_ad(0x2050, 0xf1f8, ea_ais32_read, dbrr, gen_movel_dt_ad),

  movea_l_aips_ad(0x2058, 0xf1f8, ea_aips32_read, dbrr, gen_movel_dt_ad),

  movea_l_pais_ad(0x2060, 0xf1f8, ea_pais32_read, dbrr, gen_movel_dt_ad),

  movea_l_das_ad(0x2068, 0xf1f8, ea_das32_read, dbrr, gen_movel_dt_ad),

  movea_l_dais_ad(0x2070, 0xf1f8, ea_dais32_read, dbrr, gen_movel_dt_ad),

  movea_l_adr16_ad(0x2078, 0xf1ff, ea_adr16s32_read, dbrr, gen_movel_dt_ad),

  movea_l_adr32_ad(0x2079, 0xf1ff, ea_adr32s32_read, dbrr, gen_movel_dt_ad),

  movea_l_dpc_ad(0x207a, 0xf1ff, ea_dpc32_read, dbrr, gen_movel_dt_ad),

  movea_l_dpci_ad(0x207b, 0xf1ff, ea_dpci32_read, dbrr, gen_movel_dt_ad),

  movea_l_imm32_ad(0x207c, 0xf1ff, ea_imm32_read, dbrr, gen_movel_dt_ad),

  move_l_ds_aid(0x2080, 0xf1f8, ea_aid32, gen_movel_ds_ea, dbrr),

  move_l_as_aid(0x2088, 0xf1f8, ea_aid32, gen_movel_as_ea, dbrr),

  move_l_ais_aid(0x2090, 0xf1f8, ea_ais32_read, gen_movel_dt_ea, ea_aid32),

  move_l_aips_aid(0x2098, 0xf1f8, ea_aips32_read, gen_movel_dt_ea, ea_aid32),

  move_l_pais_aid(0x20a0, 0xf1f8, ea_pais32_read, gen_movel_dt_ea, ea_aid32),

  move_l_das_aid(0x20a8, 0xf1f8, ea_das32_read, gen_movel_dt_ea, ea_aid32),

  move_l_dais_aid(0x20b0, 0xf1f8, ea_dais32_read, gen_movel_dt_ea, ea_aid32),

  move_l_adr16_aid(0x20b8, 0xf1ff, ea_adr16s32_read, gen_movel_dt_ea, ea_aid32),

  move_l_adr32_aid(0x20b9, 0xf1ff, ea_adr32s32_read, gen_movel_dt_ea, ea_aid32),

  move_l_dpc_aid(0x20ba, 0xf1ff, ea_dpc32_read, gen_movel_dt_ea, ea_aid32),

  move_l_dpci_aid(0x20bb, 0xf1ff, ea_dpci32_read, gen_movel_dt_ea, ea_aid32),

  move_l_imm32_aid(0x20bc, 0xf1ff, ea_imm32_read, gen_movel_dt_ea, ea_aid32),

  move_l_ds_aipd(0x20c0, 0xf1f8, ea_aipd32, gen_movel_ds_ea, dbrr),

  move_l_as_aipd(0x20c8, 0xf1f8, ea_aipd32, gen_movel_as_ea, dbrr),

  move_l_ais_aipd(0x20d0, 0xf1f8, ea_ais32_read, gen_movel_dt_ea, ea_aipd32),

  move_l_aips_aipd(0x20d8, 0xf1f8, ea_aips32_read, gen_movel_dt_ea, ea_aipd32),

  move_l_pais_aipd(0x20e0, 0xf1f8, ea_pais32_read, gen_movel_dt_ea, ea_aipd32),

  move_l_das_aipd(0x20e8, 0xf1f8, ea_das32_read, gen_movel_dt_ea, ea_aipd32),

  move_l_dais_aipd(0x20f0, 0xf1f8, ea_dais32_read, gen_movel_dt_ea, ea_aipd32),

  move_l_adr16_aipd(0x20f8, 0xf1ff, ea_adr16s32_read, gen_movel_dt_ea, ea_aipd32),

  move_l_adr32_aipd(0x20f9, 0xf1ff, ea_adr32s32_read, gen_movel_dt_ea, ea_aipd32),

  move_l_dpc_aipd(0x20fa, 0xf1ff, ea_dpc32_read, gen_movel_dt_ea, ea_aipd32),

  move_l_dpci_aipd(0x20fb, 0xf1ff, ea_dpci32_read, gen_movel_dt_ea, ea_aipd32),

  move_l_imm32_aipd(0x20fc, 0xf1ff, ea_imm32_read, gen_movel_dt_ea, ea_aipd32),

  move_l_ds_paid(0x2100, 0xf1f8, ea_paid32, gen_movel_ds_ea, dbrr),

  move_l_as_paid(0x2108, 0xf1f8, ea_paid32, gen_movel_as_ea, dbrr),

  move_l_ais_paid(0x2110, 0xf1f8, ea_ais32_read, gen_movel_dt_ea, ea_paid32),

  move_l_aips_paid(0x2118, 0xf1f8, ea_aips32_read, gen_movel_dt_ea, ea_paid32),

  move_l_pais_paid(0x2120, 0xf1f8, ea_pais32_read, gen_movel_dt_ea, ea_paid32),

  move_l_das_paid(0x2128, 0xf1f8, ea_das32_read, gen_movel_dt_ea, ea_paid32),

  move_l_dais_paid(0x2130, 0xf1f8, ea_dais32_read, gen_movel_dt_ea, ea_paid32),

  move_l_adr16_paid(0x2138, 0xf1ff, ea_adr16s32_read, gen_movel_dt_ea, ea_paid32),

  move_l_adr32_paid(0x2139, 0xf1ff, ea_adr32s32_read, gen_movel_dt_ea, ea_paid32),

  move_l_dpc_paid(0x213a, 0xf1ff, ea_dpc32_read, gen_movel_dt_ea, ea_paid32),

  move_l_dpci_paid(0x213b, 0xf1ff, ea_dpci32_read, gen_movel_dt_ea, ea_paid32),

  move_l_imm32_paid(0x213c, 0xf1ff, ea_imm32_read, gen_movel_dt_ea, ea_paid32),

  move_l_ds_dad(0x2140, 0xf1f8, ea_dad32, gen_movel_ds_ea, dbrr),

  move_l_as_dad(0x2148, 0xf1f8, ea_dad32, gen_movel_as_ea, dbrr),

  move_l_ais_dad(0x2150, 0xf1f8, ea_ais32_read, gen_movel_dt_ea, ea_dad32),

  move_l_aips_dad(0x2158, 0xf1f8, ea_aips32_read, gen_movel_dt_ea, ea_dad32),

  move_l_pais_dad(0x2160, 0xf1f8, ea_pais32_read, gen_movel_dt_ea, ea_dad32),

  move_l_das_dad(0x2168, 0xf1f8, ea_das32_read, gen_movel_dt_ea, ea_dad32),

  move_l_dais_dad(0x2170, 0xf1f8, ea_dais32_read, gen_movel_dt_ea, ea_dad32),

  move_l_adr16_dad(0x2178, 0xf1ff, ea_adr16s32_read, gen_movel_dt_ea, ea_dad32),

  move_l_adr32_dad(0x2179, 0xf1ff, ea_adr32s32_read, gen_movel_dt_ea, ea_dad32),

  move_l_dpc_dad(0x217a, 0xf1ff, ea_dpc32_read, gen_movel_dt_ea, ea_dad32),

  move_l_dpci_dad(0x217b, 0xf1ff, ea_dpci32_read, gen_movel_dt_ea, ea_dad32),

  move_l_imm32_dad(0x217c, 0xf1ff, ea_imm32_read, gen_movel_dt_ea, ea_dad32),

  move_l_ds_daid(0x2180, 0xf1f8, ea_daid32, gen_movel_ds_ea, dbrr),

  move_l_as_daid(0x2188, 0xf1f8, ea_daid32, gen_movel_as_ea, dbrr),

  move_l_ais_daid(0x2190, 0xf1f8, ea_ais32_read, gen_movel_dt_ea, ea_daid32),

  move_l_aips_daid(0x2198, 0xf1f8, ea_aips32_read, gen_movel_dt_ea, ea_daid32),

  move_l_pais_daid(0x21a0, 0xf1f8, ea_pais32_read, gen_movel_dt_ea, ea_daid32),

  move_l_das_daid(0x21a8, 0xf1f8, ea_das32_read, gen_movel_dt_ea, ea_daid32),

  move_l_dais_daid(0x21b0, 0xf1f8, ea_dais32_read, gen_movel_dt_ea, ea_daid32),

  move_l_adr16_daid(0x21b8, 0xf1ff, ea_adr16s32_read, gen_movel_dt_ea, ea_daid32),

  move_l_adr32_daid(0x21b9, 0xf1ff, ea_adr32s32_read, gen_movel_dt_ea, ea_daid32),

  move_l_dpc_daid(0x21ba, 0xf1ff, ea_dpc32_read, gen_movel_dt_ea, ea_daid32),

  move_l_dpci_daid(0x21bb, 0xf1ff, ea_dpci32_read, gen_movel_dt_ea, ea_daid32),

  move_l_imm32_daid(0x21bc, 0xf1ff, ea_imm32_read, gen_movel_dt_ea, ea_daid32),

  move_l_ds_adr16(0x21c0, 0xfff8, ea_adr16d32, gen_movel_ds_ea, dbrr),

  move_l_as_adr16(0x21c8, 0xfff8, ea_adr16d32, gen_movel_as_ea, dbrr),

  move_l_ais_adr16(0x21d0, 0xfff8, ea_ais32_read, gen_movel_dt_ea, ea_adr16d32),

  move_l_aips_adr16(0x21d8, 0xfff8, ea_aips32_read, gen_movel_dt_ea, ea_adr16d32),

  move_l_pais_adr16(0x21e0, 0xfff8, ea_pais32_read, gen_movel_dt_ea, ea_adr16d32),

  move_l_das_adr16(0x21e8, 0xfff8, ea_das32_read, gen_movel_dt_ea, ea_adr16d32),

  move_l_dais_adr16(0x21f0, 0xfff8, ea_dais32_read, gen_movel_dt_ea, ea_adr16d32),

  move_l_adr16_adr16(0x21f8, 0xffff, ea_adr16s32_read, gen_movel_dt_ea, ea_adr16d32),

  move_l_adr32_adr16(0x21f9, 0xffff, ea_adr32s32_read, gen_movel_dt_ea, ea_adr16d32),

  move_l_dpc_adr16(0x21fa, 0xffff, ea_dpc32_read, gen_movel_dt_ea, ea_adr16d32),

  move_l_dpci_adr16(0x21fb, 0xffff, ea_dpci32_read, gen_movel_dt_ea, ea_adr16d32),

  move_l_imm32_adr16(0x21fc, 0xffff, ea_imm32_read, gen_movel_dt_ea, ea_adr16d32),

  move_l_ds_adr32(0x23c0, 0xfff8, ea_adr32d32, gen_movel_ds_ea, dbrr),

  move_l_as_adr32(0x23c8, 0xfff8, ea_adr32d32, gen_movel_as_ea, dbrr),

  move_l_ais_adr32(0x23d0, 0xfff8, ea_ais32_read, gen_movel_dt_ea, ea_adr32d32),

  move_l_aips_adr32(0x23d8, 0xfff8, ea_aips32_read, gen_movel_dt_ea, ea_adr32d32),

  move_l_pais_adr32(0x23e0, 0xfff8, ea_pais32_read, gen_movel_dt_ea, ea_adr32d32),

  move_l_das_adr32(0x23e8, 0xfff8, ea_das32_read, gen_movel_dt_ea, ea_adr32d32),

  move_l_dais_adr32(0x23f0, 0xfff8, ea_dais32_read, gen_movel_dt_ea, ea_adr32d32),

  move_l_adr16_adr32(0x23f8, 0xffff, ea_adr16s32_read, gen_movel_dt_ea, ea_adr32d32),

  move_l_adr32_adr32(0x23f9, 0xffff, ea_adr32s32_read, gen_movel_dt_ea, ea_adr32d32),

  move_l_dpc_adr32(0x23fa, 0xffff, ea_dpc32_read, gen_movel_dt_ea, ea_adr32d32),

  move_l_dpci_adr32(0x23fb, 0xffff, ea_dpci32_read, gen_movel_dt_ea, ea_adr32d32),

  move_l_imm32_adr32(0x23fc, 0xffff, ea_imm32_read, gen_movel_dt_ea, ea_adr32d32),

  move_w_ds_dd(0x3000, 0xf1f8, gen_movew_ds_dd, dbrr, dbrr),

  move_w_as_dd(0x3008, 0xf1f8, gen_movew_as_dd, dbrr, dbrr),

  move_w_ais_dd(0x3010, 0xf1f8, ea_ais16_read, dbrr, gen_movew_dt_dd),

  move_w_aips_dd(0x3018, 0xf1f8, ea_aips16_read, dbrr, gen_movew_dt_dd),

  move_w_pais_dd(0x3020, 0xf1f8, ea_pais16_read, dbrr, gen_movew_dt_dd),

  move_w_das_dd(0x3028, 0xf1f8, ea_das16_read, dbrr, gen_movew_dt_dd),

  move_w_dais_dd(0x3030, 0xf1f8, ea_dais16_read, dbrr, gen_movew_dt_dd),

  move_w_adr16_dd(0x3038, 0xf1ff, ea_adr16s16_read, dbrr, gen_movew_dt_dd),

  move_w_adr32_dd(0x3039, 0xf1ff, ea_adr32s16_read, dbrr, gen_movew_dt_dd),

  move_w_dpc_dd(0x303a, 0xf1ff, ea_dpc16_read, dbrr, gen_movew_dt_dd),

  move_w_dpci_dd(0x303b, 0xf1ff, ea_dpci16_read, dbrr, gen_movew_dt_dd),

  move_w_imm16_dd(0x303c, 0xf1ff, ea_imm16_read, dbrr, gen_movew_dt_dd),

  movea_w_ds_ad(0x3040, 0xf1f8, gen_movew_ds_ad, dbrr, dbrr),

  movea_w_as_ad(0x3048, 0xf1f8, gen_movew_as_ad, dbrr, dbrr),

  movea_w_ais_ad(0x3050, 0xf1f8, ea_ais16_read, dbrr, gen_movew_dt_ad),

  movea_w_aips_ad(0x3058, 0xf1f8, ea_aips16_read, dbrr, gen_movew_dt_ad),

  movea_w_pais_ad(0x3060, 0xf1f8, ea_pais16_read, dbrr, gen_movew_dt_ad),

  movea_w_das_ad(0x3068, 0xf1f8, ea_das16_read, dbrr, gen_movew_dt_ad),

  movea_w_dais_ad(0x3070, 0xf1f8, ea_dais16_read, dbrr, gen_movew_dt_ad),

  movea_w_adr16_ad(0x3078, 0xf1ff, ea_adr16s16_read, dbrr, gen_movew_dt_ad),

  movea_w_adr32_ad(0x3079, 0xf1ff, ea_adr32s16_read, dbrr, gen_movew_dt_ad),

  movea_w_dpc_ad(0x307a, 0xf1ff, ea_dpc16_read, dbrr, gen_movew_dt_ad),

  movea_w_dpci_ad(0x307b, 0xf1ff, ea_dpci16_read, dbrr, gen_movew_dt_ad),

  movea_w_imm16_ad(0x307c, 0xf1ff, ea_imm16_read, dbrr, gen_movew_dt_ad),

  move_w_ds_aid(0x3080, 0xf1f8, ea_aid16, gen_movew_ds_ea, dbrr),

  move_w_as_aid(0x3088, 0xf1f8, ea_aid16, gen_movew_as_ea, dbrr),

  move_w_ais_aid(0x3090, 0xf1f8, ea_ais16_read, gen_movew_dt_ea, ea_aid16),

  move_w_aips_aid(0x3098, 0xf1f8, ea_aips16_read, gen_movew_dt_ea, ea_aid16),

  move_w_pais_aid(0x30a0, 0xf1f8, ea_pais16_read, gen_movew_dt_ea, ea_aid16),

  move_w_das_aid(0x30a8, 0xf1f8, ea_das16_read, gen_movew_dt_ea, ea_aid16),

  move_w_dais_aid(0x30b0, 0xf1f8, ea_dais16_read, gen_movew_dt_ea, ea_aid16),

  move_w_adr16_aid(0x30b8, 0xf1ff, ea_adr16s16_read, gen_movew_dt_ea, ea_aid16),

  move_w_adr32_aid(0x30b9, 0xf1ff, ea_adr32s16_read, gen_movew_dt_ea, ea_aid16),

  move_w_dpc_aid(0x30ba, 0xf1ff, ea_dpc16_read, gen_movew_dt_ea, ea_aid16),

  move_w_dpci_aid(0x30bb, 0xf1ff, ea_dpci16_read, gen_movew_dt_ea, ea_aid16),

  move_w_imm16_aid(0x30bc, 0xf1ff, ea_imm16_read, gen_movew_dt_ea, ea_aid16),

  move_w_ds_aipd(0x30c0, 0xf1f8, ea_aipd16, gen_movew_ds_ea, dbrr),

  move_w_as_aipd(0x30c8, 0xf1f8, ea_aipd16, gen_movew_as_ea, dbrr),

  move_w_ais_aipd(0x30d0, 0xf1f8, ea_ais16_read, gen_movew_dt_ea, ea_aipd16),

  move_w_aips_aipd(0x30d8, 0xf1f8, ea_aips16_read, gen_movew_dt_ea, ea_aipd16),

  move_w_pais_aipd(0x30e0, 0xf1f8, ea_pais16_read, gen_movew_dt_ea, ea_aipd16),

  move_w_das_aipd(0x30e8, 0xf1f8, ea_das16_read, gen_movew_dt_ea, ea_aipd16),

  move_w_dais_aipd(0x30f0, 0xf1f8, ea_dais16_read, gen_movew_dt_ea, ea_aipd16),

  move_w_adr16_aipd(0x30f8, 0xf1ff, ea_adr16s16_read, gen_movew_dt_ea, ea_aipd16),

  move_w_adr32_aipd(0x30f9, 0xf1ff, ea_adr32s16_read, gen_movew_dt_ea, ea_aipd16),

  move_w_dpc_aipd(0x30fa, 0xf1ff, ea_dpc16_read, gen_movew_dt_ea, ea_aipd16),

  move_w_dpci_aipd(0x30fb, 0xf1ff, ea_dpci16_read, gen_movew_dt_ea, ea_aipd16),

  move_w_imm16_aipd(0x30fc, 0xf1ff, ea_imm16_read, gen_movew_dt_ea, ea_aipd16),

  move_w_ds_paid(0x3100, 0xf1f8, ea_paid16, gen_movew_ds_ea, dbrr),

  move_w_as_paid(0x3108, 0xf1f8, ea_paid16, gen_movew_as_ea, dbrr),

  move_w_ais_paid(0x3110, 0xf1f8, ea_ais16_read, gen_movew_dt_ea, ea_paid16),

  move_w_aips_paid(0x3118, 0xf1f8, ea_aips16_read, gen_movew_dt_ea, ea_paid16),

  move_w_pais_paid(0x3120, 0xf1f8, ea_pais16_read, gen_movew_dt_ea, ea_paid16),

  move_w_das_paid(0x3128, 0xf1f8, ea_das16_read, gen_movew_dt_ea, ea_paid16),

  move_w_dais_paid(0x3130, 0xf1f8, ea_dais16_read, gen_movew_dt_ea, ea_paid16),

  move_w_adr16_paid(0x3138, 0xf1ff, ea_adr16s16_read, gen_movew_dt_ea, ea_paid16),

  move_w_adr32_paid(0x3139, 0xf1ff, ea_adr32s16_read, gen_movew_dt_ea, ea_paid16),

  move_w_dpc_paid(0x313a, 0xf1ff, ea_dpc16_read, gen_movew_dt_ea, ea_paid16),

  move_w_dpci_paid(0x313b, 0xf1ff, ea_dpci16_read, gen_movew_dt_ea, ea_paid16),

  move_w_imm16_paid(0x313c, 0xf1ff, ea_imm16_read, gen_movew_dt_ea, ea_paid16),

  move_w_ds_dad(0x3140, 0xf1f8, ea_dad16, gen_movew_ds_ea, dbrr),

  move_w_as_dad(0x3148, 0xf1f8, ea_dad16, gen_movew_as_ea, dbrr),

  move_w_ais_dad(0x3150, 0xf1f8, ea_ais16_read, gen_movew_dt_ea, ea_dad16),

  move_w_aips_dad(0x3158, 0xf1f8, ea_aips16_read, gen_movew_dt_ea, ea_dad16),

  move_w_pais_dad(0x3160, 0xf1f8, ea_pais16_read, gen_movew_dt_ea, ea_dad16),

  move_w_das_dad(0x3168, 0xf1f8, ea_das16_read, gen_movew_dt_ea, ea_dad16),

  move_w_dais_dad(0x3170, 0xf1f8, ea_dais16_read, gen_movew_dt_ea, ea_dad16),

  move_w_adr16_dad(0x3178, 0xf1ff, ea_adr16s16_read, gen_movew_dt_ea, ea_dad16),

  move_w_adr32_dad(0x3179, 0xf1ff, ea_adr32s16_read, gen_movew_dt_ea, ea_dad16),

  move_w_dpc_dad(0x317a, 0xf1ff, ea_dpc16_read, gen_movew_dt_ea, ea_dad16),

  move_w_dpci_dad(0x317b, 0xf1ff, ea_dpci16_read, gen_movew_dt_ea, ea_dad16),

  move_w_imm16_dad(0x317c, 0xf1ff, ea_imm16_read, gen_movew_dt_ea, ea_dad16),

  move_w_ds_daid(0x3180, 0xf1f8, ea_daid16, gen_movew_ds_ea, dbrr),

  move_w_as_daid(0x3188, 0xf1f8, ea_daid16, gen_movew_as_ea, dbrr),

  move_w_ais_daid(0x3190, 0xf1f8, ea_ais16_read, gen_movew_dt_ea, ea_daid16),

  move_w_aips_daid(0x3198, 0xf1f8, ea_aips16_read, gen_movew_dt_ea, ea_daid16),

  move_w_pais_daid(0x31a0, 0xf1f8, ea_pais16_read, gen_movew_dt_ea, ea_daid16),

  move_w_das_daid(0x31a8, 0xf1f8, ea_das16_read, gen_movew_dt_ea, ea_daid16),

  move_w_dais_daid(0x31b0, 0xf1f8, ea_dais16_read, gen_movew_dt_ea, ea_daid16),

  move_w_adr16_daid(0x31b8, 0xf1ff, ea_adr16s16_read, gen_movew_dt_ea, ea_daid16),

  move_w_adr32_daid(0x31b9, 0xf1ff, ea_adr32s16_read, gen_movew_dt_ea, ea_daid16),

  move_w_dpc_daid(0x31ba, 0xf1ff, ea_dpc16_read, gen_movew_dt_ea, ea_daid16),

  move_w_dpci_daid(0x31bb, 0xf1ff, ea_dpci16_read, gen_movew_dt_ea, ea_daid16),

  move_w_imm16_daid(0x31bc, 0xf1ff, ea_imm16_read, gen_movew_dt_ea, ea_daid16),

  move_w_ds_adr16(0x31c0, 0xfff8, ea_adr16d16, gen_movew_ds_ea, dbrr),

  move_w_as_adr16(0x31c8, 0xfff8, ea_adr16d16, gen_movew_as_ea, dbrr),

  move_w_ais_adr16(0x31d0, 0xfff8, ea_ais16_read, gen_movew_dt_ea, ea_adr16d16),

  move_w_aips_adr16(0x31d8, 0xfff8, ea_aips16_read, gen_movew_dt_ea, ea_adr16d16),

  move_w_pais_adr16(0x31e0, 0xfff8, ea_pais16_read, gen_movew_dt_ea, ea_adr16d16),

  move_w_das_adr16(0x31e8, 0xfff8, ea_das16_read, gen_movew_dt_ea, ea_adr16d16),

  move_w_dais_adr16(0x31f0, 0xfff8, ea_dais16_read, gen_movew_dt_ea, ea_adr16d16),

  move_w_adr16_adr16(0x31f8, 0xffff, ea_adr16s16_read, gen_movew_dt_ea, ea_adr16d16),

  move_w_adr32_adr16(0x31f9, 0xffff, ea_adr32s16_read, gen_movew_dt_ea, ea_adr16d16),

  move_w_dpc_adr16(0x31fa, 0xffff, ea_dpc16_read, gen_movew_dt_ea, ea_adr16d16),

  move_w_dpci_adr16(0x31fb, 0xffff, ea_dpci16_read, gen_movew_dt_ea, ea_adr16d16),

  move_w_imm16_adr16(0x31fc, 0xffff, ea_imm16_read, gen_movew_dt_ea, ea_adr16d16),

  move_w_ds_adr32(0x33c0, 0xfff8, ea_adr32d16, gen_movew_ds_ea, dbrr),

  move_w_as_adr32(0x33c8, 0xfff8, ea_adr32d16, gen_movew_as_ea, dbrr),

  move_w_ais_adr32(0x33d0, 0xfff8, ea_ais16_read, gen_movew_dt_ea, ea_adr32d16),

  move_w_aips_adr32(0x33d8, 0xfff8, ea_aips16_read, gen_movew_dt_ea, ea_adr32d16),

  move_w_pais_adr32(0x33e0, 0xfff8, ea_pais16_read, gen_movew_dt_ea, ea_adr32d16),

  move_w_das_adr32(0x33e8, 0xfff8, ea_das16_read, gen_movew_dt_ea, ea_adr32d16),

  move_w_dais_adr32(0x33f0, 0xfff8, ea_dais16_read, gen_movew_dt_ea, ea_adr32d16),

  move_w_adr16_adr32(0x33f8, 0xffff, ea_adr16s16_read, gen_movew_dt_ea, ea_adr32d16),

  move_w_adr32_adr32(0x33f9, 0xffff, ea_adr32s16_read, gen_movew_dt_ea, ea_adr32d16),

  move_w_dpc_adr32(0x33fa, 0xffff, ea_dpc16_read, gen_movew_dt_ea, ea_adr32d16),

  move_w_dpci_adr32(0x33fb, 0xffff, ea_dpci16_read, gen_movew_dt_ea, ea_adr32d16),

  move_w_imm16_adr32(0x33fc, 0xffff, ea_imm16_read, gen_movew_dt_ea, ea_adr32d16),

  negx_b_ds(0x4000, 0xfff8, gen_negxb_ds, dbrr, dbrr),

  negx_b_ais(0x4010, 0xfff8, ea_ais8_read, dbrr, gen_negxb_ea),

  negx_b_aips(0x4018, 0xfff8, ea_aips8_read, dbrr, gen_negxb_ea),

  negx_b_pais(0x4020, 0xfff8, ea_pais8_read, dbrr, gen_negxb_ea),

  negx_b_das(0x4028, 0xfff8, ea_das8_read, dbrr, gen_negxb_ea),

  negx_b_dais(0x4030, 0xfff8, ea_dais8_read, dbrr, gen_negxb_ea),

  negx_b_adr16(0x4038, 0xffff, ea_adr16s8_read, dbrr, gen_negxb_ea),

  negx_b_adr32(0x4039, 0xffff, ea_adr32s8_read, dbrr, gen_negxb_ea),

  negx_w_ds(0x4040, 0xfff8, gen_negxw_ds, dbrr, dbrr),

  negx_w_ais(0x4050, 0xfff8, ea_ais16_read, dbrr, gen_negxw_ea),

  negx_w_aips(0x4058, 0xfff8, ea_aips16_read, dbrr, gen_negxw_ea),

  negx_w_pais(0x4060, 0xfff8, ea_pais16_read, dbrr, gen_negxw_ea),

  negx_w_das(0x4068, 0xfff8, ea_das16_read, dbrr, gen_negxw_ea),

  negx_w_dais(0x4070, 0xfff8, ea_dais16_read, dbrr, gen_negxw_ea),

  negx_w_adr16(0x4078, 0xffff, ea_adr16s16_read, dbrr, gen_negxw_ea),

  negx_w_adr32(0x4079, 0xffff, ea_adr32s16_read, dbrr, gen_negxw_ea),

  negx_l_ds(0x4080, 0xfff8, gen_negxl_ds, dbrr, dbrr),

  negx_l_ais(0x4090, 0xfff8, ea_ais32_read, dbrr, gen_negxl_ea),

  negx_l_aips(0x4098, 0xfff8, ea_aips32_read, dbrr, gen_negxl_ea),

  negx_l_pais(0x40a0, 0xfff8, ea_pais32_read, dbrr, gen_negxl_ea),

  negx_l_das(0x40a8, 0xfff8, ea_das32_read, dbrr, gen_negxl_ea),

  negx_l_dais(0x40b0, 0xfff8, ea_dais32_read, dbrr, gen_negxl_ea),

  negx_l_adr16(0x40b8, 0xffff, ea_adr16s32_read, dbrr, gen_negxl_ea),

  negx_l_adr32(0x40b9, 0xffff, ea_adr32s32_read, dbrr, gen_negxl_ea),

  move_sr_ds(0x40c0, 0xfff8, gen_movew_sr_ds, dbrr, dbrr),

  move_sr_ais(0x40d0, 0xfff8, ea_ais16, dbrr, gen_movew_sr_ea),

  move_sr_aips(0x40d8, 0xfff8, ea_aips16, dbrr, gen_movew_sr_ea),

  move_sr_pais(0x40e0, 0xfff8, ea_pais16, dbrr, gen_movew_sr_ea),

  move_sr_das(0x40e8, 0xfff8, ea_das16, dbrr, gen_movew_sr_ea),

  move_sr_dais(0x40f0, 0xfff8, ea_dais16, dbrr, gen_movew_sr_ea),

  move_sr_adr16(0x40f8, 0xffff, ea_adr16s16, dbrr, gen_movew_sr_ea),

  move_sr_adr32(0x40f9, 0xffff, ea_adr32s16, dbrr, gen_movew_sr_ea),

  chk_w_ds_dd(0x4180, 0xf1f8, op_chk_w_ds, dbrr, dbrr),

  chk_w_ais_dd(0x4190, 0xf1f8, ea_ais16_read, dbrr, op_chk_w_ea),

  chk_w_aips_dd(0x4198, 0xf1f8, ea_aips16_read, dbrr, op_chk_w_ea),

  chk_w_pais_dd(0x41a0, 0xf1f8, ea_pais16_read, dbrr, op_chk_w_ea),

  chk_w_das_dd(0x41a8, 0xf1f8, ea_das16_read, dbrr, op_chk_w_ea),

  chk_w_dais_dd(0x41b0, 0xf1f8, ea_dais16_read, dbrr, op_chk_w_ea),

  chk_w_adr16_dd(0x41b8, 0xf1ff, ea_adr16s16_read, dbrr, op_chk_w_ea),

  chk_w_adr32_dd(0x41b9, 0xf1ff, ea_adr32s16_read, dbrr, op_chk_w_ea),

  chk_w_dpc_dd(0x41ba, 0xf1ff, ea_dpc16_read, dbrr, op_chk_w_ea),

  chk_w_dpci_dd(0x41bb, 0xf1ff, ea_dpci16_read, dbrr, op_chk_w_ea),

  chk_w_imm16_dd(0x41bc, 0xf1ff, ea_imm16_read, dbrr, op_chk_w_ea),

  lea_ais_ad(0x41d0, 0xf1f8, ea_ais16, dbrr, op_lea_ea_ad),

  lea_das_ad(0x41e8, 0xf1f8, ea_das16, dbrr, op_lea_ea_ad),

  lea_dais_ad(0x41f0, 0xf1f8, ea_dais16, dbrr, op_lea_ea_ad),

  lea_adr16_ad(0x41f8, 0xf1ff, ea_adr16s16, dbrr, op_lea_ea_ad),

  lea_adr32_ad(0x41f9, 0xf1ff, ea_adr32s16, dbrr, op_lea_ea_ad),

  lea_dpc_ad(0x41fa, 0xf1ff, ea_dpc16, dbrr, op_lea_ea_ad),

  lea_dpci_ad(0x41fb, 0xf1ff, ea_dpci16, dbrr, op_lea_ea_ad),

  clr_b_ds(0x4200, 0xfff8, op_clrb_ds, dbrr, dbrr),

  clr_b_ais(0x4210, 0xfff8, ea_ais8, dbrr, op_clrb_ea),

  clr_b_aips(0x4218, 0xfff8, ea_aips8, dbrr, op_clrb_ea),

  clr_b_pais(0x4220, 0xfff8, ea_pais8, dbrr, op_clrb_ea),

  clr_b_das(0x4228, 0xfff8, ea_das8, dbrr, op_clrb_ea),

  clr_b_dais(0x4230, 0xfff8, ea_dais8, dbrr, op_clrb_ea),

  clr_b_adr16(0x4238, 0xffff, ea_adr16s8, dbrr, op_clrb_ea),

  clr_b_adr32(0x4239, 0xffff, ea_adr32s8, dbrr, op_clrb_ea),

  clr_w_ds(0x4240, 0xfff8, op_clrw_ds, dbrr, dbrr),

  clr_w_ais(0x4250, 0xfff8, ea_ais16, dbrr, op_clrw_ea),

  clr_w_aips(0x4258, 0xfff8, ea_aips16, dbrr, op_clrw_ea),

  clr_w_pais(0x4260, 0xfff8, ea_pais16, dbrr, op_clrw_ea),

  clr_w_das(0x4268, 0xfff8, ea_das16, dbrr, op_clrw_ea),

  clr_w_dais(0x4270, 0xfff8, ea_dais16, dbrr, op_clrw_ea),

  clr_w_adr16(0x4278, 0xffff, ea_adr16s16, dbrr, op_clrw_ea),

  clr_w_adr32(0x4279, 0xffff, ea_adr32s16, dbrr, op_clrw_ea),

  clr_l_ds(0x4280, 0xfff8, op_clrl_ds, dbrr, dbrr),

  clr_l_ais(0x4290, 0xfff8, ea_ais32, dbrr, op_clrl_ea),

  clr_l_aips(0x4298, 0xfff8, ea_aips32, dbrr, op_clrl_ea),

  clr_l_pais(0x42a0, 0xfff8, ea_pais32, dbrr, op_clrl_ea),

  clr_l_das(0x42a8, 0xfff8, ea_das32, dbrr, op_clrl_ea),

  clr_l_dais(0x42b0, 0xfff8, ea_dais32, dbrr, op_clrl_ea),

  clr_l_adr16(0x42b8, 0xffff, ea_adr16s32, dbrr, op_clrl_ea),

  clr_l_adr32(0x42b9, 0xffff, ea_adr32s32, dbrr, op_clrl_ea),

  move_ccr_ds(0x42c0, 0xfff8, gen_movew_ccr_ds, dbrr, dbrr),

  move_ccr_ais(0x42d0, 0xfff8, ea_ais16, dbrr, gen_movew_ccr_ea),

  move_ccr_aips(0x42d8, 0xfff8, ea_aips16, dbrr, gen_movew_ccr_ea),

  move_ccr_pais(0x42e0, 0xfff8, ea_pais16, dbrr, gen_movew_ccr_ea),

  move_ccr_das(0x42e8, 0xfff8, ea_das16, dbrr, gen_movew_ccr_ea),

  move_ccr_dais(0x42f0, 0xfff8, ea_dais16, dbrr, gen_movew_ccr_ea),

  move_ccr_adr16(0x42f8, 0xffff, ea_adr16s16, dbrr, gen_movew_ccr_ea),

  move_ccr_adr32(0x42f9, 0xffff, ea_adr32s16, dbrr, gen_movew_ccr_ea),

  neg_b_ds(0x4400, 0xfff8, gen_negb_ds, dbrr, dbrr),

  neg_b_ais(0x4410, 0xfff8, ea_ais8_read, dbrr, gen_negb_ea),

  neg_b_aips(0x4418, 0xfff8, ea_aips8_read, dbrr, gen_negb_ea),

  neg_b_pais(0x4420, 0xfff8, ea_pais8_read, dbrr, gen_negb_ea),

  neg_b_das(0x4428, 0xfff8, ea_das8_read, dbrr, gen_negb_ea),

  neg_b_dais(0x4430, 0xfff8, ea_dais8_read, dbrr, gen_negb_ea),

  neg_b_adr16(0x4438, 0xffff, ea_adr16s8_read, dbrr, gen_negb_ea),

  neg_b_adr32(0x4439, 0xffff, ea_adr32s8_read, dbrr, gen_negb_ea),

  neg_w_ds(0x4440, 0xfff8, gen_negw_ds, dbrr, dbrr),

  neg_w_ais(0x4450, 0xfff8, ea_ais16_read, dbrr, gen_negl_ea),

  neg_w_aips(0x4458, 0xfff8, ea_aips16_read, dbrr, gen_negl_ea),

  neg_w_pais(0x4460, 0xfff8, ea_pais16_read, dbrr, gen_negl_ea),

  neg_w_das(0x4468, 0xfff8, ea_das16_read, dbrr, gen_negl_ea),

  neg_w_dais(0x4470, 0xfff8, ea_dais16_read, dbrr, gen_negl_ea),

  neg_w_adr16(0x4478, 0xffff, ea_adr16s16_read, dbrr, gen_negl_ea),

  neg_w_adr32(0x4479, 0xffff, ea_adr32s16_read, dbrr, gen_negl_ea),

  neg_l_ds(0x4480, 0xfff8, gen_negl_ds, dbrr, dbrr),

  neg_l_ais(0x4490, 0xfff8, ea_ais32_read, dbrr, gen_negl_ea),

  neg_l_aips(0x4498, 0xfff8, ea_aips32_read, dbrr, gen_negl_ea),

  neg_l_pais(0x44a0, 0xfff8, ea_pais32_read, dbrr, gen_negl_ea),

  neg_l_das(0x44a8, 0xfff8, ea_das32_read, dbrr, gen_negl_ea),

  neg_l_dais(0x44b0, 0xfff8, ea_dais32_read, dbrr, gen_negl_ea),

  neg_l_adr16(0x44b8, 0xffff, ea_adr16s32_read, dbrr, gen_negl_ea),

  neg_l_adr32(0x44b9, 0xffff, ea_adr32s32_read, dbrr, gen_negl_ea),

  move_ds_ccr(0x44c0, 0xfff8, gen_movew_ds_ccr, dbrr, dbrr),

  move_ais_ccr(0x44d0, 0xfff8, ea_ais16_read, dbrr, gen_movew_dt_ccr),

  move_aips_ccr(0x44d8, 0xfff8, ea_aips16_read, dbrr, gen_movew_dt_ccr),

  move_pais_ccr(0x44e0, 0xfff8, ea_pais16_read, dbrr, gen_movew_dt_ccr),

  move_das_ccr(0x44e8, 0xfff8, ea_das16_read, dbrr, gen_movew_dt_ccr),

  move_dais_ccr(0x44f0, 0xfff8, ea_dais16_read, dbrr, gen_movew_dt_ccr),

  move_adr16_ccr(0x44f8, 0xffff, ea_adr16s16_read, dbrr, gen_movew_dt_ccr),

  move_adr32_ccr(0x44f9, 0xffff, ea_adr32s16_read, dbrr, gen_movew_dt_ccr),

  move_dpc_ccr(0x44fa, 0xffff, ea_dpc16_read, dbrr, gen_movew_dt_ccr),

  move_dpci_ccr(0x44fb, 0xffff, ea_dpci16_read, dbrr, gen_movew_dt_ccr),

  move_imm16_ccr(0x44fc, 0xffff, ea_imm16_read, dbrr, gen_movew_dt_ccr),

  not_b_ds(0x4600, 0xfff8, gen_notb_ds, dbrr, dbrr),

  not_b_ais(0x4610, 0xfff8, ea_ais8_read, dbrr, gen_notb_ea),

  not_b_aips(0x4618, 0xfff8, ea_aips8_read, dbrr, gen_notb_ea),

  not_b_pais(0x4620, 0xfff8, ea_pais8_read, dbrr, gen_notb_ea),

  not_b_das(0x4628, 0xfff8, ea_das8_read, dbrr, gen_notb_ea),

  not_b_dais(0x4630, 0xfff8, ea_dais8_read, dbrr, gen_notb_ea),

  not_b_adr16(0x4638, 0xffff, ea_adr16s8_read, dbrr, gen_notb_ea),

  not_b_adr32(0x4639, 0xffff, ea_adr32s8_read, dbrr, gen_notb_ea),

  not_w_ds(0x4640, 0xfff8, gen_notw_ds, dbrr, dbrr),

  not_w_ais(0x4650, 0xfff8, ea_ais16_read, dbrr, gen_notw_ea),

  not_w_aips(0x4658, 0xfff8, ea_aips16_read, dbrr, gen_notw_ea),

  not_w_pais(0x4660, 0xfff8, ea_pais16_read, dbrr, gen_notw_ea),

  not_w_das(0x4668, 0xfff8, ea_das16_read, dbrr, gen_notw_ea),

  not_w_dais(0x4670, 0xfff8, ea_dais16_read, dbrr, gen_notw_ea),

  not_w_adr16(0x4678, 0xffff, ea_adr16s16_read, dbrr, gen_notw_ea),

  not_w_adr32(0x4679, 0xffff, ea_adr32s16_read, dbrr, gen_notw_ea),

  not_l_ds(0x4680, 0xfff8, gen_notl_ds, dbrr, dbrr),

  not_l_ais(0x4690, 0xfff8, ea_ais32_read, dbrr, gen_notl_ea),

  not_l_aips(0x4698, 0xfff8, ea_aips32_read, dbrr, gen_notl_ea),

  not_l_pais(0x46a0, 0xfff8, ea_pais32_read, dbrr, gen_notl_ea),

  not_l_das(0x46a8, 0xfff8, ea_das32_read, dbrr, gen_notl_ea),

  not_l_dais(0x46b0, 0xfff8, ea_dais32_read, dbrr, gen_notl_ea),

  not_l_adr16(0x46b8, 0xffff, ea_adr16s32_read, dbrr, gen_notl_ea),

  not_l_adr32(0x46b9, 0xffff, ea_adr32s32_read, dbrr, gen_notl_ea),

  move_ds_sr(0x46c0, 0xfff8, gen_movew_ds_sr, dbrr, dbrr),

  move_ais_sr(0x46d0, 0xfff8, ea_ais16_read, dbrr, gen_movew_dt_sr),

  move_aips_sr(0x46d8, 0xfff8, ea_aips16_read, dbrr, gen_movew_dt_sr),

  move_pais_sr(0x46e0, 0xfff8, ea_pais16_read, dbrr, gen_movew_dt_sr),

  move_das_sr(0x46e8, 0xfff8, ea_das16_read, dbrr, gen_movew_dt_sr),

  move_dais_sr(0x46f0, 0xfff8, ea_dais16_read, dbrr, gen_movew_dt_sr),

  move_adr16_sr(0x46f8, 0xffff, ea_adr16s16_read, dbrr, gen_movew_dt_sr),

  move_adr32_sr(0x46f9, 0xffff, ea_adr32s16_read, dbrr, gen_movew_dt_sr),

  move_dpc_sr(0x46fa, 0xffff, ea_dpc16_read, dbrr, gen_movew_dt_sr),

  move_dpci_sr(0x46fb, 0xffff, ea_dpci16_read, dbrr, gen_movew_dt_sr),

  move_imm16_sr(0x46fc, 0xffff, ea_imm16_read, dbrr, gen_movew_dt_sr),

  nbcd_b_ds(0x4800, 0xfff8, gen_nbcdb_ds, dbrr, dbrr),

  link_as_imm32(0x4808, 0xfff8, op_imm32, op_link_as_imm32, dbrr),

  nbcd_b_ais(0x4810, 0xfff8, ea_ais8_read, dbrr, gen_nbcdb_ea),

  nbcd_b_aips(0x4818, 0xfff8, ea_aips8_read, dbrr, gen_nbcdb_ea),

  nbcd_b_pais(0x4820, 0xfff8, ea_pais8_read, dbrr, gen_nbcdb_ea),

  nbcd_b_das(0x4828, 0xfff8, ea_das8_read, dbrr, gen_nbcdb_ea),

  nbcd_b_dais(0x4830, 0xfff8, ea_dais8_read, dbrr, gen_nbcdb_ea),

  nbcd_b_adr16(0x4838, 0xffff, ea_adr16s8_read, dbrr, gen_nbcdb_ea),

  nbcd_b_adr32(0x4839, 0xffff, ea_adr32s8_read, dbrr, gen_nbcdb_ea),

  swap_ds(0x4840, 0xfff8, op_swap_ds, dbrr, dbrr),

  bkpt(0x4848, 0xfff8, op_bkpt, dbrr, dbrr),

  pea_ais(0x4850, 0xfff8, ea_ais16, dbrr, op_pea),

  pea_das(0x4868, 0xfff8, ea_das16, dbrr, op_pea),

  pea_dais(0x4870, 0xfff8, ea_dais16, dbrr, op_pea),

  pea_adr16(0x4878, 0xffff, ea_adr16s16, dbrr, op_pea),

  pea_adr32(0x4879, 0xffff, ea_adr32s16, dbrr, op_pea),

  pea_dpc(0x487a, 0xffff, ea_dpc16, dbrr, op_pea),

  pea_dpci(0x487b, 0xffff, ea_dpci16, dbrr, op_pea),

  ext_w_ds(0x4880, 0xfff8, op_extw_ds, dbrr, dbrr),

  movem_w_list_ais(0x4890, 0xfff8, ea_ais16, dbrr, op_movemw_rr_ea),

  movem_w_listp_pais(0x48a0, 0xfff8, ea_pais16, dbrr, op_movemw_rr_pais),

  movem_w_list_das(0x48a8, 0xfff8, ea_das16, dbrr, op_movemw_rr_ea),

  movem_w_list_dais(0x48b0, 0xfff8, ea_dais16, dbrr, op_movemw_rr_ea),

  movem_w_list_adr16(0x48b8, 0xffff, ea_adr16s16, dbrr, op_movemw_rr_ea),

  movem_w_list_adr32(0x48b9, 0xffff, ea_adr32s16, dbrr, op_movemw_rr_ea),

  movem_w_list_dpc(0x48ba, 0xffff, ea_dpc16, dbrr, op_movemw_rr_ea),

  movem_w_list_dpci(0x48bb, 0xffff, ea_dpci16, dbrr, op_movemw_rr_ea),

  ext_l_ds(0x48c0, 0xfff8, op_extl_ds, dbrr, dbrr),

  movem_l_list_ais(0x48d0, 0xfff8, ea_ais32, dbrr, op_moveml_rr_ea),

  movem_l_listp_pais(0x48e0, 0xfff8, ea_pais32, dbrr, op_moveml_rr_pais),

  movem_l_list_das(0x48e8, 0xfff8, ea_das32, dbrr, op_moveml_rr_ea),

  movem_l_list_dais(0x48f0, 0xfff8, ea_dais32, dbrr, op_moveml_rr_ea),

  movem_l_list_adr16(0x48f8, 0xffff, ea_adr16s32, dbrr, op_moveml_rr_ea),

  movem_l_list_adr32(0x48f9, 0xffff, ea_adr32s32, dbrr, op_moveml_rr_ea),

  movem_l_list_dpc(0x48fa, 0xffff, ea_dpc32, dbrr, op_moveml_rr_ea),

  movem_l_list_dpci(0x48fb, 0xffff, ea_dpci32, dbrr, op_moveml_rr_ea),

  extb_l_ds(0x49c0, 0xfff8, op_extbl_ds, dbrr, dbrr),

  tst_b_ds(0x4a00, 0xfff8, gen_tstb_ds, dbrr, dbrr),

  tst_b_ais(0x4a10, 0xfff8, ea_ais8_read, dbrr, gen_tstb_ea),

  tst_b_aips(0x4a18, 0xfff8, ea_aips8_read, dbrr, gen_tstb_ea),

  tst_b_pais(0x4a20, 0xfff8, ea_pais8_read, dbrr, gen_tstb_ea),

  tst_b_das(0x4a28, 0xfff8, ea_das8_read, dbrr, gen_tstb_ea),

  tst_b_dais(0x4a30, 0xfff8, ea_dais8_read, dbrr, gen_tstb_ea),

  tst_b_adr16(0x4a38, 0xffff, ea_adr16s8_read, dbrr, gen_tstb_ea),

  tst_b_adr32(0x4a39, 0xffff, ea_adr32s8_read, dbrr, gen_tstb_ea),

  tst_w_ds(0x4a40, 0xfff8, gen_tstw_ds, dbrr, dbrr),

  tst_w_ais(0x4a50, 0xfff8, ea_ais16_read, dbrr, gen_tstw_ea),

  tst_w_aips(0x4a58, 0xfff8, ea_aips16_read, dbrr, gen_tstw_ea),

  tst_w_pais(0x4a60, 0xfff8, ea_pais16_read, dbrr, gen_tstw_ea),

  tst_w_das(0x4a68, 0xfff8, ea_das16_read, dbrr, gen_tstw_ea),

  tst_w_dais(0x4a70, 0xfff8, ea_dais16_read, dbrr, gen_tstw_ea),

  tst_w_adr16(0x4a78, 0xffff, ea_adr16s16_read, dbrr, gen_tstw_ea),

  tst_w_adr32(0x4a79, 0xffff, ea_adr32s16_read, dbrr, gen_tstw_ea),

  tst_l_ds(0x4a80, 0xfff8, gen_tstl_ds, dbrr, dbrr),

  tst_l_ais(0x4a90, 0xfff8, ea_ais32_read, dbrr, gen_tstl_ea),

  tst_l_aips(0x4a98, 0xfff8, ea_aips32_read, dbrr, gen_tstl_ea),

  tst_l_pais(0x4aa0, 0xfff8, ea_pais32_read, dbrr, gen_tstl_ea),

  tst_l_das(0x4aa8, 0xfff8, ea_das32_read, dbrr, gen_tstl_ea),

  tst_l_dais(0x4ab0, 0xfff8, ea_dais32_read, dbrr, gen_tstl_ea),

  tst_l_adr16(0x4ab8, 0xffff, ea_adr16s32_read, dbrr, gen_tstl_ea),

  tst_l_adr32(0x4ab9, 0xffff, ea_adr32s32_read, dbrr, gen_tstl_ea),

  illegal(0x4afc, 0xffff, op_illegal, dbrr, dbrr),

  movem_w_ais_list(0x4c90, 0xfff8, ea_ais16, dbrr, op_movemw_ea_rr),

  movem_w_aips_list(0x4c98, 0xfff8, ea_aips16, dbrr, op_movemw_aips_rr),

  movem_w_das_list(0x4ca8, 0xfff8, ea_das16, dbrr, op_movemw_ea_rr),

  movem_w_dais_list(0x4cb0, 0xfff8, ea_dais16, dbrr, op_movemw_ea_rr),

  movem_w_adr16_list(0x4cb8, 0xffff, ea_adr16s16, dbrr, op_movemw_ea_rr),

  movem_w_adr32_list(0x4cb9, 0xffff, ea_adr32s16, dbrr, op_movemw_ea_rr),

  movem_w_dpc_list(0x4cba, 0xffff, ea_dpc16, dbrr, op_movemw_ea_rr),

  movem_w_dpci_list(0x4cbb, 0xffff, ea_dpci16, dbrr, op_movemw_ea_rr),

  movem_l_ais_list(0x4cd0, 0xfff8, ea_ais32, dbrr, op_moveml_ea_rr),

  movem_l_aips_list(0x4cd8, 0xfff8, ea_aips32, dbrr, op_moveml_aips_rr),

  movem_l_das_list(0x4ce8, 0xfff8, ea_das32, dbrr, op_moveml_ea_rr),

  movem_l_dais_list(0x4cf0, 0xfff8, ea_dais32, dbrr, op_moveml_ea_rr),

  movem_l_adr16_list(0x4cf8, 0xffff, ea_adr16s32, dbrr, op_moveml_ea_rr),

  movem_l_adr32_list(0x4cf9, 0xffff, ea_adr32s32, dbrr, op_moveml_ea_rr),

  movem_l_dpc_list(0x4cfa, 0xffff, ea_dpc32, dbrr, op_moveml_ea_rr),

  movem_l_dpci_list(0x4cfb, 0xffff, ea_dpci32, dbrr, op_moveml_ea_rr),

  trap_imm4(0x4e40, 0xfff0, op_trap, dbrr, dbrr),

  link_as_imm16(0x4e50, 0xfff8, op_imm16, op_link_as_imm16, dbrr),

  unlk_as(0x4e58, 0xfff8, op_unlk_as, dbrr, dbrr),

  move_as_usp(0x4e60, 0xfff8, op_move_as_usp, dbrr, dbrr),

  move_usp_as(0x4e68, 0xfff8, op_move_usp_as, dbrr, dbrr),

  reset(0x4e70, 0xffff, op_reset, dbrr, dbrr),

  nop(0x4e71, 0xffff, op_nop, dbrr, dbrr),

  stop_i16u(0x4e72, 0xffff, op_imm16, op_stop, dbrr),

  rte(0x4e73, 0xffff, op_rte, dbrr, dbrr),

  rts(0x4e75, 0xffff, op_rts, dbrr, dbrr),

  trapv(0x4e76, 0xffff, op_trapv, dbrr, dbrr),

  rtr(0x4e77, 0xffff, op_rtr, dbrr, dbrr),

  movec_cr_rz(0x4e7a, 0xffff, op_movec_cr_rz, dbrr, dbrr),

  movec_rz_cr(0x4e7b, 0xffff, op_movec_rz_cr, dbrr, dbrr),

  jsr_ais(0x4e90, 0xfff8, ea_ais16, dbrr, op_jsr),

  jsr_das(0x4ea8, 0xfff8, ea_das16, dbrr, op_jsr),

  jsr_dais(0x4eb0, 0xfff8, ea_dais16, dbrr, op_jsr),

  jsr_adr16(0x4eb8, 0xffff, ea_adr16s16, dbrr, op_jsr),

  jsr_adr32(0x4eb9, 0xffff, ea_adr32s16, dbrr, op_jsr),

  jsr_dpc(0x4eba, 0xffff, ea_dpc16, dbrr, op_jsr),

  jsr_dpci(0x4ebb, 0xffff, ea_dpci16, dbrr, op_jsr),

  jmp_ais(0x4ed0, 0xfff8, ea_ais16, dbrr, op_jmp),

  jmp_das(0x4ee8, 0xfff8, ea_das16, dbrr, op_jmp),

  jmp_dais(0x4ef0, 0xfff8, ea_dais16, dbrr, op_jmp),

  jmp_adr16(0x4ef8, 0xffff, ea_adr16s16, dbrr, op_jmp),

  jmp_adr32(0x4ef9, 0xffff, ea_adr32s16, dbrr, op_jmp),

  jmp_dpc(0x4efa, 0xffff, ea_dpc16, dbrr, op_jmp),

  jmp_dpci(0x4efb, 0xffff, ea_dpci16, dbrr, op_jmp),

  addq_b_imm3_ds(0x5000, 0xf1f8, gen_addb_ir_ds, dbrr, dbrr),

  addq_b_imm3_ais(0x5010, 0xf1f8, ea_ais8_read, dbrr, gen_addb_ir_ea),

  addq_b_imm3_aips(0x5018, 0xf1f8, ea_aips8_read, dbrr, gen_addb_ir_ea),

  addq_b_imm3_pais(0x5020, 0xf1f8, ea_pais8_read, dbrr, gen_addb_ir_ea),

  addq_b_imm3_das(0x5028, 0xf1f8, ea_das8_read, dbrr, gen_addb_ir_ea),

  addq_b_imm3_dais(0x5030, 0xf1f8, ea_dais8_read, dbrr, gen_addb_ir_ea),

  addq_b_imm3_adr16(0x5038, 0xf1ff, ea_adr16s8_read, dbrr, gen_addb_ir_ea),

  addq_b_imm3_adr32(0x5039, 0xf1ff, ea_adr32s8_read, dbrr, gen_addb_ir_ea),

  addq_w_imm3_ds(0x5040, 0xf1f8, gen_addw_ir_ds, dbrr, dbrr),

  addq_w_imm3_as(0x5048, 0xf1f8, gen_addw_ir_as, dbrr, dbrr),

  addq_w_imm3_ais(0x5050, 0xf1f8, ea_ais16_read, dbrr, gen_addw_ir_ea),

  addq_w_imm3_aips(0x5058, 0xf1f8, ea_aips16_read, dbrr, gen_addw_ir_ea),

  addq_w_imm3_pais(0x5060, 0xf1f8, ea_pais16_read, dbrr, gen_addw_ir_ea),

  addq_w_imm3_das(0x5068, 0xf1f8, ea_das16_read, dbrr, gen_addw_ir_ea),

  addq_w_imm3_dais(0x5070, 0xf1f8, ea_dais16_read, dbrr, gen_addw_ir_ea),

  addq_w_imm3_adr16(0x5078, 0xf1ff, ea_adr16s16_read, dbrr, gen_addw_ir_ea),

  addq_w_imm3_adr32(0x5079, 0xf1ff, ea_adr32s16_read, dbrr, gen_addw_ir_ea),

  addq_l_imm3_ds(0x5080, 0xf1f8, gen_addl_ir_ds, dbrr, dbrr),

  addq_l_imm3_as(0x5088, 0xf1f8, gen_addl_ir_as, dbrr, dbrr),

  addq_l_imm3_ais(0x5090, 0xf1f8, ea_ais32_read, dbrr, gen_addl_ir_ea),

  addq_l_imm3_aips(0x5098, 0xf1f8, ea_aips32_read, dbrr, gen_addl_ir_ea),

  addq_l_imm3_pais(0x50a0, 0xf1f8, ea_pais32_read, dbrr, gen_addl_ir_ea),

  addq_l_imm3_das(0x50a8, 0xf1f8, ea_das32_read, dbrr, gen_addl_ir_ea),

  addq_l_imm3_dais(0x50b0, 0xf1f8, ea_dais32_read, dbrr, gen_addl_ir_ea),

  addq_l_imm3_adr16(0x50b8, 0xf1ff, ea_adr16s32_read, dbrr, gen_addl_ir_ea),

  addq_l_imm3_adr32(0x50b9, 0xf1ff, ea_adr32s32_read, dbrr, gen_addl_ir_ea),

  scc_b_ds(0x50c0, 0xf0f8, op_scc_b_ds, dbrr, dbrr),

  dbcc(0x50c8, 0xf0f8, op_dbcc, dbrr, dbrr),

  scc_b_ais(0x50d0, 0xf0f8, ea_ais8, dbrr, op_scc_b_ea),

  scc_b_aips(0x50d8, 0xf0f8, ea_aips8, dbrr, op_scc_b_ea),

  scc_b_pais(0x50e0, 0xf0f8, ea_pais8, dbrr, op_scc_b_ea),

  scc_b_das(0x50e8, 0xf0f8, ea_das8, dbrr, op_scc_b_ea),

  scc_b_dais(0x50f0, 0xf0f8, ea_dais8, dbrr, op_scc_b_ea),

  scc_b_adr16(0x50f8, 0xf0ff, ea_adr16s8, dbrr, op_scc_b_ea),

  scc_b_adr32(0x50f9, 0xf0ff, ea_adr32s8, dbrr, op_scc_b_ea),

  trapcc16(0x50fa, 0xf0ff, op_trapcc16, dbrr, dbrr),

  trapcc32(0x50fb, 0xf0ff, op_trapcc32, dbrr, dbrr),

  trapcc(0x50fc, 0xf0ff, op_trapcc, dbrr, dbrr),

  subq_b_imm3_ds(0x5100, 0xf1f8, gen_subb_ir_ds, dbrr, dbrr),

  subq_b_imm3_ais(0x5110, 0xf1f8, ea_ais8_read, dbrr, gen_subb_ir_ea),

  subq_b_imm3_aips(0x5118, 0xf1f8, ea_aips8_read, dbrr, gen_subb_ir_ea),

  subq_b_imm3_pais(0x5120, 0xf1f8, ea_pais8_read, dbrr, gen_subb_ir_ea),

  subq_b_imm3_das(0x5128, 0xf1f8, ea_das8_read, dbrr, gen_subb_ir_ea),

  subq_b_imm3_dais(0x5130, 0xf1f8, ea_dais8_read, dbrr, gen_subb_ir_ea),

  subq_b_imm3_adr16(0x5138, 0xf1ff, ea_adr16s8_read, dbrr, gen_subb_ir_ea),

  subq_b_imm3_adr32(0x5139, 0xf1ff, ea_adr32s8_read, dbrr, gen_subb_ir_ea),

  subq_w_imm3_ds(0x5140, 0xf1f8, gen_subw_ir_ds, dbrr, dbrr),

  subq_w_imm3_as(0x5148, 0xf1f8, gen_subw_ir_as, dbrr, dbrr),

  subq_w_imm3_ais(0x5150, 0xf1f8, ea_ais16_read, dbrr, gen_subw_ir_ea),

  subq_w_imm3_aips(0x5158, 0xf1f8, ea_aips16_read, dbrr, gen_subw_ir_ea),

  subq_w_imm3_pais(0x5160, 0xf1f8, ea_pais16_read, dbrr, gen_subw_ir_ea),

  subq_w_imm3_das(0x5168, 0xf1f8, ea_das16_read, dbrr, gen_subw_ir_ea),

  subq_w_imm3_dais(0x5170, 0xf1f8, ea_dais16_read, dbrr, gen_subw_ir_ea),

  subq_w_imm3_adr16(0x5178, 0xf1ff, ea_adr16s16_read, dbrr, gen_subw_ir_ea),

  subq_w_imm3_adr32(0x5179, 0xf1ff, ea_adr32s16_read, dbrr, gen_subw_ir_ea),

  subq_l_imm3_ds(0x5180, 0xf1f8, gen_subl_ir_ds, dbrr, dbrr),

  subq_l_imm3_as(0x5188, 0xf1f8, gen_subl_ir_as, dbrr, dbrr),

  subq_l_imm3_ais(0x5190, 0xf1f8, ea_ais32_read, dbrr, gen_subl_ir_ea),

  subq_l_imm3_aips(0x5198, 0xf1f8, ea_aips32_read, dbrr, gen_subl_ir_ea),

  subq_l_imm3_pais(0x51a0, 0xf1f8, ea_pais32_read, dbrr, gen_subl_ir_ea),

  subq_l_imm3_das(0x51a8, 0xf1f8, ea_das32_read, dbrr, gen_subl_ir_ea),

  subq_l_imm3_dais(0x51b0, 0xf1f8, ea_dais32_read, dbrr, gen_subl_ir_ea),

  subq_l_imm3_adr16(0x51b8, 0xf1ff, ea_adr16s32_read, dbrr, gen_subl_ir_ea),

  subq_l_imm3_adr32(0x51b9, 0xf1ff, ea_adr32s32_read, dbrr, gen_subl_ir_ea),

  bra_rel16(0x6000, 0xffff, op_imm16, op_bra16, dbrr),

  bcc_rel16(0x6000, 0xf0ff, op_imm16, op_bcc16, dbrr),

  bra_rel8(0x6000, 0xff00, op_bra8, dbrr, dbrr),

  bcc_rel8(0x6000, 0xf000, op_bcc8, dbrr, dbrr),

  bra_rel32(0x60ff, 0xffff, op_imm32, op_bra32, dbrr),

  bcc_rel32(0x60ff, 0xf0ff, op_imm32, op_bcc32, dbrr),

  bsr_rel16(0x6100, 0xffff, op_imm16, op_bsr16, dbrr),

  bsr_rel8(0x6100, 0xff00, op_bsr8, dbrr, dbrr),

  bsr_rel32(0x61ff, 0xffff, op_imm32, op_bsr32, dbrr),

  moveq_imm8o_dd(0x7000, 0xf100, gen_movel_im_dd, dbrr, dbrr),

  or_b_ds_dd(0x8000, 0xf1f8, gen_orb_ds_dd, dbrr, dbrr),

  or_b_ais_dd(0x8010, 0xf1f8, ea_ais8_read, dbrr, gen_orb_dt_dd),

  or_b_aips_dd(0x8018, 0xf1f8, ea_aips8_read, dbrr, gen_orb_dt_dd),

  or_b_pais_dd(0x8020, 0xf1f8, ea_pais8_read, dbrr, gen_orb_dt_dd),

  or_b_das_dd(0x8028, 0xf1f8, ea_das8_read, dbrr, gen_orb_dt_dd),

  or_b_dais_dd(0x8030, 0xf1f8, ea_dais8_read, dbrr, gen_orb_dt_dd),

  or_b_adr16_dd(0x8038, 0xf1ff, ea_adr16s8_read, dbrr, gen_orb_dt_dd),

  or_b_adr32_dd(0x8039, 0xf1ff, ea_adr32s8_read, dbrr, gen_orb_dt_dd),

  or_b_dpc_dd(0x803a, 0xf1ff, ea_dpc8_read, dbrr, gen_orb_dt_dd),

  or_b_dpci_dd(0x803b, 0xf1ff, ea_dpci8_read, dbrr, gen_orb_dt_dd),

  or_b_imm8_dd(0x803c, 0xf1ff, ea_imm8_read, dbrr, gen_orb_dt_dd),

  or_w_ds_dd(0x8040, 0xf1f8, gen_orw_ds_dd, dbrr, dbrr),

  or_w_ais_dd(0x8050, 0xf1f8, ea_ais16_read, dbrr, gen_orw_dt_dd),

  or_w_aips_dd(0x8058, 0xf1f8, ea_aips16_read, dbrr, gen_orw_dt_dd),

  or_w_pais_dd(0x8060, 0xf1f8, ea_pais16_read, dbrr, gen_orw_dt_dd),

  or_w_das_dd(0x8068, 0xf1f8, ea_das16_read, dbrr, gen_orw_dt_dd),

  or_w_dais_dd(0x8070, 0xf1f8, ea_dais16_read, dbrr, gen_orw_dt_dd),

  or_w_adr16_dd(0x8078, 0xf1ff, ea_adr16s16_read, dbrr, gen_orw_dt_dd),

  or_w_adr32_dd(0x8079, 0xf1ff, ea_adr32s16_read, dbrr, gen_orw_dt_dd),

  or_w_dpc_dd(0x807a, 0xf1ff, ea_dpc16_read, dbrr, gen_orw_dt_dd),

  or_w_dpci_dd(0x807b, 0xf1ff, ea_dpci16_read, dbrr, gen_orw_dt_dd),

  or_w_imm16_dd(0x807c, 0xf1ff, ea_imm16_read, dbrr, gen_orw_dt_dd),

  or_l_ds_dd(0x8080, 0xf1f8, gen_orl_ds_dd, dbrr, dbrr),

  or_l_ais_dd(0x8090, 0xf1f8, ea_ais32_read, dbrr, gen_orl_dt_dd),

  or_l_aips_dd(0x8098, 0xf1f8, ea_aips32_read, dbrr, gen_orl_dt_dd),

  or_l_pais_dd(0x80a0, 0xf1f8, ea_pais32_read, dbrr, gen_orl_dt_dd),

  or_l_das_dd(0x80a8, 0xf1f8, ea_das32_read, dbrr, gen_orl_dt_dd),

  or_l_dais_dd(0x80b0, 0xf1f8, ea_dais32_read, dbrr, gen_orl_dt_dd),

  or_l_adr16_dd(0x80b8, 0xf1ff, ea_adr16s32_read, dbrr, gen_orl_dt_dd),

  or_l_adr32_dd(0x80b9, 0xf1ff, ea_adr32s32_read, dbrr, gen_orl_dt_dd),

  or_l_dpc_dd(0x80ba, 0xf1ff, ea_dpc32_read, dbrr, gen_orl_dt_dd),

  or_l_dpci_dd(0x80bb, 0xf1ff, ea_dpci32_read, dbrr, gen_orl_dt_dd),

  or_l_imm32_dd(0x80bc, 0xf1ff, ea_imm32_read, dbrr, gen_orl_dt_dd),

  sbcd_ds_dd(0x8100, 0xf1f8, gen_sbcdb_ds_dd, dbrr, dbrr),

  sbcd_pais_paid(0x8108, 0xf1f8, ea_pais8_read, gen_sbcdb_im_ea, ea_paid8_read),

  or_b_dd_ais(0x8110, 0xf1f8, ea_ais8_read, dbrr, gen_orb_dd_ea),

  or_b_dd_aips(0x8118, 0xf1f8, ea_aips8_read, dbrr, gen_orb_dd_ea),

  or_b_dd_pais(0x8120, 0xf1f8, ea_pais8_read, dbrr, gen_orb_dd_ea),

  or_b_dd_das(0x8128, 0xf1f8, ea_das8_read, dbrr, gen_orb_dd_ea),

  or_b_dd_dais(0x8130, 0xf1f8, ea_dais8_read, dbrr, gen_orb_dd_ea),

  or_b_dd_adr16(0x8138, 0xf1ff, ea_adr16s8_read, dbrr, gen_orb_dd_ea),

  or_b_dd_adr32(0x8139, 0xf1ff, ea_adr32s8_read, dbrr, gen_orb_dd_ea),

  or_w_dd_ais(0x8150, 0xf1f8, ea_ais16_read, dbrr, gen_orw_dd_ea),

  or_w_dd_aips(0x8158, 0xf1f8, ea_aips16_read, dbrr, gen_orw_dd_ea),

  or_w_dd_pais(0x8160, 0xf1f8, ea_pais16_read, dbrr, gen_orw_dd_ea),

  or_w_dd_das(0x8168, 0xf1f8, ea_das16_read, dbrr, gen_orw_dd_ea),

  or_w_dd_dais(0x8170, 0xf1f8, ea_dais16_read, dbrr, gen_orw_dd_ea),

  or_w_dd_adr16(0x8178, 0xf1ff, ea_adr16s16_read, dbrr, gen_orw_dd_ea),

  or_w_dd_adr32(0x8179, 0xf1ff, ea_adr32s16_read, dbrr, gen_orw_dd_ea),

  or_l_dd_ais(0x8190, 0xf1f8, ea_ais32_read, dbrr, gen_orl_dd_ea),

  or_l_dd_aips(0x8198, 0xf1f8, ea_aips32_read, dbrr, gen_orl_dd_ea),

  or_l_dd_pais(0x81a0, 0xf1f8, ea_pais32_read, dbrr, gen_orl_dd_ea),

  or_l_dd_das(0x81a8, 0xf1f8, ea_das32_read, dbrr, gen_orl_dd_ea),

  or_l_dd_dais(0x81b0, 0xf1f8, ea_dais32_read, dbrr, gen_orl_dd_ea),

  or_l_dd_adr16(0x81b8, 0xf1ff, ea_adr16s32_read, dbrr, gen_orl_dd_ea),

  or_l_dd_adr32(0x81b9, 0xf1ff, ea_adr32s32_read, dbrr, gen_orl_dd_ea),

  sub_b_ds_dd(0x9000, 0xf1f8, gen_subb_ds_dd, dbrr, dbrr),

  sub_b_ais_dd(0x9010, 0xf1f8, ea_ais8_read, dbrr, gen_subb_dt_dd),

  sub_b_aips_dd(0x9018, 0xf1f8, ea_aips8_read, dbrr, gen_subb_dt_dd),

  sub_b_pais_dd(0x9020, 0xf1f8, ea_pais8_read, dbrr, gen_subb_dt_dd),

  sub_b_das_dd(0x9028, 0xf1f8, ea_das8_read, dbrr, gen_subb_dt_dd),

  sub_b_dais_dd(0x9030, 0xf1f8, ea_dais8_read, dbrr, gen_subb_dt_dd),

  sub_b_adr16_dd(0x9038, 0xf1ff, ea_adr16s8_read, dbrr, gen_subb_dt_dd),

  sub_b_adr32_dd(0x9039, 0xf1ff, ea_adr32s8_read, dbrr, gen_subb_dt_dd),

  sub_b_dpc_dd(0x903a, 0xf1ff, ea_dpc8_read, dbrr, gen_subb_dt_dd),

  sub_b_dpci_dd(0x903b, 0xf1ff, ea_dpci8_read, dbrr, gen_subb_dt_dd),

  sub_b_imm8_dd(0x903c, 0xf1ff, ea_imm8_read, dbrr, gen_subb_dt_dd),

  sub_w_ds_dd(0x9040, 0xf1f8, gen_subw_ds_dd, dbrr, dbrr),

  sub_w_as_dd(0x9048, 0xf1f8, gen_subw_as_dd, dbrr, dbrr),

  sub_w_ais_dd(0x9050, 0xf1f8, ea_ais16_read, dbrr, gen_subw_dt_dd),

  sub_w_aips_dd(0x9058, 0xf1f8, ea_aips16_read, dbrr, gen_subw_dt_dd),

  sub_w_pais_dd(0x9060, 0xf1f8, ea_pais16_read, dbrr, gen_subw_dt_dd),

  sub_w_das_dd(0x9068, 0xf1f8, ea_das16_read, dbrr, gen_subw_dt_dd),

  sub_w_dais_dd(0x9070, 0xf1f8, ea_dais16_read, dbrr, gen_subw_dt_dd),

  sub_w_adr16_dd(0x9078, 0xf1ff, ea_adr16s16_read, dbrr, gen_subw_dt_dd),

  sub_w_adr32_dd(0x9079, 0xf1ff, ea_adr32s16_read, dbrr, gen_subw_dt_dd),

  sub_w_dpc_dd(0x907a, 0xf1ff, ea_dpc16_read, dbrr, gen_subw_dt_dd),

  sub_w_dpci_dd(0x907b, 0xf1ff, ea_dpci16_read, dbrr, gen_subw_dt_dd),

  sub_w_imm16_dd(0x907c, 0xf1ff, ea_imm16_read, dbrr, gen_subw_dt_dd),

  sub_l_ds_dd(0x9080, 0xf1f8, gen_subl_ds_dd, dbrr, dbrr),

  sub_l_as_dd(0x9088, 0xf1f8, gen_subl_as_dd, dbrr, dbrr),

  sub_l_ais_dd(0x9090, 0xf1f8, ea_ais32_read, dbrr, gen_subl_dt_dd),

  sub_l_aips_dd(0x9098, 0xf1f8, ea_aips32_read, dbrr, gen_subl_dt_dd),

  sub_l_pais_dd(0x90a0, 0xf1f8, ea_pais32_read, dbrr, gen_subl_dt_dd),

  sub_l_das_dd(0x90a8, 0xf1f8, ea_das32_read, dbrr, gen_subl_dt_dd),

  sub_l_dais_dd(0x90b0, 0xf1f8, ea_dais32_read, dbrr, gen_subl_dt_dd),

  sub_l_adr16_dd(0x90b8, 0xf1ff, ea_adr16s32_read, dbrr, gen_subl_dt_dd),

  sub_l_adr32_dd(0x90b9, 0xf1ff, ea_adr32s32_read, dbrr, gen_subl_dt_dd),

  sub_l_dpc_dd(0x90ba, 0xf1ff, ea_dpc32_read, dbrr, gen_subl_dt_dd),

  sub_l_dpci_dd(0x90bb, 0xf1ff, ea_dpci32_read, dbrr, gen_subl_dt_dd),

  sub_l_imm32_dd(0x90bc, 0xf1ff, ea_imm32_read, dbrr, gen_subl_dt_dd),

  suba_w_ds_ad(0x90c0, 0xf1f8, gen_subw_ds_ad, dbrr, dbrr),

  suba_w_as_ad(0x90c8, 0xf1f8, gen_subw_as_ad, dbrr, dbrr),

  suba_w_ais_ad(0x90d0, 0xf1f8, ea_ais16_read, dbrr, gen_subw_dt_ad),

  suba_w_aips_ad(0x90d8, 0xf1f8, ea_aips16_read, dbrr, gen_subw_dt_ad),

  suba_w_pais_ad(0x90e0, 0xf1f8, ea_pais16_read, dbrr, gen_subw_dt_ad),

  suba_w_das_ad(0x90e8, 0xf1f8, ea_das16_read, dbrr, gen_subw_dt_ad),

  suba_w_dais_ad(0x90f0, 0xf1f8, ea_dais16_read, dbrr, gen_subw_dt_ad),

  suba_w_adr16_ad(0x90f8, 0xf1ff, ea_adr16s16_read, dbrr, gen_subw_dt_ad),

  suba_w_adr32_ad(0x90f9, 0xf1ff, ea_adr32s16_read, dbrr, gen_subw_dt_ad),

  suba_w_dpc_ad(0x90fa, 0xf1ff, ea_dpc16_read, dbrr, gen_subw_dt_ad),

  suba_w_dpci_ad(0x90fb, 0xf1ff, ea_dpci16_read, dbrr, gen_subw_dt_ad),

  suba_w_imm16_ad(0x90fc, 0xf1ff, ea_imm16_read, dbrr, gen_subw_dt_ad),

  subx_b_ds_dd(0x9100, 0xf1f8, gen_subxb_ds_dd, dbrr, dbrr),

  subx_b_pais_paid(0x9108, 0xf1f8, ea_pais8_read, gen_subxb_im_ea, ea_paid8_read),

  sub_b_dd_ais(0x9110, 0xf1f8, ea_ais8_read, dbrr, gen_subb_dd_ea),

  sub_b_dd_aips(0x9118, 0xf1f8, ea_aips8_read, dbrr, gen_subb_dd_ea),

  sub_b_dd_pais(0x9120, 0xf1f8, ea_pais8_read, dbrr, gen_subb_dd_ea),

  sub_b_dd_das(0x9128, 0xf1f8, ea_das8_read, dbrr, gen_subb_dd_ea),

  sub_b_dd_dais(0x9130, 0xf1f8, ea_dais8_read, dbrr, gen_subb_dd_ea),

  sub_b_dd_adr16(0x9138, 0xf1ff, ea_adr16s8_read, dbrr, gen_subb_dd_ea),

  sub_b_dd_adr32(0x9139, 0xf1ff, ea_adr32s8_read, dbrr, gen_subb_dd_ea),

  subx_w_ds_dd(0x9140, 0xf1f8, gen_subxw_ds_dd, dbrr, dbrr),

  subx_w_pais_paid(0x9148, 0xf1f8, ea_pais16_read, gen_subxw_im_ea, ea_paid16_read),

  sub_w_dd_ais(0x9150, 0xf1f8, ea_ais16_read, dbrr, gen_subw_dd_ea),

  sub_w_dd_aips(0x9158, 0xf1f8, ea_aips16_read, dbrr, gen_subw_dd_ea),

  sub_w_dd_pais(0x9160, 0xf1f8, ea_pais16_read, dbrr, gen_subw_dd_ea),

  sub_w_dd_das(0x9168, 0xf1f8, ea_das16_read, dbrr, gen_subw_dd_ea),

  sub_w_dd_dais(0x9170, 0xf1f8, ea_dais16_read, dbrr, gen_subw_dd_ea),

  sub_w_dd_adr16(0x9178, 0xf1ff, ea_adr16s16_read, dbrr, gen_subw_dd_ea),

  sub_w_dd_adr32(0x9179, 0xf1ff, ea_adr32s16_read, dbrr, gen_subw_dd_ea),

  subx_l_ds_dd(0x9180, 0xf1f8, gen_subxl_ds_dd, dbrr, dbrr),

  subx_l_pais_paid(0x9188, 0xf1f8, ea_pais32_read, gen_subxl_im_ea, ea_paid32_read),

  sub_l_dd_ais(0x9190, 0xf1f8, ea_ais32_read, dbrr, gen_subl_dd_ea),

  sub_l_dd_aips(0x9198, 0xf1f8, ea_aips32_read, dbrr, gen_subl_dd_ea),

  sub_l_dd_pais(0x91a0, 0xf1f8, ea_pais32_read, dbrr, gen_subl_dd_ea),

  sub_l_dd_das(0x91a8, 0xf1f8, ea_das32_read, dbrr, gen_subl_dd_ea),

  sub_l_dd_dais(0x91b0, 0xf1f8, ea_dais32_read, dbrr, gen_subl_dd_ea),

  sub_l_dd_adr16(0x91b8, 0xf1ff, ea_adr16s32_read, dbrr, gen_subl_dd_ea),

  sub_l_dd_adr32(0x91b9, 0xf1ff, ea_adr32s32_read, dbrr, gen_subl_dd_ea),

  suba_l_ds_ad(0x91c0, 0xf1f8, gen_subl_ds_ad, dbrr, dbrr),

  suba_l_as_ad(0x91c8, 0xf1f8, gen_subl_as_ad, dbrr, dbrr),

  suba_l_ais_ad(0x91d0, 0xf1f8, ea_ais32_read, dbrr, gen_subl_dt_ad),

  suba_l_aips_ad(0x91d8, 0xf1f8, ea_aips32_read, dbrr, gen_subl_dt_ad),

  suba_l_pais_ad(0x91e0, 0xf1f8, ea_pais32_read, dbrr, gen_subl_dt_ad),

  suba_l_das_ad(0x91e8, 0xf1f8, ea_das32_read, dbrr, gen_subl_dt_ad),

  suba_l_dais_ad(0x91f0, 0xf1f8, ea_dais32_read, dbrr, gen_subl_dt_ad),

  suba_l_adr16_ad(0x91f8, 0xf1ff, ea_adr16s32_read, dbrr, gen_subl_dt_ad),

  suba_l_adr32_ad(0x91f9, 0xf1ff, ea_adr32s32_read, dbrr, gen_subl_dt_ad),

  suba_l_dpc_ad(0x91fa, 0xf1ff, ea_dpc32_read, dbrr, gen_subl_dt_ad),

  suba_l_dpci_ad(0x91fb, 0xf1ff, ea_dpci32_read, dbrr, gen_subl_dt_ad),

  suba_l_imm32_ad(0x91fc, 0xf1ff, ea_imm32_read, dbrr, gen_subl_dt_ad),

  linea_imm12(0xa000, 0xf000, op_linea, dbrr, dbrr),

  cmp_b_ds_dd(0xb000, 0xf1f8, gen_cmpb_ds_dd, dbrr, dbrr),

  cmp_b_ais_dd(0xb010, 0xf1f8, ea_ais8_read, dbrr, gen_cmpb_dt_dd),

  cmp_b_aips_dd(0xb018, 0xf1f8, ea_aips8_read, dbrr, gen_cmpb_dt_dd),

  cmp_b_pais_dd(0xb020, 0xf1f8, ea_pais8_read, dbrr, gen_cmpb_dt_dd),

  cmp_b_das_dd(0xb028, 0xf1f8, ea_das8_read, dbrr, gen_cmpb_dt_dd),

  cmp_b_dais_dd(0xb030, 0xf1f8, ea_dais8_read, dbrr, gen_cmpb_dt_dd),

  cmp_b_adr16_dd(0xb038, 0xf1ff, ea_adr16s8_read, dbrr, gen_cmpb_dt_dd),

  cmp_b_adr32_dd(0xb039, 0xf1ff, ea_adr32s8_read, dbrr, gen_cmpb_dt_dd),

  cmp_b_dpc_dd(0xb03a, 0xf1ff, ea_dpc8_read, dbrr, gen_cmpb_dt_dd),

  cmp_b_dpci_dd(0xb03b, 0xf1ff, ea_dpci8_read, dbrr, gen_cmpb_dt_dd),

  cmp_b_imm8_dd(0xb03c, 0xf1ff, ea_imm8_read, dbrr, gen_cmpb_dt_dd),

  cmp_w_ds_dd(0xb040, 0xf1f8, gen_cmpw_ds_dd, dbrr, dbrr),

  cmp_w_as_dd(0xb048, 0xf1f8, gen_cmpw_as_dd, dbrr, dbrr),

  cmp_w_ais_dd(0xb050, 0xf1f8, ea_ais16_read, dbrr, gen_cmpw_dt_dd),

  cmp_w_aips_dd(0xb058, 0xf1f8, ea_aips16_read, dbrr, gen_cmpw_dt_dd),

  cmp_w_pais_dd(0xb060, 0xf1f8, ea_pais16_read, dbrr, gen_cmpw_dt_dd),

  cmp_w_das_dd(0xb068, 0xf1f8, ea_das16_read, dbrr, gen_cmpw_dt_dd),

  cmp_w_dais_dd(0xb070, 0xf1f8, ea_dais16_read, dbrr, gen_cmpw_dt_dd),

  cmp_w_adr16_dd(0xb078, 0xf1ff, ea_adr16s16_read, dbrr, gen_cmpw_dt_dd),

  cmp_w_adr32_dd(0xb079, 0xf1ff, ea_adr32s16_read, dbrr, gen_cmpw_dt_dd),

  cmp_w_dpc_dd(0xb07a, 0xf1ff, ea_dpc16_read, dbrr, gen_cmpw_dt_dd),

  cmp_w_dpci_dd(0xb07b, 0xf1ff, ea_dpci16_read, dbrr, gen_cmpw_dt_dd),

  cmp_w_imm16_dd(0xb07c, 0xf1ff, ea_imm16_read, dbrr, gen_cmpw_dt_dd),

  cmp_l_ds_dd(0xb080, 0xf1f8, gen_cmpl_ds_dd, dbrr, dbrr),

  cmp_l_as_dd(0xb088, 0xf1f8, gen_cmpl_as_dd, dbrr, dbrr),

  cmp_l_ais_dd(0xb090, 0xf1f8, ea_ais32_read, dbrr, gen_cmpl_dt_dd),

  cmp_l_aips_dd(0xb098, 0xf1f8, ea_aips32_read, dbrr, gen_cmpl_dt_dd),

  cmp_l_pais_dd(0xb0a0, 0xf1f8, ea_pais32_read, dbrr, gen_cmpl_dt_dd),

  cmp_l_das_dd(0xb0a8, 0xf1f8, ea_das32_read, dbrr, gen_cmpl_dt_dd),

  cmp_l_dais_dd(0xb0b0, 0xf1f8, ea_dais32_read, dbrr, gen_cmpl_dt_dd),

  cmp_l_adr16_dd(0xb0b8, 0xf1ff, ea_adr16s32_read, dbrr, gen_cmpl_dt_dd),

  cmp_l_adr32_dd(0xb0b9, 0xf1ff, ea_adr32s32_read, dbrr, gen_cmpl_dt_dd),

  cmp_l_dpc_dd(0xb0ba, 0xf1ff, ea_dpc32_read, dbrr, gen_cmpl_dt_dd),

  cmp_l_dpci_dd(0xb0bb, 0xf1ff, ea_dpci32_read, dbrr, gen_cmpl_dt_dd),

  cmp_l_imm32_dd(0xb0bc, 0xf1ff, ea_imm32_read, dbrr, gen_cmpl_dt_dd),

  cmpa_w_ds_ad(0xb0c0, 0xf1f8, gen_cmpw_ds_ad, dbrr, dbrr),

  cmpa_w_as_ad(0xb0c8, 0xf1f8, gen_cmpw_as_ad, dbrr, dbrr),

  cmpa_w_ais_ad(0xb0d0, 0xf1f8, ea_ais16_read, dbrr, gen_cmpw_dt_ad),

  cmpa_w_aips_ad(0xb0d8, 0xf1f8, ea_aips16_read, dbrr, gen_cmpw_dt_ad),

  cmpa_w_pais_ad(0xb0e0, 0xf1f8, ea_pais16_read, dbrr, gen_cmpw_dt_ad),

  cmpa_w_das_ad(0xb0e8, 0xf1f8, ea_das16_read, dbrr, gen_cmpw_dt_ad),

  cmpa_w_dais_ad(0xb0f0, 0xf1f8, ea_dais16_read, dbrr, gen_cmpw_dt_ad),

  cmpa_w_adr16_ad(0xb0f8, 0xf1ff, ea_adr16s16_read, dbrr, gen_cmpw_dt_ad),

  cmpa_w_adr32_ad(0xb0f9, 0xf1ff, ea_adr32s16_read, dbrr, gen_cmpw_dt_ad),

  cmpa_w_dpc_ad(0xb0fa, 0xf1ff, ea_dpc16_read, dbrr, gen_cmpw_dt_ad),

  cmpa_w_dpci_ad(0xb0fb, 0xf1ff, ea_dpci16_read, dbrr, gen_cmpw_dt_ad),

  cmpa_w_imm16_ad(0xb0fc, 0xf1ff, ea_imm16_read, dbrr, gen_cmpw_dt_ad),

  eor_b_dd_ds(0xb100, 0xf1f8, gen_eorb_dd_ds, dbrr, dbrr),

  cmpm_b_aips_aipd(0xb108, 0xf1f8, ea_aips8_read, gen_cmpmb_im_ea, ea_aipd8_read),

  eor_b_dd_ais(0xb110, 0xf1f8, ea_ais8_read, dbrr, gen_eorb_dd_ea),

  eor_b_dd_aips(0xb118, 0xf1f8, ea_aips8_read, dbrr, gen_eorb_dd_ea),

  eor_b_dd_pais(0xb120, 0xf1f8, ea_pais8_read, dbrr, gen_eorb_dd_ea),

  eor_b_dd_das(0xb128, 0xf1f8, ea_das8_read, dbrr, gen_eorb_dd_ea),

  eor_b_dd_dais(0xb130, 0xf1f8, ea_dais8_read, dbrr, gen_eorb_dd_ea),

  eor_b_dd_adr16(0xb138, 0xf1ff, ea_adr16s8_read, dbrr, gen_eorb_dd_ea),

  eor_b_dd_adr32(0xb139, 0xf1ff, ea_adr32s8_read, dbrr, gen_eorb_dd_ea),

  eor_w_dd_ds(0xb140, 0xf1f8, gen_eorw_dd_ds, dbrr, dbrr),

  cmpm_w_aips_aipd(0xb148, 0xf1f8, ea_aips16_read, gen_cmpmw_im_ea, ea_aipd16_read),

  eor_w_dd_ais(0xb150, 0xf1f8, ea_ais16_read, dbrr, gen_eorw_dd_ea),

  eor_w_dd_aips(0xb158, 0xf1f8, ea_aips16_read, dbrr, gen_eorw_dd_ea),

  eor_w_dd_pais(0xb160, 0xf1f8, ea_pais16_read, dbrr, gen_eorw_dd_ea),

  eor_w_dd_das(0xb168, 0xf1f8, ea_das16_read, dbrr, gen_eorw_dd_ea),

  eor_w_dd_dais(0xb170, 0xf1f8, ea_dais16_read, dbrr, gen_eorw_dd_ea),

  eor_w_dd_adr16(0xb178, 0xf1ff, ea_adr16s16_read, dbrr, gen_eorw_dd_ea),

  eor_w_dd_adr32(0xb179, 0xf1ff, ea_adr32s16_read, dbrr, gen_eorw_dd_ea),

  eor_l_dd_ds(0xb180, 0xf1f8, gen_eorl_dd_ds, dbrr, dbrr),

  cmpm_l_aips_aipd(0xb188, 0xf1f8, ea_aips32_read, gen_cmpml_im_ea, ea_aipd32_read),

  eor_l_dd_ais(0xb190, 0xf1f8, ea_ais32_read, dbrr, gen_eorl_dd_ea),

  eor_l_dd_aips(0xb198, 0xf1f8, ea_aips32_read, dbrr, gen_eorl_dd_ea),

  eor_l_dd_pais(0xb1a0, 0xf1f8, ea_pais32_read, dbrr, gen_eorl_dd_ea),

  eor_l_dd_das(0xb1a8, 0xf1f8, ea_das32_read, dbrr, gen_eorl_dd_ea),

  eor_l_dd_dais(0xb1b0, 0xf1f8, ea_dais32_read, dbrr, gen_eorl_dd_ea),

  eor_l_dd_adr16(0xb1b8, 0xf1ff, ea_adr16s32_read, dbrr, gen_eorl_dd_ea),

  eor_l_dd_adr32(0xb1b9, 0xf1ff, ea_adr32s32_read, dbrr, gen_eorl_dd_ea),

  cmpa_l_ds_ad(0xb1c0, 0xf1f8, gen_cmpl_ds_ad, dbrr, dbrr),

  cmpa_l_as_ad(0xb1c8, 0xf1f8, gen_cmpl_as_ad, dbrr, dbrr),

  cmpa_l_ais_ad(0xb1d0, 0xf1f8, ea_ais32_read, dbrr, gen_cmpl_dt_ad),

  cmpa_l_aips_ad(0xb1d8, 0xf1f8, ea_aips32_read, dbrr, gen_cmpl_dt_ad),

  cmpa_l_pais_ad(0xb1e0, 0xf1f8, ea_pais32_read, dbrr, gen_cmpl_dt_ad),

  cmpa_l_das_ad(0xb1e8, 0xf1f8, ea_das32_read, dbrr, gen_cmpl_dt_ad),

  cmpa_l_dais_ad(0xb1f0, 0xf1f8, ea_dais32_read, dbrr, gen_cmpl_dt_ad),

  cmpa_l_adr16_ad(0xb1f8, 0xf1ff, ea_adr16s32_read, dbrr, gen_cmpl_dt_ad),

  cmpa_l_adr32_ad(0xb1f9, 0xf1ff, ea_adr32s32_read, dbrr, gen_cmpl_dt_ad),

  cmpa_l_dpc_ad(0xb1fa, 0xf1ff, ea_dpc32_read, dbrr, gen_cmpl_dt_ad),

  cmpa_l_dpci_ad(0xb1fb, 0xf1ff, ea_dpci32_read, dbrr, gen_cmpl_dt_ad),

  cmpa_l_imm32_ad(0xb1fc, 0xf1ff, ea_imm32_read, dbrr, gen_cmpl_dt_ad),

  and_b_ds_dd(0xc000, 0xf1f8, gen_andb_ds_dd, dbrr, dbrr),

  and_b_ais_dd(0xc010, 0xf1f8, ea_ais8_read, dbrr, gen_andb_dt_dd),

  and_b_aips_dd(0xc018, 0xf1f8, ea_aips8_read, dbrr, gen_andb_dt_dd),

  and_b_pais_dd(0xc020, 0xf1f8, ea_pais8_read, dbrr, gen_andb_dt_dd),

  and_b_das_dd(0xc028, 0xf1f8, ea_das8_read, dbrr, gen_andb_dt_dd),

  and_b_dais_dd(0xc030, 0xf1f8, ea_dais8_read, dbrr, gen_andb_dt_dd),

  and_b_adr16_dd(0xc038, 0xf1ff, ea_adr16s8_read, dbrr, gen_andb_dt_dd),

  and_b_adr32_dd(0xc039, 0xf1ff, ea_adr32s8_read, dbrr, gen_andb_dt_dd),

  and_b_dpc_dd(0xc03a, 0xf1ff, ea_dpc8_read, dbrr, gen_andb_dt_dd),

  and_b_dpci_dd(0xc03b, 0xf1ff, ea_dpci8_read, dbrr, gen_andb_dt_dd),

  and_b_imm8_dd(0xc03c, 0xf1ff, ea_imm8_read, dbrr, gen_andb_dt_dd),

  and_w_ds_dd(0xc040, 0xf1f8, gen_andw_ds_dd, dbrr, dbrr),

  and_w_ais_dd(0xc050, 0xf1f8, ea_ais16_read, dbrr, gen_andw_dt_dd),

  and_w_aips_dd(0xc058, 0xf1f8, ea_aips16_read, dbrr, gen_andw_dt_dd),

  and_w_pais_dd(0xc060, 0xf1f8, ea_pais16_read, dbrr, gen_andw_dt_dd),

  and_w_das_dd(0xc068, 0xf1f8, ea_das16_read, dbrr, gen_andw_dt_dd),

  and_w_dais_dd(0xc070, 0xf1f8, ea_dais16_read, dbrr, gen_andw_dt_dd),

  and_w_adr16_dd(0xc078, 0xf1ff, ea_adr16s16_read, dbrr, gen_andw_dt_dd),

  and_w_adr32_dd(0xc079, 0xf1ff, ea_adr32s16_read, dbrr, gen_andw_dt_dd),

  and_w_dpc_dd(0xc07a, 0xf1ff, ea_dpc16_read, dbrr, gen_andw_dt_dd),

  and_w_dpci_dd(0xc07b, 0xf1ff, ea_dpci16_read, dbrr, gen_andw_dt_dd),

  and_w_imm16_dd(0xc07c, 0xf1ff, ea_imm16_read, dbrr, gen_andw_dt_dd),

  and_l_ds_dd(0xc080, 0xf1f8, gen_andl_ds_dd, dbrr, dbrr),

  and_l_ais_dd(0xc090, 0xf1f8, ea_ais32_read, dbrr, gen_andl_dt_dd),

  and_l_aips_dd(0xc098, 0xf1f8, ea_aips32_read, dbrr, gen_andl_dt_dd),

  and_l_pais_dd(0xc0a0, 0xf1f8, ea_pais32_read, dbrr, gen_andl_dt_dd),

  and_l_das_dd(0xc0a8, 0xf1f8, ea_das32_read, dbrr, gen_andl_dt_dd),

  and_l_dais_dd(0xc0b0, 0xf1f8, ea_dais32_read, dbrr, gen_andl_dt_dd),

  and_l_adr16_dd(0xc0b8, 0xf1ff, ea_adr16s32_read, dbrr, gen_andl_dt_dd),

  and_l_adr32_dd(0xc0b9, 0xf1ff, ea_adr32s32_read, dbrr, gen_andl_dt_dd),

  and_l_dpc_dd(0xc0ba, 0xf1ff, ea_dpc32_read, dbrr, gen_andl_dt_dd),

  and_l_dpci_dd(0xc0bb, 0xf1ff, ea_dpci32_read, dbrr, gen_andl_dt_dd),

  and_l_imm32_dd(0xc0bc, 0xf1ff, ea_imm32_read, dbrr, gen_andl_dt_dd),

  abcd_ds_dd(0xc100, 0xf1f8, gen_abcdb_ds_dd, dbrr, dbrr),

  abcd_pais_paid(0xc108, 0xf1f8, ea_pais8_read, gen_abcdb_im_ea, ea_paid8_read),

  and_b_dd_ais(0xc110, 0xf1f8, ea_ais8_read, dbrr, gen_andb_dd_ea),

  and_b_dd_aips(0xc118, 0xf1f8, ea_aips8_read, dbrr, gen_andb_dd_ea),

  and_b_dd_pais(0xc120, 0xf1f8, ea_pais8_read, dbrr, gen_andb_dd_ea),

  and_b_dd_das(0xc128, 0xf1f8, ea_das8_read, dbrr, gen_andb_dd_ea),

  and_b_dd_dais(0xc130, 0xf1f8, ea_dais8_read, dbrr, gen_andb_dd_ea),

  and_b_dd_adr16(0xc138, 0xf1ff, ea_adr16s8_read, dbrr, gen_andb_dd_ea),

  and_b_dd_adr32(0xc139, 0xf1ff, ea_adr32s8_read, dbrr, gen_andb_dd_ea),

  exg_dd_ds(0xc140, 0xf1f8, op_exg_dd_ds, dbrr, dbrr),

  exg_ad_as(0xc148, 0xf1f8, op_exg_ad_as, dbrr, dbrr),

  and_w_dd_ais(0xc150, 0xf1f8, ea_ais16_read, dbrr, gen_andw_dd_ea),

  and_w_dd_aips(0xc158, 0xf1f8, ea_aips16_read, dbrr, gen_andw_dd_ea),

  and_w_dd_pais(0xc160, 0xf1f8, ea_pais16_read, dbrr, gen_andw_dd_ea),

  and_w_dd_das(0xc168, 0xf1f8, ea_das16_read, dbrr, gen_andw_dd_ea),

  and_w_dd_dais(0xc170, 0xf1f8, ea_dais16_read, dbrr, gen_andw_dd_ea),

  and_w_dd_adr16(0xc178, 0xf1ff, ea_adr16s16_read, dbrr, gen_andw_dd_ea),

  and_w_dd_adr32(0xc179, 0xf1ff, ea_adr32s16_read, dbrr, gen_andw_dd_ea),

  exg_dd_as(0xc188, 0xf1f8, op_exg_dd_as, dbrr, dbrr),

  and_l_dd_ais(0xc190, 0xf1f8, ea_ais32_read, dbrr, gen_andl_dd_ea),

  and_l_dd_aips(0xc198, 0xf1f8, ea_aips32_read, dbrr, gen_andl_dd_ea),

  and_l_dd_pais(0xc1a0, 0xf1f8, ea_pais32_read, dbrr, gen_andl_dd_ea),

  and_l_dd_das(0xc1a8, 0xf1f8, ea_das32_read, dbrr, gen_andl_dd_ea),

  and_l_dd_dais(0xc1b0, 0xf1f8, ea_dais32_read, dbrr, gen_andl_dd_ea),

  and_l_dd_adr16(0xc1b8, 0xf1ff, ea_adr16s32_read, dbrr, gen_andl_dd_ea),

  and_l_dd_adr32(0xc1b9, 0xf1ff, ea_adr32s32_read, dbrr, gen_andl_dd_ea),

  add_b_ds_dd(0xd000, 0xf1f8, gen_addb_ds_dd, dbrr, dbrr),

  add_b_ais_dd(0xd010, 0xf1f8, ea_ais8_read, dbrr, gen_addb_dt_dd),

  add_b_aips_dd(0xd018, 0xf1f8, ea_aips8_read, dbrr, gen_addb_dt_dd),

  add_b_pais_dd(0xd020, 0xf1f8, ea_pais8_read, dbrr, gen_addb_dt_dd),

  add_b_das_dd(0xd028, 0xf1f8, ea_das8_read, dbrr, gen_addb_dt_dd),

  add_b_dais_dd(0xd030, 0xf1f8, ea_dais8_read, dbrr, gen_addb_dt_dd),

  add_b_adr16_dd(0xd038, 0xf1ff, ea_adr16s8_read, dbrr, gen_addb_dt_dd),

  add_b_adr32_dd(0xd039, 0xf1ff, ea_adr32s8_read, dbrr, gen_addb_dt_dd),

  add_b_dpc_dd(0xd03a, 0xf1ff, ea_dpc8_read, dbrr, gen_addb_dt_dd),

  add_b_dpci_dd(0xd03b, 0xf1ff, ea_dpci8_read, dbrr, gen_addb_dt_dd),

  add_b_imm8_dd(0xd03c, 0xf1ff, ea_imm8_read, dbrr, gen_addb_dt_dd),

  add_w_ds_dd(0xd040, 0xf1f8, gen_addw_ds_dd, dbrr, dbrr),

  add_w_as_dd(0xd048, 0xf1f8, gen_addw_as_dd, dbrr, dbrr),

  add_w_ais_dd(0xd050, 0xf1f8, ea_ais16_read, dbrr, gen_addw_dt_dd),

  add_w_aips_dd(0xd058, 0xf1f8, ea_aips16_read, dbrr, gen_addw_dt_dd),

  add_w_pais_dd(0xd060, 0xf1f8, ea_pais16_read, dbrr, gen_addw_dt_dd),

  add_w_das_dd(0xd068, 0xf1f8, ea_das16_read, dbrr, gen_addw_dt_dd),

  add_w_dais_dd(0xd070, 0xf1f8, ea_dais16_read, dbrr, gen_addw_dt_dd),

  add_w_adr16_dd(0xd078, 0xf1ff, ea_adr16s16_read, dbrr, gen_addw_dt_dd),

  add_w_adr32_dd(0xd079, 0xf1ff, ea_adr32s16_read, dbrr, gen_addw_dt_dd),

  add_w_dpc_dd(0xd07a, 0xf1ff, ea_dpc16_read, dbrr, gen_addw_dt_dd),

  add_w_dpci_dd(0xd07b, 0xf1ff, ea_dpci16_read, dbrr, gen_addw_dt_dd),

  add_w_imm16_dd(0xd07c, 0xf1ff, ea_imm16_read, dbrr, gen_addw_dt_dd),

  add_l_ds_dd(0xd080, 0xf1f8, gen_addl_ds_dd, dbrr, dbrr),

  add_l_as_dd(0xd088, 0xf1f8, gen_addl_as_dd, dbrr, dbrr),

  add_l_ais_dd(0xd090, 0xf1f8, ea_ais32_read, dbrr, gen_addl_dt_dd),

  add_l_aips_dd(0xd098, 0xf1f8, ea_aips32_read, dbrr, gen_addl_dt_dd),

  add_l_pais_dd(0xd0a0, 0xf1f8, ea_pais32_read, dbrr, gen_addl_dt_dd),

  add_l_das_dd(0xd0a8, 0xf1f8, ea_das32_read, dbrr, gen_addl_dt_dd),

  add_l_dais_dd(0xd0b0, 0xf1f8, ea_dais32_read, dbrr, gen_addl_dt_dd),

  add_l_adr16_dd(0xd0b8, 0xf1ff, ea_adr16s32_read, dbrr, gen_addl_dt_dd),

  add_l_adr32_dd(0xd0b9, 0xf1ff, ea_adr32s32_read, dbrr, gen_addl_dt_dd),

  add_l_dpc_dd(0xd0ba, 0xf1ff, ea_dpc32_read, dbrr, gen_addl_dt_dd),

  add_l_dpci_dd(0xd0bb, 0xf1ff, ea_dpci32_read, dbrr, gen_addl_dt_dd),

  add_l_imm32_dd(0xd0bc, 0xf1ff, ea_imm32_read, dbrr, gen_addl_dt_dd),

  adda_w_ds_ad(0xd0c0, 0xf1f8, gen_addw_ds_ad, dbrr, dbrr),

  adda_w_as_ad(0xd0c8, 0xf1f8, gen_addw_as_ad, dbrr, dbrr),

  adda_w_ais_ad(0xd0d0, 0xf1f8, ea_ais16_read, dbrr, gen_addw_dt_ad),

  adda_w_aips_ad(0xd0d8, 0xf1f8, ea_aips16_read, dbrr, gen_addw_dt_ad),

  adda_w_pais_ad(0xd0e0, 0xf1f8, ea_pais16_read, dbrr, gen_addw_dt_ad),

  adda_w_das_ad(0xd0e8, 0xf1f8, ea_das16_read, dbrr, gen_addw_dt_ad),

  adda_w_dais_ad(0xd0f0, 0xf1f8, ea_dais16_read, dbrr, gen_addw_dt_ad),

  adda_w_adr16_ad(0xd0f8, 0xf1ff, ea_adr16s16_read, dbrr, gen_addw_dt_ad),

  adda_w_adr32_ad(0xd0f9, 0xf1ff, ea_adr32s16_read, dbrr, gen_addw_dt_ad),

  adda_w_dpc_ad(0xd0fa, 0xf1ff, ea_dpc16_read, dbrr, gen_addw_dt_ad),

  adda_w_dpci_ad(0xd0fb, 0xf1ff, ea_dpci16_read, dbrr, gen_addw_dt_ad),

  adda_w_imm16_ad(0xd0fc, 0xf1ff, ea_imm16_read, dbrr, gen_addw_dt_ad),

  addx_b_ds_dd(0xd100, 0xf1f8, gen_addxb_ds_dd, dbrr, dbrr),

  addx_b_pais_paid(0xd108, 0xf1f8, ea_pais8_read, gen_addxb_im_ea, ea_paid8_read),

  add_b_dd_ais(0xd110, 0xf1f8, ea_ais8_read, dbrr, gen_addb_dd_ea),

  add_b_dd_aips(0xd118, 0xf1f8, ea_aips8_read, dbrr, gen_addb_dd_ea),

  add_b_dd_pais(0xd120, 0xf1f8, ea_pais8_read, dbrr, gen_addb_dd_ea),

  add_b_dd_das(0xd128, 0xf1f8, ea_das8_read, dbrr, gen_addb_dd_ea),

  add_b_dd_dais(0xd130, 0xf1f8, ea_dais8_read, dbrr, gen_addb_dd_ea),

  add_b_dd_adr16(0xd138, 0xf1ff, ea_adr16s8_read, dbrr, gen_addb_dd_ea),

  add_b_dd_adr32(0xd139, 0xf1ff, ea_adr32s8_read, dbrr, gen_addb_dd_ea),

  addx_w_ds_dd(0xd140, 0xf1f8, gen_addxw_ds_dd, dbrr, dbrr),

  addx_w_pais_paid(0xd148, 0xf1f8, ea_pais16_read, gen_addxw_im_ea, ea_paid16_read),

  add_w_dd_ais(0xd150, 0xf1f8, ea_ais16_read, dbrr, gen_addw_dd_ea),

  add_w_dd_aips(0xd158, 0xf1f8, ea_aips16_read, dbrr, gen_addw_dd_ea),

  add_w_dd_pais(0xd160, 0xf1f8, ea_pais16_read, dbrr, gen_addw_dd_ea),

  add_w_dd_das(0xd168, 0xf1f8, ea_das16_read, dbrr, gen_addw_dd_ea),

  add_w_dd_dais(0xd170, 0xf1f8, ea_dais16_read, dbrr, gen_addw_dd_ea),

  add_w_dd_adr16(0xd178, 0xf1ff, ea_adr16s16_read, dbrr, gen_addw_dd_ea),

  add_w_dd_adr32(0xd179, 0xf1ff, ea_adr32s16_read, dbrr, gen_addw_dd_ea),

  addx_l_ds_dd(0xd180, 0xf1f8, gen_addxl_ds_dd, dbrr, dbrr),

  addx_l_pais_paid(0xd188, 0xf1f8, ea_pais32_read, gen_addxl_im_ea, ea_paid32_read),

  add_l_dd_ais(0xd190, 0xf1f8, ea_ais32_read, dbrr, gen_addl_dd_ea),

  add_l_dd_aips(0xd198, 0xf1f8, ea_aips32_read, dbrr, gen_addl_dd_ea),

  add_l_dd_pais(0xd1a0, 0xf1f8, ea_pais32_read, dbrr, gen_addl_dd_ea),

  add_l_dd_das(0xd1a8, 0xf1f8, ea_das32_read, dbrr, gen_addl_dd_ea),

  add_l_dd_dais(0xd1b0, 0xf1f8, ea_dais32_read, dbrr, gen_addl_dd_ea),

  add_l_dd_adr16(0xd1b8, 0xf1ff, ea_adr16s32_read, dbrr, gen_addl_dd_ea),

  add_l_dd_adr32(0xd1b9, 0xf1ff, ea_adr32s32_read, dbrr, gen_addl_dd_ea),

  adda_l_ds_ad(0xd1c0, 0xf1f8, gen_addl_ds_ad, dbrr, dbrr),

  adda_l_as_ad(0xd1c8, 0xf1f8, gen_addl_as_ad, dbrr, dbrr),

  adda_l_ais_ad(0xd1d0, 0xf1f8, ea_ais32_read, dbrr, gen_addl_dt_ad),

  adda_l_aips_ad(0xd1d8, 0xf1f8, ea_aips32_read, dbrr, gen_addl_dt_ad),

  adda_l_pais_ad(0xd1e0, 0xf1f8, ea_pais32_read, dbrr, gen_addl_dt_ad),

  adda_l_das_ad(0xd1e8, 0xf1f8, ea_das32_read, dbrr, gen_addl_dt_ad),

  adda_l_dais_ad(0xd1f0, 0xf1f8, ea_dais32_read, dbrr, gen_addl_dt_ad),

  adda_l_adr16_ad(0xd1f8, 0xf1ff, ea_adr16s32_read, dbrr, gen_addl_dt_ad),

  adda_l_adr32_ad(0xd1f9, 0xf1ff, ea_adr32s32_read, dbrr, gen_addl_dt_ad),

  adda_l_dpc_ad(0xd1fa, 0xf1ff, ea_dpc32_read, dbrr, gen_addl_dt_ad),

  adda_l_dpci_ad(0xd1fb, 0xf1ff, ea_dpci32_read, dbrr, gen_addl_dt_ad),

  adda_l_imm32_ad(0xd1fc, 0xf1ff, ea_imm32_read, dbrr, gen_addl_dt_ad),

  asr_b_imm3_ds(0xe000, 0xf1f8, gen_asrb_ir_ds, dbrr, dbrr),

  lsr_b_imm3_ds(0xe008, 0xf1f8, gen_lsrb_ir_ds, dbrr, dbrr),

  ror_b_imm3_ds(0xe018, 0xf1f8, gen_rorb_ir_ds, dbrr, dbrr),

  asr_b_dd_ds(0xe020, 0xf1f8, gen_asrb_dd_ds, dbrr, dbrr),

  lsr_b_dd_ds(0xe028, 0xf1f8, gen_lsrb_dd_ds, dbrr, dbrr),

  ror_b_dd_ds(0xe038, 0xf1f8, gen_rorb_dd_ds, dbrr, dbrr),

  asr_w_imm3_ds(0xe040, 0xf1f8, gen_asrw_ir_ds, dbrr, dbrr),

  lsr_w_imm3_ds(0xe048, 0xf1f8, gen_lsrw_ir_ds, dbrr, dbrr),

  ror_w_imm3_ds(0xe058, 0xf1f8, gen_rorw_ir_ds, dbrr, dbrr),

  asr_w_dd_ds(0xe060, 0xf1f8, gen_asrw_dd_ds, dbrr, dbrr),

  lsr_w_dd_ds(0xe068, 0xf1f8, gen_lsrw_dd_ds, dbrr, dbrr),

  ror_w_dd_ds(0xe078, 0xf1f8, gen_rorw_dd_ds, dbrr, dbrr),

  asr_l_imm3_ds(0xe080, 0xf1f8, gen_asrl_ir_ds, dbrr, dbrr),

  lsr_l_imm3_ds(0xe088, 0xf1f8, gen_lsrl_ir_ds, dbrr, dbrr),

  ror_l_imm3_ds(0xe098, 0xf1f8, gen_rorl_ir_ds, dbrr, dbrr),

  asr_l_dd_ds(0xe0a0, 0xf1f8, gen_asrl_dd_ds, dbrr, dbrr),

  lsr_l_dd_ds(0xe0a8, 0xf1f8, gen_lsrl_dd_ds, dbrr, dbrr),

  ror_l_dd_ds(0xe0b8, 0xf1f8, gen_rorl_dd_ds, dbrr, dbrr),

  asr_ais(0xe0d0, 0xfff8, ea_ais16_read, dbrr, gen_asrw_ea),

  asr_aips(0xe0d8, 0xfff8, ea_aips16_read, dbrr, gen_asrw_ea),

  asr_pais(0xe0e0, 0xfff8, ea_pais16_read, dbrr, gen_asrw_ea),

  asr_das(0xe0e8, 0xfff8, ea_das16_read, dbrr, gen_asrw_ea),

  asr_dais(0xe0f0, 0xfff8, ea_dais16_read, dbrr, gen_asrw_ea),

  asr_adr16(0xe0f8, 0xffff, ea_adr16s16_read, dbrr, gen_asrw_ea),

  asr_adr32(0xe0f9, 0xffff, ea_adr32s16_read, dbrr, gen_asrw_ea),

  asl_b_imm3_ds(0xe100, 0xf1f8, gen_aslb_ir_ds, dbrr, dbrr),

  lsl_b_imm3_ds(0xe108, 0xf1f8, gen_lslb_ir_ds, dbrr, dbrr),

  rol_b_imm3_ds(0xe118, 0xf1f8, gen_rolb_ir_ds, dbrr, dbrr),

  asl_b_dd_ds(0xe120, 0xf1f8, gen_aslb_dd_ds, dbrr, dbrr),

  lsl_b_dd_ds(0xe128, 0xf1f8, gen_lslb_dd_ds, dbrr, dbrr),

  rol_b_dd_ds(0xe138, 0xf1f8, gen_rolb_dd_ds, dbrr, dbrr),

  asl_w_imm3_ds(0xe140, 0xf1f8, gen_aslw_ir_ds, dbrr, dbrr),

  lsl_w_imm3_ds(0xe148, 0xf1f8, gen_lslw_ir_ds, dbrr, dbrr),

  rol_w_imm3_ds(0xe158, 0xf1f8, gen_rolw_ir_ds, dbrr, dbrr),

  asl_w_dd_ds(0xe160, 0xf1f8, gen_aslw_dd_ds, dbrr, dbrr),

  lsl_w_dd_ds(0xe168, 0xf1f8, gen_lslw_dd_ds, dbrr, dbrr),

  rol_w_dd_ds(0xe178, 0xf1f8, gen_rolw_dd_ds, dbrr, dbrr),

  asl_l_imm3_ds(0xe180, 0xf1f8, gen_asll_ir_ds, dbrr, dbrr),

  lsl_l_imm3_ds(0xe188, 0xf1f8, gen_lsll_ir_ds, dbrr, dbrr),

  rol_l_imm3_ds(0xe198, 0xf1f8, gen_roll_ir_ds, dbrr, dbrr),

  asl_l_dd_ds(0xe1a0, 0xf1f8, gen_asll_dd_ds, dbrr, dbrr),

  lsl_l_dd_ds(0xe1a8, 0xf1f8, gen_lsll_dd_ds, dbrr, dbrr),

  rol_l_dd_ds(0xe1b8, 0xf1f8, gen_roll_dd_ds, dbrr, dbrr),

  asl_ais(0xe1d0, 0xfff8, ea_ais16_read, dbrr, gen_aslw_ea),

  asl_aips(0xe1d8, 0xfff8, ea_aips16_read, dbrr, gen_aslw_ea),

  asl_pais(0xe1e0, 0xfff8, ea_pais16_read, dbrr, gen_aslw_ea),

  asl_das(0xe1e8, 0xfff8, ea_das16_read, dbrr, gen_aslw_ea),

  asl_dais(0xe1f0, 0xfff8, ea_dais16_read, dbrr, gen_aslw_ea),

  asl_adr16(0xe1f8, 0xffff, ea_adr16s16_read, dbrr, gen_aslw_ea),

  asl_adr32(0xe1f9, 0xffff, ea_adr32s16_read, dbrr, gen_aslw_ea),

  lsr_ais(0xe2d0, 0xfff8, ea_ais16_read, dbrr, gen_lsrw_ea),

  lsr_aips(0xe2d8, 0xfff8, ea_aips16_read, dbrr, gen_lsrw_ea),

  lsr_pais(0xe2e0, 0xfff8, ea_pais16_read, dbrr, gen_lsrw_ea),

  lsr_das(0xe2e8, 0xfff8, ea_das16_read, dbrr, gen_lsrw_ea),

  lsr_dais(0xe2f0, 0xfff8, ea_dais16_read, dbrr, gen_lsrw_ea),

  lsr_adr16(0xe2f8, 0xffff, ea_adr16s16_read, dbrr, gen_lsrw_ea),

  lsr_adr32(0xe2f9, 0xffff, ea_adr32s16_read, dbrr, gen_lsrw_ea),

  lsl_ais(0xe3d0, 0xfff8, ea_ais16_read, dbrr, gen_lslw_ea),

  lsl_aips(0xe3d8, 0xfff8, ea_aips16_read, dbrr, gen_lslw_ea),

  lsl_pais(0xe3e0, 0xfff8, ea_pais16_read, dbrr, gen_lslw_ea),

  lsl_das(0xe3e8, 0xfff8, ea_das16_read, dbrr, gen_lslw_ea),

  lsl_dais(0xe3f0, 0xfff8, ea_dais16_read, dbrr, gen_lslw_ea),

  lsl_adr16(0xe3f8, 0xffff, ea_adr16s16_read, dbrr, gen_lslw_ea),

  lsl_adr32(0xe3f9, 0xffff, ea_adr32s16_read, dbrr, gen_lslw_ea),

  ror_ais(0xe6d0, 0xfff8, ea_ais16_read, dbrr, gen_rorw_ea),

  ror_aips(0xe6d8, 0xfff8, ea_aips16_read, dbrr, gen_rorw_ea),

  ror_pais(0xe6e0, 0xfff8, ea_pais16_read, dbrr, gen_rorw_ea),

  ror_das(0xe6e8, 0xfff8, ea_das16_read, dbrr, gen_rorw_ea),

  ror_dais(0xe6f0, 0xfff8, ea_dais16_read, dbrr, gen_rorw_ea),

  ror_adr16(0xe6f8, 0xffff, ea_adr16s16_read, dbrr, gen_rorw_ea),

  ror_adr32(0xe6f9, 0xffff, ea_adr32s16_read, dbrr, gen_rorw_ea),

  rol_ais(0xe7d0, 0xfff8, ea_ais16_read, dbrr, gen_rolw_ea),

  rol_aips(0xe7d8, 0xfff8, ea_aips16_read, dbrr, gen_rolw_ea),

  rol_pais(0xe7e0, 0xfff8, ea_pais16_read, dbrr, gen_rolw_ea),

  rol_das(0xe7e8, 0xfff8, ea_das16_read, dbrr, gen_rolw_ea),

  rol_dais(0xe7f0, 0xfff8, ea_dais16_read, dbrr, gen_rolw_ea),

  rol_adr16(0xe7f8, 0xffff, ea_adr16s16_read, dbrr, gen_rolw_ea),

  rol_adr32(0xe7f9, 0xffff, ea_adr32s16_read, dbrr, gen_rolw_ea),

  linef_imm12(0xf000, 0xf000, op_linef, dbrr, dbrr);

  private static final MacroPLA[] DECODER = new MacroPLA[0xffff + 1];

  static {
    for (MacroPLA insn : MacroPLA.values()) {
      for (int ir = insn.opcode & insn.opmask; ir < DECODER.length; ir = maskedIncrement(ir, insn.opmask)) {
        if ((ir & insn.opmask) == insn.opcode) {
          int bits = 0;
          if (DECODER[ir] != null) {
            bits = Integer.bitCount(DECODER[ir].opmask);
          }
          if ((bits == 0) || (Integer.bitCount(insn.opmask) > bits)) {
            DECODER[ir] = insn;
          }
        }
      }
    }
    for (int ir = 0; ir < DECODER.length; ir++) {
      if (DECODER[ir] == null) {
        DECODER[ir] = illegal;
      }
    }
  }

  public final int opcode;

  public final int opmask;

  public final int a1;

  public final int a2;

  public final int a3;

  private MacroPLA(int opcode, int opmask, int a1, int a2, int a3) {
    this.opcode = opcode;
    this.opmask = opmask;
    this.a1 = a1;
    this.a2 = a2;
    this.a3 = a3;
  }

  private static final int maskedIncrement(int value, int mask) {
    int variableBits = ~mask;
    int base = value & mask;
    int next = mask + (value & variableBits) + 1;
    return base + (next & variableBits);
  }

  public static final MacroPLA decode(int ir) {
    return DECODER[ir & 0xffff];
  }
}
