#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);
float powf(float, float);
void kernel_deriche(int w, int h, float alpha, float imgIn[4096 + 0][2160 + 0],
                    float imgOut[4096 + 0][2160 + 0],
                    float y1[4096 + 0][2160 + 0],
                    float y2[4096 + 0][2160 + 0]) {
  int i, j;
  float xm1, tm1, ym1, ym2;
  float xp1, xp2;
  float tp1, tp2;
  float yp1, yp2;
  float k;
  float a1, a2, a3, a4, a5, a6, a7, a8;
  float b1, b2, c1, c2;
#pragma scop
  k = (1.0f - expf(-alpha)) * (1.0f - expf(-alpha)) /
      (1.0f + 2.0f * alpha * expf(-alpha) - expf(2.0f * alpha));
  a1 = a5 = k;
  a2 = a6 = k * expf(-alpha) * (alpha - 1.0f);
  a3 = a7 = k * expf(-alpha) * (alpha + 1.0f);
  a4 = a8 = -k * expf(-2.0f * alpha);
  b1 = powf(2.0f, -alpha);
  b2 = -expf(-2.0f * alpha);
  c1 = c2 = 1;
  for (i = 0; i < w; i++) {
    ym1 = 0.0f;
    ym2 = 0.0f;
    xm1 = 0.0f;
    for (j = 0; j < h; j++) {
      y1[i][j] = a1 * imgIn[i][j] + a2 * xm1 + b1 * ym1 + b2 * ym2;
      xm1 = imgIn[i][j];
      ym2 = ym1;
      ym1 = y1[i][j];
    }
  }
  for (i = 0; i < w; i++) {
    yp1 = 0.0f;
    yp2 = 0.0f;
    xp1 = 0.0f;
    xp2 = 0.0f;
    for (j = h - 1; j >= 0; j--) {
      y2[i][j] = a3 * xp1 + a4 * xp2 + b1 * yp1 + b2 * yp2;
      xp2 = xp1;
      xp1 = imgIn[i][j];
      yp2 = yp1;
      yp1 = y2[i][j];
    }
  }
  for (i = 0; i < w; i++)
    for (j = 0; j < h; j++) {
      imgOut[i][j] = c1 * (y1[i][j] + y2[i][j]);
    }
  for (j = 0; j < h; j++) {
    tm1 = 0.0f;
    ym1 = 0.0f;
    ym2 = 0.0f;
    for (i = 0; i < w; i++) {
      y1[i][j] = a5 * imgOut[i][j] + a6 * tm1 + b1 * ym1 + b2 * ym2;
      tm1 = imgOut[i][j];
      ym2 = ym1;
      ym1 = y1[i][j];
    }
  }
  for (j = 0; j < h; j++) {
    tp1 = 0.0f;
    tp2 = 0.0f;
    yp1 = 0.0f;
    yp2 = 0.0f;
    for (i = w - 1; i >= 0; i--) {
      y2[i][j] = a7 * tp1 + a8 * tp2 + b1 * yp1 + b2 * yp2;
      tp2 = tp1;
      tp1 = imgOut[i][j];
      yp2 = yp1;
      yp1 = y2[i][j];
    }
  }
  for (i = 0; i < w; i++)
    for (j = 0; j < h; j++)
      imgOut[i][j] = c2 * (y1[i][j] + y2[i][j]);
#pragma endscop
}


x86 assembly (clang, -O0):
<kernel_deriche>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
movss  %xmm0,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movss  -0xc(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
call   1040 <expf@plt>
movaps %xmm0,%xmm1
movss  0xe98(%rip),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,-0xb0(%rbp)
ff
movss  -0xc(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
call   1040 <expf@plt>
movaps %xmm0,%xmm2
movss  -0xb0(%rbp),%xmm0
ff
movss  0xe62(%rip),%xmm1
subss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
movss  0xe52(%rip),%xmm0
mulss  -0xc(%rbp),%xmm0
movss  %xmm0,-0xac(%rbp)
ff
movss  -0xc(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
call   1040 <expf@plt>
movaps %xmm0,%xmm1
movss  -0xac(%rbp),%xmm0
ff
mulss  %xmm1,%xmm0
movss  0xe0f(%rip),%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,-0xa8(%rbp)
ff
movss  0xe03(%rip),%xmm0
mulss  -0xc(%rbp),%xmm0
call   1040 <expf@plt>
movss  -0xa8(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movss  -0xa4(%rbp),%xmm0
ff
subss  %xmm2,%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x64(%rbp),%xmm0
movss  %xmm0,-0x78(%rbp)
movss  %xmm0,-0x68(%rbp)
movss  -0x64(%rbp),%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
movss  -0xc(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
call   1040 <expf@plt>
movaps %xmm0,%xmm1
movss  -0xa0(%rbp),%xmm0
ff
mulss  %xmm1,%xmm0
movss  -0xc(%rbp),%xmm1
movss  0xd82(%rip),%xmm2
subss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  %xmm0,-0x6c(%rbp)
movss  -0x64(%rbp),%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
movss  -0xc(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
call   1040 <expf@plt>
movaps %xmm0,%xmm1
movss  -0x9c(%rbp),%xmm0
ff
mulss  %xmm1,%xmm0
movss  0xd35(%rip),%xmm1
addss  -0xc(%rbp),%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x80(%rbp)
movss  %xmm0,-0x70(%rbp)
movss  -0x64(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x98(%rbp)
ff
movss  0xd04(%rip),%xmm0
mulss  -0xc(%rbp),%xmm0
call   1040 <expf@plt>
movaps %xmm0,%xmm1
movss  -0x98(%rbp),%xmm0
ff
mulss  %xmm1,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  %xmm0,-0x74(%rbp)
movss  -0xc(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
movss  0xcc8(%rip),%xmm0
call   1030 <powf@plt>
movss  %xmm0,-0x88(%rbp)
ff
movss  0xcaf(%rip),%xmm0
mulss  -0xc(%rbp),%xmm0
call   1040 <expf@plt>
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
movss  0xc84(%rip),%xmm0
movss  %xmm0,-0x94(%rbp)
ff
movss  0xc74(%rip),%xmm0
movss  %xmm0,-0x90(%rbp)
ff
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    14b4 <kernel_deriche+0x394>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x44(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x48(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x3c(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    14a1 <kernel_deriche+0x381>
movss  -0x68(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0x21c0,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x6c(%rbp),%xmm1
mulss  -0x3c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x88(%rbp),%xmm1
ff
movss  -0x44(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x8c(%rbp),%xmm0
ff
movss  -0x48(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0x21c0,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0x21c0,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0x21c0,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    13c6 <kernel_deriche+0x2a6>
jmp    14a6 <kernel_deriche+0x386>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    139b <kernel_deriche+0x27b>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    15d0 <kernel_deriche+0x4b0>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x5c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x60(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x8(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x38(%rbp)
cmpl   $0x0,-0x38(%rbp)
jl     15bd <kernel_deriche+0x49d>
movss  -0x70(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x74(%rbp),%xmm1
mulss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x88(%rbp),%xmm1
ff
movss  -0x5c(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x8c(%rbp),%xmm0
ff
movss  -0x60(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0x21c0,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0x21c0,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0x21c0,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x38(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x38(%rbp)
jmp    14f0 <kernel_deriche+0x3d0>
jmp    15c2 <kernel_deriche+0x4a2>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    14bb <kernel_deriche+0x39b>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1674 <kernel_deriche+0x554>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1661 <kernel_deriche+0x541>
movss  -0x90(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0x21c0,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0x21c0,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm1
mulss  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0x21c0,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    15ea <kernel_deriche+0x4ca>
jmp    1666 <kernel_deriche+0x546>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    15d7 <kernel_deriche+0x4b7>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1794 <kernel_deriche+0x674>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x40(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x44(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x48(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1781 <kernel_deriche+0x661>
movss  -0x78(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0x21c0,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x7c(%rbp),%xmm1
mulss  -0x40(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x88(%rbp),%xmm1
ff
movss  -0x44(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x8c(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0x21c0,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0x21c0,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0x21c0,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    16a6 <kernel_deriche+0x586>
jmp    1786 <kernel_deriche+0x666>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    167b <kernel_deriche+0x55b>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    18b3 <kernel_deriche+0x793>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x54(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x5c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x4(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x34(%rbp)
cmpl   $0x0,-0x34(%rbp)
jl     18a0 <kernel_deriche+0x780>
movss  -0x80(%rbp),%xmm0
movss  -0x54(%rbp),%xmm2
movss  -0x84(%rbp),%xmm1
ff
mulss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x88(%rbp),%xmm1
movss  -0x5c(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x8c(%rbp),%xmm0
ff
movss  -0x60(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0x21c0,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0x21c0,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0x21c0,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
jmp    17d0 <kernel_deriche+0x6b0>
jmp    18a5 <kernel_deriche+0x785>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    179b <kernel_deriche+0x67b>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1957 <kernel_deriche+0x837>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1944 <kernel_deriche+0x824>
movss  -0x94(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0x21c0,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0x21c0,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm1
mulss  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0x21c0,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    18cd <kernel_deriche+0x7ad>
jmp    1949 <kernel_deriche+0x829>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    18ba <kernel_deriche+0x79a>
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<kernel_deriche>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xa8,%rsp
mov    %r9,%r13
mov    %r8,0x28(%rsp)
mov    %rcx,0x48(%rsp)
mov    %rdx,%rbp
movaps %xmm0,0x10(%rsp)
mov    %esi,%r14d
mov    %edi,%ebx
xorps  0xeae(%rip),%xmm0
movaps %xmm0,0x30(%rsp)
call   1030 <expf@plt>
movss  0xeac(%rip),%xmm1
subss  %xmm0,%xmm1
movss  %xmm1,(%rsp)
movaps 0x30(%rsp),%xmm0
call   1030 <expf@plt>
movss  0xe91(%rip),%xmm1
subss  %xmm0,%xmm1
mulss  (%rsp),%xmm1
movaps %xmm1,0x50(%rsp)
movaps 0x10(%rsp),%xmm0
addss  %xmm0,%xmm0
movaps %xmm0,(%rsp)
movaps 0x30(%rsp),%xmm0
call   1030 <expf@plt>
movaps (%rsp),%xmm1
mulss  %xmm1,%xmm0
addss  0xe5c(%rip),%xmm0
movss  %xmm0,0x20(%rsp)
movaps %xmm1,%xmm0
call   1030 <expf@plt>
movss  0x20(%rsp),%xmm1
subss  %xmm0,%xmm1
movaps 0x50(%rsp),%xmm0
divss  %xmm1,%xmm0
movaps %xmm0,0x50(%rsp)
movaps 0x30(%rsp),%xmm0
call   1030 <expf@plt>
mulss  0x50(%rsp),%xmm0
movss  0xe22(%rip),%xmm1
addss  0x10(%rsp),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0x70(%rsp)
movaps 0x30(%rsp),%xmm0
call   1030 <expf@plt>
movaps 0x50(%rsp),%xmm3
mulss  %xmm3,%xmm0
movaps 0x10(%rsp),%xmm1
movss  0xdee(%rip),%xmm2
addss  %xmm1,%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,0x68(%rsp)
xorps  0xdc9(%rip),%xmm3
movaps %xmm3,(%rsp)
mulss  0xdd5(%rip),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm1,%xmm0
call   1030 <expf@plt>
mulss  (%rsp),%xmm0
movss  %xmm0,0x84(%rsp)
movaps 0x30(%rsp),%xmm0
call   1040 <exp2f@plt>
movss  %xmm0,0x80(%rsp)
movaps 0x10(%rsp),%xmm0
call   1030 <expf@plt>
movss  0x70(%rsp),%xmm10
movaps 0x50(%rsp),%xmm7
movss  0x80(%rsp),%xmm6
movss  0x84(%rsp),%xmm9
movss  0x68(%rsp),%xmm8
mov    %r14d,%r11d
xorps  0xd55(%rip),%xmm0
mov    %ebx,%eax
mov    %rax,(%rsp)
mov    %r14d,%r15d
mov    %ebx,0x40(%rsp)
test   %ebx,%ebx
mov    %r14d,0x30(%rsp)
jle    167a <kernel_deriche+0x55a>
xor    %eax,%eax
mov    %rbp,%rdx
mov    0x28(%rsp),%rsi
mov    (%rsp),%rcx
mov    0x40(%rsp),%ebx
jmp    12f7 <kernel_deriche+0x1d7>
nopl   0x0(%rax)
add    $0x1,%rax
add    $0x21c0,%rsi
add    $0x21c0,%rdx
cmp    %rcx,%rax
je     1353 <kernel_deriche+0x233>
test   %r11d,%r11d
jle    12e0 <kernel_deriche+0x1c0>
xorps  %xmm2,%xmm2
xor    %edi,%edi
xorps  %xmm3,%xmm3
xorps  %xmm1,%xmm1
nopw   0x0(%rax,%rax,1)
movaps %xmm3,%xmm4
mulss  %xmm10,%xmm2
movss  (%rdx,%rdi,4),%xmm3
mulss  %xmm7,%xmm3
addss  %xmm2,%xmm3
movaps %xmm6,%xmm2
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
mulss  %xmm0,%xmm1
addss  %xmm2,%xmm1
movss  %xmm1,(%rsi,%rdi,4)
movss  (%rdx,%rdi,4),%xmm2
add    $0x1,%rdi
movaps %xmm1,%xmm3
movaps %xmm4,%xmm1
cmp    %rdi,%r15
jne    1310 <kernel_deriche+0x1f0>
jmp    12e0 <kernel_deriche+0x1c0>
test   %ebx,%ebx
jle    167a <kernel_deriche+0x55a>
lea    0x1(%r15),%r8
xor    %edx,%edx
mov    (%rsp),%rax
jmp    1379 <kernel_deriche+0x259>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rdx
cmp    %rax,%rdx
je     13e7 <kernel_deriche+0x2c7>
test   %r11d,%r11d
jle    1370 <kernel_deriche+0x250>
xorps  %xmm4,%xmm4
mov    %r8,%rsi
xorps  %xmm3,%xmm3
xorps  %xmm5,%xmm5
xorps  %xmm1,%xmm1
nopl   (%rax)
movaps %xmm5,%xmm2
lea    -0x2(%rsi),%ecx
mulss  %xmm9,%xmm3
movaps %xmm8,%xmm5
mulss  %xmm4,%xmm5
addss  %xmm3,%xmm5
movaps %xmm6,%xmm3
mulss  %xmm2,%xmm3
addss  %xmm5,%xmm3
mulss  %xmm0,%xmm1
addss  %xmm3,%xmm1
imul   $0x21c0,%rdx,%rdi
lea    (%rdi,%r13,1),%rbx
movss  %xmm1,(%rbx,%rcx,4)
add    %rbp,%rdi
movaps %xmm4,%xmm3
movss  (%rdi,%rcx,4),%xmm4
add    $0xffffffffffffffff,%rsi
movaps %xmm1,%xmm5
movaps %xmm2,%xmm1
cmp    $0x1,%rsi
jg     1390 <kernel_deriche+0x270>
jmp    1370 <kernel_deriche+0x250>
cmpl   $0x0,0x40(%rsp)
jle    167a <kernel_deriche+0x55a>
mov    %r15d,%eax
and    $0xfffffff8,%eax
mov    %rax,0xa0(%rsp)
add    $0xfffffffffffffff8,%rax
mov    %rax,0x98(%rsp)
mov    %rax,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
mov    %rcx,%rax
mov    %rcx,0x90(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x88(%rsp)
mov    %r15,%rax
neg    %rax
mov    %rax,0x78(%rsp)
mov    0x28(%rsp),%rbp
lea    0x30(%rbp),%rsi
lea    0x30(%r13),%rdi
mov    0x48(%rsp),%rax
lea    0x30(%rax),%rdx
lea    0x4(%rax),%r8
xor    %r9d,%r9d
mov    %r13,%r12
jmp    149d <kernel_deriche+0x37d>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r9
add    $0x21c0,%rsi
add    $0x21c0,%rdi
add    $0x21c0,%rdx
add    $0x21c0,%r8
add    $0x21c0,%r12
add    $0x21c0,%rbp
cmp    (%rsp),%r9
mov    0x30(%rsp),%r11d
je     167a <kernel_deriche+0x55a>
test   %r11d,%r11d
jle    1460 <kernel_deriche+0x340>
imul   $0x21c0,%r9,%r11
mov    0x48(%rsp),%rax
lea    (%rax,%r11,1),%r10
mov    0x28(%rsp),%rax
lea    (%rax,%r11,1),%rcx
add    %r13,%r11
cmpl   $0x8,0x30(%rsp)
jae    14d0 <kernel_deriche+0x3b0>
xor    %eax,%eax
jmp    1600 <kernel_deriche+0x4e0>
nopl   0x0(%rax)
lea    (%r10,%r15,4),%rax
lea    (%rcx,%r15,4),%r14
lea    (%r11,%r15,4),%rbx
cmp    %r14,%r10
setb   %r14b
mov    %rcx,0x10(%rsp)
cmp    %rax,%rcx
mov    %r10,%rcx
setb   %r10b
mov    %rcx,0x20(%rsp)
cmp    %rbx,%rcx
setb   %cl
cmp    %rax,%r11
setb   %bl
test   %r10b,%r14b
jne    15e7 <kernel_deriche+0x4c7>
mov    $0x0,%eax
and    %bl,%cl
mov    0x20(%rsp),%r10
mov    0x10(%rsp),%rcx
jne    1600 <kernel_deriche+0x4e0>
cmpq   $0x0,0x98(%rsp)
je     1664 <kernel_deriche+0x544>
mov    0x88(%rsp),%rbx
xor    %r14d,%r14d
nopl   (%rax)
movups -0x30(%rsi,%r14,4),%xmm1
movups -0x20(%rsi,%r14,4),%xmm2
movups -0x30(%rdi,%r14,4),%xmm3
addps  %xmm1,%xmm3
movups -0x20(%rdi,%r14,4),%xmm1
addps  %xmm2,%xmm1
movups %xmm3,-0x30(%rdx,%r14,4)
movups %xmm1,-0x20(%rdx,%r14,4)
movups -0x10(%rsi,%r14,4),%xmm1
movups (%rsi,%r14,4),%xmm2
movups -0x10(%rdi,%r14,4),%xmm3
addps  %xmm1,%xmm3
movups (%rdi,%r14,4),%xmm1
addps  %xmm2,%xmm1
movups %xmm3,-0x10(%rdx,%r14,4)
movups %xmm1,(%rdx,%r14,4)
add    $0x10,%r14
add    $0xfffffffffffffffe,%rbx
jne    1540 <kernel_deriche+0x420>
testb  $0x1,0x90(%rsp)
01
je     15cc <kernel_deriche+0x4ac>
movups (%rcx,%r14,4),%xmm1
movups 0x10(%rcx,%r14,4),%xmm2
movups (%r11,%r14,4),%xmm3
addps  %xmm1,%xmm3
movups 0x10(%r11,%r14,4),%xmm1
addps  %xmm2,%xmm1
movups %xmm3,(%r10,%r14,4)
movups %xmm1,0x10(%r10,%r14,4)
mov    0xa0(%rsp),%rcx
mov    %rcx,%rax
cmp    %r15,%rcx
mov    0x10(%rsp),%rcx
je     1460 <kernel_deriche+0x340>
jmp    1600 <kernel_deriche+0x4e0>
xor    %eax,%eax
mov    0x20(%rsp),%r10
mov    0x10(%rsp),%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %rax,%rbx
test   $0x1,%r15b
je     1621 <kernel_deriche+0x501>
movss  (%rcx,%rax,4),%xmm1
addss  (%r11,%rax,4),%xmm1
movss  %xmm1,(%r10,%rax,4)
mov    %rax,%rbx
or     $0x1,%rbx
not    %rax
cmp    0x78(%rsp),%rax
je     1460 <kernel_deriche+0x340>
nop
movss  0x0(%rbp,%rbx,4),%xmm1
addss  (%r12,%rbx,4),%xmm1
movss  %xmm1,-0x4(%r8,%rbx,4)
movss  0x4(%rbp,%rbx,4),%xmm1
addss  0x4(%r12,%rbx,4),%xmm1
movss  %xmm1,(%r8,%rbx,4)
add    $0x2,%rbx
cmp    %rbx,%r15
jne    1630 <kernel_deriche+0x510>
jmp    1460 <kernel_deriche+0x340>
xor    %r14d,%r14d
testb  $0x1,0x90(%rsp)
01
jne    15a5 <kernel_deriche+0x485>
jmp    15cc <kernel_deriche+0x4ac>
test   %r11d,%r11d
mov    0x48(%rsp),%r12
mov    (%rsp),%r9
mov    0x40(%rsp),%ebx
jle    17a7 <kernel_deriche+0x687>
imul   $0x21c0,%r9,%rax
xor    %edx,%edx
mov    0x28(%rsp),%rsi
mov    %r12,%rdi
jmp    16c1 <kernel_deriche+0x5a1>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%rdx
add    $0x4,%rdi
add    $0x4,%rsi
cmp    %r15,%rdx
je     1716 <kernel_deriche+0x5f6>
test   %ebx,%ebx
jle    16b0 <kernel_deriche+0x590>
xorps  %xmm2,%xmm2
xor    %ebp,%ebp
xorps  %xmm3,%xmm3
xorps  %xmm1,%xmm1
movaps %xmm3,%xmm4
mulss  %xmm10,%xmm2
movss  (%rdi,%rbp,1),%xmm3
mulss  %xmm7,%xmm3
addss  %xmm2,%xmm3
movaps %xmm6,%xmm2
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
mulss  %xmm0,%xmm1
addss  %xmm2,%xmm1
movss  %xmm1,(%rsi,%rbp,1)
movss  (%rdi,%rbp,1),%xmm2
add    $0x21c0,%rbp
movaps %xmm1,%xmm3
movaps %xmm4,%xmm1
cmp    %rbp,%rax
jne    16d0 <kernel_deriche+0x5b0>
jmp    16b0 <kernel_deriche+0x590>
test   %r11d,%r11d
jle    17a7 <kernel_deriche+0x687>
lea    0x1(%r9),%rax
xor    %edx,%edx
jmp    1739 <kernel_deriche+0x619>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rdx
cmp    %r15,%rdx
je     17a7 <kernel_deriche+0x687>
test   %ebx,%ebx
jle    1730 <kernel_deriche+0x610>
xorps  %xmm4,%xmm4
mov    %rax,%rsi
xorps  %xmm3,%xmm3
xorps  %xmm5,%xmm5
xorps  %xmm1,%xmm1
nopl   0x0(%rax)
movaps %xmm5,%xmm2
lea    -0x2(%rsi),%ecx
mulss  %xmm9,%xmm3
movaps %xmm8,%xmm5
mulss  %xmm4,%xmm5
addss  %xmm3,%xmm5
movaps %xmm6,%xmm3
mulss  %xmm2,%xmm3
addss  %xmm5,%xmm3
mulss  %xmm0,%xmm1
addss  %xmm3,%xmm1
imul   $0x21c0,%rcx,%rcx
lea    (%rcx,%r13,1),%rdi
movss  %xmm1,(%rdi,%rdx,4)
add    %r12,%rcx
movaps %xmm4,%xmm3
movss  (%rcx,%rdx,4),%xmm4
add    $0xffffffffffffffff,%rsi
movaps %xmm1,%xmm5
movaps %xmm2,%xmm1
cmp    $0x1,%rsi
jg     1750 <kernel_deriche+0x630>
jmp    1730 <kernel_deriche+0x610>
test   %ebx,%ebx
jle    1a32 <kernel_deriche+0x912>
mov    %r15d,%eax
and    $0xfffffff8,%eax
mov    %rax,0x78(%rsp)
add    $0xfffffffffffffff8,%rax
mov    %rax,0x40(%rsp)
mov    %rax,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
mov    %rcx,%rax
mov    %rcx,0x70(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x68(%rsp)
mov    %r15,%rax
neg    %rax
mov    %rax,0x20(%rsp)
mov    0x28(%rsp),%r14
lea    0x30(%r14),%rsi
lea    0x30(%r13),%rdi
lea    0x30(%r12),%rdx
lea    0x4(%r12),%rbp
xor    %r8d,%r8d
mov    %r13,%rbx
jmp    1847 <kernel_deriche+0x727>
nopl   0x0(%rax)
add    $0x1,%r8
add    $0x21c0,%rsi
add    $0x21c0,%rdi
add    $0x21c0,%rdx
add    $0x21c0,%rbp
add    $0x21c0,%rbx
add    $0x21c0,%r14
cmp    %r9,%r8
je     1a32 <kernel_deriche+0x912>
test   %r11d,%r11d
jle    1810 <kernel_deriche+0x6f0>
imul   $0x21c0,%r8,%r10
lea    (%r12,%r10,1),%rcx
mov    0x28(%rsp),%rax
add    %r10,%rax
add    %r13,%r10
cmp    $0x8,%r11d
mov    %rcx,0x10(%rsp)
mov    %rax,0x50(%rsp)
jae    1880 <kernel_deriche+0x760>
xor    %ecx,%ecx
jmp    19c0 <kernel_deriche+0x8a0>
nopl   0x0(%rax)
mov    %rax,%r12
lea    (%rcx,%r15,4),%rax
lea    (%r12,%r15,4),%r11
lea    (%r10,%r15,4),%r9
cmp    %r11,%rcx
setb   %r11b
cmp    %rax,%r12
setb   %r12b
cmp    %r9,%rcx
setb   %r9b
cmp    %rax,%r10
setb   %al
test   %r12b,%r11b
jne    194d <kernel_deriche+0x82d>
mov    $0x0,%ecx
and    %al,%r9b
mov    0x48(%rsp),%r12
mov    0x30(%rsp),%r11d
mov    (%rsp),%r9
jne    19c0 <kernel_deriche+0x8a0>
cmpq   $0x0,0x40(%rsp)
je     195f <kernel_deriche+0x83f>
mov    0x68(%rsp),%r9
xor    %r11d,%r11d
mov    0x10(%rsp),%rax
nopl   0x0(%rax,%rax,1)
movups -0x30(%rsi,%r11,4),%xmm0
movups -0x20(%rsi,%r11,4),%xmm1
movups -0x30(%rdi,%r11,4),%xmm2
addps  %xmm0,%xmm2
movups -0x20(%rdi,%r11,4),%xmm0
addps  %xmm1,%xmm0
movups %xmm2,-0x30(%rdx,%r11,4)
movups %xmm0,-0x20(%rdx,%r11,4)
movups -0x10(%rsi,%r11,4),%xmm0
movups (%rsi,%r11,4),%xmm1
movups -0x10(%rdi,%r11,4),%xmm2
addps  %xmm0,%xmm2
movups (%rdi,%r11,4),%xmm0
addps  %xmm1,%xmm0
movups %xmm2,-0x10(%rdx,%r11,4)
movups %xmm0,(%rdx,%r11,4)
add    $0x10,%r11
add    $0xfffffffffffffffe,%r9
jne    18f0 <kernel_deriche+0x7d0>
jmp    1967 <kernel_deriche+0x847>
xor    %ecx,%ecx
mov    0x48(%rsp),%r12
mov    0x30(%rsp),%r11d
mov    (%rsp),%r9
jmp    19c0 <kernel_deriche+0x8a0>
xor    %r11d,%r11d
mov    0x10(%rsp),%rax
testb  $0x1,0x70(%rsp)
mov    (%rsp),%r9
je     199e <kernel_deriche+0x87e>
mov    0x50(%rsp),%rcx
movups (%rcx,%r11,4),%xmm0
movups 0x10(%rcx,%r11,4),%xmm1
movups (%r10,%r11,4),%xmm2
addps  %xmm0,%xmm2
movups 0x10(%r10,%r11,4),%xmm0
addps  %xmm1,%xmm0
movups %xmm2,(%rax,%r11,4)
movups %xmm0,0x10(%rax,%r11,4)
mov    0x78(%rsp),%rax
mov    %rax,%rcx
cmp    %r15,%rax
mov    0x30(%rsp),%r11d
je     1810 <kernel_deriche+0x6f0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %rcx,%rax
test   $0x1,%r15b
je     19ea <kernel_deriche+0x8ca>
mov    0x50(%rsp),%rax
movss  (%rax,%rcx,4),%xmm0
addss  (%r10,%rcx,4),%xmm0
mov    0x10(%rsp),%rax
movss  %xmm0,(%rax,%rcx,4)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0x20(%rsp),%rcx
je     1810 <kernel_deriche+0x6f0>
nopl   0x0(%rax,%rax,1)
movss  (%r14,%rax,4),%xmm0
addss  (%rbx,%rax,4),%xmm0
movss  %xmm0,-0x4(%rbp,%rax,4)
movss  0x4(%r14,%rax,4),%xmm0
addss  0x4(%rbx,%rax,4),%xmm0
movss  %xmm0,0x0(%rbp,%rax,4)
add    $0x2,%rax
cmp    %rax,%r15
jne    1a00 <kernel_deriche+0x8e0>
jmp    1810 <kernel_deriche+0x6f0>
add    $0xa8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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