#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 */
int M_PI;
double cos(int);
int /*<<< orphan*/ exp(int);
int log(double);
int pow(int, int);
double round(int /*<<< orphan*/);
double sqrt(int);
double tan(double);
void preprocessing(double c[10][10]) {
  double v, g, cw, wcross, wc_n, fc_n, f_max, bw_n, T, tbw, c_m, d, Tpw;
  double a[3], b[3];
  int n;
  T = 1.0 / 44100;
  g = pow(10, 12 / 20.0);
  wcross = pow(g, 1.0 / 2.0 / 2);
  v = pow(g, 1.0 / 2) - 1;
  f_max = 30 * pow(2, 10 - 1);
  for (n = 0; n < 10; n++) {
    fc_n = round(
        exp(log(30) + log(f_max / (double)30) * (n - 1) / (double)(10 - 1)));
    wc_n = 2 * M_PI * fc_n;
    bw_n = wc_n * (sqrt(2) - 1.0 / sqrt(2)) / wcross;
    Tpw = 2.0 / bw_n * tan(bw_n / 2.0 * T);
    cw = cos(Tpw / 2.0 * sqrt(4 * wc_n * wc_n + 1)) / cos(Tpw / 2.0);
    tbw = Tpw * bw_n;
    c_m = cos(M_PI * (0.5 - 0.5 / 2));
    a[0] = 4 + 4 * c_m * tbw + tbw * tbw;
    a[1] = a[2] = 1.0 / a[0];
    a[1] *= 2 * tbw * tbw - 8;
    a[2] *= a[0] - 8 * c_m * tbw;
    b[0] = b[1] = b[2] = tbw * v / a[0];
    b[0] *= 2 * tbw + 4 * c_m + tbw * v;
    b[1] *= 2 * tbw * (v + 2);
    b[2] *= 2 * tbw - 4 * c_m + tbw * v;
    d = b[0] + 1;
    c[n][0] = cw * (1 - a[1]);
    c[n][1] = cw;
    c[n][2] = cw * (b[1] - a[1] * b[0]);
    c[n][3] = b[1] - a[1] * b[0];
    c[n][4] = -a[1];
    c[n][5] = cw * (b[2] - a[2] * b[0]);
    c[n][6] = -a[2] * cw;
    c[n][7] = b[2] - a[2] * b[0];
    c[n][8] = -a[2];
    c[n][9] = d;
  }
}


x86 assembly (clang, -O0):
<preprocessing>:
push   %rbp
mov    %rsp,%rbp
sub    $0xf0,%rsp
mov    %rdi,-0x8(%rbp)
movsd  0xe79(%rip),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    $0xa,%edi
xor    %esi,%esi
call   1070 <pow@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x18(%rbp)
cvttsd2si -0x18(%rbp),%edi
xor    %esi,%esi
call   1070 <pow@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x28(%rbp)
cvttsd2si -0x18(%rbp),%edi
xor    %esi,%esi
call   1070 <pow@plt>
sub    $0x1,%eax
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x10(%rbp)
mov    $0x2,%edi
mov    $0x9,%esi
call   1070 <pow@plt>
imul   $0x1e,%eax,%eax
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x0,-0xb4(%rbp)
cmpl   $0xa,-0xb4(%rbp)
jge    1814 <preprocessing+0x6a4>
movsd  0xe38(%rip),%xmm0
call   1060 <log@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0x40(%rbp),%xmm0
movsd  0xe1a(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1060 <log@plt>
movsd  -0xe8(%rbp),%xmm0
ff
mov    -0xb4(%rbp),%ecx
sub    $0x1,%ecx
imul   %ecx,%eax
cvtsi2sd %eax,%xmm1
movsd  0xde9(%rip),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   1030 <exp@plt>
mov    %eax,%edi
call   1080 <round@plt>
movsd  %xmm0,-0x38(%rbp)
mov    0x2d75(%rip),%rax
mov    (%rax),%eax
shl    $0x1,%eax
cvtsi2sd %eax,%xmm0
mulsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x30(%rbp)
movsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    $0x2,%edi
call   1090 <sqrt@plt>
movsd  %xmm0,-0xe0(%rbp)
ff
mov    $0x2,%edi
call   1090 <sqrt@plt>
movsd  -0xe0(%rbp),%xmm1
ff
movaps %xmm0,%xmm3
movsd  -0xd8(%rbp),%xmm0
ff
movsd  0xd3e(%rip),%xmm2
divsd  %xmm3,%xmm2
subsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
divsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  0xd30(%rip),%xmm0
divsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x48(%rbp),%xmm0
movsd  0xd16(%rip),%xmm1
divsd  %xmm1,%xmm0
mulsd  -0x50(%rbp),%xmm0
call   1040 <tan@plt>
movaps %xmm0,%xmm1
movsd  -0xd0(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm0
movsd  0xce7(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  0xccb(%rip),%xmm0
mulsd  -0x30(%rbp),%xmm0
movsd  -0x30(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xcad(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   1090 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0xc8(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   1050 <cos@plt>
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
movsd  0xc83(%rip),%xmm1
divsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   1050 <cos@plt>
movaps %xmm0,%xmm1
movsd  -0xc0(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x20(%rbp)
movsd  -0x70(%rbp),%xmm0
mulsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    0x2c1c(%rip),%rax
cvtsi2sdl (%rax),%xmm0
movsd  0xc58(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   1050 <cos@plt>
movsd  %xmm0,-0x60(%rbp)
movsd  0xc1e(%rip),%xmm1
mulsd  -0x60(%rbp),%xmm1
movsd  -0x58(%rbp),%xmm0
mulsd  %xmm0,%xmm1
movsd  0xc08(%rip),%xmm0
addsd  %xmm0,%xmm1
movsd  -0x58(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  0xbda(%rip),%xmm0
divsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x80(%rbp)
movsd  %xmm0,-0x88(%rbp)
ff
movsd  0xbcd(%rip),%xmm0
mulsd  -0x58(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xbc7(%rip),%xmm1
addsd  %xmm1,%xmm0
mulsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x90(%rbp),%xmm1
ff
movsd  0xb9b(%rip),%xmm0
mulsd  -0x60(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mulsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x58(%rbp),%xmm0
mulsd  -0x10(%rbp),%xmm0
divsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x58(%rbp),%xmm1
movsd  0xb21(%rip),%xmm0
mulsd  -0x60(%rbp),%xmm0
addsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x58(%rbp),%xmm0
movsd  -0x10(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mulsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  0xaf2(%rip),%xmm0
mulsd  -0x58(%rbp),%xmm0
movsd  0xae5(%rip),%xmm1
addsd  -0x10(%rbp),%xmm1
mulsd  %xmm1,%xmm0
mulsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0x58(%rbp),%xmm1
movsd  0xab7(%rip),%xmm0
mulsd  -0x60(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
addsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x58(%rbp),%xmm0
movsd  -0x10(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mulsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  0xa61(%rip),%xmm0
addsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0x68(%rbp)
movsd  -0x20(%rbp),%xmm0
movsd  0xa47(%rip),%xmm1
subsd  -0x88(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0xb4(%rbp),%rcx
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,(%rax)
movsd  -0x20(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0xb4(%rbp),%rcx
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x8(%rax)
movsd  -0x20(%rbp),%xmm0
movsd  -0xa8(%rbp),%xmm2
ff
movsd  -0x88(%rbp),%xmm1
ff
movsd  -0xb0(%rbp),%xmm3
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0xb4(%rbp),%rcx
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x10(%rax)
movsd  -0xa8(%rbp),%xmm1
ff
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0xb0(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0xb4(%rbp),%rcx
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x18(%rax)
movsd  -0x88(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x8(%rbp),%rax
movslq -0xb4(%rbp),%rcx
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x20(%rax)
movsd  -0x20(%rbp),%xmm0
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0x80(%rbp),%xmm1
movsd  -0xb0(%rbp),%xmm3
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0xb4(%rbp),%rcx
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x28(%rax)
movsd  -0x80(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0x20(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0xb4(%rbp),%rcx
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x30(%rax)
movsd  -0xa0(%rbp),%xmm1
ff
movsd  -0x80(%rbp),%xmm0
movsd  -0xb0(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0xb4(%rbp),%rcx
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x38(%rax)
movsd  -0x80(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x8(%rbp),%rax
movslq -0xb4(%rbp),%rcx
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x40(%rax)
movsd  -0x68(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0xb4(%rbp),%rcx
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x48(%rax)
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    11f3 <preprocessing+0x83>
add    $0xf0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<preprocessing>:
push   %rbp
push   %r15
push   %r14
push   %rbx
sub    $0x58,%rsp
mov    %rdi,%rbx
mov    $0xa,%edi
xor    %esi,%esi
call   1070 <pow@plt>
mov    %eax,%ebp
mov    %eax,%edi
xor    %esi,%esi
call   1070 <pow@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x50(%rsp)
mov    %ebp,%edi
xor    %esi,%esi
call   1070 <pow@plt>
add    $0xffffffff,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x30(%rsp)
mov    $0x2,%edi
mov    $0x9,%esi
call   1070 <pow@plt>
mov    %eax,%ecx
shl    $0x5,%ecx
sub    %eax,%ecx
sub    %eax,%ecx
xorps  %xmm0,%xmm0
cvtsi2sd %ecx,%xmm0
divsd  0xe22(%rip),%xmm0
movsd  %xmm0,0x48(%rsp)
movsd  0xe1c(%rip),%xmm0
addsd  0x30(%rsp),%xmm0
movsd  %xmm0,0x40(%rsp)
mov    $0xffffffff,%r14d
mov    $0x48,%ebp
mov    0x2dde(%rip),%r15
nopw   0x0(%rax,%rax,1)
movsd  0xde8(%rip),%xmm0
call   1060 <log@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  0x48(%rsp),%xmm0
call   1060 <log@plt>
imul   %r14d,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
divsd  0xdc8(%rip),%xmm0
addsd  0x10(%rsp),%xmm0
cvttsd2si %xmm0,%edi
call   1030 <exp@plt>
mov    %eax,%edi
call   1080 <round@plt>
mov    (%r15),%eax
add    %eax,%eax
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%rsp)
mov    $0x2,%edi
call   1090 <sqrt@plt>
movsd  %xmm0,0x28(%rsp)
mov    $0x2,%edi
call   1090 <sqrt@plt>
movsd  0xd82(%rip),%xmm1
divsd  %xmm0,%xmm1
movsd  0x28(%rsp),%xmm2
subsd  %xmm1,%xmm2
mulsd  0x10(%rsp),%xmm2
divsd  0x50(%rsp),%xmm2
movsd  %xmm2,0x28(%rsp)
movsd  0xd4a(%rip),%xmm0
divsd  %xmm2,%xmm0
movsd  %xmm0,0x8(%rsp)
movapd %xmm2,%xmm0
movsd  0xd4c(%rip),%xmm1
mulsd  %xmm1,%xmm0
mulsd  0xd48(%rip),%xmm0
call   1040 <tan@plt>
mulsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
mulsd  0xd27(%rip),%xmm0
movsd  %xmm0,0x38(%rsp)
movsd  0x10(%rsp),%xmm2
movapd %xmm2,%xmm0
movsd  0xd1f(%rip),%xmm1
mulsd  %xmm1,%xmm0
mulsd  %xmm2,%xmm0
addsd  0xcf7(%rip),%xmm0
cvttsd2si %xmm0,%edi
call   1090 <sqrt@plt>
mulsd  0x38(%rsp),%xmm0
cvttsd2si %xmm0,%edi
call   1050 <cos@plt>
movapd %xmm0,0x10(%rsp)
cvttsd2si 0x38(%rsp),%edi
call   1050 <cos@plt>
movapd 0x10(%rsp),%xmm1
divsd  %xmm0,%xmm1
movapd %xmm1,0x10(%rsp)
xorps  %xmm0,%xmm0
cvtsi2sdl (%r15),%xmm0
movsd  0x8(%rsp),%xmm1
mulsd  0x28(%rsp),%xmm1
movsd  %xmm1,0x8(%rsp)
mulsd  0xcbc(%rip),%xmm0
cvttsd2si %xmm0,%edi
call   1050 <cos@plt>
movapd %xmm0,%xmm4
movsd  0xc9f(%rip),%xmm7
mulsd  %xmm7,%xmm4
movsd  0x8(%rsp),%xmm5
movapd %xmm5,%xmm1
addsd  %xmm5,%xmm1
movapd %xmm1,%xmm3
movapd %xmm1,%xmm2
addsd  %xmm4,%xmm2
movsd  0x40(%rsp),%xmm10
mulsd  %xmm1,%xmm10
subsd  %xmm4,%xmm1
movapd %xmm4,%xmm6
movapd %xmm5,%xmm4
mulsd  %xmm5,%xmm6
addsd  %xmm7,%xmm6
movapd %xmm5,%xmm7
mulsd  %xmm5,%xmm7
movsd  0xc38(%rip),%xmm9
movapd %xmm9,%xmm4
addsd  %xmm6,%xmm7
mulsd  %xmm5,%xmm3
movsd  0xc4b(%rip),%xmm6
addsd  %xmm6,%xmm3
mulsd  %xmm6,%xmm0
divsd  %xmm7,%xmm4
mulsd  %xmm5,%xmm0
addsd  %xmm7,%xmm0
mulsd  0x30(%rsp),%xmm5
movapd %xmm5,%xmm6
mulsd  %xmm4,%xmm3
divsd  %xmm7,%xmm6
addsd  %xmm5,%xmm2
mulsd  %xmm6,%xmm2
mulsd  %xmm6,%xmm10
addsd  %xmm5,%xmm1
mulsd  %xmm6,%xmm1
movapd %xmm2,%xmm8
movapd %xmm9,%xmm7
addsd  %xmm9,%xmm8
subsd  %xmm3,%xmm7
movapd 0x10(%rsp),%xmm5
mulsd  %xmm5,%xmm7
movsd  %xmm7,-0x48(%rbx,%rbp,1)
movapd %xmm3,%xmm7
movapd 0xbf1(%rip),%xmm6
xorpd  %xmm6,%xmm7
movsd  %xmm5,-0x40(%rbx,%rbp,1)
mulsd  %xmm2,%xmm3
subsd  %xmm3,%xmm10
movapd %xmm5,%xmm3
mulsd  %xmm10,%xmm3
movsd  %xmm3,-0x38(%rbx,%rbp,1)
xorpd  %xmm6,%xmm4
mulsd  %xmm0,%xmm4
mulsd  %xmm4,%xmm2
movsd  %xmm10,-0x30(%rbx,%rbp,1)
addsd  %xmm1,%xmm2
unpcklpd %xmm5,%xmm5
movapd %xmm2,%xmm0
unpcklpd %xmm4,%xmm0
movlpd %xmm7,-0x28(%rbx,%rbp,1)
mulpd  %xmm5,%xmm0
movupd %xmm0,-0x20(%rbx,%rbp,1)
movsd  %xmm2,-0x10(%rbx,%rbp,1)
movsd  %xmm4,-0x8(%rbx,%rbp,1)
movsd  %xmm8,(%rbx,%rbp,1)
add    $0x1,%r14d
add    $0x50,%rbp
cmp    $0x368,%rbp
jne    1210 <preprocessing+0xa0>
add    $0x58,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@M_PI = global i32 0
define void @preprocessing([10 x double]* nocapture writeonly %0) {
%2 = tail call i32 @pow(i32 10, i32 0)
%3 = tail call i32 @pow(i32 %2, i32 0)
%4 = sitofp i32 %3 to double
%5 = tail call i32 @pow(i32 %2, i32 0)
%6 = add nsw i32 %5, -1
%7 = sitofp i32 %6 to double
%8 = tail call i32 @pow(i32 2, i32 9)
%9 = mul nsw i32 %8, 30
%10 = sitofp i32 %9 to double
%11 = fdiv double %10, 3.000000e+01
%12 = fadd double %7, 2.000000e+00
br label %13
13: ; preds = %1, %13
%14 = phi i64 [ 0, %1 ], [ %103, %13 ]
%15 = tail call i32 @log(double 3.000000e+01)
%16 = sitofp i32 %15 to double
%17 = tail call i32 @log(double %11)
%18 = trunc i64 %14 to i32
%19 = add i32 %18, -1
%20 = mul nsw i32 %17, %19
%21 = sitofp i32 %20 to double
%22 = fdiv double %21, 9.000000e+00
%23 = fadd double %22, %16
%24 = fptosi double %23 to i32
%25 = tail call i32 @exp(i32 %24)
%26 = tail call double @round(i32 %25)
%27 = load i32, i32* @M_PI
%28 = shl nsw i32 %27, 1
%29 = sitofp i32 %28 to double
%30 = fmul double %26, %29
%31 = tail call double @sqrt(i32 2)
%32 = tail call double @sqrt(i32 2)
%33 = fdiv double 1.000000e+00, %32
%34 = fsub double %31, %33
%35 = fmul double %30, %34
%36 = fdiv double %35, %4
%37 = fdiv double 2.000000e+00, %36
%38 = fmul double %36, 5.000000e-01
%39 = fmul double %38, 0x3EF7C6F8C751F177
%40 = tail call double @tan(double %39)
%41 = fmul double %40, %37
%42 = fmul double %41, 5.000000e-01
%43 = fmul double %30, 4.000000e+00
%44 = tail call double @llvm.fmuladd.f64(double %43, double %30, double 1.000000e+00)
%45 = fptosi double %44 to i32
%46 = tail call double @sqrt(i32 %45)
%47 = fmul double %46, %42
%48 = fptosi double %47 to i32
%49 = tail call double @cos(i32 %48)
%50 = fptosi double %42 to i32
%51 = tail call double @cos(i32 %50)
%52 = fdiv double %49, %51
%53 = fmul double %36, %41
%54 = load i32, i32* @M_PI
%55 = sitofp i32 %54 to double
%56 = fmul double %55, 2.500000e-01
%57 = fptosi double %56 to i32
%58 = tail call double @cos(i32 %57)
%59 = fmul double %58, 4.000000e+00
%60 = tail call double @llvm.fmuladd.f64(double %59, double %53, double 4.000000e+00)
%61 = tail call double @llvm.fmuladd.f64(double %53, double %53, double %60)
%62 = fdiv double 1.000000e+00, %61
%63 = fmul double %53, 2.000000e+00
%64 = tail call double @llvm.fmuladd.f64(double %63, double %53, double -8.000000e+00)
%65 = fmul double %64, %62
%66 = fmul double %58, -8.000000e+00
%67 = tail call double @llvm.fmuladd.f64(double %66, double %53, double %61)
%68 = fmul double %53, %7
%69 = fdiv double %68, %61
%70 = tail call double @llvm.fmuladd.f64(double %53, double 2.000000e+00, double %59)
%71 = tail call double @llvm.fmuladd.f64(double %53, double %7, double %70)
%72 = fmul double %71, %69
%73 = fmul double %12, %63
%74 = fmul double %73, %69
%75 = fneg double %59
%76 = tail call double @llvm.fmuladd.f64(double %53, double 2.000000e+00, double %75)
%77 = tail call double @llvm.fmuladd.f64(double %53, double %7, double %76)
%78 = fmul double %77, %69
%79 = fadd double %72, 1.000000e+00
%80 = fsub double 1.000000e+00, %65
%81 = fmul double %52, %80
%82 = getelementptr inbounds [10 x double], [10 x double]* %0, i64 %14, i64 0
store double %81, double* %82
%83 = getelementptr inbounds [10 x double], [10 x double]* %0, i64 %14, i64 1
store double %52, double* %83
%84 = fneg double %65
%85 = tail call double @llvm.fmuladd.f64(double %84, double %72, double %74)
%86 = fmul double %52, %85
%87 = getelementptr inbounds [10 x double], [10 x double]* %0, i64 %14, i64 2
store double %86, double* %87
%88 = getelementptr inbounds [10 x double], [10 x double]* %0, i64 %14, i64 3
store double %85, double* %88
%89 = getelementptr inbounds [10 x double], [10 x double]* %0, i64 %14, i64 4
store double %84, double* %89
%90 = fneg double %62
%91 = fmul double %67, %90
%92 = tail call double @llvm.fmuladd.f64(double %91, double %72, double %78)
%93 = getelementptr inbounds [10 x double], [10 x double]* %0, i64 %14, i64 5
%94 = insertelement <2 x double> poison, double %52, i64 0
%95 = shufflevector <2 x double> %94, <2 x double> poison, <2 x i32> zeroinitializer
%96 = insertelement <2 x double> poison, double %92, i64 0
%97 = insertelement <2 x double> %96, double %91, i64 1
%98 = fmul <2 x double> %95, %97
%99 = bitcast double* %93 to <2 x double>*
store <2 x double> %98, <2 x double>* %99
%100 = getelementptr inbounds [10 x double], [10 x double]* %0, i64 %14, i64 7
store double %92, double* %100
%101 = getelementptr inbounds [10 x double], [10 x double]* %0, i64 %14, i64 8
store double %91, double* %101
%102 = getelementptr inbounds [10 x double], [10 x double]* %0, i64 %14, i64 9
store double %79, double* %102
%103 = add nuw nsw i64 %14, 1
%104 = icmp eq i64 %103, 10
br i1 %104, label %105, label %13
105: ; preds = %13
ret void
}