LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::ClipperBase::GetBounds()
IntRect ClipperBase::GetBounds()
{
  IntRect result;
  LocalMinima* lm = m_MinimaList;
  if (!lm)
  {
    result.left = result.top = result.right = result.bottom = 0;
    return result;
  }
  result.left = lm->LeftBound->Bot.X;
  result.top = lm->LeftBound->Bot.Y;
  result.right = lm->LeftBound->Bot.X;
  result.bottom = lm->LeftBound->Bot.Y;
  while (lm)
  {
    if (lm->LeftBound->Bot.Y > result.bottom)
      result.bottom = lm->LeftBound->Bot.Y;
    TEdge* e = lm->LeftBound;
    for (;;) {
      TEdge* bottomE = e;
      while (e->NextInLML)
      {
        if (e->Bot.X < result.left) result.left = e->Bot.X;
        if (e->Bot.X > result.right) result.right = e->Bot.X;
        e = e->NextInLML;
      }
      if (e->Bot.X < result.left) result.left = e->Bot.X;
      if (e->Bot.X > result.right) result.right = e->Bot.X;
      if (e->Top.X < result.left) result.left = e->Top.X;
      if (e->Top.X > result.right) result.right = e->Top.X;
      if (e->Top.Y < result.top) result.top = e->Top.Y;

      if (bottomE == lm->LeftBound) e = lm->RightBound;
      else break;
    }
    lm = lm->Next;
  }
  return result;
}

// Assembly:
movq %rdi, %rax
movq 0x10(%rsi), %rcx
testq %rcx, %rcx
je 0xa102
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x8(%rcx), %rsi
movq (%rsi), %rdx
movq 0x8(%rsi), %rsi
movq %rdx, %r8
movq %rsi, %rdi
movq 0x8(%rcx), %r10
movq 0x10(%rcx), %r11
movq 0x8(%r10), %r9
movq %r10, %rbx
movq 0x70(%rbx), %r15
testq %r15, %r15
je 0xa09e
movq %rbx, %r12
movq (%r12), %r14
cmpq %rdx, %r14
cmovlq %r14, %rdx
cmpq %r8, %r14
cmovgq %r14, %r8
movq %r15, %r14
movq 0x70(%r15), %r15
movq %r14, %r12
testq %r15, %r15
jne 0xa07b
jmp 0xa0a1
movq %rbx, %r14
movq (%r14), %r15
cmpq %rdx, %r15
cmovlq %r15, %rdx
movq 0x20(%r14), %r12
cmpq %r8, %r15
cmovgq %r15, %r8
cmpq %rdx, %r12
cmovlq %r12, %rdx
cmpq %r8, %r12
cmovgq %r12, %r8
movq 0x28(%r14), %r14
cmpq %rdi, %r14
cmovlq %r14, %rdi
cmpq %r10, %rbx
movq %r11, %rbx
je 0xa06f
cmpq %rsi, %r9
cmovgq %r9, %rsi
movq 0x18(%rcx), %rcx
testq %rcx, %rcx
jne 0xa060
movq %rsi, 0x18(%rax)
movq %rdx, (%rax)
movq %r8, 0x10(%rax)
movq %rdi, 0x8(%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::Clipper::Reset()
void Clipper::Reset()
{
  ClipperBase::Reset();
  m_Scanbeam.clear();
  m_ActiveEdges = 0;
  m_SortedEdges = 0;
  LocalMinima* lm = m_MinimaList;
  while (lm)
  {
    InsertScanbeam(lm->Y);
    lm = lm->Next;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movq (%rdi), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
callq 0x9fd6
leaq 0x70(%r14), %rbx
movq %rbx, %rdi
callq 0x12864
xorps %xmm0, %xmm0
movups %xmm0, 0xa0(%r14)
movq (%r14), %rax
movq -0x18(%rax), %rax
movq 0x10(%r14,%rax), %r15
testq %r15, %r15
je 0xa3f0
leaq 0x8(%rsp), %r14
movq (%r15), %rax
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x12a16
movq 0x18(%r15), %r15
testq %r15, %r15
jne 0xa3d4
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::Clipper::Execute(ClipperLib::ClipType, std::vector<std::vector<ClipperLib::IntPoint, std::allocator<ClipperLib::IntPoint>>, std::allocator<std::vector<ClipperLib::IntPoint, std::allocator<ClipperLib::IntPoint>>>>&, ClipperLib::PolyFillType, ClipperLib::PolyFillType)
bool Clipper::Execute(ClipType clipType, Paths &solution,
    PolyFillType subjFillType, PolyFillType clipFillType)
{
  if( m_ExecuteLocked ) return false;
  if (m_HasOpenPaths)
    throw clipperException("Error: PolyTree struct is need for open path clipping.");
  m_ExecuteLocked = true;
  solution.resize(0);
  m_SubjFillType = subjFillType;
  m_ClipFillType = clipFillType;
  m_ClipType = clipType;
  m_UsingPolyTree = false;
  bool succeeded = ExecuteInternal();
  if (succeeded) BuildResult(solution);
  DisposeAllOutRecs();
  m_ExecuteLocked = false;
  return succeeded;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpb $0x0, 0xb0(%rdi)
je 0xa431
xorl %ebp, %ebp
jmp 0xa4a0
movq %rdi, %rbx
movq (%rdi), %rax
movq -0x18(%rax), %rax
cmpb $0x1, 0x39(%rdi,%rax)
je 0xa4ab
movl %r8d, %ebp
movl %ecx, %r12d
movq %rdx, %r14
movl %esi, %r15d
movb $0x1, 0xb0(%rbx)
movq %rdx, %rdi
xorl %esi, %esi
callq 0x11d24
movl %r12d, 0xb8(%rbx)
movl %ebp, 0xb4(%rbx)
movl %r15d, 0x68(%rbx)
movb $0x0, 0xbd(%rbx)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movl %eax, %ebp
testb %al, %al
je 0xa491
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa4f0
movq %rbx, %rdi
callq 0xa626
movb $0x0, 0xb0(%rbx)
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x28, %edi
callq 0x30f0
movq %rax, %rbx
leaq 0xb2f7(%rip), %rsi      # 0x157b6
movq %rax, %rdi
callq 0x11cba
leaq 0x1189a(%rip), %rsi     # 0x1bd68
leaq 0x781f(%rip), %rdx      # 0x11cf4
movq %rbx, %rdi
callq 0x3370
movq %rax, %r14
movq %rbx, %rdi
callq 0x3170
movq %r14, %rdi
callq 0x3380
// File: /workspace/github_cpp_makefile_star2_O3/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::Clipper::BuildResult(std::vector<std::vector<ClipperLib::IntPoint, std::allocator<ClipperLib::IntPoint>>, std::allocator<std::vector<ClipperLib::IntPoint, std::allocator<ClipperLib::IntPoint>>>>&)
void Clipper::BuildResult(Paths &polys)
{
  polys.reserve(m_PolyOuts.size());
  for (PolyOutList::size_type i = 0; i < m_PolyOuts.size(); ++i)
  {
    if (!m_PolyOuts[i]->Pts) continue;
    Path pg;
    OutPt* p = m_PolyOuts[i]->Pts->Prev;
    int cnt = PointCount(p);
    if (cnt < 2) continue;
    pg.reserve(cnt);
    for (int i = 0; i < cnt; ++i)
    {
      pg.push_back(p->Pt);
      p = p->Prev;
    }
    polys.push_back(pg);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rsi
subq 0x8(%rdi), %rsi
sarq $0x3, %rsi
movq %rbx, %rdi
callq 0x11d92
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
cmpq %rax, %rcx
je 0xa5f4
xorl %r12d, %r12d
movq %rsp, %r15
movq (%rax,%r12,8), %rdx
cmpq $0x0, 0x18(%rdx)
je 0xa5de
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq (%rax,%r12,8), %rax
movq 0x18(%rax), %rax
movq 0x20(%rax), %r13
testq %r13, %r13
je 0xa5d6
movl $0x1, %ecx
xorl %esi, %esi
movq %r13, %rax
movl %ecx, %ebp
movq 0x18(%rax), %rax
incq %rsi
leal 0x1(%rbp), %ecx
cmpq %r13, %rax
jne 0xa569
cmpl $0x1, %esi
je 0xa5d6
movq %r15, %rdi
callq 0x11e70
leaq 0x8(%r13), %rdx
movq 0x8(%rsp), %rsi
cmpq 0x10(%rsp), %rsi
je 0xa5a5
movups (%rdx), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0x8(%rsp)
jmp 0xa5ad
movq %r15, %rdi
callq 0x12168
movq 0x20(%r13), %r13
decl %ebp
jne 0xa587
movq %rbx, %rdi
movq %r15, %rsi
callq 0x11f18
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xa5d6
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x3220
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
incq %r12
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %rdx, %r12
jb 0xa52f
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa605
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xa61e
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x3220
movq %rbx, %rdi
callq 0x3380
// File: /workspace/github_cpp_makefile_star2_O3/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::Clipper::Execute(ClipperLib::ClipType, ClipperLib::PolyTree&, ClipperLib::PolyFillType, ClipperLib::PolyFillType)
bool Clipper::Execute(ClipType clipType, PolyTree& polytree,
    PolyFillType subjFillType, PolyFillType clipFillType)
{
  if( m_ExecuteLocked ) return false;
  m_ExecuteLocked = true;
  m_SubjFillType = subjFillType;
  m_ClipFillType = clipFillType;
  m_ClipType = clipType;
  m_UsingPolyTree = true;
  bool succeeded = ExecuteInternal();
  if (succeeded) BuildResult2(polytree);
  DisposeAllOutRecs();
  m_ExecuteLocked = false;
  return succeeded;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
cmpb $0x0, 0xb0(%rdi)
je 0xa685
xorl %ebp, %ebp
jmp 0xa6cf
movq %rdx, %r14
movq %rdi, %rbx
movb $0x1, %al
movb %al, 0xb0(%rdi)
movl %ecx, 0xb8(%rdi)
movl %r8d, 0xb4(%rdi)
movl %esi, 0x68(%rdi)
movb %al, 0xbd(%rdi)
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, %ebp
testb %al, %al
je 0xa6c0
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa6d6
movq %rbx, %rdi
callq 0xa626
movb $0x0, 0xb0(%rbx)
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::Clipper::FixHoleLinkage(ClipperLib::OutRec&)
void Clipper::FixHoleLinkage(OutRec &outrec)
{
  //skip OutRecs that (a) contain outermost polygons or
  //(b) already have the correct owner/child linkage ...
  if (!outrec.FirstLeft ||                
      (outrec.IsHole != outrec.FirstLeft->IsHole &&
      outrec.FirstLeft->Pts)) return;

  OutRec* orfl = outrec.FirstLeft;
  while (orfl && ((orfl->IsHole == outrec.IsHole) || !orfl->Pts))
      orfl = orfl->FirstLeft;
  outrec.FirstLeft = orfl;
}

// Assembly:
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0xa904
movb 0x4(%rsi), %cl
cmpb 0x4(%rax), %cl
je 0xa905
cmpq $0x0, 0x18(%rax)
je 0xa905
retq
cmpb %cl, 0x4(%rax)
je 0xa911
cmpq $0x0, 0x18(%rax)
jne 0xa91c
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0xa905
xorl %eax, %eax
movq %rax, 0x8(%rsi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::Clipper::ProcessHorizontals(bool)
void Clipper::ProcessHorizontals(bool IsTopOfScanbeam)
{
  TEdge* horzEdge = m_SortedEdges;
  while(horzEdge)
  {
    DeleteFromSEL(horzEdge);
    ProcessHorizontal(horzEdge, IsTopOfScanbeam);
    horzEdge = m_SortedEdges;
  }
}

// Assembly:
movl %esi, %eax
movq 0xa8(%rdi), %rsi
testq %rsi, %rsi
je 0xafb2
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xa8(%rdi), %r14
movl $0x88, %r15d
movzbl %al, %ebp
movq 0x88(%rsi), %rax
movq 0x90(%rsi), %rcx
leaq (%rcx,%r15), %rdx
testq %rcx, %rcx
cmoveq %r14, %rdx
movq %rax, (%rdx)
testq %rax, %rax
je 0xaf88
movq %rcx, 0x90(%rax)
leaq (%rsi,%r15), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rbx, %rdi
movl %ebp, %edx
callq 0xcbb6
movq 0xa8(%rbx), %rsi
testq %rsi, %rsi
jne 0xaf60
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::Clipper::ProcessIntersections(long long, long long)
bool Clipper::ProcessIntersections(const cInt botY, const cInt topY)
{
  if( !m_ActiveEdges ) return true;
  try {
    BuildIntersectList(botY, topY);
    size_t IlSize = m_IntersectList.size();
    if (IlSize == 0) return true;
    if (IlSize == 1 || FixupIntersectionOrder()) ProcessIntersectList();
    else return false;
  }
  catch(...) 
  {
    m_SortedEdges = 0;
    DisposeIntersectNodes();
    throw clipperException("ProcessIntersections error");
  }
  m_SortedEdges = 0;
  return true;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movb $0x1, %bpl
cmpq $0x0, 0xa0(%rdi)
je 0xb004
movq %rdi, %rbx
callq 0xd55e
movq 0x58(%rbx), %rax
subq 0x50(%rbx), %rax
sarq $0x3, %rax
je 0xb004
cmpq $0x1, %rax
je 0xafed
movq %rbx, %rdi
callq 0xd820
testb %al, %al
je 0xb002
movq %rbx, %rdi
callq 0xdabe
movq $0x0, 0xa8(%rbx)
jmp 0xb004
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
jmp 0xb00d
movq %rax, %rdi
callq 0x30d0
movq $0x0, 0xa8(%rbx)
movq %rbx, %rdi
callq 0xdb38
movl $0x28, %edi
callq 0x30f0
movq %rax, %rbx
leaq 0xa7e9(%rip), %rsi      # 0x15825
movq %rax, %rdi
callq 0x11cba
leaq 0x10d1d(%rip), %rsi     # 0x1bd68
leaq 0x6ca2(%rip), %rdx      # 0x11cf4
movq %rbx, %rdi
callq 0x3370
movq %rax, %r14
jmp 0xb06a
movq %rax, %r14
movq %rbx, %rdi
callq 0x3170
callq 0x3350
movq %r14, %rdi
callq 0x3380
movq %rax, %rdi
callq 0x11caf
nop
// File: /workspace/github_cpp_makefile_star2_O3/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::Clipper::FixupOutPolygon(ClipperLib::OutRec&)
void Clipper::FixupOutPolygon(OutRec &outrec)
{
  //FixupOutPolygon() - removes duplicate points and simplifies consecutive
  //parallel edges by removing the middle vertex.
  OutPt *lastOK = 0;
  outrec.BottomPt = 0;
  OutPt *pp = outrec.Pts;

  for (;;)
  {
    if (pp->Prev == pp || pp->Prev == pp->Next )
    {
      DisposeOutPts(pp);
      outrec.Pts = 0;
      return;
    }

    //test for duplicate points and collinear edges ...
    if ((pp->Pt == pp->Next->Pt) || (pp->Pt == pp->Prev->Pt) || 
      (SlopesEqual(pp->Prev->Pt, pp->Pt, pp->Next->Pt, m_UseFullRange) &&
      (!m_PreserveCollinear || 
      !Pt2IsBetweenPt1AndPt3(pp->Prev->Pt, pp->Pt, pp->Next->Pt))))
    {
      lastOK = 0;
      OutPt *tmp = pp;
      pp->Prev->Next = pp->Next;
      pp->Next->Prev = pp->Prev;
      pp = pp->Prev;
      delete tmp;
    }
    else if (pp == lastOK) break;
    else
    {
      if (!lastOK) lastOK = pp;
      pp = pp->Next;
    }
  }
  outrec.Pts = pp;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, 0x10(%rsp)
movq $0x0, 0x20(%rsi)
movq %rsi, 0x30(%rsp)
movq 0x18(%rsi), %r14
movq 0x20(%r14), %rbx
cmpq %r14, %rbx
je 0xb97f
leaq 0x20(%r14), %rbp
xorl %edx, %edx
movq 0x18(%r14), %r15
cmpq %r15, %rbx
je 0xb97f
movq 0x8(%r14), %r12
movq 0x10(%r14), %r13
movq 0x8(%r15), %r8
movq 0x10(%r15), %r9
movq %r12, %rax
xorq %r8, %rax
movq %r13, %rcx
xorq %r9, %rcx
orq %rax, %rcx
je 0xb889
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rsi
cmpq %rdi, %r12
jne 0xb8bd
cmpq %rsi, %r13
jne 0xb8bd
movq %r15, 0x18(%rbx)
movq 0x18(%r14), %rax
movq %rbx, 0x20(%rax)
movq (%rbp), %r15
movl $0x28, %esi
movq %r14, %rdi
callq 0x3220
xorl %edx, %edx
leaq 0x20(%r15), %rbp
movq 0x20(%r15), %rbx
movq %r15, %r14
cmpq %r15, %rbx
jne 0xb849
jmp 0xb982
movq 0x10(%rsp), %rcx
movq (%rcx), %rax
movq -0x18(%rax), %rax
movq %rax, 0x38(%rsp)
movzbl 0x18(%rcx,%rax), %eax
movl %eax, (%rsp)
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq %rdx, 0x48(%rsp)
movq %r12, %rdx
movq %r13, %rcx
movq %r8, 0x28(%rsp)
movq 0x28(%rsp), %r8
movq %r9, 0x20(%rsp)
movq 0x20(%rsp), %r9
movq %rsi, 0x40(%rsp)
callq 0x8a01
movq 0x40(%rsp), %r8
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rcx
movq 0x48(%rsp), %rdx
testb %al, %al
je 0xb96e
movq 0x10(%rsp), %rax
movq 0x38(%rsp), %r9
cmpb $0x1, 0x38(%rax,%r9)
jne 0xb889
cmpq %rcx, %rdi
jne 0xb94a
cmpq %rsi, %r8
je 0xb889
cmpq %rcx, %rdi
jne 0xb95a
cmpq %r8, %r13
setg %al
cmpq %rsi, %r13
jmp 0xb963
cmpq %rdi, %r12
setg %al
cmpq %rcx, %r12
setge %cl
xorb %al, %cl
je 0xb889
cmpq %rdx, %r14
je 0xb992
testq %rdx, %rdx
cmoveq %r14, %rdx
jmp 0xb8a8
movq %r14, %r15
leaq 0x50(%rsp), %rdi
movq %r15, (%rdi)
callq 0x8dd8
xorl %r14d, %r14d
movq 0x30(%rsp), %rax
movq %r14, 0x18(%rax)
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::Clipper::DisposeOutRec(unsigned long)
void Clipper::DisposeOutRec(PolyOutList::size_type index)
{
  OutRec *outRec = m_PolyOuts[index];
  if (outRec->Pts) DisposeOutPts(outRec->Pts);
  delete outRec;
  m_PolyOuts[index] = 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rax
movq (%rax,%rsi,8), %r15
cmpq $0x0, 0x18(%r15)
je 0xbba7
leaq 0x18(%r15), %rdi
callq 0x8dd8
movl $0x28, %esi
movq %r15, %rdi
callq 0x3220
movq 0x8(%r14), %rax
movq $0x0, (%rax,%rbx,8)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::Clipper::AddLocalMinPoly(ClipperLib::TEdge*, ClipperLib::TEdge*, ClipperLib::IntPoint const&)
OutPt* Clipper::AddLocalMinPoly(TEdge *e1, TEdge *e2, const IntPoint &Pt)
{
  OutPt* result;
  TEdge *e, *prevE;
  if (IsHorizontal(*e2) || ( e1->Dx > e2->Dx ))
  {
    result = AddOutPt(e1, Pt);
    e2->OutIdx = e1->OutIdx;
    e1->Side = esLeft;
    e2->Side = esRight;
    e = e1;
    if (e->PrevInAEL == e2)
      prevE = e2->PrevInAEL; 
    else
      prevE = e->PrevInAEL;
  } else
  {
    result = AddOutPt(e2, Pt);
    e1->OutIdx = e2->OutIdx;
    e1->Side = esRight;
    e2->Side = esLeft;
    e = e2;
    if (e->PrevInAEL == e1)
        prevE = e1->PrevInAEL;
    else
        prevE = e->PrevInAEL;
  }

  if (prevE && prevE->OutIdx >= 0 &&
      (TopX(*prevE, Pt.Y) == TopX(*e, Pt.Y)) &&
      SlopesEqual(*e, *prevE, m_UseFullRange) &&
      (e->WindDelta != 0) && (prevE->WindDelta != 0))
  {
    OutPt* outPt = AddOutPt(prevE, Pt);
    AddJoin(result, outPt, e->Top);
  }
  return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %rbp
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x38(%rdx)
je 0xbe37
movsd 0x40(%r14), %xmm0
ucomisd 0x40(%rbp), %xmm0
jbe 0xbe98
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xbfae
movq %rax, %r12
movl 0x5c(%r14), %eax
movl %eax, 0x5c(%rbp)
movl $0x1, 0x4c(%r14)
movl $0x2, 0x4c(%rbp)
movq 0x80(%r14), %r13
movq %rbp, %rax
cmpq %rbp, %r13
jne 0xbe74
movq 0x80(%rax), %r13
testq %r13, %r13
je 0xbf9b
cmpl $0x0, 0x5c(%r13)
js 0xbf9b
movq 0x8(%r15), %rcx
cmpq %rcx, 0x28(%r13)
jne 0xbed3
movq 0x20(%r13), %rax
jmp 0xbf0a
movq %rbx, %rdi
movq %rbp, %rsi
movq %r15, %rdx
callq 0xbfae
movq %rax, %r12
movl 0x5c(%rbp), %eax
movl %eax, 0x5c(%r14)
movl $0x2, 0x4c(%r14)
movl $0x1, 0x4c(%rbp)
movq 0x80(%rbp), %r13
movq %r14, %rax
cmpq %r14, %r13
movq %rbp, %r14
jne 0xbe74
jmp 0xbe6d
movq %rcx, %rax
subq 0x8(%r13), %rax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
mulsd 0x40(%r13), %xmm0
xorpd %xmm1, %xmm1
xorl %eax, %eax
ucomisd %xmm0, %xmm1
seta %al
leaq 0x97f4(%rip), %rdx      # 0x156f0
addsd (%rdx,%rax,8), %xmm0
cvttsd2si %xmm0, %rax
addq (%r13), %rax
cmpq %rcx, 0x28(%r14)
jne 0xbf16
movq 0x20(%r14), %rcx
jmp 0xbf49
subq 0x8(%r14), %rcx
xorps %xmm0, %xmm0
cvtsi2sd %rcx, %xmm0
mulsd 0x40(%r14), %xmm0
xorpd %xmm1, %xmm1
xorl %ecx, %ecx
ucomisd %xmm0, %xmm1
seta %cl
leaq 0x97b4(%rip), %rdx      # 0x156f0
addsd (%rdx,%rcx,8), %xmm0
cvttsd2si %xmm0, %rcx
addq (%r14), %rcx
cmpq %rcx, %rax
jne 0xbf9b
movq (%rbx), %rax
movq -0x18(%rax), %rax
movzbl 0x18(%rbx,%rax), %edx
movq %r14, %rdi
movq %r13, %rsi
callq 0x8991
testb %al, %al
je 0xbf9b
cmpl $0x0, 0x50(%r14)
je 0xbf9b
cmpl $0x0, 0x50(%r13)
je 0xbf9b
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0xbfae
movq 0x20(%r14), %rcx
movq 0x28(%r14), %r8
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0xc0c0
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::Clipper::AddOutPt(ClipperLib::TEdge*, ClipperLib::IntPoint const&)
OutPt* Clipper::AddOutPt(TEdge *e, const IntPoint &pt)
{
  bool ToFront = (e->Side == esLeft);
  if(  e->OutIdx < 0 )
  {
    OutRec *outRec = CreateOutRec();
    outRec->IsOpen = (e->WindDelta == 0);
    OutPt* newOp = new OutPt;
    outRec->Pts = newOp;
    newOp->Idx = outRec->Idx;
    newOp->Pt = pt;
    newOp->Next = newOp;
    newOp->Prev = newOp;
    if (!outRec->IsOpen)
      SetHoleState(e, outRec);
#ifdef use_xyz
    if (pt == e->Bot) newOp->Pt = e->Bot;
    else if (pt == e->Top) newOp->Pt = e->Top;
    else SetZ(newOp->Pt, *e);
#endif
    e->OutIdx = outRec->Idx; //nb: do this after SetZ !
    return newOp;
  } else
  {
    OutRec *outRec = m_PolyOuts[e->OutIdx];
    //OutRec.Pts is the 'Left-most' point & OutRec.Pts.Prev is the 'Right-most'
    OutPt* op = outRec->Pts;

    if (ToFront && (pt == op->Pt)) return op;
    else if (!ToFront && (pt == op->Prev->Pt)) return op->Prev;

    OutPt* newOp = new OutPt;
    newOp->Idx = outRec->Idx;
    newOp->Pt = pt;
    newOp->Next = op;
    newOp->Prev = op->Prev;
    newOp->Prev->Next = newOp;
    op->Prev = newOp;
    if (ToFront) outRec->Pts = newOp;
#ifdef use_xyz
    if (pt == e->Bot) newOp->Pt = e->Bot;
    else if (pt == e->Top) newOp->Pt = e->Top;
    else SetZ(newOp->Pt, *e);
#endif
    return newOp;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
movslq 0x5c(%rsi), %rax
testq %rax, %rax
js 0xc002
movl 0x4c(%r15), %ebp
movq 0x8(%r12), %rcx
movq (%rcx,%rax,8), %r15
movq 0x18(%r15), %r12
cmpl $0x1, %ebp
jne 0xc05b
movq (%rbx), %rax
cmpq 0x8(%r12), %rax
jne 0xc073
movq 0x10(%r12), %rax
cmpq %rax, 0x8(%rbx)
jne 0xc073
movq %r12, %r14
jmp 0xc0ad
movq %r12, %rdi
callq 0xcb3e
movq %rax, %r13
movl 0x50(%r15), %ebp
testl %ebp, %ebp
sete 0x5(%rax)
movl $0x28, %edi
callq 0x3210
movq %rax, %r14
movq %rax, 0x18(%r13)
movl (%r13), %eax
movl %eax, (%r14)
movups (%rbx), %xmm0
movups %xmm0, 0x8(%r14)
movq %r14, 0x18(%r14)
movq %r14, 0x20(%r14)
testl %ebp, %ebp
je 0xc055
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0xca42
movl (%r13), %eax
movl %eax, 0x5c(%r15)
jmp 0xc0ad
movq 0x20(%r12), %r14
movq (%rbx), %rax
cmpq 0x8(%r14), %rax
jne 0xc073
movq 0x10(%r14), %rax
cmpq %rax, 0x8(%rbx)
je 0xc0ad
movl $0x28, %edi
callq 0x3210
movq %rax, %r14
movl (%r15), %eax
movl %eax, (%r14)
movups (%rbx), %xmm0
movups %xmm0, 0x8(%r14)
movq %r12, 0x18(%r14)
movq 0x20(%r12), %rax
movq %rax, 0x20(%r14)
movq %r14, 0x18(%rax)
movq %r14, 0x20(%r12)
cmpl $0x1, %ebp
jne 0xc0ad
movq %r14, 0x18(%r15)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::Clipper::AddJoin(ClipperLib::OutPt*, ClipperLib::OutPt*, ClipperLib::IntPoint)
void Clipper::AddJoin(OutPt *op1, OutPt *op2, const IntPoint OffPt)
{
  Join* j = new Join;
  j->OutPt1 = op1;
  j->OutPt2 = op2;
  j->OffPt = OffPt;
  m_Joins.push_back(j);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movl $0x20, %edi
callq 0x3210
movq %rax, 0x8(%rsp)
movq %r13, (%rax)
movq %r12, 0x8(%rax)
movq %r15, 0x10(%rax)
movq %r14, 0x18(%rax)
movq 0x28(%rbx), %rsi
cmpq 0x30(%rbx), %rsi
je 0xc10e
movq %rax, (%rsi)
addq $0x8, 0x28(%rbx)
jmp 0xc11f
addq $0x20, %rbx
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x12b64
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::Clipper::AddLocalMaxPoly(ClipperLib::TEdge*, ClipperLib::TEdge*, ClipperLib::IntPoint const&)
void Clipper::AddLocalMaxPoly(TEdge *e1, TEdge *e2, const IntPoint &Pt)
{
  AddOutPt( e1, Pt );
  if (e2->WindDelta == 0) AddOutPt(e2, Pt);
  if( e1->OutIdx == e2->OutIdx )
  {
    e1->OutIdx = Unassigned;
    e2->OutIdx = Unassigned;
  }
  else if (e1->OutIdx < e2->OutIdx) 
    AppendPolygon(e1, e2); 
  else 
    AppendPolygon(e2, e1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rcx, %rdx
callq 0xbfae
cmpl $0x0, 0x50(%rbx)
jne 0xc15e
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0xbfae
movl 0x5c(%rbx), %eax
cmpl %eax, 0x5c(%r14)
jne 0xc17f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, 0x5c(%r14)
movl %eax, 0x5c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r15, %rdi
jge 0xc18c
movq %r14, %rsi
movq %rbx, %rdx
jmp 0xc192
movq %rbx, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xc1a2
// File: /workspace/github_cpp_makefile_star2_O3/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::Clipper::CopyAELToSEL()
void Clipper::CopyAELToSEL()
{
  TEdge* e = m_ActiveEdges;
  m_SortedEdges = e;
  while ( e )
  {
    e->PrevInSEL = e->PrevInAEL;
    e->NextInSEL = e->NextInAEL;
    e = e->NextInAEL;
  }
}

// Assembly:
movq 0xa0(%rdi), %rax
movq %rax, 0xa8(%rdi)
testq %rax, %rax
je 0xc38c
movq 0x78(%rax), %rcx
movq 0x80(%rax), %rdx
movq %rdx, 0x90(%rax)
movq %rcx, 0x88(%rax)
movq %rcx, %rax
testq %rcx, %rcx
jne 0xc36b
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::Clipper::AddGhostJoin(ClipperLib::OutPt*, ClipperLib::IntPoint)
void Clipper::AddGhostJoin(OutPt *op, const IntPoint OffPt)
{
  Join* j = new Join;
  j->OutPt1 = op;
  j->OutPt2 = 0;
  j->OffPt = OffPt;
  m_GhostJoins.push_back(j);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movl $0x20, %edi
callq 0x3210
movq %rax, (%rsp)
movq %r12, (%rax)
movq $0x0, 0x8(%rax)
movq %r15, 0x10(%rax)
movq %r14, 0x18(%rax)
movq 0x40(%rbx), %rsi
cmpq 0x48(%rbx), %rsi
je 0xc3d7
movq %rax, (%rsi)
addq $0x8, 0x40(%rbx)
jmp 0xc3e6
addq $0x38, %rbx
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x12b64
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::Clipper::InsertEdgeIntoAEL(ClipperLib::TEdge*, ClipperLib::TEdge*)
void Clipper::InsertEdgeIntoAEL(TEdge *edge, TEdge* startEdge)
{
  if(!m_ActiveEdges)
  {
    edge->PrevInAEL = 0;
    edge->NextInAEL = 0;
    m_ActiveEdges = edge;
  }
  else if(!startEdge && E2InsertsBeforeE1(*m_ActiveEdges, *edge))
  {
      edge->PrevInAEL = 0;
      edge->NextInAEL = m_ActiveEdges;
      m_ActiveEdges->PrevInAEL = edge;
      m_ActiveEdges = edge;
  } 
  else
  {
    if(!startEdge) startEdge = m_ActiveEdges;
    while(startEdge->NextInAEL  && 
      !E2InsertsBeforeE1(*startEdge->NextInAEL , *edge))
        startEdge = startEdge->NextInAEL;
    edge->NextInAEL = startEdge->NextInAEL;
    if(startEdge->NextInAEL) startEdge->NextInAEL->PrevInAEL = edge;
    edge->PrevInAEL = startEdge;
    startEdge->NextInAEL = edge;
  }
}

// Assembly:
movq 0xa0(%rdi), %rax
addq $0xa0, %rdi
testq %rax, %rax
je 0xc475
testq %rdx, %rdx
jne 0xc4c7
movq 0x10(%rax), %rcx
cmpq %rcx, 0x10(%rsi)
jne 0xc458
movq 0x28(%rsi), %rcx
movq 0x28(%rax), %rdx
cmpq %rdx, %rcx
jle 0xc483
subq 0x8(%rax), %rcx
cvtsi2sd %rcx, %xmm0
mulsd 0x40(%rax), %xmm0
xorpd %xmm1, %xmm1
xorl %ecx, %ecx
ucomisd %xmm0, %xmm1
seta %cl
leaq 0x92a9(%rip), %rdx      # 0x156f0
addsd (%rdx,%rcx,8), %xmm0
cvttsd2si %xmm0, %rcx
addq (%rax), %rcx
cmpq %rcx, 0x20(%rsi)
jge 0xc4c4
movq $0x0, 0x80(%rsi)
movq %rax, 0x78(%rsi)
movq %rsi, 0x80(%rax)
jmp 0xc59d
xorpd %xmm0, %xmm0
movupd %xmm0, 0x78(%rsi)
jmp 0xc59d
movq 0x20(%rax), %rcx
jne 0xc48f
movq 0x20(%rsi), %rdx
jmp 0xc4bf
subq 0x8(%rsi), %rdx
cvtsi2sd %rdx, %xmm0
mulsd 0x40(%rsi), %xmm0
xorpd %xmm1, %xmm1
xorl %edx, %edx
ucomisd %xmm0, %xmm1
seta %dl
leaq 0x923f(%rip), %r8       # 0x156f0
addsd (%r8,%rdx,8), %xmm0
cvttsd2si %xmm0, %rdx
addq (%rsi), %rdx
cmpq %rdx, %rcx
jg 0xc45a
movq %rax, %rdx
movq 0x78(%rdx), %r8
testq %r8, %r8
je 0xc579
movq 0x10(%rsi), %rcx
xorpd %xmm0, %xmm0
leaq 0x920d(%rip), %rdi      # 0x156f0
movq %rdx, %rax
movq %rax, %rdx
movq %r8, %rax
cmpq 0x10(%r8), %rcx
jne 0xc52d
movq 0x28(%rsi), %r9
movq 0x28(%rax), %r8
cmpq %r8, %r9
jle 0xc531
subq 0x8(%rax), %r9
xorps %xmm1, %xmm1
cvtsi2sd %r9, %xmm1
mulsd 0x40(%rax), %xmm1
xorl %r8d, %r8d
ucomisd %xmm1, %xmm0
seta %r8b
addsd (%rdi,%r8,8), %xmm1
cvttsd2si %xmm1, %r8
addq (%rax), %r8
cmpq %r8, 0x20(%rsi)
jge 0xc569
jmp 0xc57b
jne 0xc539
movq 0x20(%rsi), %r8
jmp 0xc563
subq 0x8(%rsi), %r8
xorps %xmm1, %xmm1
cvtsi2sd %r8, %xmm1
mulsd 0x40(%rsi), %xmm1
xorl %r8d, %r8d
ucomisd %xmm1, %xmm0
seta %r8b
addsd (%rdi,%r8,8), %xmm1
cvttsd2si %xmm1, %r8
addq (%rsi), %r8
cmpq %r8, 0x20(%rax)
jg 0xc57b
movq 0x78(%rax), %r8
testq %r8, %r8
jne 0xc4e6
movq %rax, %rdx
xorl %eax, %eax
movq %rax, 0x78(%rsi)
movq 0x78(%rdx), %rax
testq %rax, %rax
je 0xc58f
movq %rsi, 0x80(%rax)
movq %rdx, 0x80(%rsi)
addq $0x78, %rdx
movq %rdx, %rdi
movq %rsi, (%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::Clipper::DeleteFromAEL(ClipperLib::TEdge*)
void Clipper::DeleteFromAEL(TEdge *e)
{
  TEdge* AelPrev = e->PrevInAEL;
  TEdge* AelNext = e->NextInAEL;
  if(  !AelPrev &&  !AelNext && (e != m_ActiveEdges) ) return; //already deleted
  if( AelPrev ) AelPrev->NextInAEL = AelNext;
  else m_ActiveEdges = AelNext;
  if( AelNext ) AelNext->PrevInAEL = AelPrev;
  e->NextInAEL = 0;
  e->PrevInAEL = 0;
}

// Assembly:
movq 0x78(%rsi), %rax
movq 0x80(%rsi), %rcx
testq %rcx, %rcx
jne 0xc9c1
testq %rax, %rax
jne 0xc9c1
cmpq %rsi, 0xa0(%rdi)
je 0xc9c1
retq
addq $0x78, %rsi
addq $0xa0, %rdi
leaq 0x78(%rcx), %rdx
testq %rcx, %rcx
cmoveq %rdi, %rdx
movq %rax, (%rdx)
testq %rax, %rax
je 0xc9e6
movq %rcx, 0x80(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::Clipper::DeleteFromSEL(ClipperLib::TEdge*)
void Clipper::DeleteFromSEL(TEdge *e)
{
  TEdge* SelPrev = e->PrevInSEL;
  TEdge* SelNext = e->NextInSEL;
  if( !SelPrev &&  !SelNext && (e != m_SortedEdges) ) return; //already deleted
  if( SelPrev ) SelPrev->NextInSEL = SelNext;
  else m_SortedEdges = SelNext;
  if( SelNext ) SelNext->PrevInSEL = SelPrev;
  e->NextInSEL = 0;
  e->PrevInSEL = 0;
}

// Assembly:
movq 0x88(%rsi), %rax
movq 0x90(%rsi), %rcx
testq %rcx, %rcx
jne 0xca10
testq %rax, %rax
jne 0xca10
cmpq %rsi, 0xa8(%rdi)
je 0xca10
retq
addq $0x88, %rsi
addq $0xa8, %rdi
leaq 0x88(%rcx), %rdx
testq %rcx, %rcx
cmoveq %rdi, %rdx
movq %rax, (%rdx)
testq %rax, %rax
je 0xca3b
movq %rcx, 0x90(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::Clipper::SetHoleState(ClipperLib::TEdge*, ClipperLib::OutRec*)
void Clipper::SetHoleState(TEdge *e, OutRec *outrec)
{
  bool IsHole = false;
  TEdge *e2 = e->PrevInAEL;
  while (e2)
  {
    if (e2->OutIdx >= 0 && e2->WindDelta != 0)
    {
      IsHole = !IsHole;
      if (! outrec->FirstLeft)
        outrec->FirstLeft = m_PolyOuts[e2->OutIdx];
    }
    e2 = e2->PrevInAEL;
  }
  if (IsHole) outrec->IsHole = true;
}

// Assembly:
movq 0x80(%rsi), %rax
testq %rax, %rax
je 0xca8a
movq 0x8(%rdi), %rsi
xorl %ecx, %ecx
movslq 0x5c(%rax), %rdi
testq %rdi, %rdi
js 0xca75
cmpl $0x0, 0x50(%rax)
je 0xca75
xorb $0x1, %cl
cmpq $0x0, 0x8(%rdx)
jne 0xca75
movq (%rsi,%rdi,8), %rdi
movq %rdi, 0x8(%rdx)
movq 0x80(%rax), %rax
testq %rax, %rax
jne 0xca54
testb $0x1, %cl
je 0xca8a
movb $0x1, 0x4(%rdx)
retq
// File: /workspace/github_cpp_makefile_star2_O3/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::GetLowermostRec(ClipperLib::OutRec*, ClipperLib::OutRec*)
OutRec* GetLowermostRec(OutRec *outRec1, OutRec *outRec2)
{
  //work out which polygon fragment has the correct hole state ...
  if (!outRec1->BottomPt) 
    outRec1->BottomPt = GetBottomPt(outRec1->Pts);
  if (!outRec2->BottomPt) 
    outRec2->BottomPt = GetBottomPt(outRec2->Pts);
  OutPt *OutPt1 = outRec1->BottomPt;
  OutPt *OutPt2 = outRec2->BottomPt;
  if (OutPt1->Pt.Y > OutPt2->Pt.Y) return outRec1;
  else if (OutPt1->Pt.Y < OutPt2->Pt.Y) return outRec2;
  else if (OutPt1->Pt.X < OutPt2->Pt.X) return outRec1;
  else if (OutPt1->Pt.X > OutPt2->Pt.X) return outRec2;
  else if (OutPt1->Next == OutPt1) return outRec2;
  else if (OutPt2->Next == OutPt2) return outRec1;
  else if (FirstIsBottomPt(OutPt1, OutPt2)) return outRec1;
  else return outRec2;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rdi), %rax
testq %rax, %rax
jne 0xcaab
movq 0x18(%rbx), %rdi
callq 0x9117
movq %rax, 0x20(%rbx)
movq 0x20(%r14), %rsi
testq %rsi, %rsi
jne 0xcac8
movq 0x18(%r14), %rdi
callq 0x9117
movq %rax, %rsi
movq %rax, 0x20(%r14)
movq 0x20(%rbx), %rax
movq 0x10(%rsi), %rcx
cmpq %rcx, 0x10(%rax)
jg 0xcae3
jge 0xcad9
movq %r14, %rbx
jmp 0xcae3
movq 0x8(%rsi), %rcx
cmpq %rcx, 0x8(%rax)
jge 0xcaee
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jg 0xcad4
cmpq %rax, 0x18(%rax)
je 0xcad4
cmpq %rsi, 0x18(%rsi)
je 0xcae3
movq %rax, %rdi
callq 0x8fc3
testb %al, %al
cmoveq %r14, %rbx
jmp 0xcae3
// File: /workspace/github_cpp_makefile_star2_O3/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::Clipper::CreateOutRec()
OutRec* Clipper::CreateOutRec()
{
  OutRec* result = new OutRec;
  result->IsHole = false;
  result->IsOpen = false;
  result->FirstLeft = 0;
  result->Pts = 0;
  result->BottomPt = 0;
  result->PolyNd = 0;
  m_PolyOuts.push_back(result);
  result->Idx = (int)m_PolyOuts.size()-1;
  return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movl $0x28, %edi
callq 0x3210
movq %rax, 0x8(%rsp)
movw $0x0, 0x4(%rax)
leaq 0x8(%r14), %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x8(%rax)
movq 0x10(%r14), %rsi
cmpq 0x18(%r14), %rsi
je 0xcb89
movq %rax, (%rsi)
movq 0x10(%r14), %rcx
addq $0x8, %rcx
movq %rcx, 0x10(%r14)
jmp 0xcba0
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rdx
callq 0x12dae
movq 0x10(%r14), %rcx
movq (%r15), %rax
subq (%rbx), %rcx
shrq $0x3, %rcx
decl %ecx
movl %ecx, (%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::GetMaximaPair(ClipperLib::TEdge*)
TEdge *GetMaximaPair(TEdge *e)
{
  TEdge* result = 0;
  if ((e->Next->Top == e->Top) && !e->Next->NextInLML)
    result = e->Next;
  else if ((e->Prev->Top == e->Top) && !e->Prev->NextInLML)
    result = e->Prev;

  if (result && (result->OutIdx == Skip ||
    //result is false if both NextInAEL & PrevInAEL are nil & not horizontal ...
    (result->NextInAEL == result->PrevInAEL && !IsHorizontal(*result))))
      return 0;
  return result;
}

// Assembly:
movq 0x60(%rdi), %rcx
movq 0x20(%rdi), %rsi
movq 0x28(%rdi), %rdx
cmpq %rsi, 0x20(%rcx)
jne 0xd157
cmpq %rdx, 0x28(%rcx)
jne 0xd157
cmpq $0x0, 0x70(%rcx)
je 0xd170
movq 0x68(%rdi), %rcx
xorl %eax, %eax
cmpq %rsi, 0x20(%rcx)
jne 0xd195
cmpq %rdx, 0x28(%rcx)
jne 0xd195
cmpq $0x0, 0x70(%rcx)
jne 0xd176
cmpl $-0x2, 0x5c(%rcx)
jne 0xd179
xorl %eax, %eax
retq
movq 0x78(%rcx), %rax
cmpq 0x80(%rcx), %rax
je 0xd18a
movq %rcx, %rax
retq
xorl %eax, %eax
cmpq $0x0, 0x38(%rcx)
cmoveq %rcx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::Clipper::SwapPositionsInAEL(ClipperLib::TEdge*, ClipperLib::TEdge*)
void Clipper::SwapPositionsInAEL(TEdge *Edge1, TEdge *Edge2)
{
  //check that one or other edge hasn't already been removed from AEL ...
  if (Edge1->NextInAEL == Edge1->PrevInAEL || 
    Edge2->NextInAEL == Edge2->PrevInAEL) return;

  if(  Edge1->NextInAEL == Edge2 )
  {
    TEdge* Next = Edge2->NextInAEL;
    if( Next ) Next->PrevInAEL = Edge1;
    TEdge* Prev = Edge1->PrevInAEL;
    if( Prev ) Prev->NextInAEL = Edge2;
    Edge2->PrevInAEL = Prev;
    Edge2->NextInAEL = Edge1;
    Edge1->PrevInAEL = Edge2;
    Edge1->NextInAEL = Next;
  }
  else if(  Edge2->NextInAEL == Edge1 )
  {
    TEdge* Next = Edge1->NextInAEL;
    if( Next ) Next->PrevInAEL = Edge2;
    TEdge* Prev = Edge2->PrevInAEL;
    if( Prev ) Prev->NextInAEL = Edge1;
    Edge1->PrevInAEL = Prev;
    Edge1->NextInAEL = Edge2;
    Edge2->PrevInAEL = Edge1;
    Edge2->NextInAEL = Next;
  }
  else
  {
    TEdge* Next = Edge1->NextInAEL;
    TEdge* Prev = Edge1->PrevInAEL;
    Edge1->NextInAEL = Edge2->NextInAEL;
    if( Edge1->NextInAEL ) Edge1->NextInAEL->PrevInAEL = Edge1;
    Edge1->PrevInAEL = Edge2->PrevInAEL;
    if( Edge1->PrevInAEL ) Edge1->PrevInAEL->NextInAEL = Edge1;
    Edge2->NextInAEL = Next;
    if( Edge2->NextInAEL ) Edge2->NextInAEL->PrevInAEL = Edge2;
    Edge2->PrevInAEL = Prev;
    if( Edge2->PrevInAEL ) Edge2->PrevInAEL->NextInAEL = Edge2;
  }

  if( !Edge1->PrevInAEL ) m_ActiveEdges = Edge1;
  else if( !Edge2->PrevInAEL ) m_ActiveEdges = Edge2;
}

// Assembly:
movq 0x78(%rsi), %rcx
movq 0x80(%rsi), %rax
cmpq %rax, %rcx
je 0xd29b
movq 0x78(%rdx), %r9
movq 0x80(%rdx), %r8
cmpq %r8, %r9
je 0xd29b
cmpq %rdx, %rcx
je 0xd215
cmpq %rsi, %r9
je 0xd250
movq %r9, 0x78(%rsi)
testq %r9, %r9
je 0xd1e3
movq %rsi, 0x80(%r9)
movq 0x80(%rdx), %r8
movq %r8, 0x80(%rsi)
testq %r8, %r8
je 0xd1f3
movq %rsi, 0x78(%r8)
movq %rcx, 0x78(%rdx)
testq %rcx, %rcx
je 0xd203
movq %rdx, 0x80(%rcx)
movq %rax, 0x80(%rdx)
testq %rax, %rax
je 0xd287
movq %rdx, 0x78(%rax)
jmp 0xd289
testq %r9, %r9
je 0xd228
movq %rsi, 0x80(%r9)
movq 0x80(%rsi), %rax
testq %rax, %rax
je 0xd231
movq %rdx, 0x78(%rax)
movq %rax, 0x80(%rdx)
movq %rsi, 0x78(%rdx)
movq %rdx, 0x80(%rsi)
movq %r9, 0x78(%rsi)
movq 0x80(%rdx), %rax
jmp 0xd293
testq %rcx, %rcx
je 0xd263
movq %rdx, 0x80(%rcx)
movq 0x80(%rdx), %r8
testq %r8, %r8
je 0xd26c
movq %rsi, 0x78(%r8)
movq %r8, 0x80(%rsi)
movq %rdx, 0x78(%rsi)
movq %rsi, 0x80(%rdx)
movq %rcx, 0x78(%rdx)
movq %rsi, %rax
jmp 0xd289
xorl %eax, %eax
cmpq $0x0, 0x80(%rsi)
je 0xd29c
movq %rdx, %rsi
testq %rax, %rax
je 0xd29c
retq
movq %rsi, 0xa0(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::Clipper::SwapPositionsInSEL(ClipperLib::TEdge*, ClipperLib::TEdge*)
void Clipper::SwapPositionsInSEL(TEdge *Edge1, TEdge *Edge2)
{
  if(  !( Edge1->NextInSEL ) &&  !( Edge1->PrevInSEL ) ) return;
  if(  !( Edge2->NextInSEL ) &&  !( Edge2->PrevInSEL ) ) return;

  if(  Edge1->NextInSEL == Edge2 )
  {
    TEdge* Next = Edge2->NextInSEL;
    if( Next ) Next->PrevInSEL = Edge1;
    TEdge* Prev = Edge1->PrevInSEL;
    if( Prev ) Prev->NextInSEL = Edge2;
    Edge2->PrevInSEL = Prev;
    Edge2->NextInSEL = Edge1;
    Edge1->PrevInSEL = Edge2;
    Edge1->NextInSEL = Next;
  }
  else if(  Edge2->NextInSEL == Edge1 )
  {
    TEdge* Next = Edge1->NextInSEL;
    if( Next ) Next->PrevInSEL = Edge2;
    TEdge* Prev = Edge2->PrevInSEL;
    if( Prev ) Prev->NextInSEL = Edge1;
    Edge1->PrevInSEL = Prev;
    Edge1->NextInSEL = Edge2;
    Edge2->PrevInSEL = Edge1;
    Edge2->NextInSEL = Next;
  }
  else
  {
    TEdge* Next = Edge1->NextInSEL;
    TEdge* Prev = Edge1->PrevInSEL;
    Edge1->NextInSEL = Edge2->NextInSEL;
    if( Edge1->NextInSEL ) Edge1->NextInSEL->PrevInSEL = Edge1;
    Edge1->PrevInSEL = Edge2->PrevInSEL;
    if( Edge1->PrevInSEL ) Edge1->PrevInSEL->NextInSEL = Edge1;
    Edge2->NextInSEL = Next;
    if( Edge2->NextInSEL ) Edge2->NextInSEL->PrevInSEL = Edge2;
    Edge2->PrevInSEL = Prev;
    if( Edge2->PrevInSEL ) Edge2->PrevInSEL->NextInSEL = Edge2;
  }

  if( !Edge1->PrevInSEL ) m_SortedEdges = Edge1;
  else if( !Edge2->PrevInSEL ) m_SortedEdges = Edge2;
}

// Assembly:
movq 0x88(%rsi), %rax
testq %rax, %rax
jne 0xd2be
cmpq $0x0, 0x90(%rsi)
je 0xd3f7
movq 0x88(%rdx), %r8
testq %r8, %r8
je 0xd30d
cmpq %rdx, %rax
je 0xd36d
cmpq %rsi, %r8
je 0xd3a5
movq 0x90(%rsi), %rcx
movq %r8, 0x88(%rsi)
movq %rsi, 0x90(%r8)
leaq 0x90(%rdx), %r8
movq 0x90(%rdx), %r9
movq %r9, 0x90(%rsi)
testq %r9, %r9
jne 0xd342
jmp 0xd349
movq 0x90(%rdx), %r9
testq %r9, %r9
je 0xd3f7
cmpq %rdx, %rax
je 0xd374
movq 0x90(%rsi), %rcx
movq $0x0, 0x88(%rsi)
leaq 0x90(%rdx), %r8
movq %r9, 0x90(%rsi)
movq %rsi, 0x88(%r9)
movq %rax, 0x88(%rdx)
testq %rax, %rax
je 0xd35c
movq %rdx, 0x90(%rax)
movq %rcx, (%r8)
testq %rcx, %rcx
je 0xd3e0
movq %rdx, 0x88(%rcx)
jmp 0xd3e0
movq %rsi, 0x90(%r8)
movq 0x90(%rsi), %rax
testq %rax, %rax
je 0xd387
movq %rdx, 0x88(%rax)
movq %rax, 0x90(%rdx)
movq %rsi, 0x88(%rdx)
movq %rdx, 0x90(%rsi)
movq %r8, 0x88(%rsi)
jmp 0xd3e0
testq %rax, %rax
je 0xd3b1
movq %rdx, 0x90(%rax)
movq 0x90(%rdx), %rcx
testq %rcx, %rcx
je 0xd3c4
movq %rsi, 0x88(%rcx)
movq %rcx, 0x90(%rsi)
movq %rdx, 0x88(%rsi)
movq %rsi, 0x90(%rdx)
movq %rax, 0x88(%rdx)
cmpq $0x0, 0x90(%rsi)
je 0xd3f8
cmpq $0x0, 0x90(%rdx)
movq %rdx, %rsi
je 0xd3f8
retq
movq %rsi, 0xa8(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::Clipper::UpdateEdgeIntoAEL(ClipperLib::TEdge*&)
void Clipper::UpdateEdgeIntoAEL(TEdge *&e)
{
  if( !e->NextInLML ) throw
    clipperException("UpdateEdgeIntoAEL: invalid call");

  e->NextInLML->OutIdx = e->OutIdx;
  TEdge* AelPrev = e->PrevInAEL;
  TEdge* AelNext = e->NextInAEL;
  if (AelPrev) AelPrev->NextInAEL = e->NextInLML;
  else m_ActiveEdges = e->NextInLML;
  if (AelNext) AelNext->PrevInAEL = e->NextInLML;
  e->NextInLML->Side = e->Side;
  e->NextInLML->WindDelta = e->WindDelta;
  e->NextInLML->WindCnt = e->WindCnt;
  e->NextInLML->WindCnt2 = e->WindCnt2;
  e = e->NextInLML;
  e->Curr = e->Bot;
  e->PrevInAEL = AelPrev;
  e->NextInAEL = AelNext;
  if (!IsHorizontal(*e)) InsertScanbeam(e->Top.Y);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rsi), %rcx
movq 0x70(%rcx), %rdx
testq %rdx, %rdx
je 0xd519
movl 0x5c(%rcx), %eax
movl %eax, 0x5c(%rdx)
movq 0x78(%rcx), %rax
movq 0x80(%rcx), %rcx
leaq 0xa0(%rdi), %r8
leaq 0x78(%rcx), %r9
testq %rcx, %rcx
cmoveq %r8, %r9
movq %rdx, (%r9)
testq %rax, %rax
je 0xd4c7
movq (%rsi), %rdx
movq 0x70(%rdx), %rdx
movq %rdx, 0x80(%rax)
movq (%rsi), %rdx
movq 0x70(%rdx), %r8
movups 0x4c(%rdx), %xmm0
movups %xmm0, 0x4c(%r8)
movq %r8, (%rsi)
movups (%r8), %xmm0
movups %xmm0, 0x10(%r8)
movq (%rsi), %rdx
movq %rcx, 0x80(%rdx)
movq (%rsi), %rcx
movq %rax, 0x78(%rcx)
movq (%rsi), %rax
cmpq $0x0, 0x38(%rax)
je 0xd511
movq 0x28(%rax), %rax
movq %rsp, %rsi
movq %rax, (%rsi)
addq $0x70, %rdi
callq 0x12a16
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x28, %edi
callq 0x30f0
movq %rax, %rbx
leaq 0x82d8(%rip), %rsi      # 0x15805
movq %rax, %rdi
callq 0x11cba
leaq 0xe82c(%rip), %rsi      # 0x1bd68
leaq 0x47b1(%rip), %rdx      # 0x11cf4
movq %rbx, %rdi
callq 0x3370
movq %rax, %r14
movq %rbx, %rdi
callq 0x3170
movq %r14, %rdi
callq 0x3380
// File: /workspace/github_cpp_makefile_star2_O3/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::Clipper::ProcessIntersectList()
void Clipper::ProcessIntersectList()
{
  for (size_t i = 0; i < m_IntersectList.size(); ++i)
  {
    IntersectNode* iNode = m_IntersectList[i];
    {
      IntersectEdges( iNode->Edge1, iNode->Edge2, iNode->Pt, true);
      SwapPositionsInAEL( iNode->Edge1 , iNode->Edge2 );
    }
    delete iNode;
  }
  m_IntersectList.clear();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x50(%rdi), %rax
movq 0x58(%rdi), %rcx
cmpq %rax, %rcx
je 0xdb29
xorl %r15d, %r15d
movq (%rax,%r15,8), %r14
movq (%r14), %rsi
movq 0x8(%r14), %rdx
leaq 0x10(%r14), %rcx
movq %rbx, %rdi
movl $0x1, %r8d
callq 0xc5a2
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0xd196
movl $0x20, %esi
movq %r14, %rdi
callq 0x3220
incq %r15
movq 0x50(%rbx), %rax
movq 0x58(%rbx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %rdx, %r15
jb 0xdad6
cmpq %rax, %rcx
je 0xdb32
movq %rax, 0x58(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::GetOverlap(long long, long long, long long, long long, long long&, long long&)
bool GetOverlap(const cInt a1, const cInt a2, const cInt b1, const cInt b2, 
    cInt& Left, cInt& Right)
{
  if (a1 < a2)
  {
    if (b1 < b2) {Left = std::max(a1,b1); Right = std::min(a2,b2);}
    else {Left = std::max(a1,b2); Right = std::min(a2,b1);}
  } 
  else
  {
    if (b1 < b2) {Left = std::max(a2,b1); Right = std::min(a1,b2);}
    else {Left = std::max(a2,b2); Right = std::min(a1,b1);}
  }
  return Left < Right;
}

// Assembly:
cmpq %rsi, %rdi
jge 0xddf9
cmpq %rcx, %rdx
jge 0xde11
cmpq %rdx, %rdi
cmovgq %rdi, %rdx
movq %rdx, (%r8)
cmpq %rsi, %rcx
cmovlq %rcx, %rsi
jmp 0xde38
cmpq %rcx, %rdx
jge 0xde24
cmpq %rdx, %rsi
cmovgq %rsi, %rdx
movq %rdx, (%r8)
cmpq %rdi, %rcx
cmovlq %rcx, %rdi
jmp 0xde35
cmpq %rcx, %rdi
cmovgq %rdi, %rcx
movq %rcx, (%r8)
cmpq %rsi, %rdx
cmovlq %rdx, %rsi
jmp 0xde38
cmpq %rcx, %rsi
cmovgq %rsi, %rcx
movq %rcx, (%r8)
cmpq %rdi, %rdx
cmovlq %rdx, %rdi
movq %rdi, %rsi
movq %rsi, (%r9)
cmpq %rsi, (%r8)
setl %al
retq
// File: /workspace/github_cpp_makefile_star2_O3/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::Clipper::FixupFirstLefts1(ClipperLib::OutRec*, ClipperLib::OutRec*)
void Clipper::FixupFirstLefts1(OutRec* OldOutRec, OutRec* NewOutRec)
{ 
  
  for (PolyOutList::size_type i = 0; i < m_PolyOuts.size(); ++i)
  {
    OutRec* outRec = m_PolyOuts[i];
    if (outRec->Pts && outRec->FirstLeft == OldOutRec) 
    {
      if (Poly2ContainsPoly1(outRec->Pts, NewOutRec->Pts))
        outRec->FirstLeft = NewOutRec;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, (%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %r13
movq %rax, 0x10(%rsp)
subq %rax, %r13
je 0xe7c0
sarq $0x3, %r13
cmpq $0x1, %r13
adcq $0x0, %r13
xorl %ebp, %ebp
movq 0x10(%rsp), %rax
movq (%rax,%rbp,8), %rbx
movq 0x18(%rbx), %r12
testq %r12, %r12
je 0xe7b8
movq 0x8(%rsp), %rax
cmpq %rax, 0x8(%rbx)
jne 0xe7b8
movq (%rsp), %rax
movq 0x18(%rax), %r15
movq %r12, %r14
leaq 0x8(%r14), %rdi
movq %r15, %rsi
callq 0x8851
testl %eax, %eax
jns 0xe7ae
movq 0x18(%r14), %r14
cmpq %r12, %r14
jne 0xe793
jmp 0xe7b0
je 0xe7b8
movq (%rsp), %rax
movq %rax, 0x8(%rbx)
incq %rbp
cmpq %r13, %rbp
jne 0xe76b
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::GetUnitNormal(ClipperLib::IntPoint const&, ClipperLib::IntPoint const&)
DoublePoint GetUnitNormal(const IntPoint &pt1, const IntPoint &pt2)
{
  if(pt2.X == pt1.X && pt2.Y == pt1.Y) 
    return DoublePoint(0, 0);

  double Dx = (double)(pt2.X - pt1.X);
  double dy = (double)(pt2.Y - pt1.Y);
  double f = 1 *1.0/ std::sqrt( Dx*Dx + dy*dy );
  Dx *= f;
  dy *= f;
  return DoublePoint(dy, -Dx);
}

// Assembly:
movq (%rsi), %rcx
movq 0x8(%rsi), %rax
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
movq %rcx, %rdi
xorq %rsi, %rdi
movq %rax, %r8
xorq %rdx, %r8
xorpd %xmm1, %xmm1
orq %rdi, %r8
xorpd %xmm0, %xmm0
je 0xe870
subq %rsi, %rcx
cvtsi2sd %rcx, %xmm2
subq %rdx, %rax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
movapd %xmm0, %xmm1
mulsd %xmm0, %xmm1
movapd %xmm2, %xmm3
mulsd %xmm2, %xmm3
addsd %xmm1, %xmm3
sqrtsd %xmm3, %xmm3
movsd 0x5844(%rip), %xmm1     # 0x140a0
divsd %xmm3, %xmm1
mulsd %xmm1, %xmm0
xorpd 0x5814(%rip), %xmm1     # 0x14080
mulsd %xmm2, %xmm1
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::ClipperOffset::Clear()
void ClipperOffset::Clear()
{
  for (int i = 0; i < m_polyNodes.ChildCount(); ++i)
    delete m_polyNodes.Childs[i];
  m_polyNodes.Childs.clear();
  m_lowest.X = -1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0xc8(%rdi), %rax
movq 0xd0(%rdi), %rcx
movq %rcx, %rdx
subq %rax, %rdx
shrq $0x3, %rdx
testl %edx, %edx
jle 0xe9df
xorl %r15d, %r15d
movq (%rax,%r15,8), %r14
testq %r14, %r14
je 0xe9af
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0xe99b
movq 0x28(%r14), %rsi
subq %rdi, %rsi
callq 0x3220
movq (%r14), %rdi
testq %rdi, %rdi
je 0xe9af
movq 0x10(%r14), %rsi
subq %rdi, %rsi
callq 0x3220
movl $0x48, %esi
movq %r14, %rdi
callq 0x3220
incq %r15
movq 0xc8(%rbx), %rax
movq 0xd0(%rbx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
shrq $0x3, %rdx
movslq %edx, %rdx
cmpq %rdx, %r15
jl 0xe97d
cmpq %rax, %rcx
je 0xe9eb
movq %rax, 0xd0(%rbx)
movq $-0x1, 0xa0(%rbx)
popq %rbx
popq %r14
popq %r15
retq