long scd_parallel_form_iir_down_kernel(lenx, x, y, k0, idown, nblocks,
                                       direct_cof, gain, b, c, T)
long lenx;
float *x, *y;
long *k0, idown, nblocks;
double direct_cof, gain;
float (*b)[3], (*c)[2], (*T)[2];
{
  long kx, ky, n;
  float Ttmp;
  ky = 0;
  for (kx = 0; kx < lenx; kx++) {
    if (*k0 % idown == 0) {
      y[ky] = direct_cof * x[kx];
      for (n = 0; n < nblocks; n++) {
        Ttmp = 2. * (x[kx] - c[n][0] * T[n][0] - c[n][1] * T[n][1]);
        y[ky] += b[n][2] * Ttmp + b[n][1] * T[n][1] + b[n][0] * T[n][0];
        T[n][0] = T[n][1];
        T[n][1] = Ttmp;
      }
      y[ky] *= gain;
      ky++;
    } else {
      for (n = 0; n < nblocks; n++) {
        Ttmp = 2. * (x[kx] - c[n][0] * T[n][0] - c[n][1] * T[n][1]);
        T[n][0] = T[n][1];
        T[n][1] = Ttmp;
      }
    }
    (*k0)++;
  }
  *k0 %= idown;
  return ky;
}


x86 assembly (clang, -O0):
<scd_parallel_form_iir_down_kernel>:
push   %rbp
mov    %rsp,%rbp
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movsd  %xmm0,-0x38(%rbp)
movsd  %xmm1,-0x40(%rbp)
movq   $0x0,-0x50(%rbp)
movq   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x8(%rbp),%rax
jge    1414 <scd_parallel_form_iir_down_kernel+0x314>
mov    -0x20(%rbp),%rax
mov    (%rax),%rax
cqto
idivq  -0x28(%rbp)
cmp    $0x0,%rdx
jne    1315 <scd_parallel_form_iir_down_kernel+0x215>
movsd  -0x38(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x50(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movq   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x30(%rbp),%rax
jge    12e1 <scd_parallel_form_iir_down_kernel+0x1e1>
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
mov    -0x58(%rbp),%rcx
movss  (%rax,%rcx,8),%xmm1
mov    0x20(%rbp),%rax
mov    -0x58(%rbp),%rcx
movss  (%rax,%rcx,8),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    0x18(%rbp),%rax
mov    -0x58(%rbp),%rcx
movss  0x4(%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
mov    -0x58(%rbp),%rcx
movss  0x4(%rax,%rcx,8),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xddf(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    0x10(%rbp),%rax
imul   $0xc,-0x58(%rbp),%rcx
add    %rcx,%rax
movss  0x8(%rax),%xmm1
movss  -0x5c(%rbp),%xmm2
mov    0x10(%rbp),%rax
imul   $0xc,-0x58(%rbp),%rcx
add    %rcx,%rax
movss  0x4(%rax),%xmm0
mov    0x20(%rbp),%rax
mov    -0x58(%rbp),%rcx
mulss  0x4(%rax,%rcx,8),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    0x10(%rbp),%rax
imul   $0xc,-0x58(%rbp),%rcx
add    %rcx,%rax
movss  (%rax),%xmm0
mov    0x20(%rbp),%rax
mov    -0x58(%rbp),%rcx
movss  (%rax,%rcx,8),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x50(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    0x20(%rbp),%rax
mov    -0x58(%rbp),%rcx
movss  0x4(%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
mov    -0x58(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,8)
movss  -0x5c(%rbp),%xmm0
mov    0x20(%rbp),%rax
mov    -0x58(%rbp),%rcx
movss  %xmm0,0x4(%rax,%rcx,8)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    119a <scd_parallel_form_iir_down_kernel+0x9a>
movsd  -0x40(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    13f5 <scd_parallel_form_iir_down_kernel+0x2f5>
movq   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x30(%rbp),%rax
jge    13f0 <scd_parallel_form_iir_down_kernel+0x2f0>
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
mov    -0x58(%rbp),%rcx
movss  (%rax,%rcx,8),%xmm1
mov    0x20(%rbp),%rax
mov    -0x58(%rbp),%rcx
movss  (%rax,%rcx,8),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    0x18(%rbp),%rax
mov    -0x58(%rbp),%rcx
movss  0x4(%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
mov    -0x58(%rbp),%rcx
movss  0x4(%rax,%rcx,8),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xc5c(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    0x20(%rbp),%rax
mov    -0x58(%rbp),%rcx
movss  0x4(%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
mov    -0x58(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,8)
movss  -0x5c(%rbp),%xmm0
mov    0x20(%rbp),%rax
mov    -0x58(%rbp),%rcx
movss  %xmm0,0x4(%rax,%rcx,8)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    131d <scd_parallel_form_iir_down_kernel+0x21d>
jmp    13f5 <scd_parallel_form_iir_down_kernel+0x2f5>
mov    -0x20(%rbp),%rax
mov    (%rax),%rcx
add    $0x1,%rcx
mov    %rcx,(%rax)
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    1142 <scd_parallel_form_iir_down_kernel+0x42>
mov    -0x28(%rbp),%rcx
mov    -0x20(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    (%rax),%rax
cqto
idiv   %rcx
mov    -0x68(%rbp),%rax
mov    %rdx,(%rax)
mov    -0x50(%rbp),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<scd_parallel_form_iir_down_kernel>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
test   %rdi,%rdi
jle    1385 <scd_parallel_form_iir_down_kernel+0x285>
mov    %rdx,%r11
mov    0x48(%rsp),%rbx
mov    0x40(%rsp),%r12
mov    0x38(%rsp),%r13
mov    %rcx,-0x10(%rsp)
mov    (%rcx),%r14
lea    (%rbx,%r9,8),%rcx
lea    (%r12,%r9,8),%rax
cmp    %rbx,%rax
seta   %al
mov    %rcx,-0x8(%rsp)
cmp    %r12,%rcx
seta   %r10b
and    %al,%r10b
mov    %r9,%rcx
and    $0xfffffffffffffffc,%rcx
add    $0x8,%r13
xor    %r15d,%r15d
mov    %r14,-0x18(%rsp)
xor    %ebp,%ebp
jmp    1197 <scd_parallel_form_iir_down_kernel+0x97>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cvtss2sd %xmm2,%xmm2
mulsd  %xmm1,%xmm2
cvtsd2ss %xmm2,%xmm2
movss  %xmm2,(%r11,%r15,4)
add    $0x1,%r15
add    $0x1,%r14
add    $0x1,%rbp
cmp    %rdi,%rbp
je     1376 <scd_parallel_form_iir_down_kernel+0x276>
mov    %r14,%rax
or     %r8,%rax
shr    $0x20,%rax
je     11d0 <scd_parallel_form_iir_down_kernel+0xd0>
mov    %r14,%rax
cqto
idiv   %r8
test   %rdx,%rdx
je     11dd <scd_parallel_form_iir_down_kernel+0xdd>
test   %r9,%r9
jle    1186 <scd_parallel_form_iir_down_kernel+0x86>
cmp    $0x4,%r9
jae    128e <scd_parallel_form_iir_down_kernel+0x18e>
xor    %eax,%eax
jmp    1330 <scd_parallel_form_iir_down_kernel+0x230>
cs nopw 0x0(%rax,%rax,1)
mov    %r14d,%eax
xor    %edx,%edx
div    %r8d
test   %rdx,%rdx
jne    11b0 <scd_parallel_form_iir_down_kernel+0xb0>
movss  (%rsi,%rbp,4),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm0,%xmm2
cvtsd2ss %xmm2,%xmm2
movss  %xmm2,(%r11,%r15,4)
test   %r9,%r9
jle    1170 <scd_parallel_form_iir_down_kernel+0x70>
mov    %r13,%rax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  (%rsi,%rbp,4),%xmm3
movss  (%rbx,%rdx,8),%xmm4
movss  0x4(%rbx,%rdx,8),%xmm5
movss  (%r12,%rdx,8),%xmm6
mulss  %xmm4,%xmm6
subss  %xmm6,%xmm3
movss  0x4(%r12,%rdx,8),%xmm6
mulss  %xmm5,%xmm6
subss  %xmm6,%xmm3
mulss  -0x4(%rax),%xmm5
addss  %xmm3,%xmm3
movss  (%rax),%xmm6
mulss  %xmm3,%xmm6
addss  %xmm5,%xmm6
mulss  -0x8(%rax),%xmm4
addss  %xmm6,%xmm4
addss  %xmm2,%xmm4
movss  %xmm4,(%r11,%r15,4)
movss  0x4(%rbx,%rdx,8),%xmm2
movss  %xmm2,(%rbx,%rdx,8)
movss  %xmm3,0x4(%rbx,%rdx,8)
add    $0x1,%rdx
movss  (%r11,%r15,4),%xmm2
add    $0xc,%rax
cmp    %rdx,%r9
jne    1210 <scd_parallel_form_iir_down_kernel+0x110>
jmp    1170 <scd_parallel_form_iir_down_kernel+0x70>
lea    (%rsi,%rbp,4),%rax
lea    (%rsi,%rbp,4),%rdx
add    $0x4,%rdx
cmp    %rbx,%rdx
seta   %dl
cmp    -0x8(%rsp),%rax
setb   %al
and    %dl,%al
or     %r10b,%al
je     12b6 <scd_parallel_form_iir_down_kernel+0x1b6>
xor    %eax,%eax
jmp    1330 <scd_parallel_form_iir_down_kernel+0x230>
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movss  (%rsi,%rbp,4),%xmm2
shufps $0x0,%xmm2,%xmm2
movups (%r12,%rax,8),%xmm3
movups 0x10(%r12,%rax,8),%xmm4
movaps %xmm3,%xmm5
shufps $0x88,%xmm4,%xmm5
shufps $0xdd,%xmm4,%xmm3
movups (%rbx,%rax,8),%xmm4
movups 0x10(%rbx,%rax,8),%xmm6
movaps %xmm4,%xmm7
shufps $0x88,%xmm6,%xmm7
mulps  %xmm5,%xmm7
subps  %xmm7,%xmm2
shufps $0xdd,%xmm6,%xmm4
mulps  %xmm4,%xmm3
subps  %xmm3,%xmm2
addps  %xmm2,%xmm2
movaps %xmm4,%xmm3
unpckhps %xmm2,%xmm3
unpcklps %xmm2,%xmm4
movups %xmm4,(%rbx,%rax,8)
movups %xmm3,0x10(%rbx,%rax,8)
add    $0x4,%rax
cmp    %rax,%rcx
jne    12c0 <scd_parallel_form_iir_down_kernel+0x1c0>
mov    %rcx,%rax
cmp    %r9,%rcx
je     1186 <scd_parallel_form_iir_down_kernel+0x86>
nopl   0x0(%rax)
movss  (%rsi,%rbp,4),%xmm2
movss  (%r12,%rax,8),%xmm3
mulss  (%rbx,%rax,8),%xmm3
subss  %xmm3,%xmm2
movss  0x4(%rbx,%rax,8),%xmm3
movss  0x4(%r12,%rax,8),%xmm4
mulss  %xmm3,%xmm4
subss  %xmm4,%xmm2
addss  %xmm2,%xmm2
movss  %xmm3,(%rbx,%rax,8)
movss  %xmm2,0x4(%rbx,%rax,8)
add    $0x1,%rax
cmp    %rax,%r9
jne    1330 <scd_parallel_form_iir_down_kernel+0x230>
jmp    1186 <scd_parallel_form_iir_down_kernel+0x86>
mov    -0x18(%rsp),%rax
add    %rdi,%rax
mov    -0x10(%rsp),%rcx
jmp    138b <scd_parallel_form_iir_down_kernel+0x28b>
mov    (%rcx),%rax
xor    %r15d,%r15d
mov    %rax,%rdx
or     %r8,%rdx
shr    $0x20,%rdx
je     139e <scd_parallel_form_iir_down_kernel+0x29e>
cqto
idiv   %r8
jmp    13a3 <scd_parallel_form_iir_down_kernel+0x2a3>
xor    %edx,%edx
div    %r8d
mov    %rdx,(%rcx)
mov    %r15,%rax
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define i64 @scd_parallel_form_iir_down_kernel(i64 %0, float* nocapture %1, float* nocapture %2, i64* nocapture %3, i64 %4, i64 %5, double %6, double %7, [3 x float]* nocapture %8, [2 x float]* nocapture %9, [2 x float]* nocapture %10) {
%12 = icmp sgt i64 %0, 0
br i1 %12, label %15, label %13
13: ; preds = %11
%14 = load i64, i64* %3
br label %143
15: ; preds = %11
%16 = icmp sgt i64 %5, 0
%17 = load i64, i64* %3
%18 = getelementptr [2 x float], [2 x float]* %10, i64 %5, i64 0
%19 = getelementptr [2 x float], [2 x float]* %9, i64 %5, i64 0
%20 = icmp ult i64 %5, 4
%21 = bitcast float* %19 to [2 x float]*
%22 = icmp ugt [2 x float]* %21, %10
%23 = bitcast float* %18 to [2 x float]*
%24 = icmp ugt [2 x float]* %23, %9
%25 = and i1 %22, %24
%26 = and i64 %5, -4
%27 = icmp eq i64 %26, %5
br label %28
28: ; preds = %15, %136
%29 = phi i64 [ %17, %15 ], [ %138, %136 ]
%30 = phi i64 [ 0, %15 ], [ %137, %136 ]
%31 = phi i64 [ 0, %15 ], [ %139, %136 ]
%32 = getelementptr float, float* %1, i64 %31
%33 = add nuw i64 %31, 1
%34 = getelementptr float, float* %1, i64 %33
%35 = srem i64 %29, %4
%36 = icmp eq i64 %35, 0
br i1 %36, label %74, label %37
37: ; preds = %28
br i1 %16, label %38, label %136
38: ; preds = %37
%39 = getelementptr inbounds float, float* %1, i64 %31
br i1 %20, label %72, label %40
40: ; preds = %38
%41 = bitcast float* %34 to [2 x float]*
%42 = icmp ugt [2 x float]* %41, %10
%43 = icmp ult float* %32, %18
%44 = and i1 %42, %43
%45 = or i1 %44, %25
br i1 %45, label %72, label %46
46: ; preds = %40, %46
%47 = phi i64 [ %69, %46 ], [ 0, %40 ]
%48 = load float, float* %39
%49 = insertelement <4 x float> poison, float %48, i64 0
%50 = shufflevector <4 x float> %49, <4 x float> poison, <4 x i32> zeroinitializer
%51 = getelementptr inbounds [2 x float], [2 x float]* %9, i64 %47, i64 0
%52 = bitcast float* %51 to <8 x float>*
%53 = load <8 x float>, <8 x float>* %52
%54 = shufflevector <8 x float> %53, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%55 = shufflevector <8 x float> %53, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%56 = getelementptr inbounds [2 x float], [2 x float]* %10, i64 %47, i64 0
%57 = bitcast float* %56 to <8 x float>*
%58 = load <8 x float>, <8 x float>* %57
%59 = shufflevector <8 x float> %58, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%60 = shufflevector <8 x float> %58, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%61 = fneg <4 x float> %54
%62 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %61, <4 x float> %59, <4 x float> %50)
%63 = fneg <4 x float> %55
%64 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %63, <4 x float> %60, <4 x float> %62)
%65 = fmul <4 x float> %64, <float 2.000000e+00, float 2.000000e+00, float 2.000000e+00, float 2.000000e+00>
%66 = getelementptr inbounds [2 x float], [2 x float]* %10, i64 %47, i64 0
%67 = bitcast float* %66 to <8 x float>*
%68 = shufflevector <4 x float> %60, <4 x float> %65, <8 x i32> <i32 0, i32 4, i32 1, i32 5, i32 2, i32 6, i32 3, i32 7>
store <8 x float> %68, <8 x float>* %67
%69 = add nuw i64 %47, 4
%70 = icmp eq i64 %69, %26
br i1 %70, label %71, label %46
71: ; preds = %46
br i1 %27, label %136, label %72
72: ; preds = %40, %38, %71
%73 = phi i64 [ 0, %40 ], [ 0, %38 ], [ %26, %71 ]
br label %118
74: ; preds = %28
%75 = getelementptr inbounds float, float* %1, i64 %31
%76 = load float, float* %75
%77 = fpext float %76 to double
%78 = fmul double %77, %6
%79 = fptrunc double %78 to float
%80 = getelementptr inbounds float, float* %2, i64 %30
store float %79, float* %80
br i1 %16, label %81, label %112
81: ; preds = %74, %81
%82 = phi float [ %111, %81 ], [ %79, %74 ]
%83 = phi i64 [ %109, %81 ], [ 0, %74 ]
%84 = load float, float* %75
%85 = getelementptr inbounds [2 x float], [2 x float]* %9, i64 %83, i64 0
%86 = load float, float* %85
%87 = getelementptr inbounds [2 x float], [2 x float]* %10, i64 %83, i64 0
%88 = load float, float* %87
%89 = fneg float %86
%90 = tail call float @llvm.fmuladd.f32(float %89, float %88, float %84)
%91 = getelementptr inbounds [2 x float], [2 x float]* %9, i64 %83, i64 1
%92 = load float, float* %91
%93 = getelementptr inbounds [2 x float], [2 x float]* %10, i64 %83, i64 1
%94 = load float, float* %93
%95 = fneg float %92
%96 = tail call float @llvm.fmuladd.f32(float %95, float %94, float %90)
%97 = fmul float %96, 2.000000e+00
%98 = getelementptr inbounds [3 x float], [3 x float]* %8, i64 %83, i64 2
%99 = load float, float* %98
%100 = getelementptr inbounds [3 x float], [3 x float]* %8, i64 %83, i64 1
%101 = load float, float* %100
%102 = fmul float %94, %101
%103 = tail call float @llvm.fmuladd.f32(float %99, float %97, float %102)
%104 = getelementptr inbounds [3 x float], [3 x float]* %8, i64 %83, i64 0
%105 = load float, float* %104
%106 = tail call float @llvm.fmuladd.f32(float %105, float %88, float %103)
%107 = fadd float %82, %106
store float %107, float* %80
%108 = load float, float* %93
store float %108, float* %87
store float %97, float* %93
%109 = add nuw nsw i64 %83, 1
%110 = icmp eq i64 %109, %5
%111 = load float, float* %80
br i1 %110, label %112, label %81
112: ; preds = %81, %74
%113 = phi float [ %79, %74 ], [ %111, %81 ]
%114 = fpext float %113 to double
%115 = fmul double %114, %7
%116 = fptrunc double %115 to float
store float %116, float* %80
%117 = add nsw i64 %30, 1
br label %136
118: ; preds = %72, %118
%119 = phi i64 [ %134, %118 ], [ %73, %72 ]
%120 = load float, float* %39
%121 = getelementptr inbounds [2 x float], [2 x float]* %9, i64 %119, i64 0
%122 = load float, float* %121
%123 = getelementptr inbounds [2 x float], [2 x float]* %10, i64 %119, i64 0
%124 = load float, float* %123
%125 = fneg float %122
%126 = tail call float @llvm.fmuladd.f32(float %125, float %124, float %120)
%127 = getelementptr inbounds [2 x float], [2 x float]* %9, i64 %119, i64 1
%128 = load float, float* %127
%129 = getelementptr inbounds [2 x float], [2 x float]* %10, i64 %119, i64 1
%130 = load float, float* %129
%131 = fneg float %128
%132 = tail call float @llvm.fmuladd.f32(float %131, float %130, float %126)
%133 = fmul float %132, 2.000000e+00
store float %130, float* %123
store float %133, float* %129
%134 = add nuw nsw i64 %119, 1
%135 = icmp eq i64 %134, %5
br i1 %135, label %136, label %118
136: ; preds = %118, %71, %37, %112
%137 = phi i64 [ %117, %112 ], [ %30, %37 ], [ %30, %71 ], [ %30, %118 ]
%138 = add nsw i64 %29, 1
%139 = add nuw nsw i64 %31, 1
%140 = icmp eq i64 %139, %0
br i1 %140, label %141, label %28
141: ; preds = %136
%142 = add i64 %17, %0
br label %143
143: ; preds = %13, %141
%144 = phi i64 [ %142, %141 ], [ %14, %13 ]
%145 = phi i64 [ %137, %141 ], [ 0, %13 ]
%146 = srem i64 %144, %4
store i64 %146, i64* %3
ret i64 %145
}