LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x414c
movl $0x30, %edi
callq 0x2190
movq %rax, %r15
xorps %xmm0, %xmm0
movq %rax, %rdi
movl $0x1, %esi
callq 0x414c
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 0x414c
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 0x5aaf
movq %rax, %rbx
movq %r15, %rdi
callq 0x2170
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O3/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 0x414c
movl $0x30, %edi
callq 0x2190
movq %rax, %r15
xorps %xmm0, %xmm0
movq %rax, %rdi
movl $0x1, %esi
callq 0x414c
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 0x414c
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 0x414c
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 0x5ba3
jmp 0x5ba3
movq %rax, %rbx
movq %r15, %rdi
callq 0x2170
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O3/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 0x414c
movl $0x4, 0x8(%rbx)
movl $0x30, %edi
callq 0x2190
movq %rax, %r12
xorps %xmm0, %xmm0
movq %rax, %rdi
movl $0x1, %esi
callq 0x414c
movq %r12, 0x10(%rbx)
movl $0x30, %edi
callq 0x2190
movq %rax, %r12
xorps %xmm0, %xmm0
movq %rax, %rdi
movl $0x1, %esi
callq 0x414c
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 0x5d26
movq %rax, %rbx
movq %r12, %rdi
callq 0x2170
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
xorps %xmm0, %xmm0
movl $0x1, %esi
callq 0x414c
movl $0x4, 0x8(%rbx)
movl $0x30, %edi
callq 0x2190
movq %rax, %r15
xorps %xmm0, %xmm0
movq %rax, %rdi
movl $0x1, %esi
callq 0x414c
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 0x414c
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 0x606e
movq %rax, %rbx
movq %r15, %rdi
callq 0x2170
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O3/Eshaancoding[P]AutoDiff/src/Variable/operations/exponent.cpp
// Function: operator^(Variable const&, Variable const&)
Variable operator^ (const Variable &left, const Variable &right) {
    Variable new_var = Variable(false);
    new_var.operation = op::exponent;
    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 0x414c
movl $0x6, 0x8(%rbx)
movl $0x30, %edi
callq 0x2190
movq %rax, %r12
xorps %xmm0, %xmm0
movq %rax, %rdi
movl $0x1, %esi
callq 0x414c
movq %r12, 0x10(%rbx)
movl $0x30, %edi
callq 0x2190
movq %rax, %r12
xorps %xmm0, %xmm0
movq %rax, %rdi
movl $0x1, %esi
callq 0x414c
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 0x61c2
movq %rax, %rbx
movq %r12, %rdi
callq 0x2170
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O3/Eshaancoding[P]AutoDiff/src/Variable/operations/exponent.cpp
// Function: operator^(Variable&, Variable&)
Variable operator^ (Variable &left, Variable &right) {
    Variable new_var = Variable(false);
    new_var.operation = op::exponent;
    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 0x414c
movl $0x6, 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_O3/Eshaancoding[P]AutoDiff/src/Variable/operations/exponent.cpp
// Function: operator^(double const&, Variable const&)
Variable operator^ (const double &left, const Variable &right) {
    Variable new_var = Variable(false);
    new_var.operation = op::exponent;
    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 0x414c
movl $0x6, 0x8(%rbx)
movl $0x30, %edi
callq 0x2190
movq %rax, %r15
xorps %xmm0, %xmm0
movq %rax, %rdi
movl $0x1, %esi
callq 0x414c
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 0x414c
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 0x650a
movq %rax, %rbx
movq %r15, %rdi
callq 0x2170
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O3/Eshaancoding[P]AutoDiff/src/Variable/operations/min.cpp
// Function: min_op(Variable const&, Variable const&)
Variable min_op (const Variable &left, const Variable &right) {
    Variable new_var = Variable(false);
    new_var.operation = op::min;
    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 0x414c
movl $0x8, 0x8(%rbx)
movl $0x30, %edi
callq 0x2190
movq %rax, %r12
xorps %xmm0, %xmm0
movq %rax, %rdi
movl $0x1, %esi
callq 0x414c
movq %r12, 0x10(%rbx)
movl $0x30, %edi
callq 0x2190
movq %rax, %r12
xorps %xmm0, %xmm0
movq %rax, %rdi
movl $0x1, %esi
callq 0x414c
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 0x6ae2
movq %rax, %rbx
movq %r12, %rdi
callq 0x2170
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O3/Eshaancoding[P]AutoDiff/src/Variable/operations/min.cpp
// Function: min_op(Variable const&, double const&)
Variable min_op (const Variable &left, const double &right) {
    Variable new_var = Variable(false);
    new_var.operation = op::min;
    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 0x414c
movl $0x8, 0x8(%rbx)
movl $0x30, %edi
callq 0x2190
movq %rax, %r15
xorps %xmm0, %xmm0
movq %rax, %rdi
movl $0x1, %esi
callq 0x414c
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 0x414c
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 0x6c2a
movq %rax, %rbx
movq %r15, %rdi
callq 0x2170
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O3/Eshaancoding[P]AutoDiff/src/Variable/operations/min.cpp
// Function: min_op(double const&, Variable const&)
Variable min_op (const double &left, const Variable &right) {
    Variable new_var = Variable(false);
    new_var.operation = op::min;
    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 0x414c
movl $0x8, 0x8(%rbx)
movl $0x30, %edi
callq 0x2190
movq %rax, %r15
xorps %xmm0, %xmm0
movq %rax, %rdi
movl $0x1, %esi
callq 0x414c
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 0x414c
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 0x6e2a
movq %rax, %rbx
movq %r15, %rdi
callq 0x2170
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O3/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 0x77e0
cmpl $0x0, 0x8(%rbx)
jle 0x78d3
xorl %r14d, %r14d
xorl %r15d, %r15d
movq (%rbx), %rdi
addq %r14, %rdi
movl $0x1, %esi
callq 0x427e
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 0x78a0
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_O3/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 0x7dfb
movq %rdi, %rbx
leaq -0x48(%rbp), %rdi
callq 0x77e0
cmpl $0x0, 0x8(%rbx)
jle 0x7de5
movq %rbx, -0x38(%rbp)
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 0x77e0
movl $0x10, %edi
callq 0x2190
movq %rax, %r13
movl 0x8(%rbx), %esi
movq %rax, %rdi
callq 0x77e0
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 0x5406
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), %rcx
addq $0x30, %r12
cmpq %rcx, %r15
jl 0x7d41
jmp 0x7de9
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 0x24f9(%rip), %rsi      # 0xa308
movq %rax, %rdi
callq 0x2290
movq 0x71c2(%rip), %rsi      # 0xefe0
movq 0x71ab(%rip), %rdx      # 0xefd0
movq %r14, %rdi
callq 0x2210
movq %rax, %rbx
movq %r14, %rdi
callq 0x2130
jmp 0x7e4d
movq %rax, %rbx
movq %r14, %rdi
jmp 0x7e48
movq %rax, %rbx
movq %r13, %rdi
callq 0x2170
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7f15
movq %rdi, %r14
leaq -0x38(%rbp), %rdi
callq 0x77e0
cmpl $0x0, 0x8(%r14)
jle 0x7eff
xorl %r13d, %r13d
xorl %r15d, %r15d
movl $0x10, %edi
callq 0x2190
movq %rax, %r12
movl 0x8(%rbx), %esi
movq %rax, %rdi
callq 0x77e0
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 0x5406
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), %rcx
addq $0x30, %r13
cmpq %rcx, %r15
jl 0x7e8e
jmp 0x7f03
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 0x23df(%rip), %rsi      # 0xa308
movq %rax, %rdi
callq 0x2290
movq 0x70a8(%rip), %rsi      # 0xefe0
movq 0x7091(%rip), %rdx      # 0xefd0
movq %rbx, %rdi
callq 0x2210
movq %rax, %r14
movq %rbx, %rdi
callq 0x2130
jmp 0x7f5f
movq %rax, %r14
movq %r12, %rdi
callq 0x2170
movq %r14, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O3/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 0x77e0
movl 0x8(%r14), %r12d
testl %r12d, %r12d
jle 0x8007
xorl %r15d, %r15d
xorl %ebx, %ebx
movl $0x10, %edi
callq 0x2190
movq %rax, %r13
movq %rax, %rdi
movl %r12d, %esi
callq 0x77e0
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 0x5444
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 0x7f99
jmp 0x800b
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_O3/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 0x80ef
movq %rdi, %r14
leaq -0x38(%rbp), %rdi
callq 0x77e0
cmpl $0x0, 0x8(%r14)
jle 0x80d9
xorl %r13d, %r13d
xorl %r15d, %r15d
movl $0x10, %edi
callq 0x2190
movq %rax, %r12
movl 0x8(%rbx), %esi
movq %rax, %rdi
callq 0x77e0
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 0x5406
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), %rcx
addq $0x30, %r13
cmpq %rcx, %r15
jl 0x8069
jmp 0x80dd
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 0x2205(%rip), %rsi      # 0xa308
movq %rax, %rdi
callq 0x2290
movq 0x6ece(%rip), %rsi      # 0xefe0
movq 0x6eb7(%rip), %rdx      # 0xefd0
movq %rbx, %rdi
callq 0x2210
movq %rax, %r14
movq %rbx, %rdi
callq 0x2130
jmp 0x8139
movq %rax, %r14
movq %r12, %rdi
callq 0x2170
movq %r14, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O3/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 0x81d7
movq %rdi, %r14
leaq -0x38(%rbp), %rdi
callq 0x77e0
cmpl $0x0, 0x8(%r14)
jle 0x81c1
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 0x5406
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), %rcx
addq $0x30, %r12
cmpq %rcx, %r13
jl 0x817a
jmp 0x81c5
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 0x211d(%rip), %rsi      # 0xa308
movq %rax, %rdi
callq 0x2290
movq 0x6de6(%rip), %rsi      # 0xefe0
movq 0x6dcf(%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_O3/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 0x77e0
cmpl $0x0, 0x8(%r14)
jle 0x8294
xorl %r12d, %r12d
leaq -0x68(%rbp), %r15
xorl %r13d, %r13d
movq (%r14), %rsi
addq %r12, %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x5444
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), %rcx
addq $0x30, %r12
cmpq %rcx, %r13
jl 0x8250
jmp 0x8298
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_O3/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 0x77e0
movl 0x8(%rbx), %r12d
testl %r12d, %r12d
jle 0x834a
xorl %r15d, %r15d
xorl %r14d, %r14d
movl $0x10, %edi
callq 0x2190
movq %rax, %r13
movq %rax, %rdi
movl %r12d, %esi
callq 0x77e0
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 0x557d
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 0x82dd
jmp 0x834e
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_O3/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 0x77e0
cmpl $0x0, 0x8(%rbx)
jle 0x83ea
xorl %r12d, %r12d
leaq -0x68(%rbp), %r15
xorl %r13d, %r13d
movq (%rbx), %rdx
addq %r12, %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x557d
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), %rcx
addq $0x30, %r12
cmpq %rcx, %r13
jl 0x83a6
jmp 0x83ee
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_O3/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 0x77e0
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 0x8b08
leaq -0x58(%rbp), %r14
movq %r14, %rdi
movl $0x2, %esi
callq 0x77e0
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 0x8b08
leaq -0x48(%rbp), %r15
movq %r15, %rdi
movl $0x2, %esi
callq 0x77e0
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 0x8b08
leaq -0x28(%rbp), %r15
movq %r12, (%r15)
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x8fc1
leaq -0x68(%rbp), %rdi
movq %rax, (%rdi)
movl %edx, 0x8(%rdi)
movq %rbx, %rsi
callq 0x8cd5
leaq -0x78(%rbp), %rsi
movq %rax, (%rsi)
movl %edx, 0x8(%rsi)
movq %r15, %rdi
callq 0x912a
leaq -0x88(%rbp), %rdi
movq %rax, (%rdi)
movl %edx, 0x8(%rdi)
callq 0x78e8
movq %rax, (%r14)
movq %rdx, 0x8(%r14)
leaq -0x38(%rbp), %rdi
callq 0x2b1a
xorl %eax, %eax
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x10b83
movl $0x7, %edi
movq %r15, %rsi
callq 0x10b83
movl 0x8(%r14), %edi
movq %r15, %rsi
callq 0x10b83
movl 0x8(%r12), %edi
movq %r15, %rsi
callq 0x10b83
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_O3/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, %rbx
movq %rdi, %r15
movq (%rsi), %rdi
leaq 0x8e9e(%rip), %rsi      # 0x1aea6
callq 0x3220
testq %rax, %rax
je 0x12043
movq %rax, %r14
movq (%r15), %rsi
movl 0x10(%r15), %edx
movq %rax, %rdi
callq 0x3520
testl %eax, %eax
je 0x1208e
movq %r14, %rdi
callq 0x3500
testl %eax, %eax
jne 0x120d7
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x3240
movq %rax, %r14
leaq 0x8e53(%rip), %rsi      # 0x1aeaa
leaq 0x8(%rsp), %rdi
movq %rbx, %rdx
callq 0x145e8
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x31c0
xorl %ebp, %ebp
movq 0xcf6b(%rip), %rsi      # 0x1efe8
movq 0xcf5c(%rip), %rdx      # 0x1efe0
movq %r14, %rdi
callq 0x3360
jmp 0x120d7
movl $0x10, %edi
callq 0x3240
movq %rax, %r14
leaq 0x8e25(%rip), %rsi      # 0x1aec7
leaq 0x8(%rsp), %rdi
movq %rbx, %rdx
callq 0x145e8
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x31c0
xorl %ebp, %ebp
movq 0xcf20(%rip), %rsi      # 0x1efe8
movq 0xcf11(%rip), %rdx      # 0x1efe0
movq %r14, %rdi
callq 0x3360
movl $0x10, %edi
callq 0x3240
movq %rax, %r14
leaq 0x8e01(%rip), %rsi      # 0x1aeec
movq %rax, %rdi
callq 0x3190
movq 0xceee(%rip), %rsi      # 0x1efe8
movq 0xcedf(%rip), %rdx      # 0x1efe0
movq %r14, %rdi
callq 0x3360
jmp 0x1212c
jmp 0x1210f
jmp 0x1212c
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x12125
callq 0x32f0
testb %bpl, %bpl
jne 0x1212f
jmp 0x12137
movq %rax, %rbx
movq %r14, %rdi
callq 0x34f0
movq %rbx, %rdi
callq 0x3370
// File: /workspace/github_cpp_makefile_star2_O3/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 0x121a9
movq %rdx, %r14
movq %rsi, %r15
xorl %r13d, %r13d
leaq 0x90a7(%rip), %rbp      # 0x1b220
movzbl (%r15,%r13), %r12d
movl %r12d, %eax
shrl $0x4, %eax
movsbl (%rax,%rbp), %esi
movq %rbx, %rdi
callq 0x3680
andl $0xf, %r12d
movsbl (%r12,%rbp), %esi
movq %rbx, %rdi
callq 0x3680
incq %r13
cmpq %r13, %r14
jne 0x12179
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 0x121cc
callq 0x32f0
movq %r14, %rdi
callq 0x3370
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1466a
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0x10caa
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x153fa
leaq 0x89d6(%rip), %rsi      # 0x1af47
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 0x121d4
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x125a4
callq 0x32f0
leaq 0x168(%r15), %rdi
leaq 0x88f0(%rip), %rsi      # 0x1aea2
callq 0x3510
xorl %edx, %edx
testl %eax, %eax
sete %dl
shll $0x8, %edx
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x10a78
leaq 0x60(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movq %r14, %rdx
callq 0x14871
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 0x12625
movq %rdx, 0x80(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x90(%rsp)
jmp 0x1262d
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 0x12664
callq 0x32f0
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x12677
callq 0x32f0
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x12686
callq 0x32f0
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x12699
callq 0x32f0
leaq 0x48(%rsp), %rdi
callq 0x14844
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 0x126d2
callq 0x32f0
jmp 0x126d2
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x126e6
callq 0x32f0
jmp 0x126e6
movq %rax, %r14
movq %rbx, %rdi
callq 0x14844
jmp 0x12709
jmp 0x126f2
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x12709
callq 0x32f0
jmp 0x12709
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x12721
callq 0x32f0
jmp 0x12721
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x14844
movq %r14, %rdi
callq 0x3370
// File: /workspace/github_cpp_makefile_star2_O3/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 0x12791
movq (%rax), %rsi
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x3580
jmp 0x127ae
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x87ac(%rip), %rsi      # 0x1af4b
leaq 0x87ae(%rip), %rdx      # 0x1af54
movq %rbx, %rdi
callq 0x15490
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x127bd
callq 0x32f0
movq %rbx, %rax
addq $0x460, %rsp            # imm = 0x460
popq %rbx
popq %r14
popq %r15
retq
jmp 0x127cf
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x127e1
callq 0x32f0
movq %rbx, %rdi
callq 0x3370
// File: /workspace/github_cpp_makefile_star2_O3/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 0x12830
movq (%rax), %rsi
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x3580
jmp 0x1284d
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x870d(%rip), %rsi      # 0x1af4b
leaq 0x870f(%rip), %rdx      # 0x1af54
movq %rbx, %rdi
callq 0x15490
movq %rbx, %rax
addq $0x438, %rsp            # imm = 0x438
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x10b83
leal (%r14,%r14,2), %edi
addl $0x6, %edi
movq %rbx, %rsi
callq 0x10b83
leaq 0x20(%rbx), %r14
movl 0x28(%rbx), %edi
movq %rbx, %rsi
callq 0x10b83
movl $0x1, %edi
movq %rbx, %rsi
callq 0x10b83
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x3450
movq %r14, %rdi
xorl %esi, %esi
callq 0x3680
incq 0x40(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x10b83
movl $0x4, %edi
movq %rbx, %rsi
callq 0x10b83
leaq 0x20(%rbx), %r14
movq 0x28(%rbx), %rdi
movl %edi, %r15d
negl %r15d
andl $0x3, %r15d
je 0x13f84
movq %r14, %rdi
xorl %esi, %esi
callq 0x3680
decq %r15
jne 0x13f71
movq 0x28(%rbx), %rdi
movq %rbx, %rsi
callq 0x10b83
movl $0x1, %edi
movq %rbx, %rsi
callq 0x10b83
movl %ebp, %edi
movq %r14, %rsi
callq 0x10b83
incq 0x40(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ivan-tkatchev[P]makerpm/makerpm.cc
// Function: Store::add(unsigned int, unsigned long)
void add(uint32_t tag, uint64_t data) {

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

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

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

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

        ++nentries;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl %esi, %edi
movq %rbx, %rsi
callq 0x10b83
movl $0x5, %edi
movq %rbx, %rsi
callq 0x10b83
leaq 0x20(%rbx), %r14
movq 0x28(%rbx), %rdi
movl %edi, %r15d
negl %r15d
andl $0x7, %r15d
je 0x142a0
movq %r14, %rdi
xorl %esi, %esi
callq 0x3680
decq %r15
jne 0x1428d
movq 0x28(%rbx), %rdi
movq %rbx, %rsi
callq 0x10b83
movl $0x1, %edi
movq %rbx, %rsi
callq 0x10b83
movq %r14, %rsi
callq 0x10be4
incq 0x40(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ivan-tkatchev[P]makerpm/./mfile.h
// Function: mfile::mfile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
mfile(const std::string& f) {

        fd = ::open(f.c_str(), O_RDONLY|O_LARGEFILE);
        
        if (fd < 0) {
            throw std::runtime_error("Could not open: " + f);
        }

        struct stat st;

        if (::fstat(fd, &st) < 0) {
            throw std::runtime_error("Could not stat: " + f);
        }

        size = st.st_size;

        addr = ::mmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0);
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0xb0, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x3280
movl %eax, 0x8(%r14)
testl %eax, %eax
js 0x146cf
leaq 0x20(%rsp), %rsi
movl %eax, %edi
callq 0x34e0
testl %eax, %eax
js 0x1471a
movq 0x50(%rsp), %rsi
movq %rsi, 0x10(%r14)
movl 0x8(%r14), %r8d
xorl %edi, %edi
movl $0x1, %edx
movl $0x2, %ecx
xorl %r9d, %r9d
callq 0x3530
movq %rax, (%r14)
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x3240
movq %rax, %r14
leaq 0x6a82(%rip), %rsi      # 0x1b165
leaq 0x20(%rsp), %rdi
movq %rbx, %rdx
callq 0x145e8
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x31c0
xorl %ebp, %ebp
movq 0xa8df(%rip), %rsi      # 0x1efe8
movq 0xa8d0(%rip), %rdx      # 0x1efe0
movq %r14, %rdi
callq 0x3360
jmp 0x1475f
movl $0x10, %edi
callq 0x3240
movq %rax, %r14
leaq 0x6a66(%rip), %rsi      # 0x1b194
movq %rsp, %rdi
movq %rbx, %rdx
callq 0x145e8
movb $0x1, %bpl
movq %rsp, %rsi
movq %r14, %rdi
callq 0x31c0
xorl %ebp, %ebp
movq 0xa898(%rip), %rsi      # 0x1efe8
movq 0xa889(%rip), %rdx      # 0x1efe0
movq %r14, %rdi
callq 0x3360
movq %rax, %rbx
leaq 0x10(%rsp), %rax
jmp 0x14773
jmp 0x14788
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x14781
callq 0x32f0
testb %bpl, %bpl
jne 0x1478b
jmp 0x14793
movq %rax, %rbx
movq %r14, %rdi
callq 0x34f0
movq %rbx, %rdi
callq 0x3370
nop
// File: /workspace/github_cpp_makefile_star2_O3/nwieder[P]SSTS/src/Events/ChFlux_Rct_Evt.cpp
// Function: nw::ChFlux_Rct_Evt::update(double)
double ChFlux_Rct_Evt::update(double last_tau){

	double minTau = INFINITY;
	double actTau;

//	run through the tv vector
	for (long i = 0; i < (long) tv_vec.size(); i++) {
//		check for voxel that have been affected by last executed event
		if (tv_vec.at(i).v->get_dirty_flag()) {
			actTau = calc_tau(i);
//			find smallest tau value (->next voxel) for this event
			if (actTau < minTau) {
				minTau = actTau;
				nextVoxel = i;
			}
//		this voxel has not been affected by last event
		} else {
//			adjust tau value to global times scale
			tv_vec.at(i).t -= last_tau;
//			find smallest tau value (->next voxel) for this event
			if (tv_vec[i].t < minTau) {
				minTau = tv_vec[i].t;
				nextVoxel = i;
			}
		}
	}
	this->dirty_flag = false;

	return minTau;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, (%rsp)
movq %rdi, %rbx
movq 0x50(%rdi), %rax
movq 0x58(%rdi), %rcx
subq %rax, %rcx
movsd 0x1e0d0(%rip), %xmm1    # 0x24008
testq %rcx, %rcx
jle 0x5fa4
movl $0x8, %r15d
xorl %r14d, %r14d
movq -0x8(%rax,%r15), %rcx
cmpb $0x1, 0x20(%rcx)
jne 0x5f6a
movq %rbx, %rdi
movq %r14, %rsi
movsd %xmm1, 0x8(%rsp)
callq 0x5fba
movsd 0x8(%rsp), %xmm1
jmp 0x5f7b
movsd (%rax,%r15), %xmm0
subsd (%rsp), %xmm0
movsd %xmm0, (%rax,%r15)
ucomisd %xmm0, %xmm1
jbe 0x5f89
movq %r14, 0x70(%rbx)
movapd %xmm0, %xmm1
incq %r14
movq 0x50(%rbx), %rax
movq 0x58(%rbx), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
addq $0x10, %r15
cmpq %rcx, %r14
jl 0x5f46
movb $0x0, 0x80(%rbx)
movapd %xmm1, %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/nwieder[P]SSTS/src/Events/Diffusion_Evt.cpp
// Function: nw::Diffusion_Evt::init()
void Diffusion_Evt::init(){

//	calculate the correct diffusion probability constant according to the voxel volume
	this->c = (k*1e-3)/pow(tv_vec[0].v->get_box_length()*1e6,2);

//	build state change vector
	build_sc_vec();

//	update the first time
	update(0);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movsd 0x30(%rdi), %xmm0
mulsd 0x1de23(%rip), %xmm0    # 0x240a8
movq 0x50(%rdi), %rax
movq (%rax), %rax
movsd 0x10(%rax), %xmm1
mulsd 0x1de17(%rip), %xmm1    # 0x240b0
mulsd %xmm1, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x78(%rdi)
callq 0x62bc
movq (%rbx), %rax
movq 0x10(%rax), %rax
xorpd %xmm0, %xmm0
movq %rbx, %rdi
popq %rbx
jmpq *%rax