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

/* Variables and functions */
int /*<<< orphan*/ assert(int);
void halve1Dimage_short(GLint components, GLuint width, GLuint height,
                        const GLshort *dataIn, GLshort *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;
  GLshort *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++) {
        GLshort sshort[2];
        if (myswap_bytes) {
          sshort[0] = (GLushort)(((GLushort)((const GLubyte *)(src))[1]) << 8 |
                                 ((const GLubyte *)(src))[0]);
          sshort[1] =
              (GLushort)(((GLushort)((const GLubyte *)(src + group_size))[1])
                             << 8 |
                         ((const GLubyte *)(src + group_size))[0]);
        } else {
          sshort[0] = *(const GLshort *)src;
          sshort[1] = *(const GLshort *)(src + group_size);
        }
        *dest = (sshort[0] + sshort[1]) / 2;
        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++) {
        GLshort sshort[2];
        if (myswap_bytes) {
          sshort[0] = (GLushort)(((GLushort)((const GLubyte *)(src))[1]) << 8 |
                                 ((const GLubyte *)(src))[0]);
          sshort[1] =
              (GLushort)(((GLushort)((const GLubyte *)(src + ysize))[1]) << 8 |
                         ((const GLubyte *)(src + ysize))[0]);
        } else {
          sshort[0] = *(const GLshort *)src;
          sshort[1] = *(const GLshort *)(src + ysize);
        }
        *dest = (sshort[0] + sshort[1]) / 2;
        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_short>:
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_short+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    12be <halve1Dimage_short+0x1ae>
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    1299 <halve1Dimage_short+0x189>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    127a <halve1Dimage_short+0x16a>
cmpl   $0x0,0x20(%rbp)
je     1222 <halve1Dimage_short+0x112>
mov    -0x38(%rbp),%rax
mov    0x4(%rax),%eax
shl    $0x8,%eax
mov    -0x38(%rbp),%rcx
or     (%rcx),%eax
mov    %eax,-0x50(%rbp)
mov    -0x38(%rbp),%rax
movslq 0x18(%rbp),%rcx
mov    0x4(%rax,%rcx,1),%eax
shl    $0x8,%eax
mov    -0x38(%rbp),%rcx
movslq 0x18(%rbp),%rdx
or     (%rcx,%rdx,1),%eax
mov    %eax,-0x4c(%rbp)
jmp    1239 <halve1Dimage_short+0x129>
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)
mov    -0x50(%rbp),%eax
add    -0x4c(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%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_short+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_short+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    1406 <halve1Dimage_short+0x2f6>
cmpl   $0x1,-0x8(%rbp)
jne    1401 <halve1Dimage_short+0x2f1>
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    13dc <halve1Dimage_short+0x2cc>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    13ac <halve1Dimage_short+0x29c>
cmpl   $0x0,0x20(%rbp)
je     1354 <halve1Dimage_short+0x244>
mov    -0x38(%rbp),%rax
mov    0x4(%rax),%eax
shl    $0x8,%eax
mov    -0x38(%rbp),%rcx
or     (%rcx),%eax
mov    %eax,-0x64(%rbp)
mov    -0x38(%rbp),%rax
movslq 0x10(%rbp),%rcx
mov    0x4(%rax,%rcx,1),%eax
shl    $0x8,%eax
mov    -0x38(%rbp),%rcx
movslq 0x10(%rbp),%rdx
or     (%rcx,%rdx,1),%eax
mov    %eax,-0x60(%rbp)
jmp    136b <halve1Dimage_short+0x25b>
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)
mov    -0x64(%rbp),%eax
add    -0x60(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%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    1309 <halve1Dimage_short+0x1f9>
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    12f6 <halve1Dimage_short+0x1e6>
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    1406 <halve1Dimage_short+0x2f6>
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_short>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %r9d,(%rsp)
mov    %r8,0x8(%rsp)
mov    %rcx,%rbp
mov    %edx,%r15d
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    %r15d,%ebx
setne  %dil
call   1030 <assert@plt>
mov    %r15d,%eax
mov    0x60(%rsp),%r15d
mov    0x58(%rsp),%ecx
cmp    $0x1,%eax
jne    121b <halve1Dimage_short+0x10b>
mov    %ecx,0x4(%rsp)
xor    %edi,%edi
cmp    $0x1,%ebx
setne  %dil
call   1030 <assert@plt>
mov    $0x1,%r12d
cmp    $0x2,%ebx
jl     12e7 <halve1Dimage_short+0x1d7>
movslq 0x4(%rsp),%rax
mov    (%rsp),%r10d
movslq %r10d,%rcx
xor    %r8d,%r8d
mov    0x8(%rsp),%r9
mov    %r9,%rbx
jmp    11d0 <halve1Dimage_short+0xc0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    %rax,%rbp
add    $0x1,%r8d
cmp    %r14d,%r8d
je     1316 <halve1Dimage_short+0x206>
test   %r13d,%r13d
jle    11c0 <halve1Dimage_short+0xb0>
mov    %r13d,%esi
jmp    1200 <halve1Dimage_short+0xf0>
nopw   0x0(%rax,%rax,1)
mov    0x0(%rbp),%edi
mov    0x0(%rbp,%rax,1),%edx
add    %edi,%edx
mov    %edx,%edi
shr    $0x1f,%edi
add    %edx,%edi
sar    %edi
mov    %edi,(%rbx)
add    %rcx,%rbp
add    $0x4,%rbx
add    $0xffffffff,%esi
je     11c0 <halve1Dimage_short+0xb0>
test   %r15d,%r15d
je     11e0 <halve1Dimage_short+0xd0>
mov    0x4(%rbp),%edi
shl    $0x8,%edi
or     0x0(%rbp),%edi
mov    0x4(%rbp,%rax,1),%edx
shl    $0x8,%edx
or     0x0(%rbp,%rax,1),%edx
jmp    11e7 <halve1Dimage_short+0xd7>
mov    %eax,%r12d
shr    $0x1f,%r12d
add    %eax,%r12d
sar    %r12d
cmp    $0x1,%ebx
jne    12e7 <halve1Dimage_short+0x1d7>
mov    %ecx,0x4(%rsp)
mov    0x50(%rsp),%ecx
mov    %ecx,0x14(%rsp)
mov    $0x1,%r14d
mov    $0x1,%edi
mov    %eax,%ebx
call   1030 <assert@plt>
mov    %ebx,%r11d
mov    %rbp,%rax
mov    0x8(%rsp),%rdx
mov    %rdx,%rbx
cmp    $0x2,%r11d
jl     12f1 <halve1Dimage_short+0x1e1>
mov    0x14(%rsp),%ecx
mov    %ecx,%eax
sub    0x4(%rsp),%eax
movslq %ecx,%rcx
movslq (%rsp),%r10
movslq %eax,%r8
xor    %r9d,%r9d
mov    %rdx,%rbx
mov    %rbp,%rax
jmp    129f <halve1Dimage_short+0x18f>
cs nopw 0x0(%rax,%rax,1)
add    %r8,%rax
add    %rcx,%rax
add    $0x1,%r9d
cmp    %r12d,%r9d
je     12f1 <halve1Dimage_short+0x1e1>
test   %r13d,%r13d
jle    1290 <halve1Dimage_short+0x180>
mov    %r13d,%esi
jmp    12ce <halve1Dimage_short+0x1be>
nopl   0x0(%rax)
mov    (%rax),%edi
mov    (%rax,%rcx,1),%edx
add    %edi,%edx
mov    %edx,%edi
shr    $0x1f,%edi
add    %edx,%edi
sar    %edi
mov    %edi,(%rbx)
add    %r10,%rax
add    $0x4,%rbx
add    $0xffffffff,%esi
je     1290 <halve1Dimage_short+0x180>
test   %r15d,%r15d
je     12b0 <halve1Dimage_short+0x1a0>
mov    0x4(%rax),%edi
shl    $0x8,%edi
or     (%rax),%edi
mov    0x4(%rax,%rcx,1),%edx
shl    $0x8,%edx
or     (%rax,%rcx,1),%edx
jmp    12b5 <halve1Dimage_short+0x1a5>
mov    0x8(%rsp),%r9
mov    %r9,%rbx
jmp    1312 <halve1Dimage_short+0x202>
mov    0x14(%rsp),%ecx
imul   %r11d,%ecx
movslq %ecx,%rcx
add    %rcx,%rbp
xor    %edi,%edi
cmp    %rbp,%rax
sete   %dil
call   1030 <assert@plt>
mov    0x8(%rsp),%r9
mov    (%rsp),%r10d
imul   %r14d,%r12d
imul   %r13d,%r10d
imul   %r12d,%r10d
movslq %r10d,%rax
add    %rax,%r9
xor    %edi,%edi
cmp    %rbx,%r9
sete   %dil
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <assert@plt>

LLVM IR (-O0):
define void @halve1Dimage_short(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 %146
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 = %133, %53
%59 = load i32, i32* %23
%60 = load i32, i32* %19
%61 = icmp slt i32 %59, %60
br i1 %61, label %62, label %136
62: ; preds = %58
store i32 0, i32* %24
br label %63
63: ; preds = %125, %62
%64 = load i32, i32* %24
%65 = load i32, i32* %10
%66 = icmp slt i32 %64, %65
br i1 %66, label %67, label %128
67: ; preds = %63
%68 = load i32, i32* %18
%69 = icmp ne i32 %68, 0
br i1 %69, label %70, label %99
70: ; preds = %67
%71 = load i8*, i8** %21
%72 = bitcast i8* %71 to i32*
%73 = getelementptr inbounds i32, i32* %72, i64 1
%74 = load i32, i32* %73
%75 = shl i32 %74, 8
%76 = load i8*, i8** %21
%77 = bitcast i8* %76 to i32*
%78 = getelementptr inbounds i32, i32* %77, i64 0
%79 = load i32, i32* %78
%80 = or i32 %75, %79
%81 = getelementptr inbounds [2 x i32], [2 x i32]* %25, i64 0, i64 0
store i32 %80, i32* %81
%82 = load i8*, i8** %21
%83 = load i32, i32* %17
%84 = sext i32 %83 to i64
%85 = getelementptr inbounds i8, i8* %82, i64 %84
%86 = bitcast i8* %85 to i32*
%87 = getelementptr inbounds i32, i32* %86, i64 1
%88 = load i32, i32* %87
%89 = shl i32 %88, 8
%90 = load i8*, i8** %21
%91 = load i32, i32* %17
%92 = sext i32 %91 to i64
%93 = getelementptr inbounds i8, i8* %90, i64 %92
%94 = bitcast i8* %93 to i32*
%95 = getelementptr inbounds i32, i32* %94, i64 0
%96 = load i32, i32* %95
%97 = or i32 %89, %96
%98 = getelementptr inbounds [2 x i32], [2 x i32]* %25, i64 0, i64 1
store i32 %97, i32* %98
br label %111
99: ; preds = %67
%100 = load i8*, i8** %21
%101 = bitcast i8* %100 to i32*
%102 = load i32, i32* %101
%103 = getelementptr inbounds [2 x i32], [2 x i32]* %25, i64 0, i64 0
store i32 %102, i32* %103
%104 = load i8*, i8** %21
%105 = load i32, i32* %17
%106 = sext i32 %105 to i64
%107 = getelementptr inbounds i8, i8* %104, i64 %106
%108 = bitcast i8* %107 to i32*
%109 = load i32, i32* %108
%110 = getelementptr inbounds [2 x i32], [2 x i32]* %25, i64 0, i64 1
store i32 %109, i32* %110
br label %111
111: ; preds = %99, %70
%112 = getelementptr inbounds [2 x i32], [2 x i32]* %25, i64 0, i64 0
%113 = load i32, i32* %112
%114 = getelementptr inbounds [2 x i32], [2 x i32]* %25, i64 0, i64 1
%115 = load i32, i32* %114
%116 = add nsw i32 %113, %115
%117 = sdiv i32 %116, 2
%118 = load i32*, i32** %22
store i32 %117, i32* %118
%119 = load i32, i32* %15
%120 = load i8*, i8** %21
%121 = sext i32 %119 to i64
%122 = getelementptr inbounds i8, i8* %120, i64 %121
store i8* %122, i8** %21
%123 = load i32*, i32** %22
%124 = getelementptr inbounds i32, i32* %123, i32 1
store i32* %124, i32** %22
br label %125
125: ; preds = %111
%126 = load i32, i32* %24
%127 = add nsw i32 %126, 1
store i32 %127, i32* %24
br label %63
128: ; preds = %63
%129 = load i32, i32* %17
%130 = load i8*, i8** %21
%131 = sext i32 %129 to i64
%132 = getelementptr inbounds i8, i8* %130, i64 %131
store i8* %132, i8** %21
br label %133
133: ; preds = %128
%134 = load i32, i32* %23
%135 = add nsw i32 %134, 1
store i32 %135, i32* %23
br label %58
136: ; preds = %58
%137 = load i32, i32* %16
%138 = load i32, i32* %11
%139 = load i32, i32* %17
%140 = mul nsw i32 %138, %139
%141 = sub nsw i32 %137, %140
store i32 %141, i32* %26
%142 = load i32, i32* %26
%143 = load i8*, i8** %21
%144 = sext i32 %142 to i64
%145 = getelementptr inbounds i8, i8* %143, i64 %144
store i8* %145, i8** %21
br label %254
146: ; preds = %42
%147 = load i32, i32* %11
%148 = icmp eq i32 %147, 1
br i1 %148, label %149, label %253
149: ; preds = %146
%150 = load i32, i32* %16
%151 = load i32, i32* %11
%152 = load i32, i32* %17
%153 = mul nsw i32 %151, %152
%154 = sub nsw i32 %150, %153
store i32 %154, i32* %27
%155 = load i32, i32* %12
%156 = icmp ne i32 %155, 1
%157 = zext i1 %156 to i32
%158 = call i32 @assert(i32 %157)
store i32 1, i32* %19
store i32 0, i32* %23
br label %159
159: ; preds = %238, %149
%160 = load i32, i32* %23
%161 = load i32, i32* %20
%162 = icmp slt i32 %160, %161
br i1 %162, label %163, label %241
163: ; preds = %159
store i32 0, i32* %28
br label %164
164: ; preds = %226, %163
%165 = load i32, i32* %28
%166 = load i32, i32* %10
%167 = icmp slt i32 %165, %166
br i1 %167, label %168, label %229
168: ; preds = %164
%169 = load i32, i32* %18
%170 = icmp ne i32 %169, 0
br i1 %170, label %171, label %200
171: ; preds = %168
%172 = load i8*, i8** %21
%173 = bitcast i8* %172 to i32*
%174 = getelementptr inbounds i32, i32* %173, i64 1
%175 = load i32, i32* %174
%176 = shl i32 %175, 8
%177 = load i8*, i8** %21
%178 = bitcast i8* %177 to i32*
%179 = getelementptr inbounds i32, i32* %178, i64 0
%180 = load i32, i32* %179
%181 = or i32 %176, %180
%182 = getelementptr inbounds [2 x i32], [2 x i32]* %29, i64 0, i64 0
store i32 %181, i32* %182
%183 = load i8*, i8** %21
%184 = load i32, i32* %16
%185 = sext i32 %184 to i64
%186 = getelementptr inbounds i8, i8* %183, i64 %185
%187 = bitcast i8* %186 to i32*
%188 = getelementptr inbounds i32, i32* %187, i64 1
%189 = load i32, i32* %188
%190 = shl i32 %189, 8
%191 = load i8*, i8** %21
%192 = load i32, i32* %16
%193 = sext i32 %192 to i64
%194 = getelementptr inbounds i8, i8* %191, i64 %193
%195 = bitcast i8* %194 to i32*
%196 = getelementptr inbounds i32, i32* %195, i64 0
%197 = load i32, i32* %196
%198 = or i32 %190, %197
%199 = getelementptr inbounds [2 x i32], [2 x i32]* %29, i64 0, i64 1
store i32 %198, i32* %199
br label %212
200: ; preds = %168
%201 = load i8*, i8** %21
%202 = bitcast i8* %201 to i32*
%203 = load i32, i32* %202
%204 = getelementptr inbounds [2 x i32], [2 x i32]* %29, i64 0, i64 0
store i32 %203, i32* %204
%205 = load i8*, i8** %21
%206 = load i32, i32* %16
%207 = sext i32 %206 to i64
%208 = getelementptr inbounds i8, i8* %205, i64 %207
%209 = bitcast i8* %208 to i32*
%210 = load i32, i32* %209
%211 = getelementptr inbounds [2 x i32], [2 x i32]* %29, i64 0, i64 1
store i32 %210, i32* %211
br label %212
212: ; preds = %200, %171
%213 = getelementptr inbounds [2 x i32], [2 x i32]* %29, i64 0, i64 0
%214 = load i32, i32* %213
%215 = getelementptr inbounds [2 x i32], [2 x i32]* %29, i64 0, i64 1
%216 = load i32, i32* %215
%217 = add nsw i32 %214, %216
%218 = sdiv i32 %217, 2
%219 = load i32*, i32** %22
store i32 %218, i32* %219
%220 = load i32, i32* %15
%221 = load i8*, i8** %21
%222 = sext i32 %220 to i64
%223 = getelementptr inbounds i8, i8* %221, i64 %222
store i8* %223, i8** %21
%224 = load i32*, i32** %22
%225 = getelementptr inbounds i32, i32* %224, i32 1
store i32* %225, i32** %22
br label %226
226: ; preds = %212
%227 = load i32, i32* %28
%228 = add nsw i32 %227, 1
store i32 %228, i32* %28
br label %164
229: ; preds = %164
%230 = load i32, i32* %27
%231 = load i8*, i8** %21
%232 = sext i32 %230 to i64
%233 = getelementptr inbounds i8, i8* %231, i64 %232
store i8* %233, i8** %21
%234 = load i32, i32* %16
%235 = load i8*, i8** %21
%236 = sext i32 %234 to i64
%237 = getelementptr inbounds i8, i8* %235, i64 %236
store i8* %237, i8** %21
br label %238
238: ; preds = %229
%239 = load i32, i32* %23
%240 = add nsw i32 %239, 1
store i32 %240, i32* %23
br label %159
241: ; preds = %159
%242 = load i8*, i8** %21
%243 = load i32*, i32** %13
%244 = bitcast i32* %243 to i8*
%245 = load i32, i32* %16
%246 = load i32, i32* %12
%247 = mul nsw i32 %245, %246
%248 = sext i32 %247 to i64
%249 = getelementptr inbounds i8, i8* %244, i64 %248
%250 = icmp eq i8* %242, %249
%251 = zext i1 %250 to i32
%252 = call i32 @assert(i32 %251)
br label %253
253: ; preds = %241, %146
br label %254
254: ; preds = %253, %136
%255 = load i32*, i32** %22
%256 = bitcast i32* %255 to i8*
%257 = load i32*, i32** %14
%258 = bitcast i32* %257 to i8*
%259 = load i32, i32* %10
%260 = load i32, i32* %15
%261 = mul nsw i32 %259, %260
%262 = load i32, i32* %19
%263 = mul nsw i32 %261, %262
%264 = load i32, i32* %20
%265 = mul nsw i32 %263, %264
%266 = sext i32 %265 to i64
%267 = getelementptr inbounds i8, i8* %258, i64 %266
%268 = icmp eq i8* %256, %267
%269 = zext i1 %268 to i32
%270 = call i32 @assert(i32 %269)
ret void
}

LLVM IR (-O2):
define void @halve1Dimage_short(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 %75
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 %140
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, %69
%32 = phi i32 [ 0, %26 ], [ %73, %69 ]
%33 = phi i32* [ %4, %26 ], [ %71, %69 ]
%34 = phi i8* [ %12, %26 ], [ %72, %69 ]
br i1 %27, label %35, label %69
35: ; preds = %31, %60
%36 = phi i32 [ %67, %60 ], [ 0, %31 ]
%37 = phi i32* [ %66, %60 ], [ %33, %31 ]
%38 = phi i8* [ %65, %60 ], [ %34, %31 ]
%39 = bitcast i8* %38 to i32*
br i1 %28, label %55, label %40
40: ; preds = %35
%41 = getelementptr inbounds i8, i8* %38, i64 4
%42 = bitcast i8* %41 to i32*
%43 = load i32, i32* %42
%44 = shl i32 %43, 8
%45 = load i32, i32* %39
%46 = or i32 %44, %45
%47 = getelementptr inbounds i8, i8* %38, i64 %29
%48 = bitcast i8* %47 to i32*
%49 = getelementptr inbounds i8, i8* %47, i64 4
%50 = bitcast i8* %49 to i32*
%51 = load i32, i32* %50
%52 = shl i32 %51, 8
%53 = load i32, i32* %48
%54 = or i32 %52, %53
br label %60
55: ; preds = %35
%56 = load i32, i32* %39
%57 = getelementptr inbounds i8, i8* %38, i64 %29
%58 = bitcast i8* %57 to i32*
%59 = load i32, i32* %58
br label %60
60: ; preds = %55, %40
%61 = phi i32 [ %54, %40 ], [ %59, %55 ]
%62 = phi i32 [ %46, %40 ], [ %56, %55 ]
%63 = add nsw i32 %62, %61
%64 = sdiv i32 %63, 2
store i32 %64, i32* %37
%65 = getelementptr inbounds i8, i8* %38, i64 %30
%66 = getelementptr inbounds i32, i32* %37, i64 1
%67 = add nuw nsw i32 %36, 1
%68 = icmp eq i32 %67, %0
br i1 %68, label %69, label %35
69: ; preds = %60, %31
%70 = phi i8* [ %34, %31 ], [ %65, %60 ]
%71 = phi i32* [ %33, %31 ], [ %66, %60 ]
%72 = getelementptr inbounds i8, i8* %70, i64 %29
%73 = add nuw nsw i32 %32, 1
%74 = icmp eq i32 %73, %10
br i1 %74, label %140, label %31
75: ; preds = %9
br i1 %13, label %76, label %140
76: ; preds = %75
%77 = tail call i32 @assert(i32 1)
%78 = icmp sgt i32 %2, 1
br i1 %78, label %79, label %131
79: ; preds = %76
%80 = sub nsw i32 %6, %7
%81 = icmp sgt i32 %0, 0
%82 = icmp eq i32 %8, 0
%83 = sext i32 %6 to i64
%84 = sext i32 %5 to i64
%85 = sext i32 %80 to i64
br label %86
86: ; preds = %79, %124
%87 = phi i32 [ 0, %79 ], [ %129, %124 ]
%88 = phi i32* [ %4, %79 ], [ %126, %124 ]
%89 = phi i8* [ %12, %79 ], [ %128, %124 ]
br i1 %81, label %90, label %124
90: ; preds = %86, %115
%91 = phi i32 [ %122, %115 ], [ 0, %86 ]
%92 = phi i32* [ %121, %115 ], [ %88, %86 ]
%93 = phi i8* [ %120, %115 ], [ %89, %86 ]
%94 = bitcast i8* %93 to i32*
br i1 %82, label %110, label %95
95: ; preds = %90
%96 = getelementptr inbounds i8, i8* %93, i64 4
%97 = bitcast i8* %96 to i32*
%98 = load i32, i32* %97
%99 = shl i32 %98, 8
%100 = load i32, i32* %94
%101 = or i32 %99, %100
%102 = getelementptr inbounds i8, i8* %93, i64 %83
%103 = bitcast i8* %102 to i32*
%104 = getelementptr inbounds i8, i8* %102, i64 4
%105 = bitcast i8* %104 to i32*
%106 = load i32, i32* %105
%107 = shl i32 %106, 8
%108 = load i32, i32* %103
%109 = or i32 %107, %108
br label %115
110: ; preds = %90
%111 = load i32, i32* %94
%112 = getelementptr inbounds i8, i8* %93, i64 %83
%113 = bitcast i8* %112 to i32*
%114 = load i32, i32* %113
br label %115
115: ; preds = %110, %95
%116 = phi i32 [ %109, %95 ], [ %114, %110 ]
%117 = phi i32 [ %101, %95 ], [ %111, %110 ]
%118 = add nsw i32 %117, %116
%119 = sdiv i32 %118, 2
store i32 %119, i32* %92
%120 = getelementptr inbounds i8, i8* %93, i64 %84
%121 = getelementptr inbounds i32, i32* %92, i64 1
%122 = add nuw nsw i32 %91, 1
%123 = icmp eq i32 %122, %0
br i1 %123, label %124, label %90
124: ; preds = %115, %86
%125 = phi i8* [ %89, %86 ], [ %120, %115 ]
%126 = phi i32* [ %88, %86 ], [ %121, %115 ]
%127 = getelementptr inbounds i8, i8* %125, i64 %85
%128 = getelementptr inbounds i8, i8* %127, i64 %83
%129 = add nuw nsw i32 %87, 1
%130 = icmp eq i32 %129, %11
br i1 %130, label %131, label %86
131: ; preds = %124, %76
%132 = phi i8* [ %12, %76 ], [ %128, %124 ]
%133 = phi i32* [ %4, %76 ], [ %126, %124 ]
%134 = mul nsw i32 %6, %2
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds i8, i8* %12, i64 %135
%137 = icmp eq i8* %132, %136
%138 = zext i1 %137 to i32
%139 = tail call i32 @assert(i32 %138)
br label %140
140: ; preds = %69, %21, %75, %131
%141 = phi i32* [ %133, %131 ], [ %4, %75 ], [ %4, %21 ], [ %71, %69 ]
%142 = phi i32 [ %11, %131 ], [ %11, %75 ], [ 1, %21 ], [ 1, %69 ]
%143 = phi i32 [ 1, %131 ], [ %10, %75 ], [ %10, %21 ], [ %10, %69 ]
%144 = bitcast i32* %141 to i8*
%145 = bitcast i32* %4 to i8*
%146 = mul nsw i32 %5, %0
%147 = mul i32 %146, %142
%148 = mul i32 %147, %143
%149 = sext i32 %148 to i64
%150 = getelementptr inbounds i8, i8* %145, i64 %149
%151 = icmp eq i8* %150, %144
%152 = zext i1 %151 to i32
%153 = tail call i32 @assert(i32 %152)
ret void
}