#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ assert(_Bool);
void form_component_prediction(unsigned char *src, unsigned char *dst,
                               signed int lx, signed int lx2, signed int w,
                               signed int h, signed int x, signed int y,
                               signed int dx, signed int dy,
                               signed int average_flag) {
  signed int xint;
  signed int yint;
  signed int xh;
  signed int yh;
  signed int i;
  signed int j;
  signed int v;
  unsigned char *s;
  unsigned char *d;
  xint = dx >> 1;
  yint = dy >> 1;
  s = src + (signed long int)(lx * (y + yint)) + (signed long int)x +
      (signed long int)xint;
  d = dst + (signed long int)(lx * y) + (signed long int)x;
  xh = dx & 1;
  yh = dy & 1;
  if (!(s == d))
    (void)0;
  else
    assert((_Bool)0);
  if (xh == 0) {
    if (yh != 0)
      goto __CPROVER_DUMP_L12;
    if (!(average_flag == 0)) {
      j = 0;
      while (!(j >= h)) {
        i = 0;
        while (!(i >= w)) {
          v = (signed int)d[(signed long int)i] +
              (signed int)s[(signed long int)i];
          d[(signed long int)i] = (unsigned char)(v + (v >= 0 ? 1 : 0) >> 1);
          i = i + 1;
        }
        s = s + (signed long int)lx2;
        d = d + (signed long int)lx2;
        j = j + 1;
      }
    } else {
      j = 0;
      while (!(j >= h)) {
        i = 0;
        while (!(i >= w)) {
          d[(signed long int)i] = s[(signed long int)i];
          i = i + 1;
        }
        s = s + (signed long int)lx2;
        d = d + (signed long int)lx2;
        j = j + 1;
      }
    }
  } else {
  __CPROVER_DUMP_L12:;
    if (xh == 0) {
      if (yh == 0)
        goto __CPROVER_DUMP_L22;
      if (!(average_flag == 0)) {
        j = 0;
        while (!(j >= h)) {
          i = 0;
          while (!(i >= w)) {
            v = (signed int)((unsigned int)d[(signed long int)i] +
                             ((unsigned int)((signed int)s[(signed long int)i] +
                                             (signed int)
                                                 s[(signed long int)(i + lx)] +
                                             1) >>
                              1));
            d[(signed long int)i] = (unsigned char)(v + (v >= 0 ? 1 : 0) >> 1);
            i = i + 1;
          }
          s = s + (signed long int)lx2;
          d = d + (signed long int)lx2;
          j = j + 1;
        }
      } else {
        j = 0;
        while (!(j >= h)) {
          i = 0;
          while (!(i >= w)) {
            d[(signed long int)i] =
                (unsigned char)((unsigned int)((signed int)
                                                   s[(signed long int)i] +
                                               (signed int)s[(
                                                   signed long int)(i + lx)] +
                                               1) >>
                                1);
            i = i + 1;
          }
          s = s + (signed long int)lx2;
          d = d + (signed long int)lx2;
          j = j + 1;
        }
      }
    } else {
    __CPROVER_DUMP_L22:;
      if (!(xh == 0)) {
        if (yh != 0)
          goto __CPROVER_DUMP_L32;
        if (!(average_flag == 0)) {
          j = 0;
          while (!(j >= h)) {
            i = 0;
            while (!(i >= w)) {
              v = (signed int)((unsigned int)d[(signed long int)i] +
                               ((unsigned int)((signed int)
                                                   s[(signed long int)i] +
                                               (signed int)
                                                   s[(signed long int)(i + 1)] +
                                               1) >>
                                1));
              d[(signed long int)i] =
                  (unsigned char)(v + (v >= 0 ? 1 : 0) >> 1);
              i = i + 1;
            }
            s = s + (signed long int)lx2;
            d = d + (signed long int)lx2;
            j = j + 1;
          }
        } else {
          j = 0;
          while (!(j >= h)) {
            i = 0;
            while (!(i >= w)) {
              d[(signed long int)i] =
                  (unsigned char)((unsigned int)((signed int)
                                                     s[(signed long int)i] +
                                                 (signed int)s[(
                                                     signed long int)(i + 1)] +
                                                 1) >>
                                  1);
              i = i + 1;
            }
            s = s + (signed long int)lx2;
            d = d + (signed long int)lx2;
            j = j + 1;
          }
        }
      } else {
      __CPROVER_DUMP_L32:;
        if (!(average_flag == 0)) {
          j = 0;
          while (!(j >= h)) {
            i = 0;
            while (!(i >= w)) {
              v = (signed int)((unsigned int)d[(signed long int)i] +
                               ((unsigned int)((signed int)
                                                   s[(signed long int)i] +
                                               (signed int)
                                                   s[(signed long int)(i + 1)] +
                                               (signed int)s[(
                                                   signed long int)(i + lx)] +
                                               (signed int)
                                                   s[(signed long int)(i + lx +
                                                                       1)] +
                                               2) >>
                                2));
              d[(signed long int)i] =
                  (unsigned char)(v + (v >= 0 ? 1 : 0) >> 1);
              i = i + 1;
            }
            s = s + (signed long int)lx2;
            d = d + (signed long int)lx2;
            j = j + 1;
          }
        } else {
          j = 0;
          while (!(j >= h)) {
            i = 0;
            while (!(i >= w)) {
              d[(signed long int)i] =
                  (unsigned char)((unsigned int)((signed int)
                                                     s[(signed long int)i] +
                                                 (signed int)s[(
                                                     signed long int)(i + 1)] +
                                                 (signed int)s[(
                                                     signed long int)(i + lx)] +
                                                 (signed int)s[(
                                                     signed long int)(i + lx +
                                                                      1)] +
                                                 2) >>
                                  2);
              i = i + 1;
            }
            s = s + (signed long int)lx2;
            d = d + (signed long int)lx2;
            j = j + 1;
          }
        }
      }
    }
  }
}


x86 assembly (clang, -O0):
<form_component_prediction>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    0x30(%rbp),%eax
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    0x20(%rbp),%eax
sar    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    0x28(%rbp),%eax
sar    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    0x18(%rbp),%edx
add    -0x28(%rbp),%edx
imul   %edx,%ecx
movslq %ecx,%rcx
add    %rcx,%rax
movslq 0x10(%rbp),%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   0x18(%rbp),%ecx
movslq %ecx,%rcx
add    %rcx,%rax
movslq 0x10(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    0x20(%rbp),%eax
and    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    0x28(%rbp),%eax
and    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x50(%rbp),%rax
je     11b8 <form_component_prediction+0xa8>
jmp    11bf <form_component_prediction+0xaf>
xor    %edi,%edi
call   1030 <assert@plt>
cmpl   $0x0,-0x2c(%rbp)
jne    1339 <form_component_prediction+0x229>
cmpl   $0x0,-0x30(%rbp)
je     11d8 <form_component_prediction+0xc8>
jmp    133e <form_component_prediction+0x22e>
cmpl   $0x0,0x30(%rbp)
je     12a1 <form_component_prediction+0x191>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x20(%rbp),%eax
setge  %al
xor    $0xff,%al
test   $0x1,%al
jne    1201 <form_component_prediction+0xf1>
jmp    129c <form_component_prediction+0x18c>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
setge  %al
xor    $0xff,%al
test   $0x1,%al
jne    1220 <form_component_prediction+0x110>
jmp    1270 <form_component_prediction+0x160>
mov    -0x50(%rbp),%rax
movslq -0x34(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x48(%rbp),%rcx
movslq -0x34(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x3c(%rbp),%esi
xor    %ecx,%ecx
mov    $0x1,%edx
cmp    $0x0,%esi
cmovge %edx,%ecx
add    %ecx,%eax
sar    $0x1,%eax
mov    %al,%dl
mov    -0x50(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1208 <form_component_prediction+0xf8>
mov    -0x48(%rbp),%rax
movslq -0x18(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x50(%rbp),%rax
movslq -0x18(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    11e9 <form_component_prediction+0xd9>
jmp    1334 <form_component_prediction+0x224>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x20(%rbp),%eax
setge  %al
xor    $0xff,%al
test   $0x1,%al
jne    12c0 <form_component_prediction+0x1b0>
jmp    132f <form_component_prediction+0x21f>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
setge  %al
xor    $0xff,%al
test   $0x1,%al
jne    12df <form_component_prediction+0x1cf>
jmp    1303 <form_component_prediction+0x1f3>
mov    -0x48(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x50(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12c7 <form_component_prediction+0x1b7>
mov    -0x48(%rbp),%rax
movslq -0x18(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x50(%rbp),%rax
movslq -0x18(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    12a8 <form_component_prediction+0x198>
jmp    1334 <form_component_prediction+0x224>
jmp    1898 <form_component_prediction+0x788>
jmp    133e <form_component_prediction+0x22e>
cmpl   $0x0,-0x2c(%rbp)
jne    14ed <form_component_prediction+0x3dd>
cmpl   $0x0,-0x30(%rbp)
jne    1357 <form_component_prediction+0x247>
jmp    14f2 <form_component_prediction+0x3e2>
cmpl   $0x0,0x30(%rbp)
je     1439 <form_component_prediction+0x329>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x20(%rbp),%eax
setge  %al
xor    $0xff,%al
test   $0x1,%al
jne    1380 <form_component_prediction+0x270>
jmp    1434 <form_component_prediction+0x324>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
setge  %al
xor    $0xff,%al
test   $0x1,%al
jne    139f <form_component_prediction+0x28f>
jmp    1408 <form_component_prediction+0x2f8>
mov    -0x50(%rbp),%rax
movslq -0x34(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x48(%rbp),%rcx
movslq -0x34(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
mov    -0x48(%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
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x3c(%rbp),%esi
xor    %ecx,%ecx
mov    $0x1,%edx
cmp    $0x0,%esi
cmovge %edx,%ecx
add    %ecx,%eax
sar    $0x1,%eax
mov    %al,%dl
mov    -0x50(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1387 <form_component_prediction+0x277>
mov    -0x48(%rbp),%rax
movslq -0x18(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x50(%rbp),%rax
movslq -0x18(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1368 <form_component_prediction+0x258>
jmp    14e8 <form_component_prediction+0x3d8>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x20(%rbp),%eax
setge  %al
xor    $0xff,%al
test   $0x1,%al
jne    1458 <form_component_prediction+0x348>
jmp    14e3 <form_component_prediction+0x3d3>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
setge  %al
xor    $0xff,%al
test   $0x1,%al
jne    1477 <form_component_prediction+0x367>
jmp    14b7 <form_component_prediction+0x3a7>
mov    -0x48(%rbp),%rax
movslq -0x34(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x48(%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    -0x50(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    145f <form_component_prediction+0x34f>
mov    -0x48(%rbp),%rax
movslq -0x18(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x50(%rbp),%rax
movslq -0x18(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1440 <form_component_prediction+0x330>
jmp    14e8 <form_component_prediction+0x3d8>
jmp    1893 <form_component_prediction+0x783>
jmp    14f2 <form_component_prediction+0x3e2>
cmpl   $0x0,-0x2c(%rbp)
je     16a1 <form_component_prediction+0x591>
cmpl   $0x0,-0x30(%rbp)
je     150b <form_component_prediction+0x3fb>
jmp    16a6 <form_component_prediction+0x596>
cmpl   $0x0,0x30(%rbp)
je     15ed <form_component_prediction+0x4dd>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x20(%rbp),%eax
setge  %al
xor    $0xff,%al
test   $0x1,%al
jne    1534 <form_component_prediction+0x424>
jmp    15e8 <form_component_prediction+0x4d8>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
setge  %al
xor    $0xff,%al
test   $0x1,%al
jne    1553 <form_component_prediction+0x443>
jmp    15bc <form_component_prediction+0x4ac>
mov    -0x50(%rbp),%rax
movslq -0x34(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x48(%rbp),%rcx
movslq -0x34(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
mov    -0x48(%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
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x3c(%rbp),%esi
xor    %ecx,%ecx
mov    $0x1,%edx
cmp    $0x0,%esi
cmovge %edx,%ecx
add    %ecx,%eax
sar    $0x1,%eax
mov    %al,%dl
mov    -0x50(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    153b <form_component_prediction+0x42b>
mov    -0x48(%rbp),%rax
movslq -0x18(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x50(%rbp),%rax
movslq -0x18(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    151c <form_component_prediction+0x40c>
jmp    169c <form_component_prediction+0x58c>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x20(%rbp),%eax
setge  %al
xor    $0xff,%al
test   $0x1,%al
jne    160c <form_component_prediction+0x4fc>
jmp    1697 <form_component_prediction+0x587>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
setge  %al
xor    $0xff,%al
test   $0x1,%al
jne    162b <form_component_prediction+0x51b>
jmp    166b <form_component_prediction+0x55b>
mov    -0x48(%rbp),%rax
movslq -0x34(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x48(%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    -0x50(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1613 <form_component_prediction+0x503>
mov    -0x48(%rbp),%rax
movslq -0x18(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x50(%rbp),%rax
movslq -0x18(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    15f4 <form_component_prediction+0x4e4>
jmp    169c <form_component_prediction+0x58c>
jmp    188e <form_component_prediction+0x77e>
jmp    16a6 <form_component_prediction+0x596>
cmpl   $0x0,0x30(%rbp)
je     17b1 <form_component_prediction+0x6a1>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x20(%rbp),%eax
setge  %al
xor    $0xff,%al
test   $0x1,%al
jne    16cf <form_component_prediction+0x5bf>
jmp    17ac <form_component_prediction+0x69c>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
setge  %al
xor    $0xff,%al
test   $0x1,%al
jne    16ee <form_component_prediction+0x5de>
jmp    1780 <form_component_prediction+0x670>
mov    -0x50(%rbp),%rax
movslq -0x34(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x48(%rbp),%rcx
movslq -0x34(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
mov    -0x48(%rbp),%rdx
mov    -0x34(%rbp),%esi
add    $0x1,%esi
movslq %esi,%rsi
movzbl (%rdx,%rsi,1),%edx
add    %edx,%ecx
mov    -0x48(%rbp),%rdx
mov    -0x34(%rbp),%esi
add    -0x14(%rbp),%esi
movslq %esi,%rsi
movzbl (%rdx,%rsi,1),%edx
add    %edx,%ecx
mov    -0x48(%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
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x3c(%rbp),%esi
xor    %ecx,%ecx
mov    $0x1,%edx
cmp    $0x0,%esi
cmovge %edx,%ecx
add    %ecx,%eax
sar    $0x1,%eax
mov    %al,%dl
mov    -0x50(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    16d6 <form_component_prediction+0x5c6>
mov    -0x48(%rbp),%rax
movslq -0x18(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x50(%rbp),%rax
movslq -0x18(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    16b7 <form_component_prediction+0x5a7>
jmp    1889 <form_component_prediction+0x779>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x20(%rbp),%eax
setge  %al
xor    $0xff,%al
test   $0x1,%al
jne    17d0 <form_component_prediction+0x6c0>
jmp    1884 <form_component_prediction+0x774>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
setge  %al
xor    $0xff,%al
test   $0x1,%al
jne    17ef <form_component_prediction+0x6df>
jmp    1858 <form_component_prediction+0x748>
mov    -0x48(%rbp),%rax
movslq -0x34(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x48(%rbp),%rcx
mov    -0x34(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
mov    -0x48(%rbp),%rcx
mov    -0x34(%rbp),%edx
add    -0x14(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
mov    -0x48(%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    -0x50(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    17d7 <form_component_prediction+0x6c7>
mov    -0x48(%rbp),%rax
movslq -0x18(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x50(%rbp),%rax
movslq -0x18(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    17b8 <form_component_prediction+0x6a8>
jmp    1889 <form_component_prediction+0x779>
jmp    188e <form_component_prediction+0x77e>
jmp    1893 <form_component_prediction+0x783>
jmp    1898 <form_component_prediction+0x788>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<form_component_prediction>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %r9d,0x4(%rsp)
mov    %r8d,(%rsp)
mov    0x98(%rsp),%r12d
mov    0x90(%rsp),%r9d
movslq 0x80(%rsp),%r8
mov    0x88(%rsp),%eax
mov    %r9d,%ebx
sar    %ebx
mov    %r12d,%ebp
sar    %ebp
add    %eax,%ebp
imul   %edx,%ebp
movslq %ebp,%rbp
mov    %rdi,0x18(%rsp)
lea    (%rdi,%rbp,1),%r14
add    %r8,%r14
movslq %ebx,%rdi
mov    %rdi,0x8(%rsp)
add    %rdi,%r14
imul   %edx,%eax
cltq
mov    %rsi,0x28(%rsp)
mov    %rax,0x10(%rsp)
lea    (%rsi,%rax,1),%r15
add    %r8,%r15
cmp    %r15,%r14
jne    11ad <form_component_prediction+0x9d>
xor    %edi,%edi
mov    %r8,0x20(%rsp)
mov    %ecx,%ebx
mov    %edx,%r13d
call   1030 <assert@plt>
mov    0x90(%rsp),%r9d
mov    %r13d,%edx
mov    %ebx,%ecx
mov    0x20(%rsp),%r8
mov    0xa0(%rsp),%eax
mov    %r12d,%esi
or     %r9d,%esi
test   $0x1,%sil
jne    1350 <form_component_prediction+0x240>
test   %eax,%eax
je     18e2 <form_component_prediction+0x7d2>
cmpl   $0x0,0x4(%rsp)
jle    2600 <form_component_prediction+0x14f0>
movslq %ecx,%r9
mov    (%rsp),%ecx
mov    0x10(%rsp),%r10
add    %r8,%r10
add    %rcx,%r10
mov    0x8(%rsp),%r11
add    %r8,%r11
add    %rbp,%r11
add    %rcx,%r11
mov    %ecx,%eax
and    $0xffffffe0,%eax
mov    %ecx,%edi
and    $0xfffffff8,%edi
mov    %rcx,%r8
neg    %r8
xor    %ebp,%ebp
jmp    1224 <form_component_prediction+0x114>
nopw   0x0(%rax,%rax,1)
add    %r9,%r14
add    %r9,%r15
add    $0x1,%rbp
cmp    0x4(%rsp),%ebp
je     2600 <form_component_prediction+0x14f0>
cmpl   $0x0,(%rsp)
jle    1210 <form_component_prediction+0x100>
cmpl   $0x8,(%rsp)
jb     1252 <form_component_prediction+0x142>
mov    %rbp,%rdx
imul   %r9,%rdx
lea    (%r11,%rdx,1),%rsi
add    0x18(%rsp),%rsi
cmp    %rsi,%r15
jae    12bb <form_component_prediction+0x1ab>
add    %r10,%rdx
add    0x28(%rsp),%rdx
cmp    %rdx,%r14
jae    12bb <form_component_prediction+0x1ab>
xor    %esi,%esi
mov    %rsi,%rbx
test   $0x1,%cl
je     1278 <form_component_prediction+0x168>
movzbl (%r15,%rsi,1),%edx
movzbl (%r14,%rsi,1),%ebx
add    %ebx,%edx
add    $0x1,%edx
shr    %edx
mov    %dl,(%r15,%rsi,1)
mov    %rsi,%rbx
or     $0x1,%rbx
not    %rsi
cmp    %r8,%rsi
je     1210 <form_component_prediction+0x100>
movzbl (%r15,%rbx,1),%edx
movzbl (%r14,%rbx,1),%esi
add    %esi,%edx
add    $0x1,%edx
shr    %edx
mov    %dl,(%r15,%rbx,1)
movzbl 0x1(%r15,%rbx,1),%edx
movzbl 0x1(%r14,%rbx,1),%esi
add    %esi,%edx
add    $0x1,%edx
shr    %edx
mov    %dl,0x1(%r15,%rbx,1)
add    $0x2,%rbx
cmp    %rbx,%rcx
jne    1280 <form_component_prediction+0x170>
jmp    1210 <form_component_prediction+0x100>
cmpl   $0x20,(%rsp)
jae    12c5 <form_component_prediction+0x1b5>
xor    %edx,%edx
jmp    1320 <form_component_prediction+0x210>
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movdqu (%r15,%rdx,1),%xmm0
movdqu 0x10(%r15,%rdx,1),%xmm1
movdqu (%r14,%rdx,1),%xmm2
pavgb  %xmm0,%xmm2
movdqu 0x10(%r14,%rdx,1),%xmm0
pavgb  %xmm1,%xmm0
movdqu %xmm2,(%r15,%rdx,1)
movdqu %xmm0,0x10(%r15,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%rax
jne    12d0 <form_component_prediction+0x1c0>
cmp    %rcx,%rax
je     1210 <form_component_prediction+0x100>
mov    %rax,%rdx
mov    %rax,%rsi
test   $0x18,%cl
je     1254 <form_component_prediction+0x144>
movq   (%r15,%rdx,1),%xmm0
movq   (%r14,%rdx,1),%xmm1
pavgb  %xmm0,%xmm1
movq   %xmm1,(%r15,%rdx,1)
add    $0x8,%rdx
cmp    %rdx,%rdi
jne    1320 <form_component_prediction+0x210>
mov    %rdi,%rsi
cmp    %rcx,%rdi
je     1210 <form_component_prediction+0x100>
jmp    1254 <form_component_prediction+0x144>
and    $0x1,%r12d
test   $0x1,%r9b
jne    1657 <form_component_prediction+0x547>
test   %r12d,%r12d
je     1657 <form_component_prediction+0x547>
test   %eax,%eax
je     1fb1 <form_component_prediction+0xea1>
cmpl   $0x0,0x4(%rsp)
jle    2600 <form_component_prediction+0x14f0>
movslq %ecx,%r13
movslq %edx,%rcx
mov    (%rsp),%edx
mov    0x10(%rsp),%rax
add    %r8,%rax
add    %rdx,%rax
mov    %rax,0x10(%rsp)
mov    0x8(%rsp),%rax
add    %r8,%rax
mov    %rcx,0x30(%rsp)
add    %rax,%rcx
add    %rbp,%rcx
lea    (%rcx,%rdx,1),%rsi
mov    %rsi,0x38(%rsp)
add    %rbp,%rax
add    %rdx,%rax
mov    %rax,0x8(%rsp)
mov    %edx,%r12d
and    $0xfffffff0,%r12d
mov    %edx,%r8d
and    $0xfffffff8,%r8d
mov    %rdx,%r11
neg    %r11
mov    0x18(%rsp),%rax
mov    %rcx,0x20(%rsp)
lea    (%rax,%rcx,1),%rsi
xor    %r10d,%r10d
pxor   %xmm0,%xmm0
pcmpeqd %xmm1,%xmm1
movdqa 0x1c10(%rip),%xmm8
jmp    1418 <form_component_prediction+0x308>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    %r13,%r14
add    %r13,%r15
add    $0x1,%r10
add    %r13,%rsi
cmp    0x4(%rsp),%r10d
je     2600 <form_component_prediction+0x14f0>
cmpl   $0x0,(%rsp)
jle    1400 <form_component_prediction+0x2f0>
cmpl   $0x8,(%rsp)
jae    14d0 <form_component_prediction+0x3c0>
xor    %ecx,%ecx
mov    %rcx,%rbp
test   $0x1,%dl
je     1463 <form_component_prediction+0x353>
movzbl (%r15,%rcx,1),%eax
movzbl (%r14,%rcx,1),%ebp
mov    0x30(%rsp),%rdi
lea    (%rcx,%rdi,1),%rbx
movzbl (%r14,%rbx,1),%ebx
add    %ebx,%ebp
add    $0x1,%ebp
shr    %ebp
add    %ebp,%eax
add    $0x1,%eax
shr    %eax
mov    %al,(%r15,%rcx,1)
mov    %rcx,%rbp
or     $0x1,%rbp
not    %rcx
cmp    %r11,%rcx
je     1400 <form_component_prediction+0x2f0>
nopl   0x0(%rax,%rax,1)
movzbl (%r15,%rbp,1),%eax
movzbl (%r14,%rbp,1),%ecx
movzbl (%rsi,%rbp,1),%ebx
add    %ebx,%ecx
add    $0x1,%ecx
shr    %ecx
add    %ecx,%eax
add    $0x1,%eax
shr    %eax
mov    %al,(%r15,%rbp,1)
movzbl 0x1(%r15,%rbp,1),%eax
movzbl 0x1(%r14,%rbp,1),%ecx
movzbl 0x1(%rsi,%rbp,1),%ebx
add    %ebx,%ecx
add    $0x1,%ecx
shr    %ecx
add    %ecx,%eax
add    $0x1,%eax
shr    %eax
mov    %al,0x1(%r15,%rbp,1)
add    $0x2,%rbp
cmp    %rbp,%rdx
jne    1470 <form_component_prediction+0x360>
jmp    1400 <form_component_prediction+0x2f0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r10,%rax
imul   %r13,%rax
mov    0x10(%rsp),%rcx
add    %rax,%rcx
add    0x28(%rsp),%rcx
mov    0x20(%rsp),%rdi
lea    (%rdi,%rax,1),%rbx
mov    0x18(%rsp),%rdi
add    %rdi,%rbx
mov    0x38(%rsp),%rbp
add    %rax,%rbp
add    %rdi,%rbp
add    0x8(%rsp),%rax
add    %rdi,%rax
cmp    %rbp,%r15
setb   %bpl
cmp    %rcx,%rbx
setb   %r9b
cmp    %rax,%r15
setb   %al
cmp    %rcx,%r14
setb   %bl
test   %r9b,%bpl
jne    1428 <form_component_prediction+0x318>
mov    $0x0,%ecx
and    %bl,%al
jne    142a <form_component_prediction+0x31a>
cmpl   $0x10,(%rsp)
jae    15a0 <form_component_prediction+0x490>
xor    %ebp,%ebp
movq   (%r15,%rbp,1),%xmm2
punpcklbw %xmm0,%xmm2
movq   (%r14,%rbp,1),%xmm3
punpcklbw %xmm0,%xmm3
movq   (%rsi,%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,(%r15,%rbp,1)
add    $0x8,%rbp
cmp    %rbp,%r8
jne    1540 <form_component_prediction+0x430>
mov    %r8,%rcx
cmp    %rdx,%r8
je     1400 <form_component_prediction+0x2f0>
jmp    142a <form_component_prediction+0x31a>
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movdqu (%r15,%rbp,1),%xmm5
movdqa %xmm5,%xmm6
punpckhbw %xmm0,%xmm6
punpcklbw %xmm0,%xmm5
movdqu (%r14,%rbp,1),%xmm7
movdqa %xmm7,%xmm2
punpcklbw %xmm0,%xmm2
punpckhbw %xmm0,%xmm7
movdqu (%rsi,%rbp,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,(%r15,%rbp,1)
add    $0x10,%rbp
cmp    %rbp,%r12
jne    15b0 <form_component_prediction+0x4a0>
cmp    %rdx,%r12
je     1400 <form_component_prediction+0x2f0>
mov    %r12,%rbp
mov    %r12,%rcx
test   $0x8,%dl
jne    1540 <form_component_prediction+0x430>
jmp    142a <form_component_prediction+0x31a>
test   $0x1,%r9b
je     1b52 <form_component_prediction+0xa42>
test   %r12d,%r12d
jne    1b52 <form_component_prediction+0xa42>
test   %eax,%eax
je     21cf <form_component_prediction+0x10bf>
cmpl   $0x0,0x4(%rsp)
jle    2600 <form_component_prediction+0x14f0>
movslq %ecx,%r10
mov    (%rsp),%ecx
mov    0x10(%rsp),%r13
add    %r8,%r13
add    %rcx,%r13
mov    0x8(%rsp),%rax
add    %r8,%rax
add    %rbp,%rax
lea    (%rcx,%rax,1),%r8
add    $0x1,%r8
mov    %ecx,%r11d
and    $0xfffffff0,%r11d
mov    %ecx,%r12d
and    $0xfffffff8,%r12d
mov    %rcx,%r9
neg    %r9
xor    %edx,%edx
pxor   %xmm0,%xmm0
pcmpeqd %xmm1,%xmm1
movdqa 0x1938(%rip),%xmm8
jmp    16e4 <form_component_prediction+0x5d4>
nopw   0x0(%rax,%rax,1)
add    %r10,%r14
add    %r10,%r15
add    $0x1,%rdx
cmp    0x4(%rsp),%edx
je     2600 <form_component_prediction+0x14f0>
cmpl   $0x0,(%rsp)
jle    16d0 <form_component_prediction+0x5c0>
cmpl   $0x8,(%rsp)
jb     171a <form_component_prediction+0x60a>
mov    %rdx,%rsi
imul   %r10,%rsi
lea    (%r8,%rsi,1),%rdi
add    0x18(%rsp),%rdi
cmp    %rdi,%r15
jae    17b8 <form_component_prediction+0x6a8>
add    %r13,%rsi
add    0x28(%rsp),%rsi
cmp    %rsi,%r14
jae    17b8 <form_component_prediction+0x6a8>
xor    %edi,%edi
mov    %rdi,%rbp
test   $0x1,%cl
je     174c <form_component_prediction+0x63c>
movzbl (%r15,%rdi,1),%esi
movzbl (%r14,%rdi,1),%ebx
mov    %rdi,%rbp
or     $0x1,%rbp
movzbl (%r14,%rbp,1),%eax
add    %ebx,%eax
add    $0x1,%eax
shr    %eax
add    %esi,%eax
add    $0x1,%eax
shr    %eax
mov    %al,(%r15,%rdi,1)
not    %rdi
cmp    %r9,%rdi
je     16d0 <form_component_prediction+0x5c0>
nopl   0x0(%rax,%rax,1)
movzbl (%r15,%rbp,1),%eax
movzbl (%r14,%rbp,1),%esi
movzbl 0x1(%r14,%rbp,1),%edi
add    %edi,%esi
add    $0x1,%esi
shr    %esi
add    %esi,%eax
add    $0x1,%eax
shr    %eax
mov    %al,(%r15,%rbp,1)
movzbl 0x1(%r15,%rbp,1),%eax
movzbl 0x1(%r14,%rbp,1),%esi
movzbl 0x2(%r14,%rbp,1),%edi
add    %edi,%esi
add    $0x1,%esi
shr    %esi
add    %esi,%eax
add    $0x1,%eax
shr    %eax
mov    %al,0x1(%r15,%rbp,1)
lea    0x2(%rbp),%rax
mov    %rax,%rbp
cmp    %rax,%rcx
jne    1760 <form_component_prediction+0x650>
jmp    16d0 <form_component_prediction+0x5c0>
cmpl   $0x10,(%rsp)
jae    17c5 <form_component_prediction+0x6b5>
xor    %esi,%esi
jmp    1880 <form_component_prediction+0x770>
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movdqu (%r15,%rbp,1),%xmm5
movdqa %xmm5,%xmm6
punpckhbw %xmm0,%xmm6
punpcklbw %xmm0,%xmm5
movdqu (%r14,%rbp,1),%xmm7
movdqu 0x1(%r14,%rbp,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,(%r15,%rbp,1)
add    $0x10,%rbp
cmp    %rbp,%r11
jne    17d0 <form_component_prediction+0x6c0>
cmp    %rcx,%r11
je     16d0 <form_component_prediction+0x5c0>
mov    %r11,%rsi
mov    %r11,%rdi
test   $0x8,%cl
je     171c <form_component_prediction+0x60c>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movq   (%r15,%rsi,1),%xmm2
punpcklbw %xmm0,%xmm2
movq   (%r14,%rsi,1),%xmm3
punpcklbw %xmm0,%xmm3
movq   0x1(%r14,%rsi,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,(%r15,%rsi,1)
add    $0x8,%rsi
cmp    %rsi,%r12
jne    1880 <form_component_prediction+0x770>
mov    %r12,%rdi
cmp    %rcx,%r12
je     16d0 <form_component_prediction+0x5c0>
jmp    171c <form_component_prediction+0x60c>
cmpl   $0x0,0x4(%rsp)
jle    2600 <form_component_prediction+0x14f0>
movslq %ecx,%r13
mov    (%rsp),%ecx
mov    0x10(%rsp),%rdx
add    %r8,%rdx
lea    (%rdx,%rcx,1),%rax
mov    %rax,0x20(%rsp)
mov    0x8(%rsp),%rsi
add    %r8,%rsi
add    %rbp,%rsi
lea    (%rsi,%rcx,1),%rax
mov    %rax,0x10(%rsp)
mov    %ecx,%eax
and    $0xffffffe0,%eax
mov    %rax,0x8(%rsp)
add    $0xffffffffffffffe0,%rax
mov    %rax,0x38(%rsp)
shr    $0x5,%rax
add    $0x1,%rax
mov    %eax,%r9d
and    $0x3,%r9d
and    $0xfffffffffffffffc,%rax
mov    %rax,0x40(%rsp)
mov    %ecx,%ebp
and    $0xfffffff8,%ebp
mov    %ecx,%r11d
and    $0x3,%r11d
mov    0x28(%rsp),%rax
lea    (%rax,%rdx,1),%rbx
add    $0x10,%rbx
mov    0x18(%rsp),%rax
lea    (%rax,%rsi,1),%r8
add    $0x10,%r8
mov    %r9,0x30(%rsp)
shl    $0x5,%r9
xor    %r10d,%r10d
jmp    199b <form_component_prediction+0x88b>
nopw   0x0(%rax,%rax,1)
add    %r13,%r14
add    %r13,%r15
add    $0x1,%r10
add    %r13,%rbx
add    %r13,%r8
cmp    0x4(%rsp),%r10d
je     2600 <form_component_prediction+0x14f0>
cmpl   $0x0,(%rsp)
jle    1980 <form_component_prediction+0x870>
cmpl   $0x8,(%rsp)
jb     19d4 <form_component_prediction+0x8c4>
mov    %r10,%rdx
imul   %r13,%rdx
mov    0x10(%rsp),%rax
lea    (%rax,%rdx,1),%rsi
add    0x18(%rsp),%rsi
cmp    %rsi,%r15
jae    1a48 <form_component_prediction+0x938>
add    0x20(%rsp),%rdx
add    0x28(%rsp),%rdx
cmp    %rdx,%r14
jae    1a48 <form_component_prediction+0x938>
xor    %edx,%edx
mov    %rdx,%rsi
not    %rsi
add    %rcx,%rsi
test   %r11,%r11
je     1a03 <form_component_prediction+0x8f3>
mov    %r11,%rdi
nopw   0x0(%rax,%rax,1)
movzbl (%r14,%rdx,1),%r12d
mov    %r12b,(%r15,%rdx,1)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rdi
jne    19f0 <form_component_prediction+0x8e0>
cmp    $0x3,%rsi
jb     1980 <form_component_prediction+0x870>
nopl   (%rax)
movzbl (%r14,%rdx,1),%eax
mov    %al,(%r15,%rdx,1)
movzbl 0x1(%r14,%rdx,1),%eax
mov    %al,0x1(%r15,%rdx,1)
movzbl 0x2(%r14,%rdx,1),%eax
mov    %al,0x2(%r15,%rdx,1)
movzbl 0x3(%r14,%rdx,1),%eax
mov    %al,0x3(%r15,%rdx,1)
add    $0x4,%rdx
cmp    %rdx,%rcx
jne    1a10 <form_component_prediction+0x900>
jmp    1980 <form_component_prediction+0x870>
cmpl   $0x20,(%rsp)
jae    1a55 <form_component_prediction+0x945>
xor    %esi,%esi
jmp    1b30 <form_component_prediction+0xa20>
cmpq   $0x60,0x38(%rsp)
jae    1a64 <form_component_prediction+0x954>
xor    %edx,%edx
jmp    1adc <form_component_prediction+0x9cc>
mov    0x40(%rsp),%rsi
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movups (%r14,%rdx,1),%xmm0
movups 0x10(%r14,%rdx,1),%xmm1
movups %xmm0,(%r15,%rdx,1)
movups %xmm1,0x10(%r15,%rdx,1)
movups 0x20(%r14,%rdx,1),%xmm0
movups 0x30(%r14,%rdx,1),%xmm1
movups %xmm0,0x20(%r15,%rdx,1)
movups %xmm1,0x30(%r15,%rdx,1)
movups 0x40(%r14,%rdx,1),%xmm0
movups 0x50(%r14,%rdx,1),%xmm1
movups %xmm0,0x40(%r15,%rdx,1)
movups %xmm1,0x50(%r15,%rdx,1)
movdqu 0x60(%r14,%rdx,1),%xmm0
movdqu 0x70(%r14,%rdx,1),%xmm1
movdqu %xmm0,0x60(%r15,%rdx,1)
movdqu %xmm1,0x70(%r15,%rdx,1)
sub    $0xffffffffffffff80,%rdx
add    $0xfffffffffffffffc,%rsi
jne    1a70 <form_component_prediction+0x960>
cmpq   $0x0,0x30(%rsp)
je     1b0f <form_component_prediction+0x9ff>
lea    (%rbx,%rdx,1),%rsi
add    %r8,%rdx
xor    %edi,%edi
nopl   (%rax)
movdqu -0x10(%rdx,%rdi,1),%xmm0
movdqu (%rdx,%rdi,1),%xmm1
movdqu %xmm0,-0x10(%rsi,%rdi,1)
movdqu %xmm1,(%rsi,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%r9
jne    1af0 <form_component_prediction+0x9e0>
cmp    %rcx,0x8(%rsp)
je     1980 <form_component_prediction+0x870>
mov    0x8(%rsp),%rdx
mov    %rdx,%rsi
test   $0x18,%cl
je     19d6 <form_component_prediction+0x8c6>
nopl   0x0(%rax,%rax,1)
mov    (%r14,%rsi,1),%rdx
mov    %rdx,(%r15,%rsi,1)
add    $0x8,%rsi
cmp    %rsi,%rbp
jne    1b30 <form_component_prediction+0xa20>
mov    %rbp,%rdx
cmp    %rcx,%rbp
je     1980 <form_component_prediction+0x870>
jmp    19d6 <form_component_prediction+0x8c6>
test   %eax,%eax
je     2371 <form_component_prediction+0x1261>
cmpl   $0x0,0x4(%rsp)
jle    2600 <form_component_prediction+0x14f0>
movslq %ecx,%r12
movslq %edx,%r10
mov    (%rsp),%edx
mov    0x10(%rsp),%rax
add    %r8,%rax
add    %rdx,%rax
mov    %rax,0x10(%rsp)
mov    0x8(%rsp),%rax
add    %r8,%rax
add    %rax,%r10
add    %rbp,%r10
lea    (%rdx,%r10,1),%rcx
add    $0x1,%rcx
mov    %rcx,0x8(%rsp)
add    %rbp,%rax
lea    (%rdx,%rax,1),%r9
add    $0x1,%r9
mov    %edx,%r11d
and    $0xfffffff0,%r11d
mov    %edx,%r13d
and    $0xfffffff8,%r13d
mov    0x18(%rsp),%rax
lea    (%rax,%r10,1),%rdi
add    $0x1,%rdi
xor    %r8d,%r8d
pxor   %xmm11,%xmm11
movdqa 0x1440(%rip),%xmm8
pcmpeqd %xmm9,%xmm9
movdqa 0x1442(%rip),%xmm10
jmp    1bf8 <form_component_prediction+0xae8>
add    %r12,%r14
add    %r12,%r15
add    $0x1,%r8
add    %r12,%rdi
cmp    0x4(%rsp),%r8d
je     2600 <form_component_prediction+0x14f0>
cmpl   $0x0,(%rsp)
jle    1be0 <form_component_prediction+0xad0>
cmpl   $0x8,(%rsp)
jae    1c10 <form_component_prediction+0xb00>
xor    %esi,%esi
jmp    1f70 <form_component_prediction+0xe60>
nopl   0x0(%rax,%rax,1)
mov    %r8,%rax
imul   %r12,%rax
mov    0x10(%rsp),%rcx
lea    (%rcx,%rax,1),%rsi
add    0x28(%rsp),%rsi
lea    (%r10,%rax,1),%rbx
mov    0x18(%rsp),%rcx
add    %rcx,%rbx
mov    0x8(%rsp),%rbp
add    %rax,%rbp
add    %rcx,%rbp
add    %r9,%rax
add    %rcx,%rax
cmp    %rbp,%r15
setb   %bpl
cmp    %rsi,%rbx
setb   %cl
cmp    %rax,%r15
setb   %bl
cmp    %rsi,%r14
setb   %al
test   %cl,%bpl
jne    1c7a <form_component_prediction+0xb6a>
mov    $0x0,%esi
and    %al,%bl
jne    1f70 <form_component_prediction+0xe60>
cmpl   $0x10,(%rsp)
jae    1c81 <form_component_prediction+0xb71>
xor    %ebx,%ebx
jmp    1e70 <form_component_prediction+0xd60>
xor    %esi,%esi
jmp    1f70 <form_component_prediction+0xe60>
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movdqu (%r14,%rbp,1),%xmm1
movdqu 0x1(%r14,%rbp,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(%rdi,%rbp,1),%xmm0
movdqu (%rdi,%rbp,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 (%r15,%rbp,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,(%r15,%rbp,1)
add    $0x10,%rbp
cmp    %rbp,%r11
jne    1c90 <form_component_prediction+0xb80>
cmp    %rdx,%r11
je     1be0 <form_component_prediction+0xad0>
mov    %r11,%rbx
mov    %r11,%rsi
test   $0x8,%dl
je     1f70 <form_component_prediction+0xe60>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movq   (%r15,%rbx,1),%xmm1
punpcklbw %xmm11,%xmm1
movdqa %xmm1,%xmm4
punpckhwd %xmm11,%xmm4
punpcklwd %xmm11,%xmm1
movq   (%r14,%rbx,1),%xmm0
punpcklbw %xmm11,%xmm0
movdqa %xmm0,%xmm2
punpcklwd %xmm11,%xmm2
punpckhwd %xmm11,%xmm0
movq   0x1(%r14,%rbx,1),%xmm3
punpcklbw %xmm11,%xmm3
movdqa %xmm3,%xmm6
punpcklwd %xmm11,%xmm6
paddd  %xmm2,%xmm6
punpckhwd %xmm11,%xmm3
paddd  %xmm0,%xmm3
movq   -0x1(%rdi,%rbx,1),%xmm0
punpcklbw %xmm11,%xmm0
movdqa %xmm0,%xmm7
punpckhwd %xmm11,%xmm7
punpcklwd %xmm11,%xmm0
movq   (%rdi,%rbx,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,(%r15,%rbx,1)
add    $0x8,%rbx
cmp    %rbx,%r13
jne    1e70 <form_component_prediction+0xd60>
mov    %r13,%rsi
cmp    %rdx,%r13
je     1be0 <form_component_prediction+0xad0>
cs nopw 0x0(%rax,%rax,1)
movzbl (%r15,%rsi,1),%eax
movzbl (%r14,%rsi,1),%ecx
movzbl 0x1(%r14,%rsi,1),%ebx
add    %ecx,%ebx
movzbl -0x1(%rdi,%rsi,1),%ecx
add    %ebx,%ecx
movzbl (%rdi,%rsi,1),%ebx
add    %ebx,%ecx
add    $0x2,%ecx
shr    $0x2,%ecx
add    %ecx,%eax
add    $0x1,%eax
shr    %eax
mov    %al,(%r15,%rsi,1)
lea    0x1(%rsi),%rax
mov    %rax,%rsi
cmp    %rax,%rdx
jne    1f70 <form_component_prediction+0xe60>
jmp    1be0 <form_component_prediction+0xad0>
cmpl   $0x0,0x4(%rsp)
jle    2600 <form_component_prediction+0x14f0>
movslq %ecx,%r9
movslq %edx,%rcx
mov    (%rsp),%edx
mov    0x10(%rsp),%rax
add    %r8,%rax
add    %rdx,%rax
mov    %rax,0x10(%rsp)
mov    0x8(%rsp),%rax
add    %r8,%rax
mov    %rcx,0x40(%rsp)
add    %rax,%rcx
add    %rbp,%rcx
lea    (%rcx,%rdx,1),%rsi
mov    %rsi,0x30(%rsp)
add    %rbp,%rax
add    %rdx,%rax
mov    %rax,0x8(%rsp)
mov    %edx,%r12d
and    $0xffffffe0,%r12d
mov    %edx,%r13d
and    $0xfffffff8,%r13d
mov    %rdx,%rax
neg    %rax
mov    %rax,0x20(%rsp)
mov    0x18(%rsp),%rax
lea    (%rax,%rcx,1),%rsi
add    $0x10,%rsi
mov    %rcx,0x38(%rsp)
lea    (%rax,%rcx,1),%rdi
xor    %r10d,%r10d
jmp    204b <form_component_prediction+0xf3b>
add    %r9,%r14
add    %r9,%r15
add    $0x1,%r10
add    %r9,%rsi
add    %r9,%rdi
cmp    0x4(%rsp),%r10d
je     2600 <form_component_prediction+0x14f0>
cmpl   $0x0,(%rsp)
jle    2030 <form_component_prediction+0xf20>
cmpl   $0x8,(%rsp)
jb     20d0 <form_component_prediction+0xfc0>
mov    %r10,%rcx
imul   %r9,%rcx
mov    0x10(%rsp),%rax
add    %rcx,%rax
add    0x28(%rsp),%rax
mov    0x38(%rsp),%rbp
lea    (%rcx,%rbp,1),%r8
mov    0x18(%rsp),%rbx
add    %rbx,%r8
mov    0x30(%rsp),%rbp
add    %rcx,%rbp
add    %rbx,%rbp
add    0x8(%rsp),%rcx
add    %rbx,%rcx
cmp    %rbp,%r15
setb   %bpl
cmp    %rax,%r8
setb   %r11b
cmp    %rcx,%r15
setb   %bl
cmp    %rax,%r14
setb   %r8b
test   %r11b,%bpl
jne    20d0 <form_component_prediction+0xfc0>
mov    $0x0,%ecx
and    %r8b,%bl
jne    20d2 <form_component_prediction+0xfc2>
cmpl   $0x20,(%rsp)
jae    2149 <form_component_prediction+0x1039>
xor    %ebx,%ebx
jmp    21a0 <form_component_prediction+0x1090>
nopw   0x0(%rax,%rax,1)
xor    %ecx,%ecx
mov    %rcx,%rbx
test   $0x1,%dl
je     20fe <form_component_prediction+0xfee>
movzbl (%r14,%rcx,1),%eax
mov    0x40(%rsp),%rbp
add    %rcx,%rbp
movzbl (%r14,%rbp,1),%ebp
add    %ebp,%eax
add    $0x1,%eax
shr    %eax
mov    %al,(%r15,%rcx,1)
mov    %rcx,%rbx
or     $0x1,%rbx
not    %rcx
cmp    0x20(%rsp),%rcx
je     2030 <form_component_prediction+0xf20>
nopl   0x0(%rax)
movzbl (%r14,%rbx,1),%eax
movzbl (%rdi,%rbx,1),%ecx
add    %ecx,%eax
add    $0x1,%eax
shr    %eax
mov    %al,(%r15,%rbx,1)
movzbl 0x1(%r14,%rbx,1),%eax
movzbl 0x1(%rdi,%rbx,1),%ecx
add    %ecx,%eax
add    $0x1,%eax
shr    %eax
mov    %al,0x1(%r15,%rbx,1)
add    $0x2,%rbx
cmp    %rbx,%rdx
jne    2110 <form_component_prediction+0x1000>
jmp    2030 <form_component_prediction+0xf20>
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movdqu (%r14,%rcx,1),%xmm0
movdqu 0x10(%r14,%rcx,1),%xmm1
movdqu -0x10(%rsi,%rcx,1),%xmm2
pavgb  %xmm0,%xmm2
movdqu (%rsi,%rcx,1),%xmm0
pavgb  %xmm1,%xmm0
movdqu %xmm2,(%r15,%rcx,1)
movdqu %xmm0,0x10(%r15,%rcx,1)
add    $0x20,%rcx
cmp    %rcx,%r12
jne    2150 <form_component_prediction+0x1040>
cmp    %rdx,%r12
je     2030 <form_component_prediction+0xf20>
mov    %r12,%rbx
mov    %r12,%rcx
test   $0x18,%dl
je     20d2 <form_component_prediction+0xfc2>
xchg   %ax,%ax
movq   (%r14,%rbx,1),%xmm0
movq   (%rdi,%rbx,1),%xmm1
pavgb  %xmm0,%xmm1
movq   %xmm1,(%r15,%rbx,1)
add    $0x8,%rbx
cmp    %rbx,%r13
jne    21a0 <form_component_prediction+0x1090>
mov    %r13,%rcx
cmp    %rdx,%r13
je     2030 <form_component_prediction+0xf20>
jmp    20d2 <form_component_prediction+0xfc2>
cmpl   $0x0,0x4(%rsp)
jle    2600 <form_component_prediction+0x14f0>
movslq %ecx,%r10
mov    (%rsp),%ecx
mov    0x10(%rsp),%r12
add    %r8,%r12
add    %rcx,%r12
mov    0x8(%rsp),%rax
add    %r8,%rax
add    %rbp,%rax
lea    (%rcx,%rax,1),%r8
add    $0x1,%r8
mov    %ecx,%r11d
and    $0xffffffe0,%r11d
mov    %ecx,%ebp
and    $0xfffffff8,%ebp
mov    %rcx,%r9
neg    %r9
xor    %ebx,%ebx
jmp    2234 <form_component_prediction+0x1124>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    %r10,%r14
add    %r10,%r15
add    $0x1,%rbx
cmp    0x4(%rsp),%ebx
je     2600 <form_component_prediction+0x14f0>
cmpl   $0x0,(%rsp)
jle    2220 <form_component_prediction+0x1110>
cmpl   $0x8,(%rsp)
jb     2262 <form_component_prediction+0x1152>
mov    %rbx,%rdx
imul   %r10,%rdx
lea    (%r8,%rdx,1),%rdi
add    0x18(%rsp),%rdi
cmp    %rdi,%r15
jae    22cf <form_component_prediction+0x11bf>
add    %r12,%rdx
add    0x28(%rsp),%rdx
cmp    %rdx,%r14
jae    22cf <form_component_prediction+0x11bf>
xor    %edi,%edi
mov    %rdi,%rdx
test   $0x1,%cl
je     2288 <form_component_prediction+0x1178>
movzbl (%r14,%rdi,1),%eax
mov    %rdi,%rdx
or     $0x1,%rdx
movzbl (%r14,%rdx,1),%esi
add    %esi,%eax
add    $0x1,%eax
shr    %eax
mov    %al,(%r15,%rdi,1)
not    %rdi
cmp    %r9,%rdi
je     2220 <form_component_prediction+0x1110>
movzbl (%r14,%rdx,1),%eax
movzbl 0x1(%r14,%rdx,1),%esi
add    %esi,%eax
add    $0x1,%eax
shr    %eax
mov    %al,(%r15,%rdx,1)
movzbl 0x1(%r14,%rdx,1),%eax
movzbl 0x2(%r14,%rdx,1),%esi
add    %esi,%eax
add    $0x1,%eax
shr    %eax
mov    %al,0x1(%r15,%rdx,1)
lea    0x2(%rdx),%rax
mov    %rax,%rdx
cmp    %rax,%rcx
jne    2290 <form_component_prediction+0x1180>
jmp    2220 <form_component_prediction+0x1110>
cmpl   $0x20,(%rsp)
jae    22d9 <form_component_prediction+0x11c9>
xor    %edx,%edx
jmp    2340 <form_component_prediction+0x1230>
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movdqu (%r14,%rdx,1),%xmm0
movdqu 0x1(%r14,%rdx,1),%xmm1
pavgb  %xmm0,%xmm1
movdqu 0x10(%r14,%rdx,1),%xmm0
movdqu 0x11(%r14,%rdx,1),%xmm2
pavgb  %xmm0,%xmm2
movdqu %xmm1,(%r15,%rdx,1)
movdqu %xmm2,0x10(%r15,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%r11
jne    22e0 <form_component_prediction+0x11d0>
cmp    %rcx,%r11
je     2220 <form_component_prediction+0x1110>
mov    %r11,%rdx
mov    %r11,%rdi
test   $0x18,%cl
je     2264 <form_component_prediction+0x1154>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movq   (%r14,%rdx,1),%xmm0
movq   0x1(%r14,%rdx,1),%xmm1
pavgb  %xmm0,%xmm1
movq   %xmm1,(%r15,%rdx,1)
add    $0x8,%rdx
cmp    %rdx,%rbp
jne    2340 <form_component_prediction+0x1230>
mov    %rbp,%rdi
cmp    %rcx,%rbp
je     2220 <form_component_prediction+0x1110>
jmp    2264 <form_component_prediction+0x1154>
cmpl   $0x0,0x4(%rsp)
jle    2600 <form_component_prediction+0x14f0>
movslq %ecx,%r12
movslq %edx,%r10
mov    (%rsp),%edx
mov    0x10(%rsp),%rax
add    %r8,%rax
add    %rdx,%rax
mov    %rax,0x10(%rsp)
mov    0x8(%rsp),%rax
add    %r8,%rax
add    %rax,%r10
add    %rbp,%r10
lea    (%rdx,%r10,1),%rcx
add    $0x1,%rcx
mov    %rcx,0x8(%rsp)
add    %rbp,%rax
add    %rdx,%rax
add    $0x1,%rax
mov    %rax,0x20(%rsp)
mov    %edx,%r11d
and    $0xfffffff0,%r11d
mov    %edx,%r13d
and    $0xfffffff8,%r13d
mov    0x18(%rsp),%rax
lea    (%rax,%r10,1),%rdi
add    $0x1,%rdi
xor    %r9d,%r9d
pxor   %xmm0,%xmm0
movdqa 0xc46(%rip),%xmm8
movdqa 0xc0e(%rip),%xmm2
jmp    2418 <form_component_prediction+0x1308>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    %r12,%r14
add    %r12,%r15
add    $0x1,%r9
add    %r12,%rdi
cmp    0x4(%rsp),%r9d
je     2600 <form_component_prediction+0x14f0>
cmpl   $0x0,(%rsp)
jle    2400 <form_component_prediction+0x12f0>
cmpl   $0x8,(%rsp)
jae    2470 <form_component_prediction+0x1360>
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
movzbl (%r14,%rsi,1),%eax
movzbl 0x1(%r14,%rsi,1),%ebp
add    %eax,%ebp
movzbl -0x1(%rdi,%rsi,1),%eax
add    %ebp,%eax
movzbl (%rdi,%rsi,1),%ebp
add    %ebp,%eax
add    $0x2,%eax
shr    $0x2,%eax
mov    %al,(%r15,%rsi,1)
lea    0x1(%rsi),%rax
mov    %rax,%rsi
cmp    %rax,%rdx
jne    2430 <form_component_prediction+0x1320>
jmp    2400 <form_component_prediction+0x12f0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r9,%rax
imul   %r12,%rax
mov    0x10(%rsp),%rcx
lea    (%rcx,%rax,1),%rsi
add    0x28(%rsp),%rsi
lea    (%r10,%rax,1),%rbx
mov    0x18(%rsp),%rcx
add    %rcx,%rbx
mov    0x8(%rsp),%rbp
add    %rax,%rbp
add    %rcx,%rbp
add    0x20(%rsp),%rax
add    %rcx,%rax
cmp    %rbp,%r15
setb   %bpl
cmp    %rsi,%rbx
setb   %r8b
cmp    %rax,%r15
setb   %bl
cmp    %rsi,%r14
setb   %al
test   %r8b,%bpl
jne    2546 <form_component_prediction+0x1436>
mov    $0x0,%esi
and    %al,%bl
jne    2430 <form_component_prediction+0x1320>
cmpl   $0x10,(%rsp)
jae    254d <form_component_prediction+0x143d>
xor    %ebx,%ebx
nopl   0x0(%rax)
movq   (%r14,%rbx,1),%xmm1
punpcklbw %xmm0,%xmm1
movq   0x1(%r14,%rbx,1),%xmm3
punpcklbw %xmm0,%xmm3
paddw  %xmm1,%xmm3
movq   -0x1(%rdi,%rbx,1),%xmm1
punpcklbw %xmm0,%xmm1
movq   (%rdi,%rbx,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,(%r15,%rbx,1)
add    $0x8,%rbx
cmp    %rbx,%r13
jne    24e0 <form_component_prediction+0x13d0>
mov    %r13,%rsi
cmp    %rdx,%r13
jne    2430 <form_component_prediction+0x1320>
jmp    2400 <form_component_prediction+0x12f0>
xor    %esi,%esi
jmp    2430 <form_component_prediction+0x1320>
xor    %ebp,%ebp
nop
movdqu (%r14,%rbp,1),%xmm3
movdqu 0x1(%r14,%rbp,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(%rdi,%rbp,1),%xmm3
movdqu (%rdi,%rbp,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,(%r15,%rbp,1)
add    $0x10,%rbp
cmp    %rbp,%r11
jne    2550 <form_component_prediction+0x1440>
cmp    %rdx,%r11
je     2400 <form_component_prediction+0x12f0>
mov    %r11,%rbx
mov    %r11,%rsi
test   $0x8,%dl
je     2430 <form_component_prediction+0x1320>
jmp    24e0 <form_component_prediction+0x13d0>
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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