LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: sgalkina[P]data_structures/src/tree_map.h
// Function: gtl::tree_map<int, int>::delete_min(gtl::tree_map<int, int>::Node*)
auto tree_map<K, V>::delete_min(Node * node) -> Node * {
  if (!node) return nullptr;
  if (!node->left) {
    Node * temp = node->right;
    node->right = nullptr;
    delete node;
    return temp;
  }
  if (!is_red(node->left) && (!node->left || !is_red(node->left->left))) node = move_red_left(node);
  node->left = delete_min(node->left);
  return fix_up(node);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0xae2e
movq $0x0, 0x30(%rsp)
jmp 0xaf0d
movq 0x20(%rsp), %rax
cmpq $0x0, 0x10(%rax)
jne 0xae88
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0xae79
movq 0x8(%rsp), %rdi
callq 0xacb0
movq 0x8(%rsp), %rdi
callq 0x20f0
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0xaf0d
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0xa7b0
testb $0x1, %al
jne 0xaeda
movq 0x20(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0xaec6
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rsi
callq 0xa7b0
testb $0x1, %al
jne 0xaeda
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xac20
movq %rax, 0x20(%rsp)
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0xae00
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x20(%rsp), %rsi
callq 0xa6d0
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: sgalkina[P]data_structures/src/test_map.h
// Function: long gtl::benchmark_operation<gtl::vector_map<int, int>, gtl::addition<gtl::vector_map<int, int>>>(gtl::vector_map<int, int>&)
clock_t benchmark_operation(T & map) {
  U op;
  size_t n_runs = 100;
  clock_t min_time = LONG_MAX;
  for (size_t i = 0; i < n_runs; ++i) {
    clock_t start_time = std::clock();
    op(map);
    clock_t end_time = std::clock();
    clock_t t = (end_time - start_time) % CLOCKS_PER_SEC;
    if (t < min_time) min_time = t;
  }
  return min_time;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq $0x64, 0x30(%rsp)
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
movq %rax, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x30(%rsp), %rax
jae 0xb25a
callq 0x20a0
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rsi
leaq 0x3f(%rsp), %rdi
callq 0xb640
callq 0x20a0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
subq 0x18(%rsp), %rax
movl $0xf4240, %ecx          # imm = 0xF4240
cqto
idivq %rcx
movq %rdx, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x28(%rsp), %rax
jge 0xb248
movq 0x8(%rsp), %rax
movq %rax, 0x28(%rsp)
jmp 0xb24a
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0xb1ea
movq 0x28(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: sgalkina[P]data_structures/src/test_map.h
// Function: gtl::mixed<gtl::vector_map<int, int>>::operator()(gtl::vector_map<int, int>&)
void operator() (T & map) {
    for (size_t i = 0; i < 10*n_operations; ++i) {
      map.lookup(rand() % max_number);
    }
    for (size_t i = 0; i < 3*n_operations; ++i) {
      int el = rand() % max_number;
      map.add(el, 0);
    }
    for (size_t i = 0; i < n_operations; ++i) {
      int el = rand() % max_number;
      map.remove(el);
    }
  }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
imulq $0xa, 0x79cc(%rip), %rcx # 0x13110
cmpq %rcx, %rax
jae 0xb788
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
callq 0x2050
movq (%rsp), %rdi
cltq
xorl %ecx, %ecx
movl %ecx, %edx
divq 0x79a0(%rip)            # 0x13108
movl %edx, %eax
movl %eax, 0x2c(%rsp)
leaq 0x2c(%rsp), %rsi
callq 0x68e0
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0xb737
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
imulq $0x3, 0x7972(%rip), %rcx # 0x13110
cmpq %rcx, %rax
jae 0xb7dc
callq 0x2050
cltq
xorl %ecx, %ecx
movl %ecx, %edx
divq 0x7953(%rip)            # 0x13108
movl %edx, %eax
movl %eax, 0x1c(%rsp)
movq 0x38(%rsp), %rdi
leaq 0x1c(%rsp), %rsi
xorl %edx, %edx
callq 0x6860
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0xb791
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x791f(%rip), %rax      # 0x13110
jae 0xb82a
callq 0x2050
cltq
xorl %ecx, %ecx
movl %ecx, %edx
divq 0x7903(%rip)            # 0x13108
movl %edx, %eax
movl %eax, 0xc(%rsp)
movq 0x38(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x6910
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0xb7e5
addq $0x48, %rsp
retq
nop
// File: sgalkina[P]data_structures/src/memcheck.cpp
// Function: memcheck::~memcheck()
memcheck::~memcheck()
  {
    assert(value_ != memcheck::DESTRUCTOR_VALUE && "Double free");
    assert(value_ == memcheck::CONSTRUCTOR_VALUE && "Not initialized memory");
    value_ = memcheck::DESTRUCTOR_VALUE;
    --counter;
  }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, 0x10(%rsp)
xorl %eax, %eax
cmpl $0xdeadbeef, (%rcx)     # imm = 0xDEADBEEF
movb %al, 0x1f(%rsp)
je 0xd1d9
movb $0x1, %al
movb %al, 0x1f(%rsp)
jmp 0xd1d9
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0xd1e3
jmp 0xd1e5
jmp 0xd204
leaq 0x2159(%rip), %rdi      # 0xf345
leaq 0x2188(%rip), %rsi      # 0xf37b
movl $0x11, %edx
leaq 0x218d(%rip), %rcx      # 0xf38c
callq 0x2080
movq 0x10(%rsp), %rcx
xorl %eax, %eax
cmpl $0xcafebabe, (%rcx)     # imm = 0xCAFEBABE
movb %al, 0xf(%rsp)
jne 0xd21f
movb $0x1, %al
movb %al, 0xf(%rsp)
jmp 0xd21f
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0xd229
jmp 0xd22b
jmp 0xd24a
leaq 0x2187(%rip), %rdi      # 0xf3b9
leaq 0x2142(%rip), %rsi      # 0xf37b
movl $0x12, %edx
leaq 0x2147(%rip), %rcx      # 0xf38c
callq 0x2080
movq 0x10(%rsp), %rax
movl $0xdeadbeef, (%rax)     # imm = 0xDEADBEEF
movq 0x5ed4(%rip), %rax      # 0x13130
addq $-0x1, %rax
movq %rax, 0x5ec9(%rip)      # 0x13130
addq $0x28, %rsp
retq
nopl (%rax)
// File: zyLiu6707[P]Arknights-Pull-Simulation/./utils.h
// Function: calc_time(timespec const&, timespec const&)
double calc_time(const struct timespec& start, const struct timespec& end) {
  double start_sec =
      (double)start.tv_sec * 1000000000.0 + (double)start.tv_nsec;
  double end_sec = (double)end.tv_sec * 1000000000.0 + (double)end.tv_nsec;

  if (end_sec < start_sec) {
    return 0;
  } else {
    return (end_sec - start_sec) / 1000000000.0;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cvtsi2sdq (%rax), %xmm0
movq -0x10(%rbp), %rax
cvtsi2sdq 0x8(%rax), %xmm1
movsd 0xcaf1(%rip), %xmm2     # 0xf008
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rax
cvtsi2sdq (%rax), %xmm0
movq -0x18(%rbp), %rax
cvtsi2sdq 0x8(%rax), %xmm1
movsd 0xcac9(%rip), %xmm2     # 0xf008
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm1
movsd -0x20(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x2566
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x2581
movsd -0x28(%rbp), %xmm0
subsd -0x20(%rbp), %xmm0
movsd 0xca90(%rip), %xmm1     # 0xf008
divsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
nopl (%rax,%rax)
// File: zyLiu6707[P]Arknights-Pull-Simulation/./utils.h
// Function: get_random_seed()
uint_fast64_t get_random_seed() {
  std::random_device rd;  // uses RDRND or /dev/urandom
                          // if you want use a specific token, do not use
                          // "/dev/random" on Linux, which is much slower
  std::mt19937_64 mt64(rd());
  auto random_seed = mt64();
  return random_seed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1d90, %rsp           # imm = 0x1D90
leaq -0x1388(%rbp), %rdi
movq %rdi, -0x1d78(%rbp)
callq 0x6a50
movq -0x1d78(%rbp), %rdi
callq 0x6af0
movl %eax, -0x1d6c(%rbp)
jmp 0x25c2
movl -0x1d6c(%rbp), %eax
movl %eax, %eax
movl %eax, %esi
leaq -0x1d50(%rbp), %rdi
callq 0x6b10
jmp 0x25da
leaq -0x1d50(%rbp), %rdi
callq 0x6b40
movq %rax, -0x1d80(%rbp)
jmp 0x25ef
movq -0x1d80(%rbp), %rax
movq %rax, -0x1d68(%rbp)
movq -0x1d68(%rbp), %rax
movq %rax, -0x1d88(%rbp)
leaq -0x1388(%rbp), %rdi
callq 0x6c00
movq -0x1d88(%rbp), %rax
addq $0x1d90, %rsp           # imm = 0x1D90
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d58(%rbp)
movl %eax, -0x1d5c(%rbp)
leaq -0x1388(%rbp), %rdi
callq 0x6c00
movq -0x1d58(%rbp), %rdi
callq 0x2360
nopw %cs:(%rax,%rax)
// File: devernay[P]vlpovutils/vlpov_motionfield2.cpp
// Function: mybasename(char const*)
char * mybasename (const char *name)
{
    const char *base;
    
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
    /* Skip over the disk name in MSDOS pathnames. */
    if (ISALPHA (name[0]) && name[1] == ':') 
        name += 2;
#endif
    
    for (base = name; *name; name++) {
        if (IS_DIR_SEPARATOR (*name)) {
            base = name + 1;
        }
    }
    return (char *) base;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0x3701
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x36f1
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x36f3
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x36d0
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x440, %rsp            # imm = 0x440
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6b10
movl %eax, -0x414(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6b20
movl %eax, %ecx
movl -0x414(%rbp), %eax
imull %ecx, %eax
cltq
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3040
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6b80
movq %rax, -0x408(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6b80
movq %rax, -0x410(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6b10
movl %eax, -0x400(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6b20
movq -0x410(%rbp), %rsi
movq -0x408(%rbp), %rdi
movl %eax, %ecx
movl -0x400(%rbp), %eax
imull %ecx, %eax
cltq
shlq $0x3, %rax
addq %rax, %rsi
movq -0x20(%rbp), %rdx
callq 0x6b40
movq -0x8(%rbp), %rdi
callq 0x6b10
movl %eax, -0x3fc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6b20
movl -0x3fc(%rbp), %esi
movl %eax, %edx
movq -0x18(%rbp), %rax
leaq -0x3f0(%rbp), %rdi
movl $0x1, %r9d
movl $0x4, %r8d
movl %r9d, %ecx
movq %rax, (%rsp)
callq 0x5680
movq -0x10(%rbp), %rdi
leaq 0xd01e(%rip), %rsi      # 0x124a0
callq 0x32b0
movq %rax, -0x3f8(%rbp)
cmpq $0x0, -0x3f8(%rbp)
jne 0x54b9
movq 0x14b31(%rip), %rax     # 0x19fd0
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0xcff6(%rip), %rsi      # 0x124a3
movb $0x0, %al
callq 0x3300
jmp 0x554c
movq -0x3f8(%rbp), %rcx
leaq -0x3f0(%rbp), %rdi
movl $0x3d0, %esi            # imm = 0x3D0
movl $0x1, %edx
callq 0x3450
movq -0x20(%rbp), %rax
movq %rax, -0x430(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6b10
movl %eax, -0x424(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6b20
movq -0x430(%rbp), %rdi
movl %eax, %ecx
movl -0x424(%rbp), %eax
imull %ecx, %eax
movslq %eax, %rsi
shlq $0x2, %rsi
movq -0x3f8(%rbp), %rcx
movl $0x1, %edx
callq 0x3450
movq -0x3f8(%rbp), %rdi
callq 0x3200
movq -0x20(%rbp), %rax
movq %rax, -0x420(%rbp)
cmpq $0x0, %rax
je 0x554c
movq -0x420(%rbp), %rdi
callq 0x32e0
addq $0x440, %rsp            # imm = 0x440
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x410, %rsp            # imm = 0x410
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6d20
movl %eax, -0x3f4(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6d30
movl -0x3f4(%rbp), %esi
movl %eax, %edx
movq -0x18(%rbp), %rax
leaq -0x3e8(%rbp), %rdi
movl $0x1, %r8d
xorl %r9d, %r9d
movl %r8d, %ecx
movq %rax, (%rsp)
callq 0x5680
movq -0x10(%rbp), %rdi
leaq 0xcede(%rip), %rsi      # 0x124a0
callq 0x32b0
movq %rax, -0x3f0(%rbp)
cmpq $0x0, -0x3f0(%rbp)
jne 0x55f6
movq 0x149f1(%rip), %rax     # 0x19fd0
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0xceb6(%rip), %rsi      # 0x124a3
movb $0x0, %al
callq 0x3300
jmp 0x5671
movq -0x3f0(%rbp), %rcx
leaq -0x3e8(%rbp), %rdi
movl $0x3d0, %esi            # imm = 0x3D0
movl $0x1, %edx
callq 0x3450
movq -0x8(%rbp), %rdi
callq 0x6d50
movq %rax, -0x400(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6d20
movl %eax, -0x3f8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6d30
movq -0x400(%rbp), %rdi
movl %eax, %ecx
movl -0x3f8(%rbp), %eax
imull %ecx, %eax
movslq %eax, %rsi
shlq $0x0, %rsi
movq -0x3f0(%rbp), %rcx
movl $0x1, %edx
callq 0x3450
movq -0x3f0(%rbp), %rdi
callq 0x3200
addq $0x410, %rsp            # imm = 0x410
popq %rbp
retq
nopw (%rax,%rax)
// File: devernay[P]vlpovutils/vlpov_motionfield2.cpp
// Function: tiff_set(unsigned short*, unsigned short, unsigned short, int, int)
static void tiff_set (uint16_t *ntag,
                      uint16_t tag, uint16_t type, int count, int val)
{
    struct tiff_tag *tt;
    
    tt = (struct tiff_tag *)(ntag+1) + (*ntag)++;
    tt->tag = tag;
    tt->type = type;
    tt->count = count;
    if (type == 3 && count == 1)          /* SHORT */
        tt->val.s0 = val;
    else
        tt->val.i0 = val;                   /* other */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %dx, %ax
movw %si, %dx
movq %rdi, -0x8(%rbp)
movw %dx, -0xa(%rbp)
movw %ax, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movl %r8d, -0x14(%rbp)
movq -0x8(%rbp), %rax
addq $0x2, %rax
movq -0x8(%rbp), %rdx
movw (%rdx), %cx
movw %cx, %si
addw $0x1, %si
movw %si, (%rdx)
movzwl %cx, %ecx
movslq %ecx, %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movw -0xa(%rbp), %cx
movq -0x20(%rbp), %rax
movw %cx, (%rax)
movw -0xc(%rbp), %cx
movq -0x20(%rbp), %rax
movw %cx, 0x2(%rax)
movl -0x10(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movzwl -0xc(%rbp), %eax
cmpl $0x3, %eax
jne 0x5c07
cmpl $0x1, -0x10(%rbp)
jne 0x5c07
movl -0x14(%rbp), %eax
movw %ax, %cx
movq -0x20(%rbp), %rax
movw %cx, 0x8(%rax)
jmp 0x5c11
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x7791
movq -0x18(%rbp), %rdi
callq 0x32e0
cmpl $0x0, -0xc(%rbp)
jle 0x77df
cmpl $0x0, -0x10(%rbp)
jle 0x77df
movl -0xc(%rbp), %eax
imull -0x10(%rbp), %eax
cltq
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3040
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0x4(%rax)
jmp 0x77f8
movq -0x20(%rbp), %rax
movl $0x0, 0x4(%rax)
movl $0x0, (%rax)
movq $0x0, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x30d0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x5, %rdi
callq 0x3040
movq %rax, -0x20(%rbp)
leaq 0x862b(%rip), %rax      # 0x128f0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xaf50
movq -0x28(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x5, %rsi
movq -0x20(%rbp), %rdx
addq -0x18(%rbp), %rdx
callq 0xaf50
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xa330
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0xa31e
movq -0x38(%rbp), %rdi
callq 0x32e0
movl -0x2c(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpl $0x0, (%rax)
jle 0xafb7
movq -0x40(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jg 0xafc3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xb0a3
movq -0x40(%rbp), %rcx
movl (%rcx), %eax
imull 0x4(%rcx), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x7a9b(%rip), %rsi      # 0x12a76
callq 0x32b0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xaff7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xb0a3
movq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x3270
movq -0x28(%rbp), %rdi
callq 0x3030
movl %eax, %eax
shrq $0x3, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl -0x1c(%rbp), %ecx
cmpq %rcx, %rax
jge 0xb03a
movq -0x28(%rbp), %rdi
callq 0x3200
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xb0a3
movq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x3270
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %edx
movq -0x28(%rbp), %rcx
movl $0x8, %esi
callq 0x3330
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
callq 0x3200
movq -0x38(%rbp), %rax
movl -0x1c(%rbp), %ecx
cmpq %rcx, %rax
je 0xb086
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xb0a3
movq -0x40(%rbp), %rdi
callq 0xbb50
testb $0x1, %al
jne 0xb09c
movq -0x40(%rbp), %rdi
callq 0xbb70
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd %xmm2, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
callq 0x6190
movq -0x50(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0xb0b0
movq %rax, -0x40(%rbp)
jmp 0xb292
movq -0x50(%rbp), %rdi
movq -0x40(%rbp), %rax
movsd -0x48(%rbp), %xmm0
movsd %xmm0, (%rax)
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
callq 0xb0b0
movq %rax, -0x60(%rbp)
jmp 0xb2b7
movq -0x50(%rbp), %rdi
movq -0x60(%rbp), %rax
movq $0x0, (%rax)
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0xb0b0
movq %rax, -0x68(%rbp)
jmp 0xb2da
movq -0x50(%rbp), %rdi
movq -0x68(%rbp), %rax
movq $0x0, (%rax)
xorl %eax, %eax
movl %eax, %edx
movl $0x1, %esi
callq 0xb0b0
movq %rax, -0x70(%rbp)
jmp 0xb2fd
movq -0x50(%rbp), %rdi
movq -0x70(%rbp), %rax
movq $0x0, (%rax)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x80(%rbp)
movl $0x1, %edx
movq %rdx, %rsi
callq 0xb0b0
movq %rax, -0x78(%rbp)
jmp 0xb329
movq -0x50(%rbp), %rdi
movq -0x78(%rbp), %rax
movsd -0x80(%rbp), %xmm0
movsd %xmm0, (%rax)
movl $0x1, %esi
movl $0x2, %edx
callq 0xb0b0
movq %rax, -0x88(%rbp)
jmp 0xb352
movq -0x50(%rbp), %rdi
movq -0x88(%rbp), %rax
movq $0x0, (%rax)
xorl %eax, %eax
movl %eax, %edx
movl $0x2, %esi
callq 0xb0b0
movq %rax, -0x90(%rbp)
jmp 0xb37b
movq -0x50(%rbp), %rdi
movq -0x90(%rbp), %rax
movq $0x0, (%rax)
movl $0x2, %esi
movl $0x1, %edx
callq 0xb0b0
movq %rax, -0x98(%rbp)
jmp 0xb3a5
movq -0x50(%rbp), %rdi
movq -0x98(%rbp), %rax
movq $0x0, (%rax)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0xa8(%rbp)
movl $0x2, %edx
movq %rdx, %rsi
callq 0xb0b0
movq %rax, -0xa0(%rbp)
jmp 0xb3da
movq -0xa0(%rbp), %rax
movsd -0xa8(%rbp), %xmm0
movsd %xmm0, (%rax)
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0xb419
jmp 0xb410
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x61b0
jmp 0xb426
movq -0x50(%rbp), %rdi
callq 0x61b0
movq -0x58(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x33e0
nop
// File: devernay[P]vlpovutils/./vlpov.hpp
// Function: VLPovImage<double>::invert_endianness()
void invert_endianness() {
        unsigned int size = _width * _height;
        switch (sizeof(T)) {
            case 1:
                break;
            case 2:
                for (unsigned short *ptr = (unsigned short*)_data+size; ptr>(unsigned short*)_data; ) {
                    const unsigned short val = *(--ptr);
                    *ptr = (unsigned short)((val>>8)|((val<<8)));
                }
                break;
            case 4:
                for (unsigned int *ptr = (unsigned int*)_data+size; ptr>(unsigned int*)_data; ) {
                    const unsigned int val = *(--ptr);
                    *ptr = (val>>24)|((val>>8)&0xff00)|((val<<8)&0xff0000)|(val<<24);
                }
                break;
            default:
                for (T* ptr = _data+size; ptr>_data; ) {
                    unsigned char *pb = (unsigned char*)(--ptr), *pe = pb + sizeof(T);
                    for (int i = 0; i<(int)sizeof(T)/2; ++i) std::swap(*(pb++),*(--pe));
                }
                break;
        }
        
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl (%rax), %ecx
imull 0x4(%rax), %ecx
movl %ecx, -0xc(%rbp)
movq 0x8(%rax), %rax
movl -0xc(%rbp), %ecx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x38(%rbp), %rcx
movq -0x18(%rbp), %rax
cmpq 0x8(%rcx), %rax
jbe 0xbc03
movq -0x18(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x18(%rbp)
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
cmpl $0x4, -0x2c(%rbp)
jge 0xbc01
movq -0x20(%rbp), %rdi
movq %rdi, %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rsi
addq $-0x1, %rsi
movq %rsi, -0x28(%rbp)
callq 0xbc10
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xbbd0
jmp 0xbb9f
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
subq $0xc8, %rsp
movq %rdi, 0xb8(%rsp)
movq %rsi, 0xb0(%rsp)
movq 0xb8(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x175d0
movq 0x10(%rsp), %rdi
movq %rax, 0xa0(%rsp)
callq 0x17600
movq %rax, 0x98(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0x90(%rsp)
movq 0xa0(%rsp), %rdi
movq 0x98(%rsp), %rsi
movq 0x90(%rsp), %rdx
callq 0x8380
movq 0x10(%rsp), %rdi
movq %rax, 0xa8(%rsp)
callq 0x17600
movq %rax, 0x88(%rsp)
leaq 0xa8(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x17630
testb $0x1, %al
jne 0x82d5
jmp 0x82f0
leaq 0xa8(%rsp), %rdi
callq 0x17670
addq $0x20, %rax
movq %rax, 0xc0(%rsp)
jmp 0x8359
movq 0xb0(%rsp), %rsi
leaq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
leaq 0x2f(%rsp), %rdx
callq 0x176b0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x17680
jmp 0x831d
leaq 0x30(%rsp), %rdi
callq 0x77b0
movq 0x10(%rsp), %rdi
callq 0x17720
addq $0x20, %rax
movq %rax, 0xc0(%rsp)
jmp 0x8359
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x77b0
jmp 0x8369
movq 0xc0(%rsp), %rax
addq $0xc8, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x5620
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, (%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movb $0x0, 0x37(%rsp)
callq 0x54b0
movq 0x8(%rsp), %rdi
callq 0x17810
movq %rax, 0x10(%rsp)
jmp 0x85f5
movq 0x10(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpb $0x0, 0x1040e2(%rip)    # 0x10c6e8
jne 0x864d
leaq 0x1040d9(%rip), %rdi    # 0x10c6e8
callq 0x5650
cmpl $0x0, %eax
je 0x864d
leaq 0x103dd0(%rip), %rdi    # 0x10c3f0
callq 0x17840
jmp 0x8627
leaq 0x13842(%rip), %rdi     # 0x1be70
leaq 0x103dbb(%rip), %rsi    # 0x10c3f0
leaq 0x103d34(%rip), %rdx    # 0x10c370
callq 0x5300
leaq 0x1040a0(%rip), %rdi    # 0x10c6e8
callq 0x5200
movq 0x38(%rsp), %rdx
leaq 0x103d97(%rip), %rsi    # 0x10c3f0
leaq 0x28(%rsp), %rdi
callq 0x1bf40
jmp 0x8665
movb $0x1, 0x37(%rsp)
testb $0x1, 0x37(%rsp)
jne 0x86a9
jmp 0x869f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x86b2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x104050(%rip), %rdi    # 0x10c6e8
callq 0x51f0
jmp 0x86b2
movq 0x8(%rsp), %rdi
callq 0x51d0
movq (%rsp), %rax
addq $0x48, %rsp
retq
movq 0x8(%rsp), %rdi
callq 0x51d0
movq 0x20(%rsp), %rdi
callq 0x5620
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rsi
leaq 0x18(%rsp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0x1bf80
cmpb $0x0, 0x1042f0(%rip)    # 0x10c9e8
jne 0x873f
leaq 0x1042e7(%rip), %rdi    # 0x10c9e8
callq 0x5650
cmpl $0x0, %eax
je 0x873f
leaq 0x103fde(%rip), %rdi    # 0x10c6f0
callq 0x1bfb0
jmp 0x8719
leaq 0x17e90(%rip), %rdi     # 0x205b0
leaq 0x103fc9(%rip), %rsi    # 0x10c6f0
leaq 0x103c42(%rip), %rdx    # 0x10c370
callq 0x5300
leaq 0x1042ae(%rip), %rdi    # 0x10c9e8
callq 0x5200
movq 0x28(%rsp), %rdx
leaq 0x18(%rsp), %rdi
leaq 0x103fa0(%rip), %rsi    # 0x10c6f0
callq 0x20680
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
leaq 0x104274(%rip), %rdi    # 0x10c9e8
callq 0x51f0
movq 0x10(%rsp), %rdi
callq 0x5620
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x78(%rsp), %rdi
callq 0x206c0
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x78(%rsp), %rdi
callq 0x206f0
movq 0x20(%rsp), %rdi
movq %rax, 0x60(%rsp)
movb $0x0, 0x5f(%rsp)
callq 0x20720
movq 0x20(%rsp), %rdx
movq 0x60(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rsi
leaq 0x70(%rsp), %rdi
callq 0x20770
movb %al, 0x2f(%rsp)
jmp 0x880c
movb 0x2f(%rsp), %al
testb $0x1, %al
jne 0x88a1
jmp 0x881a
movq 0x1037cf(%rip), %rdi    # 0x10bff0
leaq 0xbbf20(%rip), %rsi     # 0xc4748
callq 0x5350
movq %rax, 0x10(%rsp)
jmp 0x8834
movq 0x68(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x20a60
movq %rax, 0x8(%rsp)
jmp 0x885e
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdi
callq 0x5660
movq %rax, (%rsp)
jmp 0x8873
movq (%rsp), %rdi
leaq 0xbccf9(%rip), %rsi     # 0xc5577
callq 0x5350
jmp 0x8885
jmp 0x88a1
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
callq 0x61d0
jmp 0x88c4
movb $0x1, 0x5f(%rsp)
testb $0x1, 0x5f(%rsp)
jne 0x88b7
movq 0x20(%rsp), %rdi
callq 0x61d0
movq 0x18(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x5620
nop
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x78(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
movl $0x1000, %esi           # imm = 0x1000
callq 0x20aa0
movq 0x78(%rsp), %rsi
leaq 0x60(%rsp), %rdi
callq 0x20ae0
leaq 0x48(%rsp), %rdi
callq 0x20b10
jmp 0x8925
movq 0x10(%rsp), %rdi
movb $0x0, 0x3b(%rsp)
callq 0x20720
leaq 0x20(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x20ed0
jmp 0x8945
movq 0x10(%rsp), %rdx
leaq 0x60(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x20b20
movb %al, 0xf(%rsp)
jmp 0x895f
movb 0xf(%rsp), %al
xorb $-0x1, %al
movb %al, 0xe(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x20f00
movb 0xe(%rsp), %al
testb $0x1, %al
jne 0x897d
jmp 0x89ce
movq 0x10366c(%rip), %rdi    # 0x10bff0
leaq 0xbbdd2(%rip), %rsi     # 0xc475d
callq 0x5350
jmp 0x8992
jmp 0x89ce
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x8a19
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x8a05
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x20f00
jmp 0x8a05
movb $0x1, 0x3b(%rsp)
testb $0x1, 0x3b(%rsp)
jne 0x89e4
movq 0x10(%rsp), %rdi
callq 0x61d0
leaq 0x48(%rsp), %rdi
callq 0x20f00
leaq 0x60(%rsp), %rdi
callq 0x20f00
movq 0x18(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x10(%rsp), %rdi
callq 0x61d0
leaq 0x48(%rsp), %rdi
callq 0x20f00
leaq 0x60(%rsp), %rdi
callq 0x20f00
movq 0x40(%rsp), %rdi
callq 0x5620
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x28(%rsp), %rdi
callq 0x6870
movl %eax, 0x18(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x18(%rsp), %eax
jae 0x3653
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, %esi
callq 0x68c0
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x6890
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq 0x20(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, %esi
callq 0x68c0
movq 0x8(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x35dd
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x68(%rsp), %rdi
callq 0x68e0
movq %rax, 0x30(%rsp)
movq 0x60(%rsp), %rdi
callq 0x68e0
movq %rax, %rcx
movq 0x30(%rsp), %rax
cmpq %rcx, %rax
jne 0x36a8
jmp 0x36c7
leaq 0xc9ad(%rip), %rdi      # 0x1005c
leaq 0xc9bd(%rip), %rsi      # 0x10073
movl $0x43, %edx
leaq 0xc9bf(%rip), %rcx      # 0x10081
callq 0x3120
movq 0x20(%rsp), %rdi
movb $0x0, 0x5f(%rsp)
callq 0x6900
movl $0x0, 0x58(%rsp)
movl 0x58(%rsp), %eax
movq %rax, 0x18(%rsp)
movq 0x68(%rsp), %rdi
callq 0x68e0
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x37c8
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
movq %rax, 0x10(%rsp)
movq 0x60(%rsp), %rdi
callq 0x68e0
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x37b6
movq 0x68(%rsp), %rdi
movl 0x58(%rsp), %eax
movl %eax, %esi
callq 0x6910
movq (%rax), %rax
movq %rax, (%rsp)
movq 0x60(%rsp), %rdi
movl 0x54(%rsp), %eax
movl %eax, %esi
callq 0x6910
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movq (%rsp), %rax
movq (%rcx), %rcx
addq %rcx, %rax
movq %rax, 0x48(%rsp)
leaq 0x48(%rsp), %rsi
callq 0x6890
movq %rax, 0x8(%rsp)
jmp 0x377d
movq 0x8(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movl 0x54(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x54(%rsp)
jmp 0x370a
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
callq 0x6930
jmp 0x37e8
jmp 0x37b8
movl 0x58(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x58(%rsp)
jmp 0x36de
movb $0x1, 0x5f(%rsp)
testb $0x1, 0x5f(%rsp)
jne 0x37de
movq 0x20(%rsp), %rdi
callq 0x6930
movq 0x28(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x3380
nopw %cs:(%rax,%rax)
// File: 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:
subq $0xc8, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq %rdx, 0xb0(%rsp)
movq %rcx, 0xa8(%rsp)
movb $0x0, 0xa7(%rsp)
movq 0xb8(%rsp), %rdi
callq 0x6940
movq %rax, 0x28(%rsp)
leaq 0xa6(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x6950
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
callq 0x6960
jmp 0x3876
leaq 0xa6(%rsp), %rdi
callq 0x69e0
movl $0x0, 0x90(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0x88(%rsp)
movq 0x88(%rsp), %rdi
callq 0x69f0
movq %rax, 0x80(%rsp)
movq 0x88(%rsp), %rdi
callq 0x6a20
movq %rax, 0x78(%rsp)
leaq 0x80(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x6a50
testb $0x1, %al
jne 0x38e0
jmp 0x39c8
leaq 0x80(%rsp), %rdi
callq 0x6a70
movq 0x10(%rax), %rcx
movq %rcx, 0x70(%rsp)
movups (%rax), %xmm0
movaps %xmm0, 0x60(%rsp)
movl $0x0, 0x4c(%rsp)
leaq 0x60(%rsp), %rdi
leaq 0x4c(%rsp), %rsi
callq 0x6a90
movl %edx, 0xc(%rsp)
movq %rax, 0x10(%rsp)
jmp 0x3920
movq 0x20(%rsp), %rdi
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
movq %rcx, 0x38(%rsp)
movl %eax, 0x40(%rsp)
movl 0x40(%rsp), %eax
movl %eax, 0x58(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x50(%rsp)
movl 0x90(%rsp), %eax
movl %eax, %esi
movl %esi, %eax
incl %eax
movl %eax, 0x90(%rsp)
callq 0x68c0
movq %rax, %rdi
leaq 0x50(%rsp), %rsi
callq 0x6ac0
jmp 0x3971
jmp 0x3973
leaq 0x80(%rsp), %rdi
callq 0x6af0
jmp 0x38c5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
leaq 0xa6(%rsp), %rdi
callq 0x69e0
jmp 0x39f1
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
callq 0x6b20
jmp 0x39f1
movb $0x1, 0xa7(%rsp)
testb $0x1, 0xa7(%rsp)
jne 0x39e4
movq 0x20(%rsp), %rdi
callq 0x6b20
movq 0x18(%rsp), %rax
addq $0xc8, %rsp
retq
movq 0x98(%rsp), %rdi
callq 0x3380
nop
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
callq 0x3030
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rdi
callq 0x6b80
movq %rax, 0x30(%rsp)
movq 0x40(%rsp), %rdi
callq 0x6bb0
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x3ac0
callq 0x3030
movq %rax, 0x18(%rsp)
movq 0x1356f(%rip), %rdi     # 0x16fc0
leaq 0xc699(%rip), %rsi      # 0x100f1
callq 0x31e0
movq %rax, (%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x6c10
movq %rax, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x6be0
movq %rax, 0x10(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x6c60
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x33c0
movq %rax, %rdi
leaq 0xc669(%rip), %rsi      # 0x1010d
callq 0x31e0
movq %rax, %rdi
movq 0x134ed(%rip), %rsi     # 0x16fa0
callq 0x3210
addq $0x48, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movb $0x0, 0x27(%rsp)
callq 0x6c70
movq 0x28(%rsp), %rsi
leaq 0x13660(%rip), %rdi     # 0x17230
callq 0x6910
movq (%rax), %rax
movl %eax, 0x20(%rsp)
cmpl $0x0, 0x20(%rsp)
je 0x3c3a
movl 0x20(%rsp), %eax
movl %eax, %esi
leaq 0x13658(%rip), %rdi     # 0x17248
callq 0x6d50
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x6d70
jmp 0x3c03
jmp 0x3c05
movl 0x20(%rsp), %eax
movl %eax, %esi
leaq 0x13636(%rip), %rdi     # 0x17248
callq 0x6d50
movq 0x8(%rax), %rax
movl %eax, 0x20(%rsp)
jmp 0x3bdc
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
callq 0x6c80
jmp 0x3c59
movb $0x1, 0x27(%rsp)
testb $0x1, 0x27(%rsp)
jne 0x3c4f
movq (%rsp), %rdi
callq 0x6c80
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x3380
nopw %cs:(%rax,%rax)
// File: stoianmihail[P]XY-sorting/algorithm.cpp
// Function: solveWithCdf(std::vector<std::pair<unsigned long, unsigned long>, std::allocator<std::pair<unsigned long, unsigned long>>>&)
void solveWithCdf(std::vector<cdf_coord>& cdf)
// Insertion sort for partially sorted cdf
{
    
    auto start = high_resolution_clock::now();
    int size = cdf.size();
    for (unsigned index = 1, limit = cdf.size(); index < limit; ++index) {
        unsigned ptr = index;
        cdf_coord curr = cdf[index];
        while ((ptr > 0) && (cdf[ptr - 1].first > curr.first)) {
            cdf[ptr] = cdf[ptr - 1];
            --ptr;
        }
        cdf[ptr] = curr;
    }
    
    auto stop = high_resolution_clock::now();
    std::cout << "Solving with CDF approximation took: " << duration_cast<milliseconds>(stop - start).count() << " ms" << std::endl;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
callq 0x3030
movq %rax, 0x58(%rsp)
movq 0x60(%rsp), %rdi
callq 0x6870
movl %eax, 0x54(%rsp)
movl $0x1, 0x50(%rsp)
movq 0x60(%rsp), %rdi
callq 0x6870
movl %eax, 0x4c(%rsp)
movl 0x50(%rsp), %eax
cmpl 0x4c(%rsp), %eax
jae 0x498a
movl 0x50(%rsp), %eax
movl %eax, 0x48(%rsp)
movq 0x60(%rsp), %rdi
movl 0x50(%rsp), %eax
movl %eax, %esi
callq 0x68c0
movq (%rax), %rcx
movq %rcx, 0x38(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x40(%rsp)
xorl %eax, %eax
cmpl $0x0, 0x48(%rsp)
movb %al, 0x1f(%rsp)
jbe 0x490f
movq 0x60(%rsp), %rdi
movl 0x48(%rsp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x68c0
movq (%rax), %rax
cmpq 0x38(%rsp), %rax
seta %al
movb %al, 0x1f(%rsp)
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0x4919
jmp 0x495d
movq 0x60(%rsp), %rdi
movl 0x48(%rsp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x68c0
movq %rax, 0x10(%rsp)
movq 0x60(%rsp), %rdi
movl 0x48(%rsp), %eax
movl %eax, %esi
callq 0x68c0
movq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x6f60
movl 0x48(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x48(%rsp)
jmp 0x48de
movq 0x60(%rsp), %rdi
movl 0x48(%rsp), %eax
movl %eax, %esi
callq 0x68c0
movq %rax, %rdi
leaq 0x38(%rsp), %rsi
callq 0x6f60
movl 0x50(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x50(%rsp)
jmp 0x48a7
callq 0x3030
movq %rax, 0x30(%rsp)
movq 0x12625(%rip), %rdi     # 0x16fc0
leaq 0xb814(%rip), %rsi      # 0x101b6
callq 0x31e0
movq %rax, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x6c10
movq %rax, 0x20(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x6be0
movq %rax, 0x28(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x6c60
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x33c0
movq %rax, %rdi
leaq 0xb71d(%rip), %rsi      # 0x1010d
callq 0x31e0
movq %rax, %rdi
movq 0x125a1(%rip), %rsi     # 0x16fa0
callq 0x3210
addq $0x68, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x27b8, %rsp           # imm = 0x27B8
movq %rdi, 0x13c8(%rsp)
movq %rdi, %rax
movq %rax, 0x13c0(%rsp)
movq %rdi, 0x27b0(%rsp)
movq %rsi, 0x27a8(%rsp)
movb $0x0, 0x27a7(%rsp)
callq 0x6c70
movq 0x13c8(%rsp), %rdi
callq 0x7a90
movq %rax, 0x13d0(%rsp)
jmp 0x4fee
movq 0x13d0(%rsp), %rax
movq %rax, 0x2798(%rsp)
movq 0x27a8(%rsp), %rcx
leaq 0x1226b(%rip), %rsi     # 0x17278
leaq 0x13f0(%rsp), %rdi
movl $0x1, %edx
callq 0x54a0
jmp 0x5021
movq 0x2798(%rsp), %rax
movq %rax, 0x13b0(%rsp)
movq %rsp, %rdi
movl $0x273, %ecx            # imm = 0x273
leaq 0x13f0(%rsp), %rsi
rep  movsq (%rsi), %es:(%rdi)
movq 0x13b0(%rsp), %rdi
movl $0x2710, %esi           # imm = 0x2710
callq 0x5420
movq %rax, 0x13b8(%rsp)
jmp 0x5060
movq 0x13c8(%rsp), %rdi
movq 0x13b8(%rsp), %rax
movq %rax, 0x13e8(%rsp)
callq 0x7b00
movq %rax, 0x13a8(%rsp)
jmp 0x5087
movq 0x13c8(%rsp), %rdi
movq 0x13a8(%rsp), %rax
movq %rax, 0x13e0(%rsp)
callq 0x7b30
movq %rax, 0x13a0(%rsp)
jmp 0x50ae
movq 0x13a0(%rsp), %rax
movq %rax, 0x13d8(%rsp)
movq 0x13e0(%rsp), %rdi
movq 0x13d8(%rsp), %rsi
callq 0x7ac0
jmp 0x50d5
movb $0x1, 0x27a7(%rsp)
testb $0x1, 0x27a7(%rsp)
jne 0x5119
jmp 0x510c
movq 0x13c8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x2790(%rsp)
movl %eax, 0x278c(%rsp)
callq 0x6c80
jmp 0x5129
movq 0x13c8(%rsp), %rdi
callq 0x6c80
movq 0x13c0(%rsp), %rax
addq $0x27b8, %rsp           # imm = 0x27B8
retq
movq 0x2790(%rsp), %rdi
callq 0x3380
nopw %cs:(%rax,%rax)
// File: stoianmihail[P]XY-sorting/./util.hpp
// Function: util::is_cdf(std::vector<unsigned long, std::allocator<unsigned long>>&, std::vector<unsigned long, std::allocator<unsigned long>>&, std::vector<std::pair<unsigned long, unsigned long>, std::allocator<std::pair<unsigned long, unsigned long>>>&)
static bool is_cdf(std::vector<uint64_t>& xs, std::vector<uint64_t>& ys, std::vector<cdf_coord>& arr) 
   // Test for cdf
   {
       assert(("CDF is empty", !arr.empty()));
       if (!is_sorted(arr))
           return false;
       return arr.back().second == (xs.size() * ys.size());
   }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0xa440
xorb $-0x1, %al
testb $0x1, %al
jne 0x5165
jmp 0x5167
jmp 0x5186
leaq 0xb1e0(%rip), %rdi      # 0x1034e
leaq 0xb1f8(%rip), %rsi      # 0x1036d
movl $0x24, %edx
leaq 0xb1f7(%rip), %rcx      # 0x10378
callq 0x3120
movq 0x18(%rsp), %rdi
callq 0x5580
testb $0x1, %al
jne 0x519b
movb $0x0, 0x37(%rsp)
jmp 0x51e4
movq 0x18(%rsp), %rdi
callq 0xa490
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
callq 0x68e0
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x68e0
movq 0x8(%rsp), %rcx
movq %rax, %rdx
movq 0x10(%rsp), %rax
imulq %rdx, %rcx
cmpq %rcx, %rax
sete %al
andb $0x1, %al
movb %al, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nop