LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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
andq $0x0, 0x10(%rsp)
andl $0x0, 0x4(%rsp)
leaq 0x8(%rsp), %rdx
andq $0x0, (%rdx)
movq %rdi, %rbx
movq (%rsi), %rdi
movq (%rdi), %rax
pushq $0x1
popq %rsi
callq *0x38(%rax)
testl %eax, %eax
jne 0x17732
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
leaq 0x4(%rsp), %rsi
callq *0x30(%rax)
testl %eax, %eax
jne 0x17732
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
leaq 0x10(%rsp), %rsi
callq *0x28(%rax)
testl %eax, %eax
jne 0x17732
movq 0x10(%rsp), %rsi
movl 0x4(%rsp), %edx
leaq 0x28(%rsp), %r14
movq %r14, -0x10(%r14)
addq %rsi, %rdx
leaq 0x18(%rsp), %rdi
callq 0x18ab0
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x18(%rsp), %rcx
cmpq %r14, %rcx
je 0x176f8
movq %rcx, (%rbx)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rbx)
jmp 0x176ff
movups (%r14), %xmm0
movups %xmm0, (%rax)
leaq 0x18(%rsp), %rdi
movq 0x8(%rdi), %rax
movq %rax, 0x8(%rbx)
movq %r14, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
callq 0x8c360
leaq 0x8(%rsp), %rdi
callq 0x18f9e
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x19d00
movq %rax, %r14
leaq 0xa69c3(%rip), %rsi     # 0xbe107
movq %rax, %rdi
callq 0x1977a
leaq 0xdcfad(%rip), %rsi     # 0xf4700
leaq 0xc166(%rip), %rdx      # 0x238c0
movq %r14, %rdi
callq 0x1ad50
jmp 0x17771
movq %rax, %rbx
movq %r14, %rdi
callq 0x19d60
jmp 0x17774
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x18f9e
movq %rbx, %rdi
callq 0xbadf0
// File: /workspace/github_cpp_makefile_star2_O2/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 0xdcfd5(%rip), %rax     # 0xf4918
movq %rax, (%rdi)
leaq 0xdd013(%rip), %rax     # 0xf4960
movq %rax, 0x8(%rdi)
andq $0x0, 0x18(%rdi)
addq $0x18, %rbx
leaq 0x8(%rsp), %rdi
callq 0x17b9e
movq 0x8(%rsp), %r14
leaq 0xa66ca(%rip), %rsi     # 0xbe03a
leaq 0x20(%rsp), %rdi
callq 0x17c68
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x17c0e
leaq 0x20(%rsp), %rdi
callq 0x17ce6
movq 0x8(%rsp), %r14
leaq 0xa66a6(%rip), %rsi     # 0xbe043
leaq 0x18(%rsp), %rdi
callq 0x17c68
leaq 0x18(%rsp), %rsi
movq %r14, %rdi
callq 0x17c0e
leaq 0x18(%rsp), %rdi
callq 0x17ce6
movq 0x8(%rsp), %r14
leaq 0xa6682(%rip), %rsi     # 0xbe04c
leaq 0x10(%rsp), %rdi
callq 0x17c68
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x17c0e
leaq 0x10(%rsp), %rdi
callq 0x17ce6
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x17cf6
leaq 0xe4a61(%rip), %rdi     # 0xfc460
leaq 0xa66ab(%rip), %rsi     # 0xbe0b1
callq 0x85bb0
movq %rax, %rdi
callq 0x85490
leaq 0x8(%rsp), %rdi
callq 0x17d26
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
leaq 0x10(%rsp), %rdi
jmp 0x17a41
movq %rax, %r14
leaq 0x18(%rsp), %rdi
jmp 0x17a41
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x17ce6
jmp 0x17a50
movq %rax, %r14
jmp 0x17a5a
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x17d26
movq %rbx, %rdi
callq 0x1786c
movq %r14, %rdi
callq 0xbadf0
// File: /workspace/github_cpp_makefile_star2_O2/tdv[P]boss/boss/include/core/ref_obj_ptr.h
// Function: Boss::RefObjPtr<Boss::IEnum>& Boss::RefObjPtr<Boss::IEnum>::operator=<Boss::Enum>(Boss::RefObjPtr<Boss::Enum>&&)
RefObjPtr& operator = (RefObjPtr<Other> &&ptr)
    {
      Release();
      Ptr = ptr.Ptr;
      ptr.Ptr = 0;
      return *this;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x178dc
movq (%rbx), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
movq %rcx, (%r14)
andq $0x0, (%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x183a2
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x18(%rdi), %r15
movq %r15, %rdi
callq 0x180d6
movl 0x44(%r14), %eax
movl %eax, (%rbx)
movq %r15, %rdi
callq 0x14630
xorl %eax, %eax
jmp 0x183a5
pushq $0x5
popq %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rdi
cmpl $0x1, %edx
jne 0x183c1
callq 0x19e60
callq 0x19ed0
pushq $0x2
jmp 0x183a4
callq 0xbadf0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x183f4
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x18(%rdi), %r15
movq %r15, %rdi
callq 0x180d6
movl 0x40(%r14), %eax
movl %eax, (%rbx)
movq %r15, %rdi
callq 0x14630
xorl %eax, %eax
jmp 0x183f7
pushq $0x5
popq %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rdi
cmpl $0x1, %edx
jne 0x18413
callq 0x19e60
callq 0x19ed0
pushq $0x2
jmp 0x183f6
callq 0xbadf0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x5
popq %rbp
testq %rdx, %rdx
je 0x1847a
movq %rdx, %r14
cmpq $0x0, (%rdx)
jne 0x1847a
movl %esi, %r12d
movq %rdi, %r15
leaq 0x18(%rdi), %rbx
movq %rbx, %rdi
callq 0x180d6
cmpl $0x0, 0x40(%r15)
je 0x1846f
movq (%r15), %rax
movq %r15, %rdi
movl %r12d, %esi
callq *0x68(%rax)
movl %eax, %ebp
testl %eax, %eax
jne 0x18472
addq $0x48, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x18fca
movl %eax, %ebp
jmp 0x18472
pushq $0x1
popq %rbp
movq %rbx, %rdi
callq 0x14630
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r15
movq %rax, %r14
movq %rbx, %rdi
callq 0x14630
jmp 0x1849b
movq %rdx, %r15
movq %rax, %r14
movq %r14, %rdi
cmpl $0x1, %r15d
jne 0x184b3
callq 0x19e60
callq 0x19ed0
pushq $0x2
popq %rbp
jmp 0x1847a
callq 0xbadf0
// File: /workspace/github_cpp_makefile_star2_O2/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
je 0x1867b
pushq $0x5
jmp 0x186d1
movq %rdx, %r12
movq %rdi, %r14
leaq 0x18(%rdi), %rbx
movq %rbx, %rdi
callq 0x180d6
andq $0x0, 0x18(%rsp)
leaq 0xc(%rsp), %rsi
andl $0x0, (%rsi)
movq (%r12), %rax
movq %r12, %rdi
callq *0x30(%rax)
pushq $0x2
popq %rbp
testl %eax, %eax
jne 0x186bf
movq (%r12), %rax
leaq 0x18(%rsp), %rsi
movq %r12, %rdi
callq *0x28(%rax)
testl %eax, %eax
je 0x186e1
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x14630
testb %r14b, %r14b
je 0x186d2
pushq $0x2
popq %rbp
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x3, 0x40(%r14)
jne 0x186f4
testb $0x3, 0xc(%rsp)
je 0x186f4
pushq $0x5
popq %rbp
jmp 0x186bf
leaq 0x10(%rsp), %rdi
leaq 0x18(%rsp), %rsi
leaq 0xc(%rsp), %rdx
callq 0x18fe8
leaq 0x48(%r14), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1906c
leaq 0x10(%rsp), %rdi
callq 0x18bca
movl %r15d, 0x40(%r14)
movl 0xc(%rsp), %eax
movl %eax, %ecx
shrl $0x2, %ecx
cmpl $0x3, %r15d
cmovnel %eax, %ecx
movl %ecx, 0x44(%r14)
movb $0x1, %r14b
jmp 0x186c2
movq %rdx, %r15
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x18bca
jmp 0x1875f
jmp 0x18759
movq %rdx, %r15
movq %rax, %r14
jmp 0x18767
movq %rdx, %r15
movq %rax, %r14
movq %rbx, %rdi
callq 0x14630
movq %r14, %rdi
cmpl $0x1, %r15d
jne 0x1877f
callq 0x19e60
callq 0x19ed0
jmp 0x186cf
callq 0xbadf0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x180d6
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
movq %rdx, %r15
movq %rax, %r14
movq %rbx, %rdi
callq 0x14630
jmp 0x187d4
movq %rdx, %r15
movq %rax, %r14
movq %r14, %rdi
cmpl $0x1, %r15d
jne 0x187ec
callq 0x19e60
callq 0x19ed0
pushq $0x2
popq %rbp
jmp 0x187b1
callq 0xbadf0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x180d6
leaq 0x48(%r14), %rdi
callq 0x18fae
andq $0x0, 0x40(%r14)
movq %rbx, %rdi
callq 0x14630
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %rdx, %r15
movq %rax, %r14
movq %rbx, %rdi
callq 0x14630
jmp 0x1883a
movq %rdx, %r15
movq %rax, %r14
movq %r14, %rdi
cmpl $0x1, %r15d
jne 0x18852
callq 0x19e60
callq 0x19ed0
pushq $0x2
popq %rax
jmp 0x1881e
callq 0xbadf0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x50, %rsp
movl 0x40(%rdi), %ecx
testl %ecx, %ecx
sete %al
testl %esi, %esi
setne %dl
testb %al, %dl
je 0x18873
pushq $0x5
popq %rax
jmp 0x18879
xorl %eax, %eax
cmpl %esi, %ecx
jne 0x1887f
addq $0x50, %rsp
popq %rbx
retq
cmpl $0x1, %ecx
sete %al
cmpl $0x1, %esi
sete %dl
orb %al, %dl
je 0x18893
pushq $0x6
jmp 0x18870
movq %rdi, %rbx
movl %ecx, %eax
xorl $0x2, %eax
movl %esi, %edx
xorl $0x3, %edx
orl %eax, %edx
jne 0x1890b
leaq 0x8(%rsp), %rsi
andq $0x0, (%rsi)
movq 0x48(%rbx), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
testl %eax, %eax
jne 0x1892c
movq 0x8(%rsp), %rsi
movl 0x44(%rbx), %edx
leaq 0x20(%rsp), %rax
movq %rax, -0x10(%rax)
addq %rsi, %rdx
leaq 0x10(%rsp), %rdi
callq 0x18ab0
movq 0x10(%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x19288
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x190d8
leaq 0x30(%rsp), %rdi
callq 0xa3d10
leaq 0x10(%rsp), %rdi
callq 0x8c360
jmp 0x18985
xorl $0x3, %ecx
xorl $0x2, %esi
orl %ecx, %esi
jne 0x1892c
leaq 0x8(%rsp), %rsi
andq $0x0, (%rsi)
movq 0x48(%rbx), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
testl %eax, %eax
je 0x18933
pushq $0x2
jmp 0x18870
movq 0x8(%rsp), %rsi
movl 0x44(%rbx), %eax
leaq 0x20(%rsp), %rcx
movq %rcx, -0x10(%rcx)
leaq (%rsi,%rax,4), %rdx
leaq 0x10(%rsp), %rdi
callq 0x19402
movq 0x10(%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x19340
leaq 0x30(%rsp), %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x19152
leaq 0x30(%rsp), %rdi
callq 0x8c360
leaq 0x10(%rsp), %rdi
callq 0xa3d10
xorl %eax, %eax
jmp 0x18879
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x8c360
jmp 0x1899e
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xa3d10
jmp 0x189cd
jmp 0x189ca
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xa3d10
jmp 0x189be
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x8c360
jmp 0x189cd
movq %rax, %rbx
movq %rbx, %rdi
callq 0xbadf0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r14
andl $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0x142c0
movq %rax, %r15
xorl %ebp, %ebp
pushq $0x3
popq %r12
pushq $0x2
popq %r13
cmpl %r15d, %ebp
jge 0x1931a
movslq %ebp, %rax
leaq (%r14,%rax), %rcx
movsbl (%r14,%rax), %eax
movl %eax, %edx
notl %edx
testb $-0x20, %dl
jne 0x192f2
shll $0xc, %eax
movzbl 0x1(%rcx), %edx
andl $0x3f, %edx
shll $0x6, %edx
movzwl %ax, %eax
orl %edx, %eax
movq %r13, %rsi
movl %r12d, %edx
jmp 0x19305
xorl %esi, %esi
testb $-0x40, %dl
jne 0x19310
andl $0x1f, %eax
shll $0x6, %eax
pushq $0x1
popq %rsi
pushq $0x2
popq %rdx
movzbl (%rcx,%rsi), %esi
andl $0x3f, %esi
orl %eax, %esi
addl %edx, %ebp
movq %rbx, %rdi
callq 0xa4300
jmp 0x192be
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xa3d10
movq %r14, %rdi
callq 0xbadf0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0x140f0
movq %rax, %r15
xorl %r12d, %r12d
testl %r15d, %r15d
cmovlel %r12d, %r15d
cmpq %r12, %r15
je 0x193df
movl (%r14,%r12,4), %eax
cmpl $0x7f, %eax
jle 0x193cf
cmpl $0x7ff, %eax            # imm = 0x7FF
ja 0x1939a
shrl $0x6, %eax
orb $-0x40, %al
movsbl %al, %esi
movq %rbx, %rdi
callq 0x8c9f0
jmp 0x193c7
cmpl $0xffff, %eax           # imm = 0xFFFF
ja 0x193da
shrl $0xc, %eax
orb $-0x20, %al
movsbl %al, %esi
movq %rbx, %rdi
callq 0x8c9f0
movl (%r14,%r12,4), %eax
shrl $0x6, %eax
andb $0x3f, %al
orb $-0x80, %al
movsbl %al, %esi
movq %rbx, %rdi
callq 0x8c9f0
movb (%r14,%r12,4), %al
andb $0x3f, %al
orb $-0x80, %al
movsbl %al, %esi
movq %rbx, %rdi
callq 0x8c9f0
incq %r12
jmp 0x19373
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x8c360
movq %r14, %rdi
callq 0xbadf0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdx, %r14
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq (%rsi), %r15
movq 0x8(%rsi), %r12
cmpq %r12, %r15
je 0x5253
movslq (%r15), %rax
testq %rax, %rax
js 0x5262
movq (%r14), %rcx
movq 0x8(%r14), %rdx
subq %rcx, %rdx
shrq $0x3, %rdx
cmpl %edx, %eax
jge 0x5262
leaq (%rcx,%rax,8), %rsi
movq %rbx, %rdi
callq 0x7134
addq $0x4, %r15
jmp 0x5222
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x1b427(%rip), %rdi     # 0x20690
leaq 0x1b440(%rip), %rsi     # 0x206b0
leaq 0x1b445(%rip), %rcx     # 0x206bc
pushq $0x32
popq %rdx
callq 0x2150
movq %rax, %r14
movq %rbx, %rdi
callq 0x6ebc
movq %r14, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq 0x58(%rdi), %rsi
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %r12
movq %r12, %rdx
callq 0x6d96
movq 0x48(%r15), %r13
leaq 0x38(%r15), %rbp
cmpq %rbp, %r13
je 0x64ae
leaq 0x20(%r13), %rsi
movq %r12, %rdi
callq 0x6de8
movslq 0x40(%rsp), %rdi
testq %rdi, %rdi
js 0x6521
cmpl 0x58(%r15), %edi
jge 0x6521
shlq $0x5, %rdi
addq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x2110
movq %r12, %rdi
callq 0x20d0
movq %r13, %rdi
callq 0x2180
movq %rax, %r13
jmp 0x645f
movq (%r14), %r12
movq 0x8(%r14), %r13
leaq 0x1b871(%rip), %r14     # 0x21d2d
cmpq %r13, %r12
je 0x6508
movslq (%r12), %rsi
movslq 0x4(%r12), %r15
shlq $0x5, %rsi
addq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x21f0
movq %rax, %rdi
movq %r14, %rsi
callq 0x2210
shlq $0x5, %r15
addq 0x8(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x21f0
movq %rax, %rdi
callq 0x20e0
addq $0x8, %r12
jmp 0x64bc
leaq 0x8(%rsp), %rdi
callq 0x3a66
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1a104(%rip), %rdi     # 0x2062c
leaq 0x19d79(%rip), %rsi     # 0x202a8
leaq 0x1a118(%rip), %rcx     # 0x2064e
movl $0x128, %edx            # imm = 0x128
callq 0x2150
jmp 0x6551
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x20d0
jmp 0x6554
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3a66
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O2/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 0x38(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rdi)
andq $0x0, 0x48(%rdi)
movups %xmm0, (%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
movl %esi, 0x50(%rdi)
andl $0x0, 0x54(%rdi)
movslq %esi, %rsi
movq %r14, %rdi
callq 0x87e2
movslq 0x50(%rbx), %rax
movq %rax, %rcx
imulq %rax, %rcx
imulq %rax, %rcx
movslq %ebp, %rax
imulq %rax, %rax
imulq $0x14, %rax, %rax
cmpq %rax, %rcx
setle 0x30(%rbx)
jg 0x783f
movq %rbx, %rdi
callq 0x7770
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
leaq 0x18(%rbx), %r12
movq %r14, %rdi
callq 0x376e
movq %r12, %rdi
callq 0x39b6
movq %rbx, %rdi
callq 0x38e4
movq %r15, %rdi
callq 0x2340
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x38(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rdi)
andq $0x0, 0x48(%rdi)
movups %xmm0, (%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
movl %esi, 0x50(%rdi)
andl $0x0, 0x54(%rdi)
movslq %esi, %rsi
movq %r14, %rdi
callq 0x87e2
movb %bpl, 0x30(%rbx)
testb %bpl, %bpl
je 0x78bb
movq %rbx, %rdi
callq 0x7770
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
leaq 0x18(%rbx), %r12
movq %r14, %rdi
callq 0x376e
movq %r12, %rdi
callq 0x39b6
movq %rbx, %rdi
callq 0x38e4
movq %r15, %rdi
callq 0x2340
nop
// File: /workspace/github_cpp_makefile_star2_O2/Laakeri[P]Triangulator/src/graph.cpp
// Function: Graph::Graph(std::set<std::pair<int, int>, std::less<std::pair<int, int>>, std::allocator<std::pair<int, int>>> const&)
Graph::Graph(const set<pair<int, int> >& es) {
	for (auto e : es) {
		vMap.push_back(e.F);
		vMap.push_back(e.S);
	}
	sort(vMap.begin(), vMap.end());
	vMap.erase(unique(vMap.begin(), vMap.end()), vMap.end());
	n = vMap.size();
	m = 0;
	g.resize(n);
	DENSE = denseG(n, es.size());
	if (DENSE) initMatrix();
	for (auto e : es) {
		e.F = lower_bound(vMap.begin(), vMap.end(), e.F) - vMap.begin();
		e.S = lower_bound(vMap.begin(), vMap.end(), e.S) - vMap.begin();
		addEdge(e.F, e.S);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x38(%rdi), %rax
movq %rax, 0x10(%rsp)
xorps %xmm0, %xmm0
andq $0x0, 0x48(%rdi)
movups %xmm0, 0x38(%rdi)
movups %xmm0, (%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
movq 0x18(%rsi), %rbp
leaq 0x8(%rsi), %r14
leaq 0xc(%rsp), %r12
leaq 0x8(%rsp), %r13
cmpq %r14, %rbp
je 0x7963
movq 0x20(%rbp), %rax
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x6402
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6402
movq %rbp, %rdi
callq 0x2260
movq %rax, %rbp
jmp 0x7932
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
movq 0x10(%rsp), %rbp
callq 0x8dde
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
callq 0x91de
movq 0x8(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x8818
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x2, %rax
movl %eax, 0x50(%rbx)
andl $0x0, 0x54(%rbx)
movslq %eax, %rsi
movq %rbp, %rdi
callq 0x87e2
movslq 0x50(%rbx), %rax
movslq 0x28(%r15), %rcx
movq %rax, %rdx
imulq %rax, %rdx
imulq %rax, %rdx
imulq %rcx, %rcx
imulq $0x14, %rcx, %rax
cmpq %rax, %rdx
setle 0x30(%rbx)
jg 0x79d8
movq %rbx, %rdi
callq 0x7770
movq 0x18(%r15), %r13
leaq 0xc(%rsp), %r15
leaq 0x8(%rsp), %r12
cmpq %r14, %r13
je 0x7a43
movq 0x20(%r13), %rax
movq %rax, 0x8(%rsp)
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
movq %r12, %rdx
callq 0x9294
movq (%rbx), %rdi
subq %rdi, %rax
shrq $0x2, %rax
movl %eax, 0x8(%rsp)
movq 0x8(%rbx), %rsi
movq %r15, %rdx
callq 0x9294
subq (%rbx), %rax
shrq $0x2, %rax
movl %eax, 0xc(%rsp)
movl 0x8(%rsp), %esi
movq %rbx, %rdi
movl %eax, %edx
callq 0x7a8e
movq %r13, %rdi
callq 0x2260
movq %rax, %r13
jmp 0x79e6
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7a5c
jmp 0x7a5c
jmp 0x7a5c
jmp 0x7a5c
jmp 0x7a5c
movq %rax, %r15
jmp 0x7a69
movq %rax, %r15
movq 0x10(%rsp), %rbp
leaq 0x18(%rbx), %r12
movq %rbp, %rdi
callq 0x376e
movq %r12, %rdi
callq 0x39b6
movq %rbx, %rdi
callq 0x38e4
movq %r15, %rdi
callq 0x2340
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, 0x4(%rsp)
movl %edx, (%rsp)
cmpb $0x0, 0x30(%rdi)
je 0x7acd
movslq %esi, %rax
movq 0x18(%rbx), %rcx
imulq $0x18, %rax, %rsi
movslq %edx, %rdx
movq (%rcx,%rsi), %rcx
movb $0x1, %sil
movb %sil, (%rcx,%rdx)
movq 0x18(%rbx), %rcx
imulq $0x18, %rdx, %rdx
movq (%rcx,%rdx), %rcx
movb %sil, (%rcx,%rax)
jmp 0x7ad0
movslq %esi, %rax
imulq $0x18, %rax, %rdi
addq 0x38(%rbx), %rdi
movq %rsp, %r14
movq %r14, %rsi
callq 0x6402
movslq (%r14), %rax
imulq $0x18, %rax, %rdi
addq 0x38(%rbx), %rdi
leaq 0x4(%rsp), %rsi
callq 0x6402
incl 0x54(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7cd6
movslq %esi, %rax
movq 0x18(%rdi), %rsi
imulq $0x18, %rax, %r8
movslq %edx, %rcx
movq (%rsi,%r8), %rdx
xorl %esi, %esi
movb %sil, (%rdx,%rcx)
movq 0x18(%rdi), %rdx
imulq $0x18, %rcx, %r8
movq (%rdx,%r8), %rdx
movb %sil, (%rdx,%rax)
jmp 0x7cdc
movslq %esi, %rax
movslq %edx, %rcx
movq 0x38(%rdi), %rdx
imulq $0x18, %rax, %rax
addq $-0x4, 0x8(%rdx,%rax)
imulq $0x18, %rcx, %rax
addq $-0x4, 0x8(%rdx,%rax)
decl 0x54(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/Laakeri[P]Triangulator/src/graph.cpp
// Function: Graph::remEdge(int, int)
void Graph::remEdge(int a, int b) {
	if (DENSE) {
		mat[a][b] = 0;
		mat[b][a] = 0;
	}
	for (size_t i = 0; i < g[a].size(); i++) {
		if (g[a][i] == b) {
			swap(g[a][i], g[a].back());
			g[a].pop_back();
			break;
		}
	}
	for (size_t i = 0; i < g[b].size(); i++) {
		if (g[b][i] == a) {
			swap(g[b][i], g[b].back());
			g[b].pop_back();
			break;
		}
	}
	m--;
}

// Assembly:
pushq %rbp
pushq %rbx
cmpb $0x0, 0x30(%rdi)
movslq %edx, %rax
movslq %esi, %r8
je 0x7d59
movq 0x18(%rdi), %rcx
imulq $0x18, %r8, %r9
movq (%rcx,%r9), %rcx
xorl %r9d, %r9d
movb %r9b, (%rcx,%rax)
movq 0x18(%rdi), %rcx
imulq $0x18, %rax, %r10
movq (%rcx,%r10), %rcx
movb %r9b, (%rcx,%r8)
movq 0x38(%rdi), %rcx
imulq $0x18, %r8, %r9
leaq (%rcx,%r9), %r8
movq (%rcx,%r9), %r10
movq 0x8(%rcx,%r9), %r9
movq %r9, %r11
subq %r10, %r11
sarq $0x2, %r11
xorl %ebx, %ebx
cmpq %rbx, %r11
je 0x7d9e
cmpl %edx, (%r10,%rbx,4)
je 0x7d8a
incq %rbx
jmp 0x7d7a
leaq -0x4(%r9), %r11
movl -0x4(%r9), %ebp
movl %ebp, (%r10,%rbx,4)
movl %edx, -0x4(%r9)
movq %r11, 0x8(%r8)
imulq $0x18, %rax, %r8
leaq (%rcx,%r8), %rax
movq (%rcx,%r8), %rdx
movq 0x8(%rcx,%r8), %rcx
movq %rcx, %r8
subq %rdx, %r8
sarq $0x2, %r8
xorl %r9d, %r9d
cmpq %r9, %r8
je 0x7ddf
cmpl %esi, (%rdx,%r9,4)
je 0x7dcc
incq %r9
jmp 0x7dbc
leaq -0x4(%rcx), %r8
movl -0x4(%rcx), %r10d
movl %r10d, (%rdx,%r9,4)
movl %esi, -0x4(%rcx)
movq %r8, 0x8(%rax)
decl 0x54(%rdi)
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
imulq $0x18, %rcx, %rax
movq (%r8,%rax), %rdx
movq 0x8(%r8,%rax), %r8
xorl %r9d, %r9d
cmpq %r8, %rdx
je 0x7e7c
movslq (%rdx), %r10
movq 0x38(%rdi), %r14
imulq $0x18, %r10, %r11
leaq (%r14,%r11), %rbx
movq (%r14,%r11), %r15
movq 0x8(%r14,%r11), %r14
movq %r14, %r12
subq %r15, %r12
sarq $0x2, %r12
xorl %r13d, %r13d
cmpq %r13, %r12
je 0x7e55
cmpl %esi, (%r15,%r13,4)
je 0x7e41
incq %r13
jmp 0x7e31
leaq -0x4(%r14), %r12
movl -0x4(%r14), %ebp
movl %ebp, (%r15,%r13,4)
movl %esi, -0x4(%r14)
movq %r12, 0x8(%rbx)
cmpb $0x1, 0x30(%rdi)
jne 0x7e73
movq 0x18(%rdi), %rbx
movq (%rbx,%rax), %rbx
movb %r9b, (%rbx,%r10)
movq 0x18(%rdi), %r10
movq (%r10,%r11), %r10
movb %r9b, (%r10,%rcx)
decl 0x54(%rdi)
addq $0x4, %rdx
jmp 0x7e07
movq 0x38(%rdi), %rcx
movq (%rcx,%rax), %rdx
cmpq %rdx, 0x8(%rcx,%rax)
je 0x7e92
addq %rax, %rcx
movq %rdx, 0x8(%rcx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movslq %esi, %rdx
movq 0x38(%rdi), %rax
movq %rdx, 0x10(%rsp)
imulq $0x18, %rdx, %rcx
movq (%rax,%rcx), %r15
movq %rcx, (%rsp)
movq 0x8(%rax,%rcx), %r13
cmpq %r13, %r15
je 0x7f6e
movslq (%r15), %r12
movl %ebp, 0x8(%rsp)
movl %r12d, 0xc(%rsp)
movq %rbx, %rdi
leaq 0x8(%rsp), %rsi
callq 0x92ce
movq 0x38(%r14), %rdx
imulq $0x18, %r12, %rax
leaq (%rdx,%rax), %rcx
movq (%rdx,%rax), %rsi
movq 0x8(%rdx,%rax), %rdx
movq %rdx, %rdi
subq %rsi, %rdi
sarq $0x2, %rdi
xorl %r8d, %r8d
cmpq %r8, %rdi
je 0x7f38
cmpl %ebp, (%rsi,%r8,4)
je 0x7f25
incq %r8
jmp 0x7f15
leaq -0x4(%rdx), %rdi
movl -0x4(%rdx), %r9d
movl %r9d, (%rsi,%r8,4)
movl %ebp, -0x4(%rdx)
movq %rdi, 0x8(%rcx)
cmpb $0x1, 0x30(%r14)
jne 0x7f61
movq 0x18(%r14), %rcx
movq (%rsp), %rdx
movq (%rcx,%rdx), %rcx
xorl %edx, %edx
movb %dl, (%rcx,%r12)
movq 0x18(%r14), %rcx
movq (%rcx,%rax), %rax
movq 0x10(%rsp), %rcx
movb %dl, (%rax,%rcx)
decl 0x54(%r14)
addq $0x4, %r15
jmp 0x7ed1
movq 0x38(%r14), %rax
movq (%rsp), %rdx
movq (%rax,%rdx), %rcx
cmpq %rcx, 0x8(%rax,%rdx)
je 0x7f88
addq %rdx, %rax
movq %rcx, 0x8(%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7fb8
movq 0x18(%rdi), %rcx
imulq $0x18, %rax, %rax
movslq %edx, %rdx
movq (%rcx,%rax), %rax
cmpb $0x1, (%rax,%rdx)
sete %al
retq
movq 0x38(%rdi), %r8
imulq $0x18, %rax, %rax
movq (%r8,%rax), %rdi
movq 0x8(%r8,%rax), %rcx
movq %rcx, %rax
subq %rdi, %rax
movslq %edx, %r9
imulq $0x18, %r9, %r10
movq (%r8,%r10), %r9
movq 0x8(%r8,%r10), %r8
movq %r8, %r10
subq %r9, %r10
cmpq %r10, %rax
jae 0x7fff
cmpq %rcx, %rdi
setne %al
je 0x8013
leaq 0x4(%rdi), %rsi
cmpl %edx, (%rdi)
movq %rsi, %rdi
jne 0x7fea
jmp 0x8013
cmpq %r8, %r9
setne %al
je 0x8013
leaq 0x4(%r9), %rcx
cmpl %esi, (%r9)
movq %rcx, %r9
jne 0x7fff
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x186f5(%rip), %rsi     # 0x20721
movq %rbx, %rdi
callq 0x2210
movl 0x50(%r14), %esi
movq %rax, %rdi
callq 0x2330
movq %rax, %rdi
callq 0x20e0
movl 0x50(%r14), %ecx
movq 0x38(%r14), %rax
xorl %edx, %edx
testl %ecx, %ecx
cmovlel %edx, %ecx
imulq $0x18, %rcx, %rsi
xorl %ecx, %ecx
cmpq %rdx, %rsi
je 0x8077
movq 0x8(%rax,%rdx), %rdi
subq (%rax,%rdx), %rdi
shrq $0x2, %rdi
addl %edi, %ecx
addq $0x18, %rdx
jmp 0x805d
testb $0x1, %cl
jne 0x812c
sarl %ecx
cmpl 0x54(%r14), %ecx
jne 0x814b
leaq 0x186d2(%rip), %rsi     # 0x20765
movq %rbx, %rdi
callq 0x2210
movl 0x54(%r14), %esi
movq %rax, %rdi
callq 0x2330
movq %rax, %rdi
callq 0x20e0
xorl %r15d, %r15d
leaq 0x19c74(%rip), %r12     # 0x21d2d
movq %r14, (%rsp)
movslq 0x50(%r14), %rax
cmpq %rax, %r15
jge 0x811d
movq 0x38(%r14), %rax
imulq $0x18, %r15, %rcx
movq (%rax,%rcx), %rbp
movq 0x8(%rax,%rcx), %r14
cmpq %r14, %rbp
je 0x8114
movslq (%rbp), %r13
cmpq %r13, %r15
jge 0x810e
movq %rbx, %rdi
movl %r15d, %esi
callq 0x2330
movq %rax, %rdi
movq %r12, %rsi
callq 0x2210
movq %rax, %rdi
movl %r13d, %esi
callq 0x2330
movq %rax, %rdi
callq 0x20e0
addq $0x4, %rbp
jmp 0x80d7
incq %r15
movq (%rsp), %r14
jmp 0x80bd
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x185f1(%rip), %rdi     # 0x20724
leaq 0x185f4(%rip), %rsi     # 0x2072e
leaq 0x185f7(%rip), %rcx     # 0x20738
movl $0xb1, %edx
callq 0x2150
leaq 0x18609(%rip), %rdi     # 0x2075b
leaq 0x185d5(%rip), %rsi     # 0x2072e
leaq 0x185d8(%rip), %rcx     # 0x20738
movl $0xb2, %edx
callq 0x2150
// File: /workspace/github_cpp_makefile_star2_O2/Laakeri[P]Triangulator/src/graph.cpp
// Function: Graph::hash() const
uint64_t Graph::hash() const {
	uint64_t ha = 0;
	vector<pair<int, int> > es;
	for (int i = 0; i < n; i++) {
		for (int nx : g[i]) {
			if (nx > i) {
				es.push_back({i, nx});
			}
		}
	}
	sort(es.begin(), es.end());
	for (auto e : es) {
		ha *= 1000003ll;
		ha += (uint64_t)e.F;
		ha *= 10007ll;
		ha += (uint64_t)e.S;
	}
	return ha;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
andq $0x0, 0x10(%r14)
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
xorl %r12d, %r12d
leaq 0x8(%rsp), %r15
movslq 0x50(%rbx), %rax
cmpq %rax, %r12
jge 0x81db
movq 0x38(%rbx), %rax
imulq $0x18, %r12, %rcx
movq (%rax,%rcx), %r13
movq 0x8(%rax,%rcx), %rbp
cmpq %rbp, %r13
je 0x81d6
movslq (%r13), %rax
cmpq %rax, %r12
jge 0x81d0
movl %r12d, 0x8(%rsp)
movl %eax, 0xc(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x92ce
addq $0x4, %r13
jmp 0x81ae
incq %r12
jmp 0x8194
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x93cc
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
xorl %ebx, %ebx
cmpq %rcx, %rax
je 0x821c
movslq (%rax), %rdx
movslq 0x4(%rax), %rsi
imulq $0xf4243, %rbx, %rdi    # imm = 0xF4243
addq %rdx, %rdi
imulq $0x2717, %rdi, %rbx     # imm = 0x2717
addq %rsi, %rbx
addq $0x8, %rax
jmp 0x81f6
leaq 0x10(%rsp), %rdi
callq 0x3bfe
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x823a
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3bfe
movq %rbx, %rdi
callq 0x2340
nop
// File: /workspace/github_cpp_makefile_star2_O2/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)
je 0x83ac
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rdx, %rbx
movq %rdi, %r14
movl $0x1, (%rcx,%rax,4)
movq 0x38(%rdi), %rcx
imulq $0x18, %rax, %rax
movq (%rcx,%rax), %r15
movq 0x8(%rcx,%rax), %r12
cmpq %r12, %r15
je 0x83a0
movl (%r15), %esi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x838c
addq $0x4, %r15
jmp 0x83ca
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movslq 0x50(%rdi), %rsi
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x8852
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x838c
movslq 0x50(%rbx), %rax
movq (%r14), %rcx
testl %eax, %eax
movl $0x0, %edx
cmovgl %eax, %edx
movq %r15, %rsi
cmpq %r15, %rdx
je 0x8439
leaq 0x1(%rsi), %r15
cmpl $0x0, (%rcx,%rsi,4)
jne 0x8427
cmpq %rax, %rsi
setge %bl
leaq 0x8(%rsp), %rdi
callq 0x38e4
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x8852
xorl %r15d, %r15d
pushq $0x2
popq %r12
xorl %ebp, %ebp
movslq 0x50(%rbx), %rax
cmpq %rax, %r15
jge 0x84c1
movq 0x8(%rsp), %rax
cmpl $0x0, (%rax,%r15,4)
jne 0x84b8
movq 0x38(%rbx), %rax
movq (%rax,%r12,4), %rcx
cmpq -0x8(%rax,%r12,4), %rcx
je 0x84b8
incl %ebp
movq %rbx, %rdi
movl %r15d, %esi
movq %r14, %rdx
callq 0x838c
incq %r15
addq $0x6, %r12
jmp 0x8484
cmpl $0x2, %ebp
setl %bl
leaq 0x8(%rsp), %rdi
callq 0x38e4
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movslq 0x50(%rdi), %rsi
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x8852
xorl %r15d, %r15d
pushq $0x2
popq %r12
xorl %ebp, %ebp
movslq 0x50(%rbx), %rax
cmpq %rax, %r15
jge 0x854b
movq 0x8(%rsp), %rax
cmpl $0x0, (%rax,%r15,4)
jne 0x8542
movq 0x38(%rbx), %rax
movq (%rax,%r12,4), %rcx
cmpq -0x8(%rax,%r12,4), %rcx
je 0x8542
incl %ebp
movq %rbx, %rdi
movl %r15d, %esi
movq %r14, %rdx
callq 0x838c
incq %r15
addq $0x6, %r12
jmp 0x850e
subl %ebp, %eax
cmpl %eax, 0x54(%rbx)
setg %bl
leaq 0x8(%rsp), %rdi
callq 0x38e4
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %rdx
movl %esi, (%rdx)
movq (%rdi), %rdi
movq 0x8(%rbx), %rsi
callq 0x9985
movq (%rbx), %rdx
movq 0x8(%rbx), %rsi
subq %rdx, %rax
movq %rax, %rcx
shrq $0x2, %rcx
subq %rdx, %rsi
shrq $0x2, %rsi
cmpl %esi, %ecx
jge 0x85bc
shlq $0x1e, %rax
sarq $0x1e, %rax
movl (%rdx,%rax), %eax
cmpl 0xc(%rsp), %eax
jne 0x85db
movl %ecx, %eax
addq $0x10, %rsp
popq %rbx
retq
leaq 0x181a5(%rip), %rdi     # 0x20768
leaq 0x18164(%rip), %rsi     # 0x2072e
leaq 0x181ad(%rip), %rcx     # 0x2077e
movl $0x10c, %edx            # imm = 0x10C
callq 0x2150
leaq 0x181ba(%rip), %rdi     # 0x2079c
leaq 0x18145(%rip), %rsi     # 0x2072e
leaq 0x1818e(%rip), %rcx     # 0x2077e
movl $0x10d, %edx            # imm = 0x10D
callq 0x2150
// File: /workspace/github_cpp_makefile_star2_O2/Laakeri[P]Triangulator/src/graph.cpp
// Function: Graph::mapInto(std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>> const&) const
vector<vector<int> > Graph::mapInto(const vector<vector<int> >& vs) const {
	vector<vector<int> > ret;
	for (auto t : vs) {
		vector<int> r;
		for (int x : t) {
			int id = lower_bound(vMap.begin(), vMap.end(), x) - vMap.begin();
			if (id >= (int)vMap.size()) continue;
			if (vMap[id] != x) continue;
			r.push_back(id);
		}
		sort(r.begin(), r.end());
		if (r.size() > 0) ret.push_back(r);
	}
	sort(ret.begin(), ret.end());
	ret.erase(unique(ret.begin(), ret.end()), ret.end());
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movq %rdi, 0x10(%rsp)
movups %xmm0, (%rdi)
movq (%rdx), %rsi
movq 0x8(%rdx), %rax
movq %rax, 0x40(%rsp)
leaq 0x50(%rsp), %rbx
leaq 0x20(%rsp), %r13
leaq 0xc(%rsp), %rbp
cmpq 0x40(%rsp), %rsi
je 0x8709
movq %rbx, %r15
movq %rbx, %rdi
movq %rsi, 0x48(%rsp)
callq 0x3896
andq $0x0, 0x30(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movq 0x50(%rsp), %r12
movq 0x58(%rsp), %rbx
cmpq %rbx, %r12
je 0x86c0
movl (%r12), %eax
movl %eax, 0xc(%rsp)
movq (%r14), %rdi
movq 0x8(%r14), %rsi
movq %rbp, %rdx
callq 0x9985
movq (%r14), %rcx
subq %rcx, %rax
shrq $0x2, %rax
movl %eax, 0x1c(%rsp)
movq 0x8(%r14), %rdx
subq %rcx, %rdx
shrq $0x2, %rdx
cmpl %edx, %eax
jge 0x86ba
cltq
movl (%rcx,%rax,4), %eax
cmpl 0xc(%rsp), %eax
jne 0x86ba
movq %r13, %rdi
leaq 0x1c(%rsp), %rsi
callq 0x6402
addq $0x4, %r12
jmp 0x8669
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x8dde
movq 0x28(%rsp), %rax
cmpq 0x20(%rsp), %rax
je 0x86e8
movq 0x10(%rsp), %rdi
movq %r13, %rsi
callq 0x88a4
movq %r13, %rdi
callq 0x38e4
movq %r15, %rbx
movq %r15, %rdi
callq 0x38e4
movq 0x48(%rsp), %rsi
addq $0x18, %rsi
jmp 0x8636
movq 0x10(%rsp), %rbx
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
callq 0x9ad1
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
callq 0xa26e
movq 0x8(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x88d0
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x874d
jmp 0x874d
jmp 0x874d
movq %rax, %rbx
jmp 0x876d
jmp 0x8756
jmp 0x8756
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x38e4
leaq 0x50(%rsp), %rdi
callq 0x38e4
movq 0x10(%rsp), %rdi
callq 0x376e
movq %rbx, %rdi
callq 0x2340
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2190
leaq 0x18(%rsp), %rdi
movq %rbx, %rsi
callq 0x21f0
xorl %ebp, %ebp
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2290
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0xcf21
incl %ebp
jmp 0xcf04
leaq 0x8(%rsp), %rdi
callq 0x21b0
movl %ebp, %eax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %rbp
retq
jmp 0xcf3b
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x21b0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O2/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:
movslq %edi, %rax
leaq 0x2cd547(%rip), %rcx    # 0x2dbbe0
cmpl $0x0, (%rcx,%rax,4)
je 0xe6a0
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movl %edi, %ebp
leaq 0x2cd526(%rip), %rcx    # 0x2dbbe0
movl $0x1, (%rcx,%rax,4)
movq %rsi, 0x10(%rsp)
movq 0x38(%rsi), %rcx
imulq $0x18, %rax, %rax
movq (%rcx,%rax), %r14
movq %rax, 0x8(%rsp)
movq 0x8(%rcx,%rax), %r12
leaq 0x2fe23d(%rip), %r13    # 0x30c920
movq %rsp, %r15
cmpq %r12, %r14
je 0xe720
movl (%r14), %eax
movslq %eax, %rcx
cmpl $0x0, (%r13,%rcx,4)
je 0xe70d
movl %ebp, (%rsp)
movl %eax, 0x4(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x92ce
jmp 0xe71a
leaq 0x2cd4cc(%rip), %rdx    # 0x2dbbe0
cmpl $0x0, (%rdx,%rcx,4)
je 0xe6f9
addq $0x4, %r14
jmp 0xe6e6
movq 0x10(%rsp), %r12
movq 0x38(%r12), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx), %r14
movq 0x8(%rax,%rcx), %r15
cmpq %r15, %r14
je 0xe766
movslq (%r14), %rdi
cmpl $0x0, (%r13,%rdi,4)
jne 0xe760
leaq 0x2cd491(%rip), %rax    # 0x2dbbe0
cmpl $0x0, (%rax,%rdi,4)
jne 0xe760
movq %r12, %rsi
movq %rbx, %rdx
callq 0xe68f
addq $0x4, %r14
jmp 0xe738
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq