LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/occivink[P]pyct/monocypher.cpp
// Function: mul_add(unsigned char*, unsigned char const*, unsigned char const*, unsigned char const*)
static void mul_add(u8 r[32], const u8 a[32], const u8 b[32], const u8 c[32])
{
    u32 A[8];  load32_le_buf(A, a, 8);
    u32 B[8];  load32_le_buf(B, b, 8);
    u32 p[16]; load32_le_buf(p, c, 8);  ZERO(p + 8, 8);
    multiply(p, A, B);
    mod_l(r, p);
    WIPE_BUFFER(p);
    WIPE_BUFFER(A);
    WIPE_BUFFER(B);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
pushq $0x8
popq %r14
movq %r14, %rdx
callq 0x264b
movq %rsp, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x264b
leaq 0x40(%rsp), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x264b
cmpq $0x10, %r14
je 0x5f07
andl $0x0, 0x40(%rsp,%r14,4)
incq %r14
jmp 0x5ef6
leaq 0x40(%rsp), %r14
leaq 0x20(%rsp), %r15
movq %rsp, %r12
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x860a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x84d1
pushq $0x40
popq %rsi
movq %r14, %rdi
callq 0x25a4
pushq $0x20
popq %rbx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x25a4
movq %r12, %rdi
movq %rbx, %rsi
callq 0x25a4
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/occivink[P]pyct/monocypher.cpp
// Function: crypto_sign
void crypto_sign(u8        signature[64],
                 const u8  secret_key[32],
                 const u8  public_key[32],
                 const u8 *message, size_t message_size)
{
    crypto_sign_ctx ctx;
    crypto_sign_ctx_abstract *actx = (crypto_sign_ctx_abstract*)&ctx;
    crypto_sign_init_first_pass (actx, secret_key, public_key);
    crypto_sign_update          (actx, message, message_size);
    crypto_sign_init_second_pass(actx);
    crypto_sign_update          (actx, message, message_size);
    crypto_sign_final           (actx, signature);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x168, %rsp            # imm = 0x168
movq %r8, %rbx
movq %rcx, %r14
movq %rdi, %r15
movq %rsp, %r12
movq %r12, %rdi
callq 0x5d5f
movq (%r12), %rax
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq *0x10(%rax)
movq %r12, %rdi
callq 0x5d74
movq (%r12), %rax
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq *0x10(%rax)
movq %r12, %rdi
movq %r15, %rsi
callq 0x5e3a
addq $0x168, %rsp            # imm = 0x168
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/occivink[P]pyct/monocypher.cpp
// Function: crypto_check_init_custom_hash
void crypto_check_init_custom_hash(crypto_check_ctx_abstract *ctx,
                                   const u8 signature[64],
                                   const u8 public_key[32],
                                   const crypto_sign_vtable *hash)
{
    ctx->hash = hash; // set vtable
    COPY(ctx->buf, signature , 64);
    COPY(ctx->pk , public_key, 32);
    ctx->hash->init  (ctx);
    ctx->hash->update(ctx, signature , 32);
    ctx->hash->update(ctx, public_key, 32);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rcx, (%rdi)
pushq $0x8
popq %rax
cmpq $0x48, %rax
je 0x5fef
movb -0x8(%r15,%rax), %dl
movb %dl, (%r14,%rax)
incq %rax
jmp 0x5fdb
xorl %eax, %eax
cmpq $0x20, %rax
je 0x6004
movb (%rbx,%rax), %dl
movb %dl, 0x68(%r14,%rax)
incq %rax
jmp 0x5ff1
movq %r14, %rdi
callq *0x8(%rcx)
movq (%r14), %rax
pushq $0x20
popq %r12
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq *0x10(%rax)
movq (%r14), %rax
movq 0x10(%rax), %rax
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_cpp_makefile_star2_O2/occivink[P]pyct/monocypher.cpp
// Function: is_above_l(unsigned int const*)
static int is_above_l(const u32 x[8])
{
    // We work with L directly, in a 2's complement encoding
    // (-L == ~L + 1)
    u64 carry = 1;
    FOR (i, 0, 8) {
        carry  += (u64)x[i] + (~L[i] & 0xffffffff);
        carry >>= 32;
    }
    return (int)carry; // carry is either 0 or 1
}

// Assembly:
pushq $0x1
popq %rax
xorl %ecx, %ecx
leaq 0x6610(%rip), %rdx      # 0xca00
cmpq $0x20, %rcx
je 0x6410
movl (%rdi,%rcx), %esi
movl (%rcx,%rdx), %r8d
notl %r8d
addq %rsi, %rax
addq %r8, %rax
shrq $0x20, %rax
addq $0x4, %rcx
jmp 0x63f0
retq
// File: /workspace/github_cpp_makefile_star2_O2/occivink[P]pyct/monocypher.cpp
// Function: crypto_from_eddsa_public
void crypto_from_eddsa_public(u8 x25519[32], const u8 eddsa[32])
{
    fe t1, t2;
    fe_frombytes(t2, eddsa);
    fe_add(t1, fe_one, t2);
    fe_sub(t2, fe_one, t2);
    fe_invert(t2, t2);
    fe_mul(t1, t1, t2);
    fe_tobytes(x25519, t1);
    WIPE_BUFFER(t1);
    WIPE_BUFFER(t2);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %r14
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x651c
leaq 0x692f(%rip), %r15      # 0xcde0
leaq 0x30(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x6524
movq %rbx, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x653b
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x6552
movq %r12, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x65a5
movq %r14, %rdi
movq %r12, %rsi
callq 0x6d90
pushq $0x28
popq %r14
movq %r12, %rdi
movq %r14, %rsi
callq 0x25a4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x25a4
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/occivink[P]pyct/monocypher.cpp
// Function: fe_invert(int*, int const*)
static void fe_invert(fe out, const fe x)
{
    fe tmp;
    fe_sq(tmp, x);
    invsqrt(tmp, tmp);
    fe_sq(tmp, tmp);
    fe_mul(out, tmp, x);
    WIPE_BUFFER(tmp);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0x76c3
movq %r15, %rdi
movq %r15, %rsi
callq 0x7b97
movq %r15, %rdi
movq %r15, %rsi
callq 0x76c3
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x65a5
pushq $0x28
popq %rsi
movq %r15, %rdi
callq 0x25a4
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/occivink[P]pyct/monocypher.cpp
// Function: crypto_x25519_dirty_small
void crypto_x25519_dirty_small(u8 public_key[32], const u8 secret_key[32])
{
    // Base point of order 8*L
    // Raw scalar multiplication with it does not clear the cofactor,
    // and the resulting public key will reveal 3 bits of the scalar.
    //
    // The low order component of this base point  has been chosen
    // to yield the same results as crypto_x25519_dirty_fast().
    static const u8 dirty_base_point[32] = {
        0xd8, 0x86, 0x1a, 0xa2, 0x78, 0x7a, 0xd9, 0x26, 0x8b, 0x74, 0x74, 0xb6,
        0x82, 0xe3, 0xbe, 0xc3, 0xce, 0x36, 0x9a, 0x1e, 0x5e, 0x31, 0x47, 0xa2,
        0x6d, 0x37, 0x7c, 0xfd, 0x20, 0xb5, 0xdf, 0x75,
    };
    // separate the main factor & the cofactor of the scalar
    u8 scalar[32];
    COPY(scalar, secret_key, 32);
    trim_scalar(scalar);

    // Separate the main factor and the cofactor
    //
    // The scalar is trimmed, so its cofactor is cleared.  The three
    // least significant bits however still have a main factor.  We must
    // remove it for X25519 compatibility.
    //
    //   cofactor = lsb * L            (modulo 8*L)
    //   combined = scalar + cofactor  (modulo 8*L)
    add_xl(scalar, secret_key[0]);
    scalarmult(public_key, scalar, dirty_base_point, 256);
    WIPE_BUFFER(scalar);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorl %eax, %eax
cmpq $0x20, %rax
je 0x6f4d
movb (%rsi,%rax), %cl
movb %cl, (%rsp,%rax)
incq %rax
jmp 0x6f3c
movq %rsp, %r14
andb $-0x8, (%r14)
movb 0x1f(%r14), %al
andb $0x3f, %al
orb $0x40, %al
movb %al, 0x1f(%r14)
movzbl (%rsi), %esi
movq %r14, %rdi
callq 0x6f95
leaq 0x518e(%rip), %rdx      # 0xc100
movq %rbx, %rdi
movq %r14, %rsi
movl $0x100, %ecx            # imm = 0x100
callq 0x57ad
pushq $0x20
popq %rsi
movq %r14, %rdi
callq 0x25a4
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/occivink[P]pyct/monocypher.cpp
// Function: add_xl(unsigned char*, unsigned char)
static void add_xl(u8 s[32], u8 x)
{
    u64 mod8  = x & 7;
    u64 carry = 0;
    FOR (i , 0, 8) {
        carry = carry + load32_le(s + 4*i) + L[i] * mod8;
        store32_le(s + 4*i, (u32)carry);
        carry >>= 32;
    }
}

// Assembly:
andl $0x7, %esi
xorl %eax, %eax
leaq 0x5a5f(%rip), %rcx      # 0xca00
xorl %edx, %edx
cmpq $0x20, %rax
je 0x6fcc
movl (%rdi,%rax), %r8d
addq %r8, %rdx
movl (%rax,%rcx), %r8d
imulq %rsi, %r8
addq %rdx, %r8
movl %r8d, (%rdi,%rax)
shrq $0x20, %r8
addq $0x4, %rax
movq %r8, %rdx
jmp 0x6fa3
retq
// File: /workspace/github_cpp_makefile_star2_O2/occivink[P]pyct/monocypher.cpp
// Function: crypto_x25519_dirty_fast
void crypto_x25519_dirty_fast(u8 public_key[32], const u8 secret_key[32])
{
    // Compute clean scalar multiplication
    u8 scalar[32];
    ge pk;
    COPY(scalar, secret_key, 32);
    trim_scalar(scalar);
    ge_scalarmult_base(&pk, scalar);

    // Compute low order point
    fe t1, t2;
    select_lop(t1, lop_x, sqrtm1, secret_key[0]);
    select_lop(t2, lop_y, fe_one, secret_key[0] + 2);
    ge_precomp low_order_point;
    fe_add(low_order_point.Yp, t2, t1);
    fe_sub(low_order_point.Ym, t2, t1);
    fe_mul(low_order_point.T2, t2, t1);
    fe_mul(low_order_point.T2, low_order_point.T2, D2);

    // Add low order point to the public key
    ge_madd(&pk, &pk, &low_order_point, t1, t2);

    // Convert to Montgomery u coordinate (we ignore the sign)
    fe_add(t1, pk.Z, pk.Y);
    fe_sub(t2, pk.Z, pk.Y);
    fe_invert(t2, t2);
    fe_mul(t1, t1, t2);

    fe_tobytes(public_key, t1);

    WIPE_BUFFER(t1);    WIPE_CTX(&pk);
    WIPE_BUFFER(t2);    WIPE_CTX(&low_order_point);
    WIPE_BUFFER(scalar);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rsi, %r12
movq %rdi, 0x8(%rsp)
xorl %eax, %eax
cmpq $0x20, %rax
je 0x6ffb
movb (%r12,%rax), %cl
movb %cl, 0x10(%rsp,%rax)
incq %rax
jmp 0x6fe8
leaq 0x10(%rsp), %rbx
andb $-0x8, (%rbx)
movb 0x1f(%rbx), %al
andb $0x3f, %al
orb $0x40, %al
movb %al, 0x1f(%rbx)
leaq 0x108(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x5acf
movzbl (%r12), %r13d
leaq 0x50f4(%rip), %rsi      # 0xc120
leaq 0x511d(%rip), %rdx      # 0xc150
leaq 0xe0(%rsp), %r12
movq %r12, %rdi
movl %r13d, %ecx
callq 0x716d
leal 0x2(%r13), %eax
movzbl %al, %ecx
leaq 0x512c(%rip), %rsi      # 0xc180
leaq 0x5d85(%rip), %rdx      # 0xcde0
leaq 0xb0(%rsp), %r13
movq %r13, %rdi
callq 0x716d
leaq 0x38(%rsp), %rbp
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x6524
leaq 0x60(%rsp), %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x653b
leaq 0x88(%rsp), %r14
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x65a5
leaq 0x5105(%rip), %rdx      # 0xc1b0
movq %r14, %rdi
movq %r14, %rsi
callq 0x65a5
movq %r15, %rdi
movq %r15, %rsi
movq %rbp, %rdx
movq %r12, %rcx
movq %r13, %r8
callq 0x71e2
leaq 0x158(%rsp), %r14
leaq 0x130(%rsp), %rbp
movq %r12, %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0x6524
movq %r13, %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0x653b
movq %r13, %rdi
movq %r13, %rsi
callq 0x6552
movq %r12, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x65a5
movq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x6d90
pushq $0x28
popq %r14
movq %r12, %rdi
movq %r14, %rsi
callq 0x25a4
movl $0xa0, %esi
movq %r15, %rdi
callq 0x25a4
movq %r13, %rdi
movq %r14, %rsi
callq 0x25a4
pushq $0x78
popq %rsi
leaq 0x38(%rsp), %rdi
callq 0x25a4
pushq $0x20
popq %rsi
movq %rbx, %rdi
callq 0x25a4
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/occivink[P]pyct/monocypher.cpp
// Function: select_lop(int*, int const*, int const*, unsigned char)
static void select_lop(fe out, const fe x, const fe k, u8 cofactor)
{
    fe tmp;
    fe_0(out);
    fe_ccopy(out, k  , (cofactor >> 1) & 1); // bit 1
    fe_ccopy(out, x  , (cofactor >> 0) & 1); // bit 0
    fe_neg  (tmp, out);
    fe_ccopy(out, tmp, (cofactor >> 2) & 1); // bit 2
    WIPE_BUFFER(tmp);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
callq 0x8b07
movl %ebx, %edx
shrl %edx
andl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x7eb4
movl %ebx, %edx
andl $0x1, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x7eb4
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x7ed8
shrl $0x2, %ebx
andl $0x1, %ebx
movq %r14, %rdi
movq %r15, %rsi
movl %ebx, %edx
callq 0x7eb4
pushq $0x28
popq %rsi
movq %r15, %rdi
callq 0x25a4
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/occivink[P]pyct/monocypher.cpp
// Function: ge_madd(ge*, ge const*, ge_precomp const*, int*, int*)
static void ge_madd(ge *s, const ge *p, const ge_precomp *q, fe a, fe b)
{
    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->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 $0x18, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r15
leaq 0x28(%rsi), %r12
movq %rcx, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x6524
movq %rbx, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x653b
movq %r14, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x65a5
leaq 0x28(%r13), %rdx
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x65a5
leaq 0x28(%r15), %rdi
movq %rdi, 0x10(%rsp)
movq %r14, %rsi
movq %rbx, %rdx
callq 0x6524
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x653b
leaq 0x50(%r15), %rdi
movq %rdi, 0x8(%rsp)
leaq 0x50(%rbp), %rdx
movq %rdx, %rsi
callq 0x6524
leaq 0x78(%r15), %r12
addq $0x78, %rbp
addq $0x50, %r13
movq %r12, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x65a5
movq %r14, %rdi
movq 0x8(%rsp), %r13
movq %r13, %rsi
movq %r12, %rdx
callq 0x6524
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x653b
movq %r12, %rdi
movq %r15, %rsi
movq 0x10(%rsp), %r12
movq %r12, %rdx
callq 0x65a5
movq %r15, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x65a5
movq %r12, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x65a5
movq %r13, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x65a5
// File: /workspace/github_cpp_makefile_star2_O2/occivink[P]pyct/monocypher.cpp
// Function: crypto_hidden_to_curve
void crypto_hidden_to_curve(uint8_t curve[32], const uint8_t hidden[32])
{
    fe r, u, t1, t2, t3;
    fe_frombytes_mask(r, hidden, 2); // r is encoded in 254 bits.
    fe_sq(r, r);
    fe_add(t1, r, r);
    fe_add(u, t1, fe_one);
    fe_sq (t2, u);
    fe_mul(t3, A2, t1);
    fe_sub(t3, t3, t2);
    fe_mul(t3, t3, A);
    fe_mul(t1, t2, u);
    fe_mul(t1, t3, t1);
    int is_square = invsqrt(t1, t1);
    fe_mul(u, r, ufactor);
    fe_ccopy(u, fe_one, is_square);
    fe_sq (t1, t1);
    fe_mul(u, u, A);
    fe_mul(u, u, t3);
    fe_mul(u, u, t2);
    fe_mul(u, u, t1);
    fe_neg(u, u);
    fe_tobytes(curve, u);

    WIPE_BUFFER(t1);  WIPE_BUFFER(r);
    WIPE_BUFFER(t2);  WIPE_BUFFER(u);
    WIPE_BUFFER(t3);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rdi, 0x8(%rsp)
leaq 0xd0(%rsp), %rbx
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x749b
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x76c3
leaq 0x70(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
callq 0x6524
leaq 0x5a99(%rip), %rdx      # 0xcde0
leaq 0xa0(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x6524
leaq 0x40(%rsp), %rbp
movq %rbp, %rdi
movq %r15, %rsi
callq 0x76c3
leaq 0x5a9f(%rip), %rsi      # 0xce10
leaq 0x10(%rsp), %r13
movq %r13, %rdi
movq %r12, %rdx
callq 0x65a5
movq %r13, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x653b
leaq 0x5aaa(%rip), %rdx      # 0xce40
movq %r13, %rdi
movq %r13, %rsi
callq 0x65a5
movq %r12, %rdi
movq %rbp, %rsi
movq %r15, %rdx
callq 0x65a5
movq %r12, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x65a5
movq %r12, %rdi
movq %r12, %rsi
callq 0x7b97
movl %eax, %r14d
leaq 0x4e0e(%rip), %rdx      # 0xc1e0
movq %r15, %rdi
movq %rbx, %rsi
callq 0x65a5
movq %r15, %rdi
leaq 0x59f9(%rip), %rsi      # 0xcde0
movl %r14d, %edx
callq 0x7eb4
movq %r12, %rdi
movq %r12, %rsi
callq 0x76c3
movq %r15, %rdi
movq %r15, %rsi
leaq 0x5a39(%rip), %rdx      # 0xce40
callq 0x65a5
movq %r15, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x65a5
movq %r15, %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x65a5
movq %r15, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x65a5
movq %r15, %rdi
movq %r15, %rsi
callq 0x7ed8
movq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x6d90
pushq $0x28
popq %r14
movq %r12, %rdi
movq %r14, %rsi
callq 0x25a4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x25a4
movq %rbp, %rdi
movq %r14, %rsi
callq 0x25a4
movq %r15, %rdi
movq %r14, %rsi
callq 0x25a4
movq %r13, %rdi
movq %r14, %rsi
callq 0x25a4
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/occivink[P]pyct/monocypher.cpp
// Function: fe_ccopy(int*, int const*, int)
static void fe_ccopy(fe f, const fe g, int b)
{
    i32 mask = -b; // -1 = 0xffffffff
    FOR (i, 0, 10) {
        i32 x = (f[i] ^ g[i]) & mask;
        f[i] = f[i] ^ x;
    }
}

// Assembly:
negl %edx
xorl %eax, %eax
cmpq $0xa, %rax
je 0x7ed7
movl (%rdi,%rax,4), %ecx
movl (%rsi,%rax,4), %r8d
xorl %ecx, %r8d
andl %edx, %r8d
xorl %ecx, %r8d
movl %r8d, (%rdi,%rax,4)
incq %rax
jmp 0x7eb8
retq
// File: /workspace/github_cpp_makefile_star2_O2/occivink[P]pyct/monocypher.cpp
// Function: crypto_curve_to_hidden
int crypto_curve_to_hidden(u8 hidden[32], const u8 public_key[32], u8 tweak)
{
    fe t1, t2, t3;
    fe_frombytes(t1, public_key);    // t1 = u

    fe_add(t2, t1, A);               // t2 = u + A
    fe_mul(t3, t1, t2);
    fe_mul_small(t3, t3, -2);
    int is_square = invsqrt(t3, t3); // t3 = sqrt(-1 / non_square * u * (u+A))
    if (is_square) {
        // The only variable time bit.  This ultimately reveals how many
        // tries it took us to find a representable key.
        // This does not affect security as long as we try keys at random.

        fe_ccopy    (t1, t2, tweak & 1); // multiply by u if v is positive,
        fe_mul      (t3, t1, t3);        // multiply by u+A otherwise
        fe_mul_small(t1, t3, 2);
        fe_neg      (t2, t3);
        fe_ccopy    (t3, t2, fe_isodd(t1));
        fe_tobytes(hidden, t3);

        // Pad with two random bits
        hidden[31] |= tweak & 0xc0;
    }

    WIPE_BUFFER(t1);
    WIPE_BUFFER(t2);
    WIPE_BUFFER(t3);
    return is_square - 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %edx, %ebx
movq %rdi, %r14
leaq 0x60(%rsp), %r15
movq %r15, %rdi
callq 0x651c
leaq 0x4f28(%rip), %rdx      # 0xce40
leaq 0x30(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x6524
movq %rsp, %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x65a5
pushq $-0x2
popq %rdx
movq %r13, %rdi
movq %r13, %rsi
callq 0x8003
movq %r13, %rdi
movq %r13, %rsi
callq 0x7b97
movl %eax, %ebp
testl %eax, %eax
je 0x7fc5
movl %ebx, %eax
andb $0x1, %al
movzbl %al, %edx
leaq 0x60(%rsp), %r13
leaq 0x30(%rsp), %r15
movq %r13, %rdi
movq %r15, %rsi
callq 0x7eb4
movq %rsp, %r12
movq %r12, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x65a5
pushq $0x2
popq %rdx
movq %r13, %rdi
movq %r12, %rsi
callq 0x8003
movq %r15, %rdi
movq %r12, %rsi
callq 0x7ed8
movq %r13, %rdi
callq 0x81bf
movq %r12, %rdi
movq %r15, %rsi
movl %eax, %edx
callq 0x7eb4
movq %r14, %rdi
movq %r12, %rsi
callq 0x6d90
andb $-0x40, %bl
orb %bl, 0x1f(%r14)
leaq 0x60(%rsp), %rdi
pushq $0x28
popq %rbx
movq %rbx, %rsi
callq 0x25a4
leaq 0x30(%rsp), %rdi
movq %rbx, %rsi
callq 0x25a4
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x25a4
decl %ebp
movl %ebp, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/occivink[P]pyct/monocypher.cpp
// Function: fe_isodd(int const*)
static int fe_isodd(const fe f)
{
    u8 s[32];
    fe_tobytes(s, f);
    u8 isodd = s[0] & 1;
    WIPE_BUFFER(s);
    return isodd;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rsi
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x6d90
movzbl (%rbx), %ebp
andl $0x1, %ebp
pushq $0x20
popq %rsi
movq %rbx, %rdi
callq 0x25a4
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/occivink[P]pyct/monocypher.cpp
// Function: crypto_hidden_key_pair
void crypto_hidden_key_pair(u8 hidden[32], u8 secret_key[32], u8 seed[32])
{
    u8 pk [32]; // public key
    u8 buf[64]; // seed + representative
    COPY(buf + 32, seed, 32);
    do {
        crypto_chacha20(buf, 0, 64, buf+32, zero);
        crypto_x25519_dirty_fast(pk, buf); // or the "small" version
    } while(crypto_curve_to_hidden(buf+32, pk, buf[32]));
    // Note that the return value of crypto_curve_to_hidden() is
    // independent from its tweak parameter.
    // Therefore, buf[32] is not actually reused.  Either we loop one
    // more time and buf[32] is used for the new seed, or we succeeded,
    // and buf[32] becomes the tweak parameter.

    crypto_wipe(seed, 32);
    COPY(hidden    , buf + 32, 32);
    COPY(secret_key, buf     , 32);
    WIPE_BUFFER(buf);
    WIPE_BUFFER(pk);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %r15
movq %rdi, %r14
pushq $0x20
popq %rax
leaq 0x30(%rsp), %r12
cmpq $0x40, %rax
je 0x821d
movb -0x20(%r15,%rax), %cl
movb %cl, 0x10(%rsp,%rax)
incq %rax
jmp 0x8209
movq %rsi, 0x8(%rsp)
leaq 0x10(%rsp), %rbp
pushq $0x40
popq %rbx
leaq 0x50(%rsp), %r13
movq %rbp, %rdi
xorl %esi, %esi
movq %rbx, %rdx
movq %r12, %rcx
leaq 0x3ddf(%rip), %r8       # 0xc020
callq 0x2a83
movq %r13, %rdi
movq %rbp, %rsi
callq 0x6fcd
movzbl 0x30(%rsp), %edx
movq %r12, %rdi
movq %r13, %rsi
callq 0x7eee
testl %eax, %eax
jne 0x822f
pushq $0x20
popq %rbx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x25a4
movq 0x8(%rsp), %rdx
cmpq $0x40, %rbx
je 0x828c
movb 0x10(%rsp,%rbx), %al
movb %al, -0x20(%r14,%rbx)
incq %rbx
jmp 0x8278
xorl %eax, %eax
cmpq $0x20, %rax
je 0x82a0
movb 0x10(%rsp,%rax), %cl
movb %cl, (%rdx,%rax)
incq %rax
jmp 0x828e
leaq 0x10(%rsp), %rdi
pushq $0x40
popq %rsi
callq 0x25a4
leaq 0x50(%rsp), %rdi
pushq $0x20
popq %rsi
callq 0x25a4
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/occivink[P]pyct/monocypher.cpp
// Function: mod_l(unsigned char*, unsigned int const*)
static void mod_l(u8 reduced[32], const u32 x[16])
{
    static const u32 r[9] = {0x0a2c131b,0xed9ce5a3,0x086329a7,0x2106215d,
                             0xffffffeb,0xffffffff,0xffffffff,0xffffffff,0xf,};
    // xr = x * r
    u32 xr[25] = {0};
    FOR (i, 0, 9) {
        u64 carry = 0;
        FOR (j, 0, 16) {
            carry  += xr[i+j] + (u64)r[i] * x[j];
            xr[i+j] = (u32)carry;
            carry >>= 32;
        }
        xr[i+16] = (u32)carry;
    }
    // xr = floor(xr / 2^512) * L
    // Since the result is guaranteed to be below 2*L,
    // it is enough to only compute the first 256 bits.
    // The division is performed by saying xr[i+16]. (16 * 32 = 512)
    ZERO(xr, 8);
    FOR (i, 0, 8) {
        u64 carry = 0;
        FOR (j, 0, 8-i) {
            carry   += xr[i+j] + (u64)xr[i+16] * L[j];
            xr[i+j] = (u32)carry;
            carry >>= 32;
        }
    }
    // xr = x - xr
    u64 carry = 1;
    FOR (i, 0, 8) {
        carry  += (u64)x[i] + (~xr[i] & 0xffffffff);
        xr[i]   = (u32)carry;
        carry >>= 32;
    }
    // Final reduction modulo L (conditional subtraction)
    remove_l(xr, xr);
    store32_le_buf(reduced, xr, 8);

    WIPE_BUFFER(xr);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rax
movaps %xmm0, 0x50(%rax)
movaps %xmm0, 0x40(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x20(%rax)
andl $0x0, 0x60(%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
xorl %ecx, %ecx
leaq 0x496b(%rip), %rdx      # 0xce70
cmpq $0x9, %rcx
je 0x8547
movl (%rdx,%rcx,4), %edi
xorl %r8d, %r8d
xorl %r9d, %r9d
cmpq $0x10, %r9
je 0x8539
movl (%rax,%r9,4), %r10d
movl (%rsi,%r9,4), %r11d
imulq %rdi, %r11
addq %r10, %r8
addq %r11, %r8
movl %r8d, (%rax,%r9,4)
shrq $0x20, %r8
incq %r9
jmp 0x8514
movl %r8d, 0x40(%rsp,%rcx,4)
incq %rcx
addq $0x4, %rax
jmp 0x8505
xorl %eax, %eax
cmpq $0x8, %rax
je 0x8558
andl $0x0, (%rsp,%rax,4)
incq %rax
jmp 0x8549
pushq $0x20
popq %rax
movq %rsp, %rcx
xorl %edx, %edx
leaq 0x4499(%rip), %rdi      # 0xca00
cmpq $0x8, %rdx
je 0x85b3
movq %rdx, %r8
orq $0x10, %r8
xorl %r9d, %r9d
xorl %r10d, %r10d
cmpq %r9, %rax
je 0x85a6
movl (%rcx,%r9), %r11d
addq %r11, %r10
movl (%rsp,%r8,4), %r11d
movl (%r9,%rdi), %r14d
imulq %r11, %r14
addq %r10, %r14
movl %r14d, (%rcx,%r9)
shrq $0x20, %r14
addq $0x4, %r9
movq %r14, %r10
jmp 0x857a
incq %rdx
addq $-0x4, %rax
addq $0x4, %rcx
jmp 0x8567
pushq $0x1
popq %rcx
xorl %eax, %eax
cmpq $0x8, %rax
je 0x85db
movl (%rsi,%rax,4), %edx
addq %rdx, %rcx
movl (%rsp,%rax,4), %edx
notl %edx
addq %rcx, %rdx
movl %edx, (%rsp,%rax,4)
shrq $0x20, %rdx
incq %rax
movq %rdx, %rcx
jmp 0x85b8
movq %rsp, %r14
movq %r14, %rdi
movq %r14, %rsi
callq 0x911e
pushq $0x8
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x287d
pushq $0x64
popq %rsi
movq %r14, %rdi
callq 0x25a4
addq $0x68, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/occivink[P]pyct/monocypher.cpp
// Function: multiply(unsigned int*, unsigned int const*, unsigned int const*)
static void multiply(u32 p[16], const u32 a[8], const u32 b[8])
{
    FOR (i, 0, 8) {
        u64 carry = 0;
        FOR (j, 0, 8) {
            carry  += p[i+j] + (u64)a[i] * b[j];
            p[i+j]  = (u32)carry;
            carry >>= 32;
        }
        p[i+8] = (u32)carry;
    }
}

// Assembly:
pushq %rbx
xorl %eax, %eax
movq %rdi, %rcx
cmpq $0x8, %rax
je 0x8653
xorl %r8d, %r8d
xorl %r9d, %r9d
cmpq $0x8, %r9
je 0x8645
movl (%rcx,%r9,4), %r10d
movl (%rsi,%rax,4), %r11d
movl (%rdx,%r9,4), %ebx
imulq %r11, %rbx
addq %r10, %r8
addq %rbx, %r8
movl %r8d, (%rcx,%r9,4)
shrq $0x20, %r8
incq %r9
jmp 0x861c
movl %r8d, 0x20(%rdi,%rax,4)
incq %rax
addq $0x4, %rcx
jmp 0x8610
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/occivink[P]pyct/monocypher.cpp
// Function: redc(unsigned int*, unsigned int*)
static void redc(u32 u[8], u32 x[16])
{
    static const u32 k[8] = { 0x12547e1b, 0xd2b51da3, 0xfdba84ff, 0xb1a206f2,
                              0xffa36bea, 0x14e75438, 0x6fe91836, 0x9db6c6f2, };

    // s = x * k (modulo 2^256)
    // This is cheaper than the full multiplication.
    u32 s[8] = {0};
    FOR (i, 0, 8) {
        u64 carry = 0;
        FOR (j, 0, 8-i) {
            carry  += s[i+j] + (u64)x[i] * k[j];
            s[i+j]  = (u32)carry;
            carry >>= 32;
        }
    }
    u32 t[16] = {0};
    multiply(t, s, L);

    // t = t + x
    u64 carry = 0;
    FOR (i, 0, 16) {
        carry  += (u64)t[i] + x[i];
        t[i]    = (u32)carry;
        carry >>= 32;
    }

    // u = (t / 2^256) % L
    // Note that t / 2^256 is always below 2*L,
    // So a constant time conditional subtraction is enough
    remove_l(u, t+8);

    WIPE_BUFFER(s);
    WIPE_BUFFER(t);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rax
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
pushq $0x20
popq %rcx
xorl %edx, %edx
leaq 0x4865(%rip), %rsi      # 0xcee0
cmpq $0x8, %rdx
je 0x86bf
xorl %edi, %edi
xorl %r8d, %r8d
cmpq %rdi, %rcx
je 0x86b2
movl (%rax,%rdi), %r9d
addq %r9, %r8
movl (%r14,%rdx,4), %r9d
movl (%rdi,%rsi), %r10d
imulq %r9, %r10
addq %r8, %r10
movl %r10d, (%rax,%rdi)
shrq $0x20, %r10
addq $0x4, %rdi
movq %r10, %r8
jmp 0x8686
incq %rdx
addq $-0x4, %rcx
addq $0x4, %rax
jmp 0x867b
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rdi
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
leaq 0x4323(%rip), %rdx      # 0xca00
movq %rsp, %rsi
callq 0x860a
xorl %ecx, %ecx
xorl %eax, %eax
cmpq $0x10, %rax
je 0x870d
movl 0x20(%rsp,%rax,4), %edx
addq %rdx, %rcx
movl (%r14,%rax,4), %edx
addq %rcx, %rdx
movl %edx, 0x20(%rsp,%rax,4)
shrq $0x20, %rdx
incq %rax
movq %rdx, %rcx
jmp 0x86e9
leaq 0x40(%rsp), %rsi
movq %rbx, %rdi
callq 0x911e
movq %rsp, %rdi
pushq $0x20
popq %rsi
callq 0x25a4
leaq 0x20(%rsp), %rdi
pushq $0x40
popq %rsi
callq 0x25a4
addq $0x68, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/occivink[P]pyct/monocypher.cpp
// 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)
{
    u8 sub_key[32];
    u8 auth_key[64]; // "Wasting" the whole Chacha block is faster
    crypto_hchacha20(sub_key, key, nonce);
    crypto_chacha20(auth_key, 0, 64, sub_key, nonce + 16);
    crypto_chacha20_ctr(cipher_text, plain_text, text_size,
                        sub_key, nonce + 16, 1);
    lock_auth(mac, auth_key, ad, ad_size, cipher_text, text_size);
    WIPE_BUFFER(sub_key);
    WIPE_BUFFER(auth_key);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %r9, 0x8(%rsp)
movq %r8, %r14
movq %rcx, %rbx
movq %rsi, %r12
movq %rdi, %rbp
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x25b5
addq $0x10, %rbx
leaq 0x30(%rsp), %r13
pushq $0x40
popq %rdx
movq %r13, %rdi
xorl %esi, %esi
movq %r15, %rcx
movq %rbx, %r8
callq 0x2a83
pushq $0x1
popq %r9
movq %r12, %rdi
movq 0xb0(%rsp), %rsi
movq 0xb8(%rsp), %rdx
movq %r15, %rcx
movq %rbx, %r8
callq 0x2890
movq %rbp, %rdi
movq %r13, %rsi
movq %r14, %rdx
movq 0x8(%rsp), %rcx
movq %r12, %r8
movq 0xb8(%rsp), %r9
callq 0x87ed
pushq $0x20
popq %rsi
movq %r15, %rdi
callq 0x25a4
movq %r13, %rdi
pushq $0x40
popq %rsi
callq 0x25a4
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/occivink[P]pyct/monocypher.cpp
// Function: lock_auth(unsigned char*, unsigned char const*, unsigned char const*, unsigned long, unsigned char const*, unsigned long)
static void lock_auth(u8 mac[16], const u8  auth_key[32],
                      const u8 *ad         , size_t ad_size,
                      const u8 *cipher_text, size_t text_size)
{
    u8 sizes[16]; // Not secret, not wiped
    store64_le(sizes + 0, ad_size);
    store64_le(sizes + 8, text_size);
    crypto_poly1305_ctx poly_ctx;           // auto wiped...
    crypto_poly1305_init  (&poly_ctx, auth_key);
    crypto_poly1305_update(&poly_ctx, ad         , ad_size);
    crypto_poly1305_update(&poly_ctx, zero       , align(ad_size, 16));
    crypto_poly1305_update(&poly_ctx, cipher_text, text_size);
    crypto_poly1305_update(&poly_ctx, zero       , align(text_size, 16));
    crypto_poly1305_update(&poly_ctx, sizes      , 16);
    crypto_poly1305_final (&poly_ctx, mac); // ...here
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %r13
movq %r8, %r12
movq %rcx, %rbx
movq %rdi, 0x8(%rsp)
leaq 0x10(%rsp), %r14
movb %bl, (%r14)
movb %bh, 0x11(%rsp)
movl %ebx, %eax
shrl $0x10, %eax
movb %al, 0x2(%r14)
movl %ebx, %eax
shrl $0x18, %eax
movb %al, 0x3(%r14)
movq %rcx, %rax
shrq $0x20, %rax
movb %al, 0x4(%r14)
movq %rcx, %rax
shrq $0x28, %rax
movb %al, 0x5(%r14)
movq %rcx, %rax
shrq $0x30, %rax
movb %al, 0x6(%r14)
movq %rcx, %rax
shrq $0x38, %rax
movb %al, 0x7(%r14)
movq %r9, %rcx
movb %cl, 0x8(%r14)
movb %ch, 0x19(%rsp)
movl %ecx, %eax
shrl $0x10, %eax
movb %al, 0xa(%r14)
movl %ecx, %eax
shrl $0x18, %eax
movb %al, 0xb(%r14)
movq %r9, %rax
shrq $0x20, %rax
movb %al, 0xc(%r14)
movq %r9, %rax
shrq $0x28, %rax
movb %al, 0xd(%r14)
movq %r9, %rax
shrq $0x30, %rax
movb %al, 0xe(%r14)
movq %r9, %rax
movq %r9, %r15
shrq $0x38, %rax
movb %al, 0xf(%r14)
leaq 0x28(%rsp), %rbp
movq %rbp, %rdi
callq 0x2a9b
movq %rbp, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x2b01
negl %ebx
andl $0xf, %ebx
leaq 0x375a(%rip), %r13      # 0xc020
movq %rbp, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x2b01
movq %rbp, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x2b01
negl %r15d
andl $0xf, %r15d
movq %rbp, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x2b01
pushq $0x10
popq %rdx
movq %rbp, %rdi
movq %r14, %rsi
callq 0x2b01
movq %rbp, %rdi
movq 0x8(%rsp), %rsi
callq 0x2d63
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/occivink[P]pyct/monocypher.cpp
// 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)
{
    u8 sub_key[32];
    u8 auth_key[64]; // "Wasting" the whole Chacha block is faster
    crypto_hchacha20(sub_key, key, nonce);
    crypto_chacha20(auth_key, 0, 64, sub_key, nonce + 16);
    u8 real_mac[16];
    lock_auth(real_mac, auth_key, ad, ad_size, cipher_text, text_size);
    WIPE_BUFFER(auth_key);
    int mismatch = crypto_verify16(mac, real_mac);
    if (!mismatch) {
        crypto_chacha20_ctr(plain_text, cipher_text, text_size,
                            sub_key, nonce + 16, 1);
    }
    WIPE_BUFFER(sub_key);
    WIPE_BUFFER(real_mac);
    return mismatch;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %r9, %rbp
movq %r8, %r14
movq %rcx, 0x8(%rsp)
movq %rdx, %rbx
movq %rdi, (%rsp)
leaq 0x20(%rsp), %r12
movq %r12, %rdi
callq 0x25b5
addq $0x10, %rbx
leaq 0x40(%rsp), %r15
pushq $0x40
popq %r13
movq %r15, %rdi
xorl %esi, %esi
movq %r13, %rdx
movq %r12, %rcx
movq %rbx, %r8
callq 0x2a83
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq 0xc8(%rsp), %r14
movq %rbp, %rcx
movq 0xc0(%rsp), %r8
movq %r14, %r9
callq 0x87ed
movq %r15, %rdi
movq %r13, %rsi
callq 0x25a4
movq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x24ec
movl %eax, %ebp
testl %eax, %eax
jne 0x89d8
leaq 0x20(%rsp), %rcx
pushq $0x1
popq %r9
movq (%rsp), %rdi
movq 0xc0(%rsp), %rsi
movq %r14, %rdx
movq %rbx, %r8
callq 0x2890
leaq 0x20(%rsp), %rdi
pushq $0x20
popq %rsi
callq 0x25a4
leaq 0x10(%rsp), %rdi
pushq $0x10
popq %rsi
callq 0x25a4
movl %ebp, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/occivink[P]pyct/monocypher.cpp
// Function: gidx_refresh(gidx_ctx*)
static void gidx_refresh(gidx_ctx *ctx)
{
    // seed the beginning 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;
    ZERO(ctx->b.a + 7, 121); // ...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.
    block tmp;
    copy_block(&tmp, &ctx->b);
    g_rounds  (&ctx->b);
    xor_block (&ctx->b, &tmp);
    copy_block(&tmp, &ctx->b);
    g_rounds  (&ctx->b);
    xor_block (&ctx->b, &tmp);
    wipe_block(&tmp);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movq %rdi, %rbx
movl 0x400(%rdi), %eax
movl 0x40c(%rdi), %ecx
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movsd 0x404(%rdi), %xmm0
xorps %xmm1, %xmm1
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movups %xmm0, 0x10(%rdi)
movq %rcx, 0x20(%rdi)
movq $0x1, 0x28(%rdi)
movl 0x410(%rdi), %eax
movq %rax, 0x30(%rdi)
pushq $0x7
popq %rax
cmpq $0x80, %rax
je 0x8a9a
andq $0x0, (%rbx,%rax,8)
incq %rax
jmp 0x8a88
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4d76
movq %rbx, %rdi
callq 0x4da6
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4d8e
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4d76
movq %rbx, %rdi
callq 0x4da6
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4d8e
movq %r14, %rdi
callq 0x5727
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/occivink[P]pyct/monocypher.cpp
// Function: fe_cswap(int*, int*, int)
static void fe_cswap(fe f, fe g, int b)
{
    i32 mask = -b; // -1 = 0xffffffff
    FOR (i, 0, 10) {
        i32 x = (f[i] ^ g[i]) & mask;
        f[i] = f[i] ^ x;
        g[i] = g[i] ^ x;
    }
}

// Assembly:
negl %edx
xorl %eax, %eax
cmpq $0xa, %rax
je 0x8b53
movl (%rdi,%rax,4), %ecx
movl (%rsi,%rax,4), %r8d
xorl %ecx, %r8d
andl %edx, %r8d
xorl %r8d, %ecx
movl %ecx, (%rdi,%rax,4)
xorl %r8d, (%rsi,%rax,4)
incq %rax
jmp 0x8b31
retq
// File: /workspace/github_cpp_makefile_star2_O2/occivink[P]pyct/monocypher.cpp
// Function: ge_zero(ge*)
static void ge_zero(ge *p)
{
    fe_0(p->X);
    fe_1(p->Y);
    fe_1(p->Z);
    fe_0(p->T);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x8b07
leaq 0x28(%rbx), %rdi
callq 0x8aee
leaq 0x50(%rbx), %rdi
callq 0x8aee
addq $0x78, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x8b07
// File: /workspace/github_cpp_makefile_star2_O2/occivink[P]pyct/monocypher.cpp
// Function: lookup_add(ge*, ge_precomp*, int*, int*, ge_precomp const*, unsigned char const*, int)
static void lookup_add(ge *p, ge_precomp *tmp_c, fe tmp_a, fe tmp_b,
                       const ge_precomp comb[8], const u8 scalar[32], int i)
{
    u8 teeth = (u8)((scalar_bit(scalar, i)          ) +
                    (scalar_bit(scalar, i + 32) << 1) +
                    (scalar_bit(scalar, i + 64) << 2) +
                    (scalar_bit(scalar, i + 96) << 3));
    u8 high  = teeth >> 3;
    u8 index = (teeth ^ (high - 1)) & 7;
    FOR (j, 0, 8) {
        i32 select = 1 & (((j ^ index) - 1) >> 8);
        fe_ccopy(tmp_c->Yp, comb[j].Yp, select);
        fe_ccopy(tmp_c->Ym, comb[j].Ym, select);
        fe_ccopy(tmp_c->T2, comb[j].T2, select);
    }
    fe_neg(tmp_a, tmp_c->T2);
    fe_cswap(tmp_c->T2, tmp_a    , high ^ 1);
    fe_cswap(tmp_c->Yp, tmp_c->Ym, high ^ 1);
    ge_madd(p, p, tmp_c, tmp_a, tmp_b);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r13
movq %rcx, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rsi, (%rsp)
movq %rdi, 0x10(%rsp)
movl 0x60(%rsp), %eax
testl %eax, %eax
js 0x8bbe
movl %eax, %ecx
shrl $0x3, %ecx
movzbl (%r9,%rcx), %ecx
movl %eax, %esi
andl $0x7, %esi
xorl %edx, %edx
btl %esi, %ecx
setb %dl
jmp 0x8bda
xorl %edx, %edx
cmpl $-0x20, %eax
jae 0x8bda
xorl %edx, %edx
cmpl $-0x40, %eax
jae 0x8bf2
xorl %ecx, %ecx
movl $0x0, %esi
cmpl $-0x60, %eax
jae 0x8c0a
jmp 0x8c21
leal 0x20(%rax), %ecx
shrl $0x3, %ecx
movzbl (%r9,%rcx), %esi
movl %eax, %ecx
andb $0x7, %cl
shrl %cl, %esi
andl $0x1, %esi
leal (%rdx,%rsi,2), %edx
leal 0x40(%rax), %ecx
shrl $0x3, %ecx
movzbl (%r9,%rcx), %esi
movl %eax, %ecx
andb $0x7, %cl
shrl %cl, %esi
andl $0x1, %esi
leal (%rdx,%rsi,4), %ecx
leal 0x60(%rax), %edx
shrl $0x3, %edx
movzbl (%r9,%rdx), %edx
andl $0x7, %eax
xorl %esi, %esi
btl %eax, %edx
setb %sil
movq %rsi, 0x8(%rsp)
leal -0x1(%rsi), %ebp
andl $0x7, %ebp
xorl %ecx, %ebp
movq (%rsp), %rax
leaq 0x28(%rax), %rbx
leaq 0x50(%rax), %r12
xorl %r15d, %r15d
cmpq $0x8, %r15
je 0x8c8a
movl %ebp, %r14d
xorl %r15d, %r14d
decl %r14d
shrl $0x8, %r14d
andl $0x1, %r14d
movq (%rsp), %rdi
movq %r13, %rsi
movl %r14d, %edx
callq 0x7eb4
leaq 0x28(%r13), %rsi
movq %rbx, %rdi
movl %r14d, %edx
callq 0x7eb4
leaq 0x50(%r13), %rsi
movq %r12, %rdi
movl %r14d, %edx
callq 0x7eb4
incq %r15
addq $0x78, %r13
jmp 0x8c3d
movq 0x18(%rsp), %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x7ed8
movq 0x8(%rsp), %r13
xorl $0x1, %r13d
movq %r12, %rdi
movq %r14, %rsi
movl %r13d, %edx
callq 0x8b2d
movq (%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
movl %r13d, %edx
callq 0x8b2d
movq 0x10(%rsp), %rdi
movq %rdi, %rsi
movq %r15, %rdx
movq %r14, %rcx
movq 0x20(%rsp), %r8
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x71e2
// File: /workspace/github_cpp_makefile_star2_O2/occivink[P]pyct/monocypher.cpp
// Function: ge_double(ge*, ge const*, ge*)
static void ge_double(ge *s, const ge *p, ge *q)
{
    fe_sq (q->X, p->X);
    fe_sq (q->Y, p->Y);
    fe_sq (q->Z, p->Z);          // qZ = pZ^2
    fe_mul_small(q->Z, q->Z, 2); // qZ = pZ^2 * 2
    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, %rbp
movq %rdi, %r14
movq %rdx, %rdi
callq 0x76c3
leaq 0x28(%rbx), %r15
leaq 0x28(%rbp), %rsi
movq %rsi, (%rsp)
movq %r15, %rdi
callq 0x76c3
leaq 0x50(%rbx), %r12
leaq 0x50(%rbp), %rsi
movq %r12, %rdi
callq 0x76c3
pushq $0x2
popq %rdx
movq %r12, %rdi
movq %r12, %rsi
callq 0x8003
leaq 0x78(%rbx), %r13
movq %r13, %rdi
movq %rbp, %rsi
movq (%rsp), %rdx
callq 0x6524
leaq 0x78(%r14), %rbp
movq %rbp, %rdi
movq %r13, %rsi
callq 0x76c3
movq %r13, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x6524
movq %r15, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x653b
movq %rbx, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x653b
movq %r12, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x653b
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x65a5
leaq 0x28(%r14), %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x65a5
addq $0x50, %r14
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x65a5
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 0x65a5
// File: /workspace/github_cpp_makefile_star2_O2/occivink[P]pyct/monocypher.cpp
// Function: ge_cache(ge_cached*, ge const*)
static void ge_cache(ge_cached *c, const ge *p)
{
    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:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x28(%rsi), %r15
movq %r15, %rsi
movq %rbx, %rdx
callq 0x6524
leaq 0x28(%r14), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x653b
leaq 0x50(%r14), %rdi
leaq 0x50(%rbx), %rsi
callq 0x8b19
addq $0x78, %r14
addq $0x78, %rbx
leaq 0x338f(%rip), %rdx      # 0xc1b0
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x65a5
// File: /workspace/github_cpp_makefile_star2_O2/occivink[P]pyct/monocypher.cpp
// Function: ge_add(ge*, ge const*, ge_cached const*)
static void ge_add(ge *s, const ge *p, const ge_cached *q)
{
    fe a, b;
    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, %r12
movq %rsi, %rbp
movq %rdi, %r15
leaq 0x28(%rsi), %rbx
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
callq 0x6524
movq %rsp, %r13
movq %r13, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
callq 0x653b
movq %r14, %rbx
movq %r14, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x65a5
leaq 0x28(%r12), %rdx
movq %r13, %r14
movq %r13, %rdi
movq %r13, %rsi
callq 0x65a5
leaq 0x28(%r15), %r13
movq %r13, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x6524
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x653b
leaq 0x50(%r15), %rbx
leaq 0x50(%rbp), %rdx
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x6524
leaq 0x50(%r12), %rdx
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x65a5
leaq 0x78(%r15), %r14
addq $0x78, %rbp
addq $0x78, %r12
movq %r14, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x65a5
leaq 0x30(%rsp), %rbp
movq %rbp, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x6524
movq %rsp, %r12
movq %r12, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x653b
movq %r14, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x65a5
movq %r15, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x65a5
movq %r13, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x65a5
movq %rbx, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x65a5
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/occivink[P]pyct/monocypher.cpp
// Function: slide_step(slide_ctx*, int, int, unsigned char const*)
static int slide_step(slide_ctx *ctx, int width, int i, const u8 scalar[32])
{
    if (i == ctx->next_check) {
        if (scalar_bit(scalar, i) == scalar_bit(scalar, i - 1)) {
            ctx->next_check--;
        } else {
            // compute digit of next window
            int w = MIN(width, i + 1);
            int v = -(scalar_bit(scalar, i) << (w-1));
            FOR_T (int, j, 0, w-1) {
                v += scalar_bit(scalar, i-(w-1)+j) << j;
            }
            v += scalar_bit(scalar, i-w);
            int lsb = v & (~v + 1);            // smallest bit of v
            int s   = (   ((lsb & 0xAA) != 0)  // log2(lsb)
                       | (((lsb & 0xCC) != 0) << 1)
                       | (((lsb & 0xF0) != 0) << 2));
            ctx->next_index  = (i16)(i-(w-1)+s);
            ctx->next_digit  = (i8) (v >> s   );
            ctx->next_check -= (u8) w;
        }
    }
    return i == ctx->next_index ? ctx->next_digit: 0;
}

// Assembly:
movzbl 0x3(%rdi), %r9d
cmpl %edx, %r9d
jne 0x90ad
movq %rcx, %rax
movl %edx, %ecx
shrl $0x3, %ecx
movzbl (%rax,%rcx), %ecx
movl %edx, %r8d
andl $0x7, %r8d
xorl %r10d, %r10d
btl %r8d, %ecx
setb %r10b
testl %edx, %edx
je 0x8fda
leal -0x1(%rdx), %r8d
movl %r8d, %ecx
shrl $0x3, %ecx
movzbl (%rax,%rcx), %r11d
andl $0x7, %r8d
xorl %ecx, %ecx
btl %r8d, %r11d
setb %cl
jmp 0x8fdc
xorl %ecx, %ecx
cmpl %ecx, %r10d
jne 0x8fe9
decb %r9b
jmp 0x90a9
pushq %rbp
pushq %r14
pushq %rbx
leal 0x1(%rdx), %ecx
cmpl %esi, %ecx
cmovll %ecx, %esi
leal -0x1(%rsi), %r8d
movl %r8d, %ecx
shll %cl, %r10d
negl %r10d
movl %edx, %r11d
subl %r8d, %r11d
xorl %ecx, %ecx
testl %r8d, %r8d
cmovlel %ecx, %r8d
cmpl %ecx, %r8d
je 0x9040
movl %r11d, %ebp
addl %ecx, %ebp
js 0x9035
movl %ebp, %ebx
shrl $0x3, %ebx
movzbl (%rax,%rbx), %r14d
andl $0x7, %ebp
xorl %ebx, %ebx
btl %ebp, %r14d
setb %bl
jmp 0x9037
xorl %ebx, %ebx
shll %cl, %ebx
addl %ebx, %r10d
incl %ecx
jmp 0x9011
movl %edx, %r8d
subl %esi, %r8d
popq %rbx
popq %r14
popq %rbp
js 0x9068
movl %r8d, %ecx
shrl $0x3, %ecx
movzbl (%rax,%rcx), %ecx
movl %r8d, %r11d
andl $0x7, %r11d
xorl %eax, %eax
btl %r11d, %ecx
setb %al
jmp 0x906a
xorl %eax, %eax
addl %r10d, %eax
movl %eax, %ecx
negl %ecx
andl %eax, %ecx
xorl %r10d, %r10d
testb $-0x56, %cl
setne %r10b
xorl %r11d, %r11d
testb $-0x34, %cl
setne %r11b
leal (%r10,%r11,2), %r10d
xorl %r11d, %r11d
testb $-0x10, %cl
setne %r11b
leal (%r10,%r11,4), %ecx
sarl %cl, %eax
addl %r8d, %ecx
incl %ecx
movw %cx, (%rdi)
movb %al, 0x2(%rdi)
subb %sil, %r9b
movb %r9b, 0x3(%rdi)
movswl (%rdi), %ecx
xorl %eax, %eax
cmpl %edx, %ecx
jne 0x90ba
movsbl 0x2(%rdi), %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/occivink[P]pyct/monocypher.cpp
// Function: fe_isequal(int const*, int const*)
static int fe_isequal(const fe f, const fe g)
{
    u8 fs[32];
    u8 gs[32];
    fe_tobytes(fs, f);
    fe_tobytes(gs, g);
    int isdifferent = crypto_verify32(fs, gs);
    WIPE_BUFFER(fs);
    WIPE_BUFFER(gs);
    return 1 + isdifferent;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %rsi
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x6d90
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x6d90
movq %r14, %rdi
movq %r15, %rsi
callq 0x2514
movl %eax, %ebx
pushq $0x20
popq %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x25a4
movq %r15, %rdi
movq %r12, %rsi
callq 0x25a4
incl %ebx
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq