LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/simh[P]simtools/converters/m8376/m8376.c
// Function: main
int main (int argc, char *argv[])
{
FILE *fi[8], *outf;
char fname[256];
int c, i, j;
unsigned int wd[1024];

for (i = 0; i < 8; i++) {
	sprintf (fname, "C:\\temp\\m8376\\m8376e%03d.bin", fnum[i]);
	fi[i] = fopen (fname, "rb");
	if (fi[i] == NULL) {
	    printf ("Can't open file %s\n", fname);
	    return 0;
	    }
	}

for (i = 0; i < 1024; i++) {
	wd[i] = 0;
	for (j = 7; j >=0; j--) {
	    c = fgetc (fi[j]);
	    if (c == EOF) {
		printf ("Premature end of file on file %d\n", i);
		return 0;
		}
	    wd[i] = (wd[i] << 4) | (c & 0xF);
	    }
	}

for (i = 0; i < 8; i++) fclose (fi[i]);
outf = fopen ("c:\\prom.bin", "wb");
if (outf == NULL) {
	printf ("Can't open output file\n");
	return 0;
	}
fwrite (wd, 1024, sizeof (int), outf);
fclose (outf);
return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1140, %rsp           # imm = 0x1140
leaq 0xecd(%rip), %r12       # 0x2080
leaq 0xe4a(%rip), %rbx       # 0x2004
leaq 0x40(%rsp), %r14
leaq 0xe5b(%rip), %r15       # 0x2021
xorl %r13d, %r13d
movl (%r13,%r12), %edx
movq %r14, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1080
movq %r14, %rdi
movq %r15, %rsi
callq 0x1070
movq %rax, (%rsp,%r13,2)
testq %rax, %rax
je 0x129d
addq $0x4, %r13
cmpq $0x20, %r13
jne 0x11c9
xorl %ebx, %ebx
movl $0x0, 0x140(%rsp,%rbx,4)
movl $0x7, %r14d
movq (%rsp,%r14,8), %rdi
callq 0x1060
cmpl $-0x1, %eax
je 0x12b2
movl 0x140(%rsp,%rbx,4), %ecx
shll $0x4, %ecx
andl $0xf, %eax
orl %ecx, %eax
movl %eax, 0x140(%rsp,%rbx,4)
addq $-0x1, %r14
jb 0x1210
incq %rbx
cmpq $0x400, %rbx            # imm = 0x400
jne 0x11ff
xorl %ebx, %ebx
movq (%rsp,%rbx,8), %rdi
callq 0x1040
incq %rbx
cmpq $0x8, %rbx
jne 0x124c
leaq 0xdf5(%rip), %rdi       # 0x205a
leaq 0xdfa(%rip), %rsi       # 0x2066
callq 0x1070
testq %rax, %rax
je 0x12d5
movq %rax, %rbx
leaq 0x140(%rsp), %rdi
movl $0x400, %esi            # imm = 0x400
movl $0x4, %edx
movq %rax, %rcx
callq 0x1090
movq %rbx, %rdi
callq 0x1040
jmp 0x12c2
leaq 0xd80(%rip), %rdi       # 0x2024
leaq 0x40(%rsp), %rsi
xorl %eax, %eax
callq 0x1050
jmp 0x12c2
leaq 0xd7f(%rip), %rdi       # 0x2038
movl %ebx, %esi
xorl %eax, %eax
callq 0x1050
xorl %eax, %eax
addq $0x1140, %rsp           # imm = 0x1140
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0xd8d(%rip), %rdi       # 0x2069
callq 0x1030
jmp 0x12c2
// File: /workspace/github_c_makefile_star2_O1/mflatt[P]gc-demo/cgc/cgc.c
// Function: find_roots
static void find_roots(jmp_buf env)
{
  num_roots = 0;

  /* Since a frame was pushed to call find_roots,
     stack variables during original_main() are definitely
     deeper than `stack_now` */
  void **stack_now = (void **)&stack_now;

  /* Scan the stack for pointers */
  while ((void *)stack_now < stack_init) {
    if (looks_like_allocated(*stack_now))
      root_addrs[num_roots++] = (struct node **)stack_now;
    stack_now++;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq 0x2dc0(%rip), %rax      # 0x4078
movl $0x0, (%rax)
movq 0x2da3(%rip), %rcx      # 0x4068
leaq -0x8(%rsp), %rdx
movq %rdx, (%rdx)
cmpq %rcx, %rdx
jae 0x137f
leaq 0x2da3(%rip), %rsi      # 0x4080
movq (%rsi), %rsi
testq %rsi, %rsi
setne %dil
xorl %r11d, %r11d
movabsq $-0x5555555555555555, %r8 # imm = 0xAAAAAAAAAAAAAAAB
movabsq $-0x5555555555555558, %r9 # imm = 0xAAAAAAAAAAAAAAA8
movabsq $0xaaaaaaaaaaaaaab, %r10 # imm = 0xAAAAAAAAAAAAAAB
movl %edi, %ebp
testq %rsi, %rsi
je 0x1357
movq (%rdx), %r14
movl %edi, %ebp
movq %rsi, %r15
movq 0x8(%r15), %r12
cmpq %r14, %r12
seta %r13b
leaq 0xc0000(%r12), %rbx
cmpq %r14, %rbx
setb %bl
orb %r13b, %bl
jne 0x134b
movq %r14, %rbx
subq %r12, %rbx
imulq %r8, %rbx
addq %r9, %rbx
rorq $0x3, %rbx
cmpq %r10, %rbx
jb 0x1357
movq (%r15), %r15
testq %r15, %r15
setne %bpl
jne 0x1317
testb $0x1, %bpl
je 0x1371
movslq %r11d, %rbx
incl %r11d
movl %r11d, (%rax)
leaq 0x2d23(%rip), %r14      # 0x4090
movq %rdx, (%r14,%rbx,8)
addq $0x8, %rdx
movq %rdx, -0x8(%rsp)
cmpq %rcx, %rdx
jb 0x1308
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/FirestonnneTFM[P]tfm_key_parser/src/main_sniffer.cpp
// Function: keys::print()
void keys::print() {
	std::cout << "version = " << version << std::endl;
	std::cout << "login = " << login << std::endl;
	std::cout << "handshake = " << handshake << std::endl;
	std::cout << "hash =";
	for (unsigned i = 0; i < 20; ++i) {
		printf(" %02x", hash[i]);
	}
	std::cout << std::endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x50c8(%rip), %rbx      # 0x9fd0
leaq 0x2428(%rip), %rsi      # 0x7337
movl $0xa, %edx
movq %rbx, %rdi
callq 0x2220
movzwl (%r14), %esi
movq %rbx, %rdi
callq 0x2140
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2150
leaq 0x23e9(%rip), %rsi      # 0x7342
movl $0x8, %r12d
movl $0x8, %edx
movq %rbx, %rdi
callq 0x2220
movl 0x4(%r14), %esi
movq %rbx, %rdi
callq 0x22d0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2150
leaq 0x23a2(%rip), %rsi      # 0x734b
movl $0xc, %edx
movq %rbx, %rdi
callq 0x2220
leaq 0x1c(%r14), %r15
movq %r15, %rdi
callq 0x20e0
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x2220
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2150
leaq 0x235a(%rip), %rsi      # 0x7358
movl $0x6, %edx
movq %rbx, %rdi
callq 0x2220
leaq 0x234d(%rip), %r15      # 0x735f
movzbl (%r14,%r12), %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x2050
incq %r12
cmpq $0x1c, %r12
jne 0x5012
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2150
// File: /workspace/github_c_makefile_star2_O1/FirestonnneTFM[P]tfm_key_parser/src/main_sniffer.cpp
// Function: keys::write_to(_IO_FILE*)
void keys::write_to(FILE *f) {
	fwrite(&version, 2, 1, f);
	fwrite(&login, 4, 1, f);
	fwrite(hash, 1, 20, f);
	fwrite(handshake, 1, 20, f);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x2300
leaq 0x4(%r14), %rdi
movl $0x4, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x2300
leaq 0x8(%r14), %rdi
movl $0x1, %esi
movl $0x14, %edx
movq %rbx, %rcx
callq 0x2300
addq $0x1c, %r14
movl $0x1, %esi
movl $0x14, %edx
movq %r14, %rdi
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2300
// File: /workspace/github_c_makefile_star2_O1/FirestonnneTFM[P]tfm_key_parser/src/main_sniffer.cpp
// Function: executer::get_lex_int()
int32_t executer::get_lex_int() {
	uint32_t index, arg_count;
	*this >> index;
	if (strlen(abc_file::get_multiname(index)->ns_str))
		fatal("class is out of our namespace");
	class_info *c = abc_file::get_class_by_name(index);
	c->do_static_init();
	assert(next() == OP_callproperty);
	*this >> index;
	*this >> arg_count;
	assert(arg_count == 0);
	traits_info *tm = c->get_trait_by_name(abc_file::get_multiname(index));
	method_info *m = abc_file::get_method(tm->vindex);
	executer exec(m);
	assert(exec.step() == OP_getlocal_0);
	assert(exec.step() == OP_pushscope);
	int32_t a = exec.get_push();
	int32_t b = exec.get_push();
	assert(exec.step() == OP_add);
	assert(exec.step() == OP_returnvalue);
	return a + b;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %r14
movq %r14, %rsi
callq 0x3098
movl (%r14), %edi
callq 0x2eb6
movq 0x8(%rax), %rax
cmpb $0x0, (%rax)
jne 0x51d7
movl 0xc(%rsp), %edi
callq 0x2f2a
movq %rax, %r14
movq %rax, %rdi
callq 0x37f4
movq %rbx, %rdi
callq 0x3042
cmpb $0x46, %al
jne 0x51fb
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x3098
leaq 0x24(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3098
cmpl $0x0, (%r15)
jne 0x520d
movl 0xc(%rsp), %edi
callq 0x2eb6
movq %r14, %rdi
movq %rax, %rsi
callq 0x3b10
movl 0xc(%rax), %edi
callq 0x2efa
movq 0x40(%rax), %rsi
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x3034
movq %rbx, %rdi
callq 0x2804
cmpb $-0x30, %al
jne 0x521f
leaq 0x10(%rsp), %rdi
callq 0x2804
cmpb $0x30, %al
jne 0x5231
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x29b2
movl %eax, %ebx
movq %r14, %rdi
callq 0x29b2
movl %eax, %ebp
movq %r14, %rdi
callq 0x2804
cmpb $-0x60, %al
jne 0x5243
leaq 0x10(%rsp), %rdi
callq 0x2804
cmpb $0x48, %al
jne 0x5255
addl %ebx, %ebp
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x18, %edi
callq 0x2100
movl $0x3c, (%rax)
leaq 0x2195(%rip), %rcx      # 0x7383
movq %rcx, 0x8(%rax)
leaq 0x216c(%rip), %rcx      # 0x7365
jmp 0x5277
movl $0x18, %edi
callq 0x2100
movl $0x3f, (%rax)
jmp 0x5265
movl $0x18, %edi
callq 0x2100
movl $0x42, (%rax)
jmp 0x5265
movl $0x18, %edi
callq 0x2100
movl $0x46, (%rax)
jmp 0x5265
movl $0x18, %edi
callq 0x2100
movl $0x47, (%rax)
jmp 0x5265
movl $0x18, %edi
callq 0x2100
movl $0x4a, (%rax)
jmp 0x5265
movl $0x18, %edi
callq 0x2100
movl $0x4b, (%rax)
leaq 0x2117(%rip), %rcx      # 0x7383
movq %rcx, 0x8(%rax)
leaq 0x2121(%rip), %rcx      # 0x7398
movq %rcx, 0x10(%rax)
leaq 0x4b0e(%rip), %rsi      # 0x9d90
movq %rax, %rdi
xorl %edx, %edx
callq 0x22c0
// File: /workspace/github_c_makefile_star2_O1/FirestonnneTFM[P]tfm_key_parser/src/main_sniffer.cpp
// Function: executer::get_lex_bool()
bool executer::get_lex_bool() {
	uint32_t index;
	*this >> index;
	if (strlen(abc_file::get_multiname(index)->ns_str))
		fatal("class is out of our namespace");
	class_info *c = abc_file::get_class_by_name(index);
	c->do_static_init();
	assert(next() == OP_getproperty);
	*this >> index;
	traits_info *trait = c->get_trait_by_name(abc_file::get_multiname(index));
	if (! trait->has_loaded_value)
		fatal("The static trait does not have a loaded value");
	return trait->loaded_value != 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %r14
movq %r14, %rsi
callq 0x3098
movl (%r14), %edi
callq 0x2eb6
movq 0x8(%rax), %rax
cmpb $0x0, (%rax)
jne 0x5310
movl 0xc(%rsp), %edi
callq 0x2f2a
movq %rax, %r14
movq %rax, %rdi
callq 0x37f4
movq %rbx, %rdi
callq 0x3042
cmpb $0x66, %al
jne 0x5334
leaq 0xc(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3098
movl (%r15), %edi
callq 0x2eb6
movq %r14, %rdi
movq %rax, %rsi
callq 0x3b10
cmpb $0x0, 0x10(%rax)
je 0x5358
cmpl $0x0, 0x14(%rax)
setne %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl $0x18, %edi
callq 0x2100
movl $0x53, (%rax)
leaq 0x205c(%rip), %rcx      # 0x7383
movq %rcx, 0x8(%rax)
leaq 0x2033(%rip), %rcx      # 0x7365
jmp 0x537a
movl $0x18, %edi
callq 0x2100
movl $0x56, (%rax)
leaq 0x2038(%rip), %rcx      # 0x7383
movq %rcx, 0x8(%rax)
leaq 0x2042(%rip), %rcx      # 0x7398
jmp 0x537a
movl $0x18, %edi
callq 0x2100
movl $0x5a, (%rax)
leaq 0x2014(%rip), %rcx      # 0x7383
movq %rcx, 0x8(%rax)
leaq 0x202c(%rip), %rcx      # 0x73a6
movq %rcx, 0x10(%rax)
leaq 0x4a0b(%rip), %rsi      # 0x9d90
movq %rax, %rdi
xorl %edx, %edx
callq 0x22c0
nop
// File: /workspace/github_c_makefile_star2_O1/FirestonnneTFM[P]tfm_key_parser/src/main_sniffer.cpp
// Function: executer::get_lex_str()
char *executer::get_lex_str() {
	uint32_t index;
	*this >> index;
	if (strlen(abc_file::get_multiname(index)->ns_str))
		return abc_file::get_str(0);
	class_info *c = abc_file::get_class_by_name(index);
	c->do_static_init();
	assert(next() == OP_getproperty);
	*this >> index;
	traits_info *trait = c->get_trait_by_name(abc_file::get_multiname(index));
	return abc_file::get_str(trait->vindex);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %r14
movq %r14, %rsi
callq 0x3098
movl (%r14), %edi
callq 0x2eb6
movq 0x8(%rax), %rax
xorl %edi, %edi
cmpb $0x0, (%rax)
jne 0x5402
movl 0xc(%rsp), %edi
callq 0x2f2a
movq %rax, %r14
movq %rax, %rdi
callq 0x37f4
movq %rbx, %rdi
callq 0x3042
cmpb $0x66, %al
jne 0x5411
leaq 0xc(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3098
movl (%r15), %edi
callq 0x2eb6
movq %r14, %rdi
movq %rax, %rsi
callq 0x3b10
movl 0xc(%rax), %edi
callq 0x2e6a
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl $0x18, %edi
callq 0x2100
movl $0x65, (%rax)
leaq 0x1f5b(%rip), %rcx      # 0x7383
movq %rcx, 0x8(%rax)
leaq 0x1f65(%rip), %rcx      # 0x7398
movq %rcx, 0x10(%rax)
leaq 0x4952(%rip), %rsi      # 0x9d90
movq %rax, %rdi
xorl %edx, %edx
callq 0x22c0
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/lua/src/lua.c
// Function: main
int main (int argc, char **argv) {
  int status;
  struct Smain s;
  lua_State *L = lua_open();  /* create state */
  if (L == NULL) {
    l_message(argv[0], "cannot create state: not enough memory");
    return EXIT_FAILURE;
  }
  s.argc = argc;
  s.argv = argv;
  status = lua_cpcall(L, &pmain, &s);
  report(L, status);
  lua_close(L);
  return (status || s.status) ? EXIT_FAILURE : EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movl %edi, %ebp
callq 0x110f2
testq %rax, %rax
je 0x498c
movq %rax, %rbx
movq %rsp, %r15
movl %ebp, (%r15)
movq %r14, 0x8(%r15)
leaq 0x49(%rip), %rsi        # 0x49a2
movq %rax, %rdi
movq %r15, %rdx
callq 0x621a
movl %eax, %ebp
movq %rbx, %rdi
movl %eax, %esi
callq 0x4e1c
movq %rbx, %rdi
callq 0xcafb
xorl %eax, %eax
orl 0x10(%r15), %ebp
setne %al
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq (%r14), %rdi
leaq 0x1666e(%rip), %rsi     # 0x1b004
callq 0x45a0
movl $0x1, %eax
jmp 0x4981
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/lua/src/lua.c
// Function: report
static int report (lua_State *L, int status) {
  if (status && !lua_isnil(L, -1)) {
    const char *msg = lua_tostring(L, -1);
    if (msg == NULL) msg = "(error object is not a string)";
    l_message(progname, msg);
    lua_pop(L, 1);
  }
  return status;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
testl %esi, %esi
je 0x4e37
movq %rdi, %r14
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x56b0
testl %eax, %eax
jne 0x4e41
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
callq 0x467f
jmp 0x4e37
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/lua/src/lua.c
// Function: dotty
static void dotty (lua_State *L) {
  int status;
  const char *oldprogname = progname;
  progname = NULL;
  while ((status = loadline(L)) != -1) {
    if (status == 0) status = docall(L, 0, 0);
    report(L, status);
    if (status == 0 && lua_gettop(L) > 0) {  /* any result to print? */
      lua_getglobal(L, "print");
      lua_insert(L, 1);
      if (lua_pcall(L, lua_gettop(L)-1, 0, 0) != 0)
        l_message(progname, lua_pushfstring(L,
                               "error calling " LUA_QL("print") " (%s)",
                               lua_tostring(L, -1)));
    }
  }
  lua_settop(L, 0);  /* clear stack */
  fputs("\n", stdout);
  fflush(stdout);
  progname = oldprogname;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x22475(%rip), %rax     # 0x272d8
movq %rax, 0x10(%rsp)
movq $0x0, 0x22465(%rip) # 0x272d8
leaq 0x163a5(%rip), %r15     # 0x1b21f
leaq 0x8(%rsp), %r12
leaq 0x163bf(%rip), %r13     # 0x1b245
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5462
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5230
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
testl %eax, %eax
je 0x4f6f
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x58ee
movq %rax, %r14
movq %rbx, %rdi
movl $0x1, %esi
callq 0x595f
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
movq %r15, %rcx
callq 0x11078
movl %eax, %r14d
cmpl $0x3, %eax
jne 0x4f62
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %r12, %rdx
callq 0x58ee
movq 0x8(%rsp), %rcx
leaq (%rax,%rcx), %rbp
addq $-0x7, %rbp
movq %rax, %rdi
movq %r13, %rsi
callq 0x4540
cmpq %rbp, %rax
jne 0x4f62
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5462
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5230
testl %eax, %eax
je 0x4fff
movl $0x1, %edx
movq %rbx, %rdi
leaq 0x170aa(%rip), %rsi     # 0x1bfe8
callq 0x5ac0
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5597
movq %rbx, %rdi
movl $0x3, %esi
callq 0x644f
jmp 0x4eab
movq %rbx, %rdi
movl $0x1, %esi
callq 0x54a6
testl %r14d, %r14d
je 0x4f7f
cmpl $-0x1, %r14d
jne 0x4f8e
jmp 0x500a
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x50a1
movl %eax, %r14d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x4e1c
testl %r14d, %r14d
jne 0x4e86
movq %rbx, %rdi
callq 0x5455
testl %eax, %eax
jle 0x4e86
movq %rbx, %rdi
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
leaq 0x1623d(%rip), %rdx     # 0x1b1fe
callq 0x5d4e
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5597
movq %rbx, %rdi
callq 0x5455
leal -0x1(%rax), %esi
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x6198
testl %eax, %eax
je 0x4e86
movq %rbx, %rdi
callq 0x46b3
jmp 0x4e86
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
jmp 0x4f6f
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5462
movq 0x21fb5(%rip), %rbx     # 0x26fd0
movq (%rbx), %rsi
leaq 0x16fc3(%rip), %rdi     # 0x1bfe8
callq 0x41a0
movq (%rbx), %rdi
callq 0x4350
movq 0x10(%rsp), %rax
movq %rax, 0x2229a(%rip)     # 0x272d8
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/lua/src/lua.c
// Function: docall
static int docall (lua_State *L, int narg, int clear) {
  int status;
  int base = lua_gettop(L) - narg;  /* function index */
  lua_pushcfunction(L, traceback);  /* push traceback function */
  lua_insert(L, base);  /* put it under chunk and args */
  signal(SIGINT, laction);
  status = lua_pcall(L, narg, (clear ? 0 : LUA_MULTRET), base);
  signal(SIGINT, SIG_DFL);
  lua_remove(L, base);  /* remove traceback function */
  /* force a complete garbage collection in case of errors */
  if (status != 0) lua_gc(L, LUA_GCCOLLECT, 0);
  return status;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r15d
movl %esi, %r14d
movq %rdi, %rbx
callq 0x5455
movl %eax, %ebp
subl %r14d, %ebp
leaq 0x78(%rip), %rsi        # 0x513b
xorl %r12d, %r12d
movq %rbx, %rdi
xorl %edx, %edx
callq 0x5c45
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5597
leaq 0x108(%rip), %rsi       # 0x51e9
movl $0x2, %edi
callq 0x42a0
cmpl $0x1, %r15d
sbbl %r12d, %r12d
movq %rbx, %rdi
movl %r14d, %esi
movl %r12d, %edx
movl %ebp, %ecx
callq 0x6198
movl %eax, %r14d
movl $0x2, %edi
xorl %esi, %esi
callq 0x42a0
movq %rbx, %rdi
movl %ebp, %esi
callq 0x54a6
testl %r14d, %r14d
je 0x512f
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x6345
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/lua/src/lua.c
// Function: traceback
static int traceback (lua_State *L) {
  if (!lua_isstring(L, 1))  /* 'message' not a string? */
    return 1;  /* keep it intact */
  lua_getfield(L, LUA_GLOBALSINDEX, "debug");
  if (!lua_istable(L, -1)) {
    lua_pop(L, 1);
    return 1;
  }
  lua_getfield(L, -1, "traceback");
  if (!lua_isfunction(L, -1)) {
    lua_pop(L, 2);
    return 1;
  }
  lua_pushvalue(L, 1);  /* pass error message */
  lua_pushinteger(L, 2);  /* skip this function and traceback */
  lua_call(L, 2, 1);  /* call debug.traceback */
  return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x573a
testl %eax, %eax
je 0x51e2
leaq 0x15ee6(%rip), %rdx     # 0x1b03e
movq %rbx, %rdi
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
callq 0x5d4e
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x56b0
cmpl $0x5, %eax
jne 0x51cb
leaq 0x15ec6(%rip), %rdx     # 0x1b044
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x5d4e
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x56b0
cmpl $0x6, %eax
jne 0x51d5
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5690
movl $0x2, %esi
movq %rbx, %rdi
callq 0x5aa6
movq %rbx, %rdi
movl $0x2, %esi
movl $0x1, %edx
callq 0x6160
jmp 0x51e2
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
jmp 0x51dd
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x5462
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/zhou-yuxin[P]redis-aof-no-cow/deps/lua/src/lua.c
// Function: pushline
static int pushline (lua_State *L, int firstline) {
  char buffer[LUA_MAXINPUT];
  char *b = buffer;
  size_t l;
  const char *prmt = get_prompt(L, firstline);
  if (lua_readline(L, b, prmt) == 0)
    return 0;  /* no input */
  l = strlen(b);
  if (l > 0 && b[l-1] == '\n')  /* line ends with newline? */
    b[l-1] = '\0';  /* remove it */
  if (firstline && b[0] == '=')  /* first line starts with `=' ? */
    lua_pushfstring(L, "return %s", b+1);  /* change it to `return' */
  else
    lua_pushstring(L, b);
  lua_freeline(L, b);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movl %esi, %ebp
movq %rdi, %rbx
testl %esi, %esi
leaq 0x15feb(%rip), %rax     # 0x1b238
leaq 0x15fdc(%rip), %rdx     # 0x1b230
cmoveq %rax, %rdx
leaq 0x15fe2(%rip), %rax     # 0x1b241
leaq 0x15fdc(%rip), %r15     # 0x1b242
cmoveq %rax, %r15
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
callq 0x5d4e
xorl %r14d, %r14d
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x58ee
testq %rax, %rax
cmovneq %rax, %r15
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5462
movq 0x21d2f(%rip), %r12     # 0x26fd0
movq (%r12), %rsi
movq %r15, %rdi
callq 0x41a0
movq (%r12), %rdi
callq 0x4350
movq 0x21d1b(%rip), %rax     # 0x26fd8
movq (%rax), %rdx
movq %rsp, %rdi
movl $0x200, %esi            # imm = 0x200
callq 0x4250
testq %rax, %rax
je 0x531e
movq %rsp, %rdi
callq 0x4140
testq %rax, %rax
je 0x52eb
cmpb $0xa, -0x1(%rsp,%rax)
jne 0x52eb
movb $0x0, -0x1(%rsp,%rax)
testl %ebp, %ebp
je 0x530d
cmpb $0x3d, (%rsp)
jne 0x530d
leaq 0x1(%rsp), %rdx
leaq 0x15f25(%rip), %rsi     # 0x1b226
movq %rbx, %rdi
xorl %eax, %eax
callq 0x5b95
jmp 0x5318
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x5b17
movl $0x1, %r14d
movl %r14d, %eax
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/ravenexp[P]aatrace/testdiff.c
// Function: main
int main(int argc, char* argv[])
{
	struct aatrace_pic src, dst;
	struct aatrace_diff_ctx ctx;
	int c;

	aatrace_diff_ctx_init(&ctx);

	while ((c = getopt(argc, argv, ":l:d:t:")) != -1) {
		switch(c) {
		case 'l':
			ctx.scale = atoi(optarg);
			break;
		case 'd':
			ctx.kernel = (enum aatrace_diff_kernel)atoi(optarg);
			break;
		case 't':
			ctx.threshold = (unsigned)atoi(optarg);
			break;
		case ':':
			fprintf(stderr, "Option -%c requires an operand\n", optopt);
			return 2;
		default:
		case '?':
			fprintf(stderr, "Unrecognized option: -%c\n", optopt);
			return 1;
		}
	}

	if (optind != argc - 2) {
		puts(usage);
		return 3;
	}

	if (util_load_pic(&src, argv[optind]) < 0)
		return 4;

	aatrace_diff(&dst, &src, &ctx);

	if (util_store_pic(argv[optind + 1], &dst) < 0)
		return 5;

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movl %edi, %ebp
leaq 0xc(%rsp), %rdi
callq 0x1c38
leaq 0x1bf8(%rip), %r14      # 0x3004
movq 0x3bbd(%rip), %r15      # 0x4fd0
movl %ebp, %edi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1130
cmpl $0x6b, %eax
jle 0x1441
cmpl $0x74, %eax
je 0x1454
cmpl $0x6c, %eax
jne 0x14e4
movq (%r15), %rdi
callq 0x1140
movl %eax, 0x10(%rsp)
jmp 0x1413
cmpl $0x64, %eax
jne 0x1462
movq (%r15), %rdi
callq 0x1140
movl %eax, 0xc(%rsp)
jmp 0x1413
movq (%r15), %rdi
callq 0x1140
movl %eax, 0x14(%rsp)
jmp 0x1413
cmpl $-0x1, %eax
jne 0x14d3
movq 0x3b5a(%rip), %r15      # 0x4fc8
movslq (%r15), %rax
addl $-0x2, %ebp
cmpl %ebp, %eax
jne 0x14b9
movq (%rbx,%rax,8), %rsi
leaq 0x18(%rsp), %rdi
callq 0x1a41
testl %eax, %eax
js 0x14cc
leaq 0x30(%rsp), %r14
leaq 0x18(%rsp), %rsi
leaq 0xc(%rsp), %rdx
movq %r14, %rdi
callq 0x1c4d
movslq (%r15), %rax
movq 0x8(%rbx,%rax,8), %rdi
movq %r14, %rsi
callq 0x1b35
sarl $0x1f, %eax
andl $0x5, %eax
jmp 0x14ee
leaq 0x1b90(%rip), %rdi      # 0x3050
callq 0x1060
movl $0x3, %eax
jmp 0x14ee
movl $0x4, %eax
jmp 0x14ee
cmpl $0x3a, %eax
jne 0x14e4
callq 0x1180
movl $0x2, %eax
jmp 0x14ee
callq 0x11a7
movl $0x1, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]libcperciva/tests/daemonize/main.c
// Function: main
int
main(int argc, char * argv[])
{
	const char * pidfile;

	/*
	 * This will allocate some memory for the program name, which will be
	 * freed by an atexit() function.  The non-daemonized fork of this
	 * program will call _exit() to quit without calling that function.
	 * This might cause a memory checker to issue an invalid warning
	 * which should be suppressed.
	 */
	WARNP_INIT;

	/* Parse command-line argument. */
	if (argc != 2) {
		fprintf(stderr, "usage: test_daemonize pidfile\n");
		goto err0;
	}
	pidfile = argv[1];

	/* Print current pid. */
	warn0("before daemonize, pid:\t%jd", (intmax_t)getpid());

	/* Launch daemon. */
	if (daemonize(pidfile))
		goto err0;

	/* Print current pid. */
	warn0("after daemonize, pid:\t%jd", (intmax_t)getpid());

	/* Success! */
	exit(0);

err0:
	/* Failure! */
	exit(1);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl %edi, %ebp
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x1422
callq 0x1ac4
cmpl $0x2, %ebp
je 0x1451
movq 0x2bca(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
leaq 0xbcc(%rip), %rdi       # 0x2004
movl $0x1e, %esi
movl $0x1, %edx
callq 0x11b0
movl $0x1, %edi
callq 0x11a0
movq 0x8(%rbx), %r14
callq 0x10a0
movslq %eax, %rsi
leaq 0xbbf(%rip), %rdi       # 0x2023
xorl %eax, %eax
callq 0x1c63
callq 0x1060
movq %rax, %rbx
movl $0x0, (%rax)
movq %r14, %rdi
callq 0x14a8
testl %eax, %eax
jne 0x1447
callq 0x10a0
movslq %eax, %rsi
leaq 0xbaa(%rip), %rdi       # 0x203e
xorl %eax, %eax
callq 0x1c63
movl $0x0, (%rbx)
xorl %edi, %edi
callq 0x11a0
// File: /workspace/github_c_makefile_star2_O1/giometti[P]mastering_UNIX_programming/chapter_04/getugid.c
// Function: main
int main(int argc, char *argv[])
{
	int ret;

	printf("real user/group ID:      %d/%d\n", getuid(), getgid());
	printf("effective user/group ID: %d/%d\n", geteuid(), getegid());
#ifdef _HAS_GETRESUID
	printf("saved user/group ID:     %d/%d\n", getsuid(), getsgid());
#endif

	if (argc > 1) {
		ret = open(argv[1], O_RDONLY);
		printf("file %s can%s be read\n",
			argv[1], ret < 0 ? "'t" : "");
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
callq 0x1040
movl %eax, %r14d
callq 0x1080
leaq 0xe38(%rip), %rdi       # 0x2004
movl %r14d, %esi
movl %eax, %edx
xorl %eax, %eax
callq 0x1050
callq 0x1060
movl %eax, %r14d
callq 0x1090
leaq 0xe38(%rip), %rdi       # 0x2024
movl %r14d, %esi
movl %eax, %edx
xorl %eax, %eax
callq 0x1050
leaq 0x4(%rsp), %rdi
movq %rsp, %r14
movq %rdi, %rsi
movq %r14, %rdx
callq 0x1070
movl (%r14), %r14d
leaq 0x4(%rsp), %rdi
movq %rsp, %r15
movq %rdi, %rsi
movq %r15, %rdx
callq 0x1030
movl (%r15), %edx
leaq 0xe19(%rip), %rdi       # 0x2044
movl %r14d, %esi
xorl %eax, %eax
callq 0x1050
cmpl $0x2, %ebp
jl 0x126d
movq 0x8(%rbx), %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x10a0
movq 0x8(%rbx), %rsi
testl %eax, %eax
leaq 0xe27(%rip), %rax       # 0x207b
leaq 0xdc8(%rip), %rdx       # 0x2023
cmovsq %rax, %rdx
leaq 0xdfe(%rip), %rdi       # 0x2064
xorl %eax, %eax
callq 0x1050
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/zefie[P]zefie_3k_iso_patcher/zefie_3k_iso_patcher.c
// Function: getFileDir
void getFileDir(char *filename, char *ret) {
	print_debug("attempting to find directory for %s\n",filename);
	char tmp[PATH_MAX];
	realpath(filename, tmp);
	if (!tmp) {
		printf("Error finding directory for %s (Err %i).\n", filename, errno);
		return;
	}
	print_debug("realpath for %s returned %s\n",filename,tmp);
	char *pos = strrchr(tmp, 47);
	int strpos = (pos - tmp);
	strncpy(ret, tmp, strpos);
	print_debug("found directory %s\n",ret);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
movq %rsi, %rbx
movq %rsp, %r14
movq %r14, %rsi
callq 0x40be10
movq %r14, %rdi
movl $0x2f, %esi
callq 0x401050
subl %r14d, %eax
movslq %eax, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x401088
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/zefie[P]zefie_3k_iso_patcher/zefie_3k_iso_patcher.c
// Function: getFileNoExt
void getFileNoExt(char *filename, char *ret) {
	print_debug("attempting to remove extention from %s\n",filename);
	char filenoext[PATH_MAX];
	char *pos = strrchr(filename, 46);
	int strpos = (pos - filename);
	strncpy(ret, filename, strpos);
	ret[strpos] = 0;
	print_debug("result: %s\n",ret);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x2e, %esi
callq 0x401050
subl %r14d, %eax
movslq %eax, %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x401088
movb $0x0, (%rbx,%r15)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/zefie[P]zefie_3k_iso_patcher/zefie_3k_iso_patcher.c
// Function: findKeyfile
void findKeyfile(char *filename, char *ret) {	
	char filepath[PATH_MAX];
	getFileDir(filename, filepath);
	strcpy(ret, filepath);
	strcat(ret, "/disc.key");
	print_debug("attempting to find keyfile %s\n",ret);
	if (!file_exists(ret)) {
		print_debug("%s does NOT exist\n",ret);
		strcpy(ret, filepath);
		char filenoext[PATH_MAX];
		getFileNoExt(filename, filenoext);
		strcat(ret,"/");
		strcat(ret,filenoext);
		print_debug("attempting to find keyfile %s\n",ret);
		strncat(ret, ".key", -1);
		if (!file_exists(ret)) {
			print_debug("%s does NOT exist\n",ret);
			ret[5] = 0;
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x2000, %rsp           # imm = 0x2000
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1000(%rsp), %r15
movq %r15, %rsi
callq 0x4017ed
movq %rbx, %rdi
movq %r15, %rsi
callq 0x401020
movq %rbx, %rdi
callq 0x4010e0
movabsq $0x656b2e637369642f, %rcx # imm = 0x656B2E637369642F
movq %rcx, (%rbx,%rax)
movw $0x79, 0x8(%rbx,%rax)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x45cc90
cmpl $-0x1, %eax
jne 0x401938
leaq 0x1000(%rsp), %rsi
movq %rbx, %rdi
callq 0x401020
movq %r14, %rdi
movl $0x2e, %esi
callq 0x401050
subl %r14d, %eax
movslq %eax, %r15
movq %rsp, %r12
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x401088
xorl %ebp, %ebp
movb %bpl, (%rsp,%r15)
movq %rbx, %rdi
callq 0x4010e0
movw $0x2f, (%rbx,%rax)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x401058
movq %rbx, %rdi
callq 0x4010e0
movb %bpl, 0x4(%rbx,%rax)
movl $0x79656b2e, (%rbx,%rax) # imm = 0x79656B2E
movq %rbx, %rdi
xorl %esi, %esi
callq 0x45cc90
cmpl $-0x1, %eax
jne 0x401938
movb $0x0, 0x5(%rbx)
addq $0x2000, %rsp           # imm = 0x2000
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: count
void count(struct counter *c) {
	char	msg[] = "statistics counter overflow";
	c->n++;
	if (c->n >= 1000) {
		c->n -= 1000;
		c->n1k++;
		if (c->n1k >= 1000) {
			c->n1k -= 1000;
			c->n1m++;
			if (c->n1m >= 1000) {
				c->n1m -= 1000;
				c->n1g++;
				if (c->n1g >= 1000) {
					c->n1t -= 1000;
					c->n1t++;
					if (c->n1t >= 1000) {
						error(msg, NOEXPR);
					}
				}
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movups 0x145ae(%rip), %xmm0    # 0x1790c
movups %xmm0, -0x14(%rbp)
movaps 0x14597(%rip), %xmm0    # 0x17900
movaps %xmm0, -0x20(%rbp)
movl (%rdi), %eax
leal 0x1(%rax), %ecx
movl %ecx, (%rdi)
cmpl $0x3e7, %eax            # imm = 0x3E7
jl 0x33e5
addl $0xfffffc19, %eax       # imm = 0xFFFFFC19
movl %eax, (%rdi)
movl 0x4(%rdi), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x4(%rdi)
cmpl $0x3e7, %eax            # imm = 0x3E7
jl 0x33e5
addl $0xfffffc19, %eax       # imm = 0xFFFFFC19
movl %eax, 0x4(%rdi)
movl 0x8(%rdi), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x8(%rdi)
cmpl $0x3e7, %eax            # imm = 0x3E7
jl 0x33e5
addl $0xfffffc19, %eax       # imm = 0xFFFFFC19
movl %eax, 0x8(%rdi)
movl 0xc(%rdi), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
cmpl $0x3e7, %eax            # imm = 0x3E7
jl 0x33e5
movl 0x10(%rdi), %eax
leal -0x3e7(%rax), %ecx
movl %ecx, 0x10(%rdi)
cmpl $0x7cf, %eax            # imm = 0x7CF
jl 0x33e5
leaq -0x20(%rbp), %rdi
movq $-0x8, %rsi
callq 0x33eb
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: error
cell error(char *msg, cell expr) {
	int	os;
	char	buf[100];

	if (Error_flag)
		return UNDEFINED;
	os = Outstream;
	Outstream = Quiet_mode? 2: 1;
	Error_flag = 1;
	pr("error: ");
	if (box_value(S_loading) == TRUE) {
		if (File_list != NIL) {
			print_form(car(File_list));
			pr(": ");
		}
		sprintf(buf, "%d: ", Line_no);
		pr(buf);
	}
	pr(msg);
	if (expr != NOEXPR) {
		pr(": ");
		Error_flag = 0;
		print_error_form(expr);
		Error_flag = 1;
	}
	nl();
	print_calltrace();
	Outstream = os;
	if (Quiet_mode)
		bye(1);
	return UNDEFINED;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
cmpl $0x0, 0x1b1b3(%rip)     # 0x1e5b4
jne 0x3516
movq %rsi, %rbx
movq %rdi, %r14
movl 0x1ae6c(%rip), %r12d    # 0x1e280
cmpl $0x1, 0x1b19d(%rip)     # 0x1e5b8
movl $0x2, %eax
sbbl $0x0, %eax
movl %eax, 0x1ae57(%rip)     # 0x1e280
movl $0x1, 0x1b181(%rip)     # 0x1e5b4
leaq 0x12dc4(%rip), %rdi     # 0x161fe
callq 0x3965
movq 0x1b17a(%rip), %rax     # 0x1e5c0
movq 0x1b17b(%rip), %rcx     # 0x1e5c8
cmpq $-0x2, (%rax,%rcx,8)
jne 0x34a5
movq 0x1aced(%rip), %rax     # 0x1e148
cmpq $-0x1, %rax
je 0x347f
movq 0x1ad08(%rip), %rcx     # 0x1e170
movq (%rcx,%rax,8), %rdi
xorl %esi, %esi
callq 0x91f0
leaq 0x131d8(%rip), %rdi     # 0x16652
callq 0x3965
movl 0x1b14b(%rip), %edx     # 0x1e5d0
leaq 0x12d7a(%rip), %rsi     # 0x16206
leaq -0x90(%rbp), %r15
movq %r15, %rdi
xorl %eax, %eax
callq 0x31f0
movq %r15, %rdi
callq 0x3965
movq %r14, %rdi
callq 0x3965
cmpq $-0x8, %rbx
je 0x34f5
leaq 0x13198(%rip), %rdi     # 0x16652
callq 0x3965
xorl %r14d, %r14d
movl %r14d, 0x1b0eb(%rip)    # 0x1e5b4
movl $0x32, 0x1adb1(%rip)    # 0x1e284
movl %r14d, 0x1adae(%rip)    # 0x1e288
movq %rbx, %rdi
xorl %esi, %esi
callq 0x91f0
movl %r14d, 0x1ad99(%rip)    # 0x1e284
movl $0x1, 0x1b0bf(%rip)     # 0x1e5b4
leaq 0x143f9(%rip), %rdi     # 0x178f5
callq 0x3965
callq 0x39ec
movl %r12d, 0x1ad73(%rip)    # 0x1e280
cmpl $0x0, 0x1b0a4(%rip)     # 0x1e5b8
jne 0x352a
movq $-0x5, %rax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %edi
callq 0x3200
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: counter_to_list
cell counter_to_list(struct counter *c) {
	cell	n, m;

	n = make_integer(c->n);
	n = node(n, NIL);
	save(n);
	m = make_integer(c->n1k);
	n = node(m, n);
	car(Stack) = n;
	m = make_integer(c->n1m);
	n = node(m, n);
	car(Stack) = n;
	m = make_integer(c->n1g);
	n = node(m, n);
	car(Stack) = n;
	m = make_integer(c->n1t);
	n = node(m, n);
	unsave(1);
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movslq (%rdi), %rdi
movq $-0x1, %rsi
movl $0x1, %edx
callq 0x36e8
movq $-0x18, %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x36e8
movq %rax, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, %r14
movq 0x1aba7(%rip), %rsi     # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x1ab96(%rip)     # 0x1e128
movslq 0x4(%rbx), %rdi
movq $-0x1, %rsi
movl $0x1, %edx
callq 0x36e8
movq $-0x18, %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x36e8
movq %rax, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, %r14
movq 0x1ab9e(%rip), %rax     # 0x1e170
movq 0x1ab4f(%rip), %rcx     # 0x1e128
movq %r14, (%rax,%rcx,8)
movslq 0x8(%rbx), %rdi
movq $-0x1, %rsi
movl $0x1, %edx
callq 0x36e8
movq $-0x18, %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x36e8
movq %rax, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, %r14
movq 0x1ab53(%rip), %rax     # 0x1e170
movq 0x1ab04(%rip), %rcx     # 0x1e128
movq %r14, (%rax,%rcx,8)
movslq 0xc(%rbx), %rdi
movq $-0x1, %rsi
movl $0x1, %edx
callq 0x36e8
movq $-0x18, %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x36e8
movq %rax, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, %r14
movq 0x1ab08(%rip), %rax     # 0x1e170
movq 0x1aab9(%rip), %rcx     # 0x1e128
movq %r14, (%rax,%rcx,8)
movslq 0x10(%rbx), %rdi
movq $-0x1, %rsi
movl $0x1, %edx
callq 0x36e8
movq $-0x18, %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x36e8
movq %rax, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, %rbx
movl $0x1, %edi
callq 0x3851
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: node3
cell node3(cell pcar, cell pcdr, int ptag) {
	cell	n;
	int	k;
	char	buf[100];

	if (Run_stats) {
		count(&Nodes);
		if (Cons_stats)
			count(&Conses);
	}
	if (Free_list == NIL) {
		if (ptag == 0)
			Tmp_car = pcar;
		if (ptag != VECTOR_TAG && ptag != STREAM_TAG)
			Tmp_cdr = pcdr;
		k = gc();
		/*
		 * Performance increases dramatically if we
		 * do not wait for the pool to run dry.
		 * In fact, don't even let it come close to that.
		 */
		if (k < Cons_pool_size / 2) {
			if (	Memory_limit_kn &&
				Cons_pool_size + Cons_segment_size
					> Memory_limit_kn
			) {
				error("hit memory limit", NOEXPR);
			}
			else {
				new_cons_segment();
				if (Verbose_GC) {
					sprintf(buf,
						"GC: new segment,"
						 " nodes = %d,"
						 " next segment = %d",
						Cons_pool_size,
						Cons_segment_size);
					pr(buf); nl();
				}
				gc();
			}
		}
		Tmp_car = Tmp_cdr = NIL;
	}
	if (Free_list == NIL)
		fatal("cons3: failed to recover from low memory condition");
	n = Free_list;
	Free_list = cdr(Free_list);
	car(n) = pcar;
	cdr(n) = pcdr;
	Tag[n] = ptag;
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
cmpl $0x0, 0x1af1a(%rip)     # 0x1e620
je 0x3729
leaq 0x1af31(%rip), %rdi     # 0x1e640
callq 0x334f
cmpl $0x0, 0x1af39(%rip)     # 0x1e654
je 0x3729
leaq 0x1af34(%rip), %rdi     # 0x1e658
callq 0x334f
cmpq $-0x1, 0x1af07(%rip)    # 0x1e638
jne 0x37fc
cmpl $0x20, %ebx
je 0x3753
cmpl $0x10, %ebx
je 0x3753
testl %ebx, %ebx
jne 0x374c
movq %r15, 0x1a9cc(%rip)     # 0x1e118
movq %r14, 0x1a9cd(%rip)     # 0x1e120
callq 0x3ef8
movslq 0x1ae75(%rip), %rcx     # 0x1e5d4
movl %ecx, %edx
shrl $0x1f, %edx
addl %ecx, %edx
sarl %edx
cmpl %edx, %eax
jge 0x37e7
movq 0x1aefd(%rip), %rax     # 0x1e670
testq %rax, %rax
je 0x379c
movslq 0x1ae59(%rip), %rdx     # 0x1e5d8
addq %rcx, %rdx
cmpq %rdx, %rax
jge 0x379c
leaq 0x12ac4(%rip), %rdi     # 0x16252
movq $-0x8, %rsi
callq 0x33eb
jmp 0x37e7
callq 0x3b02
cmpl $0x0, 0x1a948(%rip)     # 0x1e0f0
je 0x37e2
movl 0x1ae24(%rip), %edx     # 0x1e5d4
movl 0x1ae22(%rip), %ecx     # 0x1e5d8
leaq 0x12aa6(%rip), %rsi     # 0x16263
leaq -0x90(%rbp), %r12
movq %r12, %rdi
xorl %eax, %eax
callq 0x31f0
movq %r12, %rdi
callq 0x3965
leaq 0x14118(%rip), %rdi     # 0x178f5
callq 0x3965
callq 0x3ef8
movq $-0x1, %rax
movq %rax, 0x1a92b(%rip)     # 0x1e120
movq %rax, 0x1a91c(%rip)     # 0x1e118
cmpq $-0x1, 0x1ae34(%rip)    # 0x1e638
je 0x3845
movq 0x1ae2b(%rip), %rax     # 0x1e638
movq 0x1adac(%rip), %rcx     # 0x1e5c0
movq (%rcx,%rax,8), %rdx
movq %rdx, 0x1ae19(%rip)     # 0x1e638
movq 0x1a94a(%rip), %rdx     # 0x1e170
movq %r15, (%rdx,%rax,8)
movq %r14, (%rcx,%rax,8)
movq 0x1adab(%rip), %rcx     # 0x1e5e0
movb %bl, (%rcx,%rax)
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x12a46(%rip), %rdi     # 0x16292
callq 0x3ab5
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: unsave
cell unsave(int k) {
	cell	n = NIL; /*LINT*/

	while (k) {
		if (Stack == NIL)
			fatal("unsave: stack underflow");
		n = car(Stack);
		Stack = cdr(Stack);
		k--;
	}
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testl %edi, %edi
je 0x3889
movq 0x1a8c8(%rip), %rcx     # 0x1e128
movq 0x1a909(%rip), %rdx     # 0x1e170
movq 0x1ad52(%rip), %rsi     # 0x1e5c0
cmpq $-0x1, %rcx
je 0x3892
movq (%rdx,%rcx,8), %rax
movq (%rsi,%rcx,8), %rcx
movq %rcx, 0x1a8a5(%rip)     # 0x1e128
decl %edi
jne 0x386e
jmp 0x3890
movq $-0x1, %rax
popq %rbp
retq
leaq 0x12aa2(%rip), %rdi     # 0x1633b
callq 0x3ab5
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: pr_raw
void pr_raw(char *s, int k) {
	if (Printer_limit && Printer_count > Printer_limit) {
		if (Printer_limit > 0)
			fwrite("...", 1, 3, Streams[Outstream]);
		Printer_limit = -1;
		return;
	}
	fwrite(s, 1, k, Streams[Outstream]);
	if (Outstream == 1 && s[k-1] == '\n')
		flush();
	Printer_count += k;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl 0x1a9b4(%rip), %eax     # 0x1e284
testl %eax, %eax
je 0x3914
cmpl %eax, 0x1a9ae(%rip)     # 0x1e288
jle 0x3914
testl %eax, %eax
jle 0x3908
movslq 0x1a999(%rip), %rax     # 0x1e280
leaq 0x1a892(%rip), %rcx     # 0x1e180
movq (%rcx,%rax,8), %rcx
leaq 0x128df(%rip), %rdi     # 0x161d8
movl $0x1, %esi
movl $0x3, %edx
callq 0x3210
movl $0xffffffff, 0x1a972(%rip) # imm = 0xFFFFFFFF
jmp 0x395c
movslq %ebx, %r15
movslq 0x1a962(%rip), %rax     # 0x1e280
leaq 0x1a85b(%rip), %r12     # 0x1e180
movq (%r12,%rax,8), %rcx
movl $0x1, %esi
movq %r14, %rdi
movq %r15, %rdx
callq 0x3210
movl 0x1a941(%rip), %eax     # 0x1e280
cmpq $0x1, %rax
jne 0x3956
cmpb $0xa, -0x1(%r14,%r15)
jne 0x3956
movq (%r12,%rax,8), %rdi
callq 0x3160
addl %ebx, 0x1a92c(%rip)     # 0x1e288
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: print_error_form
void print_error_form(cell n) {
	Printer_limit = 50;
	Printer_count = 0;
	print_form(n);
	Printer_limit = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl $0x32, 0x1a8c0(%rip)    # 0x1e284
xorl %ebx, %ebx
movl %ebx, 0x1a8bc(%rip)     # 0x1e288
xorl %esi, %esi
callq 0x91f0
movl %ebx, 0x1a8ab(%rip)     # 0x1e284
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: print_calltrace
void print_calltrace(void) {
	int	i, j;

	for (i=0; i<Proc_max; i++)
		if (Called_procedures[i] != NIL)
			break;
	if (i == Proc_max)
		return;
	pr("call trace:");
	i = Proc_ptr;
	for (j=0; j<Proc_max; j++) {
		if (i >= Proc_max)
			i = 0;
		if (Called_procedures[i] != NIL) {
			pr(" ");
			print_form(Called_procedures[i]);
		}
		i++;
	}
	nl();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x1a88c(%rip), %eax     # 0x1e28c
testl %eax, %eax
jle 0x3a23
leaq 0x1a885(%rip), %rdx     # 0x1e290
xorl %ecx, %ecx
cmpq $-0x1, (%rdx)
jne 0x3a25
incq %rcx
addq $0x8, %rdx
cmpq %rcx, %rax
jne 0x3a0d
movl %eax, %ecx
jmp 0x3a25
xorl %ecx, %ecx
cmpl %eax, %ecx
jne 0x3a38
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x127b3(%rip), %rdi     # 0x161f2
callq 0x3965
movl 0x1a842(%rip), %eax     # 0x1e28c
testl %eax, %eax
jle 0x3a9b
xorl %r14d, %r14d
movl 0x1ab58(%rip), %r15d    # 0x1e5b0
leaq 0x1a831(%rip), %r12     # 0x1e290
xorl %r13d, %r13d
cmpl %eax, %r15d
cmovgel %r14d, %r15d
movslq %r15d, %rbx
cmpq $-0x1, (%r12,%rbx,8)
je 0x3a8a
leaq 0x13db9(%rip), %rdi     # 0x17833
callq 0x3965
movq (%r12,%rbx,8), %rdi
xorl %esi, %esi
callq 0x91f0
incl %r15d
incl %r13d
movl 0x1a7f6(%rip), %eax     # 0x1e28c
cmpl %eax, %r13d
jl 0x3a62
leaq 0x13e53(%rip), %rdi     # 0x178f5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3965
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: fatal
void fatal(char *msg) {
	Outstream = Quiet_mode? 2: 1;
	pr("fatal ");
	Error_flag = 0;
	error(msg, NOEXPR);
	bye(2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x1, 0x1aaf3(%rip)     # 0x1e5b8
movl $0x2, %eax
sbbl $0x0, %eax
movl %eax, 0x1a7ad(%rip)     # 0x1e280
leaq 0x12731(%rip), %rdi     # 0x1620b
callq 0x3965
movl $0x0, 0x1aacb(%rip)     # 0x1e5b4
movq %rbx, %rdi
movq $-0x8, %rsi
callq 0x33eb
movl $0x2, %edi
callq 0x3200
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: new_cons_segment
void new_cons_segment(void) {
	Car = realloc(Car, sizeof(cell) * (Cons_pool_size+Cons_segment_size));
	Cdr = realloc(Cdr, sizeof(cell) * (Cons_pool_size+Cons_segment_size));
	Tag = realloc(Tag, Cons_pool_size + Cons_segment_size);
	if (Car == NULL || Cdr == NULL || Tag == NULL)
		fatal("new_cons_segment: out of physical memory");
	memset(&car(Cons_pool_size), 0, Cons_segment_size * sizeof(cell));
	memset(&cdr(Cons_pool_size), 0, Cons_segment_size * sizeof(cell));
	memset(&Tag[Cons_pool_size], 0, Cons_segment_size);
	Cons_pool_size += Cons_segment_size;
	Cons_segment_size = Cons_segment_size * 3 / 2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x1a663(%rip), %rdi     # 0x1e170
movslq 0x1aac0(%rip), %rax     # 0x1e5d4
movslq 0x1aabd(%rip), %rsi     # 0x1e5d8
addq %rax, %rsi
shlq $0x3, %rsi
callq 0x3190
movq %rax, 0x1a642(%rip)     # 0x1e170
movq 0x1aa8b(%rip), %rdi     # 0x1e5c0
movslq 0x1aa98(%rip), %rax     # 0x1e5d4
movslq 0x1aa95(%rip), %rsi     # 0x1e5d8
addq %rax, %rsi
shlq $0x3, %rsi
callq 0x3190
movq %rax, 0x1aa6a(%rip)     # 0x1e5c0
movq 0x1aa83(%rip), %rdi     # 0x1e5e0
movslq 0x1aa70(%rip), %rax     # 0x1e5d4
movslq 0x1aa6d(%rip), %rsi     # 0x1e5d8
addq %rax, %rsi
callq 0x3190
movq %rax, 0x1aa66(%rip)     # 0x1e5e0
testq %rax, %rax
je 0x3c23
cmpq $0x0, 0x1a5e5(%rip)     # 0x1e170
je 0x3c23
cmpq $0x0, 0x1aa27(%rip)     # 0x1e5c0
je 0x3c23
movslq 0x1aa2e(%rip), %rdi     # 0x1e5d4
shlq $0x3, %rdi
addq 0x1a5bf(%rip), %rdi     # 0x1e170
movslq 0x1aa20(%rip), %rdx     # 0x1e5d8
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x30d0
movslq 0x1aa0a(%rip), %rdi     # 0x1e5d4
shlq $0x3, %rdi
addq 0x1a9eb(%rip), %rdi     # 0x1e5c0
movslq 0x1a9fc(%rip), %rdx     # 0x1e5d8
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x30d0
movslq 0x1a9e6(%rip), %rdi     # 0x1e5d4
addq 0x1a9eb(%rip), %rdi     # 0x1e5e0
movslq 0x1a9dc(%rip), %rdx     # 0x1e5d8
xorl %esi, %esi
callq 0x30d0
movl 0x1a9cf(%rip), %eax     # 0x1e5d8
addl %eax, 0x1a9c5(%rip)     # 0x1e5d4
leal (%rax,%rax,2), %eax
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
movl %ecx, 0x1a9b7(%rip)     # 0x1e5d8
popq %rbp
retq
leaq 0x125e8(%rip), %rdi     # 0x16212
callq 0x3ab5
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: new_vec_segment
void new_vec_segment(void) {
	Vectors = realloc(Vectors, sizeof(cell) *
			(Vec_pool_size + Vec_segment_size));
	if (Vectors == NULL)
		fatal("out of physical memory");
	memset(&Vectors[Vec_pool_size], 0, Vec_segment_size * sizeof(cell));
	Vec_pool_size += Vec_segment_size;
	Vec_segment_size = Vec_segment_size * 3 / 2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x1a9ae(%rip), %rdi     # 0x1e5e8
movslq 0x1a9af(%rip), %rax     # 0x1e5f0
movslq 0x1a9ac(%rip), %rsi     # 0x1e5f4
addq %rax, %rsi
shlq $0x3, %rsi
callq 0x3190
movq %rax, 0x1a98d(%rip)     # 0x1e5e8
testq %rax, %rax
je 0x3ca4
movslq 0x1a989(%rip), %rdi     # 0x1e5f0
shlq $0x3, %rdi
addq 0x1a976(%rip), %rdi     # 0x1e5e8
movslq 0x1a97b(%rip), %rdx     # 0x1e5f4
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x30d0
movl 0x1a96a(%rip), %eax     # 0x1e5f4
addl %eax, 0x1a960(%rip)     # 0x1e5f0
leal (%rax,%rax,2), %eax
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
movl %ecx, 0x1a952(%rip)     # 0x1e5f4
popq %rbp
retq
leaq 0x13799(%rip), %rdi     # 0x17444
callq 0x3ab5