LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Utils/R3Segmentation.cpp
// Function: gaps::R3SegmentationCluster::RemoveChild(gaps::R3SegmentationCluster*)
void R3SegmentationCluster::
RemoveChild(R3SegmentationCluster *child)
{
  // Update area
  area -= child->area;

  // Update color
  int n = points.NEntries() - child->points.NEntries();
  color *= points.NEntries();
  color -= child->points.NEntries() * child->color;
  color = (n > 0) ? color / n : RNblack_rgb;

  // Update timestamp
  timestamp *= points.NEntries();
  timestamp -= child->points.NEntries() * child->timestamp;
  timestamp = (n > 0) ? timestamp / n : 0;

  // Remove child
  this->children.Remove(child);
  child->parent = NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movsd 0xe8(%rdi), %xmm0
subsd 0xe8(%rsi), %xmm0
movsd %xmm0, 0xe8(%rdi)
movl 0x14(%rdi), %ebp
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
leaq 0xf0(%rdi), %r15
movl 0x14(%rsi), %r13d
movq %r15, %rdi
callq 0xc34dc
cvtsi2sdl 0x14(%rbx), %xmm2
movsd 0xf0(%rbx), %xmm0
mulsd %xmm2, %xmm0
movsd 0xf8(%rbx), %xmm1
mulsd %xmm2, %xmm1
mulsd 0x100(%rbx), %xmm2
leaq 0x10(%rsp), %r12
movq %r12, %rdi
callq 0xc33a0
movq %r15, %rdi
movq %r12, %rsi
callq 0xc3480
subl %r13d, %ebp
jle 0x2b102
cvtsi2sd %ebp, %xmm3
movsd 0xf0(%r14), %xmm0
movsd 0xf8(%r14), %xmm1
divsd %xmm3, %xmm0
divsd %xmm3, %xmm1
movsd 0x100(%r14), %xmm2
movsd %xmm3, 0x8(%rsp)
divsd %xmm3, %xmm2
leaq 0x10(%rsp), %rdi
callq 0xc33a0
jmp 0x2b120
leaq 0x546847(%rip), %rsi    # 0x571950
leaq 0x10(%rsp), %rdi
callq 0xc3382
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
callq 0xc3432
xorps %xmm0, %xmm0
cvtsi2sdl 0x14(%r14), %xmm0
mulsd 0x108(%r14), %xmm0
movsd %xmm0, 0x108(%r14)
testl %ebp, %ebp
jg 0x2b152
xorpd %xmm0, %xmm0
jmp 0x2b16c
xorps %xmm1, %xmm1
cvtsi2sdl 0x14(%rbx), %xmm1
mulsd 0x108(%rbx), %xmm1
subsd %xmm1, %xmm0
divsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x108(%r14)
leaq 0x20(%r14), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0xc35a4
subq 0x20(%r14), %rax
shrq $0x3, %rax
movq %r15, %rdi
movl %eax, %esi
callq 0xc374c
movq $0x0, 0x18(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Utils/R3Segmentation.cpp
// Function: gaps::R3SegmentationCluster::UpdateColor()
int R3SegmentationCluster::
UpdateColor(void)
{
  // Update color
  color.Reset(0,0,0);
  if (points.NEntries() == 0) return 1;
  for (int i = 0; i < points.NEntries(); i++)
    color += points[i]->color;
  color /= points.NEntries();
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0xf0(%rdi), %rbx
xorpd %xmm0, %xmm0
movupd %xmm0, 0xf0(%rdi)
movq $0x0, 0x100(%rdi)
movl 0x14(%rdi), %eax
testl %eax, %eax
je 0x2b56f
jle 0x2b560
movq %rdi, %r14
xorl %r15d, %r15d
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rsi
addq $0x78, %rsi
movq %rbx, %rdi
callq 0xc3452
incq %r15
movslq 0x14(%r14), %rax
cmpq %rax, %r15
jl 0x2b540
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movq %rbx, %rdi
callq 0xc34fe
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Utils/R3Segmentation.cpp
// Function: gaps::R3SegmentationCluster::UpdateTimestamp()
int R3SegmentationCluster::
UpdateTimestamp(void)
{
  // Update timestamp
  timestamp = 0;
  if (points.NEntries() == 0) return 1;
  for (int i = 0; i < points.NEntries(); i++)
    timestamp += points[i]->timestamp;
  timestamp /= points.NEntries();
  return 1;
}

// Assembly:
movq $0x0, 0x108(%rdi)
movl 0x14(%rdi), %eax
testq %rax, %rax
je 0x2b5c2
testl %eax, %eax
jle 0x2b5ae
movq 0x8(%rdi), %rcx
xorpd %xmm0, %xmm0
xorl %edx, %edx
movq (%rcx,%rdx,8), %rsi
addsd 0x68(%rsi), %xmm0
incq %rdx
cmpq %rdx, %rax
jne 0x2b59b
jmp 0x2b5b2
xorpd %xmm0, %xmm0
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x108(%rdi)
movl $0x1, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Utils/R3Segmentation.cpp
// Function: gaps::R3SegmentationCluster::UpdateArea()
int R3SegmentationCluster::
UpdateArea(void)
{
  // Update area
  area = 0;
  for (int i = 0; i < points.NEntries(); i++)
    area += points[i]->area;
  return 1;
}

// Assembly:
movq $0x0, 0xe8(%rdi)
movslq 0x14(%rdi), %rax
testq %rax, %rax
jle 0x2b5ff
movq 0x8(%rdi), %rcx
xorpd %xmm0, %xmm0
xorl %edx, %edx
movq (%rcx,%rdx,8), %rsi
addsd 0x70(%rsi), %xmm0
incq %rdx
cmpq %rdx, %rax
jne 0x2b5e6
movsd %xmm0, 0xe8(%rdi)
movl $0x1, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Utils/R3Segmentation.cpp
// Function: gaps::R3SegmentationPair::R3SegmentationPair(gaps::R3SegmentationCluster*, gaps::R3SegmentationCluster*, double)
R3SegmentationPair::
R3SegmentationPair(R3SegmentationCluster *cluster1, R3SegmentationCluster *cluster2, RNScalar affinity)
  : affinity(affinity),
    heapentry(NULL)
{
  // Insert pair into clusters
  if (cluster1 && cluster2) {
    // Remember clusters
    clusters[0] = cluster1;
    clusters[1] = cluster2;

    // Remember position of pair in clusters
    cluster_index[0] = cluster1->pairs.NEntries();
    cluster_index[1] = cluster2->pairs.NEntries();

    // Update clusters
    cluster1->pairs.Insert(this);
    cluster2->pairs.Insert(this);
  }
  else {
    // Initialize clusters
    clusters[0] = NULL;
    clusters[1] = NULL;

    // Initialize cluster index
    cluster_index[0] = -1;
    cluster_index[1] = -1;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movsd %xmm0, 0x18(%rdi)
movq $0x0, 0x20(%rdi)
testq %rsi, %rsi
sete %al
testq %rdx, %rdx
sete %cl
orb %al, %cl
jne 0x2bdae
movq %rdx, %r14
movq %rsi, (%rbx)
movq %rdx, 0x8(%rbx)
leaq 0x30(%rsi), %rdi
movl 0x3c(%rsi), %eax
movl %eax, 0x10(%rbx)
leaq 0x30(%rdx), %r15
movl 0x3c(%rdx), %eax
movl %eax, 0x14(%rbx)
movl 0x3c(%rsi), %edx
movq %rbx, %rsi
callq 0xc35c2
movl 0x3c(%r14), %edx
movq %r15, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xc35c2
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $-0x1, 0x10(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Utils/R3Segmentation.cpp
// Function: gaps::R3SegmentationPair::~R3SegmentationPair()
R3SegmentationPair::
~R3SegmentationPair(void)
{
  // Remove this pair from first cluster
  if (clusters[0]) {
    assert(cluster_index[0] >= 0);
    RNArrayEntry *entry = clusters[0]->pairs.KthEntry(cluster_index[0]);
    R3SegmentationPair *tail = clusters[0]->pairs.Tail();
    if (tail->clusters[0] == clusters[0]) tail->cluster_index[0] = cluster_index[0];
    else if (tail->clusters[1] == clusters[0]) tail->cluster_index[1] = cluster_index[0];
    clusters[0]->pairs.EntryContents(entry) = tail;
    clusters[0]->pairs.RemoveTail();
  }

  // Remove this pair from second cluster
  if (clusters[1]) {
    assert(cluster_index[1] >= 0);
    RNArrayEntry *entry = clusters[1]->pairs.KthEntry(cluster_index[1]);
    R3SegmentationPair *tail = clusters[1]->pairs.Tail();
    if (tail->clusters[0] == clusters[1]) tail->cluster_index[0] = cluster_index[1];
    else if (tail->clusters[1] == clusters[1]) tail->cluster_index[1] = cluster_index[1];
    clusters[1]->pairs.EntryContents(entry) = tail;
    clusters[1]->pairs.RemoveTail();
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x2be09
movl 0x10(%rbx), %edx
movq 0x30(%rsi), %rax
movslq %edx, %rcx
movslq 0x3c(%rsi), %rdi
movq -0x8(%rax,%rdi,8), %rdi
cmpq %rsi, (%rdi)
je 0x2bdf1
cmpq %rsi, 0x8(%rdi)
jne 0x2bdf4
movl %edx, 0x14(%rdi)
jmp 0x2bdf4
movl %edx, 0x10(%rdi)
movq %rdi, (%rax,%rcx,8)
movq (%rbx), %rdi
movl 0x3c(%rdi), %esi
addq $0x30, %rdi
decl %esi
callq 0xc374c
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x2be4e
movl 0x14(%rbx), %edx
movq 0x30(%rsi), %rax
movslq %edx, %rcx
movslq 0x3c(%rsi), %rdi
movq -0x8(%rax,%rdi,8), %rdi
cmpq %rsi, (%rdi)
je 0x2be35
cmpq %rsi, 0x8(%rdi)
jne 0x2be38
movl %edx, 0x14(%rdi)
jmp 0x2be38
movl %edx, 0x10(%rdi)
movq %rdi, (%rax,%rcx,8)
movq 0x8(%rbx), %rdi
movl 0x3c(%rdi), %esi
addq $0x30, %rdi
decl %esi
callq 0xc374c
popq %rbx
retq
movq %rax, %rdi
callq 0x1f187
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Utils/R3Segmentation.cpp
// Function: gaps::R3Segmentation::~R3Segmentation()
R3Segmentation::
~R3Segmentation(void)
{
  // Delete clusters
  for (int i = 0; i < clusters.NEntries(); i++) delete clusters[i];
  
  // Delete kdtree
  if (kdtree) delete kdtree;

  // Delete points
  if (point_buffer) delete [] point_buffer;
  else { for (int i = 0; i < points.NEntries(); i++) delete points[i]; }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
cmpl $0x0, 0x24(%rdi)
jle 0x2c056
xorl %r12d, %r12d
movq (%r14), %rax
movq (%rax,%r12,8), %r15
testq %r15, %r15
je 0x2c03d
movq %r15, %rdi
callq 0x2a8cc
movl $0x140, %esi            # imm = 0x140
movq %r15, %rdi
callq 0x15620
incq %r12
movslq 0x24(%rbx), %rax
cmpq %rax, %r12
jl 0x2c029
movq 0x10(%rbx), %r15
testq %r15, %r15
je 0x2c074
movq %r15, %rdi
callq 0x2e61c
movl $0x60, %esi
movq %r15, %rdi
callq 0x15620
movq 0x28(%rbx), %r12
testq %r12, %r12
je 0x2c0be
leaq -0x8(%r12), %r15
movq -0x8(%r12), %r13
testq %r13, %r13
je 0x2c0a9
addq $-0x30, %r12
imulq $0xe0, %r13, %rbp
leaq (%r12,%rbp), %rdi
callq 0xc3596
addq $-0xe0, %rbp
jne 0x2c097
imulq $0xe0, %r13, %rsi
orq $0x8, %rsi
movq %r15, %rdi
callq 0x15c20
jmp 0x2c0f8
cmpl $0x0, 0xc(%rbx)
jle 0x2c0f8
xorl %r12d, %r12d
movq (%rbx), %rax
movq (%rax,%r12,8), %r15
testq %r15, %r15
je 0x2c0df
leaq 0xb0(%r15), %rdi
callq 0xc3596
movl $0xe0, %esi
movq %r15, %rdi
callq 0x15620
incq %r12
movslq 0xc(%rbx), %rax
cmpq %rax, %r12
jl 0x2c0c7
movq %r14, %rdi
callq 0xc3596
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xc3596
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Utils/R3Segmentation.cpp
// Function: gaps::R3Segmentation::Affinity() const
RNScalar R3Segmentation::
Affinity(void) const
{
  RNScalar sum = 0;
  for (int i = 0; i < clusters.NEntries(); i++) {
    sum += clusters[i]->total_affinity;
  }
  return sum;
}

// Assembly:
movslq 0x24(%rdi), %rax
testq %rax, %rax
jle 0x2c13e
movq 0x18(%rdi), %rcx
xorpd %xmm0, %xmm0
xorl %edx, %edx
movq (%rcx,%rdx,8), %rsi
addsd 0x128(%rsi), %xmm0
incq %rdx
cmpq %rdx, %rax
jne 0x2c129
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Utils/R3Segmentation.cpp
// Function: gaps::R3Segmentation::NUnclusteredPoints() const
int R3Segmentation::
NUnclusteredPoints(void) const
{
  // Count unclustered points
  int count = 0;
  for (int i = 0; i < points.NEntries(); i++) {
    R3SegmentationPoint *point = points.Kth(i);
    if (!point->cluster) count++;
  }

  // Return number of unclustered points
  return count;
}

// Assembly:
movslq 0xc(%rdi), %rcx
testq %rcx, %rcx
jle 0x2c16a
movq (%rdi), %rdx
xorl %esi, %esi
xorl %eax, %eax
movq (%rdx,%rsi,8), %rdi
cmpq $0x1, 0xc0(%rdi)
adcl $0x0, %eax
incq %rsi
cmpq %rsi, %rcx
jne 0x2c152
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Utils/R3Segmentation.cpp
// Function: gaps::R3Segmentation::CreateSingletonClusters(int)
int R3Segmentation::
CreateSingletonClusters(int primitive_type)
{
  // Create cluster for every point
  for (int i = 0; i < points.NEntries(); i++) {
    R3SegmentationPoint *point = points.Kth(i);

    // Create primitive
    R3SegmentationPrimitive primitive(primitive_type);
    primitive.Update(point);
    
    // Create cluster
    R3SegmentationCluster *cluster = new R3SegmentationCluster(point, primitive);

    // Insert point
    cluster->InsertPoint(point, 1.0);

    // Insert cluster
    cluster->segmentation = this;
    cluster->segmentation_index = clusters.NEntries();    
    clusters.Insert(cluster);
  }

  // Return success
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movl %esi, 0xc(%rsp)
cmpl $0x0, 0xc(%rdi)
jle 0x2cb4f
movq %rdi, %r14
leaq 0x18(%rdi), %r15
xorl %ebp, %ebp
leaq 0x10(%rsp), %r12
movq (%r14), %rax
movq (%rax,%rbp,8), %r13
movq %r12, %rdi
movl 0xc(%rsp), %esi
callq 0x28edc
movq %r12, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x29040
movl $0x140, %edi            # imm = 0x140
callq 0x15610
movq %rax, %rbx
movq %rax, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x29c80
movq %rbx, %rdi
movq %r13, %rsi
movsd 0xdc538(%rip), %xmm0    # 0x109050
callq 0x2a720
movq %r14, 0x130(%rbx)
movl 0x24(%r14), %edx
movl %edx, 0x138(%rbx)
movq %r15, %rdi
movq %rbx, %rsi
callq 0xc35c2
leaq 0x18(%rsp), %rdi
callq 0x88520
incq %rbp
movslq 0xc(%r14), %rax
cmpq %rax, %rbp
jl 0x2cacf
movl $0x1, %eax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2cb7a
movq %rax, %r14
movl $0x140, %esi            # imm = 0x140
movq %rbx, %rdi
callq 0x15620
jmp 0x2cb7d
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x88520
movq %r14, %rdi
callq 0x15ad0
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Utils/R3Segmentation.cpp
// Function: gaps::R3Segmentation::RefineBoundaries()
int R3Segmentation::
RefineBoundaries(void)
{
  // Check if should refine boundaries
  if (!refine_boundaries) return 1;

  // Iteratively refine boundaries
  for (int iter = 0; iter < 1000; iter++) {
    RNBoolean done = TRUE;
    for (int i0 = 0; i0 < points.NEntries(); i0++) {
      R3SegmentationPoint *point0 = points.Kth(i0);
      if (point0->neighbors.NEntries() < 3) continue;
      R3SegmentationCluster *cluster0 = point0->cluster;
      if (!cluster0) continue;
      int i1 = RNRandomScalar() * point0->neighbors.NEntries();
      R3SegmentationPoint *point1 = point0->neighbors.Kth(i1);
      R3SegmentationCluster *cluster1 = point1->cluster;
      if (!cluster1) continue;
      if (cluster0 == cluster1) continue;
      int count = 0;
      for (int i2 = 0; i2 < point0->neighbors.NEntries(); i2++) {
        R3SegmentationPoint *point2 = point0->neighbors.Kth(i2);
        R3SegmentationCluster *cluster2 = point2->cluster;
        if (!cluster2) continue;
        if (cluster2 == cluster1) count++;
      }
      if (count > point0->neighbors.NEntries()/2) {
        cluster0->RemovePoint(point0);
        cluster1->InsertPoint(point0, point0->cluster_affinity);
        done = FALSE;
      }
    }
    if (done) break;
  }

  // Return success
  return 1;
}

// Assembly:
cmpl $0x0, 0xd8(%rdi)
je 0x2da0f
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0xc(%rdi), %eax
xorl %ebp, %ebp
testl %eax, %eax
jle 0x2da01
xorl %r13d, %r13d
xorl %ecx, %ecx
movq %rcx, (%rsp)
movq (%rbx), %rax
movq (%rax,%r13,8), %r14
cmpl $0x3, 0xbc(%r14)
jl 0x2d9a8
movq 0xc0(%r14), %r15
testq %r15, %r15
je 0x2d9a8
callq 0xc5308
movl 0xbc(%r14), %eax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
mulsd %xmm0, %xmm1
cvttsd2si %xmm1, %edx
movq 0xb0(%r14), %rcx
movslq %edx, %rdx
movq (%rcx,%rdx,8), %rdx
movq 0xc0(%rdx), %r12
testq %r12, %r12
je 0x2d9a8
cmpq %r12, %r15
je 0x2d9a8
testl %eax, %eax
jle 0x2d999
xorl %esi, %esi
xorl %edx, %edx
movq (%rcx,%rsi,8), %rdi
xorl %r8d, %r8d
cmpq %r12, 0xc0(%rdi)
sete %r8b
addl %r8d, %edx
incq %rsi
cmpq %rsi, %rax
jne 0x2d97a
jmp 0x2d99b
xorl %edx, %edx
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
cmpl %ecx, %edx
jg 0x2d9ba
incq %r13
movslq 0xc(%rbx), %rax
cmpq %rax, %r13
jl 0x2d91b
jmp 0x2d9ed
movq %r15, %rdi
movq %r14, %rsi
callq 0x2a1f0
movsd 0xc8(%r14), %xmm0
movq %r12, %rdi
movq %r14, %rsi
callq 0x2a720
incq %r13
movslq 0xc(%rbx), %rax
movb $0x1, %cl
cmpq %rax, %r13
jl 0x2d917
jmp 0x2d9f3
testb $0x1, (%rsp)
je 0x2da01
incl %ebp
cmpl $0x3e8, %ebp            # imm = 0x3E8
jne 0x2d90a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
movl $0x1, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Utils/../../pkgs/R3Shapes/R3Kdtree.cpp
// Function: gaps::R3Kdtree<gaps::R3SegmentationPoint*>::FindAll(gaps::R3Point const&, double, double, gaps::RNArray<gaps::R3SegmentationPoint*>&) const
int R3Kdtree<PtrType>::
FindAll(const R3Point& query_position, RNScalar min_distance, RNScalar max_distance, RNArray<PtrType>& points) const
{
  // Check root
  if (!root) return 0;

  // Use squared distances for efficiency
  if (max_distance < 0) return 0;
  if (min_distance < 0) min_distance = 0;
  RNLength min_distance_squared = min_distance * min_distance;
  RNLength max_distance_squared = max_distance * max_distance;

  // Search nodes recursively
  FindAll(root, bbox, 
    NULL, query_position, 
    min_distance_squared, max_distance_squared, 
    NULL, NULL, 
    points);

  // Return number of points
  return points.NEntries();
}

// Assembly:
pushq %rbx
movq %rdx, %rbx
movapd %xmm0, %xmm2
movq %rsi, %r8
movq 0x50(%rdi), %rsi
testq %rsi, %rsi
sete %cl
xorpd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
seta %dl
xorl %eax, %eax
orb %cl, %dl
jne 0x2e619
maxsd %xmm2, %xmm0
mulsd %xmm0, %xmm0
mulsd %xmm1, %xmm1
movq %rdi, %rdx
xorl %ecx, %ecx
xorl %r9d, %r9d
pushq %rbx
pushq $0x0
callq 0x2e884
addq $0x10, %rsp
movl 0xc(%rbx), %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/RipcordSoftware[P]lazyflatset/test/lazyflatset/main.cpp
// Function: test(std::function<void (__gnu_cxx::__normal_iterator<unsigned int*, std::vector<unsigned int, std::allocator<unsigned int>>>, __gnu_cxx::__normal_iterator<unsigned int*, std::vector<unsigned int, std::allocator<unsigned int>>>)>, __gnu_cxx::__normal_iterator<unsigned int*, std::vector<unsigned int, std::allocator<unsigned int>>>, __gnu_cxx::__normal_iterator<unsigned int*, std::vector<unsigned int, std::allocator<unsigned int>>>, bool)
void test(TestFunction func, SourceIterator begin, SourceIterator end, bool eol = false) {
    auto start = std::chrono::steady_clock::now();
    func(begin, end);
    auto duration = std::chrono::steady_clock::now() - start;
    auto durationMS = std::chrono::duration_cast<std::chrono::milliseconds>(duration);
    
    std::cout << durationMS.count();
    
    if (eol) {
        std::cout << std::endl;
    } else {
        std::cout << ", ";
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebx
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r15
callq 0x2190
movq %r13, 0x8(%rsp)
movq %r12, (%rsp)
cmpq $0x0, 0x10(%r15)
je 0x28f0
movq %rax, %r14
leaq 0x8(%rsp), %rsi
movq %rsp, %rdx
movq %r15, %rdi
callq *0x18(%r15)
callq 0x2190
subq %r14, %rax
movabsq $0x431bde82d7b634db, %rcx # imm = 0x431BDE82D7B634DB
imulq %rcx
movq %rdx, %rsi
shrq $0x3f, %rsi
sarq $0x12, %rdx
addq %rdx, %rsi
movq 0x6743(%rip), %r14      # 0x8fd8
movq %r14, %rdi
callq 0x2130
testb %bl, %bl
je 0x28ca
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
jmp 0x28e2
movq 0x6707(%rip), %rdi      # 0x8fd8
leaq 0x3815(%rip), %rsi      # 0x60ed
movl $0x2, %edx
callq 0x2170
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x2090
// File: /workspace/github_cpp_makefile_star2_O3/RipcordSoftware[P]lazyflatset/test/lazyflatset/./../../lazyflatset.hpp
// Function: rs::LazyFlatSet<unsigned int, std::less<unsigned int>, std::equal_to<unsigned int>, rs::LazyFlatSetQuickSort<unsigned int, std::less<unsigned int>>, std::allocator<unsigned int>, false>::insert(unsigned int const&, rs::LazyFlatSet<unsigned int, std::less<unsigned int>, std::equal_to<unsigned int>, rs::LazyFlatSetQuickSort<unsigned int, std::less<unsigned int>>, std::allocator<unsigned int>, false>::insert_hint)
void insert(const value_type& k, insert_hint hint = insert_hint::no_hint) {
        if (hint == insert_hint::no_hint) {
            auto iter = lower_bound_equals(coll_, k);
            if (iter != coll_.end()) {
                *iter = k;
            } else {
                iter = lower_bound_equals(nursery_, k);
                if (iter != nursery_.end()) {
                    *iter = k;
                } else {
                    iter = search_unsorted(unsorted_, k);
                    if (iter != unsorted_.end()) {
                        *iter = k;
                    } else {
                        if (unsorted_.size() == maxUnsortedEntries_) {
                            flushUnsorted();
                        }

                        unsorted_.push_back(k);
                    }
                }
            }
        } else {
            if (unsorted_.size() == maxUnsortedEntries_) {
                flushUnsorted();
            }

            unsorted_.push_back(k);
        }
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testl %edx, %edx
je 0x401e
movq 0x48(%r14), %rsi
movq %rsi, %rax
subq 0x40(%r14), %rax
sarq $0x2, %rax
movl 0x8(%r14), %ecx
cmpq %rcx, %rax
jne 0x400a
movq %r14, %rdi
callq 0x4a24
movq 0x48(%r14), %rsi
cmpq 0x50(%r14), %rsi
je 0x406d
movl (%rbx), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x48(%r14)
jmp 0x4065
leaq 0x10(%r14), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x49d2
cmpq 0x18(%r14), %rax
jne 0x4061
leaq 0x28(%r14), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x49d2
cmpq 0x30(%r14), %rax
jne 0x4061
movq 0x40(%r14), %rdi
movq 0x48(%r14), %rsi
movq %rbx, %rdx
callq 0x4aa3
movq 0x48(%r14), %rsi
cmpq %rsi, %rax
je 0x4083
movl (%rbx), %ecx
movl %ecx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
addq $0x40, %r14
movq %r14, %rdi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x438c
movq 0x40(%r14), %rcx
subq %rcx, %rax
jmp 0x3ff1
nop
// File: /workspace/github_cpp_makefile_star2_O3/RipcordSoftware[P]lazyflatset/test/lazyflatset/./../../lazyflatset.hpp
// Function: rs::LazyFlatSet<unsigned int, std::less<unsigned int>, std::equal_to<unsigned int>, rs::LazyFlatSetQuickSort<unsigned int, std::less<unsigned int>>, std::allocator<unsigned int>, false>::merge(std::vector<unsigned int, std::allocator<unsigned int>>&, std::vector<unsigned int, std::allocator<unsigned int>>&) const
void merge(base_collection& source, base_collection& target) const {
        if (source.size() > 0) {
            Less less;
            if (target.size() == 0 || less(target.back(), source.front())) {
                target.insert(target.end(), source.cbegin(), source.cend());
            } else if (less(source.back(), target.front())) {
                target.insert(target.begin(), source.cbegin(), source.cend());
            } else {
                target.insert(target.end(), source.cbegin(), source.cend());
                std::inplace_merge(target.begin(), target.end() - source.size(), target.end(), less);
            }
        }
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq (%rsi), %rdx
movq 0x8(%rsi), %rcx
cmpq %rdx, %rcx
je 0x4bb2
movq %rsi, %r14
movq (%rbx), %rsi
movq 0x8(%rbx), %rdi
movq %rdi, %rax
subq %rsi, %rax
je 0x4ba0
movl -0x4(%rdi), %edi
cmpl (%rdx), %edi
jae 0x4bba
addq %rax, %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4f5e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl -0x4(%rcx), %edi
cmpl (%rsi), %edi
jb 0x4ba3
addq %rax, %rsi
movq %rbx, %rdi
callq 0x4f5e
movq (%rbx), %rdi
movq 0x8(%rbx), %rdx
movq (%r14), %rsi
subq 0x8(%r14), %rsi
addq %rdx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5112
nop
// File: /workspace/github_cpp_makefile_star2_O3/HQarroum[P]thread-pool/examples/bulk_insertion/main.cpp
// Function: main
int main() {
 thread::pool::pool_t pool(std::thread::hardware_concurrency() + 1);
 
 // Filling our array with `iterations` amount of functions,
 // bound to the number `42`.
 std::fill_n(callables, iterations, std::bind(static_void_function, 42));
 // Scheduling the execution in bulk.
 auto result = pool.schedule_bulk(callables, iterations);
 // Log whether the insertion was successful.
 std::cout << "The insertion has " << (result ? "succeeded" : "failed") << std::endl;
 assert(result == true);
 return (0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x2b0, %rsp            # imm = 0x2B0
callq 0x21d0
leal 0x1(%rax), %esi
leaq 0x18(%rsp), %rdi
callq 0x2592
leaq -0x68(%rip), %rax       # 0x241c
leaq 0x8(%rsp), %rbx
movq %rax, (%rbx)
movl $0x2a, 0x8(%rbx)
xorl %r14d, %r14d
leaq 0x7ce3(%rip), %r15      # 0xa180
leaq (%r15,%r14), %rdi
movq %rbx, %rsi
callq 0x3dc4
addq $0x20, %r14
cmpq $0xc80, %r14            # imm = 0xC80
jne 0x249d
leaq 0x7cc3(%rip), %rsi      # 0xa180
leaq 0x18(%rsp), %rdi
movl $0x64, %edx
callq 0x265a
movl %eax, %ebx
movq 0x7afb(%rip), %rdi      # 0x9fd0
leaq 0x3be4(%rip), %rsi      # 0x60c0
movl $0x12, %edx
callq 0x21a0
leaq 0x3be6(%rip), %rax      # 0x60d3
leaq 0x3be9(%rip), %rsi      # 0x60dd
testb %bl, %bl
cmovneq %rax, %rsi
movzbl %bl, %eax
leaq (%rax,%rax,2), %rdx
addq $0x6, %rdx
movq 0x7ac4(%rip), %r14      # 0x9fd0
movq %r14, %rdi
callq 0x21a0
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq 0x7a9e(%rip), %rdi      # 0x9fd0
callq 0x2030
movq %rax, %rdi
callq 0x2110
testb %bl, %bl
je 0x255c
leaq 0x18(%rsp), %rdi
callq 0x26b6
xorl %eax, %eax
addq $0x2b0, %rsp            # imm = 0x2B0
popq %rbx
popq %r14
popq %r15
retq
leaq 0x3b81(%rip), %rdi      # 0x60e4
leaq 0x3b89(%rip), %rsi      # 0x60f3
leaq 0x3b8b(%rip), %rcx      # 0x60fc
movl $0x22, %edx
callq 0x2100
jmp 0x257d
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x26b6
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O3/FabienBounoir[P]JustePrix-CLI/justePrix.cpp
// Function: JustePrix::JustePrix()
JustePrix::JustePrix():prixMystere(0), prixMin(1), prixMax(100), nbCoups(0)
{
    joueur = new Joueur();
    historique = new Historique();
    meilleurScore = new MeilleurScore();
    srand(time(NULL));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movaps 0x3a15(%rip), %xmm0     # 0x6010
movups %xmm0, (%rdi)
movl $0x20, %edi
callq 0x21e0
movq %rax, %r14
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x3cc3(%rip), %rdx      # 0x62de
movq %rsp, %rdi
movq %rdx, %rsi
callq 0x2ebe
movq %rsp, %rsi
movq %r14, %rdi
callq 0x4374
movq %r14, 0x18(%rbx)
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x264b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21f0
movl $0x30, %edi
callq 0x21e0
movq %rax, %r14
movq %rax, %rdi
callq 0x4468
movq %r14, 0x20(%rbx)
movl $0x38, %edi
callq 0x21e0
movq %rax, %r14
movq %rax, %rdi
callq 0x4bb8
movq %r14, 0x28(%rbx)
xorl %edi, %edi
callq 0x21b0
movl %eax, %edi
callq 0x21c0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x38, %esi
jmp 0x26cc
movq %rax, %rbx
movl $0x30, %esi
jmp 0x26cc
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x26c7
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21f0
jmp 0x26c7
movq %rax, %rbx
movl $0x20, %esi
movq %r14, %rdi
callq 0x21f0
movq %rbx, %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O3/FabienBounoir[P]JustePrix-CLI/justePrix.cpp
// Function: JustePrix::compterNbCoups(int)
void JustePrix::compterNbCoups(int prix)
{
    if(historique->enregistrerAncienCoups(prix))
    {
        if(prix > getPrixMax())
        {
            ihm->AfficherPrixSupBorne(prix, this->getPrixMax());
        }
        else if(prix < getPrixMin())
        {
            ihm->AfficherPrixInfBorne(prix, this->getPrixMin());
        }
        else
        {
            ++nbCoups;
        }       
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq 0x20(%rdi), %rdi
callq 0x451e
testb %al, %al
je 0x27c2
movl 0x8(%r14), %edx
cmpl %ebx, %edx
jge 0x27a4
movq 0x10(%r14), %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3728
movl 0x4(%r14), %edx
cmpl %ebx, %edx
jle 0x27be
movq 0x10(%r14), %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x37e0
incl 0xc(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/FabienBounoir[P]JustePrix-CLI/justePrix.cpp
// Function: JustePrix::verifierPrix(int, int)
bool JustePrix::verifierPrix(int prix, int prixMystere)
{
    #ifdef CHEAT
        cout << endl;
        cout << "\033[1;34mCHEAT [prix = " <<  getPrixMystere( ) << "]\033[0m" << endl;
    #endif
    
    this->compterNbCoups(prix);

    if(prix < prixMystere)
    {
        ihm->afficherPrixMystereSuperieur();
        return true;
    }
    else if(prix > prixMystere)
    {
        ihm->afficherPrixMystereInferieur();
        return true;
    }
    else
    {
        ihm->afficherVictoire(nbCoups, joueur->getNom());
        return false;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
callq 0x2774
cmpl %ebx, %ebp
jge 0x27ed
movq 0x10(%r14), %rdi
callq 0x356e
jmp 0x27fb
movq 0x10(%r14), %rbx
jle 0x27ff
movq %rbx, %rdi
callq 0x352a
movb $0x1, %al
jmp 0x283c
movl 0xc(%r14), %ebp
movq 0x18(%r14), %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x43aa
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x35b2
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x283a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21f0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2863
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21f0
movq %rbx, %rdi
callq 0x22f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/FabienBounoir[P]JustePrix-CLI/justePrix.cpp
// Function: JustePrix::ChoisirDifficulte()
void JustePrix::ChoisirDifficulte()
{
    char choix;
    do{
        choix = ihm->demanderDifficulte(joueur->getNom());
        if(choix == 'd' || choix == 'D')
        {
            this->setPrixMax(1000);
            meilleurScore->choisirFichierDifficulte(this->getPrixMax());
            this->creerPrixMystere();
        }
        else if(choix == 'm' || choix == 'M')
        {
            this->setPrixMax(500);
            meilleurScore->choisirFichierDifficulte(this->getPrixMax());
            this->creerPrixMystere();
        }
        else if(choix == 'f' || choix == 'F')
        {
            this->setPrixMax(100);
            meilleurScore->choisirFichierDifficulte(this->getPrixMax());
            this->creerPrixMystere();
        }
        else
        {
            cerr << "Désolé, cette difficulté n'existe pas" <<endl;
        }
    }
    while(choix != 'd' && choix != 'D' && choix != 'm' && choix != 'M' && choix != 'f' && choix != 'F');
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
leaq 0x8(%rsp), %r14
movq 0x76f2(%rip), %r15      # 0x9ff0
movq 0x10(%rbx), %r13
movq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0x43aa
movq %r13, %rdi
movq %r14, %rsi
callq 0x3898
movl %eax, %ebp
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2932
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
movl %ebp, %eax
andb $-0x21, %al
cmpb $0x4d, %al
je 0x296b
movzbl %al, %eax
cmpl $0x46, %eax
je 0x2959
cmpl $0x44, %eax
jne 0x2990
movl $0x3e8, 0x8(%rbx)       # imm = 0x3E8
movq 0x28(%rbx), %rdi
movl $0x3e8, %esi            # imm = 0x3E8
jmp 0x297b
movl $0x64, 0x8(%rbx)
movq 0x28(%rbx), %rdi
movl $0x64, %esi
jmp 0x297b
movl $0x1f4, 0x8(%rbx)       # imm = 0x1F4
movq 0x28(%rbx), %rdi
movl $0x1f4, %esi            # imm = 0x1F4
callq 0x4c20
callq 0x2060
cltd
idivl 0x8(%rbx)
addl 0x4(%rbx), %edx
movl %edx, (%rbx)
jmp 0x29cb
movl $0x28, %edx
movq %r15, %rdi
leaq 0x3681(%rip), %rsi      # 0x6020
callq 0x2210
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movzbl %bpl, %eax
addl $-0x44, %eax
cmpl $0x29, %eax
ja 0x28fe
movabsq $0x20500000205, %rcx    # imm = 0x20500000205
btq %rax, %rcx
jae 0x28fe
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2a18
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
movq %rbx, %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O3/FabienBounoir[P]JustePrix-CLI/justePrix.cpp
// Function: JustePrix::jouerNouvellePartie()
void JustePrix::jouerNouvellePartie()
{
    this->setNbCoups(0);
    historique->initialiserAncienCoups();
    ihm->afficherIntroduction(this->getPrixMin());
    this->ChoisirDifficulte();
    ihm->afficherBornes(this->getPrixMin(), this->getPrixMax());
    meilleurScore->recupererScore();
    this->jouer(); 
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x0, 0xc(%rdi)
movq 0x20(%rdi), %rdi
callq 0x4586
movq 0x10(%rbx), %rdi
movl 0x4(%rbx), %esi
callq 0x2f58
movq %rbx, %rdi
callq 0x28dc
movq 0x10(%rbx), %rdi
movl 0x4(%rbx), %esi
movl 0x8(%rbx), %edx
callq 0x3672
movq 0x28(%rbx), %rdi
callq 0x4e42
movq %rbx, %rdi
popq %rbx
jmp 0x2cde
nop
// File: /workspace/github_cpp_makefile_star2_O3/FabienBounoir[P]JustePrix-CLI/justePrix.cpp
// Function: JustePrix::demarrer()
void JustePrix::demarrer()
{
    this->setNbCoups(0);
    ihm->afficherIntroduction(this->getPrixMin());
    this->recupererNom();
    this->ChoisirDifficulte();
    ihm->afficherBornes(this->getPrixMin(), this->getPrixMax());
    meilleurScore->recupererScore();
    this->jouer();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x0, 0xc(%rdi)
movq 0x10(%rdi), %rdi
movl 0x4(%rbx), %esi
callq 0x2f58
movq %rbx, %rdi
callq 0x286c
movq %rbx, %rdi
callq 0x28dc
movq 0x10(%rbx), %rdi
movl 0x4(%rbx), %esi
movl 0x8(%rbx), %edx
callq 0x3672
movq 0x28(%rbx), %rdi
callq 0x4e42
movq %rbx, %rdi
popq %rbx
jmp 0x2cde
// File: /workspace/github_cpp_makefile_star2_O3/FabienBounoir[P]JustePrix-CLI/justePrix.cpp
// Function: JustePrix::jouer()
void JustePrix::jouer()
{
    int prix = 0;
    time_t debutChrono = time(NULL);
    do
    {
        prix = ihm->demanderPrix(joueur->getNom());
    }
    while(this->verifierPrix(prix, prixMystere));
    int chronometre = (int)time(NULL) - debutChrono;
    this->calculerTemps(chronometre);
    historique->ajouter(this->getNbCoups(), joueur->getNom());
    meilleurScore->sauvegarderScore(this->getNbCoups(), joueur->getNom());
    this->ChoisirMenu();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
xorl %edi, %edi
callq 0x21b0
movq %rax, %r14
leaq 0x18(%rsp), %r13
leaq 0x8(%rsp), %r15
movq 0x10(%rbx), %r12
movq 0x18(%rbx), %rsi
movq %r15, %rdi
callq 0x43aa
movq %r12, %rdi
movq %r15, %rsi
callq 0x33e2
movl %eax, %ebp
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x2d37
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
movl (%rbx), %edx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x27ca
testb %al, %al
jne 0x2d03
xorl %edi, %edi
callq 0x21b0
subl %r14d, %eax
movslq %eax, %rcx
imulq $-0x6e5d4c3b, %rcx, %rsi # imm = 0x91A2B3C5
shrq $0x20, %rsi
addl %ecx, %esi
movl %esi, %eax
shrl $0x1f, %eax
sarl $0xb, %esi
addl %eax, %esi
imulq $-0x77777777, %rcx, %rdx # imm = 0x88888889
shrq $0x20, %rdx
addl %ecx, %edx
movl %edx, %eax
shrl $0x1f, %eax
sarl $0x5, %edx
addl %eax, %edx
imull $0x3c, %edx, %eax
subl %eax, %ecx
movq 0x10(%rbx), %rdi
callq 0x4264
movq 0x20(%rbx), %r14
movl 0xc(%rbx), %ebp
movq 0x18(%rbx), %rsi
leaq 0x48(%rsp), %r15
movq %r15, %rdi
callq 0x43aa
movq %r14, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x449a
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2dd0
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x21f0
movq 0x28(%rbx), %r14
movl 0xc(%rbx), %ebp
movq 0x18(%rbx), %rsi
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x43aa
movq %r14, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x50ce
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2e10
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21f0
movq %rbx, %rdi
callq 0x2a20
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x38(%rsp), %r13
jmp 0x2e39
movq %rax, %rbx
leaq 0x58(%rsp), %r13
movq -0x10(%r13), %rdi
jmp 0x2e47
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x2e58
movq (%r13), %rsi
incq %rsi
callq 0x21f0
movq %rbx, %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O3/FabienBounoir[P]JustePrix-CLI/ihm.cpp
// Function: Ihm::afficherPositionScore(int)
void Ihm::afficherPositionScore(int classement)
{
    cout << endl;

    if(classement <= 1)
    {
        cout << "Vous êtes classé \033[1;31m" << classement << "er\033[0m dans les meilleurs scores" << endl;   
    }
    else
    {
        cout << "Vous êtes classé \033[1;31m" << classement << "ème\033[0m dans les meilleurs scores" << endl;    
    }
    
    cout << endl;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq 0x5e25(%rip), %rbx      # 0x9fc8
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq 0x25be(%rip), %rsi      # 0x678f
movl $0x1a, %edx
movq %rbx, %rdi
callq 0x2210
movq %rbx, %rdi
movl %ebp, %esi
callq 0x22e0
movq %rax, %r14
cmpl $0x1, %ebp
jg 0x41fe
leaq 0x25b3(%rip), %rsi      # 0x67aa
movl $0x20, %edx
jmp 0x420a
leaq 0x25c6(%rip), %rsi      # 0x67cb
movl $0x22, %edx
movq %r14, %rdi
callq 0x2210
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2100
// File: /workspace/github_cpp_makefile_star2_O3/FabienBounoir[P]JustePrix-CLI/historique.cpp
// Function: Historique::enregistrerAncienCoups(int)
bool Historique::enregistrerAncienCoups(int prix)
{
    if(find(this->ancienCoups.begin(), this->ancienCoups.end(), prix ) != this->ancienCoups.end())
    {
        return false;
    }
    else
    {
        this->ancienCoups.push_back(prix);
        return true;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %rdx
movl %esi, (%rdx)
movq 0x18(%rdi), %rdi
movq 0x20(%rbx), %rsi
callq 0x49d7
movq %rax, %r14
movq 0x20(%rbx), %r15
cmpq %r15, %rax
jne 0x4575
cmpq 0x28(%rbx), %r14
je 0x4561
movl 0xc(%rsp), %eax
movl %eax, (%r15)
leaq 0x4(%r15), %rax
movq %rax, 0x20(%rbx)
jmp 0x4575
addq $0x18, %rbx
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4a7c
cmpq %r15, %r14
sete %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/FabienBounoir[P]JustePrix-CLI/meilleurScore.cpp
// Function: MeilleurScore::choisirFichierDifficulte(int)
void MeilleurScore::choisirFichierDifficulte(int difficulte)
{
    switch(difficulte)
    {
        case 100:
            {
                this->nomFichier = "./scoreFacile.txt";
            }
            break;
         case 500:
            {
                this->nomFichier = "./scoreMoyen.txt";
            }
            break;
        case 1000:
            {
                this->nomFichier = "./scoreDifficile.txt";
            }
            break;

    }
}

// Assembly:
cmpl $0x3e8, %esi            # imm = 0x3E8
je 0x4c63
cmpl $0x1f4, %esi            # imm = 0x1F4
je 0x4c4c
cmpl $0x64, %esi
jne 0x4c7f
movq 0x20(%rdi), %rdx
addq $0x18, %rdi
leaq 0x1c05(%rip), %rcx      # 0x6849
movl $0x11, %r8d
jmp 0x4c78
movq 0x20(%rdi), %rdx
addq $0x18, %rdi
leaq 0x1c00(%rip), %rcx      # 0x685b
movl $0x10, %r8d
jmp 0x4c78
movq 0x20(%rdi), %rdx
addq $0x18, %rdi
leaq 0x1bfa(%rip), %rcx      # 0x686c
movl $0x14, %r8d
xorl %esi, %esi
jmp 0x2280
retq
// File: /workspace/github_cpp_makefile_star2_O3/FabienBounoir[P]JustePrix-CLI/meilleurScore.cpp
// Function: MeilleurScore::calculerPositionClassement(int)
int MeilleurScore::calculerPositionClassement(int score)
{
    string ligneFichierScore;
    ifstream fichierScore(this->getFichierDifficulte().c_str());
    int scoreFichier = 0;
    int classement = 0; 

    while(getline(fichierScore, ligneFichierScore)) 
    {
        stringstream convert(ligneFichierScore); 
        convert >> scoreFichier; 

        if(scoreFichier <= score)
        {
            ++classement;
        } 
    }
    return classement;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3b8, %rsp            # imm = 0x3B8
movl %esi, %ebx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x18(%rdi), %rsi
movq 0x20(%rdi), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x43d2
movq 0x28(%rsp), %rsi
leaq 0x1b0(%rsp), %r14
movq %r14, %rdi
movl $0x8, %edx
callq 0x2310
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x4cf6
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21f0
leaq 0x4(%rsp), %rax
movl $0x0, (%rax)
xorl %ebp, %ebp
leaq 0x8(%rsp), %r13
leaq 0x28(%rsp), %r15
movq 0x5294(%rip), %r12      # 0x9fa8
movq 0x1b0(%rsp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %edx
movq %r14, %rdi
movq %r13, %rsi
callq 0x2320
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x4d8b
movq %r15, %rdi
movq %r13, %rsi
movl $0x18, %edx
callq 0x22a0
movq %r15, %rdi
leaq 0x4(%rsp), %rsi
callq 0x20e0
xorl %eax, %eax
cmpl %ebx, 0x4(%rsp)
setle %al
addl %eax, %ebp
movq %r15, %rdi
movq %r12, %rsi
callq 0x2140
leaq 0xa8(%rsp), %rdi
callq 0x2090
jmp 0x4d14
leaq 0x1b0(%rsp), %rdi
callq 0x2050
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x4db4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
movl %ebp, %eax
addq $0x3b8, %rsp            # imm = 0x3B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x4e1e
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21f0
jmp 0x4e1e
movq %rax, %rbx
jmp 0x4e1e
movq %rax, %rbx
movq 0x51b5(%rip), %rsi      # 0x9fa8
leaq 0x28(%rsp), %rdi
callq 0x2140
leaq 0xa8(%rsp), %rdi
callq 0x2090
jmp 0x4e11
jmp 0x4e0e
movq %rax, %rbx
leaq 0x1b0(%rsp), %rdi
callq 0x2050
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x4e3a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
movq %rbx, %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O3/s-yata[P]louds-patricia/louds-patricia.cpp
// Function: louds::(anonymous namespace)::BitVector::add(unsigned long)
void add(uint64_t bit) {
    if (n_bits % 256 == 0) {
      words.resize((n_bits + 256) / 64);
    }
    set(n_bits, bit);
    ++n_bits;
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq 0x48(%rdi), %rsi
movq %rdi, %rbx
testb %sil, %sil
jne 0x24ba
addq $0x100, %rsi            # imm = 0x100
movq %rbx, %rdi
shrq $0x6, %rsi
callq 0x3d3e
movq 0x48(%rbx), %rsi
movq (%rbx), %rax
movl $0x1, %ecx
shlxq %rsi, %rcx, %rcx
testq %r14, %r14
je 0x24d6
shrq $0x6, %rsi
orq %rcx, (%rax,%rsi,8)
jmp 0x24e1
notq %rcx
shrq $0x6, %rsi
andq %rcx, (%rax,%rsi,8)
incq 0x48(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/s-yata[P]louds-patricia/louds-patricia.cpp
// Function: louds::(anonymous namespace)::BitVector::rank(unsigned long) const
uint64_t rank(uint64_t i) const {
    uint64_t word_id = i / 64;
    uint64_t bit_id = i % 64;
    uint64_t rank_id = word_id / 4;
    uint64_t rel_id = word_id % 4;
    uint64_t n = ranks[rank_id].abs();
    if (rel_id != 0) {
      n += ranks[rank_id].rels[rel_id - 1];
    }
    n += Popcnt(words[word_id] & ((1UL << bit_id) - 1));
    return n;
  }

// Assembly:
movq %rdx, %r8
shrq $0x8, %r8
movq %rdx, %rax
shrq $0x6, %rax
movl (%rsi,%r8,8), %ecx
movzbl 0x4(%rsi,%r8,8), %r9d
shlq $0x8, %rcx
orq %r9, %rcx
movq %rax, %r9
andq $0x3, %r9
je 0x27ef
leaq (%rsi,%r8,8), %rsi
movzbl 0x4(%r9,%rsi), %esi
addq %rsi, %rcx
andb $0x3f, %dl
bzhiq %rdx, (%rdi,%rax,8), %rax
popcntq %rax, %rax
addq %rcx, %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/smuething[P]dune-cxx11/15-allocate_shared.cc
// Function: main
int main()
{
  std::allocator<int> allocator;
  std::shared_ptr<int> p(std::allocate_shared<int>(allocator,4));
  assert(*p == 4);
  return 0;
}

// Assembly:
pushq %rax
movl $0x18, %edi
callq 0x1030
movabsq $0x100000001, %rcx      # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0x2bdc(%rip), %rcx      # 0x3d58
movq %rcx, (%rax)
movl $0x4, 0x10(%rax)
movq %rax, %rdi
callq 0x1192
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O3/Mengjintao[P]SWAPCounter/src/kmerGraph.cpp
// Function: kmerGraph::stringToLongLong(char const*, int, int, parameter*)
unsigned long long kmerGraph::stringToLongLong(const char *buf, int start, int end, parameter *parameters)
{
        unsigned long long ret = 0;
        for(int i=start; i<end; i++){
                assert(buf[i]=='A'||buf[i]=='T'||buf[i]=='C'||buf[i]=='G');
		ret <<= 2;
                ret |= ((unsigned long long)parameters->nucleotideValue[(int)buf[i]]&3);
        }
        return ret;
}

// Assembly:
subl %esi, %edx
jle 0x2670
movslq %esi, %rax
addq %rax, %rdi
xorl %esi, %esi
movl $0x80045, %r8d          # imm = 0x80045
xorl %eax, %eax
movzbl (%rdi,%rsi), %r9d
leal -0x41(%r9), %r10d
cmpl $0x13, %r10d
ja 0x2673
btl %r10d, %r8d
jae 0x2673
movzbl 0xb38(%rcx,%r9), %r9d
andl $0x3, %r9d
leaq (%r9,%rax,4), %rax
incq %rsi
cmpl %esi, %edx
jne 0x2642
retq
xorl %eax, %eax
retq
pushq %rax
leaq 0x3995(%rip), %rdi      # 0x6010
leaq 0x39c1(%rip), %rsi      # 0x6043
leaq 0x39cc(%rip), %rcx      # 0x6055
movl $0x15, %edx
callq 0x2170
nop
// File: /workspace/github_cpp_makefile_star2_O3/Mengjintao[P]SWAPCounter/src/kmerGraph.cpp
// Function: kmerGraph::longLongToString[abi:cxx11](unsigned long long, parameter*)
string kmerGraph::longLongToString(unsigned long long a, parameter *parameters)
{
	string descriptor;
        descriptor.clear();
        for(int i=0;i<parameters->hashLength;i++)
        {
                descriptor += parameters->nucleotideArray[a%4];
                a = (a>>2);
        }
        reverse(descriptor.begin(), descriptor.end());
	return descriptor;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
cmpl $0x0, 0xaf8(%rdx)
jle 0x272a
movq %rdx, %r14
movq %rsi, %r15
xorl %ebp, %ebp
movl %r15d, %eax
andl $0x3, %eax
movsbl 0xbb8(%r14,%rax), %esi
movq %rbx, %rdi
callq 0x2200
shrq $0x2, %r15
incl %ebp
cmpl 0xaf8(%r14), %ebp
jl 0x26c3
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
testq %rcx, %rcx
setne %dl
addq %rax, %rcx
decq %rcx
cmpq %rax, %rcx
seta %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x272a
incq %rax
movb -0x1(%rax), %dl
movb (%rcx), %sil
movb %sil, -0x1(%rax)
movb %dl, (%rcx)
decq %rcx
leaq 0x1(%rax), %rdx
cmpq %rcx, %rax
movq %rdx, %rax
jb 0x270f
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x2746
callq 0x2240
movq %r14, %rdi
callq 0x2460
// File: /workspace/github_cpp_makefile_star2_O3/Mengjintao[P]SWAPCounter/src/kmerGraph.cpp
// Function: kmerGraph::arcPos(unsigned long long&, unsigned long long&, char, char, int)
int kmerGraph::arcPos(unsigned long long &A, unsigned long long &B, char directA, char directB, int hashLength)
{
	int lastB;
	if(directB=='+')	lastB = B%4;
	else			lastB = 3-(B>>((hashLength-1)*2));
	
	if(directA=='-')	lastB += 4;
	assert(lastB>=0&&lastB<8);
	return lastB;
}

// Assembly:
movl %ecx, %esi
movq (%rdx), %rdx
cmpb $0x2b, %r8b
jne 0x275e
andl $0x3, %edx
jmp 0x2774
addl %r9d, %r9d
addb $-0x2, %r9b
movl %r9d, %ecx
shrq %cl, %rdx
movl $0x3, %eax
subl %edx, %eax
movl %eax, %edx
leal 0x4(%rdx), %eax
cmpb $0x2d, %sil
cmovnel %edx, %eax
cmpl $0x8, %eax
jae 0x2784
retq
pushq %rax
leaq 0x3924(%rip), %rdi      # 0x60b0
leaq 0x38b0(%rip), %rsi      # 0x6043
leaq 0x3928(%rip), %rcx      # 0x60c2
movl $0x30, %edx
callq 0x2170