#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 cos(double);
double sin(double);
void view_parameter_define(int ii, int num_of_frames, int rotate_style,
                           double view_point_d[3], double screen_point[3],
                           double up[3], int num_of_lights, double *light_point,
                           double trange[6]) {
  int i, j;
  double center[3], t[3], angle, tminx, tmaxx, tminy, tmaxy, tminz, tmaxz;
  for (i = 0; i < 3; i++)
    center[i] = (trange[i * 2] + trange[i * 2 + 1]) / 2.0;
  angle = 2.0 * 3.1415926 / (double)num_of_frames;
  if (rotate_style != 0) {
    if (rotate_style == 1) {
      up[0] = 1.0;
      up[1] = 0.0;
      up[2] = 0.0;
      for (i = 0; i < 3; i++)
        t[i] = view_point_d[i] - center[i];
      view_point_d[0] = t[0];
      view_point_d[1] = t[1] * cos(angle) + t[2] * sin(angle);
      view_point_d[2] = -t[1] * sin(angle) + t[2] * cos(angle);
      for (i = 0; i < 3; i++)
        view_point_d[i] += center[i];
      for (j = 0; j < num_of_lights; j++) {
        for (i = 0; i < 3; i++)
          t[i] = light_point[j * 3 + i] - center[i];
        light_point[j * 3 + 0] = t[0];
        light_point[j * 3 + 1] = t[1] * cos(angle) + t[2] * sin(angle);
        light_point[j * 3 + 2] = -t[1] * sin(angle) + t[2] * cos(angle);
        for (i = 0; i < 3; i++)
          light_point[j * 3 + i] += center[i];
      }
      for (i = 0; i < 3; i++)
        t[i] = up[i];
      up[0] = t[0];
      up[1] = t[1] * cos(angle) + t[2] * sin(angle);
      up[2] = -t[1] * sin(angle) + t[2] * cos(angle);
    }
    if (rotate_style == 2) {
      up[0] = 0.0;
      up[1] = 1.0;
      up[2] = 0.0;
      for (i = 0; i < 3; i++)
        t[i] = view_point_d[i] - center[i];
      view_point_d[0] = t[0] * cos(angle) + t[2] * sin(angle);
      view_point_d[1] = t[1];
      view_point_d[2] = -t[0] * sin(angle) + t[2] * cos(angle);
      for (i = 0; i < 3; i++)
        view_point_d[i] += center[i];
      for (j = 0; j < num_of_lights; j++) {
        for (i = 0; i < 3; i++)
          t[i] = light_point[j * 3 + i] - center[i];
        light_point[j * 3 + 0] = t[0] * cos(angle) + t[2] * sin(angle);
        light_point[j * 3 + 1] = t[1];
        light_point[j * 3 + 2] = -t[0] * sin(angle) + t[2] * cos(angle);
        for (i = 0; i < 3; i++)
          light_point[j * 3 + i] += center[i];
      }
      for (i = 0; i < 3; i++)
        t[i] = up[i];
      up[0] = t[0] * cos(angle) + t[2] * sin(angle);
      up[1] = t[1];
      up[2] = -t[0] * sin(angle) + t[2] * cos(angle);
    }
    if (rotate_style == 3) {
      for (i = 0; i < 3; i++)
        t[i] = view_point_d[i] - center[i];
      view_point_d[0] = t[0] * cos(angle) + t[1] * sin(angle);
      view_point_d[1] = -t[0] * sin(angle) + t[1] * cos(angle);
      view_point_d[2] = t[2];
      for (i = 0; i < 3; i++)
        view_point_d[i] += center[i];
      for (j = 0; j < num_of_lights; j++) {
        for (i = 0; i < 3; i++)
          t[i] = light_point[j * 3 + i] - center[i];
        light_point[j * 3 + 0] = t[0] * cos(angle) + t[1] * sin(angle);
        light_point[j * 3 + 1] = -t[0] * sin(angle) + t[1] * cos(angle);
        light_point[j * 3 + 2] = t[2];
        for (i = 0; i < 3; i++)
          light_point[j * 3 + i] += center[i];
      }
      for (i = 0; i < 3; i++)
        t[i] = up[i];
      up[0] = t[0] * cos(angle) + t[1] * sin(angle);
      up[1] = -t[0] * sin(angle) + t[1] * cos(angle);
      up[2] = t[2];
    }
    if (rotate_style == 4) {
      if (ii > 0) {
        tminx = trange[0];
        tmaxx = trange[1];
        tminy = trange[2];
        tmaxy = trange[3];
        tminz = trange[4];
        tmaxz = trange[5];
        for (i = 0; i < 3; i++)
          screen_point[i] = center[i];
        num_of_lights = 1;
        if (ii == 1) {
          view_point_d[0] = (tminx + tmaxx) / 2.0;
          view_point_d[1] = tmaxy + 1.5 * (tmaxy - tminy);
          view_point_d[2] = tmaxz + 1.5 * (tmaxz - tminz);
          light_point[0] = (tminx + tmaxx) / 2.0;
          light_point[1] = tmaxy + 0.1 * (tmaxy - tminy);
          light_point[2] = tmaxz + (tmaxz - tminz) * 2.0;
          up[0] = 0.0;
          up[1] = 0.0;
          up[2] = 1.0;
        } else if (ii == 2) {
          view_point_d[0] = (tminx + tmaxx) / 2.0;
          view_point_d[1] = tmaxy + 1.5 * (tmaxy - tminy);
          view_point_d[2] = (tmaxz + tminz) / 2.0;
          light_point[0] = (tminx + tmaxx) / 2.0;
          light_point[1] = tmaxy + 0.1 * (tmaxy - tminy);
          light_point[2] = tmaxz + (tmaxz - tminz) * 0.5;
          up[0] = 0.0;
          up[1] = 0.0;
          up[2] = 1.0;
        } else if (ii == 3) {
          view_point_d[0] = (tminx + tmaxx) / 2.0;
          view_point_d[1] = tmaxy + 1.5 * (tmaxy - tminy);
          view_point_d[2] = tminz - 1.5 * (tmaxz - tminz);
          light_point[0] = (tminx + tmaxx) / 2.0;
          light_point[1] = tmaxy + 0.1 * (tmaxy - tminy);
          light_point[2] = tminz - (tmaxz - tminz) * 2.0;
          up[0] = 0.0;
          up[1] = 0.0;
          up[2] = 1.0;
        } else if (ii == 4) {
          view_point_d[0] = (tminx + tmaxx) / 2.0;
          view_point_d[1] = 0.5 * (tmaxy + tminy);
          view_point_d[2] = tmaxz + 1.5 * (tmaxz - tminz);
          light_point[0] = (tminx + tmaxx) / 2.0;
          light_point[1] = 0.7 * (tmaxy + tminy);
          light_point[2] = tmaxz + (tmaxz - tminz) * 2.0;
          up[0] = 0.0;
          up[1] = -1.0;
          up[2] = 0.0;
        } else if (ii == 5) {
          view_point_d[0] = tmaxx + 1.5 * (tmaxx - tminx);
          view_point_d[1] = 0.5 * (tmaxy + tminy);
          view_point_d[2] = tmaxz + 1.5 * (tmaxz - tminz);
          light_point[0] = tmaxx + 0.5 * (tmaxx - tminx);
          light_point[1] = 0.5 * (tmaxy + tminy);
          light_point[2] = tmaxz + (tmaxz - tminz) * 2.0;
          up[0] = 0.0;
          up[1] = 0.0;
          up[2] = 1.0;
        } else if (ii == 6) {
          view_point_d[0] = tminx - 1.5 * (tmaxx - tminx);
          view_point_d[1] = 0.5 * (tmaxy + tminy);
          view_point_d[2] = tmaxz + 1.5 * (tmaxz - tminz);
          light_point[0] = tminx - 0.5 * (tmaxx - tminx);
          light_point[1] = 0.5 * (tmaxy + tminy);
          light_point[2] = tmaxz + (tmaxz - tminz) * 2.0;
          up[0] = 0.0;
          up[1] = 0.0;
          up[2] = 1.0;
        } else if (ii == 7) {
          view_point_d[0] = (tmaxx + tminx) / 2.0;
          view_point_d[1] = tminy - 1.5 * (tmaxy - tminy);
          view_point_d[2] = tmaxz + 1.5 * (tmaxz - tminz);
          light_point[0] = (tmaxx + tminx) / 2.0;
          light_point[1] = tminy - 0.5 * (tmaxy - tminy);
          light_point[2] = tmaxz + (tmaxz - tminz) * 2.0;
          up[0] = 0.0;
          up[1] = 0.0;
          up[2] = 1.0;
        }
      }
    }
  }
  return;
}


