LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/norx6441v2/ref/norx.c
// Function: norx_absorb_data
void norx_absorb_data(norx_state_t state, const unsigned char * in, size_t inlen, tag_t tag)
{
    if (inlen > 0)
    {
        while (inlen >= BYTES(NORX_R))
        {
            norx_absorb_block(state, in, tag);
            #if defined(NORX_DEBUG)
            printf("Absorb block\n");
            norx_debug(state, in, BYTES(NORX_R), NULL, 0);
            #endif
            inlen -= BYTES(NORX_R);
            in += BYTES(NORX_R);
        }
        norx_absorb_lastblock(state, in, inlen, tag);
        #if defined(NORX_DEBUG)
        printf("Absorb lastblock\n");
        norx_debug(state, in, inlen, NULL, 0);
        #endif
    }
}

// Assembly:
testq %rdx, %rdx
je 0x12d8
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
cmpq $0x60, %r15
jb 0x128a
movq %r14, %rdi
movq %r12, %rsi
movl %ebx, %edx
callq 0x12d9
addq $-0x60, %r15
addq $0x60, %r12
jmp 0x126d
vxorps %xmm0, %xmm0, %xmm0
movq %rsp, %r13
vmovups %ymm0, 0x40(%r13)
vmovups %ymm0, 0x20(%r13)
vmovups %ymm0, (%r13)
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
vzeroupper
callq 0x10c0
movb $0x1, (%rsp,%r15)
orb $-0x80, 0x5f(%r13)
movq %r14, %rdi
movq %r13, %rsi
movl %ebx, %edx
callq 0x12d9
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/norx6441v2/ref/norx.c
// Function: norx_absorb_block
static NORX_INLINE void norx_absorb_block(norx_state_t state, const uint8_t * in, tag_t tag)
{
    size_t i;
    norx_word_t * S = state->S;

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

    for (i = 0; i < WORDS(NORX_R); ++i) {
        S[i] ^= LOAD(in + i * BYTES(NORX_W));
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl %edx, %eax
xorq %rax, 0x78(%rdi)
callq 0x179b
xorl %eax, %eax
cmpq $0xc, %rax
je 0x1303
movq (%rbx,%rax,8), %rcx
xorq %rcx, (%r14,%rax,8)
incq %rax
jmp 0x12f0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/norx6441v2/ref/norx.c
// Function: norx_encrypt_data
void norx_encrypt_data(norx_state_t state, unsigned char *out, const unsigned char * in, size_t inlen)
{
    if (inlen > 0)
    {
        while (inlen >= BYTES(NORX_R))
        {
            norx_encrypt_block(state, out, in);
            #if defined(NORX_DEBUG)
            printf("Encrypt block\n");
            norx_debug(state, in, BYTES(NORX_R), out, BYTES(NORX_R));
            #endif
            inlen -= BYTES(NORX_R);
            in    += BYTES(NORX_R);
            out   += BYTES(NORX_R);
        }
        norx_encrypt_lastblock(state, out, in, inlen);
        #if defined(NORX_DEBUG)
        printf("Encrypt lastblock\n");
        norx_debug(state, in, inlen, out, inlen);
        #endif
    }
}

// Assembly:
testq %rcx, %rcx
je 0x13ab
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
cmpq $0x60, %rbx
jb 0x134f
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x13ac
addq $-0x60, %rbx
addq $0x60, %r12
addq $0x60, %r14
jmp 0x132d
vxorps %xmm0, %xmm0, %xmm0
movq %rsp, %r13
vmovups %ymm0, 0x40(%r13)
vmovups %ymm0, 0x20(%r13)
vmovups %ymm0, (%r13)
movq %r13, %rdi
movq %r12, %rsi
movq %rbx, %rdx
vzeroupper
callq 0x10c0
movb $0x1, (%rsp,%rbx)
orb $-0x80, 0x5f(%r13)
movq %r15, %rdi
movq %r13, %rsi
movq %r13, %rdx
callq 0x13ac
movq %r14, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x10c0
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/norx6441v2/ref/norx.c
// Function: norx_encrypt_block
static NORX_INLINE void norx_encrypt_block(norx_state_t state, uint8_t *out, const uint8_t * in)
{
    size_t i;
    norx_word_t * S = state->S;

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorb $0x2, 0x78(%rdi)
callq 0x179b
xorl %eax, %eax
cmpq $0xc, %rax
je 0x13e0
movq (%r15,%rax,8), %rcx
xorq (%rbx,%rax,8), %rcx
movq %rcx, (%r15,%rax,8)
movq %rcx, (%r14,%rax,8)
incq %rax
jmp 0x13c5
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/norx6441v2/ref/norx.c
// Function: norx_decrypt_data
void norx_decrypt_data(norx_state_t state, unsigned char *out, const unsigned char * in, size_t inlen)
{
    if (inlen > 0)
    {
        while (inlen >= BYTES(NORX_R))
        {
            norx_decrypt_block(state, out, in);
            #if defined(NORX_DEBUG)
            printf("Decrypt block\n");
            norx_debug(state, in, BYTES(NORX_R), out, BYTES(NORX_R));
            #endif
            inlen -= BYTES(NORX_R);
            in    += BYTES(NORX_R);
            out   += BYTES(NORX_R);
        }
        norx_decrypt_lastblock(state, out, in, inlen);
        #if defined(NORX_DEBUG)
        printf("Decrypt lastblock\n");
        norx_debug(state, in, inlen, out, inlen);
        #endif
    }
}

// Assembly:
testq %rcx, %rcx
je 0x14d4
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
cmpq $0x60, %rbx
jb 0x1449
xorb $0x2, 0x78(%r15)
movq %r15, %rdi
callq 0x179b
xorl %eax, %eax
cmpq $0xc, %rax
je 0x143b
movq (%r12,%rax,8), %rcx
movq (%r15,%rax,8), %rdx
xorq %rcx, %rdx
movq %rdx, (%r14,%rax,8)
movq %rcx, (%r15,%rax,8)
incq %rax
jmp 0x141d
addq $-0x60, %rbx
addq $0x60, %r12
addq $0x60, %r14
jmp 0x1408
xorb $0x2, 0x78(%r15)
movq %r15, %rdi
callq 0x179b
xorl %eax, %eax
cmpq $0xc, %rax
je 0x146b
movq (%r15,%rax,8), %rcx
movq %rcx, (%rsp,%rax,8)
incq %rax
jmp 0x1458
movq %rsp, %r13
movq %r13, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x10c0
xorb $0x1, (%rsp,%rbx)
xorb $-0x80, 0x5f(%r13)
xorl %eax, %eax
cmpq $0xc, %rax
je 0x14a5
movq (%rsp,%rax,8), %rcx
movq (%r15,%rax,8), %rdx
xorq %rcx, %rdx
movq %rdx, (%rsp,%rax,8)
movq %rcx, (%r15,%rax,8)
incq %rax
jmp 0x1487
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x10c0
movq 0x294b(%rip), %rax      # 0x3e08
pushq $0x60
popq %rdx
movq %r15, %rdi
xorl %esi, %esi
callq *%rax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/norx6441v2/ref/norx.c
// Function: norx_verify_tag
int norx_verify_tag(const unsigned char * tag1, const unsigned char * tag2)
{
    size_t i;
    unsigned acc = 0;

    for (i = 0; i < BYTES(NORX_T); ++i) {
        acc |= tag1[i] ^ tag2[i];
    }

    return (((acc - 1) >> 8) & 1) - 1;
}

// Assembly:
xorl %eax, %eax
xorl %ecx, %ecx
cmpq $0x20, %rax
je 0x14ef
movb (%rsi,%rax), %dl
xorb (%rdi,%rax), %dl
movzbl %dl, %edx
orl %edx, %ecx
incq %rax
jmp 0x14d9
decl %ecx
xorl %eax, %eax
btl $0x8, %ecx
adcl $-0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/norx6441v2/ref/norx.c
// Function: norx_aead_encrypt
void norx_aead_encrypt(
  unsigned char *c, size_t *clen,
  const unsigned char *a, size_t alen,
  const unsigned char *m, size_t mlen,
  const unsigned char *z, size_t zlen,
  const unsigned char *nonce,
  const unsigned char *key
)
{
    norx_state_t state;
    norx_init(state, key, nonce);
    norx_absorb_data(state, a, alen, HEADER_TAG);
    norx_encrypt_data(state, c, m, mlen);
    norx_absorb_data(state, z, zlen, TRAILER_TAG);
    norx_finalise(state, c + mlen);
    *clen = mlen + BYTES(NORX_T);
    burn(state, 0, sizeof(norx_state_t));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %r9, %rbx
movq %r8, %r13
movq %rcx, %rbp
movq %rdx, %r14
movq %rsi, 0x8(%rsp)
movq %rdi, %r12
movq 0xe8(%rsp), %rsi
movq 0xe0(%rsp), %rdx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x15b9
pushq $0x1
popq %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0x1060
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rbx, %rcx
callq 0x1090
pushq $0x4
popq %rcx
movq %r15, %rdi
movq 0xd0(%rsp), %rsi
movq 0xd8(%rsp), %rdx
callq 0x1060
addq %rbx, %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x1637
addq $0x20, %rbx
movq 0x8(%rsp), %rax
movq %rbx, (%rax)
movq 0x286d(%rip), %rax      # 0x3e08
movl $0x80, %edx
movq %r15, %rdi
xorl %esi, %esi
callq *%rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
xorl %eax, %eax
cmpq $0x10, %rax
je 0x15d8
movq %rax, (%rbx,%rax,8)
incq %rax
jmp 0x15c9
movq %rbx, %rdi
callq 0x17be
movq %rbx, %rdi
callq 0x17be
movq (%r15), %rax
movq %rax, (%rbx)
movq 0x8(%r15), %rax
movq %rax, 0x8(%rbx)
movq (%r14), %rax
movq %rax, 0x20(%rbx)
movq 0x8(%r14), %rax
movq %rax, 0x28(%rbx)
movq 0x10(%r14), %rax
movq %rax, 0x30(%rbx)
movq 0x18(%r14), %rax
movq %rax, 0x38(%rbx)
vmovups 0x60(%rbx), %ymm0
vxorps 0x9de(%rip), %ymm0, %ymm0 # 0x2000
vmovups %ymm0, 0x60(%rbx)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
vzeroupper
jmp 0x179b
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorb $0x8, 0x78(%rdi)
callq 0x179b
movq %rbx, %rdi
callq 0x179b
xorl %eax, %eax
cmpq $0xc, %rax
je 0x166a
movq (%rbx,%rax,8), %rcx
movq %rcx, (%rsp,%rax,8)
incq %rax
jmp 0x1657
movq %rsp, %rdi
vmovups (%rdi), %ymm0
vmovups %ymm0, (%r14)
movq 0x278b(%rip), %rax      # 0x3e08
pushq $0x60
popq %rdx
xorl %esi, %esi
vzeroupper
callq *%rax
movq 0x277a(%rip), %rax      # 0x3e08
movl $0x80, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq *%rax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
cmpq $0x20, %r9
jae 0x16c1
pushq $-0x1
popq %rbp
jmp 0x1787
movq %r9, %r14
movq %r8, %r15
movq %rcx, %r13
movq %rdx, %r12
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
movq 0x108(%rsp), %rsi
movq 0x100(%rsp), %rdx
leaq 0x30(%rsp), %rbp
movq %rbp, %rdi
callq 0x15b9
pushq $0x1
popq %rcx
movq %rbp, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x1060
leaq -0x20(%r14), %r13
movq %rbp, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r13, %rcx
callq 0x10b0
pushq $0x4
popq %rcx
movq %rbp, %rdi
movq 0xf0(%rsp), %rsi
movq 0xf8(%rsp), %rdx
callq 0x1060
leaq 0x10(%rsp), %r12
movq %rbp, %rdi
movq %r12, %rsi
callq 0x1637
movq 0x8(%rsp), %rax
movq %r13, (%rax)
leaq (%r14,%r15), %rdi
addq $-0x20, %rdi
movq %r12, %rsi
callq 0x1070
movl %eax, %ebp
testl %eax, %eax
je 0x1772
movq 0x26a0(%rip), %rax      # 0x3e08
movq %rbx, %rdi
xorl %esi, %esi
movq %r13, %rdx
callq *%rax
movq 0x268f(%rip), %rax      # 0x3e08
leaq 0x30(%rsp), %rdi
movl $0x80, %edx
xorl %esi, %esi
callq *%rax
movl %ebp, %eax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/norx6441v2/ref/norx.c
// Function: F
static NORX_INLINE void F(norx_word_t S[16])
{
    /* Column step */
    G(S[ 0], S[ 4], S[ 8], S[12]);
    G(S[ 1], S[ 5], S[ 9], S[13]);
    G(S[ 2], S[ 6], S[10], S[14]);
    G(S[ 3], S[ 7], S[11], S[15]);
    /* Diagonal step */
    G(S[ 0], S[ 5], S[10], S[15]);
    G(S[ 1], S[ 6], S[11], S[12]);
    G(S[ 2], S[ 7], S[ 8], S[13]);
    G(S[ 3], S[ 4], S[ 9], S[14]);
}

// Assembly:
vmovdqu 0x40(%rdi), %ymm0
vmovdqu (%rdi), %xmm1
vmovdqu 0x10(%rdi), %xmm2
vmovdqu 0x20(%rdi), %xmm3
vmovdqu 0x30(%rdi), %xmm4
vpand %xmm2, %xmm4, %xmm5
vpaddq %xmm5, %xmm5, %xmm5
vpternlogq $0x96, %xmm4, %xmm2, %xmm5
vpand %xmm1, %xmm3, %xmm2
vpaddq %xmm2, %xmm2, %xmm2
vpternlogq $0x96, %xmm3, %xmm1, %xmm2
vinserti128 $0x1, %xmm5, %ymm2, %ymm1
vpxor 0x60(%rdi), %ymm1, %ymm1
vprolq $0x38, %ymm1, %ymm1
vpand %ymm0, %ymm1, %ymm3
vpaddq %ymm3, %ymm3, %ymm3
vpternlogq $0x96, %ymm0, %ymm1, %ymm3
vpxor 0x20(%rdi), %ymm3, %ymm0
vprolq $0x2d, %ymm0, %ymm0
vpand %xmm2, %xmm0, %xmm4
vpaddq %xmm4, %xmm4, %xmm4
vpternlogq $0x96, %xmm2, %xmm0, %xmm4
vextracti128 $0x1, %ymm0, %xmm2
vpand %xmm5, %xmm2, %xmm6
vpaddq %xmm6, %xmm6, %xmm6
vpternlogq $0x96, %xmm5, %xmm2, %xmm6
vinserti128 $0x1, %xmm6, %ymm4, %ymm2
vpxor %ymm1, %ymm2, %ymm1
vprolq $0x18, %ymm1, %ymm1
vpand %ymm3, %ymm1, %ymm2
vpaddq %ymm2, %ymm2, %ymm2
vpternlogq $0x96, %ymm3, %ymm1, %ymm2
vpxor %ymm0, %ymm2, %ymm0
vprolq $0x1, %ymm0, %ymm0
vpmovsxbq 0x7e7(%rip), %ymm3 # 0x2060
vpermi2q %ymm6, %ymm4, %ymm3
vpand %ymm3, %ymm0, %ymm3
vpaddq %ymm3, %ymm3, %ymm3
vpunpcklqdq %xmm0, %xmm6, %xmm5 # xmm5 = xmm6[0],xmm0[0]
vinserti128 $0x1, %xmm4, %ymm5, %ymm4
vpmovsxbq 0x7ca(%rip), %ymm5 # 0x2064
vpermq $0x93, %ymm3, %ymm3     # ymm3 = ymm3[3,0,1,2]
vpermi2q %ymm6, %ymm0, %ymm5
vpternlogq $0x96, %ymm3, %ymm4, %ymm5
vpermq $0x39, %ymm1, %ymm1     # ymm1 = ymm1[1,2,3,0]
vpxor %ymm5, %ymm1, %ymm1
vprolq $0x38, %ymm1, %ymm1
vpand %ymm1, %ymm2, %ymm3
vpaddq %ymm3, %ymm3, %ymm3
vpblendd $0xc0, %ymm1, %ymm2, %ymm4 # ymm4 = ymm2[0,1,2,3,4,5],ymm1[6,7]
vpblendd $0xc0, %ymm2, %ymm1, %ymm2 # ymm2 = ymm1[0,1,2,3,4,5],ymm2[6,7]
vpternlogq $0x96, %ymm3, %ymm4, %ymm2
vpermq $0x93, %ymm0, %ymm0     # ymm0 = ymm0[3,0,1,2]
vpxor %ymm0, %ymm2, %ymm0
vprolq $0x2d, %ymm0, %ymm0
vpand %ymm5, %ymm0, %ymm3
vpaddq %ymm3, %ymm3, %ymm3
vpternlogq $0x96, %ymm5, %ymm0, %ymm3
vpermq $0x4e, %ymm3, %ymm4     # ymm4 = ymm3[2,3,0,1]
vmovdqu %ymm4, (%rdi)
vpxor %ymm1, %ymm3, %ymm1
vprolq $0x18, %ymm1, %ymm1
vpand %ymm2, %ymm1, %ymm3
vpaddq %ymm3, %ymm3, %ymm3
vpternlogq $0x96, %ymm2, %ymm1, %ymm3
vpermq $0x93, %ymm1, %ymm1     # ymm1 = ymm1[3,0,1,2]
vmovdqu %ymm1, 0x60(%rdi)
vmovdqu %ymm3, 0x40(%rdi)
vpxor %ymm0, %ymm3, %ymm0
vprolq $0x1, %ymm0, %ymm0
vpermq $0x39, %ymm0, %ymm0     # ymm0 = ymm0[1,2,3,0]
vmovdqu %ymm0, 0x20(%rdi)
vzeroupper
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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:
movq %rdx, %rcx
movq %rsi, %rax
movq %rdi, %rsi
orq $0x1, %rsi
movq %rdi, %r8
sarq $0x3f, %r8
addq %rsi, %rax
adcq %r8, %rcx
movabsq $0x2360ed051fc65da4, %r9 # imm = 0x2360ED051FC65DA4
imulq %rax, %r9
movabsq $0x4385df649fccf645, %r10 # imm = 0x4385DF649FCCF645
mulq %r10
addq %r9, %rdx
imulq %r10, %rcx
addq %rdx, %rcx
addq %rsi, %rax
adcq %r8, %rcx
movq %rax, (%rdi)
movq %rcx, 0x8(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rax
negq %rax
xorl %edx, %edx
divq %rsi
movq %rdx, %r15
movq %r14, %rdi
callq 0x213a
cmpq %r15, %rax
jb 0x21a8
xorl %edx, %edx
divq %rbx
movq %rdx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rax
negq %rax
xorl %edx, %edx
divq %rsi
movq %rdx, %r15
movq %r14, %rdi
callq 0x21c3
cmpq %r15, %rax
jb 0x2228
xorl %edx, %edx
divq %rbx
movq %rdx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rax
negq %rax
xorl %edx, %edx
divq %rsi
movq %rdx, %r15
movq %r14, %rdi
callq 0x2243
cmpq %r15, %rax
jb 0x229c
xorl %edx, %edx
divq %rbx
movq %rdx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rax
negq %rax
xorl %edx, %edx
divq %rsi
movq %rdx, %r15
movq %r14, %rdi
callq 0x22b7
cmpq %r15, %rax
jb 0x2308
xorl %edx, %edx
divq %rbx
movq %rdx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rax
negq %rax
xorl %edx, %edx
divq %rsi
movq %rdx, %r15
movq %r14, %rdi
callq 0x2323
cmpq %r15, %rax
jb 0x2391
xorl %edx, %edx
divq %rbx
movq %rdx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rax
negq %rax
xorl %edx, %edx
divq %rsi
movq %rdx, %r15
movq %r14, %rdi
callq 0x23ac
cmpq %r15, %rax
jb 0x2411
xorl %edx, %edx
divq %rbx
movq %rdx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rax
negq %rax
xorl %edx, %edx
divq %rsi
movq %rdx, %r15
movq %r14, %rdi
callq 0x242c
cmpq %r15, %rax
jb 0x2485
xorl %edx, %edx
divq %rbx
movq %rdx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rax
negq %rax
xorl %edx, %edx
divq %rsi
movq %rdx, %r15
movq %r14, %rdi
callq 0x24a0
cmpq %r15, %rax
jb 0x24f1
xorl %edx, %edx
divq %rbx
movq %rdx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %esi, %esi
movq %r14, %rdi
negq %rdi
sbbq %rdx, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x2e70
movq %rax, %r12
movq %rdx, %r13
movq %r15, %rdi
callq 0x250c
cmpq %r12, %rax
movq %rdx, %rcx
sbbq %r13, %rcx
jb 0x258f
movq %rax, %rdi
movq %rdx, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x2e70
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %esi, %esi
movq %r14, %rdi
negq %rdi
sbbq %rdx, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x2e70
movq %rax, %r12
movq %rdx, %r13
movq %r15, %rdi
callq 0x25bd
cmpq %r12, %rax
movq %rdx, %rcx
sbbq %r13, %rcx
jb 0x2637
movq %rax, %rdi
movq %rdx, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x2e70
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/pyk[P]simple-nn/deps/pcg/src/../include/pcg_variants.h
// Function: pcg_setseq_128_rxs_m_xs_128_boundedrand_r
inline pcg128_t
pcg_setseq_128_rxs_m_xs_128_boundedrand_r(struct pcg_state_setseq_128* rng,
                                          pcg128_t bound)
{
    pcg128_t threshold = -bound % bound;
    for (;;) {
        pcg128_t r = pcg_setseq_128_rxs_m_xs_128_random_r(rng);
        if (r >= threshold)
            return r % bound;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %esi, %esi
movq %r14, %rdi
negq %rdi
sbbq %rdx, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x2e70
movq %rax, %r12
movq %rdx, %r13
movq %r15, %rdi
callq 0x2665
cmpq %r12, %rax
movq %rdx, %rcx
sbbq %r13, %rcx
jb 0x26d3
movq %rax, %rdi
movq %rdx, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x2e70
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rax
negq %rax
xorl %edx, %edx
divq %rsi
movq %rdx, %r15
movq %r14, %rdi
callq 0x2701
cmpq %r15, %rax
jb 0x276f
xorl %edx, %edx
divq %rbx
movq %rdx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/pyk[P]simple-nn/deps/pcg/src/../include/pcg_variants.h
// Function: pcg_unique_128_xsl_rr_64_boundedrand_r
inline uint64_t
pcg_unique_128_xsl_rr_64_boundedrand_r(struct pcg_state_128* rng,
                                       uint64_t bound)
{
    uint64_t threshold = -bound % bound;
    for (;;) {
        uint64_t r = pcg_unique_128_xsl_rr_64_random_r(rng);
        if (r >= threshold)
            return r % bound;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rax
negq %rax
xorl %edx, %edx
divq %rsi
movq %rdx, %r15
movq %r14, %rdi
callq 0x278a
cmpq %r15, %rax
jb 0x27f2
xorl %edx, %edx
divq %rbx
movq %rdx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rax
negq %rax
xorl %edx, %edx
divq %rsi
movq %rdx, %r15
movq %r14, %rdi
callq 0x280d
cmpq %r15, %rax
jb 0x2869
xorl %edx, %edx
divq %rbx
movq %rdx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movq %rsi, %rax
negq %rax
xorl %edx, %edx
divq %rsi
movq %rdx, %r8
movq (%rdi), %rax
movq 0x8(%rdi), %r9
movabsq $0x2360ed051fc65da4, %r10 # imm = 0x2360ED051FC65DA4
movabsq $0x4385df649fccf645, %r11 # imm = 0x4385DF649FCCF645
movq %rax, %rcx
imulq %r10, %rcx
mulq %r11
addq %rcx, %rdx
imulq %r11, %r9
addq %rdx, %r9
movq %rax, %rdx
xorq %r9, %rdx
movq %r9, %rcx
shrq $0x3a, %rcx
rorq %cl, %rdx
cmpq %r8, %rdx
jb 0x28eb
movq %rax, (%rdi)
movq %r9, 0x8(%rdi)
movq %rdx, %rax
xorl %edx, %edx
divq %rsi
movq %rdx, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %esi, %esi
movq %r14, %rdi
negq %rdi
sbbq %rdx, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x2e70
movq %rax, %r12
movq %rdx, %r13
movq %r15, %rdi
callq 0x2a93
cmpq %r12, %rax
movq %rdx, %rcx
sbbq %r13, %rcx
jb 0x2b0c
movq %rax, %rdi
movq %rdx, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x2e70
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/pyk[P]simple-nn/deps/pcg/src/pcg-advance-128.c
// Function: pcg_advance_lcg_128
pcg128_t pcg_advance_lcg_128(pcg128_t state, pcg128_t delta, pcg128_t cur_mult,
                             pcg128_t cur_plus)
{
    pcg128_t acc_mult = 1u;
    pcg128_t acc_plus = 0u;
    while (delta > 0) {
        if (delta & 1) {
            acc_mult *= cur_mult;
            acc_plus = acc_plus * cur_mult + cur_plus;
        }
        cur_plus = (cur_mult + 1) * cur_plus;
        cur_mult *= cur_mult;
        delta /= 2;
    }
    return acc_mult * state + acc_plus;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r9, %r15
movq %r8, %r11
movq %rdx, %r8
movq %rdi, -0x8(%rsp)
movq 0x40(%rsp), %rbp
movq 0x38(%rsp), %r13
movabsq $0x1, %rbx
xorl %edi, %edi
xorl %r10d, %r10d
xorl %r12d, %r12d
movq %r8, %rax
orq %rcx, %rax
je 0x2c39
testb $0x1, %r8b
je 0x2bf1
movq %rbx, %rax
mulq %r11
movq %rax, %r14
imulq %r15, %rbx
addq %rdx, %rbx
imulq %r11, %rdi
movq %r10, %rax
mulq %r11
addq %rbx, %rdi
imulq %r15, %r10
addq %rdx, %r10
imulq %r11, %r12
addq %r10, %r12
addq %r13, %rax
adcq %rbp, %r12
movq %r14, %rbx
movq %rax, %r10
movq %r11, %rax
addq $0x1, %rax
movq %r15, %r9
adcq $0x0, %r9
imulq %rax, %rbp
mulq %r13
addq %rbp, %rdx
imulq %r13, %r9
addq %rdx, %r9
imulq %r11, %r15
movq %rax, %r14
movq %r11, %rax
mulq %r11
addq %r15, %rdx
addq %rdx, %r15
shrdq $0x1, %rcx, %r8
shrq %rcx
movq %r14, %r13
movq %r9, %rbp
movq %rax, %r11
jmp 0x2ba8
imulq %rbx, %rsi
movq %rbx, %rax
movq -0x8(%rsp), %rcx
mulq %rcx
addq %rsi, %rdx
imulq %rcx, %rdi
addq %rdi, %rdx
addq %r10, %rax
adcq %r12, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/pyk[P]simple-nn/deps/pcg/src/../include/pcg_variants.h
// Function: pcg_output_xsl_rr_rr_64_64
inline uint64_t pcg_output_xsl_rr_rr_64_64(uint64_t state)
{
    uint32_t rot1 = (uint32_t)(state >> 59u);
    uint32_t high = (uint32_t)(state >> 32u);
    uint32_t low  = (uint32_t)state;
    uint32_t xored = high ^ low;
    uint32_t newlow  = pcg_rotr_32(xored, rot1);
    uint32_t newhigh = pcg_rotr_32(high, newlow & 31u);
    return (((uint64_t)newhigh) << 32u) | newlow;
}

// Assembly:
movq %rdi, %rcx
shrq $0x3b, %rcx
movq %rdi, %rax
shrq $0x20, %rax
xorl %eax, %edi
rorl %cl, %edi
movl %edi, %ecx
rorl %cl, %eax
shlq $0x20, %rax
orq %rdi, %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0x4(%rsp), %rax
movl %edi, (%rax)
xorl %r14d, %r14d
movq %rax, %rdi
xorl %esi, %esi
callq 0x6d55
cmpq $0x4, %rax
ja 0x6d4a
movl 0x4(%rsp), %ecx
movq %rax, %rdx
decq %rdx
movq %rdx, %rsi
subq $0x1, %rsi
jb 0x6d2c
movl %ecx, %edi
andb $0x3f, %dil
orb $-0x80, %dil
movb %dil, (%rbx,%rdx)
shrl $0x6, %ecx
movq %rsi, %rdx
jmp 0x6d10
leaq 0x9721(%rip), %rdx      # 0x10454
leaq 0x971f(%rip), %rsi      # 0x10459
movzbl (%rax,%rsi), %esi
notl %esi
andl %esi, %ecx
orb (%rax,%rdx), %cl
movb %cl, (%rbx)
movq %rax, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
leaq 0x9704(%rip), %rax      # 0x10460
movl (%rdi), %ecx
cmpl %ecx, (%rax,%rsi,4)
jbe 0x6d70
movl $0xfffd, (%rdi)         # imm = 0xFFFD
movl $0xfffd, %ecx           # imm = 0xFFFD
jmp 0x6d8a
movl %ecx, %eax
andl $0xfffff800, %eax       # imm = 0xFFFFF800
cmpl $0xd800, %eax           # imm = 0xD800
je 0x6d63
leaq 0x96fb(%rip), %rax      # 0x10480
cmpl (%rax,%rsi,4), %ecx
ja 0x6d63
xorl %eax, %eax
leaq 0x96ed(%rip), %rdx      # 0x10480
movq %rax, %rsi
incq %rax
cmpl 0x4(%rdx,%rsi,4), %ecx
ja 0x6d93
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movl %edx, %ebx
movl %esi, %ebp
movl %edi, %r14d
callq 0x6e36
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x11649(%rip)     # 0x18420
movl 0x15547(%rip), %eax     # 0x1c324
shrl $0x2, %eax
andl $0x1, %eax
movl %eax, 0x11663(%rip)     # 0x1844c
movl %ebx, 0x11639(%rip)     # 0x18428
movl %r14d, 0x11646(%rip)    # 0x1843c
movl %r14d, 0x11647(%rip)    # 0x18444
movl %ebp, 0x1163d(%rip)     # 0x18440
movl %ebp, 0x1163f(%rip)     # 0x18448
callq 0x6e5f
cmpl $0x0, 0x11613(%rip)     # 0x18428
je 0x6e21
movl $0x2, 0x115ff(%rip)     # 0x18420
movl 0x11609(%rip), %edi     # 0x18430
movl 0x1160b(%rip), %esi     # 0x18438
popq %rbx
popq %r14
popq %rbp
jmp 0x6f57
// File: /workspace/github_c_makefile_star2_O2/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:
cmpl $-0x1, 0x115ff(%rip)    # 0x1843c
je 0x6e5e
andl $0x0, 0x115da(%rip)     # 0x18420
orl $-0x1, 0x115ef(%rip)    # 0x1843c
movl 0x115dd(%rip), %edi     # 0x18430
movl 0x115df(%rip), %esi     # 0x18438
jmp 0x6f57
retq
// File: /workspace/github_c_makefile_star2_O2/odknt[P]st/st.c
// Function: selnormalize
void
selnormalize(void)
{
	int i;

	if (sel.type == SEL_REGULAR && sel.ob.y != sel.oe.y) {
		sel.nb.x = sel.ob.y < sel.oe.y ? sel.ob.x : sel.oe.x;
		sel.ne.x = sel.ob.y < sel.oe.y ? sel.oe.x : sel.ob.x;
	} else {
		sel.nb.x = MIN(sel.ob.x, sel.oe.x);
		sel.ne.x = MAX(sel.ob.x, sel.oe.x);
	}
	sel.nb.y = MIN(sel.ob.y, sel.oe.y);
	sel.ne.y = MAX(sel.ob.y, sel.oe.y);

	selsnap(&sel.nb.x, &sel.nb.y, -1);
	selsnap(&sel.ne.x, &sel.ne.y, +1);

	/* expand selection over line breaks */
	if (sel.type == SEL_RECTANGULAR)
		return;
	i = tlinelen(sel.nb.y);
	if (i < sel.nb.x)
		sel.nb.x = i;
	if (tlinelen(sel.ne.y) <= sel.ne.x)
		sel.ne.x = term.col - 1;
}

// Assembly:
cmpl $0x1, 0x115be(%rip)     # 0x18424
setne %dl
movl 0x115d1(%rip), %eax     # 0x18440
movl 0x115d3(%rip), %ecx     # 0x18448
cmpl %ecx, %eax
sete %sil
orb %dl, %sil
je 0x6e9e
movl 0x115b6(%rip), %esi     # 0x1843c
movl 0x115b8(%rip), %edx     # 0x18444
cmpl %edx, %esi
movl %edx, %edi
cmovll %esi, %edi
movl %edi, 0x11593(%rip)     # 0x1842c
cmovgl %esi, %edx
jmp 0x6eba
cmpl %ecx, %eax
movl 0x11596(%rip), %edx     # 0x1843c
movl 0x11598(%rip), %esi     # 0x18444
movl %esi, %edi
cmovll %edx, %edi
movl %edi, 0x11575(%rip)     # 0x1842c
cmovll %esi, %edx
pushq %r14
pushq %rbx
pushq %rax
movl %edx, 0x11570(%rip)     # 0x18434
leaq 0x11569(%rip), %rbx     # 0x18434
cmpl %ecx, %eax
movl %ecx, %edx
cmovll %eax, %edx
movl %edx, 0x11558(%rip)     # 0x18430
leaq 0x11551(%rip), %rsi     # 0x18430
cmovgl %eax, %ecx
movl %ecx, 0x11550(%rip)     # 0x18438
leaq 0x11549(%rip), %r14     # 0x18438
leaq 0x11536(%rip), %rdi     # 0x1842c
pushq $-0x1
popq %rdx
callq 0x8c41
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8c41
cmpl $0x2, 0x11511(%rip)     # 0x18424
je 0x6f4f
movl 0x11515(%rip), %edi     # 0x18430
callq 0x7303
cmpl 0x11506(%rip), %eax     # 0x1842c
jge 0x6f2e
movl %eax, 0x114fe(%rip)     # 0x1842c
movl 0x11504(%rip), %edi     # 0x18438
callq 0x7303
cmpl 0x114f5(%rip), %eax     # 0x18434
jg 0x6f4f
movl 0x1150d(%rip), %eax     # 0x18454
decl %eax
movl %eax, 0x114e5(%rip)     # 0x18434
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
testl %edi, %edi
js 0x6f6c
movl 0x114ef(%rip), %eax     # 0x18450
decl %eax
cmpl %edi, %eax
cmovgel %edi, %eax
cltq
jmp 0x6f6e
xorl %eax, %eax
testl %esi, %esi
js 0x6f84
movl 0x114d8(%rip), %ecx     # 0x18450
decl %ecx
cmpl %esi, %ecx
cmovgel %esi, %ecx
movslq %ecx, %rcx
jmp 0x6f86
xorl %ecx, %ecx
movq 0x15363(%rip), %rdx     # 0x1c2f0
cmpq %rcx, %rax
jg 0x6f9e
movl $0x1, (%rdx,%rax,4)
incq %rax
jmp 0x6f8d
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl 0x1146f(%rip), %eax     # 0x18420
testl %eax, %eax
je 0x7072
movl %ecx, %ebx
testl %ecx, %ecx
sete %cl
cmpl $0x1, %eax
setne %al
orb %cl, %al
jne 0x6fdb
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x6e36
movl %edx, %ebp
movl 0x1144c(%rip), %r14d    # 0x18430
movl 0x1144d(%rip), %r15d    # 0x18438
movl 0x11432(%rip), %r12d    # 0x18424
movsd 0x1144a(%rip), %xmm0    # 0x18444
movaps %xmm0, (%rsp)
movl %edi, 0x11440(%rip)     # 0x18444
movl %esi, 0x1143e(%rip)     # 0x18448
callq 0x6e5f
movl %ebp, 0x1140f(%rip)     # 0x18424
movq 0x11427(%rip), %xmm0    # 0x18444
pcmpeqd (%rsp), %xmm0
pshufd $0x50, %xmm0, %xmm0     # xmm0 = xmm0[0,0,1,1]
movmskpd %xmm0, %eax
cmpl $0x3, %eax
jne 0x703e
cmpl %ebp, %r12d
jne 0x703e
cmpl $0x1, 0x113e4(%rip)     # 0x18420
jne 0x7063
movl 0x113ec(%rip), %eax     # 0x18430
cmpl %r14d, %eax
cmovll %eax, %r14d
movl 0x113e7(%rip), %eax     # 0x18438
cmpl %r15d, %eax
cmovgl %eax, %r15d
movl %r14d, %edi
movl %r15d, %esi
callq 0x6f57
xorl %eax, %eax
testl %ebx, %ebx
sete %al
addl %eax, %eax
movl %eax, 0x113ae(%rip)     # 0x18420
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %eax, %eax
cmpl $0x1, 0x11398(%rip)     # 0x18420
je 0x70f5
cmpl $-0x1, 0x113ab(%rip)    # 0x1843c
je 0x70f5
movl 0x113b3(%rip), %eax     # 0x1844c
btl $0x2, 0x15283(%rip)     # 0x1c324
sbbl $0x0, %eax
jne 0x70f3
movl 0x11384(%rip), %ecx     # 0x18430
cmpl %esi, %ecx
setg %r8b
movl 0x11380(%rip), %eax     # 0x18438
cmpl %esi, %eax
setl %dl
orb %r8b, %dl
cmpl $0x2, 0x1135d(%rip)     # 0x18424
jne 0x70e3
testb %dl, %dl
jne 0x70f3
cmpl %edi, 0x11359(%rip)     # 0x1842c
setle %cl
cmpl %edi, 0x11358(%rip)     # 0x18434
setge %al
andb %cl, %al
jmp 0x70f5
testb %dl, %dl
jne 0x70f3
cmpl %esi, %ecx
jne 0x70f9
cmpl %edi, 0x1133b(%rip)     # 0x1842c
jle 0x70f9
xorl %eax, %eax
movzbl %al, %eax
retq
cmpl %esi, %eax
setne %cl
cmpl %edi, 0x11330(%rip)     # 0x18434
setge %al
orb %cl, %al
jmp 0x70f5
// File: /workspace/github_c_makefile_star2_O2/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:
movl 0x1114b(%rip), %ecx     # 0x18454
movslq %ecx, %r10
movl 0x14fda(%rip), %esi     # 0x1c2ec
movl %edi, %r9d
leaq 0x11134(%rip), %r8      # 0x18450
subl %esi, %r9d
jge 0x7346
movl 0x14fc1(%rip), %eax     # 0x1c2e8
addl %r9d, %eax
addl $0x7d1, %eax            # imm = 0x7D1
movl $0x7d0, %r11d           # imm = 0x7D0
cltd
idivl %r11d
movslq %edx, %rax
leaq (%r8,%rax,8), %rax
addq $0x18, %rax
jmp 0x7354
movslq %r9d, %rax
shlq $0x3, %rax
addq 0x11104(%rip), %rax     # 0x18458
movq (%rax), %rax
shlq $0x4, %r10
testb $0x1, -0xb(%rax,%r10)
jne 0x73b8
movslq %r9d, %r10
shlq $0x3, %r10
addq 0x110e7(%rip), %r10     # 0x18458
movl 0x14f71(%rip), %eax     # 0x1c2e8
addl %r9d, %eax
addl $0x7d1, %eax            # imm = 0x7D1
movl $0x7d0, %r9d            # imm = 0x7D0
cltd
idivl %r9d
cmpl %esi, %edi
movslq %edx, %rax
leaq 0x18(%r8,%rax,8), %rax
cmovgeq %r10, %rax
movl %ecx, %edx
sarl $0x1f, %edx
andl %ecx, %edx
testl %ecx, %ecx
jle 0x73b6
movq (%rax), %rsi
movl %ecx, %edi
shlq $0x4, %rdi
cmpl $0x20, -0x10(%rsi,%rdi)
jne 0x73b8
decl %ecx
jmp 0x739e
movl %edx, %ecx
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x10, %rsp
movl 0x14b0f(%rip), %edi     # 0x1c358
leaq 0xc(%rsp), %rsi
pushq $0x1
popq %rdx
callq 0x6650
movl 0x14afc(%rip), %ebx     # 0x1c358
testl %eax, %eax
js 0x78ce
cmpl %eax, %ebx
je 0x786a
addq $0x10, %rsp
popq %rbx
retq
movl 0x14ae4(%rip), %edi     # 0x1c354
callq 0x60f0
xorl %ebx, %ebx
movslq 0x14ad2(%rip), %rax     # 0x1c350
movq 0x14ac3(%rip), %rdi     # 0x1c348
cmpq %rax, %rbx
jge 0x7894
xorl %eax, %eax
callq *(%rdi,%rbx,8)
incq %rbx
jmp 0x7877
callq 0x63d0
movl 0xc(%rsp), %edx
movl %edx, %esi
andl $0x7f, %esi
jne 0x78ed
shrl $0x8, %edx
andl $0xff, %edx
je 0x78c7
movq 0xf73a(%rip), %rax      # 0x16ff0
movq (%rax), %rdi
leaq 0x8f02(%rip), %rsi      # 0x107c2
xorl %eax, %eax
callq 0x69d0
xorl %edi, %edi
callq 0x6280
callq 0x66e0
movl (%rax), %edi
callq 0x6570
leaq 0x8ec1(%rip), %rdi      # 0x107a2
movl %ebx, %esi
movq %rax, %rdx
xorl %eax, %eax
callq 0x6bf6
movl %esi, %eax
shll $0x18, %eax
addl $0x1000000, %eax        # imm = 0x1000000
cmpl $0x2000000, %eax        # imm = 0x2000000
jl 0x78c7
leaq 0x8eda(%rip), %rdi      # 0x107df
xorl %eax, %eax
callq 0x6bf6
// File: /workspace/github_c_makefile_star2_O2/odknt[P]st/st.c
// Function: ttyread
size_t
ttyread(void)
{
	static char buf[BUFSIZ];
	static int buflen = 0;
	int ret, written;

	/* append read bytes to unprocessed bytes */
	ret = read(cmdfd, buf+buflen, LEN(buf)-buflen);

	switch (ret) {
	case 0:
		exit(0);
	case -1:
		die("couldn't read from shell: %s\n", strerror(errno));
	default:
		buflen += ret;
		written = twrite(buf, buflen, 0);
		buflen -= written;
		/* keep any incomplete UTF-8 byte sequence for the next call */
		if (buflen > 0)
			memmove(buf, buf + written, buflen);
		if (term.scr > 0 && term.scr < HISTSIZE-1)
			term.scr++;
		return ret;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl 0x14a3e(%rip), %edi     # 0x1c354
movslq 0x16a43(%rip), %rax     # 0x1e360
leaq 0x14a3c(%rip), %rsi     # 0x1c360
addq %rax, %rsi
movl $0x2000, %edx           # imm = 0x2000
subq %rax, %rdx
callq 0x6210
movq %rax, %rbx
cmpl $-0x1, %ebx
je 0x79a7
testl %ebx, %ebx
je 0x79c4
movl 0x16a16(%rip), %esi     # 0x1e360
addl %ebx, %esi
movl %esi, 0x16a0e(%rip)     # 0x1e360
leaq 0x14a07(%rip), %r14     # 0x1c360
movq %r14, %rdi
xorl %edx, %edx
callq 0x79cb
movl 0x169f7(%rip), %ecx     # 0x1e360
subl %eax, %ecx
movl %ecx, 0x169ef(%rip)     # 0x1e360
jle 0x7983
movslq %eax, %rsi
addq %r14, %rsi
movl %ecx, %edx
movq %r14, %rdi
callq 0x6630
movl 0x14963(%rip), %eax     # 0x1c2ec
leal -0x1(%rax), %ecx
cmpl $0x7cd, %ecx            # imm = 0x7CD
ja 0x799c
incl %eax
movl %eax, 0x14950(%rip)     # 0x1c2ec
movslq %ebx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x66e0
movl (%rax), %edi
callq 0x6570
leaq 0x8c7c(%rip), %rdi      # 0x10636
movq %rax, %rsi
xorl %eax, %eax
callq 0x6bf6
xorl %edi, %edi
callq 0x61b0
// File: /workspace/github_c_makefile_star2_O2/odknt[P]st/st.c
// Function: twrite
int
twrite(const char *buf, int buflen, int show_ctrl)
{
	int charsize;
	Rune u;
	int n;

	for (n = 0; n < buflen; n += charsize) {
		if (IS_SET(MODE_UTF8)) {
			/* process a complete utf8 char */
			charsize = utf8decode(buf + n, &u, buflen - n);
			if (charsize == 0)
				break;
		} else {
			u = buf[n] & 0xFF;
			charsize = 1;
		}
		if (show_ctrl && ISCONTROL(u)) {
			if (u & 0x80) {
				u &= 0x7f;
				tputc('^');
				tputc('[');
			} else if (u != '\n' && u != '\r' && u != '\t') {
				u ^= 0x40;
				tputc('^');
			}
		}
		tputc(u);
	}
	return n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r15
xorl %r14d, %r14d
movl %ebp, %eax
subl %r14d, %eax
jle 0x7a9c
movslq %r14d, %rdi
addq %r15, %rdi
testb $0x40, 0x1492c(%rip)    # 0x1c324
jne 0x7a0b
movzbl (%rdi), %r13d
movl %r13d, 0x4(%rsp)
pushq $0x1
popq %rax
movl %eax, %r12d
jmp 0x7a25
movslq %eax, %rdx
leaq 0x4(%rsp), %rsi
callq 0x9084
movq %rax, %r12
testl %r12d, %r12d
je 0x7a9c
movl 0x4(%rsp), %r13d
testl %ebx, %ebx
je 0x7a8c
cmpl $0x20, %r13d
setae %al
cmpl $0x7f, %r13d
setne %cl
movl %r13d, %edx
andl $-0x20, %edx
cmpl $0x80, %edx
setne %dl
andb %cl, %dl
testb %al, %dl
jne 0x7a8c
cmpl $0x80, %r13d
jae 0x7a73
cmpl $0xd, %r13d
ja 0x7a66
movl $0x2600, %eax           # imm = 0x2600
btl %r13d, %eax
jb 0x7a8c
xorl $0x40, %r13d
movl %r13d, 0x4(%rsp)
pushq $0x5e
jmp 0x7a86
andl $0x7f, %r13d
movl %r13d, 0x4(%rsp)
pushq $0x5e
popq %rdi
callq 0x913c
pushq $0x5b
popq %rdi
callq 0x913c
movl %r13d, %edi
callq 0x913c
addl %r12d, %r14d
jmp 0x79e0
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq