/* generators for floating point */
extern	fp0_ea_f7(), fp0_f10_f7(), fp0_f7_ea();
extern	fp0_ea(), fp0_ea2(), fp0_f10();
extern	fp0_ea_fpair(), fp0_f10_fpair(), fp0_imm_f7(), fp0_movp_ea();
extern	fp0_ea_flist(), fp0_flist_ea(), fp0_ea_r4(), fp0_r4_ea();
extern	fp0_ea_clist(), fp0_clist_ea(); 
extern	fp_disp16(), fp_disp32(), fp2_nop();
extern	fp1_ea(), fp1_r0_disp16(), fp1_trap(), fp1_trapw(), fp1_trapl();
/* duplicates from ascode.c */
extern	ea();

/*	1st operand	2nd operand	3nd operand	opcode	generator */
/*	===========	===========	===========	======	========= */

readonly struct insfmt FABSB_FMT[] = {
	{ DATAB,	FREG,		0,		0x5818,	fp0_ea_f7, },
};

readonly struct insfmt FABSW_FMT[] = {
	{ DATAW,	FREG,		0,		0x5018,	fp0_ea_f7, },
};

readonly struct insfmt FABSL_FMT[] = {
	{ DATAL,	FREG,		0,		0x4018,	fp0_ea_f7, },
};

readonly struct insfmt FABSS_FMT[] = {
	{ DATAF,	FREG,		0,		0x4418,	fp0_ea_f7, },
};

readonly struct insfmt FABSD_FMT[] = {
	{ MEMD,		FREG,		0,		0x5418,	fp0_ea_f7, },
};

readonly struct insfmt FABSX_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x4818,	fp0_ea_f7, },
	{ FREG,		FREG,		0,		0x0018,	fp0_f10_f7, },
};

readonly struct insfmt FABSP_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x4C18,	fp0_ea_f7, },
};

readonly struct insfmt FACOSB_FMT[] = {
	{ DATAB,	FREG,		0,		0x581C,	fp0_ea_f7, },
};

readonly struct insfmt FACOSW_FMT[] = {
	{ DATAW,	FREG,		0,		0x501C,	fp0_ea_f7, },
};

readonly struct insfmt FACOSL_FMT[] = {
	{ DATAL,	FREG,		0,		0x401C,	fp0_ea_f7, },
};

readonly struct insfmt FACOSS_FMT[] = {
	{ DATAF,	FREG,		0,		0x441C,	fp0_ea_f7, },
};

readonly struct insfmt FACOSD_FMT[] = {
	{ MEMD,		FREG,		0,		0x541C,	fp0_ea_f7, },
};

readonly struct insfmt FACOSX_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x481C,	fp0_ea_f7, },
	{ FREG,		FREG,		0,		0x001C,	fp0_f10_f7, },
};

readonly struct insfmt FACOSP_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x4C1C,	fp0_ea_f7, },
};

readonly struct insfmt FADDB_FMT[] = {
	{ DATAB,	FREG,		0,		0x5822,	fp0_ea_f7, },
};

readonly struct insfmt FADDW_FMT[] = {
	{ DATAW,	FREG,		0,		0x5022,	fp0_ea_f7, },
};

readonly struct insfmt FADDL_FMT[] = {
	{ DATAL,	FREG,		0,		0x4022,	fp0_ea_f7, },
};

readonly struct insfmt FADDS_FMT[] = {
	{ DATAF,	FREG,		0,		0x4422,	fp0_ea_f7, },
};

readonly struct insfmt FADDD_FMT[] = {
	{ MEMD,		FREG,		0,		0x5422,	fp0_ea_f7, },
};

readonly struct insfmt FADDX_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x4822,	fp0_ea_f7, },
	{ FREG,		FREG,		0,		0x0022,	fp0_f10_f7, },
};

readonly struct insfmt FADDP_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x4C22,	fp0_ea_f7, },
};

readonly struct insfmt FASINB_FMT[] = {
	{ DATAB,	FREG,		0,		0x580C,	fp0_ea_f7, },
};

readonly struct insfmt FASINW_FMT[] = {
	{ DATAW,	FREG,		0,		0x500C,	fp0_ea_f7, },
};

readonly struct insfmt FASINL_FMT[] = {
	{ DATAL,	FREG,		0,		0x400C,	fp0_ea_f7, },
};

readonly struct insfmt FASINS_FMT[] = {
	{ DATAF,	FREG,		0,		0x440C,	fp0_ea_f7, },
};

readonly struct insfmt FASIND_FMT[] = {
	{ MEMD,		FREG,		0,		0x540C,	fp0_ea_f7, },
};

readonly struct insfmt FASINX_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x480C,	fp0_ea_f7, },
	{ FREG,		FREG,		0,		0x000C,	fp0_f10_f7, },
};

readonly struct insfmt FASINP_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x4C0C,	fp0_ea_f7, },
};

readonly struct insfmt FATANB_FMT[] = {
	{ DATAB,	FREG,		0,		0x580A,	fp0_ea_f7, },
};

readonly struct insfmt FATANW_FMT[] = {
	{ DATAW,	FREG,		0,		0x500A,	fp0_ea_f7, },
};

readonly struct insfmt FATANL_FMT[] = {
	{ DATAL,	FREG,		0,		0x400A,	fp0_ea_f7, },
};

readonly struct insfmt FATANS_FMT[] = {
	{ DATAF,	FREG,		0,		0x440A,	fp0_ea_f7, },
};

readonly struct insfmt FATAND_FMT[] = {
	{ MEMD,		FREG,		0,		0x540A,	fp0_ea_f7, },
};

readonly struct insfmt FATANX_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x480A,	fp0_ea_f7, },
	{ FREG,		FREG,		0,		0x000A,	fp0_f10_f7, },
};

readonly struct insfmt FATANP_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x4C0A,	fp0_ea_f7, },
};

readonly struct insfmt FATANHB_FMT[] = {
	{ DATAB,	FREG,		0,		0x580D,	fp0_ea_f7, },
};

readonly struct insfmt FATANHW_FMT[] = {
	{ DATAW,	FREG,		0,		0x500D,	fp0_ea_f7, },
};

readonly struct insfmt FATANHL_FMT[] = {
	{ DATAL,	FREG,		0,		0x400D,	fp0_ea_f7, },
};

readonly struct insfmt FATANHS_FMT[] = {
	{ DATAF,	FREG,		0,		0x440D,	fp0_ea_f7, },
};

readonly struct insfmt FATANHD_FMT[] = {
	{ MEMD,		FREG,		0,		0x540D,	fp0_ea_f7, },
};

readonly struct insfmt FATANHX_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x480D,	fp0_ea_f7, },
	{ FREG,		FREG,		0,		0x000D,	fp0_f10_f7, },
};

readonly struct insfmt FATANHP_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x4C0D,	fp0_ea_f7, },
};

readonly struct insfmt FCMPB_FMT[] = {
	{ DATAB,	FREG,		0,		0x5838,	fp0_ea_f7, },
};

readonly struct insfmt FCMPW_FMT[] = {
	{ DATAW,	FREG,		0,		0x5038,	fp0_ea_f7, },
};

readonly struct insfmt FCMPL_FMT[] = {
	{ DATAL,	FREG,		0,		0x4038,	fp0_ea_f7, },
};

readonly struct insfmt FCMPS_FMT[] = {
	{ DATAF,	FREG,		0,		0x4438,	fp0_ea_f7, },
};

readonly struct insfmt FCMPD_FMT[] = {
	{ MEMD,		FREG,		0,		0x5438,	fp0_ea_f7, },
};

readonly struct insfmt FCMPX_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x4838,	fp0_ea_f7, },
	{ FREG,		FREG,		0,		0x0038,	fp0_f10_f7, },
};

readonly struct insfmt FCMPP_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x4C38,	fp0_ea_f7, },
};

readonly struct insfmt FCOSB_FMT[] = {
	{ DATAB,	FREG,		0,		0x581D,	fp0_ea_f7, },
};

readonly struct insfmt FCOSW_FMT[] = {
	{ DATAW,	FREG,		0,		0x501D,	fp0_ea_f7, },
};

readonly struct insfmt FCOSL_FMT[] = {
	{ DATAL,	FREG,		0,		0x401D,	fp0_ea_f7, },
};

readonly struct insfmt FCOSS_FMT[] = {
	{ DATAF,	FREG,		0,		0x441D,	fp0_ea_f7, },
};

readonly struct insfmt FCOSD_FMT[] = {
	{ MEMD,		FREG,		0,		0x541D,	fp0_ea_f7, },
};

readonly struct insfmt FCOSX_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x481D,	fp0_ea_f7, },
	{ FREG,		FREG,		0,		0x001D,	fp0_f10_f7, },
};

readonly struct insfmt FCOSP_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x4C1D,	fp0_ea_f7, },
};

readonly struct insfmt FCOSHB_FMT[] = {
	{ DATAB,	FREG,		0,		0x5819,	fp0_ea_f7, },
};

readonly struct insfmt FCOSHW_FMT[] = {
	{ DATAW,	FREG,		0,		0x5019,	fp0_ea_f7, },
};

readonly struct insfmt FCOSHL_FMT[] = {
	{ DATAL,	FREG,		0,		0x4019,	fp0_ea_f7, },
};

readonly struct insfmt FCOSHS_FMT[] = {
	{ DATAF,	FREG,		0,		0x4419,	fp0_ea_f7, },
};

readonly struct insfmt FCOSHD_FMT[] = {
	{ MEMD,		FREG,		0,		0x5419,	fp0_ea_f7, },
};

readonly struct insfmt FCOSHX_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x4819,	fp0_ea_f7, },
	{ FREG,		FREG,		0,		0x0019,	fp0_f10_f7, },
};

readonly struct insfmt FCOSHP_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x4C19,	fp0_ea_f7, },
};

readonly struct insfmt FDIVB_FMT[] = {
	{ DATAB,	FREG,		0,		0x5820,	fp0_ea_f7, },
};

readonly struct insfmt FDIVW_FMT[] = {
	{ DATAW,	FREG,		0,		0x5020,	fp0_ea_f7, },
};

readonly struct insfmt FDIVL_FMT[] = {
	{ DATAL,	FREG,		0,		0x4020,	fp0_ea_f7, },
};

readonly struct insfmt FDIVS_FMT[] = {
	{ DATAF,	FREG,		0,		0x4420,	fp0_ea_f7, },
};

readonly struct insfmt FDIVD_FMT[] = {
	{ MEMD,		FREG,		0,		0x5420,	fp0_ea_f7, },
};

readonly struct insfmt FDIVX_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x4820,	fp0_ea_f7, },
	{ FREG,		FREG,		0,		0x0020,	fp0_f10_f7, },
};

readonly struct insfmt FDIVP_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x4C20,	fp0_ea_f7, },
};

readonly struct insfmt FETOXB_FMT[] = {
	{ DATAB,	FREG,		0,		0x5810,	fp0_ea_f7, },
};

readonly struct insfmt FETOXW_FMT[] = {
	{ DATAW,	FREG,		0,		0x5010,	fp0_ea_f7, },
};

readonly struct insfmt FETOXL_FMT[] = {
	{ DATAL,	FREG,		0,		0x4010,	fp0_ea_f7, },
};

readonly struct insfmt FETOXS_FMT[] = {
	{ DATAF,	FREG,		0,		0x4410,	fp0_ea_f7, },
};

readonly struct insfmt FETOXD_FMT[] = {
	{ MEMD,		FREG,		0,		0x5410,	fp0_ea_f7, },
};

readonly struct insfmt FETOXX_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x4810,	fp0_ea_f7, },
	{ FREG,		FREG,		0,		0x0010,	fp0_f10_f7, },
};

readonly struct insfmt FETOXP_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x4C10,	fp0_ea_f7, },
};

readonly struct insfmt FETOXM1B_FMT[] = {
	{ DATAB,	FREG,		0,		0x5808,	fp0_ea_f7, },
};

readonly struct insfmt FETOXM1W_FMT[] = {
	{ DATAW,	FREG,		0,		0x5008,	fp0_ea_f7, },
};

readonly struct insfmt FETOXM1L_FMT[] = {
	{ DATAL,	FREG,		0,		0x4008,	fp0_ea_f7, },
};

readonly struct insfmt FETOXM1S_FMT[] = {
	{ DATAF,	FREG,		0,		0x4408,	fp0_ea_f7, },
};

readonly struct insfmt FETOXM1D_FMT[] = {
	{ MEMD,		FREG,		0,		0x5408,	fp0_ea_f7, },
};

readonly struct insfmt FETOXM1X_FMT[] = {
	{ MEM&~IMML,	 FREG,		0,		0x4808,	fp0_ea_f7, },
	{ FREG,		FREG,		0,		0x0008,	fp0_f10_f7, },
};

readonly struct insfmt FETOXM1P_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x4C08,	fp0_ea_f7, },
};

readonly struct insfmt FGETEXPB_FMT[] = {
	{ DATAB,	FREG,		0,		0x581E,	fp0_ea_f7, },
};

readonly struct insfmt FGETEXPW_FMT[] = {
	{ DATAW,	FREG,		0,		0x501E,	fp0_ea_f7, },
};

readonly struct insfmt FGETEXPL_FMT[] = {
	{ DATAL,	FREG,		0,		0x401E,	fp0_ea_f7, },
};

readonly struct insfmt FGETEXPS_FMT[] = {
	{ DATAF,	FREG,		0,		0x441E,	fp0_ea_f7, },
};

readonly struct insfmt FGETEXPD_FMT[] = {
	{ MEMD,		FREG,		0,		0x541E,	fp0_ea_f7, },
};

readonly struct insfmt FGETEXPX_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x481E,	fp0_ea_f7, },
	{ FREG,		FREG,		0,		0x001E,	fp0_f10_f7, },
};

readonly struct insfmt FGETEXPP_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x4C1E,	fp0_ea_f7, },
};

readonly struct insfmt FGETMANB_FMT[] = {
	{ DATAB,	FREG,		0,		0x581F,	fp0_ea_f7, },
};

readonly struct insfmt FGETMANW_FMT[] = {
	{ DATAW,	FREG,		0,		0x501F,	fp0_ea_f7, },
};

readonly struct insfmt FGETMANL_FMT[] = {
	{ DATAL,	FREG,		0,		0x401F,	fp0_ea_f7, },
};

readonly struct insfmt FGETMANS_FMT[] = {
	{ DATAF,	FREG,		0,		0x441F,	fp0_ea_f7, },
};

readonly struct insfmt FGETMAND_FMT[] = {
	{ MEMD,		FREG,		0,		0x541F,	fp0_ea_f7, },
};

readonly struct insfmt FGETMANX_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x481F,	fp0_ea_f7, },
	{ FREG,		FREG,		0,		0x001F,	fp0_f10_f7, },
};

readonly struct insfmt FGETMANP_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x4C1F,	fp0_ea_f7, },
};

readonly struct insfmt FINTB_FMT[] = {
	{ DATAB,	FREG,		0,		0x5801,	fp0_ea_f7, },
};

readonly struct insfmt FINTW_FMT[] = {
	{ DATAW,	FREG,		0,		0x5001,	fp0_ea_f7, },
};

readonly struct insfmt FINTL_FMT[] = {
	{ DATAL,	FREG,		0,		0x4001,	fp0_ea_f7, },
};

readonly struct insfmt FINTS_FMT[] = {
	{ DATAF,	FREG,		0,		0x4401,	fp0_ea_f7, },
};

readonly struct insfmt FINTD_FMT[] = {
	{ MEMD,		FREG,		0,		0x5401,	fp0_ea_f7, },
};

readonly struct insfmt FINTX_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x4801,	fp0_ea_f7, },
	{ FREG,		FREG,		0,		0x0001,	fp0_f10_f7, },
};

readonly struct insfmt FINTP_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x4C01,	fp0_ea_f7, },
};

readonly struct insfmt FINTRZB_FMT[] = {
	{ DATAB,	FREG,		0,		0x5803,	fp0_ea_f7, },
};

readonly struct insfmt FINTRZW_FMT[] = {
	{ DATAW,	FREG,		0,		0x5003,	fp0_ea_f7, },
};

readonly struct insfmt FINTRZL_FMT[] = {
	{ DATAL,	FREG,		0,		0x4003,	fp0_ea_f7, },
};

readonly struct insfmt FINTRZS_FMT[] = {
	{ DATAF,	FREG,		0,		0x4403,	fp0_ea_f7, },
};

readonly struct insfmt FINTRZD_FMT[] = {
	{ MEMD,		FREG,		0,		0x5403,	fp0_ea_f7, },
};

readonly struct insfmt FINTRZX_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x4803,	fp0_ea_f7, },
	{ FREG,		FREG,		0,		0x0003,	fp0_f10_f7, },
};

readonly struct insfmt FINTRZP_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x4C03,	fp0_ea_f7, },
};

readonly struct insfmt FLOGNB_FMT[] = {
	{ DATAB,	FREG,		0,		0x5814,	fp0_ea_f7, },
};

readonly struct insfmt FLOGNW_FMT[] = {
	{ DATAW,	FREG,		0,		0x5014,	fp0_ea_f7, },
};

readonly struct insfmt FLOGNL_FMT[] = {
	{ DATAL,	FREG,		0,		0x4014,	fp0_ea_f7, },
};

readonly struct insfmt FLOGNS_FMT[] = {
	{ DATAF,	FREG,		0,		0x4414,	fp0_ea_f7, },
};

readonly struct insfmt FLOGND_FMT[] = {
	{ MEMD,		FREG,		0,		0x5414,	fp0_ea_f7, },
};

readonly struct insfmt FLOGNX_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x4814,	fp0_ea_f7, },
	{ FREG,		FREG,		0,		0x0014,	fp0_f10_f7, },
};

readonly struct insfmt FLOGNP_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x4C14,	fp0_ea_f7, },
};

readonly struct insfmt FLOGNP1B_FMT[] = {
	{ DATAB,	FREG,		0,		0x5806,	fp0_ea_f7, },
};

readonly struct insfmt FLOGNP1W_FMT[] = {
	{ DATAW,	FREG,		0,		0x5006,	fp0_ea_f7, },
};

readonly struct insfmt FLOGNP1L_FMT[] = {
	{ DATAL,	FREG,		0,		0x4006,	fp0_ea_f7, },
};

readonly struct insfmt FLOGNP1S_FMT[] = {
	{ DATAF,	FREG,		0,		0x4406,	fp0_ea_f7, },
};

readonly struct insfmt FLOGNP1D_FMT[] = {
	{ MEMD,		FREG,		0,		0x5406,	fp0_ea_f7, },
};

readonly struct insfmt FLOGNP1X_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x4806,	fp0_ea_f7, },
	{ FREG,		FREG,		0,		0x0006,	fp0_f10_f7, },
};

readonly struct insfmt FLOGNP1P_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x4C06,	fp0_ea_f7, },
};

readonly struct insfmt FLOG10B_FMT[] = {
	{ DATAB,	FREG,		0,		0x5815,	fp0_ea_f7, },
};

readonly struct insfmt FLOG10W_FMT[] = {
	{ DATAW,	FREG,		0,		0x5015,	fp0_ea_f7, },
};

readonly struct insfmt FLOG10L_FMT[] = {
	{ DATAL,	FREG,		0,		0x4015,	fp0_ea_f7, },
};

readonly struct insfmt FLOG10S_FMT[] = {
	{ DATAF,	FREG,		0,		0x4415,	fp0_ea_f7, },
};

readonly struct insfmt FLOG10D_FMT[] = {
	{ MEMD,		FREG,		0,		0x5415,	fp0_ea_f7, },
};

readonly struct insfmt FLOG10X_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x4815,	fp0_ea_f7, },
	{ FREG,		FREG,		0,		0x0015,	fp0_f10_f7, },
};

readonly struct insfmt FLOG10P_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x4C15,	fp0_ea_f7, },
};

readonly struct insfmt FLOG2B_FMT[] = {
	{ DATAB,	FREG,		0,		0x5816,	fp0_ea_f7, },
};

readonly struct insfmt FLOG2W_FMT[] = {
	{ DATAW,	FREG,		0,		0x5016,	fp0_ea_f7, },
};

readonly struct insfmt FLOG2L_FMT[] = {
	{ DATAL,	FREG,		0,		0x4016,	fp0_ea_f7, },
};

readonly struct insfmt FLOG2S_FMT[] = {
	{ DATAF,	FREG,		0,		0x4416,	fp0_ea_f7, },
};

readonly struct insfmt FLOG2D_FMT[] = {
	{ MEMD,		FREG,		0,		0x5416,	fp0_ea_f7, },
};

readonly struct insfmt FLOG2X_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x4816,	fp0_ea_f7, },
	{ FREG,		FREG,		0,		0x0016,	fp0_f10_f7, },
};

readonly struct insfmt FLOG2P_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x4C16,	fp0_ea_f7, },
};

readonly struct insfmt FMODB_FMT[] = {
	{ DATAB,	FREG,		0,		0x5821,	fp0_ea_f7, },
};

readonly struct insfmt FMODW_FMT[] = {
	{ DATAW,	FREG,		0,		0x5021,	fp0_ea_f7, },
};

readonly struct insfmt FMODL_FMT[] = {
	{ DATAL,	FREG,		0,		0x4021,	fp0_ea_f7, },
};

readonly struct insfmt FMODS_FMT[] = {
	{ DATAF,	FREG,		0,		0x4421,	fp0_ea_f7, },
};

readonly struct insfmt FMODD_FMT[] = {
	{ MEMD,		FREG,		0,		0x5421,	fp0_ea_f7, },
};

readonly struct insfmt FMODX_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x4821,	fp0_ea_f7, },
	{ FREG,		FREG,		0,		0x0021,	fp0_f10_f7, },
};

readonly struct insfmt FMODP_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x4C21,	fp0_ea_f7, },
};

readonly struct insfmt FMOVB_FMT[] = {
	{ DATAB,	FREG,		0,		0x5800,	fp0_ea_f7, },
	{ FREG,		DATAB,		0,		0x7800,	fp0_f7_ea, },
};

readonly struct insfmt FMOVW_FMT[] = {
	{ DATAW,	FREG,		0,		0x5000,	fp0_ea_f7, },
	{ FREG,		DATA&ALT,	0,		0x7000,	fp0_f7_ea, },
};

readonly struct insfmt FMOVL_FMT[] = {
	{ DATAL,	FREG,		0,		0x4000,	fp0_ea_f7, },
	{ DATAL,	FCNTL,		0,		0x9000,	fp0_ea, },
	{ DATAL,	FSTAT,		0,		0x8800,	fp0_ea, },
	{ ALLL,		FADDR,		0,		0x8400,	fp0_ea, },
	{ FREG,		DATA&ALT,	0,		0x6000,	fp0_f7_ea, },
	{ FCNTL,	DATA&ALT,	0,		0xB000,	fp0_ea2, },
	{ FSTAT,	DATA&ALT,	0,		0xA800,	fp0_ea2, },
	{ FADDR,	ALL&ALT,	0,		0xA400,	fp0_ea2, },
};

readonly struct insfmt FMOVS_FMT[] = {
	{ DATAF,	FREG,		0,		0x4400,	fp0_ea_f7, },
	{ FREG,		DATA&ALT,	0,		0x6400,	fp0_f7_ea, },
};

readonly struct insfmt FMOVD_FMT[] = {
	{ MEMD,		FREG,		0,		0x5400,	fp0_ea_f7, },
	{ FREG,		MEM&ALT,	0,		0x7400,	fp0_f7_ea, },
};

readonly struct insfmt FMOVX_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x4800,	fp0_ea_f7, },
	{ FREG,		MEM&ALT,	0,		0x6800,	fp0_f7_ea, },
	{ FREG,		FREG,		0,		0x0000,	fp0_f10_f7, },
};

readonly struct insfmt FMOVP_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x4C00,	fp0_ea_f7, },
	{ FREG,		MEM&ALT,	0,		0x6C00,	fp0_movp_ea, },
};

readonly struct insfmt FMOVCR_FMT[] = {
	{ IMMB,		FREG,		0,		0x5C00,	fp0_imm_f7, },
};

readonly struct insfmt FMOVML_FMT[] = {
	{ MEM&~IMML,	IMMB|REGLIST,	0,		0x8000,	fp0_ea_clist, },
	{ IMMB|REGLIST,	(MEM&ALT),	0,		0xA000,	fp0_clist_ea, },
};

readonly struct insfmt FMOVMX_FMT[] = {
	{ CONT|INC,	IMMB|REGLIST,	0,		0xD000,	fp0_ea_flist, },
	{ CONT|INC,	DREG,		0,		0xD800,	fp0_ea_r4, },
	{ IMMB|REGLIST,	(CONT&ALT),	0,		0xF000,	fp0_flist_ea, },
	{ IMMB|REGLIST,	DEC,		0,		0xE000,	fp0_flist_ea, },
	{ DREG,		(CONT&ALT),	0,		0xF800,	fp0_r4_ea, },
	{ DREG,		DEC,		0,		0xE800,	fp0_r4_ea, },
};

readonly struct insfmt FMULB_FMT[] = {
	{ DATAB,	FREG,		0,		0x5823,	fp0_ea_f7, },
};

readonly struct insfmt FMULW_FMT[] = {
	{ DATAW,	FREG,		0,		0x5023,	fp0_ea_f7, },
};

readonly struct insfmt FMULL_FMT[] = {
	{ DATAL,	FREG,		0,		0x4023,	fp0_ea_f7, },
};

readonly struct insfmt FMULS_FMT[] = {
	{ DATAF,	FREG,		0,		0x4423,	fp0_ea_f7, },
};

readonly struct insfmt FMULD_FMT[] = {
	{ MEMD,		FREG,		0,		0x5423,	fp0_ea_f7, },
};

readonly struct insfmt FMULX_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x4823,	fp0_ea_f7, },
	{ FREG,		FREG,		0,		0x0023,	fp0_f10_f7, },
};

readonly struct insfmt FMULP_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x4C23,	fp0_ea_f7, },
};

readonly struct insfmt FNEGB_FMT[] = {
	{ DATAB,	FREG,		0,		0x581A,	fp0_ea_f7, },
};

readonly struct insfmt FNEGW_FMT[] = {
	{ DATAW,	FREG,		0,		0x501A,	fp0_ea_f7, },
};

readonly struct insfmt FNEGL_FMT[] = {
	{ DATAL,	FREG,		0,		0x401A,	fp0_ea_f7, },
};

readonly struct insfmt FNEGS_FMT[] = {
	{ DATAF,	FREG,		0,		0x441A,	fp0_ea_f7, },
};

readonly struct insfmt FNEGD_FMT[] = {
	{ MEMD,		FREG,		0,		0x541A,	fp0_ea_f7, },
};

readonly struct insfmt FNEGX_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x481A,	fp0_ea_f7, },
	{ FREG,		FREG,		0,		0x001A,	fp0_f10_f7, },
};

readonly struct insfmt FNEGP_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x4C1A,	fp0_ea_f7, },
};

readonly struct insfmt FREMB_FMT[] = {
	{ DATAB,	FREG,		0,		0x5825,	fp0_ea_f7, },
};

readonly struct insfmt FREMW_FMT[] = {
	{ DATAW,	FREG,		0,		0x5025,	fp0_ea_f7, },
};

readonly struct insfmt FREML_FMT[] = {
	{ DATAL,	FREG,		0,		0x4025,	fp0_ea_f7, },
};

readonly struct insfmt FREMS_FMT[] = {
	{ DATAF,	FREG,		0,		0x4425,	fp0_ea_f7, },
};

readonly struct insfmt FREMD_FMT[] = {
	{ MEMD,		FREG,		0,		0x5425,	fp0_ea_f7, },
};

readonly struct insfmt FREMX_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x4825,	fp0_ea_f7, },
	{ FREG,		FREG,		0,		0x0025,	fp0_f10_f7, },
};

readonly struct insfmt FREMP_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x4C25,	fp0_ea_f7, },
};

readonly struct insfmt FRESTORE_FMT[] = {
	{ CONT|INC,	0,		0,		0xF340,	ea,	},
};

readonly struct insfmt FSAVE_FMT[] = {
	{ (CONT&ALT)|DEC,	0,	0,		0xF300,	ea,	},
};

readonly struct insfmt FSCALEB_FMT[] = {
	{ DATAB,	FREG,		0,		0x5826,	fp0_ea_f7, },
};

readonly struct insfmt FSCALEW_FMT[] = {
	{ DATAW,	FREG,		0,		0x5026,	fp0_ea_f7, },
};

readonly struct insfmt FSCALEL_FMT[] = {
	{ DATAL,	FREG,		0,		0x4026,	fp0_ea_f7, },
};

readonly struct insfmt FSCALES_FMT[] = {
	{ DATAF,	FREG,		0,		0x4426,	fp0_ea_f7, },
};

readonly struct insfmt FSCALED_FMT[] = {
	{ MEMD,		FREG,		0,		0x5426,	fp0_ea_f7, },
};

readonly struct insfmt FSCALEX_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x4826,	fp0_ea_f7, },
	{ FREG,		FREG,		0,		0x0026,	fp0_f10_f7, },
};

readonly struct insfmt FSCALEP_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x4C26,	fp0_ea_f7, },
};

readonly struct insfmt FSGLDIVB_FMT[] = {
	{ DATAB,	FREG,		0,		0x5824,	fp0_ea_f7, },
};

readonly struct insfmt FSGLDIVW_FMT[] = {
	{ DATAW,	FREG,		0,		0x5024,	fp0_ea_f7, },
};

readonly struct insfmt FSGLDIVL_FMT[] = {
	{ DATAL,	FREG,		0,		0x4024,	fp0_ea_f7, },
};

readonly struct insfmt FSGLDIVS_FMT[] = {
	{ DATAF,	FREG,		0,		0x4424,	fp0_ea_f7, },
};

readonly struct insfmt FSGLDIVD_FMT[] = {
	{ MEMD,		FREG,		0,		0x5424,	fp0_ea_f7, },
};

readonly struct insfmt FSGLDIVX_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x4824,	fp0_ea_f7, },
	{ FREG,		FREG,		0,		0x0024,	fp0_f10_f7, },
};

readonly struct insfmt FSGLDIVP_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x4C24,	fp0_ea_f7, },
};

readonly struct insfmt FSGLMULB_FMT[] = {
	{ DATAB,	FREG,		0,		0x5827,	fp0_ea_f7, },
};

readonly struct insfmt FSGLMULW_FMT[] = {
	{ DATAW,	FREG,		0,		0x5027,	fp0_ea_f7, },
};

readonly struct insfmt FSGLMULL_FMT[] = {
	{ DATAL,	FREG,		0,		0x4027,	fp0_ea_f7, },
};

readonly struct insfmt FSGLMULS_FMT[] = {
	{ DATAF,	FREG,		0,		0x4427,	fp0_ea_f7, },
};

readonly struct insfmt FSGLMULD_FMT[] = {
	{ MEMD,		FREG,		0,		0x5427,	fp0_ea_f7, },
};

readonly struct insfmt FSGLMULX_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x4827,	fp0_ea_f7, },
	{ FREG,		FREG,		0,		0x0027,	fp0_f10_f7, },
};

readonly struct insfmt FSGLMULP_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x4C27,	fp0_ea_f7, },
};

readonly struct insfmt FSINB_FMT[] = {
	{ DATAB,	FREG,		0,		0x580E,	fp0_ea_f7, },
};

readonly struct insfmt FSINW_FMT[] = {
	{ DATAW,	FREG,		0,		0x500E,	fp0_ea_f7, },
};

readonly struct insfmt FSINL_FMT[] = {
	{ DATAL,	FREG,		0,		0x400E,	fp0_ea_f7, },
};

readonly struct insfmt FSINS_FMT[] = {
	{ DATAF,	FREG,		0,		0x440E,	fp0_ea_f7, },
};

readonly struct insfmt FSIND_FMT[] = {
	{ MEMD,		FREG,		0,		0x540E,	fp0_ea_f7, },
};

readonly struct insfmt FSINX_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x480E,	fp0_ea_f7, },
	{ FREG,		FREG,		0,		0x000E,	fp0_f10_f7, },
};

readonly struct insfmt FSINP_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x4C0E,	fp0_ea_f7, },
};

readonly struct insfmt FSINCOSB_FMT[] = {
	{ DATAB,	FREGPAIR,	0,		0x5830,	fp0_ea_fpair, },
};

readonly struct insfmt FSINCOSW_FMT[] = {
	{ DATAW,	FREGPAIR,	0,		0x5030,	fp0_ea_fpair, },
};

readonly struct insfmt FSINCOSL_FMT[] = {
	{ DATAL,	FREGPAIR,	0,		0x4030,	fp0_ea_fpair, },
};

readonly struct insfmt FSINCOSS_FMT[] = {
	{ DATAF,	FREGPAIR,	0,		0x4430,	fp0_ea_fpair, },
};

readonly struct insfmt FSINCOSD_FMT[] = {
	{ MEMD,		FREGPAIR,	0,		0x5430,	fp0_ea_fpair, },
};

readonly struct insfmt FSINCOSX_FMT[] = {
	{ MEM&~IMML,	FREGPAIR,	0,		0x4830,	fp0_ea_fpair, },
	{ FREG,		FREGPAIR,	0,		0x0030,	fp0_f10_fpair,},
};

readonly struct insfmt FSINCOSP_FMT[] = {
	{ MEM&~IMML,	FREGPAIR,	0,		0x4C30,	fp0_ea_fpair, },
};

readonly struct insfmt FSINHB_FMT[] = {
	{ DATAB,	FREG,		0,		0x5802,	fp0_ea_f7, },
};

readonly struct insfmt FSINHW_FMT[] = {
	{ DATAW,	FREG,		0,		0x5002,	fp0_ea_f7, },
};

readonly struct insfmt FSINHL_FMT[] = {
	{ DATAL,	FREG,		0,		0x4002,	fp0_ea_f7, },
};

readonly struct insfmt FSINHS_FMT[] = {
	{ DATAF,	FREG,		0,		0x4402,	fp0_ea_f7, },
};

readonly struct insfmt FSINHD_FMT[] = {
	{ MEMD,		FREG,		0,		0x5402,	fp0_ea_f7, },
};

readonly struct insfmt FSINHX_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x4802,	fp0_ea_f7, },
	{ FREG,		FREG,		0,		0x0002,	fp0_f10_f7, },
};

readonly struct insfmt FSINHP_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x4C02,	fp0_ea_f7, },
};

readonly struct insfmt FSQRTB_FMT[] = {
	{ DATAB,	FREG,		0,		0x5804,	fp0_ea_f7, },
};

readonly struct insfmt FSQRTW_FMT[] = {
	{ DATAW,	FREG,		0,		0x5004,	fp0_ea_f7, },
};

readonly struct insfmt FSQRTL_FMT[] = {
	{ DATAL,	FREG,		0,		0x4004,	fp0_ea_f7, },
};

readonly struct insfmt FSQRTS_FMT[] = {
	{ DATAF,	FREG,		0,		0x4404,	fp0_ea_f7, },
};

readonly struct insfmt FSQRTD_FMT[] = {
	{ MEMD,		FREG,		0,		0x5404,	fp0_ea_f7, },
};

readonly struct insfmt FSQRTX_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x4804,	fp0_ea_f7, },
	{ FREG,		FREG,		0,		0x0004,	fp0_f10_f7, },
};

readonly struct insfmt FSQRTP_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x4C04,	fp0_ea_f7, },
};

readonly struct insfmt FSUBB_FMT[] = {
	{ DATAB,	FREG,		0,		0x5828,	fp0_ea_f7, },
};

readonly struct insfmt FSUBW_FMT[] = {
	{ DATAW,	FREG,		0,		0x5028,	fp0_ea_f7, },
};

readonly struct insfmt FSUBL_FMT[] = {
	{ DATAL,	FREG,		0,		0x4028,	fp0_ea_f7, },
};

readonly struct insfmt FSUBS_FMT[] = {
	{ DATAF,	FREG,		0,		0x4428,	fp0_ea_f7, },
};

readonly struct insfmt FSUBD_FMT[] = {
	{ MEMD,		FREG,		0,		0x5428,	fp0_ea_f7, },
};

readonly struct insfmt FSUBX_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x4828,	fp0_ea_f7, },
	{ FREG,		FREG,		0,		0x0028,	fp0_f10_f7, },
};

readonly struct insfmt FSUBP_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x4C28,	fp0_ea_f7, },
};

readonly struct insfmt FTANB_FMT[] = {
	{ DATAB,	FREG,		0,		0x580F,	fp0_ea_f7, },
};

readonly struct insfmt FTANW_FMT[] = {
	{ DATAW,	FREG,		0,		0x500F,	fp0_ea_f7, },
};

readonly struct insfmt FTANL_FMT[] = {
	{ DATAL,	FREG,		0,		0x400F,	fp0_ea_f7, },
};

readonly struct insfmt FTANS_FMT[] = {
	{ DATAF,	FREG,		0,		0x440F,	fp0_ea_f7, },
};

readonly struct insfmt FTAND_FMT[] = {
	{ MEMD,		FREG,		0,		0x540F,	fp0_ea_f7, },
};

readonly struct insfmt FTANX_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x480F,	fp0_ea_f7, },
	{ FREG,		FREG,		0,		0x000F,	fp0_f10_f7, },
};

readonly struct insfmt FTANP_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x4C0F,	fp0_ea_f7, },
};

readonly struct insfmt FTANHB_FMT[] = {
	{ DATAB,	FREG,		0,		0x5809,	fp0_ea_f7, },
};

readonly struct insfmt FTANHW_FMT[] = {
	{ DATAW,	FREG,		0,		0x5009,	fp0_ea_f7, },
};

readonly struct insfmt FTANHL_FMT[] = {
	{ DATAL,	FREG,		0,		0x4009,	fp0_ea_f7, },
};

readonly struct insfmt FTANHS_FMT[] = {
	{ DATAF,	FREG,		0,		0x4409,	fp0_ea_f7, },
};

readonly struct insfmt FTANHD_FMT[] = {
	{ MEMD,		FREG,		0,		0x5409,	fp0_ea_f7, },
};

readonly struct insfmt FTANHX_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x4809,	fp0_ea_f7, },
	{ FREG,		FREG,		0,		0x0009,	fp0_f10_f7, },
};

readonly struct insfmt FTANHP_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x4C09,	fp0_ea_f7, },
};

readonly struct insfmt FTENTOXB_FMT[] = {
	{ DATAB,	FREG,		0,		0x5812,	fp0_ea_f7, },
};

readonly struct insfmt FTENTOXW_FMT[] = {
	{ DATAW,	FREG,		0,		0x5012,	fp0_ea_f7, },
};

readonly struct insfmt FTENTOXL_FMT[] = {
	{ DATAL,	FREG,		0,		0x4012,	fp0_ea_f7, },
};

readonly struct insfmt FTENTOXS_FMT[] = {
	{ DATAF,	FREG,		0,		0x4412,	fp0_ea_f7, },
};

readonly struct insfmt FTENTOXD_FMT[] = {
	{ MEMD,		FREG,		0,		0x5412,	fp0_ea_f7, },
};

readonly struct insfmt FTENTOXX_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x4812,	fp0_ea_f7, },
	{ FREG,		FREG,		0,		0x0012,	fp0_f10_f7, },
};

readonly struct insfmt FTENTOXP_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x4C12,	fp0_ea_f7, },
};

readonly struct insfmt FTSTB_FMT[] = {
	{ DATAB,	0,		0,		0x583A,	fp0_ea,	},
};

readonly struct insfmt FTSTW_FMT[] = {
	{ DATAW,	0,		0,		0x503A,	fp0_ea,	},
};

readonly struct insfmt FTSTL_FMT[] = {
	{ DATAL,	0,		0,		0x403A,	fp0_ea,	},
};

readonly struct insfmt FTSTS_FMT[] = {
	{ DATAF,	0,		0,		0x443A,	fp0_ea,	},
};

readonly struct insfmt FTSTD_FMT[] = {
	{ MEMD,		0,		0,		0x543A,	fp0_ea,	},
};

readonly struct insfmt FTSTX_FMT[] = {
	{ MEM&~IMML,	0,		0,		0x483A,	fp0_ea,	},
	{ FREG,		0,		0,		0x003A,	fp0_f10,},
};

readonly struct insfmt FTSTP_FMT[] = {
	{ MEM&~IMML,	0,		0,		0x4C3A,	fp0_ea,	},
};

readonly struct insfmt FTWOTOXB_FMT[] = {
	{ DATAB,	FREG,		0,		0x5811,	fp0_ea_f7, },
};

readonly struct insfmt FTWOTOXW_FMT[] = {
	{ DATAW,	FREG,		0,		0x5011,	fp0_ea_f7, },
};

readonly struct insfmt FTWOTOXL_FMT[] = {
	{ DATAL,	FREG,		0,		0x4011,	fp0_ea_f7, },
};

readonly struct insfmt FTWOTOXS_FMT[] = {
	{ DATAF,	FREG,		0,		0x4411,	fp0_ea_f7, },
};

readonly struct insfmt FTWOTOXD_FMT[] = {
	{ MEMD,		FREG,		0,		0x5411,	fp0_ea_f7, },
};

readonly struct insfmt FTWOTOXX_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x4811,	fp0_ea_f7, },
	{ FREG,		FREG,		0,		0x0011,	fp0_f10_f7, },
};

readonly struct insfmt FTWOTOXP_FMT[] = {
	{ MEM&~IMML,	FREG,		0,		0x4C11,	fp0_ea_f7, },
};

readonly struct insfmt FNOP_FMT[] = {
	{ 0,		0,		0,		0xF280,	fp2_nop, },
};

readonly struct insfmt FBFW_FMT[] = {
	{ ABS,		0,		0,		0xF280,	fp_disp16, },
};

readonly struct insfmt FBEQW_FMT[] = {
	{ ABS,		0,		0,		0xF281,	fp_disp16, },
};

readonly struct insfmt FBOGTW_FMT[] = {
	{ ABS,		0,		0,		0xF282,	fp_disp16, },
};

readonly struct insfmt FBOGEW_FMT[] = {
	{ ABS,		0,		0,		0xF283,	fp_disp16, },
};

readonly struct insfmt FBOLTW_FMT[] = {
	{ ABS,		0,		0,		0xF284,	fp_disp16, },
};

readonly struct insfmt FBOLEW_FMT[] = {
	{ ABS,		0,		0,		0xF285,	fp_disp16, },
};

readonly struct insfmt FBOGLW_FMT[] = {
	{ ABS,		0,		0,		0xF286,	fp_disp16, },
};

readonly struct insfmt FBORW_FMT[] = {
	{ ABS,		0,		0,		0xF287,	fp_disp16, },
};

readonly struct insfmt FBUNW_FMT[] = {
	{ ABS,		0,		0,		0xF288,	fp_disp16, },
};

readonly struct insfmt FBUEQW_FMT[] = {
	{ ABS,		0,		0,		0xF289,	fp_disp16, },
};

readonly struct insfmt FBUGTW_FMT[] = {
	{ ABS,		0,		0,		0xF28A,	fp_disp16, },
};

readonly struct insfmt FBUGEW_FMT[] = {
	{ ABS,		0,		0,		0xF28B,	fp_disp16, },
};

readonly struct insfmt FBULTW_FMT[] = {
	{ ABS,		0,		0,		0xF28C,	fp_disp16, },
};

readonly struct insfmt FBULEW_FMT[] = {
	{ ABS,		0,		0,		0xF28D,	fp_disp16, },
};

readonly struct insfmt FBNEW_FMT[] = {
	{ ABS,		0,		0,		0xF28E,	fp_disp16, },
};

readonly struct insfmt FBTW_FMT[] = {
	{ ABS,		0,		0,		0xF28F,	fp_disp16, },
};

readonly struct insfmt FBSFW_FMT[] = {
	{ ABS,		0,		0,		0xF290,	fp_disp16, },
};

readonly struct insfmt FBSEQW_FMT[] = {
	{ ABS,		0,		0,		0xF291,	fp_disp16, },
};

readonly struct insfmt FBGTW_FMT[] = {
	{ ABS,		0,		0,		0xF292,	fp_disp16, },
};

readonly struct insfmt FBGEW_FMT[] = {
	{ ABS,		0,		0,		0xF293,	fp_disp16, },
};

readonly struct insfmt FBLTW_FMT[] = {
	{ ABS,		0,		0,		0xF294,	fp_disp16, },
};

readonly struct insfmt FBLEW_FMT[] = {
	{ ABS,		0,		0,		0xF295,	fp_disp16, },
};

readonly struct insfmt FBGLW_FMT[] = {
	{ ABS,		0,		0,		0xF296,	fp_disp16, },
};

readonly struct insfmt FBGLEW_FMT[] = {
	{ ABS,		0,		0,		0xF297,	fp_disp16, },
};

readonly struct insfmt FBNGLEW_FMT[] = {
	{ ABS,		0,		0,		0xF298,	fp_disp16, },
};

readonly struct insfmt FBNGLW_FMT[] = {
	{ ABS,		0,		0,		0xF299,	fp_disp16, },
};

readonly struct insfmt FBNLEW_FMT[] = {
	{ ABS,		0,		0,		0xF29A,	fp_disp16, },
};

readonly struct insfmt FBNLTW_FMT[] = {
	{ ABS,		0,		0,		0xF29B,	fp_disp16, },
};

readonly struct insfmt FBNGEW_FMT[] = {
	{ ABS,		0,		0,		0xF29C,	fp_disp16, },
};

readonly struct insfmt FBNGTW_FMT[] = {
	{ ABS,		0,		0,		0xF29D,	fp_disp16, },
};

readonly struct insfmt FBSNEW_FMT[] = {
	{ ABS,		0,		0,		0xF29E,	fp_disp16, },
};

readonly struct insfmt FBSTW_FMT[] = {
	{ ABS,		0,		0,		0xF29F,	fp_disp16, },
};

readonly struct insfmt FBFL_FMT[] = {
	{ ABS,		0,		0,		0xF2C0,	fp_disp32, },
};

readonly struct insfmt FBEQL_FMT[] = {
	{ ABS,		0,		0,		0xF2C1,	fp_disp32, },
};

readonly struct insfmt FBOGTL_FMT[] = {
	{ ABS,		0,		0,		0xF2C2,	fp_disp32, },
};

readonly struct insfmt FBOGEL_FMT[] = {
	{ ABS,		0,		0,		0xF2C3,	fp_disp32, },
};

readonly struct insfmt FBOLTL_FMT[] = {
	{ ABS,		0,		0,		0xF2C4,	fp_disp32, },
};

readonly struct insfmt FBOLEL_FMT[] = {
	{ ABS,		0,		0,		0xF2C5,	fp_disp32, },
};

readonly struct insfmt FBOGLL_FMT[] = {
	{ ABS,		0,		0,		0xF2C6,	fp_disp32, },
};

readonly struct insfmt FBORL_FMT[] = {
	{ ABS,		0,		0,		0xF2C7,	fp_disp32, },
};

readonly struct insfmt FBUNL_FMT[] = {
	{ ABS,		0,		0,		0xF2C8,	fp_disp32, },
};

readonly struct insfmt FBUEQL_FMT[] = {
	{ ABS,		0,		0,		0xF2C9,	fp_disp32, },
};

readonly struct insfmt FBUGTL_FMT[] = {
	{ ABS,		0,		0,		0xF2CA,	fp_disp32, },
};

readonly struct insfmt FBUGEL_FMT[] = {
	{ ABS,		0,		0,		0xF2CB,	fp_disp32, },
};

readonly struct insfmt FBULTL_FMT[] = {
	{ ABS,		0,		0,		0xF2CC,	fp_disp32, },
};

readonly struct insfmt FBULEL_FMT[] = {
	{ ABS,		0,		0,		0xF2CD,	fp_disp32, },
};

readonly struct insfmt FBNEL_FMT[] = {
	{ ABS,		0,		0,		0xF2CE,	fp_disp32, },
};

readonly struct insfmt FBTL_FMT[] = {
	{ ABS,		0,		0,		0xF2CF,	fp_disp32, },
};

readonly struct insfmt FBSFL_FMT[] = {
	{ ABS,		0,		0,		0xF2D0,	fp_disp32, },
};

readonly struct insfmt FBSEQL_FMT[] = {
	{ ABS,		0,		0,		0xF2D1,	fp_disp32, },
};

readonly struct insfmt FBGTL_FMT[] = {
	{ ABS,		0,		0,		0xF2D2,	fp_disp32, },
};

readonly struct insfmt FBGEL_FMT[] = {
	{ ABS,		0,		0,		0xF2D3,	fp_disp32, },
};

readonly struct insfmt FBLTL_FMT[] = {
	{ ABS,		0,		0,		0xF2D4,	fp_disp32, },
};

readonly struct insfmt FBLEL_FMT[] = {
	{ ABS,		0,		0,		0xF2D5,	fp_disp32, },
};

readonly struct insfmt FBGLL_FMT[] = {
	{ ABS,		0,		0,		0xF2D6,	fp_disp32, },
};

readonly struct insfmt FBGLEL_FMT[] = {
	{ ABS,		0,		0,		0xF2D7,	fp_disp32, },
};

readonly struct insfmt FBNGLEL_FMT[] = {
	{ ABS,		0,		0,		0xF2D8,	fp_disp32, },
};

readonly struct insfmt FBNGLL_FMT[] = {
	{ ABS,		0,		0,		0xF2D9,	fp_disp32, },
};

readonly struct insfmt FBNLEL_FMT[] = {
	{ ABS,		0,		0,		0xF2DA,	fp_disp32, },
};

readonly struct insfmt FBNLTL_FMT[] = {
	{ ABS,		0,		0,		0xF2DB,	fp_disp32, },
};

readonly struct insfmt FBNGEL_FMT[] = {
	{ ABS,		0,		0,		0xF2DC,	fp_disp32, },
};

readonly struct insfmt FBNGTL_FMT[] = {
	{ ABS,		0,		0,		0xF2DD,	fp_disp32, },
};

readonly struct insfmt FBSNEL_FMT[] = {
	{ ABS,		0,		0,		0xF2DE,	fp_disp32, },
};

readonly struct insfmt FBSTL_FMT[] = {
	{ ABS,		0,		0,		0xF2DF,	fp_disp32, },
};

readonly struct insfmt FDBF_FMT[] = {
	{ DREG,		ABS,		0,		0x00,	fp1_r0_disp16, },
};

readonly struct insfmt FDBEQ_FMT[] = {
	{ DREG,		ABS,		0,		0x01,	fp1_r0_disp16, },
};

readonly struct insfmt FDBOGT_FMT[] = {
	{ DREG,		ABS,		0,		0x02,	fp1_r0_disp16, },
};

readonly struct insfmt FDBOGE_FMT[] = {
	{ DREG,		ABS,		0,		0x03,	fp1_r0_disp16, },
};

readonly struct insfmt FDBOLT_FMT[] = {
	{ DREG,		ABS,		0,		0x04,	fp1_r0_disp16, },
};

readonly struct insfmt FDBOLE_FMT[] = {
	{ DREG,		ABS,		0,		0x05,	fp1_r0_disp16, },
};

readonly struct insfmt FDBOGL_FMT[] = {
	{ DREG,		ABS,		0,		0x06,	fp1_r0_disp16, },
};

readonly struct insfmt FDBOR_FMT[] = {
	{ DREG,		ABS,		0,		0x07,	fp1_r0_disp16, },
};

readonly struct insfmt FDBUN_FMT[] = {
	{ DREG,		ABS,		0,		0x08,	fp1_r0_disp16, },
};

readonly struct insfmt FDBUEQ_FMT[] = {
	{ DREG,		ABS,		0,		0x09,	fp1_r0_disp16, },
};

readonly struct insfmt FDBUGT_FMT[] = {
	{ DREG,		ABS,		0,		0x0A,	fp1_r0_disp16, },
};

readonly struct insfmt FDBUGE_FMT[] = {
	{ DREG,		ABS,		0,		0x0B,	fp1_r0_disp16, },
};

readonly struct insfmt FDBULT_FMT[] = {
	{ DREG,		ABS,		0,		0x0C,	fp1_r0_disp16, },
};

readonly struct insfmt FDBULE_FMT[] = {
	{ DREG,		ABS,		0,		0x0D,	fp1_r0_disp16, },
};

readonly struct insfmt FDBNE_FMT[] = {
	{ DREG,		ABS,		0,		0x0E,	fp1_r0_disp16, },
};

readonly struct insfmt FDBT_FMT[] = {
	{ DREG,		ABS,		0,		0x0F,	fp1_r0_disp16, },
};

readonly struct insfmt FDBSF_FMT[] = {
	{ DREG,		ABS,		0,		0x10,	fp1_r0_disp16, },
};

readonly struct insfmt FDBSEQ_FMT[] = {
	{ DREG,		ABS,		0,		0x11,	fp1_r0_disp16, },
};

readonly struct insfmt FDBGT_FMT[] = {
	{ DREG,		ABS,		0,		0x12,	fp1_r0_disp16, },
};

readonly struct insfmt FDBGE_FMT[] = {
	{ DREG,		ABS,		0,		0x13,	fp1_r0_disp16, },
};

readonly struct insfmt FDBLT_FMT[] = {
	{ DREG,		ABS,		0,		0x14,	fp1_r0_disp16, },
};

readonly struct insfmt FDBLE_FMT[] = {
	{ DREG,		ABS,		0,		0x15,	fp1_r0_disp16, },
};

readonly struct insfmt FDBGL_FMT[] = {
	{ DREG,		ABS,		0,		0x16,	fp1_r0_disp16, },
};

readonly struct insfmt FDBGLE_FMT[] = {
	{ DREG,		ABS,		0,		0x17,	fp1_r0_disp16, },
};

readonly struct insfmt FDBNGLE_FMT[] = {
	{ DREG,		ABS,		0,		0x18,	fp1_r0_disp16, },
};

readonly struct insfmt FDBNGL_FMT[] = {
	{ DREG,		ABS,		0,		0x19,	fp1_r0_disp16, },
};

readonly struct insfmt FDBNLE_FMT[] = {
	{ DREG,		ABS,		0,		0x1A,	fp1_r0_disp16, },
};

