LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/ef-gy[P]libefgy/include/ef.gy/polytope.h
// Function: efgy::geometry::generators::cube<float, 3ul>::faces(efgy::geometry::parameters<float> const&)
static std::vector<face> faces(const parameters<Q> &parameter) {
    std::vector<face> res(source::size(), face());
    const auto pd = parameter.radius * Q(.5);
    const auto nd = parameter.radius * Q(-.5);
    auto r = res.begin();

    for (auto fa : source::faces()) {
      for (std::size_t j = 0; j < depth; j++) {
        (*r)[0][j] = fa[0][j] ? pd : nd;
        (*r)[1][j] = fa[1][j] ? pd : nd;
        (*r)[2][j] = fa[2][j] ? pd : nd;
        (*r)[3][j] = fa[3][j] ? pd : nd;
      }
      r++;
    }

    return res;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %r15
movaps %xmm0, 0x20(%r15)
movaps %xmm0, 0x10(%r15)
movaps %xmm0, (%r15)
movq %r15, %rdi
callq 0x1532a
pushq $0x6
popq %rsi
leaq 0x10(%rsp), %rcx
movq %rbx, %rdi
movq %r15, %rdx
callq 0x1534e
movss (%r14), %xmm0
movss %xmm0, 0xc(%rsp)
movq (%rbx), %r14
leaq 0x20(%rsp), %rdi
callq 0x153a4
movss 0xaf06(%rip), %xmm2     # 0x2014c
movss 0xc(%rsp), %xmm1
mulss %xmm1, %xmm2
mulss 0xaef8(%rip), %xmm1     # 0x20150
leaq 0x28(%rsp), %r15
movq 0x10(%r15), %rax
movss %xmm1, 0xc(%rsp)
movss %xmm2, 0x1c(%rsp)
cmpq %r15, %rax
je 0x152ff
movl 0x28(%rax), %ecx
movl %ecx, 0x18(%rsp)
movq 0x20(%rax), %rcx
movq %rcx, 0x10(%rsp)
xorl %ecx, %ecx
cmpq $0x3, %rcx
je 0x152e2
cmpb $0x0, 0x10(%rsp,%rcx)
movaps %xmm2, %xmm0
jne 0x1529b
movaps %xmm1, %xmm0
movss %xmm0, (%r14,%rcx,4)
cmpb $0x0, 0x13(%rsp,%rcx)
movaps %xmm2, %xmm0
jne 0x152ae
movaps %xmm1, %xmm0
movss %xmm0, 0xc(%r14,%rcx,4)
cmpb $0x0, 0x16(%rsp,%rcx)
movaps %xmm2, %xmm0
jne 0x152c2
movaps %xmm1, %xmm0
movss %xmm0, 0x18(%r14,%rcx,4)
cmpb $0x0, 0x19(%rsp,%rcx)
movaps %xmm2, %xmm0
jne 0x152d6
movaps %xmm1, %xmm0
movss %xmm0, 0x24(%r14,%rcx,4)
incq %rcx
jmp 0x15288
addq $0x30, %r14
movq %rax, %rdi
callq 0x4320
movss 0x1c(%rsp), %xmm2
movss 0xc(%rsp), %xmm1
jmp 0x1526d
leaq 0x20(%rsp), %rdi
callq 0x1579a
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x15646
movq %r14, %rdi
callq 0x4450
nop
// File: /workspace/github_cpp_makefile_star2_O2/ef-gy[P]libefgy/include/ef.gy/parametric.h
// Function: efgy::geometry::parametricIterator<float, 2ul, efgy::geometry::formula::plane>::operator*() const
const face operator*(void)const {
    auto f = base[basePosition];
    face g;
    auto o = g.begin();
    for (auto &p : f) {
      *o = std::array<Q, parent::renderDepth>(
          source::getCoordinates(parameter, getPosition() + p));
      o++;
    }
    return g;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x50(%rsi), %rax
movq 0x68(%rsi), %rcx
shlq $0x5, %rcx
movups (%rax,%rcx), %xmm0
movups 0x10(%rax,%rcx), %xmm1
movaps %xmm1, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
callq 0x14f7c
leaq 0x70(%r14), %r15
xorl %ebp, %ebp
leaq 0x8(%rsp), %r12
cmpq $0x20, %rbp
je 0x1aabb
leaq (%rsp,%rbp), %r13
addq $0x10, %r13
movq %r14, %rdi
callq 0x1b608
movq %r13, %rdi
callq 0x1b6aa
movlps %xmm0, 0x8(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x1b680
movlps %xmm0, (%rbx,%rbp)
addq $0x8, %rbp
jmp 0x1aa83
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
movq %rdi, %rax
movq 0x58(%rdi), %rcx
movq 0x68(%rdi), %rdx
incq %rdx
movq %rdx, 0x68(%rdi)
subq 0x50(%rdi), %rcx
sarq $0x5, %rcx
cmpq %rcx, %rdx
jae 0x1aaee
retq
andq $0x0, 0x68(%rax)
pushq $0x1
popq %rcx
testl %ecx, %ecx
js 0x1aaed
movl %ecx, %edx
shlq $0x4, %rdx
movq (%rax), %rsi
movq 0x30(%rax), %r9
movq 0x8(%rsi,%rdx), %rdi
addq %rdx, %rsi
movq 0x8(%r9,%rdx), %r8
cmpq %r8, %rdi
jae 0x1ab2b
leaq (%r9,%rdx), %r8
addq $0x8, %r8
incq %rdi
movq %rdi, 0x8(%rsi)
movq (%r8), %r8
cmpq %r8, %rdi
jb 0x1aaed
subl $0x1, %ecx
jb 0x1aaf6
movq 0x18(%rax), %rdi
movups (%rdi,%rdx), %xmm0
movups %xmm0, (%rsi)
jmp 0x1aaf6
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x170, %rsp            # imm = 0x170
movq %rdi, %rbx
leaq 0xb8(%rsp), %rdi
movq %rbx, %rsi
callq 0x1a9d0
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x1a9e2
leaq 0xb8(%rsp), %rdi
movq %rsp, %rsi
callq 0x1b6d4
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1ab42
leaq 0xb8(%rsp), %rdi
callq 0x1ab42
movq %rbx, %rax
addq $0x170, %rsp            # imm = 0x170
popq %rbx
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1ab42
jmp 0x1abe0
movq %rax, %rbx
leaq 0xb8(%rsp), %rdi
callq 0x1ab42
movq %rbx, %rdi
callq 0x4450
nop
// File: /workspace/github_cpp_makefile_star2_O2/ef-gy[P]libefgy/include/ef.gy/parametric.h
// Function: efgy::geometry::parametricIterator<float, 3ul, efgy::geometry::formula::plane>::parametricIterator(efgy::geometry::parameters<float> const&)
parametricIterator(const parameters<Q> &pParameter) : parameter(pParameter) {
    for (std::size_t dim = 0; dim < od; dim++) {
      range<Q> qs = source::getRange(parameter, dim);
      positions.push_back(qs.begin());
      starts.push_back(qs.begin());
      ends.push_back(qs.end());
      strides[dim] = qs.stride;
    }

    base = getBase(strides);
    basePosition = 0;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movups %xmm0, 0x40(%rdi)
andl $0x0, 0x50(%rdi)
leaq 0x18(%rdi), %rax
movq %rax, 0x28(%rsp)
leaq 0x30(%rdi), %r15
leaq 0x58(%rdi), %rax
movq %rax, 0x20(%rsp)
movups %xmm0, 0x58(%rdi)
andq $0x0, 0x68(%rdi)
leaq 0x78(%rdi), %r13
movq %r13, %rdi
callq 0x1ad6c
leaq 0x48(%rbx), %rax
movq %rax, 0x40(%rsp)
xorl %r12d, %r12d
leaq 0x8(%rsp), %rbp
cmpq $0x3, %r12
je 0x1bb1f
movq %r13, %rdi
movq %r12, %rsi
callq 0x1bbb2
movaps %xmm0, 0x30(%rsp)
movq %rax, %r14
movaps 0x30(%rsp), %xmm0
movlps %xmm0, 0x8(%rsp)
andq $0x0, 0x10(%rsp)
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x1b0bc
movaps 0x30(%rsp), %xmm0
movlps %xmm0, 0x8(%rsp)
andq $0x0, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movq %rbp, %rsi
callq 0x1b0bc
movaps 0x30(%rsp), %xmm0
movlps %xmm0, 0x8(%rsp)
movq %r14, 0x10(%rsp)
movq %r15, %rdi
movq %rbp, %rsi
callq 0x1b0bc
movaps 0x30(%rsp), %xmm0
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
movss %xmm0, 0x48(%rbx,%r12,4)
incq %r12
jmp 0x1ba9f
leaq 0x8(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x1bc16
leaq 0x8(%rsp), %rsi
movq 0x20(%rsp), %rdi
callq 0x1bd70
leaq 0x8(%rsp), %rdi
callq 0x15646
andq $0x0, 0x70(%rbx)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
leaq 0x8(%rsp), %rdi
callq 0x15646
jmp 0x1bb7a
jmp 0x1bb77
movq %rax, %r12
jmp 0x1bb86
jmp 0x1bb77
jmp 0x1bb77
jmp 0x1bb77
movq %rax, %r12
leaq 0xa8(%rbx), %rdi
callq 0x14d80
movq 0x20(%rsp), %rdi
callq 0x15646
movq %r15, %rdi
callq 0x1b3cc
movq 0x28(%rsp), %rdi
callq 0x1b3cc
movq %rbx, %rdi
callq 0x1b3cc
movq %r12, %rdi
callq 0x4450
// File: /workspace/github_cpp_makefile_star2_O2/ef-gy[P]libefgy/include/ef.gy/parametric.h
// Function: efgy::geometry::parametricIterator<float, 2ul, efgy::geometry::formula::plane>::getBase(efgy::math::vector<float, 2u, efgy::math::format::cartesian> const&)
static const faces getBase(const vector &strides) {
    parameters<Q> cubeParameter;
    cube<Q, od> cube(cubeParameter);
    faces base;

    const Q r2 = cubeParameter.radius / Q(2);

    for (auto f : cube) {
      auto cf = f;
      for (auto &v : cf) {
        auto s = strides.begin();
        for (auto &q : v) {
          q = (q + r2) * (*s);
          s++;
        }
      }
      base.push_back(cf);
    }

    return base;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x80(%rsp), %r12
movq %r12, %rdi
callq 0x14b62
leaq 0x48(%rsp), %r14
movq %r12, -0x10(%r14)
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
andq $0x0, 0x10(%r14)
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
movss (%r12), %xmm0
movss %xmm0, 0xc(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x14c2e
movq %rax, %r12
movss 0xc(%rsp), %xmm0
mulss 0x52ed(%rip), %xmm0     # 0x2014c
movss %xmm0, 0xc(%rsp)
movq 0x50(%rsp), %rbp
leaq 0x10(%rsp), %r13
cmpq %rbp, %r12
je 0x1aedd
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movaps %xmm1, 0x70(%rsp)
movaps %xmm0, 0x60(%rsp)
movaps %xmm1, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movq %r13, %rax
xorl %ecx, %ecx
cmpq $0x20, %rcx
je 0x1aecc
addq $0x8, %rcx
xorl %edx, %edx
cmpq $0x8, %rdx
je 0x1aec6
movss (%rax,%rdx), %xmm0
addss 0xc(%rsp), %xmm0
mulss (%r15,%rdx), %xmm0
movss %xmm0, (%rax,%rdx)
addq $0x4, %rdx
jmp 0x1aea4
addq $0x8, %rax
jmp 0x1ae98
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1b252
addq $0x20, %r12
jmp 0x1ae6f
movq %r14, %rdi
callq 0x1501a
leaq 0xb0(%rsp), %rdi
callq 0x14d80
movq %rbx, %rax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1af09
movq %rax, %r15
movq %rbx, %rdi
callq 0x1501a
movq %r14, %rdi
callq 0x1501a
leaq 0xb0(%rsp), %rdi
callq 0x14d80
movq %r15, %rdi
callq 0x4450
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
movl (%rsi), %eax
movl %eax, -0x8(%rsp)
andl $0x0, -0x4(%rsp)
xorl %eax, %eax
cmpq $0x2, %rax
je 0x1b6a3
movss (%rsi,%rax,4), %xmm0
movss %xmm0, -0x8(%rsp,%rax,4)
incq %rax
jmp 0x1b68d
movsd -0x8(%rsp), %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O2/ef-gy[P]libefgy/include/ef.gy/parametric.h
// Function: efgy::geometry::parametricIterator<float, 3ul, 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:
andl $0x0, -0x8(%rsp)
andq $0x0, -0x10(%rsp)
movq (%rdi), %rax
xorl %ecx, %ecx
cmpq $0xc, %rcx
je 0x1c22d
movq 0x8(%rax,%rcx,4), %rdx
testq %rdx, %rdx
js 0x1c201
cvtsi2ss %rdx, %xmm0
jmp 0x1c216
movq %rdx, %rsi
shrq %rsi
andl $0x1, %edx
orq %rsi, %rdx
cvtsi2ss %rdx, %xmm0
addss %xmm0, %xmm0
mulss 0x4(%rax,%rcx,4), %xmm0
addss (%rax,%rcx,4), %xmm0
movss %xmm0, -0x10(%rsp,%rcx)
addq $0x4, %rcx
jmp 0x1c1ea
movsd -0x10(%rsp), %xmm0
movss -0x8(%rsp), %xmm1
retq
// File: /workspace/github_cpp_makefile_star2_O2/ef-gy[P]libefgy/include/ef.gy/ifs.h
// Function: efgy::geometry::ifs<float, 3ul, 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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %r12
movq 0x28(%rsi), %rax
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movaps %xmm2, 0x40(%rsp)
movaps %xmm1, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
callq 0x1532a
xorl %r13d, %r13d
leaq 0x8(%rsp), %r15
movq %r12, (%rsp)
cmpq $0x30, %r13
je 0x1dd66
movl 0x28(%rsp,%r13), %eax
movl %eax, 0x8(%r12)
movq 0x20(%rsp,%r13), %rax
movq %rax, (%r12)
movq %r15, %rdi
movq %r14, %rsi
callq 0x1e594
movq 0x8(%rsp), %rbp
movq 0x10(%rsp), %rbx
cmpq %rbx, %rbp
je 0x1dd54
movq (%rbp), %rdi
shlq $0x6, %rdi
addq 0x30(%r14), %rdi
movq %r12, %rsi
callq 0x1e636
movlps %xmm0, (%r12)
movss %xmm1, 0x8(%r12)
addq $0x8, %rbp
jmp 0x1dd29
movq %r15, %rdi
callq 0x9cfe
addq $0xc, %r12
addq $0xc, %r13
jmp 0x1dcfb
movq (%rsp), %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x9cfe
movq %rbx, %rdi
callq 0x4450
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rax
movq 0x28(%rdi), %rcx
cmpq %rax, %rcx
je 0x1d144
addq $0x20, %rcx
movq %rcx, 0x28(%rbx)
cmpq %rax, %rcx
jne 0x1d154
movq %rbx, %rdi
callq 0x14c2e
movq %rax, 0x28(%rbx)
incq 0x48(%rbx)
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x28, %rsp
movq (%rdi), %rax
leaq 0x10(%rsp), %rbx
movq %rax, -0x10(%rbx)
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rbx)
movups %xmm0, (%rbx)
movl 0x10(%rax), %eax
cvtsi2sd %rax, %xmm1
movsd 0x2fd8(%rip), %xmm0     # 0x20160
callq 0x4430
cvttsd2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0x2fc7(%rip), %xmm0     # 0x20168
cvttsd2si %xmm0, %r14
andq %rcx, %r14
orq %rax, %r14
movq %rbx, %rdi
callq 0x1501a
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ef-gy[P]libefgy/include/ef.gy/ifs.h
// Function: efgy::geometry::generators::gasket<float, 3ul, 3ul>::functions(efgy::geometry::parameters<float> const&)
static std::vector<translation> functions(const parameters<Q> &parameter) {
    std::vector<translation> rv = {};

    const std::size_t nfunctions = (1 << (depth - 1)) + 1;
    std::array<math::vector<Q, renderDepth>, nfunctions> translations;

    translations[0][0] = Q(0.25);

    for (std::size_t i = 1; i < translations.size(); i++) {
      translations[i][0] = Q(-0.25);
      for (std::size_t j = 1; j < depth; j++) {
        const std::size_t k = i - 1;
        const std::size_t l = j - 1;
        const std::size_t b = 1 << l;
        const bool s = k & b;
        translations[i][j] = Q(s ? -0.25 : 0.25);
      }
    }

    for (const auto &t : translations) {
      rv.push_back(scale(0.5) * translate(t));
    }

    return rv;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x10(%rsp), %rdi
callq 0x1e004
leaq 0x20(%rsp), %rax
movl $0x3e800000, -0x10(%rax) # imm = 0x3E800000
pushq $0x1
popq %rcx
leaq 0x2319(%rip), %rdx      # 0x20188
cmpq $0x5, %rcx
je 0x1deb4
imulq $0xc, %rcx, %rsi
movl $0xbe800000, 0x10(%rsp,%rsi) # imm = 0xBE800000
leaq 0x7fffffff(%rcx), %rsi
xorl %edi, %edi
cmpq $0x2, %rdi
je 0x1deab
xorl %r8d, %r8d
btq %rdi, %rsi
setae %r8b
movss (%rdx,%r8,4), %xmm0
movss %xmm0, (%rax,%rdi,4)
incq %rdi
jmp 0x1de8a
incq %rcx
addq $0xc, %rax
jmp 0x1de6f
xorl %ebp, %ebp
leaq 0x8c(%rsp), %r14
leaq 0xc(%rsp), %r15
leaq 0xd0(%rsp), %r12
leaq 0x4c(%rsp), %r13
cmpq $0x3c, %rbp
je 0x1df18
movl $0x3f000000, 0xc(%rsp)  # imm = 0x3F000000
movq %r14, %rdi
movq %r15, %rsi
callq 0x1e01c
leaq (%rsp,%rbp), %rsi
addq $0x10, %rsi
movq %r12, %rdi
callq 0x1e064
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x1e2a7
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1e0b6
addq $0xc, %rbp
jmp 0x1ded0
movq %rbx, %rax
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1df31
jmp 0x1df31
movq %rax, %r14
movq %rbx, %rdi
callq 0x1e498
movq %r14, %rdi
callq 0x4450
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
movq %rdi, %rax
leaq 0xc(%rdx), %rcx
leaq 0x4(%rsi), %rdi
xorl %r8d, %r8d
cmpq $0x3, %r8
je 0x1d6c8
imulq $0xc, %r8, %r9
movss (%rsi,%r9), %xmm0
addq %rax, %r9
movq %rcx, %r10
xorl %r11d, %r11d
cmpq $0x3, %r11
je 0x1d6bf
movss (%rdx,%r11,4), %xmm1
mulss %xmm0, %xmm1
movq %r10, %rbx
xorl %r14d, %r14d
cmpq $0x2, %r14
je 0x1d6b0
movss (%rdi,%r14,4), %xmm2
mulss (%rbx), %xmm2
addss %xmm2, %xmm1
incq %r14
addq $0xc, %rbx
jmp 0x1d693
movss %xmm1, (%r9,%r11,4)
incq %r11
addq $0x4, %r10
jmp 0x1d67d
incq %r8
addq $0xc, %rdi
jmp 0x1d664
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/ef-gy[P]libefgy/include/ef.gy/matrix.h
// Function: efgy::math::matrix<float, 3ul, 3ul>::matrix<3ul, 3ul, efgy::geometry::transformation::generator::translate>(efgy::math::ghost::matrix<float, 3ul, 3ul, efgy::geometry::transformation::generator::translate> 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:
xorl %eax, %eax
movss 0x29b4(%rip), %xmm0     # 0x20148
cmpq $0x3, %rax
je 0x1d7db
xorl %ecx, %ecx
cmpq $0x3, %rcx
je 0x1d7d2
cmpq $0x2, %rax
setne %dl
cmpq $0x2, %rcx
sete %r8b
orb %dl, %r8b
jne 0x1d7bd
movss (%rsi,%rcx,4), %xmm1
jmp 0x1d7c8
movaps %xmm0, %xmm1
cmpq %rcx, %rax
je 0x1d7c8
xorps %xmm1, %xmm1
movss %xmm1, (%rdi,%rcx,4)
incq %rcx
jmp 0x1d79c
incq %rax
addq $0xc, %rdi
jmp 0x1d794
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movq %rdi, %rax
xorl %ecx, %ecx
movq %rdi, %rdx
cmpq $0x3, %rcx
je 0x1d750
xorl %edi, %edi
cmpq $0x3, %rdi
je 0x1d743
movss (%rsi,%rdi,4), %xmm0
movss %xmm0, (%rdx,%rdi,4)
incq %rdi
jmp 0x1d72e
incq %rcx
addq $0xc, %rdx
addq $0xc, %rsi
jmp 0x1d726
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq 0x48(%rsi), %r12
xorl %r13d, %r13d
pushq $0x24
popq %rbp
movq %rsp, %r15
cmpq 0x50(%r14), %r13
jae 0x1d9bc
movq 0x38(%r14), %rax
subq 0x30(%r14), %rax
cqto
idivq %rbp
movq %rax, %rcx
movq %r12, %rax
xorl %edx, %edx
divq %rcx
movq %rdx, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1da70
movq 0x38(%r14), %rax
subq 0x30(%r14), %rax
cqto
idivq %rbp
movq %rax, %rcx
movq %r12, %rax
xorl %edx, %edx
divq %rcx
incq %r13
movq %rax, %r12
jmp 0x1d96f
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
callq 0x1db69
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1d9dc
movq %rax, %r14
movq %rbx, %rdi
callq 0x9cfe
movq %r14, %rdi
callq 0x4450
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x30, %rsp
movq %rdi, %rax
andq $0x0, 0x8(%rsp)
xorl %ecx, %ecx
cmpq $0x2, %rcx
je 0x1da16
movss (%rsi,%rcx,4), %xmm0
movss %xmm0, 0x14(%rsp,%rcx,4)
incq %rcx
jmp 0x1da00
leaq 0x14(%rsp), %rbx
movl $0x3f800000, 0x8(%rbx)  # imm = 0x3F800000
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1db8a
leaq 0x20(%rsp), %rsi
movlps %xmm0, (%rsi)
movss %xmm1, 0x8(%rsi)
movq %rbx, %rdi
callq 0x1dbe4
xorl %eax, %eax
movss 0x8(%rbx), %xmm0
cmpq $0x2, %rax
je 0x1da64
movss 0x14(%rsp,%rax,4), %xmm1
divss %xmm0, %xmm1
movss %xmm1, 0x8(%rsp,%rax,4)
incq %rax
jmp 0x1da49
movsd 0x8(%rsp), %xmm0
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x1d06c
movq %rbx, %rdi
callq 0x1532a
xorl %eax, %eax
movq %rbx, %rcx
cmpq $0x4, %rax
je 0x1f33b
xorl %edx, %edx
cmpq $0x2, %rdx
je 0x1f32e
movss (%r14,%rdx,4), %xmm0
movss %xmm0, (%rcx,%rdx,4)
incq %rdx
jmp 0x1f318
incq %rax
addq $0xc, %rcx
addq $0x8, %r14
jmp 0x1f310
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
callq 0x4350
leaq 0xd475(%rip), %rdi      # 0x12004
callq 0x4540
testq %rax, %rax
je 0x4b9e
cmpb $0x0, (%rax)
jne 0x4ba5
leaq 0xd464(%rip), %rax      # 0x12009
leaq 0x38(%rsp), %rdi
movq %rax, %rsi
callq 0x44b0
leaq 0xd456(%rip), %rsi      # 0x1200f
movq %rax, %rdi
callq 0x44b0
movq %rax, %r15
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0xb418
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x4430
leaq 0x8(%rsp), %rdi
callq 0x4200
leaq 0x40(%rsp), %rsi
movq %rbx, %rdi
callq 0x4680
leaq 0x28(%rsp), %rdi
callq 0x43a0
movq %rbx, %rax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4200
jmp 0x4c23
jmp 0x4c20
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x43a0
movq %rbx, %rdi
callq 0x4730
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xd3cd(%rip), %rsi      # 0x1201b
callq 0x4e48
testb %al, %al
je 0x4c6a
movq 0x1c37a(%rip), %rdi     # 0x20fd8
movq %rbx, %rsi
callq 0x4cf8
xorl %eax, %eax
jmp 0x4cd6
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x4500
movq (%r14), %rsi
pushq $0x8
popq %rdx
movq %r15, %rdi
callq 0x42d0
leaq 0x80(%rsp), %rdi
callq 0x40d0
testb %al, %al
je 0x4cc9
movq 0x8(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x1, 0x28(%rsp,%rax)
jne 0x4cc9
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x4cf8
leaq 0x8(%rsp), %rdi
callq 0x40c0
leaq 0x8(%rsp), %rdi
callq 0x40e0
jmp 0x4c66
leaq 0x8(%rsp), %rdi
callq 0x40e0
pushq $-0x1
popq %rax
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x40e0
movq %rbx, %rdi
callq 0x4730
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xd2b6(%rip), %rsi      # 0x1201b
callq 0x4e48
testb %al, %al
je 0x4d81
movq 0x1c243(%rip), %rdi     # 0x20fb8
movq %rbx, %rsi
callq 0x4dff
xorl %eax, %eax
jmp 0x4ddf
movq %rsp, %r15
movq %r15, %rdi
callq 0x4710
movq (%r14), %rsi
pushq $0x10
popq %rdx
movq %r15, %rdi
callq 0x4070
leaq 0x70(%rsp), %rdi
callq 0x40d0
testb %al, %al
je 0x4dd4
movq (%rsp), %rax
movq -0x18(%rax), %rax
testb $0x1, 0x20(%rsp,%rax)
jne 0x4dd4
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x4dff
movq %rsp, %rdi
callq 0x45f0
movq %rsp, %rdi
callq 0x4620
jmp 0x4d7d
movq %rsp, %rdi
callq 0x4620
pushq $-0x1
popq %rax
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4620
movq %rbx, %rdi
callq 0x4730
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xe0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x48(%rsp), %r15
movq %r15, %rdi
callq 0xa986
addq $0x8, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0xa9d2
movl %eax, %ebp
cmpl $-0xf, %eax
jne 0x6492
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0xbeec
leaq 0x8(%rsp), %r15
leaq 0x28(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x4550
movq %r12, %rdi
callq 0x4200
cmpq $0x0, 0x8(%r15)
je 0x6485
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xa9d2
movl %eax, %ebp
jmp 0x6488
pushq $-0x2
popq %rbp
leaq 0x8(%rsp), %rdi
callq 0x4200
testl %ebp, %ebp
js 0x64e0
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0xb418
movq 0x1ab0c(%rip), %rdi     # 0x20fb8
leaq 0x8(%rsp), %rsi
callq 0x4430
movq %rax, %rdi
callq 0x4230
leaq 0x8(%rsp), %rdi
callq 0x4200
leaq 0x48(%rsp), %rdi
callq 0xab30
testl %eax, %eax
js 0x64f1
movq %rbx, %rdi
callq 0xb6d0
jmp 0x6500
negl %ebp
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0xb82c
jmp 0x6500
negl %eax
movq %rbx, %rdi
movl %eax, %esi
movq %r14, %rdx
callq 0xb884
leaq 0x48(%rsp), %rdi
callq 0xa9b6
movq %rbx, %rax
addq $0xe0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6523
jmp 0x6523
jmp 0x6532
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4200
jmp 0x6535
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xa9b6
movq %rbx, %rdi
callq 0x4730
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x20(%rax), %rsi
callq 0x4320
leaq 0xc3fc(%rip), %rsi      # 0x12961
movq %rax, %rdi
callq 0x44b0
movq (%r14), %rcx
movq 0x20(%rcx), %rdx
movq 0x28(%rcx), %rcx
leaq (%rdx,%rcx), %rsi
decq %rsi
movq %rax, %rdi
callq 0x4320
leaq 0xbd5e(%rip), %rsi      # 0x122ec
movq %rax, %rdi
callq 0x44b0
movq (%r14), %rsi
addq $0x30, %rsi
movq %rax, %rdi
callq 0x4430
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rsi), %r12
movq %rsp, %r15
movq %r12, (%r15)
addq $0x8, %r14
cmpq %r14, %r12
je 0x65f5
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6548
movq %rbx, %rdi
callq 0x4230
movq %r12, %rdi
callq 0x4510
movq %rax, %r12
movq %rax, (%rsp)
jmp 0x65cc
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movq %r15, %rdi
callq 0xad94
addq $0x8, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0xadb0
testl %eax, %eax
js 0x6652
movq %rsp, %rdi
callq 0xb19e
movq 0x1a978(%rip), %rdi     # 0x20fb8
movq %rax, %rsi
callq 0x65b0
movq %rbx, %rdi
callq 0xb6d0
jmp 0x6661
negl %eax
movq %rbx, %rdi
movl %eax, %esi
movq %r14, %rdx
callq 0xb82c
movq %rsp, %rdi
callq 0x668a
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x668a
movq %rbx, %rdi
callq 0x4730
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
addq $0x8, %r14
movq %r14, %rdi
callq 0xbcb5
testl %eax, %eax
js 0x677f
movq 0x8(%rsp), %r12
subq (%rsp), %r12
sarq $0x4, %r12
xorl %r13d, %r13d
movq 0x1a87f(%rip), %r14     # 0x20fb8
cmpq %r12, %r13
je 0x6775
movq (%rsp), %rax
movq %r13, %rcx
shlq $0x4, %rcx
movq (%rax,%rcx), %r15
movq 0x8(%rax,%rcx), %rbp
subq $0x1, %rbp
jb 0x6770
movq %r14, %rdi
movq %r15, %rsi
callq 0x4320
movq %rax, %rdi
callq 0x4230
incq %r15
jmp 0x6752
incq %r13
jmp 0x6739
movq %rbx, %rdi
callq 0xb6d0
jmp 0x678e
negl %eax
movq %rbx, %rdi
movl %eax, %esi
movq %r14, %rdx
callq 0xb9e4
movq %rsp, %rdi
callq 0x67be
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x67aa
movq %rax, %rbx
movq %rsp, %rdi
callq 0x67be
movq %rbx, %rdi
callq 0x4730
nop
// File: /workspace/github_cpp_makefile_star2_O2/trapexit[P]bbf/src/bbf_find_files.cpp
// Function: bbf::find_files(Options const&)
AppError
  find_files(const Options &opts_)
  {
    int rv;
    BlockToFileMapper b2fm;
    std::vector<uint64_t> badblocks;

    rv = BadBlockFile::read(opts_.input_file,badblocks);
    if(rv < 0)
      return AppError::reading_badblocks_file(-rv,opts_.input_file);

    b2fm.scan(opts_.device);

    const std::string none = "[none]";
    for(uint64_t i = 0, ei = badblocks.size(); i != ei; i++)
      {
        std::pair<bool,std::string> entry;
        const uint64_t badblock = badblocks[i];

        entry = b2fm.find(badblock);

        std::cout << badblock
                  << " "
                  << (entry.first ? entry.second : none)
                  << std::endl;
      }

    return AppError::success();
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x70(%rsp), %rdi
callq 0xad94
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
leaq 0x78(%rbx), %r14
movq %r14, %rdi
callq 0x4c35
testl %eax, %eax
js 0x6e65
addq $0x8, %rbx
leaq 0x70(%rsp), %rdi
movq %rbx, %rsi
callq 0xadb0
movq %r15, 0x20(%rsp)
leaq 0xb4c7(%rip), %rsi      # 0x12243
leaq 0x50(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x5cd4
movq 0x8(%rsp), %rbx
subq (%rsp), %rbx
sarq $0x3, %rbx
leaq 0x30(%rsp), %r15
xorl %r14d, %r14d
leaq 0xa0(%rsp), %r13
xorl %r12d, %r12d
cmpq %r12, %rbx
je 0x6e4c
movb %r14b, 0x28(%rsp)
leaq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
andq $0x0, 0x38(%rsp)
movb %r14b, 0x40(%rsp)
movq (%rsp), %rax
movq (%rax,%r12,8), %rbp
movq %r13, %rdi
leaq 0x70(%rsp), %rsi
movq %rbp, %rdx
callq 0xb0ee
leaq 0x28(%rsp), %rdi
movq %r13, %rsi
callq 0x6ed8
leaq 0xa8(%rsp), %rdi
callq 0x4200
movq 0x1a1b1(%rip), %rdi     # 0x20fb8
movq %rbp, %rsi
callq 0x4320
movq %rax, %rdi
leaq 0xb4d3(%rip), %rsi      # 0x122ec
callq 0x44b0
cmpb $0x0, 0x28(%rsp)
leaq 0x50(%rsp), %rsi
cmovneq %r15, %rsi
movq %rax, %rdi
callq 0x4430
movq %rax, %rdi
callq 0x4230
movq %r15, %rdi
callq 0x4200
incq %r12
jmp 0x6dab
movq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0xb6d0
leaq 0x50(%rsp), %rdi
callq 0x4200
jmp 0x6e74
negl %eax
movq %r15, %rdi
movl %eax, %esi
movq %r14, %rdx
callq 0xb934
movq %rsp, %rdi
callq 0x63d8
leaq 0x70(%rsp), %rdi
callq 0x668a
movq %r15, %rax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x6eb4
jmp 0x6ea2
movq %rax, %rbx
jmp 0x6ebe
jmp 0x6ea9
movq %rax, %rbx
movq %r15, %rdi
callq 0x4200
leaq 0x50(%rsp), %rdi
callq 0x4200
movq %rsp, %rdi
callq 0x63d8
leaq 0x70(%rsp), %rdi
callq 0x668a
movq %rbx, %rdi
callq 0x4730
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsi), %r14
movq 0x8(%rsi), %rdi
movq %rsp, %rsi
callq 0x4450
cmpl $-0x1, %eax
je 0x87d5
movl $0xf000, %eax           # imm = 0xF000
andl 0x18(%rsp), %eax
movq %rbx, %rdi
cmpl $0x4000, %eax           # imm = 0x4000
jne 0x87e9
movq %r15, %rsi
callq 0x78dc
jmp 0x87f1
callq 0x4050
movl (%rax), %esi
movq %rbx, %rdi
movq %r14, %rdx
callq 0xb9e4
jmp 0x87f1
movq %r14, %rsi
callq 0xb7d2
movq %rbx, %rax
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r15
movb $0x0, 0x10(%rdi)
leaq 0x98(%rsi), %r14
movq %r14, %rdi
callq 0x4610
movq 0x28(%r15), %rax
cmpq 0x30(%r15), %rax
je 0x8e03
addq $0x28, %r15
movq %r15, %rdi
callq 0x8e27
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4260
movq %r14, %rdi
callq 0x43b0
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x4200
movq %r14, %rdi
callq 0x4730
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0xc0(%rdi), %rbx
movq %rbx, %rdi
callq 0x4610
movq 0x58(%r14), %rax
cmpq 0x60(%r14), %rax
je 0x8ee2
addq $0x58, %r14
movq %r14, %rdi
callq 0x8fcb
movl (%rax), %ebp
jmp 0x8ee5
pushq $-0x1
popq %rbp
movq %rbx, %rdi
callq 0x43b0
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r15
movb $0x0, 0x10(%rdi)
leaq 0x98(%rsi), %r14
movq %r14, %rdi
callq 0x4610
movq 0x28(%r15), %rax
cmpq 0x30(%r15), %rax
je 0x9075
callq 0x4100
cltq
movq 0x28(%r15), %rsi
movq 0x30(%r15), %rcx
subq %rsi, %rcx
sarq $0x5, %rcx
xorl %edx, %edx
divq %rcx
movq %rdx, %r12
shlq $0x5, %r12
addq %r12, %rsi
movq %rbx, %rdi
callq 0x4260
leaq 0x28(%r15), %r13
addq 0x28(%r15), %r12
movq 0x30(%r15), %rsi
addq $-0x20, %rsi
movq %r12, %rdi
callq 0x4370
movq %r13, %rdi
callq 0x909e
movq %r14, %rdi
callq 0x43b0
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x4200
movq %r14, %rdi
callq 0x4730
nop
// File: /workspace/github_cpp_makefile_star2_O2/trapexit[P]bbf/src/bbf_fsthrash.cpp
// Function: FSThrashState::rm_rnd_dir[abi:cxx11]()
std::string
  rm_rnd_dir(void)
  {
    size_t r;
    std::string rv;

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

    return rv;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r15
movb $0x0, 0x10(%rdi)
leaq 0x70(%rsi), %r14
movq %r14, %rdi
callq 0x4610
movq 0x40(%r15), %rax
cmpq 0x48(%r15), %rax
je 0x9134
callq 0x4100
cltq
movq 0x40(%r15), %rsi
movq 0x48(%r15), %rcx
subq %rsi, %rcx
sarq $0x5, %rcx
xorl %edx, %edx
divq %rcx
movq %rdx, %r12
shlq $0x5, %r12
addq %r12, %rsi
movq %rbx, %rdi
callq 0x4260
leaq 0x40(%r15), %r13
addq 0x40(%r15), %r12
movq 0x48(%r15), %rsi
addq $-0x20, %rsi
movq %r12, %rdi
callq 0x4370
movq %r13, %rdi
callq 0x909e
movq %r14, %rdi
callq 0x43b0
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x4200
movq %r14, %rdi
callq 0x4730
// File: /workspace/github_cpp_makefile_star2_O2/trapexit[P]bbf/src/bbf_fsthrash.cpp
// Function: FSThrashState::rm_rnd_fd()
int
  rm_rnd_fd(void)
  {
    int rv;
    size_t r;

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

    return rv;
  }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0xc0(%rdi), %rbx
movq %rbx, %rdi
callq 0x4610
movq 0x58(%r14), %rax
cmpq 0x60(%r14), %rax
je 0x91b0
callq 0x4100
cltq
movq 0x58(%r14), %rcx
movq 0x60(%r14), %rsi
movq %rsi, %rdi
subq %rcx, %rdi
sarq $0x2, %rdi
xorl %edx, %edx
divq %rdi
movl (%rcx,%rdx,4), %ebp
movl -0x4(%rsi), %eax
movl %eax, (%rcx,%rdx,4)
movl %ebp, -0x4(%rsi)
addq $-0x4, %rsi
movq %rsi, 0x60(%r14)
jmp 0x91b3
pushq $-0x1
popq %rbp
movq %rbx, %rdi
callq 0x43b0
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/trapexit[P]bbf/src/blkdev.cpp
// Function: BlkDev::open(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
int
BlkDev::open(const std::string &path,
             const int          flags)
{
  int64_t rv;

  _fd = ::open(path.c_str(),flags);
  if(_fd == -1)
    return -errno;

  rv = l::block_device(_fd);
  if(rv < 0)
    goto error;

  rv = sg::identify(_fd,_identity);
  if(rv == 0)
    _has_identity = true;

  rv = IOCtl::logical_block_size(_fd);
  if(rv < 0)
    goto error;
  _logical_block_size = rv;

  rv = IOCtl::physical_block_size(_fd);
  if(rv < 0)
    goto error;
  _physical_block_size = rv;

  rv = IOCtl::size_in_bytes(_fd);
  if(rv < 0)
    goto error;
  _size_in_bytes = rv;

  _logical_block_count  = (_size_in_bytes / _logical_block_size);
  _physical_block_count = (_size_in_bytes / _physical_block_size);

  ::posix_fadvise(_fd,0,_size_in_bytes,POSIX_FADV_DONTNEED);

  return 0;

 error:
  ::close(_fd);

  _reset_data();

  return rv;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
movq (%rsi), %rdi
xorl %r14d, %r14d
movl %edx, %esi
xorl %eax, %eax
callq 0x4380
movl %eax, 0x8c(%rbx)
cmpl $-0x1, %eax
je 0xaa2d
leaq 0x8(%rsp), %rsi
movl %eax, %edi
callq 0x46f0
cmpl $-0x1, %eax
je 0xaa3a
movl $0xf000, %eax           # imm = 0xF000
andl 0x20(%rsp), %eax
cmpl $0x6000, %eax           # imm = 0x6000
je 0xaa4f
pushq $-0xf
popq %r14
jmp 0xaae0
callq 0x4050
subl (%rax), %r14d
jmp 0xab13
callq 0x4050
movl (%rax), %r14d
testl %r14d, %r14d
jle 0xaa4f
negl %r14d
jmp 0xaae0
movl 0x8c(%rbx), %edi
leaq 0x30(%rbx), %rsi
callq 0x11250
testl %eax, %eax
jne 0xaa69
movb $0x1, 0x88(%rbx)
movl 0x8c(%rbx), %edi
callq 0xc3ac
movslq %eax, %r14
testl %r14d, %r14d
js 0xaae0
movq %r14, 0x8(%rbx)
movl 0x8c(%rbx), %edi
callq 0xc3de
movslq %eax, %r14
testl %r14d, %r14d
js 0xaae0
movq %r14, 0x10(%rbx)
movl 0x8c(%rbx), %edi
callq 0xc410
movq %rax, %r14
testq %rax, %rax
js 0xaae0
movq %r14, 0x18(%rbx)
movq %r14, %rax
xorl %edx, %edx
divq 0x8(%rbx)
movq %rax, 0x20(%rbx)
movq %r14, %rax
xorl %edx, %edx
divq 0x10(%rbx)
movq %rax, 0x28(%rbx)
movl 0x8c(%rbx), %edi
pushq $0x4
popq %rcx
xorl %esi, %esi
movq %r14, %rdx
callq 0x4390
xorl %r14d, %r14d
jmp 0xab13
movl 0x8c(%rbx), %edi
callq 0x47c0
movabsq $0x2710ffffffff, %rax   # imm = 0x2710FFFFFFFF
movq %rax, 0x8c(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movups %xmm0, 0x18(%rbx)
andq $0x0, 0x28(%rbx)
movb $0x0, 0x88(%rbx)
movl %r14d, %eax
addq $0x98, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/trapexit[P]bbf/src/blkdev.cpp
// Function: BlkDev::close()
int
BlkDev::close(void)
{
  int rv;

  if(_fd == -1)
    return 0;

  rv = ::close(_fd);

  _reset_data();

  return ((rv == -1) ? -errno : rv);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x8c(%rdi), %edi
cmpl $-0x1, %edi
je 0xab7f
callq 0x47c0
movabsq $0x2710ffffffff, %rcx   # imm = 0x2710FFFFFFFF
movq %rcx, 0x8c(%rbx)
xorps %xmm0, %xmm0
andq $0x0, 0x28(%rbx)
movups %xmm0, 0x8(%rbx)
movups %xmm0, 0x18(%rbx)
movb $0x0, 0x88(%rbx)
cmpl $-0x1, %eax
jne 0xab81
callq 0x4050
movq %rax, %rcx
xorl %eax, %eax
subl (%rcx), %eax
jmp 0xab81
xorl %eax, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/trapexit[P]bbf/src/blkdev.cpp
// Function: BlkDev::os_read(unsigned long, unsigned long, void*, unsigned long)
int64_t
BlkDev::os_read(const uint64_t  lba_,
                const uint64_t  blocks_,
                void           *buf_,
                const uint64_t  buflen_)
{
  int64_t rv;
  uint64_t len;
  off_t offset;

  len    = ((buflen_ * _logical_block_size) / _logical_block_size);
  len    = std::min((blocks_ * _logical_block_size),len);
  offset = (lba_ * _logical_block_size);

  rv = ::pread(_fd,buf_,len,offset);
  if(rv == -1)
    return -errno;

  return (rv / _logical_block_size);
}

// Assembly:
pushq %rbx
movq %r8, %rax
movq %rdx, %r8
movq %rdi, %rbx
movq 0x8(%rdi), %r9
imulq %r9, %rax
xorl %edx, %edx
divq %r9
imulq %r9, %r8
cmpq %r8, %rax
cmovbq %rax, %r8
imulq %rsi, %r9
movl 0x8c(%rdi), %edi
movq %rcx, %rsi
movq %r8, %rdx
movq %r9, %rcx
callq 0x4560
cmpq $-0x1, %rax
je 0xabcc
xorl %edx, %edx
divq 0x8(%rbx)
jmp 0xabd7
callq 0x4050
movslq (%rax), %rax
negq %rax
popq %rbx
retq
nop