LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]gh_cpp/Src/gh_cpp3.c
// Function: eval_expr
int
eval_expr(TS *p)
{	int v;

	if (!p
	||  !p->nxt
	||   p->tok != CHAR
	||   p->val != '#'
	||  !(p->nxt->tok == NAME)
	|| (strcmp(p->nxt->name, "if") != 0
	&&  strcmp(p->nxt->name, "elif") != 0))
		fatal_error("cannot happen, eval_expr");

	strcpy(err_s, "");

	pp = p->nxt;
	lat = nxt_token();
	push_expr(4);

	if (verbose>1) dump_stack("stack:");

	if (lat != DONE) syntax_error("bad expression");

	v = interpret();	/* evaluate expression on stack */
	assert(valptr == 0);
	if (verbose>1) printf("eval result: %d\n", v);
	return v?1:0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
je 0x9137
movq 0x28(%rbx), %r14
testq %r14, %r14
je 0x9137
cmpl $0x2, (%rbx)
jne 0x9137
cmpl $0x23, 0x4(%rbx)
jne 0x9137
cmpl $0x1, (%r14)
jne 0x9137
movq 0x8(%r14), %rdi
cmpb $0x69, (%rdi)
jne 0x9123
cmpb $0x66, 0x1(%rdi)
jne 0x9123
cmpb $0x0, 0x2(%rdi)
je 0x91f7
leaq 0x591f(%rip), %rsi      # 0xea49
callq 0x4140
testl %eax, %eax
je 0x91f7
leaq 0x6362(%rip), %rdi      # 0xf4a0
callq 0x4a2c
movq 0x28(%rbx), %r14
movb $0x0, 0xd352(%rip)      # 0x164a0
movq %r14, 0xd74b(%rip)      # 0x168a0
testq %r14, %r14
je 0x9191
movq 0x28(%r14), %rax
testq %rax, %rax
je 0x9191
movq %rax, 0xd736(%rip)      # 0x168a0
movl 0x4(%rax), %ecx
leaq 0xb184(%rip), %rdx      # 0x142f8
movl %ecx, (%rdx)
leaq 0xb167(%rip), %rdx      # 0x142e4
movb %cl, (%rdx)
movq 0x8(%rax), %rcx
leaq 0xb15e(%rip), %rdx      # 0x142e8
movq %rcx, (%rdx)
movl (%rax), %eax
jmp 0x9193
xorl %eax, %eax
movl %eax, 0xd70f(%rip)      # 0x168a8
movl $0x4, %edi
callq 0x9235
leaq 0xad06(%rip), %r14      # 0x13eb0
cmpl $0x2, (%r14)
jl 0x91bc
leaq 0x6302(%rip), %rdi      # 0xf4b9
callq 0x959b
cmpl $0x0, 0xd6e5(%rip)      # 0x168a8
jne 0x920a
callq 0x96dc
cmpl $0x0, 0xd6db(%rip)      # 0x168ac
jne 0x9216
movl %eax, %ebx
cmpl $0x2, (%r14)
jl 0x91eb
leaq 0x6317(%rip), %rdi      # 0xf4f9
movl %ebx, %esi
xorl %eax, %eax
callq 0x40c0
xorl %eax, %eax
testl %ebx, %ebx
setne %al
popq %rbx
popq %r14
popq %rbp
retq
movb $0x0, 0xd2a2(%rip)      # 0x164a0
movq %r14, 0xd69b(%rip)      # 0x168a0
jmp 0x915a
leaq 0x62af(%rip), %rdi      # 0xf4c0
callq 0x964d
leaq 0x62b2(%rip), %rdi      # 0xf4cf
leaq 0x62b7(%rip), %rsi      # 0xf4db
leaq 0x62ba(%rip), %rcx      # 0xf4e5
movl $0x1bb, %edx            # imm = 0x1BB
callq 0x40e0
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]gh_cpp/Src/gh_cpp3.c
// Function: dump_stack
static void
dump_stack(char *s)	/* verbose/debugging mode only */
{	int i;

	printf("=== ");
	printf("%s:\n", s);
	for (i = 0; i < valptr; i++)
	{	printf("%2d:	", i);
		tokname(valstack[i].tok, stdout);
		printf("[%d]", valstack[i].val);
		printf("\n");
	}
	printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x5fd2(%rip), %rdi      # 0xf585
xorl %eax, %eax
callq 0x40c0
leaq 0x5fc9(%rip), %rdi      # 0xf58a
movq %rbx, %rsi
xorl %eax, %eax
callq 0x40c0
cmpl $0x0, 0xd2da(%rip)      # 0x168ac
jle 0x9635
leaq 0x5fb4(%rip), %rbx      # 0xf58f
leaq 0xd2ce(%rip), %r12      # 0x168b0
movq 0x89e7(%rip), %r13      # 0x11fd0
leaq 0x5fa5(%rip), %r14      # 0xf595
xorl %r15d, %r15d
movq %rbx, %rdi
movl %r15d, %esi
xorl %eax, %eax
callq 0x40c0
movl 0x4(%r12,%r15,8), %edi
movq (%r13), %rsi
callq 0x4aae
movl (%r12,%r15,8), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x40c0
movl $0xa, %edi
callq 0x4040
incq %r15
movslq 0xd27c(%rip), %rax      # 0x168ac
cmpq %rax, %r15
jl 0x95f3
movl $0xa, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4040
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]gh_cpp/Src/gh_cpp3.c
// Function: syntax_error
static void
syntax_error(char *s)
{
	fprintf(stderr, "%s,%d: expr: syntax error at '%s' (%s)\n",
		filename, lineno, ibuf, s);
	fprintf(stderr, "unexpected '");
	tokname(lat, stderr);
	fprintf(stderr, "'\n");

	show_line(0, stderr);
	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %r9
movq 0x899b(%rip), %rbx      # 0x11ff8
movq (%rbx), %rdi
leaq 0x8aa9(%rip), %rax      # 0x12110
movq (%rax), %rdx
leaq 0x981f(%rip), %rax      # 0x12e90
movl (%rax), %ecx
leaq 0x5f20(%rip), %rsi      # 0xf59a
leaq 0xbdff(%rip), %r8       # 0x15480
xorl %eax, %eax
callq 0x4150
movq (%rbx), %rcx
leaq 0x5f30(%rip), %rdi      # 0xf5c2
movl $0xc, %esi
movl $0x1, %edx
callq 0x41c0
movl 0xd201(%rip), %edi      # 0x168a8
movq (%rbx), %rsi
callq 0x4aae
movq (%rbx), %rcx
leaq 0x5211(%rip), %rdi      # 0xe8ca
movl $0x2, %esi
movl $0x1, %edx
callq 0x41c0
movq (%rbx), %rsi
xorl %edi, %edi
callq 0x4cc3
movl $0x1, %edi
callq 0x41b0
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]gh_cpp/Src/gh_cpp3.c
// Function: emit
static void
emit(Tokvals n, int v)
{
	assert(n != CHAR);
	valstack[valptr].tok = n;
	valstack[valptr].val = v;
	if (++valptr >= MAXSTACK)
		syntax_error("formula too long");

	if (verbose>1) dump_stack("emit");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x2, %edi
je 0x9d4b
movslq 0xcb9b(%rip), %rax      # 0x168ac
leal 0x1(%rax), %ecx
leaq 0xcb95(%rip), %rdx      # 0x168b0
movl %edi, 0x4(%rdx,%rax,8)
movl %esi, (%rdx,%rax,8)
movl %ecx, 0xcb84(%rip)      # 0x168ac
cmpq $0xff, %rax
jge 0x9d6a
leaq 0xa179(%rip), %rax      # 0x13eb0
cmpl $0x2, (%rax)
jl 0x9d49
leaq 0x583d(%rip), %rdi      # 0xf580
popq %rbp
jmp 0x959b
popq %rbp
retq
leaq 0x57d8(%rip), %rdi      # 0xf52a
leaq 0x5782(%rip), %rsi      # 0xf4db
leaq 0x57f7(%rip), %rcx      # 0xf557
movl $0x46, %edx
callq 0x40e0
leaq 0x57fe(%rip), %rdi      # 0xf56f
callq 0x964d
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]gh_cpp/Src/gh_cpp3.c
// Function: do_bool
static int
do_bool(int op)
{	int v, w;

	sh_err++;
	w = interpret();
	sh_err--;
	v = interpret();

	if ((op == LAND && v == 0)
	||  (op == LOR  && v != 0))
		strcpy(err_s, "");
	else if (sh_err == 0
	     &&  strlen(err_s) > 0)
		fatal_error(err_s);

	return (op == LOR) ? (v || w) : (v && w);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %r14d
incl 0xd327(%rip)            # 0x170b0
callq 0x96dc
movl %eax, %ebx
decl 0xd31a(%rip)            # 0x170b0
callq 0x96dc
movl %eax, %r15d
movl %r14d, %eax
xorl $0x1b, %eax
orl %r15d, %eax
je 0x9dbd
cmpl $0x1a, %r14d
sete %al
testl %r15d, %r15d
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x9ded
movb $0x0, 0xc6dc(%rip)      # 0x164a0
cmpl $0x1a, %r14d
jne 0x9dd2
orl %ebx, %r15d
setne %al
jmp 0x9ddf
testl %ebx, %ebx
setne %cl
testl %r15d, %r15d
setne %al
andb %cl, %al
movzbl %al, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x0, 0xd2bc(%rip)      # 0x170b0
jne 0x9dc4
cmpb $0x0, 0xc6a3(%rip)      # 0x164a0
je 0x9dc4
leaq 0xc69a(%rip), %rdi      # 0x164a0
callq 0x4a2c
jmp 0x9dc4
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]gh_cpp/Src/gh_cpp3.c
// Function: do_shift
static int
do_shift(int op)
{	int v, w;

	sh_err++;
	w = interpret();
	v = interpret();
	sh_err--;

	if (w <= 0)
		strcpy(err_s, "shift by non-positive number");
	else if (w >= sizeof(long)*8)
		strcpy(err_s, "shift in preprocessor directive causes integer overflow");

	if (sh_err == 0
	&&  strlen(err_s) > 0)
	{	fprintf(stderr, "%s,%d: warning, %s\n",
			filename, lineno, err_s);
	}

	return (op == LS) ? (v << w) : (v >> w);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
incl 0xd291(%rip)            # 0x170b0
callq 0x96dc
movl %eax, %r15d
callq 0x96dc
movl %eax, %r14d
movl 0xd27b(%rip), %eax      # 0x170b0
decl %eax
movl %eax, 0xd273(%rip)      # 0x170b0
testl %r15d, %r15d
jle 0x9e85
cmpl $0x3f, %r15d
jbe 0x9ea5
movups 0x5833(%rip), %xmm0     # 0xf682
movaps %xmm0, 0xc66a(%rip)     # 0x164c0
movups 0x5815(%rip), %xmm0     # 0xf672
movaps %xmm0, 0xc64c(%rip)     # 0x164b0
movups 0x57f7(%rip), %xmm0     # 0xf662
movaps %xmm0, 0xc62e(%rip)     # 0x164a0
movabsq $0x776f6c66726576, %rcx # imm = 0x776F6C66726576
movq %rcx, 0xc64d(%rip)      # 0x164d0
jmp 0x9ea1
movups 0x57c6(%rip), %xmm0     # 0xf652
movups %xmm0, 0xc61a(%rip)     # 0x164ad
movups 0x57ab(%rip), %xmm0     # 0xf645
movaps %xmm0, 0xc5ff(%rip)     # 0x164a0
xorl %ecx, %ecx
jmp 0x9eaf
cmpb $0x0, 0xc5f4(%rip)      # 0x164a0
sete %cl
testl %eax, %eax
jne 0x9eb7
testb %cl, %cl
je 0x9ed7
movl %r14d, %eax
movl %r15d, %ecx
shll %cl, %eax
sarl %cl, %r14d
cmpl $0x1c, %ebx
cmovel %eax, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x47c0
jmp 0x9eb7
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]gh_cpp/Src/gh_cpp3.c
// Function: do_colon
static void
do_colon(void)
{	int v, w, x;
	char err_t[1024];
	char err_f[1024];
	char err_o[1024];

	strcpy(err_o, err_s);

	sh_err++;
	v = interpret();	/* the else value */
	strcpy(err_f, err_s);	/* remember any error conditions */

	assert(valstack[--valptr].tok == QUEST);

	w = interpret();	/* the then value */
	strcpy(err_t, err_s);	/* remember any error conditions */
	sh_err--;

	x = interpret();	/* the condition */

	if (x)
	{	if (strlen(err_t) > 0)
		{	if (sh_err == 0)
				fatal_error(err_t);
			else
				strcpy(err_o, err_t);
		}
	} else
	{	if (strlen(err_f) > 0)
		{	if (sh_err == 0)
				fatal_error(err_f);
			else
				strcpy(err_o, err_f);
	}	}

	strcpy(err_s, err_o);
	emit(VAL, x?w:v);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xc00, %rsp            # imm = 0xC00
leaq 0xc5ad(%rip), %rbx      # 0x164a0
leaq -0x410(%rbp), %rdi
movq %rbx, %rsi
callq 0x4070
incl 0xd1a8(%rip)            # 0x170b0
callq 0x96dc
movl %eax, %r14d
leaq -0x810(%rbp), %rdi
movq %rbx, %rsi
callq 0x4070
movslq 0xc986(%rip), %rax      # 0x168ac
leaq -0x1(%rax), %rcx
movl %ecx, 0xc97c(%rip)      # 0x168ac
leaq 0xc979(%rip), %rcx      # 0x168b0
cmpl $0x1e, -0x4(%rcx,%rax,8)
jne 0xa001
callq 0x96dc
movl %eax, %ebx
leaq 0xc550(%rip), %rsi      # 0x164a0
leaq -0xc10(%rbp), %rdi
callq 0x4070
decl 0xd14e(%rip)            # 0x170b0
callq 0x96dc
testl %eax, %eax
je 0x9f92
cmpb $0x0, -0xc10(%rbp)
je 0x9fd6
cmpl $0x0, 0xd135(%rip)      # 0x170b0
je 0x9fb9
leaq -0x410(%rbp), %rdi
leaq -0xc10(%rbp), %rsi
callq 0x4070
jmp 0x9fd6
cmpb $0x0, -0x810(%rbp)
je 0x9fd3
cmpl $0x0, 0xd10e(%rip)      # 0x170b0
je 0x9fc7
leaq -0x410(%rbp), %rdi
leaq -0x810(%rbp), %rsi
callq 0x4070
jmp 0x9fd3
leaq -0xc10(%rbp), %rdi
callq 0x4a2c
jmp 0x9fd6
leaq -0x810(%rbp), %rdi
callq 0x4a2c
movl %r14d, %ebx
leaq 0xc4c3(%rip), %rdi      # 0x164a0
leaq -0x410(%rbp), %rsi
callq 0x4070
movl $0x4, %edi
movl %ebx, %esi
callq 0x9d01
addq $0xc00, %rsp            # imm = 0xC00
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x56a6(%rip), %rdi      # 0xf6ae
leaq 0x54cc(%rip), %rsi      # 0xf4db
leaq 0x56b8(%rip), %rcx      # 0xf6ce
movl $0x161, %edx            # imm = 0x161
callq 0x40e0
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]gh_cpp/Src/gh_cpp4.c
// Function: show_expl
void
show_expl(FILE *fd, TS *start)
{	char tmp[1024];
	TS *n;
	int pos = 0;

	markings = (POS *) 0;

	for (n = start; n; n = n->nxt)
	{	pos += n->space;

		switch (n->tok) {
		case NAME:
			pos = mark_macro(n, pos, strlen(n->name));
			break;
		case VAL:
			sprintf(tmp, "%d", n->val);
			pos = mark_macro(n, pos, strlen(tmp));
			break;
		case ECHAR:
			pos = mark_macro(n, pos, 1);
			/* fall thru */
		case CHAR:
			sprintf(tmp, "%c", n->val);
			pos = mark_macro(n, pos, strlen(tmp));
			break;
		case TPASTE:
			pos = mark_macro(n, pos, 2);
			break;
		default:
			fprintf(stderr, "saw: ");
			tokname(n, stderr);
			fprintf(stderr, "\n");
			fatal_error("unknown token");
	}	}

	show_mark(fd, markings);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movq %rsi, %r14
movq $0x0, 0xd076(%rip) # 0x170b8
xorl %esi, %esi
testq %r14, %r14
je 0xa109
movq %rdi, -0x30(%rbp)
leaq 0x568c(%rip), %rbx      # 0xf6e4
leaq -0x430(%rbp), %r15
leaq 0x4842(%rip), %r12      # 0xe8a8
xorl %r13d, %r13d
addl 0x10(%r14), %r13d
movl (%r14), %eax
leal -0x1(%rax), %ecx
cmpl $0x3, %ecx
ja 0xa087
movslq (%rbx,%rcx,4), %rax
addq %rbx, %rax
jmpq *%rax
movq 0x8(%r14), %rdi
jmp 0xa0d3
movq %r14, %rdi
cmpl $0x20, %eax
jne 0xa0f7
movl %r13d, %esi
movl $0x2, %edx
jmp 0xa0e0
movq %r14, %rdi
movl %r13d, %esi
movl $0x1, %edx
callq 0xa11f
movl %eax, %r13d
movb 0x4(%r14), %al
movb %al, -0x430(%rbp)
movb $0x0, -0x42f(%rbp)
jmp 0xa0d0
movl 0x4(%r14), %edx
movq %r15, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x41a0
movq %r15, %rdi
callq 0x40a0
movq %r14, %rdi
movl %r13d, %esi
movl %eax, %edx
callq 0xa11f
movl %eax, %r13d
movq 0x28(%r14), %r14
testq %r14, %r14
jne 0xa069
jmp 0xa0fe
callq 0x47f7
jmp 0xa0e8
movq 0xcfb3(%rip), %rsi      # 0x170b8
movq -0x30(%rbp), %rdi
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa207
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]gh_cpp/Src/gh_cpp4.c
// Function: mark_macro
static int
mark_macro(TS *s, int from, int len)
{	ML *m;

	for (m = s->ml; m; m = m->nxt)
		add_mark(from - s->space, len + s->space, m->m);

	return from+len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movq 0x18(%rdi), %r12
testq %r12, %r12
je 0xa1f4
movq %rdi, %r9
movq 0xcf6f(%rip), %rcx      # 0x170b8
movl %esi, -0x2c(%rbp)
movq %rdi, -0x38(%rbp)
movl 0x10(%r9), %r13d
movl %esi, %r14d
subl %r13d, %r14d
addl %ebx, %r13d
movq (%r12), %r15
testq %rcx, %rcx
je 0xa184
movq %rcx, %rax
cmpq %r15, 0x8(%rax)
jne 0xa17b
movl 0x4(%rax), %edx
movl (%rax), %edi
addl %edx, %edi
cmpl %r14d, %edi
je 0xa1ec
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0xa169
movq 0xcf35(%rip), %rax      # 0x170c0
testq %rax, %rax
je 0xa1ab
movq 0x10(%rax), %rdx
movq %rdx, 0xcf25(%rip)      # 0x170c0
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
jmp 0xa1c3
movl $0x18, %edi
callq 0x4a8a
movq -0x38(%rbp), %r9
movl -0x2c(%rbp), %esi
movq 0xcef5(%rip), %rcx      # 0x170b8
movl %r14d, (%rax)
movl %r13d, 0x4(%rax)
movq %r15, 0x8(%rax)
movq %rcx, 0x10(%rax)
movq %rax, 0xcedf(%rip)      # 0x170b8
movq %rax, %rcx
movq 0x8(%r12), %r12
testq %r12, %r12
jne 0xa150
jmp 0xa1f4
addl %r13d, %edx
movl %edx, 0x4(%rax)
jmp 0xa1dc
addl %esi, %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]gh_cpp/Src/gh_cpp4.c
// Function: show_mark
static void
show_mark(FILE *fd, POS *p)
{	int i;

	if (!p) return;
	show_mark(fd, p->nxt);
	p->nxt = free_mark;
	free_mark = p;

	if (verbose) fprintf(fd, "      ");

	for (i = 0; i < p->from; i++)
		fprintf(fd, " ");
	for (i = 0; i < p->len; i++)
		fprintf(fd, "-");

	if (p->m)
		fprintf(fd, " [%s,%d: %s]",
			p->m->fnm, p->m->ln, p->m->nm);
	else
		fprintf(fd, " [undefined]");

	fprintf(fd, "\n");
}

// Assembly:
testq %rsi, %rsi
je 0xa2c4
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rsi
callq 0xa207
movq 0xce90(%rip), %rax      # 0x170c0
movq %rax, 0x10(%r14)
movq %r14, 0xce85(%rip)      # 0x170c0
leaq 0x9c6e(%rip), %rax      # 0x13eb0
cmpl $0x0, (%rax)
je 0xa260
leaq 0x54c2(%rip), %rdi      # 0xf710
movl $0x6, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x41c0
cmpl $0x0, (%r14)
jle 0xa27e
xorl %r15d, %r15d
movl $0x20, %edi
movq %rbx, %rsi
callq 0x4110
incl %r15d
cmpl (%r14), %r15d
jl 0xa269
cmpl $0x0, 0x4(%r14)
jle 0xa29e
xorl %r15d, %r15d
movl $0x2d, %edi
movq %rbx, %rsi
callq 0x4110
incl %r15d
cmpl 0x4(%r14), %r15d
jl 0xa288
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xa2c5
movq 0x10(%rax), %rdx
movl 0x8(%rax), %ecx
movq (%rax), %r8
leaq 0x545f(%rip), %rsi      # 0xf717
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4150
jmp 0xa2de
retq
leaq 0x5458(%rip), %rdi      # 0xf724
movl $0xc, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x41c0
movl $0xa, %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4110
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/nimble-code[P]gh_cpp/Src/gh_cpp5.c
// Function: m_rule
void
m_rule(int R_major, int R_minor, char *tag)
{	Rule *r;
	Offd *o;

	if (misra_rules < 2 && stack_depth > 1) return;

	if (strcmp(filename, "<predef>") == 0) return;
	
	for (r = violations; r; r = r->nxt)
		if (r->R_major == R_major
		&&  r->R_minor == R_minor)
		{	for (o = r->lst; o; o = o->nxt)
				if (o->ln == lineno
				&&  strcmp(o->fnm, filename) == 0)
					return;
			break;
		}

	if (!r)
	{	r = (Rule *) emalloc(sizeof(Rule));
		r->R_major = R_major;
		r->R_minor = R_minor;
		r->tag = tag;
		r->nxt = violations;
		violations = r;
	}

	o = (Offd *) emalloc(sizeof(Offd));
	o->fnm = emalloc(strlen(filename)+1);
	strcpy(o->fnm, filename);
	o->ln = lineno;

	o->nxt = r->lst;
	r->lst = o;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movl %esi, %r12d
movl %edi, %r13d
leaq 0x8b7e(%rip), %rax      # 0x12e94
cmpl $0x1, (%rax)
jg 0xa32b
leaq 0xc16a(%rip), %rax      # 0x1648c
cmpl $0x1, (%rax)
jg 0xa3e3
leaq 0x7dde(%rip), %rax      # 0x12110
movq (%rax), %r14
leaq 0xee0(%rip), %rsi       # 0xb21c
movq %r14, %rdi
callq 0x4140
testl %eax, %eax
je 0xa3e3
movq 0xcd75(%rip), %rbx      # 0x170c8
testq %rbx, %rbx
je 0xa36e
cmpl %r13d, 0x8(%rbx)
jne 0xa368
cmpl %r12d, 0xc(%rbx)
je 0xa3f2
movq 0x18(%rbx), %rbx
jmp 0xa353
movl $0x20, %edi
callq 0x4a8a
movq %rax, %rbx
movl %r13d, 0x8(%rax)
movl %r12d, 0xc(%rax)
movq %r15, (%rax)
movq 0xcd3b(%rip), %rax      # 0x170c8
movq %rax, 0x18(%rbx)
movq %rbx, 0xcd30(%rip)      # 0x170c8
movl $0x18, %edi
callq 0x4a8a
movq %rax, %r14
leaq 0x7d64(%rip), %r15      # 0x12110
movq (%r15), %rdi
callq 0x40a0
leal 0x1(%rax), %edi
callq 0x4a8a
movq %rax, (%r14)
movq (%r15), %rsi
movq %rax, %rdi
callq 0x4070
leaq 0x8abf(%rip), %rax      # 0x12e90
movl (%rax), %eax
movl %eax, 0x8(%r14)
movq 0x10(%rbx), %rax
movq %rax, 0x10(%r14)
movq %r14, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%rbx), %r15
testq %r15, %r15
je 0xa398
leaq 0x8a8e(%rip), %rax      # 0x12e90
movl (%rax), %r12d
cmpl %r12d, 0x8(%r15)
jne 0xa41a
movq (%r15), %rdi
movq %r14, %rsi
callq 0x4140
testl %eax, %eax
je 0xa3e3
movq 0x10(%r15), %r15
testq %r15, %r15
jne 0xa405
jmp 0xa398
// File: /workspace/github_c_makefile_star2_O3/andyfighting[P]hiredis_timer_cmpt/test.c
// Function: connect
static redisContext *connect(struct config config) {
    redisContext *c = NULL;

    if (config.type == CONN_TCP) {
        c = redisConnect(config.tcp.host, config.tcp.port);
    } else if (config.type == CONN_UNIX) {
        c = redisConnectUnix(config.unix.path);
    } else if (config.type == CONN_FD) {
        /* Create a dummy connection just to get an fd to inherit */
        redisContext *dummy_ctx = redisConnectUnix(config.unix.path);
        if (dummy_ctx) {
            int fd = disconnect(dummy_ctx, 1);
            printf("Connecting to inherited fd %d\n", fd);
            c = redisConnectFd(fd);
        }
    } else {
        assert(NULL);
    }

    if (c == NULL) {
        printf("Connection error: can't allocate redis context\n");
        exit(1);
    } else if (c->err) {
        printf("Connection error: %s\n", c->errstr);
        redisFree(c);
        exit(1);
    }

    return select_database(c);
}

// Assembly:
pushq %rbx
leaq 0x10(%rsp), %rax
movl (%rax), %ecx
cmpl $0x2, %ecx
je 0x4ece
cmpl $0x1, %ecx
je 0x4ec3
testl %ecx, %ecx
jne 0x4fd9
movq 0x8(%rax), %rdi
movl 0x10(%rax), %esi
callq 0x5df3
jmp 0x4f06
movq 0x28(%rax), %rdi
callq 0x5f95
jmp 0x4f06
movq 0x28(%rax), %rdi
callq 0x5f95
testq %rax, %rax
je 0x4f69
movq %rax, %rdi
movl $0x1, %esi
callq 0x4ff8
movl %eax, %ebx
leaq 0x5de9(%rip), %rdi      # 0xacdf
movl %eax, %esi
xorl %eax, %eax
callq 0x2110
movl %ebx, %edi
callq 0x603f
movq %rax, %rbx
testq %rax, %rax
je 0x4f69
cmpl $0x0, (%rbx)
jne 0x4f77
leaq 0x5e1f(%rip), %rsi      # 0xad39
movq %rbx, %rdi
xorl %eax, %eax
callq 0x6628
testq %rax, %rax
je 0x4f9b
movq %rax, %rdi
callq 0x509c
leaq 0x5e46(%rip), %rsi      # 0xad7e
movq %rbx, %rdi
xorl %eax, %eax
callq 0x6628
testq %rax, %rax
je 0x4fba
cmpl $0x3, (%rax)
jne 0x4f60
cmpq $0x0, 0x8(%rax)
jne 0x4f60
movq %rax, %rdi
callq 0x509c
movq %rbx, %rax
popq %rbx
retq
leaq 0x63c0(%rip), %rdi      # 0xb327
jmp 0x4f70
leaq 0x6388(%rip), %rdi      # 0xb2f8
callq 0x2090
jmp 0x4f91
leaq 0x4(%rbx), %rsi
leaq 0x5da1(%rip), %rdi      # 0xad23
xorl %eax, %eax
callq 0x2110
movq %rbx, %rdi
callq 0x5c55
movl $0x1, %edi
callq 0x22b0
leaq 0x5da0(%rip), %rdi      # 0xad42
leaq 0x58d1(%rip), %rsi      # 0xa87a
leaq 0x5da0(%rip), %rcx      # 0xad50
movl $0x3b, %edx
callq 0x2150
leaq 0x5d81(%rip), %rdi      # 0xad42
leaq 0x58b2(%rip), %rsi      # 0xa87a
leaq 0x5d81(%rip), %rcx      # 0xad50
movl $0x40, %edx
callq 0x2150
leaq 0x686e(%rip), %rdi      # 0xb84e
leaq 0x5893(%rip), %rsi      # 0xa87a
leaq 0x5d10(%rip), %rcx      # 0xacfe
movl $0x6e, %edx
callq 0x2150
// File: /workspace/github_c_makefile_star2_O3/sbp[P]tweetnacl-tools/tweetnacl-keypair.c
// Function: main
int main(int argc, char *argv[]) {
    if (argc != 3) error(2, "Usage: tweetnacl-keypair key.pub key.sec");

    unsigned char public_key[crypto_box_PUBLICKEYBYTES];
    unsigned char secret_key[crypto_box_SECRETKEYBYTES];
    crypto_box_keypair(public_key, secret_key);

    if (file_exists(argv[1])) errorf(1, "File <%s> exists", argv[1]);
    if (file_exists(argv[2])) errorf(1, "File <%s> exists", argv[2]);

    output_key(argv[1], public_key, crypto_box_PUBLICKEYBYTES);
    output_key(argv[2], secret_key, crypto_box_SECRETKEYBYTES);

    return 0;
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
cmpl $0x3, %edi
je 0x3a0d
leaq 0xe9f(%rip), %rsi       # 0x48a2
movl $0x2, %edi
callq 0x1308
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x2624
movq 0x8(%rbx), %rdi
callq 0x145c
testl %eax, %eax
je 0x3a3c
movq 0x8(%rbx), %rdx
leaq 0xe99(%rip), %rsi       # 0x48cb
movl $0x1, %edi
callq 0x1350
movq 0x10(%rbx), %rdi
callq 0x145c
testl %eax, %eax
je 0x3a5e
movq 0x10(%rbx), %rdx
leaq 0xe77(%rip), %rsi       # 0x48cb
movl $0x1, %edi
callq 0x1350
movq 0x8(%rbx), %rdi
leaq 0x20(%rsp), %rsi
movl $0x20, %edx
callq 0x3978
movq 0x10(%rbx), %rdi
movq %rsp, %rsi
movl $0x20, %edx
callq 0x3978
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/stanfordnlp[P]GloVe/src/vocab_count.c
// Function: hashinsert
void hashinsert(HASHREC **ht, char *w) {
    HASHREC     *htmp, *hprv;
    unsigned int hval = HASHFN(w, TSIZE, SEED);
    
    for (hprv = NULL, htmp = ht[hval]; htmp != NULL && scmp(htmp->word, w) != 0; hprv = htmp, htmp = htmp->next);
    if (htmp == NULL) {
        htmp = (HASHREC *) malloc( sizeof(HASHREC) );
        htmp->word = (char *) malloc( strlen(w) + 1 );
        strcpy(htmp->word, w);
        htmp->num = 1;
        htmp->next = NULL;
        if ( hprv==NULL )
            ht[hval] = htmp;
        else
            hprv->next = htmp;
    }
    else {
        /* new records are not moved to front */
        htmp->num++;
        if (hprv != NULL) {
            /* move to front on access */
            hprv->next = htmp->next;
            htmp->next = ht[hval];
            ht[hval] = htmp;
        }
    }
    return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movl $0x100000, %esi         # imm = 0x100000
movl $0x11b049, %edx         # imm = 0x11B049
callq 0x18e8
movl %eax, %r12d
movq (%rbx,%r12,8), %r15
testq %r15, %r15
je 0x174f
movq (%r15), %rdi
movq %r14, %rsi
callq 0x18c0
testl %eax, %eax
je 0x1799
movq %r15, %r13
movq 0x10(%r15), %r15
testq %r15, %r15
je 0x1752
movq (%r15), %rdi
movq %r14, %rsi
callq 0x18c0
testl %eax, %eax
jne 0x1732
jmp 0x179c
xorl %r13d, %r13d
movl $0x18, %edi
callq 0x1110
movq %rax, %r15
movq %r14, %rdi
callq 0x10a0
leaq 0x1(%rax), %rdi
callq 0x1110
movq %rax, (%r15)
movq %rax, %rdi
movq %r14, %rsi
callq 0x1050
movq $0x1, 0x8(%r15)
movq $0x0, 0x10(%r15)
testq %r13, %r13
je 0x17b5
movq %r15, 0x10(%r13)
jmp 0x17b9
xorl %r13d, %r13d
incq 0x8(%r15)
testq %r13, %r13
je 0x17b9
movq 0x10(%r15), %rax
movq %rax, 0x10(%r13)
movq (%rbx,%r12,8), %rax
movq %rax, 0x10(%r15)
movq %r15, (%rbx,%r12,8)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stanfordnlp[P]GloVe/src/vocab_count.c
// Function: main
int main(int argc, char **argv) {
    if (argc == 2 &&
        (!scmp(argv[1], "-h") || !scmp(argv[1], "-help") || !scmp(argv[1], "--help"))) {
        printf("Simple tool to extract unigram counts\n");
        printf("Author: Jeffrey Pennington (jpennin@stanford.edu)\n\n");
        printf("Usage options:\n");
        printf("\t-verbose <int>\n");
        printf("\t\tSet verbosity: 0, 1, or 2 (default)\n");
        printf("\t-max-vocab <int>\n");
        printf("\t\tUpper bound on vocabulary size, i.e. keep the <int> most frequent words. The minimum frequency words are randomly sampled so as to obtain an even distribution over the alphabet.\n");
        printf("\t-min-count <int>\n");
        printf("\t\tLower limit such that words which occur fewer than <int> times are discarded.\n");
        printf("\nExample usage:\n");
        printf("./vocab_count -verbose 2 -max-vocab 100000 -min-count 10 < corpus.txt > vocab.txt\n");
        return 0;
    }

    int i;
    if ((i = find_arg((char *)"-verbose", argc, argv)) > 0) verbose = atoi(argv[i + 1]);
    if ((i = find_arg((char *)"-max-vocab", argc, argv)) > 0) max_vocab = atoll(argv[i + 1]);
    if ((i = find_arg((char *)"-min-count", argc, argv)) > 0) min_count = atoll(argv[i + 1]);
    return get_counts();
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movl %edi, %ebp
cmpl $0x2, %edi
jne 0x18a8
movq 0x8(%rbx), %rdi
leaq 0x99d(%rip), %rsi       # 0x2181
callq 0x18c0
testl %eax, %eax
je 0x1819
movq 0x8(%rbx), %rdi
leaq 0x98d(%rip), %rsi       # 0x2185
callq 0x18c0
testl %eax, %eax
je 0x1819
movq 0x8(%rbx), %rdi
leaq 0x978(%rip), %rsi       # 0x2184
callq 0x18c0
testl %eax, %eax
jne 0x18a8
leaq 0x98a(%rip), %rdi       # 0x21aa
callq 0x1060
leaq 0x9a4(%rip), %rdi       # 0x21d0
callq 0x1060
leaq 0x9cb(%rip), %rdi       # 0x2203
callq 0x1060
leaq 0x9ce(%rip), %rdi       # 0x2212
callq 0x1060
leaq 0x9d2(%rip), %rdi       # 0x2222
callq 0x1060
leaq 0x9ec(%rip), %rdi       # 0x2248
callq 0x1060
leaq 0x9f2(%rip), %rdi       # 0x225a
callq 0x1060
leaq 0xa9a(%rip), %rdi       # 0x230e
callq 0x1060
leaq 0xaa0(%rip), %rdi       # 0x2320
callq 0x1060
leaq 0xae4(%rip), %rdi       # 0x2370
callq 0x1060
leaq 0xae8(%rip), %rdi       # 0x2380
callq 0x1060
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xc(%rsp), %r14
movl %ebp, %edi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x14b9
movl (%r14), %eax
jmp 0x189f
nop
// File: /workspace/github_c_makefile_star2_O3/Leeheng86[P]word2vec/word2phrase.c
// Function: SortVocab()
void SortVocab() {
  int a;
  unsigned int hash;
  // Sort the vocabulary and keep 
 at the first position
  qsort(&vocab[1], vocab_size - 1, sizeof(struct vocab_word), VocabCompare);
  for (a = 0; a < vocab_hash_size; a++) vocab_hash[a] = -1;
  for (a = 0; a < vocab_size; a++) {
    // Words occuring less than min_count times will be discarded from the vocab
    if (vocab[a].cn < min_count) {
      vocab_size--;
      free(vocab[vocab_size].word);
    } else {
      // Hash will be re-computed, as after the sorting it is not actual
      hash = GetWordHash(vocab[a].word);
      while (vocab_hash[hash] != -1) hash = (hash + 1) % vocab_hash_size;
      vocab_hash[hash] = a;
    }
  }
  vocab = (struct vocab_word *)realloc(vocab, vocab_size * sizeof(struct vocab_word));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x3bd8(%rip), %rdi      # 0x5190
addq $0x10, %rdi
movq 0x3bdd(%rip), %rsi      # 0x51a0
decq %rsi
leaq -0x2c(%rip), %rcx       # 0x15a1
movl $0x10, %edx
callq 0x1180
movq 0x3bba(%rip), %rdi      # 0x5198
movl $0x77359400, %edx       # imm = 0x77359400
movl $0xff, %esi
callq 0x1070
movq 0x3bac(%rip), %rbx      # 0x51a0
movq 0x3b95(%rip), %r14      # 0x5190
testq %rbx, %rbx
jle 0x16d3
xorl %r12d, %r12d
movabsq $0x44b82fa09b5a53, %r13 # imm = 0x44B82FA09B5A53
xorl %ebp, %ebp
movq %rbp, %rax
shlq $0x4, %rax
movslq 0x3abb(%rip), %rcx      # 0x50dc
cmpq %rcx, (%r14,%rax)
jge 0x164f
decq %rbx
movq %rbx, 0x3b6f(%rip)      # 0x51a0
shlq $0x4, %rbx
movq 0x8(%r14,%rbx), %rdi
callq 0x10d0
movq 0x3b4a(%rip), %r14      # 0x5190
movq 0x3b53(%rip), %rbx      # 0x51a0
jmp 0x16c7
addq %r14, %rax
movq 0x8(%rax), %r15
movq %r15, %rdi
callq 0x1060
testq %rax, %rax
je 0x169c
movl $0x1, %ecx
xorl %edx, %edx
movq %rcx, %rsi
shlq $0x8, %rsi
addq %rcx, %rsi
movsbq (%r15,%rdx), %rcx
addq %rsi, %rcx
incq %rdx
cmpq %rdx, %rax
jne 0x166a
movq %rcx, %rax
shrq $0x8, %rax
mulq %r13
shrq $0xb, %rdx
imull $0x1dcd6500, %edx, %eax # imm = 0x1DCD6500
subl %eax, %ecx
jmp 0x16a1
movl $0x1, %ecx
movq 0x3af0(%rip), %rax      # 0x5198
movl %ecx, %edx
cmpl $-0x1, (%rax,%rdx,4)
je 0x16c4
movl %ecx, %edx
incl %edx
cmpl $0x1dcd6500, %edx       # imm = 0x1DCD6500
cmovel %r12d, %edx
cmpl $-0x1, (%rax,%rdx,4)
jne 0x16b2
movl %ebp, (%rax,%rdx,4)
incq %rbp
cmpq %rbp, %rbx
jg 0x1613
shlq $0x4, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1170
movq %rax, 0x3aa7(%rip)      # 0x5190
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Leeheng86[P]word2vec/word2phrase.c
// Function: ReduceVocab()
void ReduceVocab() {
  int a, b = 0;
  unsigned int hash;
  for (a = 0; a < vocab_size; a++) if (vocab[a].cn > min_reduce) {
    vocab[b].cn = vocab[a].cn;
    vocab[b].word = vocab[a].word;
    b++;
  } else free(vocab[a].word);
  vocab_size = b;
  for (a = 0; a < vocab_hash_size; a++) vocab_hash[a] = -1;
  for (a = 0; a < vocab_size; a++) {
    // Hash will be re-computed, as it is not actual
    hash = GetWordHash(vocab[a].word);
    while (vocab_hash[hash] != -1) hash = (hash + 1) % vocab_hash_size;
    vocab_hash[hash] = a;
  }
  fflush(stdout);
  min_reduce++;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq $0x0, 0x3a95(%rip)      # 0x51a0
jle 0x1839
xorl %ebx, %ebx
movl $0x8, %r15d
movl 0x39c1(%rip), %eax      # 0x50e0
xorl %r14d, %r14d
movq 0x3a67(%rip), %rcx      # 0x5190
movq -0x8(%rcx,%r15), %rdx
movslq %eax, %rsi
cmpq %rsi, %rdx
jle 0x1752
movslq %r14d, %r14
movq %r14, %rsi
shlq $0x4, %rsi
movq %rdx, (%rcx,%rsi)
movq (%rcx,%r15), %rdx
movq %rdx, 0x8(%rcx,%rsi)
incl %r14d
jmp 0x1761
movq (%rcx,%r15), %rdi
callq 0x10d0
movl 0x397f(%rip), %eax      # 0x50e0
incq %rbx
addq $0x10, %r15
cmpq %rbx, 0x3a31(%rip)      # 0x51a0
jg 0x1722
movslq %r14d, %r15
movq %r15, 0x3a25(%rip)      # 0x51a0
movq 0x3a16(%rip), %rbx      # 0x5198
movl $0x77359400, %edx       # imm = 0x77359400
movq %rbx, %rdi
movl $0xff, %esi
callq 0x1070
testl %r15d, %r15d
jle 0x185a
movq 0x39ec(%rip), %r15      # 0x5190
movl %r14d, %r12d
xorl %r13d, %r13d
xorl %ebp, %ebp
movq %rbp, %rax
shlq $0x4, %rax
movq 0x8(%r15,%rax), %r14
movq %r14, %rdi
callq 0x1060
testq %rax, %rax
je 0x1808
movl $0x1, %ecx
xorl %edx, %edx
movq %rcx, %rsi
shlq $0x8, %rsi
addq %rcx, %rsi
movsbq (%r14,%rdx), %rcx
addq %rsi, %rcx
incq %rdx
cmpq %rdx, %rax
jne 0x17cc
movq %rcx, %rax
shrq $0x8, %rax
movabsq $0x44b82fa09b5a53, %rdx # imm = 0x44B82FA09B5A53
mulq %rdx
shrq $0xb, %rdx
imull $0x1dcd6500, %edx, %eax # imm = 0x1DCD6500
subl %eax, %ecx
jmp 0x180d
movl $0x1, %ecx
movl %ecx, %eax
cmpl $-0x1, (%rbx,%rax,4)
je 0x1828
movl %ecx, %eax
incl %eax
cmpl $0x1dcd6500, %eax       # imm = 0x1DCD6500
cmovel %r13d, %eax
cmpl $-0x1, (%rbx,%rax,4)
jne 0x1817
movl %ebp, (%rbx,%rax,4)
incq %rbp
cmpq %r12, %rbp
jne 0x17ac
jmp 0x185a
movq $0x0, 0x395c(%rip) # 0x51a0
movq 0x394d(%rip), %rdi      # 0x5198
movl $0x77359400, %edx       # imm = 0x77359400
movl $0xff, %esi
callq 0x1070
movq 0x376f(%rip), %rax      # 0x4fd0
movq (%rax), %rdi
callq 0x10b0
incl 0x3871(%rip)            # 0x50e0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Leeheng86[P]word2vec/word2phrase.c
// Function: ArgPos(char*, int, char**)
int ArgPos(char *str, int argc, char **argv) {
  int a;
  for (a = 1; a < argc; a++) if (!strcmp(str, argv[a])) {
    if (a == argc - 1) {
      printf("Argument missing for %s\n", str);
      exit(1);
    }
    return a;
  }
  return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
cmpl $0x2, %esi
jl 0x1e20
movq %rdx, %r14
movq %rdi, %rbx
movl %esi, %r12d
movl $0x1, %r15d
movq (%r14,%r15,8), %rsi
movq %rbx, %rdi
callq 0x1110
testl %eax, %eax
je 0x1e17
incq %r15
decq %r12
cmpq $0x1, %r12
jne 0x1df9
jmp 0x1e20
cmpl $0x2, %r12d
je 0x1e2b
movl %r15d, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1293(%rip), %rdi      # 0x30c5
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1030
movl $0x1, %edi
callq 0x10e0
// File: /workspace/github_c_makefile_star2_O3/mvermeulen[P]wspy/cpu_info.c
// Function: main
int main(void){
  int i;
  inventory_cpu();

  printf("CPU information:\n");
  switch(cpu_info->vendor){
  case VENDOR_AMD:
    printf("\tAMD family %x model %x\n",cpu_info->family,cpu_info->model);
    break;
  case VENDOR_INTEL:
    printf("\tIntel family %x model %x\n",cpu_info->family,cpu_info->model);
    break;
  default:
    printf("Unknown CPU\n");
    return 0;
  }

  for (i=0;i<cpu_info->num_cores;i++){
    printf("\t   ");
    printf("%c %d ",(cpu_info->coreinfo[i].is_available)?'*':' ',i);
    switch(cpu_info->coreinfo[i].vendor){
    case CORE_AMD_ZEN:
      printf("Zen");
      break;
    case CORE_AMD_ZEN5:
      printf("Zen5");
      break;
    case CORE_INTEL_ATOM:
      printf("Atom");
      break;
    case CORE_INTEL_CORE:
      printf("Core");
      break;
    case CORE_AMD_UNKNOWN:
      printf("AMD?");
      break;
    case CORE_INTEL_UNKNOWN:
      printf("Intel?");
      break;
    default:
      printf("??");
      break;
    }
    printf("\n");
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x121c
leaq 0xacc(%rip), %rdi       # 0x2146
callq 0x1050
movq 0x2a2a(%rip), %rax      # 0x40b0
movl (%rax), %ecx
cmpl $0x1, %ecx
je 0x169f
cmpl $0x2, %ecx
jne 0x1761
leaq 0xa60(%rip), %rdi       # 0x20fd
jmp 0x16a6
leaq 0xa3e(%rip), %rdi       # 0x20e4
movl 0x4(%rax), %esi
movl 0x8(%rax), %edx
xorl %eax, %eax
callq 0x1080
movq 0x29f6(%rip), %rax      # 0x40b0
cmpl $0x0, 0xc(%rax)
je 0x176d
movl $0x20, %ebp
leaq 0xa4d(%rip), %r14       # 0x211d
leaq 0xa6c(%rip), %r12       # 0x2143
leaq 0xa86(%rip), %r13       # 0x2164
xorl %ebx, %ebx
xorl %r15d, %r15d
leaq 0xa2e(%rip), %rdi       # 0x2118
xorl %eax, %eax
callq 0x1080
movq 0x29b8(%rip), %rax      # 0x40b0
movq 0x18(%rax), %rax
testb $0x1, 0x4(%rax,%rbx)
movl $0x2a, %esi
cmovel %ebp, %esi
movq %r14, %rdi
movl %r15d, %edx
xorl %eax, %eax
callq 0x1080
movq 0x2993(%rip), %rax      # 0x40b0
movq 0x18(%rax), %rax
movl (%rax,%rbx), %eax
decl %eax
movq %r12, %rdi
cmpl $0x5, %eax
ja 0x1738
movl %eax, %eax
movslq (%r13,%rax,4), %rdi
addq %r13, %rdi
xorl %eax, %eax
callq 0x1080
movl $0xa, %edi
callq 0x1030
incq %r15
movq 0x295d(%rip), %rax      # 0x40b0
movl 0xc(%rax), %eax
addq $0x60, %rbx
cmpq %rax, %r15
jb 0x16e3
jmp 0x176d
leaq 0x9ef(%rip), %rdi       # 0x2157
callq 0x1050
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jfaudiolib/src/test.c
// Function: listdevs
void listdevs(void)
{
    int dev;
    #define YESNO(x) ((x) ? "Yes" : "No ")

    for (dev = 0; dev < ASS_NumSoundCards; dev++) {
        printf("%d) %-15s PCM %s  CD %s  MIDI %s \n",
            dev, SoundDriver_GetName(dev),
            YESNO(SoundDriver_IsPCMSupported(dev)),
            YESNO(SoundDriver_IsCDSupported(dev)),
            YESNO(SoundDriver_IsMIDISupported(dev))
        );
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x79fa(%rip), %r13      # 0xa2f4
leaq 0x79ef(%rip), %rbx      # 0xa2f0
xorl %ebp, %ebp
movl %ebp, %edi
callq 0x2b7f
movq %rax, %r14
movl %ebp, %edi
callq 0x2b4c
testl %eax, %eax
movq %rbx, %r15
cmoveq %r13, %r15
movl %ebp, %edi
callq 0x2b5d
testl %eax, %eax
movq %rbx, %r12
cmoveq %r13, %r12
movl %ebp, %edi
callq 0x2b6e
testl %eax, %eax
movq %rbx, %r9
cmoveq %r13, %r9
leaq 0x7989(%rip), %rdi      # 0xa2cd
movl %ebp, %esi
movq %r14, %rdx
movq %r15, %rcx
movq %r12, %r8
xorl %eax, %eax
callq 0x2050
incl %ebp
cmpl $0x7, %ebp
jne 0x2903
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jfaudiolib/src/fx_man.c
// Function: FX_Init
int FX_Init
   (
   int SoundCard,
   int numvoices,
   int * numchannels,
   int * samplebits,
   int * mixrate,
   void * initdata
   )

   {
   int devicestatus;
   int mincard, maxcard, card;

   if ( FX_Installed )
      {
      FX_Shutdown();
      }

   if (SoundCard == ASS_AutoDetect)
      {
      mincard = ASS_NoSound + 1;
      maxcard = ASS_NumSoundCards - 1;
      }
   else if (SoundCard < 0 || SoundCard >= ASS_NumSoundCards)
      {
      FX_SetErrorCode( FX_InvalidCard );
      return FX_Error;
      }
   else
      {
      mincard = SoundCard;
      maxcard = SoundCard;
      }

   for (card = mincard; card <= maxcard; card++)
      {
      if (!SoundDriver_IsPCMSupported(card))
         {
         continue;
         }
      else if (SoundCard == ASS_AutoDetect)
         {
         ASS_Message("FX_Init: trying %s\n", SoundDriver_GetName(card));
         }

      devicestatus = MV_Init( card, mixrate, numvoices, numchannels, samplebits, initdata );
      if (devicestatus == MV_Ok)
         {
         FX_Installed = TRUE;
         return FX_Ok;
         }
      }

   if (SoundCard == ASS_AutoDetect)
      {
      // A failure to autodetect falls back to no sound.
      card = ASS_NoSound;

      devicestatus = MV_Init( card, mixrate, numvoices, numchannels, samplebits, initdata );
      if ( devicestatus == MV_Ok )
         {
         FX_Installed = TRUE;
         return FX_Ok;
         }
      }

   FX_SetErrorCode( FX_MultiVocError );
   return FX_Error;
   }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x10(%rsp)
movq %r8, %r12
movq %rcx, 0x8(%rsp)
movq %rdx, %r15
movl %esi, %ebp
movl %edi, %r14d
cmpl $0x0, 0xd385(%rip)      # 0x102c8
je 0x2f62
callq 0x5681
testl %eax, %eax
je 0x2f58
movl $0x4, 0xd36c(%rip)      # 0x102c4
movl $0x0, 0xd366(%rip)      # 0x102c8
cmpl $-0x2, %r14d
jne 0x2f75
movl $0x6, %ebx
movl $0x1, %r13d
jmp 0x2f90
movl %r14d, %r13d
movl %r14d, %ebx
cmpl $0x7, %r14d
jb 0x2f90
movl $0x3, 0xd339(%rip)      # 0x102c4
jmp 0x3012
incl %ebx
movl %r13d, %edi
callq 0x2b4c
testl %eax, %eax
je 0x2fdb
cmpl $-0x2, %r14d
jne 0x2fbd
movl %r13d, %edi
callq 0x2b7f
leaq 0x74b0(%rip), %rdi      # 0xa463
movq %rax, %rsi
xorl %eax, %eax
callq 0x8b10
movl %r13d, %edi
movq %r12, %rsi
movl %ebp, %edx
movq %r15, %rcx
movq 0x8(%rsp), %r8
movq 0x10(%rsp), %r9
callq 0x53c7
testl %eax, %eax
je 0x3019
incl %r13d
cmpl %r13d, %ebx
jne 0x2f92
cmpl $-0x2, %r14d
jne 0x3008
xorl %ebx, %ebx
xorl %edi, %edi
movq %r12, %rsi
movl %ebp, %edx
movq %r15, %rcx
movq 0x8(%rsp), %r8
movq 0x10(%rsp), %r9
callq 0x53c7
testl %eax, %eax
je 0x3027
movl $0x4, 0xd2b2(%rip)      # 0x102c4
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x3031
movl $0x1, 0xd2a5(%rip)      # 0x102c8
xorl %ebx, %ebx
jmp 0x3031
movl $0x1, 0xd297(%rip)      # 0x102c8
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jfaudiolib/src/fx_man.c
// Function: FX_PlayAuto
int FX_PlayAuto( char *ptr, unsigned int length, int pitchoffset, int vol,
                 int left, int right, int priority, unsigned int callbackval )
{
   int handle = -1;
   
   if (!memcmp("Creative Voice File\x1a", ptr, 20)) {
      handle = MV_PlayVOC(ptr, length, pitchoffset, vol, left, right, priority, callbackval);
   } else if (!memcmp("RIFF", ptr, 4) && !memcmp("WAVE", ptr + 8, 4)) {
      handle = MV_PlayWAV(ptr, length, pitchoffset, vol, left, right, priority, callbackval);
   #ifdef HAVE_VORBIS
   } else if (!memcmp("OggS", ptr, 4)) {
      handle = MV_PlayVorbis(ptr, length, pitchoffset, vol, left, right, priority, callbackval);
   #endif
   }
   
   if ( handle < MV_Ok )
   {
      FX_SetErrorCode( FX_MultiVocError );
      handle = FX_Warning;
   }
   
   return handle;
}

// Assembly:
pushq %rax
movl 0x18(%rsp), %r10d
movdqu (%rdi), %xmm0
movd 0x10(%rdi), %xmm1
pcmpeqb 0x6f9d(%rip), %xmm1     # 0xa390
pcmpeqb 0x6fa5(%rip), %xmm0     # 0xa3a0
movl 0x10(%rsp), %eax
pand %xmm1, %xmm0
pmovmskb %xmm0, %r11d
cmpl $0xffff, %r11d          # imm = 0xFFFF
je 0x3434
cmpl $0x46464952, (%rdi)     # imm = 0x46464952
jne 0x3422
cmpl $0x45564157, 0x8(%rdi)  # imm = 0x45564157
je 0x3455
cmpl $0x5367674f, (%rdi)     # imm = 0x5367674F
jne 0x3444
pushq %r10
pushq %rax
callq 0x665a
jmp 0x343c
pushq %r10
pushq %rax
callq 0x4d7a
addq $0x10, %rsp
testl %eax, %eax
jns 0x3453
movl $0x4, 0xce76(%rip)      # 0x102c4
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
popq %rcx
retq
pushq %r10
pushq %rax
callq 0x485e
jmp 0x343c
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jfaudiolib/src/fx_man.c
// Function: FX_PlayLoopedAuto
int FX_PlayLoopedAuto( char *ptr, unsigned int length, int loopstart, int loopend,
                       int pitchoffset, int vol, int left, int right, int priority,
                       unsigned int callbackval )
{
   int handle = -1;
   
   if (!memcmp("Creative Voice File\x1a", ptr, 20)) {
      handle = MV_PlayLoopedVOC(ptr, length, loopstart, loopend, pitchoffset,
                              vol, left, right, priority, callbackval);
   } else if (!memcmp("RIFF", ptr, 4) && !memcmp("WAVE", ptr + 8, 4)) {
      handle = MV_PlayLoopedWAV(ptr, length, loopstart, loopend, pitchoffset,
                              vol, left, right, priority, callbackval);
   #ifdef HAVE_VORBIS
   } else if (!memcmp("OggS", ptr, 4)) {
      handle = MV_PlayLoopedVorbis(ptr, length, loopstart, loopend, pitchoffset,
                              vol, left, right, priority, callbackval);
   #endif
   }
   
   if ( handle < MV_Ok )
   {
      FX_SetErrorCode( FX_MultiVocError );
      handle = FX_Warning;
   }
   
   return handle;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl 0x38(%rsp), %ebx
movl 0x30(%rsp), %r11d
movl 0x28(%rsp), %r10d
movdqu (%rdi), %xmm0
movd 0x10(%rdi), %xmm1
pcmpeqb 0x6f0f(%rip), %xmm1     # 0xa390
pcmpeqb 0x6f17(%rip), %xmm0     # 0xa3a0
movl 0x20(%rsp), %eax
pand %xmm1, %xmm0
pmovmskb %xmm0, %ebp
cmpl $0xffff, %ebp           # imm = 0xFFFF
je 0x34c3
cmpl $0x46464952, (%rdi)     # imm = 0x46464952
jne 0x34ae
cmpl $0x45564157, 0x8(%rdi)  # imm = 0x45564157
je 0x34ec
cmpl $0x5367674f, (%rdi)     # imm = 0x5367674F
jne 0x34d6
pushq %rbx
pushq %r11
pushq %r10
pushq %rax
callq 0x6686
jmp 0x34ce
pushq %rbx
pushq %r11
pushq %r10
pushq %rax
callq 0x4dac
addq $0x20, %rsp
testl %eax, %eax
jns 0x34e5
movl $0x4, 0xcde4(%rip)      # 0x102c4
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
pushq %rbx
pushq %r11
pushq %r10
pushq %rax
callq 0x4890
jmp 0x34ce
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jfaudiolib/src/fx_man.c
// Function: FX_PlayAuto3D
int FX_PlayAuto3D( char *ptr, unsigned int length, int pitchoffset, int angle,
                   int distance, int priority, unsigned int callbackval )
{
   int handle = -1;
   
   if (!memcmp("Creative Voice File\x1a", ptr, 20)) {
      handle = MV_PlayVOC3D(ptr, length, pitchoffset, angle, distance, priority, callbackval);
   } else if (!memcmp("RIFF", ptr, 4) && !memcmp("WAVE", ptr + 8, 4)) {
      handle = MV_PlayWAV3D(ptr, length, pitchoffset, angle, distance, priority, callbackval);
   #ifdef HAVE_VORBIS
   } else if (!memcmp("OggS", ptr, 4)) {
      handle = MV_PlayVorbis3D(ptr, length, pitchoffset, angle, distance, priority, callbackval);
   #endif
   }
   
   if ( handle < MV_Ok )
   {
      FX_SetErrorCode( FX_MultiVocError );
      handle = FX_Warning;
   }
   
   return handle;
}

// Assembly:
pushq %rax
movdqu (%rdi), %xmm0
movd 0x10(%rdi), %xmm1
pcmpeqb 0x6e85(%rip), %xmm1     # 0xa390
pcmpeqb 0x6e8d(%rip), %xmm0     # 0xa3a0
movl 0x10(%rsp), %eax
pand %xmm1, %xmm0
pmovmskb %xmm0, %r10d
cmpl $0xffff, %r10d          # imm = 0xFFFF
je 0x354c
cmpl $0x46464952, (%rdi)     # imm = 0x46464952
jne 0x353a
cmpl $0x45564157, 0x8(%rdi)  # imm = 0x45564157
je 0x3569
cmpl $0x5367674f, (%rdi)     # imm = 0x5367674F
jne 0x3558
movl %eax, (%rsp)
callq 0x65b4
jmp 0x3554
movl %eax, (%rsp)
callq 0x4cd3
testl %eax, %eax
jns 0x3567
movl $0x4, 0xcd62(%rip)      # 0x102c4
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
popq %rcx
retq
movl %eax, (%rsp)
callq 0x4aff
jmp 0x3554
nop
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jfaudiolib/src/multivoc.c
// Function: MV_PlayVoice
void MV_PlayVoice
   (
   VoiceNode *voice
   )

   {
   int flags;

   flags = DisableInterrupts();
   LL_SortedInsertion( &VoiceList, voice, prev, next, VoiceNode, priority );

   RestoreInterrupts( flags );
   }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x15f0f(%rip), %eax     # 0x19524
leal 0x1(%rax), %ecx
movl %ecx, 0x15f06(%rip)     # 0x19524
testl %eax, %eax
jg 0x3627
callq 0x2d13
movq 0xccb2(%rip), %rcx      # 0x102e0
leaq 0xcca3(%rip), %rax      # 0x102d8
cmpq %rax, %rcx
je 0x3657
movl 0x7c(%rbx), %edx
leaq 0xcc94(%rip), %rax      # 0x102d8
cmpl 0x7c(%rcx), %edx
jle 0x3654
movq 0x8(%rcx), %rcx
cmpq %rax, %rcx
jne 0x3644
jmp 0x3657
movq %rcx, %rax
movq %rax, 0x8(%rbx)
movq (%rax), %rcx
movq %rcx, (%rbx)
movq %rbx, 0x8(%rcx)
movq %rbx, (%rax)
movl 0x15eb6(%rip), %eax     # 0x19524
leal -0x1(%rax), %ecx
movl %ecx, 0x15ead(%rip)     # 0x19524
cmpl $0x1, %eax
jle 0x367e
popq %rbx
retq
popq %rbx
jmp 0x2d2c
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jfaudiolib/src/multivoc.c
// Function: MV_GetVoice
static VoiceNode *MV_GetVoice
   (
   int handle
   )

   {
   VoiceNode *voice;
   int        flags;

   flags = DisableInterrupts();

   for( voice = VoiceList.next; voice != &VoiceList; voice = voice->next )
      {
      if ( handle == voice->handle )
         {
         break;
         }
      }

   RestoreInterrupts( flags );

   if ( voice == &VoiceList )
      {
      MV_SetErrorCode( MV_VoiceNotFound );
      voice = 0;
      }

   return( voice );
   }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edi, %ebp
movl 0x15e68(%rip), %eax     # 0x19524
leal 0x1(%rax), %ecx
movl %ecx, 0x15e5f(%rip)     # 0x19524
testl %eax, %eax
jg 0x36ce
callq 0x2d13
movq 0xcc03(%rip), %rax      # 0x102d8
leaq 0xcbfc(%rip), %rbx      # 0x102d8
cmpq %rbx, %rax
je 0x36fb
leaq 0xcbf0(%rip), %rbx      # 0x102d8
cmpl %ebp, 0x78(%rax)
setne %r14b
je 0x3700
movq (%rax), %rax
cmpq %rbx, %rax
jne 0x36e8
jmp 0x3703
movb $0x1, %r14b
jmp 0x3703
movq %rax, %rbx
movl 0x15e1b(%rip), %eax     # 0x19524
leal -0x1(%rax), %ecx
movl %ecx, 0x15e12(%rip)     # 0x19524
cmpl $0x1, %eax
jg 0x371c
callq 0x2d2c
testb %r14b, %r14b
je 0x372d
movl $0x6, 0xcba9(%rip)      # 0x102d4
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq