LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/msotoodeh[P]asymmetric-passwords/server/APVerifier.cpp
// Function: APVerifier::parseChangePasswordToken(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool APVerifier::parseChangePasswordToken(const std::string& token)
{
    if (ValidateToken(token) == AP_SUCCESS)
    {
        if (m_tag == AP_CHANGE_PASSWORD)
            setKey(getItem(2)); // Change public key
        else
            m_error = AP_E_TOKEN;
    }
    return isValid();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
xorl %edx, %edx
callq 0x4069fa
testl %eax, %eax
jne 0x406c7f
cmpl $0x6370, 0x24(%rbx)     # imm = 0x6370
jne 0x406c78
movq 0x38(%rbx), %rax
movq 0x40(%rbx), %rcx
subq %rax, %rcx
addq $0x40, %rax
cmpq $0x41, %rcx
leaq 0x1e6b56(%rip), %rsi    # 0x5ed7c0
cmovaeq %rax, %rsi
movq %rbx, %rdi
callq 0x4067d2
jmp 0x406c7f
movl $0xfffffffc, 0x20(%rbx) # imm = 0xFFFFFFFC
cmpl $0x0, 0x20(%rbx)
setns %al
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/msotoodeh[P]asymmetric-passwords/common/curve25519/ed25519_sign.c
// Function: edp_AddBasePoint
void edp_AddBasePoint(Ext_POINT *p)
{
    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, _w_base_folding8[1].YmX);
    ecp_AddReduce(b, p->y, p->x);           /* B = (Y1+X1)*(Y2+X2) */
    ecp_MulReduce(b, b, _w_base_folding8[1].YpX);
    ecp_MulReduce(c, p->t, _w_base_folding8[1].T2d); /* C = T1*2d*T2 */
    ecp_AddReduce(d, p->z, p->z);           /* D = 2*Z1 */
    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(p->x, e, a);              /* E*F */
    ecp_MulReduce(p->y, b, d);              /* H*G */
    ecp_MulReduce(p->t, e, b);              /* E*H */
    ecp_MulReduce(p->z, d, a);              /* G*F */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdi, %r15
leaq 0x20(%rdi), %r14
leaq 0x90(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
movq %r14, (%rsp)
movq %r15, %rdx
callq 0x409f40
leaq 0x17382f(%rip), %rdx    # 0x57a850
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x40a238
leaq 0x70(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x409e80
leaq 0x1737ea(%rip), %rdx    # 0x57a830
movq %r12, %rdi
movq %r12, %rsi
callq 0x40a238
leaq 0x60(%r15), %rsi
movq %rsi, 0x8(%rsp)
leaq 0x17380f(%rip), %rdx    # 0x57a870
leaq 0x50(%rsp), %r14
movq %r14, %rdi
callq 0x40a238
leaq 0x40(%r15), %rbp
leaq 0x30(%rsp), %r13
movq %r13, %rdi
movq %rbp, %rsi
movq %rbp, %rdx
callq 0x409e80
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x409f40
movq %r12, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x409e80
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x409f40
movq %r13, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x409e80
movq %r15, %rdi
leaq 0x10(%rsp), %r15
movq %r15, %rsi
movq %rbx, %rdx
callq 0x40a238
movq (%rsp), %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x40a238
movq 0x8(%rsp), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x40a238
movq %rbp, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x40a238
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/msotoodeh[P]asymmetric-passwords/common/curve25519/ed25519_sign.c
// Function: edp_AddAffinePoint
void edp_AddAffinePoint(Ext_POINT *p, const PA_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_AddReduce(d, p->z, p->z);           /* D = Z1*2*Z2 (Z2=1)*/
    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(p->x, e, a);              /* E*F */
    ecp_MulReduce(p->y, b, d);              /* H*G */
    ecp_MulReduce(p->t, e, b);              /* E*H */
    ecp_MulReduce(p->z, d, a);              /* G*F */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rsi, %r13
movq %rdi, %r15
leaq 0x20(%rdi), %r14
leaq 0x90(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
movq %r14, (%rsp)
movq %r15, %rdx
callq 0x409f40
leaq 0x20(%r13), %rdx
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x40a238
leaq 0x70(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x409e80
movq %r12, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x40a238
leaq 0x60(%r15), %rsi
movq %rsi, 0x8(%rsp)
addq $0x40, %r13
leaq 0x50(%rsp), %r14
movq %r14, %rdi
movq %r13, %rdx
callq 0x40a238
leaq 0x40(%r15), %rbp
leaq 0x30(%rsp), %r13
movq %r13, %rdi
movq %rbp, %rsi
movq %rbp, %rdx
callq 0x409e80
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x409f40
movq %r12, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x409e80
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x409f40
movq %r13, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x409e80
movq %r15, %rdi
leaq 0x10(%rsp), %r15
movq %r15, %rsi
movq %rbx, %rdx
callq 0x40a238
movq (%rsp), %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x40a238
movq 0x8(%rsp), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x40a238
movq %rbp, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x40a238
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/msotoodeh[P]asymmetric-passwords/common/curve25519/ed25519_sign.c
// Function: edp_DoublePoint
void edp_DoublePoint(Ext_POINT *p)
{
    U_WORD a[K_WORDS], b[K_WORDS], c[K_WORDS], d[K_WORDS], e[K_WORDS];

    ecp_SqrReduce(a, p->x);         /* A = X1^2 */
    ecp_SqrReduce(b, p->y);         /* B = Y1^2 */
    ecp_SqrReduce(c, p->z);         /* C = 2*Z1^2 */
    ecp_AddReduce(c, c, c);
    ecp_SubReduce(d, _w_maxP, a);   /* D = -A */

    ecp_SubReduce(a, d, b);         /* H = D-B */
    ecp_AddReduce(d, d, b);         /* G = D+B */
    ecp_SubReduce(b, d, c);         /* F = G-C */
    ecp_AddReduce(e, p->x, p->y);   /* E = (X1+Y1)^2-A-B = (X1+Y1)^2+H */
    ecp_SqrReduce(e, e);
    ecp_AddReduce(e, e, a);

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdi, %r14
leaq 0x90(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x40a4c0
leaq 0x20(%r14), %r12
leaq 0x70(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x40a4c0
leaq 0x40(%r14), %rsi
movq %rsi, 0x8(%rsp)
leaq 0x50(%rsp), %rbx
movq %rbx, %rdi
callq 0x40a4c0
movq %rbx, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
callq 0x409e80
movq $0x580bf0, %rsi         # imm = 0x580BF0
leaq 0x30(%rsp), %rbp
movq %rbp, %rdi
movq %r13, %rdx
callq 0x409f40
movq %r13, %rdi
movq %rbp, %rsi
movq %r15, %rdx
callq 0x409f40
movq %rbp, %rdi
movq %rbp, %rsi
movq %r15, %rdx
callq 0x409e80
movq %r15, %rdi
movq %rbp, %rsi
movq %rbx, %rdx
callq 0x409f40
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x409e80
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x40a4c0
movq %rbx, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x409e80
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x40a238
movq %r12, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x40a238
movq 0x8(%rsp), %rdi
movq %rbp, %rsi
movq %r15, %rdx
callq 0x40a238
addq $0x60, %r14
movq %r14, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x40a238
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/msotoodeh[P]asymmetric-passwords/common/curve25519/ed25519_sign.c
// Function: edp_BasePointMult
void edp_BasePointMult(
    OUT Ext_POINT *S, 
    IN const U_WORD *sk, 
    IN const U_WORD *R)
{
    int i = 1;
    U8 cut[32];
    const PA_POINT *p0;

    ecp_8Folds(cut, sk);

    p0 = &_w_base_folding8[cut[0]];

    ecp_SubReduce(S->x, p0->YpX, p0->YmX);  /* 2x */
    ecp_AddReduce(S->y, p0->YpX, p0->YmX);  /* 2y */
    ecp_MulReduce(S->t, p0->T2d, _w_di);    /* 2xy */

    /* Randomize starting point */

    ecp_AddReduce(S->z, R, R);              /* Z = 2R */
    ecp_MulReduce(S->x, S->x, R);           /* X = 2xR */
    ecp_MulReduce(S->t, S->t, R);           /* T = 2xyR */
    ecp_MulReduce(S->y, S->y, R);           /* Y = 2yR */

    do 
    {
        edp_DoublePoint(S);
        edp_AddAffinePoint(S, &_w_base_folding8[cut[i]]);
    } while (i++ < 31);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x40ac3a
movzbl (%r15), %eax
leaq (%rax,%rax,2), %r15
shll $0x5, %r15d
leaq 0x17344a(%rip), %rbp    # 0x57a7d0
leaq (%r15,%rbp), %r12
leaq (%r15,%rbp), %r13
addq $0x20, %r13
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x409f40
leaq 0x20(%rbx), %rdi
movq %rdi, 0x8(%rsp)
movq %r12, %rsi
movq %r13, %rdx
callq 0x409e80
leaq 0x60(%rbx), %r12
leaq (%r15,%rbp), %rsi
addq $0x40, %rsi
leaq 0x1733e9(%rip), %rdx    # 0x57a7b0
movq %r12, %rdi
callq 0x40a238
leaq 0x40(%rbx), %rdi
movq %r14, %rsi
movq %r14, %rdx
callq 0x409e80
movq %rbx, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x40a238
movq %r12, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x40a238
movq 0x8(%rsp), %rdi
movq %rdi, %rsi
movq %r14, %rdx
callq 0x40a238
movl $0x1, %r14d
movq %rbx, %rdi
callq 0x407236
movzbl 0x10(%rsp,%r14), %eax
leaq (%rax,%rax,2), %rsi
shll $0x5, %esi
addq %rbp, %rsi
movq %rbx, %rdi
callq 0x407111
incq %r14
cmpq $0x20, %r14
jne 0x407410
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/msotoodeh[P]asymmetric-passwords/common/curve25519/ed25519_sign.c
// Function: edp_BasePointMultiply
void edp_BasePointMultiply(
    OUT Affine_POINT *R, 
    IN const U_WORD *sk, 
    IN const void *blinding)
{
    Ext_POINT S;
    U_WORD t[K_WORDS];

    if (blinding)
    {
        eco_AddReduce(t, sk, ((EDP_BLINDING_CTX*)blinding)->bl);
        edp_BasePointMult(&S, t, ((EDP_BLINDING_CTX*)blinding)->zr);
        edp_AddPoint(&S, &S, &((EDP_BLINDING_CTX*)blinding)->BP);
    }
    else
    {
        edp_BasePointMult(&S, sk, edp_custom_blinding.zr);
    }

    ecp_Inverse(S.z, S.z);
    ecp_MulMod(R->x, S.x, S.z);
    ecp_MulMod(R->y, S.y, S.z);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
testq %rdx, %rdx
je 0x407497
movq %rdx, %r14
leaq 0x80(%rsp), %r15
movq %r15, %rdi
callq 0x40aa2b
leaq 0x20(%r14), %rdx
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x407352
addq $0x40, %r14
movq %r12, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x407bf6
jmp 0x4074aa
movq $0x5eb2d8, %rdx         # imm = 0x5EB2D8
addq $0x20, %rdx
movq %rsp, %rdi
callq 0x407352
leaq 0x40(%rsp), %r14
movq %r14, %rdi
movq %r14, %rsi
callq 0x40a587
movq %rsp, %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x40a575
addq $0x20, %rbx
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x40a575
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/msotoodeh[P]asymmetric-passwords/common/curve25519/ed25519_sign.c
// Function: edp_ExtPoint2PE
void edp_ExtPoint2PE(PE_POINT *r, const Ext_POINT *p)
{
    ecp_AddReduce(r->YpX, p->y, p->x);
    ecp_SubReduce(r->YmX, p->y, p->x);
    ecp_MulReduce(r->T2d, p->t, _w_2d);
    ecp_AddReduce(r->Z2, p->z, p->z);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x20(%rsi), %r15
movq %r15, %rsi
movq %rbx, %rdx
callq 0x409e80
leaq 0x20(%r14), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x409f40
leaq 0x40(%r14), %rdi
leaq 0x60(%rbx), %rsi
leaq 0x17326d(%rip), %rdx    # 0x57a790
callq 0x40a238
addq $0x60, %r14
addq $0x40, %rbx
movq %r14, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x409e80
// File: /workspace/github_cpp_makefile_star2_O3/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 0x407578
movl $0xc0, %edi
callq 0x4e69a0
movq %rax, %rbx
testq %rax, %rax
je 0x407658
leaq 0xa0(%rsp), %rbp
movq %rbp, %rdi
callq 0x40827c
movq $0x5eb2d8, %r14         # imm = 0x5EB2D8
leaq 0x20(%r14), %r15
movl $0x20, %edx
movq %rbp, %rdi
movq %r15, %rsi
callq 0x409a57
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x409a57
leaq 0x178(%rsp), %r12
movq %r12, %rdi
movq %rbp, %rsi
callq 0x408304
leaq 0x20(%rbx), %rdi
leaq 0x198(%rsp), %rsi
callq 0x40ab25
leaq 0x80(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x40ab25
movq %r13, %rdi
callq 0x40a9eb
movq $0x580c10, %rsi         # imm = 0x580C10
addq $0x20, %rsi
movq %rbx, %rdi
movq %r13, %rdx
callq 0x409d55
movq %r13, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x40aa2b
movq %rsp, %r12
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x407352
addq $0x40, %r14
movq %r12, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x407bf6
leaq 0x40(%rbx), %rdi
movq %r12, %rsi
callq 0x4074eb
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 0x407643
// File: /workspace/github_cpp_makefile_star2_O3/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 0x40827c
movl $0x20, %edx
movq %r13, %rdi
movq %r15, %rsi
callq 0x409a57
leaq 0x60(%rsp), %rbp
movq %rbp, %rdi
movq %r13, %rsi
callq 0x408304
movq %rbp, %rdi
callq 0x40aafc
movq %rsp, %r13
movq %r13, %rdi
movq %rbp, %rsi
callq 0x40ab25
leaq 0x20(%rsp), %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x407448
leaq 0x40(%rsp), %rsi
movl -0x20(%rsi), %edx
andl $0x1, %edx
movq %r14, %rdi
callq 0x40ab57
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_O3/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 0x40a4c0
leaq 0x178f0c(%rip), %rdx    # 0x5807f0
leaq 0x50(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x40a238
movq $0x57a7d0, %r15         # imm = 0x57A7D0
movq %r14, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x409f40
movq %r12, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x409e80
leaq 0x10(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x40a4c0
leaq 0x30(%rsp), %rbp
movq %rbp, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x40a238
movq %rbp, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x40a238
movq %r13, %rdi
movq %r13, %rsi
callq 0x40a4c0
movq %r13, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x40a238
movq %r13, %rdi
movq %r13, %rsi
callq 0x407a33
movq %rbx, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x40a238
movq %r13, %rdi
movq %rbx, %rsi
callq 0x40a4c0
movq %r13, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x40a238
movq %r13, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x409f40
movq %r13, %rdi
callq 0x40a00a
addq $0x40, %r15
movq %r13, %rdi
movq %r15, %rsi
callq 0x409d09
testl %eax, %eax
je 0x4079ce
leaq 0x178e0d(%rip), %rdx    # 0x5807d0
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x40a238
movq $0x580bd0, %rsi         # imm = 0x580BD0
movq %rbx, %rdi
callq 0x409d3e
testl %eax, %eax
jne 0x407a05
movq $0x580bd0, %r14         # imm = 0x580BD0
movq %rbx, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x409d55
movq %rbx, %rdi
movq %r14, %rsi
callq 0x409d3e
testl %eax, %eax
je 0x4079e8
movl 0xc(%rsp), %eax
xorl (%rbx), %eax
testb $0x1, %al
je 0x407a21
movq $0x580bd0, %rsi         # imm = 0x580BD0
movq %rbx, %rdi
movq %rbx, %rdx
callq 0x409d55
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x120, %rsp            # imm = 0x120
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x100(%rsp), %r15
movq %r15, %rdi
callq 0x40a4c0
leaq 0xe0(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movl $0x2, %edx
movq %rbx, %rcx
callq 0x407ba7
leaq 0xc0(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x40a238
movq %rsp, %r15
movq %r15, %rdi
movq %r13, %rsi
callq 0x40a4c0
leaq 0xa0(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x40a238
leaq 0x80(%rsp), %r12
movq %r12, %rdi
movq %r13, %rsi
movl $0x5, %edx
movq %r13, %rcx
callq 0x407ba7
leaq 0x60(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
movl $0xa, %edx
movq %r12, %rcx
callq 0x407ba7
movq %r15, %rdi
movq %r13, %rsi
movl $0x14, %edx
movq %r13, %rcx
callq 0x407ba7
leaq 0x40(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
movl $0xa, %edx
movq %r12, %rcx
callq 0x407ba7
leaq 0x20(%rsp), %r12
movq %r12, %rdi
movq %r13, %rsi
movl $0x32, %edx
movq %r13, %rcx
callq 0x407ba7
movq %r15, %rdi
movq %r12, %rsi
movl $0x64, %edx
movq %r12, %rcx
callq 0x407ba7
movq %r15, %rdi
movq %r15, %rsi
movl $0x32, %edx
movq %r13, %rcx
callq 0x407ba7
movq %r15, %rdi
movq %r15, %rsi
callq 0x40a4c0
movq %r15, %rdi
movq %r15, %rsi
callq 0x40a4c0
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x40a238
addq $0x120, %rsp            # imm = 0x120
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/msotoodeh[P]asymmetric-passwords/common/curve25519/ed25519_verify.c
// Function: ecp_SrqMulReduce
void ecp_SrqMulReduce(U_WORD *Z, const U_WORD *X, int n, const U_WORD *Y)
{
    U_WORD t[K_WORDS];
    ecp_SqrReduce(t, X);
    while (n-- > 1) ecp_SqrReduce(t, t);
    ecp_MulReduce(Z, t, Y);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movl %edx, %ebp
movq %rdi, %r14
movq %rsp, %rdi
callq 0x40a4c0
cmpl $0x2, %ebp
jl 0x407bdd
incl %ebp
movq %rsp, %r15
movq %r15, %rdi
movq %r15, %rsi
callq 0x40a4c0
decl %ebp
cmpl $0x2, %ebp
ja 0x407bcb
movq %rsp, %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x40a238
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x409f40
leaq 0x20(%r13), %rdx
movq %r14, %rdi
movq %r14, %rsi
callq 0x40a238
leaq 0x60(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x409e80
movq %r15, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x40a238
leaq 0x60(%rbp), %rsi
leaq 0x40(%r13), %rdx
movq %rsp, %rdi
callq 0x40a238
addq $0x40, %rbp
addq $0x60, %r13
leaq 0x40(%rsp), %r12
movq %r12, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x40a238
leaq 0x20(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x409f40
movq %r15, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x409e80
movq %r14, %rdi
movq %r12, %rsi
movq %rsp, %rbp
movq %rbp, %rdx
callq 0x409f40
movq %r12, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x409e80
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x40a238
leaq 0x20(%rbx), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x40a238
leaq 0x60(%rbx), %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x40a238
addq $0x40, %rbx
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x40a238
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x409b35
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 0x409ac0
movl $0x80, %ebp
subl %edi, %ebp
addq %r15, %rdi
movq %r13, %r12
subq %rbp, %r12
jae 0x409ac5
movq %r14, %rsi
movq %r13, %rdx
callq 0x401110
addl 0xd0(%rbx), %r13d
jmp 0x409b20
movq %r13, %r12
jmp 0x409ae8
movq %r14, %rsi
movq %rbp, %rdx
callq 0x401110
movl $0x0, 0xd0(%rbx)
addq %rbp, %r14
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4083a5
cmpq $0x80, %r12
jb 0x409b0a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4083a5
subq $-0x80, %r14
addq $-0x80, %r12
cmpq $0x7f, %r12
ja 0x409af1
testq %r12, %r12
je 0x409b27
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_O3/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 $0x28, %rsp
movq %rsi, -0x48(%rbp)
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, -0x30(%rbp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rdx, -0x40(%rbp)
testq %rdx, %rdx
je 0x409c17
xorl %eax, %eax
leaq 0x176f13(%rip), %r13    # 0x580a90
xorl %r15d, %r15d
xorl %r14d, %r14d
shll $0x8, %r14d
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, -0x50(%rbp)
movzbl (%rax,%rcx), %eax
movq %rax, -0x38(%rbp)
orl %eax, %r14d
leal 0x8(%r15), %eax
addl $0x2, %r15d
movl %r15d, %r12d
movl %eax, %r15d
cmpl $0x6, %r15d
jb 0x409bde
addl $-0x6, %r15d
movl %r14d, %eax
movl %r12d, %ecx
shrl %cl, %eax
andl $0x3f, %eax
movsbl (%rax,%r13), %r8d
movq 0x8(%rbx), %rsi
addl $-0x6, %r12d
movl $0x1, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x4783f0
jmp 0x409bab
movq -0x50(%rbp), %rax
incq %rax
cmpq -0x40(%rbp), %rax
jne 0x409b83
testl %r15d, %r15d
je 0x409c17
negb %r12b
movl %r12d, %ecx
movq -0x38(%rbp), %rax
shll %cl, %eax
andl $0x3f, %eax
movsbl (%rax,%r13), %r8d
movq 0x8(%rbx), %rsi
movl $0x1, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x4783f0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x409c2b
movq %rax, %r14
movq (%rbx), %rdi
movq -0x30(%rbp), %rax
cmpq %rax, %rdi
je 0x409c45
movq (%rax), %rsi
incq %rsi
callq 0x40ac80
movq %r14, %rdi
callq 0x4a9bd0
// File: /workspace/github_cpp_makefile_star2_O3/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:
xorl %r8d, %r8d
testq %rdx, %rdx
je 0x409ce9
pushq %rbp
movq %rsp, %rbp
pushq %rbx
leaq 0x176e4a(%rip), %r9     # 0x580ad0
xorl %r11d, %r11d
xorl %r10d, %r10d
xorl %eax, %eax
cmpl $0x7, %r11d
ja 0x409cc6
movq (%rdi), %rbx
movl %r8d, %ecx
incl %r8d
movzbl (%rbx,%rcx), %ecx
movzbl (%rcx,%r9), %ecx
cmpl $0x40, %ecx
je 0x409c97
cmpb $0x3f, %cl
ja 0x409ce6
shll $0x6, %r10d
orl %ecx, %r10d
leal 0x6(%r11), %ecx
cmpl $0x2, %r11d
movl %ecx, %r11d
jb 0x409c97
jmp 0x409cc9
movl %r11d, %ecx
addl $-0x8, %ecx
movl %r10d, %r11d
shrl %cl, %r11d
movb %r11b, (%rsi)
incq %rsi
incq %rax
movl %ecx, %r11d
cmpq %rdx, %rax
jne 0x409c8e
movq %rdx, %rax
popq %rbx
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x176bb3(%rip), %r15    # 0x580bd0
movq %rdi, %rsi
movq %r15, %rdx
callq 0x409d55
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 0x409dee
movq %rbx, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x409d55
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 0x409dee
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x40a2f8
leaq 0x4(%rsp), %rdi
movl 0x4(%r12), %esi
movq %r15, %rdx
callq 0x40a37b
leaq 0x8(%rsp), %rdi
movl 0x8(%r12), %esi
movq %r15, %rdx
callq 0x40a37b
leaq 0xc(%rsp), %rdi
movl 0xc(%r12), %esi
movq %r15, %rdx
callq 0x40a37b
leaq 0x10(%rsp), %rdi
movl 0x10(%r12), %esi
movq %r15, %rdx
callq 0x40a37b
leaq 0x14(%rsp), %rdi
movl 0x14(%r12), %esi
movq %r15, %rdx
callq 0x40a37b
leaq 0x18(%rsp), %rdi
movl 0x18(%r12), %esi
movq %r15, %rdx
callq 0x40a37b
leaq 0x1c(%rsp), %rdi
movl 0x1c(%r12), %esi
movq %r15, %rdx
callq 0x40a37b
leaq 0x20(%rsp), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x26, %edx
callq 0x40a0a9
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x40a2f8
leaq 0x4(%r15), %rdi
movl 0x4(%r14), %esi
movq %rbx, %rdx
callq 0x40a37b
leaq 0x8(%r15), %rdi
movl 0x8(%r14), %esi
movq %rbx, %rdx
callq 0x40a37b
leaq 0xc(%r15), %rdi
movl 0xc(%r14), %esi
movq %rbx, %rdx
callq 0x40a37b
leaq 0x10(%r15), %rdi
movl 0x10(%r14), %esi
movq %rbx, %rdx
callq 0x40a37b
leaq 0x14(%r15), %rdi
movl 0x14(%r14), %esi
movq %rbx, %rdx
callq 0x40a37b
leaq 0x18(%r15), %rdi
movl 0x18(%r14), %esi
movq %rbx, %rdx
callq 0x40a37b
addq $0x1c, %r15
movl 0x1c(%r14), %esi
movq %r15, %rdi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x40a37b
// File: /workspace/github_cpp_makefile_star2_O3/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 0x40a2f8
leaq 0x4(%rsp), %rdi
movl 0x4(%r15), %esi
movq %r15, %rdx
callq 0x40a37b
leaq 0x8(%rsp), %rdi
movl 0x8(%r15), %esi
movq %r15, %rdx
callq 0x40a37b
leaq 0xc(%rsp), %rdi
movl 0xc(%r15), %esi
movq %r15, %rdx
callq 0x40a37b
leaq 0x10(%rsp), %rdi
movl 0x10(%r15), %esi
movq %r15, %rdx
callq 0x40a37b
leaq 0x14(%rsp), %rdi
movl 0x14(%r15), %esi
movq %r15, %rdx
callq 0x40a37b
leaq 0x18(%rsp), %rdi
movl 0x18(%r15), %esi
movq %r15, %rdx
callq 0x40a37b
leaq 0x1c(%rsp), %rdi
movl 0x1c(%r15), %esi
movq %r15, %rdx
callq 0x40a37b
leaq 0x20(%rsp), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x26, %edx
callq 0x40a0a9
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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)
movq $0x0, 0x18(%rax)
movq %rbx, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x409d55
andl $0x1, %eax
shll $0x5, %eax
leaq 0x1762dd(%rip), %rdx    # 0x580c10
addq %rax, %rdx
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x409dee
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x40a433
leaq 0x1c(%rsp), %rdi
movl 0x20(%rdi), %esi
movq %rdi, %rdx
callq 0x40a8b0
leaq 0x18(%rsp), %rdi
movl 0x20(%rdi), %esi
movq %rdi, %rdx
callq 0x40a8b0
leaq 0x14(%rsp), %rdi
movl 0x20(%rdi), %esi
movq %rdi, %rdx
callq 0x40a8b0
leaq 0x10(%rsp), %rdi
movl 0x20(%rdi), %esi
movq %rdi, %rdx
callq 0x40a8b0
leaq 0xc(%rsp), %rdi
movl 0x20(%rdi), %esi
movq %rdi, %rdx
callq 0x40a8b0
leaq 0x8(%rsp), %rdi
movl 0x20(%rdi), %esi
movq %rdi, %rdx
callq 0x40a8b0
leaq 0x4(%rsp), %r15
movl 0x20(%r15), %esi
movq %r15, %rdi
movq %r15, %rdx
callq 0x40a8b0
movl 0x1c(%r15), %esi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x40a8b0
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x40ab25
leaq 0x20(%rsp), %rdi
addq $0x20, %r15
movq %r15, %rsi
callq 0x40ab25
leaq 0x1c(%rsp), %rdi
movl 0x20(%rdi), %esi
movq %rdi, %rdx
callq 0x40a8b0
leaq 0x18(%rsp), %rdi
movl 0x20(%rdi), %esi
movq %rdi, %rdx
callq 0x40a8b0
leaq 0x14(%rsp), %rdi
movl 0x20(%rdi), %esi
movq %rdi, %rdx
callq 0x40a8b0
leaq 0x10(%rsp), %rdi
movl 0x20(%rdi), %esi
movq %rdi, %rdx
callq 0x40a8b0
leaq 0xc(%rsp), %rdi
movl 0x20(%rdi), %esi
movq %rdi, %rdx
callq 0x40a8b0
leaq 0x8(%rsp), %rdi
movl 0x20(%rdi), %esi
movq %rdi, %rdx
callq 0x40a8b0
leaq 0x4(%rsp), %r15
movl 0x20(%r15), %esi
movq %r15, %rdi
movq %r15, %rdx
callq 0x40a8b0
movl 0x1c(%r15), %esi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x40a8b0
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x12a1
movl $0x40, %r12d
subq %rax, %r12
movq %rdx, %r15
leaq (%rbx,%rax), %rdi
addq $0x30, %rdi
subq %r12, %r15
jae 0x12a6
movq %r14, %rsi
jmp 0x12f4
movq %rdx, %r15
jmp 0x12c8
leaq 0x30(%rbx), %r13
movq %r14, %rsi
movq %r12, %rdx
callq 0x1050
addq %r12, %r14
movl $0x40, %edx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1308
cmpq $0x40, %r15
jb 0x12e7
movq %r15, %rdx
andq $-0x40, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1308
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 0x1050
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
subq $0xf8, %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 0x1040
cmpb $0x0, (%r14)
je 0x2104
leaq -0x110(%rbp), %r15
movl $0x1, %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0x124c
cmpb $0x0, 0x1(%r14)
leaq 0x1(%r14), %r14
jne 0x20e9
leaq -0x110(%rbp), %rdi
movq %rbx, %rsi
callq 0x1f66
addq $0xf8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xe57(%rip), %rcx       # 0x3010
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
cmpq $0x10, %rax
jne 0x21b9
movb $0x0, 0x20(%rsi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
leaq -0x30(%rbp), %rbx
movl $0xa, %esi
movq %rbx, %rdx
callq 0x2122
leaq -0x60(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21ac
movq 0x2dab(%rip), %rbx      # 0x4fd8
leaq 0xdf7(%rip), %rsi       # 0x302b
movl $0x20, %edx
movq %rbx, %rdi
callq 0x1070
movq %r14, %rdi
callq 0x1030
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x1070
leaq 0xdee(%rip), %rsi       # 0x304c
movl $0x2, %edx
movq %rbx, %rdi
callq 0x1070
xorl %eax, %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2150
movq 0x8(%rbx), %r15
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x40(%rbp), %r14
movq %r14, %rdi
callq 0x346e
movq %r15, %rdi
movq %r14, %rsi
callq 0x3a8a
movq %rax, %r14
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x35d8
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x21d0
testq %r14, %r14
je 0x368a
movq 0x8(%rbx), %r15
movl $0xc8, %edi
callq 0x21b0
movq $0x0, (%rax)
movl $0x48, %ecx
leaq (%rax,%rcx), %rdx
movq %rdx, -0x10(%rax,%rcx)
movq $0x0, -0x8(%rax,%rcx)
movb $0x0, (%rax,%rcx)
addq $0x20, %rcx
cmpq $0xc8, %rcx
jne 0x35fb
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rcx, 0x28(%rax)
movq %rax, 0x8(%rbx)
movb $0x0, 0xc0(%rax)
movq $0x1, 0xb8(%rax)
cmpb $0x1, 0xc0(%r15)
jne 0x3651
movq %r14, %rsi
addq $0x38, %rsi
jmp 0x3664
movq 0xb8(%r15), %rcx
shlq $0x5, %rcx
leaq (%r15,%rcx), %rsi
addq $0x38, %rsi
addq $0x38, %rax
movq %rax, %rdi
callq 0x20f0
movq 0x8(%rbx), %rax
movq %r15, 0x8(%rax)
movq 0x8(%rbx), %rax
movq %rax, (%r15)
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
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x36af
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x21d0
movq %rbx, %rdi
callq 0x22b0
nop