LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: ef-gy[P]libefgy/include/ef.gy/parametric.h
// Function: efgy::geometry::parametricIterator<float, 2ul, efgy::geometry::formula::plane>::operator++()
parametricIterator &operator++(void) {
    basePosition++;

    if (basePosition < base.size()) {
      return *this;
    } else {
      basePosition = 0;
    }

    for (int dim = (od - 1); dim >= 0; dim--) {
      if (positions[dim] < ends[dim]) {
        positions[dim]++;
      }

      if (positions[dim] < ends[dim]) {
        break;
      } else if (dim > 0) {
        positions[dim] = starts[dim];
      }
    }
    return *this;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq 0x68(%rdi), %rax
addq $0x1, %rax
movq %rax, 0x68(%rdi)
movq 0x68(%rdi), %rax
movq %rax, -0x30(%rbp)
addq $0x50, %rdi
callq 0x58ff0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x56e8a
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x56f85
movq -0x38(%rbp), %rax
movq $0x0, 0x68(%rax)
movl $0x1, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x56f7d
movq -0x38(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x59c80
movq -0x38(%rbp), %rdi
movq %rax, -0x40(%rbp)
addq $0x30, %rdi
movslq -0x14(%rbp), %rsi
callq 0x59c80
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x5a7f0
testb $0x1, %al
jne 0x56edb
jmp 0x56efb
movq -0x38(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x59c80
movq %rax, %rdi
xorl %esi, %esi
callq 0x5a820
movlpd %xmm0, -0x28(%rbp)
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x59c80
movq -0x38(%rbp), %rdi
movq %rax, -0x48(%rbp)
addq $0x30, %rdi
movslq -0x14(%rbp), %rsi
callq 0x59c80
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x5a7f0
testb $0x1, %al
jne 0x56f2f
jmp 0x56f31
jmp 0x56f7d
cmpl $0x0, -0x14(%rbp)
jle 0x56f6b
movq -0x38(%rbp), %rdi
addq $0x18, %rdi
movslq -0x14(%rbp), %rsi
callq 0x59c80
movq -0x38(%rbp), %rdi
movq %rax, -0x50(%rbp)
movslq -0x14(%rbp), %rsi
callq 0x59c80
movq -0x50(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
jmp 0x56f6d
jmp 0x56f6f
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x56e9d
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: ef-gy[P]libefgy/include/ef.gy/parametric.h
// Function: efgy::geometry::parametric<float, 2ul, efgy::geometry::formula::plane>::size() const
std::size_t size(void) const {
#if 0
    std::size_t s = source::getRange(parent::parameter, 0).size();
    for (std::size_t i = 1; i < od; i++) {
      s *= source::getRange(parent::parameter, i).size();
    }
    return s;
#else
    // TODO: this is really bad, but the closed form currently eludes me.
    return std::count_if(begin(), end(),
                         [](const typename parent::face &) { return true; });
#endif
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x190(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x56be0
movq -0x190(%rbp), %rsi
leaq -0x178(%rbp), %rdi
callq 0x56c10
jmp 0x5702b
leaq -0xc0(%rbp), %rdi
leaq -0x178(%rbp), %rsi
callq 0x5a870
movq %rax, -0x198(%rbp)
jmp 0x57047
leaq -0x178(%rbp), %rdi
callq 0x56f90
leaq -0xc0(%rbp), %rdi
callq 0x56f90
movq -0x198(%rbp), %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x180(%rbp)
movl %eax, -0x184(%rbp)
jmp 0x570a1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x180(%rbp)
movl %eax, -0x184(%rbp)
leaq -0x178(%rbp), %rdi
callq 0x56f90
leaq -0xc0(%rbp), %rdi
callq 0x56f90
movq -0x180(%rbp), %rdi
callq 0x55e0
nopl (%rax)
// File: ef-gy[P]libefgy/include/ef.gy/parametric.h
// Function: efgy::geometry::parametricIterator<float, 2ul, efgy::geometry::formula::plane>::getPosition() const
const vector getPosition(void) const {
    vector r;
    for (std::size_t dim = 0; dim < od; dim++) {
      r[dim] = *(positions[dim]);
    }
    return r;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x38(%rbp)
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
xorps %xmm0, %xmm0
movss %xmm0, (%rax)
addq $0x4, %rax
cmpq %rcx, %rax
movq %rax, -0x30(%rbp)
jne 0x5a417
leaq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
leaq -0x19(%rbp), %rdx
callq 0x3a850
movq $0x0, -0x28(%rbp)
cmpq $0x2, -0x28(%rbp)
jae 0x5a491
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x5a5f0
movq %rax, %rdi
callq 0x5a610
movss %xmm0, -0x44(%rbp)
movq -0x28(%rbp), %rsi
leaq -0x8(%rbp), %rdi
callq 0x3a7e0
movss -0x44(%rbp), %xmm0
movss %xmm0, (%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x5a44c
movsd -0x8(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: ef-gy[P]libefgy/include/ef.gy/parametric.h
// Function: efgy::geometry::formula::plane<float, 2ul>::getCoordinates(efgy::geometry::parameters<float> const&, efgy::math::vector<float, 2u, efgy::math::format::cartesian> const&)
static math::vector<Q, renderDepth> getCoordinates(
      const parameters<Q> &parameter, const math::vector<Q, od> &ve) {
    math::vector<Q, renderDepth> vp{{ve[0]}};
    for (std::size_t i = 0; i < od; i++) {
      vp[i] = ve[i];
    }
    return vp;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3b280
movq -0x48(%rbp), %rcx
movss (%rax), %xmm0
movss %xmm0, -0x20(%rbp)
movq %rcx, %rax
addq $0x4, %rax
addq $0x8, %rcx
movq %rcx, -0x40(%rbp)
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
xorps %xmm0, %xmm0
movss %xmm0, (%rax)
addq $0x4, %rax
cmpq %rcx, %rax
movq %rax, -0x38(%rbp)
jne 0x5a6f5
leaq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
leaq -0x21(%rbp), %rdx
callq 0x3a850
movq $0x0, -0x30(%rbp)
cmpq $0x2, -0x30(%rbp)
jae 0x5a76b
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x3b280
movss (%rax), %xmm0
movss %xmm0, -0x4c(%rbp)
movq -0x30(%rbp), %rsi
leaq -0x8(%rbp), %rdi
callq 0x3a7e0
movss -0x4c(%rbp), %xmm0
movss %xmm0, (%rax)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x5a72a
movsd -0x8(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ef-gy[P]libefgy/include/ef.gy/ifs.h
// Function: efgy::geometry::ifs<float, 2ul, efgy::geometry::cube, efgy::geometry::generators::gasket>::iterator::operator*() const
const face operator*(void)const {
      auto f = *basePosition;
      face g;
      auto o = g.begin();
      for (auto &p : f) {
        *o = p;
        for (const auto &i : iteration()) {
          *o = functions[i] * (*o);
        }
        o++;
      }
      return g;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0xa8(%rbp)
movq %rdi, -0xb8(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
addq $0x28, %rdi
callq 0x394c0
movq -0xa8(%rbp), %rdi
movq (%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x20(%rbp)
movq 0x10(%rax), %rcx
movq %rcx, -0x18(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
callq 0x3a570
movq -0xa8(%rbp), %rdi
callq 0x394e0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x394e0
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x39500
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x48(%rbp), %rax
je 0x5fac7
movq -0xb0(%rbp), %rsi
movq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rcx
movq -0x30(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, (%rax)
leaq -0x70(%rbp), %rdi
callq 0x62030
leaq -0x70(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
callq 0x12100
movq %rax, -0x78(%rbp)
movq -0x58(%rbp), %rdi
callq 0x11f90
movq %rax, -0x80(%rbp)
leaq -0x78(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x19630
testb $0x1, %al
jne 0x5fa23
leaq -0x70(%rbp), %rdi
callq 0x10e80
jmp 0x5faaa
leaq -0x78(%rbp), %rdi
callq 0x19670
movq -0xb0(%rbp), %rdi
movq %rax, -0x88(%rbp)
addq $0x30, %rdi
movq -0x88(%rbp), %rax
movq (%rax), %rsi
callq 0x62160
movq %rax, %rdi
movq -0x30(%rbp), %rsi
callq 0x62180
movaps %xmm0, -0xd0(%rbp)
jmp 0x5fa62
movaps -0xd0(%rbp), %xmm0
movlpd %xmm0, -0x90(%rbp)
movq -0x30(%rbp), %rax
movq -0x90(%rbp), %rcx
movq %rcx, (%rax)
leaq -0x78(%rbp), %rdi
callq 0x19690
jmp 0x5fa04
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x10e80
jmp 0x5fad7
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x40(%rbp)
jmp 0x5f9ae
movq -0xb8(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0x55e0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ef-gy[P]libefgy/include/ef.gy/ifs.h
// Function: efgy::geometry::ifs<float, 2ul, efgy::geometry::cube, efgy::geometry::generators::gasket>::iterator::operator++()
iterator &operator++(void) {
      if (basePosition != base.end()) {
        basePosition++;
      }

      if (basePosition == base.end()) {
        basePosition = base.begin();
        iterations++;
      }

      return *this;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
addq $0x28, %rax
movq %rax, -0x30(%rbp)
callq 0x39450
movq -0x30(%rbp), %rdi
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rsi
callq 0x39480
testb $0x1, %al
jne 0x5fb2b
jmp 0x5fb3e
movq -0x38(%rbp), %rdi
addq $0x28, %rdi
xorl %esi, %esi
callq 0x62a50
movq %rax, -0x18(%rbp)
movq -0x38(%rbp), %rdi
movq %rdi, %rax
addq $0x28, %rax
movq %rax, -0x40(%rbp)
callq 0x39450
movq -0x40(%rbp), %rdi
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x61ff0
testb $0x1, %al
jne 0x5fb69
jmp 0x5fb91
movq -0x38(%rbp), %rdi
callq 0x393e0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq %rcx, 0x28(%rax)
movq 0x48(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x48(%rax)
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ef-gy[P]libefgy/include/ef.gy/ifs.h
// Function: efgy::geometry::ifs<float, 2ul, efgy::geometry::cube, efgy::geometry::generators::gasket>::size() const
std::size_t size(void) const {
    basePrimitive base(parent::parameter, format());
    return base.size() *
           std::pow<std::size_t>(generator::size(parent::parameter),
                                 parent::parameter.iterations);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq (%rax), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x58(%rbp)
leaq -0x31(%rbp), %rdx
callq 0x39390
movq -0x58(%rbp), %rdi
callq 0x395f0
movq %rax, -0x50(%rbp)
jmp 0x5fc0a
movq -0x60(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, %xmm0
movaps 0x9692(%rip), %xmm1     # 0x692b0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x9696(%rip), %xmm1     # 0x692c0
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd %xmm0, -0x70(%rbp)
movq (%rax), %rdi
callq 0x62ae0
movq %rax, -0x68(%rbp)
jmp 0x5fc4c
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rax
movq (%rax), %rax
movl 0x10(%rax), %esi
callq 0x62a90
movsd %xmm0, -0x78(%rbp)
jmp 0x5fc66
movsd -0x78(%rbp), %xmm1
movsd -0x70(%rbp), %xmm0
mulsd %xmm1, %xmm0
movaps %xmm0, %xmm1
cvttsd2si %xmm1, %rax
movq %rax, %rdx
sarq $0x3f, %rdx
movsd 0x95c5(%rip), %xmm1     # 0x69250
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rcx
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, -0x80(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x39610
movq -0x80(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x39610
movq -0x40(%rbp), %rdi
callq 0x55e0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ef-gy[P]libefgy/include/ef.gy/matrix.h
// Function: efgy::math::matrix<float, 3ul, 3ul> efgy::math::operator*<float, 3ul, 3ul, 3ul>(efgy::math::matrix<float, 3ul, 3ul> const&, efgy::math::matrix<float, 3ul, 3ul> const&)
matrix<Q, n, p> operator*(const matrix<Q, n, m> &a, const matrix<Q, m, p> &b) {
  matrix<Q, n, p> r;

  for (std::size_t i = 0; i < n; i++) {
    for (std::size_t j = 0; j < p; j++) {
      r[i][j] = a[i][0] * b[0][j];

      for (std::size_t k = 1; k < m; k++) {
        r[i][j] += a[i][k] * b[k][j];
      }
    }
  }

  return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, -0x30(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x3, -0x18(%rbp)
jae 0x60f8a
movq $0x0, -0x20(%rbp)
cmpq $0x3, -0x20(%rbp)
jae 0x60f77
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x60fd0
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3f870
movss (%rax), %xmm0
movss %xmm0, -0x40(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x60fd0
movq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0x3f870
movss -0x40(%rbp), %xmm0
movq -0x38(%rbp), %rdi
mulss (%rax), %xmm0
movss %xmm0, -0x3c(%rbp)
movq -0x18(%rbp), %rsi
callq 0x61000
movq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0x397b0
movss -0x3c(%rbp), %xmm0
movss %xmm0, (%rax)
movq $0x1, -0x28(%rbp)
cmpq $0x3, -0x28(%rbp)
jae 0x60f64
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x60fd0
movq %rax, %rdi
movq -0x28(%rbp), %rsi
callq 0x3f870
movss (%rax), %xmm0
movss %xmm0, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x60fd0
movq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0x3f870
movq -0x38(%rbp), %rdi
movss (%rax), %xmm0
movss %xmm0, -0x44(%rbp)
movq -0x18(%rbp), %rsi
callq 0x61000
movq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0x397b0
movss -0x48(%rbp), %xmm0
movss -0x44(%rbp), %xmm2
movss (%rax), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, (%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x60ed1
jmp 0x60f66
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x60e53
jmp 0x60f79
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x60e40
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: ef-gy[P]libefgy/include/ef.gy/matrix.h
// Function: efgy::math::matrix<float, 3ul, 3ul>::matrix<3ul, 3ul, efgy::geometry::transformation::generator::scale>(efgy::math::ghost::matrix<float, 3ul, 3ul, efgy::geometry::transformation::generator::scale> const&)
matrix(const ghost::matrix<Q, rn, rm, gen> &b) {
    for (std::size_t i = 0; i < n; i++) {
      for (std::size_t j = 0; j < m; j++) {
        if ((i < rn) && (j < rm)) {
          (*this)[i][j] = b[i][j];
        } else {
          (*this)[i][j] = Q();
        }
      }
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x3, -0x18(%rbp)
jae 0x6118d
movq $0x0, -0x20(%rbp)
cmpq $0x3, -0x20(%rbp)
jae 0x6117a
cmpq $0x3, -0x18(%rbp)
jae 0x61147
cmpq $0x3, -0x20(%rbp)
jae 0x61147
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x61440
movq %rax, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x61470
movq -0x38(%rbp), %rdi
movss %xmm0, -0x3c(%rbp)
movq -0x18(%rbp), %rsi
callq 0x61000
movq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0x397b0
movss -0x3c(%rbp), %xmm0
movss %xmm0, (%rax)
jmp 0x61167
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x61000
movq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0x397b0
xorps %xmm0, %xmm0
movss %xmm0, (%rax)
jmp 0x61169
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x610e3
jmp 0x6117c
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x610d0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ef-gy[P]libefgy/include/ef.gy/matrix.h
// Function: efgy::math::matrix<float, 3ul, 3ul>::operator=(efgy::math::matrix<float, 3ul, 3ul> const&)
matrix<Q, n, m> &operator=(const matrix<Q, n, m> &b) {
    for (std::size_t i = 0; i < n; i++) {
      for (std::size_t j = 0; j < m; j++) {
        (*this)[i][j] = b[i][j];
      }
    }

    return *this;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x3, -0x18(%rbp)
jae 0x61238
movq $0x0, -0x20(%rbp)
cmpq $0x3, -0x20(%rbp)
jae 0x61228
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x60fd0
movq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0x3f870
movq -0x28(%rbp), %rdi
movss (%rax), %xmm0
movss %xmm0, -0x2c(%rbp)
movq -0x18(%rbp), %rsi
callq 0x61000
movq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0x397b0
movss -0x2c(%rbp), %xmm0
movss %xmm0, (%rax)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x611cf
jmp 0x6122a
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x611c0
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ef-gy[P]libefgy/include/ef.gy/transformation.h
// Function: efgy::geometry::transformation::generator::scale<float, 3ul, 3ul>::operator()(unsigned long const&, unsigned long const&) const
const Q operator()(const std::size_t &i, const std::size_t &j) const {
    if (i == j) {
      return i != (d - 1) ? targetScale : Q(1);
    } else {
      return Q(0);
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x6152c
movq -0x18(%rbp), %rax
cmpq $0x2, (%rax)
je 0x61511
movq -0x28(%rbp), %rax
movss (%rax), %xmm0
movss %xmm0, -0x2c(%rbp)
jmp 0x61520
movss 0x7d1b(%rip), %xmm0     # 0x69234
movss %xmm0, -0x2c(%rbp)
jmp 0x61520
movss -0x2c(%rbp), %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x61534
xorps %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
popq %rbp
retq
nopl (%rax,%rax)
// File: ef-gy[P]libefgy/include/ef.gy/transformation.h
// Function: efgy::geometry::transformation::generator::translate<float, 3ul, 3ul>::operator()(unsigned long const&, unsigned long const&) const
const Q operator()(const std::size_t &i, const std::size_t &j) const {
    if ((i == (d - 1)) && (j < (d - 1))) {
      return from[j];
    } else if (i == j) {
      return Q(1);
    } else {
      return Q(0);
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x2, (%rax)
jne 0x6178b
movq -0x20(%rbp), %rax
cmpq $0x2, (%rax)
jae 0x6178b
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
callq 0x3b280
movss (%rax), %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x617b2
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x617aa
movss 0x7a91(%rip), %xmm0     # 0x69234
movss %xmm0, -0x4(%rbp)
jmp 0x617b2
xorps %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: ef-gy[P]libefgy/include/ef.gy/ifs.h
// Function: efgy::geometry::ifs<float, 2ul, efgy::geometry::cube, efgy::geometry::generators::gasket>::iterator::iteration() const
std::vector<std::size_t> iteration(void) const {
      std::vector<std::size_t> rv = {};
      std::size_t n = iterations;
      for (std::size_t i = 0; i < totalIterations; i++) {
        rv.push_back(n % functions.size());
        n /= functions.size();
      }
      std::reverse(rv.begin(), rv.end());
      return rv;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movb $0x0, -0x11(%rbp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x51c0
movq -0x60(%rbp), %rdi
callq 0x10a00
movq -0x58(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x58(%rbp), %rcx
movq -0x28(%rbp), %rax
cmpq 0x50(%rcx), %rax
jae 0x62104
movq -0x58(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x70(%rbp)
addq $0x30, %rdi
callq 0x60a40
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movq -0x70(%rbp), %rax
xorl %edx, %edx
divq %rcx
movq %rdx, -0x30(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x62330
jmp 0x620c2
movq -0x58(%rbp), %rdi
addq $0x30, %rdi
callq 0x60a40
movq %rax, %rcx
movq -0x20(%rbp), %rax
xorl %edx, %edx
divq %rcx
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x62080
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x10e80
jmp 0x6214a
movq -0x60(%rbp), %rdi
callq 0x12100
movq -0x60(%rbp), %rdi
movq %rax, -0x48(%rbp)
callq 0x11f90
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x62360
jmp 0x6212d
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x62140
movq -0x60(%rbp), %rdi
callq 0x10e80
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x55e0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ef-gy[P]libefgy/include/ef.gy/transformation.h
// Function: efgy::math::vector<float, 2u, efgy::math::format::cartesian> efgy::geometry::transformation::affine<float, 2ul>::operator*<efgy::math::format::cartesian>(efgy::math::vector<float, 2u, efgy::math::format::cartesian> const&) const
math::vector<Q, d, format> operator*(
      const math::vector<Q, d, format> &pV) const {
    math::vector<Q, d, format> rv;

    math::matrix<Q, 1, d + 1> vectorMatrix;

    for (std::size_t i = 0; i < d; i++) {
      vectorMatrix[0][i] = pV[i];
    }

    vectorMatrix[0][d] = Q(1);

    vectorMatrix = vectorMatrix * matrix;

    for (std::size_t i = 0; i < d; i++) {
      rv[i] = vectorMatrix[0][i] / vectorMatrix[0][d];
    }

    return rv;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x70(%rbp)
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq -0x70(%rbp), %rcx
xorps %xmm0, %xmm0
movss %xmm0, (%rax)
addq $0x4, %rax
cmpq %rcx, %rax
movq %rax, -0x68(%rbp)
jne 0x621ae
leaq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
leaq -0x21(%rbp), %rdx
callq 0x3a850
movq $0x0, -0x38(%rbp)
cmpq $0x2, -0x38(%rbp)
jae 0x62230
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x3b280
movss (%rax), %xmm0
movss %xmm0, -0x7c(%rbp)
leaq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x627a0
movq %rax, %rdi
movq -0x38(%rbp), %rsi
callq 0x397b0
movss -0x7c(%rbp), %xmm0
movss %xmm0, (%rax)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x621e3
xorl %eax, %eax
movl %eax, %esi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x627a0
movq %rax, %rdi
movl $0x2, %esi
callq 0x397b0
movq -0x88(%rbp), %rdi
movq -0x78(%rbp), %rsi
movl $0x3f800000, (%rax)     # imm = 0x3F800000
callq 0x627d0
movss %xmm1, -0x50(%rbp)
movlpd %xmm0, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x44(%rbp)
movl -0x50(%rbp), %eax
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x44(%rbp), %rsi
callq 0x62950
movq $0x0, -0x60(%rbp)
cmpq $0x2, -0x60(%rbp)
jae 0x62318
leaq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x627a0
movq %rax, %rdi
movq -0x60(%rbp), %rsi
callq 0x397b0
movss (%rax), %xmm0
movss %xmm0, -0x90(%rbp)
leaq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x627a0
movq %rax, %rdi
movl $0x2, %esi
callq 0x397b0
movss -0x90(%rbp), %xmm0
divss (%rax), %xmm0
movss %xmm0, -0x8c(%rbp)
movq -0x60(%rbp), %rsi
leaq -0x8(%rbp), %rdi
callq 0x3a7e0
movss -0x8c(%rbp), %xmm0
movss %xmm0, (%rax)
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x60(%rbp)
jmp 0x62294
movsd -0x8(%rbp), %xmm0
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ef-gy[P]libefgy/include/ef.gy/polytope.h
// Function: efgy::geometry::adaptiveIterator<std::array<efgy::math::vector<float, 3u, efgy::math::format::cartesian>, 4ul>, efgy::geometry::ifs<float, 2ul, efgy::geometry::cube, efgy::geometry::generators::gasket>::iterator>::operator*() const
const face operator*(void)const {
    const auto &f = iterator::operator*();
    face cf;
    for (std::size_t i = 0; i < std::min(f.size(), cf.size()); i++) {
      for (std::size_t j = 0; j < std::min(f[i].size(), cf[i].size()); j++) {
        cf[i][j] = f[i][j];
      }
    }
    return cf;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, -0x70(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x5f920
movq -0x68(%rbp), %rdi
leaq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x3bf40
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rdi
callq 0x68ba0
movq -0x68(%rbp), %rdi
movq %rax, -0x40(%rbp)
callq 0x68bb0
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x122a0
movq %rax, %rcx
movq -0x78(%rbp), %rax
cmpq (%rcx), %rax
jae 0x68af5
movq $0x0, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x68bc0
movq %rax, %rdi
callq 0x68bf0
movq -0x68(%rbp), %rdi
movq %rax, -0x58(%rbp)
movq -0x38(%rbp), %rsi
callq 0x3c850
movq %rax, %rdi
callq 0x68c00
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x122a0
movq %rax, %rcx
movq -0x80(%rbp), %rax
cmpq (%rcx), %rax
jae 0x68ae2
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x68bc0
movq %rax, %rdi
movq -0x50(%rbp), %rsi
callq 0x3b280
movq -0x68(%rbp), %rdi
movss (%rax), %xmm0
movss %xmm0, -0x84(%rbp)
movq -0x38(%rbp), %rsi
callq 0x3c850
movq %rax, %rdi
movq -0x50(%rbp), %rsi
callq 0x397b0
movss -0x84(%rbp), %xmm0
movss %xmm0, (%rax)
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
jmp 0x68a34
jmp 0x68ae4
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x689ed
movq -0x70(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: trapexit[P]bbf/src/badblockfile.cpp
// Function: BadBlockFile::filepath[abi:cxx11](BlkDev const&)
std::string
BadBlockFile::filepath(const BlkDev &blkdev_)
{
  const char *homedir;
  std::stringstream ss;

  homedir = ::getenv("HOME");
  if((homedir == NULL) || (homedir[0] == '\0'))
    homedir = "/root";

  ss << homedir << "/badblocks." << captcha::calculate(blkdev_);

  return ss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rdi, -0x1e0(%rbp)
movq %rdi, %rax
movq %rax, -0x1d8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x43a0
leaq 0x1e0fd(%rip), %rdi     # 0x23004
callq 0x4630
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x4f23
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x4f2e
leaq 0x1e0df(%rip), %rax     # 0x23009
movq %rax, -0x18(%rbp)
leaq -0x190(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4540
movq %rax, -0x1e8(%rbp)
jmp 0x4f47
movq -0x1e8(%rbp), %rdi
leaq 0x1e0ba(%rip), %rsi     # 0x2300f
callq 0x4540
movq %rax, -0x1f0(%rbp)
jmp 0x4f63
movq -0x10(%rbp), %rsi
leaq -0x1d0(%rbp), %rdi
callq 0x16d10
jmp 0x4f75
movq -0x1f0(%rbp), %rdi
leaq -0x1d0(%rbp), %rsi
callq 0x44a0
jmp 0x4f8a
leaq -0x1d0(%rbp), %rdi
callq 0x4300
movq -0x1e0(%rbp), %rdi
leaq -0x1a0(%rbp), %rsi
callq 0x4530
jmp 0x4fab
leaq -0x1a0(%rbp), %rdi
callq 0x43f0
movq -0x1d8(%rbp), %rax
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
jmp 0x4ff9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0x4300
leaq -0x1a0(%rbp), %rdi
callq 0x43f0
movq -0x1a8(%rbp), %rdi
callq 0x4890
nopw %cs:(%rax,%rax)
// File: trapexit[P]bbf/src/badblockfile.cpp
// Function: BadBlockFile::read(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<unsigned long, std::allocator<unsigned long>>&)
int
BadBlockFile::read(const std::string     &filepath_,
                   std::vector<uint64_t> &blocks_)
{
  if(filepath_ == "-")
    {
      l::read(std::cin,blocks_);
    }
  else
    {
      std::ifstream file;

      file.open(filepath_.c_str());
      if(!file.is_open() || file.bad())
        return -1;

      l::read(file,blocks_);

      file.close();
    }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp            # imm = 0x240
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1dfdd(%rip), %rsi     # 0x2301b
callq 0x53c0
testb $0x1, %al
jne 0x5049
jmp 0x505e
movq -0x18(%rbp), %rsi
movq 0x31f84(%rip), %rdi     # 0x36fd8
callq 0x5180
jmp 0x5155
leaq -0x220(%rbp), %rdi
movq %rdi, -0x238(%rbp)
callq 0x45e0
movq -0x10(%rbp), %rdi
callq 0x4210
movq -0x238(%rbp), %rdi
movq %rax, %rsi
movl $0x8, %edx
callq 0x4320
jmp 0x5090
leaq -0x220(%rbp), %rdi
callq 0x47e0
movb %al, -0x239(%rbp)
jmp 0x50a4
movb -0x239(%rbp), %al
testb $0x1, %al
jne 0x50b0
jmp 0x50dc
movq -0x220(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x220(%rbp,%rax), %rdi
callq 0x48c0
movb %al, -0x23a(%rbp)
jmp 0x50d0
movb -0x23a(%rbp), %al
testb $0x1, %al
jne 0x50dc
jmp 0x510f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0x230(%rbp)
jmp 0x5139
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
leaq -0x220(%rbp), %rdi
callq 0x4110
jmp 0x5168
movq -0x18(%rbp), %rsi
leaq -0x220(%rbp), %rdi
callq 0x5180
jmp 0x5121
leaq -0x220(%rbp), %rdi
callq 0x40f0
jmp 0x512f
movl $0x0, -0x230(%rbp)
leaq -0x220(%rbp), %rdi
callq 0x4110
movl -0x230(%rbp), %eax
testl %eax, %eax
je 0x5153
jmp 0x5151
jmp 0x515c
jmp 0x5155
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x240, %rsp            # imm = 0x240
popq %rbp
retq
movq -0x228(%rbp), %rdi
callq 0x4890
nopw %cs:(%rax,%rax)
// File: trapexit[P]bbf/src/badblockfile.cpp
// Function: BadBlockFile::write(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<unsigned long, std::allocator<unsigned long>> const&)
int
BadBlockFile::write(const std::string           &filepath_,
                    const std::vector<uint64_t> &blocks_)
{
  if(filepath_ == "-")
    {
      l::write(std::cout,blocks_);
    }
  else
    {
      std::ofstream file;

      file.open(filepath_.c_str());
      if(!file.is_open() || file.bad())
        return -1;

      l::write(file,blocks_);

      file.close();
    }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp            # imm = 0x240
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1de1d(%rip), %rsi     # 0x2301b
callq 0x53c0
testb $0x1, %al
jne 0x5209
jmp 0x521e
movq -0x18(%rbp), %rsi
movq 0x31d9c(%rip), %rdi     # 0x36fb0
callq 0x5340
jmp 0x5315
leaq -0x218(%rbp), %rdi
movq %rdi, -0x230(%rbp)
callq 0x4870
movq -0x10(%rbp), %rdi
callq 0x4210
movq -0x230(%rbp), %rdi
movq %rax, %rsi
movl $0x10, %edx
callq 0x4090
jmp 0x5250
leaq -0x218(%rbp), %rdi
callq 0x4410
movb %al, -0x231(%rbp)
jmp 0x5264
movb -0x231(%rbp), %al
testb $0x1, %al
jne 0x5270
jmp 0x529c
movq -0x218(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x218(%rbp,%rax), %rdi
callq 0x48c0
movb %al, -0x232(%rbp)
jmp 0x5290
movb -0x232(%rbp), %al
testb $0x1, %al
jne 0x529c
jmp 0x52cf
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0x228(%rbp)
jmp 0x52f9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x4770
jmp 0x5328
movq -0x18(%rbp), %rsi
leaq -0x218(%rbp), %rdi
callq 0x5340
jmp 0x52e1
leaq -0x218(%rbp), %rdi
callq 0x4730
jmp 0x52ef
movl $0x0, -0x228(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x4770
movl -0x228(%rbp), %eax
testl %eax, %eax
je 0x5313
jmp 0x5311
jmp 0x531c
jmp 0x5315
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x240, %rsp            # imm = 0x240
popq %rbp
retq
movq -0x220(%rbp), %rdi
callq 0x4890
nopw %cs:(%rax,%rax)
// File: trapexit[P]bbf/src/bbf.cpp
// Function: main
int
main(int    argc_,
     char **argv_)
{
  AppError rv;
  Options opts;

  signals::setup_handlers();

  rv = opts.parse(argc_,argv_);
  if(rv.succeeded())
    rv = l::process_instruction(opts);

  if(!rv.succeeded())
    std::cerr << rv.to_string() << std::endl;

  return rv.type;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp            # imm = 0x1A0
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x5fd0
leaq -0xf8(%rbp), %rdi
callq 0x6000
jmp 0x5cb0
callq 0x220c0
jmp 0x5cb7
movl -0x8(%rbp), %edx
movq -0x10(%rbp), %rcx
leaq -0x130(%rbp), %rdi
leaq -0xf8(%rbp), %rsi
callq 0x19fa0
jmp 0x5cd3
leaq -0x38(%rbp), %rdi
movq %rdi, -0x188(%rbp)
leaq -0x130(%rbp), %rsi
movq %rsi, -0x190(%rbp)
callq 0x60a0
movq -0x190(%rbp), %rdi
callq 0x60e0
movq -0x188(%rbp), %rdi
callq 0x16ee0
movb %al, -0x179(%rbp)
jmp 0x5d11
movb -0x179(%rbp), %al
testb $0x1, %al
jne 0x5d1d
jmp 0x5d7e
leaq -0x158(%rbp), %rdi
leaq -0xf8(%rbp), %rsi
callq 0x5e60
jmp 0x5d32
leaq -0x38(%rbp), %rdi
leaq -0x158(%rbp), %rsi
callq 0x60a0
leaq -0x158(%rbp), %rdi
callq 0x60e0
jmp 0x5d7e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x100(%rbp)
movl %eax, -0x104(%rbp)
jmp 0x5e3f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x100(%rbp)
movl %eax, -0x104(%rbp)
jmp 0x5e33
leaq -0x38(%rbp), %rdi
callq 0x16ee0
movb %al, -0x191(%rbp)
jmp 0x5d8f
movb -0x191(%rbp), %al
testb $0x1, %al
jne 0x5e0c
jmp 0x5d9b
leaq -0x178(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x16f00
jmp 0x5dad
movq 0x3123c(%rip), %rdi     # 0x36ff0
leaq -0x178(%rbp), %rsi
callq 0x44a0
movq %rax, -0x1a0(%rbp)
jmp 0x5dc9
movq -0x1a0(%rbp), %rdi
movq 0x311c1(%rip), %rsi     # 0x36f98
callq 0x4580
jmp 0x5dde
leaq -0x178(%rbp), %rdi
callq 0x4300
jmp 0x5e0c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x100(%rbp)
movl %eax, -0x104(%rbp)
leaq -0x178(%rbp), %rdi
callq 0x4300
jmp 0x5e33
movl -0x38(%rbp), %eax
movl %eax, -0x4(%rbp)
leaq -0xf8(%rbp), %rdi
callq 0x6100
leaq -0x38(%rbp), %rdi
callq 0x60e0
movl -0x4(%rbp), %eax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbp
retq
leaq -0xf8(%rbp), %rdi
callq 0x6100
leaq -0x38(%rbp), %rdi
callq 0x60e0
movq -0x100(%rbp), %rdi
callq 0x4890
nopw %cs:(%rax,%rax)
// File: trapexit[P]bbf/src/bbf_captcha.cpp
// Function: bbf::captcha(Options const&)
AppError
  captcha(const Options &opts_)
  {
    int rv;
    BlkDev blkdev;

    rv = blkdev.open_read(opts_.device);
    if(rv == -ENOTBLK)
      rv = l::open_file_dev(blkdev,opts_.device);

    if(rv < 0)
      return AppError::opening_device(-rv,opts_.device);

    std::cout << captcha::calculate(blkdev) << std::endl;

    rv = blkdev.close();
    if(rv < 0)
      return AppError::closing_device(-rv,opts_.device);

    return AppError::success();
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x100(%rbp)
movq %rdi, %rax
movq %rax, -0xf8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0xb0(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0x14b10
movq -0xf0(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x14b80
movl %eax, -0xe4(%rbp)
jmp 0xa283
movl -0xe4(%rbp), %eax
movl %eax, -0x14(%rbp)
cmpl $-0xf, -0x14(%rbp)
jne 0xa2d0
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
leaq -0xb0(%rbp), %rdi
callq 0xa410
movl %eax, -0x104(%rbp)
jmp 0xa2ae
movl -0x104(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0xa2d0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0xa3f0
cmpl $0x0, -0x14(%rbp)
jge 0xa300
movq -0x100(%rbp), %rdi
movl -0x14(%rbp), %esi
negl %esi
movq -0x10(%rbp), %rdx
addq $0x8, %rdx
callq 0x17610
jmp 0xa2f1
movl $0x1, -0xc0(%rbp)
jmp 0xa3d4
leaq -0xe0(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x16d10
jmp 0xa315
movq 0x2cc94(%rip), %rdi     # 0x36fb0
leaq -0xe0(%rbp), %rsi
callq 0x44a0
movq %rax, -0x110(%rbp)
jmp 0xa331
movq -0x110(%rbp), %rdi
movq 0x2cc59(%rip), %rsi     # 0x36f98
callq 0x4580
jmp 0xa346
leaq -0xe0(%rbp), %rdi
callq 0x4300
leaq -0xb0(%rbp), %rdi
callq 0x14e00
movl %eax, -0x114(%rbp)
jmp 0xa366
movl -0x114(%rbp), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0xa3bc
movq -0x100(%rbp), %rdi
movl -0x14(%rbp), %esi
negl %esi
movq -0x10(%rbp), %rdx
addq $0x8, %rdx
callq 0x17690
jmp 0xa390
movl $0x1, -0xc0(%rbp)
jmp 0xa3d4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0xe0(%rbp), %rdi
callq 0x4300
jmp 0xa3f0
movq -0x100(%rbp), %rdi
callq 0x17420
jmp 0xa3ca
movl $0x1, -0xc0(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x14b40
movq -0xf8(%rbp), %rax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
leaq -0xb0(%rbp), %rdi
callq 0x14b40
movq -0xb8(%rbp), %rdi
callq 0x4890
nopl (%rax,%rax)
// File: trapexit[P]bbf/src/bbf_dump_files.cpp
// Function: operator<<(std::ostream&, std::_Rb_tree_const_iterator<std::pair<unsigned long const, std::pair<unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>> const&)
std::ostream&
operator<<(std::ostream                                      &os_,
           const BlockToFileMapper::BlockMap::const_iterator &i_)
{
  os_ << i_->first << " - "
      << (i_->first + i_->second.first - 1)
      << " "
      << i_->second.second;
  return os_;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa6c0
movq -0x30(%rbp), %rdi
movq (%rax), %rsi
callq 0x4100
movq %rax, %rdi
leaq 0x1946e(%rip), %rsi     # 0x23965
callq 0x4540
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa6c0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa6c0
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdi
addq 0x8(%rax), %rsi
subq $0x1, %rsi
callq 0x4100
movq %rax, %rdi
leaq 0x18db5(%rip), %rsi     # 0x232ed
callq 0x4540
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa6c0
movq -0x18(%rbp), %rdi
movq %rax, %rsi
addq $0x8, %rsi
addq $0x8, %rsi
callq 0x44a0
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: trapexit[P]bbf/src/bbf_dump_files.cpp
// Function: operator<<(std::ostream&, std::map<unsigned long, std::pair<unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::less<unsigned long>, std::allocator<std::pair<unsigned long const, std::pair<unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>> const&)
std::ostream&
operator<<(std::ostream                      &os_,
           const BlockToFileMapper::BlockMap &bm_)
{
  for(BlockToFileMapper::BlockMap::const_iterator
        i = bm_.begin(), ei = bm_.end();
      i != ei;
      ++i)
    {
      os_ << i << std::endl;
    }

  return os_;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa6f0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa720
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xa750
testb $0x1, %al
jne 0xa5ad
jmp 0xa5d4
movq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xa4c0
movq %rax, %rdi
movq 0x2c9d4(%rip), %rsi     # 0x36f98
callq 0x4580
leaq -0x18(%rbp), %rdi
callq 0xa780
jmp 0xa59a
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: trapexit[P]bbf/src/bbf_dump_files.cpp
// Function: bbf::dump_files(Options const&)
AppError
  dump_files(const Options &opts_)
  {
    int rv;
    BlockToFileMapper b2fm;

    rv = b2fm.scan(opts_.device);
    if(rv < 0)
      return AppError::opening_device(-rv,opts_.device);

    std::cout << b2fm.blockmap();

    return AppError::success();
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x154e0
movq -0x68(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x15500
movl %eax, -0x5c(%rbp)
jmp 0xa621
movl -0x5c(%rbp), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0xa665
movq -0x78(%rbp), %rdi
movl -0x14(%rbp), %esi
negl %esi
movq -0x10(%rbp), %rdx
addq $0x8, %rdx
callq 0x17610
jmp 0xa645
movl $0x1, -0x58(%rbp)
jmp 0xa698
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xa7b0
jmp 0xa6ae
leaq -0x48(%rbp), %rdi
callq 0x15a80
movq %rax, -0x80(%rbp)
jmp 0xa674
movq -0x80(%rbp), %rsi
movq 0x2c931(%rip), %rdi     # 0x36fb0
callq 0xa570
jmp 0xa686
movq -0x78(%rbp), %rdi
callq 0x17420
jmp 0xa691
movl $0x1, -0x58(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xa7b0
movq -0x70(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x4890
nopw (%rax,%rax)
// File: trapexit[P]bbf/src/bbf_file_blocks.cpp
// Function: bbf::file_blocks(Options const&)
AppError
  file_blocks(const Options &opts_)
  {
    int rv;
    File::BlockVector blockvector;

    rv = File::blocks(opts_.device,blockvector);
    if(rv < 0)
      return AppError::opening_file(-rv,opts_.device);

    for(uint64_t i = 0, ei = blockvector.size(); i != ei; i++)
      {
        uint64_t        j = blockvector[i].block;
        const uint64_t ej = blockvector[i].length + j;

        for(; j != ej; j++)
          {
            std::cout << j << std::endl;
          }
      }

    return AppError::success();
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0xadc0
movq -0x70(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x17d80
movl %eax, -0x64(%rbp)
jmp 0xac91
movl -0x64(%rbp), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0xacdb
movq -0x80(%rbp), %rdi
movl -0x14(%rbp), %esi
negl %esi
movq -0x10(%rbp), %rdx
addq $0x8, %rdx
callq 0x17890
jmp 0xacb5
movl $0x1, -0x40(%rbp)
jmp 0xad98
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xae20
jmp 0xadae
movq $0x0, -0x48(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xade0
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x50(%rbp), %rax
je 0xad86
movq -0x48(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0xae00
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x48(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0xae00
movq 0x8(%rax), %rax
addq -0x58(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rax
cmpq -0x60(%rbp), %rax
je 0xad73
movq -0x58(%rbp), %rsi
movq 0x2c270(%rip), %rdi     # 0x36fb0
callq 0x4100
movq %rax, -0x88(%rbp)
jmp 0xad4e
movq -0x88(%rbp), %rdi
movq 0x2c23c(%rip), %rsi     # 0x36f98
callq 0x4580
jmp 0xad63
jmp 0xad65
movq -0x58(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
jmp 0xad2b
jmp 0xad75
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0xacf0
movq -0x80(%rbp), %rdi
callq 0x17420
jmp 0xad91
movl $0x1, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xae20
movq -0x78(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x4890
nopw (%rax,%rax)
// File: trapexit[P]bbf/src/bbf_fsthrash.cpp
// Function: bbf::fsthrash(Options const&)
AppError
  fsthrash(const Options &opts_)
  {
    int rv;
    struct stat st;

    rv = stat(opts_.device.c_str(),&st);
    if(rv == -1)
      return AppError::opening_file(errno,opts_.device);
    if(!S_ISDIR(st.st_mode))
      return AppError::not_a_directory(opts_.device);

    return l::fsthrash(opts_);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xb8(%rbp)
movq %rdi, %rax
movq %rax, -0xb0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x4210
movq %rax, %rdi
leaq -0xa8(%rbp), %rsi
callq 0x44c0
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0xf4a6
callq 0x4070
movq -0xb8(%rbp), %rdi
movl (%rax), %esi
movq -0x10(%rbp), %rdx
addq $0x8, %rdx
callq 0x17890
jmp 0xf4de
movl -0x90(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x4000, %eax           # imm = 0x4000
je 0xf4ce
movq -0xb8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x17590
jmp 0xf4de
movq -0xb8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xdf60
movq -0xb0(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
nop
// File: trapexit[P]bbf/src/bbf_fsthrash.cpp
// Function: FSThrashState::rnd_file[abi:cxx11]()
std::string
  rnd_file(void)
  {
    std::string rv;

    pthread_mutex_lock(&mutex_file);
    if(!files.empty())
      rv = rnd::element(files);
    pthread_mutex_unlock(&mutex_file);

    return rv;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x46e0
movq -0x30(%rbp), %rdi
addq $0x98, %rdi
callq 0x4760
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
callq 0x10d50
testb $0x1, %al
jne 0x10d18
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
callq 0x10d90
movq %rax, -0x48(%rbp)
jmp 0x10cf0
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdi
callq 0x4060
jmp 0x10cff
jmp 0x10d18
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x4300
jmp 0x10d45
movq -0x30(%rbp), %rdi
addq $0x98, %rdi
callq 0x4400
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x10d3b
movq -0x40(%rbp), %rdi
callq 0x4300
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x4890
nop
// File: trapexit[P]bbf/src/bbf_fsthrash.cpp
// Function: FSThrashState::rnd_fd()
int
  rnd_fd(void)
  {
    int rv = -1;

    pthread_mutex_lock(&mutex_fd);
    if(!fds.empty())
      rv = rnd::element(fds);
    pthread_mutex_unlock(&mutex_fd);

    return rv;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
addq $0xc0, %rdi
callq 0x4760
movq -0x18(%rbp), %rdi
addq $0x58, %rdi
callq 0x11450
testb $0x1, %al
jne 0x10ffa
movq -0x18(%rbp), %rdi
addq $0x58, %rdi
callq 0x11490
movl (%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rdi
addq $0xc0, %rdi
callq 0x4400
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: trapexit[P]bbf/src/bbf_fsthrash.cpp
// Function: FSThrashState::rm_rnd_file[abi:cxx11]()
std::string
  rm_rnd_file(void)
  {
    size_t r;
    std::string rv;

    pthread_mutex_lock(&mutex_file);
    if(!files.empty())
      {
        r = (std::rand() % files.size());
        rv = files[r];
        std::swap(files[r],files[files.size()-1]);
        files.pop_back();
      }
    pthread_mutex_unlock(&mutex_file);

    return rv;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x46e0
movq -0x38(%rbp), %rdi
addq $0x98, %rdi
callq 0x4760
movq -0x38(%rbp), %rdi
addq $0x28, %rdi
callq 0x10d50
testb $0x1, %al
jne 0x116d7
callq 0x4130
movq -0x38(%rbp), %rdi
cltq
movq %rax, -0x50(%rbp)
addq $0x28, %rdi
movq %rdi, -0x58(%rbp)
callq 0x10850
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movq -0x50(%rbp), %rax
xorl %edx, %edx
divq %rcx
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rsi
callq 0x10eb0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x4060
jmp 0x11668
movq -0x38(%rbp), %rdi
addq $0x28, %rdi
movq -0x18(%rbp), %rsi
callq 0x10eb0
movq -0x38(%rbp), %rdi
movq %rax, -0x60(%rbp)
movq %rdi, %rax
addq $0x28, %rax
movq %rax, -0x68(%rbp)
addq $0x28, %rdi
callq 0x10850
movq -0x68(%rbp), %rdi
movq %rax, %rsi
subq $0x1, %rsi
callq 0x10eb0
movq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x11710
movq -0x38(%rbp), %rdi
addq $0x28, %rdi
callq 0x11740
jmp 0x116d7
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x4300
jmp 0x11704
movq -0x38(%rbp), %rdi
addq $0x98, %rdi
callq 0x4400
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x116fa
movq -0x48(%rbp), %rdi
callq 0x4300
movq -0x40(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x4890
nopl (%rax)