void MalvarDemosaic(float *Output, const float *Input, int Width, int Height,
                    int RedX, int RedY) {
  const int BlueX = 1 - RedX;
  const int BlueY = 1 - RedY;
  float *OutputRed = Output;
  float *OutputGreen = Output + Width * Height;
  float *OutputBlue = Output + 2 * Width * Height;
  float Neigh[5][5];
  int NeighPresence[5][5];
  int i, j, x, y, nx, ny;
  for (y = 0, i = 0; y < Height; y++) {
    for (x = 0; x < Width; x++, i++) {
      for (ny = -2, j = x + Width * (y - 2); ny <= 2; ny++, j += Width) {
        for (nx = -2; nx <= 2; nx++) {
          if (0 <= x + nx && x + nx < Width && 0 <= y + ny && y + ny < Height) {
            Neigh[2 + nx][2 + ny] = Input[j + nx];
            NeighPresence[2 + nx][2 + ny] = 1;
          } else {
            Neigh[2 + nx][2 + ny] = 0;
            NeighPresence[2 + nx][2 + ny] = 0;
          }
        }
      }
      if ((x & 1) == RedX && (y & 1) == RedY) {
        OutputRed[i] = Input[i];
        OutputGreen[i] =
            (2 * (Neigh[2][1] + Neigh[1][2] + Neigh[3][2] + Neigh[2][3]) +
             (NeighPresence[0][2] + NeighPresence[4][2] + NeighPresence[2][0] +
              NeighPresence[2][4]) *
                 Neigh[2][2] -
             Neigh[0][2] - Neigh[4][2] - Neigh[2][0] - Neigh[2][4]) /
            (2 * (NeighPresence[2][1] + NeighPresence[1][2] +
                  NeighPresence[3][2] + NeighPresence[2][3]));
        OutputBlue[i] =
            (4 * (Neigh[1][1] + Neigh[3][1] + Neigh[1][3] + Neigh[3][3]) +
             3 * ((NeighPresence[0][2] + NeighPresence[4][2] +
                   NeighPresence[2][0] + NeighPresence[2][4]) *
                      Neigh[2][2] -
                  Neigh[0][2] - Neigh[4][2] - Neigh[2][0] - Neigh[2][4])) /
            (4 * (NeighPresence[1][1] + NeighPresence[3][1] +
                  NeighPresence[1][3] + NeighPresence[3][3]));
      } else if ((x & 1) == BlueX && (y & 1) == BlueY) {
        OutputBlue[i] = Input[i];
        OutputGreen[i] =
            (2 * (Neigh[2][1] + Neigh[1][2] + Neigh[3][2] + Neigh[2][3]) +
             (NeighPresence[0][2] + NeighPresence[4][2] + NeighPresence[2][0] +
              NeighPresence[2][4]) *
                 Neigh[2][2] -
             Neigh[0][2] - Neigh[4][2] - Neigh[2][0] - Neigh[2][4]) /
            (2 * (NeighPresence[2][1] + NeighPresence[1][2] +
                  NeighPresence[3][2] + NeighPresence[2][3]));
        OutputRed[i] =
            (4 * (Neigh[1][1] + Neigh[3][1] + Neigh[1][3] + Neigh[3][3]) +
             3 * ((NeighPresence[0][2] + NeighPresence[4][2] +
                   NeighPresence[2][0] + NeighPresence[2][4]) *
                      Neigh[2][2] -
                  Neigh[0][2] - Neigh[4][2] - Neigh[2][0] - Neigh[2][4])) /
            (4 * (NeighPresence[1][1] + NeighPresence[3][1] +
                  NeighPresence[1][3] + NeighPresence[3][3]));
      } else {
        OutputGreen[i] = Input[i];
        if ((y & 1) == RedY) {
          OutputRed[i] = (8 * (Neigh[1][2] + Neigh[3][2]) +
                          (2 * (NeighPresence[1][1] + NeighPresence[3][1] +
                                NeighPresence[0][2] + NeighPresence[4][2] +
                                NeighPresence[1][3] + NeighPresence[3][3]) -
                           NeighPresence[2][0] - NeighPresence[2][4]) *
                              Neigh[2][2] -
                          2 * (Neigh[1][1] + Neigh[3][1] + Neigh[0][2] +
                               Neigh[4][2] + Neigh[1][3] + Neigh[3][3]) +
                          Neigh[2][0] + Neigh[2][4]) /
                         (8 * (NeighPresence[1][2] + NeighPresence[3][2]));
          OutputBlue[i] = (8 * (Neigh[2][1] + Neigh[2][3]) +
                           (2 * (NeighPresence[1][1] + NeighPresence[3][1] +
                                 NeighPresence[2][0] + NeighPresence[2][4] +
                                 NeighPresence[1][3] + NeighPresence[3][3]) -
                            NeighPresence[0][2] - NeighPresence[4][2]) *
                               Neigh[2][2] -
                           2 * (Neigh[1][1] + Neigh[3][1] + Neigh[2][0] +
                                Neigh[2][4] + Neigh[1][3] + Neigh[3][3]) +
                           Neigh[0][2] + Neigh[4][2]) /
                          (8 * (NeighPresence[2][1] + NeighPresence[2][3]));
        } else {
          OutputRed[i] = (8 * (Neigh[2][1] + Neigh[2][3]) +
                          (2 * (NeighPresence[1][1] + NeighPresence[3][1] +
                                NeighPresence[2][0] + NeighPresence[2][4] +
                                NeighPresence[1][3] + NeighPresence[3][3]) -
                           NeighPresence[0][2] - NeighPresence[4][2]) *
                              Neigh[2][2] -
                          2 * (Neigh[1][1] + Neigh[3][1] + Neigh[2][0] +
                               Neigh[2][4] + Neigh[1][3] + Neigh[3][3]) +
                          Neigh[0][2] + Neigh[4][2]) /
                         (8 * (NeighPresence[2][1] + NeighPresence[2][3]));
          OutputBlue[i] = (8 * (Neigh[1][2] + Neigh[3][2]) +
                           (2 * (NeighPresence[1][1] + NeighPresence[3][1] +
                                 NeighPresence[0][2] + NeighPresence[4][2] +
                                 NeighPresence[1][3] + NeighPresence[3][3]) -
                            NeighPresence[2][0] - NeighPresence[2][4]) *
                               Neigh[2][2] -
                           2 * (Neigh[1][1] + Neigh[3][1] + Neigh[0][2] +
                                Neigh[4][2] + Neigh[1][3] + Neigh[3][3]) +
                           Neigh[2][0] + Neigh[2][4]) /
                          (8 * (NeighPresence[1][2] + NeighPresence[3][2]));
        }
      }
    }
  }
}


x86 assembly (clang, -O0):
<MalvarDemosaic>:
push   %rbp
mov    %rsp,%rbp
sub    $0xc0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
mov    %r9d,-0x20(%rbp)
mov    $0x1,%eax
sub    -0x1c(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    $0x1,%eax
sub    -0x20(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x18(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
shl    $0x1,%ecx
imul   -0x18(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x130(%rbp)
movl   $0x0,-0x124(%rbp)
mov    -0x130(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    19f8 <MalvarDemosaic+0x8f8>
movl   $0x0,-0x12c(%rbp)
mov    -0x12c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    19df <MalvarDemosaic+0x8df>
movl   $0xfffffffe,-0x138(%rbp)
ff ff ff
mov    -0x12c(%rbp),%eax
mov    -0x14(%rbp),%ecx
mov    -0x130(%rbp),%edx
sub    $0x2,%edx
imul   %edx,%ecx
add    %ecx,%eax
mov    %eax,-0x128(%rbp)
cmpl   $0x2,-0x138(%rbp)
jg     1362 <MalvarDemosaic+0x262>
movl   $0xfffffffe,-0x134(%rbp)
ff ff ff
cmpl   $0x2,-0x134(%rbp)
jg     133a <MalvarDemosaic+0x23a>
mov    -0x12c(%rbp),%ecx
add    -0x134(%rbp),%ecx
xor    %eax,%eax
cmp    %ecx,%eax
jg     12c6 <MalvarDemosaic+0x1c6>
mov    -0x12c(%rbp),%eax
add    -0x134(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    12c6 <MalvarDemosaic+0x1c6>
mov    -0x130(%rbp),%ecx
add    -0x138(%rbp),%ecx
xor    %eax,%eax
cmp    %ecx,%eax
jg     12c6 <MalvarDemosaic+0x1c6>
mov    -0x130(%rbp),%eax
add    -0x138(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    12c6 <MalvarDemosaic+0x1c6>
mov    -0x10(%rbp),%rax
mov    -0x128(%rbp),%ecx
add    -0x134(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x134(%rbp),%eax
add    $0x2,%eax
movslq %eax,%rcx
lea    -0xb0(%rbp),%rax
imul   $0x14,%rcx,%rcx
add    %rcx,%rax
mov    -0x138(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x134(%rbp),%eax
add    $0x2,%eax
movslq %eax,%rcx
lea    -0x120(%rbp),%rax
imul   $0x14,%rcx,%rcx
add    %rcx,%rax
mov    -0x138(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movl   $0x1,(%rax,%rcx,4)
jmp    1321 <MalvarDemosaic+0x221>
mov    -0x134(%rbp),%eax
add    $0x2,%eax
movslq %eax,%rcx
lea    -0xb0(%rbp),%rax
imul   $0x14,%rcx,%rcx
add    %rcx,%rax
mov    -0x138(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x134(%rbp),%eax
add    $0x2,%eax
movslq %eax,%rcx
lea    -0x120(%rbp),%rax
imul   $0x14,%rcx,%rcx
add    %rcx,%rax
mov    -0x138(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movl   $0x0,(%rax,%rcx,4)
jmp    1326 <MalvarDemosaic+0x226>
mov    -0x134(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x134(%rbp)
jmp    11ee <MalvarDemosaic+0xee>
jmp    133f <MalvarDemosaic+0x23f>
mov    -0x138(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x138(%rbp)
mov    -0x14(%rbp),%eax
add    -0x128(%rbp),%eax
mov    %eax,-0x128(%rbp)
jmp    11d7 <MalvarDemosaic+0xd7>
mov    -0x12c(%rbp),%eax
and    $0x1,%eax
cmp    -0x1c(%rbp),%eax
jne    14f4 <MalvarDemosaic+0x3f4>
mov    -0x130(%rbp),%eax
and    $0x1,%eax
cmp    -0x20(%rbp),%eax
jne    14f4 <MalvarDemosaic+0x3f4>
mov    -0x10(%rbp),%rax
movslq -0x124(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x124(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x84(%rbp),%xmm0
ff
addss  -0x94(%rbp),%xmm0
ff
addss  -0x6c(%rbp),%xmm0
addss  -0x7c(%rbp),%xmm0
mov    -0x118(%rbp),%eax
add    -0xc8(%rbp),%eax
add    -0xf8(%rbp),%eax
add    -0xe8(%rbp),%eax
cvtsi2ss %eax,%xmm1
mulss  -0x80(%rbp),%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
subss  -0xa8(%rbp),%xmm0
ff
subss  -0x58(%rbp),%xmm0
subss  -0x88(%rbp),%xmm0
ff
subss  -0x78(%rbp),%xmm0
mov    -0xf4(%rbp),%eax
add    -0x104(%rbp),%eax
add    -0xdc(%rbp),%eax
add    -0xec(%rbp),%eax
shl    $0x1,%eax
cvtsi2ss %eax,%xmm1
divss  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
movslq -0x124(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x98(%rbp),%xmm0
ff
addss  -0x70(%rbp),%xmm0
addss  -0x90(%rbp),%xmm0
ff
addss  -0x68(%rbp),%xmm0
mov    -0x118(%rbp),%eax
add    -0xc8(%rbp),%eax
add    -0xf8(%rbp),%eax
add    -0xe8(%rbp),%eax
cvtsi2ss %eax,%xmm2
movss  -0x80(%rbp),%xmm3
movss  -0xa8(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm3,%xmm2
addss  %xmm1,%xmm2
subss  -0x58(%rbp),%xmm2
subss  -0x88(%rbp),%xmm2
ff
subss  -0x78(%rbp),%xmm2
movss  0xb60(%rip),%xmm1
mulss  %xmm2,%xmm1
movss  0xb50(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x108(%rbp),%eax
add    -0xe0(%rbp),%eax
add    -0x100(%rbp),%eax
add    -0xd8(%rbp),%eax
shl    $0x2,%eax
cvtsi2ss %eax,%xmm1
divss  %xmm1,%xmm0
mov    -0x40(%rbp),%rax
movslq -0x124(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    19b7 <MalvarDemosaic+0x8b7>
mov    -0x12c(%rbp),%eax
and    $0x1,%eax
cmp    -0x24(%rbp),%eax
jne    1686 <MalvarDemosaic+0x586>
mov    -0x130(%rbp),%eax
and    $0x1,%eax
cmp    -0x28(%rbp),%eax
jne    1686 <MalvarDemosaic+0x586>
mov    -0x10(%rbp),%rax
movslq -0x124(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x124(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x84(%rbp),%xmm0
ff
addss  -0x94(%rbp),%xmm0
ff
addss  -0x6c(%rbp),%xmm0
addss  -0x7c(%rbp),%xmm0
mov    -0x118(%rbp),%eax
add    -0xc8(%rbp),%eax
add    -0xf8(%rbp),%eax
add    -0xe8(%rbp),%eax
cvtsi2ss %eax,%xmm1
mulss  -0x80(%rbp),%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
subss  -0xa8(%rbp),%xmm0
ff
subss  -0x58(%rbp),%xmm0
subss  -0x88(%rbp),%xmm0
ff
subss  -0x78(%rbp),%xmm0
mov    -0xf4(%rbp),%eax
add    -0x104(%rbp),%eax
add    -0xdc(%rbp),%eax
add    -0xec(%rbp),%eax
shl    $0x1,%eax
cvtsi2ss %eax,%xmm1
divss  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
movslq -0x124(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x98(%rbp),%xmm0
ff
addss  -0x70(%rbp),%xmm0
addss  -0x90(%rbp),%xmm0
ff
addss  -0x68(%rbp),%xmm0
mov    -0x118(%rbp),%eax
add    -0xc8(%rbp),%eax
add    -0xf8(%rbp),%eax
add    -0xe8(%rbp),%eax
cvtsi2ss %eax,%xmm2
movss  -0x80(%rbp),%xmm3
movss  -0xa8(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm3,%xmm2
addss  %xmm1,%xmm2
subss  -0x58(%rbp),%xmm2
subss  -0x88(%rbp),%xmm2
ff
subss  -0x78(%rbp),%xmm2
movss  0x9ce(%rip),%xmm1
mulss  %xmm2,%xmm1
movss  0x9be(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x108(%rbp),%eax
add    -0xe0(%rbp),%eax
add    -0x100(%rbp),%eax
add    -0xd8(%rbp),%eax
shl    $0x2,%eax
cvtsi2ss %eax,%xmm1
divss  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
movslq -0x124(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    19b2 <MalvarDemosaic+0x8b2>
mov    -0x10(%rbp),%rax
movslq -0x124(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x124(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x130(%rbp),%eax
and    $0x1,%eax
cmp    -0x20(%rbp),%eax
jne    1835 <MalvarDemosaic+0x735>
movss  -0x94(%rbp),%xmm0
ff
addss  -0x6c(%rbp),%xmm0
mov    -0x108(%rbp),%eax
add    -0xe0(%rbp),%eax
add    -0x118(%rbp),%eax
add    -0xc8(%rbp),%eax
add    -0x100(%rbp),%eax
add    -0xd8(%rbp),%eax
shl    $0x1,%eax
sub    -0xf8(%rbp),%eax
sub    -0xe8(%rbp),%eax
cvtsi2ss %eax,%xmm1
mulss  -0x80(%rbp),%xmm1
movss  0x8f7(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x98(%rbp),%xmm1
ff
addss  -0x70(%rbp),%xmm1
addss  -0xa8(%rbp),%xmm1
ff
addss  -0x58(%rbp),%xmm1
addss  -0x90(%rbp),%xmm1
ff
addss  -0x68(%rbp),%xmm1
addss  %xmm1,%xmm1
subss  %xmm1,%xmm0
addss  -0x88(%rbp),%xmm0
ff
addss  -0x78(%rbp),%xmm0
mov    -0x104(%rbp),%eax
add    -0xdc(%rbp),%eax
shl    $0x3,%eax
cvtsi2ss %eax,%xmm1
divss  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
movslq -0x124(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x84(%rbp),%xmm0
ff
addss  -0x7c(%rbp),%xmm0
mov    -0x108(%rbp),%eax
add    -0xe0(%rbp),%eax
add    -0xf8(%rbp),%eax
add    -0xe8(%rbp),%eax
add    -0x100(%rbp),%eax
add    -0xd8(%rbp),%eax
shl    $0x1,%eax
sub    -0x118(%rbp),%eax
sub    -0xc8(%rbp),%eax
cvtsi2ss %eax,%xmm1
mulss  -0x80(%rbp),%xmm1
movss  0x83b(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x98(%rbp),%xmm1
ff
addss  -0x70(%rbp),%xmm1
addss  -0x88(%rbp),%xmm1
ff
addss  -0x78(%rbp),%xmm1
addss  -0x90(%rbp),%xmm1
ff
addss  -0x68(%rbp),%xmm1
addss  %xmm1,%xmm1
subss  %xmm1,%xmm0
addss  -0xa8(%rbp),%xmm0
ff
addss  -0x58(%rbp),%xmm0
mov    -0xf4(%rbp),%eax
add    -0xec(%rbp),%eax
shl    $0x3,%eax
cvtsi2ss %eax,%xmm1
divss  %xmm1,%xmm0
mov    -0x40(%rbp),%rax
movslq -0x124(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    19ad <MalvarDemosaic+0x8ad>
movss  -0x84(%rbp),%xmm0
ff
addss  -0x7c(%rbp),%xmm0
mov    -0x108(%rbp),%eax
add    -0xe0(%rbp),%eax
add    -0xf8(%rbp),%eax
add    -0xe8(%rbp),%eax
add    -0x100(%rbp),%eax
add    -0xd8(%rbp),%eax
shl    $0x1,%eax
sub    -0x118(%rbp),%eax
sub    -0xc8(%rbp),%eax
cvtsi2ss %eax,%xmm1
mulss  -0x80(%rbp),%xmm1
movss  0x77a(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x98(%rbp),%xmm1
ff
addss  -0x70(%rbp),%xmm1
addss  -0x88(%rbp),%xmm1
ff
addss  -0x78(%rbp),%xmm1
addss  -0x90(%rbp),%xmm1
ff
addss  -0x68(%rbp),%xmm1
addss  %xmm1,%xmm1
subss  %xmm1,%xmm0
addss  -0xa8(%rbp),%xmm0
ff
addss  -0x58(%rbp),%xmm0
mov    -0xf4(%rbp),%eax
add    -0xec(%rbp),%eax
shl    $0x3,%eax
cvtsi2ss %eax,%xmm1
divss  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
movslq -0x124(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x94(%rbp),%xmm0
ff
addss  -0x6c(%rbp),%xmm0
mov    -0x108(%rbp),%eax
add    -0xe0(%rbp),%eax
add    -0x118(%rbp),%eax
add    -0xc8(%rbp),%eax
add    -0x100(%rbp),%eax
add    -0xd8(%rbp),%eax
shl    $0x1,%eax
sub    -0xf8(%rbp),%eax
sub    -0xe8(%rbp),%eax
cvtsi2ss %eax,%xmm1
mulss  -0x80(%rbp),%xmm1
movss  0x6be(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x98(%rbp),%xmm1
ff
addss  -0x70(%rbp),%xmm1
addss  -0xa8(%rbp),%xmm1
ff
addss  -0x58(%rbp),%xmm1
addss  -0x90(%rbp),%xmm1
ff
addss  -0x68(%rbp),%xmm1
addss  %xmm1,%xmm1
subss  %xmm1,%xmm0
addss  -0x88(%rbp),%xmm0
ff
addss  -0x78(%rbp),%xmm0
mov    -0x104(%rbp),%eax
add    -0xdc(%rbp),%eax
shl    $0x3,%eax
cvtsi2ss %eax,%xmm1
divss  %xmm1,%xmm0
mov    -0x40(%rbp),%rax
movslq -0x124(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    19b2 <MalvarDemosaic+0x8b2>
jmp    19b7 <MalvarDemosaic+0x8b7>
jmp    19bc <MalvarDemosaic+0x8bc>
mov    -0x12c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x12c(%rbp)
mov    -0x124(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x124(%rbp)
jmp    11a1 <MalvarDemosaic+0xa1>
jmp    19e4 <MalvarDemosaic+0x8e4>
mov    -0x130(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x130(%rbp)
jmp    1188 <MalvarDemosaic+0x88>
add    $0xc0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<MalvarDemosaic>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xa8,%rsp
mov    %r9d,-0x80(%rsp)
mov    %r8d,-0x6c(%rsp)
mov    %rsi,0x80(%rsp)
mov    %rdi,-0x78(%rsp)
test   %ecx,%ecx
jle    17f5 <MalvarDemosaic+0x6f5>
mov    $0x1,%eax
mov    $0x1,%esi
sub    -0x6c(%rsp),%esi
mov    %esi,0x94(%rsp)
sub    -0x80(%rsp),%eax
mov    %eax,0x90(%rsp)
mov    %ecx,%eax
imul   %edx,%ecx
movslq %ecx,%rcx
mov    -0x78(%rsp),%rsi
lea    (%rsi,%rcx,4),%rdi
mov    %rdi,0x78(%rsp)
add    %ecx,%ecx
movslq %ecx,%rcx
lea    (%rsi,%rcx,4),%rcx
mov    %rcx,-0x68(%rsp)
movslq %edx,%rcx
lea    (%rcx,%rcx,1),%esi
neg    %esi
mov    %ecx,%edi
mov    %rdi,0xa0(%rsp)
lea    0x0(,%rcx,4),%rbx
xor    %edi,%edi
mov    $0xfffffffffffffffe,%r15
movss  0xe64(%rip),%xmm9
movss  0xe5f(%rip),%xmm10
movss  0xe4e(%rip),%xmm8
xor    %r13d,%r13d
mov    %edx,0x88(%rsp)
jmp    11e9 <MalvarDemosaic+0xe9>
xchg   %ax,%ax
mov    0x88(%rsp),%edx
mov    0x8c(%rsp),%esi
mov    0x98(%rsp),%rdi
add    $0x1,%rdi
add    %edx,%esi
add    $0x1,%r15
cmp    %rax,%rdi
je     17f5 <MalvarDemosaic+0x6f5>
test   %edx,%edx
jle    11d6 <MalvarDemosaic+0xd6>
mov    %rdi,0x98(%rsp)
mov    %edi,%edx
and    $0x1,%edx
mov    %edx,-0x7c(%rsp)
movslq %r13d,%r13
xor    %r14d,%r14d
mov    %esi,0x8c(%rsp)
jmp    1324 <MalvarDemosaic+0x224>
mov    0x80(%rsp),%rdx
movss  (%rdx,%r13,4),%xmm0
mov    -0x78(%rsp),%rdx
movss  %xmm0,(%rdx,%r13,4)
movss  -0x34(%rsp),%xmm0
addss  -0x44(%rsp),%xmm0
addss  -0x1c(%rsp),%xmm0
addss  -0x2c(%rsp),%xmm0
mov    0x68(%rsp),%edx
add    0x18(%rsp),%edx
add    0x38(%rsp),%edx
add    0x48(%rsp),%edx
cvtsi2ss %edx,%xmm2
mov    0x2c(%rsp),%edx
mulss  -0x30(%rsp),%xmm2
addss  %xmm0,%xmm0
addss  %xmm2,%xmm0
movss  -0x58(%rsp),%xmm4
movss  -0x38(%rsp),%xmm1
subss  %xmm4,%xmm0
movss  -0x8(%rsp),%xmm5
subss  %xmm5,%xmm0
subss  %xmm1,%xmm0
movss  -0x28(%rsp),%xmm6
add    0x3c(%rsp),%edx
add    0x54(%rsp),%edx
subss  %xmm6,%xmm0
add    0x44(%rsp),%edx
add    %edx,%edx
cvtsi2ss %edx,%xmm3
divss  %xmm3,%xmm0
mov    0x78(%rsp),%rdx
movss  %xmm0,(%rdx,%r13,4)
movss  -0x48(%rsp),%xmm3
addss  -0x20(%rsp),%xmm3
addss  -0x40(%rsp),%xmm3
addss  -0x18(%rsp),%xmm3
subss  %xmm4,%xmm2
subss  %xmm5,%xmm2
subss  %xmm1,%xmm2
subss  %xmm6,%xmm2
mulss  %xmm9,%xmm2
mulss  %xmm10,%xmm3
mov    0x50(%rsp),%edi
add    0x28(%rsp),%edi
add    0x30(%rsp),%edi
addss  %xmm2,%xmm3
add    0x58(%rsp),%edi
shl    $0x2,%edi
mov    -0x68(%rsp),%rdx
xorps  %xmm0,%xmm0
cvtsi2ss %edi,%xmm0
divss  %xmm0,%xmm3
movss  %xmm3,(%rdx,%r13,4)
add    $0x1,%r13
add    $0x1,%esi
cmp    0xa0(%rsp),%r14
je     11c0 <MalvarDemosaic+0xc0>
mov    %r14,%r11
movslq %esi,%rdx
mov    0x80(%rsp),%rdi
lea    (%rdi,%rdx,4),%r9
add    $0x1,%r14
lea    0x2(%r11),%r8
xor    %edi,%edi
jmp    136c <MalvarDemosaic+0x26c>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  %xmm0,-0x10(%rsp,%rdi,4)
mov    %r10d,0x60(%rsp,%rdi,4)
add    %rbx,%r9
add    $0x1,%rdi
cmp    $0x5,%rdi
je     1440 <MalvarDemosaic+0x340>
lea    (%r15,%rdi,1),%r12
xor    %ebp,%ebp
xorps  %xmm0,%xmm0
xorps  %xmm1,%xmm1
mov    $0x0,%edx
cmp    $0x2,%r11
jb     139b <MalvarDemosaic+0x29b>
xorps  %xmm1,%xmm1
mov    $0x0,%edx
cmp    %rax,%r12
jae    139b <MalvarDemosaic+0x29b>
movss  -0x8(%r9),%xmm1
mov    $0x1,%edx
movss  %xmm1,-0x60(%rsp,%rdi,4)
mov    %edx,0x10(%rsp,%rdi,4)
test   %r11,%r11
je     13ba <MalvarDemosaic+0x2ba>
cmp    %rax,%r12
jae    13ba <MalvarDemosaic+0x2ba>
movss  -0x4(%r9),%xmm0
mov    $0x1,%ebp
movss  %xmm0,-0x4c(%rsp,%rdi,4)
mov    %ebp,0x24(%rsp,%rdi,4)
cmp    %rax,%r12
jb     13e0 <MalvarDemosaic+0x2e0>
movl   $0x0,-0x38(%rsp,%rdi,4)
movl   $0x0,0x38(%rsp,%rdi,4)
xor    %ebp,%ebp
xorps  %xmm0,%xmm0
jmp    140d <MalvarDemosaic+0x30d>
xor    %ebp,%ebp
movss  (%r9),%xmm0
movss  %xmm0,-0x38(%rsp,%rdi,4)
movl   $0x1,0x38(%rsp,%rdi,4)
xorps  %xmm0,%xmm0
cmp    %rcx,%r14
jge    140d <MalvarDemosaic+0x30d>
cmp    %rax,%r12
jae    140d <MalvarDemosaic+0x30d>
movss  0x4(%r9),%xmm0
mov    $0x1,%ebp
xor    %r10d,%r10d
movss  %xmm0,-0x24(%rsp,%rdi,4)
mov    %ebp,0x4c(%rsp,%rdi,4)
xorps  %xmm0,%xmm0
cmp    %rcx,%r8
jge    1350 <MalvarDemosaic+0x250>
cmp    %rax,%r12
jae    1350 <MalvarDemosaic+0x250>
movss  0x8(%r9),%xmm0
mov    $0x1,%r10d
jmp    1350 <MalvarDemosaic+0x250>
and    $0x1,%r11d
cmp    -0x6c(%rsp),%r11d
jne    1459 <MalvarDemosaic+0x359>
mov    -0x7c(%rsp),%edx
cmp    -0x80(%rsp),%edx
je     1210 <MalvarDemosaic+0x110>
mov    0x80(%rsp),%rdx
movss  (%rdx,%r13,4),%xmm0
cmp    0x94(%rsp),%r11d
jne    1570 <MalvarDemosaic+0x470>
mov    -0x7c(%rsp),%edx
cmp    0x90(%rsp),%edx
jne    1570 <MalvarDemosaic+0x470>
mov    -0x68(%rsp),%rdx
movss  %xmm0,(%rdx,%r13,4)
movss  -0x34(%rsp),%xmm0
addss  -0x44(%rsp),%xmm0
addss  -0x1c(%rsp),%xmm0
addss  -0x2c(%rsp),%xmm0
mov    0x68(%rsp),%edx
add    0x18(%rsp),%edx
add    0x38(%rsp),%edx
add    0x48(%rsp),%edx
cvtsi2ss %edx,%xmm2
mov    0x2c(%rsp),%edx
mulss  -0x30(%rsp),%xmm2
addss  %xmm0,%xmm0
addss  %xmm2,%xmm0
movss  -0x58(%rsp),%xmm4
movss  -0x38(%rsp),%xmm1
subss  %xmm4,%xmm0
movss  -0x8(%rsp),%xmm5
subss  %xmm5,%xmm0
subss  %xmm1,%xmm0
movss  -0x28(%rsp),%xmm6
add    0x3c(%rsp),%edx
add    0x54(%rsp),%edx
subss  %xmm6,%xmm0
add    0x44(%rsp),%edx
add    %edx,%edx
cvtsi2ss %edx,%xmm3
divss  %xmm3,%xmm0
mov    0x78(%rsp),%rdx
movss  %xmm0,(%rdx,%r13,4)
movss  -0x48(%rsp),%xmm3
addss  -0x20(%rsp),%xmm3
addss  -0x40(%rsp),%xmm3
addss  -0x18(%rsp),%xmm3
subss  %xmm4,%xmm2
subss  %xmm5,%xmm2
subss  %xmm1,%xmm2
subss  %xmm6,%xmm2
mulss  %xmm9,%xmm2
mulss  %xmm10,%xmm3
mov    0x50(%rsp),%edi
add    0x28(%rsp),%edi
add    0x30(%rsp),%edi
addss  %xmm2,%xmm3
add    0x58(%rsp),%edi
shl    $0x2,%edi
mov    -0x78(%rsp),%rdx
jmp    12fe <MalvarDemosaic+0x1fe>
nopl   0x0(%rax,%rax,1)
mov    0x78(%rsp),%rdx
movss  %xmm0,(%rdx,%r13,4)
mov    -0x7c(%rsp),%edx
cmp    -0x80(%rsp),%edx
jne    16bc <MalvarDemosaic+0x5bc>
movss  -0x44(%rsp),%xmm3
mov    0x50(%rsp),%edi
add    0x28(%rsp),%edi
mov    0x68(%rsp),%r10d
mov    0x58(%rsp),%r8d
add    0x18(%rsp),%r10d
lea    (%r10,%rdi,1),%edx
mov    0x30(%rsp),%r11d
mov    0x38(%rsp),%r9d
add    %r11d,%edx
add    %r8d,%edx
add    %edx,%edx
mov    0x48(%rsp),%r12d
sub    %r12d,%edx
sub    %r9d,%edx
xorps  %xmm0,%xmm0
cvtsi2ss %edx,%xmm0
addss  -0x1c(%rsp),%xmm3
movss  -0x30(%rsp),%xmm7
mulss  %xmm7,%xmm0
mulss  %xmm8,%xmm3
addss  %xmm0,%xmm3
movss  -0x58(%rsp),%xmm11
movss  -0x48(%rsp),%xmm5
addss  -0x20(%rsp),%xmm5
movaps %xmm5,%xmm1
addss  %xmm11,%xmm1
movss  -0x8(%rsp),%xmm12
addss  %xmm12,%xmm1
movss  -0x40(%rsp),%xmm2
addss  %xmm2,%xmm1
movss  -0x18(%rsp),%xmm0
addss  %xmm0,%xmm1
addss  %xmm1,%xmm1
subss  %xmm1,%xmm3
movss  -0x38(%rsp),%xmm1
addss  %xmm1,%xmm3
mov    0x54(%rsp),%edx
add    0x2c(%rsp),%edx
shl    $0x3,%edx
cvtsi2ss %edx,%xmm4
movss  -0x28(%rsp),%xmm6
addss  %xmm6,%xmm3
divss  %xmm4,%xmm3
mov    -0x78(%rsp),%rdx
movss  %xmm3,(%rdx,%r13,4)
movss  -0x34(%rsp),%xmm3
addss  -0x2c(%rsp),%xmm3
add    %r11d,%edi
add    %r8d,%edi
add    %r9d,%edi
add    %r12d,%edi
add    %edi,%edi
sub    %r10d,%edi
xorps  %xmm4,%xmm4
cvtsi2ss %edi,%xmm4
mulss  %xmm7,%xmm4
mulss  %xmm8,%xmm3
addss  %xmm4,%xmm3
addss  %xmm1,%xmm5
addss  %xmm6,%xmm5
addss  %xmm2,%xmm5
addss  %xmm0,%xmm5
addss  %xmm5,%xmm5
subss  %xmm5,%xmm3
addss  %xmm11,%xmm3
addss  %xmm12,%xmm3
mov    0x44(%rsp),%edi
add    0x3c(%rsp),%edi
jmp    17ed <MalvarDemosaic+0x6ed>
movss  -0x34(%rsp),%xmm3
mov    0x50(%rsp),%edi
add    0x28(%rsp),%edi
mov    0x48(%rsp),%r10d
mov    0x18(%rsp),%r8d
mov    0x30(%rsp),%r11d
mov    0x58(%rsp),%r9d
add    0x38(%rsp),%r10d
lea    (%r10,%rdi,1),%edx
add    %r11d,%edx
add    %r9d,%edx
add    %edx,%edx
mov    0x68(%rsp),%r12d
sub    %r12d,%edx
sub    %r8d,%edx
xorps  %xmm0,%xmm0
cvtsi2ss %edx,%xmm0
addss  -0x2c(%rsp),%xmm3
movss  -0x30(%rsp),%xmm7
mulss  %xmm7,%xmm0
mulss  %xmm8,%xmm3
addss  %xmm0,%xmm3
movss  -0x58(%rsp),%xmm2
movss  -0x48(%rsp),%xmm5
addss  -0x20(%rsp),%xmm5
movss  -0x38(%rsp),%xmm11
movaps %xmm5,%xmm4
addss  %xmm11,%xmm4
movss  -0x28(%rsp),%xmm12
addss  %xmm12,%xmm4
movss  -0x40(%rsp),%xmm0
addss  %xmm0,%xmm4
movss  -0x18(%rsp),%xmm1
addss  %xmm1,%xmm4
addss  %xmm4,%xmm4
subss  %xmm4,%xmm3
addss  %xmm2,%xmm3
mov    0x44(%rsp),%edx
add    0x3c(%rsp),%edx
shl    $0x3,%edx
xorps  %xmm4,%xmm4
cvtsi2ss %edx,%xmm4
movss  -0x8(%rsp),%xmm6
addss  %xmm6,%xmm3
divss  %xmm4,%xmm3
mov    -0x78(%rsp),%rdx
movss  %xmm3,(%rdx,%r13,4)
movss  -0x44(%rsp),%xmm3
addss  -0x1c(%rsp),%xmm3
add    %r11d,%edi
add    %r9d,%edi
add    %r8d,%edi
add    %r12d,%edi
add    %edi,%edi
sub    %r10d,%edi
xorps  %xmm4,%xmm4
cvtsi2ss %edi,%xmm4
mulss  %xmm7,%xmm4
mulss  %xmm8,%xmm3
addss  %xmm4,%xmm3
addss  %xmm2,%xmm5
addss  %xmm6,%xmm5
addss  %xmm0,%xmm5
addss  %xmm1,%xmm5
addss  %xmm5,%xmm5
subss  %xmm5,%xmm3
addss  %xmm11,%xmm3
addss  %xmm12,%xmm3
mov    0x54(%rsp),%edi
add    0x2c(%rsp),%edi
shl    $0x3,%edi
jmp    12f9 <MalvarDemosaic+0x1f9>
add    $0xa8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @MalvarDemosaic(float* %0, float* %1, i32 %2, i32 %3, i32 %4, i32 %5) {
%7 = alloca float*
%8 = alloca float*
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca float*
%16 = alloca float*
%17 = alloca float*
%18 = alloca [5 x [5 x float]]
%19 = alloca [5 x [5 x i32]]
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32
%25 = alloca i32
store float* %0, float** %7
store float* %1, float** %8
store i32 %2, i32* %9
store i32 %3, i32* %10
store i32 %4, i32* %11
store i32 %5, i32* %12
%26 = load i32, i32* %11
%27 = sub nsw i32 1, %26
store i32 %27, i32* %13
%28 = load i32, i32* %12
%29 = sub nsw i32 1, %28
store i32 %29, i32* %14
%30 = load float*, float** %7
store float* %30, float** %15
%31 = load float*, float** %7
%32 = load i32, i32* %9
%33 = load i32, i32* %10
%34 = mul nsw i32 %32, %33
%35 = sext i32 %34 to i64
%36 = getelementptr inbounds float, float* %31, i64 %35
store float* %36, float** %16
%37 = load float*, float** %7
%38 = load i32, i32* %9
%39 = mul nsw i32 2, %38
%40 = load i32, i32* %10
%41 = mul nsw i32 %39, %40
%42 = sext i32 %41 to i64
%43 = getelementptr inbounds float, float* %37, i64 %42
store float* %43, float** %17
store i32 0, i32* %23
store i32 0, i32* %20
br label %44
44: ; preds = %868, %6
%45 = load i32, i32* %23
%46 = load i32, i32* %10
%47 = icmp slt i32 %45, %46
br i1 %47, label %48, label %871
48: ; preds = %44
store i32 0, i32* %22
br label %49
49: ; preds = %862, %48
%50 = load i32, i32* %22
%51 = load i32, i32* %9
%52 = icmp slt i32 %50, %51
br i1 %52, label %53, label %867
53: ; preds = %49
store i32 -2, i32* %25
%54 = load i32, i32* %22
%55 = load i32, i32* %9
%56 = load i32, i32* %23
%57 = sub nsw i32 %56, 2
%58 = mul nsw i32 %55, %57
%59 = add nsw i32 %54, %58
store i32 %59, i32* %21
br label %60
60: ; preds = %135, %53
%61 = load i32, i32* %25
%62 = icmp sle i32 %61, 2
br i1 %62, label %63, label %141
63: ; preds = %60
store i32 -2, i32* %24
br label %64
64: ; preds = %131, %63
%65 = load i32, i32* %24
%66 = icmp sle i32 %65, 2
br i1 %66, label %67, label %134
67: ; preds = %64
%68 = load i32, i32* %22
%69 = load i32, i32* %24
%70 = add nsw i32 %68, %69
%71 = icmp sle i32 0, %70
br i1 %71, label %72, label %113
72: ; preds = %67
%73 = load i32, i32* %22
%74 = load i32, i32* %24
%75 = add nsw i32 %73, %74
%76 = load i32, i32* %9
%77 = icmp slt i32 %75, %76
br i1 %77, label %78, label %113
78: ; preds = %72
%79 = load i32, i32* %23
%80 = load i32, i32* %25
%81 = add nsw i32 %79, %80
%82 = icmp sle i32 0, %81
br i1 %82, label %83, label %113
83: ; preds = %78
%84 = load i32, i32* %23
%85 = load i32, i32* %25
%86 = add nsw i32 %84, %85
%87 = load i32, i32* %10
%88 = icmp slt i32 %86, %87
br i1 %88, label %89, label %113
89: ; preds = %83
%90 = load float*, float** %8
%91 = load i32, i32* %21
%92 = load i32, i32* %24
%93 = add nsw i32 %91, %92
%94 = sext i32 %93 to i64
%95 = getelementptr inbounds float, float* %90, i64 %94
%96 = load float, float* %95
%97 = load i32, i32* %24
%98 = add nsw i32 2, %97
%99 = sext i32 %98 to i64
%100 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 %99
%101 = load i32, i32* %25
%102 = add nsw i32 2, %101
%103 = sext i32 %102 to i64
%104 = getelementptr inbounds [5 x float], [5 x float]* %100, i64 0, i64 %103
store float %96, float* %104
%105 = load i32, i32* %24
%106 = add nsw i32 2, %105
%107 = sext i32 %106 to i64
%108 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 %107
%109 = load i32, i32* %25
%110 = add nsw i32 2, %109
%111 = sext i32 %110 to i64
%112 = getelementptr inbounds [5 x i32], [5 x i32]* %108, i64 0, i64 %111
store i32 1, i32* %112
br label %130
113: ; preds = %83, %78, %72, %67
%114 = load i32, i32* %24
%115 = add nsw i32 2, %114
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 %116
%118 = load i32, i32* %25
%119 = add nsw i32 2, %118
%120 = sext i32 %119 to i64
%121 = getelementptr inbounds [5 x float], [5 x float]* %117, i64 0, i64 %120
store float 0.000000e+00, float* %121
%122 = load i32, i32* %24
%123 = add nsw i32 2, %122
%124 = sext i32 %123 to i64
%125 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 %124
%126 = load i32, i32* %25
%127 = add nsw i32 2, %126
%128 = sext i32 %127 to i64
%129 = getelementptr inbounds [5 x i32], [5 x i32]* %125, i64 0, i64 %128
store i32 0, i32* %129
br label %130
130: ; preds = %113, %89
br label %131
131: ; preds = %130
%132 = load i32, i32* %24
%133 = add nsw i32 %132, 1
store i32 %133, i32* %24
br label %64
134: ; preds = %64
br label %135
135: ; preds = %134
%136 = load i32, i32* %25
%137 = add nsw i32 %136, 1
store i32 %137, i32* %25
%138 = load i32, i32* %9
%139 = load i32, i32* %21
%140 = add nsw i32 %139, %138
store i32 %140, i32* %21
br label %60
141: ; preds = %60
%142 = load i32, i32* %22
%143 = and i32 %142, 1
%144 = load i32, i32* %11
%145 = icmp eq i32 %143, %144
br i1 %145, label %146, label %310
146: ; preds = %141
%147 = load i32, i32* %23
%148 = and i32 %147, 1
%149 = load i32, i32* %12
%150 = icmp eq i32 %148, %149
br i1 %150, label %151, label %310
151: ; preds = %146
%152 = load float*, float** %8
%153 = load i32, i32* %20
%154 = sext i32 %153 to i64
%155 = getelementptr inbounds float, float* %152, i64 %154
%156 = load float, float* %155
%157 = load float*, float** %15
%158 = load i32, i32* %20
%159 = sext i32 %158 to i64
%160 = getelementptr inbounds float, float* %157, i64 %159
store float %156, float* %160
%161 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 2
%162 = getelementptr inbounds [5 x float], [5 x float]* %161, i64 0, i64 1
%163 = load float, float* %162
%164 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 1
%165 = getelementptr inbounds [5 x float], [5 x float]* %164, i64 0, i64 2
%166 = load float, float* %165
%167 = fadd float %163, %166
%168 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 3
%169 = getelementptr inbounds [5 x float], [5 x float]* %168, i64 0, i64 2
%170 = load float, float* %169
%171 = fadd float %167, %170
%172 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 2
%173 = getelementptr inbounds [5 x float], [5 x float]* %172, i64 0, i64 3
%174 = load float, float* %173
%175 = fadd float %171, %174
%176 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 0
%177 = getelementptr inbounds [5 x i32], [5 x i32]* %176, i64 0, i64 2
%178 = load i32, i32* %177
%179 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 4
%180 = getelementptr inbounds [5 x i32], [5 x i32]* %179, i64 0, i64 2
%181 = load i32, i32* %180
%182 = add nsw i32 %178, %181
%183 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 2
%184 = getelementptr inbounds [5 x i32], [5 x i32]* %183, i64 0, i64 0
%185 = load i32, i32* %184
%186 = add nsw i32 %182, %185
%187 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 2
%188 = getelementptr inbounds [5 x i32], [5 x i32]* %187, i64 0, i64 4
%189 = load i32, i32* %188
%190 = add nsw i32 %186, %189
%191 = sitofp i32 %190 to float
%192 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 2
%193 = getelementptr inbounds [5 x float], [5 x float]* %192, i64 0, i64 2
%194 = load float, float* %193
%195 = fmul float %191, %194
%196 = call float @llvm.fmuladd.f32(float 2.000000e+00, float %175, float %195)
%197 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 0
%198 = getelementptr inbounds [5 x float], [5 x float]* %197, i64 0, i64 2
%199 = load float, float* %198
%200 = fsub float %196, %199
%201 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 4
%202 = getelementptr inbounds [5 x float], [5 x float]* %201, i64 0, i64 2
%203 = load float, float* %202
%204 = fsub float %200, %203
%205 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 2
%206 = getelementptr inbounds [5 x float], [5 x float]* %205, i64 0, i64 0
%207 = load float, float* %206
%208 = fsub float %204, %207
%209 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 2
%210 = getelementptr inbounds [5 x float], [5 x float]* %209, i64 0, i64 4
%211 = load float, float* %210
%212 = fsub float %208, %211
%213 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 2
%214 = getelementptr inbounds [5 x i32], [5 x i32]* %213, i64 0, i64 1
%215 = load i32, i32* %214
%216 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 1
%217 = getelementptr inbounds [5 x i32], [5 x i32]* %216, i64 0, i64 2
%218 = load i32, i32* %217
%219 = add nsw i32 %215, %218
%220 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 3
%221 = getelementptr inbounds [5 x i32], [5 x i32]* %220, i64 0, i64 2
%222 = load i32, i32* %221
%223 = add nsw i32 %219, %222
%224 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 2
%225 = getelementptr inbounds [5 x i32], [5 x i32]* %224, i64 0, i64 3
%226 = load i32, i32* %225
%227 = add nsw i32 %223, %226
%228 = mul nsw i32 2, %227
%229 = sitofp i32 %228 to float
%230 = fdiv float %212, %229
%231 = load float*, float** %16
%232 = load i32, i32* %20
%233 = sext i32 %232 to i64
%234 = getelementptr inbounds float, float* %231, i64 %233
store float %230, float* %234
%235 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 1
%236 = getelementptr inbounds [5 x float], [5 x float]* %235, i64 0, i64 1
%237 = load float, float* %236
%238 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 3
%239 = getelementptr inbounds [5 x float], [5 x float]* %238, i64 0, i64 1
%240 = load float, float* %239
%241 = fadd float %237, %240
%242 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 1
%243 = getelementptr inbounds [5 x float], [5 x float]* %242, i64 0, i64 3
%244 = load float, float* %243
%245 = fadd float %241, %244
%246 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 3
%247 = getelementptr inbounds [5 x float], [5 x float]* %246, i64 0, i64 3
%248 = load float, float* %247
%249 = fadd float %245, %248
%250 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 0
%251 = getelementptr inbounds [5 x i32], [5 x i32]* %250, i64 0, i64 2
%252 = load i32, i32* %251
%253 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 4
%254 = getelementptr inbounds [5 x i32], [5 x i32]* %253, i64 0, i64 2
%255 = load i32, i32* %254
%256 = add nsw i32 %252, %255
%257 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 2
%258 = getelementptr inbounds [5 x i32], [5 x i32]* %257, i64 0, i64 0
%259 = load i32, i32* %258
%260 = add nsw i32 %256, %259
%261 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 2
%262 = getelementptr inbounds [5 x i32], [5 x i32]* %261, i64 0, i64 4
%263 = load i32, i32* %262
%264 = add nsw i32 %260, %263
%265 = sitofp i32 %264 to float
%266 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 2
%267 = getelementptr inbounds [5 x float], [5 x float]* %266, i64 0, i64 2
%268 = load float, float* %267
%269 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 0
%270 = getelementptr inbounds [5 x float], [5 x float]* %269, i64 0, i64 2
%271 = load float, float* %270
%272 = fneg float %271
%273 = call float @llvm.fmuladd.f32(float %265, float %268, float %272)
%274 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 4
%275 = getelementptr inbounds [5 x float], [5 x float]* %274, i64 0, i64 2
%276 = load float, float* %275
%277 = fsub float %273, %276
%278 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 2
%279 = getelementptr inbounds [5 x float], [5 x float]* %278, i64 0, i64 0
%280 = load float, float* %279
%281 = fsub float %277, %280
%282 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 2
%283 = getelementptr inbounds [5 x float], [5 x float]* %282, i64 0, i64 4
%284 = load float, float* %283
%285 = fsub float %281, %284
%286 = fmul float 3.000000e+00, %285
%287 = call float @llvm.fmuladd.f32(float 4.000000e+00, float %249, float %286)
%288 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 1
%289 = getelementptr inbounds [5 x i32], [5 x i32]* %288, i64 0, i64 1
%290 = load i32, i32* %289
%291 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 3
%292 = getelementptr inbounds [5 x i32], [5 x i32]* %291, i64 0, i64 1
%293 = load i32, i32* %292
%294 = add nsw i32 %290, %293
%295 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 1
%296 = getelementptr inbounds [5 x i32], [5 x i32]* %295, i64 0, i64 3
%297 = load i32, i32* %296
%298 = add nsw i32 %294, %297
%299 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 3
%300 = getelementptr inbounds [5 x i32], [5 x i32]* %299, i64 0, i64 3
%301 = load i32, i32* %300
%302 = add nsw i32 %298, %301
%303 = mul nsw i32 4, %302
%304 = sitofp i32 %303 to float
%305 = fdiv float %287, %304
%306 = load float*, float** %17
%307 = load i32, i32* %20
%308 = sext i32 %307 to i64
%309 = getelementptr inbounds float, float* %306, i64 %308
store float %305, float* %309
br label %861
310: ; preds = %146, %141
%311 = load i32, i32* %22
%312 = and i32 %311, 1
%313 = load i32, i32* %13
%314 = icmp eq i32 %312, %313
br i1 %314, label %315, label %479
315: ; preds = %310
%316 = load i32, i32* %23
%317 = and i32 %316, 1
%318 = load i32, i32* %14
%319 = icmp eq i32 %317, %318
br i1 %319, label %320, label %479
320: ; preds = %315
%321 = load float*, float** %8
%322 = load i32, i32* %20
%323 = sext i32 %322 to i64
%324 = getelementptr inbounds float, float* %321, i64 %323
%325 = load float, float* %324
%326 = load float*, float** %17
%327 = load i32, i32* %20
%328 = sext i32 %327 to i64
%329 = getelementptr inbounds float, float* %326, i64 %328
store float %325, float* %329
%330 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 2
%331 = getelementptr inbounds [5 x float], [5 x float]* %330, i64 0, i64 1
%332 = load float, float* %331
%333 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 1
%334 = getelementptr inbounds [5 x float], [5 x float]* %333, i64 0, i64 2
%335 = load float, float* %334
%336 = fadd float %332, %335
%337 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 3
%338 = getelementptr inbounds [5 x float], [5 x float]* %337, i64 0, i64 2
%339 = load float, float* %338
%340 = fadd float %336, %339
%341 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 2
%342 = getelementptr inbounds [5 x float], [5 x float]* %341, i64 0, i64 3
%343 = load float, float* %342
%344 = fadd float %340, %343
%345 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 0
%346 = getelementptr inbounds [5 x i32], [5 x i32]* %345, i64 0, i64 2
%347 = load i32, i32* %346
%348 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 4
%349 = getelementptr inbounds [5 x i32], [5 x i32]* %348, i64 0, i64 2
%350 = load i32, i32* %349
%351 = add nsw i32 %347, %350
%352 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 2
%353 = getelementptr inbounds [5 x i32], [5 x i32]* %352, i64 0, i64 0
%354 = load i32, i32* %353
%355 = add nsw i32 %351, %354
%356 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 2
%357 = getelementptr inbounds [5 x i32], [5 x i32]* %356, i64 0, i64 4
%358 = load i32, i32* %357
%359 = add nsw i32 %355, %358
%360 = sitofp i32 %359 to float
%361 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 2
%362 = getelementptr inbounds [5 x float], [5 x float]* %361, i64 0, i64 2
%363 = load float, float* %362
%364 = fmul float %360, %363
%365 = call float @llvm.fmuladd.f32(float 2.000000e+00, float %344, float %364)
%366 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 0
%367 = getelementptr inbounds [5 x float], [5 x float]* %366, i64 0, i64 2
%368 = load float, float* %367
%369 = fsub float %365, %368
%370 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 4
%371 = getelementptr inbounds [5 x float], [5 x float]* %370, i64 0, i64 2
%372 = load float, float* %371
%373 = fsub float %369, %372
%374 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 2
%375 = getelementptr inbounds [5 x float], [5 x float]* %374, i64 0, i64 0
%376 = load float, float* %375
%377 = fsub float %373, %376
%378 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 2
%379 = getelementptr inbounds [5 x float], [5 x float]* %378, i64 0, i64 4
%380 = load float, float* %379
%381 = fsub float %377, %380
%382 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 2
%383 = getelementptr inbounds [5 x i32], [5 x i32]* %382, i64 0, i64 1
%384 = load i32, i32* %383
%385 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 1
%386 = getelementptr inbounds [5 x i32], [5 x i32]* %385, i64 0, i64 2
%387 = load i32, i32* %386
%388 = add nsw i32 %384, %387
%389 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 3
%390 = getelementptr inbounds [5 x i32], [5 x i32]* %389, i64 0, i64 2
%391 = load i32, i32* %390
%392 = add nsw i32 %388, %391
%393 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 2
%394 = getelementptr inbounds [5 x i32], [5 x i32]* %393, i64 0, i64 3
%395 = load i32, i32* %394
%396 = add nsw i32 %392, %395
%397 = mul nsw i32 2, %396
%398 = sitofp i32 %397 to float
%399 = fdiv float %381, %398
%400 = load float*, float** %16
%401 = load i32, i32* %20
%402 = sext i32 %401 to i64
%403 = getelementptr inbounds float, float* %400, i64 %402
store float %399, float* %403
%404 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 1
%405 = getelementptr inbounds [5 x float], [5 x float]* %404, i64 0, i64 1
%406 = load float, float* %405
%407 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 3
%408 = getelementptr inbounds [5 x float], [5 x float]* %407, i64 0, i64 1
%409 = load float, float* %408
%410 = fadd float %406, %409
%411 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 1
%412 = getelementptr inbounds [5 x float], [5 x float]* %411, i64 0, i64 3
%413 = load float, float* %412
%414 = fadd float %410, %413
%415 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 3
%416 = getelementptr inbounds [5 x float], [5 x float]* %415, i64 0, i64 3
%417 = load float, float* %416
%418 = fadd float %414, %417
%419 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 0
%420 = getelementptr inbounds [5 x i32], [5 x i32]* %419, i64 0, i64 2
%421 = load i32, i32* %420
%422 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 4
%423 = getelementptr inbounds [5 x i32], [5 x i32]* %422, i64 0, i64 2
%424 = load i32, i32* %423
%425 = add nsw i32 %421, %424
%426 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 2
%427 = getelementptr inbounds [5 x i32], [5 x i32]* %426, i64 0, i64 0
%428 = load i32, i32* %427
%429 = add nsw i32 %425, %428
%430 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 2
%431 = getelementptr inbounds [5 x i32], [5 x i32]* %430, i64 0, i64 4
%432 = load i32, i32* %431
%433 = add nsw i32 %429, %432
%434 = sitofp i32 %433 to float
%435 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 2
%436 = getelementptr inbounds [5 x float], [5 x float]* %435, i64 0, i64 2
%437 = load float, float* %436
%438 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 0
%439 = getelementptr inbounds [5 x float], [5 x float]* %438, i64 0, i64 2
%440 = load float, float* %439
%441 = fneg float %440
%442 = call float @llvm.fmuladd.f32(float %434, float %437, float %441)
%443 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 4
%444 = getelementptr inbounds [5 x float], [5 x float]* %443, i64 0, i64 2
%445 = load float, float* %444
%446 = fsub float %442, %445
%447 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 2
%448 = getelementptr inbounds [5 x float], [5 x float]* %447, i64 0, i64 0
%449 = load float, float* %448
%450 = fsub float %446, %449
%451 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 2
%452 = getelementptr inbounds [5 x float], [5 x float]* %451, i64 0, i64 4
%453 = load float, float* %452
%454 = fsub float %450, %453
%455 = fmul float 3.000000e+00, %454
%456 = call float @llvm.fmuladd.f32(float 4.000000e+00, float %418, float %455)
%457 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 1
%458 = getelementptr inbounds [5 x i32], [5 x i32]* %457, i64 0, i64 1
%459 = load i32, i32* %458
%460 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 3
%461 = getelementptr inbounds [5 x i32], [5 x i32]* %460, i64 0, i64 1
%462 = load i32, i32* %461
%463 = add nsw i32 %459, %462
%464 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 1
%465 = getelementptr inbounds [5 x i32], [5 x i32]* %464, i64 0, i64 3
%466 = load i32, i32* %465
%467 = add nsw i32 %463, %466
%468 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 3
%469 = getelementptr inbounds [5 x i32], [5 x i32]* %468, i64 0, i64 3
%470 = load i32, i32* %469
%471 = add nsw i32 %467, %470
%472 = mul nsw i32 4, %471
%473 = sitofp i32 %472 to float
%474 = fdiv float %456, %473
%475 = load float*, float** %15
%476 = load i32, i32* %20
%477 = sext i32 %476 to i64
%478 = getelementptr inbounds float, float* %475, i64 %477
store float %474, float* %478
br label %860
479: ; preds = %315, %310
%480 = load float*, float** %8
%481 = load i32, i32* %20
%482 = sext i32 %481 to i64
%483 = getelementptr inbounds float, float* %480, i64 %482
%484 = load float, float* %483
%485 = load float*, float** %16
%486 = load i32, i32* %20
%487 = sext i32 %486 to i64
%488 = getelementptr inbounds float, float* %485, i64 %487
store float %484, float* %488
%489 = load i32, i32* %23
%490 = and i32 %489, 1
%491 = load i32, i32* %12
%492 = icmp eq i32 %490, %491
br i1 %492, label %493, label %676
493: ; preds = %479
%494 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 1
%495 = getelementptr inbounds [5 x float], [5 x float]* %494, i64 0, i64 2
%496 = load float, float* %495
%497 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 3
%498 = getelementptr inbounds [5 x float], [5 x float]* %497, i64 0, i64 2
%499 = load float, float* %498
%500 = fadd float %496, %499
%501 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 1
%502 = getelementptr inbounds [5 x i32], [5 x i32]* %501, i64 0, i64 1
%503 = load i32, i32* %502
%504 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 3
%505 = getelementptr inbounds [5 x i32], [5 x i32]* %504, i64 0, i64 1
%506 = load i32, i32* %505
%507 = add nsw i32 %503, %506
%508 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 0
%509 = getelementptr inbounds [5 x i32], [5 x i32]* %508, i64 0, i64 2
%510 = load i32, i32* %509
%511 = add nsw i32 %507, %510
%512 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 4
%513 = getelementptr inbounds [5 x i32], [5 x i32]* %512, i64 0, i64 2
%514 = load i32, i32* %513
%515 = add nsw i32 %511, %514
%516 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 1
%517 = getelementptr inbounds [5 x i32], [5 x i32]* %516, i64 0, i64 3
%518 = load i32, i32* %517
%519 = add nsw i32 %515, %518
%520 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 3
%521 = getelementptr inbounds [5 x i32], [5 x i32]* %520, i64 0, i64 3
%522 = load i32, i32* %521
%523 = add nsw i32 %519, %522
%524 = mul nsw i32 2, %523
%525 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 2
%526 = getelementptr inbounds [5 x i32], [5 x i32]* %525, i64 0, i64 0
%527 = load i32, i32* %526
%528 = sub nsw i32 %524, %527
%529 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 2
%530 = getelementptr inbounds [5 x i32], [5 x i32]* %529, i64 0, i64 4
%531 = load i32, i32* %530
%532 = sub nsw i32 %528, %531
%533 = sitofp i32 %532 to float
%534 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 2
%535 = getelementptr inbounds [5 x float], [5 x float]* %534, i64 0, i64 2
%536 = load float, float* %535
%537 = fmul float %533, %536
%538 = call float @llvm.fmuladd.f32(float 8.000000e+00, float %500, float %537)
%539 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 1
%540 = getelementptr inbounds [5 x float], [5 x float]* %539, i64 0, i64 1
%541 = load float, float* %540
%542 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 3
%543 = getelementptr inbounds [5 x float], [5 x float]* %542, i64 0, i64 1
%544 = load float, float* %543
%545 = fadd float %541, %544
%546 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 0
%547 = getelementptr inbounds [5 x float], [5 x float]* %546, i64 0, i64 2
%548 = load float, float* %547
%549 = fadd float %545, %548
%550 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 4
%551 = getelementptr inbounds [5 x float], [5 x float]* %550, i64 0, i64 2
%552 = load float, float* %551
%553 = fadd float %549, %552
%554 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 1
%555 = getelementptr inbounds [5 x float], [5 x float]* %554, i64 0, i64 3
%556 = load float, float* %555
%557 = fadd float %553, %556
%558 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 3
%559 = getelementptr inbounds [5 x float], [5 x float]* %558, i64 0, i64 3
%560 = load float, float* %559
%561 = fadd float %557, %560
%562 = call float @llvm.fmuladd.f32(float -2.000000e+00, float %561, float %538)
%563 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 2
%564 = getelementptr inbounds [5 x float], [5 x float]* %563, i64 0, i64 0
%565 = load float, float* %564
%566 = fadd float %562, %565
%567 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 2
%568 = getelementptr inbounds [5 x float], [5 x float]* %567, i64 0, i64 4
%569 = load float, float* %568
%570 = fadd float %566, %569
%571 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 1
%572 = getelementptr inbounds [5 x i32], [5 x i32]* %571, i64 0, i64 2
%573 = load i32, i32* %572
%574 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 3
%575 = getelementptr inbounds [5 x i32], [5 x i32]* %574, i64 0, i64 2
%576 = load i32, i32* %575
%577 = add nsw i32 %573, %576
%578 = mul nsw i32 8, %577
%579 = sitofp i32 %578 to float
%580 = fdiv float %570, %579
%581 = load float*, float** %15
%582 = load i32, i32* %20
%583 = sext i32 %582 to i64
%584 = getelementptr inbounds float, float* %581, i64 %583
store float %580, float* %584
%585 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 2
%586 = getelementptr inbounds [5 x float], [5 x float]* %585, i64 0, i64 1
%587 = load float, float* %586
%588 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 2
%589 = getelementptr inbounds [5 x float], [5 x float]* %588, i64 0, i64 3
%590 = load float, float* %589
%591 = fadd float %587, %590
%592 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 1
%593 = getelementptr inbounds [5 x i32], [5 x i32]* %592, i64 0, i64 1
%594 = load i32, i32* %593
%595 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 3
%596 = getelementptr inbounds [5 x i32], [5 x i32]* %595, i64 0, i64 1
%597 = load i32, i32* %596
%598 = add nsw i32 %594, %597
%599 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 2
%600 = getelementptr inbounds [5 x i32], [5 x i32]* %599, i64 0, i64 0
%601 = load i32, i32* %600
%602 = add nsw i32 %598, %601
%603 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 2
%604 = getelementptr inbounds [5 x i32], [5 x i32]* %603, i64 0, i64 4
%605 = load i32, i32* %604
%606 = add nsw i32 %602, %605
%607 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 1
%608 = getelementptr inbounds [5 x i32], [5 x i32]* %607, i64 0, i64 3
%609 = load i32, i32* %608
%610 = add nsw i32 %606, %609
%611 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 3
%612 = getelementptr inbounds [5 x i32], [5 x i32]* %611, i64 0, i64 3
%613 = load i32, i32* %612
%614 = add nsw i32 %610, %613
%615 = mul nsw i32 2, %614
%616 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 0
%617 = getelementptr inbounds [5 x i32], [5 x i32]* %616, i64 0, i64 2
%618 = load i32, i32* %617
%619 = sub nsw i32 %615, %618
%620 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 4
%621 = getelementptr inbounds [5 x i32], [5 x i32]* %620, i64 0, i64 2
%622 = load i32, i32* %621
%623 = sub nsw i32 %619, %622
%624 = sitofp i32 %623 to float
%625 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 2
%626 = getelementptr inbounds [5 x float], [5 x float]* %625, i64 0, i64 2
%627 = load float, float* %626
%628 = fmul float %624, %627
%629 = call float @llvm.fmuladd.f32(float 8.000000e+00, float %591, float %628)
%630 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 1
%631 = getelementptr inbounds [5 x float], [5 x float]* %630, i64 0, i64 1
%632 = load float, float* %631
%633 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 3
%634 = getelementptr inbounds [5 x float], [5 x float]* %633, i64 0, i64 1
%635 = load float, float* %634
%636 = fadd float %632, %635
%637 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 2
%638 = getelementptr inbounds [5 x float], [5 x float]* %637, i64 0, i64 0
%639 = load float, float* %638
%640 = fadd float %636, %639
%641 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 2
%642 = getelementptr inbounds [5 x float], [5 x float]* %641, i64 0, i64 4
%643 = load float, float* %642
%644 = fadd float %640, %643
%645 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 1
%646 = getelementptr inbounds [5 x float], [5 x float]* %645, i64 0, i64 3
%647 = load float, float* %646
%648 = fadd float %644, %647
%649 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 3
%650 = getelementptr inbounds [5 x float], [5 x float]* %649, i64 0, i64 3
%651 = load float, float* %650
%652 = fadd float %648, %651
%653 = call float @llvm.fmuladd.f32(float -2.000000e+00, float %652, float %629)
%654 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 0
%655 = getelementptr inbounds [5 x float], [5 x float]* %654, i64 0, i64 2
%656 = load float, float* %655
%657 = fadd float %653, %656
%658 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 4
%659 = getelementptr inbounds [5 x float], [5 x float]* %658, i64 0, i64 2
%660 = load float, float* %659
%661 = fadd float %657, %660
%662 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 2
%663 = getelementptr inbounds [5 x i32], [5 x i32]* %662, i64 0, i64 1
%664 = load i32, i32* %663
%665 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 2
%666 = getelementptr inbounds [5 x i32], [5 x i32]* %665, i64 0, i64 3
%667 = load i32, i32* %666
%668 = add nsw i32 %664, %667
%669 = mul nsw i32 8, %668
%670 = sitofp i32 %669 to float
%671 = fdiv float %661, %670
%672 = load float*, float** %17
%673 = load i32, i32* %20
%674 = sext i32 %673 to i64
%675 = getelementptr inbounds float, float* %672, i64 %674
store float %671, float* %675
br label %859
676: ; preds = %479
%677 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 2
%678 = getelementptr inbounds [5 x float], [5 x float]* %677, i64 0, i64 1
%679 = load float, float* %678
%680 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 2
%681 = getelementptr inbounds [5 x float], [5 x float]* %680, i64 0, i64 3
%682 = load float, float* %681
%683 = fadd float %679, %682
%684 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 1
%685 = getelementptr inbounds [5 x i32], [5 x i32]* %684, i64 0, i64 1
%686 = load i32, i32* %685
%687 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 3
%688 = getelementptr inbounds [5 x i32], [5 x i32]* %687, i64 0, i64 1
%689 = load i32, i32* %688
%690 = add nsw i32 %686, %689
%691 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 2
%692 = getelementptr inbounds [5 x i32], [5 x i32]* %691, i64 0, i64 0
%693 = load i32, i32* %692
%694 = add nsw i32 %690, %693
%695 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 2
%696 = getelementptr inbounds [5 x i32], [5 x i32]* %695, i64 0, i64 4
%697 = load i32, i32* %696
%698 = add nsw i32 %694, %697
%699 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 1
%700 = getelementptr inbounds [5 x i32], [5 x i32]* %699, i64 0, i64 3
%701 = load i32, i32* %700
%702 = add nsw i32 %698, %701
%703 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 3
%704 = getelementptr inbounds [5 x i32], [5 x i32]* %703, i64 0, i64 3
%705 = load i32, i32* %704
%706 = add nsw i32 %702, %705
%707 = mul nsw i32 2, %706
%708 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 0
%709 = getelementptr inbounds [5 x i32], [5 x i32]* %708, i64 0, i64 2
%710 = load i32, i32* %709
%711 = sub nsw i32 %707, %710
%712 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 4
%713 = getelementptr inbounds [5 x i32], [5 x i32]* %712, i64 0, i64 2
%714 = load i32, i32* %713
%715 = sub nsw i32 %711, %714
%716 = sitofp i32 %715 to float
%717 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 2
%718 = getelementptr inbounds [5 x float], [5 x float]* %717, i64 0, i64 2
%719 = load float, float* %718
%720 = fmul float %716, %719
%721 = call float @llvm.fmuladd.f32(float 8.000000e+00, float %683, float %720)
%722 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 1
%723 = getelementptr inbounds [5 x float], [5 x float]* %722, i64 0, i64 1
%724 = load float, float* %723
%725 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 3
%726 = getelementptr inbounds [5 x float], [5 x float]* %725, i64 0, i64 1
%727 = load float, float* %726
%728 = fadd float %724, %727
%729 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 2
%730 = getelementptr inbounds [5 x float], [5 x float]* %729, i64 0, i64 0
%731 = load float, float* %730
%732 = fadd float %728, %731
%733 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 2
%734 = getelementptr inbounds [5 x float], [5 x float]* %733, i64 0, i64 4
%735 = load float, float* %734
%736 = fadd float %732, %735
%737 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 1
%738 = getelementptr inbounds [5 x float], [5 x float]* %737, i64 0, i64 3
%739 = load float, float* %738
%740 = fadd float %736, %739
%741 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 3
%742 = getelementptr inbounds [5 x float], [5 x float]* %741, i64 0, i64 3
%743 = load float, float* %742
%744 = fadd float %740, %743
%745 = call float @llvm.fmuladd.f32(float -2.000000e+00, float %744, float %721)
%746 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 0
%747 = getelementptr inbounds [5 x float], [5 x float]* %746, i64 0, i64 2
%748 = load float, float* %747
%749 = fadd float %745, %748
%750 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 4
%751 = getelementptr inbounds [5 x float], [5 x float]* %750, i64 0, i64 2
%752 = load float, float* %751
%753 = fadd float %749, %752
%754 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 2
%755 = getelementptr inbounds [5 x i32], [5 x i32]* %754, i64 0, i64 1
%756 = load i32, i32* %755
%757 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 2
%758 = getelementptr inbounds [5 x i32], [5 x i32]* %757, i64 0, i64 3
%759 = load i32, i32* %758
%760 = add nsw i32 %756, %759
%761 = mul nsw i32 8, %760
%762 = sitofp i32 %761 to float
%763 = fdiv float %753, %762
%764 = load float*, float** %15
%765 = load i32, i32* %20
%766 = sext i32 %765 to i64
%767 = getelementptr inbounds float, float* %764, i64 %766
store float %763, float* %767
%768 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 1
%769 = getelementptr inbounds [5 x float], [5 x float]* %768, i64 0, i64 2
%770 = load float, float* %769
%771 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 3
%772 = getelementptr inbounds [5 x float], [5 x float]* %771, i64 0, i64 2
%773 = load float, float* %772
%774 = fadd float %770, %773
%775 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 1
%776 = getelementptr inbounds [5 x i32], [5 x i32]* %775, i64 0, i64 1
%777 = load i32, i32* %776
%778 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 3
%779 = getelementptr inbounds [5 x i32], [5 x i32]* %778, i64 0, i64 1
%780 = load i32, i32* %779
%781 = add nsw i32 %777, %780
%782 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 0
%783 = getelementptr inbounds [5 x i32], [5 x i32]* %782, i64 0, i64 2
%784 = load i32, i32* %783
%785 = add nsw i32 %781, %784
%786 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 4
%787 = getelementptr inbounds [5 x i32], [5 x i32]* %786, i64 0, i64 2
%788 = load i32, i32* %787
%789 = add nsw i32 %785, %788
%790 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 1
%791 = getelementptr inbounds [5 x i32], [5 x i32]* %790, i64 0, i64 3
%792 = load i32, i32* %791
%793 = add nsw i32 %789, %792
%794 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 3
%795 = getelementptr inbounds [5 x i32], [5 x i32]* %794, i64 0, i64 3
%796 = load i32, i32* %795
%797 = add nsw i32 %793, %796
%798 = mul nsw i32 2, %797
%799 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 2
%800 = getelementptr inbounds [5 x i32], [5 x i32]* %799, i64 0, i64 0
%801 = load i32, i32* %800
%802 = sub nsw i32 %798, %801
%803 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 2
%804 = getelementptr inbounds [5 x i32], [5 x i32]* %803, i64 0, i64 4
%805 = load i32, i32* %804
%806 = sub nsw i32 %802, %805
%807 = sitofp i32 %806 to float
%808 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 2
%809 = getelementptr inbounds [5 x float], [5 x float]* %808, i64 0, i64 2
%810 = load float, float* %809
%811 = fmul float %807, %810
%812 = call float @llvm.fmuladd.f32(float 8.000000e+00, float %774, float %811)
%813 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 1
%814 = getelementptr inbounds [5 x float], [5 x float]* %813, i64 0, i64 1
%815 = load float, float* %814
%816 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 3
%817 = getelementptr inbounds [5 x float], [5 x float]* %816, i64 0, i64 1
%818 = load float, float* %817
%819 = fadd float %815, %818
%820 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 0
%821 = getelementptr inbounds [5 x float], [5 x float]* %820, i64 0, i64 2
%822 = load float, float* %821
%823 = fadd float %819, %822
%824 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 4
%825 = getelementptr inbounds [5 x float], [5 x float]* %824, i64 0, i64 2
%826 = load float, float* %825
%827 = fadd float %823, %826
%828 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 1
%829 = getelementptr inbounds [5 x float], [5 x float]* %828, i64 0, i64 3
%830 = load float, float* %829
%831 = fadd float %827, %830
%832 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 3
%833 = getelementptr inbounds [5 x float], [5 x float]* %832, i64 0, i64 3
%834 = load float, float* %833
%835 = fadd float %831, %834
%836 = call float @llvm.fmuladd.f32(float -2.000000e+00, float %835, float %812)
%837 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 2
%838 = getelementptr inbounds [5 x float], [5 x float]* %837, i64 0, i64 0
%839 = load float, float* %838
%840 = fadd float %836, %839
%841 = getelementptr inbounds [5 x [5 x float]], [5 x [5 x float]]* %18, i64 0, i64 2
%842 = getelementptr inbounds [5 x float], [5 x float]* %841, i64 0, i64 4
%843 = load float, float* %842
%844 = fadd float %840, %843
%845 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 1
%846 = getelementptr inbounds [5 x i32], [5 x i32]* %845, i64 0, i64 2
%847 = load i32, i32* %846
%848 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %19, i64 0, i64 3
%849 = getelementptr inbounds [5 x i32], [5 x i32]* %848, i64 0, i64 2
%850 = load i32, i32* %849
%851 = add nsw i32 %847, %850
%852 = mul nsw i32 8, %851
%853 = sitofp i32 %852 to float
%854 = fdiv float %844, %853
%855 = load float*, float** %17
%856 = load i32, i32* %20
%857 = sext i32 %856 to i64
%858 = getelementptr inbounds float, float* %855, i64 %857
store float %854, float* %858
br label %859
859: ; preds = %676, %493
br label %860
860: ; preds = %859, %320
br label %861
861: ; preds = %860, %151
br label %862
862: ; preds = %861
%863 = load i32, i32* %22
%864 = add nsw i32 %863, 1
store i32 %864, i32* %22
%865 = load i32, i32* %20
%866 = add nsw i32 %865, 1
store i32 %866, i32* %20
br label %49
867: ; preds = %49
br label %868
868: ; preds = %867
%869 = load i32, i32* %23
%870 = add nsw i32 %869, 1
store i32 %870, i32* %23
br label %44
871: ; preds = %44
ret void
}

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