LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
callq 0x9352
leaq 0x70(%rbx), %rdi
callq 0x10452
xorps %xmm0, %xmm0
movups %xmm0, 0xa0(%rbx)
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %r14
addq $0x10, %r14
movq (%r14), %r14
testq %r14, %r14
je 0x96bd
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x96c6
addq $0x18, %r14
jmp 0x96a4
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x96fd
xorl %ebp, %ebp
jmp 0x976c
movq %rdi, %rbx
movq (%rdi), %rax
movq -0x18(%rax), %rax
cmpb $0x1, 0x39(%rdi,%rax)
je 0x9777
movl %r8d, %ebp
movl %ecx, %r12d
movq %rdx, %r14
movl %esi, %r15d
movb $0x1, 0xb0(%rbx)
movq %rdx, %rdi
xorl %esi, %esi
callq 0xf6f2
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 0x975d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x97ba
movq %rbx, %rdi
callq 0x9892
movb $0x0, 0xb0(%rbx)
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x28
popq %rdi
callq 0x3100
movq %rax, %rbx
leaq 0xa02d(%rip), %rsi      # 0x137b6
movq %rax, %rdi
callq 0xf67a
leaq 0x115d0(%rip), %rsi     # 0x1ad68
leaq 0x5f15(%rip), %rdx      # 0xf6b4
movq %rbx, %rdi
callq 0x3390
movq %rax, %r14
movq %rbx, %rdi
callq 0x3180
movq %r14, %rdi
callq 0x33a0
// File: /workspace/github_cpp_makefile_star2_O2/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 0xf7b4
xorl %r13d, %r13d
movq %rsp, %r15
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r13
jae 0x986d
movq (%rax,%r13,8), %rcx
cmpq $0x0, 0x18(%rcx)
je 0x9865
andq $0x0, 0x10(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq (%rax,%r13,8), %rax
movq 0x18(%rax), %rax
movq 0x20(%rax), %r12
movq %r12, %rdi
callq 0xc4b8
cmpl $0x2, %eax
jl 0x985d
movl %eax, %ebp
movl %eax, %esi
movq %r15, %rdi
callq 0xf856
subl $0x1, %ebp
jb 0x9852
leaq 0x8(%r12), %rsi
movq %r15, %rdi
callq 0xf8fe
movq 0x20(%r12), %r12
jmp 0x9839
movq %rbx, %rdi
movq %r15, %rsi
callq 0xf91c
movq %r15, %rdi
callq 0x673c
incq %r13
jmp 0x97e8
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x987e
movq %rax, %rbx
movq %rsp, %rdi
callq 0x673c
movq %rbx, %rdi
callq 0x33a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x98e5
xorl %ebp, %ebp
jmp 0x992f
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 0x9920
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9936
movq %rbx, %rdi
callq 0x9892
movb $0x0, 0xb0(%rbx)
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x9aa4
movb 0x4(%rsi), %cl
cmpb 0x4(%rax), %cl
je 0x9aa5
cmpq $0x0, 0x18(%rax)
je 0x9aa5
retq
testq %rax, %rax
je 0x9abc
cmpb %cl, 0x4(%rax)
je 0x9ab6
cmpq $0x0, 0x18(%rax)
jne 0x9abc
movq 0x8(%rax), %rax
jmp 0x9aa5
movq %rax, 0x8(%rsi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movzbl %sil, %ebp
movq 0xa8(%rbx), %r14
testq %r14, %r14
je 0xa053
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb5f0
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0xb780
jmp 0xa02d
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xa0a5
movq %rdi, %rbx
callq 0xc03c
movq 0x58(%rbx), %rax
subq 0x50(%rbx), %rax
sarq $0x3, %rax
je 0xa0a5
cmpq $0x1, %rax
je 0xa091
movq %rbx, %rdi
callq 0xc200
testb %al, %al
je 0xa0a3
movq %rbx, %rdi
callq 0xc2d2
andq $0x0, 0xa8(%rbx)
jmp 0xa0a5
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
jmp 0xa0ae
movq %rax, %rdi
callq 0x30d0
andq $0x0, 0xa8(%rbx)
movq %rbx, %rdi
callq 0xc34a
pushq $0x28
popq %rdi
callq 0x3100
movq %rax, %rbx
leaq 0x974d(%rip), %rsi      # 0x13825
movq %rax, %rdi
callq 0xf67a
leaq 0x10c81(%rip), %rsi     # 0x1ad68
leaq 0x55c6(%rip), %rdx      # 0xf6b4
movq %rbx, %rdi
callq 0x3390
movq %rax, %r14
jmp 0xa106
movq %rax, %r14
movq %rbx, %rdi
callq 0x3180
callq 0x3370
movq %r14, %rdi
callq 0x33a0
movq %rax, %rdi
callq 0x5a3a
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x48, %rsp
andq $0x0, 0x20(%rsi)
movq %rdi, 0x8(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x18(%rsi), %r15
xorl %edx, %edx
movq 0x20(%r15), %r12
cmpq %r15, %r12
je 0xa80c
movq 0x18(%r15), %r14
cmpq %r14, %r12
je 0xa80c
movq 0x8(%r15), %r13
movq 0x10(%r15), %rbx
movq 0x8(%r14), %rbp
movq 0x10(%r14), %r9
movq %r13, %rax
xorq %rbp, %rax
movq %rbx, %rcx
xorq %r9, %rcx
orq %rax, %rcx
je 0xa7e8
movq 0x8(%r12), %rdi
movq 0x10(%r12), %rsi
movq %r13, %rax
xorq %rdi, %rax
movq %rbx, %rcx
xorq %rsi, %rcx
orq %rax, %rcx
je 0xa7e8
movq 0x8(%rsp), %rcx
movq (%rcx), %rax
movq -0x18(%rax), %rax
movq %rax, 0x30(%rsp)
movzbl 0x18(%rcx,%rax), %eax
movl %eax, (%rsp)
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq %rdx, 0x10(%rsp)
movq %r13, %rdx
movq %rbx, %rcx
movq %rsi, 0x38(%rsp)
movq %rbp, %r8
movq %r9, 0x20(%rsp)
movq 0x20(%rsp), %r9
callq 0x7f57
movq 0x38(%rsp), %rsi
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %r9
movq 0x10(%rsp), %rdx
testb %al, %al
je 0xa7d4
movq 0x8(%rsp), %rax
movq 0x30(%rsp), %rcx
cmpb $0x1, 0x38(%rax,%rcx)
jne 0xa7e8
movq %r13, %rdx
movq %rbx, %rcx
movq %rbp, %r8
callq 0x87a3
movq 0x10(%rsp), %rdx
testb %al, %al
je 0xa7e8
cmpq %rdx, %r15
je 0xa81c
testq %rdx, %rdx
cmoveq %r15, %rdx
movq %r14, %r15
jmp 0xa6f1
movq %r14, 0x18(%r12)
movq 0x18(%r15), %rax
movq %r12, 0x20(%rax)
movq 0x20(%r15), %rbx
movq %r15, %rdi
pushq $0x28
popq %rsi
callq 0x3240
movq %rbx, %r15
jmp 0xa6ef
leaq 0x40(%rsp), %rdi
movq %r15, (%rdi)
callq 0x82ba
xorl %r15d, %r15d
movq 0x28(%rsp), %rax
movq %r15, 0x18(%rax)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xa9f5
leaq 0x18(%r15), %rdi
callq 0x82ba
pushq $0x28
popq %rsi
movq %r15, %rdi
callq 0x3240
movq 0x8(%r14), %rax
andq $0x0, (%rax,%rbx,8)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xac6d
movsd 0x40(%r14), %xmm0
ucomisd 0x40(%rbp), %xmm0
jbe 0xad35
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xad78
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 0xacaa
movq 0x80(%rax), %r13
testq %r13, %r13
je 0xad23
cmpl $0x0, 0x5c(%r13)
js 0xad23
movq 0x8(%r15), %rsi
movq %r13, %rdi
callq 0xf607
movq %rax, %rbp
movq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0xf607
cmpq %rax, %rbp
jne 0xad23
movq (%rbx), %rax
movq -0x18(%rax), %rax
movzbl 0x18(%rbx,%rax), %edx
movq %r14, %rdi
movq %r13, %rsi
callq 0x7ee7
testb %al, %al
je 0xad23
cmpl $0x0, 0x50(%r14)
je 0xad23
cmpl $0x0, 0x50(%r13)
je 0xad23
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0xad78
movq 0x20(%r14), %rcx
movq 0x28(%r14), %r8
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0xae86
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %rbp, %rsi
movq %r15, %rdx
callq 0xad78
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 0xacaa
jmp 0xaca3
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xadcc
movl 0x4c(%r15), %ebp
movq 0x8(%r12), %rcx
movq (%rcx,%rax,8), %r15
movq 0x18(%r15), %r12
cmpl $0x1, %ebp
jne 0xae23
movq (%rbx), %rax
cmpq 0x8(%r12), %rax
jne 0xae3b
movq 0x10(%r12), %rax
cmpq %rax, 0x8(%rbx)
jne 0xae3b
movq %r12, %r14
jmp 0xae73
movq %r12, %rdi
callq 0xb734
movq %rax, %r13
movl 0x50(%r15), %ebp
testl %ebp, %ebp
sete 0x5(%rax)
pushq $0x28
popq %rdi
callq 0x3230
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 0xae1d
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0xb644
movl (%r13), %eax
movl %eax, 0x5c(%r15)
jmp 0xae73
movq 0x20(%r12), %r14
movq (%rbx), %rax
cmpq 0x8(%r14), %rax
jne 0xae3b
movq 0x10(%r14), %rax
cmpq %rax, 0x8(%rbx)
je 0xae73
pushq $0x28
popq %rdi
callq 0x3230
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 0xae73
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_O2/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, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
pushq $0x20
popq %rdi
callq 0x3230
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %r12, (%rax)
movq %r15, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
addq $0x20, %r13
movq %r13, %rdi
callq 0xf728
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xad78
cmpl $0x0, 0x50(%rbx)
jne 0xaf0c
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0xad78
movl 0x5c(%rbx), %eax
cmpl %eax, 0x5c(%r14)
jne 0xaf2a
orl $-0x1, 0x5c(%r14)
orl $-0x1, 0x5c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r15, %rdi
jge 0xaf37
movq %r14, %rsi
movq %rbx, %rdx
jmp 0xaf3d
movq %rbx, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xaf4e
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xb139
movq 0x78(%rax), %rcx
movq 0x80(%rax), %rdx
movq %rdx, 0x90(%rax)
movq %rcx, 0x88(%rax)
movq %rcx, %rax
jmp 0xb116
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
pushq $0x20
popq %rdi
callq 0x3230
movq %rsp, %rsi
movq %r15, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, (%rsi)
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
addq $0x38, %r12
movq %r12, %rdi
callq 0xf728
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0xa0(%rdi), %rdi
addq $0xa0, %r14
testq %rdi, %rdi
je 0xb1ec
testq %rdx, %rdx
jne 0xb1cb
movq %rbx, %rsi
callq 0xf9fb
movq (%r14), %rdx
testb %al, %al
je 0xb1cb
andq $0x0, 0x80(%rbx)
movq %rdx, 0x78(%rbx)
movq %rbx, 0x80(%rdx)
jmp 0xb211
movq %rdx, %r15
leaq 0x78(%rdx), %r14
movq 0x78(%rdx), %rdi
testq %rdi, %rdi
je 0xb1f5
movq %rbx, %rsi
callq 0xf9fb
movq (%r14), %rdx
testb %al, %al
je 0xb1cb
jmp 0xb1f7
xorps %xmm0, %xmm0
movups %xmm0, 0x78(%rbx)
jmp 0xb211
xorl %edx, %edx
movq %rdx, 0x78(%rbx)
movq (%r14), %rax
testq %rax, %rax
je 0xb20a
movq %rbx, 0x80(%rax)
movq %r15, 0x80(%rbx)
movq %rbx, (%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xb5c3
testq %rax, %rax
jne 0xb5c3
cmpq %rsi, 0xa0(%rdi)
je 0xb5c3
retq
addq $0x78, %rsi
addq $0xa0, %rdi
leaq 0x78(%rcx), %rdx
testq %rcx, %rcx
cmoveq %rdi, %rdx
movq %rax, (%rdx)
testq %rax, %rax
je 0xb5e8
movq %rcx, 0x80(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xb612
testq %rax, %rax
jne 0xb612
cmpq %rsi, 0xa8(%rdi)
je 0xb612
retq
addq $0x88, %rsi
addq $0xa8, %rdi
leaq 0x88(%rcx), %rdx
testq %rcx, %rcx
cmoveq %rdi, %rdx
movq %rax, (%rdx)
testq %rax, %rax
je 0xb63d
movq %rcx, 0x90(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x8(%rdi), %rcx
xorl %eax, %eax
movq 0x80(%rsi), %rsi
testq %rsi, %rsi
je 0xb678
movslq 0x5c(%rsi), %rdi
testq %rdi, %rdi
js 0xb64a
cmpl $0x0, 0x50(%rsi)
je 0xb64a
xorb $0x1, %al
cmpq $0x0, 0x8(%rdx)
jne 0xb64a
movq (%rcx,%rdi,8), %rdi
movq %rdi, 0x8(%rdx)
jmp 0xb64a
testb $0x1, %al
je 0xb680
movb $0x1, 0x4(%rdx)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xb6a1
movq 0x18(%rbx), %rdi
callq 0x85d9
movq %rax, 0x20(%rbx)
movq 0x20(%r14), %rsi
testq %rsi, %rsi
jne 0xb6be
movq 0x18(%r14), %rdi
callq 0x85d9
movq %rax, %rsi
movq %rax, 0x20(%r14)
movq 0x20(%rbx), %rax
movq 0x10(%rsi), %rcx
cmpq %rcx, 0x10(%rax)
jg 0xb6d9
jge 0xb6cf
movq %r14, %rbx
jmp 0xb6d9
movq 0x8(%rsi), %rcx
cmpq %rcx, 0x8(%rax)
jge 0xb6e4
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jg 0xb6ca
cmpq %rax, 0x18(%rax)
je 0xb6ca
cmpq %rsi, 0x18(%rsi)
je 0xb6d9
movq %rax, %rdi
callq 0x848e
testb %al, %al
cmoveq %r14, %rbx
jmp 0xb6d9
// File: /workspace/github_cpp_makefile_star2_O2/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::Clipper::GetOutRec(int)
OutRec* Clipper::GetOutRec(int Idx)
{
  OutRec* outrec = m_PolyOuts[Idx];
  while (outrec != m_PolyOuts[outrec->Idx])
    outrec = m_PolyOuts[outrec->Idx];
  return outrec;
}

// Assembly:
movslq %esi, %rax
movq 0x8(%rdi), %rcx
movq (%rcx,%rax,8), %rdx
movq %rdx, %rax
movslq (%rdx), %rdx
movq (%rcx,%rdx,8), %rdx
cmpq %rdx, %rax
jne 0xb723
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x28
popq %rdi
callq 0x3230
movq %rsp, %r14
movq %rax, (%r14)
andw $0x0, 0x4(%rax)
leaq 0x8(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x8(%rax)
movq %r14, %rsi
callq 0xf778
movq 0x10(%rbx), %rcx
subq 0x8(%rbx), %rcx
shrq $0x3, %rcx
decl %ecx
movq (%r14), %rax
movl %ecx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xbc3b
cmpq %rdx, 0x28(%rcx)
jne 0xbc3b
cmpq $0x0, 0x70(%rcx)
je 0xbc54
movq 0x68(%rdi), %rcx
xorl %eax, %eax
cmpq %rsi, 0x20(%rcx)
jne 0xbc79
cmpq %rdx, 0x28(%rcx)
jne 0xbc79
cmpq $0x0, 0x70(%rcx)
jne 0xbc5a
cmpl $-0x2, 0x5c(%rcx)
jne 0xbc5d
xorl %eax, %eax
retq
movq 0x78(%rcx), %rax
cmpq 0x80(%rcx), %rax
je 0xbc6e
movq %rcx, %rax
retq
xorl %eax, %eax
cmpq $0x0, 0x38(%rcx)
cmoveq %rcx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xbd7f
movq 0x78(%rdx), %r9
movq 0x80(%rdx), %r8
cmpq %r8, %r9
je 0xbd7f
cmpq %rdx, %rcx
je 0xbcf9
cmpq %rsi, %r9
je 0xbd34
movq %r9, 0x78(%rsi)
testq %r9, %r9
je 0xbcc7
movq %rsi, 0x80(%r9)
movq 0x80(%rdx), %r8
movq %r8, 0x80(%rsi)
testq %r8, %r8
je 0xbcd7
movq %rsi, 0x78(%r8)
movq %rcx, 0x78(%rdx)
testq %rcx, %rcx
je 0xbce7
movq %rdx, 0x80(%rcx)
movq %rax, 0x80(%rdx)
testq %rax, %rax
je 0xbd6b
movq %rdx, 0x78(%rax)
jmp 0xbd6d
testq %r9, %r9
je 0xbd0c
movq %rsi, 0x80(%r9)
movq 0x80(%rsi), %rax
testq %rax, %rax
je 0xbd15
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 0xbd77
testq %rcx, %rcx
je 0xbd47
movq %rdx, 0x80(%rcx)
movq 0x80(%rdx), %r8
testq %r8, %r8
je 0xbd50
movq %rsi, 0x78(%r8)
movq %r8, 0x80(%rsi)
movq %rdx, 0x78(%rsi)
movq %rsi, 0x80(%rdx)
movq %rcx, 0x78(%rdx)
movq %rsi, %rax
jmp 0xbd6d
xorl %eax, %eax
cmpq $0x0, 0x80(%rsi)
je 0xbd80
movq %rdx, %rsi
testq %rax, %rax
je 0xbd80
retq
movq %rsi, 0xa0(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xbda2
cmpq $0x0, 0x90(%rsi)
je 0xbed8
movq 0x88(%rdx), %r8
testq %r8, %r8
je 0xbdf1
cmpq %rdx, %rax
je 0xbe4e
cmpq %rsi, %r8
je 0xbe86
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 0xbe23
jmp 0xbe2a
movq 0x90(%rdx), %r9
testq %r9, %r9
je 0xbed8
cmpq %rdx, %rax
je 0xbe55
movq 0x90(%rsi), %rcx
andq $0x0, 0x88(%rsi)
leaq 0x90(%rdx), %r8
movq %r9, 0x90(%rsi)
movq %rsi, 0x88(%r9)
movq %rax, 0x88(%rdx)
testq %rax, %rax
je 0xbe3d
movq %rdx, 0x90(%rax)
movq %rcx, (%r8)
testq %rcx, %rcx
je 0xbec1
movq %rdx, 0x88(%rcx)
jmp 0xbec1
movq %rsi, 0x90(%r8)
movq 0x90(%rsi), %rax
testq %rax, %rax
je 0xbe68
movq %rdx, 0x88(%rax)
movq %rax, 0x90(%rdx)
movq %rsi, 0x88(%rdx)
movq %rdx, 0x90(%rsi)
movq %r8, 0x88(%rsi)
jmp 0xbec1
testq %rax, %rax
je 0xbe92
movq %rdx, 0x90(%rax)
movq 0x90(%rdx), %rcx
testq %rcx, %rcx
je 0xbea5
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 0xbed9
cmpq $0x0, 0x90(%rdx)
movq %rdx, %rsi
je 0xbed9
retq
movq %rsi, 0xa8(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xbff8
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 0xbfa9
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 0xbff0
movq 0x28(%rax), %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x96c6
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x28
popq %rdi
callq 0x3100
movq %rax, %rbx
leaq 0x77fb(%rip), %rsi      # 0x13805
movq %rax, %rdi
callq 0xf67a
leaq 0xed4f(%rip), %rsi      # 0x1ad68
leaq 0x3694(%rip), %rdx      # 0xf6b4
movq %rbx, %rdi
callq 0x3390
movq %rax, %r14
movq %rbx, %rdi
callq 0x3180
movq %r14, %rdi
callq 0x33a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::Clipper::FixupIntersectionOrder()
bool Clipper::FixupIntersectionOrder()
{
  //pre-condition: intersections are sorted Bottom-most first.
  //Now it's crucial that intersections are made only between adjacent edges,
  //so to ensure this the order of intersections may need adjusting ...
  CopyAELToSEL();
  std::sort(m_IntersectList.begin(), m_IntersectList.end(), IntersectListSort);
  size_t cnt = m_IntersectList.size();
  for (size_t i = 0; i < cnt; ++i) 
  {
    if (!EdgesAdjacent(*m_IntersectList[i]))
    {
      size_t j = i + 1;
      while (j < cnt && !EdgesAdjacent(*m_IntersectList[j])) j++;
      if (j == cnt)  return false;
      std::swap(m_IntersectList[i], m_IntersectList[j]);
    }
    SwapPositionsInSEL(m_IntersectList[i]->Edge1, m_IntersectList[i]->Edge2);
  }
  return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xb108
movq 0x50(%rbx), %rdi
movq 0x58(%rbx), %rsi
leaq 0x171(%rip), %rdx       # 0xc390
callq 0x10c77
movq 0x58(%rbx), %r14
subq 0x50(%rbx), %r14
sarq $0x3, %r14
pushq $0x1
popq %r12
xorl %r15d, %r15d
cmpq %r14, %r15
je 0xc2c0
movq 0x50(%rbx), %rax
movq (%rax,%r15,8), %rcx
movq (%rcx), %rsi
movq 0x8(%rcx), %rdx
cmpq %rdx, 0x88(%rsi)
je 0xc2ad
cmpq %rdx, 0x90(%rsi)
je 0xc2ad
movq %r12, %rdi
cmpq %r14, %rdi
jae 0xc2c0
movq %rdi, %rdx
movq (%rax,%rdi,8), %rdi
movq (%rdi), %rsi
movq 0x8(%rdi), %r8
cmpq %r8, 0x88(%rsi)
je 0xc28d
leaq 0x1(%rdx), %rdi
cmpq %r8, 0x90(%rsi)
jne 0xc264
cmpq %rdx, %r14
je 0xc2c0
movq (%rax,%rdx,8), %rsi
movq %rsi, (%rax,%r15,8)
movq %rcx, (%rax,%rdx,8)
movq 0x50(%rbx), %rax
movq (%rax,%r15,8), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %rbx, %rdi
callq 0xbd88
incq %r15
incq %r12
jmp 0xc237
cmpq %r14, %r15
setae %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorl %r12d, %r12d
pushq $0x1
popq %rbp
pushq $0x20
popq %r14
movq 0x50(%rbx), %rax
movq 0x58(%rbx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %rdx, %r12
jae 0xc337
movq (%rax,%r12,8), %r15
movq (%r15), %rsi
movq 0x8(%r15), %rdx
leaq 0x10(%r15), %rcx
movq %rbx, %rdi
movl %ebp, %r8d
callq 0xb21a
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0xbc7a
movq %r15, %rdi
movq %r14, %rsi
callq 0x3240
incq %r12
jmp 0xc2e7
cmpq %rax, %rcx
je 0xc340
movq %rax, 0x58(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::Clipper::DoMaxima(ClipperLib::TEdge*)
void Clipper::DoMaxima(TEdge *e)
{
  TEdge* eMaxPair = GetMaximaPair(e);
  if (!eMaxPair)
  {
    if (e->OutIdx >= 0)
      AddOutPt(e, e->Top);
    DeleteFromAEL(e);
    return;
  }

  TEdge* eNext = e->NextInAEL;
  while(eNext && eNext != eMaxPair)
  {
    IntersectEdges(e, eNext, e->Top, true);
    SwapPositionsInAEL(e, eNext);
    eNext = e->NextInAEL;
  }

  if(e->OutIdx == Unassigned && eMaxPair->OutIdx == Unassigned)
  {
    DeleteFromAEL(e);
    DeleteFromAEL(eMaxPair);
  }
  else if( e->OutIdx >= 0 && eMaxPair->OutIdx >= 0 )
  {
    IntersectEdges( e, eMaxPair, e->Top);
  }
#ifdef use_lines
  else if (e->WindDelta == 0)
  {
    if (e->OutIdx >= 0) 
    {
      AddOutPt(e, e->Top);
      e->OutIdx = Unassigned;
    }
    DeleteFromAEL(e);

    if (eMaxPair->OutIdx >= 0)
    {
      AddOutPt(eMaxPair, e->Top);
      eMaxPair->OutIdx = Unassigned;
    }
    DeleteFromAEL(eMaxPair);
  } 
#endif
  else throw clipperException("DoMaxima error");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xbc1c
testq %rax, %rax
je 0xc42c
movq %rax, %r15
leaq 0x20(%r14), %r12
pushq $0x1
popq %rbp
movq 0x78(%r14), %r13
testq %r13, %r13
je 0xc3f6
cmpq %r15, %r13
je 0xc3f6
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %r12, %rcx
movl %ebp, %r8d
callq 0xb21a
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0xbc7a
jmp 0xc3c4
movl 0x5c(%r14), %eax
cmpl $-0x1, %eax
je 0xc44a
testl %eax, %eax
js 0xc475
cmpl $0x0, 0x5c(%r15)
js 0xc475
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
xorl %r8d, %r8d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xb21a
cmpl $0x0, 0x5c(%r14)
js 0xc442
leaq 0x20(%r14), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xad78
movq %rbx, %rdi
movq %r14, %rsi
jmp 0xc462
cmpl $-0x1, 0x5c(%r15)
jne 0xc475
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb5a4
movq %rbx, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xb5a4
pushq $0x28
popq %rdi
callq 0x3100
movq %rax, %rbx
leaq 0x73cc(%rip), %rsi      # 0x13853
movq %rax, %rdi
callq 0xf67a
leaq 0xe8d2(%rip), %rsi      # 0x1ad68
leaq 0x3217(%rip), %rdx      # 0xf6b4
movq %rbx, %rdi
callq 0x3390
movq %rax, %r14
movq %rbx, %rdi
callq 0x3180
movq %r14, %rdi
callq 0x33a0
// File: /workspace/github_cpp_makefile_star2_O2/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::SwapIntersectNodes(ClipperLib::IntersectNode&, ClipperLib::IntersectNode&)
void SwapIntersectNodes(IntersectNode &int1, IntersectNode &int2)
{
  //just swap the contents (because fIntersectNodes is a single-linked-list)
  IntersectNode inode = int1; //gets a copy of Int1
  int1.Edge1 = int2.Edge1;
  int1.Edge2 = int2.Edge2;
  int1.Pt = int2.Pt;
  int2.Edge1 = inode.Edge1;
  int2.Edge2 = inode.Edge2;
  int2.Pt = inode.Pt;
}

// Assembly:
movups 0x10(%rdi), %xmm0
movaps %xmm0, -0x18(%rsp)
movups (%rsi), %xmm0
movups (%rdi), %xmm1
movups %xmm0, (%rdi)
movups 0x10(%rsi), %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm1, (%rsi)
movaps -0x18(%rsp), %xmm0
movups %xmm0, 0x10(%rsi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xc512
cmpq %rcx, %rdx
jge 0xc52a
cmpq %rdx, %rdi
cmovgq %rdi, %rdx
movq %rdx, (%r8)
cmpq %rsi, %rcx
cmovlq %rcx, %rsi
jmp 0xc551
cmpq %rcx, %rdx
jge 0xc53d
cmpq %rdx, %rsi
cmovgq %rsi, %rdx
movq %rdx, (%r8)
cmpq %rdi, %rcx
cmovlq %rcx, %rdi
jmp 0xc54e
cmpq %rcx, %rdi
cmovgq %rdi, %rcx
movq %rcx, (%r8)
cmpq %rsi, %rdx
cmovlq %rdx, %rsi
jmp 0xc551
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_O2/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::DupOutPt(ClipperLib::OutPt*, bool)
OutPt* DupOutPt(OutPt* outPt, bool InsertAfter)
{
  OutPt* result = new OutPt;
  result->Pt = outPt->Pt;
  result->Idx = outPt->Idx;
  if (InsertAfter)
  {
    result->Next = outPt->Next;
    result->Prev = outPt;
    outPt->Next->Prev = result;
    outPt->Next = result;
  } 
  else
  {
    result->Prev = outPt->Prev;
    result->Next = outPt;
    outPt->Prev->Next = result;
    outPt->Prev = result;
  }
  return result;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
pushq $0x28
popq %rdi
callq 0x3230
movups 0x8(%r14), %xmm0
movups %xmm0, 0x8(%rax)
movl (%r14), %ecx
movl %ecx, (%rax)
movl %ebx, %ecx
xorb $0x1, %cl
movzbl %cl, %ecx
movl %ebx, %edx
movq 0x18(%r14,%rcx,8), %rsi
movq %rsi, 0x18(%rax,%rcx,8)
movq %r14, 0x18(%rax,%rdx,8)
movq %rax, 0x18(%rsi,%rdx,8)
movq %rax, 0x18(%r14,%rcx,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq 0x8(%rdi), %r15
movq 0x10(%rdi), %r12
subq %r15, %r12
sarq $0x3, %r12
xorl %r13d, %r13d
cmpq %r12, %r13
jae 0xcd0f
movq (%r15,%r13,8), %rbp
movq 0x18(%rbp), %rdi
testq %rdi, %rdi
je 0xcd0a
cmpq %r14, 0x8(%rbp)
jne 0xcd0a
movq 0x18(%rbx), %rsi
callq 0x7eb3
testb %al, %al
je 0xcd0a
movq %rbx, 0x8(%rbp)
incq %r13
jmp 0xcce1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xcdb3
subq %rsi, %rcx
cvtsi2sd %rcx, %xmm2
subq %rdx, %rax
cvtsi2sd %rax, %xmm0
movapd %xmm0, %xmm1
mulsd %xmm0, %xmm1
movapd %xmm2, %xmm3
mulsd %xmm2, %xmm3
addsd %xmm1, %xmm3
sqrtsd %xmm3, %xmm3
movsd 0x52e1(%rip), %xmm1     # 0x12080
divsd %xmm3, %xmm1
mulsd %xmm1, %xmm0
xorpd 0x52a1(%rip), %xmm1     # 0x12050
mulsd %xmm2, %xmm1
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r12d, %r12d
pushq $0x48
popq %r14
movq 0xc8(%rbx), %rax
movq 0xd0(%rbx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
shrq $0x3, %rdx
movslq %edx, %rdx
cmpq %rdx, %r12
jge 0xce97
movq (%rax,%r12,8), %r15
testq %r15, %r15
je 0xce87
movq %r15, %rdi
callq 0xf5c0
movq %r15, %rdi
movq %r14, %rsi
callq 0x3240
incq %r12
jmp 0xce56
cmpq %rax, %rcx
je 0xcea3
movq %rax, 0xd0(%rbx)
orq $-0x1, 0xa0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop