#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 MAX(int, int);
int MIN(int, int);
scalar_t__ ceilf(int);
float exp(float);
int /*<<< orphan*/ free(char *);
float *malloc(int);
int /*<<< orphan*/ memcpy(float *, float *, int);
void dsmooth(float *image, int nx, int ny, float sigma, float *smooth) {
  int i, j, npix, half, start, end, sample;
  float neghalfinvvar, total, scale, dx, sum;
  float *kernel1D;
  float *kernel_shifted;
  float *smooth_temp;
  npix = 2 * ((int)ceilf(3. * sigma)) + 1;
  half = npix / 2;
  kernel1D = malloc(npix * sizeof(float));
  neghalfinvvar = -1.0 / (2.0 * sigma * sigma);
  for (i = 0; i < npix; i++) {
    dx = ((float)i - 0.5 * ((float)npix - 1.));
    kernel1D[i] = exp((dx * dx) * neghalfinvvar);
  }
  total = 0.0;
  for (i = 0; i < npix; i++)
    total += kernel1D[i];
  scale = 1. / total;
  for (i = 0; i < npix; i++)
    kernel1D[i] *= scale;
  smooth_temp = malloc(sizeof(float) * MAX(nx, ny));
  kernel_shifted = kernel1D + half;
  for (j = 0; j < ny; j++) {
    float *imagerow = image + j * nx;
    for (i = 0; i < nx; i++) {
      start = i - half;
      start = MAX(start, 0);
      end = i + half;
      end = MIN(end, nx - 1);
      sum = 0.0;
      for (sample = start; sample <= end; sample++)
        sum += imagerow[sample] * kernel_shifted[sample - i];
      smooth_temp[i] = sum;
    }
    memcpy(smooth + j * nx, smooth_temp, nx * sizeof(float));
  }
  for (i = 0; i < nx; i++) {
    float *imagecol = smooth + i;
    for (j = 0; j < ny; j++) {
      start = j - half;
      start = MAX(start, 0);
      end = j + half;
      end = MIN(end, ny - 1);
      sum = 0.0;
      for (sample = start; sample <= end; sample++)
        sum += imagecol[sample * nx] * kernel_shifted[sample - j];
      smooth_temp[j] = sum;
    }
    for (j = 0; j < ny; j++)
      smooth[i + j * nx] = smooth_temp[j];
  }
  {
    if ((smooth_temp) != NULL)
      free((char *)(smooth_temp));
    (smooth_temp) = NULL;
  };
  {
    if ((kernel1D) != NULL)
      free((char *)(kernel1D));
    (kernel1D) = NULL;
  };
}


x86 assembly (clang, -O0):
<dsmooth>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
movss  %xmm0,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
movss  -0x14(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xe71(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   1090 <ceilf@plt>
shl    $0x1,%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x30(%rbp)
movslq -0x2c(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0x58(%rbp)
movss  -0x14(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xe21(%rip),%xmm1
mulsd  %xmm0,%xmm1
movss  -0x14(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  %xmm0,%xmm1
movsd  0xe00(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x40(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1286 <dsmooth+0x116>
cvtsi2ssl -0x24(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
cvtsi2ssl -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xdde(%rip),%xmm2
subsd  %xmm2,%xmm0
movsd  0xdda(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x4c(%rbp),%xmm0
mulss  -0x4c(%rbp),%xmm0
mulss  -0x40(%rbp),%xmm0
call   1080 <exp@plt>
mov    -0x58(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1214 <dsmooth+0xa4>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x44(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    12c6 <dsmooth+0x156>
mov    -0x58(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1295 <dsmooth+0x125>
movss  -0x44(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xd41(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x48(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    131c <dsmooth+0x1ac>
movss  -0x48(%rbp),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x24(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    12eb <dsmooth+0x17b>
mov    -0xc(%rbp),%edi
mov    -0x10(%rbp),%esi
call   1050 <MAX@plt>
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0x68(%rbp)
mov    -0x58(%rbp),%rax
movslq -0x30(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1468 <dsmooth+0x2f8>
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0xc(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1433 <dsmooth+0x2c3>
mov    -0x24(%rbp),%eax
sub    -0x30(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%edi
xor    %esi,%esi
call   1050 <MAX@plt>
mov    %eax,-0x34(%rbp)
mov    -0x24(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%edi
mov    -0xc(%rbp),%esi
sub    $0x1,%esi
call   1040 <MIN@plt>
mov    %eax,-0x38(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x38(%rbp),%eax
jg     1413 <dsmooth+0x2a3>
mov    -0x70(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x60(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    13c8 <dsmooth+0x258>
movss  -0x50(%rbp),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    137e <dsmooth+0x20e>
mov    -0x20(%rbp),%rdi
mov    -0x28(%rbp),%eax
imul   -0xc(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x68(%rbp),%rsi
movslq -0xc(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edx
call   1060 <memcpy@plt>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1352 <dsmooth+0x1e2>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    15a9 <dsmooth+0x439>
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x78(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1550 <dsmooth+0x3e0>
mov    -0x28(%rbp),%eax
sub    -0x30(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%edi
xor    %esi,%esi
call   1050 <MAX@plt>
mov    %eax,-0x34(%rbp)
mov    -0x28(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%edi
mov    -0x10(%rbp),%esi
sub    $0x1,%esi
call   1040 <MIN@plt>
mov    %eax,-0x38(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x38(%rbp),%eax
jg     1530 <dsmooth+0x3c0>
mov    -0x78(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x60(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    14df <dsmooth+0x36f>
movss  -0x50(%rbp),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1495 <dsmooth+0x325>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1596 <dsmooth+0x426>
mov    -0x68(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    -0x28(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1557 <dsmooth+0x3e7>
jmp    159b <dsmooth+0x42b>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    146f <dsmooth+0x2ff>
cmpq   $0x0,-0x68(%rbp)
je     15bd <dsmooth+0x44d>
mov    -0x68(%rbp),%rdi
call   1030 <free@plt>
movq   $0x0,-0x68(%rbp)
cmpq   $0x0,-0x58(%rbp)
je     15d9 <dsmooth+0x469>
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
movq   $0x0,-0x58(%rbp)
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<dsmooth>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x88,%rsp
mov    %rcx,0x28(%rsp)
mov    %rdx,0x40(%rsp)
mov    %rsi,0x10(%rsp)
mov    %rdi,%rbx
cvtss2sd %xmm0,%xmm1
movsd  0xe61(%rip),%xmm0
movsd  %xmm1,0x8(%rsp)
mulsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   1090 <ceilf@plt>
mov    %rax,%r14
add    %eax,%eax
lea    (%r14,%r14,1),%ebp
add    $0x1,%ebp
mov    %ebp,%ecx
shr    $0x1f,%ecx
lea    (%rcx,%r14,2),%r12d
add    $0x1,%r12d
sar    %r12d
lea    0x4(,%rax,4),%edi
call   1070 <malloc@plt>
mov    %ebp,%ecx
mov    %rax,%rbp
test   %ecx,%ecx
jle    13e9 <dsmooth+0x279>
movsd  0x8(%rsp),%xmm1
movapd %xmm1,%xmm0
addsd  %xmm1,%xmm0
mulsd  %xmm1,%xmm0
movsd  0xe07(%rip),%xmm1
divsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
movss  %xmm0,0x8(%rsp)
xorps  %xmm0,%xmm0
cvtsi2ss %ecx,%xmm0
cvtss2sd %xmm0,%xmm0
addsd  0xde3(%rip),%xmm0
mov    %ecx,0x4(%rsp)
mov    %ecx,%r13d
mov    %rbp,%r15
xor    %ebp,%ebp
mulsd  0xdd7(%rip),%xmm0
movsd  %xmm0,0x20(%rsp)
nop
xorps  %xmm0,%xmm0
cvtsi2ss %ebp,%xmm0
cvtss2sd %xmm0,%xmm0
addsd  0x20(%rsp),%xmm0
cvtsd2ss %xmm0,%xmm0
mulss  %xmm0,%xmm0
mulss  0x8(%rsp),%xmm0
call   1080 <exp@plt>
movss  %xmm0,(%r15,%rbp,4)
add    $0x1,%rbp
cmp    %rbp,%r13
jne    1240 <dsmooth+0xd0>
mov    0x4(%rsp),%esi
test   %esi,%esi
mov    %r15,%rbp
jle    13e9 <dsmooth+0x279>
lea    -0x1(%r13),%rax
cmp    $0x7,%rax
jae    1293 <dsmooth+0x123>
xorps  %xmm1,%xmm1
xor    %eax,%eax
jmp    12d9 <dsmooth+0x169>
mov    %r13d,%ecx
and    $0xfffffff8,%ecx
xorps  %xmm1,%xmm1
xor    %eax,%eax
xchg   %ax,%ax
addss  0x0(%rbp,%rax,4),%xmm1
addss  0x4(%rbp,%rax,4),%xmm1
addss  0x8(%rbp,%rax,4),%xmm1
addss  0xc(%rbp,%rax,4),%xmm1
addss  0x10(%rbp,%rax,4),%xmm1
addss  0x14(%rbp,%rax,4),%xmm1
addss  0x18(%rbp,%rax,4),%xmm1
addss  0x1c(%rbp,%rax,4),%xmm1
add    $0x8,%rax
cmp    %rax,%rcx
jne    12a0 <dsmooth+0x130>
lea    0x0(,%rax,4),%rax
add    %rbp,%rax
and    $0x3,%r14d
lea    0x4(,%r14,8),%rcx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
addss  (%rax,%rdx,1),%xmm1
add    $0x4,%rdx
cmp    %rdx,%rcx
jne    1300 <dsmooth+0x190>
test   %esi,%esi
jle    13e9 <dsmooth+0x279>
movss  0xcfa(%rip),%xmm0
divss  %xmm1,%xmm0
cmp    $0x8,%esi
jae    132e <dsmooth+0x1be>
xor    %eax,%eax
jmp    13d0 <dsmooth+0x260>
mov    %r13d,%eax
and    $0xfffffff8,%eax
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
lea    -0x8(%rax),%rdx
mov    %rdx,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
test   %rdx,%rdx
je     13a5 <dsmooth+0x235>
mov    %rcx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movups 0x0(%rbp,%rdx,4),%xmm2
movups 0x10(%rbp,%rdx,4),%xmm3
movups 0x20(%rbp,%rdx,4),%xmm4
movups 0x30(%rbp,%rdx,4),%xmm5
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,0x0(%rbp,%rdx,4)
movups %xmm3,0x10(%rbp,%rdx,4)
mulps  %xmm1,%xmm4
mulps  %xmm1,%xmm5
movups %xmm4,0x20(%rbp,%rdx,4)
movups %xmm5,0x30(%rbp,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rsi
jne    1360 <dsmooth+0x1f0>
test   $0x1,%cl
je     13d0 <dsmooth+0x260>
jmp    13ac <dsmooth+0x23c>
xor    %edx,%edx
test   $0x1,%cl
je     13d0 <dsmooth+0x260>
movups 0x0(%rbp,%rdx,4),%xmm2
movups 0x10(%rbp,%rdx,4),%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,0x0(%rbp,%rdx,4)
movups %xmm3,0x10(%rbp,%rdx,4)
cs nopw 0x0(%rax,%rax,1)
movss  0x0(%rbp,%rax,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0x0(%rbp,%rax,4)
add    $0x1,%rax
cmp    %rax,%r13
jne    13d0 <dsmooth+0x260>
mov    0x10(%rsp),%r15
mov    %r15d,%edi
mov    0x40(%rsp),%r14
mov    %r14d,%esi
call   1050 <MAX@plt>
lea    0x0(,%rax,4),%edi
call   1070 <malloc@plt>
mov    %rbp,%rcx
mov    %rax,%rbp
movslq %r12d,%rax
mov    %rcx,0x60(%rsp)
mov    %rax,0x38(%rsp)
lea    (%rcx,%rax,4),%rax
mov    %rax,0x68(%rsp)
mov    %r14d,%eax
mov    %rax,0x20(%rsp)
mov    %r15d,%eax
mov    %rax,0x8(%rsp)
test   %r14d,%r14d
jle    15a0 <dsmooth+0x430>
mov    0x10(%rsp),%rax
lea    -0x1(%rax),%ecx
mov    %ecx,0x4(%rsp)
lea    0x0(,%rax,4),%ecx
mov    %ecx,0x58(%rsp)
cltq
mov    %rax,0x50(%rsp)
lea    0x0(,%rax,4),%rax
mov    %rax,0x48(%rsp)
xor    %eax,%eax
jmp    14a3 <dsmooth+0x333>
xchg   %ax,%ax
mov    0x28(%rsp),%rax
mov    0x30(%rsp),%rcx
lea    (%rax,%rcx,4),%rdi
mov    %rbp,%rsi
mov    0x58(%rsp),%edx
call   1060 <memcpy@plt>
mov    0x18(%rsp),%rax
add    $0x1,%rax
add    0x48(%rsp),%rbx
cmp    0x20(%rsp),%rax
je     15a0 <dsmooth+0x430>
mov    %rax,0x18(%rsp)
imul   0x50(%rsp),%rax
mov    %rax,0x30(%rsp)
cmpl   $0x0,0x10(%rsp)
jle    1470 <dsmooth+0x300>
mov    0x68(%rsp),%r13
xor    %r14d,%r14d
jmp    14e4 <dsmooth+0x374>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  %xmm0,0x0(%rbp,%r14,4)
add    $0x1,%r14
add    $0xfffffffffffffffc,%r13
cmp    %rdi,%r14
je     1470 <dsmooth+0x300>
mov    %r14d,%edi
sub    %r12d,%edi
xor    %esi,%esi
call   1050 <MAX@plt>
mov    %eax,%r15d
lea    (%r12,%r14,1),%edi
mov    0x4(%rsp),%esi
call   1040 <MIN@plt>
xorpd  %xmm0,%xmm0
mov    %eax,%edx
sub    %r15d,%edx
mov    0x8(%rsp),%rdi
jl     14d0 <dsmooth+0x360>
movslq %r15d,%rcx
add    $0x1,%eax
mov    %eax,%esi
sub    %r15d,%esi
xorpd  %xmm0,%xmm0
and    $0x3,%esi
je     1549 <dsmooth+0x3d9>
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%rbx,%rcx,4),%xmm1
mulss  0x0(%r13,%rcx,4),%xmm1
addss  %xmm1,%xmm0
add    $0x1,%rcx
add    $0xffffffff,%esi
jne    1530 <dsmooth+0x3c0>
cmp    $0x3,%edx
jb     14d0 <dsmooth+0x360>
mov    %eax,%eax
movss  (%rbx,%rcx,4),%xmm1
movss  0x4(%rbx,%rcx,4),%xmm2
mulss  0x0(%r13,%rcx,4),%xmm1
mulss  0x4(%r13,%rcx,4),%xmm2
addss  %xmm0,%xmm1
movss  0x8(%rbx,%rcx,4),%xmm3
mulss  0x8(%r13,%rcx,4),%xmm3
addss  %xmm1,%xmm2
movss  0xc(%rbx,%rcx,4),%xmm0
mulss  0xc(%r13,%rcx,4),%xmm0
addss  %xmm2,%xmm3
addss  %xmm3,%xmm0
add    $0x4,%rcx
cmp    %ecx,%eax
jne    1550 <dsmooth+0x3e0>
jmp    14d0 <dsmooth+0x360>
cmpl   $0x0,0x10(%rsp)
mov    0x40(%rsp),%r8
mov    0x8(%rsp),%rdi
jle    183a <dsmooth+0x6ca>
lea    -0x1(%r8),%eax
mov    %eax,0x4(%rsp)
mov    0x20(%rsp),%rax
lea    -0x1(%rax),%rcx
mov    %rcx,0x78(%rsp)
mov    %eax,%r11d
and    $0x3,%r11d
and    $0xfffffffc,%eax
mov    %rax,0x70(%rsp)
lea    0x0(,%rdi,4),%rsi
lea    0x0(,%rdi,8),%r15
mov    0x60(%rsp),%rax
mov    0x38(%rsp),%rcx
lea    (%rax,%rcx,4),%rax
add    $0x4,%rax
mov    %rax,0x48(%rsp)
mov    %rdi,%r9
shl    $0x4,%r9
lea    (%rsi,%rsi,2),%r10
xor    %ebx,%ebx
mov    0x28(%rsp),%rax
mov    %rax,0x18(%rsp)
mov    %r11,0x50(%rsp)
mov    %rsi,0x30(%rsp)
mov    %r9,0x38(%rsp)
mov    %r10,0x80(%rsp)
jmp    1653 <dsmooth+0x4e3>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%rbx
addq   $0x4,0x18(%rsp)
cmp    %rdi,%rbx
je     183a <dsmooth+0x6ca>
test   %r8d,%r8d
jle    1640 <dsmooth+0x4d0>
mov    0x28(%rsp),%rax
mov    %rbx,0x58(%rsp)
lea    (%rax,%rbx,4),%rax
mov    %rax,0x10(%rsp)
mov    0x48(%rsp),%r13
xor    %r14d,%r14d
jmp    169a <dsmooth+0x52a>
cs nopw 0x0(%rax,%rax,1)
nop
movss  %xmm0,0x0(%rbp,%r14,4)
add    $0x1,%r14
add    $0xfffffffffffffffc,%r13
cmp    0x20(%rsp),%r14
je     1760 <dsmooth+0x5f0>
mov    %r14d,%edi
sub    %r12d,%edi
xor    %esi,%esi
call   1050 <MAX@plt>
mov    %eax,%ebx
lea    (%r12,%r14,1),%edi
mov    0x4(%rsp),%esi
call   1040 <MIN@plt>
xorpd  %xmm0,%xmm0
cmp    %ebx,%eax
jl     1680 <dsmooth+0x510>
movslq %ebx,%rcx
lea    0x1(%rax),%edx
mov    %edx,%esi
sub    %ebx,%esi
xorpd  %xmm0,%xmm0
test   $0x1,%sil
je     1701 <dsmooth+0x591>
mov    %rcx,%rsi
imul   0x8(%rsp),%rsi
mov    0x10(%rsp),%rdi
movss  (%rdi,%rsi,4),%xmm0
mov    %rcx,%rsi
sub    %r14,%rsi
mov    0x68(%rsp),%rdi
mulss  (%rdi,%rsi,4),%xmm0
addss  0x91f(%rip),%xmm0
add    $0x1,%rcx
cmp    %ebx,%eax
je     1680 <dsmooth+0x510>
mov    %edx,%eax
lea    0x1(%rcx),%rdx
mov    0x30(%rsp),%rsi
imul   %rsi,%rdx
imul   %rcx,%rsi
mov    0x18(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%rdi,%rsi,1),%xmm1
mulss  -0x4(%r13,%rcx,4),%xmm1
addss  %xmm0,%xmm1
movss  (%rdi,%rdx,1),%xmm0
mulss  0x0(%r13,%rcx,4),%xmm0
addss  %xmm1,%xmm0
add    $0x2,%rcx
add    %r15,%rdi
cmp    %ecx,%eax
jne    1730 <dsmooth+0x5c0>
jmp    1680 <dsmooth+0x510>
mov    0x40(%rsp),%r8
test   %r8d,%r8d
mov    0x8(%rsp),%rdi
mov    0x50(%rsp),%r11
mov    0x30(%rsp),%rsi
mov    0x38(%rsp),%r9
mov    0x80(%rsp),%r10
mov    0x58(%rsp),%rbx
jle    1640 <dsmooth+0x4d0>
cmpq   $0x3,0x78(%rsp)
jae    179b <dsmooth+0x62b>
xor    %eax,%eax
jmp    17e8 <dsmooth+0x678>
mov    0x18(%rsp),%rcx
xor    %eax,%eax
mov    0x70(%rsp),%rdx
nopw   0x0(%rax,%rax,1)
movss  0x0(%rbp,%rax,4),%xmm0
movss  %xmm0,(%rcx)
movss  0x4(%rbp,%rax,4),%xmm0
movss  %xmm0,(%rcx,%rdi,4)
movss  0x8(%rbp,%rax,4),%xmm0
movss  %xmm0,(%rcx,%rdi,8)
movss  0xc(%rbp,%rax,4),%xmm0
movss  %xmm0,(%rcx,%r10,1)
add    $0x4,%rax
add    %r9,%rcx
cmp    %rax,%rdx
jne    17b0 <dsmooth+0x640>
test   %r11,%r11
je     1640 <dsmooth+0x4d0>
mov    %rdi,%rcx
imul   %rax,%rcx
add    %rbx,%rcx
mov    0x28(%rsp),%rdx
lea    (%rdx,%rcx,4),%rcx
lea    0x0(,%rax,4),%rax
add    %rbp,%rax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%rax,%rdx,4),%xmm0
movss  %xmm0,(%rcx)
add    $0x1,%rdx
add    %rsi,%rcx
cmp    %rdx,%r11
jne    1820 <dsmooth+0x6b0>
jmp    1640 <dsmooth+0x4d0>
test   %rbp,%rbp
je     1847 <dsmooth+0x6d7>
mov    %rbp,%rdi
call   1030 <free@plt>
mov    0x60(%rsp),%rdi
add    $0x88,%rsp
test   %rdi,%rdi
je     1867 <dsmooth+0x6f7>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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