LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/occivink[P]pyct/monocypher.cpp
// Function: crypto_lock_aead
void crypto_lock_aead(u8 mac[16], u8 *cipher_text,
                      const u8  key[32], const u8  nonce[24],
                      const u8 *ad        , size_t ad_size,
                      const u8 *plain_text, size_t text_size)
{
    u8 sub_key[32];
    u8 auth_key[64]; // "Wasting" the whole Chacha block is faster
    crypto_hchacha20(sub_key, key, nonce);
    crypto_chacha20(auth_key, 0, 64, sub_key, nonce + 16);
    crypto_chacha20_ctr(cipher_text, plain_text, text_size,
                        sub_key, nonce + 16, 1);
    lock_auth(mac, auth_key, ad, ad_size, cipher_text, text_size);
    WIPE_BUFFER(sub_key);
    WIPE_BUFFER(auth_key);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %r9, 0x8(%rsp)
movq %r8, (%rsp)
movq %rcx, %rbp
movq %rsi, %r15
movq %rdi, %r13
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x2617
addq $0x10, %rbp
xorl %r14d, %r14d
leaq 0x30(%rsp), %rbx
movl $0x40, %edx
movq %rbx, %rdi
xorl %esi, %esi
movq %r12, %rcx
movq %rbp, %r8
xorl %r9d, %r9d
callq 0x28c8
movl $0x1, %r9d
movq %r15, %rdi
movq 0xb0(%rsp), %rsi
movq 0xb8(%rsp), %rdx
movq %r12, %rcx
movq %rbp, %r8
callq 0x28c8
movq %r13, %rdi
movq %rbx, %rsi
movq (%rsp), %rdx
movq 0x8(%rsp), %rcx
movq %r15, %r8
movq 0xb8(%rsp), %r9
callq 0x92e0
movb $0x0, 0x10(%rsp,%r14)
incq %r14
cmpq $0x20, %r14
jne 0x92b2
xorl %eax, %eax
movb $0x0, 0x30(%rsp,%rax)
incq %rax
cmpq $0x40, %rax
jne 0x92c3
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/occivink[P]pyct/monocypher.cpp
// Function: lock_auth(unsigned char*, unsigned char const*, unsigned char const*, unsigned long, unsigned char const*, unsigned long)
static void lock_auth(u8 mac[16], const u8  auth_key[32],
                      const u8 *ad         , size_t ad_size,
                      const u8 *cipher_text, size_t text_size)
{
    u8 sizes[16]; // Not secret, not wiped
    store64_le(sizes + 0, ad_size);
    store64_le(sizes + 8, text_size);
    crypto_poly1305_ctx poly_ctx;           // auto wiped...
    crypto_poly1305_init  (&poly_ctx, auth_key);
    crypto_poly1305_update(&poly_ctx, ad         , ad_size);
    crypto_poly1305_update(&poly_ctx, zero       , align(ad_size, 16));
    crypto_poly1305_update(&poly_ctx, cipher_text, text_size);
    crypto_poly1305_update(&poly_ctx, zero       , align(text_size, 16));
    crypto_poly1305_update(&poly_ctx, sizes      , 16);
    crypto_poly1305_final (&poly_ctx, mac); // ...here
}

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %r9, %rbp
movq %r8, %r14
movq %rcx, 0x8(%rsp)
movq %rdx, %rbx
movq %rdi, (%rsp)
leaq 0x20(%rsp), %r12
movq %r12, %rdi
callq 0x2617
addq $0x10, %rbx
xorl %r13d, %r13d
leaq 0x40(%rsp), %r15
movl $0x40, %edx
movq %r15, %rdi
xorl %esi, %esi
movq %r12, %rcx
movq %rbx, %r8
xorl %r9d, %r9d
callq 0x28c8
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
movq 0xc0(%rsp), %r15
movq %r14, %rdx
movq 0xc8(%rsp), %r14
movq %rbp, %rcx
movq %r15, %r8
movq %r14, %r9
callq 0x92e0
movb $0x0, 0x40(%rsp,%r13)
incq %r13
cmpq $0x40, %r13
jne 0x9493
leaq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdi
callq 0x24fa
movl %eax, %ecx
shrq $0x20, %rax
orq %rax, %rcx
decq %rcx
xorl %ebp, %ebp
btq $0x20, %rcx
adcl $-0x1, %ebp
jne 0x94e6
leaq 0x20(%rsp), %rcx
movl $0x1, %r9d
movq (%rsp), %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %r8
callq 0x28c8
xorl %eax, %eax
movb $0x0, 0x20(%rsp,%rax)
incq %rax
cmpq $0x20, %rax
jne 0x94e8
xorl %eax, %eax
movb $0x0, 0x10(%rsp,%rax)
incq %rax
cmpq $0x10, %rax
jne 0x94f8
movl %ebp, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/occivink[P]pyct/monocypher.cpp
// Function: gidx_refresh(gidx_ctx*)
static void gidx_refresh(gidx_ctx *ctx)
{
    // seed the beginning of the block...
    ctx->b.a[0] = ctx->pass_number;
    ctx->b.a[1] = 0;  // lane number (we have only one)
    ctx->b.a[2] = ctx->slice_number;
    ctx->b.a[3] = ctx->nb_blocks;
    ctx->b.a[4] = ctx->nb_iterations;
    ctx->b.a[5] = 1;  // type: Argon2i
    ctx->b.a[6] = ctx->ctr;
    ZERO(ctx->b.a + 7, 121); // ...then zero the rest out

    // Shuffle the block thus: ctx->b = G((G(ctx->b, zero)), zero)
    // (G "square" function), to get cheap pseudo-random numbers.
    block tmp;
    copy_block(&tmp, &ctx->b);
    g_rounds  (&ctx->b);
    xor_block (&ctx->b, &tmp);
    copy_block(&tmp, &ctx->b);
    g_rounds  (&ctx->b);
    xor_block (&ctx->b, &tmp);
    wipe_block(&tmp);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movq %rdi, %rbx
movl 0x400(%rdi), %eax
movl 0x404(%rdi), %ecx
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movq %rcx, 0x10(%rdi)
movl 0x408(%rdi), %eax
movq %rax, 0x18(%rdi)
movl 0x40c(%rdi), %eax
movq %rax, 0x20(%rdi)
movq $0x1, 0x28(%rdi)
movl 0x410(%rdi), %eax
movq %rax, 0x30(%rdi)
addq $0x38, %rdi
xorl %r14d, %r14d
movl $0x3c8, %edx            # imm = 0x3C8
xorl %esi, %esi
callq 0x2120
leaq 0x8(%rsp), %rdi
movl $0x400, %edx            # imm = 0x400
movq %rbx, %rsi
callq 0x2170
movq %rbx, %rdi
callq 0x51d2
movq 0x8(%rsp,%r14,8), %rax
xorq %rax, (%rbx,%r14,8)
incq %r14
cmpq $0x80, %r14
jne 0x95cf
leaq 0x8(%rsp), %rdi
movl $0x400, %edx            # imm = 0x400
movq %rbx, %rsi
callq 0x2170
movq %rbx, %rdi
callq 0x51d2
xorl %eax, %eax
movq 0x8(%rsp,%rax,8), %rcx
xorq %rcx, (%rbx,%rax,8)
incq %rax
cmpq $0x80, %rax
jne 0x9600
xorl %eax, %eax
movq $0x0, 0x8(%rsp,%rax,8)
incq %rax
cmpq $0x80, %rax
jne 0x9616
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/occivink[P]pyct/monocypher.cpp
// Function: ge_double(ge*, ge const*, ge*)
static void ge_double(ge *s, const ge *p, ge *q)
{
    fe_sq (q->X, p->X);
    fe_sq (q->Y, p->Y);
    fe_sq (q->Z, p->Z);          // qZ = pZ^2
    fe_mul_small(q->Z, q->Z, 2); // qZ = pZ^2 * 2
    fe_add(q->T, p->X, p->Y);
    fe_sq (s->T, q->T);
    fe_add(q->T, q->Y, q->X);
    fe_sub(q->Y, q->Y, q->X);
    fe_sub(q->X, s->T, q->T);
    fe_sub(q->Z, q->Z, q->Y);

    fe_mul(s->X, q->X , q->Z);
    fe_mul(s->Y, q->T , q->Y);
    fe_mul(s->Z, q->Y , q->Z);
    fe_mul(s->T, q->X , q->T);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r14
movq %rdx, %rdi
callq 0x810e
leaq 0x28(%rbx), %r15
leaq 0x28(%r13), %rbp
movq %r15, %rdi
movq %rbp, %rsi
callq 0x810e
leaq 0x50(%rbx), %r12
addq $0x50, %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x810e
movq %r12, %rdi
movq %r12, %rsi
movl $0x2, %edx
callq 0x8ab5
leaq 0x78(%rbx), %r13
movq $-0x28, %rax
movl 0x28(%rbp,%rax), %ecx
addl (%rbp,%rax), %ecx
movl %ecx, 0xa0(%rbx,%rax)
addq $0x4, %rax
jne 0x983d
leaq 0x78(%r14), %rbp
movq %rbp, %rdi
movq %r13, %rsi
callq 0x810e
xorl %eax, %eax
movl (%rbx,%rax,4), %ecx
addl 0x28(%rbx,%rax,4), %ecx
movl %ecx, 0x78(%rbx,%rax,4)
incq %rax
cmpq $0xa, %rax
jne 0x9863
movl $0xa, %eax
movl -0x28(%rbx,%rax,4), %ecx
subl %ecx, (%rbx,%rax,4)
incq %rax
cmpq $0x14, %rax
jne 0x987c
movl $0x1e, %eax
movl (%r14,%rax,4), %ecx
subl (%rbx,%rax,4), %ecx
movl %ecx, -0x78(%rbx,%rax,4)
incq %rax
cmpq $0x28, %rax
jne 0x9891
movl $0x14, %eax
movl -0x28(%rbx,%rax,4), %ecx
subl %ecx, (%rbx,%rax,4)
incq %rax
cmpq $0x1e, %rax
jne 0x98aa
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x6ea3
leaq 0x28(%r14), %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x6ea3
addq $0x50, %r14
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x6ea3
movq %rbp, %rdi
movq %rbx, %rsi
movq %r13, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6ea3
// File: /workspace/github_cpp_makefile_star2_O1/occivink[P]pyct/monocypher.cpp
// Function: ge_cache(ge_cached*, ge const*)
static void ge_cache(ge_cached *c, const ge *p)
{
    fe_add (c->Yp, p->Y, p->X);
    fe_sub (c->Ym, p->Y, p->X);
    fe_copy(c->Z , p->Z      );
    fe_mul (c->T2, p->T, D2  );
}

// Assembly:
xorl %eax, %eax
movl (%rsi,%rax,4), %ecx
addl 0x28(%rsi,%rax,4), %ecx
movl %ecx, (%rdi,%rax,4)
incq %rax
cmpq $0xa, %rax
jne 0x9907
xorl %eax, %eax
movl 0x28(%rsi,%rax,4), %ecx
subl (%rsi,%rax,4), %ecx
movl %ecx, 0x28(%rdi,%rax,4)
incq %rax
cmpq $0xa, %rax
jne 0x991c
xorl %eax, %eax
movl 0x50(%rsi,%rax,4), %ecx
movl %ecx, 0x50(%rdi,%rax,4)
incq %rax
cmpq $0xa, %rax
jne 0x9932
addq $0x78, %rdi
addq $0x78, %rsi
leaq 0x385e(%rip), %rdx      # 0xd1b0
jmp 0x6ea3
// File: /workspace/github_cpp_makefile_star2_O1/occivink[P]pyct/monocypher.cpp
// Function: ge_add(ge*, ge const*, ge_cached const*)
static void ge_add(ge *s, const ge *p, const ge_cached *q)
{
    fe a, b;
    fe_add(a   , p->Y, p->X );
    fe_sub(b   , p->Y, p->X );
    fe_mul(a   , a   , q->Yp);
    fe_mul(b   , b   , q->Ym);
    fe_add(s->Y, a   , b    );
    fe_sub(s->X, a   , b    );

    fe_add(s->Z, p->Z, p->Z );
    fe_mul(s->Z, s->Z, q->Z );
    fe_mul(s->T, p->T, q->T2);
    fe_add(a   , s->Z, s->T );
    fe_sub(b   , s->Z, s->T );

    fe_mul(s->T, s->X, s->Y);
    fe_mul(s->X, s->X, b   );
    fe_mul(s->Y, s->Y, a   );
    fe_mul(s->Z, a   , b   );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
xorl %eax, %eax
movl (%r12,%rax,4), %ecx
addl 0x28(%r12,%rax,4), %ecx
movl %ecx, 0x30(%rsp,%rax,4)
incq %rax
cmpq $0xa, %rax
jne 0x9970
xorl %eax, %eax
movl 0x28(%r12,%rax,4), %ecx
subl (%r12,%rax,4), %ecx
movl %ecx, (%rsp,%rax,4)
incq %rax
cmpq $0xa, %rax
jne 0x9988
leaq 0x30(%rsp), %rdi
movq %rdi, %rsi
movq %r14, %rdx
callq 0x6ea3
leaq 0x28(%r14), %rdx
movq %rsp, %rdi
movq %rdi, %rsi
callq 0x6ea3
leaq 0x28(%rbx), %r15
xorl %eax, %eax
movl (%rsp,%rax,4), %ecx
addl 0x30(%rsp,%rax,4), %ecx
movl %ecx, 0x28(%rbx,%rax,4)
incq %rax
cmpq $0xa, %rax
jne 0x99c2
xorl %eax, %eax
movl 0x30(%rsp,%rax,4), %ecx
subl (%rsp,%rax,4), %ecx
movl %ecx, (%rbx,%rax,4)
incq %rax
cmpq $0xa, %rax
jne 0x99d8
leaq 0x50(%rbx), %r13
movl $0x14, %eax
movl (%r12,%rax,4), %ecx
addl %ecx, %ecx
movl %ecx, (%rbx,%rax,4)
incq %rax
cmpq $0x1e, %rax
jne 0x99f4
leaq 0x50(%r14), %rdx
movq %r13, %rdi
movq %r13, %rsi
callq 0x6ea3
leaq 0x78(%rbx), %rbp
addq $0x78, %r12
addq $0x78, %r14
movq %rbp, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x6ea3
movl $0x14, %eax
movl 0x28(%rbx,%rax,4), %ecx
addl (%rbx,%rax,4), %ecx
movl %ecx, -0x20(%rsp,%rax,4)
incq %rax
cmpq $0x1e, %rax
jne 0x9a34
movl $0x14, %eax
movl (%rbx,%rax,4), %ecx
subl 0x28(%rbx,%rax,4), %ecx
movl %ecx, -0x50(%rsp,%rax,4)
incq %rax
cmpq $0x1e, %rax
jne 0x9a4d
movq %rbp, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x6ea3
movq %rsp, %r14
movq %rbx, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x6ea3
leaq 0x30(%rsp), %rbx
movq %r15, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x6ea3
movq %r13, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x6ea3
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/occivink[P]pyct/monocypher.cpp
// Function: slide_step(slide_ctx*, int, int, unsigned char const*)
static int slide_step(slide_ctx *ctx, int width, int i, const u8 scalar[32])
{
    if (i == ctx->next_check) {
        if (scalar_bit(scalar, i) == scalar_bit(scalar, i - 1)) {
            ctx->next_check--;
        } else {
            // compute digit of next window
            int w = MIN(width, i + 1);
            int v = -(scalar_bit(scalar, i) << (w-1));
            FOR_T (int, j, 0, w-1) {
                v += scalar_bit(scalar, i-(w-1)+j) << j;
            }
            v += scalar_bit(scalar, i-w);
            int lsb = v & (~v + 1);            // smallest bit of v
            int s   = (   ((lsb & 0xAA) != 0)  // log2(lsb)
                       | (((lsb & 0xCC) != 0) << 1)
                       | (((lsb & 0xF0) != 0) << 2));
            ctx->next_index  = (i16)(i-(w-1)+s);
            ctx->next_digit  = (i8) (v >> s   );
            ctx->next_check -= (u8) w;
        }
    }
    return i == ctx->next_index ? ctx->next_digit: 0;
}

// Assembly:
movzbl 0x3(%rdi), %r9d
cmpl %edx, %r9d
jne 0x9bfc
movq %rcx, %rax
xorl %r8d, %r8d
movl $0x0, %ecx
testl %edx, %edx
js 0x9ae7
movl %edx, %ecx
shrl $0x3, %ecx
movzbl (%rax,%rcx), %r10d
movl %edx, %r11d
andl $0x7, %r11d
xorl %ecx, %ecx
btl %r11d, %r10d
setb %cl
testl %edx, %edx
jle 0x9b0a
leal -0x1(%rdx), %r10d
movl %r10d, %r8d
shrl $0x3, %r8d
movzbl (%rax,%r8), %r11d
andl $0x7, %r10d
xorl %r8d, %r8d
btl %r10d, %r11d
setb %r8b
cmpl %r8d, %ecx
jne 0x9b17
decb %r9b
jmp 0x9bf8
leal 0x1(%rdx), %ecx
cmpl %esi, %ecx
cmovll %ecx, %esi
testl %edx, %edx
js 0x9b40
movl %edx, %ecx
shrl $0x3, %ecx
movzbl (%rax,%rcx), %ecx
movl %edx, %r8d
andl $0x7, %r8d
xorl %r10d, %r10d
btl %r8d, %ecx
setb %r10b
jmp 0x9b43
xorl %r10d, %r10d
leal -0x1(%rsi), %r8d
movl %r8d, %ecx
shll %cl, %r10d
negl %r10d
cmpl $0x2, %esi
jl 0x9b93
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %r11d
subl %r8d, %r11d
xorl %ecx, %ecx
movl %r11d, %ebp
addl %ecx, %ebp
movl $0x0, %ebx
js 0x9b83
movl %ebp, %ebx
shrl $0x3, %ebx
movzbl (%rax,%rbx), %r14d
andl $0x7, %ebp
xorl %ebx, %ebx
btl %ebp, %r14d
setb %bl
shll %cl, %ebx
addl %ebx, %r10d
incl %ecx
cmpl %ecx, %r8d
jne 0x9b61
popq %rbx
popq %r14
popq %rbp
movl %edx, %r8d
subl %esi, %r8d
js 0x9bb7
movl %r8d, %ecx
shrl $0x3, %ecx
movzbl (%rax,%rcx), %ecx
movl %r8d, %r11d
andl $0x7, %r11d
xorl %eax, %eax
btl %r11d, %ecx
setb %al
jmp 0x9bb9
xorl %eax, %eax
addl %r10d, %eax
movl %eax, %ecx
negl %ecx
andl %eax, %ecx
xorl %r10d, %r10d
testb $-0x56, %cl
setne %r10b
xorl %r11d, %r11d
testb $-0x34, %cl
setne %r11b
leal (%r10,%r11,2), %r10d
xorl %r11d, %r11d
testb $-0x10, %cl
setne %r11b
leal (%r10,%r11,4), %ecx
sarl %cl, %eax
addl %r8d, %ecx
incl %ecx
movw %cx, (%rdi)
movb %al, 0x2(%rdi)
subb %sil, %r9b
movb %r9b, 0x3(%rdi)
movswl (%rdi), %ecx
xorl %eax, %eax
cmpl %edx, %ecx
jne 0x9c09
movsbl 0x2(%rdi), %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/occivink[P]pyct/monocypher.cpp
// Function: fe_isequal(int const*, int const*)
static int fe_isequal(const fe f, const fe g)
{
    u8 fs[32];
    u8 gs[32];
    fe_tobytes(fs, f);
    fe_tobytes(gs, g);
    int isdifferent = crypto_verify32(fs, gs);
    WIPE_BUFFER(fs);
    WIPE_BUFFER(gs);
    return 1 + isdifferent;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %rsi
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x76b5
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x76b5
movq %r14, %rdi
movq %r15, %rsi
callq 0x254b
xorl %ecx, %ecx
movb $0x0, 0x20(%rsp,%rcx)
incq %rcx
cmpq $0x20, %rcx
jne 0x9c41
xorl %ecx, %ecx
movb $0x0, (%rsp,%rcx)
incq %rcx
cmpq $0x20, %rcx
jne 0x9c51
incl %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/occivink[P]pyct/monocypher.cpp
// Function: remove_l(unsigned int*, unsigned int const*)
static void remove_l(u32 r[8], const u32 x[8])
{
    u64 carry = is_above_l(x);
    u32 mask  = ~(u32)carry + 1; // carry == 0 or 1
    FOR (i, 0, 8) {
        carry += (u64)x[i] + (~L[i] & mask);
        r[i]   = (u32)carry;
        carry >>= 32;
    }
}

// Assembly:
movl $0x1, %eax
xorl %edx, %edx
leaq 0x4248(%rip), %rcx      # 0xdec0
movl (%rsi,%rdx), %r8d
addq %rax, %r8
movl (%rdx,%rcx), %eax
notl %eax
addq %r8, %rax
shrq $0x20, %rax
addq $0x4, %rdx
cmpq $0x20, %rdx
jne 0x9c78
movl %eax, %edx
negl %edx
xorl %r8d, %r8d
movl (%rsi,%r8), %r9d
addq %rax, %r9
movl (%r8,%rcx), %eax
notl %eax
andl %edx, %eax
addq %r9, %rax
movl %eax, (%rdi,%r8)
shrq $0x20, %rax
addq $0x4, %r8
cmpq $0x20, %r8
jne 0x9c9c
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/occivink[P]pyct/pyct.cpp
// Function: hash_password(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long, unsigned long)
Hash hash_password(string& password, const string& salt, u64 iterations, u64 work_area_size) {
    if (salt.size() < 8)
        throw invalid_argument{"Salt too small"};
    if (work_area_size < 8*1024)
        throw invalid_argument{"Work area is too small"};
    if (iterations == 0)
        throw invalid_argument{"Need at least one iteration"};

    auto rem = work_area_size % 1024;
    if (rem > 0)
        work_area_size = work_area_size - rem + 1024;
    u64 nb_blocks = work_area_size / 1024;

    vector<u8> work_area(work_area_size);

    Hash hash;
    crypto_argon2i(hash.data(), hash.size(),
                   work_area.data(), nb_blocks,
                   iterations,
                   reinterpret_cast<const u8*>(&password[0]), password.size(),
                   reinterpret_cast<const u8*>(&salt[0]), salt.size());

    crypto_wipe(&password[0], password.size());
    password = {};
    return hash;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
cmpq $0x7, 0x8(%rdx)
jbe 0xa79c
movq %r8, %r13
cmpq $0x1fff, %r8            # imm = 0x1FFF
jbe 0xa7ba
movq %rcx, %r12
testq %rcx, %rcx
je 0xa7d8
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
addq $0x3ff, %r13            # imm = 0x3FF
movq %r13, %rsi
andq $-0x400, %rsi           # imm = 0xFC00
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xc042
shrq $0xa, %r13
movq 0x8(%rsp), %rdx
movq (%r14), %r9
movl 0x8(%r14), %eax
movl 0x8(%r15), %r10d
subq $0x8, %rsp
movq %rbx, %rdi
movl $0x20, %esi
movl %r13d, %ecx
movl %r12d, %r8d
pushq %r10
pushq (%r15)
pushq %rax
callq 0x5cfc
addq $0x20, %rsp
movq (%r14), %rdi
movq 0x8(%r14), %rsi
callq 0x2603
movq 0x8(%r14), %rdx
movq %r14, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x2300
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xa78b
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x21f0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x20f0
movq %rax, %r14
leaq 0x391b(%rip), %rsi      # 0xe0cb
movq %rax, %rdi
callq 0x23a0
jmp 0xa7f4
movl $0x10, %edi
callq 0x20f0
movq %rax, %r14
leaq 0x390c(%rip), %rsi      # 0xe0da
movq %rax, %rdi
callq 0x23a0
jmp 0xa7f4
movl $0x10, %edi
callq 0x20f0
movq %rax, %r14
leaq 0x3905(%rip), %rsi      # 0xe0f1
movq %rax, %rdi
callq 0x23a0
movq 0x77d5(%rip), %rsi      # 0x11fd0
movq 0x77be(%rip), %rdx      # 0x11fc0
movq %r14, %rdi
callq 0x2360
jmp 0xa80e
jmp 0xa80e
movq %rax, %rbx
movq %r14, %rdi
callq 0x2160
jmp 0xa83a
movq %rax, %rbx
jmp 0xa83a
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xa83a
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x21f0
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O1/occivink[P]pyct/pyct.cpp
// Function: decrypt(std::vector<unsigned char, std::allocator<unsigned char>>, std::array<unsigned char, 32ul> const&)
vector<u8> decrypt(vector<u8> input, const Hash& hash) {
    if (input.size() < (8 + 16 + 24))
        throw invalid_argument{"Not enough data"};
    size_t message_length = input.size() - 24 - 16;
    u8* message_data = input.data();
    u8* mac_data = message_data + message_length;
    u8* nonce_data = mac_data + 16;

    if (0 != crypto_unlock(message_data,
                           hash.data(),
                           nonce_data,
                           mac_data,
                           message_data, message_length))
        throw invalid_argument{"Couldn't decrypt, invalid password?"};

    u8* size_data = message_data + message_length - 8;
    u64 original_size = static_cast<u64>(size_data[7])       |
                        static_cast<u64>(size_data[6]) << 8  |
                        static_cast<u64>(size_data[5]) << 16 |
                        static_cast<u64>(size_data[4]) << 24 |
                        static_cast<u64>(size_data[3]) << 32 |
                        static_cast<u64>(size_data[2]) << 40 |
                        static_cast<u64>(size_data[1]) << 48 |
                        static_cast<u64>(size_data[0]) << 56;
    input.resize(original_size);
    return input;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rdi
movq 0x8(%rsi), %rax
subq %rdi, %rax
cmpq $0x2f, %rax
jbe 0xaa1b
movq %rsi, %r14
leaq -0x28(%rax), %r9
leaq (%rdi,%rax), %r15
addq $-0x28, %r15
leaq -0x18(%rdi,%rax), %rax
movq %rdx, %rsi
movq %rax, %rdx
movq %r15, %rcx
movq %rdi, %r8
callq 0x9535
testl %eax, %eax
jne 0xaa39
movq -0x8(%r15), %rsi
bswapq %rsi
movq %r14, %rdi
callq 0xc0a2
movq (%r14), %rax
movq %rax, (%rbx)
movq 0x8(%r14), %rax
movq %rax, 0x8(%rbx)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x20f0
movq %rax, %rbx
leaq 0x3702(%rip), %rsi      # 0xe131
movq %rax, %rdi
callq 0x23a0
jmp 0xaa55
movl $0x10, %edi
callq 0x20f0
movq %rax, %rbx
leaq 0x36f4(%rip), %rsi      # 0xe141
movq %rax, %rdi
callq 0x23a0
movq 0x7574(%rip), %rsi      # 0x11fd0
movq 0x755d(%rip), %rdx      # 0x11fc0
movq %rbx, %rdi
callq 0x2360
jmp 0xaa6d
movq %rax, %r14
movq %rbx, %rdi
callq 0x2160
movq %r14, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O1/occivink[P]pyct/pyct.cpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> read_from_fd<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(int)
T read_from_fd(int fd) {
    T data;
    size_t old_size = 0;
    size_t new_size = 32;
    while (true) {
        data.resize(new_size);
        size_t left_to_read = new_size - old_size;
        size_t already_read = 0;
        while (left_to_read > 0) {
            auto just_read = read(fd, &data[old_size + already_read], left_to_read);
            if (just_read < 0 or (size_t)just_read > left_to_read)
                throw runtime_error{"I/O error"};
            else if (just_read == 0) {
                data.resize(old_size + already_read);
                return data;
            }
            left_to_read -= just_read;
            already_read += just_read;
        }
        old_size = new_size;
        new_size *= 2;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, 0x1c(%rsp)
leaq 0x10(%rdi), %rax
movq %rax, 0x10(%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movq %rdi, 0x8(%rsp)
movb $0x0, 0x10(%rdi)
movl $0x20, %r12d
xorl %r14d, %r14d
xorl %ebx, %ebx
movq 0x8(%rsp), %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x2080
movq %r12, 0x20(%rsp)
movq %r12, %rax
subq %r14, %rax
xorl %ebp, %ebp
movq %rax, %r15
testq %rax, %rax
je 0xc2ca
leaq (%r14,%rbp), %r13
movq 0x8(%rsp), %rax
movq (%rax), %rsi
addq %r13, %rsi
movl 0x1c(%rsp), %edi
movq %r15, %rdx
callq 0x22d0
movq %rax, %r12
testq %rax, %rax
js 0xc315
movq %r15, %rax
subq %r12, %rax
jb 0xc315
testq %r12, %r12
je 0xc2aa
addq %r12, %rbp
jmp 0xc2be
movb $0x1, %bl
movq 0x8(%rsp), %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x2080
movq %r15, %rax
testq %r12, %r12
jne 0xc26d
movq 0x20(%rsp), %r12
jmp 0xc2d6
movq 0x20(%rsp), %rax
movq %rax, %r14
leaq (%rax,%rax), %r12
testq %r15, %r15
je 0xc251
testb $0x1, %bl
movq 0x10(%rsp), %rcx
jne 0xc301
movq 0x8(%rsp), %rax
movq (%rax), %rdi
cmpq %rcx, %rdi
je 0xc301
movq (%rcx), %rsi
incq %rsi
callq 0x21f0
movq 0x8(%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x20f0
movq %rax, %r15
leaq 0x266d(%rip), %rsi      # 0xe996
movq %rax, %rdi
movq 0x10(%rsp), %rbx
callq 0x20b0
movq 0x5cb3(%rip), %rsi      # 0x11ff0
movq 0x5c6c(%rip), %rdx      # 0x11fb0
movq %r15, %rdi
callq 0x2360
jmp 0xc360
movq %rax, %r14
jmp 0xc368
movq %rax, %r14
movq %r15, %rdi
callq 0x2160
jmp 0xc368
movq %rax, %r14
movq 0x10(%rsp), %rbx
movq 0x8(%rsp), %rax
movq (%rax), %rdi
cmpq %rbx, %rdi
je 0xc380
movq (%rbx), %rsi
incq %rsi
callq 0x21f0
movq %r14, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O1/jingdao[P]PointCloudApp/main.cpp
// Function: testEigenvalue()
void testEigenvalue() {
	int n=4;
	double A[4*4] = {0.35,0.09,-0.44,0.25,
					 0.45,0.07,-0.33,-0.32,
					 -0.14,-0.54,-0.03,-0.13,
					 -0.17,0.35,0.17,0.11};
	double lambda_real[4] = {};
	double lambda_imag[4] = {};
	double v[4*4] = {};
	Normal::eigenvalue(n,A,lambda_real,lambda_imag,v);
	printf("lambda: ");
	for (int i=0;i<n;i++)
		printf("%f+%fi ",lambda_real[i],lambda_imag[i]);
	printf("\n");
	for (int i=0;i<n;i++) {
		printf("v%d: ",i);
		for (int j=0;j<n;j++) {
			if (lambda_imag[i]==0)
				printf("%f ",v[i*n+j]);
			else if (lambda_imag[i]>0)
				printf("%f+%fi ",v[i*n+j],v[(i+1)*n+j]);
			else
				printf("%f+%fi ",v[(i-1)*n+j],-v[i*n+j]);

		}
		printf("\n");
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp            # imm = 0x148
leaq 0x89bc(%rip), %rsi      # 0xb040
leaq 0xc0(%rsp), %rax
movl $0x10, %ecx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rdx
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, (%rdx)
movq %rsp, %rcx
movaps %xmm0, 0x10(%rcx)
movaps %xmm0, (%rcx)
leaq 0x40(%rsp), %r8
movaps %xmm0, 0x70(%r8)
movaps %xmm0, 0x60(%r8)
movaps %xmm0, 0x50(%r8)
movaps %xmm0, 0x40(%r8)
movaps %xmm0, 0x30(%r8)
movaps %xmm0, 0x20(%r8)
movaps %xmm0, 0x10(%r8)
movaps %xmm0, (%r8)
movl $0x4, %edi
movq %rax, %rsi
callq 0xa08e
leaq 0x8a90(%rip), %rdi      # 0xb180
xorl %r14d, %r14d
xorl %eax, %eax
callq 0x2050
leaq 0x8a88(%rip), %rbx      # 0xb189
movsd 0x20(%rsp,%r14,8), %xmm0
movsd (%rsp,%r14,8), %xmm1
movq %rbx, %rdi
movb $0x2, %al
callq 0x2050
incq %r14
cmpq $0x4, %r14
jne 0x2701
movl $0xa, %edi
callq 0x2280
leaq 0x60(%rsp), %r13
leaq 0x8a5a(%rip), %rbx      # 0xb191
leaq 0x8a59(%rip), %r14      # 0xb197
leaq 0x8a44(%rip), %r15      # 0xb189
xorl %r12d, %r12d
movq %rbx, %rdi
movl %r12d, %esi
xorl %eax, %eax
callq 0x2050
movq $-0x4, %rbp
movsd (%rsp,%r12,8), %xmm0
ucomisd 0x88b6(%rip), %xmm0     # 0xb020
jne 0x2781
jp 0x2781
movsd (%r13,%rbp,8), %xmm0
movq %r14, %rdi
movb $0x1, %al
callq 0x2050
jmp 0x27b2
jbe 0x2793
movsd (%r13,%rbp,8), %xmm0
movsd 0x20(%r13,%rbp,8), %xmm1
jmp 0x27a8
movsd -0x20(%r13,%rbp,8), %xmm0
movsd (%r13,%rbp,8), %xmm1
xorps 0x8868(%rip), %xmm1     # 0xb010
movq %r15, %rdi
movb $0x2, %al
callq 0x2050
incq %rbp
jne 0x275c
movl $0xa, %edi
callq 0x2280
incq %r12
addq $0x20, %r13
cmpq $0x4, %r12
jne 0x2748
addq $0x148, %rsp            # imm = 0x148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jingdao[P]PointCloudApp/main.cpp
// Function: testSVD()
void testSVD() {
	int m=6,n=4,l=(m>n?n:m);
	double A[6*4] = {2.27,0.28,-0.48,1.07,-2.35,0.62,
					-1.54,-1.67,-3.09,1.22,2.93,-7.39,
					1.15,0.94,0.99,0.79,-1.45,1.03,
					-1.94,-0.78,-0.21,0.63,2.30,-2.57};
	double U[6*6] = {};
	double S[4] = {};
	double VT[4*4] = {};
	Normal::svd(m,n,A,U,S,VT);
	printf("S: ");
	for (int i=0;i<l;i++)
		printf("%f ",S[i]);
	printf("\n");
	for (int i=0;i<m;i++) {
		printf("u%d: ",i);
		for (int j=0;j<m;j++) {
			printf("%f ",U[i*m+j]);
		}
		printf("\n");
	}
	for (int i=0;i<n;i++) {
		printf("v%d: ",i);
		for (int j=0;j<n;j++) {
			printf("%f ",VT[i*n+j]);
		}
		printf("\n");
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x288, %rsp            # imm = 0x288
leaq 0x88c4(%rip), %rsi      # 0xb0c0
leaq 0xa0(%rsp), %r15
movl $0xc0, %edx
movq %r15, %rdi
callq 0x2180
leaq 0x160(%rsp), %r14
xorl %r12d, %r12d
movl $0x120, %edx            # imm = 0x120
movq %r14, %rdi
xorl %esi, %esi
callq 0x2100
xorps %xmm0, %xmm0
movq %rsp, %r8
movaps %xmm0, 0x10(%r8)
movaps %xmm0, (%r8)
leaq 0x20(%rsp), %rbx
movaps %xmm0, 0x70(%rbx)
movaps %xmm0, 0x60(%rbx)
movaps %xmm0, 0x50(%rbx)
movaps %xmm0, 0x40(%rbx)
movaps %xmm0, 0x30(%rbx)
movaps %xmm0, 0x20(%rbx)
movaps %xmm0, 0x10(%rbx)
movaps %xmm0, (%rbx)
movl $0x6, %edi
movl $0x4, %esi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r9
callq 0xa194
leaq 0x891e(%rip), %rdi      # 0xb19b
xorl %eax, %eax
callq 0x2050
leaq 0x890c(%rip), %r15      # 0xb197
movsd (%rsp,%r12,8), %xmm0
movq %r15, %rdi
movb $0x1, %al
callq 0x2050
incq %r12
cmpq $0x4, %r12
jne 0x288b
movl $0xa, %edi
callq 0x2280
leaq 0x88ea(%rip), %r15      # 0xb19f
leaq 0x88db(%rip), %r12      # 0xb197
xorl %r13d, %r13d
movq %r15, %rdi
movl %r13d, %esi
xorl %eax, %eax
callq 0x2050
xorl %ebp, %ebp
movsd (%r14,%rbp,8), %xmm0
movq %r12, %rdi
movb $0x1, %al
callq 0x2050
incq %rbp
cmpq $0x6, %rbp
jne 0x28ce
movl $0xa, %edi
callq 0x2280
incq %r13
addq $0x30, %r14
cmpq $0x6, %r13
jne 0x28bf
leaq 0x888c(%rip), %r14      # 0xb191
leaq 0x888b(%rip), %r15      # 0xb197
xorl %r12d, %r12d
movq %r14, %rdi
movl %r12d, %esi
xorl %eax, %eax
callq 0x2050
xorl %r13d, %r13d
movsd (%rbx,%r13,8), %xmm0
movq %r15, %rdi
movb $0x1, %al
callq 0x2050
incq %r13
cmpq $0x4, %r13
jne 0x291f
movl $0xa, %edi
callq 0x2280
incq %r12
addq $0x20, %rbx
cmpq $0x4, %r12
jne 0x290f
addq $0x288, %rsp            # imm = 0x288
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jingdao[P]PointCloudApp/pcd.cpp
// Function: PCD::PCD(int)
PCD::PCD(int size) {
	numFields = 4;
	data = NULL;
	float_data = (float*) malloc(size*4*sizeof(float));
	fields = NULL;
	numPoints = size;
	capacity = size;
	data_storage = ASCII;
	kdtree = NULL;
	camera = { {0,0,0,0}, {1,0,0,0}, 1};
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl $0x4, 0x40(%rdi)
xorl %r15d, %r15d
movq %r15, 0x50(%rdi)
leal (,%rbx,4), %eax
movslq %eax, %rdi
shlq $0x2, %rdi
callq 0x2270
movq %rax, 0x58(%r14)
movq %r15, 0x48(%r14)
movl %ebx, 0x60(%r14)
movl %ebx, 0x64(%r14)
movl $0x0, 0x68(%r14)
movq %r15, 0x70(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x1c(%r14)
movl $0x3f800000, 0x2c(%r14) # imm = 0x3F800000
movq %r15, 0x30(%r14)
movabsq $0x3f80000000000000, %rax # imm = 0x3F80000000000000
movq %rax, 0x38(%r14)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jingdao[P]PointCloudApp/pcd.cpp
// Function: PCD::~PCD()
PCD::~PCD() {
	if (fields) free(fields);
	if (data) free(data);
	if (float_data) free(float_data);
	if (kdtree) delete kdtree;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
testq %rdi, %rdi
je 0x34a0
callq 0x2240
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x34ae
callq 0x2240
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0x34bc
callq 0x2240
movq 0x70(%rbx), %rbx
testq %rbx, %rbx
je 0x34db
movq %rbx, %rdi
callq 0x85e2
movl $0x40, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x2210
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jingdao[P]PointCloudApp/pcd.cpp
// Function: PCD::expand(int)
bool PCD::expand(int size) {
	if (size < 0)
		return false;
	numPoints = size;
	if (size > capacity) {
		if (capacity == 0)
			capacity = size;
		else while (capacity < size)
			capacity *= 2;
		void* memblk  = realloc(float_data, capacity * 4 * sizeof(float));
		if (memblk) {
			float_data = (float*) memblk;
		} else {
			printf("Error: Cannot realloc %lu bytes\n",capacity * 4 * sizeof(float));
			return false;
		}
	}
	return true;
}

// Assembly:
testl %esi, %esi
js 0x3506
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, 0x60(%rdi)
movl 0x64(%rdi), %eax
cmpl %esi, %eax
jge 0x3548
testl %eax, %eax
je 0x3509
movl 0x64(%rbx), %eax
cmpl %esi, %eax
jge 0x350e
addl %eax, %eax
cmpl %esi, %eax
jl 0x34fe
jmp 0x350b
xorl %eax, %eax
retq
movl %esi, %eax
movl %eax, 0x64(%rbx)
movq 0x58(%rbx), %rdi
movslq 0x64(%rbx), %rsi
shlq $0x4, %rsi
callq 0x2380
movq %rax, %r14
testq %rax, %rax
je 0x352d
movq %r14, 0x58(%rbx)
jmp 0x3543
movslq 0x64(%rbx), %rsi
shlq $0x4, %rsi
leaq 0x7f23(%rip), %rdi      # 0xb45f
xorl %eax, %eax
callq 0x2050
testq %r14, %r14
je 0x3552
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %eax, %eax
jmp 0x354a
// File: /workspace/github_cpp_makefile_star2_O1/jingdao[P]PointCloudApp/pcd.cpp
// Function: PCD::drawLine(float, float, float, float, float, float, float, float)
void PCD::drawLine(float x1,float y1,float z1,float x2,float y2,float z2,float rgb,float interval) {
	float distance = 0;
	int offset = numPoints * 4,numSteps;
	distance += (x2-x1) * (x2-x1);
	distance += (y2-y1) * (y2-y1);
	distance += (z2-z1) * (z2-z1);
	numSteps = (int) (distance/interval/interval);
	expand(numPoints + numSteps - 1);
	float* data = float_data + offset;

	float dx = (x2-x1) / numSteps;
	float dy = (y2-y1) / numSteps;
	float dz = (z2-z1) / numSteps;
	float x = x1+dx, y = y1+dy, z = z1+dz;
	for (int i=1;i<numSteps;i++) {
		*data++ = x;
		*data++ = y;
		*data++ = z;
		*data++ = rgb;
		x += dx;
		y += dy;
		z += dz;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movss %xmm6, 0x1c(%rsp)
movss %xmm2, 0x4(%rsp)
movss %xmm1, 0xc(%rsp)
movss %xmm0, 0x14(%rsp)
movq %rdi, %rbx
movslq 0x60(%rdi), %r14
subss %xmm0, %xmm3
movss %xmm3, 0x18(%rsp)
movaps %xmm3, %xmm0
mulss %xmm3, %xmm0
xorps %xmm3, %xmm3
addss %xmm0, %xmm3
movaps %xmm4, %xmm0
subss %xmm1, %xmm0
movss %xmm0, 0x10(%rsp)
mulss %xmm0, %xmm0
addss %xmm3, %xmm0
subss %xmm2, %xmm5
movss %xmm5, 0x8(%rsp)
movaps %xmm5, %xmm1
mulss %xmm5, %xmm1
addss %xmm0, %xmm1
divss %xmm7, %xmm1
divss %xmm7, %xmm1
movaps %xmm1, 0x20(%rsp)
cvttss2si %xmm1, %r15d
leal (%r15,%r14), %esi
decl %esi
callq 0x34de
movss 0x14(%rsp), %xmm7
movss 0xc(%rsp), %xmm6
movss 0x4(%rsp), %xmm5
movss 0x18(%rsp), %xmm4
movss 0x10(%rsp), %xmm3
movss 0x8(%rsp), %xmm2
movss 0x1c(%rsp), %xmm1
cmpl $0x2, %r15d
jl 0x3659
cvttps2dq 0x20(%rsp), %xmm0
cvtdq2ps %xmm0, %xmm0
divss %xmm0, %xmm4
divss %xmm0, %xmm3
divss %xmm0, %xmm2
shlq $0x4, %r14
addq 0x58(%rbx), %r14
decl %r15d
addss %xmm2, %xmm5
addss %xmm3, %xmm6
addss %xmm4, %xmm7
movss %xmm7, (%r14)
movss %xmm6, 0x4(%r14)
movss %xmm5, 0x8(%r14)
movss %xmm1, 0xc(%r14)
addq $0x10, %r14
decl %r15d
jne 0x362d
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jingdao[P]PointCloudApp/pcd.cpp
// Function: PCD::drawAxis(float, float, float, float*, float, float)
void PCD::drawAxis(float x,float y,float z,float* R,float length,float interval) {
	float I[9] = {1,0,0,0,1,0,0,0,1}; //identity matrix
	float *rotation = R ? R : I;
	float rgb[3] = {255<<16, 255<<8, 255};

	for (int i=0;i<3;i++) { // three axes
		float x2 = x + rotation[i] * length;
		float y2 = y + rotation[i + 3] * length;
		float z2 = z + rotation[i + 6] * length;
		drawLine(x,y,z,x2,y2,z2,rgb[i],interval);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movss %xmm4, 0x1c(%rsp)
movss %xmm3, 0x18(%rsp)
movq %rsi, %rbx
movss %xmm2, 0x14(%rsp)
movss %xmm1, 0x10(%rsp)
movss %xmm0, 0xc(%rsp)
movq %rdi, %r14
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rax
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movl $0x3f800000, %ecx       # imm = 0x3F800000
movl %ecx, (%rax)
movl %ecx, 0x10(%rax)
movl %ecx, 0x20(%rax)
testq %rsi, %rsi
cmoveq %rax, %rbx
xorl %r15d, %r15d
leaq 0x8240(%rip), %r12      # 0xb900
movss (%rbx,%r15), %xmm3
movss 0x18(%rsp), %xmm2
mulss %xmm2, %xmm3
movss 0xc(%rsp), %xmm0
addss %xmm0, %xmm3
movss 0xc(%rbx,%r15), %xmm4
mulss %xmm2, %xmm4
movss 0x10(%rsp), %xmm1
addss %xmm1, %xmm4
movss 0x18(%rbx,%r15), %xmm5
mulss %xmm2, %xmm5
movss 0x14(%rsp), %xmm2
addss %xmm2, %xmm5
movss (%r15,%r12), %xmm6
movq %r14, %rdi
movss 0x1c(%rsp), %xmm7
callq 0x3556
addq $0x4, %r15
cmpq $0xc, %r15
jne 0x36c0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/jingdao[P]PointCloudApp/pcd.cpp
// Function: PCD::colormap(float)
float PCD::colormap(float f) {
	unsigned char r=0,g=0,b=0;
	if (f<=0) {
		b = 128;
	} else if (f <= 0.25) {
		g = (unsigned char) f / 0.25 * 255;
		b = (unsigned char) 128 * (1 - f / 0.25);
	} else if (f <= 0.5) {
		g = 255;
		r = (unsigned char) (f - 0.25) / 0.25 * 255;
	} else if (f <= 0.75) {
		r = 255;
		g = (unsigned char) 255 + (0.5 - f) / 0.25 * 127;
	} else if (f <= 1) {
		r = 255;
		g = (unsigned char) 128 * (1 - f) / 0.25;
	} else {
		r = 255;
	}
	int res = (r<<16)|(g<<8)|b;
	return (float) res;
}

// Assembly:
xorl %eax, %eax
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jae 0x39b9
xorps %xmm1, %xmm1
cvtss2sd %xmm0, %xmm1
movss 0x7a6f(%rip), %xmm2     # 0xb3d0
ucomiss %xmm0, %xmm2
jae 0x39c2
movss 0x7a66(%rip), %xmm2     # 0xb3d4
ucomiss %xmm0, %xmm2
jae 0x39ec
movss 0x7a5d(%rip), %xmm2     # 0xb3d8
ucomiss %xmm0, %xmm2
jae 0x3a09
movl $0xff0000, %eax         # imm = 0xFF0000
xorl %ecx, %ecx
movss 0x7a49(%rip), %xmm1     # 0xb3dc
ucomiss %xmm0, %xmm1
jb 0x39be
subss %xmm0, %xmm1
mulss 0x7a3c(%rip), %xmm1     # 0xb3e0
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
mulsd 0x78dd(%rip), %xmm0     # 0xb290
cvttsd2si %xmm0, %edx
jmp 0x3a38
movl $0x80, %ecx
xorl %edx, %edx
jmp 0x3a38
cvttss2si %xmm0, %edx
shlb $0x2, %dl
mulsd 0x7957(%rip), %xmm1     # 0xb328
addsd 0x786f(%rip), %xmm1     # 0xb248
mulsd 0x794f(%rip), %xmm1     # 0xb330
negb %dl
cvttsd2si %xmm1, %ecx
movzbl %cl, %ecx
jmp 0x3a38
addsd 0x7944(%rip), %xmm1     # 0xb338
cvttsd2si %xmm1, %eax
shlb $0x2, %al
negb %al
movzbl %al, %eax
shll $0x10, %eax
xorl %ecx, %ecx
movb $-0x1, %dl
jmp 0x3a38
movsd 0x78d7(%rip), %xmm0     # 0xb2e8
subsd %xmm1, %xmm0
mulsd 0x7873(%rip), %xmm0     # 0xb290
mulsd 0x791b(%rip), %xmm0     # 0xb340
addsd 0x791b(%rip), %xmm0     # 0xb348
cvttsd2si %xmm0, %edx
movl $0xff0000, %eax         # imm = 0xFF0000
xorl %ecx, %ecx
orl %eax, %ecx
movzbl %dl, %eax
shll $0x8, %eax
orl %ecx, %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/jingdao[P]PointCloudApp/pcd.cpp
// Function: PCD::writeToPCD(char const*)
void PCD::writeToPCD(const char* filename) {
	if (!filename)
		return;
	FILE* f = fopen(filename, "w");
	if (!f) {
		printf("Cannot write to file: %s\n", filename);
		return;
	}
	fprintf(f,"# .PCD v0.7 - Point Cloud Data file format\n"
	"VERSION 0.7\n"
	"FIELDS x y z rgb\n"
	"SIZE 4 4 4 4\n"
	"TYPE F F F I\n"
	"COUNT 1 1 1 1\n"
	"WIDTH %d\n"
	"HEIGHT 1\n"
	"VIEWPOINT 0 0 0 1 0 0 0\n"
	"POINTS %d\n"
	"DATA ascii\n",numPoints,numPoints);
	int k=0;
	float x,y,z,rgb;
	for (int i=0;i<numPoints;i++) {
		x=float_data[k++];
		y=float_data[k++];
		z=float_data[k++];
		rgb=float_data[k++];
//		fprintf(f,"%f %f %f %f\n",x,y,z,rgb);
		fprintf(f,"%f %f %f %d\n",x,y,z,(int)rgb);
	}
	fclose(f);
	printf("Wrote %d points to %s\n",numPoints,filename);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x3b18
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x7a1e(%rip), %rsi      # 0xb489
movq %rbx, %rdi
callq 0x2230
testq %rax, %rax
je 0x3b27
movq %rax, %r15
movl 0x60(%r14), %ecx
leaq 0x7a1b(%rip), %rsi      # 0xb4a5
xorl %ebp, %ebp
movq %rax, %rdi
movl %ecx, %edx
xorl %eax, %eax
callq 0x22a0
cmpl $0x0, 0x60(%r14)
jle 0x3aed
movl $0xc, %r13d
leaq 0x7aa9(%rip), %r12      # 0xb555
movq 0x58(%r14), %rax
xorps %xmm0, %xmm0
cvtss2sd -0xc(%rax,%r13), %xmm0
xorps %xmm1, %xmm1
cvtss2sd -0x8(%rax,%r13), %xmm1
xorps %xmm2, %xmm2
cvtss2sd -0x4(%rax,%r13), %xmm2
cvttss2si (%rax,%r13), %edx
movq %r15, %rdi
movq %r12, %rsi
movb $0x3, %al
callq 0x22a0
incl %ebp
addq $0x10, %r13
cmpl 0x60(%r14), %ebp
jl 0x3aac
movq %r15, %rdi
callq 0x21f0
movl 0x60(%r14), %esi
leaq 0x7a62(%rip), %rdi      # 0xb562
movq %rbx, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2050
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x795d(%rip), %rdi      # 0xb48b
movq %rbx, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2050
// File: /workspace/github_cpp_makefile_star2_O1/jingdao[P]PointCloudApp/pcd.cpp
// Function: PCD::writeToPLY(char const*)
void PCD::writeToPLY(const char* filename) {
	if (!filename)
		return;
	FILE* f = fopen(filename, "w");
	if (!f) {
		printf("Cannot write to file: %s\n", filename);
		return;
	}
	fprintf(f,"ply\n"
	"format ascii 1.0\n"
	"element face 0\n"
	"property list uchar int vertex_indices\n"
	"element vertex %d\n"
	"property float x\n"
	"property float y\n"
	"property float z\n"
	"property uchar diffuse_red\n"
	"property uchar diffuse_green\n"
	"property uchar diffuse_blue\n"
	"end_header\n",numPoints);
	int k=0;
	float x,y,z;
	int rgb;
	for (int i=0;i<numPoints;i++) {
		x=float_data[k++];
		y=float_data[k++];
		z=float_data[k++];
		rgb=(int)float_data[k++];
		fprintf(f,"%f %f %f %d %d %d\n",x,y,z,(rgb>>16)&0xff,(rgb>>8)&0xff,rgb&0xff);
	}
	fclose(f);
	printf("Wrote %d points to %s\n",numPoints,filename);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x3c2f
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x7922(%rip), %rsi      # 0xb489
movq %rbx, %rdi
callq 0x2230
testq %rax, %rax
je 0x3c3e
movq %rax, %r15
movq %rbx, (%rsp)
movl 0x60(%r14), %edx
leaq 0x79ef(%rip), %rsi      # 0xb579
xorl %ebp, %ebp
movq %rax, %rdi
xorl %eax, %eax
callq 0x22a0
cmpl $0x0, 0x60(%r14)
jle 0x3c03
movl $0xc, %r13d
movl $0xff, %ebx
leaq 0x7aba(%rip), %r12      # 0xb669
movq 0x58(%r14), %rax
cvttss2si (%rax,%r13), %r8d
xorps %xmm0, %xmm0
cvtss2sd -0xc(%rax,%r13), %xmm0
xorps %xmm1, %xmm1
cvtss2sd -0x8(%rax,%r13), %xmm1
xorps %xmm2, %xmm2
cvtss2sd -0x4(%rax,%r13), %xmm2
movl %r8d, %edx
shrl $0x10, %edx
andl %ebx, %edx
movl %r8d, %ecx
shrl $0x8, %ecx
andl %ebx, %ecx
andl %ebx, %r8d
movq %r15, %rdi
movq %r12, %rsi
movb $0x3, %al
callq 0x22a0
incl %ebp
addq $0x10, %r13
cmpl 0x60(%r14), %ebp
jl 0x3baf
movq %r15, %rdi
callq 0x21f0
movl 0x60(%r14), %esi
leaq 0x794c(%rip), %rdi      # 0xb562
movq (%rsp), %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2050
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7846(%rip), %rdi      # 0xb48b
movq %rbx, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2050
nop
// File: /workspace/github_cpp_makefile_star2_O1/jingdao[P]PointCloudApp/pcd.cpp
// Function: PCD::writeClustersToPCD(std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>*, char const*)
void PCD::writeClustersToPCD(std::vector<std::vector<int>> *indices,const char* dir) {
	char buffer[256];
	for (size_t i=0;i<indices->size();i++) {
		snprintf(buffer,256,"%s/%lu-cloud.pcd",dir,i);
		std::vector<int> currentIndices = (*indices)[i];
		PCD* subcloud = extractIndices(&currentIndices);
		subcloud->writeToPCD(buffer);
		subcloud->writeToOBJ(dir,i);
		delete subcloud;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movq %rdi, (%rsp)
movq 0x8(%rsi), %rax
cmpq (%rsi), %rax
je 0x3d3d
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x20(%rsp), %rbp
xorl %r13d, %r13d
xorl %r12d, %r12d
movl $0x100, %esi            # imm = 0x100
movq %rbp, %rdi
leaq 0x79dc(%rip), %rdx      # 0xb67c
movq %rbx, %rcx
movq %r12, %r8
xorl %eax, %eax
callq 0x2340
movq (%r14), %rsi
addq %r13, %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x7b90
movq (%rsp), %rdi
movq %r15, %rsi
callq 0x3d72
movq %rax, %r15
movq %rax, %rdi
movq %rbp, %rsi
callq 0x3a4a
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x3e7c
movq %r15, %rdi
callq 0x348e
movl $0x78, %esi
movq %r15, %rdi
callq 0x2210
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x3d14
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x2210
incq %r12
movq 0x8(%r14), %rax
subq (%r14), %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rax
addq $0x18, %r13
cmpq %rax, %r12
jb 0x3c91
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x3d69
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x2210
movq %rbx, %rdi
callq 0x23a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/jingdao[P]PointCloudApp/pcd.cpp
// Function: PCD::extractIndices(std::vector<int, std::allocator<int>>*)
PCD* PCD::extractIndices(std::vector<int> *ind) {
	PCD* p = new PCD(ind->size());
	for (size_t i=0;i<ind->size();i++) {
		p->float_data[i * 4] = float_data[(*ind)[i] * 4];
		p->float_data[i * 4 + 1] = float_data[(*ind)[i] * 4 + 1];
		p->float_data[i * 4 + 2] = float_data[(*ind)[i] * 4 + 2];
		p->float_data[i * 4 + 3] = float_data[(*ind)[i] * 4 + 3];
	}
	return p;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movl $0x78, %edi
callq 0x2200
movq %rax, %rbx
movq (%r15), %r12
movq 0x8(%r15), %r13
movq %r13, %r15
subq %r12, %r15
sarq $0x2, %r15
movl $0x4, 0x40(%rax)
xorl %ebp, %ebp
movq %rbp, 0x50(%rax)
leal (,%r15,4), %eax
movslq %eax, %rdi
shlq $0x2, %rdi
callq 0x2270
movq %rax, 0x58(%rbx)
movq %rbp, 0x48(%rbx)
movl %r15d, 0x60(%rbx)
movl %r15d, 0x64(%rbx)
movl $0x0, 0x68(%rbx)
movq %rbp, 0x70(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x1c(%rbx)
movl $0x3f800000, 0x2c(%rbx) # imm = 0x3F800000
movq %rbp, 0x30(%rbx)
movabsq $0x3f80000000000000, %rcx # imm = 0x3F80000000000000
movq %rcx, 0x38(%rbx)
cmpq %r12, %r13
je 0x3e69
movq 0x58(%r14), %rcx
cmpq $0x1, %r15
adcq $0x0, %r15
addq $0xc, %rax
xorl %edx, %edx
movslq (%r12,%rdx,4), %rsi
leaq (,%rsi,4), %rdi
shlq $0x4, %rsi
movss (%rcx,%rsi), %xmm0
movss %xmm0, -0xc(%rax)
leal 0x1(%rdi), %esi
movslq %esi, %rsi
movss (%rcx,%rsi,4), %xmm0
movss %xmm0, -0x8(%rax)
leal 0x2(%rdi), %esi
movslq %esi, %rsi
movss (%rcx,%rsi,4), %xmm0
movss %xmm0, -0x4(%rax)
orl $0x3, %edi
movslq %edi, %rsi
movss (%rcx,%rsi,4), %xmm0
movss %xmm0, (%rax)
incq %rdx
addq $0x10, %rax
cmpq %rdx, %r15
jne 0x3e14
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop