LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]Uno/Src/uno_generic.c
// Function: same_expr
static int
same_expr(treenode *a, treenode *b)
{	leafnode *n, *m;

	if (!a && b) return 0;
	if (a && !b) return 0;
	if (a == b)  return 1;

	if (a->hdr.tok != b->hdr.tok
	||  a->hdr.which != b->hdr.which
	||  a->hdr.type != b->hdr.type)
		return 0;

	if (a->hdr.which == LEAF_T)
	{	n = (leafnode *) a;
		m = (leafnode *) b;

		switch (a->hdr.type) {
		case TN_INT:
			return n->data.ival == m->data.ival;
		case TN_REAL:
			return n->data.dval == m->data.dval;
		case TN_STRING:
			return n->data.sval->str == m->data.sval->str;
		case TN_IDENT:
			return (strcmp(n->data.sval->str, m->data.sval->str) == 0);
		case TN_TYPE:
			if (a->hdr.tok == TYPEDEF_NAME)
				return n->data.sval->str == m->data.sval->str;
			return (a->hdr.tok != b->hdr.tok);
		default:
			fprintf(stderr, "uno: %s:%d: %s:%d: cannot happen, same_expr: %s\n",
				a->hdr.fnm, a->hdr.line,
				b->hdr.fnm, b->hdr.line,
				name_of_node(a->hdr.type));
			exit(1);
		}
	}

	return same_expr(a->lnode, b->lnode)
	&&     same_expr(a->rnode, b->rnode);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
testq %r14, %r14
sete %al
testq %rbx, %rbx
setne %cl
cmpb %cl, %al
je 0x1c268
cmpq %rbx, %r14
je 0x1c204
movl 0x18(%r14), %eax
cmpl 0x18(%rbx), %eax
jne 0x1c268
movl (%r14), %ecx
cmpl (%rbx), %ecx
jne 0x1c268
movl 0x1c(%r14), %edi
cmpl 0x1c(%rbx), %edi
jne 0x1c268
cmpl $0x1, %ecx
je 0x1c208
movq 0x40(%r14), %rdi
movq 0x40(%rbx), %rsi
callq 0x1c194
testl %eax, %eax
je 0x1c268
movq 0x48(%r14), %r14
movq 0x48(%rbx), %rbx
jmp 0x1c1a6
movb $0x1, %al
jmp 0x1c26a
leal -0x2d(%rdi), %ecx
cmpl $0x4, %ecx
ja 0x1c286
leaq 0x12d15(%rip), %rdx     # 0x2ef2c
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq 0x40(%r14), %rax
movq 0x8(%rax), %rdi
movq 0x40(%rbx), %rax
movq 0x8(%rax), %rsi
callq 0x3190
testl %eax, %eax
jmp 0x1c281
movsd 0x40(%rbx), %xmm0
cmpeqsd 0x40(%r14), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
jmp 0x1c26a
cmpl $0x105, %eax            # imm = 0x105
jne 0x1c268
movq 0x40(%r14), %rax
movq 0x8(%rax), %rax
movq 0x40(%rbx), %rcx
cmpq 0x8(%rcx), %rax
jmp 0x1c281
xorl %eax, %eax
movzbl %al, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl 0x40(%r14), %eax
cmpl 0x40(%rbx), %eax
sete %al
jmp 0x1c26a
movq 0x1ad6b(%rip), %rax     # 0x36ff8
movq (%rax), %r15
movq 0x8(%r14), %r12
movl 0x10(%r14), %ebp
movq 0x8(%rbx), %r14
movl 0x10(%rbx), %ebx
callq 0x66b2
movq %rax, (%rsp)
leaq 0x1311b(%rip), %rsi     # 0x2f3ca
movq %r15, %rdi
movq %r12, %rdx
movl %ebp, %ecx
movq %r14, %r8
movl %ebx, %r9d
xorl %eax, %eax
callq 0x31a0
pushq $0x1
popq %rdi
callq 0x3270
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/frontend/irgen.c
// Function: fe_irgen_new_context
IRGeneratorContext * fe_irgen_new_context(ParserContext *psrctx, FILE *out) {
	assert(psrctx);
	assert(psrctx->ast);
	assert(out);
	
	IRGeneratorContext *ctx = (IRGeneratorContext *)malloc(sizeof(IRGeneratorContext));
	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 0xb540
movq %rdi, %r15
cmpq $0x0, 0x8(%rdi)
je 0xb55f
movq %rsi, %r14
testq %rsi, %rsi
je 0xb57e
pushq $0x48
popq %rdi
callq 0x3110
testq %rax, %rax
je 0xb59d
movq %rax, %rbx
movq %r15, (%rax)
movq %r14, 0x8(%rax)
callq 0x71d5
movq %rax, %r14
movq %rax, 0x10(%rbx)
callq 0x71d5
movq %rax, %r15
movq %rax, 0x18(%rbx)
callq 0x71d5
movq %rax, %r12
movq %rax, 0x20(%rbx)
callq 0x71d5
movq %rax, %r13
movq %rax, 0x28(%rbx)
andq $0x0, 0x30(%rbx)
movq %r14, %rdi
callq 0x6e1c
movq %r15, %rdi
callq 0x6e1c
movq %r12, %rdi
callq 0x6e1c
movq %r13, %rdi
callq 0x6e1c
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 0x32e79(%rip), %rdi     # 0x3e3c0
leaq 0x32e26(%rip), %rsi     # 0x3e374
leaq 0x32eb5(%rip), %rcx     # 0x3e40a
movl $0x135c, %edx           # imm = 0x135C
callq 0x30a0
leaq 0x32e66(%rip), %rdi     # 0x3e3cc
leaq 0x32e07(%rip), %rsi     # 0x3e374
leaq 0x32e96(%rip), %rcx     # 0x3e40a
movl $0x135d, %edx           # imm = 0x135D
callq 0x30a0
leaq 0x32e81(%rip), %rdi     # 0x3e406
leaq 0x32de8(%rip), %rsi     # 0x3e374
leaq 0x32e77(%rip), %rcx     # 0x3e40a
movl $0x135e, %edx           # imm = 0x135E
callq 0x30a0
movq 0x49a54(%rip), %rax     # 0x54ff8
movq (%rax), %rdi
leaq 0x3510c(%rip), %rsi     # 0x406ba
leaq 0x32e97(%rip), %rdx     # 0x3e44c
xorl %eax, %eax
callq 0x30e0
pushq $0x1
popq %rdi
callq 0x3160
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/frontend/irgen.c
// Function: fe_irgen_free_context
void fe_irgen_free_context(IRGeneratorContext *ctx) {
	assert(ctx);
	assert(ctx->global);
	assert(ctx->head);
	assert(ctx->body);
	assert(ctx->foot);

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

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

	ctx->global = NULL;
	ctx->head = NULL;
	ctx->body = NULL;
	ctx->foot = NULL;

	free(ctx);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xb656
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0xb675
cmpq $0x0, 0x18(%rbx)
je 0xb694
cmpq $0x0, 0x20(%rbx)
je 0xb6b3
cmpq $0x0, 0x28(%rbx)
je 0xb6d2
callq 0x72b9
movq 0x18(%rbx), %rdi
callq 0x72b9
movq 0x20(%rbx), %rdi
callq 0x72b9
movq 0x28(%rbx), %rdi
callq 0x72b9
movq 0x10(%rbx), %rdi
callq 0x3190
movq 0x18(%rbx), %rdi
callq 0x3190
movq 0x20(%rbx), %rdi
callq 0x3190
movq 0x28(%rbx), %rdi
callq 0x3190
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3190
leaq 0x32767(%rip), %rdi     # 0x3ddc4
leaq 0x32d10(%rip), %rsi     # 0x3e374
leaq 0x32e0b(%rip), %rcx     # 0x3e476
movl $0x137a, %edx           # imm = 0x137A
callq 0x30a0
leaq 0x32e2b(%rip), %rdi     # 0x3e4a7
leaq 0x32cf1(%rip), %rsi     # 0x3e374
leaq 0x32dec(%rip), %rcx     # 0x3e476
movl $0x137b, %edx           # imm = 0x137B
callq 0x30a0
leaq 0x32e18(%rip), %rdi     # 0x3e4b3
leaq 0x32cd2(%rip), %rsi     # 0x3e374
leaq 0x32dcd(%rip), %rcx     # 0x3e476
movl $0x137c, %edx           # imm = 0x137C
callq 0x30a0
leaq 0x32e03(%rip), %rdi     # 0x3e4bd
leaq 0x32cb3(%rip), %rsi     # 0x3e374
leaq 0x32dae(%rip), %rcx     # 0x3e476
movl $0x137d, %edx           # imm = 0x137D
callq 0x30a0
leaq 0x32dee(%rip), %rdi     # 0x3e4c7
leaq 0x32c94(%rip), %rsi     # 0x3e374
leaq 0x32d8f(%rip), %rcx     # 0x3e476
movl $0x137e, %edx           # imm = 0x137E
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/frontend/irgen.c
// Function: ir_identifier_name
static void _ir_identifier_name(
	IRGeneratorContext *ctx,
	ResizableString *rstr,
	ParserASTNode *node_identifier
) {
	assert(ctx);
	assert(rstr);
	assert(node_identifier);

	rstr_append_with_char(rstr, '_');
	rstr_append_with_raw(rstr, node_identifier->token->content, node_identifier->token->len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xbd59
movq %rsi, %r14
testq %rsi, %rsi
je 0xbd72
movq %rdi, %rbx
pushq $0x5f
popq %rsi
callq 0x6f81
movq 0x10(%r14), %rax
movq 0x8(%rax), %rsi
movl 0x4(%rax), %edx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x700f
leaq 0x30cd0(%rip), %rdi     # 0x3ca30
leaq 0x3260d(%rip), %rsi     # 0x3e374
leaq 0x328fa(%rip), %rcx     # 0x3e668
pushq $0x7c
jmp 0xbd89
leaq 0x32942(%rip), %rdi     # 0x3e6bb
leaq 0x325f4(%rip), %rsi     # 0x3e374
leaq 0x328e1(%rip), %rcx     # 0x3e668
pushq $0x7d
popq %rdx
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/frontend/irgen.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_ptr));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xc1b4
movq %rdi, %rbx
callq 0x6e1c
leaq 0x10(%rbx), %rdi
callq 0x6e1c
leaq 0x20(%rbx), %rdi
callq 0x6e1c
addq $0x30, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x6e1c
leaq 0x32a29(%rip), %rdi     # 0x3ebe4
leaq 0x321b2(%rip), %rsi     # 0x3e374
leaq 0x32a27(%rip), %rcx     # 0x3ebf0
pushq $0x3b
popq %rdx
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/frontend/irgen.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_ptr));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xc91b
movq %rdi, %rbx
callq 0x72b9
leaq 0x10(%rbx), %rdi
callq 0x72b9
leaq 0x20(%rbx), %rdi
callq 0x72b9
addq $0x30, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x72b9
leaq 0x322c2(%rip), %rdi     # 0x3ebe4
leaq 0x31a4b(%rip), %rsi     # 0x3e374
leaq 0x33578(%rip), %rcx     # 0x3fea8
pushq $0x48
popq %rdx
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/frontend/irgen.c
// Function: ir_identifier_name_tk
static void _ir_identifier_name_tk(
	IRGeneratorContext *ctx,
	ResizableString *rstr,
	LexerToken *tk_identifier
) {
	assert(ctx);
	assert(rstr);
	assert(tk_identifier);

	rstr_append_with_char(rstr, '_');
	rstr_append_with_raw(rstr, tk_identifier->content, tk_identifier->len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xcbbb
movq %rsi, %r14
testq %rsi, %rsi
je 0xcbda
movq %rdi, %rbx
pushq $0x5f
popq %rsi
callq 0x6f81
movq 0x8(%r14), %rsi
movl 0x4(%r14), %edx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x700f
leaq 0x2fe6e(%rip), %rdi     # 0x3ca30
leaq 0x317ab(%rip), %rsi     # 0x3e374
leaq 0x31def(%rip), %rcx     # 0x3e9bf
movl $0x89, %edx
callq 0x30a0
leaq 0x31e31(%rip), %rdi     # 0x3ea12
leaq 0x3178c(%rip), %rsi     # 0x3e374
leaq 0x31dd0(%rip), %rcx     # 0x3e9bf
movl $0x8a, %edx
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/frontend/irgen.c
// Function: ir_expr_wrapper
static void _ir_expr_wrapper(
	IRGeneratorContext *ctx,
	ResizableString *rstr,
	_ExprResult *expr_result,
	ParserASTNode *node
) {
	assert(ctx);
	assert(rstr);
	assert(expr_result);
	assert(node);
	assert(node->type == FE_NODE_EXPR);
	assert(node->nchilds == 1);

	ParserASTNode *child = node->childs[0];
	_ir_expr(ctx, rstr, expr_result, child);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rsi, %rsi
je 0xcf3b
testq %rdx, %rdx
je 0xcf5a
testq %rcx, %rcx
je 0xcf79
cmpl $0xe00, (%rcx)          # imm = 0xE00
jne 0xcf98
cmpl $0x1, 0x44(%rcx)
jne 0xcfb7
movq 0x48(%rcx), %rax
movq (%rax), %rcx
popq %rbp
jmp 0xcfd6
leaq 0x2faee(%rip), %rdi     # 0x3ca30
leaq 0x3142b(%rip), %rsi     # 0x3e374
leaq 0x31cc6(%rip), %rcx     # 0x3ec16
movl $0xe4d, %edx            # imm = 0xE4D
callq 0x30a0
leaq 0x31c83(%rip), %rdi     # 0x3ebe4
leaq 0x3140c(%rip), %rsi     # 0x3e374
leaq 0x31ca7(%rip), %rcx     # 0x3ec16
movl $0xe4e, %edx            # imm = 0xE4E
callq 0x30a0
leaq 0x32e72(%rip), %rdi     # 0x3fdf2
leaq 0x313ed(%rip), %rsi     # 0x3e374
leaq 0x31c88(%rip), %rcx     # 0x3ec16
movl $0xe4f, %edx            # imm = 0xE4F
callq 0x30a0
leaq 0x31cd6(%rip), %rdi     # 0x3ec75
leaq 0x313ce(%rip), %rsi     # 0x3e374
leaq 0x31c69(%rip), %rcx     # 0x3ec16
movl $0xe50, %edx            # imm = 0xE50
callq 0x30a0
leaq 0x3b812(%rip), %rdi     # 0x487d0
leaq 0x313af(%rip), %rsi     # 0x3e374
leaq 0x31c4a(%rip), %rcx     # 0x3ec16
movl $0xe51, %edx            # imm = 0xE51
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/frontend/irgen.c
// Function: generate_func_tmp_ptr_var
static size_t _generate_func_tmp_ptr_var(
	IRGeneratorContext *ctx,
	ParserSymbol *func_symbol,
	ResizableString *rstr,
	ParserASTNode *node_type
) {
	assert(ctx);
	assert(func_symbol);
	assert(rstr);
	assert(node_type);

	ResizableString rstr_type;
	rstr_init(&rstr_type);
	_ir_type(ctx, &rstr_type, node_type);

	size_t no = _generate_func_tmp_ptr_var_cstr(ctx, func_symbol, rstr, RSTR_CSTR(&rstr_type));

	rstr_free(&rstr_type);

	return no;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdx, %rdx
je 0xfef9
movq %rcx, %r13
testq %rcx, %rcx
je 0xff18
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq -0x38(%rbp), %rbx
movq %rbx, %rdi
callq 0x6e1c
movq %rbx, %rdi
movq %r13, %rsi
callq 0xbd8f
movq 0x8(%rbx), %r13
testq %r13, %r13
leaq 0x3006b(%rip), %rax     # 0x3ff16
cmoveq %rax, %r13
movq %r15, %rdi
movq %r14, %rsi
callq 0xff37
movq 0x30(%r12), %rdi
movq 0x8(%r14), %rdx
testq %rdx, %rdx
leaq 0x30049(%rip), %rax     # 0x3ff16
cmoveq %rax, %rdx
leaq 0x2eef9(%rip), %rsi     # 0x3edd1
movq %r13, %rcx
xorl %eax, %eax
callq 0x739a
movq %rbx, %rdi
callq 0x72b9
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2cb30(%rip), %rdi     # 0x3ca30
leaq 0x2e46d(%rip), %rsi     # 0x3e374
leaq 0x2ee57(%rip), %rcx     # 0x3ed65
movl $0x1c9, %edx            # imm = 0x1C9
callq 0x30a0
leaq 0x2e7f4(%rip), %rdi     # 0x3e713
leaq 0x2e44e(%rip), %rsi     # 0x3e374
leaq 0x2ee38(%rip), %rcx     # 0x3ed65
movl $0x1ca, %edx            # imm = 0x1CA
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/frontend/irgen.c
// Function: generate_func_tmp
static size_t _generate_func_tmp(
	IRGeneratorContext *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 0xff63
testq %rsi, %rsi
je 0xff82
movl 0x54(%rdi), %edx
leal 0x1(%rdx), %eax
movl %eax, 0x54(%rdi)
leaq 0x2eedc(%rip), %rax     # 0x3ee31
movq %rsi, %rdi
movq %rax, %rsi
xorl %eax, %eax
popq %rbp
jmp 0x739a
leaq 0x3000d(%rip), %rdi     # 0x3ff77
leaq 0x2e403(%rip), %rsi     # 0x3e374
leaq 0x2ee66(%rip), %rcx     # 0x3edde
movl $0x168, %edx            # imm = 0x168
callq 0x30a0
leaq 0x2caa7(%rip), %rdi     # 0x3ca30
leaq 0x2e3e4(%rip), %rsi     # 0x3e374
leaq 0x2ee47(%rip), %rcx     # 0x3edde
movl $0x169, %edx            # imm = 0x169
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/frontend/irgen.c
// Function: generate_func_tmp_var
static size_t _generate_func_tmp_var(
	IRGeneratorContext *ctx,
	ParserSymbol *func_symbol,
	ResizableString *rstr,
	ParserASTNode *node_type
) {
	assert(ctx);
	assert(func_symbol);
	assert(rstr);
	assert(node_type);

	ResizableString rstr_type;
	rstr_init(&rstr_type);
	_ir_type(ctx, &rstr_type, node_type);

	size_t no = _generate_func_tmp_var_cstr(ctx, func_symbol, rstr, RSTR_CSTR(&rstr_type));

	rstr_free(&rstr_type);

	return no;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rsi, %rsi
je 0x1004b
movq %rdx, %rbx
testq %rdx, %rdx
je 0x1006a
movq %rcx, %r13
testq %rcx, %rcx
je 0x10089
movq %rsi, %r12
movq %rdi, %r15
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x6e1c
movq %r14, %rdi
movq %r13, %rsi
callq 0xbd8f
movq 0x8(%r14), %r13
testq %r13, %r13
leaq 0x2ff18(%rip), %rax     # 0x3ff16
cmoveq %rax, %r13
movq %r12, %rdi
movq %rbx, %rsi
callq 0xff37
movq 0x30(%r15), %rdi
movq 0x8(%rbx), %rdx
testq %rdx, %rdx
leaq 0x2fef7(%rip), %rax     # 0x3ff16
cmoveq %rax, %rdx
leaq 0x2f0a3(%rip), %rsi     # 0x3f0cd
movq %r13, %rcx
xorl %eax, %eax
callq 0x739a
movq %r14, %rdi
callq 0x72b9
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2ff25(%rip), %rdi     # 0x3ff77
leaq 0x2e31b(%rip), %rsi     # 0x3e374
leaq 0x2f005(%rip), %rcx     # 0x3f065
movl $0x1b2, %edx            # imm = 0x1B2
callq 0x30a0
leaq 0x2c9bf(%rip), %rdi     # 0x3ca30
leaq 0x2e2fc(%rip), %rsi     # 0x3e374
leaq 0x2efe6(%rip), %rcx     # 0x3f065
movl $0x1b3, %edx            # imm = 0x1B3
callq 0x30a0
leaq 0x2e683(%rip), %rdi     # 0x3e713
leaq 0x2e2dd(%rip), %rsi     # 0x3e374
leaq 0x2efc7(%rip), %rcx     # 0x3f065
movl $0x1b4, %edx            # imm = 0x1B4
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/frontend/irgen.c
// Function: const_int
static void _const_int(
	IRGeneratorContext *ctx,
	ResizableString *rstr,
	ParserASTNode *type,
	int v
) {
	assert(ctx);
	assert(rstr);
	assert(type);

	ResizableString rstr_type;
	rstr_init(&rstr_type);
	_ir_type(ctx, &rstr_type, type);

	rstr_appendf(
		rstr,
		"cast<%s>(%d)",
		RSTR_CSTR(&rstr_type),
		v
	);

	rstr_free(&rstr_type);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x11993
movq %rsi, %r15
testq %rsi, %rsi
je 0x119b2
movl %edx, %ebx
movq %rdi, %r14
leaq -0x30(%rbp), %r12
movq %r12, %rdi
callq 0x6e1c
movq %r12, %rdi
movq %r15, %rsi
callq 0xbd8f
movq 0x8(%r12), %rax
testq %rax, %rax
leaq 0x2e5af(%rip), %rdx     # 0x3ff16
cmovneq %rax, %rdx
leaq 0x2e251(%rip), %rsi     # 0x3fbc3
movq %r14, %rdi
movl %ebx, %ecx
xorl %eax, %eax
callq 0x739a
movq %r12, %rdi
callq 0x72b9
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2b096(%rip), %rdi     # 0x3ca30
leaq 0x2c9d3(%rip), %rsi     # 0x3e374
leaq 0x2e1cc(%rip), %rcx     # 0x3fb74
movl $0x1de, %edx            # imm = 0x1DE
callq 0x30a0
leaq 0x2cd5f(%rip), %rdi     # 0x3e718
leaq 0x2c9b4(%rip), %rsi     # 0x3e374
leaq 0x2e1ad(%rip), %rcx     # 0x3fb74
movl $0x1df, %edx            # imm = 0x1DF
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/frontend/irgen.c
// Function: ir_cond_expr_with_rstr
static void _ir_cond_expr_with_rstr(
	IRGeneratorContext *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);

	ParserASTNode *node_type = FE_EXPR_AST_NODE_GET_TYPE_NODE(expr_node);

	ResizableString rstr_type;
	rstr_init(&rstr_type);
	_ir_type(ctx, &rstr_type, node_type);

	ResizableString rstr_tmp;
	rstr_init(&rstr_tmp);
	_generate_func_tmp_var(
		ctx,
		ctx->func_symbol,
		&rstr_tmp,
		FE_SEM_NODE_TYPE_INT64
	);

	rstr_appendf(
		rstr,
		"neq %s, %s, cast<%s>(0);\n",
		RSTR_CSTR(&rstr_tmp),
		RSTR_CSTR(&(expr_result->rstr_result)),
		RSTR_CSTR(&rstr_type)
	);

	rstr_append_with_cstr(cond_expr_label, RSTR_CSTR(&rstr_tmp));

	rstr_free(&rstr_type);
	rstr_free(&rstr_tmp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
testq %rsi, %rsi
je 0x11abe
testq %rdx, %rdx
je 0x11add
movq %rcx, %r13
testq %rcx, %rcx
je 0x11afc
movq %rdx, -0x30(%rbp)
testq %r8, %r8
je 0x11b1b
movq %rsi, %r14
movq %rdi, %r15
movq 0x68(%r8), %r12
leaq -0x50(%rbp), %rbx
movq %rbx, %rdi
callq 0x6e1c
movq %rbx, %rdi
movq %r12, %rsi
callq 0xbd8f
leaq -0x40(%rbp), %r12
movq %r12, %rdi
callq 0x6e1c
movq 0x40(%r15), %rsi
leaq 0x43c23(%rip), %rcx     # 0x55668
movq %r15, %rdi
movq %r12, %rdx
callq 0xffa1
movq 0x28(%r13), %rcx
testq %rcx, %rcx
leaq 0x2e4b8(%rip), %r15     # 0x3ff16
cmoveq %r15, %rcx
movq 0x8(%r12), %rdx
testq %rdx, %rdx
cmoveq %r15, %rdx
movq 0x8(%rbx), %r8
testq %r8, %r8
cmoveq %r15, %r8
leaq 0x2e1e3(%rip), %rsi     # 0x3fc63
movq %r14, %rdi
xorl %eax, %eax
callq 0x739a
movq 0x8(%r12), %rsi
testq %rsi, %rsi
cmoveq %r15, %rsi
movq -0x30(%rbp), %rdi
callq 0x6e99
movq %rbx, %rdi
callq 0x72b9
movq %r12, %rdi
callq 0x72b9
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2af6b(%rip), %rdi     # 0x3ca30
leaq 0x2c8a8(%rip), %rsi     # 0x3e374
leaq 0x2e0fd(%rip), %rcx     # 0x3fbd0
movl $0xb9e, %edx            # imm = 0xB9E
callq 0x30a0
leaq 0x2e165(%rip), %rdi     # 0x3fc49
leaq 0x2c889(%rip), %rsi     # 0x3e374
leaq 0x2e0de(%rip), %rcx     # 0x3fbd0
movl $0xb9f, %edx            # imm = 0xB9F
callq 0x30a0
leaq 0x2d0e1(%rip), %rdi     # 0x3ebe4
leaq 0x2c86a(%rip), %rsi     # 0x3e374
leaq 0x2e0bf(%rip), %rcx     # 0x3fbd0
movl $0xba0, %edx            # imm = 0xBA0
callq 0x30a0
leaq 0x2e137(%rip), %rdi     # 0x3fc59
leaq 0x2c84b(%rip), %rsi     # 0x3e374
leaq 0x2e0a0(%rip), %rcx     # 0x3fbd0
movl $0xba1, %edx            # imm = 0xBA1
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/frontend/irgen_c.c
// Function: fe_irgen_c_new_context
IRGeneratorCContext * fe_irgen_c_new_context(ParserContext *psrctx, FILE *out) {
	assert(psrctx);
	assert(psrctx->ast);
	assert(out);
	
	IRGeneratorCContext *ctx = (IRGeneratorCContext *)malloc(sizeof(IRGeneratorCContext));
	if (ctx == NULL) {
		_error("cannot allocate memory for a new context!");
	}

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

	rstr_init(&(ctx->global));

	return ctx;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x137ae
movq %rdi, %r14
cmpq $0x0, 0x8(%rdi)
je 0x137cd
movq %rsi, %rbx
testq %rsi, %rsi
je 0x137ec
pushq $0x20
popq %rdi
callq 0x3110
testq %rax, %rax
je 0x1380b
movq %rax, %r15
movq %r14, (%rax)
movq %rbx, 0x8(%rax)
movq %rax, %rdi
addq $0x10, %rdi
callq 0x6e1c
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2ac0b(%rip), %rdi     # 0x3e3c0
leaq 0x2d0f8(%rip), %rsi     # 0x408b4
leaq 0x2d13d(%rip), %rcx     # 0x40900
movl $0x777, %edx            # imm = 0x777
callq 0x30a0
leaq 0x2abf8(%rip), %rdi     # 0x3e3cc
leaq 0x2d0d9(%rip), %rsi     # 0x408b4
leaq 0x2d11e(%rip), %rcx     # 0x40900
movl $0x778, %edx            # imm = 0x778
callq 0x30a0
leaq 0x2ac13(%rip), %rdi     # 0x3e406
leaq 0x2d0ba(%rip), %rsi     # 0x408b4
leaq 0x2d0ff(%rip), %rcx     # 0x40900
movl $0x779, %edx            # imm = 0x779
callq 0x30a0
leaq 0x2ac3a(%rip), %rdi     # 0x3e44c
callq 0x13817
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/frontend/irgen_c.c
// Function: ir_expr_wrapper
static void _ir_expr_wrapper(
	IRGeneratorCContext *ctx,
	ResizableString *rstr,
	ParserASTNode *node_expr
) {
	assert(ctx);
	assert(rstr);
	assert(node_expr);
	assert(node_expr->type == FE_NODE_EXPR);
	assert(node_expr->nchilds == 1);

	if (_ir_expr_constexpr(ctx, rstr, node_expr)) {
		return;
	}

	ParserASTNode *child = node_expr->childs[0];
	_ir_expr(ctx, rstr, child);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x13fd1
movq %rdx, %r15
testq %rdx, %rdx
je 0x13ff0
cmpl $0xe00, (%r15)          # imm = 0xE00
jne 0x1400f
cmpl $0x1, 0x44(%r15)
jne 0x1402e
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movq %r15, %rsi
callq 0x142e3
testb %al, %al
je 0x13fb5
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x48(%r15), %rax
movq (%rax), %rdx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x14596
leaq 0x28a58(%rip), %rdi     # 0x3ca30
leaq 0x2c8d5(%rip), %rsi     # 0x408b4
leaq 0x2cb52(%rip), %rcx     # 0x40b38
movl $0x4ac, %edx            # imm = 0x4AC
callq 0x30a0
leaq 0x2cb92(%rip), %rdi     # 0x40b89
leaq 0x2c8b6(%rip), %rsi     # 0x408b4
leaq 0x2cb33(%rip), %rcx     # 0x40b38
movl $0x4ad, %edx            # imm = 0x4AD
callq 0x30a0
leaq 0x2c2f7(%rip), %rdi     # 0x4030d
leaq 0x2c897(%rip), %rsi     # 0x408b4
leaq 0x2cb14(%rip), %rcx     # 0x40b38
movl $0x4ae, %edx            # imm = 0x4AE
callq 0x30a0
leaq 0x2cb5e(%rip), %rdi     # 0x40b93
leaq 0x2c878(%rip), %rsi     # 0x408b4
leaq 0x2caf5(%rip), %rcx     # 0x40b38
movl $0x4af, %edx            # imm = 0x4AF
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/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 0x15e24
cmpl $0x200, (%rsi)          # imm = 0x200
jne 0x15e43
cmpl $0x0, 0x44(%rsi)
jne 0x15e62
movq 0x10(%rsi), %rax
movq 0x8(%rax), %rsi
movl 0x4(%rax), %edx
popq %rbp
jmp 0x700f
leaq 0x2ad5e(%rip), %rdi     # 0x40b89
leaq 0x2aa82(%rip), %rsi     # 0x408b4
leaq 0x2ae82(%rip), %rcx     # 0x40cbb
movl $0x19d, %edx            # imm = 0x19D
callq 0x30a0
leaq 0x2aec5(%rip), %rdi     # 0x40d0f
leaq 0x2aa63(%rip), %rsi     # 0x408b4
leaq 0x2ae63(%rip), %rcx     # 0x40cbb
movl $0x19e, %edx            # imm = 0x19E
callq 0x30a0
leaq 0x2aecc(%rip), %rdi     # 0x40d35
leaq 0x2aa44(%rip), %rsi     # 0x408b4
leaq 0x2ae44(%rip), %rcx     # 0x40cbb
movl $0x19f, %edx            # imm = 0x19F
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/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 0x17ac3
movq %rdi, %r15
cmpq $0x0, 0x8(%rdi)
je 0x17ae2
movq %rsi, %r14
testq %rsi, %rsi
je 0x17b01
pushq $0x48
popq %rdi
callq 0x3110
testq %rax, %rax
je 0x17b20
movq %rax, %rbx
movq %r15, (%rax)
movq %r14, 0x8(%rax)
callq 0x71d5
movq %rax, %r14
movq %rax, 0x10(%rbx)
callq 0x71d5
movq %rax, %r15
movq %rax, 0x18(%rbx)
callq 0x71d5
movq %rax, %r12
movq %rax, 0x20(%rbx)
callq 0x71d5
movq %rax, %r13
movq %rax, 0x28(%rbx)
andq $0x0, 0x30(%rbx)
movq %r14, %rdi
callq 0x6e1c
movq %r15, %rdi
callq 0x6e1c
movq %r12, %rdi
callq 0x6e1c
movq %r13, %rdi
callq 0x6e1c
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 0x268f6(%rip), %rdi     # 0x3e3c0
leaq 0x29eb7(%rip), %rsi     # 0x41988
leaq 0x29fc2(%rip), %rcx     # 0x41a9a
movl $0x1498, %edx           # imm = 0x1498
callq 0x30a0
leaq 0x268e3(%rip), %rdi     # 0x3e3cc
leaq 0x29e98(%rip), %rsi     # 0x41988
leaq 0x29fa3(%rip), %rcx     # 0x41a9a
movl $0x1499, %edx           # imm = 0x1499
callq 0x30a0
leaq 0x268fe(%rip), %rdi     # 0x3e406
leaq 0x29e79(%rip), %rsi     # 0x41988
leaq 0x29f84(%rip), %rcx     # 0x41a9a
movl $0x149a, %edx           # imm = 0x149A
callq 0x30a0
leaq 0x26925(%rip), %rdi     # 0x3e44c
callq 0x17b2c
// File: /workspace/github_c_makefile_star2_O2/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 0x18924
movq %rdi, %rbx
callq 0x6e1c
leaq 0x10(%rbx), %rdi
callq 0x6e1c
leaq 0x20(%rbx), %rdi
callq 0x6e1c
leaq 0x30(%rbx), %rdi
callq 0x6e1c
leaq 0x40(%rbx), %rdi
callq 0x6e1c
leaq 0x50(%rbx), %rdi
callq 0x6e1c
leaq 0x60(%rbx), %rdi
callq 0x6e1c
addq $0x70, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x6e1c
leaq 0x262b9(%rip), %rdi     # 0x3ebe4
leaq 0x29056(%rip), %rsi     # 0x41988
leaq 0x262b7(%rip), %rcx     # 0x3ebf0
pushq $0x57
popq %rdx
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/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 0x1923a
movq %rdi, %rbx
callq 0x72b9
leaq 0x10(%rbx), %rdi
callq 0x72b9
leaq 0x20(%rbx), %rdi
callq 0x72b9
leaq 0x30(%rbx), %rdi
callq 0x72b9
leaq 0x40(%rbx), %rdi
callq 0x72b9
leaq 0x50(%rbx), %rdi
callq 0x72b9
leaq 0x60(%rbx), %rdi
callq 0x72b9
addq $0x70, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x72b9
leaq 0x259a3(%rip), %rdi     # 0x3ebe4
leaq 0x28740(%rip), %rsi     # 0x41988
leaq 0x26c59(%rip), %rcx     # 0x3fea8
movl $0xc4, %edx
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/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 0x1cbfe
movq %rdx, %rbx
testq %rdx, %rdx
je 0x1cc17
movq %rsi, %r15
movq %rdi, %r14
addq $0x20, %rdi
leaq 0x25504(%rip), %rsi     # 0x420d0
movq %r15, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x739a
leaq 0x30(%r14), %rdi
movq %r15, %rsi
callq 0x6e99
addq $0x40, %r14
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x6e99
leaq 0x21b13(%rip), %rdi     # 0x3e718
leaq 0x24d7c(%rip), %rsi     # 0x41988
leaq 0x25475(%rip), %rcx     # 0x42088
pushq $0x6b
jmp 0x1cc2e
leaq 0x21edb(%rip), %rdi     # 0x3eaf9
leaq 0x24d63(%rip), %rsi     # 0x41988
leaq 0x2545c(%rip), %rcx     # 0x42088
pushq $0x6c
popq %rdx
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/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 0x1cc60
testq %rsi, %rsi
je 0x1cc7f
movl 0x54(%rdi), %edx
leal 0x1(%rdx), %eax
movl %eax, 0x54(%rdi)
leaq 0x2555c(%rip), %rax     # 0x421ae
movq %rsi, %rdi
movq %rax, %rsi
xorl %eax, %eax
popq %rbp
jmp 0x739a
leaq 0x23310(%rip), %rdi     # 0x3ff77
leaq 0x24d1a(%rip), %rsi     # 0x41988
leaq 0x254e0(%rip), %rcx     # 0x42155
movl $0xfb, %edx
callq 0x30a0
leaq 0x1fdaa(%rip), %rdi     # 0x3ca30
leaq 0x24cfb(%rip), %rsi     # 0x41988
leaq 0x254c1(%rip), %rcx     # 0x42155
movl $0xfc, %edx
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/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 0x1cd01
movq %rdx, %rbx
testq %rdx, %rdx
je 0x1cd20
movq %rsi, %r15
movq %rdi, %r14
addq $0x50, %rdi
leaq 0x25543(%rip), %rsi     # 0x42209
movq %r15, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x739a
leaq 0x60(%r14), %rdi
leaq 0x25532(%rip), %rsi     # 0x42210
movq %r15, %rdx
xorl %eax, %eax
callq 0x739a
addq $0x70, %r14
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x6e99
leaq 0x21a10(%rip), %rdi     # 0x3e718
leaq 0x24c79(%rip), %rsi     # 0x41988
leaq 0x254a7(%rip), %rcx     # 0x421bd
movl $0x99, %edx
callq 0x30a0
leaq 0x21dd2(%rip), %rdi     # 0x3eaf9
leaq 0x24c5a(%rip), %rsi     # 0x41988
leaq 0x25488(%rip), %rcx     # 0x421bd
movl $0x9a, %edx
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/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 0x1ea68
testq %rdx, %rdx
je 0x1ea87
movq %rcx, %r15
testq %rcx, %rcx
je 0x1eaa6
movq %rdx, -0x30(%rbp)
testq %r8, %r8
je 0x1eac5
movq %rsi, %r14
movq %rdi, %r12
movb 0x60(%r8), %bl
leaq -0x40(%rbp), %r13
movq %r13, %rdi
callq 0x6e1c
movq 0x40(%r12), %rdi
movq %r13, %rsi
callq 0x1cc34
movzbl %bl, %r12d
movl %r12d, %edi
callq 0x282fa
testb %al, %al
je 0x1e9f9
leaq 0x244db(%rip), %rsi     # 0x42ed2
jmp 0x1ea10
movl %r12d, %edi
callq 0x2832b
testb %al, %al
je 0x1eae4
leaq 0x244d6(%rip), %rsi     # 0x42ee6
leaq -0x40(%rbp), %r12
movq 0x8(%r12), %rdx
testq %rdx, %rdx
leaq 0x214f3(%rip), %rbx     # 0x3ff16
cmoveq %rbx, %rdx
movq 0x28(%r15), %rcx
testq %rcx, %rcx
cmoveq %rbx, %rcx
movq %r14, %rdi
xorl %eax, %eax
callq 0x739a
movq 0x8(%r12), %rsi
testq %rsi, %rsi
cmoveq %rbx, %rsi
movq -0x30(%rbp), %rdi
callq 0x6e99
movq %r12, %rdi
callq 0x72b9
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1dfc1(%rip), %rdi     # 0x3ca30
leaq 0x22f12(%rip), %rsi     # 0x41988
leaq 0x243d6(%rip), %rcx     # 0x42e53
movl $0x51b, %edx            # imm = 0x51B
callq 0x30a0
leaq 0x211bb(%rip), %rdi     # 0x3fc49
leaq 0x22ef3(%rip), %rsi     # 0x41988
leaq 0x243b7(%rip), %rcx     # 0x42e53
movl $0x51c, %edx            # imm = 0x51C
callq 0x30a0
leaq 0x20137(%rip), %rdi     # 0x3ebe4
leaq 0x22ed4(%rip), %rsi     # 0x41988
leaq 0x24398(%rip), %rcx     # 0x42e53
movl $0x51d, %edx            # imm = 0x51D
callq 0x30a0
leaq 0x2118d(%rip), %rdi     # 0x3fc59
leaq 0x22eb5(%rip), %rsi     # 0x41988
leaq 0x24379(%rip), %rcx     # 0x42e53
movl $0x51e, %edx            # imm = 0x51E
callq 0x30a0
leaq 0x1d875(%rip), %rdi     # 0x3c360
leaq 0x22e96(%rip), %rsi     # 0x41988
leaq 0x2435a(%rip), %rcx     # 0x42e53
movl $0x533, %edx            # imm = 0x533
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/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 0x1feef
testq %rsi, %rsi
je 0x1ff0e
testl %edx, %edx
js 0x1ff2d
leaq 0x35247(%rip), %rcx     # 0x55130
popq %rbp
jmp 0x3c5c
leaq 0x1bb03(%rip), %rdi     # 0x3b9f9
leaq 0x2372f(%rip), %rsi     # 0x4362c
leaq 0x23742(%rip), %rcx     # 0x43646
movl $0x156, %edx            # imm = 0x156
callq 0x30a0
leaq 0x1b611(%rip), %rdi     # 0x3b526
leaq 0x23710(%rip), %rsi     # 0x4362c
leaq 0x23723(%rip), %rcx     # 0x43646
movl $0x157, %edx            # imm = 0x157
callq 0x30a0
leaq 0x1b5f9(%rip), %rdi     # 0x3b52d
leaq 0x236f1(%rip), %rsi     # 0x4362c
leaq 0x23704(%rip), %rcx     # 0x43646
movl $0x158, %edx            # imm = 0x158
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/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 0x1ffda
testq %rsi, %rsi
je 0x1fff9
movl $0xfffff000, %eax       # imm = 0xFFFFF000
addl (%rsi), %eax
cmpl $0x3, %eax
ja 0x20018
leaq 0x2366f(%rip), %rcx     # 0x4360c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0x9713
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0x993b
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0x9ad7
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0x982f
leaq 0x1dde3(%rip), %rdi     # 0x3ddc4
leaq 0x23644(%rip), %rsi     # 0x4362c
leaq 0x236c6(%rip), %rcx     # 0x436b5
movl $0x167, %edx            # imm = 0x167
callq 0x30a0
leaq 0x2881c(%rip), %rdi     # 0x4881c
leaq 0x23625(%rip), %rsi     # 0x4362c
leaq 0x236a7(%rip), %rcx     # 0x436b5
movl $0x168, %edx            # imm = 0x168
callq 0x30a0
leaq 0x1c341(%rip), %rdi     # 0x3c360
leaq 0x23606(%rip), %rsi     # 0x4362c
leaq 0x23688(%rip), %rcx     # 0x436b5
movl $0x178, %edx            # imm = 0x178
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/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 0x20099
testq %rsi, %rsi
je 0x200b8
movl $0xfffff000, %eax       # imm = 0xFFFFF000
addl (%rsi), %eax
cmpl $0x3, %eax
ja 0x200d7
leaq 0x235c0(%rip), %rcx     # 0x4361c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0x966d
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0x98aa
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0x99b6
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0x978e
leaq 0x1dd24(%rip), %rdi     # 0x3ddc4
leaq 0x23585(%rip), %rsi     # 0x4362c
leaq 0x23646(%rip), %rcx     # 0x436f4
movl $0x183, %edx            # imm = 0x183
callq 0x30a0
leaq 0x2875d(%rip), %rdi     # 0x4881c
leaq 0x23566(%rip), %rsi     # 0x4362c
leaq 0x23627(%rip), %rcx     # 0x436f4
movl $0x184, %edx            # imm = 0x184
callq 0x30a0
leaq 0x1c282(%rip), %rdi     # 0x3c360
leaq 0x23547(%rip), %rsi     # 0x4362c
leaq 0x23608(%rip), %rcx     # 0x436f4
movl $0x194, %edx            # imm = 0x194
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/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 0x20119
testq %rsi, %rsi
je 0x20138
cmpl $0x1004, (%rsi)         # imm = 0x1004
jne 0x20157
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0x9c54
leaq 0x1dca4(%rip), %rdi     # 0x3ddc4
leaq 0x23505(%rip), %rsi     # 0x4362c
leaq 0x23605(%rip), %rcx     # 0x43733
movl $0x19f, %edx            # imm = 0x19F
callq 0x30a0
leaq 0x286dd(%rip), %rdi     # 0x4881c
leaq 0x234e6(%rip), %rsi     # 0x4362c
leaq 0x235e6(%rip), %rcx     # 0x43733
movl $0x1a0, %edx            # imm = 0x1A0
callq 0x30a0
leaq 0x1c202(%rip), %rdi     # 0x3c360
leaq 0x234c7(%rip), %rsi     # 0x4362c
leaq 0x235c7(%rip), %rcx     # 0x43733
movl $0x1a5, %edx            # imm = 0x1A5
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/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 0x20199
testq %rsi, %rsi
je 0x201b8
cmpl $0x1004, (%rsi)         # imm = 0x1004
jne 0x201d7
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0x9b52
leaq 0x1dc24(%rip), %rdi     # 0x3ddc4
leaq 0x23485(%rip), %rsi     # 0x4362c
leaq 0x235c0(%rip), %rcx     # 0x4376e
movl $0x1af, %edx            # imm = 0x1AF
callq 0x30a0
leaq 0x2865d(%rip), %rdi     # 0x4881c
leaq 0x23466(%rip), %rsi     # 0x4362c
leaq 0x235a1(%rip), %rcx     # 0x4376e
movl $0x1b0, %edx            # imm = 0x1B0
callq 0x30a0
leaq 0x1c182(%rip), %rdi     # 0x3c360
leaq 0x23447(%rip), %rsi     # 0x4362c
leaq 0x23582(%rip), %rcx     # 0x4376e
movl $0x1b5, %edx            # imm = 0x1B5
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/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 0x20219
testq %rsi, %rsi
je 0x20238
cmpl $0x1005, (%rsi)         # imm = 0x1005
jne 0x20257
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0x9528
leaq 0x1dba4(%rip), %rdi     # 0x3ddc4
leaq 0x23405(%rip), %rsi     # 0x4362c
leaq 0x2357d(%rip), %rcx     # 0x437ab
movl $0x1bf, %edx            # imm = 0x1BF
callq 0x30a0
leaq 0x285dd(%rip), %rdi     # 0x4881c
leaq 0x233e6(%rip), %rsi     # 0x4362c
leaq 0x2355e(%rip), %rcx     # 0x437ab
movl $0x1c0, %edx            # imm = 0x1C0
callq 0x30a0
leaq 0x1c102(%rip), %rdi     # 0x3c360
leaq 0x233c7(%rip), %rsi     # 0x4362c
leaq 0x2353f(%rip), %rcx     # 0x437ab
movl $0x1c5, %edx            # imm = 0x1C5
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/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 0x20321
testq %rsi, %rsi
je 0x20340
movl (%rsi), %eax
andl $-0x4, %eax
cmpl $0x1000, %eax           # imm = 0x1000
jne 0x2035f
movq 0x8(%rsi), %rax
movslq 0x4(%rsi), %rcx
cmpb $0x75, -0x1(%rax,%rcx)
sete %al
popq %rbp
retq
leaq 0x1da9c(%rip), %rdi     # 0x3ddc4
leaq 0x232fd(%rip), %rsi     # 0x4362c
leaq 0x23505(%rip), %rcx     # 0x4383b
movl $0x1dc, %edx            # imm = 0x1DC
callq 0x30a0
leaq 0x284d5(%rip), %rdi     # 0x4881c
leaq 0x232de(%rip), %rsi     # 0x4362c
leaq 0x234e6(%rip), %rcx     # 0x4383b
movl $0x1dd, %edx            # imm = 0x1DD
callq 0x30a0
leaq 0x23514(%rip), %rdi     # 0x4387a
leaq 0x232bf(%rip), %rsi     # 0x4362c
leaq 0x234c7(%rip), %rcx     # 0x4383b
movl $0x1e3, %edx            # imm = 0x1E3
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/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 0x203a6
testq %rsi, %rsi
je 0x203c5
cmpl $0x1004, (%rsi)         # imm = 0x1004
jne 0x203e4
movq 0x8(%rsi), %rax
movslq 0x4(%rsi), %rcx
cmpb $0x66, -0x1(%rax,%rcx)
sete %al
popq %rbp
retq
leaq 0x1da17(%rip), %rdi     # 0x3ddc4
leaq 0x23278(%rip), %rsi     # 0x4362c
leaq 0x2356c(%rip), %rcx     # 0x43927
movl $0x1ec, %edx            # imm = 0x1EC
callq 0x30a0
leaq 0x28450(%rip), %rdi     # 0x4881c
leaq 0x23259(%rip), %rsi     # 0x4362c
leaq 0x2354d(%rip), %rcx     # 0x43927
movl $0x1ed, %edx            # imm = 0x1ED
callq 0x30a0
leaq 0x23578(%rip), %rdi     # 0x43963
leaq 0x2323a(%rip), %rsi     # 0x4362c
leaq 0x2352e(%rip), %rcx     # 0x43927
movl $0x1ee, %edx            # imm = 0x1EE
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/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 0x229c5
movq %rdi, %rbx
movl $0xfffff4e0, %eax       # imm = 0xFFFFF4E0
addl (%rdi), %eax
cmpl $0x20, %eax
ja 0x229de
movabsq $0x100010001, %rcx      # imm = 0x100010001
btq %rax, %rcx
jae 0x229de
leaq 0x60(%rbx), %rdi
callq 0x72b9
addq $0x70, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x72b9
leaq 0x1d426(%rip), %rdi     # 0x3fdf2
leaq 0x22a5d(%rip), %rsi     # 0x45430
leaq 0x22a71(%rip), %rcx     # 0x4544b
pushq $0x16
jmp 0x229f5
leaq 0x22a9c(%rip), %rdi     # 0x45481
leaq 0x22a44(%rip), %rsi     # 0x45430
leaq 0x22a58(%rip), %rcx     # 0x4544b
pushq $0x19
popq %rdx
callq 0x30a0