LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: hzeller[P]gcode-multi-shell-extrude/printer.cc
// Function: (anonymous namespace)::PostScriptPrinter::ColorSwitch(float, float, float, float)
void ColorSwitch(float line_width, float r, float g, float b) {
    printf("currentpoint\nstroke\n");   // finish last path; remember pos
    printf("%.1f setlinewidth %% mm\n", line_width);
    printf("%.1f %.1f %.1f setrgbcolor\n", r, g, b);
    printf("moveto\n");   // set current point to remembered pos.
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movss %xmm1, -0x10(%rbp)
movss %xmm2, -0x14(%rbp)
movss %xmm3, -0x18(%rbp)
leaq 0x1d151(%rip), %rdi     # 0x2c5a8
movb $0x0, %al
callq 0x3040
movss -0xc(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x1d14f(%rip), %rdi     # 0x2c5bd
movb $0x1, %al
callq 0x3040
movss -0x10(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movss -0x14(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
movss -0x18(%rbp), %xmm2
cvtss2sd %xmm2, %xmm2
leaq 0x1d13f(%rip), %rdi     # 0x2c5d6
movb $0x3, %al
callq 0x3040
leaq 0x1d0d7(%rip), %rdi     # 0x2c57c
movb $0x0, %al
callq 0x3040
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: hzeller[P]gcode-multi-shell-extrude/config-values.cc
// Function: TypedParameter<bool>::FromString(char const*)
bool TypedParameter<bool>::FromString(const char *s) {
  if (s == NULL || strlen(s) == 0) {
    value_ = !value_;    // no parameter: just toggling.
  } else {
    value_ = (strcasecmp(s, "on") == 0 || strcasecmp(s, "true") == 0);
  }
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xf80e
movq -0x10(%rbp), %rdi
callq 0x3100
cmpq $0x0, %rax
jne 0xf820
movq -0x18(%rbp), %rax
movb 0x20(%rax), %cl
xorb $-0x1, %cl
andb $0x1, %cl
movb %cl, 0x20(%rax)
jmp 0xf862
movq -0x10(%rbp), %rdi
leaq 0x1bc2f(%rip), %rsi     # 0x2b45a
callq 0x3300
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
je 0xf855
movq -0x10(%rbp), %rdi
leaq 0x1cdc4(%rip), %rsi     # 0x2c60b
callq 0x3300
cmpl $0x0, %eax
sete %al
movb %al, -0x19(%rbp)
movq -0x18(%rbp), %rax
movb -0x19(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x20(%rax)
movb $0x1, %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: hzeller[P]gcode-multi-shell-extrude/vector2d.cc
// Function: Centroid(std::vector<Vector2D, std::allocator<Vector2D>> const&)
Vector2D Centroid(const Polygon &polygon) {
    Vector2D result;
    for (Polygon::size_type i = 0; i < polygon.size(); ++i) {
        result = result + polygon[i];
    }
    return result / polygon.size();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x18(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x8520
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0x82d0
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x10a7b
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x8340
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
callq 0x8c40
movsd %xmm0, -0x40(%rbp)
movsd %xmm1, -0x38(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x10a1d
movq -0x18(%rbp), %rdi
callq 0x82d0
movq %rax, %rdx
shrq %rdx
movl %eax, %ecx
andl $0x1, %ecx
orq %rdx, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
cvtsi2ss %rax, %xmm1
movss %xmm1, -0x50(%rbp)
testq %rax, %rax
movss %xmm0, -0x4c(%rbp)
js 0x10ab9
movss -0x50(%rbp), %xmm0
movss %xmm0, -0x4c(%rbp)
movss -0x4c(%rbp), %xmm0
leaq -0x28(%rbp), %rdi
callq 0x8cb0
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x8(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::PolyTree::Clear()
void PolyTree::Clear()
{
    for (PolyNodes::size_type i = 0; i < AllNodes.size(); ++i)
      delete AllNodes[i];
    AllNodes.resize(0); 
    Childs.resize(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
addq $0x48, %rdi
callq 0x201e0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x10b72
movq -0x18(%rbp), %rdi
addq $0x48, %rdi
movq -0x10(%rbp), %rsi
callq 0x20200
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x10b62
movq -0x28(%rbp), %rdi
callq 0x20220
movq -0x28(%rbp), %rdi
movl $0x48, %esi
callq 0x3290
jmp 0x10b64
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x10b0c
movq -0x18(%rbp), %rdi
addq $0x48, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x20250
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x20250
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::PolyNode::AddChild(ClipperLib::PolyNode&)
void PolyNode::AddChild(PolyNode& child)
{
  unsigned cnt = (unsigned)Childs.size();
  Childs.push_back(&child);
  child.Parent = this;
  child.Index = cnt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x18, %rdi
callq 0x201e0
movq -0x28(%rbp), %rdi
movl %eax, -0x14(%rbp)
addq $0x18, %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x20360
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x38(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::PolyNode::GetNextSiblingUp() const
PolyNode* PolyNode::GetNextSiblingUp() const
{ 
  if (!Parent) //protects against PolyTree.GetNextSiblingUp()
      return 0;
  else if (Index == Parent->Childs.size() - 1)
      return Parent->GetNextSiblingUp();
  else
      return Parent->Childs[Index + 1];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x30(%rax)
jne 0x10d75
movq $0x0, -0x8(%rbp)
jmp 0x10dd2
movq -0x18(%rbp), %rax
movl 0x38(%rax), %ecx
movq %rcx, -0x20(%rbp)
movq 0x30(%rax), %rdi
addq $0x18, %rdi
callq 0x201e0
movq %rax, %rcx
movq -0x20(%rbp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jne 0x10db0
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x10d50
movq %rax, -0x8(%rbp)
jmp 0x10dd2
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
addq $0x18, %rdi
movl 0x38(%rax), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x20200
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::PolyNode::IsHole() const
bool PolyNode::IsHole() const
{ 
  bool result = true;
  PolyNode* node = Parent;
  while (node)
  {
      result = !result;
      node = node->Parent;
  }
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb $0x1, -0x9(%rbp)
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x10e17
movb -0x9(%rbp), %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x10df8
movb -0x9(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
setl %al
andb $0x1, %al
movzbl %al, %eax
cmpq $0x0, -0x18(%rbp)
setl %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
setne %al
andb $0x1, %al
movb %al, -0x19(%rbp)
cmpq $0x0, -0x10(%rbp)
jge 0x10e98
xorl %eax, %eax
subq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
shrq $0x20, %rax
movq %rax, -0x28(%rbp)
movabsq $0xffffffff, %rax       # imm = 0xFFFFFFFF
andq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
jge 0x10ec7
xorl %eax, %eax
subq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x78(%rbp), %rdi
movq -0x18(%rbp), %rax
shrq $0x20, %rax
movq %rax, -0x38(%rbp)
movabsq $0xffffffff, %rax       # imm = 0xFFFFFFFF
andq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
imulq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rax
imulq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rax
imulq -0x40(%rbp), %rax
movq -0x30(%rbp), %rcx
imulq -0x38(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x58(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x20390
movq -0x78(%rbp), %rax
movq -0x48(%rbp), %rcx
movq -0x58(%rbp), %rdx
shrq $0x20, %rdx
addq %rdx, %rcx
movq %rcx, 0x8(%rax)
movq -0x58(%rbp), %rcx
shlq $0x20, %rcx
movq %rcx, (%rax)
movq -0x50(%rbp), %rcx
addq (%rax), %rcx
movq %rcx, (%rax)
movq (%rax), %rax
cmpq -0x50(%rbp), %rax
jae 0x10f6a
movq -0x78(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
testb $0x1, -0x19(%rbp)
je 0x10f90
movq -0x78(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x203d0
movq -0x78(%rbp), %rax
movq -0x68(%rbp), %rcx
movq %rcx, (%rax)
movq -0x60(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x70(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::Area(std::vector<ClipperLib::IntPoint, std::allocator<ClipperLib::IntPoint>> const&)
double Area(const Path &poly)
{
  int size = (int)poly.size();
  if (size < 3) return 0;

  double a = 0;
  for (int i = 0, j = size -1; i < size; ++i)
  {
    a += ((double)poly[j].X + poly[i].X) * ((double)poly[j].Y - poly[i].Y);
    j = i;
  }
  return -a * 0.5;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xd900
movl %eax, -0x14(%rbp)
cmpl $0x3, -0x14(%rbp)
jge 0x10ffb
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x110e2
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x110b5
movq -0x10(%rbp), %rdi
movslq -0x28(%rbp), %rsi
callq 0x20460
cvtsi2sdq (%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0x20460
movsd -0x40(%rbp), %xmm0
cvtsi2sdq (%rax), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x28(%rbp), %rsi
callq 0x20460
cvtsi2sdq 0x8(%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0x20460
movsd -0x38(%rbp), %xmm2
movsd -0x30(%rbp), %xmm0
cvtsi2sdq 0x8(%rax), %xmm1
subsd %xmm1, %xmm2
movsd -0x20(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x11013
movsd -0x20(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd 0x1aebf(%rip), %xmm1    # 0x2bf98
mulsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x11115
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x1118d
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
addq 0x8(%rcx), %rax
cvtsi2sd %rax, %xmm0
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
subq 0x10(%rcx), %rax
cvtsi2sd %rax, %xmm2
movsd -0x20(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jne 0x1111d
movsd 0x1ae15(%rip), %xmm0    # 0x2bf98
mulsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
callq 0x20480
testb $0x1, %al
jne 0x111cf
jmp 0x111d5
movb $0x1, -0x1(%rbp)
jmp 0x111ef
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x111b8
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
callq 0x11530
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jl 0x11890
cmpl $0x0, -0x24(%rbp)
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x118aa
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x11868
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x11ed1
jmp 0x11f13
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x8(%rbp), %rax
jne 0x11ed9
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x11f38
jmp 0x11f90
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x20(%rax), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x11f90
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x11f8e
movq -0x18(%rbp), %rdi
movl $0x28, %esi
callq 0x3290
jmp 0x11f4b
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x60(%rcx), %rcx
cmpq 0x18(%rcx), %rax
jl 0x11ffa
movq -0x8(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x10(%rcx), %rdx
movq %rdx, (%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x10(%rcx), %rdx
movq %rdx, 0x20(%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x28(%rax)
jmp 0x1202d
movq -0x8(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x10(%rcx), %rdx
movq %rdx, 0x20(%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x10(%rcx), %rdx
movq %rdx, (%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
callq 0x20600
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x48(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::RemoveEdge(ClipperLib::TEdge*)
TEdge* RemoveEdge(TEdge* e)
{
  //removes e from double_linked_list (but without removing from memory)
  e->Prev->Next = e->Next;
  e->Next->Prev = e->Prev;
  TEdge* result = e->Next;
  e->Prev = 0; //flag as removed (see ClipperBase.Clear)
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movq %rcx, 0x60(%rax)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq %rcx, 0x68(%rax)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x68(%rax)
movq -0x10(%rbp), %rax
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x8(%rbp), %rax
je 0x126f5
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jle 0x12672
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
jmp 0x126e4
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x126e2
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jg 0x126e2
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jge 0x126ba
movq $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x126e0
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
cmpq -0x8(%rbp), %rax
je 0x126de
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
cmpq -0x8(%rbp), %rax
je 0x126de
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x126e0
jmp 0x126e2
jmp 0x126e4
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x12640
cmpq $0x0, -0x10(%rbp)
je 0x1275a
jmp 0x126fe
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0x12758
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x122d0
testb $0x1, %al
jne 0x12721
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movq -0x8(%rbp), %rsi
addq $0x8, %rsi
callq 0x20710
testb $0x1, %al
jne 0x12748
jmp 0x12756
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x1272d
jmp 0x126fe
jmp 0x1275a
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::Pt2IsBetweenPt1AndPt3(ClipperLib::IntPoint, ClipperLib::IntPoint, ClipperLib::IntPoint)
bool Pt2IsBetweenPt1AndPt3(const IntPoint pt1,
  const IntPoint pt2, const IntPoint pt3)
{
  if ((pt1 == pt3) || (pt1 == pt2) || (pt3 == pt2))
    return false;
  else if (pt1.X != pt3.X)
    return (pt2.X > pt1.X) == (pt2.X < pt3.X);
  else
    return (pt2.Y > pt1.Y) == (pt2.Y < pt3.Y);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x38(%rbp)
movq %r9, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x20480
testb $0x1, %al
jne 0x12a65
leaq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x20480
testb $0x1, %al
jne 0x12a65
leaq -0x38(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x20480
testb $0x1, %al
jne 0x12a65
jmp 0x12a6b
movb $0x0, -0x1(%rbp)
jmp 0x12acd
movq -0x18(%rbp), %rax
cmpq -0x38(%rbp), %rax
je 0x12aa2
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
setg %al
andb $0x1, %al
movzbl %al, %eax
movq -0x28(%rbp), %rcx
cmpq -0x38(%rbp), %rcx
setl %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x12acd
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
setg %al
andb $0x1, %al
movzbl %al, %eax
movq -0x20(%rbp), %rcx
cmpq -0x30(%rbp), %rcx
setl %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdx, -0x10(%rbp)
movq %rcx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0x12b29
movl $0x8, %edi
callq 0x3110
movq %rax, %rdi
leaq 0x19c15(%rip), %rax     # 0x2c72b
movq %rax, (%rdi)
movq 0x284a0(%rip), %rsi     # 0x3afc0
xorl %eax, %eax
movl %eax, %edx
callq 0x3430
movl $0x28, %edi
callq 0x3280
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
callq 0x20750
jmp 0x12b44
movq -0x40(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jne 0x12bbc
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x12bec
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl $0x28, %esi
callq 0x3290
jmp 0x12bf6
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x3440
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
cmpq (%rcx), %rax
setg %al
andb $0x1, %al
movzbl %al, %eax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq -0x28(%rbp), %rdx
cmpq (%rdx), %rcx
setl %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x12c4e
movb $0x1, -0x1(%rbp)
jmp 0x12d49
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
cmpq (%rcx), %rax
setg %al
andb $0x1, %al
movzbl %al, %eax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movq -0x28(%rbp), %rdx
cmpq (%rdx), %rcx
setl %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x12c88
movb $0x1, -0x1(%rbp)
jmp 0x12d49
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
setg %al
andb $0x1, %al
movzbl %al, %eax
movq -0x20(%rbp), %rcx
movq (%rcx), %rcx
movq -0x18(%rbp), %rdx
cmpq (%rdx), %rcx
setl %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x12cc2
movb $0x1, -0x1(%rbp)
jmp 0x12d49
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
setg %al
andb $0x1, %al
movzbl %al, %eax
movq -0x28(%rbp), %rcx
movq (%rcx), %rcx
movq -0x18(%rbp), %rdx
cmpq (%rdx), %rcx
setl %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x12cf9
movb $0x1, -0x1(%rbp)
jmp 0x12d49
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x12d1f
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x12d1f
movb $0x1, -0x1(%rbp)
jmp 0x12d49
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x12d45
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x12d45
movb $0x1, -0x1(%rbp)
jmp 0x12d49
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, (%rax)
je 0x12ebe
movq -0x8(%rbp), %rax
movabsq $0x3fffffffffffffff, %rcx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rcx, (%rax)
jg 0x12e95
movq -0x8(%rbp), %rax
movabsq $0x3fffffffffffffff, %rcx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rcx, 0x8(%rax)
jg 0x12e95
movq -0x8(%rbp), %rcx
xorl %eax, %eax
subq (%rcx), %rax
movabsq $0x3fffffffffffffff, %rcx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rcx, %rax
jg 0x12e95
movq -0x8(%rbp), %rcx
xorl %eax, %eax
subq 0x8(%rcx), %rax
movabsq $0x3fffffffffffffff, %rcx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rcx, %rax
jle 0x12ebc
movl $0x8, %edi
callq 0x3110
movq %rax, %rdi
leaq 0x1988c(%rip), %rax     # 0x2c735
movq %rax, (%rdi)
movq 0x2810d(%rip), %rsi     # 0x3afc0
xorl %eax, %eax
movl %eax, %edx
callq 0x3430
jmp 0x12f12
movq -0x8(%rbp), %rax
cmpq $0x3fffffff, (%rax)     # imm = 0x3FFFFFFF
jg 0x12efc
movq -0x8(%rbp), %rax
cmpq $0x3fffffff, 0x8(%rax)  # imm = 0x3FFFFFFF
jg 0x12efc
movq -0x8(%rbp), %rcx
xorl %eax, %eax
subq (%rcx), %rax
cmpq $0x3fffffff, %rax       # imm = 0x3FFFFFFF
jg 0x12efc
movq -0x8(%rbp), %rcx
xorl %eax, %eax
subq 0x8(%rcx), %rax
cmpq $0x3fffffff, %rax       # imm = 0x3FFFFFFF
jle 0x12f10
movq -0x10(%rbp), %rax
movb $0x1, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x12e20
jmp 0x12f12
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
jmp 0x12f2e
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rsi
callq 0x20710
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x11(%rbp)
jne 0x12f63
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movq -0x8(%rbp), %rsi
addq $0x20, %rsi
callq 0x20480
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x12f6c
jmp 0x12f7a
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x12f2e
movq -0x8(%rbp), %rdi
callq 0x20510
testb $0x1, %al
jne 0x12f9d
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdi
callq 0x20510
testb $0x1, %al
jne 0x12f9d
jmp 0x1301e
jmp 0x12f9f
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdi
callq 0x20510
testb $0x1, %al
jne 0x12fb2
jmp 0x12fc0
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x12f9f
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x20510
testb $0x1, %al
jne 0x12fd7
jmp 0x12fe5
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x12fc8
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x68(%rcx), %rcx
cmpq 0x8(%rcx), %rax
jne 0x13000
jmp 0x12f2c
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jge 0x1301c
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1301e
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::ClipperBase::InsertLocalMinima(ClipperLib::LocalMinima*)
void ClipperBase::InsertLocalMinima(LocalMinima *newLm)
{
  if( ! m_MinimaList )
  {
    m_MinimaList = newLm;
  }
  else if( newLm->Y >= m_MinimaList->Y )
  {
    newLm->Next = m_MinimaList;
    m_MinimaList = newLm;
  } else
  {
    LocalMinima* tmpLm = m_MinimaList;
    while( tmpLm->Next  && ( newLm->Y < tmpLm->Next->Y ) )
      tmpLm = tmpLm->Next;
    newLm->Next = tmpLm->Next;
    tmpLm->Next = newLm;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x10(%rax)
jne 0x135cc
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x10(%rax)
jmp 0x13663
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rcx), %rcx
cmpq (%rcx), %rax
jl 0x135fa
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x10(%rbp), %rcx
movq %rdx, 0x18(%rcx)
movq -0x10(%rbp), %rcx
movq %rcx, 0x10(%rax)
jmp 0x13661
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x18(%rcx)
movb %al, -0x21(%rbp)
je 0x1362e
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpq (%rcx), %rax
setl %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x13637
jmp 0x13645
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x13606
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0x13663
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movb $0x0, -0x16(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0xcb30
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x14249
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x20a60
movq -0x28(%rbp), %rdi
movq %rax, %rsi
movl -0x14(%rbp), %edx
movb -0x15(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
callq 0x13670
testb $0x1, %al
jne 0x14235
jmp 0x14239
movb $0x1, -0x16(%rbp)
jmp 0x1423b
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x141ee
movb -0x16(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x14300
movq $0x0, -0x10(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
addq $0x20, %rdi
callq 0x20a80
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x142e1
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
movq -0x10(%rbp), %rsi
callq 0x20aa0
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x142d1
movq -0x30(%rbp), %rdi
callq 0x3360
jmp 0x142d3
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x14281
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
callq 0x20ac0
movq -0x20(%rbp), %rax
movb $0x0, 0x18(%rax)
movb $0x0, 0x39(%rax)
addq $0x30, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x14359
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq 0x18(%rcx), %rcx
movq %rcx, -0x10(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x1434b
movq -0x20(%rbp), %rdi
movl $0x20, %esi
callq 0x3290
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x10(%rax)
jmp 0x14314
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::ClipperBase::Reset()
void ClipperBase::Reset()
{
  m_CurrentLM = m_MinimaList;
  if( !m_CurrentLM ) return; //ie nothing to process

  //reset all edges ...
  LocalMinima* lm = m_MinimaList;
  while( lm )
  {
    TEdge* e = lm->LeftBound;
    if (e)
    {
      e->Curr = e->Bot;
      e->Side = esLeft;
      e->OutIdx = Unassigned;
    }

    e = lm->RightBound;
    if (e)
    {
      e->Curr = e->Bot;
      e->Side = esRight;
      e->OutIdx = Unassigned;
    }
    lm = lm->Next;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x10(%rax), %rcx
movq %rcx, 0x8(%rax)
cmpq $0x0, 0x8(%rax)
jne 0x14394
jmp 0x1443c
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1443c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x143eb
movq -0x18(%rbp), %rcx
movq -0x18(%rbp), %rax
movq (%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movl $0x1, 0x4c(%rax)
movq -0x18(%rbp), %rax
movl $0xffffffff, 0x5c(%rax) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1442b
movq -0x18(%rbp), %rcx
movq -0x18(%rbp), %rax
movq (%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movl $0x2, 0x4c(%rax)
movq -0x18(%rbp), %rax
movl $0xffffffff, 0x5c(%rax) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x143a0
popq %rbp
retq
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0xc0, %rdi
callq 0x12d50
movq -0x18(%rbp), %rdi
leaq 0x264ea(%rip), %rax     # 0x3ac98
addq $0x18, %rax
movq %rax, (%rdi)
leaq 0x264dc(%rip), %rax     # 0x3ac98
addq $0x60, %rax
movq %rax, 0xc0(%rdi)
addq $0x8, %rdi
callq 0x20ae0
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
callq 0x20b00
movq -0x18(%rbp), %rdi
addq $0x38, %rdi
callq 0x20b00
movq -0x18(%rbp), %rdi
addq $0x50, %rdi
callq 0x20b20
movq -0x18(%rbp), %rdi
addq $0x70, %rdi
callq 0x20b40
movq -0x18(%rbp), %rax
movq $0x0, 0xa0(%rax)
movq $0x0, 0xa8(%rax)
movb $0x0, 0xb0(%rax)
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movb $0x0, 0x18(%rax,%rcx)
movl -0xc(%rbp), %ecx
andl $0x1, %ecx
cmpl $0x0, %ecx
setne %cl
andb $0x1, %cl
movb %cl, 0xbc(%rax)
movl -0xc(%rbp), %ecx
andl $0x2, %ecx
cmpl $0x0, %ecx
setne %cl
andb $0x1, %cl
movb %cl, 0xbe(%rax)
movl -0xc(%rbp), %ecx
andl $0x4, %ecx
cmpl $0x0, %ecx
setne %dl
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
andb $0x1, %dl
movb %dl, 0x38(%rax,%rcx)
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movb $0x0, 0x39(%rax,%rcx)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x14370
movq -0x18(%rbp), %rdi
addq $0x70, %rdi
callq 0x20b60
movq -0x18(%rbp), %rax
movq $0x0, 0xa0(%rax)
movq $0x0, 0xa8(%rax)
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq 0x10(%rax,%rcx), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x14a6c
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x14a80
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x14a47
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
testb $0x1, 0xb0(%rax)
je 0x14b04
movb $0x0, -0x1(%rbp)
jmp 0x14bde
movq -0x40(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x1, 0x39(%rax,%rcx)
je 0x14b69
movl $0x28, %edi
callq 0x3110
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
leaq 0x17c4d(%rip), %rsi     # 0x2c77e
callq 0x20830
jmp 0x14b38
movq -0x48(%rbp), %rdi
leaq 0x2621d(%rip), %rsi     # 0x3ad60
leaq 0xbd86(%rip), %rdx      # 0x208d0
callq 0x3430
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x31c0
jmp 0x14be9
movq -0x40(%rbp), %rax
movb $0x1, 0xb0(%rax)
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x20cc0
movq -0x40(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, 0xb8(%rdi)
movl -0x28(%rbp), %eax
movl %eax, 0xb4(%rdi)
movl -0x14(%rbp), %eax
movl %eax, 0x68(%rdi)
movb $0x0, 0xbd(%rdi)
movq (%rdi), %rax
callq *0x18(%rax)
andb $0x1, %al
movb %al, -0x35(%rbp)
testb $0x1, -0x35(%rbp)
je 0x14bc2
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x14c00
movq -0x40(%rbp), %rdi
callq 0x14d80
movq -0x40(%rbp), %rax
movb $0x0, 0xb0(%rax)
movb -0x35(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x3440
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
addq $0x8, %rdi
callq 0x20d70
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0x21400
movq $0x0, -0x18(%rbp)
movq -0x60(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
addq $0x8, %rdi
callq 0x20d70
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
jae 0x14d62
movq -0x60(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
callq 0x20d90
movq (%rax), %rax
cmpq $0x0, 0x18(%rax)
jne 0x14c82
jmp 0x14d51
leaq -0x30(%rbp), %rdi
callq 0xca90
movq -0x60(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
callq 0x20d90
movq (%rax), %rax
movq 0x18(%rax), %rax
movq 0x20(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x1a440
movl %eax, -0x3c(%rbp)
cmpl $0x2, -0x3c(%rbp)
jge 0x14cc6
movl $0x4, -0x40(%rbp)
jmp 0x14d3b
movslq -0x3c(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x21500
jmp 0x14cd5
movl $0x0, -0x50(%rbp)
movl -0x50(%rbp), %eax
cmpl -0x3c(%rbp), %eax
jge 0x14d25
movq -0x38(%rbp), %rsi
addq $0x8, %rsi
leaq -0x30(%rbp), %rdi
callq 0x21600
jmp 0x14cf7
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x38(%rbp)
movl -0x50(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x50(%rbp)
jmp 0x14cdc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xcff0
jmp 0x14d68
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x21670
jmp 0x14d34
movl $0x0, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xcff0
movl -0x40(%rbp), %eax
testl %eax, %eax
je 0x14d4f
jmp 0x14d4d
jmp 0x14d51
jmp 0x14d51
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x14c3d
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3440
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
testb $0x1, 0xb0(%rax)
je 0x14e21
movb $0x0, -0x1(%rbp)
jmp 0x14e85
movq -0x38(%rbp), %rdi
movb $0x1, 0xb0(%rdi)
movl -0x24(%rbp), %eax
movl %eax, 0xb8(%rdi)
movl -0x28(%rbp), %eax
movl %eax, 0xb4(%rdi)
movl -0x14(%rbp), %eax
movl %eax, 0x68(%rdi)
movb $0x1, 0xbd(%rdi)
movq (%rdi), %rax
callq *0x18(%rax)
andb $0x1, %al
movb %al, -0x29(%rbp)
testb $0x1, -0x29(%rbp)
je 0x14e69
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x14e90
movq -0x38(%rbp), %rdi
callq 0x14d80
movq -0x38(%rbp), %rax
movb $0x0, 0xb0(%rax)
movb -0x29(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq