LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/MaoKo[P]FGFX/fgfp/src/lr.c
// Function: new_lr1_item_lr0
static lr1_item_t*
new_lr1_item_lr0(lr0_item_t* lr0_item, bitset_t const* lookahead) {
	if (!lr0_item)
		{ return (NULL); }
	if (!record_lr1_item)
		{ record_lr1_item = new_vector(); }
	lr1_item_t* item = NEW(lr1_item_t, 1);
	if (!item)
		{ return (NULL); }
	memset(item, 0, sizeof(lr1_item_t));
	item->lookahead = dup_bitset(lookahead);
	item->core = lr0_item;
	return (item);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x7f4e
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x14f92(%rip)     # 0x1cea0
jne 0x7f1c
callq 0x2aec
movq %rax, 0x14f84(%rip)     # 0x1cea0
movl $0x18, %edi
callq 0x3a0e
testq %rax, %rax
je 0x7f4e
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %r14, %rdi
callq 0x24b4
movq %rax, 0x10(%r15)
movq %rbx, 0x8(%r15)
jmp 0x7f51
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/MaoKo[P]FGFX/fgfp/src/lr.c
// Function: compute_look
static bitset_t*
compute_look(lr0_item_t const* item, bitset_t* before) {
	bitset_t* target_first = first_list_rhs_t(DOT(item)->next);
	if (target_first == NULL_BITSET)
		{ target_first = dup_bitset(before); }
	else if (list_is_nullable(DOT(item)->next))
		{ UNION_BITSET(target_first, before); }
	return (target_first);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movq 0x8(%rdi), %rax
movq (%rax), %rdi
callq 0x5aec
testq %rax, %rax
je 0x7fce
movq %rax, %r14
movq 0x8(%r15), %rax
movq (%rax), %rdi
callq 0x5a8e
testb %al, %al
je 0x7fc0
xorl %edi, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x27b4
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x24b4
// File: /workspace/github_c_makefile_star2_O3/MaoKo[P]FGFX/fgfp/src/lr.c
// Function: propagate_look_lr1_symbol
static bool
propagate_look_lr1_symbol(kernel_t* kernel, vector_t* vect_look,
							symbol_t* symbol, bitset_t* base_look) {
	bool change = false;
	for (size_t i = 0; i < SIZE_VECTOR(kernel->non_lr0_kernel_item); ++i) {
		bitset_t* crt_look = (bitset_t*)AT_VECTOR(vect_look, i);
		lr0_item_t const* crt_item = (lr0_item_t const*)
								AT_VECTOR(kernel->non_lr0_kernel_item, i);

		if (LHS(PROD(crt_item)) == symbol) {
			if (!is_subset_bitset(crt_look, base_look))
				{ change = true; }
			UNION_BITSET(crt_look, base_look);
		}
	}
	return (change);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, -0x30(%rbp)
movq 0x18(%rdi), %rax
cmpq $0x0, 0x10(%rax)
je 0x805b
movq %rcx, %rbx
movq %rdx, %r15
xorl %r14d, %r14d
xorl %r13d, %r13d
movq (%rax), %rcx
movq (%rcx,%r13,8), %rcx
movq (%rcx), %rcx
cmpq %r15, 0x8(%rcx)
jne 0x8050
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq (%rax,%r13,8), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x2979
xorb $0x1, %al
orb %al, %r14b
xorl %edi, %edi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x27b4
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
incq %r13
cmpq 0x10(%rax), %r13
jb 0x8010
jmp 0x805e
xorl %r14d, %r14d
andb $0x1, %r14b
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/MaoKo[P]FGFX/fgfp/src/gen_ll.c
// Function: gen_ll_useful_macro
void
gen_ll_useful_macro(int filde, cfg_t const* cfg) {
	dprintf(filde, DEFINE(ERROR_SLOT, 0) NL);
	dprintf(filde, DEFINE(START_SYMBOL,));
	production_t* start_prod = BACK_VECTOR(cfg->productions);
	gen_nter_symbol(filde, cfg,
			start_prod->rhs_element->symbol_rhs->index, true);
	dprintf(filde, NL NL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movl %edi, %ebx
leaq 0x27e4(%rip), %rsi      # 0xa86b
xorl %eax, %eax
callq 0x20f0
leaq 0x27ec(%rip), %rsi      # 0xa881
movl %ebx, %edi
xorl %eax, %eax
callq 0x20f0
movq (%r14), %rax
movq (%rax), %rcx
movq 0x10(%rax), %rax
movq -0x8(%rcx,%rax,8), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %rdx
movl %ebx, %edi
movq %r14, %rsi
movl $0x1, %ecx
callq 0x8637
leaq 0x28bc(%rip), %rsi      # 0xa98a
movl %ebx, %edi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x20f0
// File: /workspace/github_c_makefile_star2_O3/MaoKo[P]FGFX/fgfp/src/gen_ll.c
// Function: gen_ll_table
void
gen_ll_table(int filde, cfg_t const* cfg,
				vector_t const* ll_table, char const* header) {
	dprintf(filde, STATIC SP INT NL);
	gen_verbatim_file(filde, header);
	dprintf(filde, "_ll_table[" MACRO_NTER "]["
				MACRO_TOKEN "] = " BEG_BLOCK NL);

	for (size_t i = 0; i < SIZE_VECTOR(ll_table); ++i) {
		trans_list_t* list = AT_VECTOR(ll_table, i);
		if (list)
			{ dprintf(filde, TAB); }
		while (list) {
			dprintf(filde, "[");
			gen_nter_symbol(filde, cfg, i, true);
			dprintf(filde, "][" TOKEN_PREFIX SEP "%s]=", ((symbol_t*)
				AT_VECTOR(cfg->terminal, list->input))->name);
			gen_nproduction(filde, cfg, list->state);
			dprintf(filde, COMMA SP);
			list = list->next;
		}
		write(filde, NL, 1);
	}
	dprintf(filde, END_BLOCK SEMI NL NL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r15
movl %edi, %ebx
leaq 0x279c(%rip), %rsi      # 0xa897
xorl %eax, %eax
callq 0x20f0
movl %ebx, %edi
movq %r14, %rsi
callq 0x3eaa
leaq 0x2790(%rip), %rsi      # 0xa8a3
movl %ebx, %edi
xorl %eax, %eax
callq 0x20f0
cmpq $0x0, 0x10(%r12)
je 0x81e2
xorl %r13d, %r13d
movq %r12, -0x30(%rbp)
movq (%r12), %rax
movq (%rax,%r13,8), %r12
testq %r12, %r12
leaq 0x2a15(%rip), %r14      # 0xab56
je 0x81bd
movl %ebx, %edi
leaq 0x2749(%rip), %rsi      # 0xa895
xorl %eax, %eax
callq 0x20f0
movl %ebx, %edi
leaq 0x29ab(%rip), %rsi      # 0xab07
xorl %eax, %eax
callq 0x20f0
movl %ebx, %edi
movq %r15, %rsi
movq %r13, %rdx
movl $0x1, %ecx
callq 0x8637
movq 0x10(%r15), %rax
movq (%rax), %rax
movslq 0x8(%r12), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rdx
movl %ebx, %edi
leaq 0x2739(%rip), %rsi      # 0xa8cb
xorl %eax, %eax
callq 0x20f0
movslq 0xc(%r12), %rdx
movl %ebx, %edi
movq %r15, %rsi
callq 0x8834
movl %ebx, %edi
movq %r14, %rsi
xorl %eax, %eax
callq 0x20f0
movq (%r12), %r12
testq %r12, %r12
jne 0x8153
movl $0x1, %edx
movl %ebx, %edi
leaq 0x288d(%rip), %rsi      # 0xaa58
callq 0x2080
incq %r13
movq -0x30(%rbp), %r12
cmpq 0x10(%r12), %r13
jb 0x812f
leaq 0x26eb(%rip), %rsi      # 0xa8d4
movl %ebx, %edi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20f0
// File: /workspace/github_c_makefile_star2_O3/MaoKo[P]FGFX/fgfp/src/gen_lr.c
// Function: gen_action_enum
void
gen_action_enum(int filde) {
	dprintf(filde, ENUM SP BEG_BLOCK NL);
	dprintf(filde, TAB "_SHIFT"  TAB "= 0x1000" COMMA NL);
	dprintf(filde, TAB "_REDUCE" TAB "= 0x2000" COMMA NL);
	dprintf(filde, TAB "_GOTO"   TAB "= 0x4000" COMMA NL);
	dprintf(filde, END_BLOCK SEMI NL NL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x26ca(%rip), %rsi      # 0xa8d9
xorl %eax, %eax
callq 0x20f0
leaq 0x26c4(%rip), %rsi      # 0xa8e1
movl %ebx, %edi
xorl %eax, %eax
callq 0x20f0
leaq 0x26c7(%rip), %rsi      # 0xa8f4
movl %ebx, %edi
xorl %eax, %eax
callq 0x20f0
leaq 0x26cb(%rip), %rsi      # 0xa908
movl %ebx, %edi
xorl %eax, %eax
callq 0x20f0
leaq 0x2687(%rip), %rsi      # 0xa8d4
movl %ebx, %edi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x20f0
// File: /workspace/github_c_makefile_star2_O3/MaoKo[P]FGFX/fgfp/src/gen_lr.c
// Function: gen_lr_useful_macro
void
gen_lr_useful_macro(int filde) {
	dprintf(filde, DEFINE(SHIFT(x),(x | _SHIFT)) NL);
	dprintf(filde, DEFINE(REDUCE(x),(x | _REDUCE)) NL);
	dprintf(filde, DEFINE(GOTO(x),(x | _GOTO)) NL);
	dprintf(filde, DEFINE(ACCEPT, (~0)) NL NL);
	dprintf(filde, DEFINE(LR_START_STATE, 0) NL NL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x26af(%rip), %rsi      # 0xa91a
xorl %eax, %eax
callq 0x20f0
leaq 0x26c0(%rip), %rsi      # 0xa939
movl %ebx, %edi
xorl %eax, %eax
callq 0x20f0
leaq 0x26d1(%rip), %rsi      # 0xa95a
movl %ebx, %edi
xorl %eax, %eax
callq 0x20f0
leaq 0x26de(%rip), %rsi      # 0xa977
movl %ebx, %edi
xorl %eax, %eax
callq 0x20f0
leaq 0x26e4(%rip), %rsi      # 0xa98d
movl %ebx, %edi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x20f0
// File: /workspace/github_c_makefile_star2_O3/MaoKo[P]FGFX/fgfp/src/gen_lr.c
// Function: gen_goto_table
void
gen_goto_table(int filde, cfg_t const* cfg,
							vector_t const* lr1_states, char const* header) {

	dprintf(filde, STATIC SP INT NL);
	gen_verbatim_file(filde, header);

	dprintf(filde, "_lr_goto_table[%zu][" MACRO_NTER "] = " BEG_BLOCK NL,
			SIZE_VECTOR(lr1_states));

	for (size_t i = 0; i < SIZE_VECTOR(lr1_states); ++i) {
		lr1_state_t* state = (lr1_state_t*)AT_VECTOR(lr1_states, i);
		dprintf(filde, "/* %3zu */" TAB BEG_BLOCK, i);
		trans_list_t* action = state->goto_lst;
		while (action) {
			dprintf(filde, "[");
			gen_nter_symbol(filde, cfg, action->input ^ _GOTO, true);
			dprintf(filde, "]=" GOTO_STR "(%d)", action->state);

			if (action->next)
				{ dprintf(filde, COMMA SP); }
			action = action->next;
		}
		dprintf(filde, END_BLOCK COMMA NL);
	}
	dprintf(filde, END_BLOCK SEMI NL NL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r15
movl %edi, %ebx
leaq 0x23cc(%rip), %rsi      # 0xa897
xorl %eax, %eax
callq 0x20f0
movl %ebx, %edi
movq %r14, %rsi
callq 0x3eaa
movq 0x10(%r12), %rdx
leaq 0x2525(%rip), %rsi      # 0xaa0d
movl %ebx, %edi
xorl %eax, %eax
callq 0x20f0
cmpq $0x0, 0x10(%r12)
je 0x85ab
leaq 0x252e(%rip), %r13      # 0xaa32
xorl %r14d, %r14d
movq %r12, -0x30(%rbp)
movq (%r12), %rax
movq (%rax,%r14,8), %r12
movl %ebx, %edi
leaq 0x24b4(%rip), %rsi      # 0xa9d0
movq %r14, %rdx
xorl %eax, %eax
callq 0x20f0
movq 0x18(%r12), %r12
testq %r12, %r12
je 0x8589
movl %ebx, %edi
leaq 0x25ce(%rip), %rsi      # 0xab07
xorl %eax, %eax
callq 0x20f0
movslq 0x8(%r12), %rdx
xorq $0x2000, %rdx           # imm = 0x2000
movl %ebx, %edi
movq %r15, %rsi
movl $0x1, %ecx
callq 0x8637
movl 0xc(%r12), %edx
movl %ebx, %edi
movq %r13, %rsi
xorl %eax, %eax
callq 0x20f0
cmpq $0x0, (%r12)
je 0x8589
movl %ebx, %edi
leaq 0x25da(%rip), %rsi      # 0xab56
xorl %eax, %eax
callq 0x20f0
movq (%r12), %r12
jmp 0x852b
movl %ebx, %edi
leaq 0x25ca(%rip), %rsi      # 0xab5c
xorl %eax, %eax
callq 0x20f0
incq %r14
movq -0x30(%rbp), %r12
cmpq 0x10(%r12), %r14
jb 0x850b
leaq 0x2322(%rip), %rsi      # 0xa8d4
movl %ebx, %edi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20f0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/MaoKo[P]FGFX/fgfp/src/gen_cfg.c
// Function: gen_location_token
void
gen_location_token(int filde, cfg_t const* cfg) {
	dprintf(filde, DEFINE(_ONLY_STATE_TOKEN_,) NL);
	for (size_t i = 0; i < SIZE_VECTOR(cfg->token_file); ++i) {
		dprintf(filde, INCLUDE(%s) NL, (char const*)
								AT_VECTOR(cfg->token_file, i));
	}
	dprintf(filde, UNDEF(_ONLY_STATE_TOKEN_) NL NL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movl %edi, %ebx
leaq 0x245a(%rip), %rsi      # 0xaa3d
xorl %eax, %eax
callq 0x20f0
movq 0x18(%r14), %rax
cmpq $0x0, 0x10(%rax)
je 0x861f
leaq 0x245e(%rip), %r15      # 0xaa5a
xorl %r12d, %r12d
movq (%rax), %rax
movq (%rax,%r12,8), %rdx
movl %ebx, %edi
movq %r15, %rsi
xorl %eax, %eax
callq 0x20f0
incq %r12
movq 0x18(%r14), %rax
cmpq 0x10(%rax), %r12
jb 0x85ff
leaq 0x2443(%rip), %rsi      # 0xaa69
movl %ebx, %edi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x20f0
// File: /workspace/github_c_makefile_star2_O3/MaoKo[P]FGFX/fgfp/src/gen_cfg.c
// Function: gen_nter_symbol
void
gen_nter_symbol(int filde, cfg_t const* cfg, size_t index, bool sep) {
	vector_t const* nter = cfg->non_terminal;
	symbol_t* symbol = (symbol_t*)AT_VECTOR(nter, index);

	size_t depth = 0;
	size_t spec_nth = 0;

	if (symbol->special) {
		dprintf(filde, ((symbol->spec_kind == OPT) ? OPT_STR : LST_STR));
		if (sep)
			{ dprintf(filde, SEP); }
		
		depth = symbol->depth;
		spec_nth = symbol->spec_nth;

		symbol = symbol->special;
	}

	dprintf(filde, NTER_PREFIX);
	if (sep)
		{ dprintf(filde, SEP); }

	size_t len = strlen(symbol->name) - 1;
	for (size_t i = 1; i < len; ++i) {
		if (symbol->name[i] == '\'')
			{ dprintf(filde, PRIME_STR); }
		else
			{ write(filde, symbol->name + i, 1); }
	}
	if (depth)
		{ dprintf(filde, SEP "%zu" SEP "%zu", spec_nth, depth); }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %r12d
movl %edi, %ebx
movq 0x8(%rsi), %rax
movq (%rax), %rax
movq (%rax,%rdx,8), %r13
cmpq $0x0, 0x40(%r13)
je 0x86aa
cmpl $0x0, 0x38(%r13)
leaq 0x241a(%rip), %rax      # 0xaa85
leaq 0x2417(%rip), %rsi      # 0xaa89
cmoveq %rax, %rsi
movl %ebx, %edi
xorl %eax, %eax
callq 0x20f0
testb %r12b, %r12b
je 0x8694
leaq 0x18bb(%rip), %rsi      # 0x9f46
movl %ebx, %edi
xorl %eax, %eax
callq 0x20f0
movq 0x48(%r13), %rax
movq %rax, -0x38(%rbp)
movq 0x50(%r13), %rax
movq %rax, -0x30(%rbp)
movq 0x40(%r13), %r13
jmp 0x86ba
movq $0x0, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
leaq 0x15e2(%rip), %rsi      # 0x9ca3
movl %ebx, %edi
xorl %eax, %eax
callq 0x20f0
testb %r12b, %r12b
je 0x86df
leaq 0x1870(%rip), %rsi      # 0x9f46
movl %ebx, %edi
xorl %eax, %eax
callq 0x20f0
movq 0x10(%r13), %rdi
callq 0x2090
leaq -0x1(%rax), %rcx
cmpq $0x2, %rcx
jb 0x8740
movl $0x2, %r15d
subq %rax, %r15
movl $0x1, %r14d
leaq 0x2385(%rip), %r12      # 0xaa8d
movq 0x10(%r13), %rsi
cmpb $0x27, (%rsi,%r14)
jne 0x8721
movl %ebx, %edi
movq %r12, %rsi
xorl %eax, %eax
callq 0x20f0
jmp 0x8730
addq %r14, %rsi
movl $0x1, %edx
movl %ebx, %edi
callq 0x2080
leaq (%r15,%r14), %rax
incq %rax
incq %r14
cmpq $0x1, %rax
jne 0x8708
movq -0x38(%rbp), %rcx
testq %rcx, %rcx
je 0x876b
leaq 0x2344(%rip), %rsi      # 0xaa94
movl %ebx, %edi
movq -0x30(%rbp), %rdx
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20f0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/MaoKo[P]FGFX/fgfp/src/gen_cfg.c
// Function: gen_non_terminal_enum
void
gen_non_terminal_enum(int filde, cfg_t const* cfg) {
	dprintf(filde, ENUM SP BEG_BLOCK NL);
	for (size_t i = 0; i < SIZE_VECTOR(cfg->non_terminal) - 1; ++i) {
		dprintf(filde, TAB);
		gen_nter_symbol(filde, cfg, i, true);
		dprintf(filde, COMMA NL);
	}
	dprintf(filde, END_BLOCK SEMI NL NL);
	dprintf(filde, DEFINE(%s, %zu) NL NL,
					MACRO_NTER, SIZE_VECTOR(cfg->non_terminal) - 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movl %edi, %ebx
leaq 0x2145(%rip), %rsi      # 0xa8d9
xorl %eax, %eax
callq 0x20f0
movq 0x8(%r14), %rax
cmpq $0x1, 0x10(%rax)
je 0x87f4
leaq 0x20e8(%rip), %r15      # 0xa895
leaq 0x213d(%rip), %r12      # 0xa8f1
xorl %r13d, %r13d
movl %ebx, %edi
movq %r15, %rsi
xorl %eax, %eax
callq 0x20f0
movl %ebx, %edi
movq %r14, %rsi
movq %r13, %rdx
movl $0x1, %ecx
callq 0x8637
movl %ebx, %edi
movq %r12, %rsi
xorl %eax, %eax
callq 0x20f0
incq %r13
movq 0x8(%r14), %rax
movq 0x10(%rax), %rax
decq %rax
cmpq %rax, %r13
jb 0x87b7
leaq 0x20d9(%rip), %rsi      # 0xa8d4
movl %ebx, %edi
xorl %eax, %eax
callq 0x20f0
movq 0x8(%r14), %rax
movq 0x10(%rax), %rcx
decq %rcx
leaq 0x2287(%rip), %rsi      # 0xaa9d
leaq 0x2291(%rip), %rdx      # 0xaaae
movl %ebx, %edi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20f0
// File: /workspace/github_c_makefile_star2_O3/MaoKo[P]FGFX/fgfp/src/gen_cfg.c
// Function: gen_nproduction
void
gen_nproduction(int filde, cfg_t const* cfg, size_t index) {
	dprintf(filde, PROD_PREFIX SEP LHS_STR SEP);

	production_t* prod = (production_t*)AT_VECTOR(cfg->productions, index);
	gen_nter_symbol(filde, cfg, prod->symbol_lhs->index, false);

	dprintf(filde, SEP RHS_STR);
	list_rhs_t* list = prod->rhs_element;
	while (list) {
		dprintf(filde, SEP);
		if (IS_TERMINAL(list->symbol_rhs))
			{ dprintf(filde, TOKEN_PREFIX "%s", list->symbol_rhs->name); }
		else
			{ gen_nter_symbol(filde, cfg, list->symbol_rhs->index, false); }
		list = list->next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movl %edi, %r14d
leaq 0x2267(%rip), %rsi      # 0xaab9
xorl %eax, %eax
callq 0x20f0
movq (%rbx), %rax
movq (%rax), %rax
movq (%rax,%r15,8), %r15
movq 0x8(%r15), %rax
movq (%rax), %rdx
movl %r14d, %edi
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0x8637
leaq 0x2242(%rip), %rsi      # 0xaac0
movl %r14d, %edi
xorl %eax, %eax
callq 0x20f0
movq 0x10(%r15), %r13
testq %r13, %r13
je 0x88e2
leaq 0x16ae(%rip), %r15      # 0x9f46
leaq 0x2226(%rip), %r12      # 0xaac5
movl %r14d, %edi
movq %r15, %rsi
xorl %eax, %eax
callq 0x20f0
movq 0x8(%r13), %rax
cmpl $0x2d, 0x8(%rax)
jne 0x88c9
movq 0x10(%rax), %rdx
movl %r14d, %edi
movq %r12, %rsi
xorl %eax, %eax
callq 0x20f0
jmp 0x88d9
movq (%rax), %rdx
movl %r14d, %edi
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0x8637
movq (%r13), %r13
testq %r13, %r13
jne 0x889f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/MaoKo[P]FGFX/fgfp/src/gen_cfg.c
// Function: gen_production_enum
void
gen_production_enum(int filde, cfg_t const* cfg) {
	dprintf(filde, ENUM SP BEG_BLOCK NL);
	for (size_t i = 0; i < SIZE_VECTOR(cfg->productions) - 1; ++i) {
		dprintf(filde, TAB);
		gen_nproduction(filde, cfg, i);
		dprintf(filde, COMMA NL);
	}
	dprintf(filde, END_BLOCK SEMI NL NL);
	dprintf(filde, DEFINE(TOTAL_PROD, %zu) NL NL,
										SIZE_VECTOR(cfg->productions));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movl %edi, %ebx
leaq 0x1fce(%rip), %rsi      # 0xa8d9
xorl %eax, %eax
callq 0x20f0
movq (%r14), %rax
cmpq $0x1, 0x10(%rax)
je 0x8964
leaq 0x1f72(%rip), %r15      # 0xa895
leaq 0x1fc7(%rip), %r12      # 0xa8f1
xorl %r13d, %r13d
movl %ebx, %edi
movq %r15, %rsi
xorl %eax, %eax
callq 0x20f0
movl %ebx, %edi
movq %r14, %rsi
movq %r13, %rdx
callq 0x8834
movl %ebx, %edi
movq %r12, %rsi
xorl %eax, %eax
callq 0x20f0
incq %r13
movq (%r14), %rax
movq 0x10(%rax), %rax
decq %rax
cmpq %rax, %r13
jb 0x892d
leaq 0x1f69(%rip), %rsi      # 0xa8d4
movl %ebx, %edi
xorl %eax, %eax
callq 0x20f0
movq (%r14), %rax
movq 0x10(%rax), %rdx
leaq 0x2147(%rip), %rsi      # 0xaac9
movl %ebx, %edi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20f0
// File: /workspace/github_c_makefile_star2_O3/MaoKo[P]FGFX/fgfp/src/gen_cfg.c
// Function: gen_rhs_table
void
gen_rhs_table(int filde, cfg_t const* cfg, char const* header) {
	dprintf(filde, STATIC SP INT NL);
	gen_verbatim_file(filde, header);

	dprintf(filde, "_rhs_prod_table[%s] = " BEG_BLOCK NL, "TOTAL_PROD");
	for (size_t i = 0; i < SIZE_VECTOR(cfg->productions) - 1; ++i) {
		production_t* prod = (production_t*)AT_VECTOR(cfg->productions, i);
		dprintf(filde, TAB "[");
		gen_nproduction(filde, cfg, i);
		dprintf(filde, "] = %zu" COMMA NL,
								size_gen_list((gen_list_t*)prod->rhs_element));
	}
	dprintf(filde, END_BLOCK SEMI NL NL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movl %edi, %ebx
leaq 0x1ee1(%rip), %rsi      # 0xa897
xorl %eax, %eax
callq 0x20f0
movl %ebx, %edi
movq %r15, %rsi
callq 0x3eaa
leaq 0x2114(%rip), %rsi      # 0xaae2
leaq 0x2126(%rip), %rdx      # 0xaafb
movl %ebx, %edi
xorl %eax, %eax
callq 0x20f0
movq (%r14), %rax
cmpq $0x1, 0x10(%rax)
je 0x8a40
leaq 0x211a(%rip), %r12      # 0xab09
xorl %r13d, %r13d
movq (%rax), %rax
movq (%rax,%r13,8), %r15
movl %ebx, %edi
leaq 0x2104(%rip), %rsi      # 0xab06
xorl %eax, %eax
callq 0x20f0
movl %ebx, %edi
movq %r14, %rsi
movq %r13, %rdx
callq 0x8834
movq 0x10(%r15), %rdi
callq 0x3ae2
movl %ebx, %edi
movq %r12, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x20f0
incq %r13
movq (%r14), %rax
movq 0x10(%rax), %rcx
decq %rcx
cmpq %rcx, %r13
jb 0x89f2
leaq 0x1e8d(%rip), %rsi      # 0xa8d4
movl %ebx, %edi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20f0
// File: /workspace/github_c_makefile_star2_O3/MaoKo[P]FGFX/fgfp/src/gen_cfg.c
// Function: gen_lhs_table
void
gen_lhs_table(int filde, cfg_t const* cfg, char const* header) {
	dprintf(filde, STATIC SP INT NL);
	gen_verbatim_file(filde, header);

	dprintf(filde, "_lhs_prod_table[%s] = " BEG_BLOCK NL, "TOTAL_PROD");
	for (size_t i = 0; i < SIZE_VECTOR(cfg->productions) - 1; ++i) {
		production_t* prod = (production_t*)AT_VECTOR(cfg->productions, i);
		dprintf(filde, TAB "[");
		gen_nproduction(filde, cfg, i);
		dprintf(filde, "] = ");
		gen_nter_symbol(filde, cfg, LHS(prod)->index, true);
		dprintf(filde, COMMA NL);
	}
	dprintf(filde, END_BLOCK SEMI NL NL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movl %edi, %ebx
leaq 0x1e1c(%rip), %rsi      # 0xa897
xorl %eax, %eax
callq 0x20f0
movl %ebx, %edi
movq %r15, %rsi
callq 0x3eaa
leaq 0x2080(%rip), %rsi      # 0xab13
leaq 0x2061(%rip), %rdx      # 0xaafb
movl %ebx, %edi
xorl %eax, %eax
callq 0x20f0
movq (%r14), %rax
cmpq $0x1, 0x10(%rax)
je 0x8b20
leaq 0x1e3d(%rip), %r13      # 0xa8f1
xorl %r15d, %r15d
movq (%rax), %rax
movq (%rax,%r15,8), %r12
movl %ebx, %edi
leaq 0x203f(%rip), %rsi      # 0xab06
xorl %eax, %eax
callq 0x20f0
movl %ebx, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x8834
movl %ebx, %edi
leaq 0x2048(%rip), %rsi      # 0xab2c
xorl %eax, %eax
callq 0x20f0
movq 0x8(%r12), %rax
movq (%rax), %rdx
movl %ebx, %edi
movq %r14, %rsi
movl $0x1, %ecx
callq 0x8637
movl %ebx, %edi
movq %r13, %rsi
xorl %eax, %eax
callq 0x20f0
incq %r15
movq (%r14), %rax
movq 0x10(%rax), %rcx
decq %rcx
cmpq %rcx, %r15
jb 0x8ab7
leaq 0x1dad(%rip), %rsi      # 0xa8d4
movl %ebx, %edi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20f0
// File: /workspace/github_c_makefile_star2_O3/MaoKo[P]FGFX/fgfp/src/gen_cfg.c
// Function: gen_synchronizing_token
void
gen_synchronizing_token(int filde, cfg_t const* cfg, char const* header) {
	dprintf(filde, STATIC SP INT NL);
	gen_verbatim_file(filde, header);

	dprintf(filde, "_sync_token[%s][%zu] = " BEG_BLOCK NL,
		MACRO_NTER, count_max_follow(cfg->non_terminal) + 1);

	for (size_t i = 0; i < SIZE_VECTOR(cfg->non_terminal) - 1; ++i) {
		symbol_t* nter = AT_VECTOR(cfg->non_terminal, i);
		dprintf(filde, TAB "[");
		gen_nter_symbol(filde, cfg, i, true);
		dprintf(filde, "] = " BEG_BLOCK SP);

		int j;
		while ((j = IT_NEXT(nter->follow)) != IT_NULL) {
			symbol_t* terminal = AT_VECTOR(cfg->terminal, j);
			dprintf(filde, TOKEN_PREFIX SEP "%s" COMMA SP, terminal->name);
		}
		dprintf(filde, "-1" SP END_BLOCK COMMA NL);
	}
	dprintf(filde, END_BLOCK SEMI NL NL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movl %edi, %ebx
leaq 0x1d3c(%rip), %rsi      # 0xa897
xorl %eax, %eax
callq 0x20f0
movl %ebx, %edi
movq %r15, %rsi
callq 0x3eaa
movq 0x8(%r14), %r12
movl $0x1, %r15d
cmpq $0x1, 0x10(%r12)
je 0x8baf
xorl %r15d, %r15d
xorl %r13d, %r13d
movq (%r12), %rax
movq (%rax,%r13,8), %rax
movq 0x28(%rax), %rdi
callq 0x2a48
cmpq %r15, %rax
cmovaq %rax, %r15
incq %r13
movq 0x10(%r12), %rax
decq %rax
cmpq %rax, %r13
jb 0x8b84
incq %r15
leaq 0x1f7b(%rip), %rsi      # 0xab31
leaq 0x1ef1(%rip), %rdx      # 0xaaae
movl %ebx, %edi
movq %r15, %rcx
xorl %eax, %eax
callq 0x20f0
movq 0x8(%r14), %rax
cmpq $0x1, 0x10(%rax)
je 0x8c6f
leaq 0x1f73(%rip), %r15      # 0xab52
xorl %r12d, %r12d
movq (%rax), %rax
movq (%rax,%r12,8), %r13
movl %ebx, %edi
leaq 0x1f14(%rip), %rsi      # 0xab06
xorl %eax, %eax
callq 0x20f0
movl %ebx, %edi
movq %r14, %rsi
movq %r12, %rdx
movl $0x1, %ecx
callq 0x8637
movl %ebx, %edi
leaq 0x1f37(%rip), %rsi      # 0xab4b
xorl %eax, %eax
callq 0x20f0
movq 0x28(%r13), %rdi
callq 0x28dc
cmpl $-0x1, %eax
je 0x8c48
movq 0x10(%r14), %rcx
movq (%rcx), %rcx
cltq
movq (%rcx,%rax,8), %rax
movq 0x10(%rax), %rdx
movl %ebx, %edi
movq %r15, %rsi
xorl %eax, %eax
callq 0x20f0
jmp 0x8c1b
movl %ebx, %edi
leaq 0x1f08(%rip), %rsi      # 0xab59
xorl %eax, %eax
callq 0x20f0
incq %r12
movq 0x8(%r14), %rax
movq 0x10(%rax), %rcx
decq %rcx
cmpq %rcx, %r12
jb 0x8be2
leaq 0x1c5e(%rip), %rsi      # 0xa8d4
movl %ebx, %edi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20f0
// File: /workspace/github_c_makefile_star2_O3/waywardgeek[P]sonic/sonic_experimental.c
// Function: sonicInit
void sonicInit(float speed, int sampleRate) {
  sonicStream.speed = speed;
  sonicStream.sampleRate = sampleRate;
  sonicMinPeriod = sampleRate / SONIC_MAX_PITCH;
  sonicMaxPeriod = sampleRate / SONIC_MIN_PITCH;
  memset(&sonicStream, 0, sizeof(struct sonicStruct));
  sonicStream.speed = speed;
  sonicStream.sampleRate = sampleRate;
  sonicStream.numInputSamples = 0;
  sonicStream.numOutputSamples = 0;
  sonicStream.prevPeriod = 0;
  sonicStream.prevMinDiff = 0;
  sonicStream.numInputSamples = sonicMinPeriod;
  sonicStream.snippetPeriod = sonicMinPeriod;
  sonicStream.snippetOffset = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movss %xmm0, 0x4(%rsp)
movslq %edi, %r14
imulq $0x51eb851f, %r14, %rbx # imm = 0x51EB851F
movq %rbx, %rax
shrq $0x3f, %rax
sarq $0x27, %rbx
addl %eax, %ebx
movl %ebx, 0x5bca17(%rip)    # 0x5bde54
imulq $0x7e07e07f, %r14, %rax # imm = 0x7E07E07F
movq %rax, %rcx
shrq $0x3f, %rcx
sarq $0x25, %rax
addl %ecx, %eax
movl %eax, 0x5bca01(%rip)    # 0x5bde58
leaq 0x3c56(%rip), %rdi      # 0x50b4
movl $0x5b8d80, %edx         # imm = 0x5B8D80
xorl %esi, %esi
callq 0x1090
movss 0x4(%rsp), %xmm0
movss %xmm0, 0x5bc9bc(%rip)   # 0x5bde34
movl %r14d, 0x5bc9b9(%rip)   # 0x5bde38
movl %ebx, 0x5bc9b7(%rip)    # 0x5bde3c
movl %ebx, 0x5bc9b5(%rip)    # 0x5bde40
xorps %xmm0, %xmm0
movups %xmm0, 0x5bc9af(%rip)   # 0x5bde44
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/waywardgeek[P]sonic/sonic_experimental.c
// Function: sonicReadShortFromStream
int sonicReadShortFromStream(short *samples, int maxSamples) {
  int numSamples = sonicStream.numOutputSamples;
  int remainingSamples = 0;

  if (numSamples == 0) {
    return 0;
  }
  if (numSamples > maxSamples) {
    remainingSamples = numSamples - maxSamples;
    numSamples = maxSamples;
  }
  memcpy(samples, sonicStream.outputBuffer, numSamples * sizeof(short));
  if (remainingSamples > 0) {
    memmove(sonicStream.outputBuffer, sonicStream.outputBuffer + numSamples,
            remainingSamples * sizeof(short));
  }
  sonicStream.numOutputSamples = remainingSamples;
  return numSamples;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl 0x5bc9a0(%rip), %eax    # 0x5bde48
testl %eax, %eax
je 0x1500
movl %esi, %ebx
xorl %ecx, %ecx
movl %eax, %r14d
subl %esi, %r14d
cmovll %eax, %ebx
cmovlel %ecx, %r14d
movslq %ebx, %r15
leaq (%r15,%r15), %rdx
leaq 0x1ec069(%rip), %rsi    # 0x1ed534
callq 0x10e0
testl %r14d, %r14d
jle 0x14f7
leaq 0x3bd8(%rip), %rax      # 0x50b4
leaq (%rax,%r15,2), %rsi
addq $0x1e8480, %rsi         # imm = 0x1E8480
leaq 0x1ec046(%rip), %rdi    # 0x1ed534
leal (%r14,%r14), %edx
callq 0x1100
movl %r14d, 0x5bc94a(%rip)   # 0x5bde48
jmp 0x1502
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/waywardgeek[P]sonic/sonic_experimental.c
// Function: sonicFlushStream
void sonicFlushStream(void) {
  int remainingSamples = sonicStream.numInputSamples - sonicMaxPeriod;
  float speed = sonicStream.speed;
  int expectedOutputSamples = sonicStream.numOutputSamples + (int)((remainingSamples / speed) + 0.5f);

  memset(sonicStream.inputBuffer + sonicMaxPeriod + remainingSamples, 0,
      sizeof(short) * (SONIC_INPUT_BUFFER_SIZE - (sonicMaxPeriod + remainingSamples)));
  sonicStream.numInputSamples = SONIC_INPUT_BUFFER_SIZE;
  sonicWriteShortToStream(NULL, 0);
  /* Throw away any extra samples we generated due to the silence we added */
  if (sonicStream.numOutputSamples > expectedOutputSamples) {
    sonicStream.numOutputSamples = expectedOutputSamples;
  }
  /* Empty input buffer */
  sonicStream.numInputSamples = sonicMinPeriod;
  memset(sonicStream.inputBuffer, 0, SONIC_INPUT_BUFFER_SIZE * sizeof(short));
}

// Assembly:
pushq %rbx
movslq 0x5bc92a(%rip), %rax    # 0x5bde3c
movslq 0x5bc93f(%rip), %rcx    # 0x5bde58
movl $0x119c, %edx           # imm = 0x119C
subq %rax, %rdx
subq %rcx, %rax
cvtsi2ss %eax, %xmm0
divss 0x5bc904(%rip), %xmm0   # 0x5bde34
addss 0x1acc(%rip), %xmm0     # 0x3004
cvttss2si %xmm0, %ebx
addl 0x5bc906(%rip), %ebx    # 0x5bde48
leaq 0x3b6b(%rip), %rsi      # 0x50b4
leaq (%rsi,%rcx,2), %rcx
leaq (%rcx,%rax,2), %rdi
addq %rdx, %rdx
xorl %esi, %esi
callq 0x1090
movl $0x119c, 0x5bc8d7(%rip) # imm = 0x119C
xorl %edi, %edi
xorl %esi, %esi
callq 0x159c
cmpl %ebx, 0x5bc8d4(%rip)    # 0x5bde48
jle 0x157c
movl %ebx, 0x5bc8cc(%rip)    # 0x5bde48
movl 0x5bc8d2(%rip), %eax    # 0x5bde54
movl %eax, 0x5bc8b4(%rip)    # 0x5bde3c
leaq 0x3b25(%rip), %rdi      # 0x50b4
movl $0x2338, %edx           # imm = 0x2338
xorl %esi, %esi
popq %rbx
jmp 0x1090
// File: /workspace/github_c_makefile_star2_O3/waywardgeek[P]sonic/sonic_experimental.c
// Function: setPeriod
static void setPeriod(sonicSnippet snippet, int period) {
  int pos = snippet->inputPos;
  short* p = sonicStream.inputBuffer + pos;
  float fade;
  int i;

  snippet->period = period;
  for (i = 0; i < period; i++) {
    /* TODO: Make this a Hann window. */
    fade = 0.5*(1.0 - cos(M_PI*i/period));
    snippet->samples[i] = (1.0f - fade) * p[i] + fade * p[i - period];
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movslq 0x30d40(%rdi), %r14
movl %esi, 0x30d48(%rdi)
testl %esi, %esi
jle 0x1aa0
movq %rdi, %rbx
leaq 0x36a7(%rip), %r15      # 0x50b4
leaq (%r15,%r14,2), %r12
cvtsi2sd %esi, %xmm0
movsd %xmm0, (%rsp)
movl %esi, %r13d
addq %r14, %r14
subq %r13, %r14
subq %r13, %r14
xorl %ebp, %ebp
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
mulsd 0x15e9(%rip), %xmm0     # 0x3020
divsd (%rsp), %xmm0
callq 0x10a0
movsd 0x15df(%rip), %xmm1     # 0x3028
subsd %xmm0, %xmm1
mulsd 0x15db(%rip), %xmm1     # 0x3030
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
movswl (%r12,%rbp,2), %eax
xorps %xmm1, %xmm1
cvtsi2ss %eax, %xmm1
movss 0x1598(%rip), %xmm2     # 0x3008
subss %xmm0, %xmm2
mulss %xmm2, %xmm1
leaq (%r14,%rbp,2), %rax
movswl (%r15,%rax), %eax
xorps %xmm2, %xmm2
cvtsi2ss %eax, %xmm2
mulss %xmm0, %xmm2
addss %xmm1, %xmm2
cvttss2si %xmm2, %eax
movw %ax, (%rbx,%rbp,2)
incq %rbp
cmpq %rbp, %r13
jne 0x1a28
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/waywardgeek[P]sonic/main_experimental.c
// Function: main
int main(int argc, char** argv) {
  char* inFileName;
  char* outFileName;
  float speed = 1.0f;
  int xArg = 1;

  while (xArg < argc && *(argv[xArg]) == '-') {
    if (!strcmp(argv[xArg], "-s")) {
      xArg++;
      if (xArg < argc) {
        speed = atof(argv[xArg]);
        printf("Setting speed to %0.2fX\n", speed);
      }
    }
    xArg++;
  }
  if (argc - xArg != 2) {
    usage();
  }
  inFileName = argv[xArg];
  outFileName = argv[xArg + 1];
  runSonic(inFileName, outFileName, speed);
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x150, %rsp            # imm = 0x150
movq %rsi, %rbx
movl %edi, %ebp
cmpl $0x2, %edi
jl 0x23ae
movss 0xcbb(%rip), %xmm0      # 0x3008
movss %xmm0, 0x4(%rsp)
movl $0x1, %r15d
leaq 0xeaf(%rip), %r14       # 0x320f
movslq %r15d, %rax
movq (%rbx,%rax,8), %rax
cmpb $0x2d, (%rax)
jne 0x23c2
cmpb $0x73, 0x1(%rax)
jne 0x23a4
cmpb $0x0, 0x2(%rax)
jne 0x23a4
incl %r15d
cmpl %ebp, %r15d
jge 0x23a4
movslq %r15d, %rax
movq (%rbx,%rax,8), %rdi
callq 0x1050
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x4(%rsp)
cvtss2sd %xmm0, %xmm0
movq %r14, %rdi
movb $0x1, %al
callq 0x1080
incl %r15d
cmpl %ebp, %r15d
jl 0x2360
jmp 0x23c2
movl $0x1, %r15d
movss 0xc4c(%rip), %xmm0      # 0x3008
movss %xmm0, 0x4(%rsp)
subl %r15d, %ebp
cmpl $0x2, %ebp
jne 0x24cc
movslq %r15d, %rax
movq (%rbx,%rax,8), %r14
movq 0x8(%rbx,%rax,8), %r15
leaq 0x8(%rsp), %rsi
leaq 0xc(%rsp), %r12
movq %r14, %rdi
movq %r12, %rdx
callq 0x1bb4
movl (%r12), %edi
cmpl $0x1, %edi
jne 0x24d1
movq %rax, %rbx
testq %rax, %rax
je 0x24d6
movl 0x8(%rsp), %esi
leaq 0xef5(%rip), %rdi       # 0x3308
xorl %eax, %eax
callq 0x1080
movl 0x8(%rsp), %esi
movq %r15, %rdi
movl $0x1, %edx
callq 0x1e44
testq %rax, %rax
je 0x24de
movq %rax, %r14
movl 0x8(%rsp), %edi
movss 0x4(%rsp), %xmm0
callq 0x1416
leaq 0xb0(%rsp), %r15
leaq 0x10(%rsp), %r12
movq %rbx, %rdi
movq %r15, %rsi
movl $0x50, %edx
callq 0x211a
movl %eax, %ebp
testl %eax, %eax
je 0x2475
movq %r15, %rdi
movl %ebp, %esi
callq 0x159c
jmp 0x248f
callq 0x150a
jmp 0x248f
movq %r14, %rdi
movq %r12, %rsi
movl %eax, %edx
callq 0x2198
incl 0x5bb9cd(%rip)          # 0x5bde5c
movq %r12, %rdi
movl $0x50, %esi
callq 0x149d
testl %eax, %eax
jg 0x247c
incl 0x5bb9b6(%rip)          # 0x5bde5c
testl %ebp, %ebp
jg 0x2453
movq %rbx, %rdi
callq 0x2038
movq %r14, %rdi
callq 0x2038
xorl %eax, %eax
addq $0x150, %rsp            # imm = 0x150
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x1280
callq 0x12a5
movq %r14, %rdi
callq 0x12f4
movq %rbx, %rdi
movq %r15, %rsi
callq 0x12c8
// File: /workspace/github_c_makefile_star2_O3/qpfiffer[P]38-Moths/src/simple_sparsehash.c
// Function: sparse_array_init
struct sparse_array *sparse_array_init(const size_t element_size, const uint32_t maximum) {
	unsigned int i = 0;
	struct sparse_array *arr = NULL;
	/* CHECK YOUR SYSCALL RETURNS. Listen to djb. */
	arr = calloc(1, sizeof(struct sparse_array));
	if (arr == NULL)
		return NULL;

	/* This is a non-obvious hack I use. If we have const variables in a
	 * struct then to initialize them we can either cast them or use an
	 * initializer like this.
	 * Then we copy it into a heap-allocated blob. The compiler lets us
	 * do this.
	 */
	struct sparse_array stack_array = {
		.maximum = maximum,
	};

	memcpy(arr, &stack_array, sizeof(struct sparse_array));
	arr->groups = calloc(MAX_ARR_SIZE, sizeof(struct sparse_array_group));
	if (arr->groups == NULL) {
		free(arr);
		return NULL;
	}

	for (i = 0; i < MAX_ARR_SIZE; i++) {
		struct sparse_array_group *sag = &arr->groups[i];
		sag->elem_size = element_size;
	}

	return arr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %r14
movl $0x1, %edi
movl $0x10, %esi
callq 0x32e0
testq %rax, %rax
je 0x39c5
movq %rax, %rbx
movl %ebp, %eax
movq %rax, (%rbx)
decq %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
mulq %rcx
movq %rdx, %r15
shrq $0x5, %r15
leaq 0x1(%r15), %rdi
movl $0x20, %esi
callq 0x32e0
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x39bd
addq $0x8, %rax
movl $0x1, %ecx
movq %r14, (%rax)
movl %ecx, %edx
addq $0x20, %rax
incl %ecx
cmpq %rdx, %r15
jae 0x39ab
jmp 0x39c7
movq %rbx, %rdi
callq 0x3050
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/qpfiffer[P]38-Moths/src/simple_sparsehash.c
// Function: sparse_array_set
int sparse_array_set(struct sparse_array *arr, const uint32_t i,
						   const void *val, const size_t vlen) {
	/* Don't let users set outside the bounds of the array. */
	if (i > arr->maximum)
		return 0;
	/* Since our hashtable is divided into many arrays, we need to pick the one
	 * relevant to `i` in this case:
	 */
	struct sparse_array_group *operating_group = &arr->groups[i / GROUP_SIZE];
	const int position = i % GROUP_SIZE;
	return _sparse_array_group_set(operating_group, position, val, vlen);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %eax
xorl %ebp, %ebp
cmpq %rax, (%rdi)
jb 0x3b10
movq %rcx, %rbx
movq 0x8(%rdi), %r14
movl $0xaaaaaaab, %ecx       # imm = 0xAAAAAAAB
imulq %rax, %rcx
movq %rcx, %rax
shrq $0x20, %rax
andl $-0x20, %eax
movq 0x8(%r14,%rax), %r15
cmpq %rbx, %r15
jb 0x3b10
movl %esi, %r13d
movq %rdx, 0x20(%rsp)
shrq $0x25, %rcx
shll $0x4, %ecx
leal (%rcx,%rcx,2), %ecx
subl %ecx, %r13d
addq %rax, %r14
leaq 0x18(%r14), %rdi
movl %r13d, %esi
callq 0x4221
movl %r13d, %r12d
movl $0x1, %edx
movl %r13d, %ecx
shll %cl, %edx
shrl $0x5, %r12d
movl 0x18(%r14,%r12,4), %ecx
btl %r13d, %ecx
movl %eax, %ecx
jae 0x3a66
movq 0x10(%r14), %r13
movq %r15, %rbp
jmp 0x3ae7
movq %rax, 0x18(%rsp)
movl %edx, 0x4(%rsp)
movq %rcx, 0x8(%rsp)
movl (%r14), %eax
addq $0x8, %r15
movq 0x10(%r14), %rdi
movq %rax, 0x10(%rsp)
leal 0x1(%rax), %esi
imulq %r15, %rsi
callq 0x3440
testq %rax, %rax
je 0x3b10
movq %rax, %r13
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
subl %edi, %eax
imulq %rax, %r15
movq 0x8(%r14), %rbp
testq %r15, %r15
je 0x3ad2
incl %edi
leaq 0x8(%rbp), %rax
imulq %rax, %rdi
addq %r13, %rdi
movq 0x8(%rsp), %rsi
imulq %rax, %rsi
addq %r13, %rsi
movq %r15, %rdx
callq 0x34a0
incl (%r14)
movq %r13, 0x10(%r14)
movl 0x4(%rsp), %eax
orl %eax, 0x18(%r14,%r12,4)
movq 0x8(%rsp), %rcx
addq $0x8, %rbp
imulq %rcx, %rbp
leaq 0x8(,%rbp), %rdi
addq %r13, %rdi
movq %rbx, -0x8(%rdi)
movq 0x20(%rsp), %rsi
movq %rbx, %rdx
callq 0x3350
movl $0x1, %ebp
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/qpfiffer[P]38-Moths/src/simple_sparsehash.c
// Function: sparse_array_get
const void *sparse_array_get(struct sparse_array *arr, const uint32_t i, size_t *outsize) {
	if (i > arr->maximum)
		return NULL;
	struct sparse_array_group *operating_group = &arr->groups[i / GROUP_SIZE];
	const int position = i % GROUP_SIZE;
	return _sparse_array_group_get(operating_group, position, outsize);
}

// Assembly:
movl %esi, %eax
cmpq %rax, (%rdi)
jae 0x3b2b
xorl %eax, %eax
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq 0x8(%rdi), %r14
movl $0xaaaaaaab, %ecx       # imm = 0xAAAAAAAB
imulq %rax, %rcx
movq %rcx, %r15
shrq $0x20, %r15
andl $-0x20, %r15d
leaq (%r14,%r15), %r12
shrq $0x25, %rcx
shll $0x4, %ecx
leal (%rcx,%rcx,2), %eax
subl %eax, %ebp
leaq (%r14,%r15), %rdi
addq $0x18, %rdi
movl %ebp, %esi
callq 0x4221
movl %ebp, %ecx
shrl $0x3, %ecx
andl $0x4, %ecx
movl 0x18(%rcx,%r12), %ecx
btl %ebp, %ecx
jae 0x3bb3
movq 0x8(%r14,%r15), %rcx
movq 0x10(%r14,%r15), %rdx
movl %eax, %eax
addq $0x8, %rcx
imulq %rax, %rcx
leaq (%rdx,%rcx), %rax
movq (%rax), %rsi
testq %rsi, %rsi
je 0x3bb3
leaq (%rdx,%rcx), %rax
addq $0x8, %rax
testq %rbx, %rbx
je 0x3bb5
movq %rsi, (%rbx)
jmp 0x3bb5
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/qpfiffer[P]38-Moths/src/simple_sparsehash.c
// Function: sparse_array_free
int sparse_array_free(struct sparse_array *arr) {
	unsigned int i = 0;
	for (; i < MAX_ARR_SIZE; i++) {
		struct sparse_array_group *sag = &arr->groups[i];
		_sparse_array_group_free(sag);
	}
	free(arr->groups);
	free(arr);
	return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x1, %ebp
xorl %ecx, %ecx
movabsq $-0x5555555555555555, %r14 # imm = 0xAAAAAAAAAAAAAAAB
movq 0x8(%rbx), %rax
shlq $0x5, %rcx
movq 0x10(%rax,%rcx), %rdi
callq 0x3050
movl %ebp, %ecx
movq (%rbx), %rax
decq %rax
mulq %r14
shrq $0x5, %rdx
incl %ebp
cmpq %rcx, %rdx
jae 0x3bd6
movq 0x8(%rbx), %rdi
callq 0x3050
movq %rbx, %rdi
callq 0x3050
movl $0x1, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/qpfiffer[P]38-Moths/src/simple_sparsehash.c
// Function: sparse_dict_init
struct sparse_dict *sparse_dict_init() {
	struct sparse_dict *new = NULL;
	new = calloc(1, sizeof(struct sparse_dict));
	if (new == NULL)
		return NULL;

	new->bucket_max = STARTING_SIZE;
	new->bucket_count = 0;
	new->buckets = sparse_array_init(sizeof(struct sparse_bucket), STARTING_SIZE);
	if (new->buckets == NULL)
		goto error;

	return new;

error:
	free(new);
	return NULL;
}

// Assembly:
pushq %rbx
movl $0x1, %edi
movl $0x18, %esi
callq 0x32e0
testq %rax, %rax
je 0x3c58
movq %rax, %rbx
movq $0x20, (%rax)
movl $0x28, %edi
movl $0x20, %esi
callq 0x3570
movq %rax, 0x10(%rbx)
testq %rax, %rax
jne 0x3c5a
movq %rbx, %rdi
callq 0x3050
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/qpfiffer[P]38-Moths/src/simple_sparsehash.c
// Function: sparse_dict_get
void *sparse_dict_get(struct sparse_dict *dict, const char *key,
							const size_t klen, size_t *outsize) {
	const uint64_t key_hash = hash_fnv1a(key, klen);
	unsigned int num_probes = 0;

	while (1) {
		size_t current_value_siz = 0;
		const unsigned int probed_val = QUADRATIC_PROBE(dict->bucket_max);
		const void *current_value = sparse_array_get(dict->buckets, probed_val, &current_value_siz);

		if (current_value_siz != 0 && current_value != NULL) {
			/* We have to do a string comparison here because we use quadratic probing.
			 * The value we pulled from the underlying array could be anything.
			 */
			struct sparse_bucket *existing_bucket = (struct sparse_bucket *)current_value;
			const size_t lrgr_key = existing_bucket->klen > klen ? existing_bucket->klen : klen;
			if (existing_bucket->hash == key_hash && strncmp(existing_bucket->key, key, lrgr_key) == 0) {
				if (outsize)
					memcpy(outsize, &existing_bucket->vlen, sizeof(existing_bucket->vlen));

				return existing_bucket->val;
			}
		} else {
			/* We found nothing where we expected something. */
			return NULL;
		}

		num_probes++;

		if (num_probes > dict->bucket_count)
			return NULL;
	}

	return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, 0x18(%rsp)
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, 0x8(%rsp)
movabsq $-0x340d631b7bdddcdb, %rdx # imm = 0xCBF29CE484222325
testl %r14d, %r14d
jle 0x40ed
movb $0x1, %cl
movabsq $0x100000001b3, %rax    # imm = 0x100000001B3
leal -0x1(%rcx), %esi
movzbl %sil, %esi
movsbq (%r15,%rsi), %rbx
xorq %rdx, %rbx
imulq %rax, %rbx
movzbl %cl, %esi
leal 0x1(%rsi), %ecx
movq %rbx, %rdx
cmpl %r14d, %esi
jb 0x40ca
jmp 0x40f0
movq %rdx, %rbx
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
movq 0x8(%rsp), %rax
addq (%rax), %r12
movq 0x10(%rax), %rax
movq %rax, 0x20(%rsp)
movl $0x1, %ebp
movq $0x0, (%rsp)
leal -0x1(%rbp), %esi
movq $0x0, 0x10(%rsp)
imull %esi, %esi
addl %ebx, %esi
andl %r12d, %esi
movq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x3430
cmpq $0x0, 0x10(%rsp)
je 0x4193
movq %rax, %r13
testq %rax, %rax
je 0x4193
cmpq %rbx, 0x20(%r13)
jne 0x4169
movq 0x8(%r13), %rdx
cmpq %r14, %rdx
ja 0x4159
movq %r14, %rdx
movq (%r13), %rdi
movq %r15, %rsi
callq 0x30b0
testl %eax, %eax
je 0x417a
movl %ebp, %eax
incl %ebp
movq 0x8(%rsp), %rcx
cmpq %rax, 0x8(%rcx)
jae 0x4114
jmp 0x4193
movq 0x18(%rsp), %rcx
testq %rcx, %rcx
je 0x418b
movq 0x18(%r13), %rax
movq %rax, (%rcx)
movq 0x10(%r13), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/qpfiffer[P]38-Moths/src/simple_sparsehash.c
// Function: sparse_dict_free
int sparse_dict_free(struct sparse_dict *dict) {
	unsigned int i = 0;
	for (i = 0; i < dict->bucket_max; i++) {
		size_t current_value_siz = 0;
		const void *current_value = sparse_array_get(dict->buckets, i, &current_value_siz);

		if (current_value_siz != 0 && current_value != NULL) {
			struct sparse_bucket *existing_bucket = (struct sparse_bucket *)current_value;
			free(existing_bucket->val);
		}
	}
	sparse_array_free(dict->buckets);
	free(dict);
	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r12
testq %r12, %r12
je 0x41ff
xorl %r14d, %r14d
movq %rsp, %r15
movq $0x0, (%rsp)
movq 0x10(%rbx), %rdi
movl %r14d, %esi
movq %r15, %rdx
callq 0x3430
cmpq $0x0, (%rsp)
setne %cl
testq %rax, %rax
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x41f7
movq 0x10(%rax), %rdi
callq 0x3050
movq (%rbx), %r12
incl %r14d
cmpq %r14, %r12
ja 0x41bf
movq 0x10(%rbx), %rdi
callq 0x3230
movq %rbx, %rdi
callq 0x3050
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/qpfiffer[P]38-Moths/src/simple_sparsehash.c
// Function: position_to_offset
static uint32_t position_to_offset(const uint32_t *bitmap,
									   const uint32_t position) {
	uint32_t retval = 0;
	uint32_t pos = position;
	uint32_t bitmap_iter = 0;

	/* Here we loop through the bitmap a uint32_t at a time, and count the number
	 * of 1s in that chunk.
	 */
	for (; pos >= BITCHUNK_SIZE; pos -= BITCHUNK_SIZE)
		retval += popcount_32(bitmap[bitmap_iter++]);

	/* This last bit does the same thing as above, but takes care of the
	 * remainder that didn't fit cleanly into the 32 x 32 x 32 ... loop above. That
	 * is to say, it grabs the last 0 - 7 bits and adds the number of 1s in it to
	 * retval.
	 */
	return retval + popcount_32(bitmap[bitmap_iter] & (((uint32_t)1 << pos) - 1u));
}

// Assembly:
movl %esi, %ecx
cmpl $0x20, %esi
jb 0x42a5
pushq %rbx
leal -0x20(%rcx), %esi
movl %esi, %eax
shrl $0x5, %eax
andl $-0x20, %esi
addq $0x20, %rsi
xorl %r8d, %r8d
movl $0x33333333, %r9d       # imm = 0x33333333
movq %rdi, %r10
xorl %edx, %edx
movl (%r10), %r11d
movl %r11d, %ebx
shrl %ebx
andl $0x55555555, %ebx       # imm = 0x55555555
subl %ebx, %r11d
movl %r11d, %ebx
andl %r9d, %ebx
shrl $0x2, %r11d
andl %r9d, %r11d
addl %ebx, %r11d
movl %r11d, %ebx
shrl $0x4, %ebx
addl %r11d, %ebx
andl $0xf0f0f0f, %ebx        # imm = 0xF0F0F0F
movl %ebx, %r11d
shrl $0x8, %r11d
addl %ebx, %r11d
movl %r11d, %ebx
shrl $0x10, %ebx
addl %r11d, %ebx
movzbl %bl, %r11d
addl %r11d, %edx
addq $0x4, %r10
addq $0x20, %r8
cmpq %r8, %rsi
jne 0x4246
incl %eax
subl %r8d, %ecx
popq %rbx
jmp 0x42a9
xorl %edx, %edx
xorl %eax, %eax
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
shll %cl, %esi
notl %esi
andl (%rdi,%rax,4), %esi
movl %esi, %eax
shrl %eax
andl $0x15555555, %eax       # imm = 0x15555555
subl %eax, %esi
movl $0x33333333, %eax       # imm = 0x33333333
movl %esi, %ecx
andl %eax, %ecx
shrl $0x2, %esi
andl %eax, %esi
addl %ecx, %esi
movl %esi, %eax
shrl $0x4, %eax
addl %esi, %eax
andl $0xf0f0f0f, %eax        # imm = 0xF0F0F0F
movl %eax, %ecx
shrl $0x8, %ecx
addl %eax, %ecx
movl %ecx, %eax
shrl $0x10, %eax
addl %ecx, %eax
movzbl %al, %eax
addl %edx, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/qpfiffer[P]38-Moths/src/utils.c
// Function: m38_url_decode
int m38_url_decode(const char *s, char *dec) {
	char *o;
	const char *end = s + strlen(s);
	int c;

	for (o = dec; s <= end; o++) {
		c = *s++;
		if (c == '+') c = ' ';
		else if (c == '%' && (!_ishex(*s++) ||
					!_ishex(*s++) ||
					!sscanf(s - 2, "%2x", &c)))
			return -1;

		if (dec) {
			*o = c;
		}
	}

	return o - dec;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %r15
callq 0x3150
movq %r12, %rbx
testq %rax, %rax
js 0x43a5
movq %rax, %r14
addq %r15, %r14
leaq 0x4(%rsp), %r13
movq %r12, %rbx
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
leaq 0x1(%r15), %rdi
movzbl (%r15), %eax
movsbl %al, %ecx
movl %ecx, 0x4(%rsp)
cmpl $0x25, %eax
je 0x434b
cmpl $0x2b, %eax
jne 0x4346
movl $0x20, 0x4(%rsp)
movq %rdi, %r15
jmp 0x4392
movsbl (%rdi), %eax
leal -0x3a(%rax), %ecx
cmpl $-0xb, %ecx
ja 0x4361
andl $-0x21, %eax
addl $-0x47, %eax
cmpl $-0x6, %eax
jb 0x43aa
movsbl 0x2(%r15), %eax
leal -0x3a(%rax), %ecx
cmpl $-0xb, %ecx
ja 0x4379
andl $-0x21, %eax
addl $-0x47, %eax
cmpl $-0x6, %eax
jb 0x43aa
leaq 0x5cae(%rip), %rsi      # 0xa02e
movq %r13, %rdx
xorl %eax, %eax
callq 0x33e0
testl %eax, %eax
je 0x43aa
addq $0x3, %r15
testq %r12, %r12
je 0x439d
movb 0x4(%rsp), %al
movb %al, (%rbx)
incq %rbx
cmpq %r14, %r15
jbe 0x4325
subl %r12d, %ebx
movl %ebx, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq