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

#include "be_types.h"
#include "irnode_t.h"
#include "riscv_nodes_attr.h"

typedef enum riscv_opcodes {
	iro_riscv_FrameAddr,
	iro_riscv_SubSP,
	iro_riscv_SubSPimm,
	iro_riscv_add,
	iro_riscv_addi,
	iro_riscv_and,
	iro_riscv_andi,
	iro_riscv_bcc,
	iro_riscv_div,
	iro_riscv_divu,
	iro_riscv_ijmp,
	iro_riscv_j,
	iro_riscv_jal,
	iro_riscv_jalr,
	iro_riscv_lb,
	iro_riscv_lbu,
	iro_riscv_lh,
	iro_riscv_lhu,
	iro_riscv_lui,
	iro_riscv_lw,
	iro_riscv_mul,
	iro_riscv_mulh,
	iro_riscv_mulhu,
	iro_riscv_or,
	iro_riscv_ori,
	iro_riscv_rem,
	iro_riscv_remu,
	iro_riscv_ret,
	iro_riscv_sb,
	iro_riscv_sh,
	iro_riscv_sll,
	iro_riscv_slli,
	iro_riscv_slt,
	iro_riscv_sltiu,
	iro_riscv_sltu,
	iro_riscv_sra,
	iro_riscv_srai,
	iro_riscv_srl,
	iro_riscv_srli,
	iro_riscv_sub,
	iro_riscv_sw,
	iro_riscv_switch,
	iro_riscv_xor,
	iro_riscv_xori,
	iro_riscv_last
} riscv_opcodes;


int is_riscv_irn(const ir_node *node);
int is_riscv_op(const ir_op *op);

int get_riscv_irn_opcode(const ir_node *node);
void riscv_create_opcodes(void);
void riscv_free_opcodes(void);

extern ir_op *op_riscv_FrameAddr;

static inline bool is_riscv_FrameAddr(ir_node const *const n)
{
	return get_irn_op(n) == op_riscv_FrameAddr;
}

/**
 * construct FrameAddr node
 */
ir_node *new_bd_riscv_FrameAddr(dbg_info *dbgi, ir_node *block, ir_node *base, ir_entity *ent, int32_t val);

extern ir_op *op_riscv_SubSP;

static inline bool is_riscv_SubSP(ir_node const *const n)
{
	return get_irn_op(n) == op_riscv_SubSP;
}

/**
 * construct SubSP node
 */
ir_node *new_bd_riscv_SubSP(dbg_info *dbgi, ir_node *block, ir_node *mem, ir_node *stack, ir_node *size);

extern ir_op *op_riscv_SubSPimm;

static inline bool is_riscv_SubSPimm(ir_node const *const n)
{
	return get_irn_op(n) == op_riscv_SubSPimm;
}

/**
 * construct SubSPimm node
 */
ir_node *new_bd_riscv_SubSPimm(dbg_info *dbgi, ir_node *block, ir_node *mem, ir_node *stack, ir_entity *ent, int32_t val);

extern ir_op *op_riscv_add;

static inline bool is_riscv_add(ir_node const *const n)
{
	return get_irn_op(n) == op_riscv_add;
}

/**
 * construct add node
 */
ir_node *new_bd_riscv_add(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right);

extern ir_op *op_riscv_addi;

static inline bool is_riscv_addi(ir_node const *const n)
{
	return get_irn_op(n) == op_riscv_addi;
}

/**
 * construct addi node
 */
ir_node *new_bd_riscv_addi(dbg_info *dbgi, ir_node *block, ir_node *left, ir_entity *const ent, int32_t const val);

extern ir_op *op_riscv_and;

static inline bool is_riscv_and(ir_node const *const n)
{
	return get_irn_op(n) == op_riscv_and;
}

/**
 * construct and node
 */
ir_node *new_bd_riscv_and(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right);

extern ir_op *op_riscv_andi;

static inline bool is_riscv_andi(ir_node const *const n)
{
	return get_irn_op(n) == op_riscv_andi;
}

/**
 * construct andi node
 */
ir_node *new_bd_riscv_andi(dbg_info *dbgi, ir_node *block, ir_node *left, ir_entity *const ent, int32_t const val);

extern ir_op *op_riscv_bcc;

static inline bool is_riscv_bcc(ir_node const *const n)
{
	return get_irn_op(n) == op_riscv_bcc;
}

/**
 * construct bcc node
 */
ir_node *new_bd_riscv_bcc(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right, riscv_cond_t const cond);

extern ir_op *op_riscv_div;

static inline bool is_riscv_div(ir_node const *const n)
{
	return get_irn_op(n) == op_riscv_div;
}

/**
 * construct div node
 */
ir_node *new_bd_riscv_div(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right);

extern ir_op *op_riscv_divu;

static inline bool is_riscv_divu(ir_node const *const n)
{
	return get_irn_op(n) == op_riscv_divu;
}

/**
 * construct divu node
 */
ir_node *new_bd_riscv_divu(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right);

extern ir_op *op_riscv_ijmp;

static inline bool is_riscv_ijmp(ir_node const *const n)
{
	return get_irn_op(n) == op_riscv_ijmp;
}

/**
 * construct ijmp node
 */
ir_node *new_bd_riscv_ijmp(dbg_info *dbgi, ir_node *block, ir_node *op0);

extern ir_op *op_riscv_j;

static inline bool is_riscv_j(ir_node const *const n)
{
	return get_irn_op(n) == op_riscv_j;
}

/**
 * construct j node
 */
ir_node *new_bd_riscv_j(dbg_info *dbgi, ir_node *block);

extern ir_op *op_riscv_jal;

static inline bool is_riscv_jal(ir_node const *const n)
{
	return get_irn_op(n) == op_riscv_jal;
}

/**
 * construct jal node
 */
ir_node *new_bd_riscv_jal(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, ir_entity *const ent, int32_t const val);

extern ir_op *op_riscv_jalr;

static inline bool is_riscv_jalr(ir_node const *const n)
{
	return get_irn_op(n) == op_riscv_jalr;
}

/**
 * construct jalr node
 */
ir_node *new_bd_riscv_jalr(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);

extern ir_op *op_riscv_lb;

static inline bool is_riscv_lb(ir_node const *const n)
{
	return get_irn_op(n) == op_riscv_lb;
}

/**
 * construct lb node
 */
ir_node *new_bd_riscv_lb(dbg_info *dbgi, ir_node *block, ir_node *mem, ir_node *base, ir_entity *const ent, int32_t const val);

extern ir_op *op_riscv_lbu;

static inline bool is_riscv_lbu(ir_node const *const n)
{
	return get_irn_op(n) == op_riscv_lbu;
}

/**
 * construct lbu node
 */
ir_node *new_bd_riscv_lbu(dbg_info *dbgi, ir_node *block, ir_node *mem, ir_node *base, ir_entity *const ent, int32_t const val);

extern ir_op *op_riscv_lh;

static inline bool is_riscv_lh(ir_node const *const n)
{
	return get_irn_op(n) == op_riscv_lh;
}

/**
 * construct lh node
 */
ir_node *new_bd_riscv_lh(dbg_info *dbgi, ir_node *block, ir_node *mem, ir_node *base, ir_entity *const ent, int32_t const val);

extern ir_op *op_riscv_lhu;

static inline bool is_riscv_lhu(ir_node const *const n)
{
	return get_irn_op(n) == op_riscv_lhu;
}

/**
 * construct lhu node
 */
ir_node *new_bd_riscv_lhu(dbg_info *dbgi, ir_node *block, ir_node *mem, ir_node *base, ir_entity *const ent, int32_t const val);

extern ir_op *op_riscv_lui;

static inline bool is_riscv_lui(ir_node const *const n)
{
	return get_irn_op(n) == op_riscv_lui;
}

/**
 * construct lui node
 */
ir_node *new_bd_riscv_lui(dbg_info *dbgi, ir_node *block, ir_entity *const ent, int32_t const val);

extern ir_op *op_riscv_lw;

static inline bool is_riscv_lw(ir_node const *const n)
{
	return get_irn_op(n) == op_riscv_lw;
}

/**
 * construct lw node
 */
ir_node *new_bd_riscv_lw(dbg_info *dbgi, ir_node *block, ir_node *mem, ir_node *base, ir_entity *const ent, int32_t const val);

extern ir_op *op_riscv_mul;

static inline bool is_riscv_mul(ir_node const *const n)
{
	return get_irn_op(n) == op_riscv_mul;
}

/**
 * construct mul node
 */
ir_node *new_bd_riscv_mul(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right);

extern ir_op *op_riscv_mulh;

static inline bool is_riscv_mulh(ir_node const *const n)
{
	return get_irn_op(n) == op_riscv_mulh;
}

/**
 * construct mulh node
 */
ir_node *new_bd_riscv_mulh(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right);

extern ir_op *op_riscv_mulhu;

static inline bool is_riscv_mulhu(ir_node const *const n)
{
	return get_irn_op(n) == op_riscv_mulhu;
}

/**
 * construct mulhu node
 */
ir_node *new_bd_riscv_mulhu(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right);

extern ir_op *op_riscv_or;

static inline bool is_riscv_or(ir_node const *const n)
{
	return get_irn_op(n) == op_riscv_or;
}

/**
 * construct or node
 */
ir_node *new_bd_riscv_or(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right);

extern ir_op *op_riscv_ori;

static inline bool is_riscv_ori(ir_node const *const n)
{
	return get_irn_op(n) == op_riscv_ori;
}

/**
 * construct ori node
 */
ir_node *new_bd_riscv_ori(dbg_info *dbgi, ir_node *block, ir_node *left, ir_entity *const ent, int32_t const val);

extern ir_op *op_riscv_rem;

static inline bool is_riscv_rem(ir_node const *const n)
{
	return get_irn_op(n) == op_riscv_rem;
}

/**
 * construct rem node
 */
ir_node *new_bd_riscv_rem(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right);

extern ir_op *op_riscv_remu;

static inline bool is_riscv_remu(ir_node const *const n)
{
	return get_irn_op(n) == op_riscv_remu;
}

/**
 * construct remu node
 */
ir_node *new_bd_riscv_remu(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right);

extern ir_op *op_riscv_ret;

static inline bool is_riscv_ret(ir_node const *const n)
{
	return get_irn_op(n) == op_riscv_ret;
}

/**
 * construct ret node
 */
ir_node *new_bd_riscv_ret(dbg_info *dbgi, ir_node *block, int const arity, ir_node *const *const in, arch_register_req_t const **const in_reqs);

extern ir_op *op_riscv_sb;

static inline bool is_riscv_sb(ir_node const *const n)
{
	return get_irn_op(n) == op_riscv_sb;
}

/**
 * construct sb node
 */
ir_node *new_bd_riscv_sb(dbg_info *dbgi, ir_node *block, ir_node *mem, ir_node *base, ir_node *value, ir_entity *const ent, int32_t const val);

extern ir_op *op_riscv_sh;

static inline bool is_riscv_sh(ir_node const *const n)
{
	return get_irn_op(n) == op_riscv_sh;
}

/**
 * construct sh node
 */
ir_node *new_bd_riscv_sh(dbg_info *dbgi, ir_node *block, ir_node *mem, ir_node *base, ir_node *value, ir_entity *const ent, int32_t const val);

extern ir_op *op_riscv_sll;

static inline bool is_riscv_sll(ir_node const *const n)
{
	return get_irn_op(n) == op_riscv_sll;
}

/**
 * construct sll node
 */
ir_node *new_bd_riscv_sll(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right);

extern ir_op *op_riscv_slli;

static inline bool is_riscv_slli(ir_node const *const n)
{
	return get_irn_op(n) == op_riscv_slli;
}

/**
 * construct slli node
 */
ir_node *new_bd_riscv_slli(dbg_info *dbgi, ir_node *block, ir_node *left, ir_entity *const ent, int32_t const val);

extern ir_op *op_riscv_slt;

static inline bool is_riscv_slt(ir_node const *const n)
{
	return get_irn_op(n) == op_riscv_slt;
}

/**
 * construct slt node
 */
ir_node *new_bd_riscv_slt(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right);

extern ir_op *op_riscv_sltiu;

static inline bool is_riscv_sltiu(ir_node const *const n)
{
	return get_irn_op(n) == op_riscv_sltiu;
}

/**
 * construct sltiu node
 */
ir_node *new_bd_riscv_sltiu(dbg_info *dbgi, ir_node *block, ir_node *left, ir_entity *const ent, int32_t const val);

extern ir_op *op_riscv_sltu;

static inline bool is_riscv_sltu(ir_node const *const n)
{
	return get_irn_op(n) == op_riscv_sltu;
}

/**
 * construct sltu node
 */
ir_node *new_bd_riscv_sltu(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right);

extern ir_op *op_riscv_sra;

static inline bool is_riscv_sra(ir_node const *const n)
{
	return get_irn_op(n) == op_riscv_sra;
}

/**
 * construct sra node
 */
ir_node *new_bd_riscv_sra(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right);

extern ir_op *op_riscv_srai;

static inline bool is_riscv_srai(ir_node const *const n)
{
	return get_irn_op(n) == op_riscv_srai;
}

/**
 * construct srai node
 */
ir_node *new_bd_riscv_srai(dbg_info *dbgi, ir_node *block, ir_node *left, ir_entity *const ent, int32_t const val);

extern ir_op *op_riscv_srl;

static inline bool is_riscv_srl(ir_node const *const n)
{
	return get_irn_op(n) == op_riscv_srl;
}

/**
 * construct srl node
 */
ir_node *new_bd_riscv_srl(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right);

extern ir_op *op_riscv_srli;

static inline bool is_riscv_srli(ir_node const *const n)
{
	return get_irn_op(n) == op_riscv_srli;
}

/**
 * construct srli node
 */
ir_node *new_bd_riscv_srli(dbg_info *dbgi, ir_node *block, ir_node *left, ir_entity *const ent, int32_t const val);

extern ir_op *op_riscv_sub;

static inline bool is_riscv_sub(ir_node const *const n)
{
	return get_irn_op(n) == op_riscv_sub;
}

/**
 * construct sub node
 */
ir_node *new_bd_riscv_sub(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right);

extern ir_op *op_riscv_sw;

static inline bool is_riscv_sw(ir_node const *const n)
{
	return get_irn_op(n) == op_riscv_sw;
}

/**
 * construct sw node
 */
ir_node *new_bd_riscv_sw(dbg_info *dbgi, ir_node *block, ir_node *mem, ir_node *base, ir_node *value, ir_entity *const ent, int32_t const val);

extern ir_op *op_riscv_switch;

static inline bool is_riscv_switch(ir_node const *const n)
{
	return get_irn_op(n) == op_riscv_switch;
}

/**
 * construct switch node
 */
ir_node *new_bd_riscv_switch(dbg_info *dbgi, ir_node *block, ir_node *op0, int n_res, const ir_switch_table *table, ir_entity *table_entity);

extern ir_op *op_riscv_xor;

static inline bool is_riscv_xor(ir_node const *const n)
{
	return get_irn_op(n) == op_riscv_xor;
}

/**
 * construct xor node
 */
ir_node *new_bd_riscv_xor(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right);

extern ir_op *op_riscv_xori;

static inline bool is_riscv_xori(ir_node const *const n)
{
	return get_irn_op(n) == op_riscv_xori;
}

/**
 * construct xori node
 */
ir_node *new_bd_riscv_xori(dbg_info *dbgi, ir_node *block, ir_node *left, ir_entity *const ent, int32_t const val);


typedef enum n_riscv_FrameAddr {
	n_riscv_FrameAddr_base = 0,
} n_riscv_FrameAddr;

typedef enum pn_riscv_SubSP {
	pn_riscv_SubSP_stack = 0,
	pn_riscv_SubSP_addr = 1,
	pn_riscv_SubSP_M = 2,
} pn_riscv_SubSP;

typedef enum n_riscv_SubSP {
	n_riscv_SubSP_mem = 0,
	n_riscv_SubSP_stack = 1,
	n_riscv_SubSP_size = 2,
} n_riscv_SubSP;

typedef enum pn_riscv_SubSPimm {
	pn_riscv_SubSPimm_stack = 0,
	pn_riscv_SubSPimm_addr = 1,
	pn_riscv_SubSPimm_M = 2,
} pn_riscv_SubSPimm;

typedef enum n_riscv_SubSPimm {
	n_riscv_SubSPimm_mem = 0,
	n_riscv_SubSPimm_stack = 1,
} n_riscv_SubSPimm;

typedef enum pn_riscv_add {
	pn_riscv_add_res = 0,
} pn_riscv_add;

typedef enum n_riscv_add {
	n_riscv_add_left = 0,
	n_riscv_add_right = 1,
} n_riscv_add;

typedef enum pn_riscv_addi {
	pn_riscv_addi_res = 0,
} pn_riscv_addi;

typedef enum n_riscv_addi {
	n_riscv_addi_left = 0,
} n_riscv_addi;

typedef enum pn_riscv_and {
	pn_riscv_and_res = 0,
} pn_riscv_and;

typedef enum n_riscv_and {
	n_riscv_and_left = 0,
	n_riscv_and_right = 1,
} n_riscv_and;

typedef enum pn_riscv_andi {
	pn_riscv_andi_res = 0,
} pn_riscv_andi;

typedef enum n_riscv_andi {
	n_riscv_andi_left = 0,
} n_riscv_andi;

typedef enum pn_riscv_bcc {
	pn_riscv_bcc_false = 0,
	pn_riscv_bcc_true = 1,
} pn_riscv_bcc;

typedef enum n_riscv_bcc {
	n_riscv_bcc_left = 0,
	n_riscv_bcc_right = 1,
} n_riscv_bcc;

typedef enum pn_riscv_div {
	pn_riscv_div_res = 0,
} pn_riscv_div;

typedef enum n_riscv_div {
	n_riscv_div_left = 0,
	n_riscv_div_right = 1,
} n_riscv_div;

typedef enum pn_riscv_divu {
	pn_riscv_divu_res = 0,
} pn_riscv_divu;

typedef enum n_riscv_divu {
	n_riscv_divu_left = 0,
	n_riscv_divu_right = 1,
} n_riscv_divu;

typedef enum pn_riscv_jal {
	pn_riscv_jal_M = 0,
	pn_riscv_jal_stack = 1,
	pn_riscv_jal_first_result = 2,
} pn_riscv_jal;

typedef enum n_riscv_jal {
	n_riscv_jal_mem = 0,
	n_riscv_jal_stack = 1,
	n_riscv_jal_first_argument = 2,
} n_riscv_jal;

typedef enum pn_riscv_jalr {
	pn_riscv_jalr_M = 0,
	pn_riscv_jalr_stack = 1,
	pn_riscv_jalr_first_result = 2,
} pn_riscv_jalr;

typedef enum n_riscv_jalr {
	n_riscv_jalr_mem = 0,
	n_riscv_jalr_stack = 1,
	n_riscv_jalr_first_argument = 2,
} n_riscv_jalr;

typedef enum pn_riscv_lb {
	pn_riscv_lb_M = 0,
	pn_riscv_lb_res = 1,
} pn_riscv_lb;

typedef enum n_riscv_lb {
	n_riscv_lb_mem = 0,
	n_riscv_lb_base = 1,
} n_riscv_lb;

typedef enum pn_riscv_lbu {
	pn_riscv_lbu_M = 0,
	pn_riscv_lbu_res = 1,
} pn_riscv_lbu;

typedef enum n_riscv_lbu {
	n_riscv_lbu_mem = 0,
	n_riscv_lbu_base = 1,
} n_riscv_lbu;

typedef enum pn_riscv_lh {
	pn_riscv_lh_M = 0,
	pn_riscv_lh_res = 1,
} pn_riscv_lh;

typedef enum n_riscv_lh {
	n_riscv_lh_mem = 0,
	n_riscv_lh_base = 1,
} n_riscv_lh;

typedef enum pn_riscv_lhu {
	pn_riscv_lhu_M = 0,
	pn_riscv_lhu_res = 1,
} pn_riscv_lhu;

typedef enum n_riscv_lhu {
	n_riscv_lhu_mem = 0,
	n_riscv_lhu_base = 1,
} n_riscv_lhu;

typedef enum pn_riscv_lui {
	pn_riscv_lui_res = 0,
} pn_riscv_lui;

typedef enum pn_riscv_lw {
	pn_riscv_lw_M = 0,
	pn_riscv_lw_res = 1,
} pn_riscv_lw;

typedef enum n_riscv_lw {
	n_riscv_lw_mem = 0,
	n_riscv_lw_base = 1,
} n_riscv_lw;

typedef enum pn_riscv_mul {
	pn_riscv_mul_res = 0,
} pn_riscv_mul;

typedef enum n_riscv_mul {
	n_riscv_mul_left = 0,
	n_riscv_mul_right = 1,
} n_riscv_mul;

typedef enum pn_riscv_mulh {
	pn_riscv_mulh_res = 0,
} pn_riscv_mulh;

typedef enum n_riscv_mulh {
	n_riscv_mulh_left = 0,
	n_riscv_mulh_right = 1,
} n_riscv_mulh;

typedef enum pn_riscv_mulhu {
	pn_riscv_mulhu_res = 0,
} pn_riscv_mulhu;

typedef enum n_riscv_mulhu {
	n_riscv_mulhu_left = 0,
	n_riscv_mulhu_right = 1,
} n_riscv_mulhu;

typedef enum pn_riscv_or {
	pn_riscv_or_res = 0,
} pn_riscv_or;

typedef enum n_riscv_or {
	n_riscv_or_left = 0,
	n_riscv_or_right = 1,
} n_riscv_or;

typedef enum pn_riscv_ori {
	pn_riscv_ori_res = 0,
} pn_riscv_ori;

typedef enum n_riscv_ori {
	n_riscv_ori_left = 0,
} n_riscv_ori;

typedef enum pn_riscv_rem {
	pn_riscv_rem_res = 0,
} pn_riscv_rem;

typedef enum n_riscv_rem {
	n_riscv_rem_left = 0,
	n_riscv_rem_right = 1,
} n_riscv_rem;

typedef enum pn_riscv_remu {
	pn_riscv_remu_res = 0,
} pn_riscv_remu;

typedef enum n_riscv_remu {
	n_riscv_remu_left = 0,
	n_riscv_remu_right = 1,
} n_riscv_remu;

typedef enum n_riscv_ret {
	n_riscv_ret_mem = 0,
	n_riscv_ret_stack = 1,
	n_riscv_ret_addr = 2,
	n_riscv_ret_first_result = 3,
} n_riscv_ret;

typedef enum pn_riscv_sb {
	pn_riscv_sb_M = 0,
} pn_riscv_sb;

typedef enum n_riscv_sb {
	n_riscv_sb_mem = 0,
	n_riscv_sb_base = 1,
	n_riscv_sb_value = 2,
} n_riscv_sb;

typedef enum pn_riscv_sh {
	pn_riscv_sh_M = 0,
} pn_riscv_sh;

typedef enum n_riscv_sh {
	n_riscv_sh_mem = 0,
	n_riscv_sh_base = 1,
	n_riscv_sh_value = 2,
} n_riscv_sh;

typedef enum pn_riscv_sll {
	pn_riscv_sll_res = 0,
} pn_riscv_sll;

typedef enum n_riscv_sll {
	n_riscv_sll_left = 0,
	n_riscv_sll_right = 1,
} n_riscv_sll;

typedef enum pn_riscv_slli {
	pn_riscv_slli_res = 0,
} pn_riscv_slli;

typedef enum n_riscv_slli {
	n_riscv_slli_left = 0,
} n_riscv_slli;

typedef enum pn_riscv_slt {
	pn_riscv_slt_res = 0,
} pn_riscv_slt;

typedef enum n_riscv_slt {
	n_riscv_slt_left = 0,
	n_riscv_slt_right = 1,
} n_riscv_slt;

typedef enum pn_riscv_sltiu {
	pn_riscv_sltiu_res = 0,
} pn_riscv_sltiu;

typedef enum n_riscv_sltiu {
	n_riscv_sltiu_left = 0,
} n_riscv_sltiu;

typedef enum pn_riscv_sltu {
	pn_riscv_sltu_res = 0,
} pn_riscv_sltu;

typedef enum n_riscv_sltu {
	n_riscv_sltu_left = 0,
	n_riscv_sltu_right = 1,
} n_riscv_sltu;

typedef enum pn_riscv_sra {
	pn_riscv_sra_res = 0,
} pn_riscv_sra;

typedef enum n_riscv_sra {
	n_riscv_sra_left = 0,
	n_riscv_sra_right = 1,
} n_riscv_sra;

typedef enum pn_riscv_srai {
	pn_riscv_srai_res = 0,
} pn_riscv_srai;

typedef enum n_riscv_srai {
	n_riscv_srai_left = 0,
} n_riscv_srai;

typedef enum pn_riscv_srl {
	pn_riscv_srl_res = 0,
} pn_riscv_srl;

typedef enum n_riscv_srl {
	n_riscv_srl_left = 0,
	n_riscv_srl_right = 1,
} n_riscv_srl;

typedef enum pn_riscv_srli {
	pn_riscv_srli_res = 0,
} pn_riscv_srli;

typedef enum n_riscv_srli {
	n_riscv_srli_left = 0,
} n_riscv_srli;

typedef enum pn_riscv_sub {
	pn_riscv_sub_res = 0,
} pn_riscv_sub;

typedef enum n_riscv_sub {
	n_riscv_sub_left = 0,
	n_riscv_sub_right = 1,
} n_riscv_sub;

typedef enum pn_riscv_sw {
	pn_riscv_sw_M = 0,
} pn_riscv_sw;

typedef enum n_riscv_sw {
	n_riscv_sw_mem = 0,
	n_riscv_sw_base = 1,
	n_riscv_sw_value = 2,
} n_riscv_sw;

typedef enum pn_riscv_xor {
	pn_riscv_xor_res = 0,
} pn_riscv_xor;

typedef enum n_riscv_xor {
	n_riscv_xor_left = 0,
	n_riscv_xor_right = 1,
} n_riscv_xor;

typedef enum pn_riscv_xori {
	pn_riscv_xori_res = 0,
} pn_riscv_xori;

typedef enum n_riscv_xori {
	n_riscv_xori_left = 0,
} n_riscv_xori;


#endif
