LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/bjohnsonfl[P]Overhead-Chess-Engine-/UCI.cpp
// Function: UCI::moveCheck(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
move UCI::moveCheck(std::string str)
{
    candMoveList movs;
    movs.end = generateAllLegal(pos, movs.end);
    
    while(movs.start != movs.end)
    {
       // std::cout<< moveToString(movs.start -> mv) << "\n";
       // std::cout<<str << "\n";
        if(str == moveToString(movs.start -> mv))
        {
            return movs.start -> mv;
        }
        movs.start++;
    }
    
    return none;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x838, %rsp            # imm = 0x838
movq %rsi, %rbx
leaq 0x38(%rsp), %r14
movq %r14, -0x10(%r14)
movq %r14, -0x8(%r14)
addq $0x18, %rdi
movq %r14, %rsi
callq 0x3dbf
movq %rax, -0x10(%r14)
movq -0x8(%r14), %rcx
xorl %ebp, %ebp
cmpq %rax, %rcx
je 0x7788
leaq 0x18(%rsp), %r12
leaq 0x8(%rsp), %r14
movl (%rcx), %edx
movq %r14, %rdi
callq 0x779c
movq 0x8(%rbx), %rdx
cmpq 0x10(%rsp), %rdx
jne 0x7748
movq 0x8(%rsp), %r15
testq %rdx, %rdx
je 0x7752
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x2170
testl %eax, %eax
sete %r13b
jmp 0x7755
movq 0x8(%rsp), %r15
xorl %r13d, %r13d
jmp 0x7755
movb $0x1, %r13b
cmpq %r12, %r15
je 0x776a
movq 0x18(%rsp), %rsi
incq %rsi
movq %r15, %rdi
callq 0x2160
movq 0x30(%rsp), %rcx
testb %r13b, %r13b
jne 0x7786
addq $0x8, %rcx
movq %rcx, 0x30(%rsp)
cmpq 0x28(%rsp), %rcx
jne 0x7716
jmp 0x7788
movl (%rcx), %ebp
movl %ebp, %eax
addq $0x838, %rsp            # imm = 0x838
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/bjohnsonfl[P]Overhead-Chess-Engine-/UCI.cpp
// Function: UCI::moveToString[abi:cxx11](move)
std::string UCI::moveToString (move m)
{
    
    //the only internal moves different to external are castling and promotions
    //internally: castling is king to rook sq
    //externally: castling is king src to king dest
    //for promotions, just add the promo letter i.e. fromToPromo
    std::string mv = "    ";
    std::string pieceletters = " nbrq";
    square from ,to;
    from = source_sq(m);
    to = destination_sq(m);
    mv[0] = square_to_file(from) + 'a';
    mv[1] = square_to_rank(from) + '1';
    mv[2] = square_to_file(to) + 'a';
    mv[3] = square_to_rank(to) + '1';
    
    if(move_flag(m) == promoting)
        mv += pieceletters[promo_pieceType(m)];
    
    if(move_flag(m) == castling){
        if(to == a1){
            mv[2] = 'c';
            mv[3] = '1';
        }
        else if(to == h1){
            mv[2] = 'g';
            mv[3] = '1';
        }
        else if(to == a8){
            mv[2] = 'c';
            mv[3] = '8';
        }
        else if(to == h8){
            mv[2] = 'g';
            mv[3] = '8';
        }
    }
    return mv;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %r14d
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
leaq 0xeb1(%rip), %rsi       # 0x866c
leaq 0xeae(%rip), %rdx       # 0x8670
callq 0x4592
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xe9a(%rip), %rsi       # 0x8671
leaq 0xe98(%rip), %rdx       # 0x8676
leaq 0x8(%rsp), %rdi
callq 0x4592
movl %r14d, %ecx
shrl $0x6, %ecx
movl %ecx, %eax
andl $0x3f, %eax
movl %r14d, %edx
andb $0x7, %dl
addb $0x61, %dl
movq (%rbx), %rsi
movb %dl, (%rsi)
movl %r14d, %edx
shrb $0x3, %dl
andb $0x7, %dl
addb $0x31, %dl
movq (%rbx), %rsi
movb %dl, 0x1(%rsi)
andb $0x7, %cl
addb $0x61, %cl
movq (%rbx), %rdx
movb %cl, 0x2(%rdx)
movl %eax, %ecx
shrl $0x3, %ecx
addb $0x31, %cl
movq (%rbx), %rdx
movb %cl, 0x3(%rdx)
movl %r14d, %ecx
shrl $0xe, %ecx
andl $0x3, %ecx
cmpl $0x2, %ecx
je 0x785d
cmpl $0x3, %ecx
jne 0x788f
shrl $0xc, %r14d
andl $0x3, %r14d
movq 0x8(%rsp), %rax
movsbl 0x1(%rax,%r14), %esi
movq %rbx, %rdi
callq 0x2120
jmp 0x788f
movb $0x63, %cl
cmpl $0x37, %eax
jg 0x7871
movb $0x31, %dl
testl %eax, %eax
je 0x7883
cmpl $0x7, %eax
je 0x787d
jmp 0x788f
cmpl $0x38, %eax
je 0x7881
cmpl $0x3f, %eax
jne 0x788f
movb $0x38, %dl
movb $0x67, %cl
jmp 0x7883
movb $0x38, %dl
movq (%rbx), %rax
movb %cl, 0x2(%rax)
movq (%rbx), %rax
movb %dl, 0x3(%rax)
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x78a6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2160
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x78d4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2160
jmp 0x78d4
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x78e8
movq (%r12), %rsi
incq %rsi
callq 0x2160
movq %r14, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O3/ef-gy[P]libefgy/include/ef.gy/vector.h
// Function: std::basic_ostream<char, std::char_traits<char>>& efgy::math::operator<<<char, float, 3u, efgy::math::format::cartesian>(std::basic_ostream<char, std::char_traits<char>>&, efgy::math::vector<float, 3u, efgy::math::format::cartesian> const&)
std::basic_ostream<C> &operator<<(std::basic_ostream<C> &stream,
                                  const vector<F, n, format> &v) {
  stream << "(" << v.tag();
  for (unsigned int i = 0; i < n; i++) {
    stream << (i > 0 ? ", " : " ") << v[i];
  }
  return stream << ")";
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xc3ec(%rip), %rsi      # 0x24ce2
movl $0x1, %edx
callq 0x42c0
leaq 0xc3e0(%rip), %rsi      # 0x24ce7
movl $0xb, %edx
movq %rbx, %rdi
callq 0x42c0
xorl %r15d, %r15d
leaq 0xc237(%rip), %r12      # 0x24b55
leaq 0xc3bf(%rip), %r13      # 0x24ce4
xorl %edx, %edx
testq %r15, %r15
movq %r13, %rsi
cmoveq %r12, %rsi
setne %dl
incq %rdx
movq %rbx, %rdi
callq 0x42c0
xorps %xmm0, %xmm0
cvtss2sd (%r14,%r15,4), %xmm0
movq %rbx, %rdi
callq 0x4390
incq %r15
cmpq $0x3, %r15
jne 0x18925
leaq 0xc17a(%rip), %rsi      # 0x24ada
movl $0x1, %edx
movq %rbx, %rdi
callq 0x42c0
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/ef-gy[P]libefgy/include/ef.gy/polytope.h
// Function: efgy::geometry::generators::cube<float, 4ul>::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, %r15
movq %rdi, %rbx
movl $0x600, %edi            # imm = 0x600
callq 0x4250
movq %rax, %r14
movq %rax, (%rbx)
addq $0x600, %rax            # imm = 0x600
movq %rax, 0x10(%rbx)
xorl %eax, %eax
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%r14,%rax)
movups %xmm0, 0x20(%r14,%rax)
movups %xmm0, 0x10(%r14,%rax)
movups %xmm0, (%r14,%rax)
addq $0x40, %rax
cmpq $0x600, %rax            # imm = 0x600
jne 0x1951e
movq %r14, %rcx
addq %rax, %rcx
movq %rcx, 0x8(%rbx)
movss (%r15), %xmm0
movaps %xmm0, (%rsp)
leaq 0x20(%rsp), %rdi
callq 0x1969a
leaq 0x28(%rsp), %r15
movq 0x10(%r15), %rax
cmpq %r15, %rax
movaps (%rsp), %xmm5
je 0x1966b
movss 0xac50(%rip), %xmm0     # 0x241cc
mulss %xmm5, %xmm0
mulss 0xac48(%rip), %xmm5     # 0x241d0
shufps $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movaps %xmm0, 0x10(%rsp)
shufps $0x0, %xmm5, %xmm5      # xmm5 = xmm5[0,0,0,0]
movaps %xmm5, (%rsp)
movd 0x20(%rax), %xmm3
punpcklbw %xmm3, %xmm3    # xmm3 = xmm3[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
punpcklwd %xmm3, %xmm3    # xmm3 = xmm3[0,0,1,1,2,2,3,3]
movd 0x24(%rax), %xmm2
punpcklbw %xmm2, %xmm2    # xmm2 = xmm2[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
punpcklwd %xmm2, %xmm2    # xmm2 = xmm2[0,0,1,1,2,2,3,3]
movd 0x28(%rax), %xmm1
punpcklbw %xmm1, %xmm1    # xmm1 = xmm1[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
punpcklwd %xmm1, %xmm1    # xmm1 = xmm1[0,0,1,1,2,2,3,3]
movd 0x2c(%rax), %xmm0
punpcklbw %xmm0, %xmm0    # xmm0 = xmm0[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
punpcklwd %xmm0, %xmm0    # xmm0 = xmm0[0,0,1,1,2,2,3,3]
pslld $0x1f, %xmm3
psrad $0x1f, %xmm3
movdqa 0x10(%rsp), %xmm6
movdqa %xmm6, %xmm4
pand %xmm3, %xmm4
pandn %xmm5, %xmm3
por %xmm4, %xmm3
movdqu %xmm3, (%r14)
pslld $0x1f, %xmm2
psrad $0x1f, %xmm2
movdqa %xmm6, %xmm3
pand %xmm2, %xmm3
pandn %xmm5, %xmm2
por %xmm3, %xmm2
movdqu %xmm2, 0x10(%r14)
pslld $0x1f, %xmm1
psrad $0x1f, %xmm1
movdqa %xmm6, %xmm2
pand %xmm1, %xmm2
pandn %xmm5, %xmm1
por %xmm2, %xmm1
movdqu %xmm1, 0x20(%r14)
pslld $0x1f, %xmm0
psrad $0x1f, %xmm0
movdqa %xmm6, %xmm1
pand %xmm0, %xmm1
pandn %xmm5, %xmm0
por %xmm1, %xmm0
movdqu %xmm0, 0x30(%r14)
addq $0x40, %r14
movq %rax, %rdi
callq 0x42e0
movaps (%rsp), %xmm5
cmpq %r15, %rax
jne 0x19599
leaq 0x20(%rsp), %rdi
callq 0x199da
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x600, %esi            # imm = 0x600
movq %r14, %rdi
callq 0x4260
movq %rbx, %rdi
callq 0x4400
// File: /workspace/github_cpp_makefile_star2_O3/ef-gy[P]libefgy/include/ef.gy/parametric.h
// Function: efgy::geometry::parametricIterator<float, 3ul, 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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x58(%rsi), %rax
movq 0x70(%rsi), %rcx
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
movups (%rax,%rcx), %xmm0
movups 0x10(%rax,%rcx), %xmm1
movups 0x20(%rax,%rcx), %xmm2
leaq 0x10(%rsp), %r15
movaps %xmm2, 0x20(%r15)
movaps %xmm1, 0x10(%r15)
movaps %xmm0, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
xorl %r12d, %r12d
movq %rdi, %r13
movq %r14, %rdi
callq 0x1f946
movlps %xmm0, (%rsp)
movss %xmm1, 0x8(%rsp)
xorl %eax, %eax
movss (%r15,%rax,4), %xmm0
addss (%rsp,%rax,4), %xmm0
movss %xmm0, (%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x1ed3a
movsd (%rsp), %xmm0
movss 0x8(%rsp), %xmm1
movsd %xmm0, (%r13)
movss %xmm1, 0x8(%r13)
addq $0xc, %r13
addq $0xc, %r12
addq $0xc, %r15
cmpq $0x30, %r12
jne 0x1ed26
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1db52
retq
movq $0x0, 0x68(%rax)
xorl %ecx, %ecx
movq (%rax), %rdx
movq 0x30(%rax), %r8
movq 0x18(%rdx,%rcx), %rsi
movq 0x18(%r8,%rcx), %rdi
cmpq %rdi, %rsi
jae 0x1db85
leaq (%rdx,%rcx), %rdi
addq $0x18, %rdi
incq %rsi
movq %rsi, (%rdi)
movq 0x18(%r8,%rcx), %rdi
cmpq %rdi, %rsi
jb 0x1db51
cmpl $-0x10, %ecx
je 0x1db51
addq %rcx, %rdx
addq $0x10, %rdx
movq 0x18(%rax), %rsi
movups 0x10(%rsi,%rcx), %xmm0
movups %xmm0, (%rdx)
addq $-0x10, %rcx
jmp 0x1db5c
// File: /workspace/github_cpp_makefile_star2_O3/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
movq (%rdi), %rsi
leaq 0xb8(%rsp), %rdi
callq 0x1dd92
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x1d994
leaq 0xb8(%rsp), %rdi
movq %rsp, %rsi
callq 0x1e967
movq %rax, %rbx
movq 0xa0(%rsp), %rdi
testq %rdi, %rdi
je 0x1dc74
movq 0xb0(%rsp), %rsi
subq %rdi, %rsi
callq 0x4260
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x1dc8b
movq 0x60(%rsp), %rsi
subq %rdi, %rsi
callq 0x4260
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x1dca2
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x4260
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x1dcb9
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x4260
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1dccf
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x4260
movq 0x158(%rsp), %rdi
testq %rdi, %rdi
je 0x1dcec
movq 0x168(%rsp), %rsi
subq %rdi, %rsi
callq 0x4260
movq 0x108(%rsp), %rdi
testq %rdi, %rdi
je 0x1dd09
movq 0x118(%rsp), %rsi
subq %rdi, %rsi
callq 0x4260
movq 0xe8(%rsp), %rdi
testq %rdi, %rdi
je 0x1dd26
movq 0xf8(%rsp), %rsi
subq %rdi, %rsi
callq 0x4260
movq 0xd0(%rsp), %rdi
testq %rdi, %rdi
je 0x1dd43
movq 0xe0(%rsp), %rsi
subq %rdi, %rsi
callq 0x4260
movq 0xb8(%rsp), %rdi
testq %rdi, %rdi
je 0x1dd60
movq 0xc8(%rsp), %rsi
subq %rdi, %rsi
callq 0x4260
movq %rbx, %rax
addq $0x170, %rsp            # imm = 0x170
popq %rbx
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1dba8
jmp 0x1dd7c
movq %rax, %rbx
leaq 0xb8(%rsp), %rdi
callq 0x1dba8
movq %rbx, %rdi
callq 0x4400
nop
// File: /workspace/github_cpp_makefile_star2_O3/ef-gy[P]libefgy/include/ef.gy/parametric.h
// Function: efgy::geometry::parametricIterator<float, 3ul, efgy::geometry::formula::plane>::getBase(efgy::math::vector<float, 3u, 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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x68(%rsp), %r15
movq %r15, %rdi
callq 0x18462
leaq 0x8(%rsp), %rdi
movq %r15, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
xorl %eax, %eax
movq %rax, 0x20(%rdi)
movq %rax, 0x10(%rbx)
movups %xmm0, (%rbx)
movss (%r15), %xmm0
movss %xmm0, 0x4(%rsp)
callq 0x18872
movq %rax, %r15
movq 0x20(%rsp), %r13
cmpq %r13, %rax
je 0x1f3c5
movss 0x4(%rsp), %xmm0
mulss 0x4ec6(%rip), %xmm0     # 0x241cc
movss %xmm0, 0x4(%rsp)
leaq 0x30(%rsp), %r12
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups 0x20(%r15), %xmm2
movaps %xmm2, 0xd0(%rsp)
movaps %xmm1, 0xc0(%rsp)
movaps %xmm0, 0xb0(%rsp)
movaps %xmm2, 0x50(%rsp)
movaps %xmm1, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movq %r12, %rax
xorl %ecx, %ecx
addq $0xc, %rcx
xorl %edx, %edx
movss 0x4(%rsp), %xmm1
movss (%rax,%rdx), %xmm0
addss %xmm1, %xmm0
mulss (%r14,%rdx), %xmm0
movss %xmm0, (%rax,%rdx)
addq $0x4, %rdx
cmpq $0xc, %rdx
jne 0x1f357
addq $0xc, %rax
cmpq $0x30, %rcx
jne 0x1f34b
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x1f3ad
movaps 0x30(%rsp), %xmm0
movaps 0x40(%rsp), %xmm1
movaps 0x50(%rsp), %xmm2
movups %xmm2, 0x20(%rsi)
movups %xmm1, 0x10(%rsi)
movups %xmm0, (%rsi)
addq $0x30, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x1f3b8
movq %rbx, %rdi
movq %r12, %rdx
callq 0x1f586
addq $0x30, %r15
cmpq %r13, %r15
jne 0x1f311
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x1f3dc
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x4260
movq 0x98(%rsp), %rdi
testq %rdi, %rdi
je 0x1f3f9
movq 0xa8(%rsp), %rsi
subq %rdi, %rsi
callq 0x4260
movq %rbx, %rax
addq $0xe0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
jmp 0x1f429
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1f429
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x4260
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x1f440
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x4260
movq 0x98(%rsp), %rdi
testq %rdi, %rdi
je 0x1f45d
movq 0xa8(%rsp), %rsi
subq %rdi, %rsi
callq 0x4260
movq %r14, %rdi
callq 0x4400
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
movl $0x0, -0x8(%rsp)
movq $0x0, -0x10(%rsp)
movq (%rdi), %rax
xorl %ecx, %ecx
movq 0x8(%rax,%rcx,4), %rdx
testq %rdx, %rdx
js 0x1f970
xorps %xmm0, %xmm0
cvtsi2ss %rdx, %xmm0
jmp 0x1f988
movq %rdx, %rsi
shrq %rsi
andl $0x1, %edx
orq %rsi, %rdx
xorps %xmm0, %xmm0
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
cmpq $0xc, %rcx
jne 0x1f95c
movsd -0x10(%rsp), %xmm0
movss -0x8(%rsp), %xmm1
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %r12
movq 0x28(%rsi), %rax
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movaps %xmm1, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
xorl %ebp, %ebp
movq %rsp, %r15
movq %rdi, 0x18(%rsp)
movq 0x20(%rsp,%rbp), %rax
movq %rax, (%r12)
movq %r15, %rdi
movq %r14, %rsi
callq 0x21642
movq (%rsp), %r13
movq 0x8(%rsp), %rbx
cmpq %rbx, %r13
je 0x20d75
movq (%r13), %rax
leaq (%rax,%rax,8), %rdi
shlq $0x2, %rdi
addq 0x30(%r14), %rdi
movq %r12, %rsi
callq 0x21762
movlps %xmm0, (%r12)
addq $0x8, %r13
cmpq %rbx, %r13
jne 0x20d4b
movq (%rsp), %r13
testq %r13, %r13
je 0x20d8a
movq 0x10(%rsp), %rsi
subq %r13, %rsi
movq %r13, %rdi
callq 0x4260
addq $0x8, %r12
addq $0x8, %rbp
cmpq $0x20, %rbp
jne 0x20d29
movq 0x18(%rsp), %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x20dc5
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x4260
movq %rbx, %rdi
callq 0x4400
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x20dec
addq $0x20, %rcx
movq %rcx, 0x28(%rbx)
cmpq %rax, %rcx
jne 0x20dfc
movq %rbx, %rdi
callq 0x18534
movq %rax, 0x28(%rbx)
incq 0x48(%rbx)
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ef-gy[P]libefgy/include/ef.gy/matrix.h
// Function: efgy::geometry::transformation::scale<float, 2ul>::scale(float 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:
leaq 0x4(%rdi), %rax
xorl %ecx, %ecx
movdqa 0x3022(%rip), %xmm4     # 0x240a0
movdqa 0x302a(%rip), %xmm0     # 0x240b0
movdqa 0x3032(%rip), %xmm1     # 0x240c0
pshufd $0xf5, %xmm1, %xmm2     # xmm2 = xmm1[1,1,3,3]
movd 0x312d(%rip), %xmm5     # 0x241c8
movdqa 0x302d(%rip), %xmm3     # 0x240d0
leaq -0x1(%rcx), %rdx
xorl %r8d, %r8d
movdqa %xmm4, %xmm6
movdqa %xmm6, %xmm7
pxor %xmm0, %xmm7
movdqa %xmm1, %xmm8
pcmpgtd %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm7     # xmm7 = xmm7[1,1,3,3]
pcmpeqd %xmm2, %xmm7
pand %xmm8, %xmm7
movd %xmm7, %r9d
testb $0x1, %r9b
je 0x210ef
movdqa %xmm5, %xmm8
cmpq %r8, %rcx
je 0x210e8
pxor %xmm8, %xmm8
movd %xmm8, -0x4(%rax,%r8,4)
pextrw $0x4, %xmm7, %r9d
testb $0x1, %r9b
je 0x2110e
movdqa %xmm5, %xmm7
cmpq %r8, %rdx
je 0x21108
pxor %xmm7, %xmm7
movd %xmm7, (%rax,%r8,4)
addq $0x2, %r8
paddq %xmm3, %xmm6
cmpq $0x4, %r8
jne 0x210ae
incq %rcx
addq $0xc, %rax
cmpq $0x3, %rcx
jne 0x210a3
movl $0x3f800000, 0x24(%rdi) # imm = 0x3F800000
movd (%rsi), %xmm4
movd %xmm4, 0x24(%rdi)
leaq -0x20(%rsp), %rax
xorl %ecx, %ecx
movd 0x307c(%rip), %xmm5     # 0x241c8
movdqa 0x2f4c(%rip), %xmm6     # 0x240a0
xorl %edx, %edx
movdqa %xmm5, %xmm7
cmpq $0x2, %rdx
je 0x21164
movdqa %xmm4, %xmm7
leaq -0x4(%rcx), %rsi
xorl %r8d, %r8d
movdqa %xmm6, %xmm8
movdqa %xmm8, %xmm9
pxor %xmm0, %xmm9
movdqa %xmm1, %xmm10
pcmpgtd %xmm9, %xmm10
pshufd $0xf5, %xmm9, %xmm9     # xmm9 = xmm9[1,1,3,3]
pcmpeqd %xmm2, %xmm9
pand %xmm10, %xmm9
movd %xmm9, %r9d
testb $0x1, %r9b
je 0x211b5
movdqa %xmm7, %xmm10
cmpq %r8, %rcx
je 0x211ae
pxor %xmm10, %xmm10
movd %xmm10, -0x4(%rax,%r8)
pextrw $0x4, %xmm9, %r9d
testb $0x1, %r9b
je 0x211d6
movdqa %xmm7, %xmm9
cmpq %r8, %rsi
je 0x211d0
pxor %xmm9, %xmm9
movd %xmm9, (%rax,%r8)
paddq %xmm3, %xmm8
addq $0x8, %r8
cmpq $0x10, %r8
jne 0x21170
incq %rdx
addq $0x4, %rcx
addq $0xc, %rax
cmpq $0x3, %rdx
jne 0x21156
xorl %eax, %eax
movl -0x1c(%rsp,%rax), %ecx
movl %ecx, 0x8(%rdi,%rax)
movq -0x24(%rsp,%rax), %rcx
movq %rcx, (%rdi,%rax)
addq $0xc, %rax
cmpq $0x24, %rax
jne 0x211fc
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
cmpq $0x0, 0x50(%rsi)
je 0x21731
movq %rsi, %r14
movq 0x48(%rsi), %r12
movq 0x30(%rsi), %rcx
movq 0x38(%rsi), %rdi
xorl %r13d, %r13d
movabsq $-0x71c71c71c71c71c7, %rbp # imm = 0x8E38E38E38E38E39
movq %rsp, %r15
movq %rdi, %r8
subq %rcx, %r8
sarq $0x2, %r8
imulq %rbp, %r8
movq %r12, %rax
xorl %edx, %edx
divq %r8
movq %rdx, (%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x216b9
movq %rdx, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x216da
movq %rbx, %rdi
movq %r15, %rdx
callq 0x217b0
movq 0x30(%r14), %rcx
movq 0x38(%r14), %rdi
movq %rdi, %r8
subq %rcx, %r8
sarq $0x2, %r8
imulq %rbp, %r8
movq %r12, %rax
xorl %edx, %edx
divq %r8
incq %r13
movq %rax, %r12
cmpq 0x50(%r14), %r13
jb 0x21688
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
cmpq %rcx, %rax
setne %dl
addq $-0x8, %rcx
cmpq %rax, %rcx
seta %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x21731
addq $0x8, %rax
movq -0x8(%rax), %rdx
movq (%rcx), %rsi
movq %rsi, -0x8(%rax)
movq %rdx, (%rcx)
addq $-0x8, %rcx
leaq 0x8(%rax), %rdx
cmpq %rcx, %rax
movq %rdx, %rax
jb 0x21713
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2175a
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x4260
movq %r14, %rdi
callq 0x4400
// File: /workspace/github_cpp_makefile_star2_O3/ef-gy[P]libefgy/include/ef.gy/transformation.h
// Function: efgy::math::vector<float, 4u, efgy::math::format::cartesian> efgy::geometry::transformation::affine<float, 4ul>::operator*<efgy::math::format::cartesian>(efgy::math::vector<float, 4u, 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:
movups (%rsi), %xmm0
movaps %xmm0, -0x28(%rsp)
movl $0x3f800000, -0x18(%rsp) # imm = 0x3F800000
movss -0x28(%rsp), %xmm0
leaq 0x14(%rdi), %rax
xorl %ecx, %ecx
movss (%rdi,%rcx,4), %xmm1
mulss %xmm0, %xmm1
movl $0x1, %edx
movq %rax, %rsi
movss -0x28(%rsp,%rdx,4), %xmm2
mulss (%rsi), %xmm2
addss %xmm2, %xmm1
incq %rdx
addq $0x14, %rsi
cmpq $0x5, %rdx
jne 0x23009
movss %xmm1, -0x14(%rsp,%rcx,4)
incq %rcx
addq $0x4, %rax
cmpq $0x5, %rcx
jne 0x22ff8
movl -0x4(%rsp), %eax
movl %eax, -0x18(%rsp)
movups -0x14(%rsp), %xmm0
movaps %xmm0, -0x28(%rsp)
movss -0x18(%rsp), %xmm1
shufps $0x0, %xmm1, %xmm1      # xmm1 = xmm1[0,0,0,0]
movaps -0x28(%rsp), %xmm0
divps %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ef-gy[P]libefgy/include/ef.gy/matrix.h
// Function: efgy::math::matrix<float, 5ul, 5ul> efgy::math::operator*<float, 5ul, 5ul, 5ul>(efgy::math::matrix<float, 5ul, 5ul> const&, efgy::math::matrix<float, 5ul, 5ul> 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 0x4(%rsi), %rcx
leaq 0x14(%rdx), %rdi
xorl %r8d, %r8d
leaq (,%r8,4), %r9
leaq (%r9,%r9,4), %r9
movss (%rsi,%r9), %xmm0
addq %rax, %r9
movq %rdi, %r10
xorl %r11d, %r11d
movss (%rdx,%r11,4), %xmm1
mulss %xmm0, %xmm1
movq %r10, %rbx
xorl %r14d, %r14d
movss (%rcx,%r14,4), %xmm2
mulss (%rbx), %xmm2
addss %xmm2, %xmm1
incq %r14
addq $0x14, %rbx
cmpq $0x4, %r14
jne 0x22d4d
movss %xmm1, (%r9,%r11,4)
incq %r11
addq $0x4, %r10
cmpq $0x5, %r11
jne 0x22d3d
incq %r8
addq $0x14, %rcx
cmpq $0x5, %r8
jne 0x22d22
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xcc38
addq $0x8, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0xcc86
movl %eax, %ebp
cmpl $-0xf, %eax
jne 0x69f0
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0xe874
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %r15
movq %r15, %rsi
callq 0x4540
movq (%r15), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x69b9
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x44b0
cmpq $0x0, 0x10(%rsp)
je 0x69d4
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xcc86
movl %eax, %ebp
jmp 0x69d9
movl $0xfffffffe, %ebp       # imm = 0xFFFFFFFE
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x69f0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x44b0
testl %ebp, %ebp
js 0x6a7a
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0xd854
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x1d5a0(%rip), %rdi     # 0x23fb8
callq 0x4500
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x4480
movsbl %al, %esi
movq %r15, %rdi
callq 0x4050
movq %rax, %rdi
callq 0x4310
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6a62
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x44b0
leaq 0x48(%rsp), %rdi
callq 0xcdec
testl %eax, %eax
js 0x6a8b
movq %rbx, %rdi
callq 0xdce4
jmp 0x6a9a
negl %ebp
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0xdf2e
jmp 0x6a9a
negl %eax
movq %rbx, %rdi
movl %eax, %esi
movq %r14, %rdx
callq 0xdfc8
leaq 0x48(%rsp), %rdi
callq 0xcc6a
movq %rbx, %rax
addq $0xe0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6ab9
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
jne 0x6adb
jmp 0x6aed
jmp 0x6aea
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6aed
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x44b0
jmp 0x6aed
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xcc6a
movq %rbx, %rdi
callq 0x46f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x20(%rax), %rsi
callq 0x4300
movq %rax, %r15
leaq 0xfe28(%rip), %rsi      # 0x16949
movl $0x3, %edx
movq %rax, %rdi
callq 0x4500
movq (%r14), %rax
movq 0x20(%rax), %rcx
movq 0x28(%rax), %rax
leaq (%rcx,%rax), %rsi
decq %rsi
movq %r15, %rdi
callq 0x4300
movq %rax, %r15
leaq 0xf79a(%rip), %rsi      # 0x162ec
movl $0x1, %edx
movq %rax, %rdi
callq 0x4500
movq (%r14), %rax
movq 0x30(%rax), %rsi
movq 0x38(%rax), %rdx
movq %r15, %rdi
callq 0x4500
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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), %r15
movq %r15, (%rsp)
addq $0x8, %r14
cmpq %r14, %r15
je 0x6be3
movq %rsp, %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6b00
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x4480
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4050
movq %rax, %rdi
callq 0x4310
movq %r15, %rdi
callq 0x4510
movq %rax, %r15
movq %rax, (%rsp)
cmpq %r14, %rax
jne 0x6b9d
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xd0ec
addq $0x8, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0xd10a
testl %eax, %eax
js 0x6c40
movq %rsp, %rdi
callq 0xd68a
movq 0x1d38a(%rip), %rdi     # 0x23fb8
movq %rax, %rsi
callq 0x6b7b
movq %rbx, %rdi
callq 0xdce4
jmp 0x6c4f
negl %eax
movq %rbx, %rdi
movl %eax, %esi
movq %r14, %rdx
callq 0xdf2e
movq %rsp, %rdi
callq 0x6c78
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x6c78
movq %rbx, %rdi
callq 0x46f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
addq $0x8, %r14
movq %r14, %rdi
callq 0xe651
testl %eax, %eax
js 0x6dc2
movq %rbx, 0x20(%rsp)
movq 0x8(%rsp), %r13
movq (%rsp), %rax
subq %rax, %r13
je 0x6db3
sarq $0x4, %r13
xorl %ebp, %ebp
movq 0x1d263(%rip), %r14     # 0x23fb8
movq (%rsp), %rax
movq %rbp, %rcx
shlq $0x4, %rcx
movq 0x8(%rax,%rcx), %rbx
testq %rbx, %rbx
je 0x6dab
movq (%rax,%rcx), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x4300
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x4480
movsbl %al, %esi
movq %r12, %rdi
callq 0x4050
movq %rax, %rdi
callq 0x4310
incq %r15
decq %rbx
jne 0x6d6e
incq %rbp
cmpq %r13, %rbp
jne 0x6d55
movq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0xdce4
jmp 0x6dd1
negl %eax
movq %rbx, %rdi
movl %eax, %esi
movq %r14, %rdx
callq 0xe230
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x6de7
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x44b0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6dfb
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x6e14
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x44b0
movq %rbx, %rdi
callq 0x46f0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4430
cmpl $-0x1, %eax
je 0x9ad5
movl $0xf000, %eax           # imm = 0xF000
andl 0x18(%rsp), %eax
movq %rbx, %rdi
cmpl $0x4000, %eax           # imm = 0x4000
jne 0x9ae9
movq %r15, %rsi
callq 0x8550
jmp 0x9af1
callq 0x4060
movl (%rax), %esi
movq %rbx, %rdi
movq %r14, %rdx
callq 0xe230
jmp 0x9af1
movq %r14, %rsi
callq 0xde94
movq %rbx, %rax
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x98(%rsi), %r14
movq %r14, %rdi
callq 0x45e0
movq 0x28(%r15), %rax
cmpq 0x30(%r15), %rax
je 0xa190
callq 0x4100
cltq
movq 0x28(%r15), %rsi
movq 0x30(%r15), %rcx
subq %rsi, %rcx
sarq $0x5, %rcx
xorl %edx, %edx
divq %rcx
shlq $0x5, %rdx
addq %rdx, %rsi
movq %rbx, %rdi
callq 0x4250
movq %r14, %rdi
callq 0x4390
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0xa1be
movq (%r12), %rsi
incq %rsi
callq 0x44b0
movq %r14, %rdi
callq 0x46f0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x45e0
movq 0x58(%r14), %rax
cmpq 0x60(%r14), %rax
je 0xa232
callq 0x4100
cltq
movq 0x58(%r14), %rcx
movq 0x60(%r14), %rsi
subq %rcx, %rsi
sarq $0x2, %rsi
xorl %edx, %edx
divq %rsi
movl (%rcx,%rdx,4), %ebp
jmp 0xa237
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movq %rbx, %rdi
callq 0x4390
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x45e0
movq 0x58(%r14), %rax
cmpq 0x60(%r14), %rax
je 0xa544
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 0xa549
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movq %rbx, %rdi
callq 0x4390
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4360
movl %eax, 0x8c(%rbx)
cmpl $-0x1, %eax
je 0xcce4
leaq 0x8(%rsp), %rsi
movl %eax, %edi
callq 0x46b0
cmpl $-0x1, %eax
je 0xccf1
movl $0xf000, %eax           # imm = 0xF000
andl 0x20(%rsp), %eax
movq $-0xf, %r14
cmpl $0x6000, %eax           # imm = 0x6000
je 0xcd06
jmp 0xcd99
callq 0x4060
subl (%rax), %r14d
jmp 0xcdcf
callq 0x4060
movl (%rax), %r14d
testl %r14d, %r14d
jle 0xcd06
negl %r14d
jmp 0xcd99
movl 0x8c(%rbx), %edi
leaq 0x30(%rbx), %rsi
callq 0x14d4b
testl %eax, %eax
jne 0xcd20
movb $0x1, 0x88(%rbx)
movl 0x8c(%rbx), %edi
callq 0xef38
movslq %eax, %r14
testl %r14d, %r14d
js 0xcd99
movq %r14, 0x8(%rbx)
movl 0x8c(%rbx), %edi
callq 0xef6a
movslq %eax, %r14
testl %r14d, %r14d
js 0xcd99
movq %r14, 0x10(%rbx)
movl 0x8c(%rbx), %edi
callq 0xef9c
movq %rax, %r14
testq %rax, %rax
js 0xcd99
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
xorl %esi, %esi
movq %r14, %rdx
movl $0x4, %ecx
callq 0x4380
xorl %r14d, %r14d
jmp 0xcdcf
movl 0x8c(%rbx), %edi
callq 0x4780
movabsq $0x2710ffffffff, %rax   # imm = 0x2710FFFFFFFF
movq %rax, 0x8c(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movups %xmm0, 0x18(%rbx)
movq $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_O3/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 0xce3e
callq 0x4780
movabsq $0x2710ffffffff, %rcx   # imm = 0x2710FFFFFFFF
movq %rcx, 0x8c(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movups %xmm0, 0x18(%rbx)
movq $0x0, 0x28(%rbx)
movb $0x0, 0x88(%rbx)
cmpl $-0x1, %eax
jne 0xce40
callq 0x4060
movq %rax, %rcx
xorl %eax, %eax
subl (%rcx), %eax
jmp 0xce40
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4550
cmpq $-0x1, %rax
je 0xce8a
xorl %edx, %edx
divq 0x8(%rbx)
jmp 0xce95
callq 0x4060
movslq (%rax), %rax
negq %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/trapexit[P]bbf/src/blkdev.cpp
// Function: BlkDev::os_write(unsigned long, unsigned long, void const*, unsigned long)
int64_t
BlkDev::os_write(const uint64_t  lba_,
                 const uint64_t  blocks_,
                 const 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 = ::pwrite(_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 0x4130
cmpq $-0x1, %rax
je 0xcee0
xorl %edx, %edx
divq 0x8(%rbx)
jmp 0xceeb
callq 0x4060
movslq (%rax), %rax
negq %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/trapexit[P]bbf/src/blkdev.cpp
// Function: BlkDev::read(unsigned long, unsigned long, void*, unsigned long)
int64_t
BlkDev::read(const uint64_t  lba_,
             const uint64_t  blocks_,
             void           *buf_,
             const uint64_t  buflen_)
{
  switch(_rw_type)
    {
    case ATA:
      return ata_read(lba_,blocks_,buf_,buflen_);
    case OS:
      return os_read(lba_,blocks_,buf_,buflen_);
    }

  return -ENOTSUP;
}

// Assembly:
pushq %rbx
movq %rdx, %rbx
movl (%rdi), %edx
cmpl $0x1, %edx
je 0xcf69
movq $-0x5f, %rax
testl %edx, %edx
jne 0xcf67
movl 0x8c(%rdi), %eax
movl 0x90(%rdi), %r9d
movl %eax, %edi
movq %rbx, %rdx
callq 0x14daf
testl %eax, %eax
cltq
cmovnsq %rbx, %rax
popq %rbx
retq
movq %rbx, %rdx
popq %rbx
jmp 0xce42
// File: /workspace/github_cpp_makefile_star2_O3/trapexit[P]bbf/src/blkdev.cpp
// Function: BlkDev::read(unsigned long, unsigned long, std::vector<char, std::allocator<char>>&)
int64_t
BlkDev::read(const uint64_t     lba_,
             const uint64_t     blocks_,
             std::vector<char> &buf_)
{
  switch(_rw_type)
    {
    case ATA:
      return ata_read(lba_,blocks_,&buf_[0],buf_.size());
    case OS:
      return os_read(lba_,blocks_,&buf_[0],buf_.size());
    }

  return -ENOTSUP;
}

// Assembly:
pushq %rbx
movq %rdx, %rbx
movl (%rdi), %edx
cmpl $0x1, %edx
je 0xcfb6
movq $-0x5f, %rax
testl %edx, %edx
jne 0xcfb4
movq (%rcx), %rax
movq 0x8(%rcx), %r8
subq %rax, %r8
movl 0x8c(%rdi), %ecx
movl 0x90(%rdi), %r9d
movl %ecx, %edi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x14daf
testl %eax, %eax
cltq
cmovnsq %rbx, %rax
popq %rbx
retq
movq (%rcx), %rax
movq 0x8(%rcx), %r8
subq %rax, %r8
movq %rbx, %rdx
movq %rax, %rcx
popq %rbx
jmp 0xce42
// File: /workspace/github_cpp_makefile_star2_O3/trapexit[P]bbf/src/blkdev.cpp
// Function: BlkDev::write(unsigned long, unsigned long, void const*, unsigned long)
int64_t
BlkDev::write(const uint64_t  lba_,
              const uint64_t  blocks_,
              const void     *buf_,
              const uint64_t  buflen_)
{
  switch(_rw_type)
    {
    case ATA:
      return ata_write(lba_,blocks_,buf_,buflen_);
    case OS:
      return os_write(lba_,blocks_,buf_,buflen_);
    }

  return -ENOTSUP;
}

// Assembly:
pushq %rbx
movq %rdx, %rbx
movl (%rdi), %edx
cmpl $0x1, %edx
je 0xd003
movq $-0x5f, %rax
testl %edx, %edx
jne 0xd001
movl 0x8c(%rdi), %eax
movl 0x90(%rdi), %r9d
movl %eax, %edi
movq %rbx, %rdx
callq 0x14e26
testl %eax, %eax
cltq
cmovnsq %rbx, %rax
popq %rbx
retq
movq %rbx, %rdx
popq %rbx
jmp 0xce98
// File: /workspace/github_cpp_makefile_star2_O3/trapexit[P]bbf/src/blkdev.cpp
// Function: BlkDev::write(unsigned long, unsigned long, std::vector<char, std::allocator<char>> const&)
int64_t
BlkDev::write(const uint64_t           lba_,
              const uint64_t           blocks_,
              const std::vector<char> &buf_)
{
  switch(_rw_type)
    {
    case ATA:
      return ata_write(lba_,blocks_,&buf_[0],buf_.size());
    case OS:
      return os_write(lba_,blocks_,&buf_[0],buf_.size());
    }

  return -ENOTSUP;
}

// Assembly:
pushq %rbx
movq %rdx, %rbx
movl (%rdi), %edx
cmpl $0x1, %edx
je 0xd050
movq $-0x5f, %rax
testl %edx, %edx
jne 0xd04e
movq (%rcx), %rax
movq 0x8(%rcx), %r8
subq %rax, %r8
movl 0x8c(%rdi), %ecx
movl 0x90(%rdi), %r9d
movl %ecx, %edi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x14e26
testl %eax, %eax
cltq
cmovnsq %rbx, %rax
popq %rbx
retq
movq (%rcx), %rax
movq 0x8(%rcx), %r8
subq %rax, %r8
movq %rbx, %rdx
movq %rax, %rcx
popq %rbx
jmp 0xce98
// File: /workspace/github_cpp_makefile_star2_O3/trapexit[P]bbf/src/blkdev.cpp
// Function: BlkDev::sync()
int
BlkDev::sync(void)
{
  int rv;
  int error;

  error = 0;

  rv = ::fsync(_fd);
  if(rv == -1)
    error = -errno;

  rv = ::fdatasync(_fd);
  if(rv == -1)
    error = -errno;

  rv = IOCtl::block_flush(_fd);
  if(rv < 0)
    error = rv;

  return error;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8c(%rdi), %edi
callq 0x4400
xorl %ebp, %ebp
cmpl $-0x1, %eax
jne 0xd093
callq 0x4060
xorl %ebp, %ebp
subl (%rax), %ebp
movl 0x8c(%rbx), %edi
callq 0x4230
cmpl $-0x1, %eax
jne 0xd0ac
callq 0x4060
xorl %ebp, %ebp
subl (%rax), %ebp
movl 0x8c(%rbx), %edi
callq 0xf051
testl %eax, %eax
cmovnsl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop