#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*/ ibitmap_blitmc(char *, long, char const *, long, int, int,
                                  int, long, unsigned long);
int /*<<< orphan*/ memcpy(char *, char const *, long);
int ibitmap_blitfc(char *dst, long pitch1, const char *src, long pitch2, int w,
                   int h, int pixsize, long linesize, unsigned long mask,
                   int flag) {
  static unsigned long endian = 0x11223344;
  unsigned char *p1, *p2;
  unsigned long key24, c;
  unsigned char key08;
  unsigned short key16;
  unsigned int imask, k;
  long inc1, inc2, i;
  long longsize, isize;
  if ((flag & (2 | 4)) == 0) {
    for (; h; h--) {
      memcpy(dst, src, linesize);
      dst += pitch1;
      src -= pitch2;
    }
    return 0;
  }
  if ((flag & 2) != 0 && (flag & 4) == 0) {
    for (; h; h--) {
      ibitmap_blitmc(dst, pitch1, src, pitch2, w, 1, pixsize, linesize, mask);
      dst += pitch1;
      src -= pitch2;
    }
    return 0;
  }
  src += linesize - pixsize;
  inc1 = pitch1 - linesize;
  longsize = sizeof(long);
  isize = sizeof(int);
  if (flag & 8)
    inc2 = -(pitch2 - linesize);
  else
    inc2 = pitch2 + linesize;
  switch (pixsize) {
  case 1:
    key08 = (unsigned char)mask;
    for (; h; h--) {
      if (flag & 2) {
        for (i = w; i; i--) {
          if (*(unsigned char *)src != key08)
            *dst = *src;
          dst++;
          src--;
        }
      } else {
        for (i = w; i; i--) {
          *dst = *src;
          dst++;
          src--;
        }
      }
      dst += inc1;
      src += inc2;
    }
    break;
  case 2:
    key16 = (unsigned short)mask;
    for (; h; h--) {
      if (flag & 2) {
        for (i = w; i; i--) {
          if (*(unsigned short *)src != key16)
            *(unsigned short *)dst = *(unsigned short *)src;
          dst += 2;
          src -= 2;
        }
      } else {
        for (i = w; i; i--) {
          *(unsigned short *)dst = *(unsigned short *)src;
          dst += 2;
          src -= 2;
        }
      }
      dst += inc1;
      src += inc2;
    }
    break;
  case 3:
    if (((unsigned char *)&endian)[0] != 0x44)
      key24 = mask;
    else
      key24 = ((mask & 0xFFFF) << 8) | ((mask >> 16) & 0xFF);
    p1 = (unsigned char *)dst;
    p2 = (unsigned char *)src;
    for (; h; h--) {
      if (flag & 2) {
        if (longsize == 4) {
          for (i = w; i; i--) {
            c = (((unsigned long)(*(unsigned short *)p2)) << 8);
            if ((c | p2[2]) != key24) {
              p1[0] = p2[0];
              p1[1] = p2[1];
              p1[2] = p2[2];
            }
            p1 += 3;
            p2 -= 3;
          }
        } else if (isize == 4) {
          imask = (unsigned int)(key24 & 0xffffffff);
          for (i = w; i; i--) {
            k = (((unsigned int)(*(unsigned short *)p2)) << 8);
            if ((k | p2[2]) != imask) {
              p1[0] = p2[0];
              p1[1] = p2[1];
              p1[2] = p2[2];
            }
            p1 += 3;
            p2 -= 3;
          }
        }
      } else {
        for (i = w; i; i--) {
          p1[0] = p2[0];
          p1[1] = p2[1];
          p1[2] = p2[2];
          p1 += 3;
          p2 -= 3;
        }
      }
      p1 += inc1;
      p2 += inc2;
    }
    break;
  case 4:
    for (; h; h--) {
      if (longsize == 4) {
        if (flag & 2) {
          for (i = w; i; i--) {
            if (*(unsigned long *)src != mask)
              *(unsigned long *)dst = *(unsigned long *)src;
            dst += 4;
            src -= 4;
          }
        } else {
          for (i = w; i; i--) {
            *(unsigned long *)dst = *(unsigned long *)src;
            dst += 4;
            src -= 4;
          }
        }
      } else if (isize == 4) {
        imask = (unsigned int)(mask & 0xffffffff);
        if (flag & 2) {
          for (i = w; i; i--) {
            if (*(unsigned int *)src != imask)
              *(unsigned int *)dst = *(unsigned int *)src;
            dst += 4;
            src -= 4;
          }
        } else {
          for (i = w; i; i--) {
            *(unsigned int *)dst = *(unsigned int *)src;
            dst += 4;
            src -= 4;
          }
        }
      }
      dst += inc1;
      src += inc2;
    }
    break;
  }
  return 0;
}


x86 assembly (clang, -O0):
<ibitmap_blitfc>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%eax
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8d,-0x2c(%rbp)
mov    %r9d,-0x30(%rbp)
mov    0x28(%rbp),%eax
and    $0x6,%eax
cmp    $0x0,%eax
jne    11ba <ibitmap_blitfc+0x9a>
jmp    1165 <ibitmap_blitfc+0x45>
cmpl   $0x0,-0x30(%rbp)
je     11ae <ibitmap_blitfc+0x8e>
mov    -0x10(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    0x18(%rbp),%rdx
call   1040 <memcpy@plt>
mov    -0x18(%rbp),%rax
add    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
jmp    1165 <ibitmap_blitfc+0x45>
movl   $0x0,-0x4(%rbp)
jmp    1920 <ibitmap_blitfc+0x800>
mov    0x28(%rbp),%eax
and    $0x2,%eax
cmp    $0x0,%eax
je     125a <ibitmap_blitfc+0x13a>
mov    0x28(%rbp),%eax
and    $0x4,%eax
cmp    $0x0,%eax
jne    125a <ibitmap_blitfc+0x13a>
jmp    11dd <ibitmap_blitfc+0xbd>
cmpl   $0x0,-0x30(%rbp)
je     124e <ibitmap_blitfc+0x12e>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdx
mov    -0x28(%rbp),%rcx
mov    -0x2c(%rbp),%r8d
mov    0x10(%rbp),%r11d
mov    0x18(%rbp),%r10
mov    0x20(%rbp),%rax
mov    $0x1,%r9d
mov    %r11d,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <ibitmap_blitmc@plt>
mov    -0x18(%rbp),%rax
add    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
jmp    11dd <ibitmap_blitfc+0xbd>
movl   $0x0,-0x4(%rbp)
jmp    1920 <ibitmap_blitfc+0x800>
mov    0x18(%rbp),%rax
movslq 0x10(%rbp),%rcx
sub    %rcx,%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
sub    0x18(%rbp),%rax
mov    %rax,-0x68(%rbp)
movq   $0x8,-0x80(%rbp)
movq   $0x4,-0x88(%rbp)
mov    0x28(%rbp),%eax
and    $0x8,%eax
cmp    $0x0,%eax
je     12b1 <ibitmap_blitfc+0x191>
mov    -0x28(%rbp),%rcx
sub    0x18(%rbp),%rcx
xor    %eax,%eax
sub    %rcx,%rax
mov    %rax,-0x70(%rbp)
jmp    12bd <ibitmap_blitfc+0x19d>
mov    -0x28(%rbp),%rax
add    0x18(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    0x10(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,%ecx
mov    %rcx,-0x90(%rbp)
sub    $0x3,%eax
ja     1919 <ibitmap_blitfc+0x7f9>
mov    -0x90(%rbp),%rax
lea    0xd1d(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    0x20(%rbp),%rax
mov    %al,-0x51(%rbp)
cmpl   $0x0,-0x30(%rbp)
je     13df <ibitmap_blitfc+0x2bf>
mov    0x28(%rbp),%eax
and    $0x2,%eax
cmp    $0x0,%eax
je     136c <ibitmap_blitfc+0x24c>
movslq -0x2c(%rbp),%rax
mov    %rax,-0x78(%rbp)
cmpq   $0x0,-0x78(%rbp)
je     1367 <ibitmap_blitfc+0x247>
mov    -0x20(%rbp),%rax
movzbl (%rax),%eax
movzbl -0x51(%rbp),%ecx
cmp    %ecx,%eax
je     133e <ibitmap_blitfc+0x21e>
mov    -0x20(%rbp),%rax
mov    (%rax),%cl
mov    -0x10(%rbp),%rax
mov    %cl,(%rax)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
mov    -0x20(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x20(%rbp)
mov    -0x78(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x78(%rbp)
jmp    1314 <ibitmap_blitfc+0x1f4>
jmp    13b9 <ibitmap_blitfc+0x299>
movslq -0x2c(%rbp),%rax
mov    %rax,-0x78(%rbp)
cmpq   $0x0,-0x78(%rbp)
je     13b4 <ibitmap_blitfc+0x294>
mov    -0x20(%rbp),%rax
mov    (%rax),%cl
mov    -0x10(%rbp),%rax
mov    %cl,(%rax)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
mov    -0x20(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x20(%rbp)
mov    -0x78(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x78(%rbp)
jmp    1374 <ibitmap_blitfc+0x254>
jmp    13b9 <ibitmap_blitfc+0x299>
mov    -0x68(%rbp),%rax
add    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x70(%rbp),%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
jmp    12f3 <ibitmap_blitfc+0x1d3>
jmp    1919 <ibitmap_blitfc+0x7f9>
mov    0x20(%rbp),%rax
mov    %ax,-0x54(%rbp)
cmpl   $0x0,-0x30(%rbp)
je     14dc <ibitmap_blitfc+0x3bc>
mov    0x28(%rbp),%eax
and    $0x2,%eax
cmp    $0x0,%eax
je     1467 <ibitmap_blitfc+0x347>
movslq -0x2c(%rbp),%rax
mov    %rax,-0x78(%rbp)
cmpq   $0x0,-0x78(%rbp)
je     1462 <ibitmap_blitfc+0x342>
mov    -0x20(%rbp),%rax
movzwl (%rax),%eax
movzwl -0x54(%rbp),%ecx
cmp    %ecx,%eax
je     1439 <ibitmap_blitfc+0x319>
mov    -0x20(%rbp),%rax
mov    (%rax),%cx
mov    -0x10(%rbp),%rax
mov    %cx,(%rax)
mov    -0x10(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x10(%rbp)
mov    -0x20(%rbp),%rax
add    $0xfffffffffffffffe,%rax
mov    %rax,-0x20(%rbp)
mov    -0x78(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x78(%rbp)
jmp    140d <ibitmap_blitfc+0x2ed>
jmp    14b6 <ibitmap_blitfc+0x396>
movslq -0x2c(%rbp),%rax
mov    %rax,-0x78(%rbp)
cmpq   $0x0,-0x78(%rbp)
je     14b1 <ibitmap_blitfc+0x391>
mov    -0x20(%rbp),%rax
mov    (%rax),%cx
mov    -0x10(%rbp),%rax
mov    %cx,(%rax)
mov    -0x10(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x10(%rbp)
mov    -0x20(%rbp),%rax
add    $0xfffffffffffffffe,%rax
mov    %rax,-0x20(%rbp)
mov    -0x78(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x78(%rbp)
jmp    146f <ibitmap_blitfc+0x34f>
jmp    14b6 <ibitmap_blitfc+0x396>
mov    -0x68(%rbp),%rax
add    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x70(%rbp),%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
jmp    13ec <ibitmap_blitfc+0x2cc>
jmp    1919 <ibitmap_blitfc+0x7f9>
movzbl 0x2b48(%rip),%eax
cmp    $0x44,%eax
je     14fe <ibitmap_blitfc+0x3de>
mov    0x20(%rbp),%rax
mov    %rax,-0x48(%rbp)
jmp    1522 <ibitmap_blitfc+0x402>
mov    0x20(%rbp),%rax
and    $0xffff,%rax
shl    $0x8,%rax
mov    0x20(%rbp),%rcx
shr    $0x10,%rcx
and    $0xff,%rcx
or     %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x40(%rbp)
cmpl   $0x0,-0x30(%rbp)
je     172b <ibitmap_blitfc+0x60b>
mov    0x28(%rbp),%eax
and    $0x2,%eax
cmp    $0x0,%eax
je     169c <ibitmap_blitfc+0x57c>
cmpq   $0x4,-0x80(%rbp)
jne    15e7 <ibitmap_blitfc+0x4c7>
movslq -0x2c(%rbp),%rax
mov    %rax,-0x78(%rbp)
cmpq   $0x0,-0x78(%rbp)
je     15e2 <ibitmap_blitfc+0x4c2>
mov    -0x40(%rbp),%rax
movzwl (%rax),%eax
shl    $0x8,%rax
mov    %rax,-0x50(%rbp)
mov    -0x50(%rbp),%rax
mov    -0x40(%rbp),%rcx
movzbl 0x2(%rcx),%ecx
or     %rcx,%rax
cmp    -0x48(%rbp),%rax
je     15b9 <ibitmap_blitfc+0x499>
mov    -0x40(%rbp),%rax
mov    (%rax),%cl
mov    -0x38(%rbp),%rax
mov    %cl,(%rax)
mov    -0x40(%rbp),%rax
mov    0x1(%rax),%cl
mov    -0x38(%rbp),%rax
mov    %cl,0x1(%rax)
mov    -0x40(%rbp),%rax
mov    0x2(%rax),%cl
mov    -0x38(%rbp),%rax
mov    %cl,0x2(%rax)
mov    -0x38(%rbp),%rax
add    $0x3,%rax
mov    %rax,-0x38(%rbp)
mov    -0x40(%rbp),%rax
add    $0xfffffffffffffffd,%rax
mov    %rax,-0x40(%rbp)
mov    -0x78(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x78(%rbp)
jmp    155e <ibitmap_blitfc+0x43e>
jmp    1697 <ibitmap_blitfc+0x577>
cmpq   $0x4,-0x88(%rbp)
04
jne    1692 <ibitmap_blitfc+0x572>
movabs $0xffffffff,%rax
and    -0x48(%rbp),%rax
mov    %eax,-0x58(%rbp)
movslq -0x2c(%rbp),%rax
mov    %rax,-0x78(%rbp)
cmpq   $0x0,-0x78(%rbp)
je     168d <ibitmap_blitfc+0x56d>
mov    -0x40(%rbp),%rax
movzwl (%rax),%eax
shl    $0x8,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
mov    -0x40(%rbp),%rcx
movzbl 0x2(%rcx),%ecx
or     %ecx,%eax
cmp    -0x58(%rbp),%eax
je     1664 <ibitmap_blitfc+0x544>
mov    -0x40(%rbp),%rax
mov    (%rax),%cl
mov    -0x38(%rbp),%rax
mov    %cl,(%rax)
mov    -0x40(%rbp),%rax
mov    0x1(%rax),%cl
mov    -0x38(%rbp),%rax
mov    %cl,0x1(%rax)
mov    -0x40(%rbp),%rax
mov    0x2(%rax),%cl
mov    -0x38(%rbp),%rax
mov    %cl,0x2(%rax)
mov    -0x38(%rbp),%rax
add    $0x3,%rax
mov    %rax,-0x38(%rbp)
mov    -0x40(%rbp),%rax
add    $0xfffffffffffffffd,%rax
mov    %rax,-0x40(%rbp)
mov    -0x78(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x78(%rbp)
jmp    160e <ibitmap_blitfc+0x4ee>
jmp    1692 <ibitmap_blitfc+0x572>
jmp    1697 <ibitmap_blitfc+0x577>
jmp    1705 <ibitmap_blitfc+0x5e5>
movslq -0x2c(%rbp),%rax
mov    %rax,-0x78(%rbp)
cmpq   $0x0,-0x78(%rbp)
je     1700 <ibitmap_blitfc+0x5e0>
mov    -0x40(%rbp),%rax
mov    (%rax),%cl
mov    -0x38(%rbp),%rax
mov    %cl,(%rax)
mov    -0x40(%rbp),%rax
mov    0x1(%rax),%cl
mov    -0x38(%rbp),%rax
mov    %cl,0x1(%rax)
mov    -0x40(%rbp),%rax
mov    0x2(%rax),%cl
mov    -0x38(%rbp),%rax
mov    %cl,0x2(%rax)
mov    -0x38(%rbp),%rax
add    $0x3,%rax
mov    %rax,-0x38(%rbp)
mov    -0x40(%rbp),%rax
add    $0xfffffffffffffffd,%rax
mov    %rax,-0x40(%rbp)
mov    -0x78(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x78(%rbp)
jmp    16a4 <ibitmap_blitfc+0x584>
jmp    1705 <ibitmap_blitfc+0x5e5>
mov    -0x68(%rbp),%rax
add    -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x70(%rbp),%rax
add    -0x40(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
jmp    1532 <ibitmap_blitfc+0x412>
jmp    1919 <ibitmap_blitfc+0x7f9>
jmp    1735 <ibitmap_blitfc+0x615>
cmpl   $0x0,-0x30(%rbp)
je     1914 <ibitmap_blitfc+0x7f4>
cmpq   $0x4,-0x80(%rbp)
jne    180d <ibitmap_blitfc+0x6ed>
mov    0x28(%rbp),%eax
and    $0x2,%eax
cmp    $0x0,%eax
je     17b9 <ibitmap_blitfc+0x699>
movslq -0x2c(%rbp),%rax
mov    %rax,-0x78(%rbp)
cmpq   $0x0,-0x78(%rbp)
je     17b4 <ibitmap_blitfc+0x694>
mov    -0x20(%rbp),%rax
mov    (%rax),%rax
cmp    0x20(%rbp),%rax
je     178b <ibitmap_blitfc+0x66b>
mov    -0x20(%rbp),%rax
mov    (%rax),%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x10(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x10(%rbp)
mov    -0x20(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x20(%rbp)
mov    -0x78(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x78(%rbp)
jmp    1761 <ibitmap_blitfc+0x641>
jmp    1808 <ibitmap_blitfc+0x6e8>
movslq -0x2c(%rbp),%rax
mov    %rax,-0x78(%rbp)
cmpq   $0x0,-0x78(%rbp)
je     1803 <ibitmap_blitfc+0x6e3>
mov    -0x20(%rbp),%rax
mov    (%rax),%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x10(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x10(%rbp)
mov    -0x20(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x20(%rbp)
mov    -0x78(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x78(%rbp)
jmp    17c1 <ibitmap_blitfc+0x6a1>
jmp    1808 <ibitmap_blitfc+0x6e8>
jmp    18ee <ibitmap_blitfc+0x7ce>
cmpq   $0x4,-0x88(%rbp)
04
jne    18e9 <ibitmap_blitfc+0x7c9>
movabs $0xffffffff,%rax
and    0x20(%rbp),%rax
mov    %eax,-0x58(%rbp)
mov    0x28(%rbp),%eax
and    $0x2,%eax
cmp    $0x0,%eax
je     1897 <ibitmap_blitfc+0x777>
movslq -0x2c(%rbp),%rax
mov    %rax,-0x78(%rbp)
cmpq   $0x0,-0x78(%rbp)
je     1892 <ibitmap_blitfc+0x772>
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
cmp    -0x58(%rbp),%eax
je     1869 <ibitmap_blitfc+0x749>
mov    -0x20(%rbp),%rax
mov    (%rax),%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x10(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x10(%rbp)
mov    -0x20(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x20(%rbp)
mov    -0x78(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x78(%rbp)
jmp    1843 <ibitmap_blitfc+0x723>
jmp    18e4 <ibitmap_blitfc+0x7c4>
movslq -0x2c(%rbp),%rax
mov    %rax,-0x78(%rbp)
cmpq   $0x0,-0x78(%rbp)
je     18df <ibitmap_blitfc+0x7bf>
mov    -0x20(%rbp),%rax
mov    (%rax),%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x10(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x10(%rbp)
mov    -0x20(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x20(%rbp)
mov    -0x78(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x78(%rbp)
jmp    189f <ibitmap_blitfc+0x77f>
jmp    18e4 <ibitmap_blitfc+0x7c4>
jmp    18e9 <ibitmap_blitfc+0x7c9>
jmp    18ee <ibitmap_blitfc+0x7ce>
mov    -0x68(%rbp),%rax
add    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x70(%rbp),%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
jmp    1735 <ibitmap_blitfc+0x615>
jmp    1919 <ibitmap_blitfc+0x7f9>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ibitmap_blitfc>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
mov    %rcx,%r15
mov    %rdx,%r13
mov    %rdi,%r12
mov    0xb8(%rsp),%eax
mov    0xa8(%rsp),%rbp
and    $0x6,%eax
je     11cf <ibitmap_blitfc+0xaf>
mov    %r9d,%edi
mov    0xa0(%rsp),%ebx
cmp    $0x2,%eax
mov    %r8d,0x4(%rsp)
jne    120d <ibitmap_blitfc+0xed>
test   %edi,%edi
je     1ee7 <ibitmap_blitfc+0xdc7>
mov    %rsi,%r14
mov    %r15,%rax
neg    %rax
mov    %rax,0x8(%rsp)
nopl   (%rax)
mov    %edi,0x10(%rsp)
sub    $0x8,%rsp
mov    %r12,%rdi
mov    %r14,%rsi
mov    %r13,%rdx
mov    %r15,%rcx
mov    0xc(%rsp),%r8d
mov    $0x1,%r9d
push   0xb8(%rsp)
push   %rbp
push   %rbx
call   1030 <ibitmap_blitmc@plt>
mov    0xc8(%rsp),%rbp
mov    0x30(%rsp),%edi
add    $0x20,%rsp
add    %r14,%r12
add    0x8(%rsp),%r13
add    $0xffffffff,%edi
jne    1180 <ibitmap_blitfc+0x60>
jmp    1ee7 <ibitmap_blitfc+0xdc7>
test   %r9d,%r9d
je     1ee7 <ibitmap_blitfc+0xdc7>
mov    %rsi,%r14
neg    %r15
xchg   %ax,%ax
mov    %r12,%rdi
mov    %r13,%rsi
mov    %rbp,%rdx
mov    %r9d,%ebx
call   1040 <memcpy@plt>
mov    0xa8(%rsp),%rbp
mov    %ebx,%r9d
add    %r14,%r12
add    %r15,%r13
add    $0xffffffff,%r9d
jne    11e0 <ibitmap_blitfc+0xc0>
jmp    1ee7 <ibitmap_blitfc+0xdc7>
mov    %r15,%r9
neg    %r9
mov    0xb8(%rsp),%eax
test   $0x8,%al
cmove  %r15,%r9
lea    -0x1(%rbx),%eax
cmp    $0x3,%eax
ja     1ee7 <ibitmap_blitfc+0xdc7>
movslq %ebx,%rcx
mov    %rbp,%rdx
sub    %rcx,%rdx
add    %rdx,%r13
sub    %rbp,%rsi
mov    %rsi,%r14
add    %rbp,%r9
lea    0xdb8(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
test   %edi,%edi
je     1ee7 <ibitmap_blitfc+0xdc7>
mov    %edi,%ecx
mov    0x4(%rsp),%eax
movslq %eax,%r11
mov    $0x1,%r10d
sub    %r11,%r10
lea    -0x1(%r11),%r8
mov    %eax,%r15d
and    $0x3,%r15d
mov    %r11,%rdx
and    $0xffffffffffffffe0,%rdx
and    $0x1f,%eax
mov    %rax,0x10(%rsp)
mov    %rdx,%rax
neg    %rax
mov    %rax,0x8(%rsp)
pxor   %xmm0,%xmm0
jmp    12be <ibitmap_blitfc+0x19e>
cs nopw 0x0(%rax,%rax,1)
mov    %r13,%rbp
mov    %r12,%rbx
mov    %r14,%rax
add    %r14,%rbx
add    %r9,%rbp
mov    %rbx,%r12
mov    %rbp,%r13
add    $0xffffffff,%ecx
je     1ee7 <ibitmap_blitfc+0xdc7>
mov    0xb8(%rsp),%eax
test   $0x2,%al
jne    13a0 <ibitmap_blitfc+0x280>
mov    0x4(%rsp),%eax
test   %eax,%eax
je     12a0 <ibitmap_blitfc+0x180>
cmp    $0x20,%eax
jb     12f8 <ibitmap_blitfc+0x1d8>
lea    0x1(%r13),%rax
cmp    %rax,%r12
jae    144f <ibitmap_blitfc+0x32f>
lea    (%r12,%r11,1),%rax
lea    (%r10,%r13,1),%rsi
cmp    %rax,%rsi
jae    144f <ibitmap_blitfc+0x32f>
mov    %r12,%rbx
mov    %r11,%rsi
mov    %r13,%rbp
mov    %ecx,%r12d
lea    -0x1(%rsi),%rax
mov    %rsi,%rdi
and    $0x7,%rdi
je     1338 <ibitmap_blitfc+0x218>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl 0x0(%rbp),%ecx
mov    %cl,(%rbx)
add    $0x1,%rbx
add    $0xffffffffffffffff,%rbp
add    $0xffffffffffffffff,%rsi
add    $0xffffffffffffffff,%rdi
jne    1320 <ibitmap_blitfc+0x200>
cmp    $0x7,%rax
mov    %r12d,%ecx
jb     12a6 <ibitmap_blitfc+0x186>
cs nopw 0x0(%rax,%rax,1)
nop
movzbl 0x0(%rbp),%eax
mov    %al,(%rbx)
movzbl -0x1(%rbp),%eax
mov    %al,0x1(%rbx)
movzbl -0x2(%rbp),%eax
mov    %al,0x2(%rbx)
movzbl -0x3(%rbp),%eax
mov    %al,0x3(%rbx)
movzbl -0x4(%rbp),%eax
mov    %al,0x4(%rbx)
movzbl -0x5(%rbp),%eax
mov    %al,0x5(%rbx)
movzbl -0x6(%rbp),%eax
mov    %al,0x6(%rbx)
movzbl -0x7(%rbp),%eax
mov    %al,0x7(%rbx)
add    $0x8,%rbx
add    $0xfffffffffffffff8,%rbp
add    $0xfffffffffffffff8,%rsi
jne    1350 <ibitmap_blitfc+0x230>
jmp    12a6 <ibitmap_blitfc+0x186>
nopw   0x0(%rax,%rax,1)
cmpl   $0x0,0x4(%rsp)
je     12a0 <ibitmap_blitfc+0x180>
test   %r15,%r15
je     13e2 <ibitmap_blitfc+0x2c2>
mov    %r15,%rax
mov    %r11,%rdi
mov    0xb0(%rsp),%rsi
jmp    13d2 <ibitmap_blitfc+0x2b2>
add    $0x1,%r12
add    $0xffffffffffffffff,%r13
add    $0xffffffffffffffff,%rdi
add    $0xffffffffffffffff,%rax
je     13e5 <ibitmap_blitfc+0x2c5>
movzbl 0x0(%r13),%ebx
cmp    %sil,%bl
je     13c0 <ibitmap_blitfc+0x2a0>
mov    %bl,(%r12)
jmp    13c0 <ibitmap_blitfc+0x2a0>
mov    %r11,%rdi
mov    %r13,%rbp
mov    %r12,%rbx
cmp    $0x3,%r8
jb     12a6 <ibitmap_blitfc+0x186>
mov    0xb0(%rsp),%rsi
jmp    1412 <ibitmap_blitfc+0x2f2>
nop
add    $0x4,%r12
add    $0xfffffffffffffffc,%r13
add    $0xfffffffffffffffc,%rdi
je     12a0 <ibitmap_blitfc+0x180>
movzbl 0x0(%r13),%eax
cmp    %sil,%al
je     1420 <ibitmap_blitfc+0x300>
mov    %al,(%r12)
movzbl -0x1(%r13),%eax
cmp    %sil,%al
je     142f <ibitmap_blitfc+0x30f>
mov    %al,0x1(%r12)
movzbl -0x2(%r13),%eax
cmp    %sil,%al
je     143e <ibitmap_blitfc+0x31e>
mov    %al,0x2(%r12)
movzbl -0x3(%r13),%eax
cmp    %sil,%al
je     1400 <ibitmap_blitfc+0x2e0>
mov    %al,0x3(%r12)
jmp    1400 <ibitmap_blitfc+0x2e0>
lea    (%r12,%rdx,1),%rbx
mov    0x8(%rsp),%rax
lea    (%rax,%r13,1),%rbp
add    $0xfffffffffffffff1,%r13
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movdqu -0x10(%r13),%xmm1
movdqu 0x0(%r13),%xmm2
movdqa %xmm2,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
packuswb %xmm3,%xmm2
movdqa %xmm1,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm3,%xmm1
movdqu %xmm2,(%r12,%rax,1)
movdqu %xmm1,0x10(%r12,%rax,1)
add    $0x20,%rax
add    $0xffffffffffffffe0,%r13
cmp    %rax,%rdx
jne    1470 <ibitmap_blitfc+0x350>
mov    0x10(%rsp),%rsi
cmp    %r11,%rdx
je     12a6 <ibitmap_blitfc+0x186>
jmp    1301 <ibitmap_blitfc+0x1e1>
test   %edi,%edi
je     1ee7 <ibitmap_blitfc+0xdc7>
mov    %edi,%ecx
mov    0x4(%rsp),%eax
movslq %eax,%rdx
lea    (%rdx,%rdx,1),%rdi
mov    $0x2,%ebp
mov    %rdi,%rsi
mov    %rdi,0x10(%rsp)
sub    %rdi,%rbp
mov    %rbp,0x8(%rsp)
lea    -0x10(%rdx),%rsi
mov    %rsi,0x38(%rsp)
mov    %rsi,%rdi
shr    $0x4,%rdi
add    $0x1,%rdi
mov    %rdx,%r8
and    $0xfffffffffffffff8,%r8
lea    (%r8,%r8,1),%rbp
mov    %eax,%esi
and    $0x7,%esi
mov    %rsi,0x20(%rsp)
mov    %rbp,%rsi
mov    %rbp,0x28(%rsp)
neg    %rbp
mov    %rbp,0x18(%rsp)
mov    0xb0(%rsp),%rsi
movd   %esi,%xmm0
pshuflw $0x0,%xmm0,%xmm0
pshufd $0x0,%xmm0,%xmm0
mov    %rdx,%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsi,0x60(%rsp)
add    %rsi,%rsi
and    $0xf,%eax
mov    %rax,0x50(%rsp)
mov    %rsi,0x58(%rsp)
neg    %rsi
mov    %rsi,0x48(%rsp)
mov    %rdi,%rax
mov    %rdi,0x30(%rsp)
and    $0xfffffffffffffffe,%rdi
mov    %rdi,0x40(%rsp)
pcmpeqd %xmm1,%xmm1
jmp    15de <ibitmap_blitfc+0x4be>
nopl   (%rax)
mov    %r13,%rbp
mov    %r12,%r11
mov    %r14,%rax
add    %r14,%r11
add    %r9,%rbp
mov    %r11,%r12
mov    %rbp,%r13
add    $0xffffffff,%ecx
je     1ee7 <ibitmap_blitfc+0xdc7>
mov    0xb8(%rsp),%eax
test   $0x2,%al
mov    %ecx,%r15d
jne    16f0 <ibitmap_blitfc+0x5d0>
mov    0x4(%rsp),%eax
test   %eax,%eax
je     15c0 <ibitmap_blitfc+0x4a0>
cmp    $0x10,%eax
jb     1626 <ibitmap_blitfc+0x506>
lea    0x2(%r13),%rax
cmp    %rax,%r12
jae    17e3 <ibitmap_blitfc+0x6c3>
mov    0x10(%rsp),%rax
add    %r12,%rax
mov    0x8(%rsp),%rcx
add    %r13,%rcx
cmp    %rax,%rcx
mov    %r15d,%ecx
jae    17e3 <ibitmap_blitfc+0x6c3>
mov    %rdx,%rbx
lea    -0x1(%rbx),%rdi
mov    %rbx,%rax
and    $0x7,%rax
je     1661 <ibitmap_blitfc+0x541>
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movzwl 0x0(%r13),%ecx
mov    %cx,(%r12)
add    $0x2,%r12
add    $0xfffffffffffffffe,%r13
add    $0x1,%rsi
cmp    %rsi,%rax
jne    1640 <ibitmap_blitfc+0x520>
sub    %rsi,%rbx
mov    %r15d,%ecx
mov    %r13,%rbp
mov    %r12,%r11
cmp    $0x7,%rdi
jb     15c6 <ibitmap_blitfc+0x4a6>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzwl 0x0(%r13),%eax
mov    %ax,(%r12)
movzwl -0x2(%r13),%eax
mov    %ax,0x2(%r12)
movzwl -0x4(%r13),%eax
mov    %ax,0x4(%r12)
movzwl -0x6(%r13),%eax
mov    %ax,0x6(%r12)
movzwl -0x8(%r13),%eax
mov    %ax,0x8(%r12)
movzwl -0xa(%r13),%eax
mov    %ax,0xa(%r12)
movzwl -0xc(%r13),%eax
mov    %ax,0xc(%r12)
movzwl -0xe(%r13),%eax
mov    %ax,0xe(%r12)
add    $0x10,%r12
add    $0xfffffffffffffff0,%r13
add    $0xfffffffffffffff8,%rbx
jne    1680 <ibitmap_blitfc+0x560>
jmp    15c0 <ibitmap_blitfc+0x4a0>
nopw   0x0(%rax,%rax,1)
mov    0x4(%rsp),%eax
test   %eax,%eax
je     15c0 <ibitmap_blitfc+0x4a0>
cmp    $0x8,%eax
jb     172a <ibitmap_blitfc+0x60a>
lea    0x2(%r13),%rax
cmp    %rax,%r12
jae    1801 <ibitmap_blitfc+0x6e1>
mov    0x10(%rsp),%rax
add    %r12,%rax
mov    0x8(%rsp),%rcx
add    %r13,%rcx
cmp    %rax,%rcx
mov    %r15d,%ecx
jae    1801 <ibitmap_blitfc+0x6e1>
mov    %r12,%r11
mov    %rdx,%rbx
mov    %r13,%rbp
lea    -0x1(%rbx),%rdi
mov    %rbx,%rax
and    $0x3,%rax
je     1781 <ibitmap_blitfc+0x661>
mov    %rdx,%r12
xor    %esi,%esi
jmp    1761 <ibitmap_blitfc+0x641>
nopw   0x0(%rax,%rax,1)
add    $0x2,%r11
add    $0xfffffffffffffffe,%rbp
add    $0x1,%rsi
cmp    %rsi,%rax
je     1778 <ibitmap_blitfc+0x658>
movzwl 0x0(%rbp),%ecx
mov    0xb0(%rsp),%rdx
cmp    %dx,%cx
je     1750 <ibitmap_blitfc+0x630>
mov    %cx,(%r11)
jmp    1750 <ibitmap_blitfc+0x630>
sub    %rsi,%rbx
mov    %r15d,%ecx
mov    %r12,%rdx
cmp    $0x3,%rdi
jae    17a2 <ibitmap_blitfc+0x682>
jmp    15c6 <ibitmap_blitfc+0x4a6>
nopl   0x0(%rax)
add    $0x8,%r11
add    $0xfffffffffffffff8,%rbp
add    $0xfffffffffffffffc,%rbx
je     15c6 <ibitmap_blitfc+0x4a6>
movzwl 0x0(%rbp),%eax
mov    0xb0(%rsp),%rsi
cmp    %si,%ax
je     17b7 <ibitmap_blitfc+0x697>
mov    %ax,(%r11)
movzwl -0x2(%rbp),%eax
cmp    %si,%ax
je     17c5 <ibitmap_blitfc+0x6a5>
mov    %ax,0x2(%r11)
movzwl -0x4(%rbp),%eax
cmp    %si,%ax
je     17d3 <ibitmap_blitfc+0x6b3>
mov    %ax,0x4(%r11)
movzwl -0x6(%rbp),%eax
cmp    %si,%ax
je     1790 <ibitmap_blitfc+0x670>
mov    %ax,0x6(%r11)
jmp    1790 <ibitmap_blitfc+0x670>
cmpq   $0x10,0x38(%rsp)
jae    190a <ibitmap_blitfc+0x7ea>
xor    %ebp,%ebp
testb  $0x1,0x30(%rsp)
jne    19a3 <ibitmap_blitfc+0x883>
jmp    19e4 <ibitmap_blitfc+0x8c4>
mov    0x28(%rsp),%rax
lea    (%r12,%rax,1),%r11
mov    0x18(%rsp),%rax
lea    (%rax,%r13,1),%rbp
add    $0xfffffffffffffff2,%r13
xor    %ebx,%ebx
jmp    1831 <ibitmap_blitfc+0x711>
nopl   0x0(%rax,%rax,1)
add    $0x8,%rbx
add    $0xfffffffffffffff0,%r13
cmp    %rbx,%r8
je     18f7 <ibitmap_blitfc+0x7d7>
movdqu 0x0(%r13),%xmm2
pshufd $0x4e,%xmm2,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
pcmpeqw %xmm0,%xmm3
movd   %xmm3,%eax
not    %eax
test   $0x1,%al
je     1861 <ibitmap_blitfc+0x741>
pextrw $0x7,%xmm2,%ecx
mov    %cx,(%r12,%rbx,2)
mov    %r15d,%ecx
shr    $0x10,%eax
test   $0x1,%al
je     1873 <ibitmap_blitfc+0x753>
pextrw $0x6,%xmm2,%eax
mov    %ax,0x2(%r12,%rbx,2)
pxor   %xmm1,%xmm3
pextrw $0x2,%xmm3,%eax
test   $0x1,%al
je     188b <ibitmap_blitfc+0x76b>
pextrw $0x5,%xmm2,%eax
mov    %ax,0x4(%r12,%rbx,2)
pextrw $0x3,%xmm3,%eax
test   $0x1,%al
je     189f <ibitmap_blitfc+0x77f>
pextrw $0x4,%xmm2,%eax
mov    %ax,0x6(%r12,%rbx,2)
pextrw $0x4,%xmm3,%eax
test   $0x1,%al
je     18b3 <ibitmap_blitfc+0x793>
pextrw $0x3,%xmm2,%eax
mov    %ax,0x8(%r12,%rbx,2)
pextrw $0x5,%xmm3,%eax
test   $0x1,%al
je     18c7 <ibitmap_blitfc+0x7a7>
pextrw $0x2,%xmm2,%eax
mov    %ax,0xa(%r12,%rbx,2)
pextrw $0x6,%xmm3,%eax
test   $0x1,%al
je     18db <ibitmap_blitfc+0x7bb>
pextrw $0x1,%xmm2,%eax
mov    %ax,0xc(%r12,%rbx,2)
pextrw $0x7,%xmm3,%eax
test   $0x1,%al
je     1820 <ibitmap_blitfc+0x700>
movd   %xmm2,%eax
mov    %ax,0xe(%r12,%rbx,2)
jmp    1820 <ibitmap_blitfc+0x700>
mov    0x20(%rsp),%rbx
cmp    %rdx,%r8
je     15c6 <ibitmap_blitfc+0x4a6>
jmp    1733 <ibitmap_blitfc+0x613>
lea    0x30(%r12),%rdi
mov    0x40(%rsp),%rbx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
movdqu -0x1e(%r13,%rbp,2),%xmm2
movdqu -0xe(%r13,%rbp,2),%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
movdqu %xmm3,-0x30(%rdi)
movdqu %xmm2,-0x20(%rdi)
movdqu -0x3e(%r13,%rbp,2),%xmm2
movdqu -0x2e(%r13,%rbp,2),%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
movdqu %xmm3,-0x10(%rdi)
movdqu %xmm2,(%rdi)
add    $0x40,%rdi
add    $0xffffffffffffffe0,%rbp
add    $0xfffffffffffffffe,%rbx
jne    1920 <ibitmap_blitfc+0x800>
neg    %rbp
testb  $0x1,0x30(%rsp)
je     19e4 <ibitmap_blitfc+0x8c4>
mov    %r13,%rcx
sub    %rbp,%rcx
sub    %rbp,%rcx
movdqu -0x1e(%rcx),%xmm2
movdqu -0xe(%rcx),%xmm3
mov    %r15d,%ecx
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
movdqu %xmm3,(%r12,%rbp,2)
movdqu %xmm2,0x10(%r12,%rbp,2)
add    0x58(%rsp),%r12
add    0x48(%rsp),%r13
mov    0x50(%rsp),%rbx
mov    %r13,%rbp
mov    %r12,%r11
cmp    %rdx,0x60(%rsp)
je     15c6 <ibitmap_blitfc+0x4a6>
jmp    1629 <ibitmap_blitfc+0x509>
test   %edi,%edi
je     1ee7 <ibitmap_blitfc+0xdc7>
mov    0xb0(%rsp),%rcx
movzwl %cx,%eax
shl    $0x8,%eax
shr    $0x10,%ecx
movzbl %cl,%edx
or     %eax,%edx
movslq 0x4(%rsp),%r11
lea    -0x1(%r11),%r8
jmp    1a4f <ibitmap_blitfc+0x92f>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    %rbp,%r12
add    %r9,%r13
add    $0xffffffff,%edi
je     1ee7 <ibitmap_blitfc+0xdc7>
mov    0xb8(%rsp),%eax
test   $0x2,%al
jne    1a80 <ibitmap_blitfc+0x960>
mov    0x4(%rsp),%ecx
test   %ecx,%ecx
mov    %r14,%rbp
je     1a40 <ibitmap_blitfc+0x920>
test   $0x1,%r11b
jne    1aa3 <ibitmap_blitfc+0x983>
mov    %r11,%rax
cmp    $0x1,%ecx
jne    1ae0 <ibitmap_blitfc+0x9c0>
jmp    1a40 <ibitmap_blitfc+0x920>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x4(%rsp),%ebx
test   %ebx,%ebx
mov    %r14,%rbp
je     1a40 <ibitmap_blitfc+0x920>
test   $0x1,%r11b
jne    1b2e <ibitmap_blitfc+0xa0e>
mov    %r11,%rsi
cmp    $0x1,%ebx
jne    1b82 <ibitmap_blitfc+0xa62>
jmp    1a40 <ibitmap_blitfc+0x920>
mov    0x0(%r13),%al
mov    %al,(%r12)
mov    0x1(%r13),%al
mov    %al,0x1(%r12)
mov    0x2(%r13),%al
mov    %al,0x2(%r12)
add    $0x3,%r12
add    $0xfffffffffffffffd,%r13
mov    %r8,%rax
cmp    $0x1,%ecx
je     1a40 <ibitmap_blitfc+0x920>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl 0x0(%r13),%ecx
mov    %cl,(%r12)
movzbl 0x1(%r13),%ecx
mov    %cl,0x1(%r12)
movzbl 0x2(%r13),%ecx
mov    %cl,0x2(%r12)
movzbl -0x3(%r13),%ecx
mov    %cl,0x3(%r12)
movzbl -0x2(%r13),%ecx
mov    %cl,0x4(%r12)
movzbl -0x1(%r13),%ecx
mov    %cl,0x5(%r12)
add    $0x6,%r12
add    $0xfffffffffffffffa,%r13
add    $0xfffffffffffffffe,%rax
jne    1ae0 <ibitmap_blitfc+0x9c0>
jmp    1a40 <ibitmap_blitfc+0x920>
movzwl 0x0(%r13),%eax
mov    %eax,%ecx
shl    $0x8,%ecx
movzbl 0x2(%r13),%esi
or     %ecx,%esi
cmp    %edx,%esi
je     1b59 <ibitmap_blitfc+0xa39>
mov    %al,(%r12)
mov    0x1(%r13),%al
mov    %al,0x1(%r12)
mov    0x2(%r13),%al
mov    %al,0x2(%r12)
add    $0x3,%r12
add    $0xfffffffffffffffd,%r13
mov    %r8,%rsi
cmp    $0x1,%ebx
jne    1b82 <ibitmap_blitfc+0xa62>
jmp    1a40 <ibitmap_blitfc+0x920>
xchg   %ax,%ax
add    $0x6,%r12
add    $0xfffffffffffffffa,%r13
add    $0xfffffffffffffffe,%rsi
je     1a40 <ibitmap_blitfc+0x920>
movzwl 0x0(%r13),%eax
mov    %eax,%ecx
shl    $0x8,%ecx
movzbl 0x2(%r13),%ebx
or     %ecx,%ebx
cmp    %edx,%ebx
je     1baf <ibitmap_blitfc+0xa8f>
mov    %al,(%r12)
movzbl 0x1(%r13),%eax
mov    %al,0x1(%r12)
movzbl 0x2(%r13),%eax
mov    %al,0x2(%r12)
movzwl -0x3(%r13),%eax
mov    %eax,%ecx
shl    $0x8,%ecx
movzbl -0x1(%r13),%ebx
or     %ecx,%ebx
cmp    %edx,%ebx
je     1b70 <ibitmap_blitfc+0xa50>
mov    %al,0x3(%r12)
movzbl -0x2(%r13),%eax
mov    %al,0x4(%r12)
movzbl -0x1(%r13),%eax
mov    %al,0x5(%r12)
jmp    1b70 <ibitmap_blitfc+0xa50>
test   %edi,%edi
je     1ee7 <ibitmap_blitfc+0xdc7>
mov    %edi,%r15d
mov    0x4(%rsp),%eax
movslq %eax,%r10
lea    0x0(,%r10,4),%rdi
mov    $0x4,%ebp
mov    %rdi,%rsi
mov    %rdi,0x10(%rsp)
sub    %rdi,%rbp
mov    %rbp,0x8(%rsp)
lea    -0x1(%r10),%rsi
lea    -0x8(%r10),%r11
mov    %r11,0x38(%rsp)
shr    $0x3,%r11
add    $0x1,%r11
mov    %eax,%edi
and    $0x3,%edi
mov    %r10,%rdx
and    $0xfffffffffffffff8,%rdx
mov    %rdx,0x30(%rsp)
lea    0x0(,%rdx,4),%rdx
and    $0x7,%eax
mov    %rax,0x28(%rsp)
mov    %rdx,%rax
neg    %rax
mov    %rax,0x20(%rsp)
mov    %r11,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,0x18(%rsp)
jmp    1c73 <ibitmap_blitfc+0xb53>
nopl   (%rax)
mov    %r14,%rax
add    %r14,%r12
add    %r9,%r13
add    $0xffffffff,%r15d
je     1ee7 <ibitmap_blitfc+0xdc7>
mov    0xb8(%rsp),%eax
test   $0x2,%al
jne    1d60 <ibitmap_blitfc+0xc40>
mov    0x4(%rsp),%eax
test   %eax,%eax
je     1c60 <ibitmap_blitfc+0xb40>
cmp    $0x8,%eax
jb     1cb5 <ibitmap_blitfc+0xb95>
lea    0x4(%r13),%rax
cmp    %rax,%r12
jae    1e17 <ibitmap_blitfc+0xcf7>
mov    0x10(%rsp),%rax
add    %r12,%rax
mov    0x8(%rsp),%rbp
add    %r13,%rbp
cmp    %rax,%rbp
jae    1e17 <ibitmap_blitfc+0xcf7>
mov    %r10,%rbx
lea    -0x1(%rbx),%r8
mov    %rbx,%rax
and    $0x7,%rax
je     1cec <ibitmap_blitfc+0xbcc>
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
mov    0x0(%r13),%ecx
mov    %ecx,(%r12)
add    $0x4,%r12
add    $0xfffffffffffffffc,%r13
add    $0x1,%rbp
cmp    %rbp,%rax
jne    1cd0 <ibitmap_blitfc+0xbb0>
sub    %rbp,%rbx
cmp    $0x7,%r8
jb     1c60 <ibitmap_blitfc+0xb40>
cs nopw 0x0(%rax,%rax,1)
mov    0x0(%r13),%eax
mov    %eax,(%r12)
mov    -0x4(%r13),%eax
mov    %eax,0x4(%r12)
mov    -0x8(%r13),%eax
mov    %eax,0x8(%r12)
mov    -0xc(%r13),%eax
mov    %eax,0xc(%r12)
mov    -0x10(%r13),%eax
mov    %eax,0x10(%r12)
mov    -0x14(%r13),%eax
mov    %eax,0x14(%r12)
mov    -0x18(%r13),%eax
mov    %eax,0x18(%r12)
mov    -0x1c(%r13),%eax
mov    %eax,0x1c(%r12)
add    $0x20,%r12
add    $0xffffffffffffffe0,%r13
add    $0xfffffffffffffff8,%rbx
jne    1d00 <ibitmap_blitfc+0xbe0>
jmp    1c60 <ibitmap_blitfc+0xb40>
nopw   0x0(%rax,%rax,1)
cmpl   $0x0,0x4(%rsp)
mov    0xb0(%rsp),%rbp
je     1c60 <ibitmap_blitfc+0xb40>
test   %rdi,%rdi
je     1dc0 <ibitmap_blitfc+0xca0>
xor    %eax,%eax
jmp    1d91 <ibitmap_blitfc+0xc71>
nopl   0x0(%rax)
add    $0x4,%r12
add    $0xfffffffffffffffc,%r13
add    $0x1,%rax
cmp    %rax,%rdi
je     1da7 <ibitmap_blitfc+0xc87>
mov    0x0(%r13),%ebp
mov    0xb0(%rsp),%rbx
cmp    %ebx,%ebp
je     1d80 <ibitmap_blitfc+0xc60>
mov    %ebp,(%r12)
jmp    1d80 <ibitmap_blitfc+0xc60>
mov    %r10,%rbx
sub    %rax,%rbx
mov    0xb0(%rsp),%rbp
cmp    $0x3,%rsi
jae    1de2 <ibitmap_blitfc+0xcc2>
jmp    1c60 <ibitmap_blitfc+0xb40>
mov    %r10,%rbx
cmp    $0x3,%rsi
jae    1de2 <ibitmap_blitfc+0xcc2>
jmp    1c60 <ibitmap_blitfc+0xb40>
xchg   %ax,%ax
add    $0x10,%r12
add    $0xfffffffffffffff0,%r13
add    $0xfffffffffffffffc,%rbx
je     1c60 <ibitmap_blitfc+0xb40>
mov    0x0(%r13),%eax
cmp    %ebp,%eax
je     1dee <ibitmap_blitfc+0xcce>
mov    %eax,(%r12)
mov    -0x4(%r13),%eax
cmp    %ebp,%eax
je     1dfb <ibitmap_blitfc+0xcdb>
mov    %eax,0x4(%r12)
mov    -0x8(%r13),%eax
cmp    %ebp,%eax
je     1e08 <ibitmap_blitfc+0xce8>
mov    %eax,0x8(%r12)
mov    -0xc(%r13),%eax
cmp    %ebp,%eax
je     1dd0 <ibitmap_blitfc+0xcb0>
mov    %eax,0xc(%r12)
jmp    1dd0 <ibitmap_blitfc+0xcb0>
cmpq   $0x8,0x38(%rsp)
jae    1e2c <ibitmap_blitfc+0xd0c>
xor    %ebx,%ebx
test   $0x1,%r11b
jne    1e9b <ibitmap_blitfc+0xd7b>
jmp    1eca <ibitmap_blitfc+0xdaa>
lea    0x30(%r12),%rbp
mov    0x18(%rsp),%rax
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movdqu -0x1c(%r13,%rbx,4),%xmm0
movdqu -0xc(%r13,%rbx,4),%xmm1
pshufd $0x1b,%xmm1,%xmm1
pshufd $0x1b,%xmm0,%xmm0
movdqu %xmm1,-0x30(%rbp)
movdqu %xmm0,-0x20(%rbp)
movdqu -0x3c(%r13,%rbx,4),%xmm0
movdqu -0x2c(%r13,%rbx,4),%xmm1
pshufd $0x1b,%xmm1,%xmm1
pshufd $0x1b,%xmm0,%xmm0
movdqu %xmm1,-0x10(%rbp)
movdqu %xmm0,0x0(%rbp)
add    $0x40,%rbp
add    $0xfffffffffffffff0,%rbx
add    $0xfffffffffffffffe,%rax
jne    1e40 <ibitmap_blitfc+0xd20>
neg    %rbx
test   $0x1,%r11b
je     1eca <ibitmap_blitfc+0xdaa>
lea    0x0(,%rbx,4),%rax
mov    %r13,%rbp
sub    %rax,%rbp
movdqu -0x1c(%rbp),%xmm0
movdqu -0xc(%rbp),%xmm1
pshufd $0x1b,%xmm1,%xmm1
pshufd $0x1b,%xmm0,%xmm0
movdqu %xmm1,(%r12,%rbx,4)
movdqu %xmm0,0x10(%r12,%rbx,4)
add    %rdx,%r12
add    0x20(%rsp),%r13
mov    0x28(%rsp),%rbx
cmp    %r10,0x30(%rsp)
je     1c60 <ibitmap_blitfc+0xb40>
jmp    1cb8 <ibitmap_blitfc+0xb98>
xor    %eax,%eax
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define i32 @ibitmap_blitfc(i8* %0, i64 %1, i8* %2, i64 %3, i32 %4, i32 %5, i32 %6, i64 %7, i64 %8, i32 %9) {
%11 = and i32 %9, 6
%12 = icmp eq i32 %11, 0
br i1 %12, label %13, label %26
13: ; preds = %10
%14 = icmp eq i32 %5, 0
br i1 %14, label %946, label %15
15: ; preds = %13
%16 = sub i64 0, %3
br label %17
17: ; preds = %15, %17
%18 = phi i8* [ %0, %15 ], [ %22, %17 ]
%19 = phi i8* [ %2, %15 ], [ %23, %17 ]
%20 = phi i32 [ %5, %15 ], [ %24, %17 ]
%21 = tail call i32 @memcpy(i8* %18, i8* %19, i64 %7)
%22 = getelementptr inbounds i8, i8* %18, i64 %1
%23 = getelementptr inbounds i8, i8* %19, i64 %16
%24 = add nsw i32 %20, -1
%25 = icmp eq i32 %24, 0
br i1 %25, label %946, label %17
26: ; preds = %10
%27 = and i32 %9, 2
%28 = icmp eq i32 %27, 0
%29 = icmp eq i32 %11, 2
br i1 %29, label %30, label %43
30: ; preds = %26
%31 = icmp eq i32 %5, 0
br i1 %31, label %946, label %32
32: ; preds = %30
%33 = sub i64 0, %3
br label %34
34: ; preds = %32, %34
%35 = phi i8* [ %0, %32 ], [ %39, %34 ]
%36 = phi i8* [ %2, %32 ], [ %40, %34 ]
%37 = phi i32 [ %5, %32 ], [ %41, %34 ]
%38 = tail call i32 @ibitmap_blitmc(i8* %35, i64 %1, i8* %36, i64 %3, i32 %4, i32 1, i32 %6, i64 %7, i64 %8)
%39 = getelementptr inbounds i8, i8* %35, i64 %1
%40 = getelementptr inbounds i8, i8* %36, i64 %33
%41 = add nsw i32 %37, -1
%42 = icmp eq i32 %41, 0
br i1 %42, label %946, label %34
43: ; preds = %26
%44 = sext i32 %6 to i64
%45 = sub nsw i64 %7, %44
%46 = getelementptr inbounds i8, i8* %2, i64 %45
%47 = sub nsw i64 %1, %7
%48 = and i32 %9, 8
%49 = icmp eq i32 %48, 0
%50 = sub i64 0, %3
%51 = select i1 %49, i64 %3, i64 %50
%52 = add i64 %51, %7
switch i32 %6, label %946 [
i32 1, label %109
i32 2, label %78
i32 3, label %585
i32 4, label %53
]
53: ; preds = %43
%54 = icmp eq i32 %5, 0
br i1 %54, label %946, label %55
55: ; preds = %53
%56 = trunc i64 %8 to i32
%57 = sext i32 %4 to i64
%58 = icmp eq i32 %4, 0
%59 = shl nsw i64 %57, 2
%60 = sub nsw i64 4, %59
%61 = add nsw i64 %57, -1
%62 = add nsw i64 %57, -8
%63 = lshr i64 %62, 3
%64 = add nuw nsw i64 %63, 1
%65 = and i64 %57, 3
%66 = icmp eq i64 %65, 0
%67 = icmp ult i64 %61, 3
%68 = icmp ult i32 %4, 8
%69 = and i64 %57, -8
%70 = shl nsw i64 %69, 2
%71 = and i64 %57, 7
%72 = mul nsw i64 %69, -4
%73 = and i64 %64, 1
%74 = icmp ult i64 %62, 8
%75 = and i64 %64, 4611686018427387902
%76 = icmp eq i64 %73, 0
%77 = icmp eq i64 %69, %57
br label %729
78: ; preds = %43
%79 = icmp eq i32 %5, 0
br i1 %79, label %946, label %80
80: ; preds = %78
%81 = sext i32 %4 to i64
%82 = icmp eq i32 %4, 0
%83 = trunc i64 %8 to i16
%84 = shl nsw i64 %81, 1
%85 = sub nsw i64 2, %84
%86 = shl nsw i64 %81, 1
%87 = sub nsw i64 2, %86
%88 = add nsw i64 %81, -16
%89 = lshr i64 %88, 4
%90 = add nuw nsw i64 %89, 1
%91 = icmp ult i32 %4, 8
%92 = and i64 %81, -8
%93 = shl nsw i64 %92, 1
%94 = and i64 %81, 7
%95 = mul nsw i64 %92, -2
%96 = insertelement <8 x i16> poison, i16 %83, i64 0
%97 = shufflevector <8 x i16> %96, <8 x i16> poison, <8 x i32> zeroinitializer
%98 = icmp eq i64 %92, %81
%99 = icmp ult i32 %4, 16
%100 = and i64 %81, -16
%101 = shl nsw i64 %100, 1
%102 = and i64 %81, 15
%103 = mul nsw i64 %100, -2
%104 = and i64 %90, 1
%105 = icmp ult i64 %88, 16
%106 = and i64 %90, 2305843009213693950
%107 = icmp eq i64 %104, 0
%108 = icmp eq i64 %100, %81
br label %275
109: ; preds = %43
%110 = icmp eq i32 %5, 0
br i1 %110, label %946, label %111
111: ; preds = %109
%112 = sext i32 %4 to i64
%113 = icmp eq i32 %4, 0
%114 = trunc i64 %8 to i8
%115 = sub nsw i64 1, %112
%116 = add nsw i64 %112, -1
%117 = and i64 %112, 3
%118 = icmp eq i64 %117, 0
%119 = icmp ult i64 %116, 3
%120 = icmp ult i32 %4, 32
%121 = and i64 %112, -32
%122 = and i64 %112, 31
%123 = sub nsw i64 0, %121
%124 = icmp eq i64 %121, %112
br label %125
125: ; preds = %111, %268
%126 = phi i8* [ %0, %111 ], [ %271, %268 ]
%127 = phi i8* [ %46, %111 ], [ %272, %268 ]
%128 = phi i32 [ %5, %111 ], [ %273, %268 ]
br i1 %28, label %181, label %129
129: ; preds = %125
br i1 %113, label %268, label %130
130: ; preds = %129
br i1 %118, label %145, label %131
131: ; preds = %130, %139
%132 = phi i8* [ %140, %139 ], [ %126, %130 ]
%133 = phi i64 [ %142, %139 ], [ %112, %130 ]
%134 = phi i8* [ %141, %139 ], [ %127, %130 ]
%135 = phi i64 [ %143, %139 ], [ 0, %130 ]
%136 = load i8, i8* %134
%137 = icmp eq i8 %136, %114
br i1 %137, label %139, label %138
138: ; preds = %131
store i8 %136, i8* %132
br label %139
139: ; preds = %138, %131
%140 = getelementptr inbounds i8, i8* %132, i64 1
%141 = getelementptr inbounds i8, i8* %134, i64 -1
%142 = add nsw i64 %133, -1
%143 = add i64 %135, 1
%144 = icmp eq i64 %143, %117
br i1 %144, label %145, label %131
145: ; preds = %139, %130
%146 = phi i8* [ undef, %130 ], [ %140, %139 ]
%147 = phi i8* [ undef, %130 ], [ %141, %139 ]
%148 = phi i8* [ %126, %130 ], [ %140, %139 ]
%149 = phi i64 [ %112, %130 ], [ %142, %139 ]
%150 = phi i8* [ %127, %130 ], [ %141, %139 ]
br i1 %119, label %268, label %151
151: ; preds = %145, %176
%152 = phi i8* [ %177, %176 ], [ %148, %145 ]
%153 = phi i64 [ %179, %176 ], [ %149, %145 ]
%154 = phi i8* [ %178, %176 ], [ %150, %145 ]
%155 = load i8, i8* %154
%156 = icmp eq i8 %155, %114
br i1 %156, label %158, label %157
157: ; preds = %151
store i8 %155, i8* %152
br label %158
158: ; preds = %157, %151
%159 = getelementptr inbounds i8, i8* %154, i64 -1
%160 = load i8, i8* %159
%161 = icmp eq i8 %160, %114
br i1 %161, label %164, label %162
162: ; preds = %158
%163 = getelementptr inbounds i8, i8* %152, i64 1
store i8 %160, i8* %163
br label %164
164: ; preds = %162, %158
%165 = getelementptr inbounds i8, i8* %154, i64 -2
%166 = load i8, i8* %165
%167 = icmp eq i8 %166, %114
br i1 %167, label %170, label %168
168: ; preds = %164
%169 = getelementptr inbounds i8, i8* %152, i64 2
store i8 %166, i8* %169
br label %170
170: ; preds = %168, %164
%171 = getelementptr inbounds i8, i8* %154, i64 -3
%172 = load i8, i8* %171
%173 = icmp eq i8 %172, %114
br i1 %173, label %176, label %174
174: ; preds = %170
%175 = getelementptr inbounds i8, i8* %152, i64 3
store i8 %172, i8* %175
br label %176
176: ; preds = %174, %170
%177 = getelementptr inbounds i8, i8* %152, i64 4
%178 = getelementptr inbounds i8, i8* %154, i64 -4
%179 = add nsw i64 %153, -4
%180 = icmp eq i64 %179, 0
br i1 %180, label %268, label %151
181: ; preds = %125
br i1 %113, label %268, label %182
182: ; preds = %181
br i1 %120, label %213, label %183
183: ; preds = %182
%184 = getelementptr i8, i8* %126, i64 %112
%185 = getelementptr i8, i8* %127, i64 %115
%186 = getelementptr i8, i8* %127, i64 1
%187 = icmp ult i8* %126, %186
%188 = icmp ult i8* %185, %184
%189 = and i1 %187, %188
br i1 %189, label %213, label %190
190: ; preds = %183
%191 = getelementptr i8, i8* %126, i64 %121
%192 = getelementptr i8, i8* %127, i64 %123
br label %193
193: ; preds = %193, %190
%194 = phi i64 [ 0, %190 ], [ %210, %193 ]
%195 = getelementptr i8, i8* %126, i64 %194
%196 = sub i64 0, %194
%197 = getelementptr i8, i8* %127, i64 %196
%198 = getelementptr i8, i8* %197, i64 -15
%199 = bitcast i8* %198 to <16 x i8>*
%200 = load <16 x i8>, <16 x i8>* %199
%201 = shufflevector <16 x i8> %200, <16 x i8> poison, <16 x i32> <i32 15, i32 14, i32 13, i32 12, i32 11, i32 10, i32 9, i32 8, i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%202 = getelementptr i8, i8* %197, i64 -16
%203 = getelementptr i8, i8* %202, i64 -15
%204 = bitcast i8* %203 to <16 x i8>*
%205 = load <16 x i8>, <16 x i8>* %204
%206 = shufflevector <16 x i8> %205, <16 x i8> poison, <16 x i32> <i32 15, i32 14, i32 13, i32 12, i32 11, i32 10, i32 9, i32 8, i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%207 = bitcast i8* %195 to <16 x i8>*
store <16 x i8> %201, <16 x i8>* %207
%208 = getelementptr i8, i8* %195, i64 16
%209 = bitcast i8* %208 to <16 x i8>*
store <16 x i8> %206, <16 x i8>* %209
%210 = add nuw i64 %194, 32
%211 = icmp eq i64 %210, %121
br i1 %211, label %212, label %193
212: ; preds = %193
br i1 %124, label %268, label %213
213: ; preds = %183, %182, %212
%214 = phi i8* [ %126, %183 ], [ %126, %182 ], [ %191, %212 ]
%215 = phi i64 [ %112, %183 ], [ %112, %182 ], [ %122, %212 ]
%216 = phi i8* [ %127, %183 ], [ %127, %182 ], [ %192, %212 ]
%217 = add nsw i64 %215, -1
%218 = and i64 %215, 7
%219 = icmp eq i64 %218, 0
br i1 %219, label %231, label %220
220: ; preds = %213, %220
%221 = phi i8* [ %226, %220 ], [ %214, %213 ]
%222 = phi i64 [ %228, %220 ], [ %215, %213 ]
%223 = phi i8* [ %227, %220 ], [ %216, %213 ]
%224 = phi i64 [ %229, %220 ], [ 0, %213 ]
%225 = load i8, i8* %223
store i8 %225, i8* %221
%226 = getelementptr inbounds i8, i8* %221, i64 1
%227 = getelementptr inbounds i8, i8* %223, i64 -1
%228 = add nsw i64 %222, -1
%229 = add i64 %224, 1
%230 = icmp eq i64 %229, %218
br i1 %230, label %231, label %220
231: ; preds = %220, %213
%232 = phi i8* [ undef, %213 ], [ %226, %220 ]
%233 = phi i8* [ undef, %213 ], [ %227, %220 ]
%234 = phi i8* [ %214, %213 ], [ %226, %220 ]
%235 = phi i64 [ %215, %213 ], [ %228, %220 ]
%236 = phi i8* [ %216, %213 ], [ %227, %220 ]
%237 = icmp ult i64 %217, 7
br i1 %237, label %268, label %238
238: ; preds = %231, %238
%239 = phi i8* [ %264, %238 ], [ %234, %231 ]
%240 = phi i64 [ %266, %238 ], [ %235, %231 ]
%241 = phi i8* [ %265, %238 ], [ %236, %231 ]
%242 = load i8, i8* %241
store i8 %242, i8* %239
%243 = getelementptr inbounds i8, i8* %239, i64 1
%244 = getelementptr inbounds i8, i8* %241, i64 -1
%245 = load i8, i8* %244
store i8 %245, i8* %243
%246 = getelementptr inbounds i8, i8* %239, i64 2
%247 = getelementptr inbounds i8, i8* %241, i64 -2
%248 = load i8, i8* %247
store i8 %248, i8* %246
%249 = getelementptr inbounds i8, i8* %239, i64 3
%250 = getelementptr inbounds i8, i8* %241, i64 -3
%251 = load i8, i8* %250
store i8 %251, i8* %249
%252 = getelementptr inbounds i8, i8* %239, i64 4
%253 = getelementptr inbounds i8, i8* %241, i64 -4
%254 = load i8, i8* %253
store i8 %254, i8* %252
%255 = getelementptr inbounds i8, i8* %239, i64 5
%256 = getelementptr inbounds i8, i8* %241, i64 -5
%257 = load i8, i8* %256
store i8 %257, i8* %255
%258 = getelementptr inbounds i8, i8* %239, i64 6
%259 = getelementptr inbounds i8, i8* %241, i64 -6
%260 = load i8, i8* %259
store i8 %260, i8* %258
%261 = getelementptr inbounds i8, i8* %239, i64 7
%262 = getelementptr inbounds i8, i8* %241, i64 -7
%263 = load i8, i8* %262
store i8 %263, i8* %261
%264 = getelementptr inbounds i8, i8* %239, i64 8
%265 = getelementptr inbounds i8, i8* %241, i64 -8
%266 = add nsw i64 %240, -8
%267 = icmp eq i64 %266, 0
br i1 %267, label %268, label %238
268: ; preds = %145, %176, %231, %238, %212, %129, %181
%269 = phi i8* [ %127, %181 ], [ %127, %129 ], [ %192, %212 ], [ %233, %231 ], [ %265, %238 ], [ %147, %145 ], [ %178, %176 ]
%270 = phi i8* [ %126, %181 ], [ %126, %129 ], [ %191, %212 ], [ %232, %231 ], [ %264, %238 ], [ %146, %145 ], [ %177, %176 ]
%271 = getelementptr inbounds i8, i8* %270, i64 %47
%272 = getelementptr inbounds i8, i8* %269, i64 %52
%273 = add nsw i32 %128, -1
%274 = icmp eq i32 %273, 0
br i1 %274, label %946, label %125
275: ; preds = %80, %578
%276 = phi i8* [ %0, %80 ], [ %581, %578 ]
%277 = phi i8* [ %46, %80 ], [ %582, %578 ]
%278 = phi i32 [ %5, %80 ], [ %583, %578 ]
br i1 %28, label %434, label %279
279: ; preds = %275
br i1 %82, label %578, label %280
280: ; preds = %279
br i1 %91, label %366, label %281
281: ; preds = %280
%282 = getelementptr i8, i8* %276, i64 %86
%283 = getelementptr i8, i8* %277, i64 %87
%284 = getelementptr i8, i8* %277, i64 2
%285 = icmp ult i8* %276, %284
%286 = icmp ult i8* %283, %282
%287 = and i1 %285, %286
br i1 %287, label %366, label %288
288: ; preds = %281
%289 = getelementptr i8, i8* %276, i64 %93
%290 = getelementptr i8, i8* %277, i64 %95
%291 = getelementptr i8, i8* %277, i64 -14
br label %292
292: ; preds = %362, %288
%293 = phi i64 [ 0, %288 ], [ %363, %362 ]
%294 = shl i64 %293, 1
%295 = or i64 %294, 2
%296 = getelementptr i8, i8* %276, i64 %295
%297 = shl i64 %293, 1
%298 = or i64 %297, 4
%299 = getelementptr i8, i8* %276, i64 %298
%300 = shl i64 %293, 1
%301 = or i64 %300, 6
%302 = getelementptr i8, i8* %276, i64 %301
%303 = shl i64 %293, 1
%304 = or i64 %303, 8
%305 = getelementptr i8, i8* %276, i64 %304
%306 = shl i64 %293, 1
%307 = or i64 %306, 10
%308 = getelementptr i8, i8* %276, i64 %307
%309 = shl i64 %293, 1
%310 = or i64 %309, 12
%311 = getelementptr i8, i8* %276, i64 %310
%312 = shl i64 %293, 1
%313 = or i64 %312, 14
%314 = getelementptr i8, i8* %276, i64 %313
%315 = mul i64 %293, -2
%316 = getelementptr i8, i8* %291, i64 %315
%317 = bitcast i8* %316 to <8 x i16>*
%318 = load <8 x i16>, <8 x i16>* %317
%319 = shufflevector <8 x i16> %318, <8 x i16> poison, <8 x i32> <i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%320 = icmp ne <8 x i16> %319, %97
%321 = extractelement <8 x i1> %320, i64 0
br i1 %321, label %322, label %327
322: ; preds = %292
%323 = shl i64 %293, 1
%324 = getelementptr i8, i8* %276, i64 %323
%325 = bitcast i8* %324 to i16*
%326 = extractelement <8 x i16> %318, i64 7
store i16 %326, i16* %325
br label %327
327: ; preds = %322, %292
%328 = extractelement <8 x i1> %320, i64 1
br i1 %328, label %329, label %332
329: ; preds = %327
%330 = bitcast i8* %296 to i16*
%331 = extractelement <8 x i16> %318, i64 6
store i16 %331, i16* %330
br label %332
332: ; preds = %329, %327
%333 = extractelement <8 x i1> %320, i64 2
br i1 %333, label %334, label %337
334: ; preds = %332
%335 = bitcast i8* %299 to i16*
%336 = extractelement <8 x i16> %318, i64 5
store i16 %336, i16* %335
br label %337
337: ; preds = %334, %332
%338 = extractelement <8 x i1> %320, i64 3
br i1 %338, label %339, label %342
339: ; preds = %337
%340 = bitcast i8* %302 to i16*
%341 = extractelement <8 x i16> %318, i64 4
store i16 %341, i16* %340
br label %342
342: ; preds = %339, %337
%343 = extractelement <8 x i1> %320, i64 4
br i1 %343, label %344, label %347
344: ; preds = %342
%345 = bitcast i8* %305 to i16*
%346 = extractelement <8 x i16> %318, i64 3
store i16 %346, i16* %345
br label %347
347: ; preds = %344, %342
%348 = extractelement <8 x i1> %320, i64 5
br i1 %348, label %349, label %352
349: ; preds = %347
%350 = bitcast i8* %308 to i16*
%351 = extractelement <8 x i16> %318, i64 2
store i16 %351, i16* %350
br label %352
352: ; preds = %349, %347
%353 = extractelement <8 x i1> %320, i64 6
br i1 %353, label %354, label %357
354: ; preds = %352
%355 = bitcast i8* %311 to i16*
%356 = extractelement <8 x i16> %318, i64 1
store i16 %356, i16* %355
br label %357
357: ; preds = %354, %352
%358 = extractelement <8 x i1> %320, i64 7
br i1 %358, label %359, label %362
359: ; preds = %357
%360 = bitcast i8* %314 to i16*
%361 = extractelement <8 x i16> %318, i64 0
store i16 %361, i16* %360
br label %362
362: ; preds = %359, %357
%363 = add nuw i64 %293, 8
%364 = icmp eq i64 %363, %92
br i1 %364, label %365, label %292
365: ; preds = %362
br i1 %98, label %578, label %366
366: ; preds = %281, %280, %365
%367 = phi i8* [ %276, %281 ], [ %276, %280 ], [ %289, %365 ]
%368 = phi i64 [ %81, %281 ], [ %81, %280 ], [ %94, %365 ]
%369 = phi i8* [ %277, %281 ], [ %277, %280 ], [ %290, %365 ]
%370 = add nsw i64 %368, -1
%371 = and i64 %368, 3
%372 = icmp eq i64 %371, 0
br i1 %372, label %389, label %373
373: ; preds = %366, %383
%374 = phi i8* [ %384, %383 ], [ %367, %366 ]
%375 = phi i64 [ %386, %383 ], [ %368, %366 ]
%376 = phi i8* [ %385, %383 ], [ %369, %366 ]
%377 = phi i64 [ %387, %383 ], [ 0, %366 ]
%378 = bitcast i8* %376 to i16*
%379 = load i16, i16* %378
%380 = icmp eq i16 %379, %83
br i1 %380, label %383, label %381
381: ; preds = %373
%382 = bitcast i8* %374 to i16*
store i16 %379, i16* %382
br label %383
383: ; preds = %381, %373
%384 = getelementptr inbounds i8, i8* %374, i64 2
%385 = getelementptr inbounds i8, i8* %376, i64 -2
%386 = add nsw i64 %375, -1
%387 = add i64 %377, 1
%388 = icmp eq i64 %387, %371
br i1 %388, label %389, label %373
389: ; preds = %383, %366
%390 = phi i8* [ undef, %366 ], [ %384, %383 ]
%391 = phi i8* [ undef, %366 ], [ %385, %383 ]
%392 = phi i8* [ %367, %366 ], [ %384, %383 ]
%393 = phi i64 [ %368, %366 ], [ %386, %383 ]
%394 = phi i8* [ %369, %366 ], [ %385, %383 ]
%395 = icmp ult i64 %370, 3
br i1 %395, label %578, label %396
396: ; preds = %389, %429
%397 = phi i8* [ %430, %429 ], [ %392, %389 ]
%398 = phi i64 [ %432, %429 ], [ %393, %389 ]
%399 = phi i8* [ %431, %429 ], [ %394, %389 ]
%400 = bitcast i8* %399 to i16*
%401 = load i16, i16* %400
%402 = icmp eq i16 %401, %83
br i1 %402, label %405, label %403
403: ; preds = %396
%404 = bitcast i8* %397 to i16*
store i16 %401, i16* %404
br label %405
405: ; preds = %403, %396
%406 = getelementptr inbounds i8, i8* %399, i64 -2
%407 = bitcast i8* %406 to i16*
%408 = load i16, i16* %407
%409 = icmp eq i16 %408, %83
br i1 %409, label %413, label %410
410: ; preds = %405
%411 = getelementptr inbounds i8, i8* %397, i64 2
%412 = bitcast i8* %411 to i16*
store i16 %408, i16* %412
br label %413
413: ; preds = %410, %405
%414 = getelementptr inbounds i8, i8* %399, i64 -4
%415 = bitcast i8* %414 to i16*
%416 = load i16, i16* %415
%417 = icmp eq i16 %416, %83
br i1 %417, label %421, label %418
418: ; preds = %413
%419 = getelementptr inbounds i8, i8* %397, i64 4
%420 = bitcast i8* %419 to i16*
store i16 %416, i16* %420
br label %421
421: ; preds = %418, %413
%422 = getelementptr inbounds i8, i8* %399, i64 -6
%423 = bitcast i8* %422 to i16*
%424 = load i16, i16* %423
%425 = icmp eq i16 %424, %83
br i1 %425, label %429, label %426
426: ; preds = %421
%427 = getelementptr inbounds i8, i8* %397, i64 6
%428 = bitcast i8* %427 to i16*
store i16 %424, i16* %428
br label %429
429: ; preds = %426, %421
%430 = getelementptr inbounds i8, i8* %397, i64 8
%431 = getelementptr inbounds i8, i8* %399, i64 -8
%432 = add nsw i64 %398, -4
%433 = icmp eq i64 %432, 0
br i1 %433, label %578, label %396
434: ; preds = %275
br i1 %82, label %578, label %435
435: ; preds = %434
br i1 %99, label %505, label %436
436: ; preds = %435
%437 = getelementptr i8, i8* %276, i64 %84
%438 = getelementptr i8, i8* %277, i64 %85
%439 = getelementptr i8, i8* %277, i64 2
%440 = icmp ult i8* %276, %439
%441 = icmp ult i8* %438, %437
%442 = and i1 %440, %441
br i1 %442, label %505, label %443
443: ; preds = %436
%444 = getelementptr i8, i8* %276, i64 %101
%445 = getelementptr i8, i8* %277, i64 %103
br i1 %105, label %485, label %446
446: ; preds = %443, %446
%447 = phi i64 [ %482, %446 ], [ 0, %443 ]
%448 = phi i64 [ %483, %446 ], [ 0, %443 ]
%449 = shl i64 %447, 1
%450 = getelementptr i8, i8* %276, i64 %449
%451 = mul i64 %447, -2
%452 = getelementptr i8, i8* %277, i64 %451
%453 = getelementptr i8, i8* %452, i64 -14
%454 = bitcast i8* %453 to <8 x i16>*
%455 = load <8 x i16>, <8 x i16>* %454
%456 = shufflevector <8 x i16> %455, <8 x i16> poison, <8 x i32> <i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%457 = getelementptr i8, i8* %452, i64 -16
%458 = getelementptr i8, i8* %457, i64 -14
%459 = bitcast i8* %458 to <8 x i16>*
%460 = load <8 x i16>, <8 x i16>* %459
%461 = shufflevector <8 x i16> %460, <8 x i16> poison, <8 x i32> <i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%462 = bitcast i8* %450 to <8 x i16>*
store <8 x i16> %456, <8 x i16>* %462
%463 = getelementptr i8, i8* %450, i64 16
%464 = bitcast i8* %463 to <8 x i16>*
store <8 x i16> %461, <8 x i16>* %464
%465 = or i64 %447, 16
%466 = shl i64 %465, 1
%467 = getelementptr i8, i8* %276, i64 %466
%468 = mul i64 %465, -2
%469 = getelementptr i8, i8* %277, i64 %468
%470 = getelementptr i8, i8* %469, i64 -14
%471 = bitcast i8* %470 to <8 x i16>*
%472 = load <8 x i16>, <8 x i16>* %471
%473 = shufflevector <8 x i16> %472, <8 x i16> poison, <8 x i32> <i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%474 = getelementptr i8, i8* %469, i64 -16
%475 = getelementptr i8, i8* %474, i64 -14
%476 = bitcast i8* %475 to <8 x i16>*
%477 = load <8 x i16>, <8 x i16>* %476
%478 = shufflevector <8 x i16> %477, <8 x i16> poison, <8 x i32> <i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%479 = bitcast i8* %467 to <8 x i16>*
store <8 x i16> %473, <8 x i16>* %479
%480 = getelementptr i8, i8* %467, i64 16
%481 = bitcast i8* %480 to <8 x i16>*
store <8 x i16> %478, <8 x i16>* %481
%482 = add nuw i64 %447, 32
%483 = add i64 %448, 2
%484 = icmp eq i64 %483, %106
br i1 %484, label %485, label %446
485: ; preds = %446, %443
%486 = phi i64 [ 0, %443 ], [ %482, %446 ]
br i1 %107, label %504, label %487
487: ; preds = %485
%488 = shl i64 %486, 1
%489 = getelementptr i8, i8* %276, i64 %488
%490 = mul i64 %486, -2
%491 = getelementptr i8, i8* %277, i64 %490
%492 = getelementptr i8, i8* %491, i64 -14
%493 = bitcast i8* %492 to <8 x i16>*
%494 = load <8 x i16>, <8 x i16>* %493
%495 = shufflevector <8 x i16> %494, <8 x i16> poison, <8 x i32> <i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%496 = getelementptr i8, i8* %491, i64 -16
%497 = getelementptr i8, i8* %496, i64 -14
%498 = bitcast i8* %497 to <8 x i16>*
%499 = load <8 x i16>, <8 x i16>* %498
%500 = shufflevector <8 x i16> %499, <8 x i16> poison, <8 x i32> <i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%501 = bitcast i8* %489 to <8 x i16>*
store <8 x i16> %495, <8 x i16>* %501
%502 = getelementptr i8, i8* %489, i64 16
%503 = bitcast i8* %502 to <8 x i16>*
store <8 x i16> %500, <8 x i16>* %503
br label %504
504: ; preds = %485, %487
br i1 %108, label %578, label %505
505: ; preds = %436, %435, %504
%506 = phi i8* [ %276, %436 ], [ %276, %435 ], [ %444, %504 ]
%507 = phi i64 [ %81, %436 ], [ %81, %435 ], [ %102, %504 ]
%508 = phi i8* [ %277, %436 ], [ %277, %435 ], [ %445, %504 ]
%509 = add nsw i64 %507, -1
%510 = and i64 %507, 7
%511 = icmp eq i64 %510, 0
br i1 %511, label %525, label %512
512: ; preds = %505, %512
%513 = phi i8* [ %520, %512 ], [ %506, %505 ]
%514 = phi i64 [ %522, %512 ], [ %507, %505 ]
%515 = phi i8* [ %521, %512 ], [ %508, %505 ]
%516 = phi i64 [ %523, %512 ], [ 0, %505 ]
%517 = bitcast i8* %515 to i16*
%518 = load i16, i16* %517
%519 = bitcast i8* %513 to i16*
store i16 %518, i16* %519
%520 = getelementptr inbounds i8, i8* %513, i64 2
%521 = getelementptr inbounds i8, i8* %515, i64 -2
%522 = add nsw i64 %514, -1
%523 = add i64 %516, 1
%524 = icmp eq i64 %523, %510
br i1 %524, label %525, label %512
525: ; preds = %512, %505
%526 = phi i8* [ undef, %505 ], [ %520, %512 ]
%527 = phi i8* [ undef, %505 ], [ %521, %512 ]
%528 = phi i8* [ %506, %505 ], [ %520, %512 ]
%529 = phi i64 [ %507, %505 ], [ %522, %512 ]
%530 = phi i8* [ %508, %505 ], [ %521, %512 ]
%531 = icmp ult i64 %509, 7
br i1 %531, label %578, label %532
532: ; preds = %525, %532
%533 = phi i8* [ %574, %532 ], [ %528, %525 ]
%534 = phi i64 [ %576, %532 ], [ %529, %525 ]
%535 = phi i8* [ %575, %532 ], [ %530, %525 ]
%536 = bitcast i8* %535 to i16*
%537 = load i16, i16* %536
%538 = bitcast i8* %533 to i16*
store i16 %537, i16* %538
%539 = getelementptr inbounds i8, i8* %533, i64 2
%540 = getelementptr inbounds i8, i8* %535, i64 -2
%541 = bitcast i8* %540 to i16*
%542 = load i16, i16* %541
%543 = bitcast i8* %539 to i16*
store i16 %542, i16* %543
%544 = getelementptr inbounds i8, i8* %533, i64 4
%545 = getelementptr inbounds i8, i8* %535, i64 -4
%546 = bitcast i8* %545 to i16*
%547 = load i16, i16* %546
%548 = bitcast i8* %544 to i16*
store i16 %547, i16* %548
%549 = getelementptr inbounds i8, i8* %533, i64 6
%550 = getelementptr inbounds i8, i8* %535, i64 -6
%551 = bitcast i8* %550 to i16*
%552 = load i16, i16* %551
%553 = bitcast i8* %549 to i16*
store i16 %552, i16* %553
%554 = getelementptr inbounds i8, i8* %533, i64 8
%555 = getelementptr inbounds i8, i8* %535, i64 -8
%556 = bitcast i8* %555 to i16*
%557 = load i16, i16* %556
%558 = bitcast i8* %554 to i16*
store i16 %557, i16* %558
%559 = getelementptr inbounds i8, i8* %533, i64 10
%560 = getelementptr inbounds i8, i8* %535, i64 -10
%561 = bitcast i8* %560 to i16*
%562 = load i16, i16* %561
%563 = bitcast i8* %559 to i16*
store i16 %562, i16* %563
%564 = getelementptr inbounds i8, i8* %533, i64 12
%565 = getelementptr inbounds i8, i8* %535, i64 -12
%566 = bitcast i8* %565 to i16*
%567 = load i16, i16* %566
%568 = bitcast i8* %564 to i16*
store i16 %567, i16* %568
%569 = getelementptr inbounds i8, i8* %533, i64 14
%570 = getelementptr inbounds i8, i8* %535, i64 -14
%571 = bitcast i8* %570 to i16*
%572 = load i16, i16* %571
%573 = bitcast i8* %569 to i16*
store i16 %572, i16* %573
%574 = getelementptr inbounds i8, i8* %533, i64 16
%575 = getelementptr inbounds i8, i8* %535, i64 -16
%576 = add nsw i64 %534, -8
%577 = icmp eq i64 %576, 0
br i1 %577, label %578, label %532
578: ; preds = %389, %429, %525, %532, %365, %504, %279, %434
%579 = phi i8* [ %277, %434 ], [ %277, %279 ], [ %445, %504 ], [ %290, %365 ], [ %527, %525 ], [ %575, %532 ], [ %391, %389 ], [ %431, %429 ]
%580 = phi i8* [ %276, %434 ], [ %276, %279 ], [ %444, %504 ], [ %289, %365 ], [ %526, %525 ], [ %574, %532 ], [ %390, %389 ], [ %430, %429 ]
%581 = getelementptr inbounds i8, i8* %580, i64 %47
%582 = getelementptr inbounds i8, i8* %579, i64 %52
%583 = add nsw i32 %278, -1
%584 = icmp eq i32 %583, 0
br i1 %584, label %946, label %275
585: ; preds = %43
%586 = icmp eq i32 %5, 0
br i1 %586, label %946, label %587
587: ; preds = %585
%588 = shl i64 %8, 8
%589 = and i64 %588, 16776960
%590 = lshr i64 %8, 16
%591 = and i64 %590, 255
%592 = or i64 %589, %591
%593 = trunc i64 %592 to i32
%594 = sext i32 %4 to i64
%595 = icmp eq i32 %4, 0
%596 = and i64 %594, 1
%597 = icmp eq i64 %596, 0
%598 = add nsw i64 %594, -1
%599 = icmp eq i32 %4, 1
%600 = and i64 %594, 1
%601 = icmp eq i64 %600, 0
%602 = add nsw i64 %594, -1
%603 = icmp eq i32 %4, 1
br label %604
604: ; preds = %587, %722
%605 = phi i32 [ %5, %587 ], [ %727, %722 ]
%606 = phi i8* [ %0, %587 ], [ %725, %722 ]
%607 = phi i8* [ %46, %587 ], [ %726, %722 ]
br i1 %28, label %680, label %608
608: ; preds = %604
br i1 %595, label %722, label %609
609: ; preds = %608
br i1 %597, label %630, label %610
610: ; preds = %609
%611 = bitcast i8* %607 to i16*
%612 = load i16, i16* %611
%613 = zext i16 %612 to i32
%614 = shl nuw nsw i32 %613, 8
%615 = getelementptr inbounds i8, i8* %607, i64 2
%616 = load i8, i8* %615
%617 = zext i8 %616 to i32
%618 = or i32 %614, %617
%619 = icmp eq i32 %618, %593
br i1 %619, label %627, label %620
620: ; preds = %610
%621 = trunc i16 %612 to i8
store i8 %621, i8* %606
%622 = getelementptr inbounds i8, i8* %607, i64 1
%623 = load i8, i8* %622
%624 = getelementptr inbounds i8, i8* %606, i64 1
store i8 %623, i8* %624
%625 = load i8, i8* %615
%626 = getelementptr inbounds i8, i8* %606, i64 2
store i8 %625, i8* %626
br label %627
627: ; preds = %620, %610
%628 = getelementptr inbounds i8, i8* %606, i64 3
%629 = getelementptr inbounds i8, i8* %607, i64 -3
br label %630
630: ; preds = %627, %609
%631 = phi i8* [ undef, %609 ], [ %628, %627 ]
%632 = phi i8* [ undef, %609 ], [ %629, %627 ]
%633 = phi i64 [ %594, %609 ], [ %598, %627 ]
%634 = phi i8* [ %606, %609 ], [ %628, %627 ]
%635 = phi i8* [ %607, %609 ], [ %629, %627 ]
br i1 %599, label %722, label %636
636: ; preds = %630, %675
%637 = phi i64 [ %678, %675 ], [ %633, %630 ]
%638 = phi i8* [ %676, %675 ], [ %634, %630 ]
%639 = phi i8* [ %677, %675 ], [ %635, %630 ]
%640 = bitcast i8* %639 to i16*
%641 = load i16, i16* %640
%642 = zext i16 %641 to i32
%643 = shl nuw nsw i32 %642, 8
%644 = getelementptr inbounds i8, i8* %639, i64 2
%645 = load i8, i8* %644
%646 = zext i8 %645 to i32
%647 = or i32 %643, %646
%648 = icmp eq i32 %647, %593
br i1 %648, label %656, label %649
649: ; preds = %636
%650 = trunc i16 %641 to i8
store i8 %650, i8* %638
%651 = getelementptr inbounds i8, i8* %639, i64 1
%652 = load i8, i8* %651
%653 = getelementptr inbounds i8, i8* %638, i64 1
store i8 %652, i8* %653
%654 = load i8, i8* %644
%655 = getelementptr inbounds i8, i8* %638, i64 2
store i8 %654, i8* %655
br label %656
656: ; preds = %649, %636
%657 = getelementptr inbounds i8, i8* %639, i64 -3
%658 = bitcast i8* %657 to i16*
%659 = load i16, i16* %658
%660 = zext i16 %659 to i32
%661 = shl nuw nsw i32 %660, 8
%662 = getelementptr inbounds i8, i8* %639, i64 -1
%663 = load i8, i8* %662
%664 = zext i8 %663 to i32
%665 = or i32 %661, %664
%666 = icmp eq i32 %665, %593
br i1 %666, label %675, label %667
667: ; preds = %656
%668 = getelementptr inbounds i8, i8* %638, i64 3
%669 = trunc i16 %659 to i8
store i8 %669, i8* %668
%670 = getelementptr inbounds i8, i8* %639, i64 -2
%671 = load i8, i8* %670
%672 = getelementptr inbounds i8, i8* %638, i64 4
store i8 %671, i8* %672
%673 = load i8, i8* %662
%674 = getelementptr inbounds i8, i8* %638, i64 5
store i8 %673, i8* %674
br label %675
675: ; preds = %667, %656
%676 = getelementptr inbounds i8, i8* %638, i64 6
%677 = getelementptr inbounds i8, i8* %639, i64 -6
%678 = add nsw i64 %637, -2
%679 = icmp eq i64 %678, 0
br i1 %679, label %722, label %636
680: ; preds = %604
br i1 %595, label %722, label %681
681: ; preds = %680
br i1 %601, label %692, label %682
682: ; preds = %681
%683 = load i8, i8* %607
store i8 %683, i8* %606
%684 = getelementptr inbounds i8, i8* %607, i64 1
%685 = load i8, i8* %684
%686 = getelementptr inbounds i8, i8* %606, i64 1
store i8 %685, i8* %686
%687 = getelementptr inbounds i8, i8* %607, i64 2
%688 = load i8, i8* %687
%689 = getelementptr inbounds i8, i8* %606, i64 2
store i8 %688, i8* %689
%690 = getelementptr inbounds i8, i8* %606, i64 3
%691 = getelementptr inbounds i8, i8* %607, i64 -3
br label %692
692: ; preds = %682, %681
%693 = phi i8* [ undef, %681 ], [ %690, %682 ]
%694 = phi i8* [ undef, %681 ], [ %691, %682 ]
%695 = phi i64 [ %594, %681 ], [ %602, %682 ]
%696 = phi i8* [ %606, %681 ], [ %690, %682 ]
%697 = phi i8* [ %607, %681 ], [ %691, %682 ]
br i1 %603, label %722, label %698
698: ; preds = %692, %698
%699 = phi i64 [ %720, %698 ], [ %695, %692 ]
%700 = phi i8* [ %718, %698 ], [ %696, %692 ]
%701 = phi i8* [ %719, %698 ], [ %697, %692 ]
%702 = load i8, i8* %701
store i8 %702, i8* %700
%703 = getelementptr inbounds i8, i8* %701, i64 1
%704 = load i8, i8* %703
%705 = getelementptr inbounds i8, i8* %700, i64 1
store i8 %704, i8* %705
%706 = getelementptr inbounds i8, i8* %701, i64 2
%707 = load i8, i8* %706
%708 = getelementptr inbounds i8, i8* %700, i64 2
store i8 %707, i8* %708
%709 = getelementptr inbounds i8, i8* %700, i64 3
%710 = getelementptr inbounds i8, i8* %701, i64 -3
%711 = load i8, i8* %710
store i8 %711, i8* %709
%712 = getelementptr inbounds i8, i8* %701, i64 -2
%713 = load i8, i8* %712
%714 = getelementptr inbounds i8, i8* %700, i64 4
store i8 %713, i8* %714
%715 = getelementptr inbounds i8, i8* %701, i64 -1
%716 = load i8, i8* %715
%717 = getelementptr inbounds i8, i8* %700, i64 5
store i8 %716, i8* %717
%718 = getelementptr inbounds i8, i8* %700, i64 6
%719 = getelementptr inbounds i8, i8* %701, i64 -6
%720 = add nsw i64 %699, -2
%721 = icmp eq i64 %720, 0
br i1 %721, label %722, label %698
722: ; preds = %630, %675, %692, %698, %608, %680
%723 = phi i8* [ %607, %680 ], [ %607, %608 ], [ %694, %692 ], [ %719, %698 ], [ %632, %630 ], [ %677, %675 ]
%724 = phi i8* [ %606, %680 ], [ %606, %608 ], [ %693, %692 ], [ %718, %698 ], [ %631, %630 ], [ %676, %675 ]
%725 = getelementptr inbounds i8, i8* %724, i64 %47
%726 = getelementptr inbounds i8, i8* %723, i64 %52
%727 = add nsw i32 %605, -1
%728 = icmp eq i32 %727, 0
br i1 %728, label %946, label %604
729: ; preds = %55, %939
%730 = phi i8* [ %0, %55 ], [ %942, %939 ]
%731 = phi i8* [ %46, %55 ], [ %943, %939 ]
%732 = phi i32 [ %5, %55 ], [ %944, %939 ]
br i1 %28, label %795, label %733
733: ; preds = %729
br i1 %58, label %939, label %734
734: ; preds = %733
br i1 %66, label %751, label %735
735: ; preds = %734, %745
%736 = phi i8* [ %746, %745 ], [ %730, %734 ]
%737 = phi i64 [ %748, %745 ], [ %57, %734 ]
%738 = phi i8* [ %747, %745 ], [ %731, %734 ]
%739 = phi i64 [ %749, %745 ], [ 0, %734 ]
%740 = bitcast i8* %738 to i32*
%741 = load i32, i32* %740
%742 = icmp eq i32 %741, %56
br i1 %742, label %745, label %743
743: ; preds = %735
%744 = bitcast i8* %736 to i32*
store i32 %741, i32* %744
br label %745
745: ; preds = %743, %735
%746 = getelementptr inbounds i8, i8* %736, i64 4
%747 = getelementptr inbounds i8, i8* %738, i64 -4
%748 = add nsw i64 %737, -1
%749 = add i64 %739, 1
%750 = icmp eq i64 %749, %65
br i1 %750, label %751, label %735
751: ; preds = %745, %734
%752 = phi i8* [ undef, %734 ], [ %746, %745 ]
%753 = phi i8* [ undef, %734 ], [ %747, %745 ]
%754 = phi i8* [ %730, %734 ], [ %746, %745 ]
%755 = phi i64 [ %57, %734 ], [ %748, %745 ]
%756 = phi i8* [ %731, %734 ], [ %747, %745 ]
br i1 %67, label %939, label %757
757: ; preds = %751, %790
%758 = phi i8* [ %791, %790 ], [ %754, %751 ]
%759 = phi i64 [ %793, %790 ], [ %755, %751 ]
%760 = phi i8* [ %792, %790 ], [ %756, %751 ]
%761 = bitcast i8* %760 to i32*
%762 = load i32, i32* %761
%763 = icmp eq i32 %762, %56
br i1 %763, label %766, label %764
764: ; preds = %757
%765 = bitcast i8* %758 to i32*
store i32 %762, i32* %765
br label %766
766: ; preds = %764, %757
%767 = getelementptr inbounds i8, i8* %760, i64 -4
%768 = bitcast i8* %767 to i32*
%769 = load i32, i32* %768
%770 = icmp eq i32 %769, %56
br i1 %770, label %774, label %771
771: ; preds = %766
%772 = getelementptr inbounds i8, i8* %758, i64 4
%773 = bitcast i8* %772 to i32*
store i32 %769, i32* %773
br label %774
774: ; preds = %771, %766
%775 = getelementptr inbounds i8, i8* %760, i64 -8
%776 = bitcast i8* %775 to i32*
%777 = load i32, i32* %776
%778 = icmp eq i32 %777, %56
br i1 %778, label %782, label %779
779: ; preds = %774
%780 = getelementptr inbounds i8, i8* %758, i64 8
%781 = bitcast i8* %780 to i32*
store i32 %777, i32* %781
br label %782
782: ; preds = %779, %774
%783 = getelementptr inbounds i8, i8* %760, i64 -12
%784 = bitcast i8* %783 to i32*
%785 = load i32, i32* %784
%786 = icmp eq i32 %785, %56
br i1 %786, label %790, label %787
787: ; preds = %782
%788 = getelementptr inbounds i8, i8* %758, i64 12
%789 = bitcast i8* %788 to i32*
store i32 %785, i32* %789
br label %790
790: ; preds = %787, %782
%791 = getelementptr inbounds i8, i8* %758, i64 16
%792 = getelementptr inbounds i8, i8* %760, i64 -16
%793 = add nsw i64 %759, -4
%794 = icmp eq i64 %793, 0
br i1 %794, label %939, label %757
795: ; preds = %729
br i1 %58, label %939, label %796
796: ; preds = %795
br i1 %68, label %866, label %797
797: ; preds = %796
%798 = getelementptr i8, i8* %730, i64 %59
%799 = getelementptr i8, i8* %731, i64 %60
%800 = getelementptr i8, i8* %731, i64 4
%801 = icmp ult i8* %730, %800
%802 = icmp ult i8* %799, %798
%803 = and i1 %801, %802
br i1 %803, label %866, label %804
804: ; preds = %797
%805 = getelementptr i8, i8* %730, i64 %70
%806 = getelementptr i8, i8* %731, i64 %72
br i1 %74, label %846, label %807
807: ; preds = %804, %807
%808 = phi i64 [ %843, %807 ], [ 0, %804 ]
%809 = phi i64 [ %844, %807 ], [ 0, %804 ]
%810 = shl i64 %808, 2
%811 = getelementptr i8, i8* %730, i64 %810
%812 = mul i64 %808, -4
%813 = getelementptr i8, i8* %731, i64 %812
%814 = getelementptr i8, i8* %813, i64 -12
%815 = bitcast i8* %814 to <4 x i32>*
%816 = load <4 x i32>, <4 x i32>* %815
%817 = shufflevector <4 x i32> %816, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%818 = getelementptr i8, i8* %813, i64 -16
%819 = getelementptr i8, i8* %818, i64 -12
%820 = bitcast i8* %819 to <4 x i32>*
%821 = load <4 x i32>, <4 x i32>* %820
%822 = shufflevector <4 x i32> %821, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%823 = bitcast i8* %811 to <4 x i32>*
store <4 x i32> %817, <4 x i32>* %823
%824 = getelementptr i8, i8* %811, i64 16
%825 = bitcast i8* %824 to <4 x i32>*
store <4 x i32> %822, <4 x i32>* %825
%826 = or i64 %808, 8
%827 = shl i64 %826, 2
%828 = getelementptr i8, i8* %730, i64 %827
%829 = mul i64 %826, -4
%830 = getelementptr i8, i8* %731, i64 %829
%831 = getelementptr i8, i8* %830, i64 -12
%832 = bitcast i8* %831 to <4 x i32>*
%833 = load <4 x i32>, <4 x i32>* %832
%834 = shufflevector <4 x i32> %833, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%835 = getelementptr i8, i8* %830, i64 -16
%836 = getelementptr i8, i8* %835, i64 -12
%837 = bitcast i8* %836 to <4 x i32>*
%838 = load <4 x i32>, <4 x i32>* %837
%839 = shufflevector <4 x i32> %838, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%840 = bitcast i8* %828 to <4 x i32>*
store <4 x i32> %834, <4 x i32>* %840
%841 = getelementptr i8, i8* %828, i64 16
%842 = bitcast i8* %841 to <4 x i32>*
store <4 x i32> %839, <4 x i32>* %842
%843 = add nuw i64 %808, 16
%844 = add i64 %809, 2
%845 = icmp eq i64 %844, %75
br i1 %845, label %846, label %807
846: ; preds = %807, %804
%847 = phi i64 [ 0, %804 ], [ %843, %807 ]
br i1 %76, label %865, label %848
848: ; preds = %846
%849 = shl i64 %847, 2
%850 = getelementptr i8, i8* %730, i64 %849
%851 = mul i64 %847, -4
%852 = getelementptr i8, i8* %731, i64 %851
%853 = getelementptr i8, i8* %852, i64 -12
%854 = bitcast i8* %853 to <4 x i32>*
%855 = load <4 x i32>, <4 x i32>* %854
%856 = shufflevector <4 x i32> %855, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%857 = getelementptr i8, i8* %852, i64 -16
%858 = getelementptr i8, i8* %857, i64 -12
%859 = bitcast i8* %858 to <4 x i32>*
%860 = load <4 x i32>, <4 x i32>* %859
%861 = shufflevector <4 x i32> %860, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%862 = bitcast i8* %850 to <4 x i32>*
store <4 x i32> %856, <4 x i32>* %862
%863 = getelementptr i8, i8* %850, i64 16
%864 = bitcast i8* %863 to <4 x i32>*
store <4 x i32> %861, <4 x i32>* %864
br label %865
865: ; preds = %846, %848
br i1 %77, label %939, label %866
866: ; preds = %797, %796, %865
%867 = phi i8* [ %730, %797 ], [ %730, %796 ], [ %805, %865 ]
%868 = phi i64 [ %57, %797 ], [ %57, %796 ], [ %71, %865 ]
%869 = phi i8* [ %731, %797 ], [ %731, %796 ], [ %806, %865 ]
%870 = add nsw i64 %868, -1
%871 = and i64 %868, 7
%872 = icmp eq i64 %871, 0
br i1 %872, label %886, label %873
873: ; preds = %866, %873
%874 = phi i8* [ %881, %873 ], [ %867, %866 ]
%875 = phi i64 [ %883, %873 ], [ %868, %866 ]
%876 = phi i8* [ %882, %873 ], [ %869, %866 ]
%877 = phi i64 [ %884, %873 ], [ 0, %866 ]
%878 = bitcast i8* %876 to i32*
%879 = load i32, i32* %878
%880 = bitcast i8* %874 to i32*
store i32 %879, i32* %880
%881 = getelementptr inbounds i8, i8* %874, i64 4
%882 = getelementptr inbounds i8, i8* %876, i64 -4
%883 = add nsw i64 %875, -1
%884 = add i64 %877, 1
%885 = icmp eq i64 %884, %871
br i1 %885, label %886, label %873
886: ; preds = %873, %866
%887 = phi i8* [ undef, %866 ], [ %881, %873 ]
%888 = phi i8* [ undef, %866 ], [ %882, %873 ]
%889 = phi i8* [ %867, %866 ], [ %881, %873 ]
%890 = phi i64 [ %868, %866 ], [ %883, %873 ]
%891 = phi i8* [ %869, %866 ], [ %882, %873 ]
%892 = icmp ult i64 %870, 7
br i1 %892, label %939, label %893
893: ; preds = %886, %893
%894 = phi i8* [ %935, %893 ], [ %889, %886 ]
%895 = phi i64 [ %937, %893 ], [ %890, %886 ]
%896 = phi i8* [ %936, %893 ], [ %891, %886 ]
%897 = bitcast i8* %896 to i32*
%898 = load i32, i32* %897
%899 = bitcast i8* %894 to i32*
store i32 %898, i32* %899
%900 = getelementptr inbounds i8, i8* %894, i64 4
%901 = getelementptr inbounds i8, i8* %896, i64 -4
%902 = bitcast i8* %901 to i32*
%903 = load i32, i32* %902
%904 = bitcast i8* %900 to i32*
store i32 %903, i32* %904
%905 = getelementptr inbounds i8, i8* %894, i64 8
%906 = getelementptr inbounds i8, i8* %896, i64 -8
%907 = bitcast i8* %906 to i32*
%908 = load i32, i32* %907
%909 = bitcast i8* %905 to i32*
store i32 %908, i32* %909
%910 = getelementptr inbounds i8, i8* %894, i64 12
%911 = getelementptr inbounds i8, i8* %896, i64 -12
%912 = bitcast i8* %911 to i32*
%913 = load i32, i32* %912
%914 = bitcast i8* %910 to i32*
store i32 %913, i32* %914
%915 = getelementptr inbounds i8, i8* %894, i64 16
%916 = getelementptr inbounds i8, i8* %896, i64 -16
%917 = bitcast i8* %916 to i32*
%918 = load i32, i32* %917
%919 = bitcast i8* %915 to i32*
store i32 %918, i32* %919
%920 = getelementptr inbounds i8, i8* %894, i64 20
%921 = getelementptr inbounds i8, i8* %896, i64 -20
%922 = bitcast i8* %921 to i32*
%923 = load i32, i32* %922
%924 = bitcast i8* %920 to i32*
store i32 %923, i32* %924
%925 = getelementptr inbounds i8, i8* %894, i64 24
%926 = getelementptr inbounds i8, i8* %896, i64 -24
%927 = bitcast i8* %926 to i32*
%928 = load i32, i32* %927
%929 = bitcast i8* %925 to i32*
store i32 %928, i32* %929
%930 = getelementptr inbounds i8, i8* %894, i64 28
%931 = getelementptr inbounds i8, i8* %896, i64 -28
%932 = bitcast i8* %931 to i32*
%933 = load i32, i32* %932
%934 = bitcast i8* %930 to i32*
store i32 %933, i32* %934
%935 = getelementptr inbounds i8, i8* %894, i64 32
%936 = getelementptr inbounds i8, i8* %896, i64 -32
%937 = add nsw i64 %895, -8
%938 = icmp eq i64 %937, 0
br i1 %938, label %939, label %893
939: ; preds = %751, %790, %886, %893, %865, %733, %795
%940 = phi i8* [ %731, %795 ], [ %731, %733 ], [ %806, %865 ], [ %888, %886 ], [ %936, %893 ], [ %753, %751 ], [ %792, %790 ]
%941 = phi i8* [ %730, %795 ], [ %730, %733 ], [ %805, %865 ], [ %887, %886 ], [ %935, %893 ], [ %752, %751 ], [ %791, %790 ]
%942 = getelementptr inbounds i8, i8* %941, i64 %47
%943 = getelementptr inbounds i8, i8* %940, i64 %52
%944 = add nsw i32 %732, -1
%945 = icmp eq i32 %944, 0
br i1 %945, label %946, label %729
946: ; preds = %939, %722, %578, %268, %34, %17, %53, %585, %78, %109, %30, %13, %43
ret i32 0
}