#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 GLuint;
typedef int GLubyte;
typedef int GLint;

/* Variables and functions */
int /*<<< orphan*/ assert(int);
void halve1Dimage_int(GLint components, GLuint width, GLuint height,
                      const GLint *dataIn, GLint *dataOut, GLint element_size,
                      GLint ysize, GLint group_size, GLint myswap_bytes) {
  GLint halfWidth = width / 2;
  GLint halfHeight = height / 2;
  const char *src = (const char *)dataIn;
  GLint *dest = dataOut;
  int jj;
  assert(width == 1 || height == 1);
  assert(width != height);
  if (height == 1) {
    assert(width != 1);
    halfHeight = 1;
    for (jj = 0; jj < halfWidth; jj++) {
      int kk;
      for (kk = 0; kk < components; kk++) {
        GLuint uint[2];
        if (myswap_bytes) {
          uint[0] = (GLuint)(((GLuint)((const GLubyte *)(src))[3]) << 24 |
                             ((GLuint)((const GLubyte *)(src))[2]) << 16 |
                             ((GLuint)((const GLubyte *)(src))[1]) << 8 |
                             ((const GLubyte *)(src))[0]);
          uint[1] =
              (GLuint)(((GLuint)((const GLubyte *)(src + group_size))[3])
                           << 24 |
                       ((GLuint)((const GLubyte *)(src + group_size))[2])
                           << 16 |
                       ((GLuint)((const GLubyte *)(src + group_size))[1]) << 8 |
                       ((const GLubyte *)(src + group_size))[0]);
        } else {
          uint[0] = *(const GLuint *)src;
          uint[1] = *(const GLuint *)(src + group_size);
        }
        *dest = ((float)uint[0] + (float)uint[1]) / 2.0;
        src += element_size;
        dest++;
      }
      src += group_size;
    }
    {
      int padBytes = ysize - (width * group_size);
      src += padBytes;
    }
  } else if (width == 1) {
    int padBytes = ysize - (width * group_size);
    assert(height != 1);
    halfWidth = 1;
    for (jj = 0; jj < halfHeight; jj++) {
      int kk;
      for (kk = 0; kk < components; kk++) {
        GLuint uint[2];
        if (myswap_bytes) {
          uint[0] = (GLuint)(((GLuint)((const GLubyte *)(src))[3]) << 24 |
                             ((GLuint)((const GLubyte *)(src))[2]) << 16 |
                             ((GLuint)((const GLubyte *)(src))[1]) << 8 |
                             ((const GLubyte *)(src))[0]);
          uint[1] =
              (GLuint)(((GLuint)((const GLubyte *)(src + ysize))[3]) << 24 |
                       ((GLuint)((const GLubyte *)(src + ysize))[2]) << 16 |
                       ((GLuint)((const GLubyte *)(src + ysize))[1]) << 8 |
                       ((const GLubyte *)(src + ysize))[0]);
        } else {
          uint[0] = *(const GLuint *)src;
          uint[1] = *(const GLuint *)(src + ysize);
        }
        *dest = ((float)uint[0] + (float)uint[1]) / 2.0;
        src += element_size;
        dest++;
      }
      src += padBytes;
      src += ysize;
    }
    assert(src == &((const char *)dataIn)[ysize * height]);
  }
  assert(
      (char *)dest ==
      &((char *)dataOut)[components * element_size * halfWidth * halfHeight]);
}


x86 assembly (clang, -O0):
<halve1Dimage_int>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9d,-0x24(%rbp)
mov    -0x8(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x28(%rbp)
mov    -0xc(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x2c(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    $0x1,%al
cmpl   $0x1,-0x8(%rbp)
mov    %al,-0x65(%rbp)
je     117b <halve1Dimage_int+0x6b>
cmpl   $0x1,-0xc(%rbp)
sete   %al
mov    %al,-0x65(%rbp)
mov    -0x65(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    -0x8(%rbp),%eax
cmp    -0xc(%rbp),%eax
setne  %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
cmpl   $0x1,-0xc(%rbp)
jne    130a <halve1Dimage_int+0x1fa>
cmpl   $0x1,-0x8(%rbp)
setne  %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
movl   $0x1,-0x2c(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    12e5 <halve1Dimage_int+0x1d5>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    12c6 <halve1Dimage_int+0x1b6>
cmpl   $0x0,0x20(%rbp)
je     125c <halve1Dimage_int+0x14c>
mov    -0x38(%rbp),%rax
mov    0xc(%rax),%eax
shl    $0x18,%eax
mov    -0x38(%rbp),%rcx
mov    0x8(%rcx),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0x38(%rbp),%rcx
mov    0x4(%rcx),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0x38(%rbp),%rcx
or     (%rcx),%eax
mov    %eax,-0x50(%rbp)
mov    -0x38(%rbp),%rax
movslq 0x18(%rbp),%rcx
mov    0xc(%rax,%rcx,1),%eax
shl    $0x18,%eax
mov    -0x38(%rbp),%rcx
movslq 0x18(%rbp),%rdx
mov    0x8(%rcx,%rdx,1),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0x38(%rbp),%rcx
movslq 0x18(%rbp),%rdx
mov    0x4(%rcx,%rdx,1),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0x38(%rbp),%rcx
movslq 0x18(%rbp),%rdx
or     (%rcx,%rdx,1),%eax
mov    %eax,-0x4c(%rbp)
jmp    1273 <halve1Dimage_int+0x163>
mov    -0x38(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x50(%rbp)
mov    -0x38(%rbp),%rax
movslq 0x18(%rbp),%rcx
mov    (%rax,%rcx,1),%eax
mov    %eax,-0x4c(%rbp)
cvtsi2ssl -0x50(%rbp),%xmm0
cvtsi2ssl -0x4c(%rbp),%xmm1
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xd73(%rip),%xmm1
divsd  %xmm1,%xmm0
cvttsd2si %xmm0,%ecx
mov    -0x40(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x24(%rbp),%ecx
mov    -0x38(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x40(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x40(%rbp)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    11d7 <halve1Dimage_int+0xc7>
mov    0x18(%rbp),%ecx
mov    -0x38(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    11c4 <halve1Dimage_int+0xb4>
mov    0x10(%rbp),%eax
mov    -0x8(%rbp),%ecx
imul   0x18(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%ecx
mov    -0x38(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
jmp    149e <halve1Dimage_int+0x38e>
cmpl   $0x1,-0x8(%rbp)
jne    1499 <halve1Dimage_int+0x389>
mov    0x10(%rbp),%eax
mov    -0x8(%rbp),%ecx
imul   0x18(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x58(%rbp)
cmpl   $0x1,-0xc(%rbp)
setne  %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
movl   $0x1,-0x28(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1474 <halve1Dimage_int+0x364>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1444 <halve1Dimage_int+0x334>
cmpl   $0x0,0x20(%rbp)
je     13da <halve1Dimage_int+0x2ca>
mov    -0x38(%rbp),%rax
mov    0xc(%rax),%eax
shl    $0x18,%eax
mov    -0x38(%rbp),%rcx
mov    0x8(%rcx),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0x38(%rbp),%rcx
mov    0x4(%rcx),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0x38(%rbp),%rcx
or     (%rcx),%eax
mov    %eax,-0x64(%rbp)
mov    -0x38(%rbp),%rax
movslq 0x10(%rbp),%rcx
mov    0xc(%rax,%rcx,1),%eax
shl    $0x18,%eax
mov    -0x38(%rbp),%rcx
movslq 0x10(%rbp),%rdx
mov    0x8(%rcx,%rdx,1),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0x38(%rbp),%rcx
movslq 0x10(%rbp),%rdx
mov    0x4(%rcx,%rdx,1),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0x38(%rbp),%rcx
movslq 0x10(%rbp),%rdx
or     (%rcx,%rdx,1),%eax
mov    %eax,-0x60(%rbp)
jmp    13f1 <halve1Dimage_int+0x2e1>
mov    -0x38(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x64(%rbp)
mov    -0x38(%rbp),%rax
movslq 0x10(%rbp),%rcx
mov    (%rax,%rcx,1),%eax
mov    %eax,-0x60(%rbp)
cvtsi2ssl -0x64(%rbp),%xmm0
cvtsi2ssl -0x60(%rbp),%xmm1
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xbf5(%rip),%xmm1
divsd  %xmm1,%xmm0
cvttsd2si %xmm0,%ecx
mov    -0x40(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x24(%rbp),%ecx
mov    -0x38(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x40(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x40(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1355 <halve1Dimage_int+0x245>
mov    -0x58(%rbp),%ecx
mov    -0x38(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    0x10(%rbp),%ecx
mov    -0x38(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1342 <halve1Dimage_int+0x232>
mov    -0x38(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    0x10(%rbp),%edx
imul   -0xc(%rbp),%edx
movslq %edx,%rdx
add    %rdx,%rcx
cmp    %rcx,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
jmp    149e <halve1Dimage_int+0x38e>
mov    -0x40(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    -0x4(%rbp),%edx
imul   -0x24(%rbp),%edx
imul   -0x28(%rbp),%edx
imul   -0x2c(%rbp),%edx
movslq %edx,%rdx
add    %rdx,%rcx
cmp    %rcx,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<halve1Dimage_int>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %r9d,0x4(%rsp)
mov    %r8,0x8(%rsp)
mov    %rcx,%rbp
mov    %edx,%r12d
mov    %esi,%ebx
mov    %edi,%r13d
mov    %esi,%r14d
shr    $0x1f,%r14d
add    %esi,%r14d
sar    %r14d
cmp    $0x1,%esi
sete   %al
cmp    $0x1,%edx
sete   %cl
or     %al,%cl
movzbl %cl,%edi
call   1030 <assert@plt>
xor    %edi,%edi
cmp    %r12d,%ebx
setne  %dil
call   1030 <assert@plt>
mov    0x70(%rsp),%r15d
mov    0x68(%rsp),%ecx
cmp    $0x1,%r12d
jne    1258 <halve1Dimage_int+0x148>
mov    %ecx,0x10(%rsp)
xor    %edi,%edi
cmp    $0x1,%ebx
setne  %dil
call   1030 <assert@plt>
mov    $0x1,%r12d
cmp    $0x2,%ebx
jl     1377 <halve1Dimage_int+0x267>
movslq 0x10(%rsp),%r10
movslq 0x4(%rsp),%r9
xor    %r8d,%r8d
movsd  0xe53(%rip),%xmm0
mov    0x8(%rsp),%r11
mov    %r11,%rbx
jmp    11d0 <halve1Dimage_int+0xc0>
nopw   0x0(%rax,%rax,1)
add    %r10,%rbp
add    $0x1,%r8d
cmp    %r14d,%r8d
je     13b2 <halve1Dimage_int+0x2a2>
test   %r13d,%r13d
jle    11c0 <halve1Dimage_int+0xb0>
mov    %r13d,%esi
jmp    1217 <halve1Dimage_int+0x107>
nopw   0x0(%rax,%rax,1)
mov    0x0(%rbp),%edi
mov    0x0(%rbp,%r10,1),%edx
xorps  %xmm1,%xmm1
cvtsi2ss %edi,%xmm1
xorps  %xmm2,%xmm2
cvtsi2ss %edx,%xmm2
addss  %xmm1,%xmm2
xorps  %xmm1,%xmm1
cvtss2sd %xmm2,%xmm1
mulsd  %xmm0,%xmm1
cvttsd2si %xmm1,%eax
mov    %eax,(%rbx)
add    %r9,%rbp
add    $0x4,%rbx
add    $0xffffffff,%esi
je     11c0 <halve1Dimage_int+0xb0>
test   %r15d,%r15d
je     11e0 <halve1Dimage_int+0xd0>
mov    0xc(%rbp),%edx
shl    $0x18,%edx
mov    0x4(%rbp),%edi
mov    0x8(%rbp),%ecx
shl    $0x10,%ecx
or     %edx,%ecx
shl    $0x8,%edi
or     %ecx,%edi
or     0x0(%rbp),%edi
mov    0xc(%rbp,%r10,1),%ecx
shl    $0x18,%ecx
mov    0x4(%rbp,%r10,1),%edx
mov    0x8(%rbp,%r10,1),%eax
shl    $0x10,%eax
or     %ecx,%eax
shl    $0x8,%edx
or     %eax,%edx
or     0x0(%rbp,%r10,1),%edx
jmp    11e8 <halve1Dimage_int+0xd8>
mov    %r12d,%eax
shr    $0x1f,%eax
add    %r12d,%eax
sar    %eax
mov    %eax,0x20(%rsp)
cmp    $0x1,%ebx
jne    1381 <halve1Dimage_int+0x271>
mov    %ecx,0x10(%rsp)
mov    0x60(%rsp),%eax
mov    %eax,0x1c(%rsp)
mov    $0x1,%r14d
mov    $0x1,%edi
call   1030 <assert@plt>
mov    %rbp,%rax
mov    0x8(%rsp),%rbx
mov    %r12d,0x24(%rsp)
cmp    $0x2,%r12d
mov    0x20(%rsp),%r12d
jl     1390 <halve1Dimage_int+0x280>
mov    0x1c(%rsp),%ecx
mov    %ecx,%eax
sub    0x10(%rsp),%eax
movslq %ecx,%r11
movslq 0x4(%rsp),%r10
cltq
mov    %rax,0x10(%rsp)
xor    %r9d,%r9d
movsd  0xd34(%rip),%xmm0
mov    0x8(%rsp),%rbx
mov    %rbp,%rax
jmp    12f5 <halve1Dimage_int+0x1e5>
cs nopw 0x0(%rax,%rax,1)
add    0x10(%rsp),%rax
add    %r11,%rax
add    $0x1,%r9d
cmp    %r12d,%r9d
je     1390 <halve1Dimage_int+0x280>
test   %r13d,%r13d
jle    12e0 <halve1Dimage_int+0x1d0>
mov    %r13d,%esi
jmp    1335 <halve1Dimage_int+0x225>
nop
mov    (%rax),%edi
mov    (%rax,%r11,1),%edx
xorps  %xmm1,%xmm1
cvtsi2ss %edi,%xmm1
xorps  %xmm2,%xmm2
cvtsi2ss %edx,%xmm2
addss  %xmm1,%xmm2
xorps  %xmm1,%xmm1
cvtss2sd %xmm2,%xmm1
mulsd  %xmm0,%xmm1
cvttsd2si %xmm1,%ecx
mov    %ecx,(%rbx)
add    %r10,%rax
add    $0x4,%rbx
add    $0xffffffff,%esi
je     12e0 <halve1Dimage_int+0x1d0>
test   %r15d,%r15d
je     1300 <halve1Dimage_int+0x1f0>
mov    0xc(%rax),%edx
shl    $0x18,%edx
mov    0x4(%rax),%edi
mov    0x8(%rax),%ecx
shl    $0x10,%ecx
or     %edx,%ecx
shl    $0x8,%edi
or     %ecx,%edi
or     (%rax),%edi
mov    0xc(%rax,%r11,1),%ecx
shl    $0x18,%ecx
mov    0x4(%rax,%r11,1),%edx
mov    0x8(%rax,%r11,1),%r8d
shl    $0x10,%r8d
or     %ecx,%r8d
shl    $0x8,%edx
or     %r8d,%edx
or     (%rax,%r11,1),%edx
jmp    1306 <halve1Dimage_int+0x1f6>
mov    0x8(%rsp),%r11
mov    %r11,%rbx
jmp    13b2 <halve1Dimage_int+0x2a2>
mov    0x8(%rsp),%r11
mov    %r11,%rbx
mov    0x20(%rsp),%r12d
jmp    13b2 <halve1Dimage_int+0x2a2>
mov    0x1c(%rsp),%ecx
imul   0x24(%rsp),%ecx
movslq %ecx,%rcx
add    %rcx,%rbp
xor    %edi,%edi
cmp    %rbp,%rax
sete   %dil
call   1030 <assert@plt>
mov    0x8(%rsp),%r11
imul   %r14d,%r12d
mov    0x4(%rsp),%eax
imul   %r13d,%eax
imul   %r12d,%eax
cltq
add    %rax,%r11
xor    %edi,%edi
cmp    %rbx,%r11
sete   %dil
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <assert@plt>

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

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