LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: tbjohns[P]BlitzL1/src/common.cpp
// Function: BlitzL1::SparseColumnFromPointers::SparseColumnFromPointers(int*, double*, unsigned long, unsigned long)
SparseColumnFromPointers::SparseColumnFromPointers(
      index_t *indices, value_t *values, size_t nnz, size_t length) : Column()
  {
    this->indices = indices;
    this->values = values;
    this->nnz = nnz;
    this->length = length;
  }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xf570
movq 0x8(%rsp), %rax
movq 0x10ba0(%rip), %rcx     # 0x20fd8
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x28(%rsp), %rcx
movq %rcx, 0x28(%rax)
movq 0x20(%rsp), %rcx
movq %rcx, 0x30(%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rcx
movq %rcx, 0x8(%rax)
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: tbjohns[P]BlitzL1/src/common.cpp
// Function: BlitzL1::SparseColumnFromPointers::inner_product(std::vector<double, std::allocator<double>> const&) const
value_t SparseColumnFromPointers::inner_product(const vector<value_t> &vec) const
  {
    value_t result = 0.0;
    for (size_t ind = 0; ind < nnz; ++ind)
    {
      index_t i = indices[ind];
      result += values[ind] * vec[i];
    }
    return result;
  }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
cmpq 0x10(%rcx), %rax
jae 0x1050e
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rcx
movq 0x18(%rsp), %rdx
movl (%rcx,%rdx,4), %ecx
movl %ecx, 0x14(%rsp)
movq 0x30(%rax), %rax
movq 0x18(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rsp)
movq 0x28(%rsp), %rdi
movslq 0x14(%rsp), %rsi
callq 0xeee0
movsd (%rsp), %xmm0
movsd (%rax), %xmm2
movsd 0x20(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x1049a
movsd 0x20(%rsp), %xmm0
addq $0x38, %rsp
retq
nopl (%rax)
// File: tbjohns[P]BlitzL1/src/common.cpp
// Function: BlitzL1::SparseColumnFromPointers::weighted_inner_product(std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&) const
value_t SparseColumnFromPointers::weighted_inner_product(const std::vector<value_t> &vec, const std::vector<value_t> &weights) const
  {
    value_t result = 0.0;
    for (size_t ind = 0; ind < nnz; ++ind)
    {
      index_t i = indices[ind];
      result += values[ind] * vec[i] * weights[i];
    }
    return result;
  }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %rax
cmpq 0x10(%rcx), %rax
jae 0x105e9
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rcx
movq 0x20(%rsp), %rdx
movl (%rcx,%rdx,4), %ecx
movl %ecx, 0x1c(%rsp)
movq 0x30(%rax), %rax
movq 0x20(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rsp)
movq 0x38(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
callq 0xeee0
movsd (%rsp), %xmm0
mulsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
callq 0xeee0
movsd 0x8(%rsp), %xmm0
movsd (%rax), %xmm2
movsd 0x28(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rsp)
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x1054f
movsd 0x28(%rsp), %xmm0
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tbjohns[P]BlitzL1/src/common.cpp
// Function: BlitzL1::SparseColumnFromPointers::h_norm_sq(std::vector<double, std::allocator<double>> const&) const
value_t SparseColumnFromPointers::h_norm_sq(const vector<value_t> &h_values) const
  {
    value_t result = 0.0;
    for (size_t ind = 0; ind < nnz; ++ind)
    {
      index_t i = indices[ind];
      result += values[ind] * values[ind] * h_values[i];
    }
    return result;
  }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
cmpq 0x10(%rcx), %rax
jae 0x1075f
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rcx
movq 0x18(%rsp), %rdx
movl (%rcx,%rdx,4), %ecx
movl %ecx, 0x14(%rsp)
movq 0x30(%rax), %rcx
movq 0x18(%rsp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq 0x30(%rax), %rax
movq 0x18(%rsp), %rcx
mulsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rsp)
movq 0x28(%rsp), %rdi
movslq 0x14(%rsp), %rsi
callq 0xeee0
movsd (%rsp), %xmm0
movsd (%rax), %xmm2
movsd 0x20(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x106da
movsd 0x20(%rsp), %xmm0
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: tbjohns[P]BlitzL1/src/common.cpp
// Function: BlitzL1::sum_array(double const*, unsigned long)
value_t sum_array(const value_t *values, size_t length)
  {
    value_t result = 0.0;
    for (size_t ind = 0; ind < length; ++ind)
      result += values[ind];
    return result;
  }

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rsp)
movq $0x0, -0x20(%rsp)
movq -0x20(%rsp), %rax
cmpq -0x10(%rsp), %rax
jae 0x10823
movq -0x8(%rsp), %rax
movq -0x20(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
addsd -0x18(%rsp), %xmm0
movsd %xmm0, -0x18(%rsp)
movq -0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rsp)
jmp 0x107ec
movsd -0x18(%rsp), %xmm0
retq
nopw (%rax,%rax)
// File: tbjohns[P]BlitzL1/src/common.cpp
// Function: BlitzL1::l2_norm_sq(double const*, unsigned long)
value_t l2_norm_sq(const value_t *values, size_t length)
  {
    value_t result = 0.0;
    for (size_t ind = 0; ind < length; ++ind)
      result += values[ind] * values[ind];
    return result;
  }

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rsp)
movq $0x0, -0x20(%rsp)
movq -0x20(%rsp), %rax
cmpq -0x10(%rsp), %rax
jae 0x108ba
movq -0x8(%rsp), %rax
movq -0x20(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x8(%rsp), %rax
movq -0x20(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm2
movsd -0x18(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rsp)
movq -0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rsp)
jmp 0x1086c
movsd -0x18(%rsp), %xmm0
retq
nopw %cs:(%rax,%rax)
// File: tbjohns[P]BlitzL1/src/common.cpp
// Function: BlitzL1::DenseColumnFromPointers::inner_product(std::vector<double, std::allocator<double>> const&) const
value_t DenseColumnFromPointers::inner_product(const vector<value_t> &vec) const
  {
    value_t result = 0.0;
    for (size_t i = 0; i < length; ++i)
      result += values[i] * vec[i];
    return result;
  }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
cmpq 0x8(%rcx), %rax
jae 0x109c0
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rax
movq 0x18(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xeee0
movsd 0x8(%rsp), %xmm0
movsd (%rax), %xmm2
movsd 0x20(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x1095a
movsd 0x20(%rsp), %xmm0
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: tbjohns[P]BlitzL1/src/common.cpp
// Function: BlitzL1::DenseColumnFromPointers::weighted_inner_product(std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&) const
value_t DenseColumnFromPointers::weighted_inner_product(const std::vector<value_t> &vec, const std::vector<value_t> &weights) const
  {
    value_t result = 0.0;
    for (size_t i = 0; i < length; ++i)
      result += values[i] * vec[i] * weights[i];
    return result;
  }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rax
cmpq 0x8(%rcx), %rax
jae 0x10a87
movq 0x18(%rsp), %rax
movq 0x28(%rax), %rax
movq 0x20(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xeee0
movsd 0x8(%rsp), %xmm0
mulsd (%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xeee0
movsd 0x10(%rsp), %xmm0
movsd (%rax), %xmm2
movsd 0x28(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rsp)
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x109ff
movsd 0x28(%rsp), %xmm0
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tbjohns[P]BlitzL1/src/common.cpp
// Function: BlitzL1::DenseColumnFromPointers::h_norm_sq(std::vector<double, std::allocator<double>> const&) const
value_t DenseColumnFromPointers::h_norm_sq(const vector<value_t> &h_values) const
  {
    value_t result = 0.0;
    for (size_t i = 0; i < length; ++i)
      result += values[i] * values[i] * h_values[i];
    return result;
  }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
cmpq 0x8(%rcx), %rax
jae 0x10bde
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rcx
movq 0x18(%rsp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq 0x28(%rax), %rax
movq 0x18(%rsp), %rcx
mulsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xeee0
movsd 0x8(%rsp), %xmm0
movsd (%rax), %xmm2
movsd 0x20(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x10b6a
movsd 0x20(%rsp), %xmm0
addq $0x38, %rsp
retq
nopl (%rax)
// File: tbjohns[P]BlitzL1/src/common.cpp
// Function: BlitzL1::DatasetFromCSCPointers::DatasetFromCSCPointers(int*, int*, double*, double*, unsigned long, unsigned long, unsigned long)
DatasetFromCSCPointers::DatasetFromCSCPointers(index_t *indices,
                                                 index_t *indptr,
                                                 value_t *data,
                                                 value_t *labels,
                                                 size_t n,
                                                 size_t d,
                                                 size_t nnz)
  {
    this->n = n;
    this->d = d;
    this->nnz = nnz;
    this->labels = labels;
    columns_vec.clear();
    columns_vec.reserve(d);
    for (size_t j = 0; j < this->d; ++j)
    {
      index_t offset = indptr[j];
      index_t col_nnz = (size_t)(indptr[j + 1] - offset);
      value_t *col_data = data + offset;
      index_t *col_indices = indices + offset;
      Column *col = new SparseColumnFromPointers(col_indices, col_data, col_nnz, n);
      columns_vec.push_back(col);
    }
  }

// Assembly:
subq $0x78, %rsp
movq 0x88(%rsp), %rax
movq 0x80(%rsp), %rax
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movq %r8, 0x50(%rsp)
movq %r9, 0x48(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xeb00
movq 0x8(%rsp), %rdi
movq 0x48(%rsp), %rax
movq %rax, 0x18(%rdi)
movq 0x80(%rsp), %rax
movq %rax, 0x20(%rdi)
movq 0x88(%rsp), %rax
movq %rax, 0x28(%rdi)
movq 0x50(%rsp), %rax
movq %rax, 0x30(%rdi)
callq 0xf550
movq 0x8(%rsp), %rdi
movq 0x80(%rsp), %rsi
callq 0xe960
jmp 0x10d19
movq $0x0, 0x30(%rsp)
movq 0x8(%rsp), %rcx
movq 0x30(%rsp), %rax
cmpq 0x20(%rcx), %rax
jae 0x10e11
movq 0x60(%rsp), %rax
movq 0x30(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0x2c(%rsp)
movq 0x60(%rsp), %rax
movq 0x30(%rsp), %rcx
movl 0x4(%rax,%rcx,4), %eax
movl 0x2c(%rsp), %ecx
subl %ecx, %eax
movl %eax, 0x28(%rsp)
movq 0x58(%rsp), %rax
movslq 0x2c(%rsp), %rcx
leaq (%rax,%rcx,8), %rax
movq %rax, 0x20(%rsp)
movq 0x68(%rsp), %rax
movslq 0x2c(%rsp), %rcx
leaq (%rax,%rcx,4), %rax
movq %rax, 0x18(%rsp)
movl $0x38, %edi
callq 0xeb70
movq %rax, (%rsp)
jmp 0x10d95
movq (%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
movslq 0x28(%rsp), %rcx
movq 0x48(%rsp), %r8
callq 0xe970
jmp 0x10db4
movq 0x8(%rsp), %rdi
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x10(%rsp), %rsi
callq 0xefb0
jmp 0x10dce
jmp 0x10dd0
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x10d22
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x10e16
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
movl $0x38, %esi
callq 0xebb0
jmp 0x10e16
addq $0x78, %rsp
retq
movq 0x8(%rsp), %rdi
callq 0xe2c0
movq 0x40(%rsp), %rdi
callq 0xf590
nopw (%rax,%rax)
// File: tbjohns[P]BlitzL1/src/common.cpp
// Function: BlitzL1::DatasetFromFContiguousPointer::DatasetFromFContiguousPointer(double*, double*, unsigned long, unsigned long)
DatasetFromFContiguousPointer::DatasetFromFContiguousPointer(
      value_t *data, value_t *labels, size_t n, size_t d)
  {
    this->n = n;
    this->d = d;
    this->nnz = n * d;
    this->labels = labels;
    columns_vec.clear();
    columns_vec.reserve(d);
    for (size_t j = 0; j < d; ++j)
    {
      value_t *col_data = data + j * n;
      Column *col = new DenseColumnFromPointers(col_data, n);
      columns_vec.push_back(col);
    }
  }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xeb00
movq 0x10(%rsp), %rdi
movq 0x48(%rsp), %rax
movq %rax, 0x18(%rdi)
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rdi)
movq 0x48(%rsp), %rax
movq 0x40(%rsp), %rcx
imulq %rcx, %rax
movq %rax, 0x28(%rdi)
movq 0x50(%rsp), %rax
movq %rax, 0x30(%rdi)
callq 0xf550
movq 0x10(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0xe960
jmp 0x10ea4
movq $0x0, 0x28(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x40(%rsp), %rax
jae 0x10f5b
movq 0x58(%rsp), %rax
movq 0x28(%rsp), %rcx
movq 0x48(%rsp), %rdx
imulq %rdx, %rcx
leaq (%rax,%rcx,8), %rax
movq %rax, 0x20(%rsp)
movl $0x30, %edi
callq 0xeb70
movq %rax, 0x8(%rsp)
jmp 0x10eea
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl 0x48(%rsp), %edx
callq 0xf6f0
jmp 0x10eff
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x18(%rsp), %rsi
callq 0xefb0
jmp 0x10f1a
jmp 0x10f1c
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x10ead
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x10f60
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
movl $0x30, %esi
callq 0xebb0
jmp 0x10f60
addq $0x68, %rsp
retq
movq 0x10(%rsp), %rdi
callq 0xe2c0
movq 0x38(%rsp), %rdi
callq 0xf590
nopw %cs:(%rax,%rax)
// File: tbjohns[P]BlitzL1/src/common.cpp
// Function: BlitzL1::l2_norm_sq(std::vector<double, std::allocator<double>> const&)
value_t l2_norm_sq(const vector<value_t> &vec)
  {
    value_t result = 0.0;
    for (size_t ind = 0; ind < vec.size(); ++ind)
      result += vec[ind] * vec[ind];
    return result;
  }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0xe730
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x11010
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xeee0
movsd (%rax), %xmm0
movsd %xmm0, (%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xeee0
movsd (%rsp), %xmm0
movsd (%rax), %xmm2
movsd 0x18(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x10f9b
movsd 0x18(%rsp), %xmm0
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: tbjohns[P]BlitzL1/src/common.cpp
// Function: BlitzL1::l1_norm(double const*, unsigned long)
value_t l1_norm(const value_t *vec, size_t len)
  {
    value_t result = 0.0;
    for (size_t ind = 0; ind < len; ++ind)
    {
      if (vec[ind] != 0.0)
        result += fabs(vec[ind]);
    }
    return result;
  }

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rsp)
movq $0x0, -0x20(%rsp)
movq -0x20(%rsp), %rax
cmpq -0x10(%rsp), %rax
jae 0x1109c
movq -0x8(%rsp), %rax
movq -0x20(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x11064
jp 0x11064
jmp 0x1108a
movq -0x8(%rsp), %rax
movq -0x20(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movaps 0xafc6(%rip), %xmm1     # 0x1c040
pand %xmm1, %xmm0
addsd -0x18(%rsp), %xmm0
movsd %xmm0, -0x18(%rsp)
jmp 0x1108c
movq -0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rsp)
jmp 0x1103c
movsd -0x18(%rsp), %xmm0
retq
nopw %cs:(%rax,%rax)
// File: tbjohns[P]BlitzL1/src/common.cpp
// Function: BlitzL1::l0_norm(double const*, unsigned long)
size_t l0_norm(const value_t *values, size_t len)
  {
    index_t result = 0;
    for (size_t ind = 0; ind < len; ++ind)
    {
      if (values[ind] != 0.0)
        result++;
    }
    return result;
  }

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl $0x0, -0x14(%rsp)
movq $0x0, -0x20(%rsp)
movq -0x20(%rsp), %rax
cmpq -0x10(%rsp), %rax
jae 0x11110
movq -0x8(%rsp), %rax
movq -0x20(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x110f3
jp 0x110f3
jmp 0x110fe
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x11100
movq -0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rsp)
jmp 0x110cb
movslq -0x14(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: tbjohns[P]BlitzL1/src/common.cpp
// Function: BlitzL1::l2_norm_diff_sq(std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&)
value_t l2_norm_diff_sq(const std::vector<value_t> &vec1,
                          const std::vector<value_t> &vec2)
  {
    value_t result = 0.0;
    for (size_t ind = 0; ind < vec1.size(); ++ind)
    {
      value_t diff = vec1[ind] - vec2[ind];
      result += diff * diff;
    }
    return result;
  }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
callq 0xe730
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x111ca
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xeee0
movsd (%rax), %xmm0
movsd %xmm0, (%rsp)
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xeee0
movsd (%rsp), %xmm0
subsd (%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
movsd 0x10(%rsp), %xmm2
movsd 0x20(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x11140
movsd 0x20(%rsp), %xmm0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tbjohns[P]BlitzL1/src/common.cpp
// Function: BlitzL1::inner_product(std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&)
value_t inner_product(const vector<value_t> &vec1,
                        const vector<value_t> &vec2)
  {
    value_t result = 0.0;
    for (size_t ind = 0; ind < vec1.size(); ++ind)
      result += vec1[ind] * vec2[ind];
    return result;
  }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
callq 0xe730
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x11377
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xeee0
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xeee0
movsd 0x8(%rsp), %xmm0
movsd (%rax), %xmm2
movsd 0x20(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x11300
movsd 0x20(%rsp), %xmm0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tbjohns[P]BlitzL1/src/common.cpp
// Function: BlitzL1::max_abs(std::vector<double, std::allocator<double>> const&)
value_t max_abs(const vector<value_t> &vec)
  {
    value_t result = 0.0;
    for (size_t ind = 0; ind < vec.size(); ++ind)
    {
      if (fabs(vec[ind]) > result)
        result = fabs(vec[ind]);
    }
    return result;
  }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0xe730
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x11428
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xeee0
movsd (%rax), %xmm0
movaps 0xac5a(%rip), %xmm1     # 0x1c040
pand %xmm1, %xmm0
ucomisd 0x18(%rsp), %xmm0
jbe 0x11416
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xeee0
movsd (%rax), %xmm0
movaps 0xac34(%rip), %xmm1     # 0x1c040
pand %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
jmp 0x11418
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x113ab
movsd 0x18(%rsp), %xmm0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tbjohns[P]BlitzL1/src/common.cpp
// Function: BlitzL1::soft_threshold(double, double)
value_t soft_threshold(value_t value, value_t threshold)
  {
    if (value > threshold)
      return value - threshold;
    else if (value < -threshold)
      return value + threshold;
    else
      return 0.0;
  }

// Assembly:
movsd %xmm0, -0x10(%rsp)
movsd %xmm1, -0x18(%rsp)
movsd -0x10(%rsp), %xmm0
ucomisd -0x18(%rsp), %xmm0
jbe 0x1146e
movsd -0x10(%rsp), %xmm0
subsd -0x18(%rsp), %xmm0
movsd %xmm0, -0x8(%rsp)
jmp 0x114b4
movsd -0x10(%rsp), %xmm1
movsd -0x18(%rsp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x114ab
movsd -0x10(%rsp), %xmm0
addsd -0x18(%rsp), %xmm0
movsd %xmm0, -0x8(%rsp)
jmp 0x114b4
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rsp)
movsd -0x8(%rsp), %xmm0
retq
nopl (%rax,%rax)
// File: tbjohns[P]BlitzL1/src/logger.cpp
// Function: BlitzL1::Logger::log_value(char*, double)
void Logger::log_value(char *name, value_t value)
{
  FILE *out_file;
  char file_path[256];

  snprintf(file_path, 256, "%s/%s.%d", log_directory, name, num_points_logged);

  out_file = fopen(file_path, "w");
  if (out_file == NULL)
  {
    std::cerr << "Warning: could not open log path \"" << file_path << "\"" << std::endl;
  }
  else
  {
    fprintf(out_file, "%.15f\n", value);
    fclose(out_file);
  }
}

// Assembly:
subq $0x128, %rsp            # imm = 0x128
movq %rdi, 0x120(%rsp)
movq %rsi, 0x118(%rsp)
movsd %xmm0, 0x110(%rsp)
movq 0x120(%rsp), %rax
movq %rsp, %rdi
movq (%rax), %rcx
movq 0x118(%rsp), %r8
movl 0x8(%rax), %r9d
movl $0x100, %esi            # imm = 0x100
leaq 0x8fef(%rip), %rdx      # 0x1c0d5
movb $0x0, %al
callq 0xf360
movq %rsp, %rdi
leaq 0x8fe7(%rip), %rsi      # 0x1c0de
callq 0xee00
movq %rax, 0x108(%rsp)
cmpq $0x0, 0x108(%rsp)
jne 0x1314d
movq 0xdeda(%rip), %rdi      # 0x20ff0
leaq 0x8fc3(%rip), %rsi      # 0x1c0e0
callq 0xeb20
movq %rax, %rdi
movq %rsp, %rsi
callq 0xeb20
movq %rax, %rdi
leaq 0x8fca(%rip), %rsi      # 0x1c101
callq 0xeb20
movq %rax, %rdi
movq 0xde5a(%rip), %rsi      # 0x20fa0
callq 0xec40
jmp 0x13179
movq 0x108(%rsp), %rdi
movsd 0x110(%rsp), %xmm0
leaq 0x8f9e(%rip), %rsi      # 0x1c103
movb $0x1, %al
callq 0xf140
movq 0x108(%rsp), %rdi
callq 0xeb30
addq $0x128, %rsp            # imm = 0x128
retq
nopw %cs:(%rax,%rax)
// File: tbjohns[P]BlitzL1/src/logger.cpp
// Function: BlitzL1::Logger::log_point(double, double)
void Logger::log_point(double elapsed_time, value_t obj)
{
  if (!strlen(log_directory))
    return;

  char time_str[] = "time";
  log_value(time_str, (value_t)elapsed_time);
  char obj_str[] = "obj";
  log_value(obj_str, obj);

  num_points_logged++;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movsd %xmm0, 0x28(%rsp)
movsd %xmm1, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq (%rax), %rdi
callq 0xe480
cmpq $0x0, %rax
jne 0x131bf
jmp 0x13215
movq 0x8(%rsp), %rdi
movl 0x8f40(%rip), %eax      # 0x1c10a
movl %eax, 0x1b(%rsp)
movb 0x8f3a(%rip), %al       # 0x1c10e
movb %al, 0x1f(%rsp)
leaq 0x1b(%rsp), %rsi
movsd 0x28(%rsp), %xmm0
callq 0xe3b0
movq 0x8(%rsp), %rdi
movl 0x8f1c(%rip), %eax      # 0x1c10f
movl %eax, 0x17(%rsp)
leaq 0x17(%rsp), %rsi
movsd 0x20(%rsp), %xmm0
callq 0xe3b0
movq 0x8(%rsp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: tbjohns[P]BlitzL1/src/loss.cpp
// Function: BlitzL1::Loss::compute_Ax(std::vector<double, std::allocator<double>>&, double const*, double, BlitzL1::Dataset const*) const
void Loss::compute_Ax(
    std::vector<value_t> &Ax,
    const value_t *x,
    value_t intercept,
    const Dataset *data) const
{

  index_t n = data->get_n();
  index_t d = data->get_d();
  Ax.assign(n, intercept);
  for (index_t j = 0; j < d; ++j)
  {
    if (x[j] != 0)
      data->get_column(j)->add_multiple(Ax, x[j]);
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movsd %xmm0, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0xe7f0
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
callq 0xf1b0
movl %eax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movslq 0xc(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0xe460
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x8(%rsp), %eax
jge 0x132d6
movq 0x20(%rsp), %rax
movslq 0x4(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x1329c
jp 0x1329c
jmp 0x132c7
movq 0x10(%rsp), %rdi
movl 0x4(%rsp), %esi
callq 0xf530
movq %rax, %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rax
movslq 0x4(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x132c9
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x13276
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: tbjohns[P]BlitzL1/src/loss_logistic.cpp
// Function: BlitzL1::LogisticLoss::primal_loss(std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&, BlitzL1::Dataset const*) const
value_t LogisticLoss::primal_loss(const vector<value_t> &theta,
                                  const vector<value_t> &aux_dual,
                                  const Dataset *data) const
{
  value_t loss = 0.0;
  size_t n = data->get_n();
  for (size_t i = 0; i < n; ++i)
  {
    loss += log1p(aux_dual[i]);
  }
  return loss;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0xe7f0
movq %rax, 0x8(%rsp)
movq $0x0, (%rsp)
movq (%rsp), %rax
cmpq 0x8(%rsp), %rax
jae 0x13d84
movq 0x20(%rsp), %rdi
movq (%rsp), %rsi
callq 0xeee0
movsd (%rax), %xmm0
callq 0xf8c0
addsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x13d48
movsd 0x10(%rsp), %xmm0
addq $0x38, %rsp
retq
nop
// File: tbjohns[P]BlitzL1/src/loss_logistic.cpp
// Function: BlitzL1::LogisticLoss::dual_obj(std::vector<double, std::allocator<double>> const&, BlitzL1::Dataset const*, double) const
value_t LogisticLoss::dual_obj(const vector<value_t> &theta,
                               const Dataset *data,
                               value_t theta_scaler) const
{
  value_t result = 0.0;
  index_t n = data->get_n();
  for (index_t i = 0; i < n; ++i)
  {
    value_t label = data->get_label(i);
    if (fabs(label) < MIN_ABS_LABEL)
    {
      result += log(2.0);
    }
    else
    {
      value_t val = theta_scaler * theta[i] / label;
      result += val * log(-val) - (1 + val) * log1p(val);
    }
  }
  return result;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movsd %xmm0, 0x48(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x40(%rsp)
movq 0x50(%rsp), %rdi
callq 0xe7f0
movl %eax, 0x3c(%rsp)
movl $0x0, 0x38(%rsp)
movl 0x38(%rsp), %eax
cmpl 0x3c(%rsp), %eax
jge 0x13f01
movq 0x50(%rsp), %rdi
movl 0x38(%rsp), %esi
callq 0xea60
movsd %xmm0, 0x30(%rsp)
movsd 0x30(%rsp), %xmm1
movaps 0x8249(%rip), %xmm0     # 0x1c040
pand %xmm0, %xmm1
movsd 0x8355(%rip), %xmm0     # 0x1c158
ucomisd %xmm1, %xmm0
jbe 0x13e27
movsd 0x834f(%rip), %xmm0     # 0x1c160
callq 0xe930
addsd 0x40(%rsp), %xmm0
movsd %xmm0, 0x40(%rsp)
jmp 0x13eef
movsd 0x48(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x58(%rsp), %rdi
movslq 0x38(%rsp), %rsi
callq 0xeee0
movsd 0x8(%rsp), %xmm0
mulsd (%rax), %xmm0
divsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x28(%rsp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
callq 0xe930
movsd %xmm0, 0x18(%rsp)
movsd 0x82bc(%rip), %xmm0     # 0x1c150
addsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x28(%rsp), %xmm0
callq 0xf8c0
movsd 0x10(%rsp), %xmm1
movsd 0x18(%rsp), %xmm2
movaps %xmm0, %xmm3
movsd 0x20(%rsp), %xmm0
mulsd %xmm3, %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
addsd 0x40(%rsp), %xmm0
movsd %xmm0, 0x40(%rsp)
jmp 0x13ef1
movl 0x38(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x38(%rsp)
jmp 0x13dc8
movsd 0x40(%rsp), %xmm0
addq $0x68, %rsp
retq
nopl (%rax)
// File: tbjohns[P]BlitzL1/src/loss_logistic.cpp
// Function: BlitzL1::LogisticLoss::compute_dual_points(std::vector<double, std::allocator<double>>&, std::vector<double, std::allocator<double>>&, std::vector<double, std::allocator<double>>&, BlitzL1::Dataset const*) const
void LogisticLoss::compute_dual_points(
    vector<value_t> &Ax,
    vector<value_t> &theta,
    vector<value_t> &aux_dual,
    const Dataset *data) const
{

  index_t n = data->get_n();
  theta.resize(n);
  aux_dual.resize(n);
  for (index_t i = 0; i < n; ++i)
  {
    value_t minus_label = -data->get_label(i);
    aux_dual[i] = exp(minus_label * Ax[i]);
    theta[i] = minus_label * aux_dual[i] / (1.0 + aux_dual[i]);
  }
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0xe7f0
movl %eax, 0x3c(%rsp)
movq 0x50(%rsp), %rdi
movslq 0x3c(%rsp), %rsi
callq 0xebc0
movq 0x48(%rsp), %rdi
movslq 0x3c(%rsp), %rsi
callq 0xebc0
movl $0x0, 0x38(%rsp)
movl 0x38(%rsp), %eax
cmpl 0x3c(%rsp), %eax
jge 0x14062
movq 0x40(%rsp), %rdi
movl 0x38(%rsp), %esi
callq 0xea60
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x58(%rsp), %rdi
movslq 0x38(%rsp), %rsi
callq 0xebf0
movsd 0x8(%rsp), %xmm0
mulsd (%rax), %xmm0
callq 0xf5f0
movsd %xmm0, 0x10(%rsp)
movq 0x48(%rsp), %rdi
movslq 0x38(%rsp), %rsi
callq 0xebf0
movsd 0x10(%rsp), %xmm0
movsd %xmm0, (%rax)
movsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movq 0x48(%rsp), %rdi
movslq 0x38(%rsp), %rsi
callq 0xebf0
movsd 0x18(%rsp), %xmm0
mulsd (%rax), %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0x48(%rsp), %rdi
movslq 0x38(%rsp), %rsi
callq 0xebf0
movsd 0x20(%rsp), %xmm0
movsd 0x8125(%rip), %xmm1     # 0x1c150
addsd (%rax), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rsp)
movq 0x50(%rsp), %rdi
movslq 0x38(%rsp), %rsi
callq 0xebf0
movsd 0x28(%rsp), %xmm0
movsd %xmm0, (%rax)
movl 0x38(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x38(%rsp)
jmp 0x13f61
addq $0x68, %rsp
retq
nopw (%rax,%rax)
// File: tbjohns[P]BlitzL1/src/loss_logistic.cpp
// Function: BlitzL1::LogisticLoss::compute_H(std::vector<double, std::allocator<double>>&, std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&, BlitzL1::Dataset const*) const
void LogisticLoss::compute_H(vector<value_t> &H,
                             const vector<value_t> &theta,
                             const vector<value_t> &Ax,
                             const Dataset *data) const
{
  index_t n = data->get_n();
  H.resize(n);
  for (index_t i = 0; i < n; ++i)
  {
    value_t label = data->get_label(i);
    H[i] = -theta[i] * (label + theta[i]);
  }
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0xe7f0
movl %eax, 0x2c(%rsp)
movq 0x48(%rsp), %rdi
movslq 0x2c(%rsp), %rsi
callq 0xebc0
movl $0x0, 0x28(%rsp)
movl 0x28(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jge 0x14162
movq 0x30(%rsp), %rdi
movl 0x28(%rsp), %esi
callq 0xea60
movsd %xmm0, 0x20(%rsp)
movq 0x40(%rsp), %rdi
movslq 0x28(%rsp), %rsi
callq 0xeee0
movsd (%rax), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x40(%rsp), %rdi
movslq 0x28(%rsp), %rsi
callq 0xeee0
movsd 0x8(%rsp), %xmm1
movsd 0x10(%rsp), %xmm0
addsd (%rax), %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movq 0x48(%rsp), %rdi
movslq 0x28(%rsp), %rsi
callq 0xebf0
movsd 0x18(%rsp), %xmm0
movsd %xmm0, (%rax)
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x140b2
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: tbjohns[P]BlitzL1/src/loss_logistic.cpp
// Function: BlitzL1::LogisticLoss::apply_intercept_update(double, std::vector<double, std::allocator<double>>&, std::vector<double, std::allocator<double>>&, std::vector<double, std::allocator<double>>&, BlitzL1::Dataset const*) const
void LogisticLoss::apply_intercept_update(
    value_t delta,
    vector<value_t> &Ax,
    vector<value_t> &theta,
    vector<value_t> &aux_dual,
    const Dataset *data) const
{
  index_t n = data->get_n();
  for (index_t i = 0; i < n; ++i)
  {
    value_t minus_label = -data->get_label(i);
    Ax[i] += delta;
    aux_dual[i] = exp(minus_label * Ax[i]);
    theta[i] = minus_label * aux_dual[i] / (1.0 + aux_dual[i]);
  }
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movsd %xmm0, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
movq %rcx, 0x50(%rsp)
movq %r8, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0xe7f0
movl %eax, 0x44(%rsp)
movl $0x0, 0x40(%rsp)
movl 0x40(%rsp), %eax
cmpl 0x44(%rsp), %eax
jge 0x142d3
movq 0x48(%rsp), %rdi
movl 0x40(%rsp), %esi
callq 0xea60
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, 0x38(%rsp)
movsd 0x68(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x60(%rsp), %rdi
movslq 0x40(%rsp), %rsi
callq 0xebf0
movsd 0x8(%rsp), %xmm0
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
movsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x60(%rsp), %rdi
movslq 0x40(%rsp), %rsi
callq 0xebf0
movsd 0x10(%rsp), %xmm0
mulsd (%rax), %xmm0
callq 0xf5f0
movsd %xmm0, 0x18(%rsp)
movq 0x50(%rsp), %rdi
movslq 0x40(%rsp), %rsi
callq 0xebf0
movsd 0x18(%rsp), %xmm0
movsd %xmm0, (%rax)
movsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0x50(%rsp), %rdi
movslq 0x40(%rsp), %rsi
callq 0xebf0
movsd 0x20(%rsp), %xmm0
mulsd (%rax), %xmm0
movsd %xmm0, 0x28(%rsp)
movq 0x50(%rsp), %rdi
movslq 0x40(%rsp), %rsi
callq 0xebf0
movsd 0x28(%rsp), %xmm0
movsd 0x7eb4(%rip), %xmm1     # 0x1c150
addsd (%rax), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rsp)
movq 0x58(%rsp), %rdi
movslq 0x40(%rsp), %rsi
callq 0xebf0
movsd 0x30(%rsp), %xmm0
movsd %xmm0, (%rax)
movl 0x40(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x40(%rsp)
jmp 0x141a9
addq $0x78, %rsp
retq
nopl (%rax,%rax)
// File: tbjohns[P]BlitzL1/src/loss_squared.cpp
// Function: BlitzL1::SquaredLoss::dual_obj(std::vector<double, std::allocator<double>> const&, BlitzL1::Dataset const*, double) const
value_t SquaredLoss::dual_obj(const vector<value_t> &theta,
                              const Dataset *data,
                              value_t theta_scaler) const
{
  value_t dot_prod = 0;
  index_t n = data->get_n();
  for (index_t i = 0; i < n; ++i)
    dot_prod += data->get_label(i) * theta[i];
  return -0.5 * theta_scaler * theta_scaler * l2_norm_sq(theta) - theta_scaler * dot_prod;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movsd %xmm0, 0x28(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0x30(%rsp), %rdi
callq 0xe7f0
movl %eax, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jge 0x14a80
movq 0x30(%rsp), %rdi
movl 0x18(%rsp), %esi
callq 0xea60
movsd %xmm0, 0x10(%rsp)
movq 0x38(%rsp), %rdi
movslq 0x18(%rsp), %rsi
callq 0xeee0
movsd 0x10(%rsp), %xmm0
movsd (%rax), %xmm2
movsd 0x20(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x14a28
movsd 0x7730(%rip), %xmm0     # 0x1c1b8
mulsd 0x28(%rsp), %xmm0
mulsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x38(%rsp), %rdi
callq 0xf2e0
movaps %xmm0, %xmm2
movsd 0x8(%rsp), %xmm0
movsd 0x28(%rsp), %xmm1
mulsd 0x20(%rsp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
addq $0x48, %rsp
retq
nopl (%rax)
// File: tbjohns[P]BlitzL1/src/loss_squared.cpp
// Function: BlitzL1::SquaredLoss::compute_dual_points(std::vector<double, std::allocator<double>>&, std::vector<double, std::allocator<double>>&, std::vector<double, std::allocator<double>>&, BlitzL1::Dataset const*) const
void SquaredLoss::compute_dual_points(
    vector<value_t> &Ax,
    vector<value_t> &theta,
    vector<value_t> &aux_dual,
    const Dataset *data) const
{
  size_t n = data->get_n();
  theta.resize(n);
  for (size_t i = 0; i < n; ++i)
  {
    theta[i] = Ax[i] - data->get_label(i);
  }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0xe7f0
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xebc0
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0x14b94
movq 0x38(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xebf0
movsd (%rax), %xmm0
movsd %xmm0, (%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rax
movl %eax, %esi
callq 0xea60
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xebf0
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x14b24
addq $0x48, %rsp
retq
nopl (%rax)
// File: tbjohns[P]BlitzL1/src/loss_squared.cpp
// Function: BlitzL1::SquaredLoss::apply_intercept_update(double, std::vector<double, std::allocator<double>>&, std::vector<double, std::allocator<double>>&, std::vector<double, std::allocator<double>>&, BlitzL1::Dataset const*) const
void SquaredLoss::apply_intercept_update(
    value_t delta,
    vector<value_t> &Ax,
    vector<value_t> &theta,
    vector<value_t> &aux_dual,
    const Dataset *data) const
{
  index_t n = data->get_n();
  for (index_t i = 0; i < n; ++i)
  {
    Ax[i] += delta;
    theta[i] += delta;
  }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movsd %xmm0, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq %r8, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0xe7f0
movl %eax, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x14(%rsp), %eax
jge 0x14c90
movsd 0x38(%rsp), %xmm0
movsd %xmm0, (%rsp)
movq 0x30(%rsp), %rdi
movslq 0x10(%rsp), %rsi
callq 0xebf0
movsd (%rsp), %xmm0
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
movsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movslq 0x10(%rsp), %rsi
callq 0xebf0
movsd 0x8(%rsp), %xmm0
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x14c29
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: tbjohns[P]BlitzL1/src/solver.cpp
// Function: BlitzL1::Solver::update_intercept(double&, BlitzL1::Loss const*, BlitzL1::Dataset const*)
value_t Solver::update_intercept(value_t &intercept,
                                   const Loss *loss_function,
                                   const Dataset *data)
  {
    // Optimizes over intercept variable with other weights fixed
    // Modifies intercept, theta, and Ax
    // Returns change in intercept value

    if (!use_intercept)
      return 0.0;

    // 1-d newton method:
    value_t intercept_old = intercept;
    vector<value_t> H;
    for (int itr = 0; itr < 10; ++itr)
    {
      value_t grad = sum_vector(theta);
      if (fabs(grad) <= 1e-14)
        break;
      loss_function->compute_H(H, theta, Ax, data);
      value_t hess = sum_vector(H);
      value_t delta = -grad / hess;
      loss_function->apply_intercept_update(
          delta, Ax, theta, aux_dual, data);
      intercept += delta;
    }

    return intercept - intercept_old;
  }

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movq %rdx, 0x78(%rsp)
movq %rcx, 0x70(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x18(%rsp)
testb $0x1, 0xd9(%rax)
jne 0x14d28
xorps %xmm0, %xmm0
movsd %xmm0, 0x90(%rsp)
jmp 0x14e94
movq 0x80(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x68(%rsp)
leaq 0x50(%rsp), %rdi
callq 0xe940
movl $0x0, 0x4c(%rsp)
cmpl $0xa, 0x4c(%rsp)
jge 0x14e6f
movq 0x18(%rsp), %rdi
callq 0xe8c0
movsd %xmm0, 0x10(%rsp)
jmp 0x14d69
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x40(%rsp)
movsd 0x40(%rsp), %xmm1
movaps 0x72be(%rip), %xmm0     # 0x1c040
pand %xmm0, %xmm1
movsd 0x7452(%rip), %xmm0     # 0x1c1e0
ucomisd %xmm1, %xmm0
jb 0x14db6
jmp 0x14e6f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x50(%rsp), %rdi
callq 0xf1c0
jmp 0x14ea5
movq 0x18(%rsp), %rdx
movq 0x78(%rsp), %rdi
movq %rdx, %rcx
addq $0x18, %rcx
movq 0x70(%rsp), %r8
movq (%rdi), %rax
movq 0x18(%rax), %rax
leaq 0x50(%rsp), %rsi
callq *%rax
jmp 0x14ddc
leaq 0x50(%rsp), %rdi
callq 0xe8c0
movsd %xmm0, 0x8(%rsp)
jmp 0x14dee
movq 0x18(%rsp), %rdx
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movaps 0x73fa(%rip), %xmm1     # 0x1c200
movsd 0x40(%rsp), %xmm0
pxor %xmm1, %xmm0
movsd 0x28(%rsp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0x78(%rsp), %rdi
movsd 0x20(%rsp), %xmm0
movq %rdx, %rsi
addq $0x18, %rsi
movq %rdx, %rcx
addq $0x78, %rcx
movq 0x70(%rsp), %r8
movq (%rdi), %rax
movq 0x20(%rax), %rax
callq *%rax
jmp 0x14e49
movsd 0x20(%rsp), %xmm0
movq 0x80(%rsp), %rax
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
movl 0x4c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
jmp 0x14d4c
movq 0x80(%rsp), %rax
movsd (%rax), %xmm0
subsd 0x68(%rsp), %xmm0
movsd %xmm0, 0x90(%rsp)
leaq 0x50(%rsp), %rdi
callq 0xf1c0
movsd 0x90(%rsp), %xmm0
addq $0x98, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0xf590
nop
// File: tbjohns[P]BlitzL1/src/solver.cpp
// Function: BlitzL1::get_loss_function(char const*)
Loss *get_loss_function(const char *loss_type)
  {
    // Returns pointer to new loss object of type "loss_type"
    // Raises exception if loss type not recognized

    if (strcmp(loss_type, "logistic") == 0)
      return new LogisticLoss();
    else if (strcmp(loss_type, "squared") == 0)
      return new SquaredLoss();
    else
      throw loss_type;
  }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x735b(%rip), %rsi      # 0x1c220
callq 0xf0c0
cmpl $0x0, %eax
jne 0x14f1c
movl $0x18, %edi
callq 0xeb70
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
callq 0xf150
jmp 0x14eeb
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x14f9e
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
movl $0x18, %esi
callq 0xebb0
jmp 0x14fa8
movq 0x28(%rsp), %rdi
leaq 0x7301(%rip), %rsi      # 0x1c229
callq 0xf0c0
cmpl $0x0, %eax
jne 0x14f79
movl $0x18, %edi
callq 0xeb70
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
callq 0xecc0
jmp 0x14f4e
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x14f9e
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
movl $0x18, %esi
callq 0xebb0
jmp 0x14fa8
movl $0x8, %edi
callq 0xe530
movq %rax, %rdi
movq 0x28(%rsp), %rax
movq %rax, (%rdi)
movq 0xc013(%rip), %rsi      # 0x20fa8
xorl %eax, %eax
movl %eax, %edx
callq 0xf4d0
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0xf590
nopw %cs:(%rax,%rax)
// File: tbjohns[P]BlitzL1/src/solver.cpp
// Function: BlitzL1::Solver::compute_lambda_max(BlitzL1::Dataset const*, char const*)
value_t Solver::compute_lambda_max(const Dataset *data, const char *loss_type)
  {
    // Returns smallest lambda value for which solution is entirely 0

    // Initialize theta:
    Loss *loss_function = get_loss_function(loss_type);
    size_t n = data->get_n();
    size_t d = data->get_d();
    Ax.assign(n, 0.0);
    loss_function->compute_dual_points(Ax, theta, aux_dual, data);

    // Center theta (if using intercept term):
    value_t intercept;
    update_intercept(intercept, loss_function, data);

    // Compute loss gradient for all features:
    prioritized_features.resize(d);
    for (size_t j = 0; j < d; ++j)
      prioritized_features[j] = j;
    update_ATtheta(data);

    // Return largest magnitude in loss gradients:
    return max_abs(ATtheta);
  }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
callq 0xe120
movq %rax, 0x38(%rsp)
movq 0x48(%rsp), %rdi
callq 0xe7f0
movq %rax, 0x30(%rsp)
movq 0x48(%rsp), %rdi
callq 0xf1b0
movq 0x8(%rsp), %rdi
movq %rax, 0x28(%rsp)
addq $0x18, %rdi
movq 0x30(%rsp), %rsi
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rsp)
leaq 0x20(%rsp), %rdx
callq 0xe460
movq 0x8(%rsp), %rdx
movq 0x38(%rsp), %rdi
movq %rdx, %rsi
addq $0x18, %rsi
movq %rdx, %rcx
addq $0x78, %rcx
movq 0x48(%rsp), %r8
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x8(%rsp), %rdi
movq 0x38(%rsp), %rdx
movq 0x48(%rsp), %rcx
leaq 0x18(%rsp), %rsi
callq 0xf7e0
movq 0x8(%rsp), %rdi
addq $0xa0, %rdi
movq 0x28(%rsp), %rsi
callq 0xef00
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x28(%rsp), %rax
jae 0x150c8
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
addq $0xa0, %rdi
movq 0x10(%rsp), %rsi
callq 0xe2d0
movq (%rsp), %rcx
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x15086
movq 0x8(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0xe0f0
movq 0x8(%rsp), %rdi
addq $0x30, %rdi
callq 0xef80
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: tbjohns[P]BlitzL1/src/solver.cpp
// Function: BlitzL1::Solver::update_ATtheta(BlitzL1::Dataset const*)
void Solver::update_ATtheta(const Dataset *data)
  {
    // Updates values of ATtheta for all feature indices in
    // prioritized_features vector

    size_t d = data->get_d();
    ATtheta.resize(d);
    for (vector<size_t>::iterator j = prioritized_features.begin();
         j != prioritized_features.end();
         ++j)
    {
      const Column *col = data->get_column(*j);
      ATtheta[*j] = col->inner_product(theta);
    }
  }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x48(%rsp), %rdi
callq 0xf1b0
movq 0x20(%rsp), %rdi
movq %rax, 0x40(%rsp)
addq $0x30, %rdi
movq 0x40(%rsp), %rsi
callq 0xebc0
movq 0x20(%rsp), %rdi
addq $0xa0, %rdi
callq 0xe100
movq %rax, 0x38(%rsp)
movq 0x20(%rsp), %rdi
addq $0xa0, %rdi
callq 0xf890
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xe4d0
testb $0x1, %al
jne 0x1516b
jmp 0x151e6
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xf120
movq 0x8(%rsp), %rdi
movq (%rax), %rax
movl %eax, %esi
callq 0xf530
movq 0x20(%rsp), %rsi
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq (%rdi), %rax
callq *(%rax)
movq 0x20(%rsp), %rax
movsd %xmm0, 0x18(%rsp)
addq $0x30, %rax
movq %rax, 0x10(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xf120
movq 0x10(%rsp), %rdi
movq (%rax), %rsi
callq 0xebf0
movsd 0x18(%rsp), %xmm0
movsd %xmm0, (%rax)
leaq 0x38(%rsp), %rdi
callq 0xf5c0
jmp 0x15140
addq $0x58, %rsp
retq
nopl (%rax,%rax)