#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*/ free(int *);
int *malloc(int);
float *update2(const float *profa, const float *profb, float *newp, int *path,
               int sipa, int sipb, float internal_gap_weight) {
  int i, c;
  int *gap_len = 0;
  int gap_cost = 0;
  gap_len = malloc(sizeof(int) * (path[0] + 1));
  gap_len[0] = 0;
  for (i = 1; i <= path[0]; i++) {
    gap_len[i] = (path[i] >> 16);
    path[i] = path[i] & 0x0000ffff;
  }
  c = 1;
  while (path[c] != 3) {
    gap_cost = 0;
    if (!path[c]) {
      while (!path[c] && path[c] != 3) {
        for (i = 64; i--;) {
          newp[i] = profa[i] + profb[i];
        }
        profa += 64;
        profb += 64;
        newp += 64;
        c++;
      }
    } else if (path[c] & 1) {
      if (path[c] & 128) {
        for (i = 0; i < gap_len[c] - 1; i++) {
          gap_cost += profb[29 + 64 * i];
        }
        gap_cost += profb[27 + 64 * i];
      } else if (path[c] & 64) {
        gap_cost += profb[27 + 64];
        for (i = 1; i < gap_len[c]; i++) {
          gap_cost += profb[29 + 64 * i];
        }
      } else {
        gap_cost += profb[27 + 64];
        for (i = 1; i < gap_len[c] - 1; i++) {
          gap_cost += profb[28 + 64 * i];
        }
        gap_cost += profb[27 + 64 * i];
      }
      gap_cost /= gap_len[c];
      gap_cost *= internal_gap_weight;
      while (path[c] & 1 && path[c] != 3) {
        for (i = 64; i--;) {
          newp[i] = profb[i];
        }
        newp[23] += gap_cost;
        for (i = 32; i < 55; i++) {
          newp[i] += gap_cost;
        }
        profb += 64;
        newp += 64;
        c++;
      }
    } else if (path[c] & 2) {
      if (path[c] & 128) {
        for (i = 0; i < gap_len[c] - 1; i++) {
          gap_cost += profa[29 + 64 * i];
        }
        gap_cost += profa[27 + 64 * i];
      } else if (path[c] & 64) {
        gap_cost += profa[27 + 64];
        for (i = 1; i < gap_len[c]; i++) {
          gap_cost += profa[29 + 64 * i];
        }
      } else {
        gap_cost += profa[27 + 64];
        for (i = 1; i < gap_len[c] - 1; i++) {
          gap_cost += profa[28 + 64 * i];
        }
        gap_cost += profa[27 + 64 * i];
      }
      gap_cost /= gap_len[c];
      gap_cost *= internal_gap_weight;
      while (path[c] & 2 && path[c] != 3) {
        for (i = 64; i--;) {
          newp[i] = profa[i];
        }
        newp[23] += gap_cost;
        for (i = 32; i < 55; i++) {
          newp[i] += gap_cost;
        }
        profa += 64;
        newp += 64;
        c++;
      }
    }
  }
  for (i = 64; i--;) {
    newp[i] = profa[i] + profb[i];
  }
  newp -= path[0] * 64;
  free(gap_len);
  return newp;
}


x86 assembly (clang, -O0):
<update2>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
mov    %r9d,-0x28(%rbp)
movss  %xmm0,-0x2c(%rbp)
movq   $0x0,-0x40(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
add    $0x1,%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rax
movl   $0x0,(%rax)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x20(%rbp),%rcx
cmp    (%rcx),%eax
jg     11d1 <update2+0xb1>
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
sar    $0x10,%edx
mov    -0x40(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
and    $0xffff,%edx
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    117f <update2+0x5f>
movl   $0x1,-0x34(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
cmpl   $0x3,(%rax,%rcx,4)
je     189e <update2+0x77e>
movl   $0x0,-0x44(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    12c5 <update2+0x1a5>
jmp    1208 <update2+0xe8>
mov    -0x20(%rbp),%rcx
movslq -0x34(%rbp),%rdx
xor    %eax,%eax
cmpl   $0x0,(%rcx,%rdx,4)
mov    %al,-0x45(%rbp)
jne    1231 <update2+0x111>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
cmpl   $0x3,(%rax,%rcx,4)
setne  %al
mov    %al,-0x45(%rbp)
mov    -0x45(%rbp),%al
test   $0x1,%al
jne    1241 <update2+0x121>
jmp    12c0 <update2+0x1a0>
movl   $0x40,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x30(%rbp)
cmp    $0x0,%eax
je     1288 <update2+0x168>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1248 <update2+0x128>
mov    -0x8(%rbp),%rax
add    $0x100,%rax
mov    %rax,-0x8(%rbp)
mov    -0x10(%rbp),%rax
add    $0x100,%rax
mov    %rax,-0x10(%rbp)
mov    -0x18(%rbp),%rax
add    $0x100,%rax
mov    %rax,-0x18(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1208 <update2+0xe8>
jmp    1899 <update2+0x779>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     15aa <update2+0x48a>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
and    $0x80,%eax
cmp    $0x0,%eax
je     1372 <update2+0x252>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x40(%rbp),%rcx
movslq -0x34(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1348 <update2+0x228>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
shl    $0x6,%ecx
add    $0x1d,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
cvtsi2ssl -0x44(%rbp),%xmm0
addss  %xmm1,%xmm0
cvttss2si %xmm0,%eax
mov    %eax,-0x44(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    12fc <update2+0x1dc>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
shl    $0x6,%ecx
add    $0x1b,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
cvtsi2ssl -0x44(%rbp),%xmm0
addss  %xmm1,%xmm0
cvttss2si %xmm0,%eax
mov    %eax,-0x44(%rbp)
jmp    1491 <update2+0x371>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
and    $0x40,%eax
cmp    $0x0,%eax
je     13f8 <update2+0x2d8>
mov    -0x10(%rbp),%rax
movss  0x16c(%rax),%xmm1
cvtsi2ssl -0x44(%rbp),%xmm0
addss  %xmm1,%xmm0
cvttss2si %xmm0,%eax
mov    %eax,-0x44(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x40(%rbp),%rcx
movslq -0x34(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    13f3 <update2+0x2d3>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
shl    $0x6,%ecx
add    $0x1d,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
cvtsi2ssl -0x44(%rbp),%xmm0
addss  %xmm1,%xmm0
cvttss2si %xmm0,%eax
mov    %eax,-0x44(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    13ac <update2+0x28c>
jmp    148c <update2+0x36c>
mov    -0x10(%rbp),%rax
movss  0x16c(%rax),%xmm1
cvtsi2ssl -0x44(%rbp),%xmm0
addss  %xmm1,%xmm0
cvttss2si %xmm0,%eax
mov    %eax,-0x44(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x40(%rbp),%rcx
movslq -0x34(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1467 <update2+0x347>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
shl    $0x6,%ecx
add    $0x1c,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
cvtsi2ssl -0x44(%rbp),%xmm0
addss  %xmm1,%xmm0
cvttss2si %xmm0,%eax
mov    %eax,-0x44(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    141b <update2+0x2fb>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
shl    $0x6,%ecx
add    $0x1b,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
cvtsi2ssl -0x44(%rbp),%xmm0
addss  %xmm1,%xmm0
cvttss2si %xmm0,%eax
mov    %eax,-0x44(%rbp)
jmp    1491 <update2+0x371>
mov    -0x40(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
mov    -0x44(%rbp),%eax
cltd
idiv   %ecx
mov    %eax,-0x44(%rbp)
movss  -0x2c(%rbp),%xmm1
cvtsi2ssl -0x44(%rbp),%xmm0
mulss  %xmm1,%xmm0
cvttss2si %xmm0,%eax
mov    %eax,-0x44(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
and    $0x1,%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x46(%rbp)
je     14e8 <update2+0x3c8>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
cmpl   $0x3,(%rax,%rcx,4)
setne  %al
mov    %al,-0x46(%rbp)
mov    -0x46(%rbp),%al
test   $0x1,%al
jne    14f8 <update2+0x3d8>
jmp    15a5 <update2+0x485>
movl   $0x40,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x30(%rbp)
cmp    $0x0,%eax
je     1532 <update2+0x412>
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    14ff <update2+0x3df>
cvtsi2ssl -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
addss  0x5c(%rax),%xmm0
movss  %xmm0,0x5c(%rax)
movl   $0x20,-0x30(%rbp)
cmpl   $0x37,-0x30(%rbp)
jge    157b <update2+0x45b>
cvtsi2ssl -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    154c <update2+0x42c>
mov    -0x10(%rbp),%rax
add    $0x100,%rax
mov    %rax,-0x10(%rbp)
mov    -0x18(%rbp),%rax
add    $0x100,%rax
mov    %rax,-0x18(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    14ba <update2+0x39a>
jmp    1894 <update2+0x774>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
and    $0x2,%eax
cmp    $0x0,%eax
je     188f <update2+0x76f>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
and    $0x80,%eax
cmp    $0x0,%eax
je     1657 <update2+0x537>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x40(%rbp),%rcx
movslq -0x34(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    162d <update2+0x50d>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
shl    $0x6,%ecx
add    $0x1d,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
cvtsi2ssl -0x44(%rbp),%xmm0
addss  %xmm1,%xmm0
cvttss2si %xmm0,%eax
mov    %eax,-0x44(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    15e1 <update2+0x4c1>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
shl    $0x6,%ecx
add    $0x1b,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
cvtsi2ssl -0x44(%rbp),%xmm0
addss  %xmm1,%xmm0
cvttss2si %xmm0,%eax
mov    %eax,-0x44(%rbp)
jmp    1776 <update2+0x656>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
and    $0x40,%eax
cmp    $0x0,%eax
je     16dd <update2+0x5bd>
mov    -0x8(%rbp),%rax
movss  0x16c(%rax),%xmm1
cvtsi2ssl -0x44(%rbp),%xmm0
addss  %xmm1,%xmm0
cvttss2si %xmm0,%eax
mov    %eax,-0x44(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x40(%rbp),%rcx
movslq -0x34(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    16d8 <update2+0x5b8>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
shl    $0x6,%ecx
add    $0x1d,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
cvtsi2ssl -0x44(%rbp),%xmm0
addss  %xmm1,%xmm0
cvttss2si %xmm0,%eax
mov    %eax,-0x44(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1691 <update2+0x571>
jmp    1771 <update2+0x651>
mov    -0x8(%rbp),%rax
movss  0x16c(%rax),%xmm1
cvtsi2ssl -0x44(%rbp),%xmm0
addss  %xmm1,%xmm0
cvttss2si %xmm0,%eax
mov    %eax,-0x44(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x40(%rbp),%rcx
movslq -0x34(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    174c <update2+0x62c>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
shl    $0x6,%ecx
add    $0x1c,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
cvtsi2ssl -0x44(%rbp),%xmm0
addss  %xmm1,%xmm0
cvttss2si %xmm0,%eax
mov    %eax,-0x44(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1700 <update2+0x5e0>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
shl    $0x6,%ecx
add    $0x1b,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
cvtsi2ssl -0x44(%rbp),%xmm0
addss  %xmm1,%xmm0
cvttss2si %xmm0,%eax
mov    %eax,-0x44(%rbp)
jmp    1776 <update2+0x656>
mov    -0x40(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
mov    -0x44(%rbp),%eax
cltd
idiv   %ecx
mov    %eax,-0x44(%rbp)
movss  -0x2c(%rbp),%xmm1
cvtsi2ssl -0x44(%rbp),%xmm0
mulss  %xmm1,%xmm0
cvttss2si %xmm0,%eax
mov    %eax,-0x44(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
and    $0x2,%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x47(%rbp)
je     17cd <update2+0x6ad>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
cmpl   $0x3,(%rax,%rcx,4)
setne  %al
mov    %al,-0x47(%rbp)
mov    -0x47(%rbp),%al
test   $0x1,%al
jne    17dd <update2+0x6bd>
jmp    188a <update2+0x76a>
movl   $0x40,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x30(%rbp)
cmp    $0x0,%eax
je     1817 <update2+0x6f7>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    17e4 <update2+0x6c4>
cvtsi2ssl -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
addss  0x5c(%rax),%xmm0
movss  %xmm0,0x5c(%rax)
movl   $0x20,-0x30(%rbp)
cmpl   $0x37,-0x30(%rbp)
jge    1860 <update2+0x740>
cvtsi2ssl -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1831 <update2+0x711>
mov    -0x8(%rbp),%rax
add    $0x100,%rax
mov    %rax,-0x8(%rbp)
mov    -0x18(%rbp),%rax
add    $0x100,%rax
mov    %rax,-0x18(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    179f <update2+0x67f>
jmp    188f <update2+0x76f>
jmp    1894 <update2+0x774>
jmp    1899 <update2+0x779>
jmp    11d8 <update2+0xb8>
movl   $0x40,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x30(%rbp)
cmp    $0x0,%eax
je     18e5 <update2+0x7c5>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    18a5 <update2+0x785>
mov    -0x20(%rbp),%rax
mov    (%rax),%ecx
shl    $0x6,%ecx
mov    -0x18(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
mov    -0x18(%rbp),%rax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<update2>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
movd   %xmm0,0xc(%rsp)
mov    %rcx,%r15
mov    %rdx,%rbx
mov    %rsi,%r13
mov    %rdi,%r12
mov    (%rcx),%ebp
lea    0x4(,%rbp,4),%edi
call   1040 <malloc@plt>
mov    %rax,%r9
movl   $0x0,(%rax)
test   %ebp,%ebp
jle    12ab <update2+0x18b>
mov    $0x1,%eax
cmp    $0x8,%rbp
jb     128a <update2+0x16a>
mov    %ebp,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rcx
mov    %rcx,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     20b1 <update2+0xf91>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
mov    $0x1,%ecx
movdqa 0x1e61(%rip),%xmm0
nop
movdqu (%r15,%rcx,4),%xmm1
movdqu 0x10(%r15,%rcx,4),%xmm2
movdqa %xmm1,%xmm3
psrad  $0x10,%xmm3
movdqa %xmm2,%xmm4
psrad  $0x10,%xmm4
movdqu %xmm3,(%r9,%rcx,4)
movdqu %xmm4,0x10(%r9,%rcx,4)
pand   %xmm0,%xmm1
pand   %xmm0,%xmm2
movdqu %xmm1,(%r15,%rcx,4)
movdqu %xmm2,0x10(%r15,%rcx,4)
movdqu 0x20(%r15,%rcx,4),%xmm1
movdqu 0x30(%r15,%rcx,4),%xmm2
movdqa %xmm1,%xmm3
psrad  $0x10,%xmm3
movdqa %xmm2,%xmm4
psrad  $0x10,%xmm4
movdqu %xmm3,0x20(%r9,%rcx,4)
movdqu %xmm4,0x30(%r9,%rcx,4)
pand   %xmm0,%xmm1
pand   %xmm0,%xmm2
movdqu %xmm1,0x20(%r15,%rcx,4)
movdqu %xmm2,0x30(%r15,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rsi
jne    11a0 <update2+0x80>
test   $0x1,%dl
je     1281 <update2+0x161>
movdqu (%r15,%rcx,4),%xmm0
movdqu 0x10(%r15,%rcx,4),%xmm1
movdqa %xmm0,%xmm2
psrad  $0x10,%xmm2
movdqa %xmm1,%xmm3
psrad  $0x10,%xmm3
movdqu %xmm2,(%r9,%rcx,4)
movdqu %xmm3,0x10(%r9,%rcx,4)
movdqa 0x1d94(%rip),%xmm2
pand   %xmm2,%xmm0
pand   %xmm2,%xmm1
movdqu %xmm0,(%r15,%rcx,4)
movdqu %xmm1,0x10(%r15,%rcx,4)
cmp    %rax,%rbp
je     12ab <update2+0x18b>
or     $0x1,%rax
lea    0x1(%rbp),%rcx
xchg   %ax,%ax
mov    (%r15,%rax,4),%edx
movzwl %dx,%esi
sar    $0x10,%edx
mov    %edx,(%r9,%rax,4)
mov    %esi,(%r15,%rax,4)
add    $0x1,%rax
cmp    %rax,%rcx
jne    1290 <update2+0x170>
mov    %rbp,0x10(%rsp)
mov    $0x1,%edx
pxor   %xmm0,%xmm0
mov    %r13,%r11
lea    0x174(%r13),%rax
mov    %rax,0x40(%rsp)
lea    0x274(%r13),%rax
mov    %rax,0x38(%rsp)
lea    0x270(%r13),%rax
mov    %rax,0x20(%rsp)
mov    %rdx,%rbp
mov    %r12,%r8
mov    %rbx,%r14
movslq %ebp,%rbp
mov    (%r15,%rbp,4),%edx
lea    0x174(%r12),%rax
mov    %rax,0x30(%rsp)
lea    0x274(%r12),%rax
mov    %rax,0x28(%rsp)
lea    0x270(%r12),%rax
mov    %rax,0x18(%rsp)
nopw   0x0(%rax,%rax,1)
test   %edx,%edx
je     19a0 <update2+0x880>
cmp    $0x3,%edx
je     1e48 <update2+0xd28>
test   $0x1,%dl
jne    1400 <update2+0x2e0>
test   $0x2,%dl
je     1320 <update2+0x200>
test   $0x80,%dl
jne    14e5 <update2+0x3c5>
movss  0x16c(%r8),%xmm1
addss  %xmm0,%xmm1
mov    (%r9,%rbp,4),%r10d
cvttss2si %xmm1,%eax
test   $0x40,%dl
jne    15a2 <update2+0x482>
mov    $0x1,%edi
cmp    $0x3,%r10d
jl     1722 <update2+0x602>
lea    -0x1(%r10),%ecx
lea    -0x1(%rcx),%r12
mov    $0x1,%ebx
cmp    $0x2,%ecx
je     13d7 <update2+0x2b7>
mov    %r12,%rsi
and    $0xfffffffffffffffe,%rsi
neg    %rsi
mov    $0x1,%ebx
mov    0x18(%rsp),%rcx
nopl   0x0(%rax,%rax,1)
xorps  %xmm1,%xmm1
cvtsi2ss %eax,%xmm1
addss  -0x100(%rcx),%xmm1
ff
cvttps2dq %xmm1,%xmm1
cvtdq2ps %xmm1,%xmm1
addss  (%rcx),%xmm1
cvttss2si %xmm1,%eax
add    $0x200,%rcx
lea    (%rsi,%rbx,1),%rdi
add    $0x2,%rdi
add    $0x2,%rbx
cmp    $0x1,%rdi
jne    13a0 <update2+0x280>
lea    -0x3(%r10),%edi
test   $0x1,%r12b
je     13f7 <update2+0x2d7>
shl    $0x8,%rbx
xorps  %xmm1,%xmm1
cvtsi2ss %eax,%xmm1
addss  0x70(%r8,%rbx,1),%xmm1
cvttss2si %xmm1,%eax
add    $0x2,%rdi
jmp    1722 <update2+0x602>
test   $0x80,%dl
jne    14c0 <update2+0x3a0>
movss  0x16c(%r11),%xmm1
addss  %xmm0,%xmm1
mov    (%r9,%rbp,4),%r13d
cvttss2si %xmm1,%eax
test   $0x40,%dl
jne    150a <update2+0x3ea>
mov    $0x1,%r10d
cmp    $0x3,%r13d
jl     1692 <update2+0x572>
lea    -0x1(%r13),%ecx
lea    -0x1(%rcx),%r12
mov    $0x1,%edi
cmp    $0x2,%ecx
je     1497 <update2+0x377>
mov    %r12,%rsi
and    $0xfffffffffffffffe,%rsi
neg    %rsi
mov    $0x1,%edi
mov    0x20(%rsp),%rcx
nopl   (%rax)
xorps  %xmm1,%xmm1
cvtsi2ss %eax,%xmm1
addss  -0x100(%rcx),%xmm1
ff
cvttps2dq %xmm1,%xmm1
cvtdq2ps %xmm1,%xmm1
addss  (%rcx),%xmm1
cvttss2si %xmm1,%eax
add    $0x200,%rcx
lea    (%rsi,%rdi,1),%rbx
add    $0x2,%rbx
add    $0x2,%rdi
cmp    $0x1,%rbx
jne    1460 <update2+0x340>
lea    -0x3(%r13),%r10d
test   $0x1,%r12b
je     14b7 <update2+0x397>
shl    $0x8,%rdi
xorps  %xmm1,%xmm1
cvtsi2ss %eax,%xmm1
addss  0x70(%r11,%rdi,1),%xmm1
cvttss2si %xmm1,%eax
add    $0x2,%r10
jmp    1692 <update2+0x572>
mov    (%r9,%rbp,4),%r13d
cmp    $0x2,%r13d
jl     1598 <update2+0x478>
lea    -0x1(%r13),%edi
cmp    $0x1,%edi
jne    1628 <update2+0x508>
xor    %r12d,%r12d
xor    %eax,%eax
jmp    166e <update2+0x54e>
mov    (%r9,%rbp,4),%r10d
cmp    $0x2,%r10d
jl     16b6 <update2+0x596>
lea    -0x1(%r10),%r12d
cmp    $0x1,%r12d
jne    16bc <update2+0x59c>
xor    %ebx,%ebx
xor    %eax,%eax
jmp    16fe <update2+0x5de>
cmp    $0x2,%r13d
jl     1c00 <update2+0xae0>
lea    -0x1(%r13),%r10
mov    $0x1,%edi
cmp    $0x2,%r13d
je     1577 <update2+0x457>
mov    %r10,%rsi
and    $0xfffffffffffffffe,%rsi
neg    %rsi
mov    $0x1,%edi
mov    0x38(%rsp),%rcx
nopw   0x0(%rax,%rax,1)
xorps  %xmm1,%xmm1
cvtsi2ss %eax,%xmm1
addss  -0x100(%rcx),%xmm1
ff
cvttps2dq %xmm1,%xmm1
cvtdq2ps %xmm1,%xmm1
addss  (%rcx),%xmm1
cvttss2si %xmm1,%eax
add    $0x200,%rcx
lea    (%rsi,%rdi,1),%rbx
add    $0x2,%rbx
add    $0x2,%rdi
cmp    $0x1,%rbx
jne    1540 <update2+0x420>
test   $0x1,%r10b
je     16a8 <update2+0x588>
shl    $0x8,%rdi
xorps  %xmm1,%xmm1
cvtsi2ss %eax,%xmm1
addss  0x74(%r11,%rdi,1),%xmm1
jmp    16a4 <update2+0x584>
xor    %r10d,%r10d
xor    %eax,%eax
jmp    1692 <update2+0x572>
cmp    $0x2,%r10d
jl     1740 <update2+0x620>
lea    -0x1(%r10),%r12
mov    $0x1,%edi
cmp    $0x2,%r10d
je     1607 <update2+0x4e7>
mov    %r12,%rbx
and    $0xfffffffffffffffe,%rbx
neg    %rbx
mov    $0x1,%edi
mov    0x28(%rsp),%rcx
nop
xorps  %xmm1,%xmm1
cvtsi2ss %eax,%xmm1
addss  -0x100(%rcx),%xmm1
ff
cvttps2dq %xmm1,%xmm1
cvtdq2ps %xmm1,%xmm1
addss  (%rcx),%xmm1
cvttss2si %xmm1,%eax
add    $0x200,%rcx
lea    (%rbx,%rdi,1),%rsi
add    $0x2,%rsi
add    $0x2,%rdi
cmp    $0x1,%rsi
jne    15d0 <update2+0x4b0>
test   $0x1,%r12b
je     1737 <update2+0x617>
shl    $0x8,%rdi
xorps  %xmm1,%xmm1
cvtsi2ss %eax,%xmm1
addss  0x74(%r8,%rdi,1),%xmm1
jmp    1733 <update2+0x613>
mov    %edi,%esi
and    $0xfffffffe,%esi
xor    %r12d,%r12d
mov    0x40(%rsp),%rcx
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
xorps  %xmm1,%xmm1
cvtsi2ss %eax,%xmm1
addss  -0x100(%rcx),%xmm1
ff
cvttps2dq %xmm1,%xmm1
cvtdq2ps %xmm1,%xmm1
addss  (%rcx),%xmm1
cvttss2si %xmm1,%eax
add    $0x2,%r12
add    $0x200,%rcx
cmp    %r12,%rsi
jne    1640 <update2+0x520>
lea    -0x2(%r13),%r10d
test   $0x1,%dil
je     168e <update2+0x56e>
shl    $0x8,%r12
xorps  %xmm1,%xmm1
cvtsi2ss %eax,%xmm1
addss  0x74(%r11,%r12,1),%xmm1
cvttss2si %xmm1,%eax
add    $0x1,%r10
shl    $0x6,%r10d
xorps  %xmm1,%xmm1
cvtsi2ss %eax,%xmm1
addss  0x6c(%r11,%r10,4),%xmm1
cvttss2si %xmm1,%eax
cmp    $0x3,%edx
je     1320 <update2+0x200>
jmp    1c00 <update2+0xae0>
xor    %edi,%edi
xor    %eax,%eax
jmp    1722 <update2+0x602>
mov    %r12d,%esi
and    $0xfffffffe,%esi
xor    %ebx,%ebx
mov    0x30(%rsp),%rcx
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
xorps  %xmm1,%xmm1
cvtsi2ss %eax,%xmm1
addss  -0x100(%rcx),%xmm1
ff
cvttps2dq %xmm1,%xmm1
cvtdq2ps %xmm1,%xmm1
addss  (%rcx),%xmm1
cvttss2si %xmm1,%eax
add    $0x2,%rbx
add    $0x200,%rcx
cmp    %rbx,%rsi
jne    16d0 <update2+0x5b0>
lea    -0x2(%r10),%edi
test   $0x1,%r12b
je     171e <update2+0x5fe>
shl    $0x8,%rbx
xorps  %xmm1,%xmm1
cvtsi2ss %eax,%xmm1
addss  0x74(%r8,%rbx,1),%xmm1
cvttss2si %xmm1,%eax
add    $0x1,%rdi
shl    $0x6,%edi
xorps  %xmm1,%xmm1
cvtsi2ss %eax,%xmm1
addss  0x6c(%r8,%rdi,4),%xmm1
cvttss2si %xmm1,%eax
cmp    $0x3,%edx
je     1320 <update2+0x200>
cltd
idiv   %r10d
xorps  %xmm1,%xmm1
cvtsi2ss %eax,%xmm1
mulss  0xc(%rsp),%xmm1
cvttps2dq %xmm1,%xmm1
cvtdq2ps %xmm1,%xmm1
movaps %xmm1,%xmm2
shufps $0x0,%xmm1,%xmm2
xor    %eax,%eax
mov    %r8,%r12
mov    %r14,%rbx
nopw   0x0(%rax,%rax,1)
mov    %rax,%rcx
shl    $0x8,%rcx
lea    (%r8,%rcx,1),%rdx
add    $0x100,%rdx
cmp    %rdx,%rbx
jae    17f0 <update2+0x6d0>
add    %r14,%rcx
add    $0x100,%rcx
cmp    %rcx,%r12
jae    17f0 <update2+0x6d0>
mov    $0x3c,%ecx
nopl   0x0(%rax,%rax,1)
movss  0xc(%r12,%rcx,4),%xmm3
movss  %xmm3,0xc(%rbx,%rcx,4)
movss  0x8(%r12,%rcx,4),%xmm3
movss  %xmm3,0x8(%rbx,%rcx,4)
movss  0x4(%r12,%rcx,4),%xmm3
movss  %xmm3,0x4(%rbx,%rcx,4)
movd   (%r12,%rcx,4),%xmm3
movd   %xmm3,(%rbx,%rcx,4)
add    $0xfffffffffffffffc,%rcx
cmp    $0xfffffffffffffffc,%rcx
jne    17a0 <update2+0x680>
jmp    18c0 <update2+0x7a0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups 0xf0(%r12),%xmm3
movups %xmm3,0xf0(%rbx)
movups 0xe0(%r12),%xmm3
movups %xmm3,0xe0(%rbx)
movups 0xd0(%r12),%xmm3
movups %xmm3,0xd0(%rbx)
movups 0xc0(%r12),%xmm3
movups %xmm3,0xc0(%rbx)
movups 0xb0(%r12),%xmm3
movups %xmm3,0xb0(%rbx)
movups 0xa0(%r12),%xmm3
movups %xmm3,0xa0(%rbx)
movups 0x90(%r12),%xmm3
movups %xmm3,0x90(%rbx)
movups 0x80(%r12),%xmm3
movups %xmm3,0x80(%rbx)
movups 0x70(%r12),%xmm3
movups %xmm3,0x70(%rbx)
movups 0x60(%r12),%xmm3
movups %xmm3,0x60(%rbx)
movups 0x50(%r12),%xmm3
movups %xmm3,0x50(%rbx)
movups 0x40(%r12),%xmm3
movups %xmm3,0x40(%rbx)
movups 0x30(%r12),%xmm3
movups %xmm3,0x30(%rbx)
movups 0x20(%r12),%xmm3
movups %xmm3,0x20(%rbx)
movups 0x10(%r12),%xmm3
movups %xmm3,0x10(%rbx)
movdqu (%r12),%xmm3
movdqu %xmm3,(%rbx)
movss  0x5c(%rbx),%xmm3
addss  %xmm1,%xmm3
movss  %xmm3,0x5c(%rbx)
movups 0x80(%rbx),%xmm3
movups 0x90(%rbx),%xmm4
movups 0xa0(%rbx),%xmm5
movups 0xb0(%rbx),%xmm6
addps  %xmm2,%xmm3
movups %xmm3,0x80(%rbx)
addps  %xmm2,%xmm4
movups %xmm4,0x90(%rbx)
addps  %xmm2,%xmm5
movups %xmm5,0xa0(%rbx)
addps  %xmm2,%xmm6
movups %xmm6,0xb0(%rbx)
movups 0xc0(%rbx),%xmm3
addps  %xmm2,%xmm3
movups %xmm3,0xc0(%rbx)
movss  0xd0(%rbx),%xmm3
addss  %xmm1,%xmm3
movss  %xmm3,0xd0(%rbx)
movss  0xd4(%rbx),%xmm3
addss  %xmm1,%xmm3
movss  %xmm3,0xd4(%rbx)
movss  0xd8(%rbx),%xmm3
addss  %xmm1,%xmm3
movss  %xmm3,0xd8(%rbx)
add    $0x100,%r12
add    $0x100,%rbx
mov    0x4(%r15,%rbp,4),%edx
add    $0x1,%rbp
mov    %edx,%ecx
and    $0x2,%ecx
add    $0x1,%rax
cmp    $0x3,%edx
je     12e3 <update2+0x1c3>
test   %ecx,%ecx
jne    1770 <update2+0x650>
jmp    12e3 <update2+0x1c3>
cs nopw 0x0(%rax,%rax,1)
nop
xor    %edi,%edi
mov    %r8,%r12
mov    %r11,%r13
mov    %r14,%rbx
jmp    1b42 <update2+0xa22>
movups 0xf0(%r12),%xmm1
movups 0xf0(%r13),%xmm2
addps  %xmm1,%xmm2
movups %xmm2,0xf0(%rbx)
movups 0xe0(%r12),%xmm1
movups 0xe0(%r13),%xmm2
addps  %xmm1,%xmm2
movups %xmm2,0xe0(%rbx)
movups 0xd0(%r12),%xmm1
movups 0xd0(%r13),%xmm2
addps  %xmm1,%xmm2
movups %xmm2,0xd0(%rbx)
movups 0xc0(%r12),%xmm1
movups 0xc0(%r13),%xmm2
addps  %xmm1,%xmm2
movups %xmm2,0xc0(%rbx)
movups 0xb0(%r12),%xmm1
movups 0xb0(%r13),%xmm2
addps  %xmm1,%xmm2
movups %xmm2,0xb0(%rbx)
movups 0xa0(%r12),%xmm1
movups 0xa0(%r13),%xmm2
addps  %xmm1,%xmm2
movups %xmm2,0xa0(%rbx)
movups 0x90(%r12),%xmm1
movups 0x90(%r13),%xmm2
addps  %xmm1,%xmm2
movups %xmm2,0x90(%rbx)
movups 0x80(%r12),%xmm1
movups 0x80(%r13),%xmm2
addps  %xmm1,%xmm2
movups %xmm2,0x80(%rbx)
movups 0x70(%r12),%xmm1
movups 0x70(%r13),%xmm2
addps  %xmm1,%xmm2
movups %xmm2,0x70(%rbx)
movups 0x60(%r12),%xmm1
movups 0x60(%r13),%xmm2
addps  %xmm1,%xmm2
movups %xmm2,0x60(%rbx)
movups 0x50(%r12),%xmm1
movups 0x50(%r13),%xmm2
addps  %xmm1,%xmm2
movups %xmm2,0x50(%rbx)
movups 0x40(%r12),%xmm1
movups 0x40(%r13),%xmm2
addps  %xmm1,%xmm2
movups %xmm2,0x40(%rbx)
movups 0x30(%r12),%xmm1
movups 0x30(%r13),%xmm2
addps  %xmm1,%xmm2
movups %xmm2,0x30(%rbx)
movups 0x20(%r12),%xmm1
movups 0x20(%r13),%xmm2
addps  %xmm1,%xmm2
movups %xmm2,0x20(%rbx)
movups 0x10(%r12),%xmm1
movups 0x10(%r13),%xmm2
addps  %xmm1,%xmm2
movups %xmm2,0x10(%rbx)
movups (%r12),%xmm1
movups 0x0(%r13),%xmm2
addps  %xmm1,%xmm2
movups %xmm2,(%rbx)
add    $0x100,%r12
add    $0x100,%r13
add    $0x100,%rbx
lea    0x1(%rbp),%rdx
add    $0x1,%rdi
cmpl   $0x0,0x4(%r15,%rbp,4)
mov    %rdx,%rbp
jne    12b9 <update2+0x199>
mov    %rdi,%rcx
shl    $0x8,%rcx
lea    (%r14,%rcx,1),%rdx
add    $0x100,%rdx
lea    (%r11,%rcx,1),%rsi
add    $0x100,%rsi
add    %r8,%rcx
add    $0x100,%rcx
cmp    %rcx,%rbx
setb   %r10b
cmp    %rdx,%r12
setb   %al
cmp    %rsi,%rbx
setb   %cl
cmp    %rdx,%r13
setb   %dl
test   %al,%r10b
jne    1b8f <update2+0xa6f>
and    %dl,%cl
je     19b0 <update2+0x890>
mov    $0x3c,%ecx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  0xc(%r12,%rcx,4),%xmm1
addss  0xc(%r13,%rcx,4),%xmm1
movss  %xmm1,0xc(%rbx,%rcx,4)
movss  0x8(%r12,%rcx,4),%xmm1
addss  0x8(%r13,%rcx,4),%xmm1
movss  %xmm1,0x8(%rbx,%rcx,4)
movss  0x4(%r12,%rcx,4),%xmm1
addss  0x4(%r13,%rcx,4),%xmm1
movss  %xmm1,0x4(%rbx,%rcx,4)
movss  (%r12,%rcx,4),%xmm1
addss  0x0(%r13,%rcx,4),%xmm1
movss  %xmm1,(%rbx,%rcx,4)
add    $0xfffffffffffffffc,%rcx
cmp    $0xfffffffffffffffc,%rcx
jne    1ba0 <update2+0xa80>
jmp    1b16 <update2+0x9f6>
nopl   (%rax)
cltd
idiv   %r13d
xorps  %xmm1,%xmm1
cvtsi2ss %eax,%xmm1
mulss  0xc(%rsp),%xmm1
cvttps2dq %xmm1,%xmm1
cvtdq2ps %xmm1,%xmm1
movaps %xmm1,%xmm2
shufps $0x0,%xmm1,%xmm2
xor    %eax,%eax
mov    %r11,%r13
mov    %r14,%rbx
nopw   0x0(%rax,%rax,1)
mov    %rax,%rcx
shl    $0x8,%rcx
lea    (%r11,%rcx,1),%rdx
add    $0x100,%rdx
cmp    %rdx,%rbx
jae    1cb0 <update2+0xb90>
add    %r14,%rcx
add    $0x100,%rcx
cmp    %rcx,%r13
jae    1cb0 <update2+0xb90>
mov    $0x3c,%ecx
nopl   0x0(%rax,%rax,1)
movss  0xc(%r13,%rcx,4),%xmm3
movss  %xmm3,0xc(%rbx,%rcx,4)
movss  0x8(%r13,%rcx,4),%xmm3
movss  %xmm3,0x8(%rbx,%rcx,4)
movss  0x4(%r13,%rcx,4),%xmm3
movss  %xmm3,0x4(%rbx,%rcx,4)
movd   0x0(%r13,%rcx,4),%xmm3
movd   %xmm3,(%rbx,%rcx,4)
add    $0xfffffffffffffffc,%rcx
cmp    $0xfffffffffffffffc,%rcx
jne    1c60 <update2+0xb40>
jmp    1d71 <update2+0xc51>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups 0xf0(%r13),%xmm3
movups %xmm3,0xf0(%rbx)
movups 0xe0(%r13),%xmm3
movups %xmm3,0xe0(%rbx)
movups 0xd0(%r13),%xmm3
movups %xmm3,0xd0(%rbx)
movups 0xc0(%r13),%xmm3
movups %xmm3,0xc0(%rbx)
movups 0xb0(%r13),%xmm3
movups %xmm3,0xb0(%rbx)
movups 0xa0(%r13),%xmm3
movups %xmm3,0xa0(%rbx)
movups 0x90(%r13),%xmm3
movups %xmm3,0x90(%rbx)
movups 0x80(%r13),%xmm3
movups %xmm3,0x80(%rbx)
movups 0x70(%r13),%xmm3
movups %xmm3,0x70(%rbx)
movups 0x60(%r13),%xmm3
movups %xmm3,0x60(%rbx)
movups 0x50(%r13),%xmm3
movups %xmm3,0x50(%rbx)
movups 0x40(%r13),%xmm3
movups %xmm3,0x40(%rbx)
movups 0x30(%r13),%xmm3
movups %xmm3,0x30(%rbx)
movups 0x20(%r13),%xmm3
movups %xmm3,0x20(%rbx)
movups 0x10(%r13),%xmm3
movups %xmm3,0x10(%rbx)
movdqu 0x0(%r13),%xmm3
movdqu %xmm3,(%rbx)
movss  0x5c(%rbx),%xmm3
addss  %xmm1,%xmm3
movss  %xmm3,0x5c(%rbx)
movups 0x80(%rbx),%xmm3
movups 0x90(%rbx),%xmm4
movups 0xa0(%rbx),%xmm5
movups 0xb0(%rbx),%xmm6
addps  %xmm2,%xmm3
movups %xmm3,0x80(%rbx)
addps  %xmm2,%xmm4
movups %xmm4,0x90(%rbx)
addps  %xmm2,%xmm5
movups %xmm5,0xa0(%rbx)
addps  %xmm2,%xmm6
movups %xmm6,0xb0(%rbx)
movups 0xc0(%rbx),%xmm3
addps  %xmm2,%xmm3
movups %xmm3,0xc0(%rbx)
movss  0xd0(%rbx),%xmm3
addss  %xmm1,%xmm3
movss  %xmm3,0xd0(%rbx)
movss  0xd4(%rbx),%xmm3
addss  %xmm1,%xmm3
movss  %xmm3,0xd4(%rbx)
movss  0xd8(%rbx),%xmm3
addss  %xmm1,%xmm3
movss  %xmm3,0xd8(%rbx)
add    $0x100,%r13
add    $0x100,%rbx
mov    0x4(%r15,%rbp,4),%edx
add    $0x1,%rbp
mov    %edx,%ecx
and    $0x1,%ecx
add    $0x1,%rax
cmp    $0x3,%edx
je     1e3d <update2+0xd1d>
test   %ecx,%ecx
jne    1c30 <update2+0xb10>
mov    %r8,%r12
mov    %rbp,%rdx
jmp    12b9 <update2+0x199>
lea    0x100(%r14),%rcx
lea    0x100(%r8),%rax
lea    0x100(%r11),%rdx
cmp    %rax,%r14
setb   %sil
cmp    %rcx,%r8
setb   %bl
cmp    %rdx,%r14
setb   %al
cmp    %rcx,%r11
setb   %cl
test   %bl,%sil
jne    1ff1 <update2+0xed1>
and    %cl,%al
jne    1ff1 <update2+0xed1>
movups 0xf0(%r8),%xmm0
movups 0xf0(%r11),%xmm1
addps  %xmm0,%xmm1
movups %xmm1,0xf0(%r14)
movups 0xe0(%r8),%xmm0
movups 0xe0(%r11),%xmm1
addps  %xmm0,%xmm1
movups %xmm1,0xe0(%r14)
movups 0xd0(%r8),%xmm0
movups 0xd0(%r11),%xmm1
addps  %xmm0,%xmm1
movups %xmm1,0xd0(%r14)
movups 0xc0(%r8),%xmm0
movups 0xc0(%r11),%xmm1
addps  %xmm0,%xmm1
movups %xmm1,0xc0(%r14)
movups 0xb0(%r8),%xmm0
movups 0xb0(%r11),%xmm1
addps  %xmm0,%xmm1
movups %xmm1,0xb0(%r14)
movups 0xa0(%r8),%xmm0
movups 0xa0(%r11),%xmm1
addps  %xmm0,%xmm1
movups %xmm1,0xa0(%r14)
movups 0x90(%r8),%xmm0
movups 0x90(%r11),%xmm1
addps  %xmm0,%xmm1
movups %xmm1,0x90(%r14)
movups 0x80(%r8),%xmm0
movups 0x80(%r11),%xmm1
addps  %xmm0,%xmm1
movups %xmm1,0x80(%r14)
movups 0x70(%r8),%xmm0
movups 0x70(%r11),%xmm1
addps  %xmm0,%xmm1
movups %xmm1,0x70(%r14)
movups 0x60(%r8),%xmm0
movups 0x60(%r11),%xmm1
addps  %xmm0,%xmm1
movups %xmm1,0x60(%r14)
movups 0x50(%r8),%xmm0
movups 0x50(%r11),%xmm1
addps  %xmm0,%xmm1
movups %xmm1,0x50(%r14)
movups 0x40(%r8),%xmm0
movups 0x40(%r11),%xmm1
addps  %xmm0,%xmm1
movups %xmm1,0x40(%r14)
movups 0x30(%r8),%xmm0
movups 0x30(%r11),%xmm1
addps  %xmm0,%xmm1
movups %xmm1,0x30(%r14)
movups 0x20(%r8),%xmm0
movups 0x20(%r11),%xmm1
addps  %xmm0,%xmm1
movups %xmm1,0x20(%r14)
movups 0x10(%r8),%xmm0
movups 0x10(%r11),%xmm1
addps  %xmm0,%xmm1
movups %xmm1,0x10(%r14)
movups (%r8),%xmm0
movups (%r11),%xmm1
addps  %xmm0,%xmm1
movups %xmm1,(%r14)
jmp    2086 <update2+0xf66>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  0xfc(%r8,%rax,4),%xmm0
addss  0xfc(%r11,%rax,4),%xmm0
movss  %xmm0,0xfc(%r14,%rax,4)
movss  0xf8(%r8,%rax,4),%xmm0
addss  0xf8(%r11,%rax,4),%xmm0
movss  %xmm0,0xf8(%r14,%rax,4)
movss  0xf4(%r8,%rax,4),%xmm0
addss  0xf4(%r11,%rax,4),%xmm0
movss  %xmm0,0xf4(%r14,%rax,4)
movss  0xf0(%r8,%rax,4),%xmm0
addss  0xf0(%r11,%rax,4),%xmm0
movss  %xmm0,0xf0(%r14,%rax,4)
add    $0xfffffffffffffffc,%rax
cmp    $0xffffffffffffffc0,%rax
jne    2000 <update2+0xee0>
mov    0x10(%rsp),%rax
shl    $0x6,%eax
cltq
shl    $0x2,%rax
sub    %rax,%r14
mov    %r9,%rdi
call   1030 <free@plt>
mov    %r14,%rax
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    $0x1,%ecx
test   $0x1,%dl
jne    1238 <update2+0x118>
jmp    1281 <update2+0x161>

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

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