void filter2dsepglobal(float **p3, float **q3, float **p3c, float **q3c,
                       float **xxx, float **zzz, int nx, int nz, int hnkx1,
                       int hnkz1) {
  int i, j, k, l, kk, ll, ik, jl, ikm, jlm;
  for (i = 0; i < nx; i++)
    for (j = 0; j < nz; j++) {
      for (k = -hnkx1; k <= hnkx1; k++) {
        ik = i + k;
        ikm = ik + 5;
        kk = k + hnkx1;
        for (l = -hnkz1; l <= hnkz1; l++) {
          jl = j + l;
          jlm = jl + 5;
          ll = l + hnkz1;
          if (ik >= 0 && ik < nx && jl >= 0 && jl < nz) {
            p3c[i][j] += p3[ikm][jlm] * xxx[kk][ll];
            q3c[i][j] += q3[ikm][jlm] * zzz[kk][ll];
          }
        }
      }
    }
}


x86 assembly (clang, -O0):
<filter2dsepglobal>:
push   %rbp
mov    %rsp,%rbp
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    12bc <filter2dsepglobal+0x1bc>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    12a9 <filter2dsepglobal+0x1a9>
xor    %eax,%eax
sub    0x20(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    0x20(%rbp),%eax
jg     1296 <filter2dsepglobal+0x196>
mov    -0x34(%rbp),%eax
add    -0x3c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
add    $0x5,%eax
mov    %eax,-0x54(%rbp)
mov    -0x3c(%rbp),%eax
add    0x20(%rbp),%eax
mov    %eax,-0x44(%rbp)
xor    %eax,%eax
sub    0x28(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    0x28(%rbp),%eax
jg     1283 <filter2dsepglobal+0x183>
mov    -0x38(%rbp),%eax
add    -0x40(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
add    $0x5,%eax
mov    %eax,-0x58(%rbp)
mov    -0x40(%rbp),%eax
add    0x28(%rbp),%eax
mov    %eax,-0x48(%rbp)
cmpl   $0x0,-0x4c(%rbp)
jl     1270 <filter2dsepglobal+0x170>
mov    -0x4c(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1270 <filter2dsepglobal+0x170>
cmpl   $0x0,-0x50(%rbp)
jl     1270 <filter2dsepglobal+0x170>
mov    -0x50(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1270 <filter2dsepglobal+0x170>
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    1275 <filter2dsepglobal+0x175>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1185 <filter2dsepglobal+0x85>
jmp    1288 <filter2dsepglobal+0x188>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1156 <filter2dsepglobal+0x56>
jmp    129b <filter2dsepglobal+0x19b>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1142 <filter2dsepglobal+0x42>
jmp    12ae <filter2dsepglobal+0x1ae>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    112f <filter2dsepglobal+0x2f>
pop    %rbp
ret

x86 assembly (clang, -O2):
<filter2dsepglobal>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %r9,-0x8(%rsp)
mov    %r8,-0x10(%rsp)
mov    %rcx,-0x18(%rsp)
mov    %rdx,-0x20(%rsp)
mov    %rsi,-0x28(%rsp)
mov    0x38(%rsp),%r10d
test   %r10d,%r10d
jle    12ab <filter2dsepglobal+0x1ab>
mov    0x50(%rsp),%eax
mov    0x48(%rsp),%r8d
mov    %eax,%ebp
neg    %ebp
movslq %ebp,%rdx
movslq 0x40(%rsp),%rsi
mov    %edx,%ebp
cmovs  %eax,%ebp
movslq %eax,%r9
mov    %r8d,%eax
neg    %eax
movslq %eax,%rcx
mov    %r10d,%eax
movslq %r8d,%rbx
mov    %rbx,-0x30(%rsp)
mov    %rcx,-0x48(%rsp)
cmovs  %r8d,%ecx
add    $0x1,%ecx
mov    %ecx,-0x5c(%rsp)
mov    %esi,%ecx
mov    %rcx,-0x40(%rsp)
mov    %rdx,-0x50(%rsp)
lea    (%r9,%rdx,1),%rcx
mov    %rcx,-0x38(%rsp)
lea    (%r9,%rbp,1),%ecx
add    $0x1,%ecx
mov    %ecx,-0x60(%rsp)
xor    %r15d,%r15d
jmp    11ad <filter2dsepglobal+0xad>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r15
cmp    %rax,%r15
je     12ab <filter2dsepglobal+0x1ab>
cmpl   $0x0,0x40(%rsp)
jle    11a0 <filter2dsepglobal+0xa0>
mov    -0x50(%rsp),%rcx
mov    %rcx,-0x58(%rsp)
xor    %r12d,%r12d
jmp    11e1 <filter2dsepglobal+0xe1>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r12
addq   $0x1,-0x58(%rsp)
cmp    -0x40(%rsp),%r12
je     11a0 <filter2dsepglobal+0xa0>
cmpl   $0x0,0x48(%rsp)
js     11d0 <filter2dsepglobal+0xd0>
mov    -0x48(%rsp),%r13
jmp    11fb <filter2dsepglobal+0xfb>
nop
add    $0x1,%r13
cmp    %r13d,-0x5c(%rsp)
je     11d0 <filter2dsepglobal+0xd0>
cmpl   $0x0,0x50(%rsp)
js     11f0 <filter2dsepglobal+0xf0>
lea    (%r15,%r13,1),%r14
mov    -0x30(%rsp),%rcx
lea    (%rcx,%r13,1),%r10
mov    -0x60(%rsp),%ebp
mov    -0x58(%rsp),%r11
mov    -0x38(%rsp),%rbx
jmp    122d <filter2dsepglobal+0x12d>
nop
add    $0x1,%rbx
add    $0x1,%r11
add    $0xffffffff,%ebp
je     11f0 <filter2dsepglobal+0xf0>
test   %r14,%r14
js     1220 <filter2dsepglobal+0x120>
cmp    %rax,%r14
jge    1220 <filter2dsepglobal+0x120>
test   %r11,%r11
js     1220 <filter2dsepglobal+0x120>
cmp    %rsi,%r11
jge    1220 <filter2dsepglobal+0x120>
mov    0x28(%rdi,%r14,8),%r9
lea    0x5(%r11),%r8d
movss  (%r9,%r8,4),%xmm0
mov    -0x10(%rsp),%rcx
mov    (%rcx,%r10,8),%rcx
mov    -0x20(%rsp),%rdx
mov    (%rdx,%r15,8),%rdx
mulss  (%rcx,%rbx,4),%xmm0
addss  (%rdx,%r12,4),%xmm0
movss  %xmm0,(%rdx,%r12,4)
mov    -0x28(%rsp),%rcx
mov    0x28(%rcx,%r14,8),%rcx
movss  (%rcx,%r8,4),%xmm0
mov    -0x8(%rsp),%rcx
mov    (%rcx,%r10,8),%rcx
mulss  (%rcx,%rbx,4),%xmm0
mov    -0x18(%rsp),%rcx
mov    (%rcx,%r15,8),%rcx
addss  (%rcx,%r12,4),%xmm0
movss  %xmm0,(%rcx,%r12,4)
jmp    1220 <filter2dsepglobal+0x120>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @filter2dsepglobal(float** %0, float** %1, float** %2, float** %3, float** %4, float** %5, i32 %6, i32 %7, i32 %8, i32 %9) {
%11 = alloca float**
%12 = alloca float**
%13 = alloca float**
%14 = alloca float**
%15 = alloca float**
%16 = alloca float**
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32
%25 = alloca i32
%26 = alloca i32
%27 = alloca i32
%28 = alloca i32
%29 = alloca i32
%30 = alloca i32
store float** %0, float*** %11
store float** %1, float*** %12
store float** %2, float*** %13
store float** %3, float*** %14
store float** %4, float*** %15
store float** %5, float*** %16
store i32 %6, i32* %17
store i32 %7, i32* %18
store i32 %8, i32* %19
store i32 %9, i32* %20
store i32 0, i32* %21
br label %31
31: ; preds = %154, %10
%32 = load i32, i32* %21
%33 = load i32, i32* %17
%34 = icmp slt i32 %32, %33
br i1 %34, label %35, label %157
35: ; preds = %31
store i32 0, i32* %22
br label %36
36: ; preds = %150, %35
%37 = load i32, i32* %22
%38 = load i32, i32* %18
%39 = icmp slt i32 %37, %38
br i1 %39, label %40, label %153
40: ; preds = %36
%41 = load i32, i32* %19
%42 = sub nsw i32 0, %41
store i32 %42, i32* %23
br label %43
43: ; preds = %146, %40
%44 = load i32, i32* %23
%45 = load i32, i32* %19
%46 = icmp sle i32 %44, %45
br i1 %46, label %47, label %149
47: ; preds = %43
%48 = load i32, i32* %21
%49 = load i32, i32* %23
%50 = add nsw i32 %48, %49
store i32 %50, i32* %27
%51 = load i32, i32* %27
%52 = add nsw i32 %51, 5
store i32 %52, i32* %29
%53 = load i32, i32* %23
%54 = load i32, i32* %19
%55 = add nsw i32 %53, %54
store i32 %55, i32* %25
%56 = load i32, i32* %20
%57 = sub nsw i32 0, %56
store i32 %57, i32* %24
br label %58
58: ; preds = %142, %47
%59 = load i32, i32* %24
%60 = load i32, i32* %20
%61 = icmp sle i32 %59, %60
br i1 %61, label %62, label %145
62: ; preds = %58
%63 = load i32, i32* %22
%64 = load i32, i32* %24
%65 = add nsw i32 %63, %64
store i32 %65, i32* %28
%66 = load i32, i32* %28
%67 = add nsw i32 %66, 5
store i32 %67, i32* %30
%68 = load i32, i32* %24
%69 = load i32, i32* %20
%70 = add nsw i32 %68, %69
store i32 %70, i32* %26
%71 = load i32, i32* %27
%72 = icmp sge i32 %71, 0
br i1 %72, label %73, label %141
73: ; preds = %62
%74 = load i32, i32* %27
%75 = load i32, i32* %17
%76 = icmp slt i32 %74, %75
br i1 %76, label %77, label %141
77: ; preds = %73
%78 = load i32, i32* %28
%79 = icmp sge i32 %78, 0
br i1 %79, label %80, label %141
80: ; preds = %77
%81 = load i32, i32* %28
%82 = load i32, i32* %18
%83 = icmp slt i32 %81, %82
br i1 %83, label %84, label %141
84: ; preds = %80
%85 = load float**, float*** %11
%86 = load i32, i32* %29
%87 = sext i32 %86 to i64
%88 = getelementptr inbounds float*, float** %85, i64 %87
%89 = load float*, float** %88
%90 = load i32, i32* %30
%91 = sext i32 %90 to i64
%92 = getelementptr inbounds float, float* %89, i64 %91
%93 = load float, float* %92
%94 = load float**, float*** %15
%95 = load i32, i32* %25
%96 = sext i32 %95 to i64
%97 = getelementptr inbounds float*, float** %94, i64 %96
%98 = load float*, float** %97
%99 = load i32, i32* %26
%100 = sext i32 %99 to i64
%101 = getelementptr inbounds float, float* %98, i64 %100
%102 = load float, float* %101
%103 = load float**, float*** %13
%104 = load i32, i32* %21
%105 = sext i32 %104 to i64
%106 = getelementptr inbounds float*, float** %103, i64 %105
%107 = load float*, float** %106
%108 = load i32, i32* %22
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds float, float* %107, i64 %109
%111 = load float, float* %110
%112 = call float @llvm.fmuladd.f32(float %93, float %102, float %111)
store float %112, float* %110
%113 = load float**, float*** %12
%114 = load i32, i32* %29
%115 = sext i32 %114 to i64
%116 = getelementptr inbounds float*, float** %113, i64 %115
%117 = load float*, float** %116
%118 = load i32, i32* %30
%119 = sext i32 %118 to i64
%120 = getelementptr inbounds float, float* %117, i64 %119
%121 = load float, float* %120
%122 = load float**, float*** %16
%123 = load i32, i32* %25
%124 = sext i32 %123 to i64
%125 = getelementptr inbounds float*, float** %122, i64 %124
%126 = load float*, float** %125
%127 = load i32, i32* %26
%128 = sext i32 %127 to i64
%129 = getelementptr inbounds float, float* %126, i64 %128
%130 = load float, float* %129
%131 = load float**, float*** %14
%132 = load i32, i32* %21
%133 = sext i32 %132 to i64
%134 = getelementptr inbounds float*, float** %131, i64 %133
%135 = load float*, float** %134
%136 = load i32, i32* %22
%137 = sext i32 %136 to i64
%138 = getelementptr inbounds float, float* %135, i64 %137
%139 = load float, float* %138
%140 = call float @llvm.fmuladd.f32(float %121, float %130, float %139)
store float %140, float* %138
br label %141
141: ; preds = %84, %80, %77, %73, %62
br label %142
142: ; preds = %141
%143 = load i32, i32* %24
%144 = add nsw i32 %143, 1
store i32 %144, i32* %24
br label %58
145: ; preds = %58
br label %146
146: ; preds = %145
%147 = load i32, i32* %23
%148 = add nsw i32 %147, 1
store i32 %148, i32* %23
br label %43
149: ; preds = %43
br label %150
150: ; preds = %149
%151 = load i32, i32* %22
%152 = add nsw i32 %151, 1
store i32 %152, i32* %22
br label %36
153: ; preds = %36
br label %154
154: ; preds = %153
%155 = load i32, i32* %21
%156 = add nsw i32 %155, 1
store i32 %156, i32* %21
br label %31
157: ; preds = %31
ret void
}

LLVM IR (-O2):
define void @filter2dsepglobal(float** nocapture %0, float** nocapture %1, float** nocapture %2, float** nocapture %3, float** nocapture %4, float** nocapture %5, i32 %6, i32 %7, i32 %8, i32 %9) {
%11 = icmp sgt i32 %6, 0
br i1 %11, label %12, label %95
12: ; preds = %10
%13 = icmp sgt i32 %7, 0
%14 = sub i32 0, %8
%15 = icmp slt i32 %8, 0
%16 = sub i32 0, %9
%17 = icmp slt i32 %9, 0
%18 = sext i32 %16 to i64
%19 = sext i32 %7 to i64
%20 = sext i32 %9 to i64
%21 = call i32 @llvm.abs.i32(i32 %9, i1 false)
%22 = add nuw i32 %21, 1
%23 = sext i32 %14 to i64
%24 = zext i32 %6 to i64
%25 = sext i32 %8 to i64
%26 = call i32 @llvm.abs.i32(i32 %8, i1 false)
%27 = add nuw i32 %26, 1
%28 = zext i32 %6 to i64
%29 = zext i32 %7 to i64
br label %30
30: ; preds = %12, %92
%31 = phi i64 [ 0, %12 ], [ %93, %92 ]
br i1 %13, label %32, label %92
32: ; preds = %30
%33 = getelementptr inbounds float*, float** %2, i64 %31
%34 = getelementptr inbounds float*, float** %3, i64 %31
br label %35
35: ; preds = %32, %89
%36 = phi i64 [ 0, %32 ], [ %90, %89 ]
br i1 %15, label %89, label %37
37: ; preds = %35, %85
%38 = phi i64 [ %86, %85 ], [ %23, %35 ]
%39 = add nsw i64 %38, %31
br i1 %17, label %85, label %40
40: ; preds = %37
%41 = add nsw i64 %38, %25
%42 = add nsw i64 %39, 5
%43 = icmp sgt i64 %39, -1
%44 = icmp slt i64 %39, %24
%45 = getelementptr inbounds float*, float** %0, i64 %42
%46 = getelementptr inbounds float*, float** %4, i64 %41
%47 = getelementptr inbounds float*, float** %1, i64 %42
%48 = getelementptr inbounds float*, float** %5, i64 %41
br label %49
49: ; preds = %40, %81
%50 = phi i64 [ %18, %40 ], [ %82, %81 ]
%51 = add nsw i64 %50, %36
%52 = add nsw i64 %50, %20
br i1 %43, label %53, label %81
53: ; preds = %49
%54 = icmp sgt i64 %51, -1
%55 = select i1 %44, i1 %54, i1 false
%56 = icmp slt i64 %51, %19
%57 = select i1 %55, i1 %56, i1 false
br i1 %57, label %58, label %81
58: ; preds = %53
%59 = load float*, float** %45
%60 = add nuw i64 %51, 5
%61 = and i64 %60, 4294967295
%62 = getelementptr inbounds float, float* %59, i64 %61
%63 = load float, float* %62
%64 = load float*, float** %46
%65 = getelementptr inbounds float, float* %64, i64 %52
%66 = load float, float* %65
%67 = load float*, float** %33
%68 = getelementptr inbounds float, float* %67, i64 %36
%69 = load float, float* %68
%70 = tail call float @llvm.fmuladd.f32(float %63, float %66, float %69)
store float %70, float* %68
%71 = load float*, float** %47
%72 = getelementptr inbounds float, float* %71, i64 %61
%73 = load float, float* %72
%74 = load float*, float** %48
%75 = getelementptr inbounds float, float* %74, i64 %52
%76 = load float, float* %75
%77 = load float*, float** %34
%78 = getelementptr inbounds float, float* %77, i64 %36
%79 = load float, float* %78
%80 = tail call float @llvm.fmuladd.f32(float %73, float %76, float %79)
store float %80, float* %78
br label %81
81: ; preds = %49, %53, %58
%82 = add nsw i64 %50, 1
%83 = trunc i64 %82 to i32
%84 = icmp eq i32 %22, %83
br i1 %84, label %85, label %49
85: ; preds = %81, %37
%86 = add nsw i64 %38, 1
%87 = trunc i64 %86 to i32
%88 = icmp eq i32 %27, %87
br i1 %88, label %89, label %37
89: ; preds = %85, %35
%90 = add nuw nsw i64 %36, 1
%91 = icmp eq i64 %90, %29
br i1 %91, label %92, label %35
92: ; preds = %89, %30
%93 = add nuw nsw i64 %31, 1
%94 = icmp eq i64 %93, %28
br i1 %94, label %95, label %30
95: ; preds = %92, %10
ret void
}