LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/frontend/irgen_c.c
// Function: ir_expr_shift
static bool _ir_expr_shift(
	IRGeneratorCContext *ctx,
	ResizableString *rstr,
	ParserASTNode *node_expr
) {
	assert(ctx);
	assert(rstr);
	assert(node_expr);

	#define	_IR_EXPR_SHIFT(str_opt)	\
	{	\
		assert(node_expr->nchilds == 2);	\
		rstr_append_with_cstr(rstr, "(");	\
		_ir_expr(ctx, rstr, node_expr->childs[0]);	\
		rstr_append_with_cstr(rstr, (str_opt));	\
		_ir_expr(ctx, rstr, node_expr->childs[1]);	\
		rstr_append_with_cstr(rstr, ")");	\
	}

	switch (node_expr->type) {
		case FE_NODE_EXPR_SHIFT_LEFT: {
			_IR_EXPR_SHIFT(" << ")
			return true;
		}
		case FE_NODE_EXPR_SHIFT_RIGHT: {
			_IR_EXPR_SHIFT(" >> ")
			return true;
		}
		default: {
			return false;
		}
	}

	#undef	_IR_EXPR_SHIFT
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdx), %eax
cmpl $0xe91, %eax            # imm = 0xE91
je 0x1643c
cmpl $0xe90, %eax            # imm = 0xE90
jne 0x164a0
cmpl $0x2, 0x44(%r15)
jne 0x164ab
leaq 0x2ea8b(%rip), %r12     # 0x44ec5
jmp 0x1644e
cmpl $0x2, 0x44(%r15)
jne 0x164ca
leaq 0x2ea7c(%rip), %r12     # 0x44eca
leaq 0x2ef24(%rip), %rsi     # 0x45379
movq %rbx, %rdi
callq 0x75cf
movq 0x48(%r15), %rax
movq (%rax), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x155d5
movq %rbx, %rdi
movq %r12, %rsi
callq 0x75cf
movq 0x48(%r15), %rax
movq 0x8(%rax), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x155d5
leaq 0x2e4a6(%rip), %rsi     # 0x4493a
movq %rbx, %rdi
callq 0x75cf
movb $0x1, %al
jmp 0x164a2
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2e802(%rip), %rdi     # 0x44cb4
leaq 0x2e303(%rip), %rsi     # 0x447bc
leaq 0x2e9b5(%rip), %rcx     # 0x44e75
movl $0x315, %edx            # imm = 0x315
callq 0x30a0
leaq 0x2e7e3(%rip), %rdi     # 0x44cb4
leaq 0x2e2e4(%rip), %rsi     # 0x447bc
leaq 0x2e996(%rip), %rcx     # 0x44e75
movl $0x319, %edx            # imm = 0x319
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/frontend/irgen_c.c
// Function: ir_expr_eq
static bool _ir_expr_eq(
	IRGeneratorCContext *ctx,
	ResizableString *rstr,
	ParserASTNode *node_expr
) {
	assert(ctx);
	assert(rstr);
	assert(node_expr);

	#define	_IR_EXPR_EQ(str_opt)	\
	{	\
		assert(node_expr->nchilds == 2);	\
		_IR_EXPR_AUTO_CAST_BEGIN	\
		rstr_append_with_cstr(rstr, "(");	\
		_ir_expr(ctx, rstr, node_expr->childs[0]);	\
		rstr_append_with_cstr(rstr, (str_opt));	\
		_ir_expr(ctx, rstr, node_expr->childs[1]);	\
		rstr_append_with_cstr(rstr, ")");	\
		_IR_EXPR_AUTO_CAST_END	\
	}

	switch (node_expr->type) {
		case FE_NODE_EXPR_EQ: {
			_IR_EXPR_EQ(" == ")
			return true;
		}
		case FE_NODE_EXPR_NEQ: {
			_IR_EXPR_EQ(" != ")
			return true;
		}
		default: {
			return false;
		}
	}

	#undef	_IR_EXPR_EQ
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdx), %eax
cmpl $0xe71, %eax            # imm = 0xE71
je 0x16854
cmpl $0xe70, %eax            # imm = 0xE70
jne 0x16906
cmpl $0x2, 0x44(%r15)
jne 0x16915
leaq -0x30(%rbp), %r12
movq %r12, %rdi
callq 0x7548
movq 0x68(%r15), %rsi
movq %r12, %rdi
callq 0x14ba1
movq 0x8(%r12), %rax
testq %rax, %rax
leaq 0x2d6a5(%rip), %rdx     # 0x43eba
cmovneq %rax, %rdx
leaq 0x2e2e7(%rip), %rsi     # 0x44b07
movq %rbx, %rdi
xorl %eax, %eax
callq 0x7b31
leaq 0x2eb48(%rip), %rsi     # 0x45379
movq %rbx, %rdi
callq 0x75cf
movq 0x48(%r15), %rax
movq (%rax), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x155d5
leaq 0x2e729(%rip), %rsi     # 0x44f7b
jmp 0x168c3
cmpl $0x2, 0x44(%r15)
jne 0x16934
leaq -0x30(%rbp), %r12
movq %r12, %rdi
callq 0x7548
movq 0x68(%r15), %rsi
movq %r12, %rdi
callq 0x14ba1
movq 0x8(%r12), %rax
testq %rax, %rax
leaq 0x2d634(%rip), %rdx     # 0x43eba
cmovneq %rax, %rdx
leaq 0x2e276(%rip), %rsi     # 0x44b07
movq %rbx, %rdi
xorl %eax, %eax
callq 0x7b31
leaq 0x2ead7(%rip), %rsi     # 0x45379
movq %rbx, %rdi
callq 0x75cf
movq 0x48(%r15), %rax
movq (%rax), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x155d5
leaq 0x2e6bd(%rip), %rsi     # 0x44f80
movq %rbx, %rdi
callq 0x75cf
movq 0x48(%r15), %rax
movq 0x8(%rax), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x155d5
leaq 0x2e055(%rip), %rsi     # 0x4493a
movq %rbx, %rdi
callq 0x75cf
movq %r12, %rdi
callq 0x7a38
movq %rbx, %rdi
movl $0x29, %esi
callq 0x76cb
movb $0x1, %al
jmp 0x16908
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2e398(%rip), %rdi     # 0x44cb4
leaq 0x2de99(%rip), %rsi     # 0x447bc
leaq 0x2e604(%rip), %rcx     # 0x44f2e
movl $0x369, %edx            # imm = 0x369
callq 0x30a0
leaq 0x2e379(%rip), %rdi     # 0x44cb4
leaq 0x2de7a(%rip), %rsi     # 0x447bc
leaq 0x2e5e5(%rip), %rcx     # 0x44f2e
movl $0x36d, %edx            # imm = 0x36D
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/frontend/irgen_c.c
// Function: ir_expr_band
static bool _ir_expr_band(
	IRGeneratorCContext *ctx,
	ResizableString *rstr,
	ParserASTNode *node_expr
) {
	assert(ctx);
	assert(rstr);
	assert(node_expr);

	#define	_IR_EXPR_BAND(str_opt)	\
	{	\
		assert(node_expr->nchilds == 2);	\
		_IR_EXPR_AUTO_CAST_BEGIN	\
		rstr_append_with_cstr(rstr, "(");	\
		_ir_expr(ctx, rstr, node_expr->childs[0]);	\
		rstr_append_with_cstr(rstr, (str_opt));	\
		_ir_expr(ctx, rstr, node_expr->childs[1]);	\
		rstr_append_with_cstr(rstr, ")");	\
		_IR_EXPR_AUTO_CAST_END	\
	}

	switch (node_expr->type) {
		case FE_NODE_EXPR_BAND: {
			_IR_EXPR_BAND(" & ")
			return true;
		}
		default: {
			return false;
		}
	}

	#undef	_IR_EXPR_BAND
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl (%rdx), %r13d
cmpl $0xe60, %r13d           # imm = 0xE60
jne 0x16a2c
movq %rdx, %r12
cmpl $0x2, 0x44(%rdx)
jne 0x16a45
movq %rsi, %rbx
movq %rdi, %r15
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x7548
movq 0x68(%r12), %rsi
movq %r14, %rdi
callq 0x14ba1
movq 0x8(%r14), %rax
testq %rax, %rax
leaq 0x2d50c(%rip), %rdx     # 0x43eba
cmovneq %rax, %rdx
leaq 0x2e14e(%rip), %rsi     # 0x44b07
movq %rbx, %rdi
xorl %eax, %eax
callq 0x7b31
leaq 0x2e9af(%rip), %rsi     # 0x45379
movq %rbx, %rdi
callq 0x75cf
movq 0x48(%r12), %rax
movq (%rax), %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x155d5
leaq 0x2e5e8(%rip), %rsi     # 0x44fd4
movq %rbx, %rdi
callq 0x75cf
movq 0x48(%r12), %rax
movq 0x8(%rax), %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x155d5
leaq 0x2df2b(%rip), %rsi     # 0x4493a
movq %rbx, %rdi
callq 0x75cf
movq %r14, %rdi
callq 0x7a38
movq %rbx, %rdi
movl $0x29, %esi
callq 0x76cb
cmpl $0xe60, %r13d           # imm = 0xE60
sete %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2e268(%rip), %rdi     # 0x44cb4
leaq 0x2dd69(%rip), %rsi     # 0x447bc
leaq 0x2e52b(%rip), %rcx     # 0x44f85
movl $0x38f, %edx            # imm = 0x38F
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/frontend/irgen_c.c
// Function: ir_expr_bxor
static bool _ir_expr_bxor(
	IRGeneratorCContext *ctx,
	ResizableString *rstr,
	ParserASTNode *node_expr
) {
	assert(ctx);
	assert(rstr);
	assert(node_expr);

	#define	_IR_EXPR_BXOR(str_opt)	\
	{	\
		assert(node_expr->nchilds == 2);	\
		_IR_EXPR_AUTO_CAST_BEGIN	\
		rstr_append_with_cstr(rstr, "(");	\
		_ir_expr(ctx, rstr, node_expr->childs[0]);	\
		rstr_append_with_cstr(rstr, (str_opt));	\
		_ir_expr(ctx, rstr, node_expr->childs[1]);	\
		rstr_append_with_cstr(rstr, ")");	\
		_IR_EXPR_AUTO_CAST_END	\
	}

	switch (node_expr->type) {
		case FE_NODE_EXPR_BXOR: {
			_IR_EXPR_BXOR(" ^ ")
			return true;
		}
		default: {
			return false;
		}
	}

	#undef	_IR_EXPR_BXOR
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl (%rdx), %r13d
cmpl $0xe50, %r13d           # imm = 0xE50
jne 0x16b3d
movq %rdx, %r12
cmpl $0x2, 0x44(%rdx)
jne 0x16b56
movq %rsi, %rbx
movq %rdi, %r15
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x7548
movq 0x68(%r12), %rsi
movq %r14, %rdi
callq 0x14ba1
movq 0x8(%r14), %rax
testq %rax, %rax
leaq 0x2d3fb(%rip), %rdx     # 0x43eba
cmovneq %rax, %rdx
leaq 0x2e03d(%rip), %rsi     # 0x44b07
movq %rbx, %rdi
xorl %eax, %eax
callq 0x7b31
leaq 0x2e89e(%rip), %rsi     # 0x45379
movq %rbx, %rdi
callq 0x75cf
movq 0x48(%r12), %rax
movq (%rax), %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x155d5
leaq 0x2e52a(%rip), %rsi     # 0x45027
movq %rbx, %rdi
callq 0x75cf
movq 0x48(%r12), %rax
movq 0x8(%rax), %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x155d5
leaq 0x2de1a(%rip), %rsi     # 0x4493a
movq %rbx, %rdi
callq 0x75cf
movq %r14, %rdi
callq 0x7a38
movq %rbx, %rdi
movl $0x29, %esi
callq 0x76cb
cmpl $0xe50, %r13d           # imm = 0xE50
sete %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2e157(%rip), %rdi     # 0x44cb4
leaq 0x2dc58(%rip), %rsi     # 0x447bc
leaq 0x2e46d(%rip), %rcx     # 0x44fd8
movl $0x3b1, %edx            # imm = 0x3B1
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/frontend/irgen_c.c
// Function: ir_expr_bor
static bool _ir_expr_bor(
	IRGeneratorCContext *ctx,
	ResizableString *rstr,
	ParserASTNode *node_expr
) {
	assert(ctx);
	assert(rstr);
	assert(node_expr);

	#define	_IR_EXPR_BOR(str_opt)	\
	{	\
		assert(node_expr->nchilds == 2);	\
		_IR_EXPR_AUTO_CAST_BEGIN	\
		rstr_append_with_cstr(rstr, "(");	\
		_ir_expr(ctx, rstr, node_expr->childs[0]);	\
		rstr_append_with_cstr(rstr, (str_opt));	\
		_ir_expr(ctx, rstr, node_expr->childs[1]);	\
		rstr_append_with_cstr(rstr, ")");	\
		_IR_EXPR_AUTO_CAST_END	\
	}

	switch (node_expr->type) {
		case FE_NODE_EXPR_BOR: {
			_IR_EXPR_BOR(" | ")
			return true;
		}
		default: {
			return false;
		}
	}

	#undef	_IR_EXPR_BOR
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl (%rdx), %r13d
cmpl $0xe40, %r13d           # imm = 0xE40
jne 0x16c4e
movq %rdx, %r12
cmpl $0x2, 0x44(%rdx)
jne 0x16c67
movq %rsi, %rbx
movq %rdi, %r15
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x7548
movq 0x68(%r12), %rsi
movq %r14, %rdi
callq 0x14ba1
movq 0x8(%r14), %rax
testq %rax, %rax
leaq 0x2d2ea(%rip), %rdx     # 0x43eba
cmovneq %rax, %rdx
leaq 0x2df2c(%rip), %rsi     # 0x44b07
movq %rbx, %rdi
xorl %eax, %eax
callq 0x7b31
leaq 0x2e78d(%rip), %rsi     # 0x45379
movq %rbx, %rdi
callq 0x75cf
movq 0x48(%r12), %rax
movq (%rax), %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x155d5
leaq 0x2e46b(%rip), %rsi     # 0x45079
movq %rbx, %rdi
callq 0x75cf
movq 0x48(%r12), %rax
movq 0x8(%rax), %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x155d5
leaq 0x2dd09(%rip), %rsi     # 0x4493a
movq %rbx, %rdi
callq 0x75cf
movq %r14, %rdi
callq 0x7a38
movq %rbx, %rdi
movl $0x29, %esi
callq 0x76cb
cmpl $0xe40, %r13d           # imm = 0xE40
sete %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2e046(%rip), %rdi     # 0x44cb4
leaq 0x2db47(%rip), %rsi     # 0x447bc
leaq 0x2e3af(%rip), %rcx     # 0x4502b
movl $0x3d3, %edx            # imm = 0x3D3
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/frontend/irgen_c.c
// Function: ir_expr_and
static bool _ir_expr_and(
	IRGeneratorCContext *ctx,
	ResizableString *rstr,
	ParserASTNode *node_expr
) {
	assert(ctx);
	assert(rstr);
	assert(node_expr);

	#define	_IR_EXPR_AND(str_opt)	\
	{	\
		assert(node_expr->nchilds == 2);	\
		rstr_append_with_cstr(rstr, "(");	\
		_ir_expr(ctx, rstr, node_expr->childs[0]);	\
		rstr_append_with_cstr(rstr, (str_opt));	\
		_ir_expr(ctx, rstr, node_expr->childs[1]);	\
		rstr_append_with_cstr(rstr, ")");	\
	}

	switch (node_expr->type) {
		case FE_NODE_EXPR_AND: {
			_IR_EXPR_AND(" && ")
			return true;
		}
		default: {
			return false;
		}
	}

	#undef	_IR_EXPR_AND
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl (%rdx), %r12d
cmpl $0xe30, %r12d           # imm = 0xE30
jne 0x16cfe
movq %rdx, %r15
cmpl $0x2, 0x44(%rdx)
jne 0x16d11
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x2e6c6(%rip), %rsi     # 0x45379
movq %rbx, %rdi
callq 0x75cf
movq 0x48(%r15), %rax
movq (%rax), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x155d5
leaq 0x2e3f7(%rip), %rsi     # 0x450cb
movq %rbx, %rdi
callq 0x75cf
movq 0x48(%r15), %rax
movq 0x8(%rax), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x155d5
leaq 0x2dc44(%rip), %rsi     # 0x4493a
movq %rbx, %rdi
callq 0x75cf
cmpl $0xe30, %r12d           # imm = 0xE30
sete %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2df9c(%rip), %rdi     # 0x44cb4
leaq 0x2da9d(%rip), %rsi     # 0x447bc
leaq 0x2e357(%rip), %rcx     # 0x4507d
movl $0x3f3, %edx            # imm = 0x3F3
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/frontend/irgen_c.c
// Function: ir_expr_or
static bool _ir_expr_or(
	IRGeneratorCContext *ctx,
	ResizableString *rstr,
	ParserASTNode *node_expr
) {
	assert(ctx);
	assert(rstr);
	assert(node_expr);

	#define	_IR_EXPR_OR(str_opt)	\
	{	\
		assert(node_expr->nchilds == 2);	\
		rstr_append_with_cstr(rstr, "(");	\
		_ir_expr(ctx, rstr, node_expr->childs[0]);	\
		rstr_append_with_cstr(rstr, (str_opt));	\
		_ir_expr(ctx, rstr, node_expr->childs[1]);	\
		rstr_append_with_cstr(rstr, ")");	\
	}

	switch (node_expr->type) {
		case FE_NODE_EXPR_OR: {
			_IR_EXPR_OR(" || ")
			return true;
		}
		default: {
			return false;
		}
	}

	#undef	_IR_EXPR_OR
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl (%rdx), %r12d
cmpl $0xe20, %r12d           # imm = 0xE20
jne 0x16da8
movq %rdx, %r15
cmpl $0x2, 0x44(%rdx)
jne 0x16dbb
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x2e61c(%rip), %rsi     # 0x45379
movq %rbx, %rdi
callq 0x75cf
movq 0x48(%r15), %rax
movq (%rax), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x155d5
leaq 0x2e39f(%rip), %rsi     # 0x4511d
movq %rbx, %rdi
callq 0x75cf
movq 0x48(%r15), %rax
movq 0x8(%rax), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x155d5
leaq 0x2db9a(%rip), %rsi     # 0x4493a
movq %rbx, %rdi
callq 0x75cf
cmpl $0xe20, %r12d           # imm = 0xE20
sete %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2def2(%rip), %rdi     # 0x44cb4
leaq 0x2d9f3(%rip), %rsi     # 0x447bc
leaq 0x2e300(%rip), %rcx     # 0x450d0
movl $0x413, %edx            # imm = 0x413
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/frontend/irgen_c.c
// Function: ir_expr_cond
static bool _ir_expr_cond(
	IRGeneratorCContext *ctx,
	ResizableString *rstr,
	ParserASTNode *node_expr
) {
	assert(ctx);
	assert(rstr);
	assert(node_expr);

	if (node_expr->type == FE_NODE_EXPR_COND) {
		assert(node_expr->nchilds == 3);
		rstr_append_with_cstr(rstr, "((");
		_ir_expr(ctx, rstr, node_expr->childs[0]);
		rstr_append_with_cstr(rstr, ")?(");
		_ir_expr(ctx, rstr, node_expr->childs[1]);
		rstr_append_with_cstr(rstr, "):(");
		_ir_expr(ctx, rstr, node_expr->childs[2]);
		rstr_append_with_cstr(rstr, "))");

		return true;
	} else {
		return false;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl (%rdx), %r12d
cmpl $0xecd, %r12d           # imm = 0xECD
jne 0x16e7c
movq %rdx, %r15
cmpl $0x3, 0x44(%rdx)
jne 0x16e8f
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x2dfac(%rip), %rsi     # 0x44dbb
movq %rbx, %rdi
callq 0x75cf
movq 0x48(%r15), %rax
movq (%rax), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x155d5
leaq 0x2e359(%rip), %rsi     # 0x45189
movq %rbx, %rdi
callq 0x75cf
movq 0x48(%r15), %rax
movq 0x8(%rax), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x155d5
leaq 0x2e33b(%rip), %rsi     # 0x4518d
movq %rbx, %rdi
callq 0x75cf
movq 0x48(%r15), %rax
movq 0x10(%rax), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x155d5
leaq 0x2dac5(%rip), %rsi     # 0x44939
movq %rbx, %rdi
callq 0x75cf
cmpl $0xecd, %r12d           # imm = 0xECD
sete %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2e2db(%rip), %rdi     # 0x45171
leaq 0x2d91f(%rip), %rsi     # 0x447bc
leaq 0x2e27e(%rip), %rcx     # 0x45122
movl $0x470, %edx            # imm = 0x470
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/frontend/irgen_c.c
// Function: ir_expr_identifier
static void _ir_expr_identifier(
	IRGeneratorCContext *ctx,
	ResizableString *rstr,
	ParserASTNode *node_expr
) {
	assert(ctx);
	assert(rstr);
	assert(node_expr);
	assert(node_expr->type == FE_NODE_IDENTIFIER);
	assert(node_expr->nchilds == 0);

	rstr_append_with_raw(rstr, node_expr->token->content, node_expr->token->len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rsi, %rsi
je 0x171a2
cmpl $0x200, (%rsi)          # imm = 0x200
jne 0x171c1
cmpl $0x0, 0x44(%rsi)
jne 0x171e0
movq 0x10(%rsi), %rax
movq 0x8(%rax), %rsi
movl 0x4(%rax), %edx
popq %rbp
jmp 0x7768
leaq 0x2d8e8(%rip), %rdi     # 0x44a91
leaq 0x2d60c(%rip), %rsi     # 0x447bc
leaq 0x2da0c(%rip), %rcx     # 0x44bc3
movl $0x19d, %edx            # imm = 0x19D
callq 0x30a0
leaq 0x2da4f(%rip), %rdi     # 0x44c17
leaq 0x2d5ed(%rip), %rsi     # 0x447bc
leaq 0x2d9ed(%rip), %rcx     # 0x44bc3
movl $0x19e, %edx            # imm = 0x19E
callq 0x30a0
leaq 0x2da56(%rip), %rdi     # 0x44c3d
leaq 0x2d5ce(%rip), %rsi     # 0x447bc
leaq 0x2d9ce(%rip), %rcx     # 0x44bc3
movl $0x19f, %edx            # imm = 0x19F
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/frontend/irgen_llvmir.c
// Function: fe_irgen_llvmir_new_context
IRGeneratorLlvmirContext * fe_irgen_llvmir_new_context(ParserContext *psrctx, FILE *out) {
	assert(psrctx);
	assert(psrctx->ast);
	assert(out);
	
	IRGeneratorLlvmirContext *ctx = (IRGeneratorLlvmirContext *)malloc(sizeof(IRGeneratorLlvmirContext));
	if (ctx == NULL) {
		_error("cannot allocate memory for a new context!");
	}

	ctx->psrctx = psrctx;
	ctx->out = out;

	ctx->global = rstr_new();
	ctx->head = rstr_new();
	ctx->body = rstr_new();
	ctx->foot = rstr_new();
	ctx->local_var_defs = NULL;

	rstr_init(ctx->global);
	rstr_init(ctx->head);
	rstr_init(ctx->body);
	rstr_init(ctx->foot);

	ctx->counter = 0;
	ctx->func_symbol = NULL;

	return ctx;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x19096
movq %rdi, %r15
cmpq $0x0, 0x8(%rdi)
je 0x190b5
movq %rsi, %r14
testq %rsi, %rsi
je 0x190d4
movl $0x48, %edi
callq 0x3110
testq %rax, %rax
je 0x190f3
movq %rax, %rbx
movq %r15, (%rax)
movq %r14, 0x8(%rax)
callq 0x792a
movq %rax, %r14
movq %rax, 0x10(%rbx)
callq 0x792a
movq %rax, %r15
movq %rax, 0x18(%rbx)
callq 0x792a
movq %rax, %r12
movq %rax, 0x20(%rbx)
callq 0x792a
movq %rax, %r13
movq %rax, 0x28(%rbx)
movq $0x0, 0x30(%rbx)
movq %r14, %rdi
callq 0x7548
movq %r15, %rdi
callq 0x7548
movq %r12, %rdi
callq 0x7548
movq %r13, %rdi
callq 0x7548
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x292c7(%rip), %rdi     # 0x42364
leaq 0x2c7d0(%rip), %rsi     # 0x45874
leaq 0x2c8db(%rip), %rcx     # 0x45986
movl $0x1498, %edx           # imm = 0x1498
callq 0x30a0
leaq 0x292b4(%rip), %rdi     # 0x42370
leaq 0x2c7b1(%rip), %rsi     # 0x45874
leaq 0x2c8bc(%rip), %rcx     # 0x45986
movl $0x1499, %edx           # imm = 0x1499
callq 0x30a0
leaq 0x292cf(%rip), %rdi     # 0x423aa
leaq 0x2c792(%rip), %rsi     # 0x45874
leaq 0x2c89d(%rip), %rcx     # 0x45986
movl $0x149a, %edx           # imm = 0x149A
callq 0x30a0
callq 0x3221
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/frontend/irgen_llvmir.c
// Function: expr_result_init
static void _expr_result_init(
	_ExprResult *expr_result
) {
	assert(expr_result);

	rstr_init(&(expr_result->rstr_for_result));
	rstr_init(&(expr_result->rstr_for_result_ptr));

	rstr_init(&(expr_result->rstr_result));
	rstr_init(&(expr_result->rstr_result_type));
	rstr_init(&(expr_result->rstr_result_val));

	rstr_init(&(expr_result->rstr_result_ptr));
	rstr_init(&(expr_result->rstr_result_ptr_type));
	rstr_init(&(expr_result->rstr_result_ptr_val));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x19f25
movq %rdi, %rbx
callq 0x7548
leaq 0x10(%rbx), %rdi
callq 0x7548
leaq 0x20(%rbx), %rdi
callq 0x7548
leaq 0x30(%rbx), %rdi
callq 0x7548
leaq 0x40(%rbx), %rdi
callq 0x7548
leaq 0x50(%rbx), %rdi
callq 0x7548
leaq 0x60(%rbx), %rdi
callq 0x7548
addq $0x70, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x7548
leaq 0x28c5c(%rip), %rdi     # 0x42b88
leaq 0x2b941(%rip), %rsi     # 0x45874
leaq 0x28c5a(%rip), %rcx     # 0x42b94
movl $0x57, %edx
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/frontend/irgen_llvmir.c
// Function: expr_result_free
static void _expr_result_free(
	_ExprResult *expr_result
) {
	assert(expr_result);

	rstr_free(&(expr_result->rstr_for_result));
	rstr_free(&(expr_result->rstr_for_result_ptr));

	rstr_free(&(expr_result->rstr_result));
	rstr_free(&(expr_result->rstr_result_type));
	rstr_free(&(expr_result->rstr_result_val));

	rstr_free(&(expr_result->rstr_result_ptr));
	rstr_free(&(expr_result->rstr_result_ptr_type));
	rstr_free(&(expr_result->rstr_result_ptr_val));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1a806
movq %rdi, %rbx
callq 0x7a38
leaq 0x10(%rbx), %rdi
callq 0x7a38
leaq 0x20(%rbx), %rdi
callq 0x7a38
leaq 0x30(%rbx), %rdi
callq 0x7a38
leaq 0x40(%rbx), %rdi
callq 0x7a38
leaq 0x50(%rbx), %rdi
callq 0x7a38
leaq 0x60(%rbx), %rdi
callq 0x7a38
addq $0x70, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x7a38
leaq 0x2837b(%rip), %rdi     # 0x42b88
leaq 0x2b060(%rip), %rsi     # 0x45874
leaq 0x29631(%rip), %rcx     # 0x43e4c
movl $0xc4, %edx
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/frontend/irgen_llvmir.c
// Function: ir_expr_shift
static bool _ir_expr_shift(
	IRGeneratorLlvmirContext *ctx,
	ResizableString *rstr,
	_ExprResult *expr_result,
	ParserASTNode *node
) {
	assert(ctx);
	assert(rstr);
	assert(expr_result);
	assert(node);

	switch (node->type) {
		case FE_NODE_EXPR_SHIFT_LEFT: {
			assert(node->nchilds == 2);

			_ir_expr_shift_left(ctx, rstr, NULL, expr_result, node);

			return true;
		}
		case FE_NODE_EXPR_SHIFT_RIGHT: {
			assert(node->nchilds == 2);

			_ir_expr_shift_right(ctx, rstr, NULL, expr_result, node);

			return true;
		}
		default: {
			return false;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rcx, %r8
movq %rdx, %rcx
movl (%r8), %eax
cmpl $0xe91, %eax            # imm = 0xE91
je 0x1cc5b
cmpl $0xe90, %eax            # imm = 0xE90
jne 0x1cc6d
cmpl $0x2, 0x44(%r8)
jne 0x1cc71
xorl %edx, %edx
callq 0x1f8df
jmp 0x1cc69
cmpl $0x2, 0x44(%r8)
jne 0x1cc90
xorl %edx, %edx
callq 0x1fb3e
movb $0x1, %al
jmp 0x1cc6f
xorl %eax, %eax
popq %rbp
retq
leaq 0x2efdd(%rip), %rdi     # 0x4bc55
leaq 0x28bf5(%rip), %rsi     # 0x45874
leaq 0x29b6c(%rip), %rcx     # 0x467f2
movl $0xee4, %edx            # imm = 0xEE4
callq 0x30a0
leaq 0x2efbe(%rip), %rdi     # 0x4bc55
leaq 0x28bd6(%rip), %rsi     # 0x45874
leaq 0x29b4d(%rip), %rcx     # 0x467f2
movl $0xeeb, %edx            # imm = 0xEEB
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/frontend/irgen_llvmir.c
// Function: expr_result_set_result
static void _expr_result_set_result(
	_ExprResult *result,
	const char *type,
	const char *val
) {
	assert(result);
	assert(type);
	assert(val);

	rstr_appendf(
		&(result->rstr_result),
		"%s %s",
		type,
		val
	);

	rstr_append_with_cstr(&(result->rstr_result_type), type);

	rstr_append_with_cstr(&(result->rstr_result_val), val);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x1e2da
movq %rdx, %rbx
testq %rdx, %rdx
je 0x1e2f9
movq %rsi, %r15
movq %rdi, %r14
addq $0x20, %rdi
leaq 0x27d14(%rip), %rsi     # 0x45fbc
movq %r15, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x7b31
leaq 0x30(%r14), %rdi
movq %r15, %rsi
callq 0x75cf
addq $0x40, %r14
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x75cf
leaq 0x243db(%rip), %rdi     # 0x426bc
leaq 0x2758c(%rip), %rsi     # 0x45874
leaq 0x27c85(%rip), %rcx     # 0x45f74
movl $0x6b, %edx
callq 0x30a0
leaq 0x2479d(%rip), %rdi     # 0x42a9d
leaq 0x2756d(%rip), %rsi     # 0x45874
leaq 0x27c66(%rip), %rcx     # 0x45f74
movl $0x6c, %edx
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/frontend/irgen_llvmir.c
// Function: generate_func_tmp
static size_t _generate_func_tmp(
	IRGeneratorLlvmirContext *ctx,
	ParserSymbol *func_symbol,
	ResizableString *rstr
) {
	assert(ctx);
	assert(func_symbol);
	assert(rstr);

	size_t no = FE_FUNC_SYMBOL_NEXT_NO(func_symbol);

	rstr_appendf(rstr, "%%.__tmp_%zu__", no);

	return no;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x1e344
testq %rsi, %rsi
je 0x1e363
movl 0x54(%rdi), %edx
leal 0x1(%rdx), %eax
movl %eax, 0x54(%rdi)
leaq 0x27d64(%rip), %rax     # 0x4609a
movq %rsi, %rdi
movq %rax, %rsi
xorl %eax, %eax
popq %rbp
jmp 0x7b31
leaq 0x25bd0(%rip), %rdi     # 0x43f1b
leaq 0x27522(%rip), %rsi     # 0x45874
leaq 0x27ce8(%rip), %rcx     # 0x46041
movl $0xfb, %edx
callq 0x30a0
leaq 0x226e6(%rip), %rdi     # 0x40a50
leaq 0x27503(%rip), %rsi     # 0x45874
leaq 0x27cc9(%rip), %rcx     # 0x46041
movl $0xfc, %edx
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/frontend/irgen_llvmir.c
// Function: expr_result_set_result_ptr
static void _expr_result_set_result_ptr(
	_ExprResult *result,
	const char *type,
	const char *val
) {
	assert(result);
	assert(type);
	assert(val);

	rstr_appendf(
		&(result->rstr_result_ptr),
		"%s* %s",
		type,
		val
	);

	rstr_appendf(
		&(result->rstr_result_ptr_type),
		"%s*",
		type
	);

	rstr_append_with_cstr(&(result->rstr_result_ptr_val), val);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x1e3e5
movq %rdx, %rbx
testq %rdx, %rdx
je 0x1e404
movq %rsi, %r15
movq %rdi, %r14
addq $0x50, %rdi
leaq 0x27d4b(%rip), %rsi     # 0x460f5
movq %r15, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x7b31
leaq 0x60(%r14), %rdi
leaq 0x27d3a(%rip), %rsi     # 0x460fc
movq %r15, %rdx
xorl %eax, %eax
callq 0x7b31
addq $0x70, %r14
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x75cf
leaq 0x242d0(%rip), %rdi     # 0x426bc
leaq 0x27481(%rip), %rsi     # 0x45874
leaq 0x27caf(%rip), %rcx     # 0x460a9
movl $0x99, %edx
callq 0x30a0
leaq 0x24692(%rip), %rdi     # 0x42a9d
leaq 0x27462(%rip), %rsi     # 0x45874
leaq 0x27c90(%rip), %rcx     # 0x460a9
movl $0x9a, %edx
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/frontend/irgen_llvmir.c
// Function: ir_cond_expr_with_rstr
static void _ir_cond_expr_with_rstr(
	IRGeneratorLlvmirContext *ctx,
	ResizableString *rstr,
	ResizableString *cond_expr_label,
	_ExprResult *expr_result,
	ParserASTNode *expr_node
) {
	assert(ctx);
	assert(rstr);
	assert(cond_expr_label);
	assert(expr_result);
	assert(expr_node);

	uint8_t expr_type = FE_EXPR_AST_NODE_GET_TYPE(expr_node);

	_TMP_LABEL_DEF(ctx, cond_expr)

	if (fe_sem_is_integer_type(expr_type)) {
		rstr_appendf(
			rstr,
			"%s = icmp ne %s, 0\n",
			_TMP_LABEL_CSTR(cond_expr),
			RSTR_CSTR(&(expr_result->rstr_result))
		);
	} else if (fe_sem_is_pointer_type(expr_type)) {
		rstr_appendf(
			rstr,
			"%s = icmp ne %s, null\n",
			_TMP_LABEL_CSTR(cond_expr),
			RSTR_CSTR(&(expr_result->rstr_result))
		);
	} else {
		assert(0);
	}

	rstr_append_with_cstr(cond_expr_label, _TMP_LABEL_CSTR(cond_expr));

	_TMP_LABEL_FREE(cond_expr)
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rsi, %rsi
je 0x2021f
testq %rdx, %rdx
je 0x2023e
movq %rcx, %r15
testq %rcx, %rcx
je 0x2025d
movq %rdx, -0x30(%rbp)
testq %r8, %r8
je 0x2027c
movq %rsi, %r14
movq %rdi, %r12
movb 0x60(%r8), %bl
leaq -0x40(%rbp), %r13
movq %r13, %rdi
callq 0x7548
movq 0x40(%r12), %rdi
movq %r13, %rsi
callq 0x1e318
movzbl %bl, %r12d
movl %r12d, %edi
callq 0x2ad50
testb %al, %al
je 0x201b0
leaq 0x26c10(%rip), %rsi     # 0x46dbe
jmp 0x201c7
movl %r12d, %edi
callq 0x2ad81
testb %al, %al
je 0x2029b
leaq 0x26c0b(%rip), %rsi     # 0x46dd2
leaq -0x40(%rbp), %r12
movq 0x8(%r12), %rdx
testq %rdx, %rdx
leaq 0x23ce0(%rip), %rbx     # 0x43eba
cmoveq %rbx, %rdx
movq 0x28(%r15), %rcx
testq %rcx, %rcx
cmoveq %rbx, %rcx
movq %r14, %rdi
xorl %eax, %eax
callq 0x7b31
movq 0x8(%r12), %rsi
testq %rsi, %rsi
cmoveq %rbx, %rsi
movq -0x30(%rbp), %rdi
callq 0x75cf
movq %r12, %rdi
callq 0x7a38
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2082a(%rip), %rdi     # 0x40a50
leaq 0x25647(%rip), %rsi     # 0x45874
leaq 0x26b0b(%rip), %rcx     # 0x46d3f
movl $0x51b, %edx            # imm = 0x51B
callq 0x30a0
leaq 0x239a8(%rip), %rdi     # 0x43bed
leaq 0x25628(%rip), %rsi     # 0x45874
leaq 0x26aec(%rip), %rcx     # 0x46d3f
movl $0x51c, %edx            # imm = 0x51C
callq 0x30a0
leaq 0x22924(%rip), %rdi     # 0x42b88
leaq 0x25609(%rip), %rsi     # 0x45874
leaq 0x26acd(%rip), %rcx     # 0x46d3f
movl $0x51d, %edx            # imm = 0x51D
callq 0x30a0
leaq 0x2397a(%rip), %rdi     # 0x43bfd
leaq 0x255ea(%rip), %rsi     # 0x45874
leaq 0x26aae(%rip), %rcx     # 0x46d3f
movl $0x51e, %edx            # imm = 0x51E
callq 0x30a0
leaq 0x200e2(%rip), %rdi     # 0x40384
leaq 0x255cb(%rip), %rsi     # 0x45874
leaq 0x26a8f(%rip), %rcx     # 0x46d3f
movl $0x533, %edx            # imm = 0x533
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/frontend/lexer.c
// Function: fe_lexer_new_context
LexerContext * fe_lexer_new_context(
	const char *file,
	const char *source,
	int len
) {
	assert(file);
	assert(source);
	assert(len >= 0);

	return lexer_new_context(file, source, len, _matchers);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x21737
testq %rsi, %rsi
je 0x21756
testl %edx, %edx
js 0x21775
leaq 0x379ff(%rip), %rcx     # 0x59130
popq %rbp
jmp 0x3f04
leaq 0x1e2cb(%rip), %rdi     # 0x3fa09
leaq 0x25dd3(%rip), %rsi     # 0x47518
leaq 0x25de6(%rip), %rcx     # 0x47532
movl $0x156, %edx            # imm = 0x156
callq 0x30a0
leaq 0x1ddd9(%rip), %rdi     # 0x3f536
leaq 0x25db4(%rip), %rsi     # 0x47518
leaq 0x25dc7(%rip), %rcx     # 0x47532
movl $0x157, %edx            # imm = 0x157
callq 0x30a0
leaq 0x1ddc1(%rip), %rdi     # 0x3f53d
leaq 0x25d95(%rip), %rsi     # 0x47518
leaq 0x25da8(%rip), %rcx     # 0x47532
movl $0x158, %edx            # imm = 0x158
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/frontend/lexer.c
// Function: fe_lexer_get_uint32_val
uint32_t fe_lexer_get_uint32_val(
	LexerContext *ctx,
	LexerToken *token
) {
	assert(ctx);
	assert(token);

	switch (token->type) {
		case FE_TOKEN_LITERAL_UINT_BIN: {
			return util_get_uint32_bin_val(token->content, token->len);
		}
		case FE_TOKEN_LITERAL_UINT_OCT: {
			return util_get_uint32_oct_val(token->content, token->len);
		}
		case FE_TOKEN_LITERAL_UINT_DEC: {
			return util_get_uint32_dec_val(token->content, token->len);
		}
		case FE_TOKEN_LITERAL_UINT_HEX: {
			return util_get_uint32_hex_val(token->content, token->len);
		}
		default: {
			assert(0);
		}
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x21822
testq %rsi, %rsi
je 0x21841
movl $0xfffff000, %eax       # imm = 0xFFFFF000
addl (%rsi), %eax
cmpl $0x3, %eax
ja 0x21860
leaq 0x25d13(%rip), %rcx     # 0x474f8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0xa26f
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0xa4b3
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0xa657
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0xa397
leaq 0x2d13d(%rip), %rdi     # 0x4e966
leaq 0x25ce8(%rip), %rsi     # 0x47518
leaq 0x25d6a(%rip), %rcx     # 0x475a1
movl $0x167, %edx            # imm = 0x167
callq 0x30a0
leaq 0x2aef4(%rip), %rdi     # 0x4c73c
leaq 0x25cc9(%rip), %rsi     # 0x47518
leaq 0x25d4b(%rip), %rcx     # 0x475a1
movl $0x168, %edx            # imm = 0x168
callq 0x30a0
leaq 0x1eb1d(%rip), %rdi     # 0x40384
leaq 0x25caa(%rip), %rsi     # 0x47518
leaq 0x25d2c(%rip), %rcx     # 0x475a1
movl $0x178, %edx            # imm = 0x178
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/frontend/lexer.c
// Function: fe_lexer_get_uint64_val
uint64_t fe_lexer_get_uint64_val(
	LexerContext *ctx,
	LexerToken *token
) {
	assert(ctx);
	assert(token);

	switch (token->type) {
		case FE_TOKEN_LITERAL_UINT_BIN: {
			return util_get_uint64_bin_val(token->content, token->len);
		}
		case FE_TOKEN_LITERAL_UINT_OCT: {
			return util_get_uint64_oct_val(token->content, token->len);
		}
		case FE_TOKEN_LITERAL_UINT_DEC: {
			return util_get_uint64_dec_val(token->content, token->len);
		}
		case FE_TOKEN_LITERAL_UINT_HEX: {
			return util_get_uint64_hex_val(token->content, token->len);
		}
		default: {
			assert(0);
		}
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x218e1
testq %rsi, %rsi
je 0x21900
movl $0xfffff000, %eax       # imm = 0xFFFFF000
addl (%rsi), %eax
cmpl $0x3, %eax
ja 0x2191f
leaq 0x25c64(%rip), %rcx     # 0x47508
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0xa1c7
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0xa412
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0xa52e
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0xa2ea
leaq 0x2d07e(%rip), %rdi     # 0x4e966
leaq 0x25c29(%rip), %rsi     # 0x47518
leaq 0x25cea(%rip), %rcx     # 0x475e0
movl $0x183, %edx            # imm = 0x183
callq 0x30a0
leaq 0x2ae35(%rip), %rdi     # 0x4c73c
leaq 0x25c0a(%rip), %rsi     # 0x47518
leaq 0x25ccb(%rip), %rcx     # 0x475e0
movl $0x184, %edx            # imm = 0x184
callq 0x30a0
leaq 0x1ea5e(%rip), %rdi     # 0x40384
leaq 0x25beb(%rip), %rsi     # 0x47518
leaq 0x25cac(%rip), %rcx     # 0x475e0
movl $0x194, %edx            # imm = 0x194
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/frontend/lexer.c
// Function: fe_lexer_get_float_val
float fe_lexer_get_float_val(
	LexerContext *ctx,
	LexerToken *token
) {
	assert(ctx);
	assert(token);

	if (token->type == FE_TOKEN_LITERAL_REAL) {
		return util_get_float_val(token->content, token->len);
	} else {
		assert(0);
	}
	
	return 0.0f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x21961
testq %rsi, %rsi
je 0x21980
cmpl $0x1004, (%rsi)         # imm = 0x1004
jne 0x2199f
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0xa7f2
leaq 0x2cffe(%rip), %rdi     # 0x4e966
leaq 0x25ba9(%rip), %rsi     # 0x47518
leaq 0x25ca9(%rip), %rcx     # 0x4761f
movl $0x19f, %edx            # imm = 0x19F
callq 0x30a0
leaq 0x2adb5(%rip), %rdi     # 0x4c73c
leaq 0x25b8a(%rip), %rsi     # 0x47518
leaq 0x25c8a(%rip), %rcx     # 0x4761f
movl $0x1a0, %edx            # imm = 0x1A0
callq 0x30a0
leaq 0x1e9de(%rip), %rdi     # 0x40384
leaq 0x25b6b(%rip), %rsi     # 0x47518
leaq 0x25c6b(%rip), %rcx     # 0x4761f
movl $0x1a5, %edx            # imm = 0x1A5
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/frontend/lexer.c
// Function: fe_lexer_get_double_val
double fe_lexer_get_double_val(
	LexerContext *ctx,
	LexerToken *token
) {
	assert(ctx);
	assert(token);

	if (token->type == FE_TOKEN_LITERAL_REAL) {
		return util_get_double_val(token->content, token->len);
	} else {
		assert(0);
	}
	
	return 0.0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x219e1
testq %rsi, %rsi
je 0x21a00
cmpl $0x1004, (%rsi)         # imm = 0x1004
jne 0x21a1f
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0xa6d2
leaq 0x2cf7e(%rip), %rdi     # 0x4e966
leaq 0x25b29(%rip), %rsi     # 0x47518
leaq 0x25c64(%rip), %rcx     # 0x4765a
movl $0x1af, %edx            # imm = 0x1AF
callq 0x30a0
leaq 0x2ad35(%rip), %rdi     # 0x4c73c
leaq 0x25b0a(%rip), %rsi     # 0x47518
leaq 0x25c45(%rip), %rcx     # 0x4765a
movl $0x1b0, %edx            # imm = 0x1B0
callq 0x30a0
leaq 0x1e95e(%rip), %rdi     # 0x40384
leaq 0x25aeb(%rip), %rsi     # 0x47518
leaq 0x25c26(%rip), %rcx     # 0x4765a
movl $0x1b5, %edx            # imm = 0x1B5
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/frontend/lexer.c
// Function: fe_lexer_get_char_val
char fe_lexer_get_char_val(
	LexerContext *ctx,
	LexerToken *token
) {
	assert(ctx);
	assert(token);

	if (token->type == FE_TOKEN_LITERAL_CHAR) {
		return util_get_char_val(token->content, token->len);
	} else {
		assert(0);
	}

	return '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x21a61
testq %rsi, %rsi
je 0x21a80
cmpl $0x1005, (%rsi)         # imm = 0x1005
jne 0x21a9f
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0xa04e
leaq 0x2cefe(%rip), %rdi     # 0x4e966
leaq 0x25aa9(%rip), %rsi     # 0x47518
leaq 0x25c21(%rip), %rcx     # 0x47697
movl $0x1bf, %edx            # imm = 0x1BF
callq 0x30a0
leaq 0x2acb5(%rip), %rdi     # 0x4c73c
leaq 0x25a8a(%rip), %rsi     # 0x47518
leaq 0x25c02(%rip), %rcx     # 0x47697
movl $0x1c0, %edx            # imm = 0x1C0
callq 0x30a0
leaq 0x1e8de(%rip), %rdi     # 0x40384
leaq 0x25a6b(%rip), %rsi     # 0x47518
leaq 0x25be3(%rip), %rcx     # 0x47697
movl $0x1c5, %edx            # imm = 0x1C5
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/frontend/lexer.c
// Function: fe_lexer_has_unsigned_mark
bool fe_lexer_has_unsigned_mark(
	LexerContext *ctx,
	LexerToken *token
) {
	assert(ctx);
	assert(token);
	assert(
		token->type == FE_TOKEN_LITERAL_UINT_BIN
		|| token->type == FE_TOKEN_LITERAL_UINT_OCT
		|| token->type == FE_TOKEN_LITERAL_UINT_DEC
		|| token->type == FE_TOKEN_LITERAL_UINT_HEX
	);

	return token->content[token->len - 1] == 'u';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x21b69
testq %rsi, %rsi
je 0x21b88
movl (%rsi), %eax
andl $-0x4, %eax
cmpl $0x1000, %eax           # imm = 0x1000
jne 0x21ba7
movq 0x8(%rsi), %rax
movslq 0x4(%rsi), %rcx
cmpb $0x75, -0x1(%rax,%rcx)
sete %al
popq %rbp
retq
leaq 0x2cdf6(%rip), %rdi     # 0x4e966
leaq 0x259a1(%rip), %rsi     # 0x47518
leaq 0x25ba9(%rip), %rcx     # 0x47727
movl $0x1dc, %edx            # imm = 0x1DC
callq 0x30a0
leaq 0x2abad(%rip), %rdi     # 0x4c73c
leaq 0x25982(%rip), %rsi     # 0x47518
leaq 0x25b8a(%rip), %rcx     # 0x47727
movl $0x1dd, %edx            # imm = 0x1DD
callq 0x30a0
leaq 0x25bb8(%rip), %rdi     # 0x47766
leaq 0x25963(%rip), %rsi     # 0x47518
leaq 0x25b6b(%rip), %rcx     # 0x47727
movl $0x1e3, %edx            # imm = 0x1E3
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/frontend/lexer.c
// Function: fe_lexer_has_float_mark
bool fe_lexer_has_float_mark(
	LexerContext *ctx,
	LexerToken *token
) {
	assert(ctx);
	assert(token);
	assert(token->type == FE_TOKEN_LITERAL_REAL);

	return token->content[token->len - 1] == 'f';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x21bee
testq %rsi, %rsi
je 0x21c0d
cmpl $0x1004, (%rsi)         # imm = 0x1004
jne 0x21c2c
movq 0x8(%rsi), %rax
movslq 0x4(%rsi), %rcx
cmpb $0x66, -0x1(%rax,%rcx)
sete %al
popq %rbp
retq
leaq 0x2cd71(%rip), %rdi     # 0x4e966
leaq 0x2591c(%rip), %rsi     # 0x47518
leaq 0x25c10(%rip), %rcx     # 0x47813
movl $0x1ec, %edx            # imm = 0x1EC
callq 0x30a0
leaq 0x2ab28(%rip), %rdi     # 0x4c73c
leaq 0x258fd(%rip), %rsi     # 0x47518
leaq 0x25bf1(%rip), %rcx     # 0x47813
movl $0x1ed, %edx            # imm = 0x1ED
callq 0x30a0
leaq 0x25c1c(%rip), %rdi     # 0x4784f
leaq 0x258de(%rip), %rsi     # 0x47518
leaq 0x25bd2(%rip), %rcx     # 0x47813
movl $0x1ee, %edx            # imm = 0x1EE
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/frontend/parser.c
// Function: loop_ast_node_releaser
void _loop_ast_node_releaser(struct _ParserASTNode *node) {
	assert(node);
	assert(node->type == FE_NODE_STAT_WHILE
			|| node->type == FE_NODE_STAT_DO
			|| node->type == FE_NODE_STAT_FOR);

	rstr_free(FE_LOOP_AST_NODE_GET_LABEL_REPEAT(node));
	rstr_free(FE_LOOP_AST_NODE_GET_LABEL_END(node));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x24345
movq %rdi, %rbx
movl $0xfffff4e0, %eax       # imm = 0xFFFFF4E0
addl (%rdi), %eax
cmpl $0x20, %eax
ja 0x24364
movabsq $0x100010001, %rcx      # imm = 0x100010001
btq %rax, %rcx
jae 0x24364
leaq 0x60(%rbx), %rdi
callq 0x7a38
addq $0x70, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x7a38
leaq 0x1fa4a(%rip), %rdi     # 0x43d96
leaq 0x24fc9(%rip), %rsi     # 0x4931c
leaq 0x24fdd(%rip), %rcx     # 0x49337
movl $0x16, %edx
callq 0x30a0
leaq 0x25002(%rip), %rdi     # 0x4936d
leaq 0x24faa(%rip), %rsi     # 0x4931c
leaq 0x24fbe(%rip), %rcx     # 0x49337
movl $0x19, %edx
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/frontend/parser.c
// Function: fe_parser_new_context
_RULE_END




ParserContext * fe_parser_new_context(
	const char *file,
	const char *source,
	int len,
	int arch
) {
	assert(file);
	assert(source);
	assert(len >= 0);

	LexerContext *lexctx = fe_lexer_new_context(file, source, len);
	lexer_parse(lexctx);

	FeParserContextData data;
	data.align_node = NULL;
	data.packed_node = NULL;

	ParserContext *ctx = parser_new_context_with_data(
		lexctx, sizeof(data), &data
	);
	ctx->arch = arch;

	return ctx;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x24601
testq %rsi, %rsi
je 0x24620
testl %edx, %edx
js 0x2463f
movl %ecx, %ebx
callq 0x21718
movq %rax, %r14
movq %rax, %rdi
callq 0x47c0
xorps %xmm0, %xmm0
leaq -0x20(%rbp), %rdx
movaps %xmm0, (%rdx)
movl $0x10, %esi
movq %r14, %rdi
callq 0x621c
movl %ebx, 0x30(%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1b401(%rip), %rdi     # 0x3fa09
leaq 0x24d0d(%rip), %rsi     # 0x4931c
leaq 0x24dbb(%rip), %rcx     # 0x493d1
movl $0x8aa, %edx            # imm = 0x8AA
callq 0x30a0
leaq 0x1af0f(%rip), %rdi     # 0x3f536
leaq 0x24cee(%rip), %rsi     # 0x4931c
leaq 0x24d9c(%rip), %rcx     # 0x493d1
movl $0x8ab, %edx            # imm = 0x8AB
callq 0x30a0
leaq 0x1aef7(%rip), %rdi     # 0x3f53d
leaq 0x24ccf(%rip), %rsi     # 0x4931c
leaq 0x24d7d(%rip), %rcx     # 0x493d1
movl $0x8ac, %edx            # imm = 0x8AC
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/frontend/parser.c
// Function: fe_parser_print_ast
void fe_parser_print_ast(ParserContext * ctx, FILE *file) {
	assert(ctx);
	assert(ctx->ast);
	assert(file);

	_print_ast(ctx->ast, file, 0, '\t');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x24c50
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x24c6f
testq %rsi, %rsi
je 0x24c8e
xorl %edx, %edx
popq %rbp
jmp 0x24cad
leaq 0x29d0f(%rip), %rdi     # 0x4e966
leaq 0x246be(%rip), %rsi     # 0x4931c
leaq 0x2481b(%rip), %rcx     # 0x49480
movl $0x8eb, %edx            # imm = 0x8EB
callq 0x30a0
leaq 0x1d6fd(%rip), %rdi     # 0x42373
leaq 0x2469f(%rip), %rsi     # 0x4931c
leaq 0x247fc(%rip), %rcx     # 0x49480
movl $0x8ec, %edx            # imm = 0x8EC
callq 0x30a0
leaq 0x1ad74(%rip), %rdi     # 0x3fa09
leaq 0x24680(%rip), %rsi     # 0x4931c
leaq 0x247dd(%rip), %rcx     # 0x49480
movl $0x8ed, %edx            # imm = 0x8ED
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/frontend/parser.c
// Function: print_ast
static void _print_ast(ParserASTNode *node, FILE *file, int level, char padchr) {
	assert(node);
	assert(file);
	assert(level >= 0);

	for (int i = 0; i < level; i++) {
		fputc(padchr, file);
	}

	fprintf(
		file,
		"@%s#%x#%p#%p",
		node->type_name != NULL ? node->type_name : "N/A",
		node->type,
		node->parent,
		node
	);
	if (node->token != NULL) {
		fputc('(', file);
		for (int i = 0; i < node->token->len; i++) {
			fputc(*(node->token->content + i), file);
		}
		fprintf(file, "#%x)", node->token->type);
	}
	fputc('\n', file);

	for (int i = 0; i < node->nchilds; i++) {
		_print_ast(node->childs[i], file, level + 1, padchr);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x24daa
movl %edx, %ebx
testl %edx, %edx
js 0x24dc9
movq %rsi, %r14
movq %rdi, %r15
je 0x24ce8
movl %ebx, %r12d
movl $0x9, %edi
movq %r14, %rsi
callq 0x30c0
decl %r12d
jne 0x24cd6
movq 0x8(%r15), %rax
testq %rax, %rax
leaq 0x2605d(%rip), %rdx     # 0x4ad53
cmovneq %rax, %rdx
movl (%r15), %ecx
movq 0x30(%r15), %r8
leaq 0x2603e(%rip), %rsi     # 0x4ad46
movq %r14, %rdi
movq %r15, %r9
xorl %eax, %eax
callq 0x30e0
cmpq $0x0, 0x10(%r15)
je 0x24d6a
movl $0x28, %edi
movq %r14, %rsi
callq 0x30c0
movq 0x10(%r15), %rax
cmpl $0x0, 0x4(%rax)
jle 0x24d57
xorl %r12d, %r12d
movq 0x8(%rax), %rax
movsbl (%rax,%r12), %edi
movq %r14, %rsi
callq 0x30c0
incq %r12
movq 0x10(%r15), %rax
movslq 0x4(%rax), %rcx
cmpq %rcx, %r12
jl 0x24d36
movl (%rax), %edx
leaq 0x25ff7(%rip), %rsi     # 0x4ad57
movq %r14, %rdi
xorl %eax, %eax
callq 0x30e0
movl $0xa, %edi
movq %r14, %rsi
callq 0x30c0
cmpl $0x0, 0x44(%r15)
jle 0x24da1
incl %ebx
xorl %r12d, %r12d
movq 0x48(%r15), %rax
movq (%rax,%r12,8), %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x24cad
incq %r12
movslq 0x44(%r15), %rax
cmpq %rax, %r12
jl 0x24d83
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1efe5(%rip), %rdi     # 0x43d96
leaq 0x24564(%rip), %rsi     # 0x4931c
leaq 0x25f48(%rip), %rcx     # 0x4ad07
movl $0x8cc, %edx            # imm = 0x8CC
callq 0x30a0
leaq 0x25f6b(%rip), %rdi     # 0x4ad3b
leaq 0x24545(%rip), %rsi     # 0x4931c
leaq 0x25f29(%rip), %rcx     # 0x4ad07
movl $0x8ce, %edx            # imm = 0x8CE
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/frontend/parser.c
// Function: fe_parser_get_uint32_val
uint32_t fe_parser_get_uint32_val(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == FE_NODE_LITERAL_UINT);

	return fe_lexer_get_uint32_val(ctx->lexctx, node->token);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x24e0b
testq %rsi, %rsi
je 0x24e2a
cmpl $0x300, (%rsi)          # imm = 0x300
jne 0x24e49
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
popq %rbp
jmp 0x217c0
leaq 0x29b54(%rip), %rdi     # 0x4e966
leaq 0x24503(%rip), %rsi     # 0x4931c
leaq 0x24692(%rip), %rcx     # 0x494b2
movl $0x8f6, %edx            # imm = 0x8F6
callq 0x30a0
leaq 0x1ef65(%rip), %rdi     # 0x43d96
leaq 0x244e4(%rip), %rsi     # 0x4931c
leaq 0x24673(%rip), %rcx     # 0x494b2
movl $0x8f7, %edx            # imm = 0x8F7
callq 0x30a0
leaq 0x246a6(%rip), %rdi     # 0x494f6
leaq 0x244c5(%rip), %rsi     # 0x4931c
leaq 0x24654(%rip), %rcx     # 0x494b2
movl $0x8f8, %edx            # imm = 0x8F8
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/frontend/parser.c
// Function: fe_parser_get_uint64_val
uint64_t fe_parser_get_uint64_val(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == FE_NODE_LITERAL_UINT);

	return fe_lexer_get_uint64_val(ctx->lexctx, node->token);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x24e8b
testq %rsi, %rsi
je 0x24eaa
cmpl $0x300, (%rsi)          # imm = 0x300
jne 0x24ec9
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
popq %rbp
jmp 0x2187f
leaq 0x29ad4(%rip), %rdi     # 0x4e966
leaq 0x24483(%rip), %rsi     # 0x4931c
leaq 0x24679(%rip), %rcx     # 0x49519
movl $0x901, %edx            # imm = 0x901
callq 0x30a0
leaq 0x1eee5(%rip), %rdi     # 0x43d96
leaq 0x24464(%rip), %rsi     # 0x4931c
leaq 0x2465a(%rip), %rcx     # 0x49519
movl $0x902, %edx            # imm = 0x902
callq 0x30a0
leaq 0x24626(%rip), %rdi     # 0x494f6
leaq 0x24445(%rip), %rsi     # 0x4931c
leaq 0x2463b(%rip), %rcx     # 0x49519
movl $0x903, %edx            # imm = 0x903
callq 0x30a0