LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/hzeller[P]gcode-multi-shell-extrude/multi-shell-extrude.cc
// Function: ReadPolygon(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, double)
Polygon ReadPolygon(const std::string &filename, double factor) {
  Polygon polygon;
  FILE *in = fopen(filename.c_str(), "r");
  if (!in) {
    fprintf(stderr, "Can't open %s\n", filename.c_str());
    return polygon;
  }
  char buffer[256];
  int line = 0;
  while (fgets(buffer, sizeof(buffer), in)) {
    ++line;
    const char *start = buffer;
    while (*start && isspace(*start))
      start++;
    if (*start == '\0' || *start == '#')
      continue;
    Vector2D p;
    if (sscanf(start, "%lf %lf", &p.x, &p.y) == 2) {
      p.x *= factor;
      p.y *= factor;
      polygon.push_back(p);
    } else {
      for (char *end = buffer + strlen(buffer) - 1; isspace(*end); end--) {
        *end = '\0';
      }
      fprintf(stderr, "%s:%d not a comment and not coordinates: '%s'\n",
              filename.c_str(), line, start);
    }
  }
  fclose(in);
  return polygon;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp            # imm = 0x138
movapd %xmm0, 0x20(%rsp)
xorpd %xmm0, %xmm0
movupd %xmm0, (%rdi)
movq %rdi, (%rsp)
andq $0x0, 0x10(%rdi)
movq %rsi, 0x8(%rsp)
movq (%rsi), %rdi
leaq 0xedd3(%rip), %rsi      # 0x1243e
callq 0x32a0
testq %rax, %rax
je 0x37a3
movq %rax, %r15
movapd 0x20(%rsp), %xmm0
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
movapd %xmm0, 0x20(%rsp)
leaq 0x30(%rsp), %rbp
leaq 0x10(%rsp), %r14
xorl %r12d, %r12d
movq %rbp, %rdi
movl $0x100, %esi            # imm = 0x100
movq %r15, %rdx
callq 0x3340
testq %rax, %rax
je 0x3785
movq %r14, %rbx
incl %r12d
movq %rbp, %r13
movsbl (%r13), %r14d
testl %r14d, %r14d
je 0x377d
movl %r14d, %edi
callq 0x3050
testl %eax, %eax
je 0x36da
incq %r13
jmp 0x36bb
cmpb $0x23, %r14b
movq %rbx, %r14
je 0x3699
xorpd %xmm0, %xmm0
movapd %xmm0, 0x10(%rsp)
movq %r13, %rdi
leaq 0xea4c(%rip), %rsi      # 0x12143
movq %r14, %rdx
leaq 0x18(%rsp), %rcx
xorl %eax, %eax
callq 0x3200
cmpl $0x2, %eax
jne 0x372e
movapd 0x10(%rsp), %xmm0
mulpd 0x20(%rsp), %xmm0
movapd %xmm0, 0x10(%rsp)
movq (%rsp), %rdi
movq %r14, %rsi
callq 0x5658
jmp 0x3699
movq %rbp, %rdi
callq 0x30e0
movq %rax, %r14
leaq 0x2f(%rsp), %rax
addq %rax, %r14
movsbl (%r14), %edi
callq 0x3050
testl %eax, %eax
je 0x3757
movb $0x0, (%r14)
decq %r14
jmp 0x3741
movq 0x1787a(%rip), %rax     # 0x1afd8
movq (%rax), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rdx
leaq 0xe9db(%rip), %rsi      # 0x1214b
movl %r12d, %ecx
movq %r13, %r8
xorl %eax, %eax
callq 0x32f0
movq %rbx, %r14
jmp 0x3699
movq %r15, %rdi
callq 0x3220
movq (%rsp), %rax
addq $0x138, %rsp            # imm = 0x138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x1782e(%rip), %rax     # 0x1afd8
movq (%rax), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rdx
leaq 0xe978(%rip), %rsi      # 0x12134
xorl %eax, %eax
callq 0x32f0
jmp 0x378d
movq %rax, %r14
movq (%rsp), %rdi
callq 0x5b22
movq %r14, %rdi
callq 0x33a0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3863
xorpd %xmm0, %xmm0
andq $0x0, 0x10(%rbx)
movupd %xmm0, (%rbx)
movq (%rsi), %r15
movq 0x8(%rsi), %r12
leaq 0x10(%rsp), %r14
cmpq %r12, %r15
je 0x386b
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
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 %rbx, %rdi
movq %r14, %rsi
callq 0x5b92
addq $0x10, %r15
jmp 0x3810
movq %rbx, %rdi
callq 0x5676
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x5b22
movq %r14, %rdi
callq 0x33a0
// File: /workspace/github_cpp_makefile_star2_O2/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
sarq $0x4, %rcx
addq $0x8, %rax
movsd 0xe7b9(%rip), %xmm0     # 0x12060
subq $0x1, %rcx
jb 0x38d4
movsd -0x8(%rax), %xmm1
movsd (%rax), %xmm2
mulsd %xmm2, %xmm2
mulsd %xmm1, %xmm1
addsd %xmm2, %xmm1
sqrtsd %xmm1, %xmm1
maxsd %xmm0, %xmm1
addq $0x10, %rax
movapd %xmm1, %xmm0
jmp 0x38a7
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xc88d(%rip), %rdi      # 0x1354f
callq 0x3320
leaq 0xc896(%rip), %rdi      # 0x13564
callq 0x3320
leaq 0xc8a3(%rip), %rdi      # 0x1357d
callq 0x3320
leaq 0xc8a9(%rip), %rdi      # 0x1358f
callq 0x3320
leaq 0xc8a3(%rip), %rdi      # 0x13595
callq 0x3320
leaq 0xc8a0(%rip), %rdi      # 0x1359e
popq %rax
jmp 0x3320
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6ded
jnp 0x6e25
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movsd 0xc1b3(%rip), %xmm0     # 0x12fb0
mulsd %xmm1, %xmm0
leaq 0xc309(%rip), %rdi      # 0x13111
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_O2/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 0x6e62
movq %rdi, %rbx
movb $0x0, 0x50(%rdi)
movsd 0x10(%rdi), %xmm0
mulsd 0xc197(%rip), %xmm0     # 0x12fd8
leaq 0xc334(%rip), %rdi      # 0x1317c
movb $0x1, %al
callq 0x3040
leaq 0xc74c(%rip), %rdi      # 0x135a2
callq 0x3320
andq $0x0, 0x48(%rbx)
popq %rbx
retq
leaq 0xc369(%rip), %rdi      # 0x131d2
leaq 0xc2c0(%rip), %rsi      # 0x13130
leaq 0xc2c4(%rip), %rcx      # 0x1313b
pushq $0x76
popq %rdx
callq 0x3160
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6eaa
movq %rdi, %rbx
movsd 0x10(%rdi), %xmm0
xorps 0xb1ba(%rip), %xmm0     # 0x12050
leaq 0xc37d(%rip), %rdi      # 0x1321a
movb $0x1, %al
callq 0x3040
movb $0x1, 0x50(%rbx)
popq %rbx
retq
leaq 0xc320(%rip), %rdi      # 0x131d1
leaq 0xc278(%rip), %rsi      # 0x13130
leaq 0xc31f(%rip), %rcx      # 0x131de
movl $0x80, %edx
callq 0x3160
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
sqrtsd %xmm6, %xmm3
addsd 0x48(%rdi), %xmm3
movsd %xmm3, 0x48(%rdi)
mulsd 0x8(%rdi), %xmm3
mulsd %xmm1, %xmm3
leaq 0xc2fb(%rip), %rdi      # 0x13280
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
// File: /workspace/github_cpp_makefile_star2_O2/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 0xc5d1(%rip), %rdi      # 0x135cc
callq 0x3320
leaq 0xc2d0(%rip), %rdi      # 0x132d7
xorl %eax, %eax
callq 0x3040
leaq 0xc5d2(%rip), %rdi      # 0x135e7
callq 0x3320
cvtss2sd 0xc(%rbx), %xmm0
leaq 0xc2db(%rip), %rdi      # 0x13301
movb $0x1, %al
callq 0x3040
leaq 0xc5c1(%rip), %rdi      # 0x135f5
popq %rbx
jmp 0x3320
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7135
movq %rdi, %r15
leaq 0xc252(%rip), %r14      # 0x13364
cmpb $0x0, 0x10(%rdi)
jne 0x713c
movss 0xaff0(%rip), %xmm3     # 0x12110
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
callq 0x71cc
movb $0x1, 0x10(%r15)
jmp 0x713c
leaq 0xc23a(%rip), %r14      # 0x13376
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_O2/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 0x7182
movq %rdi, %r14
movss 0xc(%rdi), %xmm0
movss 0x14(%rdi), %xmm1
movss 0x18(%rdi), %xmm2
movss 0x1c(%rdi), %xmm3
callq 0x71cc
movb $0x0, 0x10(%r14)
movsd (%rbx), %xmm0
movsd 0x8(%rbx), %xmm1
leaq 0xc22b(%rip), %rdi      # 0x133bd
movb $0x2, %al
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3040
// File: /workspace/github_cpp_makefile_star2_O2/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 0xc421(%rip), %rdi      # 0x13610
callq 0x3320
cvtss2sd 0x8(%rsp), %xmm0
leaq 0xc187(%rip), %rdi      # 0x13388
movb $0x1, %al
callq 0x3040
cvtss2sd 0xc(%rsp), %xmm0
cvtss2sd 0x10(%rsp), %xmm1
cvtss2sd 0x14(%rsp), %xmm2
leaq 0xc180(%rip), %rdi      # 0x133a1
movb $0x3, %al
callq 0x3040
leaq 0xc3ca(%rip), %rdi      # 0x135f9
addq $0x18, %rsp
jmp 0x3320
// File: /workspace/github_cpp_makefile_star2_O2/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 0x73b3
movq %rsi, %r14
cmpb $0x0, (%rsi)
je 0x73b3
leaq 0xb0f9(%rip), %rsi      # 0x1248a
movq %r14, %rdi
callq 0x3280
testl %eax, %eax
je 0x73b9
leaq 0xc283(%rip), %rsi      # 0x13627
movq %r14, %rdi
callq 0x3280
testl %eax, %eax
sete %al
jmp 0x73bb
xorb $0x1, 0x20(%rbx)
jmp 0x73be
movb $0x1, %al
movb %al, 0x20(%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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), %rax
subq %rcx, %rax
sarq $0x4, %rax
xorpd %xmm0, %xmm0
movq %rax, %rdx
subq $0x1, %rdx
jb 0x7989
movupd (%rcx), %xmm1
addpd %xmm1, %xmm0
addq $0x10, %rcx
jmp 0x7975
testq %rax, %rax
js 0x7995
cvtsi2ss %rax, %xmm1
jmp 0x79aa
movq %rax, %rcx
shrq %rcx
andl $0x1, %eax
orq %rcx, %rax
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_O2/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 %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x48(%rdi), %r14
xorl %r13d, %r13d
pushq $0x48
popq %r15
movq 0x48(%rbx), %rax
movq 0x50(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r13
jae 0x7a0c
movq (%rax,%r13,8), %r12
testq %r12, %r12
je 0x79fc
movq %r12, %rdi
callq 0xf5c0
movq %r12, %rdi
movq %r15, %rsi
callq 0x3240
incq %r13
jmp 0x79d7
movq %r14, %rdi
xorl %esi, %esi
callq 0xf5d6
addq $0x18, %rbx
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xf5d6
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x10142
movq %r14, 0x30(%rbx)
movl %r15d, 0x38(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7aee
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 0x7ac2
incl %ecx
movq (%rdx,%rcx,8), %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7b6c
incq %rsi
movq %rsi, 0x8(%rax)
testq %rcx, %rcx
js 0x7b72
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_O2/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 0x7c5b
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
cvtsi2sd %rdi, %xmm1
cvtsi2sd %rsi, %xmm2
mulsd %xmm1, %xmm2
addsd %xmm2, %xmm0
movq %r8, %rcx
cmpq %rax, %r8
jne 0x7c21
mulsd 0xb365(%rip), %xmm0     # 0x12fc0
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7c85
movq 0x18(%rdi), %rdi
cmpq %rsi, %rdi
jne 0x7c66
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq (%rdi), %rdx
movq 0x8(%rdi), %rdi
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
xorpd %xmm0, %xmm0
movl $0x1, %r8d
movq %rsi, %r9
movq %r9, %r14
movq 0x18(%r9), %r9
movq 0x10(%r9), %r10
movq %r10, %rbx
subq %rdi, %rbx
jne 0x7e1c
movq 0x8(%r9), %r15
cmpq %rdx, %r15
je 0x7eaa
movq 0x10(%r14), %r11
cmpq %rdi, %r11
jne 0x7e20
cmpq %rdx, %r15
setg %r11b
cmpq %rdx, 0x8(%r14)
setge %bpl
xorb %r11b, %bpl
jne 0x7eaa
movq %rdi, %r11
cmpq %rdi, %r10
jl 0x7e33
jmp 0x7e9f
movq 0x10(%r14), %r11
cmpq %rdi, %r11
setl %bpl
cmpq %rdi, %r10
setge %r15b
xorb %bpl, %r15b
jne 0x7e9f
movq 0x8(%r14), %r15
movq 0x8(%r9), %r14
subq %rdx, %r15
jge 0x7e47
subq %rdx, %r14
jg 0x7e57
jmp 0x7e9f
subq %rdx, %r14
jle 0x7e57
movl %r8d, %r10d
subl %eax, %r10d
movl %r10d, %eax
jmp 0x7e9f
cvtsi2sd %r15, %xmm1
cvtsi2sd %rbx, %xmm2
mulsd %xmm1, %xmm2
cvtsi2sd %r14, %xmm1
movq %r11, %rbx
subq %rdi, %rbx
cvtsi2sd %rbx, %xmm3
mulsd %xmm1, %xmm3
subsd %xmm3, %xmm2
ucomisd %xmm0, %xmm2
jne 0x7e85
jnp 0x7eaa
seta %bl
cmpq %r11, %r10
setle %r10b
xorb %bl, %r10b
movl %r8d, %r11d
subl %eax, %r11d
testb %r10b, %r10b
cmovnel %r11d, %eax
cmpq %rsi, %r9
jne 0x7dce
jmp 0x7eac
movl %ecx, %eax
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7dad
testl %eax, %eax
jns 0x7ede
movq 0x18(%r15), %r15
cmpq %r14, %r15
jne 0x7ec1
movb $0x1, %al
jmp 0x7ee1
setne %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7f35
movq 0x38(%rbx), %rsi
movq 0x30(%r14), %rdx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x7b08
movq 0x30(%rbx), %rsi
movq 0x38(%r14), %rdx
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x7b08
movq 0x8(%r15), %rax
xorq 0x8(%rbx), %rax
movq (%rbx), %rcx
xorq (%r15), %rcx
orq %rax, %rcx
jmp 0x7f4a
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_O2/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 0x7fb8
movq %r12, %rdx
subq %r8, %rdx
leaq 0x10(%rsp), %r13
movq %r13, %rdi
callq 0x7b08
subq %r12, %r14
subq %r15, %rbx
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x7b08
movq 0x8(%r13), %rax
xorq 0x8(%r15), %rax
movq (%r15), %rcx
xorq (%r13), %rcx
orq %rax, %rcx
jmp 0x7fcc
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_O2/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 0x8043
subq %rcx, %rsi
subq (%r13), %r8
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %r8, %rdx
callq 0x7b08
subq %r15, %r14
subq 0x8(%r13), %rbx
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x7b08
movq 0x8(%r12), %rax
xorq 0x8(%r15), %rax
movq (%r15), %rcx
xorq (%r12), %rcx
orq %rax, %rcx
jmp 0x805c
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_O2/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 0x82b9
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 0x82a1
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x82f6
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rax), %rax
andq $0x0, 0x18(%rax)
pushq $0x28
popq %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x82ef
movq 0x18(%rdi), %rax
movq %rax, (%rbx)
movq %r14, %rsi
callq 0x3240
jmp 0x82d6
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq 0x10(%rdi), %rcx
movq 0x18(%rdi), %rdx
movq 0x60(%rdi), %rax
cmpq 0x18(%rax), %rdx
jge 0x8324
movups (%rcx), %xmm0
movups %xmm0, 0x20(%r14)
movups 0x10(%rax), %xmm0
movups %xmm0, (%r14)
jmp 0x8334
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movups 0x10(%rax), %xmm0
movups %xmm0, 0x20(%r14)
movq %r14, %rdi
callq 0xf642
movl %ebx, 0x48(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x83bb
cmpq %rdx, %rdi
jle 0x83c8
movq %rcx, %rbx
movq %rdx, %r14
jmp 0x83d4
cmpq %rcx, %rsi
jge 0x83ef
movq %rcx, %rbx
movq %rdx, %r14
jmp 0x83fb
movq %rsi, %rbx
movq %rdi, %r14
movq %rcx, %rsi
movq %rdx, %rdi
movq (%r11), %rcx
cmpq %r8, %rcx
jge 0x8416
movq 0x8(%r11), %r15
movq %r8, (%r11)
movq %r9, 0x8(%r11)
movq %r8, %rdx
movq %r15, %r9
jmp 0x841c
movq %rsi, %rbx
movq %rdi, %r14
movq %rcx, %rsi
movq %rdx, %rdi
movq 0x8(%r11), %rcx
cmpq %r9, %rcx
jle 0x843c
movq (%r11), %r15
movq %r8, (%r11)
movq %r9, 0x8(%r11)
movq %r9, %rdx
movq %r15, %r8
jmp 0x8442
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 0x8462
movq %rdi, (%r10)
movq %rsi, 0x8(%r10)
jmp 0x846d
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 0x8475
movq %rdi, (%r10)
movq %rsi, 0x8(%r10)
jmp 0x8481
movups (%r11), %xmm0
movups %xmm0, (%r10)
movq (%r10), %rdi
cmpq %rdi, (%rax)
setl %al
jmp 0x8488
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_O2/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 0x84b4
cmpq %rax, %r8
jne 0x84b4
cmpq %rcx, %rdx
je 0x8499
subq %rcx, %rdx
jne 0x84c3
movsd 0xb207(%rip), %xmm0     # 0x136c8
jmp 0x84d4
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 0x84f2
cmpq %rax, %r8
jne 0x84f2
cmpq %rcx, %rdx
je 0x84d7
andpd 0xa9e6(%rip), %xmm0     # 0x12ee0
subq %rcx, %rdx
jne 0x8509
movsd 0xb1c1(%rip), %xmm1     # 0x136c8
jmp 0x851a
subq %rax, %r8
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 0x8540
cmpq %rax, %rdi
jne 0x8540
cmpq %rcx, %rdx
je 0x8525
andpd 0xa998(%rip), %xmm1     # 0x12ee0
subq %rcx, %rdx
jne 0x8557
movsd 0xb173(%rip), %xmm2     # 0x136c8
jmp 0x8568
subq %rax, %rdi
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 0x8586
cmpq %rax, %rdi
jne 0x8586
cmpq %rcx, %rdx
je 0x856b
andpd 0xa952(%rip), %xmm2     # 0x12ee0
subq %rcx, %rdx
jne 0x859d
movsd 0xb12d(%rip), %xmm3     # 0x136c8
jmp 0x85ae
subq %rax, %rdi
cvtsi2sd %rdi, %xmm3
cvtsi2sd %rdx, %xmm4
divsd %xmm4, %xmm3
andpd 0xa92a(%rip), %xmm3     # 0x12ee0
ucomisd %xmm2, %xmm0
jb 0x85c4
movb $0x1, %al
ucomisd %xmm3, %xmm0
jae 0x85d6
cmplepd %xmm1, %xmm3
cmplepd %xmm1, %xmm2
andpd %xmm3, %xmm2
movd %xmm2, %eax
andb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r15d, %r15d
movq %rbx, %r14
movq 0x18(%r14), %r14
cmpq %rbx, %r14
je 0x8620
movq 0x10(%rbx), %rax
cmpq %rax, 0x10(%r14)
jg 0x861b
jne 0x85ea
movq 0x8(%rbx), %rax
cmpq %rax, 0x8(%r14)
jg 0x85ea
jl 0x861b
cmpq %rbx, 0x18(%r14)
je 0x85ea
cmpq %rbx, 0x20(%r14)
cmovneq %r14, %r15
jmp 0x85ea
movq %r14, %rbx
jmp 0x85e4
testq %r15, %r15
je 0x865d
movq %rbx, %r12
cmpq %rbx, %r15
je 0x865a
movq %r14, %rdi
movq %r15, %rsi
callq 0x848e
testb %al, %al
cmoveq %r15, %r12
movq 0x8(%r12), %rax
movq 0x10(%r12), %rcx
movq 0x18(%r15), %r15
cmpq %rax, 0x8(%r15)
jne 0x8648
cmpq %rcx, 0x10(%r15)
jne 0x8648
jmp 0x8628
movq %r12, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x878e
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 0x7fdd
testb %al, %al
je 0x876a
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 0x7f57
testb %al, %al
je 0x876a
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 0x8375
testb %al, %al
jne 0x879f
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 0x86b8
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %al
jmp 0x8790
// File: /workspace/github_cpp_makefile_star2_O2/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 0x8850
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x28
popq %rdi
callq 0x3230
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
pushq $0x8
popq %rdi
callq 0x3100
leaq 0xaf04(%rip), %rcx      # 0x13763
movq %rcx, (%rax)
movq 0x1275f(%rip), %rsi     # 0x1afc8
movq %rax, %rdi
xorl %edx, %edx
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O2/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 0x8891
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 0x8890
xorb %r8b, %r10b
jne 0x8890
xorb %r8b, %r9b
jne 0x8890
movq %rdi, %r8
xorq %rdx, %r8
movq %rsi, %r9
xorq %rcx, %r9
orq %r8, %r9
je 0x8890
xorq %rcx, %rdi
xorq %rdx, %rsi
orq %rdi, %rsi
sete %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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), %rcx
movq 0x8(%rdi), %rax
testb $0x1, (%rsi)
jne 0x896c
cmpq $0x3fffffff, %rcx       # imm = 0x3FFFFFFF
jg 0x8969
cmpq $-0x3fffffff, %rcx      # imm = 0xC0000001
jl 0x8969
leaq -0x40000000(%rax), %rdx
cmpq $-0x80000000, %rdx      # imm = 0x80000000
ja 0x89a0
movb $0x1, (%rsi)
movabsq $0x3fffffffffffffff, %rdx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rdx, %rcx
jg 0x89a1
movabsq $-0x4000000000000000, %rdx # imm = 0xC000000000000000
leaq 0x1(%rdx), %rsi
cmpq %rsi, %rcx
jl 0x89a1
addq %rdx, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
cmpq %rcx, %rax
jbe 0x89a1
retq
pushq %rax
pushq $0x8
popq %rdi
callq 0x3100
leaq 0xadbc(%rip), %rcx      # 0x1376d
movq %rcx, (%rax)
movq 0x1260d(%rip), %rsi     # 0x1afc8
movq %rax, %rdi
xorl %edx, %edx
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O2/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 0x89f2
movq 0x8(%rcx), %rdx
cmpq %rdx, 0x8(%rax)
jne 0x89f2
movq 0x10(%rax), %rdx
cmpq 0x20(%rax), %rdx
jne 0x89f8
movq 0x28(%rax), %rdx
cmpq %rdx, 0x18(%rax)
jne 0x89f8
movq 0x60(%rax), %rax
jmp 0x89c8
cmpq $0x0, 0x38(%rax)
je 0x8a06
cmpq $0x0, 0x38(%rcx)
jne 0x8a3f
movq %rax, %rdx
movq %rdx, %rcx
movq 0x68(%rdx), %rdx
cmpq $0x0, 0x38(%rdx)
je 0x8a09
movq %rcx, %rax
cmpq $0x0, 0x38(%rax)
jne 0x8a27
movq 0x60(%rax), %rax
jmp 0x8a1a
movq 0x28(%rax), %rsi
movq 0x68(%rax), %rdi
cmpq 0x8(%rdi), %rsi
je 0x89c8
movq (%rdx), %rdx
cmpq (%rax), %rdx
cmovlq %rcx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movl %edx, 0x4(%rsp)
movq %rsi, %r14
movq %rdi, %r15
xorl %r13d, %r13d
movzbl %cl, %ebp
xorl %r12d, %r12d
xorl %ebx, %ebx
movq (%r14), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
cqto
pushq $0x18
popq %rcx
idivq %rcx
cmpq %rax, %rbx
jae 0x92b4
addq %r13, %rsi
movq %r15, %rdi
movl 0x4(%rsp), %edx
movl %ebp, %ecx
callq 0x8cd0
orb %al, %r12b
incq %rbx
addq $0x18, %r13
jmp 0x9280
andb $0x1, %r12b
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
callq 0x931c
xorl %r14d, %r14d
movq 0x20(%rbx), %rax
movq 0x28(%rbx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %rdx, %r14
jae 0x9303
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x92fe
callq 0x32c0
incq %r14
jmp 0x92d9
cmpq %rax, %rcx
je 0x930c
movq %rax, 0x28(%rbx)
xorl %eax, %eax
movb %al, 0x18(%rbx)
movb %al, 0x39(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
pushq $0x20
popq %r14
testq %rdi, %rdi
je 0x9346
movq 0x18(%rdi), %r15
movq %r14, %rsi
callq 0x3240
movq %r15, 0x10(%rbx)
movq %r15, %rdi
jmp 0x932c
andq $0x0, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::ClipperBase::GetBounds()
IntRect ClipperBase::GetBounds()
{
  IntRect result;
  LocalMinima* lm = m_MinimaList;
  if (!lm)
  {
    result.left = result.top = result.right = result.bottom = 0;
    return result;
  }
  result.left = lm->LeftBound->Bot.X;
  result.top = lm->LeftBound->Bot.Y;
  result.right = lm->LeftBound->Bot.X;
  result.bottom = lm->LeftBound->Bot.Y;
  while (lm)
  {
    if (lm->LeftBound->Bot.Y > result.bottom)
      result.bottom = lm->LeftBound->Bot.Y;
    TEdge* e = lm->LeftBound;
    for (;;) {
      TEdge* bottomE = e;
      while (e->NextInLML)
      {
        if (e->Bot.X < result.left) result.left = e->Bot.X;
        if (e->Bot.X > result.right) result.right = e->Bot.X;
        e = e->NextInLML;
      }
      if (e->Bot.X < result.left) result.left = e->Bot.X;
      if (e->Bot.X > result.right) result.right = e->Bot.X;
      if (e->Top.X < result.left) result.left = e->Top.X;
      if (e->Top.X > result.right) result.right = e->Top.X;
      if (e->Top.Y < result.top) result.top = e->Top.Y;

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

// Assembly:
movq %rdi, %rax
movq 0x10(%rsi), %rcx
testq %rcx, %rcx
je 0x9459
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x8(%rcx), %rdx
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
movq %rsi, %rdi
movq %rdx, %r8
testq %rcx, %rcx
je 0x9442
movq 0x8(%rcx), %r10
movq 0x10(%rcx), %r11
movq 0x8(%r10), %r9
movq %r10, %rbx
movq %rbx, %r15
movq %r15, %r14
movq (%r15), %r12
movq 0x70(%r15), %r15
cmpq %rdi, %r12
cmovlq %r12, %rdi
cmpq %rsi, %r12
cmovgq %r12, %rsi
testq %r15, %r15
jne 0x93f3
movq 0x20(%r14), %r15
movq 0x28(%r14), %r14
cmpq %rdi, %r15
cmovlq %r15, %rdi
cmpq %rsi, %r15
cmovgq %r15, %rsi
cmpq %rdx, %r14
cmovlq %r14, %rdx
cmpq %r10, %rbx
movq %r11, %rbx
je 0x93f0
cmpq %r8, %r9
cmovgq %r9, %r8
movq 0x18(%rcx), %rcx
jmp 0x93dc
movq %r8, 0x18(%rax)
movq %rdi, (%rax)
movq %rsi, 0x10(%rax)
movq %rdx, 0x8(%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
retq