#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 */
float bessi0(float);
scalar_t__ calloc(unsigned int, int);
float cos(int);
float fabs(double);
float fmax(int, float);
int /*<<< orphan*/ free(float *);
float gaussian(float, float, float);
scalar_t__ malloc(int);
float pow(int, int);
int /*<<< orphan*/ printf(char *, unsigned int);
float sin(double);
float sqrt(int /*<<< orphan*/);
float **createEnvelopes(unsigned int n) {
  float **envs = (float **)malloc(13 * sizeof(float *));
  float a0, a1, a2, a3, L, fN;
  for (unsigned int i = 0; i < 13; i++) {
    envs[i] = (float *)calloc(n, sizeof(float));
    switch (i) {
    case 0:
      for (unsigned int j = 0; j < n; j++) {
        envs[i][j] = sin((3.141592653589) * (double)j / (double)(n - 1));
      }
      break;
    case 1:
      for (unsigned int j = 0; j < n; j++) {
        envs[i][j] =
            0.5f *
            (1.0f - cos(2.0f * (3.141592653589) * (double)j / (double)(n - 1)));
      }
      break;
    case 2:
      for (unsigned int j = 0; j < n; j++) {
        envs[i][j] =
            0.54f -
            0.46f * cos(2 * (3.141592653589) * (double)j / (double)(n - 1)) -
            0.08f;
      }
      break;
    case 3:
      for (unsigned int j = 0; j < n; j++) {
        float truncationHeight = 0.5f;
        float f =
            1.0f / (2.0f * truncationHeight) *
            (1.0f - cos(2.0f * (3.141592653589) * (double)j / (double)(n - 1)));
        envs[i][j] = f < 1 ? f : 1;
      }
      break;
    case 4:
      for (unsigned int j = 0; j < n; j++) {
        float sigma = 0.3f;
        envs[i][j] = fabs(
            pow(2.718281828459045, -0.5f * pow(((j - (double)(n - 1) / 2) /
                                                (sigma * (double)(n - 1) / 2)),
                                               2)) -
            0.003866f);
      }
      break;
    case 5:
      fN = (float)n;
      float sigma = fN * 0.2f;
      float L = (float)(n - 1);
      float numerator = 0.0f;
      float denominator = 0.0f;
      float fn = 0.0f;
      for (unsigned int j = 0; j < n; j++) {
        fn = (float)j;
        numerator = gaussian(-0.5f, L, sigma) *
                    (gaussian(fn + fN, L, sigma) + gaussian(fn - fN, L, sigma));
        denominator =
            gaussian(-0.5f + fN, L, sigma) + gaussian(-0.5f - fN, L, sigma);
        envs[i][j] = fmax(
            gaussian(fn, L, sigma) - numerator / denominator - 0.000020f, 0.f);
      }
      break;
    case 6:
      for (unsigned int j = 0; j < n; j++) {
        float slope = 10;
        float x = (float)j / n;
        float f1 = slope * x;
        float f2 = -1 * slope * (x - (slope - 1) / slope) + 1;
        envs[i][j] =
            fmax((x < 0.5f ? (f1 < 1 ? f1 : 1) : (f2 < 1 ? f2 : 1)) - 0.000152f,
                 0.f);
      }
      break;
    case 7:
      a0 = 0.426591f;
      a1 = 0.496561f;
      a2 = 0.076849f;
      L = (float)(n - 1);
      for (unsigned int j = 0; j < n; j++) {
        envs[i][j] = a0;
        envs[i][j] -=
            a1 * cos((1.0f * 2.0f * (float)((3.141592653589)) * j) / L);
        envs[i][j] +=
            a2 * cos((2.0f * 2.0f * (float)((3.141592653589)) * j) / L);
        envs[i][j] -= 0.006879f;
      }
      break;
    case 8:
      a0 = 0.35875f;
      a1 = 0.48829f;
      a2 = 0.14128f;
      a3 = 0.01168f;
      L = (float)(n - 1);
      for (unsigned int j = 0; j < n; j++) {
        envs[i][j] = a0;
        envs[i][j] -=
            a1 * cos((1.0f * 2.0f * (float)((3.141592653589)) * j) / L);
        envs[i][j] +=
            a2 * cos((2.0f * 2.0f * (float)((3.141592653589)) * j) / L);
        envs[i][j] -=
            a3 * cos((3.0f * 2.0f * (float)((3.141592653589)) * j) / L);
        envs[i][j] = fmax(envs[i][j] - 0.000060f, 0.0f);
      }
      break;
    case 9:
      for (unsigned int j = 0; j < n; j++) {
        envs[i][j] = fmax(1.0f -
                              fabs(((double)j - 0.5f * (double)(n - 1)) /
                                   (0.5f * (double)(n + 1))) -
                              0.000031f,
                          0.f);
      }
      break;
    case 10:
      for (unsigned int j = 0; j < n; j++) {
        envs[i][j] =
            0.3635819f -
            0.3635819f *
                cos(2 * (float)((3.141592653589)) * (double)j / (n - 1)) +
            0.1365995f *
                cos(4 * (float)((3.141592653589)) * (double)j / (n - 1)) -
            0.130411f *
                cos(6 * (float)((3.141592653589)) * (double)j / (n - 1));
        envs[i][j] -= 0.006188f;
      }
      break;
    case 11:
      for (unsigned int j = 0; j < n; j++) {
        envs[i][j] = fmax(
            1 -
                1.93f *
                    cos(2 * (float)((3.141592653589)) * (double)j / (n - 1)) +
                1.29f *
                    cos(4 * (float)((3.141592653589)) * (double)j / (n - 1)) -
                0.388f *
                    cos(6 * (float)((3.141592653589)) * (double)j / (n - 1)) +
                0.032f *
                    cos(8 * (float)((3.141592653589)) * (double)j / (n - 1)) *
                    0.215f,
            0.0f);
      }
      break;
    case 12:
      for (unsigned int j = 0; j < n; j++) {
        double alpha = 3.0f;
        envs[i][j] = bessi0((float)((3.141592653589)) * alpha *
                            sqrt(1 - pow((2 * (double)j / (n - 1)) - 1, 2))) /
                     bessi0((float)((3.141592653589)) * alpha);
        envs[i][j] -= 0.000612f;
      }
      break;
    default:
      printf("Envelope type %i not defined, ignored.\n", i);
      free(envs[i]);
      break;
    }
  }
  return envs;
}


x86 assembly (clang, -O0):
<createEnvelopes>:
push   %rbp
mov    %rsp,%rbp
sub    $0x100,%rsp
mov    %edi,-0x4(%rbp)
mov    $0x68,%edi
call   1090 <malloc@plt>
mov    %rax,-0x10(%rbp)
movl   $0x0,-0x2c(%rbp)
cmpl   $0xd,-0x2c(%rbp)
jae    2065 <createEnvelopes+0xea5>
mov    -0x4(%rbp),%edi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,%rdx
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    %rdx,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
mov    %rax,-0xa0(%rbp)
sub    $0xc,%rax
ja     2033 <createEnvelopes+0xe73>
mov    -0xa0(%rbp),%rax
lea    0x1ea6(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x4(%rbp),%eax
jae    128f <createEnvelopes+0xcf>
mov    -0x30(%rbp),%eax
cvtsi2sd %rax,%xmm0
movsd  0x1e72(%rip),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x4(%rbp),%eax
add    $0xffffffff,%eax
cvtsi2sd %rax,%xmm1
divsd  %xmm1,%xmm0
call   1070 <sin@plt>
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    123a <createEnvelopes+0x7a>
jmp    2052 <createEnvelopes+0xe92>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jae    130c <createEnvelopes+0x14c>
mov    -0x34(%rbp),%eax
cvtsi2sd %rax,%xmm0
movsd  0x1e09(%rip),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x4(%rbp),%eax
add    $0xffffffff,%eax
cvtsi2sd %rax,%xmm1
divsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   10b0 <cos@plt>
movss  0x1d29(%rip),%xmm1
subss  %xmm0,%xmm1
movss  0x1d61(%rip),%xmm0
mulss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    129b <createEnvelopes+0xdb>
jmp    2052 <createEnvelopes+0xe92>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jae    1395 <createEnvelopes+0x1d5>
mov    -0x38(%rbp),%eax
cvtsi2sd %rax,%xmm0
movsd  0x1d8c(%rip),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x4(%rbp),%eax
add    $0xffffffff,%eax
cvtsi2sd %rax,%xmm1
divsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   10b0 <cos@plt>
movss  0x1d10(%rip),%xmm1
mulss  %xmm1,%xmm0
movss  0x1d08(%rip),%xmm1
addss  %xmm1,%xmm0
movss  0x1cf4(%rip),%xmm1
subss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1318 <createEnvelopes+0x158>
jmp    2052 <createEnvelopes+0xe92>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jae    147f <createEnvelopes+0x2bf>
movl   $0x3f000000,-0x40(%rbp)
movss  -0x40(%rbp),%xmm1
addss  %xmm1,%xmm1
movss  0x1c3f(%rip),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
mov    -0x3c(%rbp),%eax
cvtsi2sd %rax,%xmm0
movsd  0x1cdf(%rip),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x4(%rbp),%eax
add    $0xffffffff,%eax
cvtsi2sd %rax,%xmm1
divsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   10b0 <cos@plt>
movaps %xmm0,%xmm2
movss  -0xa4(%rbp),%xmm0
ff
movss  0x1bf4(%rip),%xmm1
subss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
movss  0x1bdf(%rip),%xmm0
ucomiss -0x44(%rbp),%xmm0
jbe    1441 <createEnvelopes+0x281>
movss  -0x44(%rbp),%xmm0
movss  %xmm0,-0xa8(%rbp)
ff
jmp    1456 <createEnvelopes+0x296>
movss  0x1bbb(%rip),%xmm0
movss  %xmm0,-0xa8(%rbp)
ff
jmp    1456 <createEnvelopes+0x296>
movss  -0xa8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x3c(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    13a1 <createEnvelopes+0x1e1>
jmp    2052 <createEnvelopes+0xe92>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x4(%rbp),%eax
jae    1542 <createEnvelopes+0x382>
movl   $0x3e99999a,-0x4c(%rbp)
mov    -0x48(%rbp),%eax
cvtsi2sd %rax,%xmm0
mov    -0x4(%rbp),%eax
add    $0xffffffff,%eax
cvtsi2sd %rax,%xmm2
movsd  0x1bff(%rip),%xmm3
movaps %xmm2,%xmm1
divsd  %xmm3,%xmm1
addsd  %xmm1,%xmm0
movss  -0x4c(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm2,%xmm1
movsd  0x1bd7(%rip),%xmm2
divsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
mov    $0x2,%esi
call   10d0 <pow@plt>
movaps %xmm0,%xmm1
movss  0x1b62(%rip),%xmm0
mulss  %xmm1,%xmm0
cvttss2si %xmm0,%esi
mov    $0x2,%edi
call   10d0 <pow@plt>
movss  0x1b4c(%rip),%xmm1
subss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
call   1060 <fabs@plt>
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x48(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    148b <createEnvelopes+0x2cb>
jmp    2052 <createEnvelopes+0xe92>
mov    -0x4(%rbp),%eax
cvtsi2ss %rax,%xmm0
movss  %xmm0,-0x28(%rbp)
movss  -0x28(%rbp),%xmm0
movss  0x1af3(%rip),%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x4(%rbp),%eax
add    $0xffffffff,%eax
cvtsi2ss %rax,%xmm0
movss  %xmm0,-0x54(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x5c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x60(%rbp)
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x4(%rbp),%eax
jae    16da <createEnvelopes+0x51a>
mov    -0x64(%rbp),%eax
cvtsi2ss %rax,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x54(%rbp),%xmm1
movss  -0x50(%rbp),%xmm2
movss  0x1a98(%rip),%xmm0
call   1080 <gaussian@plt>
movss  %xmm0,-0xb0(%rbp)
ff
movss  -0x60(%rbp),%xmm0
addss  -0x28(%rbp),%xmm0
movss  -0x54(%rbp),%xmm1
movss  -0x50(%rbp),%xmm2
call   1080 <gaussian@plt>
movss  %xmm0,-0xb4(%rbp)
ff
movss  -0x60(%rbp),%xmm0
subss  -0x28(%rbp),%xmm0
movss  -0x54(%rbp),%xmm1
movss  -0x50(%rbp),%xmm2
call   1080 <gaussian@plt>
movss  -0xb4(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movss  -0xb0(%rbp),%xmm0
ff
addss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  0x1a29(%rip),%xmm0
addss  -0x28(%rbp),%xmm0
movss  -0x54(%rbp),%xmm1
movss  -0x50(%rbp),%xmm2
call   1080 <gaussian@plt>
movss  %xmm0,-0xac(%rbp)
ff
movss  0x1a05(%rip),%xmm0
subss  -0x28(%rbp),%xmm0
movss  -0x54(%rbp),%xmm1
movss  -0x50(%rbp),%xmm2
call   1080 <gaussian@plt>
movaps %xmm0,%xmm1
movss  -0xac(%rbp),%xmm0
ff
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x60(%rbp),%xmm0
movss  -0x54(%rbp),%xmm1
movss  -0x50(%rbp),%xmm2
call   1080 <gaussian@plt>
movss  -0x58(%rbp),%xmm1
divss  -0x5c(%rbp),%xmm1
subss  %xmm1,%xmm0
movss  0x19af(%rip),%xmm1
subss  %xmm1,%xmm0
cvttss2si %xmm0,%edi
xorps  %xmm0,%xmm0
call   10c0 <fmax@plt>
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x64(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1599 <createEnvelopes+0x3d9>
jmp    2052 <createEnvelopes+0xe92>
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x4(%rbp),%eax
jae    184c <createEnvelopes+0x68c>
movl   $0x41200000,-0x6c(%rbp)
mov    -0x68(%rbp),%eax
cvtsi2ss %rax,%xmm0
mov    -0x4(%rbp),%eax
cvtsi2ss %rax,%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x6c(%rbp),%xmm0
mulss  -0x70(%rbp),%xmm0
movss  %xmm0,-0x74(%rbp)
movss  0x1923(%rip),%xmm0
mulss  -0x6c(%rbp),%xmm0
movss  -0x70(%rbp),%xmm1
movss  -0x6c(%rbp),%xmm2
movss  0x18c4(%rip),%xmm3
subss  %xmm3,%xmm2
divss  -0x6c(%rbp),%xmm2
subss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
movss  0x18ab(%rip),%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,-0x78(%rbp)
movss  0x18de(%rip),%xmm0
ucomiss -0x70(%rbp),%xmm0
jbe    17c2 <createEnvelopes+0x602>
movss  0x1888(%rip),%xmm0
ucomiss -0x74(%rbp),%xmm0
jbe    1798 <createEnvelopes+0x5d8>
movss  -0x74(%rbp),%xmm0
movss  %xmm0,-0xb8(%rbp)
ff
jmp    17ad <createEnvelopes+0x5ed>
movss  0x1864(%rip),%xmm0
movss  %xmm0,-0xb8(%rbp)
ff
jmp    17ad <createEnvelopes+0x5ed>
movss  -0xb8(%rbp),%xmm0
ff
movss  %xmm0,-0xbc(%rbp)
ff
jmp    180b <createEnvelopes+0x64b>
movss  0x183a(%rip),%xmm0
ucomiss -0x78(%rbp),%xmm0
jbe    17e6 <createEnvelopes+0x626>
movss  -0x78(%rbp),%xmm0
movss  %xmm0,-0xc0(%rbp)
ff
jmp    17fb <createEnvelopes+0x63b>
movss  0x1816(%rip),%xmm0
movss  %xmm0,-0xc0(%rbp)
ff
jmp    17fb <createEnvelopes+0x63b>
movss  -0xc0(%rbp),%xmm0
ff
movss  %xmm0,-0xbc(%rbp)
ff
movss  -0xbc(%rbp),%xmm0
ff
movss  0x1835(%rip),%xmm1
subss  %xmm1,%xmm0
cvttss2si %xmm0,%edi
xorps  %xmm0,%xmm0
call   10c0 <fmax@plt>
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x68(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    16e6 <createEnvelopes+0x526>
jmp    2052 <createEnvelopes+0xe92>
movl   $0x3eda6a23,-0x14(%rbp)
movl   $0x3efe3d3e,-0x18(%rbp)
movl   $0x3d9d6302,-0x1c(%rbp)
mov    -0x4(%rbp),%eax
add    $0xffffffff,%eax
cvtsi2ss %rax,%xmm0
movss  %xmm0,-0x54(%rbp)
movl   $0x0,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jae    198b <createEnvelopes+0x7cb>
movss  -0x14(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x7c(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x18(%rbp),%xmm0
movss  %xmm0,-0xc8(%rbp)
ff
mov    -0x7c(%rbp),%eax
cvtsi2ss %rax,%xmm0
movss  0x177e(%rip),%xmm1
mulss  %xmm1,%xmm0
movss  -0x54(%rbp),%xmm1
divss  %xmm1,%xmm0
cvttss2si %xmm0,%edi
call   10b0 <cos@plt>
movss  -0xc8(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x7c(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
mulss  %xmm2,%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x1c(%rbp),%xmm0
movss  %xmm0,-0xc4(%rbp)
ff
mov    -0x7c(%rbp),%eax
cvtsi2ss %rax,%xmm1
movss  0x1724(%rip),%xmm0
mulss  %xmm1,%xmm0
divss  -0x54(%rbp),%xmm0
cvttss2si %xmm0,%edi
call   10b0 <cos@plt>
movaps %xmm0,%xmm2
movss  -0xc4(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x7c(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x7c(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  0x16d0(%rip),%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    187d <createEnvelopes+0x6bd>
jmp    2052 <createEnvelopes+0xe92>
movl   $0x3eb7ae14,-0x14(%rbp)
movl   $0x3efa0126,-0x18(%rbp)
movl   $0x3e10abb4,-0x1c(%rbp)
movl   $0x3c3f5d79,-0x20(%rbp)
mov    -0x4(%rbp),%eax
add    $0xffffffff,%eax
cvtsi2ss %rax,%xmm0
movss  %xmm0,-0x54(%rbp)
movl   $0x0,-0x80(%rbp)
mov    -0x80(%rbp),%eax
cmp    -0x4(%rbp),%eax
jae    1b57 <createEnvelopes+0x997>
movss  -0x14(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x80(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x18(%rbp),%xmm0
movss  %xmm0,-0xd4(%rbp)
ff
mov    -0x80(%rbp),%eax
cvtsi2ss %rax,%xmm0
movss  0x1638(%rip),%xmm1
mulss  %xmm1,%xmm0
movss  -0x54(%rbp),%xmm1
divss  %xmm1,%xmm0
cvttss2si %xmm0,%edi
call   10b0 <cos@plt>
movss  -0xd4(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x80(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
mulss  %xmm2,%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x1c(%rbp),%xmm0
movss  %xmm0,-0xd0(%rbp)
ff
mov    -0x80(%rbp),%eax
cvtsi2ss %rax,%xmm0
movss  0x15de(%rip),%xmm1
mulss  %xmm1,%xmm0
movss  -0x54(%rbp),%xmm1
divss  %xmm1,%xmm0
cvttss2si %xmm0,%edi
call   10b0 <cos@plt>
movaps %xmm0,%xmm2
movss  -0xd0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x80(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x20(%rbp),%xmm0
movss  %xmm0,-0xcc(%rbp)
ff
mov    -0x80(%rbp),%eax
cvtsi2ss %rax,%xmm1
movss  0x1578(%rip),%xmm0
mulss  %xmm1,%xmm0
divss  -0x54(%rbp),%xmm0
cvttss2si %xmm0,%edi
call   10b0 <cos@plt>
movaps %xmm0,%xmm2
movss  -0xcc(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x80(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm1
movd   %xmm0,%edx
xor    $0x80000000,%edx
movd   %edx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x80(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  0x150e(%rip),%xmm1
subss  %xmm1,%xmm0
cvttss2si %xmm0,%edi
xorps  %xmm0,%xmm0
call   10c0 <fmax@plt>
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x80(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    19c3 <createEnvelopes+0x803>
jmp    2052 <createEnvelopes+0xe92>
movl   $0x0,-0x84(%rbp)
mov    -0x84(%rbp),%eax
cmp    -0x4(%rbp),%eax
jae    1c0b <createEnvelopes+0xa4b>
mov    -0x84(%rbp),%eax
cvtsi2sd %rax,%xmm1
mov    -0x4(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
cvtsi2sd %rcx,%xmm0
movsd  0x1513(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
add    $0x1,%eax
cvtsi2sd %rax,%xmm2
movsd  0x14f3(%rip),%xmm1
mulsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
call   1060 <fabs@plt>
movaps %xmm0,%xmm1
movss  0x143f(%rip),%xmm0
subss  %xmm1,%xmm0
movss  0x145f(%rip),%xmm1
subss  %xmm1,%xmm0
cvttss2si %xmm0,%edi
xorps  %xmm0,%xmm0
call   10c0 <fmax@plt>
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x84(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    1b66 <createEnvelopes+0x9a6>
jmp    2052 <createEnvelopes+0xe92>
movl   $0x0,-0x88(%rbp)
mov    -0x88(%rbp),%eax
cmp    -0x4(%rbp),%eax
jae    1d5f <createEnvelopes+0xb9f>
mov    -0x88(%rbp),%eax
cvtsi2sd %rax,%xmm0
movsd  0x1444(%rip),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x4(%rbp),%eax
add    $0xffffffff,%eax
cvtsi2sd %rax,%xmm1
divsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   10b0 <cos@plt>
movss  0x13c4(%rip),%xmm1
mulss  %xmm1,%xmm0
movss  0x13bc(%rip),%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,-0xdc(%rbp)
ff
mov    -0x88(%rbp),%eax
cvtsi2sd %rax,%xmm0
movsd  0x13fd(%rip),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x4(%rbp),%eax
add    $0xffffffff,%eax
cvtsi2sd %rax,%xmm1
divsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   10b0 <cos@plt>
movss  -0xdc(%rbp),%xmm1
ff
movss  0x1375(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xd8(%rbp)
ff
mov    -0x88(%rbp),%eax
cvtsi2sd %rax,%xmm0
movsd  0x13b6(%rip),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x4(%rbp),%eax
add    $0xffffffff,%eax
cvtsi2sd %rax,%xmm1
divsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   10b0 <cos@plt>
movss  -0xd8(%rbp),%xmm1
ff
movss  0x131a(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x88(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x88(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  0x12da(%rip),%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    1c1a <createEnvelopes+0xa5a>
jmp    2052 <createEnvelopes+0xe92>
movl   $0x0,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jae    1ef6 <createEnvelopes+0xd36>
mov    -0x8c(%rbp),%eax
cvtsi2sd %rax,%xmm0
movsd  0x12f0(%rip),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x4(%rbp),%eax
add    $0xffffffff,%eax
cvtsi2sd %rax,%xmm1
divsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   10b0 <cos@plt>
movss  0x125c(%rip),%xmm1
mulss  %xmm1,%xmm0
movss  0x1244(%rip),%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,-0xe8(%rbp)
ff
mov    -0x8c(%rbp),%eax
cvtsi2sd %rax,%xmm0
movsd  0x12a9(%rip),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x4(%rbp),%eax
add    $0xffffffff,%eax
cvtsi2sd %rax,%xmm1
divsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   10b0 <cos@plt>
movss  -0xe8(%rbp),%xmm1
ff
movss  0x1209(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xe4(%rbp)
ff
mov    -0x8c(%rbp),%eax
cvtsi2sd %rax,%xmm0
movsd  0x1262(%rip),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x4(%rbp),%eax
add    $0xffffffff,%eax
cvtsi2sd %rax,%xmm1
divsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   10b0 <cos@plt>
movss  -0xe4(%rbp),%xmm1
ff
movss  0x11be(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xe0(%rbp)
ff
mov    -0x8c(%rbp),%eax
cvtsi2sd %rax,%xmm0
movsd  0x121b(%rip),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x4(%rbp),%eax
add    $0xffffffff,%eax
cvtsi2sd %rax,%xmm1
divsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   10b0 <cos@plt>
movss  -0xe0(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movss  0x1160(%rip),%xmm0
mulss  %xmm2,%xmm0
movss  0x1150(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvttss2si %xmm0,%edi
xorps  %xmm0,%xmm0
call   10c0 <fmax@plt>
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x8c(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    1d6e <createEnvelopes+0xbae>
jmp    2052 <createEnvelopes+0xe92>
movl   $0x0,-0x90(%rbp)
mov    -0x90(%rbp),%eax
cmp    -0x4(%rbp),%eax
jae    202e <createEnvelopes+0xe6e>
movabs $0x4008000000000000,%rax
mov    %rax,-0x98(%rbp)
movsd  -0x98(%rbp),%xmm0
ff
movsd  0x113b(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x90(%rbp),%eax
cvtsi2sd %rax,%xmm0
addsd  %xmm0,%xmm0
mov    -0x4(%rbp),%eax
add    $0xffffffff,%eax
cvtsi2sd %rax,%xmm1
divsd  %xmm1,%xmm0
movsd  0x1111(%rip),%xmm1
subsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
mov    $0x2,%esi
call   10d0 <pow@plt>
movaps %xmm0,%xmm1
movss  0x1080(%rip),%xmm0
subss  %xmm1,%xmm0
cvttss2si %xmm0,%edi
call   10e0 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0xf8(%rbp),%xmm0
ff
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
call   10a0 <bessi0@plt>
movss  %xmm0,-0xec(%rbp)
ff
movsd  0x10b3(%rip),%xmm0
mulsd  -0x98(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
call   10a0 <bessi0@plt>
movaps %xmm0,%xmm1
movss  -0xec(%rbp),%xmm0
ff
divss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x90(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x90(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  0xfef(%rip),%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x90(%rbp)
jmp    1f05 <createEnvelopes+0xd45>
jmp    2052 <createEnvelopes+0xe92>
mov    -0x2c(%rbp),%esi
lea    0x10c7(%rip),%rdi
call   1040 <printf@plt>
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
jmp    2057 <createEnvelopes+0xe97>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11e3 <createEnvelopes+0x23>
mov    -0x10(%rbp),%rax
add    $0x100,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<createEnvelopes>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %edi,%r15d
mov    $0x68,%edi
call   1090 <malloc@plt>
mov    %rax,0x30(%rsp)
lea    -0x1(%r15),%eax
cvtsi2sd %rax,%xmm1
lea    0x1(%r15),%ecx
cvtsi2sd %rcx,%xmm2
movsd  0xe06(%rip),%xmm0
mulsd  %xmm0,%xmm2
movsd  %xmm2,0x50(%rsp)
xorps  %xmm2,%xmm2
cvtsi2ss %rax,%xmm2
movss  %xmm2,0x4(%rsp)
mov    %r15d,%r14d
xorps  %xmm2,%xmm2
cvtsi2ss %r14,%xmm2
movss  0xe33(%rip),%xmm3
mulss  %xmm2,%xmm3
movss  %xmm3,0x1c(%rsp)
movss  0xe25(%rip),%xmm3
movaps %xmm2,%xmm4
addss  %xmm3,%xmm4
movss  %xmm4,0x2c(%rsp)
movss  %xmm2,0x24(%rsp)
subss  %xmm2,%xmm3
movss  %xmm3,0x28(%rsp)
movapd %xmm1,%xmm2
mulsd  %xmm0,%xmm2
movsd  %xmm2,0x48(%rsp)
movsd  0xd9e(%rip),%xmm2
movsd  %xmm1,0x10(%rsp)
mulsd  %xmm1,%xmm2
mulsd  %xmm0,%xmm2
movsd  %xmm2,0x40(%rsp)
mov    %r14d,%eax
and    $0xfffffffe,%eax
mov    %rax,0x38(%rsp)
xor    %r13d,%r13d
jmp    12be <createEnvelopes+0xfe>
lea    0xe87(%rip),%rdi
mov    %r13d,%esi
call   1040 <printf@plt>
mov    0x0(%rbp),%rdi
call   1030 <free@plt>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r13
cmp    $0xd,%r13
je     1b54 <createEnvelopes+0x994>
mov    %r15d,%edi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    0x30(%rsp),%rcx
lea    (%rcx,%r13,8),%rbp
mov    %rax,(%rcx,%r13,8)
cmp    $0xc,%r13d
ja     128e <createEnvelopes+0xce>
mov    %r13d,%ecx
lea    0xe00(%rip),%rdx
movslq (%rdx,%rcx,4),%rcx
add    %rdx,%rcx
jmp    *%rcx
test   %r15d,%r15d
je     12b0 <createEnvelopes+0xf0>
xor    %ebx,%ebx
cmp    $0x1,%r15d
je     136b <createEnvelopes+0x1ab>
mov    0x38(%rsp),%r12
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %ebx,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
movsd  0xd2e(%rip),%xmm1
mulsd  %xmm1,%xmm0
divsd  0x10(%rsp),%xmm0
call   1070 <sin@plt>
mov    0x0(%rbp),%rax
movss  %xmm0,(%rax,%rbx,4)
lea    0x1(%rbx),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
mulsd  0xd03(%rip),%xmm0
divsd  0x10(%rsp),%xmm0
call   1070 <sin@plt>
mov    0x0(%rbp),%rax
movss  %xmm0,0x4(%rax,%rbx,4)
add    $0x2,%rbx
cmp    %r12,%rbx
jne    1310 <createEnvelopes+0x150>
test   $0x1,%r14b
je     12b0 <createEnvelopes+0xf0>
mov    %ebx,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
mulsd  0xcc9(%rip),%xmm0
divsd  0x10(%rsp),%xmm0
call   1070 <sin@plt>
mov    0x0(%rbp),%rax
movss  %xmm0,(%rax,%rbx,4)
jmp    12b0 <createEnvelopes+0xf0>
test   %r15d,%r15d
je     12b0 <createEnvelopes+0xf0>
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
mov    %ebx,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
mulsd  0xc86(%rip),%xmm0
divsd  0x10(%rsp),%xmm0
cvttsd2si %xmm0,%edi
call   10b0 <cos@plt>
movss  0xc87(%rip),%xmm1
subss  %xmm0,%xmm1
mulss  0xce7(%rip),%xmm1
mov    0x0(%rbp),%rax
movss  %xmm1,(%rax,%rbx,4)
add    $0x1,%rbx
cmp    %rbx,%r14
jne    13b0 <createEnvelopes+0x1f0>
jmp    12b0 <createEnvelopes+0xf0>
test   %r15d,%r15d
je     12b0 <createEnvelopes+0xf0>
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
mov    %ebx,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
mulsd  0xc26(%rip),%xmm0
divsd  0x10(%rsp),%xmm0
cvttsd2si %xmm0,%edi
call   10b0 <cos@plt>
mulss  0xca3(%rip),%xmm0
addss  0xc9f(%rip),%xmm0
addss  0xc9b(%rip),%xmm0
mov    0x0(%rbp),%rax
movss  %xmm0,(%rax,%rbx,4)
add    $0x1,%rbx
cmp    %rbx,%r14
jne    1410 <createEnvelopes+0x250>
jmp    12b0 <createEnvelopes+0xf0>
test   %r15d,%r15d
je     12b0 <createEnvelopes+0xf0>
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
mov    %ebx,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
mulsd  0xbc6(%rip),%xmm0
divsd  0x10(%rsp),%xmm0
cvttsd2si %xmm0,%edi
call   10b0 <cos@plt>
movss  0xbc7(%rip),%xmm2
movaps %xmm2,%xmm1
subss  %xmm0,%xmm1
minss  %xmm2,%xmm1
mov    0x0(%rbp),%rax
movss  %xmm1,(%rax,%rbx,4)
add    $0x1,%rbx
cmp    %rbx,%r14
jne    1470 <createEnvelopes+0x2b0>
jmp    12b0 <createEnvelopes+0xf0>
test   %r15d,%r15d
je     12b0 <createEnvelopes+0xf0>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
mov    %ebx,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
subsd  0x48(%rsp),%xmm0
divsd  0x40(%rsp),%xmm0
cvttsd2si %xmm0,%edi
mov    $0x2,%esi
call   10d0 <pow@plt>
mulss  0xb60(%rip),%xmm0
cvttss2si %xmm0,%esi
mov    $0x2,%edi
call   10d0 <pow@plt>
addss  0xbc6(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
call   1060 <fabs@plt>
mov    0x0(%rbp),%rax
movss  %xmm0,(%rax,%rbx,4)
add    $0x1,%rbx
cmp    %rbx,%r14
jne    14d0 <createEnvelopes+0x310>
jmp    12b0 <createEnvelopes+0xf0>
test   %r15d,%r15d
je     12b0 <createEnvelopes+0xf0>
xor    %ebx,%ebx
nopl   (%rax)
mov    %ebx,%eax
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
movss  %xmm0,0x8(%rsp)
movss  0xb04(%rip),%xmm0
movss  0x4(%rsp),%xmm1
movss  0x1c(%rsp),%xmm2
call   1080 <gaussian@plt>
movss  %xmm0,(%rsp)
movss  0x24(%rsp),%xmm0
addss  0x8(%rsp),%xmm0
movss  0x4(%rsp),%xmm1
movss  0x1c(%rsp),%xmm2
call   1080 <gaussian@plt>
movss  %xmm0,0x20(%rsp)
movss  0x8(%rsp),%xmm0
subss  0x24(%rsp),%xmm0
movss  0x4(%rsp),%xmm1
movss  0x1c(%rsp),%xmm2
call   1080 <gaussian@plt>
addss  0x20(%rsp),%xmm0
mulss  (%rsp),%xmm0
movss  %xmm0,(%rsp)
movss  0x2c(%rsp),%xmm0
movss  0x4(%rsp),%xmm1
movss  0x1c(%rsp),%xmm2
call   1080 <gaussian@plt>
movss  %xmm0,0x20(%rsp)
movss  0x28(%rsp),%xmm0
movss  0x4(%rsp),%xmm1
movss  0x1c(%rsp),%xmm2
call   1080 <gaussian@plt>
addss  0x20(%rsp),%xmm0
movss  (%rsp),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,(%rsp)
movss  0x8(%rsp),%xmm0
movss  0x4(%rsp),%xmm1
movss  0x1c(%rsp),%xmm2
call   1080 <gaussian@plt>
subss  (%rsp),%xmm0
addss  0xaaa(%rip),%xmm0
cvttss2si %xmm0,%edi
xorps  %xmm0,%xmm0
call   10c0 <fmax@plt>
mov    0x0(%rbp),%rax
movss  %xmm0,(%rax,%rbx,4)
add    $0x1,%rbx
cmp    %rbx,%r14
jne    1540 <createEnvelopes+0x380>
jmp    12b0 <createEnvelopes+0xf0>
test   %r15d,%r15d
je     12b0 <createEnvelopes+0xf0>
xor    %ebx,%ebx
nopl   0x0(%rax)
mov    %ebx,%eax
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
divss  0x24(%rsp),%xmm0
movaps %xmm0,%xmm1
mulss  0xa45(%rip),%xmm1
movaps %xmm0,%xmm2
addss  0xa3e(%rip),%xmm2
mulss  0xa3a(%rip),%xmm2
movss  0x9ca(%rip),%xmm3
addss  %xmm3,%xmm2
cmpltss 0xa29(%rip),%xmm0
andps  %xmm0,%xmm1
andnps %xmm2,%xmm0
orps   %xmm1,%xmm0
minss  %xmm3,%xmm0
addss  0xa18(%rip),%xmm0
cvttss2si %xmm0,%edi
xorps  %xmm0,%xmm0
call   10c0 <fmax@plt>
mov    0x0(%rbp),%rax
movss  %xmm0,(%rax,%rbx,4)
add    $0x1,%rbx
cmp    %rbx,%r14
jne    1660 <createEnvelopes+0x4a0>
jmp    12b0 <createEnvelopes+0xf0>
test   %r15d,%r15d
je     12b0 <createEnvelopes+0xf0>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
movl   $0x3eda6a23,(%rax,%rbx,4)
mov    %ebx,%eax
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
movss  %xmm0,0x8(%rsp)
mulss  0x989(%rip),%xmm0
divss  0x4(%rsp),%xmm0
cvttss2si %xmm0,%edi
call   10b0 <cos@plt>
mov    0x0(%rbp),%rax
mulss  0x98a(%rip),%xmm0
addss  (%rax,%rbx,4),%xmm0
movss  %xmm0,(%rax,%rbx,4)
movss  0x8(%rsp),%xmm0
mulss  0x95e(%rip),%xmm0
divss  0x4(%rsp),%xmm0
cvttss2si %xmm0,%edi
call   10b0 <cos@plt>
mov    0x0(%rbp),%rax
mulss  0x95b(%rip),%xmm0
addss  (%rax,%rbx,4),%xmm0
addss  0x952(%rip),%xmm0
movss  %xmm0,(%rax,%rbx,4)
add    $0x1,%rbx
cmp    %rbx,%r14
jne    16f0 <createEnvelopes+0x530>
jmp    12b0 <createEnvelopes+0xf0>
test   %r15d,%r15d
je     12b0 <createEnvelopes+0xf0>
xor    %ebx,%ebx
nopl   0x0(%rax)
movl   $0x3eb7ae14,(%rax,%rbx,4)
mov    %ebx,%eax
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
movss  %xmm0,0x8(%rsp)
mulss  0x8e9(%rip),%xmm0
divss  0x4(%rsp),%xmm0
cvttss2si %xmm0,%edi
call   10b0 <cos@plt>
mov    0x0(%rbp),%rax
mulss  0x8d2(%rip),%xmm0
addss  (%rax,%rbx,4),%xmm0
movss  %xmm0,(%rax,%rbx,4)
movss  0x8(%rsp),%xmm0
mulss  0x8be(%rip),%xmm0
divss  0x4(%rsp),%xmm0
cvttss2si %xmm0,%edi
call   10b0 <cos@plt>
mov    0x0(%rbp),%rax
mulss  0x8a7(%rip),%xmm0
addss  (%rax,%rbx,4),%xmm0
movss  %xmm0,(%rax,%rbx,4)
movss  0x8(%rsp),%xmm0
mulss  0x893(%rip),%xmm0
divss  0x4(%rsp),%xmm0
cvttss2si %xmm0,%edi
call   10b0 <cos@plt>
mov    0x0(%rbp),%rax
mulss  0x87c(%rip),%xmm0
addss  (%rax,%rbx,4),%xmm0
movss  %xmm0,(%rax,%rbx,4)
addss  0x86e(%rip),%xmm0
cvttss2si %xmm0,%edi
xorps  %xmm0,%xmm0
call   10c0 <fmax@plt>
mov    0x0(%rbp),%rax
movss  %xmm0,(%rax,%rbx,4)
add    $0x1,%rbx
cmp    %rbx,%r14
jne    1790 <createEnvelopes+0x5d0>
jmp    12b0 <createEnvelopes+0xf0>
test   %r15d,%r15d
je     12b0 <createEnvelopes+0xf0>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %ebx,%eax
xorps  %xmm1,%xmm1
cvtsi2sd %rax,%xmm1
movsd  0x10(%rsp),%xmm0
mulsd  0x7a8(%rip),%xmm0
addsd  %xmm1,%xmm0
divsd  0x50(%rsp),%xmm0
call   1060 <fabs@plt>
movss  0x7b1(%rip),%xmm1
subss  %xmm0,%xmm1
addss  0x7d9(%rip),%xmm1
cvttss2si %xmm1,%edi
xorpd  %xmm0,%xmm0
call   10c0 <fmax@plt>
mov    0x0(%rbp),%rax
movss  %xmm0,(%rax,%rbx,4)
add    $0x1,%rbx
cmp    %rbx,%r14
jne    1880 <createEnvelopes+0x6c0>
jmp    12b0 <createEnvelopes+0xf0>
test   %r15d,%r15d
je     12b0 <createEnvelopes+0xf0>
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
mov    %ebx,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
movsd  %xmm0,0x8(%rsp)
mulsd  0x718(%rip),%xmm0
divsd  0x10(%rsp),%xmm0
cvttsd2si %xmm0,%edi
call   10b0 <cos@plt>
mulss  0x761(%rip),%xmm0
addss  0x75d(%rip),%xmm0
movss  %xmm0,(%rsp)
movsd  0x8(%rsp),%xmm0
mulsd  0x6ee(%rip),%xmm0
divsd  0x10(%rsp),%xmm0
cvttsd2si %xmm0,%edi
call   10b0 <cos@plt>
mulss  0x737(%rip),%xmm0
addss  (%rsp),%xmm0
movss  %xmm0,(%rsp)
movsd  0x8(%rsp),%xmm0
mulsd  0x6c7(%rip),%xmm0
divsd  0x10(%rsp),%xmm0
cvttsd2si %xmm0,%edi
call   10b0 <cos@plt>
mulss  0x70c(%rip),%xmm0
addss  (%rsp),%xmm0
mov    0x0(%rbp),%rax
addss  0x6ff(%rip),%xmm0
movss  %xmm0,(%rax,%rbx,4)
add    $0x1,%rbx
cmp    %rbx,%r14
jne    18f0 <createEnvelopes+0x730>
jmp    12b0 <createEnvelopes+0xf0>
test   %r15d,%r15d
je     12b0 <createEnvelopes+0xf0>
xor    %r12d,%r12d
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r12d,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
movsd  %xmm0,0x8(%rsp)
mulsd  0x647(%rip),%xmm0
divsd  0x10(%rsp),%xmm0
cvttsd2si %xmm0,%edi
call   10b0 <cos@plt>
mulss  0x67c(%rip),%xmm0
addss  0x668(%rip),%xmm0
movss  %xmm0,(%rsp)
movsd  0x8(%rsp),%xmm0
mulsd  0x61d(%rip),%xmm0
divsd  0x10(%rsp),%xmm0
cvttsd2si %xmm0,%edi
call   10b0 <cos@plt>
mulss  0x64e(%rip),%xmm0
addss  (%rsp),%xmm0
movss  %xmm0,(%rsp)
movsd  0x8(%rsp),%xmm0
mulsd  0x5f6(%rip),%xmm0
divsd  0x10(%rsp),%xmm0
cvttsd2si %xmm0,%edi
call   10b0 <cos@plt>
mulss  0x623(%rip),%xmm0
addss  (%rsp),%xmm0
movss  %xmm0,(%rsp)
movsd  0x8(%rsp),%xmm0
mulsd  0x5cf(%rip),%xmm0
divsd  0x10(%rsp),%xmm0
cvttsd2si %xmm0,%edi
call   10b0 <cos@plt>
mulss  0x5f8(%rip),%xmm0
mulss  0x5f4(%rip),%xmm0
addss  (%rsp),%xmm0
cvttss2si %xmm0,%edi
xorps  %xmm0,%xmm0
call   10c0 <fmax@plt>
mov    0x0(%rbp),%rax
movss  %xmm0,(%rax,%r12,4)
add    $0x1,%r12
cmp    %r12,%r14
jne    19c0 <createEnvelopes+0x800>
jmp    12b0 <createEnvelopes+0xf0>
test   %r15d,%r15d
je     12b0 <createEnvelopes+0xf0>
xor    %ebx,%ebx
mov    %ebx,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
addsd  %xmm0,%xmm0
divsd  0x10(%rsp),%xmm0
addsd  0x534(%rip),%xmm0
cvttsd2si %xmm0,%edi
mov    $0x2,%esi
call   10d0 <pow@plt>
movss  0x56e(%rip),%xmm1
subss  %xmm0,%xmm1
cvttss2si %xmm1,%edi
call   10e0 <sqrt@plt>
cvtss2sd %xmm0,%xmm0
mulsd  0x50d(%rip),%xmm0
cvtsd2ss %xmm0,%xmm0
call   10a0 <bessi0@plt>
movss  %xmm0,0x8(%rsp)
movss  0x542(%rip),%xmm0
call   10a0 <bessi0@plt>
movss  0x8(%rsp),%xmm1
divss  %xmm0,%xmm1
mov    0x0(%rbp),%rax
addss  0x52b(%rip),%xmm1
movss  %xmm1,(%rax,%rbx,4)
add    $0x1,%rbx
cmp    %rbx,%r14
jne    1ac0 <createEnvelopes+0x900>
jmp    12b0 <createEnvelopes+0xf0>
mov    0x30(%rsp),%rax
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [40 x i8] c"Envelope type %i not defined, ignored.\0A\00"
define float** @createEnvelopes(i32 %0) {
%2 = alloca i32
%3 = alloca float**
%4 = alloca float
%5 = alloca float
%6 = alloca float
%7 = alloca float
%8 = alloca float
%9 = alloca float
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca float
%16 = alloca float
%17 = alloca i32
%18 = alloca float
%19 = alloca float
%20 = alloca float
%21 = alloca float
%22 = alloca float
%23 = alloca float
%24 = alloca i32
%25 = alloca i32
%26 = alloca float
%27 = alloca float
%28 = alloca float
%29 = alloca float
%30 = alloca i32
%31 = alloca i32
%32 = alloca i32
%33 = alloca i32
%34 = alloca i32
%35 = alloca i32
%36 = alloca double
store i32 %0, i32* %2
%37 = call i64 @malloc(i32 104)
%38 = inttoptr i64 %37 to float**
store float** %38, float*** %3
store i32 0, i32* %10
br label %39
39: ; preds = %721, %1
%40 = load i32, i32* %10
%41 = icmp ult i32 %40, 13
br i1 %41, label %42, label %724
42: ; preds = %39
%43 = load i32, i32* %2
%44 = call i64 @calloc(i32 %43, i32 4)
%45 = inttoptr i64 %44 to float*
%46 = load float**, float*** %3
%47 = load i32, i32* %10
%48 = zext i32 %47 to i64
%49 = getelementptr inbounds float*, float** %46, i64 %48
store float* %45, float** %49
%50 = load i32, i32* %10
switch i32 %50, label %711 [
i32 0, label %51
i32 1, label %77
i32 2, label %106
i32 3, label %135
i32 4, label %174
i32 5, label %215
i32 6, label %281
i32 7, label %339
i32 8, label %408
i32 9, label %506
i32 10, label %540
i32 11, label %598
i32 12, label %659
]
51: ; preds = %42
store i32 0, i32* %11
br label %52
52: ; preds = %73, %51
%53 = load i32, i32* %11
%54 = load i32, i32* %2
%55 = icmp ult i32 %53, %54
br i1 %55, label %56, label %76
56: ; preds = %52
%57 = load i32, i32* %11
%58 = uitofp i32 %57 to double
%59 = fmul double 0x400921FB5444261E, %58
%60 = load i32, i32* %2
%61 = sub i32 %60, 1
%62 = uitofp i32 %61 to double
%63 = fdiv double %59, %62
%64 = call float @sin(double %63)
%65 = load float**, float*** %3
%66 = load i32, i32* %10
%67 = zext i32 %66 to i64
%68 = getelementptr inbounds float*, float** %65, i64 %67
%69 = load float*, float** %68
%70 = load i32, i32* %11
%71 = zext i32 %70 to i64
%72 = getelementptr inbounds float, float* %69, i64 %71
store float %64, float* %72
br label %73
73: ; preds = %56
%74 = load i32, i32* %11
%75 = add i32 %74, 1
store i32 %75, i32* %11
br label %52
76: ; preds = %52
br label %720
77: ; preds = %42
store i32 0, i32* %12
br label %78
78: ; preds = %102, %77
%79 = load i32, i32* %12
%80 = load i32, i32* %2
%81 = icmp ult i32 %79, %80
br i1 %81, label %82, label %105
82: ; preds = %78
%83 = load i32, i32* %12
%84 = uitofp i32 %83 to double
%85 = fmul double 0x401921FB5444261E, %84
%86 = load i32, i32* %2
%87 = sub i32 %86, 1
%88 = uitofp i32 %87 to double
%89 = fdiv double %85, %88
%90 = fptosi double %89 to i32
%91 = call float @cos(i32 %90)
%92 = fsub float 1.000000e+00, %91
%93 = fmul float 5.000000e-01, %92
%94 = load float**, float*** %3
%95 = load i32, i32* %10
%96 = zext i32 %95 to i64
%97 = getelementptr inbounds float*, float** %94, i64 %96
%98 = load float*, float** %97
%99 = load i32, i32* %12
%100 = zext i32 %99 to i64
%101 = getelementptr inbounds float, float* %98, i64 %100
store float %93, float* %101
br label %102
102: ; preds = %82
%103 = load i32, i32* %12
%104 = add i32 %103, 1
store i32 %104, i32* %12
br label %78
105: ; preds = %78
br label %720
106: ; preds = %42
store i32 0, i32* %13
br label %107
107: ; preds = %131, %106
%108 = load i32, i32* %13
%109 = load i32, i32* %2
%110 = icmp ult i32 %108, %109
br i1 %110, label %111, label %134
111: ; preds = %107
%112 = load i32, i32* %13
%113 = uitofp i32 %112 to double
%114 = fmul double 0x401921FB5444261E, %113
%115 = load i32, i32* %2
%116 = sub i32 %115, 1
%117 = uitofp i32 %116 to double
%118 = fdiv double %114, %117
%119 = fptosi double %118 to i32
%120 = call float @cos(i32 %119)
%121 = call float @llvm.fmuladd.f32(float 0xBFDD70A3E0000000, float %120, float 0x3FE147AE20000000)
%122 = fsub float %121, 0x3FB47AE140000000
%123 = load float**, float*** %3
%124 = load i32, i32* %10
%125 = zext i32 %124 to i64
%126 = getelementptr inbounds float*, float** %123, i64 %125
%127 = load float*, float** %126
%128 = load i32, i32* %13
%129 = zext i32 %128 to i64
%130 = getelementptr inbounds float, float* %127, i64 %129
store float %122, float* %130
br label %131
131: ; preds = %111
%132 = load i32, i32* %13
%133 = add i32 %132, 1
store i32 %133, i32* %13
br label %107
134: ; preds = %107
br label %720
135: ; preds = %42
store i32 0, i32* %14
br label %136
136: ; preds = %170, %135
%137 = load i32, i32* %14
%138 = load i32, i32* %2
%139 = icmp ult i32 %137, %138
br i1 %139, label %140, label %173
140: ; preds = %136
store float 5.000000e-01, float* %15
%141 = load float, float* %15
%142 = fmul float 2.000000e+00, %141
%143 = fdiv float 1.000000e+00, %142
%144 = load i32, i32* %14
%145 = uitofp i32 %144 to double
%146 = fmul double 0x401921FB5444261E, %145
%147 = load i32, i32* %2
%148 = sub i32 %147, 1
%149 = uitofp i32 %148 to double
%150 = fdiv double %146, %149
%151 = fptosi double %150 to i32
%152 = call float @cos(i32 %151)
%153 = fsub float 1.000000e+00, %152
%154 = fmul float %143, %153
store float %154, float* %16
%155 = load float, float* %16
%156 = fcmp olt float %155, 1.000000e+00
br i1 %156, label %157, label %159
157: ; preds = %140
%158 = load float, float* %16
br label %160
159: ; preds = %140
br label %160
160: ; preds = %159, %157
%161 = phi float [ %158, %157 ], [ 1.000000e+00, %159 ]
%162 = load float**, float*** %3
%163 = load i32, i32* %10
%164 = zext i32 %163 to i64
%165 = getelementptr inbounds float*, float** %162, i64 %164
%166 = load float*, float** %165
%167 = load i32, i32* %14
%168 = zext i32 %167 to i64
%169 = getelementptr inbounds float, float* %166, i64 %168
store float %161, float* %169
br label %170
170: ; preds = %160
%171 = load i32, i32* %14
%172 = add i32 %171, 1
store i32 %172, i32* %14
br label %136
173: ; preds = %136
br label %720
174: ; preds = %42
store i32 0, i32* %17
br label %175
175: ; preds = %211, %174
%176 = load i32, i32* %17
%177 = load i32, i32* %2
%178 = icmp ult i32 %176, %177
br i1 %178, label %179, label %214
179: ; preds = %175
store float 0x3FD3333340000000, float* %18
%180 = load i32, i32* %17
%181 = uitofp i32 %180 to double
%182 = load i32, i32* %2
%183 = sub i32 %182, 1
%184 = uitofp i32 %183 to double
%185 = fdiv double %184, 2.000000e+00
%186 = fsub double %181, %185
%187 = load float, float* %18
%188 = fpext float %187 to double
%189 = load i32, i32* %2
%190 = sub i32 %189, 1
%191 = uitofp i32 %190 to double
%192 = fmul double %188, %191
%193 = fdiv double %192, 2.000000e+00
%194 = fdiv double %186, %193
%195 = fptosi double %194 to i32
%196 = call float @pow(i32 %195, i32 2)
%197 = fmul float -5.000000e-01, %196
%198 = fptosi float %197 to i32
%199 = call float @pow(i32 2, i32 %198)
%200 = fsub float %199, 0x3F6FAB9700000000
%201 = fpext float %200 to double
%202 = call float @fabs(double %201)
%203 = load float**, float*** %3
%204 = load i32, i32* %10
%205 = zext i32 %204 to i64
%206 = getelementptr inbounds float*, float** %203, i64 %205
%207 = load float*, float** %206
%208 = load i32, i32* %17
%209 = zext i32 %208 to i64
%210 = getelementptr inbounds float, float* %207, i64 %209
store float %202, float* %210
br label %211
211: ; preds = %179
%212 = load i32, i32* %17
%213 = add i32 %212, 1
store i32 %213, i32* %17
br label %175
214: ; preds = %175
br label %720
215: ; preds = %42
%216 = load i32, i32* %2
%217 = uitofp i32 %216 to float
store float %217, float* %9
%218 = load float, float* %9
%219 = fmul float %218, 0x3FC99999A0000000
store float %219, float* %19
%220 = load i32, i32* %2
%221 = sub i32 %220, 1
%222 = uitofp i32 %221 to float
store float %222, float* %20
store float 0.000000e+00, float* %21
store float 0.000000e+00, float* %22
store float 0.000000e+00, float* %23
store i32 0, i32* %24
br label %223
223: ; preds = %277, %215
%224 = load i32, i32* %24
%225 = load i32, i32* %2
%226 = icmp ult i32 %224, %225
br i1 %226, label %227, label %280
227: ; preds = %223
%228 = load i32, i32* %24
%229 = uitofp i32 %228 to float
store float %229, float* %23
%230 = load float, float* %20
%231 = load float, float* %19
%232 = call float @gaussian(float -5.000000e-01, float %230, float %231)
%233 = load float, float* %23
%234 = load float, float* %9
%235 = fadd float %233, %234
%236 = load float, float* %20
%237 = load float, float* %19
%238 = call float @gaussian(float %235, float %236, float %237)
%239 = load float, float* %23
%240 = load float, float* %9
%241 = fsub float %239, %240
%242 = load float, float* %20
%243 = load float, float* %19
%244 = call float @gaussian(float %241, float %242, float %243)
%245 = fadd float %238, %244
%246 = fmul float %232, %245
store float %246, float* %21
%247 = load float, float* %9
%248 = fadd float -5.000000e-01, %247
%249 = load float, float* %20
%250 = load float, float* %19
%251 = call float @gaussian(float %248, float %249, float %250)
%252 = load float, float* %9
%253 = fsub float -5.000000e-01, %252
%254 = load float, float* %20
%255 = load float, float* %19
%256 = call float @gaussian(float %253, float %254, float %255)
%257 = fadd float %251, %256
store float %257, float* %22
%258 = load float, float* %23
%259 = load float, float* %20
%260 = load float, float* %19
%261 = call float @gaussian(float %258, float %259, float %260)
%262 = load float, float* %21
%263 = load float, float* %22
%264 = fdiv float %262, %263
%265 = fsub float %261, %264
%266 = fsub float %265, 0x3EF4F8B580000000
%267 = fptosi float %266 to i32
%268 = call float @fmax(i32 %267, float 0.000000e+00)
%269 = load float**, float*** %3
%270 = load i32, i32* %10
%271 = zext i32 %270 to i64
%272 = getelementptr inbounds float*, float** %269, i64 %271
%273 = load float*, float** %272
%274 = load i32, i32* %24
%275 = zext i32 %274 to i64
%276 = getelementptr inbounds float, float* %273, i64 %275
store float %268, float* %276
br label %277
277: ; preds = %227
%278 = load i32, i32* %24
%279 = add i32 %278, 1
store i32 %279, i32* %24
br label %223
280: ; preds = %223
br label %720
281: ; preds = %42
store i32 0, i32* %25
br label %282
282: ; preds = %335, %281
%283 = load i32, i32* %25
%284 = load i32, i32* %2
%285 = icmp ult i32 %283, %284
br i1 %285, label %286, label %338
286: ; preds = %282
store float 1.000000e+01, float* %26
%287 = load i32, i32* %25
%288 = uitofp i32 %287 to float
%289 = load i32, i32* %2
%290 = uitofp i32 %289 to float
%291 = fdiv float %288, %290
store float %291, float* %27
%292 = load float, float* %26
%293 = load float, float* %27
%294 = fmul float %292, %293
store float %294, float* %28
%295 = load float, float* %26
%296 = fmul float -1.000000e+00, %295
%297 = load float, float* %27
%298 = load float, float* %26
%299 = fsub float %298, 1.000000e+00
%300 = load float, float* %26
%301 = fdiv float %299, %300
%302 = fsub float %297, %301
%303 = call float @llvm.fmuladd.f32(float %296, float %302, float 1.000000e+00)
store float %303, float* %29
%304 = load float, float* %27
%305 = fcmp olt float %304, 5.000000e-01
br i1 %305, label %306, label %314
306: ; preds = %286
%307 = load float, float* %28
%308 = fcmp olt float %307, 1.000000e+00
br i1 %308, label %309, label %311
309: ; preds = %306
%310 = load float, float* %28
br label %312
311: ; preds = %306
br label %312
312: ; preds = %311, %309
%313 = phi float [ %310, %309 ], [ 1.000000e+00, %311 ]
br label %322
314: ; preds = %286
%315 = load float, float* %29
%316 = fcmp olt float %315, 1.000000e+00
br i1 %316, label %317, label %319
317: ; preds = %314
%318 = load float, float* %29
br label %320
319: ; preds = %314
br label %320
320: ; preds = %319, %317
%321 = phi float [ %318, %317 ], [ 1.000000e+00, %319 ]
br label %322
322: ; preds = %320, %312
%323 = phi float [ %313, %312 ], [ %321, %320 ]
%324 = fsub float %323, 0x3F23EC4600000000
%325 = fptosi float %324 to i32
%326 = call float @fmax(i32 %325, float 0.000000e+00)
%327 = load float**, float*** %3
%328 = load i32, i32* %10
%329 = zext i32 %328 to i64
%330 = getelementptr inbounds float*, float** %327, i64 %329
%331 = load float*, float** %330
%332 = load i32, i32* %25
%333 = zext i32 %332 to i64
%334 = getelementptr inbounds float, float* %331, i64 %333
store float %326, float* %334
br label %335
335: ; preds = %322
%336 = load i32, i32* %25
%337 = add i32 %336, 1
store i32 %337, i32* %25
br label %282
338: ; preds = %282
br label %720
339: ; preds = %42
store float 0x3FDB4D4460000000, float* %4
store float 0x3FDFC7A7C0000000, float* %5
store float 0x3FB3AC6040000000, float* %6
%340 = load i32, i32* %2
%341 = sub i32 %340, 1
%342 = uitofp i32 %341 to float
store float %342, float* %20
store i32 0, i32* %30
br label %343
343: ; preds = %404, %339
%344 = load i32, i32* %30
%345 = load i32, i32* %2
%346 = icmp ult i32 %344, %345
br i1 %346, label %347, label %407
347: ; preds = %343
%348 = load float, float* %4
%349 = load float**, float*** %3
%350 = load i32, i32* %10
%351 = zext i32 %350 to i64
%352 = getelementptr inbounds float*, float** %349, i64 %351
%353 = load float*, float** %352
%354 = load i32, i32* %30
%355 = zext i32 %354 to i64
%356 = getelementptr inbounds float, float* %353, i64 %355
store float %348, float* %356
%357 = load float, float* %5
%358 = load i32, i32* %30
%359 = uitofp i32 %358 to float
%360 = fmul float 0x401921FB60000000, %359
%361 = load float, float* %20
%362 = fdiv float %360, %361
%363 = fptosi float %362 to i32
%364 = call float @cos(i32 %363)
%365 = load float**, float*** %3
%366 = load i32, i32* %10
%367 = zext i32 %366 to i64
%368 = getelementptr inbounds float*, float** %365, i64 %367
%369 = load float*, float** %368
%370 = load i32, i32* %30
%371 = zext i32 %370 to i64
%372 = getelementptr inbounds float, float* %369, i64 %371
%373 = load float, float* %372
%374 = fneg float %357
%375 = call float @llvm.fmuladd.f32(float %374, float %364, float %373)
store float %375, float* %372
%376 = load float, float* %6
%377 = load i32, i32* %30
%378 = uitofp i32 %377 to float
%379 = fmul float 0x402921FB60000000, %378
%380 = load float, float* %20
%381 = fdiv float %379, %380
%382 = fptosi float %381 to i32
%383 = call float @cos(i32 %382)
%384 = load float**, float*** %3
%385 = load i32, i32* %10
%386 = zext i32 %385 to i64
%387 = getelementptr inbounds float*, float** %384, i64 %386
%388 = load float*, float** %387
%389 = load i32, i32* %30
%390 = zext i32 %389 to i64
%391 = getelementptr inbounds float, float* %388, i64 %390
%392 = load float, float* %391
%393 = call float @llvm.fmuladd.f32(float %376, float %383, float %392)
store float %393, float* %391
%394 = load float**, float*** %3
%395 = load i32, i32* %10
%396 = zext i32 %395 to i64
%397 = getelementptr inbounds float*, float** %394, i64 %396
%398 = load float*, float** %397
%399 = load i32, i32* %30
%400 = zext i32 %399 to i64
%401 = getelementptr inbounds float, float* %398, i64 %400
%402 = load float, float* %401
%403 = fsub float %402, 0x3F7C2D2780000000
store float %403, float* %401
br label %404
404: ; preds = %347
%405 = load i32, i32* %30
%406 = add i32 %405, 1
store i32 %406, i32* %30
br label %343
407: ; preds = %343
br label %720
408: ; preds = %42
store float 0x3FD6F5C280000000, float* %4
store float 0x3FDF4024C0000000, float* %5
store float 0x3FC2157680000000, float* %6
store float 0x3F87EBAF20000000, float* %7
%409 = load i32, i32* %2
%410 = sub i32 %409, 1
%411 = uitofp i32 %410 to float
store float %411, float* %20
store i32 0, i32* %31
br label %412
412: ; preds = %502, %408
%413 = load i32, i32* %31
%414 = load i32, i32* %2
%415 = icmp ult i32 %413, %414
br i1 %415, label %416, label %505
416: ; preds = %412
%417 = load float, float* %4
%418 = load float**, float*** %3
%419 = load i32, i32* %10
%420 = zext i32 %419 to i64
%421 = getelementptr inbounds float*, float** %418, i64 %420
%422 = load float*, float** %421
%423 = load i32, i32* %31
%424 = zext i32 %423 to i64
%425 = getelementptr inbounds float, float* %422, i64 %424
store float %417, float* %425
%426 = load float, float* %5
%427 = load i32, i32* %31
%428 = uitofp i32 %427 to float
%429 = fmul float 0x401921FB60000000, %428
%430 = load float, float* %20
%431 = fdiv float %429, %430
%432 = fptosi float %431 to i32
%433 = call float @cos(i32 %432)
%434 = load float**, float*** %3
%435 = load i32, i32* %10
%436 = zext i32 %435 to i64
%437 = getelementptr inbounds float*, float** %434, i64 %436
%438 = load float*, float** %437
%439 = load i32, i32* %31
%440 = zext i32 %439 to i64
%441 = getelementptr inbounds float, float* %438, i64 %440
%442 = load float, float* %441
%443 = fneg float %426
%444 = call float @llvm.fmuladd.f32(float %443, float %433, float %442)
store float %444, float* %441
%445 = load float, float* %6
%446 = load i32, i32* %31
%447 = uitofp i32 %446 to float
%448 = fmul float 0x402921FB60000000, %447
%449 = load float, float* %20
%450 = fdiv float %448, %449
%451 = fptosi float %450 to i32
%452 = call float @cos(i32 %451)
%453 = load float**, float*** %3
%454 = load i32, i32* %10
%455 = zext i32 %454 to i64
%456 = getelementptr inbounds float*, float** %453, i64 %455
%457 = load float*, float** %456
%458 = load i32, i32* %31
%459 = zext i32 %458 to i64
%460 = getelementptr inbounds float, float* %457, i64 %459
%461 = load float, float* %460
%462 = call float @llvm.fmuladd.f32(float %445, float %452, float %461)
store float %462, float* %460
%463 = load float, float* %7
%464 = load i32, i32* %31
%465 = uitofp i32 %464 to float
%466 = fmul float 0x4032D97C80000000, %465
%467 = load float, float* %20
%468 = fdiv float %466, %467
%469 = fptosi float %468 to i32
%470 = call float @cos(i32 %469)
%471 = load float**, float*** %3
%472 = load i32, i32* %10
%473 = zext i32 %472 to i64
%474 = getelementptr inbounds float*, float** %471, i64 %473
%475 = load float*, float** %474
%476 = load i32, i32* %31
%477 = zext i32 %476 to i64
%478 = getelementptr inbounds float, float* %475, i64 %477
%479 = load float, float* %478
%480 = fneg float %463
%481 = call float @llvm.fmuladd.f32(float %480, float %470, float %479)
store float %481, float* %478
%482 = load float**, float*** %3
%483 = load i32, i32* %10
%484 = zext i32 %483 to i64
%485 = getelementptr inbounds float*, float** %482, i64 %484
%486 = load float*, float** %485
%487 = load i32, i32* %31
%488 = zext i32 %487 to i64
%489 = getelementptr inbounds float, float* %486, i64 %488
%490 = load float, float* %489
%491 = fsub float %490, 0x3F0F751040000000
%492 = fptosi float %491 to i32
%493 = call float @fmax(i32 %492, float 0.000000e+00)
%494 = load float**, float*** %3
%495 = load i32, i32* %10
%496 = zext i32 %495 to i64
%497 = getelementptr inbounds float*, float** %494, i64 %496
%498 = load float*, float** %497
%499 = load i32, i32* %31
%500 = zext i32 %499 to i64
%501 = getelementptr inbounds float, float* %498, i64 %500
store float %493, float* %501
br label %502
502: ; preds = %416
%503 = load i32, i32* %31
%504 = add i32 %503, 1
store i32 %504, i32* %31
br label %412
505: ; preds = %412
br label %720
506: ; preds = %42
store i32 0, i32* %32
br label %507
507: ; preds = %536, %506
%508 = load i32, i32* %32
%509 = load i32, i32* %2
%510 = icmp ult i32 %508, %509
br i1 %510, label %511, label %539
511: ; preds = %507
%512 = load i32, i32* %32
%513 = uitofp i32 %512 to double
%514 = load i32, i32* %2
%515 = sub i32 %514, 1
%516 = uitofp i32 %515 to double
%517 = call double @llvm.fmuladd.f64(double -5.000000e-01, double %516, double %513)
%518 = load i32, i32* %2
%519 = add i32 %518, 1
%520 = uitofp i32 %519 to double
%521 = fmul double 5.000000e-01, %520
%522 = fdiv double %517, %521
%523 = call float @fabs(double %522)
%524 = fsub float 1.000000e+00, %523
%525 = fsub float %524, 0x3F0040BFE0000000
%526 = fptosi float %525 to i32
%527 = call float @fmax(i32 %526, float 0.000000e+00)
%528 = load float**, float*** %3
%529 = load i32, i32* %10
%530 = zext i32 %529 to i64
%531 = getelementptr inbounds float*, float** %528, i64 %530
%532 = load float*, float** %531
%533 = load i32, i32* %32
%534 = zext i32 %533 to i64
%535 = getelementptr inbounds float, float* %532, i64 %534
store float %527, float* %535
br label %536
536: ; preds = %511
%537 = load i32, i32* %32
%538 = add i32 %537, 1
store i32 %538, i32* %32
br label %507
539: ; preds = %507
br label %720
540: ; preds = %42
store i32 0, i32* %33
br label %541
541: ; preds = %594, %540
%542 = load i32, i32* %33
%543 = load i32, i32* %2
%544 = icmp ult i32 %542, %543
br i1 %544, label %545, label %597
545: ; preds = %541
%546 = load i32, i32* %33
%547 = uitofp i32 %546 to double
%548 = fmul double 0x401921FB60000000, %547
%549 = load i32, i32* %2
%550 = sub i32 %549, 1
%551 = uitofp i32 %550 to double
%552 = fdiv double %548, %551
%553 = fptosi double %552 to i32
%554 = call float @cos(i32 %553)
%555 = call float @llvm.fmuladd.f32(float 0xBFD744ED00000000, float %554, float 0x3FD744ED00000000)
%556 = load i32, i32* %33
%557 = uitofp i32 %556 to double
%558 = fmul double 0x402921FB60000000, %557
%559 = load i32, i32* %2
%560 = sub i32 %559, 1
%561 = uitofp i32 %560 to double
%562 = fdiv double %558, %561
%563 = fptosi double %562 to i32
%564 = call float @cos(i32 %563)
%565 = call float @llvm.fmuladd.f32(float 0x3FC17C17A0000000, float %564, float %555)
%566 = load i32, i32* %33
%567 = uitofp i32 %566 to double
%568 = fmul double 0x4032D97C80000000, %567
%569 = load i32, i32* %2
%570 = sub i32 %569, 1
%571 = uitofp i32 %570 to double
%572 = fdiv double %568, %571
%573 = fptosi double %572 to i32
%574 = call float @cos(i32 %573)
%575 = call float @llvm.fmuladd.f32(float 0xBFC0B14EC0000000, float %574, float %565)
%576 = load float**, float*** %3
%577 = load i32, i32* %10
%578 = zext i32 %577 to i64
%579 = getelementptr inbounds float*, float** %576, i64 %578
%580 = load float*, float** %579
%581 = load i32, i32* %33
%582 = zext i32 %581 to i64
%583 = getelementptr inbounds float, float* %580, i64 %582
store float %575, float* %583
%584 = load float**, float*** %3
%585 = load i32, i32* %10
%586 = zext i32 %585 to i64
%587 = getelementptr inbounds float*, float** %584, i64 %586
%588 = load float*, float** %587
%589 = load i32, i32* %33
%590 = zext i32 %589 to i64
%591 = getelementptr inbounds float, float* %588, i64 %590
%592 = load float, float* %591
%593 = fsub float %592, 0x3F795896A0000000
store float %593, float* %591
br label %594
594: ; preds = %545
%595 = load i32, i32* %33
%596 = add i32 %595, 1
store i32 %596, i32* %33
br label %541
597: ; preds = %541
br label %720
598: ; preds = %42
store i32 0, i32* %34
br label %599
599: ; preds = %655, %598
%600 = load i32, i32* %34
%601 = load i32, i32* %2
%602 = icmp ult i32 %600, %601
br i1 %602, label %603, label %658
603: ; preds = %599
%604 = load i32, i32* %34
%605 = uitofp i32 %604 to double
%606 = fmul double 0x401921FB60000000, %605
%607 = load i32, i32* %2
%608 = sub i32 %607, 1
%609 = uitofp i32 %608 to double
%610 = fdiv double %606, %609
%611 = fptosi double %610 to i32
%612 = call float @cos(i32 %611)
%613 = call float @llvm.fmuladd.f32(float 0xBFFEE147A0000000, float %612, float 1.000000e+00)
%614 = load i32, i32* %34
%615 = uitofp i32 %614 to double
%616 = fmul double 0x402921FB60000000, %615
%617 = load i32, i32* %2
%618 = sub i32 %617, 1
%619 = uitofp i32 %618 to double
%620 = fdiv double %616, %619
%621 = fptosi double %620 to i32
%622 = call float @cos(i32 %621)
%623 = call float @llvm.fmuladd.f32(float 0x3FF4A3D700000000, float %622, float %613)
%624 = load i32, i32* %34
%625 = uitofp i32 %624 to double
%626 = fmul double 0x4032D97C80000000, %625
%627 = load i32, i32* %2
%628 = sub i32 %627, 1
%629 = uitofp i32 %628 to double
%630 = fdiv double %626, %629
%631 = fptosi double %630 to i32
%632 = call float @cos(i32 %631)
%633 = call float @llvm.fmuladd.f32(float 0xBFD8D4FE00000000, float %632, float %623)
%634 = load i32, i32* %34
%635 = uitofp i32 %634 to double
%636 = fmul double 0x403921FB60000000, %635
%637 = load i32, i32* %2
%638 = sub i32 %637, 1
%639 = uitofp i32 %638 to double
%640 = fdiv double %636, %639
%641 = fptosi double %640 to i32
%642 = call float @cos(i32 %641)
%643 = fmul float 0x3FA0624DE0000000, %642
%644 = call float @llvm.fmuladd.f32(float %643, float 0x3FCB851EC0000000, float %633)
%645 = fptosi float %644 to i32
%646 = call float @fmax(i32 %645, float 0.000000e+00)
%647 = load float**, float*** %3
%648 = load i32, i32* %10
%649 = zext i32 %648 to i64
%650 = getelementptr inbounds float*, float** %647, i64 %649
%651 = load float*, float** %650
%652 = load i32, i32* %34
%653 = zext i32 %652 to i64
%654 = getelementptr inbounds float, float* %651, i64 %653
store float %646, float* %654
br label %655
655: ; preds = %603
%656 = load i32, i32* %34
%657 = add i32 %656, 1
store i32 %657, i32* %34
br label %599
658: ; preds = %599
br label %720
659: ; preds = %42
store i32 0, i32* %35
br label %660
660: ; preds = %707, %659
%661 = load i32, i32* %35
%662 = load i32, i32* %2
%663 = icmp ult i32 %661, %662
br i1 %663, label %664, label %710
664: ; preds = %660
store double 3.000000e+00, double* %36
%665 = load double, double* %36
%666 = fmul double 0x400921FB60000000, %665
%667 = load i32, i32* %35
%668 = uitofp i32 %667 to double
%669 = fmul double 2.000000e+00, %668
%670 = load i32, i32* %2
%671 = sub i32 %670, 1
%672 = uitofp i32 %671 to double
%673 = fdiv double %669, %672
%674 = fsub double %673, 1.000000e+00
%675 = fptosi double %674 to i32
%676 = call float @pow(i32 %675, i32 2)
%677 = fsub float 1.000000e+00, %676
%678 = fptosi float %677 to i32
%679 = call float @sqrt(i32 %678)
%680 = fpext float %679 to double
%681 = fmul double %666, %680
%682 = fptrunc double %681 to float
%683 = call float @bessi0(float %682)
%684 = load double, double* %36
%685 = fmul double 0x400921FB60000000, %684
%686 = fptrunc double %685 to float
%687 = call float @bessi0(float %686)
%688 = fdiv float %683, %687
%689 = load float**, float*** %3
%690 = load i32, i32* %10
%691 = zext i32 %690 to i64
%692 = getelementptr inbounds float*, float** %689, i64 %691
%693 = load float*, float** %692
%694 = load i32, i32* %35
%695 = zext i32 %694 to i64
%696 = getelementptr inbounds float, float* %693, i64 %695
store float %688, float* %696
%697 = load float**, float*** %3
%698 = load i32, i32* %10
%699 = zext i32 %698 to i64
%700 = getelementptr inbounds float*, float** %697, i64 %699
%701 = load float*, float** %700
%702 = load i32, i32* %35
%703 = zext i32 %702 to i64
%704 = getelementptr inbounds float, float* %701, i64 %703
%705 = load float, float* %704
%706 = fsub float %705, 0x3F440DD400000000
store float %706, float* %704
br label %707
707: ; preds = %664
%708 = load i32, i32* %35
%709 = add i32 %708, 1
store i32 %709, i32* %35
br label %660
710: ; preds = %660
br label %720
711: ; preds = %42
%712 = load i32, i32* %10
%713 = call i32 @printf(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str, i64 0, i64 0), i32 %712)
%714 = load float**, float*** %3
%715 = load i32, i32* %10
%716 = zext i32 %715 to i64
%717 = getelementptr inbounds float*, float** %714, i64 %716
%718 = load float*, float** %717
%719 = call i32 @free(float* %718)
br label %720
720: ; preds = %711, %710, %658, %597, %539, %505, %407, %338, %280, %214, %173, %134, %105, %76
br label %721
721: ; preds = %720
%722 = load i32, i32* %10
%723 = add i32 %722, 1
store i32 %723, i32* %10
br label %39
724: ; preds = %39
%725 = load float**, float*** %3
ret float** %725
}

LLVM IR (-O2):
@.str = [40 x i8] c"Envelope type %i not defined, ignored.\0A\00"
define float** @createEnvelopes(i32 %0) {
%2 = tail call i64 @malloc(i32 104)
%3 = inttoptr i64 %2 to float**
%4 = icmp eq i32 %0, 0
%5 = add i32 %0, -1
%6 = uitofp i32 %5 to double
%7 = add i32 %0, 1
%8 = uitofp i32 %7 to double
%9 = fmul double %8, 5.000000e-01
%10 = uitofp i32 %5 to float
%11 = uitofp i32 %0 to float
%12 = fmul float %11, 0x3FC99999A0000000
%13 = fadd float %11, -5.000000e-01
%14 = fsub float -5.000000e-01, %11
%15 = fmul double %6, 5.000000e-01
%16 = fmul double %6, 0x3FD3333340000000
%17 = fmul double %16, 5.000000e-01
%18 = zext i32 %0 to i64
%19 = zext i32 %0 to i64
%20 = zext i32 %0 to i64
%21 = zext i32 %0 to i64
%22 = zext i32 %0 to i64
%23 = zext i32 %0 to i64
%24 = zext i32 %0 to i64
%25 = zext i32 %0 to i64
%26 = zext i32 %0 to i64
%27 = zext i32 %0 to i64
%28 = zext i32 %0 to i64
%29 = zext i32 %0 to i64
%30 = and i64 %18, 1
%31 = icmp eq i32 %0, 1
%32 = and i64 %18, 4294967294
%33 = icmp eq i64 %30, 0
br label %35
34: ; preds = %351
ret float** %3
35: ; preds = %1, %351
%36 = phi i64 [ 0, %1 ], [ %352, %351 ]
%37 = tail call i64 @calloc(i32 %0, i32 4)
%38 = inttoptr i64 %37 to float*
%39 = getelementptr inbounds float*, float** %3, i64 %36
store float* %38, float** %39
%40 = trunc i64 %36 to i32
switch i32 %40, label %337 [
i32 0, label %50
i32 1, label %49
i32 2, label %48
i32 3, label %47
i32 4, label %46
i32 5, label %134
i32 6, label %45
i32 7, label %180
i32 8, label %206
i32 9, label %44
i32 10, label %43
i32 11, label %42
i32 12, label %41
]
41: ; preds = %35
br i1 %4, label %351, label %314
42: ; preds = %35
br i1 %4, label %351, label %283
43: ; preds = %35
br i1 %4, label %351, label %259
44: ; preds = %35
br i1 %4, label %351, label %244
45: ; preds = %35
br i1 %4, label %351, label %159
46: ; preds = %35
br i1 %4, label %351, label %116
47: ; preds = %35
br i1 %4, label %351, label %101
48: ; preds = %35
br i1 %4, label %351, label %87
49: ; preds = %35
br i1 %4, label %351, label %73
50: ; preds = %35
br i1 %4, label %351, label %51
51: ; preds = %50
br i1 %31, label %341, label %52
52: ; preds = %51, %52
%53 = phi i64 [ %70, %52 ], [ 0, %51 ]
%54 = phi i64 [ %71, %52 ], [ 0, %51 ]
%55 = trunc i64 %53 to i32
%56 = uitofp i32 %55 to double
%57 = fmul double %56, 0x400921FB5444261E
%58 = fdiv double %57, %6
%59 = tail call float @sin(double %58)
%60 = load float*, float** %39
%61 = getelementptr inbounds float, float* %60, i64 %53
store float %59, float* %61
%62 = or i64 %53, 1
%63 = trunc i64 %62 to i32
%64 = uitofp i32 %63 to double
%65 = fmul double %64, 0x400921FB5444261E
%66 = fdiv double %65, %6
%67 = tail call float @sin(double %66)
%68 = load float*, float** %39
%69 = getelementptr inbounds float, float* %68, i64 %62
store float %67, float* %69
%70 = add nuw nsw i64 %53, 2
%71 = add i64 %54, 2
%72 = icmp eq i64 %71, %32
br i1 %72, label %341, label %52
73: ; preds = %49, %73
%74 = phi i64 [ %85, %73 ], [ 0, %49 ]
%75 = trunc i64 %74 to i32
%76 = uitofp i32 %75 to double
%77 = fmul double %76, 0x401921FB5444261E
%78 = fdiv double %77, %6
%79 = fptosi double %78 to i32
%80 = tail call float @cos(i32 %79)
%81 = fsub float 1.000000e+00, %80
%82 = fmul float %81, 5.000000e-01
%83 = load float*, float** %39
%84 = getelementptr inbounds float, float* %83, i64 %74
store float %82, float* %84
%85 = add nuw nsw i64 %74, 1
%86 = icmp eq i64 %85, %29
br i1 %86, label %351, label %73
87: ; preds = %48, %87
%88 = phi i64 [ %99, %87 ], [ 0, %48 ]
%89 = trunc i64 %88 to i32
%90 = uitofp i32 %89 to double
%91 = fmul double %90, 0x401921FB5444261E
%92 = fdiv double %91, %6
%93 = fptosi double %92 to i32
%94 = tail call float @cos(i32 %93)
%95 = tail call float @llvm.fmuladd.f32(float %94, float 0xBFDD70A3E0000000, float 0x3FE147AE20000000)
%96 = fadd float %95, 0xBFB47AE140000000
%97 = load float*, float** %39
%98 = getelementptr inbounds float, float* %97, i64 %88
store float %96, float* %98
%99 = add nuw nsw i64 %88, 1
%100 = icmp eq i64 %99, %28
br i1 %100, label %351, label %87
101: ; preds = %47, %101
%102 = phi i64 [ %114, %101 ], [ 0, %47 ]
%103 = trunc i64 %102 to i32
%104 = uitofp i32 %103 to double
%105 = fmul double %104, 0x401921FB5444261E
%106 = fdiv double %105, %6
%107 = fptosi double %106 to i32
%108 = tail call float @cos(i32 %107)
%109 = fsub float 1.000000e+00, %108
%110 = fcmp olt float %109, 1.000000e+00
%111 = select i1 %110, float %109, float 1.000000e+00
%112 = load float*, float** %39
%113 = getelementptr inbounds float, float* %112, i64 %102
store float %111, float* %113
%114 = add nuw nsw i64 %102, 1
%115 = icmp eq i64 %114, %27
br i1 %115, label %351, label %101
116: ; preds = %46, %116
%117 = phi i64 [ %132, %116 ], [ 0, %46 ]
%118 = trunc i64 %117 to i32
%119 = uitofp i32 %118 to double
%120 = fsub double %119, %15
%121 = fdiv double %120, %17
%122 = fptosi double %121 to i32
%123 = tail call float @pow(i32 %122, i32 2)
%124 = fmul float %123, -5.000000e-01
%125 = fptosi float %124 to i32
%126 = tail call float @pow(i32 2, i32 %125)
%127 = fadd float %126, 0xBF6FAB9700000000
%128 = fpext float %127 to double
%129 = tail call float @fabs(double %128)
%130 = load float*, float** %39
%131 = getelementptr inbounds float, float* %130, i64 %117
store float %129, float* %131
%132 = add nuw nsw i64 %117, 1
%133 = icmp eq i64 %132, %26
br i1 %133, label %351, label %116
134: ; preds = %35
br i1 %4, label %351, label %135
135: ; preds = %134, %135
%136 = phi i64 [ %157, %135 ], [ 0, %134 ]
%137 = trunc i64 %136 to i32
%138 = uitofp i32 %137 to float
%139 = tail call float @gaussian(float -5.000000e-01, float %10, float %12)
%140 = fadd float %11, %138
%141 = tail call float @gaussian(float %140, float %10, float %12)
%142 = fsub float %138, %11
%143 = tail call float @gaussian(float %142, float %10, float %12)
%144 = fadd float %141, %143
%145 = fmul float %139, %144
%146 = tail call float @gaussian(float %13, float %10, float %12)
%147 = tail call float @gaussian(float %14, float %10, float %12)
%148 = fadd float %146, %147
%149 = tail call float @gaussian(float %138, float %10, float %12)
%150 = fdiv float %145, %148
%151 = fsub float %149, %150
%152 = fadd float %151, 0xBEF4F8B580000000
%153 = fptosi float %152 to i32
%154 = tail call float @fmax(i32 %153, float 0.000000e+00)
%155 = load float*, float** %39
%156 = getelementptr inbounds float, float* %155, i64 %136
store float %154, float* %156
%157 = add nuw nsw i64 %136, 1
%158 = icmp eq i64 %157, %25
br i1 %158, label %351, label %135
159: ; preds = %45, %159
%160 = phi i64 [ %178, %159 ], [ 0, %45 ]
%161 = trunc i64 %160 to i32
%162 = uitofp i32 %161 to float
%163 = fdiv float %162, %11
%164 = fmul float %163, 1.000000e+01
%165 = fadd float %163, 0xBFECCCCCC0000000
%166 = tail call float @llvm.fmuladd.f32(float %165, float -1.000000e+01, float 1.000000e+00)
%167 = fcmp olt float %163, 5.000000e-01
%168 = fcmp olt float %164, 1.000000e+00
%169 = select i1 %168, float %164, float 1.000000e+00
%170 = fcmp olt float %166, 1.000000e+00
%171 = select i1 %170, float %166, float 1.000000e+00
%172 = select i1 %167, float %169, float %171
%173 = fadd float %172, 0xBF23EC4600000000
%174 = fptosi float %173 to i32
%175 = tail call float @fmax(i32 %174, float 0.000000e+00)
%176 = load float*, float** %39
%177 = getelementptr inbounds float, float* %176, i64 %160
store float %175, float* %177
%178 = add nuw nsw i64 %160, 1
%179 = icmp eq i64 %178, %24
br i1 %179, label %351, label %159
180: ; preds = %35
br i1 %4, label %351, label %181
181: ; preds = %180, %181
%182 = phi float* [ %199, %181 ], [ %38, %180 ]
%183 = phi i64 [ %204, %181 ], [ 0, %180 ]
%184 = getelementptr inbounds float, float* %182, i64 %183
store float 0x3FDB4D4460000000, float* %184
%185 = trunc i64 %183 to i32
%186 = uitofp i32 %185 to float
%187 = fmul float %186, 0x401921FB60000000
%188 = fdiv float %187, %10
%189 = fptosi float %188 to i32
%190 = tail call float @cos(i32 %189)
%191 = load float*, float** %39
%192 = getelementptr inbounds float, float* %191, i64 %183
%193 = load float, float* %192
%194 = tail call float @llvm.fmuladd.f32(float %190, float 0xBFDFC7A7C0000000, float %193)
store float %194, float* %192
%195 = fmul float %186, 0x402921FB60000000
%196 = fdiv float %195, %10
%197 = fptosi float %196 to i32
%198 = tail call float @cos(i32 %197)
%199 = load float*, float** %39
%200 = getelementptr inbounds float, float* %199, i64 %183
%201 = load float, float* %200
%202 = tail call float @llvm.fmuladd.f32(float %198, float 0x3FB3AC6040000000, float %201)
%203 = fadd float %202, 0xBF7C2D2780000000
store float %203, float* %200
%204 = add nuw nsw i64 %183, 1
%205 = icmp eq i64 %204, %23
br i1 %205, label %351, label %181
206: ; preds = %35
br i1 %4, label %351, label %207
207: ; preds = %206, %207
%208 = phi float* [ %240, %207 ], [ %38, %206 ]
%209 = phi i64 [ %242, %207 ], [ 0, %206 ]
%210 = getelementptr inbounds float, float* %208, i64 %209
store float 0x3FD6F5C280000000, float* %210
%211 = trunc i64 %209 to i32
%212 = uitofp i32 %211 to float
%213 = fmul float %212, 0x401921FB60000000
%214 = fdiv float %213, %10
%215 = fptosi float %214 to i32
%216 = tail call float @cos(i32 %215)
%217 = load float*, float** %39
%218 = getelementptr inbounds float, float* %217, i64 %209
%219 = load float, float* %218
%220 = tail call float @llvm.fmuladd.f32(float %216, float 0xBFDF4024C0000000, float %219)
store float %220, float* %218
%221 = fmul float %212, 0x402921FB60000000
%222 = fdiv float %221, %10
%223 = fptosi float %222 to i32
%224 = tail call float @cos(i32 %223)
%225 = load float*, float** %39
%226 = getelementptr inbounds float, float* %225, i64 %209
%227 = load float, float* %226
%228 = tail call float @llvm.fmuladd.f32(float %224, float 0x3FC2157680000000, float %227)
store float %228, float* %226
%229 = fmul float %212, 0x4032D97C80000000
%230 = fdiv float %229, %10
%231 = fptosi float %230 to i32
%232 = tail call float @cos(i32 %231)
%233 = load float*, float** %39
%234 = getelementptr inbounds float, float* %233, i64 %209
%235 = load float, float* %234
%236 = tail call float @llvm.fmuladd.f32(float %232, float 0xBF87EBAF20000000, float %235)
store float %236, float* %234
%237 = fadd float %236, 0xBF0F751040000000
%238 = fptosi float %237 to i32
%239 = tail call float @fmax(i32 %238, float 0.000000e+00)
%240 = load float*, float** %39
%241 = getelementptr inbounds float, float* %240, i64 %209
store float %239, float* %241
%242 = add nuw nsw i64 %209, 1
%243 = icmp eq i64 %242, %22
br i1 %243, label %351, label %207
244: ; preds = %44, %244
%245 = phi i64 [ %257, %244 ], [ 0, %44 ]
%246 = trunc i64 %245 to i32
%247 = uitofp i32 %246 to double
%248 = tail call double @llvm.fmuladd.f64(double %6, double -5.000000e-01, double %247)
%249 = fdiv double %248, %9
%250 = tail call float @fabs(double %249)
%251 = fsub float 1.000000e+00, %250
%252 = fadd float %251, 0xBF0040BFE0000000
%253 = fptosi float %252 to i32
%254 = tail call float @fmax(i32 %253, float 0.000000e+00)
%255 = load float*, float** %39
%256 = getelementptr inbounds float, float* %255, i64 %245
store float %254, float* %256
%257 = add nuw nsw i64 %245, 1
%258 = icmp eq i64 %257, %21
br i1 %258, label %351, label %244
259: ; preds = %43, %259
%260 = phi i64 [ %281, %259 ], [ 0, %43 ]
%261 = trunc i64 %260 to i32
%262 = uitofp i32 %261 to double
%263 = fmul double %262, 0x401921FB60000000
%264 = fdiv double %263, %6
%265 = fptosi double %264 to i32
%266 = tail call float @cos(i32 %265)
%267 = tail call float @llvm.fmuladd.f32(float %266, float 0xBFD744ED00000000, float 0x3FD744ED00000000)
%268 = fmul double %262, 0x402921FB60000000
%269 = fdiv double %268, %6
%270 = fptosi double %269 to i32
%271 = tail call float @cos(i32 %270)
%272 = tail call float @llvm.fmuladd.f32(float %271, float 0x3FC17C17A0000000, float %267)
%273 = fmul double %262, 0x4032D97C80000000
%274 = fdiv double %273, %6
%275 = fptosi double %274 to i32
%276 = tail call float @cos(i32 %275)
%277 = tail call float @llvm.fmuladd.f32(float %276, float 0xBFC0B14EC0000000, float %272)
%278 = load float*, float** %39
%279 = getelementptr inbounds float, float* %278, i64 %260
%280 = fadd float %277, 0xBF795896A0000000
store float %280, float* %279
%281 = add nuw nsw i64 %260, 1
%282 = icmp eq i64 %281, %20
br i1 %282, label %351, label %259
283: ; preds = %42, %283
%284 = phi i64 [ %312, %283 ], [ 0, %42 ]
%285 = trunc i64 %284 to i32
%286 = uitofp i32 %285 to double
%287 = fmul double %286, 0x401921FB60000000
%288 = fdiv double %287, %6
%289 = fptosi double %288 to i32
%290 = tail call float @cos(i32 %289)
%291 = tail call float @llvm.fmuladd.f32(float %290, float 0xBFFEE147A0000000, float 1.000000e+00)
%292 = fmul double %286, 0x402921FB60000000
%293 = fdiv double %292, %6
%294 = fptosi double %293 to i32
%295 = tail call float @cos(i32 %294)
%296 = tail call float @llvm.fmuladd.f32(float %295, float 0x3FF4A3D700000000, float %291)
%297 = fmul double %286, 0x4032D97C80000000
%298 = fdiv double %297, %6
%299 = fptosi double %298 to i32
%300 = tail call float @cos(i32 %299)
%301 = tail call float @llvm.fmuladd.f32(float %300, float 0xBFD8D4FE00000000, float %296)
%302 = fmul double %286, 0x403921FB60000000
%303 = fdiv double %302, %6
%304 = fptosi double %303 to i32
%305 = tail call float @cos(i32 %304)
%306 = fmul float %305, 0x3FA0624DE0000000
%307 = tail call float @llvm.fmuladd.f32(float %306, float 0x3FCB851EC0000000, float %301)
%308 = fptosi float %307 to i32
%309 = tail call float @fmax(i32 %308, float 0.000000e+00)
%310 = load float*, float** %39
%311 = getelementptr inbounds float, float* %310, i64 %284
store float %309, float* %311
%312 = add nuw nsw i64 %284, 1
%313 = icmp eq i64 %312, %19
br i1 %313, label %351, label %283
314: ; preds = %41, %314
%315 = phi i64 [ %335, %314 ], [ 0, %41 ]
%316 = trunc i64 %315 to i32
%317 = uitofp i32 %316 to double
%318 = fmul double %317, 2.000000e+00
%319 = fdiv double %318, %6
%320 = fadd double %319, -1.000000e+00
%321 = fptosi double %320 to i32
%322 = tail call float @pow(i32 %321, i32 2)
%323 = fsub float 1.000000e+00, %322
%324 = fptosi float %323 to i32
%325 = tail call float @sqrt(i32 %324)
%326 = fpext float %325 to double
%327 = fmul double %326, 0x4022D97C88000000
%328 = fptrunc double %327 to float
%329 = tail call float @bessi0(float %328)
%330 = tail call float @bessi0(float 0x4022D97C80000000)
%331 = fdiv float %329, %330
%332 = load float*, float** %39
%333 = getelementptr inbounds float, float* %332, i64 %315
%334 = fadd float %331, 0xBF440DD400000000
store float %334, float* %333
%335 = add nuw nsw i64 %315, 1
%336 = icmp eq i64 %335, %18
br i1 %336, label %351, label %314
337: ; preds = %35
%338 = tail call i32 @printf(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str, i64 0, i64 0), i32 %40)
%339 = load float*, float** %39
%340 = tail call i32 @free(float* %339)
br label %351
341: ; preds = %52, %51
%342 = phi i64 [ 0, %51 ], [ %70, %52 ]
br i1 %33, label %351, label %343
343: ; preds = %341
%344 = trunc i64 %342 to i32
%345 = uitofp i32 %344 to double
%346 = fmul double %345, 0x400921FB5444261E
%347 = fdiv double %346, %6
%348 = tail call float @sin(double %347)
%349 = load float*, float** %39
%350 = getelementptr inbounds float, float* %349, i64 %342
store float %348, float* %350
br label %351
351: ; preds = %314, %283, %259, %244, %207, %181, %159, %135, %116, %101, %87, %73, %343, %341, %41, %42, %43, %44, %206, %180, %45, %134, %46, %47, %48, %49, %50, %337
%352 = add nuw nsw i64 %36, 1
%353 = icmp eq i64 %352, 13
br i1 %353, label %34, label %35
}