LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/Manca[P]algorithms2/./lib/profile.hpp
// Function: tools::Profile::stop()
void stop()
        {
            _end = std::chrono::steady_clock::now();
            _duration = std::chrono::duration_cast<std::chrono::milliseconds>(_end - _startTimes.top()).count();
            _startTimes.pop();

            std::cout << "[PROFILE] " << _profileNames.top() << " took " << _duration << "ms" << " to run." << std::endl;
            _profileNames.pop();
        }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x22a0
movq %rax, 0x8(%rbx)
leaq 0x68(%rbx), %rdi
movq 0x98(%rbx), %rcx
cmpq 0xa0(%rbx), %rcx
jne 0x72fc
movq 0xb0(%rbx), %rdx
movl $0x200, %ecx            # imm = 0x200
addq -0x8(%rdx), %rcx
movq -0x8(%rcx), %rcx
subq %rcx, %rax
movl $0xf4240, %ecx          # imm = 0xF4240
cqto
idivq %rcx
movq %rax, 0x10(%rbx)
callq 0x8a84
movq 0xecbb(%rip), %rdi      # 0x15fd8
leaq 0x6a14(%rip), %rsi      # 0xdd38
callq 0x2230
movq 0x48(%rbx), %rsi
cmpq 0x50(%rbx), %rsi
jne 0x7340
movq 0x60(%rbx), %rcx
movl $0x200, %esi            # imm = 0x200
addq -0x8(%rcx), %rsi
leaq 0x18(%rbx), %r14
addq $-0x20, %rsi
movq %rax, %rdi
callq 0x2210
leaq 0x69ec(%rip), %rsi      # 0xdd43
movq %rax, %rdi
callq 0x2230
movq 0x10(%rbx), %rsi
movq %rax, %rdi
callq 0x2110
leaq 0x640e(%rip), %rsi      # 0xd780
movq %rax, %rdi
callq 0x2230
leaq 0x69c9(%rip), %rsi      # 0xdd4a
movq %rax, %rdi
callq 0x2230
movq %rax, %rdi
callq 0x2160
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x8ad4
// File: /workspace/github_cpp_makefile_star2_O2/Manca[P]algorithms2/./lib/UnionFind.hpp
// Function: DataStructures::UnionFind::UnionFind(int)
UnionFind(int n)
        {
           // _parent.resize(n);
           // _rank.resize(n);
            _parent = new int[n];
            _rank = new int[n];

            _count = n;

            for (int i = 0; i < n; i++)
            {
                _parent[i] = i;
                _rank[i] = 0;
            }
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %r14
movl %esi, %eax
shlq $0x2, %rax
xorl %r12d, %r12d
testl %esi, %esi
pushq $-0x1
popq %r15
cmovnsq %rax, %r15
movl $0x0, %r13d
cmovgl %esi, %r13d
movq %r15, %rdi
callq 0x2030
movq %rax, %rbx
movq %rax, (%r14)
movq %r15, %rdi
callq 0x2030
movq %rax, 0x8(%r14)
movl %ebp, 0x10(%r14)
cmpq %r12, %r13
je 0x73fe
movl %r12d, (%rbx,%r12,4)
andl $0x0, (%rax,%r12,4)
incq %r12
jmp 0x73eb
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Manca[P]algorithms2/./lib/UnionFind.hpp
// Function: DataStructures::UnionFind::Union(int, int)
void Union(int x, int y)
        {
            int s1 = Find(x);
            int s2 = Find(y);

            // if both elements belong to the same component return
            if (s1 == s2)
                return;

            if (_rank[s1] > _rank[s2])
                _parent[s2] = s1;
            else if (_rank[s1] < _rank[s2])
                _parent[s1] = s2;
            else
            {
                _rank[s1]++;
                _parent[s2] = s1;
            }
            _count--;
        }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %r14d
movq %rdi, %rbx
callq 0x740e
movl %eax, %ebp
movq %rbx, %rdi
movl %r14d, %esi
callq 0x740e
cmpl %eax, %ebp
je 0x7467
movq 0x8(%rbx), %rsi
movslq %ebp, %rdx
movl (%rsi,%rdx,4), %edi
movslq %eax, %rcx
cmpl (%rsi,%rcx,4), %edi
jg 0x745e
jge 0x7459
movq %rdx, %rcx
movl %eax, %ebp
jmp 0x745e
incl %edi
movl %edi, (%rsi,%rdx,4)
movq (%rbx), %rax
movl %ebp, (%rax,%rcx,4)
decl 0x10(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Manca[P]algorithms2/./assignment5.hpp
// Function: assignment5::TSP::TSP(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
TSP(const std::string& fileName)
        {
            std::fstream file(fileName, std::ios::in);

            if (file.is_open())
            {
                file >> num_cities;
                float x, y;
                while (file >> x >> y)
                    city_coord.push_back(std::make_pair(x, y));
                file.close();
            }
            _distances.resize(num_cities);
            for (int i = 0; i < num_cities; i++)
                _distances[i].resize(num_cities);

            precalculate_distances();
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rdi, %r15
leaq 0x8(%rdi), %rax
movq %rax, 0x8(%rsp)
leaq 0x20(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x8(%rdi)
leaq 0x18(%rsp), %rdi
pushq $0x8
popq %rdx
callq 0x2360
leaq 0x98(%rsp), %rdi
callq 0x20c0
testb %al, %al
je 0x7a9f
leaq 0x18(%rsp), %rdi
movq %r15, %rsi
callq 0x21a0
leaq 0x18(%rsp), %r12
leaq 0x4(%rsp), %r13
movq %rsp, %rbp
leaq 0x10(%rsp), %rbx
movq %r12, %rdi
movq %r13, %rsi
callq 0x23a0
movq %rax, %rdi
movq %rbp, %rsi
callq 0x23a0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x7a95
movss (%rsp), %xmm0
movss 0x4(%rsp), %xmm1
unpcklps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movlps %xmm1, 0x10(%rsp)
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x8eea
jmp 0x7a4f
leaq 0x18(%rsp), %rdi
callq 0x2040
movslq (%r15), %rsi
movq %r14, %rdi
callq 0x8dfa
xorl %ebx, %ebx
xorl %r12d, %r12d
movslq (%r15), %rsi
cmpq %rsi, %r12
jge 0x7acb
movq (%r14), %rdi
addq %rbx, %rdi
callq 0x8e30
incq %r12
addq $0x18, %rbx
jmp 0x7aaf
movq %r15, %rdi
callq 0x8e62
leaq 0x18(%rsp), %rdi
callq 0x20b0
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7afc
movq %rax, %rbx
jmp 0x7b09
jmp 0x7afc
jmp 0x7afc
jmp 0x7afc
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x20b0
movq %r14, %rdi
callq 0x8ec8
movq 0x8(%rsp), %rdi
callq 0x9482
movq %rbx, %rdi
callq 0x2380
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk-extras/exprtk_loop_timeout_rtc.cpp
// Function: timeout_rtc_handler::check()
bool check() override
   {
      static constexpr std::size_t max_iters_per_check = 100000;

      if (++iterations_ >= max_iters_per_check)
      {
         if (std::chrono::steady_clock::now() >= timeout_tp_)
         {
            return false;
         }

         iterations_ = 0;
      }

      return true;
   }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x18(%rdi), %rax
incq %rax
movq %rax, 0x18(%rdi)
movb $0x1, %bl
cmpq $0x186a0, %rax          # imm = 0x186A0
jb 0x111362
movq %rdi, %r14
callq 0x10e4d0
cmpq 0x20(%r14), %rax
jge 0x111360
andq $0x0, 0x18(%r14)
jmp 0x111362
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/tdv[P]boss/boss/examples/simple_enum/main.cpp
// Function: CreateTestCollection()
Boss::RefObjPtr<Boss::IEnum> CreateTestCollection()
{
  auto Collection = Boss::Base<Boss::Enum>::Create();
  // FixPrice
  Collection->AddItem(Boss::Base<MyNs::Impl::FixPrice>::Create(10));
  Collection->AddItem(Boss::Base<MyNs::Impl::FixPrice>::Create(15));
  // BestOffer
  Collection->AddItem(Boss::Base<MyNs::Impl::BestOffer>::Create(7));
  // Auction
  Collection->AddItem(Boss::Base<MyNs::Impl::Auction>::Create(42));
  Collection->AddItem(Boss::Base<MyNs::Impl::Auction>::Create(17));
  Collection->AddItem(Boss::Base<MyNs::Impl::Auction>::Create(55));
  return Collection;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x17ece
movq (%r14), %r14
leaq 0xc(%rsp), %rsi
movl $0xa, (%rsi)
leaq 0x40(%rsp), %rdi
callq 0x17f98
leaq 0x40(%rsp), %rsi
movq %r14, %rdi
callq 0x17f3e
leaq 0x40(%rsp), %rdi
callq 0x18016
movq 0x10(%rsp), %r14
leaq 0xc(%rsp), %rsi
movl $0xf, (%rsi)
leaq 0x38(%rsp), %rdi
callq 0x17f98
leaq 0x38(%rsp), %rsi
movq %r14, %rdi
callq 0x17f3e
leaq 0x38(%rsp), %rdi
callq 0x18016
movq 0x10(%rsp), %r14
leaq 0xc(%rsp), %rsi
movl $0x7, (%rsi)
leaq 0x30(%rsp), %rdi
callq 0x18080
leaq 0x30(%rsp), %rsi
movq %r14, %rdi
callq 0x18026
leaq 0x30(%rsp), %rdi
callq 0x18104
movq 0x10(%rsp), %r14
leaq 0xc(%rsp), %rsi
movl $0x2a, (%rsi)
leaq 0x28(%rsp), %rdi
callq 0x1816e
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0x18114
leaq 0x28(%rsp), %rdi
callq 0x181f2
movq 0x10(%rsp), %r14
leaq 0xc(%rsp), %rsi
movl $0x11, (%rsi)
leaq 0x20(%rsp), %rdi
callq 0x1816e
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x18114
leaq 0x20(%rsp), %rdi
callq 0x181f2
movq 0x10(%rsp), %r14
leaq 0xc(%rsp), %rsi
movl $0x37, (%rsi)
leaq 0x18(%rsp), %rdi
callq 0x1816e
leaq 0x18(%rsp), %rsi
movq %r14, %rdi
callq 0x18114
leaq 0x18(%rsp), %rdi
callq 0x181f2
leaq 0x10(%rsp), %rdi
movq (%rdi), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
movq %rcx, (%rbx)
andq $0x0, (%rdi)
callq 0x18202
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
jmp 0x17378
jmp 0x173ad
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
jmp 0x17378
jmp 0x173ad
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x181f2
jmp 0x173b0
jmp 0x173ad
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x18104
jmp 0x173b0
jmp 0x173ad
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
jmp 0x173a6
jmp 0x173ad
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x18016
jmp 0x173b0
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x18202
movq %rbx, %rdi
callq 0xbba60
// File: /workspace/github_cpp_makefile_star2_O2/tdv[P]boss/boss/examples/simple_enum/main.cpp
// Function: main
int main()
{
  try
  {
    auto Collection = CreateTestCollection();
    std::cout << "--------------- Before --------------- " << std::endl;
    ShowAllObjects(Collection);
    SetMyOffers(Collection, 5, 7);
    SetMyBets(Collection, 7);
    std::cout << "--------------- After --------------- " << std::endl;
    ShowAllObjects(Collection);
  }
  catch (std::exception const &e)
  {
    std::cerr << "Error: " << e.what() << std::endl;
  }
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsp, %rdi
callq 0x171f3
leaq 0xe6730(%rip), %rdi     # 0xfe460
leaq 0xa745c(%rip), %rsi     # 0xbf193
callq 0x86680
movq %rax, %rdi
callq 0x85f60
movq (%rsp), %rdi
movq %rdi, 0x20(%rsp)
testq %rdi, %rdi
je 0x17d58
movq (%rdi), %rax
callq *0x10(%rax)
leaq 0x20(%rsp), %rdi
callq 0x173c2
leaq 0x20(%rsp), %rdi
callq 0x184e6
movq (%rsp), %rdi
movq %rdi, 0x18(%rsp)
testq %rdi, %rdi
je 0x17d80
movq (%rdi), %rax
callq *0x10(%rax)
leaq 0x18(%rsp), %rdi
pushq $0x5
popq %rsi
pushq $0x7
popq %rdx
callq 0x1789f
leaq 0x18(%rsp), %rdi
callq 0x184e6
movq (%rsp), %rdi
movq %rdi, 0x10(%rsp)
testq %rdi, %rdi
je 0x17dae
movq (%rdi), %rax
callq *0x10(%rax)
leaq 0x10(%rsp), %rdi
pushq $0x7
popq %rsi
callq 0x17b05
leaq 0x10(%rsp), %rdi
callq 0x184e6
leaq 0xe6694(%rip), %rdi     # 0xfe460
leaq 0xa73e8(%rip), %rsi     # 0xbf1bb
callq 0x86680
movq %rax, %rdi
callq 0x85f60
movq (%rsp), %rdi
movq %rdi, 0x8(%rsp)
testq %rdi, %rdi
je 0x17df4
movq (%rdi), %rax
callq *0x10(%rax)
leaq 0x8(%rsp), %rdi
callq 0x173c2
leaq 0x8(%rsp), %rdi
callq 0x184e6
movq %rsp, %rdi
callq 0x184e6
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %r14
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x17e4c
movq %rdx, %r14
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
jmp 0x17e4c
movq %rdx, %r14
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
jmp 0x17e4c
movq %rdx, %r14
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x184e6
jmp 0x17e61
movq %rdx, %r14
movq %rax, %rbx
jmp 0x17e69
movq %rdx, %r14
movq %rax, %rbx
movq %rsp, %rdi
callq 0x184e6
cmpl $0x1, %r14d
jne 0x17ebe
movq %rbx, %rdi
callq 0x1a930
movq %rax, %rbx
leaq 0xe64bf(%rip), %rdi     # 0xfe340
leaq 0xa735a(%rip), %rsi     # 0xbf1e2
callq 0x86680
movq %rax, %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x86680
movq %rax, %rdi
callq 0x85f60
callq 0x1a9a0
jmp 0x17e10
movq %rax, %rbx
callq 0x1a9a0
movq %rbx, %rdi
callq 0xbba60
movq %rax, %rdi
callq 0x189ae
// File: /workspace/github_cpp_makefile_star2_O2/tdv[P]boss/boss/include/common/enum_helper.h
// Function: Boss::EnumHelper<MyNs::IFaces::IFixPrice>::Next()
RefObjPtr<T> Next()
    {
      RefObjQIPtr<T> Ret;
      for (IBasePtr i ; (i = NextInternal()).Get() ; )
      {
        if ((Ret = std::move(i)).Get())
          break;
      }
      return std::move(Ret);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
andq $0x0, (%r15)
movq %rsp, %r12
andq $0x0, (%r12)
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x19cb8
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x18444
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x8(%rsp), %rbp
movq %rbp, (%rsp)
andq $0x0, 0x8(%rsp)
movq %r13, %rdi
callq 0x18626
testq %rbp, %rbp
je 0x18471
movq %r15, %rdi
movq %r12, %rsi
callq 0x19d44
cmpq $0x0, (%rax)
je 0x1842a
movq %rsp, %rdi
callq 0x18626
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x19da4
leaq 0x10(%rsp), %rdi
callq 0x182f8
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x184c3
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x18626
jmp 0x184bb
jmp 0x184b8
movq %rax, %rbx
movq %rsp, %rdi
callq 0x18626
leaq 0x10(%rsp), %rdi
callq 0x182f8
movq %rbx, %rdi
callq 0xbba60
nop
// File: /workspace/github_cpp_makefile_star2_O2/tdv[P]boss/boss/include/common/enum.h
// Function: Boss::Enum::Next(Boss::IBase**)
virtual RetCode Next(IBase **item)
    {
      if (!item || *item)
        return Status::InvalidArgument;
      try
      {
        std::lock_guard<std::recursive_mutex> Lock(Mtx);
        if (CurPos == std::end(Items))
          return Status::False;
        return (CurPos++)->QueryInterface(item);
      }
      catch (std::exception const &)
      {
        return Status::Fail;
      }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
pushq $0x5
popq %rbp
testq %rsi, %rsi
je 0x18c7e
movq %rsi, %r14
cmpq $0x0, (%rsi)
jne 0x18c7e
movq %rdi, %r15
leaq 0x18(%rdi), %rbx
movq %rbx, %rdi
callq 0x18e56
leaq 0x40(%r15), %rax
movq 0x58(%r15), %rdi
cmpq %rax, %rdi
je 0x18c73
movq (%rdi), %rax
movq %rax, 0x58(%r15)
addq $0x10, %rdi
movq %r14, %rsi
callq 0x18e38
movl %eax, %ebp
jmp 0x18c76
pushq $0x1
popq %rbp
movq %rbx, %rdi
callq 0x14620
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r15
movq %rax, %r14
movq %rbx, %rdi
callq 0x14620
jmp 0x18ca1
movq %rdx, %r15
movq %rax, %r14
movq %r14, %rdi
cmpl $0x1, %r15d
jne 0x18cb9
callq 0x1a930
callq 0x1a9a0
pushq $0x2
popq %rbp
jmp 0x18c7e
callq 0xbba60
// File: /workspace/github_cpp_makefile_star2_O2/tdv[P]boss/boss/include/common/enum.h
// Function: Boss::Enum::Reset()
virtual RetCode Reset()
    {
      try
      {
        std::lock_guard<std::recursive_mutex> Lock(Mtx);
        CurPos = Items.begin();
      }
      catch (std::exception const &)
      {
        return Status::Fail;
      }
      return Status::Ok;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x18(%rdi), %rbx
movq %rbx, %rdi
callq 0x18e56
movq 0x40(%r14), %rax
movq %rax, 0x58(%r14)
movq %rbx, %rdi
callq 0x14620
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
cmpl $0x1, %edx
jne 0x18d02
callq 0x1a930
callq 0x1a9a0
pushq $0x2
popq %rax
jmp 0x18ce3
callq 0xbba60
nop
// File: /workspace/github_cpp_makefile_star2_O2/tdv[P]boss/boss/include/core/base.h
// Function: Boss::Base<MyNs::Impl::BestOffer>::QueryInterface(unsigned int, void**)
virtual RetCode BOSS_CALL QueryInterface(InterfaceId ifaceId, Ptr *iface)
    {
      RetCode Ret = Private::QueryInterface<T>::Query(static_cast<T *>(this), ifaceId, iface);
      if (Ret == Status::Ok)
        AddRef();
      return Ret;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x195b6
testl %eax, %eax
jne 0x192e7
lock
incl 0x58(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tdv[P]boss/boss/examples/simple_enum/main.cpp
// Function: MyNs::Impl::BestOffer::MyOffer(double)
virtual Boss::RetCode BOSS_CALL MyOffer(double price)
      {
        if (price < 0)
          return Boss::Status::InvalidArgument;
        try
        {
          Prices.push_back(price);
        }
        catch (std::exception const &)
        {
          return Boss::Status::Fail;
        }
        return Boss::Status::Ok;
      }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jbe 0x19304
pushq $0x5
popq %rbx
jmp 0x19314
addq $0x38, %rdi
xorl %ebx, %ebx
leaq 0x8(%rsp), %rsi
callq 0x183de
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rdi
callq 0x1a930
callq 0x1a9a0
pushq $0x2
jmp 0x19301
nop
// File: /workspace/github_cpp_makefile_star2_O2/tdv[P]boss/boss/examples/simple_enum/main.cpp
// Function: MyNs::Impl::BestOffer::GetAllOffers(Boss::IEnum**) const
virtual Boss::RetCode BOSS_CALL GetAllOffers(Boss::IEnum **offers) const
      {
        try
        {
          auto Offers = Boss::Base<Boss::Enum>::Create();
          for (auto i : Prices)
          {
            Offers->AddItem(Boss::Base<FixPrice>::Create(i));
          }
          return Offers.QueryInterface(offers);
        }
        catch (std::exception const &)
        {
        }
        return Boss::Status::Fail;
      }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %rdi
callq 0x17ece
movq 0x38(%r14), %r13
movq 0x40(%r14), %rbp
leaq 0x8(%rsp), %r14
leaq 0x10(%rsp), %r15
cmpq %rbp, %r13
je 0x19395
movsd (%r13), %xmm0
movsd %xmm0, 0x10(%rsp)
movq (%rsp), %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x195f4
movq %r12, %rdi
movq %r14, %rsi
callq 0x17f3e
movq %r14, %rdi
callq 0x18016
addq $0x8, %r13
jmp 0x1935c
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x193b0
movq (%rdi), %rax
movl $0xe2cd2d56, %esi       # imm = 0xE2CD2D56
movq %rbx, %rdx
callq *0x28(%rax)
movl %eax, %ebx
jmp 0x193b3
pushq $0x2
popq %rbx
movq %rsp, %rdi
callq 0x18202
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x193d6
movq %rdx, %r14
movq %rax, %rbx
jmp 0x193f6
movq %rdx, %r14
movq %rax, %rbx
jmp 0x193ee
movq %rdx, %r14
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x18016
movq %rsp, %rdi
callq 0x18202
movq %rbx, %rdi
cmpl $0x1, %r14d
jne 0x1940e
callq 0x1a930
callq 0x1a9a0
pushq $0x2
popq %rbx
jmp 0x193bb
callq 0xbba60
nop
// File: /workspace/github_cpp_makefile_star2_O2/tdv[P]boss/boss/include/common/enum_helper.h
// Function: Boss::EnumHelper<Boss::IBase>::NextInternal()
IBasePtr NextInternal()
    {
      IBasePtr Ret;
      RetCode Code = Enumerator->Next(Ret.GetPPtr());
      if (Code != Status::Ok && Code != Status::False)
        throw EnumHelperException("Failed to get next item.");
      return std::move(Ret);
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsp, %rax
andq $0x0, (%rax)
movq %rdi, %rbx
movq (%rsi), %rdi
movq (%rdi), %rcx
movq %rax, %rsi
callq *0x28(%rcx)
cmpl $0x2, %eax
jae 0x19ab6
movq %rsp, %rdi
movq (%rdi), %rax
movq %rax, (%rbx)
andq $0x0, (%rdi)
callq 0x18626
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x1a7d0
movq %rax, %rbx
leaq 0xa577b(%rip), %rsi     # 0xbf243
movq %rax, %rdi
callq 0x19b98
leaq 0xdd5b9(%rip), %rsi     # 0xf7090
leaq 0xa8b2(%rip), %rdx      # 0x24390
movq %rbx, %rdi
callq 0x1b820
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a830
jmp 0x19af6
movq %rax, %r14
movq %rsp, %rdi
callq 0x18626
movq %r14, %rdi
callq 0xbba60
// File: /workspace/github_cpp_makefile_star2_O2/f18m[P]boost-intrusive-pool/tests/tutorial.cpp
// Function: showcase_std_shared_pointers()
void showcase_std_shared_pointers()
{
    print_header();
    std::cout << "Running some examples for std::shared_ptr<>:" << std::endl;

    // the test below shows that the overhead of a std::shared_ptr is about 8B/pointer
    // (tested with GCC 7.3.0) and the control block adds an overhead of about 16B

    {
        std::shared_ptr<DummyClass> hdummy;
        std::cout << "  Size of a simple std::shared_ptr<>: " << sizeof(hdummy) << std::endl;

        {
            // now allocate an instance of the class:
            std::cout << "  Now allocating dummy class of size: " << sizeof(DummyClass) << std::endl;
            hdummy = std::make_shared<DummyClass>(); // you will see a memory malloc traced when running this line

            // of course copying pointers around does not trigger any memory allocation:
            std::shared_ptr<DummyClass> hdummy2 = hdummy;

        } // the DummyClass instance survives this block since its reference is stored in hdummy

        std::cout << "  Going to release all references to the std::shared_ptr<> created so far" << std::endl;
    } // you will see a memory free traced when running this line
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x28, %rsp
callq 0x23ed
movq 0x7bae(%rip), %rbx      # 0x9fd0
leaq 0x2c51(%rip), %rsi      # 0x507a
movq %rbx, %rdi
callq 0x20f0
movq %rax, %rdi
callq 0x2080
xorps %xmm0, %xmm0
movaps %xmm0, -0x30(%rbp)
leaq 0x2c60(%rip), %rsi      # 0x50a7
movq %rbx, %rdi
callq 0x20f0
pushq $0x10
popq %rsi
movq %rax, %rdi
callq 0x20a0
movq %rax, %rdi
callq 0x2080
movq 0x7b67(%rip), %rdi      # 0x9fd0
leaq 0x2c5e(%rip), %rsi      # 0x50ce
callq 0x20f0
movl $0x420, %esi            # imm = 0x420
movq %rax, %rdi
callq 0x20a0
movq %rax, %rdi
callq 0x2080
leaq -0x18(%rbp), %rdi
callq 0x2afe
leaq -0x30(%rbp), %rbx
leaq -0x18(%rbp), %rsi
movq %rbx, %rdi
callq 0x34c4
leaq -0x10(%rbp), %rdi
callq 0x30ac
leaq -0x18(%rbp), %rdi
movq %rbx, %rsi
callq 0x314a
leaq -0x10(%rbp), %rdi
callq 0x30ac
movq 0x7b08(%rip), %rdi      # 0x9fd0
leaq 0x2c26(%rip), %rsi      # 0x50f5
callq 0x20f0
movq %rax, %rdi
callq 0x2080
leaq -0x28(%rbp), %rdi
callq 0x30ac
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
jmp 0x24ee
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x30ac
movq %rbx, %rdi
callq 0x2190
// File: /workspace/github_cpp_makefile_star2_O2/f18m[P]boost-intrusive-pool/tests/tutorial.cpp
// Function: main
int main()
{
    showcase_std_shared_pointers();
    showcase_boost_intrusive_pointers();
    showcase_boost_intrusive_pool();

    print_header();
    std::cout << "Exiting" << std::endl;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x240d
callq 0x2502
callq 0x2706
callq 0x23ed
movq 0x752b(%rip), %rdi      # 0x9fd0
leaq 0x2b3d(%rip), %rsi      # 0x55e9
callq 0x20f0
movq %rax, %rdi
callq 0x2080
xorl %eax, %eax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/f18m[P]boost-intrusive-pool/include/boost_intrusive_pool.hpp
// Function: memorypool::boost_intrusive_pool<DummyClass>::allocate()
item_ptr allocate()
    {
        assert(m_pool); // pool must be initialized
        Item* recycled_item = m_pool->allocate_safe_get_recycled_item();
        if (!recycled_item)
            return nullptr;

        // in this case we don't need to call ANY function

        item_ptr ret_ptr(recycled_item);
#if BOOST_INTRUSIVE_POOL_DEBUG_CHECKS
        ret_ptr->check();
#endif
        return ret_ptr;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
cmpq $0x0, 0x8(%rsi)
je 0x2cfb
movq %rdi, %rbx
addq $0x8, %rsi
movq %rsi, %rdi
callq 0x38ee
movq %rax, %rdi
callq 0x403a
testq %rax, %rax
je 0x2cef
movq %rax, (%rbx)
movq %rax, %rdi
callq 0x34fd
movq %rbx, %rdi
callq 0x2bcc
movq %rax, %rdi
callq 0x3584
jmp 0x2cf3
andq $0x0, (%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x3184(%rip), %rdi      # 0x5e86
leaq 0x299a(%rip), %rsi      # 0x56a3
leaq 0x317d(%rip), %rcx      # 0x5e8d
movl $0x18d, %edx            # imm = 0x18D
callq 0x2090
movq %rax, %r14
movq %rbx, %rdi
callq 0x2bf8
movq %r14, %rdi
callq 0x2190
// File: /workspace/github_cpp_makefile_star2_O2/f18m[P]boost-intrusive-pool/include/boost_intrusive_pool.hpp
// Function: boost::intrusive_ptr<DummyDerivedClass> memorypool::boost_intrusive_pool<DummyDerivedClass>::allocate_through_function<>(std::function<void (DummyDerivedClass&)>)
item_ptr allocate_through_function(allocate_function fn)
    {
        assert(m_pool); // pool must be initialized
        Item* recycled_item = m_pool->allocate_safe_get_recycled_item();
        if (!recycled_item)
            return nullptr;

        // Construct the object in the obtained storage
        // uses perfect forwarding to the class ctor:
        /// new (recycled_item) Item(std::forward<Args>(args)...);
        fn(*recycled_item);

        // relinking the item to the pool is instead a critical step: we just executed
        // the ctor of the recycled item; that resulted in a call to
        // boost_intrusive_pool_item::boost_intrusive_pool_item()!
        recycled_item->_refcounted_item_set_pool(m_pool);

        // AFTER the ctor call, run the check() function
        item_ptr ret_ptr(recycled_item);
#if BOOST_INTRUSIVE_POOL_DEBUG_CHECKS
        ret_ptr->check();
#endif
        return ret_ptr;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
cmpq $0x0, 0x8(%rsi)
je 0x2f53
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
addq $0x8, %r15
movq %r15, %rdi
callq 0x4512
movq %rax, %rdi
callq 0x4d5c
testq %rax, %rax
je 0x2f3f
movq %rax, %r14
movq %r12, %rdi
movq %rax, %rsi
callq 0x4a62
movq (%r15), %rax
movq %rax, -0x28(%rbp)
testq %rax, %rax
je 0x2f09
incl 0x8(%rax)
movq %r14, %rdi
addq $0x18, %rdi
leaq -0x28(%rbp), %rsi
callq 0x3db4
leaq -0x28(%rbp), %rdi
callq 0x32a2
movq %r14, (%rbx)
movq %r14, %rdi
callq 0x34fd
movq %rbx, %rdi
callq 0x2f94
movq %rax, %rdi
callq 0x3584
jmp 0x2f43
andq $0x0, (%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2f2c(%rip), %rdi      # 0x5e86
leaq 0x2742(%rip), %rsi      # 0x56a3
leaq 0x34f0(%rip), %rcx      # 0x6458
movl $0x1b5, %edx            # imm = 0x1B5
callq 0x2090
movq %rax, %r14
movq %rbx, %rdi
callq 0x304a
jmp 0x2f8b
movq %rax, %r14
leaq -0x28(%rbp), %rdi
callq 0x32a2
movq %r14, %rdi
callq 0x2190
nop
// File: /workspace/github_cpp_makefile_star2_O2/f18m[P]boost-intrusive-pool/include/boost_intrusive_pool.hpp
// Function: memorypool::intrusive_ptr_release(memorypool::boost_intrusive_pool_item*)
inline void intrusive_ptr_release(boost_intrusive_pool_item* x)
{
#if BOOST_INTRUSIVE_POOL_DEBUG_CHECKS
    x->check();
#endif
    if (--x->m_boost_intrusive_pool_refcount == 0) {
        if (x->m_boost_intrusive_pool_owner)
            x->m_boost_intrusive_pool_owner->recycle(x);
        else
            // assume the item has been allocated out of the pool:
            delete x;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x3584
decq 0x8(%rbx)
je 0x354f
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
cmpq $0x0, 0x18(%rbx)
je 0x3574
leaq 0x18(%rbx), %rdi
callq 0x3646
movq (%rax), %rcx
movq 0x10(%rcx), %rcx
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmpq *%rcx
movq (%rbx), %rax
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmpq *0x8(%rax)
nop
// File: /workspace/github_cpp_makefile_star2_O2/f18m[P]boost-intrusive-pool/include/boost_intrusive_pool.hpp
// Function: memorypool::boost_intrusive_pool_item::check() const
void check() const
    {
        if (is_in_memory_pool()) {
            assert(m_boost_intrusive_pool_refcount < BOOST_INTRUSIVE_POOL_DEBUG_MAX_REFCOUNT);

            if (m_boost_intrusive_pool_refcount == 0) {
                // this item is apparently inside the free list of the memory pool:
                // in such case it should be always linked to the list; the only case where
                // the "next" pointer can be NULL is in the case the memory pool is memory-bounded
                // and the free items are exhausted or the memory pool is infinite but the memory is over
                assert(m_boost_intrusive_pool_next != nullptr || m_boost_intrusive_pool_owner->is_bounded()
                    || m_boost_intrusive_pool_owner->is_memory_exhausted());
            } else {
                // this item is in use and thus must be UNLINKED from the free list of the memory pool:
                assert(m_boost_intrusive_pool_next == nullptr);
            }
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
cmpq $0x0, 0x18(%rdi)
je 0x3600
movq %rdi, %rbx
movq 0x8(%rdi), %rax
cmpq $0x400, %rax            # imm = 0x400
jae 0x3607
movq 0x10(%rbx), %rcx
testq %rax, %rax
je 0x35cd
testq %rcx, %rcx
je 0x3600
leaq 0x2263(%rip), %rdi      # 0x5818
leaq 0x20e7(%rip), %rsi      # 0x56a3
leaq 0x218f(%rip), %rcx      # 0x5752
movl $0xcd, %edx
callq 0x2090
testq %rcx, %rcx
jne 0x3600
addq $0x18, %rbx
movq %rbx, %rdi
callq 0x3646
movq (%rax), %rcx
movq %rax, %rdi
callq *0x18(%rcx)
testb %al, %al
jne 0x3600
movq %rbx, %rdi
callq 0x3646
movq (%rax), %rcx
movq %rax, %rdi
callq *0x20(%rcx)
testb %al, %al
je 0x3626
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x20fa(%rip), %rdi      # 0x5708
leaq 0x208e(%rip), %rsi      # 0x56a3
leaq 0x2136(%rip), %rcx      # 0x5752
movl $0xc2, %edx
callq 0x2090
leaq 0x215f(%rip), %rdi      # 0x578c
leaq 0x206f(%rip), %rsi      # 0x56a3
leaq 0x2117(%rip), %rcx      # 0x5752
movl $0xca, %edx
callq 0x2090
nop
// File: /workspace/github_cpp_makefile_star2_O2/f18m[P]boost-intrusive-pool/include/boost_intrusive_pool.hpp
// Function: memorypool::boost_intrusive_pool<DummyClass>::init(unsigned long, unsigned long, unsigned long, memorypool::recycle_method_e, std::function<void (DummyClass&)>)
bool init(size_t init_size = BOOST_INTRUSIVE_POOL_DEFAULT_POOL_SIZE,
        size_t enlarge_size = BOOST_INTRUSIVE_POOL_INCREASE_STEP, size_t max_size = BOOST_INTRUSIVE_POOL_NO_MAX_SIZE,
        recycle_method_e recycle_method = RECYCLE_METHOD_NONE, recycle_function recycle_fn = nullptr)
    {
        assert(m_pool == nullptr); // cannot initialize twice the memory pool
        assert(init_size > 0);
        assert((max_size == BOOST_INTRUSIVE_POOL_NO_MAX_SIZE) || (max_size >= init_size && enlarge_size > 0));

        m_pool = boost::intrusive_ptr<impl>(new impl(enlarge_size, max_size, recycle_method, recycle_fn));

        // do initial malloc
        return m_pool->enlarge(init_size);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
cmpq $0x0, 0x8(%rdi)
jne 0x373f
testq %rsi, %rsi
je 0x375e
movq %rcx, %r13
movq %rdx, %r12
movq %rdi, %r14
movq %r9, %rbx
movl %r8d, -0x2c(%rbp)
testq %rcx, %rcx
je 0x36be
testq %r12, %r12
je 0x377d
cmpq %rsi, %r13
jb 0x377d
movq %rsi, -0x38(%rbp)
movl $0x88, %edi
callq 0x22dc
movq %rax, %r15
leaq -0x58(%rbp), %rdi
movq %rbx, %rsi
callq 0x37be
leaq -0x58(%rbp), %r8
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movl -0x2c(%rbp), %ecx
callq 0x3840
addq $0x8, %r14
leaq -0x60(%rbp), %r12
movq %r15, (%r12)
incl 0x8(%r15)
movq %r14, %rdi
movq %r12, %rsi
callq 0x38c2
movq %r12, %rdi
callq 0x380c
leaq -0x58(%rbp), %rdi
callq 0x2e90
movq %r14, %rdi
callq 0x38ee
movq %rax, %rdi
movq -0x38(%rbp), %rsi
callq 0x391a
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x21fa(%rip), %rdi      # 0x5940
leaq 0x1f56(%rip), %rsi      # 0x56a3
leaq 0x21fe(%rip), %rcx      # 0x5952
movl $0x176, %edx            # imm = 0x176
callq 0x2090
leaq 0x2275(%rip), %rdi      # 0x59da
leaq 0x1f37(%rip), %rsi      # 0x56a3
leaq 0x21df(%rip), %rcx      # 0x5952
movl $0x177, %edx            # imm = 0x177
callq 0x2090
leaq 0x2264(%rip), %rdi      # 0x59e8
leaq 0x1f18(%rip), %rsi      # 0x56a3
leaq 0x21c0(%rip), %rcx      # 0x5952
movl $0x178, %edx            # imm = 0x178
callq 0x2090
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x2e90
jmp 0x37ad
movq %rax, %rbx
movq %r15, %rdi
callq 0x2345
movq %rbx, %rdi
callq 0x2190
nop
// File: /workspace/github_cpp_makefile_star2_O2/f18m[P]boost-intrusive-pool/include/boost_intrusive_pool.hpp
// Function: memorypool::boost_intrusive_pool<DummyClass>::impl::impl(unsigned long, unsigned long, memorypool::recycle_method_e, std::function<void (DummyClass&)>)
impl(size_t enlarge_size, size_t max_size, recycle_method_e method, recycle_function recycle)
        {
            // assert(enlarge_size > 0); // NOTE: enlarge_size can be zero to create a limited-size memory pool

            // configurations
            m_recycle_method = method;
            m_recycle_fn = recycle;
            m_enlarge_step = enlarge_size;
            m_max_size = max_size;

            // status
            m_first_free_item = nullptr;
            m_first_arena = nullptr;
            m_last_arena = nullptr;
            m_memory_exhausted = false;
            m_trigger_self_destruction = false;

            // stats
            m_free_count = 0;
            m_inuse_count = 0;
            m_total_count = 0;

#if BOOST_INTRUSIVE_POOL_DEBUG_THREAD_ACCESS
            m_allowed_thread = 0;
#endif
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
andl $0x0, 0x8(%rdi)
leaq 0x63e9(%rip), %rax      # 0x9c48
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x10(%rdi), %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
movl %ecx, 0xc(%rdi)
movq %r12, %rdi
movq %r8, %rsi
callq 0x39ea
movq %r15, 0x30(%rbx)
movq %r14, 0x38(%rbx)
andq $0x0, 0x80(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x49(%rbx)
movups %xmm0, 0x60(%rbx)
movups %xmm0, 0x69(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r12, %rdi
callq 0x2e90
movq %rbx, %rdi
callq 0x2190
// File: /workspace/github_cpp_makefile_star2_O2/f18m[P]boost-intrusive-pool/include/boost_intrusive_pool.hpp
// Function: memorypool::boost_intrusive_pool<DummyClass>::impl::enlarge(unsigned long)
bool enlarge(size_t arena_size)
        {
#if BOOST_INTRUSIVE_POOL_DEBUG_THREAD_ACCESS
            assert(m_allowed_thread == 0 || m_allowed_thread == pthread_self());
#endif
            // If the current arena is full, create a new one.
            boost_intrusive_pool_arena<Item>* new_arena = new boost_intrusive_pool_arena<Item>(arena_size, this);
            if (!new_arena)
                return false; // malloc failed... memory finished... very likely this is a game over

            // Link the new arena to the last one.
            if (m_last_arena)
                m_last_arena->set_next_arena(new_arena);
            if (m_first_arena == nullptr)
                m_first_arena = new_arena; // apparently we are initializing the memory pool for the very first time

            // Seek pointer to last arena
            m_last_arena = new_arena;

            // Update the free_list with the storage of the just created arena.
            if (m_first_free_item == nullptr)
                m_first_free_item = m_last_arena->get_first_item();

            m_free_count += arena_size;
            m_total_count += arena_size;

            return true;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x80(%rdi), %r15
testq %r15, %r15
je 0x3940
callq 0x20e0
cmpq %rax, %r15
jne 0x39ae
pushq $0x18
popq %rdi
callq 0x22dc
movq %rax, %r15
leaq -0x20(%rbp), %rdx
movq %r14, (%rdx)
incl 0x8(%r14)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3de4
leaq -0x20(%rbp), %rdi
callq 0x32a2
movq 0x48(%r14), %rdi
testq %rdi, %rdi
je 0x397b
movq %r15, %rsi
callq 0x3f92
cmpq $0x0, 0x40(%r14)
jne 0x3986
movq %r15, 0x40(%r14)
movq %r15, 0x48(%r14)
cmpq $0x0, 0x50(%r14)
jne 0x3999
movq 0x10(%r15), %rax
movq %rax, 0x50(%r14)
addq %rbx, 0x60(%r14)
addq %rbx, 0x70(%r14)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x22f4(%rip), %rdi      # 0x5ca9
leaq 0x1ce7(%rip), %rsi      # 0x56a3
leaq 0x2322(%rip), %rcx      # 0x5ce5
movl $0x288, %edx            # imm = 0x288
callq 0x2090
movq %rax, %rbx
leaq -0x20(%rbp), %rdi
callq 0x32a2
movq %r15, %rdi
callq 0x2345
movq %rbx, %rdi
callq 0x2190
nop
// File: /workspace/github_cpp_makefile_star2_O2/f18m[P]boost-intrusive-pool/include/boost_intrusive_pool.hpp
// Function: memorypool::boost_intrusive_pool<DummyClass>::impl::clear()
void clear()
        {
            if (m_first_arena) {
                size_t init_size = m_first_arena->get_stored_item_count();
                boost_intrusive_pool_arena<Item>* pcurr = m_first_arena;
                while (pcurr) {
                    boost_intrusive_pool_arena<Item>* pnext = pcurr->get_next_arena();
                    delete pcurr;
                    pcurr = pnext;
                }
            } else {
                // this memory pool has just been clear()ed... the last arena pointer should be null as well:
                assert(m_last_arena == nullptr);
            }

            // status
            m_first_free_item = nullptr;
            m_first_arena = nullptr;
            m_last_arena = nullptr;
            m_memory_exhausted = false;

            // stats
            m_free_count = 0;
            m_inuse_count = 0;
            m_total_count = 0;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x40(%rdi), %r14
testq %r14, %r14
je 0x3cfb
testq %r14, %r14
je 0x3d02
movq (%r14), %r15
movq %r14, %rdi
callq 0x3d44
movq %r14, %rdi
callq 0x2345
movq %r15, %r14
jmp 0x3cde
cmpq $0x0, 0x48(%rbx)
jne 0x3d24
leaq 0x40(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x9(%rax)
movups %xmm0, (%rax)
movups %xmm0, 0x60(%rbx)
andq $0x0, 0x70(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1d1b(%rip), %rdi      # 0x5a46
leaq 0x1971(%rip), %rsi      # 0x56a3
leaq 0x1d25(%rip), %rcx      # 0x5a5e
movl $0x2f3, %edx            # imm = 0x2F3
callq 0x2090
nop
// File: /workspace/github_cpp_makefile_star2_O2/f18m[P]boost-intrusive-pool/include/boost_intrusive_pool.hpp
// Function: memorypool::boost_intrusive_pool_arena<DummyClass>::boost_intrusive_pool_arena(unsigned long, boost::intrusive_ptr<memorypool::boost_intrusive_pool_iface>)
boost_intrusive_pool_arena(size_t arena_size, boost::intrusive_ptr<boost_intrusive_pool_iface> p)
    {
        assert(arena_size > 0 && p);
        m_storage_size = arena_size;
        m_storage = new Item[arena_size];
        if (m_storage) {
            for (size_t i = 1; i < arena_size; i++) {
                m_storage[i - 1]._refcounted_item_set_next(&m_storage[i]);
                m_storage[i - 1]._refcounted_item_set_pool(p);
            }
            m_storage[arena_size - 1]._refcounted_item_set_next(nullptr);
            m_storage[arena_size - 1]._refcounted_item_set_pool(p);
        }
        // else: malloc failed!

        m_next_arena = nullptr;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
testq %rsi, %rsi
je 0x3f22
movq %rdx, %r14
cmpq $0x0, (%rdx)
je 0x3f22
movq %rsi, %r15
movq %rdi, %rbx
movl $0x420, %ecx            # imm = 0x420
movq %rsi, %rax
mulq %rcx
seto %cl
orq $0x8, %rax
movq %rsi, 0x8(%rdi)
pushq $-0x1
popq %rdi
testb %cl, %cl
cmoveq %rax, %rdi
callq 0x2030
movq %r15, (%rax)
movq %rax, -0x38(%rbp)
leaq 0x8(%rax), %r13
movq %r15, -0x40(%rbp)
imulq $-0x420, %r15, %r15     # imm = 0xFBE0
xorl %r12d, %r12d
movq %r13, -0x50(%rbp)
movq %r13, %rdi
xorl %esi, %esi
callq 0x2b1a
addq $-0x420, %r12           # imm = 0xFBE0
addq $0x420, %r13            # imm = 0x420
cmpq %r12, %r15
jne 0x3e52
movq -0x50(%rbp), %rax
movq %rax, 0x10(%rbx)
movq -0x40(%rbp), %rax
leaq -0x1(%rax), %r13
movl $0x420, %r15d           # imm = 0x420
leaq -0x48(%rbp), %r12
movq 0x10(%rbx), %rax
subq $0x1, %r13
jb 0x3ed2
leaq (%rax,%r15), %rcx
movq %rcx, -0x410(%rax,%r15)
movq (%r14), %rcx
movq %rcx, -0x48(%rbp)
testq %rcx, %rcx
je 0x3eae
incl 0x8(%rcx)
leaq (%rax,%r15), %rdi
addq $-0x408, %rdi           # imm = 0xFBF8
movq %r12, %rsi
callq 0x3db4
movq %r12, %rdi
callq 0x32a2
addq $0x420, %r15            # imm = 0x420
jmp 0x3e89
imulq $0x420, -0x40(%rbp), %rcx # imm = 0x420
andq $0x0, -0x410(%rax,%rcx)
leaq (%rax,%rcx), %rdi
movq (%r14), %rax
movq %rax, -0x30(%rbp)
testq %rax, %rax
je 0x3ef6
incl 0x8(%rax)
addq $-0x408, %rdi           # imm = 0xFBF8
leaq -0x30(%rbp), %rsi
callq 0x3db4
leaq -0x30(%rbp), %rdi
callq 0x32a2
andq $0x0, (%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1e19(%rip), %rdi      # 0x5d42
leaq 0x1773(%rip), %rsi      # 0x56a3
leaq 0x1e1f(%rip), %rcx      # 0x5d56
movl $0xfb, %edx
callq 0x2090
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
jmp 0x3f51
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x32a2
jmp 0x3f89
movq %rax, %rbx
testq %r12, %r12
je 0x3f80
negq %r12
movq -0x38(%rbp), %r14
addq $-0x418, %r14           # imm = 0xFBE8
leaq (%r14,%r12), %rdi
callq 0x31d0
addq $-0x420, %r12           # imm = 0xFBE0
jne 0x3f6e
movq -0x38(%rbp), %rdi
callq 0x2140
movq %rbx, %rdi
callq 0x2190
nop
// File: /workspace/github_cpp_makefile_star2_O2/f18m[P]boost-intrusive-pool/include/boost_intrusive_pool.hpp
// Function: memorypool::boost_intrusive_pool<DummyClass>::impl::trigger_self_destruction()
void trigger_self_destruction()
        {
            m_trigger_self_destruction = true;

            // walk over the free list and reduce our own refcount by removing the link between the items and ourselves:
            // this is important because it allows the last item that will return to this pool to trigger the pool
            // dtor: see recycle() implementation
            boost_intrusive_pool_item* pcurr = m_first_free_item;
            while (pcurr) {
                pcurr->_refcounted_item_set_pool(nullptr);
                pcurr = pcurr->_refcounted_item_get_next();
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movb $0x1, 0x78(%rdi)
addq $0x50, %rbx
leaq -0x18(%rbp), %r14
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x401d
andq $0x0, -0x18(%rbp)
leaq 0x18(%rbx), %rdi
movq %r14, %rsi
callq 0x3db4
movq %r14, %rdi
callq 0x32a2
addq $0x10, %rbx
jmp 0x3ff6
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x18(%rbp), %rdi
callq 0x32a2
movq %rbx, %rdi
callq 0x2190
// File: /workspace/github_cpp_makefile_star2_O2/kc885[P]SAT-Solver-with-CDCL/cdcl.cpp
// Function: main
int main(int argc, char **argv){
    ck_cdcl_solver::Solver solver;
    if(argc == 1) {
      std::cout << "Please specify the input file." << std::endl;
    }
    std::string filename = argv[1];
    solver.parse(filename);  // parse input file
    solver.solve();
    solver.printResult();  // print answer
}

// Assembly:
pushq %rbx
subq $0xf0, %rsp
movq %rsi, %rbx
leaq 0x80(%rsp), %rax
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%rax)
movl $0x3f800000, -0x10(%rax) # imm = 0x3F800000
movups %xmm0, -0x8(%rax)
movups %xmm0, 0x8(%rax)
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x28(%rax)
movups %xmm0, 0x38(%rax)
movups %xmm0, 0x48(%rax)
movups %xmm0, 0x58(%rax)
cmpl $0x1, %edi
jne 0x23c5
movq 0x5c27(%rip), %rdi      # 0x7fd8
leaq 0x2c4c(%rip), %rsi      # 0x5004
callq 0x2150
movq %rax, %rdi
callq 0x20b0
movq 0x8(%rbx), %rsi
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x2468
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x2190
leaq 0x50(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x24a4
leaq 0x10(%rsp), %rdi
callq 0x20a0
leaq 0x50(%rsp), %rdi
callq 0x2910
leaq 0x50(%rsp), %rdi
callq 0x2a24
leaq 0x30(%rsp), %rdi
callq 0x20a0
leaq 0x50(%rsp), %rdi
callq 0x2ac0
xorl %eax, %eax
addq $0xf0, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x20a0
jmp 0x244c
jmp 0x2444
movq %rax, %rbx
jmp 0x2456
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x20a0
leaq 0x50(%rsp), %rdi
callq 0x2ac0
movq %rbx, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O2/kc885[P]SAT-Solver-with-CDCL/cdcl.cpp
// Function: ck_cdcl_solver::Solver::solve()
void solve(){
            
            int decision_level = 1;
            
            std::unordered_set<int> implied;
            if(!unitPropagate(implied, decision_level)){
                unsat = 1;
                return;
            }
                
            int i = 0;
            while(i < variableNumber && val_decisionLevel[sor[i]] != 0)
                i++;
            if(i == variableNumber)
                return;
            
            
            decisionVar[2] = sor[i];
            val_decisionLevel[sor[i]] = -2;
            if(recursion(i+1,2))
                return ;
            
            decisionVar[2] = -sor[i];
            val_decisionLevel[sor[i]] = 2;
            if(recursion(i+1,2))
                return ;
            unsat = 1;
            return;
            
            
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x38(%rsp), %rax
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%rax)
movl $0x3f800000, -0x10(%rax) # imm = 0x3F800000
movups %xmm0, -0x8(%rax)
leaq 0x8(%rsp), %rsi
pushq $0x1
popq %rdx
callq 0x47aa
testb %al, %al
je 0x29ee
movl 0x98(%rbx), %edx
movq 0x50(%rbx), %rax
movq 0x80(%rbx), %rcx
xorl %esi, %esi
testl %edx, %edx
movl $0x0, %r14d
cmovgl %edx, %r14d
cmpq %rsi, %r14
je 0x298a
movslq (%rcx,%rsi,4), %rdi
cmpl $0x0, (%rax,%rdi,4)
je 0x2987
incq %rsi
jmp 0x2973
movl %esi, %r14d
cmpl %edx, %r14d
je 0x29f8
movl %r14d, %r15d
movslq (%rcx,%r15,4), %rcx
movq 0x68(%rbx), %rdx
movl %ecx, 0x8(%rdx)
movl $0xfffffffe, (%rax,%rcx,4) # imm = 0xFFFFFFFE
incl %r14d
pushq $0x2
popq %rdx
movq %rbx, %rdi
movl %r14d, %esi
callq 0x4b46
testb %al, %al
jne 0x29f8
movq 0x68(%rbx), %rax
movq 0x80(%rbx), %rcx
xorl %edx, %edx
subl (%rcx,%r15,4), %edx
movl %edx, 0x8(%rax)
movslq (%rcx,%r15,4), %rax
movq 0x50(%rbx), %rcx
movl $0x2, (%rcx,%rax,4)
pushq $0x2
popq %rdx
movq %rbx, %rdi
movl %r14d, %esi
callq 0x4b46
testb %al, %al
jne 0x29f8
movl $0x1, 0x9c(%rbx)
leaq 0x8(%rsp), %rdi
callq 0x3bec
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x2a0e
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3bec
movq %rbx, %rdi
callq 0x2210
nop
// File: /workspace/github_cpp_makefile_star2_O2/kc885[P]SAT-Solver-with-CDCL/cdcl.cpp
// Function: ck_cdcl_solver::Solver::printResult()
void printResult(){
            if(unsat == 1)
                std::cout<< "UNSAT" << std::endl;
            else{
                std::cout << "SAT" << std::endl;
                for (int i = 1;i <= variableNumber; i ++){
                    if(val_decisionLevel[i] < 0)
                        std::cout << -i << " ";
                    else
                        std::cout << i << " ";
                    
                }
                std::cout << std::endl;
            }
            
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpl $0x1, 0x9c(%rdi)
jne 0x2a5b
movq 0x559c(%rip), %rdi      # 0x7fd8
leaq 0x2661(%rip), %rsi      # 0x50a4
callq 0x2150
movq %rax, %rbx
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x20b0
movq %rdi, %r14
movq 0x5573(%rip), %rbx      # 0x7fd8
leaq 0x263a(%rip), %rsi      # 0x50a6
movq %rbx, %rdi
callq 0x2150
movq %rax, %rdi
callq 0x20b0
pushq $0x1
popq %r12
pushq $-0x1
popq %rbp
leaq 0x2620(%rip), %r15      # 0x50aa
movslq 0x98(%r14), %rax
cmpq %rax, %r12
jg 0x2a4b
movq 0x50(%r14), %rax
cmpl $0x0, (%rax,%r12,4)
movl %ebp, %esi
js 0x2aa6
movl %r12d, %esi
movq %rbx, %rdi
callq 0x2200
movq %rax, %rdi
movq %r15, %rsi
callq 0x2150
incq %r12
decl %ebp
jmp 0x2a8a