LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/Jacobious52[P]Tanks/Test.cpp
// Function: test_timer()
void test_timer()
{
    printf("\nTesting Timer..\n\n");
    Timer timer(0.1, 20);

    printf("interval 0.1s ticks 20\n\n");
    while (timer.tick())
    {
        ConsoleTools::move_cursor(ConsoleTools::up, 1);
        ConsoleTools::clear_line();
        printf("%d\n", timer.get_tick_count());
    }

    timer.reset();
    printf("\n");

    Timer inf(0.05, true);
    printf("infinite ticks. break at 50. interval 0.05s\n\n");

    while (inf.tick())
    {
        ConsoleTools::move_cursor(ConsoleTools::up, 1);
        ConsoleTools::clear_line();
        printf("%d\n", inf.get_tick_count());
        if (inf.get_tick_count() >= 50)
        {
            break;
        }
    }

    TestTimerDelegate test_timer;
    test_timer.test1();
    test_timer.test2();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
leaq 0x1c10(%rip), %rdi      # 0xc4d6
callq 0x3320
movabsq $0x3fb999999999999a, %rax # imm = 0x3FB999999999999A
leaq -0x78(%rbp), %rbx
movq %rax, 0x8(%rbx)
movq $0x14, 0x10(%rbx)
movw $0x0, 0x18(%rbx)
leaq 0x1bf6(%rip), %rdi      # 0xc4e8
callq 0x3320
leaq 0x1b7a(%rip), %r14      # 0xc478
movq %rbx, %rdi
callq 0x8a88
testb %al, %al
je 0xa934
movl $0x41, %edi
movl $0x1, %esi
callq 0x38e6
callq 0x38b2
movq %rbx, %rdi
callq 0x8aac
movq %r14, %rdi
movl %eax, %esi
xorl %eax, %eax
callq 0x3060
jmp 0xa8fe
leaq -0x78(%rbp), %rdi
callq 0x8b82
movl $0xa, %edi
callq 0x32b0
movabsq $0x3fa999999999999a, %rax # imm = 0x3FA999999999999A
leaq -0x98(%rbp), %rbx
movq %rax, 0x8(%rbx)
movq $0x0, 0x10(%rbx)
movw $0x1, 0x18(%rbx)
leaq 0x1b8f(%rip), %rdi      # 0xc500
callq 0x3320
leaq 0x1afb(%rip), %r14      # 0xc478
movq %rbx, %rdi
callq 0x8a88
testb %al, %al
je 0xa9be
movl $0x41, %edi
movl $0x1, %esi
callq 0x38e6
callq 0x38b2
movq %rbx, %rdi
callq 0x8aac
movq %r14, %rdi
movl %eax, %esi
xorl %eax, %eax
callq 0x3060
movq %rbx, %rdi
callq 0x8aac
cmpl $0x31, %eax
jle 0xa97d
leaq -0x58(%rbp), %rdi
callq 0xb3ba
leaq -0x50(%rbp), %rdi
callq 0x8b08
leaq -0x30(%rbp), %rdi
callq 0x8b08
leaq 0x6398(%rip), %rax      # 0x10d78
movq %rax, -0x58(%rbp)
leaq 0x1806(%rip), %rdi      # 0xc1f1
callq 0x3320
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0xaa28
jmp 0xaa28
movq %rax, %rbx
leaq 0x636e(%rip), %rax      # 0x10d78
movq %rax, -0x58(%rbp)
leaq 0x17dc(%rip), %rdi      # 0xc1f1
callq 0x3320
xorl %eax, %eax
movq %rax, -0x30(%rbp)
movq %rax, -0x50(%rbp)
jmp 0xaa2b
jmp 0xaa28
movq %rax, %rbx
movq %rbx, %rdi
callq 0x33e0
// File: /workspace/github_cpp_makefile_star2_O1/Jacobious52[P]Tanks/Test.cpp
// Function: test_view()
void test_view()
{
    printf("\nTesting views...\n");

    View *view = new View(0, 0, 600, 600);
    view->add_child(new View(0, 0, 20, 20));
    view->add_child(new View(40, 40, 30, 50));

    assert(view->get_children()->get_count() == 2, "children count");

    LOOPV(i, view)
    {
        View *v = view->get_child(i);
        assert(v->get_size().x == (i+2)*10, "iterate");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
leaq 0x1569(%rip), %rdi      # 0xc55a
callq 0x3320
movl $0x38, %edi
callq 0x3230
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
movl $0x258, %ecx            # imm = 0x258
movl $0x258, %r8d            # imm = 0x258
callq 0xb464
movl $0x38, %edi
callq 0x3230
movq %rax, %r15
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
movl $0x14, %ecx
movl $0x14, %r8d
callq 0xb464
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9892
movl $0x38, %edi
callq 0x3230
movq %rax, %r15
movq %rax, %rdi
movl $0x28, %esi
movl $0x28, %edx
movl $0x1e, %ecx
movl $0x32, %r8d
callq 0xb464
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9892
movq %rbx, %rdi
callq 0x9888
xorl %edi, %edi
cmpq $0x2, 0x8(%rax)
sete %dil
leaq 0x13a1(%rip), %rsi      # 0xc439
callq 0xa0d0
movq %rbx, %rdi
callq 0x9888
cmpq $0x0, 0x8(%rax)
je 0xb0f7
movl $0x14, %r12d
xorl %r14d, %r14d
leaq 0x138c(%rip), %r15      # 0xc448
movq %rbx, %rdi
movq %r14, %rsi
callq 0x98ce
movq %rax, %rdi
callq 0x99f6
cltq
xorl %edi, %edi
cmpq %rax, %r12
sete %dil
movq %r15, %rsi
callq 0xa0d0
incq %r14
movq %rbx, %rdi
callq 0x9888
addq $0xa, %r12
cmpq 0x8(%rax), %r14
jb 0xb0bc
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0xb102
movq %rax, %r14
movq %r15, %rbx
jmp 0xb10d
movq %rax, %r14
movq %rbx, %rdi
callq 0x3210
movq %r14, %rdi
callq 0x33e0
// File: /workspace/github_cpp_makefile_star2_O1/Jacobious52[P]Tanks/Test.cpp
// Function: fexists(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool fexists(std::string fname)
{
    bool exists = false;
    std::ifstream file(fname.c_str(), std::ios::binary);
    exists = file.good();
    file.close();
    return exists;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
movq (%rdi), %rsi
leaq -0x218(%rbp), %rbx
movq %rbx, %rdi
movl $0x4, %edx
callq 0x3410
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl -0x1f8(%rbp,%rax), %r14d
movq %rbx, %rdi
callq 0x3090
testl %r14d, %r14d
sete %bl
leaq -0x218(%rbp), %rdi
callq 0x30c0
movl %ebx, %eax
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x218(%rbp), %rdi
callq 0x30c0
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x3a76
// File: /workspace/github_cpp_makefile_star2_O1/Jacobious52[P]Tanks/Test.cpp
// Function: test_sounds()
void test_sounds()
{
    printf("\nTesting sound files (passed/failed : found/not found)\n\n");

    assert(fexists("music.wav") == true, "music.wav");
    assert(fexists("boom.wav") == true, "boom.wav");
    assert(fexists("beep.wav") == true, "beep.wav");
    assert(fexists("fire.wav") == true, "fire.wav");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x80, %rsp
leaq 0x13bf(%rip), %rdi      # 0xc56c
callq 0x3320
leaq -0x80(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x128f(%rip), %rsi      # 0xc450
leaq 0x1291(%rip), %rdx      # 0xc459
leaq -0x90(%rbp), %rbx
movq %rbx, %rdi
callq 0x56e4
movq %rbx, %rdi
callq 0xb11d
movzbl %al, %edi
leaq 0x1267(%rip), %rsi      # 0xc450
callq 0xa0d0
movq -0x90(%rbp), %rdi
cmpq %r14, %rdi
je 0xb1ff
callq 0x3210
leaq -0x60(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0xf20(%rip), %rsi       # 0xc12e
leaq 0xf21(%rip), %rdx       # 0xc136
leaq -0x70(%rbp), %rbx
movq %rbx, %rdi
callq 0x56e4
movq %rbx, %rdi
callq 0xb11d
movzbl %al, %edi
leaq 0xefb(%rip), %rsi       # 0xc12e
callq 0xa0d0
movq -0x70(%rbp), %rdi
cmpq %r14, %rdi
je 0xb246
callq 0x3210
leaq -0x40(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0xeab(%rip), %rsi       # 0xc100
leaq 0xeac(%rip), %rdx       # 0xc108
leaq -0x50(%rbp), %rbx
movq %rbx, %rdi
callq 0x56e4
movq %rbx, %rdi
callq 0xb11d
movzbl %al, %edi
leaq 0xe86(%rip), %rsi       # 0xc100
callq 0xa0d0
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0xb28d
callq 0x3210
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x1004(%rip), %rsi      # 0xc2a0
leaq 0x1005(%rip), %rdx      # 0xc2a8
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x56e4
movq %rbx, %rdi
callq 0xb11d
movzbl %al, %edi
leaq 0xfdf(%rip), %rsi       # 0xc2a0
callq 0xa0d0
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0xb2d4
callq 0x3210
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
jmp 0xb305
movq %rax, %rbx
movq -0x50(%rbp), %rdi
jmp 0xb305
movq %rax, %rbx
movq -0x70(%rbp), %rdi
jmp 0xb305
movq %rax, %rbx
movq -0x90(%rbp), %rdi
cmpq %r14, %rdi
je 0xb30f
callq 0x3210
movq %rbx, %rdi
callq 0x33e0
// File: /workspace/github_cpp_makefile_star2_O1/Jacobious52[P]Tanks/Test.cpp
// Function: main
int main(int argc, char const *argv[])
{
    ConsoleTools::clear_screen();

    TextureTools::load_texture_file("textures.txt");

    test_point();
    test_array();
    test_view();
    test_textures();
    test_sounds();

    test_timer();

    ConsoleTools::set_cursor(0, ConsoleTools::get_terminal_size().y-1);
    ConsoleTools::end_color();

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
callq 0x3876
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x1124(%rip), %rsi      # 0xc45a
leaq 0x1129(%rip), %rdx      # 0xc466
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x56e4
movq %rbx, %rdi
callq 0x80ea
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0xb35f
callq 0x3210
callq 0xa14f
callq 0xa1c6
callq 0xafdf
callq 0xaa33
callq 0xb198
callq 0xa8b1
callq 0x38fe
shrq $0x20, %rax
leal -0x1(%rax), %esi
xorl %edi, %edi
callq 0x389c
callq 0x3838
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0xb3b1
callq 0x3210
movq %rbx, %rdi
callq 0x33e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/Jacobious52[P]Tanks/Test.cpp
// Function: TestTimerDelegate::TestTimerDelegate()
TestTimerDelegate()
    {
        timer1 = Timer(0.1, 20);
        timer1.set_delegate(this);

        timer2 = Timer(0.05, true);
        timer2.set_delegate(this);

        printf("\nTesting delegate timer\n\n");
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r15
leaq 0x59aa(%rip), %rax      # 0x10d78
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
leaq 0x28(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
xorl %eax, %eax
movw %ax, 0x40(%rdi)
movups %xmm0, 0x12(%rdi)
movups %xmm0, 0x8(%rdi)
movabsq $0x3fb999999999999a, %rcx # imm = 0x3FB999999999999A
movq %rcx, 0x10(%rdi)
movq $0x14, 0x18(%rdi)
movw %ax, 0x20(%rdi)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8b6c
xorl %eax, %eax
movq %rax, 0x28(%r15)
movabsq $0x3fa999999999999a, %rcx # imm = 0x3FA999999999999A
movq %rcx, 0x30(%r15)
movq %rax, 0x38(%r15)
movw $0x1, 0x40(%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0x8b6c
leaq 0x10e9(%rip), %rdi      # 0xc52d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3320
xorl %ecx, %ecx
movq %rcx, (%r14)
movq %rcx, (%rbx)
movq %rax, %rdi
callq 0x33e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/Jacobious52[P]Tanks/Test.cpp
// Function: TestTimerDelegate::timer_did_tick(Timer*, int)
void timer_did_tick(Timer *sender, int t)
    {
        if (sender == &timer1)
        {
            ConsoleTools::move_cursor(ConsoleTools::up, 1);
            ConsoleTools::clear_line();
            printf("delegate tick 1: %d\n", t);
        }
        else if (sender == &timer2)
        {
            ConsoleTools::move_cursor(ConsoleTools::up, 1);
            ConsoleTools::clear_line();
            printf("delegate tick 2: %d\n", t);
            if (t == 15)
            {
                timer2.end();
            }
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
leaq 0x8(%rdi), %rax
cmpq %rsi, %rax
je 0xb544
movq %rdi, %r14
addq $0x28, %r14
cmpq %rsi, %r14
jne 0xb53f
movl $0x41, %edi
movl $0x1, %esi
callq 0x38e6
callq 0x38b2
leaq 0xf57(%rip), %rdi       # 0xc47c
movl %ebx, %esi
xorl %eax, %eax
callq 0x3060
cmpl $0xf, %ebx
jne 0xb53f
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x8b4e
popq %rbx
popq %r14
popq %rbp
retq
movl $0x41, %edi
movl $0x1, %esi
callq 0x38e6
callq 0x38b2
leaq 0xf08(%rip), %rdi       # 0xc467
movl %ebx, %esi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x3060
// File: /workspace/github_cpp_makefile_star2_O1/mitchellsayer[P]FastPointCloudSegmentation/src/./point_cloud_segmenter.cc
// Function: PointCloudSegmenter::ExtractClusters(std::vector<Scanline, std::allocator<Scanline>>&)
std::vector<Vec3> PointCloudSegmenter::ExtractClusters( std::vector<Scanline>& scanlines ) {
  std::vector<Scanline>::iterator s_it;
  std::vector<Vec3>::iterator v_it;
  std::vector<Vec3> out_points;
  int i = 0;

  for (s_it = scanlines.begin(); s_it != scanlines.end(); s_it++, i++ ) {
    for (v_it = s_it->points.begin(); v_it != s_it->points.end(); v_it++) {
      if (v_it->label < this->rtable.size() && v_it->label != -3) {
        v_it->label = this->rtable[v_it->label];
        out_points.push_back(*v_it);
      }
    }
  }
  return out_points;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rdx), %r13
cmpq 0x8(%rdx), %r13
je 0x4128
movq %rdx, %r14
movq %rsi, %r15
movq 0x48(%r13), %r12
cmpq 0x50(%r13), %r12
je 0x411a
movq 0xb8(%r15), %rax
movq 0xc0(%r15), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
js 0x4083
xorps %xmm1, %xmm1
cvtsi2ss %rcx, %xmm1
jmp 0x409b
movq %rcx, %rdx
shrq %rdx
andl $0x1, %ecx
orq %rdx, %rcx
xorps %xmm1, %xmm1
cvtsi2ss %rcx, %xmm1
addss %xmm1, %xmm1
movss 0x18(%r12), %xmm0
ucomiss 0x3fd7(%rip), %xmm0     # 0x8080
jne 0x40ad
jnp 0x4111
ucomiss %xmm0, %xmm1
jbe 0x4111
cvttss2si %xmm0, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
subss 0x3fbe(%rip), %xmm0     # 0x8084
cvttss2si %xmm0, %rsi
andq %rdx, %rsi
orq %rcx, %rsi
xorps %xmm0, %xmm0
cvtsi2ssl (%rax,%rsi,4), %xmm0
movss %xmm0, 0x18(%r12)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x4106
movups (%r12), %xmm0
movups 0xc(%r12), %xmm1
movups %xmm1, 0xc(%rsi)
movups %xmm0, (%rsi)
addq $0x1c, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x4111
movq %rbx, %rdi
movq %r12, %rdx
callq 0x56b8
addq $0x1c, %r12
jmp 0x4058
addq $0x70, %r13
cmpq 0x8(%r14), %r13
jne 0x4054
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x4151
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x21c0
movq %r14, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/mitchellsayer[P]FastPointCloudSegmentation/src/./point_cloud_segmenter.cc
// Function: PointCloudSegmenter::FindNearestNeighbor(Scanline&, Scanline&, int, int, int)
int PointCloudSegmenter::FindNearestNeighbor(Scanline& scan_current, Scanline& scan_above, int start_index, int end_index, int point_index) {
  double conversion_factor = scan_above.points.size() / scan_current.points.size();
  int above_start = floor(start_index * conversion_factor);
  int above_end = floor(end_index * conversion_factor);

  // Determine nearest point to search at
  Vec3 current = scan_current.points[point_index];
  float query[3] = {current.x, current.y, current.z};

  // Set up KNN result set
  size_t result_index;
  float result_dist_squared;
  nanoflann::KNNResultSet<float> results(1);
  results.init(&result_index, &result_dist_squared);

  // Perform search
  scan_above.tree->findNeighbors(results, &query[0], nanoflann::SearchParams(10));

  if (result_dist_squared < this->th_merge * this->th_merge) {
    return scan_above.tree_point_cloud->get_label(result_index);
  }

  return  -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq 0x48(%rsi), %rax
movslq %r9d, %rcx
leaq (%rcx,%rcx,8), %rdx
leaq (%rdx,%rdx,2), %rdx
addq %rcx, %rdx
movq (%rax,%rdx), %rcx
movss 0x8(%rax,%rdx), %xmm0
leaq -0x3c(%rbp), %rdx
movq %rcx, (%rdx)
movss %xmm0, 0x8(%rdx)
xorps %xmm0, %xmm0
leaq -0x60(%rbp), %rsi
movaps %xmm0, (%rsi)
movq $0x1, 0x10(%rsi)
movq $0x0, 0x18(%rsi)
leaq -0x20(%rbp), %rax
movq %rax, (%rsi)
leaq -0x24(%rbp), %r15
movq %r15, 0x8(%rsi)
movl $0x7f7fffff, (%r15)     # imm = 0x7F7FFFFF
movq 0x68(%rbx), %rdi
leaq -0x30(%rbp), %rcx
movq $0xa, (%rcx)
movb $0x1, 0x8(%rcx)
callq 0x4f66
xorps %xmm0, %xmm0
cvtss2sd (%r15), %xmm0
movsd 0x78(%r14), %xmm1
mulsd %xmm1, %xmm1
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
ucomisd %xmm0, %xmm1
jbe 0x4226
movq 0x60(%rbx), %rax
movq -0x20(%rbp), %rcx
movq (%rax), %rdx
movq 0x8(%rax), %rax
leaq (%rcx,%rcx,4), %rcx
movq 0x20(%rax,%rcx,8), %rax
movq (%rdx), %rcx
leaq (%rax,%rax,8), %rdx
leaq (%rdx,%rdx,2), %rdx
addq %rax, %rdx
cvttss2si 0x18(%rcx,%rdx), %eax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/mitchellsayer[P]FastPointCloudSegmentation/src/./point_cloud_segmenter.cc
// Function: PointCloudSegmenter::ResolveMerge(int, int)
void PointCloudSegmenter::ResolveMerge(int x, int y) {
  int u = this->rtable.at(x);
  int v = this->rtable.at(y);

  if (u < v) {
    MergeOperation(u, v);
  } else if (u > v) {
    MergeOperation(v, u);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edx, %eax
movslq %esi, %rsi
movq 0xb8(%rdi), %r8
movq 0xc0(%rdi), %rdx
subq %r8, %rdx
sarq $0x2, %rdx
cmpq %rsi, %rdx
jbe 0x431b
cltq
cmpq %rax, %rdx
jbe 0x4324
movl (%r8,%rsi,4), %ecx
movl (%r8,%rax,4), %eax
cmpl %eax, %ecx
jge 0x42d7
cmpl $-0x1, %eax
je 0x42d1
movq 0x88(%rdi), %rdx
movl %eax, %esi
movslq %esi, %rsi
movl %ecx, (%r8,%rsi,4)
movl (%rdx,%rsi,4), %esi
cmpl $-0x1, %esi
jne 0x42c2
movl %ecx, %edx
movl %eax, %ecx
jmp 0x42f8
jle 0x4319
cmpl $-0x1, %ecx
je 0x42f6
movq 0x88(%rdi), %rdx
movl %ecx, %esi
movslq %esi, %rsi
movl %eax, (%r8,%rsi,4)
movl (%rdx,%rsi,4), %esi
cmpl $-0x1, %esi
jne 0x42e7
movl %eax, %edx
movslq %edx, %rax
movq 0x88(%rdi), %rdx
movq 0xa0(%rdi), %rsi
movslq (%rsi,%rax,4), %rdi
movl %ecx, (%rdx,%rdi,4)
movslq %ecx, %rcx
movl (%rsi,%rcx,4), %ecx
movl %ecx, (%rsi,%rax,4)
popq %rbp
retq
leaq 0x3ec0(%rip), %rdi      # 0x81e2
jmp 0x432e
leaq 0x3eb7(%rip), %rdi      # 0x81e2
movq %rax, %rsi
xorl %eax, %eax
callq 0x2240
nop
// File: /workspace/github_cpp_makefile_star2_O1/mitchellsayer[P]FastPointCloudSegmentation/src/./point_cloud_segmenter.cc
// Function: PointCloudSegmenter::MergeOperation(int, int)
void PointCloudSegmenter::MergeOperation(int u, int v) {
  int i = v;

  while (i != -1) {
    this->rtable[i] = u;
    i = this->next[i];
  }

  this->next[this->tail[u]] = v;
  this->tail[u] = this->tail[v];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $-0x1, %edx
je 0x4361
movq 0x88(%rdi), %rax
movq 0xb8(%rdi), %rcx
movl %edx, %r8d
movslq %r8d, %r8
movl %esi, (%rcx,%r8,4)
movl (%rax,%r8,4), %r8d
cmpl $-0x1, %r8d
jne 0x4350
movslq %esi, %rax
movq 0x88(%rdi), %rcx
movq 0xa0(%rdi), %rsi
movslq (%rsi,%rax,4), %rdi
movl %edx, (%rcx,%rdi,4)
movslq %edx, %rcx
movl (%rsi,%rcx,4), %ecx
movl %ecx, (%rsi,%rax,4)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/mitchellsayer[P]FastPointCloudSegmentation/src/main.cc
// Function: parseInput(std::vector<Vec3, std::allocator<Vec3>>&, PointCloudSegmenter)
void parseInput(std::vector<Vec3>& in, PointCloudSegmenter seg) {
  std::ifstream infile("../velodyne_points_1/data/0000000001.txt");
  double x, y, z, v;
  int k = 0;

  while (infile >> x >> y >> z >> v)
  {
    Vec3 pt = Vec3(x, y, z);
    if (pt.r > 0) {
      if (pt.x < seg.max_x && pt.x > -seg.max_x && pt.y < seg.max_y && pt.y > -seg.max_y && pt.z > -2) {
        if (pt.theta < 3 && pt.theta > -25) {
          in.push_back(pt);
        }
      }
    }

  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x258, %rsp            # imm = 0x258
movq %rsi, %rbx
movq %rdi, -0x50(%rbp)
leaq 0x39d3(%rip), %rsi      # 0x810f
leaq -0x278(%rbp), %rdi
movl $0x8, %edx
callq 0x22e0
leaq -0x68(%rbp), %r12
leaq -0x60(%rbp), %r13
leaq -0x58(%rbp), %r14
leaq -0x70(%rbp), %r15
leaq -0x278(%rbp), %rdi
movq %r12, %rsi
callq 0x20f0
movq %rax, %rdi
movq %r13, %rsi
callq 0x20f0
movq %rax, %rdi
movq %r14, %rsi
callq 0x20f0
movq %rax, %rdi
movq %r15, %rsi
callq 0x20f0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x4892
xorps %xmm0, %xmm0
cvtsd2ss -0x68(%rbp), %xmm0
xorps %xmm1, %xmm1
cvtsd2ss -0x60(%rbp), %xmm1
xorps %xmm2, %xmm2
cvtsd2ss -0x58(%rbp), %xmm2
leaq -0x44(%rbp), %rdi
callq 0x524e
movss -0x38(%rbp), %xmm0
ucomiss 0x38ac(%rip), %xmm0     # 0x8078
jbe 0x475d
movl 0x80(%rbx), %eax
xorps %xmm1, %xmm1
cvtsi2ss %eax, %xmm1
movss -0x44(%rbp), %xmm0
ucomiss %xmm0, %xmm1
jbe 0x475d
negl %eax
xorps %xmm1, %xmm1
cvtsi2ss %eax, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x475d
movl 0x84(%rbx), %eax
xorps %xmm1, %xmm1
cvtsi2ss %eax, %xmm1
movss -0x40(%rbp), %xmm0
ucomiss %xmm0, %xmm1
jbe 0x475d
negl %eax
xorps %xmm1, %xmm1
cvtsi2ss %eax, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x475d
movss -0x3c(%rbp), %xmm0
ucomiss 0x3858(%rip), %xmm0     # 0x808c
jbe 0x475d
movss -0x34(%rbp), %xmm0
movss 0x3849(%rip), %xmm1     # 0x8090
ucomiss %xmm0, %xmm1
jbe 0x475d
ucomiss 0x383d(%rip), %xmm0     # 0x8094
jbe 0x475d
movq -0x50(%rbp), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x4884
movups -0x44(%rbp), %xmm0
movups -0x38(%rbp), %xmm1
movups %xmm1, 0xc(%rsi)
movups %xmm0, (%rsi)
addq $0x1c, 0x8(%rdi)
jmp 0x475d
leaq -0x44(%rbp), %rdx
callq 0x56b8
jmp 0x475d
leaq -0x278(%rbp), %rdi
callq 0x2040
addq $0x258, %rsp            # imm = 0x258
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x48b2
movq %rax, %rbx
leaq -0x278(%rbp), %rdi
callq 0x2040
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O1/mitchellsayer[P]FastPointCloudSegmentation/src/main.cc
// Function: generateOutput(std::vector<Vec3, std::allocator<Vec3>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void generateOutput(std::vector<Vec3>& pts, std::string file_name) {
  std::ofstream file;
  file.open (file_name);
  std::vector<Vec3>::iterator it;
  for (it = pts.begin(); it != pts.end(); it++) {
    file << it->x << " " << it->y << " " << it->z << " " << it->label << "\n";
  }
  file.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x228(%rbp), %r15
movq %r15, %rdi
callq 0x2290
movq %r15, %rdi
movq %r14, %rsi
movl $0x10, %edx
callq 0x20a0
movq (%rbx), %r14
cmpq 0x8(%rbx), %r14
je 0x49bb
leaq 0x37d3(%rip), %r15      # 0x80e9
leaq 0x38c3(%rip), %r12      # 0x81e0
xorps %xmm0, %xmm0
cvtss2sd (%r14), %xmm0
leaq -0x228(%rbp), %rdi
callq 0x2260
movq %rax, %r13
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x21d0
xorps %xmm0, %xmm0
cvtss2sd 0x4(%r14), %xmm0
movq %r13, %rdi
callq 0x2260
movq %rax, %r13
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x21d0
xorps %xmm0, %xmm0
cvtss2sd 0x8(%r14), %xmm0
movq %r13, %rdi
callq 0x2260
movq %rax, %r13
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x21d0
xorps %xmm0, %xmm0
cvtss2sd 0x18(%r14), %xmm0
movq %r13, %rdi
callq 0x2260
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x21d0
addq $0x1c, %r14
cmpq 0x8(%rbx), %r14
jne 0x491d
leaq -0x228(%rbp), %rdi
callq 0x2210
movq 0x65ea(%rip), %rax      # 0xafb8
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq -0x220(%rbp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, -0x228(%rbp,%rcx)
callq 0x2180
leaq -0x130(%rbp), %rdi
callq 0x2060
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4a13
jmp 0x4a13
movq %rax, %rbx
leaq -0x228(%rbp), %rdi
callq 0x2230
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O1/mitchellsayer[P]FastPointCloudSegmentation/src/./point_cloud_segmenter.h
// Function: ScanlinePointCloud::ScanlinePointCloud(std::vector<Vec3, std::allocator<Vec3>>&)
ScanlinePointCloud(std::vector<Vec3> & pts) : scanline_points(pts) {
    // Filter out ground labels
    for (int i = 0; i < pts.size(); i++) {
      Vec3 point = pts[i];
      if (point.label != -3) {
        ScanlinePoint wrapper(point, i);
        filtered_points.push_back(wrapper);
      }
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movq $0x0, 0x18(%rdi)
movq (%rsi), %rax
cmpq %rax, 0x8(%rsi)
je 0x4d40
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rdi), %rcx
movq %rcx, -0x30(%rbp)
xorl %r13d, %r13d
movabsq $0x6db6db6db6db6db7, %r12 # imm = 0x6DB6DB6DB6DB6DB7
xorl %r15d, %r15d
movq 0x10(%rax,%r13), %rcx
movq %rcx, -0x70(%rbp)
movups (%rax,%r13), %xmm0
movaps %xmm0, -0x80(%rbp)
movss 0x18(%rax,%r13), %xmm0
ucomiss 0x33b4(%rip), %xmm0     # 0x8080
jne 0x4cd0
jnp 0x4d1e
movq -0x70(%rbp), %rax
movq %rax, -0x50(%rbp)
movaps -0x80(%rbp), %xmm1
movaps %xmm1, -0x60(%rbp)
movss %xmm0, -0x48(%rbp)
movq %r15, -0x40(%rbp)
movq 0x10(%rbx), %rsi
cmpq 0x18(%rbx), %rsi
je 0x4d11
movq -0x40(%rbp), %rax
movq %rax, 0x20(%rsi)
movaps -0x60(%rbp), %xmm0
movaps -0x50(%rbp), %xmm1
movups %xmm1, 0x10(%rsi)
movups %xmm0, (%rsi)
addq $0x28, 0x10(%rbx)
jmp 0x4d1e
movq -0x30(%rbp), %rdi
leaq -0x60(%rbp), %rdx
callq 0x52e8
incq %r15
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
imulq %r12, %rcx
addq $0x1c, %r13
cmpq %r15, %rcx
ja 0x4cac
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x30(%rbp), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x4d6a
movq 0x18(%rbx), %rsi
subq %rdi, %rsi
callq 0x21c0
movq %r14, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O1/mitchellsayer[P]FastPointCloudSegmentation/src/./nanoflann.hpp
// Function: nanoflann::KDTreeSingleIndexAdaptor<nanoflann::L2_Simple_Adaptor<float, ScanlinePointCloud, float>, ScanlinePointCloud, 3, unsigned long>::KDTreeSingleIndexAdaptor(int, ScanlinePointCloud const&, nanoflann::KDTreeSingleIndexAdaptorParams const&)
KDTreeSingleIndexAdaptor(const int dimensionality, const DatasetAdaptor& inputData, const KDTreeSingleIndexAdaptorParams& params = KDTreeSingleIndexAdaptorParams() ) :
			dataset(inputData), index_params(params), root_node(NULL), distance(inputData)
		{
			m_size = dataset.kdtree_get_point_count();
			m_size_at_index_build = m_size;
			dim = dimensionality;
			if (DIM>0) dim=DIM;
			m_leaf_max_size = params.leaf_max_size;

			// Create a permutable array of indices to the input vectors.
			init_vind();
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movq %rdx, 0x20(%rdi)
movq (%rcx), %rsi
movq %rsi, 0x28(%rdi)
movq %rax, 0x48(%rdi)
leaq 0x68(%rdi), %r14
movups %xmm0, 0x68(%rdi)
movups %xmm0, 0x80(%rdi)
movq %rdx, 0x90(%rdi)
movq 0x10(%rdx), %rax
subq 0x8(%rdx), %rax
sarq $0x3, %rax
movabsq $-0x3333333333333333, %rdx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rax, %rdx
movq %rdx, 0x30(%rdi)
movq %rdx, 0x38(%rdi)
movl $0x3, 0x40(%rdi)
movq (%rcx), %rax
movq %rax, 0x18(%rdi)
callq 0x6b2c
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq %r14, %rdi
callq 0x5518
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x4e0f
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x21c0
movq %r15, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/mitchellsayer[P]FastPointCloudSegmentation/src/./nanoflann.hpp
// Function: nanoflann::KDTreeSingleIndexAdaptor<nanoflann::L2_Simple_Adaptor<float, ScanlinePointCloud, float>, ScanlinePointCloud, 3, unsigned long>::buildIndex()
void buildIndex()
		{
			init_vind();
			freeIndex();
			m_size_at_index_build = m_size;
			if(m_size == 0) return;
			computeBoundingBox(root_bbox);
			root_node = divideTree(0, m_size, root_bbox );   // construct the tree
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x6b2c
movq %rbx, %rdi
callq 0x6d3e
movq 0x30(%rbx), %rax
movq %rax, 0x38(%rbx)
testq %rax, %rax
je 0x4e60
leaq 0x50(%rbx), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6d82
movq 0x30(%rbx), %rdx
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rcx
callq 0x6ef8
movq %rax, 0x48(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/mitchellsayer[P]FastPointCloudSegmentation/src/./nanoflann.hpp
// Function: bool nanoflann::KDTreeSingleIndexAdaptor<nanoflann::L2_Simple_Adaptor<float, ScanlinePointCloud, float>, ScanlinePointCloud, 3, unsigned long>::findNeighbors<nanoflann::KNNResultSet<float, unsigned long, unsigned long>>(nanoflann::KNNResultSet<float, unsigned long, unsigned long>&, float const*, nanoflann::SearchParams const&) const
bool findNeighbors(RESULTSET& result, const ElementType* vec, const SearchParams& searchParams) const
		{
			assert(vec);
            if (size() == 0)
                return false;
			if (!root_node)
                throw std::runtime_error("[nanoflann] findNeighbors() called before building the index.");
			float epsError = 1+searchParams.eps;

			distance_vector_t dists; // fixed or variable-sized container (depending on DIM)
			dists.assign((DIM>0 ? DIM : dim) ,0); // Fill it with zeros.
			DistanceType distsq = computeInitialDistances(vec, dists);
			searchLevel(result, vec, root_node, distsq, dists, epsError);  // "count_leaf" parameter removed since was neither used nor returned to the user.
            return result.full();
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
testq %rdx, %rdx
je 0x5004
movq %rdi, %r15
cmpq $0x0, 0x30(%rdi)
je 0x4ff5
cmpq $0x0, 0x48(%r15)
je 0x5023
movq %rdx, %r14
movq %rsi, %rbx
movss 0x4(%rcx), %xmm0
leaq -0x30(%rbp), %r12
movl $0x0, 0x8(%r12)
movq $0x0, (%r12)
addss 0x30cd(%rip), %xmm0     # 0x8088
movss %xmm0, -0x24(%rbp)
movq %r15, %rdi
movq %rdx, %rsi
movq %r12, %rdx
callq 0x7796
movq 0x48(%r15), %rcx
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %r12, %r8
movss -0x24(%rbp), %xmm1
callq 0x7810
movq 0x18(%rbx), %rax
cmpq 0x10(%rbx), %rax
sete %al
jmp 0x4ff7
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3221(%rip), %rdi      # 0x822c
leaq 0x321e(%rip), %rsi      # 0x8230
leaq 0x3227(%rip), %rcx      # 0x8240
movl $0x387, %edx            # imm = 0x387
callq 0x20e0
movl $0x10, %edi
callq 0x20b0
movq %rax, %rbx
leaq 0x3389(%rip), %rsi      # 0x83c0
movq %rax, %rdi
callq 0x2080
movq 0x5faa(%rip), %rsi      # 0xaff0
movq 0x5f73(%rip), %rdx      # 0xafc0
movq %rbx, %rdi
callq 0x22a0
movq %rax, %r14
movq %rbx, %rdi
callq 0x2140
movq %r14, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O1/mitchellsayer[P]FastPointCloudSegmentation/src/./vec3.h
// Function: Vec3::Vec3(float, float, float)
Vec3(float a, float b, float c) : x(a), y(b), z(c) {
      r = sqrt(x*x + y*y);
      theta = atan2(z, r) * 180 / 3.1415926;
      label = -1;
      theta_horizontal = atan2(y, x) - 3.14159265/2;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movss %xmm0, (%rdi)
movss %xmm1, 0x4(%rdi)
movss %xmm2, 0x8(%rdi)
mulss %xmm1, %xmm1
mulss %xmm0, %xmm0
addss %xmm1, %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x5282
xorps %xmm1, %xmm1
sqrtss %xmm0, %xmm1
jmp 0x528a
callq 0x22d0
movaps %xmm0, %xmm1
movss %xmm1, 0xc(%rbx)
movss 0x8(%rbx), %xmm0
callq 0x2200
mulss 0x2df7(%rip), %xmm0     # 0x8098
cvtss2sd %xmm0, %xmm0
divsd 0x2dbb(%rip), %xmm0     # 0x8068
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x10(%rbx)
movl $0xbf800000, 0x18(%rbx) # imm = 0xBF800000
movss (%rbx), %xmm1
movss 0x4(%rbx), %xmm0
callq 0x2200
cvtss2sd %xmm0, %xmm0
addsd 0x2d99(%rip), %xmm0     # 0x8070
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x14(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/mitchellsayer[P]FastPointCloudSegmentation/src/./nanoflann.hpp
// Function: nanoflann::KDTreeSingleIndexAdaptor<nanoflann::L2_Simple_Adaptor<float, ScanlinePointCloud, float>, ScanlinePointCloud, 3, unsigned long>::init_vind()
void init_vind()
		{
			// Create a permutable array of indices to the input vectors.
			m_size = dataset.kdtree_get_point_count();
			if (vind.size()!=m_size) vind.resize(m_size);
			for (size_t i = 0; i < m_size; i++) vind[i] = i;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x20(%rdi), %rcx
movq 0x10(%rcx), %rdx
subq 0x8(%rcx), %rdx
sarq $0x3, %rdx
movabsq $-0x3333333333333333, %rsi # imm = 0xCCCCCCCCCCCCCCCD
imulq %rdx, %rsi
movq %rsi, 0x30(%rdi)
subq (%rdi), %rax
sarq $0x3, %rax
cmpq %rsi, %rax
je 0x6b6f
movq %rbx, %rdi
callq 0x6b90
cmpq $0x0, 0x30(%rbx)
je 0x6b88
movq (%rbx), %rax
xorl %ecx, %ecx
movq %rcx, (%rax,%rcx,8)
incq %rcx
cmpq 0x30(%rbx), %rcx
jb 0x6b7b
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/mitchellsayer[P]FastPointCloudSegmentation/src/./nanoflann.hpp
// Function: nanoflann::KDTreeSingleIndexAdaptor<nanoflann::L2_Simple_Adaptor<float, ScanlinePointCloud, float>, ScanlinePointCloud, 3, unsigned long>::computeBoundingBox(nanoflann::CArray<nanoflann::KDTreeSingleIndexAdaptor<nanoflann::L2_Simple_Adaptor<float, ScanlinePointCloud, float>, ScanlinePointCloud, 3, unsigned long>::Interval, 3ul>&)
void computeBoundingBox(BoundingBox& bbox)
		{
			bbox.resize((DIM>0 ? DIM : dim));
			if (dataset.kdtree_get_bbox(bbox))
			{
				// Done! It was implemented in derived class
			}
			else
			{
				const size_t N = dataset.kdtree_get_point_count();
				if (!N) throw std::runtime_error("[nanoflann] computeBoundingBox() called but no data points found.");
				for (int i=0; i<(DIM>0 ? DIM : dim); ++i) {
					bbox[i].low =
					bbox[i].high = dataset_get(0,i);
				}
				for (size_t k=1; k<N; ++k) {
					for (int i=0; i<(DIM>0 ? DIM : dim); ++i) {
						if (dataset_get(k,i)<bbox[i].low) bbox[i].low = dataset_get(k,i);
						if (dataset_get(k,i)>bbox[i].high) bbox[i].high = dataset_get(k,i);
					}
				}
			}
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x20(%rdi), %rcx
movq 0x8(%rcx), %rax
movq 0x10(%rcx), %rdx
subq %rax, %rdx
je 0x6eb2
sarq $0x3, %rdx
movabsq $-0x3333333333333333, %rcx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rdx, %rcx
leaq 0x4(%rax), %rdx
leaq 0x8(%rax), %rdi
xorl %r8d, %r8d
movq %rax, %r9
testl %r8d, %r8d
je 0x6dcf
movq %rdx, %r9
cmpl $0x1, %r8d
je 0x6dcf
movq %rdi, %r9
movss (%r9), %xmm0
movss %xmm0, 0x4(%rsi,%r8,8)
movss %xmm0, (%rsi,%r8,8)
incq %r8
cmpq $0x3, %r8
jne 0x6dbb
cmpq $0x2, %rcx
jb 0x6ead
movl $0x1, %edx
leaq (%rdx,%rdx,4), %r9
leaq (%rax,%r9,8), %rdi
addq $0x4, %rdi
leaq (%rax,%r9,8), %r8
leaq (%rax,%r9,8), %r9
addq $0x8, %r9
xorl %r10d, %r10d
movq %r8, %r11
testl %r10d, %r10d
je 0x6e28
movq %rdi, %r11
cmpl $0x1, %r10d
je 0x6e28
movq %r9, %r11
movss (%rsi,%r10,8), %xmm0
ucomiss (%r11), %xmm0
jbe 0x6e53
movq %r8, %r11
testl %r10d, %r10d
je 0x6e48
movq %rdi, %r11
cmpl $0x1, %r10d
je 0x6e48
movq %r9, %r11
movss (%r11), %xmm0
movss %xmm0, (%rsi,%r10,8)
movq %r8, %r11
testl %r10d, %r10d
je 0x6e67
movq %rdi, %r11
cmpl $0x1, %r10d
je 0x6e67
movq %r9, %r11
movss (%r11), %xmm0
ucomiss 0x4(%rsi,%r10,8), %xmm0
jbe 0x6e94
movq %r8, %r11
testl %r10d, %r10d
je 0x6e88
movq %rdi, %r11
cmpl $0x1, %r10d
je 0x6e88
movq %r9, %r11
movss (%r11), %xmm0
movss %xmm0, 0x4(%rsi,%r10,8)
incq %r10
cmpq $0x3, %r10
jne 0x6e14
incq %rdx
cmpq %rcx, %rdx
jne 0x6df9
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x20b0
movq %rax, %rbx
leaq 0x12be(%rip), %rsi      # 0x8184
movq %rax, %rdi
callq 0x2080
movq 0x411b(%rip), %rsi      # 0xaff0
movq 0x40e4(%rip), %rdx      # 0xafc0
movq %rbx, %rdi
callq 0x22a0
movq %rax, %r14
movq %rbx, %rdi
callq 0x2140
movq %r14, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/mitchellsayer[P]FastPointCloudSegmentation/src/./nanoflann.hpp
// Function: nanoflann::PooledAllocator::malloc(unsigned long)
void* malloc(const size_t req_size)
		{
			/* Round size up to a multiple of wordsize.  The following expression
			    only works for WORDSIZE that is a power of 2, by masking last bits of
			    incremented size to zero.
			 */
			const size_t size = (req_size + (WORDSIZE - 1)) & ~(WORDSIZE - 1);

			/* Check whether a new block must be allocated.  Note that the first word
			    of a block is reserved for a pointer to the previous block.
			 */
			if (size > remaining) {

				wastedMemory += remaining;

				/* Allocate new storage. */
				const size_t blocksize = (size + sizeof(void*) + (WORDSIZE-1) > BLOCKSIZE) ?
							size + sizeof(void*) + (WORDSIZE-1) : BLOCKSIZE;

				// use the standard C malloc to allocate memory
				void* m = ::malloc(blocksize);
				if (!m) {
					fprintf(stderr,"Failed to allocate memory.\n");
					return NULL;
				}

				/* Fill first word of new block with pointer to previous block. */
				static_cast<void**>(m)[0] = base;
				base = m;

				size_t shift = 0;
				//int size_t = (WORDSIZE - ( (((size_t)m) + sizeof(void*)) & (WORDSIZE-1))) & (WORDSIZE-1);

				remaining = blocksize - sizeof(void*) - shift;
				loc = (static_cast<char*>(m) + sizeof(void*) + shift);
			}
			void* rloc = loc;
			loc = static_cast<char*>(loc) + size;
			remaining -= size;

			usedMemory += size;

			return rloc;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
addq $0xf, %rbx
andq $-0x10, %rbx
movq (%rdi), %rax
cmpq %rax, %rbx
jbe 0x73da
addq %rax, 0x20(%r14)
leaq 0x17(%rbx), %rax
cmpq $0x2001, %rax           # imm = 0x2001
movl $0x2000, %r12d          # imm = 0x2000
cmovaeq %rax, %r12
movq %r12, %rdi
callq 0x21f0
movq %rax, %r15
testq %rax, %rax
je 0x73fa
movq 0x8(%r14), %rax
movq %rax, (%r15)
movq %r15, 0x8(%r14)
addq $-0x8, %r12
movq %r12, (%r14)
leaq 0x8(%r15), %rax
movq %rax, 0x10(%r14)
testq %r15, %r15
je 0x73f6
movq 0x10(%r14), %rax
leaq (%rax,%rbx), %rcx
movq %rcx, 0x10(%r14)
subq %rbx, (%r14)
addq %rbx, 0x18(%r14)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0x73ed
callq 0x238f
jmp 0x73d5
nop
// File: /workspace/github_cpp_makefile_star2_O1/mitchellsayer[P]FastPointCloudSegmentation/src/./nanoflann.hpp
// Function: nanoflann::KDTreeSingleIndexAdaptor<nanoflann::L2_Simple_Adaptor<float, ScanlinePointCloud, float>, ScanlinePointCloud, 3, unsigned long>::computeMinMax(unsigned long*, unsigned long, int, float&, float&)
void computeMinMax(IndexType* ind, IndexType count, int element, ElementType& min_elem, ElementType& max_elem)
		{
			min_elem = dataset_get(ind[0],element);
			max_elem = dataset_get(ind[0],element);
			for (IndexType i=1; i<count; ++i) {
				ElementType val = dataset_get(ind[i],element);
				if (val<min_elem) min_elem = val;
				if (val>max_elem) max_elem = val;
			}
		}

// Assembly:
movq (%rsi), %r10
movq 0x20(%rdi), %rax
movq 0x8(%rax), %rdi
leaq (%r10,%r10,4), %r11
cmpl $0x1, %ecx
je 0x7420
testl %ecx, %ecx
jne 0x742a
leaq (%rdi,%r11,8), %rdi
jmp 0x7432
leaq (%rdi,%r11,8), %rdi
addq $0x4, %rdi
jmp 0x7432
leaq (%rdi,%r11,8), %rdi
addq $0x8, %rdi
movss (%rdi), %xmm0
movss %xmm0, (%r8)
movq 0x8(%rax), %rdi
leaq (%r10,%r10,4), %r10
cmpl $0x1, %ecx
je 0x7452
testl %ecx, %ecx
jne 0x745c
leaq (%rdi,%r10,8), %rdi
jmp 0x7464
leaq (%rdi,%r10,8), %rdi
addq $0x4, %rdi
jmp 0x7464
leaq (%rdi,%r10,8), %rdi
addq $0x8, %rdi
pushq %rbp
movq %rsp, %rbp
movss (%rdi), %xmm0
movss %xmm0, (%r9)
cmpq $0x2, %rdx
jb 0x74e0
movl $0x1, %edi
movq (%rsi,%rdi,8), %r10
cmpl $0x1, %ecx
je 0x7497
testl %ecx, %ecx
jne 0x74a9
leaq (%r10,%r10,4), %r10
shlq $0x3, %r10
addq 0x8(%rax), %r10
jmp 0x74b9
movq 0x8(%rax), %r11
leaq (%r10,%r10,4), %r10
leaq (%r11,%r10,8), %r10
addq $0x4, %r10
jmp 0x74b9
movq 0x8(%rax), %r11
leaq (%r10,%r10,4), %r10
leaq (%r11,%r10,8), %r10
addq $0x8, %r10
movss (%r10), %xmm0
movss (%r8), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x74cd
movss %xmm0, (%r8)
ucomiss (%r9), %xmm0
jbe 0x74d8
movss %xmm0, (%r9)
incq %rdi
cmpq %rdi, %rdx
jne 0x747c
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/mitchellsayer[P]FastPointCloudSegmentation/src/./nanoflann.hpp
// Function: nanoflann::KDTreeSingleIndexAdaptor<nanoflann::L2_Simple_Adaptor<float, ScanlinePointCloud, float>, ScanlinePointCloud, 3, unsigned long>::computeInitialDistances(float const*, nanoflann::CArray<float, 3ul>&) const
DistanceType computeInitialDistances(const ElementType* vec, distance_vector_t& dists) const
		{
			assert(vec);
			DistanceType distsq = DistanceType();

			for (int i = 0; i < (DIM>0 ? DIM : dim); ++i) {
				if (vec[i] < root_bbox[i].low) {
					dists[i] = distance.accum_dist(vec[i], root_bbox[i].low, i);
					distsq += dists[i];
				}
				if (vec[i] > root_bbox[i].high) {
					dists[i] = distance.accum_dist(vec[i], root_bbox[i].high, i);
					distsq += dists[i];
				}
			}

			return distsq;
		}

// Assembly:
testq %rsi, %rsi
je 0x77ec
xorps %xmm0, %xmm0
xorl %eax, %eax
movss (%rsi,%rax,4), %xmm1
movss 0x50(%rdi,%rax,8), %xmm2
ucomiss %xmm1, %xmm2
jbe 0x77c1
subss %xmm2, %xmm1
mulss %xmm1, %xmm1
movss %xmm1, (%rdx,%rax,4)
addss %xmm1, %xmm0
movss (%rsi,%rax,4), %xmm1
movss 0x54(%rdi,%rax,8), %xmm2
ucomiss %xmm2, %xmm1
jbe 0x77e2
subss %xmm2, %xmm1
mulss %xmm1, %xmm1
movss %xmm1, (%rdx,%rax,4)
addss %xmm1, %xmm0
incq %rax
cmpq $0x3, %rax
jne 0x77a0
retq
pushq %rbp
movq %rsp, %rbp
leaq 0xa35(%rip), %rdi       # 0x822c
leaq 0xa32(%rip), %rsi       # 0x8230
leaq 0xbf9(%rip), %rcx       # 0x83fe
movl $0x4a1, %edx            # imm = 0x4A1
callq 0x20e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/ddu1[P]polarizedtext/src/args.cc
// Function: fasttext::Args::Args()
Args::Args() {
  lr = 0.05;
  dim = 100;
  ws = 5;
  epoch = 5;
  minCount = 1;
  minCountLabel = 0;
  neg = 5;
  wordNgrams = 1;
  loss = loss_name::ns;
  model = model_name::sg;
  bucket = 2000000;
  minn = 3;
  maxn = 6;
  thread = 12;
  lrUpdateRate = 100;
  t = 1e-4;
  label = "__label__";
  verbose = 2;
  pretrainedVectors = "";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x8(%rsp)
movq %rax, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb %al, 0x10(%rdi)
leaq 0x30(%rdi), %rcx
movq %rcx, (%rsp)
movq %rcx, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movb %al, 0x30(%rdi)
leaq 0x50(%rdi), %r14
movq %r14, 0x40(%rdi)
movq %rax, 0x48(%rdi)
movb %al, 0x50(%rdi)
leaq 0xa8(%rdi), %r15
leaq 0xb8(%rdi), %r13
movq %r13, 0xa8(%rdi)
movq %rax, 0xb0(%rdi)
movb %al, 0xb8(%rdi)
leaq 0xd0(%rdi), %r12
leaq 0xe0(%rdi), %rbp
movq %rbp, 0xd0(%rdi)
movq %rax, 0xd8(%rdi)
movb %al, 0xe0(%rdi)
movabsq $0x3fa999999999999a, %rax # imm = 0x3FA999999999999A
movq %rax, 0x60(%rdi)
movaps 0xd6c3(%rip), %xmm0     # 0x11010
movups %xmm0, 0x6c(%rdi)
movaps 0xd6c8(%rip), %xmm0     # 0x11020
movups %xmm0, 0x7c(%rdi)
movaps 0xd6cd(%rip), %xmm0     # 0x11030
movups %xmm0, 0x8c(%rdi)
movl $0xc, 0x9c(%rdi)
movl $0x64, 0x68(%rdi)
movabsq $0x3f1a36e2eb1c432d, %rax # imm = 0x3F1A36E2EB1C432D
movq %rax, 0xa0(%rdi)
leaq 0xd6ad(%rip), %rcx      # 0x11040
movl $0x9, %r8d
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3390
movl $0x2, 0xc8(%rbx)
movq 0xd8(%rbx), %rdx
leaq 0xe7ef(%rip), %rcx      # 0x121ac
movq %r12, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x3390
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, 0x10(%rsp)
movq (%r12), %rdi
cmpq %rbp, %rdi
je 0x39f3
movq (%rbp), %rsi
incq %rsi
callq 0x3260
movq (%r15), %rdi
cmpq %r13, %rdi
je 0x3a07
movq (%r13), %rsi
incq %rsi
callq 0x3260
movq 0x40(%rbx), %rdi
cmpq %r14, %rdi
je 0x3a1b
movq (%r14), %rsi
incq %rsi
callq 0x3260
movq 0x20(%rbx), %rdi
cmpq (%rsp), %rdi
je 0x3a34
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x3260
movq (%rbx), %rdi
cmpq 0x8(%rsp), %rdi
je 0x3a4e
movq 0x8(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x3260
movq 0x10(%rsp), %rdi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O1/ddu1[P]polarizedtext/src/dictionary.cc
// Function: fasttext::Dictionary::Dictionary(std::shared_ptr<fasttext::Args>)
Dictionary::Dictionary(std::shared_ptr<Args> args) {
  args_ = args;
  size_ = 0;
  nwords_ = 0;
  nlabels_ = 0;
  ntokens_ = 0;
  word2int_.resize(MAX_VOCAB_SIZE);
  for (int32_t i = 0; i < MAX_VOCAB_SIZE; i++) {
    word2int_[i] = -1;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
leaq 0x28(%rdi), %r12
leaq 0x80(%rdi), %rbp
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
xorl %r13d, %r13d
movq %r13, 0x50(%rdi)
movq %rbp, 0x70(%rdi)
movq %r13, 0x78(%rdi)
movb $0x0, 0x80(%rdi)
movq (%rsi), %rax
movq %rax, (%rdi)
leaq 0x8(%rdi), %r15
addq $0x8, %rsi
movq %r15, %rdi
callq 0x7782
movq %r13, 0x58(%rbx)
movl $0x0, 0x60(%rbx)
movq %r13, 0x68(%rbx)
movl $0x1c9c380, %esi        # imm = 0x1C9C380
movq %r14, %rdi
callq 0x748a
movq (%r14), %rdi
movl $0x7270e00, %edx        # imm = 0x7270E00
movl $0xff, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3150
movq %rax, %r13
movq 0x70(%rbx), %rdi
cmpq %rbp, %rdi
je 0x49db
movq (%rbp), %rsi
incq %rsi
callq 0x3260
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x49f0
movq 0x50(%rbx), %rsi
subq %rdi, %rsi
callq 0x3260
movq %r12, %rdi
callq 0x74bc
movq (%r14), %rdi
testq %rdi, %rdi
je 0x4a0c
movq 0x20(%rbx), %rsi
subq %rdi, %rsi
callq 0x3260
movq (%r15), %rdi
testq %rdi, %rdi
je 0x4a19
callq 0x77d4
movq %r13, %rdi
callq 0x3450
nop
// File: /workspace/github_cpp_makefile_star2_O1/ddu1[P]polarizedtext/src/dictionary.cc
// Function: fasttext::Dictionary::getLabels(int)
std::vector<int32_t> Dictionary::getLabels( int32_t i) {
  assert(i >= 0);
  assert(i < nwords_);
  auto labels = words_[i].labels;
  std::vector<int32_t> label_ids;
  for( auto label : labels) {
      int32_t wid = getId(label);
      assert( wid >= nwords_ );  // 
      label_ids.push_back( wid-nwords_);
  }
  std::sort( label_ids.begin(), label_ids.end());
  return label_ids;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
testl %edx, %edx
js 0x4f21
movq %rsi, %r14
cmpl %edx, 0x5c(%rsi)
jle 0x4f40
movq %rdi, %rbx
movl %edx, %eax
movq 0x28(%r14), %rcx
imulq $0x68, %rax, %rax
leaq (%rcx,%rax), %rsi
addq $0x50, %rsi
leaq 0x30(%rsp), %r15
movq %r15, %rdi
callq 0x7590
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq (%r15), %r13
movq 0x8(%r15), %r12
cmpq %r12, %r13
je 0x4ead
leaq 0x20(%rsp), %rbp
leaq 0x10(%rsp), %r15
movq %rbp, 0x10(%rsp)
movq (%r13), %rsi
movq 0x8(%r13), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x7844
movq %r14, %rdi
movq %r15, %rsi
callq 0x4a22
movq 0x10(%r14), %rcx
movl %eax, %eax
movl (%rcx,%rax,4), %eax
subl 0x5c(%r14), %eax
jl 0x4f02
movl %eax, 0xc(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x4e80
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x4e8d
movq %rbx, %rdi
leaq 0xc(%rsp), %rdx
callq 0x8222
movq 0x10(%rsp), %rdi
cmpq %rbp, %rdi
je 0x4ea4
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3260
addq $0x20, %r13
cmpq %r12, %r13
jne 0x4e30
movq (%rbx), %r14
movq 0x8(%rbx), %r15
cmpq %r15, %r14
je 0x4ee6
movq %r15, %rax
subq %r14, %rax
sarq $0x2, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x82fd
movq %r14, %rdi
movq %r15, %rsi
callq 0x83e0
leaq 0x30(%rsp), %rdi
callq 0x761a
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xc7a2(%rip), %rdi      # 0x116ab
leaq 0xc73f(%rip), %rsi      # 0x1164f
leaq 0xc74a(%rip), %rcx      # 0x11661
movl $0x6c, %edx
callq 0x3160
leaq 0xc720(%rip), %rdi      # 0x11648
leaq 0xc720(%rip), %rsi      # 0x1164f
leaq 0xc72b(%rip), %rcx      # 0x11661
movl $0x66, %edx
callq 0x3160
leaq 0xc758(%rip), %rdi      # 0x1169f
leaq 0xc701(%rip), %rsi      # 0x1164f
leaq 0xc70c(%rip), %rcx      # 0x11661
movl $0x67, %edx
callq 0x3160
jmp 0x4f7d
movq %rax, %r14
movq 0x10(%rsp), %rdi
cmpq %rbp, %rdi
je 0x4f80
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0x4f80
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x4f94
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x3260
leaq 0x30(%rsp), %rdi
callq 0x761a
movq %r14, %rdi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O1/ddu1[P]polarizedtext/src/dictionary.cc
// Function: fasttext::Dictionary::discard(int, float) const
bool Dictionary::discard(int32_t id, real rand) const {
  assert(id >= 0);
  assert(id < nwords_);
  if (args_->model == model_name::sup) return false;
  return rand > pdiscard_[id];
}

// Assembly:
pushq %rax
testl %esi, %esi
js 0x5351
cmpl %esi, 0x5c(%rdi)
jle 0x5370
movq (%rdi), %rax
cmpl $0x3, 0x8c(%rax)
jne 0x5342
xorl %eax, %eax
jmp 0x534f
movl %esi, %eax
movq 0x40(%rdi), %rcx
ucomiss (%rcx,%rax,4), %xmm0
seta %al
popq %rcx
retq
leaq 0xc4d5(%rip), %rdi      # 0x1182d
leaq 0xc2f0(%rip), %rsi      # 0x1164f
leaq 0xc39f(%rip), %rcx      # 0x11705
movl $0x84, %edx
callq 0x3160
leaq 0xc3c6(%rip), %rdi      # 0x1173d
leaq 0xc2d1(%rip), %rsi      # 0x1164f
leaq 0xc380(%rip), %rcx      # 0x11705
movl $0x85, %edx
callq 0x3160
nop