/* Warning: automatically generated code */

int (is_ASM)(const ir_node *node)
{
	return is_ASM_(node);
}

int (is_Add)(const ir_node *node)
{
	return is_Add_(node);
}

int (is_Alloc)(const ir_node *node)
{
	return is_Alloc_(node);
}

int (is_Anchor)(const ir_node *node)
{
	return is_Anchor_(node);
}

int (is_And)(const ir_node *node)
{
	return is_And_(node);
}

int (is_Bad)(const ir_node *node)
{
	return is_Bad_(node);
}

int (is_Block)(const ir_node *node)
{
	return is_Block_(node);
}

int (is_Borrow)(const ir_node *node)
{
	return is_Borrow_(node);
}

int (is_Bound)(const ir_node *node)
{
	return is_Bound_(node);
}

int (is_Builtin)(const ir_node *node)
{
	return is_Builtin_(node);
}

int (is_Call)(const ir_node *node)
{
	return is_Call_(node);
}

int (is_Carry)(const ir_node *node)
{
	return is_Carry_(node);
}

int (is_Cast)(const ir_node *node)
{
	return is_Cast_(node);
}

int (is_Cmp)(const ir_node *node)
{
	return is_Cmp_(node);
}

int (is_Cond)(const ir_node *node)
{
	return is_Cond_(node);
}

int (is_Confirm)(const ir_node *node)
{
	return is_Confirm_(node);
}

int (is_Const)(const ir_node *node)
{
	return is_Const_(node);
}

int (is_Conv)(const ir_node *node)
{
	return is_Conv_(node);
}

int (is_CopyB)(const ir_node *node)
{
	return is_CopyB_(node);
}

int (is_Deleted)(const ir_node *node)
{
	return is_Deleted_(node);
}

int (is_Div)(const ir_node *node)
{
	return is_Div_(node);
}

int (is_Dummy)(const ir_node *node)
{
	return is_Dummy_(node);
}

int (is_End)(const ir_node *node)
{
	return is_End_(node);
}

int (is_Eor)(const ir_node *node)
{
	return is_Eor_(node);
}

int (is_Free)(const ir_node *node)
{
	return is_Free_(node);
}

int (is_IJmp)(const ir_node *node)
{
	return is_IJmp_(node);
}

int (is_Id)(const ir_node *node)
{
	return is_Id_(node);
}

int (is_InstOf)(const ir_node *node)
{
	return is_InstOf_(node);
}

int (is_Jmp)(const ir_node *node)
{
	return is_Jmp_(node);
}

int (is_Load)(const ir_node *node)
{
	return is_Load_(node);
}

int (is_Minus)(const ir_node *node)
{
	return is_Minus_(node);
}

int (is_Mod)(const ir_node *node)
{
	return is_Mod_(node);
}

int (is_Mul)(const ir_node *node)
{
	return is_Mul_(node);
}

int (is_Mulh)(const ir_node *node)
{
	return is_Mulh_(node);
}

int (is_Mux)(const ir_node *node)
{
	return is_Mux_(node);
}

int (is_NoMem)(const ir_node *node)
{
	return is_NoMem_(node);
}

int (is_Not)(const ir_node *node)
{
	return is_Not_(node);
}

int (is_Or)(const ir_node *node)
{
	return is_Or_(node);
}

int (is_Phi)(const ir_node *node)
{
	return is_Phi_(node);
}

int (is_Pin)(const ir_node *node)
{
	return is_Pin_(node);
}

int (is_Proj)(const ir_node *node)
{
	return is_Proj_(node);
}

int (is_Raise)(const ir_node *node)
{
	return is_Raise_(node);
}

int (is_Return)(const ir_node *node)
{
	return is_Return_(node);
}

int (is_Rotl)(const ir_node *node)
{
	return is_Rotl_(node);
}

int (is_Sel)(const ir_node *node)
{
	return is_Sel_(node);
}

int (is_Shl)(const ir_node *node)
{
	return is_Shl_(node);
}

int (is_Shr)(const ir_node *node)
{
	return is_Shr_(node);
}

int (is_Shrs)(const ir_node *node)
{
	return is_Shrs_(node);
}

int (is_Start)(const ir_node *node)
{
	return is_Start_(node);
}

int (is_Store)(const ir_node *node)
{
	return is_Store_(node);
}

int (is_Sub)(const ir_node *node)
{
	return is_Sub_(node);
}

int (is_Switch)(const ir_node *node)
{
	return is_Switch_(node);
}

int (is_SymConst)(const ir_node *node)
{
	return is_SymConst_(node);
}

int (is_Sync)(const ir_node *node)
{
	return is_Sync_(node);
}

int (is_Tuple)(const ir_node *node)
{
	return is_Tuple_(node);
}

int (is_Unknown)(const ir_node *node)
{
	return is_Unknown_(node);
}

ir_asm_constraint* (get_ASM_input_constraints)(const ir_node *node)
{
	assert(is_ASM(node));
	return node->attr.assem.input_constraints;
}

void (set_ASM_input_constraints)(ir_node *node, ir_asm_constraint* input_constraints)
{
	assert(is_ASM(node));
	node->attr.assem.input_constraints = input_constraints;
}

ir_asm_constraint* (get_ASM_output_constraints)(const ir_node *node)
{
	assert(is_ASM(node));
	return node->attr.assem.output_constraints;
}

void (set_ASM_output_constraints)(ir_node *node, ir_asm_constraint* output_constraints)
{
	assert(is_ASM(node));
	node->attr.assem.output_constraints = output_constraints;
}

ident** (get_ASM_clobbers)(const ir_node *node)
{
	assert(is_ASM(node));
	return node->attr.assem.clobbers;
}

void (set_ASM_clobbers)(ir_node *node, ident** clobbers)
{
	assert(is_ASM(node));
	node->attr.assem.clobbers = clobbers;
}

ident* (get_ASM_text)(const ir_node *node)
{
	assert(is_ASM(node));
	return node->attr.assem.text;
}

void (set_ASM_text)(ir_node *node, ident* text)
{
	assert(is_ASM(node));
	node->attr.assem.text = text;
}

ir_type* (get_Alloc_type)(const ir_node *node)
{
	assert(is_Alloc(node));
	return node->attr.alloc.type;
}

void (set_Alloc_type)(ir_node *node, ir_type* type)
{
	assert(is_Alloc(node));
	node->attr.alloc.type = type;
}

ir_where_alloc (get_Alloc_where)(const ir_node *node)
{
	assert(is_Alloc(node));
	return node->attr.alloc.where;
}

void (set_Alloc_where)(ir_node *node, ir_where_alloc where)
{
	assert(is_Alloc(node));
	node->attr.alloc.where = where;
}

ir_entity* (get_Block_entity)(const ir_node *node)
{
	assert(is_Block(node));
	return node->attr.block.entity;
}

void (set_Block_entity)(ir_node *node, ir_entity* entity)
{
	assert(is_Block(node));
	node->attr.block.entity = entity;
}

ir_builtin_kind (get_Builtin_kind)(const ir_node *node)
{
	assert(is_Builtin(node));
	return node->attr.builtin.kind;
}

void (set_Builtin_kind)(ir_node *node, ir_builtin_kind kind)
{
	assert(is_Builtin(node));
	node->attr.builtin.kind = kind;
}

ir_type* (get_Builtin_type)(const ir_node *node)
{
	assert(is_Builtin(node));
	return node->attr.builtin.type;
}

void (set_Builtin_type)(ir_node *node, ir_type* type)
{
	assert(is_Builtin(node));
	node->attr.builtin.type = type;
}

ir_type* (get_Call_type)(const ir_node *node)
{
	assert(is_Call(node));
	return node->attr.call.type;
}

void (set_Call_type)(ir_node *node, ir_type* type)
{
	assert(is_Call(node));
	node->attr.call.type = type;
}

ir_type* (get_Cast_type)(const ir_node *node)
{
	assert(is_Cast(node));
	return node->attr.cast.type;
}

void (set_Cast_type)(ir_node *node, ir_type* type)
{
	assert(is_Cast(node));
	node->attr.cast.type = type;
}

ir_relation (get_Cmp_relation)(const ir_node *node)
{
	assert(is_Cmp(node));
	return node->attr.cmp.relation;
}

void (set_Cmp_relation)(ir_node *node, ir_relation relation)
{
	assert(is_Cmp(node));
	node->attr.cmp.relation = relation;
}

cond_jmp_predicate (get_Cond_jmp_pred)(const ir_node *node)
{
	assert(is_Cond(node));
	return node->attr.cond.jmp_pred;
}

void (set_Cond_jmp_pred)(ir_node *node, cond_jmp_predicate jmp_pred)
{
	assert(is_Cond(node));
	node->attr.cond.jmp_pred = jmp_pred;
}

ir_relation (get_Confirm_relation)(const ir_node *node)
{
	assert(is_Confirm(node));
	return node->attr.confirm.relation;
}

void (set_Confirm_relation)(ir_node *node, ir_relation relation)
{
	assert(is_Confirm(node));
	node->attr.confirm.relation = relation;
}

ir_tarval* (get_Const_tarval)(const ir_node *node)
{
	assert(is_Const(node));
	return node->attr.con.tarval;
}

void (set_Const_tarval)(ir_node *node, ir_tarval* tarval)
{
	assert(is_Const(node));
	node->attr.con.tarval = tarval;
}

ir_type* (get_CopyB_type)(const ir_node *node)
{
	assert(is_CopyB(node));
	return node->attr.copyb.type;
}

void (set_CopyB_type)(ir_node *node, ir_type* type)
{
	assert(is_CopyB(node));
	node->attr.copyb.type = type;
}

