LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/Eshaancoding[P]AutoDiff/src/Matrix/operations.cpp
// Function: operator+(double const&, Matrix const&)
Matrix operator+ (const double &b, const Matrix &a) {
    // create matrix 
    Matrix return_mat = Matrix(a.height, a.width);
    // operations
    for (int i = 0; i < a.height; i++) {
        for (int x = 0; x < a.width; x++) {
            Variable *new_var = new Variable();
            new_var->operation = op::argument;
            new_var->value = b;
            return_mat.array[i].array[x] = *(new_var) + a.array[i].array[x];
        }
    }
    // return
    return return_mat;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movq %rdi, -0x38(%rbp)
movl 0x8(%rsi), %esi
movl 0xc(%rbx), %edx
leaq -0x48(%rbp), %rdi
callq 0x285c
xorl %r12d, %r12d
movslq 0x8(%rbx), %rax
cmpq %rax, %r12
jge 0x308d
movq %r12, -0x30(%rbp)
shlq $0x4, %r12
xorl %r13d, %r13d
xorl %r14d, %r14d
movslq 0xc(%rbx), %rax
cmpq %rax, %r14
jge 0x3081
pushq $0x30
popq %rdi
callq 0x2170
movq %rax, %r15
xorps %xmm0, %xmm0
movq %rax, %rdi
pushq $0x1
popq %rsi
callq 0x3bbc
movl $0x1, 0x8(%r15)
movq -0x38(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, (%r15)
movq (%rbx), %rax
movq (%rax,%r12), %rdx
addq %r13, %rdx
leaq -0x78(%rbp), %rdi
movq %r15, %rsi
callq 0x4e7c
movq -0x48(%rbp), %rax
movq (%rax,%r12), %rax
movups -0x78(%rbp), %xmm0
movups -0x68(%rbp), %xmm1
movups -0x58(%rbp), %xmm2
movups %xmm2, 0x20(%rax,%r13)
movups %xmm1, 0x10(%rax,%r13)
movups %xmm0, (%rax,%r13)
incq %r14
addq $0x30, %r13
jmp 0x3006
movq -0x30(%rbp), %r12
incq %r12
jmp 0x2feb
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rdx
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x2150
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O2/Eshaancoding[P]AutoDiff/src/Variable/Var.cpp
// Function: Variable::Variable(double, bool)
Variable::Variable (double value, bool t) {
    this->child[0] = nullptr;
    this->child[1] = nullptr;
    this->arg = nullptr;
    this->operation = op::input; 
    this->value = value;
    static int id_counter = 0;
    if (t) {
        id_counter++;
        this->id = id_counter;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
orl $-0x1, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
andl $0x0, 0x8(%rdi)
xorps %xmm1, %xmm1
movups %xmm1, 0x10(%rdi)
movsd %xmm0, (%rdi)
testl %esi, %esi
je 0x3bed
movl 0xb58a(%rip), %eax      # 0xf16c
incl %eax
movl %eax, 0xb582(%rip)      # 0xf16c
movl %eax, 0x20(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Eshaancoding[P]AutoDiff/src/Variable/eval.cpp
// Function: Variable::exec_op(double, op, double)
double Variable::exec_op(double num_one, op operation, double num_two) {
    if (operation == add) return num_one + num_two;
    else if (operation == subtract) return num_one - num_two;
    else if (operation == multiply) return num_one * num_two;
    else if (operation == divide) return num_one / num_two;
    else if (operation == exponent) return pow(num_one, num_two);
    else if (operation == op::min && num_one > num_two) return num_two;
    else if (operation == op::min && num_one < num_two) return num_one;
    else if (operation == op::max && num_one > num_two) return num_one;
    else if (operation == op::max && num_one < num_two) return num_two; 
    else if (operation == op::sin_r_op) return sin(num_one);
    else if (operation == op::cos_r_op) return cos(num_one);
    else if (operation == op::sin_d_op) return sin(num_one * (pi/180)); 
    else if (operation == op::cos_d_op) return cos(num_one * (pi/180)); 
    else {throw invalid_argument("exec op error");}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leal -0x2(%rsi), %eax
cmpl $0x4, %eax
ja 0x3c3b
leaq 0x6562(%rip), %rcx      # 0xa168
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
addsd %xmm0, %xmm1
jmp 0x3c32
popq %rbx
popq %r14
popq %rbp
jmp 0x2220
divsd %xmm1, %xmm0
jmp 0x3c2e
mulsd %xmm0, %xmm1
jmp 0x3c32
subsd %xmm1, %xmm0
movapd %xmm0, %xmm1
movapd %xmm1, %xmm0
popq %rbx
popq %r14
popq %rbp
retq
cmpl $0x8, %esi
jne 0x3c46
ucomisd %xmm1, %xmm0
ja 0x3c32
cmpl $0x8, %esi
jne 0x3c51
ucomisd %xmm0, %xmm1
ja 0x3c2e
cmpl $0x9, %esi
jne 0x3c5c
ucomisd %xmm1, %xmm0
ja 0x3c2e
cmpl $0x9, %esi
jne 0x3c67
ucomisd %xmm0, %xmm1
ja 0x3c32
addl $-0xb, %esi
cmpl $0x3, %esi
ja 0x3ca1
leaq 0x6506(%rip), %rax      # 0xa17c
movslq (%rax,%rsi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
mulsd 0x64d9(%rip), %xmm0     # 0xa160
popq %rbx
popq %r14
popq %rbp
jmp 0x2050
mulsd 0x64c8(%rip), %xmm0     # 0xa160
popq %rbx
popq %r14
popq %rbp
jmp 0x2250
pushq $0x10
popq %rdi
callq 0x20c0
movq %rax, %rbx
leaq 0x64d9(%rip), %rsi      # 0xa18c
movq %rax, %rdi
callq 0x2260
movq 0xb31e(%rip), %rsi      # 0xefe0
movq 0xb307(%rip), %rdx      # 0xefd0
movq %rbx, %rdi
callq 0x21f0
movq %rax, %r14
movq %rbx, %rdi
callq 0x2110
movq %r14, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O2/Eshaancoding[P]AutoDiff/src/Variable/eval.cpp
// Function: Variable::find_unique_id(std::vector<int, std::allocator<int>>*, std::vector<int, std::allocator<int>>*)
void Variable::find_unique_id (vector<int> *ID_ARRAY, vector<int> *input_map) {
    if (this->child[0] != NULL && child[1] != NULL) {
        if (this->child[1] != NULL) {
            this->child[0]->find_unique_id(ID_ARRAY, input_map);
            this->child[1]->find_unique_id(ID_ARRAY, input_map);
        } else {
            this->child[0]->find_unique_id(ID_ARRAY, input_map);
        }
    } else {
        if (this->operation == op::input) {
            // ID_ARRAY
            bool found = false;
            for (auto i : *ID_ARRAY) {
                if (i == this->id) {
                    found = true;
                    break;
                }
            }
            if (!found) {
                ID_ARRAY->push_back(this->id);   
            }
            // input-map
            found = false;
            for (auto i : *input_map) {
                if (i == this->id) {
                    found = true;
                    break;
                }
            }
            if (!found) {
                input_map->push_back(this->id);
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x3fd8
cmpq $0x0, 0x18(%r14)
je 0x3fd8
movq %r15, %rsi
movq %rbx, %rdx
callq 0x3fa4
movq 0x18(%r14), %r14
jmp 0x3fb7
cmpl $0x0, 0x8(%r14)
jne 0x401e
movq (%r15), %rax
movq 0x8(%r15), %rcx
addq $0x20, %r14
cmpq %rcx, %rax
je 0x3ffc
movl (%rax), %edx
addq $0x4, %rax
cmpl (%r14), %edx
jne 0x3fea
jmp 0x4007
movq %r15, %rdi
movq %r14, %rsi
callq 0x4048
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
cmpq %rcx, %rax
je 0x4029
movl (%rax), %edx
addq $0x4, %rax
cmpl (%r14), %edx
jne 0x400e
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4048
// File: /workspace/github_cpp_makefile_star2_O2/Eshaancoding[P]AutoDiff/src/Variable/grad.cpp
// Function: print_array(std::vector<double, std::allocator<double>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void print_array (vector<double> array, string name = "") {
    if (name != "") {
        cout<<name<<": ";
    }
    for (auto a : array) {
        cout<<a<<" ";
    }
    cout<<endl; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x6099(%rip), %rsi      # 0xa285
movq %r14, %rdi
callq 0x49a0
testb %al, %al
je 0x4216
movq 0xadc9(%rip), %rdi      # 0xefc8
movq %r14, %rsi
callq 0x2140
leaq 0x6075(%rip), %rsi      # 0xa283
movq %rax, %rdi
callq 0x2160
movq (%rbx), %r15
movq 0x8(%rbx), %r12
movq 0xada4(%rip), %rbx      # 0xefc8
leaq 0x6059(%rip), %r14      # 0xa284
cmpq %r12, %r15
je 0x424e
movsd (%r15), %xmm0
movq %rbx, %rdi
callq 0x21d0
movq %rax, %rdi
movq %r14, %rsi
callq 0x2160
addq $0x8, %r15
jmp 0x422b
movq 0xad73(%rip), %rdi      # 0xefc8
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/Eshaancoding[P]AutoDiff/src/Variable/grad.cpp
// Function: Variable::dir_eval(double, op, double, bool)
double Variable::dir_eval (double x, op operation, double y, bool respect_x) {
    if (operation == op::add) return 1;
    if (operation == op::multiply) return y;
    if (operation == op::min) return 1;
    if (operation == op::max) return 1;
    if (operation == op::clip) return 1; 
    if (operation == op::sin_d_op) return d_to_r(cos(r_to_d(x))); 
    if (operation == op::sin_r_op) return cos(x);
    if (operation == op::cos_d_op) return d_to_r(-sin(r_to_d(x)));
    if (operation == op::cos_r_op) return -sin(x); 
    if (respect_x) {
        if (operation == op::subtract) return 1;
        if (operation == op::divide) return 1 / y;
        if (operation == op::exponent) return y * pow(x, y - 1);
    } else {
        if (operation == op::subtract) return -1;
        if (operation == op::divide) return (-y) / pow(x,2);
        if (operation == op::exponent) return pow(y,x)*log10(y);
    }
    cout<<"ERROR OPERATION: "<<operation<<endl; 
    throw invalid_argument("operation not valid when running dir_eval()");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movapd %xmm1, %xmm3
movl %esi, %ebx
movapd %xmm0, %xmm2
movsd 0x5f75(%rip), %xmm0     # 0xa210
leal -0x2(%rbx), %eax
cmpl $0xc, %eax
ja 0x431a
leaq 0x5f96(%rip), %rcx      # 0xa240
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movapd %xmm3, %xmm0
jmp 0x4311
mulsd 0x5f47(%rip), %xmm2     # 0xa208
movapd %xmm2, %xmm0
callq 0x2050
mulsd 0x5f46(%rip), %xmm0     # 0xa218
jmp 0x4311
movapd %xmm2, %xmm0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x2250
movapd %xmm2, %xmm0
callq 0x2050
xorpd 0x5f3a(%rip), %xmm0     # 0xa230
jmp 0x4311
mulsd 0x5f08(%rip), %xmm2     # 0xa208
movapd %xmm2, %xmm0
callq 0x2250
mulsd 0x5e4f(%rip), %xmm0     # 0xa160
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
testb %dl, %dl
je 0x433f
cmpl $0x3, %ebx
je 0x4311
cmpl $0x6, %ebx
je 0x4363
cmpl $0x4, %ebx
jne 0x43bc
movsd 0x5ed7(%rip), %xmm0     # 0xa210
divsd %xmm3, %xmm0
jmp 0x4311
cmpl $0x3, %ebx
je 0x43af
cmpl $0x6, %ebx
je 0x4384
cmpl $0x4, %ebx
jne 0x43bc
xorpd 0x5eda(%rip), %xmm3     # 0xa230
mulsd %xmm2, %xmm2
divsd %xmm2, %xmm3
jmp 0x42b3
movsd 0x5eb5(%rip), %xmm1     # 0xa220
addsd %xmm3, %xmm1
movapd %xmm2, %xmm0
movapd %xmm3, -0x20(%rbp)
callq 0x2220
mulsd -0x20(%rbp), %xmm0
jmp 0x4311
movapd %xmm3, %xmm0
movapd %xmm2, %xmm1
movapd %xmm3, -0x20(%rbp)
callq 0x2220
movsd %xmm0, -0x28(%rbp)
movapd -0x20(%rbp), %xmm0
callq 0x20d0
mulsd -0x28(%rbp), %xmm0
jmp 0x4311
movsd 0x5e69(%rip), %xmm0     # 0xa220
jmp 0x4311
movq 0xac05(%rip), %rdi      # 0xefc8
leaq 0x5eaa(%rip), %rsi      # 0xa274
callq 0x2160
movq %rax, %rdi
movl %ebx, %esi
callq 0x2200
movq %rax, %rdi
callq 0x20b0
pushq $0x10
popq %rdi
callq 0x20c0
movq %rax, %rbx
leaq 0x5e93(%rip), %rsi      # 0xa286
movq %rax, %rdi
callq 0x2260
movq 0xabde(%rip), %rsi      # 0xefe0
movq 0xabc7(%rip), %rdx      # 0xefd0
movq %rbx, %rdi
callq 0x21f0
movq %rax, %r14
movq %rbx, %rdi
callq 0x2110
movq %r14, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O2/Eshaancoding[P]AutoDiff/src/Variable/operations/add.cpp
// Function: operator+(Variable const&, Variable const&)
Variable operator+ (const Variable &left, const Variable &right) {
    Variable new_var = Variable(false);
    new_var.operation = op::add;
    new_var.child[0] = new Variable();
    new_var.child[1] = new Variable();
    *(new_var.child[0]) = left;
    *(new_var.child[1]) = right;
    return new_var;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
pushq $0x1
popq %r13
xorps %xmm0, %xmm0
movl %r13d, %esi
callq 0x3bbc
movl $0x2, 0x8(%rbx)
pushq $0x30
popq %rdi
callq 0x2170
movq %rax, %r12
xorps %xmm0, %xmm0
movq %rax, %rdi
movl %r13d, %esi
callq 0x3bbc
movq %r12, 0x10(%rbx)
pushq $0x30
popq %rdi
callq 0x2170
movq %rax, %r12
pushq $0x1
popq %rsi
xorps %xmm0, %xmm0
movq %rax, %rdi
callq 0x3bbc
movq %r12, 0x18(%rbx)
movq 0x10(%rbx), %rax
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups 0x20(%r15), %xmm2
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movq 0x18(%rbx), %rax
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm1, 0x10(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm0, (%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4c91
movq %rax, %rbx
movq %r12, %rdi
callq 0x2150
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O2/Eshaancoding[P]AutoDiff/src/Variable/operations/add.cpp
// Function: operator+(Variable const&, Variable&)
Variable operator+ (const Variable &left, Variable &right) {
    Variable new_var = Variable(false);
    new_var.operation = op::add;
    new_var.child[0] = new Variable();
    *(new_var.child[0]) = left;
    new_var.child[1] = &right;
    return new_var;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
pushq $0x1
popq %r13
xorps %xmm0, %xmm0
movl %r13d, %esi
callq 0x3bbc
movl $0x2, 0x8(%r14)
pushq $0x30
popq %rdi
callq 0x2170
movq %rax, %r12
xorps %xmm0, %xmm0
movq %rax, %rdi
movl %r13d, %esi
callq 0x3bbc
movq %r12, 0x10(%r14)
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups 0x20(%r15), %xmm2
movups %xmm2, 0x20(%r12)
movups %xmm1, 0x10(%r12)
movups %xmm0, (%r12)
movq %rbx, 0x18(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r12, %rdi
callq 0x2150
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O2/Eshaancoding[P]AutoDiff/src/Variable/operations/add.cpp
// Function: operator+(Variable const&, double const&)
Variable operator+ (const Variable &left, const double &right) {
    Variable new_var = Variable(false);
    new_var.operation = op::add;
    new_var.child[0] = new Variable();
    *(new_var.child[0]) = left;
    
    new_var.child[1] = new Variable(false);
    new_var.child[1]->value = right;
    new_var.child[1]->operation = op::argument;    
    return new_var;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
pushq $0x1
popq %r13
xorps %xmm0, %xmm0
movl %r13d, %esi
callq 0x3bbc
movl $0x2, 0x8(%rbx)
pushq $0x30
popq %rdi
callq 0x2170
movq %rax, %r15
xorps %xmm0, %xmm0
movq %rax, %rdi
movl %r13d, %esi
callq 0x3bbc
movq %r15, 0x10(%rbx)
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups 0x20(%r12), %xmm2
movups %xmm2, 0x20(%r15)
movups %xmm1, 0x10(%r15)
movups %xmm0, (%r15)
pushq $0x30
popq %rdi
callq 0x2170
movq %rax, %r15
pushq $0x1
popq %rsi
xorps %xmm0, %xmm0
movq %rax, %rdi
callq 0x3bbc
movq %r15, 0x18(%rbx)
movsd (%r14), %xmm0
movsd %xmm0, (%r15)
movl $0x1, 0x8(%r15)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4de3
movq %rax, %rbx
movq %r15, %rdi
callq 0x2150
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O2/Eshaancoding[P]AutoDiff/src/Variable/operations/add.cpp
// Function: operator+(Variable&, Variable const&)
Variable operator+ (Variable &left, const Variable &right) {
    Variable new_var = Variable(false); 
    new_var.operation = op::add;
    new_var.child[0] = &left;
    new_var.child[1] = new Variable();
    *(new_var.child[1]) = right;
    return new_var;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
pushq $0x1
popq %r12
xorps %xmm0, %xmm0
movl %r12d, %esi
callq 0x3bbc
movl $0x2, 0x8(%rbx)
movq %r15, 0x10(%rbx)
pushq $0x30
popq %rdi
callq 0x2170
movq %rax, %r15
xorps %xmm0, %xmm0
movq %rax, %rdi
movl %r12d, %esi
callq 0x3bbc
movq %r15, 0x18(%rbx)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm2, 0x20(%r15)
movups %xmm1, 0x10(%r15)
movups %xmm0, (%r15)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x2150
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O2/Eshaancoding[P]AutoDiff/src/Variable/operations/add.cpp
// Function: operator+(Variable&, Variable&)
Variable operator+ (Variable &left, Variable &right) {
    Variable new_var = Variable(false);
    new_var.operation = op::add;
    new_var.child[0] = &left; 
    new_var.child[1] = &right;
    return new_var;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x1
popq %rsi
xorps %xmm0, %xmm0
callq 0x3bbc
movl $0x2, 0x8(%r15)
movq %r14, 0x10(%r15)
movq %rbx, 0x18(%r15)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Eshaancoding[P]AutoDiff/src/Variable/operations/add.cpp
// Function: operator+(Variable&, double const&)
Variable operator+ (Variable &left, const double &right) {
    Variable new_var = Variable(false);
    new_var.operation = op::add;
    new_var.child[0] = &left;
    new_var.child[1] = new Variable(false);
    new_var.child[1]->value = right;
    new_var.child[1]->operation = op::argument;
    
    return new_var;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
pushq $0x1
popq %r12
xorps %xmm0, %xmm0
movl %r12d, %esi
callq 0x3bbc
movl $0x2, 0x8(%rbx)
movq %r15, 0x10(%rbx)
pushq $0x30
popq %rdi
callq 0x2170
movq %rax, %r15
xorps %xmm0, %xmm0
movq %rax, %rdi
movl %r12d, %esi
callq 0x3bbc
movq %r15, 0x18(%rbx)
movsd (%r14), %xmm0
movsd %xmm0, (%r15)
movl $0x1, 0x8(%r15)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x2150
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O2/Eshaancoding[P]AutoDiff/src/Variable/operations/add.cpp
// Function: operator+(double const&, Variable const&)
Variable operator+ (const double &left, const Variable &right) {
    Variable new_var = Variable(false);
    new_var.operation = op::add;
    new_var.child[0] = new Variable(false);
    new_var.child[0]->value = left;
    new_var.child[0]->operation = op::argument;
    new_var.child[1] = new Variable();
    *(new_var.child[1]) = right; 
    return new_var;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
pushq $0x1
popq %r13
xorps %xmm0, %xmm0
movl %r13d, %esi
callq 0x3bbc
movl $0x2, 0x8(%rbx)
pushq $0x30
popq %rdi
callq 0x2170
movq %rax, %r15
xorps %xmm0, %xmm0
movq %rax, %rdi
movl %r13d, %esi
callq 0x3bbc
movq %r15, 0x10(%rbx)
movsd (%r12), %xmm0
movsd %xmm0, (%r15)
movl $0x1, 0x8(%r15)
pushq $0x30
popq %rdi
callq 0x2170
movq %rax, %r15
pushq $0x1
popq %rsi
xorps %xmm0, %xmm0
movq %rax, %rdi
callq 0x3bbc
movq %r15, 0x18(%rbx)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm2, 0x20(%r15)
movups %xmm1, 0x10(%r15)
movups %xmm0, (%r15)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4fde
movq %rax, %rbx
movq %r15, %rdi
callq 0x2150
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O2/Eshaancoding[P]AutoDiff/src/Variable/operations/add.cpp
// Function: operator+(double const&, Variable&)
Variable operator+ (const double &left, Variable &right) {
    Variable new_var = Variable(false); 
    new_var.operation = op::add; 
    new_var.child[0] = new Variable(false);
    new_var.child[0]->operation = op::argument;
    new_var.child[0]->value = left;
    new_var.child[1] = &right;
    return new_var;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
pushq $0x1
popq %r13
xorps %xmm0, %xmm0
movl %r13d, %esi
callq 0x3bbc
movl $0x2, 0x8(%r14)
pushq $0x30
popq %rdi
callq 0x2170
movq %rax, %r12
xorps %xmm0, %xmm0
movq %rax, %rdi
movl %r13d, %esi
callq 0x3bbc
movq %r12, 0x10(%r14)
movl $0x1, 0x8(%r12)
movsd (%r15), %xmm0
movsd %xmm0, (%r12)
movq %rbx, 0x18(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r12, %rdi
callq 0x2150
movq %rbx, %rdi
callq 0x2230
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/Eshaancoding[P]AutoDiff/src/Variable/operations/clip.cpp
// Function: Variable::clip(Variable const&, Variable const&)
Variable Variable::clip (const Variable &left, const Variable &right) {
    Variable new_var = Variable();
    new_var.arg = new Variable(); 
    new_var.arg->value = this->value;
    new_var.operation = op::clip;
    new_var.child[0] = new Variable();
    *(new_var.child[0]) = left;
    new_var.child[1] = new Variable();
    *(new_var.child[1]) = right;
    return new_var;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
pushq $0x1
popq %rsi
xorps %xmm0, %xmm0
callq 0x3bbc
pushq $0x30
popq %rdi
callq 0x2170
movq %rax, %r15
xorps %xmm0, %xmm0
movq %rax, %rdi
pushq $0x1
popq %rsi
callq 0x3bbc
movq %r15, 0x28(%rbx)
movsd (%r13), %xmm0
movsd %xmm0, (%r15)
movl $0xa, 0x8(%rbx)
pushq $0x30
popq %rdi
callq 0x2170
movq %rax, %r15
pushq $0x1
popq %rsi
xorps %xmm0, %xmm0
movq %rax, %rdi
callq 0x3bbc
movq %r15, 0x10(%rbx)
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups 0x20(%r12), %xmm2
movups %xmm2, 0x20(%r15)
movups %xmm1, 0x10(%r15)
movups %xmm0, (%r15)
pushq $0x30
popq %rdi
callq 0x2170
movq %rax, %r15
pushq $0x1
popq %rsi
xorps %xmm0, %xmm0
movq %rax, %rdi
callq 0x3bbc
movq %r15, 0x18(%rbx)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm2, 0x20(%r15)
movups %xmm1, 0x10(%r15)
movups %xmm0, (%r15)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x515b
jmp 0x515b
movq %rax, %rbx
movq %r15, %rdi
callq 0x2150
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O2/Eshaancoding[P]AutoDiff/src/Variable/operations/clip.cpp
// Function: Variable::clip(Variable const&, Variable&)
Variable Variable::clip (const Variable &left, Variable &right) {
    Variable new_var = Variable();
    new_var.arg = new Variable(); 
    new_var.arg->value = this->value;
    new_var.operation = op::clip;
    new_var.child[0] = new Variable(); 
    *(new_var.child[0]) = left;
    new_var.child[1] = &right;
    return new_var;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, -0x30(%rbp)
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %r14
pushq $0x1
popq %rbx
xorps %xmm0, %xmm0
movl %ebx, %esi
callq 0x3bbc
pushq $0x30
popq %rdi
callq 0x2170
movq %rax, %r12
xorps %xmm0, %xmm0
movq %rax, %rdi
movl %ebx, %esi
callq 0x3bbc
movq %r12, 0x28(%r14)
movsd (%r13), %xmm0
movsd %xmm0, (%r12)
movl $0xa, 0x8(%r14)
pushq $0x30
popq %rdi
callq 0x2170
movq %rax, %r12
pushq $0x1
popq %rsi
xorps %xmm0, %xmm0
movq %rax, %rdi
callq 0x3bbc
movq %r12, 0x10(%r14)
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups 0x20(%r15), %xmm2
movups %xmm2, 0x20(%r12)
movups %xmm1, 0x10(%r12)
movups %xmm0, (%r12)
movq -0x30(%rbp), %rax
movq %rax, 0x18(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x521e
movq %rax, %rbx
movq %r12, %rdi
callq 0x2150
movq %rbx, %rdi
callq 0x2230
nop
// File: /workspace/github_cpp_makefile_star2_O2/Eshaancoding[P]AutoDiff/src/Variable/operations/clip.cpp
// Function: Variable::clip(Variable const&, double const&)
Variable Variable::clip (const Variable &left, const double &right) {
    Variable new_var = Variable();
    new_var.arg = new Variable(); 
    new_var.arg->value = this->value;
    new_var.operation = op::clip;
    new_var.child[0] = new Variable();
    *(new_var.child[0]) = left;
    new_var.child[1] = new Variable();
    new_var.child[1]->operation = op::argument;
    new_var.child[1]->value = right;
    return new_var;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, -0x30(%rbp)
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
pushq $0x1
popq %rbx
xorps %xmm0, %xmm0
movl %ebx, %esi
callq 0x3bbc
pushq $0x30
popq %rdi
callq 0x2170
movq %rax, %r15
xorps %xmm0, %xmm0
movq %rax, %rdi
movl %ebx, %esi
callq 0x3bbc
movq %r15, 0x28(%r14)
movsd (%r13), %xmm0
movsd %xmm0, (%r15)
movl $0xa, 0x8(%r14)
pushq $0x30
popq %rdi
callq 0x2170
movq %rax, %r15
pushq $0x1
popq %rsi
xorps %xmm0, %xmm0
movq %rax, %rdi
callq 0x3bbc
movq %r15, 0x10(%r14)
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups 0x20(%r12), %xmm2
movups %xmm2, 0x20(%r15)
movups %xmm1, 0x10(%r15)
movups %xmm0, (%r15)
pushq $0x30
popq %rdi
callq 0x2170
movq %rax, %r15
pushq $0x1
popq %rsi
xorps %xmm0, %xmm0
movq %rax, %rdi
callq 0x3bbc
movq %r15, 0x18(%r14)
movl $0x1, 0x8(%r15)
movq -0x30(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, (%r15)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x530d
jmp 0x530d
movq %rax, %rbx
movq %r15, %rdi
callq 0x2150
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O2/Eshaancoding[P]AutoDiff/src/Variable/operations/clip.cpp
// Function: Variable::clip(Variable&, Variable const&)
Variable Variable::clip (Variable &left, const Variable &right) {
    Variable new_var = Variable();
    new_var.arg = new Variable(); 
    new_var.arg->value = this->value;
    new_var.operation = op::clip;
    new_var.child[0] = &left;
    new_var.child[1] = new Variable(); 
    *(new_var.child[1]) = right;
    return new_var;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, -0x30(%rbp)
movq %rsi, %r13
movq %rdi, %rbx
pushq $0x1
popq %r12
xorps %xmm0, %xmm0
movl %r12d, %esi
callq 0x3bbc
pushq $0x30
popq %rdi
callq 0x2170
movq %rax, %r15
xorps %xmm0, %xmm0
movq %rax, %rdi
movl %r12d, %esi
callq 0x3bbc
movq %r15, 0x28(%rbx)
movsd (%r13), %xmm0
movsd %xmm0, (%r15)
movl $0xa, 0x8(%rbx)
movq -0x30(%rbp), %rax
movq %rax, 0x10(%rbx)
pushq $0x30
popq %rdi
callq 0x2170
movq %rax, %r15
pushq $0x1
popq %rsi
xorps %xmm0, %xmm0
movq %rax, %rdi
callq 0x3bbc
movq %r15, 0x18(%rbx)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm2, 0x20(%r15)
movups %xmm1, 0x10(%r15)
movups %xmm0, (%r15)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x53ce
movq %rax, %rbx
movq %r15, %rdi
callq 0x2150
movq %rbx, %rdi
callq 0x2230
nop
// File: /workspace/github_cpp_makefile_star2_O2/Eshaancoding[P]AutoDiff/src/Variable/operations/clip.cpp
// Function: Variable::clip(Variable&, Variable&)
Variable Variable::clip (Variable &left, Variable &right) {
    Variable new_var = Variable();
    new_var.arg = new Variable(); 
    new_var.arg->value = this->value;
    new_var.operation = op::clip;
    new_var.child[0] = &left;
    new_var.child[1] = &right;
    return new_var;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, -0x30(%rbp)
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
pushq $0x1
popq %rbx
xorps %xmm0, %xmm0
movl %ebx, %esi
callq 0x3bbc
pushq $0x30
popq %rdi
callq 0x2170
movq %rax, %r13
xorps %xmm0, %xmm0
movq %rax, %rdi
movl %ebx, %esi
callq 0x3bbc
movq %r13, 0x28(%r15)
movsd (%r12), %xmm0
movsd %xmm0, (%r13)
movl $0xa, 0x8(%r15)
movq %r14, 0x10(%r15)
movq -0x30(%rbp), %rax
movq %rax, 0x18(%r15)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r13, %rdi
callq 0x2150
movq %rbx, %rdi
callq 0x2230
nop
// File: /workspace/github_cpp_makefile_star2_O2/Eshaancoding[P]AutoDiff/src/Variable/operations/clip.cpp
// Function: Variable::clip(Variable&, double const&)
Variable Variable::clip (Variable &left, const double &right) {
    Variable new_var = Variable();
    new_var.arg = new Variable(); 
    new_var.arg->value = this->value;
    new_var.operation = op::clip;
    new_var.child[0] = &left;
    new_var.child[1] = new Variable();
    new_var.child[1]->operation = op::argument;
    new_var.child[1]->value = right;
    return new_var;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, -0x30(%rbp)
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
pushq $0x1
popq %rbx
xorps %xmm0, %xmm0
movl %ebx, %esi
callq 0x3bbc
pushq $0x30
popq %rdi
callq 0x2170
movq %rax, %r15
xorps %xmm0, %xmm0
movq %rax, %rdi
movl %ebx, %esi
callq 0x3bbc
movq %r15, 0x28(%r14)
movsd (%r13), %xmm0
movsd %xmm0, (%r15)
movl $0xa, 0x8(%r14)
movq %r12, 0x10(%r14)
pushq $0x30
popq %rdi
callq 0x2170
movq %rax, %r15
pushq $0x1
popq %rsi
xorps %xmm0, %xmm0
movq %rax, %rdi
callq 0x3bbc
movq %r15, 0x18(%r14)
movl $0x1, 0x8(%r15)
movq -0x30(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, (%r15)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x550d
movq %rax, %rbx
movq %r15, %rdi
callq 0x2150
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O2/Eshaancoding[P]AutoDiff/src/Variable/operations/clip.cpp
// Function: Variable::clip(double const&, Variable const&)
Variable Variable::clip (const double &left, const Variable &right) {
    Variable new_var = Variable();
    new_var.arg = new Variable(); 
    new_var.arg->value = this->value;
    new_var.operation = op::clip;
    new_var.child[0] = new Variable();
    new_var.child[0]->value = left;
    new_var.child[0]->operation = op::argument;
    new_var.child[1] = new Variable();
    *(new_var.child[1]) = right;
    return new_var;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, -0x30(%rbp)
movq %rsi, %r13
movq %rdi, %rbx
pushq $0x1
popq %r12
xorps %xmm0, %xmm0
movl %r12d, %esi
callq 0x3bbc
pushq $0x30
popq %rdi
callq 0x2170
movq %rax, %r15
xorps %xmm0, %xmm0
movq %rax, %rdi
movl %r12d, %esi
callq 0x3bbc
movq %r15, 0x28(%rbx)
movsd (%r13), %xmm0
movsd %xmm0, (%r15)
movl $0xa, 0x8(%rbx)
pushq $0x30
popq %rdi
callq 0x2170
movq %rax, %r15
pushq $0x1
popq %rsi
xorps %xmm0, %xmm0
movq %rax, %rdi
callq 0x3bbc
movq %r15, 0x10(%rbx)
movq -0x30(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, (%r15)
movl $0x1, 0x8(%r15)
pushq $0x30
popq %rdi
callq 0x2170
movq %rax, %r15
pushq $0x1
popq %rsi
xorps %xmm0, %xmm0
movq %rax, %rdi
callq 0x3bbc
movq %r15, 0x18(%rbx)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm2, 0x20(%r15)
movups %xmm1, 0x10(%r15)
movups %xmm0, (%r15)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x55fa
jmp 0x55fa
movq %rax, %rbx
movq %r15, %rdi
callq 0x2150
movq %rbx, %rdi
callq 0x2230
nop
// File: /workspace/github_cpp_makefile_star2_O2/Eshaancoding[P]AutoDiff/src/Variable/operations/divide.cpp
// Function: operator/(double const&, Variable const&)
Variable operator/ (const double &left, const Variable &right) {
    Variable new_var = Variable(false);
    new_var.operation = op::divide;
    new_var.child[0] = new Variable(false);
    new_var.child[0]->value = left;
    new_var.child[0]->operation = op::argument;
    new_var.child[1] = new Variable();
    *(new_var.child[1]) = right; 
    return new_var;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
pushq $0x1
popq %r13
xorps %xmm0, %xmm0
movl %r13d, %esi
callq 0x3bbc
movl $0x4, 0x8(%rbx)
pushq $0x30
popq %rdi
callq 0x2170
movq %rax, %r15
xorps %xmm0, %xmm0
movq %rax, %rdi
movl %r13d, %esi
callq 0x3bbc
movq %r15, 0x10(%rbx)
movsd (%r12), %xmm0
movsd %xmm0, (%r15)
movl $0x1, 0x8(%r15)
pushq $0x30
popq %rdi
callq 0x2170
movq %rax, %r15
pushq $0x1
popq %rsi
xorps %xmm0, %xmm0
movq %rax, %rdi
callq 0x3bbc
movq %r15, 0x18(%rbx)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm2, 0x20(%r15)
movups %xmm1, 0x10(%r15)
movups %xmm0, (%r15)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5aca
movq %rax, %rbx
movq %r15, %rdi
callq 0x2150
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O2/Eshaancoding[P]AutoDiff/src/Vector/eval.cpp
// Function: Vector::eval()
Vector Vector::eval () {
    Vector new_vec = Vector(this->width);
    for (int i = 0; i < this->width; i++) {
        new_vec.array[i].value = this->array[i].eval();
        new_vec.array[i].operation = op::argument;
    }
    return new_vec;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl 0x8(%rdi), %esi
leaq -0x30(%rbp), %rdi
callq 0x7294
xorl %r15d, %r15d
pushq $0x1
popq %r14
xorl %r12d, %r12d
movslq 0x8(%rbx), %rax
cmpq %rax, %r12
jge 0x737b
movq (%rbx), %rdi
addq %r15, %rdi
movl %r14d, %esi
callq 0x3ce4
movq -0x30(%rbp), %rax
movsd %xmm0, (%rax,%r15)
movl $0x1, 0x8(%rax,%r15)
incq %r12
addq $0x30, %r15
jmp 0x7348
movq -0x30(%rbp), %rax
movl -0x28(%rbp), %edx
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Eshaancoding[P]AutoDiff/src/Vector/operations/add.cpp
// Function: operator+(Vector const&, Vector const&)
Vector operator+ (const Vector &left, const Vector &right) {
    if (left.width != right.width) throw invalid_argument("Width is not compatable."); 
    Vector new_vec = Vector(left.width);
    for (int i = 0; i < left.width; i++) {
        Vector *l = new Vector(right.width);
        Vector *r = new Vector(left.width); 
        *l = left;
        *r = right;
        new_vec.array[i] = l->array[i] + r->array[i]; 
    }
    return new_vec;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rax
movl 0x8(%rdi), %esi
movq %rax, -0x30(%rbp)
cmpl 0x8(%rax), %esi
jne 0x77be
movq %rdi, %rbx
leaq -0x40(%rbp), %rdi
callq 0x7294
xorl %r15d, %r15d
pushq $0x10
popq %r12
xorl %r14d, %r14d
movslq 0x8(%rbx), %rax
cmpq %rax, %r14
jge 0x77a8
movq %r12, %rdi
callq 0x2170
movq %rax, %r13
movq -0x30(%rbp), %rax
movl 0x8(%rax), %esi
movq %r13, %rdi
callq 0x7294
movq %r12, %rdi
callq 0x2170
movq %rax, %r12
movl 0x8(%rbx), %esi
movq %rax, %rdi
callq 0x7294
movl 0x8(%rbx), %eax
movl %eax, 0x8(%r13)
movq (%rbx), %rax
movq %rax, (%r13)
movq -0x30(%rbp), %rcx
movl 0x8(%rcx), %eax
movl %eax, 0x8(%r12)
movq (%rcx), %rax
movq %rax, (%r12)
movq (%r13), %rsi
addq %r15, %rsi
movq (%r12), %rdx
addq %r15, %rdx
leaq -0x70(%rbp), %rdi
callq 0x4e7c
movq -0x40(%rbp), %rax
movups -0x70(%rbp), %xmm0
movups -0x60(%rbp), %xmm1
movups -0x50(%rbp), %xmm2
movups %xmm2, 0x20(%rax,%r15)
movups %xmm1, 0x10(%rax,%r15)
movups %xmm0, (%rax,%r15)
incq %r14
addq $0x30, %r15
pushq $0x10
popq %r12
jmp 0x7702
movq -0x40(%rbp), %rax
movl -0x38(%rbp), %edx
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x20c0
movq %rax, %r14
leaq 0x2b18(%rip), %rsi      # 0xa2e8
movq %rax, %rdi
callq 0x2260
movq 0x7801(%rip), %rsi      # 0xefe0
movq 0x77ea(%rip), %rdx      # 0xefd0
movq %r14, %rdi
callq 0x21f0
movq %rax, %rbx
movq %r14, %rdi
callq 0x2110
jmp 0x780e
movq %rax, %rbx
movq %r12, %rdi
jmp 0x7809
movq %rax, %rbx
movq %r13, %rdi
callq 0x2150
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O2/Eshaancoding[P]AutoDiff/src/Vector/operations/add.cpp
// Function: operator+(Vector const&, Vector&)
Vector operator+ (const Vector &left, Vector &right) {
    if (left.width != right.width) throw invalid_argument("Width is not compatable."); 
    Vector new_vec = Vector(left.width);
    for (int i = 0; i < left.width; i++) {
        Vector *l = new Vector(right.width);
        *l = left;
        new_vec.array[i] = l->array[i] + right.array[i]; 
    }
    return new_vec;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movl 0x8(%rdi), %esi
cmpl 0x8(%rbx), %esi
jne 0x78cc
movq %rdi, %r14
leaq -0x38(%rbp), %rdi
callq 0x7294
xorl %r15d, %r15d
xorl %r12d, %r12d
movslq 0x8(%r14), %rax
cmpq %rax, %r12
jge 0x78b6
pushq $0x10
popq %rdi
callq 0x2170
movq %rax, %r13
movl 0x8(%rbx), %esi
movq %rax, %rdi
callq 0x7294
movl 0x8(%r14), %eax
movl %eax, 0x8(%r13)
movq (%r14), %rax
movq %rax, (%r13)
movq (%r13), %rsi
addq %r15, %rsi
movq (%rbx), %rdx
addq %r15, %rdx
leaq -0x68(%rbp), %rdi
callq 0x4e7c
movq -0x38(%rbp), %rax
movups -0x68(%rbp), %xmm0
movups -0x58(%rbp), %xmm1
movups -0x48(%rbp), %xmm2
movups %xmm2, 0x20(%rax,%r15)
movups %xmm1, 0x10(%rax,%r15)
movups %xmm0, (%rax,%r15)
incq %r12
addq $0x30, %r15
jmp 0x7848
movq -0x38(%rbp), %rax
movl -0x30(%rbp), %edx
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x20c0
movq %rax, %rbx
leaq 0x2a0a(%rip), %rsi      # 0xa2e8
movq %rax, %rdi
callq 0x2260
movq 0x76f3(%rip), %rsi      # 0xefe0
movq 0x76dc(%rip), %rdx      # 0xefd0
movq %rbx, %rdi
callq 0x21f0
movq %rax, %r14
movq %rbx, %rdi
callq 0x2110
jmp 0x7914
movq %rax, %r14
movq %r13, %rdi
callq 0x2150
movq %r14, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O2/Eshaancoding[P]AutoDiff/src/Vector/operations/add.cpp
// Function: operator+(Vector const&, double const&)
Vector operator+ (const Vector &left, const double &right) {
    Vector new_vec = Vector(left.width);
    for (int i = 0; i < left.width; i++) {
        Vector *l = new Vector(left.width);
        *l = left;
        new_vec.array[i] = l->array[i] + right; 
    }
    return new_vec;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, %r14
movl 0x8(%rdi), %esi
leaq -0x40(%rbp), %rdi
callq 0x7294
xorl %r12d, %r12d
xorl %ebx, %ebx
movslq 0x8(%r14), %r15
cmpq %r15, %rbx
jge 0x79b1
pushq $0x10
popq %rdi
callq 0x2170
movq %rax, %r13
movq %rax, %rdi
movl %r15d, %esi
callq 0x7294
movl 0x8(%r14), %eax
movl %eax, 0x8(%r13)
movq (%r14), %rax
movq %rax, (%r13)
movq (%r13), %rsi
addq %r12, %rsi
leaq -0x70(%rbp), %rdi
movq -0x30(%rbp), %rdx
callq 0x4eb8
movq -0x40(%rbp), %rax
movups -0x70(%rbp), %xmm0
movups -0x60(%rbp), %xmm1
movups -0x50(%rbp), %xmm2
movups %xmm2, 0x20(%rax,%r12)
movups %xmm1, 0x10(%rax,%r12)
movups %xmm0, (%rax,%r12)
incq %rbx
addq $0x30, %r12
jmp 0x7945
movq -0x40(%rbp), %rax
movl -0x38(%rbp), %edx
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r13, %rdi
callq 0x2150
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O2/Eshaancoding[P]AutoDiff/src/Vector/operations/add.cpp
// Function: operator+(Vector&, Vector const&)
Vector operator+ (Vector &left, const Vector &right) {
    if (left.width != right.width) throw invalid_argument("Width is not compatable."); 
    Vector new_vec = Vector(left.width);
    for (int i = 0; i < left.width; i++) {
        Vector *r = new Vector(right.width);
        *r = right;
        new_vec.array[i] = left.array[i] + r->array[i]; 
    }
    return new_vec;   
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movl 0x8(%rdi), %esi
cmpl 0x8(%rbx), %esi
jne 0x7a8f
movq %rdi, %r14
leaq -0x38(%rbp), %rdi
callq 0x7294
xorl %r15d, %r15d
xorl %r12d, %r12d
movslq 0x8(%r14), %rax
cmpq %rax, %r12
jge 0x7a79
pushq $0x10
popq %rdi
callq 0x2170
movq %rax, %r13
movl 0x8(%rbx), %esi
movq %rax, %rdi
callq 0x7294
movl 0x8(%rbx), %eax
movl %eax, 0x8(%r13)
movq (%rbx), %rax
movq %rax, (%r13)
movq (%r14), %rsi
addq %r15, %rsi
movq (%r13), %rdx
addq %r15, %rdx
leaq -0x68(%rbp), %rdi
callq 0x4e7c
movq -0x38(%rbp), %rax
movups -0x68(%rbp), %xmm0
movups -0x58(%rbp), %xmm1
movups -0x48(%rbp), %xmm2
movups %xmm2, 0x20(%rax,%r15)
movups %xmm1, 0x10(%rax,%r15)
movups %xmm0, (%rax,%r15)
incq %r12
addq $0x30, %r15
jmp 0x7a0c
movq -0x38(%rbp), %rax
movl -0x30(%rbp), %edx
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x20c0
movq %rax, %rbx
leaq 0x2847(%rip), %rsi      # 0xa2e8
movq %rax, %rdi
callq 0x2260
movq 0x7530(%rip), %rsi      # 0xefe0
movq 0x7519(%rip), %rdx      # 0xefd0
movq %rbx, %rdi
callq 0x21f0
movq %rax, %r14
movq %rbx, %rdi
callq 0x2110
jmp 0x7ad7
movq %rax, %r14
movq %r13, %rdi
callq 0x2150
movq %r14, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O2/Eshaancoding[P]AutoDiff/src/Vector/operations/add.cpp
// Function: operator+(Vector&, Vector&)
Vector operator+ (Vector &left, Vector &right) {
    if (left.width != right.width) throw invalid_argument("Width is not compatable."); 
    Vector new_vec = Vector(left.width);
    for (int i = 0; i < left.width; i++) {
        new_vec.array[i] = left.array[i] + right.array[i]; 
    }
    return new_vec;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movl 0x8(%rdi), %esi
cmpl 0x8(%rbx), %esi
jne 0x7b6e
movq %rdi, %r14
leaq -0x38(%rbp), %rdi
callq 0x7294
xorl %r12d, %r12d
leaq -0x68(%rbp), %r15
xorl %r13d, %r13d
movslq 0x8(%r14), %rax
cmpq %rax, %r13
jge 0x7b58
movq (%r14), %rsi
addq %r12, %rsi
movq (%rbx), %rdx
addq %r12, %rdx
movq %r15, %rdi
callq 0x4e7c
movq -0x38(%rbp), %rax
movups -0x68(%rbp), %xmm0
movups -0x58(%rbp), %xmm1
movups -0x48(%rbp), %xmm2
movups %xmm2, 0x20(%rax,%r12)
movups %xmm1, 0x10(%rax,%r12)
movups %xmm0, (%rax,%r12)
incq %r13
addq $0x30, %r12
jmp 0x7b11
movq -0x38(%rbp), %rax
movl -0x30(%rbp), %edx
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x20c0
movq %rax, %rbx
leaq 0x2768(%rip), %rsi      # 0xa2e8
movq %rax, %rdi
callq 0x2260
movq 0x7451(%rip), %rsi      # 0xefe0
movq 0x743a(%rip), %rdx      # 0xefd0
movq %rbx, %rdi
callq 0x21f0
movq %rax, %r14
movq %rbx, %rdi
callq 0x2110
movq %r14, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O2/Eshaancoding[P]AutoDiff/src/Vector/operations/add.cpp
// Function: operator+(Vector&, double const&)
Vector operator+ (Vector &left, const double &right) {
    Vector new_vec = Vector(left.width);
    for (int i = 0; i < left.width; i++) {
        new_vec.array[i] = left.array[i] + right;
    }
    return new_vec;
}

// 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 0x8(%rdi), %esi
leaq -0x38(%rbp), %rdi
callq 0x7294
xorl %r12d, %r12d
leaq -0x68(%rbp), %r15
xorl %r13d, %r13d
movslq 0x8(%r14), %rax
cmpq %rax, %r13
jge 0x7c22
movq (%r14), %rsi
addq %r12, %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x4eb8
movq -0x38(%rbp), %rax
movups -0x68(%rbp), %xmm0
movups -0x58(%rbp), %xmm1
movups -0x48(%rbp), %xmm2
movups %xmm2, 0x20(%rax,%r12)
movups %xmm1, 0x10(%rax,%r12)
movups %xmm0, (%rax,%r12)
incq %r13
addq $0x30, %r12
jmp 0x7bde
movq -0x38(%rbp), %rax
movl -0x30(%rbp), %edx
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Eshaancoding[P]AutoDiff/src/Vector/operations/add.cpp
// Function: operator+(double const&, Vector const&)
Vector operator+ (const double &left, const Vector &right) {
    Vector new_vec = Vector(right.width);
    for (int i = 0; i < right.width; i++) {
        Vector *r = new Vector(right.width);
        *r = right;
        new_vec.array[i] = left + r->array[i]; 
    }
    return new_vec;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, -0x30(%rbp)
movl 0x8(%rsi), %esi
leaq -0x40(%rbp), %rdi
callq 0x7294
xorl %r12d, %r12d
xorl %r14d, %r14d
movslq 0x8(%rbx), %r15
cmpq %r15, %r14
jge 0x7ccd
pushq $0x10
popq %rdi
callq 0x2170
movq %rax, %r13
movq %rax, %rdi
movl %r15d, %esi
callq 0x7294
movl 0x8(%rbx), %eax
movl %eax, 0x8(%r13)
movq (%rbx), %rax
movq %rax, (%r13)
movq (%r13), %rdx
addq %r12, %rdx
leaq -0x70(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x4ff1
movq -0x40(%rbp), %rax
movups -0x70(%rbp), %xmm0
movups -0x60(%rbp), %xmm1
movups -0x50(%rbp), %xmm2
movups %xmm2, 0x20(%rax,%r12)
movups %xmm1, 0x10(%rax,%r12)
movups %xmm0, (%rax,%r12)
incq %r14
addq $0x30, %r12
jmp 0x7c62
movq -0x40(%rbp), %rax
movl -0x38(%rbp), %edx
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r13, %rdi
callq 0x2150
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O2/Eshaancoding[P]AutoDiff/src/Vector/operations/add.cpp
// Function: operator+(double const&, Vector&)
Vector operator+ (const double &left, Vector &right) {
    Vector new_vec = Vector(right.width);
    for (int i = 0; i < right.width; i++) {
        new_vec.array[i] = left + right.array[i]; 
    }
    return new_vec;
}

// 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 0x8(%rsi), %esi
leaq -0x38(%rbp), %rdi
callq 0x7294
xorl %r12d, %r12d
leaq -0x68(%rbp), %r15
xorl %r13d, %r13d
movslq 0x8(%rbx), %rax
cmpq %rax, %r13
jge 0x7d67
movq (%rbx), %rdx
addq %r12, %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x4ff1
movq -0x38(%rbp), %rax
movups -0x68(%rbp), %xmm0
movups -0x58(%rbp), %xmm1
movups -0x48(%rbp), %xmm2
movups %xmm2, 0x20(%rax,%r12)
movups %xmm1, 0x10(%rax,%r12)
movups %xmm0, (%rax,%r12)
incq %r13
addq $0x30, %r12
jmp 0x7d23
movq -0x38(%rbp), %rax
movl -0x30(%rbp), %edx
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/Eshaancoding[P]AutoDiff/main.cpp
// Function: main
int main () {
    Vector a = Vector(2); 
    a = {6,32}; 
    Vector b = Vector(2); 
    b = {3,5};
    Vector c = Vector(2);
    c = {2,8};
    Matrix result = (3 * (a * a * a)).grad();
    result.print(); 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
leaq -0xa0(%rbp), %rbx
pushq $0x2
popq %r14
movq %rbx, %rdi
movl %r14d, %esi
callq 0x7294
movabsq $0x4018000000000000, %rax # imm = 0x4018000000000000
leaq -0x60(%rbp), %rsi
movq %rax, (%rsi)
movabsq $0x4040000000000000, %rax # imm = 0x4040000000000000
movq %rax, 0x8(%rsi)
pushq $0x2
popq %r15
movq %rbx, %rdi
movq %r15, %rdx
callq 0x8438
leaq -0x60(%rbp), %r12
movq %r12, %rdi
movl %r14d, %esi
callq 0x7294
movabsq $0x4008000000000000, %r13 # imm = 0x4008000000000000
leaq -0x50(%rbp), %rsi
movq %r13, (%rsi)
movabsq $0x4014000000000000, %rax # imm = 0x4014000000000000
movq %rax, 0x8(%rsi)
movq %r12, %rdi
movq %r15, %rdx
callq 0x8438
leaq -0x50(%rbp), %r12
movq %r12, %rdi
movl %r14d, %esi
callq 0x7294
movabsq $0x4000000000000000, %rax # imm = 0x4000000000000000
leaq -0x40(%rbp), %r14
movq %rax, (%r14)
movabsq $0x4020000000000000, %rax # imm = 0x4020000000000000
movq %rax, 0x8(%r14)
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x8438
leaq -0x30(%rbp), %r15
movq %r13, (%r15)
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x88b7
leaq -0x70(%rbp), %rdi
movq %rax, (%rdi)
movl %edx, 0x8(%rdi)
movq %rbx, %rsi
callq 0x85ee
leaq -0x80(%rbp), %rsi
movq %rax, (%rsi)
movl %edx, 0x8(%rsi)
movq %r15, %rdi
callq 0x8a10
leaq -0x90(%rbp), %rdi
movq %rax, (%rdi)
movl %edx, 0x8(%rdi)
callq 0x7390
movq %rax, (%r14)
movq %rdx, 0x8(%r14)
leaq -0x40(%rbp), %rdi
callq 0x2912
xorl %eax, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq