LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Eshaancoding[P]AutoDiff/src/Variable/operations/max.cpp
// Function: max_op(Variable const&, Variable const&)
Variable max_op (const Variable &left, const Variable &right) {
    Variable new_var = Variable(false);
    new_var.operation = op::max;
    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
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movl $0x1, %esi
movl %esi, -0x2c(%rbp)
callq 0x4a60
movq -0x40(%rbp), %rdi
movl $0x9, 0x8(%rdi)
movl $0x30, %edi
callq 0x21c0
movsd -0x38(%rbp), %xmm0
movl -0x2c(%rbp), %esi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
callq 0x4a60
jmp 0x992e
movq -0x40(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl $0x30, %edi
callq 0x21c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
xorps %xmm0, %xmm0
movl $0x1, %esi
callq 0x4a60
jmp 0x995d
movq -0x40(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rsi
movq 0x10(%rax), %rdi
movl $0x30, %edx
callq 0x2170
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rsi
movq 0x18(%rax), %rdi
movl $0x30, %edx
callq 0x2170
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x21a0
jmp 0x99c7
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x21a0
movq -0x18(%rbp), %rdi
callq 0x2280
// File: Eshaancoding[P]AutoDiff/src/Variable/operations/max.cpp
// Function: max_op(Variable const&, double const&)
Variable max_op (const Variable &left, const double &right) {
    Variable new_var = Variable(false);
    new_var.operation = op::max;
    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
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movl $0x1, %esi
movl %esi, -0x2c(%rbp)
callq 0x4a60
movq -0x40(%rbp), %rdi
movl $0x9, 0x8(%rdi)
movl $0x30, %edi
callq 0x21c0
movsd -0x38(%rbp), %xmm0
movl -0x2c(%rbp), %esi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
callq 0x4a60
jmp 0x9ade
movq -0x40(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rcx
movq 0x10(%rax), %rax
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups 0x20(%rcx), %xmm2
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movl $0x30, %edi
callq 0x21c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
xorps %xmm0, %xmm0
movl $0x1, %esi
callq 0x4a60
jmp 0x9b2b
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rcx
movq -0x50(%rbp), %rdx
movq %rdx, 0x18(%rcx)
movq -0x10(%rbp), %rdx
movsd (%rdx), %xmm0
movq 0x18(%rcx), %rdx
movsd %xmm0, (%rdx)
movq 0x18(%rcx), %rcx
movl $0x1, 0x8(%rcx)
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x21a0
jmp 0x9b88
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x21a0
movq -0x18(%rbp), %rdi
callq 0x2280
nopw %cs:(%rax,%rax)
// File: Eshaancoding[P]AutoDiff/src/Variable/operations/max.cpp
// Function: max_op(Variable&, Variable&)
Variable max_op (Variable &left, Variable &right) {
    Variable new_var = Variable(false);
    new_var.operation = op::max;
    new_var.child[0] = &left; 
    new_var.child[1] = &right;
    return new_var;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
movq %rax, -0x18(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
xorps %xmm0, %xmm0
movl $0x1, %esi
callq 0x4a60
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movl $0x9, 0x8(%rdi)
movq -0x8(%rbp), %rcx
movq %rcx, 0x10(%rdi)
movq -0x10(%rbp), %rcx
movq %rcx, 0x18(%rdi)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Eshaancoding[P]AutoDiff/src/Variable/operations/max.cpp
// Function: max_op(double const&, Variable const&)
Variable max_op (const double &left, const Variable &right) {
    Variable new_var = Variable(false);
    new_var.operation = op::max;
    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
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movl $0x1, %esi
movl %esi, -0x2c(%rbp)
callq 0x4a60
movq -0x40(%rbp), %rdi
movl $0x9, 0x8(%rdi)
movl $0x30, %edi
callq 0x21c0
movsd -0x38(%rbp), %xmm0
movl -0x2c(%rbp), %esi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
callq 0x4a60
jmp 0x9dbe
movq -0x40(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rcx
movsd (%rcx), %xmm0
movq 0x10(%rax), %rcx
movsd %xmm0, (%rcx)
movq 0x10(%rax), %rax
movl $0x1, 0x8(%rax)
movl $0x30, %edi
callq 0x21c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
xorps %xmm0, %xmm0
movl $0x1, %esi
callq 0x4a60
jmp 0x9e08
movq -0x40(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rsi
movq 0x18(%rax), %rdi
movl $0x30, %edx
callq 0x2170
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x21a0
jmp 0x9e5c
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x21a0
movq -0x18(%rbp), %rdi
callq 0x2280
nopw %cs:(%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movl $0x1, %esi
movl %esi, -0x2c(%rbp)
callq 0x4a60
movq -0x40(%rbp), %rdi
movl $0x8, 0x8(%rdi)
movl $0x30, %edi
callq 0x21c0
movsd -0x38(%rbp), %xmm0
movl -0x2c(%rbp), %esi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
callq 0x4a60
jmp 0x9f8e
movq -0x40(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl $0x30, %edi
callq 0x21c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
xorps %xmm0, %xmm0
movl $0x1, %esi
callq 0x4a60
jmp 0x9fbd
movq -0x40(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rsi
movq 0x10(%rax), %rdi
movl $0x30, %edx
callq 0x2170
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rsi
movq 0x18(%rax), %rdi
movl $0x30, %edx
callq 0x2170
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x21a0
jmp 0xa027
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x21a0
movq -0x18(%rbp), %rdi
callq 0x2280
// File: 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
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movl 0x8(%rax), %esi
leaq -0x10(%rbp), %rdi
callq 0xb250
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0xb3c3
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movslq -0x1c(%rbp), %rax
imulq $0x30, %rax, %rax
addq %rax, %rdi
movl $0x1, %esi
callq 0x4ce0
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movl $0x1, 0x8(%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xb367
movq -0x10(%rbp), %rax
movl -0x8(%rbp), %edx
addq $0x30, %rsp
popq %rbp
retq
// File: 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
subq $0x90, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0x8(%rcx), %eax
je 0xba16
movl $0x10, %edi
callq 0x20c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x78(%rbp)
leaq 0x3873(%rip), %rsi      # 0xf251
callq 0x22c0
jmp 0xb9e5
movq -0x78(%rbp), %rdi
movq 0x95f0(%rip), %rsi      # 0x14fe0
movq 0x95d9(%rip), %rdx      # 0x14fd0
callq 0x2240
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x2150
jmp 0xbb58
movq -0x18(%rbp), %rax
movl 0x8(%rax), %esi
leaq -0x10(%rbp), %rdi
callq 0xb250
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0xbb48
movl $0x10, %edi
callq 0x21c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq -0x20(%rbp), %rax
movl 0x8(%rax), %esi
callq 0xb250
jmp 0xba5f
movq -0x80(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x10, %edi
callq 0x21c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %esi
callq 0xb250
jmp 0xba8c
movq -0x88(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rcx
movq -0x38(%rbp), %rax
movq (%rcx), %rdx
movq %rdx, (%rax)
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x40(%rbp), %rax
movq (%rcx), %rdx
movq %rdx, (%rax)
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq -0x38(%rbp), %rax
movq (%rax), %rsi
movslq -0x30(%rbp), %rax
imulq $0x30, %rax, %rax
addq %rax, %rsi
movq -0x40(%rbp), %rax
movq (%rax), %rdx
movslq -0x30(%rbp), %rax
imulq $0x30, %rax, %rax
addq %rax, %rdx
leaq -0x70(%rbp), %rdi
callq 0x7fa0
movq -0x10(%rbp), %rdi
movslq -0x30(%rbp), %rax
imulq $0x30, %rax, %rax
addq %rax, %rdi
leaq -0x70(%rbp), %rsi
movl $0x30, %edx
callq 0x2170
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0xba2d
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x21a0
jmp 0xbb58
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x21a0
jmp 0xbb58
movq -0x10(%rbp), %rax
movl -0x8(%rbp), %edx
addq $0x90, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x2280
nopw %cs:(%rax,%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0x8(%rcx), %eax
je 0xbbe6
movl $0x10, %edi
callq 0x20c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x70(%rbp)
leaq 0x36a3(%rip), %rsi      # 0xf251
callq 0x22c0
jmp 0xbbb5
movq -0x70(%rbp), %rdi
movq 0x9420(%rip), %rsi      # 0x14fe0
movq 0x9409(%rip), %rdx      # 0x14fd0
callq 0x2240
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x2150
jmp 0xbcca
movq -0x18(%rbp), %rax
movl 0x8(%rax), %esi
leaq -0x10(%rbp), %rdi
callq 0xb250
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0xbcba
movl $0x10, %edi
callq 0x21c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq -0x20(%rbp), %rax
movl 0x8(%rax), %esi
callq 0xb250
jmp 0xbc2f
movq -0x78(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rcx
movq -0x38(%rbp), %rax
movq (%rcx), %rdx
movq %rdx, (%rax)
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq -0x38(%rbp), %rax
movq (%rax), %rsi
movslq -0x30(%rbp), %rax
imulq $0x30, %rax, %rax
addq %rax, %rsi
movq -0x20(%rbp), %rax
movq (%rax), %rdx
movslq -0x30(%rbp), %rax
imulq $0x30, %rax, %rax
addq %rax, %rdx
leaq -0x68(%rbp), %rdi
callq 0x7fa0
movq -0x10(%rbp), %rdi
movslq -0x30(%rbp), %rax
imulq $0x30, %rax, %rax
addq %rax, %rdi
leaq -0x68(%rbp), %rsi
movl $0x30, %edx
callq 0x2170
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0xbbfd
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x21a0
jmp 0xbcca
movq -0x10(%rbp), %rax
movl -0x8(%rbp), %edx
addq $0x80, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x2280
nopw %cs:(%rax,%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %esi
leaq -0x10(%rbp), %rdi
callq 0xb250
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0xbdb9
movl $0x10, %edi
callq 0x21c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %esi
callq 0xb250
jmp 0xbd3c
movq -0x78(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq (%rcx), %rdx
movq %rdx, (%rax)
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq -0x30(%rbp), %rax
movq (%rax), %rsi
movslq -0x24(%rbp), %rax
imulq $0x30, %rax, %rax
addq %rax, %rsi
movq -0x20(%rbp), %rdx
leaq -0x70(%rbp), %rdi
callq 0x7ff0
movq -0x10(%rbp), %rdi
movslq -0x24(%rbp), %rax
imulq $0x30, %rax, %rax
addq %rax, %rdi
leaq -0x70(%rbp), %rsi
movl $0x30, %edx
callq 0x2170
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xbd0a
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x21a0
jmp 0xbdc9
movq -0x10(%rbp), %rax
movl -0x8(%rbp), %edx
addq $0x80, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x2280
nopw %cs:(%rax,%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0x8(%rcx), %eax
je 0xbe56
movl $0x10, %edi
callq 0x20c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x70(%rbp)
leaq 0x3433(%rip), %rsi      # 0xf251
callq 0x22c0
jmp 0xbe25
movq -0x70(%rbp), %rdi
movq 0x91b0(%rip), %rsi      # 0x14fe0
movq 0x9199(%rip), %rdx      # 0x14fd0
callq 0x2240
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x2150
jmp 0xbf3a
movq -0x18(%rbp), %rax
movl 0x8(%rax), %esi
leaq -0x10(%rbp), %rdi
callq 0xb250
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0xbf2a
movl $0x10, %edi
callq 0x21c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq -0x20(%rbp), %rax
movl 0x8(%rax), %esi
callq 0xb250
jmp 0xbe9f
movq -0x78(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
movq (%rcx), %rdx
movq %rdx, (%rax)
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movslq -0x30(%rbp), %rax
imulq $0x30, %rax, %rax
addq %rax, %rsi
movq -0x38(%rbp), %rax
movq (%rax), %rdx
movslq -0x30(%rbp), %rax
imulq $0x30, %rax, %rax
addq %rax, %rdx
leaq -0x68(%rbp), %rdi
callq 0x7fa0
movq -0x10(%rbp), %rdi
movslq -0x30(%rbp), %rax
imulq $0x30, %rax, %rax
addq %rax, %rdi
leaq -0x68(%rbp), %rsi
movl $0x30, %edx
callq 0x2170
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0xbe6d
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x21a0
jmp 0xbf3a
movq -0x10(%rbp), %rax
movl -0x8(%rbp), %edx
addq $0x80, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x2280
nopw %cs:(%rax,%rax)
// File: 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
subq $0x70, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0x8(%rcx), %eax
je 0xbfc3
movl $0x10, %edi
callq 0x20c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x68(%rbp)
leaq 0x32c6(%rip), %rsi      # 0xf251
callq 0x22c0
jmp 0xbf92
movq -0x68(%rbp), %rdi
movq 0x9043(%rip), %rsi      # 0x14fe0
movq 0x902c(%rip), %rdx      # 0x14fd0
callq 0x2240
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x2150
jmp 0xc048
movq -0x18(%rbp), %rax
movl 0x8(%rax), %esi
leaq -0x10(%rbp), %rdi
callq 0xb250
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0xc03b
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movslq -0x30(%rbp), %rax
imulq $0x30, %rax, %rax
addq %rax, %rsi
movq -0x20(%rbp), %rax
movq (%rax), %rdx
movslq -0x30(%rbp), %rax
imulq $0x30, %rax, %rax
addq %rax, %rdx
leaq -0x60(%rbp), %rdi
callq 0x7fa0
movq -0x10(%rbp), %rdi
movslq -0x30(%rbp), %rax
imulq $0x30, %rax, %rax
addq %rax, %rdi
leaq -0x60(%rbp), %rsi
movl $0x30, %edx
callq 0x2170
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0xbfda
movq -0x10(%rbp), %rax
movl -0x8(%rbp), %edx
addq $0x70, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x2280
nopw %cs:(%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %esi
leaq -0x10(%rbp), %rdi
callq 0xb250
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0xc0da
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movslq -0x24(%rbp), %rax
imulq $0x30, %rax, %rax
addq %rax, %rsi
movq -0x20(%rbp), %rdx
leaq -0x58(%rbp), %rdi
callq 0x7ff0
movq -0x10(%rbp), %rdi
movslq -0x24(%rbp), %rax
imulq $0x30, %rax, %rax
addq %rax, %rdi
leaq -0x58(%rbp), %rsi
movl $0x30, %edx
callq 0x2170
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xc087
movq -0x10(%rbp), %rax
movl -0x8(%rbp), %edx
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x8(%rax), %esi
leaq -0x10(%rbp), %rdi
callq 0xb250
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0xc1c9
movl $0x10, %edi
callq 0x21c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq -0x20(%rbp), %rax
movl 0x8(%rax), %esi
callq 0xb250
jmp 0xc14c
movq -0x78(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq (%rcx), %rdx
movq %rdx, (%rax)
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rax
movq (%rax), %rdx
movslq -0x24(%rbp), %rax
imulq $0x30, %rax, %rax
addq %rax, %rdx
leaq -0x70(%rbp), %rdi
callq 0x81c0
movq -0x10(%rbp), %rdi
movslq -0x24(%rbp), %rax
imulq $0x30, %rax, %rax
addq %rax, %rdi
leaq -0x70(%rbp), %rsi
movl $0x30, %edx
callq 0x2170
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xc11a
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x21a0
jmp 0xc1d9
movq -0x10(%rbp), %rax
movl -0x8(%rbp), %edx
addq $0x80, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x2280
nopw %cs:(%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x8(%rax), %esi
leaq -0x10(%rbp), %rdi
callq 0xb250
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0xc26a
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rax
movq (%rax), %rdx
movslq -0x24(%rbp), %rax
imulq $0x30, %rax, %rax
addq %rax, %rdx
leaq -0x58(%rbp), %rdi
callq 0x81c0
movq -0x10(%rbp), %rdi
movslq -0x24(%rbp), %rax
imulq $0x30, %rax, %rax
addq %rax, %rdi
leaq -0x58(%rbp), %rsi
movl $0x30, %edx
callq 0x2170
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xc217
movq -0x10(%rbp), %rax
movl -0x8(%rbp), %edx
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x130, %rsp            # imm = 0x130
leaq -0x10(%rbp), %rdi
movq %rdi, -0x110(%rbp)
movl $0x2, %esi
movl %esi, -0x124(%rbp)
callq 0xb250
movq -0x110(%rbp), %rdi
movabsq $0x4018000000000000, %rax # imm = 0x4018000000000000
movq %rax, -0x30(%rbp)
movabsq $0x4040000000000000, %rax # imm = 0x4040000000000000
movq %rax, -0x28(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x2, -0x18(%rbp)
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xcb60
movl -0x124(%rbp), %esi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x130(%rbp)
callq 0xb250
movq -0x130(%rbp), %rdi
movabsq $0x4008000000000000, %rax # imm = 0x4008000000000000
movq %rax, -0x118(%rbp)
movq %rax, -0x60(%rbp)
movabsq $0x4014000000000000, %rax # imm = 0x4014000000000000
movq %rax, -0x58(%rbp)
leaq -0x60(%rbp), %rax
movq %rax, -0x50(%rbp)
movq $0x2, -0x48(%rbp)
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0xcb60
movl -0x124(%rbp), %esi
leaq -0x70(%rbp), %rdi
movq %rdi, -0x120(%rbp)
callq 0xb250
movq -0x120(%rbp), %rdi
movabsq $0x4000000000000000, %rax # imm = 0x4000000000000000
movq %rax, -0x90(%rbp)
movabsq $0x4020000000000000, %rax # imm = 0x4020000000000000
movq %rax, -0x88(%rbp)
leaq -0x90(%rbp), %rax
movq %rax, -0x80(%rbp)
movq $0x2, -0x78(%rbp)
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdx
callq 0xcb60
movq -0x118(%rbp), %rax
movq -0x110(%rbp), %rsi
movq %rax, -0xb8(%rbp)
movq %rsi, %rdi
callq 0xd280
movq -0x110(%rbp), %rsi
movl %edx, -0xe0(%rbp)
movq %rax, -0xe8(%rbp)
movl -0xe0(%rbp), %eax
movl %eax, -0xd0(%rbp)
movq -0xe8(%rbp), %rax
movq %rax, -0xd8(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0xcea0
movl %edx, -0xf0(%rbp)
movq %rax, -0xf8(%rbp)
movl -0xf0(%rbp), %eax
movl %eax, -0xc0(%rbp)
movq -0xf8(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq -0xb8(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
callq 0xd420
movl %edx, -0x100(%rbp)
movq %rax, -0x108(%rbp)
movq -0x108(%rbp), %rax
movq %rax, -0xb0(%rbp)
movl -0x100(%rbp), %eax
movl %eax, -0xa8(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0xb3d0
movq %rax, -0xa0(%rbp)
movq %rdx, -0x98(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x2b70
xorl %eax, %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl -0x4(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x1d910
movq -0x18(%rbp), %rsi
movl $0x7, %edi
callq 0x1d910
movq -0x20(%rbp), %rdi
callq 0x4270
movl %eax, %edi
movq -0x18(%rbp), %rsi
callq 0x1d910
movq -0x10(%rbp), %rdi
callq 0x4270
movl %eax, %edi
movq -0x18(%rbp), %rsi
callq 0x1d910
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdi
callq 0x40b0
movq -0x28(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4100
movq %rax, %rdi
leaq 0x125c8(%rip), %rsi     # 0x314ae
callq 0x42d0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1ef8a
movb $0x1, -0x45(%rbp)
movl $0x10, %edi
callq 0x42f0
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rdx
leaq 0x1259b(%rip), %rsi     # 0x314b2
leaq -0x38(%rbp), %rdi
callq 0x22dc0
jmp 0x1ef22
movq -0x80(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x4230
jmp 0x1ef31
movq -0x80(%rbp), %rdi
movb $0x0, -0x45(%rbp)
movq 0x1b0a0(%rip), %rsi     # 0x39fe0
movq 0x1b091(%rip), %rdx     # 0x39fd8
callq 0x4430
jmp 0x1f0c7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x1ef74
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4540
testb $0x1, -0x45(%rbp)
jne 0x1ef7c
jmp 0x1ef85
movq -0x80(%rbp), %rdi
callq 0x4630
jmp 0x1f0be
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl %eax, %edx
callq 0x4660
cltq
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x50(%rbp)
jne 0x1f04e
movb $0x1, -0x71(%rbp)
movl $0x10, %edi
callq 0x42f0
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rdx
leaq 0x124fa(%rip), %rsi     # 0x314cf
leaq -0x70(%rbp), %rdi
callq 0x22dc0
jmp 0x1efe0
movq -0x88(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x4230
jmp 0x1eff2
movq -0x88(%rbp), %rdi
movb $0x0, -0x71(%rbp)
movq 0x1afdc(%rip), %rsi     # 0x39fe0
movq 0x1afcd(%rip), %rdx     # 0x39fd8
callq 0x4430
jmp 0x1f0c7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x1f038
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x4540
testb $0x1, -0x71(%rbp)
jne 0x1f040
jmp 0x1f04c
movq -0x88(%rbp), %rdi
callq 0x4630
jmp 0x1f0be
movq -0x18(%rbp), %rdi
callq 0x4640
cmpl $0x0, %eax
je 0x1f0b5
movl $0x10, %edi
callq 0x42f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x90(%rbp)
leaq 0x1247a(%rip), %rsi     # 0x314f4
callq 0x41f0
jmp 0x1f081
movq -0x90(%rbp), %rdi
movq 0x1af51(%rip), %rsi     # 0x39fe0
movq 0x1af42(%rip), %rdx     # 0x39fd8
callq 0x4430
movq -0x90(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x4630
jmp 0x1f0be
addq $0x90, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x4440
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x42a0
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x1f179
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x29(%rbp)
movzbl -0x29(%rbp), %eax
shrl $0x4, %eax
leaq 0x1b306(%rip), %rcx     # 0x3a430
movsbl (%rax,%rcx), %esi
callq 0x4490
jmp 0x1f135
movq -0x50(%rbp), %rdi
movzbl -0x29(%rbp), %eax
andl $0xf, %eax
leaq 0x1b2e9(%rip), %rcx     # 0x3a430
movsbl (%rax,%rcx), %esi
callq 0x4490
jmp 0x1f152
jmp 0x1f154
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x1f100
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x4540
jmp 0x1f196
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x1f18c
movq -0x50(%rbp), %rdi
callq 0x4540
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x4440
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0xf8(%rbp)
movq %rdi, %rax
movq %rax, -0xf0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x22ed0
movq -0x10(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x1db80
jmp 0x1f758
movb $0x0, -0x65(%rbp)
movq -0x18(%rbp), %rsi
leaq 0x11de8(%rip), %rdx     # 0x3154f
leaq -0x88(%rbp), %rdi
callq 0x23340
jmp 0x1f775
movq -0xf8(%rbp), %rdi
movq -0x20(%rbp), %r8
leaq -0x58(%rbp), %rsi
leaq -0x38(%rbp), %rdx
leaq -0x88(%rbp), %rcx
callq 0x1f1a0
jmp 0x1f796
leaq -0x88(%rbp), %rdi
callq 0x4540
movq -0x10(%rbp), %rdi
movq %rdi, -0x108(%rbp)
addq $0x168, %rdi            # imm = 0x168
leaq 0x11cef(%rip), %rsi     # 0x314aa
callq 0x21e20
movb %al, -0xf9(%rbp)
jmp 0x1f7c8
movb -0xf9(%rbp), %al
movzbl %al, %edi
andl $0x1, %edi
callq 0x44a0
movq -0x108(%rbp), %rsi
movzwl %ax, %edx
leaq -0xa8(%rbp), %rdi
callq 0x1d7a0
jmp 0x1f7f1
movq -0x20(%rbp), %rdx
leaq -0xe8(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x23410
jmp 0x1f80a
leaq -0xc8(%rbp), %rdi
leaq -0xe8(%rbp), %rsi
leaq -0x58(%rbp), %rdx
callq 0x233c0
jmp 0x1f823
movq -0x20(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
callq 0x43a0
leaq -0xc8(%rbp), %rdi
callq 0x4540
leaq -0xe8(%rbp), %rdi
callq 0x4540
movb $0x1, -0x65(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x4540
testb $0x1, -0x65(%rbp)
jne 0x1f8f1
jmp 0x1f8e5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x1f928
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x1f91f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x4540
jmp 0x1f91f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x1f913
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x1f8d7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0xe8(%rbp), %rdi
callq 0x4540
leaq -0xa8(%rbp), %rdi
callq 0x4540
jmp 0x1f913
movq -0xf8(%rbp), %rdi
callq 0x232f0
leaq -0x58(%rbp), %rdi
callq 0x4540
leaq -0x38(%rbp), %rdi
callq 0x232f0
movq -0xf0(%rbp), %rax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
movq -0xf8(%rbp), %rdi
callq 0x232f0
leaq -0x58(%rbp), %rdi
callq 0x4540
leaq -0x38(%rbp), %rdi
callq 0x232f0
movq -0x60(%rbp), %rdi
callq 0x4440
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x4b0, %rsp            # imm = 0x4B0
movq %rdi, -0x498(%rbp)
movq %rdi, %rax
movq %rax, -0x490(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %edi
leaq -0x440(%rbp), %rdx
leaq -0x40(%rbp), %rsi
movl $0x400, %ecx            # imm = 0x400
leaq -0x448(%rbp), %r8
callq 0x4500
leaq -0x468(%rbp), %rdi
callq 0x42a0
cmpq $0x0, -0x448(%rbp)
jne 0x1fa05
leaq -0x469(%rbp), %rdi
movq %rdi, -0x4a0(%rbp)
callq 0x46c0
movq -0x498(%rbp), %rdi
movq -0x4a0(%rbp), %rdx
leaq 0x11b93(%rip), %rsi     # 0x31553
callq 0x45f0
jmp 0x1f9c7
leaq -0x469(%rbp), %rdi
callq 0x4820
movl $0x1, -0x480(%rbp)
jmp 0x1fa7d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x478(%rbp)
movl %eax, -0x47c(%rbp)
leaq -0x469(%rbp), %rdi
callq 0x4820
jmp 0x1fa99
movq -0x448(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x4b0(%rbp)
leaq -0x481(%rbp), %rdi
movq %rdi, -0x4a8(%rbp)
callq 0x46c0
movq -0x498(%rbp), %rdi
movq -0x4b0(%rbp), %rsi
movq -0x4a8(%rbp), %rdx
callq 0x45f0
jmp 0x1fa45
leaq -0x481(%rbp), %rdi
callq 0x4820
movl $0x1, -0x480(%rbp)
jmp 0x1fa7d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x478(%rbp)
movl %eax, -0x47c(%rbp)
leaq -0x481(%rbp), %rdi
callq 0x4820
jmp 0x1fa99
leaq -0x468(%rbp), %rdi
callq 0x4540
movq -0x490(%rbp), %rax
addq $0x4b0, %rsp            # imm = 0x4B0
popq %rbp
retq
leaq -0x468(%rbp), %rdi
callq 0x4540
movq -0x478(%rbp), %rdi
callq 0x4440
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x480, %rsp            # imm = 0x480
movq %rdi, -0x460(%rbp)
movq %rdi, %rax
movq %rax, -0x458(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %edi
leaq -0x430(%rbp), %rdx
leaq -0x30(%rbp), %rsi
movl $0x400, %ecx            # imm = 0x400
leaq -0x438(%rbp), %r8
callq 0x45c0
cmpq $0x0, -0x438(%rbp)
jne 0x1fb6c
leaq -0x439(%rbp), %rdi
movq %rdi, -0x468(%rbp)
callq 0x46c0
movq -0x460(%rbp), %rdi
movq -0x468(%rbp), %rdx
leaq 0x11a1f(%rip), %rsi     # 0x31553
callq 0x45f0
jmp 0x1fb3b
leaq -0x439(%rbp), %rdi
callq 0x4820
jmp 0x1fbda
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x448(%rbp)
movl %eax, -0x44c(%rbp)
leaq -0x439(%rbp), %rdi
callq 0x4820
jmp 0x1fbea
movq -0x438(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x478(%rbp)
leaq -0x44d(%rbp), %rdi
movq %rdi, -0x470(%rbp)
callq 0x46c0
movq -0x460(%rbp), %rdi
movq -0x478(%rbp), %rsi
movq -0x470(%rbp), %rdx
callq 0x45f0
jmp 0x1fbac
leaq -0x44d(%rbp), %rdi
callq 0x4820
jmp 0x1fbda
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x448(%rbp)
movl %eax, -0x44c(%rbp)
leaq -0x44d(%rbp), %rdi
callq 0x4820
jmp 0x1fbea
movq -0x458(%rbp), %rax
addq $0x480, %rsp            # imm = 0x480
popq %rbp
retq
movq -0x448(%rbp), %rdi
callq 0x4440
nopw %cs:(%rax,%rax)
// File: ivan-tkatchev[P]makerpm/./rpmstruct.h
// Function: rpm::lead_t::lead_t(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
lead_t(const std::string& _name = "") {

        magic[0] = 0xed;
        magic[1] = 0xab;
        magic[2] = 0xee;
        magic[3] = 0xdb;
        major = 3;
        minor = 0;
        type = 0;
        archnum = 256;          // A big-endian 1.
        osnum = 256;            // A big-endian 1.
        signature_type = 1280;  // A big-endian 5. 

        ::strncpy(name, _name.c_str(), 65);
        name[65] = '\0';
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movb $-0x13, (%rax)
movb $-0x55, 0x1(%rax)
movb $-0x12, 0x2(%rax)
movb $-0x25, 0x3(%rax)
movb $0x3, 0x4(%rax)
movb $0x0, 0x5(%rax)
movw $0x0, 0x6(%rax)
movw $0x100, 0x8(%rax)       # imm = 0x100
movw $0x100, 0x4c(%rax)      # imm = 0x100
movw $0x500, 0x4e(%rax)      # imm = 0x500
addq $0xa, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4100
movq -0x20(%rbp), %rdi
movq %rax, %rsi
movl $0x41, %edx
callq 0x4140
movq -0x18(%rbp), %rax
movb $0x0, 0x4b(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x28(%rbp)
movl -0xc(%rbp), %edi
callq 0x1d910
movq -0x28(%rbp), %rsi
movb -0x19(%rbp), %cl
movl $0x6, %edi
movl $0x9, %eax
testb $0x1, %cl
cmovnel %eax, %edi
callq 0x1d910
movq -0x28(%rbp), %rdi
addq $0x20, %rdi
callq 0x4270
movq -0x28(%rbp), %rsi
movl %eax, %edi
callq 0x1d910
movq -0x28(%rbp), %rsi
movl $0x1, %edi
callq 0x1d910
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x20, %rdi
callq 0x40b0
movq -0x28(%rbp), %rdi
addq $0x20, %rdi
xorl %esi, %esi
callq 0x4490
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x40(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x20(%rbp)
movl -0xc(%rbp), %edi
callq 0x1d910
movq -0x20(%rbp), %rsi
movl $0x4, %edi
callq 0x1d910
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
callq 0x4270
movq %rax, %rcx
andq $0x3, %rcx
movl $0x4, %eax
subq %rcx, %rax
andq $0x3, %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jbe 0x21dc8
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
xorl %esi, %esi
callq 0x4490
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x21da4
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
callq 0x4270
movq -0x20(%rbp), %rsi
movl %eax, %edi
callq 0x1d910
movq -0x20(%rbp), %rsi
movl $0x1, %edi
callq 0x1d910
movq -0x20(%rbp), %rsi
movl -0x10(%rbp), %edi
addq $0x20, %rsi
callq 0x1d910
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x40(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: ivan-tkatchev[P]makerpm/makerpm.cc
// Function: Store::add(unsigned int, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
void add(uint32_t tag, const std::vector<std::string>& txt) {

        if (txt.empty())
            return;

        add_uint32(tag, index);
        add_uint32(rpm::index_t::entry_t::TYPE_STRING_ARRAY, index);
        add_uint32(store.size(), index);
        add_uint32(txt.size(), index);

        for (const std::string& t : txt) {
            store += t;
            store += '\0';
        }

        ++nentries;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x23850
testb $0x1, %al
jne 0x2207a
jmp 0x2207f
jmp 0x22142
movq -0x40(%rbp), %rsi
movl -0xc(%rbp), %edi
callq 0x1d910
movq -0x40(%rbp), %rsi
movl $0x8, %edi
callq 0x1d910
movq -0x40(%rbp), %rdi
addq $0x20, %rdi
callq 0x4270
movq -0x40(%rbp), %rsi
movl %eax, %edi
callq 0x1d910
movq -0x18(%rbp), %rdi
callq 0x24140
movq -0x40(%rbp), %rsi
movl %eax, %edi
callq 0x1d910
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x24160
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x24190
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x241c0
testb $0x1, %al
jne 0x220fa
jmp 0x22132
leaq -0x28(%rbp), %rdi
callq 0x24200
movq -0x40(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
addq $0x20, %rdi
callq 0x40b0
movq -0x40(%rbp), %rdi
addq $0x20, %rdi
xorl %esi, %esi
callq 0x4490
leaq -0x28(%rbp), %rdi
callq 0x24220
jmp 0x220e7
movq -0x40(%rbp), %rax
movq 0x40(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x40(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ivan-tkatchev[P]makerpm/makerpm.cc
// Function: Store::add(unsigned int, std::vector<unsigned int, std::allocator<unsigned int>> const&)
void add(uint32_t tag, const std::vector<uint32_t>& data) {

        if (data.empty())
            return;

        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(data.size(), index);

        for (uint32_t v : data) {
            add_uint32(v, store);
        }

        ++nentries;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0x24270
testb $0x1, %al
jne 0x2217a
jmp 0x2217f
jmp 0x2227b
movq -0x48(%rbp), %rsi
movl -0xc(%rbp), %edi
callq 0x1d910
movq -0x48(%rbp), %rsi
movl $0x4, %edi
callq 0x1d910
movq -0x48(%rbp), %rdi
addq $0x20, %rdi
callq 0x4270
movq %rax, %rcx
andq $0x3, %rcx
movl $0x4, %eax
subq %rcx, %rax
andq $0x3, %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jbe 0x221e1
movq -0x48(%rbp), %rdi
addq $0x20, %rdi
xorl %esi, %esi
callq 0x4490
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x221bd
movq -0x48(%rbp), %rdi
addq $0x20, %rdi
callq 0x4270
movq -0x48(%rbp), %rsi
movl %eax, %edi
callq 0x1d910
movq -0x18(%rbp), %rdi
callq 0x242b0
movq -0x48(%rbp), %rsi
movl %eax, %edi
callq 0x1d910
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x242d0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x24300
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x24330
testb $0x1, %al
jne 0x22242
jmp 0x2226b
leaq -0x30(%rbp), %rdi
callq 0x24370
movq -0x48(%rbp), %rsi
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %edi
addq $0x20, %rsi
callq 0x1d910
leaq -0x30(%rbp), %rdi
callq 0x24390
jmp 0x2222f
movq -0x48(%rbp), %rax
movq 0x40(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x40(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: ivan-tkatchev[P]makerpm/makerpm.cc
// Function: Store::add(unsigned int, std::vector<unsigned long, std::allocator<unsigned long>> const&)
void add(uint32_t tag, const std::vector<uint64_t>& data) {

        if (data.empty())
            return;

        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(data.size(), index);

        for (uint64_t v : data) {
            add_uint64(v, store);
        }

        ++nentries;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0x246c0
testb $0x1, %al
jne 0x2266a
jmp 0x2266f
jmp 0x22770
movq -0x48(%rbp), %rsi
movl -0xc(%rbp), %edi
callq 0x1d910
movq -0x48(%rbp), %rsi
movl $0x5, %edi
callq 0x1d910
movq -0x48(%rbp), %rdi
addq $0x20, %rdi
callq 0x4270
movq %rax, %rcx
andq $0x7, %rcx
movl $0x8, %eax
subq %rcx, %rax
andq $0x7, %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jbe 0x226d1
movq -0x48(%rbp), %rdi
addq $0x20, %rdi
xorl %esi, %esi
callq 0x4490
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x226ad
movq -0x48(%rbp), %rdi
addq $0x20, %rdi
callq 0x4270
movq -0x48(%rbp), %rsi
movl %eax, %edi
callq 0x1d910
movq -0x18(%rbp), %rdi
callq 0x24700
movq -0x48(%rbp), %rsi
movl %eax, %edi
callq 0x1d910
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x24720
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x24750
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x24780
testb $0x1, %al
jne 0x22732
jmp 0x22760
leaq -0x30(%rbp), %rdi
callq 0x247c0
movq -0x48(%rbp), %rsi
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movl %eax, %edi
addq $0x20, %rsi
callq 0x1d9b0
leaq -0x30(%rbp), %rdi
callq 0x247e0
jmp 0x2271f
movq -0x48(%rbp), %rax
movq 0x40(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x40(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)