LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: liujan[P]randomforest/Node.cpp
// Function: Node::Node(Node const&)
Node::Node(const Node &other){
    this->attribute = other.attribute;
    this->value = other.value;
    this->left = other.left;
    this->right = other.right;
    this->sum = other.sum;
    this->samples = other.samples;
    this->depth = other.depth;
    for (int i = 0; i < numOfTypes; i++)
        this->num[i] = other.num[i];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x90, %rdi
movq %rdi, -0x28(%rbp)
callq 0x26b0
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rcx
movsd 0x8(%rcx), %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movl 0x20(%rcx), %ecx
movl %ecx, 0x20(%rax)
movq -0x10(%rbp), %rsi
addq $0x90, %rsi
callq 0x26d0
jmp 0x263a
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x8c(%rcx), %ecx
movl %ecx, 0x8c(%rax)
movl $0x0, -0x20(%rbp)
cmpl $0x1a, -0x20(%rbp)
jge 0x2695
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq -0x20(%rbp), %rdx
movl 0x24(%rcx,%rdx,4), %edx
movslq -0x20(%rbp), %rcx
movl %edx, 0x24(%rax,%rcx,4)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x2655
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x2920
jmp 0x269b
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x2330
nopw %cs:(%rax,%rax)
nop
// File: liujan[P]randomforest/Tree.cpp
// Function: Tree::readSample(std::vector<std::pair<int, std::vector<double, std::allocator<double>>>, std::allocator<std::pair<int, std::vector<double, std::allocator<double>>>>>)
bool Tree::readSample(vector<pair<int, vector<double> > > all_samples){
    if (all_samples.empty()){
        cout << "[Error] all sample is empty!" << endl;
        return false;
    }
    
    if (root == NULL)
        root = new Node();
    
    double p = 0.0;
    for (int i = 0; i < all_samples.size(); i++){
        p = rand() * 1.0 / RAND_MAX;
        if (p <= 0.6) {  //每棵树用总样本的60%来训练
            root->samples.push_back(all_samples[i]);
            int type = all_samples[i].first;
            root->num[type - 1]++;
        }
    }
    root->sum = root->samples.size();

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x50(%rbp)
movq %rdi, %rax
movq -0x50(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movq %rax, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x6030
testb $0x1, %al
jne 0x4a92
jmp 0x4abd
movq 0x1453f(%rip), %rdi     # 0x18fd8
leaq 0xb5c0(%rip), %rsi      # 0x10060
callq 0x21c0
movq %rax, %rdi
movq 0x14519(%rip), %rsi     # 0x18fc8
callq 0x2200
movb $0x0, -0x1(%rbp)
jmp 0x4c01
movq -0x40(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x4b0e
movl $0xa8, %edi
callq 0x21d0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
callq 0x2550
jmp 0x4ae2
movq -0x40(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, (%rax)
jmp 0x4b0e
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0xa8, %esi
callq 0x21e0
jmp 0x4c0c
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x48(%rbp), %rdi
movslq -0x34(%rbp), %rax
movq %rax, -0x60(%rbp)
callq 0x2e50
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jae 0x4bdd
callq 0x2080
cvtsi2sd %eax, %xmm0
movsd 0xb4c9(%rip), %xmm1     # 0x10018
mulsd %xmm1, %xmm0
movsd 0xb4b5(%rip), %xmm1     # 0x10010
divsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd 0xb49c(%rip), %xmm0     # 0x10008
ucomisd -0x30(%rbp), %xmm0
jb 0x4bcd
movq -0x40(%rbp), %rax
movq -0x48(%rbp), %rdi
movq (%rax), %rax
addq $0x90, %rax
movq %rax, -0x68(%rbp)
movslq -0x34(%rbp), %rsi
callq 0x60e0
movq -0x68(%rbp), %rdi
movq %rax, %rsi
callq 0x6070
movq -0x48(%rbp), %rdi
movslq -0x34(%rbp), %rsi
callq 0x60e0
movq %rax, %rcx
movq -0x40(%rbp), %rax
movl (%rcx), %ecx
movl %ecx, -0x38(%rbp)
movq (%rax), %rax
movl -0x38(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl 0x24(%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, 0x24(%rax,%rcx,4)
jmp 0x4bcf
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x4b1d
movq -0x40(%rbp), %rax
movq (%rax), %rdi
addq $0x90, %rdi
callq 0x2e50
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq (%rax), %rax
movl %ecx, 0x20(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x2330
nopw %cs:(%rax,%rax)
// File: liujan[P]randomforest/Tree.cpp
// Function: getType(Node*)
int getType(Node *node){
    if (node == NULL)
        return 0;
    int max_value = -1000, index = 0;
    for (int i = 0; i < numOfTypes; i++){
        if (max_value <= node->num[i]){
            max_value = node->num[i];
            index = i + 1;
        }
    }
    return index;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x5cc8
movl $0x0, -0x4(%rbp)
jmp 0x5d1f
movl $0xfffffc18, -0x14(%rbp) # imm = 0xFFFFFC18
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x1a, -0x1c(%rbp)
jge 0x5d19
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
cmpl 0x24(%rcx,%rdx,4), %eax
jg 0x5d0c
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl 0x24(%rax,%rcx,4), %eax
movl %eax, -0x14(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x5d0e
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5cdd
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: liujan[P]randomforest/Tree.cpp
// Function: Tree::predict(std::vector<double, std::allocator<double>>)
int Tree::predict(vector<double> features){
    if (root == NULL){
        cout << "[Error] empty tree" << endl;
        return 0;
    }
    Node *head = root;
    while (true) {
        if (head->left == NULL && head->right == NULL){
            return getType(head);
        }
        int attr = head->attribute;
        double value = head->value;
        if (features[attr] < value){
            if (head->left == NULL)
                return getType(head);
            else
                head = head->left;
        }
        else {
            if (head->right == NULL)
                return getType(head);
            else
                head = head->right;
        }
    }
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x40(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, (%rax)
jne 0x5d80
movq 0x1327f(%rip), %rdi     # 0x18fd8
leaq 0xa347(%rip), %rsi      # 0x100a7
callq 0x21c0
movq %rax, %rdi
movq 0x13259(%rip), %rsi     # 0x18fc8
callq 0x2200
movl $0x0, -0x4(%rbp)
jmp 0x5e38
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x5db2
movq -0x20(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x5db2
movq -0x20(%rbp), %rdi
callq 0x5cb0
movl %eax, -0x4(%rbp)
jmp 0x5e38
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movslq -0x24(%rbp), %rsi
callq 0x61e0
movsd (%rax), %xmm1
movsd -0x30(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x5e0c
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x5dfe
movq -0x20(%rbp), %rdi
callq 0x5cb0
movl %eax, -0x4(%rbp)
jmp 0x5e38
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x5e33
movq -0x20(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x5e25
movq -0x20(%rbp), %rdi
callq 0x5cb0
movl %eax, -0x4(%rbp)
jmp 0x5e38
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x5e33
jmp 0x5d8b
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: liujan[P]randomforest/Tree.cpp
// Function: Tree::randomSelect()
vector<int> Tree::randomSelect(){
    vector<int> v;
    for (int i = 0; i < numOfFeatures; i++){
        double p = rand() * 1.0 / RAND_MAX;
        if (p <= 0.6)
            v.push_back(i);
    }
    return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x6be0
movl $0x0, -0x18(%rbp)
cmpl $0x269, -0x18(%rbp)     # imm = 0x269
jge 0x5eee
callq 0x2080
cvtsi2sd %eax, %xmm0
movsd 0xa183(%rip), %xmm1     # 0x10018
mulsd %xmm1, %xmm0
movsd 0xa16f(%rip), %xmm1     # 0x10010
divsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd 0xa156(%rip), %xmm0     # 0x10008
ucomisd -0x20(%rbp), %xmm0
jb 0x5ee1
movq -0x40(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x6c00
jmp 0x5ec8
jmp 0x5ee1
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x6b80
jmp 0x5f0b
jmp 0x5ee3
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x5e7b
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x5f01
movq -0x40(%rbp), %rdi
callq 0x6b80
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x2330
nopw %cs:(%rax,%rax)
// File: liujan[P]randomforest/Tree.cpp
// Function: Tree::~Tree()
Tree::~Tree(){
    Node *head = root;
    queue<Node*>q;
    q.push(head);
    while(!q.empty()){
        head = q.front();
        q.pop();
        if (head == NULL)
            continue;
        Node *left = head->left;
        Node *right = head->right;
        delete head;
        q.push(left);
        q.push(right);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x6100
jmp 0x5f45
leaq -0x60(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x6130
jmp 0x5f54
jmp 0x5f56
leaq -0x60(%rbp), %rdi
callq 0x6160
movb %al, -0x71(%rbp)
jmp 0x5f64
movb -0x71(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x5f72
jmp 0x6009
leaq -0x60(%rbp), %rdi
callq 0x6180
movq %rax, -0x80(%rbp)
jmp 0x5f81
movq -0x80(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x61a0
jmp 0x5f97
cmpq $0x0, -0x10(%rbp)
jne 0x5fa0
jmp 0x5f56
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
cmpq $0x0, %rax
je 0x5fe6
movq -0x88(%rbp), %rdi
callq 0x6c70
movq -0x88(%rbp), %rdi
movl $0xa8, %esi
callq 0x21e0
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x6130
jmp 0x5ff5
leaq -0x60(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x6130
jmp 0x6004
jmp 0x5f56
leaq -0x60(%rbp), %rdi
callq 0x61c0
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x2a70
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: liujan[P]randomforest/RandomForest.cpp
// Function: RandomForest::build()
void RandomForest::build(){
    if (test_samples.empty()){
        cout << "[Error] test sample is empty" << endl;
        return;
    }
    Tree *tree = new Tree();
    if (tree->readSample(this->all_samples)){
        tree->buildTree();
        for (int j = 0; j < test_samples.size(); j++){
            int id = test_samples[j].first;
            int type = tree->predict(test_samples[j].second);
            result[id][type]++;
        }
    }
    delete tree;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
addq $0x18, %rdi
callq 0x6030
testb $0x1, %al
jne 0xdbd6
jmp 0xdbfd
movq 0xb3fb(%rip), %rdi      # 0x18fd8
leaq 0x2521(%rip), %rsi      # 0x10105
callq 0x21c0
movq %rax, %rdi
movq 0xb3d5(%rip), %rsi      # 0x18fc8
callq 0x2200
jmp 0xddc5
movl $0x8, %edi
callq 0x21d0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x70(%rbp)
callq 0x49f0
jmp 0xdc18
movq -0x68(%rbp), %rsi
movq -0x70(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x6230
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
callq 0x4a60
movb %al, -0x71(%rbp)
jmp 0xdc51
leaq -0x38(%rbp), %rdi
callq 0x2920
movb -0x71(%rbp), %al
testb $0x1, %al
jne 0xdc66
jmp 0xdd97
movq -0x10(%rbp), %rdi
callq 0x4c20
movl $0x0, -0x3c(%rbp)
movq -0x68(%rbp), %rdi
movslq -0x3c(%rbp), %rax
movq %rax, -0x90(%rbp)
addq $0x18, %rdi
callq 0x2e50
movq %rax, %rcx
movq -0x90(%rbp), %rax
cmpq %rcx, %rax
jae 0xdd95
movq -0x68(%rbp), %rdi
addq $0x18, %rdi
movq %rdi, -0xb0(%rbp)
movslq -0x3c(%rbp), %rsi
callq 0x60e0
movq -0xb0(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa8(%rbp)
movslq -0x3c(%rbp), %rsi
callq 0x60e0
movq %rax, %rsi
addq $0x8, %rsi
leaq -0x60(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x3490
movq -0xa8(%rbp), %rdi
movq -0xa0(%rbp), %rsi
callq 0x5d30
movl %eax, -0x94(%rbp)
jmp 0xdd0b
leaq -0x60(%rbp), %rdi
callq 0x2b70
movl -0x94(%rbp), %ecx
movq -0x68(%rbp), %rax
movl %ecx, -0x44(%rbp)
addq $0x48, %rax
movslq -0x40(%rbp), %rcx
imulq $0x6c, %rcx, %rcx
addq %rcx, %rax
movslq -0x44(%rbp), %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0xdc76
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x8, %esi
callq 0x21e0
jmp 0xddce
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2920
jmp 0xddce
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x2b70
jmp 0xddce
jmp 0xdd97
movq -0x10(%rbp), %rax
movq %rax, -0xb8(%rbp)
cmpq $0x0, %rax
je 0xddc5
movq -0xb8(%rbp), %rdi
callq 0x5f20
movq -0xb8(%rbp), %rdi
movl $0x8, %esi
callq 0x21e0
addq $0xc0, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x2330
nopw (%rax,%rax)
// File: liujan[P]randomforest/RandomForest.cpp
// Function: RandomForest::buildTree(int)
bool RandomForest::buildTree(int num){
    if (all_samples.empty()){
        cout << "[Error] all sample is empty" << endl;
        return false;
    }
    
    for (int i = 0; i < num; i++){
        cout << i+1 << " ";
        this->build();
    }
    
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x6030
testb $0x1, %al
jne 0xde02
jmp 0xde2a
movq 0xb1cf(%rip), %rdi      # 0x18fd8
leaq 0x2312(%rip), %rsi      # 0x10122
callq 0x21c0
movq %rax, %rdi
movq 0xb1a9(%rip), %rsi      # 0x18fc8
callq 0x2200
movb $0x0, -0x1(%rbp)
jmp 0xde72
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xde6e
movl -0x18(%rbp), %esi
addl $0x1, %esi
movq 0xb192(%rip), %rdi      # 0x18fd8
callq 0x2320
movq %rax, %rdi
leaq 0x2366(%rip), %rsi      # 0x101bb
callq 0x21c0
movq -0x20(%rbp), %rdi
callq 0xdbb0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xde31
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: liujan[P]randomforest/main.cpp
// Function: fun()
void fun(){
    ifstream in("train.csv");
    ofstream out("train1.csv");
    
    string s;
    getline(in, s);
    out << s << endl;
    while (1){
        if (in.eof())
            break;
        getline(in, s);
        double p = rand() * 1.0 / RAND_MAX;
        if (p <= 0.1)
            out << s << endl;
        if (in.peek() == '\n')
            in.get();
    }
    in.close();
    out.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x470, %rsp            # imm = 0x470
leaq 0xb22(%rip), %rsi       # 0x10194
leaq -0x208(%rbp), %rdi
movl $0x8, %edx
callq 0x2360
leaq 0xbae(%rip), %rsi       # 0x10238
leaq -0x408(%rbp), %rdi
movl $0x10, %edx
callq 0x2230
jmp 0xf69d
leaq -0x438(%rbp), %rdi
movq %rdi, -0x448(%rbp)
callq 0x22a0
movq -0x448(%rbp), %rsi
leaq -0x208(%rbp), %rdi
callq 0x2050
jmp 0xf6c5
leaq -0x408(%rbp), %rdi
leaq -0x438(%rbp), %rsi
callq 0x21b0
movq %rax, -0x450(%rbp)
jmp 0xf6e1
movq -0x450(%rbp), %rdi
movq 0x98d9(%rip), %rsi      # 0x18fc8
callq 0x2200
jmp 0xf6f6
jmp 0xf6f8
jmp 0xf6fa
movq -0x208(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x208(%rbp,%rax), %rdi
callq 0x2370
movb %al, -0x451(%rbp)
jmp 0xf71a
movb -0x451(%rbp), %al
testb $0x1, %al
jne 0xf726
jmp 0xf771
jmp 0xf828
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x410(%rbp)
movl %eax, -0x414(%rbp)
jmp 0xf871
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x410(%rbp)
movl %eax, -0x414(%rbp)
leaq -0x438(%rbp), %rdi
callq 0x2110
leaq -0x408(%rbp), %rdi
callq 0x22d0
jmp 0xf871
leaq -0x208(%rbp), %rdi
leaq -0x438(%rbp), %rsi
callq 0x2050
jmp 0xf786
callq 0x2080
cvtsi2sd %eax, %xmm0
movsd 0x881(%rip), %xmm1      # 0x10018
mulsd %xmm1, %xmm0
movsd 0x86d(%rip), %xmm1      # 0x10010
divsd %xmm1, %xmm0
movsd %xmm0, -0x440(%rbp)
movsd 0xa79(%rip), %xmm0      # 0x10230
ucomisd -0x440(%rbp), %xmm0
jb 0xf7f4
leaq -0x408(%rbp), %rdi
leaq -0x438(%rbp), %rsi
callq 0x21b0
movq %rax, -0x460(%rbp)
jmp 0xf7dd
movq -0x460(%rbp), %rdi
movq 0x97dd(%rip), %rsi      # 0x18fc8
callq 0x2200
jmp 0xf7f2
jmp 0xf7f4
leaq -0x208(%rbp), %rdi
callq 0x20b0
movl %eax, -0x464(%rbp)
jmp 0xf808
movl -0x464(%rbp), %eax
cmpl $0xa, %eax
jne 0xf823
leaq -0x208(%rbp), %rdi
callq 0x2270
jmp 0xf821
jmp 0xf823
jmp 0xf6f8
leaq -0x208(%rbp), %rdi
callq 0x2060
jmp 0xf836
leaq -0x408(%rbp), %rdi
callq 0x22b0
jmp 0xf844
leaq -0x438(%rbp), %rdi
callq 0x2110
leaq -0x408(%rbp), %rdi
callq 0x22d0
leaq -0x208(%rbp), %rdi
callq 0x2070
addq $0x470, %rsp            # imm = 0x470
popq %rbp
retq
leaq -0x208(%rbp), %rdi
callq 0x2070
movq -0x410(%rbp), %rdi
callq 0x2330
nopl (%rax)
// File: liujan[P]randomforest/main.cpp
// Function: main
int main(int argc, const char * argv[]) {
    // insert code here...
    std::cout << "Hello, World!\n";
    
    RandomForest forest;
    forest.readTrainSample("train.csv");
    forest.readTestSample("test.csv");
    forest.buildTree(7000);
    forest.predict();
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x29280, %rsp          # imm = 0x29280
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x9728(%rip), %rdi      # 0x18fd8
leaq 0x98c(%rip), %rsi       # 0x10243
callq 0x21c0
leaq -0x29210(%rbp), %rdi
callq 0xdb60
leaq -0x29231(%rbp), %rdi
movq %rdi, -0x29278(%rbp)
callq 0x2340
movq -0x29278(%rbp), %rdx
leaq 0x8ab(%rip), %rsi       # 0x10194
leaq -0x29230(%rbp), %rdi
callq 0xfa70
jmp 0xf8f7
leaq -0x29210(%rbp), %rdi
leaq -0x29230(%rbp), %rsi
callq 0xe170
jmp 0xf90c
leaq -0x29230(%rbp), %rdi
callq 0x2110
leaq -0x29231(%rbp), %rdi
callq 0x2220
leaq -0x29269(%rbp), %rdi
movq %rdi, -0x29280(%rbp)
callq 0x2340
movq -0x29280(%rbp), %rdx
leaq 0x8a5(%rip), %rsi       # 0x101ea
leaq -0x29268(%rbp), %rdi
callq 0xfa70
jmp 0xf953
leaq -0x29210(%rbp), %rdi
leaq -0x29268(%rbp), %rsi
callq 0xe510
jmp 0xf968
leaq -0x29268(%rbp), %rdi
callq 0x2110
leaq -0x29269(%rbp), %rdi
callq 0x2220
leaq -0x29210(%rbp), %rdi
movl $0x1b58, %esi           # imm = 0x1B58
callq 0xdde0
jmp 0xf993
leaq -0x29210(%rbp), %rdi
callq 0xde80
jmp 0xf9a1
movl $0x0, -0x4(%rbp)
leaq -0x29210(%rbp), %rdi
callq 0xe8a0
movl -0x4(%rbp), %eax
addq $0x29280, %rsp          # imm = 0x29280
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x29240(%rbp)
movl %eax, -0x29244(%rbp)
jmp 0xf9f2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x29240(%rbp)
movl %eax, -0x29244(%rbp)
leaq -0x29230(%rbp), %rdi
callq 0x2110
leaq -0x29231(%rbp), %rdi
callq 0x2220
jmp 0xfa52
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x29240(%rbp)
movl %eax, -0x29244(%rbp)
jmp 0xfa32
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x29240(%rbp)
movl %eax, -0x29244(%rbp)
leaq -0x29268(%rbp), %rdi
callq 0x2110
leaq -0x29269(%rbp), %rdi
callq 0x2220
jmp 0xfa52
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x29240(%rbp)
movl %eax, -0x29244(%rbp)
leaq -0x29210(%rbp), %rdi
callq 0xe8a0
movq -0x29240(%rbp), %rdi
callq 0x2330
nopw (%rax,%rax)
// File: mhe[P]raytracerframework_cpp/main.cpp
// Function: main
int main(int argc, char *argv[])
{
	cout << "Introduction to Computer Graphics - Raytracer" << endl << endl;
	if (argc != 3) {
		cerr << "Usage: " << argv[0] << " in-file out-file.png" << endl;
		return 1;
	}

	Raytracer raytracer;

	if (!raytracer.readScene(argv[1])) {
		cerr << "Error: reading scene from " << argv[1] << " failed - no output generated."<< endl;
		return 1;
	}
	raytracer.renderToFile(argv[2]);
	
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x47c83(%rip), %rdi     # 0x67fd0
leaq 0x2b0a1(%rip), %rsi     # 0x4b3f5
callq 0x5390
movq %rax, %rdi
movq 0x47c4d(%rip), %rsi     # 0x67fb0
callq 0x53f0
movq %rax, %rdi
movq 0x47c3e(%rip), %rsi     # 0x67fb0
callq 0x53f0
cmpl $0x3, -0x8(%rbp)
je 0x203c9
movq 0x47c6c(%rip), %rdi     # 0x67ff0
leaq 0x2b098(%rip), %rsi     # 0x4b423
callq 0x5390
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x5390
movq %rax, %rdi
leaq 0x2b082(%rip), %rsi     # 0x4b42b
callq 0x5390
movq %rax, %rdi
movq 0x47bf8(%rip), %rsi     # 0x67fb0
callq 0x53f0
movl $0x1, -0x4(%rbp)
jmp 0x20449
leaq -0x18(%rbp), %rdi
callq 0x20510
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq -0x18(%rbp), %rdi
callq 0x20d20
testb $0x1, %al
jne 0x20431
movq 0x47c02(%rip), %rdi     # 0x67ff0
leaq 0x2b04c(%rip), %rsi     # 0x4b441
callq 0x5390
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x5390
movq %rax, %rdi
leaq 0x2b048(%rip), %rsi     # 0x4b45c
callq 0x5390
movq %rax, %rdi
movq 0x47b8d(%rip), %rsi     # 0x67fb0
callq 0x53f0
movl $0x1, -0x4(%rbp)
jmp 0x20449
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
leaq -0x18(%rbp), %rdi
callq 0x21590
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: mhe[P]raytracerframework_cpp/raytracer.cpp
// Function: operator>>(YAML::Node const&, Triple&)
void operator >> (const YAML::Node& node, Triple& t)
{
	assert(node.size()==3);
    node[0] >> t.x;
    node[1] >> t.y;
    node[2] >> t.z;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x389d0
cmpl $0x3, %eax
jne 0x207e0
jmp 0x207ff
leaq 0x2acbe(%rip), %rdi     # 0x4b4a5
leaq 0x2acc6(%rip), %rsi     # 0x4b4b4
movl $0x20, %edx
leaq 0x2acc8(%rip), %rcx     # 0x4b4c2
callq 0x5250
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x38ad0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x216b0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x38ad0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x216b0
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x38ad0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x216b0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: mhe[P]raytracerframework_cpp/raytracer.cpp
// Function: parseTriple(YAML::Node const&)
Triple parseTriple(const YAML::Node& node)
{
	Triple t;
    node[0] >> t.x;
    node[1] >> t.y;
    node[2] >> t.z;	
	return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, %rax
movq %rax, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0x21740
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x38ad0
movq -0x18(%rbp), %rsi
movq %rax, %rdi
callq 0x216b0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x38ad0
movq -0x18(%rbp), %rsi
movq %rax, %rdi
addq $0x8, %rsi
callq 0x216b0
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x38ad0
movq -0x18(%rbp), %rsi
movq %rax, %rdi
addq $0x10, %rsi
callq 0x216b0
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mhe[P]raytracerframework_cpp/raytracer.cpp
// Function: Raytracer::parseMaterial(YAML::Node const&)
Material* Raytracer::parseMaterial(const YAML::Node& node)
{
	Material *m = new Material();
	node["color"] >> m->color;	
	node["ka"] >> m->ka;
	node["kd"] >> m->kd;
	node["ks"] >> m->ks;
	node["n"] >> m->n;
	return m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x38, %edi
callq 0x53b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x21780
jmp 0x2091b
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x2abc2(%rip), %rsi     # 0x4b4f0
callq 0x217b0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x207c0
movq -0x10(%rbp), %rdi
leaq 0x2abac(%rip), %rsi     # 0x4b4f6
callq 0x217b0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
addq $0x18, %rsi
callq 0x216b0
movq -0x10(%rbp), %rdi
leaq 0x2ab8f(%rip), %rsi     # 0x4b4f9
callq 0x217b0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
addq $0x20, %rsi
callq 0x216b0
movq -0x10(%rbp), %rdi
leaq 0x2ab72(%rip), %rsi     # 0x4b4fc
callq 0x217b0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
addq $0x28, %rsi
callq 0x216b0
movq -0x10(%rbp), %rdi
leaq 0x2b603(%rip), %rsi     # 0x4bfad
callq 0x217b0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
addq $0x30, %rsi
callq 0x216b0
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x38, %esi
callq 0x53c0
movq -0x20(%rbp), %rdi
callq 0x56c0
nopl (%rax)
// File: mhe[P]raytracerframework_cpp/raytracer.cpp
// Function: Raytracer::parseObject(YAML::Node const&)
Object* Raytracer::parseObject(const YAML::Node& node)
{
	Object *returnObject = NULL;
	std::string objectType;
	node["type"] >> objectType;
	if (objectType.compare("sphere") == 0) {
		
		Point pos;
		node["position"] >> pos;
		double r;
		node["radius"] >> r;
		Sphere *sphere = new Sphere(pos,r);		
		returnObject = sphere;
	}
	if (returnObject) {
		// read the material and attach to object
		returnObject->material = parseMaterial(node["material"]);
	}
	return returnObject;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq $0x0, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x55b0
movq -0x10(%rbp), %rdi
leaq 0x2aad5(%rip), %rsi     # 0x4b4ff
callq 0x217b0
movq %rax, -0x98(%rbp)
jmp 0x20a38
movq -0x98(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x21860
jmp 0x20a4a
leaq -0x38(%rbp), %rdi
leaq 0x2aaaf(%rip), %rsi     # 0x4b504
callq 0x5120
cmpl $0x0, %eax
jne 0x20b60
leaq -0x60(%rbp), %rdi
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0x21740
jmp 0x20a77
movq -0x10(%rbp), %rdi
leaq 0x2aa89(%rip), %rsi     # 0x4b50b
callq 0x217b0
movq %rax, -0xa8(%rbp)
jmp 0x20a90
movq -0xa8(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x207c0
jmp 0x20aa2
movq -0x10(%rbp), %rdi
leaq 0x2aa67(%rip), %rsi     # 0x4b514
callq 0x217b0
movq %rax, -0xb0(%rbp)
jmp 0x20abb
movq -0xb0(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x216b0
jmp 0x20acd
movl $0x30, %edi
callq 0x53b0
movq %rax, -0xb8(%rbp)
jmp 0x20ae0
movq -0xb8(%rbp), %rdi
movq -0x50(%rbp), %rax
movq %rax, -0x80(%rbp)
movups -0x60(%rbp), %xmm0
movaps %xmm0, -0x90(%rbp)
movsd -0x68(%rbp), %xmm0
movq -0x80(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x10(%rax)
movaps -0x90(%rbp), %xmm1
movups %xmm1, (%rax)
callq 0x218f0
jmp 0x20b1b
movq -0xb8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x20b60
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x20bcf
movq -0xb8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
movl $0x30, %esi
callq 0x53c0
jmp 0x20bcf
cmpq $0x0, -0x18(%rbp)
je 0x20bab
movq -0x10(%rbp), %rdi
leaq 0x2a9a9(%rip), %rsi     # 0x4b51b
callq 0x217b0
movq %rax, -0xc0(%rbp)
jmp 0x20b80
movq -0xc0(%rbp), %rsi
movq -0xa0(%rbp), %rdi
callq 0x208f0
movq %rax, -0xc8(%rbp)
jmp 0x20b9c
movq -0xc8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0xd0(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x5788
movq -0xd0(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0x5788
movq -0x40(%rbp), %rdi
callq 0x56c0
nopw %cs:(%rax,%rax)
// File: mhe[P]raytracerframework_cpp/raytracer.cpp
// Function: Raytracer::parseLight(YAML::Node const&)
Light* Raytracer::parseLight(const YAML::Node& node)
{
	Point position;
	node["position"] >> position;
	Color color;
	node["color"] >> color;
	return new Light(position,color);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
xorps %xmm2, %xmm2
movsd %xmm2, -0xa8(%rbp)
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0x21740
movq -0x10(%rbp), %rdi
leaq 0x2a8dc(%rip), %rsi     # 0x4b50b
callq 0x217b0
movq -0xb0(%rbp), %rsi
movq %rax, %rdi
callq 0x207c0
movsd -0xa8(%rbp), %xmm2
leaq -0x40(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0x21740
movq -0x10(%rbp), %rdi
leaq 0x2a884(%rip), %rsi     # 0x4b4f0
callq 0x217b0
movq -0xa0(%rbp), %rsi
movq %rax, %rdi
callq 0x207c0
movl $0x30, %edi
callq 0x53b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movups -0x28(%rbp), %xmm0
movaps %xmm0, -0x60(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x70(%rbp)
movups -0x40(%rbp), %xmm0
movaps %xmm0, -0x80(%rbp)
movq -0x70(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x28(%rax)
movaps -0x80(%rbp), %xmm0
movups %xmm0, 0x18(%rax)
movq -0x50(%rbp), %rcx
movq %rcx, 0x10(%rax)
movaps -0x60(%rbp), %xmm0
movups %xmm0, (%rax)
callq 0x21990
jmp 0x20ce0
movq -0x98(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
movl $0x30, %esi
callq 0x53c0
movq -0x88(%rbp), %rdi
callq 0x56c0
nop
// File: mhe[P]raytracerframework_cpp/raytracer.cpp
// Function: Raytracer::renderToFile(char*)
void Raytracer::renderToFile(char* outputFilename)
{
	Image img(400,400);
	cout << "Tracing..." << endl;
	scene->render(img);
	cout << "Writing image to " << outputFilename << "..." << endl;
	img.write_png(outputFilename);
	cout << "Done." << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x20(%rbp), %rdi
movl $0x190, %edx            # imm = 0x190
movl %edx, %esi
callq 0x21a30
movq 0x46a11(%rip), %rdi     # 0x67fd0
leaq 0x2a07b(%rip), %rsi     # 0x4b641
callq 0x5390
movq %rax, -0x38(%rbp)
jmp 0x215d1
movq -0x38(%rbp), %rdi
movq 0x469d4(%rip), %rsi     # 0x67fb0
callq 0x53f0
jmp 0x215e3
movq -0x40(%rbp), %rax
movq (%rax), %rdi
leaq -0x20(%rbp), %rsi
callq 0x32a00
jmp 0x215f5
movq 0x469d4(%rip), %rdi     # 0x67fd0
leaq 0x2a049(%rip), %rsi     # 0x4b64c
callq 0x5390
movq %rax, -0x48(%rbp)
jmp 0x2160e
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5390
movq %rax, -0x50(%rbp)
jmp 0x21621
movq -0x50(%rbp), %rdi
leaq 0x2a01c(%rip), %rsi     # 0x4b648
callq 0x5390
movq %rax, -0x58(%rbp)
jmp 0x21637
movq -0x58(%rbp), %rdi
movq 0x4696e(%rip), %rsi     # 0x67fb0
callq 0x53f0
jmp 0x21649
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x22610
jmp 0x21658
movq 0x46971(%rip), %rdi     # 0x67fd0
leaq 0x29ff8(%rip), %rsi     # 0x4b65e
callq 0x5390
movq %rax, -0x60(%rbp)
jmp 0x21671
movq -0x60(%rbp), %rdi
movq 0x46934(%rip), %rsi     # 0x67fb0
callq 0x53f0
jmp 0x21683
leaq -0x20(%rbp), %rdi
callq 0x21a70
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x21a70
movq -0x28(%rbp), %rdi
callq 0x56c0
// File: mhe[P]raytracerframework_cpp/./yaml/node.h
// Function: YAML::Node const& YAML::Node::GetValue<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
inline const Node& Node::GetValue(const T& key) const
	{
		if(!m_pContent)
			throw BadDereference();

		for(Iterator it=begin();it!=end();++it) {
			T t;
			if(YAML::Read(it.first(), t)) {
				if(key == t)
					return it.second();
			}
		}

		throw KeyNotFound(m_line, m_column);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
cmpq $0x0, 0x48(%rax)
jne 0x21b1e
movl $0x30, %edi
callq 0x51b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x70(%rbp)
callq 0x21ce0
jmp 0x21aed
movq -0x70(%rbp), %rdi
leaq 0x45b38(%rip), %rsi     # 0x67630
leaq 0x221(%rip), %rdx       # 0x21d20
callq 0x5690
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x52c0
jmp 0x21cd1
movq -0x68(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x38750
movq -0x68(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x38890
jmp 0x21b3a
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x348b0
movb %al, -0x71(%rbp)
jmp 0x21b4c
leaq -0x38(%rbp), %rdi
callq 0x344a0
movb -0x71(%rbp), %al
testb $0x1, %al
jne 0x21b93
movl $0x2, -0x3c(%rbp)
jmp 0x21c49
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x21c5e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x344a0
jmp 0x21c5e
leaq -0x60(%rbp), %rdi
callq 0x55b0
leaq -0x30(%rbp), %rdi
callq 0x346f0
movq %rax, -0x80(%rbp)
jmp 0x21bab
movq -0x80(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x21d40
movb %al, -0x81(%rbp)
jmp 0x21bc0
movb -0x81(%rbp), %al
testb $0x1, %al
jne 0x21bcc
jmp 0x21c1e
movq -0x18(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x21d70
testb $0x1, %al
jne 0x21bdf
jmp 0x21c1c
leaq -0x30(%rbp), %rdi
callq 0x34780
movq %rax, -0x90(%rbp)
jmp 0x21bf1
movq -0x90(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0x3c(%rbp)
jmp 0x21c25
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x5788
jmp 0x21c5e
jmp 0x21c1e
movl $0x0, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x5788
movl -0x3c(%rbp), %eax
testl %eax, %eax
jne 0x21c49
jmp 0x21c37
jmp 0x21c39
leaq -0x30(%rbp), %rdi
callq 0x344e0
jmp 0x21c44
jmp 0x21b2b
leaq -0x30(%rbp), %rdi
callq 0x344a0
movl -0x3c(%rbp), %eax
subl $0x1, %eax
je 0x21cc4
jmp 0x21c5c
jmp 0x21c69
leaq -0x30(%rbp), %rdi
callq 0x344a0
jmp 0x21cd1
movl $0x30, %edi
callq 0x51b0
movq %rax, %rdi
movq -0x68(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x98(%rbp)
movl (%rax), %esi
movl 0x4(%rax), %edx
callq 0x21e00
jmp 0x21c90
movq -0x98(%rbp), %rdi
leaq 0x459aa(%rip), %rsi     # 0x67648
leaq 0x1ab(%rip), %rdx       # 0x21e50
callq 0x5690
movq -0x98(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x52c0
jmp 0x21cd1
movq -0x8(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x56c0
nopw (%rax,%rax)
// File: mhe[P]raytracerframework_cpp/sphere.cpp
// Function: Sphere::intersect(Ray const&, double*)
bool Sphere::intersect(const Ray &ray, double *t)
{
	/****************************************************
	* RT1.1: INTERSECTION CALCULATION
	*
	* Given: ray, position, r
	* Sought: intersects? if true: *t
	* 
	* Insert calculation of ray/sphere intersection here. 
	*
	* You have the sphere's center (C) and radius (r) as well as
	* the ray's origin (ray.O) and direction (ray.D).
	*
	* If the ray does not intersect the sphere, return false.
	* Otherwise, return true and place the distance of the
	* intersection point from the ray origin in *t (see example).
	****************************************************/

	// place holder for actual intersection calculation

	Vector OC = (position - ray.O).normalized();
	if (OC.dot(ray.D) > 0.999) {
		*t = 1000;
		return true;
	}

	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
movq -0x18(%rbp), %rdx
leaq -0x50(%rbp), %rdi
callq 0x222b0
leaq -0x38(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x22310
movq -0x18(%rbp), %rsi
addq $0x18, %rsi
leaq -0x38(%rbp), %rdi
callq 0x22350
movsd 0x294b1(%rip), %xmm1    # 0x4b700
ucomisd %xmm1, %xmm0
jbe 0x2226b
movq -0x20(%rbp), %rax
movsd 0x294a7(%rip), %xmm0    # 0x4b708
movsd %xmm0, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x2226f
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mhe[P]raytracerframework_cpp/image.cpp
// Function: Image::set_extent(int, int)
bool Image::set_extent(int width, int height)
{
	_width = width;
	_height = height;
	if (_pixel) delete[] _pixel;
	_pixel = size() > 0 ? new Color[size()] : 0;
	return _pixel != 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, 0x8(%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0xc(%rax)
cmpq $0x0, (%rax)
je 0x224fb
movq -0x40(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x224f9
movq -0x48(%rbp), %rdi
callq 0x5530
jmp 0x224fb
movq -0x40(%rbp), %rdi
callq 0x22d10
movb $0x0, -0x21(%rbp)
cmpl $0x0, %eax
jle 0x225b7
movq -0x40(%rbp), %rdi
callq 0x22d10
cltq
movq %rax, -0x58(%rbp)
movl $0x18, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
movq %rdi, -0x60(%rbp)
callq 0x5050
movq -0x60(%rbp), %rcx
movq %rax, %rdx
movq -0x58(%rbp), %rax
movq %rdx, -0x50(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movb $0x1, -0x21(%rbp)
cmpq $0x0, %rax
je 0x225ad
movq -0x50(%rbp), %rax
movq -0x58(%rbp), %rcx
imulq $0x18, %rcx, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movq %rcx, -0x70(%rbp)
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rdi
movq %rdi, -0x78(%rbp)
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0x21740
jmp 0x22598
movq -0x70(%rbp), %rcx
movq -0x78(%rbp), %rax
addq $0x18, %rax
cmpq %rcx, %rax
movq %rax, -0x68(%rbp)
jne 0x22580
movq -0x50(%rbp), %rax
movq %rax, -0x80(%rbp)
jmp 0x225bf
xorl %eax, %eax
movq %rax, -0x80(%rbp)
jmp 0x225bf
movq -0x40(%rbp), %rax
movq -0x80(%rbp), %rcx
movq %rcx, (%rax)
cmpq $0x0, (%rax)
setne %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x225f0
jmp 0x225fd
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x5740
jmp 0x225ff
movq -0x30(%rbp), %rdi
callq 0x56c0
nopl (%rax,%rax)
// File: mhe[P]raytracerframework_cpp/lodepng.cpp
// Function: LodeFlate_inflate(ucvector*, unsigned char const*, unsigned long, unsigned long)
unsigned LodeFlate_inflate(ucvector* out, const unsigned char* in, size_t insize, size_t inpos)
{
  size_t bp = 0; /*bit pointer in the "in" data, current byte is bp >> 3, current bit is bp & 0x7 (from lsb to msb of the byte)*/
  unsigned BFINAL = 0;
  size_t pos = 0; /*byte position in the out buffer*/
  
  unsigned error = 0;
  
  while(!BFINAL)
  {
    unsigned BTYPE;
    if((bp >> 3) >= insize) return 52; /*error, bit pointer will jump past memory*/
    BFINAL = readBitFromStream(&bp, &in[inpos]);
    BTYPE = 1 * readBitFromStream(&bp, &in[inpos]); BTYPE += 2 * readBitFromStream(&bp, &in[inpos]);

    if(BTYPE == 3) return 20; /*error: invalid BTYPE*/
    else if(BTYPE == 0) error = inflateNoCompression(out, &in[inpos], &bp, &pos, insize); /*no compression*/
    else error = inflateHuffmanBlock(out, &in[inpos], &bp, &pos, insize, BTYPE); /*compression, BTYPE 01 or 10*/
    if(error) return error;
  }
  
  if(!ucvector_resize(out, pos)) error = 9916; /*Only now we know the true size of out, resize it to that*/
  
  return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movq $0x0, -0x40(%rbp)
movl $0x0, -0x44(%rbp)
cmpl $0x0, -0x34(%rbp)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x23d28
jmp 0x23e02
movq -0x30(%rbp), %rax
shrq $0x3, %rax
cmpq -0x20(%rbp), %rax
jb 0x23d42
movl $0x34, -0x4(%rbp)
jmp 0x23e21
movq -0x18(%rbp), %rsi
addq -0x28(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x23e30
movzbl %al, %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rsi
addq -0x28(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x23e30
movzbl %al, %eax
shll $0x0, %eax
movl %eax, -0x48(%rbp)
movq -0x18(%rbp), %rsi
addq -0x28(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x23e30
movzbl %al, %eax
shll %eax
addl -0x48(%rbp), %eax
movl %eax, -0x48(%rbp)
cmpl $0x3, -0x48(%rbp)
jne 0x23da1
movl $0x14, -0x4(%rbp)
jmp 0x23e21
cmpl $0x0, -0x48(%rbp)
jne 0x23dc9
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq -0x28(%rbp), %rsi
movq -0x20(%rbp), %r8
leaq -0x30(%rbp), %rdx
leaq -0x40(%rbp), %rcx
callq 0x23e80
movl %eax, -0x44(%rbp)
jmp 0x23ded
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq -0x28(%rbp), %rsi
movq -0x20(%rbp), %r8
movl -0x48(%rbp), %r9d
leaq -0x30(%rbp), %rdx
leaq -0x40(%rbp), %rcx
callq 0x24030
movl %eax, -0x44(%rbp)
jmp 0x23def
cmpl $0x0, -0x44(%rbp)
je 0x23dfd
movl -0x44(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x23e21
jmp 0x23d16
movq -0x10(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x24470
cmpl $0x0, %eax
jne 0x23e1b
movl $0x26bc, -0x44(%rbp)    # imm = 0x26BC
movl -0x44(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mhe[P]raytracerframework_cpp/lodepng.cpp
// Function: ucvector_resize(ucvector*, unsigned long)
static unsigned ucvector_resize(ucvector* p, size_t size) /*returns 1 if success, 0 if failure ==> nothing done*/
{
  if(size * sizeof(unsigned) > p->allocsize)
  {
    size_t newsize = size * sizeof(unsigned) * 2;
    void* data = realloc(p->data, newsize);
    if(data)
    {
      p->allocsize = newsize;
      p->data = (unsigned char*)data;
      p->size = size;
    }
    else return 0; /*error: not enough memory*/
  }
  else p->size = size;
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
shlq $0x2, %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jbe 0x244ec
movq -0x18(%rbp), %rax
shlq $0x2, %rax
shlq %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x5650
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x244e1
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x244ea
movl $0x0, -0x4(%rbp)
jmp 0x244ff
jmp 0x244f8
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: mhe[P]raytracerframework_cpp/lodepng.cpp
// Function: LodeFlate_deflate(ucvector*, unsigned char const*, unsigned long, LodeZlib_DeflateSettings const*)
unsigned LodeFlate_deflate(ucvector* out, const unsigned char* data, size_t datasize, const LodeZlib_DeflateSettings* settings)
{
  unsigned error = 0;
  if(settings->btype == 0) error = deflateNoCompression(out, data, datasize);
  else if(settings->btype == 1) error = deflateFixed(out, data, datasize, settings);
  else if(settings->btype == 2) error = deflateDynamic(out, data, datasize, settings);
  else error = 61;
  return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x2454e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x245b0
movl %eax, -0x24(%rbp)
jmp 0x2459f
movq -0x20(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x24571
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x24730
movl %eax, -0x24(%rbp)
jmp 0x2459d
movq -0x20(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x24594
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x24950
movl %eax, -0x24(%rbp)
jmp 0x2459b
movl $0x3d, -0x24(%rbp)
jmp 0x2459d
jmp 0x2459f
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: mhe[P]raytracerframework_cpp/lodepng.cpp
// Function: LodeZlib_add32bitInt(ucvector*, unsigned int)
void LodeZlib_add32bitInt(ucvector* buffer, unsigned value)
{
  ucvector_push_back(buffer, (unsigned char)((value >> 24) & 0xff));
  ucvector_push_back(buffer, (unsigned char)((value >> 16) & 0xff));
  ucvector_push_back(buffer, (unsigned char)((value >>  8) & 0xff));
  ucvector_push_back(buffer, (unsigned char)((value      ) & 0xff));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
shrl $0x18, %eax
andl $0xff, %eax
movzbl %al, %esi
callq 0x25570
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
shrl $0x10, %eax
andl $0xff, %eax
movzbl %al, %esi
callq 0x25570
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
shrl $0x8, %eax
andl $0xff, %eax
movzbl %al, %esi
callq 0x25570
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
andl $0xff, %eax
movzbl %al, %esi
callq 0x25570
addq $0x10, %rsp
popq %rbp
retq
nop
// File: mhe[P]raytracerframework_cpp/lodepng.cpp
// Function: LodePNG_chunk_check_crc(unsigned char const*)
unsigned LodePNG_chunk_check_crc(const unsigned char* chunk) /*returns 0 if the crc is correct, error code if it's incorrect*/
{
  unsigned length = LodePNG_chunk_length(chunk);
  unsigned CRC = LodePNG_read32bitInt(&chunk[length + 8]);
  unsigned checksum = Crc32_crc(&chunk[4], length + 4); /*the CRC is taken of the data and the 4 chunk type letters, not the length*/
  if(CRC != checksum) return 1;
  else return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x25a30
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
addl $0x8, %eax
movl %eax, %eax
addq %rax, %rdi
callq 0x25a50
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x4, %rdi
movl -0x14(%rbp), %eax
addl $0x4, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x25c90
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
je 0x25c7a
movl $0x1, -0x4(%rbp)
jmp 0x25c81
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mhe[P]raytracerframework_cpp/lodepng.cpp
// Function: LodePNG_set32bitInt(unsigned char*, unsigned int)
static void LodePNG_set32bitInt(unsigned char* buffer, unsigned value) /*buffer must have at least 4 allocated bytes available*/
{
  buffer[0] = (unsigned char)((value >> 24) & 0xff);
  buffer[1] = (unsigned char)((value >> 16) & 0xff);
  buffer[2] = (unsigned char)((value >>  8) & 0xff);
  buffer[3] = (unsigned char)((value      ) & 0xff);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
shrl $0x18, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, (%rax)
movl -0xc(%rbp), %eax
shrl $0x10, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x1(%rax)
movl -0xc(%rbp), %eax
shrl $0x8, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x2(%rax)
movl -0xc(%rbp), %eax
andl $0xff, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x3(%rax)
popq %rbp
retq
nopl (%rax)