LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jae 0xc73b
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
imulq $0x2018, -0x30(%rbp), %rcx # imm = 0x2018
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0xc72b
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x20(%rbp), %rax
jne 0xc72b
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x28(%rbp), %rax
jne 0xc72b
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xc7e8
jmp 0xc72d
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xc6d0
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rax
imulq $0x2018, 0x20(%rax), %rsi # imm = 0x2018
callq 0xc0c0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
imulq $0x2018, -0x40(%rbp), %rcx # imm = 0x2018
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
addq $0x18, %rdi
xorl %esi, %esi
movl $0x1000, %edx           # imm = 0x1000
callq 0xc070
movq -0x48(%rbp), %rdi
addq $0x1018, %rdi           # imm = 0x1018
xorl %esi, %esi
movl $0x1000, %edx           # imm = 0x1000
callq 0xc070
movq -0x18(%rbp), %rcx
movq -0x48(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jae 0xc884
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
imulq $0x2018, -0x30(%rbp), %rcx # imm = 0x2018
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0xc874
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x20(%rbp), %rax
jne 0xc874
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x28(%rbp), %rax
jne 0xc874
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xc88c
jmp 0xc876
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xc81c
movq $-0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x80, %rsp
movl %r8d, -0x7c(%rbp)
movq %rcx, %rax
movl -0x7c(%rbp), %ecx
movq %rax, -0x78(%rbp)
movq %rdx, %rax
movq -0x78(%rbp), %rdx
movq %rax, -0x70(%rbp)
movq %rsi, %rax
movq -0x70(%rbp), %rsi
movq %rax, -0x68(%rbp)
movq %rdi, %r8
movq -0x68(%rbp), %rdi
movb %r9b, %al
movq %r8, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movb %cl, -0x21(%rbp)
movb %al, -0x22(%rbp)
movq -0x10(%rbp), %rax
shrq $0x4, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
shrq $0x4, %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
shrq $0x4, %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
andq $0xf, %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
andq $0xf, %rax
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rax
andq $0xf, %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x40(%rbp), %rcx
callq 0xc6b0
movq %rax, -0x60(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
imulq $0x2018, -0x60(%rbp), %rax # imm = 0x2018
addq %rax, %rdi
movq -0x48(%rbp), %rsi
movq -0x50(%rbp), %rdx
movq -0x58(%rbp), %rcx
movb -0x21(%rbp), %al
movzbl %al, %r8d
movzbl -0x22(%rbp), %r9d
callq 0xc5a0
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jb 0xc99c
movq -0x10(%rbp), %rcx
addq $0x1, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jb 0xc9ba
movq -0x18(%rbp), %rcx
addq $0x1, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jb 0xc9d8
movq -0x20(%rbp), %rcx
addq $0x1, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
shrq $0x4, %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
shrq $0x4, %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
shrq $0x4, %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
andq $0xf, %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
andq $0xf, %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rax
andq $0xf, %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x40(%rbp), %rcx
callq 0xc800
movq %rax, -0x60(%rbp)
cmpq $0x0, -0x60(%rbp)
jge 0xca76
movb $0x0, -0x1(%rbp)
jmp 0xca9d
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
imulq $0x2018, -0x60(%rbp), %rax # imm = 0x2018
addq %rax, %rdi
movq -0x48(%rbp), %rsi
movq -0x50(%rbp), %rdx
movq -0x58(%rbp), %rcx
callq 0xc630
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mortie[P]makeschem/makeschem.c
// Function: blocks_get_data
uint8_t blocks_get_data(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_data(&blocks->chunks[chunkidx], relx, rely, relz);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
shrq $0x4, %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
shrq $0x4, %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
shrq $0x4, %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
andq $0xf, %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
andq $0xf, %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rax
andq $0xf, %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x40(%rbp), %rcx
callq 0xc800
movq %rax, -0x60(%rbp)
cmpq $0x0, -0x60(%rbp)
jge 0xcb36
movb $0x0, -0x1(%rbp)
jmp 0xcb5d
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
imulq $0x2018, -0x60(%rbp), %rax # imm = 0x2018
addq %rax, %rdi
movq -0x48(%rbp), %rsi
movq -0x50(%rbp), %rdx
movq -0x58(%rbp), %rcx
callq 0xc670
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
addq (%rcx), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq -0x18(%rbp), %rsi
movl $0xa, %edx
callq 0xc0b0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jge 0xcd89
movq 0x122c5(%rip), %rax     # 0x1eff8
movq (%rax), %rdi
leaq 0x12d6(%rip), %rsi      # 0xe013
movb $0x0, %al
callq 0xc0a0
movq 0x122ad(%rip), %rax     # 0x1eff8
movq (%rax), %rdi
movq -0x20(%rbp), %rdx
leaq 0x12db(%rip), %rsi      # 0xe034
movb $0x0, %al
callq 0xc0a0
movq 0x12291(%rip), %rax     # 0x1eff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x12ce(%rip), %rsi      # 0xe043
movb $0x0, %al
callq 0xc0a0
movq $0x0, -0x28(%rbp)
jmp 0xce5e
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0xcded
movq 0x1225e(%rip), %rax     # 0x1eff8
movq (%rax), %rdi
leaq 0x12aa(%rip), %rsi      # 0xe04e
movb $0x0, %al
callq 0xc0a0
movq 0x12246(%rip), %rax     # 0x1eff8
movq (%rax), %rdi
movq -0x20(%rbp), %rdx
leaq 0x1274(%rip), %rsi      # 0xe034
movb $0x0, %al
callq 0xc0a0
movq 0x1222a(%rip), %rax     # 0x1eff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x1267(%rip), %rsi      # 0xe043
movb $0x0, %al
callq 0xc0a0
movq $0x0, -0x28(%rbp)
jmp 0xce5c
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0xce5a
movq -0x18(%rbp), %rax
movsbl (%rax), %edi
callq 0xcbc0
cmpl $0x0, %eax
jne 0xce5a
movq 0x121e7(%rip), %rax     # 0x1eff8
movq (%rax), %rdi
leaq 0x124b(%rip), %rsi      # 0xe066
movb $0x0, %al
callq 0xc0a0
movq 0x121cf(%rip), %rax     # 0x1eff8
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
leaq 0x11fd(%rip), %rsi      # 0xe034
movb $0x0, %al
callq 0xc0a0
movq 0x121b3(%rip), %rax     # 0x1eff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x11f0(%rip), %rsi      # 0xe043
movb $0x0, %al
callq 0xc0a0
jmp 0xce5c
jmp 0xce5e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xcc80
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xcc10
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xccf0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xcc10
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xccf0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xcc10
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xccf0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xcc10
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xcc80
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x38(%rbp), %rdi
callq 0xc4d0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0xcf62
movq 0x120b9(%rip), %rax     # 0x1eff8
movq (%rax), %rdi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %r9
leaq 0x1131(%rip), %rsi      # 0xe08a
movb $0x0, %al
callq 0xc0a0
jmp 0xcfc4
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x40(%rbp), %rax
movb 0x8(%rax), %r8b
movq -0x40(%rbp), %rax
movzbl %r8b, %r8d
movzbl 0x9(%rax), %r9d
callq 0xc8a0
movq 0x12065(%rip), %rax     # 0x1eff8
movq (%rax), %rdi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x40(%rbp), %rax
movzbl 0x8(%rax), %r9d
movq -0x40(%rbp), %rax
movzbl 0x9(%rax), %eax
leaq 0x10f9(%rip), %rsi      # 0xe0b3
movl %eax, (%rsp)
movb $0x0, %al
callq 0xc0a0
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x3, -0x8(%rbp)
je 0xd3bd
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0xd59(%rip), %rdi       # 0xe103
movb $0x0, %al
callq 0xc060
movl $0x1, -0x4(%rbp)
jmp 0xd4fd
movq 0x11c14(%rip), %rax     # 0x1efd8
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xd49(%rip), %rsi       # 0xe123
callq 0xc090
cmpl $0x0, %eax
je 0xd41e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xac7c(%rip), %rsi      # 0x1806f
callq 0xc0d0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xd41c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xc0e0
movl $0x1, -0x4(%rbp)
jmp 0xd4fd
jmp 0xd41e
movq 0x11bab(%rip), %rax     # 0x1efd0
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0xce8(%rip), %rsi       # 0xe123
callq 0xc090
cmpl $0x0, %eax
je 0xd47f
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0xcfd5(%rip), %rsi      # 0x1a429
callq 0xc0d0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xd47d
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xc0e0
movl $0x1, -0x4(%rbp)
jmp 0xd4fd
jmp 0xd47f
leaq -0x48(%rbp), %rdi
callq 0xcb70
movq -0x18(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0xcfd0
movq -0x20(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0xd020
cmpl $0x0, %eax
jne 0xd4ed
movq -0x20(%rbp), %rdi
callq 0xc040
cmpl $0x0, %eax
je 0xd4c3
leaq 0xc69(%rip), %rdi       # 0xe125
callq 0xc0e0
jmp 0xd4db
movq 0x11b2e(%rip), %rax     # 0x1eff8
movq (%rax), %rdi
leaq 0xc57(%rip), %rsi       # 0xe12b
movb $0x0, %al
callq 0xc0a0
movq -0x30(%rbp), %rdi
callq 0xc030
movl $0x1, -0x4(%rbp)
jmp 0xd4fd
movq -0x30(%rbp), %rdi
callq 0xc030
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movl $0x0, 0x24(%rsp)
movl %edi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl 0x20(%rsp), %edi
movq 0x18(%rsp), %rsi
callq 0x4460
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %ecx
movl 0x20(%rsp), %eax
subl %ecx, %eax
movl %eax, 0x20(%rsp)
movl 0xc(%rsp), %ecx
movq 0x18(%rsp), %rax
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
cmpl $0x0, 0x20(%rsp)
jg 0x43c0
leaq 0x21e61(%rip), %rdi     # 0x2621c
callq 0x4750
callq 0xb110
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x43de
leaq 0x21e58(%rip), %rdi     # 0x26231
callq 0x47e0
movq 0x10(%rsp), %rdi
leaq 0x436(%rip), %rsi       # 0x4820
xorl %edx, %edx
callq 0x7110
movq 0x10(%rsp), %rdi
movslq 0x20(%rsp), %rsi
callq 0x6da0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x72b0
movq 0x10(%rsp), %rdi
movl $0x2, %esi
xorl %r8d, %r8d
xorl %eax, %eax
movl %eax, %r9d
movl %r8d, %edx
movl %r8d, %ecx
callq 0x80f0
cmpl $0x0, %eax
je 0x444c
movq 0x10(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x69b0
movq %rax, %rdi
callq 0x47e0
movq 0x10(%rsp), %rdi
callq 0x18f00
xorl %eax, %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x4786
movq 0x29888(%rip), %rax     # 0x2dff0
movq (%rax), %rdi
movq 0x299ce(%rip), %rdx     # 0x2e140
movq (%rsp), %rcx
leaq 0x21b3a(%rip), %rsi     # 0x262b7
movb $0x0, %al
callq 0x4140
jmp 0x47a9
movq 0x29863(%rip), %rax     # 0x2dff0
movq (%rax), %rdi
movq 0x299a9(%rip), %rdx     # 0x2e140
movq (%rsp), %rcx
leaq 0x21e32(%rip), %rsi     # 0x265d4
movb $0x0, %al
callq 0x4140
movq 0x29840(%rip), %rax     # 0x2dff0
movq (%rax), %rdi
movq 0x29986(%rip), %rdx     # 0x2e140
leaq 0x21b14(%rip), %rsi     # 0x262d5
leaq 0x2998c(%rip), %rcx     # 0x2e154
movb $0x0, %al
callq 0x4140
movl $0x1, %edi
callq 0x4200
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/luac.c
// Function: pmain
static int pmain(lua_State* L)
{
 int argc=(int)lua_tointeger(L,1);
 char** argv=(char**)lua_touserdata(L,2);
 const Proto* f;
 int i;
 if (!lua_checkstack(L,argc)) fatal("too many input files");
 for (i=0; i<argc; i++)
 {
  const char* filename=IS("-") ? NULL : argv[i];
  if (luaL_loadfile(L,filename)!=LUA_OK) fatal(lua_tostring(L,-1));
 }
 f=combine(L,argc);
 if (listing) luaU_print(f,listing>1);
 if (dumping)
 {
  FILE* D= (output==NULL) ? stdout : fopen(output,"wb");
  if (D==NULL) cannot("open");
  lua_lock(L);
  luaU_dump(L,f,writer,D,stripping);
  lua_unlock(L);
  if (ferror(D)) cannot("write");
  if (fclose(D)) cannot("close");
 }
 return 0;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x67d0
movl %eax, 0x3c(%rsp)
movq 0x40(%rsp), %rdi
movl $0x2, %esi
callq 0x6b90
movq %rax, 0x30(%rsp)
movq 0x40(%rsp), %rdi
movl 0x3c(%rsp), %esi
callq 0x5a80
cmpl $0x0, %eax
jne 0x4873
leaq 0x21bb0(%rip), %rdi     # 0x2641e
callq 0x47e0
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x3c(%rsp), %eax
jge 0x4913
movq 0x30(%rsp), %rax
movslq 0x24(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x23847(%rip), %rsi     # 0x280e5
callq 0x4130
cmpl $0x0, %eax
jne 0x48b1
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0x48c4
movq 0x30(%rsp), %rax
movslq 0x24(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rdi
movq 0x18(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xa4b0
cmpl $0x0, %eax
je 0x4901
movq 0x40(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x69b0
movq %rax, %rdi
callq 0x47e0
jmp 0x4903
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x487b
movq 0x40(%rsp), %rdi
movl 0x3c(%rsp), %esi
callq 0x4a10
movq %rax, 0x28(%rsp)
cmpl $0x0, 0x29837(%rip)     # 0x2e164
je 0x4948
movq 0x28(%rsp), %rdi
cmpl $0x1, 0x29829(%rip)     # 0x2e164
setg %al
andb $0x1, %al
movzbl %al, %esi
callq 0x4b50
cmpl $0x0, 0x29801(%rip)     # 0x2e150
je 0x49fd
cmpq $0x0, 0x297eb(%rip)     # 0x2e148
jne 0x496f
movq 0x29662(%rip), %rax     # 0x2dfc8
movq (%rax), %rax
movq %rax, (%rsp)
jmp 0x4986
movq 0x297d2(%rip), %rdi     # 0x2e148
leaq 0x21ab6(%rip), %rsi     # 0x26433
callq 0x41d0
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x49a3
leaq 0x21ec3(%rip), %rdi     # 0x26861
callq 0x4bd0
movq 0x40(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x10(%rsp), %rcx
movl 0x297af(%rip), %r8d     # 0x2e168
leaq 0x290(%rip), %rdx       # 0x4c50
callq 0xebb0
movq 0x10(%rsp), %rdi
callq 0x4070
cmpl $0x0, %eax
je 0x49e0
leaq 0x21a5b(%rip), %rdi     # 0x26436
callq 0x4bd0
movq 0x10(%rsp), %rdi
callq 0x40c0
cmpl $0x0, %eax
je 0x49fb
leaq 0x21a46(%rip), %rdi     # 0x2643c
callq 0x4bd0
jmp 0x49fd
xorl %eax, %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/luac.c
// Function: combine
static const Proto* combine(lua_State* L, int n)
{
 if (n==1)
  return toproto(L,-1);
 else
 {
  Proto* f;
  int i=n;
  if (lua_load(L,reader,&i,"=(" PROGNAME ")",NULL)!=LUA_OK) fatal(lua_tostring(L,-1));
  f=toproto(L,-1);
  for (i=0; i<n; i++)
  {
   f->p[i]=toproto(L,i-n-1);
   if (f->p[i]->sizeupvalues>0) f->p[i]->upvalues[0].instack=0;
  }
  f->sizelineinfo=0;
  return f;
 }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
cmpl $0x1, 0x14(%rsp)
jne 0x4a3f
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x4b42
movl 0x14(%rsp), %eax
movl %eax, 0x4(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x25d(%rip), %rsi       # 0x4cb0
leaq 0x4(%rsp), %rdx
leaq 0x219e3(%rip), %rcx     # 0x26442
xorl %eax, %eax
movl %eax, %r8d
callq 0x8310
cmpl $0x0, %eax
je 0x4a89
movq 0x18(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x69b0
movq %rax, %rdi
callq 0x47e0
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x14(%rsp), %eax
jge 0x4b2c
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movl 0x4(%rsp), %ecx
subl 0x14(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq 0x18(%rax), %rdx
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rax
movslq 0x4(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rax
cmpl $0x0, 0x50(%rax)
jle 0x4b1a
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x38(%rax), %rax
movb $0x0, 0x8(%rax)
jmp 0x4b1c
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x4aa7
movq 0x8(%rsp), %rax
movl $0x0, 0x5c(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/luac.c
// Function: PrintFunction
static void PrintFunction(const Proto* f, int full)
{
 int i,n=f->sizep;
 PrintHeader(f);
 PrintCode(f);
 if (full) PrintDebug(f);
 for (i=0; i<n; i++) PrintFunction(f->p[i],full);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rax
movl 0x60(%rax), %eax
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rdi
callq 0x4d10
movq 0x10(%rsp), %rdi
callq 0x4f60
cmpl $0x0, 0xc(%rsp)
je 0x4b8e
movq 0x10(%rsp), %rdi
callq 0x5600
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0x4(%rsp), %eax
jge 0x4bc8
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movslq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movl 0xc(%rsp), %esi
callq 0x4b50
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4b96
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/luac.c
// Function: reader
static const char* reader(lua_State *L, void *ud, size_t *size)
{
 UNUSED(L);
 if ((*(int*)ud)--)
 {
  *size=sizeof(FUNCTION)-1;
  return FUNCTION;
 }
 else
 {
  *size=0;
  return NULL;
 }
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq -0x18(%rsp), %rcx
movl (%rcx), %eax
movl %eax, %edx
addl $-0x1, %edx
movl %edx, (%rcx)
cmpl $0x0, %eax
je 0x4cec
movq -0x20(%rsp), %rax
movq $0x12, (%rax)
leaq 0x21765(%rip), %rax     # 0x2644a
movq %rax, -0x8(%rsp)
jmp 0x4d01
movq -0x20(%rsp), %rax
movq $0x0, (%rax)
movq $0x0, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x1c(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movl 0x8(%rax), %eax
andl $0xf, %eax
movl %eax, %ecx
movq %rcx, 0x8(%rsp)
subl $0x4, %eax
ja 0x58c0
movq 0x8(%rsp), %rax
leaq 0x20856(%rip), %rcx     # 0x260b0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x21d25(%rip), %rdi     # 0x2758f
movb $0x0, %al
callq 0x40f0
jmp 0x58d9
movq 0x10(%rsp), %rax
movl (%rax), %ecx
leaq 0x20cb9(%rip), %rdi     # 0x2653a
leaq 0x20cad(%rip), %rax     # 0x26535
cmpl $0x0, %ecx
cmovneq %rax, %rdi
movb $0x0, %al
callq 0x40f0
jmp 0x58d9
movq 0x10(%rsp), %rax
movsd (%rax), %xmm0
leaq 0x20c98(%rip), %rdi     # 0x26540
movb $0x1, %al
callq 0x40f0
jmp 0x58d9
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x58e0
jmp 0x58d9
movq 0x10(%rsp), %rax
movl 0x8(%rax), %esi
andl $0x3f, %esi
leaq 0x20c74(%rip), %rdi     # 0x26546
movb $0x0, %al
callq 0x40f0
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/luac.c
// Function: PrintString
static void PrintString(const TString* ts)
{
 const char* s=getstr(ts);
 size_t i,n=ts->tsv.len;
 printf("%c",'"');
 for (i=0; i<n; i++)
 {
  int c=(int)(unsigned char)s[i];
  switch (c)
  {
   case '"':  printf("\\\""); break;
   case '\\': printf("\\\\"); break;
   case '\a': printf("\\a"); break;
   case '\b': printf("\\b"); break;
   case '\f': printf("\\f"); break;
   case '\n': printf("\\n"); break;
   case '\r': printf("\\r"); break;
   case '\t': printf("\\t"); break;
   case '\v': printf("\\v"); break;
   default:	if (isprint(c))
   			printf("%c",c);
		else
			printf("\\%03d",c);
  }
 }
 printf("%c",'"');
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x18, %rax
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x18(%rsp)
leaq 0x20c44(%rip), %rdi     # 0x26550
movl $0x22, %esi
movb $0x0, %al
callq 0x40f0
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0x5a66
movq 0x28(%rsp), %rax
movq 0x20(%rsp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addl $-0x7, %eax
movl %eax, %ecx
movq %rcx, 0x8(%rsp)
subl $0x55, %eax
ja 0x5a0e
movq 0x8(%rsp), %rax
leaq 0x2075e(%rip), %rcx     # 0x260c4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x20bdd(%rip), %rdi     # 0x26553
movb $0x0, %al
callq 0x40f0
jmp 0x5a51
leaq 0x20bcd(%rip), %rdi     # 0x26556
movb $0x0, %al
callq 0x40f0
jmp 0x5a51
leaq 0x20bbd(%rip), %rdi     # 0x26559
movb $0x0, %al
callq 0x40f0
jmp 0x5a51
leaq 0x20bad(%rip), %rdi     # 0x2655c
movb $0x0, %al
callq 0x40f0
jmp 0x5a51
leaq 0x20b9d(%rip), %rdi     # 0x2655f
movb $0x0, %al
callq 0x40f0
jmp 0x5a51
leaq 0x20b8d(%rip), %rdi     # 0x26562
movb $0x0, %al
callq 0x40f0
jmp 0x5a51
leaq 0x20b80(%rip), %rdi     # 0x26565
movb $0x0, %al
callq 0x40f0
jmp 0x5a51
leaq 0x20b73(%rip), %rdi     # 0x26568
movb $0x0, %al
callq 0x40f0
jmp 0x5a51
leaq 0x20b66(%rip), %rdi     # 0x2656b
movb $0x0, %al
callq 0x40f0
jmp 0x5a51
callq 0x4250
movq (%rax), %rax
movslq 0x14(%rsp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x4000, %eax           # imm = 0x4000
cmpl $0x0, %eax
je 0x5a3d
movl 0x14(%rsp), %esi
leaq 0x20b1c(%rip), %rdi     # 0x26550
movb $0x0, %al
callq 0x40f0
jmp 0x5a4f
movl 0x14(%rsp), %esi
leaq 0x20b26(%rip), %rdi     # 0x2656e
movb $0x0, %al
callq 0x40f0
jmp 0x5a51
jmp 0x5a53
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x5921
leaq 0x20ae3(%rip), %rdi     # 0x26550
movl $0x22, %esi
movb $0x0, %al
callq 0x40f0
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
andq $-0x40, %rsp
subq $0xb40, %rsp            # imm = 0xB40
movq %rdi, 0xb28(%rsp)
movq %rsi, 0xb20(%rsp)
movq %rdx, 0xb18(%rsp)
movq %rcx, 0xb10(%rsp)
movq 0xb18(%rsp), %rdi
movq 0xb10(%rsp), %rsi
movq %rsp, %rdx
callq 0x4025c0
leaq 0xa80(%rsp), %rdi
movq 0xb20(%rsp), %rsi
movl $0x80, %edx
callq 0x401040
leaq 0xa80(%rsp), %rdi
movq %rsp, %rsi
callq 0x4016c0
leaq 0xa80(%rsp), %rdi
movq 0xb28(%rsp), %rsi
movl $0x80, %edx
callq 0x401080
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movq %rbp, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/utils/blanced_binary_tree/test/test_blanced_binary_tree.c
// Function: compare
int      compare(void *a, void *b) {
    int *aa = (int *)a;
    int *bb = (int *)b;
    if (*aa == *bb) {
        return 0;
    } else if (*aa > *bb) {
        return 1;
    } else {
        return -1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq -0x28(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x1e83
movl $0x0, -0x4(%rbp)
jmp 0x1ea1
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq -0x28(%rbp), %rcx
cmpl (%rcx), %eax
jle 0x1e9a
movl $0x1, -0x4(%rbp)
jmp 0x1ea1
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/GregorR[P]lstg/source/interp.c
// Function: lookupMethod
static struct object *lookupMethod(struct object *selector,
                                   struct object *class)
{
  struct object  *dict,
                 *keys,
                 *vals,
                 *val;
  LstInt          low,
                  high,
                  mid;

  /*
   * Scan upward through the class hierarchy
   */
  for(; class != nilObject; class = class->data[parentClassInClass])
  {
    /*
     * Consider the Dictionary of methods for this Class
     */
    dict = class->data[methodsInClass];
    keys = dict->data[0];
    low = 0;
    high = SIZE(keys);

    /*
     * Do a binary search through its keys, which are
     * Symbol's.
     */
    while(low < high)
    {
      mid = (low + high) / 2;
      val = keys->data[mid];

      /*
       * If we find the selector, return the
       * method object.
       */
      if(val == selector)
      {
        vals = dict->data[1];
        return (vals->data[mid]);
      }

      /*
       * Otherwise continue the binary search
       */
      if(symbolcomp(selector, val) < 0)
      {
        high = mid;
      }
      else
      {
        low = mid + 1;
      }
    }
  }

  /*
   * Sorry, couldn't find a method
   */
  return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq 0x4375d(%rip), %rax     # 0x48938
je 0x5297
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x3c(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
shrl $0x2, %eax
movl %eax, -0x40(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x40(%rbp), %eax
jge 0x5284
movl -0x3c(%rbp), %eax
addl -0x40(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x44(%rbp)
movq -0x28(%rbp), %rax
movslq -0x44(%rbp), %rcx
movq 0x10(%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x525f
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movslq -0x44(%rbp), %rcx
movq 0x10(%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x529f
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x5620
cmpl $0x0, %eax
jge 0x5279
movl -0x44(%rbp), %eax
movl %eax, -0x40(%rbp)
jmp 0x5282
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x520c
jmp 0x5286
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x51d0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x8, %edi
callq 0x6710
movq %rax, -0x10(%rbp)
movq 0x436c7(%rip), %rcx     # 0x48998
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/GregorR[P]lstg/source/interp.c
// Function: do_Integer
static struct object *do_Integer(int op, struct object *low,
                                 struct object *high)
{
  LstLInt         l,
                  h;

  l = *(LstLInt *) bytePtr(low);
  h = *(LstLInt *) bytePtr(high);
  switch (op)
  {
    case 25:                   /* Integer division */
      if(h == lstLNull)
      {
        return (NULL);
      }
      return (newLInteger(l / h));

    case 26:                   /* Integer remainder */
      if(h == lstLNull)
      {
        return (NULL);
      }
      return (newLInteger(l % h));

    case 27:                   /* Integer addition */
      return (newLInteger(l + h));

    case 28:                   /* Integer multiplication */
      return (newLInteger(l * h));

    case 29:                   /* Integer subtraction */
      return (newLInteger(l - h));

    case 30:                   /* Integer less than */
      return ((l < h) ? trueObject : falseObject);

    case 31:                   /* Integer equality */
      return ((l == h) ? trueObject : falseObject);

    default:
      sysError("Invalid op table jump", (void *)(INT_PTR)op);
  }
  return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movl -0xc(%rbp), %eax
addl $-0x19, %eax
movl %eax, %ecx
movq %rcx, -0x38(%rbp)
subl $0x6, %eax
ja 0x543a
movq -0x38(%rbp), %rax
leaq 0x4e19(%rip), %rcx      # 0xa154
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpq $0x0, -0x30(%rbp)
jne 0x5358
movq $0x0, -0x8(%rbp)
jmp 0x5452
movq -0x28(%rbp), %rax
cqto
idivq -0x30(%rbp)
movq %rax, %rdi
callq 0x52b0
movq %rax, -0x8(%rbp)
jmp 0x5452
cmpq $0x0, -0x30(%rbp)
jne 0x5387
movq $0x0, -0x8(%rbp)
jmp 0x5452
movq -0x28(%rbp), %rax
cqto
idivq -0x30(%rbp)
movq %rdx, %rdi
callq 0x52b0
movq %rax, -0x8(%rbp)
jmp 0x5452
movq -0x28(%rbp), %rdi
addq -0x30(%rbp), %rdi
callq 0x52b0
movq %rax, -0x8(%rbp)
jmp 0x5452
movq -0x28(%rbp), %rdi
imulq -0x30(%rbp), %rdi
callq 0x52b0
movq %rax, -0x8(%rbp)
jmp 0x5452
movq -0x28(%rbp), %rdi
subq -0x30(%rbp), %rdi
callq 0x52b0
movq %rax, -0x8(%rbp)
jmp 0x5452
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jge 0x53f9
movq 0x4354d(%rip), %rax     # 0x48940
movq %rax, -0x40(%rbp)
jmp 0x5404
movq 0x43548(%rip), %rax     # 0x48948
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5452
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jne 0x5425
movq 0x43521(%rip), %rax     # 0x48940
movq %rax, -0x48(%rbp)
jmp 0x5430
movq 0x4351c(%rip), %rax     # 0x48948
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5452
movslq -0xc(%rbp), %rsi
leaq 0x4d97(%rip), %rdi      # 0xa1dc
callq 0x56d0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/GregorR[P]lstg/source/interp.c
// Function: symbolcomp
static int symbolcomp(struct object *left, struct object *right)
{
  int             leftsize = SIZE(left);
  int             rightsize = SIZE(right);
  int             minsize = leftsize;
  register int    i;

  if(rightsize < minsize)
    minsize = rightsize;
  for(i = 0; i < minsize; i++)
  {
    if(bytePtr(left)[i] != bytePtr(right)[i])
    {
      return bytePtr(left)[i] - bytePtr(right)[i];
    }
  }
  return leftsize - rightsize;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl $0x2, %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
shrl $0x2, %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x5658
movl -0x20(%rbp), %eax
movl %eax, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x56b3
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movzbl 0x10(%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movslq -0x28(%rbp), %rdx
movzbl 0x10(%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x56a6
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movzbl 0x10(%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movslq -0x28(%rbp), %rdx
movzbl 0x10(%rcx,%rdx), %ecx
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x56bc
jmp 0x56a8
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x565f
movl -0x1c(%rbp), %eax
subl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/GregorR[P]lstg/source/main.c
// Function: backTrace
static void backTrace(struct object *aContext)
{
  printf("back trace\n");
  while(aContext && (aContext != nilObject))
  {
    struct object  *arguments;
    LstUInt         i;

    printf("message %s ",
           bytePtr(aContext->data[methodInContext]->data[nameInMethod]));
    arguments = aContext->data[argumentsInContext];
    if(arguments && (arguments != nilObject))
    {
      printf("(");
      for(i = 0; i < SIZE(arguments); i++)
        printf("%s%s", (i == 0) ? "" : ", ", bytePtr(arguments->data[i]->class->data[nameInClass]));
      printf(")");
    }
    printf("\n");
    aContext = aContext->data[previousContextInContext];
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x4694(%rip), %rdi      # 0xa327
movb $0x0, %al
callq 0x2140
xorl %eax, %eax
cmpq $0x0, -0x8(%rbp)
movb %al, -0x15(%rbp)
je 0x5cba
movq -0x8(%rbp), %rax
leaq 0x42c87(%rip), %rcx     # 0x48938
cmpq (%rcx), %rax
setne %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x5cc6
jmp 0x5da6
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rsi
addq $0x10, %rsi
leaq 0x4656(%rip), %rdi      # 0xa333
movb $0x0, %al
callq 0x2140
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5d87
movq -0x10(%rbp), %rax
leaq 0x42c32(%rip), %rcx     # 0x48938
cmpq (%rcx), %rax
je 0x5d87
leaq 0x462d(%rip), %rdi      # 0xa33f
movb $0x0, %al
callq 0x2140
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
shrl $0x2, %ecx
cmpl %ecx, %eax
jae 0x5d79
movl -0x14(%rbp), %ecx
leaq 0x460c(%rip), %rsi      # 0xa346
leaq 0x45cd(%rip), %rax      # 0xa30e
cmpl $0x0, %ecx
cmoveq %rax, %rsi
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movq 0x10(%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rdx
addq $0x10, %rdx
leaq 0x45da(%rip), %rdi      # 0xa341
movb $0x0, %al
callq 0x2140
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5d20
leaq 0x45c9(%rip), %rdi      # 0xa349
movb $0x0, %al
callq 0x2140
leaq 0x457f(%rip), %rdi      # 0xa30d
movb $0x0, %al
callq 0x2140
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x5c9a
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movslq -0x4(%rbp), %rdi
shlq $0x4, %rdi
callq 0x2230
movq %rax, 0x42ba6(%rip)     # 0x489f8
movslq -0x8(%rbp), %rdi
shlq $0x4, %rdi
callq 0x2230
movq %rax, 0x42b72(%rip)     # 0x489d8
movslq -0x8(%rbp), %rdi
shlq $0x4, %rdi
callq 0x2230
movq %rax, 0x42b6e(%rip)     # 0x489e8
cmpq $0x0, 0x42b76(%rip)     # 0x489f8
je 0x5e98
cmpq $0x0, 0x42b4c(%rip)     # 0x489d8
je 0x5e98
cmpq $0x0, 0x42b52(%rip)     # 0x489e8
jne 0x5ea8
leaq 0x44c5(%rip), %rdi      # 0xa364
xorl %eax, %eax
movl %eax, %esi
callq 0x56d0
movq 0x42b49(%rip), %rax     # 0x489f8
movslq -0x4(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, 0x42b3f(%rip)     # 0x48a00
movq 0x42b38(%rip), %rax     # 0x48a00
movq %rax, 0x42b39(%rip)     # 0x48a08
movslq -0x8(%rbp), %rax
movq %rax, 0x42b16(%rip)     # 0x489f0
movq %rax, 0x42aff(%rip)     # 0x489e0
movq 0x42af0(%rip), %rax     # 0x489d8
movq %rax, 0x42b21(%rip)     # 0x48a10
movq 0x42b1a(%rip), %rax     # 0x48a10
movq 0x42ae3(%rip), %rcx     # 0x489e0
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, 0x42b0d(%rip)     # 0x48a18
leaq 0x43d42(%rip), %rax     # 0x49c54
cmpl $0x0, (%rax)
je 0x5f5d
movq 0x42aba(%rip), %rsi     # 0x489d8
movq 0x42ab3(%rip), %rdx     # 0x489d8
movq 0x42ab4(%rip), %rax     # 0x489e0
shlq $0x4, %rax
addq %rax, %rdx
movq 0x42aae(%rip), %rcx     # 0x489e8
movq 0x42aa7(%rip), %r8      # 0x489e8
movq 0x42aa8(%rip), %rax     # 0x489f0
shlq $0x4, %rax
addq %rax, %r8
leaq 0x4437(%rip), %rdi      # 0xa38d
movb $0x0, %al
callq 0x2140
movl $0x1, 0x42ab9(%rip)     # 0x48a20
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, 0x42a9e(%rip)     # 0x48a20
je 0x5f91
movq 0x42a5d(%rip), %rax     # 0x489e8
movq %rax, -0x10(%rbp)
jmp 0x5f9c
movq 0x42a40(%rip), %rax     # 0x489d8
movq %rax, -0x10(%rbp)
movq 0x42a3d(%rip), %rax     # 0x489e0
cmpq 0x42a46(%rip), %rax     # 0x489f0
jbe 0x5fb9
movq 0x42a2d(%rip), %rax     # 0x489e0
movq %rax, -0x20(%rbp)
jmp 0x5fc4
movq 0x42a30(%rip), %rax     # 0x489f0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movslq -0x4(%rbp), %rax
imulq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
shlq $0x4, %rsi
callq 0x2280
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x6005
leaq 0x43c6(%rip), %rdi      # 0xa3c2
xorl %eax, %eax
movl %eax, %esi
callq 0x56d0
cmpl $0x0, 0x42a14(%rip)     # 0x48a20
je 0x6026
movq -0x10(%rbp), %rax
movq %rax, 0x429cf(%rip)     # 0x489e8
movq -0x18(%rbp), %rax
movq %rax, 0x429cc(%rip)     # 0x489f0
jmp 0x603c
movq -0x10(%rbp), %rax
movq %rax, 0x429a7(%rip)     # 0x489d8
movq -0x18(%rbp), %rax
movq %rax, 0x429a4(%rip)     # 0x489e0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)