LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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
subq $0x18, %rsp
callq 0x4900
callq 0x14376
movq %rax, %rbx
movq %rax, %rdi
callq 0x14578
leaq -0x76(%rip), %rsi       # 0x4a1a
movq %rbx, %rdi
xorl %edx, %edx
callq 0x5541
leaq 0x1b5e2(%rip), %rsi     # 0x20083
movq %rbx, %rdi
callq 0x5977
leaq 0x1b5dd(%rip), %rsi     # 0x2008d
movq %rbx, %rdi
xorl %edx, %edx
callq 0x13ae9
testl %eax, %eax
jne 0x4ad5
movq %rbx, %rdi
xorl %esi, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x5e3a
leaq 0x1b5ba(%rip), %rsi     # 0x20096
movq %rbx, %rdi
xorl %edx, %edx
callq 0x13ae9
testl %eax, %eax
jne 0x4b01
movq %rbx, %rdi
xorl %esi, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x5e3a
leaq 0x1b59b(%rip), %r14     # 0x200a3
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5977
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4d01
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5610
leaq 0x1b57c(%rip), %rdx     # 0x200ab
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x5727
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x5dd2
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5610
leaq -0x2c(%rbp), %r14
leaq 0x1bf91(%rip), %r15     # 0x20af4
leaq -0x40(%rbp), %r12
movq %r14, %rdi
callq 0x4811
cmpl $0x1b, %eax
je 0x4bd0
movl %eax, %r13d
cmpl $0x71, %eax
je 0x4bd0
cmpl $0x51, %r13d
je 0x4bd0
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %r15, %rdx
callq 0x5727
movl -0x2c(%rbp), %edx
movq %rbx, %rdi
movl %r13d, %esi
callq 0x498e
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x5dd2
movq $0x0, -0x40(%rbp)
movq $0xf42400, -0x38(%rbp)  # imm = 0xF42400
movq %r12, %rdi
xorl %esi, %esi
callq 0x41a0
jmp 0x4b67
callq 0x4935
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0x1237
movb %sil, (%rdi,%rax)
jmp 0x1230
movb 0x1(%rdi,%rdx), %sil
cmpb $0x23, %sil
jne 0x122c
incq %rdx
movb %sil, (%rdi,%rax)
movl %edx, %ecx
jmp 0x1230
movb $0x20, (%rdi,%rax)
incq %rax
incl %ecx
jmp 0x1200
movl %eax, %eax
movb $0x0, (%rdi,%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x1f58, %rsp           # imm = 0x1F58
leaq 0xdb5(%rip), %rbx       # 0x2004
movq %rbx, %rsi
callq 0x10a0
movq %rax, 0x10(%rsp)
movl $0x1, %r14d
xorl %edi, %edi
movq %rbx, %rsi
callq 0x10a0
movq %rax, 0x10(%rsp,%r14,8)
testq %rax, %rax
je 0x1286
leaq 0x1(%r14), %rax
cmpq $0x3e7, %r14            # imm = 0x3E7
movq %rax, %r14
jne 0x1262
callq 0x10f0
movl %eax, %ebx
testl %eax, %eax
jne 0x129e
leaq 0x10(%rsp), %rsi
movq (%rsi), %rdi
callq 0x10b0
leaq 0xc(%rsp), %rsi
movl %ebx, %edi
xorl %edx, %edx
callq 0x1080
addq $0x1f58, %rsp           # imm = 0x1F58
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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:
xorl %eax, %eax
cmpl $0x2, %edi
jl 0x13eb
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %r14d
movl $0x0, 0x4(%rsp)
movl $0x1, %r15d
xorl %r12d, %r12d
movq (%rbx,%r15,8), %rsi
movzbl (%rsi), %ecx
movb $0x1, %r13b
cmpl $0x71, %ecx
jle 0x132a
cmpl $0x77, %ecx
je 0x1358
cmpl $0x73, %ecx
je 0x1386
cmpl $0x72, %ecx
jne 0x133d
incq %rsi
movq %rsi, %rdi
leaq 0xcf3(%rip), %rsi       # 0x2006
callq 0x1090
movq %rax, %rbp
movq %rbp, %rdi
callq 0x1070
cmpl $-0x1, %eax
jne 0x131b
jmp 0x137c
cmpl $0x65, %ecx
je 0x139a
movl $0x1, %eax
cmpl $0x66, %ecx
je 0x13c3
xorl %r13d, %r13d
leaq 0xcdf(%rip), %rdi       # 0x2026
xorl %eax, %eax
callq 0x1050
movl $0x1, 0x4(%rsp)
jmp 0x13c0
incq %rsi
movq %rsi, %rdi
leaq 0xca3(%rip), %rsi       # 0x2008
callq 0x1090
movq %rax, %rbp
leaq 0xc96(%rip), %rdi       # 0x200a
movq %rax, %rsi
callq 0x1060
movq %rbp, %rdi
callq 0x1040
jmp 0x13c0
addq %r15, %rsi
movq %rsi, %rdi
callq 0x10c0
movl %eax, %edi
callq 0x10e0
jmp 0x13c0
incq %rsi
movq %rsi, %rdi
callq 0x10d0
movq %rax, %rbp
movq %rax, %rdi
callq 0x11fc
movq %rbp, %rdi
callq 0x123e
movq %rbp, %rdi
callq 0x1030
movl %r12d, %eax
testb %r13b, %r13b
je 0x13d9
incq %r15
movl %eax, %r12d
cmpq %r14, %r15
jne 0x12e4
jmp 0x13dd
movl 0x4(%rsp), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1040
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x1060
cmpl $-0x1, %eax
je 0x11a2
cmpl $0xa, %eax
jne 0x118b
incq %r14
jmp 0x118b
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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
movq %rsi, %rax
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, 0x20(%rsi)
movaps %xmm0, 0x30(%rsi)
movaps %xmm0, 0x40(%rsi)
movaps %xmm0, 0x50(%rsi)
movaps %xmm0, 0x60(%rsi)
movaps %xmm0, 0x70(%rsi)
leal 0x3f(%rdi), %edx
testl %edi, %edi
cmovnsl %edi, %edx
movl %edx, %r8d
andl $-0x40, %r8d
movl %edi, %ecx
subl %r8d, %ecx
movl $0x1, %r8d
shlq %cl, %r8
sarl $0x6, %edx
movslq %edx, %rcx
orq %r8, 0x10(%rsp,%rcx,8)
movq %rsp, %r8
movq %rax, 0x8(%r8)
movq %rax, (%r8)
incl %edi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x1080
addq $0x98, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/ramirezsebas[P]TP-LISTINGS/./src/capitulo_2/2.4/client.c
// Function: main
int main (){
  char* server_name = getenv ("SERVER_NAME");
  if (server_name == NULL)
    /* The SERVER_NAME environment variable was not set. Use the
     default. */
    server_name = "server.my-company.com";
  printf ("accessing server %s\n", server_name);
  /* Access the server here... */
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xead(%rip), %rdi       # 0x2004
callq 0x1030
testq %rax, %rax
leaq 0xeaa(%rip), %rsi       # 0x2010
cmovneq %rax, %rsi
leaq 0xeb5(%rip), %rdi       # 0x2026
xorl %eax, %eax
callq 0x1040
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1044(%rip), %rdi      # 0x3303
leaq 0x104d(%rip), %rsi      # 0x3313
callq 0x10e0
movq %rax, %rbx
movq %rax, %rdi
callq 0x1a40
movq %rax, %r14
movq %rax, %rdi
callq 0x1401
movq %rax, %r15
leaq 0x102a(%rip), %rsi      # 0x3315
movq %r14, %rdi
callq 0x1c82
leaq 0x1028(%rip), %rdi      # 0x3322
leaq 0xe95(%rip), %rsi       # 0x3196
callq 0x10e0
movq %rax, %r12
movq %r15, %rdi
movq %rax, %rsi
callq 0x15bb
leaq 0x100f(%rip), %rsi      # 0x332a
movq %r15, %rdi
callq 0x17ad
movq %r15, %rdi
callq 0x1a21
movq %r14, %rdi
callq 0x209a
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_O1/MuvikLabs[P]runt/runt.c
// Function: runt_init
runt_int runt_init(runt_vm *vm)
{
    vm->status = 0;
    vm->zproc = runt_proc_zero;
    vm->nil = runt_mk_ptr(RUNT_NIL, NULL);

    /* init stack */

    runt_stack_init(vm, &vm->stack);

    /* init dictionary */

    runt_dictionary_init(vm);

    /* record cells being parsed by default */

    runt_set_state(vm, RUNT_MODE_INTERACTIVE, RUNT_OFF);
    runt_set_state(vm, RUNT_MODE_RUNNING, RUNT_ON);

    vm->level = 0;
    vm->pos = 0;

    /* set print output to STDERR by default */
    vm->fp = stderr;

    /* set up plugin handle list */
    runt_list_init(&vm->plugins);

    vm->nwords = 0;
    vm->loader = load_nothing;

    runt_cell_bind(vm, &vm->empty, vm->zproc);
    runt_cell_data(vm, &vm->empty, vm->nil);

    runt_print_set(vm, runt_print_default);

    /* set up destructor list */
    runt_list_init(&vm->dtors);

    /* set up registers */
    runt_registers_init(vm);

    vm->anon = NULL;

    vm->last_cell_called = &vm->empty;

    return RUNT_OK;
}

// Assembly:
xorl %edx, %edx
movl %edx, 0x1158(%rdi)
leaq 0x13c(%rip), %rcx       # 0x1493
movq %rcx, 0x1160(%rdi)
leaq 0x1168(%rdi), %rax
movl %edx, 0x1168(%rdi)
movq $0x0, 0x1170(%rdi)
movabsq $0x2000000000, %rsi     # imm = 0x2000000000
movq %rsi, 0x500(%rdi)
movl %edx, 0x508(%rdi)
leaq 0x548(%rdi), %rsi
movq 0x540(%rdi), %r8
movq %r8, 0x1150(%rdi)
movq %rsi, 0x540(%rdi)
movl %edx, 0x548(%rdi)
movl $0x0, 0x550(%rdi,%rdx)
addq $0x18, %rdx
cmpq $0xc00, %rdx            # imm = 0xC00
jne 0x13af
movq %rsi, 0x1150(%rdi)
movl $0x8, 0x1158(%rdi)
movq $0x0, 0x11b8(%rdi)
movq 0x9c0e(%rip), %rdx      # 0xaff8
movq (%rdx), %rdx
movq %rdx, 0x11d8(%rdi)
xorl %edx, %edx
movl %edx, 0x11c0(%rdi)
movl %edx, 0x11f8(%rdi)
leaq 0x127(%rip), %rsi       # 0x1530
movq %rsi, 0x1200(%rdi)
leaq 0x1190(%rdi), %rsi
movq %rcx, 0x1190(%rdi)
movups (%rax), %xmm0
movups %xmm0, 0x1198(%rdi)
movq 0x10(%rax), %rcx
movq %rcx, 0x11a8(%rdi)
leaq 0x125(%rip), %rcx       # 0x155f
movq %rcx, 0x1208(%rdi)
movl %edx, 0x1210(%rdi)
leaq 0x1228(%rdi), %rcx
movl $0x1, (%rcx,%rdx)
movl $0x0, 0x20(%rcx,%rdx)
movups (%rax), %xmm0
movups %xmm0, 0x8(%rcx,%rdx)
movq 0x10(%rax), %r8
movq %r8, 0x18(%rcx,%rdx)
addq $0x28, %rdx
cmpq $0x280, %rdx            # imm = 0x280
jne 0x144e
movq $0x0, 0x14a8(%rdi)
movq %rsi, 0x14b0(%rdi)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1348
movq 0x510(%rbx), %rax
movl $0x0, 0x51c(%rbx)
cmpl $0x0, 0x518(%rbx)
je 0x1607
leaq 0x1168(%rbx), %rcx
xorl %edx, %edx
leaq -0x149(%rip), %rsi      # 0x1493
movq %rsi, (%rax)
movups (%rcx), %xmm0
movups %xmm0, 0x8(%rax)
movq 0x10(%rcx), %rdi
movq %rdi, 0x18(%rax)
movl $0x0, 0x20(%rax)
incq %rdx
movl 0x518(%rbx), %edi
addq $0x28, %rax
cmpq %rdi, %rdx
jb 0x15dc
movl $0x0, 0x520(%rbx)
movq 0x528(%rbx), %rdi
movl 0x530(%rbx), %edx
movq $0x0, 0x534(%rbx)
xorl %esi, %esi
callq 0x1090
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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:
cmpl $0x0, 0x518(%rdi)
je 0x16a0
movq 0x510(%rdi), %rax
leaq 0x1168(%rdi), %rcx
xorl %edx, %edx
leaq -0x1e1(%rip), %rsi      # 0x1493
movq %rsi, (%rax)
movups (%rcx), %xmm0
movups %xmm0, 0x8(%rax)
movq 0x10(%rcx), %r8
movq %r8, 0x18(%rax)
movl $0x0, 0x20(%rax)
incq %rdx
movl 0x518(%rdi), %r8d
addq $0x28, %rax
cmpq %r8, %rdx
jb 0x1674
movl $0x0, 0x520(%rdi)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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)
movq $0x0, 0x534(%rdi)
movl %edx, %edx
movq %rsi, %rdi
xorl %esi, %esi
callq 0x1090
movl $0x1, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movl 0x530(%rdi), %eax
movl 0x534(%rdi), %ecx
leaq 0x28(%rcx), %rdx
cmpq %rax, %rdx
jae 0x1748
movq 0x528(%rbx), %rax
addq %rcx, %rax
movq %rax, 0x1180(%rbx)
leal 0x28(%rcx), %edx
movl %edx, 0x534(%rbx)
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
cmpq %rdx, %rcx
je 0x1748
leaq -0x28d(%rip), %rcx      # 0x1493
movq %rcx, (%rax)
movups 0x1168(%rbx), %xmm0
movups %xmm0, 0x8(%rax)
movq 0x1178(%rbx), %rcx
movq %rcx, 0x18(%rax)
xorl %ecx, %ecx
movl %ecx, 0x20(%rax)
movq 0x1180(%rbx), %rax
movl %ecx, 0x24(%rax)
movq 0x1180(%rbx), %rax
leaq 0x182(%rip), %rcx       # 0x18d8
movq %rcx, (%rax)
movl 0x530(%rbx), %eax
movl 0x534(%rbx), %ecx
leaq 0x28(%rcx), %rdx
cmpq %rax, %rdx
jae 0x17c1
movq 0x528(%rbx), %rax
addq %rcx, %rax
movq %rax, 0x1188(%rbx)
leal 0x28(%rcx), %edx
movl %edx, 0x534(%rbx)
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
cmpq %rdx, %rcx
je 0x17c1
leaq -0x306(%rip), %rcx      # 0x1493
movq %rcx, (%rax)
movups 0x1168(%rbx), %xmm0
movups %xmm0, 0x8(%rax)
movq 0x1178(%rbx), %rcx
movq %rcx, 0x18(%rax)
xorl %ecx, %ecx
movl %ecx, 0x20(%rax)
movq 0x1188(%rbx), %rax
movl %ecx, 0x24(%rax)
movq 0x1188(%rbx), %rax
leaq 0x176(%rip), %rcx       # 0x1945
movq %rcx, (%rax)
movq 0x1160(%rbx), %rcx
leaq 0x5980(%rip), %rsi      # 0x7160
leaq 0x296(%rip), %r8        # 0x1a7d
movq %rbx, %rdi
movl $0x1, %edx
xorl %r9d, %r9d
callq 0x1994
movq 0x1160(%rbx), %rcx
leaq 0x595d(%rip), %rsi      # 0x7162
leaq 0x288(%rip), %r8        # 0x1a94
movq %rbx, %rdi
movl $0x1, %edx
xorl %r9d, %r9d
callq 0x1994
leaq 0x5941(%rip), %rsi      # 0x7164
leaq 0x343(%rip), %rcx       # 0x1b6d
leaq 0x7ba(%rip), %r8        # 0x1feb
movq %rbx, %rdi
movl $0x1, %edx
xorl %r9d, %r9d
callq 0x1994
movq 0x1160(%rbx), %rcx
leaq 0x5917(%rip), %rsi      # 0x7166
leaq 0x324(%rip), %r8        # 0x1b7a
movq %rbx, %rdi
movl $0x1, %edx
xorl %r9d, %r9d
callq 0x1994
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/MuvikLabs[P]runt/runt.c
// Function: runt_cell_malloc
runt_uint runt_malloc(runt_vm *vm, size_t size, void **ud)
{

    runt_memory_pool *pool = &vm->memory_pool;
    runt_uint id = 0;

#ifdef ALIGNED_MALLOC
    if(size % 4 != 0) {
        size = ((size/4) + 1) * 4;
    }
#endif

    /* TODO: overload error handling */
    if(pool->used + size >= pool->size) {
        return 0;
    }

    *ud = (void *)&pool->data[pool->used];

    id = pool->used + 1;
    pool->used += size;

    return id;
}

// Assembly:
movl 0x530(%rdi), %edx
movl 0x534(%rdi), %ecx
leaq 0x28(%rcx), %r8
xorl %eax, %eax
cmpq %rdx, %r8
jae 0x18d7
movq 0x528(%rdi), %rdx
addq %rcx, %rdx
movq %rdx, (%rsi)
leal 0x28(%rcx), %edx
movl %edx, 0x534(%rdi)
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
cmpq %rdx, %rcx
je 0x18d7
movq (%rsi), %rax
leaq -0x41b(%rip), %rcx      # 0x1493
movq %rcx, (%rax)
movups 0x1168(%rdi), %xmm0
movups %xmm0, 0x8(%rax)
movq 0x1178(%rdi), %rcx
movq %rcx, 0x18(%rax)
xorl %ecx, %ecx
movl %ecx, 0x20(%rax)
movq (%rsi), %rax
movl %ecx, 0x24(%rax)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x38(%rsp), %r14
movslq 0x500(%rdi), %r15
movl 0x504(%rdi), %ebp
cmpl %ebp, %r15d
jne 0x190c
leaq 0x5901(%rip), %rsi      # 0x7201
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1cfe
jmp 0x191e
leal 0x1(%r15), %eax
movl %eax, 0x500(%rbx)
leaq (%r15,%r15,4), %rax
leaq (%rbx,%rax,8), %rbx
xorl %eax, %eax
cmpl %ebp, %r15d
je 0x193a
movss (%r14), %xmm0
movss %xmm0, 0x20(%rbx)
movl $0x1, (%rbx)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movslq 0x500(%rdi), %rax
cmpl 0x504(%rdi), %eax
je 0x1986
leaq 0x10(%rsp), %rcx
leal 0x1(%rax), %edx
movl %edx, 0x500(%rdi)
leaq (%rax,%rax,4), %rax
movq 0x10(%rcx), %rdx
movq %rdx, 0x18(%rdi,%rax,8)
movups (%rcx), %xmm0
movups %xmm0, 0x8(%rdi,%rax,8)
movl $0x2, (%rdi,%rax,8)
movl $0x1, %eax
popq %rcx
retq
leaq 0x5874(%rip), %rsi      # 0x7201
xorl %eax, %eax
callq 0x1cfe
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %r9, %rbx
movl 0x530(%rdi), %r11d
movl 0x534(%rdi), %r10d
leaq 0x28(%r10), %r14
movb $0x1, %r9b
xorl %eax, %eax
cmpq %r11, %r14
jae 0x1a05
movq 0x528(%rdi), %r14
addq %r10, %r14
leal 0x28(%r10), %r11d
movl %r11d, 0x534(%rdi)
movl $0xffffffff, %r11d      # imm = 0xFFFFFFFF
cmpq %r11, %r10
je 0x1a08
leaq -0x54b(%rip), %r9       # 0x1493
movq %r9, (%r14)
movups 0x1168(%rdi), %xmm0
movups %xmm0, 0x8(%r14)
movq 0x1178(%rdi), %r9
movq %r9, 0x18(%r14)
movq $0x0, 0x20(%r14)
xorl %r9d, %r9d
jmp 0x1a08
xorl %r14d, %r14d
testb %r9b, %r9b
jne 0x1a75
movq %rcx, (%r14)
movl 0x534(%rdi), %eax
movq 0x528(%rdi), %r9
leaq (%r9,%rax), %rcx
leal 0x58(%rax), %r10d
movl %r10d, 0x534(%rdi)
leaq 0x5b8(%rip), %r10       # 0x1feb
movq %r10, 0x8(%r9,%rax)
movq %r14, (%r9,%rax)
movups 0x1168(%rdi), %xmm0
movups %xmm0, 0x10(%r9,%rax)
movq 0x1178(%rdi), %r10
movq %r10, 0x20(%r9,%rax)
movl $0x0, 0x28(%r9,%rax)
movq %r8, 0x8(%r9,%rax)
callq 0x2313
movl $0x1, %eax
testq %rbx, %rbx
je 0x1a75
movq %r14, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movslq 0x500(%rdi), %rax
testq %rax, %rax
jle 0x1ab2
leaq (%rax,%rax,4), %rax
leaq (%rbx,%rax,8), %rax
addq $-0x28, %rax
jmp 0x1ac6
leaq 0x5759(%rip), %rsi      # 0x7212
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1cfe
movq %rbx, %rax
cmpl $0x6, 0x8(%rax)
jne 0x1b52
movq 0x10(%rax), %rax
movl 0x51c(%rbx), %ecx
testl %ecx, %ecx
je 0x1b1c
decl %ecx
movl %ecx, 0x51c(%rbx)
movq 0x510(%rbx), %rdx
leaq (%rcx,%rcx,4), %rcx
leaq -0x665(%rip), %rsi      # 0x1493
movq %rsi, (%rdx,%rcx,8)
movups 0x1168(%rbx), %xmm0
movups %xmm0, 0x8(%rdx,%rcx,8)
movq 0x1178(%rbx), %rsi
movq %rsi, 0x18(%rdx,%rcx,8)
movl $0x0, 0x20(%rdx,%rcx,8)
decl 0x20(%rax)
movl 0x500(%rbx), %eax
testl %eax, %eax
jle 0x1b33
decl %eax
movl %eax, 0x500(%rbx)
jmp 0x1b44
leaq 0x56d8(%rip), %rsi      # 0x7212
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1cfe
andb $-0x2, 0x1158(%rbx)
movl $0x1, %eax
popq %rbx
retq
callq 0x1190
xorl %eax, %eax
jmp 0x1ad4
// File: /workspace/github_c_makefile_star2_O1/MuvikLabs[P]runt/runt.c
// Function: runt_cell_undo
runt_int runt_cell_undo(runt_vm *vm)
{
    runt_cell_pool *pool = &vm->cell_pool;
    runt_cell *cell;

    if(pool->used == 0) {
        return RUNT_NOT_OK;
    }

    pool->used--;
    /* id is N - 1 */
    cell = &pool->cells[pool->used];
    runt_cell_clear(vm, cell);

    return RUNT_OK;
}

// Assembly:
movl 0x51c(%rdi), %eax
testl %eax, %eax
je 0x366e
decl %eax
movl %eax, 0x51c(%rdi)
movq 0x510(%rdi), %rcx
leaq (%rax,%rax,4), %rax
leaq -0x21b1(%rip), %rdx     # 0x1493
movq %rdx, (%rcx,%rax,8)
movups 0x1168(%rdi), %xmm0
movups %xmm0, 0x8(%rcx,%rax,8)
movq 0x1178(%rdi), %rdx
movq %rdx, 0x18(%rcx,%rax,8)
movl $0x0, 0x20(%rcx,%rax,8)
movl $0x1, %eax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movl 0x51c(%rdi), %ecx
incl %ecx
movl %ecx, 0x51c(%rdi)
movl 0x1158(%rdi), %eax
xorl %r15d, %r15d
testb $0x20, %al
jne 0x1ce1
movq %rdi, %rbx
cmpl 0x518(%rdi), %ecx
jae 0x1c77
movq %rsi, %r14
testb $0x1, %al
je 0x1cc0
movslq 0x500(%rbx), %rax
testq %rax, %rax
jle 0x1c9f
leaq (%rax,%rax,4), %rax
leaq (%rbx,%rax,8), %rax
addq $-0x28, %rax
jmp 0x1cb3
leaq 0x54ea(%rip), %rsi      # 0x7168
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1cfe
movl 0x1158(%rbx), %eax
andl $-0x29, %eax
orl $0x20, %eax
movl %eax, 0x1158(%rbx)
jmp 0x1ce1
leaq 0x556c(%rip), %rsi      # 0x7212
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1cfe
movq %rbx, %rax
cmpl $0x6, 0x8(%rax)
jne 0x1cea
movq 0x10(%rax), %rax
incl 0x20(%rax)
movl 0x51c(%rbx), %r15d
movq 0x510(%rbx), %rax
leal -0x1(%r15), %ecx
leaq (%rcx,%rcx,4), %rcx
leaq (%rax,%rcx,8), %rax
movq %rax, (%r14)
movl %r15d, 0x24(%rax)
movl %r15d, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x11ac
// File: /workspace/github_c_makefile_star2_O1/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 0x1dca
leaq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
popq %rcx
retq
callq 0x11c9
xorl %eax, %eax
jmp 0x1dc8
// File: /workspace/github_c_makefile_star2_O1/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 0x1e8e
leaq 0x537e(%rip), %rsi      # 0x7201
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x1cfe
jmp 0x1e9f
leal 0x1(%rax), %ecx
movl %ecx, 0x500(%rdi)
leaq (%rax,%rax,4), %rax
leaq (%rdi,%rax,8), %rbx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1f89
movq %rsi, %r14
cmpl $0x0, 0x20(%rsi)
je 0x1f9e
cmpl $0x0, 0x20(%r14)
je 0x1fbf
movl $0x1, %r15d
movl %r15d, %eax
leaq (%rax,%rax,4), %rax
leaq (%r14,%rax,8), %rsi
cmpl $0x0, 0x20(%rsi)
je 0x1f5b
movq %rbx, %rdi
callq 0x1f14
jmp 0x1f78
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
testl %eax, %eax
je 0x1fc6
incl %r15d
cmpl 0x20(%r14), %r15d
jbe 0x1f40
jmp 0x1fc8
leaq 0x5203(%rip), %rsi      # 0x7193
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1cfe
jmp 0x1fc8
movq %r14, 0x14b0(%rbx)
movq 0x18(%r14), %rax
movq %rax, 0x10(%rsp)
movups 0x8(%r14), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq *(%r14)
jmp 0x1fca
movl $0x1, %ebp
jmp 0x1fc8
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/MuvikLabs[P]runt/runt.c
// Function: runt_mk_float
runt_ptr runt_mk_float(runt_vm *vm, runt_float ival)
{
    runt_ptr p;
    float *val;
    val = NULL;
    p.pos = runt_malloc(vm, sizeof(runt_float), (void**)&val);
    p = runt_mk_ptr(RUNT_FLOAT, val);
    *val = ival;
    return p;
}

// Assembly:
movq %rdi, %rax
movl 0x534(%rsi), %ecx
movq 0x528(%rsi), %rdx
leaq (%rdx,%rcx), %rdi
leal 0x1(%rcx), %r8d
leal 0x4(%rcx), %r9d
movl %r9d, 0x534(%rsi)
movl %r8d, 0x10(%rax)
movl $0x1, (%rax)
movq %rdi, 0x8(%rax)
movss %xmm0, (%rdx,%rcx)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2081
leaq 0x5142(%rip), %rsi      # 0x71c1
jmp 0x209f
testl %esi, %esi
je 0x2098
decl %esi
addq 0x528(%rdi), %rsi
movq %rsi, (%rdx)
movl $0x1, %ebx
jmp 0x20a8
leaq 0x513c(%rip), %rsi      # 0x71db
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x1cfe
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x20fa
movq %r10, %rdi
addq 0x528(%rsi), %rdi
leal 0x1(%r10), %r8d
addl %r10d, %r9d
movl %r9d, 0x534(%rsi)
jmp 0x20ff
xorl %edi, %edi
xorl %r8d, %r8d
movl %ecx, %esi
testl %ecx, %ecx
je 0x2117
xorl %ecx, %ecx
movb (%rdx,%rcx), %r9b
movb %r9b, (%rdi,%rcx)
incq %rcx
cmpq %rcx, %rsi
jne 0x2107
movb $0x0, (%rdi,%rsi)
movl $0x2, (%rax)
movq %rdi, 0x8(%rax)
movl %r8d, 0x10(%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2166
leaq 0x50a9(%rip), %rsi      # 0x7201
xorl %ebp, %ebp
movq %r14, %rdi
xorl %eax, %eax
callq 0x1cfe
jmp 0x217d
leal 0x1(%rax), %ecx
movl %ecx, 0x500(%r14)
leaq (%rax,%rax,4), %rax
leaq (%r14,%rax,8), %r14
movl $0x1, %ebp
movq %r14, (%rbx)
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movslq 0x500(%rdi), %rax
testq %rax, %rax
jle 0x21b0
leaq (%rax,%rax,4), %rax
leaq (%r14,%rax,8), %r14
addq $-0x28, %r14
movl $0x1, %ebp
jmp 0x21c3
leaq 0x505b(%rip), %rsi      # 0x7212
xorl %ebp, %ebp
movq %r14, %rdi
xorl %eax, %eax
callq 0x1cfe
movq %r14, (%rbx)
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2200
leaq 0x502b(%rip), %rsi      # 0x7220
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x1cfe
jmp 0x2219
testl %edx, %edx
cmovsl %ecx, %eax
addl %edx, %eax
cltq
leaq (%rax,%rax,4), %rax
leaq (%rdi,%rax,8), %rax
movq %rax, (%rsi)
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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)
movslq 0x500(%rdi), %rax
testq %rax, %rax
jle 0x228a
decq %rax
movl %eax, 0x500(%rdi)
leaq (%rax,%rax,4), %rax
leaq (%rdi,%rax,8), %rax
movq %rax, (%rsi)
movl $0x1, %ebx
jmp 0x229a
leaq 0x4f81(%rip), %rsi      # 0x7212
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x1cfe
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movl 0x530(%rdi), %ecx
movl 0x534(%rdi), %eax
leaq 0x58(%rax), %r8
cmpq %rcx, %r8
jae 0x22c9
movq %rax, %rcx
addq 0x528(%rdi), %rcx
movq %rcx, (%rdx)
addl $0x58, %eax
movl %eax, 0x534(%rdi)
movq (%rdx), %rax
leaq -0x2e8(%rip), %rcx      # 0x1feb
movq %rcx, 0x8(%rax)
movq %rsi, (%rax)
movups 0x1168(%rdi), %xmm0
movups %xmm0, 0x10(%rax)
movq 0x1178(%rdi), %rcx
movq %rcx, 0x20(%rax)
movl $0x0, 0x28(%rax)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2446
movq 0x10(%rdi), %rcx
addq $0x40, %rcx
jmp 0x244e
movq %rsi, 0x8(%rdi)
leaq 0x10(%rdi), %rcx
movq %rsi, (%rcx)
movq 0x10(%rdi), %rcx
movq %rcx, 0x48(%rsi)
movq %rsi, 0x10(%rdi)
incl %eax
movl %eax, (%rdi)
movq %rdi, 0x38(%rsi)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl %edx, %ebp
movq %rsi, %r14
testl %edx, %edx
jle 0x24cc
movl %ebp, %eax
movl $0x1505, %edx           # imm = 0x1505
xorl %r9d, %r9d
movl %edx, %esi
shll $0x5, %esi
addl %edx, %esi
movsbl (%r14,%r9), %edi
xorl %esi, %edi
leaq (%rdi,%rdi,2), %rdx
shrq $0x20, %rdx
movl %edi, %esi
subl %edx, %esi
shrl %esi
addl %edx, %esi
shrl $0x1e, %esi
movl %esi, %edx
shll $0x1f, %edx
orl %esi, %edx
addl %edi, %edx
incq %r9
cmpq %r9, %rax
jne 0x2495
andl $0x7f, %edx
jmp 0x24d1
movl $0x5, %edx
leaq (%rdx,%rdx,2), %rax
movl 0x8(%r8,%rax,8), %r12d
testl %r12d, %r12d
je 0x2522
movq %rcx, (%rsp)
leaq (%r8,%rax,8), %rax
addq $0x8, %rax
movq 0x8(%rax), %r13
movslq %ebp, %r15
movq 0x40(%r13), %rbx
cmpl %ebp, 0x28(%r13)
jne 0x251a
cmpl $0x2, 0x10(%r13)
jne 0x2509
movq 0x18(%r13), %rsi
jmp 0x250b
xorl %esi, %esi
movq %r14, %rdi
movq %r15, %rdx
callq 0x1050
testl %eax, %eax
je 0x2526
movq %rbx, %r13
decl %r12d
jne 0x24f2
xorl %eax, %eax
jmp 0x2532
movq (%rsp), %rax
movq %r13, (%rax)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2564
testl %eax, %eax
jne 0x256c
leaq 0x4cd9(%rip), %rsi      # 0x7232
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x1cfe
jmp 0x2581
movl $0x0, (%rsi)
jmp 0x257c
decl %eax
movl %eax, (%rsi)
movq 0x10(%rsi), %rax
movq 0x48(%rax), %rax
movq %rax, 0x10(%rsi)
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2593
movq 0x8(%rdi), %rcx
movq %rcx, 0x40(%rsi)
movq %rsi, 0x8(%rdi)
incl %eax
movl %eax, (%rdi)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
leaq 0x8(%rsp), %rcx
leaq 0x1190(%rdi), %rdx
movl 0x530(%rdi), %eax
movl 0x534(%rdi), %r8d
leaq 0x58(%r8), %r9
cmpq %rax, %r9
jae 0x25da
movq %r8, %rax
addq 0x528(%rdi), %rax
addl $0x58, %r8d
movl %r8d, 0x534(%rdi)
jmp 0x25dc
xorl %eax, %eax
leaq -0x5f8(%rip), %r8       # 0x1feb
movq %r8, 0x8(%rax)
movq %rdx, (%rax)
movq 0x1178(%rdi), %rdx
movq %rdx, 0x20(%rax)
movups 0x1168(%rdi), %xmm0
movups %xmm0, 0x10(%rax)
movl $0x0, 0x28(%rax)
movq 0x10(%rcx), %rdx
movq %rdx, 0x20(%rax)
movups (%rcx), %xmm0
movups %xmm0, 0x10(%rax)
movl (%rsi), %ecx
testl %ecx, %ecx
je 0x2626
movq 0x10(%rsi), %rdx
addq $0x40, %rdx
jmp 0x262e
movq %rax, 0x8(%rsi)
leaq 0x10(%rsi), %rdx
movq %rax, (%rdx)
movq 0x10(%rsi), %rdx
movq %rdx, 0x48(%rax)
movq %rax, 0x10(%rsi)
incl %ecx
movl %ecx, (%rsi)
movq %rsi, 0x38(%rax)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movl $0x0, (%rsi)
movl $0x8, %eax
movl $0x0, (%rsi,%rax)
addq $0x18, %rax
cmpq $0xc08, %rax            # imm = 0xC08
jne 0x276e
movq %rsi, 0xc08(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/MuvikLabs[P]runt/runt.c
// Function: runt_atof
runt_float runt_atof(const char *str, runt_uint pos, runt_uint size)
{
    runt_float total = 0.0;
    runt_int sign = 1.0;
    runt_uint i;
    runt_uint mode = 0;
    runt_float place = 1.0;
    runt_float scale = 10.0;

    runt_float num = 0.0;

    if(str[pos] == '-') {
        sign = -1;
        pos++;
        size--;
    }

    for(i = pos; i < pos + size; i++) {
        num = 0.0;
        switch(str[i]) {
            case '0':
                num = 0.0;
                break;
            case '1':
                num = 1.0;
                break;
            case '2':
                num = 2.0;
                break;
            case '3':
                num = 3.0;
                break;
            case '4':
                num = 4.0;
                break;
            case '5':
                num = 5.0;
                break;
            case '6':
                num = 6.0;
                break;
            case '7':
                num = 7.0;
                break;
            case '8':
                num = 8.0;
                break;
            case '9':
                num = 9.0;
                break;
            case '.':
                if(mode == 0) {
                    scale = 0.1;
                    mode = 1;
                    place = 1.0;
                }
                break;
        }

        if(mode == 0) {
            total *= scale;
            total += num;
        } else {
            total += num * place;
            place *= scale;
        }

    }

    return total * sign;
}

// Assembly:
movl %esi, %eax
movb (%rdi,%rax), %al
xorl %ecx, %ecx
cmpb $0x2d, %al
sete %cl
addl %ecx, %esi
subl %ecx, %edx
addl %esi, %edx
xorps %xmm0, %xmm0
cmpl %edx, %esi
jae 0x2b9a
movl %esi, %ecx
movl %edx, %edx
xorl %r8d, %r8d
movss 0x4681(%rip), %xmm1     # 0x7124
movss 0x467d(%rip), %xmm4     # 0x7128
leaq 0x45e2(%rip), %rsi      # 0x7094
movss 0x4692(%rip), %xmm2     # 0x714c
movss 0x4686(%rip), %xmm3     # 0x7148
movss 0x467a(%rip), %xmm5     # 0x7144
movss 0x466e(%rip), %xmm6     # 0x7140
movss 0x4662(%rip), %xmm7     # 0x713c
movss 0x4655(%rip), %xmm8     # 0x7138
movss 0x4648(%rip), %xmm9     # 0x7134
movss 0x463b(%rip), %xmm10    # 0x7130
movss 0x462e(%rip), %xmm11    # 0x712c
movaps %xmm1, %xmm12
movzbl (%rdi,%rcx), %r9d
addl $-0x2e, %r9d
cmpl $0xb, %r9d
ja 0x2b6b
movslq (%rsi,%r9,4), %r9
addq %rsi, %r9
jmpq *%r9
testl %r8d, %r8d
je 0x2b5e
movl $0x1, %r8d
jmp 0x2b6b
movaps %xmm3, %xmm13
jmp 0x2b6f
movaps %xmm7, %xmm13
jmp 0x2b6f
movaps %xmm1, %xmm13
jmp 0x2b6f
movaps %xmm8, %xmm13
jmp 0x2b6f
movaps %xmm9, %xmm13
jmp 0x2b6f
movaps %xmm5, %xmm13
jmp 0x2b6f
movaps %xmm6, %xmm13
jmp 0x2b6f
movaps %xmm11, %xmm13
jmp 0x2b6f
movaps %xmm10, %xmm13
jmp 0x2b6f
movl $0x1, %r8d
movaps %xmm1, %xmm12
movaps %xmm2, %xmm4
xorps %xmm13, %xmm13
testl %r8d, %r8d
je 0x2b85
mulss %xmm12, %xmm13
addss %xmm13, %xmm0
mulss %xmm4, %xmm12
jmp 0x2b8e
mulss %xmm4, %xmm0
addss %xmm13, %xmm0
incq %rcx
cmpq %rcx, %rdx
jne 0x2b02
cmpb $0x2d, %al
jne 0x2ba5
xorps 0x45ab(%rip), %xmm0     # 0x7150
retq
// File: /workspace/github_c_makefile_star2_O1/MuvikLabs[P]runt/runt.c
// Function: runt_copy_float
static int runt_copy_float(runt_vm *vm, runt_cell *src, runt_cell *dest)
{
    runt_stacklet *s = runt_pop(vm);

    dest->fun = src->fun;
    dest->p = runt_mk_float(vm, s->f);

    return RUNT_OK;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movslq 0x500(%rdi), %rax
testq %rax, %rax
jle 0x34e4
decq %rax
movl %eax, 0x500(%r14)
leaq (%rax,%rax,4), %rax
leaq (%r14,%rax,8), %rax
jmp 0x34f8
leaq 0x3d27(%rip), %rsi      # 0x7212
movq %r14, %rdi
xorl %eax, %eax
callq 0x1cfe
movq %r14, %rax
movq (%r15), %rcx
movq %rcx, (%rbx)
movss 0x20(%rax), %xmm0
movl 0x534(%r14), %eax
movq 0x528(%r14), %rcx
leaq (%rcx,%rax), %rdx
leal 0x1(%rax), %esi
leal 0x4(%rax), %edi
movl %edi, 0x534(%r14)
movss %xmm0, (%rcx,%rax)
movl $0x1, 0x8(%rbx)
movq %rdx, 0x10(%rbx)
movl %esi, 0x18(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/MuvikLabs[P]runt/runt.c
// Function: runt_word_define_with_copy
runt_uint runt_word_define_with_copy(runt_vm *vm,
        const char *name,
        runt_uint size,
        runt_proc proc,
        runt_copy_proc copy)
{
    runt_cell *cell;
    runt_entry *entry;
    runt_uint id;
    entry = NULL;

    id = runt_cell_new(vm, &cell);
    if(id == 0) {
        return 0;
    }
    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);

    return id;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r15
movq %rcx, %r13
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r12
movq %rsp, %rsi
callq 0x1c27
testl %eax, %eax
je 0x360d
movl %eax, %ebx
movq (%rsp), %rax
movq %r13, (%rax)
movl 0x534(%r12), %edx
movq 0x528(%r12), %rsi
leaq (%rsi,%rdx), %rcx
leal 0x58(%rdx), %edi
movl %edi, 0x534(%r12)
leaq -0x15e2(%rip), %rdi     # 0x1feb
movq %rdi, 0x8(%rsi,%rdx)
movq %rax, (%rsi,%rdx)
movups 0x1168(%r12), %xmm0
movups %xmm0, 0x10(%rsi,%rdx)
movq 0x1178(%r12), %rax
movq %rax, 0x20(%rsi,%rdx)
movl $0x0, 0x28(%rsi,%rdx)
movq %r15, 0x8(%rsi,%rdx)
movq %r12, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x2313
jmp 0x360f
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/MuvikLabs[P]runt/runt.c
// Function: runt_pmark_set
void runt_pmark_set(runt_vm *vm)
{
    if(runt_get_state(vm, RUNT_MODE_INTERACTIVE) == RUNT_ON) {
        runt_mark_set(vm);
    } else {
        if(runt_get_state(vm, RUNT_MODE_VERBOSE) == RUNT_ON)
            runt_print(vm, "Not setting a mark!\n");
    }
}

// Assembly:
movl 0x1158(%rdi), %eax
testb $0x2, %al
jne 0x36cf
testb $0x10, %al
jne 0x36e8
retq
movl 0x51c(%rdi), %eax
movl 0x534(%rdi), %ecx
movl %eax, 0x520(%rdi)
movl %ecx, 0x538(%rdi)
retq
leaq 0x3bfe(%rip), %rsi      # 0x72ed
xorl %eax, %eax
jmp 0x1cfe
// File: /workspace/github_c_makefile_star2_O1/MuvikLabs[P]runt/runt.c
// Function: runt_pmark_free
runt_uint runt_pmark_free(runt_vm *vm)
{
    if(runt_get_state(vm, RUNT_MODE_INTERACTIVE) == RUNT_ON) {
        runt_mark_free(vm);
    } else {
        if(runt_get_state(vm, RUNT_MODE_VERBOSE) == RUNT_ON)
            runt_print(vm, "Not freeing!\n");
    }
    return RUNT_OK;
}

// Assembly:
movl 0x1158(%rdi), %eax
testb $0x2, %al
jne 0x3719
testb $0x10, %al
je 0x3731
pushq %rax
leaq 0x3bf6(%rip), %rsi      # 0x7302
xorl %eax, %eax
callq 0x1cfe
addq $0x8, %rsp
jmp 0x3731
movl 0x520(%rdi), %eax
movl 0x538(%rdi), %ecx
movl %eax, 0x51c(%rdi)
movl %ecx, 0x534(%rdi)
movl $0x1, %eax
retq