LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/TurkeyMcMac[P]ts3d/src/ent.c
// Function: ent_tick
static void ent_tick(struct ent *ent, d3d_sprite_s *sprite)
{
	if (!ent_is_dead(ent)) {
		if (--ent->frame_duration <= 0) {
			if (++ent->frame >= ent->type->n_frames) ent->frame = 0;
			ent->frame_duration =
				ent->type->frames[ent->frame].duration;
			sprite->txtr = ent->type->frames[ent->frame].txtr;
		}
	} else if (ent->type->death_spawn) {
		int worth = ent->worth;
		ent_init(ent, ent->type->death_spawn, ent->team, sprite,
			&sprite->pos);
		ent->worth = worth;
	} else {
		ent->lifetime = 0;
	}
	--ent->lifetime;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6570
testb $0x1, %al
jne 0x6400
movq -0x8(%rbp), %rcx
movq 0x30(%rcx), %rax
addq $-0x1, %rax
movq %rax, 0x30(%rcx)
cmpq $0x0, %rax
jg 0x63fe
movq -0x8(%rbp), %rcx
movq 0x28(%rcx), %rax
addq $0x1, %rax
movq %rax, 0x28(%rcx)
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
cmpq 0x18(%rcx), %rax
jb 0x63b1
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x28(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x28(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x6457
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
cmpq $0x0, 0x28(%rax)
je 0x6449
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x28(%rax), %rsi
movq -0x8(%rbp), %rax
movl 0x18(%rax), %edx
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %r8
callq 0x6180
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x1c(%rax)
jmp 0x6455
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
jmp 0x6457
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x20(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/TurkeyMcMac[P]ts3d/src/ent.c
// Function: ents_clean_up_dead
void ents_clean_up_dead(struct ents *ents)
{
	for (size_t i = 0; i < ents->num; ++i) {
		struct ent *ent = &ents->ents[i];
		if (ent_is_dead(ent)) {
			--ents->num;
			*ent = ents->ents[ents->num];
			ents->sprites[i] = ents->sprites[ents->num];
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x66ca
movq -0x8(%rbp), %rax
movq (%rax), %rax
imulq $0x60, -0x10(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6570
testb $0x1, %al
jne 0x6658
jmp 0x66b7
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq -0x8(%rbp), %rax
imulq $0x60, 0x10(%rax), %rax
addq %rax, %rsi
movl $0x60, %edx
callq 0x2510
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
imulq $0x30, -0x10(%rbp), %rax
addq %rax, %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x8(%rbp), %rax
imulq $0x30, 0x10(%rax), %rax
addq %rax, %rsi
movl $0x30, %edx
callq 0x2510
jmp 0x66b9
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x6624
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/TurkeyMcMac[P]ts3d/src/grow.c
// Function: growe
void *growe(void **bufp, size_t *lenp, size_t *capp, size_t esize)
{
	if (*lenp >= *capp) {
		*capp = *lenp + *lenp / 2 + 1;
		*bufp = xrealloc(*bufp, *capp * esize);
	}
	return (char *)*bufp + (*lenp)++ * esize;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jb 0x6769
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
shrq %rax
addq %rax, %rcx
addq $0x1, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
imulq -0x20(%rbp), %rsi
callq 0x10d00
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rdx
movq (%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, (%rdx)
imulq -0x20(%rbp), %rcx
addq %rcx, %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/TurkeyMcMac[P]ts3d/src/grow.c
// Function: growc
char *growc(char **bufp, size_t *lenp, size_t *capp, size_t num)
{
	size_t old_len = *lenp;
	*lenp += num;
	if (*lenp > *capp) {
		*capp = *lenp + *lenp / 2 + 1;
		*bufp = xrealloc(*bufp, *capp);
	}
	return *bufp + old_len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jbe 0x680d
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
shrq %rax
addq %rax, %rcx
addq $0x1, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x10d00
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
addq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/TurkeyMcMac[P]ts3d/src/json-util.c
// Function: json_map_get
union json_node_data *json_map_get(struct json_node *map, const char *key,
	int kind)
{
	if (map->kind != JN_MAP) return NULL;
	void **got = table_get(&map->d.map, key);
	if (!got) return NULL;
	struct json_node *nd = *got;
	if (nd->taken) return NULL;
	if (nd->kind != (enum json_node_kind)(kind & ~TAKE_NODE)) return NULL;
	nd->taken = (kind & TAKE_NODE) != 0;
	return &nd->d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
je 0x6849
movq $0x0, -0x8(%rbp)
jmp 0x68cf
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
callq 0xfbe0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x686f
movq $0x0, -0x8(%rbp)
jmp 0x68cf
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
testb $0x1, 0x4(%rax)
je 0x688e
movq $0x0, -0x8(%rbp)
jmp 0x68cf
movq -0x30(%rbp), %rax
movl (%rax), %eax
movl -0x1c(%rbp), %ecx
andl $0xffffefff, %ecx       # imm = 0xFFFFEFFF
cmpl %ecx, %eax
je 0x68ab
movq $0x0, -0x8(%rbp)
jmp 0x68cf
movl -0x1c(%rbp), %eax
andl $0x1000, %eax           # imm = 0x1000
cmpl $0x0, %eax
setne %cl
movq -0x30(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x4(%rax)
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/TurkeyMcMac[P]ts3d/src/json-util.c
// Function: parse_json_tree
int parse_json_tree(const char *name, FILE *file, struct logger *log,
	struct json_node *root)
{
	json_reader rdr;
	struct json_reader_ctx ctx;
	ctx.file = file;
	ctx.log = log;
	json_alloc(&rdr, NULL, 8, xmalloc, free, xrealloc);
	json_source(&rdr, ctx.buf, sizeof(ctx.buf), &ctx, refill);
	ctx.name = name;
	ctx.line = 1;
	char *key;
	parse_node(&rdr, root, &key);
	json_free(&rdr);
	fclose(file);
	return root->kind == JN_ERROR ? -1 : 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20b0, %rsp           # imm = 0x20B0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x80(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x8, %edx
leaq 0xa25b(%rip), %rcx      # 0x10b80
movq 0xf684(%rip), %r8       # 0x15fb0
leaq 0xa3cd(%rip), %r9       # 0x10d00
callq 0x7510
leaq -0x20a0(%rbp), %rsi
leaq -0x80(%rbp), %rdi
movl $0x2000, %edx           # imm = 0x2000
leaq -0x20a0(%rbp), %rcx
leaq 0x6a(%rip), %r8         # 0x69c0
callq 0x7660
movq -0x8(%rbp), %rax
movq %rax, -0xa0(%rbp)
movl $0x1, -0x90(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x80(%rbp), %rdi
leaq -0x20a8(%rbp), %rdx
callq 0x6ab0
leaq -0x80(%rbp), %rdi
callq 0x78b0
movq -0x10(%rbp), %rdi
callq 0x23f0
movq -0x20(%rbp), %rax
movl (%rax), %edx
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpl $0x7, %edx
cmovel %ecx, %eax
addq $0x20b0, %rsp           # imm = 0x20B0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/TurkeyMcMac[P]ts3d/src/json-util.c
// Function: refill
static int refill(char **buf, size_t *size, void *ctx_v)
{
	struct json_reader_ctx *ctx = ctx_v;
	size_t got = fread(*buf, 1, *size, ctx->file);
	char *left = *buf;
	while ((left = memchr(left, '\n', got - (left - *buf)))) {
		++ctx->line;
		++left;
	}
	if (got < *size) {
		*size = got;
		return feof(ctx->file) ? 0 : -JSON_ERROR_ERRNO;
	}
	return 1;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
movq -0x28(%rbp), %rax
movq 0x2008(%rax), %rcx
movl $0x1, %esi
callq 0x22e0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
subq %rax, %rdx
movl $0xa, %esi
callq 0x20d0
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x6a5c
movq -0x28(%rbp), %rax
movl 0x2010(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x2010(%rax)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x6a0e
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x6a98
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq 0x2008(%rax), %rdi
callq 0x23e0
movl %eax, %edx
movl $0xffffffec, %eax       # imm = 0xFFFFFFEC
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x6a9f
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/TurkeyMcMac[P]ts3d/src/json-util.c
// Function: free_json_tree
void free_json_tree(struct json_node *nd)
{
	if (nd->taken) return;
	switch (nd->kind) {
		const char *k;
		void **v;
	case JN_MAP:
		TABLE_FOR_EACH(&nd->d.map, k, v) {
			free_json_pair(k, *v);
		}
		table_free(&nd->d.map);
		break;
	case JN_LIST:
		for (size_t i = 0; i < nd->d.list.n_vals; ++i) {
			free_json_tree(&nd->d.list.vals[i]);
		}
		free(nd->d.list.vals);
		break;
	case JN_STRING:
		free(nd->d.str);
		break;
	default:
		break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
testb $0x1, 0x4(%rax)
je 0x6e4b
jmp 0x6f61
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
subl $0x2, %eax
je 0x6e7a
jmp 0x6e5b
movl -0x2c(%rbp), %eax
subl $0x3, %eax
je 0x6f05
jmp 0x6e69
movl -0x2c(%rbp), %eax
subl $0x4, %eax
je 0x6f50
jmp 0x6f5f
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rdx
xorl %eax, %eax
cmpq 0x8(%rdx), %rcx
movb %al, -0x2d(%rbp)
jae 0x6ecf
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x20(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x20(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
movb $0x1, %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %al
testb $0x1, %al
jne 0x6ed8
jmp 0x6ef6
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x6f70
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x6e82
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0xfce0
jmp 0x6f61
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x6f41
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x28(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
callq 0x6e30
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x6f0d
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2580
jmp 0x6f61
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2580
jmp 0x6f61
jmp 0x6f61
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/TurkeyMcMac[P]ts3d/src/json-util.c
// Function: parse_json_vec
int parse_json_vec(d3d_vec_s *vec, const struct json_node_data_list *list)
{
	int retval = 0;
	vec->x = vec->y = 0;
	if (list->n_vals < 1) return -1;
	if (list->vals[0].kind == JN_NUMBER) {
		vec->x = list->vals[0].d.num;
	} else {
		retval |= -1;
	}
	if (list->n_vals >= 2 && list->vals[1].kind == JN_NUMBER) {
		vec->y = list->vals[1].d.num;
	} else {
		retval |= -1;
	}
	return retval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movq -0x18(%rbp), %rax
cmpq $0x1, (%rax)
jae 0x6fed
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7059
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x5, (%rax)
jne 0x7011
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movsd 0x8(%rax), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, (%rax)
jmp 0x701a
movl -0x1c(%rbp), %eax
orl $-0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x2, (%rax)
jb 0x704a
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x5, 0x20(%rax)
jne 0x704a
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movsd 0x28(%rax), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x8(%rax)
jmp 0x7053
movl -0x1c(%rbp), %eax
orl $-0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/TurkeyMcMac[P]ts3d/src/json-util.c
// Function: escape_text_json
void escape_text_json(const char *text, struct string *buf, size_t *cap)
{
	while (*text) {
		switch (*text) {
		case '"':
			string_pushn(buf, cap, "\\\"", 2);
			break;
		case '\\':
			string_pushn(buf, cap, "\\\\", 2);
			break;
		case '\b':
			string_pushn(buf, cap, "\\b", 2);
			break;
		case '\f':
			string_pushn(buf, cap, "\\f", 2);
			break;
		case '\n':
			string_pushn(buf, cap, "\\n", 2);
			break;
		case '\r':
			string_pushn(buf, cap, "\\r", 2);
			break;
		case '\t':
			string_pushn(buf, cap, "\\t", 2);
			break;
		default:
			if ((unsigned char)*text < 32) {
				char *space = string_grow(buf, cap, 7);
				sprintf(space, "\\u%04X", (unsigned char)*text);
				buf->len -= 1; // Ignore NUL that was appended.
			} else {
				string_pushc(buf, cap, *text);
			}
			break;
		}
		++text;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0x7223
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x24(%rbp)
subl $0x8, %eax
je 0x7121
jmp 0x7096
movl -0x24(%rbp), %eax
subl $0x9, %eax
je 0x7196
jmp 0x70a4
movl -0x24(%rbp), %eax
subl $0xa, %eax
je 0x715d
jmp 0x70b2
movl -0x24(%rbp), %eax
subl $0xc, %eax
je 0x713f
jmp 0x70c0
movl -0x24(%rbp), %eax
subl $0xd, %eax
je 0x717b
jmp 0x70ce
movl -0x24(%rbp), %eax
subl $0x22, %eax
je 0x70e5
jmp 0x70d8
movl -0x24(%rbp), %eax
subl $0x5c, %eax
je 0x7103
jmp 0x71b1
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq 0xa2f4(%rip), %rdx      # 0x113e8
movl $0x2, %ecx
callq 0xf8b0
jmp 0x7212
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq 0xa2d9(%rip), %rdx      # 0x113eb
movl $0x2, %ecx
callq 0xf8b0
jmp 0x7212
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq 0xa2be(%rip), %rdx      # 0x113ee
movl $0x2, %ecx
callq 0xf8b0
jmp 0x7212
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq 0xa2a3(%rip), %rdx      # 0x113f1
movl $0x2, %ecx
callq 0xf8b0
jmp 0x7212
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq 0xa288(%rip), %rdx      # 0x113f4
movl $0x2, %ecx
callq 0xf8b0
jmp 0x7212
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq 0xa26d(%rip), %rdx      # 0x113f7
movl $0x2, %ecx
callq 0xf8b0
jmp 0x7212
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq 0xa255(%rip), %rdx      # 0x113fa
movl $0x2, %ecx
callq 0xf8b0
jmp 0x7212
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x20, %eax
jge 0x71fc
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x7, %edx
callq 0xf830
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rax
movzbl (%rax), %edx
leaq 0xa218(%rip), %rsi      # 0x113fd
movb $0x0, %al
callq 0x2230
movq -0x10(%rbp), %rax
movq (%rax), %rcx
subq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x7210
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rax
movsbl (%rax), %edx
callq 0xf950
jmp 0x7212
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x7074
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/TurkeyMcMac[P]ts3d/src/json-util.c
// Function: scan_json_key
int scan_json_key(json_reader *rdr, const char *key, struct json_item *item)
{
	long depth = 0;
	do {
		if (json_read_item(rdr, item)) return -1;
		if (depth == 1
		 && item->key.bytes
		 && !strcmp(key, item->key.bytes))
			return 0;
		switch (item->type) {
		case JSON_LIST:
		case JSON_MAP:
			++depth;
			break;
		case JSON_END_LIST:
		case JSON_END_MAP:
			--depth;
			break;
		case JSON_EMPTY:
			depth = 0;
			break;
		case JSON_STRING:
			free(item->val.str.bytes);
			break;
		default:
			break;
		}
		free(item->key.bytes);
	} while (depth > 0);
	item->type = JSON_EMPTY;
	item->key.len = 0;
	item->key.bytes = NULL;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x7990
cmpl $0x0, %eax
je 0x726a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7338
cmpq $0x1, -0x28(%rbp)
jne 0x729c
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x729c
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
callq 0x2380
cmpl $0x0, %eax
jne 0x729c
movl $0x0, -0x4(%rbp)
jmp 0x7338
movq -0x20(%rbp), %rax
movl 0x10(%rax), %eax
movq %rax, -0x30(%rbp)
subq $0x6, %rax
ja 0x72f6
movq -0x30(%rbp), %rax
leaq 0xa0e4(%rip), %rcx      # 0x1139c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x72f8
movq -0x28(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x72f8
movq $0x0, -0x28(%rbp)
jmp 0x72f8
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x2580
jmp 0x72f8
jmp 0x72f8
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x2580
cmpq $0x0, -0x28(%rbp)
jg 0x724c
movq -0x20(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/TurkeyMcMac[P]ts3d/src/json.c
// Function: json_alloc
int json_alloc(json_reader *reader,
	void *stack, size_t stacksiz,
	void *(*alloc)(size_t),
	void  (*dealloc)(void *),
	void *(*resize)(void *, size_t))
{
	reader->alloc = alloc ? alloc : alloc_fail;
	reader->dealloc = dealloc ? dealloc : dealloc_noop;
	reader->resize = resize ? resize : realloc_fail;
	reader->flags = 0;
	if (!stack && stacksiz <= sizeof(reader->stack.small.frames)
		/* Just in case, make sure the small size can't overflow: */
		&& (size_t)UCHAR_MAX >= sizeof(reader->stack.small.frames))
	{
		reader->flags |= SMALL_STACK;
		reader->stack.small.size = 0;
	} else {
		if (!stack && !(stack = reader->alloc(stacksiz))) return -1;
		reader->stack.big.cap = stacksiz;
		reader->stack.big.size = 0;
	}
	return 0;
}

// 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 %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x7541
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x754e
leaq 0xe8(%rip), %rax        # 0x7630
movq %rax, -0x40(%rbp)
jmp 0x754e
movq -0x40(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x30(%rbp)
je 0x756a
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x7577
leaq 0xcf(%rip), %rax        # 0x7640
movq %rax, -0x48(%rbp)
jmp 0x7577
movq -0x48(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
cmpq $0x0, -0x38(%rbp)
je 0x7594
movq -0x38(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0x75a1
leaq 0xb5(%rip), %rax        # 0x7650
movq %rax, -0x50(%rbp)
jmp 0x75a1
movq -0x50(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x58(%rax)
cmpq $0x0, -0x18(%rbp)
jne 0x75e0
cmpq $0x17, -0x20(%rbp)
ja 0x75e0
movq -0x10(%rbp), %rax
movl 0x58(%rax), %ecx
orl $0x400, %ecx            # imm = 0x400
movl %ecx, 0x58(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x57(%rax)
jmp 0x761f
cmpq $0x0, -0x18(%rbp)
jne 0x7607
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rdi
callq *%rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x7607
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7626
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x48(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/TurkeyMcMac[P]ts3d/src/json.c
// Function: json_source
void json_source(json_reader *reader,
	char *buf, size_t bufsiz, void *ctx,
	int (*refill)(char **buf, size_t *bufsiz, void *ctx))
{
	reader->ctx = ctx;
	reader->buf = buf;
	reader->bufsiz = bufsiz;
	reader->head = bufsiz;
	if (refill) {
		reader->refill = refill;
	} else {
		reader->refill = refill_dont;
		reader->flags |= SOURCE_DEPLETED;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x38(%rax)
cmpq $0x0, -0x28(%rbp)
je 0x76bd
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0x76dc
movq -0x8(%rbp), %rax
leaq 0x18(%rip), %rcx        # 0x76e0
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movl 0x58(%rax), %ecx
orl $0x100, %ecx            # imm = 0x100
movl %ecx, 0x58(%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/TurkeyMcMac[P]ts3d/src/json.c
// Function: json_source_string
void json_source_string(json_reader *reader, const char *str, size_t len)
{
	reader->ctx = NULL;
	reader->buf = (char *)str;
	reader->bufsiz = len;
	reader->head = 0;
	reader->refill = refill_dont;
	reader->flags |= SOURCE_DEPLETED;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x8(%rbp), %rax
leaq -0x6b(%rip), %rcx       # 0x76e0
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movl 0x58(%rax), %ecx
orl $0x100, %ecx            # imm = 0x100
movl %ecx, 0x58(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/TurkeyMcMac[P]ts3d/src/json.c
// Function: refill_stdio
static int refill_stdio(char **buf, size_t *size, void *ctx)
{
	FILE *file = ctx;
	size_t got = fread(*buf, 1, *size, file);
	if (got < *size) {
		*size = got;
		return feof(file) ? 0 : -JSON_ERROR_ERRNO;
	}
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
movq -0x28(%rbp), %rcx
movl $0x1, %esi
callq 0x22e0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x7821
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rdi
callq 0x23e0
movl %eax, %edx
movl $0xffffffec, %eax       # imm = 0xFFFFFFEC
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x7828
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/TurkeyMcMac[P]ts3d/src/json.c
// Function: json_get_last_error
int json_get_last_error(const json_reader *reader,
	enum json_type *code, size_t *erridx)
{
	if (has_error(reader)) {
		if (erridx) *erridx = reader->head;
		if (code) *code = reader->flags & 0xFF;
		return 1;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7960
cmpl $0x0, %eax
je 0x794b
cmpq $0x0, -0x20(%rbp)
je 0x7928
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x18(%rbp)
je 0x7942
movq -0x10(%rbp), %rax
movl 0x58(%rax), %ecx
andl $0xff, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x7952
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/TurkeyMcMac[P]ts3d/src/json.c
// Function: refill
static int refill(json_reader *reader)
{
	size_t newsiz = reader->bufsiz;
	/* WARNING: Must refer to &reader->buf for refill_fd to work! */
	int retval = reader->refill(&reader->buf, &newsiz, reader->ctx);
	if (retval < 0) {
		set_error(reader, -retval & 0xFF);
		return -1;
	}
	if (retval == 0) reader->flags |= SOURCE_DEPLETED;
	reader->bufsiz = newsiz;
	reader->head = 0;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
movq -0x10(%rbp), %rcx
movq 0x30(%rcx), %rdx
leaq -0x18(%rbp), %rsi
callq *%rax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x7dbc
movq -0x10(%rbp), %rdi
xorl %esi, %esi
subl -0x1c(%rbp), %esi
andl $0xff, %esi
callq 0x7d30
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7df1
cmpl $0x0, -0x1c(%rbp)
jne 0x7dd2
movq -0x10(%rbp), %rax
movl 0x58(%rax), %ecx
orl $0x100, %ecx            # imm = 0x100
movl %ecx, 0x58(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x38(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/TurkeyMcMac[P]ts3d/src/json.c
// Function: peek_frame
static int peek_frame(const json_reader *reader)
{
	if (reader->flags & SMALL_STACK) {
		if (reader->stack.small.size == 0) return FRAME_EMPTY;
		return reader->stack.small.frames[reader->stack.small.size - 1];
	} else {
		if (reader->stack.big.size == 0) return FRAME_EMPTY;
		return reader->stack.big.frames[reader->stack.big.size - 1];
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x58(%rax), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
je 0x7e4b
movq -0x10(%rbp), %rax
movzbl 0x57(%rax), %eax
cmpl $0x0, %eax
jne 0x7e2f
movl $0x0, -0x4(%rbp)
jmp 0x7e7a
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movzbl 0x57(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl 0x40(%rax,%rcx), %eax
movl %eax, -0x4(%rbp)
jmp 0x7e7a
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
jne 0x7e5f
movl $0x0, -0x4(%rbp)
jmp 0x7e7a
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x48(%rcx), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/TurkeyMcMac[P]ts3d/src/json.c
// Function: skip_spaces
static int skip_spaces(json_reader *reader)
{
	for (;;) {
		while (is_in_range(reader)) {
			if (!is_space(reader->buf[reader->head])) return 0;
			++reader->head;
		}
		if (reader->flags & SOURCE_DEPLETED) return 0;
		if (refill(reader)) return -1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
jmp 0x7e8e
movq -0x10(%rbp), %rdi
callq 0x7d00
cmpl $0x0, %eax
je 0x7ed5
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x38(%rcx), %rcx
movsbl (%rax,%rcx), %edi
callq 0x8390
cmpl $0x0, %eax
jne 0x7ec3
movl $0x0, -0x4(%rbp)
jmp 0x7f08
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x38(%rax)
jmp 0x7e8e
movq -0x10(%rbp), %rax
movl 0x58(%rax), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
je 0x7eef
movl $0x0, -0x4(%rbp)
jmp 0x7f08
movq -0x10(%rbp), %rdi
callq 0x7d60
cmpl $0x0, %eax
je 0x7f06
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7f08
jmp 0x7e8c
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/TurkeyMcMac[P]ts3d/src/json.c
// Function: parse_value
static int parse_value(json_reader *reader, struct json_item *result)
{
	int ch;
	NEXT_CHAR(reader, ch, goto error_expected_value);
	switch (ch) {
	case '[':
		push_frame(reader, FRAME_LIST);
		reader->flags |= STARTED_COMPOUND;
		result->type = JSON_LIST;
		break;
	case '{':
		push_frame(reader, FRAME_MAP);
		reader->flags |= STARTED_COMPOUND;
		result->type = JSON_MAP;
		break;
	case '"':
		reexamine_char(reader);
		if (parse_string(reader, &result->val.str)) goto error;
		result->type = JSON_STRING;
		break;
	default:
		reexamine_char(reader);
		if (parse_token_value(reader, result)) goto error;
		break;
	}
	return 0;

error_expected_value:
	if (!has_error(reader)) set_error(reader, JSON_ERROR_EXPECTED_VALUE);
error:
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x83e0
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
jge 0x7f46
jmp 0x8018
jmp 0x7f48
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
subl $0x22, %eax
je 0x7fc2
jmp 0x7f55
movl -0x20(%rbp), %eax
subl $0x5b, %eax
je 0x7f6c
jmp 0x7f5f
movl -0x20(%rbp), %eax
subl $0x7b, %eax
je 0x7f97
jmp 0x7ff0
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x8480
movq -0x10(%rbp), %rax
movl 0x58(%rax), %ecx
orl $0x200, %ecx            # imm = 0x200
movl %ecx, 0x58(%rax)
movq -0x18(%rbp), %rax
movl $0x4, 0x10(%rax)
jmp 0x800f
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x8480
movq -0x10(%rbp), %rax
movl 0x58(%rax), %ecx
orl $0x200, %ecx            # imm = 0x200
movl %ecx, 0x58(%rax)
movq -0x18(%rbp), %rax
movl $0x2, 0x10(%rax)
jmp 0x800f
movq -0x10(%rbp), %rdi
callq 0x8620
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x18, %rsi
callq 0x8160
cmpl $0x0, %eax
je 0x7fe3
jmp 0x8036
movq -0x18(%rbp), %rax
movl $0x6, 0x10(%rax)
jmp 0x800f
movq -0x10(%rbp), %rdi
callq 0x8620
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x8640
cmpl $0x0, %eax
je 0x800d
jmp 0x8036
jmp 0x800f
movl $0x0, -0x4(%rbp)
jmp 0x803d
movq -0x10(%rbp), %rdi
callq 0x7960
cmpl $0x0, %eax
jne 0x8034
movq -0x10(%rbp), %rdi
movl $0x12, %esi
callq 0x7d30
jmp 0x8036
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/TurkeyMcMac[P]ts3d/src/json.c
// Function: try_compound_end
static int try_compound_end(json_reader *reader, int endch,
	enum json_type type, struct json_item *result)
{
	int ch;
	NEXT_CHAR(reader, ch, return -has_error(reader));
	if (ch == endch) {
		pop_frame(reader);
		result->type = type;
	} else {
		reexamine_char(reader);
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x83e0
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
jge 0x808b
movq -0x10(%rbp), %rdi
callq 0x7960
movl %eax, %ecx
xorl %eax, %eax
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x80ba
jmp 0x808d
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jne 0x80aa
movq -0x10(%rbp), %rdi
callq 0x8de0
movl -0x18(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x10(%rax)
jmp 0x80b3
movq -0x10(%rbp), %rdi
callq 0x8620
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/TurkeyMcMac[P]ts3d/src/json.c
// Function: parse_after_elem
static int parse_after_elem(json_reader *reader, int endch,
	enum json_type type, struct json_item *result)
{
	int ch;
	NEXT_CHAR(reader, ch, return -has_error(reader));
	if (ch == endch) {
		pop_frame(reader);
		result->type = type;
	} else if (ch != ',') {
		set_error(reader, JSON_ERROR_BRACKETS);
		return -1;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x83e0
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
jge 0x810b
movq -0x10(%rbp), %rdi
callq 0x7960
movl %eax, %ecx
xorl %eax, %eax
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x8150
jmp 0x810d
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jne 0x812a
movq -0x10(%rbp), %rdi
callq 0x8de0
movl -0x18(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x10(%rax)
jmp 0x8149
cmpl $0x2c, -0x24(%rbp)
je 0x8147
movq -0x10(%rbp), %rdi
movl $0xe, %esi
callq 0x7d30
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x8150
jmp 0x8149
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/TurkeyMcMac[P]ts3d/src/json.c
// Function: parse_colon
static int parse_colon(json_reader *reader)
{
	if (reader->buf[reader->head] != ':') {
		set_error(reader, JSON_ERROR_EXPECTED_COLON);
		return -1;
	}
	++reader->head;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x38(%rcx), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x3a, %eax
je 0x836c
movq -0x10(%rbp), %rdi
movl $0xd, %esi
callq 0x7d30
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x8383
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x38(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/TurkeyMcMac[P]ts3d/src/json.c
// Function: next_char
static int next_char(json_reader *reader)
{
	while (!is_in_range(reader) && (reader->flags & SOURCE_DEPLETED) == 0) {
		if (refill(reader)) return -1;
	}
	if (is_in_range(reader))
		return (unsigned char)reader->buf[reader->head++];
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7d00
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x11(%rbp)
jne 0x8416
movq -0x10(%rbp), %rax
movl 0x58(%rax), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
sete %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x841f
jmp 0x8438
movq -0x10(%rbp), %rdi
callq 0x7d60
cmpl $0x0, %eax
je 0x8436
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x8471
jmp 0x83ec
movq -0x10(%rbp), %rdi
callq 0x7d00
cmpl $0x0, %eax
je 0x846a
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rdx
movq 0x38(%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x38(%rdx)
movzbl (%rax,%rcx), %eax
movl %eax, -0x4(%rbp)
jmp 0x8471
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/TurkeyMcMac[P]ts3d/src/json.c
// Function: parse_token_value
static int parse_token_value(json_reader *reader,
	struct json_item *result)
{
	long read;
	char tokbuf[5];
	switch (reader->buf[reader->head]) {
	case 't': /* true */
		if ((read = next_chars(reader, tokbuf, 4)) < 0) goto error;
		if (read < 4 || memcmp(tokbuf, "true", 4)) goto error_invalid;
		result->type = JSON_BOOLEAN;
		result->val.boolean = 1;
		break;
	case 'f': /* false */
		if ((read = next_chars(reader, tokbuf, 5)) < 0) goto error;
		if (read < 5 || memcmp(tokbuf, "false", 5)) goto error_invalid;
		result->type = JSON_BOOLEAN;
		result->val.boolean = 0;
		break;
	case 'n': /* null */
		if ((read = next_chars(reader, tokbuf, 4)) < 0) goto error;
		if (read < 4 || memcmp(tokbuf, "null", 4)) goto error_invalid;
		result->type = JSON_NULL;
		break;
	default: /* number */
		if (parse_number(reader, result)) goto error;
		break;
	}
	return 0;

error_invalid:
	set_error(reader, JSON_ERROR_TOKEN);
error:
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rax
movq 0x38(%rcx), %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0x2c(%rbp)
subl $0x66, %eax
je 0x86e4
jmp 0x866a
movl -0x2c(%rbp), %eax
subl $0x6e, %eax
je 0x8743
jmp 0x8678
movl -0x2c(%rbp), %eax
subl $0x74, %eax
jne 0x878d
jmp 0x8686
movq -0x10(%rbp), %rdi
leaq -0x25(%rbp), %rsi
movl $0x4, %edx
callq 0x88a0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jge 0x86a7
jmp 0x87ba
cmpq $0x4, -0x20(%rbp)
jl 0x86c4
leaq -0x25(%rbp), %rax
movl (%rax), %eax
subl $0x65757274, %eax       # imm = 0x65757274
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x86c9
jmp 0x87ac
movq -0x18(%rbp), %rax
movl $0x8, 0x10(%rax)
movq -0x18(%rbp), %rax
movl $0x1, 0x18(%rax)
jmp 0x87a3
movq -0x10(%rbp), %rdi
leaq -0x25(%rbp), %rsi
movl $0x5, %edx
callq 0x88a0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jge 0x8705
jmp 0x87ba
cmpq $0x5, -0x20(%rbp)
jl 0x8726
leaq -0x25(%rbp), %rdi
leaq 0x8f6e(%rip), %rsi      # 0x11685
movl $0x5, %edx
callq 0x23c0
cmpl $0x0, %eax
je 0x872b
jmp 0x87ac
movq -0x18(%rbp), %rax
movl $0x8, 0x10(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x18(%rax)
jmp 0x87a3
movq -0x10(%rbp), %rdi
leaq -0x25(%rbp), %rsi
movl $0x4, %edx
callq 0x88a0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jge 0x8761
jmp 0x87ba
cmpq $0x4, -0x20(%rbp)
jl 0x877e
leaq -0x25(%rbp), %rax
movl (%rax), %eax
subl $0x6c6c756e, %eax       # imm = 0x6C6C756E
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x8780
jmp 0x87ac
movq -0x18(%rbp), %rax
movl $0x1, 0x10(%rax)
jmp 0x87a3
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x89e0
cmpl $0x0, %eax
je 0x87a1
jmp 0x87ba
jmp 0x87a3
movl $0x0, -0x4(%rbp)
jmp 0x87c1
movq -0x10(%rbp), %rdi
movl $0xb, %esi
callq 0x7d30
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/TurkeyMcMac[P]ts3d/src/json.c
// Function: push_byte
static int push_byte(json_reader *reader, char **bytes,
	size_t *len, size_t *cap, int ch)
{
	if (*len >= *cap) {
		size_t new_cap = *cap + *cap / 2 + 1;
		char *new_bytes = reader->resize(*bytes, new_cap);
		if (!new_bytes) {
			set_error(reader, JSON_ERROR_MEMORY);
			return -1;
		}
		*cap = new_cap;
		*bytes = new_bytes;
	}
	(*bytes)[*len] = ch;
	++*len;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
cmpq (%rcx), %rax
jb 0x8865
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rcx), %rcx
shrq %rcx
addq %rcx, %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rdi
movq -0x38(%rbp), %rsi
callq *%rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x884f
movq -0x10(%rbp), %rdi
movl $0x9, %esi
callq 0x7d30
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x8890
movq -0x38(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x40(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl -0x2c(%rbp), %eax
movb %al, %dl
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rcx
movb %dl, (%rax,%rcx)
movq -0x20(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/TurkeyMcMac[P]ts3d/src/json.c
// Function: next_chars
static long next_chars(json_reader *reader, char *buf, size_t bufsiz)
{
	if (reader->head + bufsiz <= reader->bufsiz) {
		memcpy(buf, reader->buf + reader->head, bufsiz);
		reader->head += bufsiz;
	} else {
		size_t i;
		size_t easy_copy = reader->bufsiz - reader->head;
		memcpy(buf, reader->buf + reader->head, easy_copy);
		if (refill(reader)) return -1;
		for (i = easy_copy; i < bufsiz; ++i) {
			int ch;
			NEXT_CHAR(reader, ch, return
				reader->flags & SOURCE_DEPLETED ? (long)i : -1);
			buf[i] = ch;
		}
	}
	return bufsiz;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
addq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x28(%rcx), %rax
ja 0x88fc
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x10(%rbp), %rax
addq 0x38(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x2510
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x38(%rax), %rcx
movq %rcx, 0x38(%rax)
jmp 0x89c1
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
subq 0x38(%rcx), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x10(%rbp), %rax
addq 0x38(%rax), %rsi
movq -0x30(%rbp), %rdx
callq 0x2510
movq -0x10(%rbp), %rdi
callq 0x7d60
cmpl $0x0, %eax
je 0x8948
movq $-0x1, -0x8(%rbp)
jmp 0x89c9
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x89bf
jmp 0x895c
movq -0x10(%rbp), %rdi
callq 0x83e0
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
jge 0x899f
movq -0x10(%rbp), %rax
movl 0x58(%rax), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
je 0x8988
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x8995
movq $-0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x8995
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x89c9
jmp 0x89a1
movl -0x34(%rbp), %eax
movb %al, %dl
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x8950
jmp 0x89c1
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/TurkeyMcMac[P]ts3d/src/json.c
// Function: pop_frame
static int pop_frame(json_reader *reader)
{
	if (reader->flags & SMALL_STACK) {
		if (reader->stack.small.size == 0) return FRAME_EMPTY;
		return reader->stack.small.frames[--reader->stack.small.size];
	} else {
		if (reader->stack.big.size == 0) return FRAME_EMPTY;
		return reader->stack.big.frames[--reader->stack.big.size];
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x58(%rax), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
je 0x8e2d
movq -0x10(%rbp), %rax
movzbl 0x57(%rax), %eax
cmpl $0x0, %eax
jne 0x8e0f
movl $0x0, -0x4(%rbp)
jmp 0x8e64
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rdx
movb 0x57(%rdx), %cl
addb $-0x1, %cl
movb %cl, 0x57(%rdx)
movzbl %cl, %ecx
movsbl 0x40(%rax,%rcx), %eax
movl %eax, -0x4(%rbp)
jmp 0x8e64
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
jne 0x8e41
movl $0x0, -0x4(%rbp)
jmp 0x8e64
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rdx
movq 0x48(%rdx), %rcx
movq %rcx, %rsi
addq $-0x1, %rsi
movq %rsi, 0x48(%rdx)
movsbl -0x1(%rax,%rcx), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/TurkeyMcMac[P]ts3d/src/json.c
// Function: hex_short
static long hex_short(const char hex[4])
{
	long num = 0;
	unsigned shift = 0;
	long i;
	for (i = 3, shift = 0; i >= 0; --i, shift += 4) {
		int dig = to_lower(hex[i]);
		long nibble;
		if (is_digit(dig)) nibble = to_digit(dig);
		else if (dig >= 'a' && dig <= 'f') nibble = 10 + to_digit(dig);
		else return -1;
		num |= nibble << shift;
	}
	return num;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq $0x3, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
cmpq $0x0, -0x28(%rbp)
jl 0x930d
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x95c0
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %edi
callq 0x8da0
cmpl $0x0, %eax
je 0x92b6
movl -0x2c(%rbp), %edi
callq 0x8dd0
cltq
movq %rax, -0x38(%rbp)
jmp 0x92e1
cmpl $0x61, -0x2c(%rbp)
jl 0x92d5
cmpl $0x66, -0x2c(%rbp)
jg 0x92d5
movl -0x2c(%rbp), %edi
callq 0x8dd0
addl $0xa, %eax
cltq
movq %rax, -0x38(%rbp)
jmp 0x92df
movq $-0x1, -0x8(%rbp)
jmp 0x9315
jmp 0x92e1
movq -0x38(%rbp), %rax
movl -0x1c(%rbp), %ecx
shlq %cl, %rax
orq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
movl -0x1c(%rbp), %eax
addl $0x4, %eax
movl %eax, -0x1c(%rbp)
jmp 0x927a
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/TurkeyMcMac[P]ts3d/src/json.c
// Function: push_bytes
static int push_bytes(json_reader *reader, char **bytes,
	size_t *len, size_t *cap, const char *buf, size_t bufsiz)
{
	if (*len + bufsiz > *cap) {
		size_t new_cap = *len + bufsiz;
		char *new_bytes;
		new_cap += new_cap / 2;
		new_bytes = reader->resize(*bytes, new_cap);
		if (!new_bytes) {
			set_error(reader, JSON_ERROR_MEMORY);
			return -1;
		}
		*cap = new_cap;
		*bytes = new_bytes;
	}
	memcpy(*bytes + *len, buf, bufsiz);
	*len += bufsiz;
	return 0;
}

// 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 %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
addq -0x38(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpq (%rcx), %rax
jbe 0x943f
movq -0x20(%rbp), %rax
movq (%rax), %rax
addq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
shrq %rax
addq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rdi
movq -0x40(%rbp), %rsi
callq *%rax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0x9429
movq -0x10(%rbp), %rdi
movl $0x9, %esi
callq 0x7d30
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x946f
movq -0x40(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x48(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rax
addq (%rax), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x2510
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)