LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/JohnPapad[P]Mini-Search-Engine/minisearch.cpp
// Function: manage_whitespace(char*, unsigned int, unsigned int, unsigned int&, int**, int&)
bool manage_whitespace(char * rest_line, unsigned int lwidth, unsigned int init_llen, unsigned int & curr_llen,
                       int ** underline_info, int & underline_info_size)
{
    unsigned int whitespace = calc_whitespace(rest_line); //calculate the whitespace from the beginning of the rest content
    if (whitespace == 0)
    {//the whole rest content is whitespace
        if (underline_info_size > 0)
        {//if there are some words to be underlined
            underline(init_llen, curr_llen, underline_info, underline_info_size, 1);
        }

        return 1;  //send stop signal
    }
    else
    {
        for(unsigned int i = 0; i < whitespace; i++)
        {//print whitespace space by space
            if ((curr_llen + 1) > lwidth)
            {// if there is no free space left in terminal's line
                if (underline_info_size > 0)
                {
                    underline(init_llen, curr_llen, underline_info, underline_info_size, 0);
                }
                else
                {
                    init_newline(init_llen, curr_llen);
                }
            }

            curr_llen++;
            cout<<" ";
        }

        return 0;  //keep printing
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %rbx
movq %r8, 0x10(%rsp)
movq %rcx, %r15
movl %edx, 0x8(%rsp)
movl %esi, %r13d
callq 0x3250
testl %eax, %eax
movl %eax, 0xc(%rsp)
je 0x3504
movq 0x4b24(%rip), %rbp      # 0x7fd0
leaq 0x206e(%rip), %r14      # 0x5521
movl %eax, %r12d
movl (%r15), %eax
incl %eax
cmpl %r13d, %eax
jbe 0x34ea
cmpl $0x0, (%rbx)
jle 0x34de
movl 0x8(%rsp), %edi
movq %r15, %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rcx
xorl %r8d, %r8d
callq 0x328b
jmp 0x34ea
movl 0x8(%rsp), %edi
movq %r15, %rsi
callq 0x3411
incl (%r15)
movl $0x1, %edx
movq %rbp, %rdi
movq %r14, %rsi
callq 0x2120
decl %r12d
jne 0x34b6
jmp 0x3523
cmpl $0x0, (%rbx)
jle 0x3523
movl 0x8(%rsp), %edi
movq %r15, %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rcx
movl $0x1, %r8d
callq 0x328b
cmpl $0x0, 0xc(%rsp)
sete %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/JohnPapad[P]Mini-Search-Engine/trie.cpp
// Function: my_trie::destroy(my_trie::node*)
void my_trie::destroy(node * n)
{
    if (n != NULL)
    {
        destroy(n->down);
        destroy(n->right);
        if(n->pl_ptr != NULL)
        { //delete node's posting list before deleting the node itself
            delete n->pl_ptr;
        }
        delete n;
        trie_size--;
    }
}

// Assembly:
testq %rsi, %rsi
je 0x4089
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rsi
callq 0x4032
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x4032
movq 0x18(%r14), %r15
testq %r15, %r15
je 0x4075
movq %r15, %rdi
callq 0x4570
movl $0x18, %esi
movq %r15, %rdi
callq 0x2110
movl $0x20, %esi
movq %r14, %rdi
callq 0x2110
decl (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/JohnPapad[P]Mini-Search-Engine/trie.cpp
// Function: my_trie::print(bool)
void my_trie::print(bool full_print)
{
    if(first == NULL)
    {
        cout<<"-> Trie cannot be printed because it is empty !"<<endl;
        return;
    }

    if(full_print == 1)
    {
        cout<<"-----> Printing whole trie <-----"<<endl;
    }
    else
    {
        cout<<"---> Printing document frequency vector <---"<<endl;
    }

    print_subtrie(first, full_print); //print trie recursively starting from the root
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
cmpq $0x0, 0x8(%rdi)
je 0x4234
movl %esi, %ebp
movq %rdi, %rbx
movq 0x3daf(%rip), %rdi      # 0x7fd0
testb %bpl, %bpl
je 0x427a
leaq 0x1283(%rip), %rsi      # 0x54b0
movl $0x21, %edx
jmp 0x4286
movq 0x3d95(%rip), %rbx      # 0x7fd0
leaq 0x123e(%rip), %rsi      # 0x5480
movl $0x2f, %edx
movq %rbx, %rdi
callq 0x2120
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x20d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x20a0
leaq 0x1251(%rip), %rsi      # 0x54d2
movl $0x2c, %edx
callq 0x2120
movq 0x3d3e(%rip), %r14      # 0x7fd0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x20d0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20a0
movq 0x8(%rbx), %rsi
movzbl %bpl, %edx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x42ce
nop
// File: /workspace/github_cpp_makefile_star2_O3/JohnPapad[P]Mini-Search-Engine/trie.cpp
// Function: my_trie::print_subtrie(my_trie::node*, bool)
void my_trie::print_subtrie(node * n, bool full_print)
{
    if (n != NULL)
    {
        if(n->pl_ptr != NULL)
        {
            n->pl_ptr->print(full_print);
        }
        print_subtrie(n->down, full_print);
        print_subtrie(n->right, full_print);
    }
}

// Assembly:
testq %rsi, %rsi
je 0x430b
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movzbl %dl, %ebp
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x42f0
movl %ebp, %esi
callq 0x4376
movq 0x10(%rbx), %rsi
movq %r14, %rdi
movl %ebp, %edx
callq 0x42ce
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0x42e0
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/JohnPapad[P]Mini-Search-Engine/posting_list.cpp
// Function: posting_list::print(bool)
void posting_list::print(bool full_print)
{
    if (full_print == 0) //only print df
    {
        cout<<word<<"  "<<pl_size<<endl;
        return;
    }

    node * temp = first;
    if (first == NULL)
    {
        cout<<"Posting list is empty"<<endl;
        return;
    }

    cout<<"-> word:'"<<word<<"'  "<<pl_size<<"  ";

    while(temp != NULL) //print whole posting list
    {
        cout<<"["<<temp->doc_id<<", "<<temp->freq<<"]"<<"  ";
        temp = temp->next;
    }

    cout<<endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
testl %esi, %esi
je 0x43da
movq 0x8(%r12), %r14
movq 0x3c3c(%rip), %rbx      # 0x7fd0
testq %r14, %r14
je 0x4400
leaq 0x1175(%rip), %rsi      # 0x5515
movl $0x9, %edx
movq %rbx, %rdi
callq 0x2120
movq 0x10(%r12), %r15
testq %r15, %r15
je 0x4466
movq %r15, %rdi
callq 0x2050
movq 0x3c06(%rip), %rdi      # 0x7fd0
movq %r15, %rsi
movq %rax, %rdx
callq 0x2120
jmp 0x4484
movq 0x10(%r12), %rbx
testq %rbx, %rbx
je 0x4419
movq %rbx, %rdi
callq 0x2050
movq 0x3bdd(%rip), %rdi      # 0x7fd0
movq %rbx, %rsi
movq %rax, %rdx
callq 0x2120
jmp 0x4437
leaq 0x10f8(%rip), %rsi      # 0x54ff
movl $0x15, %edx
movq %rbx, %rdi
callq 0x2120
jmp 0x4537
movq 0x3bb0(%rip), %rax      # 0x7fd0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
leaq (%rax,%rcx), %rdi
movl 0x20(%rax,%rcx), %esi
orl $0x1, %esi
callq 0x2240
movq 0x3b92(%rip), %rbx      # 0x7fd0
leaq 0x10db(%rip), %rsi      # 0x5520
movl $0x2, %edx
movq %rbx, %rdi
callq 0x2120
movl (%r12), %esi
movq %rbx, %rdi
callq 0x2090
movq %rax, %rbx
jmp 0x4537
movq 0x3b63(%rip), %rax      # 0x7fd0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
leaq (%rax,%rcx), %rdi
movl 0x20(%rax,%rcx), %esi
orl $0x1, %esi
callq 0x2240
leaq 0x1094(%rip), %rsi      # 0x551f
movl $0x3, %edx
movq %rbx, %rdi
callq 0x2120
movl (%r12), %esi
movq %rbx, %rdi
callq 0x2090
leaq 0x1075(%rip), %rsi      # 0x5520
movl $0x2, %edx
movq %rax, %rdi
callq 0x2120
leaq 0xfa0(%rip), %r15       # 0x545f
leaq 0x105d(%rip), %r12      # 0x5523
leaq 0x1059(%rip), %r13      # 0x5526
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2120
movl (%r14), %esi
movq %rbx, %rdi
callq 0x2090
movq %rax, %rbp
movl $0x2, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2120
movl 0x4(%r14), %esi
movq %rbp, %rdi
callq 0x2090
movq %rax, %rbp
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x2120
movl $0x2, %edx
movq %rbp, %rdi
leaq 0xff7(%rip), %rsi       # 0x5520
callq 0x2120
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0x44cd
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x20d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20a0
// File: /workspace/github_cpp_makefile_star2_O3/JohnPapad[P]Mini-Search-Engine/posting_list.cpp
// Function: posting_list::~posting_list()
posting_list::~posting_list()
{
    node * temp = first;
    node * temp2;

    while(temp != NULL) //iterate list
    {
        temp2 = temp->next;
        delete temp;
        temp = temp2;
        pl_size--;
    }

    free(word);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x4598
movq 0x8(%rdi), %r14
movl $0x10, %esi
callq 0x2110
decl (%rbx)
movq %r14, %rdi
testq %r14, %r14
jne 0x4580
movq 0x10(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2140
// File: /workspace/github_cpp_makefile_star2_O3/JohnPapad[P]Mini-Search-Engine/posting_list.cpp
// Function: posting_list::update(char*, unsigned int)
void posting_list::update(char * word, unsigned int doc_id)
{ //create new list node if doc id is not contained in the list or increase its term frequency otherwise
  // posting list is sorted
    node * temp = first;
    node * prev_temp;
    node * n;

    if(first == NULL)
    { // list is empty
        n = create_node(doc_id);
        first = n;
        this->word = (char *) malloc((strlen(word) + 1) * sizeof(char));
        strcpy(this->word, word);
        pl_size++;
    }
    else
    { // list already exists
        while(1)
        {
            if(temp == NULL)
            {// we have iterated the whole list and doc id does not exist. so it will be added at the end of the list
                n = create_node(doc_id);
                pl_size++;
                prev_temp->next = n;
                break;
            }

            if (temp->doc_id == doc_id)
            { // doc id exists
                temp->freq++;     //increase its term frequency
                break;
            }
            else if(temp->doc_id < doc_id)
            { //continue searching
                prev_temp = temp;
                temp = temp->next;
            }
            else
            {//because the list is sorted and the current doc id is bigger than the inserting one
             //we do not have to keep looking the rest of the list (the rest stored doc ids will be different than the inserting one)
             // doc id will be added here
                n = create_node(doc_id);
                pl_size++;
                n->next = temp;

                if(prev_temp == NULL)
                { //we be added at the start of the list
                    first = n;
                }
                else
                {
                    prev_temp->next = n;
                }

                break;
            }
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rdi, %rbx
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x4615
movq %rax, %r14
cmpl %ebp, (%rax)
je 0x465b
jae 0x4661
movq 0x8(%r14), %rax
movq %r14, %r15
testq %rax, %rax
jne 0x45dd
movl $0x10, %edi
callq 0x2100
movl %ebp, (%rax)
movl $0x1, 0x4(%rax)
movq $0x0, 0x8(%rax)
incl (%rbx)
movq %rax, 0x8(%r14)
jmp 0x4689
movq %rsi, %r14
movl $0x10, %edi
callq 0x2100
movl %ebp, (%rax)
movl $0x1, 0x4(%rax)
movq $0x0, 0x8(%rax)
movq %rax, 0x8(%rbx)
movq %r14, %rdi
callq 0x2050
leaq 0x1(%rax), %rdi
callq 0x2170
movq %rax, 0x10(%rbx)
movq %rax, %rdi
movq %r14, %rsi
callq 0x20c0
incl (%rbx)
jmp 0x4689
incl 0x4(%r14)
jmp 0x4689
movl $0x10, %edi
callq 0x2100
movl %ebp, (%rax)
movl $0x1, 0x4(%rax)
incl (%rbx)
movq %r14, 0x8(%rax)
testq %r15, %r15
je 0x4685
movq %rax, 0x8(%r15)
jmp 0x4689
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/JohnPapad[P]Mini-Search-Engine/posting_list.cpp
// Function: posting_list::add_doc_id_to_array(unsigned int*, unsigned int&)
unsigned int * posting_list::add_doc_id_to_array(unsigned int * unq_doc_ids, unsigned int & unq_doc_ids_size)
{// adding posting list's doc ids to an array. if a posting list's doc id is already contained in the array do not add it again
    node * temp = first;
    while(temp != NULL) //iterating posting list
    {
        bool doc_id_exists = 0;
        for(unsigned int i = 0; i < unq_doc_ids_size; i++)
        { // checking if current doc id is already contained in the array
            if (unq_doc_ids[i] == temp->doc_id)
            {
                doc_id_exists = 1;  // already exists
                break;
            }
        }

        if(doc_id_exists == 0)
        { //if current doc id is not already contained in the array add it now
            unq_doc_ids_size++;
            unq_doc_ids = (unsigned int *) realloc(unq_doc_ids, unq_doc_ids_size * sizeof(unsigned int));
            unq_doc_ids[unq_doc_ids_size - 1] = temp->doc_id;
        }

        temp = temp->next;
    }

    return unq_doc_ids;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rax
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0x46fb
movq %rdx, %rbx
movl (%rdx), %esi
testl %esi, %esi
je 0x46d7
movl (%r14), %ecx
movl %esi, %edx
xorl %edi, %edi
cmpl %ecx, (%rax,%rdi,4)
je 0x46f2
incq %rdi
cmpq %rdi, %rdx
jne 0x46ca
incl %esi
movl %esi, (%rbx)
shlq $0x2, %rsi
movq %rax, %rdi
callq 0x2220
movl (%r14), %ecx
movl (%rbx), %esi
leal -0x1(%rsi), %edx
movl %ecx, (%rax,%rdx,4)
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0x46bf
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/apps/confview/confview.cpp
// Function: GLUTStop()
void GLUTStop(void)
{
  // Write configuration
  if (output_configuration_filename) {
    if (!WriteConfigurationFile(configuration, output_configuration_filename)) exit(-1);
  }

  // Destroy window 
  glutDestroyWindow(GLUTwindow);

  // Exit
  exit(0);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq 0x14441e(%rip), %rbx    # 0x16ba58
testq %rbx, %rbx
jne 0x27651
movl 0x14441b(%rip), %edi    # 0x16ba60
callq 0xf2ee6
xorl %edi, %edi
callq 0x23b30
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xa6650
movq %r14, %rdi
xorl %esi, %esi
callq 0x23ff0
cmpb $0x1, 0x144431(%rip)    # 0x16baa0
jne 0x27691
leaq 0xd2c24(%rip), %rdi     # 0xfa29c
movq %rbx, %rsi
xorl %eax, %eax
callq 0x23080
movq 0x13e897(%rip), %rax    # 0x165f20
movq (%rax), %rdi
callq 0x23ac0
movq 0x144218(%rip), %rax    # 0x16b8b0
leaq 0x144211(%rip), %rdi    # 0x16b8b0
movq %rbx, %rsi
movl $0x1, %edx
callq *0x98(%rax)
testl %eax, %eax
jne 0x276bb
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x23b30
cmpb $0x1, 0x1443de(%rip)    # 0x16baa0
jne 0x2763f
leaq 0x8(%rsp), %rdi
callq 0xa66b2
leaq 0xd2be4(%rip), %rdi     # 0xfa2bd
movb $0x1, %al
callq 0x23080
movl 0x1441de(%rip), %esi    # 0x16b8c4
leaq 0xd2be7(%rip), %rdi     # 0xfa2d4
xorl %eax, %eax
callq 0x23080
movl 0x1441da(%rip), %esi    # 0x16b8d4
leaq 0xd2be4(%rip), %rdi     # 0xfa2e5
xorl %eax, %eax
callq 0x23080
movq 0x13e811(%rip), %rax    # 0x165f20
movq (%rax), %rdi
callq 0x23ac0
jmp 0x2763f
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/apps/confview/confview.cpp
// Function: DrawCameras(int)
static void
DrawCameras(int color_scheme = RGBD_INDEX_COLOR_SCHEME)
{
  // Draw cameras
  for (int i = 0; i < configuration.NImages(); i++) {
    RGBDImage *image = configuration.Image(i);
    if (!CheckVisibility(image, selected_position)) continue;
    if ((color_scheme != RGBD_INDEX_COLOR_SCHEME) && (i == selected_image_index))
      image->DrawCamera(RGBD_HIGHLIGHT_COLOR_SCHEME);
    else image->DrawCamera(color_scheme);
  }
}

// Assembly:
cmpl $0x0, 0x143922(%rip)    # 0x16b8c4
jle 0x2800d
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
xorl %r15d, %r15d
movl $0x4, %ebp
movq 0x1438fc(%rip), %rax    # 0x16b8b8
movq (%rax,%r15,8), %r14
movq %r14, %rdi
callq 0x2abb9
testl %eax, %eax
je 0x27ff4
movl 0x13ea16(%rip), %eax    # 0x1669e8
cmpq %rax, %r15
movl %ebx, %esi
cmovel %ebp, %esi
cmpl $0x3, %ebx
movq (%r14), %rax
cmovel %ebx, %esi
movq %r14, %rdi
movsd 0xd204a(%rip), %xmm0    # 0xfa038
callq *0xc0(%rax)
incq %r15
movslq 0x1438c6(%rip), %rax    # 0x16b8c4
cmpq %rax, %r15
jl 0x27fb5
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/apps/confview/confview.cpp
// Function: DrawBBoxes(int)
static void
DrawBBoxes(int color_scheme = RGBD_INDEX_COLOR_SCHEME)
{
  // Draw pixels of all images as bboxs in world space
  for (int i = 0; i < configuration.NImages(); i++) {
    RGBDImage *image = configuration.Image(i);
    if ((color_scheme != RGBD_INDEX_COLOR_SCHEME) && (i == selected_image_index)) image->DrawBBox(RGBD_HIGHLIGHT_COLOR_SCHEME);
    else image->DrawBBox(color_scheme);
  }
}

// Assembly:
cmpl $0x0, 0x1438af(%rip)    # 0x16b8c4
jle 0x28060
pushq %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
xorl %r14d, %r14d
movl $0x4, %ebp
movl 0x13e9bd(%rip), %eax    # 0x1669e8
cmpq %rax, %r14
movl %ebx, %esi
cmovel %ebp, %esi
cmpl $0x3, %ebx
movq 0x14387b(%rip), %rax    # 0x16b8b8
movq (%rax,%r14,8), %rdi
movq (%rdi), %rax
cmovel %ebx, %esi
callq *0xc8(%rax)
incq %r14
movslq 0x14386d(%rip), %rax    # 0x16b8c4
cmpq %rax, %r14
jl 0x28025
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/apps/confview/confview.cpp
// Function: DrawFaces(int)
static void
DrawFaces(int color_scheme = RGBD_INDEX_COLOR_SCHEME)
{
  // Draw surfaces
  for (int i = 0; i < configuration.NSurfaces(); i++) {
    RGBDSurface *surface = configuration.Surface(i);
    if ((color_scheme != RGBD_INDEX_COLOR_SCHEME) && (i == selected_image_index)) surface->DrawFaces(RGBD_HIGHLIGHT_COLOR_SCHEME);
    else surface->DrawFaces(color_scheme);
  }
}

// Assembly:
cmpl $0x0, 0x14386c(%rip)    # 0x16b8d4
jle 0x280b0
pushq %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
xorl %r14d, %r14d
movl $0x4, %ebp
movl 0x13e96a(%rip), %eax    # 0x1669e8
cmpq %rax, %r14
movl %ebx, %esi
cmovel %ebp, %esi
cmpl $0x3, %ebx
movq 0x143838(%rip), %rax    # 0x16b8c8
movq (%rax,%r14,8), %rdi
movq (%rdi), %rax
cmovel %ebx, %esi
callq *0x60(%rax)
incq %r14
movslq 0x14382d(%rip), %rax    # 0x16b8d4
cmpq %rax, %r14
jl 0x28078
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/apps/confview/confview.cpp
// Function: DrawPoints(int, int)
static void
DrawPoints(int color_scheme = RGBD_PHOTO_COLOR_SCHEME, int skip = 1)
{
  // Draw pixels of all images as points in world space
  for (int i = 0; i < configuration.NImages(); i++) {
    RGBDImage *image = configuration.Image(i);
    if (!image->DepthChannel()) continue;
    if ((color_scheme != RGBD_INDEX_COLOR_SCHEME) && (i == selected_image_index)) image->DrawPoints(RGBD_HIGHLIGHT_COLOR_SCHEME, skip);
    else image->DrawPoints(color_scheme, skip);
  }
}

// Assembly:
cmpl $0x0, 0x14380c(%rip)    # 0x16b8c4
jle 0x28119
pushq %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
xorl %r14d, %r14d
movl $0x4, %ebp
movq 0x1437e9(%rip), %rax    # 0x16b8b8
movq (%rax,%r14,8), %rdi
cmpl $0x4, 0x24(%rdi)
jl 0x28106
movq 0x18(%rdi), %rax
cmpq $0x0, 0x18(%rax)
je 0x28106
movl 0x13e8fe(%rip), %eax    # 0x1669e8
cmpq %rax, %r14
movl %ebx, %esi
cmovel %ebp, %esi
cmpl $0x3, %ebx
movq (%rdi), %rax
cmovel %ebx, %esi
movl $0x1, %edx
callq *0xd8(%rax)
incq %r14
movslq 0x1437b4(%rip), %rax    # 0x16b8c4
cmpq %rax, %r14
jl 0x280c8
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/apps/confview/confview.cpp
// Function: DrawSurfels(int, int)
static void
DrawSurfels(int color_scheme = RGBD_PHOTO_COLOR_SCHEME, int skip = 1)
{
  // Draw pixels of all images as surfels in world space
  for (int i = 0; i < configuration.NImages(); i++) {
    RGBDImage *image = configuration.Image(i);
    if (!image->DepthChannel()) continue;
    if ((color_scheme != RGBD_INDEX_COLOR_SCHEME) && (i == selected_image_index)) image->DrawSurfels(RGBD_HIGHLIGHT_COLOR_SCHEME, skip);
    else image->DrawSurfels(color_scheme, skip);
  }
}

// Assembly:
cmpl $0x0, 0x1437a3(%rip)    # 0x16b8c4
jle 0x28182
pushq %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
xorl %r14d, %r14d
movl $0x4, %ebp
movq 0x143780(%rip), %rax    # 0x16b8b8
movq (%rax,%r14,8), %rdi
cmpl $0x4, 0x24(%rdi)
jl 0x2816f
movq 0x18(%rdi), %rax
cmpq $0x0, 0x18(%rax)
je 0x2816f
movl 0x13e895(%rip), %eax    # 0x1669e8
cmpq %rax, %r14
movl %ebx, %esi
cmovel %ebp, %esi
cmpl $0x3, %ebx
movq (%rdi), %rax
cmovel %ebx, %esi
movl $0x1, %edx
callq *0xe0(%rax)
incq %r14
movslq 0x14374b(%rip), %rax    # 0x16b8c4
cmpq %rax, %r14
jl 0x28131
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/apps/confview/confview.cpp
// Function: DrawQuads(int, int)
static void
DrawQuads(int color_scheme = RGBD_PHOTO_COLOR_SCHEME, int skip = 1)
{
  // Draw pixels of all images as quads in world space
  for (int i = 0; i < configuration.NImages(); i++) {
    RGBDImage *image = configuration.Image(i);
    if (!image->DepthChannel()) continue;
    if ((color_scheme != RGBD_INDEX_COLOR_SCHEME) && (i == selected_image_index)) image->DrawQuads(RGBD_HIGHLIGHT_COLOR_SCHEME, skip);
    else image->DrawQuads(color_scheme, skip);
  }
}

// Assembly:
cmpl $0x0, 0x14373a(%rip)    # 0x16b8c4
jle 0x281eb
pushq %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
xorl %r14d, %r14d
movl $0x4, %ebp
movq 0x143717(%rip), %rax    # 0x16b8b8
movq (%rax,%r14,8), %rdi
cmpl $0x4, 0x24(%rdi)
jl 0x281d8
movq 0x18(%rdi), %rax
cmpq $0x0, 0x18(%rax)
je 0x281d8
movl 0x13e82c(%rip), %eax    # 0x1669e8
cmpq %rax, %r14
movl %ebx, %esi
cmovel %ebp, %esi
cmpl $0x3, %ebx
movq (%rdi), %rax
cmovel %ebx, %esi
movl $0x1, %edx
callq *0xe8(%rax)
incq %r14
movslq 0x1436e2(%rip), %rax    # 0x16b8c4
cmpq %rax, %r14
jl 0x2819a
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/apps/confview/confview.cpp
// Function: GLUTMotion(int, int)
void GLUTMotion(int x, int y)
{
  // Invert y coordinate
  y = GLUTwindow_height - y;

  // Compute mouse movement
  int dx = x - GLUTmouse[0];
  int dy = y - GLUTmouse[1];
  
  // Update mouse drag
  GLUTmouse_drag += dx*dx + dy*dy;

  // Check if control key is down
  if (GLUTmodifiers & GLUT_ACTIVE_CTRL) {
    // Update rubber box
    if (rubber_box_active) {
      DrawRubberBox();
      rubber_box_corners[1] = R2Point(x, y);
      DrawRubberBox();
    }
    else {
      rubber_box_active = TRUE;
      rubber_box_corners[0] = R2Point(x, y);
      rubber_box_corners[1] = R2Point(x, y);
      DrawRubberBox();
    }
  }
  else {
    // World in hand navigation 
    if (GLUTbutton[0]) viewer.RotateWorld(1.0, center, x, y, dx, dy);
    else if (GLUTbutton[1]) viewer.ScaleWorld(1.0, center, x, y, dx, dy);
    else if (GLUTbutton[2]) viewer.TranslateWorld(1.0, center, x, y, dx, dy);
    if (GLUTbutton[0] || GLUTbutton[1] || GLUTbutton[2]) glutPostRedisplay();
  }

  // Remember mouse position 
  GLUTmouse[0] = x;
  GLUTmouse[1] = y;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %edi, %ebp
movl 0x13e7a4(%rip), %ebx    # 0x1669e0
subl %esi, %ebx
movl %edi, %r8d
subl 0x14385c(%rip), %r8d    # 0x16baa4
movl %ebx, %r9d
subl 0x143856(%rip), %r9d    # 0x16baa8
movl %r8d, %eax
imull %r8d, %eax
movl %r9d, %ecx
imull %r9d, %ecx
addl 0x143846(%rip), %eax    # 0x16baac
addl %ecx, %eax
movl %eax, 0x14383e(%rip)    # 0x16baac
testb $0x2, 0x14383b(%rip)    # 0x16bab0
jne 0x282a8
cmpl $0x0, 0x14383a(%rip)    # 0x16bab8
je 0x2831c
leaq 0x143725(%rip), %rdi    # 0x16b9b0
leaq 0x143706(%rip), %rsi    # 0x16b998
movsd 0xd1d76(%rip), %xmm0    # 0xfa010
movl %ebp, %edx
movl %ebx, %ecx
callq 0x39136
jmp 0x2836e
cvtsi2sd %ebp, %xmm0
cvtsi2sd %ebx, %xmm1
cmpb $0x1, 0x1437fd(%rip)    # 0x16bab4
movsd %xmm0, 0x8(%rsp)
movsd %xmm1, (%rsp)
jne 0x282cb
callq 0x283a3
jmp 0x282ee
movb $0x1, 0x1437e2(%rip)    # 0x16bab4
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0xa1036
leaq 0x14367a(%rip), %rdi    # 0x16b960
movq %r14, %rsi
callq 0xa116e
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movsd 0x8(%rsp), %xmm0
movsd (%rsp), %xmm1
callq 0xa1036
leaq 0x143663(%rip), %rdi    # 0x16b970
movq %r14, %rsi
callq 0xa116e
callq 0x283a3
jmp 0x2838e
cmpl $0x0, 0x143799(%rip)    # 0x16babc
je 0x28346
leaq 0x143684(%rip), %rdi    # 0x16b9b0
leaq 0x143665(%rip), %rsi    # 0x16b998
movsd 0xd1cd5(%rip), %xmm0    # 0xfa010
movl %ebp, %edx
movl %ebx, %ecx
callq 0x390da
jmp 0x2836e
cmpl $0x0, 0x143773(%rip)    # 0x16bac0
je 0x2836e
leaq 0x14365a(%rip), %rdi    # 0x16b9b0
leaq 0x14363b(%rip), %rsi    # 0x16b998
movsd 0xd1cab(%rip), %xmm0    # 0xfa010
movl %ebp, %edx
movl %ebx, %ecx
callq 0x38fe8
cmpl $0x0, 0x143743(%rip)    # 0x16bab8
jne 0x28389
cmpl $0x0, 0x14373e(%rip)    # 0x16babc
jne 0x28389
cmpl $0x0, 0x143739(%rip)    # 0x16bac0
je 0x2838e
callq 0xecbf0
movl %ebp, 0x143710(%rip)    # 0x16baa4
movl %ebx, 0x14370e(%rip)    # 0x16baa8
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/apps/confview/confview.cpp
// Function: DrawRubberBox()
static void 
DrawRubberBox(void)
{
  // Set rendering modes
  glDrawBuffer(GL_FRONT);
  glDisable(GL_DEPTH_TEST);
  glDepthMask(0);
  glLineStipple(1, 0xFF00);
  glEnable(GL_LINE_STIPPLE);
  glLogicOp(GL_XOR);
  glEnable(GL_COLOR_LOGIC_OP);

  // Set projection matrix
  glMatrixMode(GL_PROJECTION);  
  glPushMatrix();
  glLoadIdentity();
  gluOrtho2D(0, GLUTwindow_width, 0, GLUTwindow_height);

  // Set model view matrix
  glMatrixMode(GL_MODELVIEW);
  glPushMatrix();
  glLoadIdentity();

  // Draw box
  RNGrfxBegin(RN_GRFX_LINE_LOOP);
  RNLoadRgb(1.0, 1.0, 1.0);
  R2LoadPoint(rubber_box_corners[0][0], rubber_box_corners[0][1]);
  R2LoadPoint(rubber_box_corners[0][0], rubber_box_corners[1][1]);
  R2LoadPoint(rubber_box_corners[1][0], rubber_box_corners[1][1]);
  R2LoadPoint(rubber_box_corners[1][0], rubber_box_corners[0][1]);
  RNGrfxEnd();

  // Reset projection matrix
  glMatrixMode(GL_PROJECTION);
  glPopMatrix();

  // Reset model view matrix
  glMatrixMode(GL_MODELVIEW);
  glPopMatrix();

  // Reset rendering modes
  glDisable(GL_COLOR_LOGIC_OP);
  glDisable(GL_LINE_STIPPLE);
  glEnable(GL_DEPTH_TEST);
  glDepthMask(1);
  glDrawBuffer(GL_BACK);
  glFlush();
}

// Assembly:
pushq %rax
movl $0x404, %edi            # imm = 0x404
callq 0x23dc0
movl $0xb71, %edi            # imm = 0xB71
callq 0x231f0
xorl %edi, %edi
callq 0x23510
movl $0x1, %edi
movl $0xff00, %esi           # imm = 0xFF00
callq 0x23b10
movl $0xb24, %edi            # imm = 0xB24
callq 0x23830
movl $0x1506, %edi           # imm = 0x1506
callq 0x24320
movl $0xbf2, %edi            # imm = 0xBF2
callq 0x23830
movl $0x1701, %edi           # imm = 0x1701
callq 0x23ce0
callq 0x23f90
callq 0x23c70
cvtsi2sdl 0x13e5d4(%rip), %xmm1 # 0x1669dc
cvtsi2sdl 0x13e5d0(%rip), %xmm3 # 0x1669e0
xorps %xmm0, %xmm0
xorps %xmm2, %xmm2
callq 0x23570
movl $0x1700, %edi           # imm = 0x1700
callq 0x23ce0
callq 0x23f90
callq 0x23c70
movl $0x2, %edi
callq 0x23190
movsd 0xd1bcf(%rip), %xmm0    # 0xfa010
movaps %xmm0, %xmm1
movaps %xmm0, %xmm2
callq 0x23ea0
movsd 0x14350c(%rip), %xmm0   # 0x16b960
movsd 0x14350c(%rip), %xmm1   # 0x16b968
callq 0x23640
movsd 0x1434f7(%rip), %xmm0   # 0x16b960
movsd 0x143507(%rip), %xmm1   # 0x16b978
callq 0x23640
movsd 0x1434f2(%rip), %xmm0   # 0x16b970
movsd 0x1434f2(%rip), %xmm1   # 0x16b978
callq 0x23640
movsd 0x1434dd(%rip), %xmm0   # 0x16b970
movsd 0x1434cd(%rip), %xmm1   # 0x16b968
callq 0x23640
callq 0x23c80
movl $0x1701, %edi           # imm = 0x1701
callq 0x23ce0
callq 0x241f0
movl $0x1700, %edi           # imm = 0x1700
callq 0x23ce0
callq 0x241f0
movl $0xbf2, %edi            # imm = 0xBF2
callq 0x231f0
movl $0xb24, %edi            # imm = 0xB24
callq 0x231f0
movl $0xb71, %edi            # imm = 0xB71
callq 0x23830
movl $0x1, %edi
callq 0x23510
movl $0x405, %edi            # imm = 0x405
callq 0x23dc0
popq %rax
jmp 0x23dd0
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/apps/confview/confview.cpp
// Function: GLUTInterface()
void GLUTInterface(void)
{
  // Open window
  int argc = 0;
  char *argv[1];
  argv[argc++] = RNStrdup("conf2texture");
  glutInit(&argc, argv);
  glutInitWindowPosition(100, 100);
  glutInitWindowSize(GLUTwindow_width, GLUTwindow_height);
  glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
  GLUTwindow = glutCreateWindow("Configuration Viewer");
  
  // Initialize grfx (after create context because calls glewInit)
  RNInitGrfx();

  // Initialize graphics modes  
  glEnable(GL_DEPTH_TEST);
  glEnable(GL_CULL_FACE);

  // Initialize lighting
  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity();
  static GLfloat lmodel_ambient[] = { 0.2, 0.2, 0.2, 1.0 };
  glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);
  glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);
  glEnable(GL_NORMALIZE);

  // Define headlight
  static GLfloat light0_diffuse[] = { 0.5, 0.5, 0.5, 1.0 };
  static GLfloat light0_position[] = { 0.0, 0.0, 1.0, 0.0 };
  glLightfv(GL_LIGHT0, GL_DIFFUSE, light0_diffuse);
  glLightfv(GL_LIGHT0, GL_POSITION, light0_position);
  glEnable(GL_LIGHT0);

  // Initialize GLUT callback functions 
  glutDisplayFunc(GLUTRedraw);
  glutReshapeFunc(GLUTResize);
  glutKeyboardFunc(GLUTKeyboard);
  glutSpecialFunc(GLUTSpecial);
  glutMouseFunc(GLUTMouse);
  glutMotionFunc(GLUTMotion);

  // Reset viewer
  ResetViewer();

  // Run main loop -- never returns 
  glutMainLoop();
}

// Assembly:
subq $0x18, %rsp
leaq 0xd0635(%rip), %rdi     # 0xfa27a
callq 0xa95bf
leaq 0xc(%rsp), %rdi
movl $0x1, (%rdi)
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
callq 0xed865
movl $0x64, %edi
movl $0x64, %esi
callq 0xeddb5
movl 0x13cd65(%rip), %edi    # 0x1669dc
movl 0x13cd63(%rip), %esi    # 0x1669e0
callq 0xeddcb
movl $0x12, %edi
callq 0xeddea
leaq 0xd05f4(%rip), %rdi     # 0xfa287
callq 0xf2d9a
movl %eax, 0x141dc2(%rip)    # 0x16ba60
callq 0xa6738
movl $0xb71, %edi            # imm = 0xB71
callq 0x23830
movl $0xb44, %edi            # imm = 0xB44
callq 0x23830
movl $0x1700, %edi           # imm = 0x1700
callq 0x23ce0
callq 0x23c70
leaq 0x13cd33(%rip), %rsi    # 0x166a00
movl $0xb53, %edi            # imm = 0xB53
callq 0x24230
movl $0xb51, %edi            # imm = 0xB51
movl $0x1, %esi
callq 0x23150
movl $0xba1, %edi            # imm = 0xBA1
callq 0x23830
leaq 0x13cd19(%rip), %rdx    # 0x166a10
movl $0x4000, %edi           # imm = 0x4000
movl $0x1201, %esi           # imm = 0x1201
callq 0x240d0
leaq 0x13cd13(%rip), %rdx    # 0x166a20
movl $0x4000, %edi           # imm = 0x4000
movl $0x1203, %esi           # imm = 0x1203
callq 0x240d0
movl $0x4000, %edi           # imm = 0x4000
callq 0x23830
leaq -0x2611(%rip), %rdi     # 0x2771c
callq 0xec2ec
leaq -0x1b4d(%rip), %rdi     # 0x281ec
callq 0xec341
leaq -0x6e8(%rip), %rdi      # 0x2965d
callq 0xec383
leaq -0xcdb(%rip), %rdi      # 0x29076
callq 0xec3cb
leaq -0x1862(%rip), %rdi     # 0x284fb
callq 0xec714
leaq -0x1b3d(%rip), %rdi     # 0x2822c
callq 0xec7a4
callq 0x29409
callq 0xefeab
addq $0x18, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/SoftwearDevelopment[P]xattr_syscall_wrapper/listxattr.cc
// Function: void print_with_newline<char*, std::ostream>(char*, char*, std::ostream&)
void print_with_newline(Itr s, Itr end, Os &out) {
  while (s < end) {
    char *next = std::find(s, end, '\0');
    size_t slen = next - s;

    if (next == end) {
      std::cerr << "error: Found string that is not \\0 terminated "
                << "at the end of the xattr list. Exiting confused.";
      exit(1);
    }

    out.write(s, slen);
    out << std::endl;

    s += slen + 1;
  }

}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
cmpq %rsi, %rdi
jae 0x1742
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r13
leaq 0xf(%rsp), %r15
movb $0x0, 0xf(%rsp)
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1915
cmpq %r14, %rax
je 0x1750
movq %rax, %r12
movq %rax, %rdx
subq %r13, %rdx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1170
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1110
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x10c0
incq %r12
movq %r12, %r13
cmpq %r14, %r12
jb 0x16e4
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x2899(%rip), %rdi      # 0x3ff0
leaq 0x981(%rip), %rsi       # 0x20df
callq 0x1120
leaq 0x9a4(%rip), %rsi       # 0x210e
movq %rax, %rdi
callq 0x1120
movl $0x1, %edi
callq 0x1160
// File: /workspace/github_cpp_makefile_star2_O3/Cell-veto[P]postlhc/./ecmc.hpp
// Function: ChainRunner<Jellium3, Monodisperse2D>::optimize_sr_lr_split(AbstractStorage*)
virtual
    void optimize_sr_lr_split (AbstractStorage *stor_)
    {
        stor_t *stor = downcast (stor_);

        const int num_samples = 1000;
        double try_splits[] = {  2.1,  1.6,  1.7,  2.3,  2.9,  1.8,  1.5,  3.6,
            0.8,  3.9,  3.5, 0.9,  3.4,  2. ,  1.2,  1.4,  1.9,  3.1,  3.7,  3.,
            3.3,  2.4, 2.2,  2.5,  2.8,  2.7,  1. ,  0.6,  0.7,  3.2,  1.3,  3.8,
            2.6, 1.1 };

        uint64_t smallest_time_so_far = time_for_collisions (stor, try_splits[0], num_samples);
        int best_split_so_far = 0;

        const int num_splits = sizeof(try_splits) / sizeof (try_splits[0]);

        for (int i = 1; i != num_splits; ++i)
        {
            uint64_t time_now = time_for_collisions (stor, try_splits[i], num_samples);
            if (time_now < smallest_time_so_far)
            {
                smallest_time_so_far = time_now;
                best_split_so_far = i;
            }
        }

        std::cerr << "info best sr_lr_split " << try_splits[best_split_so_far] <<"\n";
        set_parameter ("sr_lr_split", try_splits[best_split_so_far]);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x40e626
movq %rax, %r14
movsd 0x1bcbe0(%rip), %xmm0   # 0x5ca0e8
movq %rbx, %rdi
movq %rax, %rsi
movl $0x3e8, %edx            # imm = 0x3E8
callq 0x40e648
movq %rax, %r15
xorl %ebp, %ebp
movl $0x1, %r13d
leaq 0x1bf296(%rip), %r12    # 0x5cc7c0
movsd (%r12,%r13,8), %xmm0
movq %rbx, %rdi
movq %r14, %rsi
movl $0x3e8, %edx            # imm = 0x3E8
callq 0x40e648
cmpq %r15, %rax
cmovbl %r13d, %ebp
cmovbq %rax, %r15
incq %r13
cmpq $0x22, %r13
jne 0x40d52a
movq $0x655aa0, %r14         # imm = 0x655AA0
leaq 0x1bcf66(%rip), %rsi    # 0x5ca4c8
movl $0x16, %edx
movq %r14, %rdi
callq 0x4b0120
movslq %ebp, %rax
movsd (%r12,%rax,8), %xmm0
movsd %xmm0, (%rsp)
movq %r14, %rdi
callq 0x4b1380
leaq 0x1cd7de(%rip), %rsi    # 0x5dad6a
movl $0x1, %edx
movq %rax, %rdi
callq 0x4b0120
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1bbc4f(%rip), %rsi    # 0x5c91f8
leaq 0x1bbc53(%rip), %rdx    # 0x5c9203
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x4083fe
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
movsd (%rsp), %xmm0
callq *0x18(%rax)
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x40d5e5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x442d20
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x40d60e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x442d20
movq %rbx, %rdi
callq 0x4f63f0
// File: /workspace/github_cpp_makefile_star2_O3/Cell-veto[P]postlhc/./ecmc.hpp
// Function: ChainRunner<Jellium3, Monodisperse3D>::calibrate(AbstractStorage*)
virtual
    void calibrate (AbstractStorage *stor_)
    {
        stor_t *stor = downcast (stor_);
        double chexp = measure_chain_expansion (stor, 0);
        double Lmax = stor->periods ().max ();
        calib_constant = Lmax / chexp / 2;

        target_epc = factor_quantity (stor->num_particles (), trunc_periods (stor));
        target_tdisppc = trunc_periods (stor);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x41823a
movq %rax, %r14
xorl %r12d, %r12d
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
movl $0x64, %ecx
callq 0x4196ae
movsd %xmm0, 0x18(%rsp)
movq (%r14), %rax
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq *0x28(%rax)
movsd (%r15), %xmm0
movsd 0x8(%r15), %xmm1
xorl %eax, %eax
ucomisd %xmm0, %xmm1
seta %al
maxsd %xmm0, %xmm1
shll $0x3, %eax
movsd 0x10(%r15), %xmm0
ucomisd %xmm1, %xmm0
movl $0x10, %ecx
cmovbeq %rax, %rcx
movsd 0x20(%rsp,%rcx), %xmm0
divsd 0x18(%rsp), %xmm0
mulsd 0x1b27f7(%rip), %xmm0   # 0x5ca0f0
movsd %xmm0, 0x28(%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x30(%rax)
movups 0x50(%r14), %xmm0
movaps %xmm0, (%rsp)
movq 0x60(%r14), %rcx
movq %rcx, 0x10(%rsp)
movq %rax, %xmm1
punpckldq 0x1b26ba(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x1b26c2(%rip), %xmm1   # 0x5c9ff0
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movsd (%rsp), %xmm1
mulsd 0x8(%rsp), %xmm1
addq $0x50, %r14
mulsd 0x10(%rsp), %xmm1
divsd %xmm1, %xmm0
movsd 0x1b288d(%rip), %xmm1   # 0x5ca1e8
callq 0x4ecf40
movsd (%rsp,%r12,8), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x20(%rsp,%r12,8)
incq %r12
cmpq $0x3, %r12
jne 0x417960
movq 0x30(%rsp), %rax
movq %rax, 0x2498(%rbx)
movups 0x20(%rsp), %xmm0
movups %xmm0, 0x2488(%rbx)
movups (%r14), %xmm0
movq 0x10(%r14), %rax
movq %rax, 0x24b0(%rbx)
movups %xmm0, 0x24a0(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/Cell-veto[P]postlhc/./ecmc.hpp
// Function: ChainRunner<Jellium3, Monodisperse2D>::collide(AbstractStorage*, double)
virtual
    void collide (AbstractStorage *stor_, double disp_per_particle)
    {
        walltime -= gclock ();
        stor_t *stor = downcast (stor_);
        unsigned num_chains = 1 + stor->num_particles () * disp_per_particle / calib_constant;
        this->run (stor, num_chains, calib_constant);
        walltime += gclock ();
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movsd %xmm0, (%rsp)
movq %rsi, %r14
movq %rdi, %rbx
callq 0x43f4a4
subq %rax, 0x24a0(%rbx)
movq %r14, %rdi
callq 0x40e626
movq %rax, %r14
movq (%rax), %rax
movq %r14, %rdi
callq *0x30(%rax)
movq %rax, %xmm0
punpckldq 0x1bc872(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x1bc87a(%rip), %xmm0   # 0x5c9ff0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
mulsd (%rsp), %xmm1
movsd 0x28(%rbx), %xmm0
divsd %xmm0, %xmm1
addsd 0x1bb880(%rip), %xmm1   # 0x5c9018
cvttsd2si %xmm1, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x412a84
callq 0x43f4a4
addq %rax, 0x24a0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/Cell-veto[P]postlhc/./ipl.hpp
// Function: PowerLawInteraction::PowerLawInteraction()
PowerLawInteraction ()
    {
        // we set beta = 1.  scale density accordingly!
        gamma = 1.;
        // sr_lr_split = cutoff for a truncated IPL.  otherwise, it's the
        // handshake distance between probing events and direct enumeration.
        sr_lr_split = 5.8;

        // built-in self-test, will leave exponent at 32 at the end
        double rsq_list[] = { 1e-6, 1e-2, 1., 1e2, 1e6 };
        double ex_list[] = { 1024., 6., 0., .5, /*-.5,*/ 1., 32. };
        for (double rsq : rsq_list)
        for (double ex : ex_list)
        {
            set_parameter ("exponent", ex);
            double delta = repulsive_lift (rsq, 1e-2);
            if (! (delta <= 0.))
            {
                std::cerr << "ipl: self-test error\n" << ABORT;
            }
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, (%rdi)
movabsq $0x4017333333333333, %rax # imm = 0x4017333333333333
movq %rax, 0x18(%rdi)
movaps 0x1bc10c(%rip), %xmm0   # 0x5ca070
movaps %xmm0, 0x70(%rsp)
movaps 0x1bc110(%rip), %xmm0   # 0x5ca080
movaps %xmm0, 0x80(%rsp)
movabsq $0x412e848000000000, %rax # imm = 0x412E848000000000
movq %rax, 0x90(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x50(%rsp)
movaps 0x1bc0f7(%rip), %xmm0   # 0x5ca090
movaps %xmm0, 0x40(%rsp)
movapd 0x1bc0fa(%rip), %xmm0   # 0x5ca0a0
movupd %xmm0, 0x58(%rsp)
movabsq $0x4040000000000000, %rax # imm = 0x4040000000000000
movq %rax, 0x68(%rsp)
leaq 0x30(%rsp), %r13
xorl %eax, %eax
leaq 0x1bc25e(%rip), %r14    # 0x5ca227
leaq 0x1bc25f(%rip), %r15    # 0x5ca22f
leaq 0x20(%rsp), %r12
movq %rax, 0x8(%rsp)
movsd 0x70(%rsp,%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
xorl %ebp, %ebp
movsd 0x40(%rsp,%rbp), %xmm0
movsd %xmm0, 0x18(%rsp)
movq %r13, 0x20(%rsp)
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x4083fe
movq %rbx, %rdi
movq %r12, %rsi
movsd 0x18(%rsp), %xmm0
callq 0x40e0c2
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x40e02f
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x442d20
movq %rbx, %rdi
movsd 0x10(%rsp), %xmm0
movsd 0x1bafd0(%rip), %xmm1   # 0x5c9010
callq 0x40e244
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jb 0x40e07e
addq $0x8, %rbp
cmpq $0x30, %rbp
jne 0x40dfe8
movq 0x8(%rsp), %rax
addq $0x8, %rax
cmpq $0x28, %rax
jne 0x40dfd5
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq $0x655aa0, %rdi         # imm = 0x655AA0
leaq 0x1bc1a4(%rip), %rsi    # 0x5ca230
callq 0x4b0650
leaq 0x246569(%rip), %rsi    # 0x654601
movq %rax, %rdi
callq 0x43f8ce
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x40e0ba
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x442d20
movq %rbx, %rdi
callq 0x4f63f0
// File: /workspace/github_cpp_makefile_star2_O3/Cell-veto[P]postlhc/./ipl.hpp
// Function: PowerLawInteraction::set_parameter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, double)
void set_parameter (string_ref name, double value)
    {
        if (name == "strength")
        {
            if (! (value >= 0.))
                rt_error ("Invalid strength for power law");
            gamma = value;
        }
        else if (name == "exponent")
        {
            exponent = value;
        }
        else if (name == "sr_lr_split")
        {
            if (! (value > 0.))
                rt_error ("Invalid sr_lr_split for power law");
            sr_lr_split = value;
        }
        else
        {
            rt_error ("Invalid parameter: " + name);
        }

        // for compatibility with conventional normalization
        if (exponent == 0)
            stren = gamma;
        else
            stren = gamma * fabs (exponent);
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movsd %xmm0, (%rsp)
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1bc16b(%rip), %rsi    # 0x5ca246
movq %r14, %rdi
callq 0x4c2b40
testl %eax, %eax
je 0x40e12e
leaq 0x1bc139(%rip), %rsi    # 0x5ca227
movq %r14, %rdi
callq 0x4c2b40
testl %eax, %eax
je 0x40e16f
leaq 0x1bb0f7(%rip), %rsi    # 0x5c91f8
movq %r14, %rdi
callq 0x4c2b40
testl %eax, %eax
jne 0x40e1bb
xorpd %xmm0, %xmm0
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x40e1da
movapd %xmm1, %xmm0
leaq 0x18(%rbx), %rax
jmp 0x40e178
xorpd %xmm0, %xmm0
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
movq %rbx, %rax
movapd %xmm1, %xmm0
jae 0x40e178
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1bc0fb(%rip), %rsi    # 0x5ca24f
leaq 0x1bc112(%rip), %rdx    # 0x5ca26d
leaq 0x8(%rsp), %rdi
callq 0x4083fe
leaq 0x8(%rsp), %rdi
callq 0x43f581
leaq 0x10(%rbx), %rax
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
movsd (%rbx), %xmm0
movsd 0x10(%rbx), %xmm1
movapd 0x1bbed3(%rip), %xmm2   # 0x5ca060
andpd %xmm1, %xmm2
mulsd %xmm0, %xmm2
xorpd %xmm3, %xmm3
cmpeqsd %xmm1, %xmm3
movapd %xmm3, %xmm1
andnpd %xmm2, %xmm1
andpd %xmm0, %xmm3
orpd %xmm1, %xmm3
movlpd %xmm3, 0x8(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x1bc0ce(%rip), %rsi    # 0x5ca290
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rdx
callq 0x407c44
movq %rbx, %rdi
callq 0x43f581
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1bc084(%rip), %rsi    # 0x5ca26e
leaq 0x1bc09e(%rip), %rdx    # 0x5ca28f
leaq 0x8(%rsp), %rdi
callq 0x4083fe
leaq 0x8(%rsp), %rdi
callq 0x43f581
jmp 0x40e209
jmp 0x40e218
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
jne 0x40e22e
jmp 0x40e23b
movq %rax, %rbx
jmp 0x40e23b
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x40e23b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x442d20
movq %rbx, %rdi
callq 0x4f63f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Cell-veto[P]postlhc/jellium3.cpp
// Function: Jellium3::notify_error_bound(AbstractStorage const*, double)
void notify_error_bound (const AbstractStorage *stor,
        double err_bound)
    {
        const unsigned DIM = stor->dimension ();

        if (error_bound != err_bound || period != stor->periods ())
        {
            error_bound = err_bound;
            period = stor->periods ();

            if (DIM >= exponent + 3)
                std::cerr << "jellium3: exponent " << exponent
                    << " too small for dimension " << DIM << ABORT;

            switch (DIM)
            {
            case 2:
                for (unsigned n = 0; n != DIM; ++n)
                    calibrate <2> (n);
                return;
            case 3:
                for (unsigned n = 0; n != DIM; ++n)
                    calibrate <3> (n);
                return;
            default:
                std::cerr << "jellium3: DIM = " << DIM
                    << " not implemented" << ABORT;
            }
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x20(%rax)
movl %eax, %ebp
movsd 0x38(%rbx), %xmm0
movsd 0x8(%rsp), %xmm1
ucomisd %xmm1, %xmm0
jne 0x40e86c
jnp 0x40e8ef
movapd %xmm1, %xmm0
movsd %xmm0, 0x38(%rbx)
movq (%r14), %rax
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq *0x28(%rax)
movq 0x10(%r15), %rax
movq %rax, 0x30(%rbx)
movups (%r15), %xmm0
movups %xmm0, 0x20(%rbx)
movl %ebp, %eax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
movsd 0x10(%rbx), %xmm1
addsd 0x1bb8a3(%rip), %xmm1   # 0x5ca150
ucomisd %xmm1, %xmm0
jae 0x40e941
cmpl $0x2, %ebp
je 0x40e8da
cmpl $0x3, %ebp
jne 0x40e97c
xorl %ebp, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x40f402
incl %ebp
cmpl $0x3, %ebp
jne 0x40e8c7
jmp 0x40e936
xorl %ebp, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x40f0a2
incl %ebp
cmpl $0x2, %ebp
jne 0x40e8dc
jmp 0x40e936
movq (%r14), %rax
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq *0x28(%rax)
xorl %eax, %eax
movsd 0x20(%rbx,%rax), %xmm0
movsd 0x10(%rsp,%rax), %xmm1
ucomisd %xmm1, %xmm0
jne 0x40e920
jp 0x40e920
leaq 0x8(%rax), %rcx
cmpq $0x10, %rax
movq %rcx, %rax
jne 0x40e8ff
ucomisd %xmm1, %xmm0
movsd 0x8(%rsp), %xmm0
jne 0x40e870
jp 0x40e870
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq $0x655aa0, %rdi         # imm = 0x655AA0
leaq 0x1bbbb4(%rip), %rsi    # 0x5ca503
callq 0x4b0650
movsd 0x10(%rbx), %xmm0
movq %rax, %rdi
callq 0x4b15c0
leaq 0x1bbbaf(%rip), %rsi    # 0x5ca517
movq %rax, %rdi
callq 0x4b0650
movq %rax, %rdi
movl %ebp, %esi
callq 0x4b0c80
jmp 0x40e9a8
movq $0x655aa0, %rdi         # imm = 0x655AA0
leaq 0x1bbba7(%rip), %rsi    # 0x5ca531
callq 0x4b0650
movq %rax, %rdi
movl %ebp, %esi
callq 0x4b0c80
leaq 0x1e452f(%rip), %rsi    # 0x5f2ecf
movq %rax, %rdi
callq 0x4b0650
leaq 0x245c52(%rip), %rsi    # 0x654601
movq %rax, %rdi
callq 0x43f8ce
nop
// File: /workspace/github_cpp_makefile_star2_O3/Cell-veto[P]postlhc/./storage.hpp
// Function: Storage<Monodisperse2D>::random_particle(RandomContext*)
key_t random_particle (RandomContext *random)
    {
        assert (num_ > 0);
        key_t ret;
        do {
            ret = random->uint (num_cells_);
        } while (!data_[ret].in_use ());
        return ret;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpq $0x0, 0x30(%rdi)
je 0x40e9f4
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x88(%rdi), %r15
movl 0x28(%r14), %esi
movq %rbx, %rdi
callq 0x4403b6
movl %eax, %eax
movq %rax, %rcx
shlq $0x4, %rcx
testb $0x1, 0x8(%r15,%rcx)
je 0x40e9d1
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1bbee5(%rip), %rdi    # 0x5ca8e0
leaq 0x1bb8f7(%rip), %rsi    # 0x5ca2f9
leaq 0x1bbee0(%rip), %rcx    # 0x5ca8e9
movl $0x221, %edx            # imm = 0x221
callq 0x50b050
nop