LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/MaoKo[P]FGFX/fgfp/src/lr.c
// Function: print_report
void
print_report(cfg_t const* cfg, vector_t const* lr1_states) {
	for (size_t i = 0; i < SIZE_VECTOR(lr1_states); ++i) {
		printf("===== State %zu =====\n", i);
		lr1_state_t* state = AT_VECTOR(lr1_states, i);
		if (state->accept)
			{ printf("(Accept): "); }
		print_state(cfg, state->items);

		print_move(cfg, state->shift_lst, _SHIFT);
		print_move(cfg, state->goto_lst, _GOTO);

		trans_list_t* list = NULL;
		list = state->reduces;
		while (list) {
			printf("TOKEN(%s) => REDUCE(%d).\n",
				((symbol_t*)AT_VECTOR(cfg->terminal, list->input))->name,
				(_REDUCE ^ list->state) + 1);
			list = list->next;
		}
	}
}

// Assembly:
cmpq $0x0, 0x10(%rsi)
je 0x8031
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x4000, %r15d          # imm = 0x4000
leaq 0x287c(%rip), %r13      # 0xa7fb
xorl %r12d, %r12d
movq %rsi, -0x30(%rbp)
leaq 0x284c(%rip), %rdi      # 0xa7d9
movq %r12, %rsi
xorl %eax, %eax
callq 0x20a0
movq (%rbx), %rax
movq (%rax,%r12,8), %rbx
cmpb $0x1, 0x29(%rbx)
jne 0x7fb2
leaq 0x2845(%rip), %rdi      # 0xa7f0
xorl %eax, %eax
callq 0x20a0
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x7eea
movq 0x10(%rbx), %rsi
movq %r14, %rdi
movl $0x1000, %edx           # imm = 0x1000
callq 0x8032
movq 0x18(%rbx), %rsi
movq %r14, %rdi
movl $0x2000, %edx           # imm = 0x2000
callq 0x8032
movq 0x20(%rbx), %rbx
testq %rbx, %rbx
je 0x8012
movq 0x10(%r14), %rax
movq (%rax), %rax
movslq 0x8(%rbx), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rsi
movl 0xc(%rbx), %edx
xorl %r15d, %edx
incl %edx
movq %r13, %rdi
xorl %eax, %eax
callq 0x20a0
movq (%rbx), %rbx
jmp 0x7fe3
incq %r12
movq -0x30(%rbp), %rbx
cmpq 0x10(%rbx), %r12
jb 0x7f86
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/MaoKo[P]FGFX/fgfp/src/lr.c
// Function: print_move
static void
print_move(cfg_t const* cfg, trans_list_t* list, int kind) {
	char const* pattern = (kind == _SHIFT) ? "SHIFT" : "GOTO";
	vector_t const* src_vect = (kind == _SHIFT)
							? cfg->terminal : cfg->non_terminal;
	while (list) {
		if (kind & list->input) {
			printf("%s(%s)", pattern, ((symbol_t*)
				AT_VECTOR(src_vect, list->input ^ kind))->name);
		}
		printf(" into state %d.\n", list->state);
		list = list->next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
xorl %eax, %eax
cmpl $0x1000, %edx           # imm = 0x1000
sete %cl
leaq 0x27f6(%rip), %rdx      # 0xa84a
leaq 0x27f5(%rip), %r15      # 0xa850
cmoveq %rdx, %r15
testq %rsi, %rsi
je 0x80b4
movq %rsi, %r14
movb %cl, %al
movq 0x8(%rdi,%rax,8), %r13
leaq 0x27e7(%rip), %r12      # 0xa85c
movl 0x8(%r14), %eax
testl %ebx, %eax
je 0x809e
movq (%r13), %rcx
xorl %ebx, %eax
cltq
movq (%rcx,%rax,8), %rax
movq 0x10(%rax), %rdx
leaq 0x27c1(%rip), %rdi      # 0xa855
movq %r15, %rsi
xorl %eax, %eax
callq 0x20a0
movl 0xc(%r14), %esi
movq %r12, %rdi
xorl %eax, %eax
callq 0x20a0
movq (%r14), %r14
testq %r14, %r14
jne 0x8075
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/MaoKo[P]FGFX/fgfp/src/lr.c
// Function: del_lr1_item
static void
del_lr1_item(lr1_item_t* item) {
	if (item) { 
		del_bitset(item->lookahead);
//		del_vector(item->non_kernel_look);
	}
	FREE(item);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
je 0x80da
movq 0x10(%rbx), %rdi
callq 0x248a
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x21d0
// File: /workspace/github_c_makefile_star2_O1/MaoKo[P]FGFX/fgfp/src/lr.c
// Function: del_kernel
static void
del_kernel(kernel_t* kernel) {
	if (kernel) {
		del_bitset(kernel->kernel_item);
		if (!kernel->ref_lr0)
			{ del_vector(kernel->non_lr0_kernel_item); }
		del_bitset(kernel->final_state);
	}
	FREE(kernel);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
je 0x8116
movq (%rbx), %rdi
callq 0x248a
cmpb $0x0, 0x10(%rbx)
jne 0x810d
movq 0x18(%rbx), %rdi
callq 0x2b9e
movq 0x20(%rbx), %rdi
callq 0x248a
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x21d0
// File: /workspace/github_c_makefile_star2_O1/MaoKo[P]FGFX/fgfp/src/lr.c
// Function: new_lr0_item
static lr0_item_t*
new_lr0_item(production_t const* prod, list_rhs_t const* dot_pos) {
	if (!prod)
		{ return (NULL); }

	size_t hash = hash_lr0_item(prod, dot_pos);
	if (!record_lr0_item[hash])
		{ record_lr0_item[hash] = new_vector(); }

	for (size_t i = 0; i < SIZE_VECTOR(record_lr0_item[hash]); ++i) {
		lr0_item_t* target = (lr0_item_t*)AT_VECTOR(record_lr0_item[hash], i);
		if ((target->prod == prod) && (target->dot_pos == dot_pos))
			{ return (target); }
	}

	lr0_item_t* item = NEW(lr0_item_t, 1);
	if (!item)
		{ return (NULL); }

	memset(item, 0, sizeof(lr0_item_t));
	item->prod = prod;
	item->dot_pos = dot_pos;

	if (!DOT(item))
		{ item->is_final = true; }

	PUSH_BACK_VECTOR(record_lr0_item[hash], item);
	return (item);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x824a
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %r12
testq %rsi, %rsi
je 0x8175
addq 0x10(%rbx), %r12
movq %r12, %rax
shrq %rax
movabsq $-0x5c28f5c28f5c28f5, %rcx # imm = 0xA3D70A3D70A3D70B
mulq %rcx
shrq $0x4, %rdx
imulq $0x32, %rdx, %rax
subq %rax, %r12
movl %r12d, %eax
leaq 0x14d13(%rip), %r13     # 0x1ceb0
cmpq $0x0, (%r13,%rax,8)
jne 0x81af
callq 0x2afc
movq %rax, (%r13,%r12,8)
movq (%r13,%r12,8), %rdx
movq 0x10(%rdx), %rcx
testq %rcx, %rcx
setne %al
je 0x8206
movq (%rdx), %rdx
movq %rcx, %rsi
negq %rsi
movl $0x1, %edi
movq -0x8(%rdx,%rdi,8), %r8
cmpq %r14, (%r8)
jne 0x81de
cmpq %rbx, 0x8(%r8)
je 0x81fe
movb $0x1, %r9b
testb %r9b, %r9b
je 0x8206
cmpq %rcx, %rdi
setb %al
leaq (%rsi,%rdi), %r8
incq %r8
incq %rdi
cmpq $0x1, %r8
jne 0x81ce
jmp 0x8206
xorl %r9d, %r9d
movq %r8, %r15
jmp 0x81e1
testb $0x1, %al
jne 0x824d
movl $0x20, %edi
callq 0x3b0a
testq %rax, %rax
je 0x824a
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movq %r14, (%rax)
movq %rbx, 0x8(%rax)
testq %rbx, %rbx
jne 0x8237
movb $0x1, 0x10(%r15)
movq (%r13,%r12,8), %rdi
movq 0x10(%rdi), %rsi
movq %r15, %rdx
callq 0x2bf1
jmp 0x824d
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x82bc
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x14c24(%rip)     # 0x1cea0
jne 0x828a
callq 0x2afc
movq %rax, 0x14c16(%rip)     # 0x1cea0
movl $0x18, %edi
callq 0x3b0a
testq %rax, %rax
je 0x82bc
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %r14, %rdi
callq 0x24b8
movq %rax, 0x10(%r15)
movq %rbx, 0x8(%r15)
jmp 0x82bf
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x5c82
testq %rax, %rax
je 0x833c
movq %rax, %r14
movq 0x8(%r15), %rax
movq (%rax), %rdi
callq 0x5c24
testb %al, %al
je 0x832e
xorl %edi, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x27c9
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 0x24b8
// File: /workspace/github_c_makefile_star2_O1/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 %rcx, -0x40(%rbp)
movq %rsi, -0x38(%rbp)
movq 0x18(%rdi), %rax
cmpq $0x0, 0x10(%rax)
je 0x83d5
movq %rdx, %r13
xorl %ebx, %ebx
xorl %r14d, %r14d
movq %rdi, -0x30(%rbp)
movq -0x40(%rbp), %r15
movq (%rax), %rax
movq (%rax,%r14,8), %rax
movq (%rax), %rax
cmpq %r13, 0x8(%rax)
jne 0x83c6
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq (%rax,%r14,8), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x298e
movzbl %bl, %ebx
testb %al, %al
movl $0x1, %eax
cmovel %eax, %ebx
xorl %edi, %edi
movq %r12, %rsi
movq %r15, %rdx
callq 0x27c9
movq -0x30(%rbp), %rdi
incq %r14
movq 0x18(%rdi), %rax
cmpq 0x10(%rax), %r14
jb 0x8382
jmp 0x83d7
xorl %ebx, %ebx
andb $0x1, %bl
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x246e(%rip), %rsi      # 0xa86d
xorl %eax, %eax
callq 0x20f0
leaq 0x2476(%rip), %rsi      # 0xa883
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 0x8997
leaq 0x2546(%rip), %rsi      # 0xa98c
movl %ebx, %edi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x20f0
// File: /workspace/github_c_makefile_star2_O1/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 0x2426(%rip), %rsi      # 0xa899
xorl %eax, %eax
callq 0x20f0
movl %ebx, %edi
movq %r14, %rsi
callq 0x3fa6
leaq 0x241a(%rip), %rsi      # 0xa8a5
movl %ebx, %edi
xorl %eax, %eax
callq 0x20f0
cmpq $0x0, 0x10(%r12)
je 0x855a
xorl %r13d, %r13d
movq %r12, -0x30(%rbp)
movq (%r12), %rax
movq (%rax,%r13,8), %r12
testq %r12, %r12
leaq 0x269f(%rip), %r14      # 0xab58
je 0x8535
movl %ebx, %edi
leaq 0x23d3(%rip), %rsi      # 0xa897
xorl %eax, %eax
callq 0x20f0
movl %ebx, %edi
leaq 0x2635(%rip), %rsi      # 0xab09
xorl %eax, %eax
callq 0x20f0
movl %ebx, %edi
movq %r15, %rsi
movq %r13, %rdx
movl $0x1, %ecx
callq 0x8997
movq 0x10(%r15), %rax
movq (%rax), %rax
movslq 0x8(%r12), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rdx
movl %ebx, %edi
leaq 0x23c3(%rip), %rsi      # 0xa8cd
xorl %eax, %eax
callq 0x20f0
movslq 0xc(%r12), %rdx
movl %ebx, %edi
movq %r15, %rsi
callq 0x8b94
movl %ebx, %edi
movq %r14, %rsi
xorl %eax, %eax
callq 0x20f0
movq (%r12), %r12
testq %r12, %r12
jne 0x84cb
movl $0x1, %edx
movl %ebx, %edi
leaq 0x2517(%rip), %rsi      # 0xaa5a
callq 0x2080
incq %r13
movq -0x30(%rbp), %r12
cmpq 0x10(%r12), %r13
jb 0x84a7
leaq 0x2375(%rip), %rsi      # 0xa8d6
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_O1/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 0x2354(%rip), %rsi      # 0xa8db
xorl %eax, %eax
callq 0x20f0
leaq 0x234e(%rip), %rsi      # 0xa8e3
movl %ebx, %edi
xorl %eax, %eax
callq 0x20f0
leaq 0x2351(%rip), %rsi      # 0xa8f6
movl %ebx, %edi
xorl %eax, %eax
callq 0x20f0
leaq 0x2355(%rip), %rsi      # 0xa90a
movl %ebx, %edi
xorl %eax, %eax
callq 0x20f0
leaq 0x2311(%rip), %rsi      # 0xa8d6
movl %ebx, %edi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x20f0
// File: /workspace/github_c_makefile_star2_O1/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 0x2339(%rip), %rsi      # 0xa91c
xorl %eax, %eax
callq 0x20f0
leaq 0x234a(%rip), %rsi      # 0xa93b
movl %ebx, %edi
xorl %eax, %eax
callq 0x20f0
leaq 0x235b(%rip), %rsi      # 0xa95c
movl %ebx, %edi
xorl %eax, %eax
callq 0x20f0
leaq 0x2368(%rip), %rsi      # 0xa979
movl %ebx, %edi
xorl %eax, %eax
callq 0x20f0
leaq 0x236e(%rip), %rsi      # 0xa98f
movl %ebx, %edi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x20f0
// File: /workspace/github_c_makefile_star2_O1/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 0x206c(%rip), %rsi      # 0xa899
xorl %eax, %eax
callq 0x20f0
movl %ebx, %edi
movq %r14, %rsi
callq 0x3fa6
movq 0x10(%r12), %rdx
leaq 0x21c5(%rip), %rsi      # 0xaa0f
movl %ebx, %edi
xorl %eax, %eax
callq 0x20f0
cmpq $0x0, 0x10(%r12)
je 0x890e
movq %r12, %rax
leaq 0x22a0(%rip), %r12      # 0xab09
leaq 0x21c4(%rip), %r13      # 0xaa34
xorl %edx, %edx
movq %rax, -0x30(%rbp)
movq (%rax), %rax
movq (%rax,%rdx,8), %r14
movl %ebx, %edi
leaq 0x214c(%rip), %rsi      # 0xa9d2
movq %rdx, -0x38(%rbp)
xorl %eax, %eax
callq 0x20f0
movq 0x18(%r14), %r14
movl %ebx, %edi
testq %r14, %r14
je 0x88eb
movq %r12, %rsi
xorl %eax, %eax
callq 0x20f0
movslq 0x8(%r14), %rdx
xorq $0x2000, %rdx           # imm = 0x2000
movl %ebx, %edi
movq %r15, %rsi
movl $0x1, %ecx
callq 0x8997
movl 0xc(%r14), %edx
movl %ebx, %edi
movq %r13, %rsi
xorl %eax, %eax
callq 0x20f0
cmpq $0x0, (%r14)
je 0x88e6
movl %ebx, %edi
leaq 0x2279(%rip), %rsi      # 0xab58
xorl %eax, %eax
callq 0x20f0
movq (%r14), %r14
jmp 0x8895
leaq 0x226c(%rip), %rsi      # 0xab5e
xorl %eax, %eax
callq 0x20f0
movq -0x38(%rbp), %rdx
incq %rdx
movq -0x30(%rbp), %rax
cmpq 0x10(%rax), %rdx
jb 0x8876
leaq 0x1fc1(%rip), %rsi      # 0xa8d6
movl %ebx, %edi
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20f0
// File: /workspace/github_c_makefile_star2_O1/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 0x20fc(%rip), %rsi      # 0xaa3f
xorl %eax, %eax
callq 0x20f0
movq 0x18(%r14), %rax
cmpq $0x0, 0x10(%rax)
je 0x897f
leaq 0x2100(%rip), %r15      # 0xaa5c
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 0x895f
leaq 0x20e5(%rip), %rsi      # 0xaa6b
movl %ebx, %edi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x20f0
// File: /workspace/github_c_makefile_star2_O1/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 0x8a0a
cmpl $0x0, 0x38(%r13)
leaq 0x20bc(%rip), %rax      # 0xaa87
leaq 0x20b9(%rip), %rsi      # 0xaa8b
cmoveq %rax, %rsi
movl %ebx, %edi
xorl %eax, %eax
callq 0x20f0
testb %r12b, %r12b
je 0x89f4
leaq 0x155b(%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 0x8a1a
movq $0x0, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
leaq 0x1282(%rip), %rsi      # 0x9ca3
movl %ebx, %edi
xorl %eax, %eax
callq 0x20f0
testb %r12b, %r12b
je 0x8a3f
leaq 0x1510(%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 0x8aa0
movl $0x2, %r15d
subq %rax, %r15
movl $0x1, %r14d
leaq 0x2027(%rip), %r12      # 0xaa8f
movq 0x10(%r13), %rsi
cmpb $0x27, (%rsi,%r14)
jne 0x8a81
movl %ebx, %edi
movq %r12, %rsi
xorl %eax, %eax
callq 0x20f0
jmp 0x8a90
addq %r14, %rsi
movl $0x1, %edx
movl %ebx, %edi
callq 0x2080
leaq (%r15,%r14), %rax
incq %rax
incq %r14
cmpq $0x1, %rax
jne 0x8a68
movq -0x38(%rbp), %rcx
testq %rcx, %rcx
je 0x8acb
leaq 0x1fe6(%rip), %rsi      # 0xaa96
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_O1/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 0x1de7(%rip), %rsi      # 0xa8db
xorl %eax, %eax
callq 0x20f0
movq 0x8(%r14), %rax
cmpq $0x1, 0x10(%rax)
je 0x8b54
leaq 0x1d8a(%rip), %r15      # 0xa897
leaq 0x1ddf(%rip), %r12      # 0xa8f3
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 0x8997
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 0x8b17
leaq 0x1d7b(%rip), %rsi      # 0xa8d6
movl %ebx, %edi
xorl %eax, %eax
callq 0x20f0
movq 0x8(%r14), %rax
movq 0x10(%rax), %rcx
decq %rcx
leaq 0x1f29(%rip), %rsi      # 0xaa9f
leaq 0x1f33(%rip), %rdx      # 0xaab0
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_O1/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 0x1f09(%rip), %rsi      # 0xaabb
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 0x8997
leaq 0x1ee4(%rip), %rsi      # 0xaac2
movl %r14d, %edi
xorl %eax, %eax
callq 0x20f0
movq 0x10(%r15), %r13
testq %r13, %r13
je 0x8c42
leaq 0x134e(%rip), %r15      # 0x9f46
leaq 0x1ec8(%rip), %r12      # 0xaac7
movl %r14d, %edi
movq %r15, %rsi
xorl %eax, %eax
callq 0x20f0
movq 0x8(%r13), %rax
cmpl $0x2d, 0x8(%rax)
jne 0x8c29
movq 0x10(%rax), %rdx
movl %r14d, %edi
movq %r12, %rsi
xorl %eax, %eax
callq 0x20f0
jmp 0x8c39
movq (%rax), %rdx
movl %r14d, %edi
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0x8997
movq (%r13), %r13
testq %r13, %r13
jne 0x8bff
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1c70(%rip), %rsi      # 0xa8db
xorl %eax, %eax
callq 0x20f0
movq (%r14), %rax
cmpq $0x1, 0x10(%rax)
je 0x8cc4
leaq 0x1c14(%rip), %r15      # 0xa897
leaq 0x1c69(%rip), %r12      # 0xa8f3
xorl %r13d, %r13d
movl %ebx, %edi
movq %r15, %rsi
xorl %eax, %eax
callq 0x20f0
movl %ebx, %edi
movq %r14, %rsi
movq %r13, %rdx
callq 0x8b94
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 0x8c8d
leaq 0x1c0b(%rip), %rsi      # 0xa8d6
movl %ebx, %edi
xorl %eax, %eax
callq 0x20f0
movq (%r14), %rax
movq 0x10(%rax), %rdx
leaq 0x1de9(%rip), %rsi      # 0xaacb
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_O1/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 0x1b83(%rip), %rsi      # 0xa899
xorl %eax, %eax
callq 0x20f0
movl %ebx, %edi
movq %r15, %rsi
callq 0x3fa6
leaq 0x1db6(%rip), %rsi      # 0xaae4
leaq 0x1dc8(%rip), %rdx      # 0xaafd
movl %ebx, %edi
xorl %eax, %eax
callq 0x20f0
movq (%r14), %rax
cmpq $0x1, 0x10(%rax)
je 0x8da0
leaq 0x1dbc(%rip), %r12      # 0xab0b
xorl %r13d, %r13d
movq (%rax), %rax
movq (%rax,%r13,8), %r15
movl %ebx, %edi
leaq 0x1da6(%rip), %rsi      # 0xab08
xorl %eax, %eax
callq 0x20f0
movl %ebx, %edi
movq %r14, %rsi
movq %r13, %rdx
callq 0x8b94
movq 0x10(%r15), %rdi
callq 0x3bde
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 0x8d52
leaq 0x1b2f(%rip), %rsi      # 0xa8d6
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_O1/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 0x1abe(%rip), %rsi      # 0xa899
xorl %eax, %eax
callq 0x20f0
movl %ebx, %edi
movq %r15, %rsi
callq 0x3fa6
leaq 0x1d22(%rip), %rsi      # 0xab15
leaq 0x1d03(%rip), %rdx      # 0xaafd
movl %ebx, %edi
xorl %eax, %eax
callq 0x20f0
movq (%r14), %rax
cmpq $0x1, 0x10(%rax)
je 0x8e80
leaq 0x1adf(%rip), %r13      # 0xa8f3
xorl %r15d, %r15d
movq (%rax), %rax
movq (%rax,%r15,8), %r12
movl %ebx, %edi
leaq 0x1ce1(%rip), %rsi      # 0xab08
xorl %eax, %eax
callq 0x20f0
movl %ebx, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x8b94
movl %ebx, %edi
leaq 0x1cea(%rip), %rsi      # 0xab2e
xorl %eax, %eax
callq 0x20f0
movq 0x8(%r12), %rax
movq (%rax), %rdx
movl %ebx, %edi
movq %r14, %rsi
movl $0x1, %ecx
callq 0x8997
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 0x8e17
leaq 0x1a4f(%rip), %rsi      # 0xa8d6
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_O1/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 0x19de(%rip), %rsi      # 0xa899
xorl %eax, %eax
callq 0x20f0
movl %ebx, %edi
movq %r15, %rsi
callq 0x3fa6
movq 0x8(%r14), %r12
movl $0x1, %r15d
cmpq $0x1, 0x10(%r12)
je 0x8f0f
xorl %r15d, %r15d
xorl %r13d, %r13d
movq (%r12), %rax
movq (%rax,%r13,8), %rax
movq 0x28(%rax), %rdi
callq 0x2a59
cmpq %r15, %rax
cmovaq %rax, %r15
incq %r13
movq 0x10(%r12), %rax
decq %rax
cmpq %rax, %r13
jb 0x8ee4
incq %r15
leaq 0x1c1d(%rip), %rsi      # 0xab33
leaq 0x1b93(%rip), %rdx      # 0xaab0
movl %ebx, %edi
movq %r15, %rcx
xorl %eax, %eax
callq 0x20f0
movq 0x8(%r14), %rax
cmpq $0x1, 0x10(%rax)
je 0x8fcf
leaq 0x1c15(%rip), %r15      # 0xab54
xorl %r12d, %r12d
movq (%rax), %rax
movq (%rax,%r12,8), %r13
movl %ebx, %edi
leaq 0x1bb6(%rip), %rsi      # 0xab08
xorl %eax, %eax
callq 0x20f0
movl %ebx, %edi
movq %r14, %rsi
movq %r12, %rdx
movl $0x1, %ecx
callq 0x8997
movl %ebx, %edi
leaq 0x1bd9(%rip), %rsi      # 0xab4d
xorl %eax, %eax
callq 0x20f0
movq 0x28(%r13), %rdi
callq 0x28eb
cmpl $-0x1, %eax
je 0x8fa8
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 0x8f7b
movl %ebx, %edi
leaq 0x1baa(%rip), %rsi      # 0xab5b
xorl %eax, %eax
callq 0x20f0
incq %r12
movq 0x8(%r14), %rax
movq 0x10(%rax), %rcx
decq %rcx
cmpq %rcx, %r12
jb 0x8f42
leaq 0x1900(%rip), %rsi      # 0xa8d6
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_O1/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)
movss %xmm0, 0x5bca0c(%rip)   # 0x5bde34
leaq 0x3c85(%rip), %rax      # 0x50b4
movl %edi, 0x5bca03(%rip)    # 0x5bde38
movslq %edi, %r14
imulq $0x51eb851f, %r14, %rbx # imm = 0x51EB851F
movq %rbx, %rcx
shrq $0x3f, %rcx
sarq $0x27, %rbx
addl %ecx, %ebx
movl %ebx, 0x5bca02(%rip)    # 0x5bde54
imulq $0x7e07e07f, %r14, %rcx # imm = 0x7E07E07F
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x25, %rcx
addl %edx, %ecx
movl %ecx, 0x5bc9ec(%rip)    # 0x5bde58
movl $0x5b8da0, %edx         # imm = 0x5B8DA0
movq %rax, %rdi
xorl %esi, %esi
callq 0x1090
movss 0x4(%rsp), %xmm0
movss %xmm0, 0x5bc9ab(%rip)   # 0x5bde34
movl %r14d, 0x5bc9a8(%rip)   # 0x5bde38
movl %ebx, 0x5bc9a6(%rip)    # 0x5bde3c
movl %ebx, 0x5bc9a4(%rip)    # 0x5bde40
xorps %xmm0, %xmm0
movups %xmm0, 0x5bc99e(%rip)   # 0x5bde44
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x5bc98f(%rip), %eax    # 0x5bde48
testl %eax, %eax
je 0x1511
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 0x1ec058(%rip), %rsi    # 0x1ed534
callq 0x10e0
testl %r14d, %r14d
jle 0x1508
leaq 0x3bc7(%rip), %rax      # 0x50b4
leaq (%rax,%r15,2), %rsi
addq $0x1e8480, %rsi         # imm = 0x1E8480
leaq 0x1ec035(%rip), %rdi    # 0x1ed534
leal (%r14,%r14), %edx
callq 0x1100
movl %r14d, 0x5bc939(%rip)   # 0x5bde48
jmp 0x1513
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x5bc919(%rip), %rax    # 0x5bde3c
movslq 0x5bc92e(%rip), %rcx    # 0x5bde58
movl $0x119c, %edx           # imm = 0x119C
subq %rax, %rdx
subq %rcx, %rax
cvtsi2ss %eax, %xmm0
divss 0x5bc8f3(%rip), %xmm0   # 0x5bde34
addss 0x1abb(%rip), %xmm0     # 0x3004
cvttss2si %xmm0, %ebx
addl 0x5bc8f5(%rip), %ebx    # 0x5bde48
leaq 0x3b5a(%rip), %rsi      # 0x50b4
leaq (%rsi,%rcx,2), %rcx
leaq (%rcx,%rax,2), %rdi
addq %rdx, %rdx
xorl %esi, %esi
callq 0x1090
movl $0x119c, 0x5bc8c6(%rip) # imm = 0x119C
xorl %edi, %edi
xorl %esi, %esi
callq 0x15ad
cmpl %ebx, 0x5bc8c3(%rip)    # 0x5bde48
jle 0x158d
movl %ebx, 0x5bc8bb(%rip)    # 0x5bde48
movl 0x5bc8c1(%rip), %eax    # 0x5bde54
movl %eax, 0x5bc8a3(%rip)    # 0x5bde3c
leaq 0x3b14(%rip), %rdi      # 0x50b4
movl $0x2338, %edx           # imm = 0x2338
xorl %esi, %esi
popq %rbx
jmp 0x1090
// File: /workspace/github_c_makefile_star2_O1/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 0x1aa1
movq %rdi, %rbx
leaq 0x36a6(%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 0x15e8(%rip), %xmm0     # 0x3020
divsd (%rsp), %xmm0
callq 0x10a0
movsd 0x15de(%rip), %xmm1     # 0x3028
subsd %xmm0, %xmm1
mulsd 0x15da(%rip), %xmm1     # 0x3030
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
movswl (%r12,%rbp,2), %eax
xorps %xmm1, %xmm1
cvtsi2ss %eax, %xmm1
movss 0x1597(%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 0x1a29
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x243d
movss 0xc33(%rip), %xmm0      # 0x3008
movss %xmm0, 0x4(%rsp)
movl $0x1, %r12d
leaq 0xe27(%rip), %r14       # 0x320f
leaq 0xe23(%rip), %r15       # 0x3212
movslq %r12d, %rax
movq (%rbx,%rax,8), %rdi
cmpb $0x2d, (%rdi)
jne 0x2451
movq %r14, %rsi
callq 0x10c0
testl %eax, %eax
jne 0x2433
incl %r12d
cmpl %ebp, %r12d
jge 0x2433
movslq %r12d, %rax
movq (%rbx,%rax,8), %rdi
callq 0x1050
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x4(%rsp)
cvtss2sd %xmm0, %xmm0
movq %r15, %rdi
movb $0x1, %al
callq 0x1080
incl %r12d
cmpl %ebp, %r12d
jl 0x23ef
jmp 0x2451
movl $0x1, %r12d
movss 0xbbd(%rip), %xmm0      # 0x3008
movss %xmm0, 0x4(%rsp)
subl %r12d, %ebp
cmpl $0x2, %ebp
jne 0x255b
movslq %r12d, %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 0x2560
movq %rax, %rbx
testq %rax, %rax
je 0x2565
movl 0x8(%rsp), %esi
leaq 0xe69(%rip), %rdi       # 0x330b
xorl %eax, %eax
callq 0x1080
movl 0x8(%rsp), %esi
movq %r15, %rdi
movl $0x1, %edx
callq 0x1e9a
testq %rax, %rax
je 0x256d
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 0x219f
movl %eax, %ebp
testl %eax, %eax
je 0x2504
movq %r15, %rdi
movl %ebp, %esi
callq 0x15ad
jmp 0x251e
callq 0x151b
jmp 0x251e
movq %r14, %rdi
movq %r12, %rsi
movl %eax, %edx
callq 0x221d
incl 0x5bb93e(%rip)          # 0x5bde5c
movq %r12, %rdi
movl $0x50, %esi
callq 0x14ae
testl %eax, %eax
jg 0x250b
incl 0x5bb927(%rip)          # 0x5bde5c
testl %ebp, %ebp
jg 0x24e2
movq %rbx, %rdi
callq 0x20bd
movq %r14, %rdi
callq 0x20bd
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_O1/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 0x38ed
movq %rax, %rbx
movl %ebp, %eax
movq %rax, (%rbx)
decq %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
mulq %rcx
movq %rdx, %r15
movq $0x0, 0x8(%rbx)
shrq $0x5, %r15
leaq 0x1(%r15), %rdi
movl $0x20, %esi
callq 0x32e0
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x38e5
addq $0x8, %rax
movl $0x1, %ecx
movq %r14, (%rax)
movl %ecx, %edx
addq $0x20, %rax
incl %ecx
cmpq %rdx, %r15
jae 0x38d3
jmp 0x38ef
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_O1/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 0x3a2b
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 0x3a2b
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 0x4191
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, %r13d
jb 0x39fd
movq %rax, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movq %r13, 0x18(%rsp)
movl (%r14), %r13d
addq $0x8, %r15
movq 0x10(%r14), %rdi
leal 0x1(%r13), %esi
imulq %r15, %rsi
callq 0x3440
testq %rax, %rax
je 0x3a2b
movq 0x10(%rsp), %rdi
subl %edi, %r13d
imulq %r13, %r15
testq %r15, %r15
movq 0x18(%rsp), %r13
je 0x39ed
incl %edi
movq 0x8(%r14), %rcx
addq $0x8, %rcx
imulq %rcx, %rdi
addq %rax, %rdi
movq %r13, %rsi
imulq %rcx, %rsi
addq %rax, %rsi
movq %r15, %rdx
movq %rax, %r15
callq 0x34a0
movq %r15, %rax
incl (%r14)
movq %rax, 0x10(%r14)
movl 0xc(%rsp), %eax
orl %eax, 0x18(%r14,%r12,4)
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
addq $0x8, %rax
imulq %r13, %rax
leaq (%rcx,%rax), %rdi
addq $0x8, %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_O1/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 0x3a46
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 0x4191
movl %ebp, %ecx
shrl $0x3, %ecx
andl $0x4, %ecx
movl 0x18(%rcx,%r12), %ecx
btl %ebp, %ecx
jae 0x3ace
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 0x3ace
leaq (%rdx,%rcx), %rax
addq $0x8, %rax
testq %rbx, %rbx
je 0x3ad0
movq %rsi, (%rbx)
jmp 0x3ad0
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3af1
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_O1/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 0x3b7b
movq %rax, %rbx
movq $0x20, (%rax)
movq $0x0, 0x8(%rax)
movl $0x28, %edi
movl $0x20, %esi
callq 0x3570
movq %rax, 0x10(%rbx)
testq %rax, %rax
jne 0x3b7d
movq %rbx, %rdi
callq 0x3050
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq