LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/pdx-cs-tutors[P]pdp/tests/base_test.cpp
// Function: BaseFailure::report() const
void BaseFailure::report() const {
    std::cout << termcolor::on_red << termcolor::bold << " FAILED " << termcolor::reset
              << " " << description << std::endl
              << "Initial:  " << initial << std::endl
              << "Called:   " << termcolor::bold << call << termcolor::reset << std::endl
              << "Expected: " << expected << std::endl
              << "Got:      " << actual << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x11c36(%rip), %rdi     # 0x1ffb8
callq 0xdc40
movq %rax, %rdi
callq 0xd4a0
leaq 0x9c71(%rip), %rsi      # 0x18007
movq %rax, %rdi
callq 0xd7b0
movq %rax, %rdi
callq 0xdae0
leaq 0x9c8d(%rip), %rsi      # 0x1803a
movq %rax, %rdi
callq 0xd7b0
leaq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0xd640
movq %rax, %rdi
callq 0xd340
leaq 0x9c40(%rip), %rsi      # 0x18010
movq %rax, %rdi
callq 0xd7b0
leaq 0x48(%rbx), %rsi
movq %rax, %rdi
callq 0xd640
movq %rax, %rdi
callq 0xd340
leaq 0x9c28(%rip), %rsi      # 0x1801b
movq %rax, %rdi
callq 0xd7b0
movq %rax, %rdi
callq 0xd4a0
leaq 0x28(%rbx), %rsi
movq %rax, %rdi
callq 0xd640
movq %rax, %rdi
callq 0xdae0
movq %rax, %rdi
callq 0xd340
leaq 0x9c00(%rip), %rsi      # 0x18026
movq %rax, %rdi
callq 0xd7b0
leaq 0x68(%rbx), %rsi
movq %rax, %rdi
callq 0xd640
movq %rax, %rdi
callq 0xd340
leaq 0x9be8(%rip), %rsi      # 0x18031
movq %rax, %rdi
callq 0xd7b0
addq $0x88, %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0xd640
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xd340
nop
// File: /workspace/github_cpp_makefile_star2_O2/pdx-cs-tutors[P]pdp/tests/base_test.cpp
// Function: BaseTestSuite::run(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int BaseTestSuite::run(std::string key) {
    int count = 0;
    if (key != "") {
        auto it = tests.find(key);
        if (it != tests.end()) {
            for (auto const& func: tests[key]) {
                setUp();
                func();
                tearDown();
                ++count;
            }
        }
    } else {
        for (auto const& test : tests) {
            for (auto const& func : test.second) {
                setUp();
                func();
                tearDown();
                ++count;
            }
        }
    }
    report();
    return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x99b0(%rip), %rsi      # 0x1803b
movq %r14, %rdi
callq 0xd570
leaq 0x10(%rbx), %r12
testb %al, %al
je 0xe6f0
leaq 0x8(%rbx), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xdce0
cmpq %r12, %rax
je 0xe741
movq %r15, %rdi
movq %r14, %rsi
callq 0xdec0
movq (%rax), %r15
movq 0x8(%rax), %r12
xorl %r14d, %r14d
cmpq %r12, %r15
je 0xe744
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq %r15, %rdi
callq 0xd7a0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
incl %r14d
addq $0x20, %r15
jmp 0xe6c8
movq 0x20(%rbx), %r15
xorl %r14d, %r14d
movq %r12, -0x30(%rbp)
cmpq %r12, %r15
je 0xe744
movq 0x40(%r15), %r12
movq 0x48(%r15), %r13
cmpq %r13, %r12
je 0xe730
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq %r12, %rdi
callq 0xd7a0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
incl %r14d
addq $0x20, %r12
jmp 0xe708
movq %r15, %rdi
callq 0xd480
movq %rax, %r15
movq -0x30(%rbp), %r12
jmp 0xe6fb
xorl %r14d, %r14d
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x38(%rax)
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/pdx-cs-tutors[P]pdp/tests/base_test.cpp
// Function: BaseTestSuite::test(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::function<void ()>)
void BaseTestSuite::test(std::string key, std::function<void()> function) {
    if (tests.find(key) == tests.end()) {
        std::vector<std::function<void()>> funcs = {function};
        tests.insert(std::make_pair(key, funcs));
    } else {
        tests[key].push_back(function);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0xdce0
addq $0x10, %r12
cmpq %r12, %rax
je 0xe7af
movq %rbx, %rdi
movq %r14, %rsi
callq 0xdec0
movq %rax, %rdi
movq %r15, %rsi
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xd540
leaq -0x78(%rbp), %rdi
movq %r15, %rsi
callq 0xdb70
leaq -0x40(%rbp), %rdi
leaq -0x78(%rbp), %rsi
pushq $0x1
popq %rdx
leaq -0x21(%rbp), %rcx
callq 0xddc0
leaq -0x78(%rbp), %rdi
callq 0xd490
leaq -0x78(%rbp), %rdi
leaq -0x40(%rbp), %rdx
movq %r14, %rsi
callq 0xd0d0
leaq -0x78(%rbp), %rsi
movq %rbx, %rdi
callq 0xd470
leaq -0x78(%rbp), %rdi
callq 0xd1f0
leaq -0x40(%rbp), %rdi
callq 0xd850
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0xd1f0
jmp 0xe824
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0xd850
jmp 0xe840
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0xd490
jmp 0xe840
movq %rax, %rbx
movq %rbx, %rdi
callq 0xddb0
// File: /workspace/github_cpp_makefile_star2_O2/pdx-cs-tutors[P]pdp/tests/cll/cll_test.cpp
// Function: stringify[abi:cxx11](cll::node*)
std::string stringify(cll::node* rear) {
    if (!rear) return "[]";
    cll::node* current = rear->next;
    std::stringstream ss;
    ss << "[";
    if (rear->next == rear) {
        ss << rear->data << "]";
        return ss.str();
    }
    do {
        ss << current->data;
        if (current->next != rear) ss << " -> ";
        current = current->next;
    } while (current != rear);
    ss << " -> " << rear->data << "]";
    return ss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movq %rdi, %rbx
testq %rsi, %rsi
je 0x1202b
movq %rsi, %r14
movq 0x8(%rsi), %r13
leaq -0x1b0(%rbp), %rdi
callq 0xd4b0
leaq -0x1a0(%rbp), %r15
leaq 0x605f(%rip), %rsi      # 0x18000
movq %r15, %rdi
callq 0xd7b0
cmpq %r14, 0x8(%r14)
je 0x11ff4
leaq 0x604c(%rip), %r12      # 0x18002
movl (%r13), %esi
movq %r15, %rdi
callq 0xdd20
movq 0x8(%r13), %rax
cmpq %r14, %rax
je 0x11fda
movq %r15, %rdi
movq %r12, %rsi
callq 0xd7b0
movq 0x8(%r13), %rax
movq %rax, %r13
cmpq %r14, %rax
jne 0x11fb6
leaq 0x6019(%rip), %rsi      # 0x18002
movq %r15, %rdi
callq 0xd7b0
movq %rax, %r15
movl (%r14), %esi
movq %r15, %rdi
callq 0xdd20
leaq 0x665b(%rip), %rsi      # 0x18661
movq %rax, %rdi
callq 0xd7b0
leaq -0x198(%rbp), %rsi
movq %rbx, %rdi
callq 0xdc20
leaq -0x1b0(%rbp), %rdi
callq 0xd4d0
jmp 0x12041
leaq 0x662e(%rip), %rsi      # 0x18660
leaq -0x1b0(%rbp), %rdx
movq %rbx, %rdi
callq 0xd2c0
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x12058
movq %rax, %rbx
leaq -0x1b0(%rbp), %rdi
callq 0xd4d0
movq %rbx, %rdi
callq 0xddb0
// File: /workspace/github_cpp_makefile_star2_O2/pdx-cs-tutors[P]pdp/tests/cll/cll_test.cpp
// Function: destroy_cll(cll::node*&)
void destroy_cll(cll::node*& rear) {
    if (rear == nullptr) return;
    cll::node* curr = rear;
    while (curr->next != rear) {
        cll::node* temp = curr->next;
        curr->next = temp->next;
        delete temp;
        temp = nullptr;
    }
    delete rear;
    rear = nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0x120ab
movq %rdi, %rbx
movq %r14, %rdi
movq 0x8(%r14), %rax
cmpq %rdi, %rax
je 0x120a2
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%r14)
movq %rax, %rdi
callq 0xd720
movq (%rbx), %rdi
jmp 0x12084
callq 0xd720
andq $0x0, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/pdx-cs-tutors[P]pdp/tests/cll/cll_test.cpp
// Function: CLLTestSuite::tearDown()
void CLLTestSuite::tearDown() {
    BaseTestSuite::tearDown();
    if (rear) destroy_cll(rear);
    rear = nullptr;
    initial = {};
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xd950
cmpq $0x0, 0x78(%rbx)
je 0x1239c
leaq 0x78(%rbx), %rdi
callq 0xd660
andq $0x0, 0x78(%rbx)
subq $-0x80, %rbx
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xd0e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/pdx-cs-tutors[P]pdp/tests/cll/cll_test.cpp
// Function: CLLTestSuite::initialize(std::initializer_list<int>)
void CLLTestSuite::initialize(std::initializer_list<int> values) {
    rear = nullptr;
    for (auto it = values.end(); it != values.begin();) {
        if (!rear) {
            rear = new cll::node();
            rear->data = *--it;
            rear->next = rear;
        } else {
            cll::node* temp = rear->next;
            rear->next = new cll::node();
            rear->next->data = *--it;
            rear->next->next = temp;
        }
    }
    initial = values;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, -0x30(%rbp)
andq $0x0, 0x78(%rdi)
leaq (%rsi,%rdx,4), %rax
movq %rax, -0x38(%rbp)
shlq $0x2, %r12
xorl %r14d, %r14d
pushq $0x10
popq %r13
testq %r12, %r12
je 0x1243a
testq %r14, %r14
je 0x1240d
movq 0x8(%r14), %r15
movq %r13, %rdi
callq 0xd7d0
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movq %rax, 0x8(%r14)
jmp 0x12429
movq %r13, %rdi
callq 0xd7d0
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movq -0x30(%rbp), %rcx
movq %rax, 0x78(%rcx)
movq %rax, %r15
movq %rax, %r14
movl -0x4(%rbx,%r12), %ecx
movl %ecx, (%rax)
movq %r15, 0x8(%rax)
addq $-0x4, %r12
jmp 0x123eb
movq -0x30(%rbp), %rdi
subq $-0x80, %rdi
movq %rbx, %rsi
movq -0x38(%rbp), %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xd0e0
// File: /workspace/github_cpp_makefile_star2_O2/pdx-cs-tutors[P]pdp/tests/cll/cll_test.cpp
// Function: CLLTestSuite::expectReturn(int)
void CLLTestSuite::expectReturn(int value) {
    if (retval == nullptr || *retval != value) {
        addFailure(CLLReturnFailure(
            "Incorrect return value",
            call,
            initial,
            value,
            *retval
        ));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xc8, %rsp
movl %esi, %r14d
movq %rdi, %rbx
movq 0x50(%rdi), %rax
testq %rax, %rax
je 0x12764
cmpl %r14d, (%rax)
je 0x127bf
leaq 0x58(%rbx), %rsi
leaq -0x38(%rbp), %r15
movq %r15, %rdi
callq 0xda90
leaq 0x80(%rbx), %rcx
movq 0x50(%rbx), %rax
movl (%rax), %r9d
leaq 0x5f0c(%rip), %rsi      # 0x18695
leaq -0xe0(%rbp), %rdi
movq %r15, %rdx
movl %r14d, %r8d
callq 0xdcb0
leaq -0xe0(%rbp), %rsi
movq %rbx, %rdi
callq 0xd9e0
leaq -0xe0(%rbp), %rdi
callq 0xde90
leaq -0x38(%rbp), %rdi
callq 0xd300
addq $0xc8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0xe0(%rbp), %rdi
callq 0xde90
jmp 0x127e1
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0xd300
movq %rbx, %rdi
callq 0xddb0
// File: /workspace/github_cpp_makefile_star2_O2/pdx-cs-tutors[P]pdp/tests/lll/lll_test.cpp
// Function: stringify[abi:cxx11](lll::node*)
std::string stringify(lll::node* head) {
    std::stringstream ss;
    ss << "[";
    while (head) {
        ss << head->data;
        if (head->next) ss << " -> ";
        head = head->next;
    }
    ss << "]";
    return ss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movq %rsi, %r12
movq %rdi, %rbx
leaq -0x1b0(%rbp), %rdi
callq 0xd4b0
leaq -0x1a0(%rbp), %r14
leaq 0x2f38(%rip), %rsi      # 0x18000
movq %r14, %rdi
callq 0xd7b0
leaq 0x2f2b(%rip), %r15      # 0x18002
testq %r12, %r12
je 0x15109
movq %r12, %r13
movl (%r12), %esi
movq %r14, %rdi
callq 0xdd20
cmpq $0x0, 0x8(%r13)
movl $0x0, %r12d
je 0x150d7
movq %r14, %rdi
movq %r15, %rsi
callq 0xd7b0
movq 0x8(%r13), %r12
jmp 0x150d7
leaq 0x3551(%rip), %rsi      # 0x18661
movq %r14, %rdi
callq 0xd7b0
leaq -0x198(%rbp), %rsi
movq %rbx, %rdi
callq 0xdc20
leaq -0x1b0(%rbp), %rdi
callq 0xd4d0
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1514a
movq %rax, %rbx
leaq -0x1b0(%rbp), %rdi
callq 0xd4d0
movq %rbx, %rdi
callq 0xddb0
// File: /workspace/github_cpp_makefile_star2_O2/pdx-cs-tutors[P]pdp/tests/lll/lll_test.cpp
// Function: destroy_lll(lll::node*)
void destroy_lll(lll::node* head) {
    while (head) {
        lll::node* temp = head->next;
        delete head;
        head = temp;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1517a
movq 0x8(%rdi), %rbx
callq 0xd720
movq %rbx, %rdi
jmp 0x15167
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/pdx-cs-tutors[P]pdp/tests/lll/lll_test.cpp
// Function: LLLTestSuite::tearDown()
void LLLTestSuite::tearDown() {
    if (head) destroy_lll(head);
    head = nullptr;// Verify that the nodes in the LLL match the given values
// e.g. expectList(head, {1, 2, 3});
// Add failures if there are discrepancies
    if (retval) delete retval;
    retval = nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x78(%rdi), %rdi
testq %rdi, %rdi
je 0x154b3
callq 0xd970
andq $0x0, 0x78(%rbx)
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x154c6
callq 0xd720
andq $0x0, 0x50(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/pdx-cs-tutors[P]pdp/tests/lll/lll_test.cpp
// Function: LLLTestSuite::expectList(std::initializer_list<int>)
void LLLTestSuite::expectList(std::initializer_list<int> values) {
    lll::node* curr = head;
    int count = 0;
    for (auto value : values) {
        if (!curr) {
            addFailure(LLLFailure(
                "Missing item(s)",
                call,
                initial,
                values,
                head
            ));
            return;
        } else if (curr->data != value) {
            addFailure(LLLFailure(
                "Incorrect value(s)",
                call,
                initial,
                values,
                head
            ));
            return;
        }
        ++count;
        curr = curr->next;
    }
    if (curr) {
        addFailure(LLLFailure(
            "Too many items",
            call,
            initial,
            values,
            head
        ));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x78(%rdi), %rax
leaq (,%rdx,4), %rcx
xorl %edx, %edx
movq (%rax), %rax
cmpq %rdx, %rcx
je 0x1556c
testq %rax, %rax
je 0x155d4
movl (%rax), %esi
cmpl (%r15,%rdx), %esi
jne 0x15630
addq $0x8, %rax
addq $0x4, %rdx
jmp 0x15549
testq %rax, %rax
je 0x1568f
leaq 0x58(%rbx), %rsi
leaq -0x40(%rbp), %r12
movq %r12, %rdi
callq 0xda90
leaq 0x80(%rbx), %rcx
movq 0x78(%rbx), %rax
movq %rax, (%rsp)
leaq 0x30d8(%rip), %rsi      # 0x18673
leaq -0x128(%rbp), %rdi
movq %r12, %rdx
movq %r15, %r8
movq %r14, %r9
callq 0xd2d0
leaq -0x128(%rbp), %rsi
movq %rbx, %rdi
callq 0xda50
leaq -0x128(%rbp), %rdi
callq 0xde90
leaq -0x40(%rbp), %rdi
jmp 0x1568a
leaq 0x58(%rbx), %rsi
leaq -0x80(%rbp), %r12
movq %r12, %rdi
callq 0xda90
leaq 0x80(%rbx), %rcx
movq 0x78(%rbx), %rax
movq %rax, (%rsp)
leaq 0x3069(%rip), %rsi      # 0x18663
leaq -0x128(%rbp), %rdi
movq %r12, %rdx
movq %r15, %r8
movq %r14, %r9
callq 0xd2d0
leaq -0x128(%rbp), %rsi
movq %rbx, %rdi
callq 0xda50
leaq -0x128(%rbp), %rdi
callq 0xde90
leaq -0x80(%rbp), %rdi
jmp 0x1568a
leaq 0x58(%rbx), %rsi
leaq -0x60(%rbp), %r12
movq %r12, %rdi
callq 0xda90
leaq 0x80(%rbx), %rcx
movq 0x78(%rbx), %rax
movq %rax, (%rsp)
leaq 0x302c(%rip), %rsi      # 0x18682
leaq -0x128(%rbp), %rdi
movq %r12, %rdx
movq %r15, %r8
movq %r14, %r9
callq 0xd2d0
leaq -0x128(%rbp), %rsi
movq %rbx, %rdi
callq 0xda50
leaq -0x128(%rbp), %rdi
callq 0xde90
leaq -0x60(%rbp), %rdi
callq 0xd300
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x128(%rbp), %rdi
callq 0xde90
jmp 0x156b3
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
jmp 0x156eb
movq %rax, %rbx
leaq -0x128(%rbp), %rdi
callq 0xde90
jmp 0x156cd
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
jmp 0x156eb
movq %rax, %rbx
leaq -0x128(%rbp), %rdi
callq 0xde90
jmp 0x156e7
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0xd300
movq %rbx, %rdi
callq 0xddb0
// File: /workspace/github_cpp_makefile_star2_O2/pdx-cs-tutors[P]pdp/tests/lll/lll_test.cpp
// Function: LLLTestSuite::expectReturn(int)
void LLLTestSuite::expectReturn(int value) {
    if (retval == nullptr || *retval != value) {
        addFailure(LLLReturnFailure(
            "Incorrect return value",
            call,
            initial,
            value,
            *retval
        ));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xc8, %rsp
movl %esi, %r14d
movq %rdi, %rbx
movq 0x50(%rdi), %rax
testq %rax, %rax
je 0x1571c
cmpl %r14d, (%rax)
je 0x15777
leaq 0x58(%rbx), %rsi
leaq -0x38(%rbp), %r15
movq %r15, %rdi
callq 0xda90
leaq 0x80(%rbx), %rcx
movq 0x50(%rbx), %rax
movl (%rax), %r9d
leaq 0x2f54(%rip), %rsi      # 0x18695
leaq -0xe0(%rbp), %rdi
movq %r15, %rdx
movl %r14d, %r8d
callq 0xda30
leaq -0xe0(%rbp), %rsi
movq %rbx, %rdi
callq 0xd5a0
leaq -0xe0(%rbp), %rdi
callq 0xde90
leaq -0x38(%rbp), %rdi
callq 0xd300
addq $0xc8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0xe0(%rbp), %rdi
callq 0xde90
jmp 0x15799
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0xd300
movq %rbx, %rdi
callq 0xddb0
// File: /workspace/github_cpp_makefile_star2_O2/pdx-cs-tutors[P]pdp/tests/lll/lll_test.cpp
// Function: LLLTestSuite::initialize(std::initializer_list<int>)
void LLLTestSuite::initialize(std::initializer_list<int> values) {
    head = nullptr;
    for (auto it = values.end(); it != values.begin();) {
        lll::node* temp = head;
        head = new lll::node();
        head->data = *--it;
        head->next = temp;
    }
    initial = values;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r15
andq $0x0, 0x78(%rdi)
leaq (%rsi,%rdx,4), %rax
movq %rax, -0x30(%rbp)
shlq $0x2, %r12
xorl %r14d, %r14d
pushq $0x10
popq %r13
testq %r12, %r12
je 0x1585e
movq %r13, %rdi
callq 0xd7d0
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movq %rax, 0x78(%r15)
movl -0x4(%rbx,%r12), %ecx
movl %ecx, (%rax)
movq %r14, 0x8(%rax)
addq $-0x4, %r12
movq %rax, %r14
jmp 0x15833
subq $-0x80, %r15
movq %r15, %rdi
movq %rbx, %rsi
movq -0x30(%rbp), %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xd0e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/linuxnoodle[P]typer/main.cpp
// Function: generateString[abi:cxx11](int)
string generateString(int wordCount){
    string generated;
    for (int i = 0; i < wordCount; ++i){
        generated += words[distribution(generator)];
        if (i != wordCount - 1){
            generated += " ";
        }
    }
    return generated;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
leal -0x1(%r14), %ebp
xorl %r13d, %r13d
testl %esi, %esi
cmovlel %r13d, %r14d
movb $0x0, 0x10(%rdi)
leaq 0x505f(%rip), %r15      # 0x7570
leaq 0x3cd0(%rip), %r12      # 0x61e8
cmpl %r13d, %r14d
je 0x2557
movq %r15, %rdi
movq %r12, %rsi
callq 0x2d18
shlq $0x5, %rax
addq 0x3c9d(%rip), %rax      # 0x61d0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2340
cmpl %r13d, %ebp
je 0x2552
movq %rbx, %rdi
leaq 0x1c28(%rip), %rsi      # 0x4175
callq 0x2330
incl %r13d
jmp 0x2518
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x20f0
movq %r14, %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O2/SpiritLooper[P]RDV_OBJRender/matrix.cpp
// Function: Matrix::identity(int)
Matrix Matrix::identity(int dimensions) {
    Matrix E(dimensions, dimensions);
    for (int i=0; i<dimensions; i++) {
        for (int j=0; j<dimensions; j++) {
            E[i][j] = (i==j ? 1.f : 0.f);
        }
    }
    return E;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, %edx
callq 0x24dc
xorl %r14d, %r14d
testl %ebp, %ebp
movl $0x0, %r15d
cmovgl %ebp, %r15d
movl %ebp, %r12d
cmpq %r15, %r14
je 0x25c0
xorl %r13d, %r13d
cmpq %r13, %r12
je 0x25bb
movss 0x4a76(%rip), %xmm0     # 0x7004
cmpq %r13, %r14
je 0x2596
xorps %xmm0, %xmm0
movss %xmm0, 0x4(%rsp)
movq %rbx, %rdi
movl %r14d, %esi
callq 0x25d2
movq (%rax), %rax
movss 0x4(%rsp), %xmm0
movss %xmm0, (%rax,%r13,4)
incq %r13
jmp 0x2581
incq %r14
jmp 0x2579
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/SpiritLooper[P]RDV_OBJRender/matrix.cpp
// Function: Matrix::operator*(Matrix const&)
Matrix Matrix::operator*(const Matrix& a) {
    assert(cols == a.rows);
    Matrix result(rows, a.cols);
    for (int i=0; i<rows; i++) {
        for (int j=0; j<a.cols; j++) {
            result.m[i][j] = 0.f;
            for (int k=0; k<cols; k++) {
                result.m[i][j] += m[i][k]*a.m[k][j];
            }
        }
    }
    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x1c(%rsi), %eax
cmpl 0x18(%rdx), %eax
jne 0x26c8
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl 0x18(%rsi), %esi
movl 0x1c(%rdx), %edx
callq 0x24dc
movl 0x18(%r15), %eax
movl 0x1c(%rbx), %ecx
xorl %edx, %edx
testl %ecx, %ecx
cmovlel %edx, %ecx
testl %eax, %eax
cmovlel %edx, %eax
xorl %esi, %esi
cmpq %rax, %rsi
je 0x26b6
imulq $0x18, %rsi, %rdi
movq (%r14), %r8
addq %rdi, %r8
movl 0x1c(%r15), %r9d
testl %r9d, %r9d
movl $0x0, %edx
cmovlel %edx, %r9d
xorl %r10d, %r10d
cmpq %rcx, %r10
je 0x26b1
movq (%r8), %r11
andl $0x0, (%r11,%r10,4)
movq (%r15), %r12
addq %rdi, %r12
movq (%rbx), %r13
xorps %xmm0, %xmm0
xorl %ebp, %ebp
cmpq %rbp, %r9
je 0x26ac
movq (%r12), %rdx
movss (%rdx,%rbp,4), %xmm1
movq (%r13), %rdx
mulss (%rdx,%r10,4), %xmm1
addss %xmm1, %xmm0
movss %xmm0, (%r11,%r10,4)
incq %rbp
addq $0x18, %r13
jmp 0x2681
incq %r10
jmp 0x2666
incq %rsi
jmp 0x2644
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4985(%rip), %rdi      # 0x7054
leaq 0x4941(%rip), %rsi      # 0x7017
leaq 0x4986(%rip), %rcx      # 0x7063
pushq $0x1d
popq %rdx
callq 0x2120
nop
// File: /workspace/github_cpp_makefile_star2_O2/SpiritLooper[P]RDV_OBJRender/matrix.cpp
// Function: Matrix::transpose()
Matrix Matrix::transpose() {
    Matrix result(cols, rows);
    for(int i=0; i<rows; i++)
        for(int j=0; j<cols; j++)
            result[j][i] = m[i][j];
    return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x18(%rsi), %edx
movl 0x1c(%rsi), %esi
callq 0x24dc
xorl %r12d, %r12d
movslq 0x18(%r14), %rax
cmpq %rax, %r12
jge 0x2757
imulq $0x18, %r12, %r13
xorl %r15d, %r15d
movslq 0x1c(%r14), %rax
cmpq %rax, %r15
jge 0x2752
movq (%r14), %rax
movq (%rax,%r13), %rax
movss (%rax,%r15,4), %xmm0
movss %xmm0, 0xc(%rsp)
movq %rbx, %rdi
movl %r15d, %esi
callq 0x25d2
movq (%rax), %rax
movss 0xc(%rsp), %xmm0
movss %xmm0, (%rax,%r12,4)
incq %r15
jmp 0x2717
incq %r12
jmp 0x2707
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/SpiritLooper[P]RDV_OBJRender/matrix.cpp
// Function: operator<<(std::ostream&, Matrix&)
std::ostream& operator<<(std::ostream& s, Matrix& m) {
    for (int i=0; i<m.nrows(); i++)  {
        for (int j=0; j<m.ncols(); j++) {
            s << m[i][j];
            if (j<m.ncols()-1) s << "\t";
        }
        s << "\n";
    }
    return s;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorl %r15d, %r15d
leaq 0x45ec(%rip), %r12      # 0x70b0
leaq 0x45e7(%rip), %r13      # 0x70b2
cmpl 0x18(%r14), %r15d
jge 0x2b23
xorl %ebp, %ebp
movslq 0x1c(%r14), %rax
cmpq %rax, %rbp
jge 0x2b13
movq %r14, %rdi
movl %r15d, %esi
callq 0x25d2
movq (%rax), %rax
movss (%rax,%rbp,4), %xmm0
movq %rbx, %rdi
callq 0x2150
movslq 0x1c(%r14), %rax
decq %rax
cmpq %rax, %rbp
jge 0x2b0e
movq %rbx, %rdi
movq %r12, %rsi
callq 0x21a0
incq %rbp
jmp 0x2ad3
movq %rbx, %rdi
movq %r13, %rsi
callq 0x21a0
incl %r15d
jmp 0x2acb
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/SpiritLooper[P]RDV_OBJRender/camera.cpp
// Function: Camera::translate(float, float, float)
Matrix Camera::translate(float x, float y , float z) {
    Matrix R = Matrix::identity(4);

    R[0][3] = x;
    R[1][3] = y;
    R[2][3] = z;

    return R;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movss %xmm2, 0xc(%rsp)
movss %xmm1, 0x10(%rsp)
movss %xmm0, 0x14(%rsp)
movq %rdi, %rbx
pushq $0x4
popq %rsi
callq 0x2550
movq %rbx, %rdi
xorl %esi, %esi
callq 0x25d2
movq (%rax), %rax
movss 0x14(%rsp), %xmm0
movss %xmm0, 0xc(%rax)
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x25d2
movq (%rax), %rax
movss 0x10(%rsp), %xmm0
movss %xmm0, 0xc(%rax)
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x25d2
movq (%rax), %rax
movss 0xc(%rsp), %xmm0
movss %xmm0, 0xc(%rax)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x2be2
movq %r14, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O2/SpiritLooper[P]RDV_OBJRender/camera.cpp
// Function: Camera::v2m(Vec3<float>)
Matrix Camera::v2m(Vec3f v) {
    Matrix m(4,1);
    for (int i = 0; i < 3; i++)
    {
        m[i][0] = v[i];
    }
    m[3][0] = 1.;
    return m;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movlps %xmm0, (%r14)
movss %xmm1, 0x8(%r14)
pushq $0x4
popq %rsi
pushq $0x1
popq %rdx
callq 0x24dc
xorl %r15d, %r15d
cmpq $0x3, %r15
je 0x3287
movq %r14, %rdi
movq %r15, %rsi
callq 0x3902
movss (%rax), %xmm0
movss %xmm0, 0xc(%rsp)
movq %rbx, %rdi
movl %r15d, %esi
callq 0x25d2
movq (%rax), %rax
movss 0xc(%rsp), %xmm0
movss %xmm0, (%rax)
incq %r15
jmp 0x324f
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x25d2
movq (%rax), %rax
movl $0x3f800000, (%rax)     # imm = 0x3F800000
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x32aa
movq %rax, %r14
movq %rbx, %rdi
callq 0x2be2
movq %r14, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/SpiritLooper[P]RDV_OBJRender/camera.cpp
// Function: Camera::lookat()
Matrix Camera::lookat() {
    Vec3f z = (eye-center).normalize();
    Vec3f x = (up^z).normalize();
    Vec3f y = (z^x).normalize();
    Matrix res = Matrix::identity(4);
    for (int i=0; i<3; i++) {
        res[0][i] = x[i];
        res[1][i] = y[i];
        res[2][i] = z[i];
        res[i][3] = -center[i];
    }
    return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0xc(%rsi), %r14
movq %rsi, %rdi
movq %r14, %rsi
callq 0x3946
leaq 0x18(%rsp), %r12
movlps %xmm0, (%r12)
movss %xmm1, 0x8(%r12)
movss 0x3d0a(%rip), %xmm0     # 0x7004
movq %r12, %rdi
callq 0x395c
movq (%rax), %rcx
leaq 0x28(%rsp), %rbp
movq %rcx, (%rbp)
movl 0x8(%rax), %eax
movl %eax, 0x8(%rbp)
addq $0x18, %r15
movq %r15, %rdi
movq %rbp, %rsi
callq 0x399c
leaq 0x48(%rsp), %r13
movlps %xmm0, (%r13)
movss %xmm1, 0x8(%r13)
movq %r13, %rdi
movss 0x3cc6(%rip), %xmm0     # 0x7004
callq 0x395c
movq (%rax), %rcx
movq %rcx, (%r12)
movl 0x8(%rax), %eax
movl %eax, 0x8(%r12)
leaq 0x18(%rsp), %rsi
movq %rbp, %rdi
callq 0x399c
leaq 0x38(%rsp), %rdi
movlps %xmm0, (%rdi)
movss %xmm1, 0x8(%rdi)
movss 0x3c90(%rip), %xmm0     # 0x7004
callq 0x395c
movq (%rax), %rcx
movq %rcx, (%r13)
movl 0x8(%rax), %eax
movl %eax, 0x8(%r13)
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x2550
xorl %ebp, %ebp
pushq $0x1
popq %r15
pushq $0x2
popq %r12
cmpq $0x3, %rbp
je 0x3465
leaq 0x18(%rsp), %rdi
movq %rbp, %rsi
callq 0x3902
movss (%rax), %xmm0
movss %xmm0, (%rsp)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x25d2
movq (%rax), %rax
movss (%rsp), %xmm0
movss %xmm0, (%rax,%rbp,4)
movq %r13, %rdi
movq %rbp, %rsi
callq 0x3902
movss (%rax), %xmm0
movss %xmm0, (%rsp)
movq %rbx, %rdi
movl %r15d, %esi
callq 0x25d2
movq (%rax), %rax
movss (%rsp), %xmm0
movss %xmm0, (%rax,%rbp,4)
leaq 0x28(%rsp), %rdi
movq %rbp, %rsi
callq 0x3902
movss (%rax), %xmm0
movss %xmm0, (%rsp)
movq %rbx, %rdi
movl %r12d, %esi
callq 0x25d2
movq (%rax), %rax
movss (%rsp), %xmm0
movss %xmm0, (%rax,%rbp,4)
movq %r14, %rdi
movq %rbp, %rsi
callq 0x3902
movss (%rax), %xmm0
movaps %xmm0, (%rsp)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x25d2
movaps (%rsp), %xmm0
xorps 0x3cbb(%rip), %xmm0     # 0x7110
movq (%rax), %rax
movss %xmm0, 0xc(%rax)
incq %rbp
jmp 0x339c
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x2be2
movq %r14, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O2/SpiritLooper[P]RDV_OBJRender/camera.cpp
// Function: Camera::camera_transform(Vec3<float>)
Vec3f Camera::camera_transform(Vec3f p) {
    Matrix res = ViewPort;
    Matrix ModelView = lookat();

    if (mode == PERSPECTIVE)
    {
        res = res * Projection;
    }

    return m2v(res * ModelView * v2m(p));
}

// Assembly:
pushq %rbx
subq $0xc0, %rsp
movss %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq %rdi, %rbx
leaq 0x28(%rdi), %rsi
leaq 0x40(%rsp), %rdi
callq 0x39da
leaq 0xa0(%rsp), %rdi
movq %rbx, %rsi
callq 0x32be
cmpl $0x1, 0x68(%rbx)
jne 0x34f3
addq $0x48, %rbx
leaq 0x20(%rsp), %rdi
leaq 0x40(%rsp), %rsi
movq %rbx, %rdx
callq 0x2604
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rbx
movq %rbx, %rsi
callq 0x38e0
movq %rbx, %rdi
callq 0x2be2
leaq 0x20(%rsp), %rdi
leaq 0x40(%rsp), %rsi
leaq 0xa0(%rsp), %rdx
callq 0x2604
leaq 0x60(%rsp), %rdi
movaps (%rsp), %xmm0
movss 0x10(%rsp), %xmm1
callq 0x3226
leaq 0x80(%rsp), %rdi
leaq 0x20(%rsp), %rsi
leaq 0x60(%rsp), %rdx
callq 0x2604
leaq 0x80(%rsp), %rsi
callq 0x30d6
movaps %xmm0, 0x10(%rsp)
movss %xmm1, (%rsp)
leaq 0x80(%rsp), %rdi
callq 0x2be2
leaq 0x60(%rsp), %rdi
callq 0x2be2
leaq 0x20(%rsp), %rdi
callq 0x2be2
leaq 0xa0(%rsp), %rdi
callq 0x2be2
leaq 0x40(%rsp), %rdi
callq 0x2be2
movaps 0x10(%rsp), %xmm0
movss (%rsp), %xmm1
addq $0xc0, %rsp
popq %rbx
retq
jmp 0x35c9
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0x2be2
jmp 0x35ae
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x2be2
jmp 0x35bd
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2be2
jmp 0x35cc
movq %rax, %rbx
leaq 0xa0(%rsp), %rdi
callq 0x2be2
leaq 0x40(%rsp), %rdi
callq 0x2be2
movq %rbx, %rdi
callq 0x22b0
movq %rax, %rbx
jmp 0x35d9
// File: /workspace/github_cpp_makefile_star2_O2/SpiritLooper[P]RDV_OBJRender/image.cpp
// Function: Image::exportPPM()
void Image::exportPPM() {
    std::ofstream ofs;
    ofs.open("./out.ppm");
    ofs << "P6" << std::endl << width << " " << height << std::endl << "255" << std::endl;
    for (int i = 0; i < width * height; i++)
    {
        for (int j = 0; j < 3; j++)
        {
            ofs << (char)(255 * std::max(0.f, std::min(1.f , framebuffer[i][j]) ) );
        }
    }
    ofs.close();   
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x2290
leaq 0x35e3(%rip), %rsi      # 0x7170
pushq $0x10
popq %rdx
movq %r14, %rdi
callq 0x2040
leaq 0x35db(%rip), %rsi      # 0x717a
movq %rsp, %rdi
callq 0x21a0
movq %rax, %rdi
callq 0x20e0
movl 0x18(%rbx), %esi
movq %rax, %rdi
callq 0x22a0
leaq 0x35f0(%rip), %rsi      # 0x71b1
movq %rax, %rdi
callq 0x21a0
movl 0x1c(%rbx), %esi
movq %rax, %rdi
callq 0x22a0
movq %rax, %rdi
callq 0x20e0
leaq 0x359a(%rip), %rsi      # 0x717d
movq %rax, %rdi
callq 0x21a0
movq %rax, %rdi
callq 0x20e0
xorl %r12d, %r12d
movq %rsp, %r14
movslq 0x18(%rbx), %rax
movslq 0x1c(%rbx), %rcx
imulq %rax, %rcx
cmpq %rcx, %r12
jge 0x3c5a
imulq $0xc, %r12, %r13
xorl %r15d, %r15d
cmpq $0x3, %r15
je 0x3c55
movq (%rbx), %rdi
addq %r13, %rdi
movq %r15, %rsi
callq 0x3902
movss (%rax), %xmm0
minss 0x33d3(%rip), %xmm0     # 0x7004
maxss 0x3533(%rip), %xmm0     # 0x716c
mulss 0x3527(%rip), %xmm0     # 0x7168
cvttss2si %xmm0, %eax
movsbl %al, %esi
movq %r14, %rdi
callq 0x21e0
incq %r15
jmp 0x3c11
incq %r12
jmp 0x3bf9
movq %rsp, %rdi
callq 0x2220
movq %rsp, %rdi
callq 0x2240
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x3c7d
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2240
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O2/SpiritLooper[P]RDV_OBJRender/image.cpp
// Function: Image::setPixel(int, int, Vec3<float>)
void Image::setPixel(const int x, const int y, Vec3f color) {
    for (int i = 0; i < 3; i++)
    {
        if(color[i] > 1.) 
            color[i] = 1.;
        
        if( color[i] < 0. )
            color[i] = 0.;
    }
    

    if( 0 <= x && x < width && 0 <= y && y < height )
        framebuffer[x + y * width] = color;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %r14d
movl %esi, %ebp
movq %rdi, %rbx
movq %rsp, %r15
movlps %xmm0, (%r15)
movss %xmm1, 0x8(%r15)
xorl %r12d, %r12d
cmpq $0x3, %r12
je 0x3d09
movq %r15, %rdi
movq %r12, %rsi
callq 0x3902
movss (%rax), %xmm0
ucomiss 0x3334(%rip), %xmm0     # 0x7004
jbe 0x3ce3
movq %r15, %rdi
movq %r12, %rsi
callq 0x3902
movl $0x3f800000, (%rax)     # imm = 0x3F800000
movq %r15, %rdi
movq %r12, %rsi
callq 0x3902
xorps %xmm0, %xmm0
ucomiss (%rax), %xmm0
jbe 0x3d04
movq %r15, %rdi
movq %r12, %rsi
callq 0x3902
andl $0x0, (%rax)
incq %r12
jmp 0x3cb4
testl %ebp, %ebp
js 0x3d3c
testl %r14d, %r14d
js 0x3d3c
movl 0x18(%rbx), %eax
cmpl %ebp, %eax
jle 0x3d3c
cmpl %r14d, 0x1c(%rbx)
jle 0x3d3c
imull %r14d, %eax
addl %ebp, %eax
movq (%rbx), %rcx
imulq $0xc, %rax, %rax
movl 0x8(%rsp), %edx
movl %edx, 0x8(%rcx,%rax)
movq (%rsp), %rdx
movq %rdx, (%rcx,%rax)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/SpiritLooper[P]RDV_OBJRender/image.cpp
// Function: Image::flip(int)
void Image::flip(const int type) {
   std::vector<Vec3f> framebuffer_tmp(width * height);

    for (int x = 0; x < width; x++)
    {
        for (int y = 0; y < height; y++)
        {
            if ( type ==  HORIZONTAL_FLIP ) {
                framebuffer_tmp[ x + y * width ] = framebuffer[ ( width - 1 - x ) + ( y ) * width ];
            } else {
                framebuffer_tmp[ x + y * width ] = framebuffer[ x + (height - 1 - y ) * width ];
            }
        }
    }
    
    framebuffer = framebuffer_tmp;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movslq 0x18(%rdi), %rax
movslq 0x1c(%rdi), %rsi
imulq %rax, %rsi
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x3f3e
xorl %eax, %eax
pushq $-0x1
popq %rcx
cmpl 0x18(%rbx), %eax
jge 0x3e55
movl %eax, %edx
notl %edx
xorl %esi, %esi
movl %ecx, %edi
movl 0x1c(%rbx), %r8d
cmpl %r8d, %esi
jge 0x3e4e
cmpl $0x1, %ebp
jne 0x3e08
movl 0x18(%rbx), %r8d
leal (%r8,%rdx), %r9d
imull %esi, %r8d
addl %r8d, %r9d
movslq %r9d, %r9
movq (%rbx), %r10
imulq $0xc, %r9, %r9
addl %eax, %r8d
movslq %r8d, %r8
movq 0x8(%rsp), %r11
imulq $0xc, %r8, %r8
movl 0x8(%r10,%r9), %r14d
movl %r14d, 0x8(%r11,%r8)
movq (%r10,%r9), %r9
movq %r9, (%r11,%r8)
jmp 0x3e45
addl %edi, %r8d
movl 0x18(%rbx), %r9d
imull %r9d, %r8d
addl %eax, %r8d
movslq %r8d, %r8
movq (%rbx), %r10
imulq $0xc, %r8, %r8
imull %esi, %r9d
addl %eax, %r9d
movslq %r9d, %r9
movq 0x8(%rsp), %r11
imulq $0xc, %r9, %r9
movl 0x8(%r10,%r8), %r14d
movl %r14d, 0x8(%r11,%r9)
movq (%r10,%r8), %r8
movq %r8, (%r11,%r9)
incl %esi
decl %edi
jmp 0x3dba
incl %eax
jmp 0x3da9
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3f90
leaq 0x8(%rsp), %rdi
callq 0x40aa
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x40aa
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O2/SpiritLooper[P]RDV_OBJRender/image.cpp
// Function: Image::getPixel(int, int)
Vec3f Image::getPixel(const int x, const int y) {
    if( 0 <= x && x < width && 0 <= y && y < height )
        return framebuffer[x + y * width];
    else 
        return Vec3f(0,0,0);
}

// Assembly:
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
testl %esi, %esi
js 0x3ebb
testl %edx, %edx
js 0x3ebb
movl 0x18(%rdi), %eax
cmpl %esi, %eax
jle 0x3ebb
cmpl %edx, 0x1c(%rdi)
jle 0x3ebb
imull %edx, %eax
addl %esi, %eax
movq (%rdi), %rcx
imulq $0xc, %rax, %rax
movsd (%rcx,%rax), %xmm0
movss 0x8(%rcx,%rax), %xmm1
retq
// File: /workspace/github_cpp_makefile_star2_O2/SpiritLooper[P]RDV_OBJRender/image.cpp
// Function: Image::fusionner(Image&)
Image Image::fusionner(Image& i) {
    Image res(width, height);

    for (int j = 0; j < width * height; j++)
    {
        res.setPixel(j % width, j / width , Vec3f( framebuffer[j].x + i.framebuffer[j].x, 
                                                  framebuffer[j].y + i.framebuffer[j].y,                                  
                                                  framebuffer[j].z + i.framebuffer[j].z                                  
                                                ) );
    }
    
    return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl 0x18(%rsi), %esi
movl 0x1c(%r15), %edx
callq 0x3b28
pushq $0x8
popq %r13
xorl %r12d, %r12d
movslq 0x18(%r15), %rcx
movslq 0x1c(%r15), %rax
imulq %rcx, %rax
cmpq %rax, %r12
jge 0x3f30
movl %r12d, %eax
cltd
idivl %ecx
movq (%r15), %rcx
movq (%rbx), %rsi
movsd -0x8(%rcx,%r13), %xmm1
movsd -0x8(%rsi,%r13), %xmm0
addps %xmm1, %xmm0
movss (%rcx,%r13), %xmm1
addss (%rsi,%r13), %xmm1
movq %r14, %rdi
movl %edx, %esi
movl %eax, %edx
callq 0x3c90
incq %r12
addq $0xc, %r13
jmp 0x3ee1
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/SpiritLooper[P]RDV_OBJRender/model.cpp
// Function: Model::get_bbox(Vec3<float>&, Vec3<float>&)
void Model::get_bbox(Vec3f &min, Vec3f &max) {
    min = max = verts_[0];
    for (int i = 1; i < (int)verts_.size(); i++)
    {
        for (int j = 0; j < 3; j++)
        {
            min[j] = std::min(min[j],verts_[i][j] );
            max[j] = std::max(max[j],verts_[i][j] );
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdx)
movq (%rax), %rcx
movq %rcx, (%rdx)
movq (%rax), %rcx
movl 0x8(%rax), %eax
movl %eax, 0x8(%rsi)
movq %rcx, (%rsi)
pushq $0x1
popq %rcx
movq 0x8(%r15), %rax
subq (%r15), %rax
cqto
pushq $0xc
popq %rsi
idivq %rsi
cltq
cmpq %rax, %rcx
jge 0x477a
movq %rcx, 0x10(%rsp)
imulq $0xc, %rcx, %rbp
xorl %r12d, %r12d
cmpq $0x3, %r12
je 0x476d
movq %r14, %rdi
movq %r12, %rsi
callq 0x3902
movq %rax, %r13
movq (%r15), %rdi
addq %rbp, %rdi
movq %r12, %rsi
callq 0x3902
movss (%rax), %xmm0
minss (%r13), %xmm0
movss %xmm0, 0xc(%rsp)
movq %r14, %rdi
movq %r12, %rsi
callq 0x3902
movss 0xc(%rsp), %xmm0
movss %xmm0, (%rax)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3902
movq %rax, %r13
movq (%r15), %rdi
addq %rbp, %rdi
movq %r12, %rsi
callq 0x3902
movss (%rax), %xmm0
maxss (%r13), %xmm0
movss %xmm0, 0xc(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3902
movss 0xc(%rsp), %xmm0
movss %xmm0, (%rax)
incq %r12
jmp 0x46d9
movq 0x10(%rsp), %rcx
incq %rcx
jmp 0x46b3
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/SpiritLooper[P]RDV_OBJRender/./triangle.hpp
// Function: barycentric(Vec3<float>, Vec3<float>, Vec3<float>, Vec3<float>)
Vec3f barycentric(Vec3f A, Vec3f B, Vec3f C, Vec3f P) {
    Vec3f s[2];
    for (int i=2; i--; ) {
        s[i][0] = C[i]-A[i];
        s[i][1] = B[i]-A[i];
        s[i][2] = A[i]-P[i];
    }
    Vec3f u = s[0] ^ s[1];
    if (std::abs(u[2])>1e-2) 
        return Vec3f(1.f-(u.x+u.y)/u.z, u.y/u.z, u.x/u.z);
    return Vec3f(-1,1,1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
leaq 0x58(%rsp), %rbx
movlps %xmm0, (%rbx)
movss %xmm1, 0x8(%rbx)
leaq 0x48(%rsp), %r14
movlps %xmm2, (%r14)
movss %xmm3, 0x8(%r14)
leaq 0x38(%rsp), %r15
movlps %xmm4, (%r15)
movss %xmm5, 0x8(%r15)
leaq 0x28(%rsp), %r12
movlps %xmm6, (%r12)
movss %xmm7, 0x8(%r12)
xorps %xmm0, %xmm0
leaq 0x24(%rsp), %rbp
movaps %xmm0, -0x14(%rbp)
andq $0x0, -0x4(%rbp)
pushq $0x1
popq %r13
cmpq $-0x1, %r13
je 0x5696
movq %r15, %rdi
movq %r13, %rsi
callq 0x3902
movss (%rax), %xmm0
movss %xmm0, 0xc(%rsp)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x3902
movss 0xc(%rsp), %xmm0
subss (%rax), %xmm0
movss %xmm0, -0x8(%rbp)
movq %r14, %rdi
movq %r13, %rsi
callq 0x3902
movss (%rax), %xmm0
movss %xmm0, 0xc(%rsp)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x3902
movss 0xc(%rsp), %xmm0
subss (%rax), %xmm0
movss %xmm0, -0x4(%rbp)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x3902
movss (%rax), %xmm0
movss %xmm0, 0xc(%rsp)
movq %r12, %rdi
movq %r13, %rsi
callq 0x3902
movss 0xc(%rsp), %xmm0
subss (%rax), %xmm0
movss %xmm0, (%rbp)
decq %r13
addq $-0xc, %rbp
jmp 0x55f3
leaq 0x1c(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x399c
movaps %xmm0, %xmm2
movaps 0x1b51(%rip), %xmm0     # 0x7200
andps %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
ucomisd 0x1b92(%rip), %xmm0     # 0x7250
jbe 0x56eb
movaps %xmm2, %xmm3
shufps $0x55, %xmm2, %xmm3     # xmm3 = xmm3[1,1],xmm2[1,1]
movaps %xmm2, %xmm4
addss %xmm3, %xmm4
divss %xmm1, %xmm4
movss 0x192a(%rip), %xmm0     # 0x7004
subss %xmm4, %xmm0
divss %xmm1, %xmm3
unpcklps %xmm3, %xmm0            # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1]
divss %xmm1, %xmm2
jmp 0x56fb
movss 0x1911(%rip), %xmm2     # 0x7004
movsd 0x1b15(%rip), %xmm0     # 0x7210
movaps %xmm2, %xmm1
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/SpiritLooper[P]RDV_OBJRender/obj_render.cpp
// Function: main
int main(int argc, char const ** argv)
{
    std::string file_obj = "./model/head.obj";
    
    bool _3Dmode = true;

    if(argc >= 2) {
        for (int i = 1; i <= 2 && i < argc; i++)
        {
            if ( std::string(argv[i]) == "--no-3d" ){
                _3Dmode = false;
                std::cout << "*** Disabled 3D ***"  << std::endl;

            } else {
                file_obj = std::string(argv[i]) ;
            }
        }
    }
    
    std::cout << "Loading model " << file_obj << std::endl;
    Model* model = new Model(file_obj.c_str());
    
    render(model, _3Dmode);
    
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x1331(%rip), %rsi      # 0x7294
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x4e1e
movb $0x1, %r15b
cmpl $0x2, %ebp
jl 0x601f
pushq $0x3
popq %r13
cmovbel %ebp, %r13d
movb $0x1, %al
movl %eax, 0x4(%rsp)
pushq $0x1
popq %r12
leaq 0x28(%rsp), %r14
leaq 0x3(%rsp), %r15
cmpq %r13, %r12
jae 0x601a
movq (%rbx,%r12,8), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x4e1e
movq %r14, %rdi
leaq 0x12ed(%rip), %rsi      # 0x72a5
callq 0x6144
movl %eax, %ebp
movq %r14, %rdi
callq 0x20c0
testb %bpl, %bpl
je 0x5ff1
movq 0x5005(%rip), %rdi      # 0xafd8
leaq 0x12d3(%rip), %rsi      # 0x72ad
callq 0x21a0
movq %rax, %rdi
callq 0x20e0
movl $0x0, 0x4(%rsp)
jmp 0x6015
movq (%rbx,%r12,8), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x4e1e
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x21f0
movq %r14, %rdi
callq 0x20c0
incq %r12
jmp 0x5f9a
movl 0x4(%rsp), %r15d
movq 0x4fb2(%rip), %rdi      # 0xafd8
leaq 0x1294(%rip), %rsi      # 0x72c1
callq 0x21a0
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x2190
movq %rax, %rdi
callq 0x20e0
pushq $0x30
popq %rdi
callq 0x21b0
movq %rax, %r14
movq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x41a8
movzbl %r15b, %esi
andl $0x1, %esi
movq %r14, %rdi
callq 0x5a4b
leaq 0x8(%rsp), %rdi
callq 0x20c0
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x30
popq %rsi
movq %r14, %rdi
callq 0x21c0
jmp 0x60a4
jmp 0x60a1
jmp 0x60a1
jmp 0x60a1
jmp 0x60a1
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20c0
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/examples/array-parms4.cc
// Function: main
int main()
{
	int a1[] = {0,1,2,3,4,5,6,7,8,9};
	int a2[] = {1,3,5};
	string a3[4];

	print(a1);  // instantiates print(int (&arr)[10])

	print(a2);  // instantiates print(int (&arr)[3])

	print(a3);  // instantiates print(string (&arr)[42])

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xc0, %rsp
movaps 0xe1f(%rip), %xmm0      # 0x2020
movaps %xmm0, -0x40(%rbp)
movaps 0xe04(%rip), %xmm0      # 0x2010
movaps %xmm0, -0x50(%rbp)
movabsq $0x900000008, %rax      # imm = 0x900000008
movq %rax, -0x30(%rbp)
movabsq $0x300000001, %rax      # imm = 0x300000001
movq %rax, -0x20(%rbp)
movl $0x5, -0x18(%rbp)
pushq $0x10
popq %rax
leaq (%rax,%rbp), %rcx
addq $-0xd0, %rcx
movq %rcx, -0x10(%rcx)
andq $0x0, -0x8(%rcx)
movb $0x0, (%rcx)
addq $0x20, %rax
cmpq $0x90, %rax
jne 0x1236
leaq -0x50(%rbp), %rdi
callq 0x12cb
leaq -0x20(%rbp), %rdi
callq 0x130d
leaq -0xd0(%rbp), %rdi
callq 0x134f
pushq $0x60
popq %rbx
leaq (%rbx,%rbp), %rdi
addq $-0xd0, %rdi
callq 0x1030
addq $-0x20, %rbx
cmpq $-0x20, %rbx
jne 0x127a
xorl %eax, %eax
addq $0xc0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
pushq $0x60
popq %r14
leaq (%r14,%rbp), %rdi
addq $-0xd0, %rdi
callq 0x1030
addq $-0x20, %r14
cmpq $-0x20, %r14
jne 0x12a9
movq %rbx, %rdi
callq 0x10a0
// File: /workspace/github_cpp_makefile_star2_O2/sile[P]mphf/mphf.cc
// Function: main
int main(int argc, char** argv) {
  if(argc != 2) {
    std::cerr << "Usage: mphf <index>" << std::endl;
    return 1;
  }

  const char* index_filepath = argv[1];
  
  MPHF::Hash hash(index_filepath);
  if(!hash) {
    std::cerr << "Can't open file: " << index_filepath << std::endl;
    return 1;
  }

  std::string line;

  while(std::getline(std::cin, line)) 
    std::cout << hash.mphf(line.c_str()) << std::endl;

  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
cmpl $0x2, %edi
jne 0x12eb
movq 0x8(%rsi), %rbx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x13a0
cmpq $-0x1, 0x8(%r14)
je 0x1317
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x2d35(%rip), %rbx      # 0x3fd8
movq %rsp, %r14
leaq 0x20(%rsp), %r15
movq 0x2d16(%rip), %r12      # 0x3fc8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1030
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x130b
movq (%rsp), %rsi
movq %r15, %rdi
callq 0x137a
movl %eax, %esi
movq %r12, %rdi
callq 0x1080
movq %rax, %rdi
callq 0x1060
jmp 0x12b2
movq 0x2cfe(%rip), %rdi      # 0x3ff0
leaq 0xd0b(%rip), %rsi       # 0x2004
callq 0x10b0
movq %rax, %rdi
callq 0x1060
pushq $0x1
popq %rbx
jmp 0x134a
movq %rsp, %rdi
callq 0x1050
xorl %ebx, %ebx
jmp 0x1340
movq 0x2cd2(%rip), %rdi      # 0x3ff0
leaq 0xcf3(%rip), %rsi       # 0x2018
callq 0x10b0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x10b0
movq %rax, %rdi
callq 0x1060
pushq $0x1
popq %rbx
leaq 0x20(%rsp), %rdi
callq 0x16c6
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0x1368
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1050
leaq 0x20(%rsp), %rdi
callq 0x16c6
movq %rbx, %rdi
callq 0x1100
// File: /workspace/github_cpp_makefile_star2_O2/mattdibi[P]Programmatore-JTAG-per-Xilinx/main.cpp
// Function: SanitizeInput(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void SanitizeInput(string& s)
{
   // Questa funzione permette la stampa sul terminale corretta dell'output dell'arduino
   for(int i=0; i<s.length(); i++)
      if(s[i]=='\t')
         s[i]='\n';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
cmpq %rax, 0x8(%rdi)
jbe 0x42f6
movq (%rdi), %rcx
cmpb $0x9, (%rcx,%rax)
jne 0x42f1
movb $0xa, (%rcx,%rax)
incq %rax
jmp 0x42de
popq %rbp
retq