LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/WojciechMula[P]utf16utf8/tests/unittest.cpp
// Function: validate_no_surrogates_from_utf8()
bool validate_no_surrogates_from_utf8() {
    puts("Test transcoding random string from utf8 (without surrogates)");
    std::random_device rd{};
    RandomUTF8 generator(rd,
        /* 1 byte */  1,
        /* 2 bytes */ 1,
        /* 3 bytes */ 1,
        /* 4 bytes */ 0
    );
    for(size_t t = 0; t < 10000; t++) {
      auto UTF8 = generator.generate(512);
      if(!validate_from_utf8(UTF8)) {
          return false;
      }
    }
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x2770, %rsp           # imm = 0x2770
leaq 0x5e44(%rip), %rdi      # 0xb243
callq 0x21d0
leaq 0x13e8(%rsp), %rbx
movq %rbx, %rdi
callq 0x5892
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
movl $0x1, %edx
movl $0x1, %ecx
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x30d8
xorl %ebx, %ebx
leaq 0x8(%rsp), %r14
leaq 0x20(%rsp), %r15
xorl %r12d, %r12d
movl $0x200, %edx            # imm = 0x200
movq %r14, %rdi
movq %r15, %rsi
callq 0x3192
movq %r14, %rdi
callq 0x5043
movl %eax, %ebp
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x5474
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
testb %bpl, %bpl
je 0x5493
cmpq $0x270f, %r12           # imm = 0x270F
leaq 0x1(%r12), %rax
setae %bl
movq %rax, %r12
cmpq $0x2710, %rax           # imm = 0x2710
jne 0x5443
movq 0x13c0(%rsp), %rdi
testq %rdi, %rdi
je 0x54b0
movq 0x13d0(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
movq 0x13a8(%rsp), %rdi
testq %rdi, %rdi
je 0x54cd
movq 0x13b8(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
leaq 0x13e8(%rsp), %rdi
callq 0x2150
andb $0x1, %bl
movl %ebx, %eax
addq $0x2770, %rsp           # imm = 0x2770
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5534
movq %rax, %rbx
jmp 0x551f
movq %rax, %rbx
jmp 0x5515
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x5515
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
leaq 0x20(%rsp), %rdi
callq 0x5a62
leaq 0x13e8(%rsp), %rdi
callq 0x2150
movq %rbx, %rdi
callq 0x2210
movq %rax, %rdi
callq 0x5a9f
// File: /workspace/github_cpp_makefile_star2_O1/WojciechMula[P]utf16utf8/tests/unittest.cpp
// Function: validate_with_surrogates_from_utf8()
bool validate_with_surrogates_from_utf8() {
    puts("Test transcoding random string from utf8 (with surrogates)");
    std::random_device rd{};
    RandomUTF8 generator(rd,
        /* 1 byte */  1,
        /* 2 bytes */ 1,
        /* 3 bytes */ 1,
        /* 4 bytes */ 1
    );
    for(size_t t = 0; t < 10000; t++) {
      auto UTF8 = generator.generate(512);
      if(!validate_from_utf8(UTF8)) {
          return false;
      }
    }
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x2770, %rsp           # imm = 0x2770
leaq 0x5d2f(%rip), %rdi      # 0xb281
callq 0x21d0
leaq 0x13e8(%rsp), %rbx
movq %rbx, %rdi
callq 0x5892
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
movl $0x1, %edx
movl $0x1, %ecx
movl $0x1, %r8d
movl $0x1, %r9d
callq 0x30d8
xorl %ebx, %ebx
leaq 0x8(%rsp), %r14
leaq 0x20(%rsp), %r15
xorl %r12d, %r12d
movl $0x200, %edx            # imm = 0x200
movq %r14, %rdi
movq %r15, %rsi
callq 0x3192
movq %r14, %rdi
callq 0x5043
movl %eax, %ebp
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x55ca
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
testb %bpl, %bpl
je 0x55e9
cmpq $0x270f, %r12           # imm = 0x270F
leaq 0x1(%r12), %rax
setae %bl
movq %rax, %r12
cmpq $0x2710, %rax           # imm = 0x2710
jne 0x5599
movq 0x13c0(%rsp), %rdi
testq %rdi, %rdi
je 0x5606
movq 0x13d0(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
movq 0x13a8(%rsp), %rdi
testq %rdi, %rdi
je 0x5623
movq 0x13b8(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
leaq 0x13e8(%rsp), %rdi
callq 0x2150
andb $0x1, %bl
movl %ebx, %eax
addq $0x2770, %rsp           # imm = 0x2770
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x568a
movq %rax, %rbx
jmp 0x5675
movq %rax, %rbx
jmp 0x566b
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x566b
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
leaq 0x20(%rsp), %rdi
callq 0x5a62
leaq 0x13e8(%rsp), %rdi
callq 0x2150
movq %rbx, %rdi
callq 0x2210
movq %rax, %rdi
callq 0x5a9f
// File: /workspace/github_cpp_makefile_star2_O1/WojciechMula[P]utf16utf8/tests/unittest.cpp
// Function: main
int main() {

    if(!validate_no_surrogates_from_utf8())
        return EXIT_FAILURE;

    if(!validate_with_surrogates_from_utf8())
        return EXIT_FAILURE;

    if (!validate_all())
        return EXIT_FAILURE;

    if (!validate_no_surrogates())
        return EXIT_FAILURE;

    if (!validate_surrogates())
        return EXIT_FAILURE;

    puts("All OK");
    return EXIT_SUCCESS;
}

// Assembly:
pushq %rbx
movl $0x1, %ebx
callq 0x53e9
testb %al, %al
je 0x56d3
callq 0x553c
testb %al, %al
je 0x56d3
callq 0x4f5f
testb %al, %al
je 0x56d3
callq 0x4c98
testb %al, %al
je 0x56d3
callq 0x4e29
testb %al, %al
je 0x56d3
leaq 0x5bf0(%rip), %rdi      # 0xb2bc
callq 0x21d0
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/icemiliang[P]vot/src/vot/diagram.cc
// Function: vot::Diagram::Diagram(vot::otBBox, int)
Diagram::Diagram(const otBBox bBox, const int numBlocks) {
        mDiagram = new voro::container_poly(bBox.xMin, bBox.xMax,
                                             bBox.yMin, bBox.yMax,
                                             bBox.zMin, bBox.zMax,
                                             numBlocks, numBlocks, numBlocks,
                                             false, false, false, 8);
        mNumEmpiricals = 0;
        mNumDiracs = 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x50(%rdi)
movq $0x0, 0x60(%rdi)
movl $0x198, %edi            # imm = 0x198
callq 0x7370
movq %rax, %r15
leaq 0x30(%rsp), %rax
movsd (%rax), %xmm0
movsd 0x8(%rax), %xmm1
movsd 0x10(%rax), %xmm2
movsd 0x18(%rax), %xmm3
movsd 0x20(%rax), %xmm4
movsd 0x28(%rax), %xmm5
movq %r15, %rdi
movl %ebp, %esi
movl %ebp, %edx
movl %ebp, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq $0x8
pushq $0x0
callq 0x276e0
addq $0x10, %rsp
movq %r15, (%rbx)
movq $0x0, 0x38(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movl $0x198, %esi            # imm = 0x198
movq %r15, %rdi
callq 0x7380
jmp 0x10b2d
movq %rax, %r14
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x10b42
movq 0x60(%rbx), %rsi
subq %rdi, %rsi
callq 0x7380
leaq 0x8(%rbx), %r15
movq 0x40(%rbx), %rdi
callq 0x7420
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x10b64
movq 0x30(%rbx), %rsi
subq %rdi, %rsi
callq 0x7380
movq (%r15), %rdi
testq %rdi, %rdi
je 0x10b78
movq 0x18(%rbx), %rsi
subq %rdi, %rsi
callq 0x7380
movq %r14, %rdi
callq 0x76c0
// File: /workspace/github_cpp_makefile_star2_O1/icemiliang[P]vot/src/vot/diagram.cc
// Function: vot::Diagram::add_dirac(double, double, double, double, double, double, bool)
void Diagram::add_dirac(double x, double y, double z, double d, double m, double h, bool fix) {
        mDiagram->put(mNumDiracs, x, y, z, sqrt(h)); // Add a centroid/particle in container
        mDiracs.push_back(Dirac(x,y,z,d,m,fix));
        mHs.push_back(h);
        mNumDiracs++;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movl %esi, %ebp
movsd %xmm4, 0x28(%rsp)
movsd %xmm3, 0x20(%rsp)
movsd %xmm2, 0x10(%rsp)
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, (%rsp)
movq %rdi, %rbx
movsd %xmm5, 0x18(%rsp)
movq (%rdi), %r14
movl 0x38(%rdi), %r15d
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm5
jb 0x10bd4
xorps %xmm3, %xmm3
sqrtsd %xmm5, %xmm3
jmp 0x10be1
movapd %xmm5, %xmm0
callq 0x72d0
movapd %xmm0, %xmm3
movq %r14, %rdi
movl %r15d, %esi
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
callq 0x27870
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movsd (%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x38(%rsp)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x40(%rsp)
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x48(%rsp)
movsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x50(%rsp)
movb %bpl, 0x58(%rsp)
movq 0x28(%rbx), %rsi
cmpq 0x30(%rbx), %rsi
je 0x10c70
movaps 0x30(%rsp), %xmm0
movaps 0x40(%rsp), %xmm1
movaps 0x50(%rsp), %xmm2
movups %xmm2, 0x20(%rsi)
movups %xmm1, 0x10(%rsi)
movups %xmm0, (%rsi)
addq $0x30, 0x28(%rbx)
jmp 0x10c7e
leaq 0x20(%rbx), %rdi
leaq 0x30(%rsp), %rdx
callq 0x1740c
movq 0x58(%rbx), %rsi
cmpq 0x60(%rbx), %rsi
je 0x10c9c
movsd 0x18(%rsp), %xmm0
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x58(%rbx)
jmp 0x10caa
leaq 0x50(%rbx), %rdi
leaq 0x18(%rsp), %rdx
callq 0x175b2
incl 0x38(%rbx)
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/icemiliang[P]vot/src/vot/diagram.cc
// Function: vot::Diagram::write_dirac(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Diagram::write_dirac(std::string pFilename) {
        std::cout << "--> Writing resulting Diract measures to a " << pFilename << std::endl;
        std::ofstream outP(pFilename);
        for (int i = 0; i < mNumDiracs; i++) {
            // Index starts from 0
            outP << mDiracs[i].x() << " " << mDiracs[i].y() << " "
                 << mDiracs[i].z() << " "  << mDiracs[i].dirac() << " "
                 << mDiracs[i].mass() << " "  << mHs[i] << std::endl;
        }
        outP.close();
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rsi, %r14
movq %rdi, %rbx
movq 0x50efc(%rip), %r15     # 0x61f98
leaq 0x39b2e(%rip), %rsi     # 0x4abd1
movl $0x2b, %edx
movq %r15, %rdi
callq 0x73e0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r15, %rdi
callq 0x73e0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x7340
movsbl %al, %esi
movq %r15, %rdi
callq 0x7040
movq %rax, %rdi
callq 0x7260
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movl $0x10, %edx
callq 0x7790
cmpl $0x0, 0x38(%rbx)
jle 0x11222
xorl %r13d, %r13d
leaq 0x8(%rsp), %r14
leaq 0x3eae4(%rip), %r15     # 0x4fbf8
xorl %ebp, %ebp
movq 0x20(%rbx), %rax
movsd (%rax,%r13), %xmm0
movq %r14, %rdi
callq 0x7610
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x73e0
movq 0x20(%rbx), %rax
movsd 0x8(%rax,%r13), %xmm0
movq %r12, %rdi
callq 0x7610
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x73e0
movq 0x20(%rbx), %rax
movsd 0x10(%rax,%r13), %xmm0
movq %r12, %rdi
callq 0x7610
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x73e0
movq 0x20(%rbx), %rax
movsd 0x18(%rax,%r13), %xmm0
movq %r12, %rdi
callq 0x7610
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x73e0
movq 0x20(%rbx), %rax
movsd 0x20(%rax,%r13), %xmm0
movq %r12, %rdi
callq 0x7610
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x73e0
movq 0x50(%rbx), %rax
movsd (%rax,%rbp,8), %xmm0
movq %r12, %rdi
callq 0x7610
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x7340
movsbl %al, %esi
movq %r12, %rdi
callq 0x7040
movq %rax, %rdi
callq 0x7260
incq %rbp
movslq 0x38(%rbx), %rax
addq $0x30, %r13
cmpq %rax, %rbp
jl 0x11116
leaq 0x8(%rsp), %rdi
callq 0x7530
movq 0x50d3d(%rip), %rax     # 0x61f70
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x10(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x8(%rsp,%rcx)
callq 0x7300
leaq 0x100(%rsp), %rdi
callq 0x7130
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x11272
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x7570
movq %rbx, %rdi
callq 0x76c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/icemiliang[P]vot/src/vot/diagram.cc
// Function: vot::Diagram::total_dirac_mass()
double Diagram::total_dirac_mass() {
        double total = 0;
        for (int i = 0; i < mNumDiracs; i++) {
            total += mDiracs[i].dirac();
        }
        return total;
    }

// Assembly:
movslq 0x38(%rdi), %rcx
testq %rcx, %rcx
jle 0x125a7
movq 0x20(%rdi), %rax
shlq $0x4, %rcx
leaq (%rcx,%rcx,2), %rcx
xorpd %xmm0, %xmm0
xorl %edx, %edx
addsd 0x18(%rax,%rdx), %xmm0
addq $0x30, %rdx
cmpq %rdx, %rcx
jne 0x12597
retq
xorps %xmm0, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/icemiliang[P]vot/src/vot/diagram.cc
// Function: vot::Diagram::total_empirical_mass()
double Diagram::total_empirical_mass() {
        double total = 0;
        for (int i = 0; i < mNumEmpiricals; i++) {
            total += mEmpiricals[i].mass();
        }
        return total;
    }

// Assembly:
movslq 0x3c(%rdi), %rcx
testq %rcx, %rcx
jle 0x125d7
movq 0x8(%rdi), %rax
shlq $0x3, %rcx
leaq (%rcx,%rcx,4), %rcx
xorpd %xmm0, %xmm0
xorl %edx, %edx
addsd 0x18(%rax,%rdx), %xmm0
addq $0x28, %rdx
cmpq %rdx, %rcx
jne 0x125c7
retq
xorps %xmm0, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/icemiliang[P]vot/src/vot/diagram.cc
// Function: vot::Diagram::update(int, double, double, int, int)
bool Diagram::update(int method, double thres, double step, int iterP, int iterH) {
        // Hessian is computed during updating the diagram
        Eigen::SparseMatrix<double> hessian(mNumDiracs, mNumDiracs);
        if (method == METHOD_NEWTON)
            mDiagram->update_diagram(mDiracs, hessian);
        else 
            mDiagram->update_diagram();

        // Return true if gradient doesn't change too much.
        if (mFlagVerbose) 
            std::cout << "iterP: " << iterP << ", iterH: " << iterH << ". ";
        
        if (compute_gradient() < thres) {
            return true;
        }

        if (method == METHOD_NEWTON)
            update_h(hessian);
        else
            update_h(step);

        return false;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movl %ecx, %r14d
movl %edx, %r15d
movsd %xmm1, 0x18(%rsp)
movsd %xmm0, 0x10(%rsp)
movl %esi, %ebp
movq %rdi, %rbx
movslq 0x38(%rdi), %rdx
leaq 0x20(%rsp), %rdi
movb $0x0, (%rdi)
xorpd %xmm0, %xmm0
movupd %xmm0, 0x8(%rdi)
movupd %xmm0, 0x18(%rdi)
movupd %xmm0, 0x28(%rdi)
movupd %xmm0, 0x38(%rdi)
movq %rdx, %rsi
callq 0x165a6
movq (%rbx), %rdi
cmpl $0x2, %ebp
jne 0x12641
leaq 0x20(%rbx), %rsi
leaq 0x20(%rsp), %rdx
callq 0x131e2
jmp 0x12646
callq 0x13a02
cmpb $0x1, 0x68(%rbx)
jne 0x126a9
movq 0x4f945(%rip), %rdi     # 0x61f98
leaq 0x385cb(%rip), %rsi     # 0x4ac25
movl $0x7, %edx
callq 0x73e0
movq 0x4f92d(%rip), %rdi     # 0x61f98
movl %r15d, %esi
callq 0x7690
movq %rax, %r15
leaq 0x385b0(%rip), %rsi     # 0x4ac2d
movl $0x9, %edx
movq %rax, %rdi
callq 0x73e0
movq %r15, %rdi
movl %r14d, %esi
callq 0x7690
leaq 0x3cd20(%rip), %rsi     # 0x4f3bc
movl $0x2, %edx
movq %rax, %rdi
callq 0x73e0
movq %rbx, %rdi
callq 0x12752
movapd %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
ucomisd %xmm1, %xmm0
ja 0x126f5
movsd %xmm1, 0x8(%rsp)
cmpl $0x2, %ebp
jne 0x126e1
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x12af6
movsd 0x8(%rsp), %xmm1
jmp 0x126f5
movq %rbx, %rdi
movsd 0x18(%rsp), %xmm0
callq 0x12d2c
movsd 0x8(%rsp), %xmm1
movsd 0x10(%rsp), %xmm0
ucomisd %xmm1, %xmm0
seta %bl
leaq 0x48(%rsp), %r14
movq -0x10(%r14), %rdi
callq 0x7420
movq -0x8(%r14), %rdi
callq 0x7420
movq %r14, %rdi
callq 0x14f80
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x14f80
jmp 0x1274a
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x13b84
movq %rbx, %rdi
callq 0x76c0
// File: /workspace/github_cpp_makefile_star2_O1/icemiliang[P]vot/src/vot/diagram.cc
// Function: vot::Diagram::update_h(double)
void Diagram::update_h(double step) {
        for (int i = 0; i < mNumDiracs; i++) {
            mHs[i] -= step * mGradient[i]; // delta h
            ASSERT_VOT(mHs[i] > 0, "Negative h not allowed");
        }
        // I haven't found a way to directly update h
        // The alternative is to clear the diagram and define a new one with new h
        mDiagram->clear();
        for (int i = 0; i < mNumDiracs; i++) {
            mDiagram->put(i, mDiracs[i].x(), mDiracs[i].y(), mDiracs[i].z(), sqrt(mHs[i]));
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movslq 0x38(%rdi), %rax
testq %rax, %rax
jle 0x12d92
movq 0x40(%rbx), %rcx
movq 0x48(%rbx), %rdx
movq 0x50(%rbx), %rsi
xorpd 0x37e09(%rip), %xmm0    # 0x4ab60
xorl %edi, %edi
testq %rdx, %rdx
cmovleq %rdi, %rdx
xorpd %xmm1, %xmm1
cmpq %rdi, %rdx
je 0x12e3f
movsd (%rcx,%rdi,8), %xmm2
mulsd %xmm0, %xmm2
addsd (%rsi,%rdi,8), %xmm2
movsd %xmm2, (%rsi,%rdi,8)
ucomisd %xmm1, %xmm2
jbe 0x12e5e
incq %rdi
cmpq %rdi, %rax
jne 0x12d64
movq (%rbx), %rdi
callq 0x286e0
cmpl $0x0, 0x38(%rbx)
jle 0x12e33
movl $0x2, %r12d
xorl %r14d, %r14d
movq (%rbx), %r15
movq 0x20(%rbx), %rax
movsd -0x10(%rax,%r12,8), %xmm4
movsd -0x8(%rax,%r12,8), %xmm1
movsd (%rax,%r12,8), %xmm2
movq 0x50(%rbx), %rax
movsd (%rax,%r14,8), %xmm0
ucomisd 0x37d6e(%rip), %xmm0    # 0x4ab48
jb 0x12de5
xorps %xmm3, %xmm3
sqrtsd %xmm0, %xmm3
jmp 0x12e10
movsd %xmm4, 0x10(%rsp)
movsd %xmm1, 0x8(%rsp)
movsd %xmm2, (%rsp)
callq 0x72d0
movsd (%rsp), %xmm2
movsd 0x8(%rsp), %xmm1
movsd 0x10(%rsp), %xmm4
movapd %xmm0, %xmm3
movq %r15, %rdi
movl %r14d, %esi
movapd %xmm4, %xmm0
callq 0x27870
incq %r14
movslq 0x38(%rbx), %rax
addq $0x6, %r12
cmpq %rax, %r14
jl 0x12dad
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x386de(%rip), %rdi     # 0x4b524
leaq 0x386f4(%rip), %rsi     # 0x4b541
leaq 0x39e30(%rip), %rcx     # 0x4cc84
movl $0x198, %edx            # imm = 0x198
callq 0x7240
movq 0x4f17b(%rip), %rdi     # 0x61fe0
leaq 0x37e16(%rip), %rsi     # 0x4ac82
callq 0x7350
leaq 0x37e30(%rip), %rsi     # 0x4aca8
movq %rax, %rdi
callq 0x7350
leaq 0x37e2c(%rip), %rsi     # 0x4acb3
movq %rax, %rdi
callq 0x7350
movq %rax, %rdi
movl $0xe4, %esi
callq 0x7690
leaq 0x375b0(%rip), %rsi     # 0x4a453
movq %rax, %rdi
callq 0x7350
leaq 0x37e08(%rip), %rsi     # 0x4acba
movq %rax, %rdi
callq 0x7350
movq %rax, %rdi
callq 0x71a0
callq 0x7110
nop
// File: /workspace/github_cpp_makefile_star2_O1/icemiliang[P]vot/src/vot/diagram.cc
// Function: vot::Diagram::compute_wasserstein()
double Diagram::compute_wasserstein() {
        double wd = 0;
        for (int i = 0; i < mNumEmpiricals; i++) {
            wd += mEmpiricals[i].costL2(mDiracs[mEmpiricals[i].cellIndex()]);
        }
        return wd;
    }

// Assembly:
movslq 0x3c(%rdi), %rdx
testq %rdx, %rdx
jle 0x131de
movq 0x8(%rdi), %rax
movq 0x20(%rdi), %rcx
shlq $0x3, %rdx
leaq (%rdx,%rdx,4), %rdx
xorpd %xmm0, %xmm0
xorl %esi, %esi
movslq 0x20(%rax,%rsi), %rdi
leaq (%rdi,%rdi,2), %rdi
shlq $0x4, %rdi
movsd (%rax,%rsi), %xmm1
movsd 0x8(%rax,%rsi), %xmm2
subsd (%rcx,%rdi), %xmm1
subsd 0x8(%rcx,%rdi), %xmm2
mulsd %xmm2, %xmm2
mulsd %xmm1, %xmm1
addsd %xmm2, %xmm1
movsd 0x10(%rax,%rsi), %xmm2
subsd 0x10(%rcx,%rdi), %xmm2
mulsd %xmm2, %xmm2
addsd %xmm1, %xmm2
mulsd 0x18(%rax,%rsi), %xmm2
addsd %xmm2, %xmm0
addq $0x28, %rsi
cmpq %rsi, %rdx
jne 0x13187
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/icemiliang[P]vot/src/vot/../../include/Eigen/src/IterativeLinearSolvers/IterativeSolverBase.h
// Function: Eigen::LeastSquaresConjugateGradient<Eigen::SparseMatrix<double, 0, int>, Eigen::LeastSquareDiagonalPreconditioner<double>>& Eigen::IterativeSolverBase<Eigen::LeastSquaresConjugateGradient<Eigen::SparseMatrix<double, 0, int>, Eigen::LeastSquareDiagonalPreconditioner<double>>>::compute<Eigen::SparseMatrix<double, 0, int>>(Eigen::EigenBase<Eigen::SparseMatrix<double, 0, int>> const&)
Derived& compute(const EigenBase<MatrixDerived>& A)
  {
    grab(A.derived());
    m_preconditioner.compute(matrix());
    m_isInitialized = true;
    m_analysisIsOk = true;
    m_factorizationIsOk = true;
    m_info = m_preconditioner.info();
    return derived();
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x50(%rdi), %r15
movq %r15, %rdi
callq 0x17bec
xorl %eax, %eax
movb %al, 0x50(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x58(%r14)
movups %xmm0, 0x68(%r14)
movups %xmm0, 0x78(%r14)
movq $0x0, 0x88(%r14)
movb %al, 0xd8(%r14)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x17ab4
leaq 0xe0(%r14), %rdi
movq %r15, %rsi
callq 0x17c1a
movb $0x1, (%r14)
movw $0x101, 0x11c(%r14)     # imm = 0x101
movl $0x0, 0x118(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/icemiliang[P]vot/src/vot/./container.hh
// Function: void voro::container_poly::draw_diagram_gnuplot<voro::c_loop_all>(voro::c_loop_all&, _IO_FILE*)
void draw_diagram_gnuplot(c_loop &vl, FILE *fp) {
            voronoicell c; double *pp;
            if (vl.start()) do if (compute_cell(c, vl)) {
                pp = p[vl.ijk] + ps*vl.q;
                c.draw_gnuplot(*pp, pp[1], pp[2], fp);
            } while (vl.inc());
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb0, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x10(%rsp), %r12
movq %r12, %rdi
callq 0x1b948
leaq 0x4dd39(%rip), %rax     # 0x61c48
movq %rax, (%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%r14)
movl $0x0, 0x40(%r14)
movq 0x28(%r14), %r8
movslq 0x3c(%r14), %rdi
cmpl $0x0, (%r8,%rdi,4)
setne %r11b
jne 0x13fa6
movl 0x38(%r14), %eax
movl 0x34(%r14), %r9d
movl 0x30(%r14), %r10d
movl (%r14), %ecx
movl 0x4(%r14), %edx
movl 0x10(%r14), %esi
leaq (%r8,%rdi,4), %r8
addq $0x4, %r8
incl %edi
xorl %r11d, %r11d
movl %edi, 0x3c(%r14)
incl %r10d
movl %r10d, 0x30(%r14)
cmpl %ecx, %r10d
jne 0x13f96
movl $0x0, 0x30(%r14)
incl %r9d
movl %r9d, 0x34(%r14)
cmpl %edx, %r9d
jne 0x13f93
movl $0x0, 0x34(%r14)
incl %eax
movl %eax, 0x38(%r14)
cmpl %edi, %esi
je 0x13fa6
xorl %r9d, %r9d
xorl %r10d, %r10d
incl %edi
cmpl $0x0, (%r8)
leaq 0x4(%r8), %r8
setne %r11b
je 0x13f5a
testb $0x1, %r11b
je 0x140aa
leaq 0xf8(%r15), %r12
leaq 0x10(%rsp), %r13
movl 0x3c(%r14), %edx
movl 0x40(%r14), %ecx
movl 0x30(%r14), %r8d
movl 0x34(%r14), %r9d
movl 0x38(%r14), %eax
movl %eax, (%rsp)
movq %r12, %rdi
movq %r13, %rsi
callq 0x2fdae
testb %al, %al
je 0x1401c
movq 0xb0(%r15), %rax
movslq 0x3c(%r14), %rcx
movq (%rax,%rcx,8), %rax
movslq 0xc8(%r15), %rcx
movslq 0x40(%r14), %rdx
imulq %rcx, %rdx
movsd (%rax,%rdx,8), %xmm0
movsd 0x8(%rax,%rdx,8), %xmm1
movsd 0x10(%rax,%rdx,8), %xmm2
movq %r13, %rdi
movq %rbx, %rsi
callq 0x1d398
movl 0x40(%r14), %eax
incl %eax
movl %eax, 0x40(%r14)
movq 0x28(%r14), %r8
movslq 0x3c(%r14), %rdi
cmpl (%r8,%rdi,4), %eax
jl 0x13fbc
movl $0x0, 0x40(%r14)
movl (%r14), %eax
movl 0x4(%r14), %ecx
movl 0x30(%r14), %r10d
movl 0x10(%r14), %edx
movl 0x34(%r14), %r9d
movl 0x38(%r14), %esi
leaq (%r8,%rdi,4), %r8
addq $0x4, %r8
incl %edi
movl %edi, 0x3c(%r14)
incl %r10d
movl %r10d, 0x30(%r14)
cmpl %eax, %r10d
jne 0x14099
movl $0x0, 0x30(%r14)
incl %r9d
movl %r9d, 0x34(%r14)
cmpl %ecx, %r9d
jne 0x14096
movl $0x0, 0x34(%r14)
incl %esi
movl %esi, 0x38(%r14)
cmpl %edi, %edx
je 0x140aa
xorl %r9d, %r9d
xorl %r10d, %r10d
incl %edi
cmpl $0x0, (%r8)
leaq 0x4(%r8), %r8
je 0x1405d
jmp 0x13fbc
leaq 0x10(%rsp), %rdi
callq 0x1bad4
addq $0xb0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1bad4
movq %rbx, %rdi
callq 0x76c0
// File: /workspace/github_cpp_makefile_star2_O1/icemiliang[P]vot/src/vot/../../include/Eigen/src/SparseCore/SparseMatrix.h
// Function: Eigen::SparseMatrix<double, 0, int>::coeffRef(long, long)
inline Scalar& coeffRef(Index row, Index col)
    {
      eigen_assert(row>=0 && row<rows() && col>=0 && col<cols());
      
      const Index outer = IsRowMajor ? row : col;
      const Index inner = IsRowMajor ? col : row;

      Index start = m_outerIndex[outer];
      Index end = m_innerNonZeros ? m_outerIndex[outer] + m_innerNonZeros[outer] : m_outerIndex[outer+1];
      eigen_assert(end>=start && "you probably called coeffRef on a non finalized matrix");
      if(end<=start)
        return insert(row,col);
      const Index p = m_data.searchLowerIndex(start,end-1,StorageIndex(inner));
      if((p<end) && (m_data.index(p)==inner))
        return m_data.value(p);
      else
        return insert(row,col);
    }

// Assembly:
pushq %rbx
testq %rsi, %rsi
js 0x1430d
testq %rdx, %rdx
js 0x1430d
cmpq %rsi, 0x10(%rdi)
jle 0x1430d
cmpq %rdx, 0x8(%rdi)
jle 0x1430d
movq 0x18(%rdi), %rcx
movq 0x20(%rdi), %r8
movslq (%rcx,%rdx,4), %rax
testq %r8, %r8
je 0x142ac
movl (%r8,%rdx,4), %ecx
addl %eax, %ecx
jmp 0x142b0
movl 0x4(%rcx,%rdx,4), %ecx
cmpl %eax, %ecx
jl 0x1432c
cmpl %eax, %ecx
jle 0x14307
movslq %ecx, %rcx
leaq -0x1(%rcx), %r8
cmpq %rax, %r8
jle 0x142eb
movslq %esi, %r9
movq 0x30(%rdi), %r10
leaq (%r8,%rax), %r11
sarq %r11
movslq (%r10,%r11,4), %rbx
cmpq %rbx, %r9
jg 0x142e0
movq %r11, %r8
jmp 0x142e6
incq %r11
movq %r11, %rax
cmpq %rax, %r8
jg 0x142cb
cmpq %rcx, %rax
jge 0x14307
movq 0x30(%rdi), %rcx
movslq (%rcx,%rax,4), %rcx
cmpq %rsi, %rcx
jne 0x14307
shlq $0x3, %rax
addq 0x28(%rdi), %rax
popq %rbx
retq
popq %rbx
jmp 0x156ea
leaq 0x379f0(%rip), %rdi     # 0x4bd04
leaq 0x36b09(%rip), %rsi     # 0x4ae24
leaq 0x37a0f(%rip), %rcx     # 0x4bd31
movl $0xd0, %edx
callq 0x7240
leaq 0x37a70(%rip), %rdi     # 0x4bda3
leaq 0x36aea(%rip), %rsi     # 0x4ae24
leaq 0x379f0(%rip), %rcx     # 0x4bd31
movl $0xd7, %edx
callq 0x7240
nop
// File: /workspace/github_cpp_makefile_star2_O1/icemiliang[P]vot/src/vot/../../include/Eigen/src/SparseCore/SparseMatrix.h
// Function: Eigen::SparseMatrix<double, 1, int>::resize(long, long)
void resize(Index rows, Index cols)
    {
      const Index outerSize = IsRowMajor ? rows : cols;
      m_innerSize = IsRowMajor ? cols : rows;
      m_data.clear();
      if (m_outerSize != outerSize || m_outerSize==0)
      {
        std::free(m_outerIndex);
        m_outerIndex = static_cast<StorageIndex*>(std::malloc((outerSize + 1) * sizeof(StorageIndex)));
        if (!m_outerIndex) internal::throw_std_bad_alloc();
        
        m_outerSize = outerSize;
      }
      if(m_innerNonZeros)
      {
        std::free(m_innerNonZeros);
        m_innerNonZeros = 0;
      }
      memset(m_outerIndex, 0, (m_outerSize+1)*sizeof(StorageIndex));
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rdx, 0x10(%rdi)
movq $0x0, 0x38(%rdi)
movq 0x8(%rdi), %rax
cmpq %rsi, %rax
sete %cl
testq %rax, %rax
setne %al
testb %al, %cl
jne 0x14f1d
movq %rsi, %r14
movq 0x18(%rbx), %rdi
callq 0x7420
leaq 0x4(,%r14,4), %rdi
callq 0x74b0
movq %rax, 0x18(%rbx)
testq %rax, %rax
je 0x14f51
movq %r14, 0x8(%rbx)
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x14f33
callq 0x7420
movq $0x0, 0x20(%rbx)
movq 0x8(%rbx), %rax
movq 0x18(%rbx), %rdi
leaq 0x4(,%rax,4), %rdx
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x71e0
movl $0x8, %edi
callq 0x71b0
movq 0x4d01e(%rip), %rcx     # 0x61f80
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x4d030(%rip), %rsi     # 0x61fa0
movq 0x4cfe1(%rip), %rdx     # 0x61f58
movq %rax, %rdi
callq 0x7680
nop
// File: /workspace/github_cpp_makefile_star2_O1/icemiliang[P]vot/src/vot/../../include/Eigen/src/SparseCore/CompressedStorage.h
// Function: Eigen::internal::CompressedStorage<double, int>::resize(long, double)
void resize(Index size, double reserveSizeFactor = 0)
    {
      if (m_allocatedSize<size)
      {
        Index realloc_size = (std::min<Index>)(NumTraits<StorageIndex>::highest(),  size + Index(reserveSizeFactor*double(size)));
        if(realloc_size<size)
          internal::throw_std_bad_alloc();
        reallocate(realloc_size);
      }
      m_size = size;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rsi, 0x18(%rdi)
jge 0x154a3
cvtsi2sd %rbx, %xmm1
mulsd %xmm0, %xmm1
cvttsd2si %xmm1, %rbp
addq %rbx, %rbp
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
cmpq %rax, %rbp
cmovgeq %rax, %rbp
cmpq %rbx, %rbp
jl 0x154b6
movq %rbp, %rax
shrq $0x3d, %rax
leaq (,%rbp,8), %rcx
xorl %r12d, %r12d
negq %rax
movl $0x0, %edi
sbbq %rdi, %rdi
orq %rcx, %rdi
callq 0x7030
movq %rax, %r15
movq %rbp, %rax
shrq $0x3e, %rax
leaq (,%rbp,4), %rcx
negq %rax
sbbq %r12, %r12
orq %rcx, %r12
movq %r12, %rdi
callq 0x7030
movq %rax, %r12
movq 0x10(%r14), %r13
cmpq %rbp, %r13
cmovgeq %rbp, %r13
testq %r13, %r13
jle 0x1547a
movq (%r14), %rsi
leaq (,%r13,8), %rdx
movq %r15, %rdi
callq 0x72f0
movq 0x8(%r14), %rsi
shlq $0x2, %r13
movq %r12, %rdi
movq %r13, %rdx
callq 0x72f0
movq (%r14), %r13
movq 0x8(%r14), %rdi
movq %r15, (%r14)
movq %r12, 0x8(%r14)
movq %rbp, 0x18(%r14)
testq %rdi, %rdi
je 0x15496
callq 0x7480
testq %r13, %r13
je 0x154a3
movq %r13, %rdi
callq 0x7480
movq %rbx, 0x10(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x8, %edi
callq 0x71b0
movq 0x4cab9(%rip), %rcx     # 0x61f80
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x4cacb(%rip), %rsi     # 0x61fa0
movq 0x4ca7c(%rip), %rdx     # 0x61f58
movq %rax, %rdi
callq 0x7680
movq %rax, %rbx
movq %r15, %rdi
callq 0x7480
movq %rbx, %rdi
callq 0x76c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/icemiliang[P]vot/src/vot/../../include/Eigen/src/SparseCore/SparseCompressedBase.h
// Function: Eigen::SparseCompressedBase<Eigen::Block<Eigen::SparseMatrix<double, 0, int>, -1, 1, true>>::nonZeros() const
inline Index nonZeros() const
    {
      if(Derived::IsVectorAtCompileTime && outerIndexPtr()==0)
        return derived().nonZeros();
      else if(isCompressed())
        return outerIndexPtr()[derived().outerSize()]-outerIndexPtr()[0];
      else if(derived().outerSize()==0)
        return 0;
      else
        return innerNonZeros().sum();
    }

// Assembly:
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rcx
movq 0x18(%rax), %rdx
testq %rdx, %rdx
je 0x15590
subq $0x48, %rsp
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x155d5
leaq (%rax,%rcx,4), %rax
leaq 0x10(%rsp), %rcx
movq %rax, (%rcx)
movl $0x1, %edx
movq %rdx, 0x8(%rcx)
leaq 0x28(%rsp), %rdi
movq %rax, (%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
leaq 0xf(%rsp), %rsi
callq 0x155e6
cltq
jmp 0x155e1
movslq 0x4(%rdx,%rcx,4), %rax
movslq (%rdx,%rcx,4), %rcx
subq %rcx, %rax
addq $0x48, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O1/icemiliang[P]vot/src/vot/../../include/Eigen/src/SparseCore/SparseMatrix.h
// Function: void Eigen::SparseMatrix<double, 0, int>::initAssignment<Eigen::CwiseBinaryOp<Eigen::internal::scalar_sum_op<double, double>, Eigen::SparseMatrix<double, 0, int> const, Eigen::SparseMatrix<double, 0, int> const>>(Eigen::CwiseBinaryOp<Eigen::internal::scalar_sum_op<double, double>, Eigen::SparseMatrix<double, 0, int> const, Eigen::SparseMatrix<double, 0, int> const> const&)
void initAssignment(const Other& other)
    {
      resize(other.rows(), other.cols());
      if(m_innerNonZeros)
      {
        std::free(m_innerNonZeros);
        m_innerNonZeros = 0;
      }
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rsi), %rax
movq 0x8(%rax), %rdx
movq 0x10(%rax), %rsi
callq 0x165a6
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x165a3
callq 0x7420
movq $0x0, 0x20(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/icemiliang[P]vot/src/vot/../../include/Eigen/src/SparseCore/SparseRef.h
// Function: void Eigen::internal::SparseRefBase<Eigen::Ref<Eigen::SparseMatrix<double, 0, int> const, 0, Eigen::OuterStride<-1>>>::construct<Eigen::SparseMatrix<double, 0, int> const>(Eigen::SparseMatrix<double, 0, int> const&)
void construct(Expression& expr)
  {
    if(expr.outerIndexPtr()==0)
      ::new (static_cast<Base*>(this)) Base(expr.size(), expr.nonZeros(), expr.innerIndexPtr(), expr.valuePtr());
    else
      ::new (static_cast<Base*>(this)) Base(expr.rows(), expr.cols(), expr.nonZeros(), expr.outerIndexPtr(), expr.innerIndexPtr(), expr.valuePtr(), expr.innerNonZeroPtr());
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rsi), %rcx
movq 0x8(%rsi), %r15
movq 0x10(%rsi), %r12
testq %rcx, %rcx
je 0x17b15
movq 0x20(%r14), %rax
testq %rax, %rax
je 0x17b54
testq %r15, %r15
je 0x17b5c
movq %rax, 0x10(%rsp)
movq %r15, 0x18(%rsp)
js 0x17bcc
leaq 0x28(%rsp), %rdi
movq %rax, (%rdi)
movq %r15, 0x10(%rdi)
leaq 0x10(%rsp), %rax
movq %rax, 0x18(%rdi)
leaq 0xf(%rsp), %rsi
callq 0x155e6
jmp 0x17b5e
movq 0x20(%r14), %rax
testq %rax, %rax
je 0x17b7b
testq %r15, %r15
je 0x17b83
movq %rax, 0x10(%rsp)
movq %r15, 0x18(%rsp)
js 0x17bcc
leaq 0x28(%rsp), %rdi
movq %rax, (%rdi)
movq %r15, 0x10(%rdi)
leaq 0x10(%rsp), %rax
movq %rax, 0x18(%rdi)
leaq 0xf(%rsp), %rsi
callq 0x155e6
jmp 0x17b85
movl (%rcx,%r15,4), %eax
subl (%rcx), %eax
jmp 0x17b5e
xorl %eax, %eax
movq 0x18(%r14), %rdi
movq 0x20(%r14), %rsi
movq 0x30(%r14), %rdx
movq 0x28(%r14), %rcx
movb $0x0, (%rbx)
movq %r15, 0x8(%rbx)
movq %r12, 0x10(%rbx)
jmp 0x17ba6
movl (%rcx,%r15,4), %eax
subl (%rcx), %eax
jmp 0x17b85
xorl %eax, %eax
imulq %r12, %r15
movq 0x28(%r14), %rcx
movq 0x30(%r14), %rdx
movb $0x0, (%rbx)
movq $0x1, 0x8(%rbx)
movq %r15, 0x10(%rbx)
leaq 0x18(%rbx), %rdi
xorl %esi, %esi
movl $0x0, 0x18(%rbx)
movl %eax, 0x1c(%rbx)
movq %rdi, 0x20(%rbx)
movq %rdx, 0x28(%rbx)
movq %rcx, 0x30(%rbx)
movq %rsi, 0x38(%rbx)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x33c31(%rip), %rdi     # 0x4b804
leaq 0x33c37(%rip), %rsi     # 0x4b811
leaq 0x3401e(%rip), %rcx     # 0x4bbff
movl $0xa3, %edx
callq 0x7240
nop
// File: /workspace/github_cpp_makefile_star2_O1/icemiliang[P]vot/src/vot/../../include/Eigen/src/SparseCore/SparseRedux.h
// Function: Eigen::SparseMatrixBase<Eigen::CwiseUnaryOp<Eigen::internal::scalar_abs2_op<double>, Eigen::Block<Eigen::Ref<Eigen::SparseMatrix<double, 0, int> const, 0, Eigen::OuterStride<-1>> const, -1, 1, true> const>>::sum() const
typename internal::traits<Derived>::Scalar
SparseMatrixBase<Derived>::sum() const
{
  eigen_assert(rows()>0 && cols()>0 && "you are using a non initialized matrix");
  Scalar res(0);
  internal::evaluator<Derived> thisEval(derived());
  for (Index j=0; j<outerSize(); ++j)
    for (typename internal::evaluator<Derived>::InnerIterator iter(thisEval,j); iter; ++iter)
      res += iter.value();
  return res;
}

// Assembly:
pushq %rax
movq 0x10(%rdi), %rsi
cmpq $0x0, 0x10(%rsi)
jle 0x17d9a
movq 0x18(%rdi), %rcx
movq 0x20(%rsi), %rdx
movslq (%rdx,%rcx,4), %rax
movq 0x38(%rsi), %r8
testq %r8, %r8
je 0x17d46
movslq (%r8,%rcx,4), %rcx
addq %rax, %rcx
jmp 0x17d4b
movslq 0x4(%rdx,%rcx,4), %rcx
movq 0x28(%rsi), %rdx
cmpq %rax, %rcx
jle 0x17d65
cmpl $0x0, (%rdx,%rax,4)
jns 0x17d65
incq %rax
cmpq %rax, %rcx
jne 0x17d54
movq %rcx, %rax
xorpd %xmm0, %xmm0
cmpq %rcx, %rax
jge 0x17d98
movq 0x10(%rdi), %rdi
movq 0x30(%rsi), %rsi
movq 0x10(%rdi), %rdi
movslq (%rdx,%rax,4), %r8
cmpq %r8, %rdi
jle 0x17d98
movsd (%rsi,%rax,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rax
cmpq %rax, %rcx
jne 0x17d7a
popq %rax
retq
leaq 0x33d21(%rip), %rdi     # 0x4bac2
leaq 0x33d5b(%rip), %rsi     # 0x4bb03
leaq 0x34fce(%rip), %rcx     # 0x4cd7d
movl $0x13, %edx
callq 0x7240
nop
// File: /workspace/github_cpp_makefile_star2_O1/icemiliang[P]vot/src/vot/../../include/Eigen/src/IterativeLinearSolvers/LeastSquareConjugateGradient.h
// Function: void Eigen::LeastSquaresConjugateGradient<Eigen::SparseMatrix<double, 0, int>, Eigen::LeastSquareDiagonalPreconditioner<double>>::_solve_with_guess_impl<Eigen::Matrix<double, -1, 1, 0, -1, 1>, Eigen::Matrix<double, -1, 1, 0, -1, 1>>(Eigen::Matrix<double, -1, 1, 0, -1, 1> const&, Eigen::Matrix<double, -1, 1, 0, -1, 1>&) const
void _solve_with_guess_impl(const Rhs& b, Dest& x) const
  {
    m_iterations = Base::maxIterations();
    m_error = Base::m_tolerance;

    for(Index j=0; j<b.cols(); ++j)
    {
      m_iterations = Base::maxIterations();
      m_error = Base::m_tolerance;

      typename Dest::ColXpr xj(x,j);
      internal::least_square_conjugate_gradient(matrix(), b.col(j), xj, Base::m_preconditioner, m_iterations, m_error);
    }

    m_isInitialized = true;
    m_info = m_error <= Base::m_tolerance ? Success : NoConvergence;
  }

// Assembly:
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
movq 0x58(%rdi), %rax
movq 0xf8(%rdi), %rcx
addq %rax, %rax
testq %rcx, %rcx
cmovnsq %rcx, %rax
movq %rax, 0x110(%rdi)
movsd 0x100(%rdi), %xmm0
movsd %xmm0, 0x108(%rdi)
movq (%rdx), %rcx
movq 0x8(%rdx), %rax
movq %rcx, (%rsp)
movq %rax, 0x8(%rsp)
testq %rcx, %rcx
sete %cl
testq %rax, %rax
setns %dil
orb %cl, %dil
je 0x17fb5
movq %rdx, 0x18(%rsp)
movq $0x0, 0x20(%rsp)
movq %rax, 0x30(%rsp)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
movq %rax, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
testq %rax, %rax
sete %al
testq %rdx, %rdx
setns %cl
orb %al, %cl
je 0x17fcc
leaq 0x110(%rbx), %r8
leaq 0x108(%rbx), %r9
leaq 0xe0(%rbx), %rcx
leaq 0x50(%rbx), %rdi
leaq 0x38(%rsp), %rax
movq %rsi, 0x18(%rax)
movq $0x0, 0x20(%rax)
movq %rdx, 0x30(%rax)
movq %rsp, %rdx
movq %rax, %rsi
callq 0x17feb
movb $0x1, (%rbx)
movsd 0x100(%rbx), %xmm0
xorl %eax, %eax
ucomisd 0x108(%rbx), %xmm0
setb %al
addl %eax, %eax
movl %eax, 0x118(%rbx)
addq $0x70, %rsp
popq %rbx
retq
leaq 0x35117(%rip), %rdi     # 0x4d0d3
leaq 0x3384e(%rip), %rsi     # 0x4b811
leaq 0x351b3(%rip), %rcx     # 0x4d17d
jmp 0x17fe1
leaq 0x35100(%rip), %rdi     # 0x4d0d3
leaq 0x33837(%rip), %rsi     # 0x4b811
leaq 0x371f0(%rip), %rcx     # 0x4f1d1
movl $0xaf, %edx
callq 0x7240
// File: /workspace/github_cpp_makefile_star2_O1/icemiliang[P]vot/src/vot/../../include/Eigen/src/SparseCore/SparseDenseProduct.h
// Function: Eigen::internal::sparse_time_dense_product_impl<Eigen::Ref<Eigen::SparseMatrix<double, 0, int> const, 0, Eigen::OuterStride<-1>>, Eigen::Block<Eigen::Matrix<double, -1, 1, 0, -1, 1>, -1, 1, true>, Eigen::Matrix<double, -1, 1, 0, -1, 1>, double, 0, true>::run(Eigen::Ref<Eigen::SparseMatrix<double, 0, int> const, 0, Eigen::OuterStride<-1>> const&, Eigen::Block<Eigen::Matrix<double, -1, 1, 0, -1, 1>, -1, 1, true> const&, Eigen::Matrix<double, -1, 1, 0, -1, 1>&, double const&)
static void run(const SparseLhsType& lhs, const DenseRhsType& rhs, DenseResType& res, const AlphaType& alpha)
  {
    evaluator<Lhs> lhsEval(lhs);
    for(Index c=0; c<rhs.cols(); ++c)
    {
      for(Index j=0; j<lhs.outerSize(); ++j)
      {
//        typename Res::Scalar rhs_j = alpha * rhs.coeff(j,c);
        typename ScalarBinaryOpTraits<AlphaType, typename Rhs::Scalar>::ReturnType rhs_j(alpha * rhs.coeff(j,c));
        for(LhsInnerIterator it(lhsEval,j); it ;++it)
          res.coeffRef(it.index(),c) += it.value() * rhs_j;
      }
    }
  }

// Assembly:
movq 0x8(%rdi), %rax
testq %rax, %rax
jle 0x1902e
pushq %r15
pushq %r14
pushq %rbx
movq 0x20(%rdi), %r8
movq (%rsi), %rsi
movq 0x30(%rdi), %r9
movq 0x28(%rdi), %r10
movq 0x38(%rdi), %rdi
movq (%rdx), %rdx
xorl %r11d, %r11d
movslq (%r8,%r11,4), %rbx
testq %rdi, %rdi
je 0x18feb
movslq (%rdi,%r11,4), %r14
addq %rbx, %r14
jmp 0x18ff0
movslq 0x4(%r8,%r11,4), %r14
cmpq %rbx, %r14
jle 0x19021
movsd (%rcx), %xmm0
mulsd (%rsi,%r11,8), %xmm0
movslq (%r10,%rbx,4), %r15
movsd (%r9,%rbx,8), %xmm1
mulsd %xmm0, %xmm1
addsd (%rdx,%r15,8), %xmm1
movsd %xmm1, (%rdx,%r15,8)
incq %rbx
cmpq %rbx, %r14
jne 0x18fff
incq %r11
cmpq %rax, %r11
jne 0x18fd9
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/icemiliang[P]vot/src/vot/ot.cc
// Function: vot::OT::import_data(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void OT::import_data(std::string pDiracFile, std::string pEmpiricalFile) {
        std::cout << "--> Importing data... " << std::endl;
        read_dirac_from_file(pDiracFile);
        read_empirical_from_file(pEmpiricalFile);
        std::cout << std::endl;
        check_total_mass();
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq 0x484df(%rip), %r14     # 0x61f98
leaq 0x358e8(%rip), %rsi     # 0x4f3a8
movl $0x16, %edx
movq %r14, %rdi
callq 0x73e0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x7340
movsbl %al, %esi
movq %r14, %rdi
callq 0x7040
movq %rax, %rdi
callq 0x7260
leaq 0x30(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %r12
movq %r12, %rdi
callq 0xac4e
movq %rbx, %rdi
movq %r12, %rsi
callq 0x19bde
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x19b38
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x7380
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
movq %rsp, %r15
movq %r15, %rdi
callq 0xac4e
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1abaa
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x19b77
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x7380
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x7340
movsbl %al, %esi
movq %r14, %rdi
callq 0x7040
movq %rax, %rdi
callq 0x7260
movq %rbx, %rdi
callq 0x1b400
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
jmp 0x19bc5
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x19bd6
movq (%r13), %rsi
incq %rsi
callq 0x7380
movq %rbx, %rdi
callq 0x76c0
// File: /workspace/github_cpp_makefile_star2_O1/icemiliang[P]vot/src/vot/ot.cc
// Function: vot::OT::setup(int, int, double, double, bool, double, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool)
void OT::setup(const int pMaxIterD, const int pMaxIterH, const double pThres, 
                   const double pLearnRate, const bool pFlagVerbose, const double pPlotScale,
                   const std::string pFilePrefix, const bool pFlagDebug) {
        mFlagVerbose = pFlagVerbose;
        mOutFilePrefix = pFilePrefix;
        mMaxIterD = pMaxIterD;
        mMaxIterH = pMaxIterH;
        mThres = pThres;
        mLearnRate = pLearnRate;
        mMethod = pLearnRate > 0.0 ? METHOD_GD : METHOD_NEWTON;

        mDiagram->setup(pFlagVerbose, pFlagDebug);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %r9d, %ebx
movl %ecx, %ebp
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, (%rsp)
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %r12
movb %bpl, 0x28(%rdi)
addq $0x8, %rdi
movq %r8, %rsi
callq 0x71d0
movl %r15d, 0x2c(%r12)
movl %r14d, 0x30(%r12)
movsd (%rsp), %xmm0
movsd %xmm0, 0x38(%r12)
movsd 0x8(%rsp), %xmm1
movsd %xmm1, 0x40(%r12)
xorpd %xmm0, %xmm0
xorl %eax, %eax
ucomisd %xmm0, %xmm1
setbe %al
incl %eax
movl %eax, 0x48(%r12)
movq (%r12), %rdi
movl %ebp, %esi
movl %ebx, %edx
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x10b80
nop
// File: /workspace/github_cpp_makefile_star2_O1/icemiliang[P]vot/src/vot/ot.cc
// Function: vot::OT::cluster()
void OT::cluster() {
        int iterD = 0;
        mDiagram->write_results(0, 0, mOutFilePrefix);
        while (iterD < mMaxIterD) {
            // OT 
            int iterH = 0;
            while (iterH < mMaxIterH) {
                if (mDiagram->update(mMethod, mThres, mLearnRate, iterD, iterH)) {
                    break;
                }
                iterH++;
                // mDiagram->write_results(iterD, iterH, mOutFilePrefix);
            }
            // Update dirac
            if (mDiagram->update_dirac()) {
                break;
            }
            iterD++;
            mDiagram->write_results(iterD, 0, mOutFilePrefix);
        }
        // mDiagram->write_results(iterD, iterH, mOutFilePrefix);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq (%rdi), %r14
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x8(%rdi), %rsi
movq 0x10(%rdi), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0xac4e
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %r15, %rcx
callq 0x11288
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x1b73d
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x7380
xorl %ebp, %ebp
leaq 0x18(%rsp), %r13
leaq 0x8(%rsp), %r14
cmpl 0x2c(%rbx), %ebp
jge 0x1b7e5
cmpl $0x0, 0x30(%rbx)
jle 0x1b78a
movl $0x1, %r15d
leal -0x1(%r15), %ecx
movq (%rbx), %rdi
movl 0x48(%rbx), %esi
movsd 0x38(%rbx), %xmm0
movsd 0x40(%rbx), %xmm1
movl %ebp, %edx
callq 0x125dc
testb %al, %al
jne 0x1b78a
leal 0x1(%r15), %eax
cmpl 0x30(%rbx), %r15d
movl %eax, %r15d
jl 0x1b75e
movq (%rbx), %rdi
callq 0x12ec8
movl %eax, %r15d
testb %al, %al
jne 0x1b7dc
incl %ebp
movq (%rbx), %r12
movq %r13, 0x8(%rsp)
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0xac4e
movq %r12, %rdi
movl %ebp, %esi
xorl %edx, %edx
movq %r14, %rcx
callq 0x11288
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x1b7dc
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7380
testb %r15b, %r15b
je 0x1b749
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
jmp 0x1b806
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x1b817
movq (%r13), %rsi
incq %rsi
callq 0x7380
movq %rbx, %rdi
callq 0x76c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/icemiliang[P]vot/src/vot/cell.cc
// Function: voro::voronoicell_base::add_memory_ds2(int*&)
void voronoicell_base::add_memory_ds2(int *&stackp2) {
    current_delete2_size<<=1;
    if(current_delete2_size>max_delete2_size) voro_fatal_error("Delete stack 2 memory allocation exceeded absolute maximum",VOROPP_MEMORY_ERROR);
#if VOROPP_VERBOSE >=2
    fprintf(stderr,"Delete stack 2 memory scaled up to %d\n",current_delete2_size);
#endif
    int *dsn=new int[current_delete2_size],*dsnp=dsn,*dsp=ds2;
    while(dsp<stackp2) *(dsnp++)=*(dsp++);
    delete [] ds2;ds2=dsn;stackp2=dsnp;
    stacke2=ds2+current_delete2_size;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl 0x14(%rdi), %eax
addl %eax, %eax
movl %eax, 0x14(%rdi)
cmpl $0x1000001, %eax        # imm = 0x1000001
jge 0x1b8ae
movq %rsi, %r14
movq %rdi, %rbx
movslq %eax, %rcx
shlq $0x2, %rcx
testl %eax, %eax
movq $-0x1, %rdi
cmovnsq %rcx, %rdi
callq 0x7030
movq %rax, %r15
movq 0x60(%rbx), %rdi
movq (%r14), %rax
movq %r15, %r12
cmpq %rax, %rdi
jae 0x1b881
movq %rdi, %rcx
movq %r15, %r12
movl (%rcx), %edx
addq $0x4, %rcx
movl %edx, (%r12)
addq $0x4, %r12
cmpq %rax, %rcx
jb 0x1b86e
testq %rdi, %rdi
je 0x1b88b
callq 0x7480
movq %r15, 0x60(%rbx)
movq %r12, (%r14)
movslq 0x14(%rbx), %rax
shlq $0x2, %rax
addq 0x60(%rbx), %rax
movq %rax, 0x68(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x79a8
nop
// File: /workspace/github_cpp_makefile_star2_O1/icemiliang[P]vot/src/vot/cell.cc
// Function: voro::voronoicell_base::add_memory_ds(int*&)
void voronoicell_base::add_memory_ds(int *&stackp) {
    current_delete_size<<=1;
    if(current_delete_size>max_delete_size) voro_fatal_error("Delete stack 1 memory allocation exceeded absolute maximum",VOROPP_MEMORY_ERROR);
#if VOROPP_VERBOSE >=2
    fprintf(stderr,"Delete stack 1 memory scaled up to %d\n",current_delete_size);
#endif
    int *dsn=new int[current_delete_size],*dsnp=dsn,*dsp=ds;
    while(dsp<stackp) *(dsnp++)=*(dsp++);
    delete [] ds;ds=dsn;stackp=dsnp;
    stacke=ds+current_delete_size;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl 0x10(%rdi), %eax
addl %eax, %eax
movl %eax, 0x10(%rdi)
cmpl $0x1000001, %eax        # imm = 0x1000001
jge 0x1b942
movq %rsi, %r14
movq %rdi, %rbx
movslq %eax, %rcx
shlq $0x2, %rcx
testl %eax, %eax
movq $-0x1, %rdi
cmovnsq %rcx, %rdi
callq 0x7030
movq %rax, %r15
movq 0x50(%rbx), %rdi
movq (%r14), %rax
movq %r15, %r12
cmpq %rax, %rdi
jae 0x1b915
movq %rdi, %rcx
movq %r15, %r12
movl (%rcx), %edx
addq $0x4, %rcx
movl %edx, (%r12)
addq $0x4, %r12
cmpq %rax, %rcx
jb 0x1b902
testq %rdi, %rdi
je 0x1b91f
callq 0x7480
movq %r15, 0x50(%rbx)
movq %r12, (%r14)
movslq 0x10(%rbx), %rax
shlq $0x2, %rax
addq 0x50(%rbx), %rax
movq %rax, 0x58(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x79d0
nop