LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/xbarin02[P]uFFT/example.c
// Function: main
int main()
{
	size_t N = 1 << 3;

	float complex vector[N];

	for (size_t n = 0; n < N; n++) {
		vector[n] = n;
	}

	printf("in time domain:\n");

	for (size_t n = 0; n < N; n++) {
		printf("%f%+fi\n", creal(vector[n]), cimag(vector[n]));
	}

	fft(vector, N);

	printf("in frequency domain:\n");

	for (size_t n = 0; n < N; n++) {
		printf("%f%+fi\n", creal(vector[n]), cimag(vector[n]));
	}

	ift(vector, N);

	printf("in time domain:\n");

	for (size_t n = 0; n < N; n++) {
		printf("%f%+fi\n", creal(vector[n]), cimag(vector[n]));
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl $0x0, -0x4(%rbp)
movq $0x8, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rsp, %rcx
movq %rcx, -0x18(%rbp)
leaq 0xf(,%rax,8), %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x48(%rbp)
movq %rcx, %rsp
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x1233
movq -0x28(%rbp), %rax
movq %rax, %rdx
shrq %rdx
movl %eax, %ecx
andl $0x1, %ecx
orq %rdx, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
cvtsi2ss %rax, %xmm1
movss %xmm1, -0x50(%rbp)
testq %rax, %rax
movss %xmm0, -0x4c(%rbp)
js 0x120a
movss -0x50(%rbp), %xmm0
movss %xmm0, -0x4c(%rbp)
movq -0x48(%rbp), %rax
movss -0x4c(%rbp), %xmm0
movq -0x28(%rbp), %rcx
movss %xmm0, (%rax,%rcx,8)
xorps %xmm0, %xmm0
movss %xmm0, 0x4(%rax,%rcx,8)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x11c7
leaq 0x1dca(%rip), %rdi      # 0x3004
movb $0x0, %al
callq 0x1040
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x128e
movq -0x48(%rbp), %rax
movq -0x30(%rbp), %rcx
movss (%rax,%rcx,8), %xmm0
cvtss2sd %xmm0, %xmm0
movq -0x30(%rbp), %rcx
movss 0x4(%rax,%rcx,8), %xmm1
cvtss2sd %xmm1, %xmm1
leaq 0x1d9c(%rip), %rdi      # 0x3015
movb $0x2, %al
callq 0x1040
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x1249
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1380
leaq 0x1d7b(%rip), %rdi      # 0x301d
movb $0x0, %al
callq 0x1040
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x12f6
movq -0x48(%rbp), %rax
movq -0x38(%rbp), %rcx
movss (%rax,%rcx,8), %xmm0
cvtss2sd %xmm0, %xmm0
movq -0x38(%rbp), %rcx
movss 0x4(%rax,%rcx,8), %xmm1
cvtss2sd %xmm1, %xmm1
leaq 0x1d34(%rip), %rdi      # 0x3015
movb $0x2, %al
callq 0x1040
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x12b1
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1cd0
leaq 0x1cfa(%rip), %rdi      # 0x3004
movb $0x0, %al
callq 0x1040
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x135e
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rcx
movss (%rax,%rcx,8), %xmm0
cvtss2sd %xmm0, %xmm0
movq -0x40(%rbp), %rcx
movss 0x4(%rax,%rcx,8), %xmm1
cvtss2sd %xmm1, %xmm1
leaq 0x1ccc(%rip), %rdi      # 0x3015
movb $0x2, %al
callq 0x1040
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x1319
movl $0x0, -0x4(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rsp
movl -0x4(%rbp), %eax
movq %rbp, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/xbarin02[P]uFFT/fft-dit.c
// Function: fft
int fft(float complex *vector, size_t N)
{
	if (!N) return 0;

	if (N & (N - 1)) return 1;

	float complex *buffers[2] = { vector, malloc(N*sizeof(float complex)) };

	if (!buffers[1]) return -1;

	int b = 0;

	b = nop_reverse(b, buffers, N);
	b = fft_reverse(b, buffers, N);
	b = nop_reverse(b, buffers, N);

	memmove(vector, buffers[b&1], N*sizeof(float complex));

	free(buffers[1]);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x13a3
movl $0x0, -0x4(%rbp)
jmp 0x145b
movq -0x18(%rbp), %rax
movq -0x18(%rbp), %rcx
subq $0x1, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
je 0x13c4
movl $0x1, -0x4(%rbp)
jmp 0x145b
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
shlq $0x3, %rdi
callq 0x1060
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x13ed
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x145b
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %edi
leaq -0x30(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1470
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %edi
leaq -0x30(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1540
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %edi
leaq -0x30(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1470
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rdi
movl -0x34(%rbp), %eax
andl $0x1, %eax
cltq
movq -0x30(%rbp,%rax,8), %rsi
movq -0x18(%rbp), %rdx
shlq $0x3, %rdx
callq 0x1070
movq -0x28(%rbp), %rdi
callq 0x1030
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xbarin02[P]uFFT/fft-dit.c
// Function: nop_reverse
static int nop_reverse(int b, float complex *buffers[2], size_t N)
{
	int J = ctz(N);

	for (int j = 0; j < J - 1; j++, b++) {
		size_t delta = N >> j;

		for (size_t n = 0; n < N; n += delta) {
			nop_split(buffers[b&1] + n, buffers[~b&1] + n, delta);
		}
	}

	return b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1680
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x1532
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %ecx
shrq %cl, %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x1519
movq -0x10(%rbp), %rax
movl -0x4(%rbp), %ecx
andl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
movq -0x30(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rax
movl -0x4(%rbp), %ecx
xorl $-0x1, %ecx
andl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rsi
movq -0x30(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
movq -0x28(%rbp), %rdx
callq 0x16c0
movq -0x28(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x14bd
jmp 0x151b
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x1496
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xbarin02[P]uFFT/fft-dit.c
// Function: fft_reverse
static int fft_reverse(int b, float complex *buffers[2], size_t N)
{
	int J = ctz(N);

	for (int j = 0; j < J; j++, b++) {
		size_t delta = N >> j;

		for (size_t n = 0; n < N; n += delta) {
			float complex phi = (float)revbits(n/delta, j) / (float)(2 << j);
			fft_split(buffers[b&1] + n, buffers[~b&1] + n, delta, phi);
		}
	}

	return b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1680
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x1677
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %ecx
shrq %cl, %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x165e
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
xorl %edx, %edx
divq %rcx
movq %rax, %rdi
movl -0x20(%rbp), %esi
callq 0x1760
movq %rax, %rdx
shrq %rdx
movl %eax, %ecx
andl $0x1, %ecx
orq %rdx, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
cvtsi2ss %rax, %xmm1
movss %xmm1, -0x48(%rbp)
testq %rax, %rax
movss %xmm0, -0x44(%rbp)
js 0x15e3
movss -0x48(%rbp), %xmm0
movss %xmm0, -0x44(%rbp)
movss -0x44(%rbp), %xmm0
movb -0x20(%rbp), %cl
movl $0x2, %eax
shll %cl, %eax
cvtsi2ss %eax, %xmm1
divss %xmm1, %xmm0
movss %xmm0, -0x38(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x10(%rbp), %rax
movl -0x4(%rbp), %edx
movl %edx, %ecx
andl $0x1, %ecx
movq (%rax,%rcx,8), %rsi
movq -0x30(%rbp), %rcx
leaq (%rsi,%rcx,8), %rdi
notl %edx
andl $0x1, %edx
movq (%rax,%rdx,8), %rax
leaq (%rax,%rcx,8), %rsi
movq -0x28(%rbp), %rdx
movss -0x38(%rbp), %xmm1
movss -0x34(%rbp), %xmm0
movss %xmm1, -0x40(%rbp)
movss %xmm0, -0x3c(%rbp)
movsd -0x40(%rbp), %xmm0
callq 0x17c0
movq -0x28(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x1588
jmp 0x1660
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x1566
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/xbarin02[P]uFFT/fft-dit.c
// Function: ctz
static int ctz(size_t N)
{
	int ctz1 = 0;

	while (N) {
		ctz1++;
		N >>= 1;
	}

	return ctz1 - 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x16ac
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
shrq %rax
movq %rax, -0x8(%rbp)
jmp 0x168f
movl -0xc(%rbp), %eax
subl $0x1, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xbarin02[P]uFFT/fft-dit.c
// Function: revbits
static size_t revbits(size_t v, int J)
{
	size_t r = 0;

	for (int j = 0; j < J; j++) {
		r |= ((v >> j) & 1) << (J - 1 - j);
	}

	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x17b1
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
shrq %cl, %rax
andq $0x1, %rax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
subl -0x1c(%rbp), %ecx
movl %ecx, %ecx
shlq %cl, %rax
orq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x177a
movq -0x18(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xbarin02[P]uFFT/ift-dif.c
// Function: nop_reverse
static int nop_reverse(int b, float complex *buffers[2], size_t N)
{
	int J = ctz(N);

	for (int j = J - 2; j >= 0; j--, b++) {
		size_t delta = N >> j;

		for (size_t n = 0; n < N; n += delta) {
			nop_split(buffers[b&1] + n, buffers[~b&1] + n, delta);
		}
	}

	return b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1fd0
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
subl $0x2, %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jl 0x1e7d
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %ecx
shrq %cl, %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x1e64
movq -0x10(%rbp), %rax
movl -0x4(%rbp), %ecx
andl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
movq -0x30(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rax
movl -0x4(%rbp), %ecx
xorl $-0x1, %ecx
andl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rsi
movq -0x30(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
movq -0x28(%rbp), %rdx
callq 0x2010
movq -0x28(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x1e08
jmp 0x1e66
movl -0x20(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x1de8
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xbarin02[P]uFFT/ift-dif.c
// Function: fft_reverse
static int fft_reverse(int b, float complex *buffers[2], size_t N)
{
	int J = ctz(N);

	for (int j = J - 1; j >= 0; j--, b++) {
		size_t delta = N >> j;

		for (size_t n = 0; n < N; n += delta) {
			float complex phi = (float)revbits(n/delta, j) / (float)(2 << j);
			fft_split(buffers[b&1] + n, buffers[~b&1] + n, delta, phi);
		}
	}

	return b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1fd0
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jl 0x1fc7
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %ecx
shrq %cl, %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x1fae
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
xorl %edx, %edx
divq %rcx
movq %rax, %rdi
movl -0x20(%rbp), %esi
callq 0x20b0
movq %rax, %rdx
shrq %rdx
movl %eax, %ecx
andl $0x1, %ecx
orq %rdx, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
cvtsi2ss %rax, %xmm1
movss %xmm1, -0x48(%rbp)
testq %rax, %rax
movss %xmm0, -0x44(%rbp)
js 0x1f33
movss -0x48(%rbp), %xmm0
movss %xmm0, -0x44(%rbp)
movss -0x44(%rbp), %xmm0
movb -0x20(%rbp), %cl
movl $0x2, %eax
shll %cl, %eax
cvtsi2ss %eax, %xmm1
divss %xmm1, %xmm0
movss %xmm0, -0x38(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x10(%rbp), %rax
movl -0x4(%rbp), %edx
movl %edx, %ecx
andl $0x1, %ecx
movq (%rax,%rcx,8), %rsi
movq -0x30(%rbp), %rcx
leaq (%rsi,%rcx,8), %rdi
notl %edx
andl $0x1, %edx
movq (%rax,%rdx,8), %rax
leaq (%rax,%rcx,8), %rsi
movq -0x28(%rbp), %rdx
movss -0x38(%rbp), %xmm1
movss -0x34(%rbp), %xmm0
movss %xmm1, -0x40(%rbp)
movss %xmm0, -0x3c(%rbp)
movsd -0x40(%rbp), %xmm0
callq 0x2110
movq -0x28(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x1ed8
jmp 0x1fb0
movl -0x20(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x1eb8
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/util/getline.c
// Function: getline
ssize_t getline(char **lineptr, size_t *n, FILE *stream) {
    size_t pos;
    int c;

    if (lineptr == NULL || stream == NULL || n == NULL) {
        errno = EINVAL;
        return -1;
    }

    c = getc(stream);
    if (c == EOF) {
        return -1;
    }

    if (*lineptr == NULL) {
        *lineptr = (char *) malloc(128);
        if (*lineptr == NULL) {
            return -1;
        }
        *n = 128;
    }

    pos = 0;
    while(c != EOF) {
        if (pos + 1 >= *n) {
            size_t new_size = *n + (*n >> 2);
            if (new_size < 128) {
                new_size = 128;
            }
            char *new_ptr = (char *) realloc(*lineptr, new_size);
            if (new_ptr == NULL) {
                return -1;
            }
            *n = new_size;
            *lineptr = new_ptr;
        }

        ((unsigned char *)(*lineptr))[pos ++] = c;
        if (c == '\n') {
            break;
        }
        c = getc(stream);
    }

    (*lineptr)[pos] = '\0';
    return pos;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2639
cmpq $0x0, -0x20(%rbp)
je 0x2639
cmpq $0x0, -0x18(%rbp)
jne 0x2651
callq 0x2040
movl $0x16, (%rax)
movq $-0x1, -0x8(%rbp)
jmp 0x2787
movq -0x20(%rbp), %rdi
callq 0x20b0
movl %eax, -0x2c(%rbp)
cmpl $-0x1, -0x2c(%rbp)
jne 0x2670
movq $-0x1, -0x8(%rbp)
jmp 0x2787
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x26b0
movl $0x80, %edi
callq 0x2350
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x26a5
movq $-0x1, -0x8(%rbp)
jmp 0x2787
movq -0x18(%rbp), %rax
movq $0x80, (%rax)
movq $0x0, -0x28(%rbp)
cmpl $-0x1, -0x2c(%rbp)
je 0x2770
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jb 0x2739
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
shrq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
cmpq $0x80, -0x38(%rbp)
jae 0x26fe
movq $0x80, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x38(%rbp), %rsi
callq 0x2450
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x2723
movq $-0x1, -0x8(%rbp)
jmp 0x2787
movq -0x38(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x40(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl -0x2c(%rbp), %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x28(%rbp)
movb %dl, (%rax,%rcx)
cmpl $0xa, -0x2c(%rbp)
jne 0x275f
jmp 0x2770
movq -0x20(%rbp), %rdi
callq 0x20b0
movl %eax, -0x2c(%rbp)
jmp 0x26b8
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/util/debug.cpp
// Function: fog_debug_log(char const*, _IO_FILE*, char const*, int, char const*, char const*, ...)
void _fog_debug_log(const char* type, FILE* stream, const char* file,
                    int line, const char *func, const char* fmt, ...) {
    // TODO(ed): Log file with timestamps?
    va_list args;
    va_start(args, fmt);
#ifdef VIM_JUMP_TO
    fprintf(stream, "%s|%d| (%s) [%s]: ", file, line, func, type);
#else
    fprintf(stream, "%s @ %d (%s) [%s]:\n-- ", file, line, func, type);
#endif
    vfprintf(stream, fmt, args);
    va_end(args);
    fprintf(stream, "\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
testb %al, %al
je 0x27de
movaps %xmm0, -0xd0(%rbp)
movaps %xmm1, -0xc0(%rbp)
movaps %xmm2, -0xb0(%rbp)
movaps %xmm3, -0xa0(%rbp)
movaps %xmm4, -0x90(%rbp)
movaps %xmm5, -0x80(%rbp)
movaps %xmm6, -0x70(%rbp)
movaps %xmm7, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
leaq -0x100(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x30, -0x4c(%rbp)
movl $0x30, -0x50(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %r8
movq -0x8(%rbp), %r9
leaq 0x25ee0(%rip), %rsi     # 0x28710
xorl %eax, %eax
movb %al, -0x101(%rbp)
callq 0x23b0
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0x2360
movb -0x101(%rbp), %al
movq -0x10(%rbp), %rdi
leaq 0x2613c(%rip), %rsi     # 0x2899b
callq 0x23b0
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/math/block_vector.h
// Function: V4(Vec3, float)
Vec4 V4(Vec3 v, real x4 = 1.0f) {
    return {
        v.x,
        v.y,
        v.z,
    };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movlpd %xmm0, -0x30(%rbp)
movss %xmm1, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movss %xmm2, -0x34(%rbp)
movss -0x20(%rbp), %xmm0
movss %xmm0, -0x10(%rbp)
movss -0x1c(%rbp), %xmm0
movss %xmm0, -0xc(%rbp)
movss -0x18(%rbp), %xmm0
movss %xmm0, -0x8(%rbp)
movl $0x0, -0x4(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/math/block_matrix.h
// Function: translate(Mat4, Vec3)
Mat4 translate(Mat4 m, Vec3 v) {
    m._03 += v.x;
    m._13 += v.y;
    m._23 += v.z;

    return m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, %rax
movq %rax, -0x28(%rbp)
leaq 0x10(%rbp), %rsi
movlpd %xmm0, -0x1c(%rbp)
movss %xmm1, -0x14(%rbp)
movq -0x1c(%rbp), %rax
movq %rax, -0xc(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movss -0xc(%rbp), %xmm0
addss 0xc(%rsi), %xmm0
movss %xmm0, 0xc(%rsi)
movss -0x8(%rbp), %xmm0
addss 0x1c(%rsi), %xmm0
movss %xmm0, 0x1c(%rsi)
movss -0x4(%rbp), %xmm0
addss 0x2c(%rsi), %xmm0
movss %xmm0, 0x2c(%rsi)
movl $0x40, %edx
callq 0x2200
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/math/block_matrix.h
// Function: scale(Mat4, Vec3)
Mat4 scale(Mat4 m, Vec3 v) {
    m._00 *= v.x;
    m._10 *= v.x;
    m._20 *= v.x;
    m._01 *= v.y;
    m._11 *= v.y;
    m._21 *= v.y;
    m._02 *= v.z;
    m._12 *= v.z;
    m._22 *= v.z;
    return m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, %rax
movq %rax, -0x28(%rbp)
leaq 0x10(%rbp), %rsi
movlpd %xmm0, -0x1c(%rbp)
movss %xmm1, -0x14(%rbp)
movq -0x1c(%rbp), %rax
movq %rax, -0xc(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movss -0xc(%rbp), %xmm0
mulss (%rsi), %xmm0
movss %xmm0, (%rsi)
movss -0xc(%rbp), %xmm0
mulss 0x10(%rsi), %xmm0
movss %xmm0, 0x10(%rsi)
movss -0xc(%rbp), %xmm0
mulss 0x20(%rsi), %xmm0
movss %xmm0, 0x20(%rsi)
movss -0x8(%rbp), %xmm0
mulss 0x4(%rsi), %xmm0
movss %xmm0, 0x4(%rsi)
movss -0x8(%rbp), %xmm0
mulss 0x14(%rsi), %xmm0
movss %xmm0, 0x14(%rsi)
movss -0x8(%rbp), %xmm0
mulss 0x24(%rsi), %xmm0
movss %xmm0, 0x24(%rsi)
movss -0x4(%rbp), %xmm0
mulss 0x8(%rsi), %xmm0
movss %xmm0, 0x8(%rsi)
movss -0x4(%rbp), %xmm0
mulss 0x18(%rsi), %xmm0
movss %xmm0, 0x18(%rsi)
movss -0x4(%rbp), %xmm0
mulss 0x28(%rsi), %xmm0
movss %xmm0, 0x28(%rsi)
movl $0x40, %edx
callq 0x2200
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/math/block_matrix.h
// Function: scale(Mat4, float)
Mat4 scale(Mat4 m, real scalar) {
    m._00 *= scalar;
    m._10 *= scalar;
    m._20 *= scalar;
    m._01 *= scalar;
    m._11 *= scalar;
    m._21 *= scalar;
    m._02 *= scalar;
    m._12 *= scalar;
    m._22 *= scalar;

    return m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, %rax
movq %rax, -0x10(%rbp)
leaq 0x10(%rbp), %rsi
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
mulss (%rsi), %xmm0
movss %xmm0, (%rsi)
movss -0x4(%rbp), %xmm0
mulss 0x10(%rsi), %xmm0
movss %xmm0, 0x10(%rsi)
movss -0x4(%rbp), %xmm0
mulss 0x20(%rsi), %xmm0
movss %xmm0, 0x20(%rsi)
movss -0x4(%rbp), %xmm0
mulss 0x4(%rsi), %xmm0
movss %xmm0, 0x4(%rsi)
movss -0x4(%rbp), %xmm0
mulss 0x14(%rsi), %xmm0
movss %xmm0, 0x14(%rsi)
movss -0x4(%rbp), %xmm0
mulss 0x24(%rsi), %xmm0
movss %xmm0, 0x24(%rsi)
movss -0x4(%rbp), %xmm0
mulss 0x8(%rsi), %xmm0
movss %xmm0, 0x8(%rsi)
movss -0x4(%rbp), %xmm0
mulss 0x18(%rsi), %xmm0
movss %xmm0, 0x18(%rsi)
movss -0x4(%rbp), %xmm0
mulss 0x28(%rsi), %xmm0
movss %xmm0, 0x28(%rsi)
movl $0x40, %edx
callq 0x2200
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/math/block_matrix.h
// Function: create_skew_symmetric(Vec3)
Mat4 create_skew_symmetric(Vec3 v) {
    Mat4 m;
    m._00 = m._11 = m._22 = m._33 = 0.0f;
    m._10 = v.z;
    m._01 = -v.z;
    m._02 = v.y;
    m._20 = -v.y;
    m._13 = v.z;
    m._31 = -v.z;
    return m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movlpd %xmm0, -0x1c(%rbp)
movss %xmm1, -0x14(%rbp)
movq -0x1c(%rbp), %rcx
movq %rcx, -0xc(%rbp)
movl -0x14(%rbp), %ecx
movl %ecx, -0x4(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, 0x3c(%rdi)
xorps %xmm0, %xmm0
movss %xmm0, 0x28(%rdi)
xorps %xmm0, %xmm0
movss %xmm0, 0x14(%rdi)
xorps %xmm0, %xmm0
movss %xmm0, (%rdi)
movss -0x4(%rbp), %xmm0
movss %xmm0, 0x10(%rdi)
movss -0x4(%rbp), %xmm0
movd %xmm0, %ecx
xorl $0x80000000, %ecx       # imm = 0x80000000
movd %ecx, %xmm0
movss %xmm0, 0x4(%rdi)
movss -0x8(%rbp), %xmm0
movss %xmm0, 0x8(%rdi)
movss -0x8(%rbp), %xmm0
movd %xmm0, %ecx
xorl $0x80000000, %ecx       # imm = 0x80000000
movd %ecx, %xmm0
movss %xmm0, 0x20(%rdi)
movss -0x4(%rbp), %xmm0
movss %xmm0, 0x1c(%rdi)
movss -0x4(%rbp), %xmm0
movd %xmm0, %ecx
xorl $0x80000000, %ecx       # imm = 0x80000000
movd %ecx, %xmm0
movss %xmm0, 0x34(%rdi)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/math/block_matrix.h
// Function: zero_transform(Mat4)
Mat4 zero_transform(Mat4 m) {
    m._03 = 0.0f;
    m._13 = 0.0f;
    m._23 = 0.0f;
    m._33 = 1.0f;
    return m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, %rax
movq %rax, -0x8(%rbp)
leaq 0x10(%rbp), %rsi
xorps %xmm0, %xmm0
movss %xmm0, 0xc(%rsi)
xorps %xmm0, %xmm0
movss %xmm0, 0x1c(%rsi)
xorps %xmm0, %xmm0
movss %xmm0, 0x2c(%rsi)
movss 0x23b31(%rip), %xmm0    # 0x28004
movss %xmm0, 0x3c(%rsi)
movl $0x40, %edx
callq 0x2200
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/math/block_matrix.h
// Function: create_perspective_projection(float, float, float, float)
Mat4 create_perspective_projection(real fov, real aspect_ratio, real near_clip,
                                   real far_clip) {
    real w = tan(fov / 2.0f);

    Mat4 m = {};
    m._00 = 1.0f / (aspect_ratio * w);
    m._11 = 1.0f / w;
    m._22 = -(far_clip + near_clip) / (far_clip - near_clip);
    m._32 = -1.0f;
    m._23 = -(2.0f * far_clip * near_clip) / (far_clip - near_clip);
    return m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, -0x20(%rbp)
movss %xmm0, -0x4(%rbp)
movss %xmm1, -0x8(%rbp)
movss %xmm2, -0xc(%rbp)
movss %xmm3, -0x10(%rbp)
movss -0x4(%rbp), %xmm0
movss 0x23aeb(%rip), %xmm1    # 0x2800c
divss %xmm1, %xmm0
callq 0x20ed0
movq -0x28(%rbp), %rdi
movss %xmm0, -0x14(%rbp)
xorl %esi, %esi
movl $0x40, %edx
callq 0x2150
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movss -0x8(%rbp), %xmm1
mulss -0x14(%rbp), %xmm1
movss 0x23aab(%rip), %xmm0    # 0x28004
divss %xmm1, %xmm0
movss %xmm0, (%rdi)
movss 0x23a9b(%rip), %xmm0    # 0x28004
divss -0x14(%rbp), %xmm0
movss %xmm0, 0x14(%rdi)
movss -0x10(%rbp), %xmm0
addss -0xc(%rbp), %xmm0
movd %xmm0, %ecx
xorl $0x80000000, %ecx       # imm = 0x80000000
movd %ecx, %xmm0
movss -0x10(%rbp), %xmm1
subss -0xc(%rbp), %xmm1
divss %xmm1, %xmm0
movss %xmm0, 0x28(%rdi)
movss 0x23a6a(%rip), %xmm0    # 0x28010
movss %xmm0, 0x38(%rdi)
movss 0x23a59(%rip), %xmm0    # 0x2800c
mulss -0x10(%rbp), %xmm0
mulss -0xc(%rbp), %xmm0
movd %xmm0, %ecx
xorl $0x80000000, %ecx       # imm = 0x80000000
movd %ecx, %xmm0
movss -0x10(%rbp), %xmm1
subss -0xc(%rbp), %xmm1
divss %xmm1, %xmm0
movss %xmm0, 0x2c(%rdi)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/math/block_matrix.h
// Function: transpose(Mat4)
Mat4 transpose(Mat4 m) {
    Mat4 t = {};

    for (u8 i = 0; i < 4; i++)
        for (u8 j = 0; j < 4; j++) t._[i][j] = m._[j][i];

    return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
movq %rax, -0x18(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
xorl %esi, %esi
movl $0x40, %edx
callq 0x2150
movb $0x0, -0x1(%rbp)
movzbl -0x1(%rbp), %eax
cmpl $0x4, %eax
jge 0x4677
movb $0x0, -0x2(%rbp)
movzbl -0x2(%rbp), %eax
cmpl $0x4, %eax
jge 0x466b
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movzbl -0x2(%rbp), %edx
shlq $0x4, %rdx
addq %rdx, %rcx
movzbl -0x1(%rbp), %edx
movss (%rcx,%rdx,4), %xmm0
movzbl -0x1(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movzbl -0x2(%rbp), %ecx
movss %xmm0, (%rax,%rcx,4)
movb -0x2(%rbp), %al
addb $0x1, %al
movb %al, -0x2(%rbp)
jmp 0x4628
jmp 0x466d
movb -0x1(%rbp), %al
addb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x461b
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/math/block_math.h
// Function: std_progress_func_vec4(Vec4, float, Vec4, float, float)
Vec4 std_progress_func_vec4(Vec4 start_value, f32 start_slope, Vec4 end_value, f32 end_slope, f32 progress) {
    f32 p = -2 + start_slope + end_slope;
    f32 q = -(-3 + 2 * start_slope + end_slope);
    f32 y = p * pow(progress, 3) + q * pow(progress, 2) + start_slope*progress;
    return LERP(start_value, end_value, y);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movlpd %xmm0, -0x20(%rbp)
movlpd %xmm1, -0x18(%rbp)
movlpd %xmm3, -0x30(%rbp)
movlpd %xmm4, -0x28(%rbp)
movss %xmm2, -0x34(%rbp)
movss %xmm5, -0x38(%rbp)
movss %xmm6, -0x3c(%rbp)
movss -0x34(%rbp), %xmm0
movss 0x229ad(%rip), %xmm1    # 0x28018
addss %xmm1, %xmm0
movss -0x38(%rbp), %xmm1
addss %xmm1, %xmm0
movss %xmm0, -0x40(%rbp)
movss -0x34(%rbp), %xmm0
addss %xmm0, %xmm0
movss 0x2298e(%rip), %xmm1    # 0x2801c
addss %xmm1, %xmm0
movss -0x38(%rbp), %xmm1
addss %xmm1, %xmm0
movaps 0x2299e(%rip), %xmm1    # 0x28040
pxor %xmm1, %xmm0
movss %xmm0, -0x44(%rbp)
movss -0x40(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x70(%rbp)
movss -0x3c(%rbp), %xmm0
movl $0x3, %edi
callq 0x20ef0
movsd %xmm0, -0x78(%rbp)
movss -0x44(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x80(%rbp)
movss -0x3c(%rbp), %xmm0
movl $0x2, %edi
callq 0x20ef0
movsd -0x80(%rbp), %xmm1
movsd -0x78(%rbp), %xmm2
movaps %xmm0, %xmm3
movsd -0x70(%rbp), %xmm0
mulsd %xmm3, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movss -0x34(%rbp), %xmm1
movss -0x3c(%rbp), %xmm2
mulss %xmm2, %xmm1
cvtss2sd %xmm1, %xmm1
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x48(%rbp)
movss -0x48(%rbp), %xmm1
movss 0x228d0(%rip), %xmm0    # 0x28004
subss %xmm1, %xmm0
leaq -0x20(%rbp), %rdi
callq 0x20d70
movlpd %xmm0, -0x58(%rbp)
movlpd %xmm1, -0x50(%rbp)
movss -0x48(%rbp), %xmm0
leaq -0x30(%rbp), %rdi
callq 0x20d70
movlpd %xmm0, -0x68(%rbp)
movlpd %xmm1, -0x60(%rbp)
movsd -0x68(%rbp), %xmm0
movsd -0x60(%rbp), %xmm1
leaq -0x58(%rbp), %rdi
callq 0x20c90
movlpd %xmm0, -0x10(%rbp)
movlpd %xmm1, -0x8(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/math/block_math.h
// Function: binomial(unsigned int, unsigned int)
u32 binomial(u32 n, u32 k) {
    u32 res = 1;

    // k and n-k have the same binomial coeff so only calculate the "shorter"
    if (k > n - k)
        k = n - k;

    for (u32 i = 0; i < k; i++) {
        res *= (n - i);
        res /= (i + 1);
    }
    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x1, -0xc(%rbp)
movl -0x8(%rbp), %eax
movl -0x4(%rbp), %ecx
subl -0x8(%rbp), %ecx
cmpl %ecx, %eax
jbe 0x57c7
movl -0x4(%rbp), %eax
subl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x8(%rbp), %eax
jae 0x57fe
movl -0x4(%rbp), %eax
subl -0x10(%rbp), %eax
imull -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %ecx
addl $0x1, %ecx
movl -0xc(%rbp), %eax
xorl %edx, %edx
divl %ecx
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x57ce
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/math/random.cpp
// Function: random_seed(unsigned int)
void random_seed(u32 seed) {
    // Generated random numbers from random.org.
    //
    // This makes it deterministic, which you might
    // not want.
    random_state.a = 398973565 ^ seed;
    random_state.b = 141307319 ^ seed;
    random_state.c =  15804145 ^ seed;
    random_state.d = 296129167 ^ seed;
    random_state.counter = 100;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
xorl $0x17c7da7d, %eax       # imm = 0x17C7DA7D
movl %eax, 0x2db13(%rip)     # 0x33338
movl -0x4(%rbp), %eax
xorl $0x86c2db7, %eax        # imm = 0x86C2DB7
movl %eax, 0x2db09(%rip)     # 0x3333c
movl -0x4(%rbp), %eax
xorl $0xf126f1, %eax         # imm = 0xF126F1
movl %eax, 0x2daff(%rip)     # 0x33340
movl -0x4(%rbp), %eax
xorl $0x11a6928f, %eax       # imm = 0x11A6928F
movl %eax, 0x2daf5(%rip)     # 0x33344
movl $0x64, 0x2daef(%rip)    # 0x33348
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/math/random.cpp
// Function: xorwow()
u32 xorwow() {
    // Algorithm "xorwow" from p. 5 of Marsaglia, "Xorshift RNGs"
    // Stolen straight from Wikipedia.
    u32 t = random_state.d;

    u32 s = random_state.a;
    random_state.d = random_state.c;
    random_state.c = random_state.b;
    random_state.b = s;

    t ^= t >> 2;
    t ^= t << 1;
    t ^= s ^ (s << 4);
    random_state.a = t;

    random_state.counter += 362437;
    return t + random_state.counter;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x2dada(%rip), %eax     # 0x33344
movl %eax, -0x4(%rbp)
movl 0x2dac5(%rip), %eax     # 0x33338
movl %eax, -0x8(%rbp)
movl 0x2dac4(%rip), %eax     # 0x33340
movl %eax, 0x2dac2(%rip)     # 0x33344
movl 0x2dab4(%rip), %eax     # 0x3333c
movl %eax, 0x2dab2(%rip)     # 0x33340
movl -0x8(%rbp), %eax
movl %eax, 0x2daa5(%rip)     # 0x3333c
movl -0x4(%rbp), %eax
shrl $0x2, %eax
xorl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
shll %eax
xorl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x8(%rbp), %eax
movl -0x8(%rbp), %ecx
shll $0x4, %ecx
xorl %ecx, %eax
xorl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, 0x2da70(%rip)     # 0x33338
movl 0x2da7a(%rip), %eax     # 0x33348
addl $0x587c5, %eax          # imm = 0x587C5
movl %eax, 0x2da6f(%rip)     # 0x33348
movl -0x4(%rbp), %eax
addl 0x2da66(%rip), %eax     # 0x33348
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/math/random.cpp
// Function: random_unit_vec2()
Vec2 random_unit_vec2() {
    Vec2 out;
    while (true) {
        out = {random_real(-1, 1), random_real(-1, 1)};
        f32 sq = length_squared(out);
        if (sq > 1.0 || sq == 0.0)
            continue;
        return normalize(out);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movss 0x22690(%rip), %xmm0    # 0x28010
movss %xmm0, -0x34(%rbp)
movss 0x22677(%rip), %xmm1    # 0x28004
movss %xmm1, -0x38(%rbp)
callq 0x5920
movss -0x38(%rbp), %xmm1
movaps %xmm0, %xmm2
movss -0x34(%rbp), %xmm0
movss %xmm2, -0x18(%rbp)
callq 0x5920
movss %xmm0, -0x14(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
callq 0x2a00
movss %xmm0, -0x1c(%rbp)
movss -0x1c(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x22675(%rip), %xmm1    # 0x28058
ucomisd %xmm1, %xmm0
ja 0x59fd
movss -0x1c(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x5a02
jp 0x5a02
jmp 0x5978
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
callq 0x2aa0
movlpd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/math/random.cpp
// Function: random_unit_vec3()
Vec3 random_unit_vec3() {
    Vec3 out;
    while (true) {
        out = {random_real(-1, 1), random_real(-1, 1), random_real(-1, 1)};
        f32 sq = length_squared(out);
        if (sq > 1.0 || sq == 0.0)
            continue;
        return normalize(out);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movss 0x225cd(%rip), %xmm0    # 0x28010
movss %xmm0, -0x94(%rbp)
movss 0x225b1(%rip), %xmm1    # 0x28004
movss %xmm1, -0x98(%rbp)
callq 0x5920
movss -0x98(%rbp), %xmm1
movaps %xmm0, %xmm2
movss -0x94(%rbp), %xmm0
movss %xmm2, -0x2c(%rbp)
callq 0x5920
movss -0x98(%rbp), %xmm1
movaps %xmm0, %xmm2
movss -0x94(%rbp), %xmm0
movss %xmm2, -0x28(%rbp)
callq 0x5920
movss %xmm0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x2c(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x48(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
movsd -0x50(%rbp), %xmm0
movss -0x48(%rbp), %xmm1
callq 0x2e80
movss %xmm0, -0x30(%rbp)
movss -0x30(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x2256a(%rip), %xmm1    # 0x28058
ucomisd %xmm1, %xmm0
ja 0x5b08
movss -0x30(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x5b0d
jp 0x5b0d
jmp 0x5a3b
movl -0x18(%rbp), %eax
movl %eax, -0x58(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
movl -0x58(%rbp), %eax
movl %eax, -0x68(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x70(%rbp)
movsd -0x70(%rbp), %xmm0
movss -0x68(%rbp), %xmm1
callq 0x2f30
movss %xmm1, -0x78(%rbp)
movlpd %xmm0, -0x80(%rbp)
movl -0x78(%rbp), %eax
movl %eax, -0x8(%rbp)
movq -0x80(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x88(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movsd -0x90(%rbp), %xmm0
movss -0x88(%rbp), %xmm1
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/asset/asset.h
// Function: Asset::asset_hash(char const*)
u64 asset_hash(const char *str) {
    // This number is pretty arbitrary, it's prime and that's nice.
    u64 hash = 5351;
    while (*str) {
        char c = (*str++);
        hash = hash * c + c;
    }
    return hash % 0x0FFFFFFF;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x14e7, -0x10(%rbp)    # imm = 0x14E7
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0x5bc8
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb (%rax), %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movsbq -0x11(%rbp), %rcx
imulq %rcx, %rax
movsbq -0x11(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
jmp 0x5b90
movq -0x10(%rbp), %rax
movl $0xfffffff, %ecx        # imm = 0xFFFFFFF
xorl %edx, %edx
divq %rcx
movq %rdx, %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/unix_assets.cpp
// Function: get_asset_header(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const*, Asset::Type)
Asset::Header get_asset_header(const std::string *path, Asset::Type type) {
    char *file_path = (char *) malloc(path->size() * sizeof(path[0]));
    const char *from = path->c_str();
    char *to = file_path;
    while (*from) *(to++) = *(from++);
    *(to++) = *(from++);
    // struct stat buffer;
    // if (stat(file_path, &buffer) == -1) return {};

    return {type,
            file_path,
            path->size() + 1,
            0,  // buffer.st_mtime,
            0,  //(u32) buffer.st_size,
            0,
            Asset::ASSET_ID_NO_ASSET};
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, -0x30(%rbp)
movq %rsi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x21a0
movq %rax, %rdi
shlq $0x5, %rdi
callq 0x2350
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x20f0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpb $0x0, (%rax)
je 0x7602
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movb (%rax), %cl
movq -0x28(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x28(%rbp)
movb %cl, (%rax)
jmp 0x75d5
movq -0x38(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb (%rcx), %dl
movq -0x28(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x28(%rbp)
movb %dl, (%rcx)
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
callq 0x21a0
movq -0x38(%rbp), %rcx
movq %rax, %rdx
movq -0x30(%rbp), %rax
addq $0x1, %rdx
movq %rdx, 0x10(%rcx)
movq $0x0, 0x18(%rcx)
movq $0x0, 0x20(%rcx)
movq $0x0, 0x28(%rcx)
movl $0xffffffff, 0x30(%rcx) # imm = 0xFFFFFFFF
movl $0x0, 0x34(%rcx)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/unix_assets.cpp
// Function: add_asset_to_file(AssetFile*, Asset::Header*, Asset::Data*)
void add_asset_to_file(AssetFile *file, Asset::Header *header, Asset::Data *asset) {
    assert(header);
    assert(asset);
    header->asset_id = file->asset_headers.size();

    file->header.number_of_assets++;
    file->header.size_of_strings += header->file_path_length;
    file->header.size_of_headers += sizeof(Asset::Header);
    file->header.size_of_data += header->asset_size;

    file->asset_headers.push_back(*header);
    file->assets.push_back(*asset);
    assert(file->asset_headers.size() == file->assets.size());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x769d
jmp 0x76bc
leaq 0x215f6(%rip), %rdi     # 0x28c9a
leaq 0x210a9(%rip), %rsi     # 0x28754
movl $0x57, %edx
leaq 0x210b8(%rip), %rcx     # 0x2876f
callq 0x2180
cmpq $0x0, -0x18(%rbp)
je 0x76c5
jmp 0x76e4
leaq 0x210e7(%rip), %rdi     # 0x287b3
leaq 0x21081(%rip), %rsi     # 0x28754
movl $0x58, %edx
leaq 0x21090(%rip), %rcx     # 0x2876f
callq 0x2180
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
callq 0x20f60
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x34(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x38, %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl 0x30(%rax), %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
addq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
movq -0x10(%rbp), %rsi
callq 0x20f90
movq -0x8(%rbp), %rdi
addq $0x38, %rdi
movq -0x18(%rbp), %rsi
callq 0x21000
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
callq 0x20f60
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
addq $0x38, %rdi
callq 0x21070
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jne 0x778f
jmp 0x77ae
leaq 0x21023(%rip), %rdi     # 0x287b9
leaq 0x20fb7(%rip), %rsi     # 0x28754
movl $0x62, %edx
leaq 0x20fc6(%rip), %rcx     # 0x2876f
callq 0x2180
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/unix_assets.cpp
// Function: load_texture(AssetFile*, Asset::Header*, unsigned char)
void load_texture(AssetFile *file, Asset::Header *header, b8 flip=true) {
    static u16 id = 0;
    int w, h, c;
    // NOTE(ed): Kinda a ugly hack, the sprite atlases aren't flipped, but the
    // normal sprites are.
    stbi_set_flip_vertically_on_load(flip);
    u8 *buffer = stbi_load(header->file_path, &w, &h, &c, 0);
    if (w > 512 || h > 512) {
        printf("\tCannot load %s, because it is too large.\n", header->file_path);
        return;
    }
    if (!buffer) {
        printf("\tFailed to load image %s", header->file_path);
        return;
    }
    Image image = {buffer, (u32) w, (u32) h, (u8) c, id++};
    header->asset_size = sizeof(Asset::Data) + w * h * c * sizeof(u8);
    Asset::Data asset = {image};

    add_asset_to_file(file, header, &asset);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movzbl -0x11(%rbp), %edi
callq 0x5c10
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x18(%rbp), %rsi
leaq -0x1c(%rbp), %rdx
leaq -0x20(%rbp), %rcx
xorl %r8d, %r8d
callq 0x5c30
movq %rax, -0x28(%rbp)
cmpl $0x200, -0x18(%rbp)     # imm = 0x200
jg 0x7810
cmpl $0x200, -0x1c(%rbp)     # imm = 0x200
jle 0x782b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x20fcc(%rip), %rdi     # 0x287eb
movb $0x0, %al
callq 0x2050
jmp 0x78c4
cmpq $0x0, -0x28(%rbp)
jne 0x784a
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x20fd5(%rip), %rdi     # 0x28816
movb $0x0, %al
callq 0x2050
jmp 0x78c4
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x20(%rbp), %eax
movb %al, -0x30(%rbp)
movw 0x2bb35(%rip), %ax      # 0x333a0
movw %ax, %cx
addw $0x1, %cx
movw %cx, 0x2bb27(%rip)      # 0x333a0
movw %ax, -0x2e(%rbp)
movl -0x18(%rbp), %eax
imull -0x1c(%rbp), %eax
imull -0x20(%rbp), %eax
cltq
shlq $0x0, %rax
addq $0x30, %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x40(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x70(%rbp), %rdx
callq 0x7680
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/unix_assets.cpp
// Function: load_shader(AssetFile*, Asset::Header*)
void load_shader(AssetFile *file, Asset::Header *header) {
    FILE *shader_file = fopen(header->file_path, "rb");
    fseek(shader_file, 0, SEEK_END);
    long size = ftell(shader_file) + 1;
    rewind(shader_file);

    header->asset_size = size;
    Asset::Data asset = {.shader_source = (char *) malloc(size)};
    fread(asset.shader_source, 1, size, shader_file);
    asset.shader_source[size - 1] = '\0';

    add_asset_to_file(file, header, &asset);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x207d6(%rip), %rsi     # 0x28745
callq 0x22f0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x22e0
movq -0x18(%rbp), %rdi
callq 0x2030
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2070
movq -0x20(%rbp), %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x30(%rax)
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x2150
movq -0x20(%rbp), %rdi
callq 0x2350
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl $0x1, %esi
callq 0x23e0
movq -0x50(%rbp), %rax
movq -0x20(%rbp), %rcx
subq $0x1, %rcx
movb $0x0, (%rax,%rcx)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0x7680
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/unix_assets.cpp
// Function: process_asset(AssetFile*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const*)
void process_asset(AssetFile *file, const std::string *path) {
    size_t pos = path->find_last_of(".");
    if (pos == std::string::npos) return;
    std::string file_ending = path->substr(pos);
    if (!valid_endings.count(file_ending)) return;
    Asset::Type type = valid_endings[file_ending];

    Asset::Header header = get_asset_header(path, type);
    switch (header.type) {
        case (Asset::Type::TEXTURE): load_texture(file, &header); break;
        case (Asset::Type::FONT):    load_font(file, &header);    break;
        case (Asset::Type::SOUND):   load_sound(file, &header);   break;
        case (Asset::Type::SHADER):  load_shader(file, &header);  break;
        case (Asset::Type::SPRITE):  load_sprite(file, &header);  break;
        default:
            printf("!!!! Unhandled asset, unkown type: %s, %d\n", path->c_str(),
                   (int) header.type);
            return;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x20288(%rip), %rsi     # 0x289d6
movq $-0x1, %rdx
callq 0x2250
movq %rax, -0x18(%rbp)
cmpq $-0x1, -0x18(%rbp)
jne 0x876a
jmp 0x88e5
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x38(%rbp), %rdi
movq %rdi, -0x98(%rbp)
movq $-0x1, %rcx
callq 0x2290
movq -0x98(%rbp), %rsi
leaq 0x2abd1(%rip), %rdi     # 0x33368
callq 0x21140
movq %rax, -0x90(%rbp)
jmp 0x87a5
movq -0x90(%rbp), %rax
cmpq $0x0, %rax
jne 0x87d8
movl $0x1, -0x48(%rbp)
jmp 0x88dc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2170
jmp 0x88ee
leaq 0x2ab89(%rip), %rdi     # 0x33368
leaq -0x38(%rbp), %rsi
callq 0x21170
movq %rax, -0xa0(%rbp)
jmp 0x87f1
movq -0xa0(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4c(%rbp)
movq -0x10(%rbp), %rsi
movl -0x4c(%rbp), %edx
leaq -0x88(%rbp), %rdi
callq 0x7590
movl -0x88(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0xa8(%rbp)
subl $0x4, %eax
ja 0x88aa
movq -0xa8(%rbp), %rax
leaq 0x1f828(%rip), %rcx     # 0x28060
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
leaq -0x88(%rbp), %rsi
movl $0x1, %edx
callq 0x77c0
jmp 0x8858
jmp 0x88d5
movq -0x8(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x79d0
jmp 0x886c
jmp 0x88d5
movq -0x8(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x84c0
jmp 0x8880
jmp 0x88d5
movq -0x8(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x7f50
jmp 0x8894
jmp 0x88d5
movq -0x8(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x8010
jmp 0x88a8
jmp 0x88d5
movq -0x10(%rbp), %rdi
callq 0x20f0
movq %rax, %rsi
movl -0x88(%rbp), %edx
leaq 0x20115(%rip), %rdi     # 0x289d8
xorl %eax, %eax
callq 0x2050
jmp 0x88cc
movl $0x1, -0x48(%rbp)
jmp 0x88dc
movl $0x0, -0x48(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2170
addq $0xb0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x2470
nopw (%rax,%rax)