ir_mode* (get_Div_resmode)(const ir_node *node)
{
	assert(is_Div(node));
	return node->attr.div.resmode;
}

void (set_Div_resmode)(ir_node *node, ir_mode* resmode)
{
	assert(is_Div(node));
	node->attr.div.resmode = resmode;
}

int (get_Div_no_remainder)(const ir_node *node)
{
	assert(is_Div(node));
	return node->attr.div.no_remainder;
}

void (set_Div_no_remainder)(ir_node *node, int no_remainder)
{
	assert(is_Div(node));
	node->attr.div.no_remainder = no_remainder;
}

ir_type* (get_Free_type)(const ir_node *node)
{
	assert(is_Free(node));
	return node->attr.free.type;
}

void (set_Free_type)(ir_node *node, ir_type* type)
{
	assert(is_Free(node));
	node->attr.free.type = type;
}

ir_where_alloc (get_Free_where)(const ir_node *node)
{
	assert(is_Free(node));
	return node->attr.free.where;
}

void (set_Free_where)(ir_node *node, ir_where_alloc where)
{
	assert(is_Free(node));
	node->attr.free.where = where;
}

ir_type* (get_InstOf_type)(const ir_node *node)
{
	assert(is_InstOf(node));
	return node->attr.instof.type;
}

void (set_InstOf_type)(ir_node *node, ir_type* type)
{
	assert(is_InstOf(node));
	node->attr.instof.type = type;
}

ir_mode* (get_Load_mode)(const ir_node *node)
{
	assert(is_Load(node));
	return node->attr.load.mode;
}

void (set_Load_mode)(ir_node *node, ir_mode* mode)
{
	assert(is_Load(node));
	node->attr.load.mode = mode;
}

ir_volatility (get_Load_volatility)(const ir_node *node)
{
	assert(is_Load(node));
	return node->attr.load.volatility;
}

void (set_Load_volatility)(ir_node *node, ir_volatility volatility)
{
	assert(is_Load(node));
	node->attr.load.volatility = volatility;
}

ir_align (get_Load_unaligned)(const ir_node *node)
{
	assert(is_Load(node));
	return node->attr.load.unaligned;
}

void (set_Load_unaligned)(ir_node *node, ir_align unaligned)
{
	assert(is_Load(node));
	node->attr.load.unaligned = unaligned;
}

ir_mode* (get_Mod_resmode)(const ir_node *node)
{
	assert(is_Mod(node));
	return node->attr.mod.resmode;
}

void (set_Mod_resmode)(ir_node *node, ir_mode* resmode)
{
	assert(is_Mod(node));
	node->attr.mod.resmode = resmode;
}

long (get_Proj_proj)(const ir_node *node)
{
	assert(is_Proj(node));
	return node->attr.proj.proj;
}

void (set_Proj_proj)(ir_node *node, long proj)
{
	assert(is_Proj(node));
	node->attr.proj.proj = proj;
}

ir_entity* (get_Sel_entity)(const ir_node *node)
{
	assert(is_Sel(node));
	return node->attr.sel.entity;
}

void (set_Sel_entity)(ir_node *node, ir_entity* entity)
{
	assert(is_Sel(node));
	node->attr.sel.entity = entity;
}

ir_volatility (get_Store_volatility)(const ir_node *node)
{
	assert(is_Store(node));
	return node->attr.store.volatility;
}

void (set_Store_volatility)(ir_node *node, ir_volatility volatility)
{
	assert(is_Store(node));
	node->attr.store.volatility = volatility;
}

ir_align (get_Store_unaligned)(const ir_node *node)
{
	assert(is_Store(node));
	return node->attr.store.unaligned;
}

void (set_Store_unaligned)(ir_node *node, ir_align unaligned)
{
	assert(is_Store(node));
	node->attr.store.unaligned = unaligned;
}

unsigned (get_Switch_n_outs)(const ir_node *node)
{
	assert(is_Switch(node));
	return node->attr.switcha.n_outs;
}

void (set_Switch_n_outs)(ir_node *node, unsigned n_outs)
{
	assert(is_Switch(node));
	node->attr.switcha.n_outs = n_outs;
}

ir_switch_table* (get_Switch_table)(const ir_node *node)
{
	assert(is_Switch(node));
	return node->attr.switcha.table;
}

void (set_Switch_table)(ir_node *node, ir_switch_table* table)
{
	assert(is_Switch(node));
	node->attr.switcha.table = table;
}

ir_node *(get_ASM_mem)(const ir_node *node)
{
	assert(is_ASM(node));
	return get_irn_n(node, n_ASM_mem);
}

void (set_ASM_mem)(ir_node *node, ir_node *mem)
{
	assert(is_ASM(node));
	set_irn_n(node, n_ASM_mem, mem);
}


ir_node *(get_Add_left)(const ir_node *node)
{
	assert(is_Add(node));
	return get_irn_n(node, n_Add_left);
}

void (set_Add_left)(ir_node *node, ir_node *left)
{
	assert(is_Add(node));
	set_irn_n(node, n_Add_left, left);
}

ir_node *(get_Add_right)(const ir_node *node)
{
	assert(is_Add(node));
	return get_irn_n(node, n_Add_right);
}

void (set_Add_right)(ir_node *node, ir_node *right)
{
	assert(is_Add(node));
	set_irn_n(node, n_Add_right, right);
}


ir_node *(get_Alloc_mem)(const ir_node *node)
{
	assert(is_Alloc(node));
	return get_irn_n(node, n_Alloc_mem);
}

void (set_Alloc_mem)(ir_node *node, ir_node *mem)
{
	assert(is_Alloc(node));
	set_irn_n(node, n_Alloc_mem, mem);
}

ir_node *(get_Alloc_count)(const ir_node *node)
{
	assert(is_Alloc(node));
	return get_irn_n(node, n_Alloc_count);
}

void (set_Alloc_count)(ir_node *node, ir_node *count)
{
	assert(is_Alloc(node));
	set_irn_n(node, n_Alloc_count, count);
}



ir_node *(get_And_left)(const ir_node *node)
{
	assert(is_And(node));
	return get_irn_n(node, n_And_left);
}

void (set_And_left)(ir_node *node, ir_node *left)
{
	assert(is_And(node));
	set_irn_n(node, n_And_left, left);
}

ir_node *(get_And_right)(const ir_node *node)
{
	assert(is_And(node));
	return get_irn_n(node, n_And_right);
}

void (set_And_right)(ir_node *node, ir_node *right)
{
	assert(is_And(node));
	set_irn_n(node, n_And_right, right);
}




ir_node *(get_Borrow_left)(const ir_node *node)
{
	assert(is_Borrow(node));
	return get_irn_n(node, n_Borrow_left);
}

void (set_Borrow_left)(ir_node *node, ir_node *left)
{
	assert(is_Borrow(node));
	set_irn_n(node, n_Borrow_left, left);
}

ir_node *(get_Borrow_right)(const ir_node *node)
{
	assert(is_Borrow(node));
	return get_irn_n(node, n_Borrow_right);
}

void (set_Borrow_right)(ir_node *node, ir_node *right)
{
	assert(is_Borrow(node));
	set_irn_n(node, n_Borrow_right, right);
}


ir_node *(get_Bound_mem)(const ir_node *node)
{
	assert(is_Bound(node));
	return get_irn_n(node, n_Bound_mem);
}

void (set_Bound_mem)(ir_node *node, ir_node *mem)
{
	assert(is_Bound(node));
	set_irn_n(node, n_Bound_mem, mem);
}

ir_node *(get_Bound_index)(const ir_node *node)
{
	assert(is_Bound(node));
	return get_irn_n(node, n_Bound_index);
}

void (set_Bound_index)(ir_node *node, ir_node *index)
{
	assert(is_Bound(node));
	set_irn_n(node, n_Bound_index, index);
}

ir_node *(get_Bound_lower)(const ir_node *node)
{
	assert(is_Bound(node));
	return get_irn_n(node, n_Bound_lower);
}

void (set_Bound_lower)(ir_node *node, ir_node *lower)
{
	assert(is_Bound(node));
	set_irn_n(node, n_Bound_lower, lower);
}

ir_node *(get_Bound_upper)(const ir_node *node)
{
	assert(is_Bound(node));
	return get_irn_n(node, n_Bound_upper);
}

void (set_Bound_upper)(ir_node *node, ir_node *upper)
{
	assert(is_Bound(node));
	set_irn_n(node, n_Bound_upper, upper);
}


ir_node *(get_Builtin_mem)(const ir_node *node)
{
	assert(is_Builtin(node));
	return get_irn_n(node, n_Builtin_mem);
}

void (set_Builtin_mem)(ir_node *node, ir_node *mem)
{
	assert(is_Builtin(node));
	set_irn_n(node, n_Builtin_mem, mem);
}


ir_node *(get_Call_mem)(const ir_node *node)
{
	assert(is_Call(node));
	return get_irn_n(node, n_Call_mem);
}

void (set_Call_mem)(ir_node *node, ir_node *mem)
{
	assert(is_Call(node));
	set_irn_n(node, n_Call_mem, mem);
}

ir_node *(get_Call_ptr)(const ir_node *node)
{
	assert(is_Call(node));
	return get_irn_n(node, n_Call_ptr);
}

void (set_Call_ptr)(ir_node *node, ir_node *ptr)
{
	assert(is_Call(node));
	set_irn_n(node, n_Call_ptr, ptr);
}


ir_node *(get_Carry_left)(const ir_node *node)
{
	assert(is_Carry(node));
	return get_irn_n(node, n_Carry_left);
}

void (set_Carry_left)(ir_node *node, ir_node *left)
{
	assert(is_Carry(node));
	set_irn_n(node, n_Carry_left, left);
}

ir_node *(get_Carry_right)(const ir_node *node)
{
	assert(is_Carry(node));
	return get_irn_n(node, n_Carry_right);
}

void (set_Carry_right)(ir_node *node, ir_node *right)
{
	assert(is_Carry(node));
	set_irn_n(node, n_Carry_right, right);
}


ir_node *(get_Cast_op)(const ir_node *node)
{
	assert(is_Cast(node));
	return get_irn_n(node, n_Cast_op);
}

void (set_Cast_op)(ir_node *node, ir_node *op)
{
	assert(is_Cast(node));
	set_irn_n(node, n_Cast_op, op);
}


ir_node *(get_Cmp_left)(const ir_node *node)
{
	assert(is_Cmp(node));
	return get_irn_n(node, n_Cmp_left);
}

void (set_Cmp_left)(ir_node *node, ir_node *left)
{
	assert(is_Cmp(node));
	set_irn_n(node, n_Cmp_left, left);
}

ir_node *(get_Cmp_right)(const ir_node *node)
{
	assert(is_Cmp(node));
	return get_irn_n(node, n_Cmp_right);
}

void (set_Cmp_right)(ir_node *node, ir_node *right)
{
	assert(is_Cmp(node));
	set_irn_n(node, n_Cmp_right, right);
}


ir_node *(get_Cond_selector)(const ir_node *node)
{
	assert(is_Cond(node));
	return get_irn_n(node, n_Cond_selector);
}

void (set_Cond_selector)(ir_node *node, ir_node *selector)
{
	assert(is_Cond(node));
	set_irn_n(node, n_Cond_selector, selector);
}


ir_node *(get_Confirm_value)(const ir_node *node)
{
	assert(is_Confirm(node));
	return get_irn_n(node, n_Confirm_value);
}

void (set_Confirm_value)(ir_node *node, ir_node *value)
{
	assert(is_Confirm(node));
	set_irn_n(node, n_Confirm_value, value);
}

ir_node *(get_Confirm_bound)(const ir_node *node)
{
	assert(is_Confirm(node));
	return get_irn_n(node, n_Confirm_bound);
}

void (set_Confirm_bound)(ir_node *node, ir_node *bound)
{
	assert(is_Confirm(node));
	set_irn_n(node, n_Confirm_bound, bound);
}



ir_node *(get_Conv_op)(const ir_node *node)
{
	assert(is_Conv(node));
	return get_irn_n(node, n_Conv_op);
}

void (set_Conv_op)(ir_node *node, ir_node *op)
{
	assert(is_Conv(node));
	set_irn_n(node, n_Conv_op, op);
}


ir_node *(get_CopyB_mem)(const ir_node *node)
{
	assert(is_CopyB(node));
	return get_irn_n(node, n_CopyB_mem);
}

void (set_CopyB_mem)(ir_node *node, ir_node *mem)
{
	assert(is_CopyB(node));
	set_irn_n(node, n_CopyB_mem, mem);
}

ir_node *(get_CopyB_dst)(const ir_node *node)
{
	assert(is_CopyB(node));
	return get_irn_n(node, n_CopyB_dst);
}

void (set_CopyB_dst)(ir_node *node, ir_node *dst)
{
	assert(is_CopyB(node));
	set_irn_n(node, n_CopyB_dst, dst);
}

ir_node *(get_CopyB_src)(const ir_node *node)
{
	assert(is_CopyB(node));
	return get_irn_n(node, n_CopyB_src);
}

void (set_CopyB_src)(ir_node *node, ir_node *src)
{
	assert(is_CopyB(node));
	set_irn_n(node, n_CopyB_src, src);
}



ir_node *(get_Div_mem)(const ir_node *node)
{
	assert(is_Div(node));
	return get_irn_n(node, n_Div_mem);
}

void (set_Div_mem)(ir_node *node, ir_node *mem)
{
	assert(is_Div(node));
	set_irn_n(node, n_Div_mem, mem);
}

ir_node *(get_Div_left)(const ir_node *node)
{
	assert(is_Div(node));
	return get_irn_n(node, n_Div_left);
}

void (set_Div_left)(ir_node *node, ir_node *left)
{
	assert(is_Div(node));
	set_irn_n(node, n_Div_left, left);
}

ir_node *(get_Div_right)(const ir_node *node)
{
	assert(is_Div(node));
	return get_irn_n(node, n_Div_right);
}

void (set_Div_right)(ir_node *node, ir_node *right)
{
	assert(is_Div(node));
	set_irn_n(node, n_Div_right, right);
}




ir_node *(get_Eor_left)(const ir_node *node)
{
	assert(is_Eor(node));
	return get_irn_n(node, n_Eor_left);
}

void (set_Eor_left)(ir_node *node, ir_node *left)
{
	assert(is_Eor(node));
	set_irn_n(node, n_Eor_left, left);
}

ir_node *(get_Eor_right)(const ir_node *node)
{
	assert(is_Eor(node));
	return get_irn_n(node, n_Eor_right);
}

void (set_Eor_right)(ir_node *node, ir_node *right)
{
	assert(is_Eor(node));
	set_irn_n(node, n_Eor_right, right);
}


ir_node *(get_Free_mem)(const ir_node *node)
{
	assert(is_Free(node));
	return get_irn_n(node, n_Free_mem);
}

void (set_Free_mem)(ir_node *node, ir_node *mem)
{
	assert(is_Free(node));
	set_irn_n(node, n_Free_mem, mem);
}

ir_node *(get_Free_ptr)(const ir_node *node)
{
	assert(is_Free(node));
	return get_irn_n(node, n_Free_ptr);
}

void (set_Free_ptr)(ir_node *node, ir_node *ptr)
{
	assert(is_Free(node));
	set_irn_n(node, n_Free_ptr, ptr);
}

ir_node *(get_Free_count)(const ir_node *node)
{
	assert(is_Free(node));
	return get_irn_n(node, n_Free_count);
}

void (set_Free_count)(ir_node *node, ir_node *count)
{
	assert(is_Free(node));
	set_irn_n(node, n_Free_count, count);
}


ir_node *(get_IJmp_target)(const ir_node *node)
{
	assert(is_IJmp(node));
	return get_irn_n(node, n_IJmp_target);
}

void (set_IJmp_target)(ir_node *node, ir_node *target)
{
	assert(is_IJmp(node));
	set_irn_n(node, n_IJmp_target, target);
}


ir_node *(get_Id_pred)(const ir_node *node)
{
	assert(is_Id(node));
	return get_irn_n(node, n_Id_pred);
}

void (set_Id_pred)(ir_node *node, ir_node *pred)
{
	assert(is_Id(node));
	set_irn_n(node, n_Id_pred, pred);
}


ir_node *(get_InstOf_store)(const ir_node *node)
{
	assert(is_InstOf(node));
	return get_irn_n(node, n_InstOf_store);
}

void (set_InstOf_store)(ir_node *node, ir_node *store)
{
	assert(is_InstOf(node));
	set_irn_n(node, n_InstOf_store, store);
}

ir_node *(get_InstOf_obj)(const ir_node *node)
{
	assert(is_InstOf(node));
	return get_irn_n(node, n_InstOf_obj);
}

void (set_InstOf_obj)(ir_node *node, ir_node *obj)
{
	assert(is_InstOf(node));
	set_irn_n(node, n_InstOf_obj, obj);
}



ir_node *(get_Load_mem)(const ir_node *node)
{
	assert(is_Load(node));
	return get_irn_n(node, n_Load_mem);
}

void (set_Load_mem)(ir_node *node, ir_node *mem)
{
	assert(is_Load(node));
	set_irn_n(node, n_Load_mem, mem);
}

ir_node *(get_Load_ptr)(const ir_node *node)
{
	assert(is_Load(node));
	return get_irn_n(node, n_Load_ptr);
}

void (set_Load_ptr)(ir_node *node, ir_node *ptr)
{
	assert(is_Load(node));
	set_irn_n(node, n_Load_ptr, ptr);
}


ir_node *(get_Minus_op)(const ir_node *node)
{
	assert(is_Minus(node));
	return get_irn_n(node, n_Minus_op);
}

void (set_Minus_op)(ir_node *node, ir_node *op)
{
	assert(is_Minus(node));
	set_irn_n(node, n_Minus_op, op);
}


ir_node *(get_Mod_mem)(const ir_node *node)
{
	assert(is_Mod(node));
	return get_irn_n(node, n_Mod_mem);
}

void (set_Mod_mem)(ir_node *node, ir_node *mem)
{
	assert(is_Mod(node));
	set_irn_n(node, n_Mod_mem, mem);
}

ir_node *(get_Mod_left)(const ir_node *node)
{
	assert(is_Mod(node));
	return get_irn_n(node, n_Mod_left);
}

void (set_Mod_left)(ir_node *node, ir_node *left)
{
	assert(is_Mod(node));
	set_irn_n(node, n_Mod_left, left);
}

ir_node *(get_Mod_right)(const ir_node *node)
{
	assert(is_Mod(node));
	return get_irn_n(node, n_Mod_right);
}

void (set_Mod_right)(ir_node *node, ir_node *right)
{
	assert(is_Mod(node));
	set_irn_n(node, n_Mod_right, right);
}


ir_node *(get_Mul_left)(const ir_node *node)
{
	assert(is_Mul(node));
	return get_irn_n(node, n_Mul_left);
}

void (set_Mul_left)(ir_node *node, ir_node *left)
{
	assert(is_Mul(node));
	set_irn_n(node, n_Mul_left, left);
}

ir_node *(get_Mul_right)(const ir_node *node)
{
	assert(is_Mul(node));
	return get_irn_n(node, n_Mul_right);
}

void (set_Mul_right)(ir_node *node, ir_node *right)
{
	assert(is_Mul(node));
	set_irn_n(node, n_Mul_right, right);
}


ir_node *(get_Mulh_left)(const ir_node *node)
{
	assert(is_Mulh(node));
	return get_irn_n(node, n_Mulh_left);
}

void (set_Mulh_left)(ir_node *node, ir_node *left)
{
	assert(is_Mulh(node));
	set_irn_n(node, n_Mulh_left, left);
}

ir_node *(get_Mulh_right)(const ir_node *node)
{
	assert(is_Mulh(node));
	return get_irn_n(node, n_Mulh_right);
}

void (set_Mulh_right)(ir_node *node, ir_node *right)
{
	assert(is_Mulh(node));
	set_irn_n(node, n_Mulh_right, right);
}


ir_node *(get_Mux_sel)(const ir_node *node)
{
	assert(is_Mux(node));
	return get_irn_n(node, n_Mux_sel);
}

void (set_Mux_sel)(ir_node *node, ir_node *sel)
{
	assert(is_Mux(node));
	set_irn_n(node, n_Mux_sel, sel);
}

ir_node *(get_Mux_false)(const ir_node *node)
{
	assert(is_Mux(node));
	return get_irn_n(node, n_Mux_false);
}

void (set_Mux_false)(ir_node *node, ir_node *false_)
{
	assert(is_Mux(node));
	set_irn_n(node, n_Mux_false, false_);
}

ir_node *(get_Mux_true)(const ir_node *node)
{
	assert(is_Mux(node));
	return get_irn_n(node, n_Mux_true);
}

void (set_Mux_true)(ir_node *node, ir_node *true_)
{
	assert(is_Mux(node));
	set_irn_n(node, n_Mux_true, true_);
}



ir_node *(get_Not_op)(const ir_node *node)
{
	assert(is_Not(node));
	return get_irn_n(node, n_Not_op);
}

void (set_Not_op)(ir_node *node, ir_node *op)
{
	assert(is_Not(node));
	set_irn_n(node, n_Not_op, op);
}


ir_node *(get_Or_left)(const ir_node *node)
{
	assert(is_Or(node));
	return get_irn_n(node, n_Or_left);
}

void (set_Or_left)(ir_node *node, ir_node *left)
{
	assert(is_Or(node));
	set_irn_n(node, n_Or_left, left);
}

ir_node *(get_Or_right)(const ir_node *node)
{
	assert(is_Or(node));
	return get_irn_n(node, n_Or_right);
}

void (set_Or_right)(ir_node *node, ir_node *right)
{
	assert(is_Or(node));
	set_irn_n(node, n_Or_right, right);
}



ir_node *(get_Pin_op)(const ir_node *node)
{
	assert(is_Pin(node));
	return get_irn_n(node, n_Pin_op);
}

void (set_Pin_op)(ir_node *node, ir_node *op)
{
	assert(is_Pin(node));
	set_irn_n(node, n_Pin_op, op);
}


ir_node *(get_Proj_pred)(const ir_node *node)
{
	assert(is_Proj(node));
	return get_irn_n(node, n_Proj_pred);
}

void (set_Proj_pred)(ir_node *node, ir_node *pred)
{
	assert(is_Proj(node));
	set_irn_n(node, n_Proj_pred, pred);
}


ir_node *(get_Raise_mem)(const ir_node *node)
{
	assert(is_Raise(node));
	return get_irn_n(node, n_Raise_mem);
}

void (set_Raise_mem)(ir_node *node, ir_node *mem)
{
	assert(is_Raise(node));
	set_irn_n(node, n_Raise_mem, mem);
}

ir_node *(get_Raise_exo_ptr)(const ir_node *node)
{
	assert(is_Raise(node));
	return get_irn_n(node, n_Raise_exo_ptr);
}

void (set_Raise_exo_ptr)(ir_node *node, ir_node *exo_ptr)
{
	assert(is_Raise(node));
	set_irn_n(node, n_Raise_exo_ptr, exo_ptr);
}


ir_node *(get_Return_mem)(const ir_node *node)
{
	assert(is_Return(node));
	return get_irn_n(node, n_Return_mem);
}

void (set_Return_mem)(ir_node *node, ir_node *mem)
{
	assert(is_Return(node));
	set_irn_n(node, n_Return_mem, mem);
}


ir_node *(get_Rotl_left)(const ir_node *node)
{
	assert(is_Rotl(node));
	return get_irn_n(node, n_Rotl_left);
}

void (set_Rotl_left)(ir_node *node, ir_node *left)
{
	assert(is_Rotl(node));
	set_irn_n(node, n_Rotl_left, left);
}

ir_node *(get_Rotl_right)(const ir_node *node)
{
	assert(is_Rotl(node));
	return get_irn_n(node, n_Rotl_right);
}

void (set_Rotl_right)(ir_node *node, ir_node *right)
{
	assert(is_Rotl(node));
	set_irn_n(node, n_Rotl_right, right);
}


ir_node *(get_Sel_mem)(const ir_node *node)
{
	assert(is_Sel(node));
	return get_irn_n(node, n_Sel_mem);
}

void (set_Sel_mem)(ir_node *node, ir_node *mem)
{
	assert(is_Sel(node));
	set_irn_n(node, n_Sel_mem, mem);
}

ir_node *(get_Sel_ptr)(const ir_node *node)
{
	assert(is_Sel(node));
	return get_irn_n(node, n_Sel_ptr);
}

void (set_Sel_ptr)(ir_node *node, ir_node *ptr)
{
	assert(is_Sel(node));
	set_irn_n(node, n_Sel_ptr, ptr);
}


ir_node *(get_Shl_left)(const ir_node *node)
{
	assert(is_Shl(node));
	return get_irn_n(node, n_Shl_left);
}

void (set_Shl_left)(ir_node *node, ir_node *left)
{
	assert(is_Shl(node));
	set_irn_n(node, n_Shl_left, left);
}

ir_node *(get_Shl_right)(const ir_node *node)
{
	assert(is_Shl(node));
	return get_irn_n(node, n_Shl_right);
}

void (set_Shl_right)(ir_node *node, ir_node *right)
{
	assert(is_Shl(node));
	set_irn_n(node, n_Shl_right, right);
}


ir_node *(get_Shr_left)(const ir_node *node)
{
	assert(is_Shr(node));
	return get_irn_n(node, n_Shr_left);
}

void (set_Shr_left)(ir_node *node, ir_node *left)
{
	assert(is_Shr(node));
	set_irn_n(node, n_Shr_left, left);
}

ir_node *(get_Shr_right)(const ir_node *node)
{
	assert(is_Shr(node));
	return get_irn_n(node, n_Shr_right);
}

void (set_Shr_right)(ir_node *node, ir_node *right)
{
	assert(is_Shr(node));
	set_irn_n(node, n_Shr_right, right);
}


ir_node *(get_Shrs_left)(const ir_node *node)
{
	assert(is_Shrs(node));
	return get_irn_n(node, n_Shrs_left);
}

void (set_Shrs_left)(ir_node *node, ir_node *left)
{
	assert(is_Shrs(node));
	set_irn_n(node, n_Shrs_left, left);
}

ir_node *(get_Shrs_right)(const ir_node *node)
{
	assert(is_Shrs(node));
	return get_irn_n(node, n_Shrs_right);
}

void (set_Shrs_right)(ir_node *node, ir_node *right)
{
	assert(is_Shrs(node));
	set_irn_n(node, n_Shrs_right, right);
}



ir_node *(get_Store_mem)(const ir_node *node)
{
	assert(is_Store(node));
	return get_irn_n(node, n_Store_mem);
}

void (set_Store_mem)(ir_node *node, ir_node *mem)
{
	assert(is_Store(node));
	set_irn_n(node, n_Store_mem, mem);
}

ir_node *(get_Store_ptr)(const ir_node *node)
{
	assert(is_Store(node));
	return get_irn_n(node, n_Store_ptr);
}

void (set_Store_ptr)(ir_node *node, ir_node *ptr)
{
	assert(is_Store(node));
	set_irn_n(node, n_Store_ptr, ptr);
}

ir_node *(get_Store_value)(const ir_node *node)
{
	assert(is_Store(node));
	return get_irn_n(node, n_Store_value);
}

void (set_Store_value)(ir_node *node, ir_node *value)
{
	assert(is_Store(node));
	set_irn_n(node, n_Store_value, value);
}


ir_node *(get_Sub_left)(const ir_node *node)
{
	assert(is_Sub(node));
	return get_irn_n(node, n_Sub_left);
}

void (set_Sub_left)(ir_node *node, ir_node *left)
{
	assert(is_Sub(node));
	set_irn_n(node, n_Sub_left, left);
}

ir_node *(get_Sub_right)(const ir_node *node)
{
	assert(is_Sub(node));
	return get_irn_n(node, n_Sub_right);
}

void (set_Sub_right)(ir_node *node, ir_node *right)
{
	assert(is_Sub(node));
	set_irn_n(node, n_Sub_right, right);
}


ir_node *(get_Switch_selector)(const ir_node *node)
{
	assert(is_Switch(node));
	return get_irn_n(node, n_Switch_selector);
}

void (set_Switch_selector)(ir_node *node, ir_node *selector)
{
	assert(is_Switch(node));
	set_irn_n(node, n_Switch_selector, selector);
}