LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq %rdx, 0x30(%rsp)
movl 0x3c(%rsp), %eax
movabsq $0xcf5d3ed0, %rcx       # imm = 0xCF5D3ED0
imulq %rcx, %rax
movq %rax, 0x28(%rsp)
movl 0x28(%rsp), %eax
movl %eax, (%rsp)
movl 0x3c(%rsp), %eax
movabsq $0x812631a5, %rcx       # imm = 0x812631A5
imulq %rcx, %rax
movl 0x2c(%rsp), %ecx
addq %rcx, %rax
movq %rax, 0x28(%rsp)
movl 0x28(%rsp), %eax
movl %eax, 0x4(%rsp)
movl 0x3c(%rsp), %eax
imulq $0x2f79cd65, %rax, %rax # imm = 0x2F79CD65
movl 0x2c(%rsp), %ecx
addq %rcx, %rax
movq %rax, 0x28(%rsp)
movl 0x28(%rsp), %eax
movl %eax, 0x8(%rsp)
movl 0x3c(%rsp), %eax
imulq $0x4def9dea, %rax, %rax # imm = 0x4DEF9DEA
movl 0x2c(%rsp), %ecx
addq %rcx, %rax
movq %rax, 0x28(%rsp)
movl 0x28(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0x3c(%rsp), %eax
movl 0x2c(%rsp), %ecx
addq %rcx, %rax
movq %rax, 0x28(%rsp)
movl 0x28(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0x2c(%rsp), %eax
movl %eax, 0x14(%rsp)
movl $0x0, 0x18(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq %rsp, %rdx
callq 0x40fd20
movl %eax, 0x2c(%rsp)
movq 0x40(%rsp), %rdi
movq 0x40(%rsp), %rsi
movl 0x2c(%rsp), %eax
andl $0x1, %eax
cltq
leaq 0x17668c(%rip), %rdx    # 0x587c00
shlq $0x5, %rax
addq %rax, %rdx
callq 0x40fe90
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rsp, %rdi
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdx
callq 0x410d20
movq %rsp, %rdi
addq $0x1c, %rdi
movl 0x3c(%rsp), %esi
movq %rsp, %rdx
addq $0x1c, %rdx
callq 0x411480
movq %rsp, %rdi
addq $0x18, %rdi
movl 0x38(%rsp), %esi
movq %rsp, %rdx
addq $0x18, %rdx
callq 0x411480
movq %rsp, %rdi
addq $0x14, %rdi
movl 0x34(%rsp), %esi
movq %rsp, %rdx
addq $0x14, %rdx
callq 0x411480
movq %rsp, %rdi
addq $0x10, %rdi
movl 0x30(%rsp), %esi
movq %rsp, %rdx
addq $0x10, %rdx
callq 0x411480
movq %rsp, %rdi
addq $0xc, %rdi
movl 0x2c(%rsp), %esi
movq %rsp, %rdx
addq $0xc, %rdx
callq 0x411480
movq %rsp, %rdi
addq $0x8, %rdi
movl 0x28(%rsp), %esi
movq %rsp, %rdx
addq $0x8, %rdx
callq 0x411480
movq %rsp, %rdi
addq $0x4, %rdi
movl 0x24(%rsp), %esi
movq %rsp, %rdx
addq $0x4, %rdx
callq 0x411480
movq 0x50(%rsp), %rdi
movl 0x20(%rsp), %esi
movq %rsp, %rdx
callq 0x411480
addq $0x58, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rsp, %rdi
movq 0x48(%rsp), %rsi
callq 0x4118a0
movq %rsp, %rdi
addq $0x20, %rdi
movq 0x48(%rsp), %rsi
addq $0x20, %rsi
callq 0x4118a0
movq %rsp, %rdi
addq $0x1c, %rdi
movl 0x3c(%rsp), %esi
movq %rsp, %rdx
addq $0x1c, %rdx
callq 0x411480
movq %rsp, %rdi
addq $0x18, %rdi
movl 0x38(%rsp), %esi
movq %rsp, %rdx
addq $0x18, %rdx
callq 0x411480
movq %rsp, %rdi
addq $0x14, %rdi
movl 0x34(%rsp), %esi
movq %rsp, %rdx
addq $0x14, %rdx
callq 0x411480
movq %rsp, %rdi
addq $0x10, %rdi
movl 0x30(%rsp), %esi
movq %rsp, %rdx
addq $0x10, %rdx
callq 0x411480
movq %rsp, %rdi
addq $0xc, %rdi
movl 0x2c(%rsp), %esi
movq %rsp, %rdx
addq $0xc, %rdx
callq 0x411480
movq %rsp, %rdi
addq $0x8, %rdi
movl 0x28(%rsp), %esi
movq %rsp, %rdx
addq $0x8, %rdx
callq 0x411480
movq %rsp, %rdi
addq $0x4, %rdi
movl 0x24(%rsp), %esi
movq %rsp, %rdx
addq $0x4, %rdx
callq 0x411480
movq 0x50(%rsp), %rdi
movl 0x20(%rsp), %esi
movq %rsp, %rdx
callq 0x411480
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: msotoodeh[P]asymmetric-passwords/common/curve25519/curve25519_utils.c
// Function: ecp_BytesToWords
U32* ecp_BytesToWords(OUT U32 *Y, IN const U8 *X)
{
    int i;
    M32 m;
    
    for (i = 0; i < 8; i++)
    {
        m.u8.b0 = *X++;
        m.u8.b1 = *X++;
        m.u8.b2 = *X++;
        m.u8.b3 = *X++;
        
        Y[i] = m.u32;
    }
    return Y;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl $0x0, -0x14(%rsp)
cmpl $0x8, -0x14(%rsp)
jge 0x411936
movq -0x10(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rsp)
movb (%rax), %al
movb %al, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rsp)
movb (%rax), %al
movb %al, -0x17(%rsp)
movq -0x10(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rsp)
movb (%rax), %al
movb %al, -0x16(%rsp)
movq -0x10(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rsp)
movb (%rax), %al
movb %al, -0x15(%rsp)
movl -0x18(%rsp), %edx
movq -0x8(%rsp), %rax
movslq -0x14(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x4118b2
movq -0x8(%rsp), %rax
retq
nopl (%rax)
// File: msotoodeh[P]asymmetric-passwords/common/curve25519/curve25519_utils.c
// Function: ecp_WordsToBytes
U8* ecp_WordsToBytes(OUT U8 *Y, IN const U32 *X)
{
    int i;
    M32 m;
    
    for (i = 0; i < 32;)
    {
        m.u32 = *X++;
        Y[i++] = m.u8.b0;
        Y[i++] = m.u8.b1;
        Y[i++] = m.u8.b2;
        Y[i++] = m.u8.b3;
    }
    return Y;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl $0x0, -0x14(%rsp)
cmpl $0x20, -0x14(%rsp)
jge 0x4119e9
movq -0x10(%rsp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x10(%rsp)
movl (%rax), %eax
movl %eax, -0x18(%rsp)
movb -0x18(%rsp), %dl
movq -0x8(%rsp), %rax
movl -0x14(%rsp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x14(%rsp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movb -0x17(%rsp), %dl
movq -0x8(%rsp), %rax
movl -0x14(%rsp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x14(%rsp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movb -0x16(%rsp), %dl
movq -0x8(%rsp), %rax
movl -0x14(%rsp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x14(%rsp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movb -0x15(%rsp), %dl
movq -0x8(%rsp), %rax
movl -0x14(%rsp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x14(%rsp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0x411952
movq -0x8(%rsp), %rax
retq
nop
// File: msotoodeh[P]asymmetric-passwords/common/curve25519/curve25519_utils.c
// Function: ecp_EncodeInt
U8* ecp_EncodeInt(OUT U8 *Y, IN const U32 *X, IN U8 parity)
{
    int i;
    M32 m;
    
    for (i = 0; i < 28;)
    {
        m.u32 = *X++;
        Y[i++] = m.u8.b0;
        Y[i++] = m.u8.b1;
        Y[i++] = m.u8.b2;
        Y[i++] = m.u8.b3;
    }

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

    return Y;
}

// Assembly:
movb %dl, %al
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movb %al, -0x11(%rsp)
movl $0x0, -0x18(%rsp)
cmpl $0x1c, -0x18(%rsp)
jge 0x411a9f
movq -0x10(%rsp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x10(%rsp)
movl (%rax), %eax
movl %eax, -0x1c(%rsp)
movb -0x1c(%rsp), %dl
movq -0x8(%rsp), %rax
movl -0x18(%rsp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x18(%rsp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movb -0x1b(%rsp), %dl
movq -0x8(%rsp), %rax
movl -0x18(%rsp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x18(%rsp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movb -0x1a(%rsp), %dl
movq -0x8(%rsp), %rax
movl -0x18(%rsp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x18(%rsp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movb -0x19(%rsp), %dl
movq -0x8(%rsp), %rax
movl -0x18(%rsp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x18(%rsp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0x411a08
movq -0x10(%rsp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rsp)
movb -0x1c(%rsp), %cl
movq -0x8(%rsp), %rax
movb %cl, 0x1c(%rax)
movb -0x1b(%rsp), %cl
movq -0x8(%rsp), %rax
movb %cl, 0x1d(%rax)
movb -0x1a(%rsp), %cl
movq -0x8(%rsp), %rax
movb %cl, 0x1e(%rax)
movzbl -0x19(%rsp), %eax
andl $0x7f, %eax
movzbl -0x11(%rsp), %ecx
shll $0x7, %ecx
orl %ecx, %eax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x1f(%rax)
movq -0x8(%rsp), %rax
retq
// File: msotoodeh[P]asymmetric-passwords/common/curve25519/curve25519_utils.c
// Function: ecp_DecodeInt
U8 ecp_DecodeInt(OUT U32 *Y, IN const U8 *X)
{
    int i;
    M32 m;
    
    for (i = 0; i < 7; i++)
    {
        m.u8.b0 = *X++;
        m.u8.b1 = *X++;
        m.u8.b2 = *X++;
        m.u8.b3 = *X++;
        
        Y[i] = m.u32;
    }

    m.u8.b0 = *X++;
    m.u8.b1 = *X++;
    m.u8.b2 = *X++;
    m.u8.b3 = *X & 0x7f;
        
    Y[7] = m.u32;

    return (U8)((*X >> 7) & 1);
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl $0x0, -0x14(%rsp)
cmpl $0x7, -0x14(%rsp)
jge 0x411b86
movq -0x10(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rsp)
movb (%rax), %al
movb %al, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rsp)
movb (%rax), %al
movb %al, -0x17(%rsp)
movq -0x10(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rsp)
movb (%rax), %al
movb %al, -0x16(%rsp)
movq -0x10(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rsp)
movb (%rax), %al
movb %al, -0x15(%rsp)
movl -0x18(%rsp), %edx
movq -0x8(%rsp), %rax
movslq -0x14(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x411b02
movq -0x10(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rsp)
movb (%rax), %al
movb %al, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rsp)
movb (%rax), %al
movb %al, -0x17(%rsp)
movq -0x10(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rsp)
movb (%rax), %al
movb %al, -0x16(%rsp)
movq -0x10(%rsp), %rax
movzbl (%rax), %eax
andl $0x7f, %eax
movb %al, -0x15(%rsp)
movl -0x18(%rsp), %ecx
movq -0x8(%rsp), %rax
movl %ecx, 0x1c(%rax)
movq -0x10(%rsp), %rax
movzbl (%rax), %eax
sarl $0x7, %eax
andl $0x1, %eax
retq
nopw %cs:(%rax,%rax)
// File: 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:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl $0x20, -0x14(%rsp)
movl -0x14(%rsp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x14(%rsp)
cmpl $0x0, %eax
jle 0x411cc7
movb $0x0, -0x19(%rsp)
movb $0x0, -0x1a(%rsp)
movl $0x8, -0x18(%rsp)
cmpl $0x1, -0x18(%rsp)
jle 0x411c9d
movl -0x18(%rsp), %eax
subl $0x2, %eax
movl %eax, -0x18(%rsp)
movzbl -0x19(%rsp), %eax
shll %eax
movq -0x10(%rsp), %rcx
movl -0x18(%rsp), %edx
addl $0x1, %edx
movslq %edx, %rdx
movl (%rcx,%rdx,4), %edx
movl -0x14(%rsp), %ecx
shrl %cl, %edx
movl %edx, %ecx
andl $0x1, %ecx
addl %ecx, %eax
movb %al, -0x19(%rsp)
movzbl -0x1a(%rsp), %eax
shll %eax
movq -0x10(%rsp), %rcx
movslq -0x18(%rsp), %rdx
movl (%rcx,%rdx,4), %edx
movl -0x14(%rsp), %ecx
shrl %cl, %edx
movl %edx, %ecx
andl $0x1, %ecx
addl %ecx, %eax
movb %al, -0x1a(%rsp)
jmp 0x411c3a
movb -0x19(%rsp), %cl
movq -0x8(%rsp), %rax
movb %cl, (%rax)
movb -0x1a(%rsp), %cl
movq -0x8(%rsp), %rax
movb %cl, 0x20(%rax)
movq -0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rsp)
jmp 0x411c12
retq
nopl (%rax,%rax)
// File: msotoodeh[P]asymmetric-passwords/common/curve25519/curve25519_utils.c
// Function: ecp_8Folds
void ecp_8Folds(U8* Y, const U32* X)
{
    int i, j;
    U8 a = 0;
    for (i = 32; i-- > 0;)
    {
        for (j = 8; j-- > 0;) a = (a << 1) + ((X[j] >> i) & 1);
        *Y++ = a;
    }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movb $0x0, -0x19(%rsp)
movl $0x20, -0x14(%rsp)
movl -0x14(%rsp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x14(%rsp)
cmpl $0x0, %eax
jle 0x411d53
movl $0x8, -0x18(%rsp)
movl -0x18(%rsp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x18(%rsp)
cmpl $0x0, %eax
jle 0x411d3a
movzbl -0x19(%rsp), %eax
shll %eax
movq -0x10(%rsp), %rcx
movslq -0x18(%rsp), %rdx
movl (%rcx,%rdx,4), %edx
movl -0x14(%rsp), %ecx
shrl %cl, %edx
movl %edx, %ecx
andl $0x1, %ecx
addl %ecx, %eax
movb %al, -0x19(%rsp)
jmp 0x411d01
movb -0x19(%rsp), %cl
movq -0x8(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rsp)
movb %cl, (%rax)
jmp 0x411ce7
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movq $0x67452301, 0x10(%rdi) # imm = 0x67452301
movl $0xefcdab89, %eax       # imm = 0xEFCDAB89
movq %rax, 0x18(%rdi)
movl $0x98badcfe, %eax       # imm = 0x98BADCFE
movq %rax, 0x20(%rdi)
movq $0x10325476, 0x28(%rdi) # imm = 0x10325476
movq $0x0, (%rdi)
movq $0x0, 0x8(%rdi)
addq $0x30, %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x1030
movq -0x10(%rbp), %rdi
addq $0x70, %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x38(%rbp)
movq (%rcx), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq -0x18(%rbp), %rax
andq $0x1fffffff, %rax       # imm = 0x1FFFFFFF
movq %rax, (%rcx)
cmpq -0x20(%rbp), %rax
jae 0x129a
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
shrq $0x1d, %rcx
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
andq $0x3f, %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x133f
movl $0x40, %eax
subq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x12f6
movq -0x38(%rbp), %rdi
addq $0x30, %rdi
addq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1040
jmp 0x1380
movq -0x38(%rbp), %rdi
addq $0x30, %rdi
addq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x1040
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x18(%rbp)
movq %rdi, %rsi
addq $0x30, %rsi
movl $0x40, %edx
callq 0x1390
cmpq $0x40, -0x18(%rbp)
jb 0x136b
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
andq $-0x40, %rdx
callq 0x1390
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
andq $0x3f, %rax
movq %rax, -0x18(%rbp)
movq -0x38(%rbp), %rdi
addq $0x30, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1040
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x100(%rbp), %rdi
callq 0x11c0
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0x2dab
movq -0x8(%rbp), %rsi
leaq -0x100(%rbp), %rdi
movl $0x1, %edx
callq 0x1250
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x2d7f
movq -0x10(%rbp), %rsi
leaq -0x100(%rbp), %rdi
callq 0x2b40
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x10, -0x14(%rbp)
jge 0x2e9d
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movzbl (%rax,%rcx), %eax
sarl $0x4, %eax
movslq %eax, %rcx
leaq 0x1be(%rip), %rax       # 0x3010
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
shll %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0xf, %eax
movslq %eax, %rcx
leaq 0x193(%rip), %rax       # 0x3010
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
shll %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2e33
movq -0x10(%rbp), %rax
movb $0x0, 0x20(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x60, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x154(%rip), %rax       # 0x3021
movq %rax, -0x5a(%rbp)
movw 0x151(%rip), %ax        # 0x3029
movw %ax, -0x52(%rbp)
leaq -0x5a(%rbp), %rdi
leaq -0x50(%rbp), %rdx
movl $0xa, %esi
callq 0x2dd0
leaq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x2e20
movq 0x20d6(%rip), %rdi      # 0x4fd8
leaq 0x122(%rip), %rsi       # 0x302b
callq 0x1060
movq %rax, %rdi
leaq -0x40(%rbp), %rsi
callq 0x1060
movq %rax, %rdi
leaq 0x128(%rip), %rsi       # 0x304c
callq 0x1060
xorl %eax, %eax
addq $0x60, %rsp
popq %rbp
retq
// File: miniplane[P]mintree/simpletest.C
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nextrandom<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>()
string nextrandom( ) {
   const char* start = helpstr + rand() % sizeof helpstr;
   while (!isalpha( *start )) if (*start) ++start; else start = helpstr;
   const char* end = start + 1;
   while (isalpha( *end )) ++end;
   char buf[10];
   sprintf( buf, "%d", rand() % 1000 );
   return std::string( start, end - start ) += buf;
 }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, -0x70(%rbp)
callq 0x31d0
movq -0x68(%rbp), %rdi
movq %rdi, -0x8(%rbp)
callq 0x30b0
cltq
movl $0x4b9, %ecx            # imm = 0x4B9
xorl %edx, %edx
divq %rcx
leaq 0x59b8(%rip), %rax      # 0x9010
addq %rdx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0x3390
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x3679
jmp 0x369d
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x3690
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x369b
leaq 0x5979(%rip), %rax      # 0x9010
movq %rax, -0x10(%rbp)
jmp 0x365f
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %edi
callq 0x3390
cmpl $0x0, %eax
je 0x36c8
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x36a9
callq 0x30b0
movl %eax, %edx
movslq %edx, %rax
imulq $0x10624dd3, %rax, %rax # imm = 0x10624DD3
movq %rax, %rcx
shrq $0x3f, %rcx
sarq $0x26, %rax
addl %ecx, %eax
imull $0x3e8, %eax, %eax      # imm = 0x3E8
subl %eax, %edx
leaq 0x5dd4(%rip), %rsi      # 0x94c9
xorl %eax, %eax
leaq -0x22(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x3060
movq -0x10(%rbp), %rcx
movq %rcx, -0x88(%rbp)
movq -0x18(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x80(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x33e0
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdx
movq -0x78(%rbp), %rcx
leaq -0x48(%rbp), %rdi
callq 0x32e0
jmp 0x3744
movq -0x90(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x3220
movq %rax, -0x98(%rbp)
jmp 0x375d
movq -0x98(%rbp), %rsi
movq -0x68(%rbp), %rdi
callq 0x3100
jmp 0x376f
leaq -0x48(%rbp), %rdi
callq 0x3180
leaq -0x49(%rbp), %rdi
callq 0x32a0
movq -0x70(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x37b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3180
leaq -0x49(%rbp), %rdi
callq 0x32a0
movq -0x58(%rbp), %rdi
callq 0x33d0
nopw %cs:(%rax,%rax)
// File: 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
subq $0x90, %rsp
movq %rdi, -0x80(%rbp)
movq %rsi, -0x78(%rbp)
callq 0x31d0
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x3100
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x57c0
movq %rax, -0x58(%rbp)
jmp 0x4fec
leaq -0x38(%rbp), %rdi
callq 0x3180
movq -0x58(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x50ea
movq -0x70(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x50(%rbp)
movl $0xc8, %edi
callq 0x3250
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x88(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x4dd0
jmp 0x5036
movq -0x70(%rbp), %rax
movq -0x88(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rax), %rcx
movb $0x0, 0xc0(%rcx)
movq 0x8(%rax), %rax
movq $0x1, 0xb8(%rax)
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5980
movq %rax, %rsi
movq -0x70(%rbp), %rax
movq 0x8(%rax), %rdi
addq $0x38, %rdi
callq 0x3040
movq -0x70(%rbp), %rax
movq -0x50(%rbp), %rdx
movq 0x8(%rax), %rcx
movq %rdx, 0x8(%rcx)
movq 0x8(%rax), %rdx
movq -0x50(%rbp), %rcx
movq %rdx, (%rcx)
movq -0x18(%rbp), %rdx
movq 0x8(%rax), %rcx
movq %rdx, 0x10(%rcx)
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x50ea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3180
jmp 0x50f3
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
movl $0xc8, %esi
callq 0x3270
jmp 0x50f3
addq $0x90, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x33d0
nopl (%rax)
// File: miniplane[P]mintree/./BpTree.h
// Function: BpTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 2ul>::remove(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
virtual void remove(const E& e ) {
		root->remove(e, 0);
		if (!root->leaf && root->elements == 0) {
			Node *oldroot = root;
			root = root->children[0];
			root->parent = nullptr;
			oldroot->elements = -1;
			delete oldroot;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x70(%rbp)
movq %rsi, -0x68(%rbp)
callq 0x31d0
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x3100
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x6070
jmp 0x51dc
leaq -0x30(%rbp), %rdi
callq 0x3180
movq -0x60(%rbp), %rax
movq 0x8(%rax), %rax
testb $0x1, 0xc0(%rax)
jne 0x527c
movq -0x60(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0xb8(%rax)
jne 0x527c
movq -0x60(%rbp), %rax
movq 0x8(%rax), %rcx
movq %rcx, -0x48(%rbp)
movq 0x8(%rax), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rax), %rax
movq $0x0, (%rax)
movq -0x48(%rbp), %rax
movq $-0x1, 0xb8(%rax)
movq -0x48(%rbp), %rax
movq %rax, -0x78(%rbp)
cmpq $0x0, %rax
je 0x5263
movq -0x78(%rbp), %rdi
callq 0x56e0
movq -0x78(%rbp), %rdi
movl $0xc8, %esi
callq 0x3270
jmp 0x527c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3180
jmp 0x5285
addq $0x80, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x33d0
nop
// File: miniplane[P]mintree/./BpTree.h
// Function: BpTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 2ul>::apply(Functor<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&, Order) const
virtual size_t apply (const Functor<E>& f, Order order_=dontcare) const {
		if (root->elements == 0)
			return 0;
		size_t n = 0;
		root->apply_(f, order_, n);
		return n;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rsi, -0x40(%rbp)
movl %edx, -0x34(%rbp)
callq 0x31d0
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movl -0x34(%rbp), %edx
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x8(%rax), %rax
cmpq $0x0, 0xb8(%rax)
jne 0x540e
movq $0x0, -0x8(%rbp)
jmp 0x5436
movq -0x30(%rbp), %rax
movq $0x0, -0x28(%rbp)
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
leaq -0x28(%rbp), %rcx
callq 0x7550
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
// File: miniplane[P]mintree/./BpTree.h
// Function: BpTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 2ul>::Node::~Node()
~Node () {
			if (leaf)
				return;
			for (size_t i = 0; i < elements+1; i++)
				delete children[i];
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x28(%rbp)
callq 0x31d0
movq -0x28(%rbp), %rdi
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
testb $0x1, 0xc0(%rax)
je 0x5713
movl $0x1, -0xc(%rbp)
jmp 0x5778
movq $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0xb8(%rcx), %rcx
addq $0x1, %rcx
cmpq %rcx, %rax
jae 0x5771
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x5761
movq -0x30(%rbp), %rdi
callq 0x56e0
movq -0x30(%rbp), %rdi
movl $0xc8, %esi
callq 0x3270
jmp 0x5763
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x571b
movl $0x0, -0xc(%rbp)
movq -0x20(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x40(%rbp)
addq $0x80, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
addq $-0x20, %rdi
movq %rdi, -0x48(%rbp)
callq 0x3180
movq -0x40(%rbp), %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x38(%rbp)
jne 0x578e
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: miniplane[P]mintree/./BpTree.h
// Function: BpTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 2ul>::Node::insert(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Node *insert(E key) { // insertions into inner nodes and leafs

			size_t i = 0;

			for (i = 0; i < elements; i++) {
				if (key == keys[i])
					return nullptr; // return to avoid inserting the same value twice

				if (keys[i] > key) // if key smaller than value, stop
					break;
			}

			Node *retval = nullptr;

			if (leaf)
				retval = insert_in_leaf(key, i);
			else
				retval = insert_in_node(key, i);
			return retval;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x90(%rbp)
movq %rsi, -0x88(%rbp)
callq 0x31d0
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x80(%rbp), %rcx
movq -0x20(%rbp), %rax
cmpq 0xb8(%rcx), %rax
jae 0x5886
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
addq $0x38, %rsi
movq -0x20(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rsi
callq 0x59f0
testb $0x1, %al
jne 0x5842
jmp 0x584f
movq $0x0, -0x8(%rbp)
jmp 0x5965
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdi
addq $0x38, %rdi
movq -0x20(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
callq 0x5aa0
testb $0x1, %al
jne 0x5874
jmp 0x5876
jmp 0x5886
jmp 0x5878
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x580c
movq -0x80(%rbp), %rax
movq $0x0, -0x28(%rbp)
testb $0x1, 0xc0(%rax)
je 0x58fc
movq -0x88(%rbp), %rsi
leaq -0x48(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x3100
movq -0x80(%rbp), %rdi
movq -0xa0(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x5af0
movq %rax, -0x98(%rbp)
jmp 0x58cf
movq -0x98(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3180
jmp 0x595d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3180
jmp 0x5972
movq -0x88(%rbp), %rsi
leaq -0x78(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x3100
movq -0x80(%rbp), %rdi
movq -0xb0(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x5be0
movq %rax, -0xa8(%rbp)
jmp 0x5930
movq -0xa8(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x3180
jmp 0x595d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x3180
jmp 0x5972
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x33d0
nopl (%rax,%rax)
// File: miniplane[P]mintree/./BpTree.h
// Function: BpTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 2ul>::lift_key(BpTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 2ul>::Node const*, BpTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 2ul>::Node const*)
static const E& lift_key(const Node* left, const Node* right) { // returns key that goes to parent Node after split
		if (left->leaf)
			return right->keys[0];
		else
			return left->keys[left->elements];
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rsi, -0x20(%rbp)
callq 0x31d0
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0xc0(%rax)
je 0x59c0
movq -0x18(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x8(%rbp)
jmp 0x59de
movq -0x10(%rbp), %rax
addq $0x38, %rax
movq -0x10(%rbp), %rcx
movq 0xb8(%rcx), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: miniplane[P]mintree/./BpTree.h
// Function: BpTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 2ul>::Node::insert_in_leaf(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned long)
Node *insert_in_leaf(E key, size_t i) {
			for (size_t j=elements; j > i; j--)
				keys[j] = keys[j-1]; // moves elements
			
			keys[i] = key; // add new element
			elements++;

			if (elements > order-1) // if node is full, split it
				return split(); // make new child

			return nullptr;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rsi, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
callq 0x31d0
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0xb8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jbe 0x5b7a
movq -0x30(%rbp), %rdi
movq %rdi, %rsi
addq $0x38, %rsi
movq -0x28(%rbp), %rax
subq $0x1, %rax
shlq $0x5, %rax
addq %rax, %rsi
addq $0x38, %rdi
movq -0x28(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
callq 0x3040
movq -0x28(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x5b34
movq -0x30(%rbp), %rdi
movq -0x40(%rbp), %rsi
addq $0x38, %rdi
movq -0x20(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
callq 0x3040
movq -0x30(%rbp), %rax
movq 0xb8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xb8(%rax)
cmpq $0x3, 0xb8(%rax)
jbe 0x5bc5
movq -0x30(%rbp), %rdi
callq 0x5e30
movq %rax, -0x8(%rbp)
jmp 0x5bcd
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: miniplane[P]mintree/./BpTree.h
// Function: BpTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 2ul>::Node::insert_in_node(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned long)
Node *insert_in_node(E key, size_t i) {

			Node *right_child = children[i]->insert(key); // if key smaller than value move it to child
			if (right_child == nullptr)	// nothing is split
				return nullptr;

			for (size_t j=elements; j > i; j--) {
				keys[j] = keys[j-1]; // moves elements
				children[j+1] = children[j]; // moves pointers
			}
			
			keys[i] = lift_key(children[i], right_child); // add new element
			elements++;

			children[i+1] = right_child;

			if (elements > order-1) // if node is full, split it
				return split(); // make new child

			return nullptr;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x98(%rbp)
movq %rsi, -0x88(%rbp)
movq %rdx, -0x90(%rbp)
callq 0x31d0
movq -0x98(%rbp), %rdi
movq -0x90(%rbp), %rdx
movq -0x88(%rbp), %rsi
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x20(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rax
movq %rax, -0x78(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x3100
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x57c0
movq %rax, -0x68(%rbp)
jmp 0x5c5b
leaq -0x48(%rbp), %rdi
callq 0x3180
movq -0x68(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x5c9a
movq $0x0, -0x8(%rbp)
jmp 0x5d7a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3180
jmp 0x5d87
movq -0x80(%rbp), %rax
movq 0xb8(%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
cmpq -0x20(%rbp), %rax
jbe 0x5d05
movq -0x80(%rbp), %rdi
movq %rdi, %rsi
addq $0x38, %rsi
movq -0x60(%rbp), %rax
subq $0x1, %rax
shlq $0x5, %rax
addq %rax, %rsi
addq $0x38, %rdi
movq -0x60(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
callq 0x3040
movq -0x80(%rbp), %rax
movq -0x60(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rdx
movq -0x60(%rbp), %rcx
movq %rdx, 0x10(%rax,%rcx,8)
movq -0x60(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x60(%rbp)
jmp 0x5ca9
movq -0x80(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rdi
movq -0x28(%rbp), %rsi
callq 0x5980
movq -0x80(%rbp), %rdi
movq %rax, %rsi
addq $0x38, %rdi
movq -0x20(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
callq 0x3040
movq -0x80(%rbp), %rax
movq 0xb8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xb8(%rax)
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq %rdx, 0x10(%rax,%rcx,8)
cmpq $0x3, 0xb8(%rax)
jbe 0x5d72
movq -0x80(%rbp), %rdi
callq 0x5e30
movq %rax, -0x8(%rbp)
jmp 0x5d7a
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x33d0
// File: miniplane[P]mintree/./BpTree.h
// Function: BpTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 2ul>::Node::remove(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned long)
void remove(E key, size_t pos_in_parent) {

			if (leaf) {
				for (size_t i=0; i < elements; i++) {
					if (key == keys[i]) {
						remove_from_leaf(i, pos_in_parent);
						break;
					} // else, loop ends without anything being removed
				}
			} 
			else {
				size_t i;
				for (i=0; i < elements; i++)
					if (keys[i] > key)
						break;

				children[i]->remove(key, i);
				// don't place ANYTHING here
			}
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x78(%rbp)
movq %rsi, -0x70(%rbp)
movq %rdx, -0x68(%rbp)
callq 0x31d0
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdx
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
testb $0x1, 0xc0(%rax)
je 0x6118
movq $0x0, -0x20(%rbp)
movq -0x60(%rbp), %rcx
movq -0x20(%rbp), %rax
cmpq 0xb8(%rcx), %rax
jae 0x6113
movq -0x70(%rbp), %rdi
movq -0x60(%rbp), %rsi
addq $0x38, %rsi
movq -0x20(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rsi
callq 0x59f0
testb $0x1, %al
jne 0x60f0
jmp 0x6103
movq -0x60(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x61e0
jmp 0x6113
jmp 0x6105
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x60bd
jmp 0x61c2
movq $0x0, -0x28(%rbp)
movq -0x60(%rbp), %rcx
movq -0x28(%rbp), %rax
cmpq 0xb8(%rcx), %rax
jae 0x6165
movq -0x70(%rbp), %rsi
movq -0x60(%rbp), %rdi
addq $0x38, %rdi
movq -0x28(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
callq 0x5aa0
testb $0x1, %al
jne 0x6153
jmp 0x6155
jmp 0x6165
jmp 0x6157
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x6120
movq -0x70(%rbp), %rsi
movq -0x60(%rbp), %rax
movq -0x28(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rax
movq %rax, -0x88(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x3100
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x6070
jmp 0x61a0
leaq -0x48(%rbp), %rdi
callq 0x3180
jmp 0x61c2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3180
jmp 0x61cb
addq $0x90, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x33d0
nopw %cs:(%rax,%rax)
nop
// File: miniplane[P]mintree/./BpTree.h
// Function: void shift<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, unsigned long, unsigned long, int)
inline void shift(E* array, size_t begin, size_t end, int shift) {
	if (shift > 0)
		for (size_t i = end-1; i>=begin+shift; i--)
			array[i] = array[i-shift];

	else if (shift < 0)
		for (size_t i = begin; i<end+shift; i++)
			array[i] = array[i-shift];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x50(%rbp)
movq %rsi, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
movl %ecx, -0x34(%rbp)
callq 0x31d0
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movl -0x34(%rbp), %ecx
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jle 0x66ba
movq -0x18(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jb 0x66b8
movq -0x8(%rbp), %rsi
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
subq %rcx, %rax
shlq $0x5, %rax
addq %rax, %rsi
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
callq 0x3040
movq -0x28(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x666c
jmp 0x6718
cmpl $0x0, -0x1c(%rbp)
jge 0x6716
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x6714
movq -0x8(%rbp), %rsi
movq -0x30(%rbp), %rax
movslq -0x1c(%rbp), %rcx
subq %rcx, %rax
shlq $0x5, %rax
addq %rax, %rsi
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
callq 0x3040
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x66c8
jmp 0x6716
jmp 0x6718
addq $0x50, %rsp
popq %rbp
retq
nop
// File: miniplane[P]mintree/./BpTree.h
// Function: BpTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 2ul>::Node::set_key_in_node(unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void set_key_in_node(size_t index, E key) { // sets key in node to new min of right branch
			
			if (index > 0)
				keys[index-1] = key;
			else if (parent) {
				size_t pos_in_parent = 0;
				for (; pos_in_parent < parent->elements+1; pos_in_parent++)
					if (this == parent->children[pos_in_parent])
						break;
				parent->set_key_in_node(pos_in_parent, key);
			}
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x70(%rbp)
movq %rsi, -0x68(%rbp)
movq %rdx, -0x60(%rbp)
callq 0x31d0
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x10(%rbp)
jbe 0x6788
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdi
addq $0x38, %rdi
movq -0x10(%rbp), %rax
subq $0x1, %rax
shlq $0x5, %rax
addq %rax, %rdi
callq 0x3040
jmp 0x683e
movq -0x58(%rbp), %rax
cmpq $0x0, (%rax)
je 0x683c
movq $0x0, -0x20(%rbp)
movq -0x58(%rbp), %rcx
movq -0x20(%rbp), %rax
movq (%rcx), %rcx
movq 0xb8(%rcx), %rcx
addq $0x1, %rcx
cmpq %rcx, %rax
jae 0x67dd
movq -0x58(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rdx
cmpq 0x8(%rcx,%rdx,8), %rax
jne 0x67cd
jmp 0x67dd
jmp 0x67cf
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x679e
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x88(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x3100
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdx
callq 0x6720
jmp 0x681a
leaq -0x40(%rbp), %rdi
callq 0x3180
jmp 0x683c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3180
jmp 0x6847
jmp 0x683e
addq $0x90, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x33d0
// File: miniplane[P]mintree/./BpTree.h
// Function: BpTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 2ul>::Node::pop_left()
inline E pop_left() { // removes leftest key
			E key = keys[0];
			shift(keys, 0, elements--, -1);
			return key;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x48(%rbp)
movq %rdi, -0x40(%rbp)
movq %rdi, -0x50(%rbp)
callq 0x31d0
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdi
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x38(%rbp)
movb $0x0, -0x11(%rbp)
addq $0x38, %rsi
movq %rsi, -0x30(%rbp)
callq 0x3100
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rdi
movq 0xb8(%rax), %rdx
movq %rdx, %rcx
decq %rcx
movq %rcx, 0xb8(%rax)
xorl %eax, %eax
movl %eax, %esi
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x6620
jmp 0x6a5e
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x6a8a
jmp 0x6a81
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x3180
jmp 0x6a94
movq -0x40(%rbp), %rdi
callq 0x3180
movq -0x50(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x33d0
nopl (%rax)
// File: miniplane[P]mintree/./BpTree.h
// Function: BpTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 2ul>::Node::merge_leaf(unsigned long)
void merge_leaf(size_t pos_in_parent) { // if root empty, merged children form new root

			for (size_t i = 0; i < next()->elements; i++) 
				push_right(next()->keys[i]); // all values from next() are appended to this

			for (size_t i = pos_in_parent+1; i < parent->elements; i++) // moves children from parent node
				parent->children[i] = parent->children[i+1];

			for (size_t i = pos_in_parent; i < parent->elements-1; i++)
				parent->keys[i] = parent->keys[i+1]; // deletes value in parent pointing to child (min value of current node)

			parent->elements--;
			next()->unlink();

			parent->after_removal_from_inner();
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x70(%rbp)
movq %rsi, -0x68(%rbp)
callq 0x31d0
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x60(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x78(%rbp)
callq 0x56b0
movq %rax, %rcx
movq -0x78(%rbp), %rax
movq (%rcx), %rcx
cmpq 0xb8(%rcx), %rax
jae 0x6b62
movq -0x60(%rbp), %rdi
callq 0x56b0
movq (%rax), %rax
movq -0x18(%rbp), %rcx
shlq $0x5, %rcx
leaq 0x38(%rax,%rcx), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x3100
movq -0x60(%rbp), %rdi
movq -0x80(%rbp), %rsi
callq 0x6990
jmp 0x6b31
leaq -0x38(%rbp), %rdi
callq 0x3180
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x6ad8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3180
jmp 0x6c49
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
movq -0x60(%rbp), %rcx
movq -0x50(%rbp), %rax
movq (%rcx), %rcx
cmpq 0xb8(%rcx), %rax
jae 0x6bac
movq -0x60(%rbp), %rax
movq (%rax), %rcx
movq -0x50(%rbp), %rdx
movq 0x10(%rcx,%rdx,8), %rdx
movq (%rax), %rax
movq -0x50(%rbp), %rcx
movq %rdx, 0x8(%rax,%rcx,8)
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
jmp 0x6b6e
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x60(%rbp), %rcx
movq -0x58(%rbp), %rax
movq (%rcx), %rcx
movq 0xb8(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x6c0e
movq -0x60(%rbp), %rax
movq (%rax), %rsi
addq $0x38, %rsi
movq -0x58(%rbp), %rcx
addq $0x1, %rcx
shlq $0x5, %rcx
addq %rcx, %rsi
movq (%rax), %rdi
addq $0x38, %rdi
movq -0x58(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
callq 0x3040
movq -0x58(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
jmp 0x6bb4
movq -0x60(%rbp), %rdi
movq (%rdi), %rax
movq 0xb8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0xb8(%rax)
callq 0x56b0
movq (%rax), %rdi
callq 0x6c60
movq -0x60(%rbp), %rax
movq (%rax), %rdi
callq 0x6d00
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x33d0
nopw %cs:(%rax,%rax)
nopl (%rax)