// File: /workspace/github_cpp_makefile_star2_O3/hzeller[P]gcode-multi-shell-extrude/multi-shell-extrude.cc
// Function: main
int main(int argc, char *argv[]) {
  ParamHeadline h1("Screw-data from template");
  StringParam fun_init    ("AABBBAABBBAABBB", "screw-template", 't', "Template string for screw.");
  FloatParam thread_depth (-1, "thread-depth", 'd',   "Depth of thread, initial-size/5 if negative");
  FloatParam twist        (0.0, "twist",        0,    "Twist ratio of angle per radius fraction (good -0.3..0.3)");

  ParamHeadline h2("Screw-data from polygon file");
  StringParam polygon_file("", "polygon-file", 'D',  "File describing polygon. Files with x y pairs");

  ParamHeadline h3("General Parameters");
  FloatParam total_height (-1,    "height", 'h', "Total height to be printed (must set)");
  FloatParam pitch        (30.0,  "pitch",  'p', "Millimeter height a full turn takes. "
                           "Negative for left-turning screw; 0 for straight hull.");
  FloatParam initial_size (10.0, "size",    's', "Polygon sizing parameter. Means radius if from "
                           "--screw-template, factor for --polygon-file");
  Vector2DParam center_offset(Vector2D(0.0, 0.0), "center-offset", 0, "Rotation-center offset into polygon.");
  BoolParam  auto_center(false, "auto-center", 0, "Automatically center around centroid.");
  FloatParam pump         (0.0,   "pump",    0, "Pump polygon as if the center was not a dot, but a circle of this radius");
  IntParam screw_count    (2,     "number", 'n', "Number of screws to be printed");
  FloatParam initial_shell(0,     "start-offset", 0, "Initial offset for first polygon");
  FloatParam shell_increment(1.2, "offset", 'R', "Offset increment between screws - the clearance");
  FloatParam lock_offset  (-1,    "lock-offset", 0, "EXPERIMENTAL offset to stop screw at end; Approx value: (offset - shell_thickness)/2 + 0.05");
  FloatParam brim(0, "brim", 0, "Add brim of this size on the bottom for better stability");
  FloatParam brim_spiral_factor(0.55, "brim-spiral-factor", 0,
                               "Distance between spirals in brim as factor of shell-thickness");
  FloatParam brim_smooth_radius(0, "brim-smooth-radius", 0, "Smoothing of brim connection to polygon to not get lost in inner details");
  BoolParam vessel(false, "vessel", 0, "Make a vessel with closed bottom");

  ParamHeadline h4("Quality");
  FloatParam layer_height (0.16,  "layer-height", 'l', "Height of each layer");
  FloatParam shell_thickness(0.8, "shell-thickness", 0, "Thickness of shell");
  FloatParam feed_mm_per_sec(100, "feed-rate",    'f', "maximum, in mm/s");
  FloatParam min_layer_time(3,    "layer-time",   'T', "Min time per layer; upper bound for feed-rate");
  FloatParam fan_on (0.3,  "fan-on-height", 0, "Height to switch on fan");
  FloatParam elephant_foot_multiplier (0.9,  "slender-elephant", 0, "Extrusion multiplier at first two layer heights to prevent elephant foot");
  FloatParam retract_amount (1.2, "retract", 0, "Millimeter of retract");
  FloatParam first_layer_feed_multiplier (0.7, "first-layer-speed", 0, "Feedrate multiplier for first layer");
  ParamHeadline h5("Printer Parameters");
  FloatParam nozzle_diameter(0.4, "nozzle-diameter", 0, "Diameter of extruder nozzle");
  FloatParam bed_temp(-1, "bed-temp", 0, "Bed temperature.");
  FloatParam temperature(190, "temperature", 0, "Extrusion temperature.");
  FloatParam temp_variation(0, "temperature-variation", 0, "Temperature variation around --temperature, e.g. to get dark lines in wood filament.");
  FloatParam filament_diameter(1.75, "filament-diameter", 0, "Diameter of filament");
  Vector2DParam machine_limit(Vector2D(150.0,150.0), "bed-size",    'L',  "x/y size limit of your printbed.");
  Vector2DParam head_offset(Vector2D(45.0,45.0),"head-offset", 'o', "dx/dy offset per print.");
  Vector2DParam edge_offset(Vector2D(5.0,5.0), "edge-offset",  0,  "Offset from the edge of the bed (bottom left origin).");

  // Output options
  ParamHeadline h6("Output Options");
  BoolParam do_postscript(false, "postscript", 'P', "PostScript output instead of GCode output");
  FloatParam postscript_thick_factor(1.0, "ps-thick-factor", 0, "Line thickness factor for shell size. Chooser smaller (e.g. 0.1) to better see overlaps");
  BoolParam matryoshka(false,    "nested",      0, "For PostScript: show nested (Matryoshka doll style)");

  if (!SetParametersFromCommandline(argc, argv)) {
    return ParameterUsage(argv[0]);
  }

  if (total_height < 0) {
    fprintf(stderr, "\n--height needs to be set\n\n");
    return ParameterUsage(argv[0]);
  }

  if (thread_depth < 0)
    thread_depth = initial_size / 5;

  if (matryoshka && !do_postscript) {
    fprintf(stderr, "Matryoshka mode only valid with postscript\n");
    return ParameterUsage(argv[0]);
  }

  // Calculated values from input parameters.
  const double nozzle_radius = nozzle_diameter / 2;
  const double filament_radius = filament_diameter / 2;
  const double shell_thickness_factor = shell_thickness / nozzle_diameter;

  matryoshka = matryoshka & do_postscript;   // Formulate it this way.

  // Get polygon we'll be working on; either from rotational input or file.
  Polygon input_polygon = (polygon_file.get().empty()
                           ? RotationalPolygon(fun_init.get().c_str(),
                                               initial_size,
                                               thread_depth, twist)
                           : ReadPolygon(polygon_file, initial_size));

  // Add pump if needed.
  if (pump > 0) {
    input_polygon = RadialPumpPolygon(input_polygon, pump);
  }

  if (auto_center) {
    center_offset = Centroid(input_polygon);
    center_offset = Vector2D(0,0) - center_offset;
  }

  // .. and offsetting
  if (center_offset->x != 0 || center_offset->y != 0) {
    input_polygon = OffsetCenter(input_polygon,
                                 center_offset->x, center_offset->y);
  }

  const Polygon base_polygon = input_polygon;
  if (base_polygon.empty()) {
    fprintf(stderr, "Polygon empty\n");
    return 1;
  }
  if (base_polygon.size() < 3) {
    fprintf(stderr, "Polygon is a %sgon :) Need at least 3 vertices.\n",
            base_polygon.size() == 1 ? "Mono" : "Duo");
    return 1;
  }

  // Determine limits
  if (matryoshka) {
    Polygon biggst_polygon
      = PolygonOffset(base_polygon,
                      initial_shell + (screw_count-1) * shell_increment);
    double max_radius = GetRadius(biggst_polygon) + brim;
    Vector2D poly_radius(max_radius + 5, max_radius + 5);
    machine_limit = poly_radius * 2;
    edge_offset = poly_radius;  // In matryoshka-case, edge_offset is center
  } else {
    const Vector2D max_machine = machine_limit - edge_offset;
    Vector2D pos = edge_offset;
    float radius = GetRadius(PolygonOffset(base_polygon, initial_shell));
    Vector2D screw_dimension(2 * (radius + brim), 2*(radius + brim));
    for (int i = 0; i < screw_count; ++i) {
      Vector2D new_pos = pos + screw_dimension;
      if (new_pos.x > max_machine.x || new_pos.y > max_machine.y) {
        fprintf(stderr, "With currently configured bedsize and printhead-offset, "
                "only %d screws fit (radius is %.1fmm)\n"
                "Configure your machine constraints with -L <x/y> -o < dx,dy> "
                "(currently -L %.0f,%.0f -o %.0f,%.0f)\n", i, radius,
                machine_limit->x, machine_limit->y,
                head_offset->x, head_offset->y);
        screw_count = i;
        break;
      }
      pos = new_pos + head_offset;
      screw_dimension = screw_dimension
        + Vector2D(shell_increment, shell_increment) * 2;
    }
    pos = pos - head_offset;
    // Now, pos is the largest corner. We can offset
    // the edge_offset now to the difference to center things.
    edge_offset = edge_offset + (max_machine - pos - edge_offset) / 2;
  }

  const double filament_extrusion_factor = shell_thickness_factor *
    (nozzle_radius * (layer_height/2)) / (filament_radius*filament_radius);

  Printer *printer = NULL;
  if (do_postscript) {
    total_height = std::min(total_height.get(),
                            3 * layer_height); // not needed more.
    // no move lines w/ Matryoshka
    printer = CreatePostscriptPrinter(!matryoshka,
                                      postscript_thick_factor * shell_thickness);
  } else {
    printer = CreateGCodePrinter(filament_extrusion_factor, retract_amount,
                                 temperature, bed_temp);
  }
  printer->Preamble(machine_limit, feed_mm_per_sec);

  printer->Comment("https://github.com/hzeller/gcode-multi-shell-extrude\n");
  printer->Comment("\n");
  printer->Comment(" ");
  for (int i = 0; i < argc; ++i)
    printf("%s ", argv[i]);
  printf("\n");
  printer->Comment("\n");
  if (!polygon_file.get().empty()) {
    printer->Comment("Polygon from polygon-file '%s'\n",
                     polygon_file.get().c_str());
    printer->Comment("size-factor=%.1f\n", initial_size.get());
  } else {
    printer->Comment("Polygon from screw template '%s'\n",
                     fun_init.get().c_str());
    printer->Comment("thread-depth=%.1fmm size=%.1fmm (radius)\n",
                     thread_depth.get(), initial_size.get());
  }
  printer->Comment("h=%.1fmm n=%d (shell-increment=%.1fmm)\n",
                   total_height.get(), screw_count.get(), shell_increment.get());
  printer->Comment("feed=%.1fmm/s (maximum; layer time at least %.1f s)\n",
                   feed_mm_per_sec.get(), min_layer_time.get());
  printer->Comment("pitch=%.1fmm/turn layer-height=%.3f\n",
                   pitch.get(), layer_height.get());
  printer->Comment("machine limits: bed: (%.0f/%.0f):  "
                  "head-offset: (%.0f,%.0f)\n",
                   machine_limit->x, machine_limit->y,
                   head_offset->x, head_offset->y);
  printer->Comment("----\n");

  printer->Init(machine_limit, feed_mm_per_sec);

  // How much the whole system should rotate per mm height.
  const double rotation_per_mm = (fabs(pitch) < 0.1) ? 0 : 1.0 / pitch;

  double total_time = 0;
  double total_travel = 0;

  constexpr float kHoverPos = 10.0;  // Hovering over screws while moving
  Vector2D center = edge_offset;
  printer->SetSpeed(feed_mm_per_sec);  // initial speed.
  for (int i = 0; i < screw_count; ++i) {
    const float current_offset = initial_shell + i * shell_increment;
    Polygon polygon = PolygonOffset(base_polygon, current_offset);
    if (polygon.size() == 0) {
      fprintf(stderr, "Polygon offset %.1f results in empty polygon\n",
              initial_shell + i * shell_increment);
      continue;
    }
    const double radius = GetRadius(polygon);
    Vector2D screw_radius(radius + brim, radius + brim);
    if (!matryoshka) {
      // We start here.
      center = center + screw_radius;
    }
    printer->MoveTo(center, i > 0 ? total_height + kHoverPos : kHoverPos);
    const float polygon_len = CalcPolygonLen(polygon);
    const float area = polygon_len * total_height * 2;  // inside and out.
    float layer_feedrate =  polygon_len / min_layer_time;
    layer_feedrate = std::min(layer_feedrate, feed_mm_per_sec.get());
    printer->ResetExtrude();
    printer->SetSpeed(layer_feedrate);
    printer->Comment("Screw #%d, polygon-offset=%.1f\n",
                     i+1, initial_shell + i * shell_increment);
    if (vessel) {
      const float spiral_layer_distance = shell_thickness * brim_spiral_factor;
      printer->Comment("Create vessel-bottom\n");
      printer->SetColor(0.5, 0, 0.5);
      CreateBottomPlate(polygon, printer, center,
                        0, -radius, spiral_layer_distance);
      // TODO: make this multi-layer.
      printer->GoZPos(2);
    }

    if (brim > 0) {
      const float spiral_layer_distance = shell_thickness * brim_spiral_factor;
      int layers = (int) ceil(brim / spiral_layer_distance);
      Polygon brim_polygon = polygon;
      if (brim_smooth_radius > 0)
        brim_polygon = PolygonOffset(PolygonOffset(polygon, brim_smooth_radius), -brim_smooth_radius);
      printer->Comment("Create brim\n");
      printer->SetColor(0, 0.5, 0);
      CreateBottomPlate(brim_polygon, printer, center,
                        layers * spiral_layer_distance, spiral_layer_distance/2,
                        spiral_layer_distance);
    }
    ExtrusionParams params = {
      .feedrate = layer_feedrate,
      .layer_height = layer_height,
      .total_height = total_height,
      .rotation_per_mm = rotation_per_mm,
      .lock_offset = lock_offset,
      .fan_on_height = fan_on,
      .elephant_foot_multiplier = elephant_foot_multiplier,
      .first_layer_feedrate_multiplier = first_layer_feed_multiplier,
      .base_temp = temperature,
      .temp_variation = temp_variation
    };

    CreateExtrusion(polygon, printer, center, params);
    const double travel = printer->GetExtrusionDistance();  // since last reset.
    total_travel += travel;
    total_time += travel / layer_feedrate;  // roughly (without acceleration)
    printer->SetSpeed(feed_mm_per_sec);
    printer->Retract();
    printer->GoZPos(total_height + kHoverPos);
    if (!matryoshka) {
      center = center + screw_radius + head_offset;
    }
    if (!do_postscript) {
      fprintf(stderr, "Screw-surface (out+in) for offset %.1f: ~%.1f cm²\n",
              current_offset, area / 100);
    }
  }

  printer->Postamble();
  if (!do_postscript) {  // doesn't make sense to print for PostScript
    int t = (int)total_time;
    const int hours = t / 3600;
    t %= 3600;
    const int minutes = t / 60;
    const int seconds = t % 60;
    fprintf(stderr, "Total time >= %02d:%02d:%02d; %.2fm filament\n", hours,
            minutes, seconds, total_travel * filament_extrusion_factor / 1000);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x978, %rsp            # imm = 0x978
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x1041f(%rip), %rcx     # 0x1416a
leaq 0x958(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x7cec
leaq 0x17bb2(%rip), %r15     # 0x1b918
movq %r15, (%r14)
leaq 0x3a8(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x10407(%rip), %rsi     # 0x14183
leaq 0x1040f(%rip), %rdx     # 0x14192
leaq 0x398(%rsp), %rdi
callq 0x6474
leaq 0x103fc(%rip), %rsi     # 0x14193
leaq 0x10404(%rip), %rcx     # 0x141a2
leaq 0x1b8(%rsp), %rdi
movl $0x74, %edx
callq 0x7cec
leaq 0x17bc1(%rip), %rax     # 0x1b978
leaq 0x1d8(%rsp), %rdi
movq %rax, -0x20(%rdi)
leaq 0x1e8(%rsp), %rax
movq %rax, -0x10(%rax)
movq 0x398(%rsp), %rsi
movq 0x3a0(%rsp), %rdx
addq %rsi, %rdx
callq 0x670e
movq 0x398(%rsp), %rdi
cmpq %r14, %rdi
je 0x3e04
movq 0x3a8(%rsp), %rsi
incq %rsi
callq 0x3220
leaq 0x103b2(%rip), %rsi     # 0x141bd
leaq 0x103b8(%rip), %rcx     # 0x141ca
leaq 0x508(%rsp), %rdi
movl $0x64, %edx
callq 0x7cec
leaq 0x17b9d(%rip), %r12     # 0x1b9c8
movq %r12, 0x508(%rsp)
movl $0xbf800000, 0x528(%rsp) # imm = 0xBF800000
leaq 0x103b1(%rip), %rsi     # 0x141f6
leaq 0x103b0(%rip), %rcx     # 0x141fc
leaq 0x890(%rsp), %rdi
xorl %edx, %edx
callq 0x7cec
movq %r12, 0x890(%rsp)
movl $0x0, 0x8b0(%rsp)
leaq 0x103c1(%rip), %rcx     # 0x14236
leaq 0x938(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x7cec
movq %r15, 0x938(%rsp)
leaq 0x2b8(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x11439(%rip), %rdx     # 0x152da
leaq 0x2a8(%rsp), %rdi
movq %rdx, %rsi
callq 0x6474
leaq 0x104b1(%rip), %rsi     # 0x14369
leaq 0x10394(%rip), %rcx     # 0x14253
leaq 0x70(%rsp), %rdi
movl $0x44, %edx
callq 0x7cec
leaq 0x90(%rsp), %rdi
leaq 0x17a9b(%rip), %rax     # 0x1b978
movq %rax, -0x20(%rdi)
leaq 0xa0(%rsp), %rax
movq %rax, -0x10(%rax)
movq 0x2a8(%rsp), %rsi
movq 0x2b0(%rsp), %rdx
addq %rsi, %rdx
callq 0x670e
movq 0x2a8(%rsp), %rdi
cmpq %r13, %rdi
je 0x3f22
movq 0x2b8(%rsp), %rsi
incq %rsi
callq 0x3220
leaq 0x10358(%rip), %rcx     # 0x14281
leaq 0x918(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x7cec
movq %r15, 0x918(%rsp)
leaq 0x1076d(%rip), %rsi     # 0x146b6
leaq 0x10344(%rip), %rcx     # 0x14294
leaq 0x1f8(%rsp), %rdi
movl $0x68, %edx
callq 0x7cec
movq %r12, 0x1f8(%rsp)
movl $0xbf800000, 0x218(%rsp) # imm = 0xBF800000
leaq 0x1033e(%rip), %rsi     # 0x142ba
leaq 0x1033d(%rip), %rcx     # 0x142c0
leaq 0x660(%rsp), %rdi
movl $0x70, %edx
callq 0x7cec
movq %r12, 0x660(%rsp)
movl $0x41f00000, 0x680(%rsp) # imm = 0x41F00000
leaq 0x108de(%rip), %rsi     # 0x1488d
leaq 0x10365(%rip), %rcx     # 0x1431b
leaq 0x3e0(%rsp), %rdi
movl $0x73, %edx
callq 0x7cec
movl %ebp, %r14d
movq %r12, 0x3e0(%rsp)
movl $0x41200000, 0x400(%rsp) # imm = 0x41200000
leaq 0x10391(%rip), %rsi     # 0x14376
leaq 0x10398(%rip), %rcx     # 0x14384
leaq 0x630(%rsp), %rdi
xorl %edx, %edx
callq 0x7cec
leaq 0x17a16(%rip), %rbp     # 0x1ba18
movq %rbp, 0x630(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x650(%rsp)
leaq 0x1038d(%rip), %rsi     # 0x143a9
leaq 0x10392(%rip), %rcx     # 0x143b5
leaq 0x868(%rsp), %rdi
xorl %edx, %edx
callq 0x7cec
leaq 0x17a2f(%rip), %r13     # 0x1ba68
movq %r13, 0x868(%rsp)
movb $0x0, 0x888(%rsp)
leaq 0x1038b(%rip), %rsi     # 0x143db
leaq 0x10389(%rip), %rcx     # 0x143e0
leaq 0x840(%rsp), %rdi
xorl %edx, %edx
callq 0x7cec
movq %r12, 0x840(%rsp)
movl $0x0, 0x860(%rsp)
leaq 0x103a9(%rip), %rsi     # 0x14429
leaq 0x103a9(%rip), %rcx     # 0x14430
leaq 0x370(%rsp), %rdi
movl $0x6e, %edx
callq 0x7cec
leaq 0x17a18(%rip), %rax     # 0x1bab8
movq %rax, 0x370(%rsp)
movl $0x2, 0x390(%rsp)
leaq 0x10395(%rip), %rsi     # 0x1444f
leaq 0x1039b(%rip), %rcx     # 0x1445c
leaq 0x3b8(%rsp), %rdi
xorl %edx, %edx
callq 0x7cec
movq %r12, 0x3b8(%rsp)
movl $0x0, 0x3d8(%rsp)
leaq 0x107ce(%rip), %rsi     # 0x148b8
leaq 0x1038c(%rip), %rcx     # 0x1447d
leaq 0x348(%rsp), %rdi
movl $0x52, %edx
callq 0x7cec
movq %r12, 0x348(%rsp)
movl $0x3f99999a, 0x368(%rsp) # imm = 0x3F99999A
leaq 0x10390(%rip), %rsi     # 0x144ad
leaq 0x10395(%rip), %rcx     # 0x144b9
leaq 0x818(%rsp), %rdi
xorl %edx, %edx
callq 0x7cec
movq %r12, 0x818(%rsp)
movl $0xbf800000, 0x838(%rsp) # imm = 0xBF800000
leaq 0x103c8(%rip), %rsi     # 0x14515
leaq 0x103c6(%rip), %rcx     # 0x1451a
leaq 0x488(%rsp), %rdi
xorl %edx, %edx
callq 0x7cec
movq %r12, 0x488(%rsp)
movl $0x0, 0x4a8(%rsp)
leaq 0x103d6(%rip), %rsi     # 0x14553
leaq 0x103e2(%rip), %rcx     # 0x14566
leaq 0x608(%rsp), %rdi
xorl %edx, %edx
callq 0x7cec
movq %r12, 0x608(%rsp)
movl $0x3f0ccccd, 0x628(%rsp) # imm = 0x3F0CCCCD
leaq 0x103f7(%rip), %rsi     # 0x145a4
leaq 0x10403(%rip), %rcx     # 0x145b7
leaq 0x5e0(%rsp), %rdi
xorl %edx, %edx
callq 0x7cec
movq %r12, 0x5e0(%rsp)
movl $0x0, 0x600(%rsp)
leaq 0x10423(%rip), %rsi     # 0x14600
leaq 0x10423(%rip), %rcx     # 0x14607
leaq 0x7f0(%rsp), %rdi
xorl %edx, %edx
callq 0x7cec
movq %r13, 0x7f0(%rsp)
movb $0x0, 0x810(%rsp)
leaq 0x1041e(%rip), %rcx     # 0x14628
leaq 0x8f8(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x7cec
movq %r15, 0x8f8(%rsp)
leaq 0x10406(%rip), %rsi     # 0x14630
leaq 0x1040c(%rip), %rcx     # 0x1463d
leaq 0x4e0(%rsp), %rdi
movl $0x6c, %edx
callq 0x7cec
movq %r12, 0x4e0(%rsp)
movl $0x3e23d70a, 0x500(%rsp) # imm = 0x3E23D70A
leaq 0x10337(%rip), %rsi     # 0x14594
leaq 0x103ee(%rip), %rcx     # 0x14652
leaq 0x460(%rsp), %rdi
xorl %edx, %edx
callq 0x7cec
movq %r12, 0x460(%rsp)
movl $0x3f4ccccd, 0x480(%rsp) # imm = 0x3F4CCCCD
leaq 0x10418(%rip), %rsi     # 0x146a5
leaq 0x103d1(%rip), %rcx     # 0x14665
leaq 0x320(%rsp), %rdi
movl $0x66, %edx
callq 0x7cec
movq %r12, 0x320(%rsp)
movl $0x42c80000, 0x340(%rsp) # imm = 0x42C80000
leaq 0x103b6(%rip), %rsi     # 0x14676
leaq 0x103ba(%rip), %rcx     # 0x14681
leaq 0x5b8(%rsp), %rdi
movl $0x54, %edx
callq 0x7cec
movq %r12, 0x5b8(%rsp)
movl $0x40400000, 0x5d8(%rsp) # imm = 0x40400000
leaq 0x103bc(%rip), %rsi     # 0x146af
leaq 0x103c3(%rip), %rcx     # 0x146bd
leaq 0x7c8(%rsp), %rdi
xorl %edx, %edx
callq 0x7cec
movq %r12, 0x7c8(%rsp)
movl $0x3e99999a, 0x7e8(%rsp) # imm = 0x3E99999A
leaq 0x103b2(%rip), %rsi     # 0x146d5
leaq 0x103bc(%rip), %rcx     # 0x146e6
leaq 0x7a0(%rsp), %rdi
xorl %edx, %edx
callq 0x7cec
movq %r12, 0x7a0(%rsp)
movl $0x3f666666, 0x7c0(%rsp) # imm = 0x3F666666
leaq 0x103ea(%rip), %rsi     # 0x1473d
leaq 0x103d5(%rip), %rcx     # 0x1472f
leaq 0x778(%rsp), %rdi
xorl %edx, %edx
callq 0x7cec
movq %r12, 0x778(%rsp)
movl $0x3f99999a, 0x798(%rsp) # imm = 0x3F99999A
leaq 0x103c2(%rip), %rsi     # 0x14745
leaq 0x103cd(%rip), %rcx     # 0x14757
leaq 0x750(%rsp), %rdi
xorl %edx, %edx
callq 0x7cec
movq %r12, 0x750(%rsp)
movl $0x3f333333, 0x770(%rsp) # imm = 0x3F333333
leaq 0x103c8(%rip), %rcx     # 0x1477b
leaq 0x8d8(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x7cec
movq %r15, 0x8d8(%rsp)
leaq 0x103bb(%rip), %rsi     # 0x1478e
leaq 0x103c4(%rip), %rcx     # 0x1479e
leaq 0x728(%rsp), %rdi
xorl %edx, %edx
callq 0x7cec
movq %r12, 0x728(%rsp)
movl $0x3ecccccd, 0x748(%rsp) # imm = 0x3ECCCCCD
leaq 0x103b7(%rip), %rsi     # 0x147ba
leaq 0x103b9(%rip), %rcx     # 0x147c3
leaq 0x700(%rsp), %rdi
xorl %edx, %edx
callq 0x7cec
movq %r12, 0x700(%rsp)
movl $0xbf800000, 0x720(%rsp) # imm = 0xBF800000
leaq 0x103a1(%rip), %rsi     # 0x147d4
leaq 0x103a6(%rip), %rcx     # 0x147e0
leaq 0x590(%rsp), %rdi
xorl %edx, %edx
callq 0x7cec
movq %r12, 0x590(%rsp)
movl $0x433e0000, 0x5b0(%rsp) # imm = 0x433E0000
leaq 0x10394(%rip), %rsi     # 0x147f7
leaq 0x103a3(%rip), %rcx     # 0x1480d
leaq 0x6d8(%rsp), %rdi
xorl %edx, %edx
callq 0x7cec
movq %r12, 0x6d8(%rsp)
movl $0x0, 0x6f8(%rsp)
leaq 0x103cf(%rip), %rsi     # 0x14862
leaq 0x103da(%rip), %rcx     # 0x14874
leaq 0x6b0(%rsp), %rdi
xorl %edx, %edx
callq 0x7cec
movq %r12, 0x6b0(%rsp)
movl $0x3fe00000, 0x6d0(%rsp) # imm = 0x3FE00000
leaq 0x103c6(%rip), %rsi     # 0x14889
leaq 0x103c8(%rip), %rcx     # 0x14892
leaq 0x2c8(%rsp), %rdi
movl $0x4c, %edx
callq 0x7cec
movq %rbp, 0x2c8(%rsp)
movaps 0xfb35(%rip), %xmm0     # 0x14020
movups %xmm0, 0x2e8(%rsp)
leaq 0x103b9(%rip), %rsi     # 0x148b3
leaq 0x103be(%rip), %rcx     # 0x148bf
leaq 0x4b0(%rsp), %rdi
movl $0x6f, %edx
callq 0x7cec
movq %rbp, 0x4b0(%rsp)
movaps 0xfb0e(%rip), %xmm0     # 0x14030
movups %xmm0, 0x4d0(%rsp)
leaq 0x103a6(%rip), %rsi     # 0x148d7
leaq 0x103ab(%rip), %rcx     # 0x148e3
leaq 0x408(%rsp), %rdi
xorl %edx, %edx
callq 0x7cec
movq %rbp, 0x408(%rsp)
movaps 0xfaea(%rip), %xmm0     # 0x14040
movups %xmm0, 0x428(%rsp)
leaq 0x103b4(%rip), %rcx     # 0x14919
leaq 0x8b8(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x7cec
movq %r15, 0x8b8(%rsp)
leaq 0x103a3(%rip), %rsi     # 0x14928
leaq 0x103a7(%rip), %rcx     # 0x14933
leaq 0x438(%rsp), %rdi
movl $0x50, %edx
callq 0x7cec
movl %r14d, %ebp
movq %r13, 0x438(%rsp)
movb $0x0, 0x458(%rsp)
leaq 0x103a5(%rip), %rsi     # 0x1495d
leaq 0x103ae(%rip), %rcx     # 0x1496d
leaq 0x688(%rsp), %rdi
xorl %edx, %edx
callq 0x7cec
movq %r12, 0x688(%rsp)
movl $0x3f800000, 0x6a8(%rsp) # imm = 0x3F800000
leaq 0x103dd(%rip), %rsi     # 0x149c5
leaq 0x103dd(%rip), %rcx     # 0x149cc
leaq 0x2f8(%rsp), %rdi
xorl %edx, %edx
callq 0x7cec
movq %r13, 0x2f8(%rsp)
movb $0x0, 0x318(%rsp)
movl %ebp, %edi
movq %rbx, %rsi
callq 0x7f97
testb %al, %al
je 0x5cd5
xorps %xmm0, %xmm0
ucomiss 0x218(%rsp), %xmm0
ja 0x5c96
movss 0x528(%rsp), %xmm1
ucomiss %xmm1, %xmm0
jbe 0x4659
movss 0x400(%rsp), %xmm1
divss 0xfab8(%rip), %xmm1     # 0x14108
movss %xmm1, 0x528(%rsp)
movb 0x318(%rsp), %al
movb 0x458(%rsp), %cl
cmpb $0x1, %al
jne 0x4674
testb $0x1, %cl
je 0x5cd0
movss 0x748(%rsp), %xmm0
movss %xmm0, 0x20(%rsp)
movss 0x6d0(%rsp), %xmm0
mulss 0xfa78(%rip), %xmm0     # 0x1410c
movss %xmm0, 0x40(%rsp)
movss 0x480(%rsp), %xmm0
movss %xmm0, 0x30(%rsp)
andb %al, %cl
movb %cl, 0x318(%rsp)
cmpq $0x0, 0x98(%rsp)
je 0x46e0
xorps %xmm0, %xmm0
cvtss2sd 0x400(%rsp), %xmm0
leaq 0xd0(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x3a20
jmp 0x470e
xorps %xmm0, %xmm0
cvtss2sd 0x400(%rsp), %xmm0
movq 0x1d8(%rsp), %rsi
cvtss2sd %xmm1, %xmm1
cvtss2sd 0x8b0(%rsp), %xmm2
leaq 0xd0(%rsp), %rdi
callq 0x67cc
movss 0x860(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x478f
cvtss2sd %xmm0, %xmm0
movq %rsp, %rdi
leaq 0xd0(%rsp), %rsi
callq 0x3bec
movq 0xd0(%rsp), %rdi
movq 0xe0(%rsp), %rsi
movaps (%rsp), %xmm0
movaps %xmm0, 0xd0(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0xe0(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
testq %rdi, %rdi
je 0x478f
subq %rdi, %rsi
callq 0x3220
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x478f
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x3220
cmpb $0x1, 0x888(%rsp)
jne 0x47c6
leaq 0xd0(%rsp), %rdi
callq 0x8384
movaps %xmm0, %xmm2
movlhps %xmm1, %xmm2            # xmm2 = xmm2[0],xmm1[0]
xorps %xmm0, %xmm0
subpd %xmm2, %xmm0
movupd %xmm0, 0x650(%rsp)
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
jmp 0x47d8
movsd 0x650(%rsp), %xmm0
movsd 0x658(%rsp), %xmm1
xorps %xmm2, %xmm2
ucomisd %xmm2, %xmm0
jne 0x47eb
jp 0x47eb
ucomisd %xmm2, %xmm1
jne 0x47eb
jnp 0x485b
movq %rsp, %rdi
leaq 0xd0(%rsp), %rsi
callq 0x3971
movq 0xd0(%rsp), %rdi
movq 0xe0(%rsp), %rsi
movapd (%rsp), %xmm0
movapd %xmm0, 0xd0(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0xe0(%rsp)
xorpd %xmm0, %xmm0
movapd %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
testq %rdi, %rdi
je 0x485b
subq %rdi, %rsi
callq 0x3220
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x485b
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x3220
leaq 0x168(%rsp), %rdi
leaq 0xd0(%rsp), %rsi
callq 0x6262
movq 0x168(%rsp), %rax
movq 0x170(%rsp), %rdi
cmpq %rdi, %rax
je 0x5cab
subq %rax, %rdi
cmpq $0x20, %rdi
jbe 0x5cb2
cmpb $0x1, 0x318(%rsp)
jne 0x4935
movl 0x390(%rsp), %eax
decl %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
mulss 0x368(%rsp), %xmm0
addss 0x3d8(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
movq %rsp, %rdi
leaq 0x168(%rsp), %rsi
xorl %edx, %edx
callq 0x6c88
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
subq %rdi, %rax
je 0x49d0
sarq $0x4, %rax
cmpq $0x1, %rax
adcq $0x0, %rax
leaq 0x8(%rdi), %rcx
movsd 0xf78a(%rip), %xmm0     # 0x14090
movsd -0x8(%rcx), %xmm1
movsd (%rcx), %xmm2
mulsd %xmm2, %xmm2
mulsd %xmm1, %xmm1
addsd %xmm2, %xmm1
sqrtsd %xmm1, %xmm1
maxsd %xmm0, %xmm1
addq $0x10, %rcx
movapd %xmm1, %xmm0
decq %rax
jne 0x4906
jmp 0x49d8
movups 0x2e8(%rsp), %xmm0
movaps %xmm0, 0xb0(%rsp)
movups 0x428(%rsp), %xmm0
movaps %xmm0, 0x120(%rsp)
xorps %xmm0, %xmm0
cvtss2sd 0x3d8(%rsp), %xmm0
movq %rsp, %rdi
leaq 0x168(%rsp), %rsi
xorl %edx, %edx
callq 0x6c88
movq (%rsp), %rdi
movq 0x8(%rsp), %rcx
movq %rcx, %rax
subq %rdi, %rax
je 0x4a33
sarq $0x4, %rax
cmpq $0x1, %rax
adcq $0x0, %rax
leaq 0x8(%rdi), %rcx
movsd 0xf6f0(%rip), %xmm0     # 0x14090
movapd %xmm0, %xmm1
movsd -0x8(%rcx), %xmm0
movsd (%rcx), %xmm2
mulsd %xmm2, %xmm2
mulsd %xmm0, %xmm0
addsd %xmm2, %xmm0
sqrtsd %xmm0, %xmm0
maxsd %xmm1, %xmm0
addq $0x10, %rcx
decq %rax
jne 0x49a0
cvtsd2ss %xmm0, %xmm0
jmp 0x4a44
movsd 0xf6b8(%rip), %xmm1     # 0x14090
xorps %xmm0, %xmm0
cvtss2sd 0x4a8(%rsp), %xmm0
addsd %xmm1, %xmm0
addsd 0xf6a8(%rip), %xmm0     # 0x14098
movsd %xmm0, 0x428(%rsp)
movsd %xmm0, 0x430(%rsp)
addsd %xmm0, %xmm0
movsd %xmm0, 0x2e8(%rsp)
movsd %xmm0, 0x2f0(%rsp)
testq %rdi, %rdi
je 0x4b22
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x3220
jmp 0x4b22
movss 0xf6d5(%rip), %xmm0     # 0x14110
testq %rcx, %rcx
je 0x5c9d
movss %xmm0, 0x180(%rsp)
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x3220
movapd 0xb0(%rsp), %xmm5
movapd 0x120(%rsp), %xmm6
subpd %xmm6, %xmm5
movl 0x390(%rsp), %eax
movupd 0x4d0(%rsp), %xmm3
testl %eax, %eax
jle 0x4af8
movss 0x4a8(%rsp), %xmm0
addss 0x180(%rsp), %xmm0
addss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm0
xorps %xmm1, %xmm1
cvtss2sd 0x368(%rsp), %xmm1
addsd %xmm1, %xmm1
movlhps %xmm0, %xmm0            # xmm0 = xmm0[0,0]
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
xorl %r14d, %r14d
movaps %xmm0, %xmm2
addpd %xmm6, %xmm2
ucomisd %xmm5, %xmm2
ja 0x5d58
movapd %xmm5, %xmm4
cmpltpd %xmm2, %xmm4
pextrw $0x4, %xmm4, %ecx
testb $0x1, %cl
jne 0x5d58
addpd %xmm3, %xmm2
addpd %xmm1, %xmm0
incl %r14d
movapd %xmm2, %xmm6
cmpl %r14d, %eax
jne 0x4ab8
movapd %xmm2, %xmm6
subpd %xmm3, %xmm6
subpd %xmm6, %xmm5
movupd 0x428(%rsp), %xmm0
subpd %xmm0, %xmm5
mulpd 0xf53b(%rip), %xmm5     # 0x14050
addpd %xmm0, %xmm5
movupd %xmm5, 0x428(%rsp)
movss 0x20(%rsp), %xmm0
movss 0x40(%rsp), %xmm2
movss 0x30(%rsp), %xmm3
divss %xmm0, %xmm3
mulss 0xf5cc(%rip), %xmm0     # 0x1410c
xorps %xmm1, %xmm1
cvtss2sd %xmm0, %xmm1
cvtss2sd %xmm2, %xmm2
cvtss2sd %xmm3, %xmm3
movss 0x500(%rsp), %xmm5
movss 0xf5ac(%rip), %xmm4     # 0x1410c
mulss %xmm5, %xmm4
xorps %xmm0, %xmm0
cvtss2sd %xmm4, %xmm0
mulsd %xmm1, %xmm0
mulsd %xmm3, %xmm0
mulsd %xmm2, %xmm2
divsd %xmm2, %xmm0
cmpb $0x1, 0x458(%rsp)
movsd %xmm0, 0x220(%rsp)
jne 0x4bd0
mulss 0xf57e(%rip), %xmm5     # 0x14114
minss 0x218(%rsp), %xmm5
movss %xmm5, 0x218(%rsp)
movzbl 0x318(%rsp), %edi
movss 0x6a8(%rsp), %xmm0
mulss 0x480(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
xorl $0x1, %edi
callq 0x748b
jmp 0x4bf9
xorps %xmm1, %xmm1
cvtss2sd 0x798(%rsp), %xmm1
xorps %xmm2, %xmm2
cvtss2sd 0x5b0(%rsp), %xmm2
xorps %xmm3, %xmm3
cvtss2sd 0x720(%rsp), %xmm3
callq 0x7410
movq %rax, %r14
leaq 0x2e8(%rsp), %r15
xorps %xmm0, %xmm0
cvtss2sd 0x340(%rsp), %xmm0
movq (%rax), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *(%rax)
movq (%r14), %rcx
leaq 0xff2e(%rip), %rsi      # 0x14b53
movq %r14, %rdi
xorl %eax, %eax
callq *0x18(%rcx)
movq (%r14), %rcx
leaq 0x106a2(%rip), %rsi     # 0x152d9
movq %r14, %rdi
xorl %eax, %eax
callq *0x18(%rcx)
movq (%r14), %rcx
leaq 0x106d7(%rip), %rsi     # 0x15320
movq %r14, %rdi
xorl %eax, %eax
callq *0x18(%rcx)
testl %ebp, %ebp
jle 0x4c77
movl %ebp, %r13d
leaq 0xff2a(%rip), %r12      # 0x14b89
xorl %ebp, %ebp
movq (%rbx,%rbp,8), %rsi
movq %r12, %rdi
xorl %eax, %eax
callq 0x3040
incq %rbp
cmpq %rbp, %r13
jne 0x4c61
movl $0xa, %edi
callq 0x32b0
movq (%r14), %rcx
leaq 0x1064e(%rip), %rsi     # 0x152d9
movq %r14, %rdi
xorl %eax, %eax
callq *0x18(%rcx)
cmpq $0x0, 0x98(%rsp)
movq (%r14), %rax
movq 0x18(%rax), %rcx
je 0x4cdb
movq 0x90(%rsp), %rdx
leaq 0xfed9(%rip), %rsi      # 0x14b8d
movq %r14, %rdi
xorl %eax, %eax
callq *%rcx
xorps %xmm0, %xmm0
cvtss2sd 0x400(%rsp), %xmm0
movq (%r14), %rcx
leaq 0xfedc(%rip), %rsi      # 0x14bad
movq %r14, %rdi
movb $0x1, %al
callq *0x18(%rcx)
jmp 0x4d1b
movq 0x1d8(%rsp), %rdx
leaq 0xfed5(%rip), %rsi      # 0x14bbf
movq %r14, %rdi
xorl %eax, %eax
callq *%rcx
xorps %xmm0, %xmm0
cvtss2sd 0x528(%rsp), %xmm0
xorps %xmm1, %xmm1
cvtss2sd 0x400(%rsp), %xmm1
movq (%r14), %rcx
leaq 0xfece(%rip), %rsi      # 0x14be1
movq %r14, %rdi
movb $0x2, %al
callq *0x18(%rcx)
xorps %xmm0, %xmm0
cvtss2sd 0x218(%rsp), %xmm0
movl 0x390(%rsp), %edx
xorps %xmm1, %xmm1
cvtss2sd 0x368(%rsp), %xmm1
movq (%r14), %rcx
leaq 0xfec7(%rip), %rsi      # 0x14c0b
movq %r14, %rdi
movb $0x2, %al
callq *0x18(%rcx)
xorps %xmm0, %xmm0
cvtss2sd 0x340(%rsp), %xmm0
xorps %xmm1, %xmm1
cvtss2sd 0x5d8(%rsp), %xmm1
movq (%r14), %rcx
leaq 0xfec5(%rip), %rsi      # 0x14c33
movq %r14, %rdi
movb $0x2, %al
callq *0x18(%rcx)
xorps %xmm0, %xmm0
cvtss2sd 0x680(%rsp), %xmm0
xorps %xmm1, %xmm1
cvtss2sd 0x500(%rsp), %xmm1
movq (%r14), %rcx
leaq 0xfed0(%rip), %rsi      # 0x14c68
movq %r14, %rdi
movb $0x2, %al
callq *0x18(%rcx)
movsd 0x2e8(%rsp), %xmm0
movsd 0x2f0(%rsp), %xmm1
movsd 0x4d0(%rsp), %xmm2
movsd 0x4d8(%rsp), %xmm3
movq (%r14), %rcx
leaq 0xfebf(%rip), %rsi      # 0x14c8d
movq %r14, %rdi
movb $0x4, %al
callq *0x18(%rcx)
movq (%r14), %rcx
leaq 0xfeea(%rip), %rsi      # 0x14cca
movq %r14, %rdi
xorl %eax, %eax
callq *0x18(%rcx)
xorps %xmm0, %xmm0
cvtss2sd 0x340(%rsp), %xmm0
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0x8(%rax)
leaq 0x428(%rsp), %rax
movss 0x680(%rsp), %xmm0
movaps %xmm0, 0x20(%rsp)
movups (%rax), %xmm0
movaps %xmm0, 0xc0(%rsp)
xorps %xmm0, %xmm0
cvtss2sd 0x340(%rsp), %xmm0
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
cmpl $0x0, 0x390(%rsp)
jle 0x5c2e
movaps 0x20(%rsp), %xmm1
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
andps 0xf209(%rip), %xmm1     # 0x14060
xorps %xmm2, %xmm2
cvtss2sd %xmm1, %xmm2
movsd 0xf23a(%rip), %xmm1     # 0x140a0
divsd %xmm0, %xmm1
cmpltsd 0xf235(%rip), %xmm2     # 0x140a8
andnpd %xmm1, %xmm2
movapd %xmm2, 0x530(%rsp)
xorpd %xmm0, %xmm0
movsd %xmm0, 0x138(%rsp)
leaq 0x168(%rsp), %r15
leaq 0xc0(%rsp), %r12
leaq 0xfe5a(%rip), %r13      # 0x14cfe
leaq 0x290(%rsp), %rbp
leaq 0x50(%rsp), %rbx
xorl %eax, %eax
movsd %xmm0, 0xf8(%rsp)
movq %rax, 0x140(%rsp)
xorps %xmm1, %xmm1
cvtsi2ss %eax, %xmm1
movss 0x368(%rsp), %xmm0
movss %xmm1, 0x20(%rsp)
mulss %xmm1, %xmm0
addss 0x3d8(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x108(%rsp), %rdi
movq %r15, %rsi
movsd %xmm0, 0x228(%rsp)
xorl %edx, %edx
callq 0x6c88
movq 0x108(%rsp), %rax
movq 0x110(%rsp), %rcx
subq %rax, %rcx
movq 0x140(%rsp), %rdx
je 0x5bc4
sarq $0x4, %rcx
cmpq $0x1, %rcx
adcq $0x0, %rcx
addq $0x8, %rax
movsd 0xf151(%rip), %xmm2     # 0x14090
movapd %xmm2, %xmm0
movsd -0x8(%rax), %xmm1
movsd (%rax), %xmm2
mulsd %xmm2, %xmm2
mulsd %xmm1, %xmm1
addsd %xmm2, %xmm1
xorps %xmm2, %xmm2
sqrtsd %xmm1, %xmm2
maxsd %xmm0, %xmm2
addq $0x10, %rax
decq %rcx
jne 0x4f3f
xorps %xmm1, %xmm1
cvtss2sd 0x4a8(%rsp), %xmm1
addsd %xmm2, %xmm1
cmpb $0x0, 0x318(%rsp)
jne 0x4fa0
movapd %xmm1, %xmm0
unpcklpd %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
addpd 0xc0(%rsp), %xmm0
movapd %xmm0, 0xc0(%rsp)
movsd %xmm2, 0x120(%rsp)
movapd %xmm1, 0x540(%rsp)
movss 0x218(%rsp), %xmm1
addss 0xf155(%rip), %xmm1     # 0x14118
movsd 0xf0e5(%rip), %xmm0     # 0x140b0
testl %edx, %edx
je 0x4fd6
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
movq (%r14), %rax
movq %r14, %rdi
movq %r12, %rsi
callq *0x48(%rax)
leaq 0x108(%rsp), %rdi
callq 0x38dc
xorps %xmm1, %xmm1
cvtsd2ss %xmm0, %xmm1
movss 0x218(%rsp), %xmm0
movss %xmm1, 0x40(%rsp)
mulss %xmm1, %xmm0
movss %xmm0, 0x164(%rsp)
movss 0x5d8(%rsp), %xmm0
movss %xmm0, 0xb0(%rsp)
movss 0x340(%rsp), %xmm0
movss %xmm0, 0x30(%rsp)
movq (%r14), %rax
movq %r14, %rdi
callq *0x30(%rax)
movss 0x40(%rsp), %xmm0
divss 0xb0(%rsp), %xmm0
movss 0x30(%rsp), %xmm1
minss %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
movq (%r14), %rax
movq %r14, %rdi
movsd %xmm0, 0x100(%rsp)
callq *0x28(%rax)
movq 0x140(%rsp), %rax
leal 0x1(%rax), %edx
movss 0x20(%rsp), %xmm0
mulss 0x368(%rsp), %xmm0
addss 0x3d8(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
movq (%r14), %rcx
movq %r14, %rdi
movq %r13, %rsi
movb $0x1, %al
callq *0x18(%rcx)
cmpb $0x1, 0x810(%rsp)
jne 0x5132
movss 0x480(%rsp), %xmm0
mulss 0x628(%rsp), %xmm0
movss %xmm0, 0x20(%rsp)
movq (%r14), %rcx
movq %r14, %rdi
leaq 0xfc48(%rip), %rsi      # 0x14d1e
xorl %eax, %eax
callq *0x18(%rcx)
movq (%r14), %rax
xorps %xmm1, %xmm1
movq %r14, %rdi
movss 0xf020(%rip), %xmm0     # 0x1410c
movaps %xmm0, %xmm2
callq *0x68(%rax)
xorps %xmm1, %xmm1
cvtsd2ss 0x120(%rsp), %xmm1
xorps 0xef6b(%rip), %xmm1     # 0x14070
xorps %xmm0, %xmm0
leaq 0x108(%rsp), %rdi
movq %r14, %rsi
movq %r12, %rdx
movss 0x20(%rsp), %xmm2
callq 0x5fb3
movq (%r14), %rax
movq %r14, %rdi
movsd 0xef89(%rip), %xmm0     # 0x140b8
callq *0x40(%rax)
movss 0x4a8(%rsp), %xmm0
ucomiss 0xefde(%rip), %xmm0     # 0x14120
jbe 0x52aa
movss 0x480(%rsp), %xmm1
mulss 0x628(%rsp), %xmm1
movss %xmm1, 0x20(%rsp)
divss %xmm1, %xmm0
callq 0x3120
movss %xmm0, 0x40(%rsp)
movq %rsp, %rdi
leaq 0x108(%rsp), %rsi
callq 0x6262
movss 0x600(%rsp), %xmm0
ucomiss 0xef91(%rip), %xmm0     # 0x14120
jbe 0x523a
cvtss2sd %xmm0, %xmm0
movq %rbp, %rdi
leaq 0x108(%rsp), %rsi
xorl %edx, %edx
callq 0x6c88
movss 0x600(%rsp), %xmm0
xorps 0xeeb5(%rip), %xmm0     # 0x14070
cvtss2sd %xmm0, %xmm0
movq %rbx, %rdi
movq %rbp, %rsi
xorl %edx, %edx
callq 0x6c88
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
movaps 0x50(%rsp), %xmm0
movaps %xmm0, (%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x50(%rsp)
movq $0x0, 0x60(%rsp)
testq %rdi, %rdi
je 0x521d
subq %rdi, %rsi
callq 0x3220
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x521d
movq 0x60(%rsp), %rsi
subq %rdi, %rsi
callq 0x3220
movq 0x290(%rsp), %rdi
testq %rdi, %rdi
je 0x523a
movq 0x2a0(%rsp), %rsi
subq %rdi, %rsi
callq 0x3220
movq (%r14), %rcx
movq %r14, %rdi
leaq 0xfaed(%rip), %rsi      # 0x14d34
xorl %eax, %eax
callq *0x18(%rcx)
movq (%r14), %rax
xorps %xmm0, %xmm0
xorpd %xmm2, %xmm2
movq %r14, %rdi
movss 0xeeab(%rip), %xmm1     # 0x1410c
callq *0x68(%rax)
cvttss2si 0x40(%rsp), %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
movss 0x20(%rsp), %xmm2
mulss %xmm2, %xmm0
movaps %xmm2, %xmm1
mulss 0xee86(%rip), %xmm1     # 0x1410c
movq %rsp, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x5fb3
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x52aa
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x3220
movss 0x500(%rsp), %xmm0
movss %xmm0, 0x20(%rsp)
movss 0x218(%rsp), %xmm0
movss %xmm0, 0x40(%rsp)
xorps %xmm0, %xmm0
cvtss2sd 0x7e8(%rsp), %xmm0
movsd %xmm0, 0x260(%rsp)
xorps %xmm0, %xmm0
cvtss2sd 0x7c0(%rsp), %xmm0
movaps %xmm0, 0x570(%rsp)
movss 0x838(%rsp), %xmm0
movss %xmm0, 0x3c(%rsp)
xorps %xmm0, %xmm0
cvtss2sd 0x770(%rsp), %xmm0
movsd %xmm0, 0x198(%rsp)
movss 0x5b0(%rsp), %xmm0
movss %xmm0, 0x30(%rsp)
movss 0x6f8(%rsp), %xmm0
movss %xmm0, 0xb0(%rsp)
movsd 0xc0(%rsp), %xmm0
movsd 0xc8(%rsp), %xmm1
movq (%r14), %rcx
movq %r14, %rdi
leaq 0xfa4e(%rip), %rsi      # 0x14da3
movb $0x2, %al
callq *0x18(%rcx)
movq (%r14), %rax
xorpd %xmm0, %xmm0
xorps %xmm1, %xmm1
xorpd %xmm2, %xmm2
movq %r14, %rdi
callq *0x68(%rax)
xorps %xmm1, %xmm1
cvtss2sd 0x20(%rsp), %xmm1
movapd 0x530(%rsp), %xmm0
movsd %xmm1, 0x148(%rsp)
mulsd %xmm1, %xmm0
addsd %xmm0, %xmm0
mulsd 0xed27(%rip), %xmm0     # 0x140c0
movsd %xmm0, 0x1a8(%rsp)
movq (%r14), %rax
movq %r14, %rdi
xorl %esi, %esi
callq *0x58(%rax)
xorpd %xmm0, %xmm0
movapd %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movss 0x40(%rsp), %xmm0
ucomiss 0xed54(%rip), %xmm0     # 0x14120
jbe 0x5ac8
cvtss2sd %xmm0, %xmm3
xorps %xmm1, %xmm1
cvtss2sd 0x3c(%rsp), %xmm1
movss 0xed25(%rip), %xmm0     # 0x1410c
movss 0x20(%rsp), %xmm4
mulss %xmm0, %xmm4
xorps %xmm2, %xmm2
cvtss2sd %xmm4, %xmm2
movsd %xmm2, 0x238(%rsp)
mulss %xmm0, %xmm4
xorps %xmm0, %xmm0
cvtss2sd %xmm4, %xmm0
movsd %xmm0, 0x280(%rsp)
xorps %xmm0, %xmm0
cvtss2sd 0xb0(%rsp), %xmm0
movsd %xmm0, 0x258(%rsp)
xorps %xmm0, %xmm0
cvtss2sd 0x30(%rsp), %xmm0
movsd %xmm0, 0x250(%rsp)
movaps %xmm3, %xmm0
addsd 0xec81(%rip), %xmm0     # 0x140c8
movsd %xmm0, 0x230(%rsp)
movaps %xmm1, 0x560(%rsp)
xorps 0xec21(%rip), %xmm1     # 0x14080
movaps %xmm1, 0x550(%rsp)
movsd 0x100(%rsp), %xmm2
movapd %xmm2, %xmm0
divsd 0xec54(%rip), %xmm0     # 0x140d0
movsd 0xec54(%rip), %xmm1     # 0x140d8
minsd %xmm0, %xmm1
movsd %xmm1, 0x240(%rsp)
movsd 0x148(%rsp), %xmm1
movapd %xmm1, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x158(%rsp)
movapd %xmm1, %xmm0
mulsd 0xec29(%rip), %xmm0     # 0x140e0
movsd %xmm0, 0x270(%rsp)
movsd 0xebd8(%rip), %xmm4     # 0x140a0
movsd 0x198(%rsp), %xmm0
subsd %xmm0, %xmm4
movsd %xmm4, 0x268(%rsp)
mulsd %xmm0, %xmm2
movsd %xmm2, 0x288(%rsp)
mulsd 0xebf5(%rip), %xmm1     # 0x140e8
movsd %xmm3, 0x248(%rsp)
addsd %xmm3, %xmm1
movsd %xmm1, 0x278(%rsp)
movl $0x0, 0xf4(%rsp)
xorpd %xmm1, %xmm1
xorpd %xmm0, %xmm0
movsd %xmm0, 0x150(%rsp)
xorl %r15d, %r15d
movsd %xmm0, 0x1b0(%rsp)
movsd %xmm0, 0x1a0(%rsp)
movsd %xmm1, 0x68(%rsp)
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
mulsd 0xeb9d(%rip), %xmm0     # 0x140f0
divsd 0xeb9d(%rip), %xmm0     # 0x140f8
callq 0x3090
mulsd 0x258(%rsp), %xmm0
addsd 0x250(%rsp), %xmm0
cvtsd2ss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm0
movq (%r14), %rax
movq %r14, %rdi
callq *0x20(%rax)
testl %r15d, %r15d
je 0x5677
cmpl $0x1, %r15d
je 0x5646
cmpl $0x2, %r15d
jne 0x576e
movss 0x3c(%rsp), %xmm0
ucomiss 0xeb73(%rip), %xmm0     # 0x14120
movl $0x2, %ebp
jbe 0x5711
movsd 0x68(%rsp), %xmm0
ucomisd 0x230(%rsp), %xmm0
jbe 0x5711
movq %rbx, %rdi
leaq 0x108(%rsp), %rsi
movaps 0x550(%rsp), %xmm0
xorl %edx, %edx
callq 0x6c88
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
movapd 0x50(%rsp), %xmm0
movapd %xmm0, (%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
xorpd %xmm0, %xmm0
movapd %xmm0, 0x50(%rsp)
movq $0x0, 0x60(%rsp)
testq %rdi, %rdi
je 0x563c
subq %rdi, %rsi
callq 0x3220
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x563c
movq 0x60(%rsp), %rsi
subq %rdi, %rsi
callq 0x3220
movl $0x3, %ebp
jmp 0x5711
movss 0x3c(%rsp), %xmm0
ucomiss 0xeacd(%rip), %xmm0     # 0x14120
movl $0x1, %ebp
jbe 0x5711
movsd 0x68(%rsp), %xmm0
ucomisd 0xea64(%rip), %xmm0     # 0x140d0
ja 0x56fc
jmp 0x5711
movss 0x3c(%rsp), %xmm0
ucomiss 0xea9c(%rip), %xmm0     # 0x14120
jbe 0x56fc
movq %rbx, %rdi
leaq 0x108(%rsp), %rsi
movaps 0x560(%rsp), %xmm0
xorl %edx, %edx
callq 0x6c88
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
movapd 0x50(%rsp), %xmm0
movapd %xmm0, (%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
xorpd %xmm0, %xmm0
movapd %xmm0, 0x50(%rsp)
movq $0x0, 0x60(%rsp)
testq %rdi, %rdi
je 0x56f5
subq %rdi, %rsi
callq 0x3220
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x56f5
movq 0x60(%rsp), %rsi
subq %rdi, %rsi
callq 0x3220
movl $0x1, %ebp
jmp 0x5711
movl $0x2, %ebp
movq %rsp, %rdi
leaq 0x108(%rsp), %rsi
callq 0x6334
cmpl %r15d, %ebp
je 0x576e
movq %rsp, %rdi
callq 0x38dc
movsd %xmm0, 0x1a0(%rsp)
movq (%r14), %rax
movq %r14, %rdi
movsd 0x240(%rsp), %xmm0
callq *0x28(%rax)
movq (%rsp), %rax
movupd (%rax), %xmm0
addpd 0xc0(%rsp), %xmm0
movapd %xmm0, 0x50(%rsp)
movsd 0x68(%rsp), %xmm0
addsd 0x238(%rsp), %xmm0
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x48(%rax)
movl %ebp, %r15d
movq (%rsp), %rbp
movq 0x8(%rsp), %rax
subq %rbp, %rax
shrq $0x4, %rax
testl %eax, %eax
jle 0x5a22
movl $0x8, %r12d
xorl %r13d, %r13d
testq %r13, %r13
je 0x57dc
movsd -0x8(%rbp,%r12), %xmm0
movapd %xmm0, 0xb0(%rsp)
subsd -0x18(%rbp,%r12), %xmm0
movsd (%rbp,%r12), %xmm1
subsd -0x10(%rbp,%r12), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
sqrtsd %xmm0, %xmm0
movsd 0x1b0(%rsp), %xmm1
addsd %xmm0, %xmm1
movapd %xmm1, %xmm0
jmp 0x57ee
movsd (%rbp), %xmm0
movapd %xmm0, 0xb0(%rsp)
xorpd %xmm0, %xmm0
movsd %xmm0, 0x1b0(%rsp)
divsd 0x1a0(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
mulsd 0x1a8(%rsp), %xmm0
addsd 0x150(%rsp), %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x40(%rsp)
callq 0x3180
movaps %xmm0, 0x120(%rsp)
movsd (%rbp,%r12), %xmm0
movaps %xmm0, 0x20(%rsp)
movss 0x40(%rsp), %xmm0
callq 0x31c0
movaps %xmm0, 0x180(%rsp)
movaps 0x20(%rsp), %xmm0
xorps 0xe826(%rip), %xmm0     # 0x14080
movaps %xmm0, 0x20(%rsp)
movaps 0xb0(%rsp), %xmm0
movhps (%rbp,%r12), %xmm0      # xmm0 = xmm0[0,1],mem[0,1]
movaps %xmm0, 0xb0(%rsp)
movss 0x40(%rsp), %xmm0
callq 0x3180
movaps %xmm0, 0x580(%rsp)
movaps 0x20(%rsp), %xmm0
movhps -0x8(%rbp,%r12), %xmm0  # xmm0 = xmm0[0,1],mem[0,1]
movaps %xmm0, 0x20(%rsp)
movss 0x40(%rsp), %xmm0
callq 0x31c0
movsd 0x30(%rsp), %xmm1
movaps %xmm0, 0x40(%rsp)
mulsd 0x148(%rsp), %xmm1
addsd 0x68(%rsp), %xmm1
movsd 0x158(%rsp), %xmm0
ucomisd %xmm1, %xmm0
movsd 0x288(%rsp), %xmm0
movsd %xmm1, 0x30(%rsp)
ja 0x592e
movsd 0x270(%rsp), %xmm0
ucomisd %xmm1, %xmm0
movsd 0x100(%rsp), %xmm0
jbe 0x592e
movapd %xmm1, %xmm0
movsd 0x158(%rsp), %xmm1
subsd %xmm1, %xmm0
divsd %xmm1, %xmm0
mulsd 0x268(%rsp), %xmm0
addsd 0x198(%rsp), %xmm0
mulsd 0x100(%rsp), %xmm0
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
jmp 0x5937
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
movaps 0x120(%rsp), %xmm0
unpcklps 0x580(%rsp), %xmm0      # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
cvtps2pd %xmm0, %xmm0
movapd 0xb0(%rsp), %xmm1
mulpd %xmm0, %xmm1
movaps 0x180(%rsp), %xmm0
unpcklps 0x40(%rsp), %xmm0       # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
cvtps2pd %xmm0, %xmm0
movapd 0x20(%rsp), %xmm2
mulpd %xmm0, %xmm2
addpd %xmm1, %xmm2
movsd 0x30(%rsp), %xmm3
ucomisd 0x280(%rsp), %xmm3
jbe 0x59e1
movsd 0x278(%rsp), %xmm0
ucomisd %xmm3, %xmm0
jbe 0x59e1
addpd 0xc0(%rsp), %xmm2
movapd %xmm2, 0x50(%rsp)
movapd %xmm3, %xmm1
cmpltsd 0x158(%rsp), %xmm1
movapd %xmm1, %xmm0
andpd 0x570(%rsp), %xmm0
movsd 0xe6d9(%rip), %xmm2     # 0x140a0
andnpd %xmm2, %xmm1
orpd %xmm0, %xmm1
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
movapd %xmm3, %xmm0
callq *0x50(%rax)
jmp 0x5a00
addpd 0xc0(%rsp), %xmm2
movapd %xmm2, 0x50(%rsp)
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
movapd %xmm3, %xmm0
callq *0x48(%rax)
incq %r13
movq (%rsp), %rbp
movq 0x8(%rsp), %rax
subq %rbp, %rax
shrq $0x4, %rax
cltq
addq $0x10, %r12
cmpq %rax, %r13
jl 0x578f
movsd 0x68(%rsp), %xmm0
ucomisd 0x260(%rsp), %xmm0
setbe %al
orb 0xf4(%rsp), %al
testb $0x1, %al
jne 0x5a56
movq (%r14), %rax
movb $0x1, %cl
movl %ecx, 0xf4(%rsp)
movq %r14, %rdi
movl $0x1, %esi
callq *0x58(%rax)
movsd 0x68(%rsp), %xmm1
addsd 0x148(%rsp), %xmm1
movsd 0x150(%rsp), %xmm0
addsd 0x1a8(%rsp), %xmm0
movsd %xmm0, 0x150(%rsp)
movsd 0x248(%rsp), %xmm0
ucomisd %xmm1, %xmm0
ja 0x553a
movq (%rsp), %rdi
testq %rdi, %rdi
leaq 0x168(%rsp), %r15
leaq 0xc0(%rsp), %r12
leaq 0xf24d(%rip), %r13      # 0x14cfe
leaq 0x290(%rsp), %rbp
je 0x5ac8
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x3220
movq (%r14), %rax
movq %r14, %rdi
callq *0x60(%rax)
movsd %xmm0, 0x20(%rsp)
xorps %xmm0, %xmm0
cvtss2sd 0x340(%rsp), %xmm0
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
movq (%r14), %rax
movq %r14, %rdi
callq *0x38(%rax)
movss 0x218(%rsp), %xmm0
addss 0xe612(%rip), %xmm0     # 0x14118
cvtss2sd %xmm0, %xmm0
movq (%r14), %rax
movq %r14, %rdi
callq *0x40(%rax)
cmpb $0x0, 0x318(%rsp)
jne 0x5b49
movapd 0x540(%rsp), %xmm1
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
addpd 0xc0(%rsp), %xmm1
movupd 0x4d0(%rsp), %xmm0
addpd %xmm1, %xmm0
movapd %xmm0, 0xc0(%rsp)
movsd 0xf8(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, 0xf8(%rsp)
divsd 0x100(%rsp), %xmm1
movsd 0x138(%rsp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x138(%rsp)
cmpb $0x0, 0x458(%rsp)
je 0x5be1
movq 0x108(%rsp), %rdi
testq %rdi, %rdi
je 0x5bab
movq 0x118(%rsp), %rsi
subq %rdi, %rsi
callq 0x3220
movq 0x140(%rsp), %rax
incl %eax
cmpl 0x390(%rsp), %eax
jl 0x4ebc
jmp 0x5c23
leaq 0x3d8(%rsp), %rdi
leaq 0x368(%rsp), %rsi
movss 0x20(%rsp), %xmm0
callq 0x3430
jmp 0x5b8e
movss 0x164(%rsp), %xmm0
addss %xmm0, %xmm0
movq 0x163e3(%rip), %rax     # 0x1bfd8
movq (%rax), %rdi
divss 0xe51c(%rip), %xmm0     # 0x1411c
xorps %xmm1, %xmm1
cvtss2sd %xmm0, %xmm1
leaq 0xf133(%rip), %rsi      # 0x14d41
movsd 0x228(%rsp), %xmm0
movb $0x2, %al
callq 0x32c0
jmp 0x5b8e
cvttsd2si 0x138(%rsp), %ebx
jmp 0x5c3c
xorl %ebx, %ebx
xorps %xmm0, %xmm0
movsd %xmm0, 0xf8(%rsp)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpb $0x0, 0x458(%rsp)
movsd 0x220(%rsp), %xmm0
je 0x5cbe
xorl %ebx, %ebx
movq 0x168(%rsp), %rdi
testq %rdi, %rdi
je 0x5c77
movq 0x178(%rsp), %rsi
subq %rdi, %rsi
callq 0x3220
movq 0xd0(%rsp), %rdi
testq %rdi, %rdi
je 0x5cdf
movq 0xe0(%rsp), %rsi
subq %rdi, %rsi
callq 0x3220
jmp 0x5cdf
callq 0x3502
jmp 0x5cd5
movss %xmm0, 0x180(%rsp)
jmp 0x4a5a
callq 0x34e0
jmp 0x5cb7
callq 0x34a9
movl $0x1, %ebx
jmp 0x5c5a
movl %ebx, %edi
movsd 0xf8(%rsp), %xmm1
callq 0x345d
jmp 0x5c58
callq 0x340e
movq (%rbx), %rdi
callq 0x3579
movl %eax, %ebx
leaq 0x15c92(%rip), %rax     # 0x1b978
movq %rax, 0x70(%rsp)
movq 0x90(%rsp), %rdi
leaq 0xa0(%rsp), %rax
cmpq %rax, %rdi
je 0x5d10
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0x3220
leaq 0x15c61(%rip), %rax     # 0x1b978
movq %rax, 0x1b8(%rsp)
movq 0x1d8(%rsp), %rdi
leaq 0x1e8(%rsp), %rax
cmpq %rax, %rdi
je 0x5d44
movq 0x1e8(%rsp), %rsi
incq %rsi
callq 0x3220
movl %ebx, %eax
addq $0x978, %rsp            # imm = 0x978
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x16279(%rip), %rax     # 0x1bfd8
movq (%rax), %rdi
xorps %xmm0, %xmm0
cvtss2sd 0x180(%rsp), %xmm0
movsd 0x2e8(%rsp), %xmm1
movsd 0x2f0(%rsp), %xmm2
movapd %xmm3, %xmm4
unpckhpd %xmm3, %xmm4            # xmm4 = xmm4[1],xmm3[1]
leaq 0xed02(%rip), %rsi      # 0x14a91
movl %r14d, %edx
movb $0x5, %al
movapd %xmm5, 0xb0(%rsp)
movapd %xmm6, 0x120(%rsp)
callq 0x32c0
movapd 0x120(%rsp), %xmm6
movapd 0xb0(%rsp), %xmm5
movl %r14d, 0x390(%rsp)
movupd 0x4d0(%rsp), %xmm3
jmp 0x4af8
jmp 0x5eb6
jmp 0x5eb6
jmp 0x5de3
jmp 0x5de3
jmp 0x5de3
movq %rax, %rbx
jmp 0x5f2b
jmp 0x5e4a
jmp 0x5eb6
jmp 0x5e4a
jmp 0x5e4a
jmp 0x5e4a
jmp 0x5e4a
jmp 0x5e4a
jmp 0x5e4a
jmp 0x5e4a
jmp 0x5e4a
jmp 0x5e4a
jmp 0x5e4a
jmp 0x5e4a
jmp 0x5e4a
jmp 0x5e4a
jmp 0x5e4a
jmp 0x5e4a
jmp 0x5e4a
jmp 0x5e4a
jmp 0x5e4a
jmp 0x5e4a
jmp 0x5e4a
jmp 0x5e4a
jmp 0x5e4a
jmp 0x5e4a
jmp 0x5e4a
jmp 0x5e4a
jmp 0x5e4a
jmp 0x5e4a
jmp 0x5e4a
jmp 0x5e4a
jmp 0x5e4a
jmp 0x5e4a
jmp 0x5e4a
jmp 0x5e4a
jmp 0x5e4a
jmp 0x5e4a
jmp 0x5e4a
jmp 0x5e4a
jmp 0x5e42
jmp 0x5e42
jmp 0x5e42
movq %rax, %rbx
jmp 0x5f79
movq %rax, %rbx
jmp 0x5f48
movq %rax, %rbx
movq 0x290(%rsp), %rdi
testq %rdi, %rdi
je 0x5edb
movq 0x2a0(%rsp), %rsi
subq %rdi, %rsi
callq 0x3220
jmp 0x5edb
jmp 0x5ed8
movq %rax, %rbx
movq 0x2a8(%rsp), %rdi
cmpq %r13, %rdi
je 0x5f79
movq 0x2b8(%rsp), %rsi
jmp 0x5f71
movq %rax, %rbx
movq 0x398(%rsp), %rdi
cmpq %r14, %rdi
jne 0x5fa0
jmp 0x5fab
jmp 0x5ec7
jmp 0x5eb6
jmp 0x5ec7
movq %rax, %rbx
jmp 0x5f0e
jmp 0x5ed8
jmp 0x5ed8
jmp 0x5ed8
jmp 0x5ec7
jmp 0x5ec7
jmp 0x5ec7
movq %rax, %rbx
jmp 0x5ef1
jmp 0x5ed8
jmp 0x5ed8
jmp 0x5ed8
jmp 0x5ed8
jmp 0x5ed8
jmp 0x5ed8
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x5ef1
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x3220
movq 0x108(%rsp), %rdi
testq %rdi, %rdi
je 0x5f0e
movq 0x118(%rsp), %rsi
subq %rdi, %rsi
callq 0x3220
movq 0x168(%rsp), %rdi
testq %rdi, %rdi
je 0x5f2b
movq 0x178(%rsp), %rsi
subq %rdi, %rsi
callq 0x3220
movq 0xd0(%rsp), %rdi
testq %rdi, %rdi
je 0x5f48
movq 0xe0(%rsp), %rsi
subq %rdi, %rsi
callq 0x3220
leaq 0xa0(%rsp), %rcx
leaq 0x15a21(%rip), %rax     # 0x1b978
movq %rax, 0x70(%rsp)
movq 0x90(%rsp), %rdi
cmpq %rcx, %rdi
je 0x5f79
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0x3220
leaq 0x1e8(%rsp), %rax
leaq 0x159f0(%rip), %rcx     # 0x1b978
movq %rcx, 0x1b8(%rsp)
movq 0x1d8(%rsp), %rdi
movq %rax, %r14
cmpq %rax, %rdi
je 0x5fab
movq (%r14), %rsi
incq %rsi
callq 0x3220
movq %rbx, %rdi
callq 0x3380