LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/uno_generic.c
// Function: list_select
static void
list_select(treenode *n, int unused1, int unused2)
{	SymRef *s;
	SymList *r;
	int cnt = 0;

	if (n)
		printf("uno: %s:%d: symbols (*=selected):\n",
			n->hdr.fnm, n->hdr.line);
	else
		printf("uno: symbols (*=selected):\n");

	for (s = gen_stack->symrefs; s; s = s->nxt)
		{	printf("	%3d%s:\t%s [",
				++cnt,
				(s->status & SELECTED)?"*":"",
				s->sm->nme->str);
			dflow_mark(stdout, s->status);
			printf("]	(stack - mark %d)\n", s->s_val);
		}

	if (n && n->hdr.defuse)
	for (r = n->hdr.defuse->other; r; r = r->nxt)
		{	printf("	%3d%s:	%s [",
				++cnt,
				r->selected?"*":"",
				r->sm->nme->str);
			dflow_mark(stdout, r->mark);
			printf("]	(stmnt)\n");
		}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
movq %rdi, (%rsp)
je 0x1d8fe
movq 0x8(%rdi), %rsi
movl 0x10(%rdi), %edx
leaq 0x13722(%rip), %rdi     # 0x31017
xorl %eax, %eax
callq 0x3100
jmp 0x1d90a
leaq 0x13b43(%rip), %rdi     # 0x31448
callq 0x30a0
movq 0x63157(%rip), %rax     # 0x80a68
movq (%rax), %r13
testq %r13, %r13
je 0x1d98b
leaq 0x288f(%rip), %r14      # 0x201af
leaq 0x13713(%rip), %r15     # 0x3103a
movq 0x1a6a2(%rip), %rbp     # 0x37fd0
leaq 0x13712(%rip), %r12     # 0x31047
xorl %ebx, %ebx
incl %ebx
btl $0x18, 0x10(%r13)
movq %r14, %rdx
leaq 0x2452(%rip), %rax      # 0x1fd9b
cmovaeq %rax, %rdx
movq (%r13), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rcx
movq %r15, %rdi
movl %ebx, %esi
xorl %eax, %eax
callq 0x3100
movq (%rbp), %rdi
movl 0x10(%r13), %esi
callq 0x10269
movl 0x14(%r13), %esi
movq %r12, %rdi
xorl %eax, %eax
callq 0x3100
movq 0x18(%r13), %r13
testq %r13, %r13
jne 0x1d937
jmp 0x1d98d
xorl %ebx, %ebx
movq (%rsp), %rax
testq %rax, %rax
je 0x1da14
movq 0x28(%rax), %rax
testq %rax, %rax
je 0x1da14
movq 0x18(%rax), %r12
testq %r12, %r12
je 0x1da14
incl %ebx
leaq 0x27fe(%rip), %rbp      # 0x201af
leaq 0x13682(%rip), %r14     # 0x3103a
movq 0x1a611(%rip), %r13     # 0x37fd0
leaq 0x13a9d(%rip), %r15     # 0x31463
cmpl $0x0, (%r12)
movq %rbp, %rdx
leaq 0x23c6(%rip), %rax      # 0x1fd9b
cmoveq %rax, %rdx
movq 0x8(%r12), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rcx
movq %r14, %rdi
movl %ebx, %esi
xorl %eax, %eax
callq 0x3100
movq (%r13), %rdi
movl 0x4(%r12), %esi
callq 0x10269
movq %r15, %rdi
callq 0x30a0
movq 0x10(%r12), %r12
incl %ebx
testq %r12, %r12
jne 0x1d9c6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/uno_generic.c
// Function: sym_update
static void
sym_update(treenode *m, int val, int unused2)
{	SymRef *s;
	SymList *r;
	treenode *n;

	n = (m && m->hdr.type == TN_IF) ? ((if_node *)m)->cond : m;

	/* if any items on the stack were selected
	 * then a match() operations was executed
	 * which voids the select bits in defuse
	 */
	for (s = gen_stack->symrefs; s; s = s->nxt)
		if (s->status & SELECTED)
			goto after;

	if (n && n->hdr.defuse)
	for (r = n->hdr.defuse->other; r; r = r->nxt)
		if (r->selected)
		{	s = uno_getref(r->sm);
			s->nxt = gen_stack->symrefs;
			s->status = r->mark | SELECTED;
			s->n = n;
			gen_stack->symrefs = s;
			if (debug)
			printf("\tadded %s (line %d)\n",
				s->sm->nme->str, s->n?s->n->hdr.line:-1);
		}

	for (s = gen_stack->symrefs; s; s = s->nxt)
		if (s->status & SELECTED)
		{	if (debug)
			printf("\tmarked %s = %d (line %d)\n",
				s->sm->nme->str, val, s->n?s->n->hdr.line:-1);
after:			s->s_val = val;
		}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
testq %rdi, %rdi
je 0x1da40
movq %rdi, %r14
cmpl $0x1b, 0x1c(%rdi)
jne 0x1da43
movq 0x40(%r14), %r14
jmp 0x1da43
xorl %r14d, %r14d
movq 0x6301e(%rip), %rax     # 0x80a68
movq (%rax), %rcx
testq %rcx, %rcx
je 0x1da5e
testb $0x1, 0x13(%rcx)
jne 0x1dac5
movq 0x18(%rcx), %rcx
jmp 0x1da4d
testq %r14, %r14
je 0x1dab7
movq 0x28(%r14), %rcx
testq %rcx, %rcx
je 0x1dab7
movq 0x18(%rcx), %r15
testq %r15, %r15
je 0x1dab7
movl $0x1000000, %ebp        # imm = 0x1000000
cmpl $0x0, (%r15)
je 0x1daa7
movq 0x8(%r15), %rdi
callq 0x13853
movq 0x62fd8(%rip), %rcx     # 0x80a68
movq (%rcx), %rdx
movq %rdx, 0x18(%rax)
movl 0x4(%r15), %edx
orl %ebp, %edx
movl %edx, 0x10(%rax)
movq %r14, 0x8(%rax)
movq %rax, (%rcx)
movq 0x10(%r15), %r15
testq %r15, %r15
jne 0x1da7a
movq 0x62fb1(%rip), %rax     # 0x80a68
movq (%rax), %rcx
testq %rcx, %rcx
je 0x1dad1
testb $0x1, 0x13(%rcx)
je 0x1dac8
movl %ebx, 0x14(%rcx)
addq $0x18, %rcx
movq %rcx, %rax
jmp 0x1dab7
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/uno_generic.c
// Function: sym_unmark
static void
sym_unmark(treenode *unused0, int unused1, int unused2)
{	SymRef *s, *os = (SymRef *) 0;

	for (s = gen_stack->symrefs; s; s = s->nxt)
		if (s->status & SELECTED)
		{	if (!os)
				gen_stack->symrefs = s->nxt;
			else
				os->nxt = s->nxt;

			if (debug) fprintf(stderr, "\tdeleted %s (line %d)\n",
				s->sm->nme->str, s->n?s->n->hdr.line:-1);
		} else
			os = s;
}

// Assembly:
movq 0x62f85(%rip), %rax     # 0x80a68
movq (%rax), %rcx
testq %rcx, %rcx
je 0x1db22
movq 0x62f76(%rip), %rax     # 0x80a68
xorl %edx, %edx
testb $0x1, 0x13(%rcx)
jne 0x1db00
movq 0x18(%rcx), %rsi
jmp 0x1db17
movq 0x18(%rcx), %rsi
testq %rdx, %rdx
je 0x1db12
movq %rsi, 0x18(%rdx)
movq %rdx, %rcx
jmp 0x1db17
movq %rsi, (%rax)
xorl %ecx, %ecx
movq %rcx, %rdx
movq %rsi, %rcx
testq %rsi, %rsi
jne 0x1daf4
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/uno_generic.c
// Function: on_track
static int
on_track(treenode *m, int allow, int forbid)
{	SymRef *s;
	SymList *r;
	treenode *n;

	n = (m && m->hdr.type == TN_IF) ? ((if_node *)m)->cond : m;

	if (n && n->hdr.defuse)
	for (r = n->hdr.defuse->other; r; r = r->nxt)
		if ((r->mark & allow) && !(r->mark & forbid))
		{	for (s = gen_stack->symrefs; s; s = s->nxt)
			{	if (strcmp(s->sm->nme->str, r->sm->nme->str) == 0
				&&  (s->status & allow)
				&& !(s->status & forbid))
				{	if (m != s->n)
						witness = s->n;
					if (debug) printf("\tsym present %s (line %d)\n",
						r->sm->nme->str, s->n?s->n->hdr.line:-1);
					return 1;
		}	}	}

	if (debug)
	{	printf("on_track: no matching syms\n");
		if (n && n->hdr.defuse)
		for (r = n->hdr.defuse->other; r; r = r->nxt)
			printf("\tdefuse have %s %d\n", r->sm->nme->str, r->mark);
		for (s = gen_stack->symrefs; s; s = s->nxt)
			printf("\tgenstack have %s %d\n", s->sm->nme->str, s->status);
	}
	return 0;
}

// Assembly:
xorl %eax, %eax
testq %rdi, %rdi
je 0x1dc09
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r14
cmpl $0x1b, 0x1c(%rdi)
movq %rdi, %rcx
jne 0x1db57
movq 0x40(%r14), %rcx
testq %rcx, %rcx
je 0x1dbfb
movq 0x28(%rcx), %rcx
testq %rcx, %rcx
je 0x1dbfb
movq 0x18(%rcx), %r13
testq %r13, %r13
je 0x1dbfb
movq 0x62ef0(%rip), %rax     # 0x80a68
movq %rax, (%rsp)
movl 0x4(%r13), %eax
testl %r15d, %eax
sete %cl
testl %ebp, %eax
setne %al
orb %cl, %al
jne 0x1dbd9
movq (%rsp), %rax
movq (%rax), %rbx
testq %rbx, %rbx
je 0x1dbd9
movq 0x8(%r13), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %r12
movq (%rbx), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
movq %r12, %rsi
callq 0x3190
testl %eax, %eax
jne 0x1dbd0
movl 0x10(%rbx), %eax
testl %r15d, %eax
sete %cl
testl %ebp, %eax
setne %al
orb %cl, %al
je 0x1dbe6
movq 0x18(%rbx), %rbx
testq %rbx, %rbx
jne 0x1dba7
movq 0x10(%r13), %r13
testq %r13, %r13
jne 0x1db7c
xorl %eax, %eax
jmp 0x1dbfb
movq 0x8(%rbx), %rcx
movl $0x1, %eax
cmpq %r14, %rcx
je 0x1dbfb
movq %rcx, 0x62e85(%rip)     # 0x80a80
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/uno_generic.c
// Function: any_track
static int
any_track(treenode *m, int allow, int forbid)
{	SymRef *s;

	for (s = gen_stack->symrefs; s; s = s->nxt)
	{	if ((s->status & allow)
		&& !(s->status & forbid))
		{	if (m != s->n)
				witness = s->n;
			if (debug) printf("\tanytrack sym present %s (line %d)\n",
				s->sm->nme->str, s->n?s->n->hdr.line:-1);
			return 1;
	}	}

	if (debug) printf("any_track: no matching syms\n");
	return 0;
}

// Assembly:
movq 0x62e57(%rip), %rax     # 0x80a68
movq (%rax), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x1dc4d
movl 0x10(%rcx), %r8d
testl %esi, %r8d
sete %r9b
testl %edx, %r8d
setne %r8b
orb %r9b, %r8b
je 0x1dc38
movq 0x18(%rcx), %rcx
jmp 0x1dc16
movq 0x8(%rcx), %rcx
movl $0x1, %eax
cmpq %rdi, %rcx
je 0x1dc4d
movq %rcx, 0x62e33(%rip)     # 0x80a80
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/uno_generic.c
// Function: match_track
static int
match_track(treenode *m, int allow, int forbid)
{	SymRef *s;
	SymList *r;
	treenode *n;	/* var with allow and !forbid on defuse - that is also on_track? */

	n = (m && m->hdr.type == TN_IF) ? ((if_node *)m)->cond : m;

	if (n && n->hdr.defuse)
	for (r = n->hdr.defuse->other; r; r = r->nxt)
		if ((r->mark & allow) && !(r->mark & forbid))
		{	for (s = gen_stack->symrefs; s; s = s->nxt)
			{	if (strcmp(s->sm->nme->str, r->sm->nme->str) == 0)
				{	if (m != s->n)
						witness = s->n;
					if (debug) printf("\tsym matched %s (line %d)\n",
						r->sm->nme->str, s->n?s->n->hdr.line:-1);
					return 1;
		}	}	}

	if (debug) printf("match_track: no matching syms\n");
	return 0;
}

// Assembly:
xorl %eax, %eax
testq %rdi, %rdi
je 0x1dd1e
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r14
cmpl $0x1b, 0x1c(%rdi)
movq %rdi, %rcx
jne 0x1dc82
movq 0x40(%r14), %rcx
testq %rcx, %rcx
je 0x1dd10
movq 0x28(%rcx), %rcx
testq %rcx, %rcx
je 0x1dd10
movq 0x18(%rcx), %r13
testq %r13, %r13
je 0x1dd10
movq 0x62dc9(%rip), %rax     # 0x80a68
movq %rax, (%rsp)
movl 0x4(%r13), %eax
testl %r15d, %eax
sete %cl
testl %ebp, %eax
setne %al
orb %cl, %al
jne 0x1dcee
movq (%rsp), %rax
movq (%rax), %rbx
testq %rbx, %rbx
je 0x1dcee
movq 0x8(%r13), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %r12
movq (%rbx), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
movq %r12, %rsi
callq 0x3190
testl %eax, %eax
je 0x1dcfb
movq 0x18(%rbx), %rbx
testq %rbx, %rbx
jne 0x1dcce
movq 0x10(%r13), %r13
testq %r13, %r13
jne 0x1dca3
xorl %eax, %eax
jmp 0x1dd10
movq 0x8(%rbx), %rcx
movl $0x1, %eax
cmpq %r14, %rcx
je 0x1dd10
movq %rcx, 0x62d70(%rip)     # 0x80a80
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/uno_generic.c
// Function: good_target
static int
good_target(treenode *n, SymList *r)
{
	if (!n) return 0;

	if (n->hdr.type == TN_IDENT) return 1;

	if (n->hdr.type == TN_ASSIGN
	&&  n->lnode
	&&  n->lnode->hdr.type == TN_IDENT
	&&  strcmp(r->sm->nme->str, ((leafnode *) n->lnode)->data.sval->str) == 0)
		return 1;

	return 0;
}

// Assembly:
pushq %rbx
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x1e01a
movl 0x1c(%rdi), %eax
movl $0x1, %ebx
cmpl $0x2d, %eax
je 0x1e01a
cmpl $0x1c, %eax
jne 0x1e018
movq 0x40(%rdi), %rax
testq %rax, %rax
je 0x1e018
cmpl $0x2d, 0x1c(%rax)
jne 0x1e018
movq 0x8(%rsi), %rcx
movq 0x8(%rcx), %rcx
movq 0x8(%rcx), %rdi
movq 0x40(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x3190
testl %eax, %eax
je 0x1e01a
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/uno_generic.c
// Function: do_oper
static int
do_oper(treenode *m, int sign)
{	treenode *n;

	/* either --x (rnode) or x-- (lnode) */
	/* executed as stmnt, net effect the same */

	if (m->rnode) n = m->rnode; else n = m->lnode;

	if (!n
	||   n->hdr.type != TN_IDENT
	||  strcmp(((leafnode *) n)->data.sval->str, statename) != 0)
		return 0;

	gen_stack->uno_state += sign;

	return 1;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebx
movq 0x48(%rdi), %rax
testq %rax, %rax
jne 0x1e264
movq 0x40(%rdi), %rax
testq %rax, %rax
je 0x1e295
xorl %ebp, %ebp
cmpl $0x2d, 0x1c(%rax)
jne 0x1e297
movq 0x40(%rax), %rax
movq 0x8(%rax), %rdi
movq 0x19f35(%rip), %rsi     # 0x381b0
callq 0x3190
testl %eax, %eax
jne 0x1e297
movq 0x627dd(%rip), %rax     # 0x80a68
addl %ebx, 0x8(%rax)
movl $0x1, %ebp
jmp 0x1e297
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/uno_generic.c
// Function: err_matched
static int
err_matched(GenStack *g)
{
	if (!g) return 0;

	return err_matched(g->nxt)
	|| (witness
	&&  witness == g->e
	&&  v_matched(g->e));
}

// Assembly:
testq %rdi, %rdi
je 0x1e2bf
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0x1e2a0
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
je 0x1e2c2
popq %rbx
retq
xorl %eax, %eax
retq
movq 0x627b7(%rip), %rcx     # 0x80a80
testq %rcx, %rcx
je 0x1e2ec
movq 0x10(%rbx), %rdi
movl $0x0, %eax
cmpq %rdi, %rcx
jne 0x1e2bd
callq 0x1a949
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
setne %al
jmp 0x1e2bd
xorl %eax, %eax
jmp 0x1e2bd
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]Uno/Src/uno_generic.c
// Function: err_reversed
static void
err_reversed(GenStack *g)
{
	if (!g) return;

	if (!nopaths)
		err_reversed(g->nxt);
#if 0
	if (!debug && witness)
	{	if (g->e != witness)
			return;
		if (v_reported(g->e))
		{	fprintf(stderr, "\t--:\t%s:%d: <%s> matches an earlier case\n",
				g->e->hdr.fnm,
				g->e->hdr.line,
				x_stmnt(g->e));
			return;
		}
	}
	witness = ZT;
#endif

	if (g->e
	&&  g->e->hdr.type != TN_SWITCH
	&&  g->e->hdr.type != TN_WHILE
	&&  g->e->hdr.type != TN_DOWHILE)
	{
		if (g->e == witness) printf("*");
		if (g->c) printf("C");

		if (!nopaths) printf("\t%d:", steps++);

		printf("\t%s:%d: <%s>",
			g->e->hdr.fnm,
			g->e->hdr.line,
			x_stmnt(g->e));
		if (g->c)
			printf(" == <%s>", x_stmnt(g->c));

		if (debug) dump_defuse(g->e->hdr.defuse, stdout);
		printf(";\n");
	} else if (nopaths) err_reversed(g->nxt);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1e33c
movq %rdi, %rbx
leaq 0x19e61(%rip), %r14     # 0x38164
cmpl $0x0, (%r14)
sete %al
testb $0x1, %al
je 0x1e317
movq 0x20(%rbx), %rdi
callq 0x1e2f0
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x1e32b
movl 0x1c(%rax), %ecx
addl $-0x1f, %ecx
cmpl $0x3, %ecx
jae 0x1e341
cmpl $0x0, (%r14)
je 0x1e33c
movq 0x20(%rbx), %rbx
xorl %eax, %eax
testq %rbx, %rbx
jne 0x1e30a
popq %rbx
popq %r14
popq %rbp
retq
cmpq 0x62738(%rip), %rax     # 0x80a80
jne 0x1e354
movl $0x2a, %edi
callq 0x3040
cmpq $0x0, 0x18(%rbx)
je 0x1e365
movl $0x43, %edi
callq 0x3040
cmpl $0x0, (%r14)
jne 0x1e388
movl 0x62723(%rip), %esi     # 0x80a94
leal 0x1(%rsi), %eax
movl %eax, 0x6271a(%rip)     # 0x80a94
leaq 0x1304c(%rip), %rdi     # 0x313cd
xorl %eax, %eax
callq 0x3100
movq 0x10(%rbx), %rdi
movq 0x8(%rdi), %r14
movl 0x10(%rdi), %ebp
callq 0x5cbe
leaq 0x13033(%rip), %rdi     # 0x313d2
movq %r14, %rsi
movl %ebp, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3100
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x1e3cd
callq 0x5cbe
leaq 0x1301c(%rip), %rdi     # 0x313df
movq %rax, %rsi
xorl %eax, %eax
callq 0x3100
leaq 0x120bf(%rip), %rdi     # 0x30493
popq %rbx
popq %r14
popq %rbp
jmp 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
setne %cl
cmpb %cl, %al
je 0x1e4bf
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rbx, %r14
sete %r15b
je 0x1e4c2
movl 0x18(%r14), %eax
cmpl 0x18(%rbx), %eax
jne 0x1e4c2
movl (%r14), %ecx
cmpl (%rbx), %ecx
jne 0x1e4c2
movl 0x1c(%r14), %edx
cmpl 0x1c(%rbx), %edx
jne 0x1e4c2
cmpl $0x1, %ecx
je 0x1e45e
movq 0x40(%r14), %rdi
movq 0x40(%rbx), %rsi
callq 0x1e3dd
testl %eax, %eax
je 0x1e4c2
movq 0x48(%r14), %r14
movq 0x48(%rbx), %rbx
testq %r14, %r14
sete %al
testq %rbx, %rbx
setne %cl
xorb %al, %cl
jne 0x1e3fc
jmp 0x1e4c2
leal -0x2d(%rdx), %ecx
cmpl $0x4, %ecx
ja 0x1e4d9
leaq 0x12a8b(%rip), %rdx     # 0x30ef8
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 0x1e4d3
movsd 0x40(%rbx), %xmm0
cmpeqsd 0x40(%r14), %xmm0
movq %xmm0, %r15
andl $0x1, %r15d
jmp 0x1e4c2
cmpl $0x105, %eax            # imm = 0x105
jne 0x1e4bf
movq 0x40(%r14), %rax
movq 0x8(%rax), %rax
movq 0x40(%rbx), %rcx
cmpq 0x8(%rcx), %rax
jmp 0x1e4d3
xorl %r15d, %r15d
movzbl %r15b, %eax
popq %rbx
popq %r14
popq %r15
retq
movl 0x40(%r14), %eax
cmpl 0x40(%rbx), %eax
sete %r15b
jmp 0x1e4c2
movq %r14, %rdi
movq %rbx, %rsi
callq 0x43a3
// File: /workspace/github_c_makefile_star2_O3/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 0xc0ca
movq %rdi, %r15
cmpq $0x0, 0x8(%rdi)
je 0xc0e9
movq %rsi, %r14
testq %rsi, %rsi
je 0xc108
movl $0x48, %edi
callq 0x3120
testq %rax, %rax
je 0xc127
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 0x352df(%rip), %rdi     # 0x413b0
leaq 0x3528c(%rip), %rsi     # 0x41364
leaq 0x3531b(%rip), %rcx     # 0x413fa
movl $0x135c, %edx           # imm = 0x135C
callq 0x30a0
leaq 0x352cc(%rip), %rdi     # 0x413bc
leaq 0x3526d(%rip), %rsi     # 0x41364
leaq 0x352fc(%rip), %rcx     # 0x413fa
movl $0x135d, %edx           # imm = 0x135D
callq 0x30a0
leaq 0x352e7(%rip), %rdi     # 0x413f6
leaq 0x3524e(%rip), %rsi     # 0x41364
leaq 0x352dd(%rip), %rcx     # 0x413fa
movl $0x135e, %edx           # imm = 0x135E
callq 0x30a0
callq 0x31b0
// File: /workspace/github_c_makefile_star2_O3/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 0xc1be
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0xc1dd
cmpq $0x0, 0x18(%rbx)
je 0xc1fc
cmpq $0x0, 0x20(%rbx)
je 0xc21b
cmpq $0x0, 0x28(%rbx)
je 0xc23a
callq 0x7852
movq 0x18(%rbx), %rdi
callq 0x7852
movq 0x20(%rbx), %rdi
callq 0x7852
movq 0x28(%rbx), %rdi
callq 0x7852
movq 0x10(%rbx), %rdi
callq 0x31a0
movq 0x18(%rbx), %rdi
callq 0x31a0
movq 0x20(%rbx), %rdi
callq 0x31a0
movq 0x28(%rbx), %rdi
callq 0x31a0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x31a0
leaq 0x34bef(%rip), %rdi     # 0x40db4
leaq 0x35198(%rip), %rsi     # 0x41364
leaq 0x35293(%rip), %rcx     # 0x41466
movl $0x137a, %edx           # imm = 0x137A
callq 0x30a0
leaq 0x352b3(%rip), %rdi     # 0x41497
leaq 0x35179(%rip), %rsi     # 0x41364
leaq 0x35274(%rip), %rcx     # 0x41466
movl $0x137b, %edx           # imm = 0x137B
callq 0x30a0
leaq 0x352a0(%rip), %rdi     # 0x414a3
leaq 0x3515a(%rip), %rsi     # 0x41364
leaq 0x35255(%rip), %rcx     # 0x41466
movl $0x137c, %edx           # imm = 0x137C
callq 0x30a0
leaq 0x3528b(%rip), %rdi     # 0x414ad
leaq 0x3513b(%rip), %rsi     # 0x41364
leaq 0x35236(%rip), %rcx     # 0x41466
movl $0x137d, %edx           # imm = 0x137D
callq 0x30a0
leaq 0x35276(%rip), %rdi     # 0x414b7
leaq 0x3511c(%rip), %rsi     # 0x41364
leaq 0x35217(%rip), %rcx     # 0x41466
movl $0x137e, %edx           # imm = 0x137E
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0xc953
movq %rsi, %r14
testq %rsi, %rsi
je 0xc972
movq %rdi, %rbx
movl $0x5f, %esi
callq 0x74da
movq 0x10(%r14), %rax
movq 0x8(%rax), %rsi
movl 0x4(%rax), %edx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x7577
leaq 0x330d6(%rip), %rdi     # 0x3fa30
leaq 0x34a03(%rip), %rsi     # 0x41364
leaq 0x34cf0(%rip), %rcx     # 0x41658
movl $0x7c, %edx
callq 0x30a0
leaq 0x34d32(%rip), %rdi     # 0x416ab
leaq 0x349e4(%rip), %rsi     # 0x41364
leaq 0x34cd1(%rip), %rcx     # 0x41658
movl $0x7d, %edx
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0xcdf5
movq %rdi, %rbx
callq 0x7354
leaq 0x10(%rbx), %rdi
callq 0x7354
leaq 0x20(%rbx), %rdi
callq 0x7354
addq $0x30, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x7354
leaq 0x34dd8(%rip), %rdi     # 0x41bd4
leaq 0x34561(%rip), %rsi     # 0x41364
leaq 0x34dd6(%rip), %rcx     # 0x41be0
movl $0x3b, %edx
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0xd53f
movq %rdi, %rbx
callq 0x7852
leaq 0x10(%rbx), %rdi
callq 0x7852
leaq 0x20(%rbx), %rdi
callq 0x7852
addq $0x30, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x7852
leaq 0x3468e(%rip), %rdi     # 0x41bd4
leaq 0x33e17(%rip), %rsi     # 0x41364
leaq 0x35944(%rip), %rcx     # 0x42e98
movl $0x48, %edx
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0xd7f0
movq %rsi, %r14
testq %rsi, %rsi
je 0xd80f
movq %rdi, %rbx
movl $0x5f, %esi
callq 0x74da
movq 0x8(%r14), %rsi
movl 0x4(%r14), %edx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x7577
leaq 0x32239(%rip), %rdi     # 0x3fa30
leaq 0x33b66(%rip), %rsi     # 0x41364
leaq 0x341aa(%rip), %rcx     # 0x419af
movl $0x89, %edx
callq 0x30a0
leaq 0x341ec(%rip), %rdi     # 0x41a02
leaq 0x33b47(%rip), %rsi     # 0x41364
leaq 0x3418b(%rip), %rcx     # 0x419af
movl $0x8a, %edx
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0xdb70
testq %rdx, %rdx
je 0xdb8f
testq %rcx, %rcx
je 0xdbae
cmpl $0xe00, (%rcx)          # imm = 0xE00
jne 0xdbcd
cmpl $0x1, 0x44(%rcx)
jne 0xdbec
movq 0x48(%rcx), %rax
movq (%rax), %rcx
popq %rbp
jmp 0xdc0b
leaq 0x31eb9(%rip), %rdi     # 0x3fa30
leaq 0x337e6(%rip), %rsi     # 0x41364
leaq 0x34081(%rip), %rcx     # 0x41c06
movl $0xe4d, %edx            # imm = 0xE4D
callq 0x30a0
leaq 0x3403e(%rip), %rdi     # 0x41bd4
leaq 0x337c7(%rip), %rsi     # 0x41364
leaq 0x34062(%rip), %rcx     # 0x41c06
movl $0xe4e, %edx            # imm = 0xE4E
callq 0x30a0
leaq 0x3522d(%rip), %rdi     # 0x42de2
leaq 0x337a8(%rip), %rsi     # 0x41364
leaq 0x34043(%rip), %rcx     # 0x41c06
movl $0xe4f, %edx            # imm = 0xE4F
callq 0x30a0
leaq 0x34091(%rip), %rdi     # 0x41c65
leaq 0x33789(%rip), %rsi     # 0x41364
leaq 0x34024(%rip), %rcx     # 0x41c06
movl $0xe50, %edx            # imm = 0xE50
callq 0x30a0
leaq 0x3db9d(%rip), %rdi     # 0x4b790
leaq 0x3376a(%rip), %rsi     # 0x41364
leaq 0x34005(%rip), %rcx     # 0x41c06
movl $0xe51, %edx            # imm = 0xE51
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x10b96
movq %rcx, %r13
testq %rcx, %rcx
je 0x10bb5
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq -0x38(%rbp), %rbx
movq %rbx, %rdi
callq 0x7354
movq %rbx, %rdi
movq %r13, %rsi
callq 0xc991
movq 0x8(%rbx), %r13
testq %r13, %r13
leaq 0x323be(%rip), %rax     # 0x42f06
cmoveq %rax, %r13
movq %r15, %rdi
movq %r14, %rsi
callq 0x10bd4
movq 0x30(%r12), %rdi
movq 0x8(%r14), %rdx
testq %rdx, %rdx
leaq 0x3239c(%rip), %rax     # 0x42f06
cmoveq %rax, %rdx
leaq 0x3124c(%rip), %rsi     # 0x41dc1
movq %r13, %rcx
xorl %eax, %eax
callq 0x7945
movq %rbx, %rdi
callq 0x7852
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2ee93(%rip), %rdi     # 0x3fa30
leaq 0x307c0(%rip), %rsi     # 0x41364
leaq 0x311aa(%rip), %rcx     # 0x41d55
movl $0x1c9, %edx            # imm = 0x1C9
callq 0x30a0
leaq 0x30b47(%rip), %rdi     # 0x41703
leaq 0x307a1(%rip), %rsi     # 0x41364
leaq 0x3118b(%rip), %rcx     # 0x41d55
movl $0x1ca, %edx            # imm = 0x1CA
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x10c00
testq %rsi, %rsi
je 0x10c1f
movl 0x54(%rdi), %edx
leal 0x1(%rdx), %eax
movl %eax, 0x54(%rdi)
leaq 0x3122f(%rip), %rax     # 0x41e21
movq %rsi, %rdi
movq %rax, %rsi
xorl %eax, %eax
popq %rbp
jmp 0x7945
leaq 0x32360(%rip), %rdi     # 0x42f67
leaq 0x30756(%rip), %rsi     # 0x41364
leaq 0x311b9(%rip), %rcx     # 0x41dce
movl $0x168, %edx            # imm = 0x168
callq 0x30a0
leaq 0x2ee0a(%rip), %rdi     # 0x3fa30
leaq 0x30737(%rip), %rsi     # 0x41364
leaq 0x3119a(%rip), %rcx     # 0x41dce
movl $0x169, %edx            # imm = 0x169
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x10ce8
movq %rdx, %rbx
testq %rdx, %rdx
je 0x10d07
movq %rcx, %r13
testq %rcx, %rcx
je 0x10d26
movq %rsi, %r12
movq %rdi, %r15
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x7354
movq %r14, %rdi
movq %r13, %rsi
callq 0xc991
movq 0x8(%r14), %r13
testq %r13, %r13
leaq 0x3226b(%rip), %rax     # 0x42f06
cmoveq %rax, %r13
movq %r12, %rdi
movq %rbx, %rsi
callq 0x10bd4
movq 0x30(%r15), %rdi
movq 0x8(%rbx), %rdx
testq %rdx, %rdx
leaq 0x3224a(%rip), %rax     # 0x42f06
cmoveq %rax, %rdx
leaq 0x313f6(%rip), %rsi     # 0x420bd
movq %r13, %rcx
xorl %eax, %eax
callq 0x7945
movq %r14, %rdi
callq 0x7852
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x32278(%rip), %rdi     # 0x42f67
leaq 0x3066e(%rip), %rsi     # 0x41364
leaq 0x31358(%rip), %rcx     # 0x42055
movl $0x1b2, %edx            # imm = 0x1B2
callq 0x30a0
leaq 0x2ed22(%rip), %rdi     # 0x3fa30
leaq 0x3064f(%rip), %rsi     # 0x41364
leaq 0x31339(%rip), %rcx     # 0x42055
movl $0x1b3, %edx            # imm = 0x1B3
callq 0x30a0
leaq 0x309d6(%rip), %rdi     # 0x41703
leaq 0x30630(%rip), %rsi     # 0x41364
leaq 0x3131a(%rip), %rcx     # 0x42055
movl $0x1b4, %edx            # imm = 0x1B4
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x12633
movq %rsi, %r15
testq %rsi, %rsi
je 0x12652
movl %edx, %ebx
movq %rdi, %r14
leaq -0x30(%rbp), %r12
movq %r12, %rdi
callq 0x7354
movq %r12, %rdi
movq %r15, %rsi
callq 0xc991
movq 0x8(%r12), %rax
testq %rax, %rax
leaq 0x308ff(%rip), %rdx     # 0x42f06
cmovneq %rax, %rdx
leaq 0x305a1(%rip), %rsi     # 0x42bb3
movq %r14, %rdi
movl %ebx, %ecx
xorl %eax, %eax
callq 0x7945
movq %r12, %rdi
callq 0x7852
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2d3f6(%rip), %rdi     # 0x3fa30
leaq 0x2ed23(%rip), %rsi     # 0x41364
leaq 0x3051c(%rip), %rcx     # 0x42b64
movl $0x1de, %edx            # imm = 0x1DE
callq 0x30a0
leaq 0x2f0af(%rip), %rdi     # 0x41708
leaq 0x2ed04(%rip), %rsi     # 0x41364
leaq 0x304fd(%rip), %rcx     # 0x42b64
movl $0x1df, %edx            # imm = 0x1DF
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x1275e
testq %rdx, %rdx
je 0x1277d
movq %rcx, %r13
testq %rcx, %rcx
je 0x1279c
movq %rdx, -0x30(%rbp)
testq %r8, %r8
je 0x127bb
movq %rsi, %r14
movq %rdi, %r15
movq 0x68(%r8), %r12
leaq -0x50(%rbp), %rbx
movq %rbx, %rdi
callq 0x7354
movq %rbx, %rdi
movq %r12, %rsi
callq 0xc991
leaq -0x40(%rbp), %r12
movq %r12, %rdi
callq 0x7354
movq 0x40(%r15), %rsi
leaq 0x45f83(%rip), %rcx     # 0x58668
movq %r15, %rdi
movq %r12, %rdx
callq 0x10c3e
movq 0x28(%r13), %rcx
testq %rcx, %rcx
leaq 0x30808(%rip), %r15     # 0x42f06
cmoveq %r15, %rcx
movq 0x8(%r12), %rdx
testq %rdx, %rdx
cmoveq %r15, %rdx
movq 0x8(%rbx), %r8
testq %r8, %r8
cmoveq %r15, %r8
leaq 0x30533(%rip), %rsi     # 0x42c53
movq %r14, %rdi
xorl %eax, %eax
callq 0x7945
movq 0x8(%r12), %rsi
testq %rsi, %rsi
cmoveq %r15, %rsi
movq -0x30(%rbp), %rdi
callq 0x73db
movq %rbx, %rdi
callq 0x7852
movq %r12, %rdi
callq 0x7852
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2d2cb(%rip), %rdi     # 0x3fa30
leaq 0x2ebf8(%rip), %rsi     # 0x41364
leaq 0x3044d(%rip), %rcx     # 0x42bc0
movl $0xb9e, %edx            # imm = 0xB9E
callq 0x30a0
leaq 0x304b5(%rip), %rdi     # 0x42c39
leaq 0x2ebd9(%rip), %rsi     # 0x41364
leaq 0x3042e(%rip), %rcx     # 0x42bc0
movl $0xb9f, %edx            # imm = 0xB9F
callq 0x30a0
leaq 0x2f431(%rip), %rdi     # 0x41bd4
leaq 0x2ebba(%rip), %rsi     # 0x41364
leaq 0x3040f(%rip), %rcx     # 0x42bc0
movl $0xba0, %edx            # imm = 0xBA0
callq 0x30a0
leaq 0x30487(%rip), %rdi     # 0x42c49
leaq 0x2eb9b(%rip), %rsi     # 0x41364
leaq 0x303f0(%rip), %rcx     # 0x42bc0
movl $0xba1, %edx            # imm = 0xBA1
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x14573
movq %rdi, %r14
cmpq $0x0, 0x8(%rdi)
je 0x14592
movq %rsi, %rbx
testq %rsi, %rsi
je 0x145b1
movl $0x20, %edi
callq 0x3120
testq %rax, %rax
je 0x145d0
movq %rax, %r15
movq %r14, (%rax)
movq %rbx, 0x8(%rax)
movq %rax, %rdi
addq $0x10, %rdi
callq 0x7354
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2ce36(%rip), %rdi     # 0x413b0
leaq 0x2f30b(%rip), %rsi     # 0x4388c
leaq 0x2f350(%rip), %rcx     # 0x438d8
movl $0x777, %edx            # imm = 0x777
callq 0x30a0
leaq 0x2ce23(%rip), %rdi     # 0x413bc
leaq 0x2f2ec(%rip), %rsi     # 0x4388c
leaq 0x2f331(%rip), %rcx     # 0x438d8
movl $0x778, %edx            # imm = 0x778
callq 0x30a0
leaq 0x2ce3e(%rip), %rdi     # 0x413f6
leaq 0x2f2cd(%rip), %rsi     # 0x4388c
leaq 0x2f312(%rip), %rcx     # 0x438d8
movl $0x779, %edx            # imm = 0x779
callq 0x30a0
callq 0x31db
// File: /workspace/github_c_makefile_star2_O3/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 0x14d64
movq %rdx, %r15
testq %rdx, %rdx
je 0x14d83
cmpl $0xe00, (%r15)          # imm = 0xE00
jne 0x14da2
cmpl $0x1, 0x44(%r15)
jne 0x14dc1
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movq %r15, %rsi
callq 0x15079
testb %al, %al
je 0x14d48
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 0x15332
leaq 0x2acc5(%rip), %rdi     # 0x3fa30
leaq 0x2eb1a(%rip), %rsi     # 0x4388c
leaq 0x2ed94(%rip), %rcx     # 0x43b0d
movl $0x4ac, %edx            # imm = 0x4AC
callq 0x30a0
leaq 0x2edd4(%rip), %rdi     # 0x43b5e
leaq 0x2eafb(%rip), %rsi     # 0x4388c
leaq 0x2ed75(%rip), %rcx     # 0x43b0d
movl $0x4ad, %edx            # imm = 0x4AD
callq 0x30a0
leaq 0x2e554(%rip), %rdi     # 0x432fd
leaq 0x2eadc(%rip), %rsi     # 0x4388c
leaq 0x2ed56(%rip), %rcx     # 0x43b0d
movl $0x4ae, %edx            # imm = 0x4AE
callq 0x30a0
leaq 0x2eda0(%rip), %rdi     # 0x43b68
leaq 0x2eabd(%rip), %rsi     # 0x4388c
leaq 0x2ed37(%rip), %rcx     # 0x43b0d
movl $0x4af, %edx            # imm = 0x4AF
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/frontend/irgen_c.c
// Function: ir_expr_eq
static bool _ir_expr_eq(
	IRGeneratorCContext *ctx,
	ResizableString *rstr,
	ParserASTNode *node_expr
) {
	assert(ctx);
	assert(rstr);
	assert(node_expr);

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

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

	#undef	_IR_EXPR_EQ
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdx), %eax
cmpl $0xe71, %eax            # imm = 0xE71
je 0x164fa
cmpl $0xe70, %eax            # imm = 0xE70
jne 0x165ac
cmpl $0x2, 0x44(%r15)
jne 0x165bb
leaq -0x30(%rbp), %r12
movq %r12, %rdi
callq 0x7354
movq 0x68(%r15), %rsi
movq %r12, %rdi
callq 0x14901
movq 0x8(%r12), %rax
testq %rax, %rax
leaq 0x2ca4b(%rip), %rdx     # 0x42f06
cmovneq %rax, %rdx
leaq 0x2d70e(%rip), %rsi     # 0x43bd4
movq %rbx, %rdi
xorl %eax, %eax
callq 0x7945
leaq 0x2df6f(%rip), %rsi     # 0x44446
movq %rbx, %rdi
callq 0x73db
movq 0x48(%r15), %rax
movq (%rax), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x15332
leaq 0x2db50(%rip), %rsi     # 0x44048
jmp 0x16569
cmpl $0x2, 0x44(%r15)
jne 0x165da
leaq -0x30(%rbp), %r12
movq %r12, %rdi
callq 0x7354
movq 0x68(%r15), %rsi
movq %r12, %rdi
callq 0x14901
movq 0x8(%r12), %rax
testq %rax, %rax
leaq 0x2c9da(%rip), %rdx     # 0x42f06
cmovneq %rax, %rdx
leaq 0x2d69d(%rip), %rsi     # 0x43bd4
movq %rbx, %rdi
xorl %eax, %eax
callq 0x7945
leaq 0x2defe(%rip), %rsi     # 0x44446
movq %rbx, %rdi
callq 0x73db
movq 0x48(%r15), %rax
movq (%rax), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x15332
leaq 0x2dae4(%rip), %rsi     # 0x4404d
movq %rbx, %rdi
callq 0x73db
movq 0x48(%r15), %rax
movq 0x8(%rax), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x15332
leaq 0x2d47f(%rip), %rsi     # 0x43a0a
movq %rbx, %rdi
callq 0x73db
movq %r12, %rdi
callq 0x7852
movq %rbx, %rdi
movl $0x29, %esi
callq 0x74da
movb $0x1, %al
jmp 0x165ae
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2d7bf(%rip), %rdi     # 0x43d81
leaq 0x2d2c3(%rip), %rsi     # 0x4388c
leaq 0x2da2b(%rip), %rcx     # 0x43ffb
movl $0x369, %edx            # imm = 0x369
callq 0x30a0
leaq 0x2d7a0(%rip), %rdi     # 0x43d81
leaq 0x2d2a4(%rip), %rsi     # 0x4388c
leaq 0x2da0c(%rip), %rcx     # 0x43ffb
movl $0x36d, %edx            # imm = 0x36D
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/frontend/irgen_c.c
// Function: ir_expr_band
static bool _ir_expr_band(
	IRGeneratorCContext *ctx,
	ResizableString *rstr,
	ParserASTNode *node_expr
) {
	assert(ctx);
	assert(rstr);
	assert(node_expr);

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

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

	#undef	_IR_EXPR_BAND
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl (%rdx), %r13d
cmpl $0xe60, %r13d           # imm = 0xE60
jne 0x166d2
movq %rdx, %r12
cmpl $0x2, 0x44(%rdx)
jne 0x166eb
movq %rsi, %rbx
movq %rdi, %r15
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x7354
movq 0x68(%r12), %rsi
movq %r14, %rdi
callq 0x14901
movq 0x8(%r14), %rax
testq %rax, %rax
leaq 0x2c8b2(%rip), %rdx     # 0x42f06
cmovneq %rax, %rdx
leaq 0x2d575(%rip), %rsi     # 0x43bd4
movq %rbx, %rdi
xorl %eax, %eax
callq 0x7945
leaq 0x2ddd6(%rip), %rsi     # 0x44446
movq %rbx, %rdi
callq 0x73db
movq 0x48(%r12), %rax
movq (%rax), %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x15332
leaq 0x2da0f(%rip), %rsi     # 0x440a1
movq %rbx, %rdi
callq 0x73db
movq 0x48(%r12), %rax
movq 0x8(%rax), %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x15332
leaq 0x2d355(%rip), %rsi     # 0x43a0a
movq %rbx, %rdi
callq 0x73db
movq %r14, %rdi
callq 0x7852
movq %rbx, %rdi
movl $0x29, %esi
callq 0x74da
cmpl $0xe60, %r13d           # imm = 0xE60
sete %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2d68f(%rip), %rdi     # 0x43d81
leaq 0x2d193(%rip), %rsi     # 0x4388c
leaq 0x2d952(%rip), %rcx     # 0x44052
movl $0x38f, %edx            # imm = 0x38F
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/frontend/irgen_c.c
// Function: ir_expr_bxor
static bool _ir_expr_bxor(
	IRGeneratorCContext *ctx,
	ResizableString *rstr,
	ParserASTNode *node_expr
) {
	assert(ctx);
	assert(rstr);
	assert(node_expr);

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

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

	#undef	_IR_EXPR_BXOR
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl (%rdx), %r13d
cmpl $0xe50, %r13d           # imm = 0xE50
jne 0x167e3
movq %rdx, %r12
cmpl $0x2, 0x44(%rdx)
jne 0x167fc
movq %rsi, %rbx
movq %rdi, %r15
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x7354
movq 0x68(%r12), %rsi
movq %r14, %rdi
callq 0x14901
movq 0x8(%r14), %rax
testq %rax, %rax
leaq 0x2c7a1(%rip), %rdx     # 0x42f06
cmovneq %rax, %rdx
leaq 0x2d464(%rip), %rsi     # 0x43bd4
movq %rbx, %rdi
xorl %eax, %eax
callq 0x7945
leaq 0x2dcc5(%rip), %rsi     # 0x44446
movq %rbx, %rdi
callq 0x73db
movq 0x48(%r12), %rax
movq (%rax), %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x15332
leaq 0x2d951(%rip), %rsi     # 0x440f4
movq %rbx, %rdi
callq 0x73db
movq 0x48(%r12), %rax
movq 0x8(%rax), %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x15332
leaq 0x2d244(%rip), %rsi     # 0x43a0a
movq %rbx, %rdi
callq 0x73db
movq %r14, %rdi
callq 0x7852
movq %rbx, %rdi
movl $0x29, %esi
callq 0x74da
cmpl $0xe50, %r13d           # imm = 0xE50
sete %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2d57e(%rip), %rdi     # 0x43d81
leaq 0x2d082(%rip), %rsi     # 0x4388c
leaq 0x2d894(%rip), %rcx     # 0x440a5
movl $0x3b1, %edx            # imm = 0x3B1
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/frontend/irgen_c.c
// Function: ir_expr_bor
static bool _ir_expr_bor(
	IRGeneratorCContext *ctx,
	ResizableString *rstr,
	ParserASTNode *node_expr
) {
	assert(ctx);
	assert(rstr);
	assert(node_expr);

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

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

	#undef	_IR_EXPR_BOR
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl (%rdx), %r13d
cmpl $0xe40, %r13d           # imm = 0xE40
jne 0x168f4
movq %rdx, %r12
cmpl $0x2, 0x44(%rdx)
jne 0x1690d
movq %rsi, %rbx
movq %rdi, %r15
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x7354
movq 0x68(%r12), %rsi
movq %r14, %rdi
callq 0x14901
movq 0x8(%r14), %rax
testq %rax, %rax
leaq 0x2c690(%rip), %rdx     # 0x42f06
cmovneq %rax, %rdx
leaq 0x2d353(%rip), %rsi     # 0x43bd4
movq %rbx, %rdi
xorl %eax, %eax
callq 0x7945
leaq 0x2dbb4(%rip), %rsi     # 0x44446
movq %rbx, %rdi
callq 0x73db
movq 0x48(%r12), %rax
movq (%rax), %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x15332
leaq 0x2d892(%rip), %rsi     # 0x44146
movq %rbx, %rdi
callq 0x73db
movq 0x48(%r12), %rax
movq 0x8(%rax), %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x15332
leaq 0x2d133(%rip), %rsi     # 0x43a0a
movq %rbx, %rdi
callq 0x73db
movq %r14, %rdi
callq 0x7852
movq %rbx, %rdi
movl $0x29, %esi
callq 0x74da
cmpl $0xe40, %r13d           # imm = 0xE40
sete %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2d46d(%rip), %rdi     # 0x43d81
leaq 0x2cf71(%rip), %rsi     # 0x4388c
leaq 0x2d7d6(%rip), %rcx     # 0x440f8
movl $0x3d3, %edx            # imm = 0x3D3
callq 0x30a0