LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]gh_cpp/Src/gh_cpp2.c
// Function: need_more
void
need_more(void)
{
	if (fgets(ibuf, MAXIN, mfd) == NULL)
		fatal_error("gh_cpp: unexpected eof");
	delta++;
	trimline(ibuf);
	/* should check if the line ends in a \\ */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xd46c(%rip), %rdx      # 0x15480
leaq 0xc465(%rip), %rdi      # 0x14480
movl $0x1000, %esi           # imm = 0x1000
callq 0x4120
testq %rax, %rax
jne 0x8036
leaq 0x6106(%rip), %rdi      # 0xe137
callq 0x42ec
incl 0xd44c(%rip)            # 0x15488
popq %rbp
jmp 0x803f
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]gh_cpp/Src/gh_cpp2.c
// Function: trimline
static int
trimline(char *b)
{	int len;

	len = strlen(b);
	if (len >= MAXIN) fatal_error("input line too long");

	while (len > 1
	&& (b[len-2] == ' '
	||  b[len-2] == '\t'))
	{	b[len-2] = '\n';
		b[len-1] = '\0';
		len--;
	}

	return len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq 0xc433(%rip), %rbx      # 0x14480
movq %rbx, %rdi
callq 0x40a0
movq %rax, %r14
cmpl $0x1000, %r14d          # imm = 0x1000
jl 0x806d
leaq 0x61ef(%rip), %rdi      # 0xe257
callq 0x42ec
movl %r14d, %ecx
testl %r14d, %r14d
pushq $0x1
popq %rax
cmovlel %r14d, %eax
cmpl $0x2, %ecx
jl 0x809c
movzbl -0x2(%rcx,%rbx), %edx
cmpl $0x20, %edx
je 0x808e
cmpl $0x9, %edx
jne 0x809a
movw $0xa, -0x2(%rcx,%rbx)
decq %rcx
jmp 0x807a
movl %ecx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]gh_cpp/Src/gh_cpp2.c
// Function: search_sys
static int
search_sys(ARGS *n, char *f)
{	char *s;
	FILE *nfd;

	if (!n) return 0;

	if (search_sys(n->nxt, f))
		return 1;

	s = (char *) emalloc(strlen(f)+strlen(n->nm)+1+1);
	sprintf(s, "%s/%s", n->nm, f);

	if (misra_rules)
	{	if (strcmp(s, "malloc.h") == 0)
			m_rule(20, 4, "<malloc.h>");
		else if (strcmp(s, "signal.h") == 0)
			m_rule(20, 8, "<signal.h>");
		else if (strcmp(s, "stdio.h") == 0)
			m_rule(20, 9, "<stdio.h>");
		else if (strcmp(s, "time.h") == 0)
			m_rule(20, 12, "<time.h>");
	}

	if ((nfd = fopen(s, "r")) == NULL)
	{	free(s);
		return 0;
	}
	if (verbose>1) printf("/**** #include: %s ****/\n", s);

	fclose(nfd);
	do_file(filename, lineno, s);
	free(s);

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x8823
movq %rsi, %r15
movq %rdi, %r14
movq 0x8(%rdi), %rdi
callq 0x87f8
testl %eax, %eax
je 0x882b
pushq $0x1
popq %r14
jmp 0x8961
xorl %r14d, %r14d
jmp 0x8961
movq %r15, %rdi
callq 0x40a0
movq %rax, %rbx
movq (%r14), %rdi
callq 0x40a0
leal (%rax,%rbx), %edi
addl $0x2, %edi
callq 0x4348
movq %rax, %rbx
movq (%r14), %rdx
leaq 0x592c(%rip), %rsi      # 0xe182
xorl %r14d, %r14d
movq %rax, %rdi
movq %r15, %rcx
xorl %eax, %eax
callq 0x41a0
leaq 0x9627(%rip), %rax      # 0x11e94
cmpl $0x0, (%rax)
je 0x88fe
leaq 0x59ee(%rip), %rsi      # 0xe26b
movq %rbx, %rdi
callq 0x4140
testl %eax, %eax
je 0x88d0
leaq 0x59ef(%rip), %rsi      # 0xe27f
movq %rbx, %rdi
callq 0x4140
testl %eax, %eax
je 0x88de
leaq 0x59f0(%rip), %rsi      # 0xe293
movq %rbx, %rdi
callq 0x4140
testl %eax, %eax
je 0x88ec
leaq 0x59ef(%rip), %rsi      # 0xe2a5
movq %rbx, %rdi
callq 0x4140
testl %eax, %eax
jne 0x88fe
leaq 0x59e3(%rip), %rdx      # 0xe2ac
pushq $0x14
popq %rdi
pushq $0xc
jmp 0x88f8
leaq 0x599d(%rip), %rdx      # 0xe274
pushq $0x14
popq %rdi
pushq $0x4
jmp 0x88f8
leaq 0x59a3(%rip), %rdx      # 0xe288
pushq $0x14
popq %rdi
pushq $0x8
jmp 0x88f8
leaq 0x59a8(%rip), %rdx      # 0xe29b
pushq $0x14
popq %rdi
pushq $0x9
popq %rsi
callq 0x9bc0
leaq 0x2b6f(%rip), %rsi      # 0xb474
movq %rbx, %rdi
callq 0x4170
testq %rax, %rax
je 0x8959
movq %rax, %r15
leaq 0xa594(%rip), %rax      # 0x12eb0
cmpl $0x2, (%rax)
jl 0x8932
leaq 0x5860(%rip), %rdi      # 0xe188
movq %rbx, %rsi
xorl %eax, %eax
callq 0x40c0
movq %r15, %rdi
callq 0x4090
leaq 0x87cf(%rip), %rax      # 0x11110
movq (%rax), %rdi
leaq 0x9545(%rip), %rax      # 0x11e90
movl (%rax), %esi
movq %rbx, %rdx
callq 0x836a
pushq $0x1
popq %r14
movq %rbx, %rdi
callq 0x4030
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]gh_cpp/Src/gh_cpp3.c
// Function: hexa
int
hexa(char *s)
{	int x = 0;
	int cnt = 0;

	for ( ; *s != '\'' && *s != '\0'; s++)
	{	cnt++;
		x = 16*x + *s;
		switch (*s) {
		case '0': case '1': case '2':
		case '3': case '4': case '5':
		case '6': case '7': case '8':
		case '9':
			x -= '0';
			break;
		case 'a': case 'b': case 'c':
		case 'd': case 'e': case 'f':
			x -= 'a' + 10;
			break;
		case 'A': case 'B': case 'C':
		case 'D': case 'E': case 'F':
			x -= 'A' + 10;
			break;
		default:
			fatal_error("bad hexadecimal char constant");
	}	}
	if (cnt == 0)
		fprintf(stderr, "%s,%d: warning, \\x with no hex digits\n",
			filename, lineno);


	return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %r12d, %r12d
leaq 0x5a75(%rip), %r15      # 0xe400
movl $0x3ff, %r13d           # imm = 0x3FF
movl $0x7e0000, %ecx         # imm = 0x7E0000
movabsq $0x7e000000000000, %rdx # imm = 0x7E000000000000
xorl %ebx, %ebx
movzbl (%r14,%r12), %eax
testl %eax, %eax
je 0x8a00
cmpl $0x27, %eax
je 0x8a00
movsbl %al, %eax
shll $0x4, %ebx
addl %eax, %ebx
movzbl %al, %eax
addl $-0x30, %eax
cmpl $0x36, %eax
ja 0x89e7
btq %rax, %r13
jb 0x89da
btq %rax, %rcx
jb 0x89df
btq %rax, %rdx
jae 0x89e7
addl $-0x6b, %ebx
jmp 0x89e2
addl $-0x30, %ebx
jmp 0x89e2
addl $-0x4b, %ebx
incq %r12
jmp 0x89a2
movq %r15, %rdi
callq 0x42ec
movabsq $0x7e000000000000, %rdx # imm = 0x7E000000000000
movl $0x7e0000, %ecx         # imm = 0x7E0000
jmp 0x89e2
testl %r12d, %r12d
je 0x8a16
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x85db(%rip), %rax      # 0x10ff8
movq (%rax), %rdi
leaq 0x86e9(%rip), %rax      # 0x11110
movq (%rax), %rdx
leaq 0x945f(%rip), %rax      # 0x11e90
movl (%rax), %ecx
leaq 0x59e4(%rip), %rsi      # 0xe41e
xorl %eax, %eax
callq 0x4150
jmp 0x8a05
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]gh_cpp/Src/gh_cpp3.c
// Function: octal
int
octal(char *s)
{	int x = 0;
	int cnt = 0;

	for ( ; *s != '\'' && *s != '\0'; s++)
	{	if (++cnt > 3)
		{	x = (x << 8) + *s;
			continue;	/* octal sequence has only 3 significant digits */
		}
		x = 8*x + *s;
		switch (*s) {
		case '0': case '1': case '2':
		case '3': case '4': case '5':
		case '6': case '7': 
			x -= '0';
			break;
		default:
			fprintf(stderr, "saw character '%c'\n", *s);
			fatal_error("bad octal char constant");
	}	}

	if (cnt > 3)
		fprintf(stderr, "%s,%d: warning, multi-byte character constant\n",
			filename, lineno);

	return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x859d(%rip), %r15      # 0x10ff8
leaq 0x59e3(%rip), %r12      # 0xe445
xorl %r13d, %r13d
xorl %ebx, %ebx
movzbl (%r14,%r13), %eax
testl %eax, %eax
je 0x8ab3
cmpl $0x27, %eax
je 0x8ab3
movsbl %al, %edx
cmpl $0x3, %r13d
jb 0x8a85
shll $0x8, %ebx
addl %edx, %ebx
jmp 0x8a93
leal (%rdx,%rbx,8), %ebx
movl %edx, %eax
andb $-0x8, %al
cmpb $0x30, %al
jne 0x8a98
addl $-0x30, %ebx
incq %r13
jmp 0x8a67
movq (%r15), %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x4150
leaq 0x59ad(%rip), %rdi      # 0xe459
callq 0x42ec
jmp 0x8a93
cmpl $0x4, %r13d
jae 0x8aca
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%r15), %rdi
leaq 0x863c(%rip), %rax      # 0x11110
movq (%rax), %rdx
leaq 0x93b2(%rip), %rax      # 0x11e90
movl (%rax), %ecx
leaq 0x598a(%rip), %rsi      # 0xe471
xorl %eax, %eax
callq 0x4150
jmp 0x8ab9
// File: /workspace/github_c_makefile_star2_O2/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 0x8b3e
movq 0x28(%rbx), %r14
testq %r14, %r14
je 0x8b3e
cmpl $0x2, (%rbx)
jne 0x8b3e
cmpl $0x23, 0x4(%rbx)
jne 0x8b3e
cmpl $0x1, (%r14)
jne 0x8b3e
movq 0x8(%r14), %rdi
cmpb $0x69, (%rdi)
jne 0x8b2e
cmpb $0x66, 0x1(%rdi)
jne 0x8b2e
cmpb $0x0, 0x2(%rdi)
je 0x8b4e
leaq 0x4f14(%rip), %rsi      # 0xda49
callq 0x4140
testl %eax, %eax
je 0x8b4e
leaq 0x595b(%rip), %rdi      # 0xe4a0
callq 0x42ec
movq 0x28(%rbx), %r14
movb $0x0, 0xc94b(%rip)      # 0x154a0
movq %r14, 0xcd44(%rip)      # 0x158a0
callq 0x8bee
movl %eax, 0xcd41(%rip)      # 0x158a8
pushq $0x4
popq %rdi
callq 0x8c37
leaq 0xa33a(%rip), %r14      # 0x12eb0
cmpl $0x2, (%r14)
jl 0x8b88
leaq 0x5936(%rip), %rdi      # 0xe4b9
callq 0x8f47
cmpl $0x0, 0xcd19(%rip)      # 0x158a8
jne 0x8bc3
callq 0x9078
cmpl $0x0, 0xcd0f(%rip)      # 0x158ac
jne 0x8bcf
movl %eax, %ebx
cmpl $0x2, (%r14)
jl 0x8bb7
leaq 0x594b(%rip), %rdi      # 0xe4f9
movl %ebx, %esi
xorl %eax, %eax
callq 0x40c0
xorl %eax, %eax
testl %ebx, %ebx
setne %al
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x58f6(%rip), %rdi      # 0xe4c0
callq 0x8fef
leaq 0x58f9(%rip), %rdi      # 0xe4cf
leaq 0x58fe(%rip), %rsi      # 0xe4db
leaq 0x5901(%rip), %rcx      # 0xe4e5
movl $0x1bb, %edx            # imm = 0x1BB
callq 0x40e0
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]gh_cpp/Src/gh_cpp3.c
// Function: nxt_token
static Tokvals
nxt_token(void)
{
	if (!pp || !pp->nxt) return DONE;

	pp = pp->nxt;
	mychar = myval = pp->val;
	myname = pp->name;

	return pp->tok;
}

