LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/zyLiu6707[P]Arknights-Pull-Simulation/./error_flag.h
// Function: ErrorFlag::check_err() const
bool check_err() const {
    return err_redundant_identical_ctrl_arg ||

           err_redundant_total_pull_time_ctrl_arg ||
           err_invalid_value_for_total_pull_time_ctrl_arg ||
           err_invalid_value_for_total_pull_time_long_name_ctrl_arg ||
           err_missing_value_for_total_pull_time_ctrl_arg ||
           err_missing_value_for_total_pull_time_long_name_ctrl_arg ||

           err_redundant_pity_ctrl_arg ||
           err_invalid_value_for_pity_ctrl_arg ||
           err_invalid_value_for_pity_long_name_ctrl_arg ||
           err_missing_value_for_pity_ctrl_arg ||
           err_missing_value_for_pity_long_name_ctrl_arg ||

           err_redundant_num_rate_up_ctrl_arg ||
           err_invalid_value_for_num_rate_up_ctrl_arg ||
           err_invalid_value_for_num_rate_up_long_name_ctrl_arg ||
           err_missing_value_for_num_rate_up_ctrl_arg ||
           err_missing_value_for_num_rate_up_long_name_ctrl_arg ||

           err_redundant_current_pull_ctrl_arg ||
           err_invalid_value_for_current_pull_ctrl_arg ||
           err_invalid_value_for_current_pull_long_name_ctrl_arg ||
           err_missing_value_for_current_pull_ctrl_arg ||
           err_missing_value_for_current_pull_long_name_ctrl_arg ||

           err_conflict_ctrl_arg_flag ||
           err_unexpected_value_for_ctrl_arg_limited ||
           err_unexpected_value_for_ctrl_arg_standard ||
           err_unexpected_arguments_at_the_beginning ||
           err_help_ctrl_arg_with_other_args ||
           err_invalid_ctrl_args;
  }

// Assembly:
movb $0x1, %al
cmpb $0x0, (%rdi)
jne 0x51c6
cmpb $0x0, 0x1(%rdi)
jne 0x51c6
cmpb $0x0, 0x2(%rdi)
jne 0x51c6
cmpb $0x0, 0x3(%rdi)
jne 0x51c6
cmpb $0x0, 0x4(%rdi)
jne 0x51c6
cmpb $0x0, 0x5(%rdi)
jne 0x51c6
cmpb $0x0, 0x6(%rdi)
jne 0x51c6
cmpb $0x0, 0x7(%rdi)
jne 0x51c6
cmpb $0x0, 0x8(%rdi)
jne 0x51c6
cmpb $0x0, 0x9(%rdi)
jne 0x51c6
cmpb $0x0, 0xa(%rdi)
jne 0x51c6
cmpb $0x0, 0xb(%rdi)
jne 0x51c6
cmpb $0x0, 0xc(%rdi)
jne 0x51c6
cmpb $0x0, 0xd(%rdi)
jne 0x51c6
cmpb $0x0, 0xe(%rdi)
jne 0x51c6
cmpb $0x0, 0xf(%rdi)
jne 0x51c6
cmpb $0x0, 0x10(%rdi)
jne 0x51c6
cmpb $0x0, 0x11(%rdi)
jne 0x51c6
cmpb $0x0, 0x12(%rdi)
jne 0x51c6
cmpb $0x0, 0x13(%rdi)
jne 0x51c6
cmpb $0x0, 0x14(%rdi)
jne 0x51c6
cmpb $0x0, 0x15(%rdi)
jne 0x51c6
cmpb $0x0, 0x16(%rdi)
jne 0x51c6
cmpb $0x0, 0x17(%rdi)
jne 0x51c6
cmpb $0x0, 0x18(%rdi)
jne 0x51c6
cmpb $0x0, 0x19(%rdi)
jne 0x51c6
movb 0x1a(%rdi), %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/devernay[P]vlpovutils/vlpov_motionfield2.cpp
// Function: tiff_save(VLPovImage<double> const&, char const*, char const*)
static void tiff_save(const VLPovImage<double> &img, const char *fname, const char *desc)
{
    // convert to float
    float *data = new float[img.width()*img.height()];
    std::copy(img.data(), img.data()+img.width()*img.height(), data);
    //for (int i=0; i<img.width()*img.height(); ++i) {
    //    data[i] = img.data()[i];
    //}
    struct tiff_hdr th;
    tiff_head(&th, img.width(), img.height(), /*colors=*/1, /*bytes_per_sample=*/sizeof(*data), /*isfloat=*/true, desc);
    FILE *f = fopen(fname, "wb");
    if(f == NULL) {
        fprintf(stderr, "Error: cannot open file '%s' for writing\n", fname);
        return;
    }
    fwrite (&th, sizeof th, 1, f);
    fwrite(data, img.width()*img.height()*sizeof(*data), 1, f);
    fclose(f);
    delete [] data;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3d8, %rsp            # imm = 0x3D8
movq %rdx, %r12
movq %rsi, (%rsp)
movq %rdi, %r14
movl (%rdi), %ebp
movl 0x4(%rdi), %r13d
movl %r13d, %eax
imull %ebp, %eax
movslq %eax, %r15
leaq (,%r15,4), %rax
testl %r15d, %r15d
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x2040
movq %rax, %rbx
testl %r15d, %r15d
jle 0x4776
movq 0x8(%r14), %rax
incq %r15
xorl %ecx, %ecx
xorps %xmm0, %xmm0
cvtsd2ss (%rax,%rcx,2), %xmm0
movss %xmm0, (%rbx,%rcx)
decq %r15
addq $0x4, %rcx
cmpq $0x1, %r15
ja 0x475c
leaq 0x8(%rsp), %rdi
movl %ebp, %esi
movl %r13d, %edx
movl $0x4, %ecx
movl $0x1, %r8d
movq %r12, %r9
callq 0x48c7
leaq 0x6c28(%rip), %rsi      # 0xb3c2
movq (%rsp), %r15
movq %r15, %rdi
callq 0x21c0
testq %rax, %rax
je 0x4806
movq %rax, %r12
leaq 0x8(%rsp), %rdi
movl $0x3d0, %esi            # imm = 0x3D0
movl $0x1, %edx
movq %rax, %rcx
callq 0x22d0
movslq (%r14), %rax
movslq 0x4(%r14), %rsi
imulq %rax, %rsi
shlq $0x2, %rsi
movl $0x1, %edx
movq %rbx, %rdi
movq %r12, %rcx
callq 0x22d0
movq %r12, %rdi
callq 0x2150
movq %rbx, %rdi
callq 0x21e0
addq $0x3d8, %rsp            # imm = 0x3D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xa7ab(%rip), %rax      # 0xefb8
movq (%rax), %rdi
leaq 0x6bae(%rip), %rsi      # 0xb3c5
movq %r15, %rdx
xorl %eax, %eax
callq 0x2200
jmp 0x47f4
// File: /workspace/github_cpp_makefile_star2_O3/devernay[P]vlpovutils/vlpov_motionfield2.cpp
// Function: tiff_save(VLPovImage<unsigned char> const&, char const*, char const*)
static void tiff_save(const VLPovImage<unsigned char> &img, const char *fname, const char *desc)
{
    struct tiff_hdr th;
    tiff_head(&th, img.width(), img.height(), /*colors=*/1, /*bytes_per_sample=*/sizeof(img(0,0)), /*isfloat=*/false, desc);
    FILE *f = fopen(fname, "wb");
    if(f == NULL) {
        fprintf(stderr, "Error: cannot open file '%s' for writing\n", fname);
        return;
    }
    fwrite (&th, sizeof th, 1, f);
    fwrite(img.data(), img.width()*img.height()*sizeof(img(0,0)), 1, f);
    fclose(f);                          
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x3d0, %rsp            # imm = 0x3D0
movq %rdx, %r9
movq %rsi, %r14
movq %rdi, %rbx
movl (%rdi), %esi
movl 0x4(%rdi), %edx
movq %rsp, %rdi
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x48c7
leaq 0x6b6e(%rip), %rsi      # 0xb3c2
movq %r14, %rdi
callq 0x21c0
testq %rax, %rax
je 0x48aa
movq %rax, %r15
movq %rsp, %rdi
movl $0x3d0, %esi            # imm = 0x3D0
movl $0x1, %edx
movq %rax, %rcx
callq 0x22d0
movq 0x8(%rbx), %rdi
movslq (%rbx), %rax
movslq 0x4(%rbx), %rsi
imulq %rax, %rsi
movl $0x1, %edx
movq %r15, %rcx
callq 0x22d0
movq %r15, %rdi
callq 0x2150
addq $0x3d0, %rsp            # imm = 0x3D0
popq %rbx
popq %r14
popq %r15
retq
movq 0xa707(%rip), %rax      # 0xefb8
movq (%rax), %rdi
leaq 0x6b0a(%rip), %rsi      # 0xb3c5
movq %r14, %rdx
xorl %eax, %eax
callq 0x2200
jmp 0x489d
// File: /workspace/github_cpp_makefile_star2_O3/devernay[P]vlpovutils/./vlpov.hpp
// Function: VLPovImage<double>::resize(int, int)
void resize(int w, int h) {
        delete [] _data;
        if (w > 0 && h > 0) {
            _data = new T[w*h];
            _width = w; _height = h;
        } else {
            _width = _height = 0;
            _data = 0;
        }
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x5288
callq 0x21e0
testl %r14d, %r14d
setle %al
testl %ebp, %ebp
setle %cl
orb %al, %cl
jne 0x52a8
movl %ebp, %edi
imull %r14d, %edi
shlq $0x3, %rdi
callq 0x2040
jmp 0x52af
xorl %eax, %eax
xorl %r14d, %r14d
xorl %ebp, %ebp
movq %rax, 0x8(%rbx)
movl %r14d, (%rbx)
movl %ebp, 0x4(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/devernay[P]vlpovutils/occlusionmap.cpp
// Function: vlpov_occlusionmap_stereo(VLPovImage<double> const&, VLPovImage<double> const&, double, VLPovImage<unsigned char>&)
void vlpov_occlusionmap_stereo(const VLPovImage<double> &m1x, const VLPovImage<double> &m2x,
                               double t,
                               VLPovImage<unsigned char> &occ1)
{
    int width1 = m1x.width();
    int height1 = m1x.height();
    int width2 = m2x.width();
    int height2 = m2x.height();
    
    occ1.resize(width1, height1);
    
    for(int y1 = 0; y1 < height1; ++y1) {
        for(int x1 = 0; x1 < width1; ++x1) {
            double x2 = x1 + m1x(x1,y1);
            double y2 = y1;
            
            // check for visibility
            if (x2 < -0.5 || x2 > width2-0.5 ||
                y2 < -0.5 || y2 > height2-0.5) {
                occ1(x1,y1) = 0;
                continue;
            }
            
            double x1b = x2 + m2x.linear_at(x2,y2);
            // check for occlusion
            if (std::abs(x1 - x1b) > t) {
                occ1(x1,y1) = 0;
                continue;
            }
            
            // point is visible
            occ1(x1,y1) = 255;
        }
    }
    
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movsd %xmm0, 0x20(%rsp)
movq %rdi, %r15
movl (%rdi), %r12d
movl 0x4(%rdi), %r13d
movl (%rsi), %r14d
movq %rsi, 0x18(%rsp)
movl 0x4(%rsi), %ebp
movq %rdx, %rdi
movl %r12d, %esi
movl %r13d, %edx
callq 0x65e8
movl %r13d, 0xc(%rsp)
testl %r13d, %r13d
jle 0x65d9
xorps %xmm0, %xmm0
cvtsi2sd %r14d, %xmm0
movsd 0x52d5(%rip), %xmm2     # 0xb7a0
addsd %xmm2, %xmm0
movsd %xmm0, 0x30(%rsp)
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
addsd %xmm2, %xmm0
movsd %xmm0, 0x28(%rsp)
xorl %r13d, %r13d
xorpd %xmm1, %xmm1
movsd 0x4b13(%rip), %xmm4     # 0xb008
testl %r12d, %r12d
jle 0x65c7
xorpd %xmm3, %xmm3
movslq %r13d, %rbp
xorl %r14d, %r14d
movsd %xmm1, 0x10(%rsp)
movq 0x8(%r15), %rax
movslq (%r15), %rcx
imulq %rbp, %rcx
addq %r14, %rcx
movsd (%rax,%rcx,8), %xmm0
addsd %xmm3, %xmm0
ucomisd %xmm0, %xmm2
ja 0x658b
ucomisd 0x30(%rsp), %xmm0
ja 0x658b
ucomisd 0x28(%rsp), %xmm1
ja 0x658b
movq 0x18(%rsp), %rdi
movsd %xmm3, 0x40(%rsp)
movsd %xmm0, 0x38(%rsp)
callq 0x6634
movsd 0x40(%rsp), %xmm3
addsd 0x38(%rsp), %xmm0
movapd %xmm3, %xmm1
subsd %xmm0, %xmm1
andpd 0x5243(%rip), %xmm1     # 0xb7b0
movl (%rbx), %ecx
imull %r13d, %ecx
addl %r14d, %ecx
ucomisd 0x20(%rsp), %xmm1
movq 0x8(%rbx), %rax
movslq %ecx, %rcx
jbe 0x659d
movb $0x0, (%rax,%rcx)
jmp 0x65a1
movslq (%rbx), %rax
imulq %rbp, %rax
addq 0x8(%rbx), %rax
movb $0x0, (%r14,%rax)
jmp 0x65b7
movb $-0x1, (%rax,%rcx)
movsd 0x51f7(%rip), %xmm2     # 0xb7a0
movsd 0x10(%rsp), %xmm1
movsd 0x4a51(%rip), %xmm4     # 0xb008
addsd %xmm4, %xmm3
incq %r14
cmpl %r14d, %r12d
jne 0x650e
addsd %xmm4, %xmm1
incl %r13d
cmpl 0xc(%rsp), %r13d
jne 0x64f5
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/devernay[P]vlpovutils/povread.cpp
// Function: vlpov_povread(char const*, VLPovCamera&)
int vlpov_povread(const char* file, VLPovCamera &cam)
{
    size_t file_len = strlen(file);
    char *info_file = new char[file_len+5];
    const char *info_suffix = ".txt";
    std::copy(file, file+file_len, info_file);
    std::copy(info_suffix, info_suffix+5, info_file+file_len);
    int retval = vlpov_get_cam(info_file, cam);
    delete [] info_file;
    return retval;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r12
callq 0x2080
movq %rax, %r15
leaq 0x5(%rax), %rdi
callq 0x2040
movq %rax, %r14
testq %r15, %r15
je 0x6745
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x2100
movb $0x0, 0x4(%r14,%r15)
movl $0x7478742e, (%r14,%r15) # imm = 0x7478742E
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6776
movl %eax, %ebx
movq %r14, %rdi
callq 0x21e0
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/devernay[P]vlpovutils/./vlpov.hpp
// Function: VLPovImage<double>::load(char const*)
int load(const char *filename) {
        if (_width <= 0 || _height <= 0) {
            return -1;
        }
        unsigned int siz = _width*_height;
        std::FILE *const nfile = std::fopen(filename,"rb");
        if (!nfile) {
            return -1;
        }
        std::fseek(nfile,0,SEEK_END);
        const long fsiz = (unsigned int)std::ftell(nfile)/sizeof(T);
        if (fsiz < siz) {
            std::fclose(nfile);
            return -1;
        }
        std::fseek(nfile,0,SEEK_SET);
        size_t nr = std::fread(_data,sizeof(T),siz,nfile);
        std::fclose(nfile);
        if (nr != siz) {
            return -1;
        }
        if (!endianness()) {
            invert_endianness();
        }
        return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl (%rdi), %r12d
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testl %r12d, %r12d
jle 0x7076
movq %rdi, %rbx
movl 0x4(%rdi), %r14d
testl %r14d, %r14d
jle 0x7076
leaq 0x4b3b(%rip), %rax      # 0xbae9
movq %rsi, %rdi
movq %rax, %rsi
callq 0x21c0
testq %rax, %rax
je 0x7076
movq %rax, %r15
imull %r12d, %r14d
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x2170
movq %r15, %rdi
callq 0x2030
shrl $0x3, %eax
cmpl %r14d, %eax
jae 0x6ff5
movq %r15, %rdi
callq 0x2150
jmp 0x7076
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2170
movq 0x8(%rbx), %rdi
movl $0x8, %esi
movq %r14, %rdx
movq %r15, %rcx
callq 0x2210
movq %rax, %r12
movq %r15, %rdi
callq 0x2150
cmpq %r14, %r12
jne 0x7076
movl 0x4(%rbx), %eax
imull (%rbx), %eax
testl %eax, %eax
je 0x7074
movq 0x8(%rbx), %rdx
movl %eax, %eax
leaq (%rdx,%rax,8), %rcx
leaq (%rdx,%rax,8), %rax
decq %rax
movq %rcx, %rdx
addq $-0x8, %rcx
movq $-0x8, %rsi
movq %rax, %rdi
movb (%rdx,%rsi), %r8b
movb (%rdi), %r9b
movb %r9b, (%rdx,%rsi)
movb %r8b, (%rdi)
incq %rsi
decq %rdi
cmpl $-0x4, %esi
jne 0x7051
addq $-0x8, %rax
cmpq 0x8(%rbx), %rcx
ja 0x7040
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/devernay[P]vlpovutils/./small.hpp
// Function: boost::numeric::ublas::diagonal(double, double, double)
inline matrix33
diagonal(double d0, double d1, double d2) {
    matrix33 D;
    D(0,0) =  d0; D(0,1) = 0.0; D(0,2) = 0.0;
    D(1,0) = 0.0; D(1,1) =  d1; D(1,2) = 0.0;
    D(2,0) = 0.0; D(2,1) = 0.0; D(2,2) =  d2;

    return D;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movsd %xmm2, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
movl $0x3, %eax
movq %rax, (%rdi)
movq %rax, 0x8(%rdi)
leaq 0x10(%rdi), %r14
movq $0x9, 0x10(%rdi)
xorl %r15d, %r15d
movl $0x3, %esi
movl $0x3, %ecx
xorl %edi, %edi
xorl %edx, %edx
callq 0x5792
movq %r14, %rdi
movq %rax, %rsi
callq 0x75be
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
movq (%rbx), %rsi
movq 0x8(%rbx), %rcx
movl $0x1, %edx
xorl %edi, %edi
callq 0x5792
movq %r14, %rdi
movq %rax, %rsi
callq 0x75be
movq %r15, (%rax)
movq (%rbx), %rsi
movq 0x8(%rbx), %rcx
movl $0x2, %edx
xorl %edi, %edi
callq 0x5792
movq %r14, %rdi
movq %rax, %rsi
callq 0x75be
movq %r15, (%rax)
movq (%rbx), %rsi
movq 0x8(%rbx), %rcx
movl $0x1, %edi
xorl %edx, %edx
callq 0x5792
movq %r14, %rdi
movq %rax, %rsi
callq 0x75be
movq %r15, (%rax)
movq (%rbx), %rsi
movq 0x8(%rbx), %rcx
movl $0x1, %edi
movl $0x1, %edx
callq 0x5792
movq %r14, %rdi
movq %rax, %rsi
callq 0x75be
movsd 0x10(%rsp), %xmm0
movsd %xmm0, (%rax)
movq (%rbx), %rsi
movq 0x8(%rbx), %rcx
movl $0x1, %edi
movl $0x2, %edx
callq 0x5792
movq %r14, %rdi
movq %rax, %rsi
callq 0x75be
movq %r15, (%rax)
movq (%rbx), %rsi
movq 0x8(%rbx), %rcx
movl $0x2, %edi
xorl %edx, %edx
callq 0x5792
movq %r14, %rdi
movq %rax, %rsi
callq 0x75be
movq %r15, (%rax)
movq (%rbx), %rsi
movq 0x8(%rbx), %rcx
movl $0x2, %edi
movl $0x1, %edx
callq 0x5792
movq %r14, %rdi
movq %rax, %rsi
callq 0x75be
movq %r15, (%rax)
movq (%rbx), %rsi
movq 0x8(%rbx), %rcx
movl $0x2, %edi
movl $0x2, %edx
callq 0x5792
movq %r14, %rdi
movq %rax, %rsi
callq 0x75be
movsd 0x18(%rsp), %xmm0
movsd %xmm0, (%rax)
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/sehe[P]spirit-v2-json/test.cpp
// Function: main
int main(int argc, char** argv) {
    
    if (argc < 2)
        return -1;
    
    std::ifstream inputfile(argv[1]);
    std::string to_parse;
    int count;

    inputfile.seekg(0, std::ios::end);   
    to_parse.reserve(inputfile.tellg());
    inputfile.seekg(0, std::ios::beg);

    to_parse.assign((std::istreambuf_iterator<char>(inputfile)),
                     std::istreambuf_iterator<char>());
    
    steady_clock::time_point start_time = steady_clock::now();
    for (unsigned i = 0; i < ntimes; ++i) {
        JSON::Value parsed = JSON::parse(to_parse);
    }
    steady_clock::time_point end_time = steady_clock::now();
    microseconds us = duration_cast<microseconds>(end_time - start_time);
    std::cout << "[+] Finished successfully with an average of: " << (us.count() / ntimes) << " us\n";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x270, %rsp            # imm = 0x270
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x2, %edi
jl 0x4a5c
movq 0x8(%rsi), %rsi
leaq 0x68(%rsp), %rbx
movl $0x8, %edx
movq %rbx, %rdi
callq 0x4440
leaq 0x20(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
movl $0x2, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x42f0
leaq 0x68(%rsp), %rdi
callq 0x4400
leaq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x4360
leaq 0x68(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x42f0
movq 0x68(%rsp), %rax
leaq 0x10(%rsp), %rdi
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
movq -0x18(%rax), %rax
movq $0x0, 0x30(%rsp)
movl $0xffffffff, 0x38(%rsp) # imm = 0xFFFFFFFF
addq %rsi, %rdx
movq 0x150(%rsp,%rax), %rcx
vmovups 0x30(%rsp), %xmm0
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
vmovups %xmm0, (%rsp)
callq 0x4aa2
movl $0xa, %ebp
callq 0x42d0
leaq 0x30(%rsp), %r14
leaq 0x10(%rsp), %r15
movq %rax, %rbx
movq %r14, %rdi
movq %r15, %rsi
callq 0x5703
movq %r14, %rdi
callq 0x4eaa
decl %ebp
jne 0x49c9
callq 0x42d0
movq %rax, %r14
movq 0x405e1(%rip), %rdi     # 0x44fd0
leaq 0x1e65e(%rip), %rsi     # 0x23054
movl $0x2e, %edx
callq 0x4290
subq %rbx, %r14
movabsq $0x346dc5d63886594b, %rcx # imm = 0x346DC5D63886594B
movq %r14, %rax
imulq %rcx
movq %rdx, %rsi
sarq $0xb, %rdx
shrq $0x3f, %rsi
addq %rdx, %rsi
movq 0x405a8(%rip), %rdi     # 0x44fd0
callq 0x4220
leaq 0x1e64f(%rip), %rsi     # 0x23083
movl $0x4, %edx
movq %rax, %rdi
callq 0x4290
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x4a50
callq 0x4210
leaq 0x68(%rsp), %rdi
callq 0x4060
xorl %eax, %eax
addq $0x270, %rsp            # imm = 0x270
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4a72
jmp 0x4a72
jmp 0x4a72
movq 0x10(%rsp), %rdi
movq %rax, %rbx
cmpq %r12, %rdi
je 0x4a84
callq 0x4210
leaq 0x68(%rsp), %rdi
callq 0x4060
movq %rbx, %rdi
callq 0x4410
// File: /workspace/github_cpp_makefile_star2_O3/sehe[P]spirit-v2-json/json.cpp
// Function: JSON::Object::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Value& Object::operator[](std::string const& key)
    {
        auto match = std::find_if(begin(values), end(values), [&key](Entry const& e) { return key == e.first; });
        if (match != end(values))
            return match->second;

        values.push_back({ key, Undefined{} });
        return values.back().second;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq 0x8(%rdi), %rbp
movq (%rdi), %r12
movabsq $-0x3333333333333333, %rcx # imm = 0xCCCCCCCCCCCCCCCD
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
movq %rbp, %rax
subq %r12, %rax
movq %rax, %rbx
sarq $0x4, %rbx
imulq %rcx, %rbx
sarq $0x2, %rbx
testq %rbx, %rbx
jle 0x51a6
leaq (%rbx,%rbx,4), %r15
incq %rbx
shlq $0x6, %r15
addq %r12, %r15
movq %r14, %rdi
movq %r12, %rsi
callq 0x5868
testb %al, %al
jne 0x51ff
leaq 0x50(%r12), %r13
movq %r14, %rdi
movq %r13, %rsi
callq 0x5868
testb %al, %al
jne 0x5202
leaq 0xa0(%r12), %r13
movq %r14, %rdi
movq %r13, %rsi
callq 0x5868
testb %al, %al
jne 0x5202
leaq 0xf0(%r12), %r13
movq %r14, %rdi
movq %r13, %rsi
callq 0x5868
testb %al, %al
jne 0x5202
addq $0x140, %r12            # imm = 0x140
decq %rbx
cmpq $0x1, %rbx
jg 0x5127
movq %rbp, %rax
subq %r15, %rax
movabsq $-0x3333333333333333, %rcx # imm = 0xCCCCCCCCCCCCCCCD
jmp 0x51a9
movq %r12, %r15
sarq $0x4, %rax
imulq %rcx, %rax
cmpq $0x1, %rax
je 0x51e9
cmpq $0x2, %rax
je 0x51d6
cmpq $0x3, %rax
jne 0x5207
movq %r14, %rdi
movq %r15, %rsi
callq 0x5868
testb %al, %al
jne 0x51fa
addq $0x50, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x5868
testb %al, %al
jne 0x51fa
addq $0x50, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x5868
testb %al, %al
cmoveq %rbp, %r15
movq %r15, %r13
jmp 0x5202
movq %r12, %r13
cmpq %rbp, %r13
jne 0x5262
leaq 0x20(%rsp), %rbx
movq %rbx, -0x10(%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
addq %rsi, %rdx
callq 0x8c12
movl $0x0, 0x20(%r14)
movq 0x8(%rsp), %r15
movq %r14, %rsi
movq %r15, %rdi
callq 0x8efe
leaq 0x30(%rsp), %r14
movq %r14, %rdi
callq 0x4eaa
movq -0x20(%r14), %rdi
cmpq %rbx, %rdi
je 0x525a
callq 0x4210
movq 0x8(%r15), %r13
addq $-0x50, %r13
addq $0x20, %r13
movq %r13, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x10(%rsp), %rdi
movq %rax, %rbx
callq 0x65e8
movq %rbx, %rdi
callq 0x4410
nop
// File: /workspace/github_cpp_makefile_star2_O3/sehe[P]spirit-v2-json/json.cpp
// Function: JSON::to_string(boost::variant<JSON::Literal<JSON::tag_undefined>, JSON::Literal<JSON::tag_null>, JSON::Bool, boost::recursive_wrapper<JSON::Object>, boost::recursive_wrapper<JSON::Array>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, long, long double> const&)
std::string to_string(Value const& json) {
        std::string text;
        auto out = std::back_inserter(text);

        static const generator<decltype(out)> g;
        karma::generate(out, g, json);

        return text;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
leaq 0x10(%rdi), %r15
movq %rdi, 0x8(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movb 0x40069(%rip), %al      # 0x455a8
testb %al, %al
je 0x55ac
movq 0x3fd66(%rip), %rdi     # 0x452b0
vxorps %xmm0, %xmm0, %xmm0
movl $0x1, %eax
movq $0x0, 0x20(%rsp)
vmovaps %xmm0, 0x10(%rsp)
movq %rax, 0x28(%rsp)
movq %rax, 0x30(%rsp)
leaq 0x8(%rsp), %rax
movb $0x1, 0x38(%rsp)
movq %rax, 0x40(%rsp)
cmpq $0x0, 0x28(%rdi)
je 0x559f
leaq 0x48(%rsp), %rdx
addq $0x28, %rdi
movq %r14, (%rdx)
leaq 0x1ded3(%rip), %rcx     # 0x23468
leaq 0x10(%rsp), %rsi
callq 0xdb46
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x3fff5(%rip), %rdi     # 0x455a8
callq 0x4430
testl %eax, %eax
je 0x5543
leaq 0x3fced(%rip), %rdi     # 0x452b0
callq 0x660a
leaq 0x1ed7(%rip), %rdi      # 0x74a6
leaq 0x3fcda(%rip), %rsi     # 0x452b0
leaq 0x3fc63(%rip), %rdx     # 0x45240
callq 0x4200
leaq 0x3ffbf(%rip), %rdi     # 0x455a8
callq 0x4140
jmp 0x5543
leaq 0x3ffae(%rip), %rdi     # 0x455a8
movq %rax, %r14
callq 0x4130
jmp 0x5607
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x5614
callq 0x4210
movq %r14, %rdi
callq 0x4410
// File: /workspace/github_cpp_makefile_star2_O3/sehe[P]spirit-v2-json/json.cpp
// Function: JSON::operator<<(std::ostream&, boost::variant<JSON::Literal<JSON::tag_undefined>, JSON::Literal<JSON::tag_null>, JSON::Bool, boost::recursive_wrapper<JSON::Object>, boost::recursive_wrapper<JSON::Array>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, long, long double> const&)
std::ostream& operator<<(std::ostream& os, Value const& v)
    {
        boost::spirit::ostream_iterator out(os);

        static const generator<decltype(out)> g;
        karma::generate(out, g, v);

        return os;
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, (%rsp)
movq $0x0, 0x8(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
movb 0x4026c(%rip), %al      # 0x458a8
testb %al, %al
je 0x56a5
movq 0x3ff69(%rip), %rdi     # 0x455b0
vxorps %xmm0, %xmm0, %xmm0
movl $0x1, %eax
movq $0x0, 0x20(%rsp)
vmovaps %xmm0, 0x10(%rsp)
movq %rax, 0x28(%rsp)
movq %rax, 0x30(%rsp)
movb $0x1, 0x38(%rsp)
movq %rsp, %rax
movq %rax, 0x40(%rsp)
cmpq $0x0, 0x28(%rdi)
je 0x569a
leaq 0x50(%rsp), %rdx
addq $0x28, %rdi
leaq 0x1dddb(%rip), %rcx     # 0x23468
leaq 0x10(%rsp), %rsi
movq %r14, (%rdx)
callq 0x11efe
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
leaq 0x401fc(%rip), %rdi     # 0x458a8
callq 0x4430
testl %eax, %eax
je 0x5640
leaq 0x3fef4(%rip), %rdi     # 0x455b0
callq 0x761c
leaq 0x2df0(%rip), %rdi      # 0x84b8
leaq 0x3fee1(%rip), %rsi     # 0x455b0
leaq 0x3fb6a(%rip), %rdx     # 0x45240
callq 0x4200
leaq 0x401c6(%rip), %rdi     # 0x458a8
callq 0x4140
jmp 0x5640
leaq 0x401b5(%rip), %rdi     # 0x458a8
movq %rax, %rbx
callq 0x4130
movq %rbx, %rdi
callq 0x4410
// File: /workspace/github_cpp_makefile_star2_O3/sehe[P]spirit-v2-json/json.cpp
// Function: JSON::parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Value parse(std::string const& input) {
        auto f(begin(input)), saved = f, l(end(input));

        Value parsed;
        if (!tryParseJson(f, l, parsed))
        {
            std::cerr << "whoops at position #" << std::distance(saved, f) << "\n";
        }

        return parsed;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rsi), %r14
movq %rdi, %rbx
movq %rsp, %rdi
movq %r14, (%rdi)
movq 0x8(%rsi), %rsi
movl $0x0, (%rbx)
addq %r14, %rsi
movq %rbx, %rdx
callq 0x862d
testb %al, %al
jne 0x576b
movq 0x3f8bd(%rip), %rdi     # 0x44ff0
leaq 0x2b076(%rip), %rsi     # 0x307b0
movl $0x14, %edx
callq 0x4290
movq (%rsp), %rsi
subq %r14, %rsi
movq 0x3f89e(%rip), %rdi     # 0x44ff0
callq 0x4220
leaq 0x2be82(%rip), %rsi     # 0x315e0
movl $0x1, %edx
movq %rax, %rdi
callq 0x4290
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
movq %rax, %r14
callq 0x4eaa
movq %r14, %rdi
callq 0x4410
// File: /workspace/github_cpp_makefile_star2_O3/sehe[P]spirit-v2-json/json.cpp
// Function: JSON::readFrom[abi:cxx11](std::istream&)
Value readFrom(std::istream& is)
    {
        is.unsetf(std::ios::skipws);
        boost::spirit::istream_iterator it(is), pte;

        Value parsed;
        if (!tryParseJson(it, pte, parsed))
        {
            std::cerr << "whoops"; // TODO
        }

        return parsed;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq (%rsi), %rax
leaq 0x38(%rsp), %r14
movq %rdi, %rbx
movq %r14, %rdi
movq -0x18(%rax), %rax
andl $0xffffefff, 0x18(%rsi,%rax) # imm = 0xFFFFEFFF
callq 0x1b198
vxorps %xmm0, %xmm0, %xmm0
leaq 0x20(%rsp), %rsi
xorl %eax, %eax
movq %rax, 0x10(%rsp)
movl $0x0, (%rbx)
vmovaps %xmm0, (%rsp)
movq %rax, 0x10(%rsi)
vmovaps %xmm0, (%rsi)
movq %r14, %rdi
movq %rbx, %rdx
callq 0x88b1
leaq 0x20(%rsp), %rdi
movl %eax, %ebp
callq 0x1d414
testb %bpl, %bpl
jne 0x5807
movq 0x3f7fa(%rip), %rdi     # 0x44ff0
leaq 0x2afc8(%rip), %rsi     # 0x307c5
movl $0x6, %edx
callq 0x4290
movq %rsp, %rdi
callq 0x1d414
leaq 0x38(%rsp), %rdi
callq 0x1d414
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
jmp 0x5837
leaq 0x20(%rsp), %rdi
movq %rax, %r14
callq 0x1d414
movq %rbx, %rdi
callq 0x4eaa
movq %rsp, %rdi
callq 0x1d414
leaq 0x38(%rsp), %rdi
callq 0x1d414
movq %r14, %rdi
callq 0x4410
// File: /workspace/github_cpp_makefile_star2_O3/stoianmihail[P]XY-sorting/algorithm.cpp
// Function: applyFrequencies(std::unordered_map<unsigned long, std::pair<unsigned long, bool>, std::hash<unsigned long>, std::equal_to<unsigned long>, std::allocator<std::pair<unsigned long const, std::pair<unsigned long, bool>>>>&, std::vector<std::pair<unsigned long, unsigned long>, std::allocator<std::pair<unsigned long, unsigned long>>>&)
void applyFrequencies(std::unordered_map<uint64_t, hash_coord>& freqHashTable, std::vector<cdf_coord>& cdf)
// Update cdf with the frequencies from the hash table
{
    uint64_t partialSum = 0;
    for (unsigned index = 0, limit = cdf.size(); index < limit; ++index) {
        uint64_t currSum = freqHashTable[cdf[index].first].first;
        partialSum += currSum;
        cdf[index].second = partialSum;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq (%rsi), %rsi
movq 0x8(%rbx), %rax
subq %rsi, %rax
shrq $0x4, %rax
testl %eax, %eax
je 0x3525
movq %rdi, %r14
movl %eax, %r15d
xorl %r12d, %r12d
xorl %r13d, %r13d
addq %r12, %rsi
movq %r14, %rdi
callq 0x56d2
addq (%rax), %r13
movq (%rbx), %rsi
movq %r13, 0x8(%rsi,%r12)
addq $0x10, %r12
decq %r15
jne 0x3506
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/stoianmihail[P]XY-sorting/algorithm.cpp
// Function: computeFreqHashTable(std::vector<unsigned long, std::allocator<unsigned long>>&, std::vector<unsigned long, std::allocator<unsigned long>>&)
std::unordered_map<uint64_t, hash_coord> computeFreqHashTable(std::vector<uint64_t>& xs, std::vector<uint64_t>& ys) 
// Return the hash table with the frequencies of the resulted sums
// This is used by all algorithms
{
    // Hash with the frequencies of each sum
    assert(xs.size() == ys.size());
    std::unordered_map<uint64_t, hash_coord> count_;
    for (unsigned index = 0; index < xs.size(); ++index) {
        for (unsigned ptr = 0; ptr < ys.size(); ++ptr) {
            // TODO: assuming that the value is still a 32-bit unsigned value
            // This serves only to the theoretical part of the algorithm
            uint64_t sum = xs[index] + ys[ptr];
            ++count_[sum].first;
        }
    }
    return count_;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %rdx
movq 0x8(%rsi), %rsi
movq %rsi, %rdi
subq %rdx, %rdi
movq (%r14), %rax
movq 0x8(%r14), %rcx
movq %rcx, %r8
subq %rax, %r8
cmpq %r8, %rdi
jne 0x3605
leaq 0x30(%rbx), %rdi
movq %rdi, (%rbx)
movq $0x1, 0x8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movl $0x3f800000, 0x20(%rbx) # imm = 0x3F800000
movups %xmm0, 0x28(%rbx)
cmpq %rdx, %rsi
je 0x35f3
xorl %r13d, %r13d
movq %rsp, %r12
cmpq %rax, %rcx
je 0x35de
movl $0x1, %ebp
xorl %edx, %edx
movq (%r15), %rcx
movq (%rax,%rdx,8), %rax
addq (%rcx,%r13,8), %rax
movq %rax, (%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x56d2
incq (%rax)
movl %ebp, %edx
movq (%r14), %rax
movq 0x8(%r14), %rcx
movq %rcx, %rsi
subq %rax, %rsi
sarq $0x3, %rsi
incl %ebp
cmpq %rdx, %rsi
ja 0x359e
movq (%r15), %rdx
movq 0x8(%r15), %rsi
jmp 0x35e1
movq %rax, %rcx
incl %r13d
movq %rsi, %rdi
subq %rdx, %rdi
sarq $0x3, %rdi
cmpq %r13, %rdi
ja 0x3592
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3a9c(%rip), %rdi      # 0x70a8
leaq 0x3aac(%rip), %rsi      # 0x70bf
leaq 0x3ab3(%rip), %rcx      # 0x70cd
movl $0x43, %edx
callq 0x30e0
movq %rax, %r14
movq %rbx, %rdi
callq 0x4e52
movq %r14, %rdi
callq 0x32d0
// File: /workspace/github_cpp_makefile_star2_O3/stoianmihail[P]XY-sorting/algorithm.cpp
// Function: preprocessing_sorting(std::unordered_map<unsigned long, std::pair<unsigned long, bool>, std::hash<unsigned long>, std::equal_to<unsigned long>, std::allocator<std::pair<unsigned long const, std::pair<unsigned long, bool>>>>&, std::vector<unsigned long, std::allocator<unsigned long>>&, std::vector<unsigned long, std::allocator<unsigned long>>&)
std::vector<cdf_coord> preprocessing_sorting(std::unordered_map<uint64_t, hash_coord>& count_, std::vector<uint64_t>& xs, std::vector<uint64_t>& ys)
// Solve the task with sorting
{
    std::vector<cdf_coord> final_(count_.size());
    unsigned index = 0;
    for (auto elem: count_)
        final_[index++] = std::make_pair(elem.first, 0);
    return final_;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rsi), %rsi
leaq 0x7(%rsp), %rdx
callq 0x4d46
movq 0x10(%r14), %rax
testq %rax, %rax
je 0x367e
movq (%rbx), %rcx
xorl %edx, %edx
movq 0x8(%rax), %rsi
movl %edx, %edi
incl %edx
shlq $0x4, %rdi
movq %rsi, (%rcx,%rdi)
movq $0x0, 0x8(%rcx,%rdi)
movq (%rax), %rax
testq %rax, %rax
jne 0x365d
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/stoianmihail[P]XY-sorting/algorithm.cpp
// Function: solveWithSorting(std::vector<std::pair<unsigned long, unsigned long>, std::allocator<std::pair<unsigned long, unsigned long>>>&)
void solveWithSorting(std::vector<cdf_coord>& cdf)
{
    auto start = high_resolution_clock::now();
    std::sort(cdf.begin(), cdf.end(), [](auto left, auto right) {
       return left.first < right.first; 
    });
    auto stop = high_resolution_clock::now();
    std::cout << "Solving with Sorting took: " << duration_cast<milliseconds>(stop - start).count() << " ms" << std::endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x3040
movq %rax, %rbx
movq (%r14), %r15
movq 0x8(%r14), %r14
cmpq %r14, %r15
je 0x374a
movq %r14, %r12
subq %r15, %r12
movq %r12, %rax
sarq $0x4, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x49eb
cmpq $0x101, %r12            # imm = 0x101
jl 0x373f
leaq 0x100(%r15), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x4ca8
cmpq %r14, %r12
je 0x374a
addq $0x108, %r15            # imm = 0x108
movups (%r12), %xmm0
movq -0x10(%r12), %rcx
movq (%r12), %rax
movq %r12, %rdx
cmpq %rax, %rcx
jbe 0x372d
movq %r15, %rdx
movq %rcx, -0x8(%rdx)
movq -0x28(%rdx), %rcx
movq -0x10(%rdx), %rsi
movq %rsi, (%rdx)
addq $-0x10, %rdx
cmpq %rax, %rcx
ja 0x3711
addq $-0x8, %rdx
movups %xmm0, (%rdx)
addq $0x10, %r12
addq $0x10, %r15
cmpq %r14, %r12
jne 0x36f8
jmp 0x374a
movq %r15, %rdi
movq %r14, %rsi
callq 0x4ca8
callq 0x3040
movq %rax, %r14
movq 0x685f(%rip), %r15      # 0x9fb8
leaq 0x39dd(%rip), %rsi      # 0x713d
movl $0x1b, %edx
movq %r15, %rdi
callq 0x31e0
subq %rbx, %r14
movabsq $0x431bde82d7b634db, %rcx # imm = 0x431BDE82D7B634DB
movq %r14, %rax
imulq %rcx
movq %rdx, %rsi
shrq $0x3f, %rsi
sarq $0x12, %rdx
addq %rdx, %rsi
movq %r15, %rdi
callq 0x3190
movq %rax, %rbx
leaq 0x39b9(%rip), %rsi      # 0x7159
movl $0x3, %edx
movq %rax, %rdi
callq 0x31e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3110
// File: /workspace/github_cpp_makefile_star2_O3/stoianmihail[P]XY-sorting/algorithm.cpp
// Function: collectChain(unsigned long)
std::vector<uint64_t> collectChain(uint64_t index) 
// Collect the chain into a vector
{
    std::vector<uint64_t> ret;
    for (uint32_t ptr = adj[index]; ptr; ptr = list[ptr].next)
        ret.push_back(list[ptr].sum);
    return ret;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x6996(%rip), %rax      # 0xa1b8
movl (%rax,%rsi,8), %r14d
testq %r14, %r14
je 0x386d
movq 0x699e(%rip), %rax      # 0xa1d0
shlq $0x4, %r14
leaq (%rax,%r14), %rdx
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x3854
movq (%rdx), %rcx
movq %rcx, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x3863
movq %rbx, %rdi
callq 0x59a2
movq 0x696d(%rip), %rax      # 0xa1d0
movl 0x8(%rax,%r14), %r14d
testq %r14, %r14
jne 0x3832
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x388f
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x31d0
movq %r14, %rdi
callq 0x32d0
// File: /workspace/github_cpp_makefile_star2_O3/stoianmihail[P]XY-sorting/algorithm.cpp
// Function: generator(unsigned long)
static std::vector<uint64_t> generator(uint64_t maxValue)
// generates a sorted array of MAX_N unsigned ints without duplicates
{
    std::vector<uint64_t> numbers;
    std::generate_n(std::back_inserter(numbers), 10000, randomNumberBetween(1, maxValue));
    std::sort(std::begin(numbers), std::end(numbers));
    return numbers;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x2740, %rsp           # imm = 0x2740
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq $0x1, 0x10(%rsp)
movq %rsi, 0x18(%rsp)
leaq 0x13a8(%rsp), %rdi
callq 0x5268
leaq 0x13a8(%rsp), %rdi
callq 0x3210
movl %eax, %ecx
movq %rcx, 0x20(%rsp)
movl $0x3, %eax
movq %rcx, %rdx
shrq $0x1e, %rdx
xorl %ecx, %edx
imull $0x6c078965, %edx, %ecx # imm = 0x6C078965
addl %eax, %ecx
addl $-0x2, %ecx
movq %rcx, 0x10(%rsp,%rax,8)
incq %rax
cmpq $0x272, %rax            # imm = 0x272
jne 0x45fb
movq $0x270, 0x13a0(%rsp) # imm = 0x270
leaq 0x13a8(%rsp), %rdi
callq 0x3180
leaq 0x13a8(%rsp), %r14
leaq 0x10(%rsp), %rsi
movl $0x1398, %edx           # imm = 0x1398
movq %r14, %rdi
callq 0x3150
movl $0x2711, %ebp           # imm = 0x2711
leaq 0x13b8(%rsp), %r15
leaq 0x8(%rsp), %r12
movq %r14, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x4ecc
movq %rax, 0x8(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x468e
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x4699
movq %rbx, %rdi
movq %r12, %rdx
callq 0x512c
decl %ebp
cmpl $0x1, %ebp
ja 0x4664
movq (%rbx), %r14
movq 0x8(%rbx), %r15
cmpq %r15, %r14
je 0x46d9
movq %r15, %rax
subq %r14, %rax
sarq $0x3, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x5377
movq %r14, %rdi
movq %r15, %rsi
callq 0x5460
addq $0x2740, %rsp           # imm = 0x2740
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x46fd
movq %rax, %r14
leaq 0x13a8(%rsp), %rdi
callq 0x3180
jmp 0x470a
movq %rax, %rdi
callq 0x4ec1
jmp 0x4707
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x471e
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x31d0
movq %r14, %rdi
callq 0x32d0
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/test/bench/simpat/simpat_srv.c
// Function: main
int main(int argc, char *argv[])
{
  /* scdc.log_init("log_FILE", sys.stdout, sys.stderr)*/

  scdc_init(SCDC_INIT_DEFAULT);

  simpat_init();

  scdc_nodeport_t np = SCDC_NODEPORT_NULL;

  if (argc <= 1)
  {
    SIMPAT_TRACE("setup: none");

  } else if (strcmp(argv[1], "uds") == 0)
  {
    SIMPAT_TRACE("setup: UDS");

    const char *socketname = (argc <= 2)?"simpat":argv[2];

    np = scdc_nodeport_open("uds:socketname:max_connections", socketname, 2);

  } else if (strcmp(argv[1], "tcp") == 0)
  {
    SIMPAT_TRACE("setup: TCP");

    np = scdc_nodeport_open("tcp:max_connections", 2);

  } else if (strcmp(argv[1], "mpi") == 0)
  {
    SIMPAT_TRACE("setup: MPI");

    np = scdc_nodeport_open("mpi");

  } else SIMPAT_TRACE("unknown mode: %s", argv[1]);

  SIMPAT_TRACE("start");
  scdc_nodeport_start(np, SCDC_NODEPORT_START_ASYNC_UNTIL_CANCEL);

  printf("Press <ENTER> to quit!\n");
  getchar();

  SIMPAT_TRACE("stop");
  scdc_nodeport_stop(np);

  SIMPAT_TRACE("release");
  scdc_nodeport_close(np);

  simpat_release();

  scdc_release();

  /*scdc.log_release()*/

  return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x50101(%rip), %rdi     # 0x5c55d
xorl %eax, %eax
callq 0xc649
xorl %eax, %eax
callq 0xc604
cmpl $0x1, %ebp
jg 0xc48e
leaq 0x4eb8e(%rip), %rdi     # 0x5b004
xorl %ebx, %ebx
xorl %eax, %eax
callq 0xb080
movl $0xa, %edi
callq 0xb740
jmp 0xc579
movq 0x8(%rbx), %r14
leaq 0x505e7(%rip), %rsi     # 0x5ca80
movq %r14, %rdi
callq 0xb750
testl %eax, %eax
je 0xc4e4
leaq 0x505cb(%rip), %rsi     # 0x5ca77
movq %r14, %rdi
callq 0xb750
testl %eax, %eax
je 0xc50a
leaq 0x4ebda(%rip), %rsi     # 0x5b099
movq %r14, %rdi
callq 0xb750
testl %eax, %eax
je 0xc550
leaq 0x4ebe5(%rip), %rdi     # 0x5b0bb
xorl %ebx, %ebx
movq %r14, %rsi
xorl %eax, %eax
callq 0xb080
jmp 0xc47f
leaq 0x4eb38(%rip), %rdi     # 0x5b023
xorl %eax, %eax
callq 0xb080
movl $0xa, %edi
callq 0xb740
cmpl $0x2, %ebp
jne 0xc537
leaq 0x4eb39(%rip), %rsi     # 0x5b041
jmp 0xc53b
leaq 0x4eb56(%rip), %rdi     # 0x5b067
xorl %eax, %eax
callq 0xb080
movl $0xa, %edi
callq 0xb740
leaq 0x4eb5c(%rip), %rdi     # 0x5b085
movl $0x2, %esi
xorl %eax, %eax
callq 0xcc0b
jmp 0xc576
movq 0x10(%rbx), %rsi
leaq 0x4eb06(%rip), %rdi     # 0x5b048
movl $0x2, %edx
xorl %eax, %eax
callq 0xcc0b
jmp 0xc576
leaq 0x4eb46(%rip), %rdi     # 0x5b09d
xorl %eax, %eax
callq 0xb080
movl $0xa, %edi
callq 0xb740
leaq 0x4eb2a(%rip), %rdi     # 0x5b099
xorl %eax, %eax
callq 0xcc0b
movq %rax, %rbx
leaq 0x4eb5f(%rip), %rdi     # 0x5b0df
xorl %eax, %eax
callq 0xb080
movl $0xa, %edi
callq 0xb740
movl $0x4, %esi
movq %rbx, %rdi
callq 0xcd1f
leaq 0x4eb86(%rip), %rdi     # 0x5b12b
callq 0xb840
callq 0xb730
leaq 0x4eb42(%rip), %rdi     # 0x5b0f8
xorl %eax, %eax
callq 0xb080
movl $0xa, %edi
callq 0xb740
movq %rbx, %rdi
callq 0xcd50
leaq 0x4eb3a(%rip), %rdi     # 0x5b110
xorl %eax, %eax
callq 0xb080
movl $0xa, %edi
callq 0xb740
movq %rbx, %rdi
callq 0xccfd
xorl %eax, %eax
callq 0xc623
callq 0xc74a
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mortennobel[P]glMatrix-vs-GLM-Benchmark/Timer.cpp
// Function: Timer::getElapsedTimeInMicroSec()
double Timer::getElapsedTimeInMicroSec()
{
#ifdef WIN32
    if(!stopped)
        QueryPerformanceCounter(&endCount);

    startTimeInMicroSec = startCount.QuadPart * (1000000.0 / frequency.QuadPart);
    endTimeInMicroSec = endCount.QuadPart * (1000000.0 / frequency.QuadPart);
#else
    if(!stopped)
        gettimeofday(&endCount, NULL);

    startTimeInMicroSec = (startCount.tv_sec * 1000000.0) + startCount.tv_usec;
    endTimeInMicroSec = (endCount.tv_sec * 1000000.0) + endCount.tv_usec;
#endif

    return endTimeInMicroSec - startTimeInMicroSec;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x10(%rdi)
jne 0x130d
leaq 0x28(%rbx), %rdi
xorl %esi, %esi
callq 0x1120
cvtsi2sdq 0x18(%rbx), %xmm1
cvtsi2sdq 0x20(%rbx), %xmm0
movsd 0x2ce7(%rip), %xmm2     # 0x4008
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rbx)
xorps %xmm0, %xmm0
cvtsi2sdq 0x28(%rbx), %xmm0
cvtsi2sdq 0x30(%rbx), %xmm3
mulsd %xmm2, %xmm0
addsd %xmm3, %xmm0
movsd %xmm0, 0x8(%rbx)
subsd %xmm1, %xmm0
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mortennobel[P]glMatrix-vs-GLM-Benchmark/main.cpp
// Function: createRandomMatrix()
m4 createRandomMatrix(){
    return m4(
                     rnd(100),rnd(100),rnd(100),rnd(100),
                     rnd(100),rnd(100),rnd(100),rnd(100),
                     rnd(100),rnd(100),rnd(100),rnd(100),
                     rnd(100),rnd(100),rnd(100),rnd(100)
                     );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0x1040
movl %eax, 0x18(%rsp)
callq 0x1040
movl %eax, %r14d
callq 0x1040
movl %eax, %r13d
callq 0x1040
movl %eax, %r12d
callq 0x1040
movl %eax, 0x24(%rsp)
callq 0x1040
movl %eax, 0x14(%rsp)
callq 0x1040
movl %eax, 0x8(%rsp)
callq 0x1040
movl %eax, %ebp
callq 0x1040
movl %eax, 0x20(%rsp)
callq 0x1040
movl %eax, 0x10(%rsp)
callq 0x1040
movl %eax, 0x4(%rsp)
callq 0x1040
movl %eax, %r15d
callq 0x1040
movl %eax, 0x1c(%rsp)
callq 0x1040
movl %eax, 0xc(%rsp)
callq 0x1040
movl %eax, (%rsp)
callq 0x1040
movd 0x18(%rsp), %xmm0
movd %r14d, %xmm1
movd %r13d, %xmm2
movd %r12d, %xmm3
movd 0x24(%rsp), %xmm4
movd 0x14(%rsp), %xmm5
movd 0x8(%rsp), %xmm6
movd %ebp, %xmm7
movd 0x20(%rsp), %xmm8
movd 0x10(%rsp), %xmm9
movd 0x4(%rsp), %xmm10
movd %r15d, %xmm11
movd 0x1c(%rsp), %xmm12
movd 0xc(%rsp), %xmm13
movd (%rsp), %xmm14
movd %eax, %xmm15
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
punpckldq %xmm3, %xmm2    # xmm2 = xmm2[0],xmm3[0],xmm2[1],xmm3[1]
punpcklqdq %xmm2, %xmm0    # xmm0 = xmm0[0],xmm2[0]
cvtdq2ps %xmm0, %xmm0
movaps 0x2087(%rip), %xmm1     # 0x4130
mulps %xmm1, %xmm0
movaps 0x208d(%rip), %xmm2     # 0x4140
mulps %xmm2, %xmm0
movups %xmm0, (%rbx)
punpckldq %xmm5, %xmm4    # xmm4 = xmm4[0],xmm5[0],xmm4[1],xmm5[1]
punpckldq %xmm7, %xmm6    # xmm6 = xmm6[0],xmm7[0],xmm6[1],xmm7[1]
punpcklqdq %xmm6, %xmm4    # xmm4 = xmm4[0],xmm6[0]
cvtdq2ps %xmm4, %xmm0
mulps %xmm1, %xmm0
mulps %xmm2, %xmm0
movups %xmm0, 0x10(%rbx)
punpckldq %xmm9, %xmm8    # xmm8 = xmm8[0],xmm9[0],xmm8[1],xmm9[1]
punpckldq %xmm11, %xmm10  # xmm10 = xmm10[0],xmm11[0],xmm10[1],xmm11[1]
punpcklqdq %xmm10, %xmm8   # xmm8 = xmm8[0],xmm10[0]
cvtdq2ps %xmm8, %xmm0
mulps %xmm1, %xmm0
mulps %xmm2, %xmm0
movups %xmm0, 0x20(%rbx)
punpckldq %xmm13, %xmm12  # xmm12 = xmm12[0],xmm13[0],xmm12[1],xmm13[1]
punpckldq %xmm15, %xmm14  # xmm14 = xmm14[0],xmm15[0],xmm14[1],xmm15[1]
punpcklqdq %xmm14, %xmm12  # xmm12 = xmm12[0],xmm14[0]
cvtdq2ps %xmm12, %xmm0
mulps %xmm1, %xmm0
mulps %xmm2, %xmm0
movups %xmm0, 0x30(%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/mortennobel[P]glMatrix-vs-GLM-Benchmark/main.cpp
// Function: testMultiplication(long)
double testMultiplication(long count){
    m4 m1 = createRandomMatrix();
    m4 m2 = createRandomMatrix();    
    t.start();
    for (int i = 0; i < count; i++) {
        m1 = m1 * m2;
    }
    t.stop();
    return t.getElapsedTimeInMilliSec();
}

// Assembly:
pushq %rbx
subq $0x80, %rsp
leaq 0x40(%rsp), %rdi
callq 0x1f9f
movq %rsp, %rdi
callq 0x1f9f
leaq 0x3fa1(%rip), %rbx      # 0x60e0
movq %rbx, %rdi
callq 0x12d4
movq %rbx, %rdi
callq 0x12e6
movq %rbx, %rdi
addq $0x80, %rsp
popq %rbx
jmp 0x1350
// File: /workspace/github_cpp_makefile_star2_O3/mortennobel[P]glMatrix-vs-GLM-Benchmark/main.cpp
// Function: testTranslation(long)
double testTranslation(long count){
    m4 m1 = createRandomMatrix();
    v3 v1 = v3(1, 2, 3);

    t.start();
    for (int i = 0; i < count; i++) {
        m1 = glm::translate(m1,v1);
    }
    t.stop();
    return t.getElapsedTimeInMilliSec();
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
movq %rsp, %rdi
callq 0x1f9f
leaq 0x3f6d(%rip), %rbx      # 0x60e0
movq %rbx, %rdi
callq 0x12d4
movq %rbx, %rdi
callq 0x12e6
movq %rbx, %rdi
addq $0x40, %rsp
popq %rbx
jmp 0x1350
// File: /workspace/github_cpp_makefile_star2_O3/mortennobel[P]glMatrix-vs-GLM-Benchmark/main.cpp
// Function: testScale(long)
double testScale(long count){
    m4 m1 = createRandomMatrix();
    v3 v1 = v3(1, 2, 3);
    
    t.start();
    for (int i = 0; i < count; i++) {
        m1 = glm::scale(m1,v1);
    }
    t.stop();
    return t.getElapsedTimeInMilliSec();
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
movq %rsp, %rdi
callq 0x1f9f
leaq 0x3f3c(%rip), %rbx      # 0x60e0
movq %rbx, %rdi
callq 0x12d4
movq %rbx, %rdi
callq 0x12e6
movq %rbx, %rdi
addq $0x40, %rsp
popq %rbx
jmp 0x1350
// File: /workspace/github_cpp_makefile_star2_O3/mortennobel[P]glMatrix-vs-GLM-Benchmark/main.cpp
// Function: testRotationArbitraryAxis(long)
double testRotationArbitraryAxis(long count){
    m4 m1 = createRandomMatrix();
    v3 v1 = v3(1, 2, 3);
    floatType a = (floatType)M_PI /2;
    t.start();
    for (int i = 0; i < count; i++) {
        m1 = glm::rotate(m1,a,v1);
    }
    t.stop();
    return t.getElapsedTimeInMilliSec();
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
movq %rsp, %rdi
callq 0x1f9f
leaq 0x3f0b(%rip), %rbx      # 0x60e0
movq %rbx, %rdi
callq 0x12d4
movq %rbx, %rdi
callq 0x12e6
movq %rbx, %rdi
addq $0x40, %rsp
popq %rbx
jmp 0x1350