LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: thierry7100[P]CutOptim/include/cxxopts.hpp
// Function: cxxopts::ParseResult::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
const OptionValue&
    operator[](const std::string& option) const
    {
      auto iter = m_options->find(option);

      if (iter == m_options->end())
      {
        throw option_not_present_exception(option);
      }

      auto riter = m_results.find(iter->second);

      return riter->second;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x1c780
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x23290
movq -0x40(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0x1c780
movq %rax, %rdi
callq 0x232f0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x232c0
testb $0x1, %al
jne 0x11035
jmp 0x11082
movl $0x28, %edi
callq 0x92a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rsi
callq 0x29810
jmp 0x11054
movq -0x48(%rbp), %rdi
leaq 0xa60c9(%rip), %rsi     # 0xb7128
leaq 0x1890a(%rip), %rdx     # 0x29970
callq 0x9900
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x9410
jmp 0x110be
movq -0x40(%rbp), %rax
addq $0x68, %rax
movq %rax, -0x50(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x234a0
movq -0x50(%rbp), %rdi
movq %rax, %rsi
addq $0x20, %rsi
callq 0x26b80
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x26bb0
addq $0x10, %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x9960
nopw (%rax,%rax)
// File: thierry7100[P]CutOptim/include/cxxopts.hpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const& cxxopts::OptionValue::as<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>() const
const T&
    as() const
    {
      if (m_value == nullptr) {
        throw std::domain_error("No value");
      }

#ifdef CXXOPTS_NO_RTTI
      return static_cast<const values::standard_value<T>&>(*m_value).get();
#else
      return dynamic_cast<const values::standard_value<T>&>(*m_value).get();
#endif
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x24350
testb $0x1, %al
jne 0x110f3
jmp 0x11143
movl $0x10, %edi
callq 0x92a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
leaq 0x72069(%rip), %rsi     # 0x83177
callq 0x93a0
jmp 0x11115
movq -0x28(%rbp), %rdi
movq 0xa6e30(%rip), %rsi     # 0xb7f50
movq 0xa6e49(%rip), %rdx     # 0xb7f70
callq 0x9900
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x9410
jmp 0x11184
movq -0x20(%rbp), %rdi
callq 0x59bc0
movq %rax, %rdi
leaq 0xa623a(%rip), %rsi     # 0xb7390
leaq 0xa6273(%rip), %rdx     # 0xb73d0
xorl %eax, %eax
movl %eax, %ecx
callq 0x9620
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x11175
callq 0x9a20
movq -0x30(%rbp), %rdi
callq 0x59bf0
addq $0x30, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0x9960
nopl (%rax)
// File: thierry7100[P]CutOptim/include/cxxopts.hpp
// Function: cxxopts::values::abstract_value<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::abstract_value(cxxopts::values::abstract_value<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&)
abstract_value(const abstract_value& rhs)
      {
        if (rhs.m_result)
        {
          m_result = std::make_shared<T>();
          m_store = m_result.get();
        }
        else
        {
          m_store = rhs.m_store;
        }

        m_default = rhs.m_default;
        m_implicit = rhs.m_implicit;
        m_default_value = rhs.m_default_value;
        m_implicit_value = rhs.m_implicit_value;
      }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x487f0
movq -0x40(%rbp), %rdi
leaq 0x6dcf0(%rip), %rax     # 0xb73e8
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x18, %rdi
movq %rdi, -0x50(%rbp)
callq 0x49820
movq -0x40(%rbp), %rdi
movb $0x0, 0x30(%rdi)
movb $0x0, 0x31(%rdi)
addq $0x38, %rdi
movq %rdi, -0x48(%rbp)
callq 0x9760
movq -0x40(%rbp), %rdi
addq $0x58, %rdi
movq %rdi, -0x38(%rbp)
callq 0x9760
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0x49840
testb $0x1, %al
jne 0x49749
jmp 0x497ba
leaq -0x20(%rbp), %rdi
callq 0x48830
jmp 0x49754
movq -0x40(%rbp), %rdi
addq $0x18, %rdi
leaq -0x20(%rbp), %rsi
callq 0x49860
leaq -0x20(%rbp), %rdi
callq 0x492f0
movq -0x40(%rbp), %rdi
addq $0x18, %rdi
callq 0x488a0
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x28(%rax)
jmp 0x497ca
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x9a98
movq -0x48(%rbp), %rdi
callq 0x9a98
movq -0x50(%rbp), %rdi
callq 0x492f0
movq -0x40(%rbp), %rdi
callq 0x48950
jmp 0x49816
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rcx
movq %rcx, 0x28(%rax)
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rax
movb 0x30(%rax), %al
andb $0x1, %al
movb %al, 0x30(%rdi)
movq -0x10(%rbp), %rax
movb 0x31(%rax), %al
andb $0x1, %al
movb %al, 0x31(%rdi)
movq -0x10(%rbp), %rsi
addq $0x38, %rsi
addq $0x38, %rdi
callq 0x9070
jmp 0x497f9
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x58, %rsi
addq $0x58, %rdi
callq 0x9070
jmp 0x49810
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x9960
nop
// File: thierry7100[P]CutOptim/include/cxxopts.hpp
// Function: cxxopts::values::standard_value<bool>::set_default_and_implicit()
void
      set_default_and_implicit()
      {
        m_default = true;
        m_default_value = "false";
        m_implicit = true;
        m_implicit_value = "true";
      }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movb $0x1, 0x30(%rdi)
addq $0x38, %rdi
leaq 0x35a63(%rip), %rsi     # 0x824e6
callq 0x9750
movq -0x10(%rbp), %rdi
movb $0x1, 0x31(%rdi)
addq $0x58, %rdi
leaq 0x359f7(%rip), %rsi     # 0x82492
callq 0x9750
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: thierry7100[P]CutOptim/include/cxxopts.hpp
// Function: void cxxopts::values::stringstream_parser<double>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, double&)
void stringstream_parser(const std::string& text, T& value)
    {
      std::stringstream in(text);
      in >> value;
      if (!in) {
        throw argument_incorrect_type(text);
      }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1b8(%rbp)
movl $0x10, %edi
movl $0x8, %esi
callq 0x57240
movq -0x1b8(%rbp), %rsi
movl %eax, %edx
leaq -0x198(%rbp), %rdi
movq %rdi, -0x1b0(%rbp)
callq 0x9850
movq -0x1b0(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x9480
jmp 0x5716b
movq -0x198(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x198(%rbp,%rax), %rdi
callq 0x9260
movb %al, -0x1b9(%rbp)
jmp 0x5718b
movb -0x1b9(%rbp), %al
testb $0x1, %al
jne 0x57197
jmp 0x57209
movl $0x28, %edi
callq 0x92a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x1c8(%rbp)
movq -0x8(%rbp), %rsi
callq 0x4e010
jmp 0x571b9
movq -0x1c8(%rbp), %rdi
leaq 0x606e1(%rip), %rsi     # 0xb78a8
leaq -0x905e(%rip), %rdx     # 0x4e170
callq 0x9900
jmp 0x57236
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
jmp 0x5721e
movq -0x1c8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
callq 0x9410
jmp 0x5721e
leaq -0x198(%rbp), %rdi
callq 0x9420
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
leaq -0x198(%rbp), %rdi
callq 0x9420
movq -0x1a0(%rbp), %rdi
callq 0x9960
nopw %cs:(%rax,%rax)
// File: thierry7100[P]CutOptim/include/cxxopts.hpp
// Function: void cxxopts::values::detail::SignedCheck<int, true>::operator()<unsigned int>(bool, unsigned int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void
        operator()(bool negative, U u, const std::string& text)
        {
          if (negative)
          {
            if (u > static_cast<U>(-(std::numeric_limits<T>::min)()))
            {
              throw argument_incorrect_type(text);
            }
          }
          else
          {
            if (u > static_cast<U>((std::numeric_limits<T>::max)()))
            {
              throw argument_incorrect_type(text);
            }
          }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
testb $0x1, -0x9(%rbp)
je 0x59908
movl -0x10(%rbp), %eax
movl %eax, -0x28(%rbp)
callq 0x59980
movl %eax, %edx
movl -0x28(%rbp), %eax
xorl %ecx, %ecx
subl %edx, %ecx
cmpl %ecx, %eax
jbe 0x59906
movl $0x28, %edi
callq 0x92a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rsi
callq 0x4e010
jmp 0x598d8
movq -0x30(%rbp), %rdi
leaq 0x5dfc5(%rip), %rsi     # 0xb78a8
leaq -0xb77a(%rip), %rdx     # 0x4e170
callq 0x9900
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x9410
jmp 0x59971
jmp 0x5996b
movl -0x10(%rbp), %eax
movl %eax, -0x34(%rbp)
callq 0x59990
movl %eax, %ecx
movl -0x34(%rbp), %eax
cmpl %ecx, %eax
jbe 0x59969
movl $0x28, %edi
callq 0x92a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rsi
callq 0x4e010
jmp 0x5993b
movq -0x40(%rbp), %rdi
leaq 0x5df62(%rip), %rsi     # 0xb78a8
leaq -0xb7dd(%rip), %rdx     # 0x4e170
callq 0x9900
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x9410
jmp 0x59971
jmp 0x5996b
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x9960
nopw (%rax,%rax)
// File: thierry7100[P]CutOptim/src/CachePosition.cpp
// Function: CachePosition::CachePosition(int, int, int)
CachePosition::CachePosition(int numVertex, int num_rot, int numPlacedVertex)
{
    sizeCacheEntry1 = numVertex;                           //  Used later to compute offsets for iPlacedVertex so multiply by numVertex
    sizeCacheEntry2 = numVertex*numPlacedVertex;           //  Used later to compute offsets for idxRot so multiply by numVertex*numPlacedVertex
    currentIdxCache = -1;                                  //  Init state, nothing in cache
    memCache = numPlacedVertex * num_rot * numVertex;      //  Memory claim
    CachePlaced = new Polygon *[memCache];
    //  The fake value  0xCACACACACACACA is impossible as a pointer
    //  It will be used to detect entries which are not yet processed.
    memset(CachePlaced, 0xCA, memCache*sizeof(Polygon *));    //  Init all entries, such as impossible !
    FixedPerRot = new int[num_rot];
    memset(FixedPerRot, -1, num_rot*sizeof(int));          //  Init all entries, such as not already computed !
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x5ddd4(%rip), %rcx     # 0xb7c68
addq $0x10, %rcx
movq %rcx, (%rax)
movslq -0xc(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl -0xc(%rbp), %ecx
imull -0x14(%rbp), %ecx
movslq %ecx, %rcx
movq %rcx, 0x10(%rax)
movl $0xffffffff, 0x20(%rax) # imm = 0xFFFFFFFF
movl -0x14(%rbp), %ecx
imull -0x10(%rbp), %ecx
imull -0xc(%rbp), %ecx
movslq %ecx, %rcx
movq %rcx, 0x18(%rax)
movq 0x18(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x9050
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
movq 0x28(%rax), %rdi
movq 0x18(%rax), %rdx
shlq $0x3, %rdx
movl $0xca, %esi
callq 0x92f0
movslq -0x10(%rbp), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x9050
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x30(%rax)
movq 0x30(%rax), %rdi
movslq -0x10(%rbp), %rdx
shlq $0x2, %rdx
movl $0xff, %esi
callq 0x92f0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: thierry7100[P]CutOptim/src/CachePosition.cpp
// Function: CachePosition::~CachePosition()
CachePosition::~CachePosition()
{
    for ( int i = 0; i < currentIdxCache; i++ )
    {
        uint64_t val = (uint64_t )CachePlaced[i];       //  default value, skip, DO NOT try to free this fake memory pointer
        if ( val == 0xCACACACACACACACA )
            continue;
        if ( CachePlaced[i] != NULL) delete CachePlaced[i];
    }
    delete [] CachePlaced;
    delete [] FixedPerRot;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x5dced(%rip), %rcx     # 0xb7c68
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x0, -0xc(%rbp)
movq -0x20(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x20(%rcx), %eax
jge 0x5a001
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movabsq $-0x3535353535353536, %rax # imm = 0xCACACACACACACACA
cmpq %rax, -0x18(%rbp)
jne 0x59fbb
jmp 0x59ff6
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0xc(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x59ff4
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x59ff2
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x59ff4
jmp 0x59ff6
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x59f89
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x5a01c
movq -0x30(%rbp), %rdi
callq 0x96f0
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x5a037
movq -0x38(%rbp), %rdi
callq 0x96f0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: thierry7100[P]CutOptim/src/CachePosition.cpp
// Function: CachePosition::isOKPlaced(int, int, int, Polygon**)
int CachePosition::isOKPlaced(int iVertex, int iRot, int iPlacedVertex, Polygon **PlacedPoly)
{
int idx = iRot * sizeCacheEntry2 + iPlacedVertex * sizeCacheEntry1 + iVertex;

    if ( idx > currentIdxCache )
        return 0;       //  Not yet computed, return don't know
    if ( iPlacedVertex > FixedPerRot[iRot])
        return 0;       //  Not yet computed
    uint64_t val = (uint64_t )CachePlaced[idx];
    if ( val == 0xCACACACACACACACA )            //  Check if default value (not yet processed) ?
    {
        return 0;           //  If so, return don't know
    }
    if ( CachePlaced[idx] != NULL )             //  Value not null, cache is OK
    {
        *PlacedPoly = CachePlaced[idx];         //  Update pointer to polygon to avoid recompute
        return FixedPerRot[iRot] + 1;           //  Return positive value
    }
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x40(%rbp)
movslq -0x18(%rbp), %rax
imulq 0x10(%rcx), %rax
movslq -0x1c(%rbp), %rdx
imulq 0x8(%rcx), %rdx
addq %rdx, %rax
movslq -0x14(%rbp), %rdx
addq %rdx, %rax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl 0x20(%rcx), %eax
jle 0x5a0c0
movl $0x0, -0x4(%rbp)
jmp 0x5a14e
movq -0x40(%rbp), %rcx
movl -0x1c(%rbp), %eax
movq 0x30(%rcx), %rcx
movslq -0x18(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jle 0x5a0dd
movl $0x0, -0x4(%rbp)
jmp 0x5a14e
movq -0x40(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
movabsq $-0x3535353535353536, %rax # imm = 0xCACACACACACACACA
cmpq %rax, -0x38(%rbp)
jne 0x5a10a
movl $0x0, -0x4(%rbp)
jmp 0x5a14e
movq -0x40(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x2c(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x5a147
movq -0x40(%rbp), %rax
movq 0x28(%rax), %rcx
movslq -0x2c(%rbp), %rdx
movq (%rcx,%rdx,8), %rdx
movq -0x28(%rbp), %rcx
movq %rdx, (%rcx)
movq 0x30(%rax), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x5a14e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: thierry7100[P]CutOptim/src/CachePosition.cpp
// Function: CachePosition::addOKPlaced(int, int, int, Polygon*)
void CachePosition::addOKPlaced(int iVertex, int iRot, int iPlacedVertex, Polygon *Poly)
{
    if ( iPlacedVertex > FixedPerRot[iRot] )
        FixedPerRot[iRot] = iPlacedVertex;
    int idx = iRot * sizeCacheEntry2 + iPlacedVertex * sizeCacheEntry1 + iVertex;
    if ( currentIdxCache < idx)
        currentIdxCache = idx;
    CachePlaced[idx] = Poly;
    if ( Poly != NULL )
    {
        Poly->TypePoly = CachedPoly;
        nbCreatedCachedPoly++;
        nbCachedPoly++;
        nbTranslatedPoly--;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %r8, -0x20(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movl -0x14(%rbp), %eax
movq 0x30(%rcx), %rcx
movslq -0x10(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jle 0x5a19f
movq -0x30(%rbp), %rax
movl -0x14(%rbp), %edx
movq 0x30(%rax), %rax
movslq -0x10(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x30(%rbp), %rax
movslq -0x10(%rbp), %rcx
imulq 0x10(%rax), %rcx
movslq -0x14(%rbp), %rdx
imulq 0x8(%rax), %rdx
addq %rdx, %rcx
movslq -0xc(%rbp), %rdx
addq %rdx, %rcx
movl %ecx, -0x24(%rbp)
movl 0x20(%rax), %eax
cmpl -0x24(%rbp), %eax
jge 0x5a1d4
movq -0x30(%rbp), %rax
movl -0x24(%rbp), %ecx
movl %ecx, 0x20(%rax)
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rdx
movq 0x28(%rax), %rax
movslq -0x24(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
cmpq $0x0, -0x20(%rbp)
je 0x5a242
movq -0x20(%rbp), %rax
movl $0x5, 0xc(%rax)
leaq 0x5e9a7(%rip), %rax     # 0xb8ba8
movq (%rax), %rcx
addq $0x1, %rcx
leaq 0x5e999(%rip), %rax     # 0xb8ba8
movq %rcx, (%rax)
leaq 0x5e95f(%rip), %rax     # 0xb8b78
movq (%rax), %rcx
addq $0x1, %rcx
leaq 0x5e951(%rip), %rax     # 0xb8b78
movq %rcx, (%rax)
leaq 0x5e937(%rip), %rax     # 0xb8b68
movq (%rax), %rcx
addq $-0x1, %rcx
leaq 0x5e929(%rip), %rax     # 0xb8b68
movq %rcx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: thierry7100[P]CutOptim/src/CachePosition.cpp
// Function: CachePosition::isOKPlacedFreeRot(int, int, int, Polygon**)
int CachePosition::isOKPlacedFreeRot(int iVertex, int iRot, int iPlacedVertex, Polygon **PlacedPoly)
{
int idx = (iPlacedVertex * sizeCacheEntry1 + iVertex)*4 + iRot;

    if ( idx > currentIdxCache )
        return 0;       //  Not yet computed
    if ( CachePlaced[idx] != NULL )
    {
        *PlacedPoly = CachePlaced[idx];
        return 1;
    }
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x38(%rbp)
movslq -0x1c(%rbp), %rax
imulq 0x8(%rcx), %rax
movslq -0x14(%rbp), %rdx
addq %rdx, %rax
shlq $0x2, %rax
movslq -0x18(%rbp), %rdx
addq %rdx, %rax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl 0x20(%rcx), %eax
jle 0x5a29c
movl $0x0, -0x4(%rbp)
jmp 0x5a2d6
movq -0x38(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x2c(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x5a2cf
movq -0x38(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x5a2d6
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: thierry7100[P]CutOptim/src/CachePosition.cpp
// Function: CachePosition::addOKPlacedFreeRot(int, int, int, Polygon*)
void CachePosition::addOKPlacedFreeRot(int iVertex, int iRot, int iPlacedVertex, Polygon *Poly)
{
int idx = ( iPlacedVertex * sizeCacheEntry1 + iVertex) * 4 + iRot;
    if ( currentIdxCache < idx)
        currentIdxCache = idx;
    CachePlaced[idx] = Poly;
    if ( Poly != NULL )
    {
        Poly->TypePoly = CachedPoly;
        nbCreatedCachedPoly++;
        nbCachedPoly++;
        nbTranslatedPoly--;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %r8, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movslq -0x14(%rbp), %rcx
imulq 0x8(%rax), %rcx
movslq -0xc(%rbp), %rdx
addq %rdx, %rcx
shlq $0x2, %rcx
movslq -0x10(%rbp), %rdx
addq %rdx, %rcx
movl %ecx, -0x24(%rbp)
movl 0x20(%rax), %eax
cmpl -0x24(%rbp), %eax
jge 0x5a32d
movq -0x30(%rbp), %rax
movl -0x24(%rbp), %ecx
movl %ecx, 0x20(%rax)
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rdx
movq 0x28(%rax), %rax
movslq -0x24(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
cmpq $0x0, -0x20(%rbp)
je 0x5a39b
movq -0x20(%rbp), %rax
movl $0x5, 0xc(%rax)
leaq 0x5e84e(%rip), %rax     # 0xb8ba8
movq (%rax), %rcx
addq $0x1, %rcx
leaq 0x5e840(%rip), %rax     # 0xb8ba8
movq %rcx, (%rax)
leaq 0x5e806(%rip), %rax     # 0xb8b78
movq (%rax), %rcx
addq $0x1, %rcx
leaq 0x5e7f8(%rip), %rax     # 0xb8b78
movq %rcx, (%rax)
leaq 0x5e7de(%rip), %rax     # 0xb8b68
movq (%rax), %rcx
addq $-0x1, %rcx
leaq 0x5e7d0(%rip), %rax     # 0xb8b68
movq %rcx, (%rax)
popq %rbp
retq
nopl (%rax)
// File: thierry7100[P]CutOptim/src/ConvexHull.cpp
// Function: CombineHull(std::vector<Point, std::allocator<Point>> const&, std::vector<Point, std::allocator<Point>> const&)
vector<Point> CombineHull(const vector<Point> &points_1, const vector<Point> &points_2)
{
	vector<Point> newPoints = points_1;
	newPoints.insert (newPoints.end(), points_2.begin(), points_2.end());
	std::sort(newPoints.begin(), newPoints.end());
	return makeConvexHullPresorted(newPoints);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x5adf0
movq -0x88(%rbp), %rdi
callq 0x5b350
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x5b380
movq -0x18(%rbp), %rdi
callq 0x5af00
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5af30
movq -0x88(%rbp), %rdi
movq %rax, -0x50(%rbp)
movq -0x38(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq -0x50(%rbp), %rcx
callq 0x5b2a0
movq %rax, -0x80(%rbp)
jmp 0x5a981
movq -0x80(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x5b490
movq -0xa0(%rbp), %rdi
movq %rax, -0x70(%rbp)
callq 0x5b350
movq %rax, -0x78(%rbp)
movq -0x70(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x5b450
jmp 0x5a9bc
movq -0x98(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x5a3a0
jmp 0x5a9ce
leaq -0x30(%rbp), %rdi
callq 0x5b3f0
movq -0x90(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5b3f0
movq -0x58(%rbp), %rdi
callq 0x9960
nopw %cs:(%rax,%rax)
// File: thierry7100[P]CutOptim/src/ConvexHull.cpp
// Function: HullArea(std::vector<Point, std::allocator<Point>> const&)
double HullArea(const vector<Point> &points)
{
double A = 0.0;
int n = points.size();

    if ( n < 3) return 0.0;
    for (int i = 0; i < n - 1; i++)
    {
        A += points[i].x*points[i+1].y - points[i+1].x*points[i].y;
    }
    //  Then close the polygon, last point is the first one.
    A += points[n-1].x*points[0].y - points[0].x*points[n-1].y;
    A = fabs(A);
	return A/2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5add0
movl %eax, -0x1c(%rbp)
cmpl $0x3, -0x1c(%rbp)
jge 0x5aa43
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x5abc2
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x5ab00
movq -0x10(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0x5b4c0
movsd (%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x5b4c0
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x5b4c0
movsd (%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0x5b4c0
movsd -0x38(%rbp), %xmm1
movsd -0x30(%rbp), %xmm0
movsd -0x28(%rbp), %xmm2
mulsd 0x8(%rax), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x5aa4a
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x5b4c0
movsd (%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5b4c0
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5b4c0
movsd (%rax), %xmm0
movsd %xmm0, -0x50(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x5b4c0
movsd -0x50(%rbp), %xmm1
movsd -0x48(%rbp), %xmm0
movsd -0x40(%rbp), %xmm2
mulsd 0x8(%rax), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
movaps 0x2950d(%rip), %xmm1    # 0x840b0
pand %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
movsd 0x294e7(%rip), %xmm1    # 0x840a0
divsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: thierry7100[P]CutOptim/src/ConvexHull.cpp
// Function: Hull2BoundingBox(std::vector<Point, std::allocator<Point>> const&)
Rectangle Hull2BoundingBox(const vector<Point> &points)
{
double xmin, xmax, ymin, ymax;
int n = points.size();
Rectangle BBox;

    xmax = xmin = points[0].x;
    ymax = ymin = points[0].y;
    for (int i = 1; i < n - 1; i++)
    {
        xmin = fmin(xmin, points[i].x);
        ymin = fmin(ymin, points[i].y);
        xmax = fmax(xmax, points[i].x);
        ymax = fmax(ymax, points[i].y);
    }
    BBox.A = Point(xmin, ymin);
    BBox.B = Point(xmax, ymax);
	return BBox;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, -0x60(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5add0
movq -0x58(%rbp), %rdi
movl %eax, -0x2c(%rbp)
callq 0x5b4e0
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5b4c0
movsd (%rax), %xmm0
movsd %xmm0, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5b4c0
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd %xmm0, -0x28(%rbp)
movl $0x1, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl -0x2c(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x5ad67
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x80(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x30(%rbp), %rsi
callq 0x5b4c0
movsd -0x80(%rbp), %xmm3
movsd (%rax), %xmm2
movaps %xmm2, %xmm4
movaps %xmm3, %xmm0
cmpunordsd %xmm0, %xmm0
movaps %xmm0, %xmm1
pand %xmm4, %xmm1
minsd %xmm3, %xmm2
pandn %xmm2, %xmm0
por %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x78(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x30(%rbp), %rsi
callq 0x5b4c0
movsd -0x78(%rbp), %xmm3
movsd 0x8(%rax), %xmm2
movaps %xmm2, %xmm4
movaps %xmm3, %xmm0
cmpunordsd %xmm0, %xmm0
movaps %xmm0, %xmm1
pand %xmm4, %xmm1
minsd %xmm3, %xmm2
pandn %xmm2, %xmm0
por %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x70(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x30(%rbp), %rsi
callq 0x5b4c0
movsd -0x70(%rbp), %xmm3
movsd (%rax), %xmm2
movaps %xmm2, %xmm4
movaps %xmm3, %xmm0
cmpunordsd %xmm0, %xmm0
movaps %xmm0, %xmm1
pand %xmm4, %xmm1
maxsd %xmm3, %xmm2
pandn %xmm2, %xmm0
por %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x68(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x30(%rbp), %rsi
callq 0x5b4c0
movsd -0x68(%rbp), %xmm3
movsd 0x8(%rax), %xmm2
movaps %xmm2, %xmm4
movaps %xmm3, %xmm0
cmpunordsd %xmm0, %xmm0
movaps %xmm0, %xmm1
pand %xmm4, %xmm1
maxsd %xmm3, %xmm2
pandn %xmm2, %xmm0
por %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x5ac3a
movsd -0x10(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
leaq -0x40(%rbp), %rdi
callq 0x5b520
movq -0x58(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, (%rax)
movq -0x38(%rbp), %rcx
movq %rcx, 0x8(%rax)
movsd -0x18(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
leaq -0x50(%rbp), %rdi
callq 0x5b520
movq -0x58(%rbp), %rcx
movq -0x60(%rbp), %rax
movq -0x50(%rbp), %rdx
movq %rdx, 0x10(%rcx)
movq -0x48(%rbp), %rdx
movq %rdx, 0x18(%rcx)
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: thierry7100[P]CutOptim/src/Geometry.cpp
// Function: Polygon::Polygon()
Polygon::Polygon()
{
    //constructor, build an empty vector
    //  Bounding box is also empty
    BoundingBox.A = Point(0,0);
    BoundingBox.B = Point(0,0);
    nVertices = 0;
    poly_centroid_ok = 0;           //  Not yet computed;
    poly_area = 0.0;
    poly_clockwise = 0;
    poly_closed = 0;
    poly_changed = 1;
    angle_rotation = 0;
    precision = my_Default_Precision;
    TypePoly = EmptyPoly;
    nbEmptyPoly++;
    nbCreatedEmptyPoly++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
leaq 0x5968d(%rip), %rax     # 0xb7ca8
movq %rax, (%rdi)
addq $0x10, %rdi
movq %rdi, -0x58(%rbp)
callq 0x5aee0
movq -0x40(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x50(%rbp)
callq 0x63890
movq -0x40(%rbp), %rdi
addq $0x40, %rdi
movq %rdi, -0x48(%rbp)
callq 0x638b0
movq -0x40(%rbp), %rdi
addq $0x58, %rdi
callq 0x5b4e0
jmp 0x5e65c
movq -0x40(%rbp), %rdi
subq $-0x80, %rdi
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0x5b520
jmp 0x5e671
movq -0x40(%rbp), %rdi
addq $0xb0, %rdi
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0x5b520
jmp 0x5e689
leaq -0x28(%rbp), %rdi
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0x5b520
jmp 0x5e69a
movq -0x40(%rbp), %rax
movups -0x28(%rbp), %xmm0
movups %xmm0, 0x58(%rax)
leaq -0x38(%rbp), %rdi
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0x5b520
jmp 0x5e6b7
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, 0x68(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x70(%rax)
movl $0x0, 0x8(%rax)
movl $0x0, 0x90(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x78(%rax)
movl $0x0, 0x94(%rax)
movl $0x0, 0x98(%rax)
movl $0x1, 0x9c(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0xa8(%rax)
movsd 0x259c3(%rip), %xmm0    # 0x840d8
movsd %xmm0, 0xa0(%rax)
movl $0x0, 0xc(%rax)
movq 0x5a425(%rip), %rax     # 0xb8b50
addq $0x1, %rax
movq %rax, 0x5a41a(%rip)     # 0xb8b50
movq 0x5a443(%rip), %rax     # 0xb8b80
addq $0x1, %rax
movq %rax, 0x5a438(%rip)     # 0xb8b80
addq $0x60, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x638d0
movq -0x50(%rbp), %rdi
callq 0x63930
movq -0x58(%rbp), %rdi
callq 0x5b3f0
movq -0x10(%rbp), %rdi
callq 0x9960
nop
// File: thierry7100[P]CutOptim/src/Geometry.cpp
// Function: Polygon::Polygon(std::vector<Point, std::allocator<Point>>&)
Polygon::Polygon(vector<Point> &points)
{
int n = points.size();

    BoundingBox.A = Point(0,0);
    BoundingBox.B = Point(0,0);
    nVertices = 0;
    poly_centroid_ok = 0;           //  Not yet computed;
    poly_area = 0.0;
    poly_clockwise = 0;
    poly_closed = 0;
    poly_changed = 1;
    precision = my_Default_Precision;
    for (int i = 0; i < n; i++ )
    {
        addVertice(points[i]);      //  Add this point, but with the desired precision
    }
    //  Add last point which is first
    addVertice(points[0]);
    TypePoly = VectorPoly;
    nbVectorPoly++;
    nbCreatedVectorPoly++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
leaq 0x59509(%rip), %rax     # 0xb7ca8
movq %rax, (%rdi)
addq $0x10, %rdi
movq %rdi, -0x68(%rbp)
callq 0x5aee0
movq -0x50(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x60(%rbp)
callq 0x63890
movq -0x50(%rbp), %rdi
addq $0x40, %rdi
movq %rdi, -0x58(%rbp)
callq 0x638b0
movq -0x50(%rbp), %rdi
addq $0x58, %rdi
callq 0x5b4e0
jmp 0x5e7e0
movq -0x50(%rbp), %rdi
subq $-0x80, %rdi
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0x5b520
jmp 0x5e7f5
movq -0x50(%rbp), %rdi
addq $0xb0, %rdi
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0x5b520
jmp 0x5e80d
movq -0x10(%rbp), %rdi
callq 0x5add0
movl %eax, -0x20(%rbp)
leaq -0x30(%rbp), %rdi
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0x5b520
jmp 0x5e82a
movq -0x50(%rbp), %rax
movups -0x30(%rbp), %xmm0
movups %xmm0, 0x58(%rax)
leaq -0x40(%rbp), %rdi
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0x5b520
jmp 0x5e847
movq -0x50(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, 0x68(%rax)
movq -0x38(%rbp), %rcx
movq %rcx, 0x70(%rax)
movl $0x0, 0x8(%rax)
movl $0x0, 0x90(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x78(%rax)
movl $0x0, 0x94(%rax)
movl $0x0, 0x98(%rax)
movl $0x1, 0x9c(%rax)
movsd 0x2583e(%rip), %xmm0    # 0x840d8
movsd %xmm0, 0xa0(%rax)
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x5e902
movq -0x10(%rbp), %rdi
movslq -0x44(%rbp), %rsi
callq 0x63990
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x5e960
jmp 0x5e8cc
jmp 0x5e8ce
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x5e8a9
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x638d0
movq -0x60(%rbp), %rdi
callq 0x63930
movq -0x68(%rbp), %rdi
callq 0x5b3f0
jmp 0x5e952
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x63990
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x5e960
jmp 0x5e91d
movq -0x50(%rbp), %rax
movl $0x1, 0xc(%rax)
movq 0x5a229(%rip), %rax     # 0xb8b58
addq $0x1, %rax
movq %rax, 0x5a21e(%rip)     # 0xb8b58
movq 0x5a247(%rip), %rax     # 0xb8b88
addq $0x1, %rax
movq %rax, 0x5a23c(%rip)     # 0xb8b88
addq $0x70, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x9960
nopl (%rax,%rax)
// File: thierry7100[P]CutOptim/src/Geometry.cpp
// Function: Polygon::~Polygon()
Polygon::~Polygon()
{
    if ( TypePoly == EmptyPoly )
    {
        nbEmptyPoly--;
    }
    else if (TypePoly == RotatedPoly )
    {
        nbEmptyPoly--;
        nbRotatedPoly--;
    }
    else if (TypePoly == TranslatedPoly )
    {
        nbEmptyPoly--;
        nbTranslatedPoly--;
    }
    else if (TypePoly == TransformedPoly )
    {
        nbEmptyPoly--;
        nbTransformedPoly--;
    }
    else if (TypePoly == CachedPoly )
    {
        nbEmptyPoly--;
        nbCachedPoly--;
    }
    else
    {
        nbVectorPoly--;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x5910d(%rip), %rcx     # 0xb7c98
addq $0x10, %rcx
movq %rcx, (%rax)
cmpl $0x0, 0xc(%rax)
jne 0x5ebaf
movq 0x59fb1(%rip), %rax     # 0xb8b50
addq $-0x1, %rax
movq %rax, 0x59fa6(%rip)     # 0xb8b50
jmp 0x5ec8c
movq -0x10(%rbp), %rax
cmpl $0x2, 0xc(%rax)
jne 0x5ebe2
movq 0x59f90(%rip), %rax     # 0xb8b50
addq $-0x1, %rax
movq %rax, 0x59f85(%rip)     # 0xb8b50
movq 0x59f8e(%rip), %rax     # 0xb8b60
addq $-0x1, %rax
movq %rax, 0x59f83(%rip)     # 0xb8b60
jmp 0x5ec8a
movq -0x10(%rbp), %rax
cmpl $0x3, 0xc(%rax)
jne 0x5ec12
movq 0x59f5d(%rip), %rax     # 0xb8b50
addq $-0x1, %rax
movq %rax, 0x59f52(%rip)     # 0xb8b50
movq 0x59f63(%rip), %rax     # 0xb8b68
addq $-0x1, %rax
movq %rax, 0x59f58(%rip)     # 0xb8b68
jmp 0x5ec88
movq -0x10(%rbp), %rax
cmpl $0x4, 0xc(%rax)
jne 0x5ec42
movq 0x59f2d(%rip), %rax     # 0xb8b50
addq $-0x1, %rax
movq %rax, 0x59f22(%rip)     # 0xb8b50
movq 0x59f3b(%rip), %rax     # 0xb8b70
addq $-0x1, %rax
movq %rax, 0x59f30(%rip)     # 0xb8b70
jmp 0x5ec86
movq -0x10(%rbp), %rax
cmpl $0x5, 0xc(%rax)
jne 0x5ec72
movq 0x59efd(%rip), %rax     # 0xb8b50
addq $-0x1, %rax
movq %rax, 0x59ef2(%rip)     # 0xb8b50
movq 0x59f13(%rip), %rax     # 0xb8b78
addq $-0x1, %rax
movq %rax, 0x59f08(%rip)     # 0xb8b78
jmp 0x5ec84
movq 0x59edf(%rip), %rax     # 0xb8b58
addq $-0x1, %rax
movq %rax, 0x59ed4(%rip)     # 0xb8b58
jmp 0x5ec86
jmp 0x5ec88
jmp 0x5ec8a
jmp 0x5ec8c
movq -0x10(%rbp), %rdi
addq $0x40, %rdi
callq 0x638d0
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
callq 0x63930
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x5b3f0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: thierry7100[P]CutOptim/src/Geometry.cpp
// Function: Polygon::area()
double Polygon::area()
{
double A = 0.0;

    if ( nVertices < 3) return 0.0;
    if ( poly_closed == 0 ) return(0.0);
    if ( poly_changed == 0 && poly_area > 0 ) return(poly_area);
    for (int i = 0; i < nVertices - 1; i++)
    {
        A += _Vertices[i].x*_Vertices[i+1].y - _Vertices[i+1].x*_Vertices[i].y;
    }
    if ( A < 0 )
    {
        poly_clockwise = 1;
        A /= -2.0;
    }
    else
    {
        poly_clockwise = -1;
        A /= 2.0;
    }
    poly_area = A;
    poly_changed = 0;
	return poly_area;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
cmpl $0x3, 0x8(%rax)
jge 0x5ed3f
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x5eed2
movq -0x28(%rbp), %rax
cmpl $0x0, 0x98(%rax)
jne 0x5ed59
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x5eed2
movq -0x28(%rbp), %rax
cmpl $0x0, 0x9c(%rax)
jne 0x5ed8b
movq -0x28(%rbp), %rax
movsd 0x78(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x5ed8b
movq -0x28(%rbp), %rax
movsd 0x78(%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x5eed2
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
movl 0x8(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x5ee5c
movq -0x28(%rbp), %rdi
addq $0x10, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x63990
movq -0x28(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
addq $0x10, %rdi
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x63990
movq -0x28(%rbp), %rdi
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
addq $0x10, %rdi
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x63990
movq -0x28(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
addq $0x10, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x63990
movsd -0x40(%rbp), %xmm1
movsd -0x38(%rbp), %xmm0
movsd -0x30(%rbp), %xmm2
mulsd 0x8(%rax), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5ed92
xorps %xmm0, %xmm0
ucomisd -0x18(%rbp), %xmm0
jbe 0x5ee8c
movq -0x28(%rbp), %rax
movl $0x1, 0x94(%rax)
movsd -0x18(%rbp), %xmm0
movsd 0x2525f(%rip), %xmm1    # 0x840e0
divsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
jmp 0x5eeb0
movq -0x28(%rbp), %rax
movl $0xffffffff, 0x94(%rax) # imm = 0xFFFFFFFF
movsd -0x18(%rbp), %xmm0
movsd 0x251f9(%rip), %xmm1    # 0x840a0
divsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x28(%rbp), %rax
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x78(%rax)
movl $0x0, 0x9c(%rax)
movsd 0x78(%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: thierry7100[P]CutOptim/src/Geometry.cpp
// Function: Polygon::Reverse()
void Polygon::Reverse(void)
{
    if ( poly_clockwise < 0) return;    //  Oups OK before entering
    if ( poly_clockwise == 0 ) return;  //  Oups not known, unable to change
    for ( int i = 0, j = nVertices-1; i < j ; i++, j--)
    {
        Point p = _Vertices[i];
        _Vertices[i] = _Vertices[j];
        _Vertices[j] = p;
    }
    poly_clockwise = -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, 0x94(%rax)
jge 0x5f5c2
jmp 0x5f691
movq -0x28(%rbp), %rax
cmpl $0x0, 0x94(%rax)
jne 0x5f5d4
jmp 0x5f691
movq -0x28(%rbp), %rax
movl $0x0, -0xc(%rbp)
movl 0x8(%rax), %eax
subl $0x1, %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x5f683
movq -0x28(%rbp), %rdi
addq $0x10, %rdi
movslq -0xc(%rbp), %rsi
callq 0x63990
movq -0x28(%rbp), %rdi
movq (%rax), %rcx
movq %rcx, -0x20(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
addq $0x10, %rdi
movslq -0x10(%rbp), %rsi
callq 0x63990
movq -0x28(%rbp), %rdi
movq %rax, -0x30(%rbp)
addq $0x10, %rdi
movslq -0xc(%rbp), %rsi
callq 0x63990
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rdi
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
addq $0x10, %rdi
movslq -0x10(%rbp), %rsi
callq 0x63990
movq -0x20(%rbp), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x5f5e8
movq -0x28(%rbp), %rax
movl $0xffffffff, 0x94(%rax) # imm = 0xFFFFFFFF
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: thierry7100[P]CutOptim/src/Geometry.cpp
// Function: Polygon::setStartPointMinY()
void Polygon::setStartPointMinY()
{
    double ymin = 1e30;
    int idxmin = 0;
    for ( int i = 0; i < nVertices-1; i++)
    {
        if ( _Vertices[i].y < ymin )
        {
            ymin = _Vertices[i].y;
            idxmin = i;
        }
    }
    if ( idxmin == 0 ) return;      //  Already ordered, return;
    //  Create a new vector
    std::vector<Point>  tmp_vertices;
    for ( int i = 0; i < nVertices - 1; i++)
    {
        tmp_vertices.push_back(_Vertices[(i + idxmin)%(nVertices-1)]);
    }
    tmp_vertices[nVertices-1] = tmp_vertices[0];
    for ( int i = 0; i < nVertices; i++)
    {
        _Vertices[i] = tmp_vertices[i];
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movsd 0x24a34(%rip), %xmm0    # 0x840f0
movsd %xmm0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x50(%rbp), %rcx
movl -0x18(%rbp), %eax
movl 0x8(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x5f72f
movq -0x50(%rbp), %rdi
addq $0x10, %rdi
movslq -0x18(%rbp), %rsi
callq 0x63990
movsd 0x8(%rax), %xmm1
movsd -0x10(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x5f722
movq -0x50(%rbp), %rdi
addq $0x10, %rdi
movslq -0x18(%rbp), %rsi
callq 0x63990
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x10(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x5f724
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x5f6cf
cmpl $0x0, -0x14(%rbp)
jne 0x5f73a
jmp 0x5f84a
leaq -0x30(%rbp), %rdi
callq 0x5aee0
movl $0x0, -0x34(%rbp)
movq -0x50(%rbp), %rcx
movl -0x34(%rbp), %eax
movl 0x8(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x5f7b3
movq -0x50(%rbp), %rcx
movq %rcx, %rdi
addq $0x10, %rdi
movl -0x34(%rbp), %eax
movl -0x14(%rbp), %edx
addl %edx, %eax
movl 0x8(%rcx), %ecx
decl %ecx
cltd
idivl %ecx
movslq %edx, %rsi
callq 0x63990
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0x5b060
jmp 0x5f78c
jmp 0x5f78e
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x5f74a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5b3f0
jmp 0x5f850
leaq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x63990
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, -0x58(%rbp)
movl 0x8(%rax), %eax
subl $0x1, %eax
movslq %eax, %rsi
leaq -0x30(%rbp), %rdi
callq 0x63990
movq -0x58(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movl $0x0, -0x48(%rbp)
movq -0x50(%rbp), %rcx
movl -0x48(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x5f841
movslq -0x48(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x63990
movq -0x50(%rbp), %rdi
movq %rax, -0x60(%rbp)
addq $0x10, %rdi
movslq -0x48(%rbp), %rsi
callq 0x63990
movq -0x60(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x5f7f6
leaq -0x30(%rbp), %rdi
callq 0x5b3f0
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x9960
nopl (%rax)
// File: thierry7100[P]CutOptim/src/Geometry.cpp
// Function: Polygon::ReCalcBoundingBox()
void Polygon::ReCalcBoundingBox()
{
    BoundingBox.A = _Vertices[0];
    BoundingBox.B = _Vertices[0];
    for ( int i = 1; i < nVertices - 1; i++)
    {
        if ( _Vertices[i].x < BoundingBox.A.x ) BoundingBox.A.x = _Vertices[i].x ;
        if ( _Vertices[i].y < BoundingBox.A.y ) BoundingBox.A.y = _Vertices[i].y ;
        if ( _Vertices[i].x > BoundingBox.B.x ) BoundingBox.B.x = _Vertices[i].x ;
        if ( _Vertices[i].y > BoundingBox.B.y ) BoundingBox.B.y = _Vertices[i].y ;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x10, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x63990
movq -0x18(%rbp), %rdi
movq (%rax), %rcx
movq %rcx, 0x58(%rdi)
movq 0x8(%rax), %rax
movq %rax, 0x60(%rdi)
addq $0x10, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x63990
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq (%rcx), %rdx
movq %rdx, 0x68(%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x70(%rax)
movl $0x1, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
movl 0x8(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x609ff
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
movslq -0xc(%rbp), %rsi
callq 0x63990
movq %rax, %rcx
movq -0x18(%rbp), %rax
movsd (%rcx), %xmm1
movsd 0x58(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x6091b
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
movslq -0xc(%rbp), %rsi
callq 0x63990
movq %rax, %rcx
movq -0x18(%rbp), %rax
movsd (%rcx), %xmm0
movsd %xmm0, 0x58(%rax)
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
movslq -0xc(%rbp), %rsi
callq 0x63990
movq %rax, %rcx
movq -0x18(%rbp), %rax
movsd 0x8(%rcx), %xmm1
movsd 0x60(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x60965
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
movslq -0xc(%rbp), %rsi
callq 0x63990
movq %rax, %rcx
movq -0x18(%rbp), %rax
movsd 0x8(%rcx), %xmm0
movsd %xmm0, 0x60(%rax)
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
movslq -0xc(%rbp), %rsi
callq 0x63990
movq %rax, %rcx
movq -0x18(%rbp), %rax
movsd (%rcx), %xmm0
ucomisd 0x68(%rax), %xmm0
jbe 0x609a9
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
movslq -0xc(%rbp), %rsi
callq 0x63990
movq %rax, %rcx
movq -0x18(%rbp), %rax
movsd (%rcx), %xmm0
movsd %xmm0, 0x68(%rax)
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
movslq -0xc(%rbp), %rsi
callq 0x63990
movq %rax, %rcx
movq -0x18(%rbp), %rax
movsd 0x8(%rcx), %xmm0
ucomisd 0x70(%rax), %xmm0
jbe 0x609ef
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
movslq -0xc(%rbp), %rsi
callq 0x63990
movq %rax, %rcx
movq -0x18(%rbp), %rax
movsd 0x8(%rcx), %xmm0
movsd %xmm0, 0x70(%rax)
jmp 0x609f1
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x608be
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: thierry7100[P]CutOptim/src/Geometry.cpp
// Function: Polygon::delVertex(int)
void Polygon::delVertex(int index)
{
    if ( nVertices > 3 )
    {
        _Vertices.erase(_Vertices.begin()+index);
        nVertices = _Vertices.size();
        poly_changed = 1;
        poly_centroid_ok = 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $0x3, 0x8(%rax)
jle 0x612e3
movq -0x38(%rbp), %rdi
movq %rdi, %rax
addq $0x10, %rax
movq %rax, -0x40(%rbp)
addq $0x10, %rdi
callq 0x5b490
movq %rax, -0x28(%rbp)
movslq -0xc(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x5c560
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x5b380
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x64200
movq -0x38(%rbp), %rdi
movq %rax, -0x30(%rbp)
addq $0x10, %rdi
callq 0x5add0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movl %ecx, 0x8(%rax)
movl $0x1, 0x9c(%rax)
movl $0x0, 0x90(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)