LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
xorps %xmm0, %xmm0
movl $0x1, %esi
callq 0x4184
movl $0x2, 0x8(%r14)
movl $0x30, %edi
callq 0x2190
movq %rax, %r12
xorps %xmm0, %xmm0
movq %rax, %rdi
movl $0x1, %esi
callq 0x4184
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
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r12, %rdi
callq 0x2170
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
xorps %xmm0, %xmm0
movl $0x1, %esi
callq 0x4184
movl $0x2, 0x8(%rbx)
movl $0x30, %edi
callq 0x2190
movq %rax, %r15
xorps %xmm0, %xmm0
movq %rax, %rdi
movl $0x1, %esi
callq 0x4184
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)
movl $0x30, %edi
callq 0x2190
movq %rax, %r15
xorps %xmm0, %xmm0
movq %rax, %rdi
movl $0x1, %esi
callq 0x4184
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
jmp 0x53ca
movq %rax, %rbx
movq %r15, %rdi
callq 0x2170
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movl $0x1, %esi
callq 0x4184
movl $0x2, 0x8(%rbx)
movq %r15, 0x10(%rbx)
movl $0x30, %edi
callq 0x2190
movq %rax, %r15
xorps %xmm0, %xmm0
movq %rax, %rdi
movl $0x1, %esi
callq 0x4184
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 %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x2170
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O1/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
xorps %xmm0, %xmm0
movl $0x1, %esi
callq 0x4184
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_O1/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 %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movl $0x1, %esi
callq 0x4184
movl $0x2, 0x8(%rbx)
movq %r15, 0x10(%rbx)
movl $0x30, %edi
callq 0x2190
movq %rax, %r15
xorps %xmm0, %xmm0
movq %rax, %rdi
movl $0x1, %esi
callq 0x4184
movq %r15, 0x18(%rbx)
movsd (%r14), %xmm0
movsd %xmm0, (%r15)
movl $0x1, 0x8(%r15)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x2170
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
xorps %xmm0, %xmm0
movl $0x1, %esi
callq 0x4184
movl $0x2, 0x8(%rbx)
movl $0x30, %edi
callq 0x2190
movq %rax, %r15
xorps %xmm0, %xmm0
movq %rax, %rdi
movl $0x1, %esi
callq 0x4184
movq %r15, 0x10(%rbx)
movsd (%r12), %xmm0
movsd %xmm0, (%r15)
movl $0x1, 0x8(%r15)
movl $0x30, %edi
callq 0x2190
movq %rax, %r15
xorps %xmm0, %xmm0
movq %rax, %rdi
movl $0x1, %esi
callq 0x4184
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
jmp 0x55ca
movq %rax, %rbx
movq %r15, %rdi
callq 0x2170
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
xorps %xmm0, %xmm0
movl $0x1, %esi
callq 0x4184
movl $0x2, 0x8(%r14)
movl $0x30, %edi
callq 0x2190
movq %rax, %r12
xorps %xmm0, %xmm0
movq %rax, %rdi
movl $0x1, %esi
callq 0x4184
movq %r12, 0x10(%r14)
movl $0x1, 0x8(%r12)
movsd (%r15), %xmm0
movsd %xmm0, (%r12)
movq %rbx, 0x18(%r14)
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r12, %rdi
callq 0x2170
movq %rbx, %rdi
callq 0x2250
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
xorps %xmm0, %xmm0
movl $0x1, %esi
callq 0x4184
movl $0x30, %edi
callq 0x2190
movq %rax, %r15
xorps %xmm0, %xmm0
movq %rax, %rdi
movl $0x1, %esi
callq 0x4184
movq %r15, 0x28(%rbx)
movsd (%r13), %xmm0
movsd %xmm0, (%r15)
movl $0xa, 0x8(%rbx)
movl $0x30, %edi
callq 0x2190
movq %rax, %r15
xorps %xmm0, %xmm0
movq %rax, %rdi
movl $0x1, %esi
callq 0x4184
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)
movl $0x30, %edi
callq 0x2190
movq %rax, %r15
xorps %xmm0, %xmm0
movq %rax, %rdi
movl $0x1, %esi
callq 0x4184
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 0x574d
jmp 0x574d
movq %rax, %rbx
movq %r15, %rdi
callq 0x2170
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O1/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, %rbx
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %r14
xorps %xmm0, %xmm0
movl $0x1, %esi
callq 0x4184
movl $0x30, %edi
callq 0x2190
movq %rax, %r12
xorps %xmm0, %xmm0
movq %rax, %rdi
movl $0x1, %esi
callq 0x4184
movq %r12, 0x28(%r14)
movsd (%r13), %xmm0
movsd %xmm0, (%r12)
movl $0xa, 0x8(%r14)
movl $0x30, %edi
callq 0x2190
movq %rax, %r12
xorps %xmm0, %xmm0
movq %rax, %rdi
movl $0x1, %esi
callq 0x4184
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
jmp 0x5814
movq %rax, %rbx
movq %r12, %rdi
callq 0x2170
movq %rbx, %rdi
callq 0x2250
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %rbx
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
xorps %xmm0, %xmm0
movl $0x1, %esi
callq 0x4184
movl $0x30, %edi
callq 0x2190
movq %rax, %r15
xorps %xmm0, %xmm0
movq %rax, %rdi
movl $0x1, %esi
callq 0x4184
movq %r15, 0x28(%r14)
movsd (%r13), %xmm0
movsd %xmm0, (%r15)
movl $0xa, 0x8(%r14)
movl $0x30, %edi
callq 0x2190
movq %rax, %r15
xorps %xmm0, %xmm0
movq %rax, %rdi
movl $0x1, %esi
callq 0x4184
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)
movl $0x30, %edi
callq 0x2190
movq %rax, %r15
xorps %xmm0, %xmm0
movq %rax, %rdi
movl $0x1, %esi
callq 0x4184
movq %r15, 0x18(%r14)
movl $0x1, 0x8(%r15)
movsd (%rbx), %xmm0
movsd %xmm0, (%r15)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x590b
jmp 0x590b
movq %rax, %rbx
movq %r15, %rdi
callq 0x2170
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O1/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, %r12
movq %rsi, %r13
movq %rdi, %rbx
xorps %xmm0, %xmm0
movl $0x1, %esi
callq 0x4184
movl $0x30, %edi
callq 0x2190
movq %rax, %r15
xorps %xmm0, %xmm0
movq %rax, %rdi
movl $0x1, %esi
callq 0x4184
movq %r15, 0x28(%rbx)
movsd (%r13), %xmm0
movsd %xmm0, (%r15)
movl $0xa, 0x8(%rbx)
movq %r12, 0x10(%rbx)
movl $0x30, %edi
callq 0x2190
movq %rax, %r15
xorps %xmm0, %xmm0
movq %rax, %rdi
movl $0x1, %esi
callq 0x4184
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 0x59cd
movq %rax, %rbx
movq %r15, %rdi
callq 0x2170
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O1/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, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
xorps %xmm0, %xmm0
movl $0x1, %esi
callq 0x4184
movl $0x30, %edi
callq 0x2190
movq %rax, %r13
xorps %xmm0, %xmm0
movq %rax, %rdi
movl $0x1, %esi
callq 0x4184
movq %r13, 0x28(%r15)
movsd (%r12), %xmm0
movsd %xmm0, (%r13)
movl $0xa, 0x8(%r15)
movq %r14, 0x10(%r15)
movq %rbx, 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 0x2170
movq %rbx, %rdi
callq 0x2250
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %rbx
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
xorps %xmm0, %xmm0
movl $0x1, %esi
callq 0x4184
movl $0x30, %edi
callq 0x2190
movq %rax, %r15
xorps %xmm0, %xmm0
movq %rax, %rdi
movl $0x1, %esi
callq 0x4184
movq %r15, 0x28(%r14)
movsd (%r13), %xmm0
movsd %xmm0, (%r15)
movl $0xa, 0x8(%r14)
movq %r12, 0x10(%r14)
movl $0x30, %edi
callq 0x2190
movq %rax, %r15
xorps %xmm0, %xmm0
movq %rax, %rdi
movl $0x1, %esi
callq 0x4184
movq %r15, 0x18(%r14)
movl $0x1, 0x8(%r15)
movsd (%rbx), %xmm0
movsd %xmm0, (%r15)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5b0f
movq %rax, %rbx
movq %r15, %rdi
callq 0x2170
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O1/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, %r12
movq %rsi, %r13
movq %rdi, %rbx
xorps %xmm0, %xmm0
movl $0x1, %esi
callq 0x4184
movl $0x30, %edi
callq 0x2190
movq %rax, %r15
xorps %xmm0, %xmm0
movq %rax, %rdi
movl $0x1, %esi
callq 0x4184
movq %r15, 0x28(%rbx)
movsd (%r13), %xmm0
movsd %xmm0, (%r15)
movl $0xa, 0x8(%rbx)
movl $0x30, %edi
callq 0x2190
movq %rax, %r15
xorps %xmm0, %xmm0
movq %rax, %rdi
movl $0x1, %esi
callq 0x4184
movq %r15, 0x10(%rbx)
movsd (%r12), %xmm0
movsd %xmm0, (%r15)
movl $0x1, 0x8(%r15)
movl $0x30, %edi
callq 0x2190
movq %rax, %r15
xorps %xmm0, %xmm0
movq %rax, %rdi
movl $0x1, %esi
callq 0x4184
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 0x5c03
jmp 0x5c03
movq %rax, %rbx
movq %r15, %rdi
callq 0x2170
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O1/Eshaancoding[P]AutoDiff/src/Variable/operations/divide.cpp
// Function: operator/(Variable const&, Variable const&)
Variable operator/ (const Variable &left, const Variable &right) {
    Variable new_var = Variable(false);
    new_var.operation = op::divide;
    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 %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movl $0x1, %esi
callq 0x4184
movl $0x4, 0x8(%rbx)
movl $0x30, %edi
callq 0x2190
movq %rax, %r12
xorps %xmm0, %xmm0
movq %rax, %rdi
movl $0x1, %esi
callq 0x4184
movq %r12, 0x10(%rbx)
movl $0x30, %edi
callq 0x2190
movq %rax, %r12
xorps %xmm0, %xmm0
movq %rax, %rdi
movl $0x1, %esi
callq 0x4184
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
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5d86
movq %rax, %rbx
movq %r12, %rdi
callq 0x2170
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O1/Eshaancoding[P]AutoDiff/src/Variable/operations/divide.cpp
// Function: operator/(Variable const&, double const&)
Variable operator/ (const Variable &left, const double &right) {
    Variable new_var = Variable(false);
    new_var.operation = op::divide;
    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 %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
xorps %xmm0, %xmm0
movl $0x1, %esi
callq 0x4184
movl $0x4, 0x8(%rbx)
movl $0x30, %edi
callq 0x2190
movq %rax, %r15
xorps %xmm0, %xmm0
movq %rax, %rdi
movl $0x1, %esi
callq 0x4184
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)
movl $0x30, %edi
callq 0x2190
movq %rax, %r15
xorps %xmm0, %xmm0
movq %rax, %rdi
movl $0x1, %esi
callq 0x4184
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
jmp 0x5ece
movq %rax, %rbx
movq %r15, %rdi
callq 0x2170
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl 0x8(%rdi), %esi
leaq -0x28(%rbp), %rdi
callq 0x7840
cmpl $0x0, 0x8(%rbx)
jle 0x7933
xorl %r14d, %r14d
xorl %r15d, %r15d
movq (%rbx), %rdi
addq %r14, %rdi
movl $0x1, %esi
callq 0x42b6
movq -0x28(%rbp), %rax
movsd %xmm0, (%rax,%r14)
movl $0x1, 0x8(%rax,%r14)
incq %r15
movslq 0x8(%rbx), %rax
addq $0x30, %r14
cmpq %rax, %r15
jl 0x7900
movq -0x28(%rbp), %rax
movl -0x20(%rbp), %edx
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x58, %rsp
movq %rsi, %r13
movl 0x8(%rdi), %esi
cmpl 0x8(%r13), %esi
jne 0x7e3d
movq %rdi, %rbx
leaq -0x48(%rbp), %rdi
callq 0x7840
movq %rbx, -0x38(%rbp)
cmpl $0x0, 0x8(%rbx)
jle 0x7e27
xorl %r12d, %r12d
xorl %r15d, %r15d
movq %r13, -0x30(%rbp)
movq -0x38(%rbp), %rbx
movl $0x10, %edi
callq 0x2190
movl 0x8(%r13), %esi
movq %rax, %r14
movq %rax, %rdi
callq 0x7840
movl $0x10, %edi
callq 0x2190
movq %rax, %r13
movl 0x8(%rbx), %esi
movq %rax, %rdi
callq 0x7840
movl 0x8(%rbx), %eax
movq %r14, %rcx
movl %eax, 0x8(%r14)
movq (%rbx), %rax
movq %rax, (%r14)
movq -0x30(%rbp), %r14
movl 0x8(%r14), %eax
movl %eax, 0x8(%r13)
movq (%r14), %rax
movq %rax, (%r13)
movq (%rcx), %rsi
addq %r12, %rsi
movq (%r13), %rdx
movq %r14, %r13
addq %r12, %rdx
leaq -0x78(%rbp), %rdi
callq 0x5466
movq -0x48(%rbp), %rax
movups -0x78(%rbp), %xmm0
movups -0x68(%rbp), %xmm1
movups -0x58(%rbp), %xmm2
movups %xmm2, 0x20(%rax,%r12)
movups %xmm1, 0x10(%rax,%r12)
movups %xmm0, (%rax,%r12)
incq %r15
movslq 0x8(%rbx), %rax
addq $0x30, %r12
cmpq %rax, %r15
jl 0x7d85
movq -0x48(%rbp), %rax
movl -0x40(%rbp), %edx
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x20c0
movq %rax, %r14
leaq 0x24b7(%rip), %rsi      # 0xa308
movq %rax, %rdi
callq 0x2290
movq 0x7180(%rip), %rsi      # 0xefe0
movq 0x7169(%rip), %rdx      # 0xefd0
movq %r14, %rdi
callq 0x2210
movq %rax, %rbx
movq %r14, %rdi
callq 0x2130
jmp 0x7e8f
movq %rax, %rbx
movq %r14, %rdi
jmp 0x7e8a
movq %rax, %rbx
movq %r13, %rdi
callq 0x2170
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7f55
movq %rdi, %r14
leaq -0x38(%rbp), %rdi
callq 0x7840
cmpl $0x0, 0x8(%r14)
jle 0x7f3f
xorl %r13d, %r13d
xorl %r15d, %r15d
movl $0x10, %edi
callq 0x2190
movq %rax, %r12
movl 0x8(%rbx), %esi
movq %rax, %rdi
callq 0x7840
movl 0x8(%r14), %eax
movl %eax, 0x8(%r12)
movq (%r14), %rax
movq %rax, (%r12)
movq (%r12), %rsi
addq %r13, %rsi
movq (%rbx), %rdx
addq %r13, %rdx
leaq -0x68(%rbp), %rdi
callq 0x5466
movq -0x38(%rbp), %rax
movups -0x68(%rbp), %xmm0
movups -0x58(%rbp), %xmm1
movups -0x48(%rbp), %xmm2
movups %xmm2, 0x20(%rax,%r13)
movups %xmm1, 0x10(%rax,%r13)
movups %xmm0, (%rax,%r13)
incq %r15
movslq 0x8(%r14), %rax
addq $0x30, %r13
cmpq %rax, %r15
jl 0x7ed0
movq -0x38(%rbp), %rax
movl -0x30(%rbp), %edx
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x20c0
movq %rax, %rbx
leaq 0x239f(%rip), %rsi      # 0xa308
movq %rax, %rdi
callq 0x2290
movq 0x7068(%rip), %rsi      # 0xefe0
movq 0x7051(%rip), %rdx      # 0xefd0
movq %rbx, %rdi
callq 0x2210
movq %rax, %r14
movq %rbx, %rdi
callq 0x2130
jmp 0x7f9f
movq %rax, %r14
movq %r12, %rdi
callq 0x2170
movq %r14, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7840
movl 0x8(%r14), %r12d
testl %r12d, %r12d
jle 0x8045
xorl %r15d, %r15d
xorl %ebx, %ebx
movl $0x10, %edi
callq 0x2190
movq %rax, %r13
movq %rax, %rdi
movl %r12d, %esi
callq 0x7840
movl 0x8(%r14), %eax
movl %eax, 0x8(%r13)
movq (%r14), %rax
movq %rax, (%r13)
movq (%r13), %rsi
addq %r15, %rsi
leaq -0x70(%rbp), %rdi
movq -0x30(%rbp), %rdx
callq 0x54a4
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 %rbx
movslq 0x8(%r14), %r12
addq $0x30, %r15
cmpq %r12, %rbx
jl 0x7fd9
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 0x2170
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O1/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 0x812b
movq %rdi, %r14
leaq -0x38(%rbp), %rdi
callq 0x7840
cmpl $0x0, 0x8(%r14)
jle 0x8115
xorl %r13d, %r13d
xorl %r15d, %r15d
movl $0x10, %edi
callq 0x2190
movq %rax, %r12
movl 0x8(%rbx), %esi
movq %rax, %rdi
callq 0x7840
movl 0x8(%rbx), %eax
movl %eax, 0x8(%r12)
movq (%rbx), %rax
movq %rax, (%r12)
movq (%r14), %rsi
addq %r13, %rsi
movq (%r12), %rdx
addq %r13, %rdx
leaq -0x68(%rbp), %rdi
callq 0x5466
movq -0x38(%rbp), %rax
movups -0x68(%rbp), %xmm0
movups -0x58(%rbp), %xmm1
movups -0x48(%rbp), %xmm2
movups %xmm2, 0x20(%rax,%r13)
movups %xmm1, 0x10(%rax,%r13)
movups %xmm0, (%rax,%r13)
incq %r15
movslq 0x8(%r14), %rax
addq $0x30, %r13
cmpq %rax, %r15
jl 0x80a7
movq -0x38(%rbp), %rax
movl -0x30(%rbp), %edx
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x20c0
movq %rax, %rbx
leaq 0x21c9(%rip), %rsi      # 0xa308
movq %rax, %rdi
callq 0x2290
movq 0x6e92(%rip), %rsi      # 0xefe0
movq 0x6e7b(%rip), %rdx      # 0xefd0
movq %rbx, %rdi
callq 0x2210
movq %rax, %r14
movq %rbx, %rdi
callq 0x2130
jmp 0x8175
movq %rax, %r14
movq %r12, %rdi
callq 0x2170
movq %r14, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8211
movq %rdi, %r14
leaq -0x38(%rbp), %rdi
callq 0x7840
cmpl $0x0, 0x8(%r14)
jle 0x81fb
xorl %r12d, %r12d
leaq -0x68(%rbp), %r15
xorl %r13d, %r13d
movq (%r14), %rsi
addq %r12, %rsi
movq (%rbx), %rdx
addq %r12, %rdx
movq %r15, %rdi
callq 0x5466
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
movslq 0x8(%r14), %rax
addq $0x30, %r12
cmpq %rax, %r13
jl 0x81b6
movq -0x38(%rbp), %rax
movl -0x30(%rbp), %edx
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x20c0
movq %rax, %rbx
leaq 0x20e3(%rip), %rsi      # 0xa308
movq %rax, %rdi
callq 0x2290
movq 0x6dac(%rip), %rsi      # 0xefe0
movq 0x6d95(%rip), %rdx      # 0xefd0
movq %rbx, %rdi
callq 0x2210
movq %rax, %r14
movq %rbx, %rdi
callq 0x2130
movq %r14, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7840
cmpl $0x0, 0x8(%r14)
jle 0x82cc
xorl %r12d, %r12d
leaq -0x68(%rbp), %r15
xorl %r13d, %r13d
movq (%r14), %rsi
addq %r12, %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x54a4
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
movslq 0x8(%r14), %rax
addq $0x30, %r12
cmpq %rax, %r13
jl 0x828a
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_O1/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 0x7840
movl 0x8(%rbx), %r12d
testl %r12d, %r12d
jle 0x8380
xorl %r15d, %r15d
xorl %r14d, %r14d
movl $0x10, %edi
callq 0x2190
movq %rax, %r13
movq %rax, %rdi
movl %r12d, %esi
callq 0x7840
movl 0x8(%rbx), %eax
movl %eax, 0x8(%r13)
movq (%rbx), %rax
movq %rax, (%r13)
movq (%r13), %rdx
addq %r15, %rdx
leaq -0x70(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x55dd
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
movslq 0x8(%rbx), %r12
addq $0x30, %r15
cmpq %r12, %r14
jl 0x8315
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 0x2170
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7840
cmpl $0x0, 0x8(%rbx)
jle 0x841e
xorl %r12d, %r12d
leaq -0x68(%rbp), %r15
xorl %r13d, %r13d
movq (%rbx), %rdx
addq %r12, %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x55dd
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
movslq 0x8(%rbx), %rax
addq $0x30, %r12
cmpq %rax, %r13
jl 0x83dc
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_O1/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 %r12
pushq %rbx
subq $0x80, %rsp
leaq -0x98(%rbp), %rbx
movq %rbx, %rdi
movl $0x2, %esi
callq 0x7840
movabsq $0x4018000000000000, %rax # imm = 0x4018000000000000
leaq -0x58(%rbp), %rsi
movq %rax, (%rsi)
movabsq $0x4040000000000000, %rax # imm = 0x4040000000000000
movq %rax, 0x8(%rsi)
movl $0x2, %edx
movq %rbx, %rdi
callq 0x8b2c
leaq -0x58(%rbp), %r14
movq %r14, %rdi
movl $0x2, %esi
callq 0x7840
movabsq $0x4008000000000000, %r12 # imm = 0x4008000000000000
leaq -0x48(%rbp), %rsi
movq %r12, (%rsi)
movabsq $0x4014000000000000, %rax # imm = 0x4014000000000000
movq %rax, 0x8(%rsi)
movl $0x2, %edx
movq %r14, %rdi
callq 0x8b2c
leaq -0x48(%rbp), %r15
movq %r15, %rdi
movl $0x2, %esi
callq 0x7840
movabsq $0x4000000000000000, %rax # imm = 0x4000000000000000
leaq -0x38(%rbp), %r14
movq %rax, (%r14)
movabsq $0x4020000000000000, %rax # imm = 0x4020000000000000
movq %rax, 0x8(%r14)
movl $0x2, %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0x8b2c
leaq -0x28(%rbp), %r15
movq %r12, (%r15)
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x8fdd
leaq -0x68(%rbp), %rdi
movq %rax, (%rdi)
movl %edx, 0x8(%rdi)
movq %rbx, %rsi
callq 0x8cf7
leaq -0x78(%rbp), %rsi
movq %rax, (%rsi)
movl %edx, 0x8(%rsi)
movq %r15, %rdi
callq 0x9142
leaq -0x88(%rbp), %rdi
movq %rax, (%rdi)
movl %edx, 0x8(%rdi)
callq 0x7948
movq %rax, (%r14)
movq %rdx, 0x8(%r14)
leaq -0x38(%rbp), %rdi
callq 0x2b16
xorl %eax, %eax
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ivan-tkatchev[P]makerpm/makerpm.cc
// Function: add_magic(unsigned int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, unsigned long&)
void add_magic(uint32_t tag, const std::string& data,
               std::string& index, std::string& store, size_t& nentries) {

    add_uint32(tag, index);
    add_uint32(rpm::index_t::entry_t::TYPE_BIN, index);
    add_uint32(store.size(), index);
    add_uint32(data.size(), index);

    store += data;

    ++nentries;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdx, %rsi
callq 0xf0d8
movl $0x7, %edi
movq %r15, %rsi
callq 0xf0d8
movl 0x8(%r14), %edi
movq %r15, %rsi
callq 0xf0d8
movl 0x8(%r12), %edi
movq %r15, %rsi
callq 0xf0d8
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r14, %rdi
callq 0x3450
incq (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/ivan-tkatchev[P]makerpm/makerpm.cc
// Function: compress_file(mfile&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void compress_file(mfile& in, const std::string& out) {

    gzFile gf = ::gzopen(out.c_str(), "wbx");

    if (gf == NULL) {
        throw std::runtime_error("Could not open for writing: " + out);
    }

    size_t n = ::gzwrite(gf, in.addr, in.size);

    if (n == 0) {
        throw std::runtime_error("Could not write to compressed file: " + out);
    }

    if (::gzclose(gf) != Z_OK) {
        throw std::runtime_error("Error in closing compressed file.");
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rdi
leaq 0x91c6(%rip), %rsi      # 0x1972a
callq 0x3220
testq %rax, %rax
je 0x1059f
movq %rax, %rbx
movq (%r15), %rsi
movl 0x10(%r15), %edx
movq %rax, %rdi
callq 0x3530
testl %eax, %eax
je 0x105ea
movq %rbx, %rdi
callq 0x3510
testl %eax, %eax
jne 0x10633
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x3240
movq %rax, %rbx
leaq 0x917b(%rip), %rsi      # 0x1972e
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq 0x12b16
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x31c0
xorl %ebp, %ebp
movq 0xca0f(%rip), %rsi      # 0x1cfe8
movq 0xca00(%rip), %rdx      # 0x1cfe0
movq %rbx, %rdi
callq 0x3360
jmp 0x10633
movl $0x10, %edi
callq 0x3240
movq %rax, %rbx
leaq 0x914d(%rip), %rsi      # 0x1974b
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq 0x12b16
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x31c0
xorl %ebp, %ebp
movq 0xc9c4(%rip), %rsi      # 0x1cfe8
movq 0xc9b5(%rip), %rdx      # 0x1cfe0
movq %rbx, %rdi
callq 0x3360
movl $0x10, %edi
callq 0x3240
movq %rax, %rbx
leaq 0x9129(%rip), %rsi      # 0x19770
movq %rax, %rdi
callq 0x3190
movq 0xc992(%rip), %rsi      # 0x1cfe8
movq 0xc983(%rip), %rdx      # 0x1cfe0
movq %rbx, %rdi
callq 0x3360
movq %rax, %r14
jmp 0x10691
jmp 0x1066e
jmp 0x10686
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1068c
callq 0x32f0
jmp 0x1068c
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x10699
movq %rbx, %rdi
callq 0x3500
movq %r14, %rdi
callq 0x3370
// File: /workspace/github_cpp_makefile_star2_O1/ivan-tkatchev[P]makerpm/makerpm.cc
// Function: print_digest[abi:cxx11](unsigned char const*, unsigned long)
std::string print_digest(const unsigned char* digest, size_t len) {

    std::string ret;

    for (size_t i = 0; i < len; ++i) {
        static unsigned char print[16] = {'0', '1', '2', '3', '4', '5', '6', '7', 
                                          '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};

        unsigned char c = digest[i];
        ret += print[(c >> 4) & 0xF];
        ret += print[c & 0xF];
    }

    return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
testq %rdx, %rdx
je 0x1070b
movq %rdx, %r14
movq %rsi, %r15
xorl %r13d, %r13d
leaq 0x93d5(%rip), %rbp      # 0x19ab0
movzbl (%r15,%r13), %r12d
movl %r12d, %eax
shrl $0x4, %eax
movsbl (%rax,%rbp), %esi
movq %rbx, %rdi
callq 0x3690
andl $0xf, %r12d
movsbl (%r12,%rbp), %esi
movq %rbx, %rdi
callq 0x3690
incq %r13
cmpq %r13, %r14
jne 0x106db
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0x1072e
callq 0x32f0
movq %r14, %rdi
callq 0x3370
// File: /workspace/github_cpp_makefile_star2_O1/ivan-tkatchev[P]makerpm/makerpm.cc
// Function: make_rpm(rpmprops_t const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
mfile make_rpm(const rpmprops_t& props, const std::string& payload_file, std::string& header) {

    mfile payload(payload_file);

    std::string index2 = make_index2(props);
    mfile ret = make_index1(index2, payload, payload_file + ".gz", header);
    std::string lead = make_lead(
        props.name,
        htons((uint16_t)(props.arch == "src")) /* 1 for source, 0 for binary */
    );

    header = lead + header + index2;
    return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x48(%rsp), %rdi
movq %rdx, %rsi
callq 0x12b98
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0xf1ff
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x1392a
leaq 0x8cf8(%rip), %rsi      # 0x197cb
leaq 0x8(%rsp), %rdi
callq 0x3380
leaq 0x28(%rsp), %rsi
leaq 0x48(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movq %rbx, %rdi
movq %r14, %r8
callq 0x10736
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x10b06
callq 0x32f0
leaq 0x168(%r15), %rdi
leaq 0x8c12(%rip), %rsi      # 0x19726
callq 0x3520
xorl %edx, %edx
testl %eax, %eax
sete %dl
shll $0x8, %edx
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0xefcc
leaq 0x60(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movq %r14, %rdx
callq 0x12da1
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
leaq 0x60(%rsp), %rdi
callq 0x3450
leaq 0x90(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x10b87
movq %rdx, 0x80(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x90(%rsp)
jmp 0x10b8f
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rax), %rdx
leaq 0x80(%rsp), %r15
movq %rdx, 0x8(%r15)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0x32e0
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x10bc6
callq 0x32f0
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x10bd9
callq 0x32f0
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x10be8
callq 0x32f0
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x10bfb
callq 0x32f0
leaq 0x48(%rsp), %rdi
callq 0x12d74
movq %rbx, %rax
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x10c34
callq 0x32f0
jmp 0x10c34
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x10c48
callq 0x32f0
jmp 0x10c48
movq %rax, %r14
movq %rbx, %rdi
callq 0x12d74
jmp 0x10c6b
jmp 0x10c54
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x10c6b
callq 0x32f0
jmp 0x10c6b
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x10c83
callq 0x32f0
jmp 0x10c83
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x12d74
movq %r14, %rdi
callq 0x3370
// File: /workspace/github_cpp_makefile_star2_O1/ivan-tkatchev[P]makerpm/makerpm.cc
// Function: uid_to_uname[abi:cxx11](unsigned int)
std::string uid_to_uname(uid_t uid) {

    struct passwd unam;
    char buf[1024];

    struct passwd* res;
    ::getpwuid_r(uid, &unam, buf, 1024, &res);

    std::string uname;

    if (res == NULL) {
        return "(unknown)";
    } else {
        return res->pw_name;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x460, %rsp            # imm = 0x460
movl %esi, %eax
movq %rdi, %rbx
leaq 0x30(%rsp), %rsi
leaq 0x60(%rsp), %rdx
leaq 0x8(%rsp), %r14
movl $0x400, %ecx            # imm = 0x400
movl %eax, %edi
movq %r14, %r8
callq 0x3410
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
movq (%r14), %rax
testq %rax, %rax
je 0x10cf3
movq (%rax), %rsi
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x3590
jmp 0x10d10
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x8ace(%rip), %rsi      # 0x197cf
leaq 0x8ad0(%rip), %rdx      # 0x197d8
movq %rbx, %rdi
callq 0x139ba
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x10d1f
callq 0x32f0
movq %rbx, %rax
addq $0x460, %rsp            # imm = 0x460
popq %rbx
popq %r14
popq %r15
retq
jmp 0x10d31
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x10d43
callq 0x32f0
movq %rbx, %rdi
callq 0x3370
// File: /workspace/github_cpp_makefile_star2_O1/ivan-tkatchev[P]makerpm/makerpm.cc
// Function: gid_to_gname[abi:cxx11](unsigned int)
std::string gid_to_gname(gid_t gid) {

    struct group gnam;
    char buf[1024];

    struct group* res;
    ::getgrgid_r(gid, &gnam, buf, 1024, &res);

    if (res == NULL) {
        return "(unknown)";
    } else {
        return res->gr_name;
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x438, %rsp            # imm = 0x438
movl %esi, %eax
movq %rdi, %rbx
leaq 0x10(%rsp), %rsi
leaq 0x30(%rsp), %rdx
leaq 0x8(%rsp), %r14
movl $0x400, %ecx            # imm = 0x400
movl %eax, %edi
movq %r14, %r8
callq 0x34b0
movq (%r14), %rax
testq %rax, %rax
je 0x10d92
movq (%rax), %rsi
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x3590
jmp 0x10daf
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x8a2f(%rip), %rsi      # 0x197cf
leaq 0x8a31(%rip), %rdx      # 0x197d8
movq %rbx, %rdi
callq 0x139ba
movq %rbx, %rax
addq $0x438, %rsp            # imm = 0x438
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/ivan-tkatchev[P]makerpm/makerpm.cc
// Function: Store::add(unsigned int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
void add(uint32_t tag, const std::string& txt, bool i18) {

        add_uint32(tag, index);
        add_uint32((i18 ? rpm::index_t::entry_t::TYPE_I18STRING : rpm::index_t::entry_t::TYPE_STRING), index);
        add_uint32(store.size(), index);
        add_uint32(1, index);
        store += txt;
        store += '\0';

        ++nentries;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %ecx, %r14d
movq %rdx, %r15
movq %rdi, %rbx
movl %esi, %edi
movq %rbx, %rsi
callq 0xf0d8
leal (%r14,%r14,2), %edi
addl $0x6, %edi
movq %rbx, %rsi
callq 0xf0d8
leaq 0x20(%rbx), %r14
movl 0x28(%rbx), %edi
movq %rbx, %rsi
callq 0xf0d8
movl $0x1, %edi
movq %rbx, %rsi
callq 0xf0d8
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x3450
movq %r14, %rdi
xorl %esi, %esi
callq 0x3690
incq 0x40(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/ivan-tkatchev[P]makerpm/makerpm.cc
// Function: Store::add(unsigned int, unsigned int)
void add(uint32_t tag, uint32_t data) {

        add_uint32(tag, index);
        add_uint32(rpm::index_t::entry_t::TYPE_INT32, index);

        size_t n = (4 - (store.size() % 4)) % 4;

        while (n > 0) {
            store += '\0';
            --n;
        }

        add_uint32(store.size(), index);
        add_uint32(1, index);
        add_uint32(data, store);

        ++nentries;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rdi, %rbx
movl %esi, %edi
movq %rbx, %rsi
callq 0xf0d8
movl $0x4, %edi
movq %rbx, %rsi
callq 0xf0d8
leaq 0x20(%rbx), %r14
xorl %r15d, %r15d
subl 0x28(%rbx), %r15d
andl $0x3, %r15d
je 0x124c7
movq %r14, %rdi
xorl %esi, %esi
callq 0x3690
decq %r15
jne 0x124b8
movl 0x28(%rbx), %edi
movq %rbx, %rsi
callq 0xf0d8
movl $0x1, %edi
movq %rbx, %rsi
callq 0xf0d8
movl %ebp, %edi
movq %r14, %rsi
callq 0xf0d8
incq 0x40(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq