LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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, -0x30(%rbp)
movq %rsi, %r15
movl %edi, %ebx
leaq 0x2ca1(%rip), %rsi      # 0xa887
xorl %eax, %eax
callq 0x20f0
movl %ebx, %edi
movq %r14, %rsi
callq 0x3b37
leaq 0x2c95(%rip), %rsi      # 0xa893
movl %ebx, %edi
xorl %eax, %eax
callq 0x20f0
leaq 0x2f38(%rip), %r12      # 0xab46
xorl %r13d, %r13d
movq -0x30(%rbp), %rax
cmpq 0x10(%rax), %r13
jae 0x7cb9
movq (%rax), %rax
movq (%rax,%r13,8), %r14
testq %r14, %r14
je 0x7c9b
movl %ebx, %edi
leaq 0x2c51(%rip), %rsi      # 0xa885
xorl %eax, %eax
callq 0x20f0
jmp 0x7c9b
leaq 0x2eb3(%rip), %rsi      # 0xaaf7
xorl %eax, %eax
callq 0x20f0
movl %ebx, %edi
movq %r15, %rsi
movq %r13, %rdx
pushq $0x1
popq %rcx
callq 0x8106
movq 0x10(%r15), %rax
movq (%rax), %rax
movslq 0x8(%r14), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rdx
movl %ebx, %edi
leaq 0x2c44(%rip), %rsi      # 0xa8bb
xorl %eax, %eax
callq 0x20f0
movslq 0xc(%r14), %rdx
movl %ebx, %edi
movq %r15, %rsi
callq 0x82e2
movl %ebx, %edi
movq %r12, %rsi
xorl %eax, %eax
callq 0x20f0
movq (%r14), %r14
movl %ebx, %edi
testq %r14, %r14
jne 0x7c3d
leaq 0x2d9f(%rip), %rsi      # 0xaa48
pushq $0x1
popq %rdx
callq 0x2080
incq %r13
jmp 0x7c11
leaq 0x2c04(%rip), %rsi      # 0xa8c4
movl %ebx, %edi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20f0
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x2be2(%rip), %rsi      # 0xa8c9
xorl %eax, %eax
callq 0x20f0
leaq 0x2bdc(%rip), %rsi      # 0xa8d1
movl %ebx, %edi
xorl %eax, %eax
callq 0x20f0
leaq 0x2bdf(%rip), %rsi      # 0xa8e4
movl %ebx, %edi
xorl %eax, %eax
callq 0x20f0
leaq 0x2be3(%rip), %rsi      # 0xa8f8
movl %ebx, %edi
xorl %eax, %eax
callq 0x20f0
leaq 0x2b9f(%rip), %rsi      # 0xa8c4
movl %ebx, %edi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x20f0
// File: /workspace/github_c_makefile_star2_O2/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 0x2bc7(%rip), %rsi      # 0xa90a
xorl %eax, %eax
callq 0x20f0
leaq 0x2bd8(%rip), %rsi      # 0xa929
movl %ebx, %edi
xorl %eax, %eax
callq 0x20f0
leaq 0x2be9(%rip), %rsi      # 0xa94a
movl %ebx, %edi
xorl %eax, %eax
callq 0x20f0
leaq 0x2bf6(%rip), %rsi      # 0xa967
movl %ebx, %edi
xorl %eax, %eax
callq 0x20f0
leaq 0x2bfc(%rip), %rsi      # 0xa97d
movl %ebx, %edi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x20f0
// File: /workspace/github_c_makefile_star2_O2/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
subq $0x18, %rsp
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r15
movl %edi, %ebx
leaq 0x28df(%rip), %rsi      # 0xa887
xorl %eax, %eax
callq 0x20f0
movl %ebx, %edi
movq %r14, %rsi
callq 0x3b37
movq 0x10(%r12), %rdx
leaq 0x2a38(%rip), %rsi      # 0xa9fd
movl %ebx, %edi
xorl %eax, %eax
callq 0x20f0
pushq $0x1
popq %r13
leaq 0x2a49(%rip), %r14      # 0xaa22
xorl %edx, %edx
movq %r12, -0x30(%rbp)
cmpq 0x10(%r12), %rdx
jae 0x8084
movq (%r12), %rax
movq (%rax,%rdx,8), %r12
movl %ebx, %edi
leaq 0x29c5(%rip), %rsi      # 0xa9c0
movq %rdx, -0x38(%rbp)
xorl %eax, %eax
callq 0x20f0
addq $0x18, %r12
movq (%r12), %r12
movl %ebx, %edi
testq %r12, %r12
je 0x8066
leaq 0x2adb(%rip), %rsi      # 0xaaf7
xorl %eax, %eax
callq 0x20f0
movslq 0x8(%r12), %rdx
xorq $0x2000, %rdx           # imm = 0x2000
movl %ebx, %edi
movq %r15, %rsi
movl %r13d, %ecx
callq 0x8106
movl 0xc(%r12), %edx
movl %ebx, %edi
movq %r14, %rsi
xorl %eax, %eax
callq 0x20f0
cmpq $0x0, (%r12)
je 0x800a
movl %ebx, %edi
leaq 0x2ae9(%rip), %rsi      # 0xab46
xorl %eax, %eax
callq 0x20f0
jmp 0x800a
leaq 0x2adf(%rip), %rsi      # 0xab4c
xorl %eax, %eax
callq 0x20f0
movq -0x38(%rbp), %rdx
incq %rdx
movq -0x30(%rbp), %r12
jmp 0x7fdf
leaq 0x2839(%rip), %rsi      # 0xa8c4
movl %ebx, %edi
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20f0
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x2972(%rip), %rsi      # 0xaa2d
xorl %eax, %eax
callq 0x20f0
leaq 0x2981(%rip), %r15      # 0xaa4a
xorl %r12d, %r12d
movq 0x18(%r14), %rax
cmpq 0x10(%rax), %r12
jae 0x80ee
movq (%rax), %rax
movq (%rax,%r12,8), %rdx
movl %ebx, %edi
movq %r15, %rsi
xorl %eax, %eax
callq 0x20f0
incq %r12
jmp 0x80cc
leaq 0x2964(%rip), %rsi      # 0xaa59
movl %ebx, %edi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x20f0
// File: /workspace/github_c_makefile_star2_O2/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), %r14
cmpq $0x0, 0x40(%r14)
je 0x8179
cmpl $0x0, 0x38(%r14)
leaq 0x293b(%rip), %rax      # 0xaa75
leaq 0x2938(%rip), %rsi      # 0xaa79
cmoveq %rax, %rsi
movl %ebx, %edi
xorl %eax, %eax
callq 0x20f0
testb %r12b, %r12b
je 0x8163
leaq 0x1dd3(%rip), %rsi      # 0x9f2d
movl %ebx, %edi
xorl %eax, %eax
callq 0x20f0
movq 0x48(%r14), %rax
movq %rax, -0x38(%rbp)
movq 0x50(%r14), %rax
movq %rax, -0x30(%rbp)
movq 0x40(%r14), %r14
jmp 0x8189
movq $0x0, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
leaq 0xf9f(%rip), %rsi       # 0x912f
movl %ebx, %edi
xorl %eax, %eax
callq 0x20f0
testb %r12b, %r12b
je 0x81ae
leaq 0x1d88(%rip), %rsi      # 0x9f2d
movl %ebx, %edi
xorl %eax, %eax
callq 0x20f0
movq 0x10(%r14), %rdi
callq 0x2090
movq %rax, %r12
decq %r12
pushq $0x1
popq %r15
movq %r15, %r13
cmpq %r12, %r13
jae 0x81f8
movq 0x10(%r14), %rsi
cmpb $0x27, (%rsi,%r13)
jne 0x81e6
movl %ebx, %edi
leaq 0x28a0(%rip), %rsi      # 0xaa7d
xorl %eax, %eax
callq 0x20f0
jmp 0x81f3
addq %r13, %rsi
movl %ebx, %edi
movq %r15, %rdx
callq 0x2080
incq %r13
jmp 0x81c4
movq -0x38(%rbp), %rcx
testq %rcx, %rcx
je 0x8223
leaq 0x287c(%rip), %rsi      # 0xaa84
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_O2/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 0x267d(%rip), %rsi      # 0xa8c9
xorl %eax, %eax
callq 0x20f0
pushq $0x1
popq %r12
leaq 0x2683(%rip), %r13      # 0xa8e1
xorl %r15d, %r15d
movq 0x8(%r14), %rax
movq 0x10(%rax), %rax
decq %rax
cmpq %rax, %r15
jae 0x82a2
movl %ebx, %edi
leaq 0x260b(%rip), %rsi      # 0xa885
xorl %eax, %eax
callq 0x20f0
movl %ebx, %edi
movq %r14, %rsi
movq %r15, %rdx
movl %r12d, %ecx
callq 0x8106
movl %ebx, %edi
movq %r13, %rsi
xorl %eax, %eax
callq 0x20f0
incq %r15
jmp 0x8261
leaq 0x261b(%rip), %rsi      # 0xa8c4
movl %ebx, %edi
xorl %eax, %eax
callq 0x20f0
movq 0x8(%r14), %rax
movq 0x10(%rax), %rcx
decq %rcx
leaq 0x27c9(%rip), %rsi      # 0xaa8d
leaq 0x27d3(%rip), %rdx      # 0xaa9e
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_O2/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 0x27a9(%rip), %rsi      # 0xaaa9
xorl %eax, %eax
callq 0x20f0
movq (%rbx), %rax
movq (%rax), %rax
movq (%rax,%r15,8), %r13
movq 0x8(%r13), %rax
movq (%rax), %rdx
movl %r14d, %edi
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0x8106
leaq 0x2784(%rip), %rsi      # 0xaab0
movl %r14d, %edi
xorl %eax, %eax
callq 0x20f0
addq $0x10, %r13
leaq 0x1bec(%rip), %r15      # 0x9f2d
leaq 0x276d(%rip), %r12      # 0xaab5
movq (%r13), %r13
testq %r13, %r13
je 0x838d
movl %r14d, %edi
movq %r15, %rsi
xorl %eax, %eax
callq 0x20f0
movq 0x8(%r13), %rax
cmpl $0x2d, 0x8(%rax)
jne 0x837b
movq 0x10(%rax), %rdx
movl %r14d, %edi
movq %r12, %rsi
xorl %eax, %eax
callq 0x20f0
jmp 0x8348
movq (%rax), %rdx
movl %r14d, %edi
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0x8106
jmp 0x8348
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2513(%rip), %rsi      # 0xa8c9
xorl %eax, %eax
callq 0x20f0
leaq 0x24c1(%rip), %r15      # 0xa885
leaq 0x2516(%rip), %r12      # 0xa8e1
xorl %r13d, %r13d
movq (%r14), %rax
movq 0x10(%rax), %rax
decq %rax
cmpq %rax, %r13
jae 0x8407
movl %ebx, %edi
movq %r15, %rsi
xorl %eax, %eax
callq 0x20f0
movl %ebx, %edi
movq %r14, %rsi
movq %r13, %rdx
callq 0x82e2
movl %ebx, %edi
movq %r12, %rsi
xorl %eax, %eax
callq 0x20f0
incq %r13
jmp 0x83ce
leaq 0x24b6(%rip), %rsi      # 0xa8c4
movl %ebx, %edi
xorl %eax, %eax
callq 0x20f0
movq (%r14), %rax
movq 0x10(%rax), %rdx
leaq 0x2694(%rip), %rsi      # 0xaab9
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_O2/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 0x242e(%rip), %rsi      # 0xa887
xorl %eax, %eax
callq 0x20f0
movl %ebx, %edi
movq %r15, %rsi
callq 0x3b37
leaq 0x2661(%rip), %rsi      # 0xaad2
leaq 0x2673(%rip), %rdx      # 0xaaeb
movl %ebx, %edi
xorl %eax, %eax
callq 0x20f0
leaq 0x2671(%rip), %r12      # 0xaaf9
xorl %r13d, %r13d
movq (%r14), %rax
movq 0x10(%rax), %rcx
decq %rcx
cmpq %rcx, %r13
jae 0x84db
movq (%rax), %rax
movq (%rax,%r13,8), %r15
movl %ebx, %edi
leaq 0x264c(%rip), %rsi      # 0xaaf6
xorl %eax, %eax
callq 0x20f0
movl %ebx, %edi
movq %r14, %rsi
movq %r13, %rdx
callq 0x82e2
movq 0x10(%r15), %rdi
callq 0x37bb
movl %ebx, %edi
movq %r12, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x20f0
incq %r13
jmp 0x848b
leaq 0x23e2(%rip), %rsi      # 0xa8c4
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_O2/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 0x2371(%rip), %rsi      # 0xa887
xorl %eax, %eax
callq 0x20f0
movl %ebx, %edi
movq %r15, %rsi
callq 0x3b37
leaq 0x25d5(%rip), %rsi      # 0xab03
leaq 0x25b6(%rip), %rdx      # 0xaaeb
movl %ebx, %edi
xorl %eax, %eax
callq 0x20f0
leaq 0x239c(%rip), %r15      # 0xa8e1
xorl %r12d, %r12d
movq (%r14), %rax
movq 0x10(%rax), %rcx
decq %rcx
cmpq %rcx, %r12
jae 0x85b0
movq (%rax), %rax
movq (%rax,%r12,8), %r13
movl %ebx, %edi
leaq 0x258f(%rip), %rsi      # 0xaaf6
xorl %eax, %eax
callq 0x20f0
movl %ebx, %edi
movq %r14, %rsi
movq %r12, %rdx
callq 0x82e2
movl %ebx, %edi
leaq 0x2598(%rip), %rsi      # 0xab1c
xorl %eax, %eax
callq 0x20f0
movq 0x8(%r13), %rax
movq (%rax), %rdx
movl %ebx, %edi
movq %r14, %rsi
pushq $0x1
popq %rcx
callq 0x8106
movl %ebx, %edi
movq %r15, %rsi
xorl %eax, %eax
callq 0x20f0
incq %r12
jmp 0x8548
leaq 0x230d(%rip), %rsi      # 0xa8c4
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_O2/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 0x229c(%rip), %rsi      # 0xa887
xorl %r12d, %r12d
xorl %eax, %eax
callq 0x20f0
movl %ebx, %edi
movq %r15, %rsi
callq 0x3b37
movq 0x8(%r14), %r13
xorl %r15d, %r15d
movq 0x10(%r13), %rax
decq %rax
cmpq %rax, %r12
jae 0x862f
movq (%r13), %rax
movq (%rax,%r12,8), %rax
movq 0x28(%rax), %rdi
callq 0x284d
cmpq %r15, %rax
cmovaq %rax, %r15
incq %r12
jmp 0x8606
incq %r15
leaq 0x24e8(%rip), %rsi      # 0xab21
leaq 0x245e(%rip), %rdx      # 0xaa9e
movl %ebx, %edi
movq %r15, %rcx
xorl %eax, %eax
callq 0x20f0
leaq 0x24ef(%rip), %r12      # 0xab42
xorl %r13d, %r13d
movq 0x8(%r14), %rax
movq 0x10(%rax), %rcx
decq %rcx
cmpq %rcx, %r13
jae 0x86e2
movq (%rax), %rax
movq (%rax,%r13,8), %r15
movl %ebx, %edi
leaq 0x2480(%rip), %rsi      # 0xaaf6
xorl %eax, %eax
callq 0x20f0
movl %ebx, %edi
movq %r14, %rsi
movq %r13, %rdx
pushq $0x1
popq %rcx
callq 0x8106
movl %ebx, %edi
leaq 0x24a5(%rip), %rsi      # 0xab3b
xorl %eax, %eax
callq 0x20f0
movq 0x28(%r15), %rdi
callq 0x26fa
cmpl $-0x1, %eax
je 0x86ca
movq 0x10(%r14), %rcx
movq (%rcx), %rcx
cltq
movq (%rcx,%rax,8), %rax
movq 0x10(%rax), %rdx
movl %ebx, %edi
movq %r12, %rsi
xorl %eax, %eax
callq 0x20f0
jmp 0x869d
movl %ebx, %edi
leaq 0x2476(%rip), %rsi      # 0xab49
xorl %eax, %eax
callq 0x20f0
incq %r13
jmp 0x8656
leaq 0x21db(%rip), %rsi      # 0xa8c4
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_O2/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 %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
movss %xmm0, 0x4(%rsp)
movl $0x190, %ecx            # imm = 0x190
movl %edi, %eax
cltd
idivl %ecx
movl %eax, %ebp
movl %eax, 0x5bcbe9(%rip)    # 0x5bde5c
pushq $0x41
popq %rcx
movl %edi, %eax
cltd
idivl %ecx
movl %eax, 0x5bcbdf(%rip)    # 0x5bde60
leaq 0x3e34(%rip), %rdi      # 0x50bc
movl $0x5b8d80, %edx         # imm = 0x5B8D80
xorl %esi, %esi
callq 0x1090
movss 0x4(%rsp), %xmm0
movss %xmm0, 0x5bcb9a(%rip)   # 0x5bde3c
movl %ebx, 0x5bcb98(%rip)    # 0x5bde40
movl %ebp, 0x5bcb96(%rip)    # 0x5bde44
movl %ebp, 0x5bcb94(%rip)    # 0x5bde48
xorps %xmm0, %xmm0
movups %xmm0, 0x5bcb8e(%rip)   # 0x5bde4c
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x5bcb80(%rip), %eax    # 0x5bde50
testl %eax, %eax
je 0x1328
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 0x1ec249(%rip), %rsi    # 0x1ed53c
callq 0x10e0
testl %r14d, %r14d
jle 0x131f
leaq 0x3db8(%rip), %rax      # 0x50bc
leaq (%rax,%r15,2), %rsi
addq $0x1e8480, %rsi         # imm = 0x1E8480
leaq 0x1ec226(%rip), %rdi    # 0x1ed53c
leal (%r14,%r14), %edx
callq 0x1110
movl %r14d, 0x5bcb2a(%rip)   # 0x5bde50
jmp 0x132a
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x5bcb0a(%rip), %rax    # 0x5bde44
movslq 0x5bcb1f(%rip), %rcx    # 0x5bde60
movl $0x119c, %edx           # imm = 0x119C
subq %rax, %rdx
subq %rcx, %rax
cvtsi2ss %eax, %xmm0
divss 0x5bcae4(%rip), %xmm0   # 0x5bde3c
addss 0x1ca4(%rip), %xmm0     # 0x3004
cvttss2si %xmm0, %ebx
addl 0x5bcae6(%rip), %ebx    # 0x5bde50
leaq 0x3d4b(%rip), %rsi      # 0x50bc
leaq (%rsi,%rcx,2), %rcx
leaq (%rcx,%rax,2), %rdi
addq %rdx, %rdx
xorl %esi, %esi
callq 0x1090
movl $0x119c, 0x5bcab7(%rip) # imm = 0x119C
xorl %edi, %edi
xorl %esi, %esi
callq 0x13c4
cmpl %ebx, 0x5bcab4(%rip)    # 0x5bde50
jle 0x13a4
movl %ebx, 0x5bcaac(%rip)    # 0x5bde50
movl 0x5bcab2(%rip), %eax    # 0x5bde5c
movl %eax, 0x5bca94(%rip)    # 0x5bde44
leaq 0x3d05(%rip), %rdi      # 0x50bc
movl $0x2338, %edx           # imm = 0x2338
xorl %esi, %esi
popq %rbx
jmp 0x1090
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movslq 0x30d40(%rdi), %rax
leaq 0x3895(%rip), %rcx      # 0x50bc
leaq (%rcx,%rax,2), %r14
cvtsi2sd %esi, %xmm0
movsd %xmm0, 0x8(%rsp)
movslq %esi, %rax
xorl %r15d, %r15d
testl %eax, %eax
movl $0x0, %r12d
cmovgl %eax, %r12d
movl %esi, 0x30d48(%rdi)
addq %rax, %rax
movq %r14, %r13
subq %rax, %r13
cmpq %r15, %r12
je 0x18c4
cvtsi2sd %r15d, %xmm0
mulsd 0x17b8(%rip), %xmm0     # 0x3020
divsd 0x8(%rsp), %xmm0
callq 0x10a0
movsd 0x17ad(%rip), %xmm1     # 0x3028
subsd %xmm0, %xmm1
mulsd 0x17a9(%rip), %xmm1     # 0x3030
cvtsd2ss %xmm1, %xmm0
movss 0x1775(%rip), %xmm1     # 0x3008
movswl (%r14,%r15,2), %eax
cvtsi2ss %eax, %xmm2
movswl (%r13,%r15,2), %eax
cvtsi2ss %eax, %xmm3
subss %xmm0, %xmm1
mulss %xmm1, %xmm2
mulss %xmm0, %xmm3
addss %xmm2, %xmm3
cvttss2si %xmm3, %eax
movw %ax, (%rbx,%r15,2)
incq %r15
jmp 0x1856
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp            # imm = 0x158
movq %rsi, %rbx
movl %edi, %ebp
pushq $0x1
popq %r15
movss 0xefe(%rip), %xmm0      # 0x3008
movss %xmm0, 0x8(%rsp)
leaq 0x10f8(%rip), %r14      # 0x320f
movl %ebp, %ecx
movslq %r15d, %rax
subl %r15d, %ecx
jle 0x2167
movq (%rbx,%rax,8), %rdx
cmpb $0x2d, (%rdx)
jne 0x2167
cmpb $0x73, 0x1(%rdx)
jne 0x2162
cmpb $0x0, 0x2(%rdx)
jne 0x2162
incl %r15d
cmpl %ebp, %r15d
jge 0x2162
movslq %r15d, %rax
movq (%rbx,%rax,8), %rdi
callq 0x1050
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x8(%rsp)
cvtss2sd %xmm0, %xmm0
movq %r14, %rdi
movb $0x1, %al
callq 0x1080
incl %r15d
jmp 0x2117
cmpl $0x2, %ecx
jne 0x226b
movq (%rbx,%rax,8), %r14
movq 0x8(%rbx,%rax,8), %r15
leaq 0x4(%rsp), %rsi
leaq 0xc(%rsp), %r12
movq %r14, %rdi
movq %r12, %rdx
callq 0x19c0
movl (%r12), %edx
cmpl $0x1, %edx
jne 0x2289
movq %rax, %rbx
testq %rax, %rax
je 0x22a3
movl 0x4(%rsp), %esi
leaq 0x1156(%rip), %rdi      # 0x3308
xorl %eax, %eax
callq 0x1080
movl 0x4(%rsp), %esi
pushq $0x1
popq %rdx
movq %r15, %rdi
callq 0x1bd3
testq %rax, %rax
je 0x22b9
movq %rax, %r14
movl 0x4(%rsp), %edi
movss 0x8(%rsp), %xmm0
callq 0x1256
leaq 0xb0(%rsp), %r15
pushq $0x50
popq %rbp
leaq 0x10(%rsp), %r12
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x1e00
movl %eax, %r13d
testl %eax, %eax
je 0x2214
movq %r15, %rdi
movl %r13d, %esi
callq 0x13c4
jmp 0x222e
callq 0x1332
jmp 0x222e
movq %r14, %rdi
movq %r12, %rsi
movl %eax, %edx
callq 0x1e88
incl 0x5bbc36(%rip)          # 0x5bde64
movq %r12, %rdi
movl %ebp, %esi
callq 0x12c5
testl %eax, %eax
jg 0x221b
incl 0x5bbc22(%rip)          # 0x5bde64
testl %r13d, %r13d
jg 0x21f3
movq %rbx, %rdi
callq 0x1cf1
movq %r14, %rdi
callq 0x1cf1
xorl %eax, %eax
addq $0x158, %rsp            # imm = 0x158
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2d86(%rip), %rax      # 0x4ff8
movq (%rax), %rcx
leaq 0xfac(%rip), %rdi       # 0x3228
pushq $0x72
popq %rsi
pushq $0x1
popq %rdx
callq 0x1140
jmp 0x22dc
movq 0x2d68(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x1001(%rip), %rsi      # 0x329b
xorl %eax, %eax
callq 0x10d0
jmp 0x22dc
movq 0x2d4e(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x1037(%rip), %rsi      # 0x32eb
movq %r14, %rdx
jmp 0x22d5
movq %rbx, %rdi
callq 0x1cf1
movq 0x2d30(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0xd95(%rip), %rsi       # 0x3067
movq %r15, %rdx
xorl %eax, %eax
callq 0x10d0
pushq $0x1
popq %rdi
callq 0x1130
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x32e0
testq %rax, %rax
je 0x370f
movq %rax, %rbx
movl %ebp, %eax
movq %rax, (%rbx)
decq %rax
xorl %r12d, %r12d
pushq $0x30
popq %rcx
xorl %edx, %edx
divq %rcx
movq %rax, %r15
leaq 0x1(%rax), %rdi
pushq $0x20
popq %rsi
callq 0x32e0
movq %rax, 0x8(%rbx)
testq %rax, %rax
jne 0x3723
movq %rbx, %rdi
callq 0x3050
xorl %ebx, %ebx
jmp 0x372b
movq %rcx, %rdx
shlq $0x5, %rdx
movq %r14, 0x8(%rax,%rdx)
leal 0x1(%rcx), %r12d
movl %r12d, %ecx
cmpq %rcx, %r15
jae 0x3713
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3864
movq %rcx, %rbx
movq %rdx, %r8
movq 0x8(%rdi), %r14
pushq $0x30
popq %rcx
movl %esi, %eax
xorl %edx, %edx
divl %ecx
xorl %ebp, %ebp
shll $0x5, %eax
movq 0x8(%r14,%rax), %r15
cmpq %rbx, %r15
jb 0x3864
movl %edx, %r13d
movq %r8, (%rsp)
addq %rax, %r14
leaq 0x18(%r14), %rdi
movl %edx, %esi
callq 0x3e91
movl %r13d, %r12d
pushq $0x1
popq %rdx
movl %r13d, %ecx
shll %cl, %edx
shrl $0x5, %r12d
movl 0x18(%r14,%r12,4), %ecx
btl %r13d, %ecx
movl %eax, %ecx
jae 0x37b9
movq 0x10(%r14), %r13
movq %r15, %rbp
movq (%rsp), %rsi
jmp 0x3842
movq %rax, 0x20(%rsp)
movl %edx, 0xc(%rsp)
movq %rcx, 0x10(%rsp)
movl (%r14), %eax
addq $0x8, %r15
movq 0x10(%r14), %rdi
movq %rax, 0x18(%rsp)
leal 0x1(%rax), %esi
imulq %r15, %rsi
callq 0x3440
testq %rax, %rax
movq (%rsp), %rsi
je 0x3864
movq %rax, %r13
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
subl %edi, %eax
imulq %rax, %r15
movq 0x8(%r14), %rbp
testq %r15, %r15
je 0x382d
incl %edi
leaq 0x8(%rbp), %rax
imulq %rax, %rdi
addq %r13, %rdi
movq 0x10(%rsp), %rsi
imulq %rax, %rsi
addq %r13, %rsi
movq %r15, %rdx
callq 0x34a0
movq (%rsp), %rsi
incl (%r14)
movq %r13, 0x10(%r14)
movl 0xc(%rsp), %eax
orl %eax, 0x18(%r14,%r12,4)
movq 0x10(%rsp), %rcx
addq $0x8, %rbp
imulq %rcx, %rbp
leaq 0x8(,%rbp), %rdi
addq %r13, %rdi
movq %rbx, -0x8(%rdi)
movq %rbx, %rdx
callq 0x3350
pushq $0x1
popq %rbp
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_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %eax
cmpq %rax, (%rdi)
jae 0x388c
xorl %r14d, %r14d
jmp 0x38fd
movq %rdx, %rbx
movq 0x8(%rdi), %r12
pushq $0x30
popq %rcx
movl %esi, %eax
xorl %edx, %edx
divl %ecx
movl %eax, %r15d
movl %edx, %ebp
xorl %r14d, %r14d
shll $0x5, %r15d
leaq (%r12,%r15), %r13
leaq (%r12,%r15), %rdi
addq $0x18, %rdi
movl %edx, %esi
callq 0x3e91
movl %ebp, %ecx
shrl $0x3, %ecx
andl $0x4, %ecx
movl 0x18(%rcx,%r13), %ecx
btl %ebp, %ecx
jae 0x38fd
movq 0x8(%r12,%r15), %rcx
movq 0x10(%r12,%r15), %rdx
movl %eax, %eax
addq $0x8, %rcx
imulq %rax, %rcx
leaq (%rdx,%rcx), %rax
movq (%rax), %rax
testq %rax, %rax
je 0x3887
leaq (%rdx,%rcx), %r14
addq $0x8, %r14
testq %rbx, %rbx
je 0x38fd
movq %rax, (%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %eax, %eax
pushq $0x30
popq %r14
movl %eax, %r15d
movq (%rbx), %rax
movq 0x8(%rbx), %rdi
decq %rax
xorl %edx, %edx
divq %r14
cmpq %r15, %rax
jb 0x394b
movq %r15, %rax
shlq $0x5, %rax
movq 0x10(%rdi,%rax), %rdi
callq 0x3050
leal 0x1(%r15), %eax
jmp 0x391d
callq 0x3050
movq %rbx, %rdi
callq 0x3050
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rdi
pushq $0x18
popq %rsi
callq 0x32e0
testq %rax, %rax
je 0x3998
movq %rax, %rbx
movq $0x20, (%rax)
pushq $0x28
popq %rdi
pushq $0x20
popq %rsi
callq 0x3570
movq %rax, 0x10(%rbx)
testq %rax, %rax
jne 0x399a
movq %rbx, %rdi
callq 0x3050
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/qpfiffer[P]38-Moths/src/simple_sparsehash.c
// Function: create_and_insert_new_bucket
static int _create_and_insert_new_bucket(
		struct sparse_array *array, const unsigned int i,
		const char *key, const size_t klen,
		const void *value, const size_t vlen,
		const uint64_t key_hash) {
	void *copied_value = NULL;
	char *copied_key = NULL;

	copied_value = malloc(vlen + klen);
	if (copied_value == NULL)
		goto error;
	memcpy(copied_value, value, vlen);

	copied_key = copied_value + vlen;
	strncpy(copied_key, key, klen);

	struct sparse_bucket bct = {
		.key = copied_key,
		.klen = klen,
		.val = copied_value,
		.vlen = vlen,
		.hash = key_hash
	};

	if (!sparse_array_set(array, i, &bct, sizeof(bct)))
		goto error;

	return 1;

error:
	free(copied_value);
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %r14
movq %r8, %rbp
movq %rcx, %r12
movq %rdx, %r13
movl %esi, 0xc(%rsp)
movq %rdi, %r15
leaq (%r9,%rcx), %rdi
callq 0x33a0
movq %rax, %rbx
testq %rax, %rax
je 0x3d30
movq %rbx, %rdi
movq %rbp, %rsi
movq %r14, %rdx
callq 0x3350
movq %rbx, %rbp
addq %r14, %rbp
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x30a0
leaq 0x10(%rsp), %rdx
movq %rbp, (%rdx)
movq %r12, 0x8(%rdx)
movq %rbx, 0x10(%rdx)
movq %r14, 0x18(%rdx)
movq 0x70(%rsp), %rax
movq %rax, 0x20(%rdx)
pushq $0x28
popq %rcx
movq %r15, %rdi
movl 0xc(%rsp), %esi
callq 0x3070
testl %eax, %eax
je 0x3d30
pushq $0x1
popq %rax
jmp 0x3d3a
movq %rbx, %rdi
callq 0x3050
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rdi, %r12
movq %rsi, 0x20(%rsp)
movq %rsi, %rdi
movq %rdx, 0x8(%rsp)
movq %rdx, %rsi
callq 0x3c75
movq %rax, %rbp
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
addq (%r12), %r15
movq 0x10(%r12), %rbx
pushq $0x1
popq %r14
movq $0x0, (%rsp)
andq $0x0, 0x10(%rsp)
leal -0x1(%r14), %esi
imull %esi, %esi
addl %ebp, %esi
andl %r15d, %esi
movq %rbx, %rdi
leaq 0x10(%rsp), %rdx
callq 0x3430
cmpq $0x0, 0x10(%rsp)
je 0x3e11
movq %rax, %r13
testq %rax, %rax
je 0x3e11
cmpq %rbp, 0x20(%r13)
jne 0x3de9
movq 0x8(%r13), %rdx
cmpq 0x8(%rsp), %rdx
ja 0x3dd7
movq 0x8(%rsp), %rdx
movq (%r13), %rdi
movq 0x20(%rsp), %rsi
callq 0x30b0
testl %eax, %eax
je 0x3df8
movl %r14d, %eax
incl %r14d
cmpq %rax, 0x8(%r12)
jae 0x3d92
jmp 0x3e11
movq 0x18(%rsp), %rcx
testq %rcx, %rcx
je 0x3e09
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_O2/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 %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorl %ebp, %ebp
leaq 0x8(%rsp), %r14
movl %ebp, %eax
cmpq %rax, (%rbx)
jbe 0x3e74
andq $0x0, 0x8(%rsp)
movq 0x10(%rbx), %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x3430
cmpq $0x0, 0x8(%rsp)
setne %cl
testq %rax, %rax
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x3e70
movq 0x10(%rax), %rdi
callq 0x3050
incl %ebp
jmp 0x3e36
movq 0x10(%rbx), %rdi
callq 0x3230
movq %rbx, %rdi
callq 0x3050
pushq $0x1
popq %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
xorl %r14d, %r14d
cmpl $0x20, %ebp
jb 0x3eb5
movl (%rbx), %edi
callq 0x3ecd
addl %eax, %r14d
addl $-0x20, %ebp
addq $0x4, %rbx
jmp 0x3e9d
pushq $-0x1
popq %rdi
movl %ebp, %ecx
shll %cl, %edi
notl %edi
andl (%rbx), %edi
callq 0x3ecd
addl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/qpfiffer[P]38-Moths/src/simple_sparsehash.c
// Function: popcount_32
static inline uint32_t popcount_32(uint32_t x) {
	const uint32_t m1 = 0x55555555;
	const uint32_t m2 = 0x33333333;
	const uint32_t m4 = 0x0f0f0f0f;
	x -= (x >> 1) & m1;
	x = (x & m2) + ((x >> 2) & m2);
	x = (x + (x >> 4)) & m4;
	x += x >>  8;
	return (x + (x >> 16)) & 0x3f;
}

// Assembly:
movl %edi, %eax
shrl %eax
andl $0x55555555, %eax       # imm = 0x55555555
subl %eax, %edi
movl $0x33333333, %eax       # imm = 0x33333333
movl %edi, %ecx
andl %eax, %ecx
shrl $0x2, %edi
andl %eax, %edi
addl %ecx, %edi
movl %edi, %eax
shrl $0x4, %eax
addl %edi, %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
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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, %r14
movq %rdi, %r12
callq 0x3150
movq %rax, %r15
addq %r12, %r15
leaq 0x5103(%rip), %r13      # 0x902e
leaq 0x4(%rsp), %rbp
xorl %ebx, %ebx
cmpq %r15, %r12
ja 0x3fbc
leaq 0x1(%r12), %rdi
movzbl (%r12), %eax
movsbl %al, %ecx
movl %ecx, 0x4(%rsp)
cmpl $0x25, %eax
je 0x3f63
cmpl $0x2b, %eax
jne 0x3f5e
movl $0x20, 0x4(%rsp)
movq %rdi, %r12
jmp 0x3fa7
movsbl (%rdi), %eax
leal -0x3a(%rax), %ecx
cmpl $-0xb, %ecx
ja 0x3f79
andl $-0x21, %eax
addl $-0x47, %eax
cmpl $-0x6, %eax
jb 0x3fc0
movsbl 0x2(%r12), %eax
leal -0x3a(%rax), %ecx
cmpl $-0xb, %ecx
ja 0x3f92
andl $-0x21, %eax
addl $-0x47, %eax
cmpl $-0x6, %eax
jb 0x3fc0
movq %r13, %rsi
movq %rbp, %rdx
xorl %eax, %eax
callq 0x33e0
testl %eax, %eax
je 0x3fc0
addq $0x3, %r12
testq %r14, %r14
je 0x3fb4
movb 0x4(%rsp), %al
movb %al, (%r14,%rbx)
incq %rbx
jmp 0x3f32
movl %ebx, %eax
jmp 0x3fc3
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/qpfiffer[P]38-Moths/src/utils.c
// Function: endswith
int endswith(const char *string, const char *suffix) {
	size_t string_siz = strlen(string);
	size_t suffix_siz = strlen(suffix);

	if (string_siz < suffix_siz)
		return 0;

	unsigned int i = 0;
	for (; i < suffix_siz; i++) {
		if (suffix[i] != string[string_siz - suffix_siz + i])
			return 0;
	}
	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x3150
movq %rax, %r15
movq %rbx, %rdi
callq 0x3150
subq %rax, %r15
jb 0x4011
movq %rax, %rcx
addq %r15, %r14
xorl %esi, %esi
pushq $0x1
popq %rax
movl %esi, %edx
cmpq %rdx, %rcx
jbe 0x4013
movb (%rbx,%rdx), %dil
leal 0x1(%rdx), %esi
cmpb (%r14,%rdx), %dil
je 0x3ffd
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/qpfiffer[P]38-Moths/src/utils.c
// Function: strnstr
char *strnstr(const char *haystack, const char *needle, size_t len) {
	int i;
	size_t needle_len;

	/* segfault here if needle is not NULL terminated */
	if (0 == (needle_len = strlen(needle)))
		return (char *)haystack;

	/* Limit the search if haystack is shorter than 'len' */
	len = strnlen(haystack, len);

	for (i=0; i<(int)(len-needle_len); i++)
	{
		if ((haystack[0] == needle[0]) && (0 == strncmp(haystack, needle, needle_len)))
			return (char *)haystack;

		haystack++;
	}
	return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x3150
testq %rax, %rax
je 0x407a
movq %rax, %r15
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3240
movq %rax, %r12
subl %r15d, %r12d
xorl %eax, %eax
testl %r12d, %r12d
cmovlel %eax, %r12d
subl $0x1, %r12d
jb 0x4078
movb (%rbx), %al
cmpb (%r14), %al
jne 0x4073
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x30b0
testl %eax, %eax
je 0x407a
incq %rbx
jmp 0x4054
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/qpfiffer[P]38-Moths/src/utils.c
// Function: hash_string_fnv1a
int hash_string_fnv1a(const unsigned char *key, const size_t siz, char outbuf[static HASH_STR_SIZE]) {
	/* https://en.wikipedia.org/wiki/Fowler_Noll_Vo_hash */
	const uint64_t fnv_prime = 1099511628211ULL;
	const uint64_t fnv_offset_bias = 14695981039346656037ULL;

	const int iterations = siz;

	uint8_t i;
	uint64_t hash = fnv_offset_bias;

	for(i = 0; i < iterations; i++) {
		hash = hash ^ key[i];
		hash = hash * fnv_prime;
	}

	sprintf(outbuf, "%"PRIX64, hash);
	return 1;
}

// Assembly:
movq %rdx, %rax
xorl %ecx, %ecx
testl %esi, %esi
cmovlel %ecx, %esi
movabsq $-0x340d631b7bdddcdb, %rdx # imm = 0xCBF29CE484222325
movabsq $0x100000001b3, %r8     # imm = 0x100000001B3
cmpq %rcx, %rsi
je 0x414d
movzbl (%rdi,%rcx), %r9d
xorq %r9, %rdx
imulq %r8, %rdx
incq %rcx
jmp 0x4137
pushq %rax
leaq 0x4edd(%rip), %rsi      # 0x9032
movq %rax, %rdi
xorl %eax, %eax
callq 0x3560
pushq $0x1
popq %rax
popq %rcx
retq