LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/symbol_table.c
// Function: subtilis_symbol_table_promote_tmp
const subtilis_symbol_t *subtilis_symbol_table_promote_tmp(
	subtilis_symbol_table_t *st, const subtilis_type_t *id_type,
	const char *tmp_name, const char *new_name, subtilis_error_t *err)
/* clang-format on */

{
	subtilis_symbol_t *s;
	char *name = NULL;

	s = subtilis_hashtable_extract(st->h, tmp_name);
	if (!s) {
		subtilis_error_set_assertion_failed(err);
		return NULL;
	}

	if (!subtilis_type_eq(id_type, &s->t)) {
		subtilis_error_set_assertion_failed(err);
		return NULL;
	}

	name = malloc(strlen(new_name) + 1);
	if (!name) {
		subtilis_error_set_oom(err);
		return NULL;
	}
	strcpy(name, new_name);
	s->key = name;

	(void)subtilis_hashtable_insert(st->h, name, s, err);
	if (err->type != SUBTILIS_ERROR_OK) {
		free(s);
		free(name);
		return NULL;
	}

	return s;
}

// 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)
movq %r8, -0x30(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq 0x300(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x3be10
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x3cb2a
movq -0x30(%rbp), %rdi
movl $0xf, %esi
leaq 0x6e803(%rip), %rdx     # 0xab316
movl $0x16b, %ecx            # imm = 0x16B
callq 0x158e0
movq $0x0, -0x8(%rbp)
jmp 0x3cc0f
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rsi
addq $0x8, %rsi
callq 0x3d880
testb $0x1, %al
jne 0x3cb66
movq -0x30(%rbp), %rdi
movl $0xf, %esi
leaq 0x6e7c7(%rip), %rdx     # 0xab316
movl $0x170, %ecx            # imm = 0x170
callq 0x158e0
movq $0x0, -0x8(%rbp)
jmp 0x3cc0f
movq -0x28(%rbp), %rdi
callq 0x120d0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x121b0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x3cbaa
movq -0x30(%rbp), %rdi
movl $0x1, %esi
leaq 0x6e780(%rip), %rdx     # 0xab316
movl $0x176, %ecx            # imm = 0x176
callq 0x158e0
movq $0x0, -0x8(%rbp)
jmp 0x3cc0f
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x12060
movq -0x40(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x298(%rax)
movq -0x10(%rbp), %rax
movq 0x300(%rax), %rdi
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x3bbf0
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x3cc07
movq -0x38(%rbp), %rdi
callq 0x12290
movq -0x40(%rbp), %rdi
callq 0x12290
movq $0x0, -0x8(%rbp)
jmp 0x3cc0f
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/symbol_table.c
// Function: prv_symbol_new
static subtilis_symbol_t *prv_symbol_new(const char *key, size_t loc,
					 const subtilis_type_t *id_type,
					 const subtilis_type_t *sub_type,
					 size_t size, bool is_reg, bool no_rc,
					 subtilis_error_t *err)
{
	subtilis_symbol_t *sym;

	sym = malloc(sizeof(*sym));
	if (!sym) {
		subtilis_error_set_oom(err);
		return NULL;
	}

	subtilis_type_init_copy(&sym->t, id_type, err);
	if (err->type != SUBTILIS_ERROR_OK) {
		free(sym);
		return NULL;
	}

	sym->sub_t.type = SUBTILIS_TYPE_VOID;
	if (sub_type) {
		subtilis_type_init_copy(&sym->sub_t, sub_type, err);
		if (err->type != SUBTILIS_ERROR_OK) {
			prv_symbol_delete(sym);
			return NULL;
		}
	}

	sym->size = size;
	sym->key = key;
	sym->loc = loc;
	sym->is_reg = is_reg;
	sym->no_rc = no_rc;

	return sym;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %r9d, %eax
movq %rcx, -0x58(%rbp)
movq %rdx, %rcx
movq -0x58(%rbp), %rdx
movq %rcx, -0x50(%rbp)
movq %rsi, %rcx
movq -0x50(%rbp), %rsi
movq %rcx, -0x48(%rbp)
movq %rdi, %r9
movq -0x48(%rbp), %rdi
movb %al, %cl
movq 0x18(%rbp), %rax
movb 0x10(%rbp), %al
movq %r9, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
andb $0x1, %cl
movb %cl, -0x31(%rbp)
andb $0x1, %al
movb %al, -0x32(%rbp)
movl $0x2b0, %edi            # imm = 0x2B0
callq 0x121b0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x3ce70
movq 0x18(%rbp), %rdi
movl $0x1, %esi
leaq 0x6e4bd(%rip), %rdx     # 0xab316
movl $0x89, %ecx
callq 0x158e0
movq $0x0, -0x8(%rbp)
jmp 0x3cf40
movq -0x40(%rbp), %rdi
addq $0x8, %rdi
movq -0x20(%rbp), %rsi
movq 0x18(%rbp), %rdx
callq 0x3dec0
movq 0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x3cea4
movq -0x40(%rbp), %rdi
callq 0x12290
movq $0x0, -0x8(%rbp)
jmp 0x3cf40
movq -0x40(%rbp), %rax
movl $0x8, 0x150(%rax)
cmpq $0x0, -0x28(%rbp)
je 0x3ceef
movq -0x40(%rbp), %rdi
addq $0x150, %rdi            # imm = 0x150
movq -0x28(%rbp), %rsi
movq 0x18(%rbp), %rdx
callq 0x3dec0
movq 0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x3ceed
movq -0x40(%rbp), %rdi
callq 0x3c260
movq $0x0, -0x8(%rbp)
jmp 0x3cf40
jmp 0x3ceef
movq -0x30(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x2a0(%rax)
movq -0x10(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x298(%rax)
movq -0x18(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, (%rax)
movb -0x31(%rbp), %cl
movq -0x40(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x2a8(%rax)
movb -0x32(%rbp), %cl
movq -0x40(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x2a9(%rax)
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/symbol_table.c
// Function: prv_ensure_symbol_level
static void prv_ensure_symbol_level(subtilis_symbol_table_t *st,
				    size_t level_idx, subtilis_error_t *err)
{
	size_t new_size;
	subtilis_symbol_level_t *level = &st->levels[level_idx];
	const subtilis_symbol_t **new_symbols;

	if (level->size < level->max_size)
		return;

	new_size = level->size + SUBTILIS_SYMBOL_MAX_LEVELS;
	new_symbols = realloc(level->symbols, new_size * sizeof(*new_symbols));
	if (!new_symbols) {
		subtilis_error_set_oom(err);
		return;
	}
	level->symbols = new_symbols;
	level->max_size = new_size;
}

// 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
imulq $0x18, -0x10(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x3cf87
jmp 0x3cfea
movq -0x28(%rbp), %rax
movq (%rax), %rax
addq $0x20, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x20(%rbp), %rsi
shlq $0x3, %rsi
callq 0x121e0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x3cfd2
movq -0x18(%rbp), %rdi
movl $0x1, %esi
leaq 0x6e350(%rip), %rdx     # 0xab316
movl $0x5a, %ecx
callq 0x158e0
jmp 0x3cfea
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/symbol_table.c
// Function: subtilis_symbol_table_reset
void subtilis_symbol_table_reset(subtilis_symbol_table_t *st)
{
	st->levels[0].size = 0;
	subtilis_hashtable_reset(st->h);
	st->allocated = 0;
	st->max_allocated = 0;
	st->level = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq 0x300(%rax), %rdi
callq 0x3bf30
movq -0x8(%rbp), %rax
movq $0x0, 0x308(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x310(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x318(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/constant_pool.c
// Function: subtilis_constant_pool_new
subtilis_constant_pool_t *subtilis_constant_pool_new(subtilis_error_t *err)
{
	subtilis_constant_pool_t *pool;

	pool = calloc(1, sizeof(*pool));
	if (!pool) {
		subtilis_error_set_oom(err);
		return NULL;
	}
	pool->ref = 1;
	return pool;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x1, %edi
movl $0x20, %esi
callq 0x12130
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x3d0ca
movq -0x10(%rbp), %rdi
movl $0x1, %esi
leaq 0x6e278(%rip), %rdx     # 0xab32e
movl $0x1c, %ecx
callq 0x158e0
movq $0x0, -0x8(%rbp)
jmp 0x3d0de
movq -0x18(%rbp), %rax
movq $0x1, 0x18(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/constant_pool.c
// Function: subtilis_constant_pool_delete
void subtilis_constant_pool_delete(subtilis_constant_pool_t *pool)
{
	size_t i;

	if (!pool)
		return;

	if (pool->ref > 1) {
		pool->ref--;
		return;
	}

	for (i = 0; i < pool->size; i++)
		free(pool->data[i].data);
	free(pool->data);
	free(pool);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x3d125
jmp 0x3d194
movq -0x8(%rbp), %rax
cmpq $0x1, 0x18(%rax)
jbe 0x3d142
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x18(%rax)
jmp 0x3d194
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x3d17e
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
imulq $0x18, -0x10(%rbp), %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x12290
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x3d14a
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x12290
movq -0x8(%rbp), %rdi
callq 0x12290
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/constant_pool.c
// Function: subtilis_constant_pool_dump
void subtilis_constant_pool_dump(subtilis_constant_pool_t *pool)
{
	size_t i;
	size_t j;
	size_t count;

	for (i = 0; i < pool->size; i++) {
		printf("[%zu]:\n", i);
		count = 0;
		for (;;) {
			for (j = 0; j < 16; j++) {
				if (count == pool->data[i].data_size)
					goto next;
				printf("%x ", pool->data[i].data[count++]);
			}
			printf("\n");
		}
	/* clang-format off */
next:
	/* clang-format off */

		printf("\n");
	}
}

// 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 (%rcx), %rax
jae 0x3d27b
movq -0x10(%rbp), %rsi
leaq 0x6e175(%rip), %rdi     # 0xab345
movb $0x0, %al
callq 0x120f0
movq $0x0, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x10, -0x18(%rbp)
jae 0x3d24c
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
imulq $0x18, -0x10(%rbp), %rdx
addq %rdx, %rcx
cmpq (%rcx), %rax
jne 0x3d209
jmp 0x3d25c
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
imulq $0x18, -0x10(%rbp), %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movzbl (%rax,%rcx), %esi
leaq 0x6e116(%rip), %rdi     # 0xab34d
movb $0x0, %al
callq 0x120f0
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x3d1e7
leaq 0x6dc20(%rip), %rdi     # 0xaae73
movb $0x0, %al
callq 0x120f0
jmp 0x3d1df
leaq 0x6dc10(%rip), %rdi     # 0xaae73
movb $0x0, %al
callq 0x120f0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x3d1b4
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/constant_pool.c
// Function: subtilis_constant_pool_mem_size
size_t subtilis_constant_pool_mem_size(subtilis_constant_pool_t *pool,
				       size_t **ptrs, subtilis_error_t *err)
{
	size_t i;
	size_t mem_size = 0;
	size_t *constants;

	constants = malloc(sizeof(*constants) * pool->size);
	if (!constants) {
		subtilis_error_set_oom(err);
		return 0;
	}

	for (i = 0; i < pool->size; i++) {
		constants[i] = mem_size;
		mem_size += pool->data[i].data_size;
	}

	*ptrs = constants;

	return mem_size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
shlq $0x3, %rdi
callq 0x121b0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x3d4ab
movq -0x20(%rbp), %rdi
movl $0x1, %esi
leaq 0x6de97(%rip), %rdx     # 0xab32e
movl $0x84, %ecx
callq 0x158e0
movq $0x0, -0x8(%rbp)
jmp 0x3d50c
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x3d4f9
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
imulq $0x18, -0x28(%rbp), %rcx
addq %rcx, %rax
movq (%rax), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x3d4b3
movq -0x38(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%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/markdryan[P]subtilis/common/string_pool.c
// Function: subtilis_string_pool_new
subtilis_string_pool_t *subtilis_string_pool_new(subtilis_error_t *err)
{
	subtilis_string_pool_t *pool;

	pool = calloc(1, sizeof(*pool));
	if (!pool)
		subtilis_error_set_oom(err);
	pool->ref = 1;
	return pool;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, %edi
movl $0x20, %esi
callq 0x12130
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3d560
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq 0x6ddfb(%rip), %rdx     # 0xab351
movl $0x1c, %ecx
callq 0x158e0
movq -0x10(%rbp), %rax
movq $0x1, 0x18(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/string_pool.c
// Function: subtilis_string_pool_find
bool subtilis_string_pool_find(subtilis_string_pool_t *pool, const char *str,
			       size_t *index)
{
	size_t i;

	for (i = 0; i < pool->length; i++) {
		if (!strcmp(pool->strings[i], str))
			break;
	}

	if (i == pool->length)
		return false;

	*index = i;
	return true;
}

// 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 -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x3d5f9
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rsi
callq 0x12140
cmpl $0x0, %eax
jne 0x3d5e9
jmp 0x3d5f9
jmp 0x3d5eb
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x3d5bc
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x3d60d
movb $0x0, -0x1(%rbp)
jmp 0x3d61c
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/string_pool.c
// Function: subtilis_string_pool_register
size_t subtilis_string_pool_register(subtilis_string_pool_t *pool,
				     const char *str, subtilis_error_t *err)
{
	size_t i;
	char **new_pool;
	size_t new_max;
	char *str_dup = NULL;

	if (subtilis_string_pool_find(pool, str, &i))
		return i;

	i = pool->length;
	str_dup = malloc(strlen(str) + 1);
	if (!str_dup) {
		subtilis_error_set_oom(err);
		return 0;
	}
	(void)strcpy(str_dup, str);

	if (pool->length == pool->max_length) {
		new_max = pool->max_length + SUBTILIS_CONFIG_PROC_GRAN;
		new_pool =
		    realloc(pool->strings, new_max * sizeof(*pool->strings));
		if (!new_pool) {
			subtilis_error_set_oom(err);
			goto cleanup;
		}
		pool->max_length = new_max;
		pool->strings = new_pool;
	}

	pool->strings[i] = str_dup;
	pool->length++;

	return i;

cleanup:

	free(str_dup);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x3d5a0
testb $0x1, %al
jne 0x3d663
jmp 0x3d670
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3d782
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x120d0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x121b0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x3d6c3
movq -0x20(%rbp), %rdi
movl $0x1, %esi
leaq 0x6dca5(%rip), %rdx     # 0xab351
movl $0x46, %ecx
callq 0x158e0
movq $0x0, -0x8(%rbp)
jmp 0x3d782
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x12060
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x3d744
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x40, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x38(%rbp), %rsi
shlq $0x3, %rsi
callq 0x121e0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x3d72d
movq -0x20(%rbp), %rdi
movl $0x1, %esi
leaq 0x6dc30(%rip), %rdx     # 0xab351
movl $0x50, %ecx
callq 0x158e0
jmp 0x3d771
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x40(%rbp), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3d782
movq -0x40(%rbp), %rdi
callq 0x12290
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/string_pool.c
// Function: subtilis_string_pool_delete
void subtilis_string_pool_delete(subtilis_string_pool_t *pool)
{
	size_t i;

	if (!pool)
		return;

	if (pool->ref > 1) {
		pool->ref--;
		return;
	}

	for (i = 0; i < pool->length; i++)
		free(pool->strings[i]);
	free(pool->strings);
	free(pool);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x3d7a5
jmp 0x3d80f
movq -0x8(%rbp), %rax
cmpq $0x1, 0x18(%rax)
jbe 0x3d7c2
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x18(%rax)
jmp 0x3d80f
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x3d7fa
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x12290
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x3d7ca
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x12290
movq -0x8(%rbp), %rdi
callq 0x12290
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/type.c
// Function: subtilis_type_eq
bool subtilis_type_eq(const subtilis_type_t *a, const subtilis_type_t *b)
{
	if (a->type != b->type)
		return false;
	switch (a->type) {
	case SUBTILIS_TYPE_ARRAY_REAL:
	case SUBTILIS_TYPE_ARRAY_INTEGER:
	case SUBTILIS_TYPE_ARRAY_STRING:
	case SUBTILIS_TYPE_ARRAY_BYTE:
	case SUBTILIS_TYPE_ARRAY_FN:
	case SUBTILIS_TYPE_VECTOR_FN: /* fn vectors need extra checks */
	case SUBTILIS_TYPE_ARRAY_REC:
	case SUBTILIS_TYPE_VECTOR_REC: /* rec vectors need extra checks */
		return prv_array_type_match(a, b);
	case SUBTILIS_TYPE_FN:
		return prv_fn_type_match(&a->params.fn, &b->params.fn);
	case SUBTILIS_TYPE_REC:
		return prv_rec_type_match(&a->params.rec, &b->params.rec);
	default:
		return true;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
je 0x3d8a7
movb $0x0, -0x1(%rbp)
jmp 0x3d92b
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
subl $0x9, %eax
je 0x3d8ef
jmp 0x3d8b7
movl -0x1c(%rbp), %eax
addl $-0xa, %eax
subl $0x6, %eax
jb 0x3d8db
jmp 0x3d8c4
movl -0x1c(%rbp), %eax
addl $-0x14, %eax
subl $0x2, %eax
jb 0x3d8db
jmp 0x3d8d1
movl -0x1c(%rbp), %eax
subl $0x16, %eax
je 0x3d90b
jmp 0x3d927
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3d940
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x3d92b
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
callq 0x3da50
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x3d92b
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
callq 0x3db00
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x3d92b
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/type.c
// Function: prv_array_type_match
static bool prv_array_type_match(const subtilis_type_t *t1,
				 const subtilis_type_t *t2)
{
	size_t i;

	if (t1->params.array.num_dims != t2->params.array.num_dims)
		return false;

	for (i = 0; i < t1->params.array.num_dims; i++) {
		if (t1->params.array.dims[i] == -1)
			continue;
		if (t1->params.array.dims[i] != t2->params.array.dims[i])
			return false;
	}

	if ((t1->type == SUBTILIS_TYPE_ARRAY_FN) ||
	    (t1->type == SUBTILIS_TYPE_VECTOR_FN))
		return prv_fn_type_match(&t1->params.array.params.fn,
					 &t2->params.array.params.fn);
	else if ((t1->type == SUBTILIS_TYPE_ARRAY_REC) ||
		 (t1->type == SUBTILIS_TYPE_VECTOR_REC))
		return prv_rec_type_match(&t1->params.array.params.rec,
					  &t2->params.array.params.rec);
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
je 0x3d969
movb $0x0, -0x1(%rbp)
jmp 0x3da38
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq 0x8(%rcx), %rcx
cmpq %rcx, %rax
jae 0x3d9c6
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpl $-0x1, 0xc(%rax,%rcx,4)
jne 0x3d993
jmp 0x3d9b8
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movl 0xc(%rax,%rcx,4), %eax
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rdx
cmpl 0xc(%rcx,%rdx,4), %eax
je 0x3d9b6
movb $0x0, -0x1(%rbp)
jmp 0x3da38
jmp 0x3d9b8
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x3d971
movq -0x10(%rbp), %rax
cmpl $0xe, (%rax)
je 0x3d9d8
movq -0x10(%rbp), %rax
cmpl $0x14, (%rax)
jne 0x3d9fc
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
addq $0x30, %rdi
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
addq $0x30, %rsi
callq 0x3da50
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x3da38
movq -0x10(%rbp), %rax
cmpl $0xf, (%rax)
je 0x3da0e
movq -0x10(%rbp), %rax
cmpl $0x15, (%rax)
jne 0x3da32
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
addq $0x30, %rdi
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
addq $0x30, %rsi
callq 0x3db00
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x3da38
jmp 0x3da34
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/type.c
// Function: prv_fn_type_match
static bool prv_fn_type_match(const subtilis_type_fn_t *t1,
			      const subtilis_type_fn_t *t2)
{
	size_t i;

	if (!subtilis_type_eq(t1->ret_val, t2->ret_val))
		return false;

	if (t1->num_params != t2->num_params)
		return false;

	for (i = 0; i < t1->num_params; i++)
		if (!subtilis_type_eq(t1->params[i], t2->params[i]))
			return false;

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x3d880
testb $0x1, %al
jne 0x3da7d
movb $0x0, -0x1(%rbp)
jmp 0x3dae8
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
je 0x3da95
movb $0x0, -0x1(%rbp)
jmp 0x3dae8
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x3dae4
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x10(%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x10(%rax,%rcx,8), %rsi
callq 0x3d880
testb $0x1, %al
jne 0x3dad4
movb $0x0, -0x1(%rbp)
jmp 0x3dae8
jmp 0x3dad6
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x3da9d
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/type.c
// Function: prv_rec_type_match
static bool prv_rec_type_match(const subtilis_type_rec_t *t1,
			       const subtilis_type_rec_t *t2)
{
	size_t i;

	if (strcmp(t1->name, t2->name))
		return false;

	if (t1->num_fields != t2->num_fields)
		return false;

	for (i = 0; i < t1->num_fields; i++) {
		if (strcmp(t1->fields[i].name, t2->fields[i].name))
			return false;
		if (!subtilis_type_eq(&t1->field_types[i], &t2->field_types[i]))
			return false;
	}

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x12140
cmpl $0x0, %eax
je 0x3db33
movb $0x0, -0x1(%rbp)
jmp 0x3dbe6
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x20(%rcx), %rax
je 0x3db4e
movb $0x0, -0x1(%rbp)
jmp 0x3dbe6
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jae 0x3dbe2
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
imulq $0x18, -0x20(%rbp), %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
imulq $0x18, -0x20(%rbp), %rcx
addq %rcx, %rax
movq (%rax), %rsi
callq 0x12140
cmpl $0x0, %eax
je 0x3db9a
movb $0x0, -0x1(%rbp)
jmp 0x3dbe6
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
imulq $0x148, -0x20(%rbp), %rax # imm = 0x148
addq %rax, %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
imulq $0x148, -0x20(%rbp), %rax # imm = 0x148
addq %rax, %rsi
callq 0x3d880
testb $0x1, %al
jne 0x3dbcf
movb $0x0, -0x1(%rbp)
jmp 0x3dbe6
jmp 0x3dbd1
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x3db56
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/type.c
// Function: subtilis_type_section_delete
void subtilis_type_section_delete(subtilis_type_section_t *stype)
{
	size_t i;

	if (!stype)
		return;

	stype->ref_count--;
	if (stype->ref_count != 0)
		return;
	subtilis_type_free(&stype->type);
	if (stype->check_args) {
		for (i = 0; i < stype->type.params.fn.num_params; i++)
			free(stype->check_args[i].arg_name);
		free(stype->check_args);
	}
	free(stype);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x3e058
jmp 0x3e0f0
movq -0x8(%rbp), %rax
movq 0x150(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x150(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x150(%rax)
je 0x3e07e
jmp 0x3e0f0
movq -0x8(%rbp), %rdi
callq 0x3e100
movq -0x8(%rbp), %rax
cmpq $0x0, 0x148(%rax)
je 0x3e0e7
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x3e0d7
movq -0x8(%rbp), %rax
movq 0x148(%rax), %rax
movq -0x10(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x12290
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x3e09d
movq -0x8(%rbp), %rax
movq 0x148(%rax), %rdi
callq 0x12290
movq -0x8(%rbp), %rdi
callq 0x12290
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/type.c
// Function: subtilis_type_free
void subtilis_type_free(subtilis_type_t *typ)
{
	if (typ->type == SUBTILIS_TYPE_FN)
		prv_fn_type_free(&typ->params.fn);
	else if (typ->type == SUBTILIS_TYPE_REC)
		prv_rec_type_free(&typ->params.rec);
	else if ((typ->type == SUBTILIS_TYPE_ARRAY_FN) ||
		 (typ->type == SUBTILIS_TYPE_VECTOR_FN))
		prv_fn_type_free(&typ->params.array.params.fn);
	else if ((typ->type == SUBTILIS_TYPE_ARRAY_REC) ||
		 (typ->type == SUBTILIS_TYPE_VECTOR_REC))
		prv_rec_type_free(&typ->params.array.params.rec);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x9, (%rax)
jne 0x3e124
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x3e3e0
jmp 0x3e18a
movq -0x8(%rbp), %rax
cmpl $0x16, (%rax)
jne 0x3e13c
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x3e460
jmp 0x3e188
movq -0x8(%rbp), %rax
cmpl $0xe, (%rax)
je 0x3e14e
movq -0x8(%rbp), %rax
cmpl $0x14, (%rax)
jne 0x3e161
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
addq $0x30, %rdi
callq 0x3e3e0
jmp 0x3e186
movq -0x8(%rbp), %rax
cmpl $0xf, (%rax)
je 0x3e173
movq -0x8(%rbp), %rax
cmpl $0x15, (%rax)
jne 0x3e184
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
addq $0x30, %rdi
callq 0x3e460
jmp 0x3e186
jmp 0x3e188
jmp 0x3e18a
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/type.c
// Function: subtilis_type_name
const char *subtilis_type_name(const subtilis_type_t *typ)
{
	size_t index;

	if (typ->type == SUBTILIS_TYPE_REC)
		return typ->params.rec.name;

	index = (size_t)typ->type;

	if (index < SUBTILIS_TYPE_MAX)
		return prv_fixed_type_names[index];

	return "unknown";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x16, (%rax)
jne 0x3e1af
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x3e1e0
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x18(%rbp)
cmpq $0x19, -0x18(%rbp)
jae 0x3e1d5
movq -0x18(%rbp), %rcx
leaq 0x8d495(%rip), %rax     # 0xcb660
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x3e1e0
leaq 0x6deb2(%rip), %rax     # 0xac08e
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/type.c
// Function: subtilis_full_type_name
void subtilis_full_type_name(const subtilis_type_t *typ, subtilis_buffer_t *buf,
			     subtilis_error_t *err)
{
	prv_full_type_name(typ, buf, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	subtilis_buffer_zero_terminate(buf, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3e240
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x3e220
jmp 0x3e22d
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x16560
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/type.c
// Function: prv_fn_type_free
static void prv_fn_type_free(subtilis_type_fn_t *typ)
{
	size_t i;

	subtilis_type_free(typ->ret_val);
	free(typ->ret_val);
	for (i = 0; i < typ->num_params; i++) {
		subtilis_type_free(typ->params[i]);
		free(typ->params[i]);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x3e100
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x12290
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x3e44c
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rax,%rcx,8), %rdi
callq 0x3e100
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rax,%rcx,8), %rdi
callq 0x12290
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x3e40c
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/type.c
// Function: prv_rec_type_free
static void prv_rec_type_free(subtilis_type_rec_t *typ)
{
	size_t i;

	free(typ->name);
	for (i = 0; i < typ->num_fields; i++) {
		free(typ->fields[i].name);
		subtilis_type_free(&typ->field_types[i]);
	}
	free(typ->fields);
	free(typ->field_types);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x12290
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jae 0x3e4cd
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
imulq $0x18, -0x10(%rbp), %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x12290
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
imulq $0x148, -0x10(%rbp), %rax # imm = 0x148
addq %rax, %rdi
callq 0x3e100
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x3e481
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x12290
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x12290
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/type.c
// Function: prv_init_copy_fn
static void prv_init_copy_fn(subtilis_type_fn_t *dst,
			     const subtilis_type_fn_t *src,
			     subtilis_error_t *err)
{
	size_t i;

	dst->ret_val = calloc(1, sizeof(*dst->ret_val));
	if (!dst->ret_val) {
		subtilis_error_set_oom(err);
		return;
	}
	dst->num_params = 0;
	subtilis_type_init_copy(dst->ret_val, src->ret_val, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;
	for (i = 0; i < src->num_params; i++) {
		dst->params[i] = calloc(1, sizeof(*dst->params[i]));
		if (!dst->params[i]) {
			subtilis_error_set_oom(err);
			goto cleanup;
		}
		subtilis_type_init_copy(dst->params[i], src->params[i], err);
		dst->num_params++;
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;
	}
	return;

cleanup:
	prv_fn_type_free(dst);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x1, %edi
movl $0x148, %esi            # imm = 0x148
callq 0x12130
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x3e586
movq -0x18(%rbp), %rdi
movl $0x1, %esi
leaq 0x6db09(%rip), %rdx     # 0xac080
movl $0x1ca, %ecx            # imm = 0x1CA
callq 0x158e0
jmp 0x3e678
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x3dec0
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x3e5b7
jmp 0x3e66f
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x3e66d
movl $0x1, %edi
movl $0x148, %esi            # imm = 0x148
callq 0x12130
movq %rax, %rdx
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rdx, 0x10(%rax,%rcx,8)
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq $0x0, 0x10(%rax,%rcx,8)
jne 0x3e61c
movq -0x18(%rbp), %rdi
movl $0x1, %esi
leaq 0x6da70(%rip), %rdx     # 0xac080
movl $0x1d4, %ecx            # imm = 0x1D4
callq 0x158e0
jmp 0x3e66f
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x10(%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x10(%rax,%rcx,8), %rsi
movq -0x18(%rbp), %rdx
callq 0x3dec0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x3e65a
jmp 0x3e66f
jmp 0x3e65c
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x3e5bf
jmp 0x3e678
movq -0x8(%rbp), %rdi
callq 0x3e3e0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/type.c
// Function: subtilis_type_init_rec
void subtilis_type_init_rec(subtilis_type_t *dst, const char *name,
			    subtilis_error_t *err)
{
	dst->type = SUBTILIS_TYPE_REC;
	dst->params.rec.alignment = 1;
	dst->params.rec.num_fields = 0;
	dst->params.rec.max_fields = 0;
	dst->params.rec.field_types = NULL;
	dst->params.rec.fields = NULL;
	dst->params.rec.name = malloc(strlen(name) + 1);
	if (!dst->params.rec.name) {
		subtilis_error_set_oom(err);
		return;
	}
	strcpy(dst->params.rec.name, name);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl $0x16, (%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rdi
callq 0x120d0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x121b0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x3ec60
movq -0x18(%rbp), %rdi
movl $0x1, %esi
leaq 0x6d42c(%rip), %rdx     # 0xac080
movl $0x28a, %ecx            # imm = 0x28A
callq 0x158e0
jmp 0x3ec71
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x12060
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/type.c
// Function: subtilis_type_rec_find_field
size_t subtilis_type_rec_find_field(const subtilis_type_rec_t *rec,
				    const char *fname)
{
	size_t i;

	for (i = 0; i < rec->num_fields; i++) {
		if (!strcmp(rec->fields[i].name, fname))
			return i;
	}

	return SIZE_MAX;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jae 0x3ece1
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
imulq $0x18, -0x20(%rbp), %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x12140
cmpl $0x0, %eax
jne 0x3ecd1
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3ece9
jmp 0x3ecd3
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x3ec98
movq $-0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/type.c
// Function: subtilis_type_rec_field_offset_id
uint32_t subtilis_type_rec_field_offset_id(const subtilis_type_rec_t *rec,
					   size_t id)
{
	size_t i;
	uint32_t align;
	uint32_t adjust;
	uint32_t offset = 0;

	for (i = 0; i < id; i++) {
		align = rec->fields[i].alignment;
		adjust = offset & (align - 1);
		if (adjust != 0)
			offset += align - adjust;
		offset += rec->fields[i].size;
	}
	align = rec->fields[i].alignment;
	adjust = offset & (align - 1);
	if (adjust != 0)
		offset += align - adjust;

	return offset;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x24(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x3f032
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
imulq $0x18, -0x18(%rbp), %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x24(%rbp), %eax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
andl %ecx, %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0x3f00b
movl -0x1c(%rbp), %eax
subl -0x20(%rbp), %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
imulq $0x18, -0x18(%rbp), %rcx
addq %rcx, %rax
movl 0xc(%rax), %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x3efcb
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
imulq $0x18, -0x18(%rbp), %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x24(%rbp), %eax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
andl %ecx, %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0x3f068
movl -0x1c(%rbp), %eax
subl -0x20(%rbp), %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/type.c
// Function: subtilis_type_rec_field_offset
uint32_t subtilis_type_rec_field_offset(subtilis_type_t *typ, const char *name)
{
	subtilis_type_rec_t *rec = &typ->params.rec;
	size_t id = subtilis_type_rec_find_field(rec, name);

	if (id == SIZE_MAX)
		return UINT32_MAX;

	return subtilis_type_rec_field_offset_id(rec, id);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3ec80
movq %rax, -0x28(%rbp)
cmpq $-0x1, -0x28(%rbp)
jne 0x3f0ad
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3f0bd
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x3efb0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/type.c
// Function: subtilis_type_rec_size
size_t subtilis_type_rec_size(const subtilis_type_t *typ)
{
	size_t id;
	const subtilis_type_rec_t *rec = &typ->params.rec;

	if (rec->num_fields == 0)
		return 0;

	id = rec->num_fields - 1;
	return subtilis_type_rec_field_offset_id(rec, id) +
	       rec->fields[id].size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x3f0fd
movq $0x0, -0x8(%rbp)
jmp 0x3f133
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
subq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3efb0
movq -0x20(%rbp), %rcx
movq 0x18(%rcx), %rcx
imulq $0x18, -0x18(%rbp), %rdx
addq %rdx, %rcx
addl 0xc(%rcx), %eax
movl %eax, %eax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/type.c
// Function: subtilis_type_rec_is_scalar
bool subtilis_type_rec_is_scalar(const subtilis_type_t *typ)
{
	subtilis_type_t *field;
	size_t i;
	const subtilis_type_rec_t *rec = &typ->params.rec;

	for (i = 0; i < rec->num_fields; i++) {
		field = &rec->field_types[i];
		switch (field->type) {
		case SUBTILIS_TYPE_REAL:
		case SUBTILIS_TYPE_INTEGER:
		case SUBTILIS_TYPE_BYTE:
		case SUBTILIS_TYPE_FN:
		case SUBTILIS_TYPE_LOCAL_BUFFER:
			continue;
		case SUBTILIS_TYPE_REC:
			if (subtilis_type_rec_is_scalar(field))
				continue;
			break;
		default:
			break;
		}
		return false;
	}

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jae 0x3f207
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
imulq $0x148, %rcx, %rcx      # imm = 0x148
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
addl $-0x4, %eax
subl $0x3, %eax
jb 0x3f1d9
jmp 0x3f1bb
movl -0x2c(%rbp), %eax
subl $0x9, %eax
je 0x3f1d9
jmp 0x3f1c5
movl -0x2c(%rbp), %eax
subl $0x16, %eax
je 0x3f1db
jmp 0x3f1cf
movl -0x2c(%rbp), %eax
subl $0x17, %eax
jne 0x3f1ee
jmp 0x3f1d9
jmp 0x3f1f6
movq -0x18(%rbp), %rdi
callq 0x3f160
testb $0x1, %al
jne 0x3f1ea
jmp 0x3f1ec
jmp 0x3f1f6
jmp 0x3f1f0
jmp 0x3f1f0
movb $0x0, -0x1(%rbp)
jmp 0x3f20b
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x3f180
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/type.c
// Function: subtilis_type_rec_serializable
bool subtilis_type_rec_serializable(const subtilis_type_t *typ)
{
	subtilis_type_t *field;
	size_t i;
	const subtilis_type_rec_t *rec = &typ->params.rec;

	for (i = 0; i < rec->num_fields; i++) {
		field = &rec->field_types[i];
		switch (field->type) {
		case SUBTILIS_TYPE_REAL:
		case SUBTILIS_TYPE_INTEGER:
		case SUBTILIS_TYPE_BYTE:
		case SUBTILIS_TYPE_LOCAL_BUFFER:
			continue;
		case SUBTILIS_TYPE_REC:
			if (subtilis_type_rec_serializable(field))
				continue;
			break;
		default:
			break;
		}
		return false;
	}

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jae 0x3f2ba
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
imulq $0x148, %rcx, %rcx      # imm = 0x148
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
addl $-0x4, %eax
subl $0x3, %eax
jb 0x3f28f
jmp 0x3f27b
movl -0x2c(%rbp), %eax
subl $0x16, %eax
je 0x3f291
jmp 0x3f285
movl -0x2c(%rbp), %eax
subl $0x17, %eax
jne 0x3f2a4
jmp 0x3f28f
jmp 0x3f2ac
movq -0x18(%rbp), %rdi
callq 0x3f220
testb $0x1, %al
jne 0x3f2a0
jmp 0x3f2a2
jmp 0x3f2ac
jmp 0x3f2a6
jmp 0x3f2a6
movb $0x0, -0x1(%rbp)
jmp 0x3f2be
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x3f240
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/type.c
// Function: subtilis_type_rec_can_zero_fill
bool subtilis_type_rec_can_zero_fill(const subtilis_type_t *typ)
{
	subtilis_type_t *field;
	size_t i;
	const subtilis_type_rec_t *rec = &typ->params.rec;

	for (i = 0; i < rec->num_fields; i++) {
		field = &rec->field_types[i];
		switch (field->type) {
		case SUBTILIS_TYPE_REAL:
		case SUBTILIS_TYPE_INTEGER:
		case SUBTILIS_TYPE_BYTE:
		case SUBTILIS_TYPE_STRING:
		case SUBTILIS_TYPE_LOCAL_BUFFER:
			break;
		case SUBTILIS_TYPE_REC:
			if (!subtilis_type_rec_can_zero_fill(field))
				return false;
			break;
		default:
			return false;
		}
	}

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jae 0x3f36c
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
imulq $0x148, %rcx, %rcx      # imm = 0x148
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
addl $-0x4, %eax
subl $0x4, %eax
jb 0x3f33f
jmp 0x3f32b
movl -0x2c(%rbp), %eax
subl $0x16, %eax
je 0x3f341
jmp 0x3f335
movl -0x2c(%rbp), %eax
subl $0x17, %eax
jne 0x3f356
jmp 0x3f33f
jmp 0x3f35c
movq -0x18(%rbp), %rdi
callq 0x3f2d0
testb $0x1, %al
jne 0x3f354
movb $0x0, -0x1(%rbp)
jmp 0x3f370
jmp 0x3f35c
movb $0x0, -0x1(%rbp)
jmp 0x3f370
jmp 0x3f35e
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x3f2f0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/type.c
// Function: subtilis_type_rec_zero_fill_size
size_t subtilis_type_rec_zero_fill_size(const subtilis_type_t *typ)
{
	subtilis_type_t *field;
	size_t i;
	size_t size = 0;
	const subtilis_type_rec_t *rec = &typ->params.rec;

	for (i = 0; i < rec->num_fields; i++) {
		field = &rec->field_types[i];
		switch (field->type) {
		case SUBTILIS_TYPE_REAL:
		case SUBTILIS_TYPE_INTEGER:
		case SUBTILIS_TYPE_BYTE:
		case SUBTILIS_TYPE_STRING:
		case SUBTILIS_TYPE_LOCAL_BUFFER:
			size += rec->fields[i].size;
			break;
		case SUBTILIS_TYPE_REC:
			size += subtilis_type_rec_zero_fill_size(field);
			break;
		default:
			break;
		}
	}

	return size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jae 0x3f440
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
imulq $0x148, %rcx, %rcx      # imm = 0x148
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
addl $-0x4, %eax
subl $0x4, %eax
jb 0x3f3fb
jmp 0x3f3e7
movl -0x2c(%rbp), %eax
subl $0x16, %eax
je 0x3f418
jmp 0x3f3f1
movl -0x2c(%rbp), %eax
subl $0x17, %eax
jne 0x3f42b
jmp 0x3f3fb
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
imulq $0x18, -0x18(%rbp), %rcx
addq %rcx, %rax
movl 0xc(%rax), %eax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x3f42d
movq -0x10(%rbp), %rdi
callq 0x3f380
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x3f42d
jmp 0x3f42d
jmp 0x3f42f
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x3f3a8
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)