LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/msotoodeh[P]asymmetric-passwords/common/curve25519/ed25519_sign.c
// Function: ed25519_Blinding_Init
void *ed25519_Blinding_Init(
    void *context,                      /* IO: null or ptr blinding context */
    const unsigned char *seed,          /* IN: [size bytes] random blinding seed */
    size_t size)                        /* IN: size of blinding seed */
{
    struct {
        Ext_POINT T;
        U_WORD t[K_WORDS];
        SHA512_CTX H;
        U8 digest[SHA512_DIGEST_LENGTH];
    } d;

    EDP_BLINDING_CTX *ctx = (EDP_BLINDING_CTX*)context;

    if (ctx == 0)
    {
        ctx = (EDP_BLINDING_CTX*)mem_alloc(sizeof(EDP_BLINDING_CTX));
        if (ctx == 0) return 0;
    }

    /* Use edp_custom_blinding to protect generation of the new blinder */

    SHA512_Init(&d.H);
    SHA512_Update(&d.H, edp_custom_blinding.zr, 32);
    SHA512_Update(&d.H, seed, size);
    SHA512_Final(d.digest, &d.H);

    ecp_BytesToWords(ctx->zr, d.digest+32);
    ecp_BytesToWords(d.t, d.digest);
    eco_Mod(d.t);
    ecp_Sub(ctx->bl, _w_BPO, d.t);

    eco_AddReduce(d.t, d.t, edp_custom_blinding.bl);
    edp_BasePointMult(&d.T, d.t, edp_custom_blinding.zr);
    edp_AddPoint(&d.T, &d.T, &edp_custom_blinding.BP);

    edp_ExtPoint2PE(&ctx->BP, &d.T);

    /* clear potentially sensitive data */
    mem_clear (&d, sizeof(d));

    return ctx;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x406dff
movl $0xc0, %edi
callq 0x4e62b0
movq %rax, %rbx
testq %rax, %rax
je 0x406edd
leaq 0xa0(%rsp), %rbp
movq %rbp, %rdi
callq 0x407abc
movq $0x5ea2d8, %r14         # imm = 0x5EA2D8
leaq 0x20(%r14), %r15
pushq $0x20
popq %rdx
movq %rbp, %rdi
movq %r15, %rsi
callq 0x409252
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x409252
leaq 0x178(%rsp), %r12
movq %r12, %rdi
movq %rbp, %rsi
callq 0x407b44
leaq 0x20(%rbx), %rdi
leaq 0x198(%rsp), %rsi
callq 0x40a2d7
leaq 0x80(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x40a2d7
movq %r13, %rdi
callq 0x40a19c
movq $0x57fbe0, %rsi         # imm = 0x57FBE0
addq $0x20, %rsi
movq %rbx, %rdi
movq %r13, %rdx
callq 0x4094fd
movq %r13, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x40a1dc
movq %rsp, %r12
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x406be2
addq $0x40, %r14
movq %r12, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x407457
leaq 0x40(%rbx), %rdi
movq %r12, %rsi
callq 0x406d72
movq %rbx, %rax
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %ebx, %ebx
jmp 0x406ec8
// File: /workspace/github_cpp_makefile_star2_O2/msotoodeh[P]asymmetric-passwords/common/curve25519/ed25519_sign.c
// Function: ed25519_CreateKeyPair
void ed25519_CreateKeyPair(
    unsigned char *pubKey,              /* OUT: public key */
    unsigned char *privKey,             /* OUT: private key */
    const void *blinding,               /* IN: [optional] null or blinding context */
    const unsigned char *sk)            /* IN: secret key (32 bytes) */
{
    U8 md[SHA512_DIGEST_LENGTH];
    U_WORD t[K_WORDS];
    SHA512_CTX H;
    Affine_POINT Q;

    /* [a:b] = H(sk) */
    SHA512_Init(&H);
    SHA512_Update(&H, sk, 32);
    SHA512_Final(md, &H);
    ecp_TrimSecretKey(md);

    ecp_BytesToWords(t, md);
    edp_BasePointMultiply(&Q, t, blinding);
    ed25519_PackPoint(pubKey, Q.y, Q.x[0]);

    memcpy(privKey, sk, 32);
    memcpy(privKey+32, pubKey, 32);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x178, %rsp            # imm = 0x178
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xa0(%rsp), %r13
movq %r13, %rdi
callq 0x407abc
pushq $0x20
popq %rdx
movq %r13, %rdi
movq %r15, %rsi
callq 0x409252
leaq 0x60(%rsp), %rbp
movq %rbp, %rdi
movq %r13, %rsi
callq 0x407b44
movq %rbp, %rdi
callq 0x40a2ac
movq %rsp, %r13
movq %r13, %rdi
movq %rbp, %rsi
callq 0x40a2d7
leaq 0x20(%rsp), %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x406ccf
leaq 0x40(%rsp), %rsi
movl -0x20(%rsi), %edx
andl $0x1, %edx
movq %r14, %rdi
callq 0x40a306
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups %xmm0, (%rbx)
movups %xmm1, 0x10(%rbx)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm0, 0x20(%rbx)
movups %xmm1, 0x30(%rbx)
addq $0x178, %rsp            # imm = 0x178
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/msotoodeh[P]asymmetric-passwords/common/curve25519/ed25519_verify.c
// Function: ed25519_CalculateX
void ed25519_CalculateX(OUT U_WORD *X, IN const U_WORD *Y, U_WORD parity)
{
    U_WORD u[K_WORDS], v[K_WORDS], a[K_WORDS], b[K_WORDS];

    /* Calculate sqrt((y^2 - 1)/(d*y^2 + 1)) */

    ecp_SqrReduce(u, Y);            /* u = y^2 */
    ecp_MulReduce(v, u, _w_d);      /* v = dy^2 */
    ecp_SubReduce(u, u, _w_One);    /* u = y^2-1 */
    ecp_AddReduce(v, v, _w_One);    /* v = dy^2+1 */

    /* Calculate:  sqrt(u/v) = u*v^3 * (u*v^7)^((p-5)/8) */

    ecp_SqrReduce(b, v);
    ecp_MulReduce(a, u, b);
    ecp_MulReduce(a, a, v);         /* a = u*v^3 */
    ecp_SqrReduce(b, b);            /* b = v^4 */
    ecp_MulReduce(b, a, b);         /* b = u*v^7 */
    ecp_ModExp2523(b, b);
    ecp_MulReduce(X, b, a);

    /* Check if we have correct sqrt, else, multiply by sqrt(-1) */

    ecp_SqrReduce(b, X);
    ecp_MulReduce(b, b, v);
    ecp_SubReduce(b, b, u);
    ecp_Mod(b);
    if (ecp_CmpNE(b, _w_Zero)) ecp_MulReduce(X, X, _w_I);

    while (ecp_CmpLT(X, _w_P) == 0) ecp_Sub(X, X, _w_P);

    /* match parity */
    if (((X[0] ^ parity) & 1) != 0)
        ecp_Sub(X, _w_P, X);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movl %edx, 0xc(%rsp)
movq %rdi, %rbx
leaq 0x70(%rsp), %r14
movq %r14, %rdi
callq 0x409c66
leaq 0x178654(%rip), %rdx    # 0x57f7c0
leaq 0x50(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x4099e0
movq $0x5797a0, %r15         # imm = 0x5797A0
movq %r14, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x4096e8
movq %r12, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x409628
leaq 0x10(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x409c66
leaq 0x30(%rsp), %rbp
movq %rbp, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x4099e0
movq %rbp, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x4099e0
movq %r13, %rdi
movq %r13, %rsi
callq 0x409c66
movq %r13, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x4099e0
movq %r13, %rdi
movq %r13, %rsi
callq 0x4072aa
movq %rbx, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x4099e0
movq %r13, %rdi
movq %rbx, %rsi
callq 0x409c66
movq %r13, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x4099e0
movq %r13, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x4096e8
movq %r13, %rdi
callq 0x4097b2
addq $0x40, %r15
movq %r13, %rdi
movq %r15, %rsi
callq 0x4094b1
testl %eax, %eax
je 0x407256
leaq 0x178555(%rip), %rdx    # 0x57f7a0
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x4099e0
movq $0x57fba0, %r14         # imm = 0x57FBA0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4094e6
testl %eax, %eax
jne 0x40727c
movq %rbx, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x4094fd
jmp 0x40725d
movl 0xc(%rsp), %eax
xorl (%rbx), %eax
testb $0x1, %al
je 0x407298
movq $0x57fba0, %rsi         # imm = 0x57FBA0
movq %rbx, %rdi
movq %rbx, %rdx
callq 0x4094fd
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/msotoodeh[P]asymmetric-passwords/common/curve25519/ed25519_verify.c
// Function: ecp_ModExp2523
void ecp_ModExp2523(U_WORD *Y, const U_WORD *X)
{
    U_WORD x2[K_WORDS], x9[K_WORDS], x11[K_WORDS], x5[K_WORDS], x10[K_WORDS];
    U_WORD x20[K_WORDS], x50[K_WORDS], x100[K_WORDS], t[K_WORDS];

    ecp_SqrReduce(x2, X);                       /* 2 */
    ecp_SrqMulReduce(x9, x2, 2, X);             /* 9 */
    ecp_MulReduce(x11, x9, x2);                 /* 11 */
    ecp_SqrReduce(t, x11);                      /* 22 */
    ecp_MulReduce(x5, t, x9);                   /* 31 = 2^5 - 2^0 */
    ecp_SrqMulReduce(x10, x5, 5, x5);           /* 2^10 - 2^0 */
    ecp_SrqMulReduce(x20, x10, 10, x10);        /* 2^20 - 2^0 */
    ecp_SrqMulReduce(t, x20, 20, x20);          /* 2^40 - 2^0 */
    ecp_SrqMulReduce(x50, t, 10, x10);          /* 2^50 - 2^0 */
    ecp_SrqMulReduce(x100, x50, 50, x50);       /* 2^100 - 2^0 */
    ecp_SrqMulReduce(t, x100, 100, x100);       /* 2^200 - 2^0 */
    ecp_SrqMulReduce(t, t, 50, x50);            /* 2^250 - 2^0 */
    ecp_SqrReduce(t, t); ecp_SqrReduce(t, t);   /* 2^252 - 2^2 */
    ecp_MulReduce(Y, t, X);                     /* 2^252 - 3 */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x100(%rsp), %r15
movq %r15, %rdi
callq 0x409c66
leaq 0xe0(%rsp), %r12
pushq $0x2
popq %rdx
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rcx
callq 0x407412
leaq 0xc0(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x4099e0
movq %rsp, %r15
movq %r15, %rdi
movq %r13, %rsi
callq 0x409c66
leaq 0xa0(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x4099e0
leaq 0x80(%rsp), %r12
pushq $0x5
popq %rdx
movq %r12, %rdi
movq %r13, %rsi
movq %r13, %rcx
callq 0x407412
leaq 0x60(%rsp), %r13
pushq $0xa
popq %rbp
movq %r13, %rdi
movq %r12, %rsi
movl %ebp, %edx
movq %r12, %rcx
callq 0x407412
pushq $0x14
popq %rdx
movq %r15, %rdi
movq %r13, %rsi
movq %r13, %rcx
callq 0x407412
leaq 0x40(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
movl %ebp, %edx
movq %r12, %rcx
callq 0x407412
leaq 0x20(%rsp), %r12
pushq $0x32
popq %rbp
movq %r12, %rdi
movq %r13, %rsi
movl %ebp, %edx
movq %r13, %rcx
callq 0x407412
pushq $0x64
popq %rdx
movq %r15, %rdi
movq %r12, %rsi
movq %r12, %rcx
callq 0x407412
movq %r15, %rdi
movq %r15, %rsi
movl %ebp, %edx
movq %r13, %rcx
callq 0x407412
movq %r15, %rdi
movq %r15, %rsi
callq 0x409c66
movq %r15, %rdi
movq %r15, %rsi
callq 0x409c66
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x4099e0
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/msotoodeh[P]asymmetric-passwords/common/curve25519/ed25519_verify.c
// Function: edp_AddPoint
void edp_AddPoint(Ext_POINT *r, const Ext_POINT *p, const PE_POINT *q)
{
    U_WORD a[K_WORDS], b[K_WORDS], c[K_WORDS], d[K_WORDS], e[K_WORDS];

    ecp_SubReduce(a, p->y, p->x);           /* A = (Y1-X1)*(Y2-X2) */
    ecp_MulReduce(a, a, q->YmX);
    ecp_AddReduce(b, p->y, p->x);           /* B = (Y1+X1)*(Y2+X2) */
    ecp_MulReduce(b, b, q->YpX);
    ecp_MulReduce(c, p->t, q->T2d);         /* C = T1*2d*T2 */
    ecp_MulReduce(d, p->z, q->Z2);          /* D = Z1*2*Z2 */
    ecp_SubReduce(e, b, a);                 /* E = B-A */
    ecp_AddReduce(b, b, a);                 /* H = B+A */
    ecp_SubReduce(a, d, c);                 /* F = D-C */
    ecp_AddReduce(d, d, c);                 /* G = D+C */

    ecp_MulReduce(r->x, e, a);              /* E*F */
    ecp_MulReduce(r->y, b, d);              /* H*G */
    ecp_MulReduce(r->t, e, b);              /* E*H */
    ecp_MulReduce(r->z, d, a);              /* G*F */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
leaq 0x20(%rsi), %r12
leaq 0x80(%rsp), %r14
movq %r14, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x4096e8
leaq 0x20(%r13), %rdx
movq %r14, %rdi
movq %r14, %rsi
callq 0x4099e0
leaq 0x60(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x409628
movq %r15, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x4099e0
leaq 0x60(%rbp), %rsi
leaq 0x40(%r13), %rdx
movq %rsp, %rdi
callq 0x4099e0
addq $0x40, %rbp
addq $0x60, %r13
leaq 0x40(%rsp), %r12
movq %r12, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x4099e0
leaq 0x20(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x4096e8
movq %r15, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x409628
movq %r14, %rdi
movq %r12, %rsi
movq %rsp, %rbp
movq %rbp, %rdx
callq 0x4096e8
movq %r12, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x409628
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x4099e0
leaq 0x20(%rbx), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x4099e0
leaq 0x60(%rbx), %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x4099e0
addq $0x40, %rbx
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x4099e0
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/msotoodeh[P]asymmetric-passwords/common/curve25519/sha512.c
// Function: SHA512_Final
void SHA512_Final (unsigned char *md, SHA512_CTX *c)
{
    unsigned char *p=(unsigned char *)c->u.p;
    size_t n=c->num;

    p[n]=0x80;  /* There always is a room for one */
    n++;
    if (n > (SHA512_CBLOCK-16))
        mem_fill (p+n,0,SHA512_CBLOCK-n), n=0,
        SHA512_Transform (c,p);

    mem_fill (p+n,0,SHA512_CBLOCK-16-n);
#ifdef  ECP_CONFIG_BIG_ENDIAN
    c->u.d[SHA_LBLOCK-2] = c->Nh;
    c->u.d[SHA_LBLOCK-1] = c->Nl;
#else
    p[SHA512_CBLOCK-1]  = (unsigned char)(c->Nl);
    p[SHA512_CBLOCK-2]  = (unsigned char)(c->Nl>>8);
    p[SHA512_CBLOCK-3]  = (unsigned char)(c->Nl>>16);
    p[SHA512_CBLOCK-4]  = (unsigned char)(c->Nl>>24);
    p[SHA512_CBLOCK-5]  = (unsigned char)(c->Nl>>32);
    p[SHA512_CBLOCK-6]  = (unsigned char)(c->Nl>>40);
    p[SHA512_CBLOCK-7]  = (unsigned char)(c->Nl>>48);
    p[SHA512_CBLOCK-8]  = (unsigned char)(c->Nl>>56);
    p[SHA512_CBLOCK-9]  = (unsigned char)(c->Nh);
    p[SHA512_CBLOCK-10] = (unsigned char)(c->Nh>>8);
    p[SHA512_CBLOCK-11] = (unsigned char)(c->Nh>>16);
    p[SHA512_CBLOCK-12] = (unsigned char)(c->Nh>>24);
    p[SHA512_CBLOCK-13] = (unsigned char)(c->Nh>>32);
    p[SHA512_CBLOCK-14] = (unsigned char)(c->Nh>>40);
    p[SHA512_CBLOCK-15] = (unsigned char)(c->Nh>>48);
    p[SHA512_CBLOCK-16] = (unsigned char)(c->Nh>>56);
#endif

    SHA512_Transform (c,p);

    if (md) for (n=0; n < SHA512_DIGEST_LENGTH/8; n++)
    {
        M64 m;
        m.u64 = c->h[n];
        *(md++) = m.u8.b7;
        *(md++) = m.u8.b6;
        *(md++) = m.u8.b5;
        *(md++) = m.u8.b4;
        *(md++) = m.u8.b3;
        *(md++) = m.u8.b2;
        *(md++) = m.u8.b1;
        *(md++) = m.u8.b0;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x50(%rsi), %r15
movl 0xd0(%rsi), %eax
leaq 0x1(%rax), %rdi
movb $-0x80, 0x50(%rsi,%rax)
cmpq $0x70, %rax
jb 0x407b85
addq %r15, %rdi
pushq $0x7f
popq %rdx
subq %rax, %rdx
xorl %esi, %esi
callq 0x401060
movq %rbx, %rdi
movq %r15, %rsi
callq 0x407be3
xorl %edi, %edi
leaq (%r15,%rdi), %rax
pushq $0x70
popq %rdx
subq %rdi, %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x401060
movq 0x40(%rbx), %rax
movq 0x48(%rbx), %rcx
bswapq %rax
movq %rax, 0xc8(%rbx)
bswapq %rcx
movq %rcx, 0xc0(%rbx)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x407be3
testq %r14, %r14
je 0x407bdd
xorl %eax, %eax
cmpq $0x8, %rax
je 0x407bdd
movq (%rbx,%rax,8), %rcx
bswapq %rcx
movq %rcx, (%r14,%rax,8)
incq %rax
jmp 0x407bc7
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/msotoodeh[P]asymmetric-passwords/common/curve25519/sha512.c
// Function: SHA512_Update
void SHA512_Update (SHA512_CTX *c, const void *_data, size_t len)
{
    SHA_LONG64 l;
    unsigned char *p=c->u.p;
    const unsigned char *data=(const unsigned char *)_data;

    if (len==0) return;

    l = (c->Nl+(((SHA_LONG64)len)<<3))&UINT64(0xffffffffffffffff);
    if (l < c->Nl) c->Nh++;
    if (sizeof(len)>=8) c->Nh+=(((SHA_LONG64)len)>>61);
    c->Nl=l;

    if (c->num != 0)
    {
        size_t n = SHA512_CBLOCK - c->num;

        if (len < n)
        {
            memcpy (p+c->num,data,len), c->num += (unsigned int)len;
            return;
        }
        else    
        {
            memcpy (p+c->num,data,n), c->num = 0;
            len-=n, data+=n;
            SHA512_Transform (c,p);
        }
    }

    while (len >= SHA512_CBLOCK)
    {
        SHA512_Transform (c,data);//,len/SHA512_CBLOCK),
        data += SHA512_CBLOCK;
        len  -= SHA512_CBLOCK;
    }

    if (len != 0)
        memcpy (p,data,len), c->num = (int)len;
}

// Assembly:
testq %rdx, %rdx
je 0x409329
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbx
leaq (,%rdx,8), %rax
movq %rdx, %rcx
shrq $0x3d, %rcx
addq %rax, 0x40(%rdi)
adcq %rcx, 0x48(%rdi)
leaq 0x50(%rdi), %r15
movl 0xd0(%rdi), %edi
testq %rdi, %rdi
je 0x4092bb
movl $0x80, %ebp
subl %edi, %ebp
addq %r15, %rdi
movq %r13, %r12
subq %rbp, %r12
jae 0x4092c0
movq %r14, %rsi
movq %r13, %rdx
callq 0x401110
addl 0xd0(%rbx), %r13d
jmp 0x409314
movq %r13, %r12
jmp 0x4092f5
movq %r14, %rsi
movq %rbp, %rdx
callq 0x401110
andl $0x0, 0xd0(%rbx)
addq %rbp, %r14
movq %rbx, %rdi
movq %r15, %rsi
callq 0x407be3
jmp 0x4092f5
movq %rbx, %rdi
movq %r14, %rsi
callq 0x407be3
subq $-0x80, %r14
addq $-0x80, %r12
cmpq $0x80, %r12
jae 0x4092e2
testq %r12, %r12
je 0x40931b
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x401110
movl %r12d, %r13d
movl %r13d, 0xd0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/msotoodeh[P]asymmetric-passwords/common/base64.cpp
// Function: B64Encode[abi:cxx11](void const*, unsigned long)
std::string B64Encode(const void* data, size_t size)
{
    uint32_t accu = 0, bits = 0;
    std::string os;
    for (size_t i = 0; i < size; i++) {
        accu = (accu << 8) | ((unsigned char*)data)[i];
        bits += 8;

        while (bits >= 6) {
            bits -= 6;
            os.append(1, bin_to_base64[(accu >> bits) & 0x3f]);
        }
    }
    if (bits > 0)
        os.append(1, bin_to_base64[(accu << (6 - bits)) & 0x3f]);
    return os;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rdx, -0x38(%rbp)
movq %rsi, -0x30(%rbp)
movb $0x0, 0x10(%rdi)
xorl %r15d, %r15d
leaq 0x1766fe(%rip), %r12    # 0x57fa60
pushq $0x1
popq %r13
xorl %r14d, %r14d
xorl %eax, %eax
cmpq -0x38(%rbp), %rax
je 0x4093be
movq %rax, %rdx
movl %r15d, %eax
shll $0x8, %eax
movq -0x30(%rbp), %rcx
movq %rdx, -0x40(%rbp)
movzbl (%rcx,%rdx), %r15d
orl %eax, %r15d
addl $0x8, %r14d
cmpl $0x6, %r14d
jb 0x4093b5
addl $-0x6, %r14d
movl %r15d, %eax
movl %r14d, %ecx
shrl %cl, %eax
andl $0x3f, %eax
movsbl (%rax,%r12), %edx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x477cc0
jmp 0x40938e
movq -0x40(%rbp), %rax
incq %rax
jmp 0x40936b
testl %r14d, %r14d
je 0x4093df
movb $0x6, %cl
subb %r14b, %cl
shll %cl, %r15d
andl $0x3f, %r15d
movsbl (%r15,%r12), %edx
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x477cc0
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4093f3
movq %rax, %r14
movq %rbx, %rdi
callq 0x477260
movq %r14, %rdi
callq 0x4a94e0
// File: /workspace/github_cpp_makefile_star2_O2/msotoodeh[P]asymmetric-passwords/common/base64.cpp
// Function: B64Decode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned char*, unsigned long)
size_t B64Decode(const std::string& b64String, unsigned char* buffer, size_t size)
{
    size_t i;
    uint32_t ch, accu = 0, bits = 0, index = 0;
    for (i = 0; i < size; i++) {
        while (bits < 8) {
            do {
                ch = base64_to_bin[b64String[index++] & 0xff];
            } while (ch == WS);     // ignore white spaces

            if (ch >= 64) return i; // TR is expected here

            accu = (accu << 6) | ch;
            bits += 6;
        }

        bits -= 8;
        *buffer++ = (unsigned char)(accu >> bits);
    }
    return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
movq %rdx, %rax
xorl %edx, %edx
leaq 0x176664(%rip), %r8     # 0x57faa0
xorl %r9d, %r9d
xorl %ecx, %ecx
xorl %r10d, %r10d
cmpq %rax, %rdx
je 0x40948e
movq (%rdi), %r11
cmpl $0x7, %ecx
ja 0x409477
movl %r10d, %ebx
incl %r10d
movzbl (%r11,%rbx), %ebx
movzbl (%rbx,%r8), %ebx
cmpl $0x40, %ebx
je 0x409451
cmpb $0x3f, %bl
ja 0x40948b
shll $0x6, %r9d
orl %ebx, %r9d
addl $0x6, %ecx
jmp 0x40944c
addl $-0x8, %ecx
movl %r9d, %r11d
shrl %cl, %r11d
movb %r11b, (%rsi)
incq %rsi
incq %rdx
jmp 0x409444
movq %rdx, %rax
popq %rbx
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/msotoodeh[P]asymmetric-passwords/common/curve25519/curve25519_mehdi.c
// Function: ecp_Mod
void ecp_Mod(U32 *X)
{
    U32 T[8];
    U32 c = (U32)ecp_Sub(X, X, _w_P);

    /* set T = 0 if c=0, else T = P */

    T[0] = c & 0xFFFFFFED;
    T[1] = T[2] = T[3] = T[4] = T[5] = T[6] = c;
    T[7] = c >> 1;

    ecp_Add(X, X, T);   /* X += 0 or P */

    /* In case there is another P there */

    c = (U32)ecp_Sub(X, X, _w_P);

    /* set T = 0 if c=0, else T = P */

    T[0] = c & 0xFFFFFFED;
    T[1] = T[2] = T[3] = T[4] = T[5] = T[6] = c;
    T[7] = c >> 1;

    ecp_Add(X, X, T);   /* X += 0 or P */
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x1763db(%rip), %r15    # 0x57fba0
movq %rdi, %rsi
movq %r15, %rdx
callq 0x4094fd
movl %eax, %ecx
andl $-0x13, %ecx
movq %rsp, %r14
movl %ecx, (%r14)
movl %eax, 0x18(%r14)
movl %eax, 0x14(%r14)
movd %eax, %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqu %xmm0, 0x4(%r14)
shrl %eax
movl %eax, 0x1c(%r14)
movq %rbx, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x409596
movq %rbx, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x4094fd
movl %eax, %ecx
andl $-0x13, %ecx
movl %ecx, (%r14)
movl %eax, 0x18(%r14)
movl %eax, 0x14(%r14)
movd %eax, %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqu %xmm0, 0x4(%r14)
shrl %eax
movl %eax, 0x1c(%r14)
movq %rbx, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x409596
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/msotoodeh[P]asymmetric-passwords/common/curve25519/curve25519_mehdi.c
// Function: ecp_MulReduce
void ecp_MulReduce(U32* Z, const U32* X, const U32* Y) 
{
    U32 T[16];

    ecp_mul_set(T+0, X[0], Y);
    ecp_mul_add(T+1, X[1], Y);
    ecp_mul_add(T+2, X[2], Y);
    ecp_mul_add(T+3, X[3], Y);
    ecp_mul_add(T+4, X[4], Y);
    ecp_mul_add(T+5, X[5], Y);
    ecp_mul_add(T+6, X[6], Y);
    ecp_mul_add(T+7, X[7], Y);

    /* We have T = X*Y, now do the reduction in size */

    ecp_WordMulAddReduce(Z, T, 38, T+8);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movl (%rsi), %esi
movq %rsp, %r14
movq %r14, %rdi
callq 0x409a9e
leaq 0x4(%rsp), %rdi
movl 0x4(%r12), %esi
movq %r15, %rdx
callq 0x409b21
leaq 0x8(%rsp), %rdi
movl 0x8(%r12), %esi
movq %r15, %rdx
callq 0x409b21
leaq 0xc(%rsp), %rdi
movl 0xc(%r12), %esi
movq %r15, %rdx
callq 0x409b21
leaq 0x10(%rsp), %rdi
movl 0x10(%r12), %esi
movq %r15, %rdx
callq 0x409b21
leaq 0x14(%rsp), %rdi
movl 0x14(%r12), %esi
movq %r15, %rdx
callq 0x409b21
leaq 0x18(%rsp), %rdi
movl 0x18(%r12), %esi
movq %r15, %rdx
callq 0x409b21
leaq 0x1c(%rsp), %rdi
movl 0x1c(%r12), %esi
movq %r15, %rdx
callq 0x409b21
leaq 0x20(%rsp), %rcx
pushq $0x26
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x409851
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/msotoodeh[P]asymmetric-passwords/common/curve25519/curve25519_mehdi.c
// Function: ecp_Mul
void ecp_Mul(U32* Z, const U32* X, const U32* Y) 
{
    ecp_mul_set(Z+0, X[0], Y);
    ecp_mul_add(Z+1, X[1], Y);
    ecp_mul_add(Z+2, X[2], Y);
    ecp_mul_add(Z+3, X[3], Y);
    ecp_mul_add(Z+4, X[4], Y);
    ecp_mul_add(Z+5, X[5], Y);
    ecp_mul_add(Z+6, X[6], Y);
    ecp_mul_add(Z+7, X[7], Y);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl (%rsi), %esi
callq 0x409a9e
leaq 0x4(%r15), %rdi
movl 0x4(%r14), %esi
movq %rbx, %rdx
callq 0x409b21
leaq 0x8(%r15), %rdi
movl 0x8(%r14), %esi
movq %rbx, %rdx
callq 0x409b21
leaq 0xc(%r15), %rdi
movl 0xc(%r14), %esi
movq %rbx, %rdx
callq 0x409b21
leaq 0x10(%r15), %rdi
movl 0x10(%r14), %esi
movq %rbx, %rdx
callq 0x409b21
leaq 0x14(%r15), %rdi
movl 0x14(%r14), %esi
movq %rbx, %rdx
callq 0x409b21
leaq 0x18(%r15), %rdi
movl 0x18(%r14), %esi
movq %rbx, %rdx
callq 0x409b21
addq $0x1c, %r15
movl 0x1c(%r14), %esi
movq %r15, %rdi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x409b21
// File: /workspace/github_cpp_makefile_star2_O2/msotoodeh[P]asymmetric-passwords/common/curve25519/curve25519_mehdi.c
// Function: ecp_SqrReduce
void ecp_SqrReduce(U32* Y, const U32* X) 
{
    /* TBD: Implementation is based on multiply */
    /*      Optimize for squaring */

    U32 T[16];

    ecp_mul_set(T+0, X[0], X);
    ecp_mul_add(T+1, X[1], X);
    ecp_mul_add(T+2, X[2], X);
    ecp_mul_add(T+3, X[3], X);
    ecp_mul_add(T+4, X[4], X);
    ecp_mul_add(T+5, X[5], X);
    ecp_mul_add(T+6, X[6], X);
    ecp_mul_add(T+7, X[7], X);

    /* We have T = X*X, now do the reduction in size */

    ecp_WordMulAddReduce(Y, T, 38, T+8);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movl (%rsi), %esi
movq %rsp, %r14
movq %r14, %rdi
movq %r15, %rdx
callq 0x409a9e
leaq 0x4(%rsp), %rdi
movl 0x4(%r15), %esi
movq %r15, %rdx
callq 0x409b21
leaq 0x8(%rsp), %rdi
movl 0x8(%r15), %esi
movq %r15, %rdx
callq 0x409b21
leaq 0xc(%rsp), %rdi
movl 0xc(%r15), %esi
movq %r15, %rdx
callq 0x409b21
leaq 0x10(%rsp), %rdi
movl 0x10(%r15), %esi
movq %r15, %rdx
callq 0x409b21
leaq 0x14(%rsp), %rdi
movl 0x14(%r15), %esi
movq %r15, %rdx
callq 0x409b21
leaq 0x18(%rsp), %rdi
movl 0x18(%r15), %esi
movq %r15, %rdx
callq 0x409b21
leaq 0x1c(%rsp), %rdi
movl 0x1c(%r15), %esi
movq %r15, %rdx
callq 0x409b21
leaq 0x20(%rsp), %rcx
pushq $0x26
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x409851
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/msotoodeh[P]asymmetric-passwords/common/curve25519/curve25519_order.c
// Function: eco_ReduceHiWord
void eco_ReduceHiWord(U32* Y, U32 b, const U32* X)
{
    M64 c;
    U32 T[8];

    /* Set T = b*(-R) */

    c.u64 = (U64)b*minusR_0;
    T[0] = c.u32.lo;
    c.u64 = (U64)b*minusR_1 + c.u32.hi;
    T[1] = c.u32.lo;
    c.u64 = (U64)b*minusR_2 + c.u32.hi;
    T[2] = c.u32.lo;
    c.u64 = (U64)b*minusR_3 + c.u32.hi;
    T[3] = c.u32.lo;
    c.u64 = (U64)b + c.u32.hi;
    T[4] = c.u32.lo;
    T[5] = c.u32.hi;
    T[6] = 0;
    T[7] = 0;

    /* Y = X - T */
    c.s32.hi = ecp_Sub(Y, X, T);

    /* Add BPO if there is a borrow */

    ecp_Add(Y, Y, _w_NxBPO[c.s32.hi & 1]);
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movl %esi, %ecx
movl $0x812631a5, %esi       # imm = 0x812631A5
leaq 0x4e370d2b(%rsi), %rdi
imulq %rcx, %rdi
movq %rsp, %rax
movl %edi, (%rax)
shrq $0x20, %rdi
imulq %rcx, %rsi
addq %rdi, %rsi
movl %esi, 0x4(%rax)
shrq $0x20, %rsi
imulq $0x2f79cd65, %rcx, %rdi # imm = 0x2F79CD65
addq %rsi, %rdi
movl %edi, 0x8(%rax)
shrq $0x20, %rdi
imulq $0x4def9dea, %rcx, %rsi # imm = 0x4DEF9DEA
addq %rdi, %rsi
movl %esi, 0xc(%rax)
shrq $0x20, %rsi
addq %rcx, %rsi
movl %esi, 0x10(%rax)
shrq $0x20, %rsi
movl %esi, 0x14(%rax)
andq $0x0, 0x18(%rax)
movq %rbx, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x4094fd
andl $0x1, %eax
shll $0x5, %eax
leaq 0x175afc(%rip), %rdx    # 0x57fbe0
addq %rax, %rdx
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x409596
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/msotoodeh[P]asymmetric-passwords/common/curve25519/curve25519_order.c
// Function: eco_MulReduce
void eco_MulReduce(OUT U32 *Z, IN const U32 *X, IN const U32 *Y)
{
    U32 T[16];
    ecp_Mul(T, X, Y);                 /* T = X*Y */
    eco_ReduceHiWord(T+7, T[15], T+7);
    eco_ReduceHiWord(T+6, T[14], T+6);
    eco_ReduceHiWord(T+5, T[13], T+5);
    eco_ReduceHiWord(T+4, T[12], T+4);
    eco_ReduceHiWord(T+3, T[11], T+3);
    eco_ReduceHiWord(T+2, T[10], T+2);
    eco_ReduceHiWord(T+1, T[9], T+1);
    eco_ReduceHiWord(Z, T[8], T+0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x409bd9
leaq 0x1c(%rsp), %rdi
movl 0x20(%rdi), %esi
movq %rdi, %rdx
callq 0x40a064
leaq 0x18(%rsp), %rdi
movl 0x20(%rdi), %esi
movq %rdi, %rdx
callq 0x40a064
leaq 0x14(%rsp), %rdi
movl 0x20(%rdi), %esi
movq %rdi, %rdx
callq 0x40a064
leaq 0x10(%rsp), %rdi
movl 0x20(%rdi), %esi
movq %rdi, %rdx
callq 0x40a064
leaq 0xc(%rsp), %rdi
movl 0x20(%rdi), %esi
movq %rdi, %rdx
callq 0x40a064
leaq 0x8(%rsp), %rdi
movl 0x20(%rdi), %esi
movq %rdi, %rdx
callq 0x40a064
leaq 0x4(%rsp), %r15
movl 0x20(%r15), %esi
movq %r15, %rdi
movq %r15, %rdx
callq 0x40a064
movl 0x1c(%r15), %esi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x40a064
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/msotoodeh[P]asymmetric-passwords/common/curve25519/curve25519_order.c
// Function: eco_DigestToWords
void eco_DigestToWords( OUT U32 *Y, IN const U8 *md)
{
    U32 T[16];

    /* We use digest value as little-endian byte array. */
    ecp_BytesToWords(T, md);
    ecp_BytesToWords(T+8, md+32);

    eco_ReduceHiWord(T+7, T[15], T+7);
    eco_ReduceHiWord(T+6, T[14], T+6);
    eco_ReduceHiWord(T+5, T[13], T+5);
    eco_ReduceHiWord(T+4, T[12], T+4);
    eco_ReduceHiWord(T+3, T[11], T+3);
    eco_ReduceHiWord(T+2, T[10], T+2);
    eco_ReduceHiWord(T+1, T[9], T+1);
    eco_ReduceHiWord(Y, T[8], T+0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x40a2d7
leaq 0x20(%rsp), %rdi
addq $0x20, %r15
movq %r15, %rsi
callq 0x40a2d7
leaq 0x1c(%rsp), %rdi
movl 0x20(%rdi), %esi
movq %rdi, %rdx
callq 0x40a064
leaq 0x18(%rsp), %rdi
movl 0x20(%rdi), %esi
movq %rdi, %rdx
callq 0x40a064
leaq 0x14(%rsp), %rdi
movl 0x20(%rdi), %esi
movq %rdi, %rdx
callq 0x40a064
leaq 0x10(%rsp), %rdi
movl 0x20(%rdi), %esi
movq %rdi, %rdx
callq 0x40a064
leaq 0xc(%rsp), %rdi
movl 0x20(%rdi), %esi
movq %rdi, %rdx
callq 0x40a064
leaq 0x8(%rsp), %rdi
movl 0x20(%rdi), %esi
movq %rdi, %rdx
callq 0x40a064
leaq 0x4(%rsp), %r15
movl 0x20(%r15), %esi
movq %r15, %rdi
movq %r15, %rdx
callq 0x40a064
movl 0x1c(%r15), %esi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x40a064
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/msotoodeh[P]asymmetric-passwords/common/curve25519/curve25519_utils.c
// Function: ecp_EncodeInt
U8* ecp_EncodeInt(OUT U8 *Y, IN const U32 *X, IN U8 parity)
{
    int i;
    M32 m;
    
    for (i = 0; i < 28;)
    {
        m.u32 = *X++;
        Y[i++] = m.u8.b0;
        Y[i++] = m.u8.b1;
        Y[i++] = m.u8.b2;
        Y[i++] = m.u8.b3;
    }

    m.u32 = *X;
    Y[28] = m.u8.b0;
    Y[29] = m.u8.b1;
    Y[30] = m.u8.b2;
    Y[31] = (U8)((m.u8.b3 & 0x7f) | (parity << 7));

    return Y;
}

// Assembly:
movq %rdi, %rax
xorl %ecx, %ecx
cmpq $0x1b, %rcx
ja 0x40a31d
movl (%rsi,%rcx), %edi
movl %edi, (%rax,%rcx)
addq $0x4, %rcx
jmp 0x40a30b
movl (%rsi,%rcx), %ecx
movl %ecx, %esi
movb %cl, 0x1c(%rax)
movb %ch, 0x1d(%rax)
shrl $0x10, %ecx
shrl $0x18, %esi
movb %cl, 0x1e(%rax)
andl $0x7f, %esi
movzbl %dl, %ecx
shll $0x7, %ecx
orl %esi, %ecx
movb %cl, 0x1f(%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O2/msotoodeh[P]asymmetric-passwords/common/curve25519/curve25519_utils.c
// Function: ecp_4Folds
void ecp_4Folds(U8* Y, const U32* X)
{
    int i, j;
    U8 a, b;
    for (i = 32; i-- > 0; Y++)
    {
        a = 0;
        b = 0;
        for (j = 8; j > 1;)
        {
            j -= 2;
            a = (a << 1) + ((X[j+1] >> i) & 1);
            b = (b << 1) + ((X[j] >> i) & 1);
        }
        Y[0] = a;
        Y[32] = b;
    }
}

// Assembly:
pushq %rbx
movl $0x20, %eax
movabsq $0x6, %rcx
subl $0x1, %eax
jb 0x40a3ed
xorl %r8d, %r8d
movq %rcx, %rdx
xorl %r9d, %r9d
cmpq $-0x2, %rdx
je 0x40a3e1
movzbl %r8b, %r8d
movl (%rsi,%rdx,4), %r10d
movl 0x4(%rsi,%rdx,4), %r11d
xorl %ebx, %ebx
btl %eax, %r11d
setb %bl
leal (%rbx,%r8,2), %r8d
movzbl %r9b, %r9d
xorl %r11d, %r11d
btl %eax, %r10d
setb %r11b
leal (%r11,%r9,2), %r9d
addq $-0x2, %rdx
jmp 0x40a3a8
movb %r8b, (%rdi)
movb %r9b, 0x20(%rdi)
incq %rdi
jmp 0x40a39a
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/msotoodeh[P]asymmetric-passwords/common/curve25519/curve25519_utils.c
// Function: ecp_8Folds
void ecp_8Folds(U8* Y, const U32* X)
{
    int i, j;
    U8 a = 0;
    for (i = 32; i-- > 0;)
    {
        for (j = 8; j-- > 0;) a = (a << 1) + ((X[j] >> i) & 1);
        *Y++ = a;
    }
}

// Assembly:
pushq $0x20
popq %rax
xorl %edx, %edx
pushq $0x7
popq %rcx
subl $0x1, %eax
jb 0x40a427
movq %rcx, %r8
cmpq $-0x1, %r8
je 0x40a420
movzbl %dl, %edx
movl (%rsi,%r8,4), %r9d
xorl %r10d, %r10d
btl %eax, %r9d
setb %r10b
leal (%r10,%rdx,2), %edx
decq %r8
jmp 0x40a3ff
movb %dl, (%rdi)
incq %rdi
jmp 0x40a3f7
retq
nopl (%rax,%rax)
// File: /workspace/github_cpp_makefile_star2_O2/calebstewart[P]md5/md5.cpp
// Function: MD5::update(void const*, unsigned long)
void MD5::update(const void* data, size_t size)
{
  unsigned long saved_lo;
  unsigned long used, free;

  saved_lo = this->lo;
  if ((this->lo = (saved_lo + size) & 0x1fffffff) < saved_lo) {
    this->hi++;
  }
  this->hi += size >> 29;

  used = saved_lo & 0x3f;

  if (used) {
    free = 64 - used;

    if (size < free) {
      memcpy(&this->buffer[used], data, size);
      return;
    }

    memcpy(&this->buffer[used], data, free);
    data = (unsigned char *)data + free;
    size -= free;
    this->process(this->buffer, 64);
  }

  if (size >= 64) {
    data = this->process(data, size & ~(size_t)0x3f);
    size &= 0x3f;
  }

  memcpy(this->buffer, data, size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
leal (%rax,%rdx), %ecx
andl $0x1fffffff, %ecx       # imm = 0x1FFFFFFF
movq %rcx, (%rdi)
movq %rdx, %rdi
shrq $0x1d, %rdi
cmpq %rax, %rcx
adcq %rdi, 0x8(%rbx)
movq %rsi, %r14
andq $0x3f, %rax
je 0x128f
pushq $0x40
popq %r12
subq %rax, %r12
movq %rdx, %r15
leaq (%rbx,%rax), %rdi
addq $0x30, %rdi
subq %r12, %r15
jae 0x1294
movq %r14, %rsi
jmp 0x12e0
movq %rdx, %r15
jmp 0x12b4
leaq 0x30(%rbx), %r13
movq %r14, %rsi
movq %r12, %rdx
callq 0x1040
addq %r12, %r14
pushq $0x40
popq %rdx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x12f4
cmpq $0x40, %r15
jb 0x12d3
movq %r15, %rdx
andq $-0x40, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x12f4
movq %rax, %r14
andl $0x3f, %r15d
addq $0x30, %rbx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1040
nop
// File: /workspace/github_cpp_makefile_star2_O2/calebstewart[P]md5/md5.cpp
// Function: MD5::finalize(unsigned char*)
void MD5::finalize(unsigned char *result)
{
  unsigned long used, free;

  used = this->lo & 0x3f;

  this->buffer[used++] = 0x80;

  free = 64 - used;

  if (free < 8) {
    memset(&this->buffer[used], 0, free);
    this->process(this->buffer, 64);
    used = 0;
    free = 64;
  }

  memset(&this->buffer[used], 0, free - 8);

  this->lo <<= 3;
  this->buffer[56] = this->lo;
  this->buffer[57] = this->lo >> 8;
  this->buffer[58] = this->lo >> 16;
  this->buffer[59] = this->lo >> 24;
  this->buffer[60] = this->hi;
  this->buffer[61] = this->hi >> 8;
  this->buffer[62] = this->hi >> 16;
  this->buffer[63] = this->hi >> 24;

  this->process(this->buffer, 64);

  result[0] = this->a;
  result[1] = this->a >> 8;
  result[2] = this->a >> 16;
  result[3] = this->a >> 24;
  result[4] = this->b;
  result[5] = this->b >> 8;
  result[6] = this->b >> 16;
  result[7] = this->b >> 24;
  result[8] = this->c;
  result[9] = this->c >> 8;
  result[10] = this->c >> 16;
  result[11] = this->c >> 24;
  result[12] = this->d;
  result[13] = this->d >> 8;
  result[14] = this->d >> 16;
  result[15] = this->d >> 24;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdx
andl $0x3f, %edx
leaq 0x30(%rdi), %r15
leaq 0x1(%rdx), %rdi
movb $-0x80, 0x30(%r14,%rdx)
xorq $0x3f, %rdx
cmpq $0x7, %rdx
ja 0x1fa2
pushq $0x40
popq %r12
addq %r15, %rdi
xorl %esi, %esi
callq 0x1030
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x12f4
xorl %edi, %edi
movq %r12, %rdx
addq %r15, %rdi
addq $-0x8, %rdx
xorl %esi, %esi
callq 0x1030
movq (%r14), %rax
leaq (,%rax,8), %rcx
movq %rcx, (%r14)
movb %cl, 0x68(%r14)
movl %eax, %ecx
shrl $0x5, %ecx
movb %cl, 0x69(%r14)
movl %eax, %ecx
shrl $0xd, %ecx
movb %cl, 0x6a(%r14)
shrl $0x15, %eax
movb %al, 0x6b(%r14)
movl 0x8(%r14), %eax
movl %eax, 0x6c(%r14)
pushq $0x40
popq %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x12f4
movb 0x10(%r14), %al
movb %al, (%rbx)
movb 0x11(%r14), %al
movb %al, 0x1(%rbx)
movb 0x12(%r14), %al
movb %al, 0x2(%rbx)
movb 0x13(%r14), %al
movb %al, 0x3(%rbx)
movb 0x18(%r14), %al
movb %al, 0x4(%rbx)
movb 0x19(%r14), %al
movb %al, 0x5(%rbx)
movb 0x1a(%r14), %al
movb %al, 0x6(%rbx)
movb 0x1b(%r14), %al
movb %al, 0x7(%rbx)
movb 0x20(%r14), %al
movb %al, 0x8(%rbx)
movb 0x21(%r14), %al
movb %al, 0x9(%rbx)
movb 0x22(%r14), %al
movb %al, 0xa(%rbx)
movb 0x23(%r14), %al
movb %al, 0xb(%rbx)
movb 0x28(%r14), %al
movb %al, 0xc(%rbx)
movb 0x29(%r14), %al
movb %al, 0xd(%rbx)
movb 0x2a(%r14), %al
movb %al, 0xe(%rbx)
movb 0x2b(%r14), %al
movb %al, 0xf(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/calebstewart[P]md5/md5.cpp
// Function: MD5::hash(char const*, unsigned char*)
void MD5::hash(const char* str, unsigned char* hash)
{
  MD5 md5 = MD5();

  for(; *str; str++){
    md5.update(str, 1);
  }

  md5.finalize(hash);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xf0, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0xe0(%rbp), %rdi
movq $0x67452301, -0x20(%rdi) # imm = 0x67452301
movl $0x98badcfe, %eax       # imm = 0x98BADCFE
leaq 0x5712ce8b(%rax), %rcx
movq %rcx, -0x18(%rdi)
movq %rax, -0x10(%rdi)
movq $0x10325476, -0x8(%rdi) # imm = 0x10325476
xorps %xmm0, %xmm0
movaps %xmm0, -0x30(%rdi)
movl $0xc0, %edx
xorl %esi, %esi
callq 0x1030
leaq -0x110(%rbp), %r15
pushq $0x1
popq %r12
cmpb $0x0, (%r14)
je 0x20e4
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x123c
incq %r14
jmp 0x20cb
leaq -0x110(%rbp), %rdi
movq %rbx, %rsi
callq 0x1f52
addq $0xf0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/calebstewart[P]md5/md5.cpp
// Function: MD5::digest(unsigned char const*, char*)
void MD5::digest(const unsigned char* hash, char* digest)
{
  static const char digits[17] = "0123456789abcdef";

  for(int i = 0; i < 16; ++i){
    digest[i*2] = digits[hash[i] >> 4];
    digest[(i*2) + 1] = digits[hash[i] & 0x0F];
  }

  digest[32] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
leaq 0xe75(%rip), %rcx       # 0x3010
cmpq $0x10, %rax
je 0x21c1
movzbl (%rdi,%rax), %edx
shrl $0x4, %edx
movb (%rdx,%rcx), %dl
movb %dl, (%rsi,%rax,2)
movzbl (%rdi,%rax), %edx
andl $0xf, %edx
movb (%rdx,%rcx), %dl
movb %dl, 0x1(%rsi,%rax,2)
incq %rax
jmp 0x219b
movb $0x0, 0x20(%rsi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/calebstewart[P]md5/./examples/basic-buffer.cpp
// Function: main
int main(int argc, char** argv)
{
  char digest[33];
  unsigned char hash[16];
  unsigned char data[10] = {1,2,3,4,5,6,7,8,9,10};

  // Write the calculated hash to `hash`
  MD5::hash(data, 10, hash);
  // Retrieve the hex-encoded digest
  MD5::digest(hash, digest);

  std::cout << "md5({1,2,3,4,5,6,7,8,9,10}) => \"" << digest << "\"\n";

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movabsq $0x807060504030201, %rax # imm = 0x807060504030201
leaq -0x20(%rbp), %rdi
movq %rax, (%rdi)
movw $0xa09, 0x8(%rdi)       # imm = 0xA09
pushq $0xa
popq %rsi
leaq -0x30(%rbp), %rbx
movq %rbx, %rdx
callq 0x2104
leaq -0x60(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x218e
movq 0x2dc9(%rip), %rdi      # 0x4fd8
leaq 0xe15(%rip), %rsi       # 0x302b
callq 0x1060
movq %rax, %rdi
movq %r14, %rsi
callq 0x1060
leaq 0xe1f(%rip), %rsi       # 0x304c
movq %rax, %rdi
callq 0x1060
xorl %eax, %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/miniplane[P]mintree/simpletest.C
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nextrandom<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>()
string nextrandom( ) {
   const char* start = helpstr + rand() % sizeof helpstr;
   while (!isalpha( *start )) if (*start) ++start; else start = helpstr;
   const char* end = start + 1;
   while (isalpha( *end )) ++end;
   char buf[10];
   sprintf( buf, "%d", rand() % 1000 );
   return std::string( start, end - start ) += buf;
 }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
callq 0x2170
callq 0x2080
cltq
movl $0x4b9, %ecx            # imm = 0x4B9
xorl %edx, %edx
divq %rcx
movq %rdx, %r14
leaq 0x2b36(%rip), %r15      # 0x5010
addq %r15, %r14
movb (%r14), %r12b
movsbl %r12b, %edi
callq 0x2260
testl %eax, %eax
jne 0x2500
movq %r15, %rax
testb %r12b, %r12b
je 0x24fb
incq %r14
movq %r14, %rax
movq %rax, %r14
jmp 0x24dd
movq %r14, %r15
movsbl 0x1(%r15), %edi
incq %r15
callq 0x2260
testl %eax, %eax
jne 0x2503
callq 0x2080
movl $0x3e8, %ecx            # imm = 0x3E8
cltd
idivl %ecx
leaq 0x2fa1(%rip), %rsi      # 0x54c9
leaq -0x52(%rbp), %r12
movq %r12, %rdi
xorl %eax, %eax
callq 0x2040
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
leaq -0x48(%rbp), %r13
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x3136
movq %r13, %rdi
movq %r12, %rsi
callq 0x22e0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2240
leaq -0x48(%rbp), %rdi
callq 0x20e0
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O2/miniplane[P]mintree/./BpTree.h
// Function: BpTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 2ul>::add(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
virtual void add(const E& e) {
		Node *right_subroot = root->insert(e);
		if (right_subroot != nullptr) { // if root is split, make new root
			
			Node *left_subroot = root;

			root = new Node(nullptr);
			root->leaf = false;
			root->elements = 1;

			root->keys[0] = lift_key(left_subroot, right_subroot);

			root->children[0] = left_subroot;  left_subroot->parent = root; // resets parents and children
			root->children[1] = right_subroot; right_subroot->parent = root;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x2170
movq 0x8(%rbx), %r15
leaq -0x40(%rbp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x2240
movq %r15, %rdi
movq %r12, %rsi
callq 0x36c2
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x20e0
testq %r14, %r14
je 0x3366
movq 0x8(%rbx), %r12
movl $0xc8, %edi
callq 0x21d0
movq %rax, %r15
movq %rax, %rdi
xorl %esi, %esi
callq 0x31da
movq %r15, 0x8(%rbx)
movb $0x0, 0xc0(%r15)
movq $0x1, 0xb8(%r15)
cmpb $0x1, 0xc0(%r12)
jne 0x332b
movq %r14, %rsi
addq $0x38, %rsi
jmp 0x333f
movq 0xb8(%r12), %rax
shlq $0x5, %rax
leaq (%r12,%rax), %rsi
addq $0x38, %rsi
addq $0x38, %r15
movq %r15, %rdi
callq 0x2120
movq 0x8(%rbx), %rax
movq %r12, 0x8(%rax)
movq 0x8(%rbx), %rax
movq %rax, (%r12)
movq %r14, 0x10(%rax)
movq 0x8(%rbx), %rax
movq %rax, (%r14)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0xc8, %esi
movq %r15, %rdi
callq 0x21f0
jmp 0x3391
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/miniplane[P]mintree/./BpTree.h
// Function: BpTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 2ul>::remove(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
virtual void remove(const E& e ) {
		root->remove(e, 0);
		if (!root->leaf && root->elements == 0) {
			Node *oldroot = root;
			root = root->children[0];
			root->parent = nullptr;
			oldroot->elements = -1;
			delete oldroot;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x2170
movq 0x8(%rbx), %r15
leaq -0x40(%rbp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x2240
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x3b32
leaq -0x40(%rbp), %rdi
callq 0x20e0
movq 0x8(%rbx), %r14
cmpb $0x0, 0xc0(%r14)
jne 0x345a
cmpq $0x0, 0xb8(%r14)
jne 0x345a
movq 0x8(%r14), %rax
movq %rax, 0x8(%rbx)
andq $0x0, (%rax)
orq $-0x1, 0xb8(%r14)
movq %r14, %rdi
callq 0x364c
movl $0xc8, %esi
movq %r14, %rdi
callq 0x21f0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/miniplane[P]mintree/./BpTree.h
// Function: BpTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 2ul>::apply(Functor<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&, Order) const
virtual size_t apply (const Functor<E>& f, Order order_=dontcare) const {
		if (root->elements == 0)
			return 0;
		size_t n = 0;
		root->apply_(f, order_, n);
		return n;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
callq 0x2170
movq 0x8(%r15), %rdi
cmpq $0x0, 0xb8(%rdi)
je 0x355b
leaq -0x20(%rbp), %r15
andq $0x0, (%r15)
movq %r14, %rsi
movl %ebx, %edx
movq %r15, %rcx
callq 0x45d2
movq (%r15), %rax
jmp 0x355d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/miniplane[P]mintree/./BpTree.h
// Function: BpTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 2ul>::Node::~Node()
~Node () {
			if (leaf)
				return;
			for (size_t i = 0; i < elements+1; i++)
				delete children[i];
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2170
cmpb $0x1, 0xc0(%rbx)
jne 0x368b
movl $0x98, %r14d
leaq (%rbx,%r14), %rdi
callq 0x20e0
addq $-0x20, %r14
cmpq $0x18, %r14
jne 0x366d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %r15d, %r15d
movq 0xb8(%rbx), %rax
incq %rax
cmpq %rax, %r15
jae 0x3667
movq 0x8(%rbx,%r15,8), %r14
testq %r14, %r14
je 0x36af
movq %r14, %rdi
callq 0x364c
movl $0xc8, %esi
movq %r14, %rdi
callq 0x21f0
incq %r15
jmp 0x368e
nop
// File: /workspace/github_cpp_makefile_star2_O2/miniplane[P]mintree/./BpTree.h
// Function: BpTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 2ul>::Node::insert(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Node *insert(E key) { // insertions into inner nodes and leafs

			size_t i = 0;

			for (i = 0; i < elements; i++) {
				if (key == keys[i])
					return nullptr; // return to avoid inserting the same value twice

				if (keys[i] > key) // if key smaller than value, stop
					break;
			}

			Node *retval = nullptr;

			if (leaf)
				retval = insert_in_leaf(key, i);
			else
				retval = insert_in_node(key, i);
			return retval;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r12
movq %rdi, %r14
callq 0x2170
leaq 0x38(%r14), %r13
xorl %ebx, %ebx
xorl %r15d, %r15d
cmpq 0xb8(%r14), %r15
jae 0x3717
movq %r12, %rdi
movq %r13, %rsi
callq 0x3797
testb %al, %al
jne 0x3768
movq %r13, %rdi
movq %r12, %rsi
callq 0x37d4
testb %al, %al
jne 0x3717
incq %r15
addq $0x20, %r13
jmp 0x36e7
cmpb $0x1, 0xc0(%r14)
jne 0x3740
leaq -0x68(%rbp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x2240
movq %r14, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x3804
jmp 0x375d
leaq -0x48(%rbp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x2240
movq %r14, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x38a6
movq %rax, %rbx
movq %r13, %rdi
callq 0x20e0
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
jmp 0x378a
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x22b0