LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/kobolt[P]curses-collection/fileselect/fileselect.c
// Function: file_node_path
static char *file_node_path(file_node_t *node, char *path, int path_len)
{
  char temp[PATH_MAX];

  strncpy(path, node->name, path_len);

  node = node->parent;
  while (node != NULL) {
    if (node->type == FILE_NODE_TYPE_ROOT) {
      break;
    }
    strncpy(temp, path, PATH_MAX);
    snprintf(path, path_len, "%s/%s", node->name, temp);
    node = node->parent;
  }

  return path;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rsi
movl $0x1000, %edx           # imm = 0x1000
movq %rbx, %rdi
callq 0x1070
movq %rsp, %r15
leaq 0x272(%rip), %r12       # 0x2086
movq 0x18(%r14), %r14
testq %r14, %r14
je 0x1e4f
cmpl $0x0, 0x10(%r14)
je 0x1e4f
movl $0x1000, %edx           # imm = 0x1000
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1070
movq 0x8(%r14), %rcx
movl $0x1000, %esi           # imm = 0x1000
movq %rbx, %rdi
movq %r12, %rdx
movq %r15, %r8
xorl %eax, %eax
callq 0x1100
jmp 0x1e14
movq %rbx, %rax
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O2/giometti[P]mastering_UNIX_programming/chapter_05/readdir.c
// Function: main
int main(int argc, char *argv[])
{
	struct stat buf;
	DIR *d;
	struct dirent *dp;
	int dirfd, fd;
        int ret;

        if (argc < 2) {
                fprintf(stderr, "usage: %s <dir>\n", argv[0]);
                return -1;
        }

	/* Open the directory entry */
	dirfd = open(argv[1], O_RDONLY);
	if (dirfd < 0) {
		perror("open");
		return -1;
	}

	/* Create the DIR stream over the dirfd */
	d = fdopendir(dirfd);
	if (d == NULL) {
		fprintf(stderr,
			"Cannot open %s directory\n", argv[1]);
		return -1;
	}

	/* Now iterate over files */
	printf("Files list for directory %s:\n", argv[1]);
	printf("size\tname\n");
	while ((dp = readdir(d)) != NULL) {
		/* Get a file descriptor for next direntry */
		fd = openat(dirfd, dp->d_name, O_RDONLY);
		if (fd < 0) {
			perror(dp->d_name);
			continue;
		}

		/* Get file's statistics */
		ret = fstat(fd, &buf);
		close(fd); /* fd is not needed anymore */
		if (ret < 0) {
			perror(dp->d_name);
			continue;
		}

		/* Print the file entry (size & name) */
		printf("%ld\t%s\n",
			(intmax_t) buf.st_size,
			dp->d_name);
	}

	closedir(d); /* this implicitly closes dirfd */

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r15
cmpl $0x1, %edi
jle 0x12c5
movq 0x8(%r15), %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x10a0
testl %eax, %eax
js 0x12db
movl %eax, %ebx
movl %eax, %edi
callq 0x10c0
testq %rax, %rax
je 0x12e9
movq %rax, %r14
movq 0x8(%r15), %rsi
leaq 0xe06(%rip), %rdi       # 0x2034
xorl %eax, %eax
callq 0x1050
leaq 0xe1e(%rip), %rdi       # 0x205a
callq 0x1030
leaq 0x8(%rsp), %r15
movq %r14, %rdi
callq 0x1090
testq %rax, %rax
je 0x12a9
movq %rax, %r13
addq $0x13, %r13
movl %ebx, %edi
movq %r13, %rsi
xorl %edx, %edx
xorl %eax, %eax
callq 0x1040
testl %eax, %eax
js 0x129f
movl %eax, %ebp
movl %eax, %edi
movq %r15, %rsi
callq 0x10d0
movl %eax, %r12d
movl %ebp, %edi
callq 0x1060
testl %r12d, %r12d
js 0x129f
movq 0x38(%rsp), %rsi
leaq 0xdbf(%rip), %rdi       # 0x2052
movq %r13, %rdx
xorl %eax, %eax
callq 0x1050
jmp 0x1246
movq %r13, %rdi
callq 0x10b0
jmp 0x1246
movq %r14, %rdi
callq 0x1070
xorl %eax, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2d2c(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq (%r15), %rdx
leaq 0xd2b(%rip), %rsi       # 0x2004
jmp 0x12fe
leaq 0xd33(%rip), %rdi       # 0x2015
callq 0x10b0
jmp 0x1305
movq 0x2d08(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq 0x8(%r15), %rdx
leaq 0xd1c(%rip), %rsi       # 0x201a
xorl %eax, %eax
callq 0x1080
pushq $-0x1
popq %rax
jmp 0x12b3
// File: /workspace/github_c_makefile_star2_O2/mist64[P]cbmbasic/runtime.c
// Function: stack4
int
stack4(unsigned short a, unsigned short b, unsigned short c, unsigned short d) {
//	printf("stack4: %x,%x,%x,%x\n", a, b, c, d);
	if (STACK16(S+1) + 1 != a) return 0;
	if (STACK16(S+3) + 1 != b) return 0;
	if (STACK16(S+5) + 1 != c) return 0;
	if (STACK16(S+7) + 1 != d) return 0;
	return 1;
}

// Assembly:
leaq 0xd979(%rip), %rax      # 0x20128
movzbl (%rax), %r8d
leaq 0xd986(%rip), %r9       # 0x20140
movzwl 0x101(%r8,%r9), %r10d
incl %r10d
xorl %eax, %eax
cmpl %edi, %r10d
jne 0x12832
movzbl 0x103(%r8,%r9), %edi
movzbl 0x104(%r8,%r9), %r10d
shll $0x8, %r10d
addl %r10d, %edi
incl %edi
movzwl %si, %esi
cmpl %esi, %edi
jne 0x12832
movzbl 0x105(%r8,%r9), %esi
movzbl 0x106(%r8,%r9), %edi
shll $0x8, %edi
addl %edi, %esi
incl %esi
movzwl %dx, %edx
cmpl %edx, %esi
jne 0x12832
movzbl 0x107(%r8,%r9), %eax
movzbl 0x108(%r8,%r9), %edx
shll $0x8, %edx
addl %eax, %edx
incl %edx
movzwl %cx, %ecx
xorl %eax, %eax
cmpl %ecx, %edx
sete %al
retq
// File: /workspace/github_c_makefile_star2_O2/mist64[P]cbmbasic/runtime.c
// Function: CHRGET_common
static void
CHRGET_common(int inc) {
	unsigned short temp16;
	if (!inc) goto CHRGOT_start;
CHRGET_start:
	RAM[0x7A]++; SETSZ(RAM[0x7A]);
	if (!Z) goto CHRGOT_start;
	RAM[0x7B]++; SETSZ(RAM[0x7B]);
CHRGOT_start:
	A = RAM[RAM[0x7A] | RAM[0x7B]<<8]; SETSZ(A);
	temp16 = ((unsigned short)A) - ((unsigned short)0x3A); SETNC(temp16); SETSZ(temp16&0xFF);
	if (C) return;
	temp16 = ((unsigned short)A) - ((unsigned short)0x20); SETNC(temp16); SETSZ(temp16&0xFF);
	if (Z) goto CHRGET_start;
	C = 1;
	temp16 = (unsigned short)A-(unsigned short)0x30-(unsigned short)(1-C); SETV(((A ^ temp16) & 0x80) && ((A ^ 0x30) & 0x80)); A = (unsigned char)temp16; SETSZ(A); SETNC(temp16);
	C = 1;
	temp16 = (unsigned short)A-(unsigned short)0xD0-(unsigned short)(1-C); SETV(((A ^ temp16) & 0x80) && ((A ^ 0xD0) & 0x80)); A = (unsigned char)temp16; SETSZ(A); SETNC(temp16);
}

// Assembly:
testl %edi, %edi
je 0x12884
leaq 0xd8fd(%rip), %rax      # 0x20140
movb 0x7a(%rax), %al
leal 0x1(%rax), %esi
shrb $0x7, %sil
leaq 0xd8ec(%rip), %rcx      # 0x20140
leaq 0x1d8e9(%rip), %rdx     # 0x30144
movb %sil, (%rdx)
incb %al
movb %al, 0x7a(%rcx)
leaq 0x1d8d9(%rip), %rax     # 0x30143
sete (%rax)
jne 0x12884
movb 0x7b(%rcx), %sil
incb %sil
sete (%rax)
movb %sil, 0x7b(%rcx)
shrb $0x7, %sil
movb %sil, (%rdx)
leaq 0xd8b5(%rip), %rcx      # 0x20140
movzwl 0x7a(%rcx), %eax
movzbl (%rcx,%rax), %ecx
leal 0xffc6(%rcx), %edx
testb %dl, %dl
leaq 0x1d8a1(%rip), %rsi     # 0x30143
sete (%rsi)
movl %edx, %r9d
shrb $0x7, %r9b
btl $0x8, %edx
leaq 0x1d88f(%rip), %rdx     # 0x30146
setae (%rdx)
leaq 0x1d884(%rip), %r8      # 0x30145
movb %cl, (%r8)
leaq 0x1d879(%rip), %rdi     # 0x30144
movb %r9b, (%rdi)
jae 0x12909
leal 0xffe0(%rcx), %r9d
btl $0x8, %r9d
setae (%rdx)
testb %r9b, %r9b
je 0x12846
addb $-0x30, %cl
movzbl %cl, %eax
addl $0xffffff30, %eax       # imm = 0xFFFFFF30
testb %al, %al
sete (%rsi)
movb %al, (%r8)
movl %eax, %ecx
shrb $0x7, %cl
movb %cl, (%rdi)
btl $0x8, %eax
setae (%rdx)
retq
// File: /workspace/github_c_makefile_star2_O2/mist64[P]cbmbasic/runtime.c
// Function: init_os
int
init_os(int argc, char **argv) {
//	printf("init_os %d\n", argc);
	if (!argc) /* continuation */
		return PC;

	if (argc>1) {
		interactive = 0;
		input_file = fopen(argv[1], "r");
		if (!input_file) {
			printf("Error opening: %s\n", argv[1]);
			exit(1);
		}
		if (fgetc(input_file)=='#') {
			char c;
			do {
				c = fgetc(input_file);
			} while((c!=13)&&(c!=10));
		} else {
			fseek(input_file, 0, SEEK_SET);
		}
	} else {
		interactive = 1;
		input_file = NULL;
	}
	srand((unsigned int)time(NULL));

	return 0xE394; /* main entry point of BASIC */
}

// Assembly:
pushq %rbx
testl %edi, %edi
je 0x12968
cmpl $0x2, %edi
jl 0x12974
movq %rsi, %rbx
andl $0x0, 0x1d8ff(%rip)     # 0x30224
movq 0x8(%rsi), %rdi
leaq 0xaec4(%rip), %rsi      # 0x1d7f4
callq 0x11f0
movq %rax, 0x1d8ec(%rip)     # 0x30228
testq %rax, %rax
je 0x129ad
movq %rax, %rdi
callq 0x1110
cmpl $0x23, %eax
jne 0x12988
movq 0x1d8d3(%rip), %rdi     # 0x30228
callq 0x1110
cmpb $0xa, %al
je 0x12998
movzbl %al, %eax
cmpl $0xd, %eax
jne 0x1294e
jmp 0x12998
leaq 0x1d7d1(%rip), %rax     # 0x30140
movzwl (%rax), %eax
jmp 0x129ab
movl $0x1, 0x1d8a6(%rip)     # 0x30224
andq $0x0, 0x1d8a2(%rip)     # 0x30228
jmp 0x12998
movq 0x1d899(%rip), %rdi     # 0x30228
xorl %esi, %esi
xorl %edx, %edx
callq 0x11e0
xorl %edi, %edi
callq 0x1190
movl %eax, %edi
callq 0x1140
movl $0xe394, %eax           # imm = 0xE394
popq %rbx
retq
movq 0x8(%rbx), %rsi
leaq 0xae3e(%rip), %rdi      # 0x1d7f6
xorl %eax, %eax
callq 0x10c0
pushq $0x1
popq %rdi
callq 0x1200
// File: /workspace/github_c_makefile_star2_O2/mist64[P]cbmbasic/runtime.c
// Function: plugin_on
void
plugin_on() {
	if (plugin)
		return;

	replace_vector(VEC_ERROR, MAGIC_ERROR, &orig_error);
	replace_vector(VEC_MAIN, MAGIC_MAIN, &orig_main);
	replace_vector(VEC_CRNCH, MAGIC_CRNCH, &orig_crnch);
	replace_vector(VEC_QPLOP, MAGIC_QPLOP, &orig_qplop);
	replace_vector(VEC_GONE, MAGIC_GONE, &orig_gone);
	replace_vector(VEC_EVAL, MAGIC_EVAL, &orig_eval);
	
	plugin = 1;
}

// Assembly:
cmpl $0x0, 0x1d848(%rip)     # 0x30230
je 0x129eb
retq
leaq 0xd74e(%rip), %rax      # 0x20140
movzwl 0x300(%rax), %ecx
movzwl 0x302(%rax), %edx
movw %cx, 0x1d82d(%rip)      # 0x30234
movw %dx, 0x1d828(%rip)      # 0x30236
movzwl 0x304(%rax), %ecx
movw %cx, 0x1d81c(%rip)      # 0x30238
movzwl 0x306(%rax), %ecx
movw %cx, 0x1d810(%rip)      # 0x3023a
movabsq $-0xfc00fd00fe0100, %rcx # imm = 0xFF03FF02FF01FF00
movq %rcx, 0x300(%rax)
movzwl 0x308(%rax), %ecx
movw %cx, 0x1d7f3(%rip)      # 0x3023c
movzwl 0x30a(%rax), %ecx
movw %cx, 0x1d7e7(%rip)      # 0x3023e
movl $0xff05ff04, 0x308(%rax) # imm = 0xFF05FF04
movl $0x1, 0x1d7c5(%rip)     # 0x30230
retq
// File: /workspace/github_c_makefile_star2_O2/mist64[P]cbmbasic/plugin.c
// Function: compare
int
compare(const char *s1) {
	const unsigned char *s = (const unsigned char *)s1;
	unsigned short chrptr = get_chrptr();

	while (*s) {
		CHRGET();
		if (A != *s++) {
			set_chrptr(chrptr);
			return 0;
		}
	}
	CHRGET();
	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0xc6e3(%rip), %r15      # 0x20140
movzwl 0x7a(%r15), %ebp
pushq $0x1
popq %rbx
leaq 0x1c6d9(%rip), %r12     # 0x30145
movb (%r14), %r13b
callq 0x12833
testb %r13b, %r13b
je 0x13a90
movb (%r12), %al
leaq 0x1(%r14), %rcx
cmpb (%r14), %al
movq %rcx, %r14
je 0x13a6c
movw %bp, 0x7a(%r15)
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_O2/Tarsnap[P]libcperciva/tests/crypto_aes/main.c
// Function: perftest
static int
perftest(void)
{
	struct perftest_cookie_aes pca_actual;
	struct perftest_cookie_aes * pca = &pca_actual;
	uint8_t ciphertext_arr[16];
	size_t keylen;

	/* Sanity check. */
#ifdef CPUSUPPORT_X86_AESNI
	if (cpusupport_x86_aesni()) {
		if (crypto_aes_can_use_intrinsics() != 1) {
			warn0("Unexpected error with AESNI");
			goto err0;
		}
	}
#endif

	/* Inform user about the hardware optimization status. */
	print_hardware("Performance test of AES");
	fflush(stdout);

	/* Prepare arrays. */
	if (parse_testcase(perftestcase, &pca->key_exp, &keylen,
	    pca->plaintext_arr, ciphertext_arr)) {
		warn0("parse_testcase");
		goto err0;
	}

	/* Time the function. */
	if (perftest_buffers(nbytes_perftest, perfsizes, num_perf,
	    nbytes_warmup, 1, perftest_init, perftest_func, NULL, pca)) {
		warn0("perftest_buffers");
		goto err1;
	}

	/* Clean up. */
	crypto_aes_key_free(pca->key_exp);

	/* Success! */
	return (0);

err1:
	crypto_aes_key_free(pca->key_exp);
err0:
	/* Failure! */
	return (1);
}

// Assembly:
pushq %rbx
subq $0x50, %rsp
callq 0x16ff
testl %eax, %eax
je 0x1455
callq 0x19c0
cmpl $0x1, %eax
jne 0x14b0
leaq 0x2bca(%rip), %rdi      # 0x4026
callq 0x1739
movq 0x5b88(%rip), %rax      # 0x6ff0
movq (%rax), %rdi
callq 0x1200
leaq 0x28(%rsp), %rdx
movq 0x5914(%rip), %rax      # 0x6d90
movq %rax, 0x10(%rsp)
movups 0x58f8(%rip), %xmm0     # 0x6d80
movups %xmm0, (%rsp)
leaq 0x20(%rsp), %rbx
leaq 0x38(%rsp), %rsi
leaq 0x40(%rsp), %rcx
movq %rbx, %rdi
callq 0x176a
testl %eax, %eax
je 0x14d1
leaq 0x2b90(%rip), %rdi      # 0x403e
jmp 0x14b7
leaq 0x2b53(%rip), %rdi      # 0x400a
xorl %eax, %eax
callq 0x31a4
callq 0x1190
andl $0x0, (%rax)
pushq $0x1
popq %rbx
movl %ebx, %eax
addq $0x50, %rsp
popq %rbx
retq
movq %rbx, 0x10(%rsp)
andq $0x0, 0x8(%rsp)
leaq 0x41d(%rip), %rax       # 0x1900
movq %rax, (%rsp)
leaq 0x2e1a(%rip), %rsi      # 0x4308
leaq 0x3db(%rip), %r9        # 0x18d0
pushq $0x1
popq %rdx
pushq $0x1
popq %rbx
movl $0x40000000, %edi       # imm = 0x40000000
movl $0x9896800, %ecx        # imm = 0x9896800
movl %ebx, %r8d
callq 0x2bcc
testl %eax, %eax
je 0x1533
leaq 0x2b35(%rip), %rdi      # 0x404d
xorl %eax, %eax
callq 0x31a4
callq 0x1190
andl $0x0, (%rax)
movq 0x20(%rsp), %rdi
callq 0x1b1e
jmp 0x14c9
movq 0x20(%rsp), %rdi
callq 0x1b1e
xorl %ebx, %ebx
jmp 0x14c9
// File: /workspace/github_c_makefile_star2_O2/Tarsnap[P]libcperciva/tests/crypto_aes/main.c
// Function: parse_testcase
static int
parse_testcase(const struct testcase testcase,
    struct crypto_aes_key ** key_exp_p, size_t * keylen_p,
    uint8_t plaintext_arr[static MAX_PLAINTEXT_LENGTH],
    uint8_t ciphertext_arr[static MAX_PLAINTEXT_LENGTH])
{
	uint8_t key_unexpanded[32]; /* We will use 16 or 32 of these bytes. */
	const size_t len = strlen(testcase.plaintext_hex) / 2;

	/* Determine key length. */
	*keylen_p = strlen(testcase.keytext_hex) / 2;

	/* Sanity check. */
	assert((*keylen_p == 16) || (*keylen_p == 32));
	assert(len == 16);

	/* Prepare the key. */
	if (unhexify(testcase.keytext_hex, key_unexpanded, *keylen_p)) {
		warn0("unhexify(%s)", testcase.keytext_hex);
		goto err0;
	}
	if ((*key_exp_p = crypto_aes_key_expand(key_unexpanded, *keylen_p))
	    == NULL) {
		warn0("crypto_aes_key_expand");
		goto err0;
	}

	/* Prepare the arrays. */
	if (unhexify(testcase.plaintext_hex, plaintext_arr, len)) {
		warn0("unhexify(%s)", testcase.plaintext_hex);
		goto err1;
	}
	if (unhexify(testcase.ciphertext_hex, ciphertext_arr, len)) {
		warn0("unhexify(%s)", testcase.ciphertext_hex);
		goto err1;
	}

	/* Clean up.  Irrelevant for a test, but it's a good habit. */
	insecure_memzero(key_unexpanded, 32);

	/* Success! */
	return (0);

err1:
	crypto_aes_key_free(*key_exp_p);
err0:
	/* Failure! */
	return (1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, 0x8(%rsp)
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq 0x78(%rsp), %r14
movq %r14, %rdi
callq 0x1120
movq %rax, %r15
movq 0x70(%rsp), %rbp
movq %rbp, %rdi
callq 0x1120
shrq %rax
movq %rax, (%r13)
cmpq $0x10, %rax
je 0x17ba
cmpq $0x20, %rax
jne 0x18b3
andq $-0x2, %r15
cmpq $0x20, %r15
jne 0x189a
leaq 0x10(%rsp), %rsi
movq %rbp, %rdi
movq %rax, %rdx
callq 0x2b13
testl %eax, %eax
je 0x17f7
leaq 0x290d(%rip), %rdi      # 0x40f0
movq %rbp, %rsi
xorl %eax, %eax
callq 0x31a4
callq 0x1190
andl $0x0, (%rax)
jmp 0x185d
movq (%r13), %rsi
leaq 0x10(%rsp), %rdi
callq 0x1a7e
movq %rax, (%rbx)
testq %rax, %rax
je 0x186f
pushq $0x10
popq %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0x2b13
testl %eax, %eax
jne 0x183c
leaq 0x70(%rsp), %rax
movq 0x10(%rax), %r14
pushq $0x10
popq %rdx
movq %r14, %rdi
movq 0x8(%rsp), %rsi
callq 0x2b13
testl %eax, %eax
je 0x1882
leaq 0x28ad(%rip), %rdi      # 0x40f0
movq %r14, %rsi
xorl %eax, %eax
callq 0x31a4
callq 0x1190
andl $0x0, (%rax)
movq (%rbx), %rdi
callq 0x1b1e
pushq $0x1
popq %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2887(%rip), %rdi      # 0x40fd
xorl %eax, %eax
callq 0x31a4
jmp 0x17ed
leaq 0x597f(%rip), %rax      # 0x7208
movq (%rax), %rax
leaq 0x10(%rsp), %rdi
pushq $0x20
popq %rsi
callq *%rax
xorl %eax, %eax
jmp 0x1860
leaq 0x28f8(%rip), %rdi      # 0x4199
leaq 0x27dd(%rip), %rsi      # 0x4085
leaq 0x27dd(%rip), %rcx      # 0x408c
pushq $0x7e
jmp 0x18ca
leaq 0x27a4(%rip), %rdi      # 0x405e
leaq 0x27c4(%rip), %rsi      # 0x4085
leaq 0x27c4(%rip), %rcx      # 0x408c
pushq $0x7d
popq %rdx
callq 0x1090
// File: /workspace/github_c_makefile_star2_O2/MersenneTwister-Lab[P]MTGP/mtgp32-fast.c
// Function: mtgp32_init
int mtgp32_init(mtgp32_fast_t *mtgp32,
		const mtgp32_params_fast_t *para, uint32_t seed) {
    int rc;
    rc = alloc_state(mtgp32, para);
    if (rc) {
	return rc;
    }
    mtgp32->status->idx = mtgp32->status->size - 1;
    mtgp32_init_state(mtgp32->status->array, para, seed);
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
callq 0x122b
testl %eax, %eax
je 0x1207
pushq $-0x1
popq %rax
jmp 0x1225
movq 0xf0(%r15), %rdi
movl 0x4(%rdi), %eax
decl %eax
movl %eax, (%rdi)
addq $0x10, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x12a9
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/MersenneTwister-Lab[P]MTGP/mtgp32-fast.c
// Function: alloc_state
static int alloc_state(mtgp32_fast_t *mtgp32,
		       const mtgp32_params_fast_t *para) {
    int size = para->mexp / 32 + 1;
    int large_size;
    mtgp32_status_fast_t *st;

    int x;
    int y = size;
    for (x = 1; (x != size) && (y > 0); x <<= 1, y >>= 1);
    large_size = x;

    st = (mtgp32_status_fast_t *)malloc(sizeof(mtgp32_status_fast_t)
				     + sizeof(uint32_t) * large_size);
    if (st == NULL) {
	return -1;
    }
    mtgp32->params = *para;
    mtgp32->status = st;
    st->size = size;
    st->large_size = large_size;
    st->large_mask = large_size -1;
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %eax
pushq $0x20
popq %rcx
cltd
idivl %ecx
movl %eax, %ebp
incl %ebp
pushq $0x1
popq %r12
movl %ebp, %eax
cmpl %ebp, %r12d
je 0x125b
testl %eax, %eax
jle 0x125b
addl %r12d, %r12d
shrl %eax
jmp 0x124b
movslq %r12d, %rax
leaq 0x10(,%rax,4), %rdi
callq 0x10e0
testq %rax, %rax
je 0x129d
movq %rax, %r15
movl $0xec, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10d0
movq %r15, 0xf0(%rbx)
movl %ebp, 0x4(%r15)
movl %r12d, 0x8(%r15)
decl %r12d
movl %r12d, 0xc(%r15)
xorl %eax, %eax
jmp 0x12a0
pushq $-0x1
popq %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MersenneTwister-Lab[P]MTGP/mtgp32-fast.c
// Function: mtgp32_init_state
void mtgp32_init_state(uint32_t array[],
		      const mtgp32_params_fast_t *para, uint32_t seed) {
    int i;
    int size = para->mexp / 32 + 1;
    uint32_t hidden_seed;
    uint32_t tmp;
    hidden_seed = para->tbl[4] ^ (para->tbl[8] << 16);
    tmp = hidden_seed;
    tmp += tmp >> 16;
    tmp += tmp >> 8;
    memset(array, tmp & 0xff, sizeof(uint32_t) * size);
    array[0] = seed;
    array[1] = hidden_seed;
    for (i = 1; i < size; i++) {
	array[i] ^= UINT32_C(1812433253) * (array[i - 1]
					    ^ (array[i - 1] >> 30))
	    + i;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rdi, %rbx
movl (%rsi), %eax
movl 0x30(%rsi), %r15d
pushq $0x20
popq %rcx
cltd
idivl %ecx
shll $0x10, %r15d
xorl 0x20(%rsi), %r15d
movl %r15d, %ecx
shrl $0x10, %ecx
addl %r15d, %ecx
movl %ecx, %esi
shrl $0x8, %esi
addl %ecx, %esi
movslq %eax, %r14
leaq 0x4(,%r14,4), %rdx
callq 0x1090
movl %ebp, (%rbx)
movl %r15d, 0x4(%rbx)
pushq $0x1
popq %rax
cmpq %r14, %rax
jg 0x1312
movl -0x4(%rbx,%rax,4), %ecx
movl %ecx, %edx
shrl $0x1e, %edx
xorl %ecx, %edx
imull $0x6c078965, %edx, %ecx # imm = 0x6C078965
addl %eax, %ecx
xorl %ecx, (%rbx,%rax,4)
incq %rax
jmp 0x12f2
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MersenneTwister-Lab[P]MTGP/mtgp32-fast.c
// Function: mtgp32_print_idstring
void mtgp32_print_idstring(const mtgp32_fast_t *mtgp32, FILE *fp) {
    int i;
    fprintf(fp, "mtgp32:%d:", mtgp32->params.mexp);
    for (i = 0; i < 20; i++) {
	fprintf(fp, "%02x", (unsigned int)mtgp32->params.poly_sha1[i]);
    }
    fprintf(fp, "\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %edx
leaq 0x171b(%rip), %rsi      # 0x300c
movq %rbx, %rdi
xorl %eax, %eax
callq 0x10b0
pushq $-0x14
popq %r12
leaq 0x1711(%rip), %r15      # 0x3017
testq %r12, %r12
je 0x1926
movzbl 0xe8(%r14,%r12), %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x10b0
incq %r12
jmp 0x1906
pushq $0xa
popq %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x10a0
// File: /workspace/github_c_makefile_star2_O2/MersenneTwister-Lab[P]MTGP/mtgp32-fast.c
// Function: print_close1_open2
void print_close1_open2(mtgp32_fast_t *mtgp32, int count) {
    int i;
    for (i = 0; i < count; i++) {
	printf("%.8f ", mtgp32_genrand_close1_open2(mtgp32));
	if (i % 5 == 4) {
	    printf("\n");
	}
    }
    if (i % 5 != 0) {
	printf("\n");
    }
    printf("\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r12d
movq %rdi, %r14
xorl %ebp, %ebp
testl %esi, %esi
cmovlel %ebp, %r12d
pushq $0x4
popq %rbx
leaq 0x15c5(%rip), %r15      # 0x3022
movl %r12d, 0x4(%rsp)
movl %ebp, %eax
xorl %edx, %edx
pushq $0x5
popq %rcx
divl %ecx
subl $0x1, %r12d
jb 0x1aa1
leal (%rax,%rax,4), %r13d
addl %ebx, %r13d
movq %r14, %rdi
callq 0x1acb
cvtss2sd %xmm0, %xmm0
movq %r15, %rdi
movb $0x1, %al
callq 0x1080
testl %r13d, %r13d
jne 0x1a9b
pushq $0xa
popq %rdi
callq 0x1040
incl %ebp
decl %ebx
jmp 0x1a62
movl 0x4(%rsp), %eax
xorl %edx, %edx
divl %ecx
testl %edx, %edx
je 0x1ab5
pushq $0xa
popq %rdi
callq 0x1040
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O2/MersenneTwister-Lab[P]MTGP/./mtgp32-fast.h
// Function: mtgp32_genrand_close1_open2
inline static float mtgp32_genrand_close1_open2(mtgp32_fast_t *mtgp32) {
    int idx;
    uint32_t *flt_tmp_tbl = mtgp32->params.flt_tmp_tbl;
    uint32_t *array = mtgp32->status->array;
    int pos = mtgp32->params.pos;
    int large_size = mtgp32->status->large_size;
    int size = mtgp32->status->size;
    uint32_t large_mask = mtgp32->status->large_mask;

    mtgp32_next_state(mtgp32);
    idx = mtgp32->status->idx;
    return mtgp32_temper_float(flt_tmp_tbl,
				array[idx],
				array[(idx + pos - 1 - size + large_size)
				      & large_mask]);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0xf0(%rdi), %r14
movl 0x4(%r14), %r15d
movl 0x8(%r14), %ebp
movl 0xc(%r14), %r12d
addl 0x4(%rdi), %ebp
callq 0x1fef
movq 0xf0(%rbx), %rax
movslq (%rax), %rax
movl 0x10(%r14,%rax,4), %ecx
notl %r15d
addl %ebp, %r15d
addl %eax, %r15d
andl %r12d, %r15d
movl 0x10(%r14,%r15,4), %eax
movl %eax, %edx
shrl $0x10, %edx
xorl %eax, %edx
movl %edx, %eax
shrl $0x8, %eax
xorl %edx, %eax
shrl $0x9, %ecx
andl $0xf, %eax
xorl 0x90(%rbx,%rax,4), %ecx
movd %ecx, %xmm0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MersenneTwister-Lab[P]MTGP/mtgp32-fast.c
// Function: print_close_open
void print_close_open(mtgp32_fast_t *mtgp32, int count) {
    int i;
    for (i = 0; i < count; i++) {
	printf("%.8f ", mtgp32_genrand_close_open(mtgp32));
	if (i % 5 == 4) {
	    printf("\n");
	}
    }
    if (i % 5 != 0) {
	printf("\n");
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r12d
movq %rdi, %r14
xorl %ebp, %ebp
testl %esi, %esi
cmovlel %ebp, %r12d
pushq $0x4
popq %rbx
leaq 0x14c6(%rip), %r15      # 0x3022
movl %r12d, 0x4(%rsp)
movl %ebp, %eax
xorl %edx, %edx
pushq $0x5
popq %rcx
divl %ecx
subl $0x1, %r12d
jb 0x1ba8
leal (%rax,%rax,4), %r13d
addl %ebx, %r13d
movq %r14, %rdi
callq 0x1acb
addss 0x147d(%rip), %xmm0     # 0x3004
cvtss2sd %xmm0, %xmm0
movq %r15, %rdi
movb $0x1, %al
callq 0x1080
testl %r13d, %r13d
jne 0x1ba2
pushq $0xa
popq %rdi
callq 0x1040
incl %ebp
decl %ebx
jmp 0x1b61
movl 0x4(%rsp), %eax
xorl %edx, %edx
divl %ecx
testl %edx, %edx
je 0x1bca
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1040
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MersenneTwister-Lab[P]MTGP/mtgp32-fast.c
// Function: print_open_close
void print_open_close(mtgp32_fast_t *mtgp32, int count) {
    int i;
    for (i = 0; i < count; i++) {
	printf("%.8f ", mtgp32_genrand_open_close(mtgp32));
	if (i % 5 == 4) {
	    printf("\n");
	}
    }
    if (i % 5 != 0) {
	printf("\n");
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r12d
movq %rdi, %r14
xorl %ebp, %ebp
testl %esi, %esi
cmovlel %ebp, %r12d
pushq $0x4
popq %rbx
leaq 0x1426(%rip), %r15      # 0x3022
movl %r12d, 0x4(%rsp)
movl %ebp, %eax
xorl %edx, %edx
pushq $0x5
popq %rcx
divl %ecx
subl $0x1, %r12d
jb 0x1c4c
leal (%rax,%rax,4), %r13d
addl %ebx, %r13d
movq %r14, %rdi
callq 0x1acb
movss 0x13e1(%rip), %xmm1     # 0x3008
subss %xmm0, %xmm1
cvtss2sd %xmm1, %xmm0
movq %r15, %rdi
movb $0x1, %al
callq 0x1080
testl %r13d, %r13d
jne 0x1c46
pushq $0xa
popq %rdi
callq 0x1040
incl %ebp
decl %ebx
jmp 0x1c01
movl 0x4(%rsp), %eax
xorl %edx, %edx
divl %ecx
testl %edx, %edx
je 0x1c6e
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1040
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MersenneTwister-Lab[P]MTGP/./mtgp32-fast.h
// Function: mtgp32_next_state
inline static void mtgp32_next_state(mtgp32_fast_t *mtgp32) {
    uint32_t *array = mtgp32->status->array;
    int idx;
    int pos = mtgp32->params.pos;
    int large_size = mtgp32->status->large_size;
    uint32_t large_mask = mtgp32->status->large_mask;
    int size = mtgp32->status->size;

    mtgp32->status->idx = (mtgp32->status->idx + 1) & large_mask;
    idx = mtgp32->status->idx;
    mtgp32_do_recursion(&(array[idx]),
			array[(idx - size + large_size) & large_mask],
			array[(idx - size + large_size + 1) & large_mask],
			array[(idx + pos - size + large_size) & large_mask],
			mtgp32->params.sh1,
			mtgp32->params.sh2,
			mtgp32->params.mask,
			mtgp32->params.tbl);
}

// Assembly:
movq 0xf0(%rdi), %rdx
movl 0x4(%rdx), %ecx
movl 0x8(%rdx), %r8d
movslq 0xc(%rdx), %rax
movslq (%rdx), %rsi
incq %rsi
andq %rax, %rsi
movl 0x4(%rdi), %r9d
addl %r8d, %r9d
movl %esi, (%rdx)
movl %esi, %r10d
subl %ecx, %r10d
leal (%r10,%r8), %r11d
andl %eax, %r11d
addl %r10d, %r8d
incl %r8d
andl %eax, %r8d
subl %ecx, %r9d
addl %esi, %r9d
andl %eax, %r9d
movl 0x10(%rdx,%r9,4), %r9d
movb 0x8(%rdi), %cl
movl 0xd0(%rdi), %r10d
andl 0x10(%rdx,%r11,4), %r10d
movb 0xc(%rdi), %al
xorl 0x10(%rdx,%r8,4), %r10d
movl %r10d, %r8d
shll %cl, %r8d
movl %eax, %ecx
shrl %cl, %r9d
xorl %r10d, %r9d
xorl %r8d, %r9d
movl %r9d, %eax
andl $0xf, %eax
xorl 0x10(%rdi,%rax,4), %r9d
movl %r9d, 0x10(%rdx,%rsi,4)
retq
// File: /workspace/github_c_makefile_star2_O2/keiranrowan[P]tiny-core/./src/hostname.c
// Function: main
int main(int argc, char **argv) {
	if (argc > 1) {
		if ((strcmp(argv[1], "-h") == 0) || (strcmp(argv[1], "--help") == 0)) {
			printf("hostname [-s] <hostname>\n");
			printf("No arguments prints hostname\n");
		} else if (strcmp(argv[1], "-s") == 0) {
			const char *hostname = argv[2];
			int err = sethostname(hostname, strlen(hostname)); 
			if (err != 0) {
				printf("Error setting hostname\n");
				return 1;
			} else {
				printf("Hostname set.\n");
				return 0;
			}
		}
	} else {
		char hostname[HOST_NAME_MAX + 1];
		int err = gethostname(hostname, HOST_NAME_MAX + 1);
		if (err != 0) {
			printf("Error getting hostname.\n");
			return 1;
		} else {
			printf("%s\n", hostname);
			return 0;
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
cmpl $0x2, %edi
jl 0x11fe
movq %rsi, %r14
movq 0x8(%rsi), %r15
movb (%r15), %bpl
cmpb $0x2d, %bpl
jne 0x11a9
cmpb $0x68, 0x1(%r15)
jne 0x11a9
cmpb $0x0, 0x2(%r15)
je 0x1225
leaq 0xe54(%rip), %rsi       # 0x2004
movq %r15, %rdi
callq 0x1050
testl %eax, %eax
je 0x1225
xorl %ebx, %ebx
cmpb $0x2d, %bpl
jne 0x123f
cmpb $0x73, 0x1(%r15)
jne 0x123f
cmpb $0x0, 0x2(%r15)
jne 0x123f
movq 0x10(%r14), %r14
movq %r14, %rdi
callq 0x1040
movq %r14, %rdi
movq %rax, %rsi
callq 0x1060
testl %eax, %eax
je 0x124c
leaq 0xe3d(%rip), %rdi       # 0x2031
callq 0x1030
pushq $0x1
popq %rbx
jmp 0x123f
movq %rsp, %r14
pushq $0x41
popq %rsi
movq %r14, %rdi
callq 0x1070
xorl %ebx, %ebx
testl %eax, %eax
setne %bl
leaq 0xdf1(%rip), %rdi       # 0x200b
cmoveq %r14, %rdi
callq 0x1030
jmp 0x123f
leaq 0xe1c(%rip), %rdi       # 0x2048
callq 0x1030
leaq 0xe29(%rip), %rdi       # 0x2061
callq 0x1030
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xdd0(%rip), %rdi       # 0x2023
jmp 0x121e
// File: /workspace/github_c_makefile_star2_O2/Joy-Division[P]tools-zoe/subtitle-convert.c
// Function: getModdedLetter
char getModdedLetter( int modifier, int letter ) {
	if( modifier == 0x60 ) { // `
		if( letter == 0x61 ) return 0xE0; // a, à
		if( letter == 0x65 ) return 0xE8; // e, è
		if( letter == 0x6F ) return 0xF2; // o, ò
	}
	if( modifier == 0x5E ) { // ^
		if( letter == 0x75 ) return 0xFB; // u, û
		if( letter == 0x65 ) return 0xEA; // e, ê
	}
	if( modifier == 0x27 ) { // '
		if( letter == 0x65 ) return 0xE9; // e, é
	}
	if( modifier == 0x7E ) { // ~
		if( letter == 0x71 ) return 0xE7; // q, ç
		if( letter == 0x61 ) return 0xE4; // a, ä
		if( letter == 0x6F ) return 0xF6; // o, ö
		if( letter == 0x75 ) return 0xFC; // u, ü
		if( letter == 0x73 ) return 0xDF; // s, ß
	}
	if( modifier == 0x40 ) { // @
		if( letter == 0x65 ) return 0x9C; // o, œ
	}
	return 0;
}

// Assembly:
cmpl $0x5e, %edi
je 0x1248
cmpl $0x60, %edi
jne 0x1255
cmpl $0x61, %esi
je 0x12ac
cmpl $0x6f, %esi
je 0x12a9
cmpl $0x65, %esi
jne 0x128d
movb $-0x18, %al
retq
cmpl $0x75, %esi
je 0x12a6
cmpl $0x65, %esi
jne 0x128d
movb $-0x16, %al
retq
cmpl $0x27, %edi
sete %dl
cmpl $0x65, %esi
sete %cl
movb $-0x17, %al
testb %cl, %dl
jne 0x1247
cmpl $0x7e, %edi
jne 0x1293
addl $-0x61, %esi
rorl %esi
cmpl $0xb, %esi
jae 0x1293
movl $0x781, %eax            # imm = 0x781
btl %esi, %eax
jae 0x1293
movl %esi, %eax
leaq 0xe28(%rip), %rcx       # 0x20b1
movb (%rax,%rcx), %al
retq
cmpl $0x65, %esi
sete %cl
xorl %edx, %edx
testb %cl, %cl
movl $0x9c, %eax
cmovel %edx, %eax
cmpl $0x40, %edi
cmovnel %edx, %eax
retq
movb $-0x5, %al
retq
movb $-0xe, %al
retq
movb $-0x20, %al
retq
// File: /workspace/github_c_makefile_star2_O2/Joy-Division[P]tools-zoe/subtitle-convert.c
// Function: processLine
char *processLine( char *line ) {
	char *retline = malloc( strlen(line)+1 );
	int i, e = 0, modifier, letter;
	for( i = 0; i < strlen(line) + 1; i++ ) {
		if( line[i] != 0x26 ) { // &
			retline[e] = line[i];
			e++;
		}
		else {
			i++;
			modifier = line[i];
			i++;
			letter = line[i];
			retline[e] = getModdedLetter( modifier, letter );
			e++;
		}
	}
	return retline;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x1080
movq %rax, %r14
incq %r14
movq %r14, %rdi
callq 0x10c0
movq %rax, %r15
xorl %ecx, %ecx
movq %rax, %r12
movslq %ecx, %r13
cmpq %r13, %r14
jbe 0x1309
movb (%rbx,%r13), %al
cmpb $0x26, %al
jne 0x12fe
movsbl 0x1(%rbx,%r13), %edi
movsbl 0x2(%rbx,%r13), %esi
addq $0x2, %r13
callq 0x122c
movl %r13d, %ecx
movb %al, (%r12)
incl %ecx
incq %r12
jmp 0x12d6
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/ch2/eatyguy2.c
// Function: getkey
int getkey() {

  // Make reading from stdin non-blocking.
  int flags = fcntl(STDIN_FILENO, F_GETFL);
  fcntl(STDIN_FILENO, F_SETFL, flags | O_NONBLOCK);

  int ch = getchar();

  // Turn off non-blocking I/O. On some systems, leaving stdin
  // non-blocking will also leave stdout non-blocking, which
  // can cause printing errors.
  fcntl(STDIN_FILENO, F_SETFL, flags);
  return ch;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
pushq $0x3
popq %rsi
xorl %edi, %edi
xorl %eax, %eax
callq 0x4100
movl %eax, %ebx
movl %eax, %edx
orl $0x800, %edx            # imm = 0x800
pushq $0x4
popq %r14
xorl %edi, %edi
movl %r14d, %esi
xorl %eax, %eax
callq 0x4100
callq 0x4270
movl %eax, %r15d
xorl %edi, %edi
movl %r14d, %esi
movl %ebx, %edx
xorl %eax, %eax
callq 0x4100
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/ch2/eatyguy2.c
// Function: main
int main() {

  start();

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

  // Make our Lua-callable functions visible to Lua.
  lua_register(L, "set_color", set_color);
  lua_register(L, "set_pos",   set_pos);
  lua_register(L, "timestamp", timestamp);

  // Load eatyguy2.lua and run the init() function.
  luaL_dofile(L, "eatyguy2.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) {
    // Call eatyguy.loop().
    lua_getfield(L, -1, "loop");
    lua_call(L, 0, 0);

    int c = getkey();
    if (c == ESC_KEY || c == 'q' || c == 'Q') done();
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
callq 0x46a5
callq 0x12e12
movq %rax, %rbx
movq %rax, %rdi
callq 0x13038
leaq -0x113(%rip), %rsi      # 0x46fd
movq %rbx, %rdi
xorl %edx, %edx
callq 0x5232
leaq 0x1985b(%rip), %rsi     # 0x1e07c
movq %rbx, %rdi
callq 0x5671
leaq -0xcd(%rip), %rsi       # 0x4763
movq %rbx, %rdi
xorl %edx, %edx
callq 0x5232
leaq 0x19845(%rip), %rsi     # 0x1e086
movq %rbx, %rdi
callq 0x5671
leaq -0x86(%rip), %rsi       # 0x47ca
movq %rbx, %rdi
xorl %edx, %edx
callq 0x5232
leaq 0x1982d(%rip), %rsi     # 0x1e08e
movq %rbx, %rdi
callq 0x5671
leaq 0x19828(%rip), %rsi     # 0x1e098
movq %rbx, %rdi
xorl %edx, %edx
callq 0x125e3
testl %eax, %eax
jne 0x4893
pushq $-0x1
popq %rdx
movq %rbx, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x5b40
leaq 0x1980b(%rip), %r15     # 0x1e0a5
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5671
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4a59
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5300
leaq 0x197ec(%rip), %rdx     # 0x1e0ad
pushq $-0x1
popq %r14
movq %rbx, %rdi
movl %r14d, %esi
callq 0x541c
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x5ad8
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5300
leaq 0x1a288(%rip), %r15     # 0x1eb7b
movq %rbx, %rdi
movl %r14d, %esi
movq %r15, %rdx
callq 0x541c
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x5ad8
callq 0x4651
cmpl $0x1b, %eax
je 0x4926
cmpl $0x71, %eax
je 0x4926
cmpl $0x51, %eax
jne 0x48f3
callq 0x46da
nop
// File: /workspace/github_c_makefile_star2_O2/jflatow[P]jfdb/src/jfdb.c
// Function: usage
static int usage(int isError) {
  fprintf(isError ? stderr : stdout,
          "Usage: \n"
          " jfdb meta /db/path\n"
          " jfdb node /db/path [offset]\n"
          " jfdb keys /db/path [-n] [-p|-i] [prefix]\n"
          " jfdb find /db/path [-n] [-p|-i] [prefix]\n"
          " jfdb load /db/path\n"
          " jfdb wipe /db/path\n"
          " jfdb crush /db/path\n");
  return isError;
}

// Assembly:
pushq %rbx
movl %edi, %ebx
testl %edi, %edi
jne 0x188f
movq 0x7733(%rip), %rax      # 0x8fc0
jmp 0x1896
movq 0x7762(%rip), %rax      # 0x8ff8
movq (%rax), %rcx
leaq 0x4913(%rip), %rdi      # 0x61b3
pushq $0x1
popq %rdx
movl $0xca, %esi
callq 0x1200
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/openshmem-org[P]openshmem-examples/c++/hello.cxx
// Function: main
int
main(void)
{
    struct utsname u;

    uname(&u);

    shmem_init();

    const int me = shmem_my_pe();
    const int npes = shmem_n_pes();

    std::cout << u.nodename
              << " hello from PE " << me
              << " of " << npes
              << "\n";

    shmem_finalize();

    return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
leaq 0x2(%rsp), %rdi
callq 0x1030
callq 0x10b0
callq 0x1080
movl %eax, %ebp
callq 0x1060
movl %eax, %ebx
leaq 0x43(%rsp), %rsi
movq 0x2dba(%rip), %rdi      # 0x3fd8
callq 0x1070
leaq 0xdda(%rip), %rsi       # 0x2004
movq %rax, %rdi
callq 0x1070
movq %rax, %rdi
movl %ebp, %esi
callq 0x10a0
leaq 0xdd1(%rip), %rsi       # 0x2014
movq %rax, %rdi
callq 0x1070
movq %rax, %rdi
movl %ebx, %esi
callq 0x10a0
leaq 0xdbd(%rip), %rsi       # 0x2019
movq %rax, %rdi
callq 0x1070
callq 0x1040
xorl %eax, %eax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/theck01[P]offbrand_lib/src/classes/obmap.c
// Function: obmap_new_with_capacity
obmap * obmap_new_with_capacity(uint32_t capacity){

  obmap *m = obmap_create_default();

  uint32_t i = 0;
  while(MAP_CAPACITIES[i] < capacity && i < NUM_CAPACITIES - 1) i++;

  m->hash_table = obvector_new(MAP_CAPACITIES[i]);
  m->pairs = obdeque_new();
  m->cap_idx = i;

  return m;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebp
leaq 0x3b10(%rip), %r15      # 0x53f0
xorl %r14d, %r14d
callq 0x1929
movq %rax, %rbx
movq %r14, %rax
movl (%r15), %edi
incq %r14
cmpq $0x18, %rax
ja 0x1902
addq $0x4, %r15
cmpl %ebp, %edi
jb 0x18eb
callq 0x2724
movq %rax, 0x10(%rbx)
callq 0x3474
movq %rax, 0x18(%rbx)
decb %r14b
movb %r14b, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/theck01[P]offbrand_lib/src/classes/obmap.c
// Function: obmap_create_default
obmap * obmap_create_default(void){

  static const char classname[] = "obmap";
  obmap *new_instance = malloc(sizeof(obmap));
  assert(new_instance != NULL);

  /* initialize base class data */
  ob_init_base((obj *)new_instance, &obmap_destroy, &obmap_hash,
           &obmap_compare, &obmap_display, classname);

  new_instance->hash_table = NULL;
  new_instance->pairs = NULL;
  new_instance->cap_idx = 0;
  new_instance->collisions = 0;

  return new_instance;
}

// Assembly:
pushq %rbx
pushq $0x28
popq %rdi
callq 0x10b0
testq %rax, %rax
je 0x1979
movq %rax, %rbx
leaq 0x89f(%rip), %rsi       # 0x21e0
leaq 0x902(%rip), %rdx       # 0x224a
leaq 0x9f2(%rip), %rcx       # 0x2341
leaq 0xac5(%rip), %r8        # 0x241b
leaq 0x3b16(%rip), %r9       # 0x5473
movq %rax, %rdi
callq 0x31d8
movb $0x0, 0x8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
andl $0x0, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
retq
leaq 0x3c0b(%rip), %rdi      # 0x558b
leaq 0x3afa(%rip), %rsi      # 0x5481
leaq 0x3dae(%rip), %rcx      # 0x573c
movl $0x13b, %edx            # imm = 0x13B
callq 0x1050
// File: /workspace/github_c_makefile_star2_O2/theck01[P]offbrand_lib/src/classes/obmap.c
// Function: obmap_copy
obmap * obmap_copy(const obmap *to_copy){

  obmap *copy;
  obmap_pair *mp;
  obdeque_iterator *it;

  assert(to_copy);

  copy = obmap_create_default();

  copy->cap_idx = to_copy->cap_idx;
  copy->collisions = to_copy->collisions;
  copy->pairs = obdeque_new();

  /* copy deque manually, internal objects need to be copied as well as Deque
   * itself */
  it = obdeque_head_iterator(to_copy->pairs);
  if(it){
    do{
       mp = obmap_copy_pair((obmap_pair *)obdeque_obj_at_iterator(to_copy->pairs, it));
       obdeque_add_at_tail(copy->pairs, (obj *)mp);
       ob_release((obj *)mp);
    }while(obdeque_iterate_next(to_copy->pairs, it));
  }
  ob_release((obj *)it);

  obmap_rehash(copy); /* cannot grab to_copy->hash_table directly, stored
                         iterators must point to values within copy, not to copy */

  return copy;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1a36
movq %rdi, %r14
callq 0x1929
movq %rax, %rbx
movb 0x8(%r14), %al
movb %al, 0x8(%rbx)
movl 0x20(%r14), %eax
movl %eax, 0x20(%rbx)
callq 0x3474
movq %rax, 0x18(%rbx)
movq 0x18(%r14), %rdi
callq 0x355d
movq %rax, %r15
testq %rax, %rax
je 0x1a17
movq 0x18(%r14), %rdi
movq %r15, %rsi
callq 0x3589
movq %rax, %rdi
callq 0x1a53
movq %rax, %r12
movq 0x18(%rbx), %rdi
movq %rax, %rsi
callq 0x360a
movq %r12, %rdi
callq 0x33aa
movq 0x18(%r14), %rdi
movq %r15, %rsi
callq 0x3682
testb %al, %al
jne 0x19dc
movq %r15, %rdi
callq 0x33aa
movq %rbx, %rdi
callq 0x1a88
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x3a3c(%rip), %rdi      # 0x5479
leaq 0x3a3d(%rip), %rsi      # 0x5481
leaq 0x3a4a(%rip), %rcx      # 0x5495
pushq $0x4d
popq %rdx
callq 0x1050
// File: /workspace/github_c_makefile_star2_O2/theck01[P]offbrand_lib/src/classes/obmap.c
// Function: obmap_rehash
void obmap_rehash(obmap *m){

  obdeque_iterator *it, *it_copy;

  assert(m);

  ob_release((obj *)m->hash_table);
  m->hash_table = obvector_new(MAP_CAPACITIES[m->cap_idx]);

  it = obdeque_head_iterator(m->pairs);
  if(!it) return;

  do{
    it_copy = obdeque_copy_iterator(it);
    obmap_add_to_table(m, it_copy);
    ob_release((obj *)it_copy);
  }while(obdeque_iterate_next(m->pairs, it));

  ob_release((obj *)it);

  return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1b07
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x33aa
movzbl 0x8(%rbx), %eax
leaq 0x3947(%rip), %rcx      # 0x53f0
movl (%rcx,%rax,4), %edi
callq 0x2724
movq %rax, 0x10(%rbx)
movq 0x18(%rbx), %rdi
callq 0x355d
testq %rax, %rax
je 0x1b01
movq %rax, %r14
movq %r14, %rdi
callq 0x3813
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1dfa
movq %r15, %rdi
callq 0x33aa
movq 0x18(%rbx), %rdi
movq %r14, %rsi
callq 0x3682
testb %al, %al
jne 0x1ac6
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x33aa
popq %rbx
popq %r14
popq %r15
retq
leaq 0x39a8(%rip), %rdi      # 0x54b6
leaq 0x396c(%rip), %rsi      # 0x5481
leaq 0x3a3a(%rip), %rcx      # 0x5556
movl $0xb4, %edx
callq 0x1050
// File: /workspace/github_c_makefile_star2_O2/theck01[P]offbrand_lib/src/classes/obmap.c
// Function: obmap_insert
void obmap_insert(obmap *m, obj *key, obj *value){

  obmap_pair *mp;
  obdeque_iterator *it;
  ob_hash_t hash_value;

  assert(m);

  hash_value = obmap_find_key(m, key);
  it = (obdeque_iterator *)obvector_obj_at_index(m->hash_table, hash_value);

  /* If the key already exists in the map then overwrite the existing
   * value */
  if(it){
    mp = (obmap_pair *)obdeque_obj_at_iterator(m->pairs, it);
    obmap_replace_pair_value(mp, value);
    return;
  }

  /* if add operation will overload the map then resize the map */
  if((obdeque_length(m->pairs)+1)/MAP_CAPACITIES[m->cap_idx] > MAX_LOAD_FACTOR)
    obmap_increase_size(m);

  mp = obmap_new_pair(key, value);
  obdeque_add_at_tail(m->pairs, (obj *)mp);
  ob_release((obj *)mp); /* map deque has only reference to mp */

  assert(it = obdeque_tail_iterator(m->pairs));
  obmap_add_to_table(m, it);
  ob_release((obj *)it); /* map vector hash only reference to it */

  return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1bdd
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x1c19
movq 0x10(%rbx), %rdi
movq %rax, %rsi
callq 0x2a4a
movq 0x18(%rbx), %rdi
testq %rax, %rax
je 0x1b6f
movq %rax, %rsi
callq 0x3589
movq %rax, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x1cc8
callq 0x3745
incq %rax
movzbl 0x8(%rbx), %ecx
leaq 0x386e(%rip), %rdx      # 0x53f0
movl (%rdx,%rcx,4), %ecx
cmpq %rcx, %rax
jb 0x1b92
movq %rbx, %rdi
callq 0x1d13
movq %r15, %rdi
movq %r14, %rsi
callq 0x1d79
movq %rax, %r14
movq 0x18(%rbx), %rdi
movq %rax, %rsi
callq 0x360a
movq %r14, %rdi
callq 0x33aa
movq 0x18(%rbx), %rdi
callq 0x37e7
testq %rax, %rax
je 0x1bfa
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1dfa
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x33aa
leaq 0x38d2(%rip), %rdi      # 0x54b6
leaq 0x3896(%rip), %rsi      # 0x5481
leaq 0x38c6(%rip), %rcx      # 0x54b8
pushq $0x6e
popq %rdx
callq 0x1050
leaq 0x38e0(%rip), %rdi      # 0x54e1
leaq 0x3879(%rip), %rsi      # 0x5481
leaq 0x38a9(%rip), %rcx      # 0x54b8
movl $0x83, %edx
callq 0x1050
// File: /workspace/github_c_makefile_star2_O2/theck01[P]offbrand_lib/src/classes/obmap.c
// Function: obmap_find_key
ob_hash_t obmap_find_key(const obmap *m, const obj *key){

  ob_hash_t hash_value, offset;
  obmap_pair *mp;
  obdeque_iterator *it;

  hash_value = ob_hash(key)%MAP_CAPACITIES[m->cap_idx];
  offset = 0;

  while((it = (obdeque_iterator *)obvector_obj_at_index(m->hash_table, hash_value))){
    mp = (obmap_pair *)obdeque_obj_at_iterator(m->pairs, it);
    if(ob_compare(mp->key, key) == OB_EQUAL_TO)
      break;
    offset = obmap_offset_collision(offset);
    hash_value = (hash_value+offset)%MAP_CAPACITIES[m->cap_idx];
  }

  return hash_value; /* the hash value where key is actually found */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x32ba
movzbl 0x8(%r14), %ecx
leaq 0x37b2(%rip), %r12      # 0x53f0
movl (%r12,%rcx,4), %ecx
xorl %ebp, %ebp
xorl %edx, %edx
divq %rcx
movq %rdx, %r15
pushq $0x1
popq %r13
movq 0x10(%r14), %rdi
movq %r15, %rsi
callq 0x2a4a
testq %rax, %rax
je 0x1cb6
movq 0x18(%r14), %rdi
movq %rax, %rsi
callq 0x3589
movq 0x8(%rax), %rdi
movq %rbx, %rsi
callq 0x32f3
testb %al, %al
je 0x1cb6
movq %r13, %rcx
testq %rbp, %rbp
je 0x1c9a
cmpq $0x1, %rbp
jne 0x1c90
pushq $0x2
popq %rcx
jmp 0x1c9a
imulq %rbp, %rbp
decq %rbp
movq %rbp, %rcx
addq %rcx, %r15
movzbl 0x8(%r14), %eax
movl (%r12,%rax,4), %esi
movq %r15, %rax
xorl %edx, %edx
divq %rsi
movq %rcx, %rbp
movq %rdx, %r15
jmp 0x1c50
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/theck01[P]offbrand_lib/src/classes/obmap.c
// Function: obmap_replace_pair_value
void obmap_replace_pair_value(obmap_pair *mp, obj *value){

  assert(mp);

  ob_retain(value);
  ob_release(mp->value);
  mp->value = value;
  return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1cf4
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x33df
movq 0x10(%r14), %rdi
callq 0x33aa
movq %rbx, 0x10(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x38ce(%rip), %rdi      # 0x55c9
leaq 0x377f(%rip), %rsi      # 0x5481
leaq 0x38ed(%rip), %rcx      # 0x55f6
movl $0xf1, %edx
callq 0x1050
// File: /workspace/github_c_makefile_star2_O2/theck01[P]offbrand_lib/src/classes/obmap.c
// Function: obmap_increase_size
void obmap_increase_size(obmap *to_size){

  assert(to_size);
  assert(to_size->cap_idx < NUM_CAPACITIES-1); /* cannot resize beyond largest
                                                  capacity */

  to_size->cap_idx+=2;
  if(to_size->cap_idx >= NUM_CAPACITIES) to_size->cap_idx = NUM_CAPACITIES-1;
  to_size->collisions = 0; /* before resize reset collisions */

  obmap_rehash(to_size);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x1d3b
movb 0x8(%rdi), %al
cmpb $0x19, %al
jae 0x1d5a
leal 0x2(%rax), %ecx
cmpb $0x18, %al
movzbl %cl, %eax
pushq $0x19
popq %rcx
cmovnel %eax, %ecx
movb %cl, 0x8(%rdi)
andl $0x0, 0x20(%rdi)
popq %rax
jmp 0x1a88
leaq 0x3b68(%rip), %rdi      # 0x58aa
leaq 0x3738(%rip), %rsi      # 0x5481
leaq 0x3b62(%rip), %rcx      # 0x58b2
movl $0x1a6, %edx            # imm = 0x1A6
callq 0x1050
leaq 0x3b73(%rip), %rdi      # 0x58d4
leaq 0x3719(%rip), %rsi      # 0x5481
leaq 0x3b43(%rip), %rcx      # 0x58b2
movl $0x1a7, %edx            # imm = 0x1A7
callq 0x1050