LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/LoupVaillant[P]Monocypher-Utils/src/monocypher.c
// Function: crypto_lock_final
void crypto_lock_final(crypto_lock_ctx *ctx, u8 mac[16])
{
    lock_ad_padding(ctx);
    u8 sizes[16]; // Not secret, not wiped
    store64_le(sizes + 0, ctx->ad_size);
    store64_le(sizes + 8, ctx->message_size);
    crypto_poly1305_update(&ctx->poly, zero, ALIGN(ctx->message_size, 16));
    crypto_poly1305_update(&ctx->poly, sizes, 16);
    crypto_poly1305_final (&ctx->poly, mac);
    WIPE_CTX(ctx);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, 0xe8(%rdi)
je 0x6fcb
xorl %edx, %edx
movl %edx, 0xe8(%rbx)
leaq 0x88(%rbx), %rdi
subl 0xd8(%rbx), %edx
andl $0xf, %edx
leaq 0x262a(%rip), %rsi      # 0x95f0
callq 0x1db1
movq 0xd8(%rbx), %rax
movq %rsp, %r15
movq %rax, (%r15)
movq 0xe0(%rbx), %rdx
movq %rdx, 0x8(%r15)
leaq 0x88(%rbx), %r12
negl %edx
andl $0xf, %edx
leaq 0x25fa(%rip), %rsi      # 0x95f0
movq %r12, %rdi
callq 0x1db1
movl $0x10, %edx
movq %r12, %rdi
movq %r15, %rsi
callq 0x1db1
movq %r12, %rdi
movq %r14, %rsi
callq 0x2067
xorl %eax, %eax
movb $0x0, (%rbx,%rax)
incq %rax
cmpq $0xf0, %rax
jne 0x701b
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/LoupVaillant[P]Monocypher-Utils/src/monocypher.c
// Function: crypto_unlock_final
int crypto_unlock_final(crypto_lock_ctx *ctx, const u8 mac[16])
{
    u8 real_mac[16];
    crypto_lock_final(ctx, real_mac);
    int mismatch = crypto_verify16(real_mac, mac);
    WIPE_BUFFER(real_mac);
    return mismatch;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rsp, %r14
movq %r14, %rsi
callq 0x6f8d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x172e
xorl %ecx, %ecx
movb $0x0, (%rsp,%rcx)
incq %rcx
cmpq $0x10, %rcx
jne 0x7093
movq %rax, %rcx
shrq $0x20, %rcx
movl %eax, %edx
orq %rcx, %rdx
decq %rdx
xorl %eax, %eax
btq $0x20, %rdx
adcl $-0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/LoupVaillant[P]Monocypher-Utils/src/monocypher.c
// Function: crypto_lock_aead
void crypto_lock_aead(u8        mac[16],
                      u8       *cipher_text,
                      const u8  key[32],
                      const u8  nonce[24],
                      const u8 *ad        , size_t ad_size,
                      const u8 *plain_text, size_t text_size)
{
    crypto_lock_ctx ctx;
    crypto_lock_init   (&ctx, key, nonce);
    crypto_lock_auth_ad(&ctx, ad, ad_size);
    crypto_lock_update (&ctx, cipher_text, plain_text, text_size);
    crypto_lock_final  (&ctx, mac);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %r9, %r14
movq %r8, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x6e7d
leaq 0x90(%rsp), %rbp
movq %rbp, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1db1
addq %r14, 0x50(%rbp)
movq %r13, %rdi
movq %r12, %rsi
movq 0x130(%rsp), %rdx
movq 0x138(%rsp), %r14
movq %r14, %rcx
callq 0x1ba2
movq %r13, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x6f09
movq %r13, %rdi
movq %rbx, %rsi
callq 0x6f8d
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/LoupVaillant[P]Monocypher-Utils/src/monocypher.c
// Function: crypto_unlock_aead
int crypto_unlock_aead(u8       *plain_text,
                       const u8  key[32],
                       const u8  nonce[24],
                       const u8  mac[16],
                       const u8 *ad         , size_t ad_size,
                       const u8 *cipher_text, size_t text_size)
{
    crypto_unlock_ctx ctx;
    crypto_unlock_init        (&ctx, key, nonce);
    crypto_unlock_auth_ad     (&ctx, ad, ad_size);
    crypto_unlock_auth_message(&ctx, cipher_text, text_size);
    crypto_chacha_ctx chacha_ctx = ctx.chacha; // avoid the wiping...
    if (crypto_unlock_final(&ctx, mac)) {      // ...that occurs here
        WIPE_CTX(&chacha_ctx);
        return -1; // reject forgeries before wasting our time decrypting
    }
    crypto_chacha20_encrypt(&chacha_ctx, plain_text, cipher_text, text_size);
    WIPE_CTX(&chacha_ctx);
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movq %r9, %r13
movq %r8, %rbp
movq %rcx, %r12
movq %rdi, 0x8(%rsp)
movq 0x1c0(%rsp), %r14
leaq 0x98(%rsp), %rbx
movq %rbx, %rdi
callq 0x6e7d
leaq 0x120(%rsp), %r15
movq %r15, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x1db1
addq %r13, 0x50(%r15)
movq 0x1c8(%rsp), %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x6f09
leaq 0x10(%rsp), %rdi
movl $0x88, %edx
movq %rbx, %rsi
callq 0x10b0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x7071
testl %eax, %eax
je 0x71f5
xorl %eax, %eax
movb $0x0, 0x10(%rsp,%rax)
incq %rax
cmpq $0x88, %rax
jne 0x71de
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x721f
leaq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %r14, %rdx
movq %r15, %rcx
callq 0x1ba2
xorl %eax, %eax
xorl %ecx, %ecx
movb $0x0, 0x10(%rsp,%rcx)
incq %rcx
cmpq $0x88, %rcx
jne 0x720e
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/LoupVaillant[P]Monocypher-Utils/src/monocypher.c
// Function: gidx_refresh
static void gidx_refresh(gidx_ctx *ctx)
{
    // seed the begining of the block...
    ctx->b.a[0] = ctx->pass_number;
    ctx->b.a[1] = 0;  // lane number (we have only one)
    ctx->b.a[2] = ctx->slice_number;
    ctx->b.a[3] = ctx->nb_blocks;
    ctx->b.a[4] = ctx->nb_iterations;
    ctx->b.a[5] = 1;  // type: Argon2i
    ctx->b.a[6] = ctx->ctr;
    FOR (i, 7, 128) { ctx->b.a[i] = 0; } // ...then zero the rest out

    // Shuffle the block thus: ctx->b = G((G(ctx->b, zero)), zero)
    // (G "square" function), to get cheap pseudo-random numbers.
    unary_g(&ctx->b);
    unary_g(&ctx->b);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x400(%rdi), %eax
movl 0x404(%rdi), %ecx
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movq %rcx, 0x10(%rdi)
movl 0x408(%rdi), %eax
movq %rax, 0x18(%rdi)
movl 0x40c(%rdi), %eax
movq %rax, 0x20(%rdi)
movq $0x1, 0x28(%rdi)
movl 0x410(%rdi), %eax
movq %rax, 0x30(%rdi)
addq $0x38, %rdi
movl $0x3c8, %edx            # imm = 0x3C8
xorl %esi, %esi
callq 0x1070
movq %rbx, %rdi
callq 0x72ca
movq %rbx, %rdi
popq %rbx
jmp 0x72ca
// File: /workspace/github_c_makefile_star2_O1/LoupVaillant[P]Monocypher-Utils/src/monocypher.c
// Function: unary_g
static void unary_g(block *work_block)
{
    // work_block == R
    block tmp;
    copy_block(&tmp, work_block); // tmp        = R
    g_rounds(work_block);         // work_block = Z
    xor_block(work_block, &tmp);  // work_block = Z ^ R
    wipe_block(&tmp);
}

// Assembly:
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
movq %rdi, %rbx
movq %rsp, %rdi
movl $0x400, %edx            # imm = 0x400
movq %rbx, %rsi
callq 0x10b0
movq %rbx, %rdi
callq 0x7320
xorl %eax, %eax
movq (%rsp,%rax,8), %rcx
xorq %rcx, (%rbx,%rax,8)
incq %rax
cmpq $0x80, %rax
jne 0x72ef
xorl %eax, %eax
movq $0x0, (%rsp,%rax,8)
incq %rax
cmpq $0x80, %rax
jne 0x7304
addq $0x400, %rsp            # imm = 0x400
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/LoupVaillant[P]Monocypher-Utils/src/monocypher.c
// Function: fe_mul_small
static void fe_mul_small(fe h, const fe f, i32 g)
{
    i64 t0 = f[0] * (i64) g;  i64 t1 = f[1] * (i64) g;
    i64 t2 = f[2] * (i64) g;  i64 t3 = f[3] * (i64) g;
    i64 t4 = f[4] * (i64) g;  i64 t5 = f[5] * (i64) g;
    i64 t6 = f[6] * (i64) g;  i64 t7 = f[7] * (i64) g;
    i64 t8 = f[8] * (i64) g;  i64 t9 = f[9] * (i64) g;
    FE_CARRY;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movslq (%rsi), %r13
movl %edx, %ecx
imulq %rcx, %r13
movslq 0x4(%rsi), %r11
imulq %rcx, %r11
movslq 0x8(%rsi), %r10
imulq %rcx, %r10
movslq 0xc(%rsi), %r9
imulq %rcx, %r9
movslq 0x10(%rsi), %rbx
imulq %rcx, %rbx
movslq 0x14(%rsi), %r8
imulq %rcx, %r8
movslq 0x18(%rsi), %r14
imulq %rcx, %r14
movslq 0x1c(%rsi), %rdx
imulq %rcx, %rdx
movslq 0x20(%rsi), %r15
imulq %rcx, %r15
movslq 0x24(%rsi), %rax
imulq %rcx, %rax
movl $0x1000000, %r12d       # imm = 0x1000000
leaq (%rax,%r12), %rsi
movq %rsi, %rcx
sarq $0x19, %rcx
leaq (%rcx,%rcx,8), %rbp
leaq (%rcx,%rbp,2), %rcx
addq %r13, %rcx
movl $0xfe000000, %ebp       # imm = 0xFE000000
andl %ebp, %esi
subl %esi, %eax
leaq (%r11,%r12), %r13
movq %r13, %rsi
sarq $0x19, %rsi
addq %r10, %rsi
andl %ebp, %r13d
subl %r13d, %r11d
leaq (%r9,%r12), %r13
movq %r13, %r10
sarq $0x19, %r10
addq %rbx, %r10
andl %ebp, %r13d
subl %r13d, %r9d
leaq (%r8,%r12), %r13
movq %r13, %rbx
sarq $0x19, %rbx
addq %r14, %rbx
andl %ebp, %r13d
subl %r13d, %r8d
addq %rdx, %r12
movq %r12, %r14
sarq $0x19, %r14
addq %r15, %r14
andl %ebp, %r12d
subl %r12d, %edx
movl $0x2000000, %r12d       # imm = 0x2000000
leaq (%rcx,%r12), %r13
movq %r13, %r15
shrq $0x1a, %r15
addl %r11d, %r15d
movl $0xfc000000, %r11d      # imm = 0xFC000000
andl %r11d, %r13d
subl %r13d, %ecx
leaq (%rsi,%r12), %rbp
movq %rbp, %r13
shrq $0x1a, %r13
addl %r9d, %r13d
andl %r11d, %ebp
subl %ebp, %esi
leaq (%r10,%r12), %rbp
movq %rbp, %r9
shrq $0x1a, %r9
addl %r8d, %r9d
andl %r11d, %ebp
subl %ebp, %r10d
leaq (%rbx,%r12), %rbp
movq %rbp, %r8
shrq $0x1a, %r8
addl %edx, %r8d
andl %r11d, %ebp
subl %ebp, %ebx
addq %r14, %r12
movq %r12, %rdx
shrq $0x1a, %rdx
addl %eax, %edx
andl %r11d, %r12d
subl %r12d, %r14d
movl %ecx, (%rdi)
movl %r15d, 0x4(%rdi)
movl %esi, 0x8(%rdi)
movl %r13d, 0xc(%rdi)
movl %r10d, 0x10(%rdi)
movl %r9d, 0x14(%rdi)
movl %ebx, 0x18(%rdi)
movl %r8d, 0x1c(%rdi)
movl %r14d, 0x20(%rdi)
movl %edx, 0x24(%rdi)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/LoupVaillant[P]Monocypher-Utils/src/monocypher.c
// Function: ge_double
static void ge_double(ge *s, const ge *p, ge *q)
{
    fe_sq (q->X, p->X);
    fe_sq (q->Y, p->Y);
    fe_sq2(q->Z, p->Z);
    fe_add(q->T, p->X, p->Y);
    fe_sq (s->T, q->T);
    fe_add(q->T, q->Y, q->X);
    fe_sub(q->Y, q->Y, q->X);
    fe_sub(q->X, s->T, q->T);
    fe_sub(q->Z, q->Z, q->Y);

    fe_mul(s->X, q->X , q->Z);
    fe_mul(s->Y, q->T , q->Y);
    fe_mul(s->Z, q->Y , q->Z);
    fe_mul(s->T, q->X , q->T);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r14
movq %rdx, %rdi
callq 0x51c2
leaq 0x28(%rbx), %r15
leaq 0x28(%r13), %rbp
movq %r15, %rdi
movq %rbp, %rsi
callq 0x51c2
leaq 0x50(%rbx), %r12
addq $0x50, %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x51c2
movq %r12, %rdi
movq %r12, %rsi
movl $0x2, %edx
callq 0x7e4a
leaq 0x78(%rbx), %r13
movq $-0x28, %rax
movl 0x28(%rbp,%rax), %ecx
addl (%rbp,%rax), %ecx
movl %ecx, 0xa0(%rbx,%rax)
addq $0x4, %rax
jne 0x8010
leaq 0x78(%r14), %rbp
movq %rbp, %rdi
movq %r13, %rsi
callq 0x51c2
xorl %eax, %eax
movl (%rbx,%rax,4), %ecx
addl 0x28(%rbx,%rax,4), %ecx
movl %ecx, 0x78(%rbx,%rax,4)
incq %rax
cmpq $0xa, %rax
jne 0x8036
movl $0xa, %eax
movl -0x28(%rbx,%rax,4), %ecx
subl %ecx, (%rbx,%rax,4)
incq %rax
cmpq $0x14, %rax
jne 0x804f
movl $0x1e, %eax
movl (%r14,%rax,4), %ecx
subl (%rbx,%rax,4), %ecx
movl %ecx, -0x78(%rbx,%rax,4)
incq %rax
cmpq $0x28, %rax
jne 0x8064
movl $0x14, %eax
movl -0x28(%rbx,%rax,4), %ecx
subl %ecx, (%rbx,%rax,4)
incq %rax
cmpq $0x1e, %rax
jne 0x807d
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x4992
leaq 0x28(%r14), %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x4992
addq $0x50, %r14
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x4992
movq %rbp, %rdi
movq %rbx, %rsi
movq %r13, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4992
// File: /workspace/github_c_makefile_star2_O1/LoupVaillant[P]Monocypher-Utils/src/monocypher.c
// Function: modL
static void modL(u8 *r, i64 x[64])
{
    for (unsigned i = 63; i >= 32; i--) {
        i64 carry = 0;
        FOR (j, i-32, i-12) {
            x[j] += carry - 16 * x[i] * L[j - (i - 32)];
            carry = (x[j] + 128) >> 8;
            x[j] -= carry * (1 << 8);
        }
        x[i-12] += carry;
        x[i] = 0;
    }
    i64 carry = 0;
    FOR (i, 0, 32) {
        x[i] += carry - (x[31] >> 4) * L[i];
        carry = x[i] >> 8;
        x[i] &= 255;
    }
    FOR (i, 0, 32) {
        x[i] -= carry * L[i];
    }
    FOR (i, 0, 32) {
        x[i+1] += x[i] >> 8;
        r[i  ]  = x[i] & 255;
    }
}

// Assembly:
leaq 0xf8(%rsi), %rcx
movl $0x3f, %edx
leaq 0x1d65(%rip), %rax      # 0x9e50
leaq -0x20(%rdx), %r8
leaq -0xc(%rdx), %r9
cmpq %r9, %r8
jae 0x8144
xorl %r9d, %r9d
xorl %r8d, %r8d
movq (%rsi,%rdx,8), %r10
imulq (%r9,%rax), %r10
shlq $0x4, %r10
subq %r10, %r8
movq (%rcx,%r9), %r10
leaq (%r8,%r10), %r11
addq %r8, %r10
addq $0x80, %r10
movq %r10, %r8
sarq $0x8, %r8
andq $-0x100, %r10
subq %r10, %r11
movq %r11, (%rcx,%r9)
addq $0x8, %r9
cmpq $0xa0, %r9
jne 0x80fe
jmp 0x8147
xorl %r8d, %r8d
addq %r8, -0x60(%rsi,%rdx,8)
movq $0x0, (%rsi,%rdx,8)
decq %rdx
addq $-0x8, %rcx
cmpq $0x1f, %rdx
ja 0x80eb
xorl %edx, %edx
xorl %ecx, %ecx
movq 0xf8(%rsi), %r8
sarq $0x4, %r8
imulq (%rdx,%rax), %r8
subq %r8, %rcx
addq (%rsi,%rdx), %rcx
movzbl %cl, %r8d
sarq $0x8, %rcx
movq %r8, (%rsi,%rdx)
addq $0x8, %rdx
cmpq $0x100, %rdx            # imm = 0x100
jne 0x8165
xorl %edx, %edx
movq (%rdx,%rax), %r8
imulq %rcx, %r8
subq %r8, (%rsi,%rdx)
addq $0x8, %rdx
cmpq $0x100, %rdx            # imm = 0x100
jne 0x8197
xorl %eax, %eax
movq (%rsi,%rax,8), %rcx
movq %rcx, %rdx
sarq $0x8, %rdx
addq %rdx, 0x8(%rsi,%rax,8)
movb %cl, (%rdi,%rax)
leaq 0x1(%rax), %rcx
movq %rcx, %rax
cmpq $0x20, %rcx
jne 0x81b2
retq
// File: /workspace/github_c_makefile_star2_O1/LoupVaillant[P]Monocypher-Utils/src/monocypher.c
// Function: fe_isnonzero
static int fe_isnonzero(const fe f)
{
    u8 s[32];
    fe_tobytes(s, f);
    u8 isnonzero = zerocmp32(s);
    WIPE_BUFFER(s);
    return isnonzero;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rsi
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x5923
leaq 0x1403(%rip), %rsi      # 0x95f0
movq %rbx, %rdi
callq 0x177f
xorl %ecx, %ecx
movb $0x0, (%rsp,%rcx)
incq %rcx
cmpq $0x20, %rcx
jne 0x81f7
movzbl %al, %eax
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/LoupVaillant[P]Monocypher-Utils/src/monocypher.c
// Function: ge_precompute
static void ge_precompute(ge_cached lut[8], const ge *P1)
{
    ge P2, tmp;
    ge_double(&P2, P1, &tmp);
    ge_cache(&lut[0], P1);
    FOR (i, 0, 7) {
        ge_add(&tmp, &P2, &lut[i]);
        ge_cache(&lut[i+1], &tmp);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x148, %rsp            # imm = 0x148
movq %rsi, %r12
movq %rdi, %rbx
leaq 0xa8(%rsp), %r14
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rdx
callq 0x7fb3
movq %rbx, %rdi
movq %r12, %rsi
callq 0x84fb
movl $0x7, %r12d
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x8326
addq $0xa0, %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x84fb
decq %r12
jne 0x824a
addq $0x148, %rsp            # imm = 0x148
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/LoupVaillant[P]Monocypher-Utils/src/monocypher.c
// Function: slide
static void slide(i8 adds[258], const u8 scalar[32])
{
    FOR (i,   0, 256) { adds[i] = scalar_bit(scalar, i); }
    FOR (i, 256, 258) { adds[i] = 0;                     }
    FOR (i, 0, 254) {
        if (adds[i] != 0) {
            // base value of the 5-bit window
            FOR (j, 1, 5) {
                adds[i  ] |= adds[i+j] << j;
                adds[i+j]  = 0;
            }
            if (adds[i] > 16) {
                // go back to [-15, 15], propagate carry.
                adds[i] -= 32;
                int j = i + 5;
                while (adds[j] != 0) {
                    adds[j] = 0;
                    j++;
                }
                adds[j] = 1;
            }
        }
    }
}

// Assembly:
xorl %eax, %eax
movq %rax, %rcx
shrq $0x3, %rcx
movzbl (%rsi,%rcx), %ecx
movl %eax, %edx
andl $0x7, %edx
btl %edx, %ecx
setb (%rdi,%rax)
incq %rax
cmpq $0x100, %rax            # imm = 0x100
jne 0x8280
movw $0x0, 0x100(%rdi)
leaq 0x5(%rdi), %rax
xorl %edx, %edx
movq %rdi, %rsi
cmpb $0x0, (%rdi,%rdx)
je 0x8313
movb (%rdi,%rdx), %r8b
movl $0x1, %ecx
movzbl (%rsi,%rcx), %r9d
shll %cl, %r9d
orb %r9b, %r8b
movb $0x0, (%rsi,%rcx)
incq %rcx
cmpq $0x5, %rcx
jne 0x82c3
movb %r8b, (%rdi,%rdx)
cmpb $0x10, %r8b
jle 0x8313
addb $-0x20, %r8b
movb %r8b, (%rdi,%rdx)
leal 0x5(%rdx), %ecx
cmpb $0x0, (%rdi,%rcx)
je 0x830d
movq %rax, %r8
movb $0x0, (%r8)
leaq 0x1(%r8), %rcx
cmpb $0x0, 0x1(%r8)
movq %rcx, %r8
jne 0x82f9
jmp 0x8310
addq %rdi, %rcx
movb $0x1, (%rcx)
incq %rdx
incq %rsi
incq %rax
cmpq $0xfe, %rdx
jne 0x82b4
retq
// File: /workspace/github_c_makefile_star2_O1/LoupVaillant[P]Monocypher-Utils/src/monocypher.c
// Function: ge_add
static void ge_add(ge *s, const ge *p, const ge_cached *q)
{
    fe a, b; // not used to process secrets, no need to wipe
    fe_add(a   , p->Y, p->X );
    fe_sub(b   , p->Y, p->X );
    fe_mul(a   , a   , q->Yp);
    fe_mul(b   , b   , q->Ym);
    fe_add(s->Y, a   , b    );
    fe_sub(s->X, a   , b    );

    fe_add(s->Z, p->Z, p->Z );
    fe_mul(s->Z, s->Z, q->Z );
    fe_mul(s->T, p->T, q->T2);
    fe_add(a   , s->Z, s->T );
    fe_sub(b   , s->Z, s->T );

    fe_mul(s->T, s->X, s->Y);
    fe_mul(s->X, s->X, b   );
    fe_mul(s->Y, s->Y, a   );
    fe_mul(s->Z, a   , b   );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
xorl %eax, %eax
movl (%r12,%rax,4), %ecx
addl 0x28(%r12,%rax,4), %ecx
movl %ecx, 0x30(%rsp,%rax,4)
incq %rax
cmpq $0xa, %rax
jne 0x833f
xorl %eax, %eax
movl 0x28(%r12,%rax,4), %ecx
subl (%r12,%rax,4), %ecx
movl %ecx, (%rsp,%rax,4)
incq %rax
cmpq $0xa, %rax
jne 0x8357
leaq 0x30(%rsp), %rdi
movq %rdi, %rsi
movq %r14, %rdx
callq 0x4992
leaq 0x28(%r14), %rdx
movq %rsp, %rdi
movq %rdi, %rsi
callq 0x4992
leaq 0x28(%rbx), %r15
xorl %eax, %eax
movl (%rsp,%rax,4), %ecx
addl 0x30(%rsp,%rax,4), %ecx
movl %ecx, 0x28(%rbx,%rax,4)
incq %rax
cmpq $0xa, %rax
jne 0x8391
xorl %eax, %eax
movl 0x30(%rsp,%rax,4), %ecx
subl (%rsp,%rax,4), %ecx
movl %ecx, (%rbx,%rax,4)
incq %rax
cmpq $0xa, %rax
jne 0x83a7
leaq 0x50(%rbx), %r13
movl $0x14, %eax
movl (%r12,%rax,4), %ecx
addl %ecx, %ecx
movl %ecx, (%rbx,%rax,4)
incq %rax
cmpq $0x1e, %rax
jne 0x83c3
leaq 0x50(%r14), %rdx
movq %r13, %rdi
movq %r13, %rsi
callq 0x4992
leaq 0x78(%rbx), %rbp
addq $0x78, %r12
addq $0x78, %r14
movq %rbp, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x4992
movl $0x14, %eax
movl 0x28(%rbx,%rax,4), %ecx
addl (%rbx,%rax,4), %ecx
movl %ecx, -0x20(%rsp,%rax,4)
incq %rax
cmpq $0x1e, %rax
jne 0x8403
movl $0x14, %eax
movl (%rbx,%rax,4), %ecx
subl 0x28(%rbx,%rax,4), %ecx
movl %ecx, -0x50(%rsp,%rax,4)
incq %rax
cmpq $0x1e, %rax
jne 0x841c
movq %rbp, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x4992
movq %rsp, %r14
movq %rbx, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x4992
leaq 0x30(%rsp), %rbx
movq %r15, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x4992
movq %r13, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x4992
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/LoupVaillant[P]Monocypher-Utils/src/monocypher.c
// Function: ge_cache
static void ge_cache(ge_cached *c, const ge *p)
{
    static const fe D2 = { // - 2 * 121665 / 121666
        -21827239, -5839606, -30745221, 13898782, 229458,
        15978800, -12551817, -6495438, 29715968, 9444199
    };
    fe_add (c->Yp, p->Y, p->X);
    fe_sub (c->Ym, p->Y, p->X);
    fe_copy(c->Z , p->Z      );
    fe_mul (c->T2, p->T, D2  );
}

// Assembly:
xorl %eax, %eax
movl (%rsi,%rax,4), %ecx
addl 0x28(%rsi,%rax,4), %ecx
movl %ecx, (%rdi,%rax,4)
incq %rax
cmpq $0xa, %rax
jne 0x84fd
xorl %eax, %eax
movl 0x28(%rsi,%rax,4), %ecx
subl (%rsi,%rax,4), %ecx
movl %ecx, 0x28(%rdi,%rax,4)
incq %rax
cmpq $0xa, %rax
jne 0x8512
xorl %eax, %eax
movl 0x50(%rsi,%rax,4), %ecx
movl %ecx, 0x50(%rdi,%rax,4)
incq %rax
cmpq $0xa, %rax
jne 0x8528
addq $0x78, %rdi
addq $0x78, %rsi
leaq 0x1ac8(%rip), %rdx      # 0xa010
jmp 0x4992
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/LoupVaillant[P]Monocypher-Utils/src/sha512.c
// Function: crypto_sha512_init
void crypto_sha512_init(crypto_sha512_ctx *ctx)
{
    ctx->hash[0] = 0x6a09e667f3bcc908;
    ctx->hash[1] = 0xbb67ae8584caa73b;
    ctx->hash[2] = 0x3c6ef372fe94f82b;
    ctx->hash[3] = 0xa54ff53a5f1d36f1;
    ctx->hash[4] = 0x510e527fade682d1;
    ctx->hash[5] = 0x9b05688c2b3e6c1f;
    ctx->hash[6] = 0x1f83d9abfb41bd6b;
    ctx->hash[7] = 0x5be0cd19137e2179;
    ctx->input_size[0] = 0;
    ctx->input_size[1] = 0;
    ctx->input_idx = 0;
}

// Assembly:
movabsq $0x6a09e667f3bcc908, %rax # imm = 0x6A09E667F3BCC908
movq %rax, 0x280(%rdi)
movabsq $-0x4498517a7b3558c5, %rax # imm = 0xBB67AE8584CAA73B
movq %rax, 0x288(%rdi)
movabsq $0x3c6ef372fe94f82b, %rax # imm = 0x3C6EF372FE94F82B
movq %rax, 0x290(%rdi)
movabsq $-0x5ab00ac5a0e2c90f, %rax # imm = 0xA54FF53A5F1D36F1
movq %rax, 0x298(%rdi)
movabsq $0x510e527fade682d1, %rax # imm = 0x510E527FADE682D1
movq %rax, 0x2a0(%rdi)
movabsq $-0x64fa9773d4c193e1, %rax # imm = 0x9B05688C2B3E6C1F
movq %rax, 0x2a8(%rdi)
movabsq $0x1f83d9abfb41bd6b, %rax # imm = 0x1F83D9ABFB41BD6B
movq %rax, 0x2b0(%rdi)
movabsq $0x5be0cd19137e2179, %rax # imm = 0x5BE0CD19137E2179
movq %rax, 0x2b8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x340(%rdi)
movq $0x0, 0x350(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/LoupVaillant[P]Monocypher-Utils/src/sha512.c
// Function: crypto_sha512_update
void crypto_sha512_update(crypto_sha512_ctx *ctx,
                          const u8 *message, size_t message_size)
{
    // Align ourselves with block boundaries
    size_t align = MIN(ALIGN(ctx->input_idx, 128), message_size);
    sha512_update(ctx, message, align);
    message      += align;
    message_size -= align;

    // Process the message block by block
    FOR (i, 0, message_size / 128) { // number of blocks
        FOR (j, 0, 16) {
            ctx->input[j] = load64_be(message + j*8);
        }
        message        += 128;
        ctx->input_idx += 128;
        sha512_end_block(ctx);
    }
    message_size &= 127;

    // remaining bytes
    sha512_update(ctx, message, message_size);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
subl 0x350(%rdi), %r12d
andl $0x7f, %r12d
cmpq %rdx, %r12
cmovaeq %rdx, %r12
movq %r12, %rdx
callq 0x868b
addq %r12, %r14
subq %r12, %rbx
cmpq $0x80, %rbx
jb 0x8674
movq %rbx, %r12
shrq $0x7, %r12
cmpq $0x1, %r12
adcq $0x0, %r12
xorl %r13d, %r13d
xorl %eax, %eax
movq (%r14,%rax,8), %rcx
bswapq %rcx
movq %rcx, 0x2c0(%r15,%rax,8)
incq %rax
cmpq $0x10, %rax
jne 0x8640
subq $-0x80, %r14
subq $-0x80, 0x350(%r15)
movq %r15, %rdi
callq 0x872a
incq %r13
cmpq %r12, %r13
jne 0x863e
andl $0x7f, %ebx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x868b
// File: /workspace/github_c_makefile_star2_O1/LoupVaillant[P]Monocypher-Utils/src/sha512.c
// Function: sha512_update
static void sha512_update(crypto_sha512_ctx *ctx,
                          const u8 *message, size_t message_size)
{
    FOR (i, 0, message_size) {
        sha512_set_input(ctx, message[i]);
        ctx->input_idx++;
        sha512_end_block(ctx);
    }
}

// Assembly:
testq %rdx, %rdx
je 0x8729
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x2c0(%rdi), %r12
xorl %r13d, %r13d
movzbl (%r14,%r13), %eax
movq 0x350(%r15), %rdx
testq %rdx, %rdx
jne 0x86f3
xorps %xmm0, %xmm0
movups %xmm0, 0x70(%r12)
movups %xmm0, 0x60(%r12)
movups %xmm0, 0x50(%r12)
movups %xmm0, 0x40(%r12)
movups %xmm0, 0x30(%r12)
movups %xmm0, 0x20(%r12)
movups %xmm0, 0x10(%r12)
movups %xmm0, (%r12)
movl %edx, %ecx
notl %ecx
shll $0x3, %ecx
shlq %cl, %rax
andq $-0x8, %rdx
orq %rax, 0x2c0(%r15,%rdx)
incq 0x350(%r15)
movq %r15, %rdi
callq 0x872a
incq %r13
cmpq %r13, %rbx
jne 0x86b0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/LoupVaillant[P]Monocypher-Utils/src/sha512.c
// Function: sha512_end_block
static void sha512_end_block(crypto_sha512_ctx *ctx)
{
    if (ctx->input_idx == 128) {
        sha512_incr(ctx->input_size, 1024); // size is in bits
        sha512_compress(ctx);
        ctx->input_idx = 0;
    }
}

// Assembly:
cmpq $0x80, 0x350(%rdi)
jne 0x8773
pushq %rbx
movq %rdi, %rbx
movq 0x348(%rdi), %rax
leaq 0x400(%rax), %rcx
movq %rcx, 0x348(%rdi)
cmpq $-0x400, %rax           # imm = 0xFC00
jb 0x875f
incq 0x340(%rbx)
movq %rbx, %rdi
callq 0x887c
movq $0x0, 0x350(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/LoupVaillant[P]Monocypher-Utils/src/sha512.c
// Function: crypto_sha512_final
void crypto_sha512_final(crypto_sha512_ctx *ctx, u8 hash[64])
{
    sha512_incr(ctx->input_size, ctx->input_idx * 8); // size is in bits
    sha512_set_input(ctx, 128);                       // padding

    // compress penultimate block (if any)
    if (ctx->input_idx > 111) {
        sha512_compress(ctx);
        FOR(i, 0, 14) {
            ctx->input[i] = 0;
        }
    }
    // compress last block
    ctx->input[14] = ctx->input_size[0];
    ctx->input[15] = ctx->input_size[1];
    sha512_compress(ctx);

    // copy hash to output (big endian)
    FOR (i, 0, 8) {
        store64_be(hash + i*8, ctx->hash[i]);
    }

    WIPE_CTX(ctx);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x350(%rdi), %rax
leaq (,%rax,8), %rcx
addq %rcx, 0x348(%rdi)
jae 0x879e
incq 0x340(%rbx)
testq %rax, %rax
jne 0x87de
xorps %xmm0, %xmm0
movups %xmm0, 0x330(%rbx)
movups %xmm0, 0x320(%rbx)
movups %xmm0, 0x310(%rbx)
movups %xmm0, 0x300(%rbx)
movups %xmm0, 0x2f0(%rbx)
movups %xmm0, 0x2e0(%rbx)
movups %xmm0, 0x2d0(%rbx)
movups %xmm0, 0x2c0(%rbx)
notb %cl
andb $0x38, %cl
movl $0x80, %edx
shlq %cl, %rdx
andq $-0x8, %rax
orq %rdx, 0x2c0(%rbx,%rax)
cmpq $0x70, 0x350(%rbx)
jb 0x8835
leaq 0x2c0(%rbx), %r15
movq %rbx, %rdi
callq 0x887c
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%r15)
movups %xmm0, 0x50(%r15)
movups %xmm0, 0x40(%r15)
movups %xmm0, 0x30(%r15)
movups %xmm0, 0x20(%r15)
movups %xmm0, 0x10(%r15)
movups %xmm0, (%r15)
movups 0x340(%rbx), %xmm0
movups %xmm0, 0x330(%rbx)
movq %rbx, %rdi
callq 0x887c
xorl %eax, %eax
movq 0x280(%rbx,%rax,8), %rcx
bswapq %rcx
movq %rcx, (%r14,%rax,8)
incq %rax
cmpq $0x8, %rax
jne 0x884d
xorl %eax, %eax
movb $0x0, (%rbx,%rax)
incq %rax
cmpq $0x358, %rax            # imm = 0x358
jne 0x8867
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/LoupVaillant[P]Monocypher-Utils/src/sha512.c
// Function: crypto_sha512
void crypto_sha512(u8 *hash, const u8 *message, size_t message_size)
{
    crypto_sha512_ctx ctx;
    crypto_sha512_init  (&ctx);
    crypto_sha512_update(&ctx, message, message_size);
    crypto_sha512_final (&ctx, hash);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x358, %rsp            # imm = 0x358
movq %rdi, %rbx
movabsq $0x6a09e667f3bcc908, %rax # imm = 0x6A09E667F3BCC908
movq %rsp, %r14
movq %rax, 0x280(%r14)
movabsq $-0x4498517a7b3558c5, %rax # imm = 0xBB67AE8584CAA73B
movq %rax, 0x288(%r14)
movabsq $0x3c6ef372fe94f82b, %rax # imm = 0x3C6EF372FE94F82B
movq %rax, 0x290(%r14)
movabsq $-0x5ab00ac5a0e2c90f, %rax # imm = 0xA54FF53A5F1D36F1
movq %rax, 0x298(%r14)
movabsq $0x510e527fade682d1, %rax # imm = 0x510E527FADE682D1
movq %rax, 0x2a0(%r14)
movabsq $-0x64fa9773d4c193e1, %rax # imm = 0x9B05688C2B3E6C1F
movq %rax, 0x2a8(%r14)
movabsq $0x1f83d9abfb41bd6b, %rax # imm = 0x1F83D9ABFB41BD6B
movq %rax, 0x2b0(%r14)
movabsq $0x5be0cd19137e2179, %rax # imm = 0x5BE0CD19137E2179
movq %rax, 0x2b8(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x340(%r14)
movq $0x0, 0x350(%r14)
movq %r14, %rdi
callq 0x85ee
movq %r14, %rdi
movq %rbx, %rsi
callq 0x8774
addq $0x358, %rsp            # imm = 0x358
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O1/LoupVaillant[P]Monocypher-Utils/src/getopt.c
// Function: getopt_next
int getopt_next(getopt_ctx *ctx)
{
    if (ctx->char_idx == 0) {
        int    idx  = ctx->argv_idx;
        char **argv = ctx->argv;
        // Search argv for the next option
        while (idx < ctx->argc &&
               (argv[idx][0] != '-' || is_dash(ctx, idx))) {
            idx++;
        }
        // No more arguments
        if (idx == ctx->argc) {
            return -1;
        }
        // End of options marker found.  No more options, Get rid of it.
        if (is_double_dash(ctx, idx)) {
            forget_argument(ctx, idx);
            return -1;
        }
        // Remember where the argument is stored
        ctx->argv_idx = idx;
    }
    // Point to the current option
    ctx->char_idx++;

    // Option has been found
    char* option_string  = ctx->argv[ctx->argv_idx] + ctx->char_idx;
    char  current_option = option_string[0];
    int   is_last        = option_string[1] == 0;
    if (is_last) {
        forget_argument(ctx, ctx->argv_idx);
    }
    return current_option;
}

// Assembly:
pushq %rbx
cmpl $0x0, 0x10(%rdi)
jne 0x8bb4
movl 0x14(%rdi), %esi
movq 0x8(%rdi), %rax
movl (%rdi), %ecx
cmpl %ecx, %esi
jge 0x8b90
movslq %esi, %rdx
leaq (%rax,%rdx,8), %rdx
movq (%rdx), %r8
cmpb $0x2d, (%r8)
jne 0x8b84
cmpb $0x0, 0x1(%r8)
jne 0x8b90
incl %esi
addq $0x8, %rdx
cmpl %esi, %ecx
jne 0x8b74
movl %ecx, %esi
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpl %ecx, %esi
je 0x8bdc
movslq %esi, %rcx
movq (%rax,%rcx,8), %rax
cmpb $0x2d, (%rax)
jne 0x8bb1
cmpb $0x2d, 0x1(%rax)
jne 0x8bb1
cmpb $0x0, 0x2(%rax)
je 0x8bd7
movl %esi, 0x14(%rdi)
movslq 0x10(%rdi), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x10(%rdi)
movq 0x8(%rdi), %rcx
movslq 0x14(%rdi), %rsi
movq (%rcx,%rsi,8), %rcx
movsbl 0x1(%rcx,%rax), %ebx
cmpb $0x0, 0x2(%rcx,%rax)
jne 0x8bdc
callq 0x8be0
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/LoupVaillant[P]Monocypher-Utils/src/getopt.c
// Function: forget_argument
static void forget_argument(getopt_ctx *ctx, int idx)
{
    char *tmp = ctx->argv[idx];
    while (idx > 0) {
        ctx->argv[idx] = ctx->argv[idx-1];
        idx--;
    }
    ctx->argv[0]  = tmp;
    ctx->char_idx = 0;  // point to the begining of the next argument
    ctx->argv++;
    ctx->argc--;
}

// Assembly:
movq 0x8(%rdi), %rax
movslq %esi, %rcx
movq (%rax,%rcx,8), %rax
testl %ecx, %ecx
jle 0x8c0b
movl %esi, %ecx
incq %rcx
movq 0x8(%rdi), %rdx
movq -0x10(%rdx,%rcx,8), %rsi
movq %rsi, -0x8(%rdx,%rcx,8)
decq %rcx
cmpq $0x1, %rcx
jg 0x8bf4
movq 0x8(%rdi), %rcx
movq %rax, (%rcx)
movl $0x0, 0x10(%rdi)
addq $0x8, 0x8(%rdi)
decl (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/LoupVaillant[P]Monocypher-Utils/src/getopt.c
// Function: getopt_parameter
char* getopt_parameter(getopt_ctx *ctx)
{
    int idx = ctx->argv_idx;
    if (idx >= ctx->argc || is_double_dash(ctx, idx)) {
        return 0; // missing option parameter
    }
    int   char_idx = ctx->char_idx == 0 ? 0 : ctx->char_idx + 1;
    char *argument = ctx->argv[idx] + char_idx;
    forget_argument(ctx, idx);
    return argument;
}

// Assembly:
pushq %rbx
movslq 0x14(%rdi), %rsi
cmpl (%rdi), %esi
jge 0x8c5b
movq 0x8(%rdi), %rax
movq (%rax,%rsi,8), %rbx
cmpb $0x2d, (%rbx)
jne 0x8c43
cmpb $0x2d, 0x1(%rbx)
jne 0x8c43
cmpb $0x0, 0x2(%rbx)
je 0x8c5b
movl 0x10(%rdi), %eax
leal 0x1(%rax), %ecx
testl %eax, %eax
cmovel %eax, %ecx
movslq %ecx, %rax
addq %rax, %rbx
callq 0x8be0
jmp 0x8c5d
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O1/LoupVaillant[P]Monocypher-Utils/src/utils.c
// Function: alloc
void* alloc(size_t size)
{
    if (size == 0) { return 0; } // for portability
    void *buf = malloc(size);
    if (buf == NULL) {
        fprintf(stderr, "Failed to allocate 0x%zx bytes\n", size);
        panic("Out of memory.");
    }
    return buf;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x8c7f
movq %rdi, %rbx
callq 0x10c0
testq %rax, %rax
jne 0x8c81
movq %rbx, %rdi
callq 0x1100
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/LoupVaillant[P]Monocypher-Utils/src/utils.c
// Function: random_bytes
void random_bytes(uint8_t *buffer, size_t buffer_size)
{
    if (buffer_size > 256 ) {
        panic("Requested too many random bytes (<= 256)");
    }
    if (syscall(SYS_getrandom, buffer, buffer_size, 0) != (int)buffer_size) {
        fprintf(stderr, "Failed to provide %zu random bytes", buffer_size);
        panic("");
    }
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
cmpq $0x101, %rsi            # imm = 0x101
jae 0x8cbb
movq %rdi, %rsi
movl $0x13e, %edi            # imm = 0x13E
movq %rbx, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x10a0
cmpq %rbx, %rax
jne 0x8cc0
popq %rbx
retq
callq 0x1160
movq %rbx, %rdi
callq 0x1130
// File: /workspace/github_c_makefile_star2_O1/LoupVaillant[P]Monocypher-Utils/src/utils.c
// Function: int_of_string
int int_of_string(const char *s)
{
    int i = 0;
    if ( s == 0   ) return -1; // NULL  string
    if (*s == '\0') return -2; // empty string
    while (*s != 0) {
        if (!is_between(*s, '0', '9')            ) return -2; // not a number
        if (i > (INT_MAX - int_of_digit(*s)) / 10) return -3; // too big for int
        i = (10 * i) + int_of_digit(*s);
        s++;
    }
    return i;
}

// Assembly:
testq %rdi, %rdi
je 0x8d63
cmpb $0x0, (%rdi)
je 0x8d69
movb (%rdi), %dl
testb %dl, %dl
je 0x8d6f
incq %rdi
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
leal -0x3a(%rdx), %esi
cmpb $-0xa, %sil
jb 0x8d69
movzbl %dl, %edx
addl $-0x30, %edx
cmpb $-0xa, %sil
cmovbl %ecx, %edx
movl %edx, %esi
xorl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
imulq $0x66666667, %rsi, %rsi # imm = 0x66666667
shrq $0x22, %rsi
cmpl %esi, %eax
jg 0x8d72
leal (%rax,%rax,4), %eax
leal (%rdx,%rax,2), %eax
movb (%rdi), %dl
incq %rdi
testb %dl, %dl
jne 0x8d26
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
retq
xorl %eax, %eax
retq
movl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
retq
// File: /workspace/github_c_makefile_star2_O1/LoupVaillant[P]Monocypher-Utils/src/utils.c
// Function: read_buffer
int read_buffer(uint8_t *out, size_t max_size, const char *hex)
{
    size_t hex_size = string_length(hex);
    size_t buf_size = hex_size / 2;
    if (hex ==  0          ) return -1;
    if (hex_size > max_size) return -2;
    if (hex_size % 2 !=   0) return -3;
    for (size_t i = 0; i < hex_size; i += 2) {
        int msb = int_of_hex(hex[i  ]);
        int lsb = int_of_hex(hex[i+1]);
        if (msb == -1 || lsb == -1) return -4;
        out[i/2] = lsb + (msb << 4);
    }
    return buf_size;
}

// Assembly:
testq %rdx, %rdx
je 0x8dd4
cmpb $0x0, (%rdx)
je 0x8ddb
xorl %eax, %eax
leaq 0x1(%rax), %rcx
cmpb $0x0, 0x1(%rdx,%rax)
movq %rcx, %rax
jne 0x8dc4
jmp 0x8ddd
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
jmp 0x8ddd
xorl %ecx, %ecx
testq %rdx, %rdx
je 0x8ecf
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
cmpq %rsi, %rcx
ja 0x8ed4
movl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
testb $0x1, %cl
jne 0x8ed4
pushq %rbx
movq %rcx, %rsi
shrq %rsi
testq %rcx, %rcx
setne %r8b
je 0x8ec1
xorl %eax, %eax
movl $0xffffffff, %r9d       # imm = 0xFFFFFFFF
movzbl (%rdx,%rax), %r10d
leal -0x3a(%r10), %r11d
cmpb $-0xa, %r11b
jae 0x8e50
leal -0x67(%r10), %r11d
cmpb $-0x6, %r11b
jae 0x8e56
movl %r10d, %r11d
addb $-0x47, %r11b
movsbl %r10b, %r10d
addl $-0x41, %r10d
cmpb $-0x6, %r11b
cmovbl %r9d, %r10d
jmp 0x8e5a
addl $-0x30, %r10d
jmp 0x8e5a
addl $-0x61, %r10d
movzbl 0x1(%rdx,%rax), %r11d
leal -0x3a(%r11), %ebx
cmpb $-0xa, %bl
jae 0x8e89
leal -0x67(%r11), %ebx
cmpb $-0x6, %bl
jae 0x8e8f
movl %r11d, %ebx
addb $-0x47, %bl
movsbl %r11b, %r11d
addl $-0x41, %r11d
cmpb $-0x6, %bl
cmovbl %r9d, %r11d
jmp 0x8e93
addl $-0x30, %r11d
jmp 0x8e93
addl $-0x61, %r11d
cmpl $-0x1, %r10d
je 0x8ec1
cmpl $-0x1, %r11d
je 0x8ec1
shll $0x4, %r10d
addl %r10d, %r11d
movq %rax, %r8
shrq %r8
movb %r11b, (%rdi,%r8)
addq $0x2, %rax
cmpq %rcx, %rax
setb %r8b
jb 0x8e1e
testb $0x1, %r8b
movl $0xfffffffc, %eax       # imm = 0xFFFFFFFC
cmovel %esi, %eax
popq %rbx
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O1/LoupVaillant[P]Monocypher-Utils/src/utils.c
// Function: read_vector
int read_vector(vector *v, const char *hex)
{
    v->size   = string_length(hex) / 2;
    v->buffer = alloc(v->size);
    int error = read_buffer(v->buffer, INT_MAX, hex);
    if (error < 1) {
        free_vector(v);
        return error;
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
je 0x8f05
cmpb $0x0, (%r14)
je 0x8f0c
xorl %edi, %edi
cmpb $0x0, 0x1(%r14,%rdi)
leaq 0x1(%rdi), %rdi
jne 0x8ef4
shrq %rdi
jmp 0x8f0e
movl $0x7fffffff, %edi       # imm = 0x7FFFFFFF
jmp 0x8f0e
xorl %edi, %edi
movq %rdi, 0x8(%rbx)
callq 0x8c64
movq %rax, %r15
movq %rax, (%rbx)
movl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
movq %rax, %rdi
movq %r14, %rdx
callq 0x8db8
movl %eax, %ebp
xorl %eax, %eax
testl %ebp, %ebp
jg 0x8f53
testq %r15, %r15
je 0x8f49
movq %r15, %rdi
callq 0x1030
movq $0x0, (%rbx)
movq $0x0, 0x8(%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/LoupVaillant[P]Monocypher-Utils/src/utils.c
// Function: free_vector
void free_vector(vector *v)
{
    if (v->buffer != 0) {
        free(v->buffer);
        v->buffer = 0;
    }
    v->size = 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x8f76
callq 0x1030
movq $0x0, (%rbx)
movq $0x0, 0x8(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/impact-eintr[P]st/st.c
// Function: base64dec
char *
base64dec(const char *src)
{
	size_t in_len = strlen(src);
	char *result, *dst;

	if (in_len % 4)
		in_len += 4 - (in_len % 4);
	result = dst = xmalloc(in_len / 4 * 3 + 1);
	while (*src) {
		int a = base64_digits[(unsigned char) base64dec_getc(&src)];
		int b = base64_digits[(unsigned char) base64dec_getc(&src)];
		int c = base64_digits[(unsigned char) base64dec_getc(&src)];
		int d = base64_digits[(unsigned char) base64dec_getc(&src)];

		/* invalid input. 'a' can be -1, e.g. if src is "\n" (c-str) */
		if (a == -1 || b == -1)
			break;

		*dst++ = (a << 2) | ((b & 0x30) >> 4);
		if (c == -1)
			break;
		*dst++ = ((b & 0x0f) << 4) | ((c & 0x3c) >> 2);
		if (d == -1)
			break;
		*dst++ = ((c & 0x03) << 6) | d;
	}
	*dst = '\0';
	return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0x10(%rsp), %rbx
movq %rdi, (%rbx)
callq 0x5370
addq $0x3, %rax
shrq $0x2, %rax
leaq (%rax,%rax,2), %rdi
incq %rdi
callq 0x5e5c
leaq 0x51c8(%rip), %r12      # 0xe480
movq %rax, 0x8(%rsp)
movq %rax, %r15
movq 0x10(%rsp), %rax
cmpb $0x0, (%rax)
je 0x9372
movq %rbx, %rdi
callq 0x938a
movzbl %al, %eax
movb (%rax,%r12), %r14b
movq %rbx, %rdi
callq 0x938a
movzbl %al, %eax
movb (%rax,%r12), %r13b
movq %rbx, %rdi
callq 0x938a
movzbl %al, %eax
movb (%rax,%r12), %bpl
movq %rbx, %rdi
callq 0x938a
cmpb $-0x1, %r14b
sete %cl
cmpb $-0x1, %r13b
sete %dl
orb %cl, %dl
jne 0x9368
movzbl %al, %eax
movb (%rax,%r12), %al
shlb $0x2, %r14b
movl %r13d, %ecx
shrb $0x4, %cl
andb $0x3, %cl
orb %r14b, %cl
movb %cl, (%r15)
cmpb $-0x1, %bpl
je 0x935f
shlb $0x4, %r13b
movl %ebp, %ecx
shrb $0x2, %cl
andb $0xf, %cl
orb %r13b, %cl
movb %cl, 0x1(%r15)
cmpb $-0x1, %al
je 0x9364
shlb $0x6, %bpl
orb %bpl, %al
movb %al, 0x2(%r15)
addq $0x3, %r15
movb $0x1, %al
jmp 0x936a
incq %r15
jmp 0x9368
addq $0x2, %r15
xorl %eax, %eax
testb %al, %al
jne 0x92c0
movb $0x0, (%r15)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/impact-eintr[P]st/x.c
// Function: xseticontitle
void
xseticontitle(char *p)
{
	XTextProperty prop;
	DEFAULT(p, opt_title);

	Xutf8TextListToTextProperty(xw.dpy, &p, 1, XUTF8StringStyle,
			&prop);
	XSetWMIconName(xw.dpy, xw.win, &prop);
	XSetTextProperty(xw.dpy, xw.win, &prop, xw.netwmiconname);
	XFree(prop.value);
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdi, 0x8(%rsp)
testq %rdi, %rdi
jne 0xa450
movq 0xd990(%rip), %rdi      # 0x17de0
leaq 0x8(%rsp), %rsi
movq %rdi, (%rsi)
movq 0xd849(%rip), %rdi      # 0x17ca8
leaq 0x10(%rsp), %rbx
movl $0x1, %edx
movl $0x4, %ecx
movq %rbx, %r8
callq 0x5420
movq 0xd82b(%rip), %rdi      # 0x17ca8
movq 0xd834(%rip), %rsi      # 0x17cb8
movq %rbx, %rdx
callq 0x5320
movq 0xd815(%rip), %rdi      # 0x17ca8
movq 0xd81e(%rip), %rsi      # 0x17cb8
movq 0xd847(%rip), %rcx      # 0x17ce8
movq %rbx, %rdx
callq 0x5440
movq (%rbx), %rdi
callq 0x5090
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/impact-eintr[P]st/x.c
// Function: xsettitle
void
xsettitle(char *p)
{
	XTextProperty prop;
	DEFAULT(p, opt_title);

	Xutf8TextListToTextProperty(xw.dpy, &p, 1, XUTF8StringStyle,
			&prop);
	XSetWMName(xw.dpy, xw.win, &prop);
	XSetTextProperty(xw.dpy, xw.win, &prop, xw.netwmname);
	XFree(prop.value);
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdi, 0x8(%rsp)
testq %rdi, %rdi
jne 0xa4cd
movq 0xd913(%rip), %rdi      # 0x17de0
leaq 0x8(%rsp), %rsi
movq %rdi, (%rsi)
movq 0xd7cc(%rip), %rdi      # 0x17ca8
leaq 0x10(%rsp), %rbx
movl $0x1, %edx
movl $0x4, %ecx
movq %rbx, %r8
callq 0x5420
movq 0xd7ae(%rip), %rdi      # 0x17ca8
movq 0xd7b7(%rip), %rsi      # 0x17cb8
movq %rbx, %rdx
callq 0x53e0
movq 0xd798(%rip), %rdi      # 0x17ca8
movq 0xd7a1(%rip), %rsi      # 0x17cb8
movq 0xd7c2(%rip), %rcx      # 0x17ce0
movq %rbx, %rdx
callq 0x5440
movq (%rbx), %rdi
callq 0x5090
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/impact-eintr[P]st/x.c
// Function: cresize
void
cresize(int width, int height)
{
	int col, row;

	if (width != 0)
		win.w = width;
	if (height != 0)
		win.h = height;

	col = (win.w - 2 * borderpx) / win.cw;
	row = (win.h - 2 * borderpx) / win.ch;
	col = MAX(1, col);
	row = MAX(1, row);

	win.hborderpx = (win.w - col * win.cw) / 2;
	win.vborderpx = (win.h - row * win.ch) / 2;

	tresize(col, row);
	xresize(col, row);
	ttyresize(win.tw, win.th);
}

// Assembly:
testl %edi, %edi
je 0xc7e2
movl %edi, 0xb5de(%rip)      # 0x17dc0
testl %esi, %esi
je 0xc7ec
movl %esi, 0xb5d8(%rip)      # 0x17dc4
pushq %rbp
pushq %rbx
pushq %rax
movl 0xb5cb(%rip), %esi      # 0x17dc0
leal -0x4(%rsi), %eax
movl 0xb5d6(%rip), %edi      # 0x17dd4
cltd
idivl %edi
movl %eax, %ebx
movl 0xb5bb(%rip), %ecx      # 0x17dc4
leal -0x4(%rcx), %eax
movl 0xb5bd(%rip), %r8d      # 0x17dd0
cltd
idivl %r8d
cmpl $0x2, %ebx
movl $0x1, %ebp
cmovll %ebp, %ebx
cmpl $0x2, %eax
cmovgel %eax, %ebp
imull %ebx, %edi
subl %edi, %esi
movl %esi, %eax
shrl $0x1f, %eax
addl %esi, %eax
sarl %eax
movl %eax, 0xb58c(%rip)      # 0x17dc8
imull %ebp, %r8d
subl %r8d, %ecx
movl %ecx, %eax
shrl $0x1f, %eax
addl %ecx, %eax
sarl %eax
movl %eax, 0xb57a(%rip)      # 0x17dcc
movl %ebx, %edi
movl %ebp, %esi
callq 0x6fbd
movl 0xb573(%rip), %eax      # 0x17dd4
imull %ebx, %eax
imull 0xb565(%rip), %ebp      # 0x17dd0
movl %eax, 0xb547(%rip)      # 0x17db8
movl %ebp, 0xb545(%rip)      # 0x17dbc
movq 0xb42a(%rip), %rdi      # 0x17ca8
movq 0xb43b(%rip), %rsi      # 0x17cc0
callq 0x57d0
movq 0xb417(%rip), %rdi      # 0x17ca8
movq 0xb420(%rip), %rsi      # 0x17cb8
movl 0xb522(%rip), %edx      # 0x17dc0
movl 0xb520(%rip), %ecx      # 0x17dc4
movl 0xb4f5(%rip), %r8d      # 0x17da0
callq 0x5850
movq %rax, 0xb409(%rip)      # 0x17cc0
movq 0xb45a(%rip), %rdi      # 0x17d18
movq %rax, %rsi
callq 0x56c0
movl 0xb4f3(%rip), %r8d      # 0x17dc0
movl 0xb4f0(%rip), %r9d      # 0x17dc4
movq 0xb43d(%rip), %rdi      # 0x17d18
testb $0x20, 0xb4f6(%rip)     # 0x17dd8
leaq 0x8c07(%rip), %rax      # 0x154f0
leaq 0x8c04(%rip), %rcx      # 0x154f4
cmovneq %rax, %rcx
movl (%rcx), %esi
shlq $0x4, %rsi
addq 0xb2af(%rip), %rsi      # 0x17bb0
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x53d0
movq 0xb3b7(%rip), %rdi      # 0x17cc8
shlq $0x4, %rbx
movq %rbx, %rsi
callq 0x5f20
movq %rax, 0xb3a4(%rip)      # 0x17cc8
movl 0xb48e(%rip), %edi      # 0x17db8
movl 0xb48c(%rip), %esi      # 0x17dbc
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x6e4d
// File: /workspace/github_c_makefile_star2_O1/impact-eintr[P]st/x.c
// Function: bpress
void
bpress(XEvent *e)
{
	struct timespec now;
	int snap;

	if (IS_SET(MODE_MOUSE) && !(e->xbutton.state & forcemousemod)) {
		mousereport(e);
		return;
	}

	if (mouseaction(e, 0))
		return;

	if (e->xbutton.button == Button1) {
		/*
		 * If the user clicks below predefined timeouts specific
		 * snapping behaviour is exposed.
		 */
		clock_gettime(CLOCK_MONOTONIC, &now);
		if (TIMEDIFF(now, xsel.tclick2) <= tripleclicktimeout) {
			snap = SNAP_LINE;
		} else if (TIMEDIFF(now, xsel.tclick1) <= doubleclicktimeout) {
			snap = SNAP_WORD;
		} else {
			snap = 0;
		}
		xsel.tclick2 = xsel.tclick1;
		xsel.tclick1 = now;

		selstart(evcol(e), evrow(e), snap);
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movzwl 0xb2a5(%rip), %eax      # 0x17dd8
testl $0xc018, %eax           # imm = 0xC018
je 0xcb4f
testb $0x1, 0x50(%rbx)
jne 0xcb4f
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0xd37e
movq %rbx, %rdi
xorl %esi, %esi
callq 0xd52c
testl %eax, %eax
jne 0xcc76
cmpl $0x1, 0x54(%rbx)
jne 0xcc76
leaq 0x8(%rsp), %r14
movl $0x1, %edi
movq %r14, %rsi
callq 0x5130
movq (%r14), %rdx
movq 0x8(%r14), %rax
movq %rdx, %rcx
subq 0xb2c2(%rip), %rcx      # 0x17e50
imulq $0x3e8, %rcx, %rcx      # imm = 0x3E8
cvtsi2sd %rcx, %xmm0
movq %rax, %rcx
subq 0xb2b4(%rip), %rcx      # 0x17e58
cvtsi2sd %rcx, %xmm1
divsd 0x1f57(%rip), %xmm1     # 0xeb08
addsd %xmm0, %xmm1
movl $0x2, %ecx
movsd 0x1f86(%rip), %xmm0     # 0xeb48
ucomisd %xmm1, %xmm0
jae 0xcc0a
subq 0xb271(%rip), %rdx      # 0x17e40
imulq $0x3e8, %rdx, %rcx      # imm = 0x3E8
xorps %xmm0, %xmm0
cvtsi2sd %rcx, %xmm0
subq 0xb263(%rip), %rax      # 0x17e48
xorps %xmm1, %xmm1
cvtsi2sd %rax, %xmm1
divsd 0x1f13(%rip), %xmm1     # 0xeb08
addsd %xmm0, %xmm1
movsd 0x1f4f(%rip), %xmm0     # 0xeb50
xorl %ecx, %ecx
ucomisd %xmm1, %xmm0
setae %cl
movups 0xb22f(%rip), %xmm0     # 0x17e40
movups %xmm0, 0xb238(%rip)     # 0x17e50
movups 0x8(%rsp), %xmm0
movups %xmm0, 0xb21c(%rip)     # 0x17e40
movl 0x40(%rbx), %edx
xorl %esi, %esi
subl 0xb199(%rip), %edx      # 0x17dc8
movl $0x0, %eax
js 0xcc43
movl 0xb17c(%rip), %eax      # 0x17db8
decl %eax
cmpl %eax, %edx
cmovll %edx, %eax
cltd
idivl 0xb18a(%rip)            # 0x17dd4
movl %eax, %edi
movl 0x44(%rbx), %eax
subl 0xb177(%rip), %eax      # 0x17dcc
js 0xcc64
movl 0xb15f(%rip), %esi      # 0x17dbc
decl %esi
cmpl %esi, %eax
cmovll %eax, %esi
movl %esi, %eax
cltd
idivl 0xb163(%rip)            # 0x17dd0
movl %eax, %esi
movl %ecx, %edx
callq 0x6008
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/impact-eintr[P]st/x.c
// Function: brelease
void
brelease(XEvent *e)
{
	if (IS_SET(MODE_MOUSE) && !(e->xbutton.state & forcemousemod)) {
		mousereport(e);
		return;
	}

	if (mouseaction(e, 1))
		return;
	if (e->xbutton.button == Button1)
		mousesel(e, 1);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movzwl 0xb14f(%rip), %eax      # 0x17dd8
testl $0xc018, %eax           # imm = 0xC018
je 0xcc9f
testb $0x1, 0x50(%rbx)
jne 0xcc9f
movq %rbx, %rdi
popq %rbx
jmp 0xd37e
movq %rbx, %rdi
movl $0x1, %esi
callq 0xd52c
testl %eax, %eax
jne 0xccc4
cmpl $0x1, 0x54(%rbx)
jne 0xccc4
movq %rbx, %rdi
movl $0x1, %esi
popq %rbx
jmp 0xd5e1
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/jani-nykanen[P]mushrooms/./tools/src/png2spr.c
// Function: write_array
static void write_array(FILE* f, u8* arr, u32 len) {
    
    u32 i;
    u32 count = 3;
    u8 bout = 0;

    for (i = 0; i < len; ++ i) {

        bout = bout | (arr[i] << (count*2));

        if (count -- == 0) {

            fwrite(&bout, 1, 1, f);
            bout = 0;
            count = 3;
        }
    }
}

// Assembly:
testl %edx, %edx
je 0xee6b
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl %edx, %r15d
movl $0x3, %eax
xorl %r12d, %r12d
xorl %esi, %esi
movzbl (%rbx,%r12), %edx
leal (%rax,%rax), %ecx
shll %cl, %edx
orb %sil, %dl
subl $0x1, %eax
jae 0xee59
movsbl %dl, %edi
movq %r14, %rsi
callq 0x10b0
movl $0x3, %eax
xorl %edx, %edx
incq %r12
movl %edx, %esi
cmpq %r12, %r15
jne 0xee35
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq