#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 pow(double, double);
double sin(double);
double deriv4(double *param, int dimension, int functiontype, double x) {
  int i;
  double fourth_derivate = 0;
  switch (functiontype) {
  case 1: {
    int len1 = (dimension - 1);
    double D[len1];
    int len2 = (dimension - 2);
    double DD[len2];
    int len3 = (dimension - 3);
    double DDD[len3];
    int len4 = (dimension - 4);
    double DDDD[len4];
    for (i = 0; i <= len1; i++) {
      D[i] = param[i + 1] * (i + 1);
    }
    for (i = 0; i <= len2; i++) {
      DD[i] = D[i + 1] * (i + 1);
    }
    for (i = 0; i <= len2; i++) {
      DDD[i] = DD[i + 1] * (i + 1);
    }
    for (i = 0; i <= len2; i++) {
      DDDD[i] = DDD[i + 1] * (i + 1);
    }
    for (i = 0; i <= len2; i++) {
      fourth_derivate += DDDD[i] * (pow(x, i));
    }
    break;
  }
  case 2: {
    double a = param[0];
    double b = param[1];
    double n = param[2];
    fourth_derivate = a * (pow(2.7182818284, x)) +
                      b * n * (n - 1) * (n - 2) * (n - 3) * (pow(x, (n - 4)));
    break;
  }
  case 3: {
    double A = param[0];
    double m = param[1];
    double t = param[2];
    double B = param[3];
    double n = param[4];
    double p = param[5];
    fourth_derivate =
        A * m * m * m * m * sin(m * x + t) + B * n * n * n * n * cos(n * x + p);
    break;
  }
  }
  return fourth_derivate;
}


x86 assembly (clang, -O0):
<deriv4>:
push   %rbp
mov    %rsp,%rbp
sub    $0x120,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
movsd  %xmm0,-0x18(%rbp)
movq   $0x0,-0x28(%rbp)
mov    -0x10(%rbp),%eax
mov    %eax,-0xbc(%rbp)
sub    $0x1,%eax
je     1191 <deriv4+0x61>
jmp    1169 <deriv4+0x39>
mov    -0xbc(%rbp),%eax
sub    $0x2,%eax
je     1406 <deriv4+0x2d6>
jmp    117d <deriv4+0x4d>
mov    -0xbc(%rbp),%eax
sub    $0x3,%eax
je     1505 <deriv4+0x3d5>
jmp    1642 <deriv4+0x512>
mov    -0xc(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    %rsp,%rcx
mov    %rcx,-0x38(%rbp)
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0xe0(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x40(%rbp)
mov    -0xc(%rbp),%eax
add    $0xfffffffe,%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0xd8(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x50(%rbp)
mov    -0xc(%rbp),%eax
add    $0xfffffffd,%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0xd0(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x60(%rbp)
mov    -0xc(%rbp),%eax
add    $0xfffffffc,%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0xc8(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x70(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jg     1299 <deriv4+0x169>
mov    -0xe0(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0x1c(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movsd  (%rcx,%rdx,8),%xmm0
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
cvtsi2sd %ecx,%xmm1
mulsd  %xmm1,%xmm0
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    124f <deriv4+0x11f>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     12ed <deriv4+0x1bd>
mov    -0xd8(%rbp),%rax
mov    -0xe0(%rbp),%rcx
mov    -0x1c(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movsd  (%rcx,%rdx,8),%xmm0
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
cvtsi2sd %ecx,%xmm1
mulsd  %xmm1,%xmm0
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    12a0 <deriv4+0x170>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     1341 <deriv4+0x211>
mov    -0xd0(%rbp),%rax
mov    -0xd8(%rbp),%rcx
mov    -0x1c(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movsd  (%rcx,%rdx,8),%xmm0
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
cvtsi2sd %ecx,%xmm1
mulsd  %xmm1,%xmm0
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    12f4 <deriv4+0x1c4>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     1395 <deriv4+0x265>
mov    -0xc8(%rbp),%rax
mov    -0xd0(%rbp),%rcx
mov    -0x1c(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movsd  (%rcx,%rdx,8),%xmm0
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
cvtsi2sd %ecx,%xmm1
mulsd  %xmm1,%xmm0
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1348 <deriv4+0x218>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     13fa <deriv4+0x2ca>
mov    -0xc8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0x18(%rbp),%xmm0
cvtsi2sdl -0x1c(%rbp),%xmm1
call   1050 <pow@plt>
movaps %xmm0,%xmm2
movsd  -0xe8(%rbp),%xmm0
ff
movsd  -0x28(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x28(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    139c <deriv4+0x26c>
mov    -0x38(%rbp),%rax
mov    %rax,%rsp
jmp    1642 <deriv4+0x512>
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  -0x18(%rbp),%xmm1
movsd  0xbd4(%rip),%xmm0
call   1050 <pow@plt>
movsd  %xmm0,-0xf8(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
mulsd  -0x88(%rbp),%xmm0
ff
movsd  -0x88(%rbp),%xmm1
ff
movsd  0xba2(%rip),%xmm2
subsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  -0x88(%rbp),%xmm1
ff
movsd  0xb82(%rip),%xmm2
subsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  -0x88(%rbp),%xmm1
ff
movsd  0xb62(%rip),%xmm2
subsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
movsd  -0x18(%rbp),%xmm0
movsd  -0x88(%rbp),%xmm1
ff
movsd  0xb35(%rip),%xmm2
subsd  %xmm2,%xmm1
call   1050 <pow@plt>
movsd  -0x100(%rbp),%xmm1
ff
movsd  -0xf8(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0xf0(%rbp),%xmm0
ff
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x28(%rbp)
jmp    1642 <deriv4+0x512>
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
mulsd  -0x98(%rbp),%xmm0
ff
mulsd  -0x98(%rbp),%xmm0
ff
mulsd  -0x98(%rbp),%xmm0
ff
mulsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x108(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0x18(%rbp),%xmm2
movsd  -0xa0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1030 <sin@plt>
movsd  %xmm0,-0x110(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
mulsd  -0xb0(%rbp),%xmm0
ff
mulsd  -0xb0(%rbp),%xmm0
ff
mulsd  -0xb0(%rbp),%xmm0
ff
mulsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0x118(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
movsd  -0x18(%rbp),%xmm2
movsd  -0xb8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1040 <cos@plt>
movsd  -0x118(%rbp),%xmm1
ff
movsd  -0x110(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0x108(%rbp),%xmm0
ff
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x28(%rbp)
movsd  -0x28(%rbp),%xmm0
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<deriv4>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
movapd %xmm0,%xmm9
cmp    $0x3,%edx
je     11e8 <deriv4+0xb8>
cmp    $0x2,%edx
je     127c <deriv4+0x14c>
pxor   %xmm2,%xmm2
cmp    $0x1,%edx
jne    177c <deriv4+0x64c>
mov    %rsp,%r14
lea    -0x1(%rsi),%r15d
mov    %rsp,%rdx
lea    0xf(,%r15,8),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%rdx
mov    %rdx,%rsp
lea    -0x2(%rsi),%eax
mov    %rsp,%r9
lea    0xf(,%rax,8),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%r9
mov    %r9,%rsp
lea    -0x3(%rsi),%eax
mov    %rsp,%r8
lea    0xf(,%rax,8),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%r8
mov    %r8,%rsp
lea    -0x4(%rsi),%eax
mov    %rsp,%r12
lea    0xf(,%rax,8),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%r12
mov    %r12,%rsp
pxor   %xmm2,%xmm2
test   %esi,%esi
jle    1779 <deriv4+0x649>
mov    %esi,%r10d
cmp    $0x4,%esi
jae    1323 <deriv4+0x1f3>
xor    %ebx,%ebx
jmp    13c0 <deriv4+0x290>
movsd  0x8(%rdi),%xmm0
movsd  0x20(%rdi),%xmm3
movsd  (%rdi),%xmm2
mulsd  %xmm0,%xmm2
mulsd  %xmm0,%xmm2
mulsd  %xmm0,%xmm2
mulsd  %xmm0,%xmm2
movsd  %xmm2,-0x38(%rbp)
mulsd  %xmm9,%xmm0
addsd  0x10(%rdi),%xmm0
movsd  0x18(%rdi),%xmm1
movsd  %xmm3,-0x50(%rbp)
mulsd  %xmm3,%xmm1
movsd  %xmm1,-0x30(%rbp)
mulsd  %xmm3,%xmm9
addsd  0x28(%rdi),%xmm9
movsd  %xmm9,-0x40(%rbp)
call   1030 <sin@plt>
movsd  %xmm0,-0x48(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  -0x30(%rbp),%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,-0x30(%rbp)
movsd  -0x40(%rbp),%xmm0
call   1040 <cos@plt>
mulsd  -0x30(%rbp),%xmm0
movsd  -0x48(%rbp),%xmm1
mulsd  -0x38(%rbp),%xmm1
jmp    131a <deriv4+0x1ea>
movsd  (%rdi),%xmm0
movsd  %xmm0,-0x30(%rbp)
movsd  0x10(%rdi),%xmm1
movsd  %xmm1,-0x50(%rbp)
movsd  0x8(%rdi),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  0xd5b(%rip),%xmm0
movsd  %xmm9,-0x40(%rbp)
movapd %xmm9,%xmm1
call   1050 <pow@plt>
movsd  %xmm0,-0x38(%rbp)
movsd  0xd46(%rip),%xmm0
movsd  -0x50(%rbp),%xmm2
addsd  %xmm2,%xmm0
mulsd  -0x48(%rbp),%xmm0
movsd  0xd38(%rip),%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm0,%xmm1
movsd  0xd30(%rip),%xmm0
addsd  %xmm2,%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
addsd  0xd23(%rip),%xmm2
movapd %xmm2,%xmm1
movsd  -0x40(%rbp),%xmm0
call   1050 <pow@plt>
mulsd  -0x48(%rbp),%xmm0
movsd  -0x38(%rbp),%xmm1
mulsd  -0x30(%rbp),%xmm1
addsd  %xmm1,%xmm0
jmp    1780 <deriv4+0x650>
mov    %r10d,%ebx
and    $0xfffffffc,%ebx
xor    %ecx,%ecx
movdqa 0xcfc(%rip),%xmm8
movdqa 0xd03(%rip),%xmm10
movdqa 0xd0b(%rip),%xmm1
cs nopw 0x0(%rax,%rax,1)
nop
movq   %rcx,%xmm3
pshufd $0x44,%xmm3,%xmm4
movdqa %xmm4,%xmm5
por    %xmm8,%xmm5
por    %xmm10,%xmm3
paddq  %xmm1,%xmm4
movq   %xmm5,%rax
movupd (%rdi,%rax,8),%xmm6
movupd 0x10(%rdi,%rax,8),%xmm7
pshufd $0xfa,%xmm5,%xmm5
movd   %eax,%xmm0
movss  %xmm0,%xmm5
pshufd $0xee,%xmm4,%xmm0
punpckldq %xmm0,%xmm3
cvtdq2pd %xmm5,%xmm0
mulpd  %xmm6,%xmm0
cvtdq2pd %xmm3,%xmm3
mulpd  %xmm7,%xmm3
movapd %xmm0,(%rdx,%rcx,8)
movapd %xmm3,0x10(%rdx,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%rbx
jne    1350 <deriv4+0x220>
cmp    %r10,%rbx
je     13de <deriv4+0x2ae>
nopl   0x0(%rax,%rax,1)
lea    0x1(%rbx),%rax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mulsd  0x8(%rdi,%rbx,8),%xmm0
movsd  %xmm0,(%rdx,%rbx,8)
mov    %rax,%rbx
cmp    %rax,%r10
jne    13c0 <deriv4+0x290>
cmp    $0x2,%esi
jl     1779 <deriv4+0x649>
cmp    $0x4,%r15d
jae    13f4 <deriv4+0x2c4>
xor    %eax,%eax
jmp    1490 <deriv4+0x360>
mov    %r15d,%eax
and    $0xfffffffc,%eax
xor    %ecx,%ecx
movdqa 0xc2b(%rip),%xmm8
movdqa 0xc32(%rip),%xmm10
movdqa 0xc3a(%rip),%xmm1
cs nopw 0x0(%rax,%rax,1)
movq   %rcx,%xmm3
pshufd $0x44,%xmm3,%xmm4
movdqa %xmm4,%xmm5
por    %xmm8,%xmm5
por    %xmm10,%xmm3
paddq  %xmm1,%xmm4
movq   %xmm5,%rdi
movupd (%rdx,%rdi,8),%xmm6
movupd 0x10(%rdx,%rdi,8),%xmm7
pshufd $0xfa,%xmm5,%xmm5
movd   %edi,%xmm0
movss  %xmm0,%xmm5
pshufd $0xee,%xmm4,%xmm0
punpckldq %xmm0,%xmm3
cvtdq2pd %xmm5,%xmm0
mulpd  %xmm6,%xmm0
cvtdq2pd %xmm3,%xmm3
mulpd  %xmm7,%xmm3
movapd %xmm0,(%r9,%rcx,8)
movapd %xmm3,0x10(%r9,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%rax
jne    1420 <deriv4+0x2f0>
cmp    %r15,%rax
je     14af <deriv4+0x37f>
nopl   (%rax)
lea    0x1(%rax),%rcx
xorps  %xmm0,%xmm0
cvtsi2sd %ecx,%xmm0
mulsd  0x8(%rdx,%rax,8),%xmm0
movsd  %xmm0,(%r9,%rax,8)
mov    %rcx,%rax
cmp    %rcx,%r15
jne    1490 <deriv4+0x360>
cmp    $0x2,%esi
jl     1779 <deriv4+0x649>
movsd  %xmm9,-0x40(%rbp)
cmp    $0x4,%r15d
jae    14cb <deriv4+0x39b>
xor    %eax,%eax
jmp    1560 <deriv4+0x430>
mov    %r15d,%eax
and    $0xfffffffc,%eax
xor    %ecx,%ecx
movdqa 0xb54(%rip),%xmm8
movdqa 0xb5c(%rip),%xmm1
movdqa 0xb64(%rip),%xmm2
nopl   0x0(%rax)
movq   %rcx,%xmm3
pshufd $0x44,%xmm3,%xmm4
movdqa %xmm4,%xmm5
por    %xmm8,%xmm5
por    %xmm1,%xmm3
paddq  %xmm2,%xmm4
movq   %xmm5,%rdx
movupd (%r9,%rdx,8),%xmm6
movupd 0x10(%r9,%rdx,8),%xmm7
pshufd $0xfa,%xmm5,%xmm5
movd   %edx,%xmm0
movss  %xmm0,%xmm5
pshufd $0xee,%xmm4,%xmm0
punpckldq %xmm0,%xmm3
cvtdq2pd %xmm5,%xmm0
mulpd  %xmm6,%xmm0
cvtdq2pd %xmm3,%xmm3
mulpd  %xmm7,%xmm3
movapd %xmm0,(%r8,%rcx,8)
movapd %xmm3,0x10(%r8,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%rax
jne    14f0 <deriv4+0x3c0>
cmp    %r15,%rax
je     1580 <deriv4+0x450>
xchg   %ax,%ax
lea    0x1(%rax),%rcx
xorps  %xmm0,%xmm0
cvtsi2sd %ecx,%xmm0
mulsd  0x8(%r9,%rax,8),%xmm0
movsd  %xmm0,(%r8,%rax,8)
mov    %rcx,%rax
cmp    %rcx,%r15
jne    1560 <deriv4+0x430>
cmp    $0x4,%r15d
jae    158d <deriv4+0x45d>
xor    %eax,%eax
jmp    1620 <deriv4+0x4f0>
mov    %r15d,%eax
and    $0xfffffffc,%eax
xor    %ecx,%ecx
movdqa 0xa92(%rip),%xmm8
movdqa 0xa9a(%rip),%xmm1
movdqa 0xaa2(%rip),%xmm2
xchg   %ax,%ax
movq   %rcx,%xmm3
pshufd $0x44,%xmm3,%xmm4
movdqa %xmm4,%xmm5
por    %xmm8,%xmm5
por    %xmm1,%xmm3
paddq  %xmm2,%xmm4
movq   %xmm5,%rdx
movupd (%r8,%rdx,8),%xmm6
movupd 0x10(%r8,%rdx,8),%xmm7
pshufd $0xfa,%xmm5,%xmm5
movd   %edx,%xmm0
movss  %xmm0,%xmm5
pshufd $0xee,%xmm4,%xmm0
punpckldq %xmm0,%xmm3
cvtdq2pd %xmm5,%xmm0
mulpd  %xmm6,%xmm0
cvtdq2pd %xmm3,%xmm3
mulpd  %xmm7,%xmm3
movapd %xmm0,(%r12,%rcx,8)
movapd %xmm3,0x10(%r12,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%rax
jne    15b0 <deriv4+0x480>
cmp    %r15,%rax
je     1640 <deriv4+0x510>
xchg   %ax,%ax
lea    0x1(%rax),%rcx
xorps  %xmm0,%xmm0
cvtsi2sd %ecx,%xmm0
mulsd  0x8(%r8,%rax,8),%xmm0
movsd  %xmm0,(%r12,%rax,8)
mov    %rcx,%rax
cmp    %rcx,%r15
jne    1620 <deriv4+0x4f0>
lea    -0x1(%r15),%rax
mov    %r15d,%r13d
and    $0x3,%r13d
cmp    $0x3,%rax
jae    165c <deriv4+0x52c>
pxor   %xmm2,%xmm2
xor    %ebx,%ebx
jmp    1739 <deriv4+0x609>
and    $0xfffffffc,%r15d
pxor   %xmm2,%xmm2
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
movq   %xmm2,-0x30(%rbp)
movsd  (%r12,%rbx,8),%xmm0
movsd  %xmm0,-0x38(%rbp)
xorps  %xmm1,%xmm1
cvtsi2sd %ebx,%xmm1
movsd  -0x40(%rbp),%xmm0
call   1050 <pow@plt>
mulsd  -0x38(%rbp),%xmm0
addsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x30(%rbp)
movsd  0x8(%r12,%rbx,8),%xmm0
movsd  %xmm0,-0x38(%rbp)
lea    0x1(%rbx),%eax
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
movsd  -0x40(%rbp),%xmm0
call   1050 <pow@plt>
mulsd  -0x38(%rbp),%xmm0
addsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x30(%rbp)
movsd  0x10(%r12,%rbx,8),%xmm0
movsd  %xmm0,-0x38(%rbp)
lea    0x2(%rbx),%eax
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
movsd  -0x40(%rbp),%xmm0
call   1050 <pow@plt>
mulsd  -0x38(%rbp),%xmm0
addsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x30(%rbp)
movsd  0x18(%r12,%rbx,8),%xmm0
movsd  %xmm0,-0x38(%rbp)
lea    0x3(%rbx),%eax
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
movsd  -0x40(%rbp),%xmm0
call   1050 <pow@plt>
movapd %xmm0,%xmm2
mulsd  -0x38(%rbp),%xmm2
addsd  -0x30(%rbp),%xmm2
add    $0x4,%rbx
cmp    %r15,%rbx
jne    1670 <deriv4+0x540>
test   %r13,%r13
je     1779 <deriv4+0x649>
xchg   %ax,%ax
movq   %xmm2,-0x30(%rbp)
movsd  (%r12,%rbx,8),%xmm0
movsd  %xmm0,-0x38(%rbp)
xorps  %xmm1,%xmm1
cvtsi2sd %ebx,%xmm1
movsd  -0x40(%rbp),%xmm0
call   1050 <pow@plt>
movsd  -0x30(%rbp),%xmm2
mulsd  -0x38(%rbp),%xmm0
addsd  %xmm0,%xmm2
add    $0x1,%rbx
add    $0xffffffffffffffff,%r13
jne    1740 <deriv4+0x610>
mov    %r14,%rsp
movdqa %xmm2,%xmm0
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define double @deriv4(double* %0, i32 %1, i32 %2, double %3) {
%5 = alloca double*
%6 = alloca i32
%7 = alloca i32
%8 = alloca double
%9 = alloca i32
%10 = alloca double
%11 = alloca i32
%12 = alloca i8*
%13 = alloca i64
%14 = alloca i32
%15 = alloca i64
%16 = alloca i32
%17 = alloca i64
%18 = alloca i32
%19 = alloca i64
%20 = alloca double
%21 = alloca double
%22 = alloca double
%23 = alloca double
%24 = alloca double
%25 = alloca double
%26 = alloca double
%27 = alloca double
%28 = alloca double
store double* %0, double** %5
store i32 %1, i32* %6
store i32 %2, i32* %7
store double %3, double* %8
store double 0.000000e+00, double* %10
%29 = load i32, i32* %7
switch i32 %29, label %237 [
i32 1, label %30
i32 2, label %157
i32 3, label %188
]
30: ; preds = %4
%31 = load i32, i32* %6
%32 = sub nsw i32 %31, 1
store i32 %32, i32* %11
%33 = load i32, i32* %11
%34 = zext i32 %33 to i64
%35 = call i8* @llvm.stacksave()
store i8* %35, i8** %12
%36 = alloca double, i64 %34
store i64 %34, i64* %13
%37 = load i32, i32* %6
%38 = sub nsw i32 %37, 2
store i32 %38, i32* %14
%39 = load i32, i32* %14
%40 = zext i32 %39 to i64
%41 = alloca double, i64 %40
store i64 %40, i64* %15
%42 = load i32, i32* %6
%43 = sub nsw i32 %42, 3
store i32 %43, i32* %16
%44 = load i32, i32* %16
%45 = zext i32 %44 to i64
%46 = alloca double, i64 %45
store i64 %45, i64* %17
%47 = load i32, i32* %6
%48 = sub nsw i32 %47, 4
store i32 %48, i32* %18
%49 = load i32, i32* %18
%50 = zext i32 %49 to i64
%51 = alloca double, i64 %50
store i64 %50, i64* %19
store i32 0, i32* %9
br label %52
52: ; preds = %70, %30
%53 = load i32, i32* %9
%54 = load i32, i32* %11
%55 = icmp sle i32 %53, %54
br i1 %55, label %56, label %73
56: ; preds = %52
%57 = load double*, double** %5
%58 = load i32, i32* %9
%59 = add nsw i32 %58, 1
%60 = sext i32 %59 to i64
%61 = getelementptr inbounds double, double* %57, i64 %60
%62 = load double, double* %61
%63 = load i32, i32* %9
%64 = add nsw i32 %63, 1
%65 = sitofp i32 %64 to double
%66 = fmul double %62, %65
%67 = load i32, i32* %9
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds double, double* %36, i64 %68
store double %66, double* %69
br label %70
70: ; preds = %56
%71 = load i32, i32* %9
%72 = add nsw i32 %71, 1
store i32 %72, i32* %9
br label %52
73: ; preds = %52
store i32 0, i32* %9
br label %74
74: ; preds = %91, %73
%75 = load i32, i32* %9
%76 = load i32, i32* %14
%77 = icmp sle i32 %75, %76
br i1 %77, label %78, label %94
78: ; preds = %74
%79 = load i32, i32* %9
%80 = add nsw i32 %79, 1
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds double, double* %36, i64 %81
%83 = load double, double* %82
%84 = load i32, i32* %9
%85 = add nsw i32 %84, 1
%86 = sitofp i32 %85 to double
%87 = fmul double %83, %86
%88 = load i32, i32* %9
%89 = sext i32 %88 to i64
%90 = getelementptr inbounds double, double* %41, i64 %89
store double %87, double* %90
br label %91
91: ; preds = %78
%92 = load i32, i32* %9
%93 = add nsw i32 %92, 1
store i32 %93, i32* %9
br label %74
94: ; preds = %74
store i32 0, i32* %9
br label %95
95: ; preds = %112, %94
%96 = load i32, i32* %9
%97 = load i32, i32* %14
%98 = icmp sle i32 %96, %97
br i1 %98, label %99, label %115
99: ; preds = %95
%100 = load i32, i32* %9
%101 = add nsw i32 %100, 1
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds double, double* %41, i64 %102
%104 = load double, double* %103
%105 = load i32, i32* %9
%106 = add nsw i32 %105, 1
%107 = sitofp i32 %106 to double
%108 = fmul double %104, %107
%109 = load i32, i32* %9
%110 = sext i32 %109 to i64
%111 = getelementptr inbounds double, double* %46, i64 %110
store double %108, double* %111
br label %112
112: ; preds = %99
%113 = load i32, i32* %9
%114 = add nsw i32 %113, 1
store i32 %114, i32* %9
br label %95
115: ; preds = %95
store i32 0, i32* %9
br label %116
116: ; preds = %133, %115
%117 = load i32, i32* %9
%118 = load i32, i32* %14
%119 = icmp sle i32 %117, %118
br i1 %119, label %120, label %136
120: ; preds = %116
%121 = load i32, i32* %9
%122 = add nsw i32 %121, 1
%123 = sext i32 %122 to i64
%124 = getelementptr inbounds double, double* %46, i64 %123
%125 = load double, double* %124
%126 = load i32, i32* %9
%127 = add nsw i32 %126, 1
%128 = sitofp i32 %127 to double
%129 = fmul double %125, %128
%130 = load i32, i32* %9
%131 = sext i32 %130 to i64
%132 = getelementptr inbounds double, double* %51, i64 %131
store double %129, double* %132
br label %133
133: ; preds = %120
%134 = load i32, i32* %9
%135 = add nsw i32 %134, 1
store i32 %135, i32* %9
br label %116
136: ; preds = %116
store i32 0, i32* %9
br label %137
137: ; preds = %152, %136
%138 = load i32, i32* %9
%139 = load i32, i32* %14
%140 = icmp sle i32 %138, %139
br i1 %140, label %141, label %155
141: ; preds = %137
%142 = load i32, i32* %9
%143 = sext i32 %142 to i64
%144 = getelementptr inbounds double, double* %51, i64 %143
%145 = load double, double* %144
%146 = load double, double* %8
%147 = load i32, i32* %9
%148 = sitofp i32 %147 to double
%149 = call double @pow(double %146, double %148)
%150 = load double, double* %10
%151 = call double @llvm.fmuladd.f64(double %145, double %149, double %150)
store double %151, double* %10
br label %152
152: ; preds = %141
%153 = load i32, i32* %9
%154 = add nsw i32 %153, 1
store i32 %154, i32* %9
br label %137
155: ; preds = %137
%156 = load i8*, i8** %12
br label %237
157: ; preds = %4
%158 = load double*, double** %5
%159 = getelementptr inbounds double, double* %158, i64 0
%160 = load double, double* %159
store double %160, double* %20
%161 = load double*, double** %5
%162 = getelementptr inbounds double, double* %161, i64 1
%163 = load double, double* %162
store double %163, double* %21
%164 = load double*, double** %5
%165 = getelementptr inbounds double, double* %164, i64 2
%166 = load double, double* %165
store double %166, double* %22
%167 = load double, double* %20
%168 = load double, double* %8
%169 = call double @pow(double 0x4005BF0A8B12500B, double %168)
%170 = load double, double* %21
%171 = load double, double* %22
%172 = fmul double %170, %171
%173 = load double, double* %22
%174 = fsub double %173, 1.000000e+00
%175 = fmul double %172, %174
%176 = load double, double* %22
%177 = fsub double %176, 2.000000e+00
%178 = fmul double %175, %177
%179 = load double, double* %22
%180 = fsub double %179, 3.000000e+00
%181 = fmul double %178, %180
%182 = load double, double* %8
%183 = load double, double* %22
%184 = fsub double %183, 4.000000e+00
%185 = call double @pow(double %182, double %184)
%186 = fmul double %181, %185
%187 = call double @llvm.fmuladd.f64(double %167, double %169, double %186)
store double %187, double* %10
br label %237
188: ; preds = %4
%189 = load double*, double** %5
%190 = getelementptr inbounds double, double* %189, i64 0
%191 = load double, double* %190
store double %191, double* %23
%192 = load double*, double** %5
%193 = getelementptr inbounds double, double* %192, i64 1
%194 = load double, double* %193
store double %194, double* %24
%195 = load double*, double** %5
%196 = getelementptr inbounds double, double* %195, i64 2
%197 = load double, double* %196
store double %197, double* %25
%198 = load double*, double** %5
%199 = getelementptr inbounds double, double* %198, i64 3
%200 = load double, double* %199
store double %200, double* %26
%201 = load double*, double** %5
%202 = getelementptr inbounds double, double* %201, i64 4
%203 = load double, double* %202
store double %203, double* %27
%204 = load double*, double** %5
%205 = getelementptr inbounds double, double* %204, i64 5
%206 = load double, double* %205
store double %206, double* %28
%207 = load double, double* %23
%208 = load double, double* %24
%209 = fmul double %207, %208
%210 = load double, double* %24
%211 = fmul double %209, %210
%212 = load double, double* %24
%213 = fmul double %211, %212
%214 = load double, double* %24
%215 = fmul double %213, %214
%216 = load double, double* %24
%217 = load double, double* %8
%218 = load double, double* %25
%219 = call double @llvm.fmuladd.f64(double %216, double %217, double %218)
%220 = call double @sin(double %219)
%221 = load double, double* %26
%222 = load double, double* %27
%223 = fmul double %221, %222
%224 = load double, double* %27
%225 = fmul double %223, %224
%226 = load double, double* %27
%227 = fmul double %225, %226
%228 = load double, double* %27
%229 = fmul double %227, %228
%230 = load double, double* %27
%231 = load double, double* %8
%232 = load double, double* %28
%233 = call double @llvm.fmuladd.f64(double %230, double %231, double %232)
%234 = call double @cos(double %233)
%235 = fmul double %229, %234
%236 = call double @llvm.fmuladd.f64(double %215, double %220, double %235)
store double %236, double* %10
br label %237
237: ; preds = %4, %188, %157, %155
%238 = load double, double* %10
ret double %238
}

LLVM IR (-O2):
define double @deriv4(double* nocapture %0, i32 %1, i32 %2, double %3) {
switch i32 %2, label %308 [
i32 1, label %5
i32 2, label %264
i32 3, label %282
]
5: ; preds = %4
%6 = add i32 %1, -1
%7 = zext i32 %6 to i64
%8 = tail call i8* @llvm.stacksave()
%9 = alloca double, i64 %7
%10 = add nsw i32 %1, -2
%11 = zext i32 %10 to i64
%12 = alloca double, i64 %11
%13 = add nsw i32 %1, -3
%14 = zext i32 %13 to i64
%15 = alloca double, i64 %14
%16 = add nsw i32 %1, -4
%17 = zext i32 %16 to i64
%18 = alloca double, i64 %17
%19 = icmp sgt i32 %1, 0
br i1 %19, label %20, label %262
20: ; preds = %5
%21 = zext i32 %1 to i64
%22 = icmp ult i32 %1, 4
br i1 %22, label %54, label %23
23: ; preds = %20
%24 = and i64 %21, 4294967292
br label %25
25: ; preds = %25, %23
%26 = phi i64 [ 0, %23 ], [ %50, %25 ]
%27 = insertelement <2 x i64> poison, i64 %26, i64 0
%28 = shufflevector <2 x i64> %27, <2 x i64> poison, <2 x i32> zeroinitializer
%29 = or <2 x i64> %28, <i64 1, i64 2>
%30 = or <2 x i64> %28, <i64 3, i64 poison>
%31 = add <2 x i64> %28, <i64 poison, i64 4>
%32 = shufflevector <2 x i64> %30, <2 x i64> %31, <2 x i32> <i32 0, i32 3>
%33 = extractelement <2 x i64> %29, i64 0
%34 = getelementptr inbounds double, double* %0, i64 %33
%35 = bitcast double* %34 to <2 x double>*
%36 = load <2 x double>, <2 x double>* %35
%37 = getelementptr inbounds double, double* %34, i64 2
%38 = bitcast double* %37 to <2 x double>*
%39 = load <2 x double>, <2 x double>* %38
%40 = trunc <2 x i64> %29 to <2 x i32>
%41 = trunc <2 x i64> %32 to <2 x i32>
%42 = sitofp <2 x i32> %40 to <2 x double>
%43 = sitofp <2 x i32> %41 to <2 x double>
%44 = fmul <2 x double> %36, %42
%45 = fmul <2 x double> %39, %43
%46 = getelementptr inbounds double, double* %9, i64 %26
%47 = bitcast double* %46 to <2 x double>*
store <2 x double> %44, <2 x double>* %47
%48 = getelementptr inbounds double, double* %46, i64 2
%49 = bitcast double* %48 to <2 x double>*
store <2 x double> %45, <2 x double>* %49
%50 = add nuw i64 %26, 4
%51 = icmp eq i64 %50, %24
br i1 %51, label %52, label %25
52: ; preds = %25
%53 = icmp eq i64 %24, %21
br i1 %53, label %56, label %54
54: ; preds = %20, %52
%55 = phi i64 [ 0, %20 ], [ %24, %52 ]
br label %93
56: ; preds = %93, %52
%57 = icmp slt i32 %1, 2
br i1 %57, label %262, label %58
58: ; preds = %56
%59 = icmp ult i32 %6, 4
br i1 %59, label %91, label %60
60: ; preds = %58
%61 = and i64 %7, 4294967292
br label %62
62: ; preds = %62, %60
%63 = phi i64 [ 0, %60 ], [ %87, %62 ]
%64 = insertelement <2 x i64> poison, i64 %63, i64 0
%65 = shufflevector <2 x i64> %64, <2 x i64> poison, <2 x i32> zeroinitializer
%66 = or <2 x i64> %65, <i64 1, i64 2>
%67 = or <2 x i64> %65, <i64 3, i64 poison>
%68 = add <2 x i64> %65, <i64 poison, i64 4>
%69 = shufflevector <2 x i64> %67, <2 x i64> %68, <2 x i32> <i32 0, i32 3>
%70 = extractelement <2 x i64> %66, i64 0
%71 = getelementptr inbounds double, double* %9, i64 %70
%72 = bitcast double* %71 to <2 x double>*
%73 = load <2 x double>, <2 x double>* %72
%74 = getelementptr inbounds double, double* %71, i64 2
%75 = bitcast double* %74 to <2 x double>*
%76 = load <2 x double>, <2 x double>* %75
%77 = trunc <2 x i64> %66 to <2 x i32>
%78 = trunc <2 x i64> %69 to <2 x i32>
%79 = sitofp <2 x i32> %77 to <2 x double>
%80 = sitofp <2 x i32> %78 to <2 x double>
%81 = fmul <2 x double> %73, %79
%82 = fmul <2 x double> %76, %80
%83 = getelementptr inbounds double, double* %12, i64 %63
%84 = bitcast double* %83 to <2 x double>*
store <2 x double> %81, <2 x double>* %84
%85 = getelementptr inbounds double, double* %83, i64 2
%86 = bitcast double* %85 to <2 x double>*
store <2 x double> %82, <2 x double>* %86
%87 = add nuw i64 %63, 4
%88 = icmp eq i64 %87, %61
br i1 %88, label %89, label %62
89: ; preds = %62
%90 = icmp eq i64 %61, %7
br i1 %90, label %103, label %91
91: ; preds = %58, %89
%92 = phi i64 [ 0, %58 ], [ %61, %89 ]
br label %139
93: ; preds = %54, %93
%94 = phi i64 [ %95, %93 ], [ %55, %54 ]
%95 = add nuw nsw i64 %94, 1
%96 = getelementptr inbounds double, double* %0, i64 %95
%97 = load double, double* %96
%98 = trunc i64 %95 to i32
%99 = sitofp i32 %98 to double
%100 = fmul double %97, %99
%101 = getelementptr inbounds double, double* %9, i64 %94
store double %100, double* %101
%102 = icmp eq i64 %95, %21
br i1 %102, label %56, label %93
103: ; preds = %139, %89
br i1 %57, label %262, label %104
104: ; preds = %103
%105 = icmp ult i32 %6, 4
br i1 %105, label %137, label %106
106: ; preds = %104
%107 = and i64 %7, 4294967292
br label %108
108: ; preds = %108, %106
%109 = phi i64 [ 0, %106 ], [ %133, %108 ]
%110 = insertelement <2 x i64> poison, i64 %109, i64 0
%111 = shufflevector <2 x i64> %110, <2 x i64> poison, <2 x i32> zeroinitializer
%112 = or <2 x i64> %111, <i64 1, i64 2>
%113 = or <2 x i64> %111, <i64 3, i64 poison>
%114 = add <2 x i64> %111, <i64 poison, i64 4>
%115 = shufflevector <2 x i64> %113, <2 x i64> %114, <2 x i32> <i32 0, i32 3>
%116 = extractelement <2 x i64> %112, i64 0
%117 = getelementptr inbounds double, double* %12, i64 %116
%118 = bitcast double* %117 to <2 x double>*
%119 = load <2 x double>, <2 x double>* %118
%120 = getelementptr inbounds double, double* %117, i64 2
%121 = bitcast double* %120 to <2 x double>*
%122 = load <2 x double>, <2 x double>* %121
%123 = trunc <2 x i64> %112 to <2 x i32>
%124 = trunc <2 x i64> %115 to <2 x i32>
%125 = sitofp <2 x i32> %123 to <2 x double>
%126 = sitofp <2 x i32> %124 to <2 x double>
%127 = fmul <2 x double> %119, %125
%128 = fmul <2 x double> %122, %126
%129 = getelementptr inbounds double, double* %15, i64 %109
%130 = bitcast double* %129 to <2 x double>*
store <2 x double> %127, <2 x double>* %130
%131 = getelementptr inbounds double, double* %129, i64 2
%132 = bitcast double* %131 to <2 x double>*
store <2 x double> %128, <2 x double>* %132
%133 = add nuw i64 %109, 4
%134 = icmp eq i64 %133, %107
br i1 %134, label %135, label %108
135: ; preds = %108
%136 = icmp eq i64 %107, %7
br i1 %136, label %159, label %137
137: ; preds = %104, %135
%138 = phi i64 [ 0, %104 ], [ %107, %135 ]
br label %149
139: ; preds = %91, %139
%140 = phi i64 [ %141, %139 ], [ %92, %91 ]
%141 = add nuw nsw i64 %140, 1
%142 = getelementptr inbounds double, double* %9, i64 %141
%143 = load double, double* %142
%144 = trunc i64 %141 to i32
%145 = sitofp i32 %144 to double
%146 = fmul double %143, %145
%147 = getelementptr inbounds double, double* %12, i64 %140
store double %146, double* %147
%148 = icmp eq i64 %141, %7
br i1 %148, label %103, label %139
149: ; preds = %137, %149
%150 = phi i64 [ %151, %149 ], [ %138, %137 ]
%151 = add nuw nsw i64 %150, 1
%152 = getelementptr inbounds double, double* %12, i64 %151
%153 = load double, double* %152
%154 = trunc i64 %151 to i32
%155 = sitofp i32 %154 to double
%156 = fmul double %153, %155
%157 = getelementptr inbounds double, double* %15, i64 %150
store double %156, double* %157
%158 = icmp eq i64 %151, %7
br i1 %158, label %159, label %149
159: ; preds = %149, %135
%160 = icmp ult i32 %6, 4
br i1 %160, label %192, label %161
161: ; preds = %159
%162 = and i64 %7, 4294967292
br label %163
163: ; preds = %163, %161
%164 = phi i64 [ 0, %161 ], [ %188, %163 ]
%165 = insertelement <2 x i64> poison, i64 %164, i64 0
%166 = shufflevector <2 x i64> %165, <2 x i64> poison, <2 x i32> zeroinitializer
%167 = or <2 x i64> %166, <i64 1, i64 2>
%168 = or <2 x i64> %166, <i64 3, i64 poison>
%169 = add <2 x i64> %166, <i64 poison, i64 4>
%170 = shufflevector <2 x i64> %168, <2 x i64> %169, <2 x i32> <i32 0, i32 3>
%171 = extractelement <2 x i64> %167, i64 0
%172 = getelementptr inbounds double, double* %15, i64 %171
%173 = bitcast double* %172 to <2 x double>*
%174 = load <2 x double>, <2 x double>* %173
%175 = getelementptr inbounds double, double* %172, i64 2
%176 = bitcast double* %175 to <2 x double>*
%177 = load <2 x double>, <2 x double>* %176
%178 = trunc <2 x i64> %167 to <2 x i32>
%179 = trunc <2 x i64> %170 to <2 x i32>
%180 = sitofp <2 x i32> %178 to <2 x double>
%181 = sitofp <2 x i32> %179 to <2 x double>
%182 = fmul <2 x double> %174, %180
%183 = fmul <2 x double> %177, %181
%184 = getelementptr inbounds double, double* %18, i64 %164
%185 = bitcast double* %184 to <2 x double>*
store <2 x double> %182, <2 x double>* %185
%186 = getelementptr inbounds double, double* %184, i64 2
%187 = bitcast double* %186 to <2 x double>*
store <2 x double> %183, <2 x double>* %187
%188 = add nuw i64 %164, 4
%189 = icmp eq i64 %188, %162
br i1 %189, label %190, label %163
190: ; preds = %163
%191 = icmp eq i64 %162, %7
br i1 %191, label %204, label %192
192: ; preds = %159, %190
%193 = phi i64 [ 0, %159 ], [ %162, %190 ]
br label %194
194: ; preds = %192, %194
%195 = phi i64 [ %196, %194 ], [ %193, %192 ]
%196 = add nuw nsw i64 %195, 1
%197 = getelementptr inbounds double, double* %15, i64 %196
%198 = load double, double* %197
%199 = trunc i64 %196 to i32
%200 = sitofp i32 %199 to double
%201 = fmul double %198, %200
%202 = getelementptr inbounds double, double* %18, i64 %195
store double %201, double* %202
%203 = icmp eq i64 %196, %7
br i1 %203, label %204, label %194
204: ; preds = %194, %190
%205 = add nsw i64 %7, -1
%206 = and i64 %7, 3
%207 = icmp ult i64 %205, 3
br i1 %207, label %244, label %208
208: ; preds = %204
%209 = and i64 %7, 4294967292
br label %210
210: ; preds = %210, %208
%211 = phi i64 [ 0, %208 ], [ %241, %210 ]
%212 = phi double [ 0.000000e+00, %208 ], [ %240, %210 ]
%213 = phi i64 [ 0, %208 ], [ %242, %210 ]
%214 = getelementptr inbounds double, double* %18, i64 %211
%215 = load double, double* %214
%216 = trunc i64 %211 to i32
%217 = sitofp i32 %216 to double
%218 = tail call double @pow(double %3, double %217)
%219 = tail call double @llvm.fmuladd.f64(double %215, double %218, double %212)
%220 = or i64 %211, 1
%221 = getelementptr inbounds double, double* %18, i64 %220
%222 = load double, double* %221
%223 = trunc i64 %220 to i32
%224 = sitofp i32 %223 to double
%225 = tail call double @pow(double %3, double %224)
%226 = tail call double @llvm.fmuladd.f64(double %222, double %225, double %219)
%227 = or i64 %211, 2
%228 = getelementptr inbounds double, double* %18, i64 %227
%229 = load double, double* %228
%230 = trunc i64 %227 to i32
%231 = sitofp i32 %230 to double
%232 = tail call double @pow(double %3, double %231)
%233 = tail call double @llvm.fmuladd.f64(double %229, double %232, double %226)
%234 = or i64 %211, 3
%235 = getelementptr inbounds double, double* %18, i64 %234
%236 = load double, double* %235
%237 = trunc i64 %234 to i32
%238 = sitofp i32 %237 to double
%239 = tail call double @pow(double %3, double %238)
%240 = tail call double @llvm.fmuladd.f64(double %236, double %239, double %233)
%241 = add nuw nsw i64 %211, 4
%242 = add i64 %213, 4
%243 = icmp eq i64 %242, %209
br i1 %243, label %244, label %210
244: ; preds = %210, %204
%245 = phi double [ undef, %204 ], [ %240, %210 ]
%246 = phi i64 [ 0, %204 ], [ %241, %210 ]
%247 = phi double [ 0.000000e+00, %204 ], [ %240, %210 ]
%248 = icmp eq i64 %206, 0
br i1 %248, label %262, label %249
249: ; preds = %244, %249
%250 = phi i64 [ %259, %249 ], [ %246, %244 ]
%251 = phi double [ %258, %249 ], [ %247, %244 ]
%252 = phi i64 [ %260, %249 ], [ 0, %244 ]
%253 = getelementptr inbounds double, double* %18, i64 %250
%254 = load double, double* %253
%255 = trunc i64 %250 to i32
%256 = sitofp i32 %255 to double
%257 = tail call double @pow(double %3, double %256)
%258 = tail call double @llvm.fmuladd.f64(double %254, double %257, double %251)
%259 = add nuw nsw i64 %250, 1
%260 = add i64 %252, 1
%261 = icmp eq i64 %260, %206
br i1 %261, label %262, label %249
262: ; preds = %244, %249, %56, %5, %103
%263 = phi double [ 0.000000e+00, %103 ], [ 0.000000e+00, %5 ], [ 0.000000e+00, %56 ], [ %245, %244 ], [ %258, %249 ]
tail call void @llvm.stackrestore(i8* %8)
br label %308
264: ; preds = %4
%265 = load double, double* %0
%266 = getelementptr inbounds double, double* %0, i64 1
%267 = load double, double* %266
%268 = getelementptr inbounds double, double* %0, i64 2
%269 = load double, double* %268
%270 = tail call double @pow(double 0x4005BF0A8B12500B, double %3)
%271 = fmul double %267, %269
%272 = fadd double %269, -1.000000e+00
%273 = fmul double %271, %272
%274 = fadd double %269, -2.000000e+00
%275 = fmul double %274, %273
%276 = fadd double %269, -3.000000e+00
%277 = fmul double %276, %275
%278 = fadd double %269, -4.000000e+00
%279 = tail call double @pow(double %3, double %278)
%280 = fmul double %279, %277
%281 = tail call double @llvm.fmuladd.f64(double %265, double %270, double %280)
br label %308
282: ; preds = %4
%283 = load double, double* %0
%284 = getelementptr inbounds double, double* %0, i64 1
%285 = load double, double* %284
%286 = getelementptr inbounds double, double* %0, i64 2
%287 = load double, double* %286
%288 = getelementptr inbounds double, double* %0, i64 3
%289 = load double, double* %288
%290 = getelementptr inbounds double, double* %0, i64 4
%291 = load double, double* %290
%292 = getelementptr inbounds double, double* %0, i64 5
%293 = load double, double* %292
%294 = fmul double %283, %285
%295 = fmul double %285, %294
%296 = fmul double %285, %295
%297 = fmul double %285, %296
%298 = tail call double @llvm.fmuladd.f64(double %285, double %3, double %287)
%299 = tail call double @sin(double %298)
%300 = fmul double %289, %291
%301 = fmul double %291, %300
%302 = fmul double %291, %301
%303 = fmul double %291, %302
%304 = tail call double @llvm.fmuladd.f64(double %291, double %3, double %293)
%305 = tail call double @cos(double %304)
%306 = fmul double %305, %303
%307 = tail call double @llvm.fmuladd.f64(double %297, double %299, double %306)
br label %308
308: ; preds = %4, %282, %264, %262
%309 = phi double [ 0.000000e+00, %4 ], [ %307, %282 ], [ %281, %264 ], [ %263, %262 ]
ret double %309
}