#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*/ memcpy(unsigned char *, unsigned char *, int);
void NV21Transform(const unsigned char *src, const unsigned char *dst,
                   int srcWidth, int srcHeight, int directionFlag) {
  unsigned char *cdst = dst;
  unsigned char *csrc = src;
  int rotate = 0;
  int hflip = 0;
  int vflip = 0;
  if ((0x10 & directionFlag) != 0 || (0x40 & directionFlag) != 0) {
    rotate = 0;
  } else {
    rotate = 1;
  }
  if ((0x10 & directionFlag) != 0 || (0x20 & directionFlag) != 0) {
    hflip = ((0x01 & directionFlag) != 0) ? 1 : 0;
    vflip = ((0x02 & directionFlag) != 0) ? 1 : 0;
  } else {
    if (((0x02 & directionFlag) != 0)) {
      hflip = ((0x01 & directionFlag) != 0) ? 0 : 1;
      vflip = ((0x01 & directionFlag) != 0) ? 0 : 0;
    } else {
      hflip = ((0x01 & directionFlag) != 0) ? 0 : 1;
      vflip = ((0x01 & directionFlag) != 0) ? 1 : 1;
    }
  }
  int ySize = srcHeight * srcWidth;
  int totalSize = ySize * 3 / 2;
  int yStart, yStep, xStep;
  if (rotate == 0 && hflip == 0 && vflip == 0) {
    memcpy(cdst, csrc, totalSize);
    return;
  }
  int srcX, srcY, srcCurr;
  int dstX, dstY, dstCurr;
  int halfHeight = srcHeight >> 1, halfWidth = srcWidth >> 1;
  if (rotate == 1) {
    if (hflip == 1) {
      yStart = vflip == 1 ? ySize - srcHeight : ySize - 1;
      yStep = vflip == 1 ? 1 : -1;
      xStep = -srcHeight;
    } else {
      yStart = vflip == 1 ? 0 : srcHeight - 1;
      yStep = vflip == 1 ? 1 : -1;
      xStep = srcHeight;
    }
    srcCurr = -1;
    for (srcY = 0; srcY < srcHeight; ++srcY) {
      dstCurr = yStart;
      for (srcX = 0; srcX < srcWidth; ++srcX) {
        cdst[dstCurr] = csrc[++srcCurr];
        dstCurr += xStep;
      }
      yStart += yStep;
    }
    if (hflip == 1) {
      yStart = vflip == 1 ? totalSize - srcHeight : totalSize - 2;
      yStep = vflip == 1 ? 2 : -2;
      xStep = -srcHeight;
    } else {
      yStart = vflip == 1 ? ySize : ySize + srcHeight - 2;
      yStep = vflip == 1 ? 2 : -2;
      xStep = srcHeight;
    }
    srcCurr = ySize - 1;
    for (srcY = 0; srcY < halfHeight; ++srcY) {
      dstCurr = yStart;
      for (srcX = 0; srcX < halfWidth; ++srcX) {
        cdst[dstCurr] = csrc[++srcCurr];
        cdst[dstCurr + 1] = csrc[++srcCurr];
        dstCurr += xStep;
      }
      yStart += yStep;
    }
  } else {
    if (vflip == 1 && hflip == 0) {
      yStart = ySize - srcWidth;
      srcCurr = -1;
      for (srcY = 0; srcY < srcHeight; ++srcY) {
        dstCurr = yStart - 1;
        for (srcX = 0; srcX < srcWidth; ++srcX) {
          cdst[++dstCurr] = csrc[++srcCurr];
        }
        yStart -= srcWidth;
      }
      yStart = totalSize - srcWidth;
      for (srcY = 0; srcY < halfHeight; ++srcY) {
        dstCurr = yStart - 1;
        for (srcX = 0; srcX < halfWidth; ++srcX) {
          cdst[++dstCurr] = csrc[++srcCurr];
          cdst[++dstCurr] = csrc[++srcCurr];
        }
        yStart -= srcWidth;
      }
    } else {
      yStep = vflip == 1 ? -srcWidth : srcWidth;
      yStart = vflip == 1 ? ySize - 1 : srcWidth - 1;
      srcCurr = -1;
      for (srcY = 0; srcY < srcHeight; ++srcY) {
        dstCurr = yStart + 1;
        for (srcX = 0; srcX < srcWidth; ++srcX) {
          cdst[--dstCurr] = csrc[++srcCurr];
        }
        yStart += yStep;
      }
      yStart = vflip == 1 ? totalSize - 1 : ySize + srcWidth - 1;
      for (srcY = 0; srcY < halfHeight; ++srcY) {
        dstCurr = yStart;
        for (srcX = 0; srcX < halfWidth; ++srcX) {
          cdst[dstCurr - 1] = csrc[++srcCurr];
          cdst[dstCurr] = csrc[++srcCurr];
          dstCurr -= 2;
        }
        yStart += yStep;
      }
    }
  }
}


x86 assembly (clang, -O0):
<NV21Transform>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
movl   $0x0,-0x38(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x1c(%rbp),%eax
and    $0x10,%eax
cmp    $0x0,%eax
jne    1170 <NV21Transform+0x60>
mov    -0x1c(%rbp),%eax
and    $0x40,%eax
cmp    $0x0,%eax
je     117c <NV21Transform+0x6c>
movl   $0x0,-0x34(%rbp)
jmp    1183 <NV21Transform+0x73>
movl   $0x1,-0x34(%rbp)
mov    -0x1c(%rbp),%eax
and    $0x10,%eax
cmp    $0x0,%eax
jne    11a1 <NV21Transform+0x91>
mov    -0x1c(%rbp),%eax
and    $0x20,%eax
cmp    $0x0,%eax
je     11d2 <NV21Transform+0xc2>
mov    -0x1c(%rbp),%edx
and    $0x1,%edx
xor    %eax,%eax
mov    $0x1,%ecx
cmp    $0x0,%edx
cmovne %ecx,%eax
mov    %eax,-0x38(%rbp)
mov    -0x1c(%rbp),%edx
and    $0x2,%edx
xor    %eax,%eax
mov    $0x1,%ecx
cmp    $0x0,%edx
cmovne %ecx,%eax
mov    %eax,-0x3c(%rbp)
jmp    123c <NV21Transform+0x12c>
mov    -0x1c(%rbp),%eax
and    $0x2,%eax
cmp    $0x0,%eax
je     120d <NV21Transform+0xfd>
mov    -0x1c(%rbp),%edx
and    $0x1,%edx
mov    $0x1,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmovne %ecx,%eax
mov    %eax,-0x38(%rbp)
mov    -0x1c(%rbp),%ecx
and    $0x1,%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
cmovne %eax,%eax
mov    %eax,-0x3c(%rbp)
jmp    1237 <NV21Transform+0x127>
mov    -0x1c(%rbp),%edx
and    $0x1,%edx
mov    $0x1,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmovne %ecx,%eax
mov    %eax,-0x38(%rbp)
mov    -0x1c(%rbp),%ecx
and    $0x1,%ecx
mov    $0x1,%eax
cmp    $0x0,%ecx
cmovne %eax,%eax
mov    %eax,-0x3c(%rbp)
jmp    123c <NV21Transform+0x12c>
mov    -0x18(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    %eax,-0x40(%rbp)
imul   $0x3,-0x40(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x44(%rbp)
cmpl   $0x0,-0x34(%rbp)
jne    1288 <NV21Transform+0x178>
cmpl   $0x0,-0x38(%rbp)
jne    1288 <NV21Transform+0x178>
cmpl   $0x0,-0x3c(%rbp)
jne    1288 <NV21Transform+0x178>
mov    -0x28(%rbp),%rdi
mov    -0x30(%rbp),%rsi
mov    -0x44(%rbp),%edx
call   1030 <memcpy@plt>
jmp    17fb <NV21Transform+0x6eb>
mov    -0x18(%rbp),%eax
sar    $0x1,%eax
mov    %eax,-0x6c(%rbp)
mov    -0x14(%rbp),%eax
sar    $0x1,%eax
mov    %eax,-0x70(%rbp)
cmpl   $0x1,-0x34(%rbp)
jne    14f6 <NV21Transform+0x3e6>
cmpl   $0x1,-0x38(%rbp)
jne    12f8 <NV21Transform+0x1e8>
cmpl   $0x1,-0x3c(%rbp)
jne    12c6 <NV21Transform+0x1b6>
mov    -0x40(%rbp),%eax
sub    -0x18(%rbp),%eax
mov    %eax,-0x74(%rbp)
jmp    12cf <NV21Transform+0x1bf>
mov    -0x40(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x74(%rbp)
mov    -0x74(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x3c(%rbp),%edx
mov    $0xffffffff,%eax
mov    $0x1,%ecx
cmp    $0x1,%edx
cmove  %ecx,%eax
mov    %eax,-0x4c(%rbp)
xor    %eax,%eax
sub    -0x18(%rbp),%eax
mov    %eax,-0x50(%rbp)
jmp    1337 <NV21Transform+0x227>
cmpl   $0x1,-0x3c(%rbp)
jne    130c <NV21Transform+0x1fc>
xor    %eax,%eax
mov    %eax,-0x78(%rbp)
jmp    1315 <NV21Transform+0x205>
mov    -0x18(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x78(%rbp)
mov    -0x78(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x3c(%rbp),%edx
mov    $0xffffffff,%eax
mov    $0x1,%ecx
cmp    $0x1,%edx
cmove  %ecx,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x50(%rbp)
movl   $0xffffffff,-0x5c(%rbp)
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    13b6 <NV21Transform+0x2a6>
mov    -0x48(%rbp),%eax
mov    %eax,-0x68(%rbp)
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    139f <NV21Transform+0x28f>
mov    -0x30(%rbp),%rax
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x5c(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x28(%rbp),%rax
movslq -0x68(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x50(%rbp),%eax
add    -0x68(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    135e <NV21Transform+0x24e>
mov    -0x4c(%rbp),%eax
add    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1345 <NV21Transform+0x235>
cmpl   $0x1,-0x38(%rbp)
jne    140a <NV21Transform+0x2fa>
cmpl   $0x1,-0x3c(%rbp)
jne    13d8 <NV21Transform+0x2c8>
mov    -0x44(%rbp),%eax
sub    -0x18(%rbp),%eax
mov    %eax,-0x7c(%rbp)
jmp    13e1 <NV21Transform+0x2d1>
mov    -0x44(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x3c(%rbp),%edx
mov    $0xfffffffe,%eax
mov    $0x2,%ecx
cmp    $0x1,%edx
cmove  %ecx,%eax
mov    %eax,-0x4c(%rbp)
xor    %eax,%eax
sub    -0x18(%rbp),%eax
mov    %eax,-0x50(%rbp)
jmp    144d <NV21Transform+0x33d>
cmpl   $0x1,-0x3c(%rbp)
jne    141f <NV21Transform+0x30f>
mov    -0x40(%rbp),%eax
mov    %eax,-0x80(%rbp)
jmp    142b <NV21Transform+0x31b>
mov    -0x40(%rbp),%eax
add    -0x18(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x80(%rbp)
mov    -0x80(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x3c(%rbp),%edx
mov    $0xfffffffe,%eax
mov    $0x2,%ecx
cmp    $0x1,%edx
cmove  %ecx,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x40(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x5c(%rbp)
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jge    14f1 <NV21Transform+0x3e1>
mov    -0x48(%rbp),%eax
mov    %eax,-0x68(%rbp)
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x70(%rbp),%eax
jge    14da <NV21Transform+0x3ca>
mov    -0x30(%rbp),%rax
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x5c(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x28(%rbp),%rax
movslq -0x68(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x30(%rbp),%rax
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x5c(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x28(%rbp),%rax
mov    -0x68(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x50(%rbp),%eax
add    -0x68(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1476 <NV21Transform+0x366>
mov    -0x4c(%rbp),%eax
add    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    145d <NV21Transform+0x34d>
jmp    17fb <NV21Transform+0x6eb>
cmpl   $0x1,-0x3c(%rbp)
jne    1646 <NV21Transform+0x536>
cmpl   $0x0,-0x38(%rbp)
jne    1646 <NV21Transform+0x536>
mov    -0x40(%rbp),%eax
sub    -0x14(%rbp),%eax
mov    %eax,-0x48(%rbp)
movl   $0xffffffff,-0x5c(%rbp)
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1596 <NV21Transform+0x486>
mov    -0x48(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x68(%rbp)
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    157d <NV21Transform+0x46d>
mov    -0x30(%rbp),%rax
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x5c(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x28(%rbp),%rax
mov    -0x68(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x68(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    153d <NV21Transform+0x42d>
mov    -0x14(%rbp),%ecx
mov    -0x48(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x48(%rbp)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1521 <NV21Transform+0x411>
mov    -0x44(%rbp),%eax
sub    -0x14(%rbp),%eax
mov    %eax,-0x48(%rbp)
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jge    1641 <NV21Transform+0x531>
mov    -0x48(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x68(%rbp)
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x70(%rbp),%eax
jge    1628 <NV21Transform+0x518>
mov    -0x30(%rbp),%rax
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x5c(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x28(%rbp),%rax
mov    -0x68(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x68(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x30(%rbp),%rax
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x5c(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x28(%rbp),%rax
mov    -0x68(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x68(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    15c2 <NV21Transform+0x4b2>
mov    -0x14(%rbp),%ecx
mov    -0x48(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x48(%rbp)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    15a6 <NV21Transform+0x496>
jmp    17f6 <NV21Transform+0x6e6>
cmpl   $0x1,-0x3c(%rbp)
jne    1660 <NV21Transform+0x550>
xor    %eax,%eax
sub    -0x14(%rbp),%eax
mov    %eax,-0x84(%rbp)
jmp    1669 <NV21Transform+0x559>
mov    -0x14(%rbp),%eax
mov    %eax,-0x84(%rbp)
mov    -0x84(%rbp),%eax
mov    %eax,-0x4c(%rbp)
cmpl   $0x1,-0x3c(%rbp)
jne    168d <NV21Transform+0x57d>
mov    -0x40(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    1699 <NV21Transform+0x589>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x88(%rbp)
mov    -0x88(%rbp),%eax
mov    %eax,-0x48(%rbp)
movl   $0xffffffff,-0x5c(%rbp)
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1723 <NV21Transform+0x613>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    170c <NV21Transform+0x5fc>
mov    -0x30(%rbp),%rax
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x5c(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x28(%rbp),%rax
mov    -0x68(%rbp),%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x68(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    16cc <NV21Transform+0x5bc>
mov    -0x4c(%rbp),%eax
add    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    16b0 <NV21Transform+0x5a0>
cmpl   $0x1,-0x3c(%rbp)
jne    173e <NV21Transform+0x62e>
mov    -0x44(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    174d <NV21Transform+0x63d>
mov    -0x40(%rbp),%eax
add    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
mov    %eax,-0x48(%rbp)
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jge    17f1 <NV21Transform+0x6e1>
mov    -0x48(%rbp),%eax
mov    %eax,-0x68(%rbp)
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x70(%rbp),%eax
jge    17da <NV21Transform+0x6ca>
mov    -0x30(%rbp),%rax
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x5c(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x28(%rbp),%rax
mov    -0x68(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x30(%rbp),%rax
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x5c(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x28(%rbp),%rax
movslq -0x68(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x68(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x68(%rbp)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1776 <NV21Transform+0x666>
mov    -0x4c(%rbp),%eax
add    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    175d <NV21Transform+0x64d>
jmp    17f6 <NV21Transform+0x6e6>
jmp    17fb <NV21Transform+0x6eb>
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<NV21Transform>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x40,%rsp
mov    %edx,%ebx
mov    %rdi,%rax
mov    %r8d,%r11d
and    $0x1,%r11d
test   $0x30,%r8b
je     113a <NV21Transform+0x2a>
mov    %r8d,%ebp
shr    %ebp
and    $0x1,%ebp
jmp    1148 <NV21Transform+0x38>
xor    $0x1,%r11d
xor    %ebp,%ebp
test   $0x2,%r8b
sete   %bpl
mov    %ecx,%r13d
imul   %ebx,%r13d
lea    0x0(%r13,%r13,2),%edi
mov    %edi,%edx
shr    $0x1f,%edx
add    %edi,%edx
sar    %edx
test   $0x50,%r8b
je     1183 <NV21Transform+0x73>
mov    %r11d,%edi
or     %ebp,%edi
jne    1183 <NV21Transform+0x73>
mov    %rsi,%rdi
mov    %rax,%rsi
add    $0x40,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <memcpy@plt>
mov    %rcx,%r10
mov    %r10d,%r9d
sar    %r9d
mov    %rbx,%rdi
sar    %ebx
mov    %rbx,-0x8(%rsp)
mov    %rdi,%rbx
test   $0x50,%r8b
mov    %rdi,-0x80(%rsp)
mov    %rcx,-0x28(%rsp)
mov    %r9d,-0x1c(%rsp)
je     140a <NV21Transform+0x2fa>
test   %ebp,%ebp
je     1451 <NV21Transform+0x341>
test   %r11d,%r11d
jne    1451 <NV21Transform+0x341>
mov    %rcx,%rbp
test   %ebp,%ebp
jle    1daa <NV21Transform+0xc9a>
mov    %edx,-0x74(%rsp)
lea    -0x1(%rbp),%r11d
imul   %ebx,%r11d
add    $0xffffffff,%r11d
lea    0x1(%rsi),%rcx
mov    %rcx,-0x70(%rsp)
lea    -0x1(%rbx),%r10d
lea    (%rsi,%r10,1),%rcx
add    $0x2,%rcx
mov    %rcx,-0x60(%rsp)
lea    0x1(%rax),%rcx
mov    %rcx,-0x58(%rsp)
lea    0x2(%rax,%r10,1),%rcx
mov    %rcx,-0x38(%rsp)
lea    0x1(%r10),%r9
mov    %r9,-0x40(%rsp)
and    $0xffffffffffffffe0,%r9
lea    -0x20(%r9),%r8
mov    %r8,-0x48(%rsp)
shr    $0x5,%r8
add    $0x1,%r8
mov    %r8,%rcx
and    $0xfffffffffffffffe,%rcx
mov    %rcx,-0x50(%rsp)
lea    0x31(%rax),%rcx
mov    %rcx,-0x10(%rsp)
lea    0x31(%rsi),%rcx
mov    %rcx,-0x18(%rsp)
lea    0x4(%rsi),%rcx
mov    %rcx,-0x30(%rsp)
xor    %r12d,%r12d
mov    $0xffffffff,%edi
jmp    1275 <NV21Transform+0x165>
nopw   0x0(%rax,%rax,1)
mov    -0x80(%rsp),%rbx
add    $0x1,%r12d
sub    %ebx,%r11d
cmp    %ebp,%r12d
je     175e <NV21Transform+0x64e>
test   %ebx,%ebx
jle    1265 <NV21Transform+0x155>
movslq %r11d,%r13
xor    %r14d,%r14d
movslq %edi,%rdi
cmp    $0x1f,%r10d
jb     1360 <NV21Transform+0x250>
mov    -0x70(%rsp),%rcx
add    %r13,%rcx
mov    -0x38(%rsp),%rdx
add    %rdi,%rdx
cmp    %rdx,%rcx
jae    12ba <NV21Transform+0x1aa>
mov    -0x60(%rsp),%rcx
add    %r13,%rcx
mov    -0x58(%rsp),%rdx
add    %rdi,%rdx
cmp    %rcx,%rdx
jb     1360 <NV21Transform+0x250>
cmpq   $0x0,-0x48(%rsp)
je     13f9 <NV21Transform+0x2e9>
mov    -0x18(%rsp),%rcx
lea    (%rcx,%r13,1),%rbx
mov    -0x10(%rsp),%rcx
lea    (%rcx,%rdi,1),%rbp
mov    -0x50(%rsp),%rcx
xor    %edx,%edx
nop
movups -0x30(%rbp,%rdx,1),%xmm0
movups -0x20(%rbp,%rdx,1),%xmm1
movups %xmm0,-0x30(%rbx,%rdx,1)
movups %xmm1,-0x20(%rbx,%rdx,1)
movdqu -0x10(%rbp,%rdx,1),%xmm0
movdqu 0x0(%rbp,%rdx,1),%xmm1
movdqu %xmm0,-0x10(%rbx,%rdx,1)
movdqu %xmm1,(%rbx,%rdx,1)
add    $0x40,%rdx
add    $0xfffffffffffffffe,%rcx
jne    12e0 <NV21Transform+0x1d0>
test   $0x1,%r8b
je     133a <NV21Transform+0x22a>
lea    (%rdx,%rdi,1),%rcx
add    %r13,%rdx
movdqu 0x1(%rax,%rcx,1),%xmm0
movdqu 0x11(%rax,%rcx,1),%xmm1
movdqu %xmm0,0x1(%rsi,%rdx,1)
movdqu %xmm1,0x11(%rsi,%rdx,1)
add    %r9,%rdi
cmp    %r9,-0x40(%rsp)
mov    -0x28(%rsp),%rbp
je     1260 <NV21Transform+0x150>
add    %r9,%r13
mov    %r9d,%r14d
mov    -0x80(%rsp),%rbx
nopl   0x0(%rax,%rax,1)
mov    %ebx,%r15d
sub    %r14d,%r15d
mov    %r14d,%edx
not    %edx
add    %ebx,%edx
and    $0x3,%r15d
je     139d <NV21Transform+0x28d>
neg    %r15d
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movzbl 0x1(%rax,%rdi,1),%ecx
add    $0x1,%rdi
mov    %cl,0x1(%rsi,%r13,1)
add    $0x1,%r13
add    $0xffffffff,%ebx
cmp    %ebx,%r15d
jne    1380 <NV21Transform+0x270>
sub    %ebx,%r14d
cmp    $0x3,%edx
jb     1260 <NV21Transform+0x150>
add    -0x30(%rsp),%r13
mov    -0x80(%rsp),%rdx
sub    %r14d,%edx
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
movzbl 0x1(%rax,%rdi,1),%ecx
mov    %cl,-0x3(%r13,%rbx,1)
movzbl 0x2(%rax,%rdi,1),%ecx
mov    %cl,-0x2(%r13,%rbx,1)
movzbl 0x3(%rax,%rdi,1),%ecx
mov    %cl,-0x1(%r13,%rbx,1)
movzbl 0x4(%rax,%rdi,1),%ecx
add    $0x4,%rdi
mov    %cl,0x0(%r13,%rbx,1)
add    $0x4,%rbx
cmp    %ebx,%edx
jne    13c0 <NV21Transform+0x2b0>
jmp    1260 <NV21Transform+0x150>
xor    %edx,%edx
test   $0x1,%r8b
jne    131b <NV21Transform+0x20b>
jmp    133a <NV21Transform+0x22a>
mov    %ebp,%r8d
test   %r11d,%r11d
mov    %edx,-0x74(%rsp)
mov    %ebp,-0x64(%rsp)
mov    %r11d,0x4(%rsp)
mov    %r8,0x8(%rsp)
je     1999 <NV21Transform+0x889>
lea    (%r8,%r8,1),%rdi
add    $0xffffffffffffffff,%rdi
mov    %ecx,%edx
neg    %edx
cmp    $0x1,%ebp
mov    %rdi,%rbp
mov    %rcx,%rdi
sbb    %ecx,%ecx
or     %edx,%ecx
add    %r13d,%ecx
test   %edi,%edi
jg     19b8 <NV21Transform+0x8a8>
jmp    1c6b <NV21Transform+0xb5b>
mov    %ebx,%edi
neg    %edi
test   %ebp,%ebp
mov    %ebx,%r10d
mov    %edi,-0x58(%rsp)
cmovne %edi,%r10d
test   %ecx,%ecx
jle    1daa <NV21Transform+0xc9a>
mov    %edx,-0x74(%rsp)
mov    %ebp,-0x64(%rsp)
test   %ebp,%ebp
mov    %ebx,%r8d
cmovne %r13d,%r8d
lea    -0x1(%rbx),%r9d
mov    %r9,%rcx
not    %rcx
add    %rsi,%rcx
mov    %rcx,-0x70(%rsp)
lea    0x1(%rax),%rcx
mov    %rcx,-0x60(%rsp)
lea    (%r9,%rax,1),%rcx
add    $0x2,%rcx
mov    %rcx,-0x30(%rsp)
lea    0x1(%r9),%r11
mov    %r11,-0x40(%rsp)
and    $0xffffffffffffffe0,%r11
lea    -0x10(%rsi),%rcx
mov    %rcx,-0x48(%rsp)
lea    0x11(%rax),%rcx
mov    %rcx,-0x50(%rsp)
lea    -0x1(%rsi),%rcx
mov    %rcx,-0x38(%rsp)
xor    %r12d,%r12d
mov    $0xffffffff,%ebp
pxor   %xmm0,%xmm0
jmp    14f7 <NV21Transform+0x3e7>
nopl   0x0(%rax)
mov    -0x80(%rsp),%rbx
add    $0x1,%r12d
add    %r10d,%r8d
cmp    -0x28(%rsp),%r12d
je     1672 <NV21Transform+0x562>
test   %ebx,%ebx
jle    14e5 <NV21Transform+0x3d5>
movslq %r8d,%r14
xor    %ecx,%ecx
movslq %ebp,%r15
cmp    $0x1f,%r9d
jb     1537 <NV21Transform+0x427>
mov    -0x70(%rsp),%rdx
add    %r14,%rdx
mov    -0x30(%rsp),%rdi
add    %r15,%rdi
cmp    %rdi,%rdx
jae    15c8 <NV21Transform+0x4b8>
lea    (%rsi,%r14,1),%rdx
mov    -0x60(%rsp),%rdi
add    %r15,%rdi
cmp    %rdx,%rdi
jae    15c8 <NV21Transform+0x4b8>
mov    %r15,%rbp
mov    -0x80(%rsp),%rdx
mov    %edx,%ebx
sub    %ecx,%ebx
mov    %ecx,%r15d
not    %r15d
add    %edx,%r15d
and    $0x3,%ebx
je     157b <NV21Transform+0x46b>
neg    %ebx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nop
movzbl 0x1(%rax,%rbp,1),%edx
add    $0x1,%rbp
mov    %dl,-0x1(%rsi,%r14,1)
add    $0xffffffffffffffff,%r14
add    $0xffffffff,%edi
cmp    %edi,%ebx
jne    1560 <NV21Transform+0x450>
sub    %edi,%ecx
cmp    $0x3,%r15d
jb     14e0 <NV21Transform+0x3d0>
add    -0x38(%rsp),%r14
add    -0x58(%rsp),%ecx
xor    %edx,%edx
movzbl 0x1(%rax,%rbp,1),%ebx
mov    %bl,(%r14,%rdx,1)
movzbl 0x2(%rax,%rbp,1),%ebx
mov    %bl,-0x1(%r14,%rdx,1)
movzbl 0x3(%rax,%rbp,1),%ebx
mov    %bl,-0x2(%r14,%rdx,1)
movzbl 0x4(%rax,%rbp,1),%ebx
add    $0x4,%rbp
mov    %bl,-0x3(%r14,%rdx,1)
add    $0xfffffffffffffffc,%rdx
cmp    %edx,%ecx
jne    1590 <NV21Transform+0x480>
jmp    14e0 <NV21Transform+0x3d0>
mov    -0x48(%rsp),%rcx
add    %r14,%rcx
lea    (%r11,%r15,1),%rbp
sub    %r11,%r14
add    -0x50(%rsp),%r15
xor    %edx,%edx
xchg   %ax,%ax
movdqu -0x10(%r15,%rdx,1),%xmm1
movdqu (%r15,%rdx,1),%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 %xmm1,(%rcx)
movdqa %xmm2,%xmm1
punpcklbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
punpckhbw %xmm0,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
packuswb %xmm1,%xmm2
movdqu %xmm2,-0x10(%rcx)
add    $0x20,%rdx
add    $0xffffffffffffffe0,%rcx
cmp    %rdx,%r11
jne    15e0 <NV21Transform+0x4d0>
mov    %r11d,%ecx
cmp    %r11,-0x40(%rsp)
je     14e0 <NV21Transform+0x3d0>
jmp    153a <NV21Transform+0x42a>
cmpl   $0x2,-0x28(%rsp)
mov    -0x74(%rsp),%ecx
mov    -0x64(%rsp),%edx
jl     1daa <NV21Transform+0xc9a>
add    %ebx,%r13d
test   %edx,%edx
cmovne %ecx,%r13d
add    $0xffffffff,%r13d
movslq %r13d,%r11
movslq %r10d,%r9
mov    -0x8(%rsp),%rcx
cmp    $0x2,%ecx
mov    $0x1,%r10d
cmovl  %r10d,%ecx
mov    -0x1c(%rsp),%edx
cmp    $0x2,%edx
cmovge %edx,%r10d
mov    %rcx,%r14
mov    %ecx,%r8d
and    $0x7ffffffe,%r8d
xor    %edi,%edi
jmp    16e4 <NV21Transform+0x5d4>
cs nopw 0x0(%rax,%rax,1)
mov    -0x80(%rsp),%rbx
add    %r9,%r11
add    $0x1,%edi
cmp    %r10d,%edi
je     1daa <NV21Transform+0xc9a>
cmp    $0x2,%ebx
jl     16d5 <NV21Transform+0x5c5>
movslq %ebp,%rbp
cmp    $0x4,%ebx
jge    1700 <NV21Transform+0x5f0>
mov    %r11,%rdx
jmp    1740 <NV21Transform+0x630>
cs nopw 0x0(%rax,%rax,1)
mov    %r8d,%ebx
mov    %r11,%rdx
cs nopw 0x0(%rax,%rax,1)
movzbl 0x1(%rax,%rbp,1),%ecx
mov    %cl,-0x1(%rsi,%rdx,1)
movzbl 0x2(%rax,%rbp,1),%ecx
mov    %cl,(%rsi,%rdx,1)
movzbl 0x3(%rax,%rbp,1),%ecx
mov    %cl,-0x3(%rsi,%rdx,1)
movzbl 0x4(%rax,%rbp,1),%ecx
add    $0x4,%rbp
mov    %cl,-0x2(%rsi,%rdx,1)
add    $0xfffffffffffffffc,%rdx
add    $0xfffffffe,%ebx
jne    1710 <NV21Transform+0x600>
test   $0x1,%r14b
je     16d0 <NV21Transform+0x5c0>
mov    0x1(%rbp,%rax,1),%cl
mov    %cl,-0x1(%rsi,%rdx,1)
mov    0x2(%rax,%rbp,1),%cl
add    $0x2,%rbp
mov    %cl,(%rsi,%rdx,1)
jmp    16d0 <NV21Transform+0x5c0>
cmp    $0x2,%ebp
mov    -0x74(%rsp),%edx
jl     1daa <NV21Transform+0xc9a>
mov    %ebx,%ecx
not    %ecx
add    %ecx,%edx
mov    -0x8(%rsp),%rcx
cmp    $0x2,%ecx
mov    $0x1,%r8d
cmovl  %r8d,%ecx
mov    -0x1c(%rsp),%ebp
cmp    $0x2,%ebp
cmovge %ebp,%r8d
movabs $0x1ffffffe0,%rbp
mov    %rcx,%r12
lea    -0x1(%rcx),%r15d
lea    0x3(%rsi,%r15,2),%rcx
mov    %rcx,-0x38(%rsp)
lea    (%rax,%r15,2),%rcx
add    $0x3,%rcx
mov    %rcx,-0x28(%rsp)
lea    0x1(%r15),%rcx
add    $0x18,%rbp
mov    %rcx,-0x60(%rsp)
and    %rcx,%rbp
lea    -0x8(%rbp),%r10
mov    %r10,-0x40(%rsp)
shr    $0x3,%r10
add    $0x1,%r10
mov    %rbp,%rcx
add    %rbp,%rcx
mov    %rcx,-0x48(%rsp)
mov    %r10,%rcx
and    $0xfffffffffffffffe,%rcx
mov    %rcx,-0x50(%rsp)
lea    0x11(%rax),%rcx
mov    %rcx,-0x10(%rsp)
lea    0x11(%rsi),%rcx
mov    %rcx,-0x18(%rsp)
xor    %r13d,%r13d
jmp    1827 <NV21Transform+0x717>
cs nopw 0x0(%rax,%rax,1)
nop
mov    -0x80(%rsp),%rbx
mov    %r14d,%edx
add    $0x1,%r13d
sub    %ebx,%edx
cmp    %r8d,%r13d
je     1daa <NV21Transform+0xc9a>
cmp    $0x2,%ebx
jl     1818 <NV21Transform+0x708>
mov    %edx,%r14d
movslq %edx,%r9
xor    %r11d,%r11d
movslq %edi,%rdi
cmp    $0x7,%r15d
jb     1900 <NV21Transform+0x7f0>
mov    -0x70(%rsp),%rcx
add    %r9,%rcx
mov    -0x28(%rsp),%rdx
add    %rdi,%rdx
cmp    %rdx,%rcx
jae    1870 <NV21Transform+0x760>
mov    -0x38(%rsp),%rcx
add    %r9,%rcx
mov    -0x58(%rsp),%rdx
add    %rdi,%rdx
cmp    %rcx,%rdx
jb     1900 <NV21Transform+0x7f0>
mov    %rbp,%r11
cmpq   $0x0,-0x40(%rsp)
je     1988 <NV21Transform+0x878>
mov    -0x18(%rsp),%rcx
lea    (%rcx,%r9,1),%rbx
mov    -0x10(%rsp),%rcx
lea    (%rcx,%rdi,1),%rbp
mov    -0x50(%rsp),%rcx
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movups -0x10(%rbp,%rdx,2),%xmm0
movups %xmm0,-0x10(%rbx,%rdx,2)
movdqu 0x0(%rbp,%rdx,2),%xmm0
movdqu %xmm0,(%rbx,%rdx,2)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rcx
jne    18a0 <NV21Transform+0x790>
test   $0x1,%r10b
je     18d9 <NV21Transform+0x7c9>
lea    (%rdi,%rdx,2),%rcx
lea    (%r9,%rdx,2),%rdx
movdqu 0x1(%rax,%rcx,1),%xmm0
movdqu %xmm0,0x1(%rsi,%rdx,1)
mov    -0x48(%rsp),%rcx
add    %rcx,%rdi
mov    %r11,%rbp
cmp    %r11,-0x60(%rsp)
je     1810 <NV21Transform+0x700>
add    %rcx,%r9
mov    %ebp,%r11d
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r12d,%ecx
sub    %r11d,%ecx
lea    0x1(%r11),%edx
test   $0x1,%cl
je     192c <NV21Transform+0x81c>
mov    0x1(%rdi,%rax,1),%cl
mov    %cl,0x1(%r9,%rsi,1)
mov    0x2(%rax,%rdi,1),%cl
add    $0x2,%rdi
mov    %cl,0x2(%rsi,%r9,1)
add    $0x2,%r9
mov    %edx,%r11d
cmp    %edx,%r12d
je     1810 <NV21Transform+0x700>
add    -0x30(%rsp),%r9
mov    %r12d,%edx
sub    %r11d,%edx
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl 0x1(%rax,%rdi,1),%ecx
mov    %cl,-0x3(%r9,%rbx,2)
movzbl 0x2(%rax,%rdi,1),%ecx
mov    %cl,-0x2(%r9,%rbx,2)
movzbl 0x3(%rax,%rdi,1),%ecx
mov    %cl,-0x1(%r9,%rbx,2)
movzbl 0x4(%rax,%rdi,1),%ecx
add    $0x4,%rdi
mov    %cl,(%r9,%rbx,2)
add    $0x2,%rbx
cmp    %ebx,%edx
jne    1950 <NV21Transform+0x840>
jmp    1810 <NV21Transform+0x700>
xor    %edx,%edx
test   $0x1,%r10b
jne    18c5 <NV21Transform+0x7b5>
jmp    18d9 <NV21Transform+0x7c9>
mov    %rcx,%rdi
lea    -0x1(%rcx),%edx
xor    %ecx,%ecx
test   %ebp,%ebp
cmove  %edx,%ecx
lea    (%r8,%r8,1),%rbp
add    $0xffffffffffffffff,%rbp
mov    %edi,%edx
test   %edi,%edi
jle    1c6b <NV21Transform+0xb5b>
movslq %ecx,%r12
movslq %edx,%r8
lea    -0x1(%rbx),%ecx
lea    (%r12,%rcx,1),%rdx
add    $0x1,%rdx
mov    %rdx,-0x48(%rsp)
lea    0x1(%rax),%rdx
mov    %rdx,-0x50(%rsp)
lea    0x2(%rcx,%rax,1),%rdx
mov    %rdx,-0x40(%rsp)
lea    0x1(%rcx),%rdx
mov    %rdx,-0x10(%rsp)
and    $0xffffffffffffffe0,%rdx
lea    -0x20(%rdx),%r9
mov    %r9,0x38(%rsp)
shr    $0x5,%r9
add    $0x1,%r9
cmp    $0x1f,%ecx
setae  %r10b
cmp    $0x1,%r8d
sete   %cl
and    %r10b,%cl
mov    %cl,-0x38(%rsp)
mov    %rdx,%rcx
imul   %r8,%rcx
mov    %rcx,0x10(%rsp)
mov    %r9,%rcx
mov    %r9,0x30(%rsp)
and    $0xfffffffffffffffe,%r9
mov    %r9,0x28(%rsp)
lea    0x31(%rax),%rcx
mov    %rcx,0x20(%rsp)
mov    %r8,%r11
shl    $0x5,%r11
mov    %r8,%rcx
shl    $0x6,%rcx
mov    %rdi,%r9
lea    (%r12,%rsi,1),%rdi
add    $0x10,%rdi
mov    %rdi,-0x30(%rsp)
mov    %r9,%rdi
lea    0x0(,%r8,4),%r14
lea    (%r8,%r8,2),%r10
mov    $0xffffffff,%r15d
xor    %r9d,%r9d
mov    %rbp,-0x60(%rsp)
mov    %rdx,-0x18(%rsp)
mov    %rcx,0x18(%rsp)
jmp    1aaa <NV21Transform+0x99a>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    -0x80(%rsp),%rbx
add    %rbp,%r12
add    $0x1,%r9
add    %rbp,-0x30(%rsp)
cmp    %edi,%r9d
je     1c6b <NV21Transform+0xb5b>
test   %ebx,%ebx
jle    1a95 <NV21Transform+0x985>
movslq %r15d,%r15
movl   $0x0,-0x70(%rsp)
cmpb   $0x0,-0x38(%rsp)
je     1af5 <NV21Transform+0x9e5>
lea    (%rsi,%r12,1),%rcx
mov    -0x40(%rsp),%rdx
add    %r15,%rdx
cmp    %rdx,%rcx
jae    1ba7 <NV21Transform+0xa97>
mov    %rbp,%rcx
imul   %r9,%rcx
add    -0x48(%rsp),%rcx
add    %rsi,%rcx
mov    -0x50(%rsp),%rdx
add    %r15,%rdx
cmp    %rcx,%rdx
jae    1ba7 <NV21Transform+0xa97>
mov    %r12,-0x58(%rsp)
mov    %r12,%rcx
mov    %ebx,%edx
mov    -0x70(%rsp),%r12d
sub    %r12d,%edx
not    %r12d
add    %ebx,%r12d
and    $0x3,%edx
je     1b46 <NV21Transform+0xa36>
neg    %edx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
movzbl 0x1(%rax,%r15,1),%ebp
add    $0x1,%r15
mov    %bpl,(%rsi,%rcx,1)
add    %r8,%rcx
add    $0xffffffff,%edi
cmp    %edi,%edx
jne    1b20 <NV21Transform+0xa10>
sub    %edi,-0x70(%rsp)
mov    -0x28(%rsp),%rdi
mov    -0x60(%rsp),%rbp
cmp    $0x3,%r12d
mov    -0x58(%rsp),%r12
jb     1a90 <NV21Transform+0x980>
add    %rsi,%rcx
mov    -0x80(%rsp),%rdx
sub    -0x70(%rsp),%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl 0x1(%rax,%r15,1),%ebx
mov    %bl,(%rcx)
movzbl 0x2(%rax,%r15,1),%ebx
mov    %bl,(%rcx,%r8,1)
movzbl 0x3(%rax,%r15,1),%ebx
mov    %bl,(%rcx,%r8,2)
movzbl 0x4(%rax,%r15,1),%ebx
add    $0x4,%r15
mov    %bl,(%rcx,%r10,1)
add    %r14,%rcx
add    $0xfffffffc,%edx
jne    1b70 <NV21Transform+0xa60>
jmp    1a90 <NV21Transform+0x980>
cmpq   $0x0,0x38(%rsp)
je     1c08 <NV21Transform+0xaf8>
mov    0x20(%rsp),%rcx
lea    (%rcx,%r15,1),%rdx
mov    0x28(%rsp),%rbp
mov    -0x30(%rsp),%rdi
xor    %ecx,%ecx
mov    0x18(%rsp),%rbx
nopl   0x0(%rax)
movups -0x30(%rdx,%rcx,1),%xmm0
movups -0x20(%rdx,%rcx,1),%xmm1
movups %xmm0,-0x10(%rdi)
movups %xmm1,(%rdi)
movdqu -0x10(%rdx,%rcx,1),%xmm0
movdqu (%rdx,%rcx,1),%xmm1
movdqu %xmm0,-0x10(%rdi,%r11,1)
movdqu %xmm1,(%rdi,%r11,1)
add    $0x40,%rcx
add    %rbx,%rdi
add    $0xfffffffffffffffe,%rbp
jne    1bd0 <NV21Transform+0xac0>
jmp    1c0a <NV21Transform+0xafa>
xor    %ecx,%ecx
testb  $0x1,0x30(%rsp)
mov    -0x80(%rsp),%rbx
je     1c38 <NV21Transform+0xb28>
lea    (%rcx,%r15,1),%rdx
imul   %r8,%rcx
add    %r12,%rcx
movdqu 0x1(%rax,%rdx,1),%xmm0
movdqu 0x11(%rax,%rdx,1),%xmm1
movdqu %xmm0,(%rsi,%rcx,1)
movdqu %xmm1,0x10(%rsi,%rcx,1)
mov    -0x18(%rsp),%rdx
add    %rdx,%r15
cmp    %rdx,-0x10(%rsp)
mov    -0x28(%rsp),%rdi
mov    -0x60(%rsp),%rbp
je     1a90 <NV21Transform+0x980>
mov    %r12,-0x58(%rsp)
mov    0x10(%rsp),%rcx
add    %r12,%rcx
mov    %edx,-0x70(%rsp)
jmp    1afd <NV21Transform+0x9ed>
cmpl   $0x0,0x4(%rsp)
je     1c9e <NV21Transform+0xb8e>
mov    %edi,%edx
neg    %edx
cmpl   $0x0,-0x64(%rsp)
mov    0x8(%rsp),%rcx
lea    -0x2(,%rcx,4),%r8
ff
mov    $0xfffffffe,%ecx
cmovne %edx,%ecx
add    -0x74(%rsp),%ecx
cmp    $0x2,%edi
jge    1cc6 <NV21Transform+0xbb6>
jmp    1daa <NV21Transform+0xc9a>
lea    -0x2(%rdi),%edx
xor    %ecx,%ecx
cmpl   $0x0,-0x64(%rsp)
mov    0x8(%rsp),%rbp
lea    -0x2(,%rbp,4),%r8
ff
cmove  %edx,%ecx
add    %r13d,%ecx
mov    %edi,%edx
cmp    $0x2,%edi
jl     1daa <NV21Transform+0xc9a>
add    $0xffffffff,%r13d
mov    -0x8(%rsp),%rdi
cmp    $0x2,%edi
mov    $0x1,%r10d
cmovl  %r10d,%edi
movslq %ecx,%r11
mov    -0x1c(%rsp),%ecx
cmp    $0x2,%ecx
cmovge %ecx,%r10d
movslq %edx,%r15
mov    %rdi,%r12
mov    %edi,%r9d
and    $0x7ffffffe,%r9d
lea    (%r15,%rsi,1),%rbp
add    $0x1,%rbp
xor    %r14d,%r14d
jmp    1d25 <NV21Transform+0xc15>
nopw   0x0(%rax,%rax,1)
mov    -0x80(%rsp),%rbx
add    %r8,%r11
add    $0x1,%r14d
cmp    %r10d,%r14d
je     1daa <NV21Transform+0xc9a>
cmp    $0x2,%ebx
jl     1d15 <NV21Transform+0xc05>
movslq %r13d,%r13
cmp    $0x4,%ebx
jge    1d40 <NV21Transform+0xc30>
mov    %r11,%rdx
jmp    1d8a <NV21Transform+0xc7a>
nopw   0x0(%rax,%rax,1)
mov    %r9d,%ebx
mov    %r11,%rdi
cs nopw 0x0(%rax,%rax,1)
movzbl 0x1(%rax,%r13,1),%edx
mov    %dl,(%rsi,%rdi,1)
movzbl 0x2(%rax,%r13,1),%edx
mov    %dl,0x1(%rsi,%rdi,1)
lea    (%rdi,%r15,1),%rdx
movzbl 0x3(%rax,%r13,1),%ecx
mov    %cl,-0x1(%rbp,%rdi,1)
movzbl 0x4(%rax,%r13,1),%ecx
add    $0x4,%r13
mov    %cl,0x0(%rbp,%rdi,1)
add    %r15,%rdx
mov    %rdx,%rdi
add    $0xfffffffe,%ebx
jne    1d50 <NV21Transform+0xc40>
test   $0x1,%r12b
je     1d10 <NV21Transform+0xc00>
mov    0x1(%r13,%rax,1),%cl
mov    %cl,(%rsi,%rdx,1)
mov    0x2(%rax,%r13,1),%cl
add    $0x2,%r13
mov    %cl,0x1(%rsi,%rdx,1)
jmp    1d10 <NV21Transform+0xc00>
add    $0x40,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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