LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/nimble-code[P]Uno/Src/uno_generic.c
// Function: has_ident
static int
has_ident(treenode *n, char *s)
{
	if (!n) return 0;

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

	if (n->hdr.which != LEAF_T)
		switch (n->hdr.type) {
		case TN_SWITCH:
		case TN_WHILE:
		case TN_DOWHILE:
			return has_ident(n->lnode, s);
		default:
			return has_ident(n->lnode, s) || has_ident(n->rnode, s);
		}
	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %eax, %eax
testq %r14, %r14
je 0x1d0cf
movl 0x1c(%r14), %ebp
cmpl $0x2d, %ebp
je 0x1d0af
cmpl $0x1, (%r14)
je 0x1d0cf
addl $-0x1f, %ebp
movq 0x40(%r14), %rdi
movq %rbx, %rsi
callq 0x1d071
cmpl $0x3, %ebp
jb 0x1d0cf
testl %eax, %eax
jne 0x1d0ca
movq 0x48(%r14), %r14
jmp 0x1d07b
movq 0x40(%r14), %rax
movq 0x8(%rax), %rdi
movq %rbx, %rsi
callq 0x3180
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
sete %al
jmp 0x1d0cf
movl $0x1, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nimble-code[P]Uno/Src/uno_generic.c
// Function: match_args
static int
match_args(treenode *e, treenode *n, int which)	/* 1:match(mark,with,without) 2:marked(x,with,without) */
{	treenode *f, *g;
	int val1, val2, mark;

	/*	   TN_FUNC_CALL:e
		      /    \
		     /      \
		TN_IDENT  TN_EXPR_LIST:f
		   /          /         \
		match        /       TN_INT:val2
	           TN_EXPR_LIST:g
	                  /      \
		  TN_INT:mark    TN_INT:val1
	 */
		if (!e->rnode
		||   e->rnode->hdr.type != TN_EXPR_LIST)
			goto bad1;
	f = e->rnode;
		if (!f->lnode
		||   f->lnode->hdr.type != TN_EXPR_LIST)
			goto bad1;
	g = f->lnode;
		if (!g->lnode || !g->rnode)
			goto bad1;
	nogood = 0;
	val1 = eval_const_expr(g->rnode, n);
	val2 = eval_const_expr(f->rnode, n);
	mark = eval_const_expr(g->lnode, n);
	if (nogood)
	{
bad1:		err_path++;
		fprintf(stderr, "\t\t%s:%d: error match_args in '%s'\n",
			n?n->hdr.fnm:"--", n?n->hdr.line:0, x_stmnt(e));
		exit(1);
	}

	if (debug)
	{	err_path++;
		printf("%3d>>saw %s(%s,%d,%d)\n", depth, x_stmnt(e), user_name, val1, val2);
		err_path--;
	}
	return domatch(n, mark, val1, val2, which);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdi, %r13
movq 0x48(%rdi), %r15
testq %r15, %r15
je 0x1d3f6
cmpl $0xa, 0x1c(%r15)
jne 0x1d3f6
movq 0x40(%r15), %r12
testq %r12, %r12
je 0x1d3f6
cmpl $0xa, 0x1c(%r12)
jne 0x1d3f6
cmpq $0x0, 0x40(%r12)
je 0x1d3f6
movq 0x48(%r12), %rdi
testq %rdi, %rdi
je 0x1d3f6
leaq 0x63693(%rip), %rbp     # 0x80988
movl $0x0, (%rbp)
movq 0x8(%rsp), %rbx
movq %rbx, %rsi
callq 0x1b08f
movl %eax, %r14d
movq 0x48(%r15), %rdi
movq %rbx, %rsi
callq 0x1b08f
movl %eax, 0x14(%rsp)
movq 0x40(%r12), %rdi
movq %rbx, %rsi
callq 0x1b08f
cmpl $0x0, (%rbp)
jne 0x1d3f6
xorl %ebx, %ebx
cmpq $0x0, 0x8(%rsp)
je 0x1d3e5
movl %eax, %r12d
cmpl $0x2, 0x10(%rsp)
je 0x1d35b
movq 0x8(%rsp), %rcx
cmpq $0x0, 0x28(%rcx)
je 0x1d3e5
movq 0x636f6(%rip), %rcx     # 0x80a58
movq (%rcx), %rbp
testq %rbp, %rbp
je 0x1d3e5
xorl %ebx, %ebx
cmpl %r12d, 0x14(%rbp)
jne 0x1d39b
movl 0x10(%rbp), %r13d
testl %r14d, %r13d
je 0x1d39b
movl %r13d, %ecx
andl 0x14(%rsp), %ecx
jne 0x1d39b
cmpl $0x2, 0x10(%rsp)
jne 0x1d3a6
orl $0x1000000, %r13d       # imm = 0x1000000
movl %r13d, 0x10(%rbp)
movl $0x1, %ebx
movq 0x18(%rbp), %rbp
testq %rbp, %rbp
jne 0x1d36c
jmp 0x1d3e5
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %r15
testq %r15, %r15
je 0x1d39b
cmpl $0x0, (%r15)
je 0x1d3df
movq 0x8(%r15), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
movq (%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x3180
testl %eax, %eax
je 0x1d38b
movq 0x10(%r15), %r15
jmp 0x1d3b3
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x449b
// File: /workspace/github_c_makefile_star2_O1/nimble-code[P]Uno/Src/uno_generic.c
// Function: sym_add
static void
sym_add(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)
	{	if (debug) printf("	symadd - nothing to add\n");
		return;
	}

	for (r = n->hdr.defuse->other; r; r = r->nxt)
	{	if (debug) printf("\tsymadd sees %s mark %d, looking for %d & !%d\n",
			r->sm->nme->str, r->mark, allow, forbid);

		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
				&&  (unsigned int) s->status == r->mark)
				{	if (debug) printf("\tsymadd %s - already there\n",
						s->sm->nme->str);
					break;
				}
			if (!s)
			{	s = uno_getref(r->sm);
				s->nxt = gen_stack->symrefs;
				s->status = r->mark;
				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);
		}	}
	}
	if (debug) printf("\tsymadd - done\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
testq %rdi, %rdi
je 0x1de92
cmpl $0x1b, 0x1c(%rdi)
jne 0x1de92
movq 0x40(%rdi), %rdi
movq %rdi, (%rsp)
testq %rdi, %rdi
je 0x1df49
movq (%rsp), %rax
movq 0x28(%rax), %rax
testq %rax, %rax
je 0x1df49
movq 0x18(%rax), %r12
testq %r12, %r12
je 0x1df49
movl 0x4(%r12), %r13d
testl %ebp, %r13d
sete %al
testl %ebx, %r13d
setne %cl
orb %al, %cl
jne 0x1df3f
movq 0x62b7f(%rip), %rax     # 0x80a58
movq (%rax), %r14
testq %r14, %r14
je 0x1df14
movq 0x8(%r12), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %r15
movq (%r14), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
movq %r15, %rsi
callq 0x3180
testl %eax, %eax
jne 0x1df0b
cmpl %r13d, 0x10(%r14)
je 0x1df3f
movq 0x18(%r14), %r14
testq %r14, %r14
jne 0x1deee
movq 0x8(%r12), %rdi
callq 0x1439c
movq 0x62b33(%rip), %rcx     # 0x80a58
movq (%rcx), %rdx
movq %rdx, 0x18(%rax)
movl 0x4(%r12), %edx
movl %edx, 0x10(%rax)
movq (%rsp), %rdx
movq %rdx, 0x8(%rax)
movq %rax, (%rcx)
movq 0x10(%r12), %r12
jmp 0x1deb4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nimble-code[P]Uno/Src/uno_generic.c
// Function: sym_del
static void
sym_del(treenode *m, int allow, int forbid)
{	SymRef *s, *os;
	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))
		{	os = (SymRef *) 0;
again:			for (s = gen_stack->symrefs; s; os = s, s = s->nxt)
			{	if (strcmp(s->sm->nme->str, r->sm->nme->str) == 0
				&&  (s->status & allow)
				&& !(s->status & forbid))
				{	if (!os)
						gen_stack->symrefs = s->nxt;
					else
						os->nxt = s->nxt;

					if (debug) printf("\tdeleted %s\n",
						s->sm->nme->str);

					goto again;
	}	}	}	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
testq %rdi, %rdi
je 0x1df76
cmpl $0x1b, 0x1c(%rdi)
jne 0x1df76
movq 0x40(%rdi), %rdi
testq %rdi, %rdi
je 0x1e034
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0x1e034
movq 0x18(%rax), %r15
testq %r15, %r15
je 0x1e034
movq 0x62ab8(%rip), %rax     # 0x80a58
movq %rax, (%rsp)
movl 0x4(%r15), %eax
testl %ebp, %eax
sete %cl
testl %ebx, %eax
setne %al
orb %cl, %al
jne 0x1e027
movq (%rsp), %rax
movq (%rax), %rax
testq %rax, %rax
je 0x1e027
movq 0x8(%r15), %rcx
movq 0x8(%rcx), %rcx
movq 0x8(%rcx), %r14
xorl %r12d, %r12d
movq %rax, %r13
movq (%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
movq %r14, %rsi
callq 0x3180
testl %eax, %eax
jne 0x1dffd
movl 0x10(%r13), %eax
testl %ebp, %eax
sete %cl
testl %ebx, %eax
setne %al
orb %cl, %al
je 0x1e00b
movq 0x18(%r13), %rax
movq %r13, %r12
testq %rax, %rax
jne 0x1dfd1
jmp 0x1e027
leaq 0x18(%r12), %rax
testq %r12, %r12
movq (%rsp), %rdx
cmoveq %rdx, %rax
movq 0x18(%r13), %rcx
movq %rcx, (%rax)
movq (%rdx), %rax
jmp 0x1e004
movq 0x10(%r15), %r15
testq %r15, %r15
jne 0x1dfa4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1e136
movq 0x8(%rdi), %rsi
movl 0x10(%rdi), %edx
leaq 0x12f12(%rip), %rdi     # 0x3103f
xorl %eax, %eax
callq 0x3100
jmp 0x1e142
leaq 0x13333(%rip), %rdi     # 0x31470
callq 0x30a0
movq 0x6290f(%rip), %rax     # 0x80a58
movq (%rax), %r13
testq %r13, %r13
je 0x1e1c3
leaq 0x2077(%rip), %r14      # 0x201cf
leaq 0x12f03(%rip), %r15     # 0x31062
movq 0x19e6a(%rip), %rbp     # 0x37fd0
leaq 0x12f02(%rip), %r12     # 0x3106f
xorl %ebx, %ebx
incl %ebx
btl $0x18, 0x10(%r13)
movq %r14, %rdx
leaq 0x1c3a(%rip), %rax      # 0x1fdbb
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 0x10dfb
movl 0x14(%r13), %esi
movq %r12, %rdi
xorl %eax, %eax
callq 0x3100
movq 0x18(%r13), %r13
testq %r13, %r13
jne 0x1e16f
jmp 0x1e1c5
xorl %ebx, %ebx
movq (%rsp), %rax
testq %rax, %rax
je 0x1e24c
movq 0x28(%rax), %rax
testq %rax, %rax
je 0x1e24c
movq 0x18(%rax), %r12
testq %r12, %r12
je 0x1e24c
incl %ebx
leaq 0x1fe6(%rip), %rbp      # 0x201cf
leaq 0x12e72(%rip), %r14     # 0x31062
movq 0x19dd9(%rip), %r13     # 0x37fd0
leaq 0x1328d(%rip), %r15     # 0x3148b
cmpl $0x0, (%r12)
movq %rbp, %rdx
leaq 0x1bae(%rip), %rax      # 0x1fdbb
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 0x10dfb
movq %r15, %rdi
callq 0x30a0
movq 0x10(%r12), %r12
incl %ebx
testq %r12, %r12
jne 0x1e1fe
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movq %rdi, %r14
testq %rdi, %rdi
je 0x1e277
cmpl $0x1b, 0x1c(%r14)
jne 0x1e277
movq 0x40(%r14), %r14
movq 0x627da(%rip), %rax     # 0x80a58
movq (%rax), %rax
testq %rax, %rax
je 0x1e292
testb $0x1, 0x13(%rax)
jne 0x1e2f9
movq 0x18(%rax), %rax
jmp 0x1e281
testq %r14, %r14
je 0x1e2e4
movq 0x28(%r14), %rax
testq %rax, %rax
je 0x1e2e4
movq 0x18(%rax), %r15
testq %r15, %r15
je 0x1e2e4
movl $0x1000000, %ebp        # imm = 0x1000000
cmpl $0x0, (%r15)
je 0x1e2db
movq 0x8(%r15), %rdi
callq 0x1439c
movq 0x62794(%rip), %rcx     # 0x80a58
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 0x1e2ae
movq 0x6276d(%rip), %rax     # 0x80a58
movq (%rax), %rax
testq %rax, %rax
je 0x1e302
testb $0x1, 0x13(%rax)
je 0x1e2fc
movl %ebx, 0x14(%rax)
addq $0x18, %rax
jmp 0x1e2eb
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x62744(%rip), %rax     # 0x80a58
movq (%rax), %rax
testq %rax, %rax
je 0x1e34f
movq 0x62735(%rip), %rcx     # 0x80a58
xorl %edx, %edx
testb $0x1, 0x13(%rax)
movq %rax, %rsi
je 0x1e343
leaq 0x18(%rdx), %rsi
testq %rdx, %rdx
movq 0x18(%rax), %rdi
cmoveq %rcx, %rsi
movq %rdi, (%rsi)
movq %rdx, %rsi
movq 0x18(%rax), %rax
movq %rsi, %rdx
testq %rax, %rax
jne 0x1e325
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r14
movq %rdi, %rcx
testq %rdi, %rdi
je 0x1e379
cmpl $0x1b, 0x1c(%r14)
movq %r14, %rcx
jne 0x1e379
movq 0x40(%r14), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x1e428
movq 0x28(%rcx), %rcx
testq %rcx, %rcx
je 0x1e428
movq 0x18(%rcx), %r13
testq %r13, %r13
je 0x1e428
movq 0x626b3(%rip), %rax     # 0x80a58
movq %rax, (%rsp)
movl 0x4(%r13), %eax
testl %r15d, %eax
sete %cl
testl %ebp, %eax
setne %al
orb %cl, %al
jne 0x1e406
movq (%rsp), %rax
movq (%rax), %rbx
testq %rbx, %rbx
je 0x1e406
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 0x3180
testl %eax, %eax
jne 0x1e3fd
movl 0x10(%rbx), %eax
testl %r15d, %eax
sete %cl
testl %ebp, %eax
setne %al
orb %cl, %al
je 0x1e413
movq 0x18(%rbx), %rbx
testq %rbx, %rbx
jne 0x1e3d4
movq 0x10(%r13), %r13
testq %r13, %r13
jne 0x1e3a9
xorl %eax, %eax
jmp 0x1e428
movq 0x8(%rbx), %rcx
movl $0x1, %eax
cmpq %r14, %rcx
je 0x1e428
movq %rcx, 0x62648(%rip)     # 0x80a70
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6261a(%rip), %rax     # 0x80a58
movq (%rax), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x1e47a
movl 0x10(%rcx), %r8d
testl %esi, %r8d
sete %r9b
testl %edx, %r8d
setne %r8b
orb %r9b, %r8b
je 0x1e465
movq 0x18(%rcx), %rcx
jmp 0x1e443
movq 0x8(%rcx), %rcx
movl $0x1, %eax
cmpq %rdi, %rcx
je 0x1e47a
movq %rcx, 0x625f6(%rip)     # 0x80a70
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r14
movq %rdi, %rcx
testq %rdi, %rdi
je 0x1e4a4
cmpl $0x1b, 0x1c(%r14)
movq %r14, %rcx
jne 0x1e4a4
movq 0x40(%r14), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x1e53d
movq 0x28(%rcx), %rcx
testq %rcx, %rcx
je 0x1e53d
movq 0x18(%rcx), %r13
testq %r13, %r13
je 0x1e53d
movq 0x6258c(%rip), %rax     # 0x80a58
movq %rax, (%rsp)
movl 0x4(%r13), %eax
testl %r15d, %eax
sete %cl
testl %ebp, %eax
setne %al
orb %cl, %al
jne 0x1e51b
movq (%rsp), %rax
movq (%rax), %rbx
testq %rbx, %rbx
je 0x1e51b
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 0x3180
testl %eax, %eax
je 0x1e528
movq 0x18(%rbx), %rbx
testq %rbx, %rbx
jne 0x1e4fb
movq 0x10(%r13), %r13
testq %r13, %r13
jne 0x1e4d0
xorl %eax, %eax
jmp 0x1e53d
movq 0x8(%rbx), %rcx
movl $0x1, %eax
cmpq %r14, %rcx
je 0x1e53d
movq %rcx, 0x62533(%rip)     # 0x80a70
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1e908
movl 0x1c(%rdi), %eax
movl $0x1, %ebx
cmpl $0x2d, %eax
je 0x1e908
cmpl $0x1c, %eax
jne 0x1e906
movq 0x40(%rdi), %rax
testq %rax, %rax
je 0x1e906
cmpl $0x2d, 0x1c(%rax)
jne 0x1e906
movq 0x8(%rsi), %rcx
movq 0x8(%rcx), %rcx
movq 0x8(%rcx), %rdi
movq 0x40(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x3180
testl %eax, %eax
je 0x1e908
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1eb4d
movq 0x40(%rdi), %rax
xorl %ebp, %ebp
testq %rax, %rax
je 0x1eb81
cmpl $0x2d, 0x1c(%rax)
jne 0x1eb81
movq 0x40(%rax), %rax
movq 0x8(%rax), %rdi
movq 0x1963f(%rip), %rsi     # 0x381a8
callq 0x3180
testl %eax, %eax
jne 0x1eb81
movq 0x61edf(%rip), %rax     # 0x80a58
addl %ebx, 0x8(%rax)
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1eba9
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0x1eb8a
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
je 0x1ebac
popq %rbx
retq
xorl %eax, %eax
retq
movq 0x61ebd(%rip), %rcx     # 0x80a70
testq %rcx, %rcx
je 0x1ebd6
movq 0x10(%rbx), %rdi
movl $0x0, %eax
cmpq %rdi, %rcx
jne 0x1eba7
callq 0x1b28b
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
setne %al
jmp 0x1eba7
xorl %eax, %eax
jmp 0x1eba7
// File: /workspace/github_c_makefile_star2_O1/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
movq %rdi, %rbx
leaq 0x19574(%rip), %r14     # 0x3815c
testq %rbx, %rbx
je 0x1ec1c
cmpl $0x0, (%r14)
jne 0x1ebfc
movq 0x20(%rbx), %rdi
callq 0x1ebda
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x1ec10
movl 0x1c(%rax), %ecx
addl $-0x1f, %ecx
cmpl $0x3, %ecx
jae 0x1ec21
cmpl $0x0, (%r14)
je 0x1ec1c
movq 0x20(%rbx), %rbx
jmp 0x1ebe8
popq %rbx
popq %r14
popq %rbp
retq
cmpq 0x61e48(%rip), %rax     # 0x80a70
jne 0x1ec34
movl $0x2a, %edi
callq 0x3040
cmpq $0x0, 0x18(%rbx)
je 0x1ec45
movl $0x43, %edi
callq 0x3040
cmpl $0x0, (%r14)
jne 0x1ec68
movl 0x61e33(%rip), %esi     # 0x80a84
leal 0x1(%rsi), %eax
movl %eax, 0x61e2a(%rip)     # 0x80a84
leaq 0x12794(%rip), %rdi     # 0x313f5
xorl %eax, %eax
callq 0x3100
movq 0x10(%rbx), %rdi
movq 0x8(%rdi), %r14
movl 0x10(%rdi), %ebp
callq 0x5e8a
leaq 0x1277b(%rip), %rdi     # 0x313fa
movq %r14, %rsi
movl %ebp, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3100
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x1ecad
callq 0x5e8a
leaq 0x12764(%rip), %rdi     # 0x31407
movq %rax, %rsi
xorl %eax, %eax
callq 0x3100
leaq 0x11805(%rip), %rdi     # 0x304b9
popq %rbx
popq %r14
popq %rbp
jmp 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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
movq %rsi, %r14
movq %rdi, %r15
testq %r15, %r15
sete %al
testq %r14, %r14
setne %cl
xorl %ebx, %ebx
cmpb %cl, %al
je 0x1eda8
cmpq %r14, %r15
je 0x1ed2f
movl 0x18(%r15), %eax
cmpl 0x18(%r14), %eax
jne 0x1eda8
movl (%r15), %ecx
cmpl (%r14), %ecx
jne 0x1eda8
movl 0x1c(%r15), %edx
cmpl 0x1c(%r14), %edx
jne 0x1eda8
cmpl $0x1, %ecx
je 0x1ed36
movq 0x40(%r15), %rdi
movq 0x40(%r14), %rsi
callq 0x1ecbd
testl %eax, %eax
je 0x1eda8
movq 0x48(%r15), %r15
movq 0x48(%r14), %r14
jmp 0x1ecc8
movl $0x1, %ebx
jmp 0x1eda8
leal -0x2d(%rdx), %ecx
cmpl $0x4, %ecx
ja 0x1edb0
leaq 0x121db(%rip), %rdx     # 0x30f20
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq 0x40(%r15), %rax
movq 0x8(%rax), %rdi
movq 0x40(%r14), %rax
movq 0x8(%rax), %rsi
callq 0x3180
xorl %ebx, %ebx
testl %eax, %eax
jmp 0x1eda5
movsd 0x40(%r14), %xmm0
cmpeqsd 0x40(%r15), %xmm0
movq %xmm0, %rbx
andl $0x1, %ebx
jmp 0x1eda8
cmpl $0x105, %eax            # imm = 0x105
jne 0x1eda8
movq 0x40(%r15), %rax
movq 0x8(%rax), %rax
movq 0x40(%r14), %rcx
xorl %ebx, %ebx
cmpq 0x8(%rcx), %rax
jmp 0x1eda5
movl 0x40(%r15), %eax
xorl %ebx, %ebx
cmpl 0x40(%r14), %eax
sete %bl
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %r15, %rdi
movq %r14, %rsi
callq 0x4589
// File: /workspace/github_c_makefile_star2_O1/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 0xc343
movq %rdi, %r15
cmpq $0x0, 0x8(%rdi)
je 0xc362
movq %rsi, %r14
testq %rsi, %rsi
je 0xc381
movl $0x48, %edi
callq 0x3110
testq %rax, %rax
je 0xc3a0
movq %rax, %rbx
movq %r15, (%rax)
movq %r14, 0x8(%rax)
callq 0x792a
movq %rax, %r14
movq %rax, 0x10(%rbx)
callq 0x792a
movq %rax, %r15
movq %rax, 0x18(%rbx)
callq 0x792a
movq %rax, %r12
movq %rax, 0x20(%rbx)
callq 0x792a
movq %rax, %r13
movq %rax, 0x28(%rbx)
movq $0x0, 0x30(%rbx)
movq %r14, %rdi
callq 0x7548
movq %r15, %rdi
callq 0x7548
movq %r12, %rdi
callq 0x7548
movq %r13, %rdi
callq 0x7548
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3601a(%rip), %rdi     # 0x42364
leaq 0x35fc7(%rip), %rsi     # 0x42318
leaq 0x36056(%rip), %rcx     # 0x423ae
movl $0x135c, %edx           # imm = 0x135C
callq 0x30a0
leaq 0x36007(%rip), %rdi     # 0x42370
leaq 0x35fa8(%rip), %rsi     # 0x42318
leaq 0x36037(%rip), %rcx     # 0x423ae
movl $0x135d, %edx           # imm = 0x135D
callq 0x30a0
leaq 0x36022(%rip), %rdi     # 0x423aa
leaq 0x35f89(%rip), %rsi     # 0x42318
leaq 0x36018(%rip), %rcx     # 0x423ae
movl $0x135e, %edx           # imm = 0x135E
callq 0x30a0
callq 0x31a0
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
testq %rdi, %rdi
je 0xc446
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0xc465
cmpq $0x0, 0x18(%rbx)
je 0xc484
cmpq $0x0, 0x20(%rbx)
je 0xc4a3
cmpq $0x0, 0x28(%rbx)
je 0xc4c2
leaq 0x10(%rbx), %r14
callq 0x7a38
movq 0x18(%rbx), %rdi
callq 0x7a38
movq 0x20(%rbx), %rdi
callq 0x7a38
movq 0x28(%rbx), %rdi
callq 0x7a38
movq 0x10(%rbx), %rdi
callq 0x3190
movq 0x18(%rbx), %rdi
callq 0x3190
movq 0x20(%rbx), %rdi
callq 0x3190
movq 0x28(%rbx), %rdi
callq 0x3190
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movups %xmm0, (%r14)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x3190
leaq 0x42519(%rip), %rdi     # 0x4e966
leaq 0x35ec4(%rip), %rsi     # 0x42318
leaq 0x35fbf(%rip), %rcx     # 0x4241a
movl $0x137a, %edx           # imm = 0x137A
callq 0x30a0
leaq 0x35fdf(%rip), %rdi     # 0x4244b
leaq 0x35ea5(%rip), %rsi     # 0x42318
leaq 0x35fa0(%rip), %rcx     # 0x4241a
movl $0x137b, %edx           # imm = 0x137B
callq 0x30a0
leaq 0x35fcc(%rip), %rdi     # 0x42457
leaq 0x35e86(%rip), %rsi     # 0x42318
leaq 0x35f81(%rip), %rcx     # 0x4241a
movl $0x137c, %edx           # imm = 0x137C
callq 0x30a0
leaq 0x35fb7(%rip), %rdi     # 0x42461
leaq 0x35e67(%rip), %rsi     # 0x42318
leaq 0x35f62(%rip), %rcx     # 0x4241a
movl $0x137d, %edx           # imm = 0x137D
callq 0x30a0
leaq 0x35fa2(%rip), %rdi     # 0x4246b
leaq 0x35e48(%rip), %rsi     # 0x42318
leaq 0x35f43(%rip), %rcx     # 0x4241a
movl $0x137e, %edx           # imm = 0x137E
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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 0xcbb7
movq %rsi, %r14
testq %rsi, %rsi
je 0xcbd6
movq %rdi, %rbx
movl $0x5f, %esi
callq 0x76cb
movq 0x10(%r14), %rax
movq 0x8(%rax), %rsi
movl 0x4(%rax), %edx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x7768
leaq 0x33e92(%rip), %rdi     # 0x40a50
leaq 0x35753(%rip), %rsi     # 0x42318
leaq 0x35a40(%rip), %rcx     # 0x4260c
movl $0x7c, %edx
callq 0x30a0
leaq 0x35a82(%rip), %rdi     # 0x4265f
leaq 0x35734(%rip), %rsi     # 0x42318
leaq 0x35a21(%rip), %rcx     # 0x4260c
movl $0x7d, %edx
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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 0xd074
movq %rdi, %rbx
callq 0x7548
leaq 0x10(%rbx), %rdi
callq 0x7548
leaq 0x20(%rbx), %rdi
callq 0x7548
addq $0x30, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x7548
leaq 0x35b0d(%rip), %rdi     # 0x42b88
leaq 0x35296(%rip), %rsi     # 0x42318
leaq 0x35b0b(%rip), %rcx     # 0x42b94
movl $0x3b, %edx
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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 0xd7be
movq %rdi, %rbx
callq 0x7a38
leaq 0x10(%rbx), %rdi
callq 0x7a38
leaq 0x20(%rbx), %rdi
callq 0x7a38
addq $0x30, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x7a38
leaq 0x353c3(%rip), %rdi     # 0x42b88
leaq 0x34b4c(%rip), %rsi     # 0x42318
leaq 0x36679(%rip), %rcx     # 0x43e4c
movl $0x48, %edx
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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 0xda6f
movq %rsi, %r14
testq %rsi, %rsi
je 0xda8e
movq %rdi, %rbx
movl $0x5f, %esi
callq 0x76cb
movq 0x8(%r14), %rsi
movl 0x4(%r14), %edx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x7768
leaq 0x32fda(%rip), %rdi     # 0x40a50
leaq 0x3489b(%rip), %rsi     # 0x42318
leaq 0x34edf(%rip), %rcx     # 0x42963
movl $0x89, %edx
callq 0x30a0
leaq 0x34f21(%rip), %rdi     # 0x429b6
leaq 0x3487c(%rip), %rsi     # 0x42318
leaq 0x34ec0(%rip), %rcx     # 0x42963
movl $0x8a, %edx
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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 0xddef
testq %rdx, %rdx
je 0xde0e
testq %rcx, %rcx
je 0xde2d
cmpl $0xe00, (%rcx)          # imm = 0xE00
jne 0xde4c
cmpl $0x1, 0x44(%rcx)
jne 0xde6b
movq 0x48(%rcx), %rax
movq (%rax), %rcx
popq %rbp
jmp 0xde8a
leaq 0x32c5a(%rip), %rdi     # 0x40a50
leaq 0x3451b(%rip), %rsi     # 0x42318
leaq 0x34db6(%rip), %rcx     # 0x42bba
movl $0xe4d, %edx            # imm = 0xE4D
callq 0x30a0
leaq 0x34d73(%rip), %rdi     # 0x42b88
leaq 0x344fc(%rip), %rsi     # 0x42318
leaq 0x34d97(%rip), %rcx     # 0x42bba
movl $0xe4e, %edx            # imm = 0xE4E
callq 0x30a0
leaq 0x35f62(%rip), %rdi     # 0x43d96
leaq 0x344dd(%rip), %rsi     # 0x42318
leaq 0x34d78(%rip), %rcx     # 0x42bba
movl $0xe4f, %edx            # imm = 0xE4F
callq 0x30a0
leaq 0x34dc6(%rip), %rdi     # 0x42c19
leaq 0x344be(%rip), %rsi     # 0x42318
leaq 0x34d59(%rip), %rcx     # 0x42bba
movl $0xe50, %edx            # imm = 0xE50
callq 0x30a0
leaq 0x3e87e(%rip), %rdi     # 0x4c6f0
leaq 0x3449f(%rip), %rsi     # 0x42318
leaq 0x34d3a(%rip), %rcx     # 0x42bba
movl $0xe51, %edx            # imm = 0xE51
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/frontend/irgen.c
// Function: ir_expr_shift
static bool _ir_expr_shift(
	IRGeneratorContext *ctx,
	ResizableString *rstr,
	_ExprResult *expr_result,
	ParserASTNode *node
) {
	assert(ctx);
	assert(rstr);
	assert(expr_result);
	assert(node);

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

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rcx, %r8
movq %rdx, %rcx
movl (%r8), %eax
cmpl $0xe91, %eax            # imm = 0xE91
je 0xf843
cmpl $0xe90, %eax            # imm = 0xE90
jne 0xf855
cmpl $0x2, 0x44(%r8)
jne 0xf859
xorl %edx, %edx
callq 0x12044
jmp 0xf851
cmpl $0x2, 0x44(%r8)
jne 0xf878
xorl %edx, %edx
callq 0x1229a
movb $0x1, %al
jmp 0xf857
xorl %eax, %eax
popq %rbp
retq
leaq 0x3c3f5(%rip), %rdi     # 0x4bc55
leaq 0x32ab1(%rip), %rsi     # 0x42318
leaq 0x33d77(%rip), %rcx     # 0x435e5
movl $0xa48, %edx            # imm = 0xA48
callq 0x30a0
leaq 0x3c3d6(%rip), %rdi     # 0x4bc55
leaq 0x32a92(%rip), %rsi     # 0x42318
leaq 0x33d58(%rip), %rcx     # 0x435e5
movl $0xa4f, %edx            # imm = 0xA4F
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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 0x10df4
movq %rcx, %r13
testq %rcx, %rcx
je 0x10e13
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq -0x38(%rbp), %rbx
movq %rbx, %rdi
callq 0x7548
movq %rbx, %rdi
movq %r13, %rsi
callq 0xcbf5
movq 0x8(%rbx), %r13
testq %r13, %r13
leaq 0x33114(%rip), %rax     # 0x43eba
cmoveq %rax, %r13
movq %r15, %rdi
movq %r14, %rsi
callq 0x10e32
movq 0x30(%r12), %rdi
movq 0x8(%r14), %rdx
testq %rdx, %rdx
leaq 0x330f2(%rip), %rax     # 0x43eba
cmoveq %rax, %rdx
leaq 0x31fa2(%rip), %rsi     # 0x42d75
movq %r13, %rcx
xorl %eax, %eax
callq 0x7b31
movq %rbx, %rdi
callq 0x7a38
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2fc55(%rip), %rdi     # 0x40a50
leaq 0x31516(%rip), %rsi     # 0x42318
leaq 0x31f00(%rip), %rcx     # 0x42d09
movl $0x1c9, %edx            # imm = 0x1C9
callq 0x30a0
leaq 0x3189d(%rip), %rdi     # 0x426b7
leaq 0x314f7(%rip), %rsi     # 0x42318
leaq 0x31ee1(%rip), %rcx     # 0x42d09
movl $0x1ca, %edx            # imm = 0x1CA
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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 0x10e5e
testq %rsi, %rsi
je 0x10e7d
movl 0x54(%rdi), %edx
leal 0x1(%rdx), %eax
movl %eax, 0x54(%rdi)
leaq 0x31f85(%rip), %rax     # 0x42dd5
movq %rsi, %rdi
movq %rax, %rsi
xorl %eax, %eax
popq %rbp
jmp 0x7b31
leaq 0x330b6(%rip), %rdi     # 0x43f1b
leaq 0x314ac(%rip), %rsi     # 0x42318
leaq 0x31f0f(%rip), %rcx     # 0x42d82
movl $0x168, %edx            # imm = 0x168
callq 0x30a0
leaq 0x2fbcc(%rip), %rdi     # 0x40a50
leaq 0x3148d(%rip), %rsi     # 0x42318
leaq 0x31ef0(%rip), %rcx     # 0x42d82
movl $0x169, %edx            # imm = 0x169
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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 0x10f46
movq %rdx, %rbx
testq %rdx, %rdx
je 0x10f65
movq %rcx, %r13
testq %rcx, %rcx
je 0x10f84
movq %rsi, %r12
movq %rdi, %r15
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x7548
movq %r14, %rdi
movq %r13, %rsi
callq 0xcbf5
movq 0x8(%r14), %r13
testq %r13, %r13
leaq 0x32fc1(%rip), %rax     # 0x43eba
cmoveq %rax, %r13
movq %r12, %rdi
movq %rbx, %rsi
callq 0x10e32
movq 0x30(%r15), %rdi
movq 0x8(%rbx), %rdx
testq %rdx, %rdx
leaq 0x32fa0(%rip), %rax     # 0x43eba
cmoveq %rax, %rdx
leaq 0x3214c(%rip), %rsi     # 0x43071
movq %r13, %rcx
xorl %eax, %eax
callq 0x7b31
movq %r14, %rdi
callq 0x7a38
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x32fce(%rip), %rdi     # 0x43f1b
leaq 0x313c4(%rip), %rsi     # 0x42318
leaq 0x320ae(%rip), %rcx     # 0x43009
movl $0x1b2, %edx            # imm = 0x1B2
callq 0x30a0
leaq 0x2fae4(%rip), %rdi     # 0x40a50
leaq 0x313a5(%rip), %rsi     # 0x42318
leaq 0x3208f(%rip), %rcx     # 0x43009
movl $0x1b3, %edx            # imm = 0x1B3
callq 0x30a0
leaq 0x3172c(%rip), %rdi     # 0x426b7
leaq 0x31386(%rip), %rsi     # 0x42318
leaq 0x32070(%rip), %rcx     # 0x43009
movl $0x1b4, %edx            # imm = 0x1B4
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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 0x12891
movq %rsi, %r15
testq %rsi, %rsi
je 0x128b0
movl %edx, %ebx
movq %rdi, %r14
leaq -0x30(%rbp), %r12
movq %r12, %rdi
callq 0x7548
movq %r12, %rdi
movq %r15, %rsi
callq 0xcbf5
movq 0x8(%r12), %rax
testq %rax, %rax
leaq 0x31655(%rip), %rdx     # 0x43eba
cmovneq %rax, %rdx
leaq 0x312f7(%rip), %rsi     # 0x43b67
movq %r14, %rdi
movl %ebx, %ecx
xorl %eax, %eax
callq 0x7b31
movq %r12, %rdi
callq 0x7a38
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2e1b8(%rip), %rdi     # 0x40a50
leaq 0x2fa79(%rip), %rsi     # 0x42318
leaq 0x31272(%rip), %rcx     # 0x43b18
movl $0x1de, %edx            # imm = 0x1DE
callq 0x30a0
leaq 0x2fe05(%rip), %rdi     # 0x426bc
leaq 0x2fa5a(%rip), %rsi     # 0x42318
leaq 0x31253(%rip), %rcx     # 0x43b18
movl $0x1df, %edx            # imm = 0x1DF
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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 0x129bc
testq %rdx, %rdx
je 0x129db
movq %rcx, %r13
testq %rcx, %rcx
je 0x129fa
movq %rdx, -0x30(%rbp)
testq %r8, %r8
je 0x12a19
movq %rsi, %r14
movq %rdi, %r15
movq 0x68(%r8), %r12
leaq -0x50(%rbp), %rbx
movq %rbx, %rdi
callq 0x7548
movq %rbx, %rdi
movq %r12, %rsi
callq 0xcbf5
leaq -0x40(%rbp), %r12
movq %r12, %rdi
callq 0x7548
movq 0x40(%r15), %rsi
leaq 0x46d25(%rip), %rcx     # 0x59668
movq %r15, %rdi
movq %r12, %rdx
callq 0x10e9c
movq 0x28(%r13), %rcx
testq %rcx, %rcx
leaq 0x3155e(%rip), %r15     # 0x43eba
cmoveq %r15, %rcx
movq 0x8(%r12), %rdx
testq %rdx, %rdx
cmoveq %r15, %rdx
movq 0x8(%rbx), %r8
testq %r8, %r8
cmoveq %r15, %r8
leaq 0x31289(%rip), %rsi     # 0x43c07
movq %r14, %rdi
xorl %eax, %eax
callq 0x7b31
movq 0x8(%r12), %rsi
testq %rsi, %rsi
cmoveq %r15, %rsi
movq -0x30(%rbp), %rdi
callq 0x75cf
movq %rbx, %rdi
callq 0x7a38
movq %r12, %rdi
callq 0x7a38
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2e08d(%rip), %rdi     # 0x40a50
leaq 0x2f94e(%rip), %rsi     # 0x42318
leaq 0x311a3(%rip), %rcx     # 0x43b74
movl $0xb9e, %edx            # imm = 0xB9E
callq 0x30a0
leaq 0x3120b(%rip), %rdi     # 0x43bed
leaq 0x2f92f(%rip), %rsi     # 0x42318
leaq 0x31184(%rip), %rcx     # 0x43b74
movl $0xb9f, %edx            # imm = 0xB9F
callq 0x30a0
leaq 0x30187(%rip), %rdi     # 0x42b88
leaq 0x2f910(%rip), %rsi     # 0x42318
leaq 0x31165(%rip), %rcx     # 0x43b74
movl $0xba0, %edx            # imm = 0xBA0
callq 0x30a0
leaq 0x311dd(%rip), %rdi     # 0x43bfd
leaq 0x2f8f1(%rip), %rsi     # 0x42318
leaq 0x31146(%rip), %rcx     # 0x43b74
movl $0xba1, %edx            # imm = 0xBA1
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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 0x147ea
movq %rdi, %r14
cmpq $0x0, 0x8(%rdi)
je 0x14809
movq %rsi, %rbx
testq %rsi, %rsi
je 0x14828
movl $0x20, %edi
callq 0x3110
testq %rax, %rax
je 0x14847
movq %rax, %r15
movq %r14, (%rax)
movq %rbx, 0x8(%rax)
movq %rax, %rdi
addq $0x10, %rdi
callq 0x7548
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2db73(%rip), %rdi     # 0x42364
leaq 0x2ffc4(%rip), %rsi     # 0x447bc
leaq 0x30009(%rip), %rcx     # 0x44808
movl $0x777, %edx            # imm = 0x777
callq 0x30a0
leaq 0x2db60(%rip), %rdi     # 0x42370
leaq 0x2ffa5(%rip), %rsi     # 0x447bc
leaq 0x2ffea(%rip), %rcx     # 0x44808
movl $0x778, %edx            # imm = 0x778
callq 0x30a0
leaq 0x2db7b(%rip), %rdi     # 0x423aa
leaq 0x2ff86(%rip), %rsi     # 0x447bc
leaq 0x2ffcb(%rip), %rcx     # 0x44808
movl $0x779, %edx            # imm = 0x779
callq 0x30a0
callq 0x31cb
// File: /workspace/github_c_makefile_star2_O1/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 0x15007
movq %rdx, %r15
testq %rdx, %rdx
je 0x15026
cmpl $0xe00, (%r15)          # imm = 0xE00
jne 0x15045
cmpl $0x1, 0x44(%r15)
jne 0x15064
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movq %r15, %rsi
callq 0x1531c
testb %al, %al
je 0x14feb
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 0x155d5
leaq 0x2ba42(%rip), %rdi     # 0x40a50
leaq 0x2f7a7(%rip), %rsi     # 0x447bc
leaq 0x2fa24(%rip), %rcx     # 0x44a40
movl $0x4ac, %edx            # imm = 0x4AC
callq 0x30a0
leaq 0x2fa64(%rip), %rdi     # 0x44a91
leaq 0x2f788(%rip), %rsi     # 0x447bc
leaq 0x2fa05(%rip), %rcx     # 0x44a40
movl $0x4ad, %edx            # imm = 0x4AD
callq 0x30a0
leaq 0x2f265(%rip), %rdi     # 0x442b1
leaq 0x2f769(%rip), %rsi     # 0x447bc
leaq 0x2f9e6(%rip), %rcx     # 0x44a40
movl $0x4ae, %edx            # imm = 0x4AE
callq 0x30a0
leaq 0x2fa30(%rip), %rdi     # 0x44a9b
leaq 0x2f74a(%rip), %rsi     # 0x447bc
leaq 0x2f9c7(%rip), %rcx     # 0x44a40
movl $0x4af, %edx            # imm = 0x4AF
callq 0x30a0