LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x151a7
movq -0x10(%rbp), %rax
movb 0x4(%rax), %al
andb $0x1, %al
movzbl %al, %eax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movb 0x4(%rcx), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
je 0x151a9
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x18(%rax)
je 0x151a9
jmp 0x1521c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x19(%rbp)
je 0x151f9
movq -0x18(%rbp), %rax
movb 0x4(%rax), %al
andb $0x1, %al
movzbl %al, %ecx
movq -0x10(%rbp), %rax
movb 0x4(%rax), %al
andb $0x1, %al
movzbl %al, %edx
movb $0x1, %al
cmpl %edx, %ecx
movb %al, -0x1a(%rbp)
je 0x151f3
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
setne %al
xorb $-0x1, %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x15202
jmp 0x15210
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x151b5
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0xa8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x15c11
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x18740
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x18b50
movq -0x20(%rbp), %rax
movq 0xa8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x15bd7
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, 0xa0(%rax)
jne 0x15c4f
movb $0x1, -0x1(%rbp)
jmp 0x15d5e
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x19c90
jmp 0x15c62
movq -0x40(%rbp), %rdi
addq $0x50, %rdi
callq 0x21130
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x15cec
movb $0x1, -0x1(%rbp)
jmp 0x15d5e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
callq 0x30d0
movq -0x40(%rbp), %rdi
movq $0x0, 0xa8(%rdi)
callq 0x1a1f0
jmp 0x15cae
movl $0x28, %edi
callq 0x3110
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
leaq 0x16b24(%rip), %rsi     # 0x2c7ed
callq 0x20830
jmp 0x15cd0
movq -0x48(%rbp), %rdi
leaq 0x25085(%rip), %rsi     # 0x3ad60
leaq 0xabee(%rip), %rdx      # 0x208d0
callq 0x3430
jmp 0x15d7a
cmpq $0x1, -0x38(%rbp)
je 0x15d0a
movq -0x40(%rbp), %rdi
callq 0x19f80
movb %al, -0x49(%rbp)
jmp 0x15d01
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x15d0a
jmp 0x15d17
movq -0x40(%rbp), %rdi
callq 0x1a110
jmp 0x15d15
jmp 0x15d1d
movb $0x0, -0x1(%rbp)
jmp 0x15d5e
jmp 0x15d4b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x15d42
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x31c0
callq 0x3400
jmp 0x15d49
jmp 0x15d69
movq -0x40(%rbp), %rax
movq $0x0, 0xa8(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3440
movq %rax, %rdi
callq 0x9750
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
callq 0x20d90
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x16cc4
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
callq 0x11f20
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x16ce0
movq -0x28(%rbp), %rdi
movl $0x28, %esi
callq 0x3290
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
callq 0x20d90
movq $0x0, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rcx, -0x10(%rbp)
movq %r8, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movl $0x20, %edi
callq 0x3280
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
callq 0x20ef0
jmp 0x1788f
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rcx
movq %rcx, 0x18(%rax)
addq $0x20, %rdi
leaq -0x30(%rbp), %rsi
callq 0x20f20
addq $0x50, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
movl $0x20, %esi
callq 0x3290
movq -0x38(%rbp), %rdi
callq 0x3440
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x175e0
movq -0x18(%rbp), %rax
cmpl $0x0, 0x50(%rax)
jne 0x17948
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x175e0
movq -0x10(%rbp), %rax
movl 0x5c(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x5c(%rcx), %eax
jne 0x17970
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x5c(%rax) # imm = 0xFFFFFFFF
movq -0x18(%rbp), %rax
movl $0xffffffff, 0x5c(%rax) # imm = 0xFFFFFFFF
jmp 0x179a6
movq -0x10(%rbp), %rax
movl 0x5c(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x5c(%rcx), %eax
jge 0x17993
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x179b0
jmp 0x179a4
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x179b0
jmp 0x179a6
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::Clipper::AddEdgeToSEL(ClipperLib::TEdge*)
void Clipper::AddEdgeToSEL(TEdge *edge)
{
  //SEL pointers in PEdge are reused to build a list of horizontal edges.
  //However, we don't need to worry about order with horizontal edge processing.
  if( !m_SortedEdges )
  {
    m_SortedEdges = edge;
    edge->PrevInSEL = 0;
    edge->NextInSEL = 0;
  }
  else
  {
    edge->NextInSEL = m_SortedEdges;
    edge->PrevInSEL = 0;
    m_SortedEdges->PrevInSEL = edge;
    m_SortedEdges = edge;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0xa8(%rax)
jne 0x17cdd
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0xa8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x90(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x88(%rax)
jmp 0x17d1f
movq -0x18(%rbp), %rax
movq 0xa8(%rax), %rdx
movq -0x10(%rbp), %rcx
movq %rdx, 0x88(%rcx)
movq -0x10(%rbp), %rcx
movq $0x0, 0x90(%rcx)
movq -0x10(%rbp), %rdx
movq 0xa8(%rax), %rcx
movq %rdx, 0x90(%rcx)
movq -0x10(%rbp), %rcx
movq %rcx, 0xa8(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0xa0(%rax), %rcx
movq %rcx, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, 0xa8(%rax)
cmpq $0x0, -0x10(%rbp)
je 0x17d90
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x90(%rax)
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x88(%rax)
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x17d52
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdx, -0x10(%rbp)
movq %rcx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x20, %edi
callq 0x3280
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
callq 0x20ef0
jmp 0x17ddb
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rcx
movq %rcx, 0x18(%rax)
addq $0x38, %rdi
leaq -0x28(%rbp), %rsi
callq 0x20f20
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl $0x20, %esi
callq 0x3290
movq -0x30(%rbp), %rdi
callq 0x3440
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0xa0(%rax)
jne 0x17ea5
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq $0x0, 0x80(%rcx)
movq -0x10(%rbp), %rcx
movq $0x0, 0x78(%rcx)
movq -0x10(%rbp), %rcx
movq %rcx, 0xa0(%rax)
jmp 0x17faa
cmpq $0x0, -0x18(%rbp)
jne 0x17f0a
movq -0x20(%rbp), %rax
movq 0xa0(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x218d0
testb $0x1, %al
jne 0x17ec6
jmp 0x17f0a
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq $0x0, 0x80(%rcx)
movq 0xa0(%rax), %rdx
movq -0x10(%rbp), %rcx
movq %rdx, 0x78(%rcx)
movq -0x10(%rbp), %rdx
movq 0xa0(%rax), %rcx
movq %rdx, 0x80(%rcx)
movq -0x10(%rbp), %rcx
movq %rcx, 0xa0(%rax)
jmp 0x17fa8
cmpq $0x0, -0x18(%rbp)
jne 0x17f20
movq -0x20(%rbp), %rax
movq 0xa0(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x17f22
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x78(%rcx)
movb %al, -0x21(%rbp)
je 0x17f48
movq -0x18(%rbp), %rax
movq 0x78(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x218d0
xorb $-0x1, %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x17f51
jmp 0x17f5f
movq -0x18(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x17f22
movq -0x18(%rbp), %rax
movq 0x78(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x78(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x78(%rax)
je 0x17f8d
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x78(%rax), %rax
movq %rcx, 0x80(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x80(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x78(%rax)
jmp 0x17faa
addq $0x30, %rsp
popq %rbp
retq
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x186e0
cmpq $0x0, -0x20(%rbp)
jne 0x186e0
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
cmpq 0xa0(%rcx), %rax
je 0x186e0
jmp 0x18735
cmpq $0x0, -0x18(%rbp)
je 0x186f5
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x78(%rax)
jmp 0x18704
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0xa0(%rax)
cmpq $0x0, -0x20(%rbp)
je 0x1871a
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x80(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x78(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x80(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x88(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x18793
cmpq $0x0, -0x20(%rbp)
jne 0x18793
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
cmpq 0xa8(%rcx), %rax
je 0x18793
jmp 0x187ee
cmpq $0x0, -0x18(%rbp)
je 0x187ab
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x88(%rax)
jmp 0x187ba
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0xa8(%rax)
cmpq $0x0, -0x20(%rbp)
je 0x187d0
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x90(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x88(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x90(%rax)
popq %rbp
retq
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movb $0x0, -0x19(%rbp)
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x18882
movq -0x28(%rbp), %rax
cmpl $0x0, 0x5c(%rax)
jl 0x18871
movq -0x28(%rbp), %rax
cmpl $0x0, 0x50(%rax)
je 0x18871
movb -0x19(%rbp), %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x1886f
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
movq -0x28(%rbp), %rax
movslq 0x5c(%rax), %rsi
callq 0x20d90
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x18871
movq -0x28(%rbp), %rax
movq 0x80(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x1881f
testb $0x1, -0x19(%rbp)
je 0x18890
movq -0x18(%rbp), %rax
movb $0x1, 0x4(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x188d3
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x12620
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x188f6
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x12620
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jle 0x1892d
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x189d9
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jge 0x1894c
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x189d9
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jge 0x18968
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x189d9
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jle 0x18984
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x189d9
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
cmpq -0x20(%rbp), %rax
jne 0x1899c
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x189d9
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
cmpq -0x28(%rbp), %rax
jne 0x189b4
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x189d9
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x122d0
testb $0x1, %al
jne 0x189c7
jmp 0x189d1
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x189d9
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::Param1RightOfParam2(ClipperLib::OutRec*, ClipperLib::OutRec*)
bool Param1RightOfParam2(OutRec* outRec1, OutRec* outRec2)
{
  do
  {
    outRec1 = outRec1->FirstLeft;
    if (outRec1 == outRec2) return true;
  } while (outRec1);
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x18a18
movb $0x1, -0x1(%rbp)
jmp 0x18a25
jmp 0x18a1a
cmpq $0x0, -0x10(%rbp)
jne 0x189fc
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x8, %rdi
movslq -0xc(%rbp), %rsi
callq 0x20d90
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
addq $0x8, %rdi
movq -0x18(%rbp), %rax
movslq (%rax), %rsi
callq 0x20d90
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq (%rcx), %rax
je 0x18aa0
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rax
movslq (%rax), %rsi
callq 0x20d90
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x18a5b
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x28, %edi
callq 0x3280
movq -0x18(%rbp), %rdi
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movb $0x0, 0x4(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x5(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
addq $0x8, %rdi
leaq -0x10(%rbp), %rsi
callq 0x210c0
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x20d70
movl %eax, %ecx
subl $0x1, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rdi
addq $0x20, %rdi
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
callq 0x20480
testb $0x1, %al
jne 0x19303
jmp 0x19320
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
cmpq $0x0, 0x70(%rax)
jne 0x19320
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x1935c
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rdi
addq $0x20, %rdi
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
callq 0x20480
testb $0x1, %al
jne 0x1933f
jmp 0x1935a
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
cmpq $0x0, 0x70(%rax)
jne 0x1935a
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x1935c
cmpq $0x0, -0x18(%rbp)
je 0x19399
movq -0x18(%rbp), %rax
cmpl $-0x2, 0x5c(%rax)
je 0x1938f
movq -0x18(%rbp), %rax
movq 0x78(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x80(%rcx), %rax
jne 0x19399
movq -0x18(%rbp), %rdi
callq 0x20510
testb $0x1, %al
jne 0x19399
movq $0x0, -0x8(%rbp)
jmp 0x193a1
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::GetHorzDirection(ClipperLib::TEdge&, ClipperLib::Direction&, long long&, long long&)
void GetHorzDirection(TEdge& HorzEdge, Direction& Dir, cInt& Left, cInt& Right)
{
  if (HorzEdge.Bot.X < HorzEdge.Top.X)
  {
    Left = HorzEdge.Bot.X;
    Right = HorzEdge.Top.X;
    Dir = dLeftToRight;
  } else
  {
    Left = HorzEdge.Top.X;
    Right = HorzEdge.Bot.X;
    Dir = dRightToLeft;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jge 0x1999e
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
jmp 0x199c5
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::Clipper::PrepareHorzJoins(ClipperLib::TEdge*, bool)
void Clipper::PrepareHorzJoins(TEdge* horzEdge, bool isTopOfScanbeam)
{
  //get the last Op for this horizontal edge
  //the point may be anywhere along the horizontal ...
  OutPt* outPt = m_PolyOuts[horzEdge->OutIdx]->Pts;
  if (horzEdge->Side != esLeft) outPt = outPt->Prev;

  //First, match up overlapping horizontal edges (eg when one polygon's
  //intermediate horz edge overlaps an intermediate horz edge of another, or
  //when one polygon sits on top of another) ...
  //for (JoinList::size_type i = 0; i < m_GhostJoins.size(); ++i)
  //{
  //  Join* j = m_GhostJoins[i];
  //  if (HorzSegmentsOverlap(j->OutPt1->Pt, j->OffPt, horzEdge->Bot, horzEdge->Top))
  //      AddJoin(j->OutPt1, outPt, j->OffPt);
  //}

  //Also, since horizontal edges at the top of one SB are often removed from
  //the AEL before we process the horizontal edges at the bottom of the next,
  //we need to create 'ghost' Join records of 'contrubuting' horizontals that
  //we can compare with horizontals at the bottom of the next SB.
  if (isTopOfScanbeam) 
  {
    if (outPt->Pt == horzEdge->Top)
      AddGhostJoin(outPt, horzEdge->Bot); 
    else
      AddGhostJoin(outPt, horzEdge->Top);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x8, %rdi
movq -0x10(%rbp), %rax
movslq 0x5c(%rax), %rsi
callq 0x20d90
movq (%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1, 0x4c(%rax)
je 0x19a21
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
testb $0x1, -0x11(%rbp)
je 0x19a97
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
callq 0x20480
testb $0x1, %al
jne 0x19a42
jmp 0x19a6c
movq -0x48(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x17da0
jmp 0x19a95
movq -0x48(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq %rcx, -0x40(%rbp)
movq 0x28(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rcx
callq 0x17da0
jmp 0x19a97
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x17d30
movq -0x40(%rbp), %rdi
addq $0x50, %rdi
callq 0x21280
movq -0x40(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0x50, %rdi
callq 0x212b0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq 0x2b6(%rip), %rdx       # 0x1a280
callq 0x21230
movq -0x40(%rbp), %rdi
addq $0x50, %rdi
callq 0x21130
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x1a0fd
movq -0x40(%rbp), %rdi
addq $0x50, %rdi
movq -0x30(%rbp), %rsi
callq 0x21150
movq (%rax), %rdi
callq 0x212e0
testb $0x1, %al
jne 0x1a0ac
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rcx
xorl %eax, %eax
cmpq -0x28(%rbp), %rcx
movb %al, -0x41(%rbp)
jae 0x1a050
movq -0x40(%rbp), %rdi
addq $0x50, %rdi
movq -0x38(%rbp), %rsi
callq 0x21150
movq (%rax), %rdi
callq 0x212e0
xorb $-0x1, %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x1a059
jmp 0x1a067
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x1a023
movq -0x38(%rbp), %rax
cmpq -0x28(%rbp), %rax
jne 0x1a07a
movb $0x0, -0x1(%rbp)
jmp 0x1a101
movq -0x40(%rbp), %rdi
addq $0x50, %rdi
movq -0x30(%rbp), %rsi
callq 0x21150
movq -0x40(%rbp), %rdi
movq %rax, -0x50(%rbp)
addq $0x50, %rdi
movq -0x38(%rbp), %rsi
callq 0x21150
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x21330
movq -0x40(%rbp), %rdi
addq $0x50, %rdi
movq -0x30(%rbp), %rsi
callq 0x21150
movq -0x40(%rbp), %rdi
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x58(%rbp)
addq $0x50, %rdi
movq -0x30(%rbp), %rsi
callq 0x21150
movq -0x40(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq (%rax), %rax
movq 0x8(%rax), %rdx
callq 0x19630
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x19fe8
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
addq $0x50, %rdi
callq 0x21130
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x1a1d6
movq -0x20(%rbp), %rdi
addq $0x50, %rdi
movq -0x10(%rbp), %rsi
callq 0x21150
movq -0x20(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x18(%rbp), %rcx
addq $0x10, %rcx
movl $0x1, %r8d
callq 0x17fb0
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x193b0
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x1a1c3
movq -0x30(%rbp), %rdi
movl $0x20, %esi
callq 0x3290
jmp 0x1a1c5
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x1a12c
movq -0x20(%rbp), %rdi
addq $0x50, %rdi
callq 0x21170
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x192d0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1a30d
movq -0x10(%rbp), %rax
cmpl $0x0, 0x5c(%rax)
jl 0x1a2fb
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rdx
addq $0x20, %rdx
callq 0x175e0
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x18690
jmp 0x1a431
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x39(%rbp)
je 0x1a333
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
setne %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x1a33c
jmp 0x1a37a
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rcx
addq $0x20, %rcx
movl $0x1, %r8d
callq 0x17fb0
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x193b0
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x1a319
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x5c(%rax)
jne 0x1a3ad
movq -0x18(%rbp), %rax
cmpl $-0x1, 0x5c(%rax)
jne 0x1a3ad
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x18690
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x18690
jmp 0x1a431
movq -0x10(%rbp), %rax
cmpl $0x0, 0x5c(%rax)
jl 0x1a3df
movq -0x18(%rbp), %rax
cmpl $0x0, 0x5c(%rax)
jl 0x1a3df
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rcx
addq $0x20, %rcx
xorl %r8d, %r8d
callq 0x17fb0
jmp 0x1a42f
movl $0x28, %edi
callq 0x3110
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
leaq 0x12421(%rip), %rsi     # 0x2c81b
callq 0x20830
jmp 0x1a401
movq -0x48(%rbp), %rdi
leaq 0x20954(%rip), %rsi     # 0x3ad60
leaq 0x64bd(%rip), %rdx      # 0x208d0
callq 0x3430
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x31c0
jmp 0x1a437
jmp 0x1a431
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3440
// File: hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::PointCount(ClipperLib::OutPt*)
int PointCount(OutPt *Pts)
{
    if (!Pts) return 0;
    int result = 0;
    OutPt* p = Pts;
    do
    {
        result++;
        p = p->Next;
    }
    while (p != Pts);
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1a458
movl $0x0, -0x4(%rbp)
jmp 0x1a48c
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x1a467
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x10(%rax), %rcx
movq %rcx, -0x20(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x18(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
jge 0x1a5d4
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jge 0x1a5a4
leaq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x21850
movq (%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
leaq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x21890
movq (%rax), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
jmp 0x1a5d2
leaq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x21850
movq (%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x21890
movq (%rax), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
jmp 0x1a63e
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jge 0x1a60e
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x21850
movq (%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
leaq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x21890
movq (%rax), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
jmp 0x1a63c
leaq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x21850
movq (%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
leaq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x21890
movq (%rax), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
jmp 0x1a63e
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq -0x30(%rbp), %rcx
cmpq (%rcx), %rax
setl %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movl $0x28, %edi
callq 0x3280
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x20750
jmp 0x1a68f
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
testb $0x1, -0x9(%rbp)
je 0x1a717
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0x1a74f
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x28, %esi
callq 0x3290
jmp 0x1a759
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3440
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
addq $0x8, %rdi
callq 0x20d70
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x1b8e2
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
movq -0x20(%rbp), %rsi
callq 0x20d90
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x1b8cf
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x1b8cf
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x11850
testb $0x1, %al
jne 0x1b8c1
jmp 0x1b8cd
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x1b8cf
jmp 0x1b8d1
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1b854
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x1ba16
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x1ba16
leaq -0x10(%rbp), %rdi
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0x219d0
jmp 0x1bac5
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
subq (%rcx), %rax
cvtsi2sd %rax, %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
subq 0x8(%rcx), %rax
cvtsi2sd %rax, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x28(%rbp), %xmm0
movsd -0x28(%rbp), %xmm2
movsd -0x30(%rbp), %xmm1
mulsd -0x30(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
callq 0x31f0
movaps %xmm0, %xmm1
movsd 0xf5bc(%rip), %xmm0     # 0x2b030
divsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
mulsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x38(%rbp), %xmm0
mulsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
leaq -0x10(%rbp), %rdi
callq 0x219d0
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
addq $0xb0, %rdi
callq 0x10c70
movl %eax, %ecx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jge 0x1bcc3
movq -0x18(%rbp), %rdi
addq $0xb0, %rdi
addq $0x18, %rdi
movslq -0xc(%rbp), %rsi
callq 0x20200
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x1bcb6
movq -0x28(%rbp), %rdi
callq 0x20220
movq -0x28(%rbp), %rdi
movl $0x48, %esi
callq 0x3290
jmp 0x1bcb8
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1bc5b
movq -0x18(%rbp), %rdi
addq $0xb0, %rdi
addq $0x18, %rdi
callq 0x21a80
movq -0x18(%rbp), %rax
movq $-0x1, 0xa0(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)