#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 */
scalar_t__ fabs(scalar_t__);
int /*<<< orphan*/ free(float *);
scalar_t__ inline_diff3f(float *, float *);
scalar_t__ malloc(int);
int *MatrixFilter(float cutoff, int window, int n_pass, int nv, float *v1,
                  float *v2) {
  int *flag;
  float center1[3], center2[3];
  int a, b, c, cc;
  float *vv1, *vv2;
  float *dev, avg_dev;
  int wc;
  int start, finish;
  int cnt;
  flag = (int *)malloc(sizeof(int) * (nv));
  dev = (float *)malloc(sizeof(float) * (nv));
  for (a = 0; a < nv; a++) {
    flag[a] = 1;
  }
  for (c = 0; c < n_pass; c++) {
    cc = 0;
    {
      (center1)[0] = (v1)[0];
      (center1)[1] = (v1)[1];
      (center1)[2] = (v1)[2];
    };
    {
      (center2)[0] = (v2)[0];
      (center2)[1] = (v2)[1];
      (center2)[2] = (v2)[2];
    };
    for (a = 1; a < nv; a++) {
      if (flag[a]) {
        vv1 = v1 + 3 * a;
        vv2 = v2 + 3 * a;
        {
          (center1)[0] = (v1)[0] + (center1)[0];
          (center1)[1] = (v1)[1] + (center1)[1];
          (center1)[2] = (v1)[2] + (center1)[2];
        };
        {
          (center2)[0] = (v2)[0] + (center2)[0];
          (center2)[1] = (v2)[1] + (center2)[1];
          (center2)[2] = (v2)[2] + (center2)[2];
        };
        cc++;
      }
    }
    if (cc) {
      {
        (center1)[0] = (center1)[0] * (1.0F / cc);
        (center1)[1] = (center1)[1] * (1.0F / cc);
        (center1)[2] = (center1)[2] * (1.0F / cc);
      };
      {
        (center2)[0] = (center2)[0] * (1.0F / cc);
        (center2)[1] = (center2)[1] * (1.0F / cc);
        (center2)[2] = (center2)[2] * (1.0F / cc);
      };
    }
    avg_dev = 0.0F;
    cc = 0;
    for (a = 0; a < nv; a++) {
      if (flag[a]) {
        vv1 = v1 + 3 * a;
        vv2 = v2 + 3 * a;
        dev[a] = (float)fabs(inline_diff3f(center1, vv1) -
                             inline_diff3f(center2, vv2));
        avg_dev += dev[a];
        cc++;
      }
    }
    if (cc) {
      avg_dev /= cc;
      if (avg_dev > 0.0001F) {
        for (a = 0; a < nv; a++) {
          if ((dev[a] / avg_dev) > cutoff)
            flag[a] = 0;
          dev[a] = 0.0F;
        }
        for (a = 0; a < nv; a++) {
          if (flag[a]) {
            cnt = window;
            b = a;
            start = a;
            finish = a;
            while (cnt > (window / 2)) {
              if (b < 0)
                break;
              if (flag[b]) {
                start = b;
                cnt--;
              }
              b--;
            }
            b = a + 1;
            while (cnt > 0) {
              if (b >= nv)
                break;
              if (flag[b]) {
                finish = b;
                cnt--;
              }
              b++;
            }
            b = start - 1;
            while (cnt > 0) {
              if (b < 0)
                break;
              if (flag[b]) {
                start = b;
                cnt--;
              }
              b--;
            }
            if ((finish - start) >= window) {
              wc = 0;
              for (b = start; b <= finish; b++)
                if (flag[b]) {
                  vv1 = v1 + 3 * b;
                  vv2 = v2 + 3 * b;
                  if (!wc) {
                    {
                      (center1)[0] = (vv1)[0];
                      (center1)[1] = (vv1)[1];
                      (center1)[2] = (vv1)[2];
                    };
                    {
                      (center2)[0] = (vv2)[0];
                      (center2)[1] = (vv2)[1];
                      (center2)[2] = (vv2)[2];
                    };
                  } else {
                    {
                      (center1)[0] = (v1)[0] + (center1)[0];
                      (center1)[1] = (v1)[1] + (center1)[1];
                      (center1)[2] = (v1)[2] + (center1)[2];
                    };
                    {
                      (center2)[0] = (v2)[0] + (center2)[0];
                      (center2)[1] = (v2)[1] + (center2)[1];
                      (center2)[2] = (v2)[2] + (center2)[2];
                    };
                  }
                  wc++;
                }
              if (wc) {
                {
                  (center1)[0] = (center1)[0] * (1.0F / wc);
                  (center1)[1] = (center1)[1] * (1.0F / wc);
                  (center1)[2] = (center1)[2] * (1.0F / wc);
                };
                {
                  (center2)[0] = (center2)[0] * (1.0F / wc);
                  (center2)[1] = (center2)[1] * (1.0F / wc);
                  (center2)[2] = (center2)[2] * (1.0F / wc);
                };
                avg_dev = 0.0F;
                wc = 0;
                for (b = start; b <= finish; b++)
                  if (flag[b]) {
                    vv1 = v1 + 3 * b;
                    vv2 = v2 + 3 * b;
                    avg_dev += (float)fabs(inline_diff3f(center1, vv1) -
                                           inline_diff3f(center2, vv2));
                    wc++;
                  }
                if (wc) {
                  avg_dev /= wc;
                  vv1 = v1 + 3 * a;
                  vv2 = v2 + 3 * a;
                  if (avg_dev > 0.0001F)
                    dev[a] = (float)fabs(inline_diff3f(center1, vv1) -
                                         inline_diff3f(center2, vv2)) /
                             avg_dev;
                  else
                    dev[a] = 0.0F;
                }
              }
            }
          }
        }
        for (a = 0; a < nv; a++)
          if (flag[a])
            if (dev[a] > cutoff)
              flag[a] = 0;
      }
    }
  }
  {
    if (dev) {
      free(dev);
      dev = ((void *)0);
    }
  };
  return flag;
}


x86 assembly (clang, -O0):
<MatrixFilter>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
movss  %xmm0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
movslq -0x10(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x28(%rbp)
movslq -0x10(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x68(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    11b7 <MatrixFilter+0x77>
mov    -0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movl   $0x1,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    118e <MatrixFilter+0x4e>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1a9e <MatrixFilter+0x95e>
movl   $0x0,-0x50(%rbp)
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
movl   $0x1,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1300 <MatrixFilter+0x1c0>
mov    -0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     12ed <MatrixFilter+0x1ad>
mov    -0x18(%rbp),%rax
imul   $0x3,-0x44(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
mov    -0x20(%rbp),%rax
imul   $0x3,-0x44(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
addss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm0
addss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm0
addss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
addss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
addss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm0
addss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    12f2 <MatrixFilter+0x1b2>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    122a <MatrixFilter+0xea>
cmpl   $0x0,-0x50(%rbp)
je     13c4 <MatrixFilter+0x284>
movss  -0x34(%rbp),%xmm0
cvtsi2ssl -0x50(%rbp),%xmm2
movss  0xce4(%rip),%xmm1
divss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x30(%rbp),%xmm0
cvtsi2ssl -0x50(%rbp),%xmm2
movss  0xcc5(%rip),%xmm1
divss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x30(%rbp)
movss  -0x2c(%rbp),%xmm0
cvtsi2ssl -0x50(%rbp),%xmm2
movss  0xca6(%rip),%xmm1
divss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x40(%rbp),%xmm0
cvtsi2ssl -0x50(%rbp),%xmm2
movss  0xc87(%rip),%xmm1
divss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x3c(%rbp),%xmm0
cvtsi2ssl -0x50(%rbp),%xmm2
movss  0xc68(%rip),%xmm1
divss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x38(%rbp),%xmm0
cvtsi2ssl -0x50(%rbp),%xmm2
movss  0xc49(%rip),%xmm1
divss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x38(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x6c(%rbp)
movl   $0x0,-0x50(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1499 <MatrixFilter+0x359>
mov    -0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     1486 <MatrixFilter+0x346>
mov    -0x18(%rbp),%rax
imul   $0x3,-0x44(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
mov    -0x20(%rbp),%rax
imul   $0x3,-0x44(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
lea    -0x34(%rbp),%rdi
mov    -0x58(%rbp),%rsi
call   1060 <inline_diff3f@plt>
mov    %rax,-0x88(%rbp)
lea    -0x40(%rbp),%rdi
mov    -0x60(%rbp),%rsi
call   1060 <inline_diff3f@plt>
mov    -0x88(%rbp),%rdi
sub    %rax,%rdi
call   1040 <fabs@plt>
cvtsi2ss %rax,%xmm0
mov    -0x68(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x6c(%rbp),%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    148b <MatrixFilter+0x34b>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    13da <MatrixFilter+0x29a>
cmpl   $0x0,-0x50(%rbp)
je     1a8b <MatrixFilter+0x94b>
cvtsi2ssl -0x50(%rbp),%xmm1
movss  -0x6c(%rbp),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x6c(%rbp),%xmm0
movss  0xb41(%rip),%xmm1
ucomiss %xmm1,%xmm0
jbe    1a86 <MatrixFilter+0x946>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1528 <MatrixFilter+0x3e8>
mov    -0x68(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x6c(%rbp),%xmm0
ucomiss -0x4(%rbp),%xmm0
jbe    150a <MatrixFilter+0x3ca>
mov    -0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x68(%rbp),%rax
movslq -0x44(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    14d3 <MatrixFilter+0x393>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1a1e <MatrixFilter+0x8de>
mov    -0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     1a0b <MatrixFilter+0x8cb>
mov    -0x8(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x44(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x44(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0x44(%rbp),%eax
mov    %eax,-0x78(%rbp)
mov    -0x7c(%rbp),%eax
mov    %eax,-0x8c(%rbp)
mov    -0x8(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x8c(%rbp),%eax
cmp    %ecx,%eax
jle    15c7 <MatrixFilter+0x487>
cmpl   $0x0,-0x48(%rbp)
jge    1598 <MatrixFilter+0x458>
jmp    15c7 <MatrixFilter+0x487>
mov    -0x28(%rbp),%rax
movslq -0x48(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     15b9 <MatrixFilter+0x479>
mov    -0x48(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0x7c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x48(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x48(%rbp)
jmp    1565 <MatrixFilter+0x425>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
cmpl   $0x0,-0x7c(%rbp)
jle    161a <MatrixFilter+0x4da>
mov    -0x48(%rbp),%eax
cmp    -0x10(%rbp),%eax
jl     15eb <MatrixFilter+0x4ab>
jmp    161a <MatrixFilter+0x4da>
mov    -0x28(%rbp),%rax
movslq -0x48(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     160c <MatrixFilter+0x4cc>
mov    -0x48(%rbp),%eax
mov    %eax,-0x78(%rbp)
mov    -0x7c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    15d0 <MatrixFilter+0x490>
mov    -0x74(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x48(%rbp)
cmpl   $0x0,-0x7c(%rbp)
jle    166b <MatrixFilter+0x52b>
cmpl   $0x0,-0x48(%rbp)
jge    163c <MatrixFilter+0x4fc>
jmp    166b <MatrixFilter+0x52b>
mov    -0x28(%rbp),%rax
movslq -0x48(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     165d <MatrixFilter+0x51d>
mov    -0x48(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0x7c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x48(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x48(%rbp)
jmp    1623 <MatrixFilter+0x4e3>
mov    -0x78(%rbp),%eax
sub    -0x74(%rbp),%eax
cmp    -0x8(%rbp),%eax
jl     1a06 <MatrixFilter+0x8c6>
movl   $0x0,-0x70(%rbp)
mov    -0x74(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x78(%rbp),%eax
jg     17be <MatrixFilter+0x67e>
mov    -0x28(%rbp),%rax
movslq -0x48(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     17ab <MatrixFilter+0x66b>
mov    -0x18(%rbp),%rax
imul   $0x3,-0x48(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
mov    -0x20(%rbp),%rax
imul   $0x3,-0x48(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
cmpl   $0x0,-0x70(%rbp)
jne    1732 <MatrixFilter+0x5f2>
mov    -0x58(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x58(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x58(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x60(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x60(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x60(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
jmp    17a2 <MatrixFilter+0x662>
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
addss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm0
addss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm0
addss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
addss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
addss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm0
addss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    17b0 <MatrixFilter+0x670>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1687 <MatrixFilter+0x547>
cmpl   $0x0,-0x70(%rbp)
je     1a01 <MatrixFilter+0x8c1>
movss  -0x34(%rbp),%xmm0
cvtsi2ssl -0x70(%rbp),%xmm2
movss  0x826(%rip),%xmm1
divss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x30(%rbp),%xmm0
cvtsi2ssl -0x70(%rbp),%xmm2
movss  0x807(%rip),%xmm1
divss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x30(%rbp)
movss  -0x2c(%rbp),%xmm0
cvtsi2ssl -0x70(%rbp),%xmm2
movss  0x7e8(%rip),%xmm1
divss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x40(%rbp),%xmm0
cvtsi2ssl -0x70(%rbp),%xmm2
movss  0x7c9(%rip),%xmm1
divss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x3c(%rbp),%xmm0
cvtsi2ssl -0x70(%rbp),%xmm2
movss  0x7aa(%rip),%xmm1
divss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x38(%rbp),%xmm0
cvtsi2ssl -0x70(%rbp),%xmm2
movss  0x78b(%rip),%xmm1
divss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x38(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x6c(%rbp)
movl   $0x0,-0x70(%rbp)
mov    -0x74(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x78(%rbp),%eax
jg     193c <MatrixFilter+0x7fc>
mov    -0x28(%rbp),%rax
movslq -0x48(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     1929 <MatrixFilter+0x7e9>
mov    -0x18(%rbp),%rax
imul   $0x3,-0x48(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
mov    -0x20(%rbp),%rax
imul   $0x3,-0x48(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
lea    -0x34(%rbp),%rdi
mov    -0x58(%rbp),%rsi
call   1060 <inline_diff3f@plt>
mov    %rax,-0x98(%rbp)
lea    -0x40(%rbp),%rdi
mov    -0x60(%rbp),%rsi
call   1060 <inline_diff3f@plt>
mov    -0x98(%rbp),%rdi
sub    %rax,%rdi
call   1040 <fabs@plt>
cvtsi2ss %rax,%xmm0
addss  -0x6c(%rbp),%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    192e <MatrixFilter+0x7ee>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1897 <MatrixFilter+0x757>
cmpl   $0x0,-0x70(%rbp)
je     19fc <MatrixFilter+0x8bc>
cvtsi2ssl -0x70(%rbp),%xmm1
movss  -0x6c(%rbp),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x18(%rbp),%rax
imul   $0x3,-0x44(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
mov    -0x20(%rbp),%rax
imul   $0x3,-0x44(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
movss  -0x6c(%rbp),%xmm0
movss  0x672(%rip),%xmm1
ucomiss %xmm1,%xmm0
jbe    19e7 <MatrixFilter+0x8a7>
lea    -0x34(%rbp),%rdi
mov    -0x58(%rbp),%rsi
call   1060 <inline_diff3f@plt>
mov    %rax,-0xa0(%rbp)
lea    -0x40(%rbp),%rdi
mov    -0x60(%rbp),%rsi
call   1060 <inline_diff3f@plt>
mov    -0xa0(%rbp),%rdi
sub    %rax,%rdi
call   1040 <fabs@plt>
cvtsi2ss %rax,%xmm0
divss  -0x6c(%rbp),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    19f7 <MatrixFilter+0x8b7>
mov    -0x68(%rbp),%rax
movslq -0x44(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    19fc <MatrixFilter+0x8bc>
jmp    1a01 <MatrixFilter+0x8c1>
jmp    1a06 <MatrixFilter+0x8c6>
jmp    1a0b <MatrixFilter+0x8cb>
jmp    1a10 <MatrixFilter+0x8d0>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    152f <MatrixFilter+0x3ef>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1a81 <MatrixFilter+0x941>
mov    -0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     1a6e <MatrixFilter+0x92e>
mov    -0x68(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss -0x4(%rbp),%xmm0
jbe    1a69 <MatrixFilter+0x929>
mov    -0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
jmp    1a6e <MatrixFilter+0x92e>
jmp    1a73 <MatrixFilter+0x933>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1a25 <MatrixFilter+0x8e5>
jmp    1a86 <MatrixFilter+0x946>
jmp    1a8b <MatrixFilter+0x94b>
jmp    1a90 <MatrixFilter+0x950>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    11be <MatrixFilter+0x7e>
cmpq   $0x0,-0x68(%rbp)
je     1aba <MatrixFilter+0x97a>
mov    -0x68(%rbp),%rdi
call   1030 <free@plt>
movq   $0x0,-0x68(%rbp)
mov    -0x28(%rbp),%rax
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<MatrixFilter>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xf8,%rsp
mov    %r8,0x40(%rsp)
mov    %rcx,0x38(%rsp)
mov    %edx,%r13d
mov    %esi,0x4c(%rsp)
mov    %edi,%ebx
movaps %xmm0,0x90(%rsp)
lea    0x0(,%r13,4),%ebp
mov    %ebp,%edi
call   1050 <malloc@plt>
mov    %rax,%r12
mov    %ebp,%edi
call   1050 <malloc@plt>
mov    %r13d,%edi
test   %r13d,%r13d
jle    12b1 <MatrixFilter+0x171>
cmp    $0x8,%r13d
jae    119e <MatrixFilter+0x5e>
xor    %ebp,%ebp
jmp    12a0 <MatrixFilter+0x160>
mov    %edi,%ebp
and    $0xfffffff8,%ebp
lea    -0x8(%rbp),%rsi
mov    %rsi,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %edx,%ecx
and    $0x7,%ecx
cmp    $0x38,%rsi
jae    11c4 <MatrixFilter+0x84>
xor    %esi,%esi
jmp    1265 <MatrixFilter+0x125>
and    $0xfffffffffffffff8,%rdx
xor    %esi,%esi
movaps 0xe2f(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups %xmm0,(%r12,%rsi,4)
movups %xmm0,0x10(%r12,%rsi,4)
movups %xmm0,0x20(%r12,%rsi,4)
movups %xmm0,0x30(%r12,%rsi,4)
movups %xmm0,0x40(%r12,%rsi,4)
movups %xmm0,0x50(%r12,%rsi,4)
movups %xmm0,0x60(%r12,%rsi,4)
movups %xmm0,0x70(%r12,%rsi,4)
movups %xmm0,0x80(%r12,%rsi,4)
movups %xmm0,0x90(%r12,%rsi,4)
movups %xmm0,0xa0(%r12,%rsi,4)
movups %xmm0,0xb0(%r12,%rsi,4)
movups %xmm0,0xc0(%r12,%rsi,4)
movups %xmm0,0xd0(%r12,%rsi,4)
movups %xmm0,0xe0(%r12,%rsi,4)
movups %xmm0,0xf0(%r12,%rsi,4)
add    $0x40,%rsi
add    $0xfffffffffffffff8,%rdx
jne    11e0 <MatrixFilter+0xa0>
test   %rcx,%rcx
je     1292 <MatrixFilter+0x152>
lea    (%r12,%rsi,4),%rdx
add    $0x10,%rdx
shl    $0x5,%rcx
xor    %esi,%esi
movaps 0xd81(%rip),%xmm0
nop
movups %xmm0,-0x10(%rdx,%rsi,1)
movups %xmm0,(%rdx,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%rcx
jne    1280 <MatrixFilter+0x140>
cmp    %rdi,%rbp
je     12b1 <MatrixFilter+0x171>
nopw   0x0(%rax,%rax,1)
movl   $0x1,(%r12,%rbp,4)
add    $0x1,%rbp
cmp    %rbp,%rdi
jne    12a0 <MatrixFilter+0x160>
mov    %rax,0x28(%rsp)
cmpl   $0x0,0x4c(%rsp)
movaps 0x90(%rsp),%xmm12
jle    1bde <MatrixFilter+0xa9e>
mov    %ebx,%eax
shr    $0x1f,%eax
add    %ebx,%eax
sar    %eax
mov    %eax,0x4(%rsp)
movslq %r13d,%rax
mov    %rax,0xc0(%rsp)
lea    (%r12,%rdi,4),%rax
mov    0x28(%rsp),%rdx
lea    (%rdx,%rdi,4),%rcx
lea    -0x1(%rdi),%rsi
mov    %rsi,0x70(%rsp)
cmp    %rcx,%r12
setb   %cl
cmp    %rax,%rdx
setb   %al
and    %cl,%al
mov    %al,0x17(%rsp)
mov    %edi,%eax
and    $0xfffffffc,%eax
mov    %rax,0xb8(%rsp)
movaps %xmm12,%xmm6
shufps $0x0,%xmm12,%xmm6
mov    %edi,%eax
and    $0xfffffffe,%eax
mov    %rax,0xa8(%rsp)
lea    (%rdi,%rdi,2),%rax
mov    %rax,0xd8(%rsp)
lea    0x0(,%rdi,4),%rax
and    $0xfffffffffffffff0,%rax
mov    %rax,0xb0(%rsp)
xor    %eax,%eax
mov    %r12,0x80(%rsp)
mov    %r13,0x78(%rsp)
mov    %ebx,0x24(%rsp)
mov    %rdi,0x30(%rsp)
movaps %xmm6,0xe0(%rsp)
jmp    138a <MatrixFilter+0x24a>
nop
mov    0xc8(%rsp),%rax
add    $0x1,%eax
cmp    0x4c(%rsp),%eax
mov    0x30(%rsp),%rdi
je     1bde <MatrixFilter+0xa9e>
mov    %rax,0xc8(%rsp)
mov    0x38(%rsp),%rax
movss  (%rax),%xmm8
movss  %xmm8,0x8(%rsp)
movss  0x4(%rax),%xmm9
movss  %xmm9,0xc(%rsp)
movss  0x8(%rax),%xmm10
movss  %xmm10,0x10(%rsp)
mov    0x40(%rsp),%rax
movss  (%rax),%xmm11
movss  %xmm11,0x18(%rsp)
movss  0x4(%rax),%xmm1
movss  %xmm1,0x1c(%rsp)
movss  0x8(%rax),%xmm7
movss  %xmm7,0x20(%rsp)
cmp    $0x2,%r13d
jl     14c3 <MatrixFilter+0x383>
xor    %eax,%eax
mov    $0x1,%ecx
movaps %xmm8,%xmm5
movaps %xmm9,%xmm3
movaps %xmm10,%xmm6
movaps %xmm11,%xmm4
movaps %xmm1,%xmm2
movaps %xmm7,%xmm0
jmp    1419 <MatrixFilter+0x2d9>
nopl   (%rax)
add    $0x1,%rcx
cmp    %rcx,%rdi
je     1470 <MatrixFilter+0x330>
cmpl   $0x0,(%r12,%rcx,4)
je     1410 <MatrixFilter+0x2d0>
addss  %xmm8,%xmm5
movss  %xmm5,0x8(%rsp)
addss  %xmm9,%xmm3
movss  %xmm3,0xc(%rsp)
addss  %xmm10,%xmm6
movss  %xmm6,0x10(%rsp)
addss  %xmm11,%xmm4
movss  %xmm4,0x18(%rsp)
addss  %xmm1,%xmm2
movss  %xmm2,0x1c(%rsp)
addss  %xmm7,%xmm0
movss  %xmm0,0x20(%rsp)
add    $0x1,%eax
jmp    1410 <MatrixFilter+0x2d0>
cs nopw 0x0(%rax,%rax,1)
nop
test   %eax,%eax
je     14c3 <MatrixFilter+0x383>
xorps  %xmm1,%xmm1
cvtsi2ss %eax,%xmm1
movss  0xb9d(%rip),%xmm7
divss  %xmm1,%xmm7
mulss  %xmm7,%xmm5
movss  %xmm5,0x8(%rsp)
mulss  %xmm7,%xmm3
movss  %xmm3,0xc(%rsp)
mulss  %xmm7,%xmm6
movss  %xmm6,0x10(%rsp)
mulss  %xmm7,%xmm4
movss  %xmm4,0x18(%rsp)
mulss  %xmm7,%xmm2
movss  %xmm2,0x1c(%rsp)
mulss  %xmm0,%xmm7
movss  %xmm7,0x20(%rsp)
test   %r13d,%r13d
movaps 0xe0(%rsp),%xmm6
jle    1370 <MatrixFilter+0x230>
xor    %ebx,%ebx
xorps  %xmm3,%xmm3
mov    %r12,%r13
mov    0x28(%rsp),%r12
xor    %r14d,%r14d
jmp    1506 <MatrixFilter+0x3c6>
cs nopw 0x0(%rax,%rax,1)
add    $0x3,%rbx
add    $0x4,%r12
add    $0x4,%r13
cmp    %rbx,0xd8(%rsp)
je     1580 <MatrixFilter+0x440>
cmpl   $0x0,0x0(%r13)
je     14f0 <MatrixFilter+0x3b0>
mov    %ebx,%ebp
shl    $0x2,%rbp
mov    0x38(%rsp),%rax
lea    (%rax,%rbp,1),%rsi
add    0x40(%rsp),%rbp
lea    0x8(%rsp),%rdi
movaps %xmm3,0x60(%rsp)
call   1060 <inline_diff3f@plt>
mov    %rax,%r15
lea    0x18(%rsp),%rdi
mov    %rbp,%rsi
call   1060 <inline_diff3f@plt>
sub    %rax,%r15
mov    %r15,%rdi
call   1040 <fabs@plt>
movaps 0x60(%rsp),%xmm3
movaps 0xe0(%rsp),%xmm6
movaps 0x90(%rsp),%xmm12
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
movss  %xmm0,(%r12)
addss  %xmm0,%xmm3
add    $0x1,%r14d
jmp    14f0 <MatrixFilter+0x3b0>
nopl   0x0(%rax)
test   %r14d,%r14d
mov    0x80(%rsp),%r12
mov    0x78(%rsp),%r13
je     1370 <MatrixFilter+0x230>
test   %r13d,%r13d
jle    1370 <MatrixFilter+0x230>
xorps  %xmm0,%xmm0
cvtsi2ss %r14d,%xmm0
divss  %xmm0,%xmm3
ucomiss 0xa72(%rip),%xmm3
jbe    1370 <MatrixFilter+0x230>
cmp    $0x4,%r13d
setb   %al
or     0x17(%rsp),%al
je     15d6 <MatrixFilter+0x496>
xor    %ecx,%ecx
mov    0x28(%rsp),%rdx
mov    0x30(%rsp),%rsi
jmp    1676 <MatrixFilter+0x536>
movaps %xmm3,%xmm0
shufps $0x0,%xmm3,%xmm0
xor    %eax,%eax
mov    0x28(%rsp),%rdx
mov    0x30(%rsp),%rsi
mov    0xb0(%rsp),%rdi
jmp    1610 <MatrixFilter+0x4d0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xorps  %xmm1,%xmm1
movups %xmm1,(%rdx,%rax,1)
add    $0x10,%rax
cmp    %rax,%rdi
je     1666 <MatrixFilter+0x526>
movups (%rdx,%rax,1),%xmm2
divps  %xmm0,%xmm2
ucomiss %xmm6,%xmm2
jbe    1624 <MatrixFilter+0x4e4>
movl   $0x0,(%r12,%rax,1)
movaps %xmm6,%xmm1
cmpltps %xmm2,%xmm1
pextrw $0x2,%xmm1,%ecx
test   $0x1,%cl
je     163e <MatrixFilter+0x4fe>
movl   $0x0,0x4(%r12,%rax,1)
pextrw $0x4,%xmm1,%ecx
test   $0x1,%cl
je     1651 <MatrixFilter+0x511>
movl   $0x0,0x8(%r12,%rax,1)
pextrw $0x6,%xmm1,%ecx
test   $0x1,%cl
je     1600 <MatrixFilter+0x4c0>
movl   $0x0,0xc(%r12,%rax,1)
jmp    1600 <MatrixFilter+0x4c0>
mov    0xb8(%rsp),%rax
mov    %rax,%rcx
cmp    %rsi,%rax
je     16ab <MatrixFilter+0x56b>
mov    %rcx,%rax
test   $0x1,%sil
je     16a4 <MatrixFilter+0x564>
movss  (%rdx,%rcx,4),%xmm0
divss  %xmm3,%xmm0
ucomiss %xmm12,%xmm0
jbe    1696 <MatrixFilter+0x556>
movl   $0x0,(%r12,%rcx,4)
movl   $0x0,(%rdx,%rcx,4)
mov    %rcx,%rax
or     $0x1,%rax
cmp    %rcx,0x70(%rsp)
jne    16e1 <MatrixFilter+0x5a1>
test   %r13d,%r13d
jle    1370 <MatrixFilter+0x230>
mov    $0x1,%r15d
mov    $0x2,%ebp
xor    %r9d,%r9d
mov    0x24(%rsp),%r14d
mov    0x4(%rsp),%ebx
jmp    173b <MatrixFilter+0x5fb>
nopl   (%rax)
movl   $0x0,0x4(%rdx,%rax,4)
add    $0x2,%rax
cmp    %rax,%rsi
je     16ab <MatrixFilter+0x56b>
movss  (%rdx,%rax,4),%xmm0
divss  %xmm3,%xmm0
ucomiss %xmm12,%xmm0
jbe    16f8 <MatrixFilter+0x5b8>
movl   $0x0,(%r12,%rax,4)
movl   $0x0,(%rdx,%rax,4)
movss  0x4(%rdx,%rax,4),%xmm0
divss  %xmm3,%xmm0
ucomiss %xmm12,%xmm0
jbe    16d0 <MatrixFilter+0x590>
movl   $0x0,0x4(%r12,%rax,4)
jmp    16d0 <MatrixFilter+0x590>
mov    0x24(%rsp),%r14d
mov    0x4(%rsp),%ebx
mov    %r8d,%ebp
add    $0x1,%r15
add    $0x1,%ebp
mov    %r10,%r9
cmp    0x30(%rsp),%r10
je     1b38 <MatrixFilter+0x9f8>
cmpl   $0x0,(%r12,%r9,4)
je     17e0 <MatrixFilter+0x6a0>
mov    %r9d,%eax
mov    %r14d,%edx
cmp    %r14d,%ebx
jge    178f <MatrixFilter+0x64f>
mov    %r9d,%eax
lea    (%r12,%rax,4),%rcx
mov    %r14d,%edx
mov    %r9d,%eax
mov    %r9d,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xor    %edi,%edi
cmpl   $0x0,(%rcx)
setne  %dil
cmovne %esi,%eax
sub    %edi,%edx
cmp    %ebx,%edx
jle    178f <MatrixFilter+0x64f>
lea    -0x1(%rsi),%edi
add    $0xfffffffffffffffc,%rcx
test   %esi,%esi
mov    %edi,%esi
jg     1770 <MatrixFilter+0x630>
lea    0x1(%r9),%r10
test   %edx,%edx
jle    17ec <MatrixFilter+0x6ac>
mov    %r9d,%ebx
mov    %ebp,%r8d
mov    %ebp,%edi
mov    %r15,%rsi
cmp    0xc0(%rsp),%r10
jge    17d4 <MatrixFilter+0x694>
nopl   0x0(%rax)
mov    %ebx,%ecx
xor    %ebp,%ebp
cmpl   $0x0,(%r12,%rsi,4)
setne  %bpl
mov    %esi,%ebx
cmove  %ecx,%ebx
sub    %ebp,%edx
je     17d4 <MatrixFilter+0x694>
add    $0x1,%rsi
lea    0x1(%rdi),%ecx
cmp    %r13d,%edi
mov    %ecx,%edi
jl     17b0 <MatrixFilter+0x670>
test   %edx,%edx
jg     17f6 <MatrixFilter+0x6b6>
jmp    1821 <MatrixFilter+0x6e1>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r9
mov    %r9,%r10
jmp    1726 <MatrixFilter+0x5e6>
mov    %ebp,%r8d
mov    %r9d,%ebx
test   %edx,%edx
jle    1821 <MatrixFilter+0x6e1>
test   %eax,%eax
jle    1821 <MatrixFilter+0x6e1>
mov    %eax,%esi
nopl   0x0(%rax)
lea    -0x1(%rsi),%rdi
mov    %edi,%ecx
xor    %ebp,%ebp
cmpl   $0x0,(%r12,%rcx,4)
setne  %bpl
cmovne %edi,%eax
sub    %ebp,%edx
je     1821 <MatrixFilter+0x6e1>
cmp    $0x1,%rsi
mov    %rdi,%rsi
ja     1800 <MatrixFilter+0x6c0>
mov    %ebx,%ecx
sub    %eax,%ecx
cmp    %r14d,%ecx
jl     171f <MatrixFilter+0x5df>
mov    %ebx,%edx
sub    %eax,%edx
jl     171a <MatrixFilter+0x5da>
mov    %r15,0x50(%rsp)
movss  0x20(%rsp),%xmm0
movss  0x18(%rsp),%xmm1
movss  0x1c(%rsp),%xmm2
movss  0x10(%rsp),%xmm3
movss  0x8(%rsp),%xmm4
movss  0xc(%rsp),%xmm5
movslq %eax,%r11
lea    (%r11,%r11,2),%rcx
lea    0x8(,%rcx,4),%rsi
lea    (%r12,%r11,4),%r14
add    $0x1,%edx
xor    %ebp,%ebp
xor    %edi,%edi
jmp    18d9 <MatrixFilter+0x799>
nopl   (%rax)
mov    0x38(%rsp),%rcx
addss  (%rcx),%xmm4
movss  %xmm4,0x8(%rsp)
addss  0x4(%rcx),%xmm5
movss  %xmm5,0xc(%rsp)
addss  0x8(%rcx),%xmm3
movss  %xmm3,0x10(%rsp)
mov    0x40(%rsp),%rcx
addss  (%rcx),%xmm1
movss  %xmm1,0x18(%rsp)
addss  0x4(%rcx),%xmm2
movss  %xmm2,0x1c(%rsp)
addss  0x8(%rcx),%xmm0
movss  %xmm0,0x20(%rsp)
add    $0x1,%edi
add    $0xc,%rsi
add    $0x1,%rbp
cmp    %ebp,%edx
je     1930 <MatrixFilter+0x7f0>
cmpl   $0x0,(%r14,%rbp,4)
je     18cd <MatrixFilter+0x78d>
test   %edi,%edi
jne    1880 <MatrixFilter+0x740>
mov    0x38(%rsp),%rcx
movss  -0x8(%rcx,%rsi,1),%xmm4
movss  %xmm4,0x8(%rsp)
movss  -0x4(%rcx,%rsi,1),%xmm5
movss  %xmm5,0xc(%rsp)
movss  (%rcx,%rsi,1),%xmm3
movss  %xmm3,0x10(%rsp)
mov    0x40(%rsp),%rcx
movss  -0x8(%rcx,%rsi,1),%xmm1
movss  %xmm1,0x18(%rsp)
movss  -0x4(%rcx,%rsi,1),%xmm2
movss  %xmm2,0x1c(%rsp)
movss  (%rcx,%rsi,1),%xmm0
jmp    18c4 <MatrixFilter+0x784>
test   %edi,%edi
mov    %r8d,%ebp
je     1987 <MatrixFilter+0x847>
cvtsi2ss %edi,%xmm6
movss  0x6dd(%rip),%xmm7
divss  %xmm6,%xmm7
mulss  %xmm7,%xmm4
movss  %xmm4,0x8(%rsp)
mulss  %xmm7,%xmm5
movss  %xmm5,0xc(%rsp)
mulss  %xmm7,%xmm3
movss  %xmm3,0x10(%rsp)
mulss  %xmm7,%xmm1
movss  %xmm1,0x18(%rsp)
mulss  %xmm7,%xmm2
movss  %xmm2,0x1c(%rsp)
mulss  %xmm0,%xmm7
movss  %xmm7,0x20(%rsp)
cmp    %eax,%ebx
jge    199a <MatrixFilter+0x85a>
mov    0x24(%rsp),%r14d
mov    0x4(%rsp),%ebx
mov    0x50(%rsp),%r15
jmp    1726 <MatrixFilter+0x5e6>
mov    %ebp,0x48(%rsp)
shl    $0x2,%r11
lea    (%r11,%r11,2),%r12
mov    0x38(%rsp),%rax
lea    (%rax,%r12,1),%r13
add    0x40(%rsp),%r12
xorps  %xmm1,%xmm1
xor    %ebp,%ebp
xor    %eax,%eax
mov    0x4(%rsp),%ebx
mov    %r10,0x88(%rsp)
mov    %rdx,0xd0(%rsp)
jmp    19f0 <MatrixFilter+0x8b0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0xc,%r13
add    $0xc,%r12
add    $0x1,%rbp
cmp    %ebp,%edx
je     1a6a <MatrixFilter+0x92a>
cmpl   $0x0,(%r14,%rbp,4)
je     19e0 <MatrixFilter+0x8a0>
lea    0x8(%rsp),%rdi
mov    %r13,%rsi
mov    %r9,%r15
movss  %xmm1,0x60(%rsp)
mov    %eax,0x58(%rsp)
call   1060 <inline_diff3f@plt>
mov    %rax,%rbx
lea    0x18(%rsp),%rdi
mov    %r12,%rsi
call   1060 <inline_diff3f@plt>
sub    %rax,%rbx
mov    %rbx,%rdi
mov    0x4(%rsp),%ebx
call   1040 <fabs@plt>
movss  0x60(%rsp),%xmm1
mov    0xd0(%rsp),%rdx
mov    0x88(%rsp),%r10
mov    %r15,%r9
movaps 0x90(%rsp),%xmm12
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
mov    0x58(%rsp),%eax
addss  %xmm0,%xmm1
add    $0x1,%eax
jmp    19e0 <MatrixFilter+0x8a0>
test   %eax,%eax
mov    0x80(%rsp),%r12
mov    0x78(%rsp),%r13
mov    0x24(%rsp),%r14d
mov    0x50(%rsp),%r15
mov    0x48(%rsp),%ebp
je     1726 <MatrixFilter+0x5e6>
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
divss  %xmm0,%xmm1
ucomiss 0x585(%rip),%xmm1
jbe    1b26 <MatrixFilter+0x9e6>
lea    (%r9,%r9,2),%eax
mov    0x40(%rsp),%rcx
lea    (%rcx,%rax,4),%rbx
mov    0x38(%rsp),%rcx
lea    (%rcx,%rax,4),%rsi
lea    0x8(%rsp),%rdi
mov    %r9,0x58(%rsp)
movss  %xmm1,0x60(%rsp)
call   1060 <inline_diff3f@plt>
mov    %rax,%rbp
lea    0x18(%rsp),%rdi
mov    %rbx,%rsi
mov    0x4(%rsp),%ebx
call   1060 <inline_diff3f@plt>
sub    %rax,%rbp
mov    %rbp,%rdi
mov    0x48(%rsp),%ebp
call   1040 <fabs@plt>
mov    0x88(%rsp),%r10
movaps 0x90(%rsp),%xmm12
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
divss  0x60(%rsp),%xmm0
mov    0x28(%rsp),%rax
mov    0x58(%rsp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1726 <MatrixFilter+0x5e6>
mov    0x28(%rsp),%rax
movl   $0x0,(%rax,%r9,4)
jmp    1726 <MatrixFilter+0x5e6>
test   %r13d,%r13d
jle    1370 <MatrixFilter+0x230>
cmpq   $0x0,0x70(%rsp)
je     1ba2 <MatrixFilter+0xa62>
xor    %eax,%eax
mov    0x28(%rsp),%rcx
mov    0x30(%rsp),%rdx
mov    0xa8(%rsp),%rsi
jmp    1b69 <MatrixFilter+0xa29>
nop
add    $0x2,%rax
cmp    %rax,%rsi
je     1ba9 <MatrixFilter+0xa69>
cmpl   $0x0,(%r12,%rax,4)
je     1b83 <MatrixFilter+0xa43>
movss  (%rcx,%rax,4),%xmm0
ucomiss %xmm12,%xmm0
jbe    1b83 <MatrixFilter+0xa43>
movl   $0x0,(%r12,%rax,4)
cmpl   $0x0,0x4(%r12,%rax,4)
je     1b60 <MatrixFilter+0xa20>
movss  0x4(%rcx,%rax,4),%xmm0
ucomiss %xmm12,%xmm0
jbe    1b60 <MatrixFilter+0xa20>
movl   $0x0,0x4(%r12,%rax,4)
jmp    1b60 <MatrixFilter+0xa20>
xor    %eax,%eax
mov    0x30(%rsp),%rdx
test   $0x1,%dl
je     1370 <MatrixFilter+0x230>
cmpl   $0x0,(%r12,%rax,4)
je     1370 <MatrixFilter+0x230>
mov    0x28(%rsp),%rcx
movss  (%rcx,%rax,4),%xmm0
ucomiss %xmm12,%xmm0
jbe    1370 <MatrixFilter+0x230>
movl   $0x0,(%r12,%rax,4)
jmp    1370 <MatrixFilter+0x230>
mov    0x28(%rsp),%rdi
test   %rdi,%rdi
je     1bed <MatrixFilter+0xaad>
call   1030 <free@plt>
mov    %r12,%rax
add    $0xf8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32* @MatrixFilter(float %0, i32 %1, i32 %2, i32 %3, float* %4, float* %5) {
%7 = alloca float
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca float*
%12 = alloca float*
%13 = alloca i32*
%14 = alloca [3 x float]
%15 = alloca [3 x float]
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca float*
%21 = alloca float*
%22 = alloca float*
%23 = alloca float
%24 = alloca i32
%25 = alloca i32
%26 = alloca i32
%27 = alloca i32
store float %0, float* %7
store i32 %1, i32* %8
store i32 %2, i32* %9
store i32 %3, i32* %10
store float* %4, float** %11
store float* %5, float** %12
%28 = load i32, i32* %10
%29 = sext i32 %28 to i64
%30 = mul i64 4, %29
%31 = trunc i64 %30 to i32
%32 = call i64 @malloc(i32 %31)
%33 = inttoptr i64 %32 to i32*
store i32* %33, i32** %13
%34 = load i32, i32* %10
%35 = sext i32 %34 to i64
%36 = mul i64 4, %35
%37 = trunc i64 %36 to i32
%38 = call i64 @malloc(i32 %37)
%39 = inttoptr i64 %38 to float*
store float* %39, float** %22
store i32 0, i32* %16
br label %40
40: ; preds = %49, %6
%41 = load i32, i32* %16
%42 = load i32, i32* %10
%43 = icmp slt i32 %41, %42
br i1 %43, label %44, label %52
44: ; preds = %40
%45 = load i32*, i32** %13
%46 = load i32, i32* %16
%47 = sext i32 %46 to i64
%48 = getelementptr inbounds i32, i32* %45, i64 %47
store i32 1, i32* %48
br label %49
49: ; preds = %44
%50 = load i32, i32* %16
%51 = add nsw i32 %50, 1
store i32 %51, i32* %16
br label %40
52: ; preds = %40
store i32 0, i32* %18
br label %53
53: ; preds = %649, %52
%54 = load i32, i32* %18
%55 = load i32, i32* %9
%56 = icmp slt i32 %54, %55
br i1 %56, label %57, label %652
57: ; preds = %53
store i32 0, i32* %19
%58 = load float*, float** %11
%59 = getelementptr inbounds float, float* %58, i64 0
%60 = load float, float* %59
%61 = getelementptr inbounds [3 x float], [3 x float]* %14, i64 0, i64 0
store float %60, float* %61
%62 = load float*, float** %11
%63 = getelementptr inbounds float, float* %62, i64 1
%64 = load float, float* %63
%65 = getelementptr inbounds [3 x float], [3 x float]* %14, i64 0, i64 1
store float %64, float* %65
%66 = load float*, float** %11
%67 = getelementptr inbounds float, float* %66, i64 2
%68 = load float, float* %67
%69 = getelementptr inbounds [3 x float], [3 x float]* %14, i64 0, i64 2
store float %68, float* %69
%70 = load float*, float** %12
%71 = getelementptr inbounds float, float* %70, i64 0
%72 = load float, float* %71
%73 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 0
store float %72, float* %73
%74 = load float*, float** %12
%75 = getelementptr inbounds float, float* %74, i64 1
%76 = load float, float* %75
%77 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 1
store float %76, float* %77
%78 = load float*, float** %12
%79 = getelementptr inbounds float, float* %78, i64 2
%80 = load float, float* %79
%81 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 2
store float %80, float* %81
store i32 1, i32* %16
br label %82
82: ; preds = %149, %57
%83 = load i32, i32* %16
%84 = load i32, i32* %10
%85 = icmp slt i32 %83, %84
br i1 %85, label %86, label %152
86: ; preds = %82
%87 = load i32*, i32** %13
%88 = load i32, i32* %16
%89 = sext i32 %88 to i64
%90 = getelementptr inbounds i32, i32* %87, i64 %89
%91 = load i32, i32* %90
%92 = icmp ne i32 %91, 0
br i1 %92, label %93, label %148
93: ; preds = %86
%94 = load float*, float** %11
%95 = load i32, i32* %16
%96 = mul nsw i32 3, %95
%97 = sext i32 %96 to i64
%98 = getelementptr inbounds float, float* %94, i64 %97
store float* %98, float** %20
%99 = load float*, float** %12
%100 = load i32, i32* %16
%101 = mul nsw i32 3, %100
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds float, float* %99, i64 %102
store float* %103, float** %21
%104 = load float*, float** %11
%105 = getelementptr inbounds float, float* %104, i64 0
%106 = load float, float* %105
%107 = getelementptr inbounds [3 x float], [3 x float]* %14, i64 0, i64 0
%108 = load float, float* %107
%109 = fadd float %106, %108
%110 = getelementptr inbounds [3 x float], [3 x float]* %14, i64 0, i64 0
store float %109, float* %110
%111 = load float*, float** %11
%112 = getelementptr inbounds float, float* %111, i64 1
%113 = load float, float* %112
%114 = getelementptr inbounds [3 x float], [3 x float]* %14, i64 0, i64 1
%115 = load float, float* %114
%116 = fadd float %113, %115
%117 = getelementptr inbounds [3 x float], [3 x float]* %14, i64 0, i64 1
store float %116, float* %117
%118 = load float*, float** %11
%119 = getelementptr inbounds float, float* %118, i64 2
%120 = load float, float* %119
%121 = getelementptr inbounds [3 x float], [3 x float]* %14, i64 0, i64 2
%122 = load float, float* %121
%123 = fadd float %120, %122
%124 = getelementptr inbounds [3 x float], [3 x float]* %14, i64 0, i64 2
store float %123, float* %124
%125 = load float*, float** %12
%126 = getelementptr inbounds float, float* %125, i64 0
%127 = load float, float* %126
%128 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 0
%129 = load float, float* %128
%130 = fadd float %127, %129
%131 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 0
store float %130, float* %131
%132 = load float*, float** %12
%133 = getelementptr inbounds float, float* %132, i64 1
%134 = load float, float* %133
%135 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 1
%136 = load float, float* %135
%137 = fadd float %134, %136
%138 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 1
store float %137, float* %138
%139 = load float*, float** %12
%140 = getelementptr inbounds float, float* %139, i64 2
%141 = load float, float* %140
%142 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 2
%143 = load float, float* %142
%144 = fadd float %141, %143
%145 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 2
store float %144, float* %145
%146 = load i32, i32* %19
%147 = add nsw i32 %146, 1
store i32 %147, i32* %19
br label %148
148: ; preds = %93, %86
br label %149
149: ; preds = %148
%150 = load i32, i32* %16
%151 = add nsw i32 %150, 1
store i32 %151, i32* %16
br label %82
152: ; preds = %82
%153 = load i32, i32* %19
%154 = icmp ne i32 %153, 0
br i1 %154, label %155, label %198
155: ; preds = %152
%156 = getelementptr inbounds [3 x float], [3 x float]* %14, i64 0, i64 0
%157 = load float, float* %156
%158 = load i32, i32* %19
%159 = sitofp i32 %158 to float
%160 = fdiv float 1.000000e+00, %159
%161 = fmul float %157, %160
%162 = getelementptr inbounds [3 x float], [3 x float]* %14, i64 0, i64 0
store float %161, float* %162
%163 = getelementptr inbounds [3 x float], [3 x float]* %14, i64 0, i64 1
%164 = load float, float* %163
%165 = load i32, i32* %19
%166 = sitofp i32 %165 to float
%167 = fdiv float 1.000000e+00, %166
%168 = fmul float %164, %167
%169 = getelementptr inbounds [3 x float], [3 x float]* %14, i64 0, i64 1
store float %168, float* %169
%170 = getelementptr inbounds [3 x float], [3 x float]* %14, i64 0, i64 2
%171 = load float, float* %170
%172 = load i32, i32* %19
%173 = sitofp i32 %172 to float
%174 = fdiv float 1.000000e+00, %173
%175 = fmul float %171, %174
%176 = getelementptr inbounds [3 x float], [3 x float]* %14, i64 0, i64 2
store float %175, float* %176
%177 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 0
%178 = load float, float* %177
%179 = load i32, i32* %19
%180 = sitofp i32 %179 to float
%181 = fdiv float 1.000000e+00, %180
%182 = fmul float %178, %181
%183 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 0
store float %182, float* %183
%184 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 1
%185 = load float, float* %184
%186 = load i32, i32* %19
%187 = sitofp i32 %186 to float
%188 = fdiv float 1.000000e+00, %187
%189 = fmul float %185, %188
%190 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 1
store float %189, float* %190
%191 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 2
%192 = load float, float* %191
%193 = load i32, i32* %19
%194 = sitofp i32 %193 to float
%195 = fdiv float 1.000000e+00, %194
%196 = fmul float %192, %195
%197 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 2
store float %196, float* %197
br label %198
198: ; preds = %155, %152
store float 0.000000e+00, float* %23
store i32 0, i32* %19
store i32 0, i32* %16
br label %199
199: ; preds = %244, %198
%200 = load i32, i32* %16
%201 = load i32, i32* %10
%202 = icmp slt i32 %200, %201
br i1 %202, label %203, label %247
203: ; preds = %199
%204 = load i32*, i32** %13
%205 = load i32, i32* %16
%206 = sext i32 %205 to i64
%207 = getelementptr inbounds i32, i32* %204, i64 %206
%208 = load i32, i32* %207
%209 = icmp ne i32 %208, 0
br i1 %209, label %210, label %243
210: ; preds = %203
%211 = load float*, float** %11
%212 = load i32, i32* %16
%213 = mul nsw i32 3, %212
%214 = sext i32 %213 to i64
%215 = getelementptr inbounds float, float* %211, i64 %214
store float* %215, float** %20
%216 = load float*, float** %12
%217 = load i32, i32* %16
%218 = mul nsw i32 3, %217
%219 = sext i32 %218 to i64
%220 = getelementptr inbounds float, float* %216, i64 %219
store float* %220, float** %21
%221 = getelementptr inbounds [3 x float], [3 x float]* %14, i64 0, i64 0
%222 = load float*, float** %20
%223 = call i64 @inline_diff3f(float* %221, float* %222)
%224 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 0
%225 = load float*, float** %21
%226 = call i64 @inline_diff3f(float* %224, float* %225)
%227 = sub nsw i64 %223, %226
%228 = call i64 @fabs(i64 %227)
%229 = sitofp i64 %228 to float
%230 = load float*, float** %22
%231 = load i32, i32* %16
%232 = sext i32 %231 to i64
%233 = getelementptr inbounds float, float* %230, i64 %232
store float %229, float* %233
%234 = load float*, float** %22
%235 = load i32, i32* %16
%236 = sext i32 %235 to i64
%237 = getelementptr inbounds float, float* %234, i64 %236
%238 = load float, float* %237
%239 = load float, float* %23
%240 = fadd float %239, %238
store float %240, float* %23
%241 = load i32, i32* %19
%242 = add nsw i32 %241, 1
store i32 %242, i32* %19
br label %243
243: ; preds = %210, %203
br label %244
244: ; preds = %243
%245 = load i32, i32* %16
%246 = add nsw i32 %245, 1
store i32 %246, i32* %16
br label %199
247: ; preds = %199
%248 = load i32, i32* %19
%249 = icmp ne i32 %248, 0
br i1 %249, label %250, label %648
250: ; preds = %247
%251 = load i32, i32* %19
%252 = sitofp i32 %251 to float
%253 = load float, float* %23
%254 = fdiv float %253, %252
store float %254, float* %23
%255 = load float, float* %23
%256 = fcmp ogt float %255, 0x3F1A36E2E0000000
br i1 %256, label %257, label %647
257: ; preds = %250
store i32 0, i32* %16
br label %258
258: ; preds = %282, %257
%259 = load i32, i32* %16
%260 = load i32, i32* %10
%261 = icmp slt i32 %259, %260
br i1 %261, label %262, label %285
262: ; preds = %258
%263 = load float*, float** %22
%264 = load i32, i32* %16
%265 = sext i32 %264 to i64
%266 = getelementptr inbounds float, float* %263, i64 %265
%267 = load float, float* %266
%268 = load float, float* %23
%269 = fdiv float %267, %268
%270 = load float, float* %7
%271 = fcmp ogt float %269, %270
br i1 %271, label %272, label %277
272: ; preds = %262
%273 = load i32*, i32** %13
%274 = load i32, i32* %16
%275 = sext i32 %274 to i64
%276 = getelementptr inbounds i32, i32* %273, i64 %275
store i32 0, i32* %276
br label %277
277: ; preds = %272, %262
%278 = load float*, float** %22
%279 = load i32, i32* %16
%280 = sext i32 %279 to i64
%281 = getelementptr inbounds float, float* %278, i64 %280
store float 0.000000e+00, float* %281
br label %282
282: ; preds = %277
%283 = load i32, i32* %16
%284 = add nsw i32 %283, 1
store i32 %284, i32* %16
br label %258
285: ; preds = %258
store i32 0, i32* %16
br label %286
286: ; preds = %613, %285
%287 = load i32, i32* %16
%288 = load i32, i32* %10
%289 = icmp slt i32 %287, %288
br i1 %289, label %290, label %616
290: ; preds = %286
%291 = load i32*, i32** %13
%292 = load i32, i32* %16
%293 = sext i32 %292 to i64
%294 = getelementptr inbounds i32, i32* %291, i64 %293
%295 = load i32, i32* %294
%296 = icmp ne i32 %295, 0
br i1 %296, label %297, label %612
297: ; preds = %290
%298 = load i32, i32* %8
store i32 %298, i32* %27
%299 = load i32, i32* %16
store i32 %299, i32* %17
%300 = load i32, i32* %16
store i32 %300, i32* %25
%301 = load i32, i32* %16
store i32 %301, i32* %26
br label %302
302: ; preds = %322, %297
%303 = load i32, i32* %27
%304 = load i32, i32* %8
%305 = sdiv i32 %304, 2
%306 = icmp sgt i32 %303, %305
br i1 %306, label %307, label %325
307: ; preds = %302
%308 = load i32, i32* %17
%309 = icmp slt i32 %308, 0
br i1 %309, label %310, label %311
310: ; preds = %307
br label %325
311: ; preds = %307
%312 = load i32*, i32** %13
%313 = load i32, i32* %17
%314 = sext i32 %313 to i64
%315 = getelementptr inbounds i32, i32* %312, i64 %314
%316 = load i32, i32* %315
%317 = icmp ne i32 %316, 0
br i1 %317, label %318, label %322
318: ; preds = %311
%319 = load i32, i32* %17
store i32 %319, i32* %25
%320 = load i32, i32* %27
%321 = add nsw i32 %320, -1
store i32 %321, i32* %27
br label %322
322: ; preds = %318, %311
%323 = load i32, i32* %17
%324 = add nsw i32 %323, -1
store i32 %324, i32* %17
br label %302
325: ; preds = %310, %302
%326 = load i32, i32* %16
%327 = add nsw i32 %326, 1
store i32 %327, i32* %17
br label %328
328: ; preds = %347, %325
%329 = load i32, i32* %27
%330 = icmp sgt i32 %329, 0
br i1 %330, label %331, label %350
331: ; preds = %328
%332 = load i32, i32* %17
%333 = load i32, i32* %10
%334 = icmp sge i32 %332, %333
br i1 %334, label %335, label %336
335: ; preds = %331
br label %350
336: ; preds = %331
%337 = load i32*, i32** %13
%338 = load i32, i32* %17
%339 = sext i32 %338 to i64
%340 = getelementptr inbounds i32, i32* %337, i64 %339
%341 = load i32, i32* %340
%342 = icmp ne i32 %341, 0
br i1 %342, label %343, label %347
343: ; preds = %336
%344 = load i32, i32* %17
store i32 %344, i32* %26
%345 = load i32, i32* %27
%346 = add nsw i32 %345, -1
store i32 %346, i32* %27
br label %347
347: ; preds = %343, %336
%348 = load i32, i32* %17
%349 = add nsw i32 %348, 1
store i32 %349, i32* %17
br label %328
350: ; preds = %335, %328
%351 = load i32, i32* %25
%352 = sub nsw i32 %351, 1
store i32 %352, i32* %17
br label %353
353: ; preds = %371, %350
%354 = load i32, i32* %27
%355 = icmp sgt i32 %354, 0
br i1 %355, label %356, label %374
356: ; preds = %353
%357 = load i32, i32* %17
%358 = icmp slt i32 %357, 0
br i1 %358, label %359, label %360
359: ; preds = %356
br label %374
360: ; preds = %356
%361 = load i32*, i32** %13
%362 = load i32, i32* %17
%363 = sext i32 %362 to i64
%364 = getelementptr inbounds i32, i32* %361, i64 %363
%365 = load i32, i32* %364
%366 = icmp ne i32 %365, 0
br i1 %366, label %367, label %371
367: ; preds = %360
%368 = load i32, i32* %17
store i32 %368, i32* %25
%369 = load i32, i32* %27
%370 = add nsw i32 %369, -1
store i32 %370, i32* %27
br label %371
371: ; preds = %367, %360
%372 = load i32, i32* %17
%373 = add nsw i32 %372, -1
store i32 %373, i32* %17
br label %353
374: ; preds = %359, %353
%375 = load i32, i32* %26
%376 = load i32, i32* %25
%377 = sub nsw i32 %375, %376
%378 = load i32, i32* %8
%379 = icmp sge i32 %377, %378
br i1 %379, label %380, label %611
380: ; preds = %374
store i32 0, i32* %24
%381 = load i32, i32* %25
store i32 %381, i32* %17
br label %382
382: ; preds = %478, %380
%383 = load i32, i32* %17
%384 = load i32, i32* %26
%385 = icmp sle i32 %383, %384
br i1 %385, label %386, label %481
386: ; preds = %382
%387 = load i32*, i32** %13
%388 = load i32, i32* %17
%389 = sext i32 %388 to i64
%390 = getelementptr inbounds i32, i32* %387, i64 %389
%391 = load i32, i32* %390
%392 = icmp ne i32 %391, 0
br i1 %392, label %393, label %477
393: ; preds = %386
%394 = load float*, float** %11
%395 = load i32, i32* %17
%396 = mul nsw i32 3, %395
%397 = sext i32 %396 to i64
%398 = getelementptr inbounds float, float* %394, i64 %397
store float* %398, float** %20
%399 = load float*, float** %12
%400 = load i32, i32* %17
%401 = mul nsw i32 3, %400
%402 = sext i32 %401 to i64
%403 = getelementptr inbounds float, float* %399, i64 %402
store float* %403, float** %21
%404 = load i32, i32* %24
%405 = icmp ne i32 %404, 0
br i1 %405, label %431, label %406
406: ; preds = %393
%407 = load float*, float** %20
%408 = getelementptr inbounds float, float* %407, i64 0
%409 = load float, float* %408
%410 = getelementptr inbounds [3 x float], [3 x float]* %14, i64 0, i64 0
store float %409, float* %410
%411 = load float*, float** %20
%412 = getelementptr inbounds float, float* %411, i64 1
%413 = load float, float* %412
%414 = getelementptr inbounds [3 x float], [3 x float]* %14, i64 0, i64 1
store float %413, float* %414
%415 = load float*, float** %20
%416 = getelementptr inbounds float, float* %415, i64 2
%417 = load float, float* %416
%418 = getelementptr inbounds [3 x float], [3 x float]* %14, i64 0, i64 2
store float %417, float* %418
%419 = load float*, float** %21
%420 = getelementptr inbounds float, float* %419, i64 0
%421 = load float, float* %420
%422 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 0
store float %421, float* %422
%423 = load float*, float** %21
%424 = getelementptr inbounds float, float* %423, i64 1
%425 = load float, float* %424
%426 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 1
store float %425, float* %426
%427 = load float*, float** %21
%428 = getelementptr inbounds float, float* %427, i64 2
%429 = load float, float* %428
%430 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 2
store float %429, float* %430
br label %474
431: ; preds = %393
%432 = load float*, float** %11
%433 = getelementptr inbounds float, float* %432, i64 0
%434 = load float, float* %433
%435 = getelementptr inbounds [3 x float], [3 x float]* %14, i64 0, i64 0
%436 = load float, float* %435
%437 = fadd float %434, %436
%438 = getelementptr inbounds [3 x float], [3 x float]* %14, i64 0, i64 0
store float %437, float* %438
%439 = load float*, float** %11
%440 = getelementptr inbounds float, float* %439, i64 1
%441 = load float, float* %440
%442 = getelementptr inbounds [3 x float], [3 x float]* %14, i64 0, i64 1
%443 = load float, float* %442
%444 = fadd float %441, %443
%445 = getelementptr inbounds [3 x float], [3 x float]* %14, i64 0, i64 1
store float %444, float* %445
%446 = load float*, float** %11
%447 = getelementptr inbounds float, float* %446, i64 2
%448 = load float, float* %447
%449 = getelementptr inbounds [3 x float], [3 x float]* %14, i64 0, i64 2
%450 = load float, float* %449
%451 = fadd float %448, %450
%452 = getelementptr inbounds [3 x float], [3 x float]* %14, i64 0, i64 2
store float %451, float* %452
%453 = load float*, float** %12
%454 = getelementptr inbounds float, float* %453, i64 0
%455 = load float, float* %454
%456 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 0
%457 = load float, float* %456
%458 = fadd float %455, %457
%459 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 0
store float %458, float* %459
%460 = load float*, float** %12
%461 = getelementptr inbounds float, float* %460, i64 1
%462 = load float, float* %461
%463 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 1
%464 = load float, float* %463
%465 = fadd float %462, %464
%466 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 1
store float %465, float* %466
%467 = load float*, float** %12
%468 = getelementptr inbounds float, float* %467, i64 2
%469 = load float, float* %468
%470 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 2
%471 = load float, float* %470
%472 = fadd float %469, %471
%473 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 2
store float %472, float* %473
br label %474
474: ; preds = %431, %406
%475 = load i32, i32* %24
%476 = add nsw i32 %475, 1
store i32 %476, i32* %24
br label %477
477: ; preds = %474, %386
br label %478
478: ; preds = %477
%479 = load i32, i32* %17
%480 = add nsw i32 %479, 1
store i32 %480, i32* %17
br label %382
481: ; preds = %382
%482 = load i32, i32* %24
%483 = icmp ne i32 %482, 0
br i1 %483, label %484, label %610
484: ; preds = %481
%485 = getelementptr inbounds [3 x float], [3 x float]* %14, i64 0, i64 0
%486 = load float, float* %485
%487 = load i32, i32* %24
%488 = sitofp i32 %487 to float
%489 = fdiv float 1.000000e+00, %488
%490 = fmul float %486, %489
%491 = getelementptr inbounds [3 x float], [3 x float]* %14, i64 0, i64 0
store float %490, float* %491
%492 = getelementptr inbounds [3 x float], [3 x float]* %14, i64 0, i64 1
%493 = load float, float* %492
%494 = load i32, i32* %24
%495 = sitofp i32 %494 to float
%496 = fdiv float 1.000000e+00, %495
%497 = fmul float %493, %496
%498 = getelementptr inbounds [3 x float], [3 x float]* %14, i64 0, i64 1
store float %497, float* %498
%499 = getelementptr inbounds [3 x float], [3 x float]* %14, i64 0, i64 2
%500 = load float, float* %499
%501 = load i32, i32* %24
%502 = sitofp i32 %501 to float
%503 = fdiv float 1.000000e+00, %502
%504 = fmul float %500, %503
%505 = getelementptr inbounds [3 x float], [3 x float]* %14, i64 0, i64 2
store float %504, float* %505
%506 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 0
%507 = load float, float* %506
%508 = load i32, i32* %24
%509 = sitofp i32 %508 to float
%510 = fdiv float 1.000000e+00, %509
%511 = fmul float %507, %510
%512 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 0
store float %511, float* %512
%513 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 1
%514 = load float, float* %513
%515 = load i32, i32* %24
%516 = sitofp i32 %515 to float
%517 = fdiv float 1.000000e+00, %516
%518 = fmul float %514, %517
%519 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 1
store float %518, float* %519
%520 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 2
%521 = load float, float* %520
%522 = load i32, i32* %24
%523 = sitofp i32 %522 to float
%524 = fdiv float 1.000000e+00, %523
%525 = fmul float %521, %524
%526 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 2
store float %525, float* %526
store float 0.000000e+00, float* %23
store i32 0, i32* %24
%527 = load i32, i32* %25
store i32 %527, i32* %17
br label %528
528: ; preds = %564, %484
%529 = load i32, i32* %17
%530 = load i32, i32* %26
%531 = icmp sle i32 %529, %530
br i1 %531, label %532, label %567
532: ; preds = %528
%533 = load i32*, i32** %13
%534 = load i32, i32* %17
%535 = sext i32 %534 to i64
%536 = getelementptr inbounds i32, i32* %533, i64 %535
%537 = load i32, i32* %536
%538 = icmp ne i32 %537, 0
br i1 %538, label %539, label %563
539: ; preds = %532
%540 = load float*, float** %11
%541 = load i32, i32* %17
%542 = mul nsw i32 3, %541
%543 = sext i32 %542 to i64
%544 = getelementptr inbounds float, float* %540, i64 %543
store float* %544, float** %20
%545 = load float*, float** %12
%546 = load i32, i32* %17
%547 = mul nsw i32 3, %546
%548 = sext i32 %547 to i64
%549 = getelementptr inbounds float, float* %545, i64 %548
store float* %549, float** %21
%550 = getelementptr inbounds [3 x float], [3 x float]* %14, i64 0, i64 0
%551 = load float*, float** %20
%552 = call i64 @inline_diff3f(float* %550, float* %551)
%553 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 0
%554 = load float*, float** %21
%555 = call i64 @inline_diff3f(float* %553, float* %554)
%556 = sub nsw i64 %552, %555
%557 = call i64 @fabs(i64 %556)
%558 = sitofp i64 %557 to float
%559 = load float, float* %23
%560 = fadd float %559, %558
store float %560, float* %23
%561 = load i32, i32* %24
%562 = add nsw i32 %561, 1
store i32 %562, i32* %24
br label %563
563: ; preds = %539, %532
br label %564
564: ; preds = %563
%565 = load i32, i32* %17
%566 = add nsw i32 %565, 1
store i32 %566, i32* %17
br label %528
567: ; preds = %528
%568 = load i32, i32* %24
%569 = icmp ne i32 %568, 0
br i1 %569, label %570, label %609
570: ; preds = %567
%571 = load i32, i32* %24
%572 = sitofp i32 %571 to float
%573 = load float, float* %23
%574 = fdiv float %573, %572
store float %574, float* %23
%575 = load float*, float** %11
%576 = load i32, i32* %16
%577 = mul nsw i32 3, %576
%578 = sext i32 %577 to i64
%579 = getelementptr inbounds float, float* %575, i64 %578
store float* %579, float** %20
%580 = load float*, float** %12
%581 = load i32, i32* %16
%582 = mul nsw i32 3, %581
%583 = sext i32 %582 to i64
%584 = getelementptr inbounds float, float* %580, i64 %583
store float* %584, float** %21
%585 = load float, float* %23
%586 = fcmp ogt float %585, 0x3F1A36E2E0000000
br i1 %586, label %587, label %603
587: ; preds = %570
%588 = getelementptr inbounds [3 x float], [3 x float]* %14, i64 0, i64 0
%589 = load float*, float** %20
%590 = call i64 @inline_diff3f(float* %588, float* %589)
%591 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 0
%592 = load float*, float** %21
%593 = call i64 @inline_diff3f(float* %591, float* %592)
%594 = sub nsw i64 %590, %593
%595 = call i64 @fabs(i64 %594)
%596 = sitofp i64 %595 to float
%597 = load float, float* %23
%598 = fdiv float %596, %597
%599 = load float*, float** %22
%600 = load i32, i32* %16
%601 = sext i32 %600 to i64
%602 = getelementptr inbounds float, float* %599, i64 %601
store float %598, float* %602
br label %608
603: ; preds = %570
%604 = load float*, float** %22
%605 = load i32, i32* %16
%606 = sext i32 %605 to i64
%607 = getelementptr inbounds float, float* %604, i64 %606
store float 0.000000e+00, float* %607
br label %608
608: ; preds = %603, %587
br label %609
609: ; preds = %608, %567
br label %610
610: ; preds = %609, %481
br label %611
611: ; preds = %610, %374
br label %612
612: ; preds = %611, %290
br label %613
613: ; preds = %612
%614 = load i32, i32* %16
%615 = add nsw i32 %614, 1
store i32 %615, i32* %16
br label %286
616: ; preds = %286
store i32 0, i32* %16
br label %617
617: ; preds = %643, %616
%618 = load i32, i32* %16
%619 = load i32, i32* %10
%620 = icmp slt i32 %618, %619
br i1 %620, label %621, label %646
621: ; preds = %617
%622 = load i32*, i32** %13
%623 = load i32, i32* %16
%624 = sext i32 %623 to i64
%625 = getelementptr inbounds i32, i32* %622, i64 %624
%626 = load i32, i32* %625
%627 = icmp ne i32 %626, 0
br i1 %627, label %628, label %642
628: ; preds = %621
%629 = load float*, float** %22
%630 = load i32, i32* %16
%631 = sext i32 %630 to i64
%632 = getelementptr inbounds float, float* %629, i64 %631
%633 = load float, float* %632
%634 = load float, float* %7
%635 = fcmp ogt float %633, %634
br i1 %635, label %636, label %641
636: ; preds = %628
%637 = load i32*, i32** %13
%638 = load i32, i32* %16
%639 = sext i32 %638 to i64
%640 = getelementptr inbounds i32, i32* %637, i64 %639
store i32 0, i32* %640
br label %641
641: ; preds = %636, %628
br label %642
642: ; preds = %641, %621
br label %643
643: ; preds = %642
%644 = load i32, i32* %16
%645 = add nsw i32 %644, 1
store i32 %645, i32* %16
br label %617
646: ; preds = %617
br label %647
647: ; preds = %646, %250
br label %648
648: ; preds = %647, %247
br label %649
649: ; preds = %648
%650 = load i32, i32* %18
%651 = add nsw i32 %650, 1
store i32 %651, i32* %18
br label %53
652: ; preds = %53
%653 = load float*, float** %22
%654 = icmp ne float* %653, null
br i1 %654, label %655, label %658
655: ; preds = %652
%656 = load float*, float** %22
%657 = call i32 @free(float* %656)
store float* null, float** %22
br label %658
658: ; preds = %655, %652
%659 = load i32*, i32** %13
ret i32* %659
}

LLVM IR (-O2):
define i32* @MatrixFilter(float %0, i32 %1, i32 %2, i32 %3, float* %4, float* %5) {
%7 = alloca [3 x float]
%8 = alloca [3 x float]
%9 = bitcast [3 x float]* %7 to i8*
%10 = bitcast [3 x float]* %8 to i8*
%11 = shl i32 %3, 2
%12 = tail call i64 @malloc(i32 %11)
%13 = inttoptr i64 %12 to i32*
%14 = inttoptr i64 %12 to i8*
%15 = tail call i64 @malloc(i32 %11)
%16 = inttoptr i64 %15 to float*
%17 = inttoptr i64 %15 to i8*
%18 = icmp sgt i32 %3, 0
br i1 %18, label %19, label %93
19: ; preds = %6
%20 = zext i32 %3 to i64
%21 = icmp ult i32 %3, 8
br i1 %21, label %91, label %22
22: ; preds = %19
%23 = and i64 %20, 4294967288
%24 = add nsw i64 %23, -8
%25 = lshr exact i64 %24, 3
%26 = add nuw nsw i64 %25, 1
%27 = and i64 %26, 7
%28 = icmp ult i64 %24, 56
br i1 %28, label %76, label %29
29: ; preds = %22
%30 = and i64 %26, 4611686018427387896
br label %31
31: ; preds = %31, %29
%32 = phi i64 [ 0, %29 ], [ %73, %31 ]
%33 = phi i64 [ 0, %29 ], [ %74, %31 ]
%34 = getelementptr inbounds i32, i32* %13, i64 %32
%35 = bitcast i32* %34 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %35
%36 = getelementptr inbounds i32, i32* %34, i64 4
%37 = bitcast i32* %36 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %37
%38 = or i64 %32, 8
%39 = getelementptr inbounds i32, i32* %13, i64 %38
%40 = bitcast i32* %39 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %40
%41 = getelementptr inbounds i32, i32* %39, i64 4
%42 = bitcast i32* %41 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %42
%43 = or i64 %32, 16
%44 = getelementptr inbounds i32, i32* %13, i64 %43
%45 = bitcast i32* %44 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %45
%46 = getelementptr inbounds i32, i32* %44, i64 4
%47 = bitcast i32* %46 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %47
%48 = or i64 %32, 24
%49 = getelementptr inbounds i32, i32* %13, i64 %48
%50 = bitcast i32* %49 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %50
%51 = getelementptr inbounds i32, i32* %49, i64 4
%52 = bitcast i32* %51 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %52
%53 = or i64 %32, 32
%54 = getelementptr inbounds i32, i32* %13, i64 %53
%55 = bitcast i32* %54 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %55
%56 = getelementptr inbounds i32, i32* %54, i64 4
%57 = bitcast i32* %56 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %57
%58 = or i64 %32, 40
%59 = getelementptr inbounds i32, i32* %13, i64 %58
%60 = bitcast i32* %59 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %60
%61 = getelementptr inbounds i32, i32* %59, i64 4
%62 = bitcast i32* %61 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %62
%63 = or i64 %32, 48
%64 = getelementptr inbounds i32, i32* %13, i64 %63
%65 = bitcast i32* %64 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %65
%66 = getelementptr inbounds i32, i32* %64, i64 4
%67 = bitcast i32* %66 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %67
%68 = or i64 %32, 56
%69 = getelementptr inbounds i32, i32* %13, i64 %68
%70 = bitcast i32* %69 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %70
%71 = getelementptr inbounds i32, i32* %69, i64 4
%72 = bitcast i32* %71 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %72
%73 = add nuw i64 %32, 64
%74 = add nuw i64 %33, 8
%75 = icmp eq i64 %74, %30
br i1 %75, label %76, label %31
76: ; preds = %31, %22
%77 = phi i64 [ 0, %22 ], [ %73, %31 ]
%78 = icmp eq i64 %27, 0
br i1 %78, label %89, label %79
79: ; preds = %76, %79
%80 = phi i64 [ %86, %79 ], [ %77, %76 ]
%81 = phi i64 [ %87, %79 ], [ 0, %76 ]
%82 = getelementptr inbounds i32, i32* %13, i64 %80
%83 = bitcast i32* %82 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %83
%84 = getelementptr inbounds i32, i32* %82, i64 4
%85 = bitcast i32* %84 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %85
%86 = add nuw i64 %80, 8
%87 = add i64 %81, 1
%88 = icmp eq i64 %87, %27
br i1 %88, label %89, label %79
89: ; preds = %79, %76
%90 = icmp eq i64 %23, %20
br i1 %90, label %93, label %91
91: ; preds = %19, %89
%92 = phi i64 [ 0, %19 ], [ %23, %89 ]
br label %133
93: ; preds = %133, %89, %6
%94 = icmp sgt i32 %2, 0
br i1 %94, label %95, label %542
95: ; preds = %93
%96 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 0
%97 = getelementptr inbounds float, float* %4, i64 1
%98 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 1
%99 = getelementptr inbounds float, float* %4, i64 2
%100 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 2
%101 = getelementptr inbounds [3 x float], [3 x float]* %8, i64 0, i64 0
%102 = getelementptr inbounds float, float* %5, i64 1
%103 = getelementptr inbounds [3 x float], [3 x float]* %8, i64 0, i64 1
%104 = getelementptr inbounds float, float* %5, i64 2
%105 = getelementptr inbounds [3 x float], [3 x float]* %8, i64 0, i64 2
%106 = icmp sgt i32 %3, 1
%107 = sdiv i32 %1, 2
%108 = icmp slt i32 %107, %1
%109 = sext i32 %3 to i64
%110 = zext i32 %3 to i64
%111 = zext i32 %3 to i64
%112 = zext i32 %3 to i64
%113 = zext i32 %3 to i64
%114 = getelementptr i32, i32* %13, i64 %110
%115 = bitcast i32* %114 to i8*
%116 = getelementptr float, float* %16, i64 %110
%117 = bitcast float* %116 to i8*
%118 = add nsw i64 %110, -1
%119 = icmp ult i32 %3, 4
%120 = icmp ult i8* %14, %117
%121 = icmp ult i8* %17, %115
%122 = and i1 %120, %121
%123 = and i64 %110, 4294967292
%124 = insertelement <4 x float> poison, float %0, i64 0
%125 = shufflevector <4 x float> %124, <4 x float> poison, <4 x i32> zeroinitializer
%126 = icmp eq i64 %123, %110
%127 = and i64 %110, 1
%128 = icmp eq i64 %127, 0
%129 = and i64 %110, 1
%130 = icmp eq i64 %118, 0
%131 = and i64 %110, 4294967294
%132 = icmp eq i64 %129, 0
br label %138
133: ; preds = %91, %133
%134 = phi i64 [ %136, %133 ], [ %92, %91 ]
%135 = getelementptr inbounds i32, i32* %13, i64 %134
store i32 1, i32* %135
%136 = add nuw nsw i64 %134, 1
%137 = icmp eq i64 %136, %20
br i1 %137, label %93, label %133
138: ; preds = %95, %539
%139 = phi i32 [ 0, %95 ], [ %540, %539 ]
%140 = load float, float* %4
store float %140, float* %96
%141 = load float, float* %97
store float %141, float* %98
%142 = load float, float* %99
store float %142, float* %100
%143 = load float, float* %5
store float %143, float* %101
%144 = load float, float* %102
store float %144, float* %103
%145 = load float, float* %104
store float %145, float* %105
br i1 %106, label %146, label %187
146: ; preds = %138, %166
%147 = phi i64 [ %174, %166 ], [ 1, %138 ]
%148 = phi i32 [ %173, %166 ], [ 0, %138 ]
%149 = phi float [ %172, %166 ], [ %140, %138 ]
%150 = phi float [ %171, %166 ], [ %141, %138 ]
%151 = phi float [ %170, %166 ], [ %142, %138 ]
%152 = phi float [ %169, %166 ], [ %143, %138 ]
%153 = phi float [ %168, %166 ], [ %144, %138 ]
%154 = phi float [ %167, %166 ], [ %145, %138 ]
%155 = getelementptr inbounds i32, i32* %13, i64 %147
%156 = load i32, i32* %155
%157 = icmp eq i32 %156, 0
br i1 %157, label %166, label %158
158: ; preds = %146
%159 = fadd float %140, %149
store float %159, float* %96
%160 = fadd float %141, %150
store float %160, float* %98
%161 = fadd float %142, %151
store float %161, float* %100
%162 = fadd float %143, %152
store float %162, float* %101
%163 = fadd float %144, %153
store float %163, float* %103
%164 = fadd float %145, %154
store float %164, float* %105
%165 = add nsw i32 %148, 1
br label %166
166: ; preds = %146, %158
%167 = phi float [ %164, %158 ], [ %154, %146 ]
%168 = phi float [ %163, %158 ], [ %153, %146 ]
%169 = phi float [ %162, %158 ], [ %152, %146 ]
%170 = phi float [ %161, %158 ], [ %151, %146 ]
%171 = phi float [ %160, %158 ], [ %150, %146 ]
%172 = phi float [ %159, %158 ], [ %149, %146 ]
%173 = phi i32 [ %165, %158 ], [ %148, %146 ]
%174 = add nuw nsw i64 %147, 1
%175 = icmp eq i64 %174, %110
br i1 %175, label %176, label %146
176: ; preds = %166
%177 = icmp eq i32 %173, 0
br i1 %177, label %187, label %178
178: ; preds = %176
%179 = sitofp i32 %173 to float
%180 = fdiv float 1.000000e+00, %179
%181 = fmul float %180, %172
store float %181, float* %96
%182 = fmul float %180, %171
store float %182, float* %98
%183 = fmul float %180, %170
store float %183, float* %100
%184 = fmul float %180, %169
store float %184, float* %101
%185 = fmul float %180, %168
store float %185, float* %103
%186 = fmul float %180, %167
store float %186, float* %105
br label %187
187: ; preds = %138, %178, %176
br i1 %18, label %188, label %539
188: ; preds = %187, %208
%189 = phi i64 [ %211, %208 ], [ 0, %187 ]
%190 = phi float [ %210, %208 ], [ 0.000000e+00, %187 ]
%191 = phi i32 [ %209, %208 ], [ 0, %187 ]
%192 = getelementptr inbounds i32, i32* %13, i64 %189
%193 = load i32, i32* %192
%194 = icmp eq i32 %193, 0
br i1 %194, label %208, label %195
195: ; preds = %188
%196 = mul i64 %189, 3
%197 = and i64 %196, 4294967295
%198 = getelementptr inbounds float, float* %4, i64 %197
%199 = getelementptr inbounds float, float* %5, i64 %197
%200 = call i64 @inline_diff3f(float* %96, float* %198)
%201 = call i64 @inline_diff3f(float* %101, float* %199)
%202 = sub nsw i64 %200, %201
%203 = call i64 @fabs(i64 %202)
%204 = sitofp i64 %203 to float
%205 = getelementptr inbounds float, float* %16, i64 %189
store float %204, float* %205
%206 = fadd float %190, %204
%207 = add nsw i32 %191, 1
br label %208
208: ; preds = %188, %195
%209 = phi i32 [ %207, %195 ], [ %191, %188 ]
%210 = phi float [ %206, %195 ], [ %190, %188 ]
%211 = add nuw nsw i64 %189, 1
%212 = icmp eq i64 %211, %111
br i1 %212, label %213, label %188
213: ; preds = %208
%214 = icmp eq i32 %209, 0
br i1 %214, label %539, label %215
215: ; preds = %213
%216 = sitofp i32 %209 to float
%217 = fdiv float %210, %216
%218 = fcmp ogt float %217, 0x3F1A36E2E0000000
%219 = and i1 %18, %218
br i1 %219, label %220, label %539
220: ; preds = %215
%221 = select i1 %119, i1 true, i1 %122
br i1 %221, label %255, label %222
222: ; preds = %220
%223 = insertelement <4 x float> poison, float %217, i64 0
%224 = shufflevector <4 x float> %223, <4 x float> poison, <4 x i32> zeroinitializer
br label %225
225: ; preds = %250, %222
%226 = phi i64 [ 0, %222 ], [ %252, %250 ]
%227 = getelementptr inbounds float, float* %16, i64 %226
%228 = bitcast float* %227 to <4 x float>*
%229 = load <4 x float>, <4 x float>* %228
%230 = fdiv <4 x float> %229, %224
%231 = fcmp ogt <4 x float> %230, %125
%232 = extractelement <4 x i1> %231, i64 0
br i1 %232, label %233, label %235
233: ; preds = %225
%234 = getelementptr inbounds i32, i32* %13, i64 %226
store i32 0, i32* %234
br label %235
235: ; preds = %233, %225
%236 = extractelement <4 x i1> %231, i64 1
br i1 %236, label %237, label %240
237: ; preds = %235
%238 = or i64 %226, 1
%239 = getelementptr inbounds i32, i32* %13, i64 %238
store i32 0, i32* %239
br label %240
240: ; preds = %237, %235
%241 = extractelement <4 x i1> %231, i64 2
br i1 %241, label %242, label %245
242: ; preds = %240
%243 = or i64 %226, 2
%244 = getelementptr inbounds i32, i32* %13, i64 %243
store i32 0, i32* %244
br label %245
245: ; preds = %242, %240
%246 = extractelement <4 x i1> %231, i64 3
br i1 %246, label %247, label %250
247: ; preds = %245
%248 = or i64 %226, 3
%249 = getelementptr inbounds i32, i32* %13, i64 %248
store i32 0, i32* %249
br label %250
250: ; preds = %247, %245
%251 = bitcast float* %227 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %251
%252 = add nuw i64 %226, 4
%253 = icmp eq i64 %252, %123
br i1 %253, label %254, label %225
254: ; preds = %250
br i1 %126, label %269, label %255
255: ; preds = %220, %254
%256 = phi i64 [ 0, %220 ], [ %123, %254 ]
br i1 %128, label %266, label %257
257: ; preds = %255
%258 = getelementptr inbounds float, float* %16, i64 %256
%259 = load float, float* %258
%260 = fdiv float %259, %217
%261 = fcmp ogt float %260, %0
br i1 %261, label %262, label %264
262: ; preds = %257
%263 = getelementptr inbounds i32, i32* %13, i64 %256
store i32 0, i32* %263
br label %264
264: ; preds = %262, %257
store float 0.000000e+00, float* %258
%265 = or i64 %256, 1
br label %266
266: ; preds = %264, %255
%267 = phi i64 [ %256, %255 ], [ %265, %264 ]
%268 = icmp eq i64 %118, %256
br i1 %268, label %269, label %270
269: ; preds = %266, %286, %254
br i1 %18, label %291, label %539
270: ; preds = %266, %286
%271 = phi i64 [ %287, %286 ], [ %267, %266 ]
%272 = getelementptr inbounds float, float* %16, i64 %271
%273 = load float, float* %272
%274 = fdiv float %273, %217
%275 = fcmp ogt float %274, %0
br i1 %275, label %276, label %278
276: ; preds = %270
%277 = getelementptr inbounds i32, i32* %13, i64 %271
store i32 0, i32* %277
br label %278
278: ; preds = %276, %270
store float 0.000000e+00, float* %272
%279 = add nuw nsw i64 %271, 1
%280 = getelementptr inbounds float, float* %16, i64 %279
%281 = load float, float* %280
%282 = fdiv float %281, %217
%283 = fcmp ogt float %282, %0
br i1 %283, label %284, label %286
284: ; preds = %278
%285 = getelementptr inbounds i32, i32* %13, i64 %279
store i32 0, i32* %285
br label %286
286: ; preds = %284, %278
store float 0.000000e+00, float* %280
%287 = add nuw nsw i64 %271, 2
%288 = icmp eq i64 %287, %112
br i1 %288, label %269, label %270
289: ; preds = %499
br i1 %18, label %290, label %539
290: ; preds = %289
br i1 %130, label %528, label %503
291: ; preds = %269, %499
%292 = phi i64 [ %500, %499 ], [ 0, %269 ]
%293 = phi i64 [ %501, %499 ], [ 1, %269 ]
%294 = getelementptr inbounds i32, i32* %13, i64 %292
%295 = load i32, i32* %294
%296 = icmp eq i32 %295, 0
br i1 %296, label %297, label %299
297: ; preds = %291
%298 = add nuw nsw i64 %292, 1
br label %499
299: ; preds = %291
%300 = trunc i64 %292 to i32
br i1 %108, label %308, label %301
301: ; preds = %308, %299
%302 = phi i32 [ %300, %299 ], [ %316, %308 ]
%303 = phi i32 [ %1, %299 ], [ %319, %308 ]
%304 = add nuw nsw i64 %292, 1
%305 = icmp sgt i32 %303, 0
%306 = icmp slt i64 %304, %109
%307 = select i1 %305, i1 %306, i1 false
br i1 %307, label %332, label %324
308: ; preds = %299, %308
%309 = phi i32 [ %319, %308 ], [ %1, %299 ]
%310 = phi i32 [ %316, %308 ], [ %300, %299 ]
%311 = phi i32 [ %320, %308 ], [ %300, %299 ]
%312 = zext i32 %311 to i64
%313 = getelementptr inbounds i32, i32* %13, i64 %312
%314 = load i32, i32* %313
%315 = icmp eq i32 %314, 0
%316 = select i1 %315, i32 %310, i32 %311
%317 = xor i1 %315, true
%318 = sext i1 %317 to i32
%319 = add nsw i32 %309, %318
%320 = add nsw i32 %311, -1
%321 = icmp sle i32 %319, %107
%322 = icmp slt i32 %311, 1
%323 = select i1 %321, i1 true, i1 %322
br i1 %323, label %301, label %308
324: ; preds = %332, %301
%325 = phi i32 [ %300, %301 ], [ %340, %332 ]
%326 = phi i32 [ %303, %301 ], [ %343, %332 ]
%327 = icmp slt i32 %326, 1
%328 = icmp slt i32 %302, 1
%329 = select i1 %327, i1 true, i1 %328
br i1 %329, label %366, label %330
330: ; preds = %324
%331 = zext i32 %302 to i64
br label %349
332: ; preds = %301, %332
%333 = phi i64 [ %344, %332 ], [ %293, %301 ]
%334 = phi i32 [ %343, %332 ], [ %303, %301 ]
%335 = phi i32 [ %340, %332 ], [ %300, %301 ]
%336 = getelementptr inbounds i32, i32* %13, i64 %333
%337 = load i32, i32* %336
%338 = icmp eq i32 %337, 0
%339 = trunc i64 %333 to i32
%340 = select i1 %338, i32 %335, i32 %339
%341 = xor i1 %338, true
%342 = sext i1 %341 to i32
%343 = add nsw i32 %334, %342
%344 = add nuw nsw i64 %333, 1
%345 = icmp ne i32 %343, 0
%346 = trunc i64 %344 to i32
%347 = icmp slt i32 %346, %3
%348 = select i1 %345, i1 %347, i1 false
br i1 %348, label %332, label %324
349: ; preds = %330, %349
%350 = phi i64 [ %331, %330 ], [ %353, %349 ]
%351 = phi i32 [ %326, %330 ], [ %362, %349 ]
%352 = phi i32 [ %302, %330 ], [ %359, %349 ]
%353 = add nsw i64 %350, -1
%354 = trunc i64 %353 to i32
%355 = and i64 %353, 4294967295
%356 = getelementptr inbounds i32, i32* %13, i64 %355
%357 = load i32, i32* %356
%358 = icmp eq i32 %357, 0
%359 = select i1 %358, i32 %352, i32 %354
%360 = xor i1 %358, true
%361 = sext i1 %360 to i32
%362 = add nsw i32 %351, %361
%363 = icmp eq i32 %362, 0
%364 = icmp ult i64 %350, 2
%365 = select i1 %363, i1 true, i1 %364
br i1 %365, label %366, label %349
366: ; preds = %349, %324
%367 = phi i32 [ %302, %324 ], [ %359, %349 ]
%368 = sub nsw i32 %325, %367
%369 = icmp slt i32 %368, %1
br i1 %369, label %499, label %370
370: ; preds = %366
%371 = icmp slt i32 %325, %367
br i1 %371, label %499, label %372
372: ; preds = %370
%373 = load float, float* %105
%374 = load float, float* %103
%375 = load float, float* %101
%376 = load float, float* %100
%377 = load float, float* %98
%378 = load float, float* %96
%379 = sext i32 %367 to i64
%380 = add i32 %325, 1
br label %381
381: ; preds = %372, %430
%382 = phi i64 [ %379, %372 ], [ %438, %430 ]
%383 = phi i32 [ 0, %372 ], [ %437, %430 ]
%384 = phi float [ %378, %372 ], [ %436, %430 ]
%385 = phi float [ %377, %372 ], [ %435, %430 ]
%386 = phi float [ %376, %372 ], [ %434, %430 ]
%387 = phi float [ %375, %372 ], [ %433, %430 ]
%388 = phi float [ %374, %372 ], [ %432, %430 ]
%389 = phi float [ %373, %372 ], [ %431, %430 ]
%390 = getelementptr inbounds i32, i32* %13, i64 %382
%391 = load i32, i32* %390
%392 = icmp eq i32 %391, 0
br i1 %392, label %430, label %393
393: ; preds = %381
%394 = mul nsw i64 %382, 3
%395 = getelementptr inbounds float, float* %4, i64 %394
%396 = getelementptr inbounds float, float* %5, i64 %394
%397 = icmp eq i32 %383, 0
br i1 %397, label %398, label %409
398: ; preds = %393
%399 = load float, float* %395
store float %399, float* %96
%400 = getelementptr inbounds float, float* %395, i64 1
%401 = load float, float* %400
store float %401, float* %98
%402 = getelementptr inbounds float, float* %395, i64 2
%403 = load float, float* %402
store float %403, float* %100
%404 = load float, float* %396
store float %404, float* %101
%405 = getelementptr inbounds float, float* %396, i64 1
%406 = load float, float* %405
store float %406, float* %103
%407 = getelementptr inbounds float, float* %396, i64 2
%408 = load float, float* %407
br label %422
409: ; preds = %393
%410 = load float, float* %4
%411 = fadd float %410, %384
store float %411, float* %96
%412 = load float, float* %97
%413 = fadd float %412, %385
store float %413, float* %98
%414 = load float, float* %99
%415 = fadd float %414, %386
store float %415, float* %100
%416 = load float, float* %5
%417 = fadd float %416, %387
store float %417, float* %101
%418 = load float, float* %102
%419 = fadd float %418, %388
store float %419, float* %103
%420 = load float, float* %104
%421 = fadd float %420, %389
br label %422
422: ; preds = %409, %398
%423 = phi float [ %406, %398 ], [ %419, %409 ]
%424 = phi float [ %404, %398 ], [ %417, %409 ]
%425 = phi float [ %403, %398 ], [ %415, %409 ]
%426 = phi float [ %401, %398 ], [ %413, %409 ]
%427 = phi float [ %399, %398 ], [ %411, %409 ]
%428 = phi float [ %408, %398 ], [ %421, %409 ]
store float %428, float* %105
%429 = add nsw i32 %383, 1
br label %430
430: ; preds = %381, %422
%431 = phi float [ %428, %422 ], [ %389, %381 ]
%432 = phi float [ %423, %422 ], [ %388, %381 ]
%433 = phi float [ %424, %422 ], [ %387, %381 ]
%434 = phi float [ %425, %422 ], [ %386, %381 ]
%435 = phi float [ %426, %422 ], [ %385, %381 ]
%436 = phi float [ %427, %422 ], [ %384, %381 ]
%437 = phi i32 [ %429, %422 ], [ %383, %381 ]
%438 = add nsw i64 %382, 1
%439 = trunc i64 %438 to i32
%440 = icmp eq i32 %380, %439
br i1 %440, label %441, label %381
441: ; preds = %430
%442 = icmp eq i32 %437, 0
br i1 %442, label %499, label %443
443: ; preds = %441
%444 = sitofp i32 %437 to float
%445 = fdiv float 1.000000e+00, %444
%446 = fmul float %445, %436
store float %446, float* %96
%447 = fmul float %445, %435
store float %447, float* %98
%448 = fmul float %445, %434
store float %448, float* %100
%449 = fmul float %445, %433
store float %449, float* %101
%450 = fmul float %445, %432
store float %450, float* %103
%451 = fmul float %445, %431
store float %451, float* %105
br i1 %371, label %499, label %452
452: ; preds = %443
%453 = sext i32 %367 to i64
%454 = add i32 %325, 1
br label %455
455: ; preds = %452, %473
%456 = phi i64 [ %453, %452 ], [ %476, %473 ]
%457 = phi i32 [ 0, %452 ], [ %475, %473 ]
%458 = phi float [ 0.000000e+00, %452 ], [ %474, %473 ]
%459 = getelementptr inbounds i32, i32* %13, i64 %456
%460 = load i32, i32* %459
%461 = icmp eq i32 %460, 0
br i1 %461, label %473, label %462
462: ; preds = %455
%463 = mul nsw i64 %456, 3
%464 = getelementptr inbounds float, float* %4, i64 %463
%465 = getelementptr inbounds float, float* %5, i64 %463
%466 = call i64 @inline_diff3f(float* %96, float* %464)
%467 = call i64 @inline_diff3f(float* %101, float* %465)
%468 = sub nsw i64 %466, %467
%469 = call i64 @fabs(i64 %468)
%470 = sitofp i64 %469 to float
%471 = fadd float %458, %470
%472 = add nsw i32 %457, 1
br label %473
473: ; preds = %455, %462
%474 = phi float [ %471, %462 ], [ %458, %455 ]
%475 = phi i32 [ %472, %462 ], [ %457, %455 ]
%476 = add nsw i64 %456, 1
%477 = trunc i64 %476 to i32
%478 = icmp eq i32 %454, %477
br i1 %478, label %479, label %455
479: ; preds = %473
%480 = icmp eq i32 %475, 0
br i1 %480, label %499, label %481
481: ; preds = %479
%482 = sitofp i32 %475 to float
%483 = fdiv float %474, %482
%484 = mul i64 %292, 3
%485 = and i64 %484, 4294967295
%486 = fcmp ogt float %483, 0x3F1A36E2E0000000
br i1 %486, label %487, label %497
487: ; preds = %481
%488 = getelementptr inbounds float, float* %5, i64 %485
%489 = getelementptr inbounds float, float* %4, i64 %485
%490 = call i64 @inline_diff3f(float* %96, float* %489)
%491 = call i64 @inline_diff3f(float* %101, float* %488)
%492 = sub nsw i64 %490, %491
%493 = call i64 @fabs(i64 %492)
%494 = sitofp i64 %493 to float
%495 = fdiv float %494, %483
%496 = getelementptr inbounds float, float* %16, i64 %292
store float %495, float* %496
br label %499
497: ; preds = %481
%498 = getelementptr inbounds float, float* %16, i64 %292
store float 0.000000e+00, float* %498
br label %499
499: ; preds = %443, %370, %297, %441, %487, %497, %479, %366
%500 = phi i64 [ %298, %297 ], [ %304, %441 ], [ %304, %487 ], [ %304, %497 ], [ %304, %479 ], [ %304, %366 ], [ %304, %370 ], [ %304, %443 ]
%501 = add nuw nsw i64 %293, 1
%502 = icmp eq i64 %500, %113
br i1 %502, label %289, label %291
503: ; preds = %290, %524
%504 = phi i64 [ %525, %524 ], [ 0, %290 ]
%505 = phi i64 [ %526, %524 ], [ 0, %290 ]
%506 = getelementptr inbounds i32, i32* %13, i64 %504
%507 = load i32, i32* %506
%508 = icmp eq i32 %507, 0
br i1 %508, label %514, label %509
509: ; preds = %503
%510 = getelementptr inbounds float, float* %16, i64 %504
%511 = load float, float* %510
%512 = fcmp ogt float %511, %0
br i1 %512, label %513, label %514
513: ; preds = %509
store i32 0, i32* %506
br label %514
514: ; preds = %503, %513, %509
%515 = or i64 %504, 1
%516 = getelementptr inbounds i32, i32* %13, i64 %515
%517 = load i32, i32* %516
%518 = icmp eq i32 %517, 0
br i1 %518, label %524, label %519
519: ; preds = %514
%520 = getelementptr inbounds float, float* %16, i64 %515
%521 = load float, float* %520
%522 = fcmp ogt float %521, %0
br i1 %522, label %523, label %524
523: ; preds = %519
store i32 0, i32* %516
br label %524
524: ; preds = %523, %519, %514
%525 = add nuw nsw i64 %504, 2
%526 = add i64 %505, 2
%527 = icmp eq i64 %526, %131
br i1 %527, label %528, label %503
528: ; preds = %524, %290
%529 = phi i64 [ 0, %290 ], [ %525, %524 ]
br i1 %132, label %539, label %530
530: ; preds = %528
%531 = getelementptr inbounds i32, i32* %13, i64 %529
%532 = load i32, i32* %531
%533 = icmp eq i32 %532, 0
br i1 %533, label %539, label %534
534: ; preds = %530
%535 = getelementptr inbounds float, float* %16, i64 %529
%536 = load float, float* %535
%537 = fcmp ogt float %536, %0
br i1 %537, label %538, label %539
538: ; preds = %534
store i32 0, i32* %531
br label %539
539: ; preds = %528, %538, %534, %530, %215, %269, %187, %289, %213
%540 = add nuw nsw i32 %139, 1
%541 = icmp eq i32 %540, %2
br i1 %541, label %542, label %138
542: ; preds = %539, %93
%543 = icmp eq i64 %15, 0
br i1 %543, label %546, label %544
544: ; preds = %542
%545 = call i32 @free(float* %16)
br label %546
546: ; preds = %544, %542
ret i32* %13
}