#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 */
scalar_t__ calloc(int, int);
int /*<<< orphan*/ exit(int);
double fabs(double);
int /*<<< orphan*/ printf(char *);
int /*<<< orphan*/ simd_find_position(int, int, char *, int, char *, int,
                                      float *, int, int, float, int *, int *);
void simd_traceback(int depth, int num_seqs, char **q, int *q_len,
                    int max_q_len, char **r, int *r_len, int max_r_len,
                    float gap_open, float gap_extend, float *H, int *C,
                    float *max_score, char **q_alig, int *q_start,
                    char **r_alig, int *r_start, int *len_alig, char *q_aux,
                    char *r_aux) {
  char *qq, *qq_alig;
  char *rr, *rr_alig;
  int jj, kk;
  int ix, iy, gapcnt, index;
  double bimble;
  double errbounds = (double)0.01;
  int qq_len, rr_len;
  int len = 0;
  char c;
  float score;
  for (int i = 0; i < num_seqs; i++) {
    qq = q[i];
    rr = r[i];
    qq_len = q_len[i];
    rr_len = r_len[i];
    simd_find_position(depth, i, qq, qq_len, rr, rr_len, H, max_q_len,
                       max_r_len, max_score[i], &kk, &jj);
    len = 0;
    while (1) {
      index = (jj * max_q_len * depth) + (kk * depth) + i;
      score = H[index];
      if (score == 0.0f) {
        break;
      }
      c = C[index];
      if (c == 5 || c == 7) {
        q_aux[len] = qq[kk];
        r_aux[len] = rr[jj];
        len++;
        jj--;
        kk--;
        if (jj < 0)
          break;
        if (kk < 0)
          break;
        continue;
      } else if (c == 1 || c == 3) {
        gapcnt = 0;
        ix = kk - 1;
        while (1) {
          bimble = H[(jj * max_q_len * depth) + (ix * depth) + i] - gap_open -
                   (gapcnt * gap_extend);
          if (!ix || fabs((double)score - (double)bimble) < errbounds)
            break;
          --ix;
          if (ix < 0) {
            printf("Error reconstructing alignment (walking left)\n");
            exit(-1);
          }
          ++gapcnt;
        }
        if (bimble <= 0.0)
          break;
        for (int ic = 0; ic <= gapcnt; ++ic) {
          q_aux[len] = qq[kk--];
          r_aux[len] = '-';
          len++;
        }
        continue;
      } else if (c == 2 || c == 6) {
        gapcnt = 0;
        iy = jj - 1;
        while (1) {
          bimble = H[(iy * max_q_len * depth) + (kk * depth) + i] - gap_open -
                   (gapcnt * gap_extend);
          if (!iy || fabs((double)score - (double)bimble) < errbounds)
            break;
          --iy;
          if (iy < 0) {
            printf("Error reconstructing alignment (walking down)\n");
            exit(-1);
          }
          ++gapcnt;
        }
        if (bimble <= 0.0)
          break;
        for (int ic = 0; ic <= gapcnt; ++ic) {
          q_aux[len] = '-';
          r_aux[len] = rr[jj--];
          len++;
        }
        continue;
      } else {
        break;
      }
    }
    q_start[i] = kk + 1;
    r_start[i] = jj + 1;
    q_aux[len] = 0;
    r_aux[len] = 0;
    qq_alig = (char *)calloc(len + 1, sizeof(char));
    rr_alig = (char *)calloc(len + 1, sizeof(char));
    jj = len - 1;
    for (int i = 0; i < len; i++) {
      qq_alig[i] = q_aux[jj];
      rr_alig[i] = r_aux[jj];
      jj--;
    }
    qq_alig[len] = 0;
    rr_alig[len] = 0;
    q_alig[i] = qq_alig;
    r_alig[i] = rr_alig;
    len_alig[i] = len;
  }
}


x86 assembly (clang, -O0):
<simd_traceback>:
push   %rbp
mov    %rsp,%rbp
push   %r14
push   %rbx
sub    $0xd0,%rsp
mov    0x68(%rbp),%rax
mov    0x60(%rbp),%rax
mov    0x58(%rbp),%rax
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%rax
mov    %edi,-0x14(%rbp)
mov    %esi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8d,-0x2c(%rbp)
mov    %r9,-0x38(%rbp)
movss  %xmm0,-0x3c(%rbp)
movss  %xmm1,-0x40(%rbp)
movsd  0xe5b(%rip),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movl   $0x0,-0x94(%rbp)
movl   $0x0,-0xa0(%rbp)
mov    -0xa0(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    17d4 <simd_traceback+0x694>
mov    -0x20(%rbp),%rax
movslq -0xa0(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x48(%rbp)
mov    -0x38(%rbp),%rax
movslq -0xa0(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x58(%rbp)
mov    -0x28(%rbp),%rax
movslq -0xa0(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x8c(%rbp)
mov    0x10(%rbp),%rax
movslq -0xa0(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x90(%rbp)
mov    -0x14(%rbp),%edi
mov    -0xa0(%rbp),%esi
mov    -0x48(%rbp),%rdx
mov    -0x8c(%rbp),%ecx
mov    -0x58(%rbp),%r8
mov    -0x90(%rbp),%r9d
mov    0x20(%rbp),%r14
mov    -0x2c(%rbp),%ebx
mov    0x18(%rbp),%r11d
mov    0x30(%rbp),%rax
movslq -0xa0(%rbp),%r10
movss  (%rax,%r10,4),%xmm0
lea    -0x68(%rbp),%r10
lea    -0x64(%rbp),%rax
mov    %r14,(%rsp)
mov    %ebx,0x8(%rsp)
mov    %r11d,0x10(%rsp)
mov    %r10,0x18(%rsp)
mov    %rax,0x20(%rsp)
call   1040 <simd_find_position@plt>
movl   $0x0,-0x94(%rbp)
mov    -0x64(%rbp),%eax
imul   -0x2c(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    -0x68(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    %ecx,%eax
add    -0xa0(%rbp),%eax
mov    %eax,-0x78(%rbp)
mov    0x20(%rbp),%rax
movslq -0x78(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
movss  -0x9c(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    12d7 <simd_traceback+0x197>
jp     12d7 <simd_traceback+0x197>
jmp    167d <simd_traceback+0x53d>
mov    0x28(%rbp),%rax
movslq -0x78(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %al,-0x95(%rbp)
movsbl -0x95(%rbp),%eax
cmp    $0x5,%eax
je     1308 <simd_traceback+0x1c8>
movsbl -0x95(%rbp),%eax
cmp    $0x7,%eax
jne    137e <simd_traceback+0x23e>
mov    -0x48(%rbp),%rax
movslq -0x68(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    0x60(%rbp),%rax
movslq -0x94(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x58(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    0x68(%rbp),%rax
movslq -0x94(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
mov    -0x64(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x64(%rbp)
mov    -0x68(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x68(%rbp)
cmpl   $0x0,-0x64(%rbp)
jge    136a <simd_traceback+0x22a>
jmp    167d <simd_traceback+0x53d>
cmpl   $0x0,-0x68(%rbp)
jge    1379 <simd_traceback+0x239>
jmp    167d <simd_traceback+0x53d>
jmp    1286 <simd_traceback+0x146>
movsbl -0x95(%rbp),%eax
cmp    $0x1,%eax
je     139e <simd_traceback+0x25e>
movsbl -0x95(%rbp),%eax
cmp    $0x3,%eax
jne    14fb <simd_traceback+0x3bb>
movl   $0x0,-0x74(%rbp)
mov    -0x68(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x6c(%rbp)
mov    0x20(%rbp),%rax
mov    -0x64(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
mov    -0x6c(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
add    -0xa0(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
subss  -0x3c(%rbp),%xmm1
cvtsi2ssl -0x74(%rbp),%xmm0
movss  -0x40(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
cmpl   $0x0,-0x6c(%rbp)
je     1439 <simd_traceback+0x2f9>
movss  -0x9c(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
subsd  -0x80(%rbp),%xmm1
movaps 0xbed(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  -0x88(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    143e <simd_traceback+0x2fe>
jmp    1475 <simd_traceback+0x335>
mov    -0x6c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x6c(%rbp)
cmpl   $0x0,-0x6c(%rbp)
jge    1467 <simd_traceback+0x327>
lea    0xbc8(%rip),%rdi
call   1030 <printf@plt>
mov    $0xffffffff,%edi
call   1060 <exit@plt>
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    13ae <simd_traceback+0x26e>
xorps  %xmm0,%xmm0
ucomisd -0x80(%rbp),%xmm0
jb     1488 <simd_traceback+0x348>
jmp    167d <simd_traceback+0x53d>
movl   $0x0,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
cmp    -0x74(%rbp),%eax
jg     14f6 <simd_traceback+0x3b6>
mov    -0x48(%rbp),%rax
mov    -0x68(%rbp),%ecx
mov    %ecx,%edx
add    $0xffffffff,%edx
mov    %edx,-0x68(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    0x60(%rbp),%rax
movslq -0x94(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    0x68(%rbp),%rax
movslq -0x94(%rbp),%rcx
movb   $0x2d,(%rax,%rcx,1)
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    1492 <simd_traceback+0x352>
jmp    1286 <simd_traceback+0x146>
movsbl -0x95(%rbp),%eax
cmp    $0x2,%eax
je     151b <simd_traceback+0x3db>
movsbl -0x95(%rbp),%eax
cmp    $0x6,%eax
jne    1678 <simd_traceback+0x538>
movl   $0x0,-0x74(%rbp)
mov    -0x64(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x70(%rbp)
mov    0x20(%rbp),%rax
mov    -0x70(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
mov    -0x68(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
add    -0xa0(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
subss  -0x3c(%rbp),%xmm1
cvtsi2ssl -0x74(%rbp),%xmm0
movss  -0x40(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
cmpl   $0x0,-0x70(%rbp)
je     15b6 <simd_traceback+0x476>
movss  -0x9c(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
subsd  -0x80(%rbp),%xmm1
movaps 0xa70(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  -0x88(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    15bb <simd_traceback+0x47b>
jmp    15f2 <simd_traceback+0x4b2>
mov    -0x70(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x70(%rbp)
cmpl   $0x0,-0x70(%rbp)
jge    15e4 <simd_traceback+0x4a4>
lea    0xa7a(%rip),%rdi
call   1030 <printf@plt>
mov    $0xffffffff,%edi
call   1060 <exit@plt>
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    152b <simd_traceback+0x3eb>
xorps  %xmm0,%xmm0
ucomisd -0x80(%rbp),%xmm0
jb     1605 <simd_traceback+0x4c5>
jmp    167d <simd_traceback+0x53d>
movl   $0x0,-0xa8(%rbp)
mov    -0xa8(%rbp),%eax
cmp    -0x74(%rbp),%eax
jg     1673 <simd_traceback+0x533>
mov    0x60(%rbp),%rax
movslq -0x94(%rbp),%rcx
movb   $0x2d,(%rax,%rcx,1)
mov    -0x58(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    %ecx,%edx
add    $0xffffffff,%edx
mov    %edx,-0x64(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    0x68(%rbp),%rax
movslq -0x94(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
jmp    160f <simd_traceback+0x4cf>
jmp    1286 <simd_traceback+0x146>
jmp    167d <simd_traceback+0x53d>
mov    -0x68(%rbp),%edx
add    $0x1,%edx
mov    0x40(%rbp),%rax
movslq -0xa0(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x64(%rbp),%edx
add    $0x1,%edx
mov    0x50(%rbp),%rax
movslq -0xa0(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x60(%rbp),%rax
movslq -0x94(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    0x68(%rbp),%rax
movslq -0x94(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x94(%rbp),%edi
add    $0x1,%edi
mov    $0x1,%esi
call   1050 <calloc@plt>
mov    %rax,-0x50(%rbp)
mov    -0x94(%rbp),%edi
add    $0x1,%edi
mov    $0x1,%esi
call   1050 <calloc@plt>
mov    %rax,-0x60(%rbp)
mov    -0x94(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x64(%rbp)
movl   $0x0,-0xac(%rbp)
mov    -0xac(%rbp),%eax
cmp    -0x94(%rbp),%eax
jge    1768 <simd_traceback+0x628>
mov    0x60(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x50(%rbp),%rax
movslq -0xac(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    0x68(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x60(%rbp),%rax
movslq -0xac(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x64(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x64(%rbp)
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    1707 <simd_traceback+0x5c7>
mov    -0x50(%rbp),%rax
movslq -0x94(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x60(%rbp),%rax
movslq -0x94(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x50(%rbp),%rdx
mov    0x38(%rbp),%rax
movslq -0xa0(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x60(%rbp),%rdx
mov    0x48(%rbp),%rax
movslq -0xa0(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x94(%rbp),%edx
mov    0x58(%rbp),%rax
movslq -0xa0(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0xa0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa0(%rbp)
jmp    11c1 <simd_traceback+0x81>
add    $0xd0,%rsp
pop    %rbx
pop    %r14
pop    %rbp
ret

x86 assembly (clang, -O2):
<simd_traceback>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xb8,%rsp
mov    %r9,0xa0(%rsp)
mov    %rcx,0x98(%rsp)
mov    %rdx,0x90(%rsp)
test   %esi,%esi
jle    1cac <simd_traceback+0xb6c>
mov    %r8d,%r15d
mov    %edi,%r13d
mov    0x148(%rsp),%rax
mov    0x140(%rsp),%rcx
mov    0x100(%rsp),%r14
mov    %esi,%edx
mov    %rdx,0x88(%rsp)
mov    %r8d,%edx
imul   %edi,%edx
mov    %edx,0x74(%rsp)
movss  0xe55(%rip),%xmm2
mulss  %xmm1,%xmm2
movss  %xmm2,0x54(%rsp)
lea    0x1(%rcx),%rdx
mov    %rdx,0x60(%rsp)
lea    0x1(%rax),%rdx
mov    %rdx,0x58(%rsp)
add    $0x4,%rcx
mov    %rcx,0x80(%rsp)
add    $0x4,%rax
mov    %rax,0x78(%rsp)
xor    %ebx,%ebx
mov    %r15,0x48(%rsp)
mov    %edi,0x2c(%rsp)
movss  %xmm1,0x70(%rsp)
movss  %xmm0,0x6c(%rsp)
jmp    124e <simd_traceback+0x10e>
cs nopw 0x0(%rax,%rax,1)
nop
movb   $0x0,0x0(%rbp,%r14,1)
movb   $0x0,(%rax,%r14,1)
mov    0x118(%rsp),%rcx
mov    0x20(%rsp),%rbx
mov    %rbp,(%rcx,%rbx,8)
mov    0x128(%rsp),%rcx
mov    %rax,(%rcx,%rbx,8)
mov    0x138(%rsp),%rax
mov    %r12d,(%rax,%rbx,4)
add    $0x1,%rbx
cmp    0x88(%rsp),%rbx
mov    0x100(%rsp),%r14
je     1cac <simd_traceback+0xb6c>
mov    0x90(%rsp),%rax
mov    %r15,%rbp
mov    (%rax,%rbx,8),%r15
mov    0xa0(%rsp),%rax
mov    (%rax,%rbx,8),%r12
mov    0x98(%rsp),%rax
mov    (%rax,%rbx,4),%ecx
mov    0xf0(%rsp),%rax
mov    (%rax,%rbx,4),%r9d
mov    0x110(%rsp),%rax
movss  (%rax,%rbx,4),%xmm0
sub    $0x8,%rsp
mov    %r13d,%edi
mov    %ebx,%esi
mov    %r15,%rdx
mov    %r12,%r8
lea    0x14(%rsp),%rax
push   %rax
lea    0x28(%rsp),%rax
push   %rax
mov    0x110(%rsp),%eax
push   %rax
push   %rbp
push   %r14
call   1040 <simd_find_position@plt>
add    $0x30,%rsp
mov    0xc(%rsp),%r11d
mov    %r11d,%eax
mov    %rbp,%rdi
imul   %ebp,%eax
mov    0x18(%rsp),%r10d
lea    (%rax,%r10,1),%ecx
imul   %r13d,%ecx
add    %ebx,%ecx
movslq %ecx,%rdx
movss  (%r14,%rdx,4),%xmm0
xorps  %xmm8,%xmm8
ucomiss %xmm8,%xmm0
mov    %rbx,0x20(%rsp)
jne    1320 <simd_traceback+0x1e0>
jp     1320 <simd_traceback+0x1e0>
mov    %r10d,%ecx
xor    %r12d,%r12d
mov    0x148(%rsp),%r8
mov    0x140(%rsp),%rsi
mov    %rdi,%r15
jmp    1ba0 <simd_traceback+0xa60>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r12,0x40(%rsp)
lea    0x1(%r12),%rcx
mov    %rcx,0xa8(%rsp)
lea    0x1(%r15),%rcx
mov    %rcx,0xb0(%rsp)
xor    %r12d,%r12d
movss  0x70(%rsp),%xmm4
movss  0x6c(%rsp),%xmm5
mov    0x148(%rsp),%r8
mov    0x140(%rsp),%rsi
pxor   %xmm9,%xmm9
movapd 0xca6(%rip),%xmm6
movsd  0xcae(%rip),%xmm7
mov    %r15,%r9
mov    %r15,0x30(%rsp)
mov    %rdi,%r15
jmp    13b4 <simd_traceback+0x274>
nop
mov    %r14d,%r10d
mov    0x100(%rsp),%r14
mov    %r11d,%eax
imul   %r15d,%eax
lea    (%rax,%r10,1),%ecx
imul   %r13d,%ecx
add    %ebx,%ecx
movslq %ecx,%rdx
movss  (%r14,%rdx,4),%xmm0
ucomiss %xmm8,%xmm0
mov    %r10d,%ecx
jne    13b4 <simd_traceback+0x274>
jnp    1ba0 <simd_traceback+0xa60>
mov    0x108(%rsp),%rcx
mov    (%rcx,%rdx,4),%ecx
mov    %ecx,%edx
and    $0xfd,%dl
cmp    $0x5,%dl
je     1480 <simd_traceback+0x340>
cmp    $0x1,%dl
jne    14d0 <simd_traceback+0x390>
lea    -0x1(%r10),%ecx
lea    (%r10,%rax,1),%edx
add    $0xffffffff,%edx
imul   %r13d,%edx
add    %ebx,%edx
movslq %edx,%rdx
movss  (%r14,%rdx,4),%xmm1
subss  %xmm5,%xmm1
addss  0x54(%rsp),%xmm1
test   %ecx,%ecx
je     1590 <simd_traceback+0x450>
cvtss2sd %xmm0,%xmm0
test   %r10d,%r10d
mov    $0x1,%edx
cmovle %r10d,%edx
mov    %r10d,%ebp
sub    %edx,%ebp
add    %r10d,%eax
add    $0xfffffffe,%eax
imul   %r13d,%eax
add    %ebx,%eax
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nop
xorps  %xmm2,%xmm2
cvtss2sd %xmm1,%xmm2
movaps %xmm0,%xmm3
subsd  %xmm2,%xmm3
andpd  %xmm6,%xmm3
ucomisd %xmm3,%xmm7
ja     1592 <simd_traceback+0x452>
cmp    %edi,%ebp
je     1cbe <simd_traceback+0xb7e>
add    $0x1,%edi
cltq
movss  (%r14,%rax,4),%xmm1
subss  %xmm5,%xmm1
xorps  %xmm2,%xmm2
cvtsi2ss %edi,%xmm2
mulss  %xmm4,%xmm2
subss  %xmm2,%xmm1
sub    %r13d,%eax
cmp    %edi,%ecx
jne    1430 <simd_traceback+0x2f0>
mov    %ecx,%edi
jmp    1592 <simd_traceback+0x452>
movslq %r10d,%rax
mov    (%r9,%rax,1),%al
movslq %r12d,%rcx
mov    %al,(%rsi,%rcx,1)
movslq %r11d,%rax
mov    0x40(%rsp),%rdx
mov    (%rdx,%rax,1),%dl
mov    %dl,(%r8,%rcx,1)
add    $0x1,%r12d
lea    -0x1(%rax),%r11d
mov    %r11d,0xc(%rsp)
lea    -0x1(%r10),%ecx
mov    %ecx,0x18(%rsp)
test   %eax,%eax
jle    1ba0 <simd_traceback+0xa60>
test   %r10d,%r10d
mov    %ecx,%r10d
jg     138b <simd_traceback+0x24b>
jmp    1ba0 <simd_traceback+0xa60>
nopw   0x0(%rax,%rax,1)
and    $0xfb,%ecx
cmp    $0x2,%ecx
jne    1b97 <simd_traceback+0xa57>
lea    -0x1(%r11),%eax
mov    %eax,%ecx
imul   %r15d,%ecx
add    %r10d,%ecx
imul   %r13d,%ecx
add    %ebx,%ecx
movslq %ecx,%rcx
movss  (%r14,%rcx,4),%xmm1
subss  %xmm5,%xmm1
addss  0x54(%rsp),%xmm1
test   %eax,%eax
je     1764 <simd_traceback+0x624>
test   %r11d,%r11d
mov    $0x1,%edx
cmovle %r11d,%edx
cvtss2sd %xmm0,%xmm0
mov    %r11d,%ecx
sub    %edx,%ecx
lea    -0x2(%r11),%ebp
imul   %r15d,%ebp
add    %r10d,%ebp
imul   %r13d,%ebp
add    %ebx,%ebp
xor    %edi,%edi
mov    0x74(%rsp),%edx
nopl   0x0(%rax)
xorps  %xmm2,%xmm2
cvtss2sd %xmm1,%xmm2
movaps %xmm0,%xmm3
subsd  %xmm2,%xmm3
andpd  %xmm6,%xmm3
ucomisd %xmm3,%xmm7
ja     1766 <simd_traceback+0x626>
cmp    %edi,%ecx
je     1cc7 <simd_traceback+0xb87>
add    $0x1,%edi
movslq %ebp,%rbp
movss  (%r14,%rbp,4),%xmm1
subss  %xmm5,%xmm1
xorps  %xmm2,%xmm2
cvtsi2ss %edi,%xmm2
mulss  %xmm4,%xmm2
subss  %xmm2,%xmm1
sub    %edx,%ebp
cmp    %edi,%eax
jne    1540 <simd_traceback+0x400>
mov    %eax,%edi
jmp    1766 <simd_traceback+0x626>
xor    %edi,%edi
ucomiss %xmm1,%xmm8
jae    1b97 <simd_traceback+0xa57>
movslq %r12d,%rax
xor    %ebp,%ebp
cmp    $0x7,%edi
jae    15b1 <simd_traceback+0x471>
mov    %r10d,%r14d
mov    %rax,%r12
jmp    1947 <simd_traceback+0x807>
mov    %edi,%r13d
lea    (%rsi,%rax,1),%rcx
lea    (%rax,%r13,1),%rdx
mov    0x60(%rsp),%rsi
lea    (%rsi,%rdx,1),%rbx
mov    %r9,%r12
lea    (%r8,%rax,1),%r9
add    0x58(%rsp),%rdx
movslq %r10d,%r15
mov    0xb0(%rsp),%rsi
lea    (%rsi,%r15,1),%r14
mov    %r13,0x38(%rsp)
sub    %r13,%r15
add    %r12,%r15
lea    0x18(%rsp),%r8
cmp    %r8,%rbx
seta   0x17(%rsp)
lea    0x1c(%rsp),%rsi
cmp    %rsi,%rcx
setb   0x16(%rsp)
cmp    %r8,%rdx
seta   %r13b
cmp    %rsi,%r9
setb   0x15(%rsp)
cmp    %r8,%r14
seta   %r8b
cmp    %rsi,%r15
setb   0x14(%rsp)
cmp    %rdx,%rcx
setb   %sil
cmp    %rbx,%r9
setb   0x13(%rsp)
cmp    %r14,%rcx
setb   %r12b
cmp    %rbx,%r15
setb   %bl
cmp    %r14,%r9
setb   %r9b
cmp    %rdx,%r15
setb   %dl
mov    0x16(%rsp),%cl
test   %cl,0x17(%rsp)
jne    1b19 <simd_traceback+0x9d9>
mov    %ebx,%ecx
and    0x15(%rsp),%r13b
mov    0x20(%rsp),%rbx
jne    1b43 <simd_traceback+0xa03>
and    0x14(%rsp),%r8b
mov    0x48(%rsp),%r15
mov    0x2c(%rsp),%r13d
jne    1b11 <simd_traceback+0x9d1>
and    0x13(%rsp),%sil
mov    0x148(%rsp),%r8
jne    1934 <simd_traceback+0x7f4>
and    %cl,%r12b
jne    1934 <simd_traceback+0x7f4>
and    %dl,%r9b
jne    1934 <simd_traceback+0x7f4>
mov    0x38(%rsp),%rbp
add    $0x1,%rbp
mov    %rbp,0x38(%rsp)
movabs $0x1fffffff8,%rcx
and    %rcx,%rbp
mov    %r10d,%r14d
sub    %ebp,%r14d
lea    (%rax,%rbp,1),%r12
mov    0x80(%rsp),%rcx
lea    (%rcx,%rax,1),%rdx
movabs $0x2d2d2d2d2d2d2d2d,%rcx
2d 2d 2d
add    0x78(%rsp),%rax
xor    %ebx,%ebx
mov    0x140(%rsp),%rsi
mov    0x30(%rsp),%r9
cs nopw 0x0(%rax,%rax,1)
nop
movslq %r10d,%r10
movd   -0x3(%r9,%r10,1),%xmm0
punpcklbw %xmm9,%xmm0
pshuflw $0x1b,%xmm0,%xmm0
packuswb %xmm0,%xmm0
movd   -0x7(%r9,%r10,1),%xmm1
punpcklbw %xmm9,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
packuswb %xmm1,%xmm1
movd   %xmm0,-0x4(%rdx,%rbx,1)
movd   %xmm1,(%rdx,%rbx,1)
mov    %rcx,-0x4(%rax,%rbx,1)
add    $0x8,%rbx
add    $0xfffffff8,%r10d
cmp    %rbx,%rbp
jne    1700 <simd_traceback+0x5c0>
mov    %r10d,0x18(%rsp)
cmp    %rbp,0x38(%rsp)
mov    0x20(%rsp),%rbx
je     1380 <simd_traceback+0x240>
jmp    1947 <simd_traceback+0x807>
xor    %edi,%edi
ucomiss %xmm1,%xmm8
jae    1b97 <simd_traceback+0xa57>
movslq %r12d,%rax
xor    %ebp,%ebp
cmp    $0x7,%edi
jae    178a <simd_traceback+0x64a>
mov    %r11d,%r9d
mov    %rax,%r12
mov    0x40(%rsp),%rsi
jmp    1a1c <simd_traceback+0x8dc>
mov    %edi,%ecx
lea    (%rsi,%rax,1),%r14
lea    (%rax,%rcx,1),%rbx
mov    0x60(%rsp),%rdx
add    %rbx,%rdx
lea    (%r8,%rax,1),%r9
add    0x58(%rsp),%rbx
movslq %r11d,%r8
mov    0xa8(%rsp),%rsi
lea    (%rsi,%r8,1),%r12
mov    %rcx,0x38(%rsp)
sub    %rcx,%r8
add    0x40(%rsp),%r8
cmp    %rbx,%r14
setb   0x17(%rsp)
cmp    %rdx,%r9
setb   0x16(%rsp)
lea    0x10(%rsp),%r13
cmp    %r13,%r14
setb   %r15b
lea    0xc(%rsp),%rsi
cmp    %rsi,%rdx
seta   0x15(%rsp)
cmp    %r12,%r14
setb   %cl
cmp    %rdx,%r8
setb   0x14(%rsp)
cmp    %r13,%r9
setb   %r14b
cmp    %rsi,%rbx
seta   0x13(%rsp)
cmp    %r12,%r9
setb   %r9b
cmp    %rbx,%r8
setb   0x1f(%rsp)
cmp    %rsi,%r12
seta   %bl
cmp    %r13,%r8
setb   %r12b
mov    0x16(%rsp),%dl
test   %dl,0x17(%rsp)
jne    1b60 <simd_traceback+0xa20>
and    0x15(%rsp),%r15b
mov    0x48(%rsp),%r15
mov    0x2c(%rsp),%r13d
mov    0x148(%rsp),%r8
jne    1b7a <simd_traceback+0xa3a>
and    0x14(%rsp),%cl
mov    0x40(%rsp),%rsi
jne    1afe <simd_traceback+0x9be>
and    0x13(%rsp),%r14b
jne    1afe <simd_traceback+0x9be>
and    0x1f(%rsp),%r9b
mov    0x100(%rsp),%r14
jne    1a11 <simd_traceback+0x8d1>
and    %r12b,%bl
jne    1a11 <simd_traceback+0x8d1>
mov    0x38(%rsp),%rbp
add    $0x1,%rbp
mov    %rbp,0x38(%rsp)
movabs $0x1fffffff8,%rcx
and    %rcx,%rbp
mov    %r11d,%r9d
sub    %ebp,%r9d
lea    (%rax,%rbp,1),%r12
mov    0x80(%rsp),%rcx
lea    (%rcx,%rax,1),%rdx
movabs $0x2d2d2d2d2d2d2d2d,%rcx
2d 2d 2d
add    0x78(%rsp),%rax
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
mov    %rcx,-0x4(%rdx,%rbx,1)
movslq %r11d,%r11
movd   -0x3(%rsi,%r11,1),%xmm0
punpcklbw %xmm9,%xmm0
pshuflw $0x1b,%xmm0,%xmm0
packuswb %xmm0,%xmm0
movd   -0x7(%rsi,%r11,1),%xmm1
punpcklbw %xmm9,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
packuswb %xmm1,%xmm1
movd   %xmm0,-0x4(%rax,%rbx,1)
movd   %xmm1,(%rax,%rbx,1)
add    $0x8,%rbx
add    $0xfffffff8,%r11d
cmp    %rbx,%rbp
jne    18d0 <simd_traceback+0x790>
mov    %r11d,0xc(%rsp)
cmp    %rbp,0x38(%rsp)
mov    0x20(%rsp),%rbx
jne    1a1c <simd_traceback+0x8dc>
jmp    1ae9 <simd_traceback+0x9a9>
mov    %r10d,%r14d
mov    %rax,%r12
mov    0x140(%rsp),%rsi
mov    0x30(%rsp),%r9
mov    %edi,%eax
sub    %ebp,%eax
add    $0x1,%eax
test   $0x1,%al
jne    195e <simd_traceback+0x81e>
mov    %ebp,%edx
cmp    %ebp,%edi
je     1380 <simd_traceback+0x240>
jmp    1988 <simd_traceback+0x848>
movslq %r14d,%rax
lea    -0x1(%r14),%ecx
mov    %ecx,0x18(%rsp)
mov    (%r9,%rax,1),%al
mov    %al,(%rsi,%r12,1)
movb   $0x2d,(%r8,%r12,1)
add    $0x1,%r12
lea    0x1(%rbp),%edx
mov    %ecx,%r14d
cmp    %ebp,%edi
je     1380 <simd_traceback+0x240>
mov    %r9,%rax
lea    -0x2(%r14),%r9d
lea    -0x1(%r14),%ecx
movslq %ecx,%rsi
add    %rax,%rsi
movslq %r14d,%rbp
add    %rax,%rbp
not    %edi
add    %edx,%edi
mov    0x58(%rsp),%rdx
mov    0x60(%rsp),%r8
xor    %ebx,%ebx
nop
lea    (%rcx,%rbx,1),%eax
mov    %eax,0x18(%rsp)
movzbl 0x0(%rbp,%rbx,1),%eax
mov    %al,-0x1(%r8,%r12,1)
movb   $0x2d,-0x1(%rdx,%r12,1)
lea    (%r9,%rbx,1),%eax
mov    %eax,0x18(%rsp)
movzbl (%rsi,%rbx,1),%eax
mov    %al,(%r8,%r12,1)
movb   $0x2d,(%rdx,%r12,1)
add    $0xfffffffffffffffe,%rbx
add    $0x2,%r8
add    $0x2,%rdx
cmp    %ebx,%edi
jne    19b0 <simd_traceback+0x870>
add    %ebx,%r14d
sub    %rbx,%r12
mov    0x148(%rsp),%r8
mov    0x140(%rsp),%rsi
mov    0x20(%rsp),%rbx
mov    0x30(%rsp),%r9
jmp    1380 <simd_traceback+0x240>
mov    %r11d,%r9d
mov    %rax,%r12
mov    0x20(%rsp),%rbx
mov    %edi,%eax
sub    %ebp,%eax
add    $0x1,%eax
test   $0x1,%al
jne    1a32 <simd_traceback+0x8f2>
mov    %ebp,%eax
cmp    %ebp,%edi
jne    1a63 <simd_traceback+0x923>
jmp    1ae9 <simd_traceback+0x9a9>
mov    0x140(%rsp),%rax
movb   $0x2d,(%rax,%r12,1)
movslq %r9d,%rax
lea    -0x1(%r9),%ecx
mov    %ecx,0xc(%rsp)
mov    (%rsi,%rax,1),%al
mov    %al,(%r8,%r12,1)
add    $0x1,%r12
lea    0x1(%rbp),%eax
mov    %ecx,%r9d
cmp    %ebp,%edi
je     1ae9 <simd_traceback+0x9a9>
lea    -0x2(%r9),%r11d
lea    -0x1(%r9),%r8d
movslq %r8d,%r14
add    %rsi,%r14
movslq %r9d,%rbp
add    %rsi,%rbp
not    %edi
add    %eax,%edi
mov    0x58(%rsp),%rax
mov    0x60(%rsp),%rcx
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movb   $0x2d,-0x1(%rcx,%r12,1)
lea    (%r8,%rbx,1),%esi
mov    %esi,0xc(%rsp)
movzbl 0x0(%rbp,%rbx,1),%edx
mov    %dl,-0x1(%rax,%r12,1)
movb   $0x2d,(%rcx,%r12,1)
lea    (%r11,%rbx,1),%edx
mov    %edx,0xc(%rsp)
movzbl (%r14,%rbx,1),%edx
mov    %dl,(%rax,%r12,1)
add    $0xfffffffffffffffe,%rbx
add    $0x2,%rcx
add    $0x2,%rax
cmp    %ebx,%edi
jne    1a90 <simd_traceback+0x950>
add    %ebx,%r9d
sub    %rbx,%r12
mov    0x148(%rsp),%r8
mov    0x100(%rsp),%r14
mov    0x20(%rsp),%rbx
mov    %r9d,%r11d
mov    0x140(%rsp),%rsi
mov    0x30(%rsp),%r9
jmp    138b <simd_traceback+0x24b>
mov    %r11d,%r9d
mov    %rax,%r12
mov    0x100(%rsp),%r14
jmp    1a17 <simd_traceback+0x8d7>
mov    %r10d,%r14d
mov    %rax,%r12
jmp    1b53 <simd_traceback+0xa13>
mov    %r10d,%r14d
mov    %rax,%r12
mov    0x48(%rsp),%r15
mov    0x2c(%rsp),%r13d
mov    0x148(%rsp),%r8
mov    0x140(%rsp),%rsi
mov    0x20(%rsp),%rbx
jmp    1942 <simd_traceback+0x802>
mov    %r10d,%r14d
mov    %rax,%r12
mov    0x48(%rsp),%r15
mov    0x2c(%rsp),%r13d
mov    0x148(%rsp),%r8
jmp    193a <simd_traceback+0x7fa>
mov    %r11d,%r9d
mov    %rax,%r12
mov    0x48(%rsp),%r15
mov    0x2c(%rsp),%r13d
mov    0x148(%rsp),%r8
jmp    1b80 <simd_traceback+0xa40>
mov    %r11d,%r9d
mov    %rax,%r12
mov    0x100(%rsp),%r14
mov    0x20(%rsp),%rbx
mov    0x40(%rsp),%rsi
jmp    1a1c <simd_traceback+0x8dc>
mov    %r10d,%ecx
nopw   0x0(%rax,%rax,1)
add    $0x1,%ecx
mov    0x120(%rsp),%rax
mov    %ecx,(%rax,%rbx,4)
add    $0x1,%r11d
mov    0x130(%rsp),%rax
mov    %r11d,(%rax,%rbx,4)
movslq %r12d,%r14
movb   $0x0,(%rsi,%r14,1)
movb   $0x0,(%r8,%r14,1)
lea    0x1(%r14),%ebx
mov    %ebx,%edi
mov    $0x1,%esi
call   1050 <calloc@plt>
mov    %rax,%rbp
mov    %ebx,%edi
mov    $0x1,%esi
call   1050 <calloc@plt>
mov    0x140(%rsp),%r9
mov    0x148(%rsp),%r8
lea    -0x1(%r14),%edx
mov    %edx,0xc(%rsp)
test   %r14d,%r14d
jle    1200 <simd_traceback+0xc0>
mov    %r12d,%ecx
cmp    $0x1,%r12d
jne    1c20 <simd_traceback+0xae0>
xor    %esi,%esi
jmp    1c82 <simd_traceback+0xb42>
nopl   0x0(%rax,%rax,1)
mov    %ecx,%edi
and    $0xfffffffe,%edi
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movslq %edx,%rdx
movzbl (%r9,%rdx,1),%edx
mov    %dl,0x0(%rbp,%rsi,1)
movslq 0xc(%rsp),%rdx
movzbl (%r8,%rdx,1),%edx
mov    %dl,(%rax,%rsi,1)
movslq 0xc(%rsp),%rdx
lea    -0x1(%rdx),%rbx
mov    %ebx,0xc(%rsp)
movzbl -0x1(%r9,%rdx,1),%edx
mov    %dl,0x1(%rbp,%rsi,1)
movslq 0xc(%rsp),%rdx
movzbl (%r8,%rdx,1),%edx
mov    %dl,0x1(%rax,%rsi,1)
mov    0xc(%rsp),%edx
add    $0xffffffff,%edx
mov    %edx,0xc(%rsp)
add    $0x2,%rsi
cmp    %rsi,%rdi
jne    1c30 <simd_traceback+0xaf0>
test   $0x1,%cl
je     1200 <simd_traceback+0xc0>
movslq %edx,%rcx
mov    (%r9,%rcx,1),%cl
mov    %cl,0x0(%rbp,%rsi,1)
movslq 0xc(%rsp),%rcx
mov    (%r8,%rcx,1),%cl
mov    %cl,(%rax,%rsi,1)
addl   $0xffffffff,0xc(%rsp)
jmp    1200 <simd_traceback+0xc0>
add    $0xb8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0x391(%rip),%rdi
jmp    1cce <simd_traceback+0xb8e>
lea    0x35a(%rip),%rdi
call   1030 <puts@plt>
mov    $0xffffffff,%edi
call   1060 <exit@plt>

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

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