long kddsrend(const char *buf, long leng, long frameptr, long bpl, long xdim,
              long ydim, long xoff, long yoff) {
  long x, y, z, xx, yy, xsiz, ysiz, dxt, al[2], ai, j, k, v, c0, c1, stride;
  unsigned long lut[256], r[4], g[4], b[4], a[8], rr, gg, bb;
  unsigned char *uptr, *wptr;
  xsiz = (*(long *)&buf[16]);
  ysiz = (*(long *)&buf[12]);
  if ((*(long *)&buf[80]) & (64)) {
    if ((*(long *)&buf[88]) != (32))
      return (-1);
    if ((*(long *)&buf[92]) != (0x00ff0000))
      return (-1);
    if ((*(long *)&buf[96]) != (0x0000ff00))
      return (-1);
    if ((*(long *)&buf[100]) != (0x000000ff))
      return (-1);
    if ((*(long *)&buf[104]) != (0xff000000))
      return (-1);
    buf += 128;
    j = yoff * bpl + (xoff << 2) + frameptr;
    xx = (xsiz << 2);
    if (xoff < 0) {
      j -= (xoff << 2);
      buf -= (xoff << 2);
      xsiz += xoff;
    }
    xsiz = ((((xsiz) < (xdim - xoff)) ? (xsiz) : (xdim - xoff)) << 2);
    ysiz = (((ysiz) < (ydim)) ? (ysiz) : (ydim));
    for (y = 0; y < ysiz; y++, j += bpl, buf += xx) {
      if ((unsigned long)(y + yoff) >= (unsigned long)ydim)
        continue;
      memcpy((void *)j, (void *)buf, xsiz);
    }
    return (0);
  }
  if (!((*(long *)&buf[80]) & (4)))
    return (-1);
  dxt = buf[87] - '0';
  if ((buf[84] != 'D') || (buf[85] != 'X') || (buf[86] != 'T') || (dxt < 1) ||
      (dxt > 5))
    return (-1);
  buf += 128;
  if (!(dxt & 1)) {
    for (z = 256 - 1; z > 0; z--)
      lut[z] = (255 << 16) / z;
    lut[0] = (1 << 16);
  }
  if (dxt == 1)
    stride = (xsiz << 1);
  else
    stride = (xsiz << 2);
  for (y = 0; y < ysiz; y += 4, buf += stride)
    for (x = 0; x < xsiz; x += 4) {
      if (dxt == 1)
        uptr = (unsigned char *)(((long)buf) + (x << 1));
      else
        uptr = (unsigned char *)(((long)buf) + (x << 2) + 8);
      c0 = (*(unsigned short *)&uptr[0]);
      r[0] = ((c0 >> 8) & 0xf8);
      g[0] = ((c0 >> 3) & 0xfc);
      b[0] = ((c0 << 3) & 0xfc);
      a[0] = 255;
      c1 = (*(unsigned short *)&uptr[2]);
      r[1] = ((c1 >> 8) & 0xf8);
      g[1] = ((c1 >> 3) & 0xfc);
      b[1] = ((c1 << 3) & 0xfc);
      a[1] = 255;
      if ((c0 > c1) || (dxt != 1)) {
        r[2] = (((r[0] * 2 + r[1] + 1) * (65536 / 3)) >> 16);
        g[2] = (((g[0] * 2 + g[1] + 1) * (65536 / 3)) >> 16);
        b[2] = (((b[0] * 2 + b[1] + 1) * (65536 / 3)) >> 16);
        a[2] = 255;
        r[3] = (((r[0] + r[1] * 2 + 1) * (65536 / 3)) >> 16);
        g[3] = (((g[0] + g[1] * 2 + 1) * (65536 / 3)) >> 16);
        b[3] = (((b[0] + b[1] * 2 + 1) * (65536 / 3)) >> 16);
        a[3] = 255;
      } else {
        r[2] = (r[0] + r[1]) >> 1;
        g[2] = (g[0] + g[1]) >> 1;
        b[2] = (b[0] + b[1]) >> 1;
        a[2] = 255;
        r[3] = g[3] = b[3] = a[3] = 0;
      }
      v = (*(long *)&uptr[4]);
      if (dxt >= 4) {
        a[0] = uptr[-8];
        a[1] = uptr[-7];
        k = a[1] - a[0];
        if (k < 0) {
          z = a[0] * 6 + a[1] + 3;
          for (j = 2; j < 8; j++) {
            a[j] = ((z * (65536 / 7)) >> 16);
            z += k;
          }
        } else {
          z = a[0] * 4 + a[1] + 2;
          for (j = 2; j < 6; j++) {
            a[j] = ((z * (65536 / 5)) >> 16);
            z += k;
          }
          a[6] = 0;
          a[7] = 255;
        }
        al[0] = (*(long *)&uptr[-6]);
        al[1] = (*(long *)&uptr[-3]);
      }
      wptr = (unsigned char *)((y + yoff) * bpl + ((x + xoff) << 2) + frameptr);
      ai = 0;
      for (yy = 0; yy < 4; yy++, wptr += bpl) {
        if ((unsigned long)(y + yy + yoff) >= (unsigned long)ydim) {
          ai += 4;
          continue;
        }
        for (xx = 0; xx < 4; xx++, ai++) {
          if ((unsigned long)(x + xx + xoff) >= (unsigned long)xdim)
            continue;
          j = ((v >> (ai << 1)) & 3);
          switch (dxt) {
          case 1:
            z = a[j];
            break;
          case 2:
          case 3:
            z = ((uptr[(ai >> 1) - 8] >> ((xx & 1) << 2)) & 15) * 17;
            break;
          case 4:
          case 5:
            z = a[(al[yy >> 1] >> ((ai & 7) * 3)) & 7];
            break;
          }
          rr = r[j];
          gg = g[j];
          bb = b[j];
          if (!(dxt & 1)) {
            bb = ((((bb * lut[z]) >> 16) < (255)) ? ((bb * lut[z]) >> 16)
                                                  : (255));
            gg = ((((gg * lut[z]) >> 16) < (255)) ? ((gg * lut[z]) >> 16)
                                                  : (255));
            rr = ((((rr * lut[z]) >> 16) < (255)) ? ((rr * lut[z]) >> 16)
                                                  : (255));
          }
          wptr[(xx << 2) + 0] = bb;
          wptr[(xx << 2) + 1] = gg;
          wptr[(xx << 2) + 2] = rr;
          wptr[(xx << 2) + 3] = z;
        }
      }
    }
  return (0);
}


x86 assembly (clang, -O0):
<kddsrend>:
push   %rbp
mov    %rsp,%rbp
sub    $0x9d0,%rsp
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9,-0x38(%rbp)
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
mov    %rax,-0x68(%rbp)
mov    -0x10(%rbp),%rax
mov    0xc(%rax),%rax
mov    %rax,-0x70(%rbp)
mov    -0x10(%rbp),%rax
mov    0x50(%rax),%rax
and    $0x40,%rax
cmp    $0x0,%rax
je     1377 <kddsrend+0x267>
mov    -0x10(%rbp),%rax
cmpq   $0x20,0x58(%rax)
je     1185 <kddsrend+0x75>
movq   $0xffffffffffffffff,-0x8(%rbp)
ff
jmp    1d1a <kddsrend+0xc0a>
mov    -0x10(%rbp),%rax
cmpq   $0xff0000,0x5c(%rax)
je     11a4 <kddsrend+0x94>
movq   $0xffffffffffffffff,-0x8(%rbp)
ff
jmp    1d1a <kddsrend+0xc0a>
mov    -0x10(%rbp),%rax
cmpq   $0xff00,0x60(%rax)
je     11c3 <kddsrend+0xb3>
movq   $0xffffffffffffffff,-0x8(%rbp)
ff
jmp    1d1a <kddsrend+0xc0a>
mov    -0x10(%rbp),%rax
cmpq   $0xff,0x64(%rax)
je     11e2 <kddsrend+0xd2>
movq   $0xffffffffffffffff,-0x8(%rbp)
ff
jmp    1d1a <kddsrend+0xc0a>
mov    -0x10(%rbp),%rax
mov    $0xff000000,%ecx
cmp    %rcx,0x68(%rax)
je     1202 <kddsrend+0xf2>
movq   $0xffffffffffffffff,-0x8(%rbp)
ff
jmp    1d1a <kddsrend+0xc0a>
mov    -0x10(%rbp),%rax
add    $0x80,%rax
mov    %rax,-0x10(%rbp)
mov    0x18(%rbp),%rax
imul   -0x28(%rbp),%rax
mov    0x10(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
add    -0x20(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0x68(%rbp),%rax
shl    $0x2,%rax
mov    %rax,-0x58(%rbp)
cmpq   $0x0,0x10(%rbp)
jge    1283 <kddsrend+0x173>
mov    0x10(%rbp),%rcx
shl    $0x2,%rcx
mov    -0xa0(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0xa0(%rbp)
mov    0x10(%rbp),%rdx
shl    $0x2,%rdx
mov    -0x10(%rbp),%rax
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x10(%rbp)
mov    0x10(%rbp),%rax
add    -0x68(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x68(%rbp),%rax
mov    -0x30(%rbp),%rcx
sub    0x10(%rbp),%rcx
cmp    %rcx,%rax
jge    12a8 <kddsrend+0x198>
mov    -0x68(%rbp),%rax
mov    %rax,-0x9a0(%rbp)
jmp    12b7 <kddsrend+0x1a7>
mov    -0x30(%rbp),%rax
sub    0x10(%rbp),%rax
mov    %rax,-0x9a0(%rbp)
mov    -0x9a0(%rbp),%rax
shl    $0x2,%rax
mov    %rax,-0x68(%rbp)
mov    -0x70(%rbp),%rax
cmp    -0x38(%rbp),%rax
jge    12e4 <kddsrend+0x1d4>
mov    -0x70(%rbp),%rax
mov    %rax,-0x9a8(%rbp)
jmp    12ef <kddsrend+0x1df>
mov    -0x38(%rbp),%rax
mov    %rax,-0x9a8(%rbp)
mov    -0x9a8(%rbp),%rax
mov    %rax,-0x70(%rbp)
movq   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x70(%rbp),%rax
jge    136a <kddsrend+0x25a>
mov    -0x48(%rbp),%rax
add    0x18(%rbp),%rax
cmp    -0x38(%rbp),%rax
jb     1327 <kddsrend+0x217>
jmp    133b <kddsrend+0x22b>
mov    -0xa0(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x68(%rbp),%rdx
call   1030 <memcpy@plt>
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
mov    -0x28(%rbp),%rax
add    -0xa0(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0x58(%rbp),%rax
add    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
jmp    1302 <kddsrend+0x1f2>
movq   $0x0,-0x8(%rbp)
jmp    1d1a <kddsrend+0xc0a>
mov    -0x10(%rbp),%rax
mov    0x50(%rax),%rax
and    $0x4,%rax
cmp    $0x0,%rax
jne    139a <kddsrend+0x28a>
movq   $0xffffffffffffffff,-0x8(%rbp)
ff
jmp    1d1a <kddsrend+0xc0a>
mov    -0x10(%rbp),%rax
movsbl 0x57(%rax),%eax
sub    $0x30,%eax
cltq
mov    %rax,-0x78(%rbp)
mov    -0x10(%rbp),%rax
movsbl 0x54(%rax),%eax
cmp    $0x44,%eax
jne    13f4 <kddsrend+0x2e4>
mov    -0x10(%rbp),%rax
movsbl 0x55(%rax),%eax
cmp    $0x58,%eax
jne    13f4 <kddsrend+0x2e4>
mov    -0x10(%rbp),%rax
movsbl 0x56(%rax),%eax
cmp    $0x54,%eax
jne    13f4 <kddsrend+0x2e4>
cmpq   $0x1,-0x78(%rbp)
jl     13f4 <kddsrend+0x2e4>
cmpq   $0x5,-0x78(%rbp)
jle    1401 <kddsrend+0x2f1>
movq   $0xffffffffffffffff,-0x8(%rbp)
ff
jmp    1d1a <kddsrend+0xc0a>
mov    -0x10(%rbp),%rax
add    $0x80,%rax
mov    %rax,-0x10(%rbp)
mov    -0x78(%rbp),%rax
and    $0x1,%rax
cmp    $0x0,%rax
jne    146a <kddsrend+0x35a>
movq   $0xff,-0x50(%rbp)
cmpq   $0x0,-0x50(%rbp)
jle    145f <kddsrend+0x34f>
mov    $0xff0000,%eax
cqto
idivq  -0x50(%rbp)
mov    %rax,%rcx
mov    -0x50(%rbp),%rax
mov    %rcx,-0x8d0(%rbp,%rax,8)
ff
mov    -0x50(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x50(%rbp)
jmp    1429 <kddsrend+0x319>
movq   $0x10000,-0x8d0(%rbp)
cmpq   $0x1,-0x78(%rbp)
jne    1489 <kddsrend+0x379>
mov    -0x68(%rbp),%rax
shl    $0x1,%rax
mov    %rax,-0xc8(%rbp)
jmp    1498 <kddsrend+0x388>
mov    -0x68(%rbp),%rax
shl    $0x2,%rax
mov    %rax,-0xc8(%rbp)
movq   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x70(%rbp),%rax
jge    1d12 <kddsrend+0xc02>
movq   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x68(%rbp),%rax
jge    1ced <kddsrend+0xbdd>
cmpq   $0x1,-0x78(%rbp)
jne    14ea <kddsrend+0x3da>
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    %rax,-0x990(%rbp)
jmp    1504 <kddsrend+0x3f4>
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
add    $0x8,%rax
mov    %rax,-0x990(%rbp)
mov    -0x990(%rbp),%rax
movzwl (%rax),%eax
mov    %rax,-0xb8(%rbp)
mov    -0xb8(%rbp),%rax
sar    $0x8,%rax
and    $0xf8,%rax
mov    %rax,-0x8f0(%rbp)
mov    -0xb8(%rbp),%rax
sar    $0x3,%rax
and    $0xfc,%rax
mov    %rax,-0x910(%rbp)
mov    -0xb8(%rbp),%rax
shl    $0x3,%rax
and    $0xfc,%rax
mov    %rax,-0x930(%rbp)
movq   $0xff,-0x970(%rbp)
mov    -0x990(%rbp),%rax
movzwl 0x2(%rax),%eax
mov    %rax,-0xc0(%rbp)
mov    -0xc0(%rbp),%rax
sar    $0x8,%rax
and    $0xf8,%rax
mov    %rax,-0x8e8(%rbp)
mov    -0xc0(%rbp),%rax
sar    $0x3,%rax
and    $0xfc,%rax
mov    %rax,-0x908(%rbp)
mov    -0xc0(%rbp),%rax
shl    $0x3,%rax
and    $0xfc,%rax
mov    %rax,-0x928(%rbp)
movq   $0xff,-0x968(%rbp)
mov    -0xb8(%rbp),%rax
cmp    -0xc0(%rbp),%rax
jg     15ec <kddsrend+0x4dc>
cmpq   $0x1,-0x78(%rbp)
je     1700 <kddsrend+0x5f0>
mov    -0x8f0(%rbp),%rax
shl    $0x1,%rax
add    -0x8e8(%rbp),%rax
add    $0x1,%rax
imul   $0x5555,%rax,%rax
shr    $0x10,%rax
mov    %rax,-0x8e0(%rbp)
mov    -0x910(%rbp),%rax
shl    $0x1,%rax
add    -0x908(%rbp),%rax
add    $0x1,%rax
imul   $0x5555,%rax,%rax
shr    $0x10,%rax
mov    %rax,-0x900(%rbp)
mov    -0x930(%rbp),%rax
shl    $0x1,%rax
add    -0x928(%rbp),%rax
add    $0x1,%rax
imul   $0x5555,%rax,%rax
shr    $0x10,%rax
mov    %rax,-0x920(%rbp)
movq   $0xff,-0x960(%rbp)
mov    -0x8f0(%rbp),%rax
mov    -0x8e8(%rbp),%rcx
shl    $0x1,%rcx
add    %rcx,%rax
add    $0x1,%rax
imul   $0x5555,%rax,%rax
shr    $0x10,%rax
mov    %rax,-0x8d8(%rbp)
mov    -0x910(%rbp),%rax
mov    -0x908(%rbp),%rcx
shl    $0x1,%rcx
add    %rcx,%rax
add    $0x1,%rax
imul   $0x5555,%rax,%rax
shr    $0x10,%rax
mov    %rax,-0x8f8(%rbp)
mov    -0x930(%rbp),%rax
mov    -0x928(%rbp),%rcx
shl    $0x1,%rcx
add    %rcx,%rax
add    $0x1,%rax
imul   $0x5555,%rax,%rax
shr    $0x10,%rax
mov    %rax,-0x918(%rbp)
movq   $0xff,-0x958(%rbp)
jmp    1782 <kddsrend+0x672>
mov    -0x8f0(%rbp),%rax
add    -0x8e8(%rbp),%rax
shr    $0x1,%rax
mov    %rax,-0x8e0(%rbp)
mov    -0x910(%rbp),%rax
add    -0x908(%rbp),%rax
shr    $0x1,%rax
mov    %rax,-0x900(%rbp)
mov    -0x930(%rbp),%rax
add    -0x928(%rbp),%rax
shr    $0x1,%rax
mov    %rax,-0x920(%rbp)
movq   $0xff,-0x960(%rbp)
movq   $0x0,-0x958(%rbp)
movq   $0x0,-0x918(%rbp)
movq   $0x0,-0x8f8(%rbp)
movq   $0x0,-0x8d8(%rbp)
mov    -0x990(%rbp),%rax
mov    0x4(%rax),%rax
mov    %rax,-0xb0(%rbp)
cmpq   $0x4,-0x78(%rbp)
jl     190a <kddsrend+0x7fa>
mov    -0x990(%rbp),%rax
movzbl -0x8(%rax),%eax
mov    %rax,-0x970(%rbp)
mov    -0x990(%rbp),%rax
movzbl -0x7(%rax),%eax
mov    %rax,-0x968(%rbp)
mov    -0x968(%rbp),%rax
sub    -0x970(%rbp),%rax
mov    %rax,-0xa8(%rbp)
cmpq   $0x0,-0xa8(%rbp)
jge    185c <kddsrend+0x74c>
imul   $0x6,-0x970(%rbp),%rax
06
add    -0x968(%rbp),%rax
add    $0x3,%rax
mov    %rax,-0x50(%rbp)
movq   $0x2,-0xa0(%rbp)
cmpq   $0x8,-0xa0(%rbp)
08
jge    1857 <kddsrend+0x747>
imul   $0x2492,-0x50(%rbp),%rcx
sar    $0x10,%rcx
mov    -0xa0(%rbp),%rax
mov    %rcx,-0x970(%rbp,%rax,8)
ff
mov    -0xa8(%rbp),%rax
add    -0x50(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0xa0(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xa0(%rbp)
jmp    1808 <kddsrend+0x6f8>
jmp    18e6 <kddsrend+0x7d6>
mov    -0x970(%rbp),%rax
shl    $0x2,%rax
add    -0x968(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x50(%rbp)
movq   $0x2,-0xa0(%rbp)
cmpq   $0x6,-0xa0(%rbp)
06
jge    18d0 <kddsrend+0x7c0>
imul   $0x3333,-0x50(%rbp),%rcx
sar    $0x10,%rcx
mov    -0xa0(%rbp),%rax
mov    %rcx,-0x970(%rbp,%rax,8)
ff
mov    -0xa8(%rbp),%rax
add    -0x50(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0xa0(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xa0(%rbp)
jmp    1881 <kddsrend+0x771>
movq   $0x0,-0x940(%rbp)
movq   $0xff,-0x938(%rbp)
mov    -0x990(%rbp),%rax
mov    -0x6(%rax),%rax
mov    %rax,-0x90(%rbp)
mov    -0x990(%rbp),%rax
mov    -0x3(%rax),%rax
mov    %rax,-0x88(%rbp)
mov    -0x48(%rbp),%rax
add    0x18(%rbp),%rax
imul   -0x28(%rbp),%rax
mov    -0x40(%rbp),%rcx
add    0x10(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x998(%rbp)
movq   $0x0,-0x98(%rbp)
movq   $0x0,-0x60(%rbp)
cmpq   $0x4,-0x60(%rbp)
jge    1cd7 <kddsrend+0xbc7>
mov    -0x48(%rbp),%rax
add    -0x60(%rbp),%rax
add    0x18(%rbp),%rax
cmp    -0x38(%rbp),%rax
jb     197c <kddsrend+0x86c>
mov    -0x98(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x98(%rbp)
jmp    1cb4 <kddsrend+0xba4>
movq   $0x0,-0x58(%rbp)
cmpq   $0x4,-0x58(%rbp)
jge    1caf <kddsrend+0xb9f>
mov    -0x40(%rbp),%rax
add    -0x58(%rbp),%rax
add    0x10(%rbp),%rax
cmp    -0x30(%rbp),%rax
jb     19aa <kddsrend+0x89a>
jmp    1c8c <kddsrend+0xb7c>
mov    -0xb0(%rbp),%rax
mov    -0x98(%rbp),%cl
add    %cl,%cl
sar    %cl,%rax
and    $0x3,%eax
mov    %rax,-0xa0(%rbp)
mov    -0x78(%rbp),%rax
mov    %rax,-0x9b0(%rbp)
sub    $0x1,%rax
je     1a14 <kddsrend+0x904>
jmp    19e0 <kddsrend+0x8d0>
mov    -0x9b0(%rbp),%rax
add    $0xfffffffffffffffe,%rax
sub    $0x2,%rax
jb     1a2c <kddsrend+0x91c>
jmp    19fa <kddsrend+0x8ea>
mov    -0x9b0(%rbp),%rax
add    $0xfffffffffffffffc,%rax
sub    $0x2,%rax
jb     1a65 <kddsrend+0x955>
jmp    1a97 <kddsrend+0x987>
mov    -0xa0(%rbp),%rax
mov    -0x970(%rbp,%rax,8),%rax
ff
mov    %rax,-0x50(%rbp)
jmp    1a97 <kddsrend+0x987>
mov    -0x990(%rbp),%rax
mov    -0x98(%rbp),%rcx
sar    $0x1,%rcx
sub    $0x8,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x58(%rbp),%rcx
and    $0x1,%rcx
shl    $0x2,%rcx
sar    %cl,%eax
and    $0xf,%eax
imul   $0x11,%eax,%eax
cltq
mov    %rax,-0x50(%rbp)
jmp    1a97 <kddsrend+0x987>
mov    -0x60(%rbp),%rax
sar    $0x1,%rax
mov    -0x90(%rbp,%rax,8),%rax
ff
mov    -0x98(%rbp),%rcx
and    $0x7,%rcx
imul   $0x3,%rcx,%rcx
sar    %cl,%rax
and    $0x7,%rax
mov    -0x970(%rbp,%rax,8),%rax
ff
mov    %rax,-0x50(%rbp)
mov    -0xa0(%rbp),%rax
mov    -0x8f0(%rbp,%rax,8),%rax
ff
mov    %rax,-0x978(%rbp)
mov    -0xa0(%rbp),%rax
mov    -0x910(%rbp,%rax,8),%rax
ff
mov    %rax,-0x980(%rbp)
mov    -0xa0(%rbp),%rax
mov    -0x930(%rbp,%rax,8),%rax
ff
mov    %rax,-0x988(%rbp)
mov    -0x78(%rbp),%rax
and    $0x1,%rax
cmp    $0x0,%rax
jne    1c20 <kddsrend+0xb10>
mov    -0x988(%rbp),%rax
mov    -0x50(%rbp),%rcx
imul   -0x8d0(%rbp,%rcx,8),%rax
ff ff
shr    $0x10,%rax
cmp    $0xff,%rax
jae    1b33 <kddsrend+0xa23>
mov    -0x988(%rbp),%rax
mov    -0x50(%rbp),%rcx
imul   -0x8d0(%rbp,%rcx,8),%rax
ff ff
shr    $0x10,%rax
mov    %rax,-0x9b8(%rbp)
jmp    1b44 <kddsrend+0xa34>
mov    $0xff,%eax
mov    %rax,-0x9b8(%rbp)
jmp    1b44 <kddsrend+0xa34>
mov    -0x9b8(%rbp),%rax
mov    %rax,-0x988(%rbp)
mov    -0x980(%rbp),%rax
mov    -0x50(%rbp),%rcx
imul   -0x8d0(%rbp,%rcx,8),%rax
ff ff
shr    $0x10,%rax
cmp    $0xff,%rax
jae    1b9a <kddsrend+0xa8a>
mov    -0x980(%rbp),%rax
mov    -0x50(%rbp),%rcx
imul   -0x8d0(%rbp,%rcx,8),%rax
ff ff
shr    $0x10,%rax
mov    %rax,-0x9c0(%rbp)
jmp    1bab <kddsrend+0xa9b>
mov    $0xff,%eax
mov    %rax,-0x9c0(%rbp)
jmp    1bab <kddsrend+0xa9b>
mov    -0x9c0(%rbp),%rax
mov    %rax,-0x980(%rbp)
mov    -0x978(%rbp),%rax
mov    -0x50(%rbp),%rcx
imul   -0x8d0(%rbp,%rcx,8),%rax
ff ff
shr    $0x10,%rax
cmp    $0xff,%rax
jae    1c01 <kddsrend+0xaf1>
mov    -0x978(%rbp),%rax
mov    -0x50(%rbp),%rcx
imul   -0x8d0(%rbp,%rcx,8),%rax
ff ff
shr    $0x10,%rax
mov    %rax,-0x9c8(%rbp)
jmp    1c12 <kddsrend+0xb02>
mov    $0xff,%eax
mov    %rax,-0x9c8(%rbp)
jmp    1c12 <kddsrend+0xb02>
mov    -0x9c8(%rbp),%rax
mov    %rax,-0x978(%rbp)
mov    -0x988(%rbp),%rax
mov    %al,%dl
mov    -0x998(%rbp),%rax
mov    -0x58(%rbp),%rcx
shl    $0x2,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x980(%rbp),%rax
mov    %al,%dl
mov    -0x998(%rbp),%rax
mov    -0x58(%rbp),%rcx
shl    $0x2,%rcx
mov    %dl,0x1(%rax,%rcx,1)
mov    -0x978(%rbp),%rax
mov    %al,%dl
mov    -0x998(%rbp),%rax
mov    -0x58(%rbp),%rcx
shl    $0x2,%rcx
mov    %dl,0x2(%rax,%rcx,1)
mov    -0x50(%rbp),%rax
mov    %al,%dl
mov    -0x998(%rbp),%rax
mov    -0x58(%rbp),%rcx
shl    $0x2,%rcx
mov    %dl,0x3(%rax,%rcx,1)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
mov    -0x98(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x98(%rbp)
jmp    1984 <kddsrend+0x874>
jmp    1cb4 <kddsrend+0xba4>
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
mov    -0x28(%rbp),%rax
add    -0x998(%rbp),%rax
mov    %rax,-0x998(%rbp)
jmp    1944 <kddsrend+0x834>
jmp    1cdc <kddsrend+0xbcc>
mov    -0x40(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x40(%rbp)
jmp    14b6 <kddsrend+0x3a6>
jmp    1cf2 <kddsrend+0xbe2>
mov    -0x48(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x48(%rbp)
mov    -0xc8(%rbp),%rax
add    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
jmp    14a0 <kddsrend+0x390>
movq   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x9d0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<kddsrend>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x968,%rsp
mov    %r8,%r15
mov    %rcx,%r12
mov    0x9a8(%rsp),%rbp
mov    0x9a0(%rsp),%r10
mov    0xc(%rdi),%r8
mov    0x10(%rdi),%rsi
mov    0x50(%rdi),%r14
test   $0x40,%r14b
jne    11ec <kddsrend+0xdc>
test   $0x4,%r14b
je     12d5 <kddsrend+0x1c5>
movabs $0xffff00000000,%rax
and    %r14,%rax
movabs $0x584400000000,%rcx
cmp    %rcx,%rax
jne    12d5 <kddsrend+0x1c5>
movq   $0xffffffffffffffff,0x8(%rsp)
ff ff
movabs $0xff000000000000,%rax
and    %r14,%rax
movabs $0x54000000000000,%rcx
cmp    %rcx,%rax
jne    12de <kddsrend+0x1ce>
mov    %r14,%rax
shr    $0x38,%rax
cmp    $0x31,%al
jl     12de <kddsrend+0x1ce>
cmp    $0x35,%al
jg     12de <kddsrend+0x1ce>
mov    %rax,0xc0(%rsp)
mov    %rdx,0xa8(%rsp)
mov    %r14,%r11
sar    $0x38,%r11
lea    -0x30(%r11),%rax
mov    %rax,0x48(%rsp)
bt     $0x38,%r14
jb     139a <kddsrend+0x28a>
mov    $0xfd,%ecx
jmp    131e <kddsrend+0x20e>
cmpq   $0x20,0x58(%rdi)
jne    12d5 <kddsrend+0x1c5>
cmpq   $0xff0000,0x5c(%rdi)
jne    12d5 <kddsrend+0x1c5>
cmpq   $0xff00,0x60(%rdi)
jne    12d5 <kddsrend+0x1c5>
movq   $0xffffffffffffffff,0x8(%rsp)
ff ff
cmpq   $0xff,0x64(%rdi)
jne    12de <kddsrend+0x1ce>
mov    $0xff000000,%eax
cmp    %rax,0x68(%rdi)
jne    12de <kddsrend+0x1ce>
mov    %r10,%rax
sar    $0x3f,%rax
mov    %rax,%rcx
and    %r10,%rcx
add    %rsi,%rcx
sub    %r10,%r15
cmp    %r15,%rcx
cmovl  %rcx,%r15
cmp    %r9,%r8
cmovge %r9,%r8
test   %r8,%r8
jle    1991 <kddsrend+0x881>
shl    $0x2,%r10
shl    $0x2,%r15
mov    %r10,%rcx
neg    %rcx
and    %rax,%rcx
lea    (%rdi,%rcx,1),%rbx
add    $0x80,%rbx
mov    %rbp,%rdi
imul   %r12,%rdi
add    %r10,%rdi
add    %rdx,%rdi
and    %r10,%rax
sub    %rax,%rdi
cmp    $0x1,%r8
mov    %r9,0x18(%rsp)
mov    %r8,0x30(%rsp)
jne    199d <kddsrend+0x88d>
xor    %ebp,%ebp
xor    %eax,%eax
mov    %rax,0x8(%rsp)
testb  $0x1,0x30(%rsp)
je     12de <kddsrend+0x1ce>
add    0x9a8(%rsp),%rbp
cmp    0x18(%rsp),%rbp
jae    12de <kddsrend+0x1ce>
mov    %rbx,%rsi
mov    %r15,%rdx
call   1030 <memcpy@plt>
jmp    1991 <kddsrend+0x881>
movq   $0xffffffffffffffff,0x8(%rsp)
ff ff
mov    0x8(%rsp),%rax
add    $0x968,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
cs nopw 0x0(%rax,%rax,1)
nop
mov    $0xff0000,%eax
xor    %edx,%edx
div    %ecx
mov    %rax,0x160(%rsp,%rcx,8)
lea    -0x3(%rcx),%rax
cmp    $0x1,%rcx
mov    %rax,%rcx
jbe    138e <kddsrend+0x27e>
lea    0x2(%rcx),%rbx
cmp    $0xff0000,%rbx
ja     1340 <kddsrend+0x230>
mov    $0xff0000,%eax
xor    %edx,%edx
div    %ebx
jmp    1342 <kddsrend+0x232>
cs nopw 0x0(%rax,%rax,1)
xor    %eax,%eax
mov    %rax,0x170(%rsp,%rcx,8)
lea    0x1(%rcx),%rbx
cmp    $0xff0000,%rbx
ja     1370 <kddsrend+0x260>
mov    $0xff0000,%eax
xor    %edx,%edx
div    %ebx
jmp    1372 <kddsrend+0x262>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xor    %eax,%eax
mov    %rax,0x168(%rsp,%rcx,8)
cmp    $0xff0000,%rcx
jbe    1300 <kddsrend+0x1f0>
xor    %eax,%eax
jmp    1309 <kddsrend+0x1f9>
movq   $0x10000,0x160(%rsp)
cmpq   $0x1,0x48(%rsp)
sete   %al
mov    $0x2,%cl
sub    %al,%cl
mov    %rsi,%rax
shl    %cl,%rax
mov    %rax,0xb0(%rsp)
test   %r8,%r8
jle    1991 <kddsrend+0x881>
mov    %r12,0x20(%rsp)
mov    %r9,0x18(%rsp)
sub    $0xffffffffffffff80,%rdi
xor    %eax,%eax
mov    %rax,0x8(%rsp)
movaps 0xc26(%rip),%xmm0
movaps 0xc2f(%rip),%xmm1
xor    %ecx,%ecx
xor    %ebp,%ebp
mov    %r8,0x30(%rsp)
mov    %rsi,0x10(%rsp)
jmp    1427 <kddsrend+0x317>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0xb8(%rsp),%rcx
add    $0x4,%rcx
add    0xb0(%rsp),%rdi
cmp    0x30(%rsp),%rcx
mov    0x9a0(%rsp),%r10
jge    12de <kddsrend+0x1ce>
test   %rsi,%rsi
mov    %rcx,0xb8(%rsp)
jle    1400 <kddsrend+0x2f0>
lea    0x8(%rdi),%rax
mov    %rax,0xd0(%rsp)
mov    0x9a8(%rsp),%rax
add    %rcx,%rax
mov    %rax,0xe0(%rsp)
imul   0x20(%rsp),%rax
add    0xa8(%rsp),%rax
mov    %rax,0xc8(%rsp)
mov    %r10,0x58(%rsp)
xor    %edx,%edx
mov    %rdi,0xd8(%rsp)
jmp    14a5 <kddsrend+0x395>
nopw   0x0(%rax,%rax,1)
mov    0x50(%rsp),%rdx
add    $0x4,%rdx
addq   $0x4,0x58(%rsp)
mov    0x10(%rsp),%rsi
cmp    %rsi,%rdx
mov    0xd8(%rsp),%rdi
jge    1400 <kddsrend+0x2f0>
mov    0x48(%rsp),%r12
cmp    $0x1,%r12
lea    (%rdi,%rdx,2),%rax
mov    0xd0(%rsp),%rcx
mov    %rdx,0x50(%rsp)
lea    (%rcx,%rdx,4),%rdx
cmove  %rax,%rdx
movzwl (%rdx),%r10d
movzwl %r10w,%ebx
mov    %rbx,%rsi
shr    $0x8,%rsi
and    $0xfffffff8,%esi
mov    %rsi,0x130(%rsp)
shr    $0x3,%rbx
and    $0xfc,%ebx
mov    %rbx,0x110(%rsp)
mov    %r10d,%ecx
shl    $0x3,%ecx
movzbl %cl,%r8d
mov    %r8,0xf0(%rsp)
mov    %rdx,%rax
mov    %rdx,0x28(%rsp)
movzwl 0x2(%rdx),%eax
movzwl %ax,%ecx
mov    %rcx,%rdi
shr    $0x8,%rdi
and    $0xfffffff8,%edi
mov    %rdi,0x138(%rsp)
shr    $0x3,%rcx
and    $0xfc,%ecx
mov    %rcx,0x118(%rsp)
mov    %eax,%edx
shl    $0x3,%edx
movzbl %dl,%r9d
mov    %r9,0xf8(%rsp)
movaps %xmm0,0x60(%rsp)
cmp    %ax,%r10w
ja     15c0 <kddsrend+0x4b0>
cmp    $0x1,%r12
jne    15c0 <kddsrend+0x4b0>
add    %rsi,%rdi
shr    %rdi
mov    %rdi,0x140(%rsp)
add    %rbx,%rcx
shr    %rcx
mov    %rcx,0x120(%rsp)
add    %r8,%r9
shr    %r9
mov    %r9,0x100(%rsp)
movaps %xmm1,0x70(%rsp)
movq   $0x0,0x108(%rsp)
movq   $0x0,0x128(%rsp)
movq   $0x0,0x148(%rsp)
jmp    1673 <kddsrend+0x563>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    (%rdi,%rsi,2),%rax
imul   $0x5555,%rax,%rax
add    $0x5555,%rax
shr    $0x10,%rax
mov    %rax,0x140(%rsp)
lea    (%rcx,%rbx,2),%rax
imul   $0x5555,%rax,%rax
add    $0x5555,%rax
shr    $0x10,%rax
mov    %rax,0x120(%rsp)
lea    (%r9,%r8,2),%rax
imul   $0x5555,%rax,%rax
add    $0x5555,%rax
shr    $0x10,%rax
mov    %rax,0x100(%rsp)
lea    (%rsi,%rdi,2),%rax
imul   $0x5555,%rax,%rax
add    $0x5555,%rax
shr    $0x10,%rax
mov    %rax,0x148(%rsp)
lea    (%rbx,%rcx,2),%rax
imul   $0x5555,%rax,%rax
add    $0x5555,%rax
shr    $0x10,%rax
mov    %rax,0x128(%rsp)
lea    (%r8,%r9,2),%rax
imul   $0x5555,%rax,%rax
add    $0x5555,%rax
shr    $0x10,%rax
mov    %rax,0x108(%rsp)
movaps %xmm0,0x70(%rsp)
cmpb   $0x34,0xc0(%rsp)
34
mov    0x9a0(%rsp),%r8
mov    0x50(%rsp),%rsi
jl     17d3 <kddsrend+0x6c3>
mov    0x28(%rsp),%rax
movzbl -0x8(%rax),%ecx
mov    %rcx,0x60(%rsp)
movzbl -0x7(%rax),%edx
mov    %rdx,0x68(%rsp)
mov    %rdx,%rax
sub    %rcx,%rax
js     1723 <kddsrend+0x613>
lea    (%rdx,%rcx,4),%rdi
lea    (%rdx,%rcx,4),%rcx
add    $0x2,%rcx
imul   $0x3333,%rcx,%rcx
shr    $0x10,%rcx
mov    %rcx,0x70(%rsp)
lea    (%rax,%rdi,1),%rbp
add    $0x2,%rbp
imul   $0x3333,%rbp,%rcx
sar    $0x10,%rcx
mov    %rcx,0x78(%rsp)
add    %rax,%rbp
imul   $0x3333,%rbp,%rcx
sar    $0x10,%rcx
mov    %rcx,0x80(%rsp)
add    %rax,%rbp
imul   $0x3333,%rbp,%rcx
sar    $0x10,%rcx
mov    %rcx,0x88(%rsp)
movq   $0x0,0x90(%rsp)
mov    $0xff,%ecx
jmp    17ab <kddsrend+0x69b>
lea    (%rcx,%rcx,2),%rcx
lea    (%rdx,%rcx,2),%rdi
lea    (%rdx,%rcx,2),%rcx
add    $0x3,%rcx
imul   $0x2492,%rcx,%rcx
shr    $0x10,%rcx
mov    %rcx,0x70(%rsp)
lea    (%rax,%rdi,1),%rbp
add    $0x3,%rbp
imul   $0x2492,%rbp,%rcx
sar    $0x10,%rcx
mov    %rcx,0x78(%rsp)
add    %rax,%rbp
imul   $0x2492,%rbp,%rcx
sar    $0x10,%rcx
mov    %rcx,0x80(%rsp)
add    %rax,%rbp
imul   $0x2492,%rbp,%rcx
sar    $0x10,%rcx
mov    %rcx,0x88(%rsp)
add    %rax,%rbp
imul   $0x2492,%rbp,%rcx
sar    $0x10,%rcx
mov    %rcx,0x90(%rsp)
add    %rax,%rbp
imul   $0x2492,%rbp,%rcx
sar    $0x10,%rcx
mov    %rcx,0x98(%rsp)
add    %rax,%rbp
mov    0x28(%rsp),%rcx
mov    -0x6(%rcx),%rax
mov    %rax,0x150(%rsp)
mov    -0x3(%rcx),%rax
mov    %rax,0x158(%rsp)
mov    0x28(%rsp),%rax
mov    0x4(%rax),%r12
lea    (%rsi,%r8,1),%rax
mov    0xc8(%rsp),%rcx
lea    (%rcx,%rax,4),%r10
xor    %r9d,%r9d
xor    %ecx,%ecx
jmp    181f <kddsrend+0x70f>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x4,%r9
mov    0xe8(%rsp),%rcx
add    $0x1,%rcx
add    0x20(%rsp),%r10
cmp    $0x4,%rcx
je     1480 <kddsrend+0x370>
mov    0xe0(%rsp),%rax
add    %rcx,%rax
cmp    0x18(%rsp),%rax
mov    %rcx,0xe8(%rsp)
jae    1800 <kddsrend+0x6f0>
shr    %rcx
mov    %rcx,0x38(%rsp)
lea    (%r9,%r9,1),%rdx
mov    0x58(%rsp),%r8
xor    %eax,%eax
jmp    1879 <kddsrend+0x769>
xchg   %ax,%ax
mov    %dil,(%r10,%rax,1)
mov    %r13b,0x1(%r10,%rax,1)
mov    %cl,0x2(%r10,%rax,1)
mov    %bpl,0x3(%r10,%rax,1)
add    $0x1,%r9
add    $0x2,%rdx
add    $0x4,%rax
add    $0x1,%r8
cmp    $0x10,%rax
je     1804 <kddsrend+0x6f4>
cmp    %r15,%r8
jae    1863 <kddsrend+0x753>
mov    %r12,%rdi
mov    %edx,%ecx
sar    %cl,%rdi
and    $0x3,%edi
lea    -0x32(%r11),%rcx
cmp    $0x2,%rcx
jb     18c3 <kddsrend+0x7b3>
lea    -0x34(%r11),%rcx
cmp    $0x2,%rcx
jae    18ea <kddsrend+0x7da>
mov    0x38(%rsp),%rcx
mov    0x150(%rsp,%rcx,8),%rsi
mov    %r9d,%ecx
and    $0x7,%cl
movzbl %cl,%ecx
lea    (%rcx,%rcx,2),%ecx
sar    %cl,%rsi
and    $0x7,%esi
mov    0x60(%rsp,%rsi,8),%rbp
jmp    1900 <kddsrend+0x7f0>
mov    %r9,%rcx
sar    %rcx
mov    0x28(%rsp),%rsi
movzbl -0x8(%rcx,%rsi,1),%esi
mov    %eax,%ecx
and    $0x4,%cl
shr    %cl,%rsi
and    $0xf,%esi
mov    %rsi,%rbp
shl    $0x4,%rbp
or     %rsi,%rbp
jmp    1900 <kddsrend+0x7f0>
cmp    $0x31,%r11
jne    1900 <kddsrend+0x7f0>
mov    0x60(%rsp,%rdi,8),%rbp
cs nopw 0x0(%rax,%rax,1)
nop
bt     $0x38,%r14
mov    0x130(%rsp,%rdi,8),%rcx
mov    0x110(%rsp,%rdi,8),%r13
mov    0xf0(%rsp,%rdi,8),%rdi
jb     1850 <kddsrend+0x740>
mov    0x160(%rsp,%rbp,8),%rsi
imul   %rsi,%rdi
mov    %rbp,0x40(%rsp)
mov    %r14,%rbp
mov    %rdi,%rbx
shr    $0x10,%rbx
cmp    $0xff0000,%rdi
mov    $0xff,%r14d
cmovae %r14,%rbx
imul   %rsi,%r13
mov    %r13,%rdi
shr    $0x10,%rdi
cmp    $0xff0000,%r13
cmovae %r14,%rdi
imul   %rsi,%rcx
mov    %rcx,%rsi
shr    $0x10,%rsi
cmp    $0xff0000,%rcx
cmovae %r14,%rsi
mov    %rsi,%rcx
mov    %rdi,%r13
mov    %rbx,%rdi
mov    %rbp,%r14
mov    0x40(%rsp),%rbp
jmp    1850 <kddsrend+0x740>
xor    %eax,%eax
mov    %rax,0x8(%rsp)
jmp    12de <kddsrend+0x1ce>
shl    $0x2,%rsi
and    $0xfffffffffffffffe,%r8
mov    %r8,0x40(%rsp)
lea    0x1(%rbp),%rcx
imul   %r12,%rcx
add    %rcx,%rdx
add    %r10,%rdx
sub    %rax,%rdx
mov    %rdx,%r13
lea    (%r12,%r12,1),%rax
mov    %rax,0x38(%rsp)
xor    %ebp,%ebp
mov    %rsi,0x10(%rsp)
mov    %r12,0x20(%rsp)
jmp    19ef <kddsrend+0x8df>
add    $0x2,%rbp
add    %r12,%rdi
add    %rsi,%rbx
add    0x38(%rsp),%r13
cmp    %rbp,0x40(%rsp)
je     12a8 <kddsrend+0x198>
mov    0x9a8(%rsp),%rcx
lea    (%rcx,%rbp,1),%rax
mov    0x18(%rsp),%r14
cmp    %r14,%rax
jae    1a23 <kddsrend+0x913>
mov    %rdi,%r12
mov    %rbx,%rsi
mov    %r15,%rdx
call   1030 <memcpy@plt>
mov    0x9a8(%rsp),%rcx
mov    %r12,%rdi
mov    0x10(%rsp),%rsi
mov    0x20(%rsp),%r12
add    %r12,%rdi
add    %rsi,%rbx
lea    (%rcx,%rbp,1),%rax
add    $0x1,%rax
cmp    %r14,%rax
jae    19d5 <kddsrend+0x8c5>
mov    %rdi,%r14
mov    %r13,%rdi
mov    %rbx,%rsi
mov    %r15,%rdx
call   1030 <memcpy@plt>
mov    %r14,%rdi
mov    0x10(%rsp),%rsi
jmp    19d5 <kddsrend+0x8c5>

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

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