LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/mist64[P]cbmbasic/runtime.c
// Function: plugin_off
static void
plugin_off() {
	unsigned short dummy;

	if (!plugin)
		return;

	replace_vector(VEC_ERROR, orig_error, &dummy);
	replace_vector(VEC_MAIN, orig_main, &dummy);
	replace_vector(VEC_CRNCH, orig_crnch, &dummy);
	replace_vector(VEC_QPLOP, orig_qplop, &dummy);
	replace_vector(VEC_GONE, orig_gone, &dummy);
	replace_vector(VEC_EVAL, orig_eval, &dummy);

	plugin = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpl $0x0, 0x1cc01(%rip)     # 0x5aba0
jne 0x3dfa6
jmp 0x3e02e
movl $0x300, %edi            # imm = 0x300
leaq -0x2(%rbp), %rdx
movzwl 0x1cbee(%rip), %esi     # 0x5aba4
callq 0x3bcf0
movl $0x302, %edi            # imm = 0x302
leaq -0x2(%rbp), %rdx
movzwl 0x1cbdb(%rip), %esi     # 0x5aba6
callq 0x3bcf0
movl $0x304, %edi            # imm = 0x304
leaq -0x2(%rbp), %rdx
movzwl 0x1cbc8(%rip), %esi     # 0x5aba8
callq 0x3bcf0
movl $0x306, %edi            # imm = 0x306
leaq -0x2(%rbp), %rdx
movzwl 0x1cbb5(%rip), %esi     # 0x5abaa
callq 0x3bcf0
movl $0x308, %edi            # imm = 0x308
leaq -0x2(%rbp), %rdx
movzwl 0x1cba2(%rip), %esi     # 0x5abac
callq 0x3bcf0
movl $0x30a, %edi            # imm = 0x30A
leaq -0x2(%rbp), %rdx
movzwl 0x1cb8f(%rip), %esi     # 0x5abae
callq 0x3bcf0
movl $0x0, 0x1cb72(%rip)     # 0x5aba0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/mist64[P]cbmbasic/plugin.c
// Function: compare
int
compare(const char *s1) {
	const unsigned char *s = (const unsigned char *)s1;
	unsigned short chrptr = get_chrptr();

	while (*s) {
		CHRGET();
		if (A != *s++) {
			set_chrptr(chrptr);
			return 0;
		}
	}
	CHRGET();
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x3e480
movw %ax, -0x1a(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0x3e09f
callq 0x3b7f0
leaq 0x1ca43(%rip), %rax     # 0x5aab5
movzbl (%rax), %eax
movq -0x18(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movzbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x3e09d
movzwl -0x1a(%rbp), %edi
callq 0x3e0c0
movl $0x0, -0x4(%rbp)
jmp 0x3e0ab
jmp 0x3e05d
callq 0x3b7f0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mist64[P]cbmbasic/plugin.c
// Function: get_string
static void
get_string(char *s) {
	int i;

	call(0xAD9E);
	call(0xB6A3);
	for (i = 0; i < A; i++)
		s[i] = RAM[(X|(Y<<8))+i];
	s[A] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0xad9e, %edi           # imm = 0xAD9E
callq 0x3e4d0
movl $0xb6a3, %edi           # imm = 0xB6A3
callq 0x3e4d0
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
leaq 0x1c6a4(%rip), %rcx     # 0x5aab5
movzbl (%rcx), %ecx
cmpl %ecx, %eax
jge 0x3e457
leaq 0x1c693(%rip), %rax     # 0x5aab2
movzbl (%rax), %eax
leaq 0x1c68f(%rip), %rcx     # 0x5aab8
movzbl (%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
addl -0xc(%rbp), %eax
movslq %eax, %rcx
leaq 0xc672(%rip), %rax      # 0x4aab0
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3e407
movq -0x8(%rbp), %rax
leaq 0x1c653(%rip), %rcx     # 0x5aab5
movzbl (%rcx), %ecx
movb $0x0, (%rax,%rcx)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mist64[P]cbmbasic/console.c
// Function: reverse_screen
void reverse_screen(int c) {
#ifdef _WIN32
	/* No implementation for Windows yet */
#else /* ANSI */
   if (c == 1) {
     fputs("\033[7m", stdout);
   } else {
     fputs("\033[0m", stdout);
   }
	
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x1, -0x4(%rbp)
jne 0x3e6d9
movq 0x3918(%rip), %rax      # 0x41fe0
movq (%rax), %rsi
leaq 0x1534(%rip), %rdi      # 0x3fc06
callq 0x10d0
jmp 0x3e6ef
movq 0x3900(%rip), %rax      # 0x41fe0
movq (%rax), %rsi
leaq 0x1521(%rip), %rdi      # 0x3fc0b
callq 0x10d0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/tests/crypto_aes/main.c
// Function: perftest
static int
perftest(void)
{
	struct perftest_cookie_aes pca_actual;
	struct perftest_cookie_aes * pca = &pca_actual;
	uint8_t ciphertext_arr[16];
	size_t keylen;

	/* Sanity check. */
#ifdef CPUSUPPORT_X86_AESNI
	if (cpusupport_x86_aesni()) {
		if (crypto_aes_can_use_intrinsics() != 1) {
			warn0("Unexpected error with AESNI");
			goto err0;
		}
	}
#endif

	/* Inform user about the hardware optimization status. */
	print_hardware("Performance test of AES");
	fflush(stdout);

	/* Prepare arrays. */
	if (parse_testcase(perftestcase, &pca->key_exp, &keylen,
	    pca->plaintext_arr, ciphertext_arr)) {
		warn0("parse_testcase");
		goto err0;
	}

	/* Time the function. */
	if (perftest_buffers(nbytes_perftest, perfsizes, num_perf,
	    nbytes_warmup, 1, perftest_init, perftest_func, NULL, pca)) {
		warn0("perftest_buffers");
		goto err1;
	}

	/* Clean up. */
	crypto_aes_key_free(pca->key_exp);

	/* Success! */
	return (0);

err1:
	crypto_aes_key_free(pca->key_exp);
err0:
	/* Failure! */
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x18b0
cmpl $0x0, %eax
je 0x1516
callq 0x1f10
cmpl $0x1, %eax
je 0x1514
jmp 0x14f6
leaq 0x4b0d(%rip), %rdi      # 0x600a
movb $0x0, %al
callq 0x58b0
callq 0x1150
movl $0x0, (%rax)
jmp 0x161a
jmp 0x1516
leaq 0x4b09(%rip), %rdi      # 0x6026
callq 0x1920
movq 0x7ac7(%rip), %rax      # 0x8ff0
movq (%rax), %rdi
callq 0x11c0
movq -0x28(%rbp), %rdi
movq -0x28(%rbp), %rdx
addq $0x8, %rdx
leaq -0x40(%rbp), %rcx
leaq 0x7838(%rip), %rax      # 0x8d80
leaq -0x48(%rbp), %rsi
movq (%rax), %r8
movq %r8, (%rsp)
movq 0x8(%rax), %r8
movq %r8, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x1970
cmpl $0x0, %eax
je 0x158f
jmp 0x1571
leaq 0x4ac6(%rip), %rdi      # 0x603e
movb $0x0, %al
callq 0x58b0
callq 0x1150
movl $0x0, (%rax)
jmp 0x161a
movq -0x28(%rbp), %rax
movl $0x40000000, %edi       # imm = 0x40000000
leaq 0x4d71(%rip), %rsi      # 0x6310
movl $0x1, %edx
movl $0x9896800, %ecx        # imm = 0x9896800
movl $0x1, %r8d
leaq 0x59a(%rip), %r9        # 0x1b50
leaq 0x603(%rip), %r10       # 0x1bc0
xorl %r11d, %r11d
movq %r10, (%rsp)
movq $0x0, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x5050
cmpl $0x0, %eax
je 0x15f9
jmp 0x15de
leaq 0x4a68(%rip), %rdi      # 0x604d
movb $0x0, %al
callq 0x58b0
callq 0x1150
movl $0x0, (%rax)
jmp 0x160e
movq -0x28(%rbp), %rax
movq (%rax), %rdi
callq 0x20f0
movl $0x0, -0x4(%rbp)
jmp 0x1621
movq -0x28(%rbp), %rax
movq (%rax), %rdi
callq 0x20f0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/tests/crypto_aes/main.c
// Function: perftest_init
static int
perftest_init(void * cookie, uint8_t * buf, size_t buflen)
{
	struct perftest_cookie_aes * pca = cookie;

	/* AES only operates on a block of 16 bytes. */
	assert(buflen == 16);

	/* Set the plaintext input. */
	memcpy(buf, pca->plaintext_arr, buflen);

	/* Success! */
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x10, -0x18(%rbp)
jne 0x1b75
jmp 0x1b94
leaq 0x4648(%rip), %rdi      # 0x61c4
leaq 0x4530(%rip), %rsi      # 0x60b3
movl $0xad, %edx
leaq 0x4642(%rip), %rcx      # 0x61d1
callq 0x1080
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x8, %rsi
movq -0x18(%rbp), %rdx
callq 0x11b0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/tests/crypto_aes/main.c
// Function: perftest_func
static int
perftest_func(void * cookie, uint8_t * buf, size_t buflen, size_t nreps)
{
	struct perftest_cookie_aes * pca = cookie;
	size_t i;
#ifdef CPUSUPPORT_X86_AESNI
	__m128i bufsse;
#endif
#ifdef CPUSUPPORT_ARM_AES
	uint8x16_t bufarm;
#endif

	(void)buflen; /* UNUSED */

	/* Do the encryption. */
#ifdef CPUSUPPORT_X86_AESNI
	if (crypto_aes_can_use_intrinsics() == 1) {
		/* Load the plaintext. */
		bufsse = _mm_loadu_si128((const __m128i *)buf);

		/* Use the __m128i bufsse, instead of the normal buf. */
		for (i = 0; i < nreps; i++)
			bufsse = crypto_aes_encrypt_block_aesni_m128i(bufsse,
			    pca->key_exp);

		/* Store the output. */
		_mm_storeu_si128((__m128i *)buf, bufsse);
	} else
#endif
#ifdef CPUSUPPORT_ARM_AES
	if (crypto_aes_can_use_intrinsics() == 2) {
		/* Load the plaintext. */
		bufarm = vld1q_u8(buf);

		/* Use the _u8 bufarm, instead of the normal buf. */
		for (i = 0; i < nreps; i++)
			bufarm = crypto_aes_encrypt_block_arm_u8(bufarm,
			    pca->key_exp);

		/* Store the output. */
		vst1q_u8(buf, bufarm);
	} else
#endif
	for (i = 0; i < nreps; i++)
		crypto_aes_encrypt_block(buf, buf, pca->key_exp);

	/* Success! */
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x30(%rbp)
movq %rsi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
movq %rcx, -0x48(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0x1f10
cmpl $0x1, %eax
jne 0x1c56
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movdqu (%rax), %xmm0
movdqa %xmm0, -0x70(%rbp)
movq $0x0, -0x58(%rbp)
movq -0x58(%rbp), %rax
cmpq -0x48(%rbp), %rax
jae 0x1c35
movdqa -0x70(%rbp), %xmm0
movq -0x50(%rbp), %rax
movq (%rax), %rdi
callq 0x3bf0
movdqa %xmm0, -0x70(%rbp)
movq -0x58(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
jmp 0x1c07
movq -0x38(%rbp), %rax
movdqa -0x70(%rbp), %xmm0
movq %rax, -0x8(%rbp)
movdqa %xmm0, -0x20(%rbp)
movdqa -0x20(%rbp), %xmm0
movq -0x8(%rbp), %rax
movdqu %xmm0, (%rax)
jmp 0x1c8c
movq $0x0, -0x58(%rbp)
movq -0x58(%rbp), %rax
cmpq -0x48(%rbp), %rax
jae 0x1c8a
movq -0x38(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x50(%rbp), %rax
movq (%rax), %rdx
callq 0x20a0
movq -0x58(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
jmp 0x1c5e
jmp 0x1c8c
xorl %eax, %eax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MersenneTwister-Lab[P]MTGP/mtgp32-fast.c
// Function: mtgp32_init
int mtgp32_init(mtgp32_fast_t *mtgp32,
		const mtgp32_params_fast_t *para, uint32_t seed) {
    int rc;
    rc = alloc_state(mtgp32, para);
    if (rc) {
	return rc;
    }
    mtgp32->status->idx = mtgp32->status->size - 1;
    mtgp32_init_state(mtgp32->status->array, para, seed);
    return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x1250
movl %eax, 0x8(%rsp)
cmpl $0x0, 0x8(%rsp)
je 0x11f6
movl 0x8(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x123c
movq 0x18(%rsp), %rax
movq 0xf0(%rax), %rax
movl 0x4(%rax), %ecx
subl $0x1, %ecx
movq 0x18(%rsp), %rax
movq 0xf0(%rax), %rax
movl %ecx, (%rax)
movq 0x18(%rsp), %rax
movq 0xf0(%rax), %rdi
addq $0x10, %rdi
movq 0x10(%rsp), %rsi
movl 0xc(%rsp), %edx
callq 0x1350
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MersenneTwister-Lab[P]MTGP/mtgp32-fast.c
// Function: alloc_state
static int alloc_state(mtgp32_fast_t *mtgp32,
		       const mtgp32_params_fast_t *para) {
    int size = para->mexp / 32 + 1;
    int large_size;
    mtgp32_status_fast_t *st;

    int x;
    int y = size;
    for (x = 1; (x != size) && (y > 0); x <<= 1, y >>= 1);
    large_size = x;

    st = (mtgp32_status_fast_t *)malloc(sizeof(mtgp32_status_fast_t)
				     + sizeof(uint32_t) * large_size);
    if (st == NULL) {
	return -1;
    }
    mtgp32->params = *para;
    mtgp32->status = st;
    st->size = size;
    st->large_size = large_size;
    st->large_mask = large_size -1;
    return 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movl (%rax), %eax
movl $0x20, %ecx
cltd
idivl %ecx
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0x8(%rsp)
movl $0x1, 0xc(%rsp)
movl 0xc(%rsp), %ecx
xorl %eax, %eax
cmpl 0x1c(%rsp), %ecx
movb %al, 0x7(%rsp)
je 0x12a0
cmpl $0x0, 0x8(%rsp)
setg %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x12aa
jmp 0x12c2
jmp 0x12ac
movl 0xc(%rsp), %eax
shll %eax
movl %eax, 0xc(%rsp)
movl 0x8(%rsp), %eax
sarl %eax
movl %eax, 0x8(%rsp)
jmp 0x1284
movl 0xc(%rsp), %eax
movl %eax, 0x18(%rsp)
movslq 0x18(%rsp), %rdi
shlq $0x2, %rdi
addq $0x10, %rdi
callq 0x10b0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x12f3
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x1347
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl $0xec, %edx
callq 0x10a0
movq 0x10(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0xf0(%rax)
movl 0x1c(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x4(%rax)
movl 0x18(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x8(%rax)
movl 0x18(%rsp), %ecx
subl $0x1, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0xc(%rax)
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/MersenneTwister-Lab[P]MTGP/mtgp32-fast.c
// Function: mtgp32_init_state
void mtgp32_init_state(uint32_t array[],
		      const mtgp32_params_fast_t *para, uint32_t seed) {
    int i;
    int size = para->mexp / 32 + 1;
    uint32_t hidden_seed;
    uint32_t tmp;
    hidden_seed = para->tbl[4] ^ (para->tbl[8] << 16);
    tmp = hidden_seed;
    tmp += tmp >> 16;
    tmp += tmp >> 8;
    memset(array, tmp & 0xff, sizeof(uint32_t) * size);
    array[0] = seed;
    array[1] = hidden_seed;
    for (i = 1; i < size; i++) {
	array[i] ^= UINT32_C(1812433253) * (array[i - 1]
					    ^ (array[i - 1] >> 30))
	    + i;
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq 0x18(%rsp), %rax
movl (%rax), %eax
movl $0x20, %ecx
cltd
idivl %ecx
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rax
movl 0x20(%rax), %eax
movq 0x18(%rsp), %rcx
movl 0x30(%rcx), %ecx
shll $0x10, %ecx
xorl %ecx, %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
shrl $0x10, %eax
addl 0x4(%rsp), %eax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
shrl $0x8, %eax
addl 0x4(%rsp), %eax
movl %eax, 0x4(%rsp)
movq 0x20(%rsp), %rdi
movl 0x4(%rsp), %eax
andl $0xff, %eax
movslq 0xc(%rsp), %rdx
shlq $0x2, %rdx
movzbl %al, %esi
callq 0x1070
movl 0x14(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
movl 0x8(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x4(%rax)
movl $0x1, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0xc(%rsp), %eax
jge 0x144f
movq 0x20(%rsp), %rax
movl 0x10(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movq 0x20(%rsp), %rcx
movl 0x10(%rsp), %edx
subl $0x1, %edx
movslq %edx, %rdx
movl (%rcx,%rdx,4), %ecx
shrl $0x1e, %ecx
xorl %ecx, %eax
imull $0x6c078965, %eax, %edx # imm = 0x6C078965
addl 0x10(%rsp), %edx
movq 0x20(%rsp), %rax
movslq 0x10(%rsp), %rcx
xorl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x13f5
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MersenneTwister-Lab[P]MTGP/mtgp32-fast.c
// Function: mtgp32_print_idstring
void mtgp32_print_idstring(const mtgp32_fast_t *mtgp32, FILE *fp) {
    int i;
    fprintf(fp, "mtgp32:%d:", mtgp32->params.mexp);
    for (i = 0; i < 20; i++) {
	fprintf(fp, "%02x", (unsigned int)mtgp32->params.poly_sha1[i]);
    }
    fprintf(fp, "\n");
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movl (%rax), %edx
leaq 0x1a1b(%rip), %rsi      # 0x400c
movb $0x0, %al
callq 0x1080
movl $0x0, 0x4(%rsp)
cmpl $0x14, 0x4(%rsp)
jge 0x2639
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movslq 0x4(%rsp), %rcx
movzbl 0xd4(%rax,%rcx), %edx
leaq 0x19f2(%rip), %rsi      # 0x4017
movb $0x0, %al
callq 0x1080
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x2600
movq 0x8(%rsp), %rdi
leaq 0x19f4(%rip), %rsi      # 0x4039
movb $0x0, %al
callq 0x1080
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MersenneTwister-Lab[P]MTGP/./mtgp32-fast.h
// Function: mtgp32_genrand_uint32
inline static uint32_t mtgp32_genrand_uint32(mtgp32_fast_t *mtgp32) {
    int idx;
    uint32_t *tmp_tbl = mtgp32->params.tmp_tbl;
    uint32_t *array = mtgp32->status->array;
    int pos = mtgp32->params.pos;
    int large_size = mtgp32->status->large_size;
    int size = mtgp32->status->size;
    uint32_t large_mask = mtgp32->status->large_mask;

    mtgp32_next_state(mtgp32);
    idx = mtgp32->status->idx;
    return mtgp32_temper(tmp_tbl,
			 array[idx],
			 array[(idx + pos - 1 - size + large_size)
			       & large_mask]);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x50, %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq 0xf0(%rax), %rax
addq $0x10, %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0x14(%rsp)
movq 0x30(%rsp), %rax
movq 0xf0(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq 0xf0(%rax), %rax
movl 0x4(%rax), %eax
movl %eax, 0xc(%rsp)
movq 0x30(%rsp), %rax
movq 0xf0(%rax), %rax
movl 0xc(%rax), %eax
movl %eax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
callq 0x3000
movq 0x30(%rsp), %rax
movq 0xf0(%rax), %rax
movl (%rax), %eax
movl %eax, 0x2c(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movslq 0x2c(%rsp), %rcx
movl (%rax,%rcx,4), %esi
movq 0x18(%rsp), %rax
movl 0x2c(%rsp), %ecx
addl 0x14(%rsp), %ecx
subl $0x1, %ecx
subl 0xc(%rsp), %ecx
addl 0x10(%rsp), %ecx
andl 0x8(%rsp), %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %edx
callq 0x3140
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MersenneTwister-Lab[P]MTGP/mtgp32-fast.c
// Function: print_close1_open2
void print_close1_open2(mtgp32_fast_t *mtgp32, int count) {
    int i;
    for (i = 0; i < count; i++) {
	printf("%.8f ", mtgp32_genrand_close1_open2(mtgp32));
	if (i % 5 == 4) {
	    printf("\n");
	}
    }
    if (i % 5 != 0) {
	printf("\n");
    }
    printf("\n");
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
jge 0x2829
movq 0x10(%rsp), %rdi
callq 0x2860
cvtss2sd %xmm0, %xmm0
leaq 0x182e(%rip), %rdi      # 0x4022
movb $0x1, %al
callq 0x1060
movl 0x8(%rsp), %eax
movl $0x5, %ecx
cltd
idivl %ecx
cmpl $0x4, %edx
jne 0x281a
leaq 0x1826(%rip), %rdi      # 0x4039
movb $0x0, %al
callq 0x1060
jmp 0x281c
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x27d5
movl 0x8(%rsp), %eax
movl $0x5, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
je 0x2848
leaq 0x17f8(%rip), %rdi      # 0x4039
movb $0x0, %al
callq 0x1060
leaq 0x17ea(%rip), %rdi      # 0x4039
movb $0x0, %al
callq 0x1060
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MersenneTwister-Lab[P]MTGP/./mtgp32-fast.h
// Function: mtgp32_genrand_close1_open2
inline static float mtgp32_genrand_close1_open2(mtgp32_fast_t *mtgp32) {
    int idx;
    uint32_t *flt_tmp_tbl = mtgp32->params.flt_tmp_tbl;
    uint32_t *array = mtgp32->status->array;
    int pos = mtgp32->params.pos;
    int large_size = mtgp32->status->large_size;
    int size = mtgp32->status->size;
    uint32_t large_mask = mtgp32->status->large_mask;

    mtgp32_next_state(mtgp32);
    idx = mtgp32->status->idx;
    return mtgp32_temper_float(flt_tmp_tbl,
				array[idx],
				array[(idx + pos - 1 - size + large_size)
				      & large_mask]);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x90, %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq 0xf0(%rax), %rax
addq $0x10, %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0x14(%rsp)
movq 0x30(%rsp), %rax
movq 0xf0(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq 0xf0(%rax), %rax
movl 0x4(%rax), %eax
movl %eax, 0xc(%rsp)
movq 0x30(%rsp), %rax
movq 0xf0(%rax), %rax
movl 0xc(%rax), %eax
movl %eax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
callq 0x3000
movq 0x30(%rsp), %rax
movq 0xf0(%rax), %rax
movl (%rax), %eax
movl %eax, 0x2c(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movslq 0x2c(%rsp), %rcx
movl (%rax,%rcx,4), %esi
movq 0x18(%rsp), %rax
movl 0x2c(%rsp), %ecx
addl 0x14(%rsp), %ecx
subl $0x1, %ecx
subl 0xc(%rsp), %ecx
addl 0x10(%rsp), %ecx
andl 0x8(%rsp), %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %edx
callq 0x3210
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MersenneTwister-Lab[P]MTGP/mtgp32-fast.c
// Function: print_close_open
void print_close_open(mtgp32_fast_t *mtgp32, int count) {
    int i;
    for (i = 0; i < count; i++) {
	printf("%.8f ", mtgp32_genrand_close_open(mtgp32));
	if (i % 5 == 4) {
	    printf("\n");
	}
    }
    if (i % 5 != 0) {
	printf("\n");
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
jge 0x2999
movq 0x10(%rsp), %rdi
callq 0x29c0
cvtss2sd %xmm0, %xmm0
leaq 0x16be(%rip), %rdi      # 0x4022
movb $0x1, %al
callq 0x1060
movl 0x8(%rsp), %eax
movl $0x5, %ecx
cltd
idivl %ecx
cmpl $0x4, %edx
jne 0x298a
leaq 0x16b6(%rip), %rdi      # 0x4039
movb $0x0, %al
callq 0x1060
jmp 0x298c
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x2945
movl 0x8(%rsp), %eax
movl $0x5, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
je 0x29b8
leaq 0x1688(%rip), %rdi      # 0x4039
movb $0x0, %al
callq 0x1060
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MersenneTwister-Lab[P]MTGP/mtgp32-fast.c
// Function: print_open_close
void print_open_close(mtgp32_fast_t *mtgp32, int count) {
    int i;
    for (i = 0; i < count; i++) {
	printf("%.8f ", mtgp32_genrand_open_close(mtgp32));
	if (i % 5 == 4) {
	    printf("\n");
	}
    }
    if (i % 5 != 0) {
	printf("\n");
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
jge 0x2a49
movq 0x10(%rsp), %rdi
callq 0x2a70
cvtss2sd %xmm0, %xmm0
leaq 0x160e(%rip), %rdi      # 0x4022
movb $0x1, %al
callq 0x1060
movl 0x8(%rsp), %eax
movl $0x5, %ecx
cltd
idivl %ecx
cmpl $0x4, %edx
jne 0x2a3a
leaq 0x1606(%rip), %rdi      # 0x4039
movb $0x0, %al
callq 0x1060
jmp 0x2a3c
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x29f5
movl 0x8(%rsp), %eax
movl $0x5, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
je 0x2a68
leaq 0x15d8(%rip), %rdi      # 0x4039
movb $0x0, %al
callq 0x1060
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MersenneTwister-Lab[P]MTGP/./mtgp32-fast.h
// Function: mtgp32_genrand_open_open
inline static float mtgp32_genrand_open_open(mtgp32_fast_t *mtgp32) {
    float r;
    int idx;
    uint32_t *flt_tmp_tbl = mtgp32->params.flt_tmp_tbl;
    uint32_t *array = mtgp32->status->array;
    int pos = mtgp32->params.pos;
    int large_size = mtgp32->status->large_size;
    int size = mtgp32->status->size;
    uint32_t large_mask = mtgp32->status->large_mask;
    mtgp32_next_state(mtgp32);
    idx = mtgp32->status->idx;
    r = mtgp32_temper_float_open(flt_tmp_tbl,
				  array[idx],
				  array[(idx + pos - 1 - size + large_size)
					& large_mask]);
    return r - 1.0F;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x90, %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq 0xf0(%rax), %rax
addq $0x10, %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0x14(%rsp)
movq 0x30(%rsp), %rax
movq 0xf0(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq 0xf0(%rax), %rax
movl 0x4(%rax), %eax
movl %eax, 0xc(%rsp)
movq 0x30(%rsp), %rax
movq 0xf0(%rax), %rax
movl 0xc(%rax), %eax
movl %eax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
callq 0x3000
movq 0x30(%rsp), %rax
movq 0xf0(%rax), %rax
movl (%rax), %eax
movl %eax, 0x28(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movslq 0x28(%rsp), %rcx
movl (%rax,%rcx,4), %esi
movq 0x18(%rsp), %rax
movl 0x28(%rsp), %ecx
addl 0x14(%rsp), %ecx
subl $0x1, %ecx
subl 0xc(%rsp), %ecx
addl 0x10(%rsp), %ecx
andl 0x8(%rsp), %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %edx
callq 0x3270
movss %xmm0, 0x2c(%rsp)
movss 0x2c(%rsp), %xmm0
movss 0x1409(%rip), %xmm1     # 0x4004
subss %xmm1, %xmm0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MersenneTwister-Lab[P]MTGP/./mtgp32-fast.h
// Function: mtgp32_next_state
inline static void mtgp32_next_state(mtgp32_fast_t *mtgp32) {
    uint32_t *array = mtgp32->status->array;
    int idx;
    int pos = mtgp32->params.pos;
    int large_size = mtgp32->status->large_size;
    uint32_t large_mask = mtgp32->status->large_mask;
    int size = mtgp32->status->size;

    mtgp32->status->idx = (mtgp32->status->idx + 1) & large_mask;
    idx = mtgp32->status->idx;
    mtgp32_do_recursion(&(array[idx]),
			array[(idx - size + large_size) & large_mask],
			array[(idx - size + large_size + 1) & large_mask],
			array[(idx + pos - size + large_size) & large_mask],
			mtgp32->params.sh1,
			mtgp32->params.sh2,
			mtgp32->params.mask,
			mtgp32->params.tbl);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0xf0(%rax), %rax
addq $0x10, %rax
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq 0xf0(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, 0x1c(%rsp)
movq 0x30(%rsp), %rax
movq 0xf0(%rax), %rax
movl 0xc(%rax), %eax
movl %eax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq 0xf0(%rax), %rax
movl 0x4(%rax), %eax
movl %eax, 0x14(%rsp)
movq 0x30(%rsp), %rax
movq 0xf0(%rax), %rax
movl (%rax), %ecx
addl $0x1, %ecx
andl 0x18(%rsp), %ecx
movq 0x30(%rsp), %rax
movq 0xf0(%rax), %rax
movl %ecx, (%rax)
movq 0x30(%rsp), %rax
movq 0xf0(%rax), %rax
movl (%rax), %eax
movl %eax, 0x24(%rsp)
movq 0x28(%rsp), %rdi
movslq 0x24(%rsp), %rax
shlq $0x2, %rax
addq %rax, %rdi
movq 0x28(%rsp), %rax
movl 0x24(%rsp), %ecx
subl 0x14(%rsp), %ecx
addl 0x1c(%rsp), %ecx
andl 0x18(%rsp), %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %esi
movq 0x28(%rsp), %rax
movl 0x24(%rsp), %ecx
subl 0x14(%rsp), %ecx
addl 0x1c(%rsp), %ecx
addl $0x1, %ecx
andl 0x18(%rsp), %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %edx
movq 0x28(%rsp), %rax
movl 0x24(%rsp), %ecx
addl 0x20(%rsp), %ecx
subl 0x14(%rsp), %ecx
addl 0x1c(%rsp), %ecx
andl 0x18(%rsp), %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %ecx
movq 0x30(%rsp), %rax
movl 0x8(%rax), %r8d
movq 0x30(%rsp), %rax
movl 0xc(%rax), %r9d
movq 0x30(%rsp), %rax
movl 0xd0(%rax), %r10d
movq 0x30(%rsp), %rax
addq $0x10, %rax
movl %r10d, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x3190
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MersenneTwister-Lab[P]MTGP/./mtgp32-fast.h
// Function: mtgp32_temper
inline static uint32_t mtgp32_temper(const uint32_t tmp_tbl[16],
				     uint32_t r, uint32_t t) {
    t ^= t >> 16;
    t ^= t >> 8;
    r ^= tmp_tbl[t & 0x0f];
    return r;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl %edx, -0x10(%rsp)
movl -0x10(%rsp), %eax
shrl $0x10, %eax
xorl -0x10(%rsp), %eax
movl %eax, -0x10(%rsp)
movl -0x10(%rsp), %eax
shrl $0x8, %eax
xorl -0x10(%rsp), %eax
movl %eax, -0x10(%rsp)
movq -0x8(%rsp), %rax
movl -0x10(%rsp), %ecx
andl $0xf, %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
xorl -0xc(%rsp), %eax
movl %eax, -0xc(%rsp)
movl -0xc(%rsp), %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MersenneTwister-Lab[P]MTGP/./mtgp32-fast.h
// Function: mtgp32_do_recursion
inline static void mtgp32_do_recursion(uint32_t *r, uint32_t x1,
				       uint32_t x2, uint32_t y,
				       int sh1, int sh2,
				       uint32_t mask, uint32_t tbl[16]) {
    uint32_t x;

    x = (x1 & mask) ^ x2;
    x ^= x << sh1;
    y = x ^ (y >> sh2);
    *r = y ^ tbl[y & 0x0f];
}

// Assembly:
movq 0x10(%rsp), %rax
movl 0x8(%rsp), %eax
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl %edx, -0x10(%rsp)
movl %ecx, -0x14(%rsp)
movl %r8d, -0x18(%rsp)
movl %r9d, -0x1c(%rsp)
movl -0xc(%rsp), %eax
andl 0x8(%rsp), %eax
xorl -0x10(%rsp), %eax
movl %eax, -0x20(%rsp)
movl -0x20(%rsp), %eax
movl -0x18(%rsp), %ecx
shll %cl, %eax
xorl -0x20(%rsp), %eax
movl %eax, -0x20(%rsp)
movl -0x20(%rsp), %eax
movl -0x14(%rsp), %edx
movl -0x1c(%rsp), %ecx
shrl %cl, %edx
movl %edx, %ecx
xorl %ecx, %eax
movl %eax, -0x14(%rsp)
movl -0x14(%rsp), %ecx
movq 0x10(%rsp), %rax
movl -0x14(%rsp), %edx
andl $0xf, %edx
movl %edx, %edx
xorl (%rax,%rdx,4), %ecx
movq -0x8(%rsp), %rax
movl %ecx, (%rax)
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MersenneTwister-Lab[P]MTGP/./mtgp32-fast.h
// Function: mtgp32_temper_float
inline static float mtgp32_temper_float(const uint32_t flt_tmp_tbl[16],
					  uint32_t r, uint32_t t) {
    union {
	uint32_t u;
	float f;
    } x;
    t ^= t >> 16;
    t ^= t >> 8;
    r = r >> 9;
    x.u = r ^ flt_tmp_tbl[t & 0x0f];
    return x.f;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl %edx, -0x10(%rsp)
movl -0x10(%rsp), %eax
shrl $0x10, %eax
xorl -0x10(%rsp), %eax
movl %eax, -0x10(%rsp)
movl -0x10(%rsp), %eax
shrl $0x8, %eax
xorl -0x10(%rsp), %eax
movl %eax, -0x10(%rsp)
movl -0xc(%rsp), %eax
shrl $0x9, %eax
movl %eax, -0xc(%rsp)
movl -0xc(%rsp), %eax
movq -0x8(%rsp), %rcx
movl -0x10(%rsp), %edx
andl $0xf, %edx
movl %edx, %edx
xorl (%rcx,%rdx,4), %eax
movl %eax, -0x14(%rsp)
movss -0x14(%rsp), %xmm0
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MersenneTwister-Lab[P]MTGP/./mtgp32-fast.h
// Function: mtgp32_temper_float_open
inline static float mtgp32_temper_float_open(const uint32_t flt_tmp_tbl[16],
					       uint32_t r, uint32_t t) {
    union {
	uint32_t u;
	float f;
    } x;
    t ^= t >> 16;
    t ^= t >> 8;
    r = r >> 9;
    x.u = (r ^ flt_tmp_tbl[t & 0x0f]) | 1;
    return x.f;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl %edx, -0x10(%rsp)
movl -0x10(%rsp), %eax
shrl $0x10, %eax
xorl -0x10(%rsp), %eax
movl %eax, -0x10(%rsp)
movl -0x10(%rsp), %eax
shrl $0x8, %eax
xorl -0x10(%rsp), %eax
movl %eax, -0x10(%rsp)
movl -0xc(%rsp), %eax
shrl $0x9, %eax
movl %eax, -0xc(%rsp)
movl -0xc(%rsp), %eax
movq -0x8(%rsp), %rcx
movl -0x10(%rsp), %edx
andl $0xf, %edx
movl %edx, %edx
xorl (%rcx,%rdx,4), %eax
orl $0x1, %eax
movl %eax, -0x14(%rsp)
movss -0x14(%rsp), %xmm0
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/keiranrowan[P]tiny-core/./src/hostname.c
// Function: main
int main(int argc, char **argv) {
	if (argc > 1) {
		if ((strcmp(argv[1], "-h") == 0) || (strcmp(argv[1], "--help") == 0)) {
			printf("hostname [-s] <hostname>\n");
			printf("No arguments prints hostname\n");
		} else if (strcmp(argv[1], "-s") == 0) {
			const char *hostname = argv[2];
			int err = sethostname(hostname, strlen(hostname)); 
			if (err != 0) {
				printf("Error setting hostname\n");
				return 1;
			} else {
				printf("Hostname set.\n");
				return 0;
			}
		}
	} else {
		char hostname[HOST_NAME_MAX + 1];
		int err = gethostname(hostname, HOST_NAME_MAX + 1);
		if (err != 0) {
			printf("Error getting hostname.\n");
			return 1;
		} else {
			printf("%s\n", hostname);
			return 0;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x1, -0x8(%rbp)
jle 0x126d
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xe55(%rip), %rsi       # 0x2004
callq 0x1050
cmpl $0x0, %eax
je 0x11d2
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xe3f(%rip), %rsi       # 0x2007
callq 0x1050
cmpl $0x0, %eax
jne 0x11f0
leaq 0xe35(%rip), %rdi       # 0x200e
movb $0x0, %al
callq 0x1040
leaq 0xe41(%rip), %rdi       # 0x2028
movb $0x0, %al
callq 0x1040
jmp 0x126b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xe47(%rip), %rsi       # 0x2046
callq 0x1050
cmpl $0x0, %eax
jne 0x1269
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1030
movq -0x70(%rbp), %rdi
movq %rax, %rsi
callq 0x1060
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x1252
leaq 0xe07(%rip), %rdi       # 0x2049
movb $0x0, %al
callq 0x1040
movl $0x1, -0x4(%rbp)
jmp 0x12b4
leaq 0xe08(%rip), %rdi       # 0x2061
movb $0x0, %al
callq 0x1040
movl $0x0, -0x4(%rbp)
jmp 0x12b4
jmp 0x126b
jmp 0x12b4
leaq -0x60(%rbp), %rdi
movl $0x41, %esi
callq 0x1070
movl %eax, -0x64(%rbp)
cmpl $0x0, -0x64(%rbp)
je 0x129b
leaq 0xde5(%rip), %rdi       # 0x2070
movb $0x0, %al
callq 0x1040
movl $0x1, -0x4(%rbp)
jmp 0x12b4
leaq -0x60(%rbp), %rsi
leaq 0xde3(%rip), %rdi       # 0x2089
movb $0x0, %al
callq 0x1040
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Joy-Division[P]tools-zoe/subtitle-convert.c
// Function: getModdedLetter
char getModdedLetter( int modifier, int letter ) {
	if( modifier == 0x60 ) { // `
		if( letter == 0x61 ) return 0xE0; // a, à
		if( letter == 0x65 ) return 0xE8; // e, è
		if( letter == 0x6F ) return 0xF2; // o, ò
	}
	if( modifier == 0x5E ) { // ^
		if( letter == 0x75 ) return 0xFB; // u, û
		if( letter == 0x65 ) return 0xEA; // e, ê
	}
	if( modifier == 0x27 ) { // '
		if( letter == 0x65 ) return 0xE9; // e, é
	}
	if( modifier == 0x7E ) { // ~
		if( letter == 0x71 ) return 0xE7; // q, ç
		if( letter == 0x61 ) return 0xE4; // a, ä
		if( letter == 0x6F ) return 0xF6; // o, ö
		if( letter == 0x75 ) return 0xFC; // u, ü
		if( letter == 0x73 ) return 0xDF; // s, ß
	}
	if( modifier == 0x40 ) { // @
		if( letter == 0x65 ) return 0x9C; // o, œ
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x60, -0x8(%rbp)
jne 0x126f
cmpl $0x61, -0xc(%rbp)
jne 0x124f
movb $-0x20, -0x1(%rbp)
jmp 0x12ff
cmpl $0x65, -0xc(%rbp)
jne 0x125e
movb $-0x18, -0x1(%rbp)
jmp 0x12ff
cmpl $0x6f, -0xc(%rbp)
jne 0x126d
movb $-0xe, -0x1(%rbp)
jmp 0x12ff
jmp 0x126f
cmpl $0x5e, -0x8(%rbp)
jne 0x128f
cmpl $0x75, -0xc(%rbp)
jne 0x1281
movb $-0x5, -0x1(%rbp)
jmp 0x12ff
cmpl $0x65, -0xc(%rbp)
jne 0x128d
movb $-0x16, -0x1(%rbp)
jmp 0x12ff
jmp 0x128f
cmpl $0x27, -0x8(%rbp)
jne 0x12a3
cmpl $0x65, -0xc(%rbp)
jne 0x12a1
movb $-0x17, -0x1(%rbp)
jmp 0x12ff
jmp 0x12a3
cmpl $0x7e, -0x8(%rbp)
jne 0x12e7
cmpl $0x71, -0xc(%rbp)
jne 0x12b5
movb $-0x19, -0x1(%rbp)
jmp 0x12ff
cmpl $0x61, -0xc(%rbp)
jne 0x12c1
movb $-0x1c, -0x1(%rbp)
jmp 0x12ff
cmpl $0x6f, -0xc(%rbp)
jne 0x12cd
movb $-0xa, -0x1(%rbp)
jmp 0x12ff
cmpl $0x75, -0xc(%rbp)
jne 0x12d9
movb $-0x4, -0x1(%rbp)
jmp 0x12ff
cmpl $0x73, -0xc(%rbp)
jne 0x12e5
movb $-0x21, -0x1(%rbp)
jmp 0x12ff
jmp 0x12e7
cmpl $0x40, -0x8(%rbp)
jne 0x12fb
cmpl $0x65, -0xc(%rbp)
jne 0x12f9
movb $-0x64, -0x1(%rbp)
jmp 0x12ff
jmp 0x12fb
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Joy-Division[P]tools-zoe/subtitle-convert.c
// Function: processLine
char *processLine( char *line ) {
	char *retline = malloc( strlen(line)+1 );
	int i, e = 0, modifier, letter;
	for( i = 0; i < strlen(line) + 1; i++ ) {
		if( line[i] != 0x26 ) { // &
			retline[e] = line[i];
			e++;
		}
		else {
			i++;
			modifier = line[i];
			i++;
			letter = line[i];
			retline[e] = getModdedLetter( modifier, letter );
			e++;
		}
	}
	return retline;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1070
movq %rax, %rdi
addq $0x1, %rdi
callq 0x10c0
movq %rax, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1070
movq %rax, %rcx
movq -0x28(%rbp), %rax
addq $0x1, %rcx
cmpq %rcx, %rax
jae 0x13fb
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x26, %eax
je 0x139a
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x13eb
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %edi
movl -0x20(%rbp), %esi
callq 0x1230
movb %al, %dl
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x13ed
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1343
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Joy-Division[P]tools-zoe/subtitle-convert.c
// Function: processLineJp
char *processLineJp( char *line, unsigned int len ) {
	char *tempbuf = malloc(len*2);
	char *workbuf = tempbuf;
	iconv_t cd;
	size_t inbufsize = len;
	size_t outbufsize = len*2;
	cd = iconv_open("UTF-8", "EUC-JP");
	#ifdef _WIN32
	const char *linein = (const char *)line;
	iconv(cd, &linein, &inbufsize, &workbuf, &outbufsize);
	#else
	iconv(cd, &line, &inbufsize, &workbuf, &outbufsize);
	#endif
	iconv_close(cd);
	return tempbuf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
shll %eax
movl %eax, %eax
movl %eax, %edi
callq 0x10c0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x30(%rbp)
movl -0xc(%rbp), %eax
shll %eax
movl %eax, %eax
movq %rax, -0x38(%rbp)
leaq 0xbba(%rip), %rdi       # 0x200c
leaq 0xbb9(%rip), %rsi       # 0x2012
callq 0x1120
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
leaq -0x8(%rbp), %rsi
leaq -0x30(%rbp), %rdx
leaq -0x20(%rbp), %rcx
leaq -0x38(%rbp), %r8
callq 0x1040
movq -0x28(%rbp), %rdi
callq 0x10e0
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/ch2/eatyguy2.c
// Function: getkey
int getkey() {

  // Make reading from stdin non-blocking.
  int flags = fcntl(STDIN_FILENO, F_GETFL);
  fcntl(STDIN_FILENO, F_SETFL, flags | O_NONBLOCK);

  int ch = getchar();

  // Turn off non-blocking I/O. On some systems, leaving stdin
  // non-blocking will also leave stdout non-blocking, which
  // can cause printing errors.
  fcntl(STDIN_FILENO, F_SETFL, flags);
  return ch;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
xorl %edi, %edi
movl $0x3, %esi
movb $0x0, %al
callq 0x5110
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %edx
orl $0x800, %edx            # imm = 0x800
xorl %edi, %edi
movl $0x4, %esi
movb $0x0, %al
callq 0x5110
callq 0x5270
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %edx
xorl %edi, %edi
movl $0x4, %esi
movb $0x0, %al
callq 0x5110
movl -0x8(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/ch2/eatyguy2.c
// Function: main
int main() {

  start();

  // Create a Lua state and load the module.
  lua_State *L = luaL_newstate();
  luaL_openlibs(L);

  // Make our Lua-callable functions visible to Lua.
  lua_register(L, "set_color", set_color);
  lua_register(L, "set_pos",   set_pos);
  lua_register(L, "timestamp", timestamp);

  // Load eatyguy2.lua and run the init() function.
  luaL_dofile(L, "eatyguy2.lua");
  lua_setglobal(L, "eatyguy");
  lua_settop(L, 0);

  lua_getglobal(L, "eatyguy");
  lua_getfield(L, -1, "init");  // -1 means stack top.
  lua_call(L, 0, 0);            // 0, 0 = #args, #retvals

  lua_getglobal(L, "eatyguy");
  while (1) {
    // Call eatyguy.loop().
    lua_getfield(L, -1, "loop");
    lua_call(L, 0, 0);

    int c = getkey();
    if (c == ESC_KEY || c == 'q' || c == 'Q') done();
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
callq 0x56a0
callq 0x21680
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x21a40
movq -0x10(%rbp), %rdi
leaq -0x161(%rip), %rsi      # 0x5710
xorl %edx, %edx
callq 0x6d70
movq -0x10(%rbp), %rdi
leaq 0x2e7f9(%rip), %rsi     # 0x3407c
callq 0x76b0
movq -0x10(%rbp), %rdi
leaq -0x103(%rip), %rsi      # 0x5790
xorl %edx, %edx
callq 0x6d70
movq -0x10(%rbp), %rdi
leaq 0x2e7e1(%rip), %rsi     # 0x34086
callq 0x76b0
movq -0x10(%rbp), %rdi
leaq -0xa5(%rip), %rsi       # 0x5810
xorl %edx, %edx
callq 0x6d70
movq -0x10(%rbp), %rdi
leaq 0x2e7c7(%rip), %rsi     # 0x3408e
callq 0x76b0
movq -0x10(%rbp), %rdi
leaq 0x2e7c1(%rip), %rsi     # 0x34098
xorl %eax, %eax
movl %eax, %edx
callq 0x20b50
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x15(%rbp)
jne 0x590f
movq -0x10(%rbp), %rdi
xorl %ecx, %ecx
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %r9d
movl %ecx, %esi
movq %r9, %r8
callq 0x80e0
cmpl $0x0, %eax
setne %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
movq -0x10(%rbp), %rdi
leaq 0x2e788(%rip), %rsi     # 0x340a5
callq 0x76b0
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x5c90
movq -0x10(%rbp), %rdi
leaq 0x2e76d(%rip), %rsi     # 0x340a5
callq 0x6f80
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
leaq 0x2e760(%rip), %rdx     # 0x340ad
callq 0x71c0
movq -0x10(%rbp), %rdi
xorl %edx, %edx
xorl %eax, %eax
movl %eax, %r8d
movl %edx, %esi
movq %r8, %rcx
callq 0x8010
movq -0x10(%rbp), %rdi
leaq 0x2e733(%rip), %rsi     # 0x340a5
callq 0x6f80
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
leaq 0x2f519(%rip), %rdx     # 0x34ea0
callq 0x71c0
movq -0x10(%rbp), %rdi
xorl %edx, %edx
xorl %eax, %eax
movl %eax, %r8d
movl %edx, %esi
movq %r8, %rcx
callq 0x8010
callq 0x5640
movl %eax, -0x14(%rbp)
cmpl $0x1b, -0x14(%rbp)
je 0x59bb
cmpl $0x71, -0x14(%rbp)
je 0x59bb
cmpl $0x51, -0x14(%rbp)
jne 0x59c0
callq 0x56e0
jmp 0x5977
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jflatow[P]jfdb/src/jfdb.c
// Function: usage
static int usage(int isError) {
  fprintf(isError ? stderr : stdout,
          "Usage: \n"
          " jfdb meta /db/path\n"
          " jfdb node /db/path [offset]\n"
          " jfdb keys /db/path [-n] [-p|-i] [prefix]\n"
          " jfdb find /db/path [-n] [-p|-i] [prefix]\n"
          " jfdb load /db/path\n"
          " jfdb wipe /db/path\n"
          " jfdb crush /db/path\n");
  return isError;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0x16a1
movq 0xc960(%rip), %rax      # 0xdff8
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x16af
movq 0xc918(%rip), %rax      # 0xdfc0
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x8ba9(%rip), %rsi      # 0xa263
movb $0x0, %al
callq 0x1140
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jflatow[P]jfdb/src/jfdb.c
// Function: print_meta
static void print_meta(JFDB *db) {
  JFDB_CheckPoint *cp = &db->tip.cp;
  printf("-----\n");
  printf("magic: %x:%x\n", db->tip.magic, db->tip.version);
  printf("level: %"PRIu64" / %llu\n", cp->levels, 1LLU << db->tip.level);
  printf("-----\n");
  printf("gaps:\n");
  for (int i = 0; i < JFDB_NUM_GAPS; i++)
    printf(" %8u @ %-8u\n", cp->gaps[i].size, cp->gaps[i].block);
  printf("keys: %12zu / %-12"PRIu64"\n", db->kmap.size, cp->lengthKeys);
  printf("vals: %12zu / %-12"PRIu64"\n", db->vmap.size, cp->lengthVals);
  printf("-----\n");
  printf("roots:\n");
  JFT *trie;
  for (JFT_Offset pos = cp->offset; pos; pos = JFT_parent_offset(trie)) {
    trie = JFDB_get_trie(db, pos);
    printf("      %12"PRIu64" = ", pos);
    print_bits((JFT_Head *)trie, 1);
    printf("\n");
  }
  printf("-----\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xc0, %rax
addq $0x10, %rax
movq %rax, -0x10(%rbp)
leaq 0x8be2(%rip), %rdi      # 0xa347
movb $0x0, %al
callq 0x10d0
movq -0x8(%rbp), %rax
movl 0xc0(%rax), %esi
movq -0x8(%rbp), %rax
movl 0xc4(%rax), %edx
leaq 0x8bc7(%rip), %rdi      # 0xa34e
movb $0x0, %al
callq 0x10d0
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rsi
movq -0x8(%rbp), %rax
movzbl 0xc8(%rax), %eax
movl %eax, %eax
movl %eax, %ecx
movl $0x1, %edx
shlq %cl, %rdx
leaq 0x8ba8(%rip), %rdi      # 0xa35c
movb $0x0, %al
callq 0x10d0
leaq 0x8b85(%rip), %rdi      # 0xa347
movb $0x0, %al
callq 0x10d0
leaq 0x8b9f(%rip), %rdi      # 0xa36f
movb $0x0, %al
callq 0x10d0
movl $0x0, -0x14(%rbp)
cmpl $0x8, -0x14(%rbp)
jge 0x1814
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl 0x4(%rax,%rcx,8), %esi
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,8), %edx
leaq 0x8b74(%rip), %rdi      # 0xa376
movb $0x0, %al
callq 0x10d0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x17de
movq -0x8(%rbp), %rax
movq 0xa0(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdx
leaq 0x8b55(%rip), %rdi      # 0xa383
movb $0x0, %al
callq 0x10d0
movq -0x8(%rbp), %rax
movq 0xb8(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdx
leaq 0x8b4a(%rip), %rdi      # 0xa399
movb $0x0, %al
callq 0x10d0
leaq 0x8aea(%rip), %rdi      # 0xa347
movb $0x0, %al
callq 0x10d0
leaq 0x8b44(%rip), %rdi      # 0xa3af
movb $0x0, %al
callq 0x10d0
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x18d3
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x4450
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rsi
leaq 0x8b16(%rip), %rdi      # 0xa3b7
movb $0x0, %al
callq 0x10d0
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x1fb0
leaq 0x8a8f(%rip), %rdi      # 0xa34c
movb $0x0, %al
callq 0x10d0
movq -0x20(%rbp), %rdi
callq 0x2050
movq %rax, -0x28(%rbp)
jmp 0x187e
leaq 0x8a6d(%rip), %rdi      # 0xa347
movb $0x0, %al
callq 0x10d0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jflatow[P]jfdb/src/jfdb.c
// Function: print_info
static void print_info(JFDB *db, JFT_Stem *prefix, JFT *node, JFT_Symbol *stop) {
  JFT_Stem key = JFT_key(node, db->keyData), val = (JFT_Stem) {};
  printf("-----\n");
  printf("@ %ld\n", node - db->kmap.map);
  print_stem("> ", *prefix);
  print_stem("< ", key);
  print_node(node);
  if (JFT_node_type(node) == Leaf)
    if (key.pre == JFT_SYMBOL_PRIMARY)
      if (JFDB_get_value(db, node, &val))
        print_stem("= ", val);
  JFT_Cursor cursor = JFT_cursor(node);
  for (JFT_Keys keys = JFT_keys(&cursor, &key, Forward); JFT_keys_next_until(&keys, stop); )
    print_stem(JFT_cursor_at_terminal(&cursor) ? "[val] " : "[sub] ", *keys.stem);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rdx
addq $0x998, %rdx            # imm = 0x998
leaq -0x38(%rbp), %rdi
callq 0x2070
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x1100
leaq 0x8a0d(%rip), %rdi      # 0xa347
movb $0x0, %al
callq 0x10d0
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x98(%rax), %rax
subq %rax, %rsi
leaq 0x8a71(%rip), %rdi      # 0xa3cb
movb $0x0, %al
callq 0x10d0
movq -0x10(%rbp), %rax
leaq 0x8a66(%rip), %rdi      # 0xa3d2
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x2160
leaq 0x8a44(%rip), %rdi      # 0xa3d5
leaq -0x38(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x2160
movq -0x18(%rbp), %rdi
callq 0x21f0
movq -0x18(%rbp), %rdi
callq 0x2320
cmpl $0x3, %eax
jne 0x1a15
cmpq $-0x5, -0x38(%rbp)
jne 0x1a13
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0x5160
cmpq $0x0, %rax
je 0x1a11
leaq 0x89d4(%rip), %rdi      # 0xa3c3
leaq -0x50(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x2160
jmp 0x1a13
jmp 0x1a15
movq -0x18(%rbp), %rsi
leaq -0x88(%rbp), %rdi
callq 0x2340
leaq -0xa8(%rbp), %rdi
leaq -0x88(%rbp), %rsi
leaq -0x38(%rbp), %rdx
movl $0x1, %ecx
callq 0x2390
movq -0x20(%rbp), %rsi
leaq -0xa8(%rbp), %rdi
callq 0x23f0
cmpq $0x0, %rax
je 0x1aa1
leaq -0x88(%rbp), %rdi
callq 0x25a0
movl %eax, %ecx
leaq 0x8973(%rip), %rdi      # 0xa3df
leaq 0x8965(%rip), %rax      # 0xa3d8
cmpl $0x0, %ecx
cmovneq %rax, %rdi
movq -0xa0(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x2160
jmp 0x1a41
addq $0xc0, %rsp
popq %rbp
retq
nopw (%rax,%rax)