LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0xd321(%rip)            # 0x170b0
callq 0x96ee
movl %eax, %r15d
callq 0x96ee
movl %eax, %r14d
movl 0xd30b(%rip), %eax      # 0x170b0
decl %eax
movl %eax, 0xd303(%rip)      # 0x170b0
testl %r15d, %r15d
jle 0x9df5
cmpl $0x40, %r15d
jb 0x9e11
movups 0x58c7(%rip), %xmm0     # 0xf686
movaps %xmm0, 0xc6fa(%rip)     # 0x164c0
movups 0x58a9(%rip), %xmm0     # 0xf676
movaps %xmm0, 0xc6dc(%rip)     # 0x164b0
movups 0x588b(%rip), %xmm0     # 0xf666
movaps %xmm0, 0xc6be(%rip)     # 0x164a0
movabsq $0x776f6c66726576, %rcx # imm = 0x776F6C66726576
movq %rcx, 0xc6dd(%rip)      # 0x164d0
jmp 0x9e11
movups 0x585a(%rip), %xmm0     # 0xf656
movups %xmm0, 0xc6aa(%rip)     # 0x164ad
movups 0x583f(%rip), %xmm0     # 0xf649
movaps %xmm0, 0xc68f(%rip)     # 0x164a0
testl %eax, %eax
jne 0x9e1e
cmpb $0x0, 0xc684(%rip)      # 0x164a0
jne 0x9e3e
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 0x4883
jmp 0x9e1e
// File: /workspace/github_c_makefile_star2_O1/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 0xc646(%rip), %rbx      # 0x164a0
leaq -0x410(%rbp), %rdi
movq %rbx, %rsi
callq 0x4070
incl 0xd241(%rip)            # 0x170b0
callq 0x96ee
movl %eax, %r14d
leaq -0x810(%rbp), %rdi
movq %rbx, %rsi
callq 0x4070
movslq 0xca1f(%rip), %rax      # 0x168ac
leaq -0x1(%rax), %rcx
movl %ecx, 0xca15(%rip)      # 0x168ac
leaq 0xca12(%rip), %rcx      # 0x168b0
cmpl $0x1e, -0x4(%rcx,%rax,8)
jne 0x9f68
callq 0x96ee
movl %eax, %ebx
leaq 0xc5e9(%rip), %rsi      # 0x164a0
leaq -0xc10(%rbp), %rdi
callq 0x4070
decl 0xd1e7(%rip)            # 0x170b0
callq 0x96ee
testl %eax, %eax
je 0x9ef9
cmpb $0x0, -0xc10(%rbp)
je 0x9f3d
cmpl $0x0, 0xd1ce(%rip)      # 0x170b0
je 0x9f20
leaq -0x410(%rbp), %rdi
leaq -0xc10(%rbp), %rsi
callq 0x4070
jmp 0x9f3d
cmpb $0x0, -0x810(%rbp)
je 0x9f3a
cmpl $0x0, 0xd1a7(%rip)      # 0x170b0
je 0x9f2e
leaq -0x410(%rbp), %rdi
leaq -0x810(%rbp), %rsi
callq 0x4070
jmp 0x9f3a
leaq -0xc10(%rbp), %rdi
callq 0x4a9c
jmp 0x9f3d
leaq -0x810(%rbp), %rdi
callq 0x4a9c
movl %r14d, %ebx
leaq 0xc55c(%rip), %rdi      # 0x164a0
leaq -0x410(%rbp), %rsi
callq 0x4070
movl $0x4, %edi
movl %ebx, %esi
callq 0x9c71
addq $0xc00, %rsp            # imm = 0xC00
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x5743(%rip), %rdi      # 0xf6b2
leaq 0x5569(%rip), %rsi      # 0xf4df
leaq 0x5755(%rip), %rcx      # 0xf6d2
movl $0x161, %edx            # imm = 0x161
callq 0x40e0
nop
// File: /workspace/github_c_makefile_star2_O1/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 %rdi, -0x30(%rbp)
movq $0x0, 0xd10d(%rip) # 0x170b8
testq %rsi, %rsi
je 0xa064
movq %rsi, %r14
leaq 0x572a(%rip), %rbx      # 0xf6e8
leaq -0x430(%rbp), %r15
leaq 0x48dc(%rip), %r12      # 0xe8a8
xorl %r13d, %r13d
addl 0x10(%r14), %r13d
movl (%r14), %eax
leal -0x1(%rax), %ecx
cmpl $0x3, %ecx
ja 0x9fed
movslq (%rbx,%rcx,4), %rax
addq %rbx, %rax
jmpq *%rax
movq 0x8(%r14), %rdi
jmp 0xa039
movq %r14, %rdi
cmpl $0x20, %eax
jne 0xa05d
movl %r13d, %esi
movl $0x2, %edx
jmp 0xa046
movq %r14, %rdi
movl %r13d, %esi
movl $0x1, %edx
callq 0xa085
movl %eax, %r13d
movb 0x4(%r14), %al
movb %al, -0x430(%rbp)
movb $0x0, -0x42f(%rbp)
jmp 0xa036
movl 0x4(%r14), %edx
movq %r15, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x41b0
movq %r15, %rdi
callq 0x40a0
movq %r14, %rdi
movl %r13d, %esi
movl %eax, %edx
callq 0xa085
movl %eax, %r13d
movq 0x28(%r14), %r14
testq %r14, %r14
jne 0x9fcf
jmp 0xa064
callq 0x48ba
jmp 0xa04e
movq 0xd04d(%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 0xa161
// File: /workspace/github_c_makefile_star2_O1/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 0xa14e
movl %esi, -0x2c(%rbp)
movq %rdi, -0x38(%rbp)
movl 0x10(%rdi), %r13d
movl %esi, %r14d
subl %r13d, %r14d
addl %ebx, %r13d
movq (%r12), %r15
movq 0xcff4(%rip), %rax      # 0x170b8
testq %rax, %rax
je 0xa0e1
cmpq %r15, 0x8(%rax)
jne 0xa0db
movl 0x4(%rax), %ecx
movl (%rax), %edx
addl %ecx, %edx
cmpl %r14d, %edx
je 0xa146
movq 0x10(%rax), %rax
jmp 0xa0c4
movq 0xcfd8(%rip), %rax      # 0x170c0
testq %rax, %rax
je 0xa108
movq 0x10(%rax), %rcx
movq %rcx, 0xcfc8(%rip)      # 0x170c0
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
jmp 0xa119
movl $0x18, %edi
callq 0x4afa
movq -0x38(%rbp), %rdi
movl -0x2c(%rbp), %esi
movl %r14d, (%rax)
movl %r13d, 0x4(%rax)
movq %r15, 0x8(%rax)
movq 0xcf8d(%rip), %rcx      # 0x170b8
movq %rcx, 0x10(%rax)
movq %rax, 0xcf82(%rip)      # 0x170b8
movq 0x8(%r12), %r12
testq %r12, %r12
jne 0xa0ac
jmp 0xa14e
addl %r13d, %ecx
movl %ecx, 0x4(%rax)
jmp 0xa136
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_O1/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 0xa21e
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rsi
callq 0xa161
movq 0xcf36(%rip), %rax      # 0x170c0
movq %rax, 0x10(%r14)
movq %r14, 0xcf2b(%rip)      # 0x170c0
leaq 0x9d14(%rip), %rax      # 0x13eb0
cmpl $0x0, (%rax)
je 0xa1ba
leaq 0x5568(%rip), %rdi      # 0xf710
movl $0x6, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x41d0
cmpl $0x0, (%r14)
jle 0xa1d8
xorl %r15d, %r15d
movl $0x20, %edi
movq %rbx, %rsi
callq 0x4120
incl %r15d
cmpl (%r14), %r15d
jl 0xa1c3
cmpl $0x0, 0x4(%r14)
jle 0xa1f8
xorl %r15d, %r15d
movl $0x2d, %edi
movq %rbx, %rsi
callq 0x4120
incl %r15d
cmpl 0x4(%r14), %r15d
jl 0xa1e2
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xa21f
movq 0x10(%rax), %rdx
movl 0x8(%rax), %ecx
movq (%rax), %r8
leaq 0x5505(%rip), %rsi      # 0xf717
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4150
jmp 0xa238
retq
leaq 0x54fe(%rip), %rdi      # 0xf724
movl $0xc, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x41d0
movl $0xa, %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4120
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x8c26(%rip), %rax      # 0x12e94
cmpl $0x1, (%rax)
jg 0xa283
leaq 0xc212(%rip), %rax      # 0x1648c
cmpl $0x1, (%rax)
jg 0xa33b
leaq 0x7e86(%rip), %rax      # 0x12110
movq (%rax), %r14
leaq 0xf88(%rip), %rsi       # 0xb21c
movq %r14, %rdi
callq 0x4140
testl %eax, %eax
je 0xa33b
movq 0xce1d(%rip), %rbx      # 0x170c8
testq %rbx, %rbx
je 0xa2c6
cmpl %r13d, 0x8(%rbx)
jne 0xa2c0
cmpl %r12d, 0xc(%rbx)
je 0xa34a
movq 0x18(%rbx), %rbx
jmp 0xa2ab
movl $0x20, %edi
callq 0x4afa
movq %rax, %rbx
movl %r13d, 0x8(%rax)
movl %r12d, 0xc(%rax)
movq %r15, (%rax)
movq 0xcde3(%rip), %rax      # 0x170c8
movq %rax, 0x18(%rbx)
movq %rbx, 0xcdd8(%rip)      # 0x170c8
movl $0x18, %edi
callq 0x4afa
movq %rax, %r14
leaq 0x7e0c(%rip), %r15      # 0x12110
movq (%r15), %rdi
callq 0x40a0
leal 0x1(%rax), %edi
callq 0x4afa
movq %rax, (%r14)
movq (%r15), %rsi
movq %rax, %rdi
callq 0x4070
leaq 0x8b67(%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 0xa2f0
leaq 0x8b36(%rip), %rax      # 0x12e90
movl (%rax), %r12d
cmpl %r12d, 0x8(%r15)
jne 0xa372
movq (%r15), %rdi
movq %r14, %rsi
callq 0x4140
testl %eax, %eax
je 0xa33b
movq 0x10(%r15), %r15
testq %r15, %r15
jne 0xa35d
jmp 0xa2f0
// File: /workspace/github_c_makefile_star2_O1/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 0xa39e
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0xa398
movq 0xcd19(%rip), %rdi      # 0x170d0
testq %rdi, %rdi
je 0xa3c8
movq (%rbx), %rsi
callq 0x4140
testl %eax, %eax
je 0xa3d0
movq %rbx, %rdi
callq 0x4981
movq 0x7c21(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
movl 0x8(%rbx), %edx
leaq 0x5386(%rip), %rsi      # 0xf76a
xorl %eax, %eax
callq 0x4150
movq (%rbx), %rax
movq %rax, 0xccdb(%rip)      # 0x170d0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4f60
cmpl $0x1, %ecx
je 0x4f55
testl %ecx, %ecx
jne 0x506f
movq 0x8(%rax), %rdi
movl 0x10(%rax), %esi
callq 0x5f30
jmp 0x4f98
movq 0x28(%rax), %rdi
callq 0x60f7
jmp 0x4f98
movq 0x28(%rax), %rdi
callq 0x60f7
testq %rax, %rax
je 0x4ff2
movq %rax, %rdi
movl $0x1, %esi
callq 0x508e
movl %eax, %ebx
leaq 0x5d60(%rip), %rdi      # 0xace8
movl %eax, %esi
xorl %eax, %eax
callq 0x2110
movl %ebx, %edi
callq 0x61ac
movq %rax, %rbx
testq %rbx, %rbx
je 0x4fff
cmpl $0x0, (%rbx)
jne 0x500d
leaq 0x5d96(%rip), %rsi      # 0xad42
movq %rbx, %rdi
xorl %eax, %eax
callq 0x67a7
testq %rax, %rax
je 0x5031
movq %rax, %rdi
callq 0x5130
leaq 0x5dbd(%rip), %rsi      # 0xad87
movq %rbx, %rdi
xorl %eax, %eax
callq 0x67a7
testq %rax, %rax
je 0x5050
cmpl $0x3, (%rax)
jne 0x4ff6
cmpq $0x0, 0x8(%rax)
jne 0x4ff6
movq %rax, %rdi
callq 0x5130
movq %rbx, %rax
popq %rbx
retq
xorl %ebx, %ebx
jmp 0x4f9b
leaq 0x6333(%rip), %rdi      # 0xb330
jmp 0x5006
leaq 0x62fb(%rip), %rdi      # 0xb301
callq 0x2090
jmp 0x5027
leaq 0x4(%rbx), %rsi
leaq 0x5d14(%rip), %rdi      # 0xad2c
xorl %eax, %eax
callq 0x2110
movq %rbx, %rdi
callq 0x5d92
movl $0x1, %edi
callq 0x22b0
leaq 0x5d13(%rip), %rdi      # 0xad4b
leaq 0x5844(%rip), %rsi      # 0xa883
leaq 0x5d13(%rip), %rcx      # 0xad59
movl $0x3b, %edx
callq 0x2150
leaq 0x5cf4(%rip), %rdi      # 0xad4b
leaq 0x5825(%rip), %rsi      # 0xa883
leaq 0x5cf4(%rip), %rcx      # 0xad59
movl $0x40, %edx
callq 0x2150
leaq 0x67d0(%rip), %rdi      # 0xb846
leaq 0x5806(%rip), %rsi      # 0xa883
leaq 0x5c83(%rip), %rcx      # 0xad07
movl $0x6e, %edx
callq 0x2150
// File: /workspace/github_c_makefile_star2_O1/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 0x37a8
leaq 0x10f6(%rip), %rsi      # 0x4894
movl $0x2, %edi
callq 0x1324
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x24e8
movq 0x8(%rbx), %rdi
callq 0x1478
testl %eax, %eax
je 0x37d7
movq 0x8(%rbx), %rdx
leaq 0x10f0(%rip), %rsi      # 0x48bd
movl $0x1, %edi
callq 0x136c
movq 0x10(%rbx), %rdi
callq 0x1478
testl %eax, %eax
je 0x37f9
movq 0x10(%rbx), %rdx
leaq 0x10ce(%rip), %rsi      # 0x48bd
movl $0x1, %edi
callq 0x136c
movq 0x8(%rbx), %rdi
leaq 0x20(%rsp), %rsi
movl $0x20, %edx
callq 0x3708
movq 0x10(%rbx), %rdi
movq %rsp, %rsi
movl $0x20, %edx
callq 0x3708
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1902
movl %eax, %r12d
movq (%rbx,%r12,8), %r15
testq %r15, %r15
je 0x176f
movq (%r15), %rdi
movq %r14, %rsi
callq 0x18e0
testl %eax, %eax
je 0x17b9
movq %r15, %r13
movq 0x10(%r15), %r15
testq %r15, %r15
je 0x1772
movq (%r15), %rdi
movq %r14, %rsi
callq 0x18e0
testl %eax, %eax
jne 0x1752
jmp 0x17bc
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 0x17d5
movq %r15, 0x10(%r13)
jmp 0x17d9
xorl %r13d, %r13d
incq 0x8(%r15)
testq %r13, %r13
je 0x17d9
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_O1/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 0x18c8
movq 0x8(%rbx), %rdi
leaq 0x97d(%rip), %rsi       # 0x2181
callq 0x18e0
testl %eax, %eax
je 0x1839
movq 0x8(%rbx), %rdi
leaq 0x96d(%rip), %rsi       # 0x2185
callq 0x18e0
testl %eax, %eax
je 0x1839
movq 0x8(%rbx), %rdi
leaq 0x958(%rip), %rsi       # 0x2184
callq 0x18e0
testl %eax, %eax
jne 0x18c8
leaq 0x96a(%rip), %rdi       # 0x21aa
callq 0x1060
leaq 0x984(%rip), %rdi       # 0x21d0
callq 0x1060
leaq 0x9ab(%rip), %rdi       # 0x2203
callq 0x1060
leaq 0x9ae(%rip), %rdi       # 0x2212
callq 0x1060
leaq 0x9b2(%rip), %rdi       # 0x2222
callq 0x1060
leaq 0x9cc(%rip), %rdi       # 0x2248
callq 0x1060
leaq 0x9d2(%rip), %rdi       # 0x225a
callq 0x1060
leaq 0xa7a(%rip), %rdi       # 0x230e
callq 0x1060
leaq 0xa80(%rip), %rdi       # 0x2320
callq 0x1060
leaq 0xac4(%rip), %rdi       # 0x2370
callq 0x1060
leaq 0xac8(%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 0x14d3
movl (%r14), %eax
jmp 0x18bf
nop
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x1140
xorl %ebp, %ebp
testl %eax, %eax
je 0x12b9
movslq %ebp, %rax
movb $0x0, (%rbx,%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %ebp, %ebp
movabsq $0x100000600, %r15      # imm = 0x100000600
movq %r14, %rdi
callq 0x1160
cmpl $0xd, %eax
je 0x12e8
cmpl $0x20, %eax
ja 0x12f6
movl %eax, %ecx
btq %rcx, %r15
jae 0x12f6
testl %ebp, %ebp
jne 0x1303
cmpl $0xa, %eax
je 0x1317
movq %r14, %rdi
callq 0x1140
testl %eax, %eax
je 0x12c5
jmp 0x12a7
movl %ebp, %ecx
movb %al, (%rbx,%rcx)
cmpl $0x3a, %ebp
adcl $0x0, %ebp
jmp 0x12e8
cmpl $0xa, %eax
jne 0x12a7
movl $0xa, %edi
movq %r14, %rsi
callq 0x1040
jmp 0x12a7
movb $0x0, 0x4(%rbx)
movl $0x3e732f3c, (%rbx)     # imm = 0x3E732F3C
jmp 0x12ae
// File: /workspace/github_c_makefile_star2_O1/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
testq %rax, %rax
je 0x1374
movl $0x1, %ecx
xorl %edx, %edx
movq %rcx, %rsi
shlq $0x8, %rsi
addq %rcx, %rsi
movsbq (%rbx,%rdx), %rcx
addq %rsi, %rcx
incq %rdx
cmpq %rdx, %rax
jne 0x1338
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 0x1379
movl $0x1, %ecx
movl %ecx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1060
testq %rax, %rax
je 0x13da
movl $0x1, %r14d
xorl %ecx, %ecx
movq %r14, %rdx
shlq $0x8, %rdx
addq %r14, %rdx
movsbq (%rbx,%rcx), %r14
addq %rdx, %r14
incq %rcx
cmpq %rcx, %rax
jne 0x139d
movq %r14, %rax
shrq $0x8, %rax
movabsq $0x44b82fa09b5a53, %rcx # imm = 0x44B82FA09B5A53
mulq %rcx
shrq $0xb, %rdx
imull $0x1dcd6500, %edx, %eax # imm = 0x1DCD6500
subl %eax, %r14d
jmp 0x13e0
movl $0x1, %r14d
movq 0x3db1(%rip), %r15      # 0x5198
movl %r14d, %eax
movl (%r15,%rax,4), %ebp
cmpl $-0x1, %ebp
je 0x142c
movq 0x3d96(%rip), %r12      # 0x5190
xorl %r13d, %r13d
movslq %ebp, %rax
shlq $0x4, %rax
movq 0x8(%r12,%rax), %rsi
movq %rbx, %rdi
callq 0x1110
testl %eax, %eax
je 0x1431
incl %r14d
cmpl $0x1dcd6500, %r14d      # imm = 0x1DCD6500
cmovel %r13d, %r14d
movl (%r15,%r14,4), %ebp
cmpl $-0x1, %ebp
jne 0x13fd
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x1470
movq %rsp, %rdi
callq 0x137d
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x3c, %edi
cmovbl %eax, %edi
movl $0x1, %esi
callq 0x1080
movq 0x3cf3(%rip), %rcx      # 0x5190
movq 0x3cfc(%rip), %rdx      # 0x51a0
shlq $0x4, %rdx
movq %rax, 0x8(%rcx,%rdx)
movq 0x3cdc(%rip), %rax      # 0x5190
movq 0x8(%rax,%rdx), %rdi
movq %rbx, %rsi
callq 0x1090
movq 0x3cc8(%rip), %rdi      # 0x5190
movq 0x3cd1(%rip), %rax      # 0x51a0
shlq $0x4, %rax
movq $0x0, (%rdi,%rax)
movq 0x3cbe(%rip), %rax      # 0x51a0
leaq 0x1(%rax), %rcx
movq %rcx, 0x3cb3(%rip)      # 0x51a0
addq $0x3, %rax
movq 0x3bf0(%rip), %rsi      # 0x50e8
cmpq %rsi, %rax
jl 0x151b
addq $0x2710, %rsi           # imm = 0x2710
movq %rsi, 0x3bdd(%rip)      # 0x50e8
shlq $0x4, %rsi
callq 0x1170
movq %rax, 0x3c75(%rip)      # 0x5190
movq %rbx, %rdi
callq 0x1060
testq %rax, %rax
je 0x156b
movl $0x1, %ecx
xorl %edx, %edx
movq %rcx, %rsi
shlq $0x8, %rsi
addq %rcx, %rsi
movsbq (%rbx,%rdx), %rcx
addq %rsi, %rcx
incq %rdx
cmpq %rdx, %rax
jne 0x152f
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 0x1570
movl $0x1, %ecx
movq 0x3c21(%rip), %rdx      # 0x5198
movl %ecx, %esi
cmpl $-0x1, (%rdx,%rsi,4)
je 0x1594
xorl %eax, %eax
movl %ecx, %esi
incl %esi
cmpl $0x1dcd6500, %esi       # imm = 0x1DCD6500
cmovel %eax, %esi
cmpl $-0x1, (%rdx,%rsi,4)
jne 0x1583
movl 0x3c06(%rip), %eax      # 0x51a0
decl %eax
movl %eax, (%rdx,%rsi,4)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
pushq %rax
movq 0x3bdb(%rip), %rdi      # 0x5190
addq $0x10, %rdi
movq 0x3be0(%rip), %rsi      # 0x51a0
decq %rsi
leaq -0x29(%rip), %rcx       # 0x15a1
movl $0x10, %edx
callq 0x1180
movq 0x3bbd(%rip), %rdi      # 0x5198
movl $0x77359400, %edx       # imm = 0x77359400
movl $0xff, %esi
callq 0x1070
movq 0x3baf(%rip), %rsi      # 0x51a0
testq %rsi, %rsi
jle 0x16cb
xorl %r14d, %r14d
movabsq $0x44b82fa09b5a53, %r15 # imm = 0x44B82FA09B5A53
xorl %r12d, %r12d
movq 0x3b7f(%rip), %rax      # 0x5190
movq %r12, %rcx
shlq $0x4, %rcx
movslq 0x3abd(%rip), %rdx      # 0x50dc
cmpq %rdx, (%rax,%rcx)
jge 0x163f
decq %rsi
movq %rsi, 0x3b71(%rip)      # 0x51a0
shlq $0x4, %rsi
movq 0x8(%rax,%rsi), %rdi
callq 0x10d0
jmp 0x16b8
addq %rcx, %rax
movq 0x8(%rax), %rbx
movq %rbx, %rdi
callq 0x1060
testq %rax, %rax
je 0x168c
movl $0x1, %ecx
xorl %edx, %edx
movq %rcx, %rsi
shlq $0x8, %rsi
addq %rcx, %rsi
movsbq (%rbx,%rdx), %rcx
addq %rsi, %rcx
incq %rdx
cmpq %rdx, %rax
jne 0x165a
movq %rcx, %rax
shrq $0x8, %rax
mulq %r15
shrq $0xb, %rdx
imull $0x1dcd6500, %edx, %eax # imm = 0x1DCD6500
subl %eax, %ecx
jmp 0x1691
movl $0x1, %ecx
movq 0x3b00(%rip), %rax      # 0x5198
movl %ecx, %edx
cmpl $-0x1, (%rax,%rdx,4)
je 0x16b4
movl %ecx, %edx
incl %edx
cmpl $0x1dcd6500, %edx       # imm = 0x1DCD6500
cmovel %r14d, %edx
cmpl $-0x1, (%rax,%rdx,4)
jne 0x16a2
movl %r12d, (%rax,%rdx,4)
incq %r12
movq 0x3ade(%rip), %rsi      # 0x51a0
cmpq %r12, %rsi
jg 0x160a
movq 0x3abe(%rip), %rdi      # 0x5190
shlq $0x4, %rsi
callq 0x1170
movq %rax, 0x3aae(%rip)      # 0x5190
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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, 0x3a9f(%rip)      # 0x51a0
jle 0x175c
xorl %r14d, %r14d
movl $0x8, %r15d
xorl %ebx, %ebx
movq 0x3a7b(%rip), %rax      # 0x5190
movq -0x8(%rax,%r15), %rcx
movslq 0x39bf(%rip), %rdx      # 0x50e0
cmpq %rdx, %rcx
jle 0x1741
movslq %ebx, %rbx
movq %rbx, %rdx
shlq $0x4, %rdx
movq %rcx, (%rax,%rdx)
movq (%rax,%r15), %rcx
movq %rcx, 0x8(%rax,%rdx)
incl %ebx
jmp 0x174a
movq (%rax,%r15), %rdi
callq 0x10d0
incq %r14
addq $0x10, %r15
cmpq %r14, 0x3a48(%rip)      # 0x51a0
jg 0x170e
jmp 0x175e
xorl %ebx, %ebx
movslq %ebx, %r14
movq %r14, 0x3a38(%rip)      # 0x51a0
movq 0x3a29(%rip), %rdi      # 0x5198
movl $0x77359400, %edx       # imm = 0x77359400
movl $0xff, %esi
callq 0x1070
testl %r14d, %r14d
jle 0x182b
movq 0x3a02(%rip), %r14      # 0x5190
movq 0x3a03(%rip), %r15      # 0x5198
movl %ebx, %r12d
xorl %r13d, %r13d
xorl %ebp, %ebp
movq %rbp, %rax
shlq $0x4, %rax
movq 0x8(%r14,%rax), %rbx
movq %rbx, %rdi
callq 0x1060
testq %rax, %rax
je 0x17f9
movl $0x1, %ecx
xorl %edx, %edx
movq %rcx, %rsi
shlq $0x8, %rsi
addq %rcx, %rsi
movsbq (%rbx,%rdx), %rcx
addq %rsi, %rcx
incq %rdx
cmpq %rdx, %rax
jne 0x17bd
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 0x17fe
movl $0x1, %ecx
movl %ecx, %eax
cmpl $-0x1, (%r15,%rax,4)
je 0x181b
movl %ecx, %eax
incl %eax
cmpl $0x1dcd6500, %eax       # imm = 0x1DCD6500
cmovel %r13d, %eax
cmpl $-0x1, (%r15,%rax,4)
jne 0x1809
movl %ebp, (%r15,%rax,4)
incq %rbp
cmpq %r12, %rbp
jne 0x179d
movq 0x379e(%rip), %rax      # 0x4fd0
movq (%rax), %rdi
callq 0x10b0
incl 0x38a0(%rip)            # 0x50e0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1e1a
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 0x1e11
incq %r15
decq %r12
cmpq $0x1, %r12
jne 0x1df3
jmp 0x1e1a
cmpl $0x2, %r12d
je 0x1e25
movl %r15d, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1299(%rip), %rdi      # 0x30c5
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1030
movl $0x1, %edi
callq 0x10e0
// File: /workspace/github_c_makefile_star2_O1/motet-a[P]libforks/tests/socket_creation_fork_error.c
// Function: main
int main() {
  struct rlimit l;
  l.rlim_cur = l.rlim_max = 10;
  check(setrlimit(RLIMIT_NOFILE, &l) == 0);

  libforks_ServerConn conn;
  check(libforks_start(&conn) == libforks_OK);

  while (true) {
    libforks_Result r = libforks_fork(
      conn,
      NULL, // pid_ptr
      NULL, // socket_fd_ptr
      NULL, // exit_fd_ptr
      child_main
    );
    if (r != libforks_OK) {
      check(r == libforks_SOCKET_CREATION_ERROR);
      check(errno == EMFILE);
      break;
    }
    check(r == libforks_OK);
  }

  check(libforks_stop(conn) == libforks_OK);

  return 0;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movl $0xa, %eax
leaq 0x10(%rsp), %rsi
movq %rax, 0x8(%rsi)
movq %rax, (%rsi)
movl $0x7, %edi
callq 0x1170
testl %eax, %eax
jne 0x13b2
leaq 0x8(%rsp), %rdi
callq 0x179b
testl %eax, %eax
jne 0x13c3
leaq 0xbc(%rip), %rbx        # 0x1421
movq 0x8(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
movq %rbx, %r8
callq 0x21ef
testl %eax, %eax
je 0x1365
cmpl $-0x3, %eax
jne 0x13a1
callq 0x1050
cmpl $0x18, (%rax)
jne 0x13d4
movq 0x8(%rsp), %rdi
callq 0x23aa
testl %eax, %eax
jne 0x13e5
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
retq
leaq 0x1cc6(%rip), %rdi      # 0x306e
movl $0x1e, %esi
callq 0x13f6
leaq 0x1c4b(%rip), %rdi      # 0x3004
movl $0x10, %esi
callq 0x13f6
leaq 0x1c7f(%rip), %rdi      # 0x3049
movl $0x13, %esi
callq 0x13f6
leaq 0x1cb7(%rip), %rdi      # 0x3092
movl $0x1f, %esi
callq 0x13f6
leaq 0x1cb6(%rip), %rdi      # 0x30a2
movl $0x25, %esi
callq 0x13f6
// File: /workspace/github_c_makefile_star2_O1/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 0x122c
leaq 0xab3(%rip), %rdi       # 0x2146
callq 0x1050
movq 0x2a19(%rip), %rax      # 0x40b8
movl (%rax), %ecx
cmpl $0x1, %ecx
je 0x16b8
cmpl $0x2, %ecx
jne 0x177a
leaq 0xa47(%rip), %rdi       # 0x20fd
jmp 0x16bf
leaq 0xa25(%rip), %rdi       # 0x20e4
movl 0x4(%rax), %esi
movl 0x8(%rax), %edx
xorl %eax, %eax
callq 0x1080
movq 0x29e5(%rip), %rax      # 0x40b8
cmpl $0x0, 0xc(%rax)
je 0x1786
movl $0x20, %ebp
leaq 0xa34(%rip), %r14       # 0x211d
leaq 0xa53(%rip), %r12       # 0x2143
leaq 0xa6d(%rip), %r13       # 0x2164
xorl %ebx, %ebx
xorl %r15d, %r15d
leaq 0xa15(%rip), %rdi       # 0x2118
xorl %eax, %eax
callq 0x1080
movq 0x29a7(%rip), %rax      # 0x40b8
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 0x2982(%rip), %rax      # 0x40b8
movq 0x18(%rax), %rax
movl (%rax,%rbx), %eax
decl %eax
movq %r12, %rdi
cmpl $0x5, %eax
ja 0x1751
movl %eax, %eax
movslq (%r13,%rax,4), %rdi
addq %r13, %rdi
xorl %eax, %eax
callq 0x1080
movl $0xa, %edi
callq 0x1030
incq %r15
movq 0x294c(%rip), %rax      # 0x40b8
movl 0xc(%rax), %eax
addq $0x60, %rbx
cmpq %rax, %r15
jb 0x16fc
jmp 0x1786
leaq 0x9d6(%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_O1/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 0x79ff(%rip), %r13      # 0xa2f4
leaq 0x79f4(%rip), %rbx      # 0xa2f0
xorl %ebp, %ebp
movl %ebp, %edi
callq 0x2b77
movq %rax, %r14
movl %ebp, %edi
callq 0x2b44
testl %eax, %eax
movq %rbx, %r15
cmoveq %r13, %r15
movl %ebp, %edi
callq 0x2b55
testl %eax, %eax
movq %rbx, %r12
cmoveq %r13, %r12
movl %ebp, %edi
callq 0x2b66
testl %eax, %eax
movq %rbx, %r9
cmoveq %r13, %r9
leaq 0x798e(%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 0x28fe
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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, 0xd38f(%rip)      # 0x102c8
je 0x2f58
callq 0x56c8
testl %eax, %eax
je 0x2f4e
movl $0x4, 0xd376(%rip)      # 0x102c4
movl $0x0, 0xd370(%rip)      # 0x102c8
cmpl $-0x2, %r14d
jne 0x2f6b
movl $0x6, %ebx
movl $0x1, %r13d
jmp 0x2f86
movl %r14d, %r13d
movl %r14d, %ebx
cmpl $0x7, %r14d
jb 0x2f86
movl $0x3, 0xd343(%rip)      # 0x102c4
jmp 0x300d
cmpl %ebx, %r13d
ja 0x2fde
incl %ebx
movl %r13d, %edi
callq 0x2b44
testl %eax, %eax
je 0x2fd6
cmpl $-0x2, %r14d
jne 0x2fb8
movl %r13d, %edi
callq 0x2b77
leaq 0x74b5(%rip), %rdi      # 0xa463
movq %rax, %rsi
xorl %eax, %eax
callq 0x8aa8
movl %r13d, %edi
movq %r12, %rsi
movl %ebp, %edx
movq %r15, %rcx
movq 0x8(%rsp), %r8
movq 0x10(%rsp), %r9
callq 0x53fa
testl %eax, %eax
je 0x3023
incl %r13d
cmpl %r13d, %ebx
jne 0x2f8d
cmpl $-0x2, %r14d
jne 0x3003
xorl %ebx, %ebx
xorl %edi, %edi
movq %r12, %rsi
movl %ebp, %edx
movq %r15, %rcx
movq 0x8(%rsp), %r8
movq 0x10(%rsp), %r9
callq 0x53fa
testl %eax, %eax
je 0x3031
movl $0x4, 0xd2b7(%rip)      # 0x102c4
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, 0xd29b(%rip)      # 0x102c8
xorl %ebx, %ebx
jmp 0x3012
movl $0x1, 0xd28d(%rip)      # 0x102c8
jmp 0x3012
// File: /workspace/github_c_makefile_star2_O1/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), %r11d
movdqu (%rdi), %xmm0
movd 0x10(%rdi), %xmm1
pcmpeqb 0x6fa2(%rip), %xmm1     # 0xa390
pcmpeqb 0x6faa(%rip), %xmm0     # 0xa3a0
movl 0x10(%rsp), %r10d
pand %xmm1, %xmm0
pmovmskb %xmm0, %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
je 0x3433
cmpl $0x46464952, (%rdi)     # imm = 0x46464952
jne 0x341b
cmpl $0x45564157, 0x8(%rdi)  # imm = 0x45564157
je 0x3455
cmpl $0x5367674f, (%rdi)     # imm = 0x5367674F
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jne 0x3440
pushq %r11
pushq %r10
callq 0x65ce
jmp 0x343c
pushq %r11
pushq %r10
callq 0x4d9c
addq $0x10, %rsp
testl %eax, %eax
jns 0x3453
movl $0x4, 0xce76(%rip)      # 0x102c4
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
popq %rcx
retq
pushq %r11
pushq %r10
callq 0x487a
jmp 0x343c
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movl 0x38(%rsp), %r14d
movl 0x30(%rsp), %ebx
movl 0x28(%rsp), %r11d
movdqu (%rdi), %xmm0
movd 0x10(%rdi), %xmm1
pcmpeqb 0x6f0d(%rip), %xmm1     # 0xa390
pcmpeqb 0x6f15(%rip), %xmm0     # 0xa3a0
movl 0x20(%rsp), %r10d
pand %xmm1, %xmm0
pmovmskb %xmm0, %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
je 0x34cb
cmpl $0x46464952, (%rdi)     # imm = 0x46464952
jne 0x34b0
cmpl $0x45564157, 0x8(%rdi)  # imm = 0x45564157
je 0x34f6
cmpl $0x5367674f, (%rdi)     # imm = 0x5367674F
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jne 0x34db
pushq %r14
pushq %rbx
pushq %r11
pushq %r10
callq 0x65fa
jmp 0x34d7
pushq %r14
pushq %rbx
pushq %r11
pushq %r10
callq 0x4dce
addq $0x20, %rsp
testl %eax, %eax
jns 0x34ee
movl $0x4, 0xcddb(%rip)      # 0x102c4
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq %r14
pushq %rbx
pushq %r11
pushq %r10
callq 0x48ac
jmp 0x34d7
// File: /workspace/github_c_makefile_star2_O1/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 0x6e7a(%rip), %xmm1     # 0xa390
pcmpeqb 0x6e82(%rip), %xmm0     # 0xa3a0
movl 0x10(%rsp), %r10d
pand %xmm1, %xmm0
pmovmskb %xmm0, %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
je 0x355b
cmpl $0x46464952, (%rdi)     # imm = 0x46464952
jne 0x3543
cmpl $0x45564157, 0x8(%rdi)  # imm = 0x45564157
je 0x3579
cmpl $0x5367674f, (%rdi)     # imm = 0x5367674F
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jne 0x3564
movl %r10d, (%rsp)
callq 0x6528
jmp 0x3564
movl %r10d, (%rsp)
callq 0x4cf5
testl %eax, %eax
jns 0x3577
movl $0x4, 0xcd52(%rip)      # 0x102c4
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
popq %rcx
retq
movl %r10d, (%rsp)
callq 0x4b1b
jmp 0x3564
// File: /workspace/github_c_makefile_star2_O1/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 0x15f01(%rip), %eax     # 0x19524
leal 0x1(%rax), %ecx
movl %ecx, 0x15ef8(%rip)     # 0x19524
testl %eax, %eax
jg 0x3635
callq 0x2d0b
movq 0xcca4(%rip), %rax      # 0x102e0
leaq 0xcc95(%rip), %rcx      # 0x102d8
cmpq %rcx, %rax
je 0x3659
movl 0x7c(%rbx), %edx
cmpl 0x7c(%rax), %edx
jle 0x3659
movq 0x8(%rax), %rax
cmpq %rcx, %rax
jne 0x364b
movq %rax, 0x8(%rbx)
movq (%rax), %rcx
movq %rcx, (%rbx)
movq (%rax), %rcx
movq %rbx, 0x8(%rcx)
movq %rbx, (%rax)
movl 0x15eb1(%rip), %eax     # 0x19524
leal -0x1(%rax), %ecx
movl %ecx, 0x15ea8(%rip)     # 0x19524
cmpl $0x1, %eax
jle 0x3683
popq %rbx
retq
popq %rbx
jmp 0x2d24