LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/Rjerk[P]ratabase/Value.cpp
// Function: Value::freeValue()
void Value::freeValue()
{
    switch (type) {
        case STRING:
            delete (string*)val;
            break;
        case LIST:
            delete (List*)val;
            break;
        case DICT:
            delete (Hashtable*)val;
            break;
        default:
            break;
    }
}

// Assembly:
pushq %rbx
movl (%rdi), %eax
cmpl $0x3, %eax
je 0xa9c3
cmpl $0x2, %eax
je 0xa9b0
cmpl $0x1, %eax
jne 0xa9dd
movq 0x8(%rdi), %rbx
testq %rbx, %rbx
je 0xa9dd
movq (%rbx), %rdi
leaq 0x10(%rbx), %rax
cmpq %rax, %rdi
je 0xa9d4
callq 0x32d0
jmp 0xa9d4
movq 0x8(%rdi), %rbx
testq %rbx, %rbx
je 0xa9dd
movq %rbx, %rdi
callq 0xb2d6
jmp 0xa9d4
movq 0x8(%rdi), %rbx
testq %rbx, %rbx
je 0xa9dd
movq %rbx, %rdi
callq 0xac86
movq %rbx, %rdi
popq %rbx
jmp 0x32d0
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Rjerk[P]ratabase/Value.cpp
// Function: Value::getList[abi:cxx11](unsigned long) const
string Value::getList(size_t pos) const
{
    List* lst = static_cast<List*>(val);
    string s;
    if (lst->get(pos, s)) {
        return s;
    } else {
        return string();
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x8(%rsi), %rdi
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
leaq 0x8(%rsp), %rax
movq %rdx, %rsi
movq %rax, %rdx
callq 0xb578
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
testb %al, %al
je 0xaaee
movq 0x8(%rsp), %rax
cmpq %r14, %rax
je 0xaaf4
movq %rax, (%rbx)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rbx)
jmp 0xaafb
leaq 0x8(%rbx), %rax
jmp 0xab0e
movups (%r14), %xmm0
movups %xmm0, (%rcx)
leaq 0x10(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x8(%rbx)
movq %r14, -0x8(%rax)
movq %r14, %rcx
movq $0x0, (%rax)
movb $0x0, (%rcx)
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xab27
callq 0x32d0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xab44
callq 0x32d0
movq %rbx, %rdi
callq 0x34d0
// File: /workspace/github_cpp_makefile_star2_O1/Rjerk[P]ratabase/Hash.cpp
// Function: Hashtable::~Hashtable()
Hashtable::~Hashtable()
{
	for (size_t i = 0; i < tablesz; ++i) {
    	Hashnode* entry = table[i];
        while (entry != nullptr) {
            Hashnode* prev = entry->getNext();
            entry = entry->getNext();
            delete prev;
        }
        table[i] = nullptr;
    }
    delete [] table;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0xacd7
xorl %r15d, %r15d
movq 0x10(%rbx), %rax
movq (%rax,%r15,8), %rax
testq %rax, %rax
je 0xacc3
movq 0x18(%rax), %r14
testq %r14, %r14
je 0xacc3
movq %r14, %rdi
callq 0xb1c6
movq %r14, %rdi
callq 0x32d0
movq 0x18(%r14), %r14
jmp 0xaca8
movq 0x10(%rbx), %rax
movq $0x0, (%rax,%r15,8)
incq %r15
cmpq (%rbx), %r15
jb 0xac97
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0xacea
popq %rbx
popq %r14
popq %r15
jmp 0x3390
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/Rjerk[P]ratabase/Hash.cpp
// Function: Hashtable::hashFunc(char const*)
unsigned Hashtable::hashFunc(const char* s) // fnv1a hash.
{
    unsigned hashvalue = 0x811C9DC5; // 2166136261 as seed.
    const unsigned fnv_prime = 0x01000193; // 16777619
    while (*s) {
        hashvalue = (*s++ ^ hashvalue) * fnv_prime;
    }
    return hashvalue;
}

// Assembly:
movb (%rsi), %cl
testb %cl, %cl
je 0xad13
incq %rsi
movl $0x811c9dc5, %eax       # imm = 0x811C9DC5
movsbl %cl, %ecx
xorl %eax, %ecx
imull $0x1000193, %ecx, %eax  # imm = 0x1000193
movb (%rsi), %cl
incq %rsi
testb %cl, %cl
jne 0xacfe
retq
movl $0x811c9dc5, %eax       # imm = 0x811C9DC5
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Rjerk[P]ratabase/Hash.cpp
// Function: Hashtable::get(char const*, Value&)
bool Hashtable::get(const char* key, Value& value)
{
    Hashnode* entry = table[getSlot(key)];

    while (entry != nullptr) {
        if (strcmp(entry->getKey(), key) == 0) {
            value = entry->getValue();
            return true;
        }
        entry = entry->getNext();
    }
    return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq 0x10(%rdi), %rcx
movb (%rsi), %dl
testb %dl, %dl
je 0xad89
leaq 0x1(%r14), %rax
movl $0x811c9dc5, %esi       # imm = 0x811C9DC5
movsbl %dl, %edx
xorl %esi, %edx
imull $0x1000193, %edx, %esi  # imm = 0x1000193
movb (%rax), %dl
incq %rax
testb %dl, %dl
jne 0xad71
movl %esi, %eax
jmp 0xad8e
movl $0x811c9dc5, %eax       # imm = 0x811C9DC5
xorl %edx, %edx
divq (%rdi)
movq (%rcx,%rdx,8), %r15
testq %r15, %r15
setne %bpl
je 0xadde
movq (%r15), %rdi
movq %r14, %rsi
callq 0x33c0
testl %eax, %eax
je 0xadb5
movq 0x18(%r15), %r15
jmp 0xad97
addq $0x8, %r15
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0xa64a
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa658
leaq 0x8(%rsp), %rdi
callq 0xa648
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xa648
movq %rbx, %rdi
callq 0x34d0
// File: /workspace/github_cpp_makefile_star2_O1/Rjerk[P]ratabase/Hash.cpp
// Function: Hashtable::put(char const*, Value const&)
void Hashtable::put(const char* key, const Value& value)
{
	size_t index = getSlot(key);
    ++elemsz;
    Hashnode* entry = table[index];
    Hashnode* prev = nullptr;

    while (entry != nullptr && strcmp(entry->getKey(), key) != 0) {
        prev = entry;
        entry = entry->getNext();
    }

    if (entry != nullptr) {
        entry->setValue(value);
    } else {
        entry = new Hashnode(key, value);
        if (prev == nullptr) { // empty slot
            table[index] = entry;
        } else {
            prev->setNext(entry); // end of linklist.
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movb (%rsi), %cl
testb %cl, %cl
je 0xae3b
leaq 0x1(%r15), %rax
movl $0x811c9dc5, %edx       # imm = 0x811C9DC5
movsbl %cl, %ecx
xorl %edx, %ecx
imull $0x1000193, %ecx, %edx  # imm = 0x1000193
movb (%rax), %cl
incq %rax
testb %cl, %cl
jne 0xae23
movl %edx, %eax
jmp 0xae40
movl $0x811c9dc5, %eax       # imm = 0x811C9DC5
xorl %edx, %edx
divq (%rbx)
movq %rdx, %r12
xorl %r13d, %r13d
incq 0x8(%rbx)
movq 0x10(%rbx), %rax
movq (%rax,%rdx,8), %rax
testq %rax, %rax
je 0xae74
movq %rax, %r13
movq (%rax), %rdi
movq %r15, %rsi
callq 0x33c0
testl %eax, %eax
je 0xae9a
movq 0x18(%r13), %rax
jmp 0xae57
movl $0x20, %edi
callq 0x3300
movq %rax, %rbp
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xb242
testq %r13, %r13
je 0xaeb3
movq %rbp, 0x18(%r13)
jmp 0xaebb
movq %r13, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xb1f4
movq 0x10(%rbx), %rax
movq %rbp, (%rax,%r12,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rbp, %rdi
callq 0x32d0
movq %rbx, %rdi
callq 0x34d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/Rjerk[P]ratabase/Hash.cpp
// Function: Hashtable::remove(char const*)
bool Hashtable::remove(const char* key)
{
	size_t index = getSlot(key);
    Hashnode* prev = nullptr;
    Hashnode* entry = table[index];

    while (entry != nullptr && strcmp(entry->getKey(), key) != 0) {
   		prev = entry;
        entry = entry->getNext();
    }

    if (entry == nullptr) { // not found
        return false;
    } else {
        if (prev == nullptr) {// remove the element in slot
            table[index] = entry->getNext();
        } else {
            prev->setNext(entry->getNext());
        }
        delete entry;
        --elemsz;
        return true;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movb (%rsi), %cl
testb %cl, %cl
je 0xaf16
leaq 0x1(%r14), %rax
movl $0x811c9dc5, %edx       # imm = 0x811C9DC5
movsbl %cl, %ecx
xorl %edx, %ecx
imull $0x1000193, %ecx, %edx  # imm = 0x1000193
movb (%rax), %cl
incq %rax
testb %cl, %cl
jne 0xaefe
movl %edx, %eax
jmp 0xaf1b
movl $0x811c9dc5, %eax       # imm = 0x811C9DC5
xorl %ebp, %ebp
xorl %edx, %edx
divq (%rbx)
movq %rdx, %r12
movq 0x10(%rbx), %r13
movq (%r13,%rdx,8), %r15
testq %r15, %r15
je 0xaf61
movq (%r15), %rdi
movq %r14, %rsi
callq 0x33c0
testl %eax, %eax
je 0xaf5f
movq %r15, %rbp
movq 0x18(%r15), %r15
testq %r15, %r15
je 0xaf61
movq (%r15), %rdi
movq %r14, %rsi
callq 0x33c0
testl %eax, %eax
jne 0xaf42
jmp 0xaf61
xorl %ebp, %ebp
testq %r15, %r15
je 0xaf97
leaq (,%r12,8), %rax
addq %r13, %rax
leaq 0x18(%rbp), %rcx
testq %rbp, %rbp
movq 0x18(%r15), %rdx
cmoveq %rax, %rcx
movq %rdx, (%rcx)
movq %r15, %rdi
callq 0xb1c6
movq %r15, %rdi
callq 0x32d0
decq 0x8(%rbx)
testq %r15, %r15
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Rjerk[P]ratabase/Hash.cpp
// Function: Hashtable::print[abi:cxx11]() const
string Hashtable::print() const
{
    std::ostringstream os;
    os << "{\n";
    for (size_t i = 0; i < tablesz; ++i) {
        const Hashnode* entry = table[i];
        while (entry != nullptr) {
            os << "(" << string(entry->getKey())
               << ": " << entry->getValue().getString() << ")\n";
            entry = entry->getNext();
        }
    }
    os << "}";
    return os.str();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1e8, %rsp            # imm = 0x1E8
movq %rsi, %r15
movq %rdi, %r14
leaq 0x70(%rsp), %rbx
movq %rbx, %rdi
callq 0x33b0
leaq 0x27b2(%rip), %rsi      # 0xd789
movl $0x2, %edx
movq %rbx, %rdi
callq 0x3340
movq %r14, 0x10(%rsp)
cmpq $0x0, (%r15)
je 0xb0ff
leaq 0x30(%rsp), %rbx
xorl %r13d, %r13d
leaq 0x70(%rsp), %r12
leaq 0x60(%rsp), %r14
movq %r15, 0x18(%rsp)
movq 0x10(%r15), %rax
movq (%rax,%r13,8), %r15
testq %r15, %r15
je 0xb0ee
movl $0x1, %edx
movq %r12, %rdi
leaq 0x2680(%rip), %rsi      # 0xd6aa
callq 0x3340
movq (%r15), %rsi
leaq 0x40(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x3140
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
movq %r12, %rdi
callq 0x3340
movq %rax, %rbp
movl $0x2, %edx
movq %rax, %rdi
leaq 0x21aa(%rip), %rsi      # 0xd20f
callq 0x3340
leaq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0xa64a
movq 0x68(%rsp), %rax
movq %rbx, 0x20(%rsp)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0x55d2
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq %rbp, %rdi
callq 0x3340
movl $0x2, %edx
movq %rax, %rdi
leaq 0x26d7(%rip), %rsi      # 0xd78c
callq 0x3340
movq 0x20(%rsp), %rdi
cmpq %rbx, %rdi
je 0xb0c9
callq 0x32d0
movq %r14, %rdi
callq 0xa648
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0xb0e5
callq 0x32d0
movq 0x18(%r15), %r15
jmp 0xb012
incq %r13
movq 0x18(%rsp), %r15
cmpq (%r15), %r13
jb 0xb00a
leaq 0x2689(%rip), %rsi      # 0xd78f
leaq 0x70(%rsp), %rdi
movl $0x1, %edx
callq 0x3340
movq 0x10(%rsp), %rbx
leaq 0x78(%rsp), %rsi
movq %rbx, %rdi
callq 0x3470
movq 0x6ea2(%rip), %rsi      # 0x11fd0
leaq 0x70(%rsp), %rdi
callq 0x3190
leaq 0xe0(%rsp), %rdi
callq 0x30e0
movq %rbx, %rax
addq $0x1e8, %rsp            # imm = 0x1E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xb160
jmp 0xb160
jmp 0xb188
movq %rax, %r14
jmp 0xb19f
movq %rax, %r14
jmp 0xb17c
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %rbx, %rdi
je 0xb17c
callq 0x32d0
leaq 0x60(%rsp), %rdi
callq 0xa648
jmp 0xb18b
movq %rax, %r14
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0xb19f
callq 0x32d0
movq 0x6e2a(%rip), %rsi      # 0x11fd0
leaq 0x70(%rsp), %rdi
callq 0x3190
leaq 0xe0(%rsp), %rdi
callq 0x30e0
movq %r14, %rdi
callq 0x34d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/Rjerk[P]ratabase/List.cpp
// Function: List::~List()
List::~List()
{
    while (head != tail) {
        head = head->next;
        delete head->prev;
    }
    delete tail;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %rax
movq 0x30(%rdi), %r14
cmpq %r14, %rax
je 0xb326
movq 0x28(%rax), %rax
movq %rax, 0x28(%rbx)
movq 0x20(%rax), %r14
testq %r14, %r14
je 0xb31c
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%r14)
movq (%r14), %rdi
leaq 0x10(%r14), %rax
cmpq %rax, %rdi
je 0xb314
callq 0x32d0
movq %r14, %rdi
callq 0x32d0
movq 0x28(%rbx), %rax
movq 0x30(%rbx), %r14
jmp 0xb2e5
testq %r14, %r14
je 0xb34c
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%r14)
movq (%r14), %rdi
leaq 0x10(%r14), %rax
cmpq %rax, %rdi
je 0xb344
callq 0x32d0
movq %r14, %rdi
callq 0x32d0
movq (%rbx), %rdi
addq $0x10, %rbx
addq $0x8, %rsp
cmpq %rbx, %rdi
je 0xb364
popq %rbx
popq %r14
jmp 0x32d0
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/Rjerk[P]ratabase/List.cpp
// Function: List::push(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void List::push(const string& s)
{
    ListNode* node = new ListNode();
    node->s = s;
    if (sz == 0) {
        head = tail = node;
    } else {
        tail->next = node;
        node->prev = tail;
        tail = node;
        node = nullptr;
    }
    ++sz;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movl $0x30, %edi
callq 0x3300
movq %rax, %r14
addq $0x10, %rax
movq %rax, (%r14)
movq $0x0, 0x8(%r14)
movb $0x0, 0x10(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%r14)
movq %r14, %rdi
movq %r15, %rsi
callq 0x31a0
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0xb3c1
leaq 0x30(%rbx), %rcx
movq (%rcx), %rdx
movq %r14, 0x28(%rdx)
movq %rdx, 0x20(%r14)
jmp 0xb3c9
movq %r14, 0x30(%rbx)
leaq 0x28(%rbx), %rcx
movq %r14, (%rcx)
incq %rax
movq %rax, 0x20(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Rjerk[P]ratabase/List.cpp
// Function: List::pop()
ListNode List::pop()
{
    ListNode* node = head;
    if (sz == 0) {
        return ListNode();
    } else if (sz == 1){
        head = tail = nullptr;
        --sz;
        return *node;
    } else {
        head = head->next;
        node->next = nullptr;
        head->prev = nullptr;
        --sz;
        return *node;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rsi), %rax
movq 0x28(%rsi), %r14
cmpq $0x1, %rax
je 0xb40c
testq %rax, %rax
jne 0xb41b
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
jmp 0xb452
leaq 0x28(%rsi), %rcx
decq %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rcx)
jmp 0xb430
movq 0x28(%r14), %rcx
movq %rcx, 0x28(%rsi)
xorl %edx, %edx
movq %rdx, 0x28(%r14)
movq %rdx, 0x20(%rcx)
decq %rax
movq %rax, 0x20(%rsi)
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x55d2
movups 0x20(%r14), %xmm0
movups %xmm0, 0x20(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Rjerk[P]ratabase/List.cpp
// Function: List::index(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
int List::index(const string& s) const
{
    ListNode* p = head;
    size_t i = 0;
    while (p->next != nullptr) {
        if (p->s == s) {
            return (int)i;
        }
        ++i;
        p = p->next;
    }
    return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x28(%rdi), %rax
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpq $0x0, 0x28(%rax)
je 0xb4b8
leaq 0x28(%rax), %r15
movq (%rsi), %r14
movq 0x8(%rsi), %r12
xorl %ebp, %ebp
movq 0x8(%rax), %rdx
cmpq %r12, %rdx
jne 0xb4a4
testq %rdx, %rdx
je 0xb4b6
movq (%rax), %rdi
movq %r14, %rsi
callq 0x3310
testl %eax, %eax
je 0xb4b6
movq (%r15), %rax
leaq 0x28(%rax), %r15
incl %ebp
cmpq $0x0, 0x28(%rax)
jne 0xb487
jmp 0xb4b8
movl %ebp, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Rjerk[P]ratabase/List.cpp
// Function: List::put(unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void List::put(size_t pos, const string& s)
{
    ListNode* newnode = new ListNode();
    newnode->s = s;
    if (pos > sz)
        pos = sz;
    if (pos == sz)
        push(s);
    else if (pos == 0) {
        head->prev = newnode;
        newnode->next = head;
        head = newnode;
    } else {
        ListNode* p = head;
        size_t i = 0;
        while (p->next != nullptr) {
            if (i != pos) {
                ++i;
                p = p->next;
            } else {
            	break;
			}
        }
        p->prev->next = newnode;
        newnode->prev = p->prev;
        p->prev = newnode;
        newnode->next = p;
    }
    newnode = nullptr;
    ++sz;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
movl $0x30, %edi
callq 0x3300
movq %rax, %r14
addq $0x10, %rax
movq %rax, (%r14)
movq $0x0, 0x8(%r14)
movb $0x0, 0x10(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%r14)
movq %r14, %rdi
movq %r12, %rsi
callq 0x31a0
movq 0x20(%rbx), %rax
cmpq %r15, %rax
cmovaeq %r15, %rax
jbe 0xb54e
movq 0x28(%rbx), %rcx
testq %r15, %r15
je 0xb55b
movq %rcx, %rdx
movq 0x28(%rcx), %rcx
subq $0x1, %rax
setb %sil
testq %rcx, %rcx
je 0xb538
testb %sil, %sil
je 0xb51f
movq 0x20(%rdx), %rax
movq %r14, 0x28(%rax)
movq %rax, 0x20(%r14)
movq %r14, 0x20(%rdx)
movq %rdx, 0x28(%r14)
jmp 0xb567
movq %rbx, %rdi
movq %r12, %rsi
callq 0xb368
jmp 0xb567
movq %r14, 0x20(%rcx)
movq %rcx, 0x28(%r14)
movq %r14, 0x28(%rbx)
incq 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Rjerk[P]ratabase/List.cpp
// Function: List::get(unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool List::get(const size_t pos, string& s)
{
    if (pos >= sz)
        return false;

    ListNode* p = head;
    size_t i = 0;
    while (p->next != nullptr) {
        if (i == pos) {
            s = p->s;
            break;
        } else {
            p = p->next;
            ++i;
        }
    }
    return true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x20(%rdi), %r14
cmpq %rsi, %r14
jbe 0xb5b6
movq 0x28(%rdi), %rsi
movq 0x28(%rsi), %rax
testq %rax, %rax
je 0xb5b6
testq %rbx, %rbx
je 0xb5ae
movq %rbx, %rcx
movq %rax, %rsi
movq 0x28(%rax), %rax
testq %rax, %rax
je 0xb5b6
decq %rcx
jne 0xb59d
movq %rdx, %rdi
callq 0x31a0
cmpq %rbx, %r14
seta %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/Rjerk[P]ratabase/List.cpp
// Function: List::del(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool List::del(const string& s)
{
    size_t pos;
    if ((pos = index(s)) != size_t(-1)) {
        if (pos == 0) {
            pop();
            return true;
        } else if (pos == sz-1) {
            if (sz == 1) {
                delete tail;
                head = tail = nullptr;
            } else {
                tail = tail->prev;
                delete tail->next;
                tail->next = nullptr;
            }
        } else {
            ListNode* p = head;
            while (p->next != nullptr) {
                if (p->s == s)
                    break;
                else
                	p = p->next;
            }
            p->prev->next = p->next;
            p->next->prev = p->prev;
            delete p;
        }
        --sz;
        return true;
    } else {
        return false;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r13
movq %rdi, %r14
callq 0xb462
movl %eax, %ebx
cmpl $-0x1, %eax
je 0xb738
testl %ebx, %ebx
je 0xb63d
movslq %ebx, %rcx
movq 0x20(%r14), %rax
leaq -0x1(%rax), %rdx
cmpq %rcx, %rdx
jne 0xb670
movq 0x30(%r14), %r15
cmpq $0x1, %rax
jne 0xb6f6
testq %r15, %r15
je 0xb630
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%r15)
movq (%r15), %rdi
leaq 0x10(%r15), %rax
cmpq %rax, %rdi
je 0xb628
callq 0x32d0
movq %r15, %rdi
callq 0x32d0
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r14)
jmp 0xb734
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xb3da
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%r15)
movq (%r15), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xb738
callq 0x32d0
jmp 0xb738
movq 0x28(%r14), %r15
movq 0x28(%r15), %rbp
testq %rbp, %rbp
je 0xb6bc
leaq 0x28(%r15), %r12
movq (%r13), %rax
movq %rax, (%rsp)
movq 0x8(%r13), %r13
movq 0x8(%r15), %rdx
cmpq %r13, %rdx
jne 0xb6ab
testq %rdx, %rdx
je 0xb6bc
movq (%r15), %rdi
movq (%rsp), %rsi
callq 0x3310
testl %eax, %eax
je 0xb6bc
movq (%r12), %r15
leaq 0x28(%r15), %r12
movq 0x28(%r15), %rbp
testq %rbp, %rbp
jne 0xb68d
movq 0x20(%r15), %rax
movq %rbp, 0x28(%rax)
movq 0x28(%r15), %rcx
movq %rax, 0x20(%rcx)
testq %r15, %r15
je 0xb734
leaq 0x20(%r15), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq (%r15), %rdi
leaq 0x10(%r15), %rax
cmpq %rax, %rdi
je 0xb6ec
callq 0x32d0
movq %r15, %rdi
callq 0x32d0
jmp 0xb734
movq 0x20(%r15), %rax
movq %rax, 0x30(%r14)
movq 0x28(%rax), %r15
testq %r15, %r15
je 0xb728
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%r15)
movq (%r15), %rdi
leaq 0x10(%r15), %rax
cmpq %rax, %rdi
je 0xb720
callq 0x32d0
movq %r15, %rdi
callq 0x32d0
movq 0x30(%r14), %rax
movq $0x0, 0x28(%rax)
decq 0x20(%r14)
cmpl $-0x1, %ebx
setne %al
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Rjerk[P]ratabase/List.cpp
// Function: List::print[abi:cxx11]()
string List::print()
{
    std::ostringstream os;
    ListNode* p = head;
    if (p == nullptr)
        os << "[]" << std::endl;

    os << "[";
    while (p != nullptr && p->next != nullptr) {
        os << p->s << ", ";
        p = p->next;
    }
    os << p->s << "]";
    return os.str();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x178, %rsp            # imm = 0x178
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x33b0
movq 0x28(%r14), %r12
testq %r12, %r12
jne 0xb7b2
leaq 0x2036(%rip), %rsi      # 0xd7b0
movq %rsp, %r14
movl $0x2, %edx
movq %r14, %rdi
callq 0x3340
movq (%rsp), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x32f0
movsbl %al, %esi
movq %rsp, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3200
leaq 0x1cba(%rip), %rsi      # 0xd473
movq %rsp, %rdi
movl $0x1, %edx
callq 0x3340
testq %r12, %r12
je 0xb808
movq %rsp, %r14
leaq 0x1ed7(%rip), %r15      # 0xd6ac
cmpq $0x0, 0x28(%r12)
je 0xb808
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r14, %rdi
callq 0x3340
movl $0x2, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x3340
movq 0x28(%r12), %r12
testq %r12, %r12
jne 0xb7d5
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %rsp, %rdi
callq 0x3340
leaq 0x1f91(%rip), %rsi      # 0xd7b1
movl $0x1, %edx
movq %rax, %rdi
callq 0x3340
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3470
movq 0x678f(%rip), %rsi      # 0x11fd0
movq %rsp, %rdi
callq 0x3190
leaq 0x70(%rsp), %rdi
callq 0x30e0
movq %rbx, %rax
addq $0x178, %rsp            # imm = 0x178
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xb867
movq %rax, %rbx
movq 0x675f(%rip), %rsi      # 0x11fd0
movq %rsp, %rdi
callq 0x3190
leaq 0x70(%rsp), %rdi
callq 0x30e0
movq %rbx, %rdi
callq 0x34d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/rowdyroad[P]dtmfdecoder/example.cpp
// Function: loadWaveFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, WAVHeader&)
FILE * loadWaveFile(const std::string& filename, WAVHeader& header)
{
  FILE * fd = fopen(filename.c_str(), "rb");
  if (fd == nullptr) {
    std::cout << "Wave file not found!" << std::endl;
    exit(1);
  }
  fread(&header, sizeof(WAVHeader), 1, fd);
  return fd;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rdi), %rdi
leaq 0x1c43(%rip), %rsi      # 0x4080
callq 0x21c0
testq %rax, %rax
je 0x246a
movq %rax, %r14
movl $0x48, %esi
movl $0x1, %edx
movq %rbx, %rdi
movq %rax, %rcx
callq 0x21f0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x3b67(%rip), %rdi      # 0x5fd8
leaq 0x1c0b(%rip), %rsi      # 0x4083
callq 0x2160
movq %rax, %rdi
callq 0x20a0
movl $0x1, %edi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O1/rowdyroad[P]dtmfdecoder/./DTMFDecoder.h
// Function: DTMFDecoder<short>::DTMFDecoder(DTMFDecoder<short>::Handler*, unsigned long, unsigned long, unsigned long, double)
DTMFDecoder(Handler* handler, size_t sampleRate = 8000, size_t windowDurationMilliseconds = 50, size_t windowOverlapMilliseconds = 10, double thresold = -59.0)
        : handler_(handler)
        , sampleRate_(sampleRate)
        , windowDurationMilliseconds_(windowDurationMilliseconds)
        , thresold_(thresold)
      {
          if (windowOverlapMilliseconds > windowDurationMilliseconds_) {
            windowOverlapMilliseconds = windowDurationMilliseconds_;
          }
          samplesPerMilliseconds_ = sampleRate_ / 1000;
          framesCount_ = samplesPerMilliseconds_* windowDurationMilliseconds_;
          overlapFramesCount_ = samplesPerMilliseconds_ * windowOverlapMilliseconds;
          windowFrames_.reserve(framesCount_);

          createWindowFunctionTable();
          reset();
      }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movsd %xmm0, 0x8(%rsp)
movq %r8, %rbp
movq %rcx, %r13
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movw $0x0, (%rdi)
addq $0x8, %rdi
movabsq $0x3ad0354030202b9, %rax # imm = 0x3AD0354030202B9
leaq 0x18(%rsp), %r15
movq %rax, (%r15)
leaq 0x7(%rsp), %rcx
movl $0x4, %edx
movq %rdi, 0x10(%rsp)
movq %r15, %rsi
callq 0x2fd8
leaq 0x20(%rbx), %rdi
movabsq $0x66105c5053804b9, %rax # imm = 0x66105C5053804B9
movq %rax, (%r15)
leaq 0x18(%rsp), %rsi
leaq 0x7(%rsp), %rcx
movl $0x4, %edx
movq %rdi, %r15
callq 0x2fd8
movaps 0x1768(%rip), %xmm0     # 0x4050
movups %xmm0, 0x38(%rbx)
movq %r12, 0x48(%rbx)
movq %r14, 0x50(%rbx)
movq %r13, 0x60(%rbx)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x80(%rbx)
leaq 0x88(%rbx), %r12
leaq 0xb8(%rbx), %rax
movq %rax, 0x8(%rsp)
leaq 0xc0(%rbx), %rax
movl $0x0, 0xc0(%rbx)
xorl %ecx, %ecx
movq %rcx, 0xc8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0xa8(%rbx)
movups %xmm0, 0x98(%rbx)
movups %xmm0, 0x88(%rbx)
movq %rax, 0xd0(%rbx)
movq %rax, 0xd8(%rbx)
cmpq %rbp, %r13
cmovbq %r13, %rbp
shrq $0x3, %r14
movabsq $0x20c49ba5e353f7cf, %rdx # imm = 0x20C49BA5E353F7CF
movq %r14, %rax
mulq %rdx
movq %rcx, 0xe0(%rbx)
shrq $0x4, %rdx
movq %rdx, 0x58(%rbx)
imulq %rdx, %r13
movq %r13, 0x68(%rbx)
imulq %rbp, %rdx
movq %rdx, 0x70(%rbx)
movq %r12, %rdi
movq %r13, %rsi
callq 0x301e
movq %rbx, %rdi
callq 0x30b2
movq $0x0, 0x78(%rbx)
movq 0x88(%rbx), %rax
cmpq %rax, 0x90(%rbx)
je 0x29c5
movq %rax, 0x90(%rbx)
movq %rbx, %rdi
callq 0x3416
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x2a2c
movq %rdx, %r14
movq %rax, %r13
movq 0x8(%rsp), %rdi
callq 0x2ed4
movq 0xa0(%rbx), %rdi
testq %rdi, %rdi
je 0x2a0c
movq 0xb0(%rbx), %rsi
subq %rdi, %rsi
callq 0x2190
leaq 0x18(%rsp), %rbp
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %r13, %rcx
movl %r14d, %r8d
movq %rbp, %r9
callq 0x2290
movq (%rbp), %r14
movq 0x10(%rsp), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x2a45
movq 0x18(%rbx), %rsi
subq %rdi, %rsi
callq 0x2190
movq %r14, %rdi
callq 0x2240
nop
// File: /workspace/github_cpp_makefile_star2_O1/rowdyroad[P]dtmfdecoder/./DTMFDecoder.h
// Function: DTMFDecoder<short>::createWindowFunctionTable()
void createWindowFunctionTable()
      {
          windowFunctionTable_.resize(framesCount_);
          for (size_t i = 0; i < framesCount_; ++i) {
            windowFunctionTable_[i] = (0.42 - 0.5 * cos(2.0 * M_PI * i / (framesCount_ - 1)) + 0.08 * cos(4.0 * M_PI * i / (framesCount_ - 1)))
                                      /
                                      (pow(2, sizeof(T) * 8 - 1) - 1);
          }
      }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
addq $0xa0, %rdi
movq 0x68(%rbx), %rsi
callq 0x327c
movq 0x68(%rbx), %rax
testq %rax, %rax
je 0x31d0
xorl %r14d, %r14d
movq %r14, %xmm0
movq 0xf77(%rip), %xmm1      # 0x4060
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movdqa %xmm1, %xmm2
movapd 0xf77(%rip), %xmm1      # 0x4070
subpd %xmm1, %xmm0
movapd %xmm1, %xmm3
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd %xmm1, 0x10(%rsp)
movapd %xmm1, %xmm0
mulsd 0xef1(%rip), %xmm0      # 0x4010
decq %rax
movq %rax, %xmm1
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
subpd %xmm3, %xmm1
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
callq 0x2270
mulsd 0xecc(%rip), %xmm0      # 0x4018
addsd 0xecc(%rip), %xmm0      # 0x4020
movsd %xmm0, 0x8(%rsp)
movapd 0x10(%rsp), %xmm2
mulsd 0xec0(%rip), %xmm2      # 0x4028
movq 0x68(%rbx), %rax
decq %rax
movq %rax, %xmm0
punpckldq 0xee4(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0xeec(%rip), %xmm0      # 0x4070
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd %xmm2, %xmm0
divsd %xmm1, %xmm0
callq 0x2270
mulsd 0xe8b(%rip), %xmm0      # 0x4030
addsd 0x8(%rsp), %xmm0
divsd 0xe85(%rip), %xmm0      # 0x4038
movq 0xa0(%rbx), %rax
movsd %xmm0, (%rax,%r14,8)
incq %r14
movq 0x68(%rbx), %rax
cmpq %rax, %r14
jb 0x30dc
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/rowdyroad[P]dtmfdecoder/./DTMFDecoder.h
// Function: DTMFDecoder<short>::fillDtmfStatsTable()
void fillDtmfStatsTable()
      {
        dtmfStatsTable_.clear();
        size_t idxl = 0;
        for (auto l : kLowFreqs_) {
          size_t idxh = 0;
          for (auto h : kHighFreqs_) {
            uint8_t c = kDtmfCodes_[idxl][idxh];
            dtmfStatsTable_.insert(std::make_pair(std::make_pair(l,h), FrequencyPairStat({0, c})));
            ++idxh;
          }
          ++idxl;
        }
      }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0xb8(%rdi), %r14
movq %r14, %rdi
callq 0x34e4
movq 0x8(%rbx), %rax
movq %rbx, 0x8(%rsp)
movq 0x10(%rbx), %rcx
movq %rax, (%rsp)
movq %rcx, 0x18(%rsp)
cmpq %rcx, %rax
je 0x34d5
movq 0x8(%rsp), %rax
addq $0x38, %rax
movq %rax, 0x10(%rsp)
leaq 0x20(%rsp), %r15
movq 0x8(%rsp), %rax
movq 0x20(%rax), %r13
movq 0x28(%rax), %rbx
cmpq %rbx, %r13
je 0x34bc
movq (%rsp), %rax
movzwl (%rax), %ebp
movq 0x10(%rsp), %r12
movb (%r12), %al
movzwl (%r13), %ecx
shll $0x10, %ecx
orl %ebp, %ecx
movl %ecx, 0x20(%rsp)
movq $0x0, 0x28(%rsp)
movb %al, 0x30(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x3512
addq $0x2, %r13
incq %r12
cmpq %rbx, %r13
jne 0x3486
movq (%rsp), %rax
addq $0x2, %rax
addq $0x4, 0x10(%rsp)
movq %rax, (%rsp)
cmpq 0x18(%rsp), %rax
jne 0x3468
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/rowdyroad[P]dtmfdecoder/./DTMFDecoder.h
// Function: DTMFDecoder<short>::getExistsFrequency(std::vector<double, std::allocator<double>> const&, std::vector<unsigned short, std::allocator<unsigned short>> const&)
Frequency getExistsFrequency(const std::vector<double>& frames, const std::vector<Frequency>& frequencies)
      {
        double max = thresold_;
        Frequency ret = kUndefinedFrequency;
        for (auto f : frequencies) {
          double mag = 20.0 * log10(goertzelFunction(f , frames));
          if (mag > max) {
            max = mag;
            ret = f;
          }
        }
        return ret;
      }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movzwl (%rdi), %ebp
movq (%rdx), %r12
movq 0x8(%rdx), %r13
cmpq %r13, %r12
je 0x379e
movq %rsi, %rbx
movq %rdi, %r14
movsd 0x80(%rdi), %xmm0
movsd %xmm0, (%rsp)
movzwl (%r12), %r15d
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x3a62
callq 0x20b0
mulsd 0x8c1(%rip), %xmm0      # 0x4040
movsd (%rsp), %xmm1
ucomisd %xmm1, %xmm0
cmovbel %ebp, %r15d
maxsd %xmm1, %xmm0
addq $0x2, %r12
movl %r15d, %ebp
cmpq %r13, %r12
jne 0x375a
jmp 0x37a1
movl %ebp, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/rowdyroad[P]dtmfdecoder/./DTMFDecoder.h
// Function: DTMFDecoder<short>::goertzelFunction(unsigned long, std::vector<double, std::allocator<double>> const&)
double goertzelFunction(size_t frequency, const std::vector<double>& samples)
      {
          size_t scalingFactor = samples.size() / 2;
          double k = 0.5 + (((double)samples.size() * frequency) / sampleRate_),
                 omega = (2.0 * M_PI * k) / samples.size(),
                 sine = sin(omega),
                 cosine =cos(omega),
                 coeff = 2.0 * cosine,
                 q0 = 0,
                 q1 = 0,
                 q2 = 0;

          for (auto sample : samples) {
              q0 = coeff * q1 - q2 + sample;
              q2 = q1;
              q1 = q0;
          }
          double real = (q1 - q2 * cosine) / scalingFactor;
          double imag = (q2 * sine) / scalingFactor;
          return sqrtf(real*real + imag*imag);
      }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq 0x8(%rdx), %r14
subq (%rdx), %r14
sarq $0x3, %r14
movq %r14, %xmm0
movq 0x5dc(%rip), %xmm1      # 0x4060
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x5e0(%rip), %xmm2      # 0x4070
subpd %xmm2, %xmm0
movapd %xmm0, %xmm3
unpckhpd %xmm0, %xmm3            # xmm3 = xmm3[1],xmm0[1]
addsd %xmm0, %xmm3
movq %rsi, %xmm4
punpckldq %xmm1, %xmm4    # xmm4 = xmm4[0],xmm1[0],xmm4[1],xmm1[1]
subpd %xmm2, %xmm4
movapd %xmm4, %xmm0
unpckhpd %xmm4, %xmm0            # xmm0 = xmm0[1],xmm4[1]
addsd %xmm4, %xmm0
mulsd %xmm3, %xmm0
movq 0x50(%rdi), %xmm4
punpckldq %xmm1, %xmm4    # xmm4 = xmm4[0],xmm1[0],xmm4[1],xmm1[1]
subpd %xmm2, %xmm4
movapd %xmm4, %xmm1
unpckhpd %xmm4, %xmm1            # xmm1 = xmm1[1],xmm4[1]
addsd %xmm4, %xmm1
divsd %xmm1, %xmm0
addsd 0x566(%rip), %xmm0      # 0x4048
mulsd 0x526(%rip), %xmm0      # 0x4010
divsd %xmm3, %xmm0
movapd %xmm0, 0x10(%rsp)
callq 0x2050
movsd %xmm0, 0x8(%rsp)
movapd 0x10(%rsp), %xmm0
callq 0x2270
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
cmpq %rcx, %rax
je 0x3b49
movapd %xmm0, %xmm3
addsd %xmm0, %xmm3
xorpd %xmm1, %xmm1
xorpd %xmm4, %xmm4
movapd %xmm1, %xmm2
movapd %xmm3, %xmm1
mulsd %xmm2, %xmm1
subsd %xmm4, %xmm1
addsd (%rax), %xmm1
addq $0x8, %rax
movapd %xmm2, %xmm4
cmpq %rcx, %rax
jne 0x3b26
jmp 0x3b51
xorpd %xmm2, %xmm2
xorpd %xmm1, %xmm1
shrq %r14
mulsd %xmm2, %xmm0
subsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsi2sd %r14, %xmm0
divsd %xmm0, %xmm1
movsd 0x8(%rsp), %xmm3
mulsd %xmm2, %xmm3
divsd %xmm0, %xmm3
mulsd %xmm3, %xmm3
mulsd %xmm1, %xmm1
addsd %xmm3, %xmm1
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x3b97
sqrtss %xmm0, %xmm0
jmp 0x3b9c
callq 0x2260
cvtss2sd %xmm0, %xmm0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/j-faria[P]kima/src/main.cpp
// Function: main
int main(int argc, char** argv)
{
    /* set the RV data file */
    datafile = "examples/BL2009/BL2009_dataset1.kms.rv";

    /* load the file (RVs are in km/s) */
    /* don't skip any lines in the header */
    Data::get_instance().load(datafile, "kms", 0);

    // set the sampler and run it!
    Sampler<RVmodel> sampler = setup<RVmodel>(argc, argv);
    sampler.run(50);

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x6f8, %rsp            # imm = 0x6F8
movq %rsi, %rbx
movl %edi, %ebp
movq 0x32858(%rip), %rdx     # 0x53550
leaq 0x32849(%rip), %rdi     # 0x53548
leaq 0x247fb(%rip), %rcx     # 0x45501
movl $0x26, %r8d
xorl %esi, %esi
callq 0x6600
leaq 0x30(%rsp), %r14
movq %r14, -0x10(%r14)
movq 0x32825(%rip), %rsi     # 0x53548
movq 0x32826(%rip), %rdx     # 0x53550
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0xad7e
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1e4e1(%rip), %rsi     # 0x3f228
leaq 0x1e4dd(%rip), %rdx     # 0x3f22b
movq %rsp, %rdi
callq 0x18632
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %r8
movaps %xmm0, (%r8)
movq $0x0, 0x10(%r8)
leaq 0x3268f(%rip), %rdi     # 0x53400
leaq 0x20(%rsp), %rsi
movq %rsp, %rdx
xorl %ecx, %ecx
callq 0x81f6
leaq 0x40(%rsp), %rdi
callq 0xac88
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x20da0
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6460
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x20db7
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x6460
leaq 0x40(%rsp), %r14
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x20fe9
movq %r14, %rdi
movl $0x32, %esi
callq 0x210ba
leaq 0x40(%rsp), %rdi
callq 0x21298
xorl %eax, %eax
addq $0x6f8, %rsp            # imm = 0x6F8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x21298
jmp 0x20e3e
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0xac88
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x20e27
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6460
jmp 0x20e27
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x20e3e
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x6460
movq %rbx, %rdi
callq 0x6710
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/apps/mshcompare/mshcompare.cpp
// Function: ReadMesh(char*)
static R3Mesh *
ReadMesh(char *filename)
{
  // Start statistics
  RNTime start_time;
  start_time.Read();

  // Allocate mesh
  R3Mesh *mesh = new R3Mesh();
  if (!mesh) {
    RNFail("Unable to allocate mesh for %s\n", filename);
    return NULL;
  }

  // Read mesh from file
  if (!mesh->ReadFile(filename)) {
    delete mesh;
    return NULL;
  }

  // Print statistics
  if (print_verbose) {
    printf("Read mesh from %s\n", filename);
    printf("  Time = %.2f seconds\n", start_time.Elapsed());
    printf("  # Faces = %d\n", mesh->NFaces());
    printf("  # Edges = %d\n", mesh->NEdges());
    printf("  # Vertices = %d\n", mesh->NVertices());
    fflush(stdout);
  }

  // Return success
  return mesh;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x5737c
movq %rbx, %rdi
xorl %esi, %esi
callq 0xc5c0
movl $0x138, %edi            # imm = 0x138
callq 0xc390
movq %rax, %rbx
movq %rax, %rdi
callq 0x221d0
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0x180(%rax)
testl %eax, %eax
je 0xf5db
cmpb $0x1, 0x71544(%rip)     # 0x80ab0
jne 0xf5e6
leaq 0x4ab03(%rip), %rdi     # 0x5a078
movq %r14, %rsi
xorl %eax, %eax
callq 0xc070
leaq 0x8(%rsp), %rdi
callq 0x573de
leaq 0x4aafb(%rip), %rdi     # 0x5a08b
movb $0x1, %al
callq 0xc070
movl 0x34(%rbx), %esi
leaq 0x4ab01(%rip), %rdi     # 0x5a0a2
xorl %eax, %eax
callq 0xc070
movl 0x24(%rbx), %esi
leaq 0x4ab00(%rip), %rdi     # 0x5a0b2
xorl %eax, %eax
callq 0xc070
movl 0x14(%rbx), %esi
leaq 0x4aaff(%rip), %rdi     # 0x5a0c2
xorl %eax, %eax
callq 0xc070
movq 0x709b7(%rip), %rax     # 0x7ff88
movq (%rax), %rdi
callq 0xc440
jmp 0xf5e6
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movl $0x138, %esi            # imm = 0x138
movq %rbx, %rdi
callq 0xc3a0
movq %r14, %rdi
callq 0xc640
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/vividvilla[P]hackerrank/src/quicksort1.cpp
// Function: partition(std::vector<int, std::allocator<int>>)
vector<int> partition(vector<int> ar) {
    int N = ar.size();

    int p = ar[0];
    vector<int> p1;
    vector<int> p2;
    for (int i = 0; i < N; i++) {
        if (ar[i] < p)
            p1.push_back(ar[i]);
        else if (ar[i] > p)
            p2.push_back(ar[i]);
    }
    p1.push_back(p);
    p1.insert(p1.end(), p2.begin(), p2.end());

    return p1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %r15
subq %rax, %r15
shrq $0x2, %r15
movl (%rax), %eax
movl %eax, 0xc(%rsp)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rax, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
testl %r15d, %r15d
jle 0x12ff
movq %rsi, %r14
leaq 0x8(%rbx), %r13
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
xorl %ebp, %ebp
leaq 0x10(%rsp), %r12
movq (%r14), %rdx
movl (%rdx,%rbp), %eax
cmpl 0xc(%rsp), %eax
jge 0x12d8
movq 0x8(%rbx), %rsi
movq %rbx, %rdi
movq %r13, %rcx
cmpq 0x10(%rbx), %rsi
je 0x12ee
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, (%rcx)
jmp 0x12f6
jle 0x12f6
movq 0x18(%rsp), %rsi
movq %r12, %rdi
leaq 0x18(%rsp), %rcx
cmpq 0x20(%rsp), %rsi
jne 0x12cd
addq %rbp, %rdx
callq 0x15de
addq $0x4, %rbp
decq %r15
jne 0x12b1
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x1319
movl 0xc(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x1326
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
callq 0x15de
movq 0x8(%rbx), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq %rbx, %rdi
callq 0x171a
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1353
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x10c0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1369
jmp 0x1369
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1383
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x10c0
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1397
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x10c0
movq %r14, %rdi
callq 0x1110
// File: /workspace/github_cpp_makefile_star2_O1/vividvilla[P]hackerrank/src/quicksort1.cpp
// Function: main
int main() {
    int n, x;
    cin >> n;

    vector<int> ar;
    for (int i = 0; i < n; i++) {
        cin >> x;
        ar.push_back(x);
    }

    vector<int> p = partition(ar);
    for (int i = 0; i < n; i++) {
        cout << p[i];
        if (i + 1 < n)
            cout << " ";
        else
            cout << endl;
    }

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq 0x2c30(%rip), %rdi      # 0x3fe0
leaq 0x8(%rsp), %rbx
movq %rbx, %rsi
callq 0x1060
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
cmpl $0x0, (%rbx)
jle 0x1421
xorl %ebp, %ebp
movq 0x2c04(%rip), %rbx      # 0x3fe0
leaq 0xc(%rsp), %r14
leaq 0x10(%rsp), %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1060
movq 0x18(%rsp), %rsi
cmpq 0x20(%rsp), %rsi
je 0x140e
movl 0xc(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x18(%rsp)
jmp 0x1419
movq %r15, %rdi
movq %r14, %rdx
callq 0x15de
incl %ebp
cmpl 0x8(%rsp), %ebp
jl 0x13e6
leaq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x155e
leaq 0x40(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x125c
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x1456
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x10c0
cmpl $0x0, 0x8(%rsp)
jle 0x14cf
xorl %r15d, %r15d
movq 0x2b69(%rip), %rbx      # 0x3fd0
leaq 0xb96(%rip), %r14       # 0x2004
movq 0x40(%rsp), %rax
movl (%rax,%r15,4), %esi
movq %rbx, %rdi
callq 0x1100
incq %r15
movslq 0x8(%rsp), %rax
cmpq %rax, %r15
jge 0x149e
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10d0
jmp 0x14c5
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x10a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1070
movslq 0x8(%rsp), %rax
cmpq %rax, %r15
jl 0x146e
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x14e6
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x10c0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x14fd
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x10c0
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x153f
movq 0x38(%rsp), %rsi
jmp 0x1537
jmp 0x1520
movq %rax, %rbx
jmp 0x153f
movq %rax, %rbx
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x153f
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x10c0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1556
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x10c0
movq %rbx, %rdi
callq 0x1110
// File: /workspace/github_cpp_makefile_star2_O1/ashlall[P]StreamStats/ChiSquareExperiments/VaryMemoryReal.cpp
// Function: name_file(char*, char**, int)
void name_file(char *str, char* argv[], int extra)
{
  time_t now = time(0);
  struct tm tstruct;
  char buf[80];
  tstruct = *localtime(&now);
  strftime(buf, sizeof(buf), "%m-%d-%Y.%X", &tstruct);

  strcpy(str, "RealContinuous_");
  strcat(str, argv[1]);
  strcat(str, "-");
  strcat(str, argv[2]);
  strcat(str, "_");
  strcat(str, argv[3]);
  strcat(str, "_");
  strcat(str, argv[5]);
  strcat(str, "_");
  strcat(str, buf);

  if (extra == 0)
  strcat(str, "_log.dat");
 else if (extra == 1)
   strcat(str, "_table.dat");
 else if (extra == 2)
   strcat(str, "_extra.dat");
 else 
   strcat(str, "_pvalues.dat");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
xorl %edi, %edi
callq 0x2200
leaq -0x30(%rbp), %rdi
movq %rax, (%rdi)
callq 0x2190
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
leaq -0x70(%rbp), %rcx
movaps %xmm0, (%rcx)
movaps %xmm1, 0x10(%rcx)
movaps %xmm2, 0x20(%rcx)
movq 0x30(%rax), %rax
movq %rax, 0x30(%rcx)
leaq 0x2665(%rip), %rdx      # 0x839a
leaq -0xc0(%rbp), %r12
movl $0x50, %esi
movq %r12, %rdi
callq 0x21d0
movups 0x2656(%rip), %xmm0     # 0x83a6
movups %xmm0, (%r14)
movq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0x23c0
movq %r14, %rdi
callq 0x2100
movw $0x2d, (%r14,%rax)
movq 0x10(%r15), %rsi
movq %r14, %rdi
callq 0x23c0
movq %r14, %rdi
callq 0x2100
movw $0x5f, %r13w
movw %r13w, (%r14,%rax)
movq 0x18(%r15), %rsi
movq %r14, %rdi
callq 0x23c0
movq %r14, %rdi
callq 0x2100
movw %r13w, (%r14,%rax)
movq 0x28(%r15), %rsi
movq %r14, %rdi
callq 0x23c0
movq %r14, %rdi
callq 0x2100
movw %r13w, (%r14,%rax)
movq %r14, %rdi
movq %r12, %rsi
callq 0x23c0
movq %r14, %rdi
callq 0x2100
addq %r14, %rax
cmpl $0x2, %ebx
je 0x5e02
cmpl $0x1, %ebx
je 0x5df6
testl %ebx, %ebx
jne 0x5e18
movabsq $0x7461642e676f6c5f, %rcx # imm = 0x7461642E676F6C5F
movq %rcx, (%rax)
movb $0x0, 0x8(%rax)
jmp 0x5e33
movabsq $0x642e656c6261745f, %rcx # imm = 0x642E656C6261745F
jmp 0x5e0c
movabsq $0x642e61727478655f, %rcx # imm = 0x642E61727478655F
movq %rcx, (%rax)
movl $0x746164, 0x7(%rax)    # imm = 0x746164
jmp 0x5e33
movabsq $0x7461642e736575, %rcx # imm = 0x7461642E736575
movq %rcx, 0x5(%rax)
movabsq $0x7365756c6176705f, %rcx # imm = 0x7365756C6176705F
movq %rcx, (%rax)
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/bluesky466[P]ResourcesParser/main.cpp
// Function: getArgv(char const*, char**, int)
const char* getArgv(const char* argv, char *argvs[], int count) {
	int index = findArgvIndex(argv, argvs, count);
	if(index>=0 && index+1 < count) {
		return argvs[index+1];
	}
	return nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
testl %edx, %edx
jle 0x3b66
movq %rdi, %r15
movl %edx, -0x2c(%rbp)
movl %edx, %r14d
xorl %r13d, %r13d
movq (%rbx,%r13,8), %rsi
movq %r15, %rdi
callq 0x3280
testl %eax, %eax
je 0x3b60
incq %r13
cmpq %r13, %r14
jne 0x3b46
jmp 0x3b63
movl %r13d, %r12d
movl -0x2c(%rbp), %edx
testl %r12d, %r12d
js 0x3b7c
incl %r12d
cmpl %edx, %r12d
jge 0x3b7c
movl %r12d, %eax
movq (%rbx,%rax,8), %rax
jmp 0x3b7e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/bluesky466[P]ResourcesParser/main.cpp
// Function: findArgvIndex(char const*, char**, int)
int findArgvIndex(const char* argv, char *argvs[], int count) {
	for(int i = 0 ; i<count ; i++) {
		if(strcmp(argv, argvs[i])==0) {
			return i;
		}
	}
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testl %edx, %edx
jle 0x3bcd
movq %rsi, %r14
movq %rdi, %r15
movl %edx, %r13d
xorl %r12d, %r12d
movq (%r14,%r12,8), %rsi
movq %r15, %rdi
callq 0x3280
testl %eax, %eax
je 0x3bca
incq %r12
cmpq %r12, %r13
jne 0x3bb0
jmp 0x3bcd
movl %r12d, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq