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::Int128Mul(long long, long long)
Int128 Int128Mul (cInt lhs, cInt rhs)
{
  bool negate = (lhs < 0) != (rhs < 0);

  if (lhs < 0) lhs = -lhs;
  ulong64 int1Hi = ulong64(lhs) >> 32;
  ulong64 int1Lo = ulong64(lhs & 0xFFFFFFFF);

  if (rhs < 0) rhs = -rhs;
  ulong64 int2Hi = ulong64(rhs) >> 32;
  ulong64 int2Lo = ulong64(rhs & 0xFFFFFFFF);

  //nb: see comments in clipper.pas
  ulong64 a = int1Hi * int2Hi;
  ulong64 b = int1Lo * int2Lo;
  ulong64 c = int1Hi * int2Lo + int1Lo * int2Hi;

  Int128 tmp;
  tmp.hi = cInt(a + (c >> 32));
  tmp.lo = cInt(c << 32);
  tmp.lo += cInt(b);
  if (tmp.lo < b) tmp.hi++;
  if (negate) tmp = -tmp;
  return tmp;
}

// Assembly:
movq %rdi, %rax
movq %rdx, %rcx
xorq %rsi, %rcx
movq %rsi, %rdi
negq %rdi
cmovsq %rsi, %rdi
movl %edi, %esi
shrq $0x20, %rdi
movq %rdx, %r8
negq %r8
cmovsq %rdx, %r8
movl %r8d, %r9d
movq %r8, %rdx
shrq $0x20, %rdx
movq %rdx, %r8
imulq %rdi, %r8
imulq %r9, %rdi
imulq %rsi, %r9
imulq %rsi, %rdx
addq %rdi, %rdx
movq %rdx, %rsi
shrq $0x20, %rsi
addq %r8, %rsi
movq %rsi, 0x8(%rax)
shlq $0x20, %rdx
addq %r9, %rdx
movq %rdx, (%rax)
jae 0x88f8
incq %rsi
movq %rsi, 0x8(%rax)
testq %rcx, %rcx
js 0x88fe
retq
movq 0x8(%rax), %rcx
movq %rcx, %rsi
negq %rsi
negq %rdx
notq %rcx
cmovaeq %rsi, %rcx
movq %rdx, (%rax)
movq %rcx, 0x8(%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O1/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::Area(ClipperLib::OutRec const&)
double Area(const OutRec &outRec)
{
  OutPt *op = outRec.Pts;
  if (!op) return 0;
  double a = 0;
  do {
    a +=  (double)(op->Prev->Pt.X + op->Pt.X) * (double)(op->Prev->Pt.Y - op->Pt.Y);
    op = op->Next;
  } while (op != outRec.Pts);
  return a * 0.5;
}

// Assembly:
movq 0x18(%rdi), %rax
xorpd %xmm0, %xmm0
testq %rax, %rax
je 0x89f7
movq %rax, %rcx
movq 0x20(%rcx), %rdx
movq 0x10(%rdx), %rsi
subq 0x10(%rcx), %rsi
movq 0x8(%rcx), %rdi
movq 0x18(%rcx), %r8
addq 0x8(%rdx), %rdi
xorps %xmm1, %xmm1
cvtsi2sd %rdi, %xmm1
xorps %xmm2, %xmm2
cvtsi2sd %rsi, %xmm2
mulsd %xmm1, %xmm2
addsd %xmm2, %xmm0
movq %r8, %rcx
cmpq %rax, %r8
jne 0x89b7
mulsd 0xb621(%rip), %xmm0     # 0x14018
retq
// File: /workspace/github_cpp_makefile_star2_O1/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::PointIsVertex(ClipperLib::IntPoint const&, ClipperLib::OutPt*)
bool PointIsVertex(const IntPoint &Pt, OutPt *pp)
{
  OutPt *pp2 = pp;
  do
  {
    if (pp2->Pt == Pt) return true;
    pp2 = pp2->Next;
  }
  while (pp2 != pp);
  return false;
}

// Assembly:
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
movq %rsi, %rdi
movq 0x8(%rdi), %rax
xorq %rcx, %rax
movq 0x10(%rdi), %r8
xorq %rdx, %r8
orq %rax, %r8
sete %al
je 0x8a21
movq 0x18(%rdi), %rdi
cmpq %rsi, %rdi
jne 0x8a02
retq
// File: /workspace/github_cpp_makefile_star2_O1/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::PointInPolygon(ClipperLib::IntPoint const&, ClipperLib::OutPt*)
int PointInPolygon (const IntPoint &pt, OutPt *op)
{
  //returns 0 if false, +1 if true, -1 if pt ON polygon boundary
  //http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.88.5498&rep=rep1&type=pdf
  int result = 0;
  OutPt* startOp = op;
  for(;;)
  {
    if (op->Next->Pt.Y == pt.Y)
    {
        if ((op->Next->Pt.X == pt.X) || (op->Pt.Y == pt.Y && 
          ((op->Next->Pt.X > pt.X) == (op->Pt.X < pt.X)))) return -1;
    }
    if ((op->Pt.Y < pt.Y) != (op->Next->Pt.Y < pt.Y))
    {
      if (op->Pt.X >= pt.X)
      {
        if (op->Next->Pt.X > pt.X) result = 1 - result;
        else
        {
          double d = (double)(op->Pt.X - pt.X) * (op->Next->Pt.Y - pt.Y) - 
            (double)(op->Next->Pt.X - pt.X) * (op->Pt.Y - pt.Y);
          if (!d) return -1;
          if ((d > 0) == (op->Next->Pt.Y > op->Pt.Y)) result = 1 - result;
        }
      } else
      {
        if (op->Next->Pt.X > pt.X)
        {
          double d = (double)(op->Pt.X - pt.X) * (op->Next->Pt.Y - pt.Y) - 
            (double)(op->Next->Pt.X - pt.X) * (op->Pt.Y - pt.Y);
          if (!d) return -1;
          if ((d > 0) == (op->Next->Pt.Y > op->Pt.Y)) result = 1 - result;
        }
      }
    } 
    op = op->Next;
    if (startOp == op) break;
  } 
  return result;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
xorl %edi, %edi
xorpd %xmm0, %xmm0
movq %rsi, %r8
movq %r8, %r11
movq 0x18(%r8), %r8
movq 0x10(%r8), %r9
cmpq %rdx, %r9
jne 0x8bc2
movq 0x8(%r8), %r10
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rcx, %r10
je 0x8c6d
cmpq %rdx, 0x10(%r11)
jne 0x8bc2
cmpq %rcx, %r10
setg %r10b
cmpq %rcx, 0x8(%r11)
setge %bl
xorb %r10b, %bl
jne 0x8c6d
movq 0x10(%r11), %rax
movq %rax, %r10
subq %rdx, %r10
setl %bpl
movq %r9, %rbx
subq %rdx, %rbx
setge %r14b
xorb %bpl, %r14b
jne 0x8c5b
movq 0x8(%r11), %r14
movq 0x8(%r8), %r11
subq %rcx, %r14
jge 0x8bf3
subq %rcx, %r11
jg 0x8c03
jmp 0x8c5b
subq %rcx, %r11
jle 0x8c03
movl $0x1, %eax
subl %edi, %eax
movl %eax, %edi
jmp 0x8c5b
xorps %xmm2, %xmm2
cvtsi2sd %r14, %xmm2
xorps %xmm1, %xmm1
cvtsi2sd %rbx, %xmm1
mulsd %xmm2, %xmm1
xorps %xmm2, %xmm2
cvtsi2sd %r11, %xmm2
xorps %xmm3, %xmm3
cvtsi2sd %r10, %xmm3
mulsd %xmm2, %xmm3
subsd %xmm3, %xmm1
ucomisd %xmm0, %xmm1
jne 0x8c37
jnp 0x8c53
seta %r10b
cmpq %rax, %r9
setle %al
xorb %r10b, %al
movl $0x1, %r9d
subl %edi, %r9d
testb %al, %al
cmovnel %r9d, %edi
ucomisd %xmm0, %xmm1
jne 0x8c5b
jnp 0x8c68
movl %edi, %eax
cmpq %rsi, %r8
jne 0x8b83
jmp 0x8c6d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::Poly2ContainsPoly1(ClipperLib::OutPt*, ClipperLib::OutPt*)
bool Poly2ContainsPoly1(OutPt *OutPt1, OutPt *OutPt2)
{
  OutPt* op = OutPt1;
  do
  {
    int res = PointInPolygon(op->Pt, OutPt2);
    if (res >= 0) return res != 0;
    op = op->Next; 
  }
  while (op != OutPt1);
  return true; 
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movq %rdi, %r12
leaq 0x8(%r12), %rdi
movq %r14, %rsi
callq 0x8b6f
testl %eax, %eax
js 0x8c99
setne %bl
jmp 0x8c9e
movq 0x18(%r12), %r12
testl %eax, %eax
jns 0x8ca9
cmpq %r15, %r12
jne 0x8c83
movb $0x1, %bl
andb $0x1, %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::SlopesEqual(ClipperLib::TEdge const&, ClipperLib::TEdge const&, bool)
bool SlopesEqual(const TEdge &e1, const TEdge &e2, bool UseFullInt64Range)
{
#ifndef use_int32
  if (UseFullInt64Range)
    return Int128Mul(e1.Delta.Y, e2.Delta.X) == Int128Mul(e1.Delta.X, e2.Delta.Y);
  else 
#endif
    return e1.Delta.Y * e2.Delta.X == e1.Delta.X * e2.Delta.Y;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
testl %edx, %edx
je 0x8d08
movq 0x38(%rbx), %rsi
movq 0x30(%r14), %rdx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x8894
movq 0x30(%rbx), %rsi
movq 0x38(%r14), %rdx
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x8894
movq 0x8(%r15), %rax
xorq 0x8(%rbx), %rax
movq (%rbx), %rcx
xorq (%r15), %rcx
orq %rax, %rcx
jmp 0x8d1d
movq 0x30(%r14), %rax
movq 0x38(%r14), %rcx
imulq 0x38(%rbx), %rax
imulq 0x30(%rbx), %rcx
cmpq %rcx, %rax
sete %al
addq $0x20, %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::SlopesEqual(ClipperLib::IntPoint, ClipperLib::IntPoint, ClipperLib::IntPoint, bool)
bool SlopesEqual(const IntPoint pt1, const IntPoint pt2,
  const IntPoint pt3, bool UseFullInt64Range)
{
#ifndef use_int32
  if (UseFullInt64Range)
    return Int128Mul(pt1.Y-pt2.Y, pt2.X-pt3.X) == Int128Mul(pt1.X-pt2.X, pt2.Y-pt3.Y);
  else 
#endif
    return (pt1.Y-pt2.Y)*(pt2.X-pt3.X) == (pt1.X-pt2.X)*(pt2.Y-pt3.Y);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %r9, %r15
movq %rcx, %rbx
movq %rdx, %r12
movq %rdi, %r14
subq %rcx, %rsi
cmpb $0x0, 0x50(%rsp)
je 0x8d8b
movq %r12, %rdx
subq %r8, %rdx
leaq 0x10(%rsp), %r13
movq %r13, %rdi
callq 0x8894
subq %r12, %r14
subq %r15, %rbx
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x8894
movq 0x8(%r13), %rax
xorq 0x8(%r15), %rax
movq (%r15), %rcx
xorq (%r13), %rcx
orq %rax, %rcx
jmp 0x8d9f
subq %r12, %r14
subq %r8, %r12
imulq %rsi, %r12
subq %r15, %rbx
imulq %r14, %rbx
cmpq %rbx, %r12
sete %al
addq $0x20, %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::SlopesEqual(ClipperLib::IntPoint, ClipperLib::IntPoint, ClipperLib::IntPoint, ClipperLib::IntPoint, bool)
bool SlopesEqual(const IntPoint pt1, const IntPoint pt2,
  const IntPoint pt3, const IntPoint pt4, bool UseFullInt64Range)
{
#ifndef use_int32
  if (UseFullInt64Range)
    return Int128Mul(pt1.Y-pt2.Y, pt3.X-pt4.X) == Int128Mul(pt1.X-pt2.X, pt3.Y-pt4.Y);
  else 
#endif
    return (pt1.Y-pt2.Y)*(pt3.X-pt4.X) == (pt1.X-pt2.X)*(pt3.Y-pt4.Y);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %r9, %rbx
movq %rdx, %r15
movq %rdi, %r14
leaq 0x50(%rsp), %r13
cmpb $0x0, 0x60(%rsp)
je 0x8e16
subq %rcx, %rsi
subq (%r13), %r8
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %r8, %rdx
callq 0x8894
subq %r15, %r14
subq 0x8(%r13), %rbx
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x8894
movq 0x8(%r12), %rax
xorq 0x8(%r15), %rax
movq (%r15), %rcx
xorq (%r12), %rcx
orq %rax, %rcx
jmp 0x8e2f
subq (%r13), %r8
subq %rcx, %rsi
imulq %rsi, %r8
subq 0x8(%r13), %rbx
subq %r15, %r14
imulq %r14, %rbx
cmpq %rbx, %r8
sete %al
addq $0x20, %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::ReversePolyPtLinks(ClipperLib::OutPt*)
void ReversePolyPtLinks(OutPt *pp)
{
  if (!pp) return;
  OutPt *pp1, *pp2;
  pp1 = pp;
  do {
  pp2 = pp1->Next;
  pp1->Next = pp1->Prev;
  pp1->Prev = pp2;
  pp1 = pp2;
  } while( pp1 != pp );
}

// Assembly:
testq %rdi, %rdi
je 0x910a
movq %rdi, %rax
movq 0x18(%rax), %rcx
movq 0x20(%rax), %rdx
movq %rdx, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq %rcx, %rax
cmpq %rdi, %rcx
jne 0x90f2
retq
// File: /workspace/github_cpp_makefile_star2_O1/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::DisposeOutPts(ClipperLib::OutPt*&)
void DisposeOutPts(OutPt*& pp)
{
  if (pp == 0) return;
    pp->Prev->Next = 0;
  while( pp )
  {
    OutPt *tmpPp = pp;
    pp = pp->Next;
    delete tmpPp;
  }
}

// Assembly:
movq (%rdi), %rax
testq %rax, %rax
je 0x913f
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rax), %rax
movq $0x0, 0x18(%rax)
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x913e
movq 0x18(%rdi), %rax
movq %rax, (%rbx)
movl $0x28, %esi
callq 0x3220
jmp 0x9123
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::InitEdge2(ClipperLib::TEdge&, ClipperLib::PolyType)
void InitEdge2(TEdge& e, PolyType Pt)
{
  if (e.Curr.Y >= e.Next->Curr.Y)
  {
    e.Bot = e.Curr;
    e.Top = e.Next->Curr;
  } else
  {
    e.Top = e.Curr;
    e.Bot = e.Next->Curr;
  }
  SetDx(e);
  e.PolyTyp = Pt;
}

// Assembly:
leaq 0x10(%rdi), %rcx
movq 0x18(%rdi), %rdx
movq 0x60(%rdi), %rax
cmpq 0x18(%rax), %rdx
jge 0x9162
movups (%rcx), %xmm0
movups %xmm0, 0x20(%rdi)
movups 0x10(%rax), %xmm0
movups %xmm0, (%rdi)
jmp 0x9170
movups (%rcx), %xmm0
movups %xmm0, (%rdi)
movups 0x10(%rax), %xmm0
movups %xmm0, 0x20(%rdi)
movq 0x20(%rdi), %rax
movq 0x28(%rdi), %rcx
subq (%rdi), %rax
movq %rax, 0x30(%rdi)
subq 0x8(%rdi), %rcx
movq %rcx, 0x38(%rdi)
je 0x919c
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
cvtsi2sd %rcx, %xmm1
divsd %xmm1, %xmm0
jmp 0x91a4
movsd 0xc4c4(%rip), %xmm0     # 0x15668
movsd %xmm0, 0x40(%rdi)
movl %esi, 0x48(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::GetOverlapSegment(ClipperLib::IntPoint, ClipperLib::IntPoint, ClipperLib::IntPoint, ClipperLib::IntPoint, ClipperLib::IntPoint&, ClipperLib::IntPoint&)
bool GetOverlapSegment(IntPoint pt1a, IntPoint pt1b, IntPoint pt2a,
  IntPoint pt2b, IntPoint &pt1, IntPoint &pt2)
{
  //precondition: segments are Collinear.
  if (Abs(pt1a.X - pt1b.X) > Abs(pt1a.Y - pt1b.Y))
  {
    if (pt1a.X > pt1b.X) SwapPoints(pt1a, pt1b);
    if (pt2a.X > pt2b.X) SwapPoints(pt2a, pt2b);
    if (pt1a.X > pt2a.X) pt1 = pt1a; else pt1 = pt2a;
    if (pt1b.X < pt2b.X) pt2 = pt1b; else pt2 = pt2b;
    return pt1.X < pt2.X;
  } else
  {
    if (pt1a.Y < pt1b.Y) SwapPoints(pt1a, pt1b);
    if (pt2a.Y < pt2b.Y) SwapPoints(pt2a, pt2b);
    if (pt1a.Y < pt2a.Y) pt1 = pt1a; else pt1 = pt2a;
    if (pt1b.Y > pt2b.Y) pt2 = pt1b; else pt2 = pt2b;
    return pt1.Y > pt2.Y;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x38(%rsp), %rax
movq 0x30(%rsp), %r10
movq %rdi, %r11
subq %rdx, %r11
movq %r11, %rbx
negq %rbx
cmovsq %r11, %rbx
leaq 0x20(%rsp), %r11
movq %rsi, %r14
subq %rcx, %r14
movq %r14, %r15
negq %r15
cmovsq %r14, %r15
cmpq %r15, %rbx
jbe 0x9227
cmpq %rdx, %rdi
jle 0x9234
movq %rcx, %rbx
movq %rdx, %r14
jmp 0x9240
cmpq %rcx, %rsi
jge 0x9258
movq %rcx, %rbx
movq %rdx, %r14
jmp 0x9264
movq %rsi, %rbx
movq %rdi, %r14
movq %rcx, %rsi
movq %rdx, %rdi
movq (%r11), %rcx
cmpq %r8, %rcx
jge 0x927c
movq 0x8(%r11), %rdx
movq %r8, (%r11)
movq %r9, 0x8(%r11)
movq %rdx, %r9
jmp 0x927f
movq %rsi, %rbx
movq %rdi, %r14
movq %rcx, %rsi
movq %rdx, %rdi
movq 0x8(%r11), %rcx
cmpq %r9, %rcx
jle 0x929f
movq (%r11), %rdx
movq %r8, (%r11)
movq %r9, 0x8(%r11)
movq %rdx, %r8
jmp 0x92a2
movq %r8, %rcx
cmpq %rcx, %r14
cmovgq %r14, %rcx
cmovgq %rbx, %r9
movq %rcx, (%r10)
movq %r9, 0x8(%r10)
cmpq (%r11), %rdi
jge 0x92c3
movq %rdi, (%rax)
movq %rsi, 0x8(%rax)
jmp 0x92ca
movq %r9, %rcx
cmpq %rcx, %rbx
cmovlq %r14, %r8
cmovlq %rbx, %rcx
movq %r8, (%r10)
movq %rcx, 0x8(%r10)
cmpq 0x8(%r11), %rsi
jle 0x92d5
movq %rdi, (%rax)
movq %rsi, 0x8(%rax)
jmp 0x92dc
movups (%r11), %xmm0
movups %xmm0, (%rax)
movq (%r10), %rcx
cmpq (%rax), %rcx
setl %al
jmp 0x92e7
movups (%r11), %xmm0
movups %xmm0, (%rax)
movq 0x8(%r10), %rcx
cmpq 0x8(%rax), %rcx
setg %al
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::FirstIsBottomPt(ClipperLib::OutPt const*, ClipperLib::OutPt const*)
bool FirstIsBottomPt(const OutPt* btmPt1, const OutPt* btmPt2)
{
  OutPt *p = btmPt1->Prev;
  while ((p->Pt == btmPt1->Pt) && (p != btmPt1)) p = p->Prev;
  double dx1p = std::fabs(GetDx(btmPt1->Pt, p->Pt));
  p = btmPt1->Next;
  while ((p->Pt == btmPt1->Pt) && (p != btmPt1)) p = p->Next;
  double dx1n = std::fabs(GetDx(btmPt1->Pt, p->Pt));

  p = btmPt2->Prev;
  while ((p->Pt == btmPt2->Pt) && (p != btmPt2)) p = p->Prev;
  double dx2p = std::fabs(GetDx(btmPt2->Pt, p->Pt));
  p = btmPt2->Next;
  while ((p->Pt == btmPt2->Pt) && (p != btmPt2)) p = p->Next;
  double dx2n = std::fabs(GetDx(btmPt2->Pt, p->Pt));
  return (dx1p >= dx2p && dx1p >= dx2n) || (dx1n >= dx2p && dx1n >= dx2n);
}

// Assembly:
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rcx
movq %rdi, %r9
movq 0x20(%r9), %r9
movq 0x8(%r9), %r8
cmpq %rdi, %r9
je 0x9310
cmpq %rax, %r8
jne 0x9310
cmpq %rcx, 0x10(%r9)
je 0x92f8
movq 0x10(%rdi), %rdx
movq 0x10(%r9), %r9
subq %rdx, %r9
jne 0x9327
movsd 0xc343(%rip), %xmm0     # 0x15668
jmp 0x9338
subq %rax, %r8
cvtsi2sd %r8, %xmm0
cvtsi2sd %r9, %xmm1
divsd %xmm1, %xmm0
movq %rdi, %r9
movq 0x18(%r9), %r9
movq 0x8(%r9), %r8
cmpq %rdi, %r9
je 0x9353
cmpq %rax, %r8
jne 0x9353
cmpq %rcx, 0x10(%r9)
je 0x933b
andpd 0xbb35(%rip), %xmm0     # 0x14e90
movq 0x10(%r9), %rcx
subq %rdx, %rcx
jne 0x936e
movsd 0xc2fc(%rip), %xmm1     # 0x15668
jmp 0x9382
subq %rax, %r8
xorps %xmm1, %xmm1
cvtsi2sd %r8, %xmm1
cvtsi2sd %rcx, %xmm2
divsd %xmm2, %xmm1
movq 0x8(%rsi), %rax
movq 0x10(%rsi), %rcx
movq %rsi, %r8
movq 0x20(%r8), %r8
movq 0x8(%r8), %rdi
cmpq %rsi, %r8
je 0x93a5
cmpq %rax, %rdi
jne 0x93a5
cmpq %rcx, 0x10(%r8)
je 0x938d
andpd 0xbae3(%rip), %xmm1     # 0x14e90
movq 0x10(%rsi), %rdx
movq 0x10(%r8), %r8
subq %rdx, %r8
jne 0x93c4
movsd 0xc2a6(%rip), %xmm2     # 0x15668
jmp 0x93d8
subq %rax, %rdi
xorps %xmm2, %xmm2
cvtsi2sd %rdi, %xmm2
cvtsi2sd %r8, %xmm3
divsd %xmm3, %xmm2
movq %rsi, %r8
movq 0x18(%r8), %r8
movq 0x8(%r8), %rdi
cmpq %rsi, %r8
je 0x93f3
cmpq %rax, %rdi
jne 0x93f3
cmpq %rcx, 0x10(%r8)
je 0x93db
andpd 0xba95(%rip), %xmm2     # 0x14e90
movq 0x10(%r8), %rcx
subq %rdx, %rcx
jne 0x940e
movsd 0xc25c(%rip), %xmm3     # 0x15668
jmp 0x9422
subq %rax, %rdi
xorps %xmm3, %xmm3
cvtsi2sd %rdi, %xmm3
cvtsi2sd %rcx, %xmm4
divsd %xmm4, %xmm3
andpd 0xba66(%rip), %xmm3     # 0x14e90
ucomisd %xmm2, %xmm0
jb 0x9438
movb $0x1, %al
ucomisd %xmm3, %xmm0
jae 0x944a
cmplepd %xmm1, %xmm3
cmplepd %xmm1, %xmm2
andpd %xmm3, %xmm2
movd %xmm2, %eax
andb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::GetBottomPt(ClipperLib::OutPt*)
OutPt* GetBottomPt(OutPt *pp)
{
  OutPt* dups = 0;
  OutPt* p = pp->Next;
  while (p != pp)
  {
    if (p->Pt.Y > pp->Pt.Y)
    {
      pp = p;
      dups = 0;
    }
    else if (p->Pt.Y == pp->Pt.Y && p->Pt.X <= pp->Pt.X)
    {
      if (p->Pt.X < pp->Pt.X)
      {
        dups = 0;
        pp = p;
      } else
      {
        if (p->Next != pp && p->Prev != pp) dups = p;
      }
    }
    p = p->Next;
  }
  if (dups)
  {
    //there appears to be at least 2 vertices at BottomPt so ...
    while (dups != p)
    {
      if (!FirstIsBottomPt(p, dups)) pp = dups;
      dups = dups->Next;
      while (dups->Pt != pp->Pt) dups = dups->Next;
    }
  }
  return pp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %r14
xorl %r15d, %r15d
cmpq %rdi, %r14
je 0x9498
movq 0x10(%rbx), %rax
cmpq %rax, 0x10(%r14)
jle 0x9473
movq %r14, %rbx
xorl %r15d, %r15d
jmp 0x948f
jne 0x948f
movq 0x8(%rbx), %rax
cmpq %rax, 0x8(%r14)
jg 0x948f
jl 0x946b
cmpq %rbx, 0x18(%r14)
je 0x948f
cmpq %rbx, 0x20(%r14)
cmovneq %r14, %r15
movq 0x18(%r14), %r14
cmpq %rbx, %r14
jne 0x9461
testq %r15, %r15
sete %al
cmpq %r14, %r15
sete %cl
orb %al, %cl
jne 0x94d6
movq %r14, %rdi
movq %r15, %rsi
callq 0x92ed
testb %al, %al
cmoveq %r15, %rbx
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
movq 0x18(%r15), %r15
cmpq %rax, 0x8(%r15)
jne 0x94c1
cmpq %rcx, 0x10(%r15)
jne 0x94c1
cmpq %r14, %r15
jne 0x94a8
movq %rbx, %rax
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::FindSegment(ClipperLib::OutPt*&, bool, ClipperLib::IntPoint&, ClipperLib::IntPoint&)
bool FindSegment(OutPt* &pp, bool UseFullInt64Range, 
  IntPoint &pt1, IntPoint &pt2)
{
  //OutPt1 & OutPt2 => the overlap segment (if the function returns true)
  if (!pp) return false;
  OutPt* pp2 = pp;
  IntPoint pt1a = pt1, pt2a = pt2;
  do
  {
    if (SlopesEqual(pt1a, pt2a, pp->Pt, pp->Prev->Pt, UseFullInt64Range) &&
      SlopesEqual(pt1a, pt2a, pp->Pt, UseFullInt64Range) &&
      GetOverlapSegment(pt1a, pt2a, pp->Pt, pp->Prev->Pt, pt1, pt2))
        return true;
    pp = pp->Next;
  }
  while (pp != pp2);
  return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq (%rdi), %rax
movq %rax, 0x50(%rsp)
testq %rax, %rax
je 0x95dc
movq (%rdx), %rbp
movq %rdx, 0x38(%rsp)
movq 0x8(%rdx), %rbx
movq (%rcx), %r15
movq %rcx, 0x40(%rsp)
movq 0x8(%rcx), %r14
movzbl %sil, %eax
movl %eax, 0x2c(%rsp)
movq %rdi, 0x48(%rsp)
movq (%rdi), %rax
movq 0x8(%rax), %r8
movq 0x10(%rax), %r12
movq 0x20(%rax), %r13
movups 0x8(%r13), %xmm0
movups %xmm0, (%rsp)
movl 0x2c(%rsp), %eax
movl %eax, 0x10(%rsp)
movq %rbp, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r14, %rcx
movq %r8, 0x30(%rsp)
movq %r12, %r9
callq 0x8db0
testb %al, %al
je 0x95c2
movl 0x2c(%rsp), %eax
movl %eax, (%rsp)
movq %rbp, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r14, %rcx
movq 0x30(%rsp), %r8
movq %r12, %r9
callq 0x8d2a
testb %al, %al
je 0x95c2
addq $0x8, %r13
movups (%r13), %xmm0
movups %xmm0, (%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movq %rbp, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r14, %rcx
movq 0x30(%rsp), %r8
movq %r12, %r9
callq 0x91e1
testb %al, %al
jne 0x95ed
movq 0x48(%rsp), %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
movq %rax, (%rdi)
cmpq 0x50(%rsp), %rax
jne 0x9523
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %al
jmp 0x95de
// File: /workspace/github_cpp_makefile_star2_O1/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::InsertPolyPtBetween(ClipperLib::OutPt*, ClipperLib::OutPt*, ClipperLib::IntPoint)
OutPt* InsertPolyPtBetween(OutPt* p1, OutPt* p2, const IntPoint Pt)
{
  if (p1 == p2) throw "JoinError";
  OutPt* result = new OutPt;
  result->Pt = Pt;
  if (p2 == p1->Next)
  {
    p1->Next = result;
    p2->Prev = result;
    result->Next = p2;
    result->Prev = p1;
  } else
  {
    p2->Next = result;
    p1->Prev = result;
    result->Next = p1;
    result->Prev = p2;
  }
  return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpq %rsi, %rdi
je 0x96a7
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movl $0x28, %edi
callq 0x3210
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq %r12, 0x8(%rax)
movq %r15, 0x10(%rax)
cmpq %r14, 0x18(%rbx)
movq %r14, %rcx
cmoveq %rbx, %rcx
cmoveq %r14, %rbx
movq %rax, 0x18(%rcx)
movq %rax, 0x20(%rbx)
movq %rbx, 0x18(%rax)
movq %rcx, 0x20(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x8, %edi
callq 0x30f0
leaq 0xc03b(%rip), %rcx      # 0x156f3
movq %rcx, (%rax)
movq 0x12906(%rip), %rsi     # 0x1bfc8
movq %rax, %rdi
xorl %edx, %edx
callq 0x3370
// File: /workspace/github_cpp_makefile_star2_O1/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::HorzSegmentsOverlap(ClipperLib::IntPoint const&, ClipperLib::IntPoint const&, ClipperLib::IntPoint const&, ClipperLib::IntPoint const&)
bool HorzSegmentsOverlap(const IntPoint& pt1a, const IntPoint& pt1b, 
    const IntPoint& pt2a, const IntPoint& pt2b)
{
  //precondition: both segments are horizontal
  if ((pt1a.X > pt2a.X) == (pt1a.X < pt2b.X)) return true;
  else if ((pt1b.X > pt2a.X) == (pt1b.X < pt2b.X)) return true;
  else if ((pt2a.X > pt1a.X) == (pt2a.X < pt1b.X)) return true;
  else if ((pt2b.X > pt1a.X) == (pt2b.X < pt1b.X)) return true;
  else if ((pt1a.X == pt2a.X) && (pt1b.X == pt2b.X)) return true;
  else if ((pt1a.X == pt2b.X) && (pt1b.X == pt2a.X)) return true;
  else return false;
}

// Assembly:
movq (%rdi), %rdi
movq (%rdx), %rdx
movq (%rcx), %rcx
cmpq %rcx, %rdi
setl %al
cmpq %rdx, %rdi
setle %r8b
xorb %al, %r8b
movb $0x1, %al
je 0x96ea
retq
pushq %rbx
cmpq %rcx, %rdi
setl %r11b
movq (%rsi), %rsi
cmpq %rdx, %rsi
setg %r8b
cmpq %rcx, %rsi
setge %r10b
cmpq %rdi, %rdx
setle %r9b
cmpq %rsi, %rcx
setge %bl
xorb %r11b, %bl
popq %rbx
jne 0x96e9
xorb %r8b, %r10b
jne 0x96e9
xorb %r8b, %r9b
jne 0x96e9
movq %rdi, %r8
xorq %rdx, %r8
movq %rsi, %r9
xorq %rcx, %r9
orq %r8, %r9
je 0x96e9
xorq %rcx, %rdi
xorq %rdx, %rsi
orq %rdi, %rsi
sete %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::RangeTest(ClipperLib::IntPoint const&, bool&)
void RangeTest(const IntPoint& Pt, bool& useFullRange)
{
  if (useFullRange)
  {
    if (Pt.X > hiRange || Pt.Y > hiRange || -Pt.X > hiRange || -Pt.Y > hiRange) 
      throw "Coordinate outside allowed range";
  }
  else if (Pt.X > loRange|| Pt.Y > loRange || -Pt.X > loRange || -Pt.Y > loRange) 
  {
    useFullRange = true;
    RangeTest(Pt, useFullRange);
  }
}

// Assembly:
movq $-0x40000000, %rax      # imm = 0xC0000000
movq (%rdi), %rcx
cmpb $0x1, (%rsi)
je 0x97d9
cmpq $0x3fffffff, %rcx       # imm = 0x3FFFFFFF
jg 0x97d4
cmpq $-0x3fffffff, %rcx      # imm = 0xC0000001
jl 0x97d4
movq 0x8(%rdi), %rcx
addq %rax, %rcx
cmpq $-0x80000000, %rcx      # imm = 0x80000000
ja 0x980e
movb $0x1, (%rsi)
jmp 0x97aa
movabsq $0x3fffffffffffffff, %rax # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rax, %rcx
jg 0x980f
movabsq $-0x4000000000000000, %rax # imm = 0xC000000000000000
leaq 0x1(%rax), %rdx
cmpq %rdx, %rcx
jl 0x980f
addq 0x8(%rdi), %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
cmpq %rcx, %rax
jbe 0x980f
retq
pushq %rax
movl $0x8, %edi
callq 0x30f0
leaq 0xbedc(%rip), %rcx      # 0x156fd
movq %rcx, (%rax)
movq 0x1279d(%rip), %rsi     # 0x1bfc8
movq %rax, %rdi
xorl %edx, %edx
callq 0x3370
// File: /workspace/github_cpp_makefile_star2_O1/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::FindNextLocMin(ClipperLib::TEdge*)
TEdge* FindNextLocMin(TEdge* E)
{
  for (;;)
  {
    while (E->Bot != E->Prev->Bot || E->Curr == E->Top) E = E->Next;
    if (!IsHorizontal(*E) && !IsHorizontal(*E->Prev)) break;
    while (IsHorizontal(*E->Prev)) E = E->Prev;
    TEdge* E2 = E;
    while (IsHorizontal(*E)) E = E->Next;
    if (E->Top.Y == E->Prev->Bot.Y) continue; //ie just an intermediate horz.
    if (E2->Prev->Bot.X < E->Bot.X) E = E2;
    break;
  }
  return E;
}

// Assembly:
movq 0x68(%rdi), %rax
movq (%rdi), %rcx
cmpq (%rax), %rcx
jne 0x985f
movq 0x8(%rax), %rcx
cmpq %rcx, 0x8(%rdi)
jne 0x985f
movq 0x10(%rdi), %rcx
cmpq 0x20(%rdi), %rcx
jne 0x9865
movq 0x28(%rdi), %rcx
cmpq %rcx, 0x18(%rdi)
jne 0x9865
movq 0x60(%rdi), %rdi
jmp 0x9835
cmpq $0x0, 0x38(%rdi)
je 0x9873
cmpq $0x0, 0x38(%rax)
jne 0x98c1
movq %rdi, %rcx
movq 0x68(%rdi), %rdi
cmpq $0x0, 0x38(%rdi)
je 0x9873
cmpq $0x0, 0x38(%rcx)
movq %rcx, %rax
jne 0x9899
movq %rcx, %rax
movq 0x60(%rax), %rax
cmpq $0x0, 0x38(%rax)
je 0x988e
movq 0x28(%rax), %rdx
movq 0x68(%rax), %rsi
movq 0x8(%rsi), %rsi
cmpq %rsi, %rdx
je 0x98b4
movq (%rdi), %rdi
cmpq (%rax), %rdi
cmovlq %rcx, %rax
movq %rax, %rdi
cmpq %rsi, %rdx
je 0x9835
retq
movq %rdi, %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::ClipperBase::AddPaths(std::vector<std::vector<ClipperLib::IntPoint, std::allocator<ClipperLib::IntPoint>>, std::allocator<std::vector<ClipperLib::IntPoint, std::allocator<ClipperLib::IntPoint>>>> const&, ClipperLib::PolyType, bool)
bool ClipperBase::AddPaths(const Paths &ppg, PolyType PolyTyp, bool Closed)
{
  bool result = false;
  for (Paths::size_type i = 0; i < ppg.size(); ++i)
    if (AddPath(ppg[i], PolyTyp, Closed)) result = true;
  return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq (%rsi), %rsi
cmpq %rsi, 0x8(%r14)
je 0xa20f
movl %edx, %r15d
movq %rdi, %r12
xorl %r13d, %r13d
movzbl %cl, %eax
movl %eax, 0x4(%rsp)
xorl %ebx, %ebx
xorl %ebp, %ebp
addq %r13, %rsi
movq %r12, %rdi
movl %r15d, %edx
movl 0x4(%rsp), %ecx
callq 0x9b74
movzbl %bpl, %ebp
testb %al, %al
movl $0x1, %eax
cmovnel %eax, %ebp
incq %rbx
movq (%r14), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rax
addq $0x18, %r13
cmpq %rax, %rbx
jb 0xa1c5
jmp 0xa211
xorl %ebp, %ebp
andb $0x1, %bpl
movl %ebp, %eax
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::ClipperBase::Clear()
void ClipperBase::Clear()
{
  DisposeLocalMinimaList();
  for (EdgeList::size_type i = 0; i < m_edges.size(); ++i)
  {
    //for each edge array in turn, find the first used edge and 
    //check for and remove any hiddenPts in each edge in the array.
    TEdge* edges = m_edges[i];
    delete [] edges;
  }
  m_edges.clear();
  m_UseFullRange = false;
  m_HasOpenPaths = false;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0xa250
movq 0x18(%rdi), %r14
movl $0x20, %esi
callq 0x3220
movq %r14, 0x10(%rbx)
movq %r14, %rdi
testq %r14, %r14
jne 0xa236
movq $0x0, 0x8(%rbx)
movq 0x20(%rbx), %rax
movq 0x28(%rbx), %rcx
cmpq %rax, %rcx
je 0xa290
xorl %r14d, %r14d
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0xa276
callq 0x32a0
incq %r14
movq 0x20(%rbx), %rax
movq 0x28(%rbx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %rdx, %r14
jb 0xa268
cmpq %rax, %rcx
je 0xa299
movq %rax, 0x28(%rbx)
xorl %eax, %eax
movb %al, 0x18(%rbx)
movb %al, 0x39(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::ClipperBase::DisposeLocalMinimaList()
void ClipperBase::DisposeLocalMinimaList()
{
  while( m_MinimaList )
  {
    LocalMinima* tmpLm = m_MinimaList->Next;
    delete m_MinimaList;
    m_MinimaList = tmpLm;
  }
  m_CurrentLM = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0xa2d4
movq 0x18(%rdi), %r14
movl $0x20, %esi
callq 0x3220
movq %r14, 0x10(%rbx)
movq %r14, %rdi
testq %r14, %r14
jne 0xa2ba
movq $0x0, 0x8(%rbx)
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::ClipperBase::GetBounds()
IntRect ClipperBase::GetBounds()
{
  IntRect result;
  LocalMinima* lm = m_MinimaList;
  if (!lm)
  {
    result.left = result.top = result.right = result.bottom = 0;
    return result;
  }
  result.left = lm->LeftBound->Bot.X;
  result.top = lm->LeftBound->Bot.Y;
  result.right = lm->LeftBound->Bot.X;
  result.bottom = lm->LeftBound->Bot.Y;
  while (lm)
  {
    if (lm->LeftBound->Bot.Y > result.bottom)
      result.bottom = lm->LeftBound->Bot.Y;
    TEdge* e = lm->LeftBound;
    for (;;) {
      TEdge* bottomE = e;
      while (e->NextInLML)
      {
        if (e->Bot.X < result.left) result.left = e->Bot.X;
        if (e->Bot.X > result.right) result.right = e->Bot.X;
        e = e->NextInLML;
      }
      if (e->Bot.X < result.left) result.left = e->Bot.X;
      if (e->Bot.X > result.right) result.right = e->Bot.X;
      if (e->Top.X < result.left) result.left = e->Top.X;
      if (e->Top.X > result.right) result.right = e->Top.X;
      if (e->Top.Y < result.top) result.top = e->Top.Y;

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

// Assembly:
movq %rdi, %rax
movq 0x10(%rsi), %rcx
testq %rcx, %rcx
je 0xa41f
pushq %r15
pushq %r14
pushq %rbx
movq 0x8(%rcx), %rsi
movq (%rsi), %rdx
movq %rdx, (%rax)
movq 0x8(%rsi), %rsi
movq %rsi, 0x8(%rax)
movq %rdx, 0x10(%rax)
movq %rsi, 0x18(%rax)
movq %rdx, %r8
movq %rsi, %rdi
movq 0x8(%rcx), %r10
movq 0x8(%r10), %r9
movq %r10, %r11
movq 0x70(%r11), %r14
testq %r14, %r14
je 0xa3b4
movq %r11, %r15
movq (%r15), %rbx
cmpq %rdx, %rbx
cmovlq %rbx, %rdx
cmpq %r8, %rbx
cmovgq %rbx, %r8
movq %r14, %rbx
movq 0x70(%r14), %r14
movq %rbx, %r15
testq %r14, %r14
jne 0xa392
jmp 0xa3b7
movq %r11, %rbx
movq (%rbx), %r14
cmpq %rdx, %r14
cmovlq %r14, %rdx
cmpq %r8, %r14
cmovgq %r14, %r8
movq 0x20(%rbx), %r14
cmpq %rdx, %r14
cmovlq %r14, %rdx
cmpq %r8, %r14
cmovgq %r14, %r8
movq 0x28(%rbx), %r14
cmpq %rdi, %r14
cmovlq %r14, %rdi
cmpq %r10, %r11
jne 0xa3ee
movq 0x10(%rcx), %rbx
cmpq %r10, %r11
movq %rbx, %r11
je 0xa386
cmpq %rsi, %r9
cmovgq %r9, %rsi
movq 0x18(%rcx), %rcx
testq %rcx, %rcx
jne 0xa37b
movq %rsi, 0x18(%rax)
movq %rdx, (%rax)
movq %r8, 0x10(%rax)
movq %rdi, 0x8(%rax)
popq %rbx
popq %r14
popq %r15
retq
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O1/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::Clipper::Clipper(int)
Clipper::Clipper(int initOptions) : ClipperBase() //constructor
{
  m_ActiveEdges = 0;
  m_SortedEdges = 0;
  m_ExecuteLocked = false;
  m_UseFullRange = false;
  m_ReverseOutput = ((initOptions & ioReverseSolution) != 0);
  m_StrictSimple = ((initOptions & ioStrictlySimple) != 0);
  m_PreserveCollinear = ((initOptions & ioPreserveCollinear) != 0);
  m_HasOpenPaths = false;
#ifdef use_xyz  
  m_ZFill = 0;
#endif
}

// Assembly:
movq (%rsi), %rax
movq %rax, (%rdi)
movq 0x8(%rsi), %rcx
movq -0x18(%rax), %rax
movq %rcx, (%rdi,%rax)
leaq 0x78(%rdi), %rax
movl $0x0, 0x78(%rdi)
movq $0x0, 0x80(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x48(%rdi)
movups %xmm0, 0x58(%rdi)
movq %rax, 0x88(%rdi)
movq %rax, 0x90(%rdi)
movups %xmm0, 0x98(%rdi)
movups %xmm0, 0xa1(%rdi)
movq (%rdi), %rax
movq -0x18(%rax), %rcx
xorl %esi, %esi
movb %sil, 0x18(%rdi,%rcx)
movl %edx, %ecx
andb $0x1, %cl
movb %cl, 0xbc(%rdi)
movl %edx, %ecx
shrb %cl
andb $0x1, %cl
movb %cl, 0xbe(%rdi)
movq -0x18(%rax), %rcx
shrb $0x2, %dl
andb $0x1, %dl
movb %dl, 0x38(%rdi,%rcx)
movq -0x18(%rax), %rax
movb %sil, 0x39(%rdi,%rax)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::Clipper::Reset()
void Clipper::Reset()
{
  ClipperBase::Reset();
  m_Scanbeam.clear();
  m_ActiveEdges = 0;
  m_SortedEdges = 0;
  LocalMinima* lm = m_MinimaList;
  while (lm)
  {
    InsertScanbeam(lm->Y);
    lm = lm->Next;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movq (%rdi), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
callq 0xa2e4
leaq 0x70(%r14), %rbx
movq %rbx, %rdi
callq 0x12e18
xorps %xmm0, %xmm0
movups %xmm0, 0xa0(%r14)
movq (%r14), %rax
movq -0x18(%rax), %rax
movq 0x10(%r14,%rax), %r15
testq %r15, %r15
je 0xa70c
leaq 0x8(%rsp), %r14
movq (%r15), %rax
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x12fd2
movq 0x18(%r15), %r15
testq %r15, %r15
jne 0xa6f0
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::Clipper::Execute(ClipperLib::ClipType, std::vector<std::vector<ClipperLib::IntPoint, std::allocator<ClipperLib::IntPoint>>, std::allocator<std::vector<ClipperLib::IntPoint, std::allocator<ClipperLib::IntPoint>>>>&, ClipperLib::PolyFillType, ClipperLib::PolyFillType)
bool Clipper::Execute(ClipType clipType, Paths &solution,
    PolyFillType subjFillType, PolyFillType clipFillType)
{
  if( m_ExecuteLocked ) return false;
  if (m_HasOpenPaths)
    throw clipperException("Error: PolyTree struct is need for open path clipping.");
  m_ExecuteLocked = true;
  solution.resize(0);
  m_SubjFillType = subjFillType;
  m_ClipFillType = clipFillType;
  m_ClipType = clipType;
  m_UsingPolyTree = false;
  bool succeeded = ExecuteInternal();
  if (succeeded) BuildResult(solution);
  DisposeAllOutRecs();
  m_ExecuteLocked = false;
  return succeeded;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpb $0x0, 0xb0(%rdi)
je 0xa74d
xorl %ebp, %ebp
jmp 0xa7bc
movq %rdi, %rbx
movq (%rdi), %rax
movq -0x18(%rax), %rax
cmpb $0x1, 0x39(%rdi,%rax)
je 0xa7c7
movl %r8d, %ebp
movl %ecx, %r12d
movq %rdx, %r14
movl %esi, %r15d
movb $0x1, 0xb0(%rbx)
movq %rdx, %rdi
xorl %esi, %esi
callq 0x122c6
movl %r12d, 0xb8(%rbx)
movl %ebp, 0xb4(%rbx)
movl %r15d, 0x68(%rbx)
movb $0x0, 0xbd(%rbx)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movl %eax, %ebp
testb %al, %al
je 0xa7ad
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa80c
movq %rbx, %rdi
callq 0xa934
movb $0x0, 0xb0(%rbx)
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x28, %edi
callq 0x30f0
movq %rax, %rbx
leaq 0xaf6b(%rip), %rsi      # 0x15746
movq %rax, %rdi
callq 0x1225c
leaq 0x1157e(%rip), %rsi     # 0x1bd68
leaq 0x7aa5(%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::BuildResult(std::vector<std::vector<ClipperLib::IntPoint, std::allocator<ClipperLib::IntPoint>>, std::allocator<std::vector<ClipperLib::IntPoint, std::allocator<ClipperLib::IntPoint>>>>&)
void Clipper::BuildResult(Paths &polys)
{
  polys.reserve(m_PolyOuts.size());
  for (PolyOutList::size_type i = 0; i < m_PolyOuts.size(); ++i)
  {
    if (!m_PolyOuts[i]->Pts) continue;
    Path pg;
    OutPt* p = m_PolyOuts[i]->Pts->Prev;
    int cnt = PointCount(p);
    if (cnt < 2) continue;
    pg.reserve(cnt);
    for (int i = 0; i < cnt; ++i)
    {
      pg.push_back(p->Pt);
      p = p->Prev;
    }
    polys.push_back(pg);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rsi
subq 0x8(%rdi), %rsi
sarq $0x3, %rsi
movq %rbx, %rdi
callq 0x12334
movq 0x8(%r14), %rax
cmpq %rax, 0x10(%r14)
je 0xa901
xorl %r12d, %r12d
movq %rsp, %r15
movq (%rax,%r12,8), %rcx
cmpq $0x0, 0x18(%rcx)
je 0xa8e6
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq (%rax,%r12,8), %rax
movq 0x18(%rax), %rax
movq 0x20(%rax), %r13
xorl %ebp, %ebp
testq %r13, %r13
je 0xa888
movq %r13, %rax
incl %ebp
movq 0x18(%rax), %rax
cmpq %r13, %rax
jne 0xa87d
cmpl $0x2, %ebp
jl 0xa8d0
movl %ebp, %esi
movq %r15, %rdi
callq 0x1241a
leaq 0x8(%r13), %rdx
movq 0x8(%rsp), %rsi
cmpq 0x10(%rsp), %rsi
je 0xa8b5
movups (%rdx), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0x8(%rsp)
jmp 0xa8bd
movq %r15, %rdi
callq 0x1270c
movq 0x20(%r13), %r13
decl %ebp
jne 0xa897
movq %rbx, %rdi
movq %r15, %rsi
callq 0x124c2
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xa8e6
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x3220
incq %r12
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r12
jb 0xa848
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa912
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xa92b
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x3220
movq %rbx, %rdi
callq 0x3380
nop
// File: /workspace/github_cpp_makefile_star2_O1/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::Clipper::Execute(ClipperLib::ClipType, ClipperLib::PolyTree&, ClipperLib::PolyFillType, ClipperLib::PolyFillType)
bool Clipper::Execute(ClipType clipType, PolyTree& polytree,
    PolyFillType subjFillType, PolyFillType clipFillType)
{
  if( m_ExecuteLocked ) return false;
  m_ExecuteLocked = true;
  m_SubjFillType = subjFillType;
  m_ClipFillType = clipFillType;
  m_ClipType = clipType;
  m_UsingPolyTree = true;
  bool succeeded = ExecuteInternal();
  if (succeeded) BuildResult2(polytree);
  DisposeAllOutRecs();
  m_ExecuteLocked = false;
  return succeeded;
}

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

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

// Assembly:
movq 0x8(%rsi), %rcx
testq %rcx, %rcx
je 0xabfc
movb 0x4(%rsi), %al
cmpb 0x4(%rcx), %al
je 0xabfd
cmpq $0x0, 0x18(%rcx)
je 0xabfd
retq
movq 0x8(%rsi), %rcx
testq %rcx, %rcx
je 0xac18
cmpb %al, 0x4(%rcx)
je 0xac12
cmpq $0x0, 0x18(%rcx)
jne 0xac18
movq 0x8(%rcx), %rcx
jmp 0xac01
movq %rcx, 0x8(%rsi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::Clipper::ProcessHorizontals(bool)
void Clipper::ProcessHorizontals(bool IsTopOfScanbeam)
{
  TEdge* horzEdge = m_SortedEdges;
  while(horzEdge)
  {
    DeleteFromSEL(horzEdge);
    ProcessHorizontal(horzEdge, IsTopOfScanbeam);
    horzEdge = m_SortedEdges;
  }
}

// Assembly:
movl %esi, %eax
movq 0xa8(%rdi), %rsi
testq %rsi, %rsi
je 0xb2ac
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xa8(%rdi), %r14
movl $0x88, %r15d
movzbl %al, %ebp
movq 0x88(%rsi), %rax
movq 0x90(%rsi), %rcx
leaq (%rcx,%r15), %rdx
testq %rcx, %rcx
cmoveq %r14, %rdx
movq %rax, (%rdx)
testq %rax, %rax
je 0xb282
movq %rcx, 0x90(%rax)
leaq (%rsi,%r15), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rbx, %rdi
movl %ebp, %edx
callq 0xcf46
movq 0xa8(%rbx), %rsi
testq %rsi, %rsi
jne 0xb25a
addq $0x8, %rsp
popq %rbx
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::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 %r14
pushq %rbx
pushq %rax
cmpq $0x0, 0xa0(%rdi)
je 0xb307
movq %rdi, %rbx
callq 0xd98e
movq 0x58(%rbx), %rax
subq 0x50(%rbx), %rax
sarq $0x3, %rax
je 0xb2f0
cmpq $0x1, %rax
je 0xb2e4
movq %rbx, %rdi
callq 0xdc34
testb %al, %al
je 0xb2f4
movq %rbx, %rdi
callq 0xdee4
movb $0x1, %cl
jmp 0xb2f8
movb $0x1, %al
jmp 0xb2f6
xorl %eax, %eax
xorl %ecx, %ecx
testb %cl, %cl
je 0xb309
movq $0x0, 0xa8(%rbx)
movb $0x1, %al
andb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0xb315
movq %rax, %rdi
callq 0x30d0
movq $0x0, 0xa8(%rbx)
movq %rbx, %rdi
callq 0xdf5e
movl $0x28, %edi
callq 0x30f0
movq %rax, %rbx
leaq 0xa471(%rip), %rsi      # 0x157b5
movq %rax, %rdi
callq 0x1225c
leaq 0x10a15(%rip), %rsi     # 0x1bd68
leaq 0x6f3c(%rip), %rdx      # 0x12296
movq %rbx, %rdi
callq 0x3370
movq %rax, %r14
jmp 0xb372
movq %rax, %r14
movq %rbx, %rdi
callq 0x3170
callq 0x3350
movq %r14, %rdi
callq 0x3380
movq %rax, %rdi
callq 0x12251
nop
// File: /workspace/github_cpp_makefile_star2_O1/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::Clipper::DisposeOutRec(unsigned long)
void Clipper::DisposeOutRec(PolyOutList::size_type index)
{
  OutRec *outRec = m_PolyOuts[index];
  if (outRec->Pts) DisposeOutPts(outRec->Pts);
  delete outRec;
  m_PolyOuts[index] = 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rax
movq (%rax,%rsi,8), %r15
cmpq $0x0, 0x18(%r15)
je 0xbf21
leaq 0x18(%r15), %rdi
callq 0x910b
testq %r15, %r15
je 0xbf33
movl $0x28, %esi
movq %r15, %rdi
callq 0x3220
movq 0x8(%r14), %rax
movq $0x0, (%rax,%rbx,8)
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::Clipper::AddLocalMinPoly(ClipperLib::TEdge*, ClipperLib::TEdge*, ClipperLib::IntPoint const&)
OutPt* Clipper::AddLocalMinPoly(TEdge *e1, TEdge *e2, const IntPoint &Pt)
{
  OutPt* result;
  TEdge *e, *prevE;
  if (IsHorizontal(*e2) || ( e1->Dx > e2->Dx ))
  {
    result = AddOutPt(e1, Pt);
    e2->OutIdx = e1->OutIdx;
    e1->Side = esLeft;
    e2->Side = esRight;
    e = e1;
    if (e->PrevInAEL == e2)
      prevE = e2->PrevInAEL; 
    else
      prevE = e->PrevInAEL;
  } else
  {
    result = AddOutPt(e2, Pt);
    e1->OutIdx = e2->OutIdx;
    e1->Side = esRight;
    e2->Side = esLeft;
    e = e2;
    if (e->PrevInAEL == e1)
        prevE = e1->PrevInAEL;
    else
        prevE = e->PrevInAEL;
  }

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %rbp
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x38(%rdx)
je 0xc1b1
movsd 0x40(%r14), %xmm0
ucomisd 0x40(%rbp), %xmm0
jbe 0xc212
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xc328
movq %rax, %r12
movl 0x5c(%r14), %eax
movl %eax, 0x5c(%rbp)
movl $0x1, 0x4c(%r14)
movl $0x2, 0x4c(%rbp)
movq 0x80(%r14), %r13
movq %rbp, %rax
cmpq %rbp, %r13
jne 0xc1ee
movq 0x80(%rax), %r13
testq %r13, %r13
je 0xc315
cmpl $0x0, 0x5c(%r13)
js 0xc315
movq 0x8(%r15), %rcx
cmpq %rcx, 0x28(%r13)
jne 0xc24d
movq 0x20(%r13), %rax
jmp 0xc284
movq %rbx, %rdi
movq %rbp, %rsi
movq %r15, %rdx
callq 0xc328
movq %rax, %r12
movl 0x5c(%rbp), %eax
movl %eax, 0x5c(%r14)
movl $0x2, 0x4c(%r14)
movl $0x1, 0x4c(%rbp)
movq 0x80(%rbp), %r13
movq %r14, %rax
cmpq %r14, %r13
movq %rbp, %r14
jne 0xc1ee
jmp 0xc1e7
movq %rcx, %rax
subq 0x8(%r13), %rax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
mulsd 0x40(%r13), %xmm0
xorpd %xmm1, %xmm1
xorl %eax, %eax
ucomisd %xmm0, %xmm1
seta %al
leaq 0x941a(%rip), %rdx      # 0x15690
addsd (%rdx,%rax,8), %xmm0
cvttsd2si %xmm0, %rax
addq (%r13), %rax
cmpq %rcx, 0x28(%r14)
jne 0xc290
movq 0x20(%r14), %rcx
jmp 0xc2c3
subq 0x8(%r14), %rcx
xorps %xmm0, %xmm0
cvtsi2sd %rcx, %xmm0
mulsd 0x40(%r14), %xmm0
xorpd %xmm1, %xmm1
xorl %ecx, %ecx
ucomisd %xmm0, %xmm1
seta %cl
leaq 0x93da(%rip), %rdx      # 0x15690
addsd (%rdx,%rcx,8), %xmm0
cvttsd2si %xmm0, %rcx
addq (%r14), %rcx
cmpq %rcx, %rax
jne 0xc315
movq (%rbx), %rax
movq -0x18(%rax), %rax
movzbl 0x18(%rbx,%rax), %edx
movq %r14, %rdi
movq %r13, %rsi
callq 0x8cba
testb %al, %al
je 0xc315
cmpl $0x0, 0x50(%r14)
je 0xc315
cmpl $0x0, 0x50(%r13)
je 0xc315
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0xc328
movq 0x20(%r14), %rcx
movq 0x28(%r14), %r8
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0xc452
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop