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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ TriggsM(double *, double *);
void f_iir_xline_filter(double *src, double *dest, int sx, int sy,
                        double *filter) {
  int i, j;
  double b1, b2, b3;
  double pix, p1, p2, p3;
  double sum, sumsq;
  double iplus, uplus, vplus;
  double unp, unp1, unp2;
  double M[9];
  sumsq = filter[3];
  sum = sumsq * sumsq;
  for (i = 0; i < sy; i++) {
    b1 = filter[2];
    b2 = filter[1];
    b3 = filter[0];
    p1 = *src / sumsq;
    p2 = p1;
    p3 = p1;
    iplus = src[sx - 1];
    for (j = 0; j < sx; j++) {
      pix = *src++ + b1 * p1 + b2 * p2 + b3 * p3;
      *dest++ = pix;
      p3 = p2;
      p2 = p1;
      p1 = pix;
    }
    uplus = iplus / (1.0 - b1 - b2 - b3);
    b1 = filter[4];
    b2 = filter[5];
    b3 = filter[6];
    vplus = uplus / (1.0 - b1 - b2 - b3);
    unp = p1 - uplus;
    unp1 = p2 - uplus;
    unp2 = p3 - uplus;
    TriggsM(filter, M);
    pix = M[0] * unp + M[1] * unp1 + M[2] * unp2 + vplus;
    p1 = M[3] * unp + M[4] * unp1 + M[5] * unp2 + vplus;
    p2 = M[6] * unp + M[7] * unp1 + M[8] * unp2 + vplus;
    pix *= sum;
    p1 *= sum;
    p2 *= sum;
    *(--dest) = pix;
    p3 = p2;
    p2 = p1;
    p1 = pix;
    for (j = sx - 2; j >= 0; j--) {
      pix = sum * *(--dest) + b1 * p1 + b2 * p2 + b3 * p3;
      *dest = pix;
      p3 = p2;
      p2 = p1;
      p1 = pix;
    }
    dest += sx;
  }
}


x86 assembly (clang, -O0):
<f_iir_xline_filter>:
push   %rbp
mov    %rsp,%rbp
sub    $0xf0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    -0x20(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm0
mulsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1533 <f_iir_xline_filter+0x423>
mov    -0x20(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x20(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
divsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1268 <f_iir_xline_filter+0x158>
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x8(%rbp)
movsd  (%rax),%xmm1
movsd  -0x30(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x38(%rbp),%xmm1
movsd  -0x58(%rbp),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x40(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x10(%rbp)
movsd  %xmm0,(%rax)
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11ca <f_iir_xline_filter+0xba>
movsd  -0x78(%rbp),%xmm0
movsd  0xd8b(%rip),%xmm1
subsd  -0x30(%rbp),%xmm1
subsd  -0x38(%rbp),%xmm1
subsd  -0x40(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x20(%rbp),%rax
movsd  0x20(%rax),%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x20(%rbp),%rax
movsd  0x28(%rax),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x20(%rbp),%rax
movsd  0x30(%rax),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x80(%rbp),%xmm0
movsd  0xd3c(%rip),%xmm1
subsd  -0x30(%rbp),%xmm1
subsd  -0x38(%rbp),%xmm1
subsd  -0x40(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
subsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
subsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
subsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x20(%rbp),%rdi
lea    -0xf0(%rbp),%rsi
call   1030 <TriggsM@plt>
movsd  -0xf0(%rbp),%xmm1
ff
movsd  -0x90(%rbp),%xmm2
ff
movsd  -0xe8(%rbp),%xmm0
ff
mulsd  -0x98(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xe0(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
addsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x48(%rbp)
movsd  -0xd8(%rbp),%xmm1
ff
movsd  -0x90(%rbp),%xmm2
ff
movsd  -0xd0(%rbp),%xmm0
ff
mulsd  -0x98(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xc8(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
addsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x50(%rbp)
movsd  -0xc0(%rbp),%xmm1
ff
movsd  -0x90(%rbp),%xmm2
ff
movsd  -0xb8(%rbp),%xmm0
ff
mulsd  -0x98(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xb0(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
addsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x58(%rbp)
movsd  -0x68(%rbp),%xmm0
mulsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x68(%rbp),%xmm0
mulsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x68(%rbp),%xmm0
mulsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffff8,%rcx
mov    %rcx,-0x10(%rbp)
movsd  %xmm0,-0x8(%rax)
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x14(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x28(%rbp)
cmpl   $0x0,-0x28(%rbp)
jl     1510 <f_iir_xline_filter+0x400>
movsd  -0x68(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffff8,%rcx
mov    %rcx,-0x10(%rbp)
movsd  -0x8(%rax),%xmm2
movsd  -0x30(%rbp),%xmm1
mulsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x38(%rbp),%xmm1
movsd  -0x58(%rbp),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x40(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x28(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x28(%rbp)
jmp    1479 <f_iir_xline_filter+0x369>
mov    -0x14(%rbp),%ecx
mov    -0x10(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x10(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1151 <f_iir_xline_filter+0x41>
add    $0xf0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<f_iir_xline_filter>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x108,%rsp
mov    %ecx,0xc(%rsp)
test   %ecx,%ecx
jle    15ef <f_iir_xline_filter+0x4df>
mov    %r8,%r13
mov    %edx,%r15d
mov    %rsi,%rbx
mov    %rdi,%rbp
movsd  0x18(%r8),%xmm0
movsd  %xmm0,0x20(%rsp)
mulsd  %xmm0,%xmm0
movapd %xmm0,0xc0(%rsp)
lea    -0x1(%r15),%eax
mov    %eax,0x4(%rsp)
movslq %eax,%r12
lea    -0x2(%r15),%eax
mov    %eax,(%rsp)
movslq %edx,%rcx
unpcklpd %xmm0,%xmm0
movapd %xmm0,0xb0(%rsp)
mov    %rcx,%rax
mov    %rcx,0x10(%rsp)
lea    -0x3(%rcx),%eax
mov    %eax,0x8(%rsp)
mov    %r12,%rax
mov    %r12,0x18(%rsp)
and    $0xfffffffe,%r12d
xor    %r14d,%r14d
jmp    11bf <f_iir_xline_filter+0xaf>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %rbx,%rax
mov    0x10(%rsp),%rcx
lea    (%rax,%rcx,8),%rbx
add    $0xfffffffffffffff8,%rbx
add    $0x1,%r14d
cmp    0xc(%rsp),%r14d
je     15ef <f_iir_xline_filter+0x4df>
movsd  0x10(%r13),%xmm6
movsd  0x0(%r13),%xmm5
movsd  0x8(%r13),%xmm7
movsd  0x0(%rbp),%xmm1
movapd %xmm1,%xmm0
divsd  0x20(%rsp),%xmm0
mov    0x18(%rsp),%rax
movsd  0x0(%rbp,%rax,8),%xmm4
test   %r15d,%r15d
movsd  %xmm4,0x58(%rsp)
jle    1240 <f_iir_xline_filter+0x130>
add    $0x8,%rbp
lea    0x8(%rbx),%rax
movapd %xmm6,%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm1,%xmm2
movapd %xmm7,%xmm3
mulsd  %xmm0,%xmm3
addsd  %xmm2,%xmm3
movapd %xmm5,%xmm1
mulsd  %xmm0,%xmm1
addsd  %xmm3,%xmm1
movsd  %xmm1,(%rbx)
cmp    $0x1,%r15d
jne    1260 <f_iir_xline_filter+0x150>
movapd %xmm1,%xmm2
movapd %xmm0,%xmm3
jmp    133f <f_iir_xline_filter+0x22f>
nopl   0x0(%rax)
movapd %xmm0,%xmm2
movapd %xmm0,%xmm3
movapd %xmm0,%xmm4
jmp    1346 <f_iir_xline_filter+0x236>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cmpl   $0x0,(%rsp)
je     12f7 <f_iir_xline_filter+0x1e7>
xor    %edx,%edx
xor    %ecx,%ecx
movapd %xmm0,%xmm4
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movapd %xmm0,%xmm2
movapd %xmm4,%xmm0
movapd %xmm1,%xmm4
movapd %xmm6,%xmm1
mulsd  %xmm4,%xmm1
addsd  0x0(%rbp,%rdx,8),%xmm1
mulsd  %xmm5,%xmm0
movapd %xmm7,%xmm3
mulsd  %xmm2,%xmm3
addsd  %xmm1,%xmm3
addsd  %xmm3,%xmm0
movsd  %xmm0,(%rax,%rdx,8)
movapd %xmm6,%xmm1
mulsd  %xmm0,%xmm1
addsd  0x8(%rbp,%rdx,8),%xmm1
movapd %xmm7,%xmm3
mulsd  %xmm4,%xmm3
addsd  %xmm1,%xmm3
mulsd  %xmm5,%xmm2
movapd %xmm2,%xmm1
addsd  %xmm3,%xmm1
movsd  %xmm1,0x8(%rax,%rdx,8)
add    $0xfffffffffffffff0,%rcx
add    $0x2,%rdx
cmp    %edx,%r12d
jne    1280 <f_iir_xline_filter+0x170>
sub    %rcx,%rax
sub    %rcx,%rbp
mov    %rax,%rbx
jmp    12fb <f_iir_xline_filter+0x1eb>
movapd %xmm0,%xmm4
movapd %xmm1,%xmm2
movapd %xmm0,%xmm3
testb  $0x1,0x4(%rsp)
je     1346 <f_iir_xline_filter+0x236>
movapd %xmm6,%xmm2
mulsd  %xmm1,%xmm2
addsd  0x0(%rbp),%xmm2
add    $0x8,%rbp
movapd %xmm7,%xmm3
mulsd  %xmm0,%xmm3
addsd  %xmm2,%xmm3
mulsd  %xmm5,%xmm4
addsd  %xmm3,%xmm4
movsd  %xmm4,(%rax)
add    $0x8,%rax
movapd %xmm4,%xmm2
movapd %xmm1,%xmm3
movapd %xmm0,%xmm4
mov    %rax,%rbx
movapd %xmm4,0xd0(%rsp)
movapd %xmm3,0xe0(%rsp)
movapd %xmm2,0xf0(%rsp)
movsd  0x20(%r13),%xmm0
movsd  %xmm0,0x48(%rsp)
movsd  0x28(%r13),%xmm0
movsd  %xmm0,0x38(%rsp)
movsd  0x30(%r13),%xmm0
movsd  %xmm0,0x28(%rsp)
mov    %r13,%rdi
lea    0x60(%rsp),%rsi
movsd  %xmm5,0x50(%rsp)
movsd  %xmm6,0x30(%rsp)
movsd  %xmm7,0x40(%rsp)
call   1030 <TriggsM@plt>
movapd 0xe0(%rsp),%xmm14
movapd 0xf0(%rsp),%xmm4
movsd  0x28(%rsp),%xmm6
movsd  0x38(%rsp),%xmm12
movsd  0x48(%rsp),%xmm7
movsd  0xc2e(%rip),%xmm1
movapd %xmm1,%xmm0
subsd  0x30(%rsp),%xmm0
subsd  0x40(%rsp),%xmm0
subsd  0x50(%rsp),%xmm0
movsd  0x58(%rsp),%xmm2
divsd  %xmm0,%xmm2
subsd  %xmm7,%xmm1
subsd  %xmm12,%xmm1
subsd  %xmm6,%xmm1
movapd %xmm2,%xmm0
divsd  %xmm1,%xmm0
subsd  %xmm2,%xmm4
subsd  %xmm2,%xmm14
movapd 0xd0(%rsp),%xmm15
subsd  %xmm2,%xmm15
movsd  0x68(%rsp),%xmm1
mulsd  %xmm14,%xmm1
movsd  0x60(%rsp),%xmm2
mulsd  %xmm4,%xmm2
addsd  %xmm1,%xmm2
movsd  0x70(%rsp),%xmm1
mulsd  %xmm15,%xmm1
addsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movupd 0x78(%rsp),%xmm13
movapd 0x80(%rsp),%xmm3
movupd 0x88(%rsp),%xmm11
movsd  0x90(%rsp),%xmm9
movsd  0x98(%rsp),%xmm10
movsd  0xa0(%rsp),%xmm8
movapd 0xc0(%rsp),%xmm5
mulsd  %xmm5,%xmm1
movsd  %xmm1,-0x8(%rbx)
cmp    $0x2,%r15d
jl     11a0 <f_iir_xline_filter+0x90>
movapd %xmm15,%xmm2
lea    -0x8(%rbx),%rax
unpcklpd %xmm14,%xmm14
unpcklpd %xmm10,%xmm3
mulpd  %xmm14,%xmm3
unpcklpd %xmm9,%xmm13
unpcklpd %xmm4,%xmm4
mulpd  %xmm13,%xmm4
addpd  %xmm3,%xmm4
unpcklpd %xmm8,%xmm11
unpcklpd %xmm15,%xmm2
mulpd  %xmm11,%xmm2
addpd  %xmm4,%xmm2
unpcklpd %xmm0,%xmm0
addpd  %xmm2,%xmm0
mulpd  0xb0(%rsp),%xmm0
testb  $0x1,0x4(%rsp)
jne    1510 <f_iir_xline_filter+0x400>
mov    %rax,%rcx
mov    (%rsp),%esi
mov    %esi,%edx
test   %esi,%esi
jne    1566 <f_iir_xline_filter+0x456>
jmp    11a3 <f_iir_xline_filter+0x93>
cs nopw 0x0(%rax,%rax,1)
nop
lea    -0x10(%rbx),%rcx
movapd %xmm7,%xmm2
mulsd  %xmm1,%xmm2
movsd  -0x10(%rbx),%xmm3
mulsd  %xmm5,%xmm3
addsd  %xmm2,%xmm3
movapd %xmm12,%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm3,%xmm2
movapd %xmm1,%xmm3
unpcklpd %xmm0,%xmm3
unpckhpd %xmm0,%xmm0
mulsd  %xmm6,%xmm0
addsd  %xmm2,%xmm0
movsd  %xmm0,-0x10(%rbx)
mov    0x8(%rsp),%edx
movapd %xmm0,%xmm1
movapd %xmm3,%xmm0
mov    (%rsp),%esi
test   %esi,%esi
je     11a3 <f_iir_xline_filter+0x93>
add    $0x8,%rcx
add    $0x1,%edx
nopl   (%rax)
lea    -0x10(%rcx),%rax
movapd %xmm7,%xmm2
mulsd  %xmm1,%xmm2
movsd  -0x10(%rcx),%xmm3
mulsd  %xmm5,%xmm3
addsd  %xmm2,%xmm3
movapd %xmm12,%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm3,%xmm2
movapd %xmm6,%xmm3
mulsd  %xmm0,%xmm3
unpckhpd %xmm0,%xmm0
mulsd  %xmm6,%xmm0
addsd  %xmm2,%xmm0
movsd  %xmm0,-0x10(%rcx)
movapd %xmm7,%xmm2
mulsd  %xmm0,%xmm2
movsd  -0x18(%rcx),%xmm4
mulsd  %xmm5,%xmm4
addsd  %xmm2,%xmm4
movapd %xmm12,%xmm2
mulsd  %xmm1,%xmm2
addsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
movsd  %xmm2,-0x18(%rcx)
unpcklpd %xmm1,%xmm0
mov    %rax,%rcx
movapd %xmm2,%xmm1
add    $0xfffffffe,%edx
jne    1570 <f_iir_xline_filter+0x460>
jmp    11a3 <f_iir_xline_filter+0x93>
add    $0x108,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @f_iir_xline_filter(double* %0, double* %1, i32 %2, i32 %3, double* %4) {
%6 = alloca double*
%7 = alloca double*
%8 = alloca i32
%9 = alloca i32
%10 = alloca double*
%11 = alloca i32
%12 = alloca i32
%13 = alloca double
%14 = alloca double
%15 = alloca double
%16 = alloca double
%17 = alloca double
%18 = alloca double
%19 = alloca double
%20 = alloca double
%21 = alloca double
%22 = alloca double
%23 = alloca double
%24 = alloca double
%25 = alloca double
%26 = alloca double
%27 = alloca double
%28 = alloca [9 x double]
store double* %0, double** %6
store double* %1, double** %7
store i32 %2, i32* %8
store i32 %3, i32* %9
store double* %4, double** %10
%29 = load double*, double** %10
%30 = getelementptr inbounds double, double* %29, i64 3
%31 = load double, double* %30
store double %31, double* %21
%32 = load double, double* %21
%33 = load double, double* %21
%34 = fmul double %32, %33
store double %34, double* %20
store i32 0, i32* %11
br label %35
35: ; preds = %215, %5
%36 = load i32, i32* %11
%37 = load i32, i32* %9
%38 = icmp slt i32 %36, %37
br i1 %38, label %39, label %218
39: ; preds = %35
%40 = load double*, double** %10
%41 = getelementptr inbounds double, double* %40, i64 2
%42 = load double, double* %41
store double %42, double* %13
%43 = load double*, double** %10
%44 = getelementptr inbounds double, double* %43, i64 1
%45 = load double, double* %44
store double %45, double* %14
%46 = load double*, double** %10
%47 = getelementptr inbounds double, double* %46, i64 0
%48 = load double, double* %47
store double %48, double* %15
%49 = load double*, double** %6
%50 = load double, double* %49
%51 = load double, double* %21
%52 = fdiv double %50, %51
store double %52, double* %17
%53 = load double, double* %17
store double %53, double* %18
%54 = load double, double* %17
store double %54, double* %19
%55 = load double*, double** %6
%56 = load i32, i32* %8
%57 = sub nsw i32 %56, 1
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds double, double* %55, i64 %58
%60 = load double, double* %59
store double %60, double* %22
store i32 0, i32* %12
br label %61
61: ; preds = %84, %39
%62 = load i32, i32* %12
%63 = load i32, i32* %8
%64 = icmp slt i32 %62, %63
br i1 %64, label %65, label %87
65: ; preds = %61
%66 = load double*, double** %6
%67 = getelementptr inbounds double, double* %66, i32 1
store double* %67, double** %6
%68 = load double, double* %66
%69 = load double, double* %13
%70 = load double, double* %17
%71 = call double @llvm.fmuladd.f64(double %69, double %70, double %68)
%72 = load double, double* %14
%73 = load double, double* %18
%74 = call double @llvm.fmuladd.f64(double %72, double %73, double %71)
%75 = load double, double* %15
%76 = load double, double* %19
%77 = call double @llvm.fmuladd.f64(double %75, double %76, double %74)
store double %77, double* %16
%78 = load double, double* %16
%79 = load double*, double** %7
%80 = getelementptr inbounds double, double* %79, i32 1
store double* %80, double** %7
store double %78, double* %79
%81 = load double, double* %18
store double %81, double* %19
%82 = load double, double* %17
store double %82, double* %18
%83 = load double, double* %16
store double %83, double* %17
br label %84
84: ; preds = %65
%85 = load i32, i32* %12
%86 = add nsw i32 %85, 1
store i32 %86, i32* %12
br label %61
87: ; preds = %61
%88 = load double, double* %22
%89 = load double, double* %13
%90 = fsub double 1.000000e+00, %89
%91 = load double, double* %14
%92 = fsub double %90, %91
%93 = load double, double* %15
%94 = fsub double %92, %93
%95 = fdiv double %88, %94
store double %95, double* %23
%96 = load double*, double** %10
%97 = getelementptr inbounds double, double* %96, i64 4
%98 = load double, double* %97
store double %98, double* %13
%99 = load double*, double** %10
%100 = getelementptr inbounds double, double* %99, i64 5
%101 = load double, double* %100
store double %101, double* %14
%102 = load double*, double** %10
%103 = getelementptr inbounds double, double* %102, i64 6
%104 = load double, double* %103
store double %104, double* %15
%105 = load double, double* %23
%106 = load double, double* %13
%107 = fsub double 1.000000e+00, %106
%108 = load double, double* %14
%109 = fsub double %107, %108
%110 = load double, double* %15
%111 = fsub double %109, %110
%112 = fdiv double %105, %111
store double %112, double* %24
%113 = load double, double* %17
%114 = load double, double* %23
%115 = fsub double %113, %114
store double %115, double* %25
%116 = load double, double* %18
%117 = load double, double* %23
%118 = fsub double %116, %117
store double %118, double* %26
%119 = load double, double* %19
%120 = load double, double* %23
%121 = fsub double %119, %120
store double %121, double* %27
%122 = load double*, double** %10
%123 = getelementptr inbounds [9 x double], [9 x double]* %28, i64 0, i64 0
%124 = call i32 @TriggsM(double* %122, double* %123)
%125 = getelementptr inbounds [9 x double], [9 x double]* %28, i64 0, i64 0
%126 = load double, double* %125
%127 = load double, double* %25
%128 = getelementptr inbounds [9 x double], [9 x double]* %28, i64 0, i64 1
%129 = load double, double* %128
%130 = load double, double* %26
%131 = fmul double %129, %130
%132 = call double @llvm.fmuladd.f64(double %126, double %127, double %131)
%133 = getelementptr inbounds [9 x double], [9 x double]* %28, i64 0, i64 2
%134 = load double, double* %133
%135 = load double, double* %27
%136 = call double @llvm.fmuladd.f64(double %134, double %135, double %132)
%137 = load double, double* %24
%138 = fadd double %136, %137
store double %138, double* %16
%139 = getelementptr inbounds [9 x double], [9 x double]* %28, i64 0, i64 3
%140 = load double, double* %139
%141 = load double, double* %25
%142 = getelementptr inbounds [9 x double], [9 x double]* %28, i64 0, i64 4
%143 = load double, double* %142
%144 = load double, double* %26
%145 = fmul double %143, %144
%146 = call double @llvm.fmuladd.f64(double %140, double %141, double %145)
%147 = getelementptr inbounds [9 x double], [9 x double]* %28, i64 0, i64 5
%148 = load double, double* %147
%149 = load double, double* %27
%150 = call double @llvm.fmuladd.f64(double %148, double %149, double %146)
%151 = load double, double* %24
%152 = fadd double %150, %151
store double %152, double* %17
%153 = getelementptr inbounds [9 x double], [9 x double]* %28, i64 0, i64 6
%154 = load double, double* %153
%155 = load double, double* %25
%156 = getelementptr inbounds [9 x double], [9 x double]* %28, i64 0, i64 7
%157 = load double, double* %156
%158 = load double, double* %26
%159 = fmul double %157, %158
%160 = call double @llvm.fmuladd.f64(double %154, double %155, double %159)
%161 = getelementptr inbounds [9 x double], [9 x double]* %28, i64 0, i64 8
%162 = load double, double* %161
%163 = load double, double* %27
%164 = call double @llvm.fmuladd.f64(double %162, double %163, double %160)
%165 = load double, double* %24
%166 = fadd double %164, %165
store double %166, double* %18
%167 = load double, double* %20
%168 = load double, double* %16
%169 = fmul double %168, %167
store double %169, double* %16
%170 = load double, double* %20
%171 = load double, double* %17
%172 = fmul double %171, %170
store double %172, double* %17
%173 = load double, double* %20
%174 = load double, double* %18
%175 = fmul double %174, %173
store double %175, double* %18
%176 = load double, double* %16
%177 = load double*, double** %7
%178 = getelementptr inbounds double, double* %177, i32 -1
store double* %178, double** %7
store double %176, double* %178
%179 = load double, double* %18
store double %179, double* %19
%180 = load double, double* %17
store double %180, double* %18
%181 = load double, double* %16
store double %181, double* %17
%182 = load i32, i32* %8
%183 = sub nsw i32 %182, 2
store i32 %183, i32* %12
br label %184
184: ; preds = %207, %87
%185 = load i32, i32* %12
%186 = icmp sge i32 %185, 0
br i1 %186, label %187, label %210
187: ; preds = %184
%188 = load double, double* %20
%189 = load double*, double** %7
%190 = getelementptr inbounds double, double* %189, i32 -1
store double* %190, double** %7
%191 = load double, double* %190
%192 = load double, double* %13
%193 = load double, double* %17
%194 = fmul double %192, %193
%195 = call double @llvm.fmuladd.f64(double %188, double %191, double %194)
%196 = load double, double* %14
%197 = load double, double* %18
%198 = call double @llvm.fmuladd.f64(double %196, double %197, double %195)
%199 = load double, double* %15
%200 = load double, double* %19
%201 = call double @llvm.fmuladd.f64(double %199, double %200, double %198)
store double %201, double* %16
%202 = load double, double* %16
%203 = load double*, double** %7
store double %202, double* %203
%204 = load double, double* %18
store double %204, double* %19
%205 = load double, double* %17
store double %205, double* %18
%206 = load double, double* %16
store double %206, double* %17
br label %207
207: ; preds = %187
%208 = load i32, i32* %12
%209 = add nsw i32 %208, -1
store i32 %209, i32* %12
br label %184
210: ; preds = %184
%211 = load i32, i32* %8
%212 = load double*, double** %7
%213 = sext i32 %211 to i64
%214 = getelementptr inbounds double, double* %212, i64 %213
store double* %214, double** %7
br label %215
215: ; preds = %210
%216 = load i32, i32* %11
%217 = add nsw i32 %216, 1
store i32 %217, i32* %11
br label %35
218: ; preds = %35
ret void
}

LLVM IR (-O2):
define void @f_iir_xline_filter(double* nocapture %0, double* nocapture %1, i32 %2, i32 %3, double* %4) {
%6 = alloca [9 x double]
%7 = bitcast [9 x double]* %6 to i8*
%8 = getelementptr inbounds double, double* %4, i64 3
%9 = load double, double* %8
%10 = fmul double %9, %9
%11 = icmp sgt i32 %3, 0
br i1 %11, label %12, label %207
12: ; preds = %5
%13 = getelementptr inbounds double, double* %4, i64 2
%14 = getelementptr inbounds double, double* %4, i64 1
%15 = add nsw i32 %2, -1
%16 = sext i32 %15 to i64
%17 = icmp sgt i32 %2, 0
%18 = getelementptr inbounds double, double* %4, i64 4
%19 = getelementptr inbounds double, double* %4, i64 5
%20 = getelementptr inbounds double, double* %4, i64 6
%21 = getelementptr inbounds [9 x double], [9 x double]* %6, i64 0, i64 0
%22 = getelementptr inbounds [9 x double], [9 x double]* %6, i64 0, i64 1
%23 = getelementptr inbounds [9 x double], [9 x double]* %6, i64 0, i64 2
%24 = getelementptr inbounds [9 x double], [9 x double]* %6, i64 0, i64 3
%25 = getelementptr inbounds [9 x double], [9 x double]* %6, i64 0, i64 4
%26 = getelementptr inbounds [9 x double], [9 x double]* %6, i64 0, i64 5
%27 = getelementptr inbounds [9 x double], [9 x double]* %6, i64 0, i64 6
%28 = getelementptr inbounds [9 x double], [9 x double]* %6, i64 0, i64 7
%29 = getelementptr inbounds [9 x double], [9 x double]* %6, i64 0, i64 8
%30 = add nsw i32 %2, -2
%31 = icmp sgt i32 %2, 1
%32 = sext i32 %2 to i64
%33 = insertelement <2 x double> poison, double %10, i64 0
%34 = shufflevector <2 x double> %33, <2 x double> poison, <2 x i32> zeroinitializer
%35 = add i32 %2, -1
%36 = add i32 %2, -2
%37 = icmp eq i32 %2, 1
%38 = and i32 %35, 1
%39 = icmp eq i32 %36, 0
%40 = and i32 %35, -2
%41 = icmp eq i32 %38, 0
%42 = bitcast double* %24 to <2 x double>*
%43 = bitcast double* %25 to <2 x double>*
%44 = bitcast double* %26 to <2 x double>*
%45 = and i32 %35, 1
%46 = icmp eq i32 %45, 0
%47 = add nsw i32 %2, -3
%48 = icmp eq i32 %36, 0
br label %49
49: ; preds = %12, %201
%50 = phi double* [ %0, %12 ], [ %111, %201 ]
%51 = phi double* [ %1, %12 ], [ %204, %201 ]
%52 = phi i32 [ 0, %12 ], [ %205, %201 ]
%53 = load double, double* %13
%54 = load double, double* %14
%55 = load double, double* %4
%56 = load double, double* %50
%57 = fdiv double %56, %9
%58 = getelementptr inbounds double, double* %50, i64 %16
%59 = load double, double* %58
br i1 %17, label %60, label %106
60: ; preds = %49
%61 = getelementptr inbounds double, double* %50, i64 1
%62 = call double @llvm.fmuladd.f64(double %53, double %57, double %56)
%63 = call double @llvm.fmuladd.f64(double %54, double %57, double %62)
%64 = call double @llvm.fmuladd.f64(double %55, double %57, double %63)
%65 = getelementptr inbounds double, double* %51, i64 1
store double %64, double* %51
br i1 %37, label %106, label %66
66: ; preds = %60
br i1 %39, label %88, label %67
67: ; preds = %66, %67
%68 = phi double* [ %85, %67 ], [ %65, %66 ]
%69 = phi double [ %84, %67 ], [ %64, %66 ]
%70 = phi double* [ %81, %67 ], [ %61, %66 ]
%71 = phi double [ %78, %67 ], [ %57, %66 ]
%72 = phi double [ %69, %67 ], [ %57, %66 ]
%73 = phi i32 [ %86, %67 ], [ 0, %66 ]
%74 = load double, double* %70
%75 = getelementptr inbounds double, double* %70, i64 1
%76 = call double @llvm.fmuladd.f64(double %53, double %69, double %74)
%77 = call double @llvm.fmuladd.f64(double %54, double %71, double %76)
%78 = call double @llvm.fmuladd.f64(double %55, double %72, double %77)
%79 = getelementptr inbounds double, double* %68, i64 1
store double %78, double* %68
%80 = load double, double* %75
%81 = getelementptr inbounds double, double* %70, i64 2
%82 = call double @llvm.fmuladd.f64(double %53, double %78, double %80)
%83 = call double @llvm.fmuladd.f64(double %54, double %69, double %82)
%84 = call double @llvm.fmuladd.f64(double %55, double %71, double %83)
%85 = getelementptr inbounds double, double* %68, i64 2
store double %84, double* %79
%86 = add i32 %73, 2
%87 = icmp eq i32 %86, %40
br i1 %87, label %88, label %67
88: ; preds = %67, %66
%89 = phi double [ undef, %66 ], [ %78, %67 ]
%90 = phi double [ undef, %66 ], [ %69, %67 ]
%91 = phi double* [ undef, %66 ], [ %81, %67 ]
%92 = phi double [ undef, %66 ], [ %84, %67 ]
%93 = phi double* [ undef, %66 ], [ %85, %67 ]
%94 = phi double* [ %65, %66 ], [ %85, %67 ]
%95 = phi double [ %64, %66 ], [ %84, %67 ]
%96 = phi double* [ %61, %66 ], [ %81, %67 ]
%97 = phi double [ %57, %66 ], [ %78, %67 ]
%98 = phi double [ %57, %66 ], [ %69, %67 ]
br i1 %41, label %106, label %99
99: ; preds = %88
%100 = load double, double* %96
%101 = getelementptr inbounds double, double* %96, i64 1
%102 = call double @llvm.fmuladd.f64(double %53, double %95, double %100)
%103 = call double @llvm.fmuladd.f64(double %54, double %97, double %102)
%104 = call double @llvm.fmuladd.f64(double %55, double %98, double %103)
%105 = getelementptr inbounds double, double* %94, i64 1
store double %104, double* %94
br label %106
106: ; preds = %99, %88, %60, %49
%107 = phi double [ %57, %49 ], [ %64, %60 ], [ %92, %88 ], [ %104, %99 ]
%108 = phi double [ %57, %49 ], [ %57, %60 ], [ %89, %88 ], [ %95, %99 ]
%109 = phi double [ %57, %49 ], [ %57, %60 ], [ %90, %88 ], [ %97, %99 ]
%110 = phi double* [ %51, %49 ], [ %65, %60 ], [ %93, %88 ], [ %105, %99 ]
%111 = phi double* [ %50, %49 ], [ %61, %60 ], [ %91, %88 ], [ %101, %99 ]
%112 = fsub double 1.000000e+00, %53
%113 = fsub double %112, %54
%114 = fsub double %113, %55
%115 = fdiv double %59, %114
%116 = load double, double* %18
%117 = load double, double* %19
%118 = load double, double* %20
%119 = fsub double 1.000000e+00, %116
%120 = fsub double %119, %117
%121 = fsub double %120, %118
%122 = fdiv double %115, %121
%123 = fsub double %107, %115
%124 = fsub double %108, %115
%125 = fsub double %109, %115
%126 = call i32 @TriggsM(double* %4, double* %21)
%127 = load double, double* %21
%128 = load double, double* %22
%129 = fmul double %124, %128
%130 = call double @llvm.fmuladd.f64(double %127, double %123, double %129)
%131 = load double, double* %23
%132 = call double @llvm.fmuladd.f64(double %131, double %125, double %130)
%133 = fadd double %122, %132
%134 = load <2 x double>, <2 x double>* %42
%135 = load <2 x double>, <2 x double>* %43
%136 = load <2 x double>, <2 x double>* %44
%137 = load double, double* %27
%138 = load double, double* %28
%139 = load double, double* %29
%140 = fmul double %10, %133
%141 = getelementptr inbounds double, double* %110, i64 -1
store double %140, double* %141
br i1 %31, label %142, label %201
142: ; preds = %106
%143 = insertelement <2 x double> poison, double %124, i64 0
%144 = shufflevector <2 x double> %143, <2 x double> poison, <2 x i32> zeroinitializer
%145 = insertelement <2 x double> %135, double %138, i64 1
%146 = fmul <2 x double> %144, %145
%147 = insertelement <2 x double> %134, double %137, i64 1
%148 = insertelement <2 x double> poison, double %123, i64 0
%149 = shufflevector <2 x double> %148, <2 x double> poison, <2 x i32> zeroinitializer
%150 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %147, <2 x double> %149, <2 x double> %146)
%151 = insertelement <2 x double> %136, double %139, i64 1
%152 = insertelement <2 x double> poison, double %125, i64 0
%153 = shufflevector <2 x double> %152, <2 x double> poison, <2 x i32> zeroinitializer
%154 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %151, <2 x double> %153, <2 x double> %150)
%155 = insertelement <2 x double> poison, double %122, i64 0
%156 = shufflevector <2 x double> %155, <2 x double> poison, <2 x i32> zeroinitializer
%157 = fadd <2 x double> %156, %154
%158 = fmul <2 x double> %34, %157
br i1 %46, label %170, label %159
159: ; preds = %142
%160 = getelementptr inbounds double, double* %110, i64 -2
%161 = load double, double* %160
%162 = fmul double %116, %140
%163 = call double @llvm.fmuladd.f64(double %10, double %161, double %162)
%164 = extractelement <2 x double> %158, i64 0
%165 = call double @llvm.fmuladd.f64(double %117, double %164, double %163)
%166 = extractelement <2 x double> %158, i64 1
%167 = call double @llvm.fmuladd.f64(double %118, double %166, double %165)
store double %167, double* %160
%168 = insertelement <2 x double> poison, double %140, i64 0
%169 = shufflevector <2 x double> %168, <2 x double> %158, <2 x i32> <i32 0, i32 2>
br label %170
170: ; preds = %159, %142
%171 = phi double* [ %141, %142 ], [ %160, %159 ]
%172 = phi i32 [ %30, %142 ], [ %47, %159 ]
%173 = phi double [ %140, %142 ], [ %167, %159 ]
%174 = phi <2 x double> [ %158, %142 ], [ %169, %159 ]
br i1 %48, label %201, label %175
175: ; preds = %170, %175
%176 = phi double* [ %188, %175 ], [ %171, %170 ]
%177 = phi i32 [ %195, %175 ], [ %172, %170 ]
%178 = phi double [ %194, %175 ], [ %173, %170 ]
%179 = phi <2 x double> [ %198, %175 ], [ %174, %170 ]
%180 = getelementptr inbounds double, double* %176, i64 -1
%181 = load double, double* %180
%182 = fmul double %116, %178
%183 = call double @llvm.fmuladd.f64(double %10, double %181, double %182)
%184 = extractelement <2 x double> %179, i64 0
%185 = call double @llvm.fmuladd.f64(double %117, double %184, double %183)
%186 = extractelement <2 x double> %179, i64 1
%187 = call double @llvm.fmuladd.f64(double %118, double %186, double %185)
store double %187, double* %180
%188 = getelementptr inbounds double, double* %176, i64 -2
%189 = load double, double* %188
%190 = fmul double %116, %187
%191 = call double @llvm.fmuladd.f64(double %10, double %189, double %190)
%192 = call double @llvm.fmuladd.f64(double %117, double %178, double %191)
%193 = extractelement <2 x double> %179, i64 0
%194 = call double @llvm.fmuladd.f64(double %118, double %193, double %192)
store double %194, double* %188
%195 = add nsw i32 %177, -2
%196 = icmp eq i32 %177, 1
%197 = insertelement <2 x double> poison, double %187, i64 0
%198 = insertelement <2 x double> %197, double %178, i64 1
br i1 %196, label %199, label %175
199: ; preds = %175
%200 = getelementptr inbounds double, double* %176, i64 -1
br label %201
201: ; preds = %199, %170, %106
%202 = phi double* [ %110, %106 ], [ %141, %170 ], [ %200, %199 ]
%203 = getelementptr inbounds double, double* %202, i64 -1
%204 = getelementptr inbounds double, double* %203, i64 %32
%205 = add nuw nsw i32 %52, 1
%206 = icmp eq i32 %205, %3
br i1 %206, label %207, label %49
207: ; preds = %201, %5
ret void
}