LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x169a4
movq %rdx, %r15
cmpl $0x2, 0x44(%rdx)
jne 0x169b7
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x2daed(%rip), %rsi     # 0x44446
movq %rbx, %rdi
callq 0x73db
movq 0x48(%r15), %rax
movq (%rax), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x15332
leaq 0x2d81e(%rip), %rsi     # 0x44198
movq %rbx, %rdi
callq 0x73db
movq 0x48(%r15), %rax
movq 0x8(%rax), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x15332
leaq 0x2d06e(%rip), %rsi     # 0x43a0a
movq %rbx, %rdi
callq 0x73db
cmpl $0xe30, %r12d           # imm = 0xE30
sete %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2d3c3(%rip), %rdi     # 0x43d81
leaq 0x2cec7(%rip), %rsi     # 0x4388c
leaq 0x2d77e(%rip), %rcx     # 0x4414a
movl $0x3f3, %edx            # imm = 0x3F3
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x16a4e
movq %rdx, %r15
cmpl $0x2, 0x44(%rdx)
jne 0x16a61
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x2da43(%rip), %rsi     # 0x44446
movq %rbx, %rdi
callq 0x73db
movq 0x48(%r15), %rax
movq (%rax), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x15332
leaq 0x2d7c6(%rip), %rsi     # 0x441ea
movq %rbx, %rdi
callq 0x73db
movq 0x48(%r15), %rax
movq 0x8(%rax), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x15332
leaq 0x2cfc4(%rip), %rsi     # 0x43a0a
movq %rbx, %rdi
callq 0x73db
cmpl $0xe20, %r12d           # imm = 0xE20
sete %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2d319(%rip), %rdi     # 0x43d81
leaq 0x2ce1d(%rip), %rsi     # 0x4388c
leaq 0x2d727(%rip), %rcx     # 0x4419d
movl $0x413, %edx            # imm = 0x413
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x16b22
movq %rdx, %r15
cmpl $0x3, 0x44(%rdx)
jne 0x16b35
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x2d3d3(%rip), %rsi     # 0x43e88
movq %rbx, %rdi
callq 0x73db
movq 0x48(%r15), %rax
movq (%rax), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x15332
leaq 0x2d780(%rip), %rsi     # 0x44256
movq %rbx, %rdi
callq 0x73db
movq 0x48(%r15), %rax
movq 0x8(%rax), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x15332
leaq 0x2d762(%rip), %rsi     # 0x4425a
movq %rbx, %rdi
callq 0x73db
movq 0x48(%r15), %rax
movq 0x10(%rax), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x15332
leaq 0x2ceef(%rip), %rsi     # 0x43a09
movq %rbx, %rdi
callq 0x73db
cmpl $0xecd, %r12d           # imm = 0xECD
sete %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2d702(%rip), %rdi     # 0x4423e
leaq 0x2cd49(%rip), %rsi     # 0x4388c
leaq 0x2d6a5(%rip), %rcx     # 0x441ef
movl $0x470, %edx            # imm = 0x470
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x16e48
cmpl $0x200, (%rsi)          # imm = 0x200
jne 0x16e67
cmpl $0x0, 0x44(%rsi)
jne 0x16e86
movq 0x10(%rsi), %rax
movq 0x8(%rax), %rsi
movl 0x4(%rax), %edx
popq %rbp
jmp 0x7577
leaq 0x2cd0f(%rip), %rdi     # 0x43b5e
leaq 0x2ca36(%rip), %rsi     # 0x4388c
leaq 0x2ce33(%rip), %rcx     # 0x43c90
movl $0x19d, %edx            # imm = 0x19D
callq 0x30a0
leaq 0x2ce76(%rip), %rdi     # 0x43ce4
leaq 0x2ca17(%rip), %rsi     # 0x4388c
leaq 0x2ce14(%rip), %rcx     # 0x43c90
movl $0x19e, %edx            # imm = 0x19E
callq 0x30a0
leaq 0x2ce7d(%rip), %rdi     # 0x43d0a
leaq 0x2c9f8(%rip), %rsi     # 0x4388c
leaq 0x2cdf5(%rip), %rcx     # 0x43c90
movl $0x19f, %edx            # imm = 0x19F
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x18d0e
movq %rdi, %r15
cmpq $0x0, 0x8(%rdi)
je 0x18d2d
movq %rsi, %r14
testq %rsi, %rsi
je 0x18d4c
movl $0x48, %edi
callq 0x3120
testq %rax, %rax
je 0x18d6b
movq %rax, %rbx
movq %r15, (%rax)
movq %r14, 0x8(%rax)
callq 0x7745
movq %rax, %r14
movq %rax, 0x10(%rbx)
callq 0x7745
movq %rax, %r15
movq %rax, 0x18(%rbx)
callq 0x7745
movq %rax, %r12
movq %rax, 0x20(%rbx)
callq 0x7745
movq %rax, %r13
movq %rax, 0x28(%rbx)
movq $0x0, 0x30(%rbx)
movq %r14, %rdi
callq 0x7354
movq %r15, %rdi
callq 0x7354
movq %r12, %rdi
callq 0x7354
movq %r13, %rdi
callq 0x7354
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 0x2869b(%rip), %rdi     # 0x413b0
leaq 0x2bc28(%rip), %rsi     # 0x44944
leaq 0x2bd33(%rip), %rcx     # 0x44a56
movl $0x1498, %edx           # imm = 0x1498
callq 0x30a0
leaq 0x28688(%rip), %rdi     # 0x413bc
leaq 0x2bc09(%rip), %rsi     # 0x44944
leaq 0x2bd14(%rip), %rcx     # 0x44a56
movl $0x1499, %edx           # imm = 0x1499
callq 0x30a0
leaq 0x286a3(%rip), %rdi     # 0x413f6
leaq 0x2bbea(%rip), %rsi     # 0x44944
leaq 0x2bcf5(%rip), %rcx     # 0x44a56
movl $0x149a, %edx           # imm = 0x149A
callq 0x30a0
callq 0x3231
// File: /workspace/github_c_makefile_star2_O3/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 0x19b77
movq %rdi, %rbx
callq 0x7354
leaq 0x10(%rbx), %rdi
callq 0x7354
leaq 0x20(%rbx), %rdi
callq 0x7354
leaq 0x30(%rbx), %rdi
callq 0x7354
leaq 0x40(%rbx), %rdi
callq 0x7354
leaq 0x50(%rbx), %rdi
callq 0x7354
leaq 0x60(%rbx), %rdi
callq 0x7354
addq $0x70, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x7354
leaq 0x28056(%rip), %rdi     # 0x41bd4
leaq 0x2adbf(%rip), %rsi     # 0x44944
leaq 0x28054(%rip), %rcx     # 0x41be0
movl $0x57, %edx
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x1a458
movq %rdi, %rbx
callq 0x7852
leaq 0x10(%rbx), %rdi
callq 0x7852
leaq 0x20(%rbx), %rdi
callq 0x7852
leaq 0x30(%rbx), %rdi
callq 0x7852
leaq 0x40(%rbx), %rdi
callq 0x7852
leaq 0x50(%rbx), %rdi
callq 0x7852
leaq 0x60(%rbx), %rdi
callq 0x7852
addq $0x70, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x7852
leaq 0x27775(%rip), %rdi     # 0x41bd4
leaq 0x2a4de(%rip), %rsi     # 0x44944
leaq 0x28a2b(%rip), %rcx     # 0x42e98
movl $0xc4, %edx
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x1c8cf
cmpl $0xe90, %eax            # imm = 0xE90
jne 0x1c8e1
cmpl $0x2, 0x44(%r8)
jne 0x1c8e5
xorl %edx, %edx
callq 0x1f554
jmp 0x1c8dd
cmpl $0x2, 0x44(%r8)
jne 0x1c904
xorl %edx, %edx
callq 0x1f7b3
movb $0x1, %al
jmp 0x1c8e3
xorl %eax, %eax
popq %rbp
retq
leaq 0x2e409(%rip), %rdi     # 0x4acf5
leaq 0x28051(%rip), %rsi     # 0x44944
leaq 0x28fc8(%rip), %rcx     # 0x458c2
movl $0xee4, %edx            # imm = 0xEE4
callq 0x30a0
leaq 0x2e3ea(%rip), %rdi     # 0x4acf5
leaq 0x28032(%rip), %rsi     # 0x44944
leaq 0x28fa9(%rip), %rcx     # 0x458c2
movl $0xeeb, %edx            # imm = 0xEEB
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x1df4f
movq %rdx, %rbx
testq %rdx, %rdx
je 0x1df6e
movq %rsi, %r15
movq %rdi, %r14
addq $0x20, %rdi
leaq 0x2716f(%rip), %rsi     # 0x4508c
movq %r15, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x7945
leaq 0x30(%r14), %rdi
movq %r15, %rsi
callq 0x73db
addq $0x40, %r14
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x73db
leaq 0x237b2(%rip), %rdi     # 0x41708
leaq 0x269e7(%rip), %rsi     # 0x44944
leaq 0x270e0(%rip), %rcx     # 0x45044
movl $0x6b, %edx
callq 0x30a0
leaq 0x23b74(%rip), %rdi     # 0x41ae9
leaq 0x269c8(%rip), %rsi     # 0x44944
leaq 0x270c1(%rip), %rcx     # 0x45044
movl $0x6c, %edx
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x1dfb9
testq %rsi, %rsi
je 0x1dfd8
movl 0x54(%rdi), %edx
leal 0x1(%rdx), %eax
movl %eax, 0x54(%rdi)
leaq 0x271bf(%rip), %rax     # 0x4516a
movq %rsi, %rdi
movq %rax, %rsi
xorl %eax, %eax
popq %rbp
jmp 0x7945
leaq 0x24fa7(%rip), %rdi     # 0x42f67
leaq 0x2697d(%rip), %rsi     # 0x44944
leaq 0x27143(%rip), %rcx     # 0x45111
movl $0xfb, %edx
callq 0x30a0
leaq 0x21a51(%rip), %rdi     # 0x3fa30
leaq 0x2695e(%rip), %rsi     # 0x44944
leaq 0x27124(%rip), %rcx     # 0x45111
movl $0xfc, %edx
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x1e05a
movq %rdx, %rbx
testq %rdx, %rdx
je 0x1e079
movq %rsi, %r15
movq %rdi, %r14
addq $0x50, %rdi
leaq 0x271a6(%rip), %rsi     # 0x451c5
movq %r15, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x7945
leaq 0x60(%r14), %rdi
leaq 0x27195(%rip), %rsi     # 0x451cc
movq %r15, %rdx
xorl %eax, %eax
callq 0x7945
addq $0x70, %r14
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x73db
leaq 0x236a7(%rip), %rdi     # 0x41708
leaq 0x268dc(%rip), %rsi     # 0x44944
leaq 0x2710a(%rip), %rcx     # 0x45179
movl $0x99, %edx
callq 0x30a0
leaq 0x23a69(%rip), %rdi     # 0x41ae9
leaq 0x268bd(%rip), %rsi     # 0x44944
leaq 0x270eb(%rip), %rcx     # 0x45179
movl $0x9a, %edx
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x1fe94
testq %rdx, %rdx
je 0x1feb3
movq %rcx, %r15
testq %rcx, %rcx
je 0x1fed2
movq %rdx, -0x30(%rbp)
testq %r8, %r8
je 0x1fef1
movq %rsi, %r14
movq %rdi, %r12
movb 0x60(%r8), %bl
leaq -0x40(%rbp), %r13
movq %r13, %rdi
callq 0x7354
movq 0x40(%r12), %rdi
movq %r13, %rsi
callq 0x1df8d
movzbl %bl, %r12d
movl %r12d, %edi
callq 0x2a465
testb %al, %al
je 0x1fe25
leaq 0x2606b(%rip), %rsi     # 0x45e8e
jmp 0x1fe3c
movl %r12d, %edi
callq 0x2a496
testb %al, %al
je 0x1ff10
leaq 0x26066(%rip), %rsi     # 0x45ea2
leaq -0x40(%rbp), %r12
movq 0x8(%r12), %rdx
testq %rdx, %rdx
leaq 0x230b7(%rip), %rbx     # 0x42f06
cmoveq %rbx, %rdx
movq 0x28(%r15), %rcx
testq %rcx, %rcx
cmoveq %rbx, %rcx
movq %r14, %rdi
xorl %eax, %eax
callq 0x7945
movq 0x8(%r12), %rsi
testq %rsi, %rsi
cmoveq %rbx, %rsi
movq -0x30(%rbp), %rdi
callq 0x73db
movq %r12, %rdi
callq 0x7852
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1fb95(%rip), %rdi     # 0x3fa30
leaq 0x24aa2(%rip), %rsi     # 0x44944
leaq 0x25f66(%rip), %rcx     # 0x45e0f
movl $0x51b, %edx            # imm = 0x51B
callq 0x30a0
leaq 0x22d7f(%rip), %rdi     # 0x42c39
leaq 0x24a83(%rip), %rsi     # 0x44944
leaq 0x25f47(%rip), %rcx     # 0x45e0f
movl $0x51c, %edx            # imm = 0x51C
callq 0x30a0
leaq 0x21cfb(%rip), %rdi     # 0x41bd4
leaq 0x24a64(%rip), %rsi     # 0x44944
leaq 0x25f28(%rip), %rcx     # 0x45e0f
movl $0x51d, %edx            # imm = 0x51D
callq 0x30a0
leaq 0x22d51(%rip), %rdi     # 0x42c49
leaq 0x24a45(%rip), %rsi     # 0x44944
leaq 0x25f09(%rip), %rcx     # 0x45e0f
movl $0x51e, %edx            # imm = 0x51E
callq 0x30a0
leaq 0x1f449(%rip), %rdi     # 0x3f360
leaq 0x24a26(%rip), %rsi     # 0x44944
leaq 0x25eea(%rip), %rcx     # 0x45e0f
movl $0x533, %edx            # imm = 0x533
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x213ab
testq %rsi, %rsi
je 0x213ca
testl %edx, %edx
js 0x213e9
leaq 0x36d8b(%rip), %rcx     # 0x58130
popq %rbp
jmp 0x3ef8
leaq 0x1d647(%rip), %rdi     # 0x3e9f9
leaq 0x2522f(%rip), %rsi     # 0x465e8
leaq 0x25242(%rip), %rcx     # 0x46602
movl $0x156, %edx            # imm = 0x156
callq 0x30a0
leaq 0x1d155(%rip), %rdi     # 0x3e526
leaq 0x25210(%rip), %rsi     # 0x465e8
leaq 0x25223(%rip), %rcx     # 0x46602
movl $0x157, %edx            # imm = 0x157
callq 0x30a0
leaq 0x1d13d(%rip), %rdi     # 0x3e52d
leaq 0x251f1(%rip), %rsi     # 0x465e8
leaq 0x25204(%rip), %rcx     # 0x46602
movl $0x158, %edx            # imm = 0x158
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x21496
testq %rsi, %rsi
je 0x214b5
movl $0xfffff000, %eax       # imm = 0xFFFFF000
addl (%rsi), %eax
cmpl $0x3, %eax
ja 0x214d4
leaq 0x2516f(%rip), %rcx     # 0x465c8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0xa013
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0xa245
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0xa3e3
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0xa132
leaq 0x1f917(%rip), %rdi     # 0x40db4
leaq 0x25144(%rip), %rsi     # 0x465e8
leaq 0x251c6(%rip), %rcx     # 0x46671
movl $0x167, %edx            # imm = 0x167
callq 0x30a0
leaq 0x2a320(%rip), %rdi     # 0x4b7dc
leaq 0x25125(%rip), %rsi     # 0x465e8
leaq 0x251a7(%rip), %rcx     # 0x46671
movl $0x168, %edx            # imm = 0x168
callq 0x30a0
leaq 0x1de85(%rip), %rdi     # 0x3f360
leaq 0x25106(%rip), %rsi     # 0x465e8
leaq 0x25188(%rip), %rcx     # 0x46671
movl $0x178, %edx            # imm = 0x178
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x21555
testq %rsi, %rsi
je 0x21574
movl $0xfffff000, %eax       # imm = 0xFFFFF000
addl (%rsi), %eax
cmpl $0x3, %eax
ja 0x21593
leaq 0x250c0(%rip), %rcx     # 0x465d8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0x9f74
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0xa1ad
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0xa2c0
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0xa08e
leaq 0x1f858(%rip), %rdi     # 0x40db4
leaq 0x25085(%rip), %rsi     # 0x465e8
leaq 0x25146(%rip), %rcx     # 0x466b0
movl $0x183, %edx            # imm = 0x183
callq 0x30a0
leaq 0x2a261(%rip), %rdi     # 0x4b7dc
leaq 0x25066(%rip), %rsi     # 0x465e8
leaq 0x25127(%rip), %rcx     # 0x466b0
movl $0x184, %edx            # imm = 0x184
callq 0x30a0
leaq 0x1ddc6(%rip), %rdi     # 0x3f360
leaq 0x25047(%rip), %rsi     # 0x465e8
leaq 0x25108(%rip), %rcx     # 0x466b0
movl $0x194, %edx            # imm = 0x194
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x215d5
testq %rsi, %rsi
je 0x215f4
cmpl $0x1004, (%rsi)         # imm = 0x1004
jne 0x21613
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0xa56b
leaq 0x1f7d8(%rip), %rdi     # 0x40db4
leaq 0x25005(%rip), %rsi     # 0x465e8
leaq 0x25105(%rip), %rcx     # 0x466ef
movl $0x19f, %edx            # imm = 0x19F
callq 0x30a0
leaq 0x2a1e1(%rip), %rdi     # 0x4b7dc
leaq 0x24fe6(%rip), %rsi     # 0x465e8
leaq 0x250e6(%rip), %rcx     # 0x466ef
movl $0x1a0, %edx            # imm = 0x1A0
callq 0x30a0
leaq 0x1dd46(%rip), %rdi     # 0x3f360
leaq 0x24fc7(%rip), %rsi     # 0x465e8
leaq 0x250c7(%rip), %rcx     # 0x466ef
movl $0x1a5, %edx            # imm = 0x1A5
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x21655
testq %rsi, %rsi
je 0x21674
cmpl $0x1004, (%rsi)         # imm = 0x1004
jne 0x21693
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0xa45e
leaq 0x1f758(%rip), %rdi     # 0x40db4
leaq 0x24f85(%rip), %rsi     # 0x465e8
leaq 0x250c0(%rip), %rcx     # 0x4672a
movl $0x1af, %edx            # imm = 0x1AF
callq 0x30a0
leaq 0x2a161(%rip), %rdi     # 0x4b7dc
leaq 0x24f66(%rip), %rsi     # 0x465e8
leaq 0x250a1(%rip), %rcx     # 0x4672a
movl $0x1b0, %edx            # imm = 0x1B0
callq 0x30a0
leaq 0x1dcc6(%rip), %rdi     # 0x3f360
leaq 0x24f47(%rip), %rsi     # 0x465e8
leaq 0x25082(%rip), %rcx     # 0x4672a
movl $0x1b5, %edx            # imm = 0x1B5
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x216d5
testq %rsi, %rsi
je 0x216f4
cmpl $0x1005, (%rsi)         # imm = 0x1005
jne 0x21713
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0x9dff
leaq 0x1f6d8(%rip), %rdi     # 0x40db4
leaq 0x24f05(%rip), %rsi     # 0x465e8
leaq 0x2507d(%rip), %rcx     # 0x46767
movl $0x1bf, %edx            # imm = 0x1BF
callq 0x30a0
leaq 0x2a0e1(%rip), %rdi     # 0x4b7dc
leaq 0x24ee6(%rip), %rsi     # 0x465e8
leaq 0x2505e(%rip), %rcx     # 0x46767
movl $0x1c0, %edx            # imm = 0x1C0
callq 0x30a0
leaq 0x1dc46(%rip), %rdi     # 0x3f360
leaq 0x24ec7(%rip), %rsi     # 0x465e8
leaq 0x2503f(%rip), %rcx     # 0x46767
movl $0x1c5, %edx            # imm = 0x1C5
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x217dd
testq %rsi, %rsi
je 0x217fc
movl (%rsi), %eax
andl $-0x4, %eax
cmpl $0x1000, %eax           # imm = 0x1000
jne 0x2181b
movq 0x8(%rsi), %rax
movslq 0x4(%rsi), %rcx
cmpb $0x75, -0x1(%rax,%rcx)
sete %al
popq %rbp
retq
leaq 0x1f5d0(%rip), %rdi     # 0x40db4
leaq 0x24dfd(%rip), %rsi     # 0x465e8
leaq 0x25005(%rip), %rcx     # 0x467f7
movl $0x1dc, %edx            # imm = 0x1DC
callq 0x30a0
leaq 0x29fd9(%rip), %rdi     # 0x4b7dc
leaq 0x24dde(%rip), %rsi     # 0x465e8
leaq 0x24fe6(%rip), %rcx     # 0x467f7
movl $0x1dd, %edx            # imm = 0x1DD
callq 0x30a0
leaq 0x25014(%rip), %rdi     # 0x46836
leaq 0x24dbf(%rip), %rsi     # 0x465e8
leaq 0x24fc7(%rip), %rcx     # 0x467f7
movl $0x1e3, %edx            # imm = 0x1E3
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x21862
testq %rsi, %rsi
je 0x21881
cmpl $0x1004, (%rsi)         # imm = 0x1004
jne 0x218a0
movq 0x8(%rsi), %rax
movslq 0x4(%rsi), %rcx
cmpb $0x66, -0x1(%rax,%rcx)
sete %al
popq %rbp
retq
leaq 0x1f54b(%rip), %rdi     # 0x40db4
leaq 0x24d78(%rip), %rsi     # 0x465e8
leaq 0x2506c(%rip), %rcx     # 0x468e3
movl $0x1ec, %edx            # imm = 0x1EC
callq 0x30a0
leaq 0x29f54(%rip), %rdi     # 0x4b7dc
leaq 0x24d59(%rip), %rsi     # 0x465e8
leaq 0x2504d(%rip), %rcx     # 0x468e3
movl $0x1ed, %edx            # imm = 0x1ED
callq 0x30a0
leaq 0x25078(%rip), %rdi     # 0x4691f
leaq 0x24d3a(%rip), %rsi     # 0x465e8
leaq 0x2502e(%rip), %rcx     # 0x468e3
movl $0x1ee, %edx            # imm = 0x1EE
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x23f89
movq %rdi, %rbx
movl $0xfffff4e0, %eax       # imm = 0xFFFFF4E0
addl (%rdi), %eax
cmpl $0x20, %eax
ja 0x23fa8
movabsq $0x100010001, %rcx      # imm = 0x100010001
btq %rax, %rcx
jae 0x23fa8
leaq 0x60(%rbx), %rdi
callq 0x7852
addq $0x70, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x7852
leaq 0x1ee52(%rip), %rdi     # 0x42de2
leaq 0x24455(%rip), %rsi     # 0x483ec
leaq 0x24469(%rip), %rcx     # 0x48407
movl $0x16, %edx
callq 0x30a0
leaq 0x2448e(%rip), %rdi     # 0x4843d
leaq 0x24436(%rip), %rsi     # 0x483ec
leaq 0x2444a(%rip), %rcx     # 0x48407
movl $0x19, %edx
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x24245
testq %rsi, %rsi
je 0x24264
testl %edx, %edx
js 0x24283
movl %ecx, %ebx
callq 0x2138c
movq %rax, %r14
movq %rax, %rdi
callq 0x47f7
xorps %xmm0, %xmm0
leaq -0x20(%rbp), %rdx
movaps %xmm0, (%rdx)
movl $0x10, %esi
movq %r14, %rdi
callq 0x60e8
movl %ebx, 0x30(%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1a7ad(%rip), %rdi     # 0x3e9f9
leaq 0x24199(%rip), %rsi     # 0x483ec
leaq 0x24247(%rip), %rcx     # 0x484a1
movl $0x8aa, %edx            # imm = 0x8AA
callq 0x30a0
leaq 0x1a2bb(%rip), %rdi     # 0x3e526
leaq 0x2417a(%rip), %rsi     # 0x483ec
leaq 0x24228(%rip), %rcx     # 0x484a1
movl $0x8ab, %edx            # imm = 0x8AB
callq 0x30a0
leaq 0x1a2a3(%rip), %rdi     # 0x3e52d
leaq 0x2415b(%rip), %rsi     # 0x483ec
leaq 0x24209(%rip), %rcx     # 0x484a1
movl $0x8ac, %edx            # imm = 0x8AC
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x24846
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x24865
testq %rsi, %rsi
je 0x24884
xorl %edx, %edx
popq %rbp
jmp 0x248a3
leaq 0x1c567(%rip), %rdi     # 0x40db4
leaq 0x23b98(%rip), %rsi     # 0x483ec
leaq 0x23cf5(%rip), %rcx     # 0x48550
movl $0x8eb, %edx            # imm = 0x8EB
callq 0x30a0
leaq 0x1cb53(%rip), %rdi     # 0x413bf
leaq 0x23b79(%rip), %rsi     # 0x483ec
leaq 0x23cd6(%rip), %rcx     # 0x48550
movl $0x8ec, %edx            # imm = 0x8EC
callq 0x30a0
leaq 0x1a16e(%rip), %rdi     # 0x3e9f9
leaq 0x23b5a(%rip), %rsi     # 0x483ec
leaq 0x23cb7(%rip), %rcx     # 0x48550
movl $0x8ed, %edx            # imm = 0x8ED
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x249a0
movl %edx, %ebx
testl %edx, %edx
js 0x249bf
movq %rsi, %r14
movq %rdi, %r15
je 0x248de
movl %ebx, %r12d
movl $0x9, %edi
movq %r14, %rsi
callq 0x30c0
decl %r12d
jne 0x248cc
movq 0x8(%r15), %rax
testq %rax, %rax
leaq 0x25537(%rip), %rdx     # 0x49e23
cmovneq %rax, %rdx
movl (%r15), %ecx
movq 0x30(%r15), %r8
leaq 0x25518(%rip), %rsi     # 0x49e16
movq %r14, %rdi
movq %r15, %r9
xorl %eax, %eax
callq 0x30f0
cmpq $0x0, 0x10(%r15)
je 0x24960
movl $0x28, %edi
movq %r14, %rsi
callq 0x30c0
movq 0x10(%r15), %rax
cmpl $0x0, 0x4(%rax)
jle 0x2494d
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 0x2492c
movl (%rax), %edx
leaq 0x254d1(%rip), %rsi     # 0x49e27
movq %r14, %rdi
xorl %eax, %eax
callq 0x30f0
movl $0xa, %edi
movq %r14, %rsi
callq 0x30c0
cmpl $0x0, 0x44(%r15)
jle 0x24997
incl %ebx
xorl %r12d, %r12d
movq 0x48(%r15), %rax
movq (%rax,%r12,8), %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x248a3
incq %r12
movslq 0x44(%r15), %rax
cmpq %rax, %r12
jl 0x24979
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1e43b(%rip), %rdi     # 0x42de2
leaq 0x23a3e(%rip), %rsi     # 0x483ec
leaq 0x25422(%rip), %rcx     # 0x49dd7
movl $0x8cc, %edx            # imm = 0x8CC
callq 0x30a0
leaq 0x25445(%rip), %rdi     # 0x49e0b
leaq 0x23a1f(%rip), %rsi     # 0x483ec
leaq 0x25403(%rip), %rcx     # 0x49dd7
movl $0x8ce, %edx            # imm = 0x8CE
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x24a01
testq %rsi, %rsi
je 0x24a20
cmpl $0x300, (%rsi)          # imm = 0x300
jne 0x24a3f
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
popq %rbp
jmp 0x21434
leaq 0x1c3ac(%rip), %rdi     # 0x40db4
leaq 0x239dd(%rip), %rsi     # 0x483ec
leaq 0x23b6c(%rip), %rcx     # 0x48582
movl $0x8f6, %edx            # imm = 0x8F6
callq 0x30a0
leaq 0x1e3bb(%rip), %rdi     # 0x42de2
leaq 0x239be(%rip), %rsi     # 0x483ec
leaq 0x23b4d(%rip), %rcx     # 0x48582
movl $0x8f7, %edx            # imm = 0x8F7
callq 0x30a0
leaq 0x23b80(%rip), %rdi     # 0x485c6
leaq 0x2399f(%rip), %rsi     # 0x483ec
leaq 0x23b2e(%rip), %rcx     # 0x48582
movl $0x8f8, %edx            # imm = 0x8F8
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x24a81
testq %rsi, %rsi
je 0x24aa0
cmpl $0x300, (%rsi)          # imm = 0x300
jne 0x24abf
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
popq %rbp
jmp 0x214f3
leaq 0x1c32c(%rip), %rdi     # 0x40db4
leaq 0x2395d(%rip), %rsi     # 0x483ec
leaq 0x23b53(%rip), %rcx     # 0x485e9
movl $0x901, %edx            # imm = 0x901
callq 0x30a0
leaq 0x1e33b(%rip), %rdi     # 0x42de2
leaq 0x2393e(%rip), %rsi     # 0x483ec
leaq 0x23b34(%rip), %rcx     # 0x485e9
movl $0x902, %edx            # imm = 0x902
callq 0x30a0
leaq 0x23b00(%rip), %rdi     # 0x485c6
leaq 0x2391f(%rip), %rsi     # 0x483ec
leaq 0x23b15(%rip), %rcx     # 0x485e9
movl $0x903, %edx            # imm = 0x903
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/frontend/parser.c
// Function: fe_parser_get_uint_val
uint64_t fe_parser_get_uint_val(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == FE_NODE_LITERAL_UINT);

	int arch = ctx->arch;
	if (arch == FE_ARCH_32) {
		return fe_parser_get_uint32_val(ctx, node);
	} else if (arch == FE_ARCH_64) {
		return fe_parser_get_uint64_val(ctx, node);
	} else {
		assert(0);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x24b10
testq %rsi, %rsi
je 0x24b2f
cmpl $0x300, (%rsi)          # imm = 0x300
jne 0x24b4e
movl 0x30(%rdi), %eax
cmpl $0x2, %eax
je 0x24b0a
cmpl $0x1, %eax
jne 0x24b6d
callq 0x249de
movl %eax, %eax
popq %rbp
retq
popq %rbp
jmp 0x24a5e
leaq 0x1c29d(%rip), %rdi     # 0x40db4
leaq 0x238ce(%rip), %rsi     # 0x483ec
leaq 0x23b08(%rip), %rcx     # 0x4862d
movl $0x90c, %edx            # imm = 0x90C
callq 0x30a0
leaq 0x1e2ac(%rip), %rdi     # 0x42de2
leaq 0x238af(%rip), %rsi     # 0x483ec
leaq 0x23ae9(%rip), %rcx     # 0x4862d
movl $0x90d, %edx            # imm = 0x90D
callq 0x30a0
leaq 0x23a71(%rip), %rdi     # 0x485c6
leaq 0x23890(%rip), %rsi     # 0x483ec
leaq 0x23aca(%rip), %rcx     # 0x4862d
movl $0x90e, %edx            # imm = 0x90E
callq 0x30a0
leaq 0x1a7ec(%rip), %rdi     # 0x3f360
leaq 0x23871(%rip), %rsi     # 0x483ec
leaq 0x23aab(%rip), %rcx     # 0x4862d
movl $0x916, %edx            # imm = 0x916
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/frontend/parser.c
// Function: fe_parser_get_float_val
float fe_parser_get_float_val(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == FE_NODE_LITERAL_REAL);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x24baf
testq %rsi, %rsi
je 0x24bce
cmpl $0x301, (%rsi)          # imm = 0x301
jne 0x24bed
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
popq %rbp
jmp 0x215b2
leaq 0x1c1fe(%rip), %rdi     # 0x40db4
leaq 0x2382f(%rip), %rsi     # 0x483ec
leaq 0x23aab(%rip), %rcx     # 0x4866f
movl $0x91e, %edx            # imm = 0x91E
callq 0x30a0
leaq 0x1e20d(%rip), %rdi     # 0x42de2
leaq 0x23810(%rip), %rsi     # 0x483ec
leaq 0x23a8c(%rip), %rcx     # 0x4866f
movl $0x91f, %edx            # imm = 0x91F
callq 0x30a0
leaq 0x23abb(%rip), %rdi     # 0x486af
leaq 0x237f1(%rip), %rsi     # 0x483ec
leaq 0x23a6d(%rip), %rcx     # 0x4866f
movl $0x920, %edx            # imm = 0x920
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/frontend/parser.c
// Function: fe_parser_get_double_val
double fe_parser_get_double_val(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == FE_NODE_LITERAL_REAL);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x24c2f
testq %rsi, %rsi
je 0x24c4e
cmpl $0x301, (%rsi)          # imm = 0x301
jne 0x24c6d
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
popq %rbp
jmp 0x21632
leaq 0x1c17e(%rip), %rdi     # 0x40db4
leaq 0x237af(%rip), %rsi     # 0x483ec
leaq 0x23a8e(%rip), %rcx     # 0x486d2
movl $0x929, %edx            # imm = 0x929
callq 0x30a0
leaq 0x1e18d(%rip), %rdi     # 0x42de2
leaq 0x23790(%rip), %rsi     # 0x483ec
leaq 0x23a6f(%rip), %rcx     # 0x486d2
movl $0x92a, %edx            # imm = 0x92A
callq 0x30a0
leaq 0x23a3b(%rip), %rdi     # 0x486af
leaq 0x23771(%rip), %rsi     # 0x483ec
leaq 0x23a50(%rip), %rcx     # 0x486d2
movl $0x92b, %edx            # imm = 0x92B
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/frontend/parser.c
// Function: fe_parser_get_char_val
char fe_parser_get_char_val(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == FE_NODE_LITERAL_CHAR);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x24caf
testq %rsi, %rsi
je 0x24cce
cmpl $0x302, (%rsi)          # imm = 0x302
jne 0x24ced
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
popq %rbp
jmp 0x216b2
leaq 0x1c0fe(%rip), %rdi     # 0x40db4
leaq 0x2372f(%rip), %rsi     # 0x483ec
leaq 0x23a50(%rip), %rcx     # 0x48714
movl $0x934, %edx            # imm = 0x934
callq 0x30a0
leaq 0x1e10d(%rip), %rdi     # 0x42de2
leaq 0x23710(%rip), %rsi     # 0x483ec
leaq 0x23a31(%rip), %rcx     # 0x48714
movl $0x935, %edx            # imm = 0x935
callq 0x30a0
leaq 0x23a5e(%rip), %rdi     # 0x48752
leaq 0x236f1(%rip), %rsi     # 0x483ec
leaq 0x23a12(%rip), %rcx     # 0x48714
movl $0x936, %edx            # imm = 0x936
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/frontend/parser.c
// Function: fe_parser_add_var_symbol_to_node
ParserSymbol * fe_parser_add_var_symbol_to_node(
	ParserContext *ctx,
	ParserASTNode *node,
	LexerToken *token,
	uint8_t var_type,
	ParserASTNode *var_type_node
) {
	assert(ctx);
	assert(node);
	assert(token);
	assert(var_type > 0);
	assert(var_type_node);

	FeParserVarSymbolData data;
	data.type = var_type;
	data.type_node = var_type_node;
	data.func_symbol = NULL;
	data.has_code_gen_name = false;

	ParserSymbol *symbol = parser_add_symbol_to_node(
		ctx,
		node,
		FE_SYM_VAR,
		token,
		sizeof(data),
		&data
	);
	symbol->releaser = _var_symbol_releaser;

	return symbol;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
testq %rdi, %rdi
je 0x24daf
testq %rsi, %rsi
je 0x24dce
movq %rdx, %rax
testq %rdx, %rdx
je 0x24ded
testb %cl, %cl
je 0x24e0c
testq %r8, %r8
je 0x24e2b
leaq -0x38(%rbp), %r9
movb %cl, (%r9)
movq %r8, 0x8(%r9)
movq $0x0, 0x10(%r9)
movb $0x0, 0x18(%r9)
movl $0x38, %r8d
movl $0x1, %edx
movq %rax, %rcx
callq 0x6d30
leaq -0x99(%rip), %rcx       # 0x24d0c
movq %rcx, 0x20(%rax)
addq $0x40, %rsp
popq %rbp
retq
leaq 0x1bffe(%rip), %rdi     # 0x40db4
leaq 0x2362f(%rip), %rsi     # 0x483ec
leaq 0x239db(%rip), %rcx     # 0x4879f
movl $0x94d, %edx            # imm = 0x94D
callq 0x30a0
leaq 0x1e00d(%rip), %rdi     # 0x42de2
leaq 0x23610(%rip), %rsi     # 0x483ec
leaq 0x239bc(%rip), %rcx     # 0x4879f
movl $0x94e, %edx            # imm = 0x94E
callq 0x30a0
leaq 0x269e8(%rip), %rdi     # 0x4b7dc
leaq 0x235f1(%rip), %rsi     # 0x483ec
leaq 0x2399d(%rip), %rcx     # 0x4879f
movl $0x94f, %edx            # imm = 0x94F
callq 0x30a0
leaq 0x23a05(%rip), %rdi     # 0x48818
leaq 0x235d2(%rip), %rsi     # 0x483ec
leaq 0x2397e(%rip), %rcx     # 0x4879f
movl $0x950, %edx            # imm = 0x950
callq 0x30a0
leaq 0x239f3(%rip), %rdi     # 0x48825
leaq 0x235b3(%rip), %rsi     # 0x483ec
leaq 0x2395f(%rip), %rcx     # 0x4879f
movl $0x951, %edx            # imm = 0x951
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/frontend/parser.c
// Function: fe_parser_add_struct_member_var_symbol_to_symbol
ParserSymbol * fe_parser_add_struct_member_var_symbol_to_symbol(
	ParserContext *ctx,
	ParserSymbol *symbol,
	LexerToken *token,
	uint8_t var_type,
	ParserASTNode *var_type_node
) {
	assert(ctx);
	assert(symbol);
	assert(token);
	assert(var_type > 0);
	assert(var_type_node);

	FeParserStructMemberVarSymbolData data;
	data.type = var_type;
	data.type_node = var_type_node;

	return parser_add_symbol_to_symbol(
		ctx,
		symbol,
		FE_SYM_STRUCT_MEMBER_VAR,
		token,
		sizeof(data),
		&data
	);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
testq %rdi, %rdi
je 0x24e99
testq %rsi, %rsi
je 0x24eb8
movq %rdx, %rax
testq %rdx, %rdx
je 0x24ed7
testb %cl, %cl
je 0x24ef6
testq %r8, %r8
je 0x24f15
leaq -0x10(%rbp), %r9
movb %cl, (%r9)
movq %r8, 0x8(%r9)
movl $0x10, %r8d
movl $0x5, %edx
movq %rax, %rcx
callq 0x7069
addq $0x10, %rsp
popq %rbp
retq
leaq 0x1bf14(%rip), %rdi     # 0x40db4
leaq 0x23545(%rip), %rsi     # 0x483ec
leaq 0x23985(%rip), %rcx     # 0x48833
movl $0x96d, %edx            # imm = 0x96D
callq 0x30a0
leaq 0x1e0ad(%rip), %rdi     # 0x42f6c
leaq 0x23526(%rip), %rsi     # 0x483ec
leaq 0x23966(%rip), %rcx     # 0x48833
movl $0x96e, %edx            # imm = 0x96E
callq 0x30a0
leaq 0x268fe(%rip), %rdi     # 0x4b7dc
leaq 0x23507(%rip), %rsi     # 0x483ec
leaq 0x23947(%rip), %rcx     # 0x48833
movl $0x96f, %edx            # imm = 0x96F
callq 0x30a0
leaq 0x2391b(%rip), %rdi     # 0x48818
leaq 0x234e8(%rip), %rsi     # 0x483ec
leaq 0x23928(%rip), %rcx     # 0x48833
movl $0x970, %edx            # imm = 0x970
callq 0x30a0
leaq 0x23909(%rip), %rdi     # 0x48825
leaq 0x234c9(%rip), %rsi     # 0x483ec
leaq 0x23909(%rip), %rcx     # 0x48833
movl $0x971, %edx            # imm = 0x971
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/frontend/parser.c
// Function: fe_parser_new_struct_symbol
ParserSymbol * fe_parser_new_struct_symbol(
	ParserContext *ctx,
	LexerToken *token,
	ParserASTNode *struct_node,
	ParserASTNode *body_node,
	bool dummy
) {
	assert(ctx);
	assert(token);
	assert(body_node);

	FeParserStructSymbolData data;
	data.struct_node = struct_node;
	data.body_node = body_node;
	data.dummy = dummy;

	return parser_new_symbol(
		ctx,
		FE_SYM_STRUCT,
		token,
		sizeof(data),
		&data
	);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
testq %rdi, %rdi
je 0x24f78
movq %rsi, %rax
testq %rsi, %rsi
je 0x24f97
testq %rcx, %rcx
je 0x24fb6
leaq -0x18(%rbp), %r9
movq %rdx, (%r9)
movq %rcx, 0x8(%r9)
movb %r8b, 0x10(%r9)
movl $0x18, %ecx
movl $0x2, %esi
movq %rax, %rdx
movq %r9, %r8
callq 0x69fb
addq $0x20, %rsp
popq %rbp
retq
leaq 0x1be35(%rip), %rdi     # 0x40db4
leaq 0x23466(%rip), %rsi     # 0x483ec
leaq 0x2392e(%rip), %rcx     # 0x488bb
movl $0x988, %edx            # imm = 0x988
callq 0x30a0
leaq 0x2683e(%rip), %rdi     # 0x4b7dc
leaq 0x23447(%rip), %rsi     # 0x483ec
leaq 0x2390f(%rip), %rcx     # 0x488bb
movl $0x989, %edx            # imm = 0x989
callq 0x30a0
leaq 0x25e37(%rip), %rdi     # 0x4adf4
leaq 0x23428(%rip), %rsi     # 0x483ec
leaq 0x238f0(%rip), %rcx     # 0x488bb
movl $0x98a, %edx            # imm = 0x98A
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/frontend/parser.c
// Function: fe_parser_add_struct_symbol_to_node
ParserSymbol * fe_parser_add_struct_symbol_to_node(
	ParserContext *ctx,
	ParserASTNode *node,
	LexerToken *token,
	ParserASTNode *body_node,
	bool dummy
) {
	assert(ctx);
	assert(node);
	assert(token);
	assert(body_node);

	FeParserStructSymbolData data;
	data.body_node = body_node;
	data.dummy = dummy;

	return parser_add_symbol_to_node(
		ctx,
		node,
		FE_SYM_STRUCT,
		token,
		sizeof(data),
		&data
	);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
testq %rdi, %rdi
je 0x2501d
testq %rsi, %rsi
je 0x2503c
movq %rdx, %rax
testq %rdx, %rdx
je 0x2505b
testq %rcx, %rcx
je 0x2507a
leaq -0x18(%rbp), %r9
movq %rcx, 0x8(%r9)
movb %r8b, 0x10(%r9)
movl $0x18, %r8d
movl $0x2, %edx
movq %rax, %rcx
callq 0x6d30
addq $0x20, %rsp
popq %rbp
retq
leaq 0x1bd90(%rip), %rdi     # 0x40db4
leaq 0x233c1(%rip), %rsi     # 0x483ec
leaq 0x238fb(%rip), %rcx     # 0x4892d
movl $0x9a1, %edx            # imm = 0x9A1
callq 0x30a0
leaq 0x1dd9f(%rip), %rdi     # 0x42de2
leaq 0x233a2(%rip), %rsi     # 0x483ec
leaq 0x238dc(%rip), %rcx     # 0x4892d
movl $0x9a2, %edx            # imm = 0x9A2
callq 0x30a0
leaq 0x2677a(%rip), %rdi     # 0x4b7dc
leaq 0x23383(%rip), %rsi     # 0x483ec
leaq 0x238bd(%rip), %rcx     # 0x4892d
movl $0x9a3, %edx            # imm = 0x9A3
callq 0x30a0
leaq 0x25d73(%rip), %rdi     # 0x4adf4
leaq 0x23364(%rip), %rsi     # 0x483ec
leaq 0x2389e(%rip), %rcx     # 0x4892d
movl $0x9a4, %edx            # imm = 0x9A4
callq 0x30a0