#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 */
typedef int uint32_t;

/* Variables and functions */
int opt_med25(int *);
void chroma_smooth_5x5(int w, int h, uint32_t *inp, uint32_t *out, int *raw2ev,
                       int *ev2raw, int black) {
  int x, y;
  for (y = 4; y < h - 5; y += 2) {
    for (x = 4; x < w - 4; x += 2) {
      int g1 = inp[x + 1 + y * w];
      int g2 = inp[x + (y + 1) * w];
      int ge = (raw2ev[g1] + raw2ev[g2]) / 2;
      if (ge < 2 * 32768)
        continue;
      int i, j;
      int k = 0;
      int med_r[25];
      int med_b[25];
      for (i = -4; i <= 4; i += 2) {
        for (j = -4; j <= 4; j += 2) {
          int r = inp[x + i + (y + j) * w];
          int g1 = inp[x + i + 1 + (y + j) * w];
          int g2 = inp[x + i + (y + j + 1) * w];
          int b = inp[x + i + 1 + (y + j + 1) * w];
          int ge = (raw2ev[g1] + raw2ev[g2]) / 2;
          med_r[k] = raw2ev[r] - ge;
          med_b[k] = raw2ev[b] - ge;
          k++;
        }
      }
      int dr = opt_med25(med_r);
      int db = opt_med25(med_b);
      if (ge + dr <= 32768)
        continue;
      if (ge + db <= 32768)
        continue;
      out[x + y * w] = ev2raw[(((((((ge + dr)) < ((14 * 32768 - 1)))
                                      ? ((ge + dr))
                                      : ((14 * 32768 - 1)))) > ((0)))
                                   ? (((((ge + dr)) < ((14 * 32768 - 1)))
                                           ? ((ge + dr))
                                           : ((14 * 32768 - 1))))
                                   : ((0)))] +
                       black;
      out[x + 1 + (y + 1) * w] =
          ev2raw[(
              ((((((ge + db)) < ((14 * 32768 - 1))) ? ((ge + db))
                                                    : ((14 * 32768 - 1)))) >
               ((0)))
                  ? (((((ge + db)) < ((14 * 32768 - 1))) ? ((ge + db))
                                                         : ((14 * 32768 - 1))))
                  : ((0)))] +
          black;
    }
  }
}


x86 assembly (clang, -O0):
<chroma_smooth_5x5>:
push   %rbp
mov    %rsp,%rbp
sub    $0x170,%rsp
mov    0x10(%rbp),%eax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
movl   $0x4,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    $0x5,%ecx
cmp    %ecx,%eax
jge    1543 <chroma_smooth_5x5+0x433>
movl   $0x4,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x4(%rbp),%ecx
sub    $0x4,%ecx
cmp    %ecx,%eax
jge    1530 <chroma_smooth_5x5+0x420>
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
mov    -0x30(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x34(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x30(%rbp),%edx
add    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x38(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x20(%rbp),%rcx
movslq -0x38(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x3c(%rbp)
cmpl   $0x10000,-0x3c(%rbp)
jge    11cf <chroma_smooth_5x5+0xbf>
jmp    1522 <chroma_smooth_5x5+0x412>
movl   $0x0,-0x48(%rbp)
movl   $0xfffffffc,-0x40(%rbp)
cmpl   $0x4,-0x40(%rbp)
jg     131e <chroma_smooth_5x5+0x20e>
movl   $0xfffffffc,-0x44(%rbp)
cmpl   $0x4,-0x44(%rbp)
jg     130b <chroma_smooth_5x5+0x1fb>
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x40(%rbp),%ecx
mov    -0x30(%rbp),%edx
add    -0x44(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x124(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x40(%rbp),%ecx
add    $0x1,%ecx
mov    -0x30(%rbp),%edx
add    -0x44(%rbp),%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x128(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x40(%rbp),%ecx
mov    -0x30(%rbp),%edx
add    -0x44(%rbp),%edx
add    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x12c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x40(%rbp),%ecx
add    $0x1,%ecx
mov    -0x30(%rbp),%edx
add    -0x44(%rbp),%edx
add    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x130(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x128(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x20(%rbp),%rcx
movslq -0x12c(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x134(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x124(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
sub    -0x134(%rbp),%ecx
movslq -0x48(%rbp),%rax
mov    %ecx,-0xb0(%rbp,%rax,4)
mov    -0x20(%rbp),%rax
movslq -0x130(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
sub    -0x134(%rbp),%ecx
movslq -0x48(%rbp),%rax
mov    %ecx,-0x120(%rbp,%rax,4)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x44(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x44(%rbp)
jmp    11ee <chroma_smooth_5x5+0xde>
jmp    1310 <chroma_smooth_5x5+0x200>
mov    -0x40(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x40(%rbp)
jmp    11dd <chroma_smooth_5x5+0xcd>
lea    -0xb0(%rbp),%rdi
call   1030 <opt_med25@plt>
mov    %eax,-0x138(%rbp)
lea    -0x120(%rbp),%rdi
call   1030 <opt_med25@plt>
mov    %eax,-0x13c(%rbp)
mov    -0x3c(%rbp),%eax
add    -0x138(%rbp),%eax
cmp    $0x8000,%eax
jg     135b <chroma_smooth_5x5+0x24b>
jmp    1522 <chroma_smooth_5x5+0x412>
mov    -0x3c(%rbp),%eax
add    -0x13c(%rbp),%eax
cmp    $0x8000,%eax
jg     1374 <chroma_smooth_5x5+0x264>
jmp    1522 <chroma_smooth_5x5+0x412>
mov    -0x28(%rbp),%rax
mov    %rax,-0x148(%rbp)
mov    -0x3c(%rbp),%eax
add    -0x138(%rbp),%eax
cmp    $0x6ffff,%eax
jge    13a7 <chroma_smooth_5x5+0x297>
mov    -0x3c(%rbp),%eax
add    -0x138(%rbp),%eax
mov    %eax,-0x14c(%rbp)
jmp    13b7 <chroma_smooth_5x5+0x2a7>
mov    $0x6ffff,%eax
mov    %eax,-0x14c(%rbp)
jmp    13b7 <chroma_smooth_5x5+0x2a7>
mov    -0x14c(%rbp),%eax
cmp    $0x0,%eax
jle    140f <chroma_smooth_5x5+0x2ff>
mov    -0x3c(%rbp),%eax
add    -0x138(%rbp),%eax
cmp    $0x6ffff,%eax
jge    13ee <chroma_smooth_5x5+0x2de>
mov    -0x3c(%rbp),%eax
add    -0x138(%rbp),%eax
mov    %eax,-0x150(%rbp)
jmp    13fe <chroma_smooth_5x5+0x2ee>
mov    $0x6ffff,%eax
mov    %eax,-0x150(%rbp)
jmp    13fe <chroma_smooth_5x5+0x2ee>
mov    -0x150(%rbp),%eax
mov    %eax,-0x154(%rbp)
jmp    141c <chroma_smooth_5x5+0x30c>
xor    %eax,%eax
mov    %eax,-0x154(%rbp)
jmp    141c <chroma_smooth_5x5+0x30c>
mov    -0x148(%rbp),%rax
mov    -0x154(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
add    0x10(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x30(%rbp),%esi
imul   -0x4(%rbp),%esi
add    %esi,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
mov    %rax,-0x160(%rbp)
mov    -0x3c(%rbp),%eax
add    -0x13c(%rbp),%eax
cmp    $0x6ffff,%eax
jge    147b <chroma_smooth_5x5+0x36b>
mov    -0x3c(%rbp),%eax
add    -0x13c(%rbp),%eax
mov    %eax,-0x164(%rbp)
jmp    148b <chroma_smooth_5x5+0x37b>
mov    $0x6ffff,%eax
mov    %eax,-0x164(%rbp)
jmp    148b <chroma_smooth_5x5+0x37b>
mov    -0x164(%rbp),%eax
cmp    $0x0,%eax
jle    14e3 <chroma_smooth_5x5+0x3d3>
mov    -0x3c(%rbp),%eax
add    -0x13c(%rbp),%eax
cmp    $0x6ffff,%eax
jge    14c2 <chroma_smooth_5x5+0x3b2>
mov    -0x3c(%rbp),%eax
add    -0x13c(%rbp),%eax
mov    %eax,-0x168(%rbp)
jmp    14d2 <chroma_smooth_5x5+0x3c2>
mov    $0x6ffff,%eax
mov    %eax,-0x168(%rbp)
jmp    14d2 <chroma_smooth_5x5+0x3c2>
mov    -0x168(%rbp),%eax
mov    %eax,-0x16c(%rbp)
jmp    14f0 <chroma_smooth_5x5+0x3e0>
xor    %eax,%eax
mov    %eax,-0x16c(%rbp)
jmp    14f0 <chroma_smooth_5x5+0x3e0>
mov    -0x160(%rbp),%rax
mov    -0x16c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
add    0x10(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
mov    -0x30(%rbp),%esi
add    $0x1,%esi
imul   -0x4(%rbp),%esi
add    %esi,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    1153 <chroma_smooth_5x5+0x43>
jmp    1535 <chroma_smooth_5x5+0x425>
mov    -0x30(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x30(%rbp)
jmp    113b <chroma_smooth_5x5+0x2b>
add    $0x170,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<chroma_smooth_5x5>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x148,%rsp
mov    %r9,0x38(%rsp)
mov    %rcx,0x30(%rsp)
mov    %rdi,0x20(%rsp)
mov    %rsi,(%rsp)
cmp    $0xa,%esi
jl     1442 <chroma_smooth_5x5+0x332>
mov    %r8,%rbx
mov    (%rsp),%rax
add    $0xfffffffb,%eax
mov    %rax,(%rsp)
mov    0x20(%rsp),%rcx
lea    -0x4(%rcx),%eax
movslq %ecx,%r15
movslq %eax,%r8
lea    0x0(,%r15,8),%rax
mov    %rax,0x28(%rsp)
lea    0x0(,%r15,4),%r13
mov    $0x4,%eax
mov    %rax,0x10(%rsp)
mov    %rdx,0x8(%rsp)
mov    %rdx,0x48(%rsp)
mov    %r8,0x40(%rsp)
jmp    11b7 <chroma_smooth_5x5+0xa7>
nopl   0x0(%rax)
mov    0x10(%rsp),%rax
add    $0x2,%rax
mov    0x8(%rsp),%rcx
add    0x28(%rsp),%rcx
mov    %rcx,0x8(%rsp)
mov    %rax,0x10(%rsp)
cmp    (%rsp),%rax
jge    1442 <chroma_smooth_5x5+0x332>
cmpl   $0x9,0x20(%rsp)
jl     1190 <chroma_smooth_5x5+0x80>
mov    0x10(%rsp),%rax
mov    %rax,%r9
imul   %r15,%r9
mov    %rax,%rdi
or     $0x1,%rdi
imul   %r15,%rdi
mov    $0x4,%esi
mov    0x8(%rsp),%r12
mov    %r9,0x58(%rsp)
mov    %rdi,0x50(%rsp)
jmp    1207 <chroma_smooth_5x5+0xf7>
nopl   0x0(%rax,%rax,1)
mov    0x48(%rsp),%rdx
mov    0x40(%rsp),%r8
add    $0x2,%rsi
add    $0x8,%r12
cmp    %r8,%rsi
jge    1190 <chroma_smooth_5x5+0x80>
mov    %rsi,%rbp
or     $0x1,%rbp
lea    (%r9,%rbp,1),%rax
movslq (%rdx,%rax,4),%rcx
lea    (%rsi,%rdi,1),%rax
movslq (%rdx,%rax,4),%rax
mov    (%rbx,%rax,4),%eax
add    (%rbx,%rcx,4),%eax
cmp    $0x20000,%eax
jl     11fa <chroma_smooth_5x5+0xea>
mov    %rbp,0x60(%rsp)
mov    %rsi,0x68(%rsp)
mov    %eax,%ecx
shr    $0x1f,%ecx
add    %eax,%ecx
sar    %ecx
mov    %ecx,0x1c(%rsp)
mov    $0x4,%eax
mov    $0xfffffffffffffffa,%rcx
xchg   %ax,%ax
lea    (%r12,%rcx,4),%rsi
movslq 0x18(%r12,%rcx,4),%r8
movslq 0x1c(%r12,%rcx,4),%r9
lea    (%rsi,%r13,1),%rdx
add    $0x18,%rdx
movslq 0x18(%rsi,%r15,4),%rdi
mov    (%rbx,%rdi,4),%ebp
add    (%rbx,%r9,4),%ebp
movslq 0x1c(%rsi,%r15,4),%r9
mov    %ebp,%edi
shr    $0x1f,%edi
add    %ebp,%edi
sar    %edi
mov    (%rbx,%r8,4),%ebp
sub    %edi,%ebp
mov    %ebp,0xd0(%rsp,%rax,4)
mov    (%rbx,%r9,4),%ebp
sub    %edi,%ebp
mov    %ebp,0x60(%rsp,%rax,4)
add    %r13,%rdx
movslq 0x18(%rsi,%r15,8),%r8
movslq 0x1c(%rsi,%r15,8),%rsi
lea    (%rdx,%r13,1),%r10
movslq (%rdx,%r15,4),%rdi
movslq 0x4(%rdx,%r15,4),%r9
mov    (%rbx,%rdi,4),%edi
add    (%rbx,%rsi,4),%edi
mov    %edi,%esi
shr    $0x1f,%esi
add    %edi,%esi
sar    %esi
mov    (%rbx,%r8,4),%edi
sub    %esi,%edi
mov    %edi,0xd4(%rsp,%rax,4)
mov    (%rbx,%r9,4),%edi
sub    %esi,%edi
mov    %edi,0x64(%rsp,%rax,4)
lea    (%r10,%r13,1),%rsi
movslq (%rdx,%r15,8),%r8
movslq 0x4(%rdx,%r15,8),%r9
lea    (%rsi,%r13,1),%rdi
movslq (%rsi,%r15,4),%rbp
mov    (%rbx,%rbp,4),%edx
add    (%rbx,%r9,4),%edx
movslq 0x4(%r10,%r15,8),%r9
mov    %edx,%ebp
shr    $0x1f,%ebp
add    %edx,%ebp
sar    %ebp
mov    (%rbx,%r8,4),%edx
sub    %ebp,%edx
mov    %edx,0xd8(%rsp,%rax,4)
mov    (%rbx,%r9,4),%edx
sub    %ebp,%edx
mov    %edx,0x68(%rsp,%rax,4)
lea    (%rdi,%r13,1),%rdx
movslq (%rdi,%r15,4),%r8
movslq 0x4(%rsi,%r15,8),%r9
lea    (%rdx,%r13,1),%rbp
movslq (%rdx,%r15,4),%rsi
movslq 0x4(%rdi,%r15,8),%r10
mov    (%rbx,%rsi,4),%edi
add    (%rbx,%r9,4),%edi
mov    %edi,%esi
shr    $0x1f,%esi
add    %edi,%esi
sar    %esi
mov    (%rbx,%r8,4),%edi
sub    %esi,%edi
mov    %edi,0xdc(%rsp,%rax,4)
mov    (%rbx,%r10,4),%edi
sub    %esi,%edi
mov    %edi,0x6c(%rsp,%rax,4)
mov    %rbp,%rsi
add    %r13,%rsi
movslq 0x0(%rbp,%r15,4),%rdi
movslq 0x4(%rdx,%r15,8),%rdx
movslq (%rsi,%r15,4),%rsi
movslq 0x4(%rbp,%r15,8),%rbp
mov    (%rbx,%rsi,4),%esi
add    (%rbx,%rdx,4),%esi
mov    %esi,%edx
shr    $0x1f,%edx
add    %esi,%edx
sar    %edx
mov    (%rbx,%rdi,4),%esi
sub    %edx,%esi
mov    %esi,0xe0(%rsp,%rax,4)
mov    (%rbx,%rbp,4),%esi
sub    %edx,%esi
mov    %esi,0x70(%rsp,%rax,4)
add    $0x5,%rax
add    $0x2,%rcx
cmp    $0x3,%rcx
jl     1250 <chroma_smooth_5x5+0x140>
lea    0xe0(%rsp),%rdi
call   1030 <opt_med25@plt>
mov    %eax,%r14d
lea    0x70(%rsp),%rdi
call   1030 <opt_med25@plt>
mov    0x1c(%rsp),%ecx
add    %ecx,%r14d
cmp    $0x8001,%r14d
mov    0x58(%rsp),%r9
mov    0x50(%rsp),%rdi
mov    0x68(%rsp),%rsi
jl     11f0 <chroma_smooth_5x5+0xe0>
add    %ecx,%eax
cmp    $0x8001,%eax
jl     11f0 <chroma_smooth_5x5+0xe0>
cmp    $0x6ffff,%r14d
mov    $0x6ffff,%r8d
cmovae %r8d,%r14d
mov    0x38(%rsp),%r11
mov    (%r11,%r14,4),%ecx
mov    0x180(%rsp),%ebp
add    %ebp,%ecx
lea    (%rsi,%r9,1),%rdx
mov    0x30(%rsp),%r10
mov    %ecx,(%r10,%rdx,4)
cmp    $0x6ffff,%eax
cmovae %r8d,%eax
mov    (%r11,%rax,4),%eax
add    %ebp,%eax
mov    0x60(%rsp),%rcx
add    %rdi,%rcx
mov    %eax,(%r10,%rcx,4)
jmp    11f0 <chroma_smooth_5x5+0xe0>
add    $0x148,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @chroma_smooth_5x5(i32 %0, i32 %1, i32* %2, i32* %3, i32* %4, i32* %5, i32 %6) {
%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 i32
%22 = alloca i32
%23 = alloca [25 x i32]
%24 = alloca [25 x i32]
%25 = alloca i32
%26 = alloca i32
%27 = alloca i32
%28 = alloca i32
%29 = alloca i32
%30 = alloca i32
%31 = alloca i32
store i32 %0, i32* %8
store i32 %1, i32* %9
store i32* %2, i32** %10
store i32* %3, i32** %11
store i32* %4, i32** %12
store i32* %5, i32** %13
store i32 %6, i32* %14
store i32 4, i32* %16
br label %32
32: ; preds = %290, %7
%33 = load i32, i32* %16
%34 = load i32, i32* %9
%35 = sub nsw i32 %34, 5
%36 = icmp slt i32 %33, %35
br i1 %36, label %37, label %293
37: ; preds = %32
store i32 4, i32* %15
br label %38
38: ; preds = %286, %37
%39 = load i32, i32* %15
%40 = load i32, i32* %8
%41 = sub nsw i32 %40, 4
%42 = icmp slt i32 %39, %41
br i1 %42, label %43, label %289
43: ; preds = %38
%44 = load i32*, i32** %10
%45 = load i32, i32* %15
%46 = add nsw i32 %45, 1
%47 = load i32, i32* %16
%48 = load i32, i32* %8
%49 = mul nsw i32 %47, %48
%50 = add nsw i32 %46, %49
%51 = sext i32 %50 to i64
%52 = getelementptr inbounds i32, i32* %44, i64 %51
%53 = load i32, i32* %52
store i32 %53, i32* %17
%54 = load i32*, i32** %10
%55 = load i32, i32* %15
%56 = load i32, i32* %16
%57 = add nsw i32 %56, 1
%58 = load i32, i32* %8
%59 = mul nsw i32 %57, %58
%60 = add nsw i32 %55, %59
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds i32, i32* %54, i64 %61
%63 = load i32, i32* %62
store i32 %63, i32* %18
%64 = load i32*, i32** %12
%65 = load i32, i32* %17
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds i32, i32* %64, i64 %66
%68 = load i32, i32* %67
%69 = load i32*, i32** %12
%70 = load i32, i32* %18
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds i32, i32* %69, i64 %71
%73 = load i32, i32* %72
%74 = add nsw i32 %68, %73
%75 = sdiv i32 %74, 2
store i32 %75, i32* %19
%76 = load i32, i32* %19
%77 = icmp slt i32 %76, 65536
br i1 %77, label %78, label %79
78: ; preds = %43
br label %286
79: ; preds = %43
store i32 0, i32* %22
store i32 -4, i32* %20
br label %80
80: ; preds = %182, %79
%81 = load i32, i32* %20
%82 = icmp sle i32 %81, 4
br i1 %82, label %83, label %185
83: ; preds = %80
store i32 -4, i32* %21
br label %84
84: ; preds = %178, %83
%85 = load i32, i32* %21
%86 = icmp sle i32 %85, 4
br i1 %86, label %87, label %181
87: ; preds = %84
%88 = load i32*, i32** %10
%89 = load i32, i32* %15
%90 = load i32, i32* %20
%91 = add nsw i32 %89, %90
%92 = load i32, i32* %16
%93 = load i32, i32* %21
%94 = add nsw i32 %92, %93
%95 = load i32, i32* %8
%96 = mul nsw i32 %94, %95
%97 = add nsw i32 %91, %96
%98 = sext i32 %97 to i64
%99 = getelementptr inbounds i32, i32* %88, i64 %98
%100 = load i32, i32* %99
store i32 %100, i32* %25
%101 = load i32*, i32** %10
%102 = load i32, i32* %15
%103 = load i32, i32* %20
%104 = add nsw i32 %102, %103
%105 = add nsw i32 %104, 1
%106 = load i32, i32* %16
%107 = load i32, i32* %21
%108 = add nsw i32 %106, %107
%109 = load i32, i32* %8
%110 = mul nsw i32 %108, %109
%111 = add nsw i32 %105, %110
%112 = sext i32 %111 to i64
%113 = getelementptr inbounds i32, i32* %101, i64 %112
%114 = load i32, i32* %113
store i32 %114, i32* %26
%115 = load i32*, i32** %10
%116 = load i32, i32* %15
%117 = load i32, i32* %20
%118 = add nsw i32 %116, %117
%119 = load i32, i32* %16
%120 = load i32, i32* %21
%121 = add nsw i32 %119, %120
%122 = add nsw i32 %121, 1
%123 = load i32, i32* %8
%124 = mul nsw i32 %122, %123
%125 = add nsw i32 %118, %124
%126 = sext i32 %125 to i64
%127 = getelementptr inbounds i32, i32* %115, i64 %126
%128 = load i32, i32* %127
store i32 %128, i32* %27
%129 = load i32*, i32** %10
%130 = load i32, i32* %15
%131 = load i32, i32* %20
%132 = add nsw i32 %130, %131
%133 = add nsw i32 %132, 1
%134 = load i32, i32* %16
%135 = load i32, i32* %21
%136 = add nsw i32 %134, %135
%137 = add nsw i32 %136, 1
%138 = load i32, i32* %8
%139 = mul nsw i32 %137, %138
%140 = add nsw i32 %133, %139
%141 = sext i32 %140 to i64
%142 = getelementptr inbounds i32, i32* %129, i64 %141
%143 = load i32, i32* %142
store i32 %143, i32* %28
%144 = load i32*, i32** %12
%145 = load i32, i32* %26
%146 = sext i32 %145 to i64
%147 = getelementptr inbounds i32, i32* %144, i64 %146
%148 = load i32, i32* %147
%149 = load i32*, i32** %12
%150 = load i32, i32* %27
%151 = sext i32 %150 to i64
%152 = getelementptr inbounds i32, i32* %149, i64 %151
%153 = load i32, i32* %152
%154 = add nsw i32 %148, %153
%155 = sdiv i32 %154, 2
store i32 %155, i32* %29
%156 = load i32*, i32** %12
%157 = load i32, i32* %25
%158 = sext i32 %157 to i64
%159 = getelementptr inbounds i32, i32* %156, i64 %158
%160 = load i32, i32* %159
%161 = load i32, i32* %29
%162 = sub nsw i32 %160, %161
%163 = load i32, i32* %22
%164 = sext i32 %163 to i64
%165 = getelementptr inbounds [25 x i32], [25 x i32]* %23, i64 0, i64 %164
store i32 %162, i32* %165
%166 = load i32*, i32** %12
%167 = load i32, i32* %28
%168 = sext i32 %167 to i64
%169 = getelementptr inbounds i32, i32* %166, i64 %168
%170 = load i32, i32* %169
%171 = load i32, i32* %29
%172 = sub nsw i32 %170, %171
%173 = load i32, i32* %22
%174 = sext i32 %173 to i64
%175 = getelementptr inbounds [25 x i32], [25 x i32]* %24, i64 0, i64 %174
store i32 %172, i32* %175
%176 = load i32, i32* %22
%177 = add nsw i32 %176, 1
store i32 %177, i32* %22
br label %178
178: ; preds = %87
%179 = load i32, i32* %21
%180 = add nsw i32 %179, 2
store i32 %180, i32* %21
br label %84
181: ; preds = %84
br label %182
182: ; preds = %181
%183 = load i32, i32* %20
%184 = add nsw i32 %183, 2
store i32 %184, i32* %20
br label %80
185: ; preds = %80
%186 = getelementptr inbounds [25 x i32], [25 x i32]* %23, i64 0, i64 0
%187 = call i32 @opt_med25(i32* %186)
store i32 %187, i32* %30
%188 = getelementptr inbounds [25 x i32], [25 x i32]* %24, i64 0, i64 0
%189 = call i32 @opt_med25(i32* %188)
store i32 %189, i32* %31
%190 = load i32, i32* %19
%191 = load i32, i32* %30
%192 = add nsw i32 %190, %191
%193 = icmp sle i32 %192, 32768
br i1 %193, label %194, label %195
194: ; preds = %185
br label %286
195: ; preds = %185
%196 = load i32, i32* %19
%197 = load i32, i32* %31
%198 = add nsw i32 %196, %197
%199 = icmp sle i32 %198, 32768
br i1 %199, label %200, label %201
200: ; preds = %195
br label %286
201: ; preds = %195
%202 = load i32*, i32** %13
%203 = load i32, i32* %19
%204 = load i32, i32* %30
%205 = add nsw i32 %203, %204
%206 = icmp slt i32 %205, 458751
br i1 %206, label %207, label %211
207: ; preds = %201
%208 = load i32, i32* %19
%209 = load i32, i32* %30
%210 = add nsw i32 %208, %209
br label %212
211: ; preds = %201
br label %212
212: ; preds = %211, %207
%213 = phi i32 [ %210, %207 ], [ 458751, %211 ]
%214 = icmp sgt i32 %213, 0
br i1 %214, label %215, label %227
215: ; preds = %212
%216 = load i32, i32* %19
%217 = load i32, i32* %30
%218 = add nsw i32 %216, %217
%219 = icmp slt i32 %218, 458751
br i1 %219, label %220, label %224
220: ; preds = %215
%221 = load i32, i32* %19
%222 = load i32, i32* %30
%223 = add nsw i32 %221, %222
br label %225
224: ; preds = %215
br label %225
225: ; preds = %224, %220
%226 = phi i32 [ %223, %220 ], [ 458751, %224 ]
br label %228
227: ; preds = %212
br label %228
228: ; preds = %227, %225
%229 = phi i32 [ %226, %225 ], [ 0, %227 ]
%230 = sext i32 %229 to i64
%231 = getelementptr inbounds i32, i32* %202, i64 %230
%232 = load i32, i32* %231
%233 = load i32, i32* %14
%234 = add nsw i32 %232, %233
%235 = load i32*, i32** %11
%236 = load i32, i32* %15
%237 = load i32, i32* %16
%238 = load i32, i32* %8
%239 = mul nsw i32 %237, %238
%240 = add nsw i32 %236, %239
%241 = sext i32 %240 to i64
%242 = getelementptr inbounds i32, i32* %235, i64 %241
store i32 %234, i32* %242
%243 = load i32*, i32** %13
%244 = load i32, i32* %19
%245 = load i32, i32* %31
%246 = add nsw i32 %244, %245
%247 = icmp slt i32 %246, 458751
br i1 %247, label %248, label %252
248: ; preds = %228
%249 = load i32, i32* %19
%250 = load i32, i32* %31
%251 = add nsw i32 %249, %250
br label %253
252: ; preds = %228
br label %253
253: ; preds = %252, %248
%254 = phi i32 [ %251, %248 ], [ 458751, %252 ]
%255 = icmp sgt i32 %254, 0
br i1 %255, label %256, label %268
256: ; preds = %253
%257 = load i32, i32* %19
%258 = load i32, i32* %31
%259 = add nsw i32 %257, %258
%260 = icmp slt i32 %259, 458751
br i1 %260, label %261, label %265
261: ; preds = %256
%262 = load i32, i32* %19
%263 = load i32, i32* %31
%264 = add nsw i32 %262, %263
br label %266
265: ; preds = %256
br label %266
266: ; preds = %265, %261
%267 = phi i32 [ %264, %261 ], [ 458751, %265 ]
br label %269
268: ; preds = %253
br label %269
269: ; preds = %268, %266
%270 = phi i32 [ %267, %266 ], [ 0, %268 ]
%271 = sext i32 %270 to i64
%272 = getelementptr inbounds i32, i32* %243, i64 %271
%273 = load i32, i32* %272
%274 = load i32, i32* %14
%275 = add nsw i32 %273, %274
%276 = load i32*, i32** %11
%277 = load i32, i32* %15
%278 = add nsw i32 %277, 1
%279 = load i32, i32* %16
%280 = add nsw i32 %279, 1
%281 = load i32, i32* %8
%282 = mul nsw i32 %280, %281
%283 = add nsw i32 %278, %282
%284 = sext i32 %283 to i64
%285 = getelementptr inbounds i32, i32* %276, i64 %284
store i32 %275, i32* %285
br label %286
286: ; preds = %269, %200, %194, %78
%287 = load i32, i32* %15
%288 = add nsw i32 %287, 2
store i32 %288, i32* %15
br label %38
289: ; preds = %38
br label %290
290: ; preds = %289
%291 = load i32, i32* %16
%292 = add nsw i32 %291, 2
store i32 %292, i32* %16
br label %32
293: ; preds = %32
ret void
}

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