LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl -0x4(%rbp), %edi
leaq 0x1452(%rip), %rsi      # 0xce6f
movb $0x0, %al
callq 0x10d0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rdx
xorl %ecx, %ecx
callq 0xb7b0
movl -0x4(%rbp), %edi
leaq 0x1419(%rip), %rsi      # 0xce76
movb $0x0, %al
callq 0x10d0
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xbadb
movl -0x4(%rbp), %edi
leaq 0x875(%rip), %rsi       # 0xc2f6
movb $0x0, %al
callq 0x10d0
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x2d, 0x8(%rax)
jne 0xbab5
movl -0x4(%rbp), %edi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rdx
leaq 0x13cf(%rip), %rsi      # 0xce7b
movb $0x0, %al
callq 0x10d0
jmp 0xbace
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rdx
xorl %ecx, %ecx
callq 0xb7b0
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xba70
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %edi
leaq 0x1186(%rip), %rsi      # 0xcc8f
movb $0x0, %al
callq 0x10d0
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq 0x10(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0xbb70
movl -0x4(%rbp), %edi
leaq 0x1111(%rip), %rsi      # 0xcc4b
movb $0x0, %al
callq 0x10d0
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xba00
movl -0x4(%rbp), %edi
leaq 0x114c(%rip), %rsi      # 0xcca7
movb $0x0, %al
callq 0x10d0
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xbb18
movl -0x4(%rbp), %edi
leaq 0x1110(%rip), %rsi      # 0xcc8a
movb $0x0, %al
callq 0x10d0
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rdx
leaq 0x12e9(%rip), %rsi      # 0xce7f
movb $0x0, %al
callq 0x10d0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl -0x4(%rbp), %edi
leaq 0x1080(%rip), %rsi      # 0xcc4d
movb $0x0, %al
callq 0x10d0
movl -0x4(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x4150
movl -0x4(%rbp), %edi
leaq 0x12ae(%rip), %rsi      # 0xce98
leaq 0x12c0(%rip), %rdx      # 0xceb1
movb $0x0, %al
callq 0x10d0
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq 0x10(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0xbc87
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movl -0x4(%rbp), %edi
leaq 0x1284(%rip), %rsi      # 0xcebc
movb $0x0, %al
callq 0x10d0
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xba00
movl -0x4(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x3a60
movl -0x2c(%rbp), %edi
movq %rax, %rdx
leaq 0x1250(%rip), %rsi      # 0xcebf
movb $0x0, %al
callq 0x10d0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xbc00
movl -0x4(%rbp), %edi
leaq 0xff9(%rip), %rsi       # 0xcc8a
movb $0x0, %al
callq 0x10d0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl -0x4(%rbp), %edi
leaq 0xf90(%rip), %rsi       # 0xcc4d
movb $0x0, %al
callq 0x10d0
movl -0x4(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x4150
movl -0x4(%rbp), %edi
leaq 0x11ef(%rip), %rsi      # 0xcec9
leaq 0x11d0(%rip), %rdx      # 0xceb1
movb $0x0, %al
callq 0x10d0
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq 0x10(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0xbd92
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movl -0x4(%rbp), %edi
leaq 0x1190(%rip), %rsi      # 0xcebc
movb $0x0, %al
callq 0x10d0
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xba00
movl -0x4(%rbp), %edi
leaq 0x1195(%rip), %rsi      # 0xcee2
movb $0x0, %al
callq 0x10d0
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rdx
movl $0x1, %ecx
callq 0xb7b0
movl -0x4(%rbp), %edi
leaq 0xf2d(%rip), %rsi       # 0xcca7
movb $0x0, %al
callq 0x10d0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xbcf0
movl -0x4(%rbp), %edi
leaq 0xeee(%rip), %rsi       # 0xcc8a
movb $0x0, %al
callq 0x10d0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl -0x4(%rbp), %edi
leaq 0xe80(%rip), %rsi       # 0xcc4d
movb $0x0, %al
callq 0x10d0
movl -0x4(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x4150
movl -0x4(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xbf10
movl -0x3c(%rbp), %edi
movq %rax, %rcx
addq $0x1, %rcx
leaq 0x10e3(%rip), %rsi      # 0xcee7
leaq 0x1059(%rip), %rdx      # 0xce64
movb $0x0, %al
callq 0x10d0
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq 0x10(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0xbeee
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movl -0x4(%rbp), %edi
leaq 0x1064(%rip), %rsi      # 0xcebc
movb $0x0, %al
callq 0x10d0
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl $0x1, %ecx
callq 0xb7b0
movl -0x4(%rbp), %edi
leaq 0x1083(%rip), %rsi      # 0xcf01
movb $0x0, %al
callq 0x10d0
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x1aa0
movl %eax, -0x2c(%rbp)
cmpl $-0x1, %eax
je 0xbecc
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
movl -0x4(%rbp), %edi
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rdx
leaq 0x1045(%rip), %rsi      # 0xcf08
movb $0x0, %al
callq 0x10d0
jmp 0xbe85
movl -0x4(%rbp), %edi
leaq 0x1039(%rip), %rsi      # 0xcf0f
movb $0x0, %al
callq 0x10d0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xbe1a
movl -0x4(%rbp), %edi
leaq 0xd92(%rip), %rsi       # 0xcc8a
movb $0x0, %al
callq 0x10d0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MaoKo[P]FGFX/fgfp/src/gen_cfg.c
// Function: count_max_follow
static size_t
count_max_follow(vector_t const* vnter) {
	size_t max_follow = 0;
	for (size_t i = 0; i < SIZE_VECTOR(vnter) - 1; ++i) {
		symbol_t* nter = (symbol_t*)AT_VECTOR(vnter, i);

		size_t count_nter = count_elt_bitset(nter->follow);
		if (count_nter > max_follow)
			{ max_follow = count_nter; }
	}
	return (max_follow);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0xbf87
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x1df0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
jbe 0xbf77
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0xbf79
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xbf2c
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movss %xmm0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movss -0x4(%rbp), %xmm0
movss %xmm0, 0x5bcba7(%rip)   # 0x5bde34
movl -0x8(%rbp), %eax
movl %eax, 0x5bcba2(%rip)    # 0x5bde38
movl -0x8(%rbp), %eax
movl $0x190, %ecx            # imm = 0x190
cltd
idivl %ecx
movl %eax, 0x5bcbad(%rip)    # 0x5bde54
movl -0x8(%rbp), %eax
movl $0x41, %ecx
cltd
idivl %ecx
movl %eax, 0x5bcba0(%rip)    # 0x5bde58
leaq 0x3df5(%rip), %rdi      # 0x50b4
xorl %esi, %esi
movl $0x5b8da0, %edx         # imm = 0x5B8DA0
callq 0x1090
movss -0x4(%rbp), %xmm0
movss %xmm0, 0x5bcb5c(%rip)   # 0x5bde34
movl -0x8(%rbp), %eax
movl %eax, 0x5bcb57(%rip)    # 0x5bde38
movl $0x0, 0x5bcb51(%rip)    # 0x5bde3c
movl $0x0, 0x5bcb53(%rip)    # 0x5bde48
movl $0x0, 0x5bcb4d(%rip)    # 0x5bde4c
movl $0x0, 0x5bcb47(%rip)    # 0x5bde50
movl 0x5bcb45(%rip), %eax    # 0x5bde54
movl %eax, 0x5bcb27(%rip)    # 0x5bde3c
movl 0x5bcb39(%rip), %eax    # 0x5bde54
movl %eax, 0x5bcb1f(%rip)    # 0x5bde40
movl $0x0, 0x5bcb19(%rip)    # 0x5bde44
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl 0x5bcaf3(%rip), %eax    # 0x5bde48
movl %eax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0x136e
movl $0x0, -0x4(%rbp)
jmp 0x13e3
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jle 0x1385
movl -0x18(%rbp), %eax
subl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x18(%rbp), %rdx
shlq %rdx
leaq 0x3d1d(%rip), %rsi      # 0x50b4
addq $0x1e8480, %rsi         # imm = 0x1E8480
callq 0x10e0
cmpl $0x0, -0x1c(%rbp)
jle 0x13d4
movslq -0x18(%rbp), %rax
leaq 0x3d00(%rip), %rsi      # 0x50b4
addq $0x1e8480, %rsi         # imm = 0x1E8480
shlq %rax
addq %rax, %rsi
movslq -0x1c(%rbp), %rdx
shlq %rdx
leaq 0x1ec165(%rip), %rdi    # 0x1ed534
callq 0x1100
movl -0x1c(%rbp), %eax
movl %eax, 0x5bca6b(%rip)    # 0x5bde48
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl 0x5bca3e(%rip), %eax    # 0x5bde3c
subl 0x5bca54(%rip), %eax    # 0x5bde58
movl %eax, -0x4(%rbp)
movss 0x5bca25(%rip), %xmm0   # 0x5bde34
movss %xmm0, -0x8(%rbp)
movl 0x5bca2e(%rip), %eax    # 0x5bde48
cvtsi2ssl -0x4(%rbp), %xmm0
divss -0x8(%rbp), %xmm0
movss 0x1bd8(%rip), %xmm1     # 0x3004
addss %xmm1, %xmm0
cvttss2si %xmm0, %ecx
addl %ecx, %eax
movl %eax, -0xc(%rbp)
movslq 0x5bca18(%rip), %rax    # 0x5bde58
leaq 0x3c6d(%rip), %rdi      # 0x50b4
shlq %rax
addq %rax, %rdi
movslq -0x4(%rbp), %rax
shlq %rax
addq %rax, %rdi
movl 0x5bc9fb(%rip), %ecx    # 0x5bde58
addl -0x4(%rbp), %ecx
movl $0x119c, %eax           # imm = 0x119C
subl %ecx, %eax
movslq %eax, %rdx
shlq %rdx
xorl %esi, %esi
callq 0x1090
movl $0x119c, 0x5bc9be(%rip) # imm = 0x119C
xorl %eax, %eax
movl %eax, %edi
xorl %esi, %esi
callq 0x14d0
movl 0x5bc9b9(%rip), %eax    # 0x5bde48
cmpl -0xc(%rbp), %eax
jle 0x149d
movl -0xc(%rbp), %eax
movl %eax, 0x5bc9ab(%rip)    # 0x5bde48
movl 0x5bc9b1(%rip), %eax    # 0x5bde54
movl %eax, 0x5bc993(%rip)    # 0x5bde3c
leaq 0x3c04(%rip), %rdi      # 0x50b4
xorl %esi, %esi
movl $0x2338, %edx           # imm = 0x2338
callq 0x1090
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/waywardgeek[P]sonic/sonic_experimental.c
// Function: addShortSamplesToInputBuffer
static int addShortSamplesToInputBuffer(short *samples,
                                        int numSamples) {
  if (numSamples == 0) {
    return 1;
  }
  if (sonicStream.numInputSamples + numSamples > SONIC_INPUT_BUFFER_SIZE) {
    return 0;
  }
  memcpy(sonicStream.inputBuffer + sonicStream.numInputSamples,
         samples, numSamples * sizeof(short));
  sonicStream.numInputSamples += numSamples;
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x152e
movl $0x1, -0x4(%rbp)
jmp 0x1581
movl 0x5bc908(%rip), %eax    # 0x5bde3c
addl -0x14(%rbp), %eax
cmpl $0x119c, %eax           # imm = 0x119C
jle 0x1547
movl $0x0, -0x4(%rbp)
jmp 0x1581
movslq 0x5bc8ee(%rip), %rax    # 0x5bde3c
leaq 0x3b5f(%rip), %rdi      # 0x50b4
shlq %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
shlq %rdx
callq 0x10e0
movl -0x14(%rbp), %eax
addl 0x5bc8c8(%rip), %eax    # 0x5bde3c
movl %eax, 0x5bc8c2(%rip)    # 0x5bde3c
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/waywardgeek[P]sonic/sonic_experimental.c
// Function: processStreamInput
static void processStreamInput(void) {
  float speed = sonicStream.speed;

  if (speed > 1.00001 || speed < 0.99999) {
    changeSpeed(speed);
  } else {
    copyToOutput(sonicStream.inputBuffer + sonicMaxPeriod,
        sonicStream.numInputSamples - sonicMaxPeriod);
    sonicStream.numInputSamples = sonicMaxPeriod;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movss 0x5bc894(%rip), %xmm0   # 0x5bde34
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x1a5a(%rip), %xmm1     # 0x3010
ucomisd %xmm1, %xmm0
ja 0x15d3
movss -0x4(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x1a4b(%rip), %xmm0     # 0x3018
ucomisd %xmm1, %xmm0
jbe 0x15df
movss -0x4(%rbp), %xmm0
callq 0x1630
jmp 0x1610
movslq 0x5bc872(%rip), %rax    # 0x5bde58
leaq 0x3ac7(%rip), %rdi      # 0x50b4
shlq %rax
addq %rax, %rdi
movl 0x5bc843(%rip), %esi    # 0x5bde3c
subl 0x5bc859(%rip), %esi    # 0x5bde58
callq 0x1730
movl 0x5bc84e(%rip), %eax    # 0x5bde58
movl %eax, 0x5bc82c(%rip)    # 0x5bde3c
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/waywardgeek[P]sonic/sonic_experimental.c
// Function: changeSpeed
static void changeSpeed(float speed) {
  struct sonicSnippetStruct A, B;
  int period;

  if (sonicStream.numInputSamples < 3 * sonicMaxPeriod) {
    return;
  }
  while (sonicStream.numInputSamples >= 3 * sonicMaxPeriod) {
    /* TODO: Don't recompute the snippet for A. */
    A.inputPos = sonicMaxPeriod;
    A.offset = sonicStream.snippetOffset;
    setPeriod(&A, sonicStream.snippetPeriod);
    period = findPitchPeriod(sonicStream.inputBuffer + sonicMaxPeriod, 1);
    B.inputPos = sonicMaxPeriod + period;
    setPeriod(&B, period);
    setBOffset(&A, &B);
    fadeFromAToB(&A, &B);
    removeInputSamples(B.inputPos);
    sonicStream.snippetPeriod = B.period;
    sonicStream.snippetOffset = B.offset;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x61aa0, %rsp          # imm = 0x61AA0
movss %xmm0, -0x4(%rbp)
movl 0x5bc7f6(%rip), %eax    # 0x5bde3c
imull $0x3, 0x5bc80b(%rip), %ecx # 0x5bde58
cmpl %ecx, %eax
jge 0x1656
jmp 0x1727
jmp 0x1658
movl 0x5bc7de(%rip), %eax    # 0x5bde3c
imull $0x3, 0x5bc7f3(%rip), %ecx # 0x5bde58
cmpl %ecx, %eax
jl 0x1727
movl 0x5bc7e5(%rip), %eax    # 0x5bde58
movl %eax, -0x10(%rbp)
movl 0x5bc7c8(%rip), %eax    # 0x5bde44
movl %eax, -0xc(%rbp)
movl 0x5bc7bb(%rip), %esi    # 0x5bde40
leaq -0x30d50(%rbp), %rdi
callq 0x1780
movslq 0x5bc7c0(%rip), %rax    # 0x5bde58
leaq 0x3a15(%rip), %rdi      # 0x50b4
shlq %rax
addq %rax, %rdi
movl $0x1, %esi
callq 0x1880
movl %eax, -0x61aa0(%rbp)
movl 0x5bc79d(%rip), %eax    # 0x5bde58
addl -0x61aa0(%rbp), %eax
movl %eax, -0x30d5c(%rbp)
movl -0x61aa0(%rbp), %esi
leaq -0x61a9c(%rbp), %rdi
callq 0x1780
leaq -0x30d50(%rbp), %rdi
leaq -0x61a9c(%rbp), %rsi
callq 0x19c0
leaq -0x30d50(%rbp), %rdi
leaq -0x61a9c(%rbp), %rsi
callq 0x1a10
movl -0x30d5c(%rbp), %edi
callq 0x1b80
movl -0x30d54(%rbp), %eax
movl %eax, 0x5bc72a(%rip)    # 0x5bde40
movl -0x30d58(%rbp), %eax
movl %eax, 0x5bc722(%rip)    # 0x5bde44
jmp 0x1658
addq $0x61aa0, %rsp          # imm = 0x61AA0
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x30d40(%rax), %eax
movl %eax, -0x10(%rbp)
movslq -0x10(%rbp), %rcx
leaq 0x390d(%rip), %rax      # 0x50b4
shlq %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x30d48(%rax)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x1874
cvtsi2sdl -0x20(%rbp), %xmm0
movsd 0x1842(%rip), %xmm1     # 0x3020
mulsd %xmm1, %xmm0
cvtsi2sdl -0xc(%rbp), %xmm1
divsd %xmm1, %xmm0
callq 0x10a0
movaps %xmm0, %xmm1
movsd 0x182d(%rip), %xmm0     # 0x3028
subsd %xmm1, %xmm0
movsd 0x1829(%rip), %xmm1     # 0x3030
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x1c(%rbp)
movss -0x1c(%rbp), %xmm1
movss 0x17e7(%rip), %xmm0     # 0x3008
subss %xmm1, %xmm0
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rdx
movl %edx, %ecx
movswl (%rax,%rdx,2), %edx
cvtsi2ss %edx, %xmm2
movl -0xc(%rbp), %edx
subl %edx, %ecx
movslq %ecx, %rcx
movswl (%rax,%rcx,2), %eax
cvtsi2ss %eax, %xmm3
mulss %xmm3, %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
cvttss2si %xmm0, %eax
movw %ax, %dx
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movw %dx, (%rax,%rcx,2)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x17c5
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/waywardgeek[P]sonic/sonic_experimental.c
// Function: setBOffset
static void setBOffset(sonicSnippet A, sonicSnippet B) {
  int offset = A->offset;

  /* When pitch is increasing, offset can be > B->period. */
  while (offset >= B->period) {
    offset -= B->period;
  }
  B->offset = offset;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x30d44(%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x30d48(%rcx), %eax
jl 0x19fc
movq -0x10(%rbp), %rax
movl 0x30d48(%rax), %ecx
movl -0x14(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x14(%rbp)
jmp 0x19d9
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x30d44(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/waywardgeek[P]sonic/sonic_experimental.c
// Function: fadeFromAToB
static void fadeFromAToB(sonicSnippet A, sonicSnippet B) {
  int numOutputSamples = B->period / sonicStream.speed;
  /* Initially snippet A and snippet B have different periods. */
  int periodB = B->period;
  int changedPeriod = 0;
  int i;
  float fadeA, fadeB;

  /* A’s offset may be non-zero from playing it in the prior iteration. */
  if (numOutputSamples <= A->period - A->offset) {
    /* We will fade out A before finishing it.  Just use B’s period
       for B.  Don’t use it for A as that would cause a discontinuity. */
    changedPeriod = 1;
  } else {
    /* Play B using A’s period until we reset the offset to 0. */
    setPeriod(B, A->period);
    B->offset = A->offset;
  }
  for (i = 0; i < numOutputSamples; i++) {
    if (!changedPeriod && A->offset == 0) {
      setPeriod(A, periodB);
      setPeriod(B, periodB);
      changedPeriod = 1;
    }
    fadeB = (float) i / numOutputSamples;
    fadeA = 1.0 - fadeB;
    outputSample(fadeA * A->samples[A->offset] +
           fadeB * B->samples[B->offset]);
    incOffset(A);  /* Sets offset to 0 if offset == period. */
    incOffset(B);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cvtsi2ssl 0x30d48(%rax), %xmm0
divss 0x5bc400(%rip), %xmm0   # 0x5bde34
cvttss2si %xmm0, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x30d48(%rax), %eax
movl %eax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
movl 0x30d48(%rcx), %ecx
movq -0x8(%rbp), %rdx
subl 0x30d44(%rdx), %ecx
cmpl %ecx, %eax
jg 0x1a73
movl $0x1, -0x1c(%rbp)
jmp 0x1a9a
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x30d48(%rax), %esi
callq 0x1780
movq -0x8(%rbp), %rax
movl 0x30d44(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x30d44(%rax)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x1b78
cmpl $0x0, -0x1c(%rbp)
jne 0x1adf
movq -0x8(%rbp), %rax
cmpl $0x0, 0x30d44(%rax)
jne 0x1adf
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x1780
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x1780
movl $0x1, -0x1c(%rbp)
cvtsi2ssl -0x20(%rbp), %xmm0
cvtsi2ssl -0x14(%rbp), %xmm1
divss %xmm1, %xmm0
movss %xmm0, -0x28(%rbp)
movss -0x28(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x1525(%rip), %xmm0     # 0x3028
subsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x24(%rbp)
movss -0x24(%rbp), %xmm0
movq -0x8(%rbp), %rax
movslq 0x30d44(%rax), %rcx
movswl (%rax,%rcx,2), %eax
cvtsi2ss %eax, %xmm2
movss -0x28(%rbp), %xmm1
movq -0x10(%rbp), %rax
movslq 0x30d44(%rax), %rcx
movswl (%rax,%rcx,2), %eax
cvtsi2ss %eax, %xmm3
mulss %xmm3, %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
cvttss2si %xmm0, %eax
movswl %ax, %edi
callq 0x1eb0
movq -0x8(%rbp), %rdi
callq 0x1ef0
movq -0x10(%rbp), %rdi
callq 0x1ef0
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1aa1
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/waywardgeek[P]sonic/sonic_experimental.c
// Function: removeInputSamples
static void removeInputSamples(int position) {
  int remainingSamples = sonicStream.numInputSamples - position;

  if (remainingSamples > 0) {
    memmove(sonicStream.inputBuffer,
            sonicStream.inputBuffer + position - sonicMaxPeriod,
            (remainingSamples + sonicMaxPeriod) * sizeof(short));
  }
  sonicStream.numInputSamples = sonicMaxPeriod + remainingSamples;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl 0x5bc2ab(%rip), %eax    # 0x5bde3c
subl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jle 0x1bdb
movslq -0x4(%rbp), %rax
leaq 0x350c(%rip), %rsi      # 0x50b4
shlq %rax
addq %rax, %rsi
movslq 0x5bc2a3(%rip), %rcx    # 0x5bde58
xorl %eax, %eax
subq %rcx, %rax
shlq %rax
addq %rax, %rsi
movl -0x8(%rbp), %eax
addl 0x5bc28f(%rip), %eax    # 0x5bde58
movslq %eax, %rdx
shlq %rdx
leaq 0x34de(%rip), %rdi      # 0x50b4
callq 0x1100
movl 0x5bc277(%rip), %eax    # 0x5bde58
addl -0x8(%rbp), %eax
movl %eax, 0x5bc252(%rip)    # 0x5bde3c
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/waywardgeek[P]sonic/sonic_experimental.c
// Function: downSampleInput
static void downSampleInput(short *samples) {
  int numSamples = 2 * sonicMaxPeriod;
  int i, j;
  int value;
  short *downSamples = sonicStream.downSampleBuffer;
  int skip = sonicStream.sampleRate / SONIC_AMDF_FREQ;

  for (i = 0; i < numSamples; i++) {
    value = 0;
    for (j = 0; j < skip; j++) {
      value += *samples++;
    }
    value /= skip;
    *downSamples++ = value;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl 0x5bc0ca(%rip), %eax    # 0x5bde58
shll %eax
movl %eax, -0xc(%rbp)
leaq 0x331a(%rip), %rax      # 0x50b4
addq $0x3d0900, %rax         # imm = 0x3D0900
movq %rax, -0x20(%rbp)
movl 0x5bc08e(%rip), %eax    # 0x5bde38
movl $0xfa0, %ecx            # imm = 0xFA0
cltd
idivl %ecx
movl %eax, -0x24(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x1e2c
movl $0x0, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x1dfd
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x2, %rcx
movq %rcx, -0x8(%rbp)
movswl (%rax), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1dd2
movl -0x24(%rbp), %ecx
movl -0x18(%rbp), %eax
cltd
idivl %ecx
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movw %ax, %cx
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x2, %rdx
movq %rdx, -0x20(%rbp)
movw %cx, (%rax)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1dbc
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/waywardgeek[P]sonic/sonic_experimental.c
// Function: prevPeriodBetter
static int prevPeriodBetter(int minDiff, int maxDiff, int preferNewPeriod) {
  if (minDiff == 0 || sonicStream.prevPeriod == 0) {
    return 0;
  }
  if (preferNewPeriod) {
    if (maxDiff > minDiff * 3) {
      /* Got a reasonable match this period */
      return 0;
    }
    if (minDiff * 2 <= sonicStream.prevMinDiff * 3) {
      /* Mismatch is not that much greater this period */
      return 0;
    }
  } else {
    if (minDiff <= sonicStream.prevMinDiff) {
      return 0;
    }
  }
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0x1e4c
cmpl $0x0, 0x5bc002(%rip)    # 0x5bde4c
jne 0x1e55
movl $0x0, -0x4(%rbp)
jmp 0x1ea7
cmpl $0x0, -0x10(%rbp)
je 0x1e8a
movl -0xc(%rbp), %eax
imull $0x3, -0x8(%rbp), %ecx
cmpl %ecx, %eax
jle 0x1e6f
movl $0x0, -0x4(%rbp)
jmp 0x1ea7
movl -0x8(%rbp), %eax
shll %eax
imull $0x3, 0x5bbfd5(%rip), %ecx # 0x5bde50
cmpl %ecx, %eax
jg 0x1e88
movl $0x0, -0x4(%rbp)
jmp 0x1ea7
jmp 0x1ea0
movl -0x8(%rbp), %eax
cmpl 0x5bbfbd(%rip), %eax    # 0x5bde50
jg 0x1e9e
movl $0x0, -0x4(%rbp)
jmp 0x1ea7
jmp 0x1ea0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movss 0x51a(%rip), %xmm0      # 0x3008
movss %xmm0, -0x24(%rbp)
movl $0x1, -0x28(%rbp)
movl -0x28(%rbp), %ecx
xorl %eax, %eax
cmpl -0x8(%rbp), %ecx
movb %al, -0x29(%rbp)
jge 0x2b1f
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
sete %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x2b28
jmp 0x2b97
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x6d4(%rip), %rsi       # 0x320f
callq 0x10c0
cmpl $0x0, %eax
jne 0x2b89
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x2b87
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1050
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x24(%rbp)
movss -0x24(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x692(%rip), %rdi       # 0x3212
movb $0x1, %al
callq 0x1080
jmp 0x2b89
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x2afa
movl -0x8(%rbp), %eax
subl -0x28(%rbp), %eax
cmpl $0x2, %eax
je 0x2ba7
callq 0x2bf0
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl -0x28(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movss -0x24(%rbp), %xmm0
callq 0x2c20
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/waywardgeek[P]sonic/main_experimental.c
// Function: usage
static void usage(void) {
  fprintf(
      stderr,
      "Usage: sonic_experimental [OPTION]... infile outfile\n"
      "    -s speed   -- Set speed up factor.  2.0 means 2X faster.\n");
  exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x23fd(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x626(%rip), %rsi       # 0x322b
movb $0x0, %al
callq 0x10d0
movl $0x1, %edi
callq 0x1120
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x1, %edi
movl $0x10, %esi
callq 0x3300
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x3745
movq $0x0, -0x8(%rbp)
jmp 0x381e
movl -0x14(%rbp), %eax
movq %rax, -0x30(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rax
subq $0x1, %rax
movl $0x30, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, %rdi
addq $0x1, %rdi
movl $0x20, %esi
callq 0x3300
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x37b6
movq -0x20(%rbp), %rdi
callq 0x3050
movq $0x0, -0x8(%rbp)
jmp 0x381e
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
subq $0x1, %rax
movl $0x30, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
movq -0x40(%rbp), %rax
addq $0x1, %rcx
cmpq %rcx, %rax
jae 0x3816
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x18(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x37bd
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jbe 0x385c
movl $0x0, -0x4(%rbp)
jmp 0x38ad
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movl -0x14(%rbp), %eax
movl $0x30, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, %ecx
movq -0x40(%rbp), %rax
movl %ecx, %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %eax
movl $0x30, %ecx
xorl %edx, %edx
divl %ecx
movl %edx, -0x34(%rbp)
movq -0x30(%rbp), %rdi
movl -0x34(%rbp), %esi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x38c0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jbe 0x3a89
movq $0x0, -0x8(%rbp)
jmp 0x3ad7
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movl -0x14(%rbp), %eax
movl $0x30, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %eax
movl $0x30, %ecx
xorl %edx, %edx
divl %ecx
movl %edx, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
movl -0x2c(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x3af0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/qpfiffer[P]38-Moths/src/simple_sparsehash.c
// Function: sparse_array_group_get
static const void *_sparse_array_group_get(struct sparse_array_group *arr,
							 const uint32_t i, size_t *outsize) {
	const uint32_t offset = position_to_offset(arr->bitmap, i);
	const unsigned char *item_siz = (unsigned char *)(arr->group) + (offset * FULL_ELEM_SIZE);
	const void *item = item_siz + sizeof(size_t);

	if (!is_position_occupied(arr->bitmap, i))
		return NULL;

	/* In a perfect world you could store 0 sized items and have that mean
	 * something, but I'll tolerate none of that right now.
	 */
	if (*(size_t *)item_siz == 0)
		return NULL;

	/* If the user wants to know the size (outsize is non-null), write it
	 * out.
	 */
	if (outsize)
		memcpy(outsize, item_siz, sizeof(size_t));

	return item;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
movl -0x14(%rbp), %esi
callq 0x44c0
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x24(%rbp), %ecx
movq -0x10(%rbp), %rdx
movq 0x8(%rdx), %rdx
addq $0x8, %rdx
imulq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
movl -0x14(%rbp), %esi
callq 0x4550
cmpl $0x0, %eax
jne 0x3b63
movq $0x0, -0x8(%rbp)
jmp 0x3b94
movq -0x30(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x3b77
movq $0x0, -0x8(%rbp)
jmp 0x3b94
cmpq $0x0, -0x20(%rbp)
je 0x3b8c
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
subq $0x1, %rax
movl $0x30, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
movq -0x20(%rbp), %rax
addq $0x1, %rcx
cmpq %rcx, %rax
jae 0x3c09
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0xc(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3c30
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3bb3
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3050
movq -0x8(%rbp), %rdi
callq 0x3050
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq $0x0, -0x10(%rbp)
movl $0x1, %edi
movl $0x18, %esi
callq 0x3300
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3c94
movq $0x0, -0x8(%rbp)
jmp 0x3ced
movq -0x10(%rbp), %rax
movq $0x20, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movl $0x28, %edi
movl $0x20, %esi
callq 0x35b0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x3cd2
jmp 0x3cdc
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3ced
movq -0x10(%rbp), %rdi
callq 0x3050
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/qpfiffer[P]38-Moths/src/simple_sparsehash.c
// Function: hash_fnv1a
static uint64_t hash_fnv1a(const char *key, const size_t klen) {
	static const uint64_t fnv_prime = 1099511628211ULL;
	static const uint64_t fnv_offset_bias = 14695981039346656037ULL;

	const int iterations = klen;

	uint8_t i;
	uint64_t hash = fnv_offset_bias;

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

	return hash;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl %eax, -0x14(%rbp)
movabsq $-0x340d631b7bdddcdb, %rax # imm = 0xCBF29CE484222325
movq %rax, -0x20(%rbp)
movb $0x0, -0x15(%rbp)
movzbl -0x15(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x4023
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movzbl -0x15(%rbp), %edx
movsbq (%rcx,%rdx), %rcx
xorq %rcx, %rax
movq %rax, -0x20(%rbp)
movabsq $0x100000001b3, %rax    # imm = 0x100000001B3
imulq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movb -0x15(%rbp), %al
addb $0x1, %al
movb %al, -0x15(%rbp)
jmp 0x3fe5
movq -0x20(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x70, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x38(%rbp), %rdi
addq -0x28(%rbp), %rdi
callq 0x33d0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x407d
jmp 0x40f8
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x3370
movq -0x40(%rbp), %rax
addq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x30a0
movq -0x48(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x58(%rbp)
movq 0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
leaq -0x70(%rbp), %rdx
movl $0x28, %ecx
callq 0x3070
cmpl $0x0, %eax
jne 0x40ef
jmp 0x40f8
movl $0x1, -0x4(%rbp)
jmp 0x4108
movq -0x40(%rbp), %rdi
callq 0x3050
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3fc0
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x30(%rbp), %rax
movl -0x34(%rbp), %ecx
imull -0x34(%rbp), %ecx
movl %ecx, %ecx
addq %rcx, %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
subq $0x1, %rcx
andq %rcx, %rax
movl %eax, -0x44(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0x44(%rbp), %esi
leaq -0x40(%rbp), %rdx
callq 0x3460
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x43d8
cmpq $0x0, -0x50(%rbp)
je 0x43d8
movq -0x50(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x20(%rbp), %rax
jbe 0x437b
movq -0x58(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x68(%rbp)
jmp 0x4383
movq -0x20(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rax
movq 0x20(%rax), %rax
cmpq -0x30(%rbp), %rax
jne 0x43d6
movq -0x58(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x60(%rbp), %rdx
callq 0x30b0
cmpl $0x0, %eax
jne 0x43d6
cmpq $0x0, -0x28(%rbp)
je 0x43c8
movq -0x28(%rbp), %rax
movq -0x58(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq %rcx, (%rax)
movq -0x58(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x4407
jmp 0x43e2
movq $0x0, -0x8(%rbp)
jmp 0x4407
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0x4402
movq $0x0, -0x8(%rbp)
jmp 0x4407
jmp 0x4300
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)