LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/MechaDragonX[P]CPPCollections/queue.cpp
// Function: Queue<float>::add(float)
void Queue<T>::add(T value) {
    if(head_ == nullptr)
        head_ = new DoubleListNode<T>{ value, nullptr, tail_ };
        // tail = nullptr in this case
    else if(size_ == 1) {
        // Set tail to new value
        tail_ = new DoubleListNode<T>{ value, head_, nullptr };
        // Make head => tail (forward link)
        head_->next = tail_;
    }
    else {
        // Make a new node with the passed value that is forward linked to nullptr
        DoubleListNode<T>* neo = new DoubleListNode<T>{ value, tail_, nullptr };
        // Make tail => neo
        tail_->next = neo;
        // Make neo the new tail
        tail_ = neo;
    }

    size_++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movss %xmm0, -0x1c(%rbp)
movq %rdi, %rbx
movq 0x8(%rdi), %r15
testq %r15, %r15
je 0x6f4f
movl 0x18(%rbx), %r14d
pushq $0x18
popq %rdi
callq 0x3140
movss -0x1c(%rbp), %xmm0
movss %xmm0, (%rax)
cmpl $0x1, %r14d
jne 0x6f77
movq %r15, 0x8(%rax)
andq $0x0, 0x10(%rax)
movq %rax, 0x10(%rbx)
movq %rax, 0x10(%r15)
pushq $0x1
popq %r14
jmp 0x6f8c
pushq $0x18
popq %rdi
callq 0x3140
movss -0x1c(%rbp), %xmm0
movss %xmm0, (%rax)
andq $0x0, 0x8(%rax)
movq 0x10(%rbx), %rcx
movq %rcx, 0x10(%rax)
movq %rax, 0x8(%rbx)
movl 0x18(%rbx), %r14d
jmp 0x6f8c
movq 0x10(%rbx), %rcx
movq %rcx, 0x8(%rax)
andq $0x0, 0x10(%rax)
movq %rax, 0x10(%rcx)
movq %rax, 0x10(%rbx)
incl %r14d
movl %r14d, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/MechaDragonX[P]CPPCollections/queue.cpp
// Function: Queue<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::remove()
void Queue<T>::remove() {
    DoubleListNode<T>* oldHead = head_;
    // Make value after head point back to nullptr
    head_->next->previous = nullptr;
    delete oldHead;

    size_--;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %r14
movq 0x28(%r14), %rax
andq $0x0, 0x20(%rax)
movq %r14, %rdi
callq 0x30a0
pushq $0x30
popq %rsi
movq %r14, %rdi
callq 0x3150
decl 0x18(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/MechaDragonX[P]CPPCollections/queue.cpp
// Function: Queue<int>::toString[abi:cxx11]()
std::string Queue<T>::toString() {
    DoubleListNode<T>* current = tail_;
    std::string output = "";
    // Print each element backwards so it looks like the back is facing the element in front of it
    while(current != nullptr) {
        if(current->previous != nullptr) {
            // If type is Student
            if constexpr (std::is_same<T, Student>::value)
                output += current->value.toString(false) + " => ";
            // If type is std::string
            else if constexpr (std::is_same<T, std::string>::value)
                output += current->value + " => ";
            // Otherwise, it's a primitive
            else
                output += std::to_string(current->value) + " => ";
        }
        else {
            // If type is Student
            if constexpr (std::is_same<T, Student>::value)
                output += current->value.toString(false);
            // If type is std::string
            else if constexpr (std::is_same<T, std::string>::value)
                output += current->value;
            // Otherwise, it's a primitive
            else
                output += std::to_string(current->value);
        }

        current = current->previous;
    }
    return output;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x10(%rsi), %r13
leaq 0x4a61(%rip), %rsi      # 0xb3be
leaq -0x48(%rbp), %r14
movq %r14, %rdx
callq 0x36d4
leaq -0x68(%rbp), %r15
leaq 0x4690(%rip), %r12      # 0xb004
testq %r13, %r13
je 0x69d7
cmpq $0x0, 0x8(%r13)
je 0x69b2
movl (%r13), %esi
movq %r15, %rdi
callq 0x3738
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x370f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3220
movq %r14, %rdi
callq 0x30a0
movq %r15, %rdi
jmp 0x69cc
movl (%r13), %esi
movq %r14, %rdi
callq 0x3738
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3220
movq %r14, %rdi
callq 0x30a0
movq 0x8(%r13), %r13
jmp 0x6974
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6a02
movq %rax, %r14
leaq -0x48(%rbp), %rdi
jmp 0x6a0e
movq %rax, %r14
leaq -0x48(%rbp), %rdi
callq 0x30a0
jmp 0x6a0a
movq %rax, %r14
jmp 0x6a13
movq %rax, %r14
leaq -0x68(%rbp), %rdi
callq 0x30a0
movq %rbx, %rdi
callq 0x30a0
movq %r14, %rdi
callq 0x31e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/MechaDragonX[P]CPPCollections/stack.cpp
// Function: Stack<int>::toString[abi:cxx11]()
std::string Stack<T>::toString() {
    DoubleListNode<T>* current = tail_;
    std::string output = "";
    // Print each element backwards so it looks like the back is facing the element in front of it
    while(current != nullptr) {
        // If type is Student
        if constexpr (std::is_same<T, Student>::value)
            output += current->value.toString(false) + "\n";
        // If type is std::string
        else if constexpr (std::is_same<T, std::string>::value)
            output += current->value + "\n";
        // Otherwise, it's a primitive
        else
            output += std::to_string(current->value) + "\n";

        current = current->previous;
    }
    return output;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x10(%rsi), %r13
leaq 0x384d(%rip), %rsi      # 0xb3be
leaq -0x68(%rbp), %r14
movq %r14, %rdx
callq 0x36d4
leaq -0x48(%rbp), %r15
leaq 0x3835(%rip), %r12      # 0xb3bd
testq %r13, %r13
je 0x7bc8
movl (%r13), %esi
movq %r15, %rdi
callq 0x3738
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x370f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3220
movq %r14, %rdi
callq 0x30a0
movq %r15, %rdi
callq 0x30a0
movq 0x8(%r13), %r13
jmp 0x7b88
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x7bf9
movq %rax, %r14
jmp 0x7bf0
movq %rax, %r14
leaq -0x68(%rbp), %rdi
callq 0x30a0
leaq -0x48(%rbp), %rdi
callq 0x30a0
movq %rbx, %rdi
callq 0x30a0
movq %r14, %rdi
callq 0x31e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/MechaDragonX[P]CPPCollections/student.cpp
// Function: Student::Student()
Student::Student() {
    // Initialize RNG with current time as seed
    // srand(time(nullptr));

    // id_ = rand() % 10000 + 1;
    givenName_ = "";
    surname_ = "";
    coursesTaken_ = {};
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
xorl %eax, %eax
movb %al, 0x10(%rdi)
leaq 0x30(%rdi), %rcx
movq %rcx, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
leaq 0x20(%rdi), %r14
movb %al, 0x30(%rdi)
leaq 0x40(%rdi), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rdi)
andq $0x0, 0x50(%rdi)
leaq 0x2894(%rip), %rsi      # 0xb3be
callq 0x3210
leaq 0x2888(%rip), %rsi      # 0xb3be
movq %r14, %rdi
callq 0x3210
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x908c
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
movq %r15, %rdi
callq 0x50a4
movq %r14, %rdi
callq 0x30a0
movq %rbx, %rdi
callq 0x30a0
movq %r12, %rdi
callq 0x31e0
// File: /workspace/github_cpp_makefile_star2_O2/MechaDragonX[P]CPPCollections/student.cpp
// Function: Student::removeCourse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Student::removeCourse(std::string courseId) {
    if(std::find(coursesTaken_.begin(), coursesTaken_.end(), courseId) != coursesTaken_.end()) {
        coursesTaken_.erase(std::find(coursesTaken_.begin(), coursesTaken_.end(), courseId));
        return true;
    }

    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x40(%rdi), %rdi
movq 0x48(%rbx), %rsi
movq %r14, %rdx
callq 0x9407
movq %rax, %r15
movq 0x48(%rbx), %r12
cmpq %r12, %rax
je 0x8cfc
addq $0x40, %rbx
movq (%rbx), %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x9407
movq %rbx, %rdi
movq %rax, %rsi
callq 0x9102
cmpq %r12, %r15
setne %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/MechaDragonX[P]CPPCollections/student.cpp
// Function: Student::toString[abi:cxx11](bool)
std::string Student::toString(bool full = false) {
    if(full) {
        std::string output = surname_ + ", " + givenName_ + "\n";
        output += "{ ";
        for(int i = 0; i < coursesTaken_.size(); i++) {
            if(i != coursesTaken_.size() - 1)
                output += coursesTaken_[i] + ", ";
            else
                output += coursesTaken_[i];
        }
        return output + " }";
    }

    return "[" + surname_ + ", " + givenName_ + "]";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %edx, %eax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsi), %rdx
testl %eax, %eax
je 0x8e36
leaq 0x26d9(%rip), %rax      # 0xb449
leaq -0x90(%rbp), %r15
movq %r15, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x48f1
leaq -0x48(%rbp), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x910c
leaq 0x2622(%rip), %rdx      # 0xb3bd
leaq -0x68(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x370f
leaq -0x48(%rbp), %rdi
callq 0x30a0
leaq -0x90(%rbp), %rdi
callq 0x30a0
leaq 0x2688(%rip), %rsi      # 0xb44c
leaq -0x68(%rbp), %rdi
callq 0x3200
movq %rbx, -0x70(%rbp)
xorl %ebx, %ebx
leaq -0x68(%rbp), %r15
leaq -0x48(%rbp), %r13
xorl %r12d, %r12d
movq 0x40(%r14), %rsi
movq 0x48(%r14), %rax
subq %rsi, %rax
sarq $0x5, %rax
cmpq %r12, %rax
jbe 0x8e9d
decq %rax
addq %rbx, %rsi
cmpq %rax, %r12
jne 0x8e0b
movq %r15, %rdi
callq 0x3220
jmp 0x8e2d
movq %r13, %rdi
leaq 0x2634(%rip), %rdx      # 0xb449
callq 0x48f1
movq %r15, %rdi
movq %r13, %rsi
callq 0x3220
movq %r13, %rdi
callq 0x30a0
incq %r12
addq $0x20, %rbx
jmp 0x8dde
leaq 0x2615(%rip), %rsi      # 0xb452
leaq -0x90(%rbp), %r15
movq %r15, %rdi
callq 0x9135
leaq 0x25f6(%rip), %rdx      # 0xb449
leaq -0x48(%rbp), %rdi
movq %r15, %rsi
callq 0x370f
leaq -0x68(%rbp), %rdi
leaq -0x48(%rbp), %rsi
movq %r14, %rdx
callq 0x910c
leaq 0x25de(%rip), %rdx      # 0xb454
leaq -0x68(%rbp), %rsi
movq %rbx, %rdi
callq 0x370f
leaq -0x68(%rbp), %rdi
callq 0x30a0
leaq -0x48(%rbp), %rdi
callq 0x30a0
leaq -0x90(%rbp), %rdi
jmp 0x8eb8
leaq 0x25ab(%rip), %rdx      # 0xb44f
leaq -0x68(%rbp), %rsi
movq -0x70(%rbp), %rbx
movq %rbx, %rdi
callq 0x48f1
leaq -0x68(%rbp), %rdi
callq 0x30a0
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x30a0
jmp 0x8ee2
jmp 0x8edf
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x30a0
jmp 0x8ef2
jmp 0x8eef
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
jmp 0x8f14
jmp 0x8f0d
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x30a0
jmp 0x8f10
jmp 0x8f0d
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x30a0
movq %rbx, %rdi
callq 0x31e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/MechaDragonX[P]CPPCollections/main.cpp
// Function: queueStuff(Student, Student, Student, Student, Student)
Queue<Student> queueStuff(Student rags, Student syke1, Student syke2, Student surnameLacking, Student knob) {
    Queue<Student> queue = Queue<Student>(rags);
    queue.add(syke1);
    queue.add(syke2);
    queue.add(surnameLacking);
    queue.add(knob);
    std::cout << queue.toString() << std::endl;
    queue.remove();
    std::cout << queue.toString() << std::endl;
    return queue;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1e8, %rsp            # imm = 0x1E8
movq %r9, -0x30(%rbp)
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rdi, %rbx
leaq -0x208(%rbp), %r14
movq %r14, %rdi
callq 0x49b4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x778e
leaq -0x208(%rbp), %rdi
callq 0x507a
leaq -0x1b0(%rbp), %r14
movq %r14, %rdi
movq %r13, %rsi
callq 0x49b4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x783a
leaq -0x1b0(%rbp), %rdi
callq 0x507a
leaq -0x158(%rbp), %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x49b4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x783a
leaq -0x158(%rbp), %rdi
callq 0x507a
leaq -0x100(%rbp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x49b4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x783a
leaq -0x100(%rbp), %rdi
callq 0x507a
leaq -0xa8(%rbp), %r14
movq %r14, %rdi
movq -0x30(%rbp), %rsi
callq 0x49b4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x783a
leaq -0xa8(%rbp), %rdi
callq 0x507a
leaq -0x50(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x792c
movq 0x827b(%rip), %rdi      # 0x11fd8
movq %r14, %rsi
callq 0x3120
movq %rax, %rdi
callq 0x30b0
leaq -0x50(%rbp), %rdi
callq 0x30a0
movq %rbx, %rdi
callq 0x78fa
movq %r14, %rdi
movq %rbx, %rsi
callq 0x792c
movq 0x8248(%rip), %rdi      # 0x11fd8
movq %r14, %rsi
callq 0x3120
movq %rax, %rdi
callq 0x30b0
leaq -0x50(%rbp), %rdi
callq 0x30a0
movq %rbx, %rax
addq $0x1e8, %rsp            # imm = 0x1E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0xa8(%rbp), %rdi
jmp 0x9df8
movq %rax, %rbx
leaq -0x100(%rbp), %rdi
jmp 0x9df8
movq %rax, %rbx
leaq -0x158(%rbp), %rdi
jmp 0x9df8
movq %rax, %rbx
leaq -0x1b0(%rbp), %rdi
jmp 0x9df8
movq %rax, %rbx
leaq -0x208(%rbp), %rdi
callq 0x507a
jmp 0x9e0d
jmp 0x9e01
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x30a0
movq %rbx, %rdi
callq 0x31e0
// File: /workspace/github_cpp_makefile_star2_O2/MechaDragonX[P]CPPCollections/main.cpp
// Function: stackStuff(Student, Student, Student, Student, Student)
Stack<Student> stackStuff(Student rags, Student syke1, Student syke2, Student surnameLacking, Student knob) {
    Stack<Student> stack = Stack<Student>(rags);
    stack.add(syke1);
    stack.add(syke2);
    stack.add(surnameLacking);
    stack.add(knob);
    std::cout << stack.toString() << std::endl;
    stack.remove();
    std::cout << stack.toString() << std::endl;
    return stack;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1e8, %rsp            # imm = 0x1E8
movq %r9, -0x30(%rbp)
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rdi, %rbx
leaq -0x208(%rbp), %r14
movq %r14, %rdi
callq 0x49b4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8886
leaq -0x208(%rbp), %rdi
callq 0x507a
leaq -0x1b0(%rbp), %r14
movq %r14, %rdi
movq %r13, %rsi
callq 0x49b4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8932
leaq -0x1b0(%rbp), %rdi
callq 0x507a
leaq -0x158(%rbp), %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x49b4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8932
leaq -0x158(%rbp), %rdi
callq 0x507a
leaq -0x100(%rbp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x49b4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8932
leaq -0x100(%rbp), %rdi
callq 0x507a
leaq -0xa8(%rbp), %r14
movq %r14, %rdi
movq -0x30(%rbp), %rsi
callq 0x49b4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8932
leaq -0xa8(%rbp), %rdi
callq 0x507a
leaq -0x50(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x8a26
movq 0x80be(%rip), %rdi      # 0x11fd8
movq %r14, %rsi
callq 0x3120
movq %rax, %rdi
callq 0x30b0
leaq -0x50(%rbp), %rdi
callq 0x30a0
movq %rbx, %rdi
callq 0x89f2
movq %r14, %rdi
movq %rbx, %rsi
callq 0x8a26
movq 0x808b(%rip), %rdi      # 0x11fd8
movq %r14, %rsi
callq 0x3120
movq %rax, %rdi
callq 0x30b0
leaq -0x50(%rbp), %rdi
callq 0x30a0
movq %rbx, %rax
addq $0x1e8, %rsp            # imm = 0x1E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0xa8(%rbp), %rdi
jmp 0x9fb5
movq %rax, %rbx
leaq -0x100(%rbp), %rdi
jmp 0x9fb5
movq %rax, %rbx
leaq -0x158(%rbp), %rdi
jmp 0x9fb5
movq %rax, %rbx
leaq -0x1b0(%rbp), %rdi
jmp 0x9fb5
movq %rax, %rbx
leaq -0x208(%rbp), %rdi
callq 0x507a
jmp 0x9fca
jmp 0x9fbe
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x30a0
movq %rbx, %rdi
callq 0x31e0
// File: /workspace/github_cpp_makefile_star2_O2/Sweet-john[P]Linux_bash/OS.cpp
// Function: checkSpecialOrder(char* const*)
bool checkSpecialOrder(char *const argv[])
{
 bool check = false;
 if (strcmp(argv[0],"go")==0)
	 {check = true ; go(argv);}
 else if
	 (strcmp(argv[0],"history")==0) {check = true ; printHistory();}
 else if
	 (strcmp(argv[0],"pid")==0) {check = true ; printPid();}
 else if 
	 (strcmp(argv[0],"continue")==0) {check = true ; cont(argv[1]);}
 else if 
	 (strcmp(argv[0],"jobs")==0) {check = true ; printJobs();}
 else if 
	 (strcmp(argv[0],"status")==0) {check = true ; printStatus();}
 return check;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movq (%rdi), %rbx
cmpb $0x67, (%rbx)
jne 0x248a
cmpb $0x6f, 0x1(%rbx)
jne 0x248a
cmpb $0x0, 0x2(%rbx)
je 0x2506
leaq 0x1b8f(%rip), %rsi      # 0x4020
movq %rbx, %rdi
callq 0x21e0
testl %eax, %eax
je 0x24ed
leaq 0x1b84(%rip), %rsi      # 0x4028
movq %rbx, %rdi
callq 0x21e0
testl %eax, %eax
je 0x24f4
leaq 0x1b75(%rip), %rsi      # 0x402c
movq %rbx, %rdi
callq 0x21e0
testl %eax, %eax
je 0x24fb
leaq 0x1b6b(%rip), %rsi      # 0x4035
movq %rbx, %rdi
callq 0x21e0
testl %eax, %eax
je 0x2510
leaq 0x1b5d(%rip), %rsi      # 0x403a
movq %rbx, %rdi
callq 0x21e0
testl %eax, %eax
je 0x2517
xorl %eax, %eax
jmp 0x251e
callq 0x2555
jmp 0x251c
callq 0x25ac
jmp 0x251c
movq 0x8(%r14), %rdi
callq 0x31e0
jmp 0x251c
movq %r14, %rdi
callq 0x2523
jmp 0x251c
callq 0x3285
jmp 0x251c
callq 0x32da
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Sweet-john[P]Linux_bash/OS.cpp
// Function: printPid()
void printPid()
{
 int i = 0;
 int size = pidList.size();
 int j = 1;
 if (i<size-5)
  i = size - 5; 
  while(i<size)
  {
   cout<<"["<<size-i<<"] "<<pidList[size-j]<<"\n";
   i++;
   j++;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0xd81f(%rip), %r14      # 0xfde0
subq 0xd810(%rip), %r14      # 0xfdd8
shrq $0x2, %r14
leal -0x5(%r14), %eax
movslq %r14d, %rcx
leaq -0x1(%rcx), %r15
xorl %r12d, %r12d
cmpl $0x6, %ecx
cmovgel %eax, %r12d
pushq $0x5
popq %rax
cmovgel %r14d, %eax
negl %eax
leal (%rcx,%rax), %ebx
addl $0x5, %ebx
leaq 0x1afe(%rip), %r13      # 0x40f5
cmpl %r14d, %r12d
jge 0x2650
movq 0x39cd(%rip), %rdi      # 0x5fd0
leaq 0x1a67(%rip), %rsi      # 0x4071
callq 0x2150
movq %rax, %rdi
movl %ebx, %esi
callq 0x2280
movq %rax, %rdi
leaq 0x1a50(%rip), %rsi      # 0x4073
callq 0x2150
movq 0xd7a9(%rip), %rcx      # 0xfdd8
movl (%rcx,%r15,4), %esi
movq %rax, %rdi
callq 0x2280
movq %rax, %rdi
movq %r13, %rsi
callq 0x2150
incl %r12d
decq %r15
decl %ebx
jmp 0x25f7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Sweet-john[P]Linux_bash/OS.cpp
// Function: execute(char* const*)
void execute(char *const argv[])
{ 
 pid=fork();
 int success;
 if (pid!=0)
 { /*waitpid(pid,&success,0);
   if (WEXITSTATUS(success)==0)
	{
	setPid(pid);
	}*/
	waitid(P_PID,pid,&info,WEXITED|WSTOPPED);
	setPid(pid);
 }
 else
 {
	if (execvp(argv[0],argv)<0)
        {
		perror("Exec error ");
		exit(-1);
	}
 }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2040
movl %eax, 0xd76b(%rip)      # 0xfe40
testl %eax, %eax
je 0x26fe
leaq 0xd768(%rip), %rdx      # 0xfe48
pushq $0x1
popq %rdi
pushq $0x6
popq %rcx
movl %eax, %esi
callq 0x2070
movl 0xd74d(%rip), %edi      # 0xfe40
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x26a1
movq (%rbx), %rdi
movq %rbx, %rsi
callq 0x20f0
testl %eax, %eax
js 0x2714
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x195b(%rip), %rdi      # 0x4076
callq 0x2110
pushq $-0x1
popq %rdi
callq 0x21b0
// File: /workspace/github_cpp_makefile_star2_O2/Sweet-john[P]Linux_bash/OS.cpp
// Function: main
int main()
{

 signal(SIGINT,kill_sig_handler);
 signal(SIGTSTP,stp_sig_handler);

 while(1)
 {
 prompt();
 cin.getline(Command,80);

 if (strcmp(Command,"exit")==0)
	{
	freeMemory();
	exit(0);
	}
 else if (Command == NULL)
 continue;
 
 setHistory();
 //check space
 char *temp = strtok(Command," ");
 vector<char*>obj;
 while (temp)
 	{
  	obj.push_back(temp);
  	temp = strtok(NULL," ");
 	}
 
 //obj to char
 char* a[obj.size()];
 int s;
 for (s = 0; s < obj.size() ;s++ )
	{
	  a[s]=obj[s];
 	}
 a[s]=NULL;

 multiple(a,obj.size());
 }
return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
leaq 0x905(%rip), %rsi       # 0x30fc
pushq $0x2
popq %rdi
callq 0x2190
leaq 0x94f(%rip), %rsi       # 0x3155
pushq $0x14
popq %rdi
callq 0x2190
leaq 0xd5db(%rip), %r14      # 0xfdf0
leaq 0x186b(%rip), %rbx      # 0x4087
leaq -0x50(%rbp), %r15
leaq -0x30(%rbp), %r12
callq 0x2728
movq 0x37b0(%rip), %rdi      # 0x5fe0
movq %r14, %rsi
pushq $0x50
popq %rdx
callq 0x2060
movq %r14, %rdi
leaq 0x1844(%rip), %rsi      # 0x4089
pushq $0x5
popq %rdx
callq 0x2180
testl %eax, %eax
je 0x28f1
callq 0x265f
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2260
movq %rax, -0x30(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
andq $0x0, -0x40(%rbp)
testq %rax, %rax
je 0x2895
movq %r15, %rdi
movq %r12, %rsi
callq 0x2944
xorl %edi, %edi
movq %rbx, %rsi
callq 0x2260
movq %rax, -0x30(%rbp)
jmp 0x2875
movq %rsp, %r13
movq -0x48(%rbp), %rax
subq -0x50(%rbp), %rax
movq %rsp, %rdi
addq $0xf, %rax
andq $-0x10, %rax
subq %rax, %rdi
movq %rdi, %rsp
movq -0x50(%rbp), %rcx
movq -0x48(%rbp), %rax
subq %rcx, %rax
movq %rax, %rsi
sarq $0x3, %rsi
xorl %edx, %edx
cmpq %rdx, %rsi
je 0x28d7
movq (%rcx,%rdx,8), %r8
movq %r8, (%rdi,%rdx,8)
incq %rdx
jmp 0x28c5
andq $0x0, (%rdi,%rax)
callq 0x2ca8
movq %r13, %rsp
movq %r15, %rdi
callq 0x2b0e
jmp 0x2824
callq 0x27ac
xorl %edi, %edi
callq 0x21b0
jmp 0x28ff
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x2b0e
movq %rbx, %rdi
callq 0x2290
nop
// File: /workspace/github_cpp_makefile_star2_O2/Sweet-john[P]Linux_bash/OS2.cpp
// Function: multiple(char**, int)
bool multiple(char*argv[],int size)
{
 int n = 1;
 bool check = false;
	for (int i = 0; i<size; i++)
	{
	 	if (strchr(argv[i],';')!=NULL||i==size-1)
		{
		check = true;
		char* temp[20];
		int j;
		char *out;
		if (strcmp(argv[i],";")!=0)
		out = strtok(argv[i],";");
		for (j = 0; j < n; j++)
			{
			if (j == n-1 && strcmp(argv[i],";")!=0)
			temp[j] = out;
			else if (j == n-1 && strcmp(argv[i],";")==0)
			temp[j] = NULL;
			else
			temp[j] = argv[i+j-n+1];
			}
		temp[j]=NULL;
		if (Redirection(temp,n)) 
			{
			n = 1;
			continue;
			}
		n = 0;
		bool isSpecial = checkSpecialOrder(temp);
		if (!isSpecial)
		execute(temp);
		}
	 n++;
	}
 return check;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
leal -0x1(%rsi), %eax
movq %rax, -0x40(%rbp)
xorl %ebx, %ebx
testl %esi, %esi
cmovlel %ebx, %esi
movq %rsi, -0x48(%rbp)
movq %rdi, %r14
pushq $0x1
popq %rax
xorl %r15d, %r15d
movq $0x0, -0x30(%rbp)
movl %eax, %r12d
cmpq -0x48(%rbp), %r15
je 0x2df3
movq %rbx, -0x38(%rbp)
movq (%r14,%r15,8), %rbx
movq %rbx, %rdi
pushq $0x3b
popq %rsi
callq 0x2090
testq %rax, %rax
setne %al
cmpq -0x40(%rbp), %r15
sete %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x2d92
cmpb $0x3b, (%rbx)
jne 0x2d1e
cmpb $0x0, 0x1(%rbx)
je 0x2d30
movq %rbx, %rdi
leaq 0x1380(%rip), %rsi      # 0x40a8
callq 0x2260
movq %rax, %r13
testl %r12d, %r12d
movl $0x0, %eax
cmovgl %r12d, %eax
leal -0x1(%r12), %ecx
movq -0x38(%rbp), %rbx
movl %ebx, %edx
subl %r12d, %edx
xorl %esi, %esi
cmpq %rsi, %rax
je 0x2d98
cmpq %rsi, %rcx
jne 0x2d6f
movq (%r14,%r15,8), %rdi
cmpb $0x3b, (%rdi)
jne 0x2d65
cmpb $0x0, 0x1(%rdi)
je 0x2d87
movq %r13, -0xf0(%rbp,%rcx,8)
jmp 0x2d82
leal (%rdx,%rsi), %edi
movslq %edi, %rdi
movq 0x8(%r14,%rdi,8), %rdi
movq %rdi, -0xf0(%rbp,%rsi,8)
incq %rsi
jmp 0x2d4c
andq $0x0, -0xf0(%rbp,%rcx,8)
jmp 0x2d82
movq -0x38(%rbp), %rbx
jmp 0x2de6
andq $0x0, -0xf0(%rbp,%rax,8)
leaq -0xf0(%rbp), %rdi
movl %r12d, %esi
callq 0x2e0b
testb %al, %al
je 0x2dc2
movb $0x1, %al
movq %rax, -0x30(%rbp)
pushq $0x1
popq %rax
movl %eax, %r12d
jmp 0x2de9
leaq -0xf0(%rbp), %r12
movq %r12, %rdi
callq 0x246c
testb %al, %al
jne 0x2ddd
movq %r12, %rdi
callq 0x26c1
xorl %r12d, %r12d
movb $0x1, %al
movq %rax, -0x30(%rbp)
incl %r12d
incq %r15
incl %ebx
jmp 0x2ce2
movq -0x30(%rbp), %rax
andb $0x1, %al
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Sweet-john[P]Linux_bash/OS2.cpp
// Function: pipe(char**, char**)
void pipe(char* input[], char* output[])
{
int fd[2];
 pipe(fd);
 if (fork()!=0)
 {
  close(fd[0]);
  int fdo = dup(STDOUT_FILENO);
  close(1);
  dup(fd[1]);
  close(fd[1]);
  bool isSpecial = checkSpecialOrder(input);
  if (!isSpecial)
  execute(input);
  dup2(fdo,STDOUT_FILENO);
  wait(NULL);
 }
else
 {
  close(fd[1]);
  close(0);
  dup(fd[0]);
  close(fd[0]);
  bool isSpecial = checkSpecialOrder(output);
  if (!isSpecial)
  execute(output);
  exit(0); 
 }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x20(%rbp), %rdi
callq 0x21d0
callq 0x2040
testl %eax, %eax
je 0x30c2
movl -0x20(%rbp), %edi
callq 0x22a0
pushq $0x1
popq %r15
movl %r15d, %edi
callq 0x2220
movl %eax, %r14d
movl %r15d, %edi
callq 0x22a0
movl -0x1c(%rbp), %edi
callq 0x2220
movl -0x1c(%rbp), %edi
callq 0x22a0
movq %rbx, %rdi
callq 0x246c
testb %al, %al
jne 0x30a5
movq %rbx, %rdi
callq 0x26c1
pushq $0x1
popq %rsi
movl %r14d, %edi
callq 0x2130
xorl %edi, %edi
callq 0x21c0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl -0x1c(%rbp), %edi
callq 0x22a0
xorl %edi, %edi
callq 0x22a0
movl -0x20(%rbp), %edi
callq 0x2220
movl -0x20(%rbp), %edi
callq 0x22a0
movq %r14, %rdi
callq 0x246c
testb %al, %al
jne 0x30f5
movq %r14, %rdi
callq 0x26c1
xorl %edi, %edi
callq 0x21b0
// File: /workspace/github_cpp_makefile_star2_O2/Sweet-john[P]Linux_bash/OS3.cpp
// Function: kill_sig_handler(int)
void kill_sig_handler(int sig)
{
	kill(pid,SIGINT);
	
	for (int i=0; i<jobList.size();i++)
	{
		if (pid==jobList[i].id)
			jobList[i].status = TERMINATE;
	}
	printf("\nThe current process has been killed\n");	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0xcd37(%rip), %rbx      # 0xfe40
movl (%rbx), %edi
pushq $0x2
popq %rsi
callq 0x21f0
movq 0xcdbe(%rip), %rax      # 0xfed8
movq 0xcdaf(%rip), %rcx      # 0xfed0
subq %rcx, %rax
sarq $0x3, %rax
xorl %edx, %edx
cmpq %rdx, %rax
jbe 0x3143
movl (%rbx), %esi
cmpl (%rcx,%rdx,8), %esi
jne 0x313e
movl $0x3, 0x4(%rcx,%rdx,8)
incq %rdx
jmp 0x312a
leaq 0xfad(%rip), %rdi       # 0x40f7
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2240
// File: /workspace/github_cpp_makefile_star2_O2/Sweet-john[P]Linux_bash/OS3.cpp
// Function: stp_sig_handler(int)
void stp_sig_handler(int sig)
{
	bool check = false;
	int sus;
	kill(pid,SIGSTOP);
	
	for (int i=0; i<jobList.size();i++)
	{
		if (pid!=jobList[i].id)
			continue;
		else
			{check = true; jobList[i].status = SUSPEND; sus = i+1; break;}
	}
	
	if (check == false)	
	{
		job temp;
		temp.id = pid;
		temp.status = SUSPEND;
		jobList.push_back(temp);
		sus = jobList.size();
	}
	printf("[%d] Suspend\n",sus);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0xccde(%rip), %rbx      # 0xfe40
movl (%rbx), %edi
pushq $0x13
popq %rsi
callq 0x21f0
movq 0xcd65(%rip), %rcx      # 0xfed8
movq 0xcd56(%rip), %rax      # 0xfed0
subq %rax, %rcx
sarq $0x3, %rcx
movl (%rbx), %edx
xorl %esi, %esi
cmpq %rsi, %rcx
je 0x3194
cmpl (%rax,%rsi,8), %edx
je 0x31c1
incq %rsi
jmp 0x3185
leaq -0x10(%rbp), %rsi
movl %edx, (%rsi)
movl $0x2, 0x4(%rsi)
leaq 0xcd28(%rip), %rdi      # 0xfed0
callq 0x330e
movq 0xcd24(%rip), %rsi      # 0xfed8
subq 0xcd15(%rip), %rsi      # 0xfed0
shrq $0x3, %rsi
jmp 0x31cb
movl $0x2, 0x4(%rax,%rsi,8)
incl %esi
leaq 0xee4(%rip), %rdi       # 0x40b6
xorl %eax, %eax
callq 0x2030
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Sweet-john[P]Linux_bash/OS3.cpp
// Function: cont(char*)
void cont(char *arg)
{
	int i = atoi(arg);
	
	if (jobList[i-1].status == SUSPEND)
	{
	
	kill(jobList[i-1].id,SIGCONT);
	pid = jobList[i-1].id;
	jobList[i-1].status = RUN;
	
	waitid(P_PID,jobList[i-1].id,&info,WEXITED|WSTOPPED);
	
	if (info.si_code == CLD_STOPPED)
	jobList[i-1].status = SUSPEND;
	else if (info.si_code == CLD_EXITED || info.si_code == CLD_KILLED)
	jobList[i-1].status = TERMINATE;
	
	}
	else
	printf("Not a suspend job!\n");	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
callq 0x2250
movslq %eax, %r14
movq 0xccda(%rip), %rax      # 0xfed0
cmpl $0x2, -0x4(%rax,%r14,8)
jne 0x3259
decq %r14
movl (%rax,%r14,8), %edi
pushq $0x12
popq %rsi
callq 0x21f0
movq 0xccbc(%rip), %rax      # 0xfed0
movl (%rax,%r14,8), %esi
leaq 0xcc21(%rip), %rcx      # 0xfe40
movl %esi, (%rcx)
movl $0x1, 0x4(%rax,%r14,8)
leaq 0xcc17(%rip), %rbx      # 0xfe48
pushq $0x1
popq %rdi
pushq $0x6
popq %rcx
movq %rbx, %rdx
callq 0x2070
movl 0x8(%rbx), %eax
cmpl $0x5, %eax
jne 0x3269
movq 0xcc82(%rip), %rax      # 0xfed0
movl $0x2, 0x4(%rax,%r14,8)
jmp 0x3280
leaq 0xebc(%rip), %rdi       # 0x411c
popq %rbx
popq %r14
popq %rbp
jmp 0x2240
decl %eax
cmpl $0x1, %eax
ja 0x3280
movq 0xcc59(%rip), %rax      # 0xfed0
movl $0x3, 0x4(%rax,%r14,8)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Sweet-john[P]Linux_bash/OS3.cpp
// Function: printJobs()
void printJobs()
{
	for (int i=0; i<jobList.size();i++)
	{
		switch (jobList[i].status)
		{
		case 1: printf("[%d] Running\n",i+1); break;
		case 2: printf("[%d] Suspended\n",i+1); break;
		case 3: printf("[%d] Terminated\n",i+1); break;
		}
	}	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq 0xe9d(%rip), %rbx       # 0x4130
xorl %r14d, %r14d
movq 0xcc3b(%rip), %rcx      # 0xfed8
movq 0xcc2c(%rip), %rax      # 0xfed0
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r14, %rcx
jbe 0x32d5
movl 0x4(%rax,%r14,8), %eax
decl %eax
cmpl $0x3, %eax
jae 0x32d0
movl %eax, %eax
movslq (%rbx,%rax,4), %rdi
addq %rbx, %rdi
leal 0x1(%r14), %esi
xorl %eax, %eax
callq 0x2030
incq %r14
jmp 0x3296
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/s0sasaki[P]ExecutableBlockchain/compiler.cpp
// Function: Compiler::read(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, char const*) const
void Compiler::read(std::vector<std::string> &strtable, const char *src_data) const{
    int32_t c;
    int32_t idx = 0;
    char buf[256];
    bool iscomment = false;
    while((c = *src_data++)) {
        c = toupper(c);
        if(isSep(c, (char *)" \t\r\n()")) {
            if(c == '(') iscomment = true;
            if(c == ')') iscomment = false;
            if(!idx) continue;
            buf[idx] = 0;
            strtable.push_back(buf);
            idx = 0;
            continue;
        }
        if(!iscomment) buf[idx++] = c;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp            # imm = 0x138
movq %rdx, %rbx
movq %rsi, -0x38(%rbp)
movq %rdi, %r15
xorl %r14d, %r14d
xorl %r12d, %r12d
movsbl (%rbx), %edi
testl %edi, %edi
je 0x2aad
incq %rbx
callq 0x22c0
movl %eax, %r13d
movsbl %r13b, %esi
movq %r15, %rdi
leaq 0x36eb(%rip), %rdx      # 0x6127
callq 0x3328
movl %r12d, %ecx
testb %al, %al
jne 0x2a5b
testb $0x1, %r14b
jne 0x2a18
incl %r12d
movb %r13b, -0x160(%rbp,%rcx)
jmp 0x2a18
cmpl $0x28, %r13d
sete %al
orb %r14b, %al
cmpl $0x29, %r13d
setne %r14b
andb %al, %r14b
testl %r12d, %r12d
je 0x2a15
movb $0x0, -0x160(%rbp,%rcx)
leaq -0x58(%rbp), %r12
movq %r12, %rdi
leaq -0x160(%rbp), %rsi
leaq -0x29(%rbp), %rdx
callq 0x20a0
movq -0x38(%rbp), %rdi
movq %r12, %rsi
callq 0x3636
movq %r12, %rdi
callq 0x20d0
jmp 0x2a15
addq $0x138, %rsp            # imm = 0x138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/s0sasaki[P]ExecutableBlockchain/block.cpp
// Function: Block::Block(int const (&) [1024])
Block::Block(const int32_t (&data)[DATA_SIZE]){
    nonce = 0;
    timestamp = time(nullptr);
    for(int32_t i=0; i<sizeof(data)/sizeof(int32_t); i++) 
        this->data[i] = data[i];
    hash = calculateHash();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
xorl %eax, %eax
movb %al, 0x10(%rdi)
leaq 0x20(%rdi), %r14
leaq 0x30(%rdi), %rcx
movq %rcx, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
movb %al, 0x30(%rdi)
andl $0x0, 0x1040(%rdi)
xorl %edi, %edi
callq 0x21b0
movq %rax, 0x1048(%rbx)
pushq $0x10
popq %rax
cmpq $0x410, %rax            # imm = 0x410
je 0x432d
movl -0x40(%r15,%rax,4), %ecx
movl %ecx, (%rbx,%rax,4)
incq %rax
jmp 0x4318
leaq -0x38(%rbp), %rdi
movq %rbx, %rsi
callq 0x44a0
leaq -0x38(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2220
movq %r14, %rdi
callq 0x20d0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq %r14, %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x20d0
movq %r15, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O2/s0sasaki[P]ExecutableBlockchain/block.cpp
// Function: Block::mineBlock(unsigned int const&)
void Block::mineBlock(const uint32_t &difficulty){
    char cstr[difficulty + 1];
    for (uint32_t i = 0; i < difficulty; ++i)
        cstr[i] = '0';
    cstr[difficulty] = '\0';
    std::string str(cstr);

    //std::cout << "Mining block... " << std::flush;
    do{
        nonce++;
        hash = calculateHash();
    }while (hash.substr(0, difficulty) != str);
    //std::cout << hash << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl (%rsi), %eax
leal 0x1(%rax), %ecx
movq %rsp, %rsi
addq $0xf, %rcx
andq $-0x10, %rcx
subq %rcx, %rsi
movq %rsi, %rsp
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x43b3
movb $0x30, (%rsi,%rcx)
incq %rcx
jmp 0x43a5
movb $0x0, (%rsi,%rax)
leaq -0x48(%rbp), %r15
leaq -0x68(%rbp), %r12
movq %r15, %rdi
movq %r12, %rdx
callq 0x20a0
incl 0x1040(%r14)
movq %r12, %rdi
movq %r14, %rsi
callq 0x44a0
movq %r14, %rdi
movq %r12, %rsi
callq 0x2220
movq %r12, %rdi
callq 0x20d0
movl (%rbx), %ecx
movq %r12, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x2200
movq %r12, %rdi
movq %r15, %rsi
callq 0x457e
movl %eax, %r13d
movq %r12, %rdi
callq 0x20d0
testb %r13b, %r13b
jne 0x43ca
leaq -0x48(%rbp), %rdi
callq 0x20d0
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4433
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/s0sasaki[P]ExecutableBlockchain/block.cpp
// Function: Block::calculateHash[abi:cxx11]() const
inline std::string Block::calculateHash() const{
    std::stringstream ss;
    ss << prev_hash << timestamp << nonce;
    for(uint32_t i=0; i<DATA_SIZE; i++)
        ss << data[i];
    return sha256(ss.str());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x1c8(%rbp), %rdi
callq 0x2150
leaq -0x1b8(%rbp), %r15
leaq 0x20(%r14), %rsi
movq %r15, %rdi
callq 0x21a0
movq 0x1048(%r14), %rsi
movq %rax, %rdi
callq 0x21d0
movl 0x1040(%r14), %esi
movq %rax, %rdi
callq 0x2130
xorl %r12d, %r12d
cmpq $0x400, %r12            # imm = 0x400
je 0x4513
movl 0x40(%r14,%r12,4), %esi
movq %r15, %rdi
callq 0x22a0
incq %r12
jmp 0x44f8
leaq -0x1b0(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x2280
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x4f34
leaq -0x40(%rbp), %rdi
callq 0x20d0
leaq -0x1c8(%rbp), %rdi
callq 0x2160
movq %rbx, %rax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x20d0
jmp 0x456a
jmp 0x4567
movq %rax, %rbx
leaq -0x1c8(%rbp), %rdi
callq 0x2160
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O2/s0sasaki[P]ExecutableBlockchain/blockchain.cpp
// Function: Blockchain::Blockchain()
Blockchain::Blockchain(){
    int32_t genesis_data[Block::DATA_SIZE];
    Block genesis_block(genesis_data);
    genesis_block.mineBlock(difficulty);
    chain.emplace_back(genesis_block);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x2050, %rsp           # imm = 0x2050
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movl $0x3, 0x18(%rdi)
leaq -0x1060(%rbp), %rdi
leaq -0x2060(%rbp), %rsi
callq 0x42c8
leaq 0x18(%rbx), %rsi
leaq -0x1060(%rbp), %rdi
callq 0x4376
leaq -0x1060(%rbp), %rsi
movq %rbx, %rdi
callq 0x476c
leaq -0x1060(%rbp), %rdi
callq 0x284e
addq $0x2050, %rsp           # imm = 0x2050
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
jmp 0x460d
movq %rax, %r14
leaq -0x1060(%rbp), %rdi
callq 0x284e
movq %rbx, %rdi
callq 0x298c
movq %r14, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/s0sasaki[P]ExecutableBlockchain/blockchain.cpp
// Function: Blockchain::isValid() const
bool Blockchain::isValid() const{
    for (auto block: chain)
        if(!block.isValid(difficulty)) return false;
    std::string prev_hash = chain.front().hash;
    for(uint32_t i=1; i<chain.size(); i++){
        if(prev_hash != chain[i].prev_hash) return false;
        prev_hash = chain[i].hash;
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1058, %rsp           # imm = 0x1058
movq (%rdi), %r14
movq 0x8(%rdi), %rbx
movq %rdi, -0x30(%rbp)
leaq 0x18(%rdi), %r15
leaq -0x1080(%rbp), %r12
cmpq %rbx, %r14
je 0x467f
movq %r12, %rdi
movq %r14, %rsi
callq 0x47aa
movq %r12, %rdi
movq %r15, %rsi
callq 0x4448
movl %eax, %r13d
movq %r12, %rdi
callq 0x284e
addq $0x1050, %r14           # imm = 0x1050
testb %r13b, %r13b
jne 0x4648
xorl %r15d, %r15d
jmp 0x46f3
movq -0x30(%rbp), %rbx
movq (%rbx), %rsi
leaq -0x1080(%rbp), %r14
movq %r14, %rdi
callq 0x2240
pushq $0x1
popq %r13
movl %r13d, %r13d
movq (%rbx), %rcx
movq 0x8(%rbx), %rax
subq %rcx, %rax
cqto
movl $0x1050, %esi           # imm = 0x1050
idivq %rsi
cmpq %r13, %rax
setbe %r15b
jbe 0x46e7
imulq $0x1050, %r13, %r12     # imm = 0x1050
leaq (%rcx,%r12), %rsi
addq $0x20, %rsi
movq %r14, %rdi
callq 0x457e
testb %al, %al
jne 0x46e7
addq (%rbx), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x2100
incl %r13d
jmp 0x4699
leaq -0x1080(%rbp), %rdi
callq 0x20d0
movl %r15d, %eax
addq $0x1058, %rsp           # imm = 0x1058
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x1080(%rbp), %rdi
callq 0x20d0
jmp 0x4728
movq %rax, %rbx
leaq -0x1080(%rbp), %rdi
callq 0x284e
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O2/s0sasaki[P]ExecutableBlockchain/sha256.cpp
// Function: SHA256::update(unsigned char const*, unsigned int)
void SHA256::update(const unsigned char *message, unsigned int len)
{
    unsigned int block_nb;
    unsigned int new_len, rem_len, tmp_len;
    const unsigned char *shifted_message;
    tmp_len = SHA224_256_BLOCK_SIZE - m_len;
    rem_len = len < tmp_len ? len : tmp_len;
    memcpy(&m_block[m_len], message, rem_len);
    if (m_len + len < SHA224_256_BLOCK_SIZE) {
        m_len += len;
        return;
    }
    new_len = len - rem_len;
    block_nb = new_len / SHA224_256_BLOCK_SIZE;
    shifted_message = message + rem_len;
    transform(m_block, 1);
    transform(shifted_message, block_nb);
    rem_len = new_len % SHA224_256_BLOCK_SIZE;
    memcpy(m_block, &shifted_message[block_nb << 6], rem_len);
    m_len = rem_len;
    m_tot_len += (block_nb + 1) << 6;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r12d
movq %rsi, %r15
movq %rdi, %rbx
movl 0x4(%rdi), %eax
pushq $0x40
popq %r13
subl %eax, %r13d
cmpl %edx, %r13d
cmovael %edx, %r13d
addq %rax, %rdi
addq $0x8, %rdi
movq %r13, %rdx
callq 0x2180
movl 0x4(%rbx), %r14d
addl %r12d, %r14d
cmpl $0x40, %r14d
jb 0x4e2f
leaq 0x8(%rbx), %rsi
subl %r13d, %r12d
movl %r12d, %r14d
shrl $0x6, %r14d
addq %r13, %r15
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %rsi, %r13
callq 0x4b88
movq %rbx, %rdi
movq %r15, %rsi
movl %r14d, %edx
callq 0x4b88
movl %r12d, %r14d
andl $0x3f, %r14d
andl $-0x40, %r12d
leaq (%r12,%r15), %rsi
movq %r13, %rdi
movq %r14, %rdx
callq 0x2180
movl (%rbx), %eax
addl %r12d, %eax
addl $0x40, %eax
movl %eax, (%rbx)
movl %r14d, 0x4(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/s0sasaki[P]ExecutableBlockchain/sha256.cpp
// Function: sha256(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string sha256(std::string input)
{
    unsigned char digest[SHA256::DIGEST_SIZE];
    memset(digest,0,SHA256::DIGEST_SIZE);

    SHA256 ctx = SHA256();
    ctx.init();
    ctx.update( (unsigned char*)input.c_str(), input.length());
    ctx.final(digest);

    char buf[2*SHA256::DIGEST_SIZE+1];
    buf[2*SHA256::DIGEST_SIZE] = 0;
    for (int i = 0; i < SHA256::DIGEST_SIZE; i++)
        sprintf(buf+i*2, "%02x", digest[i]);
    return std::string(buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x130, %rsp            # imm = 0x130
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq -0x148(%rbp), %r14
movups %xmm0, 0x78(%r14)
movups %xmm0, 0x68(%r14)
movups %xmm0, 0x58(%r14)
movups %xmm0, 0x48(%r14)
movups %xmm0, 0x38(%r14)
movups %xmm0, 0x28(%r14)
movups %xmm0, 0x18(%r14)
movups %xmm0, 0x8(%r14)
movaps 0x123e(%rip), %xmm1     # 0x61c0
movups %xmm1, 0x88(%r14)
movaps 0x123f(%rip), %xmm1     # 0x61d0
movups %xmm1, 0x98(%r14)
leaq -0x50(%rbp), %r15
andq $0x0, (%r14)
movaps %xmm0, 0x10(%r15)
movaps %xmm0, (%r15)
movq (%rsi), %rax
movl 0x8(%rsi), %edx
movq %r14, %rdi
movq %rax, %rsi
callq 0x4d9a
movq %r14, %rdi
movq %r15, %rsi
callq 0x4e42
leaq -0xa0(%rbp), %r14
movb $0x0, 0x40(%r14)
leaq 0x1307(%rip), %r15      # 0x62e0
xorl %r12d, %r12d
cmpq $0x20, %r12
je 0x4ffe
movzbl -0x50(%rbp,%r12), %edx
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x2060
incq %r12
addq $0x2, %r14
jmp 0x4fdc
leaq -0xa0(%rbp), %rsi
leaq -0x21(%rbp), %rdx
movq %rbx, %rdi
callq 0x20a0
movq %rbx, %rax
addq $0x130, %rsp            # imm = 0x130
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/s0sasaki[P]ExecutableBlockchain/vm.cpp
// Function: VM::funcOpRet()
void VM::funcOpRet () { 
    if(rsp == 0) is_halt = true; 
    ip = return_stack[rsp--];  
    ib = return_stack[rsp--];  
    load();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq 0x8(%rdi), %rax
testq %rax, %rax
jne 0x524b
movb $0x1, 0x10(%rdi)
leal -0x1(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl 0x3020(%rdi,%rax,4), %ecx
movl %ecx, 0x4(%rdi)
leal -0x2(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl 0x301c(%rdi,%rax,4), %eax
movl %eax, (%rdi)
popq %rbp
jmp 0x5870
// File: /workspace/github_cpp_makefile_star2_O2/s0sasaki[P]ExecutableBlockchain/vm.cpp
// Function: VM::funcOpCall()
void VM::funcOpCall() { 
    return_stack[++rsp] = ib; 
    return_stack[++rsp] = ip + 2; 
    ib = mem[ip++];  
    ip = mem[ip];  
    load();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl (%rdi), %eax
movslq 0x8(%rdi), %rcx
leaq 0x1(%rcx), %rdx
movl %edx, 0x8(%rdi)
movl %eax, 0x3024(%rdi,%rcx,4)
movl 0x4(%rdi), %eax
addl $0x2, %eax
movslq 0x8(%rdi), %rcx
leaq 0x1(%rcx), %rdx
movl %edx, 0x8(%rdi)
movl %eax, 0x3024(%rdi,%rcx,4)
movslq 0x4(%rdi), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x4(%rdi)
movl 0x1020(%rdi,%rax,4), %ecx
movl %ecx, (%rdi)
movl 0x1024(%rdi,%rax,4), %eax
movl %eax, 0x4(%rdi)
popq %rbp
jmp 0x5870
// File: /workspace/github_cpp_makefile_star2_O2/s0sasaki[P]ExecutableBlockchain/vm.cpp
// Function: VM::exec(int const*, Blockchain const&)
void VM::exec(const int32_t *bin_data, const Blockchain &blockchain) {
    refresh(bin_data, blockchain);
    while(is_halt == false) {
#ifdef DEBUG
        displayState();
#endif
        (this->*func_table[mem[ip++]])();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x55b8
leaq 0x5020(%rbx), %r14
cmpb $0x0, 0x10(%rbx)
jne 0x55b2
movslq 0x4(%rbx), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x4(%rbx)
movslq 0x1020(%rbx,%rax,4), %rcx
shlq $0x4, %rcx
movq (%r14,%rcx), %rax
movq 0x8(%r14,%rcx), %rdi
addq %rbx, %rdi
testb $0x1, %al
je 0x55ae
movq (%rdi), %rcx
movq -0x1(%rcx,%rax), %rax
callq *%rax
jmp 0x557a
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/s0sasaki[P]ExecutableBlockchain/vm.cpp
// Function: VM::refresh(int const*, Blockchain const&)
void VM::refresh(const int32_t *latest_data, const Blockchain &blockchain){
    ib      = blockchain.chain.size();
    ip      = 0;
    rsp     = 0;
    psp     = 0;
    is_halt = false;
    pblockchain = &blockchain;
    std::memcpy(mem,      latest_data, sizeof mem);
    std::memcpy(bin_data, latest_data, sizeof mem);
    std::memset(return_stack, 0, sizeof return_stack);
    std::memset(data_stack, 0, sizeof data_stack);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %rcx
movq %rdi, %rbx
movq 0x8(%rdx), %rax
subq (%rdx), %rax
movl $0x1050, %edi           # imm = 0x1050
cqto
idivq %rdi
movl %eax, (%rbx)
andq $0x0, 0x4(%rbx)
andq $0x0, 0x9(%rbx)
movq %rsi, %r14
movq %rcx, 0x18(%rbx)
leaq 0x1020(%rbx), %rdi
movl $0x1000, %edx           # imm = 0x1000
callq 0x2180
leaq 0x20(%rbx), %rdi
movl $0x1000, %edx           # imm = 0x1000
movq %r14, %rsi
callq 0x2180
addq $0x3020, %rbx           # imm = 0x3020
movl $0x2000, %edx           # imm = 0x2000
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x2110
nop
// File: /workspace/github_cpp_makefile_star2_O2/s0sasaki[P]ExecutableBlockchain/vm.cpp
// Function: VM::load()
inline void VM::load() {
    if (ib < pblockchain->chain.size())
        std::memcpy(mem, pblockchain->chain[ib].data, sizeof mem);
    else
        std::memcpy(mem, bin_data, sizeof mem);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq (%rdi), %rcx
movq 0x18(%rdi), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rax
subq %rsi, %rax
movl $0x1050, %r8d           # imm = 0x1050
cqto
idivq %r8
leaq 0x20(%rdi), %rdx
imulq $0x1050, %rcx, %r8      # imm = 0x1050
cmpq %rcx, %rax
leaq 0x40(%rsi,%r8), %rsi
cmovbeq %rdx, %rsi
addq $0x1020, %rdi           # imm = 0x1020
movl $0x1000, %edx           # imm = 0x1000
popq %rbp
jmp 0x2180
// File: /workspace/github_cpp_makefile_star2_O2/big-data-lab-team[P]OrpailleCC/main.cpp
// Function: main
int main(){
	CoarseMondrianForest<double, funct, KappaMetrics<LABEL_COUNT>, FEATURE_COUNT, LABEL_COUNT, 6000> classifier(0.6, 0.0001, 0.0, 10);
	//CoarseMondrianForest<double, funct, ErrorMetrics<FEATURE_COUNT, LABEL_COUNT>, FEATURE_COUNT, LABEL_COUNT, 6000> classifier(0.6, 0.0001, 0.0, 10);
	classifier.train(dt[0], labels[0]);
	classifier.train(dt[2], labels[2]);

	double scores[2];
	int result = classifier.predict(dt[0], scores);
#ifdef DEBUG
	cout << "Prediction: " << result << endl;
	cout << "True Label: " << labels[0] << endl;
#endif
	//result = classifier.predict(dt[2], scores);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x18a0, %rsp           # imm = 0x18A0
andl $0x0, 0x38(%rsp)
andl $0x0, 0x30(%rsp)
andl $0x0, 0x28(%rsp)
andl $0x0, 0x10(%rsp)
pushq $0x1
popq %rcx
andl $0x0, 0x8(%rsp)
movl %ecx, 0x20(%rsp)
andl $0x0, (%rsp)
movl %ecx, 0x18(%rsp)
leaq 0x58(%rsp), %rbx
movsd 0x4dfc(%rip), %xmm0     # 0x6008
movsd 0x4dfc(%rip), %xmm1     # 0x6010
pushq $0xa
popq %rsi
pushq $-0x1
popq %rbp
movsd 0x4df6(%rip), %xmm3     # 0x6018
xorps %xmm2, %xmm2
movq %rbx, %rdi
xorl %edx, %edx
movl %ebp, %r8d
xorl %r9d, %r9d
movaps %xmm3, %xmm4
movaps %xmm3, %xmm5
movaps %xmm3, %xmm6
callq 0x128c
movl 0x7fdc(%rip), %edx      # 0x9220
leaq 0x7e15(%rip), %r14      # 0x9060
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1438
movl 0x7fcc(%rip), %edx      # 0x9228
leaq 0x7e3d(%rip), %rsi      # 0x90a0
movq %rbx, %rdi
callq 0x1438
leaq 0x40(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %ecx
callq 0x15b8
xorl %eax, %eax
addq $0x18a0, %rsp           # imm = 0x18A0
popq %rbx
popq %r14
popq %rbp
retq
nop