LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/sparse.c
// Function: check_bb_context
static int check_bb_context(struct entrypoint *ep, struct basic_block *bb, int entry, int exit)
{
	if (!bb)
		return 0;
	if (bb->context == entry)
		return 0;

	/* Now that's not good.. */
	if (bb->context >= 0)
		return imbalance(ep, bb, entry, bb->context, "different lock contexts for basic block");

	bb->context = entry;
	entry += context_increase(bb, entry);
	if (entry < 0)
		return imbalance(ep, bb, entry, exit, "unexpected unlock");

	return check_children(ep, bb, entry, exit);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, 0xc(%rsp)
xorl %eax, %eax
testq %rsi, %rsi
je 0xe90f
movl %edx, %r12d
movq %rsi, %r15
movl 0x58(%rsi), %ecx
cmpl %edx, %ecx
je 0xe90f
movq %rdi, %r13
testl %ecx, %ecx
js 0xe91e
leaq 0x2a7a0(%rip), %rdx     # 0x390a1
movq %r13, %rdi
movq %r15, %rsi
callq 0xead5
pushq $-0x1
popq %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, 0x10(%rsp)
movl %r12d, 0x58(%r15)
movq 0x28(%r15), %rbx
testq %rbx, %rbx
je 0xe9ac
movq %rbx, %rbp
xorl %r14d, %r14d
xorl %r13d, %r13d
movl (%rbp), %ecx
movsbq %cl, %rax
cmpq %rax, %r13
jge 0xe9a1
movq 0x18(%rbp,%r13,8), %rax
cmpw $0x100, %cx             # imm = 0x100
jb 0xe956
testq %rax, %rax
je 0xe99c
cmpq $0x0, 0x8(%rax)
je 0xe99c
movl (%rax), %ecx
andl $0x7f, %ecx
cmpl $0x4f, %ecx
jne 0xe99c
movl 0x30(%rax), %ecx
cmpl $0x0, 0x34(%rax)
je 0xe97e
leal (%r14,%r12), %edx
testl %ecx, %ecx
je 0xe986
cmpl %ecx, %edx
jl 0xe98a
jmp 0xe99c
addl %r14d, %ecx
movl %ecx, %r14d
jmp 0xe99c
testl %edx, %edx
je 0xe99c
movq 0x10(%rax), %rdi
leaq 0x2a765(%rip), %rsi     # 0x390fa
xorl %eax, %eax
callq 0x116b6
incq %r13
jmp 0xe939
movq 0x10(%rbp), %rbp
cmpq %rbx, %rbp
jne 0xe936
jmp 0xe9af
xorl %r14d, %r14d
addl %r12d, %r14d
js 0xe9f1
movq 0x28(%r15), %rdi
callq 0x1ff63
movq %rax, %rcx
xorl %eax, %eax
testq %rcx, %rcx
movq 0x10(%rsp), %r13
je 0xe90f
movl (%rcx), %ecx
andl $0x7f, %ecx
cmpl $0x2, %ecx
jne 0xea02
cmpl 0xc(%rsp), %r14d
je 0xe90f
leaq 0x2a724(%rip), %rdx     # 0x39110
jmp 0xe901
leaq 0x2a6d1(%rip), %rdx     # 0x390c9
movq 0x10(%rsp), %r13
jmp 0xe901
movq 0x20(%r15), %rbx
testq %rbx, %rbx
je 0xe90f
pushq $-0x1
popq %rbp
movq %rbx, %r15
xorl %r12d, %r12d
movl (%r15), %eax
movsbq %al, %rcx
cmpq %rcx, %r12
jge 0xea4c
movq 0x18(%r15,%r12,8), %rsi
cmpw $0x100, %ax             # imm = 0x100
jb 0xea34
testq %rsi, %rsi
je 0xea47
movq %r13, %rdi
movl %r14d, %edx
movl 0xc(%rsp), %ecx
callq 0xe8cd
testl %eax, %eax
jne 0xea5c
incq %r12
jmp 0xea18
movq 0x10(%r15), %r15
xorl %eax, %eax
cmpq %rbx, %r15
jne 0xea15
jmp 0xe90f
movl %ebp, %eax
jmp 0xe90f
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/sparse.c
// Function: imbalance
static int imbalance(struct entrypoint *ep, struct basic_block *bb, int entry, int exit, const char *why)
{
	if (Wcontext) {
		struct symbol *sym = ep->name;
		warning(bb->pos, "context imbalance in '%s' - %s", show_ident(sym->ident), why);
	}
	return -1;
}

// Assembly:
leaq 0x4bab8(%rip), %rax     # 0x5a594
cmpl $0x0, (%rax)
je 0xeb15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq (%rdi), %rax
movq 0x18(%rax), %rdi
callq 0x29bfd
movq (%r14), %rdi
leaq 0x2a5da(%rip), %rsi     # 0x390db
movq %rax, %rdx
movq %rbx, %rcx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x116b6
retq
nop
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/stats.c
// Function: show_allocation_stats
void show_allocation_stats(void)
{
	struct allocator_stats tot = { .name = "total", };

	fprintf(stderr, "%16s: %8s, %10s, %10s, %7s, %8s\n", "allocator", "allocs",
		"bytes", "total", "%usage", "average");
	show_stats(get_token_stats, &tot);
	show_stats(get_ident_stats, &tot);
	show_stats(get_symbol_stats, &tot);
	show_stats(get_expression_stats, &tot);
	show_stats(get_statement_stats, &tot);
	show_stats(get_scope_stats, &tot);
	show_stats(get_basic_block_stats, &tot);
	show_stats(get_instruction_stats, &tot);
	show_stats(get_pseudo_stats, &tot);
	show_stats(get_pseudo_user_stats, &tot);
	show_stats(get_ptrlist_stats, &tot);
	show_stats(get_multijmp_stats, &tot);
	show_stats(get_asm_rules_stats, &tot);
	show_stats(get_asm_constraint_stats, &tot);
	show_stats(get_context_stats, &tot);
	show_stats(get_string_stats, &tot);
	show_stats(get_bytes_stats, &tot);
	//show_stats(get_storage_stats, &tot);
	//show_stats(get_storage_hash_stats, &tot);

	show_stats(NULL, &tot);
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movups 0x2cb0c(%rip), %xmm0    # 0x53808
movq %rsp, %rbx
movaps %xmm0, 0x10(%rbx)
movups 0x2caee(%rip), %xmm0    # 0x537f8
movaps %xmm0, (%rbx)
movq 0x332dc(%rip), %rax     # 0x59ff0
movq (%rax), %rdi
leaq 0x19c4f(%rip), %r10     # 0x4096d
leaq 0x19c41(%rip), %r11     # 0x40966
leaq 0x19c02(%rip), %rsi     # 0x4092e
leaq 0x19c1c(%rip), %rdx     # 0x4094f
leaq 0x19c1f(%rip), %rcx     # 0x40959
leaq 0x19c1f(%rip), %r8      # 0x40960
leaq 0x19be0(%rip), %r9      # 0x40928
xorl %eax, %eax
pushq %r10
pushq %r11
callq 0xe1d0
popq %rcx
popq %rdx
leaq 0x44a8(%rip), %rdi      # 0x2b204
movq %rbx, %rsi
callq 0x26e64
leaq 0x442d(%rip), %rdi      # 0x2b198
movq %rbx, %rsi
callq 0x26e64
leaq 0x4565(%rip), %rdi      # 0x2b2df
movq %rbx, %rsi
callq 0x26e64
leaq 0x462e(%rip), %rdi      # 0x2b3b7
movq %rbx, %rsi
callq 0x26e64
leaq 0x468b(%rip), %rdi      # 0x2b423
movq %rbx, %rsi
callq 0x26e64
leaq 0x4754(%rip), %rdi      # 0x2b4fb
movq %rbx, %rsi
callq 0x26e64
leaq 0x481c(%rip), %rdi      # 0x2b5d2
movq %rbx, %rsi
callq 0x26e64
leaq 0x48e5(%rip), %rdi      # 0x2b6aa
movq %rbx, %rsi
callq 0x26e64
leaq 0x49ae(%rip), %rdi      # 0x2b782
movq %rbx, %rsi
callq 0x26e64
leaq -0x14dd9(%rip), %rdi    # 0x1200a
movq %rbx, %rsi
callq 0x26e64
leaq -0x6f51(%rip), %rdi     # 0x1fea1
movq %rbx, %rsi
callq 0x26e64
leaq 0x4915(%rip), %rdi      # 0x2b716
movq %rbx, %rsi
callq 0x26e64
leaq -0x138bd(%rip), %rdi    # 0x13553
movq %rbx, %rsi
callq 0x26e64
leaq -0x1387b(%rip), %rdi    # 0x135a4
movq %rbx, %rsi
callq 0x26e64
leaq 0x4442(%rip), %rdi      # 0x2b270
movq %rbx, %rsi
callq 0x26e64
leaq 0x4652(%rip), %rdi      # 0x2b48f
movq %rbx, %rsi
callq 0x26e64
leaq 0x471a(%rip), %rdi      # 0x2b566
movq %rbx, %rsi
callq 0x26e64
xorl %edi, %edi
movq %rbx, %rsi
callq 0x26e64
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/stats.c
// Function: show_stats
static void show_stats(get_t get, struct allocator_stats * tot)
{
	struct allocator_stats x;

	if (get)
		get(&x);
	else
		x = *tot;
	fprintf(stderr, "%16s: %8d, %10ld, %10ld, %6.2f%%, %8.2f\n",
		x.name, x.allocations, x.useful_bytes, x.total_bytes,
		100 * (double) x.useful_bytes / (x.total_bytes ? : 1),
		(double) x.useful_bytes / (x.allocations ? : 1));

	tot->allocations += x.allocations;
	tot->useful_bytes += x.useful_bytes;
	tot->total_bytes += x.total_bytes;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
testq %rdi, %rdi
jne 0x26e83
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
jmp 0x26e8b
movq %rdi, %rax
movq %rsp, %rdi
callq *%rax
movq 0x3315e(%rip), %rax     # 0x59ff0
movq (%rax), %rdi
movq (%rsp), %rdx
movl 0x8(%rsp), %ecx
movq 0x18(%rsp), %r8
movq 0x10(%rsp), %r9
movq %r8, %xmm0
movq 0x19a4c(%rip), %xmm2    # 0x40900
punpckldq %xmm2, %xmm0    # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
movapd 0x19a50(%rip), %xmm3    # 0x40910
subpd %xmm3, %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd 0x19a48(%rip), %xmm0    # 0x40920
mulsd %xmm1, %xmm0
cmpq $0x1, %r9
movq %r9, %rax
adcq $0x0, %rax
movq %rax, %xmm4
punpckldq %xmm2, %xmm4    # xmm4 = xmm4[0],xmm2[0],xmm4[1],xmm2[1]
subpd %xmm3, %xmm4
movapd %xmm4, %xmm2
unpckhpd %xmm4, %xmm2            # xmm2 = xmm2[1],xmm4[1]
addsd %xmm4, %xmm2
cmpl $0x1, %ecx
movl %ecx, %eax
adcl $0x0, %eax
divsd %xmm2, %xmm0
cvtsi2sd %rax, %xmm2
divsd %xmm2, %xmm1
leaq 0x19a59(%rip), %rsi     # 0x40975
movb $0x2, %al
callq 0xe1d0
movl 0x8(%rsp), %eax
addl %eax, 0x8(%rbx)
movdqu 0x10(%rbx), %xmm0
paddq 0x10(%rsp), %xmm0
movdqu %xmm0, 0x10(%rbx)
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/ch3/eatyguy5.c
// Function: push_state_table
void push_state_table(lua_State *L,
                      int key,
                      int is_end_of_seq) {

  // The state of the Lua stack is given in indented comments in
  // this function to clarify the actions of each function call.

  lua_newtable(L);

    // stack = [.., {}]

  push_keypress(L, key, is_end_of_seq);

    // stack = [.., {}, key]

  lua_setfield(L, -2, "key");

    // stack = [.., {key = key}]

  lua_pushnumber(L, gettime());

    // stack = [.., {key = key}, clock]

  lua_setfield(L, -2, "clock");

    // stack = [.., {key = key, clock = clock}]
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
xorl %esi, %esi
xorl %edx, %edx
callq 0x560a
movq %rbx, %rdi
movl %r15d, %esi
movl %r14d, %edx
callq 0x479a
leaq 0x19880(%rip), %rdx     # 0x1e081
pushq $-0x2
popq %r14
movq %rbx, %rdi
movl %r14d, %esi
callq 0x5869
callq 0x462c
movq %rbx, %rdi
callq 0x50f6
leaq 0x19861(%rip), %rdx     # 0x1e085
movq %rbx, %rdi
movl %r14d, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5869
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/ch3/eatyguy5.c
// Function: main
int main() {

  start();

  // Create a Lua state and load the module.
  lua_State *L = luaL_newstate();
  luaL_openlibs(L);

  // Set up API functions written in C.
  lua_register(L, "timestamp", timestamp);

  // Set up API functions written in Lua.
  luaL_dofile(L, "util.lua");

  // Load eatyguy5 and run the init() function.
  luaL_dofile(L, "eatyguy5.lua");
  lua_setglobal(L, "eatyguy");
  lua_settop(L, 0);

  lua_getglobal(L, "eatyguy");
  lua_getfield(L, -1, "init");  // -1 means stack top.
  lua_call(L, 0, 0);            // 0, 0 = #args, #retvals

  lua_getglobal(L, "eatyguy");
  while (1) {
    int is_end_of_seq;
    int key = getkey(&is_end_of_seq);
    if (key == ESC_KEY || key == 'q' || key == 'Q') done();

    // Call eatyguy.loop(state).
    lua_getfield(L, -1, "loop");
    // This replaces the previous call to push_keypress().
    push_state_table(L, key, is_end_of_seq);
    lua_call(L, 1, 0);

    sleephires(0.016);  // Sleep for 16ms.
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x4742
callq 0x12e9a
movq %rax, %rbx
movq %rax, %rdi
callq 0x130c0
leaq -0x4a(%rip), %rsi       # 0x4839
movq %rbx, %rdi
xorl %edx, %edx
callq 0x52ba
leaq 0x197f7(%rip), %rsi     # 0x1e08b
movq %rbx, %rdi
callq 0x56f9
leaq 0x197f2(%rip), %rsi     # 0x1e095
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1266b
testl %eax, %eax
jne 0x48c6
pushq $-0x1
popq %rdx
movq %rbx, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x5bc8
leaq 0x197d1(%rip), %rsi     # 0x1e09e
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1266b
testl %eax, %eax
jne 0x48f0
pushq $-0x1
popq %rdx
movq %rbx, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x5bc8
leaq 0x197b4(%rip), %r15     # 0x1e0ab
movq %rbx, %rdi
movq %r15, %rsi
callq 0x56f9
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4ae1
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5388
leaq 0x19795(%rip), %rdx     # 0x1e0b3
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x54a4
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x5b60
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5388
leaq -0x2c(%rbp), %r15
leaq 0x1a23b(%rip), %r12     # 0x1eb8b
pushq $0x1
popq %r13
movq %r15, %rdi
callq 0x4661
cmpl $0x1b, %eax
je 0x49ac
movl %eax, %r14d
cmpl $0x71, %eax
je 0x49ac
cmpl $0x51, %r14d
je 0x49ac
movq %rbx, %rdi
pushq $-0x1
popq %rsi
movq %r12, %rdx
callq 0x54a4
movl -0x2c(%rbp), %edx
movq %rbx, %rdi
movl %r14d, %esi
callq 0x47d0
movq %rbx, %rdi
movl %r13d, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x5b60
movsd 0x19673(%rip), %xmm0    # 0x1e018
callq 0x46ed
jmp 0x4954
callq 0x4777
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/jacereda[P]fsatrace/src/fsatest.c
// Function: unescape
void
unescape(char *s)
{
	// w = write index, r = read index
	int w = 0;
	for (int r = 0; s[r]; r++) {
		if (s[r] != '#')
			s[w++] = s[r];
		else if (s[r + 1] != '#')
			s[w++] = ' ';
		else
			s[w++] = s[++r];
	}
	s[w] = 0;
}

// Assembly:
xorl %eax, %eax
xorl %ecx, %ecx
movslq %ecx, %rdx
movzbl (%rdi,%rdx), %esi
cmpl $0x23, %esi
je 0x1216
testl %esi, %esi
je 0x1233
movb %sil, (%rdi,%rax)
jmp 0x122c
cmpb $0x23, 0x1(%rdi,%rdx)
jne 0x1228
incq %rdx
movb $0x23, (%rdi,%rax)
movl %edx, %ecx
jmp 0x122c
movb $0x20, (%rdi,%rax)
incq %rax
incl %ecx
jmp 0x1200
movl %eax, %eax
movb $0x0, (%rdi,%rax)
retq
// File: /workspace/github_c_makefile_star2_O2/jacereda[P]fsatrace/src/fsatest.c
// Function: exec
void
exec(char *s)
{
#ifndef _WIN32_WINNT
	int child;
	int rc;
#endif

	char *args[1000];
	args[0] = strtok(s, " ");
	for (int i = 1; i < 1000; i++) {
		args[i] = strtok(NULL, " ");
		if (args[i] == NULL)
			break;
	}

#ifdef _WIN32_WINNT
	spawnv(P_WAIT, args[0], args);
#else
	child = fork();
	if (child == 0)
		execvp(args[0], args);
	waitpid(child, &rc, 0);
#endif
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1f58, %rsp           # imm = 0x1F58
leaq 0xdb6(%rip), %r14       # 0x2004
movq %r14, %rsi
callq 0x10a0
movq %rax, %rbx
movq %rax, 0x10(%rsp)
pushq $0x1
popq %r15
cmpq $0x3e8, %r15            # imm = 0x3E8
je 0x1282
xorl %edi, %edi
movq %r14, %rsi
callq 0x10a0
movq %rax, 0x10(%rsp,%r15,8)
incq %r15
testq %rax, %rax
jne 0x1262
callq 0x10f0
movl %eax, %ebp
testl %eax, %eax
jne 0x129a
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x10b0
leaq 0xc(%rsp), %rsi
movl %ebp, %edi
xorl %edx, %edx
callq 0x1080
addq $0x1f58, %rsp           # imm = 0x1F58
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jacereda[P]fsatrace/src/fsatest.c
// Function: main
int
main(int argc, const char *argv[])
{
	int trace = 0;
	int exitCode = 0;

	for (int i = 1; i < argc; i++) {
		const char *s = argv[i];
		FILE *	    fp;
		char *	    cmdline;
		int	    seconds;

		switch (s[0]) {
		case 'r':
			if (trace)
				printf("Reading from: %s\n", &s[1]);
			fp = fopen(&s[1], "r");
			while (fgetc(fp) != EOF)
				; // nothing
			fclose(fp);
			break;

		case 'w':
			if (trace)
				printf("Writing to: %s\n", &s[1]);
			fp = fopen(&s[1], "w");
			fputs("Written by fsatest harness\n", fp);
			fclose(fp);
			break;

		case 's':
			seconds = atoi(&s[i]);
			if (trace)
				printf("Sleeping for: %is\n", seconds);
			sleep(seconds);
			break;

		case 'f':
			if (trace)
				printf("Will return a failing exit code\n");
			exitCode = 1;
			break;

		case 'e':
			cmdline = strdup(&s[1]);
			unescape(cmdline);
			if (trace)
				printf("Running command: %s\n", cmdline);
			exec(cmdline);
			free(cmdline);
			break;

		default:
			printf("FAILED: Could not interpret command line: %s\n",
			    s);
			return 1;
		}
	}
	return exitCode;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movslq %edi, %r14
xorl %ebp, %ebp
pushq $0x1
popq %r15
pushq $0x1
popq %r12
cmpq %r14, %r15
jge 0x13b2
movq (%rbx,%r15,8), %rsi
movzbl (%rsi), %eax
cmpl $0x65, %eax
je 0x136f
movl %r12d, %ecx
cmpl $0x66, %eax
je 0x1397
cmpl $0x77, %eax
je 0x1341
cmpl $0x73, %eax
je 0x132d
cmpl $0x72, %eax
jne 0x13a1
incq %rsi
movq %rsi, %rdi
leaq 0xcf0(%rip), %rsi       # 0x2006
callq 0x1090
movq %rax, %r13
movq %r13, %rdi
callq 0x1070
cmpl $-0x1, %eax
jne 0x131e
jmp 0x1365
addq %r15, %rsi
movq %rsi, %rdi
callq 0x10c0
movl %eax, %edi
callq 0x10e0
jmp 0x1395
incq %rsi
movq %rsi, %rdi
leaq 0xcba(%rip), %rsi       # 0x2008
callq 0x1090
movq %rax, %r13
leaq 0xcad(%rip), %rdi       # 0x200a
movq %rax, %rsi
callq 0x1060
movq %r13, %rdi
callq 0x1040
jmp 0x1395
incq %rsi
movq %rsi, %rdi
callq 0x10d0
movq %rax, %r13
movq %rax, %rdi
callq 0x11fc
movq %r13, %rdi
callq 0x123a
movq %r13, %rdi
callq 0x1030
movl %ebp, %ecx
incq %r15
movl %ecx, %ebp
jmp 0x12d1
leaq 0xc7e(%rip), %rdi       # 0x2026
xorl %eax, %eax
callq 0x1050
pushq $0x1
popq %rbp
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_O2/sasairc[P]clangsay/src/libbenly/src/file.c
// Function: count_file_lines
int count_file_lines(FILE* fp)
{
    int     c       = 0;

    size_t  y       = 0;

    rewind(fp);
    while ((c = fgetc(fp)) != EOF) {
        if (c == '\n')
            y++;
    }

    return y;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1040
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0x1060
cmpl $-0x1, %eax
je 0x11af
cmpl $0xa, %eax
jne 0x1199
incl %ebp
jmp 0x1199
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sasairc[P]clangsay/src/libbenly/src/file.c
// Function: watch_fd
int watch_fd(int fd, long timeout)
{
    fd_set  fdset;

    struct  timeval tm;

    FD_ZERO(&fdset);
    FD_SET(fd, &fdset);

    tm.tv_sec = tm.tv_usec = timeout;

    return select(fd + 1, &fdset, NULL, NULL, &tm);
}

// Assembly:
subq $0x98, %rsp
xorl %eax, %eax
cmpq $0x10, %rax
je 0x1397
andq $0x0, 0x18(%rsp,%rax,8)
incq %rax
jmp 0x1386
pushq $0x40
popq %rcx
movl %edi, %eax
cltd
idivl %ecx
movslq %eax, %rdx
shll $0x6, %eax
movl %edi, %ecx
subl %eax, %ecx
pushq $0x1
popq %rax
shlq %cl, %rax
orq %rax, 0x18(%rsp,%rdx,8)
leaq 0x8(%rsp), %r8
movq %rsi, 0x8(%r8)
movq %rsi, (%r8)
incl %edi
leaq 0x18(%rsp), %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x1090
addq $0x98, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/trumabrat[P]GrandProjet/reseauMain.c
// Function: main
int main()
{
    // lecture et creation d'une instance de Chaines et de Reseau
    FILE* f = NULL;
    f = fopen("00014_burma.cha", "r");
    Chaines *c = lectureChaines(f);
    
    Reseau *R = reconstitueReseauListe(c);
    
    // affichage et l'enregistrement
    afficheChainesSVG(c, "chaineReseau");
    FILE* f2 = NULL;
    f2 = fopen("res.txt", "w");
    ecrireReseau(R, f2);
    
    afficheReseauSVG(R, "reso");

    //fermeture et liberation
    liberation_reseau(R);
    liberer_chaines(c);
    fclose(f);
    fclose(f2);
    
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x1344(%rip), %rdi      # 0x3313
leaq 0x134d(%rip), %rsi      # 0x3323
callq 0x10e0
movq %rax, %rbx
movq %rax, %rdi
callq 0x18d8
movq %rax, %r14
movq %rax, %rdi
callq 0x1384
movq %rax, %r15
leaq 0x132a(%rip), %rsi      # 0x3325
movq %r14, %rdi
callq 0x1af5
leaq 0x1328(%rip), %rdi      # 0x3332
leaq 0x1195(%rip), %rsi      # 0x31a6
callq 0x10e0
movq %rax, %r12
movq %r15, %rdi
movq %rax, %rsi
callq 0x1502
leaq 0x130f(%rip), %rsi      # 0x333a
movq %r15, %rdi
callq 0x16b1
movq %r15, %rdi
callq 0x18b9
movq %r14, %rdi
callq 0x1dc0
movq %rbx, %rdi
callq 0x1060
movq %r12, %rdi
callq 0x1060
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/MuvikLabs[P]runt/runt.c
// Function: runt_reinit
runt_int runt_reinit(runt_vm *vm)
{
    runt_init(vm);
    runt_cell_pool_set(vm, vm->cell_pool.cells, vm->cell_pool.size);
    runt_cell_pool_init(vm);
    runt_memory_pool_set(vm, vm->memory_pool.data, vm->memory_pool.size);
    return RUNT_OK;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x1294
andl $0x0, 0x51c(%rbx)
movq %rbx, %rdi
callq 0x14ba
movq 0x528(%rbx), %rdi
movl 0x530(%rbx), %edx
andq $0x0, 0x534(%rbx)
xorl %esi, %esi
callq 0x1090
pushq $0x1
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/MuvikLabs[P]runt/runt.c
// Function: runt_cell_pool_set
runt_int runt_cell_pool_set(runt_vm *vm, runt_cell *cells, runt_uint size)
{
    vm->cell_pool.cells = cells;
    vm->cell_pool.size = size;
    vm->cell_pool.used = 0;
    return RUNT_OK;
}

// Assembly:
movq %rsi, 0x510(%rdi)
movl %edx, 0x518(%rdi)
andl $0x0, 0x51c(%rdi)
pushq $0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/MuvikLabs[P]runt/runt.c
// Function: runt_cell_pool_init
runt_int runt_cell_pool_init(runt_vm *vm)
{
    runt_uint i;
    runt_cell *cells = vm->cell_pool.cells;

    for(i = 0; i < vm->cell_pool.size; i++) {
       runt_cell_clear(vm, &cells[i]);
    }
    vm->cell_pool.mark = 0;
    return RUNT_OK;
}

// Assembly:
movq 0x510(%rdi), %rax
leaq 0x1168(%rdi), %rcx
xorl %edx, %edx
leaq -0x146(%rip), %rsi      # 0x138b
movl 0x518(%rdi), %r8d
cmpq %r8, %rdx
jae 0x14fc
movq %rsi, (%rax)
movups (%rcx), %xmm0
movups %xmm0, 0x8(%rax)
movq 0x10(%rcx), %r8
movq %r8, 0x18(%rax)
andl $0x0, 0x20(%rax)
incq %rdx
addq $0x28, %rax
jmp 0x14d1
andl $0x0, 0x520(%rdi)
pushq $0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/MuvikLabs[P]runt/runt.c
// Function: runt_memory_pool_set
runt_int runt_memory_pool_set(runt_vm *vm, unsigned char *buf, runt_uint size)
{
    vm->memory_pool.data = buf;
    vm->memory_pool.size = size;
    vm->memory_pool.used = 0;
    vm->memory_pool.mark = 0;
    memset(buf, 0, size);
    return RUNT_OK;
}

// Assembly:
pushq %rax
movq %rsi, 0x528(%rdi)
movl %edx, 0x530(%rdi)
andq $0x0, 0x534(%rdi)
movl %edx, %edx
movq %rsi, %rdi
xorl %esi, %esi
callq 0x1090
pushq $0x1
popq %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/MuvikLabs[P]runt/runt.c
// Function: runt_load_minimal
runt_int runt_load_minimal(runt_vm *vm)
{
    /* create float type */
    runt_cell_malloc(vm, &vm->f_cell);
    runt_cell_bind(vm, vm->f_cell, rproc_float);

    /* create string type */
    runt_cell_malloc(vm, &vm->s_cell);
    runt_cell_bind(vm, vm->s_cell, rproc_string);

    /* ability to create procedures by default */
    runt_keyword_define_with_copy(vm, ":", 1, vm->zproc, rproc_begin, NULL);
    runt_keyword_define_with_copy(vm, ";", 1, vm->zproc, rproc_end, NULL);

    /* [ and ] for rec, stop */
    runt_keyword_define(vm, "[", 1, rproc_rec, NULL);
    runt_keyword_define_with_copy(vm, "]", 1, vm->zproc, rproc_stop, NULL);

    return RUNT_OK;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1180(%rdi), %rsi
callq 0x15fe
movq 0x1180(%rbx), %rax
leaq 0x107(%rip), %rcx       # 0x1655
movq %rcx, (%rax)
leaq 0x1188(%rbx), %rsi
movq %rbx, %rdi
callq 0x15fe
movq 0x1188(%rbx), %rax
leaq 0x120(%rip), %rcx       # 0x168e
movq %rcx, (%rax)
movq 0x1160(%rbx), %rcx
leaq 0x4be1(%rip), %rsi      # 0x6160
leaq 0x1bd(%rip), %r8        # 0x1743
pushq $0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %edx
xorl %r9d, %r9d
callq 0x16b1
movq 0x1160(%rbx), %rcx
leaq 0x4bbe(%rip), %rsi      # 0x6162
leaq 0x1ad(%rip), %r8        # 0x1758
movq %rbx, %rdi
movl %ebp, %edx
xorl %r9d, %r9d
callq 0x16b1
leaq 0x4ba5(%rip), %rsi      # 0x6164
leaq 0x1e8(%rip), %rcx       # 0x17ae
movq %rbx, %rdi
movl %ebp, %edx
xorl %r8d, %r8d
callq 0x179f
movq 0x1160(%rbx), %rcx
leaq 0x4b85(%rip), %rsi      # 0x6166
leaq 0x1d1(%rip), %r8        # 0x17b9
movq %rbx, %rdi
movl %ebp, %edx
xorl %r9d, %r9d
callq 0x16b1
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MuvikLabs[P]runt/runt.c
// Function: runt_cell_malloc
runt_int runt_cell_malloc(runt_vm *vm, runt_cell **cell)
{
    runt_uint id;
    id = runt_malloc(vm, sizeof(runt_cell), (void **)cell);
    if(id == 0) return RUNT_NOT_OK;
    runt_cell_clear(vm, *cell);
    (*cell)->id = 0;
    return RUNT_OK;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x28
popq %rsi
movq %rbx, %rdx
callq 0x19ad
testl %eax, %eax
je 0x164b
movq (%rbx), %rax
leaq -0x296(%rip), %rcx      # 0x138b
movq %rcx, (%rax)
movups 0x1168(%r14), %xmm0
movups %xmm0, 0x8(%rax)
movq 0x1178(%r14), %rcx
movq %rcx, 0x18(%rax)
andl $0x0, 0x20(%rax)
movq (%rbx), %rax
andl $0x0, 0x24(%rax)
pushq $0x1
popq %rax
jmp 0x164d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/MuvikLabs[P]runt/runt.c
// Function: rproc_float
static int rproc_float(runt_vm *vm, runt_ptr p)
{
    runt_stacklet *s;
    runt_float *f;
    runt_int rc;

    f = runt_to_float(p);
    rc = runt_ppush(vm, &s);
    RUNT_ERROR_CHECK(rc);

    s->f = *f;
    s->t = RUNT_FLOAT;
    return RUNT_OK;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq 0x28(%rsp), %rbx
leaq 0x8(%rsp), %rsi
callq 0x1cb0
testl %eax, %eax
je 0x1686
movss (%rbx), %xmm0
movq 0x8(%rsp), %rax
movss %xmm0, 0x20(%rax)
movl $0x1, (%rax)
pushq $0x1
popq %rax
jmp 0x1688
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/MuvikLabs[P]runt/runt.c
// Function: rproc_string
static int rproc_string(runt_vm *vm, runt_ptr p)
{
    runt_stacklet *s;

    s = runt_push(vm);
    s->p = p;
    s->t = RUNT_STRING;
    return RUNT_OK;
}

// Assembly:
pushq %rax
callq 0x1a2e
movaps 0x10(%rsp), %xmm0
movups %xmm0, 0x8(%rax)
movq 0x20(%rsp), %rcx
movq %rcx, 0x18(%rax)
movl $0x2, (%rax)
pushq $0x1
popq %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/MuvikLabs[P]runt/runt.c
// Function: runt_keyword_define_with_copy
runt_int runt_keyword_define_with_copy(runt_vm *vm,
        const char *name,
        runt_uint size,
        runt_proc proc,
        runt_copy_proc copy,
        runt_cell **pcell)
{
    runt_cell *cell;
    runt_entry *entry;
    runt_int rc;
    cell = NULL;
    entry = NULL;
    rc = runt_cell_malloc(vm, &cell);
    RUNT_ERROR_CHECK(rc);
    runt_cell_bind(vm, cell, proc);
    runt_entry_create(vm, cell, &entry);
    runt_entry_set_copy_proc(entry, copy);
    runt_word(vm, name, size, entry);
    if(pcell != NULL) *pcell = cell;
    return RUNT_OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %rbx
movq %r8, %r15
movq %rcx, %rbp
movl %edx, %r13d
movq %rsi, %r14
leaq 0x10(%rsp), %rsi
andq $0x0, (%rsi)
movq %rdi, %r12
andq $0x0, 0x8(%rsp)
callq 0x15fe
testl %eax, %eax
je 0x1732
movq %rbx, (%rsp)
movl %r13d, %ebx
movq 0x10(%rsp), %r13
movq %rbp, (%r13)
leaq 0x8(%rsp), %rbp
movq %r12, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x1e00
movq (%rbp), %rcx
movq %r15, 0x8(%rcx)
movq %r12, %rdi
movq %r14, %rsi
movl %ebx, %edx
movq (%rsp), %r14
callq 0x1e63
pushq $0x1
popq %rax
testq %r14, %r14
je 0x1734
movq %r13, (%r14)
jmp 0x1734
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MuvikLabs[P]runt/runt.c
// Function: rproc_end
static int rproc_end(runt_vm *vm, runt_cell *src, runt_cell *dst)
{
    runt_stacklet *s = runt_peak(vm);
    runt_cell *proc = runt_to_cell(s->p);
    runt_cell_undo(vm);
    proc->psize--;
    return runt_proc_end(vm);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x195f
movq 0x18(%rax), %rcx
movq %rcx, 0x10(%rsp)
movups 0x8(%rax), %xmm0
movups %xmm0, (%rsp)
callq 0x197a
movq %rax, %r14
movq %rbx, %rdi
callq 0x2bea
decl 0x20(%r14)
movq %rbx, %rdi
callq 0x1a65
pushq $0x1
popq %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/MuvikLabs[P]runt/runt.c
// Function: rproc_stop
static int rproc_stop(runt_vm *vm, runt_cell *src, runt_cell *dst)
{
    runt_cell_undo(vm);
    runt_set_state(vm, RUNT_MODE_INTERACTIVE, RUNT_ON);
    runt_mark_set(vm);
    return RUNT_OK;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x2bea
orb $0x2, 0x1158(%rbx)
movl 0x51c(%rbx), %eax
movl 0x534(%rbx), %ecx
movl %eax, 0x520(%rbx)
movl %ecx, 0x538(%rbx)
pushq $0x1
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/MuvikLabs[P]runt/runt.c
// Function: runt_cell_new
runt_uint runt_cell_new(runt_vm *vm, runt_cell **cell)
{
    runt_uint id;
    runt_cell_pool *pool = &vm->cell_pool;
    runt_cell *proc;
    runt_stacklet *s;

    pool->used++;

    if(runt_get_state(vm, RUNT_MODE_PANIC) == RUNT_ON) {
        return 0;
    }else if(pool->used >= pool->size) {
        runt_print(vm, "Oh dear. Runt cell pool space at maximum.\n");
        runt_set_state(vm, RUNT_MODE_PANIC, RUNT_ON);
        runt_set_state(vm, RUNT_MODE_RUNNING, RUNT_OFF);
        return 0;
    }

    if(vm->status & RUNT_MODE_PROC) {
        s = runt_peak(vm);
        proc = runt_to_cell(s->p);
        proc->psize++;
    }

    id = pool->used;
    *cell = &pool->cells[id - 1];
    (*cell)->id = id;
    return id;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl 0x51c(%rdi), %eax
incl %eax
movl %eax, 0x51c(%rdi)
movl 0x1158(%rdi), %ecx
xorl %ebp, %ebp
testb $0x20, %cl
jne 0x18c0
movq %rdi, %rbx
cmpl 0x518(%rdi), %eax
jae 0x189b
movq %rsi, %r14
testb $0x1, %cl
je 0x187e
movq %rbx, %rdi
callq 0x195f
movq 0x18(%rax), %rcx
movq %rcx, 0x10(%rsp)
movups 0x8(%rax), %xmm0
movups %xmm0, (%rsp)
callq 0x197a
incl 0x20(%rax)
movl 0x51c(%rbx), %eax
movq 0x510(%rbx), %rcx
leal -0x1(%rax), %edx
imulq $0x28, %rdx, %rdx
leaq (%rcx,%rdx), %rsi
movq %rsi, (%r14)
movl %eax, 0x24(%rcx,%rdx)
movl %eax, %ebp
jmp 0x18c0
leaq 0x48c6(%rip), %rsi      # 0x6168
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %eax, %eax
callq 0x18da
movl 0x1158(%rbx), %eax
andl $-0x29, %eax
orl $0x20, %eax
movl %eax, 0x1158(%rbx)
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MuvikLabs[P]runt/runt.c
// Function: runt_to_cell
runt_cell * runt_to_cell(runt_ptr p)
{
    runt_cell *cell = NULL;
    /* TODO: error handling */
    if(p.type == RUNT_CELL) {
        cell = (runt_cell *)p.ud;
    } else {
        fprintf(stderr, "Not a cell!\n");
    }
    return cell;
}

// Assembly:
pushq %rax
cmpl $0x6, 0x10(%rsp)
jne 0x198d
leaq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
popq %rcx
retq
movq 0x8664(%rip), %rax      # 0x9ff8
movq (%rax), %rcx
leaq 0x4816(%rip), %rdi      # 0x61b4
pushq $0xc
popq %rsi
pushq $0x1
popq %rdx
callq 0x1160
xorl %eax, %eax
jmp 0x198b
// File: /workspace/github_c_makefile_star2_O2/MuvikLabs[P]runt/runt.c
// Function: runt_proc_begin
runt_int runt_proc_begin(runt_vm *vm, runt_cell *proc)
{
    runt_stacklet *s = runt_push(vm);
    runt_set_state(vm, RUNT_MODE_PROC, RUNT_ON);
    s->p = runt_mk_ptr(RUNT_CELL, (void *)proc);
    return RUNT_OK;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1a2e
orb $0x1, 0x1158(%r14)
movl $0x6, 0x8(%rax)
movq %rbx, 0x10(%rax)
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/MuvikLabs[P]runt/runt.c
// Function: runt_push
runt_stacklet * runt_push(runt_vm *vm)
{
    /*TODO: wrapper for ppush */
    runt_stacklet *s;
   /*TODO: error handling for stack overflows */
    if(runt_stack_pos(vm, &vm->stack) == vm->stack.size) {
        runt_print(vm, "stack overflow!\n");
        s = &vm->stack.stack[0];
        return NULL;
    }

    runt_stack_inc(vm, &vm->stack);
    s = &vm->stack.stack[runt_stack_pos(vm, &vm->stack) - 1];
    return s;
}

// Assembly:
pushq %rbx
movslq 0x500(%rdi), %rax
cmpl 0x504(%rdi), %eax
jne 0x1a50
leaq 0x47bc(%rip), %rsi      # 0x6201
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x18da
jmp 0x1a60
leal 0x1(%rax), %ecx
movl %ecx, 0x500(%rdi)
imulq $0x28, %rax, %rbx
addq %rdi, %rbx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/MuvikLabs[P]runt/runt.c
// Function: runt_cell_exec
runt_int runt_cell_exec(runt_vm *vm, runt_cell *cell)
{
    runt_uint i;
    runt_int rc = RUNT_OK;

    if(cell == NULL) {
        runt_print(vm, "Could not execute. Cell is NULL\n");
        return RUNT_NOT_OK;
    }

    if(cell->psize == 0) {
        return runt_cell_call(vm, cell);
    }

    for(i = 1; i <= cell->psize; i++) {
        if(cell[i].psize == 0) {
            rc = runt_cell_call(vm, &cell[i]);
        } else {
            rc = runt_cell_exec(vm, &cell[i]);
        }
        RUNT_ERROR_CHECK(rc);
    }

    return rc;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
je 0x1b08
movq %rsi, %r14
cmpl $0x0, 0x20(%rsi)
je 0x1b1f
pushq $0x1
popq %r15
movl %r15d, %ebp
cmpl 0x20(%r14), %r15d
ja 0x1b1b
movl %r15d, %eax
imulq $0x28, %rax, %rax
leaq (%r14,%rax), %rsi
cmpl $0x0, 0x20(%r14,%rax)
je 0x1ade
movq %rbx, %rdi
callq 0x1a99
jmp 0x1afb
movq %rsi, 0x14b0(%rbx)
movq 0x18(%rsi), %rax
movq %rax, 0x10(%rsp)
movups 0x8(%rsi), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq *(%rsi)
movl %eax, %ebp
incl %r15d
testl %eax, %eax
jne 0x1abb
xorl %ebp, %ebp
jmp 0x1b1b
leaq 0x4684(%rip), %rsi      # 0x6193
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %eax, %eax
callq 0x18da
movl %ebp, %eax
jmp 0x1b3e
movq %r14, 0x14b0(%rbx)
movq 0x18(%r14), %rax
movq %rax, 0x10(%rsp)
movups 0x8(%r14), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq *(%r14)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MuvikLabs[P]runt/runt.c
// Function: runt_memory_pool_get
runt_int runt_memory_pool_get(runt_vm *vm, runt_uint id, void **ud)
{
    if(id > runt_memory_pool_size(vm)) {
        runt_print(vm, "Memory ID out of bounds!\n");
        return RUNT_NOT_OK;
    }
    if(id == 0) {
        runt_print(vm, "Memory ID has illegal value of zero.\n");
        return RUNT_NOT_OK;
    }
    *ud = &vm->memory_pool.data[id - 1];
    return RUNT_OK;
}

// Assembly:
pushq %rbx
cmpl %esi, 0x530(%rdi)
jae 0x1bfd
leaq 0x45c6(%rip), %rsi      # 0x61c1
jmp 0x1c19
testl %esi, %esi
je 0x1c12
decl %esi
addq 0x528(%rdi), %rsi
movq %rsi, (%rdx)
pushq $0x1
popq %rbx
jmp 0x1c22
leaq 0x45c2(%rip), %rsi      # 0x61db
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x18da
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/MuvikLabs[P]runt/runt.c
// Function: runt_mk_string
runt_ptr runt_mk_string(runt_vm *vm, const char *str, runt_uint size)
{
    runt_ptr p;
    char *buf;
    runt_uint i;
    runt_uint pos;

    buf = NULL;
    pos = runt_malloc(vm, size + 1, (void *)&buf);
    for(i = 0; i < size; i++) {
        buf[i] = str[i];
    }

    buf[size] = 0;

    p = runt_mk_ptr(RUNT_STRING, (void *)buf);
    p.pos = pos;

    return p;
}

// Assembly:
movq %rdi, %rax
leal 0x1(%rcx), %r9d
movl 0x530(%rsi), %edi
movl 0x534(%rsi), %r10d
leaq (%r10,%r9), %r8
cmpq %rdi, %r8
jae 0x1c74
movq %r10, %rdi
addq 0x528(%rsi), %rdi
leal 0x1(%r10), %r8d
addl %r10d, %r9d
movl %r9d, 0x534(%rsi)
jmp 0x1c79
xorl %edi, %edi
xorl %r8d, %r8d
movl %ecx, %ecx
xorl %esi, %esi
cmpq %rsi, %rcx
je 0x1c8f
movb (%rdx,%rsi), %r9b
movb %r9b, (%rdi,%rsi)
incq %rsi
jmp 0x1c7d
movb $0x0, (%rdi,%rcx)
movl $0x2, (%rax)
movq %rdi, 0x8(%rax)
movl %r8d, 0x10(%rax)
retq
// File: /workspace/github_c_makefile_star2_O2/MuvikLabs[P]runt/runt.c
// Function: runt_ppush
runt_int runt_ppush(runt_vm *vm, runt_stacklet **s)
{
   /*TODO: error handling for stack overflows */
    if(runt_stack_pos(vm, &vm->stack) == vm->stack.size) {
        runt_print(vm, "stack overflow!\n");
        *s = &vm->stack.stack[0];
        return RUNT_NOT_OK;
    }

    runt_stack_inc(vm, &vm->stack);
    *s = &vm->stack.stack[runt_stack_pos(vm, &vm->stack)- 1];
    return RUNT_OK;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movslq 0x500(%rdi), %rax
cmpl 0x504(%rdi), %eax
jne 0x1cde
leaq 0x4531(%rip), %rsi      # 0x6201
xorl %ebp, %ebp
movq %r14, %rdi
xorl %eax, %eax
callq 0x18da
jmp 0x1cf2
leal 0x1(%rax), %ecx
movl %ecx, 0x500(%r14)
imulq $0x28, %rax, %rax
addq %rax, %r14
pushq $0x1
popq %rbp
movq %r14, (%rbx)
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MuvikLabs[P]runt/runt.c
// Function: runt_ppeak
runt_int runt_ppeak(runt_vm *vm, runt_stacklet **s)
{
    /*TODO: error handling for stack underflows */
    if(runt_stack_pos(vm, &vm->stack) > 0) {
        *s = &vm->stack.stack[runt_stack_pos(vm, &vm->stack) - 1];
    } else {
        runt_print(vm, "Empty stack.\n");
        *s = &vm->stack.stack[0];
        return RUNT_NOT_OK;
    }

    return RUNT_OK;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x500(%rdi), %eax
testl %eax, %eax
jle 0x1d1e
decl %eax
imulq $0x28, %rax, %rax
addq %rax, %r14
pushq $0x1
popq %rbp
jmp 0x1d31
leaq 0x44ed(%rip), %rsi      # 0x6212
xorl %ebp, %ebp
movq %r14, %rdi
xorl %eax, %eax
callq 0x18da
movq %r14, (%rbx)
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MuvikLabs[P]runt/runt.c
// Function: runt_ppeakn
runt_int runt_ppeakn(runt_vm *vm, runt_stacklet **s, runt_int pos)
{
    *s = &vm->stack.stack[0];
    if(abs(pos) > runt_stack_bias_pos(vm, &vm->stack)) {
        runt_print(vm, "Invalid range %d\n", pos);
        return RUNT_NOT_OK;
    }

    if(pos >= 0) {
        *s = &vm->stack.stack[pos + vm->stack.bias];
    } else {
        *s = &vm->stack.stack[runt_stack_bias_pos(vm, &vm->stack) + pos];
    }
    return RUNT_OK;
}

// Assembly:
pushq %rbx
movq %rdi, (%rsi)
movl %edx, %r8d
negl %r8d
cmovsl %edx, %r8d
movl 0x508(%rdi), %eax
movl 0x500(%rdi), %ecx
addl %eax, %ecx
cmpl %ecx, %r8d
jle 0x1d6e
leaq 0x44bd(%rip), %rsi      # 0x6220
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x18da
jmp 0x1d84
testl %edx, %edx
cmovsl %ecx, %eax
addl %edx, %eax
cltq
imulq $0x28, %rax, %rax
addq %rax, %rdi
movq %rdi, (%rsi)
pushq $0x1
popq %rbx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/MuvikLabs[P]runt/runt.c
// Function: runt_ppop
runt_int  runt_ppop(runt_vm *vm, runt_stacklet **s)
{
    *s = &vm->stack.stack[0];

    if(runt_stack_pos(vm, &vm->stack) > 0) {
        runt_stack_dec(vm, &vm->stack);
        *s = &vm->stack.stack[runt_stack_pos(vm, &vm->stack)];
    } else {
        runt_print(vm, "Empty stack.\n");
        return RUNT_NOT_OK;
    }

    return RUNT_OK;
}

// Assembly:
pushq %rbx
movq %rdi, (%rsi)
movl 0x500(%rdi), %eax
testl %eax, %eax
jle 0x1dec
decl %eax
movl %eax, 0x500(%rdi)
imulq $0x28, %rax, %rax
addq %rdi, %rax
movq %rax, (%rsi)
pushq $0x1
popq %rbx
jmp 0x1dfc
leaq 0x441f(%rip), %rsi      # 0x6212
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x18da
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/MuvikLabs[P]runt/runt.c
// Function: runt_entry_create
runt_uint runt_entry_create(runt_vm *vm,
        runt_cell *cell,
        runt_entry **entry)
{
    runt_entry *e;
    runt_malloc(vm, sizeof(runt_entry), (void **)entry);
    e = *entry;
    e->copy = runt_cell_link;
    e->cell = cell;
    e->p = vm->nil;
    e->size = 0;
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x58
popq %rsi
callq 0x19ad
movq (%rbx), %rax
leaq -0x2c5(%rip), %rcx      # 0x1b5b
movq %rcx, 0x8(%rax)
movq %r14, (%rax)
movq 0x1178(%r15), %rcx
movq %rcx, 0x20(%rax)
movups 0x1168(%r15), %xmm0
movups %xmm0, 0x10(%rax)
andl $0x0, 0x28(%rax)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/MuvikLabs[P]runt/runt.c
// Function: runt_word
runt_int runt_word(runt_vm *vm,
        const char *name,
        runt_int size,
        runt_entry *entry)
{
    entry->p = runt_mk_string(vm, name, size);
    return runt_word_dict(vm,
                          name,
                          size,
                          entry,
                          runt_dictionary_get(vm));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x1c3d
movq 0x10(%r12), %rax
movq %rax, 0x20(%rbx)
movups (%r12), %xmm0
movups %xmm0, 0x10(%rbx)
movq 0x540(%r15), %r8
movq %r14, %rsi
movl %ebp, %edx
movq %rbx, %rcx
callq 0x1ec5
pushq $0x1
popq %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MuvikLabs[P]runt/runt.c
// Function: runt_word_dict
runt_int runt_word_dict(runt_vm *vm,
        const char *name,
        runt_int size,
        runt_entry *entry,
        runt_dict *dict)
{
    runt_uint pos;
    runt_list *list;

    pos = runt_hash(name, size);
    list = &dict->list[pos];

    entry->size = size;

    runt_list_append(list, entry);

    dict->nwords++;
    return RUNT_OK;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %rdi
movl %edx, %esi
callq 0x1f07
movl %eax, %eax
imulq $0x18, %rax, %rax
leaq (%rbx,%rax), %rdi
addq $0x8, %rdi
movl %ebp, 0x28(%r14)
movq %r14, %rsi
callq 0x1f37
incl (%rbx)
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MuvikLabs[P]runt/runt.c
// Function: runt_hash
static runt_uint runt_hash(const char *str, runt_int size)
{
    runt_uint h = 5381;
    runt_int i = 0;

    for(i = 0; i < size; i++) {
        h = ((h << 5) + h) ^ str[i];
        h %= 0x7FFFFFFF;
    }

    return h % RUNT_DICT_SIZE;
}

// Assembly:
xorl %ecx, %ecx
testl %esi, %esi
cmovlel %ecx, %esi
movl $0x1505, %edx           # imm = 0x1505
movl $0x7fffffff, %r8d       # imm = 0x7FFFFFFF
cmpq %rcx, %rsi
je 0x1f31
imull $0x21, %edx, %edx
movsbl (%rdi,%rcx), %eax
xorl %edx, %eax
xorl %edx, %edx
divl %r8d
incq %rcx
jmp 0x1f19
andl $0x7f, %edx
movl %edx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/MuvikLabs[P]runt/runt.c
// Function: runt_list_append
runt_int runt_list_append(runt_list *lst, runt_entry *ent)
{
    if(lst->size == 0) {
        lst->top = ent;
        lst->last = lst->top;
    } else {
        lst->last->next = ent;
    }
    ent->prev = lst->last;
    lst->last = ent;
    lst->size++;
    ent->list = lst;
    return RUNT_OK;
}

// Assembly:
movl (%rdi), %eax
testl %eax, %eax
je 0x1f47
movq 0x10(%rdi), %rdx
leaq 0x40(%rdx), %rcx
jmp 0x1f4e
leaq 0x8(%rdi), %rcx
movq %rsi, %rdx
movq %rsi, (%rcx)
movq %rdx, 0x48(%rsi)
movq %rsi, 0x10(%rdi)
incl %eax
movl %eax, (%rdi)
movq %rdi, 0x38(%rsi)
pushq $0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/MuvikLabs[P]runt/runt.c
// Function: runt_word_search_dict
runt_int runt_word_search_dict(runt_vm *vm,
        const char *name,
        runt_int size,
        runt_entry **entry,
        runt_dict *dict)
{
    runt_uint pos;
    runt_list *list;

    runt_uint i;
    runt_entry *ent;
    runt_entry *next;

    pos = runt_hash(name, size);
    list = &dict->list[pos];

    ent = runt_list_top(list);

    for(i = 0; i < list->size; i++) {
        next = ent->next;
        if(runt_strncmp(vm, name, size, ent) == 0) {
            *entry = ent;
            return RUNT_OK;
        }
        ent = next;
    }

    return RUNT_NOT_OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, (%rsp)
movl %edx, %ebp
movq %rsi, %r14
movq %rsi, %rdi
movl %edx, %esi
callq 0x1f07
movl %eax, %eax
imulq $0x18, %rax, %rax
movq 0x10(%rbx,%rax), %r15
movl 0x8(%rbx,%rax), %r13d
movslq %ebp, %r12
subl $0x1, %r13d
jb 0x1fe0
movq %r15, %rbx
movq 0x40(%r15), %r15
cmpl %ebp, 0x28(%rbx)
jne 0x1fa5
cmpl $0x2, 0x10(%rbx)
jne 0x1fc3
movq 0x18(%rbx), %rsi
jmp 0x1fc5
xorl %esi, %esi
movq %r14, %rdi
movq %r12, %rdx
callq 0x1050
testl %eax, %eax
jne 0x1fa5
movq (%rsp), %rax
movq %rbx, (%rax)
pushq $0x1
popq %rax
jmp 0x1fe2
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MuvikLabs[P]runt/runt.c
// Function: runt_list_pop
runt_int runt_list_pop(runt_vm *vm, runt_list *lst)
{
    if(lst->size == 0) {
        runt_print(vm, "No items on the list to pop off");
        return RUNT_NOT_OK;
    } else if(lst->size == 1) {
        lst->size = 0;
        return RUNT_OK;
    }

    lst->size--;
    lst->last = lst->last->prev;
    return RUNT_OK;
}

// Assembly:
pushq %rbx
movl (%rsi), %eax
cmpl $0x1, %eax
je 0x2014
testl %eax, %eax
jne 0x2019
leaq 0x4229(%rip), %rsi      # 0x6232
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x18da
jmp 0x202c
andl $0x0, (%rsi)
jmp 0x2029
decl %eax
movl %eax, (%rsi)
movq 0x10(%rsi), %rax
movq 0x48(%rax), %rax
movq %rax, 0x10(%rsi)
pushq $0x1
popq %rbx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/MuvikLabs[P]runt/runt.c
// Function: runt_list_prepend
runt_int runt_list_prepend(runt_list *lst, runt_entry *ent)
{
    if(lst->size > 0) {
        ent->next = lst->top;
    }
    lst->top = ent;
    lst->size++;
    return RUNT_OK;
}

// Assembly:
movl (%rdi), %eax
testl %eax, %eax
jle 0x203e
movq 0x8(%rdi), %rcx
movq %rcx, 0x40(%rsi)
movq %rsi, 0x8(%rdi)
incl %eax
movl %eax, (%rdi)
pushq $0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/MuvikLabs[P]runt/runt.c
// Function: runt_list_append_ptr
runt_int runt_list_append_ptr(runt_vm *vm, runt_list *lst, runt_ptr p)
{
    runt_entry *entry;
    entry = NULL;
    /* make entry, using empty cell */
    runt_entry_create(vm, &vm->empty, &entry);
    /* set ptr to "string" entry in struct. works better than it looks */
    entry->p = p;

    runt_list_append(lst, entry);
    return RUNT_OK;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rsp, %r14
andq $0x0, (%r14)
leaq 0x1190(%rdi), %rsi
movq %r14, %rdx
callq 0x1e00
movq (%r14), %rsi
movaps 0x20(%rsp), %xmm0
movups %xmm0, 0x10(%rsi)
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsi)
movq %rbx, %rdi
callq 0x1f37
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/MuvikLabs[P]runt/runt.c
// Function: runt_list_append_cell
runt_int runt_list_append_cell(runt_vm *vm, runt_list *lst, runt_cell *cell)
{
    runt_entry *entry;
    entry = NULL;
    runt_entry_create(vm, cell, &entry);
    runt_list_append(lst, entry);
    return RUNT_OK;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rsp, %r14
andq $0x0, (%r14)
movq %rdx, %rsi
movq %r14, %rdx
callq 0x1e00
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x1f37
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/MuvikLabs[P]runt/runt.c
// Function: runt_list_prepend_cell
runt_int runt_list_prepend_cell(runt_vm *vm, runt_list *lst, runt_cell *cell)
{
    runt_entry *entry;
    entry = NULL;
    runt_entry_create(vm, cell, &entry);
    runt_list_prepend(lst, entry);
    return RUNT_OK;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rsp, %r14
andq $0x0, (%r14)
movq %rdx, %rsi
movq %r14, %rdx
callq 0x1e00
movq (%r14), %rcx
movl (%rbx), %eax
testl %eax, %eax
jle 0x20e8
movq 0x8(%rbx), %rdx
movq %rdx, 0x40(%rcx)
movq %rcx, 0x8(%rbx)
incl %eax
movl %eax, (%rbx)
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/MuvikLabs[P]runt/runt.c
// Function: runt_dict_init
void runt_dict_init(runt_vm *vm, runt_dict *dict)
{
    runt_uint i;
    dict->nwords = 0;
    for(i = 0; i < RUNT_DICT_SIZE; i++) {
        runt_list_init(&dict->list[i]);
    }
    dict->last = dict;
}

// Assembly:
andl $0x0, (%rsi)
pushq $0x8
popq %rax
cmpq $0xc08, %rax            # imm = 0xC08
je 0x212c
andl $0x0, (%rsi,%rax)
addq $0x18, %rax
jmp 0x211a
movq %rsi, 0xc08(%rsi)
retq