#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;
typedef int uint16_t;

/* Variables and functions */
int /*<<< orphan*/ memcpy(int *, int *, int);
void debayerBasic(uint16_t *__restrict debayerto, float *__restrict bayerdata,
                  int width, int height, int threads) {
  (void)threads;
  int pixelsizeDB;
  if (height % 2 == 0)
    pixelsizeDB = width * (height - 1);
  else
    pixelsizeDB = width * (height - 2);
  int widthDB = width - 1;
  int step = width * 2;
  int nextRowRGB = width * 3;
#pragma omp parallel for
  for (int Y = width; Y < pixelsizeDB; Y += step) {
    for (int x = 1; x < widthDB; x += 2) {
      int pix = Y + x;
      int pixm1 = pix - width;
      int pixp1 = pix + width;
      int pixp2 = pixp1 + width;
      int bPix[16] = {
          (pixm1 - 1), (pixm1), (pixm1 + 1), (pixm1 + 2),
          (pix - 1),   (pix),   (pix + 1),   (pix + 2),
          (pixp1 - 1), (pixp1), (pixp1 + 1), (pixp1 + 2),
          (pixp2 - 1), (pixp2), (pixp2 + 1), (pixp2 + 2),
      };
      int rgbPix[4] = {(bPix[5] * 3), (bPix[6] * 3), (bPix[9] * 3),
                       (bPix[10] * 3)};
      debayerto[rgbPix[0]] =
          (uint32_t)(bayerdata[bPix[0]] + bayerdata[bPix[2]] +
                     bayerdata[bPix[8]] + bayerdata[bPix[10]]) >>
          2;
      debayerto[rgbPix[0] + 1] =
          (uint32_t)(bayerdata[bPix[1]] + bayerdata[bPix[6]] +
                     bayerdata[bPix[4]] + bayerdata[bPix[9]]) >>
          2;
      debayerto[rgbPix[0] + 2] = (uint16_t)bayerdata[bPix[5]];
      debayerto[rgbPix[1]] =
          (uint32_t)(bayerdata[bPix[2]] + bayerdata[bPix[10]]) >> 1;
      debayerto[rgbPix[1] + 1] = (uint16_t)bayerdata[bPix[6]];
      debayerto[rgbPix[1] + 2] =
          (uint32_t)(bayerdata[bPix[5]] + bayerdata[bPix[7]]) >> 1;
      debayerto[rgbPix[2]] =
          (uint32_t)(bayerdata[bPix[8]] + bayerdata[bPix[10]]) >> 1;
      debayerto[rgbPix[2] + 1] = (uint16_t)bayerdata[bPix[9]];
      debayerto[rgbPix[2] + 2] =
          (uint32_t)(bayerdata[bPix[5]] + bayerdata[bPix[13]]) >> 1;
      debayerto[rgbPix[3]] = (uint16_t)bayerdata[bPix[10]];
      debayerto[rgbPix[3] + 1] =
          (uint32_t)(bayerdata[bPix[6]] + bayerdata[bPix[9]] +
                     bayerdata[bPix[11]] + bayerdata[bPix[14]]) >>
          2;
      debayerto[rgbPix[3] + 2] =
          (uint32_t)(bayerdata[bPix[5]] + bayerdata[bPix[7]] +
                     bayerdata[bPix[13]] + bayerdata[bPix[15]]) >>
          2;
    }
    uint16_t *edgePixel = debayerto + (3 * Y);
    edgePixel[0] = edgePixel[3];
    edgePixel[1] = edgePixel[4];
    edgePixel[2] = edgePixel[5];
    edgePixel += nextRowRGB;
    edgePixel[0] = edgePixel[3];
    edgePixel[1] = edgePixel[4];
    edgePixel[2] = edgePixel[5];
    edgePixel[-1] = edgePixel[-4];
    edgePixel[-2] = edgePixel[-5];
    edgePixel[-3] = edgePixel[-6];
    edgePixel += nextRowRGB;
    edgePixel[-1] = edgePixel[-4];
    edgePixel[-2] = edgePixel[-5];
    edgePixel[-3] = edgePixel[-6];
  }
  memcpy(debayerto, debayerto + (width * 3), width * 3 * sizeof(uint16_t));
  memcpy(debayerto + (width * (height - 1) * 3),
         debayerto + (width * (height - 2) * 3), width * 3 * sizeof(uint16_t));
}


x86 assembly (clang, -O0):
<debayerBasic>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
mov    -0x18(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    1155 <debayerBasic+0x45>
mov    -0x14(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
imul   %ecx,%eax
mov    %eax,-0x20(%rbp)
jmp    1164 <debayerBasic+0x54>
mov    -0x14(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x2,%ecx
imul   %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x28(%rbp)
imul   $0x3,-0x14(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1657 <debayerBasic+0x547>
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    150c <debayerBasic+0x3fc>
mov    -0x30(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
sub    -0x14(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x38(%rbp),%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x3c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x90(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x8c(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x84(%rbp)
mov    -0x38(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x80(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
mov    -0x38(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x74(%rbp)
mov    -0x40(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x70(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
mov    -0x40(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x64(%rbp)
mov    -0x44(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x60(%rbp)
mov    -0x44(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
mov    -0x44(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x54(%rbp)
imul   $0x3,-0x7c(%rbp),%eax
mov    %eax,-0xa0(%rbp)
imul   $0x3,-0x78(%rbp),%eax
mov    %eax,-0x9c(%rbp)
imul   $0x3,-0x6c(%rbp),%eax
mov    %eax,-0x98(%rbp)
imul   $0x3,-0x68(%rbp),%eax
mov    %eax,-0x94(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x90(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x88(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x70(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x68(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
cvttss2si %xmm0,%edx
sar    $0x2,%edx
mov    -0x8(%rbp),%rax
movslq -0xa0(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x78(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x80(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x6c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
cvttss2si %xmm0,%edx
sar    $0x2,%edx
mov    -0x8(%rbp),%rax
mov    -0xa0(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x7c(%rbp),%rcx
cvttss2si (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
mov    -0xa0(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x88(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x68(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
cvttss2si %xmm0,%edx
sar    $0x1,%edx
mov    -0x8(%rbp),%rax
movslq -0x9c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x78(%rbp),%rcx
cvttss2si (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
mov    -0x9c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x74(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
cvttss2si %xmm0,%edx
sar    $0x1,%edx
mov    -0x8(%rbp),%rax
mov    -0x9c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x70(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x68(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
cvttss2si %xmm0,%edx
sar    $0x1,%edx
mov    -0x8(%rbp),%rax
movslq -0x98(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x6c(%rbp),%rcx
cvttss2si (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
mov    -0x98(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x5c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
cvttss2si %xmm0,%edx
sar    $0x1,%edx
mov    -0x8(%rbp),%rax
mov    -0x98(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x68(%rbp),%rcx
cvttss2si (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x94(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x78(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x6c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x64(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x58(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
cvttss2si %xmm0,%edx
sar    $0x2,%edx
mov    -0x8(%rbp),%rax
mov    -0x94(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x74(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x5c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x54(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
cvttss2si %xmm0,%edx
sar    $0x2,%edx
mov    -0x8(%rbp),%rax
mov    -0x94(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x34(%rbp)
jmp    1196 <debayerBasic+0x86>
mov    -0x8(%rbp),%rax
imul   $0x3,-0x30(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0xa8(%rbp)
mov    -0xa8(%rbp),%rax
mov    0xc(%rax),%ecx
mov    -0xa8(%rbp),%rax
mov    %ecx,(%rax)
mov    -0xa8(%rbp),%rax
mov    0x10(%rax),%ecx
mov    -0xa8(%rbp),%rax
mov    %ecx,0x4(%rax)
mov    -0xa8(%rbp),%rax
mov    0x14(%rax),%ecx
mov    -0xa8(%rbp),%rax
mov    %ecx,0x8(%rax)
mov    -0x2c(%rbp),%ecx
mov    -0xa8(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0xa8(%rbp)
mov    -0xa8(%rbp),%rax
mov    0xc(%rax),%ecx
mov    -0xa8(%rbp),%rax
mov    %ecx,(%rax)
mov    -0xa8(%rbp),%rax
mov    0x10(%rax),%ecx
mov    -0xa8(%rbp),%rax
mov    %ecx,0x4(%rax)
mov    -0xa8(%rbp),%rax
mov    0x14(%rax),%ecx
mov    -0xa8(%rbp),%rax
mov    %ecx,0x8(%rax)
mov    -0xa8(%rbp),%rax
mov    -0x10(%rax),%ecx
mov    -0xa8(%rbp),%rax
mov    %ecx,-0x4(%rax)
mov    -0xa8(%rbp),%rax
mov    -0x14(%rax),%ecx
mov    -0xa8(%rbp),%rax
mov    %ecx,-0x8(%rax)
mov    -0xa8(%rbp),%rax
mov    -0x18(%rax),%ecx
mov    -0xa8(%rbp),%rax
mov    %ecx,-0xc(%rax)
mov    -0x2c(%rbp),%ecx
mov    -0xa8(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0xa8(%rbp)
mov    -0xa8(%rbp),%rax
mov    -0x10(%rax),%ecx
mov    -0xa8(%rbp),%rax
mov    %ecx,-0x4(%rax)
mov    -0xa8(%rbp),%rax
mov    -0x14(%rax),%ecx
mov    -0xa8(%rbp),%rax
mov    %ecx,-0x8(%rax)
mov    -0xa8(%rbp),%rax
mov    -0x18(%rax),%ecx
mov    -0xa8(%rbp),%rax
mov    %ecx,-0xc(%rax)
mov    -0x28(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x30(%rbp)
jmp    1183 <debayerBasic+0x73>
mov    -0x8(%rbp),%rdi
mov    -0x8(%rbp),%rsi
imul   $0x3,-0x14(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rsi
imul   $0x3,-0x14(%rbp),%eax
cltq
shl    $0x2,%rax
mov    %eax,%edx
call   1030 <memcpy@plt>
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
imul   %ecx,%eax
imul   $0x3,%eax,%eax
cltq
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x8(%rbp),%rsi
mov    -0x14(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x2,%ecx
imul   %ecx,%eax
imul   $0x3,%eax,%eax
cltq
shl    $0x2,%rax
add    %rax,%rsi
imul   $0x3,-0x14(%rbp),%eax
cltq
shl    $0x2,%rax
mov    %eax,%edx
call   1030 <memcpy@plt>
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<debayerBasic>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
lea    -0x1(%rcx),%r14d
mov    %ecx,%ebx
add    $0xfffffffe,%ebx
test   $0x1,%cl
mov    %ebx,%ebp
cmove  %r14d,%ebp
mov    %rdi,%r13
imul   %edx,%ebp
lea    (%rdx,%rdx,2),%r15d
cmp    %edx,%ebp
jle    138f <debayerBasic+0x27f>
mov    %r14d,0x8(%rsp)
mov    %ebx,0xc(%rsp)
lea    (%rdx,%rdx,1),%ebx
lea    -0x1(%rdx),%edi
mov    %r15d,0x4(%rsp)
movslq %r15d,%r10
movslq %edx,%r11
movslq %edi,%rdi
movslq %ebx,%rax
movslq %ebp,%rcx
mov    %rcx,0x20(%rsp)
lea    (%rsi,%r11,4),%rbp
lea    0x0(,%r11,4),%rbx
mov    %rax,0x28(%rsp)
lea    0x0(,%rax,4),%rax
lea    (%rbx,%rbx,2),%r8
lea    0x20(%r13,%r8,1),%rbx
mov    %rax,0x18(%rsp)
lea    (%rax,%rax,2),%rax
mov    %rax,0x10(%rsp)
lea    (%rsi,%r11,8),%r12
lea    (%r11,%r11,2),%rcx
lea    0x20(,%rcx,8),%r15
add    %r13,%r15
lea    (%rsi,%r8,1),%r14
add    $0x4,%r14
mov    %rdx,0x30(%rsp)
jmp    1257 <debayerBasic+0x147>
nop
lea    (%r11,%r11,2),%rcx
lea    0x0(,%rcx,4),%rdx
add    %r13,%rdx
mov    0xc(%r13,%rcx,4),%eax
mov    %eax,0x0(%r13,%rcx,4)
mov    0x10(%r13,%rcx,4),%rax
mov    %rax,0x4(%r13,%rcx,4)
movsd  0xc(%rdx,%r10,4),%xmm0
mov    -0x18(%rdx,%r10,4),%eax
mov    0x14(%rdx,%r10,4),%ecx
mov    %ecx,0x8(%rdx,%r10,4)
movsd  -0x14(%rdx,%r10,4),%xmm1
movlhps %xmm0,%xmm1
movups %xmm1,-0x8(%rdx,%r10,4)
mov    %eax,-0xc(%rdx,%r10,4)
lea    (%rdx,%r10,4),%rax
mov    -0x10(%rax,%r10,4),%ecx
mov    %ecx,-0x4(%rax,%r10,4)
mov    -0x18(%rax,%r10,4),%rcx
mov    %rcx,-0xc(%rax,%r10,4)
add    0x28(%rsp),%r11
mov    0x18(%rsp),%rax
add    %rax,%rbp
mov    0x10(%rsp),%rcx
add    %rcx,%rbx
add    %rax,%rsi
add    %rax,%r12
add    %rcx,%r15
add    %rax,%r14
cmp    0x20(%rsp),%r11
mov    0x30(%rsp),%rdx
jge    1394 <debayerBasic+0x284>
cmp    $0x3,%edx
jl     11c0 <debayerBasic+0xb0>
mov    $0x1,%r8d
xor    %r9d,%r9d
nopl   0x0(%rax)
movss  0x4(%rsi,%r8,4),%xmm4
movss  -0x4(%rsi,%r8,4),%xmm1
addss  %xmm4,%xmm1
movss  -0x4(%r12,%r8,4),%xmm3
movss  0x4(%r12,%r8,4),%xmm0
addss  %xmm3,%xmm1
addss  %xmm0,%xmm1
cvttss2si %xmm1,%eax
sar    $0x2,%eax
mov    %eax,-0x14(%rbx,%r9,1)
movss  0x4(%rbp,%r8,4),%xmm1
movss  (%rsi,%r8,4),%xmm5
addss  %xmm1,%xmm5
addss  -0x4(%rbp,%r8,4),%xmm5
movss  (%r12,%r8,4),%xmm2
addss  %xmm2,%xmm5
cvttss2si %xmm5,%eax
sar    $0x2,%eax
movss  0x0(%rbp,%r8,4),%xmm5
cvttss2si %xmm5,%ecx
mov    %eax,-0x10(%rbx,%r9,1)
addss  %xmm0,%xmm4
cvttss2si %xmm4,%eax
mov    %ecx,-0xc(%rbx,%r9,1)
sar    %eax
cvttss2si %xmm1,%ecx
mov    %eax,-0x8(%rbx,%r9,1)
mov    %ecx,-0x4(%rbx,%r9,1)
movss  0x8(%rbp,%r8,4),%xmm4
addss  %xmm5,%xmm4
cvttss2si %xmm4,%eax
sar    %eax
mov    %eax,(%rbx,%r9,1)
addss  %xmm0,%xmm3
cvttss2si %xmm3,%eax
sar    %eax
mov    %eax,-0x14(%r15,%r9,1)
cvttss2si %xmm2,%eax
mov    %eax,-0x10(%r15,%r9,1)
movss  -0x4(%r14,%r8,4),%xmm3
addss  %xmm3,%xmm5
cvttss2si %xmm5,%eax
sar    %eax
mov    %eax,-0xc(%r15,%r9,1)
cvttss2si %xmm0,%eax
mov    %eax,-0x8(%r15,%r9,1)
addss  %xmm2,%xmm1
addss  0x8(%r12,%r8,4),%xmm1
addss  (%r14,%r8,4),%xmm1
cvttss2si %xmm1,%eax
sar    $0x2,%eax
addss  %xmm3,%xmm4
addss  0x4(%r14,%r8,4),%xmm4
mov    %eax,-0x4(%r15,%r9,1)
cvttss2si %xmm4,%eax
sar    $0x2,%eax
mov    %eax,(%r15,%r9,1)
add    $0x2,%r8
add    $0x18,%r9
cmp    %rdi,%r8
jl     1270 <debayerBasic+0x160>
jmp    11c0 <debayerBasic+0xb0>
movslq %r15d,%r10
jmp    13a2 <debayerBasic+0x292>
mov    0xc(%rsp),%ebx
mov    0x8(%rsp),%r14d
mov    0x4(%rsp),%r15d
lea    0x0(,%r10,4),%rsi
add    %r13,%rsi
shl    $0x2,%edx
lea    (%rdx,%rdx,2),%ebp
mov    %r13,%rdi
mov    %ebp,%edx
call   1030 <memcpy@plt>
imul   %r15d,%r14d
movslq %r14d,%rax
lea    0x0(,%rax,4),%rdi
add    %r13,%rdi
imul   %r15d,%ebx
movslq %ebx,%rax
lea    0x0(,%rax,4),%rsi
add    %r13,%rsi
mov    %ebp,%edx
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <memcpy@plt>

LLVM IR (-O0):
define void @debayerBasic(i32* noalias %0, float* noalias %1, i32 %2, i32 %3, i32 %4) {
%6 = alloca i32*
%7 = alloca float*
%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 [16 x i32]
%22 = alloca [4 x i32]
%23 = alloca i32*
store i32* %0, i32** %6
store float* %1, float** %7
store i32 %2, i32* %8
store i32 %3, i32* %9
store i32 %4, i32* %10
%24 = load i32, i32* %10
%25 = load i32, i32* %9
%26 = srem i32 %25, 2
%27 = icmp eq i32 %26, 0
br i1 %27, label %28, label %33
28: ; preds = %5
%29 = load i32, i32* %8
%30 = load i32, i32* %9
%31 = sub nsw i32 %30, 1
%32 = mul nsw i32 %29, %31
store i32 %32, i32* %11
br label %38
33: ; preds = %5
%34 = load i32, i32* %8
%35 = load i32, i32* %9
%36 = sub nsw i32 %35, 2
%37 = mul nsw i32 %34, %36
store i32 %37, i32* %11
br label %38
38: ; preds = %33, %28
%39 = load i32, i32* %8
%40 = sub nsw i32 %39, 1
store i32 %40, i32* %12
%41 = load i32, i32* %8
%42 = mul nsw i32 %41, 2
store i32 %42, i32* %13
%43 = load i32, i32* %8
%44 = mul nsw i32 %43, 3
store i32 %44, i32* %14
%45 = load i32, i32* %8
store i32 %45, i32* %15
br label %46
46: ; preds = %477, %38
%47 = load i32, i32* %15
%48 = load i32, i32* %11
%49 = icmp slt i32 %47, %48
br i1 %49, label %50, label %481
50: ; preds = %46
store i32 1, i32* %16
br label %51
51: ; preds = %400, %50
%52 = load i32, i32* %16
%53 = load i32, i32* %12
%54 = icmp slt i32 %52, %53
br i1 %54, label %55, label %403
55: ; preds = %51
%56 = load i32, i32* %15
%57 = load i32, i32* %16
%58 = add nsw i32 %56, %57
store i32 %58, i32* %17
%59 = load i32, i32* %17
%60 = load i32, i32* %8
%61 = sub nsw i32 %59, %60
store i32 %61, i32* %18
%62 = load i32, i32* %17
%63 = load i32, i32* %8
%64 = add nsw i32 %62, %63
store i32 %64, i32* %19
%65 = load i32, i32* %19
%66 = load i32, i32* %8
%67 = add nsw i32 %65, %66
store i32 %67, i32* %20
%68 = getelementptr inbounds [16 x i32], [16 x i32]* %21, i64 0, i64 0
%69 = load i32, i32* %18
%70 = sub nsw i32 %69, 1
store i32 %70, i32* %68
%71 = getelementptr inbounds i32, i32* %68, i64 1
%72 = load i32, i32* %18
store i32 %72, i32* %71
%73 = getelementptr inbounds i32, i32* %71, i64 1
%74 = load i32, i32* %18
%75 = add nsw i32 %74, 1
store i32 %75, i32* %73
%76 = getelementptr inbounds i32, i32* %73, i64 1
%77 = load i32, i32* %18
%78 = add nsw i32 %77, 2
store i32 %78, i32* %76
%79 = getelementptr inbounds i32, i32* %76, i64 1
%80 = load i32, i32* %17
%81 = sub nsw i32 %80, 1
store i32 %81, i32* %79
%82 = getelementptr inbounds i32, i32* %79, i64 1
%83 = load i32, i32* %17
store i32 %83, i32* %82
%84 = getelementptr inbounds i32, i32* %82, i64 1
%85 = load i32, i32* %17
%86 = add nsw i32 %85, 1
store i32 %86, i32* %84
%87 = getelementptr inbounds i32, i32* %84, i64 1
%88 = load i32, i32* %17
%89 = add nsw i32 %88, 2
store i32 %89, i32* %87
%90 = getelementptr inbounds i32, i32* %87, i64 1
%91 = load i32, i32* %19
%92 = sub nsw i32 %91, 1
store i32 %92, i32* %90
%93 = getelementptr inbounds i32, i32* %90, i64 1
%94 = load i32, i32* %19
store i32 %94, i32* %93
%95 = getelementptr inbounds i32, i32* %93, i64 1
%96 = load i32, i32* %19
%97 = add nsw i32 %96, 1
store i32 %97, i32* %95
%98 = getelementptr inbounds i32, i32* %95, i64 1
%99 = load i32, i32* %19
%100 = add nsw i32 %99, 2
store i32 %100, i32* %98
%101 = getelementptr inbounds i32, i32* %98, i64 1
%102 = load i32, i32* %20
%103 = sub nsw i32 %102, 1
store i32 %103, i32* %101
%104 = getelementptr inbounds i32, i32* %101, i64 1
%105 = load i32, i32* %20
store i32 %105, i32* %104
%106 = getelementptr inbounds i32, i32* %104, i64 1
%107 = load i32, i32* %20
%108 = add nsw i32 %107, 1
store i32 %108, i32* %106
%109 = getelementptr inbounds i32, i32* %106, i64 1
%110 = load i32, i32* %20
%111 = add nsw i32 %110, 2
store i32 %111, i32* %109
%112 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 0
%113 = getelementptr inbounds [16 x i32], [16 x i32]* %21, i64 0, i64 5
%114 = load i32, i32* %113
%115 = mul nsw i32 %114, 3
store i32 %115, i32* %112
%116 = getelementptr inbounds i32, i32* %112, i64 1
%117 = getelementptr inbounds [16 x i32], [16 x i32]* %21, i64 0, i64 6
%118 = load i32, i32* %117
%119 = mul nsw i32 %118, 3
store i32 %119, i32* %116
%120 = getelementptr inbounds i32, i32* %116, i64 1
%121 = getelementptr inbounds [16 x i32], [16 x i32]* %21, i64 0, i64 9
%122 = load i32, i32* %121
%123 = mul nsw i32 %122, 3
store i32 %123, i32* %120
%124 = getelementptr inbounds i32, i32* %120, i64 1
%125 = getelementptr inbounds [16 x i32], [16 x i32]* %21, i64 0, i64 10
%126 = load i32, i32* %125
%127 = mul nsw i32 %126, 3
store i32 %127, i32* %124
%128 = load float*, float** %7
%129 = getelementptr inbounds [16 x i32], [16 x i32]* %21, i64 0, i64 0
%130 = load i32, i32* %129
%131 = sext i32 %130 to i64
%132 = getelementptr inbounds float, float* %128, i64 %131
%133 = load float, float* %132
%134 = load float*, float** %7
%135 = getelementptr inbounds [16 x i32], [16 x i32]* %21, i64 0, i64 2
%136 = load i32, i32* %135
%137 = sext i32 %136 to i64
%138 = getelementptr inbounds float, float* %134, i64 %137
%139 = load float, float* %138
%140 = fadd float %133, %139
%141 = load float*, float** %7
%142 = getelementptr inbounds [16 x i32], [16 x i32]* %21, i64 0, i64 8
%143 = load i32, i32* %142
%144 = sext i32 %143 to i64
%145 = getelementptr inbounds float, float* %141, i64 %144
%146 = load float, float* %145
%147 = fadd float %140, %146
%148 = load float*, float** %7
%149 = getelementptr inbounds [16 x i32], [16 x i32]* %21, i64 0, i64 10
%150 = load i32, i32* %149
%151 = sext i32 %150 to i64
%152 = getelementptr inbounds float, float* %148, i64 %151
%153 = load float, float* %152
%154 = fadd float %147, %153
%155 = fptosi float %154 to i32
%156 = ashr i32 %155, 2
%157 = load i32*, i32** %6
%158 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 0
%159 = load i32, i32* %158
%160 = sext i32 %159 to i64
%161 = getelementptr inbounds i32, i32* %157, i64 %160
store i32 %156, i32* %161
%162 = load float*, float** %7
%163 = getelementptr inbounds [16 x i32], [16 x i32]* %21, i64 0, i64 1
%164 = load i32, i32* %163
%165 = sext i32 %164 to i64
%166 = getelementptr inbounds float, float* %162, i64 %165
%167 = load float, float* %166
%168 = load float*, float** %7
%169 = getelementptr inbounds [16 x i32], [16 x i32]* %21, i64 0, i64 6
%170 = load i32, i32* %169
%171 = sext i32 %170 to i64
%172 = getelementptr inbounds float, float* %168, i64 %171
%173 = load float, float* %172
%174 = fadd float %167, %173
%175 = load float*, float** %7
%176 = getelementptr inbounds [16 x i32], [16 x i32]* %21, i64 0, i64 4
%177 = load i32, i32* %176
%178 = sext i32 %177 to i64
%179 = getelementptr inbounds float, float* %175, i64 %178
%180 = load float, float* %179
%181 = fadd float %174, %180
%182 = load float*, float** %7
%183 = getelementptr inbounds [16 x i32], [16 x i32]* %21, i64 0, i64 9
%184 = load i32, i32* %183
%185 = sext i32 %184 to i64
%186 = getelementptr inbounds float, float* %182, i64 %185
%187 = load float, float* %186
%188 = fadd float %181, %187
%189 = fptosi float %188 to i32
%190 = ashr i32 %189, 2
%191 = load i32*, i32** %6
%192 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 0
%193 = load i32, i32* %192
%194 = add nsw i32 %193, 1
%195 = sext i32 %194 to i64
%196 = getelementptr inbounds i32, i32* %191, i64 %195
store i32 %190, i32* %196
%197 = load float*, float** %7
%198 = getelementptr inbounds [16 x i32], [16 x i32]* %21, i64 0, i64 5
%199 = load i32, i32* %198
%200 = sext i32 %199 to i64
%201 = getelementptr inbounds float, float* %197, i64 %200
%202 = load float, float* %201
%203 = fptosi float %202 to i32
%204 = load i32*, i32** %6
%205 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 0
%206 = load i32, i32* %205
%207 = add nsw i32 %206, 2
%208 = sext i32 %207 to i64
%209 = getelementptr inbounds i32, i32* %204, i64 %208
store i32 %203, i32* %209
%210 = load float*, float** %7
%211 = getelementptr inbounds [16 x i32], [16 x i32]* %21, i64 0, i64 2
%212 = load i32, i32* %211
%213 = sext i32 %212 to i64
%214 = getelementptr inbounds float, float* %210, i64 %213
%215 = load float, float* %214
%216 = load float*, float** %7
%217 = getelementptr inbounds [16 x i32], [16 x i32]* %21, i64 0, i64 10
%218 = load i32, i32* %217
%219 = sext i32 %218 to i64
%220 = getelementptr inbounds float, float* %216, i64 %219
%221 = load float, float* %220
%222 = fadd float %215, %221
%223 = fptosi float %222 to i32
%224 = ashr i32 %223, 1
%225 = load i32*, i32** %6
%226 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 1
%227 = load i32, i32* %226
%228 = sext i32 %227 to i64
%229 = getelementptr inbounds i32, i32* %225, i64 %228
store i32 %224, i32* %229
%230 = load float*, float** %7
%231 = getelementptr inbounds [16 x i32], [16 x i32]* %21, i64 0, i64 6
%232 = load i32, i32* %231
%233 = sext i32 %232 to i64
%234 = getelementptr inbounds float, float* %230, i64 %233
%235 = load float, float* %234
%236 = fptosi float %235 to i32
%237 = load i32*, i32** %6
%238 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 1
%239 = load i32, i32* %238
%240 = add nsw i32 %239, 1
%241 = sext i32 %240 to i64
%242 = getelementptr inbounds i32, i32* %237, i64 %241
store i32 %236, i32* %242
%243 = load float*, float** %7
%244 = getelementptr inbounds [16 x i32], [16 x i32]* %21, i64 0, i64 5
%245 = load i32, i32* %244
%246 = sext i32 %245 to i64
%247 = getelementptr inbounds float, float* %243, i64 %246
%248 = load float, float* %247
%249 = load float*, float** %7
%250 = getelementptr inbounds [16 x i32], [16 x i32]* %21, i64 0, i64 7
%251 = load i32, i32* %250
%252 = sext i32 %251 to i64
%253 = getelementptr inbounds float, float* %249, i64 %252
%254 = load float, float* %253
%255 = fadd float %248, %254
%256 = fptosi float %255 to i32
%257 = ashr i32 %256, 1
%258 = load i32*, i32** %6
%259 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 1
%260 = load i32, i32* %259
%261 = add nsw i32 %260, 2
%262 = sext i32 %261 to i64
%263 = getelementptr inbounds i32, i32* %258, i64 %262
store i32 %257, i32* %263
%264 = load float*, float** %7
%265 = getelementptr inbounds [16 x i32], [16 x i32]* %21, i64 0, i64 8
%266 = load i32, i32* %265
%267 = sext i32 %266 to i64
%268 = getelementptr inbounds float, float* %264, i64 %267
%269 = load float, float* %268
%270 = load float*, float** %7
%271 = getelementptr inbounds [16 x i32], [16 x i32]* %21, i64 0, i64 10
%272 = load i32, i32* %271
%273 = sext i32 %272 to i64
%274 = getelementptr inbounds float, float* %270, i64 %273
%275 = load float, float* %274
%276 = fadd float %269, %275
%277 = fptosi float %276 to i32
%278 = ashr i32 %277, 1
%279 = load i32*, i32** %6
%280 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 2
%281 = load i32, i32* %280
%282 = sext i32 %281 to i64
%283 = getelementptr inbounds i32, i32* %279, i64 %282
store i32 %278, i32* %283
%284 = load float*, float** %7
%285 = getelementptr inbounds [16 x i32], [16 x i32]* %21, i64 0, i64 9
%286 = load i32, i32* %285
%287 = sext i32 %286 to i64
%288 = getelementptr inbounds float, float* %284, i64 %287
%289 = load float, float* %288
%290 = fptosi float %289 to i32
%291 = load i32*, i32** %6
%292 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 2
%293 = load i32, i32* %292
%294 = add nsw i32 %293, 1
%295 = sext i32 %294 to i64
%296 = getelementptr inbounds i32, i32* %291, i64 %295
store i32 %290, i32* %296
%297 = load float*, float** %7
%298 = getelementptr inbounds [16 x i32], [16 x i32]* %21, i64 0, i64 5
%299 = load i32, i32* %298
%300 = sext i32 %299 to i64
%301 = getelementptr inbounds float, float* %297, i64 %300
%302 = load float, float* %301
%303 = load float*, float** %7
%304 = getelementptr inbounds [16 x i32], [16 x i32]* %21, i64 0, i64 13
%305 = load i32, i32* %304
%306 = sext i32 %305 to i64
%307 = getelementptr inbounds float, float* %303, i64 %306
%308 = load float, float* %307
%309 = fadd float %302, %308
%310 = fptosi float %309 to i32
%311 = ashr i32 %310, 1
%312 = load i32*, i32** %6
%313 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 2
%314 = load i32, i32* %313
%315 = add nsw i32 %314, 2
%316 = sext i32 %315 to i64
%317 = getelementptr inbounds i32, i32* %312, i64 %316
store i32 %311, i32* %317
%318 = load float*, float** %7
%319 = getelementptr inbounds [16 x i32], [16 x i32]* %21, i64 0, i64 10
%320 = load i32, i32* %319
%321 = sext i32 %320 to i64
%322 = getelementptr inbounds float, float* %318, i64 %321
%323 = load float, float* %322
%324 = fptosi float %323 to i32
%325 = load i32*, i32** %6
%326 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 3
%327 = load i32, i32* %326
%328 = sext i32 %327 to i64
%329 = getelementptr inbounds i32, i32* %325, i64 %328
store i32 %324, i32* %329
%330 = load float*, float** %7
%331 = getelementptr inbounds [16 x i32], [16 x i32]* %21, i64 0, i64 6
%332 = load i32, i32* %331
%333 = sext i32 %332 to i64
%334 = getelementptr inbounds float, float* %330, i64 %333
%335 = load float, float* %334
%336 = load float*, float** %7
%337 = getelementptr inbounds [16 x i32], [16 x i32]* %21, i64 0, i64 9
%338 = load i32, i32* %337
%339 = sext i32 %338 to i64
%340 = getelementptr inbounds float, float* %336, i64 %339
%341 = load float, float* %340
%342 = fadd float %335, %341
%343 = load float*, float** %7
%344 = getelementptr inbounds [16 x i32], [16 x i32]* %21, i64 0, i64 11
%345 = load i32, i32* %344
%346 = sext i32 %345 to i64
%347 = getelementptr inbounds float, float* %343, i64 %346
%348 = load float, float* %347
%349 = fadd float %342, %348
%350 = load float*, float** %7
%351 = getelementptr inbounds [16 x i32], [16 x i32]* %21, i64 0, i64 14
%352 = load i32, i32* %351
%353 = sext i32 %352 to i64
%354 = getelementptr inbounds float, float* %350, i64 %353
%355 = load float, float* %354
%356 = fadd float %349, %355
%357 = fptosi float %356 to i32
%358 = ashr i32 %357, 2
%359 = load i32*, i32** %6
%360 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 3
%361 = load i32, i32* %360
%362 = add nsw i32 %361, 1
%363 = sext i32 %362 to i64
%364 = getelementptr inbounds i32, i32* %359, i64 %363
store i32 %358, i32* %364
%365 = load float*, float** %7
%366 = getelementptr inbounds [16 x i32], [16 x i32]* %21, i64 0, i64 5
%367 = load i32, i32* %366
%368 = sext i32 %367 to i64
%369 = getelementptr inbounds float, float* %365, i64 %368
%370 = load float, float* %369
%371 = load float*, float** %7
%372 = getelementptr inbounds [16 x i32], [16 x i32]* %21, i64 0, i64 7
%373 = load i32, i32* %372
%374 = sext i32 %373 to i64
%375 = getelementptr inbounds float, float* %371, i64 %374
%376 = load float, float* %375
%377 = fadd float %370, %376
%378 = load float*, float** %7
%379 = getelementptr inbounds [16 x i32], [16 x i32]* %21, i64 0, i64 13
%380 = load i32, i32* %379
%381 = sext i32 %380 to i64
%382 = getelementptr inbounds float, float* %378, i64 %381
%383 = load float, float* %382
%384 = fadd float %377, %383
%385 = load float*, float** %7
%386 = getelementptr inbounds [16 x i32], [16 x i32]* %21, i64 0, i64 15
%387 = load i32, i32* %386
%388 = sext i32 %387 to i64
%389 = getelementptr inbounds float, float* %385, i64 %388
%390 = load float, float* %389
%391 = fadd float %384, %390
%392 = fptosi float %391 to i32
%393 = ashr i32 %392, 2
%394 = load i32*, i32** %6
%395 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 3
%396 = load i32, i32* %395
%397 = add nsw i32 %396, 2
%398 = sext i32 %397 to i64
%399 = getelementptr inbounds i32, i32* %394, i64 %398
store i32 %393, i32* %399
br label %400
400: ; preds = %55
%401 = load i32, i32* %16
%402 = add nsw i32 %401, 2
store i32 %402, i32* %16
br label %51
403: ; preds = %51
%404 = load i32*, i32** %6
%405 = load i32, i32* %15
%406 = mul nsw i32 3, %405
%407 = sext i32 %406 to i64
%408 = getelementptr inbounds i32, i32* %404, i64 %407
store i32* %408, i32** %23
%409 = load i32*, i32** %23
%410 = getelementptr inbounds i32, i32* %409, i64 3
%411 = load i32, i32* %410
%412 = load i32*, i32** %23
%413 = getelementptr inbounds i32, i32* %412, i64 0
store i32 %411, i32* %413
%414 = load i32*, i32** %23
%415 = getelementptr inbounds i32, i32* %414, i64 4
%416 = load i32, i32* %415
%417 = load i32*, i32** %23
%418 = getelementptr inbounds i32, i32* %417, i64 1
store i32 %416, i32* %418
%419 = load i32*, i32** %23
%420 = getelementptr inbounds i32, i32* %419, i64 5
%421 = load i32, i32* %420
%422 = load i32*, i32** %23
%423 = getelementptr inbounds i32, i32* %422, i64 2
store i32 %421, i32* %423
%424 = load i32, i32* %14
%425 = load i32*, i32** %23
%426 = sext i32 %424 to i64
%427 = getelementptr inbounds i32, i32* %425, i64 %426
store i32* %427, i32** %23
%428 = load i32*, i32** %23
%429 = getelementptr inbounds i32, i32* %428, i64 3
%430 = load i32, i32* %429
%431 = load i32*, i32** %23
%432 = getelementptr inbounds i32, i32* %431, i64 0
store i32 %430, i32* %432
%433 = load i32*, i32** %23
%434 = getelementptr inbounds i32, i32* %433, i64 4
%435 = load i32, i32* %434
%436 = load i32*, i32** %23
%437 = getelementptr inbounds i32, i32* %436, i64 1
store i32 %435, i32* %437
%438 = load i32*, i32** %23
%439 = getelementptr inbounds i32, i32* %438, i64 5
%440 = load i32, i32* %439
%441 = load i32*, i32** %23
%442 = getelementptr inbounds i32, i32* %441, i64 2
store i32 %440, i32* %442
%443 = load i32*, i32** %23
%444 = getelementptr inbounds i32, i32* %443, i64 -4
%445 = load i32, i32* %444
%446 = load i32*, i32** %23
%447 = getelementptr inbounds i32, i32* %446, i64 -1
store i32 %445, i32* %447
%448 = load i32*, i32** %23
%449 = getelementptr inbounds i32, i32* %448, i64 -5
%450 = load i32, i32* %449
%451 = load i32*, i32** %23
%452 = getelementptr inbounds i32, i32* %451, i64 -2
store i32 %450, i32* %452
%453 = load i32*, i32** %23
%454 = getelementptr inbounds i32, i32* %453, i64 -6
%455 = load i32, i32* %454
%456 = load i32*, i32** %23
%457 = getelementptr inbounds i32, i32* %456, i64 -3
store i32 %455, i32* %457
%458 = load i32, i32* %14
%459 = load i32*, i32** %23
%460 = sext i32 %458 to i64
%461 = getelementptr inbounds i32, i32* %459, i64 %460
store i32* %461, i32** %23
%462 = load i32*, i32** %23
%463 = getelementptr inbounds i32, i32* %462, i64 -4
%464 = load i32, i32* %463
%465 = load i32*, i32** %23
%466 = getelementptr inbounds i32, i32* %465, i64 -1
store i32 %464, i32* %466
%467 = load i32*, i32** %23
%468 = getelementptr inbounds i32, i32* %467, i64 -5
%469 = load i32, i32* %468
%470 = load i32*, i32** %23
%471 = getelementptr inbounds i32, i32* %470, i64 -2
store i32 %469, i32* %471
%472 = load i32*, i32** %23
%473 = getelementptr inbounds i32, i32* %472, i64 -6
%474 = load i32, i32* %473
%475 = load i32*, i32** %23
%476 = getelementptr inbounds i32, i32* %475, i64 -3
store i32 %474, i32* %476
br label %477
477: ; preds = %403
%478 = load i32, i32* %13
%479 = load i32, i32* %15
%480 = add nsw i32 %479, %478
store i32 %480, i32* %15
br label %46
481: ; preds = %46
%482 = load i32*, i32** %6
%483 = load i32*, i32** %6
%484 = load i32, i32* %8
%485 = mul nsw i32 %484, 3
%486 = sext i32 %485 to i64
%487 = getelementptr inbounds i32, i32* %483, i64 %486
%488 = load i32, i32* %8
%489 = mul nsw i32 %488, 3
%490 = sext i32 %489 to i64
%491 = mul i64 %490, 4
%492 = trunc i64 %491 to i32
%493 = call i32 @memcpy(i32* %482, i32* %487, i32 %492)
%494 = load i32*, i32** %6
%495 = load i32, i32* %8
%496 = load i32, i32* %9
%497 = sub nsw i32 %496, 1
%498 = mul nsw i32 %495, %497
%499 = mul nsw i32 %498, 3
%500 = sext i32 %499 to i64
%501 = getelementptr inbounds i32, i32* %494, i64 %500
%502 = load i32*, i32** %6
%503 = load i32, i32* %8
%504 = load i32, i32* %9
%505 = sub nsw i32 %504, 2
%506 = mul nsw i32 %503, %505
%507 = mul nsw i32 %506, 3
%508 = sext i32 %507 to i64
%509 = getelementptr inbounds i32, i32* %502, i64 %508
%510 = load i32, i32* %8
%511 = mul nsw i32 %510, 3
%512 = sext i32 %511 to i64
%513 = mul i64 %512, 4
%514 = trunc i64 %513 to i32
%515 = call i32 @memcpy(i32* %501, i32* %509, i32 %514)
ret void
}

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