LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq (%rdi), %rax
movl %esi, %ecx
movslq %esi, %r8
movl (%rax,%r8,4), %esi
cmpl %r8d, %esi
jne 0x8b75
movl %edx, %r9d
movslq %edx, %rsi
movl (%rax,%rsi,4), %edx
cmpl %esi, %edx
jne 0x8b83
cmpl %r9d, %ecx
je 0x8bb8
movq 0x8(%rdi), %rdx
movl (%rdx,%r8,4), %r10d
cmpl (%rdx,%rsi,4), %r10d
jg 0x8bb2
jge 0x8bab
movl %r9d, (%rax,%r8,4)
jmp 0x8bb5
incl %r10d
movl %r10d, (%rdx,%r8,4)
movl %ecx, (%rax,%rsi,4)
decl 0x10(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x8, %edx
callq 0x2340
leaq 0x98(%rsp), %rdi
callq 0x20b0
testb %al, %al
je 0x92b2
leaq 0x18(%rsp), %rdi
movq %r15, %rsi
callq 0x2160
leaq 0x18(%rsp), %r12
leaq 0x4(%rsp), %r13
movq %rsp, %rbp
leaq 0x10(%rsp), %rbx
movq %r12, %rdi
movq %r13, %rsi
callq 0x2390
movq %rax, %rdi
movq %rbp, %rsi
callq 0x2390
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x92a8
movss (%rsp), %xmm0
movss 0x4(%rsp), %xmm1
unpcklps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movlps %xmm1, 0x10(%rsp)
movq 0x10(%r15), %rsi
cmpq 0x18(%r15), %rsi
je 0x9299
movq 0x10(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x10(%r15)
jmp 0x9249
movq 0x8(%rsp), %rdi
movq %rbx, %rdx
callq 0xa944
jmp 0x9249
leaq 0x18(%rsp), %rdi
callq 0x2050
movslq (%r15), %rsi
movq %r14, %rdi
callq 0xa7ba
movl (%r15), %eax
testl %eax, %eax
jle 0x92e6
xorl %ebx, %ebx
xorl %r12d, %r12d
movq (%r14), %rdi
addq %rbx, %rdi
movslq %eax, %rsi
callq 0xa83c
incq %r12
movslq (%r15), %rax
addq $0x18, %rbx
cmpq %rax, %r12
jl 0x92c9
movq %r15, %rdi
callq 0xa86e
leaq 0x18(%rsp), %rdi
callq 0x20a0
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9317
movq %rax, %rbx
jmp 0x9324
jmp 0x9317
jmp 0x9317
jmp 0x9317
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x20a0
movq %r14, %rdi
callq 0xa904
movq 0x8(%rsp), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x933e
callq 0x2200
movq %rbx, %rdi
callq 0x2360
// File: /workspace/github_cpp_makefile_star2_O1/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 0x11ace3
movq %rdi, %r14
callq 0x1164b0
cmpq 0x20(%r14), %rax
jge 0x11ace1
movq $0x0, 0x18(%r14)
jmp 0x11ace3
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorl %eax, %eax
leaq 0x18(%rsp), %r15
movq %rax, (%r15)
leaq 0x8(%rsp), %r12
movq %rax, (%r12)
leaq 0x10(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x1b364
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1990a
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x1992a
movq %r15, %rdi
movq %r12, %rsi
callq 0x1b404
cmpq $0x0, (%rax)
je 0x198ef
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1993a
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x18(%rsp), %r14
testq %r14, %r14
je 0x1994d
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq %r14, (%rbx)
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x19960
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x199c9
movq %rax, %rbx
jmp 0x199af
jmp 0x199c9
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1998d
movq (%rdi), %rax
callq *0x18(%rax)
movq $0x0, 0x10(%rsp)
jmp 0x1999f
jmp 0x199c9
jmp 0x1999c
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x199af
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x199bf
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rdi
callq 0xbc480
jmp 0x199c9
movq %rax, %rdi
callq 0x19dff
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x5, %ebp
testq %rsi, %rsi
je 0x1a0a0
movq %rsi, %r14
cmpq $0x0, (%rsi)
jne 0x1a0a0
movq %rdi, %r15
leaq 0x18(%rdi), %rbx
movq %rbx, %rdi
callq 0x155c0
testl %eax, %eax
jne 0x1a0ad
leaq 0x40(%r15), %rcx
movq 0x58(%r15), %rax
cmpq %rcx, %rax
je 0x1a08c
movq (%rax), %rcx
movq %rcx, 0x58(%r15)
movq 0x10(%rax), %rdi
testq %rdi, %rdi
je 0x1a093
movq (%rdi), %rax
movl $0x2cc77d66, %esi       # imm = 0x2CC77D66
movq %r14, %rdx
callq *0x20(%rax)
movl %eax, %ebp
jmp 0x1a098
movl $0x1, %ebp
jmp 0x1a098
movl $0x2, %ebp
movq %rbx, %rdi
callq 0x15620
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x1719d
movq %rdx, %r15
movq %rax, %r14
movq %rbx, %rdi
callq 0x15620
jmp 0x1a0ca
movq %rdx, %r15
movq %rax, %r14
movq %r14, %rdi
cmpl $0x1, %r15d
jne 0x1a0e4
callq 0x1beb0
callq 0x1bf20
movl $0x2, %ebp
jmp 0x1a0a0
callq 0xbc480
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x155c0
testl %eax, %eax
jne 0x1a11b
movq 0x40(%r14), %rax
movq %rax, 0x58(%r14)
movq %rbx, %rdi
callq 0x15620
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl %eax, %edi
callq 0x1719d
movq %rax, %rdi
cmpl $0x1, %edx
jne 0x1a13b
callq 0x1beb0
callq 0x1bf20
movl $0x2, %eax
jmp 0x1a113
callq 0xbc480
// File: /workspace/github_cpp_makefile_star2_O1/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)
movl $0x5, %ebx
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
ja 0x1a77a
movq 0x40(%rdi), %rsi
cmpq 0x48(%rdi), %rsi
je 0x1a76a
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x40(%rdi)
xorl %ebx, %ebx
jmp 0x1a77a
addq $0x38, %rdi
xorl %ebx, %ebx
leaq 0x8(%rsp), %rdx
callq 0x19e0a
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rdi
callq 0x1beb0
callq 0x1bf20
movl $0x2, %ebx
jmp 0x1a77a
// File: /workspace/github_cpp_makefile_star2_O1/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 0x19304
movq 0x38(%r14), %r13
movq 0x40(%r14), %rbp
cmpq %rbp, %r13
je 0x1a811
leaq 0x8(%rsp), %r14
leaq 0x10(%rsp), %r15
movsd (%r13), %xmm0
movsd %xmm0, 0x10(%rsp)
movq (%rsp), %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x1acae
movq %r12, %rdi
movq %r14, %rsi
callq 0x193d8
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1a7ff
movq (%rdi), %rax
callq *0x20(%rax)
movq $0x0, 0x8(%rsp)
addq $0x8, %r13
cmpq %rbp, %r13
jne 0x1a7c9
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1a82c
movq (%rdi), %rax
movl $0xe2cd2d56, %esi       # imm = 0xE2CD2D56
movq %rbx, %rdx
callq *0x28(%rax)
movl %eax, %ebx
jmp 0x1a831
movl $0x2, %ebx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1a840
movq (%rdi), %rax
callq *0x20(%rax)
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1a85d
jmp 0x1a865
movq %rdx, %r14
movq %rax, %rbx
jmp 0x1a8a3
movq %rax, %rdi
callq 0x19dff
movq %rdx, %r14
movq %rax, %rbx
jmp 0x1a88c
movq %rdx, %r14
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1a883
movq (%rdi), %rax
callq *0x20(%rax)
movq $0x0, 0x8(%rsp)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1a89b
movq (%rdi), %rax
callq *0x20(%rax)
movq $0x0, (%rsp)
movq %rbx, %rdi
cmpl $0x1, %r14d
jne 0x1a8bd
callq 0x1beb0
callq 0x1bf20
movl $0x2, %ebx
jmp 0x1a840
callq 0xbc480
jmp 0x1a85d
jmp 0x1a85d
// File: /workspace/github_cpp_makefile_star2_O1/tdv[P]boss/boss/include/core/base.h
// Function: non-virtual thunk to Boss::Base<MyNs::Impl::BestOffer>::QueryInterface(unsigned int, void**)
static RetCode Query(ObjType *obj, InterfaceId ifaceId, Ptr *iface)
      {
        if (ifaceId == InterfaceTraits<T>::Id)
        {
          *iface = static_cast<T *>(obj);
          return Status::Ok;
        }
        return QueryFromInterfacesList<T>::Query(static_cast<T *>(obj), ifaceId, iface);
      }

// Assembly:
cmpl $0x2cc77d66, %esi       # imm = 0x2CC77D66
je 0x1a9e9
movq %rdi, %rax
cmpl $0x29ab589c, %esi       # imm = 0x29AB589C
je 0x1a9ed
cmpl $0x6f972b9, %esi        # imm = 0x6F972B9
jne 0x1a9f6
leaq 0x18(%rdi), %rax
movq %rax, (%rdx)
xorl %eax, %eax
movb $0x1, %cl
jmp 0x1a9fd
movl $0x3, %eax
xorl %ecx, %ecx
testb %cl, %cl
je 0x1aa05
lock
incl 0x48(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rdi, %rbx
movq %rsp, %rax
movq $0x0, (%rax)
movq (%rsi), %rdi
movq (%rdi), %rcx
movq %rax, %rsi
callq *0x28(%rcx)
cmpl $0x2, %eax
jae 0x1b180
movq (%rsp), %rax
movq %rax, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x1bd50
movq %rax, %r14
leaq 0xa40af(%rip), %rsi     # 0xbf243
movq %rax, %rdi
callq 0x2f290
leaq 0xdaf1d(%rip), %rax     # 0xf60c0
movq %rax, (%r14)
leaq 0xdaeeb(%rip), %rsi     # 0xf6098
leaq 0xa75c(%rip), %rdx      # 0x25910
movq %r14, %rdi
callq 0x1cda0
movq %rax, %rbx
movq %r14, %rdi
callq 0x1bdb0
jmp 0x1b1cc
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1b1db
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rdi
callq 0xbc480
movq %rax, %rdi
callq 0x19dff
nop
// File: /workspace/github_cpp_makefile_star2_O1/tdv[P]boss/boss/include/common/../core/ref_obj_qi_ptr.h
// Function: Boss::RefObjQIPtr<Boss::IBase>& Boss::RefObjQIPtr<Boss::IBase>::operator=<Boss::IBase>(Boss::RefObjPtr<Boss::IBase>&&)
RefObjQIPtr& operator = (RefObjPtr<Other> &&ptr)
    {
      RefObjQIPtr<T> Tmp;
      if (ptr.Ptr)
        ptr.QueryInterface(Tmp.GetPPtr());
      Swap(Tmp);
      ptr.Release();
      return *this;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq $0x0, (%rsp)
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x1b214
movq (%rdi), %rax
movq %rsp, %rdx
movl $0x2cc77d66, %esi       # imm = 0x2CC77D66
callq *0x20(%rax)
movq (%rsp), %rax
movq (%rbx), %rcx
movq %rcx, (%rsp)
movq %rax, (%rbx)
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1b230
movq (%rdi), %rax
callq *0x18(%rax)
movq $0x0, (%r14)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1b246
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0x1b26d
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1b265
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rdi
callq 0xbc480
movq %rax, %rdi
callq 0x19dff
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
pushq %rax
callq 0x25f3
callq 0x27cf
callq 0x2b98
callq 0x25a5
movq 0x7d92(%rip), %rbx      # 0xafd0
leaq 0x33a4(%rip), %rsi      # 0x65e9
movl $0x7, %edx
movq %rbx, %rdi
callq 0x2100
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x20e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20a0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rdi, %rbx
movq 0x8(%rsi), %rdi
testq %rdi, %rdi
je 0x34f3
callq 0x4796
testq %rax, %rax
je 0x34e4
movq %rax, (%rbx)
movq 0x8(%rax), %rcx
cmpq $0x3ff, %rcx            # imm = 0x3FF
jae 0x3512
incq %rcx
movq %rcx, 0x8(%rax)
movq %rax, %rdi
callq 0x3c68
jmp 0x34eb
movq $0x0, (%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x398c(%rip), %rdi      # 0x6e86
leaq 0x31a2(%rip), %rsi      # 0x66a3
leaq 0x3985(%rip), %rcx      # 0x6e8d
movl $0x18d, %edx            # imm = 0x18D
callq 0x2080
leaq 0x3139(%rip), %rdi      # 0x6652
leaq 0x3183(%rip), %rsi      # 0x66a3
leaq 0x319d(%rip), %rcx      # 0x66c4
movl $0xdc, %edx
callq 0x2080
movq %rax, %r14
movq %rbx, %rdi
callq 0x3394
movq %r14, %rdi
callq 0x21a0
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rdi, %rbx
movq 0x8(%rsi), %rdi
testq %rdi, %rdi
je 0x37da
movq %rdx, %r12
movq %rsi, %r15
callq 0x5538
testq %rax, %rax
je 0x37c3
cmpq $0x0, 0x10(%r12)
je 0x37f9
movq %rax, %r14
movq %r12, %rdi
movq %rax, %rsi
callq *0x18(%r12)
movq 0x8(%r15), %rax
movq %rax, -0x28(%rbp)
testq %rax, %rax
je 0x377f
incl 0x8(%rax)
movq %r14, %rdi
addq $0x18, %rdi
leaq -0x28(%rbp), %rsi
callq 0x44c6
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x37a3
decl 0x8(%rdi)
jne 0x37a3
movq (%rdi), %rax
callq *0x8(%rax)
movq %r14, (%rbx)
movq 0x8(%r14), %rax
cmpq $0x3ff, %rax            # imm = 0x3FF
jae 0x37fe
incq %rax
movq %rax, 0x8(%r14)
movq %r14, %rdi
callq 0x3c68
jmp 0x37ca
movq $0x0, (%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x36a5(%rip), %rdi      # 0x6e86
leaq 0x2ebb(%rip), %rsi      # 0x66a3
leaq 0x3c69(%rip), %rcx      # 0x7458
movl $0x1b5, %edx            # imm = 0x1B5
callq 0x2080
callq 0x2060
leaq 0x2e4d(%rip), %rdi      # 0x6652
leaq 0x2e97(%rip), %rsi      # 0x66a3
leaq 0x2eb1(%rip), %rcx      # 0x66c4
movl $0xdc, %edx
callq 0x2080
movq %rax, %r14
movq %rbx, %rdi
callq 0x3916
jmp 0x3841
movq %rax, %r14
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x3841
decl 0x8(%rdi)
jne 0x3841
movq (%rdi), %rax
callq *0x8(%rax)
movq %r14, %rdi
callq 0x21a0
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x3cd5
movq 0x8(%rbx), %rax
cmpq $0x400, %rax            # imm = 0x400
jae 0x3cdc
movq 0x10(%rbx), %rcx
testq %rax, %rax
je 0x3cb3
testq %rcx, %rcx
je 0x3cd5
leaq 0x2b7d(%rip), %rdi      # 0x6818
leaq 0x2a01(%rip), %rsi      # 0x66a3
leaq 0x2aa9(%rip), %rcx      # 0x6752
movl $0xcd, %edx
callq 0x2080
testq %rcx, %rcx
jne 0x3cd5
movq (%rdi), %rax
callq *0x18(%rax)
testb %al, %al
jne 0x3cd5
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x3cfb
movq (%rdi), %rax
callq *0x20(%rax)
testb %al, %al
je 0x3d1a
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x2a25(%rip), %rdi      # 0x6708
leaq 0x29b9(%rip), %rsi      # 0x66a3
leaq 0x2a61(%rip), %rcx      # 0x6752
movl $0xc2, %edx
callq 0x2080
leaq 0x2b3d(%rip), %rdi      # 0x683f
leaq 0x2b3e(%rip), %rsi      # 0x6847
leaq 0x2b66(%rip), %rcx      # 0x6876
movl $0xc7, %edx
callq 0x2080
leaq 0x2a6b(%rip), %rdi      # 0x678c
leaq 0x297b(%rip), %rsi      # 0x66a3
leaq 0x2a23(%rip), %rcx      # 0x6752
movl $0xca, %edx
callq 0x2080
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3e0f
testq %rsi, %rsi
je 0x3e2e
movq %rcx, %r13
movq %rdx, %r12
movq %rdi, %r14
movq %r9, %rbx
movl %r8d, -0x2c(%rbp)
testq %rcx, %rcx
je 0x3d86
testq %r12, %r12
je 0x3e6c
cmpq %rsi, %r13
jb 0x3e6c
movq %rsi, -0x38(%rbp)
movl $0x88, %edi
callq 0x236c
movq %rax, %r15
leaq -0x58(%rbp), %rdi
movq %rbx, %rsi
callq 0x3ec4
leaq -0x58(%rbp), %r8
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movl -0x2c(%rbp), %ecx
callq 0x3f46
incl 0x8(%r15)
movq 0x8(%r14), %rdi
movq %r15, 0x8(%r14)
testq %rdi, %rdi
je 0x3dd4
decl 0x8(%rdi)
jne 0x3dd4
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x48(%rbp), %rax
testq %rax, %rax
movq -0x38(%rbp), %rbx
je 0x3def
leaq -0x58(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x3e4d
movq %rbx, %rsi
callq 0x3fe4
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2b2a(%rip), %rdi      # 0x6940
leaq 0x2886(%rip), %rsi      # 0x66a3
leaq 0x2b2e(%rip), %rcx      # 0x6952
movl $0x176, %edx            # imm = 0x176
callq 0x2080
leaq 0x2ba5(%rip), %rdi      # 0x69da
leaq 0x2867(%rip), %rsi      # 0x66a3
leaq 0x2b0f(%rip), %rcx      # 0x6952
movl $0x177, %edx            # imm = 0x177
callq 0x2080
leaq 0x29eb(%rip), %rdi      # 0x683f
leaq 0x29ec(%rip), %rsi      # 0x6847
leaq 0x2dae(%rip), %rcx      # 0x6c10
movl $0xc7, %edx
callq 0x2080
leaq 0x2b75(%rip), %rdi      # 0x69e8
leaq 0x2829(%rip), %rsi      # 0x66a3
leaq 0x2ad1(%rip), %rcx      # 0x6952
movl $0x178, %edx            # imm = 0x178
callq 0x2080
jmp 0x3ea9
movq %rax, %rbx
movq -0x48(%rbp), %rax
testq %rax, %rax
je 0x3eb4
leaq -0x58(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x3eb4
movq %rax, %rdi
callq 0x3a1c
movq %rax, %rbx
movq %r15, %rdi
callq 0x243d
movq %rbx, %rdi
callq 0x21a0
// File: /workspace/github_cpp_makefile_star2_O1/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, %r15
movq %rsi, %r12
movq %rdi, %rbx
movl $0x0, 0x8(%rdi)
leaq 0x6cd8(%rip), %rax      # 0xac40
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x10(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
movl %ecx, 0xc(%rdi)
movq %r14, %rdi
movq %r8, %rsi
callq 0x40c6
movq %r12, 0x30(%rbx)
movq %r15, 0x38(%rbx)
movq $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, %r15
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0x3fd4
movq %r14, %rdi
movq %r14, %rsi
movl $0x3, %edx
callq *%rax
movq %r15, %rdi
callq 0x21a0
movq %rax, %rdi
callq 0x3a1c
// File: /workspace/github_cpp_makefile_star2_O1/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 0x400a
callq 0x20d0
cmpq %rax, %r15
jne 0x4085
movl $0x18, %edi
callq 0x236c
movq %rax, %r15
leaq -0x20(%rbp), %rdx
movq %r14, (%rdx)
incl 0x8(%r14)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x44fa
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x4041
decl 0x8(%rdi)
jne 0x4041
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x48(%r14), %rdi
testq %rdi, %rdi
je 0x4052
movq %r15, %rsi
callq 0x46dc
cmpq $0x0, 0x40(%r14)
jne 0x405d
movq %r15, 0x40(%r14)
movq %r15, 0x48(%r14)
cmpq $0x0, 0x50(%r14)
jne 0x4070
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 0x2c1d(%rip), %rdi      # 0x6ca9
leaq 0x2610(%rip), %rsi      # 0x66a3
leaq 0x2c4b(%rip), %rcx      # 0x6ce5
movl $0x288, %edx            # imm = 0x288
callq 0x2080
movq %rax, %rbx
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x40b5
callq 0x21d8
movq %r15, %rdi
callq 0x243d
movq %rbx, %rdi
callq 0x21a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x441d
movq (%r14), %r15
movq %r14, %rdi
callq 0x4468
movq %r14, %rdi
callq 0x243d
movq %r15, %r14
testq %r15, %r15
jne 0x4400
jmp 0x4424
cmpq $0x0, 0x48(%rbx)
jne 0x4449
leaq 0x40(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x9(%rax)
movups %xmm0, (%rax)
movups %xmm0, 0x60(%rbx)
movq $0x0, 0x70(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x25f6(%rip), %rdi      # 0x6a46
leaq 0x224c(%rip), %rsi      # 0x66a3
leaq 0x2600(%rip), %rcx      # 0x6a5e
movl $0x2f3, %edx            # imm = 0x2F3
callq 0x2080
// File: /workspace/github_cpp_makefile_star2_O1/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
movb $0x1, 0x78(%rdi)
movq 0x50(%rdi), %r14
testq %r14, %r14
je 0x4773
leaq -0x18(%rbp), %rbx
movq $0x0, -0x18(%rbp)
leaq 0x18(%r14), %rdi
movq %rbx, %rsi
callq 0x44c6
movq -0x18(%rbp), %rdi
testq %rdi, %rdi
je 0x476a
decl 0x8(%rdi)
jne 0x476a
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x10(%r14), %r14
testq %r14, %r14
jne 0x4742
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x18(%rbp), %rdi
testq %rdi, %rdi
je 0x478d
callq 0x21fc
movq %rbx, %rdi
callq 0x21a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0xe8, %rsp
movq %rsi, %rbx
leaq 0x78(%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 0x243f
movq 0x6bd8(%rip), %r14      # 0x8fd8
leaq 0x3c39(%rip), %rsi      # 0x6040
movl $0x1e, %edx
movq %r14, %rdi
callq 0x2180
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq 0x6ba6(%rip), %rdi      # 0x8fd8
callq 0x2030
movq %rax, %rdi
callq 0x20e0
movq 0x8(%rbx), %rsi
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x2596
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x51d4
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x25d4
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x2498
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2170
leaq 0x48(%rsp), %rdi
callq 0x2c64
leaq 0x48(%rsp), %rdi
callq 0x2d88
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x24c7
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2170
movq 0xc8(%rsp), %rdi
testq %rdi, %rdi
je 0x24e4
movq 0xd8(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
movq 0xb0(%rsp), %rdi
testq %rdi, %rdi
je 0x2501
movq 0xc0(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
movq 0x98(%rsp), %rdi
testq %rdi, %rdi
je 0x251e
movq 0xa8(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
leaq 0x80(%rsp), %rdi
callq 0x511e
leaq 0x48(%rsp), %rdi
callq 0x5160
xorl %eax, %eax
addq $0xe8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x2568
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2170
jmp 0x2568
jmp 0x2560
movq %rax, %rbx
jmp 0x2583
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2583
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2170
leaq 0x48(%rsp), %rdi
callq 0x2e92
movq %rbx, %rdi
callq 0x2210
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x1, %edx
callq 0x48e6
testb %al, %al
je 0x2d53
movl 0x98(%rbx), %eax
testl %eax, %eax
jle 0x2cd9
movq 0x50(%rbx), %rcx
movq 0x80(%rbx), %rdx
xorl %r14d, %r14d
movslq (%rdx,%r14,4), %rsi
cmpl $0x0, (%rcx,%rsi,4)
je 0x2cdc
incq %r14
cmpq %r14, %rax
jne 0x2cc2
movl %eax, %r14d
jmp 0x2cdc
xorl %r14d, %r14d
cmpl %eax, %r14d
je 0x2d5d
movl %r14d, %r15d
movq 0x68(%rbx), %rax
movq 0x80(%rbx), %rcx
movl (%rcx,%r15,4), %edx
movl %edx, 0x8(%rax)
movslq (%rcx,%r15,4), %rax
movq 0x50(%rbx), %rcx
movl $0xfffffffe, (%rcx,%rax,4) # imm = 0xFFFFFFFE
incl %r14d
movq %rbx, %rdi
movl %r14d, %esi
movl $0x2, %edx
callq 0x4d82
testb %al, %al
jne 0x2d5d
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)
movq %rbx, %rdi
movl %r14d, %esi
movl $0x2, %edx
callq 0x4d82
testb %al, %al
jne 0x2d5d
movl $0x1, 0x9c(%rbx)
leaq 0x8(%rsp), %rdi
callq 0x3de2
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x2d73
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3de2
movq %rbx, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2db6
movq 0x6238(%rip), %rdi      # 0x8fd8
leaq 0x3339(%rip), %rsi      # 0x60e0
movl $0x5, %edx
callq 0x2180
jmp 0x2e5b
movq %rdi, %rbx
movq 0x6218(%rip), %r14      # 0x8fd8
leaq 0x331b(%rip), %rsi      # 0x60e2
movl $0x3, %edx
movq %r14, %rdi
callq 0x2180
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
cmpl $0x0, 0x98(%rbx)
jle 0x2e5b
movl $0x1, %r12d
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movq 0x61c2(%rip), %r14      # 0x8fd8
leaq 0x32c9(%rip), %r15      # 0x60e6
movq 0x50(%rbx), %rax
cmpl $0x0, (%rax,%r12,4)
movl %ebp, %esi
js 0x2e2d
movl %r12d, %esi
movq %r14, %rdi
callq 0x2200
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2180
leaq 0x1(%r12), %rax
movslq 0x98(%rbx), %rcx
decl %ebp
cmpq %rcx, %r12
movq %rax, %r12
jl 0x2e1d
movq 0x6176(%rip), %rbx      # 0x8fd8
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x20e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/kc885[P]SAT-Solver-with-CDCL/cdcl.cpp
// Function: ck_cdcl_solver::Solver::recursion(int, int)
bool recursion(int index, int level){
            std::unordered_set<int> implied;
            if(!unitPropagate(implied,level)){
                for(auto iter = implied.begin();iter != implied.end(); iter++)
                    val_decisionLevel[*iter] = 0;
                return false;
            }
                
            int i = index;
            while(i < variableNumber && val_decisionLevel[sor[i]] != 0)
                i++;
            if(i == variableNumber)
                return true;
            
            
            decisionVar[level+1] = sor[i];
            val_decisionLevel[sor[i]] = -level-1;
            if(recursion(i+1,level+1))
                return true;
            
            decisionVar[level+1] = -sor[i];
            val_decisionLevel[sor[i]] = level+1;
            if(recursion(i+1,level+1))
                return true;
            
            val_decisionLevel[sor[i]] = 0;
            for(auto iter = implied.begin();iter != implied.end(); iter++)
                val_decisionLevel[*iter] = 0;
            return false;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %r15d
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x30(%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)
movq %rsp, %rsi
callq 0x48e6
testb %al, %al
je 0x4eb3
movl 0x98(%rbx), %eax
cmpl %ebp, %eax
jle 0x4dfc
movq 0x50(%rbx), %rcx
movslq %ebp, %rdx
shlq $0x2, %rdx
addq 0x80(%rbx), %rdx
movslq (%rdx), %rsi
cmpl $0x0, (%rcx,%rsi,4)
je 0x4dfc
incl %ebp
addq $0x4, %rdx
cmpl %ebp, %eax
jne 0x4de7
movl %eax, %ebp
movb $0x1, %r14b
cmpl %eax, %ebp
je 0x4ed7
movslq %ebp, %r13
movq 0x68(%rbx), %rax
movq 0x80(%rbx), %rcx
movl (%rcx,%r13,4), %edx
movslq %r15d, %r12
leal 0x1(%r15), %esi
movl %edx, 0x4(%rax,%r12,4)
notl %r15d
movslq (%rcx,%r13,4), %rax
movq 0x50(%rbx), %rcx
movl %r15d, (%rcx,%rax,4)
movl %esi, %r15d
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x4d82
testb %al, %al
jne 0x4ed7
incq %r12
movq 0x68(%rbx), %rax
movq 0x80(%rbx), %rcx
xorl %edx, %edx
subl (%rcx,%r13,4), %edx
movl %edx, (%rax,%r12,4)
movslq (%rcx,%r13,4), %rax
movq 0x50(%rbx), %rcx
movl %r15d, (%rcx,%rax,4)
movq %rbx, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x4d82
testb %al, %al
jne 0x4ed7
movq 0x50(%rbx), %rax
movq 0x80(%rbx), %rcx
movslq (%rcx,%r13,4), %rcx
movl $0x0, (%rax,%rcx,4)
movq 0x10(%rsp), %rcx
testq %rcx, %rcx
je 0x4ed4
movslq 0x8(%rcx), %rdx
movl $0x0, (%rax,%rdx,4)
movq (%rcx), %rcx
jmp 0x4e9e
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x4ed4
movq 0x50(%rbx), %rcx
movslq 0x8(%rax), %rdx
movl $0x0, (%rcx,%rdx,4)
movq (%rax), %rax
testq %rax, %rax
jne 0x4ec1
xorl %r14d, %r14d
movq %rsp, %rdi
callq 0x3de2
movl %r14d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4ef3
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3de2
movq %rbx, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O1/biotomas[P]ipasir/sat/picosat961/picosat-961/app.c
// Function: next_assumption
static int
next_assumption (int start)
{
  char * arg, c;
  int res;
  res = start + 1;
  while (res < sargc)
  {
    arg = sargv[res++];
    if (!strcmp (arg, "-a"))
      {
	assert (res < sargc);
	break;
      }

    if (arg[0] == '-') {
      c = arg[1];
      if (c == 'l' || c == 'i' || c == 's' || c == 'o' || c == 't' ||
	  c == 'T' || c == 'r' || c == 'R' || c == 'c' || c == 'V' ||
	  c == 'U' || c == 'A') res++;
    }
  }
  if (res >= sargc) res = 0;
  return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %r14d
incl %r14d
movl 0x15ea6(%rip), %ebp     # 0x19140
cmpl %ebp, %r14d
jge 0x32fc
movq 0x15ea2(%rip), %r13     # 0x19148
leaq 0xe45c(%rip), %rbx      # 0x11709
leal 0x1(%r14), %r12d
movslq %r14d, %rax
movq (%r13,%rax,8), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1110
testl %eax, %eax
je 0x3301
cmpb $0x2d, (%r15)
jne 0x32f2
movzbl 0x1(%r15), %eax
addl $-0x41, %eax
cmpl $0x33, %eax
ja 0x32f2
movabsq $0xe4904003a0001, %rcx  # imm = 0xE4904003A0001
btq %rax, %rcx
jae 0x32f2
addl $0x2, %r14d
movl %r14d, %r12d
movl %r12d, %r14d
cmpl %ebp, %r12d
jl 0x32ad
jmp 0x3306
movl %r14d, %r12d
jmp 0x3306
cmpl %ebp, %r12d
jge 0x331e
xorl %eax, %eax
cmpl %ebp, %r12d
cmovll %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xeca1(%rip), %rdi      # 0x11fc6
leaq 0xe97c(%rip), %rsi      # 0x11ca8
leaq 0xec9f(%rip), %rcx      # 0x11fd2
movl $0x11e, %edx            # imm = 0x11E
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O1/biotomas[P]ipasir/sat/picosat961/picosat-961/app.c
// Function: write_to_file
static void
write_to_file (PicoSAT * picosat, 
               const char *name, 
               const char *type,
	       void (*writer) (PicoSAT *, FILE *))
{
  int pclose_file, zipped = has_suffix (name, ".gz");
  FILE *file;
  char *cmd;

  if (zipped)
    {
      cmd = malloc (strlen (GZIP) + strlen (name));
      sprintf (cmd, GZIP, name);
      file = popen (cmd, "w");
      free (cmd);
      pclose_file = 1;
    }
  else
    {
      file = fopen (name, "w");
      pclose_file = 0;
    }

  if (file)
    {
      if (verbose)
	fprintf (output,
		 "c\nc writing %s%s to '%s'\n",
		 zipped ? "gzipped " : "", type, name);

      writer (picosat, file);

      if (pclose_file)
	pclose (file);
      else
	fclose (file);
    }
  else
    fprintf (output, "*** picosat: can not write to '%s'\n", name);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, (%rsp)
movq %rsi, %r14
movq %rdi, %r15
leaq 0xe7c2(%rip), %rsi      # 0x11b1e
movq %r14, %rdi
callq 0x3237
movl %eax, %ebp
testl %eax, %eax
je 0x33ae
movq %r14, %rdi
callq 0x1090
leaq 0xf(%rax), %rdi
callq 0x1150
movq %rax, %r12
leaq 0xec66(%rip), %rsi      # 0x11feb
movq %rax, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x11d0
leaq 0xe44a(%rip), %rsi      # 0x117e3
movq %r12, %rdi
callq 0x1180
movq %rax, %r13
movq %r12, %rdi
callq 0x1050
jmp 0x33c0
leaq 0xe42e(%rip), %rsi      # 0x117e3
movq %r14, %rdi
callq 0x1190
movq %rax, %r13
testq %r13, %r13
je 0x3420
cmpl $0x0, 0x15d9c(%rip)     # 0x19168
je 0x33fe
testl %ebp, %ebp
movq 0x15d89(%rip), %rdi     # 0x19160
leaq 0xf8ba(%rip), %rax      # 0x12c98
leaq 0xec30(%rip), %rdx      # 0x12015
cmoveq %rax, %rdx
leaq 0xec0b(%rip), %rsi      # 0x11ffb
movq (%rsp), %rcx
movq %r14, %r8
xorl %eax, %eax
callq 0x1130
movq %r15, %rdi
movq %r13, %rsi
callq *%rbx
movq %r13, %rdi
addq $0x8, %rsp
testl %ebp, %ebp
je 0x3446
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x10a0
movq 0x15d39(%rip), %rdi     # 0x19160
leaq 0xe534(%rip), %rsi      # 0x11962
movq %r14, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1130
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1080
// File: /workspace/github_cpp_makefile_star2_O1/biotomas[P]ipasir/sat/picosat961/picosat-961/app.c
// Function: write_core_variables
static void
write_core_variables (PicoSAT * picosat, FILE * file)
{
  int i, max_idx = picosat_variables (picosat), count = 0;
  for (i = 1; i <= max_idx; i++)
    if (picosat_corelit (picosat, i))
      {
	fprintf (file, "%d\n", i);
	count++;
      }

  if (verbose)
    fprintf (output, "c found and wrote %d core variables\n", count);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xa6c2
testl %eax, %eax
jle 0x34ba
movl %eax, %r15d
negl %r15d
movl $0x1, %r13d
leaq 0xe858(%rip), %r12      # 0x11cda
xorl %ebp, %ebp
movq %r14, %rdi
movl %r13d, %esi
callq 0x8c66
testl %eax, %eax
je 0x34a5
movq %rbx, %rdi
movq %r12, %rsi
movl %r13d, %edx
xorl %eax, %eax
callq 0x1130
incl %ebp
leal (%r15,%r13), %eax
incl %eax
movl %r13d, %ecx
incl %ecx
movl %ecx, %r13d
cmpl $0x1, %eax
jne 0x3484
jmp 0x34bc
xorl %ebp, %ebp
cmpl $0x0, 0x15ca5(%rip)     # 0x19168
je 0x34ea
movq 0x15c94(%rip), %rdi     # 0x19160
leaq 0xeb4b(%rip), %rsi      # 0x1201e
movl %ebp, %edx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1130
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq