LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/darwin-on-arm[P]darwin-sdk/developer_cmds/unifdef/unifdef.c
// Function: eval_table
static Linetype
eval_table(const struct ops *ops, int *valp, const char **cpp)
{
	const struct op *op;
	const char *cp;
	int val;
	Linetype lt, rt;

	debug("eval%d", ops - eval_ops);
	cp = *cpp;
	lt = ops->inner(ops+1, valp, &cp);
	if (lt == LT_ERROR)
		return (LT_ERROR);
	for (;;) {
		cp = skipcomment(cp);
		for (op = ops->op; op->str != NULL; op++)
			if (strncmp(cp, op->str, strlen(op->str)) == 0)
				break;
		if (op->str == NULL)
			break;
		cp += strlen(op->str);
		debug("eval%d %s", ops - eval_ops, op->str);
		rt = ops->inner(ops+1, &val, &cp);
		if (rt == LT_ERROR)
			return (LT_ERROR);
		lt = op->fn(valp, lt, *valp, rt, val);
	}

	*cpp = cp;
	debug("eval%d = %d", ops - eval_ops, *valp);
	debug("eval%d lt = %s", ops - eval_ops, linetype_name[lt]);
	return (lt);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
leaq 0x3880(%rip), %rcx      # 0x7c70
movq %rdi, %rax
subq %rcx, %rax
pushq $0x58
popq %rcx
cqto
idivq %rcx
movq %rax, %rbx
leaq 0x1080(%rip), %rdi      # 0x5488
movq %rax, %rsi
xorl %eax, %eax
callq 0x3caf
movq (%r15), %rax
movq %rsp, %rdx
movq %rax, (%rdx)
leaq 0x58(%r12), %r13
movq %r13, %rdi
movq %r14, %rsi
callq *(%r12)
movl %eax, %ebp
pushq $0x16
popq %rax
cmpl $0x16, %ebp
jne 0x443b
movl %eax, %ebp
jmp 0x452a
movq %r13, 0x28(%rsp)
movq %r15, 0x30(%rsp)
movq %r14, 0x10(%rsp)
movq %rbx, 0x18(%rsp)
leaq 0x10(%r12), %r14
movq %r14, 0x20(%rsp)
movq (%rsp), %rdi
callq 0x3da1
movq %rax, %r15
movq %rax, (%rsp)
movq -0x8(%r14), %r13
testq %r13, %r13
je 0x44e7
movq %r13, %rdi
callq 0x30d0
movq %rax, %rbx
movq %r15, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x3070
testl %eax, %eax
je 0x4495
addq $0x10, %r14
jmp 0x4469
addq %rbx, %r15
movq %r15, (%rsp)
leaq 0xfec(%rip), %rdi       # 0x548f
movq 0x18(%rsp), %rsi
movq %r13, %rdx
xorl %eax, %eax
callq 0x3caf
movq 0x28(%rsp), %rdi
leaq 0xc(%rsp), %rsi
movq %rsp, %rdx
callq *(%r12)
cmpl $0x16, %eax
je 0x453b
movq 0x10(%rsp), %rdi
movl (%rdi), %edx
movl 0xc(%rsp), %r8d
movl %ebp, %esi
movl %eax, %ecx
callq *(%r14)
movl %eax, %ebp
movq 0x20(%rsp), %r14
jmp 0x4459
movq 0x30(%rsp), %rax
movq %r15, (%rax)
movq 0x10(%rsp), %rax
movl (%rax), %edx
leaq 0xf9c(%rip), %rdi       # 0x5499
movq 0x18(%rsp), %rbx
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3caf
movl %ebp, %eax
leaq 0x369b(%rip), %rcx      # 0x7bb0
movq (%rcx,%rax,8), %rdx
leaq 0xf85(%rip), %rdi       # 0x54a5
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3caf
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x16
popq %rbp
jmp 0x452a
// File: /workspace/github_c_makefile_star2_O2/darwin-on-arm[P]darwin-sdk/developer_cmds/unifdef/unifdef.c
// Function: skipargs
static const char *
skipargs(const char *cp)
{
	const char *ocp = cp;
	int level = 0;
	cp = skipcomment(cp);
	if (*cp != '(')
		return (cp);
	do {
		if (*cp == '(')
			level++;
		if (*cp == ')')
			level--;
		cp = skipcomment(cp+1);
	} while (level != 0 && *cp != '\0');
	if (level == 0)
		return (cp);
	else
	/* Rewind and re-detect the syntax error later. */
		return (ocp);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x3da1
cmpb $0x28, (%rax)
jne 0x4a83
xorl %ebp, %ebp
movb $0x28, %cl
xorl %edx, %edx
cmpb $0x28, %cl
sete %dl
addl %edx, %ebp
xorl %r14d, %r14d
cmpb $0x29, %cl
sete %r14b
incq %rax
movq %rax, %rdi
callq 0x3da1
subl %r14d, %ebp
je 0x4a83
movb (%rax), %cl
testb %cl, %cl
jne 0x4a56
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/darwin-on-arm[P]darwin-sdk/developer_cmds/unifdef/unifdef.c
// Function: done
static void
done(void)
{
	if (incomment)
		error("EOF in comment");
	closeout();
	if (overwriting && rename(tempname, ofilename) == -1) {
		warn("couldn't rename temporary file");
		unlink(tempname);
		errx(2, "%s unchanged", ofilename);
	}
	exit(exitstat);
}

// Assembly:
pushq %rax
cmpl $0x0, 0x579a(%rip)      # 0xa2e8
jne 0x4ba8
callq 0x4342
cmpb $0x1, 0x3644(%rip)      # 0x81a0
jne 0x4bb4
movq 0x3613(%rip), %rsi      # 0x8178
leaq 0x3644(%rip), %rdi      # 0x81b0
callq 0x3220
cmpl $-0x1, %eax
jne 0x4bb4
leaq 0xa4a(%rip), %rdi       # 0x55c7
xorl %eax, %eax
callq 0x3090
leaq 0x3625(%rip), %rdi      # 0x81b0
callq 0x3060
movq 0x35e1(%rip), %rdx      # 0x8178
leaq 0x82e(%rip), %rsi       # 0x53cc
pushq $0x2
popq %rdi
xorl %eax, %eax
callq 0x30e0
leaq 0xa09(%rip), %rdi       # 0x55b8
callq 0x3d45
movzbl 0x168ad(%rip), %edi     # 0x1b468
callq 0x3240
// File: /workspace/github_c_makefile_star2_O2/darwin-on-arm[P]darwin-sdk/developer_cmds/unifdef/unifdef.c
// Function: nest
static void
nest(void)
{
	if (depth > MAXDEPTH-1)
		abort(); /* bug */
	if (depth == MAXDEPTH-1)
		error("Too many levels of nesting");
	depth += 1;
	stifline[depth] = linenum;
}

// Assembly:
pushq %rax
movslq 0x4514(%rip), %rax      # 0x92c0
cmpq $0x40, %rax
jge 0x4dd4
cmpl $0x3f, %eax
je 0x4dd9
leaq 0x1(%rax), %rcx
movl %ecx, 0x44ff(%rip)      # 0x92c0
movl 0x44fd(%rip), %ecx      # 0x92c4
leaq 0xe532(%rip), %rdx      # 0x13300
movl %ecx, 0x4(%rdx,%rax,4)
popq %rax
retq
callq 0x3040
leaq 0x770(%rip), %rdi       # 0x5550
callq 0x3d45
// File: /workspace/github_c_makefile_star2_O2/darwin-on-arm[P]darwin-sdk/developer_cmds/unifdef/unifdef.c
// Function: flushline
static void
flushline(bool keep)
{
	if (symlist)
		return;
	if (keep ^ complement) {
		bool blankline = tline[strspn(tline, " \t\r\n")] == '\0';
		if (blankline && compblank && blankcount != blankmax) {
			delcount += 1;
			blankcount += 1;
		} else {
			if (lnnum && delcount > 0 &&
			    fprintf(output, "#line %d%s", linenum, newline) < 0)
				closeout();
			if (fputs(tline, output) == EOF)
				closeout();
			delcount = 0;
			blankmax = blankcount = blankline ? blankcount + 1 : 0;
		}
	} else {
		if (lnblank && fputs(newline, output) == EOF)
			closeout();
		exitstat = 1;
		delcount += 1;
		blankcount = 0;
	}
	if (debugging && fflush(output) == EOF)
		closeout();
}

// Assembly:
pushq %rbx
cmpb $0x0, 0x3393(%rip)      # 0x8180
jne 0x4f0a
cmpb %dil, 0x3378(%rip)      # 0x8172
je 0x4eb6
leaq 0x44c9(%rip), %rbx      # 0x92d0
leaq 0x79a(%rip), %rsi       # 0x55a8
movq %rbx, %rdi
callq 0x3140
movb (%rax,%rbx), %bl
testb %bl, %bl
jne 0x4e38
cmpb $0x1, 0x334d(%rip)      # 0x8171
jne 0x4e38
movl 0x4384(%rip), %eax      # 0x91b0
cmpl 0x4382(%rip), %eax      # 0x91b4
jne 0x4f12
cmpb $0x1, 0x3338(%rip)      # 0x8177
jne 0x4e75
cmpl $0x0, 0x1661c(%rip)     # 0x1b464
jle 0x4e75
movq 0x3347(%rip), %rdi      # 0x8198
movl 0x446d(%rip), %edx      # 0x92c4
movq 0x5482(%rip), %rcx      # 0xa2e0
leaq 0x748(%rip), %rsi       # 0x55ad
xorl %eax, %eax
callq 0x3180
testl %eax, %eax
jns 0x4e75
callq 0x4342
movq 0x331c(%rip), %rsi      # 0x8198
leaq 0x444d(%rip), %rdi      # 0x92d0
callq 0x3130
cmpl $-0x1, %eax
jne 0x4e92
callq 0x4342
andl $0x0, 0x165cb(%rip)     # 0x1b464
movl 0x4311(%rip), %eax      # 0x91b0
incl %eax
xorl %ecx, %ecx
testb %bl, %bl
cmovel %eax, %ecx
movl %ecx, 0x4302(%rip)      # 0x91b0
movl %ecx, 0x4300(%rip)      # 0x91b4
jmp 0x4ef0
cmpb $0x1, 0x32b3(%rip)      # 0x8170
jne 0x4edc
movq 0x541a(%rip), %rdi      # 0xa2e0
movq 0x32cb(%rip), %rsi      # 0x8198
callq 0x3130
cmpl $-0x1, %eax
jne 0x4edc
callq 0x4342
incl 0x16582(%rip)           # 0x1b464
movb $0x1, 0x1657f(%rip)     # 0x1b468
andl $0x0, 0x42c0(%rip)      # 0x91b0
cmpb $0x1, 0x327c(%rip)      # 0x8173
jne 0x4f0a
movq 0x3298(%rip), %rdi      # 0x8198
callq 0x31d0
cmpl $-0x1, %eax
je 0x4f0c
popq %rbx
retq
popq %rbx
jmp 0x4342
incl 0x1654c(%rip)           # 0x1b464
incl %eax
movl %eax, 0x4290(%rip)      # 0x91b0
jmp 0x4ef0
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/ch4/eatyguy6.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");
  luaL_dofile(L, "Character.lua");
  lua_setglobal(L, "Character");

  // Load eatyguy6 and run the init() function.
  luaL_dofile(L, "eatyguy6.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");
    push_state_table(L, key, is_end_of_seq);
    lua_call(L, 1, 0);

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

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x5742
callq 0x13ed2
movq %rax, %rbx
movq %rax, %rdi
callq 0x140f8
leaq -0x4a(%rip), %rsi       # 0x5839
movq %rbx, %rdi
xorl %edx, %edx
callq 0x62f2
leaq 0x197f7(%rip), %rsi     # 0x1f08b
movq %rbx, %rdi
callq 0x6731
leaq 0x197f2(%rip), %rsi     # 0x1f095
movq %rbx, %rdi
xorl %edx, %edx
callq 0x136a3
testl %eax, %eax
jne 0x58c6
pushq $-0x1
popq %rdx
movq %rbx, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x6c00
leaq 0x197d1(%rip), %rsi     # 0x1f09e
movq %rbx, %rdi
xorl %edx, %edx
callq 0x136a3
testl %eax, %eax
jne 0x58f0
pushq $-0x1
popq %rdx
movq %rbx, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x6c00
leaq 0x197b5(%rip), %rsi     # 0x1f0ac
movq %rbx, %rdi
callq 0x6731
leaq 0x197b0(%rip), %rsi     # 0x1f0b6
movq %rbx, %rdi
xorl %edx, %edx
callq 0x136a3
testl %eax, %eax
jne 0x5929
pushq $-0x1
popq %rdx
movq %rbx, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x6c00
leaq 0x19793(%rip), %r15     # 0x1f0c3
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6731
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5b19
movq %rbx, %rdi
movq %r15, %rsi
callq 0x63c0
leaq 0x19774(%rip), %rdx     # 0x1f0cb
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x64dc
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x6b98
movq %rbx, %rdi
movq %r15, %rsi
callq 0x63c0
leaq -0x2c(%rbp), %r15
leaq 0x1a212(%rip), %r12     # 0x1fb9b
pushq $0x1
popq %r13
movq %r15, %rdi
callq 0x5661
cmpl $0x1b, %eax
je 0x59e5
movl %eax, %r14d
cmpl $0x71, %eax
je 0x59e5
cmpl $0x51, %r14d
je 0x59e5
movq %rbx, %rdi
pushq $-0x1
popq %rsi
movq %r12, %rdx
callq 0x64dc
movl -0x2c(%rbp), %edx
movq %rbx, %rdi
movl %r14d, %esi
callq 0x57d0
movq %rbx, %rdi
movl %r13d, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x6b98
movsd 0x1963a(%rip), %xmm0    # 0x1f018
callq 0x56ed
jmp 0x598d
callq 0x5777
nop
// File: /workspace/github_c_makefile_star2_O2/mortie[P]makeschem/makeschem.c
// Function: nbt_write_int
int nbt_write_int(FILE *f, int32_t val) {
	char bytes[] = {
		(val & 0xff000000l) >> 24, (val & 0x00ff0000l) >> 16,
		(val & 0x0000ff00l) >> 8, val & 0x000000ffl,
	};
	return fwrite(bytes, 1, 4, f) == 4;
}

// Assembly:
pushq %rax
movq %rdi, %rcx
bswapl %esi
leaq 0x4(%rsp), %rdi
movl %esi, (%rdi)
pushq $0x1
popq %rsi
pushq $0x4
popq %rdx
callq 0xc0f0
xorl %ecx, %ecx
cmpq $0x4, %rax
sete %cl
movl %ecx, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/mortie[P]makeschem/makeschem.c
// Function: mappings_lookup
struct mapping *mappings_lookup(const char *name) {
	size_t start = 0;
	size_t end = legacy_mappings_len - 1;
	while (1) {
		size_t mid = (end - start) / 2 + start;
		struct mapping *m = &legacy_mappings[mid];
		int cmp = strcmp(name, m->name);
		if (cmp > 0) {
			start = mid;
		} else if (cmp < 0) {
			end = mid;
		} else {
			return m;
		}

		if (start >= end) {
			fprintf(stderr, "nothing found\n");
			return NULL;
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x193b3(%rip), %rax     # 0x25730
movq (%rax), %r15
decq %r15
xorl %r13d, %r13d
leaq 0x11d03(%rip), %r12     # 0x1e090
movq %r15, %rbp
subq %r13, %rbp
shrq %rbp
addq %r13, %rbp
movq %rbp, %rax
shlq $0x4, %rax
leaq (%r12,%rax), %r14
movq (%r12,%rax), %rsi
movq %rbx, %rdi
callq 0xc090
testl %eax, %eax
jle 0xc3b9
movq %rbp, %r13
jmp 0xc3be
movq %rbp, %r15
jns 0xc3e2
cmpq %r15, %r13
jb 0xc38d
movq 0x11c2e(%rip), %rax     # 0x1dff8
movq (%rax), %rcx
leaq 0xc30(%rip), %rdi       # 0xd004
pushq $0xe
popq %rsi
pushq $0x1
popq %rdx
callq 0xc0f0
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mortie[P]makeschem/makeschem.c
// Function: blocks_find_or_create_chunk
size_t blocks_find_or_create_chunk(struct blocks *blocks, size_t chunkx, size_t chunky, size_t chunkz) {
	for (size_t i = 0; i < blocks->chunkcount; ++i) {
		struct blockchunk *chunk = &blocks->chunks[i];
		if (chunk->x == chunkx && chunk->y == chunky && chunk->z == chunkz) {
			return i;
		}
	}

	size_t idx = blocks->chunkcount;
	blocks->chunkcount += 1;
	blocks->chunks = realloc(blocks->chunks, sizeof(struct blockchunk) * blocks->chunkcount);
	struct blockchunk *chunk = &blocks->chunks[idx];
	memset(chunk->blocks, 0, sizeof(chunk->blocks));
	memset(chunk->data, 0, sizeof(chunk->data));
	chunk->x = chunkx;
	chunk->y = chunky;
	chunk->z = chunkz;
	return idx;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq 0x20(%rdi), %rbx
pushq $0x10
popq %rcx
xorl %eax, %eax
cmpq %rax, %rbx
je 0xc482
movq 0x18(%r13), %rdx
cmpq %r12, -0x10(%rdx,%rcx)
jne 0xc476
cmpq %r15, -0x8(%rdx,%rcx)
jne 0xc476
cmpq %r14, (%rdx,%rcx)
je 0xc4da
incq %rax
addq $0x2018, %rcx           # imm = 0x2018
jmp 0xc459
leaq 0x1(%rbx), %rax
movq %rax, 0x20(%r13)
movq 0x18(%r13), %rdi
imulq $0x2018, %rbx, %rbp     # imm = 0x2018
leaq 0x2018(%rbp), %rsi
callq 0xc0c0
movq %rax, 0x18(%r13)
leaq (%rax,%rbp), %r13
addq $0x18, %r13
movl $0x2000, %edx           # imm = 0x2000
movq %r13, %rdi
xorl %esi, %esi
callq 0xc070
movq %r12, -0x18(%r13)
movq %r15, -0x10(%r13)
movq %r14, -0x8(%r13)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0xc4c8
// File: /workspace/github_c_makefile_star2_O2/mortie[P]makeschem/makeschem.c
// Function: blocks_find_chunk
ssize_t blocks_find_chunk(struct blocks *blocks, size_t chunkx, size_t chunky, size_t chunkz) {
	for (size_t i = 0; i < blocks->chunkcount; ++i) {
		struct blockchunk *chunk = &blocks->chunks[i];
		if (chunk->x == chunkx && chunk->y == chunky && chunk->z == chunkz) {
			return i;
		}
	}

	return -1;
}

// Assembly:
movq 0x20(%rdi), %r8
pushq $0x10
popq %r10
xorl %r9d, %r9d
pushq $-0x1
popq %rax
cmpq %r8, %r9
jae 0xc519
movq 0x18(%rdi), %r11
cmpq %rsi, -0x10(%r11,%r10)
jne 0xc50a
cmpq %rdx, -0x8(%r11,%r10)
jne 0xc50a
cmpq %rcx, (%r11,%r10)
je 0xc516
incq %r9
addq $0x2018, %r10           # imm = 0x2018
jmp 0xc4ed
movq %r9, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/mortie[P]makeschem/makeschem.c
// Function: blocks_set
void blocks_set(struct blocks *blocks, size_t x, size_t y, size_t z, uint8_t id, uint8_t data) {
	size_t chunkx = x / CHUNK_SIZE;
	size_t chunky = y / CHUNK_SIZE;
	size_t chunkz = z / CHUNK_SIZE;
	size_t relx = x % CHUNK_SIZE;
	size_t rely = y % CHUNK_SIZE;
	size_t relz = z % CHUNK_SIZE;
	size_t chunkidx = blocks_find_or_create_chunk(blocks, chunkx, chunky, chunkz);
	blockchunk_set(&blocks->chunks[chunkidx], relx, rely, relz, id, data);
	if (x >= blocks->width) blocks->width = x + 1;
	if (y >= blocks->height) blocks->height = y + 1;
	if (z >= blocks->length) blocks->length = z + 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, 0x4(%rsp)
movl %r8d, %r13d
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %rbp
movq %rdi, %r14
shrq $0x4, %rsi
shrq $0x4, %rdx
shrq $0x4, %rcx
movl %ebp, %r12d
andl $0xf, %r12d
callq 0xc439
imulq $0x2018, %rax, %rax     # imm = 0x2018
addq 0x18(%r14), %rax
movl %r15d, %ecx
andl $0xf, %ecx
shll $0x8, %ecx
orq %r12, %rcx
movl %ebx, %edx
shll $0x4, %edx
movzbl %dl, %edx
orq %rcx, %rdx
movb %r13b, 0x18(%rax,%rdx)
movl 0x4(%rsp), %ecx
movb %cl, 0x1018(%rax,%rdx)
cmpq %rbp, (%r14)
ja 0xc58e
incq %rbp
movq %rbp, (%r14)
cmpq %r15, 0x8(%r14)
ja 0xc59b
incq %r15
movq %r15, 0x8(%r14)
cmpq %rbx, 0x10(%r14)
ja 0xc5a8
incq %rbx
movq %rbx, 0x10(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mortie[P]makeschem/makeschem.c
// Function: blocks_get_id
uint8_t blocks_get_id(struct blocks *blocks, size_t x, size_t y, size_t z) {
	size_t chunkx = x / CHUNK_SIZE;
	size_t chunky = y / CHUNK_SIZE;
	size_t chunkz = z / CHUNK_SIZE;
	size_t relx = x % CHUNK_SIZE;
	size_t rely = y % CHUNK_SIZE;
	size_t relz = z % CHUNK_SIZE;
	ssize_t chunkidx = blocks_find_chunk(blocks, chunkx, chunky, chunkz);
	if (chunkidx < 0) {
		return 0;
	}

	return blockchunk_get_id(&blocks->chunks[chunkidx], relx, rely, relz);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
shrq $0x4, %rsi
shrq $0x4, %rdx
shrq $0x4, %rcx
callq 0xc4df
testq %rax, %rax
js 0xc60c
andl $0xf, %r12d
andl $0xf, %r14d
shll $0x8, %r14d
orq %r12, %r14
shll $0x4, %r15d
movzbl %r15b, %ecx
orq %r14, %rcx
imulq $0x2018, %rax, %rax     # imm = 0x2018
addq 0x18(%rbx), %rax
movb 0x18(%rax,%rcx), %al
jmp 0xc60e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/mortie[P]makeschem/makeschem.c
// Function: scdef_read_num
size_t scdef_read_num(char *line, size_t *idx) {
	char *end;
	char *start = &line[*idx];
	long num = strtol(start, &end, 10);

	if (num < 0) {
		fprintf(stderr, "Error: Expected positive number\n");
		fprintf(stderr, "  Here: ... %s", start);
		fprintf(stderr, "  Line: %s", line);
		num = 0;
	} else if (end == start) {
		fprintf(stderr, "Error: Expected number\n");
		fprintf(stderr, "  Here: ... %s", start);
		fprintf(stderr, "  Line: %s", line);
		num = 0;
	} else if (end[0] != '\0' && !scdef_is_space(end[0])) {
		fprintf(stderr, "Error: Expected space after number\n");
		fprintf(stderr, "  Here: ... %s", end);
		fprintf(stderr, "  Line: %s", line);
	}

	scdef_skip_to_space(line, idx);
	return num;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %r12
addq %rdi, %r12
leaq 0x8(%rsp), %rsi
pushq $0xa
popq %rdx
movq %r12, %rdi
callq 0xc0b0
testq %rax, %rax
js 0xc789
movq 0x8(%rsp), %r13
cmpq %r12, %r13
je 0xc79e
movq %rax, %r15
movzbl (%r13), %eax
cmpq $0x20, %rax
ja 0xc7f1
movabsq $0x100000601, %rcx      # imm = 0x100000601
btq %rax, %rcx
jae 0xc7f1
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc6e5
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x11868(%rip), %r15     # 0x1dff8
movq (%r15), %rcx
leaq 0x879(%rip), %rdi       # 0xd013
pushq $0x20
jmp 0xc7b1
movq 0x11853(%rip), %r15     # 0x1dff8
movq (%r15), %rcx
leaq 0x89f(%rip), %rdi       # 0xd04e
pushq $0x17
popq %rsi
pushq $0x1
popq %rdx
callq 0xc0f0
movq (%r15), %rdi
leaq 0x870(%rip), %rsi       # 0xd034
xorl %r15d, %r15d
movq %r12, %rdx
xorl %eax, %eax
callq 0xc0a0
movq 0x11820(%rip), %rax     # 0x1dff8
movq (%rax), %rdi
leaq 0x861(%rip), %rsi       # 0xd043
movq %r14, %rdx
xorl %eax, %eax
callq 0xc0a0
jmp 0xc76d
movq 0x11800(%rip), %r12     # 0x1dff8
movq (%r12), %rcx
leaq 0x863(%rip), %rdi       # 0xd066
pushq $0x23
popq %rsi
pushq $0x1
popq %rdx
callq 0xc0f0
movq (%r12), %rdi
leaq 0x81b(%rip), %rsi       # 0xd034
movq %r13, %rdx
jmp 0xc7ca
// File: /workspace/github_c_makefile_star2_O2/mortie[P]makeschem/makeschem.c
// Function: scdef_read_line
void scdef_read_line(struct blocks *blocks, char *line) {
	size_t idx = 0;
	scdef_skip_space(line, &idx);
	size_t x = scdef_read_num(line, &idx);
	scdef_skip_space(line, &idx);
	size_t y = scdef_read_num(line, &idx);
	scdef_skip_space(line, &idx);
	size_t z = scdef_read_num(line, &idx);
	scdef_skip_space(line, &idx);

	char *name = &line[idx];
	scdef_skip_to_space(line, &idx);
	line[idx] = '\0';

	struct mapping *m = mappings_lookup(name);
	if (m == NULL) {
		fprintf(stderr, "(%zu,%zu,%zu): Unknown block name: '%s'\n", x, y, z, name);
	} else {
		blocks_set(blocks, x, y, z, m->id, m->data);
		fprintf(stderr, "(%zu,%zu,%zu): %u:%u\n", x, y, z, m->id, m->data);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r13
movq %rdi, 0x8(%rsp)
leaq 0x10(%rsp), %rbp
andq $0x0, (%rbp)
movq %rsi, %rdi
movq %rbp, %rsi
callq 0xc6bb
movq %r13, %rdi
movq %rbp, %rsi
callq 0xc70f
movq %rax, %rbx
movq %r13, %rdi
movq %rbp, %rsi
callq 0xc6bb
movq %r13, %rdi
movq %rbp, %rsi
callq 0xc70f
movq %rax, %r14
movq %r13, %rdi
movq %rbp, %rsi
callq 0xc6bb
movq %r13, %rdi
movq %rbp, %rsi
callq 0xc70f
movq %rax, %r12
movq %r13, %rdi
movq %rbp, %rsi
callq 0xc6bb
movq (%rbp), %r15
addq %r13, %r15
movq %r13, %rdi
movq %rbp, %rsi
callq 0xc6e5
movq (%rbp), %rax
movb $0x0, (%r13,%rax)
movq %r15, %rdi
callq 0xc368
testq %rax, %rax
jne 0xc8ef
movq 0x11734(%rip), %rax     # 0x1dff8
movq (%rax), %rdi
leaq 0x7bc(%rip), %rsi       # 0xd08a
movq %rbx, %rdx
movq %r14, %rcx
movq %r12, %r8
movq %r15, %r9
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xc0a0
movq %rax, %r13
movzbl 0x8(%rax), %r8d
movzbl 0x9(%rax), %r9d
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %r12, %rcx
callq 0xc51a
movq 0x116e2(%rip), %rax     # 0x1dff8
movq (%rax), %rdi
movzbl 0x8(%r13), %r9d
movzbl 0x9(%r13), %eax
movl %eax, (%rsp)
leaq 0x786(%rip), %rsi       # 0xd0b3
movq %rbx, %rdx
movq %r14, %rcx
movq %r12, %r8
xorl %eax, %eax
callq 0xc0a0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mortie[P]makeschem/makeschem.c
// Function: main
int main(int argc, char **argv) {
	if (argc != 3) {
		printf("Usage: %s <input|-> [output|-]\n", argv[0]);
		return EXIT_FAILURE;
	}

	FILE *in = stdin;
	if (strcmp(argv[1], "-") != 0) {
		in = fopen(argv[1], "r");
		if (in == NULL) {
			perror(argv[1]);
			return EXIT_FAILURE;
		}
	}

	FILE *out = stdout;
	if (strcmp(argv[2], "-") != 0) {
		out = fopen(argv[2], "w");
		if (out == NULL) {
			perror(argv[2]);
			return EXIT_FAILURE;
		}
	}

	struct blocks blocks;
	blocks_init(&blocks);
	scdef_read(&blocks, in);
	if (!schem_write(&blocks, out)) {
		if (ferror(out)) {
			perror("write");
		} else {
			fprintf(stderr, "Error: Write failed.\n");
		}
		free(blocks.chunks);
		return EXIT_FAILURE;
	}

	free(blocks.chunks);
	return EXIT_SUCCESS;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
cmpl $0x3, %edi
jne 0xcc30
movq 0x8(%rbx), %rdi
cmpb $0x2d, (%rdi)
jne 0xcbab
cmpb $0x0, 0x1(%rdi)
je 0xcc50
leaq 0xa4bb(%rip), %rsi      # 0x1706d
callq 0xc0d0
movq %rax, %r14
testq %rax, %rax
je 0xcc95
movq 0x10(%rbx), %rdi
cmpb $0x2d, (%rdi)
jne 0xcbd6
cmpb $0x0, 0x1(%rdi)
je 0xcc5f
leaq 0xc84a(%rip), %rsi      # 0x19427
callq 0xc0d0
movq %rax, %r15
testq %rax, %rax
je 0xcc9b
xorps %xmm0, %xmm0
leaq 0x8(%rsp), %rbx
movups %xmm0, 0x18(%rbx)
pushq $0x1
popq %rax
movq %rax, 0x8(%rbx)
movq %rax, 0x10(%rbx)
movq %rax, (%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc94c
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc990
xorl %ebx, %ebx
testl %eax, %eax
je 0xcc6b
movq 0x20(%rsp), %rdi
callq 0xc030
jmp 0xcc44
movq (%rbx), %rsi
leaq 0x4c9(%rip), %rdi       # 0xd103
xorl %eax, %eax
callq 0xc060
pushq $0x1
popq %rbx
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x11381(%rip), %rax     # 0x1dfd8
movq (%rax), %r14
jmp 0xcbc3
movq 0x1136a(%rip), %rax     # 0x1dfd0
movq (%rax), %r15
jmp 0xcbee
movq %r15, %rdi
callq 0xc040
testl %eax, %eax
jne 0xcca6
movq 0x1137a(%rip), %rax     # 0x1dff8
movq (%rax), %rcx
leaq 0x4a1(%rip), %rdi       # 0xd129
pushq $0x15
popq %rsi
pushq $0x1
popq %rdx
callq 0xc0f0
jmp 0xccb2
movq 0x8(%rbx), %rdi
jmp 0xcc9f
movq 0x10(%rbx), %rdi
callq 0xc0e0
jmp 0xcc41
leaq 0x476(%rip), %rdi       # 0xd123
callq 0xc0e0
pushq $0x1
popq %rbx
jmp 0xcc24
nop
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/luac.c
// Function: main
int main(int argc, char* argv[])
{
 lua_State* L;
 int i=doargs(argc,argv);
 argc-=i; argv+=i;
 if (argc<=0) usage("no input files given");
 L=luaL_newstate();
 if (L==NULL) fatal("cannot create state: not enough memory");
 lua_pushcfunction(L,&pmain);
 lua_pushinteger(L,argc);
 lua_pushlightuserdata(L,argv);
 if (lua_pcall(L,2,0,0)!=LUA_OK) fatal(lua_tostring(L,-1));
 lua_close(L);
 return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movl %edi, %ebx
movq (%rsi), %rax
testq %rax, %rax
je 0x439c
cmpb $0x0, (%rax)
je 0x439c
movq %rax, 0x1adb4(%rip)     # 0x1f150
xorl %r15d, %r15d
pushq $0x1
popq %rbp
movl 0x1adc8(%rip), %eax     # 0x1f170
leaq 0x10c55(%rip), %rcx     # 0x15004
cmpl %ebx, %ebp
jge 0x449d
movslq %ebp, %rdx
movq (%r14,%rdx,8), %rdi
cmpb $0x2d, (%rdi)
jne 0x449d
movzbl 0x1(%rdi), %esi
leal -0x6c(%rsi), %r8d
cmpl $0xa, %r8d
ja 0x4476
movslq (%rcx,%r8,4), %rsi
addq %rcx, %rsi
jmpq *%rsi
cmpb $0x0, 0x2(%rdi)
jne 0x4552
incl %eax
movl %eax, 0x1ad7c(%rip)     # 0x1f170
jmp 0x446f
cmpb $0x0, 0x2(%rdi)
jne 0x4552
movq 0x8(%r14,%rdx,8), %rdx
movq %rdx, 0x1ad4c(%rip)     # 0x1f158
testq %rdx, %rdx
je 0x4557
incl %ebp
movzbl (%rdx), %esi
cmpl $0x2d, %esi
je 0x445d
testl %esi, %esi
jne 0x446f
jmp 0x4557
cmpb $0x0, 0x2(%rdi)
jne 0x4552
movb $0x1, 0x1ad3f(%rip)     # 0x1f178
jmp 0x446f
cmpb $0x0, 0x2(%rdi)
jne 0x4552
incl %r15d
jmp 0x446f
cmpb $0x0, 0x2(%rdi)
jne 0x4552
movb $0x1, 0x1ad19(%rip)     # 0x1f174
jmp 0x446f
cmpb $0x0, 0x1(%rdx)
jne 0x4557
andq $0x0, 0x1ace9(%rip)     # 0x1f158
incl %ebp
jmp 0x43af
testl %esi, %esi
je 0x449d
cmpl $0x2d, %esi
jne 0x4552
cmpb $0x0, 0x2(%rdi)
jne 0x4552
incl %ebp
leal 0x1(%r15), %ecx
testl %r15d, %r15d
cmovel %r15d, %ecx
movl %ecx, %r15d
cmpl %ebx, %ebp
jne 0x44c9
testl %eax, %eax
jne 0x44b0
testb $0x1, 0x1acc8(%rip)     # 0x1f174
movl %ebx, %ebp
je 0x44c9
movb $0x1, 0x1acbd(%rip)     # 0x1f174
leal -0x1(%rbx), %ebp
movslq %ebx, %rax
leaq 0x1ac9c(%rip), %rcx     # 0x1f160
movq %rcx, -0x8(%r14,%rax,8)
testl %r15d, %r15d
je 0x44e6
leaq 0x10c87(%rip), %rdi     # 0x1515c
callq 0x4080
leal -0x1(%rbx), %eax
cmpl %eax, %r15d
je 0x4590
subl %ebp, %ebx
jle 0x4563
callq 0x7d69
testq %rax, %rax
je 0x456f
movq %rax, %r15
movslq %ebp, %rax
leaq (%r14,%rax,8), %r14
leaq 0x115(%rip), %rsi       # 0x461a
movq %r15, %rdi
xorl %edx, %edx
callq 0x5a5e
movl %ebx, %esi
movq %r15, %rdi
callq 0x5895
movq %r15, %rdi
movq %r14, %rsi
callq 0x5afb
pushq $0x2
popq %rsi
movq %r15, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x6162
testl %eax, %eax
jne 0x457b
movq %r15, %rdi
callq 0xea2b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x4597
leaq 0x10bea(%rip), %rdi     # 0x15148
callq 0x4597
leaq 0x10ba2(%rip), %rdi     # 0x1510c
callq 0x4597
leaq 0x10bab(%rip), %rdi     # 0x15121
callq 0x45ef
pushq $-0x1
popq %rsi
movq %r15, %rdi
xorl %edx, %edx
callq 0x570b
movq %rax, %rdi
callq 0x45ef
xorl %edi, %edi
callq 0x4220
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/luac.c
// Function: usage
static void usage(const char* message)
{
 if (*message=='-')
  fprintf(stderr,"%s: unrecognized option " LUA_QS "\n",progname,message);
 else
  fprintf(stderr,"%s: %s\n",progname,message);
 fprintf(stderr,
  "usage: %s [options] [filenames]\n"
  "Available options are:\n"
  "  -l       list (use -l -l for full listing)\n"
  "  -o name  output to file " LUA_QL("name") " (default is \"%s\")\n"
  "  -p       parse only\n"
  "  -s       strip debug information\n"
  "  -v       show version information\n"
  "  --       stop handling options\n"
  "  -        stop handling options and process stdin\n"
  ,progname,Output);
 exit(EXIT_FAILURE);
}

// Assembly:
pushq %rbx
movq %rdi, %rcx
cmpb $0x2d, (%rdi)
movq 0x1aa4b(%rip), %rbx     # 0x1eff0
movq (%rbx), %rdi
movq 0x1aba1(%rip), %rdx     # 0x1f150
leaq 0x10bdf(%rip), %rax     # 0x15195
leaq 0x10eed(%rip), %rsi     # 0x154aa
cmoveq %rax, %rsi
xorl %eax, %eax
callq 0x4150
movq (%rbx), %rdi
movq 0x1ab7e(%rip), %rdx     # 0x1f150
leaq 0x10bda(%rip), %rsi     # 0x151b3
leaq 0x1ab80(%rip), %rcx     # 0x1f160
xorl %eax, %eax
callq 0x4150
pushq $0x1
popq %rdi
callq 0x4220
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/luac.c
// Function: PrintConstant
static void PrintConstant(const Proto* f, int i)
{
 const TValue* o=&f->k[i];
 switch (ttypenv(o))
 {
  case LUA_TNIL:
	printf("nil");
	break;
  case LUA_TBOOLEAN:
	printf(bvalue(o) ? "true" : "false");
	break;
  case LUA_TNUMBER:
	printf(LUA_NUMBER_FMT,nvalue(o));
	break;
  case LUA_TSTRING:
	PrintString(rawtsvalue(o));
	break;
  default:				/* cannot happen */
	printf("? type=%d",ttype(o));
	break;
 }
}

// Assembly:
movq 0x10(%rdi), %rax
movslq %esi, %rcx
shlq $0x4, %rcx
movl 0x8(%rax,%rcx), %esi
movl %esi, %edx
andl $0xf, %edx
cmpl $0x4, %edx
ja 0x5090
addq %rcx, %rax
leaq 0x10183(%rip), %rcx     # 0x150dc
movslq (%rcx,%rdx,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
leaq 0x1134e(%rip), %rdi     # 0x162b7
jmp 0x4f92
movsd (%rax), %xmm0
leaq 0x104a3(%rip), %rdi     # 0x15419
movb $0x1, %al
jmp 0x4110
cmpl $0x0, (%rax)
leaq 0x1048c(%rip), %rax     # 0x15413
leaq 0x10480(%rip), %rdi     # 0x1540e
cmoveq %rax, %rdi
xorl %eax, %eax
jmp 0x4110
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rax), %rbp
movq 0x10(%rbp), %r15
pushq $0x22
popq %rdi
callq 0x4040
leaq 0x10136(%rip), %rbx     # 0x150f0
leaq 0x1047a(%rip), %r12     # 0x1543b
xorl %r14d, %r14d
cmpq %r14, %r15
je 0x507a
movzbl 0x18(%rbp,%r14), %r13d
leal -0x7(%r13), %eax
cmpl $0x6, %eax
ja 0x4fee
movslq (%rbx,%rax,4), %rax
addq %rbx, %rax
jmpq *%rax
leaq 0x10443(%rip), %rdi     # 0x1542f
jmp 0x503c
cmpl $0x5c, %r13d
je 0x5015
cmpl $0x22, %r13d
jne 0x504b
leaq 0x10428(%rip), %rdi     # 0x15429
jmp 0x503c
leaq 0x10437(%rip), %rdi     # 0x15441
jmp 0x503c
leaq 0x1042b(%rip), %rdi     # 0x1543e
jmp 0x503c
leaq 0x10410(%rip), %rdi     # 0x1542c
jmp 0x503c
leaq 0x10413(%rip), %rdi     # 0x15438
jmp 0x503c
leaq 0x10404(%rip), %rdi     # 0x15432
jmp 0x503c
leaq 0x103fe(%rip), %rdi     # 0x15435
jmp 0x503c
movq %r12, %rdi
xorl %eax, %eax
callq 0x4110
incq %r14
jmp 0x4fc4
callq 0x4270
movq (%rax), %rax
movl %r13d, %ecx
testb $0x40, 0x1(%rax,%rcx,2)
jne 0x5070
leaq 0x103e0(%rip), %rdi     # 0x15444
movl %r13d, %esi
xorl %eax, %eax
callq 0x4110
jmp 0x5043
movl %r13d, %edi
callq 0x4040
jmp 0x5043
pushq $0x22
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4040
andl $0x3f, %esi
leaq 0x10385(%rip), %rdi     # 0x1541f
xorl %eax, %eax
jmp 0x4110
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/TomCrypto[P]avxfish/src/test.c
// Function: avxfish_test
static int avxfish_test(const char* output, const char* input, const char *key, const char *tweak) {
  __attribute__((aligned(64))) uint64_t input_bytes[16];
  __attribute__((aligned(64))) uint64_t subkeys[336];

  threefish1024_key_schedule(key, tweak, subkeys);
  memcpy(input_bytes, input, sizeof(input_bytes));
  avxfish(input_bytes, subkeys);

  return (memcmp(input_bytes, output, sizeof(input_bytes)) == 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
andq $-0x40, %rsp
subq $0xb40, %rsp            # imm = 0xB40
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x80(%rsp), %r15
movq %rdx, %rdi
movq %rcx, %rsi
movq %r15, %rdx
callq 0x4025c0
movq %rsp, %r12
movl $0x80, %edx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x401048
movq %r12, %rdi
movq %r15, %rsi
callq 0x4016c0
movl $0x80, %edx
movq %r12, %rdi
movq %r14, %rsi
callq 0x401028
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
movl %ecx, %eax
leaq -0x20(%rbp), %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O2/GregorR[P]lstg/source/interp.c
// Function: newLInteger
static struct object *newLInteger(LstLInt val)
{
  struct object  *res;

  res = gcialloc(sizeof(LstLInt));
  res->class = IntegerClass;
  *(LstLInt *) bytePtr(res) = val;
  return (res);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
pushq $0x8
popq %rdi
callq 0x4987
movq 0x419f7(%rip), %rcx     # 0x45998
movq %rcx, 0x8(%rax)
movq %rbx, 0x10(%rax)
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O2/GregorR[P]lstg/source/memory.c
// Function: gcinit
void gcinit(int staticsz, int dynamicsz)
{
  /*
     allocate the memory areas 
   */
  staticBase = (struct object *) malloc(staticsz * sizeof(struct object));
  spaceOne = (struct object *) malloc(dynamicsz * sizeof(struct object));
  spaceTwo = (struct object *) malloc(dynamicsz * sizeof(struct object));
  if((staticBase == 0) || (spaceOne == 0) || (spaceTwo == 0))
    sysError("not enough memory for space allocations\n", 0);

  staticTop = staticBase + staticsz;
  staticPointer = staticTop;

  spaceOneSize = spaceTwoSize = dynamicsz;
  memoryBase = spaceOne;
  memoryPointer = memoryBase + spaceOneSize;
  if(lstDebugging)
  {
    printf("space one 0x%p, top 0x%p,"
           " space two 0x%p , top 0x%p\n",
           spaceOne, (spaceOne + spaceOneSize),
           spaceTwo, (spaceTwo + spaceTwoSize));
  }
  inSpaceOne = 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %esi, %ebx
movslq %edi, %r14
shlq $0x4, %r14
movq %r14, %rdi
callq 0x2220
movq %rax, %r12
movq %rax, 0x41564(%rip)     # 0x459f8
movslq %ebx, %r13
movq %r13, %rbx
shlq $0x4, %rbx
movq %rbx, %rdi
callq 0x2220
movq %rax, %r15
movq %rax, 0x41528(%rip)     # 0x459d8
movq %rbx, %rdi
callq 0x2220
movq %rax, 0x41529(%rip)     # 0x459e8
testq %r12, %r12
setne %cl
testq %r15, %r15
setne %dl
andb %cl, %dl
testq %rax, %rax
setne %al
testb %al, %dl
jne 0x44f3
leaq 0x2e76(%rip), %rdi      # 0x7354
xorl %esi, %esi
callq 0x3fac
movq 0x4150c(%rip), %r12     # 0x459f8
movq 0x414e5(%rip), %r15     # 0x459d8
addq %r14, %r12
movq %r12, 0x41503(%rip)     # 0x45a00
movq %r12, 0x41504(%rip)     # 0x45a08
movq %r13, 0x414e5(%rip)     # 0x459f0
movq %r13, 0x414ce(%rip)     # 0x459e0
movq %r15, 0x414f7(%rip)     # 0x45a10
leaq (%r15,%rbx), %rdx
movq %rdx, 0x414f4(%rip)     # 0x45a18
leaq 0x42729(%rip), %rax     # 0x46c54
cmpl $0x0, (%rax)
je 0x454e
movq 0x414b1(%rip), %rcx     # 0x459e8
addq %rcx, %rbx
leaq 0x2e3c(%rip), %rdi      # 0x737d
movq %r15, %rsi
movq %rbx, %r8
xorl %eax, %eax
callq 0x2130
movb $0x1, 0x414cb(%rip)     # 0x45a20
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/GregorR[P]lstg/source/memory.c
// Function: gcexpand
void gcexpand(int multiplier)
{
  struct object *space;
  size_t spaceSize;

  /* figure out where to expand */
  if (inSpaceOne)
  {
    space = spaceTwo;
  }
  else
  {
    space = spaceOne;
  }
  spaceSize = (spaceOneSize > spaceTwoSize) ? spaceOneSize : spaceTwoSize;
  spaceSize *= multiplier;

  /* expand it */
  space = realloc(space, spaceSize * sizeof(struct object));
  if (!space)
  {
    sysError("failed to expand memory", NULL);
  }

  if (inSpaceOne)
  {
    spaceTwo = space;
    spaceTwoSize = spaceSize;
  }
  else
  {
    spaceOne = space;
    spaceOneSize = spaceSize;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movb 0x414b2(%rip), %bpl     # 0x45a20
leaq 0x41473(%rip), %r12     # 0x459e8
leaq 0x4145c(%rip), %r14     # 0x459d8
testb %bpl, %bpl
movq %r14, %rax
cmovneq %r12, %rax
movq (%rax), %rax
movq 0x41450(%rip), %rcx     # 0x459e0
movq 0x41459(%rip), %rdx     # 0x459f0
cmpq %rdx, %rcx
cmovaq %rcx, %rdx
movslq %edi, %r15
imulq %rdx, %r15
movq %r15, %rsi
shlq $0x4, %rsi
movq %rax, %rdi
callq 0x2270
movq %rax, %rbx
testq %rax, %rax
je 0x45cd
testb %bpl, %bpl
je 0x45e4
leaq 0x41428(%rip), %rax     # 0x459f0
movq %r12, %r14
jmp 0x45eb
leaq 0x2dde(%rip), %rdi      # 0x73b2
xorl %esi, %esi
callq 0x3fac
cmpb $0x0, 0x4143e(%rip)     # 0x45a20
jne 0x45c1
leaq 0x413f5(%rip), %rax     # 0x459e0
movq %rbx, (%r14)
movq %r15, (%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/GregorR[P]lstg/source/memory.c
// Function: staticAllocate
struct object  *staticAllocate(int sz)
{
  staticPointer = WORDSDOWN(staticPointer, sz + 2);
  if(staticPointer < staticBase)
  {
    sysError("insufficient static memory", 0);
  }
  SETSIZE(staticPointer, sz);
  return (staticPointer);
}

// Assembly:
pushq %rbx
movl %edi, %ebx
leal (,%rbx,8), %eax
pushq $-0x10
popq %rcx
subl %eax, %ecx
movslq %ecx, %rax
addq 0x410cb(%rip), %rax     # 0x45a08
movq %rax, 0x410c4(%rip)     # 0x45a08
cmpq 0x410ad(%rip), %rax     # 0x459f8
jae 0x4962
leaq 0x2a76(%rip), %rdi      # 0x73ca
xorl %esi, %esi
callq 0x3fac
movq 0x410a6(%rip), %rax     # 0x45a08
shll $0x2, %ebx
movl %ebx, (%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/GregorR[P]lstg/source/memory.c
// Function: staticIAllocate
struct object  *staticIAllocate(int sz)
{
  int             trueSize;
  struct object  *result;

  trueSize = (sz + BytesPerWord - 1) / BytesPerWord;
  result = staticAllocate(trueSize);
  SETSIZE(result, sz);
  result->size |= FLAG_BIN;
  return result;
}

// Assembly:
pushq %rbx
movl %edi, %ebx
leal 0x7(%rbx), %eax
pushq $0x8
popq %rcx
cltd
idivl %ecx
movl %eax, %edi
callq 0x4924
leal 0x2(,%rbx,4), %ecx
movl %ecx, (%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/GregorR[P]lstg/source/memory.c
// Function: gcialloc
struct object  *gcialloc(int sz)
{
  int             trueSize;
  struct object  *result;

  trueSize = (sz + BytesPerWord - 1) / BytesPerWord;
  result = gcalloc(trueSize);
  SETSIZE(result, sz);
  result->size |= FLAG_BIN;
  return result;
}

// Assembly:
pushq %rbx
movl %edi, %ebx
leal 0x7(%rbx), %eax
pushq $0x8
popq %rcx
cltd
idivl %ecx
movl %eax, %edi
leal (,%rdi,8), %eax
pushq $-0x10
popq %rcx
subl %eax, %ecx
movslq %ecx, %rax
addq 0x4106d(%rip), %rax     # 0x45a18
movq %rax, 0x41066(%rip)     # 0x45a18
cmpq 0x41057(%rip), %rax     # 0x45a10
jae 0x49c2
callq 0x45fa
jmp 0x49c7
shll $0x2, %edi
movl %edi, (%rax)
leal 0x2(,%rbx,4), %ecx
movl %ecx, (%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/GregorR[P]lstg/source/memory.c
// Function: fileIn
int fileIn(FILE * fp)
{
  int             i;

  /*
     use the currently unused space for the indir pointers 
   */
  if(inSpaceOne)
  {
    indirArray = (struct object * *) spaceTwo;
    indirSize = spaceTwoSize;
  }
  else
  {
    indirArray = (struct object * *) spaceOne;
    indirSize = spaceOneSize;
  }
  indirtop = 0;

  /*
     read in the method from the image file 
   */
  nilObject     = objectRead(fp);
  trueObject    = objectRead(fp);
  falseObject   = objectRead(fp);
  globalsObject = objectRead(fp);
  SmallIntClass = objectRead(fp);
  IntegerClass  = objectRead(fp);
  ArrayClass    = objectRead(fp);
  BlockClass    = objectRead(fp);
  ContextClass  = objectRead(fp);
  StringClass   = objectRead(fp);
  initialMethod = objectRead(fp);
  for(i = 0; i < 3; i++)
  {
    binaryMessages[i] = objectRead(fp);
  }
  badMethodSym = objectRead(fp);

  /*
     clean up after ourselves 
   */
  memoryClear((char *) indirArray, indirSize * sizeof(struct object));
  return indirtop;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x4100a(%rip), %rax     # 0x459e8
leaq 0x40ff3(%rip), %rcx     # 0x459d8
cmpb $0x0, 0x41034(%rip)     # 0x45a20
cmovneq %rax, %rcx
movq %rdi, %rbx
movq (%rcx), %rax
movq %rax, 0x42183(%rip)     # 0x46b80
leaq 0x40fec(%rip), %rax     # 0x459f0
leaq 0x40fd5(%rip), %rcx     # 0x459e0
cmovneq %rax, %rcx
movq (%rcx), %rax
movq %rax, 0x4216f(%rip)     # 0x46b88
andl $0x0, 0x42170(%rip)     # 0x46b90
callq 0x4b33
leaq 0x40f0c(%rip), %rcx     # 0x45938
movq %rax, (%rcx)
movq %rbx, %rdi
callq 0x4b33
leaq 0x40f02(%rip), %rcx     # 0x45940
movq %rax, (%rcx)
movq %rbx, %rdi
callq 0x4b33
leaq 0x40ef8(%rip), %rcx     # 0x45948
movq %rax, (%rcx)
movq %rbx, %rdi
callq 0x4b33
leaq 0x40f46(%rip), %rcx     # 0x459a8
movq %rax, (%rcx)
movq %rbx, %rdi
callq 0x4b33
leaq 0x40eec(%rip), %rcx     # 0x45960
movq %rax, (%rcx)
movq %rbx, %rdi
callq 0x4b33
leaq 0x40f12(%rip), %rcx     # 0x45998
movq %rax, (%rcx)
movq %rbx, %rdi
callq 0x4b33
leaq 0x40eb8(%rip), %rcx     # 0x45950
movq %rax, (%rcx)
movq %rbx, %rdi
callq 0x4b33
leaq 0x40eae(%rip), %rcx     # 0x45958
movq %rax, (%rcx)
movq %rbx, %rdi
callq 0x4b33
leaq 0x40eb4(%rip), %rcx     # 0x45970
movq %rax, (%rcx)
movq %rbx, %rdi
callq 0x4b33
leaq 0x40ed2(%rip), %rcx     # 0x459a0
movq %rax, (%rcx)
movq %rbx, %rdi
callq 0x4b33
leaq 0x40ed0(%rip), %rcx     # 0x459b0
movq %rax, (%rcx)
xorl %r14d, %r14d
leaq 0x40e93(%rip), %r15     # 0x45980
movq %rbx, %rdi
callq 0x4b33
cmpq $0x3, %r14
je 0x4b04
movq %rax, (%r15,%r14,8)
incq %r14
jmp 0x4aed
leaq 0x40e5d(%rip), %rcx     # 0x45968
movq %rax, (%rcx)
movq 0x4206b(%rip), %rdi     # 0x46b80
movq 0x4206c(%rip), %rdx     # 0x46b88
shlq $0x4, %rdx
xorl %esi, %esi
callq 0x2140
movl 0x42063(%rip), %eax     # 0x46b90
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/GregorR[P]lstg/source/memory.c
// Function: fileOut
int fileOut(FILE * fp)
{
  int             i;

  /*
     use the currently unused space for the indir pointers 
   */
  if(inSpaceOne)
  {
    indirArray = (struct object * *) spaceTwo;
    indirSize = spaceTwoSize;
  }
  else
  {
    indirArray = (struct object * *) spaceOne;
    indirSize = spaceOneSize;
  }
  indirtop = 0;

  /*
     write out the roots of the image file 
   */
  objectWrite(fp, nilObject);
  objectWrite(fp, trueObject);
  objectWrite(fp, falseObject);
  objectWrite(fp, globalsObject);
  objectWrite(fp, SmallIntClass);
  objectWrite(fp, IntegerClass);
  objectWrite(fp, ArrayClass);
  objectWrite(fp, BlockClass);
  objectWrite(fp, ContextClass);
  objectWrite(fp, StringClass);
  objectWrite(fp, initialMethod);
  for(i = 0; i < 3; i++)
  {
    objectWrite(fp, binaryMessages[i]);
  }
  objectWrite(fp, badMethodSym);
  printf("%d objects written in image\n", indirtop);

  /*
     clean up after ourselves 
   */
  memoryClear((char *) indirArray, indirSize * sizeof(struct object));
  return indirtop;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x40d55(%rip), %rax     # 0x459e8
leaq 0x40d3e(%rip), %rcx     # 0x459d8
cmpb $0x0, 0x40d7f(%rip)     # 0x45a20
cmovneq %rax, %rcx
movq (%rcx), %rax
movq %rax, 0x41ed1(%rip)     # 0x46b80
leaq 0x40d3a(%rip), %rax     # 0x459f0
leaq 0x40d23(%rip), %rcx     # 0x459e0
cmovneq %rax, %rcx
movq (%rcx), %rax
andl $0x0, 0x41ec5(%rip)     # 0x46b90
movq %rdi, %rbx
movq %rax, 0x41eb3(%rip)     # 0x46b88
leaq 0x40c5c(%rip), %rax     # 0x45938
movq (%rax), %rsi
callq 0x4e04
leaq 0x40c55(%rip), %rax     # 0x45940
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x4e04
leaq 0x40c4b(%rip), %rax     # 0x45948
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x4e04
leaq 0x40c99(%rip), %rax     # 0x459a8
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x4e04
leaq 0x40c3f(%rip), %rax     # 0x45960
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x4e04
leaq 0x40c65(%rip), %rax     # 0x45998
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x4e04
leaq 0x40c0b(%rip), %rax     # 0x45950
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x4e04
leaq 0x40c01(%rip), %rax     # 0x45958
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x4e04
leaq 0x40c07(%rip), %rax     # 0x45970
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x4e04
leaq 0x40c25(%rip), %rax     # 0x459a0
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x4e04
leaq 0x40c23(%rip), %rax     # 0x459b0
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x4e04
xorl %r14d, %r14d
leaq 0x40bde(%rip), %r15     # 0x45980
cmpq $0x3, %r14
je 0x4db9
movq (%r15,%r14,8), %rsi
movq %rbx, %rdi
callq 0x4e04
incq %r14
jmp 0x4da2
leaq 0x40ba8(%rip), %rax     # 0x45968
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x4e04
movl 0x41dbf(%rip), %esi     # 0x46b90
leaq 0x260d(%rip), %rdi      # 0x73e5
xorl %eax, %eax
callq 0x2130
movq 0x41d9a(%rip), %rdi     # 0x46b80
movq 0x41d9b(%rip), %rdx     # 0x46b88
shlq $0x4, %rdx
xorl %esi, %esi
callq 0x2140
movl 0x41d92(%rip), %eax     # 0x46b90
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/GregorR[P]lstg/source/memory.c
// Function: objectWrite
static void objectWrite(FILE * fp, struct object *obj)
{
  int             i,
                  size;

  if(obj == 0)
  {
    sysError("writing out a null object", 0);
  }

  if(IS_SMALLINT(obj))
  {                             /* SmallInt */
    int             val;

    writeWord(fp, 2);
    val = HTONL(integerValue(obj));
    (void) fwrite(&val, sizeof(val), 1, fp);
    return;
  }

  /*
     see if already written 
   */
  for(i = 0; i < indirtop; i++)
  {
    if(obj == indirArray[i])
    {
      if(i == 0)
      {
        writeWord(fp, 5);
      }
      else
      {
        writeWord(fp, 4);
        writeWord(fp, i);
      }
      return;
    }
  }

  /*
     not written, do it now 
   */
  indirArray[indirtop++] = obj;

  /*
     byte objects 
   */
  if(obj->size & FLAG_BIN)
  {
    struct byteObject *bobj = (struct byteObject *) obj;

    size = SIZE(obj);
    writeWord(fp, 3);
    writeWord(fp, size);
    for(i = 0; i < size; i++)
      writeWord(fp, bobj->bytes[i]);
    objectWrite(fp, obj->class);
    return;
  }

  /*
     ordinary objects 
   */
  size = SIZE(obj);
  writeWord(fp, 1);
  writeWord(fp, size);
  objectWrite(fp, obj->class);
  for(i = 0; i < size; i++)
  {
    objectWrite(fp, obj->data[i]);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x26a4(%rip), %r15      # 0x74c0
pushq $0x3
popq %rbp
testq %r14, %r14
jne 0x4e2e
movq %r15, %rdi
xorl %esi, %esi
callq 0x3fac
testb $0x1, %r14b
jne 0x4eec
movslq 0x41d51(%rip), %rax     # 0x46b90
movq 0x41d3a(%rip), %rcx     # 0x46b80
testl %eax, %eax
movl $0x0, %edx
cmovgl %eax, %edx
xorl %r12d, %r12d
cmpq %r12, %rdx
je 0x4e63
cmpq %r14, (%rcx,%r12,8)
je 0x4ebb
incq %r12
jmp 0x4e53
leal 0x1(%rax), %edx
movl %edx, 0x41d24(%rip)     # 0x46b90
movq %r14, (%rcx,%rax,8)
movl (%r14), %eax
movl %eax, %r12d
shrl $0x2, %r12d
testb $0x2, %al
je 0x4f1f
movq %rbx, %rdi
movl %ebp, %esi
callq 0x526b
movq %rbx, %rdi
movl %r12d, %esi
callq 0x526b
xorl %r13d, %r13d
cmpq %r13, %r12
je 0x4eb2
movzbl 0x10(%r14,%r13), %esi
movq %rbx, %rdi
callq 0x526b
incq %r13
jmp 0x4e9a
movq 0x8(%r14), %r14
jmp 0x4e1f
testq %r12, %r12
je 0x4ed3
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x526b
movq %rbx, %rdi
movl %r12d, %esi
jmp 0x4ed9
pushq $0x5
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x526b
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x526b
shrq %r14
leaq 0x4(%rsp), %rdi
movl %r14d, (%rdi)
pushq $0x4
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x2340
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x526b
movq %rbx, %rdi
movl %r12d, %esi
callq 0x526b
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x4e04
movl %r12d, %r15d
xorl %r12d, %r12d
cmpq %r12, %r15
je 0x4f10
movq 0x10(%r14,%r12,8), %rsi
movq %rbx, %rdi
callq 0x4e04
incq %r12
jmp 0x4f47
// File: /workspace/github_c_makefile_star2_O2/GregorR[P]lstg/source/memory.c
// Function: addStaticRoot
void addStaticRoot(struct object **objp)
{
  LstUInt         i;

  for(i = 0; i < staticRootTop; ++i)
  {
    if(objp == staticRoots[i])
    {
      return;
    }
  }
  if(staticRootTop >= STATICROOTLIMIT)
  {
    sysError("addStaticRoot: too many static references",
             0);
  }
  staticRoots[staticRootTop++] = objp;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x40c65(%rip), %ecx     # 0x45bd0
movl %ecx, %eax
leaq (,%rax,8), %rdx
xorl %esi, %esi
leaq 0x40c62(%rip), %r14     # 0x45be0
cmpq %rsi, %rdx
je 0x4f92
leaq 0x8(%rsi), %rdi
cmpq %rbx, (%rsi,%r14)
movq %rdi, %rsi
jne 0x4f7e
jmp 0x4fbc
cmpl $0x1f4, %ecx            # imm = 0x1F4
jb 0x4fb0
leaq 0x2461(%rip), %rdi      # 0x7402
xorl %esi, %esi
callq 0x3fac
movl 0x40c22(%rip), %eax     # 0x45bd0
movl %eax, %ecx
incl %ecx
movl %ecx, 0x40c18(%rip)     # 0x45bd0
movq %rbx, (%r14,%rax,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq