#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*/ free(float *);
float *malloc(int const);
void GaussianBlur(float *image, const int xRes, const int yRes) {
  float *imageCopy;
  imageCopy = malloc(xRes * yRes * sizeof *imageCopy * 3);
  for (int j = 0; j < yRes; j++) {
    for (int i = 0; i < xRes; i++) {
      imageCopy[j * xRes * 3 + i * 3 + 0] = image[j * xRes * 3 + i * 3 + 0];
      imageCopy[j * xRes * 3 + i * 3 + 1] = image[j * xRes * 3 + i * 3 + 1];
      imageCopy[j * xRes * 3 + i * 3 + 2] = image[j * xRes * 3 + i * 3 + 2];
    }
  }
  for (int j = 0; j < yRes; j++) {
    for (int i = 0; i < xRes; i++) {
      const int ju = (j == yRes - 1) ? j : j + 1;
      const int jd = (j == 0) ? j : j - 1;
      const int il = (i == 0) ? i : i - 1;
      const int ir = (i == xRes - 1) ? i : i + 1;
      image[j * xRes * 3 + i * 3 + 0] =
          (+1.0 * imageCopy[ju * xRes * 3 + i * 3 + 0] +
           1.0 * imageCopy[j * xRes * 3 + ir * 3 + 0] +
           4.0 * imageCopy[j * xRes * 3 + i * 3 + 0] +
           1.0 * imageCopy[j * xRes * 3 + il * 3 + 0] +
           1.0 * imageCopy[jd * xRes * 3 + i * 3 + 0]) /
          8.0;
      image[j * xRes * 3 + i * 3 + 1] =
          (+1.0 * imageCopy[ju * xRes * 3 + i * 3 + 1] +
           1.0 * imageCopy[j * xRes * 3 + ir * 3 + 1] +
           4.0 * imageCopy[j * xRes * 3 + i * 3 + 1] +
           1.0 * imageCopy[j * xRes * 3 + il * 3 + 1] +
           1.0 * imageCopy[jd * xRes * 3 + i * 3 + 1]) /
          8.0;
      image[j * xRes * 3 + i * 3 + 2] =
          (+1.0 * imageCopy[ju * xRes * 3 + i * 3 + 2] +
           1.0 * imageCopy[j * xRes * 3 + ir * 3 + 2] +
           4.0 * imageCopy[j * xRes * 3 + i * 3 + 2] +
           1.0 * imageCopy[j * xRes * 3 + il * 3 + 2] +
           1.0 * imageCopy[jd * xRes * 3 + i * 3 + 2]) /
          8.0;
    }
  }
  free(imageCopy);
}


x86 assembly (clang, -O0):
<GaussianBlur>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    -0xc(%rbp),%eax
imul   -0x10(%rbp),%eax
cltq
shl    $0x2,%rax
imul   $0x3,%rax,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    124f <GaussianBlur+0x12f>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    123c <GaussianBlur+0x11c>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
imul   $0x3,%ecx,%ecx
imul   $0x3,-0x20(%rbp),%edx
add    %edx,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
imul   $0x3,%ecx,%ecx
imul   $0x3,-0x20(%rbp),%edx
add    %edx,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
imul   $0x3,%ecx,%ecx
imul   $0x3,-0x20(%rbp),%edx
add    %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
imul   $0x3,%ecx,%ecx
imul   $0x3,-0x20(%rbp),%edx
add    %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
imul   $0x3,%ecx,%ecx
imul   $0x3,-0x20(%rbp),%edx
add    %edx,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
imul   $0x3,%ecx,%ecx
imul   $0x3,-0x20(%rbp),%edx
add    %edx,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1168 <GaussianBlur+0x48>
jmp    1241 <GaussianBlur+0x121>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1155 <GaussianBlur+0x35>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1646 <GaussianBlur+0x526>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1633 <GaussianBlur+0x513>
mov    -0x24(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    1291 <GaussianBlur+0x171>
mov    -0x24(%rbp),%eax
mov    %eax,-0x3c(%rbp)
jmp    129a <GaussianBlur+0x17a>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
cmpl   $0x0,-0x24(%rbp)
jne    12b5 <GaussianBlur+0x195>
mov    -0x24(%rbp),%eax
mov    %eax,-0x40(%rbp)
jmp    12be <GaussianBlur+0x19e>
mov    -0x24(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x28(%rbp)
jne    12d9 <GaussianBlur+0x1b9>
mov    -0x28(%rbp),%eax
mov    %eax,-0x44(%rbp)
jmp    12e2 <GaussianBlur+0x1c2>
mov    -0x28(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x28(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    1304 <GaussianBlur+0x1e4>
mov    -0x28(%rbp),%eax
mov    %eax,-0x48(%rbp)
jmp    130d <GaussianBlur+0x1ed>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
imul   $0x3,%ecx,%ecx
imul   $0x3,-0x28(%rbp),%edx
add    %edx,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
imul   $0x3,%ecx,%ecx
imul   $0x3,-0x38(%rbp),%edx
add    %edx,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm2
movsd  0xcaf(%rip),%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
imul   $0x3,%ecx,%ecx
imul   $0x3,-0x28(%rbp),%edx
add    %edx,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xc74(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
imul   $0x3,%ecx,%ecx
imul   $0x3,-0x34(%rbp),%edx
add    %edx,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0xc(%rbp),%ecx
imul   $0x3,%ecx,%ecx
imul   $0x3,-0x28(%rbp),%edx
add    %edx,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm1,%xmm0
movsd  0xc0e(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
imul   $0x3,%ecx,%ecx
imul   $0x3,-0x28(%rbp),%edx
add    %edx,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
imul   $0x3,%ecx,%ecx
imul   $0x3,-0x28(%rbp),%edx
add    %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
imul   $0x3,%ecx,%ecx
imul   $0x3,-0x38(%rbp),%edx
add    %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm2
movsd  0xba9(%rip),%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
imul   $0x3,%ecx,%ecx
imul   $0x3,-0x28(%rbp),%edx
add    %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xb6e(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
imul   $0x3,%ecx,%ecx
imul   $0x3,-0x34(%rbp),%edx
add    %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0xc(%rbp),%ecx
imul   $0x3,%ecx,%ecx
imul   $0x3,-0x28(%rbp),%edx
add    %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm1,%xmm0
movsd  0xb08(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
imul   $0x3,%ecx,%ecx
imul   $0x3,-0x28(%rbp),%edx
add    %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
imul   $0x3,%ecx,%ecx
imul   $0x3,-0x28(%rbp),%edx
add    %edx,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
imul   $0x3,%ecx,%ecx
imul   $0x3,-0x38(%rbp),%edx
add    %edx,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm2
movsd  0xaa3(%rip),%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
imul   $0x3,%ecx,%ecx
imul   $0x3,-0x28(%rbp),%edx
add    %edx,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xa68(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
imul   $0x3,%ecx,%ecx
imul   $0x3,-0x34(%rbp),%edx
add    %edx,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0xc(%rbp),%ecx
imul   $0x3,%ecx,%ecx
imul   $0x3,-0x28(%rbp),%edx
add    %edx,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm1,%xmm0
movsd  0xa02(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
imul   $0x3,%ecx,%ecx
imul   $0x3,-0x28(%rbp),%edx
add    %edx,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1269 <GaussianBlur+0x149>
jmp    1638 <GaussianBlur+0x518>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1256 <GaussianBlur+0x136>
mov    -0x18(%rbp),%rdi
call   1030 <free@plt>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<GaussianBlur>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %edx,%r15d
mov    %esi,%r14d
mov    %rdi,0x10(%rsp)
mov    %esi,%eax
imul   %edx,%eax
shl    $0x2,%eax
lea    (%rax,%rax,2),%edi
call   1040 <malloc@plt>
test   %r15d,%r15d
jle    1416 <GaussianBlur+0x2f6>
mov    %r14d,%r8d
lea    (%r14,%r14,2),%r9d
xor    %esi,%esi
xor    %edi,%edi
mov    0x10(%rsp),%rbx
jmp    117b <GaussianBlur+0x5b>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%edi
add    %r9d,%esi
cmp    %r15d,%edi
je     11c8 <GaussianBlur+0xa8>
mov    %r8,%rdx
mov    %esi,%ebp
test   %r14d,%r14d
jle    1170 <GaussianBlur+0x50>
cs nopw 0x0(%rax,%rax,1)
nop
movslq %ebp,%rbp
movss  (%rbx,%rbp,4),%xmm0
movss  %xmm0,(%rax,%rbp,4)
lea    0x1(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rbx,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
lea    0x2(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rbx,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
add    $0x3,%ebp
add    $0xffffffffffffffff,%rdx
jne    1190 <GaussianBlur+0x70>
jmp    1170 <GaussianBlur+0x50>
test   %r15d,%r15d
jle    1416 <GaussianBlur+0x2f6>
lea    -0x1(%r15),%ecx
mov    %rcx,0x30(%rsp)
lea    -0x1(%r14),%ecx
lea    (%r14,%r14,2),%edx
mov    %edx,0xc(%rsp)
mov    %r15d,%edx
mov    %rdx,0x38(%rsp)
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,0x28(%rsp)
addq   $0x8,0x10(%rsp)
lea    (%rcx,%rcx,2),%rbx
lea    (%r8,%r8,2),%rbp
xor    %edx,%edx
movsd  0xdee(%rip),%xmm0
movsd  0xdee(%rip),%xmm1
movl   $0x0,0x8(%rsp)
xor    %ecx,%ecx
mov    %rcx,0x18(%rsp)
mov    %r14,0x40(%rsp)
jmp    125d <GaussianBlur+0x13d>
mov    0x18(%rsp),%rsi
add    $0x1,%rsi
mov    0x8(%rsp),%ecx
add    0xc(%rsp),%ecx
mov    %ecx,0x8(%rsp)
mov    %rsi,%rcx
mov    %rsi,0x18(%rsp)
cmp    0x38(%rsp),%rsi
mov    0x40(%rsp),%r14
je     1416 <GaussianBlur+0x2f6>
test   %r14d,%r14d
jle    1230 <GaussianBlur+0x110>
movslq 0x8(%rsp),%rcx
mov    0x28(%rsp),%r10
lea    (%r10,%rcx,4),%r12
mov    0x10(%rsp),%rsi
lea    (%rsi,%rcx,4),%r13
xor    %r14d,%r14d
mov    0x18(%rsp),%r11
cmp    0x30(%rsp),%r11
setne  %r14b
lea    -0x1(%r11),%esi
test   %r11,%r11
cmove  %edx,%esi
mov    0xc(%rsp),%r9d
mov    %r9d,%ecx
imul   %r11d,%ecx
mov    %ecx,0x24(%rsp)
imul   %r9d,%esi
movslq %esi,%rsi
lea    (%r10,%rsi,4),%r8
add    %r11d,%r14d
imul   %r9d,%r14d
movslq %r14d,%rcx
lea    (%r10,%rcx,4),%r9
xor    %r10d,%r10d
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    0x1(%rcx),%r14
cmp    %r10,%rbx
cmovne %r14d,%ecx
lea    (%rcx,%rcx,2),%ecx
mov    0x24(%rsp),%edi
add    %edi,%ecx
lea    -0x3(%r10),%esi
test   %r10,%r10
movss  -0x8(%r9,%r10,4),%xmm2
cvtss2sd %xmm2,%xmm2
movslq %ecx,%r11
movss  (%rax,%r11,4),%xmm3
cvtss2sd %xmm3,%xmm3
addsd  %xmm2,%xmm3
movss  -0x8(%r12,%r10,4),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm0,%xmm2
cmove  %edx,%esi
addsd  %xmm3,%xmm2
add    %edi,%esi
movslq %esi,%r15
movss  (%rax,%r15,4),%xmm3
cvtss2sd %xmm3,%xmm3
addsd  %xmm2,%xmm3
movss  -0x8(%r8,%r10,4),%xmm2
cvtss2sd %xmm2,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm1,%xmm2
cvtsd2ss %xmm2,%xmm2
movss  %xmm2,-0x8(%r13,%r10,4)
movss  -0x4(%r9,%r10,4),%xmm2
cvtss2sd %xmm2,%xmm2
movss  0x4(%rax,%r11,4),%xmm3
cvtss2sd %xmm3,%xmm3
addsd  %xmm2,%xmm3
movss  -0x4(%r12,%r10,4),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm3,%xmm2
movss  0x4(%rax,%r15,4),%xmm3
cvtss2sd %xmm3,%xmm3
addsd  %xmm2,%xmm3
movss  -0x4(%r8,%r10,4),%xmm2
cvtss2sd %xmm2,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm1,%xmm2
cvtsd2ss %xmm2,%xmm2
movss  %xmm2,-0x4(%r13,%r10,4)
movss  (%r9,%r10,4),%xmm2
cvtss2sd %xmm2,%xmm2
movss  0x8(%rax,%r11,4),%xmm3
cvtss2sd %xmm3,%xmm3
addsd  %xmm2,%xmm3
movss  (%r12,%r10,4),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm3,%xmm2
movss  0x8(%rax,%r15,4),%xmm3
xor    %edx,%edx
cvtss2sd %xmm3,%xmm3
addsd  %xmm2,%xmm3
movss  (%r8,%r10,4),%xmm2
cvtss2sd %xmm2,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm1,%xmm2
cvtsd2ss %xmm2,%xmm2
movss  %xmm2,0x0(%r13,%r10,4)
add    $0x3,%r10
mov    %r14,%rcx
cmp    %r10,%rbp
jne    12d0 <GaussianBlur+0x1b0>
jmp    1230 <GaussianBlur+0x110>
mov    %rax,%rdi
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

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

LLVM IR (-O2):
define void @GaussianBlur(float* nocapture %0, i32 %1, i32 %2) {
%4 = mul i32 %1, 12
%5 = mul i32 %4, %2
%6 = tail call float* @malloc(i32 %5)
%7 = icmp sgt i32 %2, 0
br i1 %7, label %8, label %66
8: ; preds = %3
%9 = icmp sgt i32 %1, 0
%10 = zext i32 %1 to i64
br label %11
11: ; preds = %8, %25
%12 = phi i32 [ 0, %8 ], [ %26, %25 ]
br i1 %9, label %13, label %25
13: ; preds = %11
%14 = mul nsw i32 %12, %1
br label %28
15: ; preds = %25
br i1 %7, label %16, label %66
16: ; preds = %15
%17 = icmp sgt i32 %1, 0
%18 = add nsw i32 %2, -1
%19 = add nsw i32 %1, -1
%20 = mul i32 %1, 3
%21 = zext i32 %19 to i64
%22 = zext i32 %18 to i64
%23 = zext i32 %2 to i64
%24 = zext i32 %1 to i64
br label %49
25: ; preds = %28, %11
%26 = add nuw nsw i32 %12, 1
%27 = icmp eq i32 %26, %2
br i1 %27, label %15, label %11
28: ; preds = %13, %28
%29 = phi i64 [ 0, %13 ], [ %47, %28 ]
%30 = trunc i64 %29 to i32
%31 = add i32 %14, %30
%32 = mul i32 %31, 3
%33 = sext i32 %32 to i64
%34 = getelementptr inbounds float, float* %0, i64 %33
%35 = load float, float* %34
%36 = getelementptr inbounds float, float* %6, i64 %33
store float %35, float* %36
%37 = add nsw i32 %32, 1
%38 = sext i32 %37 to i64
%39 = getelementptr inbounds float, float* %0, i64 %38
%40 = load float, float* %39
%41 = getelementptr inbounds float, float* %6, i64 %38
store float %40, float* %41
%42 = add nsw i32 %32, 2
%43 = sext i32 %42 to i64
%44 = getelementptr inbounds float, float* %0, i64 %43
%45 = load float, float* %44
%46 = getelementptr inbounds float, float* %6, i64 %43
store float %45, float* %46
%47 = add nuw nsw i64 %29, 1
%48 = icmp eq i64 %47, %10
br i1 %48, label %25, label %28
49: ; preds = %16, %68
%50 = phi i64 [ 0, %16 ], [ %69, %68 ]
br i1 %17, label %51, label %68
51: ; preds = %49
%52 = icmp ne i64 %50, %22
%53 = zext i1 %52 to i32
%54 = trunc i64 %50 to i32
%55 = add nuw nsw i32 %54, %53
%56 = icmp eq i64 %50, 0
%57 = trunc i64 %50 to i32
%58 = add i32 %57, -1
%59 = select i1 %56, i32 0, i32 %58
%60 = mul i32 %20, %55
%61 = mul i32 %20, %54
%62 = mul i32 %20, %59
%63 = sext i32 %60 to i64
%64 = sext i32 %61 to i64
%65 = sext i32 %62 to i64
br label %71
66: ; preds = %68, %3, %15
%67 = tail call i32 @free(float* %6)
ret void
68: ; preds = %71, %49
%69 = add nuw nsw i64 %50, 1
%70 = icmp eq i64 %69, %23
br i1 %70, label %66, label %49
71: ; preds = %51, %71
%72 = phi i64 [ 0, %51 ], [ %75, %71 ]
%73 = icmp eq i64 %72, 0
%74 = icmp eq i64 %72, %21
%75 = add nuw nsw i64 %72, 1
%76 = select i1 %74, i64 %72, i64 %75
%77 = trunc i64 %76 to i32
%78 = mul nuw nsw i64 %72, 3
%79 = add nsw i64 %78, %63
%80 = getelementptr inbounds float, float* %6, i64 %79
%81 = load float, float* %80
%82 = fpext float %81 to double
%83 = mul nsw i32 %77, 3
%84 = add nsw i32 %83, %61
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds float, float* %6, i64 %85
%87 = load float, float* %86
%88 = fpext float %87 to double
%89 = fadd double %82, %88
%90 = add nsw i64 %78, %64
%91 = getelementptr inbounds float, float* %6, i64 %90
%92 = load float, float* %91
%93 = fpext float %92 to double
%94 = tail call double @llvm.fmuladd.f64(double %93, double 4.000000e+00, double %89)
%95 = trunc i64 %78 to i32
%96 = add i32 %95, -3
%97 = select i1 %73, i32 0, i32 %96
%98 = add nsw i32 %97, %61
%99 = sext i32 %98 to i64
%100 = getelementptr inbounds float, float* %6, i64 %99
%101 = load float, float* %100
%102 = fpext float %101 to double
%103 = fadd double %94, %102
%104 = add nsw i64 %78, %65
%105 = getelementptr inbounds float, float* %6, i64 %104
%106 = load float, float* %105
%107 = fpext float %106 to double
%108 = fadd double %103, %107
%109 = fmul double %108, 1.250000e-01
%110 = fptrunc double %109 to float
%111 = getelementptr inbounds float, float* %0, i64 %90
store float %110, float* %111
%112 = add nsw i64 %79, 1
%113 = getelementptr inbounds float, float* %6, i64 %112
%114 = load float, float* %113
%115 = fpext float %114 to double
%116 = add nsw i32 %84, 1
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds float, float* %6, i64 %117
%119 = load float, float* %118
%120 = fpext float %119 to double
%121 = fadd double %115, %120
%122 = add nsw i64 %90, 1
%123 = getelementptr inbounds float, float* %6, i64 %122
%124 = load float, float* %123
%125 = fpext float %124 to double
%126 = tail call double @llvm.fmuladd.f64(double %125, double 4.000000e+00, double %121)
%127 = add nsw i32 %98, 1
%128 = sext i32 %127 to i64
%129 = getelementptr inbounds float, float* %6, i64 %128
%130 = load float, float* %129
%131 = fpext float %130 to double
%132 = fadd double %126, %131
%133 = add nsw i64 %104, 1
%134 = getelementptr inbounds float, float* %6, i64 %133
%135 = load float, float* %134
%136 = fpext float %135 to double
%137 = fadd double %132, %136
%138 = fmul double %137, 1.250000e-01
%139 = fptrunc double %138 to float
%140 = getelementptr inbounds float, float* %0, i64 %122
store float %139, float* %140
%141 = add nsw i64 %79, 2
%142 = getelementptr inbounds float, float* %6, i64 %141
%143 = load float, float* %142
%144 = fpext float %143 to double
%145 = add nsw i32 %84, 2
%146 = sext i32 %145 to i64
%147 = getelementptr inbounds float, float* %6, i64 %146
%148 = load float, float* %147
%149 = fpext float %148 to double
%150 = fadd double %144, %149
%151 = add nsw i64 %90, 2
%152 = getelementptr inbounds float, float* %6, i64 %151
%153 = load float, float* %152
%154 = fpext float %153 to double
%155 = tail call double @llvm.fmuladd.f64(double %154, double 4.000000e+00, double %150)
%156 = add nsw i32 %98, 2
%157 = sext i32 %156 to i64
%158 = getelementptr inbounds float, float* %6, i64 %157
%159 = load float, float* %158
%160 = fpext float %159 to double
%161 = fadd double %155, %160
%162 = add nsw i64 %104, 2
%163 = getelementptr inbounds float, float* %6, i64 %162
%164 = load float, float* %163
%165 = fpext float %164 to double
%166 = fadd double %161, %165
%167 = fmul double %166, 1.250000e-01
%168 = fptrunc double %167 to float
%169 = getelementptr inbounds float, float* %0, i64 %151
store float %168, float* %169
%170 = icmp eq i64 %75, %24
br i1 %170, label %68, label %71
}