#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double fabs(double);
double sqrt(double);
void compute_color_vr(int current_ijk[3], int color_mapping_style,
                      double *interval_point, int transfer_function_style,
                      double opa_value, int num_of_features, double *fea_point,
                      double view_point_d[3], int interval_mapping_num,
                      int color_system_type, int num_of_lights,
                      double *light_point, double k_ads[3], int r_level[3],
                      double orig_xyz[3], double r_dxyz[3], double *var,
                      double *grad_var, double accum_rgba[4], double mincolor,
                      double maxcolor, double grad_minmax[2],
                      double feap_minmax[2], double feai_minmax[2],
                      double dis_minmax[2], double *opa_table,
                      double in_point[3], double out_point[3],
                      double tav_length, int time_step, int print_flag) {
  int i, j, k;
  double a_current;
  double color[3];
  double value;
  double length, coff_i;
  int index;
  int m;
  double value2[8], vv[8 * 3], v;
  double dis[8], d;
  int return_flag;
  double t;
  double r, g, b;
  length = sqrt((out_point[0] - in_point[0]) * (out_point[0] - in_point[0]) +
                (out_point[1] - in_point[1]) * (out_point[1] - in_point[1]) +
                (out_point[2] - in_point[2]) * (out_point[2] - in_point[2]));
  coff_i = length / tav_length;
  index = current_ijk[2] * r_level[0] * r_level[1] +
          current_ijk[1] * r_level[0] + current_ijk[0];
  return_flag = 0;
  vv[0 * 3] = vv[4 * 3] = vv[7 * 3] = vv[3 * 3] =
      orig_xyz[0] + current_ijk[0] * r_dxyz[0];
  vv[1 * 3] = vv[5 * 3] = vv[6 * 3] = vv[2 * 3] =
      orig_xyz[0] + (current_ijk[0] + 1) * r_dxyz[0];
  vv[0 * 3 + 2] = vv[1 * 3 + 2] = vv[2 * 3 + 2] = vv[3 * 3 + 2] =
      orig_xyz[2] + current_ijk[2] * r_dxyz[2];
  vv[4 * 3 + 2] = vv[5 * 3 + 2] = vv[6 * 3 + 2] = vv[7 * 3 + 2] =
      orig_xyz[2] + (current_ijk[2] + 1) * r_dxyz[2];
  vv[0 * 3 + 1] = vv[1 * 3 + 1] = vv[5 * 3 + 1] = vv[4 * 3 + 1] =
      orig_xyz[1] + current_ijk[1] * r_dxyz[1];
  vv[3 * 3 + 1] = vv[2 * 3 + 1] = vv[6 * 3 + 1] = vv[7 * 3 + 1] =
      orig_xyz[1] + (current_ijk[1] + 1) * r_dxyz[1];
  for (m = 0; m < 8; m++) {
    i = m % 2;
    j = (m / 2) % 2;
    k = (m / 2) / 2;
    index = (current_ijk[2] + k) * (r_level[0] + 1) * (r_level[1] + 1) +
            (current_ijk[1] + j) * (r_level[0] + 1) + current_ijk[0] + i;
    value2[k * 4 + j * 2 + i] = var[index];
  }
  for (i = 0; i < 8; i++) {
    dis[i] =
        sqrt((in_point[0] - vv[i * 3]) * (in_point[0] - vv[i * 3]) +
             (in_point[1] - vv[i * 3 + 1]) * (in_point[1] - vv[i * 3 + 1]) +
             (in_point[2] - vv[i * 3 + 2]) * (in_point[2] - vv[i * 3 + 2]));
  }
  d = 0.0;
  for (i = 0; i < 8; i++)
    d += 1.0 / (dis[i] + 0.00000001);
  v = 0.0;
  for (i = 0; i < 8; i++) {
    v += value2[i] / ((dis[i] + 0.00000001) * d);
  }
  value = v;
  a_current = opa_value;
  if (transfer_function_style == 3) {
    a_current = opa_value;
    for (i = 0; i < num_of_features; i++) {
      t = fabs(value - fea_point[i * 3]);
      if (t < fea_point[i * 3 + 1])
        a_current += fea_point[i * 3 + 2] * (fea_point[i * 3 + 1] - t) /
                     fea_point[i * 3 + 1];
    }
  }
  if (transfer_function_style == 4) {
    a_current = opa_value;
    for (i = 0; i < num_of_features; i++) {
      if ((value >= fea_point[i * 3]) && (value <= fea_point[i * 3 + 1])) {
        a_current = fea_point[i * 3 + 2];
      }
    }
  }
  if (color_mapping_style == 1) {
    if (fabs(maxcolor - mincolor) > 0.00000001)
      value = (value - mincolor) / (maxcolor - mincolor);
  }
  if (color_mapping_style == 2) {
    mincolor = interval_point[0];
    maxcolor = interval_point[1];
    if (fabs(maxcolor - mincolor) > 0.00000001)
      value = (value - mincolor) / (maxcolor - mincolor);
  }
  if (color_mapping_style == 3) {
    if (value < interval_point[0])
      value = 0.0;
    else if (value > interval_point[interval_mapping_num * 2])
      value = 1.0;
    else {
      for (i = 1; i < interval_mapping_num + 1; i++) {
        if ((value <= interval_point[i * 2]) &&
            (value > interval_point[(i - 1) * 2])) {
          value = (value - interval_point[(i - 1) * 2]) /
                      (interval_point[i * 2] - interval_point[(i - 1) * 2]) *
                      (interval_point[i * 2 + 1] -
                       interval_point[(i - 1) * 2 + 1]) +
                  interval_point[(i - 1) * 2 + 1];
          break;
        }
      }
    }
  }
  if (color_system_type == 1) {
    if (value < 0.0)
      value = 0.0;
    if (value > 1.0)
      value = 1.0;
    if (value <= 0.25) {
      r = 0.0;
      g = value * 4.0;
      b = 1.0;
    } else if ((value > 0.25) && (value <= 0.5)) {
      r = 0.0;
      g = 1.0;
      b = (0.5 - value) * 4.0;
    } else if ((value > 0.5) && (value <= 0.75)) {
      r = (value - 0.5) * 4.0;
      g = 1.0;
      b = 0.0;
    } else if (value > 0.75) {
      r = 1.0;
      g = (1.0 - value) * 4.0;
      b = 0.0;
    }
  } else if (color_system_type == 2) {
    if (value < 0.0)
      value = 0.0;
    if (value > 1.0)
      value = 1.0;
    if (value <= 0.2) {
      g = 0.0;
      b = 1.0;
      r = (0.2 - value) * 5.0;
    } else if ((value > 0.2) && (value <= 0.4)) {
      r = 0.0;
      b = 1.0;
      g = (value - 0.2) * 5.0;
    } else if ((value > 0.4) && (value <= 0.6)) {
      r = 0.0;
      g = 1.0;
      b = 1.0 - (value - 0.4) * 5.0;
    } else if ((value > 0.6) && (value <= 0.8)) {
      r = (value - 0.6) * 5.0;
      g = 1.0;
      b = 0.0;
    } else if (value > 0.0) {
      r = 1.0;
      g = 1.0 - (value - 0.8) * 5.0;
      b = 0.0;
    }
  } else if (color_system_type == 3) {
    r = g = b = value;
  }
  color[0] = r;
  color[1] = g;
  color[2] = b;
  r = 0.0;
  g = 0.0;
  b = 0.0;
  r += color[0] * k_ads[0] * coff_i;
  g += color[1] * k_ads[0] * coff_i;
  b += color[2] * k_ads[0] * coff_i;
  r *= a_current;
  g *= a_current;
  b *= a_current;
  if (accum_rgba[3] < 0.99) {
    accum_rgba[0] += r * (1.0 - accum_rgba[3]);
    accum_rgba[1] += g * (1.0 - accum_rgba[3]);
    accum_rgba[2] += b * (1.0 - accum_rgba[3]);
    accum_rgba[3] += a_current * (1.0 - accum_rgba[3]) * coff_i;
  }
  return;
}


x86 assembly (clang, -O0):
<compute_color_vr>:
push   %rbp
mov    %rsp,%rbp
sub    $0x220,%rsp
mov    0xb0(%rbp),%eax
mov    0xa8(%rbp),%eax
mov    0xa0(%rbp),%rax
mov    0x98(%rbp),%rax
mov    0x90(%rbp),%rax
mov    0x88(%rbp),%rax
mov    0x80(%rbp),%rax
mov    0x78(%rbp),%rax
mov    0x70(%rbp),%rax
mov    0x68(%rbp),%rax
mov    0x60(%rbp),%rax
mov    0x58(%rbp),%rax
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
movsd  %xmm0,-0x28(%rbp)
mov    %r8d,-0x2c(%rbp)
mov    %r9,-0x38(%rbp)
movsd  %xmm1,-0x40(%rbp)
movsd  %xmm2,-0x48(%rbp)
movsd  %xmm3,-0x50(%rbp)
mov    0xa0(%rbp),%rax
movsd  (%rax),%xmm1
mov    0x98(%rbp),%rax
subsd  (%rax),%xmm1
mov    0xa0(%rbp),%rax
movsd  (%rax),%xmm2
mov    0x98(%rbp),%rax
subsd  (%rax),%xmm2
mov    0xa0(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    0x98(%rbp),%rax
subsd  0x8(%rax),%xmm0
mov    0xa0(%rbp),%rax
movsd  0x8(%rax),%xmm3
mov    0x98(%rbp),%rax
subsd  0x8(%rax),%xmm3
mulsd  %xmm3,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    0xa0(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    0x98(%rbp),%rax
subsd  0x10(%rax),%xmm0
mov    0xa0(%rbp),%rax
movsd  0x10(%rax),%xmm2
mov    0x98(%rbp),%rax
subsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1030 <sqrt@plt>
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
divsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%eax
mov    0x40(%rbp),%rcx
imul   (%rcx),%eax
mov    0x40(%rbp),%rcx
imul   0x4(%rcx),%eax
mov    -0x8(%rbp),%rcx
mov    0x4(%rcx),%ecx
mov    0x40(%rbp),%rdx
imul   (%rdx),%ecx
add    %ecx,%eax
mov    -0x8(%rbp),%rcx
add    (%rcx),%eax
mov    %eax,-0x9c(%rbp)
movl   $0x0,-0x1fc(%rbp)
mov    0x48(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x8(%rbp),%rax
cvtsi2sdl (%rax),%xmm0
mov    0x50(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x158(%rbp)
ff
movsd  %xmm0,-0xf8(%rbp)
ff
movsd  %xmm0,-0x140(%rbp)
ff
movsd  %xmm0,-0x1a0(%rbp)
ff
mov    0x48(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
add    $0x1,%eax
cvtsi2sd %eax,%xmm0
mov    0x50(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x170(%rbp)
ff
movsd  %xmm0,-0x110(%rbp)
ff
movsd  %xmm0,-0x128(%rbp)
ff
movsd  %xmm0,-0x188(%rbp)
ff
mov    0x48(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x8(%rbp),%rax
cvtsi2sdl 0x8(%rax),%xmm0
mov    0x50(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
movsd  %xmm0,-0x160(%rbp)
ff
movsd  %xmm0,-0x178(%rbp)
ff
movsd  %xmm0,-0x190(%rbp)
ff
mov    0x48(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%eax
add    $0x1,%eax
cvtsi2sd %eax,%xmm0
mov    0x50(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  %xmm0,-0x100(%rbp)
ff
movsd  %xmm0,-0x118(%rbp)
ff
movsd  %xmm0,-0x130(%rbp)
ff
mov    0x48(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x8(%rbp),%rax
cvtsi2sdl 0x4(%rax),%xmm0
mov    0x50(%rbp),%rax
movsd  0x8(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  %xmm0,-0x120(%rbp)
ff
movsd  %xmm0,-0x180(%rbp)
ff
movsd  %xmm0,-0x198(%rbp)
ff
mov    0x48(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x8(%rbp),%rax
mov    0x4(%rax),%eax
add    $0x1,%eax
cvtsi2sd %eax,%xmm0
mov    0x50(%rbp),%rax
movsd  0x8(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  %xmm0,-0x108(%rbp)
ff
movsd  %xmm0,-0x168(%rbp)
ff
movsd  %xmm0,-0x150(%rbp)
ff
movl   $0x0,-0xa0(%rbp)
cmpl   $0x8,-0xa0(%rbp)
jge    1526 <compute_color_vr+0x416>
mov    -0xa0(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %edx,-0x54(%rbp)
mov    -0xa0(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %edx,-0x58(%rbp)
mov    -0xa0(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x5c(%rbp)
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%eax
add    -0x5c(%rbp),%eax
mov    0x40(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    0x40(%rbp),%rcx
mov    0x4(%rcx),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    -0x8(%rbp),%rcx
mov    0x4(%rcx),%ecx
add    -0x58(%rbp),%ecx
mov    0x40(%rbp),%rdx
mov    (%rdx),%edx
add    $0x1,%edx
imul   %edx,%ecx
add    %ecx,%eax
mov    -0x8(%rbp),%rcx
add    (%rcx),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x9c(%rbp)
mov    0x58(%rbp),%rax
movslq -0x9c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x5c(%rbp),%eax
shl    $0x2,%eax
mov    -0x58(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
add    -0x54(%rbp),%eax
cltq
movsd  %xmm0,-0xe0(%rbp,%rax,8)
ff ff
mov    -0xa0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa0(%rbp)
jmp    144c <compute_color_vr+0x33c>
movl   $0x0,-0x54(%rbp)
cmpl   $0x8,-0x54(%rbp)
jge    1617 <compute_color_vr+0x507>
mov    0x98(%rbp),%rax
movsd  (%rax),%xmm1
imul   $0x3,-0x54(%rbp),%eax
cltq
subsd  -0x1a0(%rbp,%rax,8),%xmm1
ff ff
mov    0x98(%rbp),%rax
movsd  (%rax),%xmm2
imul   $0x3,-0x54(%rbp),%eax
cltq
subsd  -0x1a0(%rbp,%rax,8),%xmm2
ff ff
mov    0x98(%rbp),%rax
movsd  0x8(%rax),%xmm0
imul   $0x3,-0x54(%rbp),%eax
add    $0x1,%eax
cltq
subsd  -0x1a0(%rbp,%rax,8),%xmm0
ff ff
mov    0x98(%rbp),%rax
movsd  0x8(%rax),%xmm3
imul   $0x3,-0x54(%rbp),%eax
add    $0x1,%eax
cltq
subsd  -0x1a0(%rbp,%rax,8),%xmm3
ff ff
mulsd  %xmm3,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    0x98(%rbp),%rax
movsd  0x10(%rax),%xmm0
imul   $0x3,-0x54(%rbp),%eax
add    $0x2,%eax
cltq
subsd  -0x1a0(%rbp,%rax,8),%xmm0
ff ff
mov    0x98(%rbp),%rax
movsd  0x10(%rax),%xmm2
imul   $0x3,-0x54(%rbp),%eax
add    $0x2,%eax
cltq
subsd  -0x1a0(%rbp,%rax,8),%xmm2
ff ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1030 <sqrt@plt>
movslq -0x54(%rbp),%rax
movsd  %xmm0,-0x1f0(%rbp,%rax,8)
ff ff
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    152d <compute_color_vr+0x41d>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f8(%rbp)
ff
movl   $0x0,-0x54(%rbp)
cmpl   $0x8,-0x54(%rbp)
jge    1672 <compute_color_vr+0x562>
movslq -0x54(%rbp),%rax
movsd  0x19c1(%rip),%xmm1
addsd  -0x1f0(%rbp,%rax,8),%xmm1
ff ff
movsd  0x19b8(%rip),%xmm0
divsd  %xmm1,%xmm0
addsd  -0x1f8(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f8(%rbp)
ff
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1629 <compute_color_vr+0x519>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1a8(%rbp)
ff
movl   $0x0,-0x54(%rbp)
cmpl   $0x8,-0x54(%rbp)
jge    16da <compute_color_vr+0x5ca>
movslq -0x54(%rbp),%rax
movsd  -0xe0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x54(%rbp),%rax
movsd  0x1959(%rip),%xmm1
addsd  -0x1f0(%rbp,%rax,8),%xmm1
ff ff
mulsd  -0x1f8(%rbp),%xmm1
ff
divsd  %xmm1,%xmm0
addsd  -0x1a8(%rbp),%xmm0
ff
movsd  %xmm0,-0x1a8(%rbp)
ff
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1684 <compute_color_vr+0x574>
movsd  -0x1a8(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
cmpl   $0x3,-0x1c(%rbp)
jne    17d2 <compute_color_vr+0x6c2>
movsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    17cd <compute_color_vr+0x6bd>
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x38(%rbp),%rax
imul   $0x3,-0x54(%rbp),%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movaps 0x1926(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x208(%rbp)
ff
movsd  -0x208(%rbp),%xmm1
ff
mov    -0x38(%rbp),%rax
imul   $0x3,-0x54(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    17ba <compute_color_vr+0x6aa>
mov    -0x38(%rbp),%rax
imul   $0x3,-0x54(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
imul   $0x3,-0x54(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
subsd  -0x208(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
imul   $0x3,-0x54(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
addsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
jmp    17bf <compute_color_vr+0x6af>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    170f <compute_color_vr+0x5ff>
jmp    17d2 <compute_color_vr+0x6c2>
cmpl   $0x4,-0x1c(%rbp)
jne    186c <compute_color_vr+0x75c>
movsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1867 <compute_color_vr+0x757>
movsd  -0x88(%rbp),%xmm0
mov    -0x38(%rbp),%rax
imul   $0x3,-0x54(%rbp),%ecx
movslq %ecx,%rcx
ucomisd (%rax,%rcx,8),%xmm0
jb     1854 <compute_color_vr+0x744>
movsd  -0x88(%rbp),%xmm1
ff
mov    -0x38(%rbp),%rax
imul   $0x3,-0x54(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jb     1854 <compute_color_vr+0x744>
mov    -0x38(%rbp),%rax
imul   $0x3,-0x54(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
jmp    1859 <compute_color_vr+0x749>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    17ed <compute_color_vr+0x6dd>
jmp    186c <compute_color_vr+0x75c>
cmpl   $0x1,-0xc(%rbp)
jne    18c5 <compute_color_vr+0x7b5>
movsd  -0x48(%rbp),%xmm0
subsd  -0x40(%rbp),%xmm0
movaps 0x17d9(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  0x176d(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    18c0 <compute_color_vr+0x7b0>
movsd  -0x88(%rbp),%xmm0
ff
subsd  -0x40(%rbp),%xmm0
movsd  -0x48(%rbp),%xmm1
subsd  -0x40(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
jmp    18c5 <compute_color_vr+0x7b5>
cmpl   $0x2,-0xc(%rbp)
jne    1939 <compute_color_vr+0x829>
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm0
subsd  -0x40(%rbp),%xmm0
movaps 0x1765(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  0x16f9(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1934 <compute_color_vr+0x824>
movsd  -0x88(%rbp),%xmm0
ff
subsd  -0x40(%rbp),%xmm0
movsd  -0x48(%rbp),%xmm1
subsd  -0x40(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
jmp    1939 <compute_color_vr+0x829>
cmpl   $0x3,-0xc(%rbp)
jne    1ac5 <compute_color_vr+0x9b5>
movsd  -0x88(%rbp),%xmm1
ff
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
ucomisd %xmm1,%xmm0
jbe    196d <compute_color_vr+0x85d>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
jmp    1ac0 <compute_color_vr+0x9b0>
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    0x18(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
ucomisd (%rax,%rcx,8),%xmm0
jbe    19a2 <compute_color_vr+0x892>
movsd  0x1673(%rip),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
jmp    1abb <compute_color_vr+0x9ab>
movl   $0x1,-0x54(%rbp)
mov    -0x54(%rbp),%eax
mov    0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1ab6 <compute_color_vr+0x9a6>
movsd  -0x88(%rbp),%xmm1
ff
mov    -0x18(%rbp),%rax
mov    -0x54(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jb     1aa3 <compute_color_vr+0x993>
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x54(%rbp),%ecx
sub    $0x1,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
ucomisd (%rax,%rcx,8),%xmm0
jbe    1aa3 <compute_color_vr+0x993>
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x54(%rbp),%ecx
sub    $0x1,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x54(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x54(%rbp),%ecx
sub    $0x1,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm1
divsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x54(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x18(%rbp),%rax
mov    -0x54(%rbp),%ecx
sub    $0x1,%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm2
mov    -0x18(%rbp),%rax
mov    -0x54(%rbp),%ecx
sub    $0x1,%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
jmp    1ab6 <compute_color_vr+0x9a6>
jmp    1aa8 <compute_color_vr+0x998>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    19a9 <compute_color_vr+0x899>
jmp    1abb <compute_color_vr+0x9ab>
jmp    1ac0 <compute_color_vr+0x9b0>
jmp    1ac5 <compute_color_vr+0x9b5>
cmpl   $0x1,0x20(%rbp)
jne    1cbc <compute_color_vr+0xbac>
xorps  %xmm0,%xmm0
ucomisd -0x88(%rbp),%xmm0
ff
jbe    1aeb <compute_color_vr+0x9db>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
movsd  0x150d(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1b15 <compute_color_vr+0xa05>
movsd  0x14fb(%rip),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  0x151b(%rip),%xmm0
ucomisd -0x88(%rbp),%xmm0
ff
jb     1b63 <compute_color_vr+0xa53>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x210(%rbp)
ff
movsd  0x1512(%rip),%xmm0
mulsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x218(%rbp)
ff
movsd  0x14b2(%rip),%xmm0
movsd  %xmm0,-0x220(%rbp)
ff
jmp    1cb7 <compute_color_vr+0xba7>
movsd  -0x88(%rbp),%xmm0
ff
movsd  0x14c5(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1bd7 <compute_color_vr+0xac7>
movsd  0x14bb(%rip),%xmm0
ucomisd -0x88(%rbp),%xmm0
ff
jb     1bd7 <compute_color_vr+0xac7>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x210(%rbp)
ff
movsd  0x1462(%rip),%xmm0
movsd  %xmm0,-0x218(%rbp)
ff
movsd  0x148a(%rip),%xmm0
subsd  -0x88(%rbp),%xmm0
ff
movsd  0x148a(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x220(%rbp)
ff
jmp    1cb2 <compute_color_vr+0xba2>
movsd  -0x88(%rbp),%xmm0
ff
movsd  0x1459(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1c4f <compute_color_vr+0xb3f>
movsd  0x144f(%rip),%xmm0
ucomisd -0x88(%rbp),%xmm0
jb     1c4f <compute_color_vr+0xb3f>
movsd  -0x88(%rbp),%xmm0
ff
movsd  0x1429(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  0x142d(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x210(%rbp)
ff
movsd  0x13d1(%rip),%xmm0
movsd  %xmm0,-0x218(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x220(%rbp)
ff
jmp    1cad <compute_color_vr+0xb9d>
movsd  -0x88(%rbp),%xmm0
ff
movsd  0x13e9(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1ca8 <compute_color_vr+0xb98>
movsd  0x1397(%rip),%xmm0
movsd  %xmm0,-0x210(%rbp)
ff
movsd  0x1387(%rip),%xmm0
subsd  -0x88(%rbp),%xmm0
ff
movsd  0x13bf(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x218(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x220(%rbp)
ff
jmp    1cad <compute_color_vr+0xb9d>
jmp    1cb2 <compute_color_vr+0xba2>
jmp    1cb7 <compute_color_vr+0xba7>
jmp    1fb9 <compute_color_vr+0xea9>
cmpl   $0x2,0x20(%rbp)
jne    1f85 <compute_color_vr+0xe75>
xorps  %xmm0,%xmm0
ucomisd -0x88(%rbp),%xmm0
ff
jbe    1ce2 <compute_color_vr+0xbd2>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
movsd  0x1316(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1d0c <compute_color_vr+0xbfc>
movsd  0x1304(%rip),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  0x12fc(%rip),%xmm0
ucomisd -0x88(%rbp),%xmm0
ff
jb     1d66 <compute_color_vr+0xc56>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x218(%rbp)
ff
movsd  0x12d3(%rip),%xmm0
movsd  %xmm0,-0x220(%rbp)
ff
movsd  0x12cb(%rip),%xmm0
subsd  -0x88(%rbp),%xmm0
ff
movsd  0x12db(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x210(%rbp)
ff
jmp    1f80 <compute_color_vr+0xe70>
movsd  -0x88(%rbp),%xmm0
ff
movsd  0x129a(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1dde <compute_color_vr+0xcce>
movsd  0x1290(%rip),%xmm0
ucomisd -0x88(%rbp),%xmm0
ff
jb     1dde <compute_color_vr+0xcce>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x210(%rbp)
ff
movsd  0x125f(%rip),%xmm0
movsd  %xmm0,-0x220(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
movsd  0x124f(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  0x1263(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x218(%rbp)
ff
jmp    1f7b <compute_color_vr+0xe6b>
movsd  -0x88(%rbp),%xmm0
ff
movsd  0x122a(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1e79 <compute_color_vr+0xd69>
movsd  0x1220(%rip),%xmm0
ucomisd -0x88(%rbp),%xmm0
ff
jb     1e79 <compute_color_vr+0xd69>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x210(%rbp)
ff
movsd  0x11e7(%rip),%xmm0
movsd  %xmm0,-0x218(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
movsd  0x11df(%rip),%xmm1
subsd  %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x11d4(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0x11a0(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x220(%rbp)
ff
jmp    1f76 <compute_color_vr+0xe66>
movsd  -0x88(%rbp),%xmm0
ff
movsd  0x1197(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1ef1 <compute_color_vr+0xde1>
movsd  0x118d(%rip),%xmm0
ucomisd -0x88(%rbp),%xmm0
ff
jb     1ef1 <compute_color_vr+0xde1>
movsd  -0x88(%rbp),%xmm0
ff
movsd  0x1167(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  0x116b(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x210(%rbp)
ff
movsd  0x112f(%rip),%xmm0
movsd  %xmm0,-0x218(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x220(%rbp)
ff
jmp    1f71 <compute_color_vr+0xe61>
movsd  -0x88(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1f6c <compute_color_vr+0xe5c>
movsd  0x10fa(%rip),%xmm0
movsd  %xmm0,-0x210(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
movsd  0x1102(%rip),%xmm1
subsd  %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x10e7(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0x10b3(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x218(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x220(%rbp)
ff
jmp    1f71 <compute_color_vr+0xe61>
jmp    1f76 <compute_color_vr+0xe66>
jmp    1f7b <compute_color_vr+0xe6b>
jmp    1f80 <compute_color_vr+0xe70>
jmp    1fb4 <compute_color_vr+0xea4>
cmpl   $0x3,0x20(%rbp)
jne    1faf <compute_color_vr+0xe9f>
movsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x220(%rbp)
ff
movsd  %xmm0,-0x218(%rbp)
ff
movsd  %xmm0,-0x210(%rbp)
ff
jmp    1fb4 <compute_color_vr+0xea4>
jmp    1fb9 <compute_color_vr+0xea9>
movsd  -0x210(%rbp),%xmm0
ff
movsd  %xmm0,-0x80(%rbp)
movsd  -0x218(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
movsd  -0x220(%rbp),%xmm0
ff
movsd  %xmm0,-0x70(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x210(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x218(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x220(%rbp)
movsd  -0x80(%rbp),%xmm0
mov    0x38(%rbp),%rax
mulsd  (%rax),%xmm0
movsd  -0x98(%rbp),%xmm2
ff
movsd  -0x210(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x210(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
mov    0x38(%rbp),%rax
mulsd  (%rax),%xmm0
movsd  -0x98(%rbp),%xmm2
ff
movsd  -0x218(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x218(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
mov    0x38(%rbp),%rax
mulsd  (%rax),%xmm0
movsd  -0x98(%rbp),%xmm2
ff
movsd  -0x220(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x220(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
mulsd  -0x210(%rbp),%xmm0
ff
movsd  %xmm0,-0x210(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
mulsd  -0x218(%rbp),%xmm0
ff
movsd  %xmm0,-0x218(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
mulsd  -0x220(%rbp),%xmm0
ff
movsd  %xmm0,-0x220(%rbp)
ff
mov    0x68(%rbp),%rax
movsd  0xf85(%rip),%xmm0
ucomisd 0x18(%rax),%xmm0
jbe    21a1 <compute_color_vr+0x1091>
movsd  -0x210(%rbp),%xmm0
ff
mov    0x68(%rbp),%rax
movsd  0xf16(%rip),%xmm2
subsd  0x18(%rax),%xmm2
mov    0x68(%rbp),%rax
movsd  (%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
movsd  -0x218(%rbp),%xmm0
ff
mov    0x68(%rbp),%rax
movsd  0xee9(%rip),%xmm2
subsd  0x18(%rax),%xmm2
mov    0x68(%rbp),%rax
movsd  0x8(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%rax)
movsd  -0x220(%rbp),%xmm0
ff
mov    0x68(%rbp),%rax
movsd  0xeba(%rip),%xmm2
subsd  0x18(%rax),%xmm2
mov    0x68(%rbp),%rax
movsd  0x10(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x10(%rax)
movsd  -0x68(%rbp),%xmm0
mov    0x68(%rbp),%rax
movsd  0xe8e(%rip),%xmm1
subsd  0x18(%rax),%xmm1
mulsd  %xmm1,%xmm0
movsd  -0x98(%rbp),%xmm2
ff
mov    0x68(%rbp),%rax
movsd  0x18(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x18(%rax)
add    $0x220,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<compute_color_vr>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xe8,%rsp
mov    %r9,%r15
movaps %xmm0,%xmm5
mov    %rdx,0x50(%rsp)
mov    %rdi,%rbp
mov    0x1a8(%rsp),%r14
mov    0x168(%rsp),%r9
mov    0x160(%rsp),%rbx
mov    0x158(%rsp),%r12
mov    0x1b0(%rsp),%rax
movsd  (%rax),%xmm4
movsd  0x8(%rax),%xmm0
subsd  (%r14),%xmm4
subsd  0x8(%r14),%xmm0
mov    0x150(%rsp),%rdi
mulsd  %xmm0,%xmm0
mulsd  %xmm4,%xmm4
addsd  %xmm0,%xmm4
movsd  0x10(%rax),%xmm0
subsd  0x10(%r14),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm4,%xmm0
xorpd  %xmm7,%xmm7
ucomisd %xmm7,%xmm0
movsd  %xmm3,0x98(%rsp)
movaps %xmm2,0xd0(%rsp)
movsd  %xmm1,0x90(%rsp)
mov    %esi,0x44(%rsp)
movsd  %xmm5,0xb8(%rsp)
mov    %r8d,0x40(%rsp)
mov    %ecx,0x3c(%rsp)
jb     11d2 <compute_color_vr+0xc2>
sqrtsd %xmm0,%xmm0
jmp    11e9 <compute_color_vr+0xd9>
mov    %r9,%r13
call   1030 <sqrt@plt>
mov    0x150(%rsp),%rdi
xorpd  %xmm7,%xmm7
mov    %r13,%r9
movapd %xmm0,0xc0(%rsp)
mov    0x0(%rbp),%eax
mov    0x4(%rbp),%ecx
xorps  %xmm3,%xmm3
cvtsi2sd %eax,%xmm3
movsd  (%rbx),%xmm0
movsd  0x8(%rbx),%xmm1
mulsd  %xmm0,%xmm3
movsd  (%r12),%xmm2
movsd  0x8(%r12),%xmm15
addsd  %xmm2,%xmm3
lea    0x1(%rax),%edx
xorps  %xmm5,%xmm5
cvtsi2sd %edx,%xmm5
mulsd  %xmm0,%xmm5
addsd  %xmm2,%xmm5
mov    0x8(%rbp),%r13d
xorps  %xmm2,%xmm2
cvtsi2sd %r13d,%xmm2
movsd  0x10(%r12),%xmm13
movsd  0x10(%rbx),%xmm14
mulsd  %xmm14,%xmm2
addsd  %xmm13,%xmm2
xorps  %xmm4,%xmm4
cvtsi2sd %ecx,%xmm4
mulsd  %xmm1,%xmm4
addsd  %xmm15,%xmm4
lea    0x1(%rcx),%edx
cvtsi2sd %edx,%xmm12
mulsd  %xmm1,%xmm12
mov    (%rdi),%edx
mov    0x4(%rdi),%esi
add    $0x1,%edx
add    $0x1,%esi
mov    %esi,%edi
imul   %r13d,%edi
add    $0x1,%r13d
lea    (%rcx,%rdi,1),%ebp
imul   %edx,%ebp
lea    (%rax,%rbp,1),%ebx
movslq %ebx,%rbx
movsd  (%r9,%rbx,8),%xmm8
add    %eax,%ebp
add    $0x1,%ebp
movslq %ebp,%rbp
movsd  (%r9,%rbp,8),%xmm9
add    %ecx,%edi
add    $0x1,%edi
imul   %edx,%edi
lea    (%rax,%rdi,1),%ebp
movslq %ebp,%rbp
movsd  (%r9,%rbp,8),%xmm10
add    %eax,%edi
add    $0x1,%edi
movslq %edi,%rdi
movsd  (%r9,%rdi,8),%xmm11
imul   %r13d,%esi
lea    (%rcx,%rsi,1),%edi
add    $0x1,%edi
add    %esi,%ecx
imul   %edx,%ecx
lea    (%rax,%rcx,1),%esi
movslq %esi,%rsi
movsd  (%r9,%rsi,8),%xmm6
add    %eax,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%r14),%xmm1
movsd  0x8(%r14),%xmm0
movsd  %xmm3,0x48(%rsp)
subsd  %xmm3,%xmm1
subsd  %xmm4,%xmm0
mulsd  %xmm0,%xmm0
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  0x10(%r14),%xmm0
subsd  %xmm2,%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movsd  (%r9,%rcx,8),%xmm3
imul   %edx,%edi
lea    (%rax,%rdi,1),%ecx
add    $0x1,%ecx
add    %edi,%eax
ucomisd %xmm7,%xmm0
cltq
movsd  (%r9,%rax,8),%xmm7
movslq %ecx,%rax
movsd  (%r9,%rax,8),%xmm1
movsd  %xmm5,0x8(%rsp)
movsd  %xmm4,0x10(%rsp)
movsd  %xmm1,0x88(%rsp)
movsd  %xmm9,0x80(%rsp)
movsd  %xmm8,0x78(%rsp)
movsd  %xmm11,0x70(%rsp)
movsd  %xmm10,0x68(%rsp)
movsd  %xmm6,0xb0(%rsp)
movsd  %xmm7,0xa8(%rsp)
movsd  %xmm3,0xa0(%rsp)
movsd  %xmm2,0x20(%rsp)
movsd  %xmm13,0x30(%rsp)
movsd  %xmm14,0x28(%rsp)
jb     13b4 <compute_color_vr+0x2a4>
xorps  %xmm3,%xmm3
sqrtsd %xmm0,%xmm3
jmp    13e9 <compute_color_vr+0x2d9>
movsd  %xmm12,0x18(%rsp)
movsd  %xmm15,(%rsp)
call   1030 <sqrt@plt>
movsd  (%rsp),%xmm15
movsd  0x20(%rsp),%xmm2
movsd  0x10(%rsp),%xmm4
movsd  0x8(%rsp),%xmm5
movsd  0x18(%rsp),%xmm12
movapd %xmm0,%xmm3
xorps  %xmm6,%xmm6
cvtsi2sd %r13d,%xmm6
addsd  %xmm15,%xmm12
movsd  (%r14),%xmm1
movsd  0x8(%r14),%xmm0
subsd  %xmm5,%xmm1
subsd  %xmm4,%xmm0
mulsd  %xmm0,%xmm0
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  0x10(%r14),%xmm0
subsd  %xmm2,%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
xorpd  %xmm4,%xmm4
ucomisd %xmm4,%xmm0
movsd  %xmm12,0x18(%rsp)
movsd  %xmm3,0x60(%rsp)
jb     1444 <compute_color_vr+0x334>
sqrtsd %xmm0,%xmm0
jmp    146a <compute_color_vr+0x35a>
movsd  %xmm6,(%rsp)
call   1030 <sqrt@plt>
xorpd  %xmm4,%xmm4
movsd  0x20(%rsp),%xmm2
movsd  (%rsp),%xmm6
movsd  0x8(%rsp),%xmm5
movsd  0x18(%rsp),%xmm12
movsd  %xmm0,0x58(%rsp)
movsd  0x28(%rsp),%xmm0
mulsd  %xmm0,%xmm6
movsd  (%r14),%xmm1
movsd  0x8(%r14),%xmm0
subsd  %xmm5,%xmm1
subsd  %xmm12,%xmm0
mulsd  %xmm0,%xmm0
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  0x10(%r14),%xmm0
subsd  %xmm2,%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
ucomisd %xmm4,%xmm0
jb     14b8 <compute_color_vr+0x3a8>
sqrtsd %xmm0,%xmm0
jmp    14d4 <compute_color_vr+0x3c4>
movsd  %xmm6,(%rsp)
call   1030 <sqrt@plt>
movsd  0x20(%rsp),%xmm2
movsd  (%rsp),%xmm6
movsd  0x18(%rsp),%xmm12
movsd  %xmm0,0x28(%rsp)
movsd  0x30(%rsp),%xmm0
addsd  %xmm0,%xmm6
movsd  (%r14),%xmm1
movsd  0x8(%r14),%xmm0
subsd  0x48(%rsp),%xmm1
subsd  %xmm12,%xmm0
mulsd  %xmm0,%xmm0
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  0x10(%r14),%xmm0
subsd  %xmm2,%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
xorpd  %xmm3,%xmm3
ucomisd %xmm3,%xmm0
movsd  %xmm6,(%rsp)
jb     152d <compute_color_vr+0x41d>
sqrtsd %xmm0,%xmm0
jmp    153b <compute_color_vr+0x42b>
call   1030 <sqrt@plt>
xorpd  %xmm3,%xmm3
movsd  (%rsp),%xmm6
movsd  %xmm0,0x20(%rsp)
movsd  0x10(%rsp),%xmm2
movsd  (%r14),%xmm1
movsd  0x8(%r14),%xmm0
subsd  0x48(%rsp),%xmm1
subsd  %xmm2,%xmm0
mulsd  %xmm0,%xmm0
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  0x10(%r14),%xmm0
subsd  %xmm6,%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
ucomisd %xmm3,%xmm0
jb     1586 <compute_color_vr+0x476>
sqrtsd %xmm0,%xmm0
jmp    1596 <compute_color_vr+0x486>
call   1030 <sqrt@plt>
movsd  (%rsp),%xmm6
movsd  0x10(%rsp),%xmm2
movsd  %xmm0,0x30(%rsp)
movsd  0x8(%rsp),%xmm3
movsd  (%r14),%xmm1
movsd  0x8(%r14),%xmm0
subsd  %xmm3,%xmm1
subsd  %xmm2,%xmm0
mulsd  %xmm0,%xmm0
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  0x10(%r14),%xmm0
subsd  %xmm6,%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
xorpd  %xmm4,%xmm4
ucomisd %xmm4,%xmm0
jb     15e3 <compute_color_vr+0x4d3>
sqrtsd %xmm0,%xmm0
jmp    15f7 <compute_color_vr+0x4e7>
call   1030 <sqrt@plt>
xorpd  %xmm4,%xmm4
movsd  (%rsp),%xmm6
movsd  0x8(%rsp),%xmm3
movsd  %xmm0,0x10(%rsp)
movsd  0x18(%rsp),%xmm2
movsd  (%r14),%xmm1
movsd  0x8(%r14),%xmm0
subsd  %xmm3,%xmm1
subsd  %xmm2,%xmm0
mulsd  %xmm0,%xmm0
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  0x10(%r14),%xmm0
subsd  %xmm6,%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
ucomisd %xmm4,%xmm0
jb     1640 <compute_color_vr+0x530>
sqrtsd %xmm0,%xmm0
jmp    1650 <compute_color_vr+0x540>
call   1030 <sqrt@plt>
movsd  (%rsp),%xmm6
movsd  0x18(%rsp),%xmm2
movsd  %xmm0,0x8(%rsp)
movsd  (%r14),%xmm1
movsd  0x8(%r14),%xmm0
subsd  0x48(%rsp),%xmm1
subsd  %xmm2,%xmm0
mulsd  %xmm0,%xmm0
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  0x10(%r14),%xmm0
subsd  %xmm6,%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1699 <compute_color_vr+0x589>
sqrtsd %xmm0,%xmm0
jmp    169e <compute_color_vr+0x58e>
call   1030 <sqrt@plt>
movsd  %xmm0,(%rsp)
mov    0x44(%rsp),%edi
movsd  0x88(%rsp),%xmm7
mov    0x40(%rsp),%edx
mov    0x3c(%rsp),%esi
movsd  0x80(%rsp),%xmm5
movsd  0x78(%rsp),%xmm1
movsd  0x70(%rsp),%xmm11
movsd  0x68(%rsp),%xmm15
movsd  0x60(%rsp),%xmm6
movsd  0x91c(%rip),%xmm10
addsd  %xmm10,%xmm6
movsd  0x917(%rip),%xmm2
movapd %xmm2,%xmm3
divsd  %xmm6,%xmm3
xorpd  %xmm0,%xmm0
addsd  %xmm0,%xmm3
movsd  0x58(%rsp),%xmm8
addsd  %xmm10,%xmm8
movapd %xmm2,%xmm4
divsd  %xmm8,%xmm4
addsd  %xmm3,%xmm4
movsd  0x28(%rsp),%xmm9
addsd  %xmm10,%xmm9
movapd %xmm2,%xmm3
divsd  %xmm9,%xmm3
addsd  %xmm4,%xmm3
movsd  0x20(%rsp),%xmm13
addsd  %xmm10,%xmm13
movapd %xmm2,%xmm4
divsd  %xmm13,%xmm4
addsd  %xmm3,%xmm4
movsd  0x30(%rsp),%xmm0
addsd  %xmm10,%xmm0
movapd %xmm2,%xmm3
divsd  %xmm0,%xmm3
addsd  %xmm4,%xmm3
movsd  0x10(%rsp),%xmm14
addsd  %xmm10,%xmm14
movapd %xmm2,%xmm4
divsd  %xmm14,%xmm4
addsd  %xmm3,%xmm4
movsd  0x8(%rsp),%xmm12
addsd  %xmm10,%xmm12
movapd %xmm2,%xmm3
divsd  %xmm12,%xmm3
addsd  %xmm4,%xmm3
movsd  (%rsp),%xmm4
addsd  %xmm10,%xmm4
divsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm6
divsd  %xmm6,%xmm1
addsd  0x8d9(%rip),%xmm1
mulsd  %xmm2,%xmm8
divsd  %xmm8,%xmm5
addsd  %xmm1,%xmm5
mulsd  %xmm2,%xmm9
divsd  %xmm9,%xmm15
addsd  %xmm5,%xmm15
mulsd  %xmm2,%xmm13
divsd  %xmm13,%xmm11
addsd  %xmm15,%xmm11
mulsd  %xmm2,%xmm0
movsd  0xb0(%rsp),%xmm3
divsd  %xmm0,%xmm3
addsd  %xmm11,%xmm3
mulsd  %xmm2,%xmm14
movsd  0xa0(%rsp),%xmm1
divsd  %xmm14,%xmm1
addsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm12
movsd  0xa8(%rsp),%xmm0
divsd  %xmm12,%xmm0
addsd  %xmm1,%xmm0
mulsd  %xmm4,%xmm2
divsd  %xmm2,%xmm7
addsd  %xmm0,%xmm7
movsd  0xb8(%rsp),%xmm1
movapd %xmm1,%xmm0
cmp    $0x3,%esi
jne    18ad <compute_color_vr+0x79d>
movapd %xmm1,%xmm0
test   %edx,%edx
jle    18ad <compute_color_vr+0x79d>
mov    %edx,%eax
shl    $0x3,%rax
lea    (%rax,%rax,2),%rax
xor    %ecx,%ecx
movapd 0x83f(%rip),%xmm2
movapd %xmm1,%xmm0
jmp    1879 <compute_color_vr+0x769>
nopw   0x0(%rax,%rax,1)
add    $0x18,%rcx
cmp    %rcx,%rax
je     18ad <compute_color_vr+0x79d>
movapd %xmm7,%xmm4
subsd  (%r15,%rcx,1),%xmm4
andpd  %xmm2,%xmm4
movsd  0x8(%r15,%rcx,1),%xmm3
ucomisd %xmm4,%xmm3
jbe    1870 <compute_color_vr+0x760>
movapd %xmm3,%xmm5
subsd  %xmm4,%xmm5
mulsd  0x10(%r15,%rcx,1),%xmm5
divsd  %xmm3,%xmm5
addsd  %xmm5,%xmm0
jmp    1870 <compute_color_vr+0x760>
cmp    $0x4,%esi
jne    18b6 <compute_color_vr+0x7a6>
movapd %xmm1,%xmm0
jne    18f1 <compute_color_vr+0x7e1>
test   %edx,%edx
jle    18f1 <compute_color_vr+0x7e1>
mov    %edx,%eax
cmp    $0x1,%edx
jne    1950 <compute_color_vr+0x840>
xor    %ecx,%ecx
movapd %xmm1,%xmm0
test   $0x1,%al
je     18f1 <compute_color_vr+0x7e1>
lea    (%rcx,%rcx,2),%rax
ucomisd (%r15,%rax,8),%xmm7
jb     18f1 <compute_color_vr+0x7e1>
movsd  0x8(%r15,%rax,8),%xmm2
ucomisd %xmm7,%xmm2
jb     18f1 <compute_color_vr+0x7e1>
movsd  0x10(%r15,%rax,8),%xmm0
mov    0x130(%rsp),%ecx
cmp    $0x3,%edi
je     19b0 <compute_color_vr+0x8a0>
cmp    $0x2,%edi
je     19e7 <compute_color_vr+0x8d7>
cmp    $0x1,%edi
jne    1a17 <compute_color_vr+0x907>
movsd  0x90(%rsp),%xmm3
movapd 0xd0(%rsp),%xmm1
subsd  %xmm3,%xmm1
movapd 0x76f(%rip),%xmm2
andpd  %xmm1,%xmm2
ucomisd 0x6c3(%rip),%xmm2
jbe    1a17 <compute_color_vr+0x907>
subsd  %xmm3,%xmm7
divsd  %xmm1,%xmm7
jmp    1a17 <compute_color_vr+0x907>
mov    %eax,%edx
and    $0xfffffffe,%edx
lea    0x28(%r15),%rsi
xor    %ecx,%ecx
movapd %xmm1,%xmm0
jmp    1981 <compute_color_vr+0x871>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x2,%rcx
add    $0x30,%rsi
cmp    %rcx,%rdx
je     18cd <compute_color_vr+0x7bd>
ucomisd -0x28(%rsi),%xmm7
jb     1998 <compute_color_vr+0x888>
movsd  -0x20(%rsi),%xmm2
ucomisd %xmm7,%xmm2
jb     1998 <compute_color_vr+0x888>
movsd  -0x18(%rsi),%xmm0
ucomisd -0x10(%rsi),%xmm7
jb     1970 <compute_color_vr+0x860>
movsd  -0x8(%rsi),%xmm2
ucomisd %xmm7,%xmm2
jb     1970 <compute_color_vr+0x860>
movsd  (%rsi),%xmm0
jmp    1970 <compute_color_vr+0x860>
mov    0x50(%rsp),%rbp
movsd  0x0(%rbp),%xmm3
xorpd  %xmm2,%xmm2
ucomisd %xmm7,%xmm3
ja     1a1b <compute_color_vr+0x90b>
mov    0x128(%rsp),%eax
lea    (%rax,%rax,1),%edx
movslq %edx,%rdx
ucomisd 0x0(%rbp,%rdx,8),%xmm7
jbe    1c7c <compute_color_vr+0xb6c>
movsd  0x623(%rip),%xmm2
jmp    1a1b <compute_color_vr+0x90b>
mov    0x50(%rsp),%rax
movsd  (%rax),%xmm3
movsd  0x8(%rax),%xmm2
subsd  %xmm3,%xmm2
movapd 0x69f(%rip),%xmm4
andpd  %xmm2,%xmm4
ucomisd 0x5f3(%rip),%xmm4
jbe    1a17 <compute_color_vr+0x907>
subsd  %xmm3,%xmm7
divsd  %xmm2,%xmm7
movapd %xmm7,%xmm2
mov    0x178(%rsp),%rax
cmp    $0x2,%ecx
je     1a98 <compute_color_vr+0x988>
cmp    $0x1,%ecx
jne    1af8 <compute_color_vr+0x9e8>
xorpd  %xmm3,%xmm3
maxsd  %xmm2,%xmm3
movsd  0x5c7(%rip),%xmm1
movapd %xmm1,%xmm4
minsd  %xmm3,%xmm4
movsd  0x60f(%rip),%xmm2
ucomisd %xmm4,%xmm2
jae    1b02 <compute_color_vr+0x9f2>
ucomisd 0x5fd(%rip),%xmm4
jbe    1be9 <compute_color_vr+0xad9>
movsd  0x5ff(%rip),%xmm2
ucomisd %xmm4,%xmm2
jb     1be9 <compute_color_vr+0xad9>
subsd  %xmm4,%xmm2
mulsd  0x5e1(%rip),%xmm2
xorpd  %xmm3,%xmm3
movhpd 0x575(%rip),%xmm3
jmp    1b28 <compute_color_vr+0xa18>
xorpd  %xmm3,%xmm3
maxsd  %xmm2,%xmm3
movsd  0x560(%rip),%xmm2
movapd %xmm2,%xmm1
minsd  %xmm3,%xmm1
movsd  0x558(%rip),%xmm3
ucomisd %xmm1,%xmm3
jae    1b18 <compute_color_vr+0xa08>
ucomisd 0x54a(%rip),%xmm1
jbe    1c2f <compute_color_vr+0xb1f>
movsd  0x54c(%rip),%xmm3
ucomisd %xmm1,%xmm3
jb     1c2f <compute_color_vr+0xb1f>
addsd  0x572(%rip),%xmm1
mulsd  0x52a(%rip),%xmm1
xorpd  %xmm3,%xmm3
unpcklpd %xmm1,%xmm3
jmp    1b28 <compute_color_vr+0xa18>
movapd %xmm2,%xmm3
unpcklpd %xmm2,%xmm3
jmp    1b28 <compute_color_vr+0xa18>
mulsd  0x55e(%rip),%xmm4
xorpd  %xmm3,%xmm3
unpcklpd %xmm4,%xmm3
movapd %xmm1,%xmm2
jmp    1b28 <compute_color_vr+0xa18>
subsd  %xmm1,%xmm3
mulsd  0x4f4(%rip),%xmm3
movq   %xmm3,%xmm3
movsd  0x18(%rax),%xmm1
movsd  0x553(%rip),%xmm4
ucomisd %xmm1,%xmm4
jbe    1bd7 <compute_color_vr+0xac7>
mov    0x148(%rsp),%rcx
movapd 0xc0(%rsp),%xmm7
divsd  0x98(%rsp),%xmm7
movsd  (%rcx),%xmm5
mulsd  %xmm5,%xmm2
mulsd  %xmm7,%xmm2
xorpd  %xmm4,%xmm4
addsd  %xmm2,%xmm4
unpcklpd %xmm5,%xmm5
mulpd  %xmm5,%xmm3
movapd %xmm7,%xmm2
unpcklpd %xmm7,%xmm2
mulpd  %xmm3,%xmm2
xorpd  %xmm3,%xmm3
addpd  %xmm2,%xmm3
unpcklpd %xmm0,%xmm0
mulpd  %xmm0,%xmm3
movsd  0x46f(%rip),%xmm2
subsd  %xmm1,%xmm2
movupd (%rax),%xmm5
movapd %xmm2,%xmm6
unpcklpd %xmm2,%xmm6
mulpd  %xmm3,%xmm6
addpd  %xmm5,%xmm6
movupd %xmm6,(%rax)
unpcklpd %xmm2,%xmm4
mulpd  %xmm0,%xmm4
unpcklpd %xmm7,%xmm2
mulpd  %xmm4,%xmm2
movsd  0x10(%rax),%xmm0
unpcklpd %xmm1,%xmm0
addpd  %xmm2,%xmm0
movupd %xmm0,0x10(%rax)
add    $0xe8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
ucomisd 0x47f(%rip),%xmm4
jbe    1d05 <compute_color_vr+0xbf5>
movsd  0x479(%rip),%xmm1
ucomisd %xmm4,%xmm1
jb     1d05 <compute_color_vr+0xbf5>
addsd  0x46f(%rip),%xmm4
mulsd  0x44f(%rip),%xmm4
shufpd $0x2,0x49e(%rip),%xmm4
xorpd  %xmm2,%xmm2
movapd %xmm4,%xmm3
jmp    1b28 <compute_color_vr+0xa18>
ucomisd 0x3e9(%rip),%xmm1
jbe    1d3c <compute_color_vr+0xc2c>
movsd  0x3e3(%rip),%xmm2
ucomisd %xmm1,%xmm2
jb     1d3c <compute_color_vr+0xc2c>
addsd  0x3f9(%rip),%xmm1
movsd  0x3a9(%rip),%xmm2
xorpd  %xmm3,%xmm3
unpcklpd %xmm2,%xmm3
mulsd  0x3d1(%rip),%xmm1
addsd  %xmm2,%xmm1
movapd %xmm1,%xmm2
jmp    1b28 <compute_color_vr+0xa18>
test   %eax,%eax
jle    1a17 <compute_color_vr+0x907>
mov    %eax,%esi
shl    $0x4,%rsi
add    $0x10,%rsi
movabs $0x100000000,%rax
mov    $0x10,%edx
movabs $0x200000000,%rdi
jmp    1cc0 <compute_color_vr+0xbb0>
nopl   0x0(%rax)
add    %rdi,%rax
add    $0x10,%rdx
cmp    %rdx,%rsi
je     1a17 <compute_color_vr+0x907>
movsd  0x0(%rbp,%rdx,1),%xmm2
ucomisd %xmm7,%xmm2
jb     1cb0 <compute_color_vr+0xba0>
movsd  -0x10(%rbp,%rdx,1),%xmm3
ucomisd %xmm3,%xmm7
jbe    1cb0 <compute_color_vr+0xba0>
subsd  %xmm3,%xmm7
subsd  %xmm3,%xmm2
divsd  %xmm2,%xmm7
movsd  0x8(%rbp,%rdx,1),%xmm2
sar    $0x1d,%rax
movsd  0x0(%rbp,%rax,1),%xmm3
subsd  %xmm3,%xmm2
mulsd  %xmm7,%xmm2
addsd  %xmm3,%xmm2
jmp    1a1b <compute_color_vr+0x90b>
ucomisd 0x36b(%rip),%xmm4
jbe    1da9 <compute_color_vr+0xc99>
movsd  0x2ed(%rip),%xmm1
subsd  %xmm4,%xmm1
mulsd  0x341(%rip),%xmm1
movapd 0x381(%rip),%xmm3
unpcklpd %xmm1,%xmm3
xorpd  %xmm2,%xmm2
jmp    1b28 <compute_color_vr+0xa18>
ucomisd 0x2e4(%rip),%xmm1
jbe    1d7a <compute_color_vr+0xc6a>
movsd  0x2e2(%rip),%xmm2
ucomisd %xmm1,%xmm2
jb     1d7a <compute_color_vr+0xc6a>
addsd  0x2ec(%rip),%xmm1
mulsd  0x2b4(%rip),%xmm1
shufpd $0x2,0x353(%rip),%xmm1
xorpd  %xmm2,%xmm2
movapd %xmm1,%xmm3
jmp    1b28 <compute_color_vr+0xa18>
xorpd  %xmm2,%xmm2
ucomisd %xmm2,%xmm1
jbe    1da9 <compute_color_vr+0xc99>
addsd  0x2ac(%rip),%xmm1
mulsd  0x2ac(%rip),%xmm1
addsd  0x26c(%rip),%xmm1
movapd 0x30c(%rip),%xmm3
jmp    1af2 <compute_color_vr+0x9e2>
jmp    1b28 <compute_color_vr+0xa18>

LLVM IR (-O0):
define void @compute_color_vr(i32* %0, i32 %1, double* %2, i32 %3, double %4, i32 %5, double* %6, double* %7, i32 %8, i32 %9, i32 %10, double* %11, double* %12, i32* %13, double* %14, double* %15, double* %16, double* %17, double* %18, double %19, double %20, double* %21, double* %22, double* %23, double* %24, double* %25, double* %26, double* %27, double %28, i32 %29, i32 %30) {
%32 = alloca i32*
%33 = alloca i32
%34 = alloca double*
%35 = alloca i32
%36 = alloca double
%37 = alloca i32
%38 = alloca double*
%39 = alloca double*
%40 = alloca i32
%41 = alloca i32
%42 = alloca i32
%43 = alloca double*
%44 = alloca double*
%45 = alloca i32*
%46 = alloca double*
%47 = alloca double*
%48 = alloca double*
%49 = alloca double*
%50 = alloca double*
%51 = alloca double
%52 = alloca double
%53 = alloca double*
%54 = alloca double*
%55 = alloca double*
%56 = alloca double*
%57 = alloca double*
%58 = alloca double*
%59 = alloca double*
%60 = alloca double
%61 = alloca i32
%62 = alloca i32
%63 = alloca i32
%64 = alloca i32
%65 = alloca i32
%66 = alloca double
%67 = alloca [3 x double]
%68 = alloca double
%69 = alloca double
%70 = alloca double
%71 = alloca i32
%72 = alloca i32
%73 = alloca [8 x double]
%74 = alloca [24 x double]
%75 = alloca double
%76 = alloca [8 x double]
%77 = alloca double
%78 = alloca i32
%79 = alloca double
%80 = alloca double
%81 = alloca double
%82 = alloca double
store i32* %0, i32** %32
store i32 %1, i32* %33
store double* %2, double** %34
store i32 %3, i32* %35
store double %4, double* %36
store i32 %5, i32* %37
store double* %6, double** %38
store double* %7, double** %39
store i32 %8, i32* %40
store i32 %9, i32* %41
store i32 %10, i32* %42
store double* %11, double** %43
store double* %12, double** %44
store i32* %13, i32** %45
store double* %14, double** %46
store double* %15, double** %47
store double* %16, double** %48
store double* %17, double** %49
store double* %18, double** %50
store double %19, double* %51
store double %20, double* %52
store double* %21, double** %53
store double* %22, double** %54
store double* %23, double** %55
store double* %24, double** %56
store double* %25, double** %57
store double* %26, double** %58
store double* %27, double** %59
store double %28, double* %60
store i32 %29, i32* %61
store i32 %30, i32* %62
%83 = load double*, double** %59
%84 = getelementptr inbounds double, double* %83, i64 0
%85 = load double, double* %84
%86 = load double*, double** %58
%87 = getelementptr inbounds double, double* %86, i64 0
%88 = load double, double* %87
%89 = fsub double %85, %88
%90 = load double*, double** %59
%91 = getelementptr inbounds double, double* %90, i64 0
%92 = load double, double* %91
%93 = load double*, double** %58
%94 = getelementptr inbounds double, double* %93, i64 0
%95 = load double, double* %94
%96 = fsub double %92, %95
%97 = load double*, double** %59
%98 = getelementptr inbounds double, double* %97, i64 1
%99 = load double, double* %98
%100 = load double*, double** %58
%101 = getelementptr inbounds double, double* %100, i64 1
%102 = load double, double* %101
%103 = fsub double %99, %102
%104 = load double*, double** %59
%105 = getelementptr inbounds double, double* %104, i64 1
%106 = load double, double* %105
%107 = load double*, double** %58
%108 = getelementptr inbounds double, double* %107, i64 1
%109 = load double, double* %108
%110 = fsub double %106, %109
%111 = fmul double %103, %110
%112 = call double @llvm.fmuladd.f64(double %89, double %96, double %111)
%113 = load double*, double** %59
%114 = getelementptr inbounds double, double* %113, i64 2
%115 = load double, double* %114
%116 = load double*, double** %58
%117 = getelementptr inbounds double, double* %116, i64 2
%118 = load double, double* %117
%119 = fsub double %115, %118
%120 = load double*, double** %59
%121 = getelementptr inbounds double, double* %120, i64 2
%122 = load double, double* %121
%123 = load double*, double** %58
%124 = getelementptr inbounds double, double* %123, i64 2
%125 = load double, double* %124
%126 = fsub double %122, %125
%127 = call double @llvm.fmuladd.f64(double %119, double %126, double %112)
%128 = call double @sqrt(double %127)
store double %128, double* %69
%129 = load double, double* %69
%130 = load double, double* %60
%131 = fdiv double %129, %130
store double %131, double* %70
%132 = load i32*, i32** %32
%133 = getelementptr inbounds i32, i32* %132, i64 2
%134 = load i32, i32* %133
%135 = load i32*, i32** %45
%136 = getelementptr inbounds i32, i32* %135, i64 0
%137 = load i32, i32* %136
%138 = mul nsw i32 %134, %137
%139 = load i32*, i32** %45
%140 = getelementptr inbounds i32, i32* %139, i64 1
%141 = load i32, i32* %140
%142 = mul nsw i32 %138, %141
%143 = load i32*, i32** %32
%144 = getelementptr inbounds i32, i32* %143, i64 1
%145 = load i32, i32* %144
%146 = load i32*, i32** %45
%147 = getelementptr inbounds i32, i32* %146, i64 0
%148 = load i32, i32* %147
%149 = mul nsw i32 %145, %148
%150 = add nsw i32 %142, %149
%151 = load i32*, i32** %32
%152 = getelementptr inbounds i32, i32* %151, i64 0
%153 = load i32, i32* %152
%154 = add nsw i32 %150, %153
store i32 %154, i32* %71
store i32 0, i32* %78
%155 = load double*, double** %46
%156 = getelementptr inbounds double, double* %155, i64 0
%157 = load double, double* %156
%158 = load i32*, i32** %32
%159 = getelementptr inbounds i32, i32* %158, i64 0
%160 = load i32, i32* %159
%161 = sitofp i32 %160 to double
%162 = load double*, double** %47
%163 = getelementptr inbounds double, double* %162, i64 0
%164 = load double, double* %163
%165 = call double @llvm.fmuladd.f64(double %161, double %164, double %157)
%166 = getelementptr inbounds [24 x double], [24 x double]* %74, i64 0, i64 9
store double %165, double* %166
%167 = getelementptr inbounds [24 x double], [24 x double]* %74, i64 0, i64 21
store double %165, double* %167
%168 = getelementptr inbounds [24 x double], [24 x double]* %74, i64 0, i64 12
store double %165, double* %168
%169 = getelementptr inbounds [24 x double], [24 x double]* %74, i64 0, i64 0
store double %165, double* %169
%170 = load double*, double** %46
%171 = getelementptr inbounds double, double* %170, i64 0
%172 = load double, double* %171
%173 = load i32*, i32** %32
%174 = getelementptr inbounds i32, i32* %173, i64 0
%175 = load i32, i32* %174
%176 = add nsw i32 %175, 1
%177 = sitofp i32 %176 to double
%178 = load double*, double** %47
%179 = getelementptr inbounds double, double* %178, i64 0
%180 = load double, double* %179
%181 = call double @llvm.fmuladd.f64(double %177, double %180, double %172)
%182 = getelementptr inbounds [24 x double], [24 x double]* %74, i64 0, i64 6
store double %181, double* %182
%183 = getelementptr inbounds [24 x double], [24 x double]* %74, i64 0, i64 18
store double %181, double* %183
%184 = getelementptr inbounds [24 x double], [24 x double]* %74, i64 0, i64 15
store double %181, double* %184
%185 = getelementptr inbounds [24 x double], [24 x double]* %74, i64 0, i64 3
store double %181, double* %185
%186 = load double*, double** %46
%187 = getelementptr inbounds double, double* %186, i64 2
%188 = load double, double* %187
%189 = load i32*, i32** %32
%190 = getelementptr inbounds i32, i32* %189, i64 2
%191 = load i32, i32* %190
%192 = sitofp i32 %191 to double
%193 = load double*, double** %47
%194 = getelementptr inbounds double, double* %193, i64 2
%195 = load double, double* %194
%196 = call double @llvm.fmuladd.f64(double %192, double %195, double %188)
%197 = getelementptr inbounds [24 x double], [24 x double]* %74, i64 0, i64 11
store double %196, double* %197
%198 = getelementptr inbounds [24 x double], [24 x double]* %74, i64 0, i64 8
store double %196, double* %198
%199 = getelementptr inbounds [24 x double], [24 x double]* %74, i64 0, i64 5
store double %196, double* %199
%200 = getelementptr inbounds [24 x double], [24 x double]* %74, i64 0, i64 2
store double %196, double* %200
%201 = load double*, double** %46
%202 = getelementptr inbounds double, double* %201, i64 2
%203 = load double, double* %202
%204 = load i32*, i32** %32
%205 = getelementptr inbounds i32, i32* %204, i64 2
%206 = load i32, i32* %205
%207 = add nsw i32 %206, 1
%208 = sitofp i32 %207 to double
%209 = load double*, double** %47
%210 = getelementptr inbounds double, double* %209, i64 2
%211 = load double, double* %210
%212 = call double @llvm.fmuladd.f64(double %208, double %211, double %203)
%213 = getelementptr inbounds [24 x double], [24 x double]* %74, i64 0, i64 23
store double %212, double* %213
%214 = getelementptr inbounds [24 x double], [24 x double]* %74, i64 0, i64 20
store double %212, double* %214
%215 = getelementptr inbounds [24 x double], [24 x double]* %74, i64 0, i64 17
store double %212, double* %215
%216 = getelementptr inbounds [24 x double], [24 x double]* %74, i64 0, i64 14
store double %212, double* %216
%217 = load double*, double** %46
%218 = getelementptr inbounds double, double* %217, i64 1
%219 = load double, double* %218
%220 = load i32*, i32** %32
%221 = getelementptr inbounds i32, i32* %220, i64 1
%222 = load i32, i32* %221
%223 = sitofp i32 %222 to double
%224 = load double*, double** %47
%225 = getelementptr inbounds double, double* %224, i64 1
%226 = load double, double* %225
%227 = call double @llvm.fmuladd.f64(double %223, double %226, double %219)
%228 = getelementptr inbounds [24 x double], [24 x double]* %74, i64 0, i64 13
store double %227, double* %228
%229 = getelementptr inbounds [24 x double], [24 x double]* %74, i64 0, i64 16
store double %227, double* %229
%230 = getelementptr inbounds [24 x double], [24 x double]* %74, i64 0, i64 4
store double %227, double* %230
%231 = getelementptr inbounds [24 x double], [24 x double]* %74, i64 0, i64 1
store double %227, double* %231
%232 = load double*, double** %46
%233 = getelementptr inbounds double, double* %232, i64 1
%234 = load double, double* %233
%235 = load i32*, i32** %32
%236 = getelementptr inbounds i32, i32* %235, i64 1
%237 = load i32, i32* %236
%238 = add nsw i32 %237, 1
%239 = sitofp i32 %238 to double
%240 = load double*, double** %47
%241 = getelementptr inbounds double, double* %240, i64 1
%242 = load double, double* %241
%243 = call double @llvm.fmuladd.f64(double %239, double %242, double %234)
%244 = getelementptr inbounds [24 x double], [24 x double]* %74, i64 0, i64 22
store double %243, double* %244
%245 = getelementptr inbounds [24 x double], [24 x double]* %74, i64 0, i64 19
store double %243, double* %245
%246 = getelementptr inbounds [24 x double], [24 x double]* %74, i64 0, i64 7
store double %243, double* %246
%247 = getelementptr inbounds [24 x double], [24 x double]* %74, i64 0, i64 10
store double %243, double* %247
store i32 0, i32* %72
br label %248
248: ; preds = %306, %31
%249 = load i32, i32* %72
%250 = icmp slt i32 %249, 8
br i1 %250, label %251, label %309
251: ; preds = %248
%252 = load i32, i32* %72
%253 = srem i32 %252, 2
store i32 %253, i32* %63
%254 = load i32, i32* %72
%255 = sdiv i32 %254, 2
%256 = srem i32 %255, 2
store i32 %256, i32* %64
%257 = load i32, i32* %72
%258 = sdiv i32 %257, 2
%259 = sdiv i32 %258, 2
store i32 %259, i32* %65
%260 = load i32*, i32** %32
%261 = getelementptr inbounds i32, i32* %260, i64 2
%262 = load i32, i32* %261
%263 = load i32, i32* %65
%264 = add nsw i32 %262, %263
%265 = load i32*, i32** %45
%266 = getelementptr inbounds i32, i32* %265, i64 0
%267 = load i32, i32* %266
%268 = add nsw i32 %267, 1
%269 = mul nsw i32 %264, %268
%270 = load i32*, i32** %45
%271 = getelementptr inbounds i32, i32* %270, i64 1
%272 = load i32, i32* %271
%273 = add nsw i32 %272, 1
%274 = mul nsw i32 %269, %273
%275 = load i32*, i32** %32
%276 = getelementptr inbounds i32, i32* %275, i64 1
%277 = load i32, i32* %276
%278 = load i32, i32* %64
%279 = add nsw i32 %277, %278
%280 = load i32*, i32** %45
%281 = getelementptr inbounds i32, i32* %280, i64 0
%282 = load i32, i32* %281
%283 = add nsw i32 %282, 1
%284 = mul nsw i32 %279, %283
%285 = add nsw i32 %274, %284
%286 = load i32*, i32** %32
%287 = getelementptr inbounds i32, i32* %286, i64 0
%288 = load i32, i32* %287
%289 = add nsw i32 %285, %288
%290 = load i32, i32* %63
%291 = add nsw i32 %289, %290
store i32 %291, i32* %71
%292 = load double*, double** %48
%293 = load i32, i32* %71
%294 = sext i32 %293 to i64
%295 = getelementptr inbounds double, double* %292, i64 %294
%296 = load double, double* %295
%297 = load i32, i32* %65
%298 = mul nsw i32 %297, 4
%299 = load i32, i32* %64
%300 = mul nsw i32 %299, 2
%301 = add nsw i32 %298, %300
%302 = load i32, i32* %63
%303 = add nsw i32 %301, %302
%304 = sext i32 %303 to i64
%305 = getelementptr inbounds [8 x double], [8 x double]* %73, i64 0, i64 %304
store double %296, double* %305
br label %306
306: ; preds = %251
%307 = load i32, i32* %72
%308 = add nsw i32 %307, 1
store i32 %308, i32* %72
br label %248
309: ; preds = %248
store i32 0, i32* %63
br label %310
310: ; preds = %379, %309
%311 = load i32, i32* %63
%312 = icmp slt i32 %311, 8
br i1 %312, label %313, label %382
313: ; preds = %310
%314 = load double*, double** %58
%315 = getelementptr inbounds double, double* %314, i64 0
%316 = load double, double* %315
%317 = load i32, i32* %63
%318 = mul nsw i32 %317, 3
%319 = sext i32 %318 to i64
%320 = getelementptr inbounds [24 x double], [24 x double]* %74, i64 0, i64 %319
%321 = load double, double* %320
%322 = fsub double %316, %321
%323 = load double*, double** %58
%324 = getelementptr inbounds double, double* %323, i64 0
%325 = load double, double* %324
%326 = load i32, i32* %63
%327 = mul nsw i32 %326, 3
%328 = sext i32 %327 to i64
%329 = getelementptr inbounds [24 x double], [24 x double]* %74, i64 0, i64 %328
%330 = load double, double* %329
%331 = fsub double %325, %330
%332 = load double*, double** %58
%333 = getelementptr inbounds double, double* %332, i64 1
%334 = load double, double* %333
%335 = load i32, i32* %63
%336 = mul nsw i32 %335, 3
%337 = add nsw i32 %336, 1
%338 = sext i32 %337 to i64
%339 = getelementptr inbounds [24 x double], [24 x double]* %74, i64 0, i64 %338
%340 = load double, double* %339
%341 = fsub double %334, %340
%342 = load double*, double** %58
%343 = getelementptr inbounds double, double* %342, i64 1
%344 = load double, double* %343
%345 = load i32, i32* %63
%346 = mul nsw i32 %345, 3
%347 = add nsw i32 %346, 1
%348 = sext i32 %347 to i64
%349 = getelementptr inbounds [24 x double], [24 x double]* %74, i64 0, i64 %348
%350 = load double, double* %349
%351 = fsub double %344, %350
%352 = fmul double %341, %351
%353 = call double @llvm.fmuladd.f64(double %322, double %331, double %352)
%354 = load double*, double** %58
%355 = getelementptr inbounds double, double* %354, i64 2
%356 = load double, double* %355
%357 = load i32, i32* %63
%358 = mul nsw i32 %357, 3
%359 = add nsw i32 %358, 2
%360 = sext i32 %359 to i64
%361 = getelementptr inbounds [24 x double], [24 x double]* %74, i64 0, i64 %360
%362 = load double, double* %361
%363 = fsub double %356, %362
%364 = load double*, double** %58
%365 = getelementptr inbounds double, double* %364, i64 2
%366 = load double, double* %365
%367 = load i32, i32* %63
%368 = mul nsw i32 %367, 3
%369 = add nsw i32 %368, 2
%370 = sext i32 %369 to i64
%371 = getelementptr inbounds [24 x double], [24 x double]* %74, i64 0, i64 %370
%372 = load double, double* %371
%373 = fsub double %366, %372
%374 = call double @llvm.fmuladd.f64(double %363, double %373, double %353)
%375 = call double @sqrt(double %374)
%376 = load i32, i32* %63
%377 = sext i32 %376 to i64
%378 = getelementptr inbounds [8 x double], [8 x double]* %76, i64 0, i64 %377
store double %375, double* %378
br label %379
379: ; preds = %313
%380 = load i32, i32* %63
%381 = add nsw i32 %380, 1
store i32 %381, i32* %63
br label %310
382: ; preds = %310
store double 0.000000e+00, double* %77
store i32 0, i32* %63
br label %383
383: ; preds = %395, %382
%384 = load i32, i32* %63
%385 = icmp slt i32 %384, 8
br i1 %385, label %386, label %398
386: ; preds = %383
%387 = load i32, i32* %63
%388 = sext i32 %387 to i64
%389 = getelementptr inbounds [8 x double], [8 x double]* %76, i64 0, i64 %388
%390 = load double, double* %389
%391 = fadd double %390, 1.000000e-08
%392 = fdiv double 1.000000e+00, %391
%393 = load double, double* %77
%394 = fadd double %393, %392
store double %394, double* %77
br label %395
395: ; preds = %386
%396 = load i32, i32* %63
%397 = add nsw i32 %396, 1
store i32 %397, i32* %63
br label %383
398: ; preds = %383
store double 0.000000e+00, double* %75
store i32 0, i32* %63
br label %399
399: ; preds = %417, %398
%400 = load i32, i32* %63
%401 = icmp slt i32 %400, 8
br i1 %401, label %402, label %420
402: ; preds = %399
%403 = load i32, i32* %63
%404 = sext i32 %403 to i64
%405 = getelementptr inbounds [8 x double], [8 x double]* %73, i64 0, i64 %404
%406 = load double, double* %405
%407 = load i32, i32* %63
%408 = sext i32 %407 to i64
%409 = getelementptr inbounds [8 x double], [8 x double]* %76, i64 0, i64 %408
%410 = load double, double* %409
%411 = fadd double %410, 1.000000e-08
%412 = load double, double* %77
%413 = fmul double %411, %412
%414 = fdiv double %406, %413
%415 = load double, double* %75
%416 = fadd double %415, %414
store double %416, double* %75
br label %417
417: ; preds = %402
%418 = load i32, i32* %63
%419 = add nsw i32 %418, 1
store i32 %419, i32* %63
br label %399
420: ; preds = %399
%421 = load double, double* %75
store double %421, double* %68
%422 = load double, double* %36
store double %422, double* %66
%423 = load i32, i32* %35
%424 = icmp eq i32 %423, 3
br i1 %424, label %425, label %483
425: ; preds = %420
%426 = load double, double* %36
store double %426, double* %66
store i32 0, i32* %63
br label %427
427: ; preds = %479, %425
%428 = load i32, i32* %63
%429 = load i32, i32* %37
%430 = icmp slt i32 %428, %429
br i1 %430, label %431, label %482
431: ; preds = %427
%432 = load double, double* %68
%433 = load double*, double** %38
%434 = load i32, i32* %63
%435 = mul nsw i32 %434, 3
%436 = sext i32 %435 to i64
%437 = getelementptr inbounds double, double* %433, i64 %436
%438 = load double, double* %437
%439 = fsub double %432, %438
%440 = call double @llvm.fabs.f64(double %439)
store double %440, double* %79
%441 = load double, double* %79
%442 = load double*, double** %38
%443 = load i32, i32* %63
%444 = mul nsw i32 %443, 3
%445 = add nsw i32 %444, 1
%446 = sext i32 %445 to i64
%447 = getelementptr inbounds double, double* %442, i64 %446
%448 = load double, double* %447
%449 = fcmp olt double %441, %448
br i1 %449, label %450, label %478
450: ; preds = %431
%451 = load double*, double** %38
%452 = load i32, i32* %63
%453 = mul nsw i32 %452, 3
%454 = add nsw i32 %453, 2
%455 = sext i32 %454 to i64
%456 = getelementptr inbounds double, double* %451, i64 %455
%457 = load double, double* %456
%458 = load double*, double** %38
%459 = load i32, i32* %63
%460 = mul nsw i32 %459, 3
%461 = add nsw i32 %460, 1
%462 = sext i32 %461 to i64
%463 = getelementptr inbounds double, double* %458, i64 %462
%464 = load double, double* %463
%465 = load double, double* %79
%466 = fsub double %464, %465
%467 = fmul double %457, %466
%468 = load double*, double** %38
%469 = load i32, i32* %63
%470 = mul nsw i32 %469, 3
%471 = add nsw i32 %470, 1
%472 = sext i32 %471 to i64
%473 = getelementptr inbounds double, double* %468, i64 %472
%474 = load double, double* %473
%475 = fdiv double %467, %474
%476 = load double, double* %66
%477 = fadd double %476, %475
store double %477, double* %66
br label %478
478: ; preds = %450, %431
br label %479
479: ; preds = %478
%480 = load i32, i32* %63
%481 = add nsw i32 %480, 1
store i32 %481, i32* %63
br label %427
482: ; preds = %427
br label %483
483: ; preds = %482, %420
%484 = load i32, i32* %35
%485 = icmp eq i32 %484, 4
br i1 %485, label %486, label %524
486: ; preds = %483
%487 = load double, double* %36
store double %487, double* %66
store i32 0, i32* %63
br label %488
488: ; preds = %520, %486
%489 = load i32, i32* %63
%490 = load i32, i32* %37
%491 = icmp slt i32 %489, %490
br i1 %491, label %492, label %523
492: ; preds = %488
%493 = load double, double* %68
%494 = load double*, double** %38
%495 = load i32, i32* %63
%496 = mul nsw i32 %495, 3
%497 = sext i32 %496 to i64
%498 = getelementptr inbounds double, double* %494, i64 %497
%499 = load double, double* %498
%500 = fcmp oge double %493, %499
br i1 %500, label %501, label %519
501: ; preds = %492
%502 = load double, double* %68
%503 = load double*, double** %38
%504 = load i32, i32* %63
%505 = mul nsw i32 %504, 3
%506 = add nsw i32 %505, 1
%507 = sext i32 %506 to i64
%508 = getelementptr inbounds double, double* %503, i64 %507
%509 = load double, double* %508
%510 = fcmp ole double %502, %509
br i1 %510, label %511, label %519
511: ; preds = %501
%512 = load double*, double** %38
%513 = load i32, i32* %63
%514 = mul nsw i32 %513, 3
%515 = add nsw i32 %514, 2
%516 = sext i32 %515 to i64
%517 = getelementptr inbounds double, double* %512, i64 %516
%518 = load double, double* %517
store double %518, double* %66
br label %519
519: ; preds = %511, %501, %492
br label %520
520: ; preds = %519
%521 = load i32, i32* %63
%522 = add nsw i32 %521, 1
store i32 %522, i32* %63
br label %488
523: ; preds = %488
br label %524
524: ; preds = %523, %483
%525 = load i32, i32* %33
%526 = icmp eq i32 %525, 1
br i1 %526, label %527, label %542
527: ; preds = %524
%528 = load double, double* %52
%529 = load double, double* %51
%530 = fsub double %528, %529
%531 = call double @llvm.fabs.f64(double %530)
%532 = fcmp ogt double %531, 1.000000e-08
br i1 %532, label %533, label %541
533: ; preds = %527
%534 = load double, double* %68
%535 = load double, double* %51
%536 = fsub double %534, %535
%537 = load double, double* %52
%538 = load double, double* %51
%539 = fsub double %537, %538
%540 = fdiv double %536, %539
store double %540, double* %68
br label %541
541: ; preds = %533, %527
br label %542
542: ; preds = %541, %524
%543 = load i32, i32* %33
%544 = icmp eq i32 %543, 2
br i1 %544, label %545, label %566
545: ; preds = %542
%546 = load double*, double** %34
%547 = getelementptr inbounds double, double* %546, i64 0
%548 = load double, double* %547
store double %548, double* %51
%549 = load double*, double** %34
%550 = getelementptr inbounds double, double* %549, i64 1
%551 = load double, double* %550
store double %551, double* %52
%552 = load double, double* %52
%553 = load double, double* %51
%554 = fsub double %552, %553
%555 = call double @llvm.fabs.f64(double %554)
%556 = fcmp ogt double %555, 1.000000e-08
br i1 %556, label %557, label %565
557: ; preds = %545
%558 = load double, double* %68
%559 = load double, double* %51
%560 = fsub double %558, %559
%561 = load double, double* %52
%562 = load double, double* %51
%563 = fsub double %561, %562
%564 = fdiv double %560, %563
store double %564, double* %68
br label %565
565: ; preds = %557, %545
br label %566
566: ; preds = %565, %542
%567 = load i32, i32* %33
%568 = icmp eq i32 %567, 3
br i1 %568, label %569, label %668
569: ; preds = %566
%570 = load double, double* %68
%571 = load double*, double** %34
%572 = getelementptr inbounds double, double* %571, i64 0
%573 = load double, double* %572
%574 = fcmp olt double %570, %573
br i1 %574, label %575, label %576
575: ; preds = %569
store double 0.000000e+00, double* %68
br label %667
576: ; preds = %569
%577 = load double, double* %68
%578 = load double*, double** %34
%579 = load i32, i32* %40
%580 = mul nsw i32 %579, 2
%581 = sext i32 %580 to i64
%582 = getelementptr inbounds double, double* %578, i64 %581
%583 = load double, double* %582
%584 = fcmp ogt double %577, %583
br i1 %584, label %585, label %586
585: ; preds = %576
store double 1.000000e+00, double* %68
br label %666
586: ; preds = %576
store i32 1, i32* %63
br label %587
587: ; preds = %662, %586
%588 = load i32, i32* %63
%589 = load i32, i32* %40
%590 = add nsw i32 %589, 1
%591 = icmp slt i32 %588, %590
br i1 %591, label %592, label %665
592: ; preds = %587
%593 = load double, double* %68
%594 = load double*, double** %34
%595 = load i32, i32* %63
%596 = mul nsw i32 %595, 2
%597 = sext i32 %596 to i64
%598 = getelementptr inbounds double, double* %594, i64 %597
%599 = load double, double* %598
%600 = fcmp ole double %593, %599
br i1 %600, label %601, label %661
601: ; preds = %592
%602 = load double, double* %68
%603 = load double*, double** %34
%604 = load i32, i32* %63
%605 = sub nsw i32 %604, 1
%606 = mul nsw i32 %605, 2
%607 = sext i32 %606 to i64
%608 = getelementptr inbounds double, double* %603, i64 %607
%609 = load double, double* %608
%610 = fcmp ogt double %602, %609
br i1 %610, label %611, label %661
611: ; preds = %601
%612 = load double, double* %68
%613 = load double*, double** %34
%614 = load i32, i32* %63
%615 = sub nsw i32 %614, 1
%616 = mul nsw i32 %615, 2
%617 = sext i32 %616 to i64
%618 = getelementptr inbounds double, double* %613, i64 %617
%619 = load double, double* %618
%620 = fsub double %612, %619
%621 = load double*, double** %34
%622 = load i32, i32* %63
%623 = mul nsw i32 %622, 2
%624 = sext i32 %623 to i64
%625 = getelementptr inbounds double, double* %621, i64 %624
%626 = load double, double* %625
%627 = load double*, double** %34
%628 = load i32, i32* %63
%629 = sub nsw i32 %628, 1
%630 = mul nsw i32 %629, 2
%631 = sext i32 %630 to i64
%632 = getelementptr inbounds double, double* %627, i64 %631
%633 = load double, double* %632
%634 = fsub double %626, %633
%635 = fdiv double %620, %634
%636 = load double*, double** %34
%637 = load i32, i32* %63
%638 = mul nsw i32 %637, 2
%639 = add nsw i32 %638, 1
%640 = sext i32 %639 to i64
%641 = getelementptr inbounds double, double* %636, i64 %640
%642 = load double, double* %641
%643 = load double*, double** %34
%644 = load i32, i32* %63
%645 = sub nsw i32 %644, 1
%646 = mul nsw i32 %645, 2
%647 = add nsw i32 %646, 1
%648 = sext i32 %647 to i64
%649 = getelementptr inbounds double, double* %643, i64 %648
%650 = load double, double* %649
%651 = fsub double %642, %650
%652 = load double*, double** %34
%653 = load i32, i32* %63
%654 = sub nsw i32 %653, 1
%655 = mul nsw i32 %654, 2
%656 = add nsw i32 %655, 1
%657 = sext i32 %656 to i64
%658 = getelementptr inbounds double, double* %652, i64 %657
%659 = load double, double* %658
%660 = call double @llvm.fmuladd.f64(double %635, double %651, double %659)
store double %660, double* %68
br label %665
661: ; preds = %601, %592
br label %662
662: ; preds = %661
%663 = load i32, i32* %63
%664 = add nsw i32 %663, 1
store i32 %664, i32* %63
br label %587
665: ; preds = %611, %587
br label %666
666: ; preds = %665, %585
br label %667
667: ; preds = %666, %575
br label %668
668: ; preds = %667, %566
%669 = load i32, i32* %41
%670 = icmp eq i32 %669, 1
br i1 %670, label %671, label %716
671: ; preds = %668
%672 = load double, double* %68
%673 = fcmp olt double %672, 0.000000e+00
br i1 %673, label %674, label %675
674: ; preds = %671
store double 0.000000e+00, double* %68
br label %675
675: ; preds = %674, %671
%676 = load double, double* %68
%677 = fcmp ogt double %676, 1.000000e+00
br i1 %677, label %678, label %679
678: ; preds = %675
store double 1.000000e+00, double* %68
br label %679
679: ; preds = %678, %675
%680 = load double, double* %68
%681 = fcmp ole double %680, 2.500000e-01
br i1 %681, label %682, label %685
682: ; preds = %679
store double 0.000000e+00, double* %80
%683 = load double, double* %68
%684 = fmul double %683, 4.000000e+00
store double %684, double* %81
store double 1.000000e+00, double* %82
br label %715
685: ; preds = %679
%686 = load double, double* %68
%687 = fcmp ogt double %686, 2.500000e-01
br i1 %687, label %688, label %695
688: ; preds = %685
%689 = load double, double* %68
%690 = fcmp ole double %689, 5.000000e-01
br i1 %690, label %691, label %695
691: ; preds = %688
store double 0.000000e+00, double* %80
store double 1.000000e+00, double* %81
%692 = load double, double* %68
%693 = fsub double 5.000000e-01, %692
%694 = fmul double %693, 4.000000e+00
store double %694, double* %82
br label %714
695: ; preds = %688, %685
%696 = load double, double* %68
%697 = fcmp ogt double %696, 5.000000e-01
br i1 %697, label %698, label %705
698: ; preds = %695
%699 = load double, double* %68
%700 = fcmp ole double %699, 7.500000e-01
br i1 %700, label %701, label %705
701: ; preds = %698
%702 = load double, double* %68
%703 = fsub double %702, 5.000000e-01
%704 = fmul double %703, 4.000000e+00
store double %704, double* %80
store double 1.000000e+00, double* %81
store double 0.000000e+00, double* %82
br label %713
705: ; preds = %698, %695
%706 = load double, double* %68
%707 = fcmp ogt double %706, 7.500000e-01
br i1 %707, label %708, label %712
708: ; preds = %705
store double 1.000000e+00, double* %80
%709 = load double, double* %68
%710 = fsub double 1.000000e+00, %709
%711 = fmul double %710, 4.000000e+00
store double %711, double* %81
store double 0.000000e+00, double* %82
br label %712
712: ; preds = %708, %705
br label %713
713: ; preds = %712, %701
br label %714
714: ; preds = %713, %691
br label %715
715: ; preds = %714, %682
br label %785
716: ; preds = %668
%717 = load i32, i32* %41
%718 = icmp eq i32 %717, 2
br i1 %718, label %719, label %778
719: ; preds = %716
%720 = load double, double* %68
%721 = fcmp olt double %720, 0.000000e+00
br i1 %721, label %722, label %723
722: ; preds = %719
store double 0.000000e+00, double* %68
br label %723
723: ; preds = %722, %719
%724 = load double, double* %68
%725 = fcmp ogt double %724, 1.000000e+00
br i1 %725, label %726, label %727
726: ; preds = %723
store double 1.000000e+00, double* %68
br label %727
727: ; preds = %726, %723
%728 = load double, double* %68
%729 = fcmp ole double %728, 2.000000e-01
br i1 %729, label %730, label %734
730: ; preds = %727
store double 0.000000e+00, double* %81
store double 1.000000e+00, double* %82
%731 = load double, double* %68
%732 = fsub double 2.000000e-01, %731
%733 = fmul double %732, 5.000000e+00
store double %733, double* %80
br label %777
734: ; preds = %727
%735 = load double, double* %68
%736 = fcmp ogt double %735, 2.000000e-01
br i1 %736, label %737, label %744
737: ; preds = %734
%738 = load double, double* %68
%739 = fcmp ole double %738, 4.000000e-01
br i1 %739, label %740, label %744
740: ; preds = %737
store double 0.000000e+00, double* %80
store double 1.000000e+00, double* %82
%741 = load double, double* %68
%742 = fsub double %741, 2.000000e-01
%743 = fmul double %742, 5.000000e+00
store double %743, double* %81
br label %776
744: ; preds = %737, %734
%745 = load double, double* %68
%746 = fcmp ogt double %745, 4.000000e-01
br i1 %746, label %747, label %755
747: ; preds = %744
%748 = load double, double* %68
%749 = fcmp ole double %748, 6.000000e-01
br i1 %749, label %750, label %755
750: ; preds = %747
store double 0.000000e+00, double* %80
store double 1.000000e+00, double* %81
%751 = load double, double* %68
%752 = fsub double %751, 4.000000e-01
%753 = fneg double %752
%754 = call double @llvm.fmuladd.f64(double %753, double 5.000000e+00, double 1.000000e+00)
store double %754, double* %82
br label %775
755: ; preds = %747, %744
%756 = load double, double* %68
%757 = fcmp ogt double %756, 6.000000e-01
br i1 %757, label %758, label %765
758: ; preds = %755
%759 = load double, double* %68
%760 = fcmp ole double %759, 8.000000e-01
br i1 %760, label %761, label %765
761: ; preds = %758
%762 = load double, double* %68
%763 = fsub double %762, 6.000000e-01
%764 = fmul double %763, 5.000000e+00
store double %764, double* %80
store double 1.000000e+00, double* %81
store double 0.000000e+00, double* %82
br label %774
765: ; preds = %758, %755
%766 = load double, double* %68
%767 = fcmp ogt double %766, 0.000000e+00
br i1 %767, label %768, label %773
768: ; preds = %765
store double 1.000000e+00, double* %80
%769 = load double, double* %68
%770 = fsub double %769, 8.000000e-01
%771 = fneg double %770
%772 = call double @llvm.fmuladd.f64(double %771, double 5.000000e+00, double 1.000000e+00)
store double %772, double* %81
store double 0.000000e+00, double* %82
br label %773
773: ; preds = %768, %765
br label %774
774: ; preds = %773, %761
br label %775
775: ; preds = %774, %750
br label %776
776: ; preds = %775, %740
br label %777
777: ; preds = %776, %730
br label %784
778: ; preds = %716
%779 = load i32, i32* %41
%780 = icmp eq i32 %779, 3
br i1 %780, label %781, label %783
781: ; preds = %778
%782 = load double, double* %68
store double %782, double* %82
store double %782, double* %81
store double %782, double* %80
br label %783
783: ; preds = %781, %778
br label %784
784: ; preds = %783, %777
br label %785
785: ; preds = %784, %715
%786 = load double, double* %80
%787 = getelementptr inbounds [3 x double], [3 x double]* %67, i64 0, i64 0
store double %786, double* %787
%788 = load double, double* %81
%789 = getelementptr inbounds [3 x double], [3 x double]* %67, i64 0, i64 1
store double %788, double* %789
%790 = load double, double* %82
%791 = getelementptr inbounds [3 x double], [3 x double]* %67, i64 0, i64 2
store double %790, double* %791
store double 0.000000e+00, double* %80
store double 0.000000e+00, double* %81
store double 0.000000e+00, double* %82
%792 = getelementptr inbounds [3 x double], [3 x double]* %67, i64 0, i64 0
%793 = load double, double* %792
%794 = load double*, double** %44
%795 = getelementptr inbounds double, double* %794, i64 0
%796 = load double, double* %795
%797 = fmul double %793, %796
%798 = load double, double* %70
%799 = load double, double* %80
%800 = call double @llvm.fmuladd.f64(double %797, double %798, double %799)
store double %800, double* %80
%801 = getelementptr inbounds [3 x double], [3 x double]* %67, i64 0, i64 1
%802 = load double, double* %801
%803 = load double*, double** %44
%804 = getelementptr inbounds double, double* %803, i64 0
%805 = load double, double* %804
%806 = fmul double %802, %805
%807 = load double, double* %70
%808 = load double, double* %81
%809 = call double @llvm.fmuladd.f64(double %806, double %807, double %808)
store double %809, double* %81
%810 = getelementptr inbounds [3 x double], [3 x double]* %67, i64 0, i64 2
%811 = load double, double* %810
%812 = load double*, double** %44
%813 = getelementptr inbounds double, double* %812, i64 0
%814 = load double, double* %813
%815 = fmul double %811, %814
%816 = load double, double* %70
%817 = load double, double* %82
%818 = call double @llvm.fmuladd.f64(double %815, double %816, double %817)
store double %818, double* %82
%819 = load double, double* %66
%820 = load double, double* %80
%821 = fmul double %820, %819
store double %821, double* %80
%822 = load double, double* %66
%823 = load double, double* %81
%824 = fmul double %823, %822
store double %824, double* %81
%825 = load double, double* %66
%826 = load double, double* %82
%827 = fmul double %826, %825
store double %827, double* %82
%828 = load double*, double** %50
%829 = getelementptr inbounds double, double* %828, i64 3
%830 = load double, double* %829
%831 = fcmp olt double %830, 0x3FEFAE147AE147AE
br i1 %831, label %832, label %871
832: ; preds = %785
%833 = load double, double* %80
%834 = load double*, double** %50
%835 = getelementptr inbounds double, double* %834, i64 3
%836 = load double, double* %835
%837 = fsub double 1.000000e+00, %836
%838 = load double*, double** %50
%839 = getelementptr inbounds double, double* %838, i64 0
%840 = load double, double* %839
%841 = call double @llvm.fmuladd.f64(double %833, double %837, double %840)
store double %841, double* %839
%842 = load double, double* %81
%843 = load double*, double** %50
%844 = getelementptr inbounds double, double* %843, i64 3
%845 = load double, double* %844
%846 = fsub double 1.000000e+00, %845
%847 = load double*, double** %50
%848 = getelementptr inbounds double, double* %847, i64 1
%849 = load double, double* %848
%850 = call double @llvm.fmuladd.f64(double %842, double %846, double %849)
store double %850, double* %848
%851 = load double, double* %82
%852 = load double*, double** %50
%853 = getelementptr inbounds double, double* %852, i64 3
%854 = load double, double* %853
%855 = fsub double 1.000000e+00, %854
%856 = load double*, double** %50
%857 = getelementptr inbounds double, double* %856, i64 2
%858 = load double, double* %857
%859 = call double @llvm.fmuladd.f64(double %851, double %855, double %858)
store double %859, double* %857
%860 = load double, double* %66
%861 = load double*, double** %50
%862 = getelementptr inbounds double, double* %861, i64 3
%863 = load double, double* %862
%864 = fsub double 1.000000e+00, %863
%865 = fmul double %860, %864
%866 = load double, double* %70
%867 = load double*, double** %50
%868 = getelementptr inbounds double, double* %867, i64 3
%869 = load double, double* %868
%870 = call double @llvm.fmuladd.f64(double %865, double %866, double %869)
store double %870, double* %868
br label %871
871: ; preds = %832, %785
ret void
}

LLVM IR (-O2):
define void @compute_color_vr(i32* nocapture %0, i32 %1, double* nocapture %2, i32 %3, double %4, i32 %5, double* nocapture %6, double* nocapture readnone %7, i32 %8, i32 %9, i32 %10, double* nocapture readnone %11, double* nocapture %12, i32* nocapture %13, double* nocapture %14, double* nocapture %15, double* nocapture %16, double* nocapture readnone %17, double* nocapture %18, double %19, double %20, double* nocapture readnone %21, double* nocapture readnone %22, double* nocapture readnone %23, double* nocapture readnone %24, double* nocapture readnone %25, double* nocapture %26, double* nocapture %27, double %28, i32 %29, i32 %30) {
%32 = load double, double* %27
%33 = load double, double* %26
%34 = fsub double %32, %33
%35 = getelementptr inbounds double, double* %27, i64 1
%36 = load double, double* %35
%37 = getelementptr inbounds double, double* %26, i64 1
%38 = load double, double* %37
%39 = fsub double %36, %38
%40 = fmul double %39, %39
%41 = tail call double @llvm.fmuladd.f64(double %34, double %34, double %40)
%42 = getelementptr inbounds double, double* %27, i64 2
%43 = load double, double* %42
%44 = getelementptr inbounds double, double* %26, i64 2
%45 = load double, double* %44
%46 = fsub double %43, %45
%47 = tail call double @llvm.fmuladd.f64(double %46, double %46, double %41)
%48 = tail call double @sqrt(double %47)
%49 = getelementptr inbounds i32, i32* %0, i64 2
%50 = getelementptr inbounds i32, i32* %13, i64 1
%51 = getelementptr inbounds i32, i32* %0, i64 1
%52 = load i32, i32* %0
%53 = load double, double* %14
%54 = sitofp i32 %52 to double
%55 = load double, double* %15
%56 = tail call double @llvm.fmuladd.f64(double %54, double %55, double %53)
%57 = add i32 %52, 1
%58 = sitofp i32 %57 to double
%59 = tail call double @llvm.fmuladd.f64(double %58, double %55, double %53)
%60 = getelementptr inbounds double, double* %14, i64 2
%61 = load double, double* %60
%62 = load i32, i32* %49
%63 = sitofp i32 %62 to double
%64 = getelementptr inbounds double, double* %15, i64 2
%65 = load double, double* %64
%66 = tail call double @llvm.fmuladd.f64(double %63, double %65, double %61)
%67 = add nsw i32 %62, 1
%68 = sitofp i32 %67 to double
%69 = tail call double @llvm.fmuladd.f64(double %68, double %65, double %61)
%70 = getelementptr inbounds double, double* %14, i64 1
%71 = load double, double* %70
%72 = load i32, i32* %51
%73 = sitofp i32 %72 to double
%74 = getelementptr inbounds double, double* %15, i64 1
%75 = load double, double* %74
%76 = tail call double @llvm.fmuladd.f64(double %73, double %75, double %71)
%77 = add nsw i32 %72, 1
%78 = sitofp i32 %77 to double
%79 = tail call double @llvm.fmuladd.f64(double %78, double %75, double %71)
%80 = load i32, i32* %13
%81 = add nsw i32 %80, 1
%82 = load i32, i32* %50
%83 = add nsw i32 %82, 1
%84 = mul i32 %83, %62
%85 = add i32 %72, %84
%86 = mul i32 %85, %81
%87 = add i32 %52, %86
%88 = sext i32 %87 to i64
%89 = getelementptr inbounds double, double* %16, i64 %88
%90 = load double, double* %89
%91 = add i32 %57, %86
%92 = sext i32 %91 to i64
%93 = getelementptr inbounds double, double* %16, i64 %92
%94 = load double, double* %93
%95 = add i32 %77, %84
%96 = mul i32 %95, %81
%97 = add i32 %52, %96
%98 = sext i32 %97 to i64
%99 = getelementptr inbounds double, double* %16, i64 %98
%100 = load double, double* %99
%101 = add i32 %57, %96
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds double, double* %16, i64 %102
%104 = load double, double* %103
%105 = mul i32 %83, %67
%106 = add i32 %72, %105
%107 = mul i32 %106, %81
%108 = add i32 %52, %107
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds double, double* %16, i64 %109
%111 = load double, double* %110
%112 = add i32 %57, %107
%113 = sext i32 %112 to i64
%114 = getelementptr inbounds double, double* %16, i64 %113
%115 = load double, double* %114
%116 = add i32 %77, %105
%117 = mul i32 %116, %81
%118 = add i32 %52, %117
%119 = sext i32 %118 to i64
%120 = getelementptr inbounds double, double* %16, i64 %119
%121 = load double, double* %120
%122 = add i32 %57, %117
%123 = sext i32 %122 to i64
%124 = getelementptr inbounds double, double* %16, i64 %123
%125 = load double, double* %124
%126 = load double, double* %26
%127 = fsub double %126, %56
%128 = load double, double* %37
%129 = fsub double %128, %76
%130 = fmul double %129, %129
%131 = tail call double @llvm.fmuladd.f64(double %127, double %127, double %130)
%132 = load double, double* %44
%133 = fsub double %132, %66
%134 = tail call double @llvm.fmuladd.f64(double %133, double %133, double %131)
%135 = tail call double @sqrt(double %134)
%136 = load double, double* %26
%137 = fsub double %136, %59
%138 = load double, double* %37
%139 = fsub double %138, %76
%140 = fmul double %139, %139
%141 = tail call double @llvm.fmuladd.f64(double %137, double %137, double %140)
%142 = load double, double* %44
%143 = fsub double %142, %66
%144 = tail call double @llvm.fmuladd.f64(double %143, double %143, double %141)
%145 = tail call double @sqrt(double %144)
%146 = load double, double* %26
%147 = fsub double %146, %59
%148 = load double, double* %37
%149 = fsub double %148, %79
%150 = fmul double %149, %149
%151 = tail call double @llvm.fmuladd.f64(double %147, double %147, double %150)
%152 = load double, double* %44
%153 = fsub double %152, %66
%154 = tail call double @llvm.fmuladd.f64(double %153, double %153, double %151)
%155 = tail call double @sqrt(double %154)
%156 = load double, double* %26
%157 = fsub double %156, %56
%158 = load double, double* %37
%159 = fsub double %158, %79
%160 = fmul double %159, %159
%161 = tail call double @llvm.fmuladd.f64(double %157, double %157, double %160)
%162 = load double, double* %44
%163 = fsub double %162, %66
%164 = tail call double @llvm.fmuladd.f64(double %163, double %163, double %161)
%165 = tail call double @sqrt(double %164)
%166 = load double, double* %26
%167 = fsub double %166, %56
%168 = load double, double* %37
%169 = fsub double %168, %76
%170 = fmul double %169, %169
%171 = tail call double @llvm.fmuladd.f64(double %167, double %167, double %170)
%172 = load double, double* %44
%173 = fsub double %172, %69
%174 = tail call double @llvm.fmuladd.f64(double %173, double %173, double %171)
%175 = tail call double @sqrt(double %174)
%176 = load double, double* %26
%177 = fsub double %176, %59
%178 = load double, double* %37
%179 = fsub double %178, %76
%180 = fmul double %179, %179
%181 = tail call double @llvm.fmuladd.f64(double %177, double %177, double %180)
%182 = load double, double* %44
%183 = fsub double %182, %69
%184 = tail call double @llvm.fmuladd.f64(double %183, double %183, double %181)
%185 = tail call double @sqrt(double %184)
%186 = load double, double* %26
%187 = fsub double %186, %59
%188 = load double, double* %37
%189 = fsub double %188, %79
%190 = fmul double %189, %189
%191 = tail call double @llvm.fmuladd.f64(double %187, double %187, double %190)
%192 = load double, double* %44
%193 = fsub double %192, %69
%194 = tail call double @llvm.fmuladd.f64(double %193, double %193, double %191)
%195 = tail call double @sqrt(double %194)
%196 = load double, double* %26
%197 = fsub double %196, %56
%198 = load double, double* %37
%199 = fsub double %198, %79
%200 = fmul double %199, %199
%201 = tail call double @llvm.fmuladd.f64(double %197, double %197, double %200)
%202 = load double, double* %44
%203 = fsub double %202, %69
%204 = tail call double @llvm.fmuladd.f64(double %203, double %203, double %201)
%205 = tail call double @sqrt(double %204)
%206 = fadd double %135, 1.000000e-08
%207 = fdiv double 1.000000e+00, %206
%208 = fadd double %207, 0.000000e+00
%209 = fadd double %145, 1.000000e-08
%210 = fdiv double 1.000000e+00, %209
%211 = fadd double %208, %210
%212 = fadd double %155, 1.000000e-08
%213 = fdiv double 1.000000e+00, %212
%214 = fadd double %211, %213
%215 = fadd double %165, 1.000000e-08
%216 = fdiv double 1.000000e+00, %215
%217 = fadd double %214, %216
%218 = fadd double %175, 1.000000e-08
%219 = fdiv double 1.000000e+00, %218
%220 = fadd double %217, %219
%221 = fadd double %185, 1.000000e-08
%222 = fdiv double 1.000000e+00, %221
%223 = fadd double %220, %222
%224 = fadd double %195, 1.000000e-08
%225 = fdiv double 1.000000e+00, %224
%226 = fadd double %223, %225
%227 = fadd double %205, 1.000000e-08
%228 = fdiv double 1.000000e+00, %227
%229 = fadd double %226, %228
%230 = fmul double %229, %206
%231 = fdiv double %90, %230
%232 = fadd double %231, 0.000000e+00
%233 = fmul double %229, %209
%234 = fdiv double %94, %233
%235 = fadd double %232, %234
%236 = fmul double %229, %212
%237 = fdiv double %100, %236
%238 = fadd double %235, %237
%239 = fmul double %229, %215
%240 = fdiv double %104, %239
%241 = fadd double %238, %240
%242 = fmul double %229, %218
%243 = fdiv double %111, %242
%244 = fadd double %241, %243
%245 = fmul double %229, %221
%246 = fdiv double %115, %245
%247 = fadd double %244, %246
%248 = fmul double %229, %224
%249 = fdiv double %121, %248
%250 = fadd double %247, %249
%251 = fmul double %229, %227
%252 = fdiv double %125, %251
%253 = fadd double %250, %252
%254 = fdiv double %48, %28
%255 = icmp eq i32 %3, 3
%256 = icmp sgt i32 %5, 0
%257 = and i1 %255, %256
br i1 %257, label %258, label %284
258: ; preds = %31
%259 = zext i32 %5 to i64
br label %260
260: ; preds = %258, %280
%261 = phi i64 [ 0, %258 ], [ %282, %280 ]
%262 = phi double [ %4, %258 ], [ %281, %280 ]
%263 = mul nuw nsw i64 %261, 3
%264 = getelementptr inbounds double, double* %6, i64 %263
%265 = load double, double* %264
%266 = fsub double %253, %265
%267 = tail call double @llvm.fabs.f64(double %266)
%268 = add nuw nsw i64 %263, 1
%269 = getelementptr inbounds double, double* %6, i64 %268
%270 = load double, double* %269
%271 = fcmp olt double %267, %270
br i1 %271, label %272, label %280
272: ; preds = %260
%273 = add nuw nsw i64 %263, 2
%274 = getelementptr inbounds double, double* %6, i64 %273
%275 = load double, double* %274
%276 = fsub double %270, %267
%277 = fmul double %276, %275
%278 = fdiv double %277, %270
%279 = fadd double %262, %278
br label %280
280: ; preds = %260, %272
%281 = phi double [ %279, %272 ], [ %262, %260 ]
%282 = add nuw nsw i64 %261, 1
%283 = icmp eq i64 %282, %259
br i1 %283, label %284, label %260
284: ; preds = %280, %31
%285 = phi double [ %4, %31 ], [ %281, %280 ]
%286 = icmp ne i32 %3, 4
%287 = xor i1 %256, true
%288 = or i1 %286, %287
%289 = select i1 %286, double %285, double %4
br i1 %288, label %353, label %290
290: ; preds = %284
%291 = zext i32 %5 to i64
%292 = and i64 %291, 1
%293 = icmp eq i32 %5, 1
br i1 %293, label %334, label %294
294: ; preds = %290
%295 = and i64 %291, 4294967294
br label %296
296: ; preds = %329, %294
%297 = phi i64 [ 0, %294 ], [ %331, %329 ]
%298 = phi double [ %4, %294 ], [ %330, %329 ]
%299 = phi i64 [ 0, %294 ], [ %332, %329 ]
%300 = mul nuw nsw i64 %297, 3
%301 = getelementptr inbounds double, double* %6, i64 %300
%302 = load double, double* %301
%303 = fcmp ult double %253, %302
br i1 %303, label %313, label %304
304: ; preds = %296
%305 = or i64 %300, 1
%306 = getelementptr inbounds double, double* %6, i64 %305
%307 = load double, double* %306
%308 = fcmp ugt double %253, %307
br i1 %308, label %313, label %309
309: ; preds = %304
%310 = add nuw nsw i64 %300, 2
%311 = getelementptr inbounds double, double* %6, i64 %310
%312 = load double, double* %311
br label %313
313: ; preds = %296, %304, %309
%314 = phi double [ %312, %309 ], [ %298, %304 ], [ %298, %296 ]
%315 = or i64 %297, 1
%316 = mul nuw nsw i64 %315, 3
%317 = getelementptr inbounds double, double* %6, i64 %316
%318 = load double, double* %317
%319 = fcmp ult double %253, %318
br i1 %319, label %329, label %320
320: ; preds = %313
%321 = add nuw nsw i64 %316, 1
%322 = getelementptr inbounds double, double* %6, i64 %321
%323 = load double, double* %322
%324 = fcmp ugt double %253, %323
br i1 %324, label %329, label %325
325: ; preds = %320
%326 = add nuw nsw i64 %316, 2
%327 = getelementptr inbounds double, double* %6, i64 %326
%328 = load double, double* %327
br label %329
329: ; preds = %325, %320, %313
%330 = phi double [ %328, %325 ], [ %314, %320 ], [ %314, %313 ]
%331 = add nuw nsw i64 %297, 2
%332 = add i64 %299, 2
%333 = icmp eq i64 %332, %295
br i1 %333, label %334, label %296
334: ; preds = %329, %290
%335 = phi double [ undef, %290 ], [ %330, %329 ]
%336 = phi i64 [ 0, %290 ], [ %331, %329 ]
%337 = phi double [ %4, %290 ], [ %330, %329 ]
%338 = icmp eq i64 %292, 0
br i1 %338, label %353, label %339
339: ; preds = %334
%340 = mul nuw nsw i64 %336, 3
%341 = getelementptr inbounds double, double* %6, i64 %340
%342 = load double, double* %341
%343 = fcmp ult double %253, %342
br i1 %343, label %353, label %344
344: ; preds = %339
%345 = add nuw nsw i64 %340, 1
%346 = getelementptr inbounds double, double* %6, i64 %345
%347 = load double, double* %346
%348 = fcmp ugt double %253, %347
br i1 %348, label %353, label %349
349: ; preds = %344
%350 = add nuw nsw i64 %340, 2
%351 = getelementptr inbounds double, double* %6, i64 %350
%352 = load double, double* %351
br label %353
353: ; preds = %334, %349, %344, %339, %284
%354 = phi double [ %289, %284 ], [ %335, %334 ], [ %352, %349 ], [ %337, %344 ], [ %337, %339 ]
switch i32 %1, label %415 [
i32 1, label %355
i32 2, label %362
i32 3, label %372
]
355: ; preds = %353
%356 = fsub double %20, %19
%357 = tail call double @llvm.fabs.f64(double %356)
%358 = fcmp ogt double %357, 1.000000e-08
br i1 %358, label %359, label %415
359: ; preds = %355
%360 = fsub double %253, %19
%361 = fdiv double %360, %356
br label %415
362: ; preds = %353
%363 = load double, double* %2
%364 = getelementptr inbounds double, double* %2, i64 1
%365 = load double, double* %364
%366 = fsub double %365, %363
%367 = tail call double @llvm.fabs.f64(double %366)
%368 = fcmp ogt double %367, 1.000000e-08
br i1 %368, label %369, label %415
369: ; preds = %362
%370 = fsub double %253, %363
%371 = fdiv double %370, %366
br label %415
372: ; preds = %353
%373 = load double, double* %2
%374 = fcmp olt double %253, %373
br i1 %374, label %415, label %375
375: ; preds = %372
%376 = shl nsw i32 %8, 1
%377 = sext i32 %376 to i64
%378 = getelementptr inbounds double, double* %2, i64 %377
%379 = load double, double* %378
%380 = fcmp ogt double %253, %379
br i1 %380, label %415, label %381
381: ; preds = %375
%382 = icmp slt i32 %8, 1
br i1 %382, label %415, label %383
383: ; preds = %381
%384 = add nuw i32 %8, 1
%385 = zext i32 %384 to i64
br label %386
386: ; preds = %383, %412
%387 = phi i64 [ 1, %383 ], [ %413, %412 ]
%388 = shl nuw nsw i64 %387, 1
%389 = getelementptr inbounds double, double* %2, i64 %388
%390 = load double, double* %389
%391 = fcmp ugt double %253, %390
br i1 %391, label %412, label %392
392: ; preds = %386
%393 = add nsw i64 %388, -2
%394 = getelementptr inbounds double, double* %2, i64 %393
%395 = load double, double* %394
%396 = fcmp ogt double %253, %395
br i1 %396, label %397, label %412
397: ; preds = %392
%398 = fsub double %253, %395
%399 = fsub double %390, %395
%400 = fdiv double %398, %399
%401 = and i64 %388, 4294967294
%402 = or i64 %401, 1
%403 = getelementptr inbounds double, double* %2, i64 %402
%404 = load double, double* %403
%405 = shl i64 %387, 33
%406 = add i64 %405, -4294967296
%407 = ashr exact i64 %406, 32
%408 = getelementptr inbounds double, double* %2, i64 %407
%409 = load double, double* %408
%410 = fsub double %404, %409
%411 = tail call double @llvm.fmuladd.f64(double %400, double %410, double %409)
br label %415
412: ; preds = %386, %392
%413 = add nuw nsw i64 %387, 1
%414 = icmp eq i64 %413, %385
br i1 %414, label %415, label %386
415: ; preds = %412, %381, %353, %359, %355, %369, %362, %375, %372, %397
%416 = phi double [ %411, %397 ], [ 0.000000e+00, %372 ], [ 1.000000e+00, %375 ], [ %253, %362 ], [ %371, %369 ], [ %253, %355 ], [ %361, %359 ], [ %253, %353 ], [ %253, %381 ], [ %253, %412 ]
%417 = insertelement <2 x double> poison, double %416, i64 0
%418 = shufflevector <2 x double> %417, <2 x double> poison, <2 x i32> zeroinitializer
switch i32 %9, label %490 [
i32 1, label %419
i32 2, label %449
]
419: ; preds = %415
%420 = fcmp olt double %416, 0.000000e+00
%421 = select i1 %420, double 0.000000e+00, double %416
%422 = fcmp ogt double %421, 1.000000e+00
%423 = select i1 %422, double 1.000000e+00, double %421
%424 = fcmp ugt double %423, 2.500000e-01
br i1 %424, label %428, label %425
425: ; preds = %419
%426 = fmul double %423, 4.000000e+00
%427 = insertelement <2 x double> <double 0.000000e+00, double poison>, double %426, i64 1
br label %490
428: ; preds = %419
%429 = fcmp ogt double %423, 2.500000e-01
%430 = fcmp ole double %423, 5.000000e-01
%431 = and i1 %429, %430
br i1 %431, label %432, label %435
432: ; preds = %428
%433 = fsub double 5.000000e-01, %423
%434 = fmul double %433, 4.000000e+00
br label %490
435: ; preds = %428
%436 = fcmp ogt double %423, 5.000000e-01
%437 = fcmp ole double %423, 7.500000e-01
%438 = and i1 %436, %437
br i1 %438, label %439, label %443
439: ; preds = %435
%440 = fadd double %423, -5.000000e-01
%441 = fmul double %440, 4.000000e+00
%442 = insertelement <2 x double> <double poison, double 1.000000e+00>, double %441, i64 0
br label %490
443: ; preds = %435
%444 = fcmp ogt double %423, 7.500000e-01
br i1 %444, label %445, label %490
445: ; preds = %443
%446 = fsub double 1.000000e+00, %423
%447 = fmul double %446, 4.000000e+00
%448 = insertelement <2 x double> <double 1.000000e+00, double poison>, double %447, i64 1
br label %490
449: ; preds = %415
%450 = fcmp olt double %416, 0.000000e+00
%451 = select i1 %450, double 0.000000e+00, double %416
%452 = fcmp ogt double %451, 1.000000e+00
%453 = select i1 %452, double 1.000000e+00, double %451
%454 = fcmp ugt double %453, 2.000000e-01
br i1 %454, label %459, label %455
455: ; preds = %449
%456 = fsub double 2.000000e-01, %453
%457 = fmul double %456, 5.000000e+00
%458 = insertelement <2 x double> <double poison, double 0.000000e+00>, double %457, i64 0
br label %490
459: ; preds = %449
%460 = fcmp ogt double %453, 2.000000e-01
%461 = fcmp ole double %453, 4.000000e-01
%462 = and i1 %460, %461
br i1 %462, label %463, label %467
463: ; preds = %459
%464 = fadd double %453, -2.000000e-01
%465 = fmul double %464, 5.000000e+00
%466 = insertelement <2 x double> <double 0.000000e+00, double poison>, double %465, i64 1
br label %490
467: ; preds = %459
%468 = fcmp ogt double %453, 4.000000e-01
%469 = fcmp ole double %453, 6.000000e-01
%470 = and i1 %468, %469
br i1 %470, label %471, label %475
471: ; preds = %467
%472 = fadd double %453, -4.000000e-01
%473 = fneg double %472
%474 = tail call double @llvm.fmuladd.f64(double %473, double 5.000000e+00, double 1.000000e+00)
br label %490
475: ; preds = %467
%476 = fcmp ogt double %453, 6.000000e-01
%477 = fcmp ole double %453, 8.000000e-01
%478 = and i1 %476, %477
br i1 %478, label %479, label %483
479: ; preds = %475
%480 = fadd double %453, -6.000000e-01
%481 = fmul double %480, 5.000000e+00
%482 = insertelement <2 x double> <double poison, double 1.000000e+00>, double %481, i64 0
br label %490
483: ; preds = %475
%484 = fcmp ogt double %453, 0.000000e+00
br i1 %484, label %485, label %490
485: ; preds = %483
%486 = fadd double %453, -8.000000e-01
%487 = fneg double %486
%488 = tail call double @llvm.fmuladd.f64(double %487, double 5.000000e+00, double 1.000000e+00)
%489 = insertelement <2 x double> <double 1.000000e+00, double poison>, double %488, i64 1
br label %490
490: ; preds = %415, %463, %479, %485, %483, %471, %455, %425, %439, %445, %443, %432
%491 = phi double [ 1.000000e+00, %425 ], [ %434, %432 ], [ 0.000000e+00, %439 ], [ 0.000000e+00, %445 ], [ undef, %443 ], [ 1.000000e+00, %455 ], [ 1.000000e+00, %463 ], [ %474, %471 ], [ 0.000000e+00, %479 ], [ 0.000000e+00, %485 ], [ undef, %483 ], [ %416, %415 ]
%492 = phi <2 x double> [ %427, %425 ], [ <double 0.000000e+00, double 1.000000e+00>, %432 ], [ %442, %439 ], [ %448, %445 ], [ undef, %443 ], [ %458, %455 ], [ %466, %463 ], [ <double 0.000000e+00, double 1.000000e+00>, %471 ], [ %482, %479 ], [ %489, %485 ], [ undef, %483 ], [ %418, %415 ]
%493 = load double, double* %12
%494 = getelementptr inbounds double, double* %18, i64 3
%495 = load double, double* %494
%496 = fcmp olt double %495, 0x3FEFAE147AE147AE
br i1 %496, label %497, label %527
497: ; preds = %490
%498 = fmul double %491, %493
%499 = tail call double @llvm.fmuladd.f64(double %498, double %254, double 0.000000e+00)
%500 = insertelement <2 x double> poison, double %493, i64 0
%501 = shufflevector <2 x double> %500, <2 x double> poison, <2 x i32> zeroinitializer
%502 = fmul <2 x double> %492, %501
%503 = insertelement <2 x double> poison, double %254, i64 0
%504 = shufflevector <2 x double> %503, <2 x double> poison, <2 x i32> zeroinitializer
%505 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %502, <2 x double> %504, <2 x double> zeroinitializer)
%506 = insertelement <2 x double> poison, double %354, i64 0
%507 = shufflevector <2 x double> %506, <2 x double> poison, <2 x i32> zeroinitializer
%508 = fmul <2 x double> %507, %505
%509 = fsub double 1.000000e+00, %495
%510 = bitcast double* %18 to <2 x double>*
%511 = load <2 x double>, <2 x double>* %510
%512 = insertelement <2 x double> poison, double %509, i64 0
%513 = shufflevector <2 x double> %512, <2 x double> poison, <2 x i32> zeroinitializer
%514 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %508, <2 x double> %513, <2 x double> %511)
%515 = bitcast double* %18 to <2 x double>*
store <2 x double> %514, <2 x double>* %515
%516 = getelementptr inbounds double, double* %18, i64 2
%517 = load double, double* %516
%518 = insertelement <2 x double> poison, double %499, i64 0
%519 = insertelement <2 x double> %518, double %509, i64 1
%520 = fmul <2 x double> %507, %519
%521 = insertelement <2 x double> poison, double %254, i64 1
%522 = insertelement <2 x double> %521, double %509, i64 0
%523 = insertelement <2 x double> poison, double %517, i64 0
%524 = insertelement <2 x double> %523, double %495, i64 1
%525 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %520, <2 x double> %522, <2 x double> %524)
%526 = bitcast double* %516 to <2 x double>*
store <2 x double> %525, <2 x double>* %526
br label %527
527: ; preds = %497, %490
ret void
}