void pred_comp(unsigned char *src, unsigned char *dst, int lx, int w, int h,
               int x, int y, int dx, int dy, int addflag) {
  int xint;
  int xh;
  int yint;
  int yh;
  int i;
  int j;
  unsigned char *s;
  unsigned char *d___0;
  {
    xint = dx >> 1;
    xh = dx & 1;
    yint = dy >> 1;
    yh = dy & 1;
    s = (src + lx * (y + yint)) + (x + xint);
    d___0 = (dst + lx * y) + x;
    if (!xh) {
      if (!yh) {
        if (addflag) {
          j = 0;
          while (j < h) {
            i = 0;
            while (i < w) {
              *(d___0 + i) = (unsigned char)((unsigned int)(((int)*(d___0 + i) +
                                                             (int)*(s + i)) +
                                                            1) >>
                                             1);
              i++;
            }
            s += lx;
            d___0 += lx;
            j++;
          }
        } else {
          j = 0;
          while (j < h) {
            i = 0;
            while (i < w) {
              *(d___0 + i) = *(s + i);
              i++;
            }
            s += lx;
            d___0 += lx;
            j++;
          }
        }
      } else {
        goto _L___1;
      }
    } else
    _L___1:
      if (!xh) {
        if (yh) {
          if (addflag) {
            j = 0;
            while (j < h) {
              i = 0;
              while (i < w) {
                *(d___0 + i) =
                    (unsigned char)((((unsigned int)*(d___0 + i) +
                                      ((unsigned int)(((int)*(s + i) +
                                                       (int)*(s + (i + lx))) +
                                                      1) >>
                                       1)) +
                                     1U) >>
                                    1);
                i++;
              }
              s += lx;
              d___0 += lx;
              j++;
            }
          } else {
            j = 0;
            while (j < h) {
              i = 0;
              while (i < w) {
                *(d___0 + i) =
                    (unsigned char)((unsigned int)(((int)*(s + i) +
                                                    (int)*(s + (i + lx))) +
                                                   1) >>
                                    1);
                i++;
              }
              s += lx;
              d___0 += lx;
              j++;
            }
          }
        } else {
          goto _L___0;
        }
      } else
      _L___0:
        if (xh) {
          if (!yh) {
            if (addflag) {
              j = 0;
              while (j < h) {
                i = 0;
                while (i < w) {
                  *(d___0 + i) =
                      (unsigned char)((((unsigned int)*(d___0 + i) +
                                        ((unsigned int)(((int)*(s + i) +
                                                         (int)*(s + (i + 1))) +
                                                        1) >>
                                         1)) +
                                       1U) >>
                                      1);
                  i++;
                }
                s += lx;
                d___0 += lx;
                j++;
              }
            } else {
              j = 0;
              while (j < h) {
                i = 0;
                while (i < w) {
                  *(d___0 + i) =
                      (unsigned char)((unsigned int)(((int)*(s + i) +
                                                      (int)*(s + (i + 1))) +
                                                     1) >>
                                      1);
                  i++;
                }
                s += lx;
                d___0 += lx;
                j++;
              }
            }
          } else {
            goto _L;
          }
        } else
        _L:
          if (addflag) {
            j = 0;
            while (j < h) {
              i = 0;
              while (i < w) {
                *(d___0 + i) =
                    (unsigned char)((((unsigned int)*(d___0 + i) +
                                      ((unsigned int)(((((int)*(s + i) +
                                                         (int)*(s + (i + 1))) +
                                                        (int)*(s + (i + lx))) +
                                                       (int)*(s +
                                                              ((i + lx) + 1))) +
                                                      2) >>
                                       2)) +
                                     1U) >>
                                    1);
                i++;
              }
              s += lx;
              d___0 += lx;
              j++;
            }
          } else {
            j = 0;
            while (j < h) {
              i = 0;
              while (i < w) {
                *(d___0 + i) =
                    (unsigned char)((unsigned int)(((((int)*(s + i) +
                                                      (int)*(s + (i + 1))) +
                                                     (int)*(s + (i + lx))) +
                                                    (int)*(s +
                                                           ((i + lx) + 1))) +
                                                   2) >>
                                    2);
                i++;
              }
              s += lx;
              d___0 += lx;
              j++;
            }
          }
    return;
  }
}


x86 assembly (clang, -O0):
<pred_comp>:
push   %rbp
mov    %rsp,%rbp
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
mov    %r9d,-0x20(%rbp)
mov    0x18(%rbp),%eax
sar    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    0x18(%rbp),%eax
and    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    0x20(%rbp),%eax
sar    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    0x20(%rbp),%eax
and    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    0x10(%rbp),%edx
add    -0x2c(%rbp),%edx
imul   %edx,%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    -0x20(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   0x10(%rbp),%ecx
movslq %ecx,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
cmpl   $0x0,-0x28(%rbp)
jne    12ce <pred_comp+0x1ce>
cmpl   $0x0,-0x30(%rbp)
jne    12c4 <pred_comp+0x1c4>
cmpl   $0x0,0x28(%rbp)
je     1240 <pred_comp+0x140>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    123b <pred_comp+0x13b>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    120b <pred_comp+0x10b>
mov    -0x48(%rbp),%rax
movslq -0x34(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x40(%rbp),%rcx
movslq -0x34(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
add    $0x1,%eax
shr    $0x1,%eax
mov    %al,%dl
mov    -0x48(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11c4 <pred_comp+0xc4>
mov    -0x14(%rbp),%ecx
mov    -0x40(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x48(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    11b1 <pred_comp+0xb1>
jmp    12bf <pred_comp+0x1bf>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    12ba <pred_comp+0x1ba>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    128a <pred_comp+0x18a>
mov    -0x40(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x48(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    125a <pred_comp+0x15a>
mov    -0x14(%rbp),%ecx
mov    -0x40(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x48(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1247 <pred_comp+0x147>
jmp    12bf <pred_comp+0x1bf>
jmp    12c9 <pred_comp+0x1c9>
jmp    12d3 <pred_comp+0x1d3>
jmp    1780 <pred_comp+0x680>
jmp    12d3 <pred_comp+0x1d3>
cmpl   $0x0,-0x28(%rbp)
jne    144a <pred_comp+0x34a>
cmpl   $0x0,-0x30(%rbp)
je     1440 <pred_comp+0x340>
cmpl   $0x0,0x28(%rbp)
je     13a0 <pred_comp+0x2a0>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    139b <pred_comp+0x29b>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    136b <pred_comp+0x26b>
mov    -0x48(%rbp),%rax
movslq -0x34(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x40(%rbp),%rcx
movslq -0x34(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
mov    -0x40(%rbp),%rdx
mov    -0x34(%rbp),%esi
add    -0x14(%rbp),%esi
movslq %esi,%rsi
movzbl (%rdx,%rsi,1),%edx
add    %edx,%ecx
add    $0x1,%ecx
shr    $0x1,%ecx
add    %ecx,%eax
add    $0x1,%eax
shr    $0x1,%eax
mov    %al,%dl
mov    -0x48(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    130b <pred_comp+0x20b>
mov    -0x14(%rbp),%ecx
mov    -0x40(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x48(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    12f8 <pred_comp+0x1f8>
jmp    143b <pred_comp+0x33b>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1436 <pred_comp+0x336>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1406 <pred_comp+0x306>
mov    -0x40(%rbp),%rax
movslq -0x34(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x40(%rbp),%rcx
mov    -0x34(%rbp),%edx
add    -0x14(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
add    $0x1,%eax
shr    $0x1,%eax
mov    %al,%dl
mov    -0x48(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    13ba <pred_comp+0x2ba>
mov    -0x14(%rbp),%ecx
mov    -0x40(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x48(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    13a7 <pred_comp+0x2a7>
jmp    143b <pred_comp+0x33b>
jmp    1445 <pred_comp+0x345>
jmp    144f <pred_comp+0x34f>
jmp    177b <pred_comp+0x67b>
jmp    144f <pred_comp+0x34f>
cmpl   $0x0,-0x28(%rbp)
je     15c6 <pred_comp+0x4c6>
cmpl   $0x0,-0x30(%rbp)
jne    15bc <pred_comp+0x4bc>
cmpl   $0x0,0x28(%rbp)
je     151c <pred_comp+0x41c>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1517 <pred_comp+0x417>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    14e7 <pred_comp+0x3e7>
mov    -0x48(%rbp),%rax
movslq -0x34(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x40(%rbp),%rcx
movslq -0x34(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
mov    -0x40(%rbp),%rdx
mov    -0x34(%rbp),%esi
add    $0x1,%esi
movslq %esi,%rsi
movzbl (%rdx,%rsi,1),%edx
add    %edx,%ecx
add    $0x1,%ecx
shr    $0x1,%ecx
add    %ecx,%eax
add    $0x1,%eax
shr    $0x1,%eax
mov    %al,%dl
mov    -0x48(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1487 <pred_comp+0x387>
mov    -0x14(%rbp),%ecx
mov    -0x40(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x48(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1474 <pred_comp+0x374>
jmp    15b7 <pred_comp+0x4b7>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    15b2 <pred_comp+0x4b2>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1582 <pred_comp+0x482>
mov    -0x40(%rbp),%rax
movslq -0x34(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x40(%rbp),%rcx
mov    -0x34(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
add    $0x1,%eax
shr    $0x1,%eax
mov    %al,%dl
mov    -0x48(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1536 <pred_comp+0x436>
mov    -0x14(%rbp),%ecx
mov    -0x40(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x48(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1523 <pred_comp+0x423>
jmp    15b7 <pred_comp+0x4b7>
jmp    15c1 <pred_comp+0x4c1>
jmp    15cb <pred_comp+0x4cb>
jmp    1776 <pred_comp+0x676>
jmp    15cb <pred_comp+0x4cb>
cmpl   $0x0,0x28(%rbp)
je     16ad <pred_comp+0x5ad>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    16a8 <pred_comp+0x5a8>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1678 <pred_comp+0x578>
mov    -0x48(%rbp),%rax
movslq -0x34(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x40(%rbp),%rcx
movslq -0x34(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
mov    -0x40(%rbp),%rdx
mov    -0x34(%rbp),%esi
add    $0x1,%esi
movslq %esi,%rsi
movzbl (%rdx,%rsi,1),%edx
add    %edx,%ecx
mov    -0x40(%rbp),%rdx
mov    -0x34(%rbp),%esi
add    -0x14(%rbp),%esi
movslq %esi,%rsi
movzbl (%rdx,%rsi,1),%edx
add    %edx,%ecx
mov    -0x40(%rbp),%rdx
mov    -0x34(%rbp),%esi
add    -0x14(%rbp),%esi
add    $0x1,%esi
movslq %esi,%rsi
movzbl (%rdx,%rsi,1),%edx
add    %edx,%ecx
add    $0x2,%ecx
shr    $0x2,%ecx
add    %ecx,%eax
add    $0x1,%eax
shr    $0x1,%eax
mov    %al,%dl
mov    -0x48(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    15ef <pred_comp+0x4ef>
mov    -0x14(%rbp),%ecx
mov    -0x40(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x48(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    15dc <pred_comp+0x4dc>
jmp    1771 <pred_comp+0x671>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    176c <pred_comp+0x66c>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    173c <pred_comp+0x63c>
mov    -0x40(%rbp),%rax
movslq -0x34(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x40(%rbp),%rcx
mov    -0x34(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
mov    -0x40(%rbp),%rcx
mov    -0x34(%rbp),%edx
add    -0x14(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
mov    -0x40(%rbp),%rcx
mov    -0x34(%rbp),%edx
add    -0x14(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
add    $0x2,%eax
shr    $0x2,%eax
mov    %al,%dl
mov    -0x48(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    16c7 <pred_comp+0x5c7>
mov    -0x14(%rbp),%ecx
mov    -0x40(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x48(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    16b4 <pred_comp+0x5b4>
jmp    1771 <pred_comp+0x671>
jmp    1776 <pred_comp+0x676>
jmp    177b <pred_comp+0x67b>
jmp    1780 <pred_comp+0x680>
pop    %rbp
ret

x86 assembly (clang, -O2):
<pred_comp>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %r8d,-0x44(%rsp)
mov    %ecx,-0x48(%rsp)
mov    0x50(%rsp),%r11d
mov    0x48(%rsp),%r15d
mov    0x40(%rsp),%r14d
mov    0x38(%rsp),%eax
mov    %r14d,%ebx
sar    %ebx
mov    %r15d,%ebp
sar    %ebp
add    %eax,%ebp
imul   %edx,%ebp
movslq %ebp,%rcx
mov    %rdi,-0x38(%rsp)
mov    %rcx,-0x40(%rsp)
lea    (%rdi,%rcx,1),%r10
add    %r9d,%ebx
movslq %ebx,%r8
add    %r8,%r10
imul   %edx,%eax
movslq %eax,%rdi
mov    %rsi,-0x20(%rsp)
lea    (%rsi,%rdi,1),%rax
movslq %r9d,%rsi
mov    %rsi,%rcx
add    %rsi,%rax
mov    %r15d,%ebp
or     %r14d,%ebp
test   $0x1,%bpl
jne    130e <pred_comp+0x20e>
test   %r11d,%r11d
je     1890 <pred_comp+0x790>
cmpl   $0x0,-0x44(%rsp)
jle    2581 <pred_comp+0x1481>
movslq %edx,%r15
mov    -0x48(%rsp),%esi
add    %rdi,%rcx
add    %rsi,%rcx
mov    -0x40(%rsp),%rdx
add    %r8,%rdx
add    %rsi,%rdx
mov    %rdx,%r8
mov    %esi,%r9d
and    $0xffffffe0,%r9d
mov    %esi,%r11d
and    $0xfffffff8,%r11d
mov    %rsi,%r14
neg    %r14
xor    %edx,%edx
jmp    11d4 <pred_comp+0xd4>
xchg   %ax,%ax
add    %r15,%r10
add    %r15,%rax
add    $0x1,%rdx
cmp    -0x44(%rsp),%edx
je     2581 <pred_comp+0x1481>
cmpl   $0x0,-0x48(%rsp)
jle    11c0 <pred_comp+0xc0>
cmpl   $0x8,-0x48(%rsp)
jb     1208 <pred_comp+0x108>
mov    %rdx,%rdi
imul   %r15,%rdi
lea    (%r8,%rdi,1),%rbp
add    -0x38(%rsp),%rbp
cmp    %rbp,%rax
jae    1277 <pred_comp+0x177>
add    %rcx,%rdi
add    -0x20(%rsp),%rdi
cmp    %rdi,%r10
jae    1277 <pred_comp+0x177>
xor    %ebp,%ebp
mov    %rbp,%rdi
test   $0x1,%sil
je     122e <pred_comp+0x12e>
movzbl (%rax,%rbp,1),%edi
movzbl (%r10,%rbp,1),%ebx
add    %ebx,%edi
add    $0x1,%edi
shr    %edi
mov    %dil,(%rax,%rbp,1)
mov    %rbp,%rdi
or     $0x1,%rdi
not    %rbp
cmp    %r14,%rbp
je     11c0 <pred_comp+0xc0>
cs nopw 0x0(%rax,%rax,1)
movzbl (%rax,%rdi,1),%ebx
movzbl (%r10,%rdi,1),%ebp
add    %ebp,%ebx
add    $0x1,%ebx
shr    %ebx
mov    %bl,(%rax,%rdi,1)
movzbl 0x1(%rax,%rdi,1),%ebx
movzbl 0x1(%r10,%rdi,1),%ebp
add    %ebp,%ebx
add    $0x1,%ebx
shr    %ebx
mov    %bl,0x1(%rax,%rdi,1)
add    $0x2,%rdi
cmp    %rdi,%rsi
jne    1240 <pred_comp+0x140>
jmp    11c0 <pred_comp+0xc0>
cmpl   $0x20,-0x48(%rsp)
jae    1282 <pred_comp+0x182>
xor    %edi,%edi
jmp    12e0 <pred_comp+0x1e0>
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movdqu (%rax,%rdi,1),%xmm0
movdqu 0x10(%rax,%rdi,1),%xmm1
movdqu (%r10,%rdi,1),%xmm2
pavgb  %xmm0,%xmm2
movdqu 0x10(%r10,%rdi,1),%xmm0
pavgb  %xmm1,%xmm0
movdqu %xmm2,(%rax,%rdi,1)
movdqu %xmm0,0x10(%rax,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%r9
jne    1290 <pred_comp+0x190>
cmp    %rsi,%r9
je     11c0 <pred_comp+0xc0>
mov    %r9,%rdi
mov    %r9,%rbp
test   $0x18,%sil
je     120a <pred_comp+0x10a>
nopl   (%rax)
movq   (%rax,%rdi,1),%xmm0
movq   (%r10,%rdi,1),%xmm1
pavgb  %xmm0,%xmm1
movq   %xmm1,(%rax,%rdi,1)
add    $0x8,%rdi
cmp    %rdi,%r11
jne    12e0 <pred_comp+0x1e0>
mov    %r11,%rbp
cmp    %rsi,%r11
je     11c0 <pred_comp+0xc0>
jmp    120a <pred_comp+0x10a>
and    $0x1,%r15d
test   $0x1,%r14b
jne    15fc <pred_comp+0x4fc>
test   %r15d,%r15d
je     15fc <pred_comp+0x4fc>
test   %r11d,%r11d
je     1f60 <pred_comp+0xe60>
cmpl   $0x0,-0x44(%rsp)
jle    2581 <pred_comp+0x1481>
movslq %edx,%r11
mov    -0x48(%rsp),%r12d
add    %rdi,%rcx
add    %r12,%rcx
mov    %rcx,-0x28(%rsp)
mov    -0x40(%rsp),%rcx
lea    (%r11,%rcx,1),%r15
add    %r8,%r15
lea    (%r15,%r12,1),%rdx
mov    %rdx,-0x18(%rsp)
add    %r8,%rcx
add    %r12,%rcx
mov    %rcx,-0x40(%rsp)
mov    %r12d,%ecx
and    $0xfffffff0,%ecx
mov    %r12d,%r13d
and    $0xfffffff8,%r13d
mov    %r12,%rdx
neg    %rdx
mov    %rdx,-0x30(%rsp)
mov    -0x38(%rsp),%rdx
lea    (%rdx,%r15,1),%r14
xor    %r8d,%r8d
pxor   %xmm0,%xmm0
pcmpeqd %xmm1,%xmm1
movdqa 0x1c5f(%rip),%xmm8
mov    -0x38(%rsp),%rbx
jmp    13c8 <pred_comp+0x2c8>
nopl   0x0(%rax,%rax,1)
add    %r11,%r10
add    %r11,%rax
add    $0x1,%r8
add    %r11,%r14
cmp    -0x44(%rsp),%r8d
je     2581 <pred_comp+0x1481>
cmpl   $0x0,-0x48(%rsp)
jle    13b0 <pred_comp+0x2b0>
cmpl   $0x8,-0x48(%rsp)
jae    1470 <pred_comp+0x370>
xor    %edi,%edi
mov    %rdi,%rbp
test   $0x1,%r12b
je     140f <pred_comp+0x30f>
movzbl (%rax,%rdi,1),%edx
movzbl (%r10,%rdi,1),%esi
lea    (%rdi,%r11,1),%rbp
movzbl (%r10,%rbp,1),%ebp
add    %ebp,%esi
add    $0x1,%esi
shr    %esi
add    %esi,%edx
add    $0x1,%edx
shr    %edx
mov    %dl,(%rax,%rdi,1)
mov    %rdi,%rbp
or     $0x1,%rbp
not    %rdi
cmp    -0x30(%rsp),%rdi
je     13b0 <pred_comp+0x2b0>
nopl   0x0(%rax)
movzbl (%rax,%rbp,1),%edx
movzbl (%r10,%rbp,1),%esi
movzbl (%r14,%rbp,1),%edi
add    %edi,%esi
add    $0x1,%esi
shr    %esi
add    %esi,%edx
add    $0x1,%edx
shr    %edx
mov    %dl,(%rax,%rbp,1)
movzbl 0x1(%rax,%rbp,1),%edx
movzbl 0x1(%r10,%rbp,1),%esi
movzbl 0x1(%r14,%rbp,1),%edi
add    %edi,%esi
add    $0x1,%esi
shr    %esi
add    %esi,%edx
add    $0x1,%edx
shr    %edx
mov    %dl,0x1(%rax,%rbp,1)
add    $0x2,%rbp
cmp    %rbp,%r12
jne    1420 <pred_comp+0x320>
jmp    13b0 <pred_comp+0x2b0>
mov    %r8,%rdx
imul   %r11,%rdx
mov    -0x28(%rsp),%rsi
lea    (%rsi,%rdx,1),%rdi
add    -0x20(%rsp),%rdi
lea    (%r15,%rdx,1),%rbp
add    %rbx,%rbp
mov    -0x18(%rsp),%rsi
add    %rdx,%rsi
add    %rbx,%rsi
add    -0x40(%rsp),%rdx
add    %rbx,%rdx
cmp    %rsi,%rax
setb   %sil
cmp    %rdi,%rbp
setb   %bpl
cmp    %rdx,%rax
setb   %dl
cmp    %rdi,%r10
setb   %r9b
test   %bpl,%sil
jne    13da <pred_comp+0x2da>
mov    $0x0,%edi
and    %r9b,%dl
jne    13dc <pred_comp+0x2dc>
cmpl   $0x10,-0x48(%rsp)
jae    153f <pred_comp+0x43f>
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movq   (%rax,%rbp,1),%xmm2
punpcklbw %xmm0,%xmm2
movq   (%r10,%rbp,1),%xmm3
punpcklbw %xmm0,%xmm3
movq   (%r14,%rbp,1),%xmm4
punpcklbw %xmm0,%xmm4
paddw  %xmm3,%xmm4
psubw  %xmm1,%xmm4
psrlw  $0x1,%xmm4
paddw  %xmm2,%xmm4
psubw  %xmm1,%xmm4
psrlw  $0x1,%xmm4
pand   %xmm8,%xmm4
packuswb %xmm4,%xmm4
movq   %xmm4,(%rax,%rbp,1)
add    $0x8,%rbp
cmp    %rbp,%r13
jne    14e0 <pred_comp+0x3e0>
mov    %r13,%rdi
cmp    %r12,%r13
je     13b0 <pred_comp+0x2b0>
jmp    13dc <pred_comp+0x2dc>
mov    %r15,%rdx
lea    (%r10,%r11,1),%r9
xor    %r15d,%r15d
nopl   0x0(%rax)
movdqu (%rax,%r15,1),%xmm5
movdqa %xmm5,%xmm6
punpckhbw %xmm0,%xmm6
punpcklbw %xmm0,%xmm5
movdqu (%r10,%r15,1),%xmm7
movdqa %xmm7,%xmm2
punpcklbw %xmm0,%xmm2
punpckhbw %xmm0,%xmm7
movdqu (%r9,%r15,1),%xmm3
movdqa %xmm3,%xmm4
punpcklbw %xmm0,%xmm4
paddw  %xmm2,%xmm4
punpckhbw %xmm0,%xmm3
paddw  %xmm7,%xmm3
psubw  %xmm1,%xmm4
psubw  %xmm1,%xmm3
psrlw  $0x1,%xmm3
paddw  %xmm6,%xmm3
psrlw  $0x1,%xmm4
paddw  %xmm5,%xmm4
psubw  %xmm1,%xmm3
psubw  %xmm1,%xmm4
psrlw  $0x1,%xmm4
psrlw  $0x1,%xmm3
pand   %xmm8,%xmm3
pand   %xmm8,%xmm4
packuswb %xmm3,%xmm4
movdqu %xmm4,(%rax,%r15,1)
add    $0x10,%r15
cmp    %r15,%rcx
jne    1550 <pred_comp+0x450>
cmp    %r12,%rcx
mov    %rdx,%r15
je     13b0 <pred_comp+0x2b0>
mov    %rcx,%rbp
mov    %rcx,%rdi
test   $0x8,%r12b
jne    14e0 <pred_comp+0x3e0>
jmp    13dc <pred_comp+0x2dc>
test   $0x1,%r14b
je     1b02 <pred_comp+0xa02>
test   %r15d,%r15d
jne    1b02 <pred_comp+0xa02>
test   %r11d,%r11d
je     216f <pred_comp+0x106f>
cmpl   $0x0,-0x44(%rsp)
jle    2581 <pred_comp+0x1481>
movslq %edx,%r15
mov    -0x48(%rsp),%esi
add    %rdi,%rcx
add    %rsi,%rcx
mov    -0x40(%rsp),%rdx
add    %r8,%rdx
add    %rsi,%rdx
add    $0x1,%rdx
mov    %rdx,-0x40(%rsp)
mov    %esi,%r12d
and    $0xfffffff0,%r12d
mov    %esi,%r9d
and    $0xfffffff8,%r9d
mov    %rsi,%r14
neg    %r14
xor    %r11d,%r11d
pxor   %xmm0,%xmm0
pcmpeqd %xmm1,%xmm1
movdqa 0x1994(%rip),%xmm8
jmp    1685 <pred_comp+0x585>
xchg   %ax,%ax
add    %r15,%r10
add    %r15,%rax
add    $0x1,%r11
cmp    -0x44(%rsp),%r11d
je     2581 <pred_comp+0x1481>
cmpl   $0x0,-0x48(%rsp)
jle    1670 <pred_comp+0x570>
cmpl   $0x8,-0x48(%rsp)
jb     16c2 <pred_comp+0x5c2>
mov    %r11,%rdi
imul   %r15,%rdi
mov    -0x40(%rsp),%rdx
lea    (%rdx,%rdi,1),%rbp
add    -0x38(%rsp),%rbp
cmp    %rbp,%rax
jae    1764 <pred_comp+0x664>
add    %rcx,%rdi
add    -0x20(%rsp),%rdi
cmp    %rdi,%r10
jae    1764 <pred_comp+0x664>
xor    %ebp,%ebp
mov    %rbp,%rbx
test   $0x1,%sil
je     16f7 <pred_comp+0x5f7>
movzbl (%rax,%rbp,1),%r8d
movzbl (%r10,%rbp,1),%r13d
mov    %rbp,%rbx
or     $0x1,%rbx
movzbl (%r10,%rbx,1),%edi
add    %r13d,%edi
add    $0x1,%edi
shr    %edi
add    %r8d,%edi
add    $0x1,%edi
shr    %edi
mov    %dil,(%rax,%rbp,1)
not    %rbp
cmp    %r14,%rbp
je     1670 <pred_comp+0x570>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzbl (%rax,%rbx,1),%edi
movzbl (%r10,%rbx,1),%ebp
movzbl 0x1(%r10,%rbx,1),%edx
add    %ebp,%edx
add    $0x1,%edx
shr    %edx
add    %edi,%edx
add    $0x1,%edx
shr    %edx
mov    %dl,(%rax,%rbx,1)
movzbl 0x1(%rax,%rbx,1),%edx
movzbl 0x1(%r10,%rbx,1),%edi
movzbl 0x2(%r10,%rbx,1),%ebp
add    %ebp,%edi
add    $0x1,%edi
shr    %edi
add    %edi,%edx
add    $0x1,%edx
shr    %edx
mov    %dl,0x1(%rax,%rbx,1)
lea    0x2(%rbx),%rdx
mov    %rdx,%rbx
cmp    %rdx,%rsi
jne    1710 <pred_comp+0x610>
jmp    1670 <pred_comp+0x570>
cmpl   $0x10,-0x48(%rsp)
jae    1772 <pred_comp+0x672>
xor    %edi,%edi
jmp    1830 <pred_comp+0x730>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movdqu (%rax,%rbx,1),%xmm5
movdqa %xmm5,%xmm6
punpckhbw %xmm0,%xmm6
punpcklbw %xmm0,%xmm5
movdqu (%r10,%rbx,1),%xmm7
movdqu 0x1(%r10,%rbx,1),%xmm3
movdqa %xmm7,%xmm2
punpcklbw %xmm0,%xmm2
punpckhbw %xmm0,%xmm7
movdqa %xmm3,%xmm4
punpcklbw %xmm0,%xmm4
paddw  %xmm2,%xmm4
punpckhbw %xmm0,%xmm3
paddw  %xmm7,%xmm3
psubw  %xmm1,%xmm4
psubw  %xmm1,%xmm3
psrlw  $0x1,%xmm3
paddw  %xmm6,%xmm3
psrlw  $0x1,%xmm4
paddw  %xmm5,%xmm4
psubw  %xmm1,%xmm3
psubw  %xmm1,%xmm4
psrlw  $0x1,%xmm4
psrlw  $0x1,%xmm3
pand   %xmm8,%xmm3
pand   %xmm8,%xmm4
packuswb %xmm3,%xmm4
movdqu %xmm4,(%rax,%rbx,1)
add    $0x10,%rbx
cmp    %rbx,%r12
jne    1780 <pred_comp+0x680>
cmp    %rsi,%r12
je     1670 <pred_comp+0x570>
mov    %r12,%rdi
mov    %r12,%rbp
test   $0x8,%sil
je     16c4 <pred_comp+0x5c4>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movq   (%rax,%rdi,1),%xmm2
punpcklbw %xmm0,%xmm2
movq   (%r10,%rdi,1),%xmm3
punpcklbw %xmm0,%xmm3
movq   0x1(%r10,%rdi,1),%xmm4
punpcklbw %xmm0,%xmm4
paddw  %xmm3,%xmm4
psubw  %xmm1,%xmm4
psrlw  $0x1,%xmm4
paddw  %xmm2,%xmm4
psubw  %xmm1,%xmm4
psrlw  $0x1,%xmm4
pand   %xmm8,%xmm4
packuswb %xmm4,%xmm4
movq   %xmm4,(%rax,%rdi,1)
add    $0x8,%rdi
cmp    %rdi,%r9
jne    1830 <pred_comp+0x730>
mov    %r9,%rbp
cmp    %rsi,%r9
je     1670 <pred_comp+0x570>
jmp    16c4 <pred_comp+0x5c4>
cmpl   $0x0,-0x44(%rsp)
jle    2581 <pred_comp+0x1481>
movslq %edx,%r14
mov    -0x48(%rsp),%esi
add    %rdi,%rcx
lea    (%rcx,%rsi,1),%rdx
mov    %rdx,-0x28(%rsp)
mov    -0x40(%rsp),%rdi
add    %r8,%rdi
lea    (%rdi,%rsi,1),%rdx
mov    %rdx,-0x40(%rsp)
mov    %esi,%edx
and    $0xffffffe0,%edx
mov    %rdx,-0x30(%rsp)
add    $0xffffffffffffffe0,%rdx
mov    %rdx,-0x18(%rsp)
shr    $0x5,%rdx
add    $0x1,%rdx
mov    %edx,%r9d
and    $0x3,%r9d
and    $0xfffffffffffffffc,%rdx
mov    %rdx,-0x10(%rsp)
mov    %esi,%r15d
and    $0xfffffff8,%r15d
mov    %esi,%r13d
and    $0x3,%r13d
mov    -0x20(%rsp),%rdx
lea    (%rdx,%rcx,1),%r12
add    $0x10,%r12
mov    -0x38(%rsp),%rdx
lea    (%rdx,%rdi,1),%r11
add    $0x10,%r11
mov    %r9,-0x8(%rsp)
shl    $0x5,%r9
xor    %r8d,%r8d
mov    %r13,%rcx
jmp    194b <pred_comp+0x84b>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    %r14,%r10
add    %r14,%rax
add    $0x1,%r8
add    %r14,%r12
add    %r14,%r11
cmp    -0x44(%rsp),%r8d
je     2581 <pred_comp+0x1481>
cmpl   $0x0,-0x48(%rsp)
jle    1930 <pred_comp+0x830>
cmpl   $0x8,-0x48(%rsp)
jb     1986 <pred_comp+0x886>
mov    %r8,%rdi
imul   %r14,%rdi
mov    -0x40(%rsp),%rdx
lea    (%rdx,%rdi,1),%rbx
add    -0x38(%rsp),%rbx
cmp    %rbx,%rax
jae    19f4 <pred_comp+0x8f4>
add    -0x28(%rsp),%rdi
add    -0x20(%rsp),%rdi
cmp    %rdi,%r10
jae    19f4 <pred_comp+0x8f4>
xor    %ebx,%ebx
mov    %rbx,%rdi
not    %rdi
add    %rsi,%rdi
test   %r13,%r13
je     19b3 <pred_comp+0x8b3>
mov    %r13,%rbp
nopl   0x0(%rax)
movzbl (%r10,%rbx,1),%r13d
mov    %r13b,(%rax,%rbx,1)
add    $0x1,%rbx
add    $0xffffffffffffffff,%rbp
jne    19a0 <pred_comp+0x8a0>
cmp    $0x3,%rdi
mov    %rcx,%r13
jb     1930 <pred_comp+0x830>
movzbl (%r10,%rbx,1),%edx
mov    %dl,(%rax,%rbx,1)
movzbl 0x1(%r10,%rbx,1),%edx
mov    %dl,0x1(%rax,%rbx,1)
movzbl 0x2(%r10,%rbx,1),%edx
mov    %dl,0x2(%rax,%rbx,1)
movzbl 0x3(%r10,%rbx,1),%edx
mov    %dl,0x3(%rax,%rbx,1)
add    $0x4,%rbx
cmp    %rbx,%rsi
jne    19c0 <pred_comp+0x8c0>
jmp    1930 <pred_comp+0x830>
cmpl   $0x20,-0x48(%rsp)
jae    1a02 <pred_comp+0x902>
xor    %edi,%edi
jmp    1ae0 <pred_comp+0x9e0>
cmpq   $0x60,-0x18(%rsp)
jae    1a0e <pred_comp+0x90e>
xor    %ebx,%ebx
jmp    1a84 <pred_comp+0x984>
mov    -0x10(%rsp),%rdi
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
movups (%r10,%rbx,1),%xmm0
movups 0x10(%r10,%rbx,1),%xmm1
movups %xmm0,(%rax,%rbx,1)
movups %xmm1,0x10(%rax,%rbx,1)
movups 0x20(%r10,%rbx,1),%xmm0
movups 0x30(%r10,%rbx,1),%xmm1
movups %xmm0,0x20(%rax,%rbx,1)
movups %xmm1,0x30(%rax,%rbx,1)
movups 0x40(%r10,%rbx,1),%xmm0
movups 0x50(%r10,%rbx,1),%xmm1
movups %xmm0,0x40(%rax,%rbx,1)
movups %xmm1,0x50(%rax,%rbx,1)
movdqu 0x60(%r10,%rbx,1),%xmm0
movdqu 0x70(%r10,%rbx,1),%xmm1
movdqu %xmm0,0x60(%rax,%rbx,1)
movdqu %xmm1,0x70(%rax,%rbx,1)
sub    $0xffffffffffffff80,%rbx
add    $0xfffffffffffffffc,%rdi
jne    1a20 <pred_comp+0x920>
cmpq   $0x0,-0x8(%rsp)
je     1abf <pred_comp+0x9bf>
lea    (%r12,%rbx,1),%rdi
add    %r11,%rbx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
movdqu -0x10(%rbx,%rbp,1),%xmm0
movdqu (%rbx,%rbp,1),%xmm1
movdqu %xmm0,-0x10(%rdi,%rbp,1)
movdqu %xmm1,(%rdi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%r9
jne    1aa0 <pred_comp+0x9a0>
cmp    %rsi,-0x30(%rsp)
je     1930 <pred_comp+0x830>
mov    -0x30(%rsp),%rbx
mov    %rbx,%rdi
test   $0x18,%sil
je     1988 <pred_comp+0x888>
nopl   0x0(%rax)
mov    (%r10,%rdi,1),%rbx
mov    %rbx,(%rax,%rdi,1)
add    $0x8,%rdi
cmp    %rdi,%r15
jne    1ae0 <pred_comp+0x9e0>
mov    %r15,%rbx
cmp    %rsi,%r15
je     1930 <pred_comp+0x830>
jmp    1988 <pred_comp+0x888>
test   %r11d,%r11d
je     2300 <pred_comp+0x1200>
cmpl   $0x0,-0x44(%rsp)
jle    2581 <pred_comp+0x1481>
movslq %edx,%r13
mov    -0x48(%rsp),%r12d
add    %rdi,%rcx
add    %r12,%rcx
mov    %rcx,-0x28(%rsp)
mov    -0x40(%rsp),%rcx
lea    (%rcx,%r13,1),%r14
add    %r8,%r14
lea    (%r12,%r14,1),%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rsp)
add    %r8,%rcx
add    %r12,%rcx
add    $0x1,%rcx
mov    %rcx,-0x40(%rsp)
mov    %r12d,%r11d
and    $0xfffffff0,%r11d
mov    %r12d,%r9d
and    $0xfffffff8,%r9d
mov    -0x38(%rsp),%rdx
lea    (%rdx,%r14,1),%rbp
add    $0x1,%rbp
xor    %r15d,%r15d
pxor   %xmm11,%xmm11
movdqa 0x1493(%rip),%xmm8
pcmpeqd %xmm9,%xmm9
movdqa 0x1495(%rip),%xmm10
jmp    1ba8 <pred_comp+0xaa8>
nopl   (%rax)
add    %r13,%r10
add    %r13,%rax
add    $0x1,%r15
add    %r13,%rbp
cmp    -0x44(%rsp),%r15d
je     2581 <pred_comp+0x1481>
cmpl   $0x0,-0x48(%rsp)
jle    1b90 <pred_comp+0xa90>
cmpl   $0x8,-0x48(%rsp)
jae    1bc0 <pred_comp+0xac0>
xor    %edi,%edi
jmp    1f20 <pred_comp+0xe20>
nopl   (%rax)
mov    %r15,%rdx
imul   %r13,%rdx
mov    -0x28(%rsp),%rcx
lea    (%rcx,%rdx,1),%rsi
add    -0x20(%rsp),%rsi
lea    (%r14,%rdx,1),%r8
mov    -0x38(%rsp),%rcx
add    %rcx,%r8
mov    -0x30(%rsp),%rdi
add    %rdx,%rdi
add    %rcx,%rdi
add    -0x40(%rsp),%rdx
add    %rcx,%rdx
cmp    %rdi,%rax
setb   %dil
cmp    %rsi,%r8
setb   %r8b
cmp    %rdx,%rax
setb   %dl
cmp    %rsi,%r10
setb   %sil
test   %r8b,%dil
jne    1c30 <pred_comp+0xb30>
mov    $0x0,%edi
and    %sil,%dl
jne    1f20 <pred_comp+0xe20>
cmpl   $0x10,-0x48(%rsp)
jae    1c37 <pred_comp+0xb37>
xor    %esi,%esi
jmp    1e20 <pred_comp+0xd20>
xor    %edi,%edi
jmp    1f20 <pred_comp+0xe20>
xor    %esi,%esi
nopl   0x0(%rax)
movdqu (%r10,%rsi,1),%xmm1
movdqu 0x1(%r10,%rsi,1),%xmm7
movdqa %xmm1,%xmm2
punpcklbw %xmm11,%xmm2
movdqa %xmm2,%xmm5
punpcklwd %xmm11,%xmm5
punpckhwd %xmm11,%xmm2
punpckhbw %xmm11,%xmm1
movdqa %xmm1,%xmm6
punpcklwd %xmm11,%xmm6
punpckhwd %xmm11,%xmm1
movdqa %xmm7,%xmm4
punpcklbw %xmm11,%xmm4
movdqa %xmm4,%xmm13
punpcklwd %xmm11,%xmm13
paddd  %xmm5,%xmm13
punpckhwd %xmm11,%xmm4
paddd  %xmm2,%xmm4
punpckhbw %xmm11,%xmm7
movdqa %xmm7,%xmm12
punpcklwd %xmm11,%xmm12
paddd  %xmm6,%xmm12
punpckhwd %xmm11,%xmm7
paddd  %xmm1,%xmm7
movdqu -0x1(%rbp,%rsi,1),%xmm0
movdqu 0x0(%rbp,%rsi,1),%xmm1
movdqa %xmm0,%xmm2
punpcklbw %xmm11,%xmm0
movdqa %xmm0,%xmm3
punpcklwd %xmm11,%xmm0
movdqa %xmm1,%xmm6
punpcklbw %xmm11,%xmm6
movdqa %xmm6,%xmm5
punpcklwd %xmm11,%xmm5
paddd  %xmm0,%xmm5
paddd  %xmm13,%xmm5
punpckhbw %xmm11,%xmm2
punpckhwd %xmm11,%xmm3
punpckhwd %xmm11,%xmm6
paddd  %xmm3,%xmm6
movdqa %xmm2,%xmm0
punpcklwd %xmm11,%xmm2
paddd  %xmm4,%xmm6
punpckhbw %xmm11,%xmm1
movdqa %xmm1,%xmm4
punpcklwd %xmm11,%xmm4
paddd  %xmm2,%xmm4
paddd  %xmm12,%xmm4
movdqu (%rax,%rsi,1),%xmm2
punpckhwd %xmm11,%xmm0
punpckhwd %xmm11,%xmm1
paddd  %xmm0,%xmm1
movdqa %xmm2,%xmm0
punpckhbw %xmm11,%xmm0
paddd  %xmm7,%xmm1
movdqa %xmm0,%xmm3
punpckhwd %xmm11,%xmm3
paddd  %xmm8,%xmm1
psrld  $0x2,%xmm1
paddd  %xmm3,%xmm1
punpcklwd %xmm11,%xmm0
punpcklbw %xmm11,%xmm2
paddd  %xmm8,%xmm4
psrld  $0x2,%xmm4
paddd  %xmm0,%xmm4
movdqa %xmm2,%xmm0
punpckhwd %xmm11,%xmm0
paddd  %xmm8,%xmm6
psrld  $0x2,%xmm6
paddd  %xmm0,%xmm6
punpcklwd %xmm11,%xmm2
paddd  %xmm8,%xmm5
psrld  $0x2,%xmm5
paddd  %xmm2,%xmm5
psubd  %xmm9,%xmm1
psubd  %xmm9,%xmm4
psrld  $0x1,%xmm4
psrld  $0x1,%xmm1
pand   %xmm10,%xmm1
pand   %xmm10,%xmm4
packuswb %xmm1,%xmm4
psubd  %xmm9,%xmm6
psubd  %xmm9,%xmm5
psrld  $0x1,%xmm5
psrld  $0x1,%xmm6
pand   %xmm10,%xmm6
pand   %xmm10,%xmm5
packuswb %xmm6,%xmm5
packuswb %xmm4,%xmm5
movdqu %xmm5,(%rax,%rsi,1)
add    $0x10,%rsi
cmp    %rsi,%r11
jne    1c40 <pred_comp+0xb40>
cmp    %r12,%r11
je     1b90 <pred_comp+0xa90>
mov    %r11,%rsi
mov    %r11,%rdi
test   $0x8,%r12b
je     1f20 <pred_comp+0xe20>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movq   (%rax,%rsi,1),%xmm1
punpcklbw %xmm11,%xmm1
movdqa %xmm1,%xmm4
punpckhwd %xmm11,%xmm4
punpcklwd %xmm11,%xmm1
movq   (%r10,%rsi,1),%xmm0
punpcklbw %xmm11,%xmm0
movdqa %xmm0,%xmm2
punpcklwd %xmm11,%xmm2
punpckhwd %xmm11,%xmm0
movq   0x1(%r10,%rsi,1),%xmm3
punpcklbw %xmm11,%xmm3
movdqa %xmm3,%xmm6
punpcklwd %xmm11,%xmm6
paddd  %xmm2,%xmm6
punpckhwd %xmm11,%xmm3
paddd  %xmm0,%xmm3
movq   -0x1(%rbp,%rsi,1),%xmm0
punpcklbw %xmm11,%xmm0
movdqa %xmm0,%xmm7
punpckhwd %xmm11,%xmm7
punpcklwd %xmm11,%xmm0
movq   0x0(%rbp,%rsi,1),%xmm2
punpcklbw %xmm11,%xmm2
movdqa %xmm2,%xmm5
punpcklwd %xmm11,%xmm5
paddd  %xmm0,%xmm5
paddd  %xmm6,%xmm5
punpckhwd %xmm11,%xmm2
paddd  %xmm7,%xmm2
paddd  %xmm3,%xmm2
paddd  %xmm8,%xmm5
paddd  %xmm8,%xmm2
psrld  $0x2,%xmm2
paddd  %xmm4,%xmm2
psrld  $0x2,%xmm5
paddd  %xmm1,%xmm5
psubd  %xmm9,%xmm2
psubd  %xmm9,%xmm5
psrld  $0x1,%xmm5
psrld  $0x1,%xmm2
pand   %xmm10,%xmm2
pand   %xmm10,%xmm5
packuswb %xmm2,%xmm5
packuswb %xmm5,%xmm5
movq   %xmm5,(%rax,%rsi,1)
add    $0x8,%rsi
cmp    %rsi,%r9
jne    1e20 <pred_comp+0xd20>
mov    %r9,%rdi
cmp    %r12,%r9
je     1b90 <pred_comp+0xa90>
cs nopw 0x0(%rax,%rax,1)
nop
movzbl (%rax,%rdi,1),%edx
movzbl (%r10,%rdi,1),%esi
movzbl 0x1(%r10,%rdi,1),%ebx
add    %esi,%ebx
movzbl -0x1(%rbp,%rdi,1),%esi
add    %ebx,%esi
movzbl 0x0(%rbp,%rdi,1),%ebx
add    %ebx,%esi
add    $0x2,%esi
shr    $0x2,%esi
add    %esi,%edx
add    $0x1,%edx
shr    %edx
mov    %dl,(%rax,%rdi,1)
lea    0x1(%rdi),%rdx
mov    %rdx,%rdi
cmp    %rdx,%r12
jne    1f20 <pred_comp+0xe20>
jmp    1b90 <pred_comp+0xa90>
cmpl   $0x0,-0x44(%rsp)
jle    2581 <pred_comp+0x1481>
movslq %edx,%r11
mov    -0x48(%rsp),%esi
add    %rdi,%rcx
add    %rsi,%rcx
mov    %rcx,-0x28(%rsp)
mov    -0x40(%rsp),%rcx
lea    (%r11,%rcx,1),%rdi
add    %r8,%rdi
lea    (%rdi,%rsi,1),%rdx
mov    %rdx,-0x18(%rsp)
add    %r8,%rcx
add    %rsi,%rcx
mov    %rcx,-0x40(%rsp)
mov    %esi,%r13d
and    $0xffffffe0,%r13d
mov    %esi,%r9d
and    $0xfffffff8,%r9d
mov    %rsi,%r12
neg    %r12
mov    -0x38(%rsp),%rdx
lea    (%rdx,%rdi,1),%rbp
add    $0x10,%rbp
mov    %rdi,-0x30(%rsp)
lea    (%rdx,%rdi,1),%r14
xor    %r15d,%r15d
jmp    1feb <pred_comp+0xeeb>
nopl   0x0(%rax)
add    %r11,%r10
add    %r11,%rax
add    $0x1,%r15
add    %r11,%rbp
add    %r11,%r14
cmp    -0x44(%rsp),%r15d
je     2581 <pred_comp+0x1481>
cmpl   $0x0,-0x48(%rsp)
jle    1fd0 <pred_comp+0xed0>
cmpl   $0x8,-0x48(%rsp)
jb     2070 <pred_comp+0xf70>
mov    %r15,%rdx
imul   %r11,%rdx
mov    -0x28(%rsp),%rcx
lea    (%rcx,%rdx,1),%rdi
add    -0x20(%rsp),%rdi
mov    -0x30(%rsp),%rcx
lea    (%rcx,%rdx,1),%r8
mov    -0x38(%rsp),%rcx
add    %rcx,%r8
mov    -0x18(%rsp),%rbx
add    %rdx,%rbx
add    %rcx,%rbx
add    -0x40(%rsp),%rdx
add    %rcx,%rdx
cmp    %rbx,%rax
setb   %bl
cmp    %rdi,%r8
setb   %r8b
cmp    %rdx,%rax
setb   %dl
cmp    %rdi,%r10
setb   %dil
test   %r8b,%bl
jne    2070 <pred_comp+0xf70>
mov    $0x0,%ebx
and    %dil,%dl
jne    2072 <pred_comp+0xf72>
cmpl   $0x20,-0x48(%rsp)
jae    20e9 <pred_comp+0xfe9>
xor    %edi,%edi
jmp    2140 <pred_comp+0x1040>
nopl   (%rax)
xor    %ebx,%ebx
mov    %rbx,%rdi
test   $0x1,%sil
je     209a <pred_comp+0xf9a>
movzbl (%r10,%rbx,1),%edx
lea    (%rbx,%r11,1),%rdi
movzbl (%r10,%rdi,1),%edi
add    %edi,%edx
add    $0x1,%edx
shr    %edx
mov    %dl,(%rax,%rbx,1)
mov    %rbx,%rdi
or     $0x1,%rdi
not    %rbx
cmp    %r12,%rbx
je     1fd0 <pred_comp+0xed0>
cs nopw 0x0(%rax,%rax,1)
movzbl (%r10,%rdi,1),%edx
movzbl (%r14,%rdi,1),%ebx
add    %ebx,%edx
add    $0x1,%edx
shr    %edx
mov    %dl,(%rax,%rdi,1)
movzbl 0x1(%r10,%rdi,1),%edx
movzbl 0x1(%r14,%rdi,1),%ebx
add    %ebx,%edx
add    $0x1,%edx
shr    %edx
mov    %dl,0x1(%rax,%rdi,1)
add    $0x2,%rdi
cmp    %rdi,%rsi
jne    20b0 <pred_comp+0xfb0>
jmp    1fd0 <pred_comp+0xed0>
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movdqu (%r10,%rdi,1),%xmm0
movdqu 0x10(%r10,%rdi,1),%xmm1
movdqu -0x10(%rbp,%rdi,1),%xmm2
pavgb  %xmm0,%xmm2
movdqu 0x0(%rbp,%rdi,1),%xmm0
pavgb  %xmm1,%xmm0
movdqu %xmm2,(%rax,%rdi,1)
movdqu %xmm0,0x10(%rax,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%r13
jne    20f0 <pred_comp+0xff0>
cmp    %rsi,%r13
je     1fd0 <pred_comp+0xed0>
mov    %r13,%rdi
mov    %r13,%rbx
test   $0x18,%sil
je     2072 <pred_comp+0xf72>
xchg   %ax,%ax
movq   (%r10,%rdi,1),%xmm0
movq   (%r14,%rdi,1),%xmm1
pavgb  %xmm0,%xmm1
movq   %xmm1,(%rax,%rdi,1)
add    $0x8,%rdi
cmp    %rdi,%r9
jne    2140 <pred_comp+0x1040>
mov    %r9,%rbx
cmp    %rsi,%r9
je     1fd0 <pred_comp+0xed0>
jmp    2072 <pred_comp+0xf72>
cmpl   $0x0,-0x44(%rsp)
jle    2581 <pred_comp+0x1481>
movslq %edx,%r15
mov    -0x48(%rsp),%esi
add    %rdi,%rcx
add    %rsi,%rcx
mov    -0x40(%rsp),%rdx
add    %r8,%rdx
lea    (%rsi,%rdx,1),%r11
add    $0x1,%r11
mov    %esi,%r9d
and    $0xffffffe0,%r9d
mov    %esi,%r12d
and    $0xfffffff8,%r12d
mov    %rsi,%r14
neg    %r14
xor    %edx,%edx
jmp    21c4 <pred_comp+0x10c4>
nop
add    %r15,%r10
add    %r15,%rax
add    $0x1,%rdx
cmp    -0x44(%rsp),%edx
je     2581 <pred_comp+0x1481>
cmpl   $0x0,-0x48(%rsp)
jle    21b0 <pred_comp+0x10b0>
cmpl   $0x8,-0x48(%rsp)
jb     21f8 <pred_comp+0x10f8>
mov    %rdx,%rdi
imul   %r15,%rdi
lea    (%r11,%rdi,1),%rbp
add    -0x38(%rsp),%rbp
cmp    %rbp,%rax
jae    226f <pred_comp+0x116f>
add    %rcx,%rdi
add    -0x20(%rsp),%rdi
cmp    %rdi,%r10
jae    226f <pred_comp+0x116f>
xor    %ebp,%ebp
mov    %rbp,%rdi
test   $0x1,%sil
je     221f <pred_comp+0x111f>
movzbl (%r10,%rbp,1),%r8d
mov    %rbp,%rdi
or     $0x1,%rdi
movzbl (%r10,%rdi,1),%ebx
add    %r8d,%ebx
add    $0x1,%ebx
shr    %ebx
mov    %bl,(%rax,%rbp,1)
not    %rbp
cmp    %r14,%rbp
je     21b0 <pred_comp+0x10b0>
nopw   0x0(%rax,%rax,1)
movzbl (%r10,%rdi,1),%ebp
movzbl 0x1(%r10,%rdi,1),%ebx
add    %ebx,%ebp
add    $0x1,%ebp
shr    %ebp
mov    %bpl,(%rax,%rdi,1)
movzbl 0x1(%r10,%rdi,1),%ebp
movzbl 0x2(%r10,%rdi,1),%ebx
add    %ebx,%ebp
add    $0x1,%ebp
shr    %ebp
mov    %bpl,0x1(%rax,%rdi,1)
lea    0x2(%rdi),%rbp
mov    %rbp,%rdi
cmp    %rbp,%rsi
jne    2230 <pred_comp+0x1130>
jmp    21b0 <pred_comp+0x10b0>
cmpl   $0x20,-0x48(%rsp)
jae    227a <pred_comp+0x117a>
xor    %edi,%edi
jmp    22d0 <pred_comp+0x11d0>
xor    %edi,%edi
nopl   0x0(%rax)
movdqu (%r10,%rdi,1),%xmm0
movdqu 0x1(%r10,%rdi,1),%xmm1
pavgb  %xmm0,%xmm1
movdqu 0x10(%r10,%rdi,1),%xmm0
movdqu 0x11(%r10,%rdi,1),%xmm2
pavgb  %xmm0,%xmm2
movdqu %xmm1,(%rax,%rdi,1)
movdqu %xmm2,0x10(%rax,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%r9
jne    2280 <pred_comp+0x1180>
cmp    %rsi,%r9
je     21b0 <pred_comp+0x10b0>
mov    %r9,%rdi
mov    %r9,%rbp
test   $0x18,%sil
je     21fa <pred_comp+0x10fa>
movq   (%r10,%rdi,1),%xmm0
movq   0x1(%r10,%rdi,1),%xmm1
pavgb  %xmm0,%xmm1
movq   %xmm1,(%rax,%rdi,1)
add    $0x8,%rdi
cmp    %rdi,%r12
jne    22d0 <pred_comp+0x11d0>
mov    %r12,%rbp
cmp    %rsi,%r12
je     21b0 <pred_comp+0x10b0>
jmp    21fa <pred_comp+0x10fa>
cmpl   $0x0,-0x44(%rsp)
jle    2581 <pred_comp+0x1481>
movslq %edx,%r13
mov    -0x48(%rsp),%esi
add    %rdi,%rcx
add    %rsi,%rcx
mov    %rcx,-0x28(%rsp)
mov    -0x40(%rsp),%rcx
lea    (%rcx,%r13,1),%r15
add    %r8,%r15
lea    (%rsi,%r15,1),%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rsp)
add    %r8,%rcx
add    %rsi,%rcx
add    $0x1,%rcx
mov    %rcx,-0x40(%rsp)
mov    %esi,%r12d
and    $0xfffffff0,%r12d
mov    %esi,%r9d
and    $0xfffffff8,%r9d
mov    -0x38(%rsp),%rdx
lea    (%rdx,%r15,1),%rbp
add    $0x1,%rbp
xor    %r8d,%r8d
pxor   %xmm0,%xmm0
movdqa 0xcc0(%rip),%xmm8
movdqa 0xc88(%rip),%xmm2
jmp    2398 <pred_comp+0x1298>
nopw   0x0(%rax,%rax,1)
add    %r13,%r10
add    %r13,%rax
add    $0x1,%r8
add    %r13,%rbp
cmp    -0x44(%rsp),%r8d
je     2581 <pred_comp+0x1481>
cmpl   $0x0,-0x48(%rsp)
jle    2380 <pred_comp+0x1280>
cmpl   $0x8,-0x48(%rsp)
jae    23f0 <pred_comp+0x12f0>
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movzbl (%r10,%rbx,1),%edx
movzbl 0x1(%r10,%rbx,1),%edi
add    %edx,%edi
movzbl -0x1(%rbp,%rbx,1),%edx
add    %edi,%edx
movzbl 0x0(%rbp,%rbx,1),%edi
add    %edi,%edx
add    $0x2,%edx
shr    $0x2,%edx
mov    %dl,(%rax,%rbx,1)
lea    0x1(%rbx),%rdx
mov    %rdx,%rbx
cmp    %rdx,%rsi
jne    23b0 <pred_comp+0x12b0>
jmp    2380 <pred_comp+0x1280>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r8,%rdi
imul   %r13,%rdi
mov    -0x28(%rsp),%rcx
lea    (%rcx,%rdi,1),%rbx
add    -0x20(%rsp),%rbx
lea    (%r15,%rdi,1),%r14
mov    -0x38(%rsp),%rcx
add    %rcx,%r14
mov    -0x30(%rsp),%rdx
add    %rdi,%rdx
add    %rcx,%rdx
add    -0x40(%rsp),%rdi
add    %rcx,%rdi
cmp    %rdx,%rax
setb   %dl
cmp    %rbx,%r14
setb   %r11b
cmp    %rdi,%rax
setb   %dil
cmp    %rbx,%r10
setb   %r14b
test   %r11b,%dl
jne    24c6 <pred_comp+0x13c6>
mov    $0x0,%ebx
and    %r14b,%dil
jne    23b0 <pred_comp+0x12b0>
cmpl   $0x10,-0x48(%rsp)
jae    24cd <pred_comp+0x13cd>
xor    %edi,%edi
nop
movq   (%r10,%rdi,1),%xmm1
punpcklbw %xmm0,%xmm1
movq   0x1(%r10,%rdi,1),%xmm3
punpcklbw %xmm0,%xmm3
paddw  %xmm1,%xmm3
movq   -0x1(%rbp,%rdi,1),%xmm1
punpcklbw %xmm0,%xmm1
movq   0x0(%rbp,%rdi,1),%xmm4
punpcklbw %xmm0,%xmm4
paddw  %xmm1,%xmm4
paddw  %xmm3,%xmm4
paddw  %xmm8,%xmm4
psrlw  $0x2,%xmm4
pand   %xmm2,%xmm4
packuswb %xmm4,%xmm4
movq   %xmm4,(%rax,%rdi,1)
add    $0x8,%rdi
cmp    %rdi,%r9
jne    2460 <pred_comp+0x1360>
mov    %r9,%rbx
cmp    %rsi,%r9
jne    23b0 <pred_comp+0x12b0>
jmp    2380 <pred_comp+0x1280>
xor    %ebx,%ebx
jmp    23b0 <pred_comp+0x12b0>
xor    %ebx,%ebx
nop
movdqu (%r10,%rbx,1),%xmm3
movdqu 0x1(%r10,%rbx,1),%xmm4
movdqa %xmm3,%xmm5
punpckhbw %xmm0,%xmm5
punpcklbw %xmm0,%xmm3
movdqa %xmm4,%xmm6
punpckhbw %xmm0,%xmm6
paddw  %xmm5,%xmm6
punpcklbw %xmm0,%xmm4
paddw  %xmm3,%xmm4
movdqu -0x1(%rbp,%rbx,1),%xmm3
movdqu 0x0(%rbp,%rbx,1),%xmm5
movdqa %xmm3,%xmm7
punpcklbw %xmm0,%xmm7
punpckhbw %xmm0,%xmm3
movdqa %xmm5,%xmm1
punpckhbw %xmm0,%xmm1
paddw  %xmm3,%xmm1
paddw  %xmm6,%xmm1
punpcklbw %xmm0,%xmm5
paddw  %xmm7,%xmm5
paddw  %xmm4,%xmm5
paddw  %xmm8,%xmm1
paddw  %xmm8,%xmm5
psrlw  $0x2,%xmm5
psrlw  $0x2,%xmm1
pand   %xmm2,%xmm1
pand   %xmm2,%xmm5
packuswb %xmm1,%xmm5
movdqu %xmm5,(%rax,%rbx,1)
add    $0x10,%rbx
cmp    %rbx,%r12
jne    24d0 <pred_comp+0x13d0>
cmp    %rsi,%r12
je     2380 <pred_comp+0x1280>
mov    %r12,%rdi
mov    %r12,%rbx
test   $0x8,%sil
je     23b0 <pred_comp+0x12b0>
jmp    2460 <pred_comp+0x1360>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @pred_comp(i8* nocapture %0, i8* nocapture %1, i32 %2, i32 %3, i32 %4, i32 %5, i32 %6, i32 %7, i32 %8, i32 %9) {
%11 = ashr i32 %7, 1
%12 = ashr i32 %8, 1
%13 = and i32 %8, 1
%14 = add nsw i32 %12, %6
%15 = mul nsw i32 %14, %2
%16 = sext i32 %15 to i64
%17 = getelementptr inbounds i8, i8* %0, i64 %16
%18 = add nsw i32 %11, %5
%19 = sext i32 %18 to i64
%20 = getelementptr inbounds i8, i8* %17, i64 %19
%21 = mul nsw i32 %6, %2
%22 = sext i32 %21 to i64
%23 = getelementptr inbounds i8, i8* %1, i64 %22
%24 = sext i32 %5 to i64
%25 = getelementptr inbounds i8, i8* %23, i64 %24
%26 = icmp ne i32 %13, 0
%27 = or i32 %8, %7
%28 = and i32 %27, 1
%29 = icmp eq i32 %28, 0
br i1 %29, label %30, label %336
30: ; preds = %10
%31 = icmp eq i32 %9, 0
%32 = icmp sgt i32 %4, 0
br i1 %31, label %53, label %33
33: ; preds = %30
br i1 %32, label %34, label %1294
34: ; preds = %33
%35 = icmp sgt i32 %3, 0
%36 = sext i32 %2 to i64
%37 = zext i32 %3 to i64
%38 = add nsw i64 %24, %22
%39 = add nsw i64 %38, %37
%40 = add nsw i64 %16, %19
%41 = add nsw i64 %40, %37
%42 = icmp ult i32 %3, 8
%43 = icmp ult i32 %3, 32
%44 = and i64 %37, 4294967264
%45 = icmp eq i64 %44, %37
%46 = and i64 %37, 24
%47 = icmp eq i64 %46, 0
%48 = and i64 %37, 4294967288
%49 = icmp eq i64 %48, %37
%50 = and i64 %37, 1
%51 = icmp eq i64 %50, 0
%52 = sub nsw i64 0, %37
br label %80
53: ; preds = %30
br i1 %32, label %54, label %1294
54: ; preds = %53
%55 = icmp sgt i32 %3, 0
%56 = sext i32 %2 to i64
%57 = zext i32 %3 to i64
%58 = add nsw i64 %24, %22
%59 = add nsw i64 %58, %57
%60 = add nsw i64 %16, %19
%61 = add nsw i64 %60, %57
%62 = and i64 %57, 4294967264
%63 = add nsw i64 %62, -32
%64 = lshr exact i64 %63, 5
%65 = add nuw nsw i64 %64, 1
%66 = icmp ult i32 %3, 8
%67 = icmp ult i32 %3, 32
%68 = and i64 %57, 4294967264
%69 = and i64 %65, 3
%70 = icmp ult i64 %63, 96
%71 = and i64 %65, 1152921504606846972
%72 = icmp eq i64 %69, 0
%73 = icmp eq i64 %68, %57
%74 = and i64 %57, 24
%75 = icmp eq i64 %74, 0
%76 = and i64 %57, 4294967288
%77 = icmp eq i64 %76, %57
%78 = and i64 %57, 3
%79 = icmp eq i64 %78, 0
br label %197
80: ; preds = %34, %191
%81 = phi i64 [ 0, %34 ], [ %196, %191 ]
%82 = phi i8* [ %25, %34 ], [ %193, %191 ]
%83 = phi i8* [ %20, %34 ], [ %192, %191 ]
%84 = phi i32 [ 0, %34 ], [ %194, %191 ]
%85 = mul i64 %81, %36
%86 = add i64 %39, %85
%87 = getelementptr i8, i8* %1, i64 %86
%88 = add i64 %41, %85
%89 = getelementptr i8, i8* %0, i64 %88
br i1 %35, label %90, label %191
90: ; preds = %80
br i1 %42, label %148, label %91
91: ; preds = %90
%92 = icmp ult i8* %82, %89
%93 = icmp ult i8* %83, %87
%94 = and i1 %92, %93
br i1 %94, label %148, label %95
95: ; preds = %91
br i1 %43, label %128, label %96
96: ; preds = %95, %96
%97 = phi i64 [ %124, %96 ], [ 0, %95 ]
%98 = getelementptr inbounds i8, i8* %82, i64 %97
%99 = bitcast i8* %98 to <16 x i8>*
%100 = load <16 x i8>, <16 x i8>* %99
%101 = getelementptr inbounds i8, i8* %98, i64 16
%102 = bitcast i8* %101 to <16 x i8>*
%103 = load <16 x i8>, <16 x i8>* %102
%104 = zext <16 x i8> %100 to <16 x i16>
%105 = zext <16 x i8> %103 to <16 x i16>
%106 = getelementptr inbounds i8, i8* %83, i64 %97
%107 = bitcast i8* %106 to <16 x i8>*
%108 = load <16 x i8>, <16 x i8>* %107
%109 = getelementptr inbounds i8, i8* %106, i64 16
%110 = bitcast i8* %109 to <16 x i8>*
%111 = load <16 x i8>, <16 x i8>* %110
%112 = zext <16 x i8> %108 to <16 x i16>
%113 = zext <16 x i8> %111 to <16 x i16>
%114 = add nuw nsw <16 x i16> %104, <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
%115 = add nuw nsw <16 x i16> %105, <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
%116 = add nuw nsw <16 x i16> %114, %112
%117 = add nuw nsw <16 x i16> %115, %113
%118 = lshr <16 x i16> %116, <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
%119 = lshr <16 x i16> %117, <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
%120 = trunc <16 x i16> %118 to <16 x i8>
%121 = trunc <16 x i16> %119 to <16 x i8>
%122 = bitcast i8* %98 to <16 x i8>*
store <16 x i8> %120, <16 x i8>* %122
%123 = bitcast i8* %101 to <16 x i8>*
store <16 x i8> %121, <16 x i8>* %123
%124 = add nuw i64 %97, 32
%125 = icmp eq i64 %124, %44
br i1 %125, label %126, label %96
126: ; preds = %96
br i1 %45, label %191, label %127
127: ; preds = %126
br i1 %47, label %148, label %128
128: ; preds = %95, %127
%129 = phi i64 [ %44, %127 ], [ 0, %95 ]
br label %130
130: ; preds = %130, %128
%131 = phi i64 [ %129, %128 ], [ %145, %130 ]
%132 = getelementptr inbounds i8, i8* %82, i64 %131
%133 = bitcast i8* %132 to <8 x i8>*
%134 = load <8 x i8>, <8 x i8>* %133
%135 = zext <8 x i8> %134 to <8 x i16>
%136 = getelementptr inbounds i8, i8* %83, i64 %131
%137 = bitcast i8* %136 to <8 x i8>*
%138 = load <8 x i8>, <8 x i8>* %137
%139 = zext <8 x i8> %138 to <8 x i16>
%140 = add nuw nsw <8 x i16> %135, <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
%141 = add nuw nsw <8 x i16> %140, %139
%142 = lshr <8 x i16> %141, <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
%143 = trunc <8 x i16> %142 to <8 x i8>
%144 = bitcast i8* %132 to <8 x i8>*
store <8 x i8> %143, <8 x i8>* %144
%145 = add nuw i64 %131, 8
%146 = icmp eq i64 %145, %48
br i1 %146, label %147, label %130
147: ; preds = %130
br i1 %49, label %191, label %148
148: ; preds = %91, %90, %127, %147
%149 = phi i64 [ 0, %90 ], [ 0, %91 ], [ %44, %127 ], [ %48, %147 ]
%150 = xor i64 %149, -1
br i1 %51, label %163, label %151
151: ; preds = %148
%152 = getelementptr inbounds i8, i8* %82, i64 %149
%153 = load i8, i8* %152
%154 = zext i8 %153 to i16
%155 = getelementptr inbounds i8, i8* %83, i64 %149
%156 = load i8, i8* %155
%157 = zext i8 %156 to i16
%158 = add nuw nsw i16 %154, 1
%159 = add nuw nsw i16 %158, %157
%160 = lshr i16 %159, 1
%161 = trunc i16 %160 to i8
store i8 %161, i8* %152
%162 = or i64 %149, 1
br label %163
163: ; preds = %151, %148
%164 = phi i64 [ %149, %148 ], [ %162, %151 ]
%165 = icmp eq i64 %150, %52
br i1 %165, label %191, label %166
166: ; preds = %163, %166
%167 = phi i64 [ %189, %166 ], [ %164, %163 ]
%168 = getelementptr inbounds i8, i8* %82, i64 %167
%169 = load i8, i8* %168
%170 = zext i8 %169 to i16
%171 = getelementptr inbounds i8, i8* %83, i64 %167
%172 = load i8, i8* %171
%173 = zext i8 %172 to i16
%174 = add nuw nsw i16 %170, 1
%175 = add nuw nsw i16 %174, %173
%176 = lshr i16 %175, 1
%177 = trunc i16 %176 to i8
store i8 %177, i8* %168
%178 = add nuw nsw i64 %167, 1
%179 = getelementptr inbounds i8, i8* %82, i64 %178
%180 = load i8, i8* %179
%181 = zext i8 %180 to i16
%182 = getelementptr inbounds i8, i8* %83, i64 %178
%183 = load i8, i8* %182
%184 = zext i8 %183 to i16
%185 = add nuw nsw i16 %181, 1
%186 = add nuw nsw i16 %185, %184
%187 = lshr i16 %186, 1
%188 = trunc i16 %187 to i8
store i8 %188, i8* %179
%189 = add nuw nsw i64 %167, 2
%190 = icmp eq i64 %189, %37
br i1 %190, label %191, label %166
191: ; preds = %163, %166, %126, %147, %80
%192 = getelementptr inbounds i8, i8* %83, i64 %36
%193 = getelementptr inbounds i8, i8* %82, i64 %36
%194 = add nuw nsw i32 %84, 1
%195 = icmp eq i32 %194, %4
%196 = add i64 %81, 1
br i1 %195, label %1294, label %80
197: ; preds = %54, %330
%198 = phi i64 [ 0, %54 ], [ %335, %330 ]
%199 = phi i8* [ %25, %54 ], [ %332, %330 ]
%200 = phi i8* [ %20, %54 ], [ %331, %330 ]
%201 = phi i32 [ 0, %54 ], [ %333, %330 ]
%202 = mul i64 %198, %56
%203 = add i64 %59, %202
%204 = getelementptr i8, i8* %1, i64 %203
%205 = add i64 %61, %202
%206 = getelementptr i8, i8* %0, i64 %205
br i1 %55, label %207, label %330
207: ; preds = %197
br i1 %66, label %295, label %208
208: ; preds = %207
%209 = icmp ult i8* %199, %206
%210 = icmp ult i8* %200, %204
%211 = and i1 %209, %210
br i1 %211, label %295, label %212
212: ; preds = %208
br i1 %67, label %283, label %213
213: ; preds = %212
br i1 %70, label %263, label %214
214: ; preds = %213, %214
%215 = phi i64 [ %260, %214 ], [ 0, %213 ]
%216 = phi i64 [ %261, %214 ], [ 0, %213 ]
%217 = getelementptr inbounds i8, i8* %200, i64 %215
%218 = bitcast i8* %217 to <16 x i8>*
%219 = load <16 x i8>, <16 x i8>* %218
%220 = getelementptr inbounds i8, i8* %217, i64 16
%221 = bitcast i8* %220 to <16 x i8>*
%222 = load <16 x i8>, <16 x i8>* %221
%223 = getelementptr inbounds i8, i8* %199, i64 %215
%224 = bitcast i8* %223 to <16 x i8>*
store <16 x i8> %219, <16 x i8>* %224
%225 = getelementptr inbounds i8, i8* %223, i64 16
%226 = bitcast i8* %225 to <16 x i8>*
store <16 x i8> %222, <16 x i8>* %226
%227 = or i64 %215, 32
%228 = getelementptr inbounds i8, i8* %200, i64 %227
%229 = bitcast i8* %228 to <16 x i8>*
%230 = load <16 x i8>, <16 x i8>* %229
%231 = getelementptr inbounds i8, i8* %228, i64 16
%232 = bitcast i8* %231 to <16 x i8>*
%233 = load <16 x i8>, <16 x i8>* %232
%234 = getelementptr inbounds i8, i8* %199, i64 %227
%235 = bitcast i8* %234 to <16 x i8>*
store <16 x i8> %230, <16 x i8>* %235
%236 = getelementptr inbounds i8, i8* %234, i64 16
%237 = bitcast i8* %236 to <16 x i8>*
store <16 x i8> %233, <16 x i8>* %237
%238 = or i64 %215, 64
%239 = getelementptr inbounds i8, i8* %200, i64 %238
%240 = bitcast i8* %239 to <16 x i8>*
%241 = load <16 x i8>, <16 x i8>* %240
%242 = getelementptr inbounds i8, i8* %239, i64 16
%243 = bitcast i8* %242 to <16 x i8>*
%244 = load <16 x i8>, <16 x i8>* %243
%245 = getelementptr inbounds i8, i8* %199, i64 %238
%246 = bitcast i8* %245 to <16 x i8>*
store <16 x i8> %241, <16 x i8>* %246
%247 = getelementptr inbounds i8, i8* %245, i64 16
%248 = bitcast i8* %247 to <16 x i8>*
store <16 x i8> %244, <16 x i8>* %248
%249 = or i64 %215, 96
%250 = getelementptr inbounds i8, i8* %200, i64 %249
%251 = bitcast i8* %250 to <16 x i8>*
%252 = load <16 x i8>, <16 x i8>* %251
%253 = getelementptr inbounds i8, i8* %250, i64 16
%254 = bitcast i8* %253 to <16 x i8>*
%255 = load <16 x i8>, <16 x i8>* %254
%256 = getelementptr inbounds i8, i8* %199, i64 %249
%257 = bitcast i8* %256 to <16 x i8>*
store <16 x i8> %252, <16 x i8>* %257
%258 = getelementptr inbounds i8, i8* %256, i64 16
%259 = bitcast i8* %258 to <16 x i8>*
store <16 x i8> %255, <16 x i8>* %259
%260 = add nuw i64 %215, 128
%261 = add i64 %216, 4
%262 = icmp eq i64 %261, %71
br i1 %262, label %263, label %214
263: ; preds = %214, %213
%264 = phi i64 [ 0, %213 ], [ %260, %214 ]
br i1 %72, label %281, label %265
265: ; preds = %263, %265
%266 = phi i64 [ %278, %265 ], [ %264, %263 ]
%267 = phi i64 [ %279, %265 ], [ 0, %263 ]
%268 = getelementptr inbounds i8, i8* %200, i64 %266
%269 = bitcast i8* %268 to <16 x i8>*
%270 = load <16 x i8>, <16 x i8>* %269
%271 = getelementptr inbounds i8, i8* %268, i64 16
%272 = bitcast i8* %271 to <16 x i8>*
%273 = load <16 x i8>, <16 x i8>* %272
%274 = getelementptr inbounds i8, i8* %199, i64 %266
%275 = bitcast i8* %274 to <16 x i8>*
store <16 x i8> %270, <16 x i8>* %275
%276 = getelementptr inbounds i8, i8* %274, i64 16
%277 = bitcast i8* %276 to <16 x i8>*
store <16 x i8> %273, <16 x i8>* %277
%278 = add nuw i64 %266, 32
%279 = add i64 %267, 1
%280 = icmp eq i64 %279, %69
br i1 %280, label %281, label %265
281: ; preds = %265, %263
br i1 %73, label %330, label %282
282: ; preds = %281
br i1 %75, label %295, label %283
283: ; preds = %212, %282
%284 = phi i64 [ %68, %282 ], [ 0, %212 ]
br label %285
285: ; preds = %285, %283
%286 = phi i64 [ %284, %283 ], [ %292, %285 ]
%287 = getelementptr inbounds i8, i8* %200, i64 %286
%288 = bitcast i8* %287 to <8 x i8>*
%289 = load <8 x i8>, <8 x i8>* %288
%290 = getelementptr inbounds i8, i8* %199, i64 %286
%291 = bitcast i8* %290 to <8 x i8>*
store <8 x i8> %289, <8 x i8>* %291
%292 = add nuw i64 %286, 8
%293 = icmp eq i64 %292, %76
br i1 %293, label %294, label %285
294: ; preds = %285
br i1 %77, label %330, label %295
295: ; preds = %208, %207, %282, %294
%296 = phi i64 [ 0, %207 ], [ 0, %208 ], [ %68, %282 ], [ %76, %294 ]
%297 = xor i64 %296, -1
%298 = add nsw i64 %297, %57
br i1 %79, label %308, label %299
299: ; preds = %295, %299
%300 = phi i64 [ %305, %299 ], [ %296, %295 ]
%301 = phi i64 [ %306, %299 ], [ 0, %295 ]
%302 = getelementptr inbounds i8, i8* %200, i64 %300
%303 = load i8, i8* %302
%304 = getelementptr inbounds i8, i8* %199, i64 %300
store i8 %303, i8* %304
%305 = add nuw nsw i64 %300, 1
%306 = add i64 %301, 1
%307 = icmp eq i64 %306, %78
br i1 %307, label %308, label %299
308: ; preds = %299, %295
%309 = phi i64 [ %296, %295 ], [ %305, %299 ]
%310 = icmp ult i64 %298, 3
br i1 %310, label %330, label %311
311: ; preds = %308, %311
%312 = phi i64 [ %328, %311 ], [ %309, %308 ]
%313 = getelementptr inbounds i8, i8* %200, i64 %312
%314 = load i8, i8* %313
%315 = getelementptr inbounds i8, i8* %199, i64 %312
store i8 %314, i8* %315
%316 = add nuw nsw i64 %312, 1
%317 = getelementptr inbounds i8, i8* %200, i64 %316
%318 = load i8, i8* %317
%319 = getelementptr inbounds i8, i8* %199, i64 %316
store i8 %318, i8* %319
%320 = add nuw nsw i64 %312, 2
%321 = getelementptr inbounds i8, i8* %200, i64 %320
%322 = load i8, i8* %321
%323 = getelementptr inbounds i8, i8* %199, i64 %320
store i8 %322, i8* %323
%324 = add nuw nsw i64 %312, 3
%325 = getelementptr inbounds i8, i8* %200, i64 %324
%326 = load i8, i8* %325
%327 = getelementptr inbounds i8, i8* %199, i64 %324
store i8 %326, i8* %327
%328 = add nuw nsw i64 %312, 4
%329 = icmp eq i64 %328, %57
br i1 %329, label %330, label %311
330: ; preds = %308, %311, %281, %294, %197
%331 = getelementptr inbounds i8, i8* %200, i64 %56
%332 = getelementptr inbounds i8, i8* %199, i64 %56
%333 = add nuw nsw i32 %201, 1
%334 = icmp eq i32 %333, %4
%335 = add i64 %198, 1
br i1 %334, label %1294, label %197
336: ; preds = %10
%337 = and i32 %7, 1
%338 = icmp eq i32 %337, 0
%339 = and i1 %338, %26
br i1 %339, label %340, label %674
340: ; preds = %336
%341 = icmp eq i32 %9, 0
%342 = icmp sgt i32 %4, 0
br i1 %341, label %366, label %343
343: ; preds = %340
br i1 %342, label %344, label %1294
344: ; preds = %343
%345 = icmp sgt i32 %3, 0
%346 = sext i32 %2 to i64
%347 = zext i32 %3 to i64
%348 = add nsw i64 %24, %22
%349 = add nsw i64 %348, %347
%350 = add nsw i64 %346, %16
%351 = add nsw i64 %350, %19
%352 = add nsw i64 %351, %347
%353 = add nsw i64 %16, %19
%354 = add nsw i64 %353, %347
%355 = icmp ult i32 %3, 8
%356 = icmp ult i32 %3, 16
%357 = and i64 %347, 4294967280
%358 = icmp eq i64 %357, %347
%359 = and i64 %347, 8
%360 = icmp eq i64 %359, 0
%361 = and i64 %347, 4294967288
%362 = icmp eq i64 %361, %347
%363 = and i64 %347, 1
%364 = icmp eq i64 %363, 0
%365 = sub nsw i64 0, %347
br label %389
366: ; preds = %340
br i1 %342, label %367, label %1294
367: ; preds = %366
%368 = icmp sgt i32 %3, 0
%369 = sext i32 %2 to i64
%370 = zext i32 %3 to i64
%371 = add nsw i64 %24, %22
%372 = add nsw i64 %371, %370
%373 = add nsw i64 %369, %16
%374 = add nsw i64 %373, %19
%375 = add nsw i64 %374, %370
%376 = add nsw i64 %16, %19
%377 = add nsw i64 %376, %370
%378 = icmp ult i32 %3, 8
%379 = icmp ult i32 %3, 32
%380 = and i64 %370, 4294967264
%381 = icmp eq i64 %380, %370
%382 = and i64 %370, 24
%383 = icmp eq i64 %382, 0
%384 = and i64 %370, 4294967288
%385 = icmp eq i64 %384, %370
%386 = and i64 %370, 1
%387 = icmp eq i64 %386, 0
%388 = sub nsw i64 0, %370
br label %538
389: ; preds = %344, %532
%390 = phi i64 [ 0, %344 ], [ %537, %532 ]
%391 = phi i8* [ %25, %344 ], [ %534, %532 ]
%392 = phi i8* [ %20, %344 ], [ %533, %532 ]
%393 = phi i32 [ 0, %344 ], [ %535, %532 ]
%394 = mul i64 %390, %346
%395 = add i64 %349, %394
%396 = getelementptr i8, i8* %1, i64 %395
%397 = add i64 %351, %394
%398 = getelementptr i8, i8* %0, i64 %397
%399 = add i64 %352, %394
%400 = getelementptr i8, i8* %0, i64 %399
%401 = add i64 %354, %394
%402 = getelementptr i8, i8* %0, i64 %401
br i1 %345, label %403, label %532
403: ; preds = %389
br i1 %355, label %468, label %404
404: ; preds = %403
%405 = icmp ult i8* %391, %400
%406 = icmp ult i8* %398, %396
%407 = and i1 %405, %406
%408 = icmp ult i8* %391, %402
%409 = icmp ult i8* %392, %396
%410 = and i1 %408, %409
%411 = or i1 %407, %410
br i1 %411, label %468, label %412
412: ; preds = %404
br i1 %356, label %440, label %413
413: ; preds = %412, %413
%414 = phi i64 [ %436, %413 ], [ 0, %412 ]
%415 = getelementptr inbounds i8, i8* %391, i64 %414
%416 = bitcast i8* %415 to <16 x i8>*
%417 = load <16 x i8>, <16 x i8>* %416
%418 = zext <16 x i8> %417 to <16 x i16>
%419 = getelementptr inbounds i8, i8* %392, i64 %414
%420 = bitcast i8* %419 to <16 x i8>*
%421 = load <16 x i8>, <16 x i8>* %420
%422 = zext <16 x i8> %421 to <16 x i16>
%423 = add nsw i64 %414, %346
%424 = getelementptr inbounds i8, i8* %392, i64 %423
%425 = bitcast i8* %424 to <16 x i8>*
%426 = load <16 x i8>, <16 x i8>* %425
%427 = zext <16 x i8> %426 to <16 x i16>
%428 = add nuw nsw <16 x i16> %422, <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
%429 = add nuw nsw <16 x i16> %428, %427
%430 = lshr <16 x i16> %429, <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
%431 = add nuw nsw <16 x i16> %418, <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
%432 = add nuw nsw <16 x i16> %431, %430
%433 = lshr <16 x i16> %432, <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
%434 = trunc <16 x i16> %433 to <16 x i8>
%435 = bitcast i8* %415 to <16 x i8>*
store <16 x i8> %434, <16 x i8>* %435
%436 = add nuw i64 %414, 16
%437 = icmp eq i64 %436, %357
br i1 %437, label %438, label %413
438: ; preds = %413
br i1 %358, label %532, label %439
439: ; preds = %438
br i1 %360, label %468, label %440
440: ; preds = %412, %439
%441 = phi i64 [ %357, %439 ], [ 0, %412 ]
br label %442
442: ; preds = %442, %440
%443 = phi i64 [ %441, %440 ], [ %465, %442 ]
%444 = getelementptr inbounds i8, i8* %391, i64 %443
%445 = bitcast i8* %444 to <8 x i8>*
%446 = load <8 x i8>, <8 x i8>* %445
%447 = zext <8 x i8> %446 to <8 x i16>
%448 = getelementptr inbounds i8, i8* %392, i64 %443
%449 = bitcast i8* %448 to <8 x i8>*
%450 = load <8 x i8>, <8 x i8>* %449
%451 = zext <8 x i8> %450 to <8 x i16>
%452 = add nsw i64 %443, %346
%453 = getelementptr inbounds i8, i8* %392, i64 %452
%454 = bitcast i8* %453 to <8 x i8>*
%455 = load <8 x i8>, <8 x i8>* %454
%456 = zext <8 x i8> %455 to <8 x i16>
%457 = add nuw nsw <8 x i16> %451, <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
%458 = add nuw nsw <8 x i16> %457, %456
%459 = lshr <8 x i16> %458, <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
%460 = add nuw nsw <8 x i16> %447, <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
%461 = add nuw nsw <8 x i16> %460, %459
%462 = lshr <8 x i16> %461, <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
%463 = trunc <8 x i16> %462 to <8 x i8>
%464 = bitcast i8* %444 to <8 x i8>*
store <8 x i8> %463, <8 x i8>* %464
%465 = add nuw i64 %443, 8
%466 = icmp eq i64 %465, %361
br i1 %466, label %467, label %442
467: ; preds = %442
br i1 %362, label %532, label %468
468: ; preds = %404, %403, %439, %467
%469 = phi i64 [ 0, %403 ], [ 0, %404 ], [ %357, %439 ], [ %361, %467 ]
%470 = xor i64 %469, -1
br i1 %364, label %490, label %471
471: ; preds = %468
%472 = getelementptr inbounds i8, i8* %391, i64 %469
%473 = load i8, i8* %472
%474 = zext i8 %473 to i16
%475 = getelementptr inbounds i8, i8* %392, i64 %469
%476 = load i8, i8* %475
%477 = zext i8 %476 to i16
%478 = add nsw i64 %469, %346
%479 = getelementptr inbounds i8, i8* %392, i64 %478
%480 = load i8, i8* %479
%481 = zext i8 %480 to i16
%482 = add nuw nsw i16 %477, 1
%483 = add nuw nsw i16 %482, %481
%484 = lshr i16 %483, 1
%485 = add nuw nsw i16 %474, 1
%486 = add nuw nsw i16 %485, %484
%487 = lshr i16 %486, 1
%488 = trunc i16 %487 to i8
store i8 %488, i8* %472
%489 = or i64 %469, 1
br label %490
490: ; preds = %471, %468
%491 = phi i64 [ %469, %468 ], [ %489, %471 ]
%492 = icmp eq i64 %470, %365
br i1 %492, label %532, label %493
493: ; preds = %490, %493
%494 = phi i64 [ %530, %493 ], [ %491, %490 ]
%495 = getelementptr inbounds i8, i8* %391, i64 %494
%496 = load i8, i8* %495
%497 = zext i8 %496 to i16
%498 = getelementptr inbounds i8, i8* %392, i64 %494
%499 = load i8, i8* %498
%500 = zext i8 %499 to i16
%501 = add nsw i64 %494, %346
%502 = getelementptr inbounds i8, i8* %392, i64 %501
%503 = load i8, i8* %502
%504 = zext i8 %503 to i16
%505 = add nuw nsw i16 %500, 1
%506 = add nuw nsw i16 %505, %504
%507 = lshr i16 %506, 1
%508 = add nuw nsw i16 %497, 1
%509 = add nuw nsw i16 %508, %507
%510 = lshr i16 %509, 1
%511 = trunc i16 %510 to i8
store i8 %511, i8* %495
%512 = add nuw nsw i64 %494, 1
%513 = getelementptr inbounds i8, i8* %391, i64 %512
%514 = load i8, i8* %513
%515 = zext i8 %514 to i16
%516 = getelementptr inbounds i8, i8* %392, i64 %512
%517 = load i8, i8* %516
%518 = zext i8 %517 to i16
%519 = add nsw i64 %512, %346
%520 = getelementptr inbounds i8, i8* %392, i64 %519
%521 = load i8, i8* %520
%522 = zext i8 %521 to i16
%523 = add nuw nsw i16 %518, 1
%524 = add nuw nsw i16 %523, %522
%525 = lshr i16 %524, 1
%526 = add nuw nsw i16 %515, 1
%527 = add nuw nsw i16 %526, %525
%528 = lshr i16 %527, 1
%529 = trunc i16 %528 to i8
store i8 %529, i8* %513
%530 = add nuw nsw i64 %494, 2
%531 = icmp eq i64 %530, %347
br i1 %531, label %532, label %493
532: ; preds = %490, %493, %438, %467, %389
%533 = getelementptr inbounds i8, i8* %392, i64 %346
%534 = getelementptr inbounds i8, i8* %391, i64 %346
%535 = add nuw nsw i32 %393, 1
%536 = icmp eq i32 %535, %4
%537 = add i64 %390, 1
br i1 %536, label %1294, label %389
538: ; preds = %367, %668
%539 = phi i64 [ 0, %367 ], [ %673, %668 ]
%540 = phi i8* [ %25, %367 ], [ %670, %668 ]
%541 = phi i8* [ %20, %367 ], [ %669, %668 ]
%542 = phi i32 [ 0, %367 ], [ %671, %668 ]
%543 = mul i64 %539, %369
%544 = add i64 %372, %543
%545 = getelementptr i8, i8* %1, i64 %544
%546 = add i64 %374, %543
%547 = getelementptr i8, i8* %0, i64 %546
%548 = add i64 %375, %543
%549 = getelementptr i8, i8* %0, i64 %548
%550 = add i64 %377, %543
%551 = getelementptr i8, i8* %0, i64 %550
br i1 %368, label %552, label %668
552: ; preds = %538
br i1 %378, label %619, label %553
553: ; preds = %552
%554 = icmp ult i8* %540, %549
%555 = icmp ult i8* %547, %545
%556 = and i1 %554, %555
%557 = icmp ult i8* %540, %551
%558 = icmp ult i8* %541, %545
%559 = and i1 %557, %558
%560 = or i1 %556, %559
br i1 %560, label %619, label %561
561: ; preds = %553
br i1 %379, label %597, label %562
562: ; preds = %561, %562
%563 = phi i64 [ %593, %562 ], [ 0, %561 ]
%564 = getelementptr inbounds i8, i8* %541, i64 %563
%565 = bitcast i8* %564 to <16 x i8>*
%566 = load <16 x i8>, <16 x i8>* %565
%567 = getelementptr inbounds i8, i8* %564, i64 16
%568 = bitcast i8* %567 to <16 x i8>*
%569 = load <16 x i8>, <16 x i8>* %568
%570 = zext <16 x i8> %566 to <16 x i16>
%571 = zext <16 x i8> %569 to <16 x i16>
%572 = add nsw i64 %563, %369
%573 = getelementptr inbounds i8, i8* %541, i64 %572
%574 = bitcast i8* %573 to <16 x i8>*
%575 = load <16 x i8>, <16 x i8>* %574
%576 = getelementptr inbounds i8, i8* %573, i64 16
%577 = bitcast i8* %576 to <16 x i8>*
%578 = load <16 x i8>, <16 x i8>* %577
%579 = zext <16 x i8> %575 to <16 x i16>
%580 = zext <16 x i8> %578 to <16 x i16>
%581 = add nuw nsw <16 x i16> %570, <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
%582 = add nuw nsw <16 x i16> %571, <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
%583 = add nuw nsw <16 x i16> %581, %579
%584 = add nuw nsw <16 x i16> %582, %580
%585 = lshr <16 x i16> %583, <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
%586 = lshr <16 x i16> %584, <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
%587 = trunc <16 x i16> %585 to <16 x i8>
%588 = trunc <16 x i16> %586 to <16 x i8>
%589 = getelementptr inbounds i8, i8* %540, i64 %563
%590 = bitcast i8* %589 to <16 x i8>*
store <16 x i8> %587, <16 x i8>* %590
%591 = getelementptr inbounds i8, i8* %589, i64 16
%592 = bitcast i8* %591 to <16 x i8>*
store <16 x i8> %588, <16 x i8>* %592
%593 = add nuw i64 %563, 32
%594 = icmp eq i64 %593, %380
br i1 %594, label %595, label %562
595: ; preds = %562
br i1 %381, label %668, label %596
596: ; preds = %595
br i1 %383, label %619, label %597
597: ; preds = %561, %596
%598 = phi i64 [ %380, %596 ], [ 0, %561 ]
br label %599
599: ; preds = %599, %597
%600 = phi i64 [ %598, %597 ], [ %616, %599 ]
%601 = getelementptr inbounds i8, i8* %541, i64 %600
%602 = bitcast i8* %601 to <8 x i8>*
%603 = load <8 x i8>, <8 x i8>* %602
%604 = zext <8 x i8> %603 to <8 x i16>
%605 = add nsw i64 %600, %369
%606 = getelementptr inbounds i8, i8* %541, i64 %605
%607 = bitcast i8* %606 to <8 x i8>*
%608 = load <8 x i8>, <8 x i8>* %607
%609 = zext <8 x i8> %608 to <8 x i16>
%610 = add nuw nsw <8 x i16> %604, <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
%611 = add nuw nsw <8 x i16> %610, %609
%612 = lshr <8 x i16> %611, <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
%613 = trunc <8 x i16> %612 to <8 x i8>
%614 = getelementptr inbounds i8, i8* %540, i64 %600
%615 = bitcast i8* %614 to <8 x i8>*
store <8 x i8> %613, <8 x i8>* %615
%616 = add nuw i64 %600, 8
%617 = icmp eq i64 %616, %384
br i1 %617, label %618, label %599
618: ; preds = %599
br i1 %385, label %668, label %619
619: ; preds = %553, %552, %596, %618
%620 = phi i64 [ 0, %552 ], [ 0, %553 ], [ %380, %596 ], [ %384, %618 ]
%621 = xor i64 %620, -1
br i1 %387, label %636, label %622
622: ; preds = %619
%623 = getelementptr inbounds i8, i8* %541, i64 %620
%624 = load i8, i8* %623
%625 = zext i8 %624 to i16
%626 = add nsw i64 %620, %369
%627 = getelementptr inbounds i8, i8* %541, i64 %626
%628 = load i8, i8* %627
%629 = zext i8 %628 to i16
%630 = add nuw nsw i16 %625, 1
%631 = add nuw nsw i16 %630, %629
%632 = lshr i16 %631, 1
%633 = trunc i16 %632 to i8
%634 = getelementptr inbounds i8, i8* %540, i64 %620
store i8 %633, i8* %634
%635 = or i64 %620, 1
br label %636
636: ; preds = %622, %619
%637 = phi i64 [ %620, %619 ], [ %635, %622 ]
%638 = icmp eq i64 %621, %388
br i1 %638, label %668, label %639
639: ; preds = %636, %639
%640 = phi i64 [ %666, %639 ], [ %637, %636 ]
%641 = getelementptr inbounds i8, i8* %541, i64 %640
%642 = load i8, i8* %641
%643 = zext i8 %642 to i16
%644 = add nsw i64 %640, %369
%645 = getelementptr inbounds i8, i8* %541, i64 %644
%646 = load i8, i8* %645
%647 = zext i8 %646 to i16
%648 = add nuw nsw i16 %643, 1
%649 = add nuw nsw i16 %648, %647
%650 = lshr i16 %649, 1
%651 = trunc i16 %650 to i8
%652 = getelementptr inbounds i8, i8* %540, i64 %640
store i8 %651, i8* %652
%653 = add nuw nsw i64 %640, 1
%654 = getelementptr inbounds i8, i8* %541, i64 %653
%655 = load i8, i8* %654
%656 = zext i8 %655 to i16
%657 = add nsw i64 %653, %369
%658 = getelementptr inbounds i8, i8* %541, i64 %657
%659 = load i8, i8* %658
%660 = zext i8 %659 to i16
%661 = add nuw nsw i16 %656, 1
%662 = add nuw nsw i16 %661, %660
%663 = lshr i16 %662, 1
%664 = trunc i16 %663 to i8
%665 = getelementptr inbounds i8, i8* %540, i64 %653
store i8 %664, i8* %665
%666 = add nuw nsw i64 %640, 2
%667 = icmp eq i64 %666, %370
br i1 %667, label %668, label %639
668: ; preds = %636, %639, %595, %618, %538
%669 = getelementptr inbounds i8, i8* %541, i64 %369
%670 = getelementptr inbounds i8, i8* %540, i64 %369
%671 = add nuw nsw i32 %542, 1
%672 = icmp eq i32 %671, %4
%673 = add i64 %539, 1
br i1 %672, label %1294, label %538
674: ; preds = %336
%675 = or i1 %338, %26
%676 = icmp eq i32 %9, 0
%677 = icmp sgt i32 %4, 0
br i1 %675, label %984, label %678
678: ; preds = %674
br i1 %676, label %700, label %679
679: ; preds = %678
br i1 %677, label %680, label %1294
680: ; preds = %679
%681 = icmp sgt i32 %3, 0
%682 = sext i32 %2 to i64
%683 = zext i32 %3 to i64
%684 = add nsw i64 %24, %22
%685 = add nsw i64 %684, %683
%686 = add nsw i64 %16, %19
%687 = add nsw i64 %686, %683
%688 = add nsw i64 %687, 1
%689 = icmp ult i32 %3, 8
%690 = icmp ult i32 %3, 16
%691 = and i64 %683, 4294967280
%692 = icmp eq i64 %691, %683
%693 = and i64 %683, 8
%694 = icmp eq i64 %693, 0
%695 = and i64 %683, 4294967288
%696 = icmp eq i64 %695, %683
%697 = and i64 %683, 1
%698 = icmp eq i64 %697, 0
%699 = sub nsw i64 0, %683
br label %721
700: ; preds = %678
br i1 %677, label %701, label %1294
701: ; preds = %700
%702 = icmp sgt i32 %3, 0
%703 = sext i32 %2 to i64
%704 = zext i32 %3 to i64
%705 = add nsw i64 %24, %22
%706 = add nsw i64 %705, %704
%707 = add nsw i64 %16, %19
%708 = add nsw i64 %707, %704
%709 = add nsw i64 %708, 1
%710 = icmp ult i32 %3, 8
%711 = icmp ult i32 %3, 32
%712 = and i64 %704, 4294967264
%713 = icmp eq i64 %712, %704
%714 = and i64 %704, 24
%715 = icmp eq i64 %714, 0
%716 = and i64 %704, 4294967288
%717 = icmp eq i64 %716, %704
%718 = and i64 %704, 1
%719 = icmp eq i64 %718, 0
%720 = sub nsw i64 0, %704
br label %859
721: ; preds = %680, %853
%722 = phi i64 [ 0, %680 ], [ %858, %853 ]
%723 = phi i8* [ %25, %680 ], [ %855, %853 ]
%724 = phi i8* [ %20, %680 ], [ %854, %853 ]
%725 = phi i32 [ 0, %680 ], [ %856, %853 ]
%726 = mul i64 %722, %682
%727 = add i64 %685, %726
%728 = getelementptr i8, i8* %1, i64 %727
%729 = add i64 %688, %726
%730 = getelementptr i8, i8* %0, i64 %729
br i1 %681, label %731, label %853
731: ; preds = %721
br i1 %689, label %792, label %732
732: ; preds = %731
%733 = icmp ult i8* %723, %730
%734 = icmp ult i8* %724, %728
%735 = and i1 %733, %734
br i1 %735, label %792, label %736
736: ; preds = %732
br i1 %690, label %764, label %737
737: ; preds = %736, %737
%738 = phi i64 [ %760, %737 ], [ 0, %736 ]
%739 = getelementptr inbounds i8, i8* %723, i64 %738
%740 = bitcast i8* %739 to <16 x i8>*
%741 = load <16 x i8>, <16 x i8>* %740
%742 = zext <16 x i8> %741 to <16 x i16>
%743 = getelementptr inbounds i8, i8* %724, i64 %738
%744 = bitcast i8* %743 to <16 x i8>*
%745 = load <16 x i8>, <16 x i8>* %744
%746 = zext <16 x i8> %745 to <16 x i16>
%747 = or i64 %738, 1
%748 = getelementptr inbounds i8, i8* %724, i64 %747
%749 = bitcast i8* %748 to <16 x i8>*
%750 = load <16 x i8>, <16 x i8>* %749
%751 = zext <16 x i8> %750 to <16 x i16>
%752 = add nuw nsw <16 x i16> %746, <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
%753 = add nuw nsw <16 x i16> %752, %751
%754 = lshr <16 x i16> %753, <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
%755 = add nuw nsw <16 x i16> %742, <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
%756 = add nuw nsw <16 x i16> %755, %754
%757 = lshr <16 x i16> %756, <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
%758 = trunc <16 x i16> %757 to <16 x i8>
%759 = bitcast i8* %739 to <16 x i8>*
store <16 x i8> %758, <16 x i8>* %759
%760 = add nuw i64 %738, 16
%761 = icmp eq i64 %760, %691
br i1 %761, label %762, label %737
762: ; preds = %737
br i1 %692, label %853, label %763
763: ; preds = %762
br i1 %694, label %792, label %764
764: ; preds = %736, %763
%765 = phi i64 [ %691, %763 ], [ 0, %736 ]
br label %766
766: ; preds = %766, %764
%767 = phi i64 [ %765, %764 ], [ %789, %766 ]
%768 = getelementptr inbounds i8, i8* %723, i64 %767
%769 = bitcast i8* %768 to <8 x i8>*
%770 = load <8 x i8>, <8 x i8>* %769
%771 = zext <8 x i8> %770 to <8 x i16>
%772 = getelementptr inbounds i8, i8* %724, i64 %767
%773 = bitcast i8* %772 to <8 x i8>*
%774 = load <8 x i8>, <8 x i8>* %773
%775 = zext <8 x i8> %774 to <8 x i16>
%776 = or i64 %767, 1
%777 = getelementptr inbounds i8, i8* %724, i64 %776
%778 = bitcast i8* %777 to <8 x i8>*
%779 = load <8 x i8>, <8 x i8>* %778
%780 = zext <8 x i8> %779 to <8 x i16>
%781 = add nuw nsw <8 x i16> %775, <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
%782 = add nuw nsw <8 x i16> %781, %780
%783 = lshr <8 x i16> %782, <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
%784 = add nuw nsw <8 x i16> %771, <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
%785 = add nuw nsw <8 x i16> %784, %783
%786 = lshr <8 x i16> %785, <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
%787 = trunc <8 x i16> %786 to <8 x i8>
%788 = bitcast i8* %768 to <8 x i8>*
store <8 x i8> %787, <8 x i8>* %788
%789 = add nuw i64 %767, 8
%790 = icmp eq i64 %789, %695
br i1 %790, label %791, label %766
791: ; preds = %766
br i1 %696, label %853, label %792
792: ; preds = %732, %731, %763, %791
%793 = phi i64 [ 0, %731 ], [ 0, %732 ], [ %691, %763 ], [ %695, %791 ]
%794 = xor i64 %793, -1
br i1 %698, label %813, label %795
795: ; preds = %792
%796 = getelementptr inbounds i8, i8* %723, i64 %793
%797 = load i8, i8* %796
%798 = zext i8 %797 to i16
%799 = getelementptr inbounds i8, i8* %724, i64 %793
%800 = load i8, i8* %799
%801 = zext i8 %800 to i16
%802 = or i64 %793, 1
%803 = getelementptr inbounds i8, i8* %724, i64 %802
%804 = load i8, i8* %803
%805 = zext i8 %804 to i16
%806 = add nuw nsw i16 %801, 1
%807 = add nuw nsw i16 %806, %805
%808 = lshr i16 %807, 1
%809 = add nuw nsw i16 %798, 1
%810 = add nuw nsw i16 %809, %808
%811 = lshr i16 %810, 1
%812 = trunc i16 %811 to i8
store i8 %812, i8* %796
br label %813
813: ; preds = %795, %792
%814 = phi i64 [ %793, %792 ], [ %802, %795 ]
%815 = icmp eq i64 %794, %699
br i1 %815, label %853, label %816
816: ; preds = %813, %816
%817 = phi i64 [ %841, %816 ], [ %814, %813 ]
%818 = getelementptr inbounds i8, i8* %723, i64 %817
%819 = load i8, i8* %818
%820 = zext i8 %819 to i16
%821 = getelementptr inbounds i8, i8* %724, i64 %817
%822 = load i8, i8* %821
%823 = zext i8 %822 to i16
%824 = add nuw nsw i64 %817, 1
%825 = getelementptr inbounds i8, i8* %724, i64 %824
%826 = load i8, i8* %825
%827 = zext i8 %826 to i16
%828 = add nuw nsw i16 %823, 1
%829 = add nuw nsw i16 %828, %827
%830 = lshr i16 %829, 1
%831 = add nuw nsw i16 %820, 1
%832 = add nuw nsw i16 %831, %830
%833 = lshr i16 %832, 1
%834 = trunc i16 %833 to i8
store i8 %834, i8* %818
%835 = getelementptr inbounds i8, i8* %723, i64 %824
%836 = load i8, i8* %835
%837 = zext i8 %836 to i16
%838 = getelementptr inbounds i8, i8* %724, i64 %824
%839 = load i8, i8* %838
%840 = zext i8 %839 to i16
%841 = add nuw nsw i64 %817, 2
%842 = getelementptr inbounds i8, i8* %724, i64 %841
%843 = load i8, i8* %842
%844 = zext i8 %843 to i16
%845 = add nuw nsw i16 %840, 1
%846 = add nuw nsw i16 %845, %844
%847 = lshr i16 %846, 1
%848 = add nuw nsw i16 %837, 1
%849 = add nuw nsw i16 %848, %847
%850 = lshr i16 %849, 1
%851 = trunc i16 %850 to i8
store i8 %851, i8* %835
%852 = icmp eq i64 %841, %683
br i1 %852, label %853, label %816
853: ; preds = %813, %816, %762, %791, %721
%854 = getelementptr inbounds i8, i8* %724, i64 %682
%855 = getelementptr inbounds i8, i8* %723, i64 %682
%856 = add nuw nsw i32 %725, 1
%857 = icmp eq i32 %856, %4
%858 = add i64 %722, 1
br i1 %857, label %1294, label %721
859: ; preds = %701, %978
%860 = phi i64 [ 0, %701 ], [ %983, %978 ]
%861 = phi i8* [ %25, %701 ], [ %980, %978 ]
%862 = phi i8* [ %20, %701 ], [ %979, %978 ]
%863 = phi i32 [ 0, %701 ], [ %981, %978 ]
%864 = mul i64 %860, %703
%865 = add i64 %706, %864
%866 = getelementptr i8, i8* %1, i64 %865
%867 = add i64 %709, %864
%868 = getelementptr i8, i8* %0, i64 %867
br i1 %702, label %869, label %978
869: ; preds = %859
br i1 %710, label %932, label %870
870: ; preds = %869
%871 = icmp ult i8* %861, %868
%872 = icmp ult i8* %862, %866
%873 = and i1 %871, %872
br i1 %873, label %932, label %874
874: ; preds = %870
br i1 %711, label %910, label %875
875: ; preds = %874, %875
%876 = phi i64 [ %906, %875 ], [ 0, %874 ]
%877 = getelementptr inbounds i8, i8* %862, i64 %876
%878 = bitcast i8* %877 to <16 x i8>*
%879 = load <16 x i8>, <16 x i8>* %878
%880 = getelementptr inbounds i8, i8* %877, i64 16
%881 = bitcast i8* %880 to <16 x i8>*
%882 = load <16 x i8>, <16 x i8>* %881
%883 = zext <16 x i8> %879 to <16 x i16>
%884 = zext <16 x i8> %882 to <16 x i16>
%885 = or i64 %876, 1
%886 = getelementptr inbounds i8, i8* %862, i64 %885
%887 = bitcast i8* %886 to <16 x i8>*
%888 = load <16 x i8>, <16 x i8>* %887
%889 = getelementptr inbounds i8, i8* %886, i64 16
%890 = bitcast i8* %889 to <16 x i8>*
%891 = load <16 x i8>, <16 x i8>* %890
%892 = zext <16 x i8> %888 to <16 x i16>
%893 = zext <16 x i8> %891 to <16 x i16>
%894 = add nuw nsw <16 x i16> %883, <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
%895 = add nuw nsw <16 x i16> %884, <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
%896 = add nuw nsw <16 x i16> %894, %892
%897 = add nuw nsw <16 x i16> %895, %893
%898 = lshr <16 x i16> %896, <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
%899 = lshr <16 x i16> %897, <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
%900 = trunc <16 x i16> %898 to <16 x i8>
%901 = trunc <16 x i16> %899 to <16 x i8>
%902 = getelementptr inbounds i8, i8* %861, i64 %876
%903 = bitcast i8* %902 to <16 x i8>*
store <16 x i8> %900, <16 x i8>* %903
%904 = getelementptr inbounds i8, i8* %902, i64 16
%905 = bitcast i8* %904 to <16 x i8>*
store <16 x i8> %901, <16 x i8>* %905
%906 = add nuw i64 %876, 32
%907 = icmp eq i64 %906, %712
br i1 %907, label %908, label %875
908: ; preds = %875
br i1 %713, label %978, label %909
909: ; preds = %908
br i1 %715, label %932, label %910
910: ; preds = %874, %909
%911 = phi i64 [ %712, %909 ], [ 0, %874 ]
br label %912
912: ; preds = %912, %910
%913 = phi i64 [ %911, %910 ], [ %929, %912 ]
%914 = getelementptr inbounds i8, i8* %862, i64 %913
%915 = bitcast i8* %914 to <8 x i8>*
%916 = load <8 x i8>, <8 x i8>* %915
%917 = zext <8 x i8> %916 to <8 x i16>
%918 = or i64 %913, 1
%919 = getelementptr inbounds i8, i8* %862, i64 %918
%920 = bitcast i8* %919 to <8 x i8>*
%921 = load <8 x i8>, <8 x i8>* %920
%922 = zext <8 x i8> %921 to <8 x i16>
%923 = add nuw nsw <8 x i16> %917, <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
%924 = add nuw nsw <8 x i16> %923, %922
%925 = lshr <8 x i16> %924, <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
%926 = trunc <8 x i16> %925 to <8 x i8>
%927 = getelementptr inbounds i8, i8* %861, i64 %913
%928 = bitcast i8* %927 to <8 x i8>*
store <8 x i8> %926, <8 x i8>* %928
%929 = add nuw i64 %913, 8
%930 = icmp eq i64 %929, %716
br i1 %930, label %931, label %912
931: ; preds = %912
br i1 %717, label %978, label %932
932: ; preds = %870, %869, %909, %931
%933 = phi i64 [ 0, %869 ], [ 0, %870 ], [ %712, %909 ], [ %716, %931 ]
%934 = xor i64 %933, -1
br i1 %719, label %948, label %935
935: ; preds = %932
%936 = getelementptr inbounds i8, i8* %862, i64 %933
%937 = load i8, i8* %936
%938 = zext i8 %937 to i16
%939 = or i64 %933, 1
%940 = getelementptr inbounds i8, i8* %862, i64 %939
%941 = load i8, i8* %940
%942 = zext i8 %941 to i16
%943 = add nuw nsw i16 %938, 1
%944 = add nuw nsw i16 %943, %942
%945 = lshr i16 %944, 1
%946 = trunc i16 %945 to i8
%947 = getelementptr inbounds i8, i8* %861, i64 %933
store i8 %946, i8* %947
br label %948
948: ; preds = %935, %932
%949 = phi i64 [ %933, %932 ], [ %939, %935 ]
%950 = icmp eq i64 %934, %720
br i1 %950, label %978, label %951
951: ; preds = %948, %951
%952 = phi i64 [ %968, %951 ], [ %949, %948 ]
%953 = getelementptr inbounds i8, i8* %862, i64 %952
%954 = load i8, i8* %953
%955 = zext i8 %954 to i16
%956 = add nuw nsw i64 %952, 1
%957 = getelementptr inbounds i8, i8* %862, i64 %956
%958 = load i8, i8* %957
%959 = zext i8 %958 to i16
%960 = add nuw nsw i16 %955, 1
%961 = add nuw nsw i16 %960, %959
%962 = lshr i16 %961, 1
%963 = trunc i16 %962 to i8
%964 = getelementptr inbounds i8, i8* %861, i64 %952
store i8 %963, i8* %964
%965 = getelementptr inbounds i8, i8* %862, i64 %956
%966 = load i8, i8* %965
%967 = zext i8 %966 to i16
%968 = add nuw nsw i64 %952, 2
%969 = getelementptr inbounds i8, i8* %862, i64 %968
%970 = load i8, i8* %969
%971 = zext i8 %970 to i16
%972 = add nuw nsw i16 %967, 1
%973 = add nuw nsw i16 %972, %971
%974 = lshr i16 %973, 1
%975 = trunc i16 %974 to i8
%976 = getelementptr inbounds i8, i8* %861, i64 %956
store i8 %975, i8* %976
%977 = icmp eq i64 %968, %704
br i1 %977, label %978, label %951
978: ; preds = %948, %951, %908, %931, %859
%979 = getelementptr inbounds i8, i8* %862, i64 %703
%980 = getelementptr inbounds i8, i8* %861, i64 %703
%981 = add nuw nsw i32 %863, 1
%982 = icmp eq i32 %981, %4
%983 = add i64 %860, 1
br i1 %982, label %1294, label %859
984: ; preds = %674
br i1 %676, label %1007, label %985
985: ; preds = %984
br i1 %677, label %986, label %1294
986: ; preds = %985
%987 = icmp sgt i32 %3, 0
%988 = sext i32 %2 to i64
%989 = zext i32 %3 to i64
%990 = add nsw i64 %24, %22
%991 = add nsw i64 %990, %989
%992 = add nsw i64 %988, %16
%993 = add nsw i64 %992, %19
%994 = add nsw i64 %993, %989
%995 = add nsw i64 %994, 1
%996 = add nsw i64 %16, %19
%997 = add nsw i64 %996, %989
%998 = add nsw i64 %997, 1
%999 = icmp ult i32 %3, 8
%1000 = icmp ult i32 %3, 16
%1001 = and i64 %989, 4294967280
%1002 = icmp eq i64 %1001, %989
%1003 = and i64 %989, 8
%1004 = icmp eq i64 %1003, 0
%1005 = and i64 %989, 4294967288
%1006 = icmp eq i64 %1005, %989
br label %1029
1007: ; preds = %984
br i1 %677, label %1008, label %1294
1008: ; preds = %1007
%1009 = icmp sgt i32 %3, 0
%1010 = sext i32 %2 to i64
%1011 = zext i32 %3 to i64
%1012 = add nsw i64 %24, %22
%1013 = add nsw i64 %1012, %1011
%1014 = add nsw i64 %1010, %16
%1015 = add nsw i64 %1014, %19
%1016 = add nsw i64 %1015, %1011
%1017 = add nsw i64 %1016, 1
%1018 = add nsw i64 %16, %19
%1019 = add nsw i64 %1018, %1011
%1020 = add nsw i64 %1019, 1
%1021 = icmp ult i32 %3, 8
%1022 = icmp ult i32 %3, 16
%1023 = and i64 %1011, 4294967280
%1024 = icmp eq i64 %1023, %1011
%1025 = and i64 %1011, 8
%1026 = icmp eq i64 %1025, 0
%1027 = and i64 %1011, 4294967288
%1028 = icmp eq i64 %1027, %1011
br label %1170
1029: ; preds = %986, %1164
%1030 = phi i64 [ 0, %986 ], [ %1169, %1164 ]
%1031 = phi i8* [ %25, %986 ], [ %1166, %1164 ]
%1032 = phi i8* [ %20, %986 ], [ %1165, %1164 ]
%1033 = phi i32 [ 0, %986 ], [ %1167, %1164 ]
%1034 = mul i64 %1030, %988
%1035 = add i64 %991, %1034
%1036 = getelementptr i8, i8* %1, i64 %1035
%1037 = add i64 %993, %1034
%1038 = getelementptr i8, i8* %0, i64 %1037
%1039 = add i64 %995, %1034
%1040 = getelementptr i8, i8* %0, i64 %1039
%1041 = add i64 %998, %1034
%1042 = getelementptr i8, i8* %0, i64 %1041
br i1 %987, label %1043, label %1164
1043: ; preds = %1029
br i1 %999, label %1132, label %1044
1044: ; preds = %1043
%1045 = icmp ult i8* %1031, %1040
%1046 = icmp ult i8* %1038, %1036
%1047 = and i1 %1045, %1046
%1048 = icmp ult i8* %1031, %1042
%1049 = icmp ult i8* %1032, %1036
%1050 = and i1 %1048, %1049
%1051 = or i1 %1047, %1050
br i1 %1051, label %1132, label %1052
1052: ; preds = %1044
br i1 %1000, label %1092, label %1053
1053: ; preds = %1052, %1053
%1054 = phi i64 [ %1088, %1053 ], [ 0, %1052 ]
%1055 = getelementptr inbounds i8, i8* %1031, i64 %1054
%1056 = bitcast i8* %1055 to <16 x i8>*
%1057 = load <16 x i8>, <16 x i8>* %1056
%1058 = zext <16 x i8> %1057 to <16 x i32>
%1059 = getelementptr inbounds i8, i8* %1032, i64 %1054
%1060 = bitcast i8* %1059 to <16 x i8>*
%1061 = load <16 x i8>, <16 x i8>* %1060
%1062 = zext <16 x i8> %1061 to <16 x i32>
%1063 = or i64 %1054, 1
%1064 = getelementptr inbounds i8, i8* %1032, i64 %1063
%1065 = bitcast i8* %1064 to <16 x i8>*
%1066 = load <16 x i8>, <16 x i8>* %1065
%1067 = zext <16 x i8> %1066 to <16 x i32>
%1068 = add nsw i64 %1054, %988
%1069 = getelementptr inbounds i8, i8* %1032, i64 %1068
%1070 = bitcast i8* %1069 to <16 x i8>*
%1071 = load <16 x i8>, <16 x i8>* %1070
%1072 = zext <16 x i8> %1071 to <16 x i32>
%1073 = add nsw i64 %1068, 1
%1074 = getelementptr inbounds i8, i8* %1032, i64 %1073
%1075 = bitcast i8* %1074 to <16 x i8>*
%1076 = load <16 x i8>, <16 x i8>* %1075
%1077 = zext <16 x i8> %1076 to <16 x i32>
%1078 = add nuw nsw <16 x i32> %1062, <i32 2, i32 2, i32 2, i32 2, i32 2, i32 2, i32 2, i32 2, i32 2, i32 2, i32 2, i32 2, i32 2, i32 2, i32 2, i32 2>
%1079 = add nuw nsw <16 x i32> %1078, %1067
%1080 = add nuw nsw <16 x i32> %1079, %1072
%1081 = add nuw nsw <16 x i32> %1080, %1077
%1082 = lshr <16 x i32> %1081, <i32 2, i32 2, i32 2, i32 2, i32 2, i32 2, i32 2, i32 2, i32 2, i32 2, i32 2, i32 2, i32 2, i32 2, i32 2, i32 2>
%1083 = add nuw nsw <16 x i32> %1058, <i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1>
%1084 = add nuw nsw <16 x i32> %1083, %1082
%1085 = lshr <16 x i32> %1084, <i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1>
%1086 = trunc <16 x i32> %1085 to <16 x i8>
%1087 = bitcast i8* %1055 to <16 x i8>*
store <16 x i8> %1086, <16 x i8>* %1087
%1088 = add nuw i64 %1054, 16
%1089 = icmp eq i64 %1088, %1001
br i1 %1089, label %1090, label %1053
1090: ; preds = %1053
br i1 %1002, label %1164, label %1091
1091: ; preds = %1090
br i1 %1004, label %1132, label %1092
1092: ; preds = %1052, %1091
%1093 = phi i64 [ %1001, %1091 ], [ 0, %1052 ]
br label %1094
1094: ; preds = %1094, %1092
%1095 = phi i64 [ %1093, %1092 ], [ %1129, %1094 ]
%1096 = getelementptr inbounds i8, i8* %1031, i64 %1095
%1097 = bitcast i8* %1096 to <8 x i8>*
%1098 = load <8 x i8>, <8 x i8>* %1097
%1099 = zext <8 x i8> %1098 to <8 x i32>
%1100 = getelementptr inbounds i8, i8* %1032, i64 %1095
%1101 = bitcast i8* %1100 to <8 x i8>*
%1102 = load <8 x i8>, <8 x i8>* %1101
%1103 = zext <8 x i8> %1102 to <8 x i32>
%1104 = or i64 %1095, 1
%1105 = getelementptr inbounds i8, i8* %1032, i64 %1104
%1106 = bitcast i8* %1105 to <8 x i8>*
%1107 = load <8 x i8>, <8 x i8>* %1106
%1108 = zext <8 x i8> %1107 to <8 x i32>
%1109 = add nsw i64 %1095, %988
%1110 = getelementptr inbounds i8, i8* %1032, i64 %1109
%1111 = bitcast i8* %1110 to <8 x i8>*
%1112 = load <8 x i8>, <8 x i8>* %1111
%1113 = zext <8 x i8> %1112 to <8 x i32>
%1114 = add nsw i64 %1109, 1
%1115 = getelementptr inbounds i8, i8* %1032, i64 %1114
%1116 = bitcast i8* %1115 to <8 x i8>*
%1117 = load <8 x i8>, <8 x i8>* %1116
%1118 = zext <8 x i8> %1117 to <8 x i32>
%1119 = add nuw nsw <8 x i32> %1103, <i32 2, i32 2, i32 2, i32 2, i32 2, i32 2, i32 2, i32 2>
%1120 = add nuw nsw <8 x i32> %1119, %1108
%1121 = add nuw nsw <8 x i32> %1120, %1113
%1122 = add nuw nsw <8 x i32> %1121, %1118
%1123 = lshr <8 x i32> %1122, <i32 2, i32 2, i32 2, i32 2, i32 2, i32 2, i32 2, i32 2>
%1124 = add nuw nsw <8 x i32> %1099, <i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1>
%1125 = add nuw nsw <8 x i32> %1124, %1123
%1126 = lshr <8 x i32> %1125, <i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1>
%1127 = trunc <8 x i32> %1126 to <8 x i8>
%1128 = bitcast i8* %1096 to <8 x i8>*
store <8 x i8> %1127, <8 x i8>* %1128
%1129 = add nuw i64 %1095, 8
%1130 = icmp eq i64 %1129, %1005
br i1 %1130, label %1131, label %1094
1131: ; preds = %1094
br i1 %1006, label %1164, label %1132
1132: ; preds = %1044, %1043, %1091, %1131
%1133 = phi i64 [ 0, %1043 ], [ 0, %1044 ], [ %1001, %1091 ], [ %1005, %1131 ]
br label %1134
1134: ; preds = %1132, %1134
%1135 = phi i64 [ %1142, %1134 ], [ %1133, %1132 ]
%1136 = getelementptr inbounds i8, i8* %1031, i64 %1135
%1137 = load i8, i8* %1136
%1138 = zext i8 %1137 to i32
%1139 = getelementptr inbounds i8, i8* %1032, i64 %1135
%1140 = load i8, i8* %1139
%1141 = zext i8 %1140 to i32
%1142 = add nuw nsw i64 %1135, 1
%1143 = getelementptr inbounds i8, i8* %1032, i64 %1142
%1144 = load i8, i8* %1143
%1145 = zext i8 %1144 to i32
%1146 = add nsw i64 %1135, %988
%1147 = getelementptr inbounds i8, i8* %1032, i64 %1146
%1148 = load i8, i8* %1147
%1149 = zext i8 %1148 to i32
%1150 = add nsw i64 %1146, 1
%1151 = getelementptr inbounds i8, i8* %1032, i64 %1150
%1152 = load i8, i8* %1151
%1153 = zext i8 %1152 to i32
%1154 = add nuw nsw i32 %1141, 2
%1155 = add nuw nsw i32 %1154, %1145
%1156 = add nuw nsw i32 %1155, %1149
%1157 = add nuw nsw i32 %1156, %1153
%1158 = lshr i32 %1157, 2
%1159 = add nuw nsw i32 %1138, 1
%1160 = add nuw nsw i32 %1159, %1158
%1161 = lshr i32 %1160, 1
%1162 = trunc i32 %1161 to i8
store i8 %1162, i8* %1136
%1163 = icmp eq i64 %1142, %989
br i1 %1163, label %1164, label %1134
1164: ; preds = %1134, %1090, %1131, %1029
%1165 = getelementptr inbounds i8, i8* %1032, i64 %988
%1166 = getelementptr inbounds i8, i8* %1031, i64 %988
%1167 = add nuw nsw i32 %1033, 1
%1168 = icmp eq i32 %1167, %4
%1169 = add i64 %1030, 1
br i1 %1168, label %1294, label %1029
1170: ; preds = %1008, %1288
%1171 = phi i64 [ 0, %1008 ], [ %1293, %1288 ]
%1172 = phi i8* [ %25, %1008 ], [ %1290, %1288 ]
%1173 = phi i8* [ %20, %1008 ], [ %1289, %1288 ]
%1174 = phi i32 [ 0, %1008 ], [ %1291, %1288 ]
%1175 = mul i64 %1171, %1010
%1176 = add i64 %1013, %1175
%1177 = getelementptr i8, i8* %1, i64 %1176
%1178 = add i64 %1015, %1175
%1179 = getelementptr i8, i8* %0, i64 %1178
%1180 = add i64 %1017, %1175
%1181 = getelementptr i8, i8* %0, i64 %1180
%1182 = add i64 %1020, %1175
%1183 = getelementptr i8, i8* %0, i64 %1182
br i1 %1009, label %1184, label %1288
1184: ; preds = %1170
br i1 %1021, label %1261, label %1185
1185: ; preds = %1184
%1186 = icmp ult i8* %1172, %1181
%1187 = icmp ult i8* %1179, %1177
%1188 = and i1 %1186, %1187
%1189 = icmp ult i8* %1172, %1183
%1190 = icmp ult i8* %1173, %1177
%1191 = and i1 %1189, %1190
%1192 = or i1 %1188, %1191
br i1 %1192, label %1261, label %1193
1193: ; preds = %1185
br i1 %1022, label %1227, label %1194
1194: ; preds = %1193, %1194
%1195 = phi i64 [ %1223, %1194 ], [ 0, %1193 ]
%1196 = getelementptr inbounds i8, i8* %1173, i64 %1195
%1197 = bitcast i8* %1196 to <16 x i8>*
%1198 = load <16 x i8>, <16 x i8>* %1197
%1199 = zext <16 x i8> %1198 to <16 x i16>
%1200 = or i64 %1195, 1
%1201 = getelementptr inbounds i8, i8* %1173, i64 %1200
%1202 = bitcast i8* %1201 to <16 x i8>*
%1203 = load <16 x i8>, <16 x i8>* %1202
%1204 = zext <16 x i8> %1203 to <16 x i16>
%1205 = add nsw i64 %1195, %1010
%1206 = getelementptr inbounds i8, i8* %1173, i64 %1205
%1207 = bitcast i8* %1206 to <16 x i8>*
%1208 = load <16 x i8>, <16 x i8>* %1207
%1209 = zext <16 x i8> %1208 to <16 x i16>
%1210 = add nsw i64 %1205, 1
%1211 = getelementptr inbounds i8, i8* %1173, i64 %1210
%1212 = bitcast i8* %1211 to <16 x i8>*
%1213 = load <16 x i8>, <16 x i8>* %1212
%1214 = zext <16 x i8> %1213 to <16 x i16>
%1215 = add nuw nsw <16 x i16> %1199, <i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2>
%1216 = add nuw nsw <16 x i16> %1215, %1204
%1217 = add nuw nsw <16 x i16> %1216, %1209
%1218 = add nuw nsw <16 x i16> %1217, %1214
%1219 = lshr <16 x i16> %1218, <i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2>
%1220 = trunc <16 x i16> %1219 to <16 x i8>
%1221 = getelementptr inbounds i8, i8* %1172, i64 %1195
%1222 = bitcast i8* %1221 to <16 x i8>*
store <16 x i8> %1220, <16 x i8>* %1222
%1223 = add nuw i64 %1195, 16
%1224 = icmp eq i64 %1223, %1023
br i1 %1224, label %1225, label %1194
1225: ; preds = %1194
br i1 %1024, label %1288, label %1226
1226: ; preds = %1225
br i1 %1026, label %1261, label %1227
1227: ; preds = %1193, %1226
%1228 = phi i64 [ %1023, %1226 ], [ 0, %1193 ]
br label %1229
1229: ; preds = %1229, %1227
%1230 = phi i64 [ %1228, %1227 ], [ %1258, %1229 ]
%1231 = getelementptr inbounds i8, i8* %1173, i64 %1230
%1232 = bitcast i8* %1231 to <8 x i8>*
%1233 = load <8 x i8>, <8 x i8>* %1232
%1234 = zext <8 x i8> %1233 to <8 x i16>
%1235 = or i64 %1230, 1
%1236 = getelementptr inbounds i8, i8* %1173, i64 %1235
%1237 = bitcast i8* %1236 to <8 x i8>*
%1238 = load <8 x i8>, <8 x i8>* %1237
%1239 = zext <8 x i8> %1238 to <8 x i16>
%1240 = add nsw i64 %1230, %1010
%1241 = getelementptr inbounds i8, i8* %1173, i64 %1240
%1242 = bitcast i8* %1241 to <8 x i8>*
%1243 = load <8 x i8>, <8 x i8>* %1242
%1244 = zext <8 x i8> %1243 to <8 x i16>
%1245 = add nsw i64 %1240, 1
%1246 = getelementptr inbounds i8, i8* %1173, i64 %1245
%1247 = bitcast i8* %1246 to <8 x i8>*
%1248 = load <8 x i8>, <8 x i8>* %1247
%1249 = zext <8 x i8> %1248 to <8 x i16>
%1250 = add nuw nsw <8 x i16> %1234, <i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2>
%1251 = add nuw nsw <8 x i16> %1250, %1239
%1252 = add nuw nsw <8 x i16> %1251, %1244
%1253 = add nuw nsw <8 x i16> %1252, %1249
%1254 = lshr <8 x i16> %1253, <i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2>
%1255 = trunc <8 x i16> %1254 to <8 x i8>
%1256 = getelementptr inbounds i8, i8* %1172, i64 %1230
%1257 = bitcast i8* %1256 to <8 x i8>*
store <8 x i8> %1255, <8 x i8>* %1257
%1258 = add nuw i64 %1230, 8
%1259 = icmp eq i64 %1258, %1027
br i1 %1259, label %1260, label %1229
1260: ; preds = %1229
br i1 %1028, label %1288, label %1261
1261: ; preds = %1185, %1184, %1226, %1260
%1262 = phi i64 [ 0, %1184 ], [ 0, %1185 ], [ %1023, %1226 ], [ %1027, %1260 ]
br label %1263
1263: ; preds = %1261, %1263
%1264 = phi i64 [ %1268, %1263 ], [ %1262, %1261 ]
%1265 = getelementptr inbounds i8, i8* %1173, i64 %1264
%1266 = load i8, i8* %1265
%1267 = zext i8 %1266 to i16
%1268 = add nuw nsw i64 %1264, 1
%1269 = getelementptr inbounds i8, i8* %1173, i64 %1268
%1270 = load i8, i8* %1269
%1271 = zext i8 %1270 to i16
%1272 = add nsw i64 %1264, %1010
%1273 = getelementptr inbounds i8, i8* %1173, i64 %1272
%1274 = load i8, i8* %1273
%1275 = zext i8 %1274 to i16
%1276 = add nsw i64 %1272, 1
%1277 = getelementptr inbounds i8, i8* %1173, i64 %1276
%1278 = load i8, i8* %1277
%1279 = zext i8 %1278 to i16
%1280 = add nuw nsw i16 %1267, 2
%1281 = add nuw nsw i16 %1280, %1271
%1282 = add nuw nsw i16 %1281, %1275
%1283 = add nuw nsw i16 %1282, %1279
%1284 = lshr i16 %1283, 2
%1285 = trunc i16 %1284 to i8
%1286 = getelementptr inbounds i8, i8* %1172, i64 %1264
store i8 %1285, i8* %1286
%1287 = icmp eq i64 %1268, %1011
br i1 %1287, label %1288, label %1263
1288: ; preds = %1263, %1225, %1260, %1170
%1289 = getelementptr inbounds i8, i8* %1173, i64 %1010
%1290 = getelementptr inbounds i8, i8* %1172, i64 %1010
%1291 = add nuw nsw i32 %1174, 1
%1292 = icmp eq i32 %1291, %4
%1293 = add i64 %1171, 1
br i1 %1292, label %1294, label %1170
1294: ; preds = %853, %978, %1164, %1288, %532, %668, %191, %330, %679, %700, %985, %1007, %343, %366, %33, %53
ret void
}