x86 assembly (clang, -O0):
<view_parameter_define>:
push   %rbp
mov    %rsp,%rbp
sub    $0x260,%rsp
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%eax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
cmpl   $0x3,-0x2c(%rbp)
jge    11a7 <view_parameter_define+0x87>
mov    0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  0x1e8d(%rip),%xmm1
divsd  %xmm1,%xmm0
movslq -0x2c(%rbp),%rax
movsd  %xmm0,-0x50(%rbp,%rax,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1152 <view_parameter_define+0x32>
cvtsi2sdl -0x8(%rbp),%xmm1
movsd  0x1e4c(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
cmpl   $0x0,-0xc(%rbp)
je     285f <view_parameter_define+0x173f>
cmpl   $0x1,-0xc(%rbp)
jne    1646 <view_parameter_define+0x526>
mov    -0x28(%rbp),%rax
movsd  0x1e2b(%rip),%xmm0
movsd  %xmm0,(%rax)
mov    -0x28(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x8(%rax)
mov    -0x28(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x10(%rax)
movl   $0x0,-0x2c(%rbp)
cmpl   $0x3,-0x2c(%rbp)
jge    1239 <view_parameter_define+0x119>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x2c(%rbp),%rax
subsd  -0x50(%rbp,%rax,8),%xmm0
movslq -0x2c(%rbp),%rax
movsd  %xmm0,-0x70(%rbp,%rax,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1200 <view_parameter_define+0xe0>
movsd  -0x70(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
call   1040 <cos@plt>
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
call   1030 <sin@plt>
movsd  -0xd8(%rbp),%xmm1
ff
movsd  -0xd0(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0xc8(%rbp),%xmm0
ff
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0x68(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
call   1040 <cos@plt>
movsd  -0xc0(%rbp),%xmm1
movsd  -0xb8(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0xb0(%rbp),%xmm0
ff
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x10(%rax)
movl   $0x0,-0x2c(%rbp)
cmpl   $0x3,-0x2c(%rbp)
jge    1364 <view_parameter_define+0x244>
movslq -0x2c(%rbp),%rax
movsd  -0x50(%rbp,%rax,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1330 <view_parameter_define+0x210>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1520 <view_parameter_define+0x400>
movl   $0x0,-0x2c(%rbp)
cmpl   $0x3,-0x2c(%rbp)
jge    13bd <view_parameter_define+0x29d>
mov    0x18(%rbp),%rax
imul   $0x3,-0x30(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x2c(%rbp),%rax
subsd  -0x50(%rbp,%rax,8),%xmm0
movslq -0x2c(%rbp),%rax
movsd  %xmm0,-0x70(%rbp,%rax,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    137e <view_parameter_define+0x25e>
movsd  -0x70(%rbp),%xmm0
mov    0x18(%rbp),%rax
imul   $0x3,-0x30(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
call   1040 <cos@plt>
movsd  %xmm0,-0x100(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x108(%rbp)
movsd  -0x78(%rbp),%xmm0
call   1030 <sin@plt>
movsd  -0x108(%rbp),%xmm1
ff
movsd  -0x100(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0xf8(%rbp),%xmm0
ff
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
imul   $0x3,-0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
call   1040 <cos@plt>
movsd  -0xf0(%rbp),%xmm1
ff
movsd  -0xe8(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0xe0(%rbp),%xmm0
ff
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
imul   $0x3,-0x30(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x2c(%rbp)
cmpl   $0x3,-0x2c(%rbp)
jge    150d <view_parameter_define+0x3ed>
movslq -0x2c(%rbp),%rax
movsd  -0x50(%rbp,%rax,8),%xmm0
mov    0x18(%rbp),%rax
imul   $0x3,-0x30(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    14d3 <view_parameter_define+0x3b3>
jmp    1512 <view_parameter_define+0x3f2>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    136b <view_parameter_define+0x24b>
movl   $0x0,-0x2c(%rbp)
cmpl   $0x3,-0x2c(%rbp)
jge    1556 <view_parameter_define+0x436>
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x2c(%rbp),%rax
movsd  %xmm0,-0x70(%rbp,%rax,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1527 <view_parameter_define+0x407>
movsd  -0x70(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
call   1040 <cos@plt>
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
call   1030 <sin@plt>
movsd  -0x138(%rbp),%xmm1
ff
movsd  -0x130(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0x128(%rbp),%xmm0
ff
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0x68(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,-0x118(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
call   1040 <cos@plt>
movsd  -0x120(%rbp),%xmm1
ff
movsd  -0x118(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0x110(%rbp),%xmm0
ff
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movsd  %xmm0,0x10(%rax)
cmpl   $0x2,-0xc(%rbp)
jne    1ac5 <view_parameter_define+0x9a5>
mov    -0x28(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
mov    -0x28(%rbp),%rax
movsd  0x19a1(%rip),%xmm0
movsd  %xmm0,0x8(%rax)
mov    -0x28(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x10(%rax)
movl   $0x0,-0x2c(%rbp)
cmpl   $0x3,-0x2c(%rbp)
jge    16b8 <view_parameter_define+0x598>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x2c(%rbp),%rax
subsd  -0x50(%rbp,%rax,8),%xmm0
movslq -0x2c(%rbp),%rax
movsd  %xmm0,-0x70(%rbp,%rax,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    167f <view_parameter_define+0x55f>
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x158(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
call   1040 <cos@plt>
movsd  %xmm0,-0x160(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x168(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
call   1030 <sin@plt>
movsd  -0x168(%rbp),%xmm1
ff
movsd  -0x160(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0x158(%rbp),%xmm0
ff
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x68(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0x70(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,-0x148(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
call   1040 <cos@plt>
movsd  -0x150(%rbp),%xmm1
ff
movsd  -0x148(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0x140(%rbp),%xmm0
ff
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x10(%rax)
movl   $0x0,-0x2c(%rbp)
cmpl   $0x3,-0x2c(%rbp)
jge    17e3 <view_parameter_define+0x6c3>
movslq -0x2c(%rbp),%rax
movsd  -0x50(%rbp,%rax,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    17af <view_parameter_define+0x68f>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    199f <view_parameter_define+0x87f>
movl   $0x0,-0x2c(%rbp)
cmpl   $0x3,-0x2c(%rbp)
jge    183c <view_parameter_define+0x71c>
mov    0x18(%rbp),%rax
imul   $0x3,-0x30(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x2c(%rbp),%rax
subsd  -0x50(%rbp,%rax,8),%xmm0
movslq -0x2c(%rbp),%rax
movsd  %xmm0,-0x70(%rbp,%rax,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    17fd <view_parameter_define+0x6dd>
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x188(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
call   1040 <cos@plt>
movsd  %xmm0,-0x190(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x198(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
call   1030 <sin@plt>
movsd  -0x198(%rbp),%xmm1
ff
movsd  -0x190(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0x188(%rbp),%xmm0
ff
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
imul   $0x3,-0x30(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
mov    0x18(%rbp),%rax
imul   $0x3,-0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x170(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,-0x178(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x180(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
call   1040 <cos@plt>
movsd  -0x180(%rbp),%xmm1
ff
movsd  -0x178(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0x170(%rbp),%xmm0
ff
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
imul   $0x3,-0x30(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x2c(%rbp)
cmpl   $0x3,-0x2c(%rbp)
jge    198c <view_parameter_define+0x86c>
movslq -0x2c(%rbp),%rax
movsd  -0x50(%rbp,%rax,8),%xmm0
mov    0x18(%rbp),%rax
imul   $0x3,-0x30(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1952 <view_parameter_define+0x832>
jmp    1991 <view_parameter_define+0x871>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    17ea <view_parameter_define+0x6ca>
movl   $0x0,-0x2c(%rbp)
cmpl   $0x3,-0x2c(%rbp)
jge    19d5 <view_parameter_define+0x8b5>
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x2c(%rbp),%rax
movsd  %xmm0,-0x70(%rbp,%rax,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    19a6 <view_parameter_define+0x886>
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x1b8(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
call   1040 <cos@plt>
movsd  %xmm0,-0x1c0(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x1c8(%rbp)
movsd  -0x78(%rbp),%xmm0
call   1030 <sin@plt>
movsd  -0x1c8(%rbp),%xmm1
ff
movsd  -0x1c0(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0x1b8(%rbp),%xmm0
ff
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x68(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0x70(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x1a0(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,-0x1a8(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x1b0(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
call   1040 <cos@plt>
movsd  -0x1b0(%rbp),%xmm1
ff
movsd  -0x1a8(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0x1a0(%rbp),%xmm0
ff
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movsd  %xmm0,0x10(%rax)
cmpl   $0x3,-0xc(%rbp)
jne    1f1c <view_parameter_define+0xdfc>
movl   $0x0,-0x2c(%rbp)
cmpl   $0x3,-0x2c(%rbp)
jge    1b0f <view_parameter_define+0x9ef>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x2c(%rbp),%rax
subsd  -0x50(%rbp,%rax,8),%xmm0
movslq -0x2c(%rbp),%rax
movsd  %xmm0,-0x70(%rbp,%rax,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1ad6 <view_parameter_define+0x9b6>
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x1e8(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
call   1040 <cos@plt>
movsd  %xmm0,-0x1f0(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x1f8(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
call   1030 <sin@plt>
movsd  -0x1f8(%rbp),%xmm1
ff
movsd  -0x1f0(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0x1e8(%rbp),%xmm0
ff
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x70(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x1d0(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,-0x1d8(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x1e0(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
call   1040 <cos@plt>
movsd  -0x1e0(%rbp),%xmm1
ff
movsd  -0x1d8(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0x1d0(%rbp),%xmm0
ff
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0x60(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x10(%rax)
movl   $0x0,-0x2c(%rbp)
cmpl   $0x3,-0x2c(%rbp)
jge    1c3a <view_parameter_define+0xb1a>
movslq -0x2c(%rbp),%rax
movsd  -0x50(%rbp,%rax,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1c06 <view_parameter_define+0xae6>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1df6 <view_parameter_define+0xcd6>
movl   $0x0,-0x2c(%rbp)
cmpl   $0x3,-0x2c(%rbp)
jge    1c93 <view_parameter_define+0xb73>
mov    0x18(%rbp),%rax
imul   $0x3,-0x30(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x2c(%rbp),%rax
subsd  -0x50(%rbp,%rax,8),%xmm0
movslq -0x2c(%rbp),%rax
movsd  %xmm0,-0x70(%rbp,%rax,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1c54 <view_parameter_define+0xb34>
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x218(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
call   1040 <cos@plt>
movsd  %xmm0,-0x220(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x228(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
call   1030 <sin@plt>
movsd  -0x228(%rbp),%xmm1
ff
movsd  -0x220(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0x218(%rbp),%xmm0
ff
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
imul   $0x3,-0x30(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x200(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,-0x208(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x210(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
call   1040 <cos@plt>
movsd  -0x210(%rbp),%xmm1
ff
movsd  -0x208(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0x200(%rbp),%xmm0
ff
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
imul   $0x3,-0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x60(%rbp),%xmm0
mov    0x18(%rbp),%rax
imul   $0x3,-0x30(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x2c(%rbp)
cmpl   $0x3,-0x2c(%rbp)
jge    1de3 <view_parameter_define+0xcc3>
movslq -0x2c(%rbp),%rax
movsd  -0x50(%rbp,%rax,8),%xmm0
mov    0x18(%rbp),%rax
imul   $0x3,-0x30(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1da9 <view_parameter_define+0xc89>
jmp    1de8 <view_parameter_define+0xcc8>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1c41 <view_parameter_define+0xb21>
movl   $0x0,-0x2c(%rbp)
cmpl   $0x3,-0x2c(%rbp)
jge    1e2c <view_parameter_define+0xd0c>
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x2c(%rbp),%rax
movsd  %xmm0,-0x70(%rbp,%rax,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1dfd <view_parameter_define+0xcdd>
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x248(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
call   1040 <cos@plt>
movsd  %xmm0,-0x250(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x258(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
call   1030 <sin@plt>
movsd  -0x258(%rbp),%xmm1
ff
movsd  -0x250(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0x248(%rbp),%xmm0
ff
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x70(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x230(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,-0x238(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x240(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
call   1040 <cos@plt>
movsd  -0x240(%rbp),%xmm1
ff
movsd  -0x238(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0x230(%rbp),%xmm0
ff
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0x60(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movsd  %xmm0,0x10(%rax)
cmpl   $0x4,-0xc(%rbp)
jne    285a <view_parameter_define+0x173a>
cmpl   $0x0,-0x4(%rbp)
jle    2855 <view_parameter_define+0x1735>
mov    0x20(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    0x20(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    0x20(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    0x20(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    0x20(%rbp),%rax
movsd  0x20(%rax),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    0x20(%rbp),%rax
movsd  0x28(%rax),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movl   $0x0,-0x2c(%rbp)
cmpl   $0x3,-0x2c(%rbp)
jge    1fc8 <view_parameter_define+0xea8>
movslq -0x2c(%rbp),%rax
movsd  -0x50(%rbp,%rax,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1f99 <view_parameter_define+0xe79>
movl   $0x1,0x10(%rbp)
cmpl   $0x1,-0x4(%rbp)
jne    2104 <view_parameter_define+0xfe4>
movsd  -0x80(%rbp),%xmm0
addsd  -0x88(%rbp),%xmm0
ff
movsd  0x102a(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x98(%rbp),%xmm1
movsd  -0x98(%rbp),%xmm0
subsd  -0x90(%rbp),%xmm0
ff
movsd  0x1006(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0xa8(%rbp),%xmm1
ff
movsd  -0xa8(%rbp),%xmm0
ff
subsd  -0xa0(%rbp),%xmm0
ff
movsd  0xfd5(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x10(%rax)
movsd  -0x80(%rbp),%xmm0
addsd  -0x88(%rbp),%xmm0
ff
movsd  0xfa7(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x98(%rbp),%xmm1
ff
movsd  -0x98(%rbp),%xmm0
ff
subsd  -0x90(%rbp),%xmm0
ff
movsd  0xfab(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0xa8(%rbp),%xmm1
ff
movsd  -0xa8(%rbp),%xmm0
ff
subsd  -0xa0(%rbp),%xmm0
ff
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
movsd  %xmm0,0x10(%rax)
mov    -0x28(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
mov    -0x28(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x8(%rax)
mov    -0x28(%rbp),%rax
movsd  0xf0e(%rip),%xmm0
movsd  %xmm0,0x10(%rax)
jmp    2850 <view_parameter_define+0x1730>
cmpl   $0x2,-0x4(%rbp)
jne    2235 <view_parameter_define+0x1115>
movsd  -0x80(%rbp),%xmm0
addsd  -0x88(%rbp),%xmm0
ff
movsd  0xef5(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x98(%rbp),%xmm1
ff
movsd  -0x98(%rbp),%xmm0
ff
subsd  -0x90(%rbp),%xmm0
ff
movsd  0xed1(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0xa8(%rbp),%xmm0
ff
addsd  -0xa0(%rbp),%xmm0
ff
movsd  0xea0(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x10(%rax)
movsd  -0x80(%rbp),%xmm0
addsd  -0x88(%rbp),%xmm0
ff
movsd  0xe7e(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x98(%rbp),%xmm1
ff
movsd  -0x98(%rbp),%xmm0
ff
subsd  -0x90(%rbp),%xmm0
ff
movsd  0xe82(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0xa8(%rbp),%xmm1
ff
movsd  -0xa8(%rbp),%xmm0
ff
subsd  -0xa0(%rbp),%xmm0
ff
movsd  0xe39(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
movsd  %xmm0,0x10(%rax)
mov    -0x28(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
mov    -0x28(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x8(%rax)
mov    -0x28(%rbp),%rax
movsd  0xddd(%rip),%xmm0
movsd  %xmm0,0x10(%rax)
jmp    284b <view_parameter_define+0x172b>
cmpl   $0x3,-0x4(%rbp)
jne    2381 <view_parameter_define+0x1261>
movsd  -0x80(%rbp),%xmm0
addsd  -0x88(%rbp),%xmm0
ff
movsd  0xdc4(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x98(%rbp),%xmm1
ff
movsd  -0x98(%rbp),%xmm0
ff
subsd  -0x90(%rbp),%xmm0
ff
movsd  0xda0(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0xa0(%rbp),%xmm1
ff
movsd  -0xa8(%rbp),%xmm0
ff
subsd  -0xa0(%rbp),%xmm0
ff
movsd  0xd77(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x10(%rax)
movsd  -0x80(%rbp),%xmm0
addsd  -0x88(%rbp),%xmm0
ff
movsd  0xd41(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x98(%rbp),%xmm1
ff
movsd  -0x98(%rbp),%xmm0
ff
subsd  -0x90(%rbp),%xmm0
ff
movsd  0xd45(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0xa0(%rbp),%xmm1
ff
movsd  -0xa8(%rbp),%xmm0
ff
subsd  -0xa0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
movsd  %xmm0,0x10(%rax)
mov    -0x28(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
mov    -0x28(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x8(%rax)
mov    -0x28(%rbp),%rax
movsd  0xc91(%rip),%xmm0
movsd  %xmm0,0x10(%rax)
jmp    2846 <view_parameter_define+0x1726>
cmpl   $0x4,-0x4(%rbp)
jne    249e <view_parameter_define+0x137e>
movsd  -0x80(%rbp),%xmm0
addsd  -0x88(%rbp),%xmm0
ff
movsd  0xc78(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x98(%rbp),%xmm1
ff
addsd  -0x90(%rbp),%xmm1
ff
movsd  0xc6c(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0xa8(%rbp),%xmm1
ff
movsd  -0xa8(%rbp),%xmm0
ff
subsd  -0xa0(%rbp),%xmm0
ff
movsd  0xc2f(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x10(%rax)
movsd  -0x80(%rbp),%xmm0
addsd  -0x88(%rbp),%xmm0
ff
movsd  0xc01(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x98(%rbp),%xmm1
ff
addsd  -0x90(%rbp),%xmm1
ff
movsd  0xc05(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0xa8(%rbp),%xmm1
ff
movsd  -0xa8(%rbp),%xmm0
ff
subsd  -0xa0(%rbp),%xmm0
ff
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
movsd  %xmm0,0x10(%rax)
mov    -0x28(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
mov    -0x28(%rbp),%rax
movsd  0xbb0(%rip),%xmm0
movsd  %xmm0,0x8(%rax)
mov    -0x28(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x10(%rax)
jmp    2841 <view_parameter_define+0x1721>
cmpl   $0x5,-0x4(%rbp)
jne    25d3 <view_parameter_define+0x14b3>
movsd  -0x88(%rbp),%xmm1
ff
movsd  -0x88(%rbp),%xmm0
ff
subsd  -0x80(%rbp),%xmm0
movsd  0xb5b(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x98(%rbp),%xmm1
ff
addsd  -0x90(%rbp),%xmm1
ff
movsd  0xb43(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0xa8(%rbp),%xmm1
ff
movsd  -0xa8(%rbp),%xmm0
ff
subsd  -0xa0(%rbp),%xmm0
ff
movsd  0xb06(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x10(%rax)
movsd  -0x88(%rbp),%xmm1
ff
movsd  -0x88(%rbp),%xmm0
ff
subsd  -0x80(%rbp),%xmm0
movsd  0xae8(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x98(%rbp),%xmm1
ff
addsd  -0x90(%rbp),%xmm1
ff
movsd  0xac0(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0xa8(%rbp),%xmm1
ff
movsd  -0xa8(%rbp),%xmm0
ff
subsd  -0xa0(%rbp),%xmm0
ff
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
movsd  %xmm0,0x10(%rax)
mov    -0x28(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
mov    -0x28(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x8(%rax)
mov    -0x28(%rbp),%rax
movsd  0xa3f(%rip),%xmm0
movsd  %xmm0,0x10(%rax)
jmp    283c <view_parameter_define+0x171c>
cmpl   $0x6,-0x4(%rbp)
jne    2702 <view_parameter_define+0x15e2>
movsd  -0x80(%rbp),%xmm1
movsd  -0x88(%rbp),%xmm0
ff
subsd  -0x80(%rbp),%xmm0
movsd  0xa31(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x98(%rbp),%xmm1
ff
addsd  -0x90(%rbp),%xmm1
ff
movsd  0xa11(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0xa8(%rbp),%xmm1
ff
movsd  -0xa8(%rbp),%xmm0
ff
subsd  -0xa0(%rbp),%xmm0
ff
movsd  0x9d4(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x10(%rax)
movsd  -0x80(%rbp),%xmm1
movsd  -0x88(%rbp),%xmm0
ff
subsd  -0x80(%rbp),%xmm0
movsd  0x999(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x98(%rbp),%xmm1
ff
addsd  -0x90(%rbp),%xmm1
ff
movsd  0x991(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0xa8(%rbp),%xmm1
ff
movsd  -0xa8(%rbp),%xmm0
ff
subsd  -0xa0(%rbp),%xmm0
ff
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
movsd  %xmm0,0x10(%rax)
mov    -0x28(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
mov    -0x28(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x8(%rax)
mov    -0x28(%rbp),%rax
movsd  0x910(%rip),%xmm0
movsd  %xmm0,0x10(%rax)
jmp    2837 <view_parameter_define+0x1717>
cmpl   $0x7,-0x4(%rbp)
jne    2832 <view_parameter_define+0x1712>
movsd  -0x88(%rbp),%xmm0
ff
addsd  -0x80(%rbp),%xmm0
movsd  0x8f7(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x90(%rbp),%xmm1
ff
movsd  -0x98(%rbp),%xmm0
ff
subsd  -0x90(%rbp),%xmm0
ff
movsd  0x8db(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0xa8(%rbp),%xmm1
ff
movsd  -0xa8(%rbp),%xmm0
ff
subsd  -0xa0(%rbp),%xmm0
ff
movsd  0x8a2(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x10(%rax)
movsd  -0x88(%rbp),%xmm0
ff
addsd  -0x80(%rbp),%xmm0
movsd  0x874(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x90(%rbp),%xmm1
ff
movsd  -0x98(%rbp),%xmm0
ff
subsd  -0x90(%rbp),%xmm0
ff
movsd  0x840(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0xa8(%rbp),%xmm1
ff
movsd  -0xa8(%rbp),%xmm0
ff
subsd  -0xa0(%rbp),%xmm0
ff
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
movsd  %xmm0,0x10(%rax)
mov    -0x28(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
mov    -0x28(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x8(%rax)
mov    -0x28(%rbp),%rax
movsd  0x7db(%rip),%xmm0
movsd  %xmm0,0x10(%rax)
jmp    2837 <view_parameter_define+0x1717>
jmp    283c <view_parameter_define+0x171c>
jmp    2841 <view_parameter_define+0x1721>
jmp    2846 <view_parameter_define+0x1726>
jmp    284b <view_parameter_define+0x172b>
jmp    2850 <view_parameter_define+0x1730>
jmp    2855 <view_parameter_define+0x1735>
jmp    285a <view_parameter_define+0x173a>
jmp    285f <view_parameter_define+0x173f>
add    $0x260,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<view_parameter_define>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
mov    0xc0(%rsp),%r12
movsd  (%r12),%xmm4
movhpd 0x18(%r12),%xmm4
movupd 0x8(%r12),%xmm0
addpd  %xmm0,%xmm4
mulpd  0xeaa(%rip),%xmm4
mov    %r9,%r14
mov    %r8,0x70(%rsp)
mov    %rcx,%r13
movsd  0x20(%r12),%xmm5
addsd  0x28(%r12),%xmm5
mov    0xb8(%rsp),%rbp
mulsd  0xf01(%rip),%xmm5
cmp    $0x3,%edx
ja     196c <view_parameter_define+0x84c>
mov    0xb0(%rsp),%ebx
cvtsi2sd %esi,%xmm1
movsd  0xeed(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    %edx,%eax
lea    0xf18(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
movapd %xmm4,0x50(%rsp)
movsd  %xmm5,0x40(%rsp)
jmp    *%rax
mov    %edx,0x2c(%rsp)
mov    %rdi,0x48(%rsp)
movabs $0x3ff0000000000000,%rax
mov    %rax,(%r14)
xorpd  %xmm1,%xmm1
movupd %xmm1,0x8(%r14)
movsd  0x0(%r13),%xmm1
movsd  0x8(%r13),%xmm2
subsd  %xmm4,%xmm1
unpckhpd %xmm4,%xmm4
movapd %xmm4,0x30(%rsp)
subsd  %xmm4,%xmm2
movsd  %xmm2,0x20(%rsp)
movsd  0x10(%r13),%xmm2
subsd  %xmm5,%xmm2
movsd  %xmm2,0x18(%rsp)
movsd  %xmm1,0x0(%r13)
movsd  %xmm0,0x8(%rsp)
call   1040 <cos@plt>
movsd  %xmm0,0x10(%rsp)
movsd  0x8(%rsp),%xmm0
call   1030 <sin@plt>
mulsd  0x18(%rsp),%xmm0
movsd  0x10(%rsp),%xmm1
mulsd  0x20(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r13)
movsd  0x8(%rsp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,0x10(%rsp)
movsd  0x8(%rsp),%xmm0
call   1040 <cos@plt>
movsd  0x40(%rsp),%xmm3
movapd 0x50(%rsp),%xmm2
mulsd  0x18(%rsp),%xmm0
movsd  0x10(%rsp),%xmm1
mulsd  0x20(%rsp),%xmm1
subsd  %xmm1,%xmm0
movupd 0x0(%r13),%xmm1
addpd  %xmm2,%xmm1
movupd %xmm1,0x0(%r13)
addsd  %xmm3,%xmm0
movsd  %xmm0,0x10(%r13)
test   %ebx,%ebx
jle    138f <view_parameter_define+0x26f>
mov    %ebx,%eax
shl    $0x3,%rax
lea    (%rax,%rax,2),%r15
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rbx,1),%xmm0
movsd  0x8(%rbp,%rbx,1),%xmm1
subsd  %xmm2,%xmm0
subsd  0x30(%rsp),%xmm1
movsd  %xmm1,0x20(%rsp)
movsd  0x10(%rbp,%rbx,1),%xmm1
subsd  %xmm3,%xmm1
movsd  %xmm1,0x18(%rsp)
movsd  %xmm0,0x0(%rbp,%rbx,1)
movsd  0x8(%rsp),%xmm0
call   1040 <cos@plt>
movsd  %xmm0,0x10(%rsp)
movsd  0x8(%rsp),%xmm0
call   1030 <sin@plt>
mulsd  0x18(%rsp),%xmm0
movsd  0x10(%rsp),%xmm1
mulsd  0x20(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rbp,%rbx,1)
movsd  0x8(%rsp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,0x10(%rsp)
movsd  0x8(%rsp),%xmm0
call   1040 <cos@plt>
movsd  0x40(%rsp),%xmm3
movapd 0x50(%rsp),%xmm2
mulsd  0x18(%rsp),%xmm0
movsd  0x10(%rsp),%xmm1
mulsd  0x20(%rsp),%xmm1
subsd  %xmm1,%xmm0
movupd 0x0(%rbp,%rbx,1),%xmm1
addpd  %xmm2,%xmm1
movupd %xmm1,0x0(%rbp,%rbx,1)
addsd  %xmm3,%xmm0
movsd  %xmm0,0x10(%rbp,%rbx,1)
add    $0x18,%rbx
cmp    %rbx,%r15
jne    12c0 <view_parameter_define+0x1a0>
movsd  0x8(%r14),%xmm0
movsd  %xmm0,0x20(%rsp)
movsd  0x10(%r14),%xmm0
movsd  %xmm0,0x18(%rsp)
movsd  0x8(%rsp),%xmm0
call   1040 <cos@plt>
movsd  %xmm0,0x10(%rsp)
movsd  0x8(%rsp),%xmm0
call   1030 <sin@plt>
mulsd  0x18(%rsp),%xmm0
movsd  0x10(%rsp),%xmm1
mulsd  0x20(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r14)
movsd  0x8(%rsp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,0x10(%rsp)
movsd  0x8(%rsp),%xmm0
call   1040 <cos@plt>
movsd  0x40(%rsp),%xmm5
movapd 0x50(%rsp),%xmm4
mulsd  0x18(%rsp),%xmm0
movsd  0x10(%rsp),%xmm1
mulsd  0x20(%rsp),%xmm1
subsd  %xmm1,%xmm0
jmp    195d <view_parameter_define+0x83d>
mov    %edx,0x2c(%rsp)
mov    %rdi,0x48(%rsp)
xorpd  %xmm1,%xmm1
movhpd 0xc59(%rip),%xmm1
movupd %xmm1,(%r14)
movq   $0x0,0x10(%r14)
movsd  0x0(%r13),%xmm1
movsd  0x8(%r13),%xmm2
subsd  %xmm4,%xmm1
movsd  %xmm1,0x20(%rsp)
unpckhpd %xmm4,%xmm4
movapd %xmm4,0x60(%rsp)
subsd  %xmm4,%xmm2
movsd  %xmm2,0x10(%rsp)
movsd  0x10(%r13),%xmm1
subsd  %xmm5,%xmm1
movsd  %xmm1,0x18(%rsp)
movsd  %xmm0,0x8(%rsp)
call   1040 <cos@plt>
movsd  %xmm0,0x30(%rsp)
movsd  0x8(%rsp),%xmm0
call   1030 <sin@plt>
mulsd  0x18(%rsp),%xmm0
movsd  0x30(%rsp),%xmm1
mulsd  0x20(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%r13)
movsd  0x10(%rsp),%xmm0
movsd  %xmm0,0x8(%r13)
movsd  0x8(%rsp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,0x10(%rsp)
movsd  0x8(%rsp),%xmm0
call   1040 <cos@plt>
movsd  0x40(%rsp),%xmm3
movapd 0x50(%rsp),%xmm2
mulsd  0x18(%rsp),%xmm0
movsd  0x10(%rsp),%xmm1
mulsd  0x20(%rsp),%xmm1
subsd  %xmm1,%xmm0
movupd 0x0(%r13),%xmm1
addpd  %xmm2,%xmm1
movupd %xmm1,0x0(%r13)
addsd  %xmm3,%xmm0
movsd  %xmm0,0x10(%r13)
test   %ebx,%ebx
jle    161b <view_parameter_define+0x4fb>
mov    0xb0(%rsp),%eax
shl    $0x3,%rax
lea    (%rax,%rax,2),%r15
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  0x0(%rbp,%rbx,1),%xmm0
movsd  0x8(%rbp,%rbx,1),%xmm1
subsd  %xmm2,%xmm0
movsd  %xmm0,0x20(%rsp)
subsd  0x60(%rsp),%xmm1
movsd  %xmm1,0x10(%rsp)
movsd  0x10(%rbp,%rbx,1),%xmm0
subsd  %xmm3,%xmm0
movsd  %xmm0,0x18(%rsp)
movsd  0x8(%rsp),%xmm0
call   1040 <cos@plt>
movsd  %xmm0,0x30(%rsp)
movsd  0x8(%rsp),%xmm0
call   1030 <sin@plt>
mulsd  0x18(%rsp),%xmm0
movsd  0x30(%rsp),%xmm1
mulsd  0x20(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%rbp,%rbx,1)
movsd  0x10(%rsp),%xmm0
movsd  %xmm0,0x8(%rbp,%rbx,1)
movsd  0x8(%rsp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,0x10(%rsp)
movsd  0x8(%rsp),%xmm0
call   1040 <cos@plt>
movsd  0x40(%rsp),%xmm3
movapd 0x50(%rsp),%xmm2
mulsd  0x18(%rsp),%xmm0
movsd  0x10(%rsp),%xmm1
mulsd  0x20(%rsp),%xmm1
subsd  %xmm1,%xmm0
movupd 0x0(%rbp,%rbx,1),%xmm1
addpd  %xmm2,%xmm1
movupd %xmm1,0x0(%rbp,%rbx,1)
addsd  %xmm3,%xmm0
movsd  %xmm0,0x10(%rbp,%rbx,1)
add    $0x18,%rbx
cmp    %rbx,%r15
jne    1540 <view_parameter_define+0x420>
movsd  (%r14),%xmm0
movsd  %xmm0,0x20(%rsp)
movsd  0x8(%r14),%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  0x10(%r14),%xmm0
movsd  %xmm0,0x18(%rsp)
movsd  0x8(%rsp),%xmm0
call   1040 <cos@plt>
movsd  %xmm0,0x30(%rsp)
movsd  0x8(%rsp),%xmm0
call   1030 <sin@plt>
mulsd  0x18(%rsp),%xmm0
movsd  0x30(%rsp),%xmm1
mulsd  0x20(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%r14)
movsd  0x10(%rsp),%xmm0
movsd  %xmm0,0x8(%r14)
movsd  0x8(%rsp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,0x10(%rsp)
movsd  0x8(%rsp),%xmm0
call   1040 <cos@plt>
movsd  0x40(%rsp),%xmm5
movapd 0x50(%rsp),%xmm4
mulsd  0x18(%rsp),%xmm0
movsd  0x10(%rsp),%xmm1
mulsd  0x20(%rsp),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,0x10(%r14)
mov    0x2c(%rsp),%edx
cmp    $0x3,%edx
mov    0x48(%rsp),%rdi
movsd  0x8(%rsp),%xmm0
mov    0xb0(%rsp),%ebx
jne    196c <view_parameter_define+0x84c>
movsd  %xmm0,0x8(%rsp)
mov    %edx,0x2c(%rsp)
mov    %rdi,0x48(%rsp)
movsd  0x0(%r13),%xmm1
movsd  0x8(%r13),%xmm2
subsd  %xmm4,%xmm1
movsd  %xmm1,0x20(%rsp)
unpckhpd %xmm4,%xmm4
movapd %xmm4,0x60(%rsp)
subsd  %xmm4,%xmm2
movsd  %xmm2,0x18(%rsp)
movsd  0x10(%r13),%xmm1
subsd  %xmm5,%xmm1
movsd  %xmm1,0x10(%rsp)
call   1040 <cos@plt>
movsd  %xmm0,0x30(%rsp)
movsd  0x8(%rsp),%xmm0
call   1030 <sin@plt>
mulsd  0x18(%rsp),%xmm0
movsd  0x30(%rsp),%xmm1
mulsd  0x20(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%r13)
movsd  0x8(%rsp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,0x30(%rsp)
movsd  0x8(%rsp),%xmm0
call   1040 <cos@plt>
movsd  0x40(%rsp),%xmm3
movapd 0x50(%rsp),%xmm2
mulsd  0x18(%rsp),%xmm0
movsd  0x30(%rsp),%xmm1
mulsd  0x20(%rsp),%xmm1
subsd  %xmm1,%xmm0
movsd  0x0(%r13),%xmm1
unpcklpd %xmm0,%xmm1
addpd  %xmm2,%xmm1
movupd %xmm1,0x0(%r13)
movsd  0x10(%rsp),%xmm0
addsd  %xmm3,%xmm0
movsd  %xmm0,0x10(%r13)
test   %ebx,%ebx
jle    18b9 <view_parameter_define+0x799>
mov    %ebx,%eax
shl    $0x3,%rax
lea    (%rax,%rax,2),%r15
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
movsd  0x0(%rbp,%rbx,1),%xmm0
movsd  0x8(%rbp,%rbx,1),%xmm1
subsd  %xmm2,%xmm0
movsd  %xmm0,0x20(%rsp)
subsd  0x60(%rsp),%xmm1
movsd  %xmm1,0x18(%rsp)
movsd  0x10(%rbp,%rbx,1),%xmm0
subsd  %xmm3,%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  0x8(%rsp),%xmm0
call   1040 <cos@plt>
movsd  %xmm0,0x30(%rsp)
movsd  0x8(%rsp),%xmm0
call   1030 <sin@plt>
mulsd  0x18(%rsp),%xmm0
movsd  0x30(%rsp),%xmm1
mulsd  0x20(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%rbp,%rbx,1)
movsd  0x8(%rsp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,0x30(%rsp)
movsd  0x8(%rsp),%xmm0
call   1040 <cos@plt>
movsd  0x40(%rsp),%xmm3
movapd 0x50(%rsp),%xmm2
mulsd  0x18(%rsp),%xmm0
movsd  0x30(%rsp),%xmm1
mulsd  0x20(%rsp),%xmm1
subsd  %xmm1,%xmm0
movsd  0x0(%rbp,%rbx,1),%xmm1
unpcklpd %xmm0,%xmm1
addpd  %xmm2,%xmm1
movupd %xmm1,0x0(%rbp,%rbx,1)
movsd  0x10(%rsp),%xmm0
addsd  %xmm3,%xmm0
movsd  %xmm0,0x10(%rbp,%rbx,1)
add    $0x18,%rbx
cmp    %rbx,%r15
jne    17e0 <view_parameter_define+0x6c0>
movsd  (%r14),%xmm0
movsd  %xmm0,0x20(%rsp)
movsd  0x8(%r14),%xmm0
movsd  %xmm0,0x18(%rsp)
movsd  0x10(%r14),%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  0x8(%rsp),%xmm0
call   1040 <cos@plt>
movsd  %xmm0,0x30(%rsp)
movsd  0x8(%rsp),%xmm0
call   1030 <sin@plt>
mulsd  0x18(%rsp),%xmm0
movsd  0x30(%rsp),%xmm1
mulsd  0x20(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%r14)
movsd  0x8(%rsp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,0x30(%rsp)
movsd  0x8(%rsp),%xmm0
call   1040 <cos@plt>
movsd  0x40(%rsp),%xmm5
movapd 0x50(%rsp),%xmm4
mulsd  0x18(%rsp),%xmm0
movsd  0x30(%rsp),%xmm1
mulsd  0x20(%rsp),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%r14)
movsd  0x10(%rsp),%xmm0
movsd  %xmm0,0x10(%r14)
mov    0x48(%rsp),%rdi
mov    0x2c(%rsp),%edx
test   %edi,%edi
jle    1ccd <view_parameter_define+0xbad>
cmp    $0x4,%edx
jne    1ccd <view_parameter_define+0xbad>
movsd  (%r12),%xmm3
movupd 0x8(%r12),%xmm1
movupd 0x18(%r12),%xmm2
movsd  0x28(%r12),%xmm0
mov    0x70(%rsp),%rax
movupd %xmm4,(%rax)
movsd  %xmm5,0x10(%rax)
add    $0xffffffff,%edi
cmp    $0x6,%edi
ja     1ccd <view_parameter_define+0xbad>
lea    0x717(%rip),%rax
movslq (%rax,%rdi,4),%rcx
add    %rax,%rcx
jmp    *%rcx
addsd  %xmm1,%xmm3
mulsd  0x6b2(%rip),%xmm3
movsd  %xmm3,0x0(%r13)
unpckhpd %xmm2,%xmm1
unpcklpd %xmm0,%xmm2
movapd %xmm2,%xmm0
subpd  %xmm1,%xmm0
movapd 0x684(%rip),%xmm1
mulpd  %xmm0,%xmm1
addpd  %xmm2,%xmm1
movupd %xmm1,0x8(%r13)
movsd  %xmm3,0x0(%rbp)
mulpd  0x649(%rip),%xmm0
addpd  %xmm2,%xmm0
movupd %xmm0,0x8(%rbp)
jmp    1cb6 <view_parameter_define+0xb96>
addsd  %xmm1,%xmm3
movsd  0x65f(%rip),%xmm4
mulsd  %xmm4,%xmm3
movsd  %xmm3,0x0(%r13)
movapd %xmm2,%xmm5
unpcklpd %xmm0,%xmm5
movapd %xmm2,%xmm6
unpckhpd %xmm2,%xmm6
unpckhpd %xmm2,%xmm1
movapd %xmm5,%xmm7
subpd  %xmm1,%xmm7
movsd  0x651(%rip),%xmm1
mulsd  %xmm7,%xmm1
addsd  %xmm2,%xmm1
movsd  %xmm1,0x8(%r13)
addsd  %xmm0,%xmm6
mulsd  %xmm4,%xmm6
movsd  %xmm6,0x10(%r13)
movsd  %xmm3,0x0(%rbp)
mulpd  0x5e8(%rip),%xmm7
addpd  %xmm5,%xmm7
movupd %xmm7,0x8(%rbp)
jmp    1cb6 <view_parameter_define+0xb96>
addsd  %xmm1,%xmm3
mulsd  0x5ee(%rip),%xmm3
movsd  %xmm3,0x0(%r13)
movapd %xmm2,%xmm4
unpcklpd %xmm0,%xmm4
unpckhpd %xmm2,%xmm1
subpd  %xmm1,%xmm4
movapd 0x580(%rip),%xmm0
mulpd  %xmm4,%xmm0
addpd  %xmm2,%xmm0
movupd %xmm0,0x8(%r13)
movsd  %xmm3,0x0(%rbp)
movapd %xmm4,%xmm0
unpckhpd %xmm4,%xmm0
xorpd  0x56d(%rip),%xmm0
unpcklpd %xmm0,%xmm4
mulpd  0x571(%rip),%xmm4
addpd  %xmm2,%xmm4
movupd %xmm4,0x8(%rbp)
jmp    1cb6 <view_parameter_define+0xb96>
unpcklpd %xmm2,%xmm3
addpd  %xmm3,%xmm1
movapd 0x503(%rip),%xmm3
mulpd  %xmm1,%xmm3
movupd %xmm3,0x0(%r13)
unpckhpd %xmm2,%xmm2
movapd %xmm0,%xmm4
subsd  %xmm2,%xmm4
movsd  0x585(%rip),%xmm2
mulsd  %xmm4,%xmm2
addsd  %xmm0,%xmm2
movsd  %xmm2,0x10(%r13)
movlpd %xmm3,0x0(%rbp)
unpckhpd %xmm1,%xmm1
mulsd  0x576(%rip),%xmm1
movsd  %xmm1,0x8(%rbp)
addsd  %xmm4,%xmm4
addsd  %xmm0,%xmm4
movsd  %xmm4,0x10(%rbp)
xorpd  %xmm0,%xmm0
movhpd 0x560(%rip),%xmm0
movupd %xmm0,(%r14)
movq   $0x0,0x10(%r14)
jmp    1ccd <view_parameter_define+0xbad>
movapd %xmm1,%xmm4
subsd  %xmm3,%xmm4
movsd  0x526(%rip),%xmm3
movapd %xmm4,%xmm5
mulsd  %xmm3,%xmm5
addsd  %xmm1,%xmm5
movsd  %xmm5,0x0(%r13)
movapd %xmm1,%xmm5
unpckhpd %xmm1,%xmm5
addsd  %xmm2,%xmm5
movsd  0x4e0(%rip),%xmm6
mulsd  %xmm6,%xmm5
movsd  %xmm5,0x8(%r13)
unpckhpd %xmm2,%xmm2
movapd %xmm0,%xmm7
subsd  %xmm2,%xmm7
mulsd  %xmm7,%xmm3
addsd  %xmm0,%xmm3
movsd  %xmm3,0x10(%r13)
mulsd  %xmm6,%xmm4
addsd  %xmm1,%xmm4
movsd  %xmm4,0x0(%rbp)
movsd  %xmm5,0x8(%rbp)
addsd  %xmm7,%xmm7
addsd  %xmm0,%xmm7
movsd  %xmm7,0x10(%rbp)
jmp    1cb6 <view_parameter_define+0xb96>
movapd %xmm1,%xmm4
subsd  %xmm3,%xmm4
movsd  0x4a0(%rip),%xmm5
mulsd  %xmm4,%xmm5
addsd  %xmm3,%xmm5
unpckhpd %xmm1,%xmm1
addsd  %xmm2,%xmm1
mulsd  0x470(%rip),%xmm1
movsd  %xmm5,0x0(%r13)
movsd  %xmm1,0x8(%r13)
unpckhpd %xmm2,%xmm2
movapd %xmm0,%xmm5
subsd  %xmm2,%xmm5
movsd  0x470(%rip),%xmm2
mulsd  %xmm5,%xmm2
addsd  %xmm0,%xmm2
movsd  %xmm2,0x10(%r13)
mulsd  0x462(%rip),%xmm4
addsd  %xmm3,%xmm4
movsd  %xmm4,0x0(%rbp)
movsd  %xmm1,0x8(%rbp)
addsd  %xmm5,%xmm5
addsd  %xmm0,%xmm5
movsd  %xmm5,0x10(%rbp)
jmp    1cb6 <view_parameter_define+0xb96>
addsd  %xmm1,%xmm3
mulsd  0x411(%rip),%xmm3
movsd  %xmm3,0x0(%r13)
movapd %xmm1,%xmm4
unpckhpd %xmm2,%xmm4
unpcklpd %xmm0,%xmm2
subpd  %xmm4,%xmm2
shufpd $0x1,%xmm0,%xmm1
movapd 0x37e(%rip),%xmm0
mulpd  %xmm2,%xmm0
addpd  %xmm1,%xmm0
movupd %xmm0,0x8(%r13)
movsd  %xmm3,0x0(%rbp)
mulpd  0x373(%rip),%xmm2
addpd  %xmm1,%xmm2
movupd %xmm2,0x8(%rbp)
xorpd  %xmm0,%xmm0
movupd %xmm0,(%r14)
movabs $0x3ff0000000000000,%rax
mov    %rax,0x10(%r14)
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @view_parameter_define(i32 %0, i32 %1, i32 %2, double* %3, double* %4, double* %5, i32 %6, double* %7, double* %8) {
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca double*
%14 = alloca double*
%15 = alloca double*
%16 = alloca i32
%17 = alloca double*
%18 = alloca double*
%19 = alloca i32
%20 = alloca i32
%21 = alloca [3 x double]
%22 = alloca [3 x double]
%23 = alloca double
%24 = alloca double
%25 = alloca double
%26 = alloca double
%27 = alloca double
%28 = alloca double
%29 = alloca double
store i32 %0, i32* %10
store i32 %1, i32* %11
store i32 %2, i32* %12
store double* %3, double** %13
store double* %4, double** %14
store double* %5, double** %15
store i32 %6, i32* %16
store double* %7, double** %17
store double* %8, double** %18
store i32 0, i32* %19
br label %30
30: ; preds = %52, %9
%31 = load i32, i32* %19
%32 = icmp slt i32 %31, 3
br i1 %32, label %33, label %55
33: ; preds = %30
%34 = load double*, double** %18
%35 = load i32, i32* %19
%36 = mul nsw i32 %35, 2
%37 = sext i32 %36 to i64
%38 = getelementptr inbounds double, double* %34, i64 %37
%39 = load double, double* %38
%40 = load double*, double** %18
%41 = load i32, i32* %19
%42 = mul nsw i32 %41, 2
%43 = add nsw i32 %42, 1
%44 = sext i32 %43 to i64
%45 = getelementptr inbounds double, double* %40, i64 %44
%46 = load double, double* %45
%47 = fadd double %39, %46
%48 = fdiv double %47, 2.000000e+00
%49 = load i32, i32* %19
%50 = sext i32 %49 to i64
%51 = getelementptr inbounds [3 x double], [3 x double]* %21, i64 0, i64 %50
store double %48, double* %51
br label %52
52: ; preds = %33
%53 = load i32, i32* %19
%54 = add nsw i32 %53, 1
store i32 %54, i32* %19
br label %30
55: ; preds = %30
%56 = load i32, i32* %11
%57 = sitofp i32 %56 to double
%58 = fdiv double 0x401921FB4D12D84A, %57
store double %58, double* %23
%59 = load i32, i32* %12
%60 = icmp ne i32 %59, 0
br i1 %60, label %61, label %1106
61: ; preds = %55
%62 = load i32, i32* %12
%63 = icmp eq i32 %62, 1
br i1 %63, label %64, label %279
64: ; preds = %61
%65 = load double*, double** %15
%66 = getelementptr inbounds double, double* %65, i64 0
store double 1.000000e+00, double* %66
%67 = load double*, double** %15
%68 = getelementptr inbounds double, double* %67, i64 1
store double 0.000000e+00, double* %68
%69 = load double*, double** %15
%70 = getelementptr inbounds double, double* %69, i64 2
store double 0.000000e+00, double* %70
store i32 0, i32* %19
br label %71
71: ; preds = %88, %64
%72 = load i32, i32* %19
%73 = icmp slt i32 %72, 3
br i1 %73, label %74, label %91
74: ; preds = %71
%75 = load double*, double** %13
%76 = load i32, i32* %19
%77 = sext i32 %76 to i64
%78 = getelementptr inbounds double, double* %75, i64 %77
%79 = load double, double* %78
%80 = load i32, i32* %19
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds [3 x double], [3 x double]* %21, i64 0, i64 %81
%83 = load double, double* %82
%84 = fsub double %79, %83
%85 = load i32, i32* %19
%86 = sext i32 %85 to i64
%87 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 %86
store double %84, double* %87
br label %88
88: ; preds = %74
%89 = load i32, i32* %19
%90 = add nsw i32 %89, 1
store i32 %90, i32* %19
br label %71
91: ; preds = %71
%92 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 0
%93 = load double, double* %92
%94 = load double*, double** %13
%95 = getelementptr inbounds double, double* %94, i64 0
store double %93, double* %95
%96 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 1
%97 = load double, double* %96
%98 = load double, double* %23
%99 = call double @cos(double %98)
%100 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 2
%101 = load double, double* %100
%102 = load double, double* %23
%103 = call double @sin(double %102)
%104 = fmul double %101, %103
%105 = call double @llvm.fmuladd.f64(double %97, double %99, double %104)
%106 = load double*, double** %13
%107 = getelementptr inbounds double, double* %106, i64 1
store double %105, double* %107
%108 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 1
%109 = load double, double* %108
%110 = fneg double %109
%111 = load double, double* %23
%112 = call double @sin(double %111)
%113 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 2
%114 = load double, double* %113
%115 = load double, double* %23
%116 = call double @cos(double %115)
%117 = fmul double %114, %116
%118 = call double @llvm.fmuladd.f64(double %110, double %112, double %117)
%119 = load double*, double** %13
%120 = getelementptr inbounds double, double* %119, i64 2
store double %118, double* %120
store i32 0, i32* %19
br label %121
121: ; preds = %135, %91
%122 = load i32, i32* %19
%123 = icmp slt i32 %122, 3
br i1 %123, label %124, label %138
124: ; preds = %121
%125 = load i32, i32* %19
%126 = sext i32 %125 to i64
%127 = getelementptr inbounds [3 x double], [3 x double]* %21, i64 0, i64 %126
%128 = load double, double* %127
%129 = load double*, double** %13
%130 = load i32, i32* %19
%131 = sext i32 %130 to i64
%132 = getelementptr inbounds double, double* %129, i64 %131
%133 = load double, double* %132
%134 = fadd double %133, %128
store double %134, double* %132
br label %135
135: ; preds = %124
%136 = load i32, i32* %19
%137 = add nsw i32 %136, 1
store i32 %137, i32* %19
br label %121
138: ; preds = %121
store i32 0, i32* %20
br label %139
139: ; preds = %230, %138
%140 = load i32, i32* %20
%141 = load i32, i32* %16
%142 = icmp slt i32 %140, %141
br i1 %142, label %143, label %233
143: ; preds = %139
store i32 0, i32* %19
br label %144
144: ; preds = %164, %143
%145 = load i32, i32* %19
%146 = icmp slt i32 %145, 3
br i1 %146, label %147, label %167
147: ; preds = %144
%148 = load double*, double** %17
%149 = load i32, i32* %20
%150 = mul nsw i32 %149, 3
%151 = load i32, i32* %19
%152 = add nsw i32 %150, %151
%153 = sext i32 %152 to i64
%154 = getelementptr inbounds double, double* %148, i64 %153
%155 = load double, double* %154
%156 = load i32, i32* %19
%157 = sext i32 %156 to i64
%158 = getelementptr inbounds [3 x double], [3 x double]* %21, i64 0, i64 %157
%159 = load double, double* %158
%160 = fsub double %155, %159
%161 = load i32, i32* %19
%162 = sext i32 %161 to i64
%163 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 %162
store double %160, double* %163
br label %164
164: ; preds = %147
%165 = load i32, i32* %19
%166 = add nsw i32 %165, 1
store i32 %166, i32* %19
br label %144
167: ; preds = %144
%168 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 0
%169 = load double, double* %168
%170 = load double*, double** %17
%171 = load i32, i32* %20
%172 = mul nsw i32 %171, 3
%173 = add nsw i32 %172, 0
%174 = sext i32 %173 to i64
%175 = getelementptr inbounds double, double* %170, i64 %174
store double %169, double* %175
%176 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 1
%177 = load double, double* %176
%178 = load double, double* %23
%179 = call double @cos(double %178)
%180 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 2
%181 = load double, double* %180
%182 = load double, double* %23
%183 = call double @sin(double %182)
%184 = fmul double %181, %183
%185 = call double @llvm.fmuladd.f64(double %177, double %179, double %184)
%186 = load double*, double** %17
%187 = load i32, i32* %20
%188 = mul nsw i32 %187, 3
%189 = add nsw i32 %188, 1
%190 = sext i32 %189 to i64
%191 = getelementptr inbounds double, double* %186, i64 %190
store double %185, double* %191
%192 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 1
%193 = load double, double* %192
%194 = fneg double %193
%195 = load double, double* %23
%196 = call double @sin(double %195)
%197 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 2
%198 = load double, double* %197
%199 = load double, double* %23
%200 = call double @cos(double %199)
%201 = fmul double %198, %200
%202 = call double @llvm.fmuladd.f64(double %194, double %196, double %201)
%203 = load double*, double** %17
%204 = load i32, i32* %20
%205 = mul nsw i32 %204, 3
%206 = add nsw i32 %205, 2
%207 = sext i32 %206 to i64
%208 = getelementptr inbounds double, double* %203, i64 %207
store double %202, double* %208
store i32 0, i32* %19
br label %209
209: ; preds = %226, %167
%210 = load i32, i32* %19
%211 = icmp slt i32 %210, 3
br i1 %211, label %212, label %229
212: ; preds = %209
%213 = load i32, i32* %19
%214 = sext i32 %213 to i64
%215 = getelementptr inbounds [3 x double], [3 x double]* %21, i64 0, i64 %214
%216 = load double, double* %215
%217 = load double*, double** %17
%218 = load i32, i32* %20
%219 = mul nsw i32 %218, 3
%220 = load i32, i32* %19
%221 = add nsw i32 %219, %220
%222 = sext i32 %221 to i64
%223 = getelementptr inbounds double, double* %217, i64 %222
%224 = load double, double* %223
%225 = fadd double %224, %216
store double %225, double* %223
br label %226
226: ; preds = %212
%227 = load i32, i32* %19
%228 = add nsw i32 %227, 1
store i32 %228, i32* %19
br label %209
229: ; preds = %209
br label %230
230: ; preds = %229
%231 = load i32, i32* %20
%232 = add nsw i32 %231, 1
store i32 %232, i32* %20
br label %139
233: ; preds = %139
store i32 0, i32* %19
br label %234
234: ; preds = %246, %233
%235 = load i32, i32* %19
%236 = icmp slt i32 %235, 3
br i1 %236, label %237, label %249
237: ; preds = %234
%238 = load double*, double** %15
%239 = load i32, i32* %19
%240 = sext i32 %239 to i64
%241 = getelementptr inbounds double, double* %238, i64 %240
%242 = load double, double* %241
%243 = load i32, i32* %19
%244 = sext i32 %243 to i64
%245 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 %244
store double %242, double* %245
br label %246
246: ; preds = %237
%247 = load i32, i32* %19
%248 = add nsw i32 %247, 1
store i32 %248, i32* %19
br label %234
249: ; preds = %234
%250 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 0
%251 = load double, double* %250
%252 = load double*, double** %15
%253 = getelementptr inbounds double, double* %252, i64 0
store double %251, double* %253
%254 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 1
%255 = load double, double* %254
%256 = load double, double* %23
%257 = call double @cos(double %256)
%258 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 2
%259 = load double, double* %258
%260 = load double, double* %23
%261 = call double @sin(double %260)
%262 = fmul double %259, %261
%263 = call double @llvm.fmuladd.f64(double %255, double %257, double %262)
%264 = load double*, double** %15
%265 = getelementptr inbounds double, double* %264, i64 1
store double %263, double* %265
%266 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 1
%267 = load double, double* %266
%268 = fneg double %267
%269 = load double, double* %23
%270 = call double @sin(double %269)
%271 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 2
%272 = load double, double* %271
%273 = load double, double* %23
%274 = call double @cos(double %273)
%275 = fmul double %272, %274
%276 = call double @llvm.fmuladd.f64(double %268, double %270, double %275)
%277 = load double*, double** %15
%278 = getelementptr inbounds double, double* %277, i64 2
store double %276, double* %278
br label %279
279: ; preds = %249, %61
%280 = load i32, i32* %12
%281 = icmp eq i32 %280, 2
br i1 %281, label %282, label %497
282: ; preds = %279
%283 = load double*, double** %15
%284 = getelementptr inbounds double, double* %283, i64 0
store double 0.000000e+00, double* %284
%285 = load double*, double** %15
%286 = getelementptr inbounds double, double* %285, i64 1
store double 1.000000e+00, double* %286
%287 = load double*, double** %15
%288 = getelementptr inbounds double, double* %287, i64 2
store double 0.000000e+00, double* %288
store i32 0, i32* %19
br label %289
289: ; preds = %306, %282
%290 = load i32, i32* %19
%291 = icmp slt i32 %290, 3
br i1 %291, label %292, label %309
292: ; preds = %289
%293 = load double*, double** %13
%294 = load i32, i32* %19
%295 = sext i32 %294 to i64
%296 = getelementptr inbounds double, double* %293, i64 %295
%297 = load double, double* %296
%298 = load i32, i32* %19
%299 = sext i32 %298 to i64
%300 = getelementptr inbounds [3 x double], [3 x double]* %21, i64 0, i64 %299
%301 = load double, double* %300
%302 = fsub double %297, %301
%303 = load i32, i32* %19
%304 = sext i32 %303 to i64
%305 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 %304
store double %302, double* %305
br label %306
306: ; preds = %292
%307 = load i32, i32* %19
%308 = add nsw i32 %307, 1
store i32 %308, i32* %19
br label %289
309: ; preds = %289
%310 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 0
%311 = load double, double* %310
%312 = load double, double* %23
%313 = call double @cos(double %312)
%314 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 2
%315 = load double, double* %314
%316 = load double, double* %23
%317 = call double @sin(double %316)
%318 = fmul double %315, %317
%319 = call double @llvm.fmuladd.f64(double %311, double %313, double %318)
%320 = load double*, double** %13
%321 = getelementptr inbounds double, double* %320, i64 0
store double %319, double* %321
%322 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 1
%323 = load double, double* %322
%324 = load double*, double** %13
%325 = getelementptr inbounds double, double* %324, i64 1
store double %323, double* %325
%326 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 0
%327 = load double, double* %326
%328 = fneg double %327
%329 = load double, double* %23
%330 = call double @sin(double %329)
%331 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 2
%332 = load double, double* %331
%333 = load double, double* %23
%334 = call double @cos(double %333)
%335 = fmul double %332, %334
%336 = call double @llvm.fmuladd.f64(double %328, double %330, double %335)
%337 = load double*, double** %13
%338 = getelementptr inbounds double, double* %337, i64 2
store double %336, double* %338
store i32 0, i32* %19
br label %339
339: ; preds = %353, %309
%340 = load i32, i32* %19
%341 = icmp slt i32 %340, 3
br i1 %341, label %342, label %356
342: ; preds = %339
%343 = load i32, i32* %19
%344 = sext i32 %343 to i64
%345 = getelementptr inbounds [3 x double], [3 x double]* %21, i64 0, i64 %344
%346 = load double, double* %345
%347 = load double*, double** %13
%348 = load i32, i32* %19
%349 = sext i32 %348 to i64
%350 = getelementptr inbounds double, double* %347, i64 %349
%351 = load double, double* %350
%352 = fadd double %351, %346
store double %352, double* %350
br label %353
353: ; preds = %342
%354 = load i32, i32* %19
%355 = add nsw i32 %354, 1
store i32 %355, i32* %19
br label %339
356: ; preds = %339
store i32 0, i32* %20
br label %357
357: ; preds = %448, %356
%358 = load i32, i32* %20
%359 = load i32, i32* %16
%360 = icmp slt i32 %358, %359
br i1 %360, label %361, label %451
361: ; preds = %357
store i32 0, i32* %19
br label %362
362: ; preds = %382, %361
%363 = load i32, i32* %19
%364 = icmp slt i32 %363, 3
br i1 %364, label %365, label %385
365: ; preds = %362
%366 = load double*, double** %17
%367 = load i32, i32* %20
%368 = mul nsw i32 %367, 3
%369 = load i32, i32* %19
%370 = add nsw i32 %368, %369
%371 = sext i32 %370 to i64
%372 = getelementptr inbounds double, double* %366, i64 %371
%373 = load double, double* %372
%374 = load i32, i32* %19
%375 = sext i32 %374 to i64
%376 = getelementptr inbounds [3 x double], [3 x double]* %21, i64 0, i64 %375
%377 = load double, double* %376
%378 = fsub double %373, %377
%379 = load i32, i32* %19
%380 = sext i32 %379 to i64
%381 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 %380
store double %378, double* %381
br label %382
382: ; preds = %365
%383 = load i32, i32* %19
%384 = add nsw i32 %383, 1
store i32 %384, i32* %19
br label %362
385: ; preds = %362
%386 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 0
%387 = load double, double* %386
%388 = load double, double* %23
%389 = call double @cos(double %388)
%390 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 2
%391 = load double, double* %390
%392 = load double, double* %23
%393 = call double @sin(double %392)
%394 = fmul double %391, %393
%395 = call double @llvm.fmuladd.f64(double %387, double %389, double %394)
%396 = load double*, double** %17
%397 = load i32, i32* %20
%398 = mul nsw i32 %397, 3
%399 = add nsw i32 %398, 0
%400 = sext i32 %399 to i64
%401 = getelementptr inbounds double, double* %396, i64 %400
store double %395, double* %401
%402 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 1
%403 = load double, double* %402
%404 = load double*, double** %17
%405 = load i32, i32* %20
%406 = mul nsw i32 %405, 3
%407 = add nsw i32 %406, 1
%408 = sext i32 %407 to i64
%409 = getelementptr inbounds double, double* %404, i64 %408
store double %403, double* %409
%410 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 0
%411 = load double, double* %410
%412 = fneg double %411
%413 = load double, double* %23
%414 = call double @sin(double %413)
%415 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 2
%416 = load double, double* %415
%417 = load double, double* %23
%418 = call double @cos(double %417)
%419 = fmul double %416, %418
%420 = call double @llvm.fmuladd.f64(double %412, double %414, double %419)
%421 = load double*, double** %17
%422 = load i32, i32* %20
%423 = mul nsw i32 %422, 3
%424 = add nsw i32 %423, 2
%425 = sext i32 %424 to i64
%426 = getelementptr inbounds double, double* %421, i64 %425
store double %420, double* %426
store i32 0, i32* %19
br label %427
427: ; preds = %444, %385
%428 = load i32, i32* %19
%429 = icmp slt i32 %428, 3
br i1 %429, label %430, label %447
430: ; preds = %427
%431 = load i32, i32* %19
%432 = sext i32 %431 to i64
%433 = getelementptr inbounds [3 x double], [3 x double]* %21, i64 0, i64 %432
%434 = load double, double* %433
%435 = load double*, double** %17
%436 = load i32, i32* %20
%437 = mul nsw i32 %436, 3
%438 = load i32, i32* %19
%439 = add nsw i32 %437, %438
%440 = sext i32 %439 to i64
%441 = getelementptr inbounds double, double* %435, i64 %440
%442 = load double, double* %441
%443 = fadd double %442, %434
store double %443, double* %441
br label %444
444: ; preds = %430
%445 = load i32, i32* %19
%446 = add nsw i32 %445, 1
store i32 %446, i32* %19
br label %427
447: ; preds = %427
br label %448
448: ; preds = %447
%449 = load i32, i32* %20
%450 = add nsw i32 %449, 1
store i32 %450, i32* %20
br label %357
451: ; preds = %357
store i32 0, i32* %19
br label %452
452: ; preds = %464, %451
%453 = load i32, i32* %19
%454 = icmp slt i32 %453, 3
br i1 %454, label %455, label %467
455: ; preds = %452
%456 = load double*, double** %15
%457 = load i32, i32* %19
%458 = sext i32 %457 to i64
%459 = getelementptr inbounds double, double* %456, i64 %458
%460 = load double, double* %459
%461 = load i32, i32* %19
%462 = sext i32 %461 to i64
%463 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 %462
store double %460, double* %463
br label %464
464: ; preds = %455
%465 = load i32, i32* %19
%466 = add nsw i32 %465, 1
store i32 %466, i32* %19
br label %452
467: ; preds = %452
%468 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 0
%469 = load double, double* %468
%470 = load double, double* %23
%471 = call double @cos(double %470)
%472 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 2
%473 = load double, double* %472
%474 = load double, double* %23
%475 = call double @sin(double %474)
%476 = fmul double %473, %475
%477 = call double @llvm.fmuladd.f64(double %469, double %471, double %476)
%478 = load double*, double** %15
%479 = getelementptr inbounds double, double* %478, i64 0
store double %477, double* %479
%480 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 1
%481 = load double, double* %480
%482 = load double*, double** %15
%483 = getelementptr inbounds double, double* %482, i64 1
store double %481, double* %483
%484 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 0
%485 = load double, double* %484
%486 = fneg double %485
%487 = load double, double* %23
%488 = call double @sin(double %487)
%489 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 2
%490 = load double, double* %489
%491 = load double, double* %23
%492 = call double @cos(double %491)
%493 = fmul double %490, %492
%494 = call double @llvm.fmuladd.f64(double %486, double %488, double %493)
%495 = load double*, double** %15
%496 = getelementptr inbounds double, double* %495, i64 2
store double %494, double* %496
br label %497
497: ; preds = %467, %279
%498 = load i32, i32* %12
%499 = icmp eq i32 %498, 3
br i1 %499, label %500, label %709
500: ; preds = %497
store i32 0, i32* %19
br label %501
501: ; preds = %518, %500
%502 = load i32, i32* %19
%503 = icmp slt i32 %502, 3
br i1 %503, label %504, label %521
504: ; preds = %501
%505 = load double*, double** %13
%506 = load i32, i32* %19
%507 = sext i32 %506 to i64
%508 = getelementptr inbounds double, double* %505, i64 %507
%509 = load double, double* %508
%510 = load i32, i32* %19
%511 = sext i32 %510 to i64
%512 = getelementptr inbounds [3 x double], [3 x double]* %21, i64 0, i64 %511
%513 = load double, double* %512
%514 = fsub double %509, %513
%515 = load i32, i32* %19
%516 = sext i32 %515 to i64
%517 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 %516
store double %514, double* %517
br label %518
518: ; preds = %504
%519 = load i32, i32* %19
%520 = add nsw i32 %519, 1
store i32 %520, i32* %19
br label %501
521: ; preds = %501
%522 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 0
%523 = load double, double* %522
%524 = load double, double* %23
%525 = call double @cos(double %524)
%526 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 1
%527 = load double, double* %526
%528 = load double, double* %23
%529 = call double @sin(double %528)
%530 = fmul double %527, %529
%531 = call double @llvm.fmuladd.f64(double %523, double %525, double %530)
%532 = load double*, double** %13
%533 = getelementptr inbounds double, double* %532, i64 0
store double %531, double* %533
%534 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 0
%535 = load double, double* %534
%536 = fneg double %535
%537 = load double, double* %23
%538 = call double @sin(double %537)
%539 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 1
%540 = load double, double* %539
%541 = load double, double* %23
%542 = call double @cos(double %541)
%543 = fmul double %540, %542
%544 = call double @llvm.fmuladd.f64(double %536, double %538, double %543)
%545 = load double*, double** %13
%546 = getelementptr inbounds double, double* %545, i64 1
store double %544, double* %546
%547 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 2
%548 = load double, double* %547
%549 = load double*, double** %13
%550 = getelementptr inbounds double, double* %549, i64 2
store double %548, double* %550
store i32 0, i32* %19
br label %551
551: ; preds = %565, %521
%552 = load i32, i32* %19
%553 = icmp slt i32 %552, 3
br i1 %553, label %554, label %568
554: ; preds = %551
%555 = load i32, i32* %19
%556 = sext i32 %555 to i64
%557 = getelementptr inbounds [3 x double], [3 x double]* %21, i64 0, i64 %556
%558 = load double, double* %557
%559 = load double*, double** %13
%560 = load i32, i32* %19
%561 = sext i32 %560 to i64
%562 = getelementptr inbounds double, double* %559, i64 %561
%563 = load double, double* %562
%564 = fadd double %563, %558
store double %564, double* %562
br label %565
565: ; preds = %554
%566 = load i32, i32* %19
%567 = add nsw i32 %566, 1
store i32 %567, i32* %19
br label %551
568: ; preds = %551
store i32 0, i32* %20
br label %569
569: ; preds = %660, %568
%570 = load i32, i32* %20
%571 = load i32, i32* %16
%572 = icmp slt i32 %570, %571
br i1 %572, label %573, label %663
573: ; preds = %569
store i32 0, i32* %19
br label %574
574: ; preds = %594, %573
%575 = load i32, i32* %19
%576 = icmp slt i32 %575, 3
br i1 %576, label %577, label %597
577: ; preds = %574
%578 = load double*, double** %17
%579 = load i32, i32* %20
%580 = mul nsw i32 %579, 3
%581 = load i32, i32* %19
%582 = add nsw i32 %580, %581
%583 = sext i32 %582 to i64
%584 = getelementptr inbounds double, double* %578, i64 %583
%585 = load double, double* %584
%586 = load i32, i32* %19
%587 = sext i32 %586 to i64
%588 = getelementptr inbounds [3 x double], [3 x double]* %21, i64 0, i64 %587
%589 = load double, double* %588
%590 = fsub double %585, %589
%591 = load i32, i32* %19
%592 = sext i32 %591 to i64
%593 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 %592
store double %590, double* %593
br label %594
594: ; preds = %577
%595 = load i32, i32* %19
%596 = add nsw i32 %595, 1
store i32 %596, i32* %19
br label %574
597: ; preds = %574
%598 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 0
%599 = load double, double* %598
%600 = load double, double* %23
%601 = call double @cos(double %600)
%602 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 1
%603 = load double, double* %602
%604 = load double, double* %23
%605 = call double @sin(double %604)
%606 = fmul double %603, %605
%607 = call double @llvm.fmuladd.f64(double %599, double %601, double %606)
%608 = load double*, double** %17
%609 = load i32, i32* %20
%610 = mul nsw i32 %609, 3
%611 = add nsw i32 %610, 0
%612 = sext i32 %611 to i64
%613 = getelementptr inbounds double, double* %608, i64 %612
store double %607, double* %613
%614 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 0
%615 = load double, double* %614
%616 = fneg double %615
%617 = load double, double* %23
%618 = call double @sin(double %617)
%619 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 1
%620 = load double, double* %619
%621 = load double, double* %23
%622 = call double @cos(double %621)
%623 = fmul double %620, %622
%624 = call double @llvm.fmuladd.f64(double %616, double %618, double %623)
%625 = load double*, double** %17
%626 = load i32, i32* %20
%627 = mul nsw i32 %626, 3
%628 = add nsw i32 %627, 1
%629 = sext i32 %628 to i64
%630 = getelementptr inbounds double, double* %625, i64 %629
store double %624, double* %630
%631 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 2
%632 = load double, double* %631
%633 = load double*, double** %17
%634 = load i32, i32* %20
%635 = mul nsw i32 %634, 3
%636 = add nsw i32 %635, 2
%637 = sext i32 %636 to i64
%638 = getelementptr inbounds double, double* %633, i64 %637
store double %632, double* %638
store i32 0, i32* %19
br label %639
639: ; preds = %656, %597
%640 = load i32, i32* %19
%641 = icmp slt i32 %640, 3
br i1 %641, label %642, label %659
642: ; preds = %639
%643 = load i32, i32* %19
%644 = sext i32 %643 to i64
%645 = getelementptr inbounds [3 x double], [3 x double]* %21, i64 0, i64 %644
%646 = load double, double* %645
%647 = load double*, double** %17
%648 = load i32, i32* %20
%649 = mul nsw i32 %648, 3
%650 = load i32, i32* %19
%651 = add nsw i32 %649, %650
%652 = sext i32 %651 to i64
%653 = getelementptr inbounds double, double* %647, i64 %652
%654 = load double, double* %653
%655 = fadd double %654, %646
store double %655, double* %653
br label %656
656: ; preds = %642
%657 = load i32, i32* %19
%658 = add nsw i32 %657, 1
store i32 %658, i32* %19
br label %639
659: ; preds = %639
br label %660
660: ; preds = %659
%661 = load i32, i32* %20
%662 = add nsw i32 %661, 1
store i32 %662, i32* %20
br label %569
663: ; preds = %569
store i32 0, i32* %19
br label %664
664: ; preds = %676, %663
%665 = load i32, i32* %19
%666 = icmp slt i32 %665, 3
br i1 %666, label %667, label %679
667: ; preds = %664
%668 = load double*, double** %15
%669 = load i32, i32* %19
%670 = sext i32 %669 to i64
%671 = getelementptr inbounds double, double* %668, i64 %670
%672 = load double, double* %671
%673 = load i32, i32* %19
%674 = sext i32 %673 to i64
%675 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 %674
store double %672, double* %675
br label %676
676: ; preds = %667
%677 = load i32, i32* %19
%678 = add nsw i32 %677, 1
store i32 %678, i32* %19
br label %664
679: ; preds = %664
%680 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 0
%681 = load double, double* %680
%682 = load double, double* %23
%683 = call double @cos(double %682)
%684 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 1
%685 = load double, double* %684
%686 = load double, double* %23
%687 = call double @sin(double %686)
%688 = fmul double %685, %687
%689 = call double @llvm.fmuladd.f64(double %681, double %683, double %688)
%690 = load double*, double** %15
%691 = getelementptr inbounds double, double* %690, i64 0
store double %689, double* %691
%692 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 0
%693 = load double, double* %692
%694 = fneg double %693
%695 = load double, double* %23
%696 = call double @sin(double %695)
%697 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 1
%698 = load double, double* %697
%699 = load double, double* %23
%700 = call double @cos(double %699)
%701 = fmul double %698, %700
%702 = call double @llvm.fmuladd.f64(double %694, double %696, double %701)
%703 = load double*, double** %15
%704 = getelementptr inbounds double, double* %703, i64 1
store double %702, double* %704
%705 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 2
%706 = load double, double* %705
%707 = load double*, double** %15
%708 = getelementptr inbounds double, double* %707, i64 2
store double %706, double* %708
br label %709
709: ; preds = %679, %497
%710 = load i32, i32* %12
%711 = icmp eq i32 %710, 4
br i1 %711, label %712, label %1105
712: ; preds = %709
%713 = load i32, i32* %10
%714 = icmp sgt i32 %713, 0
br i1 %714, label %715, label %1104
715: ; preds = %712
%716 = load double*, double** %18
%717 = getelementptr inbounds double, double* %716, i64 0
%718 = load double, double* %717
store double %718, double* %24
%719 = load double*, double** %18
%720 = getelementptr inbounds double, double* %719, i64 1
%721 = load double, double* %720
store double %721, double* %25
%722 = load double*, double** %18
%723 = getelementptr inbounds double, double* %722, i64 2
%724 = load double, double* %723
store double %724, double* %26
%725 = load double*, double** %18
%726 = getelementptr inbounds double, double* %725, i64 3
%727 = load double, double* %726
store double %727, double* %27
%728 = load double*, double** %18
%729 = getelementptr inbounds double, double* %728, i64 4
%730 = load double, double* %729
store double %730, double* %28
%731 = load double*, double** %18
%732 = getelementptr inbounds double, double* %731, i64 5
%733 = load double, double* %732
store double %733, double* %29
store i32 0, i32* %19
br label %734
734: ; preds = %746, %715
%735 = load i32, i32* %19
%736 = icmp slt i32 %735, 3
br i1 %736, label %737, label %749
737: ; preds = %734
%738 = load i32, i32* %19
%739 = sext i32 %738 to i64
%740 = getelementptr inbounds [3 x double], [3 x double]* %21, i64 0, i64 %739
%741 = load double, double* %740
%742 = load double*, double** %14
%743 = load i32, i32* %19
%744 = sext i32 %743 to i64
%745 = getelementptr inbounds double, double* %742, i64 %744
store double %741, double* %745
br label %746
746: ; preds = %737
%747 = load i32, i32* %19
%748 = add nsw i32 %747, 1
store i32 %748, i32* %19
br label %734
749: ; preds = %734
store i32 1, i32* %16
%750 = load i32, i32* %10
%751 = icmp eq i32 %750, 1
br i1 %751, label %752, label %799
752: ; preds = %749
%753 = load double, double* %24
%754 = load double, double* %25
%755 = fadd double %753, %754
%756 = fdiv double %755, 2.000000e+00
%757 = load double*, double** %13
%758 = getelementptr inbounds double, double* %757, i64 0
store double %756, double* %758
%759 = load double, double* %27
%760 = load double, double* %27
%761 = load double, double* %26
%762 = fsub double %760, %761
%763 = call double @llvm.fmuladd.f64(double 1.500000e+00, double %762, double %759)
%764 = load double*, double** %13
%765 = getelementptr inbounds double, double* %764, i64 1
store double %763, double* %765
%766 = load double, double* %29
%767 = load double, double* %29
%768 = load double, double* %28
%769 = fsub double %767, %768
%770 = call double @llvm.fmuladd.f64(double 1.500000e+00, double %769, double %766)
%771 = load double*, double** %13
%772 = getelementptr inbounds double, double* %771, i64 2
store double %770, double* %772
%773 = load double, double* %24
%774 = load double, double* %25
%775 = fadd double %773, %774
%776 = fdiv double %775, 2.000000e+00
%777 = load double*, double** %17
%778 = getelementptr inbounds double, double* %777, i64 0
store double %776, double* %778
%779 = load double, double* %27
%780 = load double, double* %27
%781 = load double, double* %26
%782 = fsub double %780, %781
%783 = call double @llvm.fmuladd.f64(double 1.000000e-01, double %782, double %779)
%784 = load double*, double** %17
%785 = getelementptr inbounds double, double* %784, i64 1
store double %783, double* %785
%786 = load double, double* %29
%787 = load double, double* %29
%788 = load double, double* %28
%789 = fsub double %787, %788
%790 = call double @llvm.fmuladd.f64(double %789, double 2.000000e+00, double %786)
%791 = load double*, double** %17
%792 = getelementptr inbounds double, double* %791, i64 2
store double %790, double* %792
%793 = load double*, double** %15
%794 = getelementptr inbounds double, double* %793, i64 0
store double 0.000000e+00, double* %794
%795 = load double*, double** %15
%796 = getelementptr inbounds double, double* %795, i64 1
store double 0.000000e+00, double* %796
%797 = load double*, double** %15
%798 = getelementptr inbounds double, double* %797, i64 2
store double 1.000000e+00, double* %798
br label %1103
799: ; preds = %749
%800 = load i32, i32* %10
%801 = icmp eq i32 %800, 2
br i1 %801, label %802, label %848
802: ; preds = %799
%803 = load double, double* %24
%804 = load double, double* %25
%805 = fadd double %803, %804
%806 = fdiv double %805, 2.000000e+00
%807 = load double*, double** %13
%808 = getelementptr inbounds double, double* %807, i64 0
store double %806, double* %808
%809 = load double, double* %27
%810 = load double, double* %27
%811 = load double, double* %26
%812 = fsub double %810, %811
%813 = call double @llvm.fmuladd.f64(double 1.500000e+00, double %812, double %809)
%814 = load double*, double** %13
%815 = getelementptr inbounds double, double* %814, i64 1
store double %813, double* %815
%816 = load double, double* %29
%817 = load double, double* %28
%818 = fadd double %816, %817
%819 = fdiv double %818, 2.000000e+00
%820 = load double*, double** %13
%821 = getelementptr inbounds double, double* %820, i64 2
store double %819, double* %821
%822 = load double, double* %24
%823 = load double, double* %25
%824 = fadd double %822, %823
%825 = fdiv double %824, 2.000000e+00
%826 = load double*, double** %17
%827 = getelementptr inbounds double, double* %826, i64 0
store double %825, double* %827
%828 = load double, double* %27
%829 = load double, double* %27
%830 = load double, double* %26
%831 = fsub double %829, %830
%832 = call double @llvm.fmuladd.f64(double 1.000000e-01, double %831, double %828)
%833 = load double*, double** %17
%834 = getelementptr inbounds double, double* %833, i64 1
store double %832, double* %834
%835 = load double, double* %29
%836 = load double, double* %29
%837 = load double, double* %28
%838 = fsub double %836, %837
%839 = call double @llvm.fmuladd.f64(double %838, double 5.000000e-01, double %835)
%840 = load double*, double** %17
%841 = getelementptr inbounds double, double* %840, i64 2
store double %839, double* %841
%842 = load double*, double** %15
%843 = getelementptr inbounds double, double* %842, i64 0
store double 0.000000e+00, double* %843
%844 = load double*, double** %15
%845 = getelementptr inbounds double, double* %844, i64 1
store double 0.000000e+00, double* %845
%846 = load double*, double** %15
%847 = getelementptr inbounds double, double* %846, i64 2
store double 1.000000e+00, double* %847
br label %1102
848: ; preds = %799
%849 = load i32, i32* %10
%850 = icmp eq i32 %849, 3
br i1 %850, label %851, label %899
851: ; preds = %848
%852 = load double, double* %24
%853 = load double, double* %25
%854 = fadd double %852, %853
%855 = fdiv double %854, 2.000000e+00
%856 = load double*, double** %13
%857 = getelementptr inbounds double, double* %856, i64 0
store double %855, double* %857
%858 = load double, double* %27
%859 = load double, double* %27
%860 = load double, double* %26
%861 = fsub double %859, %860
%862 = call double @llvm.fmuladd.f64(double 1.500000e+00, double %861, double %858)
%863 = load double*, double** %13
%864 = getelementptr inbounds double, double* %863, i64 1
store double %862, double* %864
%865 = load double, double* %28
%866 = load double, double* %29
%867 = load double, double* %28
%868 = fsub double %866, %867
%869 = call double @llvm.fmuladd.f64(double -1.500000e+00, double %868, double %865)
%870 = load double*, double** %13
%871 = getelementptr inbounds double, double* %870, i64 2
store double %869, double* %871
%872 = load double, double* %24
%873 = load double, double* %25
%874 = fadd double %872, %873
%875 = fdiv double %874, 2.000000e+00
%876 = load double*, double** %17
%877 = getelementptr inbounds double, double* %876, i64 0
store double %875, double* %877
%878 = load double, double* %27
%879 = load double, double* %27
%880 = load double, double* %26
%881 = fsub double %879, %880
%882 = call double @llvm.fmuladd.f64(double 1.000000e-01, double %881, double %878)
%883 = load double*, double** %17
%884 = getelementptr inbounds double, double* %883, i64 1
store double %882, double* %884
%885 = load double, double* %28
%886 = load double, double* %29
%887 = load double, double* %28
%888 = fsub double %886, %887
%889 = fneg double %888
%890 = call double @llvm.fmuladd.f64(double %889, double 2.000000e+00, double %885)
%891 = load double*, double** %17
%892 = getelementptr inbounds double, double* %891, i64 2
store double %890, double* %892
%893 = load double*, double** %15
%894 = getelementptr inbounds double, double* %893, i64 0
store double 0.000000e+00, double* %894
%895 = load double*, double** %15
%896 = getelementptr inbounds double, double* %895, i64 1
store double 0.000000e+00, double* %896
%897 = load double*, double** %15
%898 = getelementptr inbounds double, double* %897, i64 2
store double 1.000000e+00, double* %898
br label %1101
899: ; preds = %848
%900 = load i32, i32* %10
%901 = icmp eq i32 %900, 4
br i1 %901, label %902, label %947
902: ; preds = %899
%903 = load double, double* %24
%904 = load double, double* %25
%905 = fadd double %903, %904
%906 = fdiv double %905, 2.000000e+00
%907 = load double*, double** %13
%908 = getelementptr inbounds double, double* %907, i64 0
store double %906, double* %908
%909 = load double, double* %27
%910 = load double, double* %26
%911 = fadd double %909, %910
%912 = fmul double 5.000000e-01, %911
%913 = load double*, double** %13
%914 = getelementptr inbounds double, double* %913, i64 1
store double %912, double* %914
%915 = load double, double* %29
%916 = load double, double* %29
%917 = load double, double* %28
%918 = fsub double %916, %917
%919 = call double @llvm.fmuladd.f64(double 1.500000e+00, double %918, double %915)
%920 = load double*, double** %13
%921 = getelementptr inbounds double, double* %920, i64 2
store double %919, double* %921
%922 = load double, double* %24
%923 = load double, double* %25
%924 = fadd double %922, %923
%925 = fdiv double %924, 2.000000e+00
%926 = load double*, double** %17
%927 = getelementptr inbounds double, double* %926, i64 0
store double %925, double* %927
%928 = load double, double* %27
%929 = load double, double* %26
%930 = fadd double %928, %929
%931 = fmul double 0x3FE6666666666666, %930
%932 = load double*, double** %17
%933 = getelementptr inbounds double, double* %932, i64 1
store double %931, double* %933
%934 = load double, double* %29
%935 = load double, double* %29
%936 = load double, double* %28
%937 = fsub double %935, %936
%938 = call double @llvm.fmuladd.f64(double %937, double 2.000000e+00, double %934)
%939 = load double*, double** %17
%940 = getelementptr inbounds double, double* %939, i64 2
store double %938, double* %940
%941 = load double*, double** %15
%942 = getelementptr inbounds double, double* %941, i64 0
store double 0.000000e+00, double* %942
%943 = load double*, double** %15
%944 = getelementptr inbounds double, double* %943, i64 1
store double -1.000000e+00, double* %944
%945 = load double*, double** %15
%946 = getelementptr inbounds double, double* %945, i64 2
store double 0.000000e+00, double* %946
br label %1100
947: ; preds = %899
%948 = load i32, i32* %10
%949 = icmp eq i32 %948, 5
br i1 %949, label %950, label %997
950: ; preds = %947
%951 = load double, double* %25
%952 = load double, double* %25
%953 = load double, double* %24
%954 = fsub double %952, %953
%955 = call double @llvm.fmuladd.f64(double 1.500000e+00, double %954, double %951)
%956 = load double*, double** %13
%957 = getelementptr inbounds double, double* %956, i64 0
store double %955, double* %957
%958 = load double, double* %27
%959 = load double, double* %26
%960 = fadd double %958, %959
%961 = fmul double 5.000000e-01, %960
%962 = load double*, double** %13
%963 = getelementptr inbounds double, double* %962, i64 1
store double %961, double* %963
%964 = load double, double* %29
%965 = load double, double* %29
%966 = load double, double* %28
%967 = fsub double %965, %966
%968 = call double @llvm.fmuladd.f64(double 1.500000e+00, double %967, double %964)
%969 = load double*, double** %13
%970 = getelementptr inbounds double, double* %969, i64 2
store double %968, double* %970
%971 = load double, double* %25
%972 = load double, double* %25
%973 = load double, double* %24
%974 = fsub double %972, %973
%975 = call double @llvm.fmuladd.f64(double 5.000000e-01, double %974, double %971)
%976 = load double*, double** %17
%977 = getelementptr inbounds double, double* %976, i64 0
store double %975, double* %977
%978 = load double, double* %27
%979 = load double, double* %26
%980 = fadd double %978, %979
%981 = fmul double 5.000000e-01, %980
%982 = load double*, double** %17
%983 = getelementptr inbounds double, double* %982, i64 1
store double %981, double* %983
%984 = load double, double* %29
%985 = load double, double* %29
%986 = load double, double* %28
%987 = fsub double %985, %986
%988 = call double @llvm.fmuladd.f64(double %987, double 2.000000e+00, double %984)
%989 = load double*, double** %17
%990 = getelementptr inbounds double, double* %989, i64 2
store double %988, double* %990
%991 = load double*, double** %15
%992 = getelementptr inbounds double, double* %991, i64 0
store double 0.000000e+00, double* %992
%993 = load double*, double** %15
%994 = getelementptr inbounds double, double* %993, i64 1
store double 0.000000e+00, double* %994
%995 = load double*, double** %15
%996 = getelementptr inbounds double, double* %995, i64 2
store double 1.000000e+00, double* %996
br label %1099
997: ; preds = %947
%998 = load i32, i32* %10
%999 = icmp eq i32 %998, 6
br i1 %999, label %1000, label %1047
1000: ; preds = %997
%1001 = load double, double* %24
%1002 = load double, double* %25
%1003 = load double, double* %24
%1004 = fsub double %1002, %1003
%1005 = call double @llvm.fmuladd.f64(double -1.500000e+00, double %1004, double %1001)
%1006 = load double*, double** %13
%1007 = getelementptr inbounds double, double* %1006, i64 0
store double %1005, double* %1007
%1008 = load double, double* %27
%1009 = load double, double* %26
%1010 = fadd double %1008, %1009
%1011 = fmul double 5.000000e-01, %1010
%1012 = load double*, double** %13
%1013 = getelementptr inbounds double, double* %1012, i64 1
store double %1011, double* %1013
%1014 = load double, double* %29
%1015 = load double, double* %29
%1016 = load double, double* %28
%1017 = fsub double %1015, %1016
%1018 = call double @llvm.fmuladd.f64(double 1.500000e+00, double %1017, double %1014)
%1019 = load double*, double** %13
%1020 = getelementptr inbounds double, double* %1019, i64 2
store double %1018, double* %1020
%1021 = load double, double* %24
%1022 = load double, double* %25
%1023 = load double, double* %24
%1024 = fsub double %1022, %1023
%1025 = call double @llvm.fmuladd.f64(double -5.000000e-01, double %1024, double %1021)
%1026 = load double*, double** %17
%1027 = getelementptr inbounds double, double* %1026, i64 0
store double %1025, double* %1027
%1028 = load double, double* %27
%1029 = load double, double* %26
%1030 = fadd double %1028, %1029
%1031 = fmul double 5.000000e-01, %1030
%1032 = load double*, double** %17
%1033 = getelementptr inbounds double, double* %1032, i64 1
store double %1031, double* %1033
%1034 = load double, double* %29
%1035 = load double, double* %29
%1036 = load double, double* %28
%1037 = fsub double %1035, %1036
%1038 = call double @llvm.fmuladd.f64(double %1037, double 2.000000e+00, double %1034)
%1039 = load double*, double** %17
%1040 = getelementptr inbounds double, double* %1039, i64 2
store double %1038, double* %1040
%1041 = load double*, double** %15
%1042 = getelementptr inbounds double, double* %1041, i64 0
store double 0.000000e+00, double* %1042
%1043 = load double*, double** %15
%1044 = getelementptr inbounds double, double* %1043, i64 1
store double 0.000000e+00, double* %1044
%1045 = load double*, double** %15
%1046 = getelementptr inbounds double, double* %1045, i64 2
store double 1.000000e+00, double* %1046
br label %1098
1047: ; preds = %997
%1048 = load i32, i32* %10
%1049 = icmp eq i32 %1048, 7
br i1 %1049, label %1050, label %1097
1050: ; preds = %1047
%1051 = load double, double* %25
%1052 = load double, double* %24
%1053 = fadd double %1051, %1052
%1054 = fdiv double %1053, 2.000000e+00
%1055 = load double*, double** %13
%1056 = getelementptr inbounds double, double* %1055, i64 0
store double %1054, double* %1056
%1057 = load double, double* %26
%1058 = load double, double* %27
%1059 = load double, double* %26
%1060 = fsub double %1058, %1059
%1061 = call double @llvm.fmuladd.f64(double -1.500000e+00, double %1060, double %1057)
%1062 = load double*, double** %13
%1063 = getelementptr inbounds double, double* %1062, i64 1
store double %1061, double* %1063
%1064 = load double, double* %29
%1065 = load double, double* %29
%1066 = load double, double* %28
%1067 = fsub double %1065, %1066
%1068 = call double @llvm.fmuladd.f64(double 1.500000e+00, double %1067, double %1064)
%1069 = load double*, double** %13
%1070 = getelementptr inbounds double, double* %1069, i64 2
store double %1068, double* %1070
%1071 = load double, double* %25
%1072 = load double, double* %24
%1073 = fadd double %1071, %1072
%1074 = fdiv double %1073, 2.000000e+00
%1075 = load double*, double** %17
%1076 = getelementptr inbounds double, double* %1075, i64 0
store double %1074, double* %1076
%1077 = load double, double* %26
%1078 = load double, double* %27
%1079 = load double, double* %26
%1080 = fsub double %1078, %1079
%1081 = call double @llvm.fmuladd.f64(double -5.000000e-01, double %1080, double %1077)
%1082 = load double*, double** %17
%1083 = getelementptr inbounds double, double* %1082, i64 1
store double %1081, double* %1083
%1084 = load double, double* %29
%1085 = load double, double* %29
%1086 = load double, double* %28
%1087 = fsub double %1085, %1086
%1088 = call double @llvm.fmuladd.f64(double %1087, double 2.000000e+00, double %1084)
%1089 = load double*, double** %17
%1090 = getelementptr inbounds double, double* %1089, i64 2
store double %1088, double* %1090
%1091 = load double*, double** %15
%1092 = getelementptr inbounds double, double* %1091, i64 0
store double 0.000000e+00, double* %1092
%1093 = load double*, double** %15
%1094 = getelementptr inbounds double, double* %1093, i64 1
store double 0.000000e+00, double* %1094
%1095 = load double*, double** %15
%1096 = getelementptr inbounds double, double* %1095, i64 2
store double 1.000000e+00, double* %1096
br label %1097
1097: ; preds = %1050, %1047
br label %1098
1098: ; preds = %1097, %1000
br label %1099
1099: ; preds = %1098, %950
br label %1100
1100: ; preds = %1099, %902
br label %1101
1101: ; preds = %1100, %851
br label %1102
1102: ; preds = %1101, %802
br label %1103
1103: ; preds = %1102, %752
br label %1104
1104: ; preds = %1103, %712
br label %1105
1105: ; preds = %1104, %709
br label %1106
1106: ; preds = %1105, %55
ret void
}

LLVM IR (-O2):
define void @view_parameter_define(i32 %0, i32 %1, i32 %2, double* %3, double* nocapture writeonly %4, double* %5, i32 %6, double* %7, double* nocapture %8) {
%10 = load double, double* %8
%11 = getelementptr inbounds double, double* %8, i64 1
%12 = bitcast double* %11 to <2 x double>*
%13 = load <2 x double>, <2 x double>* %12
%14 = getelementptr inbounds double, double* %8, i64 3
%15 = load double, double* %14
%16 = insertelement <2 x double> poison, double %10, i64 0
%17 = insertelement <2 x double> %16, double %15, i64 1
%18 = fadd <2 x double> %13, %17
%19 = fmul <2 x double> %18, <double 5.000000e-01, double 5.000000e-01>
%20 = getelementptr inbounds double, double* %8, i64 4
%21 = load double, double* %20
%22 = getelementptr inbounds double, double* %8, i64 5
%23 = load double, double* %22
%24 = fadd double %21, %23
%25 = fmul double %24, 5.000000e-01
%26 = sitofp i32 %1 to double
%27 = fdiv double 0x401921FB4D12D84A, %26
switch i32 %2, label %251 [
i32 0, label %390
i32 1, label %28
i32 2, label %101
i32 3, label %176
]
28: ; preds = %9
store double 1.000000e+00, double* %5
%29 = getelementptr inbounds double, double* %5, i64 1
%30 = getelementptr inbounds double, double* %5, i64 2
%31 = bitcast double* %29 to i8*
%32 = load double, double* %3
%33 = extractelement <2 x double> %19, i64 0
%34 = fsub double %32, %33
%35 = getelementptr inbounds double, double* %3, i64 1
%36 = load double, double* %35
%37 = extractelement <2 x double> %19, i64 1
%38 = fsub double %36, %37
%39 = getelementptr inbounds double, double* %3, i64 2
%40 = load double, double* %39
%41 = fsub double %40, %25
store double %34, double* %3
%42 = tail call double @cos(double %27)
%43 = tail call double @sin(double %27)
%44 = fmul double %41, %43
%45 = tail call double @llvm.fmuladd.f64(double %38, double %42, double %44)
store double %45, double* %35
%46 = fneg double %38
%47 = tail call double @sin(double %27)
%48 = tail call double @cos(double %27)
%49 = fmul double %41, %48
%50 = tail call double @llvm.fmuladd.f64(double %46, double %47, double %49)
%51 = bitcast double* %3 to <2 x double>*
%52 = load <2 x double>, <2 x double>* %51
%53 = fadd <2 x double> %19, %52
%54 = bitcast double* %3 to <2 x double>*
store <2 x double> %53, <2 x double>* %54
%55 = fadd double %25, %50
store double %55, double* %39
%56 = icmp sgt i32 %6, 0
br i1 %56, label %57, label %89
57: ; preds = %28
%58 = zext i32 %6 to i64
br label %59
59: ; preds = %57, %59
%60 = phi i64 [ 0, %57 ], [ %87, %59 ]
%61 = mul nuw nsw i64 %60, 3
%62 = getelementptr inbounds double, double* %7, i64 %61
%63 = load double, double* %62
%64 = fsub double %63, %33
%65 = add nuw nsw i64 %61, 1
%66 = getelementptr inbounds double, double* %7, i64 %65
%67 = load double, double* %66
%68 = fsub double %67, %37
%69 = add nuw nsw i64 %61, 2
%70 = getelementptr inbounds double, double* %7, i64 %69
%71 = load double, double* %70
%72 = fsub double %71, %25
store double %64, double* %62
%73 = tail call double @cos(double %27)
%74 = tail call double @sin(double %27)
%75 = fmul double %72, %74
%76 = tail call double @llvm.fmuladd.f64(double %68, double %73, double %75)
store double %76, double* %66
%77 = fneg double %68
%78 = tail call double @sin(double %27)
%79 = tail call double @cos(double %27)
%80 = fmul double %72, %79
%81 = tail call double @llvm.fmuladd.f64(double %77, double %78, double %80)
store double %81, double* %70
%82 = bitcast double* %62 to <2 x double>*
%83 = load <2 x double>, <2 x double>* %82
%84 = fadd <2 x double> %19, %83
%85 = bitcast double* %62 to <2 x double>*
store <2 x double> %84, <2 x double>* %85
%86 = fadd double %25, %81
store double %86, double* %70
%87 = add nuw nsw i64 %60, 1
%88 = icmp eq i64 %87, %58
br i1 %88, label %89, label %59
89: ; preds = %59, %28
%90 = load double, double* %29
%91 = load double, double* %30
%92 = tail call double @cos(double %27)
%93 = tail call double @sin(double %27)
%94 = fmul double %91, %93
%95 = tail call double @llvm.fmuladd.f64(double %90, double %92, double %94)
store double %95, double* %29
%96 = fneg double %90
%97 = tail call double @sin(double %27)
%98 = tail call double @cos(double %27)
%99 = fmul double %91, %98
%100 = tail call double @llvm.fmuladd.f64(double %96, double %97, double %99)
store double %100, double* %30
br label %251
101: ; preds = %9
%102 = getelementptr inbounds double, double* %5, i64 1
%103 = bitcast double* %5 to <2 x double>*
store <2 x double> <double 0.000000e+00, double 1.000000e+00>, <2 x double>* %103
%104 = getelementptr inbounds double, double* %5, i64 2
store double 0.000000e+00, double* %104
%105 = load double, double* %3
%106 = extractelement <2 x double> %19, i64 0
%107 = fsub double %105, %106
%108 = getelementptr inbounds double, double* %3, i64 1
%109 = load double, double* %108
%110 = extractelement <2 x double> %19, i64 1
%111 = fsub double %109, %110
%112 = getelementptr inbounds double, double* %3, i64 2
%113 = load double, double* %112
%114 = fsub double %113, %25
%115 = tail call double @cos(double %27)
%116 = tail call double @sin(double %27)
%117 = fmul double %114, %116
%118 = tail call double @llvm.fmuladd.f64(double %107, double %115, double %117)
store double %118, double* %3
store double %111, double* %108
%119 = fneg double %107
%120 = tail call double @sin(double %27)
%121 = tail call double @cos(double %27)
%122 = fmul double %114, %121
%123 = tail call double @llvm.fmuladd.f64(double %119, double %120, double %122)
%124 = bitcast double* %3 to <2 x double>*
%125 = load <2 x double>, <2 x double>* %124
%126 = fadd <2 x double> %19, %125
%127 = bitcast double* %3 to <2 x double>*
store <2 x double> %126, <2 x double>* %127
%128 = fadd double %25, %123
store double %128, double* %112
%129 = icmp sgt i32 %6, 0
br i1 %129, label %130, label %162
130: ; preds = %101
%131 = zext i32 %6 to i64
br label %132
132: ; preds = %130, %132
%133 = phi i64 [ 0, %130 ], [ %160, %132 ]
%134 = mul nuw nsw i64 %133, 3
%135 = getelementptr inbounds double, double* %7, i64 %134
%136 = load double, double* %135
%137 = fsub double %136, %106
%138 = add nuw nsw i64 %134, 1
%139 = getelementptr inbounds double, double* %7, i64 %138
%140 = load double, double* %139
%141 = fsub double %140, %110
%142 = add nuw nsw i64 %134, 2
%143 = getelementptr inbounds double, double* %7, i64 %142
%144 = load double, double* %143
%145 = fsub double %144, %25
%146 = tail call double @cos(double %27)
%147 = tail call double @sin(double %27)
%148 = fmul double %145, %147
%149 = tail call double @llvm.fmuladd.f64(double %137, double %146, double %148)
store double %149, double* %135
store double %141, double* %139
%150 = fneg double %137
%151 = tail call double @sin(double %27)
%152 = tail call double @cos(double %27)
%153 = fmul double %145, %152
%154 = tail call double @llvm.fmuladd.f64(double %150, double %151, double %153)
store double %154, double* %143
%155 = bitcast double* %135 to <2 x double>*
%156 = load <2 x double>, <2 x double>* %155
%157 = fadd <2 x double> %19, %156
%158 = bitcast double* %135 to <2 x double>*
store <2 x double> %157, <2 x double>* %158
%159 = fadd double %25, %154
store double %159, double* %143
%160 = add nuw nsw i64 %133, 1
%161 = icmp eq i64 %160, %131
br i1 %161, label %162, label %132
162: ; preds = %132, %101
%163 = load double, double* %5
%164 = load double, double* %102
%165 = load double, double* %104
%166 = tail call double @cos(double %27)
%167 = tail call double @sin(double %27)
%168 = fmul double %165, %167
%169 = tail call double @llvm.fmuladd.f64(double %163, double %166, double %168)
store double %169, double* %5
store double %164, double* %102
%170 = fneg double %163
%171 = tail call double @sin(double %27)
%172 = tail call double @cos(double %27)
%173 = fmul double %165, %172
%174 = tail call double @llvm.fmuladd.f64(double %170, double %171, double %173)
store double %174, double* %104
%175 = icmp eq i32 %2, 3
br i1 %175, label %176, label %251
176: ; preds = %9, %162
%177 = load double, double* %3
%178 = extractelement <2 x double> %19, i64 0
%179 = fsub double %177, %178
%180 = getelementptr inbounds double, double* %3, i64 1
%181 = load double, double* %180
%182 = extractelement <2 x double> %19, i64 1
%183 = fsub double %181, %182
%184 = getelementptr inbounds double, double* %3, i64 2
%185 = load double, double* %184
%186 = fsub double %185, %25
%187 = tail call double @cos(double %27)
%188 = tail call double @sin(double %27)
%189 = fmul double %183, %188
%190 = tail call double @llvm.fmuladd.f64(double %179, double %187, double %189)
store double %190, double* %3
%191 = fneg double %179
%192 = tail call double @sin(double %27)
%193 = tail call double @cos(double %27)
%194 = fmul double %183, %193
%195 = tail call double @llvm.fmuladd.f64(double %191, double %192, double %194)
%196 = load double, double* %3
%197 = insertelement <2 x double> poison, double %196, i64 0
%198 = insertelement <2 x double> %197, double %195, i64 1
%199 = fadd <2 x double> %19, %198
%200 = bitcast double* %3 to <2 x double>*
store <2 x double> %199, <2 x double>* %200
%201 = fadd double %25, %186
store double %201, double* %184
%202 = icmp sgt i32 %6, 0
br i1 %202, label %203, label %236
203: ; preds = %176
%204 = zext i32 %6 to i64
br label %205
205: ; preds = %203, %205
%206 = phi i64 [ 0, %203 ], [ %234, %205 ]
%207 = mul nuw nsw i64 %206, 3
%208 = getelementptr inbounds double, double* %7, i64 %207
%209 = load double, double* %208
%210 = fsub double %209, %178
%211 = add nuw nsw i64 %207, 1
%212 = getelementptr inbounds double, double* %7, i64 %211
%213 = load double, double* %212
%214 = fsub double %213, %182
%215 = add nuw nsw i64 %207, 2
%216 = getelementptr inbounds double, double* %7, i64 %215
%217 = load double, double* %216
%218 = fsub double %217, %25
%219 = tail call double @cos(double %27)
%220 = tail call double @sin(double %27)
%221 = fmul double %214, %220
%222 = tail call double @llvm.fmuladd.f64(double %210, double %219, double %221)
store double %222, double* %208
%223 = fneg double %210
%224 = tail call double @sin(double %27)
%225 = tail call double @cos(double %27)
%226 = fmul double %214, %225
%227 = tail call double @llvm.fmuladd.f64(double %223, double %224, double %226)
%228 = load double, double* %208
%229 = insertelement <2 x double> poison, double %228, i64 0
%230 = insertelement <2 x double> %229, double %227, i64 1
%231 = fadd <2 x double> %19, %230
%232 = bitcast double* %208 to <2 x double>*
store <2 x double> %231, <2 x double>* %232
%233 = fadd double %25, %218
store double %233, double* %216
%234 = add nuw nsw i64 %206, 1
%235 = icmp eq i64 %234, %204
br i1 %235, label %236, label %205
236: ; preds = %205, %176
%237 = load double, double* %5
%238 = getelementptr inbounds double, double* %5, i64 1
%239 = load double, double* %238
%240 = getelementptr inbounds double, double* %5, i64 2
%241 = load double, double* %240
%242 = tail call double @cos(double %27)
%243 = tail call double @sin(double %27)
%244 = fmul double %239, %243
%245 = tail call double @llvm.fmuladd.f64(double %237, double %242, double %244)
store double %245, double* %5
%246 = fneg double %237
%247 = tail call double @sin(double %27)
%248 = tail call double @cos(double %27)
%249 = fmul double %239, %248
%250 = tail call double @llvm.fmuladd.f64(double %246, double %247, double %249)
store double %250, double* %238
store double %241, double* %240
br label %251
251: ; preds = %89, %9, %236, %162
%252 = icmp eq i32 %2, 4
%253 = icmp sgt i32 %0, 0
%254 = and i1 %253, %252
br i1 %254, label %255, label %390
255: ; preds = %251
%256 = load double, double* %8
%257 = bitcast double* %11 to <2 x double>*
%258 = load <2 x double>, <2 x double>* %257
%259 = bitcast double* %14 to <2 x double>*
%260 = load <2 x double>, <2 x double>* %259
%261 = load double, double* %22
%262 = bitcast double* %4 to <2 x double>*
store <2 x double> %19, <2 x double>* %262
%263 = getelementptr inbounds double, double* %4, i64 2
store double %25, double* %263
switch i32 %0, label %390 [
i32 1, label %264
i32 2, label %279
i32 3, label %299
i32 4, label %317
i32 5, label %335
i32 6, label %354
i32 7, label %373
]
264: ; preds = %255
%265 = extractelement <2 x double> %258, i64 0
%266 = fadd double %256, %265
%267 = fmul double %266, 5.000000e-01
store double %267, double* %3
%268 = getelementptr inbounds double, double* %3, i64 1
%269 = insertelement <2 x double> %260, double %261, i64 1
%270 = shufflevector <2 x double> %258, <2 x double> %260, <2 x i32> <i32 1, i32 3>
%271 = fsub <2 x double> %269, %270
%272 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %271, <2 x double> <double 1.500000e+00, double 1.500000e+00>, <2 x double> %269)
%273 = bitcast double* %268 to <2 x double>*
store <2 x double> %272, <2 x double>* %273
store double %267, double* %7
%274 = getelementptr inbounds double, double* %7, i64 1
%275 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %271, <2 x double> <double 1.000000e-01, double 2.000000e+00>, <2 x double> %269)
%276 = bitcast double* %274 to <2 x double>*
store <2 x double> %275, <2 x double>* %276
%277 = getelementptr inbounds double, double* %5, i64 2
%278 = bitcast double* %5 to i8*
store double 1.000000e+00, double* %277
br label %390
279: ; preds = %255
%280 = extractelement <2 x double> %258, i64 0
%281 = fadd double %256, %280
%282 = fmul double %281, 5.000000e-01
store double %282, double* %3
%283 = extractelement <2 x double> %260, i64 0
%284 = insertelement <2 x double> %260, double %261, i64 1
%285 = extractelement <2 x double> %260, i64 1
%286 = shufflevector <2 x double> %258, <2 x double> %260, <2 x i32> <i32 1, i32 3>
%287 = fsub <2 x double> %284, %286
%288 = extractelement <2 x double> %287, i64 0
%289 = tail call double @llvm.fmuladd.f64(double %288, double 1.500000e+00, double %283)
%290 = getelementptr inbounds double, double* %3, i64 1
store double %289, double* %290
%291 = fadd double %285, %261
%292 = fmul double %291, 5.000000e-01
%293 = getelementptr inbounds double, double* %3, i64 2
store double %292, double* %293
store double %282, double* %7
%294 = getelementptr inbounds double, double* %7, i64 1
%295 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %287, <2 x double> <double 1.000000e-01, double 5.000000e-01>, <2 x double> %284)
%296 = bitcast double* %294 to <2 x double>*
store <2 x double> %295, <2 x double>* %296
%297 = getelementptr inbounds double, double* %5, i64 2
%298 = bitcast double* %5 to i8*
store double 1.000000e+00, double* %297
br label %390
299: ; preds = %255
%300 = extractelement <2 x double> %258, i64 0
%301 = fadd double %256, %300
%302 = fmul double %301, 5.000000e-01
store double %302, double* %3
%303 = getelementptr inbounds double, double* %3, i64 1
%304 = insertelement <2 x double> %260, double %261, i64 1
%305 = shufflevector <2 x double> %258, <2 x double> %260, <2 x i32> <i32 1, i32 3>
%306 = fsub <2 x double> %304, %305
%307 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %306, <2 x double> <double 1.500000e+00, double -1.500000e+00>, <2 x double> %260)
%308 = bitcast double* %303 to <2 x double>*
store <2 x double> %307, <2 x double>* %308
store double %302, double* %7
%309 = getelementptr inbounds double, double* %7, i64 1
%310 = extractelement <2 x double> %306, i64 1
%311 = fneg double %310
%312 = insertelement <2 x double> %306, double %311, i64 1
%313 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %312, <2 x double> <double 1.000000e-01, double 2.000000e+00>, <2 x double> %260)
%314 = bitcast double* %309 to <2 x double>*
store <2 x double> %313, <2 x double>* %314
%315 = getelementptr inbounds double, double* %5, i64 2
%316 = bitcast double* %5 to i8*
store double 1.000000e+00, double* %315
br label %390
317: ; preds = %255
%318 = insertelement <2 x double> poison, double %256, i64 0
%319 = shufflevector <2 x double> %318, <2 x double> %260, <2 x i32> <i32 0, i32 2>
%320 = fadd <2 x double> %258, %319
%321 = fmul <2 x double> %320, <double 5.000000e-01, double 5.000000e-01>
%322 = bitcast double* %3 to <2 x double>*
store <2 x double> %321, <2 x double>* %322
%323 = extractelement <2 x double> %260, i64 1
%324 = fsub double %261, %323
%325 = tail call double @llvm.fmuladd.f64(double %324, double 1.500000e+00, double %261)
%326 = getelementptr inbounds double, double* %3, i64 2
store double %325, double* %326
%327 = extractelement <2 x double> %321, i64 0
store double %327, double* %7
%328 = extractelement <2 x double> %320, i64 1
%329 = fmul double %328, 0x3FE6666666666666
%330 = getelementptr inbounds double, double* %7, i64 1
store double %329, double* %330
%331 = tail call double @llvm.fmuladd.f64(double %324, double 2.000000e+00, double %261)
%332 = getelementptr inbounds double, double* %7, i64 2
store double %331, double* %332
%333 = bitcast double* %5 to <2 x double>*
store <2 x double> <double 0.000000e+00, double -1.000000e+00>, <2 x double>* %333
%334 = getelementptr inbounds double, double* %5, i64 2
store double 0.000000e+00, double* %334
br label %390
335: ; preds = %255
%336 = extractelement <2 x double> %258, i64 0
%337 = fsub double %336, %256
%338 = tail call double @llvm.fmuladd.f64(double %337, double 1.500000e+00, double %336)
store double %338, double* %3
%339 = shufflevector <2 x double> %258, <2 x double> poison, <2 x i32> <i32 1, i32 undef>
%340 = fadd <2 x double> %339, %260
%341 = extractelement <2 x double> %340, i64 0
%342 = fmul double %341, 5.000000e-01
%343 = getelementptr inbounds double, double* %3, i64 1
store double %342, double* %343
%344 = extractelement <2 x double> %260, i64 1
%345 = fsub double %261, %344
%346 = tail call double @llvm.fmuladd.f64(double %345, double 1.500000e+00, double %261)
%347 = getelementptr inbounds double, double* %3, i64 2
store double %346, double* %347
%348 = tail call double @llvm.fmuladd.f64(double %337, double 5.000000e-01, double %336)
store double %348, double* %7
%349 = getelementptr inbounds double, double* %7, i64 1
store double %342, double* %349
%350 = tail call double @llvm.fmuladd.f64(double %345, double 2.000000e+00, double %261)
%351 = getelementptr inbounds double, double* %7, i64 2
store double %350, double* %351
%352 = getelementptr inbounds double, double* %5, i64 2
%353 = bitcast double* %5 to i8*
store double 1.000000e+00, double* %352
br label %390
354: ; preds = %255
%355 = extractelement <2 x double> %258, i64 0
%356 = fsub double %355, %256
%357 = tail call double @llvm.fmuladd.f64(double %356, double -1.500000e+00, double %256)
store double %357, double* %3
%358 = shufflevector <2 x double> %258, <2 x double> poison, <2 x i32> <i32 1, i32 undef>
%359 = fadd <2 x double> %358, %260
%360 = extractelement <2 x double> %359, i64 0
%361 = fmul double %360, 5.000000e-01
%362 = getelementptr inbounds double, double* %3, i64 1
store double %361, double* %362
%363 = extractelement <2 x double> %260, i64 1
%364 = fsub double %261, %363
%365 = tail call double @llvm.fmuladd.f64(double %364, double 1.500000e+00, double %261)
%366 = getelementptr inbounds double, double* %3, i64 2
store double %365, double* %366
%367 = tail call double @llvm.fmuladd.f64(double %356, double -5.000000e-01, double %256)
store double %367, double* %7
%368 = getelementptr inbounds double, double* %7, i64 1
store double %361, double* %368
%369 = tail call double @llvm.fmuladd.f64(double %364, double 2.000000e+00, double %261)
%370 = getelementptr inbounds double, double* %7, i64 2
store double %369, double* %370
%371 = getelementptr inbounds double, double* %5, i64 2
%372 = bitcast double* %5 to i8*
store double 1.000000e+00, double* %371
br label %390
373: ; preds = %255
%374 = extractelement <2 x double> %258, i64 0
%375 = fadd double %256, %374
%376 = fmul double %375, 5.000000e-01
store double %376, double* %3
%377 = getelementptr inbounds double, double* %3, i64 1
%378 = insertelement <2 x double> %260, double %261, i64 1
%379 = shufflevector <2 x double> %258, <2 x double> undef, <2 x i32> <i32 1, i32 undef>
%380 = shufflevector <2 x double> %379, <2 x double> %260, <2 x i32> <i32 0, i32 3>
%381 = fsub <2 x double> %378, %380
%382 = insertelement <2 x double> %379, double %261, i64 1
%383 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %381, <2 x double> <double -1.500000e+00, double 1.500000e+00>, <2 x double> %382)
%384 = bitcast double* %377 to <2 x double>*
store <2 x double> %383, <2 x double>* %384
store double %376, double* %7
%385 = getelementptr inbounds double, double* %7, i64 1
%386 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %381, <2 x double> <double -5.000000e-01, double 2.000000e+00>, <2 x double> %382)
%387 = bitcast double* %385 to <2 x double>*
store <2 x double> %386, <2 x double>* %387
%388 = getelementptr inbounds double, double* %5, i64 2
%389 = bitcast double* %5 to i8*
store double 1.000000e+00, double* %388
br label %390
390: ; preds = %255, %9, %251, %264, %299, %335, %373, %354, %317, %279
ret void
}