#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 */

/* Variables and functions */
int /*<<< orphan*/ v4lconvert_border_bayer_line_to_bgr24(unsigned char const *,
                                                         unsigned char const *,
                                                         unsigned char *, int,
                                                         int, int);
void bayer_to_rgbbgr24(const unsigned char *bayer, unsigned char *bgr,
                       int width, int height, unsigned int pixfmt,
                       int start_with_green, int blue_line) {
  v4lconvert_border_bayer_line_to_bgr24(bayer, bayer + width, bgr, width,
                                        start_with_green, blue_line);
  bgr += width * 3;
  for (height -= 2; height; height--) {
    int t0, t1;
    const unsigned char *bayerEnd = bayer + (width - 2);
    if (start_with_green) {
      t0 = (bayer[1] + bayer[width * 2 + 1] + 1) >> 1;
      t1 = (bayer[0] + bayer[width * 2] + bayer[width + 1] + 1) / 3;
      if (blue_line) {
        *bgr++ = t0;
        *bgr++ = t1;
        *bgr++ = bayer[width];
      } else {
        *bgr++ = bayer[width];
        *bgr++ = t1;
        *bgr++ = t0;
      }
      t1 = (bayer[width] + bayer[width + 2] + 1) >> 1;
      if (blue_line) {
        *bgr++ = t0;
        *bgr++ = bayer[width + 1];
        *bgr++ = t1;
      } else {
        *bgr++ = t1;
        *bgr++ = bayer[width + 1];
        *bgr++ = t0;
      }
      bayer++;
    } else {
      t0 = (bayer[0] + bayer[width * 2] + 1) >> 1;
      if (blue_line) {
        *bgr++ = t0;
        *bgr++ = bayer[width];
        *bgr++ = bayer[width + 1];
      } else {
        *bgr++ = bayer[width + 1];
        *bgr++ = bayer[width];
        *bgr++ = t0;
      }
    }
    if (blue_line) {
      for (; bayer <= bayerEnd - 2; bayer += 2) {
        t0 = (bayer[0] + bayer[2] + bayer[width * 2] + bayer[width * 2 + 2] +
              2) >>
             2;
        t1 = (bayer[1] + bayer[width] + bayer[width + 2] +
              bayer[width * 2 + 1] + 2) >>
             2;
        *bgr++ = t0;
        *bgr++ = t1;
        *bgr++ = bayer[width + 1];
        t0 = (bayer[2] + bayer[width * 2 + 2] + 1) >> 1;
        t1 = (bayer[width + 1] + bayer[width + 3] + 1) >> 1;
        *bgr++ = t0;
        *bgr++ = bayer[width + 2];
        *bgr++ = t1;
      }
    } else {
      for (; bayer <= bayerEnd - 2; bayer += 2) {
        t0 = (bayer[0] + bayer[2] + bayer[width * 2] + bayer[width * 2 + 2] +
              2) >>
             2;
        t1 = (bayer[1] + bayer[width] + bayer[width + 2] +
              bayer[width * 2 + 1] + 2) >>
             2;
        *bgr++ = bayer[width + 1];
        *bgr++ = t1;
        *bgr++ = t0;
        t0 = (bayer[2] + bayer[width * 2 + 2] + 1) >> 1;
        t1 = (bayer[width + 1] + bayer[width + 3] + 1) >> 1;
        *bgr++ = t1;
        *bgr++ = bayer[width + 2];
        *bgr++ = t0;
      }
    }
    if (bayer < bayerEnd) {
      t0 =
          (bayer[0] + bayer[2] + bayer[width * 2] + bayer[width * 2 + 2] + 2) >>
          2;
      t1 = (bayer[1] + bayer[width] + bayer[width + 2] + bayer[width * 2 + 1] +
            2) >>
           2;
      if (blue_line) {
        *bgr++ = t0;
        *bgr++ = t1;
        *bgr++ = bayer[width + 1];
      } else {
        *bgr++ = bayer[width + 1];
        *bgr++ = t1;
        *bgr++ = t0;
      }
      t0 = (bayer[2] + bayer[width * 2 + 2] + 1) >> 1;
      if (blue_line) {
        *bgr++ = t0;
        *bgr++ = bayer[width + 2];
        *bgr++ = bayer[width + 1];
      } else {
        *bgr++ = bayer[width + 1];
        *bgr++ = bayer[width + 2];
        *bgr++ = t0;
      }
      bayer++;
    } else {
      t0 = (bayer[0] + bayer[width * 2] + 1) >> 1;
      t1 = (bayer[1] + bayer[width * 2 + 1] + bayer[width] + 1) / 3;
      if (blue_line) {
        *bgr++ = t0;
        *bgr++ = t1;
        *bgr++ = bayer[width + 1];
      } else {
        *bgr++ = bayer[width + 1];
        *bgr++ = t1;
        *bgr++ = t0;
      }
    }
    bayer += 2;
    blue_line = !blue_line;
    start_with_green = !start_with_green;
  }
  v4lconvert_border_bayer_line_to_bgr24(bayer + width, bayer, bgr, width,
                                        !start_with_green, !blue_line);
}


x86 assembly (clang, -O0):
<bayer_to_rgbbgr24>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
mov    %r9d,-0x20(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x8(%rbp),%rsi
movslq -0x14(%rbp),%rax
add    %rax,%rsi
mov    -0x10(%rbp),%rdx
mov    -0x14(%rbp),%ecx
mov    -0x20(%rbp),%r8d
mov    0x10(%rbp),%r9d
call   1030 <v4lconvert_border_bayer_line_to_bgr24@plt>
imul   $0x3,-0x14(%rbp),%ecx
mov    -0x10(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x10(%rbp)
mov    -0x18(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x18(%rbp)
cmpl   $0x0,-0x18(%rbp)
je     1b33 <bayer_to_rgbbgr24+0xa23>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
cmpl   $0x0,-0x20(%rbp)
je     137a <bayer_to_rgbbgr24+0x26a>
mov    -0x8(%rbp),%rax
movzbl 0x1(%rax),%eax
mov    -0x8(%rbp),%rcx
mov    -0x14(%rbp),%edx
shl    $0x1,%edx
add    $0x1,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
add    $0x1,%eax
sar    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x8(%rbp),%rax
movzbl (%rax),%eax
mov    -0x8(%rbp),%rcx
mov    -0x14(%rbp),%edx
shl    $0x1,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
mov    -0x8(%rbp),%rcx
mov    -0x14(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
add    $0x1,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,-0x28(%rbp)
cmpl   $0x0,0x10(%rbp)
je     1250 <bayer_to_rgbbgr24+0x140>
mov    -0x24(%rbp),%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x28(%rbp),%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
jmp    1298 <bayer_to_rgbbgr24+0x188>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x28(%rbp),%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x24(%rbp),%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x8(%rbp),%rcx
mov    -0x14(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
add    $0x1,%eax
sar    $0x1,%eax
mov    %eax,-0x28(%rbp)
cmpl   $0x0,0x10(%rbp)
je     131c <bayer_to_rgbbgr24+0x20c>
mov    -0x24(%rbp),%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x28(%rbp),%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
jmp    1369 <bayer_to_rgbbgr24+0x259>
mov    -0x28(%rbp),%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x24(%rbp),%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
jmp    1457 <bayer_to_rgbbgr24+0x347>
mov    -0x8(%rbp),%rax
movzbl (%rax),%eax
mov    -0x8(%rbp),%rcx
mov    -0x14(%rbp),%edx
shl    $0x1,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
add    $0x1,%eax
sar    $0x1,%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x0,0x10(%rbp)
je     13ff <bayer_to_rgbbgr24+0x2ef>
mov    -0x24(%rbp),%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
jmp    1452 <bayer_to_rgbbgr24+0x342>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x24(%rbp),%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
jmp    1457 <bayer_to_rgbbgr24+0x347>
cmpl   $0x0,0x10(%rbp)
je     160a <bayer_to_rgbbgr24+0x4fa>
jmp    1466 <bayer_to_rgbbgr24+0x356>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%rcx
add    $0xfffffffffffffffe,%rcx
cmp    %rcx,%rax
ja     1605 <bayer_to_rgbbgr24+0x4f5>
mov    -0x8(%rbp),%rax
movzbl (%rax),%eax
mov    -0x8(%rbp),%rcx
movzbl 0x2(%rcx),%ecx
add    %ecx,%eax
mov    -0x8(%rbp),%rcx
mov    -0x14(%rbp),%edx
shl    $0x1,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
mov    -0x8(%rbp),%rcx
mov    -0x14(%rbp),%edx
shl    $0x1,%edx
add    $0x2,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
add    $0x2,%eax
sar    $0x2,%eax
mov    %eax,-0x24(%rbp)
mov    -0x8(%rbp),%rax
movzbl 0x1(%rax),%eax
mov    -0x8(%rbp),%rcx
movslq -0x14(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
mov    -0x8(%rbp),%rcx
mov    -0x14(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
mov    -0x8(%rbp),%rcx
mov    -0x14(%rbp),%edx
shl    $0x1,%edx
add    $0x1,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
add    $0x2,%eax
sar    $0x2,%eax
mov    %eax,-0x28(%rbp)
mov    -0x24(%rbp),%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x28(%rbp),%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x8(%rbp),%rax
movzbl 0x2(%rax),%eax
mov    -0x8(%rbp),%rcx
mov    -0x14(%rbp),%edx
shl    $0x1,%edx
add    $0x2,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
add    $0x1,%eax
sar    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x8(%rbp),%rcx
mov    -0x14(%rbp),%edx
add    $0x3,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
add    $0x1,%eax
sar    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x24(%rbp),%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x28(%rbp),%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x8(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x8(%rbp)
jmp    1466 <bayer_to_rgbbgr24+0x356>
jmp    17b3 <bayer_to_rgbbgr24+0x6a3>
jmp    160f <bayer_to_rgbbgr24+0x4ff>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%rcx
add    $0xfffffffffffffffe,%rcx
cmp    %rcx,%rax
ja     17ae <bayer_to_rgbbgr24+0x69e>
mov    -0x8(%rbp),%rax
movzbl (%rax),%eax
mov    -0x8(%rbp),%rcx
movzbl 0x2(%rcx),%ecx
add    %ecx,%eax
mov    -0x8(%rbp),%rcx
mov    -0x14(%rbp),%edx
shl    $0x1,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
mov    -0x8(%rbp),%rcx
mov    -0x14(%rbp),%edx
shl    $0x1,%edx
add    $0x2,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
add    $0x2,%eax
sar    $0x2,%eax
mov    %eax,-0x24(%rbp)
mov    -0x8(%rbp),%rax
movzbl 0x1(%rax),%eax
mov    -0x8(%rbp),%rcx
movslq -0x14(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
mov    -0x8(%rbp),%rcx
mov    -0x14(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
mov    -0x8(%rbp),%rcx
mov    -0x14(%rbp),%edx
shl    $0x1,%edx
add    $0x1,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
add    $0x2,%eax
sar    $0x2,%eax
mov    %eax,-0x28(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x28(%rbp),%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x24(%rbp),%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x8(%rbp),%rax
movzbl 0x2(%rax),%eax
mov    -0x8(%rbp),%rcx
mov    -0x14(%rbp),%edx
shl    $0x1,%edx
add    $0x2,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
add    $0x1,%eax
sar    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x8(%rbp),%rcx
mov    -0x14(%rbp),%edx
add    $0x3,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
add    $0x1,%eax
sar    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x24(%rbp),%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x8(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x8(%rbp)
jmp    160f <bayer_to_rgbbgr24+0x4ff>
jmp    17b3 <bayer_to_rgbbgr24+0x6a3>
mov    -0x8(%rbp),%rax
cmp    -0x30(%rbp),%rax
jae    19ec <bayer_to_rgbbgr24+0x8dc>
mov    -0x8(%rbp),%rax
movzbl (%rax),%eax
mov    -0x8(%rbp),%rcx
movzbl 0x2(%rcx),%ecx
add    %ecx,%eax
mov    -0x8(%rbp),%rcx
mov    -0x14(%rbp),%edx
shl    $0x1,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
mov    -0x8(%rbp),%rcx
mov    -0x14(%rbp),%edx
shl    $0x1,%edx
add    $0x2,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
add    $0x2,%eax
sar    $0x2,%eax
mov    %eax,-0x24(%rbp)
mov    -0x8(%rbp),%rax
movzbl 0x1(%rax),%eax
mov    -0x8(%rbp),%rcx
movslq -0x14(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
mov    -0x8(%rbp),%rcx
mov    -0x14(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
mov    -0x8(%rbp),%rcx
mov    -0x14(%rbp),%edx
shl    $0x1,%edx
add    $0x1,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
add    $0x2,%eax
sar    $0x2,%eax
mov    %eax,-0x28(%rbp)
cmpl   $0x0,0x10(%rbp)
je     18a8 <bayer_to_rgbbgr24+0x798>
mov    -0x24(%rbp),%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x28(%rbp),%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
jmp    18f5 <bayer_to_rgbbgr24+0x7e5>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x28(%rbp),%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x24(%rbp),%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x8(%rbp),%rax
movzbl 0x2(%rax),%eax
mov    -0x8(%rbp),%rcx
mov    -0x14(%rbp),%edx
shl    $0x1,%edx
add    $0x2,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
add    $0x1,%eax
sar    $0x1,%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x0,0x10(%rbp)
je     1983 <bayer_to_rgbbgr24+0x873>
mov    -0x24(%rbp),%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
jmp    19db <bayer_to_rgbbgr24+0x8cb>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x24(%rbp),%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
jmp    1af7 <bayer_to_rgbbgr24+0x9e7>
mov    -0x8(%rbp),%rax
movzbl (%rax),%eax
mov    -0x8(%rbp),%rcx
mov    -0x14(%rbp),%edx
shl    $0x1,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
add    $0x1,%eax
sar    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x8(%rbp),%rax
movzbl 0x1(%rax),%eax
mov    -0x8(%rbp),%rcx
mov    -0x14(%rbp),%edx
shl    $0x1,%edx
add    $0x1,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
mov    -0x8(%rbp),%rcx
movslq -0x14(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
add    $0x1,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,-0x28(%rbp)
cmpl   $0x0,0x10(%rbp)
je     1aa5 <bayer_to_rgbbgr24+0x995>
mov    -0x24(%rbp),%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x28(%rbp),%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
jmp    1af2 <bayer_to_rgbbgr24+0x9e2>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x28(%rbp),%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x24(%rbp),%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
jmp    1af7 <bayer_to_rgbbgr24+0x9e7>
mov    -0x8(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x8(%rbp)
cmpl   $0x0,0x10(%rbp)
setne  %al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,0x10(%rbp)
cmpl   $0x0,-0x20(%rbp)
setne  %al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x20(%rbp)
mov    -0x18(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
jmp    116f <bayer_to_rgbbgr24+0x5f>
mov    -0x8(%rbp),%rdi
movslq -0x14(%rbp),%rax
add    %rax,%rdi
mov    -0x8(%rbp),%rsi
mov    -0x10(%rbp),%rdx
mov    -0x14(%rbp),%ecx
cmpl   $0x0,-0x20(%rbp)
setne  %al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%r8d
cmpl   $0x0,0x10(%rbp)
setne  %al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%r9d
call   1030 <v4lconvert_border_bayer_line_to_bgr24@plt>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<bayer_to_rgbbgr24>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %r9d,%ebx
mov    %ecx,%r15d
mov    %rsi,%rbp
mov    %rdi,%r13
mov    0x40(%rsp),%r12d
movslq %edx,%r14
lea    (%rdi,%r14,1),%rsi
mov    %rbp,%rdx
mov    %r14d,%ecx
mov    %r9d,%r8d
mov    %r12d,%r9d
call   1030 <v4lconvert_border_bayer_line_to_bgr24@plt>
lea    (%r14,%r14,2),%eax
movslq %eax,%rdx
add    %rbp,%rdx
add    $0xfffffffe,%r15d
je     155b <bayer_to_rgbbgr24+0x44b>
lea    -0x2(%r14),%eax
cltq
mov    %rax,(%rsp)
lea    (%r14,%r14,1),%r8
movslq %r8d,%r11
or     $0x1,%r11
jmp    11ca <bayer_to_rgbbgr24+0xba>
nop
mov    0x1(%r13,%r14,1),%al
mov    %al,(%rdx)
mov    %bpl,0x1(%rdx)
mov    %dil,0x2(%rdx)
movzbl 0x2(%r13),%eax
movzbl 0x2(%r13,%r8,1),%ecx
lea    (%rax,%rcx,1),%edi
add    $0x1,%edi
shr    %edi
mov    0x1(%r13,%r14,1),%al
mov    %al,0x3(%rdx)
mov    0x2(%r13,%r14,1),%al
mov    %al,0x4(%rdx)
add    $0x1,%r13
mov    %dil,0x5(%rdx)
add    $0x6,%rdx
xor    %ebp,%ebp
test   %ebx,%ebx
sete   %bpl
add    $0x2,%r13
movzbl %r10b,%r12d
mov    %ebp,%ebx
add    $0xffffffff,%r15d
je     155d <bayer_to_rgbbgr24+0x44d>
mov    (%rsp),%rax
lea    (%rax,%r13,1),%r9
test   %ebx,%ebx
je     1260 <bayer_to_rgbbgr24+0x150>
lea    0x1(%r13),%rbp
movzbl 0x1(%r13),%eax
movzbl 0x0(%r13,%r11,1),%edi
lea    (%rax,%rdi,1),%r10d
add    $0x1,%r10d
shr    %r10d
movzbl 0x0(%r13),%edi
movzbl 0x0(%r13,%r8,1),%eax
add    %edi,%eax
movzbl 0x1(%r13,%r14,1),%edi
add    %edi,%eax
add    $0x1,%eax
imul   $0xaaab,%eax,%edi
shr    $0x11,%edi
test   %r12d,%r12d
je     1350 <bayer_to_rgbbgr24+0x240>
mov    %r10b,(%rdx)
mov    %dil,0x1(%rdx)
mov    0x0(%r13,%r14,1),%al
mov    %al,0x2(%rdx)
movzbl 0x0(%r13,%r14,1),%eax
movzbl 0x2(%r13,%r14,1),%edi
add    %eax,%edi
add    $0x1,%edi
shr    %edi
mov    %r10b,0x3(%rdx)
mov    0x1(%r13,%r14,1),%al
mov    %al,0x4(%rdx)
mov    %dil,0x5(%rdx)
add    $0x6,%rdx
mov    %rbp,%r13
lea    -0x2(%r9),%rax
jmp    1332 <bayer_to_rgbbgr24+0x222>
movzbl 0x0(%r13),%eax
movzbl 0x0(%r13,%r8,1),%edi
add    %eax,%edi
add    $0x1,%edi
shr    %edi
test   %r12d,%r12d
je     138a <bayer_to_rgbbgr24+0x27a>
mov    %dil,(%rdx)
mov    0x0(%r13,%r14,1),%al
mov    %al,0x1(%rdx)
mov    0x1(%r13,%r14,1),%al
mov    %al,0x2(%rdx)
add    $0x3,%rdx
lea    -0x2(%r9),%rax
jmp    1332 <bayer_to_rgbbgr24+0x222>
nopl   0x0(%rax,%rax,1)
movzbl 0x0(%r13),%edi
movzbl 0x2(%r13),%ebp
add    %edi,%ebp
movzbl -0x1(%r13,%r11,1),%edi
add    %ebp,%edi
movzbl 0x2(%r13,%r8,1),%ebp
add    %ebp,%edi
add    $0x2,%edi
shr    $0x2,%edi
movzbl 0x1(%r13),%ebp
movzbl 0x0(%r13,%r14,1),%esi
add    %ebp,%esi
movzbl 0x2(%r13,%r14,1),%ebp
add    %esi,%ebp
movzbl 0x0(%r13,%r11,1),%esi
add    %ebp,%esi
add    $0x2,%esi
shr    $0x2,%esi
mov    %dil,(%rdx)
mov    %sil,0x1(%rdx)
movzbl 0x1(%r13,%r14,1),%ecx
mov    %cl,0x2(%rdx)
movzbl 0x2(%r13),%ecx
movzbl 0x2(%r13,%r8,1),%esi
add    %esi,%ecx
add    $0x1,%ecx
shr    %ecx
movzbl 0x1(%r13,%r14,1),%esi
movzbl 0x3(%r13,%r14,1),%edi
mov    %cl,0x3(%rdx)
movzbl 0x2(%r13,%r14,1),%ecx
add    $0x2,%r13
add    %edi,%esi
add    $0x1,%esi
shr    %esi
mov    %cl,0x4(%rdx)
mov    %sil,0x5(%rdx)
add    $0x6,%rdx
cmp    %rax,%r13
jbe    12a0 <bayer_to_rgbbgr24+0x190>
xor    %r10d,%r10d
jmp    145b <bayer_to_rgbbgr24+0x34b>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %ebx,%r12d
mov    0x0(%r13,%r14,1),%al
mov    %al,(%rdx)
mov    %dil,0x1(%rdx)
mov    %r10b,0x2(%rdx)
movzbl 0x0(%r13,%r14,1),%eax
movzbl 0x2(%r13,%r14,1),%edi
add    %edi,%eax
add    $0x1,%eax
shr    %eax
mov    %al,0x3(%rdx)
mov    0x1(%r13,%r14,1),%al
mov    %al,0x4(%rdx)
mov    %r10b,0x5(%rdx)
add    $0x6,%rdx
jmp    13a7 <bayer_to_rgbbgr24+0x297>
mov    %ebx,%r12d
mov    0x1(%r13,%r14,1),%al
mov    %al,(%rdx)
mov    0x0(%r13,%r14,1),%al
mov    %al,0x1(%rdx)
mov    %dil,0x2(%rdx)
add    $0x3,%rdx
mov    %r13,%rbp
lea    -0x2(%r9),%rdi
mov    $0x1,%r10b
cmp    %rdi,%rbp
ja     1455 <bayer_to_rgbbgr24+0x345>
nopw   0x0(%rax,%rax,1)
movzbl 0x0(%rbp),%ecx
movzbl 0x2(%rbp),%esi
add    %ecx,%esi
movzbl -0x1(%rbp,%r11,1),%ecx
add    %esi,%ecx
movzbl 0x2(%rbp,%r8,1),%esi
add    %esi,%ecx
add    $0x2,%ecx
shr    $0x2,%ecx
movzbl 0x1(%rbp),%esi
movzbl 0x0(%rbp,%r14,1),%eax
add    %esi,%eax
movzbl 0x2(%rbp,%r14,1),%esi
add    %eax,%esi
movzbl 0x0(%rbp,%r11,1),%eax
add    %esi,%eax
add    $0x2,%eax
shr    $0x2,%eax
movzbl 0x1(%rbp,%r14,1),%ebx
mov    %bl,(%rdx)
mov    %al,0x1(%rdx)
mov    %cl,0x2(%rdx)
movzbl 0x2(%rbp),%eax
movzbl 0x2(%rbp,%r8,1),%ecx
movzbl 0x1(%rbp,%r14,1),%esi
movzbl 0x3(%rbp,%r14,1),%ebx
add    %ebx,%esi
add    $0x1,%esi
shr    %esi
mov    %sil,0x3(%rdx)
movzbl 0x2(%rbp,%r14,1),%ebx
add    $0x2,%rbp
add    %ecx,%eax
add    $0x1,%eax
shr    %eax
mov    %bl,0x4(%rdx)
mov    %al,0x5(%rdx)
add    $0x6,%rdx
cmp    %rdi,%rbp
jbe    13c0 <bayer_to_rgbbgr24+0x2b0>
mov    %rbp,%r13
mov    %r12d,%ebx
movzbl 0x0(%r13),%edi
cmp    %r9,%r13
jae    14f0 <bayer_to_rgbbgr24+0x3e0>
movzbl 0x2(%r13),%eax
movzbl 0x0(%r13,%r8,1),%ecx
movzbl 0x2(%r13,%r8,1),%esi
add    %eax,%edi
add    %ecx,%edi
add    %esi,%edi
add    $0x2,%edi
shr    $0x2,%edi
movzbl 0x1(%r13),%eax
movzbl 0x0(%r13,%r14,1),%ecx
add    %eax,%ecx
movzbl 0x2(%r13,%r14,1),%eax
add    %ecx,%eax
movzbl 0x0(%r13,%r11,1),%ecx
lea    (%rcx,%rax,1),%ebp
add    $0x2,%ebp
shr    $0x2,%ebp
test   %r10b,%r10b
jne    1170 <bayer_to_rgbbgr24+0x60>
mov    %dil,(%rdx)
mov    %bpl,0x1(%rdx)
mov    0x1(%r13,%r14,1),%al
mov    %al,0x2(%rdx)
movzbl 0x2(%r13),%eax
movzbl 0x2(%r13,%r8,1),%ecx
add    %ecx,%eax
add    $0x1,%eax
shr    %eax
mov    %al,0x3(%rdx)
mov    0x2(%r13,%r14,1),%al
mov    %al,0x4(%rdx)
mov    0x1(%r13,%r14,1),%dil
jmp    11a2 <bayer_to_rgbbgr24+0x92>
nopl   0x0(%rax)
movzbl 0x0(%r13,%r8,1),%eax
add    %eax,%edi
add    $0x1,%edi
shr    %edi
movzbl 0x1(%r13),%eax
movzbl 0x0(%r13,%r11,1),%ecx
add    %eax,%ecx
movzbl 0x0(%r13,%r14,1),%eax
add    %ecx,%eax
add    $0x1,%eax
imul   $0xaaab,%eax,%ebp
shr    $0x11,%ebp
test   %r10b,%r10b
je     1540 <bayer_to_rgbbgr24+0x430>
mov    0x1(%r13,%r14,1),%al
mov    %al,(%rdx)
mov    %bpl,0x1(%rdx)
mov    %dil,0x2(%rdx)
add    $0x3,%rdx
mov    $0x1,%r10b
jmp    11ae <bayer_to_rgbbgr24+0x9e>
xchg   %ax,%ax
mov    %dil,(%rdx)
mov    %bpl,0x1(%rdx)
mov    0x1(%r13,%r14,1),%al
mov    %al,0x2(%rdx)
add    $0x3,%rdx
xor    %r10d,%r10d
jmp    11ae <bayer_to_rgbbgr24+0x9e>
mov    %ebx,%ebp
lea    (%r14,%r13,1),%rdi
xor    %r8d,%r8d
test   %ebp,%ebp
sete   %r8b
xor    %r9d,%r9d
test   %r12d,%r12d
sete   %r9b
mov    %r13,%rsi
mov    %r14d,%ecx
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <v4lconvert_border_bayer_line_to_bgr24@plt>

LLVM IR (-O0):
define void @bayer_to_rgbbgr24(i8* %0, i8* %1, i32 %2, i32 %3, i32 %4, i32 %5, i32 %6) {
%8 = alloca i8*
%9 = alloca i8*
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i8*
store i8* %0, i8** %8
store i8* %1, i8** %9
store i32 %2, i32* %10
store i32 %3, i32* %11
store i32 %4, i32* %12
store i32 %5, i32* %13
store i32 %6, i32* %14
%18 = load i8*, i8** %8
%19 = load i8*, i8** %8
%20 = load i32, i32* %10
%21 = sext i32 %20 to i64
%22 = getelementptr inbounds i8, i8* %19, i64 %21
%23 = load i8*, i8** %9
%24 = load i32, i32* %10
%25 = load i32, i32* %13
%26 = load i32, i32* %14
%27 = call i32 @v4lconvert_border_bayer_line_to_bgr24(i8* %18, i8* %22, i8* %23, i32 %24, i32 %25, i32 %26)
%28 = load i32, i32* %10
%29 = mul nsw i32 %28, 3
%30 = load i8*, i8** %9
%31 = sext i32 %29 to i64
%32 = getelementptr inbounds i8, i8* %30, i64 %31
store i8* %32, i8** %9
%33 = load i32, i32* %11
%34 = sub nsw i32 %33, 2
store i32 %34, i32* %11
br label %35
35: ; preds = %748, %7
%36 = load i32, i32* %11
%37 = icmp ne i32 %36, 0
br i1 %37, label %38, label %751
38: ; preds = %35
%39 = load i8*, i8** %8
%40 = load i32, i32* %10
%41 = sub nsw i32 %40, 2
%42 = sext i32 %41 to i64
%43 = getelementptr inbounds i8, i8* %39, i64 %42
store i8* %43, i8** %17
%44 = load i32, i32* %13
%45 = icmp ne i32 %44, 0
br i1 %45, label %46, label %174
46: ; preds = %38
%47 = load i8*, i8** %8
%48 = getelementptr inbounds i8, i8* %47, i64 1
%49 = load i8, i8* %48
%50 = zext i8 %49 to i32
%51 = load i8*, i8** %8
%52 = load i32, i32* %10
%53 = mul nsw i32 %52, 2
%54 = add nsw i32 %53, 1
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds i8, i8* %51, i64 %55
%57 = load i8, i8* %56
%58 = zext i8 %57 to i32
%59 = add nsw i32 %50, %58
%60 = add nsw i32 %59, 1
%61 = ashr i32 %60, 1
store i32 %61, i32* %15
%62 = load i8*, i8** %8
%63 = getelementptr inbounds i8, i8* %62, i64 0
%64 = load i8, i8* %63
%65 = zext i8 %64 to i32
%66 = load i8*, i8** %8
%67 = load i32, i32* %10
%68 = mul nsw i32 %67, 2
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds i8, i8* %66, i64 %69
%71 = load i8, i8* %70
%72 = zext i8 %71 to i32
%73 = add nsw i32 %65, %72
%74 = load i8*, i8** %8
%75 = load i32, i32* %10
%76 = add nsw i32 %75, 1
%77 = sext i32 %76 to i64
%78 = getelementptr inbounds i8, i8* %74, i64 %77
%79 = load i8, i8* %78
%80 = zext i8 %79 to i32
%81 = add nsw i32 %73, %80
%82 = add nsw i32 %81, 1
%83 = sdiv i32 %82, 3
store i32 %83, i32* %16
%84 = load i32, i32* %14
%85 = icmp ne i32 %84, 0
br i1 %85, label %86, label %102
86: ; preds = %46
%87 = load i32, i32* %15
%88 = trunc i32 %87 to i8
%89 = load i8*, i8** %9
%90 = getelementptr inbounds i8, i8* %89, i32 1
store i8* %90, i8** %9
store i8 %88, i8* %89
%91 = load i32, i32* %16
%92 = trunc i32 %91 to i8
%93 = load i8*, i8** %9
%94 = getelementptr inbounds i8, i8* %93, i32 1
store i8* %94, i8** %9
store i8 %92, i8* %93
%95 = load i8*, i8** %8
%96 = load i32, i32* %10
%97 = sext i32 %96 to i64
%98 = getelementptr inbounds i8, i8* %95, i64 %97
%99 = load i8, i8* %98
%100 = load i8*, i8** %9
%101 = getelementptr inbounds i8, i8* %100, i32 1
store i8* %101, i8** %9
store i8 %99, i8* %100
br label %118
102: ; preds = %46
%103 = load i8*, i8** %8
%104 = load i32, i32* %10
%105 = sext i32 %104 to i64
%106 = getelementptr inbounds i8, i8* %103, i64 %105
%107 = load i8, i8* %106
%108 = load i8*, i8** %9
%109 = getelementptr inbounds i8, i8* %108, i32 1
store i8* %109, i8** %9
store i8 %107, i8* %108
%110 = load i32, i32* %16
%111 = trunc i32 %110 to i8
%112 = load i8*, i8** %9
%113 = getelementptr inbounds i8, i8* %112, i32 1
store i8* %113, i8** %9
store i8 %111, i8* %112
%114 = load i32, i32* %15
%115 = trunc i32 %114 to i8
%116 = load i8*, i8** %9
%117 = getelementptr inbounds i8, i8* %116, i32 1
store i8* %117, i8** %9
store i8 %115, i8* %116
br label %118
118: ; preds = %102, %86
%119 = load i8*, i8** %8
%120 = load i32, i32* %10
%121 = sext i32 %120 to i64
%122 = getelementptr inbounds i8, i8* %119, i64 %121
%123 = load i8, i8* %122
%124 = zext i8 %123 to i32
%125 = load i8*, i8** %8
%126 = load i32, i32* %10
%127 = add nsw i32 %126, 2
%128 = sext i32 %127 to i64
%129 = getelementptr inbounds i8, i8* %125, i64 %128
%130 = load i8, i8* %129
%131 = zext i8 %130 to i32
%132 = add nsw i32 %124, %131
%133 = add nsw i32 %132, 1
%134 = ashr i32 %133, 1
store i32 %134, i32* %16
%135 = load i32, i32* %14
%136 = icmp ne i32 %135, 0
br i1 %136, label %137, label %154
137: ; preds = %118
%138 = load i32, i32* %15
%139 = trunc i32 %138 to i8
%140 = load i8*, i8** %9
%141 = getelementptr inbounds i8, i8* %140, i32 1
store i8* %141, i8** %9
store i8 %139, i8* %140
%142 = load i8*, i8** %8
%143 = load i32, i32* %10
%144 = add nsw i32 %143, 1
%145 = sext i32 %144 to i64
%146 = getelementptr inbounds i8, i8* %142, i64 %145
%147 = load i8, i8* %146
%148 = load i8*, i8** %9
%149 = getelementptr inbounds i8, i8* %148, i32 1
store i8* %149, i8** %9
store i8 %147, i8* %148
%150 = load i32, i32* %16
%151 = trunc i32 %150 to i8
%152 = load i8*, i8** %9
%153 = getelementptr inbounds i8, i8* %152, i32 1
store i8* %153, i8** %9
store i8 %151, i8* %152
br label %171
154: ; preds = %118
%155 = load i32, i32* %16
%156 = trunc i32 %155 to i8
%157 = load i8*, i8** %9
%158 = getelementptr inbounds i8, i8* %157, i32 1
store i8* %158, i8** %9
store i8 %156, i8* %157
%159 = load i8*, i8** %8
%160 = load i32, i32* %10
%161 = add nsw i32 %160, 1
%162 = sext i32 %161 to i64
%163 = getelementptr inbounds i8, i8* %159, i64 %162
%164 = load i8, i8* %163
%165 = load i8*, i8** %9
%166 = getelementptr inbounds i8, i8* %165, i32 1
store i8* %166, i8** %9
store i8 %164, i8* %165
%167 = load i32, i32* %15
%168 = trunc i32 %167 to i8
%169 = load i8*, i8** %9
%170 = getelementptr inbounds i8, i8* %169, i32 1
store i8* %170, i8** %9
store i8 %168, i8* %169
br label %171
171: ; preds = %154, %137
%172 = load i8*, i8** %8
%173 = getelementptr inbounds i8, i8* %172, i32 1
store i8* %173, i8** %8
br label %232
174: ; preds = %38
%175 = load i8*, i8** %8
%176 = getelementptr inbounds i8, i8* %175, i64 0
%177 = load i8, i8* %176
%178 = zext i8 %177 to i32
%179 = load i8*, i8** %8
%180 = load i32, i32* %10
%181 = mul nsw i32 %180, 2
%182 = sext i32 %181 to i64
%183 = getelementptr inbounds i8, i8* %179, i64 %182
%184 = load i8, i8* %183
%185 = zext i8 %184 to i32
%186 = add nsw i32 %178, %185
%187 = add nsw i32 %186, 1
%188 = ashr i32 %187, 1
store i32 %188, i32* %15
%189 = load i32, i32* %14
%190 = icmp ne i32 %189, 0
br i1 %190, label %191, label %211
191: ; preds = %174
%192 = load i32, i32* %15
%193 = trunc i32 %192 to i8
%194 = load i8*, i8** %9
%195 = getelementptr inbounds i8, i8* %194, i32 1
store i8* %195, i8** %9
store i8 %193, i8* %194
%196 = load i8*, i8** %8
%197 = load i32, i32* %10
%198 = sext i32 %197 to i64
%199 = getelementptr inbounds i8, i8* %196, i64 %198
%200 = load i8, i8* %199
%201 = load i8*, i8** %9
%202 = getelementptr inbounds i8, i8* %201, i32 1
store i8* %202, i8** %9
store i8 %200, i8* %201
%203 = load i8*, i8** %8
%204 = load i32, i32* %10
%205 = add nsw i32 %204, 1
%206 = sext i32 %205 to i64
%207 = getelementptr inbounds i8, i8* %203, i64 %206
%208 = load i8, i8* %207
%209 = load i8*, i8** %9
%210 = getelementptr inbounds i8, i8* %209, i32 1
store i8* %210, i8** %9
store i8 %208, i8* %209
br label %231
211: ; preds = %174
%212 = load i8*, i8** %8
%213 = load i32, i32* %10
%214 = add nsw i32 %213, 1
%215 = sext i32 %214 to i64
%216 = getelementptr inbounds i8, i8* %212, i64 %215
%217 = load i8, i8* %216
%218 = load i8*, i8** %9
%219 = getelementptr inbounds i8, i8* %218, i32 1
store i8* %219, i8** %9
store i8 %217, i8* %218
%220 = load i8*, i8** %8
%221 = load i32, i32* %10
%222 = sext i32 %221 to i64
%223 = getelementptr inbounds i8, i8* %220, i64 %222
%224 = load i8, i8* %223
%225 = load i8*, i8** %9
%226 = getelementptr inbounds i8, i8* %225, i32 1
store i8* %226, i8** %9
store i8 %224, i8* %225
%227 = load i32, i32* %15
%228 = trunc i32 %227 to i8
%229 = load i8*, i8** %9
%230 = getelementptr inbounds i8, i8* %229, i32 1
store i8* %230, i8** %9
store i8 %228, i8* %229
br label %231
231: ; preds = %211, %191
br label %232
232: ; preds = %231, %171
%233 = load i32, i32* %14
%234 = icmp ne i32 %233, 0
br i1 %234, label %235, label %368
235: ; preds = %232
br label %236
236: ; preds = %364, %235
%237 = load i8*, i8** %8
%238 = load i8*, i8** %17
%239 = getelementptr inbounds i8, i8* %238, i64 -2
%240 = icmp ule i8* %237, %239
br i1 %240, label %241, label %367
241: ; preds = %236
%242 = load i8*, i8** %8
%243 = getelementptr inbounds i8, i8* %242, i64 0
%244 = load i8, i8* %243
%245 = zext i8 %244 to i32
%246 = load i8*, i8** %8
%247 = getelementptr inbounds i8, i8* %246, i64 2
%248 = load i8, i8* %247
%249 = zext i8 %248 to i32
%250 = add nsw i32 %245, %249
%251 = load i8*, i8** %8
%252 = load i32, i32* %10
%253 = mul nsw i32 %252, 2
%254 = sext i32 %253 to i64
%255 = getelementptr inbounds i8, i8* %251, i64 %254
%256 = load i8, i8* %255
%257 = zext i8 %256 to i32
%258 = add nsw i32 %250, %257
%259 = load i8*, i8** %8
%260 = load i32, i32* %10
%261 = mul nsw i32 %260, 2
%262 = add nsw i32 %261, 2
%263 = sext i32 %262 to i64
%264 = getelementptr inbounds i8, i8* %259, i64 %263
%265 = load i8, i8* %264
%266 = zext i8 %265 to i32
%267 = add nsw i32 %258, %266
%268 = add nsw i32 %267, 2
%269 = ashr i32 %268, 2
store i32 %269, i32* %15
%270 = load i8*, i8** %8
%271 = getelementptr inbounds i8, i8* %270, i64 1
%272 = load i8, i8* %271
%273 = zext i8 %272 to i32
%274 = load i8*, i8** %8
%275 = load i32, i32* %10
%276 = sext i32 %275 to i64
%277 = getelementptr inbounds i8, i8* %274, i64 %276
%278 = load i8, i8* %277
%279 = zext i8 %278 to i32
%280 = add nsw i32 %273, %279
%281 = load i8*, i8** %8
%282 = load i32, i32* %10
%283 = add nsw i32 %282, 2
%284 = sext i32 %283 to i64
%285 = getelementptr inbounds i8, i8* %281, i64 %284
%286 = load i8, i8* %285
%287 = zext i8 %286 to i32
%288 = add nsw i32 %280, %287
%289 = load i8*, i8** %8
%290 = load i32, i32* %10
%291 = mul nsw i32 %290, 2
%292 = add nsw i32 %291, 1
%293 = sext i32 %292 to i64
%294 = getelementptr inbounds i8, i8* %289, i64 %293
%295 = load i8, i8* %294
%296 = zext i8 %295 to i32
%297 = add nsw i32 %288, %296
%298 = add nsw i32 %297, 2
%299 = ashr i32 %298, 2
store i32 %299, i32* %16
%300 = load i32, i32* %15
%301 = trunc i32 %300 to i8
%302 = load i8*, i8** %9
%303 = getelementptr inbounds i8, i8* %302, i32 1
store i8* %303, i8** %9
store i8 %301, i8* %302
%304 = load i32, i32* %16
%305 = trunc i32 %304 to i8
%306 = load i8*, i8** %9
%307 = getelementptr inbounds i8, i8* %306, i32 1
store i8* %307, i8** %9
store i8 %305, i8* %306
%308 = load i8*, i8** %8
%309 = load i32, i32* %10
%310 = add nsw i32 %309, 1
%311 = sext i32 %310 to i64
%312 = getelementptr inbounds i8, i8* %308, i64 %311
%313 = load i8, i8* %312
%314 = load i8*, i8** %9
%315 = getelementptr inbounds i8, i8* %314, i32 1
store i8* %315, i8** %9
store i8 %313, i8* %314
%316 = load i8*, i8** %8
%317 = getelementptr inbounds i8, i8* %316, i64 2
%318 = load i8, i8* %317
%319 = zext i8 %318 to i32
%320 = load i8*, i8** %8
%321 = load i32, i32* %10
%322 = mul nsw i32 %321, 2
%323 = add nsw i32 %322, 2
%324 = sext i32 %323 to i64
%325 = getelementptr inbounds i8, i8* %320, i64 %324
%326 = load i8, i8* %325
%327 = zext i8 %326 to i32
%328 = add nsw i32 %319, %327
%329 = add nsw i32 %328, 1
%330 = ashr i32 %329, 1
store i32 %330, i32* %15
%331 = load i8*, i8** %8
%332 = load i32, i32* %10
%333 = add nsw i32 %332, 1
%334 = sext i32 %333 to i64
%335 = getelementptr inbounds i8, i8* %331, i64 %334
%336 = load i8, i8* %335
%337 = zext i8 %336 to i32
%338 = load i8*, i8** %8
%339 = load i32, i32* %10
%340 = add nsw i32 %339, 3
%341 = sext i32 %340 to i64
%342 = getelementptr inbounds i8, i8* %338, i64 %341
%343 = load i8, i8* %342
%344 = zext i8 %343 to i32
%345 = add nsw i32 %337, %344
%346 = add nsw i32 %345, 1
%347 = ashr i32 %346, 1
store i32 %347, i32* %16
%348 = load i32, i32* %15
%349 = trunc i32 %348 to i8
%350 = load i8*, i8** %9
%351 = getelementptr inbounds i8, i8* %350, i32 1
store i8* %351, i8** %9
store i8 %349, i8* %350
%352 = load i8*, i8** %8
%353 = load i32, i32* %10
%354 = add nsw i32 %353, 2
%355 = sext i32 %354 to i64
%356 = getelementptr inbounds i8, i8* %352, i64 %355
%357 = load i8, i8* %356
%358 = load i8*, i8** %9
%359 = getelementptr inbounds i8, i8* %358, i32 1
store i8* %359, i8** %9
store i8 %357, i8* %358
%360 = load i32, i32* %16
%361 = trunc i32 %360 to i8
%362 = load i8*, i8** %9
%363 = getelementptr inbounds i8, i8* %362, i32 1
store i8* %363, i8** %9
store i8 %361, i8* %362
br label %364
364: ; preds = %241
%365 = load i8*, i8** %8
%366 = getelementptr inbounds i8, i8* %365, i64 2
store i8* %366, i8** %8
br label %236
367: ; preds = %236
br label %501
368: ; preds = %232
br label %369
369: ; preds = %497, %368
%370 = load i8*, i8** %8
%371 = load i8*, i8** %17
%372 = getelementptr inbounds i8, i8* %371, i64 -2
%373 = icmp ule i8* %370, %372
br i1 %373, label %374, label %500
374: ; preds = %369
%375 = load i8*, i8** %8
%376 = getelementptr inbounds i8, i8* %375, i64 0
%377 = load i8, i8* %376
%378 = zext i8 %377 to i32
%379 = load i8*, i8** %8
%380 = getelementptr inbounds i8, i8* %379, i64 2
%381 = load i8, i8* %380
%382 = zext i8 %381 to i32
%383 = add nsw i32 %378, %382
%384 = load i8*, i8** %8
%385 = load i32, i32* %10
%386 = mul nsw i32 %385, 2
%387 = sext i32 %386 to i64
%388 = getelementptr inbounds i8, i8* %384, i64 %387
%389 = load i8, i8* %388
%390 = zext i8 %389 to i32
%391 = add nsw i32 %383, %390
%392 = load i8*, i8** %8
%393 = load i32, i32* %10
%394 = mul nsw i32 %393, 2
%395 = add nsw i32 %394, 2
%396 = sext i32 %395 to i64
%397 = getelementptr inbounds i8, i8* %392, i64 %396
%398 = load i8, i8* %397
%399 = zext i8 %398 to i32
%400 = add nsw i32 %391, %399
%401 = add nsw i32 %400, 2
%402 = ashr i32 %401, 2
store i32 %402, i32* %15
%403 = load i8*, i8** %8
%404 = getelementptr inbounds i8, i8* %403, i64 1
%405 = load i8, i8* %404
%406 = zext i8 %405 to i32
%407 = load i8*, i8** %8
%408 = load i32, i32* %10
%409 = sext i32 %408 to i64
%410 = getelementptr inbounds i8, i8* %407, i64 %409
%411 = load i8, i8* %410
%412 = zext i8 %411 to i32
%413 = add nsw i32 %406, %412
%414 = load i8*, i8** %8
%415 = load i32, i32* %10
%416 = add nsw i32 %415, 2
%417 = sext i32 %416 to i64
%418 = getelementptr inbounds i8, i8* %414, i64 %417
%419 = load i8, i8* %418
%420 = zext i8 %419 to i32
%421 = add nsw i32 %413, %420
%422 = load i8*, i8** %8
%423 = load i32, i32* %10
%424 = mul nsw i32 %423, 2
%425 = add nsw i32 %424, 1
%426 = sext i32 %425 to i64
%427 = getelementptr inbounds i8, i8* %422, i64 %426
%428 = load i8, i8* %427
%429 = zext i8 %428 to i32
%430 = add nsw i32 %421, %429
%431 = add nsw i32 %430, 2
%432 = ashr i32 %431, 2
store i32 %432, i32* %16
%433 = load i8*, i8** %8
%434 = load i32, i32* %10
%435 = add nsw i32 %434, 1
%436 = sext i32 %435 to i64
%437 = getelementptr inbounds i8, i8* %433, i64 %436
%438 = load i8, i8* %437
%439 = load i8*, i8** %9
%440 = getelementptr inbounds i8, i8* %439, i32 1
store i8* %440, i8** %9
store i8 %438, i8* %439
%441 = load i32, i32* %16
%442 = trunc i32 %441 to i8
%443 = load i8*, i8** %9
%444 = getelementptr inbounds i8, i8* %443, i32 1
store i8* %444, i8** %9
store i8 %442, i8* %443
%445 = load i32, i32* %15
%446 = trunc i32 %445 to i8
%447 = load i8*, i8** %9
%448 = getelementptr inbounds i8, i8* %447, i32 1
store i8* %448, i8** %9
store i8 %446, i8* %447
%449 = load i8*, i8** %8
%450 = getelementptr inbounds i8, i8* %449, i64 2
%451 = load i8, i8* %450
%452 = zext i8 %451 to i32
%453 = load i8*, i8** %8
%454 = load i32, i32* %10
%455 = mul nsw i32 %454, 2
%456 = add nsw i32 %455, 2
%457 = sext i32 %456 to i64
%458 = getelementptr inbounds i8, i8* %453, i64 %457
%459 = load i8, i8* %458
%460 = zext i8 %459 to i32
%461 = add nsw i32 %452, %460
%462 = add nsw i32 %461, 1
%463 = ashr i32 %462, 1
store i32 %463, i32* %15
%464 = load i8*, i8** %8
%465 = load i32, i32* %10
%466 = add nsw i32 %465, 1
%467 = sext i32 %466 to i64
%468 = getelementptr inbounds i8, i8* %464, i64 %467
%469 = load i8, i8* %468
%470 = zext i8 %469 to i32
%471 = load i8*, i8** %8
%472 = load i32, i32* %10
%473 = add nsw i32 %472, 3
%474 = sext i32 %473 to i64
%475 = getelementptr inbounds i8, i8* %471, i64 %474
%476 = load i8, i8* %475
%477 = zext i8 %476 to i32
%478 = add nsw i32 %470, %477
%479 = add nsw i32 %478, 1
%480 = ashr i32 %479, 1
store i32 %480, i32* %16
%481 = load i32, i32* %16
%482 = trunc i32 %481 to i8
%483 = load i8*, i8** %9
%484 = getelementptr inbounds i8, i8* %483, i32 1
store i8* %484, i8** %9
store i8 %482, i8* %483
%485 = load i8*, i8** %8
%486 = load i32, i32* %10
%487 = add nsw i32 %486, 2
%488 = sext i32 %487 to i64
%489 = getelementptr inbounds i8, i8* %485, i64 %488
%490 = load i8, i8* %489
%491 = load i8*, i8** %9
%492 = getelementptr inbounds i8, i8* %491, i32 1
store i8* %492, i8** %9
store i8 %490, i8* %491
%493 = load i32, i32* %15
%494 = trunc i32 %493 to i8
%495 = load i8*, i8** %9
%496 = getelementptr inbounds i8, i8* %495, i32 1
store i8* %496, i8** %9
store i8 %494, i8* %495
br label %497
497: ; preds = %374
%498 = load i8*, i8** %8
%499 = getelementptr inbounds i8, i8* %498, i64 2
store i8* %499, i8** %8
br label %369
500: ; preds = %369
br label %501
501: ; preds = %500, %367
%502 = load i8*, i8** %8
%503 = load i8*, i8** %17
%504 = icmp ult i8* %502, %503
br i1 %504, label %505, label %663
505: ; preds = %501
%506 = load i8*, i8** %8
%507 = getelementptr inbounds i8, i8* %506, i64 0
%508 = load i8, i8* %507
%509 = zext i8 %508 to i32
%510 = load i8*, i8** %8
%511 = getelementptr inbounds i8, i8* %510, i64 2
%512 = load i8, i8* %511
%513 = zext i8 %512 to i32
%514 = add nsw i32 %509, %513
%515 = load i8*, i8** %8
%516 = load i32, i32* %10
%517 = mul nsw i32 %516, 2
%518 = sext i32 %517 to i64
%519 = getelementptr inbounds i8, i8* %515, i64 %518
%520 = load i8, i8* %519
%521 = zext i8 %520 to i32
%522 = add nsw i32 %514, %521
%523 = load i8*, i8** %8
%524 = load i32, i32* %10
%525 = mul nsw i32 %524, 2
%526 = add nsw i32 %525, 2
%527 = sext i32 %526 to i64
%528 = getelementptr inbounds i8, i8* %523, i64 %527
%529 = load i8, i8* %528
%530 = zext i8 %529 to i32
%531 = add nsw i32 %522, %530
%532 = add nsw i32 %531, 2
%533 = ashr i32 %532, 2
store i32 %533, i32* %15
%534 = load i8*, i8** %8
%535 = getelementptr inbounds i8, i8* %534, i64 1
%536 = load i8, i8* %535
%537 = zext i8 %536 to i32
%538 = load i8*, i8** %8
%539 = load i32, i32* %10
%540 = sext i32 %539 to i64
%541 = getelementptr inbounds i8, i8* %538, i64 %540
%542 = load i8, i8* %541
%543 = zext i8 %542 to i32
%544 = add nsw i32 %537, %543
%545 = load i8*, i8** %8
%546 = load i32, i32* %10
%547 = add nsw i32 %546, 2
%548 = sext i32 %547 to i64
%549 = getelementptr inbounds i8, i8* %545, i64 %548
%550 = load i8, i8* %549
%551 = zext i8 %550 to i32
%552 = add nsw i32 %544, %551
%553 = load i8*, i8** %8
%554 = load i32, i32* %10
%555 = mul nsw i32 %554, 2
%556 = add nsw i32 %555, 1
%557 = sext i32 %556 to i64
%558 = getelementptr inbounds i8, i8* %553, i64 %557
%559 = load i8, i8* %558
%560 = zext i8 %559 to i32
%561 = add nsw i32 %552, %560
%562 = add nsw i32 %561, 2
%563 = ashr i32 %562, 2
store i32 %563, i32* %16
%564 = load i32, i32* %14
%565 = icmp ne i32 %564, 0
br i1 %565, label %566, label %583
566: ; preds = %505
%567 = load i32, i32* %15
%568 = trunc i32 %567 to i8
%569 = load i8*, i8** %9
%570 = getelementptr inbounds i8, i8* %569, i32 1
store i8* %570, i8** %9
store i8 %568, i8* %569
%571 = load i32, i32* %16
%572 = trunc i32 %571 to i8
%573 = load i8*, i8** %9
%574 = getelementptr inbounds i8, i8* %573, i32 1
store i8* %574, i8** %9
store i8 %572, i8* %573
%575 = load i8*, i8** %8
%576 = load i32, i32* %10
%577 = add nsw i32 %576, 1
%578 = sext i32 %577 to i64
%579 = getelementptr inbounds i8, i8* %575, i64 %578
%580 = load i8, i8* %579
%581 = load i8*, i8** %9
%582 = getelementptr inbounds i8, i8* %581, i32 1
store i8* %582, i8** %9
store i8 %580, i8* %581
br label %600
583: ; preds = %505
%584 = load i8*, i8** %8
%585 = load i32, i32* %10
%586 = add nsw i32 %585, 1
%587 = sext i32 %586 to i64
%588 = getelementptr inbounds i8, i8* %584, i64 %587
%589 = load i8, i8* %588
%590 = load i8*, i8** %9
%591 = getelementptr inbounds i8, i8* %590, i32 1
store i8* %591, i8** %9
store i8 %589, i8* %590
%592 = load i32, i32* %16
%593 = trunc i32 %592 to i8
%594 = load i8*, i8** %9
%595 = getelementptr inbounds i8, i8* %594, i32 1
store i8* %595, i8** %9
store i8 %593, i8* %594
%596 = load i32, i32* %15
%597 = trunc i32 %596 to i8
%598 = load i8*, i8** %9
%599 = getelementptr inbounds i8, i8* %598, i32 1
store i8* %599, i8** %9
store i8 %597, i8* %598
br label %600
600: ; preds = %583, %566
%601 = load i8*, i8** %8
%602 = getelementptr inbounds i8, i8* %601, i64 2
%603 = load i8, i8* %602
%604 = zext i8 %603 to i32
%605 = load i8*, i8** %8
%606 = load i32, i32* %10
%607 = mul nsw i32 %606, 2
%608 = add nsw i32 %607, 2
%609 = sext i32 %608 to i64
%610 = getelementptr inbounds i8, i8* %605, i64 %609
%611 = load i8, i8* %610
%612 = zext i8 %611 to i32
%613 = add nsw i32 %604, %612
%614 = add nsw i32 %613, 1
%615 = ashr i32 %614, 1
store i32 %615, i32* %15
%616 = load i32, i32* %14
%617 = icmp ne i32 %616, 0
br i1 %617, label %618, label %639
618: ; preds = %600
%619 = load i32, i32* %15
%620 = trunc i32 %619 to i8
%621 = load i8*, i8** %9
%622 = getelementptr inbounds i8, i8* %621, i32 1
store i8* %622, i8** %9
store i8 %620, i8* %621
%623 = load i8*, i8** %8
%624 = load i32, i32* %10
%625 = add nsw i32 %624, 2
%626 = sext i32 %625 to i64
%627 = getelementptr inbounds i8, i8* %623, i64 %626
%628 = load i8, i8* %627
%629 = load i8*, i8** %9
%630 = getelementptr inbounds i8, i8* %629, i32 1
store i8* %630, i8** %9
store i8 %628, i8* %629
%631 = load i8*, i8** %8
%632 = load i32, i32* %10
%633 = add nsw i32 %632, 1
%634 = sext i32 %633 to i64
%635 = getelementptr inbounds i8, i8* %631, i64 %634
%636 = load i8, i8* %635
%637 = load i8*, i8** %9
%638 = getelementptr inbounds i8, i8* %637, i32 1
store i8* %638, i8** %9
store i8 %636, i8* %637
br label %660
639: ; preds = %600
%640 = load i8*, i8** %8
%641 = load i32, i32* %10
%642 = add nsw i32 %641, 1
%643 = sext i32 %642 to i64
%644 = getelementptr inbounds i8, i8* %640, i64 %643
%645 = load i8, i8* %644
%646 = load i8*, i8** %9
%647 = getelementptr inbounds i8, i8* %646, i32 1
store i8* %647, i8** %9
store i8 %645, i8* %646
%648 = load i8*, i8** %8
%649 = load i32, i32* %10
%650 = add nsw i32 %649, 2
%651 = sext i32 %650 to i64
%652 = getelementptr inbounds i8, i8* %648, i64 %651
%653 = load i8, i8* %652
%654 = load i8*, i8** %9
%655 = getelementptr inbounds i8, i8* %654, i32 1
store i8* %655, i8** %9
store i8 %653, i8* %654
%656 = load i32, i32* %15
%657 = trunc i32 %656 to i8
%658 = load i8*, i8** %9
%659 = getelementptr inbounds i8, i8* %658, i32 1
store i8* %659, i8** %9
store i8 %657, i8* %658
br label %660
660: ; preds = %639, %618
%661 = load i8*, i8** %8
%662 = getelementptr inbounds i8, i8* %661, i32 1
store i8* %662, i8** %8
br label %737
663: ; preds = %501
%664 = load i8*, i8** %8
%665 = getelementptr inbounds i8, i8* %664, i64 0
%666 = load i8, i8* %665
%667 = zext i8 %666 to i32
%668 = load i8*, i8** %8
%669 = load i32, i32* %10
%670 = mul nsw i32 %669, 2
%671 = sext i32 %670 to i64
%672 = getelementptr inbounds i8, i8* %668, i64 %671
%673 = load i8, i8* %672
%674 = zext i8 %673 to i32
%675 = add nsw i32 %667, %674
%676 = add nsw i32 %675, 1
%677 = ashr i32 %676, 1
store i32 %677, i32* %15
%678 = load i8*, i8** %8
%679 = getelementptr inbounds i8, i8* %678, i64 1
%680 = load i8, i8* %679
%681 = zext i8 %680 to i32
%682 = load i8*, i8** %8
%683 = load i32, i32* %10
%684 = mul nsw i32 %683, 2
%685 = add nsw i32 %684, 1
%686 = sext i32 %685 to i64
%687 = getelementptr inbounds i8, i8* %682, i64 %686
%688 = load i8, i8* %687
%689 = zext i8 %688 to i32
%690 = add nsw i32 %681, %689
%691 = load i8*, i8** %8
%692 = load i32, i32* %10
%693 = sext i32 %692 to i64
%694 = getelementptr inbounds i8, i8* %691, i64 %693
%695 = load i8, i8* %694
%696 = zext i8 %695 to i32
%697 = add nsw i32 %690, %696
%698 = add nsw i32 %697, 1
%699 = sdiv i32 %698, 3
store i32 %699, i32* %16
%700 = load i32, i32* %14
%701 = icmp ne i32 %700, 0
br i1 %701, label %702, label %719
702: ; preds = %663
%703 = load i32, i32* %15
%704 = trunc i32 %703 to i8
%705 = load i8*, i8** %9
%706 = getelementptr inbounds i8, i8* %705, i32 1
store i8* %706, i8** %9
store i8 %704, i8* %705
%707 = load i32, i32* %16
%708 = trunc i32 %707 to i8
%709 = load i8*, i8** %9
%710 = getelementptr inbounds i8, i8* %709, i32 1
store i8* %710, i8** %9
store i8 %708, i8* %709
%711 = load i8*, i8** %8
%712 = load i32, i32* %10
%713 = add nsw i32 %712, 1
%714 = sext i32 %713 to i64
%715 = getelementptr inbounds i8, i8* %711, i64 %714
%716 = load i8, i8* %715
%717 = load i8*, i8** %9
%718 = getelementptr inbounds i8, i8* %717, i32 1
store i8* %718, i8** %9
store i8 %716, i8* %717
br label %736
719: ; preds = %663
%720 = load i8*, i8** %8
%721 = load i32, i32* %10
%722 = add nsw i32 %721, 1
%723 = sext i32 %722 to i64
%724 = getelementptr inbounds i8, i8* %720, i64 %723
%725 = load i8, i8* %724
%726 = load i8*, i8** %9
%727 = getelementptr inbounds i8, i8* %726, i32 1
store i8* %727, i8** %9
store i8 %725, i8* %726
%728 = load i32, i32* %16
%729 = trunc i32 %728 to i8
%730 = load i8*, i8** %9
%731 = getelementptr inbounds i8, i8* %730, i32 1
store i8* %731, i8** %9
store i8 %729, i8* %730
%732 = load i32, i32* %15
%733 = trunc i32 %732 to i8
%734 = load i8*, i8** %9
%735 = getelementptr inbounds i8, i8* %734, i32 1
store i8* %735, i8** %9
store i8 %733, i8* %734
br label %736
736: ; preds = %719, %702
br label %737
737: ; preds = %736, %660
%738 = load i8*, i8** %8
%739 = getelementptr inbounds i8, i8* %738, i64 2
store i8* %739, i8** %8
%740 = load i32, i32* %14
%741 = icmp ne i32 %740, 0
%742 = xor i1 %741, true
%743 = zext i1 %742 to i32
store i32 %743, i32* %14
%744 = load i32, i32* %13
%745 = icmp ne i32 %744, 0
%746 = xor i1 %745, true
%747 = zext i1 %746 to i32
store i32 %747, i32* %13
br label %748
748: ; preds = %737
%749 = load i32, i32* %11
%750 = add nsw i32 %749, -1
store i32 %750, i32* %11
br label %35
751: ; preds = %35
%752 = load i8*, i8** %8
%753 = load i32, i32* %10
%754 = sext i32 %753 to i64
%755 = getelementptr inbounds i8, i8* %752, i64 %754
%756 = load i8*, i8** %8
%757 = load i8*, i8** %9
%758 = load i32, i32* %10
%759 = load i32, i32* %13
%760 = icmp ne i32 %759, 0
%761 = xor i1 %760, true
%762 = zext i1 %761 to i32
%763 = load i32, i32* %14
%764 = icmp ne i32 %763, 0
%765 = xor i1 %764, true
%766 = zext i1 %765 to i32
%767 = call i32 @v4lconvert_border_bayer_line_to_bgr24(i8* %755, i8* %756, i8* %757, i32 %758, i32 %762, i32 %766)
ret void
}

LLVM IR (-O2):
define void @bayer_to_rgbbgr24(i8* %0, i8* %1, i32 %2, i32 %3, i32 %4, i32 %5, i32 %6) {
%8 = sext i32 %2 to i64
%9 = getelementptr inbounds i8, i8* %0, i64 %8
%10 = tail call i32 @v4lconvert_border_bayer_line_to_bgr24(i8* %0, i8* %9, i8* %1, i32 %2, i32 %5, i32 %6)
%11 = mul nsw i32 %2, 3
%12 = sext i32 %11 to i64
%13 = getelementptr inbounds i8, i8* %1, i64 %12
%14 = add nsw i32 %3, -2
%15 = icmp eq i32 %14, 0
br i1 %15, label %402, label %16
16: ; preds = %7
%17 = add nsw i32 %2, -2
%18 = sext i32 %17 to i64
%19 = shl nsw i32 %2, 1
%20 = or i32 %19, 1
%21 = sext i32 %20 to i64
%22 = sext i32 %19 to i64
%23 = add nsw i32 %2, 1
%24 = sext i32 %23 to i64
%25 = add nsw i32 %2, 2
%26 = sext i32 %25 to i64
%27 = add nsw i32 %19, 2
%28 = sext i32 %27 to i64
%29 = add nsw i32 %2, 3
%30 = sext i32 %29 to i64
br label %31
31: ; preds = %16, %393
%32 = phi i8* [ %0, %16 ], [ %397, %393 ]
%33 = phi i32 [ %6, %16 ], [ %398, %393 ]
%34 = phi i32 [ %5, %16 ], [ %399, %393 ]
%35 = phi i8* [ %13, %16 ], [ %395, %393 ]
%36 = phi i32 [ %14, %16 ], [ %400, %393 ]
%37 = getelementptr inbounds i8, i8* %32, i64 %18
%38 = icmp eq i32 %34, 0
br i1 %38, label %85, label %39
39: ; preds = %31
%40 = getelementptr inbounds i8, i8* %32, i64 1
%41 = load i8, i8* %40
%42 = zext i8 %41 to i32
%43 = getelementptr inbounds i8, i8* %32, i64 %21
%44 = load i8, i8* %43
%45 = zext i8 %44 to i32
%46 = add nuw nsw i32 %42, 1
%47 = add nuw nsw i32 %46, %45
%48 = lshr i32 %47, 1
%49 = load i8, i8* %32
%50 = zext i8 %49 to i16
%51 = getelementptr inbounds i8, i8* %32, i64 %22
%52 = load i8, i8* %51
%53 = zext i8 %52 to i16
%54 = getelementptr inbounds i8, i8* %32, i64 %24
%55 = load i8, i8* %54
%56 = zext i8 %55 to i16
%57 = add nuw nsw i16 %50, 1
%58 = add nuw nsw i16 %57, %53
%59 = add nuw nsw i16 %58, %56
%60 = udiv i16 %59, 3
%61 = icmp eq i32 %33, 0
br i1 %61, label %62, label %113
62: ; preds = %39
%63 = getelementptr inbounds i8, i8* %32, i64 %8
%64 = load i8, i8* %63
%65 = getelementptr inbounds i8, i8* %35, i64 1
store i8 %64, i8* %35
%66 = trunc i16 %60 to i8
store i8 %66, i8* %65
%67 = trunc i32 %48 to i8
%68 = getelementptr inbounds i8, i8* %35, i64 2
store i8 %67, i8* %68
%69 = getelementptr inbounds i8, i8* %35, i64 3
%70 = getelementptr inbounds i8, i8* %32, i64 %8
%71 = load i8, i8* %70
%72 = zext i8 %71 to i16
%73 = getelementptr inbounds i8, i8* %32, i64 %26
%74 = load i8, i8* %73
%75 = zext i8 %74 to i16
%76 = add nuw nsw i16 %72, 1
%77 = add nuw nsw i16 %76, %75
%78 = lshr i16 %77, 1
%79 = trunc i16 %78 to i8
store i8 %79, i8* %69
%80 = trunc i32 %48 to i8
%81 = load i8, i8* %54
%82 = getelementptr inbounds i8, i8* %35, i64 4
store i8 %81, i8* %82
%83 = getelementptr inbounds i8, i8* %35, i64 5
store i8 %80, i8* %83
%84 = getelementptr inbounds i8, i8* %35, i64 6
br label %141
85: ; preds = %31
%86 = load i8, i8* %32
%87 = zext i8 %86 to i32
%88 = getelementptr inbounds i8, i8* %32, i64 %22
%89 = load i8, i8* %88
%90 = zext i8 %89 to i32
%91 = add nuw nsw i32 %87, 1
%92 = add nuw nsw i32 %91, %90
%93 = lshr i32 %92, 1
%94 = icmp eq i32 %33, 0
br i1 %94, label %104, label %95
95: ; preds = %85
%96 = trunc i32 %93 to i8
%97 = getelementptr inbounds i8, i8* %35, i64 1
store i8 %96, i8* %35
%98 = getelementptr inbounds i8, i8* %32, i64 %8
%99 = load i8, i8* %98
%100 = getelementptr inbounds i8, i8* %35, i64 2
store i8 %99, i8* %97
%101 = getelementptr inbounds i8, i8* %32, i64 %24
%102 = load i8, i8* %101
%103 = getelementptr inbounds i8, i8* %35, i64 3
store i8 %102, i8* %100
br label %136
104: ; preds = %85
%105 = getelementptr inbounds i8, i8* %32, i64 %24
%106 = load i8, i8* %105
%107 = getelementptr inbounds i8, i8* %35, i64 1
store i8 %106, i8* %35
%108 = getelementptr inbounds i8, i8* %32, i64 %8
%109 = load i8, i8* %108
%110 = getelementptr inbounds i8, i8* %35, i64 2
store i8 %109, i8* %107
%111 = trunc i32 %93 to i8
%112 = getelementptr inbounds i8, i8* %35, i64 3
store i8 %111, i8* %110
br label %141
113: ; preds = %39
%114 = trunc i32 %48 to i8
%115 = getelementptr inbounds i8, i8* %35, i64 1
store i8 %114, i8* %35
%116 = trunc i16 %60 to i8
store i8 %116, i8* %115
%117 = getelementptr inbounds i8, i8* %32, i64 %8
%118 = load i8, i8* %117
%119 = getelementptr inbounds i8, i8* %35, i64 2
store i8 %118, i8* %119
%120 = getelementptr inbounds i8, i8* %35, i64 3
%121 = getelementptr inbounds i8, i8* %32, i64 %8
%122 = load i8, i8* %121
%123 = zext i8 %122 to i16
%124 = getelementptr inbounds i8, i8* %32, i64 %26
%125 = load i8, i8* %124
%126 = zext i8 %125 to i16
%127 = add nuw nsw i16 %123, 1
%128 = add nuw nsw i16 %127, %126
%129 = lshr i16 %128, 1
%130 = trunc i32 %48 to i8
store i8 %130, i8* %120
%131 = trunc i16 %129 to i8
%132 = load i8, i8* %54
%133 = getelementptr inbounds i8, i8* %35, i64 4
store i8 %132, i8* %133
%134 = getelementptr inbounds i8, i8* %35, i64 5
store i8 %131, i8* %134
%135 = getelementptr inbounds i8, i8* %35, i64 6
br label %136
136: ; preds = %113, %95
%137 = phi i8* [ %32, %95 ], [ %40, %113 ]
%138 = phi i8* [ %103, %95 ], [ %135, %113 ]
%139 = getelementptr inbounds i8, i8* %37, i64 -2
%140 = icmp ugt i8* %137, %139
br i1 %140, label %276, label %146
141: ; preds = %62, %104
%142 = phi i8* [ %32, %104 ], [ %40, %62 ]
%143 = phi i8* [ %112, %104 ], [ %84, %62 ]
%144 = getelementptr inbounds i8, i8* %37, i64 -2
%145 = icmp ugt i8* %142, %144
br i1 %145, label %276, label %211
146: ; preds = %136, %146
%147 = phi i8* [ %151, %146 ], [ %137, %136 ]
%148 = phi i8* [ %209, %146 ], [ %138, %136 ]
%149 = load i8, i8* %147
%150 = zext i8 %149 to i16
%151 = getelementptr inbounds i8, i8* %147, i64 2
%152 = load i8, i8* %151
%153 = zext i8 %152 to i16
%154 = getelementptr inbounds i8, i8* %147, i64 %22
%155 = load i8, i8* %154
%156 = zext i8 %155 to i16
%157 = getelementptr inbounds i8, i8* %147, i64 %28
%158 = load i8, i8* %157
%159 = zext i8 %158 to i16
%160 = add nuw nsw i16 %150, 2
%161 = add nuw nsw i16 %160, %153
%162 = add nuw nsw i16 %161, %156
%163 = add nuw nsw i16 %162, %159
%164 = lshr i16 %163, 2
%165 = getelementptr inbounds i8, i8* %147, i64 1
%166 = load i8, i8* %165
%167 = zext i8 %166 to i16
%168 = getelementptr inbounds i8, i8* %147, i64 %8
%169 = load i8, i8* %168
%170 = zext i8 %169 to i16
%171 = getelementptr inbounds i8, i8* %147, i64 %26
%172 = load i8, i8* %171
%173 = zext i8 %172 to i16
%174 = getelementptr inbounds i8, i8* %147, i64 %21
%175 = load i8, i8* %174
%176 = zext i8 %175 to i16
%177 = add nuw nsw i16 %167, 2
%178 = add nuw nsw i16 %177, %170
%179 = add nuw nsw i16 %178, %173
%180 = add nuw nsw i16 %179, %176
%181 = lshr i16 %180, 2
%182 = trunc i16 %164 to i8
%183 = getelementptr inbounds i8, i8* %148, i64 1
store i8 %182, i8* %148
%184 = trunc i16 %181 to i8
%185 = getelementptr inbounds i8, i8* %148, i64 2
store i8 %184, i8* %183
%186 = getelementptr inbounds i8, i8* %147, i64 %24
%187 = load i8, i8* %186
%188 = getelementptr inbounds i8, i8* %148, i64 3
store i8 %187, i8* %185
%189 = load i8, i8* %151
%190 = zext i8 %189 to i16
%191 = load i8, i8* %157
%192 = zext i8 %191 to i16
%193 = add nuw nsw i16 %190, 1
%194 = add nuw nsw i16 %193, %192
%195 = lshr i16 %194, 1
%196 = load i8, i8* %186
%197 = zext i8 %196 to i16
%198 = getelementptr inbounds i8, i8* %147, i64 %30
%199 = load i8, i8* %198
%200 = zext i8 %199 to i16
%201 = add nuw nsw i16 %197, 1
%202 = add nuw nsw i16 %201, %200
%203 = lshr i16 %202, 1
%204 = trunc i16 %195 to i8
%205 = getelementptr inbounds i8, i8* %148, i64 4
store i8 %204, i8* %188
%206 = load i8, i8* %171
%207 = getelementptr inbounds i8, i8* %148, i64 5
store i8 %206, i8* %205
%208 = trunc i16 %203 to i8
%209 = getelementptr inbounds i8, i8* %148, i64 6
store i8 %208, i8* %207
%210 = icmp ugt i8* %151, %139
br i1 %210, label %276, label %146
211: ; preds = %141, %211
%212 = phi i8* [ %216, %211 ], [ %142, %141 ]
%213 = phi i8* [ %274, %211 ], [ %143, %141 ]
%214 = load i8, i8* %212
%215 = zext i8 %214 to i16
%216 = getelementptr inbounds i8, i8* %212, i64 2
%217 = load i8, i8* %216
%218 = zext i8 %217 to i16
%219 = getelementptr inbounds i8, i8* %212, i64 %22
%220 = load i8, i8* %219
%221 = zext i8 %220 to i16
%222 = getelementptr inbounds i8, i8* %212, i64 %28
%223 = load i8, i8* %222
%224 = zext i8 %223 to i16
%225 = add nuw nsw i16 %215, 2
%226 = add nuw nsw i16 %225, %218
%227 = add nuw nsw i16 %226, %221
%228 = add nuw nsw i16 %227, %224
%229 = lshr i16 %228, 2
%230 = getelementptr inbounds i8, i8* %212, i64 1
%231 = load i8, i8* %230
%232 = zext i8 %231 to i16
%233 = getelementptr inbounds i8, i8* %212, i64 %8
%234 = load i8, i8* %233
%235 = zext i8 %234 to i16
%236 = getelementptr inbounds i8, i8* %212, i64 %26
%237 = load i8, i8* %236
%238 = zext i8 %237 to i16
%239 = getelementptr inbounds i8, i8* %212, i64 %21
%240 = load i8, i8* %239
%241 = zext i8 %240 to i16
%242 = add nuw nsw i16 %232, 2
%243 = add nuw nsw i16 %242, %235
%244 = add nuw nsw i16 %243, %238
%245 = add nuw nsw i16 %244, %241
%246 = lshr i16 %245, 2
%247 = getelementptr inbounds i8, i8* %212, i64 %24
%248 = load i8, i8* %247
%249 = getelementptr inbounds i8, i8* %213, i64 1
store i8 %248, i8* %213
%250 = trunc i16 %246 to i8
%251 = getelementptr inbounds i8, i8* %213, i64 2
store i8 %250, i8* %249
%252 = trunc i16 %229 to i8
%253 = getelementptr inbounds i8, i8* %213, i64 3
store i8 %252, i8* %251
%254 = load i8, i8* %216
%255 = zext i8 %254 to i16
%256 = load i8, i8* %222
%257 = zext i8 %256 to i16
%258 = add nuw nsw i16 %255, 1
%259 = add nuw nsw i16 %258, %257
%260 = lshr i16 %259, 1
%261 = load i8, i8* %247
%262 = zext i8 %261 to i16
%263 = getelementptr inbounds i8, i8* %212, i64 %30
%264 = load i8, i8* %263
%265 = zext i8 %264 to i16
%266 = add nuw nsw i16 %262, 1
%267 = add nuw nsw i16 %266, %265
%268 = lshr i16 %267, 1
%269 = trunc i16 %268 to i8
%270 = getelementptr inbounds i8, i8* %213, i64 4
store i8 %269, i8* %253
%271 = load i8, i8* %236
%272 = getelementptr inbounds i8, i8* %213, i64 5
store i8 %271, i8* %270
%273 = trunc i16 %260 to i8
%274 = getelementptr inbounds i8, i8* %213, i64 6
store i8 %273, i8* %272
%275 = icmp ugt i8* %216, %144
br i1 %275, label %276, label %211
276: ; preds = %146, %211, %136, %141
%277 = phi i1 [ true, %141 ], [ false, %136 ], [ true, %211 ], [ false, %146 ]
%278 = phi i8* [ %143, %141 ], [ %138, %136 ], [ %274, %211 ], [ %209, %146 ]
%279 = phi i8* [ %142, %141 ], [ %137, %136 ], [ %216, %211 ], [ %151, %146 ]
%280 = icmp ult i8* %279, %37
%281 = load i8, i8* %279
%282 = zext i8 %281 to i32
br i1 %280, label %283, label %357
283: ; preds = %276
%284 = getelementptr inbounds i8, i8* %279, i64 2
%285 = load i8, i8* %284
%286 = zext i8 %285 to i32
%287 = getelementptr inbounds i8, i8* %279, i64 %22
%288 = load i8, i8* %287
%289 = zext i8 %288 to i32
%290 = getelementptr inbounds i8, i8* %279, i64 %28
%291 = load i8, i8* %290
%292 = zext i8 %291 to i32
%293 = add nuw nsw i32 %282, 2
%294 = add nuw nsw i32 %293, %286
%295 = add nuw nsw i32 %294, %289
%296 = add nuw nsw i32 %295, %292
%297 = lshr i32 %296, 2
%298 = getelementptr inbounds i8, i8* %279, i64 1
%299 = load i8, i8* %298
%300 = zext i8 %299 to i32
%301 = getelementptr inbounds i8, i8* %279, i64 %8
%302 = load i8, i8* %301
%303 = zext i8 %302 to i32
%304 = getelementptr inbounds i8, i8* %279, i64 %26
%305 = load i8, i8* %304
%306 = zext i8 %305 to i32
%307 = getelementptr inbounds i8, i8* %279, i64 %21
%308 = load i8, i8* %307
%309 = zext i8 %308 to i32
%310 = add nuw nsw i32 %300, 2
%311 = add nuw nsw i32 %310, %303
%312 = add nuw nsw i32 %311, %306
%313 = add nuw nsw i32 %312, %309
%314 = lshr i32 %313, 2
br i1 %277, label %334, label %315
315: ; preds = %283
%316 = trunc i32 %297 to i8
%317 = getelementptr inbounds i8, i8* %278, i64 1
store i8 %316, i8* %278
%318 = trunc i32 %314 to i8
%319 = getelementptr inbounds i8, i8* %278, i64 2
store i8 %318, i8* %317
%320 = getelementptr inbounds i8, i8* %279, i64 %24
%321 = load i8, i8* %320
store i8 %321, i8* %319
%322 = getelementptr inbounds i8, i8* %278, i64 3
%323 = load i8, i8* %284
%324 = zext i8 %323 to i16
%325 = load i8, i8* %290
%326 = zext i8 %325 to i16
%327 = add nuw nsw i16 %324, 1
%328 = add nuw nsw i16 %327, %326
%329 = lshr i16 %328, 1
%330 = trunc i16 %329 to i8
%331 = getelementptr inbounds i8, i8* %278, i64 4
store i8 %330, i8* %322
%332 = load i8, i8* %304
store i8 %332, i8* %331
%333 = load i8, i8* %320
br label %353
334: ; preds = %283
%335 = getelementptr inbounds i8, i8* %279, i64 %24
%336 = load i8, i8* %335
%337 = getelementptr inbounds i8, i8* %278, i64 1
store i8 %336, i8* %278
%338 = trunc i32 %314 to i8
%339 = getelementptr inbounds i8, i8* %278, i64 2
store i8 %338, i8* %337
%340 = trunc i32 %297 to i8
store i8 %340, i8* %339
%341 = getelementptr inbounds i8, i8* %278, i64 3
%342 = load i8, i8* %284
%343 = zext i8 %342 to i16
%344 = load i8, i8* %290
%345 = zext i8 %344 to i16
%346 = add nuw nsw i16 %343, 1
%347 = add nuw nsw i16 %346, %345
%348 = lshr i16 %347, 1
%349 = load i8, i8* %335
%350 = getelementptr inbounds i8, i8* %278, i64 4
store i8 %349, i8* %341
%351 = load i8, i8* %304
store i8 %351, i8* %350
%352 = trunc i16 %348 to i8
br label %353
353: ; preds = %334, %315
%354 = phi i8 [ %352, %334 ], [ %333, %315 ]
%355 = getelementptr inbounds i8, i8* %278, i64 5
store i8 %354, i8* %355
%356 = getelementptr inbounds i8, i8* %278, i64 6
br label %393
357: ; preds = %276
%358 = getelementptr inbounds i8, i8* %279, i64 %22
%359 = load i8, i8* %358
%360 = zext i8 %359 to i32
%361 = add nuw nsw i32 %282, 1
%362 = add nuw nsw i32 %361, %360
%363 = lshr i32 %362, 1
%364 = getelementptr inbounds i8, i8* %279, i64 1
%365 = load i8, i8* %364
%366 = zext i8 %365 to i16
%367 = getelementptr inbounds i8, i8* %279, i64 %21
%368 = load i8, i8* %367
%369 = zext i8 %368 to i16
%370 = getelementptr inbounds i8, i8* %279, i64 %8
%371 = load i8, i8* %370
%372 = zext i8 %371 to i16
%373 = add nuw nsw i16 %366, 1
%374 = add nuw nsw i16 %373, %369
%375 = add nuw nsw i16 %374, %372
%376 = udiv i16 %375, 3
br i1 %277, label %385, label %377
377: ; preds = %357
%378 = trunc i32 %363 to i8
%379 = getelementptr inbounds i8, i8* %278, i64 1
store i8 %378, i8* %278
%380 = trunc i16 %376 to i8
%381 = getelementptr inbounds i8, i8* %278, i64 2
store i8 %380, i8* %379
%382 = getelementptr inbounds i8, i8* %279, i64 %24
%383 = load i8, i8* %382
%384 = getelementptr inbounds i8, i8* %278, i64 3
store i8 %383, i8* %381
br label %393
385: ; preds = %357
%386 = getelementptr inbounds i8, i8* %279, i64 %24
%387 = load i8, i8* %386
%388 = getelementptr inbounds i8, i8* %278, i64 1
store i8 %387, i8* %278
%389 = trunc i16 %376 to i8
%390 = getelementptr inbounds i8, i8* %278, i64 2
store i8 %389, i8* %388
%391 = trunc i32 %363 to i8
%392 = getelementptr inbounds i8, i8* %278, i64 3
store i8 %391, i8* %390
br label %393
393: ; preds = %377, %385, %353
%394 = phi i1 [ %277, %353 ], [ false, %377 ], [ true, %385 ]
%395 = phi i8* [ %356, %353 ], [ %384, %377 ], [ %392, %385 ]
%396 = phi i8* [ %298, %353 ], [ %279, %377 ], [ %279, %385 ]
%397 = getelementptr inbounds i8, i8* %396, i64 2
%398 = zext i1 %394 to i32
%399 = zext i1 %38 to i32
%400 = add nsw i32 %36, -1
%401 = icmp eq i32 %400, 0
br i1 %401, label %402, label %31
402: ; preds = %393, %7
%403 = phi i8* [ %13, %7 ], [ %395, %393 ]
%404 = phi i32 [ %5, %7 ], [ %399, %393 ]
%405 = phi i32 [ %6, %7 ], [ %398, %393 ]
%406 = phi i8* [ %0, %7 ], [ %397, %393 ]
%407 = getelementptr inbounds i8, i8* %406, i64 %8
%408 = icmp eq i32 %404, 0
%409 = zext i1 %408 to i32
%410 = icmp eq i32 %405, 0
%411 = zext i1 %410 to i32
%412 = tail call i32 @v4lconvert_border_bayer_line_to_bgr24(i8* %407, i8* %406, i8* %403, i32 %2, i32 %409, i32 %411)
ret void
}