LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/f18m[P]boost-intrusive-pool/include/boost_intrusive_pool.hpp
// Function: memorypool::boost_intrusive_pool<DummyInt>::clear()
void clear()
    {
        if (!m_pool)
            return; // nothing to do

        // VERY IMPORTANT: this function is very tricky: to do this correctly we cannot
        // simply call m_pool->clear(): that would remove all arenas that are the memory
        // support of memory pool items.
        // At this point we don't know yet if there are boost::intrusive_ptr<> out there
        // still alive... so we must play safe:
        size_t init_size = m_pool->m_enlarge_step;
        size_t enlarge_size = m_pool->m_enlarge_step;
        size_t max_size = m_pool->m_max_size;
        recycle_method_e method = m_pool->m_recycle_method;
        recycle_function recycle = m_pool->m_recycle_fn;
        m_pool->trigger_self_destruction();
        m_pool = nullptr; // release old pool
        m_pool = boost::intrusive_ptr<impl>(new impl(enlarge_size, max_size, method, recycle));
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq 0x8(%rdi), %rsi
testq %rsi, %rsi
je 0x3974f
movq %rdi, %rbx
movq 0x30(%rsi), %r14
movq 0x38(%rsi), %r15
movl 0xc(%rsi), %r12d
addq $0x10, %rsi
leaq -0x68(%rbp), %rdi
callq 0x54a50
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x3975e
callq 0x55374
movq 0x8(%rbx), %rdi
movq $0x0, 0x8(%rbx)
testq %rdi, %rdi
je 0x396d6
decl 0x8(%rdi)
jne 0x396d6
movq (%rdi), %rax
callq *0x8(%rax)
movl $0x88, %edi
callq 0xf4e0
movq %rax, %r13
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x54a50
leaq -0x48(%rbp), %r8
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl %r12d, %ecx
callq 0x54ad2
incl 0x8(%r13)
movq 0x8(%rbx), %rdi
movq %r13, 0x8(%rbx)
testq %rdi, %rdi
je 0x39721
decl 0x8(%rdi)
jne 0x39721
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x38(%rbp), %rax
testq %rax, %rax
je 0x39738
leaq -0x48(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq -0x58(%rbp), %rax
testq %rax, %rax
je 0x3974f
leaq -0x68(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x21a78(%rip), %rdi     # 0x5b1dd
leaq 0x26081(%rip), %rsi     # 0x5f7ed
leaq 0x2612a(%rip), %rcx     # 0x5f89d
movl $0xc7, %edx
callq 0xf2f0
jmp 0x397d0
jmp 0x397d0
movq %rax, %rbx
movq -0x38(%rbp), %rax
testq %rax, %rax
je 0x397a2
leaq -0x48(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x397a2
jmp 0x397d0
movq %rax, %rbx
movq %r13, %rdi
callq 0xf480
jmp 0x397b1
jmp 0x397ae
movq %rax, %rbx
movq -0x58(%rbp), %rax
testq %rax, %rax
je 0x397c8
leaq -0x68(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0xf880
movq %rax, %rdi
callq 0x32d2e
// File: /workspace/github_cpp_makefile_star2_O3/f18m[P]boost-intrusive-pool/include/boost_intrusive_pool.hpp
// Function: memorypool::boost_intrusive_pool_arena<dummy_one>::~boost_intrusive_pool_arena()
~boost_intrusive_pool_arena()
    {
        // m_storage is automatically cleaned up
        if (m_storage) {
            delete[] m_storage;
            m_storage = nullptr;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x10(%rdi), %r14
testq %r14, %r14
je 0x565f6
movq %rdi, %rbx
movq -0x8(%r14), %r15
addq $-0x8, %r14
testq %r15, %r15
je 0x565e6
leaq 0x2a7ae(%rip), %r12     # 0x80d58
movl (%r12), %eax
shlq $0x5, %r15
leaq 0x28967(%rip), %r13     # 0x7ef20
addq $0x10, %r13
decl %eax
movl %eax, (%r12)
movq %r13, -0x18(%r14,%r15)
movq (%r14,%r15), %rdi
testq %rdi, %rdi
je 0x565e0
decl 0x8(%rdi)
jne 0x565e0
movq (%rdi), %rax
callq *0x8(%rax)
movl (%r12), %eax
addq $-0x20, %r15
jne 0x565bd
movq %r14, %rdi
callq 0xf650
movq $0x0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tdv[P]boss/boss/include/common/string_helper.h
// Function: Boss::Private::StringTypeFromTypeId<1u>::Type Boss::StringHelper::GetString<1u>() const
typename Private::StringTypeFromTypeId<Type>::Type GetString() const
    {
      void const *Data = 0;
      UInt Size = 0;
      RefObjPtr<IBuffer> Buf;
      if (Str->GetString(Type, Buf.GetPPtr()) != Status::Ok ||
          Buf->GetSize(&Size)  != Status::Ok ||
          Buf->GetData(&Data)  != Status::Ok)
      {
        throw StringHelperException("Failed to get string.");
      }
      typedef typename Private::StringTypeFromTypeId<Type>::Type StrType;
      typedef typename StrType::value_type CharType;
      return std::move(StrType(reinterpret_cast<CharType const *>(Data),
                               Size / sizeof(CharType)));
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x10(%rsp)
movl $0x0, 0x4(%rsp)
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
movq (%rsi), %rdi
movq (%rdi), %rax
movl $0x1, %esi
callq *0x38(%rax)
testl %eax, %eax
jne 0x176c2
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
leaq 0x4(%rsp), %rsi
callq *0x30(%rax)
testl %eax, %eax
jne 0x176c2
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
leaq 0x10(%rsp), %rsi
callq *0x28(%rax)
testl %eax, %eax
jne 0x176c2
movq 0x10(%rsp), %rsi
movl 0x4(%rsp), %edx
leaq 0x28(%rsp), %r14
movq %r14, -0x10(%r14)
addq %rsi, %rdx
leaq 0x18(%rsp), %rdi
callq 0x18cbe
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x18(%rsp), %rcx
cmpq %r14, %rcx
je 0x17697
movq %rcx, (%rbx)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rbx)
jmp 0x1769e
movups (%r14), %xmm0
movups %xmm0, (%rax)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rbx)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x176b7
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x19dd0
movq %rax, %r14
leaq 0xa5a31(%rip), %rsi     # 0xbd107
movq %rax, %rdi
callq 0x2d310
leaq 0xdb043(%rip), %rax     # 0xf2728
movq %rax, (%r14)
leaq 0xdb011(%rip), %rsi     # 0xf2700
leaq 0xc29a(%rip), %rdx      # 0x23990
movq %r14, %rdi
callq 0x1ae20
jmp 0x1772a
jmp 0x1770f
movq %rax, %rbx
movq %r14, %rdi
callq 0x19e30
jmp 0x17712
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x17722
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rdi
callq 0xba430
movq %rax, %rdi
callq 0x17887
// File: /workspace/github_cpp_makefile_star2_O3/tdv[P]boss/boss/examples/string_enum/main.cpp
// Function: MyNs::SimpleObject::SimpleObject()
SimpleObject()
    {
      auto StringEnum = Boss::Base<Boss::Enum>::Create();
      
      StringEnum->AddItem(Boss::Base<Boss::String>::Create("String 1"));
      StringEnum->AddItem(Boss::Base<Boss::String>::Create("String 2"));
      StringEnum->AddItem(Boss::Base<Boss::String>::Create("String 3"));
      
      Strings = std::move(StringEnum);
      
      std::cout << "SimpleObject" << std::endl;
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movb $0x0, 0x10(%rdi)
leaq 0xdb05f(%rip), %rax     # 0xf2918
movq %rax, (%rdi)
leaq 0xdb09d(%rip), %rax     # 0xf2960
movq %rax, 0x8(%rdi)
movq $0x0, 0x18(%rdi)
addq $0x18, %rbx
leaq 0x8(%rsp), %rdi
callq 0x17c82
movq 0x8(%rsp), %r14
leaq 0xa5751(%rip), %rsi     # 0xbd03a
leaq 0x20(%rsp), %rdi
callq 0x17db4
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x17d1c
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x17910
movq (%rdi), %rax
callq *0x20(%rax)
movq $0x0, 0x20(%rsp)
movq 0x8(%rsp), %r14
leaq 0xa571e(%rip), %rsi     # 0xbd043
leaq 0x18(%rsp), %rdi
callq 0x17db4
leaq 0x18(%rsp), %rsi
movq %r14, %rdi
callq 0x17d1c
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x1794c
movq (%rdi), %rax
callq *0x20(%rax)
movq $0x0, 0x18(%rsp)
movq 0x8(%rsp), %r14
leaq 0xa56eb(%rip), %rsi     # 0xbd04c
leaq 0x10(%rsp), %rdi
callq 0x17db4
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x17d1c
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x17988
movq (%rdi), %rax
callq *0x20(%rax)
movq $0x0, 0x10(%rsp)
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1799f
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
movq %rcx, (%rbx)
movq $0x0, 0x8(%rsp)
leaq 0xe2a9e(%rip), %r14     # 0xfa460
leaq 0xa56e8(%rip), %rsi     # 0xbd0b1
movl $0xc, %edx
movq %r14, %rdi
callq 0x85750
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x668a0
movsbl %al, %esi
leaq 0xe2a6c(%rip), %rdi     # 0xfa460
callq 0x85250
movq %rax, %rdi
callq 0x84820
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x17a11
movq (%rdi), %rax
callq *0x20(%rax)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0x17ab5
jmp 0x17ab5
jmp 0x17ab5
jmp 0x17ab5
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x17a40
movq (%rdi), %rax
callq *0x20(%rax)
movq $0x0, 0x10(%rsp)
jmp 0x17a95
jmp 0x17ab5
movq %rax, %r14
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x17a60
movq (%rdi), %rax
callq *0x20(%rax)
movq $0x0, 0x18(%rsp)
jmp 0x17a95
jmp 0x17ab5
movq %rax, %r14
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x17a80
movq (%rdi), %rax
callq *0x20(%rax)
movq $0x0, 0x20(%rsp)
jmp 0x17a95
jmp 0x17ab5
movq %rax, %r14
jmp 0x17aa5
movq %rax, %r14
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x17aa5
movq (%rdi), %rax
callq *0x20(%rax)
movq %rbx, %rdi
callq 0x17864
movq %r14, %rdi
callq 0xba430
movq %rax, %rdi
callq 0x17887
nop
// File: /workspace/github_cpp_makefile_star2_O3/tdv[P]boss/boss/include/common/string.h
// Function: Boss::String::GetLength(unsigned int*) const
virtual RetCode BOSS_CALL GetLength(UInt *length) const
    {
      if (!length)
        return Status::InvalidArgument;
      try
      {
        std::lock_guard<std::recursive_mutex> Lock(Mtx);
        *length = Length;
        return Status::Ok;
      }
      catch (std::exception const &)
      {
      }
      return Status::Fail;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x18484
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x18(%rdi), %r15
movq %r15, %rdi
callq 0x145d0
testl %eax, %eax
jne 0x1848f
movl 0x44(%r14), %eax
movl %eax, (%rbx)
movq %r15, %rdi
callq 0x14630
xorl %eax, %eax
jmp 0x18489
movl $0x5, %eax
popq %rbx
popq %r14
popq %r15
retq
movl %eax, %edi
callq 0x16169
movq %rax, %rdi
cmpl $0x1, %edx
jne 0x184af
callq 0x19f30
callq 0x19fa0
movl $0x2, %eax
jmp 0x18489
callq 0xba430
// File: /workspace/github_cpp_makefile_star2_O3/tdv[P]boss/boss/include/common/string.h
// Function: Boss::String::GetType(unsigned int*) const
virtual RetCode BOSS_CALL GetType(UInt *type) const
    {
      if (!type)
        return Status::InvalidArgument;
      try
      {
        std::lock_guard<std::recursive_mutex> Lock(Mtx);
        *type = Type;
        return Status::Ok;
      }
      catch (std::exception const &)
      {
      }
      return Status::Fail;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x184e6
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x18(%rdi), %r15
movq %r15, %rdi
callq 0x145d0
testl %eax, %eax
jne 0x184f1
movl 0x40(%r14), %eax
movl %eax, (%rbx)
movq %r15, %rdi
callq 0x14630
xorl %eax, %eax
jmp 0x184eb
movl $0x5, %eax
popq %rbx
popq %r14
popq %r15
retq
movl %eax, %edi
callq 0x16169
movq %rax, %rdi
cmpl $0x1, %edx
jne 0x18511
callq 0x19f30
callq 0x19fa0
movl $0x2, %eax
jmp 0x184eb
callq 0xba430
// File: /workspace/github_cpp_makefile_star2_O3/tdv[P]boss/boss/include/common/string.h
// Function: Boss::String::GetString(unsigned int, Boss::IBuffer**) const
virtual RetCode BOSS_CALL GetString(UInt type, IBuffer **str) const
    {
      if (!str || *str)
        return Status::InvalidArgument;
      try
      {
        std::lock_guard<std::recursive_mutex> Lock(Mtx);
        if (Type == UnknownStringType)
          return Status::False;
        RetCode Code = const_cast<String *>(this)->ConvertInternal(type);
        return Code == Status::Ok ? Data.QueryInterface(str) : Code;
      }
      catch (std::exception const &)
      {
      }
      return Status::Fail;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl $0x5, %ebp
testq %rdx, %rdx
je 0x18588
movq %rdx, %r14
cmpq $0x0, (%rdx)
jne 0x18588
movl %esi, %r12d
movq %rdi, %r15
leaq 0x18(%rdi), %rbx
movq %rbx, %rdi
callq 0x145d0
testl %eax, %eax
jne 0x1859a
cmpl $0x0, 0x40(%r15)
je 0x1857b
movq (%r15), %rax
movq %r15, %rdi
movl %r12d, %esi
callq *0x68(%rax)
movl %eax, %ebp
testl %eax, %eax
jne 0x18580
movq 0x48(%r15), %rdi
testq %rdi, %rdi
je 0x18593
movq (%rdi), %rax
movl $0xaaa58dc, %esi        # imm = 0xAAA58DC
movq %r14, %rdx
callq *0x20(%rax)
movl %eax, %ebp
jmp 0x18580
movl $0x1, %ebp
movq %rbx, %rdi
callq 0x14630
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x2, %ebp
jmp 0x18580
movl %eax, %edi
callq 0x16169
movq %rdx, %r15
movq %rax, %r14
movq %rbx, %rdi
callq 0x14630
jmp 0x185b7
movq %rdx, %r15
movq %rax, %r14
movq %r14, %rdi
cmpl $0x1, %r15d
jne 0x185d1
callq 0x19f30
callq 0x19fa0
movl $0x2, %ebp
jmp 0x18588
callq 0xba430
// File: /workspace/github_cpp_makefile_star2_O3/tdv[P]boss/boss/include/common/string.h
// Function: Boss::String::SetString(unsigned int, Boss::IBuffer*)
virtual RetCode BOSS_CALL SetString(UInt type, IBuffer *str)
    {
      if (!str || (type != AnsiString && type != Utf8String && type != UnicodeString))
        return Status::InvalidArgument;
      try
      {
        std::lock_guard<std::recursive_mutex> Lock(Mtx);
        void const *Buf = 0;
        UInt Len = 0;
        if (str->GetSize(&Len) != Status::Ok || str->GetData(&Buf) != Status::Ok)
          return Status::Fail;
        if (Type == UnicodeString && Len % sizeof(std::wstring::value_type))
          return Status::InvalidArgument;
        Data = std::move(Base<RawBuffer>::Create(Buf, Len));
        Type = type;
        Length = Len;
        if (Type == UnicodeString)
          Length /= sizeof(std::wstring::value_type);
      }
      catch (std::exception const &)
      {
      }
      return Status::Fail;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %esi, %r15d
testq %rdx, %rdx
sete %al
leal -0x4(%r15), %ecx
cmpl $-0x3, %ecx
setb %cl
orb %al, %cl
movl $0x5, %ebp
jne 0x1885c
movq %rdx, %r12
movq %rdi, %r14
leaq 0x18(%rdi), %rbx
movq %rbx, %rdi
callq 0x145d0
testl %eax, %eax
jne 0x188dc
movq $0x0, 0x18(%rsp)
leaq 0xc(%rsp), %rsi
movl $0x0, (%rsi)
movq (%r12), %rax
movq %r12, %rdi
callq *0x30(%rax)
movl $0x2, %ebp
testl %eax, %eax
jne 0x18854
movq (%r12), %rax
leaq 0x18(%rsp), %rsi
movq %r12, %rdi
callq *0x28(%rax)
testl %eax, %eax
je 0x1886b
movq %rbx, %rdi
callq 0x14630
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x3, 0x40(%r14)
jne 0x1887e
movl $0x5, %ebp
testb $0x3, 0xc(%rsp)
jne 0x18854
leaq 0x10(%rsp), %rdi
leaq 0x18(%rsp), %rsi
leaq 0xc(%rsp), %rdx
callq 0x1920c
movq 0x48(%r14), %rdi
testq %rdi, %rdi
je 0x188a1
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x10(%rsp), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
movq %rcx, 0x48(%r14)
movl %r15d, 0x40(%r14)
movl 0xc(%rsp), %eax
movl %eax, %ecx
shrl $0x2, %ecx
cmpl $0x3, %r15d
cmovnel %eax, %ecx
movl %ecx, 0x44(%r14)
movq %rbx, %rdi
callq 0x14630
movl $0x2, %ebp
jmp 0x1885c
movl %eax, %edi
callq 0x16169
movq %rdx, %r15
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x18913
movq (%rdi), %rax
callq *0x20(%rax)
jmp 0x18913
movq %rax, %rdi
callq 0x17887
jmp 0x1890d
movq %rdx, %r15
movq %rax, %r14
jmp 0x1891b
movq %rdx, %r15
movq %rax, %r14
movq %rbx, %rdi
callq 0x14630
movq %r14, %rdi
cmpl $0x1, %r15d
jne 0x18930
callq 0x19f30
callq 0x19fa0
jmp 0x188d5
callq 0xba430
nop
// File: /workspace/github_cpp_makefile_star2_O3/tdv[P]boss/boss/include/common/string.h
// Function: Boss::String::Convert(unsigned int)
virtual RetCode BOSS_CALL Convert(UInt type)
    {
      try
      {
        std::lock_guard<std::recursive_mutex> Lock(Mtx);
        return ConvertInternal(type);
      }
      catch (std::exception const &)
      {
      }
      return Status::Fail;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %r14
leaq 0x18(%rdi), %rbx
movq %rbx, %rdi
callq 0x145d0
testl %eax, %eax
jne 0x18974
movq (%r14), %rax
movq %r14, %rdi
movl %ebp, %esi
callq *0x68(%rax)
movl %eax, %ebp
movq %rbx, %rdi
callq 0x14630
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x16169
movq %rdx, %r15
movq %rax, %r14
movq %rbx, %rdi
callq 0x14630
jmp 0x18991
movq %rdx, %r15
movq %rax, %r14
movq %r14, %rdi
cmpl $0x1, %r15d
jne 0x189ab
callq 0x19f30
callq 0x19fa0
movl $0x2, %ebp
jmp 0x18967
callq 0xba430
// File: /workspace/github_cpp_makefile_star2_O3/tdv[P]boss/boss/include/common/string.h
// Function: Boss::String::Clear()
virtual RetCode BOSS_CALL Clear()
    {
      try
      {
        std::lock_guard<std::recursive_mutex> Lock(Mtx);
        Data.Release();
        Type = UnknownStringType;
        Length = 0;
        return Status::Ok;
      }
      catch (std::exception const &)
      {
      }
      return Status::Fail;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x18(%rdi), %rbx
movq %rbx, %rdi
callq 0x145d0
testl %eax, %eax
jne 0x189ef
movq 0x48(%r14), %rdi
testq %rdi, %rdi
je 0x189d7
movq (%rdi), %rax
callq *0x18(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%r14)
movq %rbx, %rdi
callq 0x14630
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movl %eax, %edi
callq 0x16169
movq %rdx, %r15
movq %rax, %r14
movq %rbx, %rdi
callq 0x14630
jmp 0x18a0c
movq %rdx, %r15
movq %rax, %r14
movq %r14, %rdi
cmpl $0x1, %r15d
jne 0x18a26
callq 0x19f30
callq 0x19fa0
movl $0x2, %eax
jmp 0x189e9
callq 0xba430
nop
// File: /workspace/github_cpp_makefile_star2_O3/tdv[P]boss/boss/include/common/string.h
// Function: Boss::String::ConvertInternal(unsigned int)
virtual RetCode ConvertInternal(UInt type)
    {
      if (Type == UnknownStringType && type != UnknownStringType)
        return Status::InvalidArgument;
      if (Type == type)
        return Status::Ok;
      if (Type == AnsiString || type == AnsiString)
        return Status::NotImplemented;
      if (Type == Utf8String && type == UnicodeString)
      {
        void const *Buf = 0;
        if (Data->GetData(&Buf) != Status::Ok)
          return Status::Fail;
        SetStringInternal(FromUtf8(std::string(reinterpret_cast<std::string::value_type const *>(Buf), Length).c_str()));
        return Status::Ok;
      }
      if (Type == UnicodeString && type == Utf8String)
      {
        void const *Buf = 0;
        if (Data->GetData(&Buf) != Status::Ok)
          return Status::Fail;
        SetStringInternal(ToUtf8(std::wstring(reinterpret_cast<std::wstring::value_type const *>(Buf), Length).c_str()), true);
        return Status::Ok;
      }
      return Status::Fail;
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl 0x40(%rdi), %ecx
testl %ecx, %ecx
sete %dl
testl %esi, %esi
setne %dil
movl $0x5, %eax
testb %dl, %dil
jne 0x18b76
xorl %eax, %eax
cmpl %esi, %ecx
je 0x18b76
cmpl $0x1, %ecx
sete %al
cmpl $0x1, %esi
sete %dl
orb %al, %dl
movl $0x6, %eax
jne 0x18b76
movl %ecx, %eax
xorl $0x2, %eax
movl %esi, %edx
xorl $0x3, %edx
orl %eax, %edx
jne 0x18ae1
movq %rsp, %rsi
movq $0x0, (%rsi)
movq 0x48(%rbx), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movl %eax, %ecx
movl $0x2, %eax
testl %ecx, %ecx
jne 0x18b76
movq (%rsp), %rsi
movl 0x44(%rbx), %edx
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x18cbe
movq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x19472
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x192b2
jmp 0x18b52
xorl $0x3, %ecx
xorl $0x2, %esi
movl $0x2, %eax
orl %ecx, %esi
jne 0x18b76
movq %rsp, %rsi
movq $0x0, (%rsi)
movq 0x48(%rbx), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movl %eax, %ecx
movl $0x2, %eax
testl %ecx, %ecx
jne 0x18b76
movq (%rsp), %rsi
movl 0x44(%rbx), %eax
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq (%rsi,%rax,4), %rdx
leaq 0x8(%rsp), %rdi
callq 0x195f8
movq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x1952c
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x1933c
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x18b65
callq 0x19ae0
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x18b74
callq 0x19ae0
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
jmp 0x18b84
jmp 0x18b9c
jmp 0x18bb0
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x18b9f
callq 0x19ae0
jmp 0x18b9f
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x18bb3
callq 0x19ae0
jmp 0x18bb3
movq %rax, %rbx
movq %rbx, %rdi
callq 0xba430
nop
// File: /workspace/github_cpp_makefile_star2_O3/tdv[P]boss/boss/include/common/../other/utf8_converter.h
// Function: Boss::Private::Utf8Converter::FromUtf8[abi:cxx11](char const*)
static std::wstring FromUtf8(char const *src)
      {
        std::wstring Ret;
        int len = strlen(src);
        for(int i = 0 ; i < len ; )
        {
          unsigned short ch = 0;
          if((src[i] & MASK3BYTES) == MASK3BYTES)
          {
            ch = ((src[i] & 0x0F) << 12) | ((src[i+1] & MASKBITS) << 6) | (src[i+2] & MASKBITS);
            i += 3;
          }
          else
          if((src[i] & MASK2BYTES) == MASK2BYTES)
          {
            ch = ((src[i] & 0x1F) << 6) | (src[i+1] & MASKBITS);
            i += 2;
          }
          else
          if(src[i] < static_cast<char>(MASKBYTE))
          {
            ch = src[i];
            i += 1;
          }
          Ret += ch;
        }
        return Ret;
      }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movl $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0x142c0
movq %rax, %r15
xorl %ebp, %ebp
cmpl %r15d, %ebp
jge 0x19507
movslq %ebp, %rax
leaq (%r14,%rax), %rcx
movsbl (%r14,%rax), %eax
movl %eax, %edx
notl %edx
testb $-0x20, %dl
jne 0x194db
shll $0xc, %eax
movzbl 0x1(%rcx), %edx
andl $0x3f, %edx
shll $0x6, %edx
movzwl %ax, %eax
orl %edx, %eax
movl $0x3, %edx
movl $0x2, %esi
jmp 0x194f2
xorl %esi, %esi
testb $-0x40, %dl
jne 0x194fd
andl $0x1f, %eax
shll $0x6, %eax
movl $0x2, %edx
movl $0x1, %esi
movzbl (%rcx,%rsi), %esi
andl $0x3f, %esi
orl %eax, %esi
addl %edx, %ebp
movq %rbx, %rdi
callq 0xa4340
jmp 0x194a3
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x19523
callq 0x19ae0
movq %r14, %rdi
callq 0xba430
nop
// File: /workspace/github_cpp_makefile_star2_O3/tdv[P]boss/boss/include/common/../other/utf8_converter.h
// Function: Boss::Private::Utf8Converter::ToUtf8[abi:cxx11](wchar_t const*)
static std::string ToUtf8(wchar_t const *src)
      {
        std::string Ret;
        int len = wcslen(src);
        for(int i = 0 ; i < len ; ++i)
        {
          if(src[i] < 0x80)
            Ret += static_cast<char>(src[i]);
          else
          if(src[i] < 0x800)
          {
            Ret += static_cast<char>(MASK2BYTES | src[i] >> 6);
            Ret += static_cast<char>(MASKBYTE | (src[i] & MASKBITS));
          }
          else
          if(src[i] < 0x10000)
          {
            Ret += static_cast<char>(MASK3BYTES | src[i] >> 12);
            Ret+= static_cast<char>(MASKBYTE | ((src[i] >> 6) & MASKBITS));
            Ret += static_cast<char>(MASKBYTE | (src[i] & MASKBITS));
          }
        }
        return Ret;
      }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0x140f0
movq %rax, %r15
testl %r15d, %r15d
jle 0x195d2
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
xorl %r13d, %r13d
movl (%r14,%r13,4), %eax
cmpl $0x7f, %eax
jle 0x195bf
cmpl $0x7ff, %eax            # imm = 0x7FF
ja 0x1958a
shrl $0x6, %eax
orb $-0x40, %al
movsbl %al, %esi
movq %rbx, %rdi
callq 0x8cac0
jmp 0x195b7
cmpl $0xffff, %eax           # imm = 0xFFFF
ja 0x195ca
shrl $0xc, %eax
orb $-0x20, %al
movsbl %al, %esi
movq %rbx, %rdi
callq 0x8cac0
movl (%r14,%r13,4), %eax
shrl $0x6, %eax
andb $0x3f, %al
orb $-0x80, %al
movsbl %al, %esi
movq %rbx, %rdi
callq 0x8cac0
movb (%r14,%r13,4), %al
andb $0x3f, %al
orb $-0x80, %al
movsbl %al, %esi
movq %rbx, %rdi
callq 0x8cac0
incq %r13
cmpq %r13, %r15
jne 0x19568
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x195ef
callq 0x19ae0
movq %r14, %rdi
callq 0xba430
nop
// File: /workspace/github_cpp_makefile_star2_O3/Laakeri[P]Triangulator/src/./graph.hpp
// Function: std::vector<long, std::allocator<long>> Graph::mapTableInto<long>(std::vector<long, std::allocator<long>> const&) const
std::vector<T> mapTableInto(const std::vector<T>& table) const {
		std::vector<T> res;
		for (int x : vMap) {
			assert(x >= 0 && x < (int)table.size());
			res.push_back(table[x]);
		}
		return res;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rsi), %r15
movq 0x8(%rsi), %r12
cmpq %r12, %r15
je 0x6ac5
movq %rdx, %r14
movslq (%r15), %rax
testq %rax, %rax
js 0x6ad4
movq (%r14), %rcx
movq 0x8(%r14), %rdx
subq %rcx, %rdx
shrq $0x3, %rdx
cmpl %edx, %eax
jge 0x6ad4
leaq (%rcx,%rax,8), %rdx
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x6ab4
movq (%rdx), %rax
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x6abc
movq %rbx, %rdi
callq 0x8df0
addq $0x4, %r15
cmpq %r12, %r15
jne 0x6a7c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x22bb5(%rip), %rdi     # 0x29690
leaq 0x22bce(%rip), %rsi     # 0x296b0
leaq 0x22bd3(%rip), %rcx     # 0x296bc
movl $0x32, %edx
callq 0x2140
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x6b0a
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x2210
movq %r14, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O3/Laakeri[P]Triangulator/src/bayes.cpp
// Function: Bayes::BayesIO::printFill(std::ostream&, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>)
void printFill(ostream& out, vector<pair<int, int> > es) {
		vector<string> mp(variables.size());
		for (auto v : variables) {
			assert(v.S>=0&&v.S<(int)variables.size());
			mp[v.S] = v.F;
		}
		for (auto e : es) {
			out<<mp[e.F]<<" "<<mp[e.S]<<endl;
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, (%rsp)
movq %rsi, %rbx
movq %rdi, %r15
movq 0x58(%rdi), %rsi
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x8976
movq 0x48(%r15), %r12
leaq 0x38(%r15), %r14
cmpq %r14, %r12
je 0x8020
leaq 0x30(%rsp), %rbp
leaq 0x20(%rsp), %r13
movq %rbp, 0x20(%rsp)
movq 0x20(%r12), %rsi
movq 0x28(%r12), %rdx
addq %rsi, %rdx
movq %r13, %rdi
callq 0x8714
movslq 0x40(%r12), %rdi
movl %edi, 0x40(%rsp)
testq %rdi, %rdi
js 0x80db
cmpl 0x58(%r15), %edi
jge 0x80db
shlq $0x5, %rdi
addq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x2100
movq 0x20(%rsp), %rdi
cmpq %rbp, %rdi
je 0x8010
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x2210
movq %r12, %rdi
callq 0x2170
movq %rax, %r12
cmpq %r14, %rax
jne 0x7fb2
movq (%rsp), %rax
movq (%rax), %r12
movq 0x8(%rax), %r13
cmpq %r13, %r12
je 0x80c2
leaq 0x22cf2(%rip), %r14     # 0x2ad2d
movslq (%r12), %rax
movslq 0x4(%r12), %rbp
movq 0x8(%rsp), %rcx
shlq $0x5, %rax
movq (%rcx,%rax), %rsi
movq 0x8(%rcx,%rax), %rdx
movq %rbx, %rdi
callq 0x2250
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x2250
movq 0x8(%rsp), %rax
shlq $0x5, %rbp
movq (%rax,%rbp), %rsi
movq 0x8(%rax,%rbp), %rdx
movq %r15, %rdi
callq 0x2250
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21f0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2160
addq $0x8, %r12
cmpq %r13, %r12
jne 0x803b
leaq 0x8(%rsp), %rdi
callq 0x43be
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2154a(%rip), %rdi     # 0x2962c
leaq 0x211bf(%rip), %rsi     # 0x292a8
leaq 0x2155e(%rip), %rcx     # 0x2964e
movl $0x128, %edx            # imm = 0x128
callq 0x2140
jmp 0x8118
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %rbp, %rdi
je 0x811b
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x2210
jmp 0x811b
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x43be
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O3/Laakeri[P]Triangulator/src/graph.cpp
// Function: Graph::Graph(int, int)
Graph::Graph(int n_, int m_) {
	n = n_;
	m = 0;
	g.resize(n);
	DENSE = denseG(n, m_);
	if (DENSE) initMatrix();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
leaq 0x38(%rdi), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rdi)
movq $0x0, 0x48(%rdi)
movups %xmm0, (%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
movl %esi, 0x50(%rdi)
movl $0x0, 0x54(%rdi)
movslq %esi, %rsi
movq %r15, %rdi
callq 0xa9dc
movslq 0x50(%rbx), %rax
movq %rax, %rcx
imulq %rax, %rcx
imulq %rax, %rcx
movslq %ebp, %rax
imulq %rax, %rax
shlq $0x2, %rax
leaq (%rax,%rax,4), %rax
cmpq %rax, %rcx
setle 0x30(%rbx)
jg 0x94c3
movq %rbx, %rdi
callq 0x93e4
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
movq %r15, %rdi
callq 0x41aa
movq %r14, %rdi
callq 0x436a
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x94f3
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x2210
movq %r12, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O3/Laakeri[P]Triangulator/src/graph.cpp
// Function: Graph::Graph(int, bool)
Graph::Graph(int n_, bool dense) {
	n = n_;
	m = 0;
	g.resize(n);
	DENSE = dense;
	if (DENSE) initMatrix();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
leaq 0x38(%rdi), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rdi)
movq $0x0, 0x48(%rdi)
movups %xmm0, (%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
movl %esi, 0x50(%rdi)
movl $0x0, 0x54(%rdi)
movslq %esi, %rsi
movq %r15, %rdi
callq 0xa9dc
movb %bpl, 0x30(%rbx)
testb %bpl, %bpl
je 0x9551
movq %rbx, %rdi
callq 0x93e4
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
movq %r15, %rdi
callq 0x41aa
movq %r14, %rdi
callq 0x436a
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x9581
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x2210
movq %r12, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O3/Laakeri[P]Triangulator/src/graph.cpp
// Function: Graph::addEdge(int, int)
void Graph::addEdge(int a, int b) {
	if (DENSE) {
		mat[a][b] = 1;
		mat[b][a] = 1;
	}
	g[a].push_back(b);
	g[b].push_back(a);
	m++;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
cmpb $0x0, 0x30(%rdi)
je 0x987c
movslq %ebp, %rcx
movq 0x18(%rbx), %rax
leaq (%rcx,%rcx,2), %rsi
movslq %edx, %rdi
movq (%rax,%rsi,8), %rax
movb $0x1, %sil
movb %sil, (%rax,%rdi)
movq 0x18(%rbx), %rax
leaq (%rdi,%rdi,2), %rdi
movq (%rax,%rdi,8), %rax
movb %sil, (%rax,%rcx)
jmp 0x987f
movslq %ebp, %rcx
movq 0x38(%rbx), %rax
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x98a1
movl %edx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x98b5
leaq 0x8(%rsp), %r14
movq %r14, %rdx
callq 0x92c4
movl (%r14), %edx
movq 0x38(%rbx), %rax
movslq %edx, %rcx
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x98d6
movl %ebp, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x98e0
leaq 0xc(%rsp), %rdx
callq 0x92c4
incl 0x54(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Laakeri[P]Triangulator/src/graph.cpp
// Function: Graph::popEdge(int, int)
void Graph::popEdge(int a, int b) {
	if (DENSE) {
		mat[a][b] = 0;
		mat[b][a] = 0;
	}
	g[a].pop_back();
	g[b].pop_back();
	m--;
}

// Assembly:
cmpb $0x0, 0x30(%rdi)
je 0x9bb6
movslq %esi, %rax
movq 0x18(%rdi), %rsi
leaq (%rax,%rax,2), %r8
movslq %edx, %rcx
movq (%rsi,%r8,8), %rdx
xorl %esi, %esi
movb %sil, (%rdx,%rcx)
movq 0x18(%rdi), %rdx
leaq (%rcx,%rcx,2), %r8
movq (%rdx,%r8,8), %rdx
movb %sil, (%rdx,%rax)
jmp 0x9bbc
movslq %esi, %rax
movslq %edx, %rcx
movq 0x38(%rdi), %rdx
leaq (%rax,%rax,2), %rax
addq $-0x4, 0x8(%rdx,%rax,8)
leaq (%rcx,%rcx,2), %rax
addq $-0x4, 0x8(%rdx,%rax,8)
decl 0x54(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/Laakeri[P]Triangulator/src/graph.cpp
// Function: Graph::remIncident(int)
void Graph::remIncident(int x) {
	for (int nx : g[x]) {
		for (size_t i = 0; i < g[nx].size(); i++) {
			if (g[nx][i] == x) {
				swap(g[nx][i], g[nx].back());
				g[nx].pop_back();
				break;
			}
		}
		if (DENSE) {
			mat[x][nx] = 0;
			mat[nx][x] = 0;
		}
		m--;
	}
	g[x].clear();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movslq %esi, %rcx
movq 0x38(%rdi), %r8
leaq (%rcx,%rcx,2), %rax
movq (%r8,%rax,8), %rdx
movq 0x8(%r8,%rax,8), %r8
cmpq %r8, %rdx
je 0x9d95
xorl %r9d, %r9d
movslq (%rdx), %r10
movq 0x38(%rdi), %r15
leaq (%r10,%r10,2), %r11
movq (%r15,%r11,8), %r14
movq 0x8(%r15,%r11,8), %rbx
movq %rbx, %r12
subq %r14, %r12
je 0x9d57
leaq (%r15,%r11,8), %r15
sarq $0x2, %r12
cmpq $0x1, %r12
adcq $0x0, %r12
xorl %r13d, %r13d
cmpl %esi, (%r14,%r13,4)
je 0x9d45
incq %r13
cmpq %r13, %r12
jne 0x9d35
jmp 0x9d57
leaq -0x4(%rbx), %r12
movl -0x4(%rbx), %ebp
movl %ebp, (%r14,%r13,4)
movl %esi, -0x4(%rbx)
movq %r12, 0x8(%r15)
cmpb $0x1, 0x30(%rdi)
jne 0x9d75
movq 0x18(%rdi), %rbx
movq (%rbx,%rax,8), %rbx
movb %r9b, (%rbx,%r10)
movq 0x18(%rdi), %r10
movq (%r10,%r11,8), %r10
movb %r9b, (%r10,%rcx)
decl 0x54(%rdi)
addq $0x4, %rdx
cmpq %r8, %rdx
jne 0x9d06
movq 0x38(%rdi), %rcx
movq (%rcx,%rax,8), %rdx
cmpq %rdx, 0x8(%rcx,%rax,8)
je 0x9d95
movq %rdx, 0x8(%rcx,%rax,8)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Laakeri[P]Triangulator/src/graph.cpp
// Function: Graph::remIncident(int, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>&)
void Graph::remIncident(int x, vector<pair<int, int> >& remd) {
	for (int nx : g[x]) {
		remd.push_back({x, nx});
		for (size_t i = 0; i < g[nx].size(); i++) {
			if (g[nx][i] == x) {
				swap(g[nx][i], g[nx].back());
				g[nx].pop_back();
				break;
			}
		}
		if (DENSE) {
			mat[x][nx] = 0;
			mat[nx][x] = 0;
		}
		m--;
	}
	g[x].clear();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movslq %esi, %rcx
movq 0x38(%rdi), %rax
movq %rcx, 0x10(%rsp)
leaq (%rcx,%rcx,2), %rcx
movq (%rax,%rcx,8), %r15
movq 0x8(%rax,%rcx,8), %r13
cmpq %r13, %r15
je 0x9e96
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movq %rcx, (%rsp)
movslq (%r15), %r12
movl %ebp, 0x8(%rsp)
movl %r12d, 0xc(%rsp)
movq %rbx, %rdi
leaq 0x8(%rsp), %rsi
callq 0xb2ae
movq 0x38(%r14), %rsi
leaq (%r12,%r12,2), %rax
movq (%rsi,%rax,8), %rdx
movq 0x8(%rsi,%rax,8), %rcx
movq %rcx, %rdi
subq %rdx, %rdi
je 0x9e44
leaq (%rsi,%rax,8), %rsi
sarq $0x2, %rdi
cmpq $0x1, %rdi
adcq $0x0, %rdi
xorl %r8d, %r8d
cmpl %ebp, (%rdx,%r8,4)
je 0x9e31
incq %r8
cmpq %r8, %rdi
jne 0x9e21
jmp 0x9e44
leaq -0x4(%rcx), %rdi
movl -0x4(%rcx), %r9d
movl %r9d, (%rdx,%r8,4)
movl %ebp, -0x4(%rcx)
movq %rdi, 0x8(%rsi)
cmpb $0x1, 0x30(%r14)
jne 0x9e6d
movq 0x18(%r14), %rcx
movq (%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
xorl %edx, %edx
movb %dl, (%rcx,%r12)
movq 0x18(%r14), %rcx
movq (%rcx,%rax,8), %rax
movq 0x10(%rsp), %rcx
movb %dl, (%rax,%rcx)
decl 0x54(%r14)
addq $0x4, %r15
cmpq %r13, %r15
jne 0x9ddc
movq 0x38(%r14), %rax
movq (%rsp), %rdx
movq (%rax,%rdx,8), %rcx
cmpq %rcx, 0x8(%rax,%rdx,8)
je 0x9e96
movq %rcx, 0x8(%rax,%rdx,8)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Laakeri[P]Triangulator/src/graph.cpp
// Function: Graph::hasEdge(int, int) const
bool Graph::hasEdge(int a, int b) const {
	if (DENSE) return mat[a][b] == 1;
	if (g[a].size() < g[b].size()) {
		for (int nx : g[a]) {
			if (nx == b) return true;
		}
		return false;
	}
	else {
		for (int nx : g[b]) {
			if (nx == a) return true;
		}
		return false;
	}
}

// Assembly:
movslq %esi, %rax
cmpb $0x1, 0x30(%rdi)
jne 0x9ec6
movq 0x18(%rdi), %rcx
leaq (%rax,%rax,2), %rax
movslq %edx, %rdx
movq (%rcx,%rax,8), %rax
cmpb $0x1, (%rax,%rdx)
sete %al
retq
movq 0x38(%rdi), %r8
leaq (%rax,%rax,2), %rax
movq (%r8,%rax,8), %rdi
movq 0x8(%r8,%rax,8), %rcx
movq %rcx, %rax
subq %rdi, %rax
movslq %edx, %r9
leaq (%r9,%r9,2), %r10
movq (%r8,%r10,8), %r9
movq 0x8(%r8,%r10,8), %r8
movq %r8, %r10
subq %r9, %r10
cmpq %r10, %rax
jae 0x9f17
cmpq %rcx, %rdi
je 0x9f37
addq $0x4, %rdi
cmpl %edx, -0x4(%rdi)
sete %al
je 0x9ec5
leaq 0x4(%rdi), %rsi
cmpq %rcx, %rdi
movq %rsi, %rdi
jne 0x9f01
jmp 0x9ec5
cmpq %r8, %r9
je 0x9f37
addq $0x4, %r9
cmpl %esi, -0x4(%r9)
sete %al
je 0x9ec5
leaq 0x4(%r9), %rcx
cmpq %r8, %r9
movq %rcx, %r9
jne 0x9f20
jmp 0x9ec5
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/Laakeri[P]Triangulator/src/graph.cpp
// Function: Graph::print(std::ostream&) const
void Graph::print(ostream& out) const {
	out<<"n "<<n<<endl;
	int mm = 0;
	for (int i = 0; i < n; i++) {
		mm += (int)g[i].size();
	}
	assert(mm%2 == 0);
	assert(mm/2 == m);
	out<<"m "<<m<<endl;
	for (int i = 0; i < n; i++) {
		for (int nx : g[i]) {
			if (i<nx) out<<i<<" "<<nx<<endl;
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r13
leaq 0x1f7cc(%rip), %rsi     # 0x29721
movl $0x2, %edx
movq %rbx, %rdi
callq 0x2250
movl 0x50(%r13), %esi
movq %rbx, 0x8(%rsp)
movq %rbx, %rdi
callq 0x2300
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21f0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2160
movslq 0x50(%r13), %rax
testq %rax, %rax
jle 0x9ff1
movq 0x38(%r13), %rcx
shlq $0x3, %rax
leaq (%rax,%rax,2), %rdx
xorl %esi, %esi
xorl %eax, %eax
movq 0x8(%rcx,%rsi), %rdi
subq (%rcx,%rsi), %rdi
shrq $0x2, %rdi
addl %edi, %eax
addq $0x18, %rsi
cmpq %rsi, %rdx
jne 0x9fb6
testb $0x1, %al
je 0x9ff3
leaq 0x1f74b(%rip), %rdi     # 0x29724
leaq 0x1f74e(%rip), %rsi     # 0x2972e
leaq 0x1f751(%rip), %rcx     # 0x29738
movl $0xb1, %edx
callq 0x2140
xorl %eax, %eax
sarl %eax
cmpl 0x54(%r13), %eax
jne 0xa10c
leaq 0x1f75f(%rip), %rsi     # 0x29765
movl $0x2, %edx
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x2250
movl 0x54(%r13), %esi
movq %rbx, %rdi
callq 0x2300
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21f0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2160
movl 0x50(%r13), %eax
testl %eax, %eax
jle 0xa0fd
xorl %r15d, %r15d
leaq 0x20cc9(%rip), %r12     # 0x2ad2d
movq %r13, 0x10(%rsp)
movq 0x38(%r13), %rcx
leaq (%r15,%r15,2), %rdx
movq (%rcx,%rdx,8), %r14
movq 0x8(%rcx,%rdx,8), %rbx
cmpq %rbx, %r14
je 0xa0ee
movslq (%r14), %r13
cmpq %r13, %r15
jge 0xa0dc
movq 0x8(%rsp), %rdi
movl %r15d, %esi
callq 0x2300
movq %rax, %rbp
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2250
movq %rbp, %rdi
movl %r13d, %esi
callq 0x2300
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x21f0
movsbl %al, %esi
movq %r13, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2160
addq $0x4, %r14
cmpq %rbx, %r14
jne 0xa07f
movq 0x10(%rsp), %r13
movl 0x50(%r13), %eax
incq %r15
movslq %eax, %rcx
cmpq %rcx, %r15
jl 0xa069
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1f648(%rip), %rdi     # 0x2975b
leaq 0x1f614(%rip), %rsi     # 0x2972e
leaq 0x1f617(%rip), %rcx     # 0x29738
movl $0xb2, %edx
callq 0x2140
nop
// File: /workspace/github_cpp_makefile_star2_O3/Laakeri[P]Triangulator/src/graph.cpp
// Function: Graph::dfs1(int, std::vector<int, std::allocator<int>>&) const
void Graph::dfs1(int x, vector<int>& u) const {
	if (u[x]) return;
	u[x] = 1;
	for (int nx : g[x]) {
		dfs1(nx, u);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movslq %esi, %rax
movq (%rdx), %rcx
cmpl $0x0, (%rcx,%rax,4)
jne 0xa47a
movq %rdi, %r14
movl $0x1, (%rcx,%rax,4)
movq 0x38(%rdi), %rcx
leaq (%rax,%rax,2), %rax
movq (%rcx,%rax,8), %r15
movq 0x8(%rcx,%rax,8), %r12
cmpq %r12, %r15
je 0xa47a
movq %rdx, %rbx
movl (%r15), %esi
movq %r14, %rdi
movq %rbx, %rdx
callq 0xa42c
addq $0x4, %r15
cmpq %r12, %r15
jne 0xa463
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/Laakeri[P]Triangulator/src/graph.cpp
// Function: Graph::isConnected() const
bool Graph::isConnected() const {
	vector<int> u(n);
	dfs1(0, u);
	for (int i = 0; i < n; i++) {
		if (!u[i]) return false;
	}
	return true;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movslq 0x50(%rdi), %rsi
leaq 0x10(%rsp), %r14
leaq 0xf(%rsp), %rdx
movq %r14, %rdi
callq 0xaa18
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0xa42c
movslq 0x50(%rbx), %rax
movq (%r14), %rdi
testq %rax, %rax
jle 0xa4e5
cmpl $0x0, (%rdi)
je 0xa4ee
leaq -0x1(%rax), %rcx
xorl %edx, %edx
cmpq %rdx, %rcx
je 0xa4f2
leaq 0x1(%rdx), %rsi
cmpl $0x0, 0x4(%rdi,%rdx,4)
movq %rsi, %rdx
jne 0xa4ca
cmpq %rax, %rsi
setae %bl
jmp 0xa4f4
movb $0x1, %bl
testq %rdi, %rdi
jne 0xa4f4
jmp 0xa501
xorl %ebx, %ebx
jmp 0xa4f4
movb $0x1, %bl
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x2210
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Laakeri[P]Triangulator/src/graph.cpp
// Function: Graph::isConnectedOrIsolated() const
bool Graph::isConnectedOrIsolated() const {
	vector<int> u(n);
	int cc = 0;
	for (int i = 0; i < n; i++) {
		if (u[i] == 0 && g[i].size() > 0) {
			cc++;
			dfs1(i, u);
		}
	}
	return cc <= 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movslq 0x50(%rdi), %rsi
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xaa18
movl 0x50(%rbx), %eax
testl %eax, %eax
jle 0xa58a
xorl %r14d, %r14d
movl $0x2, %r12d
leaq 0x8(%rsp), %r15
xorl %ebp, %ebp
movq 0x8(%rsp), %rcx
cmpl $0x0, (%rcx,%r14,4)
jne 0xa573
movq 0x38(%rbx), %rcx
movq (%rcx,%r12,4), %rdx
cmpq -0x8(%rcx,%r12,4), %rdx
je 0xa573
incl %ebp
movq %rbx, %rdi
movl %r14d, %esi
movq %r15, %rdx
callq 0xa42c
movl 0x50(%rbx), %eax
incq %r14
movslq %eax, %rcx
addq $0x6, %r12
cmpq %rcx, %r14
jl 0xa545
cmpl $0x2, %ebp
setl %bl
jmp 0xa58c
movb $0x1, %bl
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xa5a3
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x2210
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Laakeri[P]Triangulator/src/graph.cpp
// Function: Graph::hasCycle() const
bool Graph::hasCycle() const {
	vector<int> u(n);
	int cc = 0;
	for (int i = 0; i < n; i++) {
		if (u[i] == 0 && g[i].size() > 0) {
			cc++;
			dfs1(i, u);
		}
	}
	return m > n - cc;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movslq 0x50(%rdi), %rsi
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xaa18
movl 0x50(%rbx), %ebp
testl %ebp, %ebp
jle 0xa62e
xorl %r14d, %r14d
movl $0x2, %r13d
leaq 0x10(%rsp), %r15
xorl %r12d, %r12d
movq 0x10(%rsp), %rax
cmpl $0x0, (%rax,%r14,4)
jne 0xa61d
movq 0x38(%rbx), %rax
movq (%rax,%r13,4), %rcx
cmpq -0x8(%rax,%r13,4), %rcx
je 0xa61d
incl %r12d
movq %rbx, %rdi
movl %r14d, %esi
movq %r15, %rdx
callq 0xa42c
movl 0x50(%rbx), %ebp
incq %r14
movslq %ebp, %rax
addq $0x6, %r13
cmpq %rax, %r14
jl 0xa5ee
jmp 0xa631
xorl %r12d, %r12d
movl 0x54(%rbx), %ebx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xa64b
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x2210
subl %r12d, %ebp
cmpl %ebp, %ebx
setg %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Laakeri[P]Triangulator/src/graph.cpp
// Function: Graph::mapInto(int) const
int Graph::mapInto(int v) const {
	int id = lower_bound(vMap.begin(), vMap.end(), v) - vMap.begin();
	assert(id < (int)vMap.size());
	assert(vMap[id] == v);
	return id;
}

// Assembly:
pushq %rax
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
subq %rcx, %rdx
sarq $0x2, %rdx
movq %rcx, %rdi
testq %rdx, %rdx
jle 0xa6a9
movq %rdx, %rax
movq %rcx, %rdi
movq %rax, %r8
shrq %r8
movq %r8, %r9
notq %r9
addq %rax, %r9
leaq (%rdi,%r8,4), %rax
addq $0x4, %rax
cmpl %esi, -0x4(%rax)
cmovlq %rax, %rdi
cmovgeq %r8, %r9
movq %r9, %rax
testq %r9, %r9
jg 0xa67f
subq %rcx, %rdi
movq %rdi, %rax
shrq $0x2, %rax
cmpl %edx, %eax
jge 0xa6c6
shlq $0x1e, %rdi
sarq $0x1e, %rdi
cmpl %esi, (%rcx,%rdi)
jne 0xa6e5
popq %rcx
retq
leaq 0x1f09b(%rip), %rdi     # 0x29768
leaq 0x1f05a(%rip), %rsi     # 0x2972e
leaq 0x1f0a3(%rip), %rcx     # 0x2977e
movl $0x10c, %edx            # imm = 0x10C
callq 0x2140
leaq 0x1f0b0(%rip), %rdi     # 0x2979c
leaq 0x1f03b(%rip), %rsi     # 0x2972e
leaq 0x1f084(%rip), %rcx     # 0x2977e
movl $0x10d, %edx            # imm = 0x10D
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O3/Laakeri[P]Triangulator/src/IO.cpp
// Function: IO::nTokens(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const
int IO::nTokens(string s) const {
	stringstream ss;
	ss<<s;
	int r=0;
	while (ss>>s) {
		r++;
	}
	return r;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rsi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2180
leaq 0x18(%rsp), %rdi
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
callq 0x2250
xorl %ebp, %ebp
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2280
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x10ff9
incl %ebp
jmp 0x10fdc
movq 0x23fb0(%rip), %rsi     # 0x34fb0
leaq 0x8(%rsp), %rdi
callq 0x21a0
leaq 0x88(%rsp), %rdi
callq 0x2080
movl %ebp, %eax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x11027
movq %rax, %rbx
movq 0x23f7f(%rip), %rsi     # 0x34fb0
leaq 0x8(%rsp), %rdi
callq 0x21a0
leaq 0x88(%rsp), %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O3/Laakeri[P]Triangulator/src/MCS.cpp
// Function: MCS::findCC(int, Graph const&, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>&)
void findCC(int x, const Graph& G, vector<pair<int, int> >& v) {
	if (rc[x]) return;
	rc[x] = 1;
	for (int nx : G.g[x]) {
		if (ca[nx] || !rc[nx]) {
			v.push_back({x, nx});
		}
	}
	for (int nx : G.g[x]) {
		if (!ca[nx] && !rc[nx]) {
			findCC(nx, G, v);
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, (%rsp)
movslq %edi, %rax
leaq 0x2cda8e(%rip), %rcx    # 0x2e0bd0
cmpl $0x0, (%rcx,%rax,4)
je 0x13157
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2cda72(%rip), %rcx    # 0x2e0bd0
movl $0x1, (%rcx,%rax,4)
movq (%rsp), %rcx
movq 0x38(%rcx), %rcx
leaq (%rax,%rax,2), %rax
movq (%rcx,%rax,8), %r14
movq 0x8(%rcx,%rax,8), %r12
cmpq %r12, %r14
je 0x13148
movq %rdx, %rbx
movl %edi, %ebp
movq %rax, 0x10(%rsp)
leaq 0x2fe780(%rip), %r13    # 0x311910
leaq 0x8(%rsp), %r15
movl (%r14), %eax
movslq %eax, %rcx
cmpl $0x0, (%r13,%rcx,4)
je 0x131b8
movl %ebp, 0x8(%rsp)
movl %eax, 0xc(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb2ae
jmp 0x131c5
leaq 0x2cda11(%rip), %rdx    # 0x2e0bd0
cmpl $0x0, (%rdx,%rcx,4)
je 0x131a3
addq $0x4, %r14
cmpq %r12, %r14
jne 0x13195
movq (%rsp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %r14
movq 0x8(%rax,%rcx,8), %r15
cmpq %r15, %r14
je 0x13148
movslq (%r14), %rdi
cmpl $0x0, (%r13,%rdi,4)
jne 0x13211
leaq 0x2cd9d1(%rip), %rax    # 0x2e0bd0
cmpl $0x0, (%rax,%rdi,4)
jne 0x13211
movq (%rsp), %rsi
movq %rbx, %rdx
callq 0x13126
addq $0x4, %r14
jmp 0x131e4
// File: /workspace/github_cpp_makefile_star2_O3/Laakeri[P]Triangulator/src/minfill.cpp
// Function: MinFill::BackTrack::solve(Graph, int, int, int)
vector<pair<int, int> > solve(Graph G, int lowerBound, int upperBound, int depth) {
	assert(lowerBound >= 0);
	if (upperBound < lowerBound) return FAILSOLUTION;
	auto sol = searchNaive(G, lowerBound, upperBound, 0, depth);
	return sol;
}

// Assembly:
pushq %rbx
testl %edx, %edx
js 0x16c13
movq %rdi, %rbx
cmpl %edx, %ecx
jge 0x16c00
leaq 0x4b245a(%rip), %rsi    # 0x4c9050
movq %rbx, %rdi
callq 0x3f7c
jmp 0x16c0e
movl %r8d, %r9d
movq %rbx, %rdi
xorl %r8d, %r8d
callq 0x160f8
movq %rbx, %rax
popq %rbx
retq
leaq 0x12734(%rip), %rdi     # 0x2934e
leaq 0x134f7(%rip), %rsi     # 0x2a118
leaq 0x135ec(%rip), %rcx     # 0x2a214
movl $0x42, %edx
callq 0x2140