// Assembly:
movq 0xccab(%rip), %rcx      # 0x158a0
xorl %eax, %eax
testq %rcx, %rcx
je 0x8c36
pushq %rbp
movq %rsp, %rbp
movq 0x28(%rcx), %rcx
testq %rcx, %rcx
je 0x8c35
movq %rcx, 0xcc90(%rip)      # 0x158a0
movl 0x4(%rcx), %eax
leaq 0xa6de(%rip), %rdx      # 0x132f8
movl %eax, (%rdx)
leaq 0xa6c1(%rip), %rdx      # 0x132e4
movb %al, (%rdx)
movq 0x8(%rcx), %rax
leaq 0xa6b8(%rip), %rdx      # 0x132e8
movq %rax, (%rdx)
movl (%rcx), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x5626(%rip), %rdi      # 0xe585
xorl %eax, %eax
callq 0x40c0
leaq 0x561d(%rip), %rdi      # 0xe58a
movq %rbx, %rsi
xorl %eax, %eax
callq 0x40c0
leaq 0xc932(%rip), %r13      # 0x158b0
movq 0x804b(%rip), %rbx      # 0x10fd0
leaq 0x5609(%rip), %r14      # 0xe595
pushq $0xa
popq %r15
xorl %r12d, %r12d
movslq 0xc912(%rip), %rax      # 0x158ac
cmpq %rax, %r12
jge 0x8fd9
leaq 0x55e9(%rip), %rdi      # 0xe58f
movl %r12d, %esi
xorl %eax, %eax
callq 0x40c0
movl 0x4(%r13,%r12,8), %edi
movq (%rbx), %rsi
callq 0x436a
movl (%r13,%r12,8), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x40c0
movl %r15d, %edi
callq 0x4040
incq %r12
jmp 0x8f93
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4040
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
movq %rdi, %r9
movq 0x7ff8(%rip), %r14      # 0x10ff8
movq (%r14), %rdi
leaq 0x8106(%rip), %rax      # 0x11110
movq (%rax), %rdx
leaq 0x8e7c(%rip), %rax      # 0x11e90
movl (%rax), %ecx
leaq 0x557d(%rip), %rsi      # 0xe59a
leaq 0xb45c(%rip), %r8       # 0x14480
xorl %eax, %eax
callq 0x4150
movq (%r14), %rcx
leaq 0x558d(%rip), %rdi      # 0xe5c2
pushq $0xc
popq %rsi
pushq $0x1
popq %rbx
movq %rbx, %rdx
callq 0x41c0
movl 0xc85f(%rip), %edi      # 0x158a8
movq (%r14), %rsi
callq 0x436a
movq (%r14), %rcx
leaq 0x486f(%rip), %rdi      # 0xd8ca
pushq $0x2
popq %rsi
movq %rbx, %rdx
callq 0x41c0
movq (%r14), %rsi
xorl %edi, %edi
callq 0x45aa
pushq $0x1
popq %rdi
callq 0x41b0
// File: /workspace/github_c_makefile_star2_O2/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 0x95c8
movslq 0xc31e(%rip), %rax      # 0x158ac
leal 0x1(%rax), %ecx
leaq 0xc318(%rip), %rdx      # 0x158b0
movl %edi, 0x4(%rdx,%rax,8)
movl %esi, (%rdx,%rax,8)
movl %ecx, 0xc307(%rip)      # 0x158ac
cmpq $0xff, %rax
jge 0x95e5
leaq 0x98fc(%rip), %rax      # 0x12eb0
cmpl $0x2, (%rax)
jl 0x95c6
leaq 0x4fc0(%rip), %rdi      # 0xe580
popq %rbp
jmp 0x8f47
popq %rbp
retq
leaq 0x4f5b(%rip), %rdi      # 0xe52a
leaq 0x4f05(%rip), %rsi      # 0xe4db
leaq 0x4f7a(%rip), %rcx      # 0xe557
pushq $0x46
popq %rdx
callq 0x40e0
leaq 0x4f83(%rip), %rdi      # 0xe56f
callq 0x8fef
// File: /workspace/github_c_makefile_star2_O2/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 0xcaac(%rip)            # 0x160b0
callq 0x9078
movl %eax, %ebx
decl 0xca9f(%rip)            # 0x160b0
callq 0x9078
movl %eax, %r15d
movl %r14d, %eax
xorl $0x1b, %eax
orl %r15d, %eax
je 0x9638
cmpl $0x1a, %r14d
sete %al
testl %r15d, %r15d
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x9668
movb $0x0, 0xbe61(%rip)      # 0x154a0
cmpl $0x1a, %r14d
jne 0x964d
orl %ebx, %r15d
setne %al
jmp 0x965a
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, 0xca41(%rip)      # 0x160b0
jne 0x963f
cmpb $0x0, 0xbe28(%rip)      # 0x154a0
je 0x963f
leaq 0xbe1f(%rip), %rdi      # 0x154a0
callq 0x42ec
jmp 0x963f
// File: /workspace/github_c_makefile_star2_O2/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 0xca16(%rip)            # 0x160b0
callq 0x9078
movl %eax, %r15d
callq 0x9078
movl %eax, %r14d
movl 0xca00(%rip), %eax      # 0x160b0
decl %eax
movl %eax, 0xc9f8(%rip)      # 0x160b0
testl %r15d, %r15d
jle 0x9700
cmpl $0x3f, %r15d
jbe 0x9720
movups 0x4fb8(%rip), %xmm0     # 0xe682
movaps %xmm0, 0xbdef(%rip)     # 0x154c0
movups 0x4f9a(%rip), %xmm0     # 0xe672
movaps %xmm0, 0xbdd1(%rip)     # 0x154b0
movups 0x4f7c(%rip), %xmm0     # 0xe662
movaps %xmm0, 0xbdb3(%rip)     # 0x154a0
movabsq $0x776f6c66726576, %rcx # imm = 0x776F6C66726576
movq %rcx, 0xbdd2(%rip)      # 0x154d0
jmp 0x971c
movups 0x4f4b(%rip), %xmm0     # 0xe652
movups %xmm0, 0xbd9f(%rip)     # 0x154ad
movups 0x4f30(%rip), %xmm0     # 0xe645
movaps %xmm0, 0xbd84(%rip)     # 0x154a0
xorl %ecx, %ecx
jmp 0x972a
cmpb $0x0, 0xbd79(%rip)      # 0x154a0
sete %cl
testl %eax, %eax
jne 0x9732
testb %cl, %cl
je 0x9752
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
movq 0x789f(%rip), %rax      # 0x10ff8
movq (%rax), %rdi
leaq 0x79ad(%rip), %rax      # 0x11110
movq (%rax), %rdx
leaq 0x8723(%rip), %rax      # 0x11e90
movl (%rax), %ecx
leaq 0x4f24(%rip), %rsi      # 0xe69a
leaq 0xbd23(%rip), %r8       # 0x154a0
xorl %eax, %eax
callq 0x4150
jmp 0x9732
// File: /workspace/github_c_makefile_star2_O2/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 0xbd05(%rip), %rbx      # 0x154a0
leaq -0x410(%rbp), %rdi
movq %rbx, %rsi
callq 0x4070
incl 0xc900(%rip)            # 0x160b0
callq 0x9078
movl %eax, %r14d
leaq -0x810(%rbp), %rdi
movq %rbx, %rsi
callq 0x4070
movslq 0xc0de(%rip), %rax      # 0x158ac
leaq -0x1(%rax), %rcx
movl %ecx, 0xc0d4(%rip)      # 0x158ac
leaq 0xc0d1(%rip), %rcx      # 0x158b0
cmpl $0x1e, -0x4(%rcx,%rax,8)
jne 0x98a7
callq 0x9078
movl %eax, %ebx
leaq 0xbca8(%rip), %rsi      # 0x154a0
leaq -0xc10(%rbp), %rdi
callq 0x4070
decl 0xc8a6(%rip)            # 0x160b0
callq 0x9078
testl %eax, %eax
je 0x983a
cmpb $0x0, -0xc10(%rbp)
je 0x987e
cmpl $0x0, 0xc88d(%rip)      # 0x160b0
je 0x9861
leaq -0x410(%rbp), %rdi
leaq -0xc10(%rbp), %rsi
callq 0x4070
jmp 0x987e
cmpb $0x0, -0x810(%rbp)
je 0x987b
cmpl $0x0, 0xc866(%rip)      # 0x160b0
je 0x986f
leaq -0x410(%rbp), %rdi
leaq -0x810(%rbp), %rsi
callq 0x4070
jmp 0x987b
leaq -0xc10(%rbp), %rdi
callq 0x42ec
jmp 0x987e
leaq -0x810(%rbp), %rdi
callq 0x42ec
movl %r14d, %ebx
leaq 0xbc1b(%rip), %rdi      # 0x154a0
leaq -0x410(%rbp), %rsi
callq 0x4070
pushq $0x4
popq %rdi
movl %ebx, %esi
callq 0x957e
addq $0xc00, %rsp            # imm = 0xC00
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x4e00(%rip), %rdi      # 0xe6ae
leaq 0x4c26(%rip), %rsi      # 0xe4db
leaq 0x4e12(%rip), %rcx      # 0xe6ce
movl $0x161, %edx            # imm = 0x161
callq 0x40e0
nop
// File: /workspace/github_c_makefile_star2_O2/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 %rdi, -0x30(%rbp)
andq $0x0, 0xc7cd(%rip)      # 0x160b8
leaq 0x4df2(%rip), %r12      # 0xe6e4
leaq -0x430(%rbp), %r13
leaq 0x3fa8(%rip), %rbx      # 0xd8a8
xorl %r15d, %r15d
testq %r14, %r14
je 0x99de
addl 0x10(%r14), %r15d
movl (%r14), %eax
leal -0x1(%rax), %ecx
cmpl $0x3, %ecx
ja 0x992a
movslq (%r12,%rcx,4), %rax
addq %r12, %rax
jmpq *%rax
movq 0x8(%r14), %rdi
jmp 0x9972
cmpl $0x20, %eax
jne 0x9990
movq %r14, %rdi
movl %r15d, %esi
pushq $0x2
popq %rdx
jmp 0x997f
movq %r14, %rdi
movl %r15d, %esi
pushq $0x1
popq %rdx
callq 0x99ff
movl %eax, %r15d
movb 0x4(%r14), %al
movb %al, -0x430(%rbp)
movb $0x0, -0x42f(%rbp)
jmp 0x996f
movl 0x4(%r14), %edx
movq %r13, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x41a0
movq %r13, %rdi
callq 0x40a0
movq %r14, %rdi
movl %r15d, %esi
movl %eax, %edx
callq 0x99ff
movl %eax, %r15d
movq 0x28(%r14), %r14
jmp 0x9903
movq 0x7661(%rip), %rax      # 0x10ff8
movq (%rax), %rcx
leaq 0x3f2f(%rip), %rdi      # 0xd8d0
pushq $0x5
popq %rsi
pushq $0x1
popq %rdx
callq 0x41c0
movq 0x7645(%rip), %rax      # 0x10ff8
movq (%rax), %rsi
movq %r14, %rdi
callq 0x436a
movq 0x7633(%rip), %rax      # 0x10ff8
movq (%rax), %rsi
pushq $0xa
popq %rdi
callq 0x4110
leaq 0x3eff(%rip), %rdi      # 0xd8d6
callq 0x42ec
jmp 0x9987
movq 0xc6d3(%rip), %rsi      # 0x160b8
movq -0x30(%rbp), %rdi
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x9ae0
// File: /workspace/github_c_makefile_star2_O2/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
leaq 0x18(%rdi), %r13
leaq 0xc69b(%rip), %r9       # 0x160b8
movl %esi, -0x2c(%rbp)
movq %rdi, -0x38(%rbp)
movq (%r13), %r13
testq %r13, %r13
je 0x9acd
movl 0x10(%rdi), %r12d
movl %esi, %r14d
subl %r12d, %r14d
addl %ebx, %r12d
movq (%r13), %r15
movq %r9, %rax
movq (%rax), %rax
testq %rax, %rax
je 0x9a65
cmpq %r15, 0x8(%rax)
jne 0x9a5f
movl 0x4(%rax), %ecx
movl (%rax), %edx
addl %ecx, %edx
cmpl %r14d, %edx
je 0x9abe
addq $0x10, %rax
jmp 0x9a45
movq 0xc654(%rip), %rax      # 0x160c0
testq %rax, %rax
je 0x9a89
movq 0x10(%rax), %rcx
movq %rcx, 0xc644(%rip)      # 0x160c0
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
jmp 0x9a9f
pushq $0x18
popq %rdi
callq 0x4348
leaq 0xc620(%rip), %r9       # 0x160b8
movq -0x38(%rbp), %rdi
movl -0x2c(%rbp), %esi
movl %r14d, (%rax)
movl %r12d, 0x4(%rax)
movq %r15, 0x8(%rax)
movq 0xc607(%rip), %rcx      # 0x160b8
movq %rcx, 0x10(%rax)
movq %rax, 0xc5fc(%rip)      # 0x160b8
jmp 0x9ac4
addl %r12d, %ecx
movl %ecx, 0x4(%rax)
addq $0x8, %r13
jmp 0x9a24
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_O2/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 0x9b95
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rsi
callq 0x9ae0
movq 0xc5b6(%rip), %rax      # 0x160c0
movq %rax, 0x10(%r14)
movq %r14, 0xc5ab(%rip)      # 0x160c0
leaq 0x9394(%rip), %rax      # 0x12eb0
cmpl $0x0, (%rax)
je 0x9b36
leaq 0x4be8(%rip), %rdi      # 0xe710
pushq $0x6
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x41c0
xorl %r12d, %r12d
pushq $0x20
popq %r15
cmpl (%r14), %r12d
jge 0x9b52
movl %r15d, %edi
movq %rbx, %rsi
callq 0x4110
incl %r12d
jmp 0x9b3d
xorl %r12d, %r12d
pushq $0x2d
popq %r15
cmpl 0x4(%r14), %r12d
jge 0x9b6f
movl %r15d, %edi
movq %rbx, %rsi
callq 0x4110
incl %r12d
jmp 0x9b59
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x9b96
movq 0x10(%rax), %rdx
movl 0x8(%rax), %ecx
movq (%rax), %r8
leaq 0x4b8e(%rip), %rsi      # 0xe717
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4150
jmp 0x9bab
retq
leaq 0x4b87(%rip), %rdi      # 0xe724
pushq $0xc
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x41c0
pushq $0xa
popq %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4110
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x82b6(%rip), %rax      # 0x11e94
cmpl $0x1, (%rax)
jg 0x9bf3
leaq 0xb8a2(%rip), %rax      # 0x1548c
cmpl $0x1, (%rax)
jg 0x9caa
leaq 0x7516(%rip), %rax      # 0x11110
movq (%rax), %r14
leaq 0x618(%rip), %rsi       # 0xa21c
movq %r14, %rdi
callq 0x4140
testl %eax, %eax
je 0x9caa
leaq 0xc4ad(%rip), %rbx      # 0x160c8
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x9c39
cmpl %r13d, 0x8(%rbx)
jne 0x9c33
cmpl %r12d, 0xc(%rbx)
je 0x9cb9
addq $0x18, %rbx
jmp 0x9c1b
pushq $0x20
popq %rdi
callq 0x4348
movq %rax, %rbx
movl %r13d, 0x8(%rax)
movl %r12d, 0xc(%rax)
movq %r15, (%rax)
movq 0xc472(%rip), %rax      # 0x160c8
movq %rax, 0x18(%rbx)
movq %rbx, 0xc467(%rip)      # 0x160c8
pushq $0x18
popq %rdi
callq 0x4348
movq %rax, %r14
leaq 0x749d(%rip), %r15      # 0x11110
movq (%r15), %rdi
callq 0x40a0
leal 0x1(%rax), %edi
callq 0x4348
movq %rax, (%r14)
movq (%r15), %rsi
movq %rax, %rdi
callq 0x4070
leaq 0x81f8(%rip), %rax      # 0x11e90
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
leaq 0x81d0(%rip), %rax      # 0x11e90
movl (%rax), %r15d
movq %rbx, %r12
movq 0x10(%r12), %r12
testq %r12, %r12
je 0x9c61
cmpl %r15d, 0x8(%r12)
jne 0x9cc6
movq (%r12), %rdi
movq %r14, %rsi
callq 0x4140
testl %eax, %eax
jne 0x9cc6
jmp 0x9caa
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]gh_cpp/Src/gh_cpp5.c
// Function: show_violations
void
show_violations(void)
{	Rule *r;

	if (!violations) return;
	
	for (r = violations; r; r = r->nxt)
	{	fprintf(stderr, "non-compliance with misra-rule %d.%d: use of '%s'",
			r->R_major, r->R_minor, r->tag);
		lastnm = (char *) 0;
		show_one(r->lst);
		fprintf(stderr, "\n\n");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0xc3ca(%rip), %r13      # 0x160c8
testq %r13, %r13
je 0x9d63
movq 0x72ee(%rip), %rbx      # 0x10ff8
leaq 0x4105(%rip), %r14      # 0xde16
pushq $0x2
popq %r15
pushq $0x1
popq %r12
testq %r13, %r13
je 0x9d63
movq (%rbx), %rdi
movl 0x8(%r13), %edx
movl 0xc(%r13), %ecx
movq (%r13), %r8
leaq 0x49fd(%rip), %rsi      # 0xe731
xorl %eax, %eax
callq 0x4150
andq $0x0, 0xc38d(%rip)      # 0x160d0
movq 0x10(%r13), %rdi
callq 0x9d72
movq (%rbx), %rcx
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x41c0
movq 0x18(%r13), %r13
jmp 0x9d19
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nimble-code[P]gh_cpp/Src/gh_cpp5.c
// Function: show_one
static void
show_one(Offd *o)
{
	if (!o) return;
	show_one(o->nxt);

	if (!lastnm || strcmp(lastnm, o->fnm) != 0)
		fprintf(stderr, "\n\t%s:\t", o->fnm);
	fprintf(stderr, "%d, ", o->ln);

	lastnm = o->fnm;
}

// Assembly:
testq %rdi, %rdi
jne 0x9d78
retq
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x9d72
movq 0xc33e(%rip), %rdi      # 0x160d0
movq (%rbx), %r14
testq %rdi, %rdi
je 0x9da6
movq %r14, %rsi
callq 0x4140
testl %eax, %eax
je 0x9dc1
movq 0x724b(%rip), %rax      # 0x10ff8
movq (%rax), %rdi
leaq 0x49ac(%rip), %rsi      # 0xe763
movq %r14, %rdx
xorl %eax, %eax
callq 0x4150
movq 0x7230(%rip), %rax      # 0x10ff8
movq (%rax), %rdi
movl 0x8(%rbx), %edx
leaq 0x4995(%rip), %rsi      # 0xe76a
xorl %eax, %eax
callq 0x4150
movq (%rbx), %rax
movq %rax, 0xc2ea(%rip)      # 0x160d0
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4d14
cmpl $0x1, %ecx
je 0x4d09
testl %ecx, %ecx
jne 0x4e0f
movq 0x8(%rax), %rdi
movl 0x10(%rax), %esi
callq 0x5ac4
jmp 0x4d4a
movq 0x28(%rax), %rdi
callq 0x5c5d
jmp 0x4d4a
movq 0x28(%rax), %rdi
callq 0x5c5d
testq %rax, %rax
je 0x4dad
pushq $0x1
popq %rsi
movq %rax, %rdi
callq 0x4e2c
movl %eax, %ebx
leaq 0x4fa5(%rip), %rdi      # 0x9cdf
movl %eax, %esi
xorl %eax, %eax
callq 0x2110
movl %ebx, %edi
callq 0x5d07
movq %rax, %rbx
testq %rax, %rax
je 0x4dad
cmpl $0x0, (%rbx)
jne 0x4dbb
leaq 0x4fdb(%rip), %rsi      # 0x9d39
movq %rbx, %rdi
xorl %eax, %eax
callq 0x612d
testq %rax, %rax
je 0x4ddd
movq %rax, %rdi
callq 0x4ee8
leaq 0x5002(%rip), %rsi      # 0x9d7e
movq %rbx, %rdi
xorl %eax, %eax
callq 0x612d
testq %rax, %rax
je 0x4df6
cmpl $0x3, (%rax)
jne 0x4da4
cmpq $0x0, 0x8(%rax)
jne 0x4da4
movq %rax, %rdi
callq 0x4ee8
movq %rbx, %rax
popq %rbx
retq
leaq 0x557c(%rip), %rdi      # 0xa327
jmp 0x4db4
leaq 0x5544(%rip), %rdi      # 0xa2f8
callq 0x2090
jmp 0x4dd5
leaq 0x4(%rbx), %rsi
leaq 0x4f5d(%rip), %rdi      # 0x9d23
xorl %eax, %eax
callq 0x2110
movq %rbx, %rdi
callq 0x5964
pushq $0x1
popq %rdi
callq 0x22b0
leaq 0x4f5e(%rip), %rdi      # 0x9d42
leaq 0x4a8f(%rip), %rsi      # 0x987a
leaq 0x4f5e(%rip), %rcx      # 0x9d50
pushq $0x3b
jmp 0x4e26
leaq 0x4f45(%rip), %rdi      # 0x9d42
leaq 0x4a76(%rip), %rsi      # 0x987a
leaq 0x4f45(%rip), %rcx      # 0x9d50
pushq $0x40
jmp 0x4e26
leaq 0x5a48(%rip), %rdi      # 0xa85e
leaq 0x4a5d(%rip), %rsi      # 0x987a
leaq 0x4eda(%rip), %rcx      # 0x9cfe
pushq $0x6e
popq %rdx
callq 0x2150
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
cmpl $0x3, %edi
je 0x32d8
leaq 0x1652(%rip), %rsi      # 0x4922
pushq $0x2
popq %rdi
callq 0x12c4
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x225e
movq 0x8(%rbx), %rdi
callq 0x140c
testl %eax, %eax
je 0x3305
movq 0x8(%rbx), %rdx
leaq 0x164e(%rip), %rsi      # 0x494b
pushq $0x1
popq %rdi
callq 0x1306
movq 0x10(%rbx), %rdi
callq 0x140c
testl %eax, %eax
je 0x3325
movq 0x10(%rbx), %rdx
leaq 0x162e(%rip), %rsi      # 0x494b
pushq $0x1
popq %rdi
callq 0x1306
movq 0x8(%rbx), %rdi
leaq 0x20(%rsp), %rsi
pushq $0x20
popq %rbp
movl %ebp, %edx
callq 0x3248
movq 0x10(%rbx), %rdi
movq %rsp, %rsi
movl %ebp, %edx
callq 0x3248
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movl $0x100000, %esi         # imm = 0x100000
movl $0x11b049, %edx         # imm = 0x11B049
callq 0x17d4
movl %eax, %eax
leaq (%r14,%rax,8), %r15
xorl %r12d, %r12d
movq %r15, %rax
movq (%rax), %r14
testq %r14, %r14
je 0x12f2
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x17b8
testl %eax, %eax
je 0x1335
leaq 0x10(%r14), %rax
movq %r14, %r12
jmp 0x12d2
pushq $0x18
popq %rdi
callq 0x1100
movq %rax, %r14
movq %rbx, %rdi
callq 0x10a0
leaq 0x1(%rax), %rdi
callq 0x1100
movq %rax, (%r14)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1050
movq $0x1, 0x8(%r14)
andq $0x0, 0x10(%r14)
testq %r12, %r12
je 0x134e
movq %r14, 0x10(%r12)
jmp 0x1351
incq 0x8(%r14)
testq %r12, %r12
je 0x1351
movq 0x10(%r14), %rax
movq %rax, 0x10(%r12)
movq (%r15), %rax
movq %rax, 0x10(%r14)
movq %r14, (%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
cmpl $0x2, %edi
jne 0x16a6
movq 0x8(%rbx), %rdi
leaq 0xb18(%rip), %rsi       # 0x2181
callq 0x17b8
testl %eax, %eax
je 0x1728
movq 0x8(%rbx), %rdi
leaq 0xb04(%rip), %rsi       # 0x2185
callq 0x17b8
testl %eax, %eax
je 0x1728
movq 0x8(%rbx), %rdi
leaq 0xaeb(%rip), %rsi       # 0x2184
callq 0x17b8
testl %eax, %eax
je 0x1728
leaq 0xade(%rip), %rdi       # 0x218b
movl %ebp, %esi
movq %rbx, %rdx
callq 0x18fc
testl %eax, %eax
jle 0x16cd
movl %eax, %eax
movq 0x8(%rbx,%rax,8), %rdi
callq 0x1140
movl %eax, 0x29fb(%rip)      # 0x40c8
leaq 0xac0(%rip), %rdi       # 0x2194
movl %ebp, %esi
movq %rbx, %rdx
callq 0x18fc
testl %eax, %eax
jle 0x16f5
movl %eax, %eax
movq 0x8(%rbx,%rax,8), %rdi
callq 0x10d0
movq %rax, 0x29eb(%rip)      # 0x40e0
leaq 0xaa3(%rip), %rdi       # 0x219f
movl %ebp, %esi
movq %rbx, %rdx
callq 0x18fc
testl %eax, %eax
jle 0x171d
movl %eax, %eax
movq 0x8(%rbx,%rax,8), %rdi
callq 0x10d0
movq %rax, 0x29b3(%rip)      # 0x40d0
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x135d
leaq 0xa7b(%rip), %rdi       # 0x21aa
callq 0x1060
leaq 0xa95(%rip), %rdi       # 0x21d0
callq 0x1060
leaq 0xabc(%rip), %rdi       # 0x2203
callq 0x1060
leaq 0xabf(%rip), %rdi       # 0x2212
callq 0x1060
leaq 0xac3(%rip), %rdi       # 0x2222
callq 0x1060
leaq 0xadd(%rip), %rdi       # 0x2248
callq 0x1060
leaq 0xae3(%rip), %rdi       # 0x225a
callq 0x1060
leaq 0xb8b(%rip), %rdi       # 0x230e
callq 0x1060
leaq 0xb91(%rip), %rdi       # 0x2320
callq 0x1060
leaq 0xbd5(%rip), %rdi       # 0x2370
callq 0x1060
leaq 0xbd9(%rip), %rdi       # 0x2380
callq 0x1060
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/X1319RAY[P]fileIO/extraction.cpp
// Function: main
int main(int argc, char* argv[]){
	using namespace std;
	
	// コマンドライン引数のチェック
	if(argc != 2){
		cerr << "引数の数が間違っています．" << endl;
		cerr << "./extraction input.txt" << endl;
		return 1;
	}
	
	// C++のファイル入力のための準備
	ifstream ifs(argv[1], ios::in);
	// ファイルを開くのに失敗したときの処理
	if(!ifs){
		cerr << "Error: file not opened." << endl;
		return 1;
	}
	
	string str;
	int num;
	int sum = 0;
	// 抽出演算子>>を使ってデリミタで区切られた単語，値を読み込む
	while(ifs >> str >> num){
		// ここで格納した文字列や変数を煮るなり焼くなりする
		cout << str << " " << num << endl; // そのまま出力
		sum += num; // 値をsumに加算
	}
	
	cout << "\nsum: " << sum << endl;
	
	// ファイルを閉じる
	ifs.close();
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x238, %rsp            # imm = 0x238
cmpl $0x2, %edi
jne 0x129f
movq 0x8(%rsi), %rsi
leaq -0x258(%rbp), %rbx
pushq $0x8
popq %rdx
movq %rbx, %rdi
callq 0x10f0
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x238(%rbp,%rax)
je 0x12dc
movq 0x2d6d(%rip), %rdi      # 0x3ff0
leaq 0xdb9(%rip), %rsi       # 0x2043
callq 0x10a0
movq %rax, %rdi
callq 0x1060
pushq $0x1
popq %rbx
jmp 0x1396
movq 0x2d4a(%rip), %rbx      # 0x3ff0
leaq 0xd57(%rip), %rsi       # 0x2004
movq %rbx, %rdi
callq 0x10a0
movq %rax, %rdi
callq 0x1060
leaq 0xd68(%rip), %rsi       # 0x202c
movq %rbx, %rdi
callq 0x10a0
movq %rax, %rdi
callq 0x1060
pushq $0x1
popq %rbx
jmp 0x13a2
leaq -0x40(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
xorl %ebx, %ebx
leaq -0x258(%rbp), %r14
leaq -0x50(%rbp), %r15
leaq -0x2c(%rbp), %r12
leaq 0xd5c(%rip), %r13       # 0x2060
movq %r14, %rdi
movq %r15, %rsi
callq 0x10b0
movq %rax, %rdi
movq %r12, %rsi
callq 0x1070
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x135a
movq 0x2ca1(%rip), %rdi      # 0x3fd0
movq %r15, %rsi
callq 0x1090
movq %rax, %rdi
movq %r13, %rsi
callq 0x10a0
movl -0x2c(%rbp), %esi
movq %rax, %rdi
callq 0x10d0
movq %rax, %rdi
callq 0x1060
addl -0x2c(%rbp), %ebx
jmp 0x1304
movq 0x2c6f(%rip), %rdi      # 0x3fd0
leaq 0xcf3(%rip), %rsi       # 0x205b
callq 0x10a0
movq %rax, %rdi
movl %ebx, %esi
callq 0x10d0
movq %rax, %rdi
callq 0x1060
leaq -0x258(%rbp), %rdi
callq 0x1030
leaq -0x50(%rbp), %rdi
callq 0x1050
xorl %ebx, %ebx
leaq -0x258(%rbp), %rdi
callq 0x1040
movl %ebx, %eax
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x13c9
jmp 0x13bd
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x1050
leaq -0x258(%rbp), %rdi
callq 0x1040
movq %rbx, %rdi
callq 0x10e0
// File: /workspace/github_c_makefile_star2_O2/Leeheng86[P]word2vec/word2phrase.c
// Function: ReadWord(char*, _IO_FILE*)
void ReadWord(char *word, FILE *fin) {
  int a = 0, ch;
  while (!feof(fin)) {
    ch = fgetc(fin);
    if (ch == 13) continue;
    if ((ch == ' ') || (ch == '\t') || (ch == '\n')) {
      if (a > 0) {
        if (ch == '\n') ungetc(ch, fin);
        break;
      }
      if (ch == '\n') {
        strcpy(word, (char *)"
");
        return;
      } else continue;
    }
    word[a] = ch;
    a++;
    if (a >= MAX_STRING - 1) a--;   // Truncate too long words
  }
  word[a] = 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
xorl %ebp, %ebp
movabsq $0x100000600, %r15      # imm = 0x100000600
movq %r14, %rdi
callq 0x1140
movl %ebp, %r12d
testl %eax, %eax
jne 0x12f6
movq %r14, %rdi
callq 0x1160
cmpl $0xd, %eax
je 0x12a6
cmpl $0x20, %eax
ja 0x12da
movl %eax, %ecx
btq %rcx, %r15
jae 0x12da
testl %ebp, %ebp
jne 0x12e6
cmpl $0xa, %eax
jne 0x12a6
jmp 0x12fd
movb %al, (%rbx,%r12)
cmpl $0x3a, %ebp
adcl $0x0, %ebp
jmp 0x12a6
cmpl $0xa, %eax
jne 0x12f6
pushq $0xa
popq %rdi
movq %r14, %rsi
callq 0x1040
movb $0x0, (%rbx,%r12)
jmp 0x1307
movb $0x0, 0x4(%rbx)
movl $0x3e732f3c, (%rbx)     # imm = 0x3E732F3C
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Leeheng86[P]word2vec/word2phrase.c
// Function: GetWordHash(char*)
int GetWordHash(char *word) {
  unsigned long long a, hash = 1;
  for (a = 0; a < strlen(word); a++) hash = hash * 257 + word[a];
  hash = hash % vocab_hash_size;
  return hash;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x1060
movq %rax, %rcx
pushq $0x1
popq %rax
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x133a
imulq $0x101, %rax, %rsi      # imm = 0x101
movsbq (%rbx,%rdx), %rax
addq %rsi, %rax
incq %rdx
jmp 0x1321
movl $0x1dcd6500, %ecx       # imm = 0x1DCD6500
xorl %edx, %edx
divq %rcx
movq %rdx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/Leeheng86[P]word2vec/word2phrase.c
// Function: SearchVocab(char*)
int SearchVocab(char *word) {
  unsigned int hash = GetWordHash(word);
  while (1) {
    if (vocab_hash[hash] == -1) return -1;
    if (!strcmp(word, vocab[vocab_hash[hash]].word)) return vocab_hash[hash];
    hash = (hash + 1) % vocab_hash_size;
  }
  return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1310
movl %eax, %ebp
movq 0x2e33(%rip), %r15      # 0x4198
movq 0x2e24(%rip), %r12      # 0x4190
xorl %r13d, %r13d
movl %ebp, %eax
movslq (%r15,%rax,4), %r14
cmpq $-0x1, %r14
je 0x13a1
movq %r14, %rax
shlq $0x4, %rax
movq 0x8(%r12,%rax), %rsi
movq %rbx, %rdi
callq 0x1110
testl %eax, %eax
je 0x13a1
incl %ebp
cmpl $0x1dcd6500, %ebp       # imm = 0x1DCD6500
cmovel %r13d, %ebp
jmp 0x136f
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Leeheng86[P]word2vec/word2phrase.c
// Function: ReadWordIndex(_IO_FILE*)
int ReadWordIndex(FILE *fin) {
  char word[MAX_STRING];
  ReadWord(word, fin);
  if (feof(fin)) return -1;
  return SearchVocab(word);
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x128c
movq %rbx, %rdi
callq 0x1140
testl %eax, %eax
je 0x13d7
pushq $-0x1
popq %rax
jmp 0x13df
movq %rsp, %rdi
callq 0x1349
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/Leeheng86[P]word2vec/word2phrase.c
// Function: AddWordToVocab(char*)
int AddWordToVocab(char *word) {
  unsigned int hash, length = strlen(word) + 1;
  if (length > MAX_STRING) length = MAX_STRING;
  vocab[vocab_size].word = (char *)calloc(length, sizeof(char));
  strcpy(vocab[vocab_size].word, word);
  vocab[vocab_size].cn = 0;
  vocab_size++;
  // Reallocate memory if needed
  if (vocab_size + 2 >= vocab_max_size) {
    vocab_max_size += 10000;
    vocab=(struct vocab_word *)realloc(vocab, vocab_max_size * sizeof(struct vocab_word));
  }
  hash = GetWordHash(word);
  while (vocab_hash[hash] != -1) hash = (hash + 1) % vocab_hash_size;
  vocab_hash[hash]=vocab_size - 1;
  return vocab_size - 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x1060
incl %eax
cmpl $0x3c, %eax
pushq $0x3c
popq %rdi
cmovbl %eax, %edi
pushq $0x1
popq %rsi
callq 0x1070
movq 0x2d88(%rip), %rcx      # 0x4190
movq 0x2d91(%rip), %rdx      # 0x41a0
shlq $0x4, %rdx
movq %rax, 0x8(%rcx,%rdx)
movq 0x2d71(%rip), %rax      # 0x4190
movq 0x8(%rax,%rdx), %rdi
movq %rbx, %rsi
callq 0x1080
movq 0x2d5d(%rip), %rdi      # 0x4190
movq 0x2d66(%rip), %rax      # 0x41a0
shlq $0x4, %rax
andq $0x0, (%rdi,%rax)
movq 0x2d56(%rip), %rax      # 0x41a0
leaq 0x1(%rax), %rcx
movq %rcx, 0x2d4b(%rip)      # 0x41a0
addq $0x3, %rax
movq 0x2c88(%rip), %rsi      # 0x40e8
cmpq %rsi, %rax
jl 0x1483
addq $0x2710, %rsi           # imm = 0x2710
movq %rsi, 0x2c75(%rip)      # 0x40e8
shlq $0x4, %rsi
callq 0x1170
movq %rax, 0x2d0d(%rip)      # 0x4190
movq %rbx, %rdi
callq 0x1310
movq 0x2d06(%rip), %rdx      # 0x4198
xorl %ecx, %ecx
movl %eax, %eax
cmpl $-0x1, (%rdx,%rax,4)
je 0x14a8
incl %eax
cmpl $0x1dcd6500, %eax       # imm = 0x1DCD6500
cmovel %ecx, %eax
jmp 0x1494
movl 0x2cf2(%rip), %ecx      # 0x41a0
decl %ecx
movl %ecx, (%rdx,%rax,4)
movl %ecx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq 0x2cc8(%rip), %rdi      # 0x4190
addq $0x10, %rdi
movq 0x2ccd(%rip), %rsi      # 0x41a0
decq %rsi
leaq -0x26(%rip), %rcx       # 0x14b7
pushq $0x10
popq %rdx
callq 0x1180
xorl %eax, %eax
movq 0x2caa(%rip), %rcx      # 0x4198
cmpq $0x1dcd6500, %rax       # imm = 0x1DCD6500
je 0x14ff
orl $-0x1, (%rcx,%rax,4)
incq %rax
jmp 0x14ee
movq 0x2c9a(%rip), %rbx      # 0x41a0
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x2c7d(%rip), %rdi      # 0x4190
cmpq %r15, %rbx
jle 0x157e
movq %r15, %rax
shlq $0x4, %rax
movslq 0x2bb6(%rip), %rcx      # 0x40dc
cmpq %rcx, (%rdi,%rax)
jge 0x154d
decq %rbx
movq %rbx, 0x2c6a(%rip)      # 0x41a0
shlq $0x4, %rbx
movq 0x8(%rdi,%rbx), %rdi
callq 0x10d0
movq 0x2c55(%rip), %rbx      # 0x41a0
jmp 0x1579
addq %rax, %rdi
movq 0x8(%rdi), %rdi
callq 0x1310
movq 0x2c38(%rip), %rcx      # 0x4198
movl %eax, %eax
cmpl $-0x1, (%rcx,%rax,4)
je 0x1575
incl %eax
cmpl $0x1dcd6500, %eax       # imm = 0x1DCD6500
cmovel %r14d, %eax
jmp 0x1560
movl %r15d, (%rcx,%rax,4)
incq %r15
jmp 0x150c
shlq $0x4, %rbx
movq %rbx, %rsi
callq 0x1170
movq %rax, 0x2bff(%rip)      # 0x4190
popq %rbx
popq %r14
popq %r15
retq