/**
 * @file
 * @brief Function prototypes for the new opcode functions.
 * @note  DO NOT EDIT THIS FILE, your changes will be lost.
 *        Edit ./ir/be/ia32/ia32_spec.pl instead.
 *        created by: ./ir/be/scripts/generate_new_opcodes.pl ./ir/be/ia32/ia32_spec.pl build/gen/ir/be/ia32
 * @date  Tue Jul  7 23:51:18 2026
 */
#ifndef FIRM_BE_IA32_GEN_IA32_NEW_NODES_H
#define FIRM_BE_IA32_GEN_IA32_NEW_NODES_H

#include "be_types.h"
#include "irnode_t.h"
#include "ia32_nodes_attr.h"

typedef enum ia32_opcodes {
	iro_ia32_Adc,
	iro_ia32_Add,
	iro_ia32_AddMem,
	iro_ia32_AddSP,
	iro_ia32_Adds,
	iro_ia32_And,
	iro_ia32_AndMem,
	iro_ia32_Andnp,
	iro_ia32_Andp,
	iro_ia32_Breakpoint,
	iro_ia32_Bsf,
	iro_ia32_Bsr,
	iro_ia32_Bswap,
	iro_ia32_Bswap16,
	iro_ia32_Bt,
	iro_ia32_CMovcc,
	iro_ia32_Call,
	iro_ia32_ChangeCW,
	iro_ia32_Cltd,
	iro_ia32_Cmc,
	iro_ia32_Cmp,
	iro_ia32_CmpXChgMem,
	iro_ia32_Const,
	iro_ia32_Conv_FP2FP,
	iro_ia32_Conv_FP2I,
	iro_ia32_Conv_I2FP,
	iro_ia32_Conv_I2I,
	iro_ia32_CopyB,
	iro_ia32_CopyB_i,
	iro_ia32_CopyEbpEsp,
	iro_ia32_CvtSI2SD,
	iro_ia32_CvtSI2SS,
	iro_ia32_Cwtl,
	iro_ia32_Dec,
	iro_ia32_DecMem,
	iro_ia32_Div,
	iro_ia32_Divs,
	iro_ia32_Enter,
	iro_ia32_FldCW,
	iro_ia32_FnstCW,
	iro_ia32_FnstCWNOP,
	iro_ia32_FtstFnstsw,
	iro_ia32_FucomFnstsw,
	iro_ia32_Fucomi,
	iro_ia32_FucomppFnstsw,
	iro_ia32_GetEIP,
	iro_ia32_IDiv,
	iro_ia32_IJmp,
	iro_ia32_IMul,
	iro_ia32_IMul1OP,
	iro_ia32_IMulImm,
	iro_ia32_Immediate,
	iro_ia32_Inc,
	iro_ia32_IncMem,
	iro_ia32_Inport,
	iro_ia32_Jcc,
	iro_ia32_Jmp,
	iro_ia32_LdTls,
	iro_ia32_Lea,
	iro_ia32_Leave,
	iro_ia32_Load,
	iro_ia32_Maxs,
	iro_ia32_Mins,
	iro_ia32_Minus64,
	iro_ia32_Movd,
	iro_ia32_Mul,
	iro_ia32_Muls,
	iro_ia32_Neg,
	iro_ia32_NegMem,
	iro_ia32_NoReg_FP,
	iro_ia32_NoReg_GP,
	iro_ia32_NoReg_XMM,
	iro_ia32_Not,
	iro_ia32_NotMem,
	iro_ia32_Or,
	iro_ia32_OrMem,
	iro_ia32_Orp,
	iro_ia32_Outport,
	iro_ia32_Pop,
	iro_ia32_PopMem,
	iro_ia32_Popcnt,
	iro_ia32_Prefetch,
	iro_ia32_PrefetchNTA,
	iro_ia32_PrefetchT0,
	iro_ia32_PrefetchT1,
	iro_ia32_PrefetchT2,
	iro_ia32_PrefetchW,
	iro_ia32_Pslld,
	iro_ia32_Psllq,
	iro_ia32_Psrld,
	iro_ia32_Push,
	iro_ia32_PushEax,
	iro_ia32_Ret,
	iro_ia32_Rol,
	iro_ia32_RolMem,
	iro_ia32_Ror,
	iro_ia32_RorMem,
	iro_ia32_Sahf,
	iro_ia32_Sar,
	iro_ia32_SarMem,
	iro_ia32_Sbb,
	iro_ia32_Sbb0,
	iro_ia32_Setcc,
	iro_ia32_SetccMem,
	iro_ia32_Shl,
	iro_ia32_ShlD,
	iro_ia32_ShlMem,
	iro_ia32_Shr,
	iro_ia32_ShrD,
	iro_ia32_ShrMem,
	iro_ia32_Stc,
	iro_ia32_Store,
	iro_ia32_Sub,
	iro_ia32_SubMem,
	iro_ia32_SubSP,
	iro_ia32_Subs,
	iro_ia32_SwitchJmp,
	iro_ia32_Test,
	iro_ia32_UD2,
	iro_ia32_Ucomis,
	iro_ia32_Xor,
	iro_ia32_Xor0,
	iro_ia32_XorHighLow,
	iro_ia32_XorMem,
	iro_ia32_Xorp,
	iro_ia32_emms,
	iro_ia32_fabs,
	iro_ia32_fadd,
	iro_ia32_fchs,
	iro_ia32_fdiv,
	iro_ia32_fdup,
	iro_ia32_femms,
	iro_ia32_ffreep,
	iro_ia32_fild,
	iro_ia32_fist,
	iro_ia32_fistp,
	iro_ia32_fisttp,
	iro_ia32_fld,
	iro_ia32_fld1,
	iro_ia32_fldl2e,
	iro_ia32_fldl2t,
	iro_ia32_fldlg2,
	iro_ia32_fldln2,
	iro_ia32_fldpi,
	iro_ia32_fldz,
	iro_ia32_fmul,
	iro_ia32_fpop,
	iro_ia32_fst,
	iro_ia32_fstp,
	iro_ia32_fsub,
	iro_ia32_fxch,
	iro_ia32_l_Adc,
	iro_ia32_l_Add,
	iro_ia32_l_FloattoLL,
	iro_ia32_l_IMul,
	iro_ia32_l_LLtoFloat,
	iro_ia32_l_Minus64,
	iro_ia32_l_Mul,
	iro_ia32_l_Sbb,
	iro_ia32_l_Sub,
	iro_ia32_xAllOnes,
	iro_ia32_xLoad,
	iro_ia32_xPzero,
	iro_ia32_xStore,
	iro_ia32_xZero,
	iro_ia32_xxLoad,
	iro_ia32_xxStore,
	iro_ia32_last
} ia32_opcodes;


int is_ia32_irn(const ir_node *node);
int is_ia32_op(const ir_op *op);

int get_ia32_irn_opcode(const ir_node *node);
void ia32_create_opcodes(void);
void ia32_free_opcodes(void);

extern ir_op *op_ia32_Adc;

static inline bool is_ia32_Adc(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Adc;
}

/**
 * construct Adc node
 */
ir_node *new_bd_ia32_Adc(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *left, ir_node *right, ir_node *eflags, x86_insn_size_t size);

extern ir_op *op_ia32_Add;

static inline bool is_ia32_Add(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Add;
}

/**
 * construct Add node
 */
ir_node *new_bd_ia32_Add(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *left, ir_node *right, x86_insn_size_t size);
/**
 * construct Add node
 */
ir_node *new_bd_ia32_Add_8bit(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *left, ir_node *right, x86_insn_size_t size);

extern ir_op *op_ia32_AddMem;

static inline bool is_ia32_AddMem(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_AddMem;
}

/**
 * construct AddMem node
 */
ir_node *new_bd_ia32_AddMem(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *val, x86_insn_size_t size);
/**
 * construct AddMem node
 */
ir_node *new_bd_ia32_AddMem_8bit(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *val, x86_insn_size_t size);

extern ir_op *op_ia32_AddSP;

static inline bool is_ia32_AddSP(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_AddSP;
}

/**
 * construct AddSP node
 */
ir_node *new_bd_ia32_AddSP(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *stack, ir_node *amount);

extern ir_op *op_ia32_Adds;

static inline bool is_ia32_Adds(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Adds;
}

/**
 * construct Adds node
 */
ir_node *new_bd_ia32_Adds(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *left, ir_node *right, x86_insn_size_t size);

extern ir_op *op_ia32_And;

static inline bool is_ia32_And(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_And;
}

/**
 * construct And node
 */
ir_node *new_bd_ia32_And(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *left, ir_node *right, x86_insn_size_t size);
/**
 * construct And node
 */
ir_node *new_bd_ia32_And_8bit(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *left, ir_node *right, x86_insn_size_t size);

extern ir_op *op_ia32_AndMem;

static inline bool is_ia32_AndMem(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_AndMem;
}

/**
 * construct AndMem node
 */
ir_node *new_bd_ia32_AndMem(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *val, x86_insn_size_t size);
/**
 * construct AndMem node
 */
ir_node *new_bd_ia32_AndMem_8bit(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *val, x86_insn_size_t size);

extern ir_op *op_ia32_Andnp;

static inline bool is_ia32_Andnp(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Andnp;
}

/**
 * construct Andnp node
 */
ir_node *new_bd_ia32_Andnp(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *left, ir_node *right, x86_insn_size_t size);

extern ir_op *op_ia32_Andp;

static inline bool is_ia32_Andp(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Andp;
}

/**
 * construct Andp node
 */
ir_node *new_bd_ia32_Andp(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *left, ir_node *right, x86_insn_size_t size);

extern ir_op *op_ia32_Breakpoint;

static inline bool is_ia32_Breakpoint(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Breakpoint;
}

/**
 * construct Breakpoint node
 */
ir_node *new_bd_ia32_Breakpoint(dbg_info *dbgi, ir_node *block, ir_node *mem);

extern ir_op *op_ia32_Bsf;

static inline bool is_ia32_Bsf(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Bsf;
}

/**
 * construct Bsf node
 */
ir_node *new_bd_ia32_Bsf(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *operand, x86_insn_size_t size);

extern ir_op *op_ia32_Bsr;

static inline bool is_ia32_Bsr(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Bsr;
}

/**
 * construct Bsr node
 */
ir_node *new_bd_ia32_Bsr(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *operand, x86_insn_size_t size);

extern ir_op *op_ia32_Bswap;

static inline bool is_ia32_Bswap(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Bswap;
}

/**
 * construct Bswap node
 */
ir_node *new_bd_ia32_Bswap(dbg_info *dbgi, ir_node *block, ir_node *val, x86_insn_size_t size);

extern ir_op *op_ia32_Bswap16;

static inline bool is_ia32_Bswap16(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Bswap16;
}

/**
 * construct Bswap16 node
 */
ir_node *new_bd_ia32_Bswap16(dbg_info *dbgi, ir_node *block, ir_node *val);

extern ir_op *op_ia32_Bt;

static inline bool is_ia32_Bt(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Bt;
}

/**
 * construct Bt node
 */
ir_node *new_bd_ia32_Bt(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right, x86_insn_size_t size);

extern ir_op *op_ia32_CMovcc;

static inline bool is_ia32_CMovcc(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_CMovcc;
}

/**
 * construct CMovcc node
 */
ir_node *new_bd_ia32_CMovcc(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *val_false, ir_node *val_true, ir_node *eflags, x86_insn_size_t size, x86_condition_code_t condition_code);

extern ir_op *op_ia32_Call;

static inline bool is_ia32_Call(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Call;
}

/**
 * construct Call node
 */
ir_node *new_bd_ia32_Call(dbg_info *dbgi, ir_node *block, int const arity, ir_node *const *const in, arch_register_req_t const **const in_reqs, int n_res, uint8_t pop, uint8_t n_reg_results);

extern ir_op *op_ia32_ChangeCW;

static inline bool is_ia32_ChangeCW(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_ChangeCW;
}

/**
 * construct ChangeCW node
 */
ir_node *new_bd_ia32_ChangeCW(dbg_info *dbgi, ir_node *block);

extern ir_op *op_ia32_Cltd;

static inline bool is_ia32_Cltd(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Cltd;
}

/**
 * construct Cltd node
 */
ir_node *new_bd_ia32_Cltd(dbg_info *dbgi, ir_node *block, ir_node *val);

extern ir_op *op_ia32_Cmc;

static inline bool is_ia32_Cmc(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Cmc;
}

/**
 * construct Cmc node
 */
ir_node *new_bd_ia32_Cmc(dbg_info *dbgi, ir_node *block, ir_node *op0);

extern ir_op *op_ia32_Cmp;

static inline bool is_ia32_Cmp(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Cmp;
}

/**
 * construct Cmp node
 */
ir_node *new_bd_ia32_Cmp(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *left, ir_node *right, x86_insn_size_t size, bool ins_permuted);
/**
 * construct Cmp node
 */
ir_node *new_bd_ia32_Cmp_8bit(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *left, ir_node *right, x86_insn_size_t size, bool ins_permuted);

extern ir_op *op_ia32_CmpXChgMem;

static inline bool is_ia32_CmpXChgMem(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_CmpXChgMem;
}

/**
 * construct CmpXChgMem node
 */
ir_node *new_bd_ia32_CmpXChgMem(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *old, ir_node *new, x86_insn_size_t size);

extern ir_op *op_ia32_Const;

static inline bool is_ia32_Const(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Const;
}

/**
 * construct Const node
 */
ir_node *new_bd_ia32_Const(dbg_info *dbgi, ir_node *block, const x86_imm32_t *imm);

extern ir_op *op_ia32_Conv_FP2FP;

static inline bool is_ia32_Conv_FP2FP(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Conv_FP2FP;
}

/**
 * construct Conv_FP2FP node
 */
ir_node *new_bd_ia32_Conv_FP2FP(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *val, x86_insn_size_t size);

extern ir_op *op_ia32_Conv_FP2I;

static inline bool is_ia32_Conv_FP2I(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Conv_FP2I;
}

/**
 * construct Conv_FP2I node
 */
ir_node *new_bd_ia32_Conv_FP2I(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *val, x86_insn_size_t size);

extern ir_op *op_ia32_Conv_I2FP;

static inline bool is_ia32_Conv_I2FP(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Conv_I2FP;
}

/**
 * construct Conv_I2FP node
 */
ir_node *new_bd_ia32_Conv_I2FP(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *val, x86_insn_size_t size);

extern ir_op *op_ia32_Conv_I2I;

static inline bool is_ia32_Conv_I2I(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Conv_I2I;
}

/**
 * construct Conv_I2I node
 */
ir_node *new_bd_ia32_Conv_I2I(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *val, x86_insn_size_t size, bool sign_extend);
/**
 * construct Conv_I2I node
 */
ir_node *new_bd_ia32_Conv_I2I_8bit(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *val, x86_insn_size_t size, bool sign_extend);

extern ir_op *op_ia32_CopyB;

static inline bool is_ia32_CopyB(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_CopyB;
}

/**
 * construct CopyB node
 */
ir_node *new_bd_ia32_CopyB(dbg_info *dbgi, ir_node *block, ir_node *dest, ir_node *source, ir_node *count, ir_node *mem, unsigned size);

extern ir_op *op_ia32_CopyB_i;

static inline bool is_ia32_CopyB_i(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_CopyB_i;
}

/**
 * construct CopyB_i node
 */
ir_node *new_bd_ia32_CopyB_i(dbg_info *dbgi, ir_node *block, ir_node *dest, ir_node *source, ir_node *mem, unsigned size);

extern ir_op *op_ia32_CopyEbpEsp;

static inline bool is_ia32_CopyEbpEsp(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_CopyEbpEsp;
}

/**
 * construct CopyEbpEsp node
 */
ir_node *new_bd_ia32_CopyEbpEsp(dbg_info *dbgi, ir_node *block, ir_node *ebp);

extern ir_op *op_ia32_CvtSI2SD;

static inline bool is_ia32_CvtSI2SD(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_CvtSI2SD;
}

/**
 * construct CvtSI2SD node
 */
ir_node *new_bd_ia32_CvtSI2SD(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *val, x86_insn_size_t size);

extern ir_op *op_ia32_CvtSI2SS;

static inline bool is_ia32_CvtSI2SS(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_CvtSI2SS;
}

/**
 * construct CvtSI2SS node
 */
ir_node *new_bd_ia32_CvtSI2SS(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *val, x86_insn_size_t size);

extern ir_op *op_ia32_Cwtl;

static inline bool is_ia32_Cwtl(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Cwtl;
}

/**
 * construct Cwtl node
 */
ir_node *new_bd_ia32_Cwtl(dbg_info *dbgi, ir_node *block, ir_node *val);

extern ir_op *op_ia32_Dec;

static inline bool is_ia32_Dec(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Dec;
}

/**
 * construct Dec node
 */
ir_node *new_bd_ia32_Dec(dbg_info *dbgi, ir_node *block, ir_node *val, x86_insn_size_t size);

extern ir_op *op_ia32_DecMem;

static inline bool is_ia32_DecMem(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_DecMem;
}

/**
 * construct DecMem node
 */
ir_node *new_bd_ia32_DecMem(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, x86_insn_size_t size);

extern ir_op *op_ia32_Div;

static inline bool is_ia32_Div(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Div;
}

/**
 * construct Div node
 */
ir_node *new_bd_ia32_Div(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *divisor, ir_node *dividend_low, ir_node *dividend_high, x86_insn_size_t size);

extern ir_op *op_ia32_Divs;

static inline bool is_ia32_Divs(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Divs;
}

/**
 * construct Divs node
 */
ir_node *new_bd_ia32_Divs(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *left, ir_node *right, x86_insn_size_t size);

extern ir_op *op_ia32_Enter;

static inline bool is_ia32_Enter(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Enter;
}

/**
 * construct Enter node
 */
ir_node *new_bd_ia32_Enter(dbg_info *dbgi, ir_node *block, ir_node *op0);

extern ir_op *op_ia32_FldCW;

static inline bool is_ia32_FldCW(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_FldCW;
}

/**
 * construct FldCW node
 */
ir_node *new_bd_ia32_FldCW(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem);

extern ir_op *op_ia32_FnstCW;

static inline bool is_ia32_FnstCW(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_FnstCW;
}

/**
 * construct FnstCW node
 */
ir_node *new_bd_ia32_FnstCW(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *fpcw);

extern ir_op *op_ia32_FnstCWNOP;

static inline bool is_ia32_FnstCWNOP(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_FnstCWNOP;
}

/**
 * construct FnstCWNOP node
 */
ir_node *new_bd_ia32_FnstCWNOP(dbg_info *dbgi, ir_node *block, ir_node *fpcw);

extern ir_op *op_ia32_FtstFnstsw;

static inline bool is_ia32_FtstFnstsw(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_FtstFnstsw;
}

/**
 * construct FtstFnstsw node
 */
ir_node *new_bd_ia32_FtstFnstsw(dbg_info *dbgi, ir_node *block, ir_node *left, bool ins_permuted);

extern ir_op *op_ia32_FucomFnstsw;

static inline bool is_ia32_FucomFnstsw(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_FucomFnstsw;
}

/**
 * construct FucomFnstsw node
 */
ir_node *new_bd_ia32_FucomFnstsw(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right, bool ins_permuted);

extern ir_op *op_ia32_Fucomi;

static inline bool is_ia32_Fucomi(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Fucomi;
}

/**
 * construct Fucomi node
 */
ir_node *new_bd_ia32_Fucomi(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right, bool ins_permuted);

extern ir_op *op_ia32_FucomppFnstsw;

static inline bool is_ia32_FucomppFnstsw(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_FucomppFnstsw;
}

/**
 * construct FucomppFnstsw node
 */
ir_node *new_bd_ia32_FucomppFnstsw(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right, bool ins_permuted);

extern ir_op *op_ia32_GetEIP;

static inline bool is_ia32_GetEIP(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_GetEIP;
}

/**
 * construct GetEIP node
 */
ir_node *new_bd_ia32_GetEIP(dbg_info *dbgi, ir_node *block);

extern ir_op *op_ia32_IDiv;

static inline bool is_ia32_IDiv(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_IDiv;
}

/**
 * construct IDiv node
 */
ir_node *new_bd_ia32_IDiv(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *divisor, ir_node *dividend_low, ir_node *dividend_high, x86_insn_size_t size);

extern ir_op *op_ia32_IJmp;

static inline bool is_ia32_IJmp(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_IJmp;
}

/**
 * construct IJmp node
 */
ir_node *new_bd_ia32_IJmp(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *target);

extern ir_op *op_ia32_IMul;

static inline bool is_ia32_IMul(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_IMul;
}

/**
 * construct IMul node
 */
ir_node *new_bd_ia32_IMul(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *left, ir_node *right, x86_insn_size_t size);
/**
 * construct IMul node
 */
ir_node *new_bd_ia32_IMul_8bit(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *left, ir_node *right, x86_insn_size_t size);

extern ir_op *op_ia32_IMul1OP;

static inline bool is_ia32_IMul1OP(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_IMul1OP;
}

/**
 * construct IMul1OP node
 */
ir_node *new_bd_ia32_IMul1OP(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *left, ir_node *right, x86_insn_size_t size);

extern ir_op *op_ia32_IMulImm;

static inline bool is_ia32_IMulImm(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_IMulImm;
}

/**
 * construct IMulImm node
 */
ir_node *new_bd_ia32_IMulImm(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *left, ir_node *right, x86_insn_size_t size);

extern ir_op *op_ia32_Immediate;

static inline bool is_ia32_Immediate(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Immediate;
}

/**
 * construct Immediate node
 */
ir_node *new_bd_ia32_Immediate(dbg_info *dbgi, ir_node *block, const x86_imm32_t *imm);

extern ir_op *op_ia32_Inc;

static inline bool is_ia32_Inc(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Inc;
}

/**
 * construct Inc node
 */
ir_node *new_bd_ia32_Inc(dbg_info *dbgi, ir_node *block, ir_node *val, x86_insn_size_t size);

extern ir_op *op_ia32_IncMem;

static inline bool is_ia32_IncMem(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_IncMem;
}

/**
 * construct IncMem node
 */
ir_node *new_bd_ia32_IncMem(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, x86_insn_size_t size);

extern ir_op *op_ia32_Inport;

static inline bool is_ia32_Inport(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Inport;
}

/**
 * construct Inport node
 */
ir_node *new_bd_ia32_Inport(dbg_info *dbgi, ir_node *block, ir_node *port, ir_node *mem, x86_insn_size_t size);

extern ir_op *op_ia32_Jcc;

static inline bool is_ia32_Jcc(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Jcc;
}

/**
 * construct Jcc node
 */
ir_node *new_bd_ia32_Jcc(dbg_info *dbgi, ir_node *block, ir_node *eflags, x86_condition_code_t condition_code);

extern ir_op *op_ia32_Jmp;

static inline bool is_ia32_Jmp(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Jmp;
}

/**
 * construct Jmp node
 */
ir_node *new_bd_ia32_Jmp(dbg_info *dbgi, ir_node *block);

extern ir_op *op_ia32_LdTls;

static inline bool is_ia32_LdTls(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_LdTls;
}

/**
 * construct LdTls node
 */
ir_node *new_bd_ia32_LdTls(dbg_info *dbgi, ir_node *block);

extern ir_op *op_ia32_Lea;

static inline bool is_ia32_Lea(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Lea;
}

/**
 * construct Lea node
 */
ir_node *new_bd_ia32_Lea(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index);

extern ir_op *op_ia32_Leave;

static inline bool is_ia32_Leave(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Leave;
}

/**
 * construct Leave node
 */
ir_node *new_bd_ia32_Leave(dbg_info *dbgi, ir_node *block, ir_node *op0, ir_node *op1);

extern ir_op *op_ia32_Load;

static inline bool is_ia32_Load(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Load;
}

/**
 * construct Load node
 */
ir_node *new_bd_ia32_Load(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, x86_insn_size_t size, bool sign_extend);

extern ir_op *op_ia32_Maxs;

static inline bool is_ia32_Maxs(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Maxs;
}

/**
 * construct Maxs node
 */
ir_node *new_bd_ia32_Maxs(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *left, ir_node *right, x86_insn_size_t size);

extern ir_op *op_ia32_Mins;

static inline bool is_ia32_Mins(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Mins;
}

/**
 * construct Mins node
 */
ir_node *new_bd_ia32_Mins(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *left, ir_node *right, x86_insn_size_t size);

extern ir_op *op_ia32_Minus64;

static inline bool is_ia32_Minus64(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Minus64;
}

/**
 * construct Minus64 node
 */
ir_node *new_bd_ia32_Minus64(dbg_info *dbgi, ir_node *block, ir_node *low, ir_node *high);

extern ir_op *op_ia32_Movd;

static inline bool is_ia32_Movd(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Movd;
}

/**
 * construct Movd node
 */
ir_node *new_bd_ia32_Movd(dbg_info *dbgi, ir_node *block, ir_node *op0);

extern ir_op *op_ia32_Mul;

static inline bool is_ia32_Mul(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Mul;
}

/**
 * construct Mul node
 */
ir_node *new_bd_ia32_Mul(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *left, ir_node *right, x86_insn_size_t size);

extern ir_op *op_ia32_Muls;

static inline bool is_ia32_Muls(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Muls;
}

/**
 * construct Muls node
 */
ir_node *new_bd_ia32_Muls(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *left, ir_node *right, x86_insn_size_t size);

extern ir_op *op_ia32_Neg;

static inline bool is_ia32_Neg(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Neg;
}

/**
 * construct Neg node
 */
ir_node *new_bd_ia32_Neg(dbg_info *dbgi, ir_node *block, ir_node *val, x86_insn_size_t size);

extern ir_op *op_ia32_NegMem;

static inline bool is_ia32_NegMem(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_NegMem;
}

/**
 * construct NegMem node
 */
ir_node *new_bd_ia32_NegMem(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, x86_insn_size_t size);

extern ir_op *op_ia32_NoReg_FP;

static inline bool is_ia32_NoReg_FP(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_NoReg_FP;
}

/**
 * construct NoReg_FP node
 */
ir_node *new_bd_ia32_NoReg_FP(dbg_info *dbgi, ir_node *block);

extern ir_op *op_ia32_NoReg_GP;

static inline bool is_ia32_NoReg_GP(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_NoReg_GP;
}

/**
 * construct NoReg_GP node
 */
ir_node *new_bd_ia32_NoReg_GP(dbg_info *dbgi, ir_node *block);

extern ir_op *op_ia32_NoReg_XMM;

static inline bool is_ia32_NoReg_XMM(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_NoReg_XMM;
}

/**
 * construct NoReg_XMM node
 */
ir_node *new_bd_ia32_NoReg_XMM(dbg_info *dbgi, ir_node *block);

extern ir_op *op_ia32_Not;

static inline bool is_ia32_Not(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Not;
}

/**
 * construct Not node
 */
ir_node *new_bd_ia32_Not(dbg_info *dbgi, ir_node *block, ir_node *val, x86_insn_size_t size);
/**
 * construct Not node
 */
ir_node *new_bd_ia32_Not_8bit(dbg_info *dbgi, ir_node *block, ir_node *val, x86_insn_size_t size);

extern ir_op *op_ia32_NotMem;

static inline bool is_ia32_NotMem(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_NotMem;
}

/**
 * construct NotMem node
 */
ir_node *new_bd_ia32_NotMem(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, x86_insn_size_t size);

extern ir_op *op_ia32_Or;

static inline bool is_ia32_Or(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Or;
}

/**
 * construct Or node
 */
ir_node *new_bd_ia32_Or(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *left, ir_node *right, x86_insn_size_t size);
/**
 * construct Or node
 */
ir_node *new_bd_ia32_Or_8bit(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *left, ir_node *right, x86_insn_size_t size);

extern ir_op *op_ia32_OrMem;

static inline bool is_ia32_OrMem(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_OrMem;
}

/**
 * construct OrMem node
 */
ir_node *new_bd_ia32_OrMem(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *val, x86_insn_size_t size);
/**
 * construct OrMem node
 */
ir_node *new_bd_ia32_OrMem_8bit(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *val, x86_insn_size_t size);

extern ir_op *op_ia32_Orp;

static inline bool is_ia32_Orp(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Orp;
}

/**
 * construct Orp node
 */
ir_node *new_bd_ia32_Orp(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *left, ir_node *right, x86_insn_size_t size);

extern ir_op *op_ia32_Outport;

static inline bool is_ia32_Outport(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Outport;
}

/**
 * construct Outport node
 */
ir_node *new_bd_ia32_Outport(dbg_info *dbgi, ir_node *block, ir_node *port, ir_node *value, ir_node *mem, x86_insn_size_t size);

extern ir_op *op_ia32_Pop;

static inline bool is_ia32_Pop(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Pop;
}

/**
 * construct Pop node
 */
ir_node *new_bd_ia32_Pop(dbg_info *dbgi, ir_node *block, ir_node *mem, ir_node *stack, x86_insn_size_t size);
/**
 * construct Pop node
 */
ir_node *new_bd_ia32_Pop_ebp(dbg_info *dbgi, ir_node *block, ir_node *mem, ir_node *stack, x86_insn_size_t size);

extern ir_op *op_ia32_PopMem;

static inline bool is_ia32_PopMem(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_PopMem;
}

/**
 * construct PopMem node
 */
ir_node *new_bd_ia32_PopMem(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *stack, x86_insn_size_t size);

extern ir_op *op_ia32_Popcnt;

static inline bool is_ia32_Popcnt(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Popcnt;
}

/**
 * construct Popcnt node
 */
ir_node *new_bd_ia32_Popcnt(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *operand, x86_insn_size_t size);

extern ir_op *op_ia32_Prefetch;

static inline bool is_ia32_Prefetch(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Prefetch;
}

/**
 * construct Prefetch node
 */
ir_node *new_bd_ia32_Prefetch(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem);

extern ir_op *op_ia32_PrefetchNTA;

static inline bool is_ia32_PrefetchNTA(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_PrefetchNTA;
}

/**
 * construct PrefetchNTA node
 */
ir_node *new_bd_ia32_PrefetchNTA(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem);

extern ir_op *op_ia32_PrefetchT0;

static inline bool is_ia32_PrefetchT0(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_PrefetchT0;
}

/**
 * construct PrefetchT0 node
 */
ir_node *new_bd_ia32_PrefetchT0(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem);

extern ir_op *op_ia32_PrefetchT1;

static inline bool is_ia32_PrefetchT1(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_PrefetchT1;
}

/**
 * construct PrefetchT1 node
 */
ir_node *new_bd_ia32_PrefetchT1(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem);

extern ir_op *op_ia32_PrefetchT2;

static inline bool is_ia32_PrefetchT2(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_PrefetchT2;
}

/**
 * construct PrefetchT2 node
 */
ir_node *new_bd_ia32_PrefetchT2(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem);

extern ir_op *op_ia32_PrefetchW;

static inline bool is_ia32_PrefetchW(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_PrefetchW;
}

/**
 * construct PrefetchW node
 */
ir_node *new_bd_ia32_PrefetchW(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem);

extern ir_op *op_ia32_Pslld;

static inline bool is_ia32_Pslld(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Pslld;
}

/**
 * construct Pslld node
 */
ir_node *new_bd_ia32_Pslld(dbg_info *dbgi, ir_node *block, ir_node *op0, ir_node *op1, x86_insn_size_t size);

extern ir_op *op_ia32_Psllq;

static inline bool is_ia32_Psllq(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Psllq;
}

/**
 * construct Psllq node
 */
ir_node *new_bd_ia32_Psllq(dbg_info *dbgi, ir_node *block, ir_node *op0, ir_node *op1, x86_insn_size_t size);

extern ir_op *op_ia32_Psrld;

static inline bool is_ia32_Psrld(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Psrld;
}

/**
 * construct Psrld node
 */
ir_node *new_bd_ia32_Psrld(dbg_info *dbgi, ir_node *block, ir_node *op0, ir_node *op1, x86_insn_size_t size);

extern ir_op *op_ia32_Push;

static inline bool is_ia32_Push(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Push;
}

/**
 * construct Push node
 */
ir_node *new_bd_ia32_Push(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *val, ir_node *stack, x86_insn_size_t size);

extern ir_op *op_ia32_PushEax;

static inline bool is_ia32_PushEax(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_PushEax;
}

/**
 * construct PushEax node
 */
ir_node *new_bd_ia32_PushEax(dbg_info *dbgi, ir_node *block, ir_node *stack);

extern ir_op *op_ia32_Ret;

static inline bool is_ia32_Ret(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Ret;
}

/**
 * construct Ret node
 */
ir_node *new_bd_ia32_Ret(dbg_info *dbgi, ir_node *block, int const arity, ir_node *const *const in, arch_register_req_t const **const in_reqs, uint16_t pop);

extern ir_op *op_ia32_Rol;

static inline bool is_ia32_Rol(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Rol;
}

/**
 * construct Rol node
 */
ir_node *new_bd_ia32_Rol(dbg_info *dbgi, ir_node *block, ir_node *val, ir_node *count, x86_insn_size_t size);
/**
 * construct Rol node
 */
ir_node *new_bd_ia32_Rol_8bit(dbg_info *dbgi, ir_node *block, ir_node *val, ir_node *count, x86_insn_size_t size);

extern ir_op *op_ia32_RolMem;

static inline bool is_ia32_RolMem(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_RolMem;
}

/**
 * construct RolMem node
 */
ir_node *new_bd_ia32_RolMem(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *count, x86_insn_size_t size);

extern ir_op *op_ia32_Ror;

static inline bool is_ia32_Ror(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Ror;
}

/**
 * construct Ror node
 */
ir_node *new_bd_ia32_Ror(dbg_info *dbgi, ir_node *block, ir_node *val, ir_node *count, x86_insn_size_t size);
/**
 * construct Ror node
 */
ir_node *new_bd_ia32_Ror_8bit(dbg_info *dbgi, ir_node *block, ir_node *val, ir_node *count, x86_insn_size_t size);

extern ir_op *op_ia32_RorMem;

static inline bool is_ia32_RorMem(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_RorMem;
}

/**
 * construct RorMem node
 */
ir_node *new_bd_ia32_RorMem(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *count, x86_insn_size_t size);

extern ir_op *op_ia32_Sahf;

static inline bool is_ia32_Sahf(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Sahf;
}

/**
 * construct Sahf node
 */
ir_node *new_bd_ia32_Sahf(dbg_info *dbgi, ir_node *block, ir_node *val);

extern ir_op *op_ia32_Sar;

static inline bool is_ia32_Sar(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Sar;
}

/**
 * construct Sar node
 */
ir_node *new_bd_ia32_Sar(dbg_info *dbgi, ir_node *block, ir_node *val, ir_node *count, x86_insn_size_t size);
/**
 * construct Sar node
 */
ir_node *new_bd_ia32_Sar_8bit(dbg_info *dbgi, ir_node *block, ir_node *val, ir_node *count, x86_insn_size_t size);

extern ir_op *op_ia32_SarMem;

static inline bool is_ia32_SarMem(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_SarMem;
}

/**
 * construct SarMem node
 */
ir_node *new_bd_ia32_SarMem(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *count, x86_insn_size_t size);

extern ir_op *op_ia32_Sbb;

static inline bool is_ia32_Sbb(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Sbb;
}

/**
 * construct Sbb node
 */
ir_node *new_bd_ia32_Sbb(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *minuend, ir_node *subtrahend, ir_node *eflags, x86_insn_size_t size);

extern ir_op *op_ia32_Sbb0;

static inline bool is_ia32_Sbb0(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Sbb0;
}

/**
 * construct Sbb0 node
 */
ir_node *new_bd_ia32_Sbb0(dbg_info *dbgi, ir_node *block, ir_node *op0, x86_insn_size_t size);

extern ir_op *op_ia32_Setcc;

static inline bool is_ia32_Setcc(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Setcc;
}

/**
 * construct Setcc node
 */
ir_node *new_bd_ia32_Setcc(dbg_info *dbgi, ir_node *block, ir_node *eflags, x86_condition_code_t condition_code);

extern ir_op *op_ia32_SetccMem;

static inline bool is_ia32_SetccMem(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_SetccMem;
}

/**
 * construct SetccMem node
 */
ir_node *new_bd_ia32_SetccMem(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *eflags, x86_condition_code_t condition_code);

extern ir_op *op_ia32_Shl;

static inline bool is_ia32_Shl(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Shl;
}

/**
 * construct Shl node
 */
ir_node *new_bd_ia32_Shl(dbg_info *dbgi, ir_node *block, ir_node *val, ir_node *count, x86_insn_size_t size);
/**
 * construct Shl node
 */
ir_node *new_bd_ia32_Shl_8bit(dbg_info *dbgi, ir_node *block, ir_node *val, ir_node *count, x86_insn_size_t size);

extern ir_op *op_ia32_ShlD;

static inline bool is_ia32_ShlD(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_ShlD;
}

/**
 * construct ShlD node
 */
ir_node *new_bd_ia32_ShlD(dbg_info *dbgi, ir_node *block, ir_node *val_high, ir_node *val_low, ir_node *count);
/**
 * construct ShlD node
 */
ir_node *new_bd_ia32_ShlD_imm(dbg_info *dbgi, ir_node *block, ir_node *val_high, ir_node *val_low, ir_node *count);

extern ir_op *op_ia32_ShlMem;

static inline bool is_ia32_ShlMem(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_ShlMem;
}

/**
 * construct ShlMem node
 */
ir_node *new_bd_ia32_ShlMem(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *count, x86_insn_size_t size);

extern ir_op *op_ia32_Shr;

static inline bool is_ia32_Shr(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Shr;
}

/**
 * construct Shr node
 */
ir_node *new_bd_ia32_Shr(dbg_info *dbgi, ir_node *block, ir_node *val, ir_node *count, x86_insn_size_t size);
/**
 * construct Shr node
 */
ir_node *new_bd_ia32_Shr_8bit(dbg_info *dbgi, ir_node *block, ir_node *val, ir_node *count, x86_insn_size_t size);

extern ir_op *op_ia32_ShrD;

static inline bool is_ia32_ShrD(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_ShrD;
}

/**
 * construct ShrD node
 */
ir_node *new_bd_ia32_ShrD(dbg_info *dbgi, ir_node *block, ir_node *val_high, ir_node *val_low, ir_node *count);
/**
 * construct ShrD node
 */
ir_node *new_bd_ia32_ShrD_imm(dbg_info *dbgi, ir_node *block, ir_node *val_high, ir_node *val_low, ir_node *count);

extern ir_op *op_ia32_ShrMem;

static inline bool is_ia32_ShrMem(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_ShrMem;
}

/**
 * construct ShrMem node
 */
ir_node *new_bd_ia32_ShrMem(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *count, x86_insn_size_t size);

extern ir_op *op_ia32_Stc;

static inline bool is_ia32_Stc(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Stc;
}

/**
 * construct Stc node
 */
ir_node *new_bd_ia32_Stc(dbg_info *dbgi, ir_node *block);

extern ir_op *op_ia32_Store;

static inline bool is_ia32_Store(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Store;
}

/**
 * construct Store node
 */
ir_node *new_bd_ia32_Store(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *val, x86_insn_size_t size);
/**
 * construct Store node
 */
ir_node *new_bd_ia32_Store_8bit(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *val, x86_insn_size_t size);

extern ir_op *op_ia32_Sub;

static inline bool is_ia32_Sub(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Sub;
}

/**
 * construct Sub node
 */
ir_node *new_bd_ia32_Sub(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *minuend, ir_node *subtrahend, x86_insn_size_t size);
/**
 * construct Sub node
 */
ir_node *new_bd_ia32_Sub_8bit(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *minuend, ir_node *subtrahend, x86_insn_size_t size);

extern ir_op *op_ia32_SubMem;

static inline bool is_ia32_SubMem(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_SubMem;
}

/**
 * construct SubMem node
 */
ir_node *new_bd_ia32_SubMem(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *val, x86_insn_size_t size);
/**
 * construct SubMem node
 */
ir_node *new_bd_ia32_SubMem_8bit(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *val, x86_insn_size_t size);

extern ir_op *op_ia32_SubSP;

static inline bool is_ia32_SubSP(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_SubSP;
}

/**
 * construct SubSP node
 */
ir_node *new_bd_ia32_SubSP(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *stack, ir_node *amount);

extern ir_op *op_ia32_Subs;

static inline bool is_ia32_Subs(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Subs;
}

/**
 * construct Subs node
 */
ir_node *new_bd_ia32_Subs(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *minuend, ir_node *subtrahend, x86_insn_size_t size);

extern ir_op *op_ia32_SwitchJmp;

static inline bool is_ia32_SwitchJmp(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_SwitchJmp;
}

/**
 * construct SwitchJmp node
 */
ir_node *new_bd_ia32_SwitchJmp(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, int n_res, const ir_switch_table *switch_table, const ir_entity *table_entity);

extern ir_op *op_ia32_Test;

static inline bool is_ia32_Test(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Test;
}

/**
 * construct Test node
 */
ir_node *new_bd_ia32_Test(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *left, ir_node *right, x86_insn_size_t size, bool ins_permuted);
/**
 * construct Test node
 */
ir_node *new_bd_ia32_Test_8bit(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *left, ir_node *right, x86_insn_size_t size, bool ins_permuted);

extern ir_op *op_ia32_UD2;

static inline bool is_ia32_UD2(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_UD2;
}

/**
 * construct UD2 node
 */
ir_node *new_bd_ia32_UD2(dbg_info *dbgi, ir_node *block, ir_node *mem);

extern ir_op *op_ia32_Ucomis;

static inline bool is_ia32_Ucomis(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Ucomis;
}

/**
 * construct Ucomis node
 */
ir_node *new_bd_ia32_Ucomis(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *left, ir_node *right, bool ins_permuted);

extern ir_op *op_ia32_Xor;

static inline bool is_ia32_Xor(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Xor;
}

/**
 * construct Xor node
 */
ir_node *new_bd_ia32_Xor(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *left, ir_node *right, x86_insn_size_t size);
/**
 * construct Xor node
 */
ir_node *new_bd_ia32_Xor_8bit(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *left, ir_node *right, x86_insn_size_t size);

extern ir_op *op_ia32_Xor0;

static inline bool is_ia32_Xor0(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Xor0;
}

/**
 * construct Xor0 node
 */
ir_node *new_bd_ia32_Xor0(dbg_info *dbgi, ir_node *block, x86_insn_size_t size);

extern ir_op *op_ia32_XorHighLow;

static inline bool is_ia32_XorHighLow(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_XorHighLow;
}

/**
 * construct XorHighLow node
 */
ir_node *new_bd_ia32_XorHighLow(dbg_info *dbgi, ir_node *block, ir_node *value);

extern ir_op *op_ia32_XorMem;

static inline bool is_ia32_XorMem(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_XorMem;
}

/**
 * construct XorMem node
 */
ir_node *new_bd_ia32_XorMem(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *val, x86_insn_size_t size);
/**
 * construct XorMem node
 */
ir_node *new_bd_ia32_XorMem_8bit(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *val, x86_insn_size_t size);

extern ir_op *op_ia32_Xorp;

static inline bool is_ia32_Xorp(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_Xorp;
}

/**
 * construct Xorp node
 */
ir_node *new_bd_ia32_Xorp(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *left, ir_node *right, x86_insn_size_t size);

extern ir_op *op_ia32_emms;

static inline bool is_ia32_emms(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_emms;
}

/**
 * construct emms node
 */
ir_node *new_bd_ia32_emms(dbg_info *dbgi, ir_node *block);

extern ir_op *op_ia32_fabs;

static inline bool is_ia32_fabs(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_fabs;
}

/**
 * construct fabs node
 */
ir_node *new_bd_ia32_fabs(dbg_info *dbgi, ir_node *block, ir_node *value);

extern ir_op *op_ia32_fadd;

static inline bool is_ia32_fadd(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_fadd;
}

/**
 * construct fadd node
 */
ir_node *new_bd_ia32_fadd(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *left, ir_node *right, ir_node *fpcw, x86_insn_size_t size);

extern ir_op *op_ia32_fchs;

static inline bool is_ia32_fchs(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_fchs;
}

/**
 * construct fchs node
 */
ir_node *new_bd_ia32_fchs(dbg_info *dbgi, ir_node *block, ir_node *value);

extern ir_op *op_ia32_fdiv;

static inline bool is_ia32_fdiv(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_fdiv;
}

/**
 * construct fdiv node
 */
ir_node *new_bd_ia32_fdiv(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *left, ir_node *right, ir_node *fpcw, x86_insn_size_t size);

extern ir_op *op_ia32_fdup;

static inline bool is_ia32_fdup(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_fdup;
}

/**
 * construct fdup node
 */
ir_node *new_bd_ia32_fdup(dbg_info *dbgi, ir_node *block, ir_node *val, const arch_register_t *reg);

extern ir_op *op_ia32_femms;

static inline bool is_ia32_femms(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_femms;
}

/**
 * construct femms node
 */
ir_node *new_bd_ia32_femms(dbg_info *dbgi, ir_node *block);

extern ir_op *op_ia32_ffreep;

static inline bool is_ia32_ffreep(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_ffreep;
}

/**
 * construct ffreep node
 */
ir_node *new_bd_ia32_ffreep(dbg_info *dbgi, ir_node *block, const arch_register_t *reg);

extern ir_op *op_ia32_fild;

static inline bool is_ia32_fild(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_fild;
}

/**
 * construct fild node
 */
ir_node *new_bd_ia32_fild(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, x86_insn_size_t size);

extern ir_op *op_ia32_fist;

static inline bool is_ia32_fist(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_fist;
}

/**
 * construct fist node
 */
ir_node *new_bd_ia32_fist(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *val, ir_node *fpcw, x86_insn_size_t size);

extern ir_op *op_ia32_fistp;

static inline bool is_ia32_fistp(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_fistp;
}

/**
 * construct fistp node
 */
ir_node *new_bd_ia32_fistp(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *val, ir_node *fpcw, x86_insn_size_t size);

extern ir_op *op_ia32_fisttp;

static inline bool is_ia32_fisttp(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_fisttp;
}

/**
 * construct fisttp node
 */
ir_node *new_bd_ia32_fisttp(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *val, x86_insn_size_t size);

extern ir_op *op_ia32_fld;

static inline bool is_ia32_fld(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_fld;
}

/**
 * construct fld node
 */
ir_node *new_bd_ia32_fld(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, x86_insn_size_t size);

extern ir_op *op_ia32_fld1;

static inline bool is_ia32_fld1(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_fld1;
}

/**
 * construct fld1 node
 */
ir_node *new_bd_ia32_fld1(dbg_info *dbgi, ir_node *block);

extern ir_op *op_ia32_fldl2e;

static inline bool is_ia32_fldl2e(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_fldl2e;
}

/**
 * construct fldl2e node
 */
ir_node *new_bd_ia32_fldl2e(dbg_info *dbgi, ir_node *block);

extern ir_op *op_ia32_fldl2t;

static inline bool is_ia32_fldl2t(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_fldl2t;
}

/**
 * construct fldl2t node
 */
ir_node *new_bd_ia32_fldl2t(dbg_info *dbgi, ir_node *block);

extern ir_op *op_ia32_fldlg2;

static inline bool is_ia32_fldlg2(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_fldlg2;
}

/**
 * construct fldlg2 node
 */
ir_node *new_bd_ia32_fldlg2(dbg_info *dbgi, ir_node *block);

extern ir_op *op_ia32_fldln2;

static inline bool is_ia32_fldln2(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_fldln2;
}

/**
 * construct fldln2 node
 */
ir_node *new_bd_ia32_fldln2(dbg_info *dbgi, ir_node *block);

extern ir_op *op_ia32_fldpi;

static inline bool is_ia32_fldpi(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_fldpi;
}

/**
 * construct fldpi node
 */
ir_node *new_bd_ia32_fldpi(dbg_info *dbgi, ir_node *block);

extern ir_op *op_ia32_fldz;

static inline bool is_ia32_fldz(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_fldz;
}

/**
 * construct fldz node
 */
ir_node *new_bd_ia32_fldz(dbg_info *dbgi, ir_node *block);

extern ir_op *op_ia32_fmul;

static inline bool is_ia32_fmul(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_fmul;
}

/**
 * construct fmul node
 */
ir_node *new_bd_ia32_fmul(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *left, ir_node *right, ir_node *fpcw, x86_insn_size_t size);

extern ir_op *op_ia32_fpop;

static inline bool is_ia32_fpop(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_fpop;
}

/**
 * construct fpop node
 */
ir_node *new_bd_ia32_fpop(dbg_info *dbgi, ir_node *block, const arch_register_t *reg);

extern ir_op *op_ia32_fst;

static inline bool is_ia32_fst(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_fst;
}

/**
 * construct fst node
 */
ir_node *new_bd_ia32_fst(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *val, x86_insn_size_t size);

extern ir_op *op_ia32_fstp;

static inline bool is_ia32_fstp(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_fstp;
}

/**
 * construct fstp node
 */
ir_node *new_bd_ia32_fstp(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *val, x86_insn_size_t size);

extern ir_op *op_ia32_fsub;

static inline bool is_ia32_fsub(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_fsub;
}

/**
 * construct fsub node
 */
ir_node *new_bd_ia32_fsub(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *left, ir_node *right, ir_node *fpcw, x86_insn_size_t size);

extern ir_op *op_ia32_fxch;

static inline bool is_ia32_fxch(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_fxch;
}

/**
 * construct fxch node
 */
ir_node *new_bd_ia32_fxch(dbg_info *dbgi, ir_node *block, const arch_register_t *reg);

extern ir_op *op_ia32_l_Adc;

static inline bool is_ia32_l_Adc(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_l_Adc;
}

/**
 * construct l_Adc node
 */
ir_node *new_bd_ia32_l_Adc(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right, ir_node *eflags, ir_mode *mode);

extern ir_op *op_ia32_l_Add;

static inline bool is_ia32_l_Add(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_l_Add;
}

/**
 * construct l_Add node
 */
ir_node *new_bd_ia32_l_Add(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right);

extern ir_op *op_ia32_l_FloattoLL;

static inline bool is_ia32_l_FloattoLL(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_l_FloattoLL;
}

/**
 * construct l_FloattoLL node
 */
ir_node *new_bd_ia32_l_FloattoLL(dbg_info *dbgi, ir_node *block, ir_node *val);

extern ir_op *op_ia32_l_IMul;

static inline bool is_ia32_l_IMul(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_l_IMul;
}

/**
 * construct l_IMul node
 */
ir_node *new_bd_ia32_l_IMul(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right);

extern ir_op *op_ia32_l_LLtoFloat;

static inline bool is_ia32_l_LLtoFloat(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_l_LLtoFloat;
}

/**
 * construct l_LLtoFloat node
 */
ir_node *new_bd_ia32_l_LLtoFloat(dbg_info *dbgi, ir_node *block, ir_node *val_high, ir_node *val_low, ir_mode *mode);

extern ir_op *op_ia32_l_Minus64;

static inline bool is_ia32_l_Minus64(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_l_Minus64;
}

/**
 * construct l_Minus64 node
 */
ir_node *new_bd_ia32_l_Minus64(dbg_info *dbgi, ir_node *block, ir_node *low, ir_node *high);

extern ir_op *op_ia32_l_Mul;

static inline bool is_ia32_l_Mul(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_l_Mul;
}

/**
 * construct l_Mul node
 */
ir_node *new_bd_ia32_l_Mul(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right);

extern ir_op *op_ia32_l_Sbb;

static inline bool is_ia32_l_Sbb(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_l_Sbb;
}

/**
 * construct l_Sbb node
 */
ir_node *new_bd_ia32_l_Sbb(dbg_info *dbgi, ir_node *block, ir_node *minuend, ir_node *subtrahend, ir_node *eflags, ir_mode *mode);

extern ir_op *op_ia32_l_Sub;

static inline bool is_ia32_l_Sub(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_l_Sub;
}

/**
 * construct l_Sub node
 */
ir_node *new_bd_ia32_l_Sub(dbg_info *dbgi, ir_node *block, ir_node *minuend, ir_node *subtrahend);

extern ir_op *op_ia32_xAllOnes;

static inline bool is_ia32_xAllOnes(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_xAllOnes;
}

/**
 * construct xAllOnes node
 */
ir_node *new_bd_ia32_xAllOnes(dbg_info *dbgi, ir_node *block, x86_insn_size_t size);

extern ir_op *op_ia32_xLoad;

static inline bool is_ia32_xLoad(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_xLoad;
}

/**
 * construct xLoad node
 */
ir_node *new_bd_ia32_xLoad(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, x86_insn_size_t size);

extern ir_op *op_ia32_xPzero;

static inline bool is_ia32_xPzero(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_xPzero;
}

/**
 * construct xPzero node
 */
ir_node *new_bd_ia32_xPzero(dbg_info *dbgi, ir_node *block, x86_insn_size_t size);

extern ir_op *op_ia32_xStore;

static inline bool is_ia32_xStore(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_xStore;
}

/**
 * construct xStore node
 */
ir_node *new_bd_ia32_xStore(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *val, x86_insn_size_t size);

extern ir_op *op_ia32_xZero;

static inline bool is_ia32_xZero(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_xZero;
}

/**
 * construct xZero node
 */
ir_node *new_bd_ia32_xZero(dbg_info *dbgi, ir_node *block, x86_insn_size_t size);

extern ir_op *op_ia32_xxLoad;

static inline bool is_ia32_xxLoad(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_xxLoad;
}

/**
 * construct xxLoad node
 */
ir_node *new_bd_ia32_xxLoad(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, x86_insn_size_t size);

extern ir_op *op_ia32_xxStore;

static inline bool is_ia32_xxStore(ir_node const *const n)
{
	return get_irn_op(n) == op_ia32_xxStore;
}

/**
 * construct xxStore node
 */
ir_node *new_bd_ia32_xxStore(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index, ir_node *mem, ir_node *val, x86_insn_size_t size);


typedef enum pn_ia32_Adc {
	pn_ia32_Adc_res = 0,
	pn_ia32_Adc_flags = 1,
	pn_ia32_Adc_M = 2,
} pn_ia32_Adc;

typedef enum n_ia32_Adc {
	n_ia32_Adc_base = 0,
	n_ia32_Adc_index = 1,
	n_ia32_Adc_mem = 2,
	n_ia32_Adc_left = 3,
	n_ia32_Adc_right = 4,
	n_ia32_Adc_eflags = 5,
} n_ia32_Adc;

typedef enum pn_ia32_Add {
	pn_ia32_Add_res = 0,
	pn_ia32_Add_flags = 1,
	pn_ia32_Add_M = 2,
} pn_ia32_Add;

typedef enum n_ia32_Add {
	n_ia32_Add_base = 0,
	n_ia32_Add_index = 1,
	n_ia32_Add_mem = 2,
	n_ia32_Add_left = 3,
	n_ia32_Add_right = 4,
} n_ia32_Add;

typedef enum pn_ia32_AddMem {
	pn_ia32_AddMem_unused = 0,
	pn_ia32_AddMem_flags = 1,
	pn_ia32_AddMem_M = 2,
} pn_ia32_AddMem;

typedef enum n_ia32_AddMem {
	n_ia32_AddMem_base = 0,
	n_ia32_AddMem_index = 1,
	n_ia32_AddMem_mem = 2,
	n_ia32_AddMem_val = 3,
} n_ia32_AddMem;

typedef enum pn_ia32_AddSP {
	pn_ia32_AddSP_stack = 0,
	pn_ia32_AddSP_M = 1,
} pn_ia32_AddSP;

typedef enum n_ia32_AddSP {
	n_ia32_AddSP_base = 0,
	n_ia32_AddSP_index = 1,
	n_ia32_AddSP_mem = 2,
	n_ia32_AddSP_stack = 3,
	n_ia32_AddSP_amount = 4,
} n_ia32_AddSP;

typedef enum pn_ia32_Adds {
	pn_ia32_Adds_res = 0,
	pn_ia32_Adds_flags = 1,
	pn_ia32_Adds_M = 2,
} pn_ia32_Adds;

typedef enum n_ia32_Adds {
	n_ia32_Adds_base = 0,
	n_ia32_Adds_index = 1,
	n_ia32_Adds_mem = 2,
	n_ia32_Adds_left = 3,
	n_ia32_Adds_right = 4,
} n_ia32_Adds;

typedef enum pn_ia32_And {
	pn_ia32_And_res = 0,
	pn_ia32_And_flags = 1,
	pn_ia32_And_M = 2,
} pn_ia32_And;

typedef enum n_ia32_And {
	n_ia32_And_base = 0,
	n_ia32_And_index = 1,
	n_ia32_And_mem = 2,
	n_ia32_And_left = 3,
	n_ia32_And_right = 4,
} n_ia32_And;

typedef enum pn_ia32_AndMem {
	pn_ia32_AndMem_unused = 0,
	pn_ia32_AndMem_flags = 1,
	pn_ia32_AndMem_M = 2,
} pn_ia32_AndMem;

typedef enum n_ia32_AndMem {
	n_ia32_AndMem_base = 0,
	n_ia32_AndMem_index = 1,
	n_ia32_AndMem_mem = 2,
	n_ia32_AndMem_val = 3,
} n_ia32_AndMem;

typedef enum pn_ia32_Andnp {
	pn_ia32_Andnp_res = 0,
	pn_ia32_Andnp_flags = 1,
	pn_ia32_Andnp_M = 2,
} pn_ia32_Andnp;

typedef enum n_ia32_Andnp {
	n_ia32_Andnp_base = 0,
	n_ia32_Andnp_index = 1,
	n_ia32_Andnp_mem = 2,
	n_ia32_Andnp_left = 3,
	n_ia32_Andnp_right = 4,
} n_ia32_Andnp;

typedef enum pn_ia32_Andp {
	pn_ia32_Andp_res = 0,
	pn_ia32_Andp_flags = 1,
	pn_ia32_Andp_M = 2,
} pn_ia32_Andp;

typedef enum n_ia32_Andp {
	n_ia32_Andp_base = 0,
	n_ia32_Andp_index = 1,
	n_ia32_Andp_mem = 2,
	n_ia32_Andp_left = 3,
	n_ia32_Andp_right = 4,
} n_ia32_Andp;

typedef enum n_ia32_Breakpoint {
	n_ia32_Breakpoint_mem = 0,
} n_ia32_Breakpoint;

typedef enum pn_ia32_Bsf {
	pn_ia32_Bsf_res = 0,
	pn_ia32_Bsf_flags = 1,
	pn_ia32_Bsf_M = 2,
} pn_ia32_Bsf;

typedef enum n_ia32_Bsf {
	n_ia32_Bsf_base = 0,
	n_ia32_Bsf_index = 1,
	n_ia32_Bsf_mem = 2,
	n_ia32_Bsf_operand = 3,
} n_ia32_Bsf;

typedef enum pn_ia32_Bsr {
	pn_ia32_Bsr_res = 0,
	pn_ia32_Bsr_flags = 1,
	pn_ia32_Bsr_M = 2,
} pn_ia32_Bsr;

typedef enum n_ia32_Bsr {
	n_ia32_Bsr_base = 0,
	n_ia32_Bsr_index = 1,
	n_ia32_Bsr_mem = 2,
	n_ia32_Bsr_operand = 3,
} n_ia32_Bsr;

typedef enum pn_ia32_Bswap {
	pn_ia32_Bswap_res = 0,
} pn_ia32_Bswap;

typedef enum n_ia32_Bswap {
	n_ia32_Bswap_val = 0,
} n_ia32_Bswap;

typedef enum pn_ia32_Bswap16 {
	pn_ia32_Bswap16_res = 0,
} pn_ia32_Bswap16;

typedef enum n_ia32_Bswap16 {
	n_ia32_Bswap16_val = 0,
} n_ia32_Bswap16;

typedef enum n_ia32_Bt {
	n_ia32_Bt_left = 0,
	n_ia32_Bt_right = 1,
} n_ia32_Bt;

typedef enum pn_ia32_CMovcc {
	pn_ia32_CMovcc_res = 0,
	pn_ia32_CMovcc_unused = 1,
	pn_ia32_CMovcc_M = 2,
} pn_ia32_CMovcc;

typedef enum n_ia32_CMovcc {
	n_ia32_CMovcc_base = 0,
	n_ia32_CMovcc_index = 1,
	n_ia32_CMovcc_mem = 2,
	n_ia32_CMovcc_val_false = 3,
	n_ia32_CMovcc_val_true = 4,
	n_ia32_CMovcc_eflags = 5,
} n_ia32_CMovcc;

typedef enum pn_ia32_Call {
	pn_ia32_Call_mem = 0,
	pn_ia32_Call_stack = 1,
	pn_ia32_Call_first_result = 2,
} pn_ia32_Call;

typedef enum n_ia32_Call {
	n_ia32_Call_base = 0,
	n_ia32_Call_index = 1,
	n_ia32_Call_mem = 2,
	n_ia32_Call_callee = 3,
	n_ia32_Call_stack = 4,
	n_ia32_Call_first_argument = 5,
} n_ia32_Call;

typedef enum n_ia32_Cltd {
	n_ia32_Cltd_val = 0,
} n_ia32_Cltd;

typedef enum pn_ia32_Cmp {
	pn_ia32_Cmp_eflags = 0,
	pn_ia32_Cmp_unused = 1,
	pn_ia32_Cmp_M = 2,
} pn_ia32_Cmp;

typedef enum n_ia32_Cmp {
	n_ia32_Cmp_base = 0,
	n_ia32_Cmp_index = 1,
	n_ia32_Cmp_mem = 2,
	n_ia32_Cmp_left = 3,
	n_ia32_Cmp_right = 4,
} n_ia32_Cmp;

typedef enum pn_ia32_CmpXChgMem {
	pn_ia32_CmpXChgMem_res = 0,
	pn_ia32_CmpXChgMem_flags = 1,
	pn_ia32_CmpXChgMem_M = 2,
} pn_ia32_CmpXChgMem;

typedef enum n_ia32_CmpXChgMem {
	n_ia32_CmpXChgMem_base = 0,
	n_ia32_CmpXChgMem_index = 1,
	n_ia32_CmpXChgMem_mem = 2,
	n_ia32_CmpXChgMem_old = 3,
	n_ia32_CmpXChgMem_new = 4,
} n_ia32_CmpXChgMem;

typedef enum pn_ia32_Const {
	pn_ia32_Const_res = 0,
} pn_ia32_Const;

typedef enum n_ia32_Conv_FP2FP {
	n_ia32_Conv_FP2FP_base = 0,
	n_ia32_Conv_FP2FP_index = 1,
	n_ia32_Conv_FP2FP_mem = 2,
	n_ia32_Conv_FP2FP_val = 3,
} n_ia32_Conv_FP2FP;

typedef enum n_ia32_Conv_FP2I {
	n_ia32_Conv_FP2I_base = 0,
	n_ia32_Conv_FP2I_index = 1,
	n_ia32_Conv_FP2I_mem = 2,
	n_ia32_Conv_FP2I_val = 3,
} n_ia32_Conv_FP2I;

typedef enum n_ia32_Conv_I2FP {
	n_ia32_Conv_I2FP_base = 0,
	n_ia32_Conv_I2FP_index = 1,
	n_ia32_Conv_I2FP_mem = 2,
	n_ia32_Conv_I2FP_val = 3,
} n_ia32_Conv_I2FP;

typedef enum pn_ia32_Conv_I2I {
	pn_ia32_Conv_I2I_res = 0,
	pn_ia32_Conv_I2I_unused = 1,
	pn_ia32_Conv_I2I_M = 2,
	pn_ia32_Conv_I2I_X_regular = 3,
	pn_ia32_Conv_I2I_X_except = 4,
} pn_ia32_Conv_I2I;

typedef enum n_ia32_Conv_I2I {
	n_ia32_Conv_I2I_base = 0,
	n_ia32_Conv_I2I_index = 1,
	n_ia32_Conv_I2I_mem = 2,
	n_ia32_Conv_I2I_val = 3,
} n_ia32_Conv_I2I;

typedef enum pn_ia32_CopyB {
	pn_ia32_CopyB_dest = 0,
	pn_ia32_CopyB_source = 1,
	pn_ia32_CopyB_count = 2,
	pn_ia32_CopyB_M = 3,
} pn_ia32_CopyB;

typedef enum n_ia32_CopyB {
	n_ia32_CopyB_dest = 0,
	n_ia32_CopyB_source = 1,
	n_ia32_CopyB_count = 2,
	n_ia32_CopyB_mem = 3,
} n_ia32_CopyB;

typedef enum pn_ia32_CopyB_i {
	pn_ia32_CopyB_i_dest = 0,
	pn_ia32_CopyB_i_source = 1,
	pn_ia32_CopyB_i_M = 2,
} pn_ia32_CopyB_i;

typedef enum n_ia32_CopyB_i {
	n_ia32_CopyB_i_dest = 0,
	n_ia32_CopyB_i_source = 1,
	n_ia32_CopyB_i_mem = 2,
} n_ia32_CopyB_i;

typedef enum pn_ia32_CopyEbpEsp {
	pn_ia32_CopyEbpEsp_esp = 0,
} pn_ia32_CopyEbpEsp;

typedef enum n_ia32_CopyEbpEsp {
	n_ia32_CopyEbpEsp_ebp = 0,
} n_ia32_CopyEbpEsp;

typedef enum n_ia32_CvtSI2SD {
	n_ia32_CvtSI2SD_base = 0,
	n_ia32_CvtSI2SD_index = 1,
	n_ia32_CvtSI2SD_mem = 2,
	n_ia32_CvtSI2SD_val = 3,
} n_ia32_CvtSI2SD;

typedef enum n_ia32_CvtSI2SS {
	n_ia32_CvtSI2SS_base = 0,
	n_ia32_CvtSI2SS_index = 1,
	n_ia32_CvtSI2SS_mem = 2,
	n_ia32_CvtSI2SS_val = 3,
} n_ia32_CvtSI2SS;

typedef enum pn_ia32_Cwtl {
	pn_ia32_Cwtl_res = 0,
} pn_ia32_Cwtl;

typedef enum n_ia32_Cwtl {
	n_ia32_Cwtl_val = 0,
} n_ia32_Cwtl;

typedef enum pn_ia32_Dec {
	pn_ia32_Dec_res = 0,
	pn_ia32_Dec_flags = 1,
} pn_ia32_Dec;

typedef enum n_ia32_Dec {
	n_ia32_Dec_val = 0,
} n_ia32_Dec;

typedef enum pn_ia32_DecMem {
	pn_ia32_DecMem_unused = 0,
	pn_ia32_DecMem_flags = 1,
	pn_ia32_DecMem_M = 2,
} pn_ia32_DecMem;

typedef enum n_ia32_DecMem {
	n_ia32_DecMem_base = 0,
	n_ia32_DecMem_index = 1,
	n_ia32_DecMem_mem = 2,
} n_ia32_DecMem;

typedef enum pn_ia32_Div {
	pn_ia32_Div_div_res = 0,
	pn_ia32_Div_flags = 1,
	pn_ia32_Div_M = 2,
	pn_ia32_Div_mod_res = 3,
	pn_ia32_Div_X_regular = 4,
	pn_ia32_Div_X_except = 5,
} pn_ia32_Div;

typedef enum n_ia32_Div {
	n_ia32_Div_base = 0,
	n_ia32_Div_index = 1,
	n_ia32_Div_mem = 2,
	n_ia32_Div_divisor = 3,
	n_ia32_Div_dividend_low = 4,
	n_ia32_Div_dividend_high = 5,
} n_ia32_Div;

typedef enum pn_ia32_Divs {
	pn_ia32_Divs_res = 0,
	pn_ia32_Divs_flags = 1,
	pn_ia32_Divs_M = 2,
} pn_ia32_Divs;

typedef enum n_ia32_Divs {
	n_ia32_Divs_base = 0,
	n_ia32_Divs_index = 1,
	n_ia32_Divs_mem = 2,
	n_ia32_Divs_left = 3,
	n_ia32_Divs_right = 4,
} n_ia32_Divs;

typedef enum pn_ia32_Enter {
	pn_ia32_Enter_frame = 0,
	pn_ia32_Enter_stack = 1,
	pn_ia32_Enter_M = 2,
} pn_ia32_Enter;

typedef enum n_ia32_FldCW {
	n_ia32_FldCW_base = 0,
	n_ia32_FldCW_index = 1,
	n_ia32_FldCW_mem = 2,
} n_ia32_FldCW;

typedef enum n_ia32_FnstCW {
	n_ia32_FnstCW_base = 0,
	n_ia32_FnstCW_index = 1,
	n_ia32_FnstCW_mem = 2,
	n_ia32_FnstCW_fpcw = 3,
} n_ia32_FnstCW;

typedef enum n_ia32_FnstCWNOP {
	n_ia32_FnstCWNOP_fpcw = 0,
} n_ia32_FnstCWNOP;

typedef enum pn_ia32_FtstFnstsw {
	pn_ia32_FtstFnstsw_flags = 0,
} pn_ia32_FtstFnstsw;

typedef enum n_ia32_FtstFnstsw {
	n_ia32_FtstFnstsw_left = 0,
} n_ia32_FtstFnstsw;

typedef enum pn_ia32_FucomFnstsw {
	pn_ia32_FucomFnstsw_flags = 0,
} pn_ia32_FucomFnstsw;

typedef enum n_ia32_FucomFnstsw {
	n_ia32_FucomFnstsw_left = 0,
	n_ia32_FucomFnstsw_right = 1,
} n_ia32_FucomFnstsw;

typedef enum pn_ia32_Fucomi {
	pn_ia32_Fucomi_flags = 0,
} pn_ia32_Fucomi;

typedef enum n_ia32_Fucomi {
	n_ia32_Fucomi_left = 0,
	n_ia32_Fucomi_right = 1,
} n_ia32_Fucomi;

typedef enum pn_ia32_FucomppFnstsw {
	pn_ia32_FucomppFnstsw_flags = 0,
} pn_ia32_FucomppFnstsw;

typedef enum n_ia32_FucomppFnstsw {
	n_ia32_FucomppFnstsw_left = 0,
	n_ia32_FucomppFnstsw_right = 1,
} n_ia32_FucomppFnstsw;

typedef enum pn_ia32_GetEIP {
	pn_ia32_GetEIP_res = 0,
} pn_ia32_GetEIP;

typedef enum pn_ia32_IDiv {
	pn_ia32_IDiv_div_res = 0,
	pn_ia32_IDiv_flags = 1,
	pn_ia32_IDiv_M = 2,
	pn_ia32_IDiv_mod_res = 3,
	pn_ia32_IDiv_X_regular = 4,
	pn_ia32_IDiv_X_except = 5,
} pn_ia32_IDiv;

typedef enum n_ia32_IDiv {
	n_ia32_IDiv_base = 0,
	n_ia32_IDiv_index = 1,
	n_ia32_IDiv_mem = 2,
	n_ia32_IDiv_divisor = 3,
	n_ia32_IDiv_dividend_low = 4,
	n_ia32_IDiv_dividend_high = 5,
} n_ia32_IDiv;

typedef enum pn_ia32_IJmp {
	pn_ia32_IJmp_jmp = 0,
	pn_ia32_IJmp_none = 1,
	pn_ia32_IJmp_M = 2,
} pn_ia32_IJmp;

typedef enum n_ia32_IJmp {
	n_ia32_IJmp_base = 0,
	n_ia32_IJmp_index = 1,
	n_ia32_IJmp_mem = 2,
	n_ia32_IJmp_target = 3,
} n_ia32_IJmp;

typedef enum pn_ia32_IMul {
	pn_ia32_IMul_res = 0,
	pn_ia32_IMul_flags = 1,
	pn_ia32_IMul_M = 2,
} pn_ia32_IMul;

typedef enum n_ia32_IMul {
	n_ia32_IMul_base = 0,
	n_ia32_IMul_index = 1,
	n_ia32_IMul_mem = 2,
	n_ia32_IMul_left = 3,
	n_ia32_IMul_right = 4,
} n_ia32_IMul;

typedef enum pn_ia32_IMul1OP {
	pn_ia32_IMul1OP_res_low = 0,
	pn_ia32_IMul1OP_flags = 1,
	pn_ia32_IMul1OP_M = 2,
	pn_ia32_IMul1OP_res_high = 3,
} pn_ia32_IMul1OP;

typedef enum n_ia32_IMul1OP {
	n_ia32_IMul1OP_base = 0,
	n_ia32_IMul1OP_index = 1,
	n_ia32_IMul1OP_mem = 2,
	n_ia32_IMul1OP_left = 3,
	n_ia32_IMul1OP_right = 4,
} n_ia32_IMul1OP;

typedef enum pn_ia32_IMulImm {
	pn_ia32_IMulImm_res = 0,
	pn_ia32_IMulImm_flags = 1,
	pn_ia32_IMulImm_M = 2,
} pn_ia32_IMulImm;

typedef enum n_ia32_IMulImm {
	n_ia32_IMulImm_base = 0,
	n_ia32_IMulImm_index = 1,
	n_ia32_IMulImm_mem = 2,
	n_ia32_IMulImm_left = 3,
	n_ia32_IMulImm_right = 4,
} n_ia32_IMulImm;

typedef enum pn_ia32_Inc {
	pn_ia32_Inc_res = 0,
	pn_ia32_Inc_flags = 1,
} pn_ia32_Inc;

typedef enum n_ia32_Inc {
	n_ia32_Inc_val = 0,
} n_ia32_Inc;

typedef enum pn_ia32_IncMem {
	pn_ia32_IncMem_unused = 0,
	pn_ia32_IncMem_flags = 1,
	pn_ia32_IncMem_M = 2,
} pn_ia32_IncMem;

typedef enum n_ia32_IncMem {
	n_ia32_IncMem_base = 0,
	n_ia32_IncMem_index = 1,
	n_ia32_IncMem_mem = 2,
} n_ia32_IncMem;

typedef enum pn_ia32_Inport {
	pn_ia32_Inport_res = 0,
	pn_ia32_Inport_M = 1,
} pn_ia32_Inport;

typedef enum n_ia32_Inport {
	n_ia32_Inport_port = 0,
	n_ia32_Inport_mem = 1,
} n_ia32_Inport;

typedef enum pn_ia32_Jcc {
	pn_ia32_Jcc_false = 0,
	pn_ia32_Jcc_true = 1,
} pn_ia32_Jcc;

typedef enum n_ia32_Jcc {
	n_ia32_Jcc_eflags = 0,
} n_ia32_Jcc;

typedef enum pn_ia32_LdTls {
	pn_ia32_LdTls_res = 0,
} pn_ia32_LdTls;

typedef enum pn_ia32_Lea {
	pn_ia32_Lea_res = 0,
} pn_ia32_Lea;

typedef enum n_ia32_Lea {
	n_ia32_Lea_base = 0,
	n_ia32_Lea_index = 1,
} n_ia32_Lea;

typedef enum pn_ia32_Leave {
	pn_ia32_Leave_frame = 0,
	pn_ia32_Leave_M = 1,
	pn_ia32_Leave_stack = 2,
} pn_ia32_Leave;

typedef enum pn_ia32_Load {
	pn_ia32_Load_res = 0,
	pn_ia32_Load_unused = 1,
	pn_ia32_Load_M = 2,
	pn_ia32_Load_X_regular = 3,
	pn_ia32_Load_X_except = 4,
} pn_ia32_Load;

typedef enum n_ia32_Load {
	n_ia32_Load_base = 0,
	n_ia32_Load_index = 1,
	n_ia32_Load_mem = 2,
} n_ia32_Load;

typedef enum pn_ia32_Maxs {
	pn_ia32_Maxs_res = 0,
	pn_ia32_Maxs_flags = 1,
	pn_ia32_Maxs_M = 2,
} pn_ia32_Maxs;

typedef enum n_ia32_Maxs {
	n_ia32_Maxs_base = 0,
	n_ia32_Maxs_index = 1,
	n_ia32_Maxs_mem = 2,
	n_ia32_Maxs_left = 3,
	n_ia32_Maxs_right = 4,
} n_ia32_Maxs;

typedef enum pn_ia32_Mins {
	pn_ia32_Mins_res = 0,
	pn_ia32_Mins_flags = 1,
	pn_ia32_Mins_M = 2,
} pn_ia32_Mins;

typedef enum n_ia32_Mins {
	n_ia32_Mins_base = 0,
	n_ia32_Mins_index = 1,
	n_ia32_Mins_mem = 2,
	n_ia32_Mins_left = 3,
	n_ia32_Mins_right = 4,
} n_ia32_Mins;

typedef enum pn_ia32_Minus64 {
	pn_ia32_Minus64_res_low = 0,
	pn_ia32_Minus64_res_high = 1,
} pn_ia32_Minus64;

typedef enum n_ia32_Minus64 {
	n_ia32_Minus64_low = 0,
	n_ia32_Minus64_high = 1,
} n_ia32_Minus64;

typedef enum pn_ia32_Mul {
	pn_ia32_Mul_res_low = 0,
	pn_ia32_Mul_flags = 1,
	pn_ia32_Mul_M = 2,
	pn_ia32_Mul_res_high = 3,
} pn_ia32_Mul;

typedef enum n_ia32_Mul {
	n_ia32_Mul_base = 0,
	n_ia32_Mul_index = 1,
	n_ia32_Mul_mem = 2,
	n_ia32_Mul_left = 3,
	n_ia32_Mul_right = 4,
} n_ia32_Mul;

typedef enum pn_ia32_Muls {
	pn_ia32_Muls_res = 0,
	pn_ia32_Muls_flags = 1,
	pn_ia32_Muls_M = 2,
} pn_ia32_Muls;

typedef enum n_ia32_Muls {
	n_ia32_Muls_base = 0,
	n_ia32_Muls_index = 1,
	n_ia32_Muls_mem = 2,
	n_ia32_Muls_left = 3,
	n_ia32_Muls_right = 4,
} n_ia32_Muls;

typedef enum pn_ia32_Neg {
	pn_ia32_Neg_res = 0,
	pn_ia32_Neg_flags = 1,
} pn_ia32_Neg;

typedef enum n_ia32_Neg {
	n_ia32_Neg_val = 0,
} n_ia32_Neg;

typedef enum pn_ia32_NegMem {
	pn_ia32_NegMem_unused = 0,
	pn_ia32_NegMem_flags = 1,
	pn_ia32_NegMem_M = 2,
} pn_ia32_NegMem;

typedef enum n_ia32_NegMem {
	n_ia32_NegMem_base = 0,
	n_ia32_NegMem_index = 1,
	n_ia32_NegMem_mem = 2,
} n_ia32_NegMem;

typedef enum pn_ia32_Not {
	pn_ia32_Not_res = 0,
} pn_ia32_Not;

typedef enum n_ia32_Not {
	n_ia32_Not_val = 0,
} n_ia32_Not;

typedef enum pn_ia32_NotMem {
	pn_ia32_NotMem_unused0 = 0,
	pn_ia32_NotMem_unused1 = 1,
	pn_ia32_NotMem_M = 2,
} pn_ia32_NotMem;

typedef enum n_ia32_NotMem {
	n_ia32_NotMem_base = 0,
	n_ia32_NotMem_index = 1,
	n_ia32_NotMem_mem = 2,
} n_ia32_NotMem;

typedef enum pn_ia32_Or {
	pn_ia32_Or_res = 0,
	pn_ia32_Or_flags = 1,
	pn_ia32_Or_M = 2,
} pn_ia32_Or;

typedef enum n_ia32_Or {
	n_ia32_Or_base = 0,
	n_ia32_Or_index = 1,
	n_ia32_Or_mem = 2,
	n_ia32_Or_left = 3,
	n_ia32_Or_right = 4,
} n_ia32_Or;

typedef enum pn_ia32_OrMem {
	pn_ia32_OrMem_unused = 0,
	pn_ia32_OrMem_flags = 1,
	pn_ia32_OrMem_M = 2,
} pn_ia32_OrMem;

typedef enum n_ia32_OrMem {
	n_ia32_OrMem_base = 0,
	n_ia32_OrMem_index = 1,
	n_ia32_OrMem_mem = 2,
	n_ia32_OrMem_val = 3,
} n_ia32_OrMem;

typedef enum pn_ia32_Orp {
	pn_ia32_Orp_res = 0,
	pn_ia32_Orp_flags = 1,
	pn_ia32_Orp_M = 2,
} pn_ia32_Orp;

typedef enum n_ia32_Orp {
	n_ia32_Orp_base = 0,
	n_ia32_Orp_index = 1,
	n_ia32_Orp_mem = 2,
	n_ia32_Orp_left = 3,
	n_ia32_Orp_right = 4,
} n_ia32_Orp;

typedef enum n_ia32_Outport {
	n_ia32_Outport_port = 0,
	n_ia32_Outport_value = 1,
	n_ia32_Outport_mem = 2,
} n_ia32_Outport;

typedef enum pn_ia32_Pop {
	pn_ia32_Pop_res = 0,
	pn_ia32_Pop_unused = 1,
	pn_ia32_Pop_M = 2,
	pn_ia32_Pop_stack = 3,
} pn_ia32_Pop;

typedef enum n_ia32_Pop {
	n_ia32_Pop_mem = 0,
	n_ia32_Pop_stack = 1,
} n_ia32_Pop;

typedef enum pn_ia32_PopMem {
	pn_ia32_PopMem_unused0 = 0,
	pn_ia32_PopMem_unused1 = 1,
	pn_ia32_PopMem_M = 2,
	pn_ia32_PopMem_stack = 3,
} pn_ia32_PopMem;

typedef enum n_ia32_PopMem {
	n_ia32_PopMem_base = 0,
	n_ia32_PopMem_index = 1,
	n_ia32_PopMem_mem = 2,
	n_ia32_PopMem_stack = 3,
} n_ia32_PopMem;

typedef enum pn_ia32_Popcnt {
	pn_ia32_Popcnt_res = 0,
	pn_ia32_Popcnt_flags = 1,
	pn_ia32_Popcnt_M = 2,
} pn_ia32_Popcnt;

typedef enum n_ia32_Popcnt {
	n_ia32_Popcnt_base = 0,
	n_ia32_Popcnt_index = 1,
	n_ia32_Popcnt_mem = 2,
	n_ia32_Popcnt_operand = 3,
} n_ia32_Popcnt;

typedef enum pn_ia32_Prefetch {
	pn_ia32_Prefetch_M = 0,
} pn_ia32_Prefetch;

typedef enum n_ia32_Prefetch {
	n_ia32_Prefetch_base = 0,
	n_ia32_Prefetch_index = 1,
	n_ia32_Prefetch_mem = 2,
} n_ia32_Prefetch;

typedef enum pn_ia32_PrefetchNTA {
	pn_ia32_PrefetchNTA_M = 0,
} pn_ia32_PrefetchNTA;

typedef enum n_ia32_PrefetchNTA {
	n_ia32_PrefetchNTA_base = 0,
	n_ia32_PrefetchNTA_index = 1,
	n_ia32_PrefetchNTA_mem = 2,
} n_ia32_PrefetchNTA;

typedef enum pn_ia32_PrefetchT0 {
	pn_ia32_PrefetchT0_M = 0,
} pn_ia32_PrefetchT0;

typedef enum n_ia32_PrefetchT0 {
	n_ia32_PrefetchT0_base = 0,
	n_ia32_PrefetchT0_index = 1,
	n_ia32_PrefetchT0_mem = 2,
} n_ia32_PrefetchT0;

typedef enum pn_ia32_PrefetchT1 {
	pn_ia32_PrefetchT1_M = 0,
} pn_ia32_PrefetchT1;

typedef enum n_ia32_PrefetchT1 {
	n_ia32_PrefetchT1_base = 0,
	n_ia32_PrefetchT1_index = 1,
	n_ia32_PrefetchT1_mem = 2,
} n_ia32_PrefetchT1;

typedef enum pn_ia32_PrefetchT2 {
	pn_ia32_PrefetchT2_M = 0,
} pn_ia32_PrefetchT2;

typedef enum n_ia32_PrefetchT2 {
	n_ia32_PrefetchT2_base = 0,
	n_ia32_PrefetchT2_index = 1,
	n_ia32_PrefetchT2_mem = 2,
} n_ia32_PrefetchT2;

typedef enum pn_ia32_PrefetchW {
	pn_ia32_PrefetchW_M = 0,
} pn_ia32_PrefetchW;

typedef enum n_ia32_PrefetchW {
	n_ia32_PrefetchW_base = 0,
	n_ia32_PrefetchW_index = 1,
	n_ia32_PrefetchW_mem = 2,
} n_ia32_PrefetchW;

typedef enum pn_ia32_Push {
	pn_ia32_Push_M = 0,
	pn_ia32_Push_stack = 1,
} pn_ia32_Push;

typedef enum n_ia32_Push {
	n_ia32_Push_base = 0,
	n_ia32_Push_index = 1,
	n_ia32_Push_mem = 2,
	n_ia32_Push_val = 3,
	n_ia32_Push_stack = 4,
} n_ia32_Push;

typedef enum pn_ia32_PushEax {
	pn_ia32_PushEax_stack = 0,
} pn_ia32_PushEax;

typedef enum n_ia32_PushEax {
	n_ia32_PushEax_stack = 0,
} n_ia32_PushEax;

typedef enum n_ia32_Ret {
	n_ia32_Ret_mem = 0,
	n_ia32_Ret_stack = 1,
	n_ia32_Ret_first_result = 2,
} n_ia32_Ret;

typedef enum pn_ia32_Rol {
	pn_ia32_Rol_res = 0,
	pn_ia32_Rol_flags = 1,
} pn_ia32_Rol;

typedef enum n_ia32_Rol {
	n_ia32_Rol_val = 0,
	n_ia32_Rol_count = 1,
} n_ia32_Rol;

typedef enum pn_ia32_RolMem {
	pn_ia32_RolMem_unused = 0,
	pn_ia32_RolMem_flags = 1,
	pn_ia32_RolMem_M = 2,
} pn_ia32_RolMem;

typedef enum n_ia32_RolMem {
	n_ia32_RolMem_base = 0,
	n_ia32_RolMem_index = 1,
	n_ia32_RolMem_mem = 2,
	n_ia32_RolMem_count = 3,
} n_ia32_RolMem;

typedef enum pn_ia32_Ror {
	pn_ia32_Ror_res = 0,
	pn_ia32_Ror_flags = 1,
} pn_ia32_Ror;

typedef enum n_ia32_Ror {
	n_ia32_Ror_val = 0,
	n_ia32_Ror_count = 1,
} n_ia32_Ror;

typedef enum pn_ia32_RorMem {
	pn_ia32_RorMem_unused = 0,
	pn_ia32_RorMem_flags = 1,
	pn_ia32_RorMem_M = 2,
} pn_ia32_RorMem;

typedef enum n_ia32_RorMem {
	n_ia32_RorMem_base = 0,
	n_ia32_RorMem_index = 1,
	n_ia32_RorMem_mem = 2,
	n_ia32_RorMem_count = 3,
} n_ia32_RorMem;

typedef enum pn_ia32_Sahf {
	pn_ia32_Sahf_flags = 0,
} pn_ia32_Sahf;

typedef enum n_ia32_Sahf {
	n_ia32_Sahf_val = 0,
} n_ia32_Sahf;

typedef enum pn_ia32_Sar {
	pn_ia32_Sar_res = 0,
	pn_ia32_Sar_flags = 1,
} pn_ia32_Sar;

typedef enum n_ia32_Sar {
	n_ia32_Sar_val = 0,
	n_ia32_Sar_count = 1,
} n_ia32_Sar;

typedef enum pn_ia32_SarMem {
	pn_ia32_SarMem_unused = 0,
	pn_ia32_SarMem_flags = 1,
	pn_ia32_SarMem_M = 2,
} pn_ia32_SarMem;

typedef enum n_ia32_SarMem {
	n_ia32_SarMem_base = 0,
	n_ia32_SarMem_index = 1,
	n_ia32_SarMem_mem = 2,
	n_ia32_SarMem_count = 3,
} n_ia32_SarMem;

typedef enum pn_ia32_Sbb {
	pn_ia32_Sbb_res = 0,
	pn_ia32_Sbb_flags = 1,
	pn_ia32_Sbb_M = 2,
} pn_ia32_Sbb;

typedef enum n_ia32_Sbb {
	n_ia32_Sbb_base = 0,
	n_ia32_Sbb_index = 1,
	n_ia32_Sbb_mem = 2,
	n_ia32_Sbb_minuend = 3,
	n_ia32_Sbb_subtrahend = 4,
	n_ia32_Sbb_eflags = 5,
} n_ia32_Sbb;

typedef enum pn_ia32_Sbb0 {
	pn_ia32_Sbb0_res = 0,
	pn_ia32_Sbb0_flags = 1,
} pn_ia32_Sbb0;

typedef enum pn_ia32_Setcc {
	pn_ia32_Setcc_res = 0,
} pn_ia32_Setcc;

typedef enum n_ia32_Setcc {
	n_ia32_Setcc_eflags = 0,
} n_ia32_Setcc;

typedef enum n_ia32_SetccMem {
	n_ia32_SetccMem_base = 0,
	n_ia32_SetccMem_index = 1,
	n_ia32_SetccMem_mem = 2,
	n_ia32_SetccMem_eflags = 3,
} n_ia32_SetccMem;

typedef enum pn_ia32_Shl {
	pn_ia32_Shl_res = 0,
	pn_ia32_Shl_flags = 1,
} pn_ia32_Shl;

typedef enum n_ia32_Shl {
	n_ia32_Shl_val = 0,
	n_ia32_Shl_count = 1,
} n_ia32_Shl;

typedef enum pn_ia32_ShlD {
	pn_ia32_ShlD_res = 0,
	pn_ia32_ShlD_flags = 1,
} pn_ia32_ShlD;

typedef enum n_ia32_ShlD {
	n_ia32_ShlD_val_high = 0,
	n_ia32_ShlD_val_low = 1,
	n_ia32_ShlD_count = 2,
} n_ia32_ShlD;

typedef enum pn_ia32_ShlMem {
	pn_ia32_ShlMem_unused = 0,
	pn_ia32_ShlMem_flags = 1,
	pn_ia32_ShlMem_M = 2,
} pn_ia32_ShlMem;

typedef enum n_ia32_ShlMem {
	n_ia32_ShlMem_base = 0,
	n_ia32_ShlMem_index = 1,
	n_ia32_ShlMem_mem = 2,
	n_ia32_ShlMem_count = 3,
} n_ia32_ShlMem;

typedef enum pn_ia32_Shr {
	pn_ia32_Shr_res = 0,
	pn_ia32_Shr_flags = 1,
} pn_ia32_Shr;

typedef enum n_ia32_Shr {
	n_ia32_Shr_val = 0,
	n_ia32_Shr_count = 1,
} n_ia32_Shr;

typedef enum pn_ia32_ShrD {
	pn_ia32_ShrD_res = 0,
	pn_ia32_ShrD_flags = 1,
} pn_ia32_ShrD;

typedef enum n_ia32_ShrD {
	n_ia32_ShrD_val_high = 0,
	n_ia32_ShrD_val_low = 1,
	n_ia32_ShrD_count = 2,
} n_ia32_ShrD;

typedef enum pn_ia32_ShrMem {
	pn_ia32_ShrMem_unused = 0,
	pn_ia32_ShrMem_flags = 1,
	pn_ia32_ShrMem_M = 2,
} pn_ia32_ShrMem;

typedef enum n_ia32_ShrMem {
	n_ia32_ShrMem_base = 0,
	n_ia32_ShrMem_index = 1,
	n_ia32_ShrMem_mem = 2,
	n_ia32_ShrMem_count = 3,
} n_ia32_ShrMem;

typedef enum pn_ia32_Store {
	pn_ia32_Store_M = 0,
	pn_ia32_Store_X_regular = 1,
	pn_ia32_Store_X_except = 2,
} pn_ia32_Store;

typedef enum n_ia32_Store {
	n_ia32_Store_base = 0,
	n_ia32_Store_index = 1,
	n_ia32_Store_mem = 2,
	n_ia32_Store_val = 3,
} n_ia32_Store;

typedef enum pn_ia32_Sub {
	pn_ia32_Sub_res = 0,
	pn_ia32_Sub_flags = 1,
	pn_ia32_Sub_M = 2,
} pn_ia32_Sub;

typedef enum n_ia32_Sub {
	n_ia32_Sub_base = 0,
	n_ia32_Sub_index = 1,
	n_ia32_Sub_mem = 2,
	n_ia32_Sub_minuend = 3,
	n_ia32_Sub_subtrahend = 4,
} n_ia32_Sub;

typedef enum pn_ia32_SubMem {
	pn_ia32_SubMem_unused = 0,
	pn_ia32_SubMem_flags = 1,
	pn_ia32_SubMem_M = 2,
} pn_ia32_SubMem;

typedef enum n_ia32_SubMem {
	n_ia32_SubMem_base = 0,
	n_ia32_SubMem_index = 1,
	n_ia32_SubMem_mem = 2,
	n_ia32_SubMem_val = 3,
} n_ia32_SubMem;

typedef enum pn_ia32_SubSP {
	pn_ia32_SubSP_stack = 0,
	pn_ia32_SubSP_addr = 1,
	pn_ia32_SubSP_M = 2,
} pn_ia32_SubSP;

typedef enum n_ia32_SubSP {
	n_ia32_SubSP_base = 0,
	n_ia32_SubSP_index = 1,
	n_ia32_SubSP_mem = 2,
	n_ia32_SubSP_stack = 3,
	n_ia32_SubSP_amount = 4,
} n_ia32_SubSP;

typedef enum pn_ia32_Subs {
	pn_ia32_Subs_res = 0,
	pn_ia32_Subs_flags = 1,
	pn_ia32_Subs_M = 2,
} pn_ia32_Subs;

typedef enum n_ia32_Subs {
	n_ia32_Subs_base = 0,
	n_ia32_Subs_index = 1,
	n_ia32_Subs_mem = 2,
	n_ia32_Subs_minuend = 3,
	n_ia32_Subs_subtrahend = 4,
} n_ia32_Subs;

typedef enum n_ia32_SwitchJmp {
	n_ia32_SwitchJmp_base = 0,
	n_ia32_SwitchJmp_index = 1,
} n_ia32_SwitchJmp;

typedef enum pn_ia32_Test {
	pn_ia32_Test_eflags = 0,
	pn_ia32_Test_unused = 1,
	pn_ia32_Test_M = 2,
} pn_ia32_Test;

typedef enum n_ia32_Test {
	n_ia32_Test_base = 0,
	n_ia32_Test_index = 1,
	n_ia32_Test_mem = 2,
	n_ia32_Test_left = 3,
	n_ia32_Test_right = 4,
} n_ia32_Test;

typedef enum n_ia32_UD2 {
	n_ia32_UD2_mem = 0,
} n_ia32_UD2;

typedef enum pn_ia32_Ucomis {
	pn_ia32_Ucomis_flags = 0,
} pn_ia32_Ucomis;

typedef enum n_ia32_Ucomis {
	n_ia32_Ucomis_base = 0,
	n_ia32_Ucomis_index = 1,
	n_ia32_Ucomis_mem = 2,
	n_ia32_Ucomis_left = 3,
	n_ia32_Ucomis_right = 4,
} n_ia32_Ucomis;

typedef enum pn_ia32_Xor {
	pn_ia32_Xor_res = 0,
	pn_ia32_Xor_flags = 1,
	pn_ia32_Xor_M = 2,
} pn_ia32_Xor;

typedef enum n_ia32_Xor {
	n_ia32_Xor_base = 0,
	n_ia32_Xor_index = 1,
	n_ia32_Xor_mem = 2,
	n_ia32_Xor_left = 3,
	n_ia32_Xor_right = 4,
} n_ia32_Xor;

typedef enum pn_ia32_Xor0 {
	pn_ia32_Xor0_res = 0,
	pn_ia32_Xor0_flags = 1,
} pn_ia32_Xor0;

typedef enum pn_ia32_XorHighLow {
	pn_ia32_XorHighLow_res = 0,
	pn_ia32_XorHighLow_flags = 1,
} pn_ia32_XorHighLow;

typedef enum n_ia32_XorHighLow {
	n_ia32_XorHighLow_value = 0,
} n_ia32_XorHighLow;

typedef enum pn_ia32_XorMem {
	pn_ia32_XorMem_unused = 0,
	pn_ia32_XorMem_flags = 1,
	pn_ia32_XorMem_M = 2,
} pn_ia32_XorMem;

typedef enum n_ia32_XorMem {
	n_ia32_XorMem_base = 0,
	n_ia32_XorMem_index = 1,
	n_ia32_XorMem_mem = 2,
	n_ia32_XorMem_val = 3,
} n_ia32_XorMem;

typedef enum pn_ia32_Xorp {
	pn_ia32_Xorp_res = 0,
	pn_ia32_Xorp_flags = 1,
	pn_ia32_Xorp_M = 2,
} pn_ia32_Xorp;

typedef enum n_ia32_Xorp {
	n_ia32_Xorp_base = 0,
	n_ia32_Xorp_index = 1,
	n_ia32_Xorp_mem = 2,
	n_ia32_Xorp_left = 3,
	n_ia32_Xorp_right = 4,
} n_ia32_Xorp;

typedef enum n_ia32_fabs {
	n_ia32_fabs_value = 0,
} n_ia32_fabs;

typedef enum pn_ia32_fadd {
	pn_ia32_fadd_res = 0,
	pn_ia32_fadd_dummy = 1,
	pn_ia32_fadd_M = 2,
} pn_ia32_fadd;

typedef enum n_ia32_fadd {
	n_ia32_fadd_base = 0,
	n_ia32_fadd_index = 1,
	n_ia32_fadd_mem = 2,
	n_ia32_fadd_left = 3,
	n_ia32_fadd_right = 4,
	n_ia32_fadd_fpcw = 5,
} n_ia32_fadd;

typedef enum n_ia32_fchs {
	n_ia32_fchs_value = 0,
} n_ia32_fchs;

typedef enum pn_ia32_fdiv {
	pn_ia32_fdiv_res = 0,
	pn_ia32_fdiv_dummy = 1,
	pn_ia32_fdiv_M = 2,
} pn_ia32_fdiv;

typedef enum n_ia32_fdiv {
	n_ia32_fdiv_base = 0,
	n_ia32_fdiv_index = 1,
	n_ia32_fdiv_mem = 2,
	n_ia32_fdiv_left = 3,
	n_ia32_fdiv_right = 4,
	n_ia32_fdiv_fpcw = 5,
} n_ia32_fdiv;

typedef enum n_ia32_fdup {
	n_ia32_fdup_val = 0,
} n_ia32_fdup;

typedef enum pn_ia32_fild {
	pn_ia32_fild_res = 0,
	pn_ia32_fild_unused = 1,
	pn_ia32_fild_M = 2,
	pn_ia32_fild_X_regular = 3,
	pn_ia32_fild_X_except = 4,
} pn_ia32_fild;

typedef enum n_ia32_fild {
	n_ia32_fild_base = 0,
	n_ia32_fild_index = 1,
	n_ia32_fild_mem = 2,
} n_ia32_fild;

typedef enum pn_ia32_fist {
	pn_ia32_fist_M = 0,
	pn_ia32_fist_X_regular = 1,
	pn_ia32_fist_X_except = 2,
} pn_ia32_fist;

typedef enum n_ia32_fist {
	n_ia32_fist_base = 0,
	n_ia32_fist_index = 1,
	n_ia32_fist_mem = 2,
	n_ia32_fist_val = 3,
	n_ia32_fist_fpcw = 4,
} n_ia32_fist;

typedef enum pn_ia32_fistp {
	pn_ia32_fistp_M = 0,
	pn_ia32_fistp_X_regular = 1,
	pn_ia32_fistp_X_except = 2,
} pn_ia32_fistp;

typedef enum n_ia32_fistp {
	n_ia32_fistp_base = 0,
	n_ia32_fistp_index = 1,
	n_ia32_fistp_mem = 2,
	n_ia32_fistp_val = 3,
	n_ia32_fistp_fpcw = 4,
} n_ia32_fistp;

typedef enum pn_ia32_fisttp {
	pn_ia32_fisttp_M = 0,
	pn_ia32_fisttp_X_regular = 1,
	pn_ia32_fisttp_X_except = 2,
} pn_ia32_fisttp;

typedef enum n_ia32_fisttp {
	n_ia32_fisttp_base = 0,
	n_ia32_fisttp_index = 1,
	n_ia32_fisttp_mem = 2,
	n_ia32_fisttp_val = 3,
} n_ia32_fisttp;

typedef enum pn_ia32_fld {
	pn_ia32_fld_res = 0,
	pn_ia32_fld_unused = 1,
	pn_ia32_fld_M = 2,
	pn_ia32_fld_X_regular = 3,
	pn_ia32_fld_X_except = 4,
} pn_ia32_fld;

typedef enum n_ia32_fld {
	n_ia32_fld_base = 0,
	n_ia32_fld_index = 1,
	n_ia32_fld_mem = 2,
} n_ia32_fld;

typedef enum pn_ia32_fld1 {
	pn_ia32_fld1_res = 0,
} pn_ia32_fld1;

typedef enum pn_ia32_fldl2e {
	pn_ia32_fldl2e_res = 0,
} pn_ia32_fldl2e;

typedef enum pn_ia32_fldl2t {
	pn_ia32_fldl2t_res = 0,
} pn_ia32_fldl2t;

typedef enum pn_ia32_fldlg2 {
	pn_ia32_fldlg2_res = 0,
} pn_ia32_fldlg2;

typedef enum pn_ia32_fldln2 {
	pn_ia32_fldln2_res = 0,
} pn_ia32_fldln2;

typedef enum pn_ia32_fldpi {
	pn_ia32_fldpi_res = 0,
} pn_ia32_fldpi;

typedef enum pn_ia32_fldz {
	pn_ia32_fldz_res = 0,
} pn_ia32_fldz;

typedef enum pn_ia32_fmul {
	pn_ia32_fmul_res = 0,
	pn_ia32_fmul_dummy = 1,
	pn_ia32_fmul_M = 2,
} pn_ia32_fmul;

typedef enum n_ia32_fmul {
	n_ia32_fmul_base = 0,
	n_ia32_fmul_index = 1,
	n_ia32_fmul_mem = 2,
	n_ia32_fmul_left = 3,
	n_ia32_fmul_right = 4,
	n_ia32_fmul_fpcw = 5,
} n_ia32_fmul;

typedef enum pn_ia32_fst {
	pn_ia32_fst_M = 0,
	pn_ia32_fst_X_regular = 1,
	pn_ia32_fst_X_except = 2,
} pn_ia32_fst;

typedef enum n_ia32_fst {
	n_ia32_fst_base = 0,
	n_ia32_fst_index = 1,
	n_ia32_fst_mem = 2,
	n_ia32_fst_val = 3,
} n_ia32_fst;

typedef enum pn_ia32_fstp {
	pn_ia32_fstp_M = 0,
	pn_ia32_fstp_X_regular = 1,
	pn_ia32_fstp_X_except = 2,
} pn_ia32_fstp;

typedef enum n_ia32_fstp {
	n_ia32_fstp_base = 0,
	n_ia32_fstp_index = 1,
	n_ia32_fstp_mem = 2,
	n_ia32_fstp_val = 3,
} n_ia32_fstp;

typedef enum pn_ia32_fsub {
	pn_ia32_fsub_res = 0,
	pn_ia32_fsub_dummy = 1,
	pn_ia32_fsub_M = 2,
} pn_ia32_fsub;

typedef enum n_ia32_fsub {
	n_ia32_fsub_base = 0,
	n_ia32_fsub_index = 1,
	n_ia32_fsub_mem = 2,
	n_ia32_fsub_left = 3,
	n_ia32_fsub_right = 4,
	n_ia32_fsub_fpcw = 5,
} n_ia32_fsub;

typedef enum n_ia32_l_Adc {
	n_ia32_l_Adc_left = 0,
	n_ia32_l_Adc_right = 1,
	n_ia32_l_Adc_eflags = 2,
} n_ia32_l_Adc;

typedef enum pn_ia32_l_Add {
	pn_ia32_l_Add_res = 0,
	pn_ia32_l_Add_flags = 1,
} pn_ia32_l_Add;

typedef enum n_ia32_l_Add {
	n_ia32_l_Add_left = 0,
	n_ia32_l_Add_right = 1,
} n_ia32_l_Add;

typedef enum pn_ia32_l_FloattoLL {
	pn_ia32_l_FloattoLL_res_high = 0,
	pn_ia32_l_FloattoLL_res_low = 1,
} pn_ia32_l_FloattoLL;

typedef enum n_ia32_l_FloattoLL {
	n_ia32_l_FloattoLL_val = 0,
} n_ia32_l_FloattoLL;

typedef enum pn_ia32_l_IMul {
	pn_ia32_l_IMul_res_low = 0,
	pn_ia32_l_IMul_flags = 1,
	pn_ia32_l_IMul_M = 2,
	pn_ia32_l_IMul_res_high = 3,
} pn_ia32_l_IMul;

typedef enum n_ia32_l_IMul {
	n_ia32_l_IMul_left = 0,
	n_ia32_l_IMul_right = 1,
} n_ia32_l_IMul;

typedef enum n_ia32_l_LLtoFloat {
	n_ia32_l_LLtoFloat_val_high = 0,
	n_ia32_l_LLtoFloat_val_low = 1,
} n_ia32_l_LLtoFloat;

typedef enum pn_ia32_l_Minus64 {
	pn_ia32_l_Minus64_res_low = 0,
	pn_ia32_l_Minus64_res_high = 1,
} pn_ia32_l_Minus64;

typedef enum n_ia32_l_Minus64 {
	n_ia32_l_Minus64_low = 0,
	n_ia32_l_Minus64_high = 1,
} n_ia32_l_Minus64;

typedef enum pn_ia32_l_Mul {
	pn_ia32_l_Mul_res_low = 0,
	pn_ia32_l_Mul_flags = 1,
	pn_ia32_l_Mul_M = 2,
	pn_ia32_l_Mul_res_high = 3,
} pn_ia32_l_Mul;

typedef enum n_ia32_l_Mul {
	n_ia32_l_Mul_left = 0,
	n_ia32_l_Mul_right = 1,
} n_ia32_l_Mul;

typedef enum n_ia32_l_Sbb {
	n_ia32_l_Sbb_minuend = 0,
	n_ia32_l_Sbb_subtrahend = 1,
	n_ia32_l_Sbb_eflags = 2,
} n_ia32_l_Sbb;

typedef enum pn_ia32_l_Sub {
	pn_ia32_l_Sub_res = 0,
	pn_ia32_l_Sub_flags = 1,
} pn_ia32_l_Sub;

typedef enum n_ia32_l_Sub {
	n_ia32_l_Sub_minuend = 0,
	n_ia32_l_Sub_subtrahend = 1,
} n_ia32_l_Sub;

typedef enum pn_ia32_xAllOnes {
	pn_ia32_xAllOnes_res = 0,
} pn_ia32_xAllOnes;

typedef enum pn_ia32_xLoad {
	pn_ia32_xLoad_res = 0,
	pn_ia32_xLoad_unused = 1,
	pn_ia32_xLoad_M = 2,
	pn_ia32_xLoad_X_regular = 3,
	pn_ia32_xLoad_X_except = 4,
} pn_ia32_xLoad;

typedef enum n_ia32_xLoad {
	n_ia32_xLoad_base = 0,
	n_ia32_xLoad_index = 1,
	n_ia32_xLoad_mem = 2,
} n_ia32_xLoad;

typedef enum pn_ia32_xPzero {
	pn_ia32_xPzero_res = 0,
} pn_ia32_xPzero;

typedef enum pn_ia32_xStore {
	pn_ia32_xStore_M = 0,
	pn_ia32_xStore_X_regular = 1,
	pn_ia32_xStore_X_except = 2,
} pn_ia32_xStore;

typedef enum n_ia32_xStore {
	n_ia32_xStore_base = 0,
	n_ia32_xStore_index = 1,
	n_ia32_xStore_mem = 2,
	n_ia32_xStore_val = 3,
} n_ia32_xStore;

typedef enum pn_ia32_xZero {
	pn_ia32_xZero_res = 0,
} pn_ia32_xZero;

typedef enum pn_ia32_xxLoad {
	pn_ia32_xxLoad_res = 0,
	pn_ia32_xxLoad_M = 1,
	pn_ia32_xxLoad_X_regular = 2,
	pn_ia32_xxLoad_X_except = 3,
} pn_ia32_xxLoad;

typedef enum n_ia32_xxLoad {
	n_ia32_xxLoad_base = 0,
	n_ia32_xxLoad_index = 1,
	n_ia32_xxLoad_mem = 2,
} n_ia32_xxLoad;

typedef enum pn_ia32_xxStore {
	pn_ia32_xxStore_M = 0,
	pn_ia32_xxStore_X_regular = 1,
	pn_ia32_xxStore_X_except = 2,
} pn_ia32_xxStore;

typedef enum n_ia32_xxStore {
	n_ia32_xxStore_base = 0,
	n_ia32_xxStore_index = 1,
	n_ia32_xxStore_mem = 2,
	n_ia32_xxStore_val = 3,
} n_ia32_xxStore;


#endif