readonly struct insfmt FDBNLT_FMT[] = {
	{ DREG,		ABS,		0,		0x1B,	fp1_r0_disp16, },
};

readonly struct insfmt FDBNGE_FMT[] = {
	{ DREG,		ABS,		0,		0x1C,	fp1_r0_disp16, },
};

readonly struct insfmt FDBNGT_FMT[] = {
	{ DREG,		ABS,		0,		0x1D,	fp1_r0_disp16, },
};

readonly struct insfmt FDBSNE_FMT[] = {
	{ DREG,		ABS,		0,		0x1E,	fp1_r0_disp16, },
};

readonly struct insfmt FDBST_FMT[] = {
	{ DREG,		ABS,		0,		0x1F,	fp1_r0_disp16, },
};

readonly struct insfmt FSF_FMT[] = {
	{ DATA&ALT,	0,		0,		0x00,	fp1_ea, },
};

readonly struct insfmt FSEQ_FMT[] = {
	{ DATA&ALT,	0,		0,		0x01,	fp1_ea, },
};

readonly struct insfmt FSOGT_FMT[] = {
	{ DATA&ALT,	0,		0,		0x02,	fp1_ea, },
};

readonly struct insfmt FSOGE_FMT[] = {
	{ DATA&ALT,	0,		0,		0x03,	fp1_ea, },
};

readonly struct insfmt FSOLT_FMT[] = {
	{ DATA&ALT,	0,		0,		0x04,	fp1_ea, },
};

readonly struct insfmt FSOLE_FMT[] = {
	{ DATA&ALT,	0,		0,		0x05,	fp1_ea, },
};

readonly struct insfmt FSOGL_FMT[] = {
	{ DATA&ALT,	0,		0,		0x06,	fp1_ea, },
};

readonly struct insfmt FSOR_FMT[] = {
	{ DATA&ALT,	0,		0,		0x07,	fp1_ea, },
};

readonly struct insfmt FSUN_FMT[] = {
	{ DATA&ALT,	0,		0,		0x08,	fp1_ea, },
};

readonly struct insfmt FSUEQ_FMT[] = {
	{ DATA&ALT,	0,		0,		0x09,	fp1_ea, },
};

readonly struct insfmt FSUGT_FMT[] = {
	{ DATA&ALT,	0,		0,		0x0A,	fp1_ea, },
};

readonly struct insfmt FSUGE_FMT[] = {
	{ DATA&ALT,	0,		0,		0x0B,	fp1_ea, },
};

readonly struct insfmt FSULT_FMT[] = {
	{ DATA&ALT,	0,		0,		0x0C,	fp1_ea, },
};

readonly struct insfmt FSULE_FMT[] = {
	{ DATA&ALT,	0,		0,		0x0D,	fp1_ea, },
};

readonly struct insfmt FSNE_FMT[] = {
	{ DATA&ALT,	0,		0,		0x0E,	fp1_ea, },
};

readonly struct insfmt FST_FMT[] = {
	{ DATA&ALT,	0,		0,		0x0F,	fp1_ea, },
};

readonly struct insfmt FSSF_FMT[] = {
	{ DATA&ALT,	0,		0,		0x10,	fp1_ea, },
};

readonly struct insfmt FSSEQ_FMT[] = {
	{ DATA&ALT,	0,		0,		0x11,	fp1_ea, },
};

readonly struct insfmt FSGT_FMT[] = {
	{ DATA&ALT,	0,		0,		0x12,	fp1_ea, },
};

readonly struct insfmt FSGE_FMT[] = {
	{ DATA&ALT,	0,		0,		0x13,	fp1_ea, },
};

readonly struct insfmt FSLT_FMT[] = {
	{ DATA&ALT,	0,		0,		0x14,	fp1_ea, },
};

readonly struct insfmt FSLE_FMT[] = {
	{ DATA&ALT,	0,		0,		0x15,	fp1_ea, },
};

readonly struct insfmt FSGL_FMT[] = {
	{ DATA&ALT,	0,		0,		0x16,	fp1_ea, },
};

readonly struct insfmt FSGLE_FMT[] = {
	{ DATA&ALT,	0,		0,		0x17,	fp1_ea, },
};

readonly struct insfmt FSNGLE_FMT[] = {
	{ DATA&ALT,	0,		0,		0x18,	fp1_ea, },
};

readonly struct insfmt FSNGL_FMT[] = {
	{ DATA&ALT,	0,		0,		0x19,	fp1_ea, },
};

readonly struct insfmt FSNLE_FMT[] = {
	{ DATA&ALT,	0,		0,		0x1A,	fp1_ea, },
};

readonly struct insfmt FSNLT_FMT[] = {
	{ DATA&ALT,	0,		0,		0x1B,	fp1_ea, },
};

readonly struct insfmt FSNGE_FMT[] = {
	{ DATA&ALT,	0,		0,		0x1C,	fp1_ea, },
};

readonly struct insfmt FSNGT_FMT[] = {
	{ DATA&ALT,	0,		0,		0x1D,	fp1_ea, },
};

readonly struct insfmt FSSNE_FMT[] = {
	{ DATA&ALT,	0,		0,		0x1E,	fp1_ea, },
};

readonly struct insfmt FSST_FMT[] = {
	{ DATA&ALT,	0,		0,		0x1F,	fp1_ea, },
};

readonly struct insfmt FTPF_FMT[] = {
	{ 0,		0,		0,		0x00,	fp1_trap, },
};

readonly struct insfmt FTPEQ_FMT[] = {
	{ 0,		0,		0,		0x01,	fp1_trap, },
};

readonly struct insfmt FTPOGT_FMT[] = {
	{ 0,		0,		0,		0x02,	fp1_trap, },
};

readonly struct insfmt FTPOGE_FMT[] = {
	{ 0,		0,		0,		0x03,	fp1_trap, },
};

readonly struct insfmt FTPOLT_FMT[] = {
	{ 0,		0,		0,		0x04,	fp1_trap, },
};

readonly struct insfmt FTPOLE_FMT[] = {
	{ 0,		0,		0,		0x05,	fp1_trap, },
};

readonly struct insfmt FTPOGL_FMT[] = {
	{ 0,		0,		0,		0x06,	fp1_trap, },
};

readonly struct insfmt FTPOR_FMT[] = {
	{ 0,		0,		0,		0x07,	fp1_trap, },
};

readonly struct insfmt FTPUN_FMT[] = {
	{ 0,		0,		0,		0x08,	fp1_trap, },
};

readonly struct insfmt FTPUEQ_FMT[] = {
	{ 0,		0,		0,		0x09,	fp1_trap, },
};

readonly struct insfmt FTPUGT_FMT[] = {
	{ 0,		0,		0,		0x0A,	fp1_trap, },
};

readonly struct insfmt FTPUGE_FMT[] = {
	{ 0,		0,		0,		0x0B,	fp1_trap, },
};

readonly struct insfmt FTPULT_FMT[] = {
	{ 0,		0,		0,		0x0C,	fp1_trap, },
};

readonly struct insfmt FTPULE_FMT[] = {
	{ 0,		0,		0,		0x0D,	fp1_trap, },
};

readonly struct insfmt FTPNE_FMT[] = {
	{ 0,		0,		0,		0x0E,	fp1_trap, },
};

readonly struct insfmt FTPT_FMT[] = {
	{ 0,		0,		0,		0x0F,	fp1_trap, },
};

readonly struct insfmt FTPSF_FMT[] = {
	{ 0,		0,		0,		0x10,	fp1_trap, },
};

readonly struct insfmt FTPSEQ_FMT[] = {
	{ 0,		0,		0,		0x11,	fp1_trap, },
};

readonly struct insfmt FTPGT_FMT[] = {
	{ 0,		0,		0,		0x12,	fp1_trap, },
};

readonly struct insfmt FTPGE_FMT[] = {
	{ 0,		0,		0,		0x13,	fp1_trap, },
};

readonly struct insfmt FTPLT_FMT[] = {
	{ 0,		0,		0,		0x14,	fp1_trap, },
};

readonly struct insfmt FTPLE_FMT[] = {
	{ 0,		0,		0,		0x15,	fp1_trap, },
};

readonly struct insfmt FTPGL_FMT[] = {
	{ 0,		0,		0,		0x16,	fp1_trap, },
};

readonly struct insfmt FTPGLE_FMT[] = {
	{ 0,		0,		0,		0x17,	fp1_trap, },
};

readonly struct insfmt FTPNGLE_FMT[] = {
	{ 0,		0,		0,		0x18,	fp1_trap, },
};

readonly struct insfmt FTPNGL_FMT[] = {
	{ 0,		0,		0,		0x19,	fp1_trap, },
};

readonly struct insfmt FTPNLE_FMT[] = {
	{ 0,		0,		0,		0x1A,	fp1_trap, },
};

readonly struct insfmt FTPNLT_FMT[] = {
	{ 0,		0,		0,		0x1B,	fp1_trap, },
};

readonly struct insfmt FTPNGE_FMT[] = {
	{ 0,		0,		0,		0x1C,	fp1_trap, },
};

readonly struct insfmt FTPNGT_FMT[] = {
	{ 0,		0,		0,		0x1D,	fp1_trap, },
};

readonly struct insfmt FTPSNE_FMT[] = {
	{ 0,		0,		0,		0x1E,	fp1_trap, },
};

readonly struct insfmt FTPST_FMT[] = {
	{ 0,		0,		0,		0x1F,	fp1_trap, },
};

readonly struct insfmt FTPFW_FMT[] = {
	{ IMMW,		0,		0,		0x00,	fp1_trapw, },
};

readonly struct insfmt FTPEQW_FMT[] = {
	{ IMMW,		0,		0,		0x01,	fp1_trapw, },
};

readonly struct insfmt FTPOGTW_FMT[] = {
	{ IMMW,		0,		0,		0x02,	fp1_trapw, },
};

readonly struct insfmt FTPOGEW_FMT[] = {
	{ IMMW,		0,		0,		0x03,	fp1_trapw, },
};

readonly struct insfmt FTPOLTW_FMT[] = {
	{ IMMW,		0,		0,		0x04,	fp1_trapw, },
};

readonly struct insfmt FTPOLEW_FMT[] = {
	{ IMMW,		0,		0,		0x05,	fp1_trapw, },
};

readonly struct insfmt FTPOGLW_FMT[] = {
	{ IMMW,		0,		0,		0x06,	fp1_trapw, },
};

readonly struct insfmt FTPORW_FMT[] = {
	{ IMMW,		0,		0,		0x07,	fp1_trapw, },
};

readonly struct insfmt FTPUNW_FMT[] = {
	{ IMMW,		0,		0,		0x08,	fp1_trapw, },
};

readonly struct insfmt FTPUEQW_FMT[] = {
	{ IMMW,		0,		0,		0x09,	fp1_trapw, },
};

readonly struct insfmt FTPUGTW_FMT[] = {
	{ IMMW,		0,		0,		0x0A,	fp1_trapw, },
};

readonly struct insfmt FTPUGEW_FMT[] = {
	{ IMMW,		0,		0,		0x0B,	fp1_trapw, },
};

readonly struct insfmt FTPULTW_FMT[] = {
	{ IMMW,		0,		0,		0x0C,	fp1_trapw, },
};

readonly struct insfmt FTPULEW_FMT[] = {
	{ IMMW,		0,		0,		0x0D,	fp1_trapw, },
};

readonly struct insfmt FTPNEW_FMT[] = {
	{ IMMW,		0,		0,		0x0E,	fp1_trapw, },
};

readonly struct insfmt FTPTW_FMT[] = {
	{ IMMW,		0,		0,		0x0F,	fp1_trapw, },
};

readonly struct insfmt FTPSFW_FMT[] = {
	{ IMMW,		0,		0,		0x10,	fp1_trapw, },
};

readonly struct insfmt FTPSEQW_FMT[] = {
	{ IMMW,		0,		0,		0x11,	fp1_trapw, },
};

readonly struct insfmt FTPGTW_FMT[] = {
	{ IMMW,		0,		0,		0x12,	fp1_trapw, },
};

readonly struct insfmt FTPGEW_FMT[] = {
	{ IMMW,		0,		0,		0x13,	fp1_trapw, },
};

readonly struct insfmt FTPLTW_FMT[] = {
	{ IMMW,		0,		0,		0x14,	fp1_trapw, },
};

readonly struct insfmt FTPLEW_FMT[] = {
	{ IMMW,		0,		0,		0x15,	fp1_trapw, },
};

readonly struct insfmt FTPGLW_FMT[] = {
	{ IMMW,		0,		0,		0x16,	fp1_trapw, },
};

readonly struct insfmt FTPGLEW_FMT[] = {
	{ IMMW,		0,		0,		0x17,	fp1_trapw, },
};

readonly struct insfmt FTPNGLEW_FMT[] = {
	{ IMMW,		0,		0,		0x18,	fp1_trapw, },
};

readonly struct insfmt FTPNGLW_FMT[] = {
	{ IMMW,		0,		0,		0x19,	fp1_trapw, },
};

readonly struct insfmt FTPNLEW_FMT[] = {
	{ IMMW,		0,		0,		0x1A,	fp1_trapw, },
};

readonly struct insfmt FTPNLTW_FMT[] = {
	{ IMMW,		0,		0,		0x1B,	fp1_trapw, },
};

readonly struct insfmt FTPNGEW_FMT[] = {
	{ IMMW,		0,		0,		0x1C,	fp1_trapw, },
};

readonly struct insfmt FTPNGTW_FMT[] = {
	{ IMMW,		0,		0,		0x1D,	fp1_trapw, },
};

readonly struct insfmt FTPSNEW_FMT[] = {
	{ IMMW,		0,		0,		0x1E,	fp1_trapw, },
};

readonly struct insfmt FTPSTW_FMT[] = {
	{ IMMW,		0,		0,		0x1F,	fp1_trapw, },
};

readonly struct insfmt FTPFL_FMT[] = {
	{ IMML,		0,		0,		0x00,	fp1_trapl, },
};

readonly struct insfmt FTPEQL_FMT[] = {
	{ IMML,		0,		0,		0x01,	fp1_trapl, },
};

readonly struct insfmt FTPOGTL_FMT[] = {
	{ IMML,		0,		0,		0x02,	fp1_trapl, },
};

readonly struct insfmt FTPOGEL_FMT[] = {
	{ IMML,		0,		0,		0x03,	fp1_trapl, },
};

readonly struct insfmt FTPOLTL_FMT[] = {
	{ IMML,		0,		0,		0x04,	fp1_trapl, },
};

readonly struct insfmt FTPOLEL_FMT[] = {
	{ IMML,		0,		0,		0x05,	fp1_trapl, },
};

readonly struct insfmt FTPOGLL_FMT[] = {
	{ IMML,		0,		0,		0x06,	fp1_trapl, },
};

readonly struct insfmt FTPORL_FMT[] = {
	{ IMML,		0,		0,		0x07,	fp1_trapl, },
};

readonly struct insfmt FTPUNL_FMT[] = {
	{ IMML,		0,		0,		0x08,	fp1_trapl, },
};

readonly struct insfmt FTPUEQL_FMT[] = {
	{ IMML,		0,		0,		0x09,	fp1_trapl, },
};

readonly struct insfmt FTPUGTL_FMT[] = {
	{ IMML,		0,		0,		0x0A,	fp1_trapl, },
};

readonly struct insfmt FTPUGEL_FMT[] = {
	{ IMML,		0,		0,		0x0B,	fp1_trapl, },
};

readonly struct insfmt FTPULTL_FMT[] = {
	{ IMML,		0,		0,		0x0C,	fp1_trapl, },
};

readonly struct insfmt FTPULEL_FMT[] = {
	{ IMML,		0,		0,		0x0D,	fp1_trapl, },
};

readonly struct insfmt FTPNEL_FMT[] = {
	{ IMML,		0,		0,		0x0E,	fp1_trapl, },
};

readonly struct insfmt FTPTL_FMT[] = {
	{ IMML,		0,		0,		0x0F,	fp1_trapl, },
};

readonly struct insfmt FTPSFL_FMT[] = {
	{ IMML,		0,		0,		0x10,	fp1_trapl, },
};

readonly struct insfmt FTPSEQL_FMT[] = {
	{ IMML,		0,		0,		0x11,	fp1_trapl, },
};

readonly struct insfmt FTPGTL_FMT[] = {
	{ IMML,		0,		0,		0x12,	fp1_trapl, },
};

readonly struct insfmt FTPGEL_FMT[] = {
	{ IMML,		0,		0,		0x13,	fp1_trapl, },
};

readonly struct insfmt FTPLTL_FMT[] = {
	{ IMML,		0,		0,		0x14,	fp1_trapl, },
};

readonly struct insfmt FTPLEL_FMT[] = {
	{ IMML,		0,		0,		0x15,	fp1_trapl, },
};

readonly struct insfmt FTPGLL_FMT[] = {
	{ IMML,		0,		0,		0x16,	fp1_trapl, },
};

readonly struct insfmt FTPGLEL_FMT[] = {
	{ IMML,		0,		0,		0x17,	fp1_trapl, },
};

readonly struct insfmt FTPNGLEL_FMT[] = {
	{ IMML,		0,		0,		0x18,	fp1_trapl, },
};

readonly struct insfmt FTPNGLL_FMT[] = {
	{ IMML,		0,		0,		0x19,	fp1_trapl, },
};

readonly struct insfmt FTPNLEL_FMT[] = {
	{ IMML,		0,		0,		0x1A,	fp1_trapl, },
};

readonly struct insfmt FTPNLTL_FMT[] = {
	{ IMML,		0,		0,		0x1B,	fp1_trapl, },
};

readonly struct insfmt FTPNGEL_FMT[] = {
	{ IMML,		0,		0,		0x1C,	fp1_trapl, },
};

readonly struct insfmt FTPNGTL_FMT[] = {
	{ IMML,		0,		0,		0x1D,	fp1_trapl, },
};

readonly struct insfmt FTPSNEL_FMT[] = {
	{ IMML,		0,		0,		0x1E,	fp1_trapl, },
};

readonly struct insfmt FTPSTL_FMT[] = {
	{ IMML,		0,		0,		0x1F,	fp1_trapl, },
};

