#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 /*<<< orphan*/ abort();
int exp(int);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *);
int /*<<< orphan*/ free(double *);
double const sqrt(double);
int /*<<< orphan*/ stderr;
double *xmalloc(int const);
void gaussian(float *I, const int xdim, const int ydim, const double sigma) {
  const int boundary_condition = 1;
  const int window_size = 5;
  const double den = 2 * sigma * sigma;
  const int size = (int)(window_size * sigma) + 1;
  const int bdx = xdim + size;
  const int bdy = ydim + size;
  if (boundary_condition && size > xdim) {
    fprintf(stderr, "GaussianSmooth: sigma too large\n");
    abort();
  }
  double B[size];
  for (int i = 0; i < size; i++)
    B[i] = 1 / (sigma * sqrt(2.0 * 3.1415926)) * exp(-i * i / den);
  double norm = 0;
  for (int i = 0; i < size; i++)
    norm += B[i];
  norm *= 2;
  norm -= B[0];
  for (int i = 0; i < size; i++)
    B[i] /= norm;
  double *R = xmalloc((size + xdim + size) * sizeof *R);
  for (int k = 0; k < ydim; k++) {
    int i, j;
    for (i = size; i < bdx; i++)
      R[i] = I[k * xdim + i - size];
    switch (boundary_condition) {
    case 0:
      for (i = 0, j = bdx; i < size; i++, j++)
        R[i] = R[j] = 0;
      break;
    case 1:
      for (i = 0, j = bdx; i < size; i++, j++) {
        R[i] = I[k * xdim + size - i];
        R[j] = I[k * xdim + xdim - i - 1];
      }
      break;
    case 2:
      for (i = 0, j = bdx; i < size; i++, j++) {
        R[i] = I[k * xdim + xdim - size + i];
        R[j] = I[k * xdim + i];
      }
      break;
    }
    for (i = size; i < bdx; i++) {
      double sum = B[0] * R[i];
      for (j = 1; j < size; j++)
        sum += B[j] * (R[i - j] + R[i + j]);
      I[k * xdim + i - size] = sum;
    }
  }
  double *T = xmalloc((size + ydim + size) * sizeof *T);
  for (int k = 0; k < xdim; k++) {
    int i, j;
    for (i = size; i < bdy; i++)
      T[i] = I[(i - size) * xdim + k];
    switch (boundary_condition) {
    case 0:
      for (i = 0, j = bdy; i < size; i++, j++)
        T[i] = T[j] = 0;
      break;
    case 1:
      for (i = 0, j = bdy; i < size; i++, j++) {
        T[i] = I[(size - i) * xdim + k];
        T[j] = I[(ydim - i - 1) * xdim + k];
      }
      break;
    case 2:
      for (i = 0, j = bdx; i < size; i++, j++) {
        T[i] = I[(ydim - size + i) * xdim + k];
        T[j] = I[i * xdim + k];
      }
      break;
    }
    for (i = size; i < bdy; i++) {
      double sum = B[0] * T[i];
      for (j = 1; j < size; j++)
        sum += B[j] * (T[i - j] + T[i + j]);
      I[(i - size) * xdim + k] = sum;
    }
  }
  free(R);
  free(T);
}


x86 assembly (clang, -O0):
<gaussian>:
push   %rbp
mov    %rsp,%rbp
sub    $0xc0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
movsd  %xmm0,-0x18(%rbp)
movl   $0x1,-0x1c(%rbp)
movl   $0x5,-0x20(%rbp)
movsd  0xe78(%rip),%xmm0
mulsd  -0x18(%rbp),%xmm0
mulsd  -0x18(%rbp),%xmm0
movsd  %xmm0,-0x28(%rbp)
movsd  0xe59(%rip),%xmm0
mulsd  -0x18(%rbp),%xmm0
cvttsd2si %xmm0,%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0xc(%rbp),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x10(%rbp),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jle    11f0 <gaussian+0x90>
mov    0x2e05(%rip),%rax
mov    (%rax),%edi
lea    0xe3c(%rip),%rsi
call   1060 <fprintf@plt>
mov    $0x0,%al
call   1040 <abort@plt>
mov    -0x2c(%rbp),%eax
mov    %rsp,%rcx
mov    %rcx,-0x40(%rbp)
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0xa8(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x48(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    12b2 <gaussian+0x152>
movsd  -0x18(%rbp),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  0xdd6(%rip),%xmm0
call   1080 <sqrt@plt>
movsd  -0xb8(%rbp),%xmm1
ff
mulsd  %xmm0,%xmm1
movsd  0xdb5(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
xor    %eax,%eax
sub    -0x4c(%rbp),%eax
imul   -0x4c(%rbp),%eax
cvtsi2sd %eax,%xmm0
divsd  -0x28(%rbp),%xmm0
cvttsd2si %xmm0,%edi
call   1070 <exp@plt>
movsd  -0xb0(%rbp),%xmm0
ff
mov    %eax,%ecx
mov    -0xa8(%rbp),%rax
cvtsi2sd %ecx,%xmm1
mulsd  %xmm1,%xmm0
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1221 <gaussian+0xc1>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    12f5 <gaussian+0x195>
mov    -0xa8(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    12c1 <gaussian+0x161>
mov    -0xa8(%rbp),%rax
movsd  0xd04(%rip),%xmm0
mulsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  (%rax),%xmm1
movsd  -0x58(%rbp),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    135f <gaussian+0x1ff>
mov    -0xa8(%rbp),%rax
movsd  -0x58(%rbp),%xmm1
movslq -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    1327 <gaussian+0x1c7>
mov    -0x2c(%rbp),%eax
add    -0xc(%rbp),%eax
add    -0x2c(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <xmalloc@plt>
mov    %rax,-0x68(%rbp)
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1536 <gaussian+0x3d6>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    13d6 <gaussian+0x276>
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x70(%rbp),%ecx
sub    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x68(%rbp),%rax
movslq -0x70(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    1392 <gaussian+0x232>
movl   $0x0,-0x70(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0x70(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    145d <gaussian+0x2fd>
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x2c(%rbp),%ecx
sub    -0x70(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x68(%rbp),%rax
movslq -0x70(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0xc(%rbp),%ecx
sub    -0x70(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x68(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    13e3 <gaussian+0x283>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1523 <gaussian+0x3c3>
mov    -0xa8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x70(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
movl   $0x1,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    14f3 <gaussian+0x393>
mov    -0xa8(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x70(%rbp),%ecx
sub    -0x74(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x68(%rbp),%rax
mov    -0x70(%rbp),%ecx
add    -0x74(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm2
movsd  -0x80(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    1493 <gaussian+0x333>
movsd  -0x80(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x70(%rbp),%ecx
sub    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    1463 <gaussian+0x303>
jmp    1528 <gaussian+0x3c8>
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    1380 <gaussian+0x220>
mov    -0x2c(%rbp),%eax
add    -0x10(%rbp),%eax
add    -0x2c(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <xmalloc@plt>
mov    %rax,-0x88(%rbp)
movl   $0x0,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    17a6 <gaussian+0x646>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x90(%rbp)
mov    -0x90(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    15ce <gaussian+0x46e>
mov    -0x8(%rbp),%rax
mov    -0x90(%rbp),%ecx
sub    -0x2c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x8c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x88(%rbp),%rax
movslq -0x90(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x90(%rbp)
jmp    1575 <gaussian+0x415>
movl   $0x0,-0x90(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x94(%rbp)
mov    -0x90(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1682 <gaussian+0x522>
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    -0x90(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x8c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x88(%rbp),%rax
movslq -0x90(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    -0x90(%rbp),%ecx
sub    $0x1,%ecx
imul   -0xc(%rbp),%ecx
add    -0x8c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x88(%rbp),%rax
movslq -0x94(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x90(%rbp)
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    15e1 <gaussian+0x481>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x90(%rbp)
mov    -0x90(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    178d <gaussian+0x62d>
mov    -0xa8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x88(%rbp),%rax
movslq -0x90(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movl   $0x1,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    174e <gaussian+0x5ee>
mov    -0xa8(%rbp),%rax
movslq -0x94(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x88(%rbp),%rax
mov    -0x90(%rbp),%ecx
sub    -0x94(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x88(%rbp),%rax
mov    -0x90(%rbp),%ecx
add    -0x94(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm2
movsd  -0xa0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    16ca <gaussian+0x56a>
movsd  -0xa0(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x90(%rbp),%ecx
sub    -0x2c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x8c(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x90(%rbp)
jmp    168b <gaussian+0x52b>
jmp    1792 <gaussian+0x632>
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    155d <gaussian+0x3fd>
mov    -0x68(%rbp),%rdi
call   1030 <free@plt>
mov    -0x88(%rbp),%rdi
call   1030 <free@plt>
mov    -0x40(%rbp),%rax
mov    %rax,%rsp
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<gaussian>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xe8,%rsp
mov    %rdx,-0x70(%rbp)
mov    %rdi,%r13
movsd  0xe8d(%rip),%xmm1
mulsd  %xmm0,%xmm1
cvttsd2si %xmm1,%edi
cmp    %esi,%edi
jge    1b61 <gaussian+0xa11>
lea    0x1(%rdi),%ecx
mov    %rsi,-0xa0(%rbp)
lea    (%rdi,%rsi,1),%r12d
add    $0x1,%r12d
mov    %rcx,%rax
mov    %rcx,-0x50(%rbp)
mov    %ecx,%r14d
mov    %rsp,%r15
lea    0xf(,%r14,8),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%r15
mov    %r15,%rsp
test   %edi,%edi
mov    %rdi,-0x58(%rbp)
js     13a9 <gaussian+0x259>
movapd %xmm0,%xmm1
addsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,-0x40(%rbp)
mulsd  0xe2f(%rip),%xmm0
movsd  0xe2f(%rip),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,-0x38(%rbp)
xor    %ebx,%ebx
nopl   0x0(%rax)
mov    %ebx,%eax
imul   %ebx,%eax
neg    %eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
divsd  -0x40(%rbp),%xmm0
cvttsd2si %xmm0,%edi
call   1070 <exp@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mulsd  -0x38(%rbp),%xmm0
movsd  %xmm0,(%r15,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%r14
jne    11f0 <gaussian+0xa0>
mov    -0x58(%rbp),%rdi
test   %edi,%edi
js     13a9 <gaussian+0x259>
lea    -0x1(%r14),%rax
mov    %r14d,%ecx
and    $0x7,%ecx
cmp    $0x7,%rax
jae    124b <gaussian+0xfb>
xorpd  %xmm0,%xmm0
xor    %edx,%edx
jmp    12a0 <gaussian+0x150>
mov    %r14d,%esi
and    $0xfffffff8,%esi
xorpd  %xmm0,%xmm0
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
addsd  (%r15,%rdx,8),%xmm0
addsd  0x8(%r15,%rdx,8),%xmm0
addsd  0x10(%r15,%rdx,8),%xmm0
addsd  0x18(%r15,%rdx,8),%xmm0
addsd  0x20(%r15,%rdx,8),%xmm0
addsd  0x28(%r15,%rdx,8),%xmm0
addsd  0x30(%r15,%rdx,8),%xmm0
addsd  0x38(%r15,%rdx,8),%xmm0
add    $0x8,%rdx
cmp    %rdx,%rsi
jne    1260 <gaussian+0x110>
test   %rcx,%rcx
je     12be <gaussian+0x16e>
lea    (%r15,%rdx,8),%rdx
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
addsd  (%rdx,%rsi,8),%xmm0
add    $0x1,%rsi
cmp    %rsi,%rcx
jne    12b0 <gaussian+0x160>
test   %edi,%edi
js     13a9 <gaussian+0x259>
addsd  %xmm0,%xmm0
movsd  (%r15),%xmm1
subsd  %xmm1,%xmm0
divsd  %xmm0,%xmm1
movsd  %xmm1,(%r15)
je     13a9 <gaussian+0x259>
mov    $0x1,%ecx
cmp    $0x2,%rax
jb     1390 <gaussian+0x240>
mov    %rax,%rcx
and    $0xfffffffffffffffe,%rcx
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    -0x2(%rcx),%rsi
mov    %rsi,%rdx
shr    %rdx
add    $0x1,%rdx
test   %rsi,%rsi
je     1b4e <gaussian+0x9fe>
mov    %rdx,%rdi
and    $0xfffffffffffffffe,%rdi
mov    $0x1,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd (%r15,%rsi,8),%xmm2
movupd 0x10(%r15,%rsi,8),%xmm3
divpd  %xmm1,%xmm2
movupd %xmm2,(%r15,%rsi,8)
divpd  %xmm1,%xmm3
movupd %xmm3,0x10(%r15,%rsi,8)
add    $0x4,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1330 <gaussian+0x1e0>
test   $0x1,%dl
je     1371 <gaussian+0x221>
movupd (%r15,%rsi,8),%xmm2
divpd  %xmm1,%xmm2
movupd %xmm2,(%r15,%rsi,8)
cmp    %rcx,%rax
mov    -0x58(%rbp),%rdi
je     13a9 <gaussian+0x259>
or     $0x1,%rax
mov    %rax,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r15,%rcx,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%r15,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%r14
jne    1390 <gaussian+0x240>
mov    %r14,-0x60(%rbp)
mov    -0x70(%rbp),%rbx
lea    (%rdi,%rbx,1),%eax
add    $0x1,%eax
mov    %rax,-0xb8(%rbp)
mov    -0x50(%rbp),%rax
lea    (%r12,%rax,1),%edi
shl    $0x3,%edi
call   1050 <xmalloc@plt>
mov    %rax,%rcx
mov    -0xa0(%rbp),%r14
mov    %r14d,%eax
mov    %rax,-0x98(%rbp)
test   %ebx,%ebx
mov    %rcx,-0x38(%rbp)
jle    18cb <gaussian+0x77b>
mov    -0x58(%rbp),%rax
mov    %eax,%r8d
not    %r8d
mov    -0x50(%rbp),%rdi
movslq %edi,%r9
movslq %r12d,%r12
mov    -0x60(%rbp),%rsi
lea    -0x1(%rsi),%r10
lea    (%rcx,%rsi,8),%r11
lea    (%rcx,%r12,8),%rcx
lea    (%r12,%rsi,1),%rdx
mov    -0x38(%rbp),%rbx
lea    (%rbx,%rdx,8),%rdx
lea    0x1(%r9),%rbx
cmp    %r12,%rbx
cmovle %r12,%rbx
mov    %r9,%rdi
not    %rdi
add    %rbx,%rdi
mov    %rdi,-0xc8(%rbp)
sub    %r9,%rbx
lea    -0x4(%rbx),%rax
mov    %rax,-0x100(%rbp)
shr    $0x2,%rax
add    $0x1,%rax
mov    %rbx,-0x78(%rbp)
and    $0xfffffffffffffffc,%rbx
mov    %rax,%rdi
mov    %rax,-0xf8(%rbp)
and    $0xfffffffffffffffe,%rax
mov    %rax,-0xd8(%rbp)
cmp    %rdx,-0x38(%rbp)
setb   %dl
cmp    %r11,%rcx
setb   %al
and    %dl,%al
mov    %al,-0x29(%rbp)
mov    -0x38(%rbp),%rdx
mov    %esi,%eax
and    $0xfffffffe,%eax
mov    %r10,%rsi
and    $0xfffffffffffffffe,%rsi
neg    %rsi
lea    -0x1(%r14),%ecx
mov    %rbx,-0xf0(%rbp)
lea    (%rbx,%r9,1),%rdi
mov    %rdi,-0xe8(%rbp)
mov    %rax,-0xc0(%rbp)
add    %r12,%rax
mov    %rax,-0xe0(%rbp)
lea    0x30(%rdx,%r9,8),%rax
mov    %rax,-0xd0(%rbp)
mov    %r8d,-0x90(%rbp)
mov    %r8d,%r11d
mov    %r9,-0x48(%rbp)
lea    (%rdx,%r9,8),%rax
mov    %rax,-0x88(%rbp)
xor    %eax,%eax
mov    %rax,-0x80(%rbp)
mov    $0x4,%edi
mov    -0x50(%rbp),%rax
mov    %eax,%r9d
mov    %rcx,-0x108(%rbp)
mov    %ecx,%eax
mov    %ecx,-0x68(%rbp)
xor    %ecx,%ecx
mov    %r10,-0x110(%rbp)
jmp    153e <gaussian+0x3ee>
cs nopw 0x0(%rax,%rax,1)
mov    -0xa8(%rbp),%ecx
add    $0x1,%ecx
mov    -0x98(%rbp),%rax
mov    -0x40(%rbp),%rdi
add    %rax,%rdi
add    %rax,-0x80(%rbp)
add    %rax,%r11
add    %r14d,-0x68(%rbp)
add    %r14d,%r9d
cmp    -0x70(%rbp),%ecx
je     18cb <gaussian+0x77b>
mov    %rdi,-0x40(%rbp)
mov    %ecx,-0xa8(%rbp)
mov    %ecx,%r8d
imul   %r14d,%r8d
test   %r14d,%r14d
mov    -0x58(%rbp),%r14
jle    1680 <gaussian+0x530>
mov    -0x48(%rbp),%rax
cmpq   $0x4,-0x78(%rbp)
jb     1660 <gaussian+0x510>
mov    -0xc8(%rbp),%rax
lea    (%r8,%rax,1),%ecx
mov    -0x48(%rbp),%rax
cmp    %r8d,%ecx
jl     1660 <gaussian+0x510>
mov    -0xc8(%rbp),%rax
shr    $0x20,%rax
mov    -0x48(%rbp),%rax
jne    1660 <gaussian+0x510>
mov    %r9d,-0xac(%rbp)
cmpq   $0x4,-0x100(%rbp)
04
jae    15ad <gaussian+0x45d>
xor    %ecx,%ecx
jmp    1614 <gaussian+0x4c4>
mov    -0xd8(%rbp),%rax
xor    %ecx,%ecx
mov    -0xd0(%rbp),%rbx
mov    -0x80(%rbp),%rdi
mov    -0x40(%rbp),%r9
cs nopw 0x0(%rax,%rax,1)
nop
lea    (%rdi,%rcx,1),%edx
movslq %edx,%rdx
cvtps2pd 0x0(%r13,%rdx,4),%xmm0
cvtps2pd 0x8(%r13,%rdx,4),%xmm1
movups %xmm0,-0x30(%rbx,%rcx,8)
movups %xmm1,-0x20(%rbx,%rcx,8)
lea    (%r9,%rcx,1),%edx
movslq %edx,%rdx
cvtps2pd 0x0(%r13,%rdx,4),%xmm0
cvtps2pd 0x8(%r13,%rdx,4),%xmm1
movupd %xmm0,-0x10(%rbx,%rcx,8)
movupd %xmm1,(%rbx,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rax
jne    15d0 <gaussian+0x480>
testb  $0x1,-0xf8(%rbp)
mov    -0x38(%rbp),%rdx
mov    -0xac(%rbp),%r9d
je     164c <gaussian+0x4fc>
mov    -0x48(%rbp),%rax
add    %rcx,%rax
add    %r8d,%ecx
movslq %ecx,%rcx
cvtps2pd 0x0(%r13,%rcx,4),%xmm0
cvtps2pd 0x8(%r13,%rcx,4),%xmm1
movupd %xmm0,(%rdx,%rax,8)
movupd %xmm1,0x10(%rdx,%rax,8)
mov    -0xe8(%rbp),%rax
mov    -0xf0(%rbp),%rcx
cmp    %rcx,-0x78(%rbp)
je     1680 <gaussian+0x530>
lea    (%r11,%rax,1),%ecx
movslq %ecx,%rcx
movss  0x0(%r13,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,(%rdx,%rax,8)
add    $0x1,%rax
cmp    %r12,%rax
jl     1660 <gaussian+0x510>
test   %r14d,%r14d
js     1747 <gaussian+0x5f7>
mov    -0x50(%rbp),%rax
cmp    $0x2,%eax
jb     16cc <gaussian+0x57c>
add    %r8d,%eax
mov    -0x108(%rbp),%rcx
add    %r8d,%ecx
mov    %r10,%rdx
shr    $0x20,%rdx
setne  %dl
mov    %eax,%edi
sub    %r10d,%edi
cmp    %eax,%edi
setg   %al
or     %dl,%al
mov    %ecx,%edi
sub    %r10d,%edi
cmp    %ecx,%edi
setg   %cl
or     %dl,%cl
or     %al,%cl
or     -0x29(%rbp),%cl
je     185a <gaussian+0x70a>
xor    %edx,%edx
mov    %r12,%rcx
mov    -0x68(%rbp),%eax
mov    %rcx,%r10
mov    %eax,%ecx
sub    %edx,%ecx
mov    %r9d,%edi
sub    %edx,%edi
mov    %r9d,%r14d
mov    -0x38(%rbp),%r9
lea    (%r9,%rdx,8),%rax
mov    -0x60(%rbp),%rbx
sub    %rdx,%rbx
lea    (%r9,%r10,8),%rdx
mov    -0x110(%rbp),%r10
mov    %r14d,%r9d
xor    %r14d,%r14d
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movslq %edi,%rdi
movss  0x0(%r13,%rdi,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,(%rax,%r14,8)
movslq %ecx,%rcx
movss  0x0(%r13,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,(%rdx,%r14,8)
add    $0xffffffff,%ecx
add    $0xffffffff,%edi
add    $0x1,%r14
cmp    %r14,%rbx
jne    1710 <gaussian+0x5c0>
mov    -0xa0(%rbp),%r14
test   %r14d,%r14d
mov    -0x38(%rbp),%rdx
jle    1510 <gaussian+0x3c0>
movsd  (%r15),%xmm0
add    -0x90(%rbp),%r8d
mov    -0x88(%rbp),%rdi
mov    -0x48(%rbp),%rcx
jmp    17a2 <gaussian+0x652>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cvtsd2ss %xmm1,%xmm1
lea    (%r8,%rcx,1),%eax
cltq
movss  %xmm1,0x0(%r13,%rax,4)
add    $0x1,%rcx
add    $0x8,%rdi
cmp    %r12,%rcx
jge    1510 <gaussian+0x3c0>
movsd  (%rdx,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
cmpl   $0x0,-0x58(%rbp)
jle    1780 <gaussian+0x630>
mov    $0x1,%ebx
cmpl   $0x2,-0x50(%rbp)
jne    17d0 <gaussian+0x680>
movapd %xmm1,%xmm2
jmp    1825 <gaussian+0x6d5>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    $0x1,%ebx
mov    $0xfffffffffffffff8,%rax
nopl   0x0(%rax)
movsd  -0x8(%rdi,%rax,1),%xmm2
movsd  (%rdi,%rax,1),%xmm3
addsd  (%rdi,%rbx,8),%xmm3
mulsd  (%r15,%rbx,8),%xmm3
addsd  0x8(%rdi,%rbx,8),%xmm2
addsd  %xmm1,%xmm3
mulsd  0x8(%r15,%rbx,8),%xmm2
addsd  %xmm3,%xmm2
add    $0xfffffffffffffff0,%rax
lea    (%rsi,%rbx,1),%rdx
add    $0x2,%rdx
add    $0x2,%rbx
movapd %xmm2,%xmm1
cmp    $0x1,%rdx
jne    17e0 <gaussian+0x690>
movapd %xmm2,%xmm1
test   $0x1,%r10b
mov    -0x38(%rbp),%rdx
je     1780 <gaussian+0x630>
mov    %rcx,%rax
sub    %rbx,%rax
movsd  (%rdx,%rax,8),%xmm1
lea    (%rbx,%rcx,1),%rax
addsd  (%rdx,%rax,8),%xmm1
mulsd  (%r15,%rbx,8),%xmm1
addsd  %xmm2,%xmm1
jmp    1780 <gaussian+0x630>
mov    %r9d,%ecx
mov    -0x68(%rbp),%eax
mov    %eax,%edi
mov    -0xc0(%rbp),%rax
mov    -0x38(%rbp),%rbx
nopl   (%rax)
movslq %ecx,%rcx
movsd  -0x4(%r13,%rcx,4),%xmm0
shufps $0xe1,%xmm0,%xmm0
cvtps2pd %xmm0,%xmm0
movups %xmm0,(%rbx)
movslq %edi,%rdi
movsd  -0x4(%r13,%rdi,4),%xmm0
shufps $0xe1,%xmm0,%xmm0
cvtps2pd %xmm0,%xmm0
movupd %xmm0,(%rbx,%r12,8)
add    $0x10,%rbx
add    $0xfffffffe,%edi
add    $0xfffffffe,%ecx
add    $0xfffffffffffffffe,%rax
jne    1870 <gaussian+0x720>
mov    -0xc0(%rbp),%rax
mov    %rax,%rdx
mov    -0xe0(%rbp),%rcx
cmp    -0x60(%rbp),%rax
jne    16d1 <gaussian+0x581>
jmp    1747 <gaussian+0x5f7>
mov    -0x50(%rbp),%rbx
mov    -0xb8(%rbp),%rax
lea    (%rax,%rbx,1),%edi
shl    $0x3,%edi
call   1050 <xmalloc@plt>
mov    -0x98(%rbp),%rdx
mov    %rax,%r12
test   %r14d,%r14d
jle    1b2f <gaussian+0x9df>
mov    %rbx,%rcx
movslq %ecx,%rbx
movslq -0xb8(%rbp),%r8
mov    -0x60(%rbp),%rax
lea    -0x1(%rax),%rsi
lea    0x0(,%rdx,4),%rdi
mov    -0x70(%rbp),%rax
add    $0xffffffff,%eax
imul   %r14d,%eax
mov    %eax,-0x78(%rbp)
mov    %rbx,%rax
imul   %rdx,%rax
lea    0x0(,%rax,4),%rcx
add    %r13,%rcx
mov    %rdi,%r9
neg    %r9
mov    %rbx,-0x40(%rbp)
lea    (%r12,%rbx,8),%rax
mov    %rax,-0x88(%rbp)
mov    %rsi,%rax
mov    %rsi,-0xa8(%rbp)
mov    %rsi,%rdx
and    $0xfffffffffffffffe,%rdx
neg    %rdx
xor    %r10d,%r10d
mov    %r13,%rax
mov    %rdi,-0x80(%rbp)
mov    %r9,-0x90(%rbp)
jmp    199f <gaussian+0x84f>
nopl   (%rax)
add    $0x1,%r10
mov    -0x68(%rbp),%rax
add    $0x4,%rax
mov    -0x48(%rbp),%rcx
add    $0x4,%rcx
cmp    %rbx,%r10
mov    -0xa0(%rbp),%r14
mov    -0x80(%rbp),%rdi
mov    -0x90(%rbp),%r9
je     1b2f <gaussian+0x9df>
mov    %rax,-0x68(%rbp)
mov    -0x40(%rbp),%rsi
cmpl   $0x0,-0x70(%rbp)
jle    19ca <gaussian+0x87a>
nopl   (%rax)
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,(%r12,%rsi,8)
add    $0x1,%rsi
add    %rdi,%rax
cmp    %r8,%rsi
jl     19b0 <gaussian+0x860>
mov    -0x60(%rbp),%rax
mov    %r12,%rbx
mov    %rcx,-0x48(%rbp)
mov    %rcx,%rdi
mov    -0x78(%rbp),%ecx
mov    %ecx,%esi
cmpl   $0x0,-0x58(%rbp)
js     1a24 <gaussian+0x8d4>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  (%rdi),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,(%rbx)
movslq %esi,%rsi
lea    (%r10,%rsi,1),%rcx
movss  0x0(%r13,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,(%rbx,%r8,8)
sub    %r14d,%esi
add    %r9,%rdi
add    $0x8,%rbx
add    $0xffffffffffffffff,%rax
jne    19f0 <gaussian+0x8a0>
cmpl   $0x0,-0x70(%rbp)
mov    -0x58(%rbp),%rsi
mov    -0x50(%rbp),%rdi
mov    -0x98(%rbp),%rbx
jle    1970 <gaussian+0x820>
movsd  (%r15),%xmm0
mov    -0x88(%rbp),%r9
mov    -0x40(%rbp),%rax
jmp    1a7a <gaussian+0x92a>
nop
cvtsd2ss %xmm1,%xmm1
mov    %rax,%rcx
sub    -0x40(%rbp),%rcx
imul   %rbx,%rcx
add    %r10,%rcx
movss  %xmm1,0x0(%r13,%rcx,4)
add    $0x1,%rax
add    $0x8,%r9
cmp    %r8,%rax
jge    1970 <gaussian+0x820>
movsd  (%r12,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
test   %esi,%esi
jle    1a50 <gaussian+0x900>
mov    $0x1,%r14d
cmp    $0x2,%edi
jne    1aa0 <gaussian+0x950>
movapd %xmm1,%xmm2
jmp    1af9 <gaussian+0x9a9>
nopl   0x0(%rax)
mov    $0x1,%r14d
mov    $0xfffffffffffffff8,%r11
nopl   (%rax)
movsd  -0x8(%r9,%r11,1),%xmm2
movsd  (%r9,%r11,1),%xmm3
addsd  (%r9,%r14,8),%xmm3
mulsd  (%r15,%r14,8),%xmm3
addsd  0x8(%r9,%r14,8),%xmm2
addsd  %xmm1,%xmm3
mulsd  0x8(%r15,%r14,8),%xmm2
addsd  %xmm3,%xmm2
add    $0xfffffffffffffff0,%r11
lea    (%rdx,%r14,1),%rcx
add    $0x2,%rcx
add    $0x2,%r14
movapd %xmm2,%xmm1
cmp    $0x1,%rcx
jne    1ab0 <gaussian+0x960>
movapd %xmm2,%xmm1
testb  $0x1,-0xa8(%rbp)
je     1a50 <gaussian+0x900>
mov    %rax,%rcx
sub    %r14,%rcx
movsd  (%r12,%rcx,8),%xmm1
lea    (%r14,%rax,1),%rcx
addsd  (%r12,%rcx,8),%xmm1
mulsd  (%r15,%r14,8),%xmm1
addsd  %xmm2,%xmm1
jmp    1a50 <gaussian+0x900>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
mov    %r12,%rdi
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>
mov    $0x1,%esi
test   $0x1,%dl
jne    1361 <gaussian+0x211>
jmp    1371 <gaussian+0x221>
mov    0x2478(%rip),%rax
mov    (%rax),%edi
lea    0x4a7(%rip),%rsi
call   1060 <fprintf@plt>
xor    %eax,%eax
call   1040 <abort@plt>

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

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