#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_fail(char *, char *, unsigned int, char *);
void form_component_prediction(unsigned char *src, unsigned char *dst, int lx,
                               int lx2, int w, int h, int x, int y, int dx,
                               int dy, int average_flag) {
  int xint;
  int yint;
  int xh;
  int yh;
  int i;
  int j;
  int v;
  unsigned char *s;
  unsigned char *d;
  int tmp;
  int tmp___0;
  int tmp___1;
  int tmp___2;
  {
    xint = dx >> 1;
    yint = dy >> 1;
    s = ((src + lx * (y + yint)) + x) + xint;
    d = (dst + lx * y) + x;
    xh = dx & 1;
    yh = dy & 1;
    if (!((unsigned long)s != (unsigned long)d)) {
      __assert_fail("s!=d", "src/recon.c", 474U, "form_component_prediction");
    }
    if (!xh) {
      if (!yh) {
        if (average_flag) {
          j = 0;
          while (j < h) {
            i = 0;
            while (i < w) {
              v = (int)*(d + i) + (int)*(s + i);
              if (v >= 0) {
                tmp = 1;
              } else {
                tmp = 0;
              }
              *(d + i) = (unsigned char)((v + tmp) >> 1);
              i++;
            }
            s += lx2;
            d += lx2;
            j++;
          }
        } else {
          j = 0;
          while (j < h) {
            i = 0;
            while (i < w) {
              *(d + i) = *(s + i);
              i++;
            }
            s += lx2;
            d += lx2;
            j++;
          }
        }
      } else {
        goto _L___1;
      }
    } else
    _L___1:
      if (!xh) {
        if (yh) {
          if (average_flag) {
            j = 0;
            while (j < h) {
              i = 0;
              while (i < w) {
                v = (int)((unsigned int)*(d + i) +
                          ((unsigned int)(((int)*(s + i) +
                                           (int)*(s + (i + lx))) +
                                          1) >>
                           1));
                if (v >= 0) {
                  tmp___0 = 1;
                } else {
                  tmp___0 = 0;
                }
                *(d + i) = (unsigned char)((v + tmp___0) >> 1);
                i++;
              }
              s += lx2;
              d += lx2;
              j++;
            }
          } else {
            j = 0;
            while (j < h) {
              i = 0;
              while (i < w) {
                *(d + i) =
                    (unsigned char)((unsigned int)(((int)*(s + i) +
                                                    (int)*(s + (i + lx))) +
                                                   1) >>
                                    1);
                i++;
              }
              s += lx2;
              d += lx2;
              j++;
            }
          }
        } else {
          goto _L___0;
        }
      } else
      _L___0:
        if (xh) {
          if (!yh) {
            if (average_flag) {
              j = 0;
              while (j < h) {
                i = 0;
                while (i < w) {
                  v = (int)((unsigned int)*(d + i) +
                            ((unsigned int)(((int)*(s + i) +
                                             (int)*(s + (i + 1))) +
                                            1) >>
                             1));
                  if (v >= 0) {
                    tmp___1 = 1;
                  } else {
                    tmp___1 = 0;
                  }
                  *(d + i) = (unsigned char)((v + tmp___1) >> 1);
                  i++;
                }
                s += lx2;
                d += lx2;
                j++;
              }
            } else {
              j = 0;
              while (j < h) {
                i = 0;
                while (i < w) {
                  *(d + i) =
                      (unsigned char)((unsigned int)(((int)*(s + i) +
                                                      (int)*(s + (i + 1))) +
                                                     1) >>
                                      1);
                  i++;
                }
                s += lx2;
                d += lx2;
                j++;
              }
            }
          } else {
            goto _L;
          }
        } else
        _L:
          if (average_flag) {
            j = 0;
            while (j < h) {
              i = 0;
              while (i < w) {
                v = (int)((unsigned int)*(d + i) +
                          ((unsigned int)(((((int)*(s + i) +
                                             (int)*(s + (i + 1))) +
                                            (int)*(s + (i + lx))) +
                                           (int)*(s + ((i + lx) + 1))) +
                                          2) >>
                           2));
                if (v >= 0) {
                  tmp___2 = 1;
                } else {
                  tmp___2 = 0;
                }
                *(d + i) = (unsigned char)((v + tmp___2) >> 1);
                i++;
              }
              s += lx2;
              d += lx2;
              j++;
            }
          } else {
            j = 0;
            while (j < h) {
              i = 0;
              while (i < w) {
                *(d + i) =
                    (unsigned char)((unsigned int)(((((int)*(s + i) +
                                                      (int)*(s + (i + 1))) +
                                                     (int)*(s + (i + lx))) +
                                                    (int)*(s +
                                                           ((i + lx) + 1))) +
                                                   2) >>
                                    2);
                i++;
              }
              s += lx2;
              d += lx2;
              j++;
            }
          }
    return;
  }
}


x86 assembly (clang, -O0):
<form_component_prediction>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%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
mov    -0x50(%rbp),%rcx
cmp    %rcx,%rax
jne    11d5 <form_component_prediction+0xc5>
lea    0xe43(%rip),%rdi
lea    0xe41(%rip),%rsi
mov    $0x1da,%edx
lea    0xe41(%rip),%rcx
call   1030 <__assert_fail@plt>
cmpl   $0x0,-0x2c(%rbp)
jne    133a <form_component_prediction+0x22a>
cmpl   $0x0,-0x30(%rbp)
jne    1330 <form_component_prediction+0x220>
cmpl   $0x0,0x30(%rbp)
je     12ac <form_component_prediction+0x19c>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    12a7 <form_component_prediction+0x197>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1277 <form_component_prediction+0x167>
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)
cmpl   $0x0,-0x3c(%rbp)
jl     124c <form_component_prediction+0x13c>
movl   $0x1,-0x54(%rbp)
jmp    1253 <form_component_prediction+0x143>
movl   $0x0,-0x54(%rbp)
mov    -0x3c(%rbp),%eax
add    -0x54(%rbp),%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    120d <form_component_prediction+0xfd>
mov    -0x18(%rbp),%ecx
mov    -0x48(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x18(%rbp),%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    11fa <form_component_prediction+0xea>
jmp    132b <form_component_prediction+0x21b>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1326 <form_component_prediction+0x216>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    12f6 <form_component_prediction+0x1e6>
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    12c6 <form_component_prediction+0x1b6>
mov    -0x18(%rbp),%ecx
mov    -0x48(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x18(%rbp),%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    12b3 <form_component_prediction+0x1a3>
jmp    132b <form_component_prediction+0x21b>
jmp    1335 <form_component_prediction+0x225>
jmp    133f <form_component_prediction+0x22f>
jmp    1855 <form_component_prediction+0x745>
jmp    133f <form_component_prediction+0x22f>
cmpl   $0x0,-0x2c(%rbp)
jne    14d9 <form_component_prediction+0x3c9>
cmpl   $0x0,-0x30(%rbp)
je     14cf <form_component_prediction+0x3bf>
cmpl   $0x0,0x30(%rbp)
je     142f <form_component_prediction+0x31f>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    142a <form_component_prediction+0x31a>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    13fa <form_component_prediction+0x2ea>
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)
cmpl   $0x0,-0x3c(%rbp)
jl     13cf <form_component_prediction+0x2bf>
movl   $0x1,-0x58(%rbp)
jmp    13d6 <form_component_prediction+0x2c6>
movl   $0x0,-0x58(%rbp)
mov    -0x3c(%rbp),%eax
add    -0x58(%rbp),%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    1377 <form_component_prediction+0x267>
mov    -0x18(%rbp),%ecx
mov    -0x48(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x18(%rbp),%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1364 <form_component_prediction+0x254>
jmp    14ca <form_component_prediction+0x3ba>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    14c5 <form_component_prediction+0x3b5>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1495 <form_component_prediction+0x385>
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    1449 <form_component_prediction+0x339>
mov    -0x18(%rbp),%ecx
mov    -0x48(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x18(%rbp),%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1436 <form_component_prediction+0x326>
jmp    14ca <form_component_prediction+0x3ba>
jmp    14d4 <form_component_prediction+0x3c4>
jmp    14de <form_component_prediction+0x3ce>
jmp    1850 <form_component_prediction+0x740>
jmp    14de <form_component_prediction+0x3ce>
cmpl   $0x0,-0x2c(%rbp)
je     1678 <form_component_prediction+0x568>
cmpl   $0x0,-0x30(%rbp)
jne    166e <form_component_prediction+0x55e>
cmpl   $0x0,0x30(%rbp)
je     15ce <form_component_prediction+0x4be>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    15c9 <form_component_prediction+0x4b9>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1599 <form_component_prediction+0x489>
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)
cmpl   $0x0,-0x3c(%rbp)
jl     156e <form_component_prediction+0x45e>
movl   $0x1,-0x5c(%rbp)
jmp    1575 <form_component_prediction+0x465>
movl   $0x0,-0x5c(%rbp)
mov    -0x3c(%rbp),%eax
add    -0x5c(%rbp),%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    1516 <form_component_prediction+0x406>
mov    -0x18(%rbp),%ecx
mov    -0x48(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x18(%rbp),%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1503 <form_component_prediction+0x3f3>
jmp    1669 <form_component_prediction+0x559>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1664 <form_component_prediction+0x554>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1634 <form_component_prediction+0x524>
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    15e8 <form_component_prediction+0x4d8>
mov    -0x18(%rbp),%ecx
mov    -0x48(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x18(%rbp),%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    15d5 <form_component_prediction+0x4c5>
jmp    1669 <form_component_prediction+0x559>
jmp    1673 <form_component_prediction+0x563>
jmp    167d <form_component_prediction+0x56d>
jmp    184b <form_component_prediction+0x73b>
jmp    167d <form_component_prediction+0x56d>
cmpl   $0x0,0x30(%rbp)
je     1782 <form_component_prediction+0x672>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    177d <form_component_prediction+0x66d>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    174d <form_component_prediction+0x63d>
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)
cmpl   $0x0,-0x3c(%rbp)
jl     1722 <form_component_prediction+0x612>
movl   $0x1,-0x60(%rbp)
jmp    1729 <form_component_prediction+0x619>
movl   $0x0,-0x60(%rbp)
mov    -0x3c(%rbp),%eax
add    -0x60(%rbp),%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    16a1 <form_component_prediction+0x591>
mov    -0x18(%rbp),%ecx
mov    -0x48(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x18(%rbp),%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    168e <form_component_prediction+0x57e>
jmp    1846 <form_component_prediction+0x736>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1841 <form_component_prediction+0x731>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1811 <form_component_prediction+0x701>
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    179c <form_component_prediction+0x68c>
mov    -0x18(%rbp),%ecx
mov    -0x48(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x18(%rbp),%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1789 <form_component_prediction+0x679>
jmp    1846 <form_component_prediction+0x736>
jmp    184b <form_component_prediction+0x73b>
jmp    1850 <form_component_prediction+0x740>
jmp    1855 <form_component_prediction+0x745>
add    $0x60,%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    %ecx,%r13d
mov    %edx,%ebp
mov    0x98(%rsp),%r12d
mov    0x90(%rsp),%ebx
movslq 0x80(%rsp),%r8
mov    0x88(%rsp),%eax
mov    %ebx,%ecx
sar    %ecx
mov    %r12d,%edx
sar    %edx
add    %eax,%edx
imul   %ebp,%edx
movslq %edx,%rdx
mov    %rdi,0x20(%rsp)
mov    %rdx,0x18(%rsp)
lea    (%rdi,%rdx,1),%r14
add    %r8,%r14
movslq %ecx,%rcx
mov    %rcx,0x8(%rsp)
add    %rcx,%r14
imul   %ebp,%eax
cltq
mov    %rsi,0x28(%rsp)
mov    %rax,0x10(%rsp)
lea    (%rsi,%rax,1),%r15
add    %r8,%r15
cmp    %r15,%r14
jne    11bb <form_component_prediction+0xab>
lea    0x1ea7(%rip),%rdi
lea    0x1ea5(%rip),%rsi
lea    0x1eaa(%rip),%rcx
mov    $0x1da,%edx
mov    %r8,0x30(%rsp)
call   1030 <__assert_fail@plt>
mov    0x30(%rsp),%r8
mov    0xa0(%rsp),%eax
mov    %r12d,%ecx
or     %ebx,%ecx
test   $0x1,%cl
jne    1360 <form_component_prediction+0x250>
test   %eax,%eax
je     18f2 <form_component_prediction+0x7e2>
cmpl   $0x0,0x4(%rsp)
jle    2630 <form_component_prediction+0x1520>
movslq %r13d,%r9
mov    (%rsp),%ecx
mov    0x10(%rsp),%r10
add    %r8,%r10
add    %rcx,%r10
mov    0x8(%rsp),%r11
add    %r8,%r11
add    0x18(%rsp),%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    1234 <form_component_prediction+0x124>
nopl   0x0(%rax,%rax,1)
add    %r9,%r14
add    %r9,%r15
add    $0x1,%rbp
cmp    0x4(%rsp),%ebp
je     2630 <form_component_prediction+0x1520>
cmpl   $0x0,(%rsp)
jle    1220 <form_component_prediction+0x110>
cmpl   $0x8,(%rsp)
jb     1262 <form_component_prediction+0x152>
mov    %rbp,%rdx
imul   %r9,%rdx
lea    (%r11,%rdx,1),%rsi
add    0x20(%rsp),%rsi
cmp    %rsi,%r15
jae    12cb <form_component_prediction+0x1bb>
add    %r10,%rdx
add    0x28(%rsp),%rdx
cmp    %rdx,%r14
jae    12cb <form_component_prediction+0x1bb>
xor    %esi,%esi
mov    %rsi,%rbx
test   $0x1,%cl
je     1288 <form_component_prediction+0x178>
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     1220 <form_component_prediction+0x110>
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    1290 <form_component_prediction+0x180>
jmp    1220 <form_component_prediction+0x110>
cmpl   $0x20,(%rsp)
jae    12d5 <form_component_prediction+0x1c5>
xor    %edx,%edx
jmp    1330 <form_component_prediction+0x220>
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    12e0 <form_component_prediction+0x1d0>
cmp    %rcx,%rax
je     1220 <form_component_prediction+0x110>
mov    %rax,%rdx
mov    %rax,%rsi
test   $0x18,%cl
je     1264 <form_component_prediction+0x154>
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    1330 <form_component_prediction+0x220>
mov    %rdi,%rsi
cmp    %rcx,%rdi
je     1220 <form_component_prediction+0x110>
jmp    1264 <form_component_prediction+0x154>
and    $0x1,%r12d
test   $0x1,%bl
jne    1667 <form_component_prediction+0x557>
test   %r12d,%r12d
je     1667 <form_component_prediction+0x557>
test   %eax,%eax
je     1fd1 <form_component_prediction+0xec1>
cmpl   $0x0,0x4(%rsp)
jle    2630 <form_component_prediction+0x1520>
movslq %r13d,%r13
movslq %ebp,%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,0x38(%rsp)
add    %rax,%rcx
mov    0x18(%rsp),%rdi
add    %rdi,%rcx
lea    (%rcx,%rdx,1),%rsi
mov    %rsi,0x30(%rsp)
add    %rdi,%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    0x20(%rsp),%rax
mov    %rcx,0x18(%rsp)
lea    (%rax,%rcx,1),%rsi
xor    %r10d,%r10d
pxor   %xmm0,%xmm0
pcmpeqd %xmm1,%xmm1
movdqa 0x1bfc(%rip),%xmm8
jmp    1428 <form_component_prediction+0x318>
cs nopw 0x0(%rax,%rax,1)
add    %r13,%r14
add    %r13,%r15
add    $0x1,%r10
add    %r13,%rsi
cmp    0x4(%rsp),%r10d
je     2630 <form_component_prediction+0x1520>
cmpl   $0x0,(%rsp)
jle    1410 <form_component_prediction+0x300>
cmpl   $0x8,(%rsp)
jae    14e0 <form_component_prediction+0x3d0>
xor    %ecx,%ecx
mov    %rcx,%rbp
test   $0x1,%dl
je     1473 <form_component_prediction+0x363>
movzbl (%r15,%rcx,1),%eax
movzbl (%r14,%rcx,1),%ebp
mov    0x38(%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     1410 <form_component_prediction+0x300>
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    1480 <form_component_prediction+0x370>
jmp    1410 <form_component_prediction+0x300>
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    0x18(%rsp),%rdi
lea    (%rdi,%rax,1),%rbx
mov    0x20(%rsp),%rdi
add    %rdi,%rbx
mov    0x30(%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    1438 <form_component_prediction+0x328>
mov    $0x0,%ecx
and    %bl,%al
jne    143a <form_component_prediction+0x32a>
cmpl   $0x10,(%rsp)
jae    15b0 <form_component_prediction+0x4a0>
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    1550 <form_component_prediction+0x440>
mov    %r8,%rcx
cmp    %rdx,%r8
je     1410 <form_component_prediction+0x300>
jmp    143a <form_component_prediction+0x32a>
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    15c0 <form_component_prediction+0x4b0>
cmp    %rdx,%r12
je     1410 <form_component_prediction+0x300>
mov    %r12,%rbp
mov    %r12,%rcx
test   $0x8,%dl
jne    1550 <form_component_prediction+0x440>
jmp    143a <form_component_prediction+0x32a>
test   $0x1,%bl
je     1b62 <form_component_prediction+0xa52>
test   %r12d,%r12d
jne    1b62 <form_component_prediction+0xa52>
test   %eax,%eax
je     21ff <form_component_prediction+0x10ef>
cmpl   $0x0,0x4(%rsp)
jle    2630 <form_component_prediction+0x1520>
movslq %r13d,%r10
mov    (%rsp),%ecx
mov    0x10(%rsp),%r13
add    %r8,%r13
add    %rcx,%r13
mov    0x8(%rsp),%rax
add    %r8,%rax
add    0x18(%rsp),%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 0x1927(%rip),%xmm8
jmp    16f4 <form_component_prediction+0x5e4>
nopl   0x0(%rax,%rax,1)
add    %r10,%r14
add    %r10,%r15
add    $0x1,%rdx
cmp    0x4(%rsp),%edx
je     2630 <form_component_prediction+0x1520>
cmpl   $0x0,(%rsp)
jle    16e0 <form_component_prediction+0x5d0>
cmpl   $0x8,(%rsp)
jb     172a <form_component_prediction+0x61a>
mov    %rdx,%rsi
imul   %r10,%rsi
lea    (%r8,%rsi,1),%rdi
add    0x20(%rsp),%rdi
cmp    %rdi,%r15
jae    17c8 <form_component_prediction+0x6b8>
add    %r13,%rsi
add    0x28(%rsp),%rsi
cmp    %rsi,%r14
jae    17c8 <form_component_prediction+0x6b8>
xor    %edi,%edi
mov    %rdi,%rbp
test   $0x1,%cl
je     175c <form_component_prediction+0x64c>
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     16e0 <form_component_prediction+0x5d0>
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    1770 <form_component_prediction+0x660>
jmp    16e0 <form_component_prediction+0x5d0>
cmpl   $0x10,(%rsp)
jae    17d5 <form_component_prediction+0x6c5>
xor    %esi,%esi
jmp    1890 <form_component_prediction+0x780>
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    17e0 <form_component_prediction+0x6d0>
cmp    %rcx,%r11
je     16e0 <form_component_prediction+0x5d0>
mov    %r11,%rsi
mov    %r11,%rdi
test   $0x8,%cl
je     172c <form_component_prediction+0x61c>
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    1890 <form_component_prediction+0x780>
mov    %r12,%rdi
cmp    %rcx,%r12
je     16e0 <form_component_prediction+0x5d0>
jmp    172c <form_component_prediction+0x61c>
cmpl   $0x0,0x4(%rsp)
jle    2630 <form_component_prediction+0x1520>
movslq %r13d,%r12
mov    (%rsp),%ecx
mov    0x10(%rsp),%rdx
add    %r8,%rdx
lea    (%rdx,%rcx,1),%rax
mov    %rax,0x30(%rsp)
mov    0x8(%rsp),%rsi
add    %r8,%rsi
add    0x18(%rsp),%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,0x18(%rsp)
shr    $0x5,%rax
add    $0x1,%rax
mov    %eax,%r9d
and    $0x3,%r9d
and    $0xfffffffffffffffc,%rax
mov    %rax,0x40(%rsp)
mov    %ecx,%r10d
and    $0xfffffff8,%r10d
mov    %ecx,%r11d
and    $0x3,%r11d
mov    0x28(%rsp),%rax
lea    (%rax,%rdx,1),%rbx
add    $0x10,%rbx
mov    0x20(%rsp),%rax
lea    (%rax,%rsi,1),%r8
add    $0x10,%r8
mov    %r9,0x38(%rsp)
shl    $0x5,%r9
xor    %esi,%esi
jmp    19aa <form_component_prediction+0x89a>
nopw   0x0(%rax,%rax,1)
add    %r12,%r14
add    %r12,%r15
add    $0x1,%rsi
add    %r12,%rbx
add    %r12,%r8
cmp    0x4(%rsp),%esi
je     2630 <form_component_prediction+0x1520>
cmpl   $0x0,(%rsp)
jle    1990 <form_component_prediction+0x880>
cmpl   $0x8,(%rsp)
jb     19e3 <form_component_prediction+0x8d3>
mov    %rsi,%rdx
imul   %r12,%rdx
mov    0x10(%rsp),%rax
lea    (%rax,%rdx,1),%rdi
add    0x20(%rsp),%rdi
cmp    %rdi,%r15
jae    1a58 <form_component_prediction+0x948>
add    0x30(%rsp),%rdx
add    0x28(%rsp),%rdx
cmp    %rdx,%r14
jae    1a58 <form_component_prediction+0x948>
xor    %edx,%edx
mov    %rdx,%rbp
not    %rbp
add    %rcx,%rbp
test   %r11,%r11
je     1a13 <form_component_prediction+0x903>
mov    %r11,%rdi
cs nopw 0x0(%rax,%rax,1)
movzbl (%r14,%rdx,1),%r13d
mov    %r13b,(%r15,%rdx,1)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rdi
jne    1a00 <form_component_prediction+0x8f0>
cmp    $0x3,%rbp
jb     1990 <form_component_prediction+0x880>
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    1a20 <form_component_prediction+0x910>
jmp    1990 <form_component_prediction+0x880>
cmpl   $0x20,(%rsp)
jae    1a65 <form_component_prediction+0x955>
xor    %ebp,%ebp
jmp    1b40 <form_component_prediction+0xa30>
cmpq   $0x60,0x18(%rsp)
jae    1a74 <form_component_prediction+0x964>
xor    %edx,%edx
jmp    1aec <form_component_prediction+0x9dc>
mov    0x40(%rsp),%rbp
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,%rbp
jne    1a80 <form_component_prediction+0x970>
cmpq   $0x0,0x38(%rsp)
je     1b20 <form_component_prediction+0xa10>
lea    (%rbx,%rdx,1),%rbp
add    %r8,%rdx
xor    %edi,%edi
nopl   (%rax)
movdqu -0x10(%rdx,%rdi,1),%xmm0
movdqu (%rdx,%rdi,1),%xmm1
movdqu %xmm0,-0x10(%rbp,%rdi,1)
movdqu %xmm1,0x0(%rbp,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%r9
jne    1b00 <form_component_prediction+0x9f0>
cmp    %rcx,0x8(%rsp)
je     1990 <form_component_prediction+0x880>
mov    0x8(%rsp),%rdx
mov    %rdx,%rbp
test   $0x18,%cl
je     19e5 <form_component_prediction+0x8d5>
nopl   0x0(%rax)
mov    (%r14,%rbp,1),%rdx
mov    %rdx,(%r15,%rbp,1)
add    $0x8,%rbp
cmp    %rbp,%r10
jne    1b40 <form_component_prediction+0xa30>
mov    %r10,%rdx
cmp    %rcx,%r10
je     1990 <form_component_prediction+0x880>
jmp    19e5 <form_component_prediction+0x8d5>
test   %eax,%eax
je     23a1 <form_component_prediction+0x1291>
cmpl   $0x0,0x4(%rsp)
jle    2630 <form_component_prediction+0x1520>
movslq %r13d,%r12
movslq %ebp,%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
mov    0x18(%rsp),%rsi
add    %rsi,%r10
lea    (%rdx,%r10,1),%rcx
add    $0x1,%rcx
mov    %rcx,0x8(%rsp)
add    %rsi,%rax
lea    (%rdx,%rax,1),%r9
add    $0x1,%r9
mov    %edx,%r11d
and    $0xfffffff0,%r11d
mov    %edx,%r13d
and    $0xfffffff8,%r13d
mov    0x20(%rsp),%rax
lea    (%rax,%r10,1),%rdi
add    $0x1,%rdi
xor    %r8d,%r8d
pxor   %xmm11,%xmm11
movdqa 0x142b(%rip),%xmm8
pcmpeqd %xmm9,%xmm9
movdqa 0x142d(%rip),%xmm10
jmp    1c18 <form_component_prediction+0xb08>
cs nopw 0x0(%rax,%rax,1)
nop
add    %r12,%r14
add    %r12,%r15
add    $0x1,%r8
add    %r12,%rdi
cmp    0x4(%rsp),%r8d
je     2630 <form_component_prediction+0x1520>
cmpl   $0x0,(%rsp)
jle    1c00 <form_component_prediction+0xaf0>
cmpl   $0x8,(%rsp)
jae    1c30 <form_component_prediction+0xb20>
xor    %esi,%esi
jmp    1f90 <form_component_prediction+0xe80>
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    0x20(%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    1c9a <form_component_prediction+0xb8a>
mov    $0x0,%esi
and    %al,%bl
jne    1f90 <form_component_prediction+0xe80>
cmpl   $0x10,(%rsp)
jae    1ca1 <form_component_prediction+0xb91>
xor    %ebx,%ebx
jmp    1e90 <form_component_prediction+0xd80>
xor    %esi,%esi
jmp    1f90 <form_component_prediction+0xe80>
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    1cb0 <form_component_prediction+0xba0>
cmp    %rdx,%r11
je     1c00 <form_component_prediction+0xaf0>
mov    %r11,%rbx
mov    %r11,%rsi
test   $0x8,%dl
je     1f90 <form_component_prediction+0xe80>
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    1e90 <form_component_prediction+0xd80>
mov    %r13,%rsi
cmp    %rdx,%r13
je     1c00 <form_component_prediction+0xaf0>
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    1f90 <form_component_prediction+0xe80>
jmp    1c00 <form_component_prediction+0xaf0>
cmpl   $0x0,0x4(%rsp)
jle    2630 <form_component_prediction+0x1520>
movslq %r13d,%r9
movslq %ebp,%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
mov    0x18(%rsp),%rdi
add    %rdi,%rcx
lea    (%rcx,%rdx,1),%rsi
mov    %rsi,0x38(%rsp)
add    %rdi,%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,0x18(%rsp)
mov    0x20(%rsp),%rax
lea    (%rax,%rcx,1),%rsi
add    $0x10,%rsi
mov    %rcx,0x30(%rsp)
lea    (%rax,%rcx,1),%rdi
xor    %r10d,%r10d
jmp    207b <form_component_prediction+0xf6b>
cs nopw 0x0(%rax,%rax,1)
nop
add    %r9,%r14
add    %r9,%r15
add    $0x1,%r10
add    %r9,%rsi
add    %r9,%rdi
cmp    0x4(%rsp),%r10d
je     2630 <form_component_prediction+0x1520>
cmpl   $0x0,(%rsp)
jle    2060 <form_component_prediction+0xf50>
cmpl   $0x8,(%rsp)
jb     2100 <form_component_prediction+0xff0>
mov    %r10,%rcx
imul   %r9,%rcx
mov    0x10(%rsp),%rax
add    %rcx,%rax
add    0x28(%rsp),%rax
mov    0x30(%rsp),%rbp
lea    (%rcx,%rbp,1),%r8
mov    0x20(%rsp),%rbx
add    %rbx,%r8
mov    0x38(%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    2100 <form_component_prediction+0xff0>
mov    $0x0,%ecx
and    %r8b,%bl
jne    2102 <form_component_prediction+0xff2>
cmpl   $0x20,(%rsp)
jae    2179 <form_component_prediction+0x1069>
xor    %ebx,%ebx
jmp    21d0 <form_component_prediction+0x10c0>
nopw   0x0(%rax,%rax,1)
xor    %ecx,%ecx
mov    %rcx,%rbx
test   $0x1,%dl
je     212e <form_component_prediction+0x101e>
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    0x18(%rsp),%rcx
je     2060 <form_component_prediction+0xf50>
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    2140 <form_component_prediction+0x1030>
jmp    2060 <form_component_prediction+0xf50>
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    2180 <form_component_prediction+0x1070>
cmp    %rdx,%r12
je     2060 <form_component_prediction+0xf50>
mov    %r12,%rbx
mov    %r12,%rcx
test   $0x18,%dl
je     2102 <form_component_prediction+0xff2>
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    21d0 <form_component_prediction+0x10c0>
mov    %r13,%rcx
cmp    %rdx,%r13
je     2060 <form_component_prediction+0xf50>
jmp    2102 <form_component_prediction+0xff2>
cmpl   $0x0,0x4(%rsp)
jle    2630 <form_component_prediction+0x1520>
movslq %r13d,%r10
mov    (%rsp),%ecx
mov    0x10(%rsp),%r12
add    %r8,%r12
add    %rcx,%r12
mov    0x8(%rsp),%rax
add    %r8,%rax
add    0x18(%rsp),%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    2264 <form_component_prediction+0x1154>
cs nopw 0x0(%rax,%rax,1)
add    %r10,%r14
add    %r10,%r15
add    $0x1,%rbx
cmp    0x4(%rsp),%ebx
je     2630 <form_component_prediction+0x1520>
cmpl   $0x0,(%rsp)
jle    2250 <form_component_prediction+0x1140>
cmpl   $0x8,(%rsp)
jb     2292 <form_component_prediction+0x1182>
mov    %rbx,%rdx
imul   %r10,%rdx
lea    (%r8,%rdx,1),%rdi
add    0x20(%rsp),%rdi
cmp    %rdi,%r15
jae    22ff <form_component_prediction+0x11ef>
add    %r12,%rdx
add    0x28(%rsp),%rdx
cmp    %rdx,%r14
jae    22ff <form_component_prediction+0x11ef>
xor    %edi,%edi
mov    %rdi,%rdx
test   $0x1,%cl
je     22b8 <form_component_prediction+0x11a8>
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     2250 <form_component_prediction+0x1140>
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    22c0 <form_component_prediction+0x11b0>
jmp    2250 <form_component_prediction+0x1140>
cmpl   $0x20,(%rsp)
jae    2309 <form_component_prediction+0x11f9>
xor    %edx,%edx
jmp    2370 <form_component_prediction+0x1260>
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    2310 <form_component_prediction+0x1200>
cmp    %rcx,%r11
je     2250 <form_component_prediction+0x1140>
mov    %r11,%rdx
mov    %r11,%rdi
test   $0x18,%cl
je     2294 <form_component_prediction+0x1184>
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    2370 <form_component_prediction+0x1260>
mov    %rbp,%rdi
cmp    %rcx,%rbp
je     2250 <form_component_prediction+0x1140>
jmp    2294 <form_component_prediction+0x1184>
cmpl   $0x0,0x4(%rsp)
jle    2630 <form_component_prediction+0x1520>
movslq %r13d,%r12
movslq %ebp,%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
mov    0x18(%rsp),%rsi
add    %rsi,%r10
lea    (%rdx,%r10,1),%rcx
add    $0x1,%rcx
mov    %rcx,0x8(%rsp)
add    %rsi,%rax
add    %rdx,%rax
add    $0x1,%rax
mov    %rax,0x18(%rsp)
mov    %edx,%r11d
and    $0xfffffff0,%r11d
mov    %edx,%r13d
and    $0xfffffff8,%r13d
mov    0x20(%rsp),%rax
lea    (%rax,%r10,1),%rdi
add    $0x1,%rdi
xor    %r9d,%r9d
pxor   %xmm0,%xmm0
movdqa 0xc11(%rip),%xmm8
movdqa 0xbd9(%rip),%xmm2
jmp    2448 <form_component_prediction+0x1338>
nopl   0x0(%rax)
add    %r12,%r14
add    %r12,%r15
add    $0x1,%r9
add    %r12,%rdi
cmp    0x4(%rsp),%r9d
je     2630 <form_component_prediction+0x1520>
cmpl   $0x0,(%rsp)
jle    2430 <form_component_prediction+0x1320>
cmpl   $0x8,(%rsp)
jae    24a0 <form_component_prediction+0x1390>
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    2460 <form_component_prediction+0x1350>
jmp    2430 <form_component_prediction+0x1320>
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    0x20(%rsp),%rcx
add    %rcx,%rbx
mov    0x8(%rsp),%rbp
add    %rax,%rbp
add    %rcx,%rbp
add    0x18(%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    2576 <form_component_prediction+0x1466>
mov    $0x0,%esi
and    %al,%bl
jne    2460 <form_component_prediction+0x1350>
cmpl   $0x10,(%rsp)
jae    257d <form_component_prediction+0x146d>
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    2510 <form_component_prediction+0x1400>
mov    %r13,%rsi
cmp    %rdx,%r13
jne    2460 <form_component_prediction+0x1350>
jmp    2430 <form_component_prediction+0x1320>
xor    %esi,%esi
jmp    2460 <form_component_prediction+0x1350>
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    2580 <form_component_prediction+0x1470>
cmp    %rdx,%r11
je     2430 <form_component_prediction+0x1320>
mov    %r11,%rbx
mov    %r11,%rsi
test   $0x8,%dl
je     2460 <form_component_prediction+0x1350>
jmp    2510 <form_component_prediction+0x1400>
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [5 x i8] c"s!=d\00"
@.str.1 = [12 x i8] c"src/recon.c\00"
@.str.2 = [26 x i8] c"form_component_prediction\00"
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*
%32 = alloca i32
%33 = alloca i32
%34 = alloca i32
%35 = alloca i32
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
%36 = load i32, i32* %20
%37 = ashr i32 %36, 1
store i32 %37, i32* %23
%38 = load i32, i32* %21
%39 = ashr i32 %38, 1
store i32 %39, i32* %24
%40 = load i8*, i8** %12
%41 = load i32, i32* %14
%42 = load i32, i32* %19
%43 = load i32, i32* %24
%44 = add nsw i32 %42, %43
%45 = mul nsw i32 %41, %44
%46 = sext i32 %45 to i64
%47 = getelementptr inbounds i8, i8* %40, i64 %46
%48 = load i32, i32* %18
%49 = sext i32 %48 to i64
%50 = getelementptr inbounds i8, i8* %47, i64 %49
%51 = load i32, i32* %23
%52 = sext i32 %51 to i64
%53 = getelementptr inbounds i8, i8* %50, i64 %52
store i8* %53, i8** %30
%54 = load i8*, i8** %13
%55 = load i32, i32* %14
%56 = load i32, i32* %19
%57 = mul nsw i32 %55, %56
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds i8, i8* %54, i64 %58
%60 = load i32, i32* %18
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds i8, i8* %59, i64 %61
store i8* %62, i8** %31
%63 = load i32, i32* %20
%64 = and i32 %63, 1
store i32 %64, i32* %25
%65 = load i32, i32* %21
%66 = and i32 %65, 1
store i32 %66, i32* %26
%67 = load i8*, i8** %30
%68 = ptrtoint i8* %67 to i64
%69 = load i8*, i8** %31
%70 = ptrtoint i8* %69 to i64
%71 = icmp ne i64 %68, %70
br i1 %71, label %74, label %72
72: ; preds = %11
%73 = call i32 @__assert_fail(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.1, i64 0, i64 0), i32 474, i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.2, i64 0, i64 0))
br label %74
74: ; preds = %72, %11
%75 = load i32, i32* %25
%76 = icmp ne i32 %75, 0
br i1 %76, label %172, label %77
77: ; preds = %74
%78 = load i32, i32* %26
%79 = icmp ne i32 %78, 0
br i1 %79, label %170, label %80
80: ; preds = %77
%81 = load i32, i32* %22
%82 = icmp ne i32 %81, 0
br i1 %82, label %83, label %135
83: ; preds = %80
store i32 0, i32* %28
br label %84
84: ; preds = %123, %83
%85 = load i32, i32* %28
%86 = load i32, i32* %17
%87 = icmp slt i32 %85, %86
br i1 %87, label %88, label %134
88: ; preds = %84
store i32 0, i32* %27
br label %89
89: ; preds = %111, %88
%90 = load i32, i32* %27
%91 = load i32, i32* %16
%92 = icmp slt i32 %90, %91
br i1 %92, label %93, label %123
93: ; preds = %89
%94 = load i8*, i8** %31
%95 = load i32, i32* %27
%96 = sext i32 %95 to i64
%97 = getelementptr inbounds i8, i8* %94, i64 %96
%98 = load i8, i8* %97
%99 = zext i8 %98 to i32
%100 = load i8*, i8** %30
%101 = load i32, i32* %27
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds i8, i8* %100, i64 %102
%104 = load i8, i8* %103
%105 = zext i8 %104 to i32
%106 = add nsw i32 %99, %105
store i32 %106, i32* %29
%107 = load i32, i32* %29
%108 = icmp sge i32 %107, 0
br i1 %108, label %109, label %110
109: ; preds = %93
store i32 1, i32* %32
br label %111
110: ; preds = %93
store i32 0, i32* %32
br label %111
111: ; preds = %110, %109
%112 = load i32, i32* %29
%113 = load i32, i32* %32
%114 = add nsw i32 %112, %113
%115 = ashr i32 %114, 1
%116 = trunc i32 %115 to i8
%117 = load i8*, i8** %31
%118 = load i32, i32* %27
%119 = sext i32 %118 to i64
%120 = getelementptr inbounds i8, i8* %117, i64 %119
store i8 %116, i8* %120
%121 = load i32, i32* %27
%122 = add nsw i32 %121, 1
store i32 %122, i32* %27
br label %89
123: ; preds = %89
%124 = load i32, i32* %15
%125 = load i8*, i8** %30
%126 = sext i32 %124 to i64
%127 = getelementptr inbounds i8, i8* %125, i64 %126
store i8* %127, i8** %30
%128 = load i32, i32* %15
%129 = load i8*, i8** %31
%130 = sext i32 %128 to i64
%131 = getelementptr inbounds i8, i8* %129, i64 %130
store i8* %131, i8** %31
%132 = load i32, i32* %28
%133 = add nsw i32 %132, 1
store i32 %133, i32* %28
br label %84
134: ; preds = %84
br label %169
135: ; preds = %80
store i32 0, i32* %28
br label %136
136: ; preds = %157, %135
%137 = load i32, i32* %28
%138 = load i32, i32* %17
%139 = icmp slt i32 %137, %138
br i1 %139, label %140, label %168
140: ; preds = %136
store i32 0, i32* %27
br label %141
141: ; preds = %145, %140
%142 = load i32, i32* %27
%143 = load i32, i32* %16
%144 = icmp slt i32 %142, %143
br i1 %144, label %145, label %157
145: ; preds = %141
%146 = load i8*, i8** %30
%147 = load i32, i32* %27
%148 = sext i32 %147 to i64
%149 = getelementptr inbounds i8, i8* %146, i64 %148
%150 = load i8, i8* %149
%151 = load i8*, i8** %31
%152 = load i32, i32* %27
%153 = sext i32 %152 to i64
%154 = getelementptr inbounds i8, i8* %151, i64 %153
store i8 %150, i8* %154
%155 = load i32, i32* %27
%156 = add nsw i32 %155, 1
store i32 %156, i32* %27
br label %141
157: ; preds = %141
%158 = load i32, i32* %15
%159 = load i8*, i8** %30
%160 = sext i32 %158 to i64
%161 = getelementptr inbounds i8, i8* %159, i64 %160
store i8* %161, i8** %30
%162 = load i32, i32* %15
%163 = load i8*, i8** %31
%164 = sext i32 %162 to i64
%165 = getelementptr inbounds i8, i8* %163, i64 %164
store i8* %165, i8** %31
%166 = load i32, i32* %28
%167 = add nsw i32 %166, 1
store i32 %167, i32* %28
br label %136
168: ; preds = %136
br label %169
169: ; preds = %168, %134
br label %171
170: ; preds = %77
br label %173
171: ; preds = %169
br label %569
172: ; preds = %74
br label %173
173: ; preds = %172, %170
%174 = load i32, i32* %25
%175 = icmp ne i32 %174, 0
br i1 %175, label %295, label %176
176: ; preds = %173
%177 = load i32, i32* %26
%178 = icmp ne i32 %177, 0
br i1 %178, label %179, label %293
179: ; preds = %176
%180 = load i32, i32* %22
%181 = icmp ne i32 %180, 0
br i1 %181, label %182, label %245
182: ; preds = %179
store i32 0, i32* %28
br label %183
183: ; preds = %233, %182
%184 = load i32, i32* %28
%185 = load i32, i32* %17
%186 = icmp slt i32 %184, %185
br i1 %186, label %187, label %244
187: ; preds = %183
store i32 0, i32* %27
br label %188
188: ; preds = %221, %187
%189 = load i32, i32* %27
%190 = load i32, i32* %16
%191 = icmp slt i32 %189, %190
br i1 %191, label %192, label %233
192: ; preds = %188
%193 = load i8*, i8** %31
%194 = load i32, i32* %27
%195 = sext i32 %194 to i64
%196 = getelementptr inbounds i8, i8* %193, i64 %195
%197 = load i8, i8* %196
%198 = zext i8 %197 to i32
%199 = load i8*, i8** %30
%200 = load i32, i32* %27
%201 = sext i32 %200 to i64
%202 = getelementptr inbounds i8, i8* %199, i64 %201
%203 = load i8, i8* %202
%204 = zext i8 %203 to i32
%205 = load i8*, i8** %30
%206 = load i32, i32* %27
%207 = load i32, i32* %14
%208 = add nsw i32 %206, %207
%209 = sext i32 %208 to i64
%210 = getelementptr inbounds i8, i8* %205, i64 %209
%211 = load i8, i8* %210
%212 = zext i8 %211 to i32
%213 = add nsw i32 %204, %212
%214 = add nsw i32 %213, 1
%215 = lshr i32 %214, 1
%216 = add i32 %198, %215
store i32 %216, i32* %29
%217 = load i32, i32* %29
%218 = icmp sge i32 %217, 0
br i1 %218, label %219, label %220
219: ; preds = %192
store i32 1, i32* %33
br label %221
220: ; preds = %192
store i32 0, i32* %33
br label %221
221: ; preds = %220, %219
%222 = load i32, i32* %29
%223 = load i32, i32* %33
%224 = add nsw i32 %222, %223
%225 = ashr i32 %224, 1
%226 = trunc i32 %225 to i8
%227 = load i8*, i8** %31
%228 = load i32, i32* %27
%229 = sext i32 %228 to i64
%230 = getelementptr inbounds i8, i8* %227, i64 %229
store i8 %226, i8* %230
%231 = load i32, i32* %27
%232 = add nsw i32 %231, 1
store i32 %232, i32* %27
br label %188
233: ; preds = %188
%234 = load i32, i32* %15
%235 = load i8*, i8** %30
%236 = sext i32 %234 to i64
%237 = getelementptr inbounds i8, i8* %235, i64 %236
store i8* %237, i8** %30
%238 = load i32, i32* %15
%239 = load i8*, i8** %31
%240 = sext i32 %238 to i64
%241 = getelementptr inbounds i8, i8* %239, i64 %240
store i8* %241, i8** %31
%242 = load i32, i32* %28
%243 = add nsw i32 %242, 1
store i32 %243, i32* %28
br label %183
244: ; preds = %183
br label %292
245: ; preds = %179
store i32 0, i32* %28
br label %246
246: ; preds = %280, %245
%247 = load i32, i32* %28
%248 = load i32, i32* %17
%249 = icmp slt i32 %247, %248
br i1 %249, label %250, label %291
250: ; preds = %246
store i32 0, i32* %27
br label %251
251: ; preds = %255, %250
%252 = load i32, i32* %27
%253 = load i32, i32* %16
%254 = icmp slt i32 %252, %253
br i1 %254, label %255, label %280
255: ; preds = %251
%256 = load i8*, i8** %30
%257 = load i32, i32* %27
%258 = sext i32 %257 to i64
%259 = getelementptr inbounds i8, i8* %256, i64 %258
%260 = load i8, i8* %259
%261 = zext i8 %260 to i32
%262 = load i8*, i8** %30
%263 = load i32, i32* %27
%264 = load i32, i32* %14
%265 = add nsw i32 %263, %264
%266 = sext i32 %265 to i64
%267 = getelementptr inbounds i8, i8* %262, i64 %266
%268 = load i8, i8* %267
%269 = zext i8 %268 to i32
%270 = add nsw i32 %261, %269
%271 = add nsw i32 %270, 1
%272 = lshr i32 %271, 1
%273 = trunc i32 %272 to i8
%274 = load i8*, i8** %31
%275 = load i32, i32* %27
%276 = sext i32 %275 to i64
%277 = getelementptr inbounds i8, i8* %274, i64 %276
store i8 %273, i8* %277
%278 = load i32, i32* %27
%279 = add nsw i32 %278, 1
store i32 %279, i32* %27
br label %251
280: ; preds = %251
%281 = load i32, i32* %15
%282 = load i8*, i8** %30
%283 = sext i32 %281 to i64
%284 = getelementptr inbounds i8, i8* %282, i64 %283
store i8* %284, i8** %30
%285 = load i32, i32* %15
%286 = load i8*, i8** %31
%287 = sext i32 %285 to i64
%288 = getelementptr inbounds i8, i8* %286, i64 %287
store i8* %288, i8** %31
%289 = load i32, i32* %28
%290 = add nsw i32 %289, 1
store i32 %290, i32* %28
br label %246
291: ; preds = %246
br label %292
292: ; preds = %291, %244
br label %294
293: ; preds = %176
br label %296
294: ; preds = %292
br label %568
295: ; preds = %173
br label %296
296: ; preds = %295, %293
%297 = load i32, i32* %25
%298 = icmp ne i32 %297, 0
br i1 %298, label %299, label %416
299: ; preds = %296
%300 = load i32, i32* %26
%301 = icmp ne i32 %300, 0
br i1 %301, label %414, label %302
302: ; preds = %299
%303 = load i32, i32* %22
%304 = icmp ne i32 %303, 0
br i1 %304, label %305, label %367
305: ; preds = %302
store i32 0, i32* %28
br label %306
306: ; preds = %355, %305
%307 = load i32, i32* %28
%308 = load i32, i32* %17
%309 = icmp slt i32 %307, %308
br i1 %309, label %310, label %366
310: ; preds = %306
store i32 0, i32* %27
br label %311
311: ; preds = %343, %310
%312 = load i32, i32* %27
%313 = load i32, i32* %16
%314 = icmp slt i32 %312, %313
br i1 %314, label %315, label %355
315: ; preds = %311
%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 = icmp sge i32 %339, 0
br i1 %340, label %341, label %342
341: ; preds = %315
store i32 1, i32* %34
br label %343
342: ; preds = %315
store i32 0, i32* %34
br label %343
343: ; preds = %342, %341
%344 = load i32, i32* %29
%345 = load i32, i32* %34
%346 = add nsw i32 %344, %345
%347 = ashr i32 %346, 1
%348 = trunc i32 %347 to i8
%349 = load i8*, i8** %31
%350 = load i32, i32* %27
%351 = sext i32 %350 to i64
%352 = getelementptr inbounds i8, i8* %349, i64 %351
store i8 %348, i8* %352
%353 = load i32, i32* %27
%354 = add nsw i32 %353, 1
store i32 %354, i32* %27
br label %311
355: ; preds = %311
%356 = load i32, i32* %15
%357 = load i8*, i8** %30
%358 = sext i32 %356 to i64
%359 = getelementptr inbounds i8, i8* %357, i64 %358
store i8* %359, i8** %30
%360 = load i32, i32* %15
%361 = load i8*, i8** %31
%362 = sext i32 %360 to i64
%363 = getelementptr inbounds i8, i8* %361, i64 %362
store i8* %363, i8** %31
%364 = load i32, i32* %28
%365 = add nsw i32 %364, 1
store i32 %365, i32* %28
br label %306
366: ; preds = %306
br label %413
367: ; preds = %302
store i32 0, i32* %28
br label %368
368: ; preds = %401, %367
%369 = load i32, i32* %28
%370 = load i32, i32* %17
%371 = icmp slt i32 %369, %370
br i1 %371, label %372, label %412
372: ; preds = %368
store i32 0, i32* %27
br label %373
373: ; preds = %377, %372
%374 = load i32, i32* %27
%375 = load i32, i32* %16
%376 = icmp slt i32 %374, %375
br i1 %376, label %377, label %401
377: ; preds = %373
%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 %373
401: ; preds = %373
%402 = load i32, i32* %15
%403 = load i8*, i8** %30
%404 = sext i32 %402 to i64
%405 = getelementptr inbounds i8, i8* %403, i64 %404
store i8* %405, i8** %30
%406 = load i32, i32* %15
%407 = load i8*, i8** %31
%408 = sext i32 %406 to i64
%409 = getelementptr inbounds i8, i8* %407, 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 %368
412: ; preds = %368
br label %413
413: ; preds = %412, %366
br label %415
414: ; preds = %299
br label %417
415: ; preds = %413
br label %567
416: ; preds = %296
br label %417
417: ; preds = %416, %414
%418 = load i32, i32* %22
%419 = icmp ne i32 %418, 0
br i1 %419, label %420, label %501
420: ; preds = %417
store i32 0, i32* %28
br label %421
421: ; preds = %489, %420
%422 = load i32, i32* %28
%423 = load i32, i32* %17
%424 = icmp slt i32 %422, %423
br i1 %424, label %425, label %500
425: ; preds = %421
store i32 0, i32* %27
br label %426
426: ; preds = %477, %425
%427 = load i32, i32* %27
%428 = load i32, i32* %16
%429 = icmp slt i32 %427, %428
br i1 %429, label %430, label %489
430: ; preds = %426
%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 = icmp sge i32 %473, 0
br i1 %474, label %475, label %476
475: ; preds = %430
store i32 1, i32* %35
br label %477
476: ; preds = %430
store i32 0, i32* %35
br label %477
477: ; preds = %476, %475
%478 = load i32, i32* %29
%479 = load i32, i32* %35
%480 = add nsw i32 %478, %479
%481 = ashr i32 %480, 1
%482 = trunc i32 %481 to i8
%483 = load i8*, i8** %31
%484 = load i32, i32* %27
%485 = sext i32 %484 to i64
%486 = getelementptr inbounds i8, i8* %483, i64 %485
store i8 %482, i8* %486
%487 = load i32, i32* %27
%488 = add nsw i32 %487, 1
store i32 %488, i32* %27
br label %426
489: ; preds = %426
%490 = load i32, i32* %15
%491 = load i8*, i8** %30
%492 = sext i32 %490 to i64
%493 = getelementptr inbounds i8, i8* %491, i64 %492
store i8* %493, i8** %30
%494 = load i32, i32* %15
%495 = load i8*, i8** %31
%496 = sext i32 %494 to i64
%497 = getelementptr inbounds i8, i8* %495, i64 %496
store i8* %497, i8** %31
%498 = load i32, i32* %28
%499 = add nsw i32 %498, 1
store i32 %499, i32* %28
br label %421
500: ; preds = %421
br label %566
501: ; preds = %417
store i32 0, i32* %28
br label %502
502: ; preds = %554, %501
%503 = load i32, i32* %28
%504 = load i32, i32* %17
%505 = icmp slt i32 %503, %504
br i1 %505, label %506, label %565
506: ; preds = %502
store i32 0, i32* %27
br label %507
507: ; preds = %511, %506
%508 = load i32, i32* %27
%509 = load i32, i32* %16
%510 = icmp slt i32 %508, %509
br i1 %510, label %511, label %554
511: ; preds = %507
%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 %507
554: ; preds = %507
%555 = load i32, i32* %15
%556 = load i8*, i8** %30
%557 = sext i32 %555 to i64
%558 = getelementptr inbounds i8, i8* %556, i64 %557
store i8* %558, i8** %30
%559 = load i32, i32* %15
%560 = load i8*, i8** %31
%561 = sext i32 %559 to i64
%562 = getelementptr inbounds i8, i8* %560, 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 %502
565: ; preds = %502
br label %566
566: ; preds = %565, %500
br label %567
567: ; preds = %566, %415
br label %568
568: ; preds = %567, %294
br label %569
569: ; preds = %568, %171
ret void
}

LLVM IR (-O2):
@.str = [5 x i8] c"s!=d\00"
@.str.1 = [12 x i8] c"src/recon.c\00"
@.str.2 = [26 x i8] c"form_component_prediction\00"
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_fail(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.1, i64 0, i64 0), i32 474, i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.2, i64 0, i64 0))
br label %31
31: ; preds = %29, %11
%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 %1311
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 %1311
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 %1311, 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 %1311, label %205
344: ; preds = %31
%345 = icmp eq i32 %26, 0
%346 = and i1 %345, %32
br i1 %346, label %347, label %685
347: ; preds = %344
%348 = icmp eq i32 %10, 0
%349 = icmp sgt i32 %5, 0
br i1 %348, label %375, label %350
350: ; preds = %347
br i1 %349, label %351, label %1311
351: ; preds = %350
%352 = icmp sgt i32 %4, 0
%353 = sext i32 %3 to i64
%354 = sext i32 %2 to i64
%355 = zext i32 %4 to i64
%356 = add nsw i64 %18, %23
%357 = add nsw i64 %356, %355
%358 = add nsw i64 %20, %18
%359 = add nsw i64 %358, %354
%360 = add nsw i64 %359, %16
%361 = add nsw i64 %360, %355
%362 = add nsw i64 %358, %16
%363 = add nsw i64 %362, %355
%364 = icmp ult i32 %4, 8
%365 = icmp ult i32 %4, 16
%366 = and i64 %355, 4294967280
%367 = icmp eq i64 %366, %355
%368 = and i64 %355, 8
%369 = icmp eq i64 %368, 0
%370 = and i64 %355, 4294967288
%371 = icmp eq i64 %370, %355
%372 = and i64 %355, 1
%373 = icmp eq i64 %372, 0
%374 = sub nsw i64 0, %355
br label %400
375: ; preds = %347
br i1 %349, label %376, label %1311
376: ; preds = %375
%377 = icmp sgt i32 %4, 0
%378 = sext i32 %3 to i64
%379 = sext i32 %2 to i64
%380 = zext i32 %4 to i64
%381 = add nsw i64 %18, %23
%382 = add nsw i64 %381, %380
%383 = add nsw i64 %20, %18
%384 = add nsw i64 %383, %379
%385 = add nsw i64 %384, %16
%386 = add nsw i64 %385, %380
%387 = add nsw i64 %383, %16
%388 = add nsw i64 %387, %380
%389 = icmp ult i32 %4, 8
%390 = icmp ult i32 %4, 32
%391 = and i64 %380, 4294967264
%392 = icmp eq i64 %391, %380
%393 = and i64 %380, 24
%394 = icmp eq i64 %393, 0
%395 = and i64 %380, 4294967288
%396 = icmp eq i64 %395, %380
%397 = and i64 %380, 1
%398 = icmp eq i64 %397, 0
%399 = sub nsw i64 0, %380
br label %549
400: ; preds = %351, %543
%401 = phi i64 [ 0, %351 ], [ %548, %543 ]
%402 = phi i8* [ %25, %351 ], [ %545, %543 ]
%403 = phi i8* [ %21, %351 ], [ %544, %543 ]
%404 = phi i32 [ 0, %351 ], [ %546, %543 ]
%405 = mul i64 %401, %353
%406 = add i64 %357, %405
%407 = getelementptr i8, i8* %1, i64 %406
%408 = add i64 %360, %405
%409 = getelementptr i8, i8* %0, i64 %408
%410 = add i64 %361, %405
%411 = getelementptr i8, i8* %0, i64 %410
%412 = add i64 %363, %405
%413 = getelementptr i8, i8* %0, i64 %412
br i1 %352, label %414, label %543
414: ; preds = %400
br i1 %364, label %479, label %415
415: ; preds = %414
%416 = icmp ult i8* %402, %411
%417 = icmp ult i8* %409, %407
%418 = and i1 %416, %417
%419 = icmp ult i8* %402, %413
%420 = icmp ult i8* %403, %407
%421 = and i1 %419, %420
%422 = or i1 %418, %421
br i1 %422, label %479, label %423
423: ; preds = %415
br i1 %365, label %451, label %424
424: ; preds = %423, %424
%425 = phi i64 [ %447, %424 ], [ 0, %423 ]
%426 = getelementptr inbounds i8, i8* %402, i64 %425
%427 = bitcast i8* %426 to <16 x i8>*
%428 = load <16 x i8>, <16 x i8>* %427
%429 = zext <16 x i8> %428 to <16 x i16>
%430 = getelementptr inbounds i8, i8* %403, i64 %425
%431 = bitcast i8* %430 to <16 x i8>*
%432 = load <16 x i8>, <16 x i8>* %431
%433 = zext <16 x i8> %432 to <16 x i16>
%434 = add nsw i64 %425, %354
%435 = getelementptr inbounds i8, i8* %403, i64 %434
%436 = bitcast i8* %435 to <16 x i8>*
%437 = load <16 x i8>, <16 x i8>* %436
%438 = zext <16 x i8> %437 to <16 x i16>
%439 = add nuw nsw <16 x i16> %433, <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>
%440 = add nuw nsw <16 x i16> %439, %438
%441 = lshr <16 x i16> %440, <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>
%442 = add nuw nsw <16 x i16> %429, <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
%443 = add nuw nsw <16 x i16> %442, %441
%444 = lshr <16 x i16> %443, <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>
%445 = trunc <16 x i16> %444 to <16 x i8>
%446 = bitcast i8* %426 to <16 x i8>*
store <16 x i8> %445, <16 x i8>* %446
%447 = add nuw i64 %425, 16
%448 = icmp eq i64 %447, %366
br i1 %448, label %449, label %424
449: ; preds = %424
br i1 %367, label %543, label %450
450: ; preds = %449
br i1 %369, label %479, label %451
451: ; preds = %423, %450
%452 = phi i64 [ %366, %450 ], [ 0, %423 ]
br label %453
453: ; preds = %453, %451
%454 = phi i64 [ %452, %451 ], [ %476, %453 ]
%455 = getelementptr inbounds i8, i8* %402, i64 %454
%456 = bitcast i8* %455 to <8 x i8>*
%457 = load <8 x i8>, <8 x i8>* %456
%458 = zext <8 x i8> %457 to <8 x i16>
%459 = getelementptr inbounds i8, i8* %403, i64 %454
%460 = bitcast i8* %459 to <8 x i8>*
%461 = load <8 x i8>, <8 x i8>* %460
%462 = zext <8 x i8> %461 to <8 x i16>
%463 = add nsw i64 %454, %354
%464 = getelementptr inbounds i8, i8* %403, i64 %463
%465 = bitcast i8* %464 to <8 x i8>*
%466 = load <8 x i8>, <8 x i8>* %465
%467 = zext <8 x i8> %466 to <8 x i16>
%468 = add nuw nsw <8 x i16> %462, <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
%469 = add nuw nsw <8 x i16> %468, %467
%470 = lshr <8 x i16> %469, <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
%471 = add nuw nsw <8 x i16> %458, <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
%472 = add nuw nsw <8 x i16> %471, %470
%473 = lshr <8 x i16> %472, <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
%474 = trunc <8 x i16> %473 to <8 x i8>
%475 = bitcast i8* %455 to <8 x i8>*
store <8 x i8> %474, <8 x i8>* %475
%476 = add nuw i64 %454, 8
%477 = icmp eq i64 %476, %370
br i1 %477, label %478, label %453
478: ; preds = %453
br i1 %371, label %543, label %479
479: ; preds = %415, %414, %450, %478
%480 = phi i64 [ 0, %414 ], [ 0, %415 ], [ %366, %450 ], [ %370, %478 ]
%481 = xor i64 %480, -1
br i1 %373, label %501, label %482
482: ; preds = %479
%483 = getelementptr inbounds i8, i8* %402, i64 %480
%484 = load i8, i8* %483
%485 = zext i8 %484 to i16
%486 = getelementptr inbounds i8, i8* %403, i64 %480
%487 = load i8, i8* %486
%488 = zext i8 %487 to i16
%489 = add nsw i64 %480, %354
%490 = getelementptr inbounds i8, i8* %403, i64 %489
%491 = load i8, i8* %490
%492 = zext i8 %491 to i16
%493 = add nuw nsw i16 %488, 1
%494 = add nuw nsw i16 %493, %492
%495 = lshr i16 %494, 1
%496 = add nuw nsw i16 %485, 1
%497 = add nuw nsw i16 %496, %495
%498 = lshr i16 %497, 1
%499 = trunc i16 %498 to i8
store i8 %499, i8* %483
%500 = or i64 %480, 1
br label %501
501: ; preds = %482, %479
%502 = phi i64 [ %480, %479 ], [ %500, %482 ]
%503 = icmp eq i64 %481, %374
br i1 %503, label %543, label %504
504: ; preds = %501, %504
%505 = phi i64 [ %541, %504 ], [ %502, %501 ]
%506 = getelementptr inbounds i8, i8* %402, i64 %505
%507 = load i8, i8* %506
%508 = zext i8 %507 to i16
%509 = getelementptr inbounds i8, i8* %403, i64 %505
%510 = load i8, i8* %509
%511 = zext i8 %510 to i16
%512 = add nsw i64 %505, %354
%513 = getelementptr inbounds i8, i8* %403, i64 %512
%514 = load i8, i8* %513
%515 = zext i8 %514 to i16
%516 = add nuw nsw i16 %511, 1
%517 = add nuw nsw i16 %516, %515
%518 = lshr i16 %517, 1
%519 = add nuw nsw i16 %508, 1
%520 = add nuw nsw i16 %519, %518
%521 = lshr i16 %520, 1
%522 = trunc i16 %521 to i8
store i8 %522, i8* %506
%523 = add nuw nsw i64 %505, 1
%524 = getelementptr inbounds i8, i8* %402, i64 %523
%525 = load i8, i8* %524
%526 = zext i8 %525 to i16
%527 = getelementptr inbounds i8, i8* %403, i64 %523
%528 = load i8, i8* %527
%529 = zext i8 %528 to i16
%530 = add nsw i64 %523, %354
%531 = getelementptr inbounds i8, i8* %403, i64 %530
%532 = load i8, i8* %531
%533 = zext i8 %532 to i16
%534 = add nuw nsw i16 %529, 1
%535 = add nuw nsw i16 %534, %533
%536 = lshr i16 %535, 1
%537 = add nuw nsw i16 %526, 1
%538 = add nuw nsw i16 %537, %536
%539 = lshr i16 %538, 1
%540 = trunc i16 %539 to i8
store i8 %540, i8* %524
%541 = add nuw nsw i64 %505, 2
%542 = icmp eq i64 %541, %355
br i1 %542, label %543, label %504
543: ; preds = %501, %504, %449, %478, %400
%544 = getelementptr inbounds i8, i8* %403, i64 %353
%545 = getelementptr inbounds i8, i8* %402, i64 %353
%546 = add nuw nsw i32 %404, 1
%547 = icmp eq i32 %546, %5
%548 = add i64 %401, 1
br i1 %547, label %1311, label %400
549: ; preds = %376, %679
%550 = phi i64 [ 0, %376 ], [ %684, %679 ]
%551 = phi i8* [ %25, %376 ], [ %681, %679 ]
%552 = phi i8* [ %21, %376 ], [ %680, %679 ]
%553 = phi i32 [ 0, %376 ], [ %682, %679 ]
%554 = mul i64 %550, %378
%555 = add i64 %382, %554
%556 = getelementptr i8, i8* %1, i64 %555
%557 = add i64 %385, %554
%558 = getelementptr i8, i8* %0, i64 %557
%559 = add i64 %386, %554
%560 = getelementptr i8, i8* %0, i64 %559
%561 = add i64 %388, %554
%562 = getelementptr i8, i8* %0, i64 %561
br i1 %377, label %563, label %679
563: ; preds = %549
br i1 %389, label %630, label %564
564: ; preds = %563
%565 = icmp ult i8* %551, %560
%566 = icmp ult i8* %558, %556
%567 = and i1 %565, %566
%568 = icmp ult i8* %551, %562
%569 = icmp ult i8* %552, %556
%570 = and i1 %568, %569
%571 = or i1 %567, %570
br i1 %571, label %630, label %572
572: ; preds = %564
br i1 %390, label %608, label %573
573: ; preds = %572, %573
%574 = phi i64 [ %604, %573 ], [ 0, %572 ]
%575 = getelementptr inbounds i8, i8* %552, i64 %574
%576 = bitcast i8* %575 to <16 x i8>*
%577 = load <16 x i8>, <16 x i8>* %576
%578 = getelementptr inbounds i8, i8* %575, i64 16
%579 = bitcast i8* %578 to <16 x i8>*
%580 = load <16 x i8>, <16 x i8>* %579
%581 = zext <16 x i8> %577 to <16 x i16>
%582 = zext <16 x i8> %580 to <16 x i16>
%583 = add nsw i64 %574, %379
%584 = getelementptr inbounds i8, i8* %552, i64 %583
%585 = bitcast i8* %584 to <16 x i8>*
%586 = load <16 x i8>, <16 x i8>* %585
%587 = getelementptr inbounds i8, i8* %584, i64 16
%588 = bitcast i8* %587 to <16 x i8>*
%589 = load <16 x i8>, <16 x i8>* %588
%590 = zext <16 x i8> %586 to <16 x i16>
%591 = zext <16 x i8> %589 to <16 x i16>
%592 = add nuw nsw <16 x i16> %581, <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>
%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> %592, %590
%595 = add nuw nsw <16 x i16> %593, %591
%596 = lshr <16 x i16> %594, <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>
%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 = trunc <16 x i16> %596 to <16 x i8>
%599 = trunc <16 x i16> %597 to <16 x i8>
%600 = getelementptr inbounds i8, i8* %551, i64 %574
%601 = bitcast i8* %600 to <16 x i8>*
store <16 x i8> %598, <16 x i8>* %601
%602 = getelementptr inbounds i8, i8* %600, i64 16
%603 = bitcast i8* %602 to <16 x i8>*
store <16 x i8> %599, <16 x i8>* %603
%604 = add nuw i64 %574, 32
%605 = icmp eq i64 %604, %391
br i1 %605, label %606, label %573
606: ; preds = %573
br i1 %392, label %679, label %607
607: ; preds = %606
br i1 %394, label %630, label %608
608: ; preds = %572, %607
%609 = phi i64 [ %391, %607 ], [ 0, %572 ]
br label %610
610: ; preds = %610, %608
%611 = phi i64 [ %609, %608 ], [ %627, %610 ]
%612 = getelementptr inbounds i8, i8* %552, i64 %611
%613 = bitcast i8* %612 to <8 x i8>*
%614 = load <8 x i8>, <8 x i8>* %613
%615 = zext <8 x i8> %614 to <8 x i16>
%616 = add nsw i64 %611, %379
%617 = getelementptr inbounds i8, i8* %552, i64 %616
%618 = bitcast i8* %617 to <8 x i8>*
%619 = load <8 x i8>, <8 x i8>* %618
%620 = zext <8 x i8> %619 to <8 x i16>
%621 = add nuw nsw <8 x i16> %615, <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
%622 = add nuw nsw <8 x i16> %621, %620
%623 = lshr <8 x i16> %622, <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
%624 = trunc <8 x i16> %623 to <8 x i8>
%625 = getelementptr inbounds i8, i8* %551, i64 %611
%626 = bitcast i8* %625 to <8 x i8>*
store <8 x i8> %624, <8 x i8>* %626
%627 = add nuw i64 %611, 8
%628 = icmp eq i64 %627, %395
br i1 %628, label %629, label %610
629: ; preds = %610
br i1 %396, label %679, label %630
630: ; preds = %564, %563, %607, %629
%631 = phi i64 [ 0, %563 ], [ 0, %564 ], [ %391, %607 ], [ %395, %629 ]
%632 = xor i64 %631, -1
br i1 %398, label %647, label %633
633: ; preds = %630
%634 = getelementptr inbounds i8, i8* %552, i64 %631
%635 = load i8, i8* %634
%636 = zext i8 %635 to i16
%637 = add nsw i64 %631, %379
%638 = getelementptr inbounds i8, i8* %552, i64 %637
%639 = load i8, i8* %638
%640 = zext i8 %639 to i16
%641 = add nuw nsw i16 %636, 1
%642 = add nuw nsw i16 %641, %640
%643 = lshr i16 %642, 1
%644 = trunc i16 %643 to i8
%645 = getelementptr inbounds i8, i8* %551, i64 %631
store i8 %644, i8* %645
%646 = or i64 %631, 1
br label %647
647: ; preds = %633, %630
%648 = phi i64 [ %631, %630 ], [ %646, %633 ]
%649 = icmp eq i64 %632, %399
br i1 %649, label %679, label %650
650: ; preds = %647, %650
%651 = phi i64 [ %677, %650 ], [ %648, %647 ]
%652 = getelementptr inbounds i8, i8* %552, i64 %651
%653 = load i8, i8* %652
%654 = zext i8 %653 to i16
%655 = add nsw i64 %651, %379
%656 = getelementptr inbounds i8, i8* %552, i64 %655
%657 = load i8, i8* %656
%658 = zext i8 %657 to i16
%659 = add nuw nsw i16 %654, 1
%660 = add nuw nsw i16 %659, %658
%661 = lshr i16 %660, 1
%662 = trunc i16 %661 to i8
%663 = getelementptr inbounds i8, i8* %551, i64 %651
store i8 %662, i8* %663
%664 = add nuw nsw i64 %651, 1
%665 = getelementptr inbounds i8, i8* %552, i64 %664
%666 = load i8, i8* %665
%667 = zext i8 %666 to i16
%668 = add nsw i64 %664, %379
%669 = getelementptr inbounds i8, i8* %552, i64 %668
%670 = load i8, i8* %669
%671 = zext i8 %670 to i16
%672 = add nuw nsw i16 %667, 1
%673 = add nuw nsw i16 %672, %671
%674 = lshr i16 %673, 1
%675 = trunc i16 %674 to i8
%676 = getelementptr inbounds i8, i8* %551, i64 %664
store i8 %675, i8* %676
%677 = add nuw nsw i64 %651, 2
%678 = icmp eq i64 %677, %380
br i1 %678, label %679, label %650
679: ; preds = %647, %650, %606, %629, %549
%680 = getelementptr inbounds i8, i8* %552, i64 %378
%681 = getelementptr inbounds i8, i8* %551, i64 %378
%682 = add nuw nsw i32 %553, 1
%683 = icmp eq i32 %682, %5
%684 = add i64 %550, 1
br i1 %683, label %1311, label %549
685: ; preds = %344
%686 = or i1 %345, %32
%687 = icmp eq i32 %10, 0
%688 = icmp sgt i32 %5, 0
br i1 %686, label %997, label %689
689: ; preds = %685
br i1 %687, label %712, label %690
690: ; preds = %689
br i1 %688, label %691, label %1311
691: ; preds = %690
%692 = icmp sgt i32 %4, 0
%693 = sext i32 %3 to i64
%694 = zext i32 %4 to i64
%695 = add nsw i64 %18, %23
%696 = add nsw i64 %695, %694
%697 = add nsw i64 %20, %18
%698 = add nsw i64 %697, %16
%699 = add nsw i64 %698, %694
%700 = add nsw i64 %699, 1
%701 = icmp ult i32 %4, 8
%702 = icmp ult i32 %4, 16
%703 = and i64 %694, 4294967280
%704 = icmp eq i64 %703, %694
%705 = and i64 %694, 8
%706 = icmp eq i64 %705, 0
%707 = and i64 %694, 4294967288
%708 = icmp eq i64 %707, %694
%709 = and i64 %694, 1
%710 = icmp eq i64 %709, 0
%711 = sub nsw i64 0, %694
br label %734
712: ; preds = %689
br i1 %688, label %713, label %1311
713: ; preds = %712
%714 = icmp sgt i32 %4, 0
%715 = sext i32 %3 to i64
%716 = zext i32 %4 to i64
%717 = add nsw i64 %18, %23
%718 = add nsw i64 %717, %716
%719 = add nsw i64 %20, %18
%720 = add nsw i64 %719, %16
%721 = add nsw i64 %720, %716
%722 = add nsw i64 %721, 1
%723 = icmp ult i32 %4, 8
%724 = icmp ult i32 %4, 32
%725 = and i64 %716, 4294967264
%726 = icmp eq i64 %725, %716
%727 = and i64 %716, 24
%728 = icmp eq i64 %727, 0
%729 = and i64 %716, 4294967288
%730 = icmp eq i64 %729, %716
%731 = and i64 %716, 1
%732 = icmp eq i64 %731, 0
%733 = sub nsw i64 0, %716
br label %872
734: ; preds = %691, %866
%735 = phi i64 [ 0, %691 ], [ %871, %866 ]
%736 = phi i8* [ %25, %691 ], [ %868, %866 ]
%737 = phi i8* [ %21, %691 ], [ %867, %866 ]
%738 = phi i32 [ 0, %691 ], [ %869, %866 ]
%739 = mul i64 %735, %693
%740 = add i64 %696, %739
%741 = getelementptr i8, i8* %1, i64 %740
%742 = add i64 %700, %739
%743 = getelementptr i8, i8* %0, i64 %742
br i1 %692, label %744, label %866
744: ; preds = %734
br i1 %701, label %805, label %745
745: ; preds = %744
%746 = icmp ult i8* %736, %743
%747 = icmp ult i8* %737, %741
%748 = and i1 %746, %747
br i1 %748, label %805, label %749
749: ; preds = %745
br i1 %702, label %777, label %750
750: ; preds = %749, %750
%751 = phi i64 [ %773, %750 ], [ 0, %749 ]
%752 = getelementptr inbounds i8, i8* %736, i64 %751
%753 = bitcast i8* %752 to <16 x i8>*
%754 = load <16 x i8>, <16 x i8>* %753
%755 = zext <16 x i8> %754 to <16 x i16>
%756 = getelementptr inbounds i8, i8* %737, i64 %751
%757 = bitcast i8* %756 to <16 x i8>*
%758 = load <16 x i8>, <16 x i8>* %757
%759 = zext <16 x i8> %758 to <16 x i16>
%760 = or i64 %751, 1
%761 = getelementptr inbounds i8, i8* %737, i64 %760
%762 = bitcast i8* %761 to <16 x i8>*
%763 = load <16 x i8>, <16 x i8>* %762
%764 = zext <16 x i8> %763 to <16 x i16>
%765 = add nuw nsw <16 x i16> %759, <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>
%766 = add nuw nsw <16 x i16> %765, %764
%767 = lshr <16 x i16> %766, <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> %755, <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>
%769 = add nuw nsw <16 x i16> %768, %767
%770 = lshr <16 x i16> %769, <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 = trunc <16 x i16> %770 to <16 x i8>
%772 = bitcast i8* %752 to <16 x i8>*
store <16 x i8> %771, <16 x i8>* %772
%773 = add nuw i64 %751, 16
%774 = icmp eq i64 %773, %703
br i1 %774, label %775, label %750
775: ; preds = %750
br i1 %704, label %866, label %776
776: ; preds = %775
br i1 %706, label %805, label %777
777: ; preds = %749, %776
%778 = phi i64 [ %703, %776 ], [ 0, %749 ]
br label %779
779: ; preds = %779, %777
%780 = phi i64 [ %778, %777 ], [ %802, %779 ]
%781 = getelementptr inbounds i8, i8* %736, i64 %780
%782 = bitcast i8* %781 to <8 x i8>*
%783 = load <8 x i8>, <8 x i8>* %782
%784 = zext <8 x i8> %783 to <8 x i16>
%785 = getelementptr inbounds i8, i8* %737, i64 %780
%786 = bitcast i8* %785 to <8 x i8>*
%787 = load <8 x i8>, <8 x i8>* %786
%788 = zext <8 x i8> %787 to <8 x i16>
%789 = or i64 %780, 1
%790 = getelementptr inbounds i8, i8* %737, i64 %789
%791 = bitcast i8* %790 to <8 x i8>*
%792 = load <8 x i8>, <8 x i8>* %791
%793 = zext <8 x i8> %792 to <8 x i16>
%794 = add nuw nsw <8 x i16> %788, <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
%795 = add nuw nsw <8 x i16> %794, %793
%796 = lshr <8 x i16> %795, <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
%797 = add nuw nsw <8 x i16> %784, <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
%798 = add nuw nsw <8 x i16> %797, %796
%799 = lshr <8 x i16> %798, <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
%800 = trunc <8 x i16> %799 to <8 x i8>
%801 = bitcast i8* %781 to <8 x i8>*
store <8 x i8> %800, <8 x i8>* %801
%802 = add nuw i64 %780, 8
%803 = icmp eq i64 %802, %707
br i1 %803, label %804, label %779
804: ; preds = %779
br i1 %708, label %866, label %805
805: ; preds = %745, %744, %776, %804
%806 = phi i64 [ 0, %744 ], [ 0, %745 ], [ %703, %776 ], [ %707, %804 ]
%807 = xor i64 %806, -1
br i1 %710, label %826, label %808
808: ; preds = %805
%809 = getelementptr inbounds i8, i8* %736, i64 %806
%810 = load i8, i8* %809
%811 = zext i8 %810 to i16
%812 = getelementptr inbounds i8, i8* %737, i64 %806
%813 = load i8, i8* %812
%814 = zext i8 %813 to i16
%815 = or i64 %806, 1
%816 = getelementptr inbounds i8, i8* %737, i64 %815
%817 = load i8, i8* %816
%818 = zext i8 %817 to i16
%819 = add nuw nsw i16 %814, 1
%820 = add nuw nsw i16 %819, %818
%821 = lshr i16 %820, 1
%822 = add nuw nsw i16 %811, 1
%823 = add nuw nsw i16 %822, %821
%824 = lshr i16 %823, 1
%825 = trunc i16 %824 to i8
store i8 %825, i8* %809
br label %826
826: ; preds = %808, %805
%827 = phi i64 [ %806, %805 ], [ %815, %808 ]
%828 = icmp eq i64 %807, %711
br i1 %828, label %866, label %829
829: ; preds = %826, %829
%830 = phi i64 [ %854, %829 ], [ %827, %826 ]
%831 = getelementptr inbounds i8, i8* %736, i64 %830
%832 = load i8, i8* %831
%833 = zext i8 %832 to i16
%834 = getelementptr inbounds i8, i8* %737, i64 %830
%835 = load i8, i8* %834
%836 = zext i8 %835 to i16
%837 = add nuw nsw i64 %830, 1
%838 = getelementptr inbounds i8, i8* %737, i64 %837
%839 = load i8, i8* %838
%840 = zext i8 %839 to i16
%841 = add nuw nsw i16 %836, 1
%842 = add nuw nsw i16 %841, %840
%843 = lshr i16 %842, 1
%844 = add nuw nsw i16 %833, 1
%845 = add nuw nsw i16 %844, %843
%846 = lshr i16 %845, 1
%847 = trunc i16 %846 to i8
store i8 %847, i8* %831
%848 = getelementptr inbounds i8, i8* %736, i64 %837
%849 = load i8, i8* %848
%850 = zext i8 %849 to i16
%851 = getelementptr inbounds i8, i8* %737, i64 %837
%852 = load i8, i8* %851
%853 = zext i8 %852 to i16
%854 = add nuw nsw i64 %830, 2
%855 = getelementptr inbounds i8, i8* %737, i64 %854
%856 = load i8, i8* %855
%857 = zext i8 %856 to i16
%858 = add nuw nsw i16 %853, 1
%859 = add nuw nsw i16 %858, %857
%860 = lshr i16 %859, 1
%861 = add nuw nsw i16 %850, 1
%862 = add nuw nsw i16 %861, %860
%863 = lshr i16 %862, 1
%864 = trunc i16 %863 to i8
store i8 %864, i8* %848
%865 = icmp eq i64 %854, %694
br i1 %865, label %866, label %829
866: ; preds = %826, %829, %775, %804, %734
%867 = getelementptr inbounds i8, i8* %737, i64 %693
%868 = getelementptr inbounds i8, i8* %736, i64 %693
%869 = add nuw nsw i32 %738, 1
%870 = icmp eq i32 %869, %5
%871 = add i64 %735, 1
br i1 %870, label %1311, label %734
872: ; preds = %713, %991
%873 = phi i64 [ 0, %713 ], [ %996, %991 ]
%874 = phi i8* [ %25, %713 ], [ %993, %991 ]
%875 = phi i8* [ %21, %713 ], [ %992, %991 ]
%876 = phi i32 [ 0, %713 ], [ %994, %991 ]
%877 = mul i64 %873, %715
%878 = add i64 %718, %877
%879 = getelementptr i8, i8* %1, i64 %878
%880 = add i64 %722, %877
%881 = getelementptr i8, i8* %0, i64 %880
br i1 %714, label %882, label %991
882: ; preds = %872
br i1 %723, label %945, label %883
883: ; preds = %882
%884 = icmp ult i8* %874, %881
%885 = icmp ult i8* %875, %879
%886 = and i1 %884, %885
br i1 %886, label %945, label %887
887: ; preds = %883
br i1 %724, label %923, label %888
888: ; preds = %887, %888
%889 = phi i64 [ %919, %888 ], [ 0, %887 ]
%890 = getelementptr inbounds i8, i8* %875, i64 %889
%891 = bitcast i8* %890 to <16 x i8>*
%892 = load <16 x i8>, <16 x i8>* %891
%893 = getelementptr inbounds i8, i8* %890, i64 16
%894 = bitcast i8* %893 to <16 x i8>*
%895 = load <16 x i8>, <16 x i8>* %894
%896 = zext <16 x i8> %892 to <16 x i16>
%897 = zext <16 x i8> %895 to <16 x i16>
%898 = or i64 %889, 1
%899 = getelementptr inbounds i8, i8* %875, i64 %898
%900 = bitcast i8* %899 to <16 x i8>*
%901 = load <16 x i8>, <16 x i8>* %900
%902 = getelementptr inbounds i8, i8* %899, i64 16
%903 = bitcast i8* %902 to <16 x i8>*
%904 = load <16 x i8>, <16 x i8>* %903
%905 = zext <16 x i8> %901 to <16 x i16>
%906 = zext <16 x i8> %904 to <16 x i16>
%907 = add nuw nsw <16 x i16> %896, <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
%908 = add nuw nsw <16 x i16> %897, <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
%909 = add nuw nsw <16 x i16> %907, %905
%910 = add nuw nsw <16 x i16> %908, %906
%911 = lshr <16 x i16> %909, <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>
%912 = lshr <16 x i16> %910, <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>
%913 = trunc <16 x i16> %911 to <16 x i8>
%914 = trunc <16 x i16> %912 to <16 x i8>
%915 = getelementptr inbounds i8, i8* %874, i64 %889
%916 = bitcast i8* %915 to <16 x i8>*
store <16 x i8> %913, <16 x i8>* %916
%917 = getelementptr inbounds i8, i8* %915, i64 16
%918 = bitcast i8* %917 to <16 x i8>*
store <16 x i8> %914, <16 x i8>* %918
%919 = add nuw i64 %889, 32
%920 = icmp eq i64 %919, %725
br i1 %920, label %921, label %888
921: ; preds = %888
br i1 %726, label %991, label %922
922: ; preds = %921
br i1 %728, label %945, label %923
923: ; preds = %887, %922
%924 = phi i64 [ %725, %922 ], [ 0, %887 ]
br label %925
925: ; preds = %925, %923
%926 = phi i64 [ %924, %923 ], [ %942, %925 ]
%927 = getelementptr inbounds i8, i8* %875, i64 %926
%928 = bitcast i8* %927 to <8 x i8>*
%929 = load <8 x i8>, <8 x i8>* %928
%930 = zext <8 x i8> %929 to <8 x i16>
%931 = or i64 %926, 1
%932 = getelementptr inbounds i8, i8* %875, i64 %931
%933 = bitcast i8* %932 to <8 x i8>*
%934 = load <8 x i8>, <8 x i8>* %933
%935 = zext <8 x i8> %934 to <8 x i16>
%936 = add nuw nsw <8 x i16> %930, <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
%937 = add nuw nsw <8 x i16> %936, %935
%938 = lshr <8 x i16> %937, <i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1, i16 1>
%939 = trunc <8 x i16> %938 to <8 x i8>
%940 = getelementptr inbounds i8, i8* %874, i64 %926
%941 = bitcast i8* %940 to <8 x i8>*
store <8 x i8> %939, <8 x i8>* %941
%942 = add nuw i64 %926, 8
%943 = icmp eq i64 %942, %729
br i1 %943, label %944, label %925
944: ; preds = %925
br i1 %730, label %991, label %945
945: ; preds = %883, %882, %922, %944
%946 = phi i64 [ 0, %882 ], [ 0, %883 ], [ %725, %922 ], [ %729, %944 ]
%947 = xor i64 %946, -1
br i1 %732, label %961, label %948
948: ; preds = %945
%949 = getelementptr inbounds i8, i8* %875, i64 %946
%950 = load i8, i8* %949
%951 = zext i8 %950 to i16
%952 = or i64 %946, 1
%953 = getelementptr inbounds i8, i8* %875, i64 %952
%954 = load i8, i8* %953
%955 = zext i8 %954 to i16
%956 = add nuw nsw i16 %951, 1
%957 = add nuw nsw i16 %956, %955
%958 = lshr i16 %957, 1
%959 = trunc i16 %958 to i8
%960 = getelementptr inbounds i8, i8* %874, i64 %946
store i8 %959, i8* %960
br label %961
961: ; preds = %948, %945
%962 = phi i64 [ %946, %945 ], [ %952, %948 ]
%963 = icmp eq i64 %947, %733
br i1 %963, label %991, label %964
964: ; preds = %961, %964
%965 = phi i64 [ %981, %964 ], [ %962, %961 ]
%966 = getelementptr inbounds i8, i8* %875, i64 %965
%967 = load i8, i8* %966
%968 = zext i8 %967 to i16
%969 = add nuw nsw i64 %965, 1
%970 = getelementptr inbounds i8, i8* %875, i64 %969
%971 = load i8, i8* %970
%972 = zext i8 %971 to i16
%973 = add nuw nsw i16 %968, 1
%974 = add nuw nsw i16 %973, %972
%975 = lshr i16 %974, 1
%976 = trunc i16 %975 to i8
%977 = getelementptr inbounds i8, i8* %874, i64 %965
store i8 %976, i8* %977
%978 = getelementptr inbounds i8, i8* %875, i64 %969
%979 = load i8, i8* %978
%980 = zext i8 %979 to i16
%981 = add nuw nsw i64 %965, 2
%982 = getelementptr inbounds i8, i8* %875, i64 %981
%983 = load i8, i8* %982
%984 = zext i8 %983 to i16
%985 = add nuw nsw i16 %980, 1
%986 = add nuw nsw i16 %985, %984
%987 = lshr i16 %986, 1
%988 = trunc i16 %987 to i8
%989 = getelementptr inbounds i8, i8* %874, i64 %969
store i8 %988, i8* %989
%990 = icmp eq i64 %981, %716
br i1 %990, label %991, label %964
991: ; preds = %961, %964, %921, %944, %872
%992 = getelementptr inbounds i8, i8* %875, i64 %715
%993 = getelementptr inbounds i8, i8* %874, i64 %715
%994 = add nuw nsw i32 %876, 1
%995 = icmp eq i32 %994, %5
%996 = add i64 %873, 1
br i1 %995, label %1311, label %872
997: ; preds = %685
br i1 %687, label %1022, label %998
998: ; preds = %997
br i1 %688, label %999, label %1311
999: ; preds = %998
%1000 = icmp sgt i32 %4, 0
%1001 = sext i32 %3 to i64
%1002 = sext i32 %2 to i64
%1003 = zext i32 %4 to i64
%1004 = add nsw i64 %18, %23
%1005 = add nsw i64 %1004, %1003
%1006 = add nsw i64 %20, %18
%1007 = add nsw i64 %1006, %1002
%1008 = add nsw i64 %1007, %16
%1009 = add nsw i64 %1008, %1003
%1010 = add nsw i64 %1009, 1
%1011 = add nsw i64 %1006, %16
%1012 = add nsw i64 %1011, %1003
%1013 = add nsw i64 %1012, 1
%1014 = icmp ult i32 %4, 8
%1015 = icmp ult i32 %4, 16
%1016 = and i64 %1003, 4294967280
%1017 = icmp eq i64 %1016, %1003
%1018 = and i64 %1003, 8
%1019 = icmp eq i64 %1018, 0
%1020 = and i64 %1003, 4294967288
%1021 = icmp eq i64 %1020, %1003
br label %1046
1022: ; preds = %997
br i1 %688, label %1023, label %1311
1023: ; preds = %1022
%1024 = icmp sgt i32 %4, 0
%1025 = sext i32 %3 to i64
%1026 = sext i32 %2 to i64
%1027 = zext i32 %4 to i64
%1028 = add nsw i64 %18, %23
%1029 = add nsw i64 %1028, %1027
%1030 = add nsw i64 %20, %18
%1031 = add nsw i64 %1030, %1026
%1032 = add nsw i64 %1031, %16
%1033 = add nsw i64 %1032, %1027
%1034 = add nsw i64 %1033, 1
%1035 = add nsw i64 %1030, %16
%1036 = add nsw i64 %1035, %1027
%1037 = add nsw i64 %1036, 1
%1038 = icmp ult i32 %4, 8
%1039 = icmp ult i32 %4, 16
%1040 = and i64 %1027, 4294967280
%1041 = icmp eq i64 %1040, %1027
%1042 = and i64 %1027, 8
%1043 = icmp eq i64 %1042, 0
%1044 = and i64 %1027, 4294967288
%1045 = icmp eq i64 %1044, %1027
br label %1187
1046: ; preds = %999, %1181
%1047 = phi i64 [ 0, %999 ], [ %1186, %1181 ]
%1048 = phi i8* [ %25, %999 ], [ %1183, %1181 ]
%1049 = phi i8* [ %21, %999 ], [ %1182, %1181 ]
%1050 = phi i32 [ 0, %999 ], [ %1184, %1181 ]
%1051 = mul i64 %1047, %1001
%1052 = add i64 %1005, %1051
%1053 = getelementptr i8, i8* %1, i64 %1052
%1054 = add i64 %1008, %1051
%1055 = getelementptr i8, i8* %0, i64 %1054
%1056 = add i64 %1010, %1051
%1057 = getelementptr i8, i8* %0, i64 %1056
%1058 = add i64 %1013, %1051
%1059 = getelementptr i8, i8* %0, i64 %1058
br i1 %1000, label %1060, label %1181
1060: ; preds = %1046
br i1 %1014, label %1149, label %1061
1061: ; preds = %1060
%1062 = icmp ult i8* %1048, %1057
%1063 = icmp ult i8* %1055, %1053
%1064 = and i1 %1062, %1063
%1065 = icmp ult i8* %1048, %1059
%1066 = icmp ult i8* %1049, %1053
%1067 = and i1 %1065, %1066
%1068 = or i1 %1064, %1067
br i1 %1068, label %1149, label %1069
1069: ; preds = %1061
br i1 %1015, label %1109, label %1070
1070: ; preds = %1069, %1070
%1071 = phi i64 [ %1105, %1070 ], [ 0, %1069 ]
%1072 = getelementptr inbounds i8, i8* %1048, i64 %1071
%1073 = bitcast i8* %1072 to <16 x i8>*
%1074 = load <16 x i8>, <16 x i8>* %1073
%1075 = zext <16 x i8> %1074 to <16 x i32>
%1076 = getelementptr inbounds i8, i8* %1049, i64 %1071
%1077 = bitcast i8* %1076 to <16 x i8>*
%1078 = load <16 x i8>, <16 x i8>* %1077
%1079 = zext <16 x i8> %1078 to <16 x i32>
%1080 = or i64 %1071, 1
%1081 = getelementptr inbounds i8, i8* %1049, i64 %1080
%1082 = bitcast i8* %1081 to <16 x i8>*
%1083 = load <16 x i8>, <16 x i8>* %1082
%1084 = zext <16 x i8> %1083 to <16 x i32>
%1085 = add nsw i64 %1071, %1002
%1086 = getelementptr inbounds i8, i8* %1049, i64 %1085
%1087 = bitcast i8* %1086 to <16 x i8>*
%1088 = load <16 x i8>, <16 x i8>* %1087
%1089 = zext <16 x i8> %1088 to <16 x i32>
%1090 = add nsw i64 %1085, 1
%1091 = getelementptr inbounds i8, i8* %1049, i64 %1090
%1092 = bitcast i8* %1091 to <16 x i8>*
%1093 = load <16 x i8>, <16 x i8>* %1092
%1094 = zext <16 x i8> %1093 to <16 x i32>
%1095 = add nuw nsw <16 x i32> %1079, <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>
%1096 = add nuw nsw <16 x i32> %1095, %1084
%1097 = add nuw nsw <16 x i32> %1096, %1089
%1098 = add nuw nsw <16 x i32> %1097, %1094
%1099 = lshr <16 x i32> %1098, <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>
%1100 = add nuw nsw <16 x i32> %1075, <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>
%1101 = add nuw nsw <16 x i32> %1100, %1099
%1102 = lshr <16 x i32> %1101, <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 = trunc <16 x i32> %1102 to <16 x i8>
%1104 = bitcast i8* %1072 to <16 x i8>*
store <16 x i8> %1103, <16 x i8>* %1104
%1105 = add nuw i64 %1071, 16
%1106 = icmp eq i64 %1105, %1016
br i1 %1106, label %1107, label %1070
1107: ; preds = %1070
br i1 %1017, label %1181, label %1108
1108: ; preds = %1107
br i1 %1019, label %1149, label %1109
1109: ; preds = %1069, %1108
%1110 = phi i64 [ %1016, %1108 ], [ 0, %1069 ]
br label %1111
1111: ; preds = %1111, %1109
%1112 = phi i64 [ %1110, %1109 ], [ %1146, %1111 ]
%1113 = getelementptr inbounds i8, i8* %1048, i64 %1112
%1114 = bitcast i8* %1113 to <8 x i8>*
%1115 = load <8 x i8>, <8 x i8>* %1114
%1116 = zext <8 x i8> %1115 to <8 x i32>
%1117 = getelementptr inbounds i8, i8* %1049, i64 %1112
%1118 = bitcast i8* %1117 to <8 x i8>*
%1119 = load <8 x i8>, <8 x i8>* %1118
%1120 = zext <8 x i8> %1119 to <8 x i32>
%1121 = or i64 %1112, 1
%1122 = getelementptr inbounds i8, i8* %1049, i64 %1121
%1123 = bitcast i8* %1122 to <8 x i8>*
%1124 = load <8 x i8>, <8 x i8>* %1123
%1125 = zext <8 x i8> %1124 to <8 x i32>
%1126 = add nsw i64 %1112, %1002
%1127 = getelementptr inbounds i8, i8* %1049, i64 %1126
%1128 = bitcast i8* %1127 to <8 x i8>*
%1129 = load <8 x i8>, <8 x i8>* %1128
%1130 = zext <8 x i8> %1129 to <8 x i32>
%1131 = add nsw i64 %1126, 1
%1132 = getelementptr inbounds i8, i8* %1049, i64 %1131
%1133 = bitcast i8* %1132 to <8 x i8>*
%1134 = load <8 x i8>, <8 x i8>* %1133
%1135 = zext <8 x i8> %1134 to <8 x i32>
%1136 = add nuw nsw <8 x i32> %1120, <i32 2, i32 2, i32 2, i32 2, i32 2, i32 2, i32 2, i32 2>
%1137 = add nuw nsw <8 x i32> %1136, %1125
%1138 = add nuw nsw <8 x i32> %1137, %1130
%1139 = add nuw nsw <8 x i32> %1138, %1135
%1140 = lshr <8 x i32> %1139, <i32 2, i32 2, i32 2, i32 2, i32 2, i32 2, i32 2, i32 2>
%1141 = add nuw nsw <8 x i32> %1116, <i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1>
%1142 = add nuw nsw <8 x i32> %1141, %1140
%1143 = lshr <8 x i32> %1142, <i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1>
%1144 = trunc <8 x i32> %1143 to <8 x i8>
%1145 = bitcast i8* %1113 to <8 x i8>*
store <8 x i8> %1144, <8 x i8>* %1145
%1146 = add nuw i64 %1112, 8
%1147 = icmp eq i64 %1146, %1020
br i1 %1147, label %1148, label %1111
1148: ; preds = %1111
br i1 %1021, label %1181, label %1149
1149: ; preds = %1061, %1060, %1108, %1148
%1150 = phi i64 [ 0, %1060 ], [ 0, %1061 ], [ %1016, %1108 ], [ %1020, %1148 ]
br label %1151
1151: ; preds = %1149, %1151
%1152 = phi i64 [ %1159, %1151 ], [ %1150, %1149 ]
%1153 = getelementptr inbounds i8, i8* %1048, i64 %1152
%1154 = load i8, i8* %1153
%1155 = zext i8 %1154 to i32
%1156 = getelementptr inbounds i8, i8* %1049, i64 %1152
%1157 = load i8, i8* %1156
%1158 = zext i8 %1157 to i32
%1159 = add nuw nsw i64 %1152, 1
%1160 = getelementptr inbounds i8, i8* %1049, i64 %1159
%1161 = load i8, i8* %1160
%1162 = zext i8 %1161 to i32
%1163 = add nsw i64 %1152, %1002
%1164 = getelementptr inbounds i8, i8* %1049, i64 %1163
%1165 = load i8, i8* %1164
%1166 = zext i8 %1165 to i32
%1167 = add nsw i64 %1163, 1
%1168 = getelementptr inbounds i8, i8* %1049, i64 %1167
%1169 = load i8, i8* %1168
%1170 = zext i8 %1169 to i32
%1171 = add nuw nsw i32 %1158, 2
%1172 = add nuw nsw i32 %1171, %1162
%1173 = add nuw nsw i32 %1172, %1166
%1174 = add nuw nsw i32 %1173, %1170
%1175 = lshr i32 %1174, 2
%1176 = add nuw nsw i32 %1155, 1
%1177 = add nuw nsw i32 %1176, %1175
%1178 = lshr i32 %1177, 1
%1179 = trunc i32 %1178 to i8
store i8 %1179, i8* %1153
%1180 = icmp eq i64 %1159, %1003
br i1 %1180, label %1181, label %1151
1181: ; preds = %1151, %1107, %1148, %1046
%1182 = getelementptr inbounds i8, i8* %1049, i64 %1001
%1183 = getelementptr inbounds i8, i8* %1048, i64 %1001
%1184 = add nuw nsw i32 %1050, 1
%1185 = icmp eq i32 %1184, %5
%1186 = add i64 %1047, 1
br i1 %1185, label %1311, label %1046
1187: ; preds = %1023, %1305
%1188 = phi i64 [ 0, %1023 ], [ %1310, %1305 ]
%1189 = phi i8* [ %25, %1023 ], [ %1307, %1305 ]
%1190 = phi i8* [ %21, %1023 ], [ %1306, %1305 ]
%1191 = phi i32 [ 0, %1023 ], [ %1308, %1305 ]
%1192 = mul i64 %1188, %1025
%1193 = add i64 %1029, %1192
%1194 = getelementptr i8, i8* %1, i64 %1193
%1195 = add i64 %1032, %1192
%1196 = getelementptr i8, i8* %0, i64 %1195
%1197 = add i64 %1034, %1192
%1198 = getelementptr i8, i8* %0, i64 %1197
%1199 = add i64 %1037, %1192
%1200 = getelementptr i8, i8* %0, i64 %1199
br i1 %1024, label %1201, label %1305
1201: ; preds = %1187
br i1 %1038, label %1278, label %1202
1202: ; preds = %1201
%1203 = icmp ult i8* %1189, %1198
%1204 = icmp ult i8* %1196, %1194
%1205 = and i1 %1203, %1204
%1206 = icmp ult i8* %1189, %1200
%1207 = icmp ult i8* %1190, %1194
%1208 = and i1 %1206, %1207
%1209 = or i1 %1205, %1208
br i1 %1209, label %1278, label %1210
1210: ; preds = %1202
br i1 %1039, label %1244, label %1211
1211: ; preds = %1210, %1211
%1212 = phi i64 [ %1240, %1211 ], [ 0, %1210 ]
%1213 = getelementptr inbounds i8, i8* %1190, i64 %1212
%1214 = bitcast i8* %1213 to <16 x i8>*
%1215 = load <16 x i8>, <16 x i8>* %1214
%1216 = zext <16 x i8> %1215 to <16 x i16>
%1217 = or i64 %1212, 1
%1218 = getelementptr inbounds i8, i8* %1190, i64 %1217
%1219 = bitcast i8* %1218 to <16 x i8>*
%1220 = load <16 x i8>, <16 x i8>* %1219
%1221 = zext <16 x i8> %1220 to <16 x i16>
%1222 = add nsw i64 %1212, %1026
%1223 = getelementptr inbounds i8, i8* %1190, i64 %1222
%1224 = bitcast i8* %1223 to <16 x i8>*
%1225 = load <16 x i8>, <16 x i8>* %1224
%1226 = zext <16 x i8> %1225 to <16 x i16>
%1227 = add nsw i64 %1222, 1
%1228 = getelementptr inbounds i8, i8* %1190, i64 %1227
%1229 = bitcast i8* %1228 to <16 x i8>*
%1230 = load <16 x i8>, <16 x i8>* %1229
%1231 = zext <16 x i8> %1230 to <16 x i16>
%1232 = add nuw nsw <16 x i16> %1216, <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>
%1233 = add nuw nsw <16 x i16> %1232, %1221
%1234 = add nuw nsw <16 x i16> %1233, %1226
%1235 = add nuw nsw <16 x i16> %1234, %1231
%1236 = lshr <16 x i16> %1235, <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>
%1237 = trunc <16 x i16> %1236 to <16 x i8>
%1238 = getelementptr inbounds i8, i8* %1189, i64 %1212
%1239 = bitcast i8* %1238 to <16 x i8>*
store <16 x i8> %1237, <16 x i8>* %1239
%1240 = add nuw i64 %1212, 16
%1241 = icmp eq i64 %1240, %1040
br i1 %1241, label %1242, label %1211
1242: ; preds = %1211
br i1 %1041, label %1305, label %1243
1243: ; preds = %1242
br i1 %1043, label %1278, label %1244
1244: ; preds = %1210, %1243
%1245 = phi i64 [ %1040, %1243 ], [ 0, %1210 ]
br label %1246
1246: ; preds = %1246, %1244
%1247 = phi i64 [ %1245, %1244 ], [ %1275, %1246 ]
%1248 = getelementptr inbounds i8, i8* %1190, i64 %1247
%1249 = bitcast i8* %1248 to <8 x i8>*
%1250 = load <8 x i8>, <8 x i8>* %1249
%1251 = zext <8 x i8> %1250 to <8 x i16>
%1252 = or i64 %1247, 1
%1253 = getelementptr inbounds i8, i8* %1190, i64 %1252
%1254 = bitcast i8* %1253 to <8 x i8>*
%1255 = load <8 x i8>, <8 x i8>* %1254
%1256 = zext <8 x i8> %1255 to <8 x i16>
%1257 = add nsw i64 %1247, %1026
%1258 = getelementptr inbounds i8, i8* %1190, i64 %1257
%1259 = bitcast i8* %1258 to <8 x i8>*
%1260 = load <8 x i8>, <8 x i8>* %1259
%1261 = zext <8 x i8> %1260 to <8 x i16>
%1262 = add nsw i64 %1257, 1
%1263 = getelementptr inbounds i8, i8* %1190, i64 %1262
%1264 = bitcast i8* %1263 to <8 x i8>*
%1265 = load <8 x i8>, <8 x i8>* %1264
%1266 = zext <8 x i8> %1265 to <8 x i16>
%1267 = add nuw nsw <8 x i16> %1251, <i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2>
%1268 = add nuw nsw <8 x i16> %1267, %1256
%1269 = add nuw nsw <8 x i16> %1268, %1261
%1270 = add nuw nsw <8 x i16> %1269, %1266
%1271 = lshr <8 x i16> %1270, <i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2>
%1272 = trunc <8 x i16> %1271 to <8 x i8>
%1273 = getelementptr inbounds i8, i8* %1189, i64 %1247
%1274 = bitcast i8* %1273 to <8 x i8>*
store <8 x i8> %1272, <8 x i8>* %1274
%1275 = add nuw i64 %1247, 8
%1276 = icmp eq i64 %1275, %1044
br i1 %1276, label %1277, label %1246
1277: ; preds = %1246
br i1 %1045, label %1305, label %1278
1278: ; preds = %1202, %1201, %1243, %1277
%1279 = phi i64 [ 0, %1201 ], [ 0, %1202 ], [ %1040, %1243 ], [ %1044, %1277 ]
br label %1280
1280: ; preds = %1278, %1280
%1281 = phi i64 [ %1285, %1280 ], [ %1279, %1278 ]
%1282 = getelementptr inbounds i8, i8* %1190, i64 %1281
%1283 = load i8, i8* %1282
%1284 = zext i8 %1283 to i16
%1285 = add nuw nsw i64 %1281, 1
%1286 = getelementptr inbounds i8, i8* %1190, i64 %1285
%1287 = load i8, i8* %1286
%1288 = zext i8 %1287 to i16
%1289 = add nsw i64 %1281, %1026
%1290 = getelementptr inbounds i8, i8* %1190, i64 %1289
%1291 = load i8, i8* %1290
%1292 = zext i8 %1291 to i16
%1293 = add nsw i64 %1289, 1
%1294 = getelementptr inbounds i8, i8* %1190, i64 %1293
%1295 = load i8, i8* %1294
%1296 = zext i8 %1295 to i16
%1297 = add nuw nsw i16 %1284, 2
%1298 = add nuw nsw i16 %1297, %1288
%1299 = add nuw nsw i16 %1298, %1292
%1300 = add nuw nsw i16 %1299, %1296
%1301 = lshr i16 %1300, 2
%1302 = trunc i16 %1301 to i8
%1303 = getelementptr inbounds i8, i8* %1189, i64 %1281
store i8 %1302, i8* %1303
%1304 = icmp eq i64 %1285, %1027
br i1 %1304, label %1305, label %1280
1305: ; preds = %1280, %1242, %1277, %1187
%1306 = getelementptr inbounds i8, i8* %1190, i64 %1025
%1307 = getelementptr inbounds i8, i8* %1189, i64 %1025
%1308 = add nuw nsw i32 %1191, 1
%1309 = icmp eq i32 %1308, %5
%1310 = add i64 %1188, 1
br i1 %1309, label %1311, label %1187
1311: ; preds = %866, %991, %1181, %1305, %543, %679, %199, %338, %690, %712, %998, %1022, %350, %375, %39, %60
ret void
}