LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x408338
movl $0x20, %edx
movq %r13, %rdi
movq %r15, %rsi
callq 0x409b13
leaq 0x60(%rsp), %rbp
movq %rbp, %rdi
movq %r13, %rsi
callq 0x4083c0
movq %rbp, %rdi
callq 0x40abb4
movq %rsp, %r13
movq %r13, %rdi
movq %rbp, %rsi
callq 0x40abdd
leaq 0x20(%rsp), %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x4074e4
leaq 0x40(%rsp), %rsi
movl -0x20(%rsi), %edx
andl $0x1, %edx
movq %r14, %rdi
callq 0x40ac0f
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_O1/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 0x40a578
leaq 0x178e4c(%rip), %rdx    # 0x5807f0
leaq 0x50(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x40a2f0
movq $0x57a7d0, %r15         # imm = 0x57A7D0
movq %r14, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x409ff8
movq %r12, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x409f38
leaq 0x10(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x40a578
leaq 0x30(%rsp), %rbp
movq %rbp, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x40a2f0
movq %rbp, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x40a2f0
movq %r13, %rdi
movq %r13, %rsi
callq 0x40a578
movq %r13, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x40a2f0
movq %r13, %rdi
movq %r13, %rsi
callq 0x407af3
movq %rbx, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x40a2f0
movq %r13, %rdi
movq %rbx, %rsi
callq 0x40a578
movq %r13, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x40a2f0
movq %r13, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x409ff8
movq %r13, %rdi
callq 0x40a0c2
addq $0x40, %r15
movq %r13, %rdi
movq %r15, %rsi
callq 0x409dc1
testl %eax, %eax
je 0x407a8e
leaq 0x178d4d(%rip), %rdx    # 0x5807d0
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x40a2f0
movq $0x580bd0, %rsi         # imm = 0x580BD0
movq %rbx, %rdi
callq 0x409df6
testl %eax, %eax
jne 0x407ac5
movq $0x580bd0, %r14         # imm = 0x580BD0
movq %rbx, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x409e0d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x409df6
testl %eax, %eax
je 0x407aa8
movl 0xc(%rsp), %eax
xorl (%rbx), %eax
testb $0x1, %al
je 0x407ae1
movq $0x580bd0, %rsi         # imm = 0x580BD0
movq %rbx, %rdi
movq %rbx, %rdx
callq 0x409e0d
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x40a578
leaq 0xe0(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movl $0x2, %edx
movq %rbx, %rcx
callq 0x407c67
leaq 0xc0(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x40a2f0
movq %rsp, %r15
movq %r15, %rdi
movq %r13, %rsi
callq 0x40a578
leaq 0xa0(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x40a2f0
leaq 0x80(%rsp), %r12
movq %r12, %rdi
movq %r13, %rsi
movl $0x5, %edx
movq %r13, %rcx
callq 0x407c67
leaq 0x60(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
movl $0xa, %edx
movq %r12, %rcx
callq 0x407c67
movq %r15, %rdi
movq %r13, %rsi
movl $0x14, %edx
movq %r13, %rcx
callq 0x407c67
leaq 0x40(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
movl $0xa, %edx
movq %r12, %rcx
callq 0x407c67
leaq 0x20(%rsp), %r12
movq %r12, %rdi
movq %r13, %rsi
movl $0x32, %edx
movq %r13, %rcx
callq 0x407c67
movq %r15, %rdi
movq %r12, %rsi
movl $0x64, %edx
movq %r12, %rcx
callq 0x407c67
movq %r15, %rdi
movq %r15, %rsi
movl $0x32, %edx
movq %r13, %rcx
callq 0x407c67
movq %r15, %rdi
movq %r15, %rsi
callq 0x40a578
movq %r15, %rdi
movq %r15, %rsi
callq 0x40a578
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x40a2f0
addq $0x120, %rsp            # imm = 0x120
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x40a578
cmpl $0x2, %ebp
jl 0x407c9d
incl %ebp
movq %rsp, %r15
movq %r15, %rdi
movq %r15, %rsi
callq 0x40a578
decl %ebp
cmpl $0x2, %ebp
jg 0x407c8b
movq %rsp, %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x40a2f0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x409ff8
leaq 0x20(%r13), %rdx
movq %r14, %rdi
movq %r14, %rsi
callq 0x40a2f0
leaq 0x60(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x409f38
movq %r15, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x40a2f0
leaq 0x60(%rbp), %rsi
leaq 0x40(%r13), %rdx
movq %rsp, %rdi
callq 0x40a2f0
addq $0x40, %rbp
addq $0x60, %r13
leaq 0x40(%rsp), %r12
movq %r12, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x40a2f0
leaq 0x20(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x409ff8
movq %r15, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x409f38
movq %r14, %rdi
movq %r12, %rsi
movq %rsp, %rbp
movq %rbp, %rdx
callq 0x409ff8
movq %r12, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x409f38
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x40a2f0
leaq 0x20(%rbx), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x40a2f0
leaq 0x60(%rbx), %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x40a2f0
addq $0x40, %rbx
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x40a2f0
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/msotoodeh[P]asymmetric-passwords/common/curve25519/sha512.c
// Function: SHA512_Init
void SHA512_Init (SHA512_CTX *c)
{
    c->h[0]=UINT64(0x6a09e667f3bcc908);
    c->h[1]=UINT64(0xbb67ae8584caa73b);
    c->h[2]=UINT64(0x3c6ef372fe94f82b);
    c->h[3]=UINT64(0xa54ff53a5f1d36f1);
    c->h[4]=UINT64(0x510e527fade682d1);
    c->h[5]=UINT64(0x9b05688c2b3e6c1f);
    c->h[6]=UINT64(0x1f83d9abfb41bd6b);
    c->h[7]=UINT64(0x5be0cd19137e2179);

    c->Nl=0;
    c->Nh=0;
    c->num=0;
    c->md_len=SHA512_DIGEST_LENGTH;
}

// Assembly:
movabsq $0x6a09e667f3bcc908, %rax # imm = 0x6A09E667F3BCC908
movq %rax, (%rdi)
movabsq $-0x4498517a7b3558c5, %rax # imm = 0xBB67AE8584CAA73B
movq %rax, 0x8(%rdi)
movabsq $0x3c6ef372fe94f82b, %rax # imm = 0x3C6EF372FE94F82B
movq %rax, 0x10(%rdi)
movabsq $-0x5ab00ac5a0e2c90f, %rax # imm = 0xA54FF53A5F1D36F1
movq %rax, 0x18(%rdi)
movabsq $0x510e527fade682d1, %rax # imm = 0x510E527FADE682D1
movq %rax, 0x20(%rdi)
movabsq $-0x64fa9773d4c193e1, %rax # imm = 0x9B05688C2B3E6C1F
movq %rax, 0x28(%rdi)
movabsq $0x1f83d9abfb41bd6b, %rax # imm = 0x1F83D9ABFB41BD6B
movq %rax, 0x30(%rdi)
movabsq $0x5be0cd19137e2179, %rax # imm = 0x5BE0CD19137E2179
movq %rax, 0x38(%rdi)
movabsq $0x4000000000, %rax     # imm = 0x4000000000
movq %rax, 0xd0(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x409bfd
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq (,%rdx,8), %rax
addq 0x40(%rdi), %rax
jae 0x409b42
incq 0x48(%rbx)
movq %r14, %rcx
shrq $0x3d, %rcx
addq %rcx, 0x48(%rbx)
leaq 0x50(%rbx), %r12
movq %rax, 0x40(%rbx)
movl 0xd0(%rbx), %edi
testq %rdi, %rdi
je 0x409bb3
movl $0x80, %r13d
subl %edi, %r13d
addq %r12, %rdi
movq %r14, %rbp
movq %r15, %rsi
subq %r13, %rbp
jae 0x409b8b
movq %r14, %rdx
callq 0x401110
addl %r14d, 0xd0(%rbx)
movq %r14, %rbp
jmp 0x409bab
movq %r13, %rdx
callq 0x401110
movl $0x0, 0xd0(%rbx)
addq %r13, %r15
movq %rbx, %rdi
movq %r12, %rsi
callq 0x408461
cmpq %r13, %r14
movq %rbp, %r14
jb 0x409bef
cmpq $0x80, %r14
jb 0x409bd5
movq %rbx, %rdi
movq %r15, %rsi
callq 0x408461
subq $-0x80, %r15
addq $-0x80, %r14
cmpq $0x7f, %r14
ja 0x409bbc
testq %r14, %r14
je 0x409bef
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x401110
movl %r14d, 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_O1/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 %rsi, -0x40(%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, -0x38(%rbp)
testq %rdx, %rdx
je 0x409c98
xorl %r15d, %r15d
leaq 0x176e4e(%rip), %r14    # 0x580a90
xorl %r12d, %r12d
xorl %r13d, %r13d
movl %r13d, %eax
shll $0x8, %eax
movq -0x40(%rbp), %rcx
movzbl (%rcx,%r15), %r13d
orl %eax, %r13d
addl $0x8, %r12d
cmpl $0x6, %r12d
jb 0x409c8d
addl $-0x6, %r12d
movl %r13d, %eax
movl %r12d, %ecx
shrl %cl, %eax
andl $0x3f, %eax
movsbl (%rax,%r14), %r8d
movq 0x8(%rbx), %rsi
movl $0x1, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x4784a0
jmp 0x409c5e
incq %r15
cmpq -0x38(%rbp), %r15
jne 0x409c48
jmp 0x409c9e
xorl %r13d, %r13d
xorl %r12d, %r12d
testl %r12d, %r12d
je 0x409ccf
movb $0x6, %cl
subb %r12b, %cl
shll %cl, %r13d
andl $0x3f, %r13d
leaq 0x176dda(%rip), %rax    # 0x580a90
movsbl (%r13,%rax), %r8d
movq 0x8(%rbx), %rsi
movl $0x1, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x4784a0
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x409ce3
movq %rax, %r14
movq (%rbx), %rdi
movq -0x30(%rbp), %rax
cmpq %rax, %rdi
je 0x409cfd
movq (%rax), %rsi
incq %rsi
callq 0x40ad30
movq %r14, %rdi
callq 0x4a9c80
// File: /workspace/github_cpp_makefile_star2_O1/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 0x409da1
pushq %rbp
movq %rsp, %rbp
pushq %rbx
leaq 0x176d92(%rip), %r9     # 0x580ad0
xorl %r11d, %r11d
xorl %r10d, %r10d
xorl %eax, %eax
cmpl $0x7, %r11d
ja 0x409d7e
movq (%rdi), %rbx
movl %r8d, %ecx
incl %r8d
movzbl (%rbx,%rcx), %ecx
movzbl (%rcx,%r9), %ecx
cmpl $0x40, %ecx
je 0x409d4f
cmpb $0x3f, %cl
ja 0x409d9e
shll $0x6, %r10d
orl %ecx, %r10d
leal 0x6(%r11), %ecx
cmpl $0x2, %r11d
movl %ecx, %r11d
jb 0x409d4f
jmp 0x409d81
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 0x409d46
movq %rdx, %rax
popq %rbx
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/msotoodeh[P]asymmetric-passwords/common/curve25519/curve25519_mehdi.c
// Function: ecp_Sub
S32 ecp_Sub(U32* Z, const U32* X, const U32* Y) 
{
    M64 b;
    ECP_SUB32(Z[0], X[0], Y[0]);
    ECP_SBC32(Z[1], X[1], Y[1]);
    ECP_SBC32(Z[2], X[2], Y[2]);
    ECP_SBC32(Z[3], X[3], Y[3]);
    ECP_SBC32(Z[4], X[4], Y[4]);
    ECP_SBC32(Z[5], X[5], Y[5]);
    ECP_SBC32(Z[6], X[6], Y[6]);
    ECP_SBC32(Z[7], X[7], Y[7]);
    return b.s32.hi;
}

// Assembly:
movl (%rsi), %eax
movl (%rdx), %ecx
subq %rcx, %rax
movl %eax, (%rdi)
movl 0x4(%rsi), %ecx
movl 0x4(%rdx), %r8d
subq %r8, %rcx
sarq $0x20, %rax
addq %rcx, %rax
movl %eax, 0x4(%rdi)
movl 0x8(%rsi), %ecx
movl 0x8(%rdx), %r8d
subq %r8, %rcx
sarq $0x20, %rax
addq %rcx, %rax
movl %eax, 0x8(%rdi)
movl 0xc(%rsi), %ecx
movl 0xc(%rdx), %r8d
subq %r8, %rcx
sarq $0x20, %rax
addq %rcx, %rax
movl %eax, 0xc(%rdi)
movl 0x10(%rsi), %ecx
movl 0x10(%rdx), %r8d
subq %r8, %rcx
sarq $0x20, %rax
addq %rcx, %rax
movl %eax, 0x10(%rdi)
movl 0x14(%rsi), %ecx
movl 0x14(%rdx), %r8d
subq %r8, %rcx
sarq $0x20, %rax
addq %rcx, %rax
movl %eax, 0x14(%rdi)
movl 0x18(%rsi), %ecx
movl 0x18(%rdx), %r8d
subq %r8, %rcx
sarq $0x20, %rax
addq %rcx, %rax
movl %eax, 0x18(%rdi)
movl 0x1c(%rsi), %ecx
movl 0x1c(%rdx), %edx
subq %rdx, %rcx
sarq $0x20, %rax
addq %rcx, %rax
movl %eax, 0x1c(%rdi)
shrq $0x20, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/msotoodeh[P]asymmetric-passwords/common/curve25519/curve25519_mehdi.c
// Function: ecp_Add
U32 ecp_Add(U32* Z, const U32* X, const U32* Y) 
{
    M64 c;

    ECP_ADD32(Z[0], X[0], Y[0]);
    ECP_ADC32(Z[1], X[1], Y[1]);
    ECP_ADC32(Z[2], X[2], Y[2]);
    ECP_ADC32(Z[3], X[3], Y[3]);
    ECP_ADC32(Z[4], X[4], Y[4]);
    ECP_ADC32(Z[5], X[5], Y[5]);
    ECP_ADC32(Z[6], X[6], Y[6]);
    ECP_ADC32(Z[7], X[7], Y[7]);
    return c.u32.hi;
}

// Assembly:
movl (%rdx), %eax
addl (%rsi), %eax
movl %eax, (%rdi)
movl 0x4(%rsi), %eax
movl 0x4(%rdx), %ecx
adcq %rax, %rcx
movl %ecx, 0x4(%rdi)
shrq $0x20, %rcx
movl 0x8(%rsi), %eax
movl 0x8(%rdx), %r8d
addq %rax, %r8
addq %rcx, %r8
movl %r8d, 0x8(%rdi)
shrq $0x20, %r8
movl 0xc(%rsi), %eax
movl 0xc(%rdx), %ecx
addq %rax, %rcx
addq %r8, %rcx
movl %ecx, 0xc(%rdi)
shrq $0x20, %rcx
movl 0x10(%rsi), %eax
movl 0x10(%rdx), %r8d
addq %rax, %r8
addq %rcx, %r8
movl %r8d, 0x10(%rdi)
shrq $0x20, %r8
movl 0x14(%rsi), %eax
movl 0x14(%rdx), %ecx
addq %rax, %rcx
addq %r8, %rcx
movl %ecx, 0x14(%rdi)
shrq $0x20, %rcx
movl 0x18(%rsi), %eax
movl 0x18(%rdx), %r8d
addq %rax, %r8
addq %rcx, %r8
movl %r8d, 0x18(%rdi)
shrq $0x20, %r8
movl 0x1c(%rsi), %eax
movl 0x1c(%rdx), %ecx
addq %rax, %rcx
addq %r8, %rcx
movl %ecx, 0x1c(%rdi)
movq %rcx, %rax
shrq $0x20, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/msotoodeh[P]asymmetric-passwords/common/curve25519/curve25519_mehdi.c
// Function: ecp_AddReduce
void ecp_AddReduce(U32* Z, const U32* X, const U32* Y) 
{
    M64 c;
    c.u32.hi = ecp_Add(Z, X, Y) * 38;

    /* Z += c.u32.hi * 38 */
    ECP_ADD_C0(Z[0], Z[0], c.u32.hi);
    ECP_ADD_C1(Z[1], Z[1]);
    ECP_ADD_C1(Z[2], Z[2]);
    ECP_ADD_C1(Z[3], Z[3]);
    ECP_ADD_C1(Z[4], Z[4]);
    ECP_ADD_C1(Z[5], Z[5]);
    ECP_ADD_C1(Z[6], Z[6]);
    ECP_ADD_C1(Z[7], Z[7]);

    /* One more carry at most */
    ECP_ADD_C0(Z[0], Z[0], c.u32.hi*38);
    ECP_ADD_C1(Z[1], Z[1]);
    ECP_ADD_C1(Z[2], Z[2]);
    ECP_ADD_C1(Z[3], Z[3]);
    ECP_ADD_C1(Z[4], Z[4]);
    ECP_ADD_C1(Z[5], Z[5]);
    ECP_ADD_C1(Z[6], Z[6]);
    ECP_ADD_C1(Z[7], Z[7]);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x409ea6
imull $0x26, %eax, %eax
addl (%rbx), %eax
movl 0x4(%rbx), %edx
movl 0x8(%rbx), %esi
adcq $0x0, %rdx
movl %edx, %ecx
shrq $0x20, %rdx
addq %rdx, %rsi
movl %esi, %edx
shrq $0x20, %rsi
movl 0xc(%rbx), %edi
addq %rsi, %rdi
movl %edi, %esi
shrq $0x20, %rdi
movl 0x10(%rbx), %r8d
addq %rdi, %r8
movl %r8d, %edi
shrq $0x20, %r8
movl 0x14(%rbx), %r9d
addq %r8, %r9
movl %r9d, %r8d
shrq $0x20, %r9
movl 0x18(%rbx), %r11d
addq %r9, %r11
movl %r11d, %r10d
shrq $0x20, %r11
movl 0x1c(%rbx), %r9d
addq %r11, %r9
movq %r9, %r11
shrq $0x20, %r11
imulq $0x26, %r11, %r11
addq %rax, %r11
movl %r11d, (%rbx)
shrq $0x20, %r11
addq %r11, %rcx
movl %ecx, 0x4(%rbx)
shrq $0x20, %rcx
addq %rcx, %rdx
movl %edx, 0x8(%rbx)
shrq $0x20, %rdx
addq %rdx, %rsi
movl %esi, 0xc(%rbx)
shrq $0x20, %rsi
addq %rsi, %rdi
movl %edi, 0x10(%rbx)
shrq $0x20, %rdi
addq %rdi, %r8
movl %r8d, 0x14(%rbx)
shrq $0x20, %r8
addq %r8, %r10
movl %r10d, 0x18(%rbx)
shrq $0x20, %r10
addl %r9d, %r10d
movl %r10d, 0x1c(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/msotoodeh[P]asymmetric-passwords/common/curve25519/curve25519_mehdi.c
// Function: ecp_SubReduce
void ecp_SubReduce(U32* Z, const U32* X, const U32* Y) 
{
    M64 c;
    c.u32.hi = ecp_Sub(Z, X, Y) & 38;

    ECP_SUB_C0(Z[0], Z[0], c.u32.hi);
    ECP_SUB_C1(Z[1], Z[1]);
    ECP_SUB_C1(Z[2], Z[2]);
    ECP_SUB_C1(Z[3], Z[3]);
    ECP_SUB_C1(Z[4], Z[4]);
    ECP_SUB_C1(Z[5], Z[5]);
    ECP_SUB_C1(Z[6], Z[6]);
    ECP_SUB_C1(Z[7], Z[7]);

    ECP_SUB_C0(Z[0], Z[0], c.u32.hi & 38);
    ECP_SUB_C1(Z[1], Z[1]);
    ECP_SUB_C1(Z[2], Z[2]);
    ECP_SUB_C1(Z[3], Z[3]);
    ECP_SUB_C1(Z[4], Z[4]);
    ECP_SUB_C1(Z[5], Z[5]);
    ECP_SUB_C1(Z[6], Z[6]);
    ECP_SUB_C1(Z[7], Z[7]);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x409e0d
andl $0x26, %eax
movl (%rbx), %edx
movl 0x4(%rbx), %ecx
subq %rax, %rdx
movl %edx, %eax
sarq $0x20, %rdx
addq %rcx, %rdx
movl 0x8(%rbx), %esi
movl %edx, %ecx
movq %rdx, %rdi
sarq $0x20, %rdi
addq %rsi, %rdi
movl 0xc(%rbx), %esi
movl %edi, %edx
sarq $0x20, %rdi
addq %rsi, %rdi
movl 0x10(%rbx), %r8d
movl %edi, %esi
movq %rdi, %r9
sarq $0x20, %r9
addq %r8, %r9
movl 0x14(%rbx), %r8d
movl %r9d, %edi
sarq $0x20, %r9
addq %r8, %r9
movl 0x18(%rbx), %r10d
movl %r9d, %r8d
sarq $0x20, %r9
addq %r10, %r9
movl 0x1c(%rbx), %r10d
movl %r9d, %r11d
sarq $0x20, %r9
addq %r10, %r9
movq %r9, %r10
shrq $0x20, %r10
andl $0x26, %r10d
subq %r10, %rax
movl %eax, (%rbx)
sarq $0x20, %rax
addq %rcx, %rax
movl %eax, 0x4(%rbx)
sarq $0x20, %rax
addq %rdx, %rax
movl %eax, 0x8(%rbx)
sarq $0x20, %rax
addq %rsi, %rax
movl %eax, 0xc(%rbx)
sarq $0x20, %rax
addq %rdi, %rax
movl %eax, 0x10(%rbx)
sarq $0x20, %rax
addq %r8, %rax
movl %eax, 0x14(%rbx)
sarq $0x20, %rax
addq %r11, %rax
movl %eax, 0x18(%rbx)
shrq $0x20, %rax
addl %r9d, %eax
movl %eax, 0x1c(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x176afb(%rip), %r15    # 0x580bd0
movq %rdi, %rsi
movq %r15, %rdx
callq 0x409e0d
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 0x409ea6
movq %rbx, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x409e0d
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 0x409ea6
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x40a3b0
leaq 0x4(%rsp), %rdi
movl 0x4(%r12), %esi
movq %r15, %rdx
callq 0x40a433
leaq 0x8(%rsp), %rdi
movl 0x8(%r12), %esi
movq %r15, %rdx
callq 0x40a433
leaq 0xc(%rsp), %rdi
movl 0xc(%r12), %esi
movq %r15, %rdx
callq 0x40a433
leaq 0x10(%rsp), %rdi
movl 0x10(%r12), %esi
movq %r15, %rdx
callq 0x40a433
leaq 0x14(%rsp), %rdi
movl 0x14(%r12), %esi
movq %r15, %rdx
callq 0x40a433
leaq 0x18(%rsp), %rdi
movl 0x18(%r12), %esi
movq %r15, %rdx
callq 0x40a433
leaq 0x1c(%rsp), %rdi
movl 0x1c(%r12), %esi
movq %r15, %rdx
callq 0x40a433
leaq 0x20(%rsp), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x26, %edx
callq 0x40a161
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/msotoodeh[P]asymmetric-passwords/common/curve25519/curve25519_mehdi.c
// Function: ecp_mul_set
static void ecp_mul_set(U32* Y, U32 b, const U32* X) 
{
    M64 c;
    ECP_MULSET_W0(Y[0], b, X[0]);
    ECP_MULSET_W1(Y[1], b, X[1]);
    ECP_MULSET_W1(Y[2], b, X[2]);
    ECP_MULSET_W1(Y[3], b, X[3]);
    ECP_MULSET_W1(Y[4], b, X[4]);
    ECP_MULSET_W1(Y[5], b, X[5]);
    ECP_MULSET_W1(Y[6], b, X[6]);
    ECP_MULSET_W1(Y[7], b, X[7]);
    Y[8] = c.u32.hi;
}

// Assembly:
movl %esi, %eax
movl (%rdx), %ecx
imulq %rax, %rcx
movl %ecx, (%rdi)
shrq $0x20, %rcx
movl 0x4(%rdx), %esi
imulq %rax, %rsi
addq %rcx, %rsi
movl %esi, 0x4(%rdi)
shrq $0x20, %rsi
movl 0x8(%rdx), %ecx
imulq %rax, %rcx
addq %rsi, %rcx
movl %ecx, 0x8(%rdi)
shrq $0x20, %rcx
movl 0xc(%rdx), %esi
imulq %rax, %rsi
addq %rcx, %rsi
movl %esi, 0xc(%rdi)
shrq $0x20, %rsi
movl 0x10(%rdx), %ecx
imulq %rax, %rcx
addq %rsi, %rcx
movl %ecx, 0x10(%rdi)
shrq $0x20, %rcx
movl 0x14(%rdx), %esi
imulq %rax, %rsi
addq %rcx, %rsi
movl %esi, 0x14(%rdi)
shrq $0x20, %rsi
movl 0x18(%rdx), %ecx
imulq %rax, %rcx
addq %rsi, %rcx
movl %ecx, 0x18(%rdi)
shrq $0x20, %rcx
movl 0x1c(%rdx), %edx
imulq %rax, %rdx
addq %rcx, %rdx
movq %rdx, 0x1c(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/msotoodeh[P]asymmetric-passwords/common/curve25519/curve25519_mehdi.c
// Function: ecp_mul_add
static void ecp_mul_add(U32* Y, U32 b, const U32* X) 
{
    M64 c;
    ECP_MULADD_W0(Y[0], Y[0], b, X[0]);
    ECP_MULADD_W1(Y[1], Y[1], b, X[1]);
    ECP_MULADD_W1(Y[2], Y[2], b, X[2]);
    ECP_MULADD_W1(Y[3], Y[3], b, X[3]);
    ECP_MULADD_W1(Y[4], Y[4], b, X[4]);
    ECP_MULADD_W1(Y[5], Y[5], b, X[5]);
    ECP_MULADD_W1(Y[6], Y[6], b, X[6]);
    ECP_MULADD_W1(Y[7], Y[7], b, X[7]);
    Y[8] = c.u32.hi;
}

// Assembly:
movl %esi, %eax
movl (%rdx), %ecx
imulq %rax, %rcx
movl (%rdi), %esi
movl 0x4(%rdi), %r8d
addq %rcx, %rsi
movl %esi, (%rdi)
shrq $0x20, %rsi
movl 0x4(%rdx), %ecx
imulq %rax, %rcx
addq %rcx, %r8
addq %rsi, %r8
movl %r8d, 0x4(%rdi)
shrq $0x20, %r8
movl 0x8(%rdx), %ecx
imulq %rax, %rcx
movl 0x8(%rdi), %esi
addq %rcx, %rsi
addq %r8, %rsi
movl %esi, 0x8(%rdi)
shrq $0x20, %rsi
movl 0xc(%rdx), %ecx
imulq %rax, %rcx
movl 0xc(%rdi), %r8d
addq %rcx, %r8
addq %rsi, %r8
movl %r8d, 0xc(%rdi)
shrq $0x20, %r8
movl 0x10(%rdx), %ecx
imulq %rax, %rcx
movl 0x10(%rdi), %esi
addq %rcx, %rsi
addq %r8, %rsi
movl %esi, 0x10(%rdi)
shrq $0x20, %rsi
movl 0x14(%rdx), %ecx
imulq %rax, %rcx
movl 0x14(%rdi), %r8d
addq %rcx, %r8
addq %rsi, %r8
movl %r8d, 0x14(%rdi)
shrq $0x20, %r8
movl 0x18(%rdx), %ecx
imulq %rax, %rcx
movl 0x18(%rdi), %esi
addq %rcx, %rsi
addq %r8, %rsi
movl %esi, 0x18(%rdi)
shrq $0x20, %rsi
movl 0x1c(%rdx), %ecx
imulq %rax, %rcx
movl 0x1c(%rdi), %eax
addq %rcx, %rax
addq %rsi, %rax
movq %rax, 0x1c(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x40a3b0
leaq 0x4(%r15), %rdi
movl 0x4(%r14), %esi
movq %rbx, %rdx
callq 0x40a433
leaq 0x8(%r15), %rdi
movl 0x8(%r14), %esi
movq %rbx, %rdx
callq 0x40a433
leaq 0xc(%r15), %rdi
movl 0xc(%r14), %esi
movq %rbx, %rdx
callq 0x40a433
leaq 0x10(%r15), %rdi
movl 0x10(%r14), %esi
movq %rbx, %rdx
callq 0x40a433
leaq 0x14(%r15), %rdi
movl 0x14(%r14), %esi
movq %rbx, %rdx
callq 0x40a433
leaq 0x18(%r15), %rdi
movl 0x18(%r14), %esi
movq %rbx, %rdx
callq 0x40a433
addq $0x1c, %r15
movl 0x1c(%r14), %esi
movq %r15, %rdi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x40a433
// File: /workspace/github_cpp_makefile_star2_O1/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 0x40a3b0
leaq 0x4(%rsp), %rdi
movl 0x4(%r15), %esi
movq %r15, %rdx
callq 0x40a433
leaq 0x8(%rsp), %rdi
movl 0x8(%r15), %esi
movq %r15, %rdx
callq 0x40a433
leaq 0xc(%rsp), %rdi
movl 0xc(%r15), %esi
movq %r15, %rdx
callq 0x40a433
leaq 0x10(%rsp), %rdi
movl 0x10(%r15), %esi
movq %r15, %rdx
callq 0x40a433
leaq 0x14(%rsp), %rdi
movl 0x14(%r15), %esi
movq %r15, %rdx
callq 0x40a433
leaq 0x18(%rsp), %rdi
movl 0x18(%r15), %esi
movq %r15, %rdx
callq 0x40a433
leaq 0x1c(%rsp), %rdi
movl 0x1c(%r15), %esi
movq %r15, %rdx
callq 0x40a433
leaq 0x20(%rsp), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x26, %edx
callq 0x40a161
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x409e0d
andl $0x1, %eax
shll $0x5, %eax
leaq 0x176225(%rip), %rdx    # 0x580c10
addq %rax, %rdx
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x409ea6
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x40a4eb
leaq 0x1c(%rsp), %rdi
movl 0x20(%rdi), %esi
movq %rdi, %rdx
callq 0x40a968
leaq 0x18(%rsp), %rdi
movl 0x20(%rdi), %esi
movq %rdi, %rdx
callq 0x40a968
leaq 0x14(%rsp), %rdi
movl 0x20(%rdi), %esi
movq %rdi, %rdx
callq 0x40a968
leaq 0x10(%rsp), %rdi
movl 0x20(%rdi), %esi
movq %rdi, %rdx
callq 0x40a968
leaq 0xc(%rsp), %rdi
movl 0x20(%rdi), %esi
movq %rdi, %rdx
callq 0x40a968
leaq 0x8(%rsp), %rdi
movl 0x20(%rdi), %esi
movq %rdi, %rdx
callq 0x40a968
leaq 0x4(%rsp), %r15
movl 0x20(%r15), %esi
movq %r15, %rdi
movq %r15, %rdx
callq 0x40a968
movl 0x1c(%r15), %esi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x40a968
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x40abdd
leaq 0x20(%rsp), %rdi
addq $0x20, %r15
movq %r15, %rsi
callq 0x40abdd
leaq 0x1c(%rsp), %rdi
movl 0x20(%rdi), %esi
movq %rdi, %rdx
callq 0x40a968
leaq 0x18(%rsp), %rdi
movl 0x20(%rdi), %esi
movq %rdi, %rdx
callq 0x40a968
leaq 0x14(%rsp), %rdi
movl 0x20(%rdi), %esi
movq %rdi, %rdx
callq 0x40a968
leaq 0x10(%rsp), %rdi
movl 0x20(%rdi), %esi
movq %rdi, %rdx
callq 0x40a968
leaq 0xc(%rsp), %rdi
movl 0x20(%rdi), %esi
movq %rdi, %rdx
callq 0x40a968
leaq 0x8(%rsp), %rdi
movl 0x20(%rdi), %esi
movq %rdi, %rdx
callq 0x40a968
leaq 0x4(%rsp), %r15
movl 0x20(%r15), %esi
movq %r15, %rdi
movq %r15, %rdx
callq 0x40a968
movl 0x1c(%r15), %esi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x40a968
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x1f, %eax
movl $0xff, %ecx
xorl %edx, %edx
movl $0xa, %r9d
xorl %r8d, %r8d
andl %ecx, %r8d
movl -0x10(%rsi,%r9,4), %r10d
movl -0xc(%rsi,%r9,4), %r11d
xorl %ebx, %ebx
btl %eax, %r11d
setb %bl
leal (%rbx,%r8,2), %r8d
andl %ecx, %edx
xorl %r11d, %r11d
btl %eax, %r10d
setb %r11b
leal (%r11,%rdx,2), %edx
addq $-0x2, %r9
cmpq $0x3, %r9
ja 0x40acad
movb %r8b, (%rdi)
movb %dl, 0x20(%rdi)
incq %rdi
subl $0x1, %eax
jae 0x40aca2
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/calebstewart[P]md5/md5.cpp
// Function: MD5::reset()
void MD5::reset()
{
  a = 0x67452301;
  b = 0xefcdab89;
  c = 0x98badcfe;
  d = 0x10325476;
  lo = 0;
  hi = 0;

  memset(buffer, 0, 64*sizeof(unsigned char));
  memset(block, 0, 16*sizeof(unsigned long));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq $0x67452301, 0x10(%rdi) # imm = 0x67452301
movl $0x98badcfe, %eax       # imm = 0x98BADCFE
leaq 0x5712ce8b(%rax), %rcx
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq $0x10325476, 0x28(%rdi) # imm = 0x10325476
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
addq $0x30, %rdi
movl $0xc0, %edx
xorl %esi, %esi
popq %rbp
jmp 0x1040
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
leal (%rax,%rdx), %ecx
andl $0x1fffffff, %ecx       # imm = 0x1FFFFFFF
movq %rcx, (%rdi)
cmpq %rax, %rcx
jae 0x1278
incq 0x8(%r14)
movq %rdx, %rcx
shrq $0x1d, %rcx
addq %rcx, 0x8(%r14)
andq $0x3f, %rax
je 0x12a7
movl $0x40, %r12d
subq %rax, %r12
movq %rdx, %r15
leaq (%r14,%rax), %rdi
addq $0x30, %rdi
subq %r12, %r15
jae 0x12ac
movq %rbx, %rsi
jmp 0x12fa
movq %rdx, %r15
jmp 0x12ce
leaq 0x30(%r14), %r13
movq %rbx, %rsi
movq %r12, %rdx
callq 0x1050
addq %r12, %rbx
movl $0x40, %edx
movq %r14, %rdi
movq %r13, %rsi
callq 0x130e
cmpq $0x40, %r15
jb 0x12ed
movq %r15, %rdx
andq $-0x40, %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x130e
movq %rax, %rbx
andl $0x3f, %r15d
addq $0x30, %r14
movq %r14, %rdi
movq %rbx, %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_O1/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), %r12
andl $0x3f, %r12d
leaq 0x30(%rdi), %r15
leaq 0x1(%r12), %rdi
movb $-0x80, 0x30(%r14,%r12)
xorq $0x3f, %r12
cmpq $0x7, %r12
ja 0x1fc2
addq %r15, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x1040
movl $0x40, %r12d
movl $0x40, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x130e
xorl %edi, %edi
addq %r15, %rdi
addq $-0x8, %r12
xorl %esi, %esi
movq %r12, %rdx
callq 0x1040
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)
movl $0x40, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x130e
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
// File: /workspace/github_cpp_makefile_star2_O1/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 0x210a
leaq -0x110(%rbp), %r15
movl $0x1, %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0x124c
cmpb $0x0, 0x1(%r14)
leaq 0x1(%r14), %r14
jne 0x20ef
leaq -0x110(%rbp), %rdi
movq %rbx, %rsi
callq 0x1f6c
addq $0xf8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xe51(%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 0x21bf
movb $0x0, 0x20(%rsi)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2128
leaq -0x60(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21b2
movq 0x2da3(%rip), %rbx      # 0x4fd8
leaq 0xdef(%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 0xde6(%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_O1/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 0x3a62
movq %rax, %r14
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x35da
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x21d0
testq %r14, %r14
je 0x369a
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 0x35fd
xorl %ecx, %ecx
movq %rcx, 0xb8(%rax)
movb $0x1, 0xc0(%rax)
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 0x3661
movq %r14, %rsi
addq $0x38, %rsi
jmp 0x3674
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 0x36bf
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x21d0
movq %rbx, %rdi
callq 0x22b0
nop