LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/bonetblai[P]mdp-engine/race/parsing.cc
// Function: ps::draw_text(std::ostream&, float, float, float, int, char*)
void draw_text(ostream &os, float x, float y, float angle, int ptsz, char *text) {
    os << "0 0 0 setrgbcolor" << endl
       << "/Helvetica " << ptsz << " selectfont" << endl
       << x << " " << y << " moveto " << angle << " rotate" << endl
       << "(" << text << ") show" << endl;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movss %xmm2, 0xc(%rsp)
movss %xmm1, 0x8(%rsp)
movss %xmm0, 0x4(%rsp)
movq %rdi, %r14
leaq 0x54f7(%rip), %rsi      # 0x2ad1e
movl $0x11, %edx
callq 0x52d0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x5250
movsbl %al, %esi
movq %r14, %rdi
callq 0x5040
movq %rax, %rdi
callq 0x51b0
movq %rax, %r14
leaq 0x5534(%rip), %rsi      # 0x2ad96
movl $0xb, %edx
movq %rax, %rdi
callq 0x52d0
movq %r14, %rdi
movl %ebp, %esi
callq 0x5430
movq %rax, %r14
leaq 0x551f(%rip), %rsi      # 0x2ada2
movl $0xb, %edx
movq %rax, %rdi
callq 0x52d0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x5250
movsbl %al, %esi
movq %r14, %rdi
callq 0x5040
movq %rax, %rdi
callq 0x51b0
xorps %xmm0, %xmm0
cvtss2sd 0x4(%rsp), %xmm0
movq %rax, %rdi
callq 0x53b0
movq %rax, %r14
leaq 0x55ac(%rip), %rsi      # 0x2ae7e
movl $0x1, %edx
movq %rax, %rdi
callq 0x52d0
xorps %xmm0, %xmm0
cvtss2sd 0x8(%rsp), %xmm0
movq %r14, %rdi
callq 0x53b0
movq %rax, %r14
leaq 0x53e9(%rip), %rsi      # 0x2ace3
movl $0x8, %edx
movq %rax, %rdi
callq 0x52d0
xorps %xmm0, %xmm0
cvtss2sd 0xc(%rsp), %xmm0
movq %r14, %rdi
callq 0x53b0
movq %rax, %r14
leaq 0x548c(%rip), %rsi      # 0x2adae
movl $0x7, %edx
movq %rax, %rdi
callq 0x52d0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x5250
movsbl %al, %esi
movq %r14, %rdi
callq 0x5040
movq %rax, %rdi
callq 0x51b0
movq %rax, %r14
leaq 0x2507(%rip), %rsi      # 0x27e67
movl $0x1, %edx
movq %rax, %rdi
callq 0x52d0
testq %rbx, %rbx
je 0x2598a
movq %rbx, %rdi
callq 0x5110
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x52d0
jmp 0x259a4
movq (%r14), %rax
movq -0x18(%rax), %rax
movq %r14, %rdi
addq %rax, %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x5410
leaq 0x540b(%rip), %rsi      # 0x2adb6
movl $0x6, %edx
movq %r14, %rdi
callq 0x52d0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x5250
movsbl %al, %esi
movq %r14, %rdi
callq 0x5040
movq %rax, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x51b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/hzeller[P]gcode-multi-shell-extrude/multi-shell-extrude.cc
// Function: OffsetCenter(std::vector<Vector2D, std::allocator<Vector2D>> const&, double, double)
Polygon OffsetCenter(const Polygon& polygon, double x_offset, double y_offset) {
  Polygon result;
  for (const Vector2D &p : polygon) {
    result.push_back(Vector2D(p.x + x_offset, p.y + y_offset));
  }
  return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movapd %xmm0, (%rsp)
movq %rdi, %rbx
xorpd %xmm0, %xmm0
movupd %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rsi), %r15
movq 0x8(%rsi), %r12
cmpq %r12, %r15
je 0x39f2
movapd (%rsp), %xmm0
unpcklpd %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
movapd %xmm0, (%rsp)
leaq 0x10(%rsp), %r14
movupd (%r15), %xmm0
addpd (%rsp), %xmm0
movapd %xmm0, 0x10(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x39de
movapd 0x10(%rsp), %xmm0
movupd %xmm0, (%rsi)
addq $0x10, 0x8(%rbx)
jmp 0x39e9
movq %rbx, %rdi
movq %r14, %rdx
callq 0x650a
addq $0x10, %r15
cmpq %r12, %r15
jne 0x39b3
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x3a18
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x3220
movq %r14, %rdi
callq 0x3380
// File: /workspace/github_cpp_makefile_star2_O3/hzeller[P]gcode-multi-shell-extrude/multi-shell-extrude.cc
// Function: RadialPumpPolygon(std::vector<Vector2D, std::allocator<Vector2D>> const&, double)
Polygon RadialPumpPolygon(const Polygon& polygon, double pump_r) {
  if (pump_r <= 0)
    return polygon;
  Polygon result;
  for (const Vector2D &p : polygon) {
    double from_center = distance(p.x, p.y, 0);
    double stretch = (from_center + pump_r) / from_center;
    result.push_back(Vector2D(p.x * stretch, p.y * stretch));
  }
  return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorpd %xmm1, %xmm1
movsd %xmm0, 0x8(%rsp)
ucomisd %xmm0, %xmm1
jae 0x3ca0
xorpd %xmm0, %xmm0
movupd %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq (%rsi), %r15
movq 0x8(%rsi), %r12
cmpq %r12, %r15
je 0x3ca8
leaq 0x10(%rsp), %r14
movupd (%r15), %xmm0
movapd %xmm0, %xmm1
mulpd %xmm0, %xmm1
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
movapd %xmm0, %xmm2
mulsd %xmm0, %xmm2
addsd %xmm1, %xmm2
xorps %xmm1, %xmm1
sqrtsd %xmm2, %xmm1
movapd %xmm1, %xmm2
addsd 0x8(%rsp), %xmm2
divsd %xmm1, %xmm2
unpcklpd %xmm2, %xmm2            # xmm2 = xmm2[0,0]
mulpd %xmm0, %xmm2
movapd %xmm2, 0x10(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x3c8a
movapd 0x10(%rsp), %xmm0
movupd %xmm0, (%rsi)
addq $0x10, 0x8(%rbx)
jmp 0x3c95
movq %rbx, %rdi
movq %r14, %rdx
callq 0x650a
addq $0x10, %r15
cmpq %r12, %r15
jne 0x3c2f
jmp 0x3ca8
movq %rbx, %rdi
callq 0x6262
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x3cce
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x3220
movq %r14, %rdi
callq 0x3380
// File: /workspace/github_cpp_makefile_star2_O3/hzeller[P]gcode-multi-shell-extrude/multi-shell-extrude.cc
// Function: GetRadius(std::vector<Vector2D, std::allocator<Vector2D>> const&)
double GetRadius(const Polygon &polygon) {
  double dist = -1;
  for (size_t i = 0; i < polygon.size(); ++i) {
    dist = std::max(dist, distance(polygon[i].x, polygon[i].y, 0));
  }
  return dist;
}

// Assembly:
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
je 0x3d25
sarq $0x4, %rcx
cmpq $0x1, %rcx
adcq $0x0, %rcx
addq $0x8, %rax
movsd 0x10396(%rip), %xmm1    # 0x14090
movsd -0x8(%rax), %xmm0
movsd (%rax), %xmm2
mulsd %xmm2, %xmm2
mulsd %xmm0, %xmm0
addsd %xmm2, %xmm0
sqrtsd %xmm0, %xmm0
maxsd %xmm1, %xmm0
addq $0x10, %rax
movapd %xmm0, %xmm1
decq %rcx
jne 0x3cfa
retq
movsd 0x10363(%rip), %xmm0    # 0x14090
retq
// File: /workspace/github_cpp_makefile_star2_O3/hzeller[P]gcode-multi-shell-extrude/printer.cc
// Function: (anonymous namespace)::GCodePrinter::Postamble()
virtual void Postamble() {
    printf("M104 S0 ; hotend off\n");
    printf("M140 S0 ; heated bed off\n");
    printf("M106 S0 ; fan off\n");
    printf("G1 X0\n");  // We keep z-axis as is.
    printf("G92 E0.0\n");
    printf("M84\n");
  }

// Assembly:
pushq %rax
leaq 0xddf3(%rip), %rdi      # 0x15553
callq 0x32f0
leaq 0xddfc(%rip), %rdi      # 0x15568
callq 0x32f0
leaq 0xde09(%rip), %rdi      # 0x15581
callq 0x32f0
leaq 0xde0f(%rip), %rdi      # 0x15593
callq 0x32f0
leaq 0xde09(%rip), %rdi      # 0x15599
callq 0x32f0
leaq 0xde06(%rip), %rdi      # 0x155a2
popq %rax
jmp 0x32f0
// File: /workspace/github_cpp_makefile_star2_O3/hzeller[P]gcode-multi-shell-extrude/printer.cc
// Function: (anonymous namespace)::GCodePrinter::SetSpeed(double)
virtual void SetSpeed(double feed_mm_per_sec) {
    if (feed_mm_per_sec != current_feedrate_) {
      printf("G1 F%.1f  ; feedrate=%.1fmm/s\n", feed_mm_per_sec * 60,
             feed_mm_per_sec);
      current_feedrate_ = feed_mm_per_sec;
    }
  }

// Assembly:
movapd %xmm0, %xmm1
movsd 0x18(%rdi), %xmm0
ucomisd %xmm1, %xmm0
jne 0x788b
jnp 0x78c3
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movsd 0xd715(%rip), %xmm0     # 0x14fb0
mulsd %xmm1, %xmm0
leaq 0xd86f(%rip), %rdi      # 0x15115
movsd %xmm1, 0x8(%rsp)
movb $0x2, %al
callq 0x3040
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x18(%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/hzeller[P]gcode-multi-shell-extrude/printer.cc
// Function: (anonymous namespace)::GCodePrinter::ResetExtrude()
virtual void ResetExtrude() {
    assert(in_retract_);
    in_retract_ = false;
    printf("M83      ; relative E\n"  // extruder relative mode
           "G1 E%.1f  ; filament back to nozzle tip\n"
           "M82      ; absolute E\n", // extruder absolute mode
           1.1 * retract_amount_);  // fudging... a bit more squeeze.
    printf("G92 E0.0 ; start extrusion, set E to zero\n");
    extrude_dist_ = 0;
  }

// Assembly:
pushq %rbx
cmpb $0x0, 0x50(%rdi)
je 0x7903
movq %rdi, %rbx
movb $0x0, 0x50(%rdi)
movsd 0x10(%rdi), %xmm0
mulsd 0xd6f9(%rip), %xmm0     # 0x14fd8
leaq 0xd89a(%rip), %rdi      # 0x15180
movb $0x1, %al
callq 0x3040
leaq 0xdcb2(%rip), %rdi      # 0x155a6
callq 0x32f0
movq $0x0, 0x48(%rbx)
popq %rbx
retq
leaq 0xd8cc(%rip), %rdi      # 0x151d6
leaq 0xd823(%rip), %rsi      # 0x15134
leaq 0xd827(%rip), %rcx      # 0x1513f
movl $0x76, %edx
callq 0x3150
// File: /workspace/github_cpp_makefile_star2_O3/hzeller[P]gcode-multi-shell-extrude/printer.cc
// Function: (anonymous namespace)::GCodePrinter::Retract()
virtual void Retract() {
    assert(!in_retract_);
    printf("M83      ; relative E\n"
           "G1 E%.1f ; retract\n"
           "M82      ; Back to absolute\n", -retract_amount_);
    in_retract_ = true;
  }

// Assembly:
pushq %rbx
cmpb $0x1, 0x50(%rdi)
je 0x794c
movq %rdi, %rbx
movsd 0x10(%rdi), %xmm0
xorps 0xc748(%rip), %xmm0     # 0x14080
leaq 0xd8df(%rip), %rdi      # 0x1521e
movb $0x1, %al
callq 0x3040
movb $0x1, 0x50(%rbx)
popq %rbx
retq
leaq 0xd882(%rip), %rdi      # 0x151d5
leaq 0xd7da(%rip), %rsi      # 0x15134
leaq 0xd881(%rip), %rcx      # 0x151e2
movl $0x80, %edx
callq 0x3150
nop
// File: /workspace/github_cpp_makefile_star2_O3/hzeller[P]gcode-multi-shell-extrude/printer.cc
// Function: (anonymous namespace)::GCodePrinter::ExtrudeTo(Vector2D const&, double, double)
virtual void ExtrudeTo(const Vector2D &pos, double z,
                         double extrusion_multiplier) {
    extrude_dist_ += distance(pos.x - last_x, pos.y - last_y, z - last_z);
    printf("G1 X%.3f Y%.3f Z%.3f E%.3f\n", pos.x, pos.y, z,
           extrude_dist_ * filament_extrusion_factor_ * extrusion_multiplier);
    last_x = pos.x; last_y = pos.y; last_z = z;
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movsd (%rsi), %xmm7
movapd %xmm7, %xmm3
subsd 0x30(%rdi), %xmm3
movsd 0x8(%rsi), %xmm4
movapd %xmm4, %xmm5
subsd 0x38(%rdi), %xmm5
movapd %xmm0, %xmm6
movapd %xmm0, %xmm2
movsd %xmm0, (%rsp)
subsd 0x40(%rdi), %xmm6
mulsd %xmm5, %xmm5
mulsd %xmm3, %xmm3
addsd %xmm5, %xmm3
mulsd %xmm6, %xmm6
addsd %xmm3, %xmm6
xorps %xmm3, %xmm3
sqrtsd %xmm6, %xmm3
addsd 0x48(%rdi), %xmm3
movsd %xmm3, 0x48(%rdi)
mulsd 0x8(%rdi), %xmm3
mulsd %xmm1, %xmm3
leaq 0xd85a(%rip), %rdi      # 0x15284
movapd %xmm7, %xmm0
movapd %xmm4, %xmm1
movb $0x4, %al
callq 0x3040
movups (%r14), %xmm0
movups %xmm0, 0x30(%rbx)
movsd (%rsp), %xmm0
movsd %xmm0, 0x40(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/hzeller[P]gcode-multi-shell-extrude/printer.cc
// Function: (anonymous namespace)::PostScriptPrinter::Init(Vector2D const&, double)
virtual void Init(const Vector2D &machine_limit,
                    double feed_mm_per_sec) {
    printf("/extrude-to { lineto } def\n");
    printf("72.0 25.4 div dup scale  %% Switch to mm\n");
    printf("1 setlinejoin\n");
    printf("%.2f setlinewidth %% mm\n", line_thickness_);
    printf("0 0 moveto\n");
  }

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0xdb2f(%rip), %rdi      # 0x155d0
callq 0x32f0
leaq 0xd82e(%rip), %rdi      # 0x152db
xorl %eax, %eax
callq 0x3040
leaq 0xdb30(%rip), %rdi      # 0x155eb
callq 0x32f0
cvtss2sd 0xc(%rbx), %xmm0
leaq 0xd839(%rip), %rdi      # 0x15305
movb $0x1, %al
callq 0x3040
leaq 0xdb1f(%rip), %rdi      # 0x155f9
popq %rbx
jmp 0x32f0
// File: /workspace/github_cpp_makefile_star2_O3/hzeller[P]gcode-multi-shell-extrude/printer.cc
// Function: (anonymous namespace)::PostScriptPrinter::MoveTo(Vector2D const&, double)
virtual void MoveTo(const Vector2D &pos, double z) {
    if (show_move_as_line_) {
      if (!in_move_color_) {
        ColorSwitch(0, 0, 0, 0.9);  // blue move color
        in_move_color_ = true;
      }
      printf("%.3f %.3f lineto\n", pos.x, pos.y);
    } else {
      printf("%.3f %.3f moveto\n", pos.x, pos.y);
    }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
cmpb $0x1, 0x8(%rdi)
jne 0x7bdb
movq %rdi, %r15
leaq 0xd7b0(%rip), %r14      # 0x15368
cmpb $0x0, 0x10(%rdi)
jne 0x7be2
movss 0xd422(%rip), %xmm3     # 0x14fe8
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
callq 0x7c72
movb $0x1, 0x10(%r15)
jmp 0x7be2
leaq 0xd798(%rip), %r14      # 0x1537a
movsd (%rbx), %xmm0
movsd 0x8(%rbx), %xmm1
movq %r14, %rdi
movb $0x2, %al
popq %rbx
popq %r14
popq %r15
jmp 0x3040
// File: /workspace/github_cpp_makefile_star2_O3/hzeller[P]gcode-multi-shell-extrude/printer.cc
// Function: (anonymous namespace)::PostScriptPrinter::ExtrudeTo(Vector2D const&, double, double)
virtual void ExtrudeTo(const Vector2D &pos, double /*z*/,
                         double /*extrusion_multiplier*/) {
    if (in_move_color_) {
      ColorSwitch(line_thickness_, r_, g_, b_);
      in_move_color_ = false;
    }
    printf("%.3f %.3f extrude-to\n", pos.x, pos.y);
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpb $0x1, 0x10(%rdi)
jne 0x7c28
movq %rdi, %r14
movss 0xc(%rdi), %xmm0
movss 0x14(%rdi), %xmm1
movss 0x18(%rdi), %xmm2
movss 0x1c(%rdi), %xmm3
callq 0x7c72
movb $0x0, 0x10(%r14)
movsd (%rbx), %xmm0
movsd 0x8(%rbx), %xmm1
leaq 0xd789(%rip), %rdi      # 0x153c1
movb $0x2, %al
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3040
// File: /workspace/github_cpp_makefile_star2_O3/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:
subq $0x18, %rsp
movss %xmm3, 0x14(%rsp)
movss %xmm2, 0x10(%rsp)
movss %xmm1, 0xc(%rsp)
movss %xmm0, 0x8(%rsp)
leaq 0xd97f(%rip), %rdi      # 0x15614
callq 0x32f0
xorps %xmm0, %xmm0
cvtss2sd 0x8(%rsp), %xmm0
leaq 0xd6e2(%rip), %rdi      # 0x1538c
movb $0x1, %al
callq 0x3040
xorps %xmm0, %xmm0
cvtss2sd 0xc(%rsp), %xmm0
xorps %xmm1, %xmm1
cvtss2sd 0x10(%rsp), %xmm1
xorps %xmm2, %xmm2
cvtss2sd 0x14(%rsp), %xmm2
leaq 0xd6d2(%rip), %rdi      # 0x153a5
movb $0x3, %al
callq 0x3040
leaq 0xd91c(%rip), %rdi      # 0x155fd
addq $0x18, %rsp
jmp 0x32f0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
je 0x7ec9
movq %rsi, %r14
cmpb $0x0, (%rsi)
je 0x7ec9
leaq 0xc5d3(%rip), %rsi      # 0x1447a
movq %r14, %rdi
callq 0x3250
testl %eax, %eax
je 0x7ecf
leaq 0xd771(%rip), %rsi      # 0x1562b
movq %r14, %rdi
callq 0x3250
testl %eax, %eax
sete %al
jmp 0x7ed1
xorb $0x1, 0x20(%rbx)
jmp 0x7ed4
movb $0x1, %al
movb %al, 0x20(%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
movq %rdx, %rax
subq %rcx, %rax
sarq $0x4, %rax
cmpq %rcx, %rdx
je 0x83bc
cmpq $0x1, %rax
movq %rax, %rdx
adcq $0x0, %rdx
xorpd %xmm0, %xmm0
movupd (%rcx), %xmm1
addpd %xmm1, %xmm0
addq $0x10, %rcx
decq %rdx
jne 0x83a9
jmp 0x83c0
xorpd %xmm0, %xmm0
testq %rax, %rax
js 0x83cf
xorps %xmm1, %xmm1
cvtsi2ss %rax, %xmm1
jmp 0x83e7
movq %rax, %rcx
shrq %rcx
andl $0x1, %eax
orq %rcx, %rax
xorps %xmm1, %xmm1
cvtsi2ss %rax, %xmm1
addss %xmm1, %xmm1
cvtss2sd %xmm1, %xmm1
movlhps %xmm1, %xmm1            # xmm1 = xmm1[0,0]
divpd %xmm1, %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x48(%rdi), %r14
movq 0x48(%rdi), %rax
cmpq %rax, 0x50(%rdi)
je 0x846e
xorl %r12d, %r12d
movq (%rax,%r12,8), %r15
testq %r15, %r15
je 0x844a
movq 0x18(%r15), %rdi
testq %rdi, %rdi
je 0x8436
movq 0x28(%r15), %rsi
subq %rdi, %rsi
callq 0x3220
movq (%r15), %rdi
testq %rdi, %rdi
je 0x844a
movq 0x10(%r15), %rsi
subq %rdi, %rsi
callq 0x3220
movl $0x48, %esi
movq %r15, %rdi
callq 0x3220
incq %r12
movq 0x48(%rbx), %rax
movq 0x50(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r12
jb 0x8418
movq %r14, %rdi
xorl %esi, %esi
callq 0x11c7e
addq $0x18, %rbx
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x11c7e
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rdi), %r15
subq 0x18(%rdi), %r15
addq $0x18, %rdi
shrq $0x3, %r15
leaq 0x8(%rsp), %rsi
movq %rbx, (%rsi)
callq 0x12614
movq %r14, 0x30(%rbx)
movl %r15d, 0x38(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
xorl %eax, %eax
movq 0x30(%rdi), %rsi
testq %rsi, %rsi
je 0x857c
movl 0x38(%rdi), %ecx
movq 0x18(%rsi), %rdx
movq 0x20(%rsi), %r8
subq %rdx, %r8
sarq $0x3, %r8
decq %r8
movq %rsi, %rdi
cmpq %rcx, %r8
je 0x8550
incl %ecx
movq (%rdx,%rcx,8), %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x85fa
incq %rsi
movq %rsi, 0x8(%rax)
testq %rcx, %rcx
js 0x8600
retq
movq %rsi, %rcx
negq %rcx
negq %rdx
notq %rsi
cmovaeq %rcx, %rsi
movq %rdx, (%rax)
movq %rsi, 0x8(%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x86f5
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 0x86b5
mulsd 0xc8cb(%rip), %xmm0     # 0x14fc0
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x871f
movq 0x18(%rdi), %rdi
cmpq %rsi, %rdi
jne 0x8700
retq
// File: /workspace/github_cpp_makefile_star2_O3/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, %rbx
movq 0x18(%r8), %r8
movq 0x10(%r8), %r9
movq %r9, %r11
subq %rdx, %r11
jne 0x88b8
movq 0x8(%r8), %r14
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rcx, %r14
je 0x8958
movq 0x10(%rbx), %r10
cmpq %rdx, %r10
jne 0x88bc
cmpq %rcx, %r14
setg %r10b
cmpq %rcx, 0x8(%rbx)
setge %bpl
xorb %r10b, %bpl
jne 0x8958
movq %rdx, %r10
cmpq %rdx, %r9
jl 0x88ce
jmp 0x8946
movq 0x10(%rbx), %r10
cmpq %rdx, %r10
setl %al
cmpq %rdx, %r9
setge %bpl
xorb %al, %bpl
jne 0x8946
movq 0x8(%rbx), %rbx
movq 0x8(%r8), %rax
subq %rcx, %rbx
jge 0x88e2
subq %rcx, %rax
jg 0x88f2
jmp 0x8946
subq %rcx, %rax
jle 0x88f2
movl $0x1, %eax
subl %edi, %eax
movl %eax, %edi
jmp 0x8946
xorps %xmm1, %xmm1
cvtsi2sd %rbx, %xmm1
xorps %xmm2, %xmm2
cvtsi2sd %r11, %xmm2
mulsd %xmm1, %xmm2
xorps %xmm1, %xmm1
cvtsi2sd %rax, %xmm1
movq %r10, %rax
subq %rdx, %rax
xorps %xmm3, %xmm3
cvtsi2sd %rax, %xmm3
mulsd %xmm1, %xmm3
subsd %xmm3, %xmm2
ucomisd %xmm0, %xmm2
jne 0x892c
jnp 0x8953
seta %al
cmpq %r10, %r9
setle %r9b
xorb %al, %r9b
movl $0x1, %eax
subl %edi, %eax
testb %r9b, %r9b
cmovnel %eax, %edi
movl %edi, %eax
cmpq %rsi, %r8
jne 0x8865
jmp 0x8958
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rdi, %r15
leaq 0x8(%r15), %rdi
movq %rbx, %rsi
callq 0x8851
testl %eax, %eax
jns 0x8988
movq 0x18(%r15), %r15
cmpq %r14, %r15
jne 0x896b
movb $0x1, %al
jmp 0x898b
setne %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x89df
movq 0x38(%rbx), %rsi
movq 0x30(%r14), %rdx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x8596
movq 0x30(%rbx), %rsi
movq 0x38(%r14), %rdx
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x8596
movq 0x8(%r15), %rax
xorq 0x8(%rbx), %rax
movq (%rbx), %rcx
xorq (%r15), %rcx
orq %rax, %rcx
jmp 0x89f4
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_O3/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 0x8a62
movq %r12, %rdx
subq %r8, %rdx
leaq 0x10(%rsp), %r13
movq %r13, %rdi
callq 0x8596
subq %r12, %r14
subq %r15, %rbx
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x8596
movq 0x8(%r13), %rax
xorq 0x8(%r15), %rax
movq (%r15), %rcx
xorq (%r13), %rcx
orq %rax, %rcx
jmp 0x8a76
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_O3/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 0x8aed
subq %rcx, %rsi
subq (%r13), %r8
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %r8, %rdx
callq 0x8596
subq %r15, %r14
subq 0x8(%r13), %rbx
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x8596
movq 0x8(%r12), %rax
xorq 0x8(%r15), %rax
movq (%r15), %rcx
xorq (%r12), %rcx
orq %rax, %rcx
jmp 0x8b06
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_O3/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 0x8dd7
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 0x8dbf
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8e0c
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rax), %rax
movq $0x0, 0x18(%rax)
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x8e0b
movq 0x18(%rdi), %rax
movq %rax, (%rbx)
movl $0x28, %esi
callq 0x3220
jmp 0x8df0
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8e2f
movups (%rcx), %xmm0
movups %xmm0, 0x20(%rdi)
movups 0x10(%rax), %xmm0
movups %xmm0, (%rdi)
jmp 0x8e3d
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 0x8e69
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
cvtsi2sd %rcx, %xmm1
divsd %xmm1, %xmm0
jmp 0x8e71
movsd 0xc857(%rip), %xmm0     # 0x156c8
movsd %xmm0, 0x40(%rdi)
movl %esi, 0x48(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/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), %r10
movq 0x30(%rsp), %rax
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 0x8ef0
cmpq %rdx, %rdi
jle 0x8efd
movq %rcx, %rbx
movq %rdx, %r14
jmp 0x8f09
cmpq %rcx, %rsi
jge 0x8f24
movq %rcx, %rbx
movq %rdx, %r14
jmp 0x8f30
movq %rsi, %rbx
movq %rdi, %r14
movq %rcx, %rsi
movq %rdx, %rdi
movq (%r11), %rcx
cmpq %r8, %rcx
jge 0x8f4b
movq 0x8(%r11), %r15
movq %r8, (%r11)
movq %r9, 0x8(%r11)
movq %r8, %rdx
movq %r15, %r9
jmp 0x8f51
movq %rsi, %rbx
movq %rdi, %r14
movq %rcx, %rsi
movq %rdx, %rdi
movq 0x8(%r11), %rcx
cmpq %r9, %rcx
jle 0x8f71
movq (%r11), %r15
movq %r8, (%r11)
movq %r9, 0x8(%r11)
movq %r9, %rdx
movq %r15, %r8
jmp 0x8f77
movq %rcx, %rdx
movq %r8, %rcx
cmpq %rcx, %r14
cmovgq %r14, %rcx
cmovgq %rbx, %r9
movq %rcx, (%rax)
movq %r9, 0x8(%rax)
cmpq %rdx, %rdi
jge 0x8f97
movq %rdi, (%r10)
movq %rsi, 0x8(%r10)
jmp 0x8fa2
movq %rcx, %rdx
movq %r9, %rcx
cmpq %rcx, %rbx
cmovlq %r14, %r8
cmovlq %rbx, %rcx
movq %r8, (%rax)
movq %rcx, 0x8(%rax)
cmpq %rdx, %rsi
jle 0x8faa
movq %rdi, (%r10)
movq %rsi, 0x8(%r10)
jmp 0x8fb6
movups (%r11), %xmm0
movups %xmm0, (%r10)
movq (%r10), %rdi
cmpq %rdi, (%rax)
setl %al
jmp 0x8fbd
movups (%r11), %xmm0
movups %xmm0, (%r10)
movq 0x8(%r10), %rsi
cmpq %rsi, 0x8(%rax)
setg %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movq 0x10(%r9), %rdx
cmpq %rdi, %r9
je 0x8fe9
cmpq %rax, %r8
jne 0x8fe9
cmpq %rcx, %rdx
je 0x8fce
subq %rcx, %rdx
jne 0x8ff8
movsd 0xc6d2(%rip), %xmm0     # 0x156c8
jmp 0x9009
subq %rax, %r8
cvtsi2sd %r8, %xmm0
cvtsi2sd %rdx, %xmm1
divsd %xmm1, %xmm0
movq %rdi, %r9
movq 0x18(%r9), %r9
movq 0x8(%r9), %r8
movq 0x10(%r9), %rdx
cmpq %rdi, %r9
je 0x9027
cmpq %rax, %r8
jne 0x9027
cmpq %rcx, %rdx
je 0x900c
andpd 0xbea1(%rip), %xmm0     # 0x14ed0
subq %rcx, %rdx
jne 0x903e
movsd 0xc68c(%rip), %xmm1     # 0x156c8
jmp 0x9052
subq %rax, %r8
xorps %xmm1, %xmm1
cvtsi2sd %r8, %xmm1
cvtsi2sd %rdx, %xmm2
divsd %xmm2, %xmm1
movq 0x8(%rsi), %rax
movq 0x10(%rsi), %rcx
movq %rsi, %r8
movq 0x20(%r8), %r8
movq 0x8(%r8), %rdi
movq 0x10(%r8), %rdx
cmpq %rsi, %r8
je 0x9078
cmpq %rax, %rdi
jne 0x9078
cmpq %rcx, %rdx
je 0x905d
andpd 0xbe50(%rip), %xmm1     # 0x14ed0
subq %rcx, %rdx
jne 0x908f
movsd 0xc63b(%rip), %xmm2     # 0x156c8
jmp 0x90a3
subq %rax, %rdi
xorps %xmm2, %xmm2
cvtsi2sd %rdi, %xmm2
cvtsi2sd %rdx, %xmm3
divsd %xmm3, %xmm2
movq %rsi, %r8
movq 0x18(%r8), %r8
movq 0x8(%r8), %rdi
movq 0x10(%r8), %rdx
cmpq %rsi, %r8
je 0x90c1
cmpq %rax, %rdi
jne 0x90c1
cmpq %rcx, %rdx
je 0x90a6
andpd 0xbe07(%rip), %xmm2     # 0x14ed0
subq %rcx, %rdx
jne 0x90d8
movsd 0xc5f2(%rip), %xmm3     # 0x156c8
jmp 0x90ec
subq %rax, %rdi
xorps %xmm3, %xmm3
cvtsi2sd %rdi, %xmm3
cvtsi2sd %rdx, %xmm4
divsd %xmm4, %xmm3
andpd 0xbddc(%rip), %xmm3     # 0x14ed0
ucomisd %xmm2, %xmm0
jb 0x9102
movb $0x1, %al
ucomisd %xmm3, %xmm0
jae 0x9114
cmplepd %xmm1, %xmm3
cmplepd %xmm1, %xmm2
andpd %xmm3, %xmm2
movd %xmm2, %eax
andb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
cmpq %rdi, %r14
je 0x9197
xorl %r15d, %r15d
movq 0x10(%rbx), %rax
cmpq %rax, 0x10(%r14)
jle 0x913d
movq %r14, %rbx
xorl %r15d, %r15d
jmp 0x9159
jne 0x9159
movq 0x8(%rbx), %rax
cmpq %rax, 0x8(%r14)
jg 0x9159
jl 0x9135
cmpq %rbx, 0x18(%r14)
je 0x9159
cmpq %rbx, 0x20(%r14)
cmovneq %r14, %r15
movq 0x18(%r14), %r14
cmpq %rbx, %r14
jne 0x912b
testq %r15, %r15
jne 0x9192
jmp 0x9197
movq %r14, %rdi
movq %r15, %rsi
callq 0x8fc3
testb %al, %al
cmoveq %r15, %rbx
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
movq 0x18(%r15), %r15
cmpq %rax, 0x8(%r15)
jne 0x9182
cmpq %rcx, 0x10(%r15)
jne 0x9182
cmpq %r14, %r15
jne 0x9169
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x68, %rsp
movq %rdi, 0x38(%rsp)
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x92c2
movq (%rdx), %rbx
movq %rdx, 0x48(%rsp)
movq 0x8(%rdx), %rbp
movq (%rcx), %r14
movq %rcx, 0x50(%rsp)
movq 0x8(%rcx), %r15
movzbl %sil, %ecx
movq %rdi, %r12
movq %rbp, 0x30(%rsp)
movl %ecx, 0x2c(%rsp)
movq %rdi, 0x58(%rsp)
movq 0x8(%r12), %r8
movq 0x10(%r12), %r9
movq 0x20(%r12), %r13
movups 0x8(%r13), %xmm0
movups %xmm0, (%rsp)
movl %ecx, 0x10(%rsp)
movq %rbx, %rdi
movq %rbp, %rsi
movq %r14, %rdx
movq %r15, %rcx
movq %r8, 0x60(%rsp)
movq %r9, 0x40(%rsp)
callq 0x8a87
testb %al, %al
je 0x929e
movl 0x2c(%rsp), %eax
movl %eax, (%rsp)
movq %rbx, %rdi
movq %rbp, %rsi
movq %r14, %rdx
movq %r15, %rcx
movq 0x60(%rsp), %rbp
movq %rbp, %r8
movq 0x40(%rsp), %r9
callq 0x8a01
testb %al, %al
je 0x929e
addq $0x8, %r13
movups (%r13), %xmm0
movups %xmm0, (%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
movq %rbx, %r13
movq %rbx, %rdi
movq 0x30(%rsp), %rsi
movq %r14, %rdx
movq %r15, %rcx
movq %rbp, %r8
movq 0x40(%rsp), %r9
callq 0x8eaa
testb %al, %al
jne 0x92d3
movq 0x38(%rsp), %rax
movq (%rax), %r12
movq %r13, %rbx
movq 0x18(%r12), %r12
movq 0x38(%rsp), %rax
movq %r12, (%rax)
movq 0x58(%rsp), %rdi
cmpq %rdi, %r12
movq 0x30(%rsp), %rbp
movl 0x2c(%rsp), %ecx
jne 0x91ec
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %al
jmp 0x92c4
// File: /workspace/github_cpp_makefile_star2_O3/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 0x9386
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movl $0x28, %edi
callq 0x3210
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 0xc3cc(%rip), %rcx      # 0x15763
movq %rcx, (%rax)
movq 0x12c27(%rip), %rsi     # 0x1bfc8
movq %rax, %rdi
xorl %edx, %edx
callq 0x3370
// File: /workspace/github_cpp_makefile_star2_O3/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 0x93c9
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 0x93c8
xorb %r8b, %r10b
jne 0x93c8
xorb %r8b, %r9b
jne 0x93c8
movq %rdi, %r8
xorq %rdx, %r8
movq %rsi, %r9
xorq %rcx, %r9
orq %r8, %r9
je 0x93c8
xorq %rcx, %rdi
xorq %rdx, %rsi
orq %rdi, %rsi
sete %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 (%rdi), %rax
testb $0x1, (%rsi)
jne 0x94b2
cmpq $0x3fffffff, %rax       # imm = 0x3FFFFFFF
jg 0x94af
cmpq $-0x3fffffff, %rax      # imm = 0xC0000001
jl 0x94af
movq $-0x40000000, %rcx      # imm = 0xC0000000
addq 0x8(%rdi), %rcx
cmpq $-0x7fffffff, %rcx      # imm = 0x80000001
jae 0x94e7
movb $0x1, (%rsi)
movabsq $0x3fffffffffffffff, %rcx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rcx, %rax
jg 0x94e8
movabsq $-0x4000000000000000, %rcx # imm = 0xC000000000000000
leaq 0x1(%rcx), %rdx
cmpq %rdx, %rax
jl 0x94e8
addq 0x8(%rdi), %rcx
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
cmpq %rax, %rcx
jbe 0x94e8
retq
pushq %rax
movl $0x8, %edi
callq 0x30f0
leaq 0xc273(%rip), %rcx      # 0x1576d
movq %rcx, (%rax)
movq 0x12ac4(%rip), %rsi     # 0x1bfc8
movq %rax, %rdi
xorl %edx, %edx
callq 0x3370
// File: /workspace/github_cpp_makefile_star2_O3/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 %rdi, %rax
movq 0x68(%rax), %rcx
movq (%rax), %rdx
cmpq (%rcx), %rdx
jne 0x953b
movq 0x8(%rcx), %rdx
cmpq %rdx, 0x8(%rax)
jne 0x953b
movq 0x10(%rax), %rdx
cmpq 0x20(%rax), %rdx
jne 0x9541
movq 0x28(%rax), %rdx
cmpq %rdx, 0x18(%rax)
jne 0x9541
movq 0x60(%rax), %rax
jmp 0x9511
cmpq $0x0, 0x38(%rax)
je 0x954f
cmpq $0x0, 0x38(%rcx)
jne 0x9593
movq %rax, %rdx
movq %rdx, %rcx
movq 0x68(%rdx), %rdx
cmpq $0x0, 0x38(%rdx)
je 0x9552
cmpq $0x0, 0x38(%rcx)
movq %rdx, %rsi
movq %rcx, %rax
jne 0x957f
movq %rcx, %rax
movq 0x60(%rax), %rax
cmpq $0x0, 0x38(%rax)
je 0x9570
movq 0x68(%rax), %rsi
movq 0x28(%rax), %rdi
cmpq 0x8(%rsi), %rdi
je 0x9511
movq (%rdx), %rdx
cmpq (%rax), %rdx
cmovlq %rcx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x9f00
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 0x985a
orb %al, %bpl
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 0x9ec1
jmp 0x9f02
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
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x9f42
movq 0x18(%rdi), %r14
movl $0x20, %esi
callq 0x3220
movq %r14, 0x10(%rbx)
movq %r14, %rdi
testq %r14, %r14
jne 0x9f28
movq $0x0, 0x8(%rbx)
movq 0x20(%rbx), %rax
movq 0x28(%rbx), %rcx
cmpq %rax, %rcx
je 0x9f82
xorl %r14d, %r14d
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x9f70
callq 0x32a0
movq 0x20(%rbx), %rax
movq 0x28(%rbx), %rcx
incq %r14
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %rdx, %r14
jb 0x9f5a
cmpq %rax, %rcx
je 0x9f8b
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_O3/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 0x9fc6
movq 0x18(%rdi), %r14
movl $0x20, %esi
callq 0x3220
movq %r14, 0x10(%rbx)
movq %r14, %rdi
testq %r14, %r14
jne 0x9fac
movq $0x0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq