LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/norx6441v2/ref/norx.c
// Function: norx_init
static NORX_INLINE void norx_init(norx_state_t state, const unsigned char *k, const unsigned char *n)
{
    norx_word_t * S = state->S;
    size_t i;

    for(i = 0; i < 16; ++i) {
        S[i] = i;
    }

    F(S);
    F(S);

    S[ 0] = LOAD(n + 0 * BYTES(NORX_W));
    S[ 1] = LOAD(n + 1 * BYTES(NORX_W));

    S[ 4] = LOAD(k + 0 * BYTES(NORX_W));
    S[ 5] = LOAD(k + 1 * BYTES(NORX_W));
    S[ 6] = LOAD(k + 2 * BYTES(NORX_W));
    S[ 7] = LOAD(k + 3 * BYTES(NORX_W));

    S[12] ^= NORX_W;
    S[13] ^= NORX_L;
    S[14] ^= NORX_P;
    S[15] ^= NORX_T;

    norx_permute(state);

#if defined(NORX_DEBUG)
    printf("Initialise\n");
    norx_debug(state, NULL, 0, NULL, 0);
#endif
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq $0x0, (%rsp)
cmpq $0x10, (%rsp)
jae 0x1abb
movq (%rsp), %rdx
movq 0x8(%rsp), %rax
movq (%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x1a95
movq 0x8(%rsp), %rdi
callq 0x1ec0
movq 0x8(%rsp), %rdi
callq 0x1ec0
movq 0x10(%rsp), %rdi
callq 0x1ea0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
callq 0x1ea0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rdi
callq 0x1ea0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x18(%rsp), %rdi
addq $0x8, %rdi
callq 0x1ea0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x18(%rsp), %rdi
addq $0x10, %rdi
callq 0x1ea0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x30(%rax)
movq 0x18(%rsp), %rdi
addq $0x18, %rdi
callq 0x1ea0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x38(%rax)
movq 0x8(%rsp), %rax
movq 0x60(%rax), %rcx
xorq $0x40, %rcx
movq %rcx, 0x60(%rax)
movq 0x8(%rsp), %rax
movq 0x68(%rax), %rcx
xorq $0x4, %rcx
movq %rcx, 0x68(%rax)
movq 0x8(%rsp), %rax
movq 0x70(%rax), %rcx
xorq $0x1, %rcx
movq %rcx, 0x70(%rax)
movq 0x8(%rsp), %rax
movq 0x78(%rax), %rcx
xorq $0x100, %rcx            # imm = 0x100
movq %rcx, 0x78(%rax)
movq 0x20(%rsp), %rdi
callq 0x1e50
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/norx6441v2/ref/norx.c
// Function: norx_finalise
static NORX_INLINE void norx_finalise(norx_state_t state, unsigned char * tag)
{
    size_t i;
    norx_word_t * S = state->S;
    uint8_t lastblock[BYTES(NORX_R)];

    S[15] ^= FINAL_TAG;
    norx_permute(state);
    norx_permute(state);

    for (i = 0; i < WORDS(NORX_R); ++i) {
        STORE(lastblock + i * BYTES(NORX_W), S[i]);
    }

    memcpy(tag, lastblock, BYTES(NORX_T));

    #if defined(NORX_DEBUG)
    printf("Finalise\n");
    norx_debug(state, NULL, 0, NULL, 0);
    #endif

    burn(lastblock, 0, BYTES(NORX_R)); /* burn full state dump */
    burn(state, 0, sizeof(norx_state_t)); /* at this point we can also burn the state */
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq 0x78(%rax), %rcx
xorq $0x8, %rcx
movq %rcx, 0x78(%rax)
movq 0x80(%rsp), %rdi
callq 0x1e50
movq 0x80(%rsp), %rdi
callq 0x1e50
movq $0x0, 0x70(%rsp)
cmpq $0xc, 0x70(%rsp)
jae 0x1c4f
movq %rsp, %rdi
movq 0x70(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq 0x68(%rsp), %rax
movq 0x70(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x2d00
movq 0x70(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x70(%rsp)
jmp 0x1c15
movq 0x78(%rsp), %rax
movq (%rsp), %rcx
movq %rcx, (%rax)
movq 0x8(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x18(%rax)
movq 0x318b(%rip), %rax      # 0x4e08
movq %rsp, %rdi
xorl %esi, %esi
movl $0x60, %edx
callq *%rax
movq 0x3178(%rip), %rax      # 0x4e08
movq 0x80(%rsp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq *%rax
addq $0x88, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/norx6441v2/ref/norx.c
// Function: norx_aead_decrypt
int norx_aead_decrypt(
  unsigned char *m, size_t *mlen,
  const unsigned char *a, size_t alen,
  const unsigned char *c, size_t clen,
  const unsigned char *z, size_t zlen,
  const unsigned char *nonce,
  const unsigned char *key
)
{
    int result = -1;
    unsigned char tag[BYTES(NORX_T)];
    norx_state_t state;

    if (clen < BYTES(NORX_T)) {
        return -1;
    }

    norx_init(state, key, nonce);
    norx_absorb_data(state, a, alen, HEADER_TAG);
    norx_decrypt_data(state, m, c, clen - BYTES(NORX_T));
    norx_absorb_data(state, z, zlen, TRAILER_TAG);
    norx_finalise(state, tag);
    *mlen = clen - BYTES(NORX_T);

    result = norx_verify_tag(c + clen - BYTES(NORX_T), tag);
    if (result != 0) { /* burn decrypted plaintext on auth failure */
        burn(m, 0, clen - BYTES(NORX_T));
    }
    burn(state, 0, sizeof(norx_state_t));

    return result;
}

// Assembly:
subq $0xe8, %rsp
movq 0x108(%rsp), %rax
movq 0x100(%rsp), %rax
movq 0xf8(%rsp), %rax
movq 0xf0(%rsp), %rax
movq %rdi, 0xd8(%rsp)
movq %rsi, 0xd0(%rsp)
movq %rdx, 0xc8(%rsp)
movq %rcx, 0xc0(%rsp)
movq %r8, 0xb8(%rsp)
movq %r9, 0xb0(%rsp)
movl $0xffffffff, 0xac(%rsp) # imm = 0xFFFFFFFF
cmpq $0x20, 0xb0(%rsp)
jae 0x1d2d
movl $0xffffffff, 0xe4(%rsp) # imm = 0xFFFFFFFF
jmp 0x1e3c
movq %rsp, %rdi
movq 0x108(%rsp), %rsi
movq 0x100(%rsp), %rdx
callq 0x1a70
movq %rsp, %rdi
movq 0xc8(%rsp), %rsi
movq 0xc0(%rsp), %rdx
movl $0x1, %ecx
callq 0x1070
movq %rsp, %rdi
movq 0xd8(%rsp), %rsi
movq 0xb8(%rsp), %rdx
movq 0xb0(%rsp), %rcx
subq $0x20, %rcx
callq 0x10c0
movq %rsp, %rdi
movq 0xf0(%rsp), %rsi
movq 0xf8(%rsp), %rdx
movl $0x4, %ecx
callq 0x1070
movq %rsp, %rdi
leaq 0x80(%rsp), %rsi
callq 0x1bc0
movq 0xb0(%rsp), %rcx
subq $0x20, %rcx
movq 0xd0(%rsp), %rax
movq %rcx, (%rax)
movq 0xb8(%rsp), %rdi
addq 0xb0(%rsp), %rdi
addq $-0x20, %rdi
leaq 0x80(%rsp), %rsi
callq 0x1080
movl %eax, 0xac(%rsp)
cmpl $0x0, 0xac(%rsp)
je 0x1e1b
movq 0x3005(%rip), %rax      # 0x4e08
movq 0xd8(%rsp), %rdi
movq 0xb0(%rsp), %rdx
subq $0x20, %rdx
xorl %esi, %esi
callq *%rax
movq 0x2fe6(%rip), %rax      # 0x4e08
movq %rsp, %rdi
xorl %esi, %esi
movl $0x80, %edx
callq *%rax
movl 0xac(%rsp), %eax
movl %eax, 0xe4(%rsp)
movl 0xe4(%rsp), %eax
addq $0xe8, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/norx6441v2/ref/norx.c
// Function: norx_permute
static NORX_INLINE void norx_permute(norx_state_t state)
{
    size_t i;
    norx_word_t * S = state->S;

    for (i = 0; i < NORX_L; ++i) {
        F(S);
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq $0x0, 0x8(%rsp)
cmpq $0x4, 0x8(%rsp)
jae 0x1e8c
movq (%rsp), %rdi
callq 0x1ec0
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x1e6b
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/norx6441v2/ref/norx.c
// Function: norx_pad
static NORX_INLINE void norx_pad(uint8_t *out, const uint8_t *in, const size_t inlen)
{
    memset(out, 0, BYTES(NORX_R));
    memcpy(out, in, inlen);
    out[inlen] = 0x01;
    out[BYTES(NORX_R) - 1] |= 0x80;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rdi
xorl %esi, %esi
movl $0x60, %edx
callq 0x1030
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq 0x10d0
movq 0x10(%rsp), %rax
movq (%rsp), %rcx
movb $0x1, (%rax,%rcx)
movq 0x10(%rsp), %rax
movzbl 0x5f(%rax), %ecx
orl $0x80, %ecx
movb %cl, 0x5f(%rax)
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pyk[P]simple-nn/deps/pcg/src/../include/pcg_variants.h
// Function: pcg_oneseq_128_srandom_r
inline void pcg_oneseq_128_srandom_r(struct pcg_state_128* rng,
                                     pcg128_t initstate)
{
    rng->state = 0U;
    pcg_oneseq_128_step_r(rng);
    rng->state += initstate;
    pcg_oneseq_128_step_r(rng);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq %rdi, -0x18(%rbp)
movq %rcx, -0x28(%rbp)
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq $0x0, (%rax)
movq -0x18(%rbp), %rdi
callq 0x24e0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rcx
addq %rdi, %rdx
adcq %rsi, %rcx
movq %rdx, (%rax)
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rdi
callq 0x24e0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pyk[P]simple-nn/deps/pcg/src/../include/pcg_variants.h
// Function: pcg_unique_128_srandom_r
inline void pcg_unique_128_srandom_r(struct pcg_state_128* rng,
                                     pcg128_t initstate)
{
    rng->state = 0U;
    pcg_unique_128_step_r(rng);
    rng->state += initstate;
    pcg_unique_128_step_r(rng);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq %rdi, -0x18(%rbp)
movq %rcx, -0x28(%rbp)
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq $0x0, (%rax)
movq -0x18(%rbp), %rdi
callq 0x2750
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rcx
addq %rdi, %rdx
adcq %rsi, %rcx
movq %rdx, (%rax)
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rdi
callq 0x2750
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pyk[P]simple-nn/deps/pcg/src/../include/pcg_variants.h
// Function: pcg_setseq_128_srandom_r
inline void pcg_setseq_128_srandom_r(struct pcg_state_setseq_128* rng,
                                     pcg128_t initstate, pcg128_t initseq)
{
    rng->state = 0U;
    rng->inc = (initseq << 1u) | 1u;
    pcg_setseq_128_step_r(rng);
    rng->state += initstate;
    pcg_setseq_128_step_r(rng);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rsi
movq %rcx, -0x20(%rbp)
movq %r8, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rdi, -0x28(%rbp)
movq %rsi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
movq %rcx, -0x48(%rbp)
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rax
movq $0x0, 0x8(%rax)
movq $0x0, (%rax)
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rdx
shldq $0x1, %rax, %rdx
leaq 0x1(%rax,%rax), %rcx
movq -0x28(%rbp), %rax
movq %rdx, 0x18(%rax)
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rdi
callq 0x2880
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x28(%rbp), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rcx
addq %rdi, %rdx
adcq %rsi, %rcx
movq %rdx, (%rax)
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rdi
callq 0x2880
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pyk[P]simple-nn/deps/pcg/src/../include/pcg_variants.h
// Function: pcg_oneseq_128_xsh_rs_64_boundedrand_r
inline uint64_t
pcg_oneseq_128_xsh_rs_64_boundedrand_r(struct pcg_state_128* rng,
                                       uint64_t bound)
{
    uint64_t threshold = -bound % bound;
    for (;;) {
        uint64_t r = pcg_oneseq_128_xsh_rs_64_random_r(rng);
        if (r >= threshold)
            return r % bound;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
subq -0x10(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2b80
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jb 0x2c0e
movq -0x20(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x10(%rbp)
movq %rdx, %rax
addq $0x20, %rsp
popq %rbp
retq
jmp 0x2be2
// File: /workspace/github_c_makefile_star2_O0/pyk[P]simple-nn/deps/pcg/src/../include/pcg_variants.h
// Function: pcg_unique_128_xsh_rs_64_boundedrand_r
inline uint64_t
pcg_unique_128_xsh_rs_64_boundedrand_r(struct pcg_state_128* rng,
                                       uint64_t bound)
{
    uint64_t threshold = -bound % bound;
    for (;;) {
        uint64_t r = pcg_unique_128_xsh_rs_64_random_r(rng);
        if (r >= threshold)
            return r % bound;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
subq -0x10(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2c10
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jb 0x2c9e
movq -0x20(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x10(%rbp)
movq %rdx, %rax
addq $0x20, %rsp
popq %rbp
retq
jmp 0x2c72
// File: /workspace/github_c_makefile_star2_O0/pyk[P]simple-nn/deps/pcg/src/../include/pcg_variants.h
// Function: pcg_setseq_128_xsh_rs_64_boundedrand_r
inline uint64_t
pcg_setseq_128_xsh_rs_64_boundedrand_r(struct pcg_state_setseq_128* rng,
                                       uint64_t bound)
{
    uint64_t threshold = -bound % bound;
    for (;;) {
        uint64_t r = pcg_setseq_128_xsh_rs_64_random_r(rng);
        if (r >= threshold)
            return r % bound;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
subq -0x10(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2ca0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jb 0x2d2e
movq -0x20(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x10(%rbp)
movq %rdx, %rax
addq $0x20, %rsp
popq %rbp
retq
jmp 0x2d02
// File: /workspace/github_c_makefile_star2_O0/pyk[P]simple-nn/deps/pcg/src/../include/pcg_variants.h
// Function: pcg_mcg_128_xsh_rs_64_boundedrand_r
inline uint64_t pcg_mcg_128_xsh_rs_64_boundedrand_r(struct pcg_state_128* rng,
                                                    uint64_t bound)
{
    uint64_t threshold = -bound % bound;
    for (;;) {
        uint64_t r = pcg_mcg_128_xsh_rs_64_random_r(rng);
        if (r >= threshold)
            return r % bound;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
subq -0x10(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2d30
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jb 0x2dbe
movq -0x20(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x10(%rbp)
movq %rdx, %rax
addq $0x20, %rsp
popq %rbp
retq
jmp 0x2d92
// File: /workspace/github_c_makefile_star2_O0/pyk[P]simple-nn/deps/pcg/src/../include/pcg_variants.h
// Function: pcg_oneseq_128_xsh_rr_64_boundedrand_r
inline uint64_t
pcg_oneseq_128_xsh_rr_64_boundedrand_r(struct pcg_state_128* rng,
                                       uint64_t bound)
{
    uint64_t threshold = -bound % bound;
    for (;;) {
        uint64_t r = pcg_oneseq_128_xsh_rr_64_random_r(rng);
        if (r >= threshold)
            return r % bound;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
subq -0x10(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2dc0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jb 0x2e4e
movq -0x20(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x10(%rbp)
movq %rdx, %rax
addq $0x20, %rsp
popq %rbp
retq
jmp 0x2e22
// File: /workspace/github_c_makefile_star2_O0/pyk[P]simple-nn/deps/pcg/src/../include/pcg_variants.h
// Function: pcg_unique_128_xsh_rr_64_boundedrand_r
inline uint64_t
pcg_unique_128_xsh_rr_64_boundedrand_r(struct pcg_state_128* rng,
                                       uint64_t bound)
{
    uint64_t threshold = -bound % bound;
    for (;;) {
        uint64_t r = pcg_unique_128_xsh_rr_64_random_r(rng);
        if (r >= threshold)
            return r % bound;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
subq -0x10(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2e50
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jb 0x2ede
movq -0x20(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x10(%rbp)
movq %rdx, %rax
addq $0x20, %rsp
popq %rbp
retq
jmp 0x2eb2
// File: /workspace/github_c_makefile_star2_O0/pyk[P]simple-nn/deps/pcg/src/../include/pcg_variants.h
// Function: pcg_setseq_128_xsh_rr_64_boundedrand_r
inline uint64_t
pcg_setseq_128_xsh_rr_64_boundedrand_r(struct pcg_state_setseq_128* rng,
                                       uint64_t bound)
{
    uint64_t threshold = -bound % bound;
    for (;;) {
        uint64_t r = pcg_setseq_128_xsh_rr_64_random_r(rng);
        if (r >= threshold)
            return r % bound;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
subq -0x10(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2ee0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jb 0x2f6e
movq -0x20(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x10(%rbp)
movq %rdx, %rax
addq $0x20, %rsp
popq %rbp
retq
jmp 0x2f42
// File: /workspace/github_c_makefile_star2_O0/pyk[P]simple-nn/deps/pcg/src/../include/pcg_variants.h
// Function: pcg_mcg_128_xsh_rr_64_boundedrand_r
inline uint64_t pcg_mcg_128_xsh_rr_64_boundedrand_r(struct pcg_state_128* rng,
                                                    uint64_t bound)
{
    uint64_t threshold = -bound % bound;
    for (;;) {
        uint64_t r = pcg_mcg_128_xsh_rr_64_random_r(rng);
        if (r >= threshold)
            return r % bound;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
subq -0x10(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2f70
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jb 0x2ffe
movq -0x20(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x10(%rbp)
movq %rdx, %rax
addq $0x20, %rsp
popq %rbp
retq
jmp 0x2fd2
// File: /workspace/github_c_makefile_star2_O0/pyk[P]simple-nn/deps/pcg/src/../include/pcg_variants.h
// Function: pcg_oneseq_128_rxs_m_xs_128_boundedrand_r
inline pcg128_t
pcg_oneseq_128_rxs_m_xs_128_boundedrand_r(struct pcg_state_128* rng,
                                          pcg128_t bound)
{
    pcg128_t threshold = -bound % bound;
    for (;;) {
        pcg128_t r = pcg_oneseq_128_rxs_m_xs_128_random_r(rng);
        if (r >= threshold)
            return r % bound;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rdi, -0x28(%rbp)
movq %rcx, -0x38(%rbp)
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rcx
xorl %eax, %eax
movq %rdx, %rdi
negq %rdi
movl %eax, %esi
sbbq %rcx, %rsi
callq 0x4050
movq %rdx, -0x48(%rbp)
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rdi
callq 0x3000
movq %rax, -0x70(%rbp)
movq %rdx, -0x68(%rbp)
movq -0x70(%rbp), %rax
movq -0x68(%rbp), %rcx
movq %rcx, -0x58(%rbp)
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdx
movq -0x58(%rbp), %rax
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rcx
subq %rsi, %rdx
sbbq %rcx, %rax
jb 0x310c
jmp 0x30e1
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rcx
callq 0x4050
movq %rdx, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x70, %rsp
popq %rbp
retq
jmp 0x30a6
nop
// File: /workspace/github_c_makefile_star2_O0/pyk[P]simple-nn/deps/pcg/src/../include/pcg_variants.h
// Function: pcg_unique_128_rxs_m_xs_128_boundedrand_r
inline pcg128_t
pcg_unique_128_rxs_m_xs_128_boundedrand_r(struct pcg_state_128* rng,
                                          pcg128_t bound)
{
    pcg128_t threshold = -bound % bound;
    for (;;) {
        pcg128_t r = pcg_unique_128_rxs_m_xs_128_random_r(rng);
        if (r >= threshold)
            return r % bound;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rdi, -0x28(%rbp)
movq %rcx, -0x38(%rbp)
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rcx
xorl %eax, %eax
movq %rdx, %rdi
negq %rdi
movl %eax, %esi
sbbq %rcx, %rsi
callq 0x4050
movq %rdx, -0x48(%rbp)
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rdi
callq 0x3110
movq %rax, -0x70(%rbp)
movq %rdx, -0x68(%rbp)
movq -0x70(%rbp), %rax
movq -0x68(%rbp), %rcx
movq %rcx, -0x58(%rbp)
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdx
movq -0x58(%rbp), %rax
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rcx
subq %rsi, %rdx
sbbq %rcx, %rax
jb 0x321c
jmp 0x31f1
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rcx
callq 0x4050
movq %rdx, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x70, %rsp
popq %rbp
retq
jmp 0x31b6
nop
// File: /workspace/github_c_makefile_star2_O0/pyk[P]simple-nn/deps/pcg/src/../include/pcg_variants.h
// Function: pcg_oneseq_128_xsl_rr_64_boundedrand_r
inline uint64_t
pcg_oneseq_128_xsl_rr_64_boundedrand_r(struct pcg_state_128* rng,
                                       uint64_t bound)
{
    uint64_t threshold = -bound % bound;
    for (;;) {
        uint64_t r = pcg_oneseq_128_xsl_rr_64_random_r(rng);
        if (r >= threshold)
            return r % bound;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
subq -0x10(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3330
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jb 0x33be
movq -0x20(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x10(%rbp)
movq %rdx, %rax
addq $0x20, %rsp
popq %rbp
retq
jmp 0x3392
// File: /workspace/github_c_makefile_star2_O0/pyk[P]simple-nn/deps/pcg/src/../include/pcg_variants.h
// Function: pcg_setseq_128_xsl_rr_64_boundedrand_r
inline uint64_t
pcg_setseq_128_xsl_rr_64_boundedrand_r(struct pcg_state_setseq_128* rng,
                                       uint64_t bound)
{
    uint64_t threshold = -bound % bound;
    for (;;) {
        uint64_t r = pcg_setseq_128_xsl_rr_64_random_r(rng);
        if (r >= threshold)
            return r % bound;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
subq -0x10(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3450
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jb 0x34de
movq -0x20(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x10(%rbp)
movq %rdx, %rax
addq $0x20, %rsp
popq %rbp
retq
jmp 0x34b2
// File: /workspace/github_c_makefile_star2_O0/pyk[P]simple-nn/deps/pcg/src/../include/pcg_variants.h
// Function: pcg_mcg_128_xsl_rr_64_boundedrand_r
inline uint64_t pcg_mcg_128_xsl_rr_64_boundedrand_r(struct pcg_state_128* rng,
                                                    uint64_t bound)
{
    uint64_t threshold = -bound % bound;
    for (;;) {
        uint64_t r = pcg_mcg_128_xsl_rr_64_random_r(rng);
        if (r >= threshold)
            return r % bound;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
subq -0x10(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x34e0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jb 0x356e
movq -0x20(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x10(%rbp)
movq %rdx, %rax
addq $0x20, %rsp
popq %rbp
retq
jmp 0x3542
// File: /workspace/github_c_makefile_star2_O0/pyk[P]simple-nn/deps/pcg/src/../include/pcg_variants.h
// Function: pcg_unique_128_xsl_rr_rr_128_boundedrand_r
inline pcg128_t
pcg_unique_128_xsl_rr_rr_128_boundedrand_r(struct pcg_state_128* rng,
                                           pcg128_t bound)
{
    pcg128_t threshold = -bound % bound;
    for (;;) {
        pcg128_t r = pcg_unique_128_xsl_rr_rr_128_random_r(rng);
        if (r >= threshold)
            return r % bound;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rdi, -0x28(%rbp)
movq %rcx, -0x38(%rbp)
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rcx
xorl %eax, %eax
movq %rdx, %rdi
negq %rdi
movl %eax, %esi
sbbq %rcx, %rsi
callq 0x4050
movq %rdx, -0x48(%rbp)
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rdi
callq 0x3680
movq %rax, -0x70(%rbp)
movq %rdx, -0x68(%rbp)
movq -0x70(%rbp), %rax
movq -0x68(%rbp), %rcx
movq %rcx, -0x58(%rbp)
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdx
movq -0x58(%rbp), %rax
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rcx
subq %rsi, %rdx
sbbq %rcx, %rax
jb 0x378c
jmp 0x3761
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rcx
callq 0x4050
movq %rdx, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x70, %rsp
popq %rbp
retq
jmp 0x3726
nop
// File: /workspace/github_c_makefile_star2_O0/pyk[P]simple-nn/deps/pcg/src/../include/pcg_variants.h
// Function: pcg_setseq_128_xsl_rr_rr_128_boundedrand_r
inline pcg128_t
pcg_setseq_128_xsl_rr_rr_128_boundedrand_r(struct pcg_state_setseq_128* rng,
                                           pcg128_t bound)
{
    pcg128_t threshold = -bound % bound;
    for (;;) {
        pcg128_t r = pcg_setseq_128_xsl_rr_rr_128_random_r(rng);
        if (r >= threshold)
            return r % bound;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rdi, -0x28(%rbp)
movq %rcx, -0x38(%rbp)
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rcx
xorl %eax, %eax
movq %rdx, %rdi
negq %rdi
movl %eax, %esi
sbbq %rcx, %rsi
callq 0x4050
movq %rdx, -0x48(%rbp)
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rdi
callq 0x3790
movq %rax, -0x70(%rbp)
movq %rdx, -0x68(%rbp)
movq -0x70(%rbp), %rax
movq -0x68(%rbp), %rcx
movq %rcx, -0x58(%rbp)
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdx
movq -0x58(%rbp), %rax
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rcx
subq %rsi, %rdx
sbbq %rcx, %rax
jb 0x389c
jmp 0x3871
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rcx
callq 0x4050
movq %rdx, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x70, %rsp
popq %rbp
retq
jmp 0x3836
nop
// File: /workspace/github_c_makefile_star2_O0/pyk[P]simple-nn/deps/pcg/src/../include/pcg_variants.h
// Function: pcg_output_rxs_m_xs_128_128
inline pcg128_t pcg_output_rxs_m_xs_128_128(pcg128_t state)
{
    pcg128_t word = ((state >> ((state >> 122u) + 6u)) ^ state)
                       * (PCG_128BIT_CONSTANT(17766728186571221404ULL,
                                              12605985483714917081ULL));
    // 327738287884841127335028083622016905945
    return (word >> 86u) ^ word;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq %rdx, %rax
shrq $0x3a, %rax
movb %al, %r8b
addb $0x6, %r8b
movb %r8b, %cl
movq %rdx, %rax
shrq %cl, %rax
movq %rax, -0x50(%rbp)
movb %r8b, %cl
movq %rsi, %rax
shrdq %cl, %rdx, %rax
movq -0x50(%rbp), %rcx
xorl %edi, %edi
testb $0x40, %r8b
cmovneq %rcx, %rax
cmovneq %rdi, %rcx
xorq %rsi, %rax
xorq %rdx, %rcx
movq %rcx, -0x48(%rbp)
movabsq $-0x96fe6d8b2809664, %rcx # imm = 0xF69019274D7F699C
movq %rax, %rdi
imulq %rcx, %rdi
movabsq $-0x510e8afdef710d27, %rsi # imm = 0xAEF17502108EF2D9
mulq %rsi
movq %rax, %rcx
movq %rdx, %rax
movq -0x48(%rbp), %rdx
addq %rdi, %rax
imulq %rsi, %rdx
addq %rdx, %rax
movq %rcx, -0x40(%rbp)
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq %rcx, %rax
shrq $0x16, %rax
xorq %rdx, %rax
movq %rcx, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pyk[P]simple-nn/deps/pcg/src/../include/pcg_variants.h
// Function: pcg_output_xsl_rr_rr_128_128
inline pcg128_t pcg_output_xsl_rr_rr_128_128(pcg128_t state)
{
    uint32_t rot1 = (uint32_t)(state >> 122u);
    uint64_t high = (uint64_t)(state >> 64u);
    uint64_t low  = (uint64_t)state;
    uint64_t xored = high ^ low;
    uint64_t newlow  = pcg_rotr_64(xored, rot1);
    uint64_t newhigh = pcg_rotr_64(high, newlow & 63u);
    return (((pcg128_t)newhigh) << 64u) | newlow;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
shrq $0x3a, %rax
movl %eax, -0x34(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
movq -0x48(%rbp), %rcx
xorq %rcx, %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
movl -0x34(%rbp), %esi
callq 0x3c90
movq %rax, -0x58(%rbp)
movq -0x40(%rbp), %rdi
movl -0x58(%rbp), %esi
andl $0x3f, %esi
callq 0x3c90
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rcx
movq -0x58(%rbp), %rax
movq %rcx, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/odknt[P]st/st.c
// Function: die
void
die(const char *errstr, ...)
{
	va_list ap;

	va_start(ap, errstr);
	vfprintf(stderr, errstr, ap);
	va_end(ap);
	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x6c55
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0x12349(%rip), %rax     # 0x18ff0
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x6360
leaq -0x20(%rbp), %rax
movl $0x1, %edi
callq 0x61b0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/odknt[P]st/st.c
// Function: utf8encode
size_t
utf8encode(Rune u, char *c)
{
	size_t len, i;

	len = utf8validate(&u, 0);
	if (len > UTF_SIZ)
		return 0;

	for (i = len - 1; i != 0; --i) {
		c[i] = utf8encodebyte(u, 0);
		u >>= 6;
	}
	c[0] = utf8encodebyte(u, len);

	return len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0xc(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x6e10
movq %rax, -0x20(%rbp)
cmpq $0x4, -0x20(%rbp)
jbe 0x6da1
movq $0x0, -0x8(%rbp)
jmp 0x6e00
movq -0x20(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x6de4
movl -0xc(%rbp), %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x6ea0
movb %al, %dl
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0xc(%rbp), %eax
shrl $0x6, %eax
movl %eax, -0xc(%rbp)
movq -0x28(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x6dad
movl -0xc(%rbp), %edi
movq -0x20(%rbp), %rsi
callq 0x6ea0
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/odknt[P]st/st.c
// Function: utf8validate
size_t
utf8validate(Rune *u, size_t i)
{
	if (!BETWEEN(*u, utfmin[i], utfmax[i]) || BETWEEN(*u, 0xD800, 0xDFFF))
		*u = UTF_INVALID;
	for (i = 1; *u > utfmax[i]; ++i)
		;

	return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
leaq 0xd8e9(%rip), %rax      # 0x14710
movl (%rax,%rcx,4), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
ja 0x6e61
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rdx
leaq 0xd8ed(%rip), %rcx      # 0x14730
cmpl (%rcx,%rdx,4), %eax
ja 0x6e61
movq -0x8(%rbp), %rcx
movl $0xd800, %eax           # imm = 0xD800
cmpl (%rcx), %eax
ja 0x6e6b
movq -0x8(%rbp), %rax
cmpl $0xdfff, (%rax)         # imm = 0xDFFF
ja 0x6e6b
movq -0x8(%rbp), %rax
movl $0xfffd, (%rax)         # imm = 0xFFFD
movq $0x1, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rdx
leaq 0xd8ac(%rip), %rcx      # 0x14730
cmpl (%rcx,%rdx,4), %eax
jbe 0x6e99
jmp 0x6e8b
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x6e73
movq -0x10(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/odknt[P]st/st.c
// Function: selstart
void
selstart(int col, int row, int snap)
{
	selclear();
	sel.mode = SEL_EMPTY;
	sel.type = SEL_REGULAR;
	sel.alt = IS_SET(MODE_ALTSCREEN);
	sel.snap = snap;
	sel.oe.x = sel.ob.x = col;
	sel.oe.y = sel.ob.y = row;
	selnormalize();

	if (sel.snap != 0)
		sel.mode = SEL_READY;
	tsetdirt(sel.nb.y, sel.ne.y);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
callq 0x6fb0
movl $0x1, 0x15280(%rip)     # 0x1c1b0
movl $0x1, 0x1527a(%rip)     # 0x1c1b4
movl 0x19174(%rip), %eax     # 0x200b4
andl $0x4, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x15288(%rip)     # 0x1c1dc
movl -0xc(%rbp), %eax
movl %eax, 0x1525b(%rip)     # 0x1c1b8
movl -0x4(%rbp), %eax
movl %eax, 0x15266(%rip)     # 0x1c1cc
movl %eax, 0x15268(%rip)     # 0x1c1d4
movl -0x8(%rbp), %eax
movl %eax, 0x1525b(%rip)     # 0x1c1d0
movl %eax, 0x1525d(%rip)     # 0x1c1d8
callq 0x6ff0
cmpl $0x0, 0x15231(%rip)     # 0x1c1b8
je 0x6f93
movl $0x2, 0x1521d(%rip)     # 0x1c1b0
movl 0x15227(%rip), %edi     # 0x1c1c0
movl 0x15229(%rip), %esi     # 0x1c1c8
callq 0x71a0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/odknt[P]st/st.c
// Function: selclear
void
selclear(void)
{
	if (sel.ob.x == -1)
		return;
	sel.mode = SEL_IDLE;
	sel.ob.x = -1;
	tsetdirt(sel.nb.y, sel.ne.y);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $-0x1, 0x15211(%rip)    # 0x1c1cc
jne 0x6fbf
jmp 0x6fe4
movl $0x0, 0x151e7(%rip)     # 0x1c1b0
movl $0xffffffff, 0x151f9(%rip) # imm = 0xFFFFFFFF
movl 0x151e7(%rip), %edi     # 0x1c1c0
movl 0x151e9(%rip), %esi     # 0x1c1c8
callq 0x71a0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/odknt[P]st/st.c
// Function: tsetdirt
void
tsetdirt(int top, int bot)
{
	int i;

	LIMIT(top, 0, term.row-1);
	LIMIT(bot, 0, term.row-1);

	for (i = top; i <= bot; i++)
		term.dirty[i] = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0x0, -0x4(%rbp)
jge 0x71b7
xorl %eax, %eax
movl %eax, -0x10(%rbp)
jmp 0x71e1
movl -0x4(%rbp), %eax
movl 0x15020(%rip), %ecx     # 0x1c1e0
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x71d5
movl 0x15013(%rip), %eax     # 0x1c1e0
subl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x71db
movl -0x4(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x71f4
xorl %eax, %eax
movl %eax, -0x18(%rbp)
jmp 0x721e
movl -0x8(%rbp), %eax
movl 0x14fe3(%rip), %ecx     # 0x1c1e0
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x7212
movl 0x14fd6(%rip), %eax     # 0x1c1e0
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7218
movl -0x8(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x8(%rbp), %eax
jg 0x724f
movq 0x18e47(%rip), %rax     # 0x20080
movslq -0xc(%rbp), %rcx
movl $0x1, (%rax,%rcx,4)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x722a
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/odknt[P]st/st.c
// Function: selextend
void
selextend(int col, int row, int type, int done)
{
	int oldey, oldex, oldsby, oldsey, oldtype;

	if (sel.mode == SEL_IDLE)
		return;
	if (done && sel.mode == SEL_EMPTY) {
		selclear();
		return;
	}

	oldey = sel.oe.y;
	oldex = sel.oe.x;
	oldsby = sel.nb.y;
	oldsey = sel.ne.y;
	oldtype = sel.type;

	sel.oe.x = col;
	sel.oe.y = row;
	selnormalize();
	sel.type = type;

	if (oldey != sel.oe.y || oldex != sel.oe.x || oldtype != sel.type || sel.mode == SEL_EMPTY)
		tsetdirt(MIN(sel.nb.y, oldsby), MAX(sel.ne.y, oldsey));

	sel.mode = done ? SEL_IDLE : SEL_READY;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
cmpl $0x0, 0x14f35(%rip)     # 0x1c1b0
jne 0x7282
jmp 0x7371
cmpl $0x0, -0x10(%rbp)
je 0x729b
cmpl $0x1, 0x14f21(%rip)     # 0x1c1b0
jne 0x729b
callq 0x6fb0
jmp 0x7371
movl 0x14f37(%rip), %eax     # 0x1c1d8
movl %eax, -0x14(%rbp)
movl 0x14f2a(%rip), %eax     # 0x1c1d4
movl %eax, -0x18(%rbp)
movl 0x14f0d(%rip), %eax     # 0x1c1c0
movl %eax, -0x1c(%rbp)
movl 0x14f0c(%rip), %eax     # 0x1c1c8
movl %eax, -0x20(%rbp)
movl 0x14eef(%rip), %eax     # 0x1c1b4
movl %eax, -0x24(%rbp)
movl -0x4(%rbp), %eax
movl %eax, 0x14f03(%rip)     # 0x1c1d4
movl -0x8(%rbp), %eax
movl %eax, 0x14efe(%rip)     # 0x1c1d8
callq 0x6ff0
movl -0xc(%rbp), %eax
movl %eax, 0x14ecc(%rip)     # 0x1c1b4
movl -0x14(%rbp), %eax
cmpl 0x14ee7(%rip), %eax     # 0x1c1d8
jne 0x7312
movl -0x18(%rbp), %eax
cmpl 0x14ed8(%rip), %eax     # 0x1c1d4
jne 0x7312
movl -0x24(%rbp), %eax
cmpl 0x14ead(%rip), %eax     # 0x1c1b4
jne 0x7312
cmpl $0x1, 0x14ea0(%rip)     # 0x1c1b0
jne 0x735b
movl 0x14ea8(%rip), %eax     # 0x1c1c0
cmpl -0x1c(%rbp), %eax
jge 0x7328
movl 0x14e9d(%rip), %eax     # 0x1c1c0
movl %eax, -0x28(%rbp)
jmp 0x732e
movl -0x1c(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl 0x14e8e(%rip), %eax     # 0x1c1c8
cmpl -0x20(%rbp), %eax
jge 0x7347
movl -0x20(%rbp), %eax
movl %eax, -0x30(%rbp)
jmp 0x7350
movl 0x14e7b(%rip), %eax     # 0x1c1c8
movl %eax, -0x30(%rbp)
movl -0x2c(%rbp), %edi
movl -0x30(%rbp), %esi
callq 0x71a0
movl -0x10(%rbp), %edx
movl $0x2, %eax
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, 0x14e3f(%rip)     # 0x1c1b0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/odknt[P]st/st.c
// Function: selected
int
selected(int x, int y)
{
	if (sel.mode == SEL_EMPTY || sel.ob.x == -1 ||
			sel.alt != IS_SET(MODE_ALTSCREEN))
		return 0;

	if (sel.type == SEL_RECTANGULAR)
		return BETWEEN(y, sel.nb.y, sel.ne.y)
		    && BETWEEN(x, sel.nb.x, sel.ne.x);

	return BETWEEN(y, sel.nb.y, sel.ne.y)
	    && (y != sel.nb.y || x >= sel.nb.x)
	    && (y != sel.ne.y || x <= sel.ne.x);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x1, 0x14e1f(%rip)     # 0x1c1b0
je 0x73bb
cmpl $-0x1, 0x14e32(%rip)    # 0x1c1cc
je 0x73bb
movl 0x14e3a(%rip), %eax     # 0x1c1dc
movl 0x18d0c(%rip), %ecx     # 0x200b4
andl $0x4, %ecx
cmpl $0x0, %ecx
setne %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
je 0x73c7
movl $0x0, -0x4(%rbp)
jmp 0x748d
cmpl $0x2, 0x14de6(%rip)     # 0x1c1b4
jne 0x7422
movl 0x14dea(%rip), %ecx     # 0x1c1c0
xorl %eax, %eax
cmpl -0xc(%rbp), %ecx
movb %al, -0xd(%rbp)
jg 0x7415
movl -0xc(%rbp), %ecx
xorl %eax, %eax
cmpl 0x14ddd(%rip), %ecx     # 0x1c1c8
movb %al, -0xd(%rbp)
jg 0x7415
movl 0x14dc6(%rip), %ecx     # 0x1c1bc
xorl %eax, %eax
cmpl -0x8(%rbp), %ecx
movb %al, -0xe(%rbp)
jg 0x740f
movl -0x8(%rbp), %eax
cmpl 0x14dbb(%rip), %eax     # 0x1c1c4
setle %al
movb %al, -0xe(%rbp)
movb -0xe(%rbp), %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x748d
movl 0x14d98(%rip), %ecx     # 0x1c1c0
xorl %eax, %eax
cmpl -0xc(%rbp), %ecx
movb %al, -0xf(%rbp)
jg 0x7482
movl -0xc(%rbp), %ecx
xorl %eax, %eax
cmpl 0x14d8b(%rip), %ecx     # 0x1c1c8
movb %al, -0xf(%rbp)
jg 0x7482
movl -0xc(%rbp), %eax
cmpl 0x14d75(%rip), %eax     # 0x1c1c0
jne 0x745d
movl -0x8(%rbp), %ecx
xorl %eax, %eax
cmpl 0x14d64(%rip), %ecx     # 0x1c1bc
movb %al, -0xf(%rbp)
jl 0x7482
movl -0xc(%rbp), %ecx
movb $0x1, %al
cmpl 0x14d60(%rip), %ecx     # 0x1c1c8
movb %al, -0x10(%rbp)
jne 0x747c
movl -0x8(%rbp), %eax
cmpl 0x14d4e(%rip), %eax     # 0x1c1c4
setle %al
movb %al, -0x10(%rbp)
movb -0x10(%rbp), %al
movb %al, -0xf(%rbp)
movb -0xf(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/odknt[P]st/st.c
// Function: tlinelen
int
tlinelen(int y)
{
	int i = term.col;

	if (TLINE(y)[i - 1].mode & ATTR_WRAP)
		return i;

	while (i > 0 && TLINE(y)[i - 1].u == ' ')
		--i;

	return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl 0x149e7(%rip), %eax     # 0x1c1e4
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
cmpl 0x18873(%rip), %eax     # 0x2007c
jge 0x783f
movl -0x8(%rbp), %eax
addl 0x18864(%rip), %eax     # 0x20078
subl 0x18862(%rip), %eax     # 0x2007c
addl $0x7d0, %eax            # imm = 0x7D0
addl $0x1, %eax
movl $0x7d0, %ecx            # imm = 0x7D0
cltd
idivl %ecx
movslq %edx, %rcx
leaq 0x149ac(%rip), %rax     # 0x1c1e0
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
jmp 0x785a
movq 0x149a2(%rip), %rax     # 0x1c1e8
movl -0x8(%rbp), %ecx
subl 0x1882d(%rip), %ecx     # 0x2007c
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movzwl 0x4(%rax), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
je 0x7887
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x7928
jmp 0x7889
xorl %eax, %eax
cmpl $0x0, -0xc(%rbp)
movb %al, -0x19(%rbp)
jle 0x790b
movl -0x8(%rbp), %eax
cmpl 0x187df(%rip), %eax     # 0x2007c
jge 0x78d3
movl -0x8(%rbp), %eax
addl 0x187d0(%rip), %eax     # 0x20078
subl 0x187ce(%rip), %eax     # 0x2007c
addl $0x7d0, %eax            # imm = 0x7D0
addl $0x1, %eax
movl $0x7d0, %ecx            # imm = 0x7D0
cltd
idivl %ecx
movslq %edx, %rcx
leaq 0x14918(%rip), %rax     # 0x1c1e0
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
jmp 0x78ee
movq 0x1490e(%rip), %rax     # 0x1c1e8
movl -0x8(%rbp), %ecx
subl 0x18799(%rip), %ecx     # 0x2007c
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $0x20, (%rax)
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x7914
jmp 0x7922
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x7889
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/odknt[P]st/st.c
// Function: stty
void
stty(char **args)
{
	char cmd[_POSIX_ARG_MAX], **p, *q, *s;
	size_t n, siz;

	if ((n = strlen(stty_args)) > sizeof(cmd)-1)
		die("incorrect stty parameters\n");
	memcpy(cmd, stty_args, n);
	q = cmd + n;
	siz = sizeof(cmd) - n;
	for (p = args; p && (s = *p); ++p) {
		if ((n = strlen(s)) > siz-1)
			die("stty parameter length too long\n");
		*q++ = ' ';
		memcpy(q, s, n);
		q += n;
		siz -= n + 1;
	}
	*q = '\0';
	if (system(cmd) != 0)
		perror("Couldn't call stty");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1040, %rsp           # imm = 0x1040
movq %rdi, -0x8(%rbp)
leaq 0x11b6a(%rip), %rax     # 0x19780
movq (%rax), %rdi
callq 0x6410
movq %rax, -0x1030(%rbp)
cmpq $0xfff, %rax            # imm = 0xFFF
jbe 0x7c3b
leaq 0xcd83(%rip), %rdi      # 0x149b7
movb $0x0, %al
callq 0x6c20
leaq -0x1010(%rbp), %rdi
leaq 0x11b37(%rip), %rax     # 0x19780
movq (%rax), %rsi
movq -0x1030(%rbp), %rdx
callq 0x6a30
leaq -0x1010(%rbp), %rax
addq -0x1030(%rbp), %rax
movq %rax, -0x1020(%rbp)
movl $0x1000, %eax           # imm = 0x1000
subq -0x1030(%rbp), %rax
movq %rax, -0x1038(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1018(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x1018(%rbp)
movb %al, -0x1039(%rbp)
je 0x7cbb
movq -0x1018(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x1028(%rbp)
cmpq $0x0, %rax
setne %al
movb %al, -0x1039(%rbp)
movb -0x1039(%rbp), %al
testb $0x1, %al
jne 0x7cca
jmp 0x7d75
movq -0x1028(%rbp), %rdi
callq 0x6410
movq %rax, -0x1030(%rbp)
movq -0x1038(%rbp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jbe 0x7cfb
leaq 0xccde(%rip), %rdi      # 0x149d2
movb $0x0, %al
callq 0x6c20
movq -0x1020(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x1020(%rbp)
movb $0x20, (%rax)
movq -0x1020(%rbp), %rdi
movq -0x1028(%rbp), %rsi
movq -0x1030(%rbp), %rdx
callq 0x6a30
movq -0x1030(%rbp), %rax
addq -0x1020(%rbp), %rax
movq %rax, -0x1020(%rbp)
movq -0x1030(%rbp), %rcx
addq $0x1, %rcx
movq -0x1038(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x1038(%rbp)
movq -0x1018(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x1018(%rbp)
jmp 0x7c8b
movq -0x1020(%rbp), %rax
movb $0x0, (%rax)
leaq -0x1010(%rbp), %rdi
callq 0x6250
cmpl $0x0, %eax
je 0x7d9c
leaq 0xcc5b(%rip), %rdi      # 0x149f2
callq 0x69a0
addq $0x1040, %rsp           # imm = 0x1040
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/odknt[P]st/st.c
// Function: sigchld
void
sigchld(int a)
{
	int stat;
	pid_t p;

	if ((p = waitpid(pid, &stat, WNOHANG)) < 0)
		die("waiting for pid %hd failed: %s\n", pid, strerror(errno));

	if (pid != p)
		return;
	cleanup();

	if (WIFEXITED(stat) && WEXITSTATUS(stat))
		fprintf(stderr, "child exited with status %d\n", WEXITSTATUS(stat));
	else if (WIFSIGNALED(stat))
		die("child terminated due to signal %d\n", WTERMSIG(stat));
	_exit(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl 0x18087(%rip), %edi     # 0x200e8
leaq -0x8(%rbp), %rsi
movl $0x1, %edx
callq 0x6650
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
jge 0x80a0
movl 0x1806b(%rip), %eax     # 0x200e8
movl %eax, -0x10(%rbp)
callq 0x66e0
movl (%rax), %edi
callq 0x6570
movl -0x10(%rbp), %esi
movq %rax, %rdx
leaq 0xc9bb(%rip), %rdi      # 0x14a54
movb $0x0, %al
callq 0x6c20
movl 0x18042(%rip), %eax     # 0x200e8
cmpl -0xc(%rbp), %eax
je 0x80b1
addq $0x10, %rsp
popq %rbp
retq
callq 0xa3c0
movl -0x8(%rbp), %eax
andl $0x7f, %eax
cmpl $0x0, %eax
jne 0x80f7
movl -0x8(%rbp), %eax
andl $0xff00, %eax           # imm = 0xFF00
sarl $0x8, %eax
cmpl $0x0, %eax
je 0x80f7
movq 0x10f18(%rip), %rax     # 0x18ff0
movq (%rax), %rdi
movl -0x8(%rbp), %edx
andl $0xff00, %edx           # imm = 0xFF00
sarl $0x8, %edx
leaq 0xc986(%rip), %rsi      # 0x14a74
movb $0x0, %al
callq 0x69d0
jmp 0x8120
movl -0x8(%rbp), %eax
andl $0x7f, %eax
addl $0x1, %eax
movsbl %al, %eax
sarl %eax
cmpl $0x0, %eax
jle 0x811e
movl -0x8(%rbp), %esi
andl $0x7f, %esi
leaq 0xc97a(%rip), %rdi      # 0x14a91
movb $0x0, %al
callq 0x6c20
jmp 0x8120
xorl %edi, %edi
callq 0x6280
nopw (%rax,%rax)