#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
float expf(float);
void gaussianblur(float *data, int size) {
  static float norm = 0.0f, c_2 = 0.0f, c_1 = 0.0f, c0 = 0.0f, c1 = 0.0f,
               c2 = 0.0f;
  if (norm == 0.0f) {
    norm = expf(-2.0f * (1.0f) * (1.0f) * -2 * -2 / (5 * 5)) +
           expf(-2.0f * (1.0f) * (1.0f) * -1 * -1 / (5 * 5)) +
           expf(-2.0f * (1.0f) * (1.0f) * 0 * 0 / (5 * 5)) +
           expf(-2.0f * (1.0f) * (1.0f) * 1 * 1 / (5 * 5)) +
           expf(-2.0f * (1.0f) * (1.0f) * 2 * 2 / (5 * 5));
    c_2 = expf(-2.0f * (1.0f) * (1.0f) * -2 * -2 / (5 * 5)) / norm;
    c_1 = expf(-2.0f * (1.0f) * (1.0f) * -1 * -1 / (5 * 5)) / norm;
    c0 = expf(-2.0f * (1.0f) * (1.0f) * 0 * 0 / (5 * 5)) / norm;
    c1 = expf(-2.0f * (1.0f) * (1.0f) * 1 * 1 / (5 * 5)) / norm;
    c2 = expf(-2.0f * (1.0f) * (1.0f) * 2 * 2 / (5 * 5)) / norm;
  }
  float p_2, p_1, p0, p1, p2, data_2, data_3, data_4;
  if (size < 5) {
    p_2 = data[0];
    p_1 = data[1 % size];
    p0 = data[2 % size];
    p1 = data[3 % size];
    p2 = data[4 % size];
  } else {
    p_2 = data[0];
    p_1 = data[1];
    p0 = data[2];
    p1 = data[3];
    p2 = data[4];
  }
  data_2 = p0;
  data_3 = p1;
  data_4 = p2;
  int i;
  const int sizem2 = size - 2;
  const int sizem5 = size - 5;
  for (i = 0; i < size; i++) {
    const int idtoupdate = (i < sizem2) ? (i + 2) : (i - sizem2);
    const int nexti = (i < sizem5) ? (i + 5) : (i - sizem5);
    data[idtoupdate] = p_2 * c_2 + p_1 * c_1 + p0 * c0 + p1 * c1 + p2 * c2;
    p_2 = p_1;
    p_1 = p0;
    p0 = p1;
    p1 = p2;
    if (nexti < 2 || nexti >= 5)
      p2 = data[nexti];
    else {
      switch (nexti) {
      case 2:
        p2 = data_2;
        break;
      case 3:
        p2 = data_3;
        break;
      case 4:
        p2 = data_4;
        break;
      }
    }
  }
}


x86 assembly (clang, -O0):
<gaussianblur>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
movss  0x2f02(%rip),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    125a <gaussianblur+0x14a>
jp     125a <gaussianblur+0x14a>
movss  0xebc(%rip),%xmm0
call   1030 <expf@plt>
movss  %xmm0,-0x50(%rbp)
movss  0xeae(%rip),%xmm0
call   1030 <expf@plt>
movaps %xmm0,%xmm1
movss  -0x50(%rbp),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  0xe94(%rip),%xmm0
call   1030 <expf@plt>
movaps %xmm0,%xmm1
movss  -0x4c(%rbp),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  0xe72(%rip),%xmm0
call   1030 <expf@plt>
movaps %xmm0,%xmm1
movss  -0x48(%rbp),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
movss  0xe50(%rip),%xmm0
call   1030 <expf@plt>
movaps %xmm0,%xmm1
movss  -0x44(%rbp),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x2e63(%rip)
movss  0xe2f(%rip),%xmm0
call   1030 <expf@plt>
divss  0x2e4e(%rip),%xmm0
movss  %xmm0,0x2e4a(%rip)
movss  0xe16(%rip),%xmm0
call   1030 <expf@plt>
divss  0x2e31(%rip),%xmm0
movss  %xmm0,0x2e31(%rip)
movss  0xdfd(%rip),%xmm0
call   1030 <expf@plt>
divss  0x2e14(%rip),%xmm0
movss  %xmm0,0x2e18(%rip)
movss  0xddc(%rip),%xmm0
call   1030 <expf@plt>
divss  0x2df7(%rip),%xmm0
movss  %xmm0,0x2dff(%rip)
movss  0xdbb(%rip),%xmm0
call   1030 <expf@plt>
divss  0x2dda(%rip),%xmm0
movss  %xmm0,0x2de6(%rip)
cmpl   $0x5,-0xc(%rbp)
jge    12fe <gaussianblur+0x1ee>
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x10(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    $0x1,%eax
cltd
idivl  -0xc(%rbp)
mov    -0x70(%rbp),%rax
movslq %edx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x14(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    $0x2,%eax
cltd
idivl  -0xc(%rbp)
mov    -0x68(%rbp),%rax
movslq %edx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x18(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    $0x3,%eax
cltd
idivl  -0xc(%rbp)
mov    -0x60(%rbp),%rax
movslq %edx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    $0x4,%eax
cltd
idivl  -0xc(%rbp)
mov    -0x58(%rbp),%rax
movslq %edx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x20(%rbp)
jmp    1343 <gaussianblur+0x233>
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x14(%rbp)
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x18(%rbp)
mov    -0x8(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  %xmm0,-0x20(%rbp)
movss  -0x18(%rbp),%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x1c(%rbp),%xmm0
movss  %xmm0,-0x28(%rbp)
movss  -0x20(%rbp),%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0xc(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x34(%rbp)
mov    -0xc(%rbp),%eax
sub    $0x5,%eax
mov    %eax,-0x38(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    150f <gaussianblur+0x3ff>
mov    -0x30(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    13a0 <gaussianblur+0x290>
mov    -0x30(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x74(%rbp)
jmp    13a9 <gaussianblur+0x299>
mov    -0x30(%rbp),%eax
sub    -0x34(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0x74(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    13c9 <gaussianblur+0x2b9>
mov    -0x30(%rbp),%eax
add    $0x5,%eax
mov    %eax,-0x78(%rbp)
jmp    13d2 <gaussianblur+0x2c2>
mov    -0x30(%rbp),%eax
sub    -0x38(%rbp),%eax
mov    %eax,-0x78(%rbp)
mov    -0x78(%rbp),%eax
mov    %eax,-0x40(%rbp)
movss  -0x10(%rbp),%xmm1
movss  0x2c4b(%rip),%xmm2
movss  -0x14(%rbp),%xmm0
mulss  0x2c42(%rip),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x18(%rbp),%xmm0
movss  0x2c31(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x1c(%rbp),%xmm1
movss  0x2c20(%rip),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x20(%rbp),%xmm0
movss  0x2c0f(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x14(%rbp),%xmm0
movss  %xmm0,-0x10(%rbp)
movss  -0x18(%rbp),%xmm0
movss  %xmm0,-0x14(%rbp)
movss  -0x1c(%rbp),%xmm0
movss  %xmm0,-0x18(%rbp)
movss  -0x20(%rbp),%xmm0
movss  %xmm0,-0x1c(%rbp)
cmpl   $0x2,-0x40(%rbp)
jl     1482 <gaussianblur+0x372>
cmpl   $0x5,-0x40(%rbp)
jl     1499 <gaussianblur+0x389>
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x20(%rbp)
jmp    14fc <gaussianblur+0x3ec>
mov    -0x40(%rbp),%eax
mov    %eax,-0x7c(%rbp)
sub    $0x2,%eax
je     14cf <gaussianblur+0x3bf>
jmp    14ad <gaussianblur+0x39d>
mov    -0x7c(%rbp),%eax
sub    $0x3,%eax
je     14de <gaussianblur+0x3ce>
jmp    14be <gaussianblur+0x3ae>
mov    -0x7c(%rbp),%eax
sub    $0x4,%eax
je     14ed <gaussianblur+0x3dd>
jmp    14f7 <gaussianblur+0x3e7>
movss  -0x24(%rbp),%xmm0
movss  %xmm0,-0x20(%rbp)
jmp    14f7 <gaussianblur+0x3e7>
movss  -0x28(%rbp),%xmm0
movss  %xmm0,-0x20(%rbp)
jmp    14f7 <gaussianblur+0x3e7>
movss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x20(%rbp)
jmp    14fc <gaussianblur+0x3ec>
jmp    1501 <gaussianblur+0x3f1>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    137a <gaussianblur+0x26a>
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<gaussianblur>:
push   %rbp
push   %r14
push   %rbx
movss  0x2f18(%rip),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1152 <gaussianblur+0x52>
jp     1152 <gaussianblur+0x52>
movl   $0x40898d90,0x2f04(%rip)
8d 89 40
movl   $0x3e2cfbe1,0x2efe(%rip)
fb 2c 3e
movl   $0x3e5be7d8,0x2ef8(%rip)
e7 5b 3e
movl   $0x3e6e3890,0x2ef2(%rip)
38 6e 3e
movl   $0x3e5be7d8,0x2eec(%rip)
e7 5b 3e
movl   $0x3e2cfbe1,0x2ee6(%rip)
fb 2c 3e
cmp    $0x5,%esi
jge    119d <gaussianblur+0x9d>
mov    $0x1,%eax
xor    %edx,%edx
idiv   %esi
mov    %edx,%r8d
mov    $0x2,%eax
xor    %edx,%edx
idiv   %esi
mov    %edx,%r9d
mov    $0x3,%eax
xor    %edx,%edx
idiv   %esi
mov    %edx,%ecx
mov    $0x4,%eax
xor    %edx,%edx
idiv   %esi
test   %esi,%esi
jle    12df <gaussianblur+0x1df>
lea    (%rdi,%r8,4),%rax
lea    (%rdi,%r9,4),%rbx
lea    (%rdi,%rcx,4),%rcx
lea    (%rdi,%rdx,4),%rdx
jmp    11ad <gaussianblur+0xad>
lea    0x4(%rdi),%rax
lea    0x8(%rdi),%rbx
lea    0xc(%rdi),%rcx
lea    0x10(%rdi),%rdx
movss  (%rbx),%xmm8
movss  (%rcx),%xmm10
movss  (%rdx),%xmm9
lea    -0x2(%rsi),%r10d
lea    -0x5(%rsi),%r11d
movss  (%rax),%xmm6
movss  (%rdi),%xmm4
mov    $0x2,%r8d
mov    $0x2,%r14d
sub    %esi,%r14d
mov    $0x5,%r9d
mov    $0x5,%eax
sub    %esi,%eax
movss  0x2e37(%rip),%xmm11
movss  0x2e32(%rip),%xmm12
movss  0x2e2d(%rip),%xmm13
movss  0x2e29(%rip),%xmm7
xor    %ecx,%ecx
movss  0x2e23(%rip),%xmm0
movaps %xmm8,%xmm5
movaps %xmm10,%xmm1
movaps %xmm9,%xmm2
jmp    1252 <gaussianblur+0x152>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movslq %ebx,%rdx
movss  (%rdi,%rdx,4),%xmm3
add    $0x1,%ecx
movaps %xmm6,%xmm4
movaps %xmm5,%xmm6
movaps %xmm1,%xmm5
movaps %xmm2,%xmm1
movaps %xmm3,%xmm2
cmp    %ecx,%esi
je     12df <gaussianblur+0x1df>
mulss  %xmm11,%xmm4
cmp    %r10d,%ecx
mov    %r14d,%ebp
cmovl  %r8d,%ebp
add    %ecx,%ebp
cmp    %r11d,%ecx
mov    %eax,%edx
cmovl  %r9d,%edx
lea    (%rdx,%rcx,1),%ebx
movaps %xmm6,%xmm3
mulss  %xmm12,%xmm3
addss  %xmm4,%xmm3
movaps %xmm5,%xmm4
mulss  %xmm13,%xmm4
addss  %xmm3,%xmm4
movaps %xmm1,%xmm3
mulss  %xmm7,%xmm3
addss  %xmm4,%xmm3
movaps %xmm2,%xmm4
mulss  %xmm0,%xmm4
addss  %xmm3,%xmm4
movslq %ebp,%rbp
movss  %xmm4,(%rdi,%rbp,4)
add    %ecx,%edx
add    $0xfffffffb,%edx
cmp    $0xfffffffc,%edx
jbe    1230 <gaussianblur+0x130>
cmp    $0x4,%ebx
je     12d6 <gaussianblur+0x1d6>
movaps %xmm10,%xmm3
cmp    $0x3,%ebx
je     1238 <gaussianblur+0x138>
movaps %xmm2,%xmm3
cmp    $0x2,%ebx
jne    1238 <gaussianblur+0x138>
movaps %xmm8,%xmm3
jmp    1238 <gaussianblur+0x138>
movaps %xmm9,%xmm3
jmp    1238 <gaussianblur+0x138>
pop    %rbx
pop    %r14
pop    %rbp
ret

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

LLVM IR (-O2):
@gaussianblur.norm = internal unnamed_addr global float 0.000000e+00
@gaussianblur.c_2 = internal unnamed_addr global float 0.000000e+00
@gaussianblur.c_1 = internal unnamed_addr global float 0.000000e+00
@gaussianblur.c0 = internal unnamed_addr global float 0.000000e+00
@gaussianblur.c1 = internal unnamed_addr global float 0.000000e+00
@gaussianblur.c2 = internal unnamed_addr global float 0.000000e+00
define void @gaussianblur(float* nocapture %0, i32 %1) {
%3 = load float, float* @gaussianblur.norm
%4 = fcmp oeq float %3, 0.000000e+00
br i1 %4, label %5, label %6
5: ; preds = %2
store float 0x401131B200000000, float* @gaussianblur.norm
store float 0x3FC59F7C20000000, float* @gaussianblur.c_2
store float 0x3FCB7CFB00000000, float* @gaussianblur.c_1
store float 0x3FCDC71200000000, float* @gaussianblur.c0
store float 0x3FCB7CFB00000000, float* @gaussianblur.c1
store float 0x3FC59F7C20000000, float* @gaussianblur.c2
br label %6
6: ; preds = %5, %2
%7 = icmp slt i32 %1, 5
br i1 %7, label %13, label %8
8: ; preds = %6
%9 = getelementptr inbounds float, float* %0, i64 1
%10 = getelementptr inbounds float, float* %0, i64 2
%11 = getelementptr inbounds float, float* %0, i64 3
%12 = getelementptr inbounds float, float* %0, i64 4
br label %27
13: ; preds = %6
%14 = srem i32 1, %1
%15 = zext i32 %14 to i64
%16 = getelementptr inbounds float, float* %0, i64 %15
%17 = srem i32 2, %1
%18 = zext i32 %17 to i64
%19 = getelementptr inbounds float, float* %0, i64 %18
%20 = srem i32 3, %1
%21 = zext i32 %20 to i64
%22 = getelementptr inbounds float, float* %0, i64 %21
%23 = srem i32 4, %1
%24 = zext i32 %23 to i64
%25 = getelementptr inbounds float, float* %0, i64 %24
%26 = icmp sgt i32 %1, 0
br i1 %26, label %27, label %80
27: ; preds = %8, %13
%28 = phi float* [ %12, %8 ], [ %25, %13 ]
%29 = phi float* [ %11, %8 ], [ %22, %13 ]
%30 = phi float* [ %10, %8 ], [ %19, %13 ]
%31 = phi float* [ %9, %8 ], [ %16, %13 ]
%32 = load float, float* %30
%33 = load float, float* %29
%34 = load float, float* %28
%35 = add nsw i32 %1, -2
%36 = add nsw i32 %1, -5
%37 = load float, float* %31
%38 = load float, float* %0
%39 = sub nsw i32 2, %1
%40 = sub nsw i32 5, %1
%41 = load float, float* @gaussianblur.c_2
%42 = load float, float* @gaussianblur.c_1
%43 = load float, float* @gaussianblur.c0
%44 = load float, float* @gaussianblur.c1
%45 = load float, float* @gaussianblur.c2
br label %46
46: ; preds = %27, %76
%47 = phi float [ %38, %27 ], [ %48, %76 ]
%48 = phi float [ %37, %27 ], [ %49, %76 ]
%49 = phi float [ %32, %27 ], [ %50, %76 ]
%50 = phi float [ %33, %27 ], [ %52, %76 ]
%51 = phi i32 [ 0, %27 ], [ %78, %76 ]
%52 = phi float [ %34, %27 ], [ %77, %76 ]
%53 = icmp slt i32 %51, %35
%54 = select i1 %53, i32 2, i32 %39
%55 = add i32 %54, %51
%56 = icmp slt i32 %51, %36
%57 = select i1 %56, i32 5, i32 %40
%58 = add i32 %57, %51
%59 = fmul float %48, %42
%60 = tail call float @llvm.fmuladd.f32(float %47, float %41, float %59)
%61 = tail call float @llvm.fmuladd.f32(float %49, float %43, float %60)
%62 = tail call float @llvm.fmuladd.f32(float %50, float %44, float %61)
%63 = tail call float @llvm.fmuladd.f32(float %52, float %45, float %62)
%64 = sext i32 %55 to i64
%65 = getelementptr inbounds float, float* %0, i64 %64
store float %63, float* %65
%66 = add i32 %58, -5
%67 = icmp ult i32 %66, -3
br i1 %67, label %68, label %72
68: ; preds = %46
%69 = sext i32 %58 to i64
%70 = getelementptr inbounds float, float* %0, i64 %69
%71 = load float, float* %70
br label %76
72: ; preds = %46
switch i32 %58, label %76 [
i32 2, label %73
i32 3, label %74
i32 4, label %75
]
73: ; preds = %72
br label %76
74: ; preds = %72
br label %76
75: ; preds = %72
br label %76
76: ; preds = %73, %74, %75, %72, %68
%77 = phi float [ %71, %68 ], [ %52, %72 ], [ %34, %75 ], [ %33, %74 ], [ %32, %73 ]
%78 = add nuw nsw i32 %51, 1
%79 = icmp eq i32 %78, %1
br i1 %79, label %80, label %46
80: ; preds = %76, %13
ret void
}