LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0xc384
movl 0x4c(%r15), %ebp
movq 0x8(%r12), %rcx
movq (%rcx,%rax,8), %r15
movq 0x18(%r15), %r12
cmpl $0x1, %ebp
jne 0xc3e6
movq (%rbx), %rax
cmpq 0x8(%r12), %rax
jne 0xc3fe
movq 0x10(%r12), %rax
cmpq %rax, 0x8(%rbx)
jne 0xc3fe
movq %r12, %r14
jmp 0xc43f
movq %r12, %rdi
callq 0xcee0
cmpl $0x0, 0x50(%r15)
movq %rax, %r13
sete 0x5(%rax)
movl $0x28, %edi
callq 0x3210
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
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)
cmpb $0x0, 0x5(%r13)
jne 0xc3dc
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0xcdea
movl (%r13), %eax
movl %eax, 0x5c(%r15)
jmp 0xc43f
movq 0x20(%r12), %r14
movq (%rbx), %rax
cmpq 0x8(%r14), %rax
jne 0xc3fe
movq 0x10(%r14), %rax
cmpq %rax, 0x8(%rbx)
je 0xc43f
movl $0x28, %edi
callq 0x3210
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
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 0xc43f
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_O1/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::Clipper::AddJoin(ClipperLib::OutPt*, ClipperLib::OutPt*, ClipperLib::IntPoint)
void Clipper::AddJoin(OutPt *op1, OutPt *op2, const IntPoint OffPt)
{
  Join* j = new Join;
  j->OutPt1 = op1;
  j->OutPt2 = op2;
  j->OffPt = OffPt;
  m_Joins.push_back(j);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movl $0x20, %edi
callq 0x3210
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movq %rax, 0x8(%rsp)
movq %r13, (%rax)
movq %r12, 0x8(%rax)
movq %r15, 0x10(%rax)
movq %r14, 0x18(%rax)
movq 0x28(%rbx), %rsi
cmpq 0x30(%rbx), %rsi
je 0xc4a7
movq %rax, (%rsi)
addq $0x8, 0x28(%rbx)
jmp 0xc4b8
addq $0x20, %rbx
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x13120
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xc328
cmpl $0x0, 0x50(%rbx)
jne 0xc4f6
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0xc328
movl 0x5c(%rbx), %eax
cmpl %eax, 0x5c(%r14)
jne 0xc517
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, 0x5c(%r14)
movl %eax, 0x5c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r15, %rdi
jge 0xc524
movq %r14, %rsi
movq %rbx, %rdx
jmp 0xc52a
movq %rbx, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xc53a
// File: /workspace/github_cpp_makefile_star2_O1/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 0xc740
movq 0x78(%rax), %rcx
movq 0x80(%rax), %rdx
movq %rdx, 0x90(%rax)
movq %rcx, 0x88(%rax)
movq %rcx, %rax
testq %rcx, %rcx
jne 0xc71f
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::Clipper::AddGhostJoin(ClipperLib::OutPt*, ClipperLib::IntPoint)
void Clipper::AddGhostJoin(OutPt *op, const IntPoint OffPt)
{
  Join* j = new Join;
  j->OutPt1 = op;
  j->OutPt2 = 0;
  j->OffPt = OffPt;
  m_GhostJoins.push_back(j);
}

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

// Assembly:
movq 0xa0(%rdi), %rax
addq $0xa0, %rdi
testq %rax, %rax
je 0xc819
testq %rdx, %rdx
jne 0xc88b
movq 0x10(%rax), %rcx
cmpq %rcx, 0x10(%rsi)
jne 0xc814
movq 0x28(%rsi), %rcx
movq 0x28(%rax), %rdx
cmpq %rdx, %rcx
jle 0xc827
subq 0x8(%rax), %rcx
cvtsi2sd %rcx, %xmm0
mulsd 0x40(%rax), %xmm0
xorpd %xmm1, %xmm1
xorl %ecx, %ecx
ucomisd %xmm0, %xmm1
seta %cl
leaq 0x8e8d(%rip), %rdx      # 0x15690
addsd (%rdx,%rcx,8), %xmm0
cvttsd2si %xmm0, %rcx
addq (%rax), %rcx
cmpq %rcx, 0x20(%rsi)
setl %cl
jmp 0xc869
xorpd %xmm0, %xmm0
movupd %xmm0, 0x78(%rsi)
jmp 0xc94a
movq 0x20(%rax), %rcx
jne 0xc833
movq 0x20(%rsi), %rdx
jmp 0xc863
subq 0x8(%rsi), %rdx
cvtsi2sd %rdx, %xmm0
mulsd 0x40(%rsi), %xmm0
xorpd %xmm1, %xmm1
xorl %edx, %edx
ucomisd %xmm0, %xmm1
seta %dl
leaq 0x8e3b(%rip), %r8       # 0x15690
addsd (%r8,%rdx,8), %xmm0
cvttsd2si %xmm0, %rdx
addq (%rsi), %rdx
cmpq %rdx, %rcx
setg %cl
testb %cl, %cl
je 0xc888
movq $0x0, 0x80(%rsi)
movq %rax, 0x78(%rsi)
movq %rsi, 0x80(%rax)
jmp 0xc94a
movq %rax, %rdx
xorpd %xmm0, %xmm0
leaq 0x8dfa(%rip), %rax      # 0x15690
movq %rdx, %rdi
movq 0x78(%rdx), %rdx
testq %rdx, %rdx
je 0xc92b
movq 0x10(%rdx), %rcx
cmpq %rcx, 0x10(%rsi)
jne 0xc8e8
movq 0x28(%rsi), %r8
movq 0x28(%rdx), %rcx
cmpq %rcx, %r8
jle 0xc8ed
subq 0x8(%rdx), %r8
xorps %xmm1, %xmm1
cvtsi2sd %r8, %xmm1
mulsd 0x40(%rdx), %xmm1
xorl %ecx, %ecx
ucomisd %xmm1, %xmm0
seta %cl
addsd (%rax,%rcx,8), %xmm1
cvttsd2si %xmm1, %rcx
addq (%rdx), %rcx
cmpq %rcx, 0x20(%rsi)
setl %cl
jmp 0xc923
jne 0xc8f5
movq 0x20(%rsi), %rcx
jmp 0xc91c
subq 0x8(%rsi), %rcx
xorps %xmm1, %xmm1
cvtsi2sd %rcx, %xmm1
mulsd 0x40(%rsi), %xmm1
xorl %ecx, %ecx
ucomisd %xmm1, %xmm0
seta %cl
addsd (%rax,%rcx,8), %xmm1
cvttsd2si %xmm1, %rcx
addq (%rsi), %rcx
cmpq %rcx, 0x20(%rdx)
setg %cl
testb %cl, %cl
je 0xc896
movq %rdx, 0x78(%rsi)
movq 0x78(%rdi), %rax
testq %rax, %rax
je 0xc93f
movq %rsi, 0x80(%rax)
movq %rdi, 0x80(%rsi)
addq $0x78, %rdi
movq %rsi, (%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xcd69
testq %rax, %rax
jne 0xcd69
cmpq %rsi, 0xa0(%rdi)
je 0xcd69
retq
addq $0x78, %rsi
addq $0xa0, %rdi
leaq 0x78(%rcx), %rdx
testq %rcx, %rcx
cmoveq %rdi, %rdx
movq %rax, (%rdx)
testq %rax, %rax
je 0xcd8e
movq %rcx, 0x80(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xcdb8
testq %rax, %rax
jne 0xcdb8
cmpq %rsi, 0xa8(%rdi)
je 0xcdb8
retq
addq $0x88, %rsi
addq $0xa8, %rdi
leaq 0x88(%rcx), %rdx
testq %rcx, %rcx
cmoveq %rdi, %rdx
movq %rax, (%rdx)
testq %rax, %rax
je 0xcde3
movq %rcx, 0x90(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::Clipper::SetHoleState(ClipperLib::TEdge*, ClipperLib::OutRec*)
void Clipper::SetHoleState(TEdge *e, OutRec *outrec)
{
  bool IsHole = false;
  TEdge *e2 = e->PrevInAEL;
  while (e2)
  {
    if (e2->OutIdx >= 0 && e2->WindDelta != 0)
    {
      IsHole = !IsHole;
      if (! outrec->FirstLeft)
        outrec->FirstLeft = m_PolyOuts[e2->OutIdx];
    }
    e2 = e2->PrevInAEL;
  }
  if (IsHole) outrec->IsHole = true;
}

// Assembly:
movq 0x80(%rsi), %rax
testq %rax, %rax
je 0xce32
movq 0x8(%rdi), %rsi
xorl %ecx, %ecx
movslq 0x5c(%rax), %rdi
testq %rdi, %rdi
js 0xce1d
cmpl $0x0, 0x50(%rax)
je 0xce1d
xorb $0x1, %cl
cmpq $0x0, 0x8(%rdx)
jne 0xce1d
movq (%rsi,%rdi,8), %rdi
movq %rdi, 0x8(%rdx)
movq 0x80(%rax), %rax
testq %rax, %rax
jne 0xcdfc
testb $0x1, %cl
je 0xce32
movb $0x1, 0x4(%rdx)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpq $0x0, 0x20(%rdi)
jne 0xce51
movq 0x18(%rbx), %rdi
callq 0x944d
movq %rax, 0x20(%rbx)
cmpq $0x0, 0x20(%r14)
jne 0xce65
movq 0x18(%r14), %rdi
callq 0x944d
movq %rax, 0x20(%r14)
movq 0x20(%rbx), %rdi
movq 0x20(%r14), %rsi
movq 0x10(%rsi), %rax
cmpq %rax, 0x10(%rdi)
jg 0xce88
jge 0xce7e
movq %r14, %rbx
jmp 0xce88
movq 0x8(%rsi), %rax
cmpq %rax, 0x8(%rdi)
jge 0xce93
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jg 0xce79
cmpq %rdi, 0x18(%rdi)
je 0xce79
cmpq %rsi, 0x18(%rsi)
je 0xce88
callq 0x92ed
testb %al, %al
cmoveq %r14, %rbx
jmp 0xce88
// File: /workspace/github_cpp_makefile_star2_O1/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
leaq (%rcx,%rax,8), %rdx
movq (%rdx), %rax
movslq (%rax), %rdx
leaq (%rcx,%rdx,8), %rdx
cmpq (%rdx), %rax
jne 0xcecf
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl $0x28, %edi
callq 0x3210
movq %rax, 0x8(%rsp)
movw $0x0, 0x4(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x8(%rax)
movq 0x10(%rbx), %rsi
cmpq 0x18(%rbx), %rsi
je 0xcf1c
movq %rax, (%rsi)
addq $0x8, 0x10(%rbx)
jmp 0xcf2a
leaq 0x8(%rbx), %rdi
leaq 0x8(%rsp), %rdx
callq 0x13364
movq 0x10(%rbx), %rcx
subq 0x8(%rbx), %rcx
shrq $0x3, %rcx
decl %ecx
movq 0x8(%rsp), %rax
movl %ecx, (%rax)
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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), %rax
movq 0x20(%rdi), %rdx
movq 0x28(%rdi), %rcx
cmpq %rdx, 0x20(%rax)
jne 0xd596
cmpq %rcx, 0x28(%rax)
jne 0xd596
cmpq $0x0, 0x70(%rax)
je 0xd5b3
movq 0x68(%rdi), %rsi
xorl %eax, %eax
cmpq %rdx, 0x20(%rsi)
jne 0xd5b3
cmpq %rcx, 0x28(%rsi)
jne 0xd5b3
xorl %eax, %eax
cmpq $0x0, 0x70(%rsi)
cmoveq %rsi, %rax
testq %rax, %rax
je 0xd5ce
cmpl $-0x2, 0x5c(%rax)
jne 0xd5c1
xorl %eax, %eax
retq
movq 0x78(%rax), %rcx
cmpq 0x80(%rax), %rcx
je 0xd5cf
retq
cmpq $0x0, 0x38(%rax)
jne 0xd5be
jmp 0xd5ce
// File: /workspace/github_cpp_makefile_star2_O1/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), %rax
movq 0x80(%rsi), %rcx
cmpq %rcx, %rax
je 0xd6cd
movq 0x78(%rdx), %r8
cmpq 0x80(%rdx), %r8
je 0xd6cd
cmpq %rdx, %rax
je 0xd650
cmpq %rsi, %r8
je 0xd684
movq %r8, 0x78(%rsi)
testq %r8, %r8
je 0xd617
movq %rsi, 0x80(%r8)
movq 0x80(%rdx), %r8
movq %r8, 0x80(%rsi)
testq %r8, %r8
je 0xd62e
movq %rsi, 0x78(%r8)
movq %rax, 0x78(%rdx)
testq %rax, %rax
je 0xd63e
movq %rdx, 0x80(%rax)
movq %rcx, 0x80(%rdx)
testq %rcx, %rcx
je 0xd6b6
movq %rdx, 0x78(%rcx)
jmp 0xd6b6
testq %r8, %r8
je 0xd65c
movq %rsi, 0x80(%r8)
movq 0x80(%rsi), %rax
testq %rax, %rax
je 0xd66c
movq %rdx, 0x78(%rax)
movq %rax, 0x80(%rdx)
movq %rsi, 0x78(%rdx)
movq %rdx, 0x80(%rsi)
movq %r8, 0x78(%rsi)
jmp 0xd6b6
testq %rax, %rax
je 0xd690
movq %rdx, 0x80(%rax)
movq 0x80(%rdx), %rcx
testq %rcx, %rcx
je 0xd6a0
movq %rsi, 0x78(%rcx)
movq %rcx, 0x80(%rsi)
movq %rdx, 0x78(%rsi)
movq %rsi, 0x80(%rdx)
movq %rax, 0x78(%rdx)
cmpq $0x0, 0x80(%rsi)
je 0xd6ce
cmpq $0x0, 0x80(%rdx)
movq %rdx, %rsi
je 0xd6ce
retq
movq %rsi, 0xa0(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xd6f0
cmpq $0x0, 0x90(%rsi)
je 0xd807
movq 0x88(%rdx), %rcx
testq %rcx, %rcx
jne 0xd70a
cmpq $0x0, 0x90(%rdx)
je 0xd807
cmpq %rdx, %rax
je 0xd778
cmpq %rsi, %rcx
je 0xd7b5
movq 0x90(%rsi), %r8
movq %rcx, 0x88(%rsi)
testq %rcx, %rcx
je 0xd732
movq %rsi, 0x90(%rcx)
movq 0x90(%rdx), %rcx
movq %rcx, 0x90(%rsi)
testq %rcx, %rcx
je 0xd74c
movq %rsi, 0x88(%rcx)
movq %rax, 0x88(%rdx)
testq %rax, %rax
je 0xd75f
movq %rdx, 0x90(%rax)
movq %r8, 0x90(%rdx)
testq %r8, %r8
je 0xd7f0
movq %rdx, 0x88(%r8)
jmp 0xd7f0
testq %rcx, %rcx
je 0xd784
movq %rsi, 0x90(%rcx)
movq 0x90(%rsi), %rax
testq %rax, %rax
je 0xd797
movq %rdx, 0x88(%rax)
movq %rax, 0x90(%rdx)
movq %rsi, 0x88(%rdx)
movq %rdx, 0x90(%rsi)
movq %rcx, 0x88(%rsi)
jmp 0xd7f0
testq %rax, %rax
je 0xd7c1
movq %rdx, 0x90(%rax)
movq 0x90(%rdx), %rcx
testq %rcx, %rcx
je 0xd7d4
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 0xd808
cmpq $0x0, 0x90(%rdx)
movq %rdx, %rsi
je 0xd808
retq
movq %rsi, 0xa8(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xd949
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 0xd8e1
movq (%rsi), %rdx
movq 0x70(%rdx), %rdx
movq %rdx, 0x80(%rax)
movq (%rsi), %rdx
movl 0x4c(%rdx), %r8d
movq 0x70(%rdx), %r9
movl %r8d, 0x4c(%r9)
movl 0x50(%rdx), %r8d
movl %r8d, 0x50(%r9)
movl 0x54(%rdx), %r8d
movl %r8d, 0x54(%r9)
movl 0x58(%rdx), %edx
movl %edx, 0x58(%r9)
movq %r9, (%rsi)
movups (%r9), %xmm0
movups %xmm0, 0x10(%r9)
movq (%rsi), %rdx
movq %rcx, 0x80(%rdx)
movq (%rsi), %rcx
movq %rax, 0x78(%rcx)
movq (%rsi), %rax
cmpq $0x0, 0x38(%rax)
je 0xd941
movq 0x28(%rax), %rax
movq %rsp, %rsi
movq %rax, (%rsi)
addq $0x70, %rdi
callq 0x12fd2
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x28, %edi
callq 0x30f0
movq %rax, %rbx
leaq 0x7e38(%rip), %rsi      # 0x15795
movq %rax, %rdi
callq 0x1225c
leaq 0xe3fc(%rip), %rsi      # 0x1bd68
leaq 0x4923(%rip), %rdx      # 0x12296
movq %rbx, %rdi
callq 0x3370
movq %rax, %r14
movq %rbx, %rdi
callq 0x3170
movq %r14, %rdi
callq 0x3380
// File: /workspace/github_cpp_makefile_star2_O1/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::Clipper::ProcessIntersectList()
void Clipper::ProcessIntersectList()
{
  for (size_t i = 0; i < m_IntersectList.size(); ++i)
  {
    IntersectNode* iNode = m_IntersectList[i];
    {
      IntersectEdges( iNode->Edge1, iNode->Edge2, iNode->Pt, true);
      SwapPositionsInAEL( iNode->Edge1 , iNode->Edge2 );
    }
    delete iNode;
  }
  m_IntersectList.clear();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x50(%rdi), %rax
movq 0x58(%rdi), %rcx
cmpq %rax, %rcx
je 0xdf4f
xorl %r15d, %r15d
movq (%rax,%r15,8), %r14
movq (%r14), %rsi
movq 0x8(%r14), %rdx
leaq 0x10(%r14), %rcx
movq %rbx, %rdi
movl $0x1, %r8d
callq 0xc94e
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0xd5d8
movl $0x20, %esi
movq %r14, %rdi
callq 0x3220
incq %r15
movq 0x50(%rbx), %rax
movq 0x58(%rbx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %rdx, %r15
jb 0xdefc
cmpq %rax, %rcx
je 0xdf58
movq %rax, 0x58(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 (%rdi), %xmm0
movups 0x10(%rdi), %xmm1
movaps %xmm1, -0x18(%rsp)
movq (%rsi), %rax
movq %rax, (%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rdi)
movups 0x10(%rsi), %xmm1
movups %xmm1, 0x10(%rdi)
movups %xmm0, (%rsi)
movaps -0x18(%rsp), %xmm0
movups %xmm0, 0x10(%rsi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xe215
cmpq %rcx, %rdx
jge 0xe22d
cmpq %rdx, %rdi
cmovgq %rdi, %rdx
movq %rdx, (%r8)
cmpq %rsi, %rcx
cmovlq %rcx, %rsi
jmp 0xe254
cmpq %rcx, %rdx
jge 0xe240
cmpq %rdx, %rsi
cmovgq %rsi, %rdx
movq %rdx, (%r8)
cmpq %rdi, %rcx
cmovlq %rcx, %rdi
jmp 0xe251
cmpq %rcx, %rdi
cmovgq %rdi, %rcx
movq %rcx, (%r8)
cmpq %rsi, %rdx
cmovlq %rdx, %rsi
jmp 0xe254
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_O1/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
movl $0x28, %edi
callq 0x3210
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_O1/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::Clipper::FixupFirstLefts1(ClipperLib::OutRec*, ClipperLib::OutRec*)
void Clipper::FixupFirstLefts1(OutRec* OldOutRec, OutRec* NewOutRec)
{ 
  
  for (PolyOutList::size_type i = 0; i < m_PolyOuts.size(); ++i)
  {
    OutRec* outRec = m_PolyOuts[i];
    if (outRec->Pts && outRec->FirstLeft == OldOutRec) 
    {
      if (Poly2ContainsPoly1(outRec->Pts, NewOutRec->Pts))
        outRec->FirstLeft = NewOutRec;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rcx
movq %rax, 0x20(%rsp)
subq %rax, %rcx
je 0xeb63
movq %rcx, %rax
sarq $0x3, %rax
cmpq $0x1, %rax
adcq $0x0, %rax
movq %rax, 0x18(%rsp)
xorl %ebp, %ebp
movq 0x20(%rsp), %rax
movq (%rax,%rbp,8), %rbx
movq 0x18(%rbx), %r12
testq %r12, %r12
je 0xeb59
movq 0x10(%rsp), %rax
cmpq %rax, 0x8(%rbx)
jne 0xeb59
movq 0x8(%rsp), %rax
movq 0x18(%rax), %r15
movq %r12, %r14
leaq 0x8(%r14), %rdi
movq %r15, %rsi
callq 0x8b6f
testl %eax, %eax
js 0xeb3b
setne %r13b
jmp 0xeb3f
movq 0x18(%r14), %r14
testl %eax, %eax
jns 0xeb4a
cmpq %r12, %r14
jne 0xeb25
jmp 0xeb50
testb $0x1, %r13b
je 0xeb59
movq 0x8(%rsp), %rax
movq %rax, 0x8(%rbx)
incq %rbp
cmpq 0x18(%rsp), %rbp
jne 0xeafc
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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), %rax
subq (%rdi), %rax
jne 0xebbe
movq 0x8(%rsi), %rcx
xorpd %xmm1, %xmm1
xorpd %xmm3, %xmm3
cmpq 0x8(%rdi), %rcx
je 0xec3b
subq $0x18, %rsp
xorps %xmm1, %xmm1
cvtsi2sd %rax, %xmm1
movq 0x8(%rsi), %rax
subq 0x8(%rdi), %rax
xorps %xmm3, %xmm3
cvtsi2sd %rax, %xmm3
movapd %xmm3, %xmm2
mulsd %xmm3, %xmm2
movapd %xmm1, %xmm0
mulsd %xmm1, %xmm0
addsd %xmm2, %xmm0
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm0
jb 0xebfe
sqrtsd %xmm0, %xmm0
jmp 0xec1b
movsd %xmm1, 0x10(%rsp)
movsd %xmm3, 0x8(%rsp)
callq 0x31a0
movsd 0x8(%rsp), %xmm3
movsd 0x10(%rsp), %xmm1
movsd 0x5405(%rip), %xmm2     # 0x14028
divsd %xmm0, %xmm2
mulsd %xmm2, %xmm3
xorpd 0x548d(%rip), %xmm2     # 0x140c0
mulsd %xmm2, %xmm1
addq $0x18, %rsp
movapd %xmm3, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::ClipperOffset::Clear()
void ClipperOffset::Clear()
{
  for (int i = 0; i < m_polyNodes.ChildCount(); ++i)
    delete m_polyNodes.Childs[i];
  m_polyNodes.Childs.clear();
  m_lowest.X = -1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0xd0(%rdi), %rax
subq 0xc8(%rdi), %rax
shrq $0x3, %rax
testl %eax, %eax
jle 0xeda3
xorl %r15d, %r15d
movq 0xc8(%rbx), %rax
movq (%rax,%r15,8), %r14
testq %r14, %r14
je 0xed87
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0xed66
movq 0x28(%r14), %rsi
subq %rdi, %rsi
callq 0x3220
movq (%r14), %rdi
testq %rdi, %rdi
je 0xed7a
movq 0x10(%r14), %rsi
subq %rdi, %rsi
callq 0x3220
movl $0x48, %esi
movq %r14, %rdi
callq 0x3220
movq 0xd0(%rbx), %rax
subq 0xc8(%rbx), %rax
incq %r15
shrq $0x3, %rax
cltq
cmpq %rax, %r15
jl 0xed41
movq 0xc8(%rbx), %rax
cmpq %rax, 0xd0(%rbx)
je 0xedba
movq %rax, 0xd0(%rbx)
movq $-0x1, 0xa0(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::ClipperOffset::FixOrientations()
void ClipperOffset::FixOrientations()
{
  //fixup orientations of all closed paths if the orientation of the
  //closed path with the lowermost vertex is wrong ...
  if (m_lowest.X >= 0 && 
    !Orientation(m_polyNodes.Childs[(int)m_lowest.X]->Contour))
  {
    for (int i = 0; i < m_polyNodes.ChildCount(); ++i)
    {
      PolyNode& node = *m_polyNodes.Childs[i];
      if (node.m_endtype == etClosedPolygon ||
        (node.m_endtype == etClosedLine && Orientation(node.Contour)))
          ReversePath(node.Contour);
    }
  } else
  {
    for (int i = 0; i < m_polyNodes.ChildCount(); ++i)
    {
      PolyNode& node = *m_polyNodes.Childs[i];
      if (node.m_endtype == etClosedLine && !Orientation(node.Contour))
        ReversePath(node.Contour);
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0xa0(%rdi), %rax
testq %rax, %rax
js 0xf201
movq 0xc8(%rbx), %rcx
cltq
movq (%rcx,%rax,8), %rdi
callq 0x892d
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jae 0xf201
movq 0xd0(%rbx), %rax
subq 0xc8(%rbx), %rax
shrq $0x3, %rax
testl %eax, %eax
jle 0xf2af
xorl %r15d, %r15d
movq 0xc8(%rbx), %rax
movq (%rax,%r15,8), %r14
movl 0x44(%r14), %eax
testl %eax, %eax
je 0xf18f
cmpl $0x1, %eax
jne 0xf1dc
movq %r14, %rdi
callq 0x892d
ucomisd 0x4e7b(%rip), %xmm0     # 0x14008
jb 0xf1dc
movq (%r14), %rax
movq 0x8(%r14), %rcx
cmpq %rcx, %rax
setne %dl
addq $-0x10, %rcx
cmpq %rax, %rcx
seta %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0xf1dc
addq $0x10, %rax
movups -0x10(%rax), %xmm0
movaps %xmm0, (%rsp)
movups (%rcx), %xmm0
movups %xmm0, -0x10(%rax)
movapd (%rsp), %xmm0
movupd %xmm0, (%rcx)
addq $-0x10, %rcx
leaq 0x10(%rax), %rdx
cmpq %rcx, %rax
movq %rdx, %rax
jb 0xf1b4
movq 0xd0(%rbx), %rax
subq 0xc8(%rbx), %rax
incq %r15
shrq $0x3, %rax
cltq
cmpq %rax, %r15
jl 0xf165
jmp 0xf2af
movq 0xd0(%rbx), %rax
subq 0xc8(%rbx), %rax
shrq $0x3, %rax
testl %eax, %eax
jle 0xf2af
xorl %r15d, %r15d
movq 0xc8(%rbx), %rax
movq (%rax,%r15,8), %r14
cmpl $0x1, 0x44(%r14)
jne 0xf28f
movq %r14, %rdi
callq 0x892d
ucomisd 0x4dc8(%rip), %xmm0     # 0x14008
jae 0xf28f
movq (%r14), %rax
movq 0x8(%r14), %rcx
cmpq %rcx, %rax
setne %dl
addq $-0x10, %rcx
cmpq %rax, %rcx
seta %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0xf28f
addq $0x10, %rax
movups -0x10(%rax), %xmm0
movaps %xmm0, (%rsp)
movups (%rcx), %xmm0
movups %xmm0, -0x10(%rax)
movapd (%rsp), %xmm0
movupd %xmm0, (%rcx)
addq $-0x10, %rcx
leaq 0x10(%rax), %rdx
cmpq %rcx, %rax
movq %rdx, %rax
jb 0xf267
movq 0xd0(%rbx), %rax
subq 0xc8(%rbx), %rax
incq %r15
shrq $0x3, %rax
cltq
cmpq %rax, %r15
jl 0xf21e
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::SimplifyPolygon(std::vector<ClipperLib::IntPoint, std::allocator<ClipperLib::IntPoint>> const&, std::vector<std::vector<ClipperLib::IntPoint, std::allocator<ClipperLib::IntPoint>>, std::allocator<std::vector<ClipperLib::IntPoint, std::allocator<ClipperLib::IntPoint>>>>&, ClipperLib::PolyFillType)
void SimplifyPolygon(const Path &in_poly, Paths &out_polys, PolyFillType fillType)
{
  Clipper c;
  c.StrictlySimple(true);
  c.AddPath(in_poly, ptSubject, true);
  c.Execute(ctUnion, out_polys, fillType, fillType);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rsi
leaq 0xc0(%rsp), %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
xorl %eax, %eax
movq %rax, 0x30(%rbx)
movups %xmm0, 0x8(%rbx)
leaq 0xae06(%rip), %rcx      # 0x1bcb8
movq %rcx, -0xc0(%rbx)
leaq 0xae40(%rip), %rcx      # 0x1bd00
movq %rcx, (%rbx)
leaq 0x78(%rsp), %rcx
movl $0x0, (%rcx)
movq %rax, 0x8(%rcx)
movups %xmm0, -0x70(%rcx)
movups %xmm0, -0x60(%rcx)
movups %xmm0, -0x50(%rcx)
movups %xmm0, -0x40(%rcx)
movups %xmm0, -0x30(%rcx)
movups %xmm0, -0x20(%rcx)
movq %rcx, 0x10(%rcx)
movq %rcx, 0x18(%rcx)
movb %al, 0x60(%rcx)
movups %xmm0, 0x29(%rcx)
movups %xmm0, 0x20(%rcx)
movb %al, 0x44(%rcx)
movw $0x0, 0x38(%rbx)
movb $0x1, 0x46(%rcx)
movq %rbx, %rdi
xorl %edx, %edx
movl $0x1, %ecx
callq 0x9b74
movq %rsp, %rdi
movl $0x1, %esi
movq %r14, %rdx
movl %ebp, %ecx
movl %ebp, %r8d
callq 0xa738
leaq 0xadeb(%rip), %rsi      # 0x1bd20
movq %rsp, %rdi
callq 0xa574
movq %rbx, %rdi
callq 0x9760
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
leaq 0xadc5(%rip), %rsi      # 0x1bd20
movq %rsp, %rdi
callq 0xa574
movq %rbx, %rdi
callq 0x9760
movq %r14, %rdi
callq 0x3380
// File: /workspace/github_cpp_makefile_star2_O1/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::SimplifyPolygons(std::vector<std::vector<ClipperLib::IntPoint, std::allocator<ClipperLib::IntPoint>>, std::allocator<std::vector<ClipperLib::IntPoint, std::allocator<ClipperLib::IntPoint>>>> const&, std::vector<std::vector<ClipperLib::IntPoint, std::allocator<ClipperLib::IntPoint>>, std::allocator<std::vector<ClipperLib::IntPoint, std::allocator<ClipperLib::IntPoint>>>>&, ClipperLib::PolyFillType)
void SimplifyPolygons(const Paths &in_polys, Paths &out_polys, PolyFillType fillType)
{
  Clipper c;
  c.StrictlySimple(true);
  c.AddPaths(in_polys, ptSubject, true);
  c.Execute(ctUnion, out_polys, fillType, fillType);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rsi
leaq 0xc0(%rsp), %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
xorl %eax, %eax
movq %rax, 0x30(%rbx)
movups %xmm0, 0x8(%rbx)
leaq 0xad12(%rip), %rcx      # 0x1bcb8
movq %rcx, -0xc0(%rbx)
leaq 0xad4c(%rip), %rcx      # 0x1bd00
movq %rcx, (%rbx)
leaq 0x78(%rsp), %rcx
movl $0x0, (%rcx)
movq %rax, 0x8(%rcx)
movups %xmm0, -0x70(%rcx)
movups %xmm0, -0x60(%rcx)
movups %xmm0, -0x50(%rcx)
movups %xmm0, -0x40(%rcx)
movups %xmm0, -0x30(%rcx)
movups %xmm0, -0x20(%rcx)
movq %rcx, 0x10(%rcx)
movq %rcx, 0x18(%rcx)
movb %al, 0x60(%rcx)
movups %xmm0, 0x29(%rcx)
movups %xmm0, 0x20(%rcx)
movb %al, 0x44(%rcx)
movw $0x0, 0x38(%rbx)
movb $0x1, 0x46(%rcx)
movq %rbx, %rdi
xorl %edx, %edx
movl $0x1, %ecx
callq 0xa19a
movq %rsp, %rdi
movl $0x1, %esi
movq %r14, %rdx
movl %ebp, %ecx
movl %ebp, %r8d
callq 0xa738
leaq 0xacf7(%rip), %rsi      # 0x1bd20
movq %rsp, %rdi
callq 0xa574
movq %rbx, %rdi
callq 0x9760
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
leaq 0xacd1(%rip), %rsi      # 0x1bd20
movq %rsp, %rdi
callq 0xa574
movq %rbx, %rdi
callq 0x9760
movq %r14, %rdi
callq 0x3380
// File: /workspace/github_cpp_makefile_star2_O1/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::SlopesNearCollinear(ClipperLib::IntPoint const&, ClipperLib::IntPoint const&, ClipperLib::IntPoint const&, double)
double DistanceFromLineSqrd(
  const IntPoint& pt, const IntPoint& ln1, const IntPoint& ln2)
{
  //The equation of a line in general form (Ax + By + C = 0)
  //given 2 points (x�,y�) & (x�,y�) is ...
  //(y� - y�)x + (x� - x�)y + (y� - y�)x� - (x� - x�)y� = 0
  //A = (y� - y�); B = (x� - x�); C = (y� - y�)x� - (x� - x�)y�
  //perpendicular distance of point (x�,y�) = (Ax� + By� + C)/Sqrt(A� + B�)
  //see http://en.wikipedia.org/wiki/Perpendicular_distance
  double A = double(ln1.Y - ln2.Y);
  double B = double(ln2.X - ln1.X);
  double C = A * ln1.X  + B * ln1.Y;
  C = A * pt.X + B * pt.Y - C;
  return (C * C) / (A * A + B * B);
}

// Assembly:
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
cvtsi2sd %rcx, %xmm1
subq 0x8(%rdx), %rcx
cvtsi2sd %rcx, %xmm2
movq (%rdx), %rcx
subq %rax, %rcx
cvtsi2sd %rcx, %xmm3
cvtsi2sd %rax, %xmm4
mulsd %xmm3, %xmm1
mulsd %xmm2, %xmm4
cvtsi2sdq (%rsi), %xmm5
cvtsi2sdq 0x8(%rsi), %xmm6
addsd %xmm1, %xmm4
mulsd %xmm3, %xmm6
mulsd %xmm2, %xmm5
addsd %xmm6, %xmm5
subsd %xmm4, %xmm5
mulsd %xmm5, %xmm5
mulsd %xmm3, %xmm3
mulsd %xmm2, %xmm2
addsd %xmm3, %xmm2
divsd %xmm2, %xmm5
ucomisd %xmm5, %xmm0
seta %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::ExcludeOp(ClipperLib::OutPt*)
OutPt* ExcludeOp(OutPt* op)
{
  OutPt* result = op->Prev;
  result->Next = op->Next;
  op->Next->Prev = result;
  result->Idx = 0;
  return result;
}

// Assembly:
movq 0x18(%rdi), %rcx
movq 0x20(%rdi), %rax
movq %rcx, 0x18(%rax)
movq 0x18(%rdi), %rcx
movq %rax, 0x20(%rcx)
movl $0x0, (%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O1/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::AddPolyNodeToPolygons(ClipperLib::PolyNode const&, ClipperLib::NodeType, std::vector<std::vector<ClipperLib::IntPoint, std::allocator<ClipperLib::IntPoint>>, std::allocator<std::vector<ClipperLib::IntPoint, std::allocator<ClipperLib::IntPoint>>>>&)
void AddPolyNodeToPolygons(const PolyNode& polynode, NodeType nodetype, Paths& paths)
{
  bool match = true;
  if (nodetype == ntClosed) match = !polynode.IsOpen();
  else if (nodetype == ntOpen) return;

  if (!polynode.Contour.empty() && match)
    paths.push_back(polynode.Contour);
  for (int i = 0; i < polynode.ChildCount(); ++i)
    AddPolyNodeToPolygons(*polynode.Childs[i], nodetype, paths);
}

// Assembly:
cmpl $0x1, %esi
je 0x11e8d
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
cmpl $0x2, %esi
jne 0x11e2b
movb 0x3c(%r14), %al
jmp 0x11e2d
xorl %eax, %eax
testb %al, %al
jne 0x11e45
movq 0x8(%r14), %rax
cmpq %rax, (%r14)
je 0x11e45
movq %rbx, %rdi
movq %r14, %rsi
callq 0x124c2
movq 0x18(%r14), %rax
movq 0x20(%r14), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
testl %ecx, %ecx
jle 0x11e83
xorl %r15d, %r15d
movq (%rax,%r15,8), %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x11e0c
incq %r15
movq 0x18(%r14), %rax
movq 0x20(%r14), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
movslq %ecx, %rcx
cmpq %rcx, %r15
jl 0x11e5b
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::OpenPathsFromPolyTree(ClipperLib::PolyTree&, std::vector<std::vector<ClipperLib::IntPoint, std::allocator<ClipperLib::IntPoint>>, std::allocator<std::vector<ClipperLib::IntPoint, std::allocator<ClipperLib::IntPoint>>>>&)
void OpenPathsFromPolyTree(PolyTree& polytree, Paths& paths)
{
  paths.resize(0); 
  paths.reserve(polytree.Total());
  //Open paths are top level only, so ...
  for (int i = 0; i < polytree.ChildCount(); ++i)
    if (polytree.Childs[i]->IsOpen())
      paths.push_back(polytree.Childs[i]->Contour);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
xorl %esi, %esi
callq 0x122c6
movq 0x50(%r14), %rax
subq 0x48(%r14), %rax
shrq $0x3, %rax
movslq %eax, %rsi
movq %rbx, %rdi
callq 0x12334
movq 0x18(%r14), %rax
movq 0x20(%r14), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
testl %ecx, %ecx
jle 0x11f7d
xorl %r15d, %r15d
movq (%rax,%r15,8), %rsi
cmpb $0x1, 0x3c(%rsi)
jne 0x11f63
movq %rbx, %rdi
callq 0x124c2
incq %r15
movq 0x18(%r14), %rax
movq 0x20(%r14), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
movslq %ecx, %rcx
cmpq %rcx, %r15
jl 0x11f51
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::operator<<(std::ostream&, std::vector<ClipperLib::IntPoint, std::allocator<ClipperLib::IntPoint>> const&)
std::ostream& operator <<(std::ostream &s, const Path &p)
{
  if (p.empty()) return s;
  Path::size_type last = p.size() -1;
  for (Path::size_type i = 0; i < last; i++)
    s << "(" << p[i].X << "," << p[i].Y << "), ";
  s << "(" << p[last].X << "," << p[last].Y << ")\n";
  return s;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
cmpq %rcx, %rax
je 0x120f2
movq %rsi, %r14
subq %rax, %rcx
sarq $0x4, %rcx
decq %rcx
movq %rcx, (%rsp)
je 0x1208c
xorl %r15d, %r15d
leaq 0x37d1(%rip), %r13      # 0x157f6
movq (%rsp), %r12
movl $0x1, %edx
movq %rbx, %rdi
leaq 0x37ba(%rip), %rsi      # 0x157f2
callq 0x3260
movq (%r14), %rax
movq (%rax,%r15), %rsi
movq %rbx, %rdi
callq 0x30c0
movq %rax, %rbp
movl $0x1, %edx
movq %rax, %rdi
leaq 0x3796(%rip), %rsi      # 0x157f4
callq 0x3260
movq (%r14), %rax
movq 0x8(%rax,%r15), %rsi
movq %rbp, %rdi
callq 0x30c0
movl $0x3, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x3260
addq $0x10, %r15
decq %r12
jne 0x12029
leaq 0x375f(%rip), %rsi      # 0x157f2
movl $0x1, %edx
movq %rbx, %rdi
callq 0x3260
movq (%r14), %rax
movq (%rsp), %r12
shlq $0x4, %r12
movq (%rax,%r12), %rsi
movq %rbx, %rdi
callq 0x30c0
movq %rax, %r15
leaq 0x3733(%rip), %rsi      # 0x157f4
movl $0x1, %edx
movq %rax, %rdi
callq 0x3260
movq (%r14), %rax
movq 0x8(%rax,%r12), %rsi
movq %r15, %rdi
callq 0x30c0
leaq 0x3577(%rip), %rsi      # 0x1565c
movl $0x2, %edx
movq %rax, %rdi
callq 0x3260
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::operator<<(std::ostream&, std::vector<std::vector<ClipperLib::IntPoint, std::allocator<ClipperLib::IntPoint>>, std::allocator<std::vector<ClipperLib::IntPoint, std::allocator<ClipperLib::IntPoint>>>> const&)
std::ostream& operator <<(std::ostream &s, const Paths &p)
{
  for (Paths::size_type i = 0; i < p.size(); i++)
    s << p[i];
  s << "\n";
  return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
cmpq %rsi, 0x8(%r14)
je 0x12155
xorl %r15d, %r15d
movabsq $-0x5555555555555555, %r12 # imm = 0xAAAAAAAAAAAAAAAB
xorl %r13d, %r13d
addq %r15, %rsi
movq %rbx, %rdi
callq 0x11fea
incq %r13
movq (%r14), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
sarq $0x3, %rax
imulq %r12, %rax
addq $0x18, %r15
cmpq %rax, %r13
jb 0x1212c
leaq 0x311d(%rip), %rsi      # 0x15279
movl $0x1, %edx
movq %rbx, %rdi
callq 0x3260
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/marxn[P]pupp/3rdparty/gmp/gen-psqr.c
// Function: square_mask
void
square_mask (mpz_t mask, int m)
{
  int    p, i, r, idx;

  p = mul_2exp_mod (1, mod_bits, m);
  p = neg_mod (p, m);

  mpz_set_ui (mask, 0L);
  for (i = 0; i < m; i++)
    {
      r = (i * i) % m;
      idx = (r * p) % m;
      mpz_setbit (mask, (unsigned long) idx);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl 0x75c3(%rip), %ecx      # 0x100e0
testl %ecx, %ecx
jle 0x8b38
incl %ecx
movl $0x1, %edx
addl %edx, %edx
movl %edx, %eax
cltd
idivl %ebx
decl %ecx
cmpl $0x1, %ecx
jg 0x8b28
jmp 0x8b3d
movl $0x1, %edx
testl %edx, %edx
js 0x8b8e
movl %ebx, %r15d
subl %edx, %r15d
jle 0x8b8e
testl %edx, %edx
cmovel %edx, %r15d
movl $0x0, 0x4(%r14)
testl %ebx, %ebx
jle 0x8b85
xorl %r12d, %r12d
movl %r12d, %eax
imull %r12d, %eax
xorl %edx, %edx
divl %ebx
movl %edx, %eax
imull %r15d, %eax
cltd
idivl %ebx
movslq %edx, %rsi
movq %r14, %rdi
callq 0x539d
incl %r12d
cmpl %r12d, %ebx
jne 0x8b5e
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2f6e(%rip), %rdi      # 0xbb03
leaq 0x2f77(%rip), %rsi      # 0xbb13
leaq 0x2f7b(%rip), %rcx      # 0xbb1e
movl $0xba, %edx
callq 0x10a0