LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
leaq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x12710
leaq -0x40(%rbp), %rdi
addq $0x8, %rdi
movq -0x30(%rbp), %rsi
callq 0x12710
movq -0x10(%rbp), %rsi
leaq -0x90(%rbp), %rdi
callq 0x44e0
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x90(%rbp), %rdi
callq 0x45c0
movq -0x20(%rbp), %rdi
movl $0x10, %esi
callq 0x4750
movq %rax, %rdx
leaq -0x90(%rbp), %rdi
leaq 0x9bec(%rip), %rsi      # 0x1c020
callq 0x45c0
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
leaq -0x90(%rbp), %rdi
callq 0x45c0
movq -0x30(%rbp), %rdi
movl $0x10, %esi
callq 0x4750
movq %rax, %rdx
leaq -0x90(%rbp), %rdi
leaq 0x9bb4(%rip), %rsi      # 0x1c020
callq 0x45c0
leaq -0x40(%rbp), %rsi
leaq -0x90(%rbp), %rdi
movl $0x10, %edx
callq 0x45c0
movq -0x8(%rbp), %rsi
leaq -0x90(%rbp), %rdi
callq 0x4ae0
addq $0x90, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0xb0, %rsp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
leaq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x38e0
leaq -0x90(%rbp), %rdi
leaq -0x50(%rbp), %rcx
movq -0x18(%rbp), %r8
addq $0x10, %r8
xorl %eax, %eax
movl %eax, %esi
movl $0x40, %edx
callq 0x4420
leaq -0xa0(%rbp), %rdi
leaq -0x90(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq 0x10(%rbp), %r8
movq 0x18(%rbp), %r9
callq 0x123b0
leaq -0x90(%rbp), %rdi
movl $0x40, %esi
callq 0x3890
movq -0x20(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x36b0
movl %eax, -0xa4(%rbp)
cmpl $0x0, -0xa4(%rbp)
jne 0x12573
movq -0x8(%rbp), %rdi
movq 0x10(%rbp), %rsi
movq 0x18(%rbp), %rdx
leaq -0x50(%rbp), %rcx
movq -0x18(%rbp), %r8
addq $0x10, %r8
movl $0x1, %r9d
callq 0x3f50
leaq -0x50(%rbp), %rdi
movl $0x20, %esi
callq 0x3890
leaq -0xa0(%rbp), %rdi
movl $0x10, %esi
callq 0x3890
movl -0xa4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x410, %rsp            # imm = 0x410
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x400(%rax), %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movl 0x404(%rax), %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movl 0x408(%rax), %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movl 0x40c(%rax), %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq $0x1, 0x28(%rax)
movq -0x8(%rbp), %rax
movl 0x410(%rax), %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movq $0x0, -0x10(%rbp)
cmpq $0x79, -0x10(%rbp)
jae 0x12808
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq $0x0, 0x38(%rax,%rcx,8)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x127e2
movq -0x8(%rbp), %rsi
leaq -0x410(%rbp), %rdi
callq 0xa610
movq -0x8(%rbp), %rdi
callq 0xa6b0
movq -0x8(%rbp), %rdi
leaq -0x410(%rbp), %rsi
callq 0xa660
movq -0x8(%rbp), %rsi
leaq -0x410(%rbp), %rdi
callq 0xa610
movq -0x8(%rbp), %rdi
callq 0xa6b0
movq -0x8(%rbp), %rdi
leaq -0x410(%rbp), %rsi
callq 0xa660
leaq -0x410(%rbp), %rdi
callq 0xd550
addq $0x410, %rsp            # imm = 0x410
popq %rbp
retq
nop
// File: occivink[P]pyct/monocypher.cpp
// Function: fe_cswap(int*, int*, int)
static void fe_cswap(fe f, fe g, int b)
{
    i32 mask = -b; // -1 = 0xffffffff
    FOR (i, 0, 10) {
        i32 x = (f[i] ^ g[i]) & mask;
        f[i] = f[i] ^ x;
        g[i] = g[i] ^ x;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
xorl %eax, %eax
subl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0xa, -0x20(%rbp)
jae 0x129d2
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rdx
xorl (%rcx,%rdx,4), %eax
andl -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %edx
xorl -0x24(%rbp), %edx
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %edx
xorl -0x24(%rbp), %edx
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1296f
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: occivink[P]pyct/monocypher.cpp
// Function: ge_zero(ge*)
static void ge_zero(ge *p)
{
    fe_0(p->X);
    fe_1(p->Y);
    fe_1(p->Z);
    fe_0(p->T);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x128c0
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
callq 0x12870
movq -0x8(%rbp), %rdi
addq $0x50, %rdi
callq 0x12870
movq -0x8(%rbp), %rdi
addq $0x78, %rdi
callq 0x128c0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: occivink[P]pyct/monocypher.cpp
// Function: lookup_add(ge*, ge_precomp*, int*, int*, ge_precomp const*, unsigned char const*, int)
static void lookup_add(ge *p, ge_precomp *tmp_c, fe tmp_a, fe tmp_b,
                       const ge_precomp comb[8], const u8 scalar[32], int i)
{
    u8 teeth = (u8)((scalar_bit(scalar, i)          ) +
                    (scalar_bit(scalar, i + 32) << 1) +
                    (scalar_bit(scalar, i + 64) << 2) +
                    (scalar_bit(scalar, i + 96) << 3));
    u8 high  = teeth >> 3;
    u8 index = (teeth ^ (high - 1)) & 7;
    FOR (j, 0, 8) {
        i32 select = 1 & (((j ^ index) - 1) >> 8);
        fe_ccopy(tmp_c->Yp, comb[j].Yp, select);
        fe_ccopy(tmp_c->Ym, comb[j].Ym, select);
        fe_ccopy(tmp_c->T2, comb[j].T2, select);
    }
    fe_neg(tmp_a, tmp_c->T2);
    fe_cswap(tmp_c->T2, tmp_a    , high ^ 1);
    fe_cswap(tmp_c->Yp, tmp_c->Ym, high ^ 1);
    ge_madd(p, p, tmp_c, tmp_a, tmp_b);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movl 0x10(%rbp), %esi
callq 0x122a0
movl %eax, -0x50(%rbp)
movq -0x30(%rbp), %rdi
movl 0x10(%rbp), %esi
addl $0x20, %esi
callq 0x122a0
movl %eax, %ecx
movl -0x50(%rbp), %eax
shll %ecx
addl %ecx, %eax
movl %eax, -0x4c(%rbp)
movq -0x30(%rbp), %rdi
movl 0x10(%rbp), %esi
addl $0x40, %esi
callq 0x122a0
movl %eax, %ecx
movl -0x4c(%rbp), %eax
shll $0x2, %ecx
addl %ecx, %eax
movl %eax, -0x48(%rbp)
movq -0x30(%rbp), %rdi
movl 0x10(%rbp), %esi
addl $0x60, %esi
callq 0x122a0
movl %eax, %ecx
movl -0x48(%rbp), %eax
shll $0x3, %ecx
addl %ecx, %eax
movb %al, -0x31(%rbp)
movzbl -0x31(%rbp), %eax
sarl $0x3, %eax
movb %al, -0x32(%rbp)
movzbl -0x31(%rbp), %eax
movzbl -0x32(%rbp), %ecx
subl $0x1, %ecx
xorl %ecx, %eax
andl $0x7, %eax
movb %al, -0x33(%rbp)
movq $0x0, -0x40(%rbp)
cmpq $0x8, -0x40(%rbp)
jae 0x12b68
movq -0x40(%rbp), %rax
movzbl -0x33(%rbp), %ecx
xorq %rcx, %rax
subq $0x1, %rax
shrq $0x8, %rax
andq $0x1, %rax
movl %eax, -0x44(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
imulq $0x78, -0x40(%rbp), %rax
addq %rax, %rsi
movl -0x44(%rbp), %edx
callq 0x11220
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
movq -0x28(%rbp), %rsi
imulq $0x78, -0x40(%rbp), %rax
addq %rax, %rsi
addq $0x28, %rsi
movl -0x44(%rbp), %edx
callq 0x11220
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
movq -0x28(%rbp), %rsi
imulq $0x78, -0x40(%rbp), %rax
addq %rax, %rsi
addq $0x50, %rsi
movl -0x44(%rbp), %edx
callq 0x11220
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x12ada
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x50, %rsi
callq 0x11290
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
movq -0x18(%rbp), %rsi
movzbl -0x32(%rbp), %edx
xorl $0x1, %edx
callq 0x12950
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
movzbl -0x32(%rbp), %edx
xorl $0x1, %edx
callq 0x12950
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
callq 0xfe40
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x10580
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
callq 0x10580
movq -0x18(%rbp), %rdi
addq $0x50, %rdi
movq -0x10(%rbp), %rsi
addq $0x50, %rsi
callq 0x10580
movq -0x18(%rbp), %rdi
addq $0x50, %rdi
movq -0x18(%rbp), %rsi
addq $0x50, %rsi
movl $0x2, %edx
callq 0x11460
movq -0x18(%rbp), %rdi
addq $0x78, %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rdx
addq $0x28, %rdx
callq 0xeb00
movq -0x8(%rbp), %rdi
addq $0x78, %rdi
movq -0x18(%rbp), %rsi
addq $0x78, %rsi
callq 0x10580
movq -0x18(%rbp), %rdi
addq $0x78, %rdi
movq -0x18(%rbp), %rsi
addq $0x28, %rsi
movq -0x18(%rbp), %rdx
callq 0xeb00
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
movq -0x18(%rbp), %rsi
addq $0x28, %rsi
movq -0x18(%rbp), %rdx
callq 0xeb50
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x78, %rsi
movq -0x18(%rbp), %rdx
addq $0x78, %rdx
callq 0xeb50
movq -0x18(%rbp), %rdi
addq $0x50, %rdi
movq -0x18(%rbp), %rsi
addq $0x50, %rsi
movq -0x18(%rbp), %rdx
addq $0x28, %rdx
callq 0xeb50
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x18(%rbp), %rdx
addq $0x50, %rdx
callq 0xec00
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movq -0x18(%rbp), %rsi
addq $0x78, %rsi
movq -0x18(%rbp), %rdx
addq $0x28, %rdx
callq 0xec00
movq -0x8(%rbp), %rdi
addq $0x50, %rdi
movq -0x18(%rbp), %rsi
addq $0x28, %rsi
movq -0x18(%rbp), %rdx
addq $0x50, %rdx
callq 0xec00
movq -0x8(%rbp), %rdi
addq $0x78, %rdi
movq -0x18(%rbp), %rsi
movq -0x18(%rbp), %rdx
addq $0x78, %rdx
callq 0xec00
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
movq -0x10(%rbp), %rdx
callq 0xeb00
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
movq -0x10(%rbp), %rdx
callq 0xeb50
movq -0x8(%rbp), %rdi
addq $0x50, %rdi
movq -0x10(%rbp), %rsi
addq $0x50, %rsi
callq 0x12900
movq -0x8(%rbp), %rdi
addq $0x78, %rdi
movq -0x10(%rbp), %rsi
addq $0x78, %rsi
leaq 0x9406(%rip), %rdx      # 0x1c1b0
callq 0xec00
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
movq -0x10(%rbp), %rdx
callq 0xeb00
leaq -0x70(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
movq -0x10(%rbp), %rdx
callq 0xeb50
leaq -0x40(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xec00
leaq -0x70(%rbp), %rdi
leaq -0x70(%rbp), %rsi
movq -0x18(%rbp), %rdx
addq $0x28, %rdx
callq 0xec00
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
leaq -0x40(%rbp), %rsi
leaq -0x70(%rbp), %rdx
callq 0xeb00
movq -0x8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x70(%rbp), %rdx
callq 0xeb50
movq -0x8(%rbp), %rdi
addq $0x50, %rdi
movq -0x10(%rbp), %rsi
addq $0x50, %rsi
movq -0x10(%rbp), %rdx
addq $0x50, %rdx
callq 0xeb00
movq -0x8(%rbp), %rdi
addq $0x50, %rdi
movq -0x8(%rbp), %rsi
addq $0x50, %rsi
movq -0x18(%rbp), %rdx
addq $0x50, %rdx
callq 0xec00
movq -0x8(%rbp), %rdi
addq $0x78, %rdi
movq -0x10(%rbp), %rsi
addq $0x78, %rsi
movq -0x18(%rbp), %rdx
addq $0x78, %rdx
callq 0xec00
leaq -0x40(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x50, %rsi
movq -0x8(%rbp), %rdx
addq $0x78, %rdx
callq 0xeb00
leaq -0x70(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x50, %rsi
movq -0x8(%rbp), %rdx
addq $0x78, %rdx
callq 0xeb50
movq -0x8(%rbp), %rdi
addq $0x78, %rdi
movq -0x8(%rbp), %rsi
movq -0x8(%rbp), %rdx
addq $0x28, %rdx
callq 0xec00
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
leaq -0x70(%rbp), %rdx
callq 0xec00
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movq -0x8(%rbp), %rsi
addq $0x28, %rsi
leaq -0x40(%rbp), %rdx
callq 0xec00
movq -0x8(%rbp), %rdi
addq $0x50, %rdi
leaq -0x40(%rbp), %rsi
leaq -0x70(%rbp), %rdx
callq 0xec00
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: occivink[P]pyct/monocypher.cpp
// Function: slide_init(slide_ctx*, unsigned char const*)
static void slide_init(slide_ctx *ctx, const u8 scalar[32])
{
    // scalar is guaranteed to be below L, either because we checked (s),
    // or because we reduced it modulo L (h_ram). L is under 2^253, so
    // so bits 253 to 255 are guaranteed to be zero. No need to test them.
    //
    // Note however that L is very close to 2^252, so bit 252 is almost
    // always zero.  If we were to start at bit 251, the tests wouldn't
    // catch the off-by-one error (constructing one that does would be
    // prohibitively expensive).
    //
    // We should still check bit 252, though.
    int i = 252;
    while (i > 0 && scalar_bit(scalar, i) == 0) {
        i--;
    }
    ctx->next_check = (u8)(i + 1);
    ctx->next_index = -1;
    ctx->next_digit = -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0xfc, -0x14(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x14(%rbp)
movb %al, -0x15(%rbp)
jle 0x12f77
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x122a0
cmpl $0x0, %eax
sete %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x12f80
jmp 0x12f8b
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x12f57
movl -0x14(%rbp), %eax
addl $0x1, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x3(%rax)
movq -0x8(%rbp), %rax
movw $0xffff, (%rax)         # imm = 0xFFFF
movq -0x8(%rbp), %rax
movb $-0x1, 0x2(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: occivink[P]pyct/monocypher.cpp
// Function: ge_sub(ge*, ge const*, ge_cached const*)
static void ge_sub(ge *s, const ge *p, const ge_cached *q)
{
    ge_cached neg;
    fe_copy(neg.Ym, q->Yp);
    fe_copy(neg.Yp, q->Ym);
    fe_copy(neg.Z , q->Z );
    fe_neg (neg.T2, q->T2);
    ge_add(s, p, &neg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0xb8(%rbp), %rdi
addq $0x28, %rdi
movq -0x18(%rbp), %rsi
callq 0x12900
leaq -0xb8(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x28, %rsi
callq 0x12900
leaq -0xb8(%rbp), %rdi
addq $0x50, %rdi
movq -0x18(%rbp), %rsi
addq $0x50, %rsi
callq 0x12900
leaq -0xb8(%rbp), %rdi
addq $0x78, %rdi
movq -0x18(%rbp), %rsi
addq $0x78, %rsi
callq 0x11290
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0xb8(%rbp), %rdx
callq 0x12dc0
addq $0xc0, %rsp
popq %rbp
retq
nopl (%rax)
// File: occivink[P]pyct/monocypher.cpp
// Function: ge_msub(ge*, ge const*, ge_precomp const*, int*, int*)
static void ge_msub(ge *s, const ge *p, const ge_precomp *q, fe a, fe b)
{
    ge_precomp neg;
    fe_copy(neg.Ym, q->Yp);
    fe_copy(neg.Yp, q->Ym);
    fe_neg (neg.T2, q->T2);
    ge_madd(s, p, &neg, a, b);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
leaq -0xa0(%rbp), %rdi
addq $0x28, %rdi
movq -0x18(%rbp), %rsi
callq 0x12900
leaq -0xa0(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x28, %rsi
callq 0x12900
leaq -0xa0(%rbp), %rdi
addq $0x50, %rdi
movq -0x18(%rbp), %rsi
addq $0x50, %rsi
callq 0x11290
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
leaq -0xa0(%rbp), %rdx
callq 0xfe40
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0xf800
leaq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xf800
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x3790
movl %eax, -0x54(%rbp)
leaq -0x30(%rbp), %rdi
movl $0x20, %esi
callq 0x3890
leaq -0x50(%rbp), %rdi
movl $0x20, %esi
callq 0x3890
movl -0x54(%rbp), %eax
addl $0x1, %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xe620
cltq
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
xorl $-0x1, %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0x8, -0x28(%rbp)
jae 0x133d2
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x28(%rbp), %rdx
leaq 0x974f(%rip), %rcx      # 0x1cae0
movl (%rcx,%rdx,4), %ecx
xorl $-0x1, %ecx
andl -0x1c(%rbp), %ecx
movl %ecx, %ecx
addq %rcx, %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl %eax, %edx
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x18(%rbp), %rax
shrq $0x20, %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x13374
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb $0x0, -0xd(%rbp)
callq 0x33f0
movq $0x0, -0x18(%rbp)
movq $0x20, -0x20(%rbp)
jmp 0x178b8
movq -0x58(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x33e0
jmp 0x178c7
movq -0x20(%rbp), %rax
subq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
cmpq $0x0, -0x38(%rbp)
jbe 0x179e6
movq -0x58(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x64(%rbp)
movq -0x18(%rbp), %rsi
movq -0x40(%rbp), %rax
addq %rax, %rsi
callq 0x3560
movq %rax, -0x60(%rbp)
jmp 0x17906
movq -0x60(%rbp), %rsi
movl -0x64(%rbp), %edi
movq -0x38(%rbp), %rdx
callq 0x3420
movq %rax, -0x70(%rbp)
jmp 0x1791c
movq -0x70(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jl 0x17935
movq -0x48(%rbp), %rax
cmpq -0x38(%rbp), %rax
jbe 0x1799b
movl $0x10, %edi
callq 0x3140
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x78(%rbp)
leaq 0x60f9(%rip), %rsi      # 0x1da49
callq 0x30c0
jmp 0x17957
movq -0x78(%rbp), %rdi
movq 0xc68e(%rip), %rsi      # 0x23ff0
movq 0xc637(%rip), %rdx      # 0x23fa0
callq 0x34c0
jmp 0x17a26
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x17a14
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x3200
jmp 0x17a14
cmpq $0x0, -0x48(%rbp)
jne 0x179c4
movq -0x58(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x40(%rbp), %rax
addq %rax, %rsi
callq 0x33e0
jmp 0x179b8
movb $0x1, -0xd(%rbp)
testb $0x1, -0xd(%rbp)
jne 0x17a07
jmp 0x179fe
jmp 0x179c6
movq -0x48(%rbp), %rcx
movq -0x38(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x48(%rbp), %rax
addq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x178db
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
shlq %rax
movq %rax, -0x20(%rbp)
jmp 0x178b6
movq -0x58(%rbp), %rdi
callq 0x31b0
movq -0x50(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x31b0
movq -0x28(%rbp), %rdi
callq 0x34f0
nopw %cs:(%rax,%rax)
// File: jingdao[P]PointCloudApp/main.cpp
// Function: main
int main(int argc,char* argv[]) {
	srand(time(NULL));
//	srand(0);
	numCommandLineArgs = argc;
	commandLineArgs = argv;

	if (argc >= 3)
		fileConversion(argv[1], argv[2]);

//	printf("Loaded %s (%d points)\n",f, d->numPoints);
//	std::vector<std::vector<int>> clusters;
//	d->kMeansClustering(&clusters);
//	for (size_t i=0;i<clusters.size();i++) {
//		for (size_t j=0;j<clusters[i].size();j++) {
//			printf("%d.pcd ",clusters[i][j]);
//		}
//		printf("\n");
//	}

//	p->loadDescriptor(argv[3]);

//	delete d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x21b0
movl %eax, %edi
callq 0x21d0
movl -0x8(%rbp), %eax
movl %eax, 0x1712d(%rip)     # 0x1a22c
movq -0x10(%rbp), %rax
movq %rax, 0x17126(%rip)     # 0x1a230
cmpl $0x3, -0x8(%rbp)
jl 0x3125
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x2b00
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x4, 0x40(%rax)
movq $0x0, 0x50(%rax)
movl -0xc(%rbp), %eax
shll $0x2, %eax
movslq %eax, %rdi
shlq $0x2, %rdi
callq 0x2260
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x58(%rax)
movq $0x0, 0x48(%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x60(%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x64(%rax)
movl $0x0, 0x68(%rax)
movq $0x0, 0x70(%rax)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x24, %edx
callq 0x2100
movq -0x38(%rbp), %rdi
movss 0xf0fe(%rip), %xmm0     # 0x13360
movss %xmm0, -0x20(%rbp)
movss 0xf0f1(%rip), %xmm0     # 0x13360
movss %xmm0, -0x10(%rbp)
addq $0x1c, %rdi
leaq -0x30(%rbp), %rsi
movl $0x24, %edx
callq 0x2180
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x48(%rax)
je 0x42b8
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x2240
movq -0x10(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x42d0
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x2240
movq -0x10(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x42e8
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0x2240
movq -0x10(%rbp), %rax
cmpq $0x0, 0x70(%rax)
je 0x431e
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x431c
movq -0x18(%rbp), %rdi
callq 0xe160
movq -0x18(%rbp), %rdi
movl $0x40, %esi
callq 0x2210
jmp 0x431e
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x4356
movb $0x0, -0x1(%rbp)
jmp 0x43fe
movq -0x28(%rbp), %rcx
movl -0x14(%rbp), %eax
movl %eax, 0x60(%rcx)
movl -0x14(%rbp), %eax
cmpl 0x64(%rcx), %eax
jle 0x43fa
movq -0x28(%rbp), %rax
cmpl $0x0, 0x64(%rax)
jne 0x4382
movq -0x28(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0x64(%rax)
jmp 0x43a0
jmp 0x4384
movq -0x28(%rbp), %rax
movl 0x64(%rax), %eax
cmpl -0x14(%rbp), %eax
jge 0x439e
movq -0x28(%rbp), %rax
movl 0x64(%rax), %ecx
shll %ecx
movl %ecx, 0x64(%rax)
jmp 0x4384
jmp 0x43a0
movq -0x28(%rbp), %rax
movq 0x58(%rax), %rdi
movl 0x64(%rax), %eax
shll $0x2, %eax
movslq %eax, %rsi
shlq $0x2, %rsi
callq 0x2350
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x43d3
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x58(%rax)
jmp 0x43f8
movq -0x28(%rbp), %rax
movl 0x64(%rax), %eax
shll $0x2, %eax
movslq %eax, %rsi
shlq $0x2, %rsi
leaq 0xf024(%rip), %rdi      # 0x1340f
movb $0x0, %al
callq 0x2050
movb $0x0, -0x1(%rbp)
jmp 0x43fe
jmp 0x43fa
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movss %xmm1, -0x10(%rbp)
movss %xmm2, -0x14(%rbp)
movq %rsi, -0x20(%rbp)
movss %xmm3, -0x24(%rbp)
movss %xmm4, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x24, %edx
callq 0x2100
movss 0xecd4(%rip), %xmm0     # 0x13360
movss %xmm0, -0x50(%rbp)
movss 0xecc7(%rip), %xmm0     # 0x13360
movss %xmm0, -0x40(%rbp)
movss 0xecba(%rip), %xmm0     # 0x13360
movss %xmm0, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x46bf
movq -0x20(%rbp), %rax
movq %rax, -0x88(%rbp)
jmp 0x46ca
leaq -0x50(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rax
movq %rax, -0x58(%rbp)
movq 0xf1d4(%rip), %rax      # 0x138b0
movq %rax, -0x64(%rbp)
movl 0xf1d2(%rip), %eax      # 0x138b8
movl %eax, -0x5c(%rbp)
movl $0x0, -0x68(%rbp)
cmpl $0x3, -0x68(%rbp)
jge 0x47b4
movq -0x80(%rbp), %rdi
movss -0xc(%rbp), %xmm1
movq -0x58(%rbp), %rax
movslq -0x68(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movss -0x24(%rbp), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x6c(%rbp)
movss -0x10(%rbp), %xmm1
movq -0x58(%rbp), %rax
movl -0x68(%rbp), %ecx
addl $0x3, %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
movss -0x24(%rbp), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x70(%rbp)
movss -0x14(%rbp), %xmm1
movq -0x58(%rbp), %rax
movl -0x68(%rbp), %ecx
addl $0x6, %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
movss -0x24(%rbp), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x74(%rbp)
movss -0xc(%rbp), %xmm0
movss -0x10(%rbp), %xmm1
movss -0x14(%rbp), %xmm2
movss -0x6c(%rbp), %xmm3
movss -0x70(%rbp), %xmm4
movss -0x74(%rbp), %xmm5
movslq -0x68(%rbp), %rax
movss -0x64(%rbp,%rax,4), %xmm6
movss -0x28(%rbp), %xmm7
callq 0x4410
movl -0x68(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x68(%rbp)
jmp 0x46f0
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movss %xmm0, -0x4(%rbp)
movb $0x0, -0x5(%rbp)
movb $0x0, -0x6(%rbp)
movb $0x0, -0x7(%rbp)
xorps %xmm0, %xmm0
ucomiss -0x4(%rbp), %xmm0
jb 0x4ad7
movb $-0x80, -0x7(%rbp)
jmp 0x4c62
movss -0x4(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0xe7d0(%rip), %xmm0     # 0x132b8
ucomisd %xmm1, %xmm0
jb 0x4b52
cvttss2si -0x4(%rbp), %eax
movzbl %al, %eax
cvtsi2sd %eax, %xmm0
movsd 0xe736(%rip), %xmm1     # 0x13238
mulsd %xmm1, %xmm0
movsd 0xe80a(%rip), %xmm1     # 0x13318
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movb %al, -0x6(%rbp)
movss -0x4(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0xe7fe(%rip), %xmm1     # 0x13328
mulsd %xmm1, %xmm0
movsd 0xe722(%rip), %xmm1     # 0x13258
addsd %xmm1, %xmm0
movsd 0xe7ee(%rip), %xmm1     # 0x13330
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movb %al, -0x7(%rbp)
jmp 0x4c60
movss -0x4(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0xe69d(%rip), %xmm0     # 0x13200
ucomisd %xmm1, %xmm0
jb 0x4bb1
movb $-0x1, -0x6(%rbp)
movss -0x4(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0xe7a2(%rip), %xmm1     # 0x13320
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movzbl %al, %eax
cvtsi2sd %eax, %xmm0
movsd 0xe6a3(%rip), %xmm1     # 0x13238
mulsd %xmm1, %xmm0
movsd 0xe777(%rip), %xmm1     # 0x13318
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movb %al, -0x5(%rbp)
jmp 0x4c5e
movss -0x4(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0xe746(%rip), %xmm0     # 0x13308
ucomisd %xmm1, %xmm0
jb 0x4c0e
movb $-0x1, -0x5(%rbp)
movss -0x4(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0xe623(%rip), %xmm0     # 0x13200
subsd %xmm1, %xmm0
movsd 0xe64f(%rip), %xmm1     # 0x13238
mulsd %xmm1, %xmm0
movsd 0xe71b(%rip), %xmm1     # 0x13310
mulsd %xmm1, %xmm0
movsd 0xe717(%rip), %xmm1     # 0x13318
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movb %al, -0x6(%rbp)
jmp 0x4c5c
movss 0xe74a(%rip), %xmm0     # 0x13360
ucomiss -0x4(%rbp), %xmm0
jb 0x4c56
movb $-0x1, -0x5(%rbp)
movss -0x4(%rbp), %xmm1
movss 0xe733(%rip), %xmm0     # 0x13360
subss %xmm1, %xmm0
movss 0xe72b(%rip), %xmm1     # 0x13364
mulss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0xe5ef(%rip), %xmm1     # 0x13238
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movb %al, -0x6(%rbp)
jmp 0x4c5a
movb $-0x1, -0x5(%rbp)
jmp 0x4c5c
jmp 0x4c5e
jmp 0x4c60
jmp 0x4c62
movzbl -0x5(%rbp), %eax
shll $0x10, %eax
movzbl -0x6(%rbp), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movzbl -0x7(%rbp), %ecx
orl %ecx, %eax
movl %eax, -0xc(%rbp)
cvtsi2ssl -0xc(%rbp), %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x4cb4
jmp 0x4df6
movq -0x10(%rbp), %rdi
leaq 0xe7b2(%rip), %rsi      # 0x13471
callq 0x2230
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x4ce6
movq -0x10(%rbp), %rsi
leaq 0xe799(%rip), %rdi      # 0x13473
movb $0x0, %al
callq 0x2050
jmp 0x4df6
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rdi
movl 0x60(%rax), %edx
movl 0x60(%rax), %ecx
leaq 0xe792(%rip), %rsi      # 0x1348d
movb $0x0, %al
callq 0x2280
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x30(%rbp)
movq -0x38(%rbp), %rcx
movl -0x30(%rbp), %eax
cmpl 0x60(%rcx), %eax
jge 0x4dd4
movq -0x38(%rbp), %rax
movq 0x58(%rax), %rcx
movl -0x1c(%rbp), %edx
movl %edx, %esi
addl $0x1, %esi
movl %esi, -0x1c(%rbp)
movslq %edx, %rdx
movss (%rcx,%rdx,4), %xmm0
movss %xmm0, -0x20(%rbp)
movq 0x58(%rax), %rcx
movl -0x1c(%rbp), %edx
movl %edx, %esi
addl $0x1, %esi
movl %esi, -0x1c(%rbp)
movslq %edx, %rdx
movss (%rcx,%rdx,4), %xmm0
movss %xmm0, -0x24(%rbp)
movq 0x58(%rax), %rcx
movl -0x1c(%rbp), %edx
movl %edx, %esi
addl $0x1, %esi
movl %esi, -0x1c(%rbp)
movslq %edx, %rdx
movss (%rcx,%rdx,4), %xmm0
movss %xmm0, -0x28(%rbp)
movq 0x58(%rax), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x1c(%rbp)
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, -0x2c(%rbp)
movq -0x18(%rbp), %rdi
movss -0x20(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movss -0x24(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
movss -0x28(%rbp), %xmm2
cvtss2sd %xmm2, %xmm2
cvttss2si -0x2c(%rbp), %edx
leaq 0xe77e(%rip), %rsi      # 0x1353d
movb $0x3, %al
callq 0x2280
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x4d10
movq -0x18(%rbp), %rdi
callq 0x21f0
movq -0x38(%rbp), %rax
movl 0x60(%rax), %esi
movq -0x10(%rbp), %rdx
leaq 0xe75b(%rip), %rdi      # 0x1354a
movb $0x0, %al
callq 0x2050
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x4e24
jmp 0x4f7f
movq -0x10(%rbp), %rdi
leaq 0xe642(%rip), %rsi      # 0x13471
callq 0x2230
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x4e56
movq -0x10(%rbp), %rsi
leaq 0xe629(%rip), %rdi      # 0x13473
movb $0x0, %al
callq 0x2050
jmp 0x4f7f
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rdi
movl 0x60(%rax), %edx
leaq 0xe6f9(%rip), %rsi      # 0x13561
movb $0x0, %al
callq 0x2280
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x30(%rbp)
movq -0x38(%rbp), %rcx
movl -0x30(%rbp), %eax
cmpl 0x60(%rcx), %eax
jge 0x4f5d
movq -0x38(%rbp), %rax
movq 0x58(%rax), %rcx
movl -0x1c(%rbp), %edx
movl %edx, %esi
addl $0x1, %esi
movl %esi, -0x1c(%rbp)
movslq %edx, %rdx
movss (%rcx,%rdx,4), %xmm0
movss %xmm0, -0x20(%rbp)
movq 0x58(%rax), %rcx
movl -0x1c(%rbp), %edx
movl %edx, %esi
addl $0x1, %esi
movl %esi, -0x1c(%rbp)
movslq %edx, %rdx
movss (%rcx,%rdx,4), %xmm0
movss %xmm0, -0x24(%rbp)
movq 0x58(%rax), %rcx
movl -0x1c(%rbp), %edx
movl %edx, %esi
addl $0x1, %esi
movl %esi, -0x1c(%rbp)
movslq %edx, %rdx
movss (%rcx,%rdx,4), %xmm0
movss %xmm0, -0x28(%rbp)
movq 0x58(%rax), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x1c(%rbp)
movslq %ecx, %rcx
cvttss2si (%rax,%rcx,4), %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rdi
movss -0x20(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movss -0x24(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
movss -0x28(%rbp), %xmm2
cvtss2sd %xmm2, %xmm2
movl -0x2c(%rbp), %edx
sarl $0x10, %edx
andl $0xff, %edx
movl -0x2c(%rbp), %ecx
sarl $0x8, %ecx
andl $0xff, %ecx
movl -0x2c(%rbp), %r8d
andl $0xff, %r8d
leaq 0xe709(%rip), %rsi      # 0x13651
movb $0x3, %al
callq 0x2280
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x4e7d
movq -0x18(%rbp), %rdi
callq 0x21f0
movq -0x38(%rbp), %rax
movl 0x60(%rax), %esi
movq -0x10(%rbp), %rdx
leaq 0xe5d2(%rip), %rdi      # 0x1354a
movb $0x0, %al
callq 0x2050
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x180, %rsp            # imm = 0x180
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x160(%rbp)
movq $0x0, -0x128(%rbp)
movq -0x128(%rbp), %rax
movq %rax, -0x168(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa9d0
movq %rax, %rcx
movq -0x168(%rbp), %rax
cmpq %rcx, %rax
jae 0x50fe
movq -0x18(%rbp), %rcx
movq -0x128(%rbp), %r8
leaq 0xe66b(%rip), %rdx      # 0x13664
xorl %eax, %eax
leaq -0x120(%rbp), %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x2310
movq -0x10(%rbp), %rdi
movq -0x128(%rbp), %rsi
callq 0xaa00
movq %rax, %rsi
leaq -0x140(%rbp), %rdi
movq %rdi, -0x178(%rbp)
callq 0xaa20
movq -0x160(%rbp), %rdi
movq -0x178(%rbp), %rsi
callq 0x5120
movq %rax, -0x170(%rbp)
jmp 0x504e
movq -0x170(%rbp), %rax
movq %rax, -0x148(%rbp)
movq -0x148(%rbp), %rdi
leaq -0x120(%rbp), %rsi
callq 0x4c90
jmp 0x5071
movq -0x148(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x128(%rbp), %rdx
callq 0x52f0
jmp 0x508a
movq -0x148(%rbp), %rax
movq %rax, -0x180(%rbp)
cmpq $0x0, %rax
je 0x50bb
movq -0x180(%rbp), %rdi
callq 0x4290
movq -0x180(%rbp), %rdi
movl $0x78, %esi
callq 0x2210
leaq -0x140(%rbp), %rdi
callq 0x31d0
movq -0x128(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x128(%rbp)
jmp 0x4fbd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x150(%rbp)
movl %eax, -0x154(%rbp)
leaq -0x140(%rbp), %rdi
callq 0x31d0
jmp 0x5107
addq $0x180, %rsp            # imm = 0x180
popq %rbp
retq
movq -0x150(%rbp), %rdi
callq 0x2380
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x78, %edi
callq 0x2200
movq %rax, -0x38(%rbp)
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0xaca0
movq -0x38(%rbp), %rdi
movl %eax, %esi
callq 0x41e0
jmp 0x5160
movq -0x40(%rbp), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0xaca0
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jae 0x52d2
movq -0x48(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xacc0
movq -0x70(%rbp), %rcx
movq %rax, %rdx
movq -0x48(%rbp), %rax
movl (%rdx), %edx
shll $0x2, %edx
movslq %edx, %rdx
movss (%rcx,%rdx,4), %xmm0
movq -0x18(%rbp), %rcx
movq 0x58(%rcx), %rcx
movq -0x30(%rbp), %rdx
shlq $0x2, %rdx
movss %xmm0, (%rcx,%rdx,4)
movq 0x58(%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xacc0
movq -0x68(%rbp), %rcx
movq %rax, %rdx
movq -0x48(%rbp), %rax
movl (%rdx), %edx
shll $0x2, %edx
addl $0x1, %edx
movslq %edx, %rdx
movss (%rcx,%rdx,4), %xmm0
movq -0x18(%rbp), %rcx
movq 0x58(%rcx), %rcx
movq -0x30(%rbp), %rdx
shlq $0x2, %rdx
movss %xmm0, 0x4(%rcx,%rdx,4)
movq 0x58(%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xacc0
movq -0x60(%rbp), %rcx
movq %rax, %rdx
movq -0x48(%rbp), %rax
movl (%rdx), %edx
shll $0x2, %edx
addl $0x2, %edx
movslq %edx, %rdx
movss (%rcx,%rdx,4), %xmm0
movq -0x18(%rbp), %rcx
movq 0x58(%rcx), %rcx
movq -0x30(%rbp), %rdx
shlq $0x2, %rdx
movss %xmm0, 0x8(%rcx,%rdx,4)
movq 0x58(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xacc0
movq %rax, %rcx
movq -0x58(%rbp), %rax
movl (%rcx), %ecx
shll $0x2, %ecx
addl $0x3, %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x30(%rbp), %rcx
shlq $0x2, %rcx
movss %xmm0, 0xc(%rax,%rcx,4)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x5170
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x78, %esi
callq 0x2210
jmp 0x52dc
movq -0x18(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x2380
nopw %cs:(%rax,%rax)
// File: jingdao[P]PointCloudApp/pcd.cpp
// Function: PCD::translate(float, float, float)
void PCD::translate(float x, float y, float z) {
	for (int i=0;i<numPoints;i++) {
		float_data[i * 4] += x;
		float_data[i * 4 + 1] += y;
		float_data[i * 4 + 2] += z;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movss %xmm1, -0x10(%rbp)
movss %xmm2, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x60(%rcx), %eax
jge 0x70ab
movq -0x20(%rbp), %rax
movss -0xc(%rbp), %xmm0
movq 0x58(%rax), %rcx
movl -0x18(%rbp), %edx
shll $0x2, %edx
movslq %edx, %rdx
addss (%rcx,%rdx,4), %xmm0
movss %xmm0, (%rcx,%rdx,4)
movss -0x10(%rbp), %xmm0
movq 0x58(%rax), %rcx
movl -0x18(%rbp), %edx
shll $0x2, %edx
addl $0x1, %edx
movslq %edx, %rdx
addss (%rcx,%rdx,4), %xmm0
movss %xmm0, (%rcx,%rdx,4)
movss -0x14(%rbp), %xmm0
movq 0x58(%rax), %rax
movl -0x18(%rbp), %ecx
shll $0x2, %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
addss (%rax,%rcx,4), %xmm0
movss %xmm0, (%rax,%rcx,4)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x7036
popq %rbp
retq
nopl (%rax)