void minimum_filter(int *image, int *width, int *height, int *depth, int *dim,
                    int *ret) {
  int x, y, d, i, j, minimum_index = 0;
  for (x = 0; x < *width; x++) {
    for (y = 0; y < *height; y++) {
      int src = *depth / 2;
      int index = 0;
      int values[*dim * *dim * *depth];
      int min = 255 * *depth;
      for (i = 0; i < *dim; i++) {
        for (j = 0; j < *dim; j++) {
          int x_pos, y_pos;
          x_pos = (x + i < src) ? -1 : x + i - src;
          x_pos = (x_pos > *width - 1) ? -1 : x_pos;
          y_pos = (y + j < src) ? -1 : y + j - src;
          y_pos = (y_pos > *height - 1) ? -1 : y_pos;
          if (x_pos != -1 && y_pos != -1) {
            int value = 0;
            for (d = 0; d < *depth; d++) {
              values[index + d] = image[((*height) * (x_pos) + (y_pos) +
                                         (*width) * (*height) * (d))];
              value += image[((*height) * (x_pos) + (y_pos) +
                              (*width) * (*height) * (d))];
            }
            if (value < min) {
              min = value;
              minimum_index = index;
            }
            index += *depth;
          }
        }
      }
      for (d = 0; d < *depth; d++) {
        ret[((*height) * (x) + (y) + (*width) * (*height) * (d))] =
            values[minimum_index + d];
      }
    }
  }
}


x86 assembly (clang, -O0):
<minimum_filter>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
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,-0x48(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x10(%rbp),%rcx
cmp    (%rcx),%eax
jge    141f <minimum_filter+0x31f>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x18(%rbp),%rcx
cmp    (%rcx),%eax
jge    140c <minimum_filter+0x30c>
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
mov    %eax,%ecx
shr    $0x1f,%ecx
add    %ecx,%eax
sar    %eax
mov    %eax,-0x4c(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x28(%rbp),%rax
mov    (%rax),%eax
imul   %eax,%eax
mov    -0x20(%rbp),%rcx
mov    (%rcx),%ecx
imul   %ecx,%eax
mov    %rsp,%rcx
mov    %rcx,-0x58(%rbp)
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x78(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x60(%rbp)
mov    -0x20(%rbp),%rax
imul   $0xff,(%rax),%eax
mov    %eax,-0x64(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    -0x28(%rbp),%rcx
cmp    (%rcx),%eax
jge    1399 <minimum_filter+0x299>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    -0x28(%rbp),%rcx
cmp    (%rcx),%eax
jge    1386 <minimum_filter+0x286>
mov    -0x34(%rbp),%eax
add    -0x40(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    11fa <minimum_filter+0xfa>
mov    $0xffffffff,%eax
mov    %eax,-0x7c(%rbp)
jmp    1206 <minimum_filter+0x106>
mov    -0x34(%rbp),%eax
add    -0x40(%rbp),%eax
sub    -0x4c(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
mov    -0x10(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    122d <minimum_filter+0x12d>
mov    $0xffffffff,%eax
mov    %eax,-0x80(%rbp)
jmp    1233 <minimum_filter+0x133>
mov    -0x68(%rbp),%eax
mov    %eax,-0x80(%rbp)
mov    -0x80(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x38(%rbp),%eax
add    -0x44(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    1258 <minimum_filter+0x158>
mov    $0xffffffff,%eax
mov    %eax,-0x84(%rbp)
jmp    1267 <minimum_filter+0x167>
mov    -0x38(%rbp),%eax
add    -0x44(%rbp),%eax
sub    -0x4c(%rbp),%eax
mov    %eax,-0x84(%rbp)
mov    -0x84(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
mov    -0x18(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    1294 <minimum_filter+0x194>
mov    $0xffffffff,%eax
mov    %eax,-0x88(%rbp)
jmp    129d <minimum_filter+0x19d>
mov    -0x6c(%rbp),%eax
mov    %eax,-0x88(%rbp)
mov    -0x88(%rbp),%eax
mov    %eax,-0x6c(%rbp)
cmpl   $0xffffffff,-0x68(%rbp)
je     1373 <minimum_filter+0x273>
cmpl   $0xffffffff,-0x6c(%rbp)
je     1373 <minimum_filter+0x273>
movl   $0x0,-0x70(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x20(%rbp),%rcx
cmp    (%rcx),%eax
jge    134f <minimum_filter+0x24f>
mov    -0x78(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0x18(%rbp),%rdx
mov    (%rdx),%edx
imul   -0x68(%rbp),%edx
add    -0x6c(%rbp),%edx
mov    -0x10(%rbp),%rsi
mov    (%rsi),%esi
mov    -0x18(%rbp),%rdi
imul   (%rdi),%esi
imul   -0x3c(%rbp),%esi
add    %esi,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%edx
mov    -0x50(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rcx),%ecx
imul   -0x68(%rbp),%ecx
add    -0x6c(%rbp),%ecx
mov    -0x10(%rbp),%rdx
mov    (%rdx),%edx
mov    -0x18(%rbp),%rsi
imul   (%rsi),%edx
imul   -0x3c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
add    -0x70(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    12c8 <minimum_filter+0x1c8>
mov    -0x70(%rbp),%eax
cmp    -0x64(%rbp),%eax
jge    1367 <minimum_filter+0x267>
mov    -0x70(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x50(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
jmp    1378 <minimum_filter+0x278>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    11cf <minimum_filter+0xcf>
jmp    138b <minimum_filter+0x28b>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    11b9 <minimum_filter+0xb9>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x20(%rbp),%rcx
cmp    (%rcx),%eax
jge    13f7 <minimum_filter+0x2f7>
mov    -0x78(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x30(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rcx),%ecx
imul   -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
mov    -0x10(%rbp),%rsi
mov    (%rsi),%esi
mov    -0x18(%rbp),%rdi
imul   (%rdi),%esi
imul   -0x3c(%rbp),%esi
add    %esi,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    13a0 <minimum_filter+0x2a0>
mov    -0x58(%rbp),%rax
mov    %rax,%rsp
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1147 <minimum_filter+0x47>
jmp    1411 <minimum_filter+0x311>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1131 <minimum_filter+0x31>
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<minimum_filter>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x98,%rsp
mov    %r8,-0x90(%rbp)
mov    (%rsi),%ebx
test   %ebx,%ebx
jle    13f9 <minimum_filter+0x2f9>
mov    (%rdx),%eax
xor    %r11d,%r11d
mov    $0xffffffff,%r14d
xor    %r12d,%r12d
mov    %r9,-0x88(%rbp)
mov    %rcx,-0x80(%rbp)
mov    %rdx,-0x78(%rbp)
mov    %rsi,-0x70(%rbp)
jmp    115f <minimum_filter+0x5f>
nopl   0x0(%rax,%rax,1)
mov    (%rsi),%ebx
add    $0x1,%r11d
cmp    %ebx,%r11d
jge    13f9 <minimum_filter+0x2f9>
test   %eax,%eax
jle    1152 <minimum_filter+0x52>
xor    %r15d,%r15d
mov    %r11,-0x50(%rbp)
jmp    1182 <minimum_filter+0x82>
nopl   0x0(%rax)
mov    -0x98(%rbp),%rsp
add    $0x1,%r15d
mov    (%rdx),%eax
cmp    %eax,%r15d
jge    1150 <minimum_filter+0x50>
mov    %r15,-0x38(%rbp)
mov    %rsp,%r10
mov    (%rcx),%r8d
mov    -0x90(%rbp),%r9
mov    (%r9),%ebx
mov    %ebx,%eax
imul   %r8d,%eax
imul   %ebx,%eax
lea    0xf(,%rax,4),%rax
and    $0xfffffffffffffff0,%rax
mov    %rsp,%r11
sub    %rax,%r11
mov    %r11,%rsp
mov    (%rcx),%ecx
mov    (%r9),%r13d
test   %r13d,%r13d
mov    %r10,-0x98(%rbp)
mov    %r11,-0x58(%rbp)
jle    1390 <minimum_filter+0x290>
mov    %r8d,%ebx
shr    $0x1f,%ebx
add    %r8d,%ebx
sar    %ebx
mov    %ecx,%eax
shl    $0x8,%eax
sub    %ecx,%eax
mov    %eax,-0x30(%rbp)
mov    (%rsi),%esi
mov    (%rdx),%r9d
mov    %ecx,%eax
and    $0xfffffffe,%eax
mov    %r9d,-0x2c(%rbp)
mov    %rsi,-0x60(%rbp)
imul   %esi,%r9d
add    %r9d,%r9d
lea    0x4(%r11),%rdx
mov    %rdx,-0xa8(%rbp)
xor    %r15d,%r15d
xor    %r10d,%r10d
mov    %r12d,%esi
mov    -0x38(%rbp),%r8
mov    %rcx,%rdx
mov    %rcx,-0x68(%rbp)
mov    %r13d,-0x40(%rbp)
mov    %ebx,-0x3c(%rbp)
jmp    1244 <minimum_filter+0x144>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    -0xa0(%rbp),%r10
add    $0x1,%r10d
cmp    %r13d,%r10d
je     139a <minimum_filter+0x29a>
mov    -0x50(%rbp),%rcx
mov    %r10,-0xa0(%rbp)
add    %ecx,%r10d
sub    %ebx,%r10d
cmovl  %r14d,%r10d
mov    -0x60(%rbp),%rcx
cmp    %ecx,%r10d
cmovge %r14d,%r10d
add    %r10d,%ecx
mov    -0x2c(%rbp),%r11d
imul   %r11d,%ecx
mov    %rcx,-0xb8(%rbp)
mov    %r11d,%ecx
imul   %r10d,%ecx
mov    %rcx,-0xb0(%rbp)
xor    %ecx,%ecx
jmp    12ae <minimum_filter+0x1ae>
xor    %r13d,%r13d
mov    -0x30(%rbp),%ebx
cmp    %ebx,%r13d
cmovl  %r15d,%esi
cmovl  %r13d,%ebx
mov    %ebx,-0x30(%rbp)
add    %edx,%r15d
mov    -0x40(%rbp),%r13d
mov    -0x3c(%rbp),%ebx
add    $0x1,%ecx
cmp    %r13d,%ecx
je     1230 <minimum_filter+0x130>
lea    (%rcx,%r8,1),%r11d
sub    %ebx,%r11d
cmovl  %r14d,%r11d
cmp    -0x2c(%rbp),%r11d
cmovge %r14d,%r11d
cmp    $0xffffffff,%r10d
je     12a6 <minimum_filter+0x1a6>
cmp    $0xffffffff,%r11d
je     12a6 <minimum_filter+0x1a6>
test   %edx,%edx
jle    1288 <minimum_filter+0x188>
movslq %r15d,%r12
cmp    $0x1,%edx
mov    %esi,-0x44(%rbp)
jne    12e3 <minimum_filter+0x1e3>
xor    %ebx,%ebx
xor    %r13d,%r13d
jmp    133a <minimum_filter+0x23a>
mov    -0xb8(%rbp),%rdx
lea    (%rdx,%r11,1),%r14d
mov    -0xa8(%rbp),%rdx
lea    (%rdx,%r12,4),%rdx
mov    -0xb0(%rbp),%rsi
lea    (%rsi,%r11,1),%r8d
xor    %ebx,%ebx
xor    %r13d,%r13d
nopl   0x0(%rax)
movslq %r8d,%r8
mov    (%rdi,%r8,4),%esi
mov    %esi,-0x4(%rdx,%rbx,4)
add    %esi,%r13d
movslq %r14d,%r14
mov    (%rdi,%r14,4),%esi
mov    %esi,(%rdx,%rbx,4)
add    %esi,%r13d
add    $0x2,%rbx
add    %r9d,%r14d
add    %r9d,%r8d
cmp    %rbx,%rax
jne    1310 <minimum_filter+0x210>
mov    -0x68(%rbp),%rdx
test   $0x1,%dl
mov    $0xffffffff,%r14d
mov    -0x44(%rbp),%esi
mov    -0x38(%rbp),%r8
je     128b <minimum_filter+0x18b>
mov    -0x60(%rbp),%rdx
imul   %ebx,%edx
add    %r10d,%edx
imul   -0x2c(%rbp),%edx
add    %r11d,%edx
movslq %edx,%rdx
mov    (%rdi,%rdx,4),%edx
add    %rbx,%r12
mov    -0x58(%rbp),%rbx
mov    %edx,(%rbx,%r12,4)
add    %edx,%r13d
mov    -0x68(%rbp),%rdx
jmp    128b <minimum_filter+0x18b>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r12d,%esi
mov    -0x38(%rbp),%r8
mov    %rcx,%rdx
mov    %esi,%r12d
test   %edx,%edx
mov    %r8,%r15
mov    -0x88(%rbp),%r8
mov    -0x80(%rbp),%rcx
mov    -0x78(%rbp),%rdx
mov    -0x70(%rbp),%rsi
mov    -0x50(%rbp),%r11
jle    1170 <minimum_filter+0x70>
movslq %r12d,%rax
mov    -0x58(%rbp),%rbx
lea    (%rbx,%rax,4),%r9
xor    %ebx,%ebx
nopl   0x0(%rax)
mov    (%r9,%rbx,4),%r10d
mov    (%rsi),%eax
imul   %ebx,%eax
add    %r11d,%eax
imul   (%rdx),%eax
add    %r15d,%eax
cltq
mov    %r10d,(%r8,%rax,4)
add    $0x1,%rbx
movslq (%rcx),%rax
cmp    %rax,%rbx
jl     13d0 <minimum_filter+0x2d0>
jmp    1170 <minimum_filter+0x70>
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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