#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 labs(long);
int /*<<< orphan*/ memcpy(char *, char *, int);
int imcomp_copy_overlap(char *tile, int pixlen, int ndim, long *tfpixel,
                        long *tlpixel, char *bnullarray, char *image,
                        long *fpixel, long *lpixel, long *ininc, int nullcheck,
                        char *nullarray, int *status) {
  long imgdim[6];
  long tiledim[6];
  long imgfpix[6];
  long imglpix[6];
  long tilefpix[6];
  long inc[6];
  long i1, i2, i3, i4;
  long it1, it2, it3, it4;
  long im1, im2, im3, im4;
  long ipos, tf, tl;
  long t2, t3, t4;
  long tilepix, imgpix, tilepixbyte, imgpixbyte;
  int ii, overlap_bytes, overlap_flags;
  if (*status > 0)
    return (*status);
  for (ii = 0; ii < 6; ii++) {
    inc[ii] = 1;
    imgdim[ii] = 1;
    tiledim[ii] = 1;
    imgfpix[ii] = 0;
    imglpix[ii] = 0;
    tilefpix[ii] = 0;
  }
  for (ii = 0; ii < ndim; ii++) {
    if (tlpixel[ii] < fpixel[ii] || tfpixel[ii] > lpixel[ii])
      return (*status);
    inc[ii] = ininc[ii];
    imgdim[ii] = (lpixel[ii] - fpixel[ii]) / labs(inc[ii]) + 1;
    if (imgdim[ii] < 1)
      return (*status = 323);
    tiledim[ii] = tlpixel[ii] - tfpixel[ii] + 1;
    if (tiledim[ii] < 1)
      return (*status = 323);
    if (ii > 0)
      tiledim[ii] *= tiledim[ii - 1];
    tf = tfpixel[ii] - 1;
    tl = tlpixel[ii] - 1;
    while ((tf - (fpixel[ii] - 1)) % labs(inc[ii])) {
      tf++;
      if (tf > tl)
        return (*status);
    }
    while ((tl - (fpixel[ii] - 1)) % labs(inc[ii])) {
      tl--;
      if (tf > tl)
        return (*status);
    }
    imgfpix[ii] = (((tf - fpixel[ii] + 1) / labs(inc[ii])) > (0)
                       ? ((tf - fpixel[ii] + 1) / labs(inc[ii]))
                       : (0));
    imglpix[ii] = (((tl - fpixel[ii] + 1) / labs(inc[ii])) < (imgdim[ii] - 1)
                       ? ((tl - fpixel[ii] + 1) / labs(inc[ii]))
                       : (imgdim[ii] - 1));
    tilefpix[ii] =
        ((fpixel[ii] - tfpixel[ii]) > (0) ? (fpixel[ii] - tfpixel[ii]) : (0));
    while ((tfpixel[ii] + tilefpix[ii] - fpixel[ii]) % labs(inc[ii])) {
      (tilefpix[ii])++;
      if (tilefpix[ii] >= tiledim[ii])
        return (*status);
    }
    if (ii > 0)
      imgdim[ii] *= imgdim[ii - 1];
  }
  if (inc[0] != 1)
    overlap_flags = 1;
  else
    overlap_flags = imglpix[0] - imgfpix[0] + 1;
  overlap_bytes = overlap_flags * pixlen;
  for (i4 = 0, it4 = 0; i4 <= imglpix[4] - imgfpix[4]; i4++, it4++) {
    while (ndim > 4 &&
           (tfpixel[4] + tilefpix[4] - fpixel[4] + it4) % labs(inc[4]) != 0)
      it4++;
    if (inc[4] > 0)
      im4 = (i4 + imgfpix[4]) * imgdim[3];
    else
      im4 = imgdim[4] - (i4 + 1 + imgfpix[4]) * imgdim[3];
    t4 = (tilefpix[4] + it4) * tiledim[3];
    for (i3 = 0, it3 = 0; i3 <= imglpix[3] - imgfpix[3]; i3++, it3++) {
      while (ndim > 3 &&
             (tfpixel[3] + tilefpix[3] - fpixel[3] + it3) % labs(inc[3]) != 0)
        it3++;
      if (inc[3] > 0)
        im3 = (i3 + imgfpix[3]) * imgdim[2] + im4;
      else
        im3 = imgdim[3] - (i3 + 1 + imgfpix[3]) * imgdim[2] + im4;
      t3 = (tilefpix[3] + it3) * tiledim[2] + t4;
      for (i2 = 0, it2 = 0; i2 <= imglpix[2] - imgfpix[2]; i2++, it2++) {
        while (ndim > 2 &&
               (tfpixel[2] + tilefpix[2] - fpixel[2] + it2) % labs(inc[2]) != 0)
          it2++;
        if (inc[2] > 0)
          im2 = (i2 + imgfpix[2]) * imgdim[1] + im3;
        else
          im2 = imgdim[2] - (i2 + 1 + imgfpix[2]) * imgdim[1] + im3;
        t2 = (tilefpix[2] + it2) * tiledim[1] + t3;
        for (i1 = 0, it1 = 0; i1 <= imglpix[1] - imgfpix[1]; i1++, it1++) {
          while (ndim > 1 &&
                 (tfpixel[1] + tilefpix[1] - fpixel[1] + it1) % labs(inc[1]) !=
                     0)
            it1++;
          tilepix = tilefpix[0] + (tilefpix[1] + it1) * tiledim[0] + t2;
          if (inc[1] > 0)
            im1 = (i1 + imgfpix[1]) * imgdim[0] + im2;
          else
            im1 = imgdim[1] - (i1 + 1 + imgfpix[1]) * imgdim[0] + im2;
          if (inc[0] > 0)
            imgpix = imgfpix[0] + im1;
          else
            imgpix = imgdim[0] - 1 - imgfpix[0] + im1;
          for (ipos = imgfpix[0]; ipos <= imglpix[0]; ipos += overlap_flags) {
            if (nullcheck == 2) {
              memcpy(nullarray + imgpix, bnullarray + tilepix, overlap_flags);
            }
            tilepixbyte = tilepix * pixlen;
            imgpixbyte = imgpix * pixlen;
            memcpy(image + imgpixbyte, tile + tilepixbyte, overlap_bytes);
            tilepix += (overlap_flags * labs(inc[0]));
            if (inc[0] > 0)
              imgpix += overlap_flags;
            else
              imgpix -= overlap_flags;
          }
        }
      }
    }
  }
  return (*status);
}


x86 assembly (clang, -O0):
<imcomp_copy_overlap>:
push   %rbp
mov    %rsp,%rbp
sub    $0x2b0,%rsp
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%eax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %edx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    0x40(%rbp),%rax
cmpl   $0x0,(%rax)
jle    1177 <imcomp_copy_overlap+0x57>
mov    0x40(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x4(%rbp)
jmp    1fa7 <imcomp_copy_overlap+0xe87>
movl   $0x0,-0x204(%rbp)
cmpl   $0x6,-0x204(%rbp)
jge    1211 <imcomp_copy_overlap+0xf1>
movslq -0x204(%rbp),%rax
movq   $0x1,-0x150(%rbp,%rax,8)
movslq -0x204(%rbp),%rax
movq   $0x1,-0x60(%rbp,%rax,8)
movslq -0x204(%rbp),%rax
movq   $0x1,-0x90(%rbp,%rax,8)
movslq -0x204(%rbp),%rax
movq   $0x0,-0xc0(%rbp,%rax,8)
movslq -0x204(%rbp),%rax
movq   $0x0,-0xf0(%rbp,%rax,8)
movslq -0x204(%rbp),%rax
movq   $0x0,-0x120(%rbp,%rax,8)
mov    -0x204(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x204(%rbp)
jmp    1181 <imcomp_copy_overlap+0x61>
movl   $0x0,-0x204(%rbp)
mov    -0x204(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1821 <imcomp_copy_overlap+0x701>
mov    -0x28(%rbp),%rax
movslq -0x204(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x18(%rbp),%rcx
movslq -0x204(%rbp),%rdx
cmp    (%rcx,%rdx,8),%rax
jl     1272 <imcomp_copy_overlap+0x152>
mov    -0x20(%rbp),%rax
movslq -0x204(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x20(%rbp),%rcx
movslq -0x204(%rbp),%rdx
cmp    (%rcx,%rdx,8),%rax
jle    1280 <imcomp_copy_overlap+0x160>
mov    0x40(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x4(%rbp)
jmp    1fa7 <imcomp_copy_overlap+0xe87>
mov    0x28(%rbp),%rax
movslq -0x204(%rbp),%rcx
mov    (%rax,%rcx,8),%rcx
movslq -0x204(%rbp),%rax
mov    %rcx,-0x150(%rbp,%rax,8)
ff
mov    0x20(%rbp),%rax
movslq -0x204(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x18(%rbp),%rcx
movslq -0x204(%rbp),%rdx
sub    (%rcx,%rdx,8),%rax
mov    %rax,-0x218(%rbp)
movslq -0x204(%rbp),%rax
mov    -0x150(%rbp,%rax,8),%rdi
ff
call   1030 <labs@plt>
mov    %eax,%ecx
mov    -0x218(%rbp),%rax
movslq %ecx,%rcx
cqto
idiv   %rcx
mov    %rax,%rcx
add    $0x1,%rcx
movslq -0x204(%rbp),%rax
mov    %rcx,-0x60(%rbp,%rax,8)
movslq -0x204(%rbp),%rax
cmpq   $0x1,-0x60(%rbp,%rax,8)
jge    1324 <imcomp_copy_overlap+0x204>
mov    0x40(%rbp),%rax
movl   $0x143,(%rax)
movl   $0x143,-0x4(%rbp)
jmp    1fa7 <imcomp_copy_overlap+0xe87>
mov    -0x28(%rbp),%rax
movslq -0x204(%rbp),%rcx
mov    (%rax,%rcx,8),%rcx
mov    -0x20(%rbp),%rax
movslq -0x204(%rbp),%rdx
sub    (%rax,%rdx,8),%rcx
add    $0x1,%rcx
movslq -0x204(%rbp),%rax
mov    %rcx,-0x90(%rbp,%rax,8)
ff
movslq -0x204(%rbp),%rax
cmpq   $0x1,-0x90(%rbp,%rax,8)
ff 01
jge    1381 <imcomp_copy_overlap+0x261>
mov    0x40(%rbp),%rax
movl   $0x143,(%rax)
movl   $0x143,-0x4(%rbp)
jmp    1fa7 <imcomp_copy_overlap+0xe87>
cmpl   $0x0,-0x204(%rbp)
jle    13b9 <imcomp_copy_overlap+0x299>
mov    -0x204(%rbp),%eax
sub    $0x1,%eax
cltq
mov    -0x90(%rbp,%rax,8),%rcx
ff
movslq -0x204(%rbp),%rax
imul   -0x90(%rbp,%rax,8),%rcx
ff ff
mov    %rcx,-0x90(%rbp,%rax,8)
ff
mov    -0x20(%rbp),%rax
movslq -0x204(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
sub    $0x1,%rax
mov    %rax,-0x1c0(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x204(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
sub    $0x1,%rax
mov    %rax,-0x1c8(%rbp)
mov    -0x1c0(%rbp),%rax
mov    0x18(%rbp),%rcx
movslq -0x204(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
sub    $0x1,%rcx
sub    %rcx,%rax
mov    %rax,-0x220(%rbp)
movslq -0x204(%rbp),%rax
mov    -0x150(%rbp,%rax,8),%rdi
ff
call   1030 <labs@plt>
mov    %eax,%ecx
mov    -0x220(%rbp),%rax
movslq %ecx,%rcx
cqto
idiv   %rcx
cmp    $0x0,%rdx
je     1479 <imcomp_copy_overlap+0x359>
mov    -0x1c0(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x1c0(%rbp)
mov    -0x1c0(%rbp),%rax
cmp    -0x1c8(%rbp),%rax
jle    1474 <imcomp_copy_overlap+0x354>
mov    0x40(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x4(%rbp)
jmp    1fa7 <imcomp_copy_overlap+0xe87>
jmp    13ed <imcomp_copy_overlap+0x2cd>
jmp    147e <imcomp_copy_overlap+0x35e>
mov    -0x1c8(%rbp),%rax
mov    0x18(%rbp),%rcx
movslq -0x204(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
sub    $0x1,%rcx
sub    %rcx,%rax
mov    %rax,-0x228(%rbp)
movslq -0x204(%rbp),%rax
mov    -0x150(%rbp,%rax,8),%rdi
ff
call   1030 <labs@plt>
mov    %eax,%ecx
mov    -0x228(%rbp),%rax
movslq %ecx,%rcx
cqto
idiv   %rcx
cmp    $0x0,%rdx
je     150a <imcomp_copy_overlap+0x3ea>
mov    -0x1c8(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x1c8(%rbp)
mov    -0x1c0(%rbp),%rax
cmp    -0x1c8(%rbp),%rax
jle    1505 <imcomp_copy_overlap+0x3e5>
mov    0x40(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x4(%rbp)
jmp    1fa7 <imcomp_copy_overlap+0xe87>
jmp    147e <imcomp_copy_overlap+0x35e>
mov    -0x1c0(%rbp),%rax
mov    0x18(%rbp),%rcx
movslq -0x204(%rbp),%rdx
sub    (%rcx,%rdx,8),%rax
add    $0x1,%rax
mov    %rax,-0x230(%rbp)
movslq -0x204(%rbp),%rax
mov    -0x150(%rbp,%rax,8),%rdi
ff
call   1030 <labs@plt>
mov    %eax,%ecx
mov    -0x230(%rbp),%rax
movslq %ecx,%rcx
cqto
idiv   %rcx
cmp    $0x0,%rax
jle    15ac <imcomp_copy_overlap+0x48c>
mov    -0x1c0(%rbp),%rax
mov    0x18(%rbp),%rcx
movslq -0x204(%rbp),%rdx
sub    (%rcx,%rdx,8),%rax
add    $0x1,%rax
mov    %rax,-0x240(%rbp)
movslq -0x204(%rbp),%rax
mov    -0x150(%rbp,%rax,8),%rdi
ff
call   1030 <labs@plt>
mov    %eax,%ecx
mov    -0x240(%rbp),%rax
movslq %ecx,%rcx
cqto
idiv   %rcx
mov    %rax,-0x238(%rbp)
jmp    15ba <imcomp_copy_overlap+0x49a>
xor    %eax,%eax
mov    %rax,-0x238(%rbp)
jmp    15ba <imcomp_copy_overlap+0x49a>
mov    -0x238(%rbp),%rcx
movslq -0x204(%rbp),%rax
mov    %rcx,-0xc0(%rbp,%rax,8)
ff
mov    -0x1c8(%rbp),%rax
mov    0x18(%rbp),%rcx
movslq -0x204(%rbp),%rdx
sub    (%rcx,%rdx,8),%rax
add    $0x1,%rax
mov    %rax,-0x248(%rbp)
movslq -0x204(%rbp),%rax
mov    -0x150(%rbp,%rax,8),%rdi
ff
call   1030 <labs@plt>
mov    %eax,%ecx
mov    -0x248(%rbp),%rax
movslq %ecx,%rcx
cqto
idiv   %rcx
movslq -0x204(%rbp),%rcx
mov    -0x60(%rbp,%rcx,8),%rcx
sub    $0x1,%rcx
cmp    %rcx,%rax
jge    1681 <imcomp_copy_overlap+0x561>
mov    -0x1c8(%rbp),%rax
mov    0x18(%rbp),%rcx
movslq -0x204(%rbp),%rdx
sub    (%rcx,%rdx,8),%rax
add    $0x1,%rax
mov    %rax,-0x258(%rbp)
movslq -0x204(%rbp),%rax
mov    -0x150(%rbp,%rax,8),%rdi
ff
call   1030 <labs@plt>
mov    %eax,%ecx
mov    -0x258(%rbp),%rax
movslq %ecx,%rcx
cqto
idiv   %rcx
mov    %rax,-0x250(%rbp)
jmp    1698 <imcomp_copy_overlap+0x578>
movslq -0x204(%rbp),%rax
mov    -0x60(%rbp,%rax,8),%rax
sub    $0x1,%rax
mov    %rax,-0x250(%rbp)
mov    -0x250(%rbp),%rcx
movslq -0x204(%rbp),%rax
mov    %rcx,-0xf0(%rbp,%rax,8)
ff
mov    0x18(%rbp),%rax
movslq -0x204(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x20(%rbp),%rcx
movslq -0x204(%rbp),%rdx
sub    (%rcx,%rdx,8),%rax
cmp    $0x0,%rax
jle    1700 <imcomp_copy_overlap+0x5e0>
mov    0x18(%rbp),%rax
movslq -0x204(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x20(%rbp),%rcx
movslq -0x204(%rbp),%rdx
sub    (%rcx,%rdx,8),%rax
mov    %rax,-0x260(%rbp)
jmp    170e <imcomp_copy_overlap+0x5ee>
xor    %eax,%eax
mov    %rax,-0x260(%rbp)
jmp    170e <imcomp_copy_overlap+0x5ee>
mov    -0x260(%rbp),%rcx
movslq -0x204(%rbp),%rax
mov    %rcx,-0x120(%rbp,%rax,8)
ff
mov    -0x20(%rbp),%rax
movslq -0x204(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x204(%rbp),%rcx
add    -0x120(%rbp,%rcx,8),%rax
ff
mov    0x18(%rbp),%rcx
movslq -0x204(%rbp),%rdx
sub    (%rcx,%rdx,8),%rax
mov    %rax,-0x268(%rbp)
movslq -0x204(%rbp),%rax
mov    -0x150(%rbp,%rax,8),%rdi
ff
call   1030 <labs@plt>
mov    %eax,%ecx
mov    -0x268(%rbp),%rax
movslq %ecx,%rcx
cqto
idiv   %rcx
cmp    $0x0,%rdx
je     17d9 <imcomp_copy_overlap+0x6b9>
movslq -0x204(%rbp),%rax
mov    -0x120(%rbp,%rax,8),%rcx
ff
add    $0x1,%rcx
mov    %rcx,-0x120(%rbp,%rax,8)
ff
movslq -0x204(%rbp),%rax
mov    -0x120(%rbp,%rax,8),%rax
ff
movslq -0x204(%rbp),%rcx
cmp    -0x90(%rbp,%rcx,8),%rax
ff
jl     17d4 <imcomp_copy_overlap+0x6b4>
mov    0x40(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x4(%rbp)
jmp    1fa7 <imcomp_copy_overlap+0xe87>
jmp    1724 <imcomp_copy_overlap+0x604>
cmpl   $0x0,-0x204(%rbp)
jle    1808 <imcomp_copy_overlap+0x6e8>
mov    -0x204(%rbp),%eax
sub    $0x1,%eax
cltq
mov    -0x60(%rbp,%rax,8),%rcx
movslq -0x204(%rbp),%rax
imul   -0x60(%rbp,%rax,8),%rcx
mov    %rcx,-0x60(%rbp,%rax,8)
jmp    180d <imcomp_copy_overlap+0x6ed>
mov    -0x204(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x204(%rbp)
jmp    121b <imcomp_copy_overlap+0xfb>
cmpq   $0x1,-0x150(%rbp)
01
je     183e <imcomp_copy_overlap+0x71e>
movl   $0x1,-0x20c(%rbp)
jmp    1856 <imcomp_copy_overlap+0x736>
mov    -0xf0(%rbp),%rax
sub    -0xc0(%rbp),%rax
add    $0x1,%rax
mov    %eax,-0x20c(%rbp)
mov    -0x20c(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    %eax,-0x208(%rbp)
movq   $0x0,-0x170(%rbp)
movq   $0x0,-0x190(%rbp)
mov    -0x170(%rbp),%rax
mov    -0xd0(%rbp),%rcx
sub    -0xa0(%rbp),%rcx
cmp    %rcx,%rax
jg     1f9e <imcomp_copy_overlap+0xe7e>
jmp    189f <imcomp_copy_overlap+0x77f>
xor    %eax,%eax
cmpl   $0x4,-0x18(%rbp)
mov    %al,-0x269(%rbp)
jle    1900 <imcomp_copy_overlap+0x7e0>
mov    -0x20(%rbp),%rax
mov    0x20(%rax),%rax
add    -0x100(%rbp),%rax
mov    0x18(%rbp),%rcx
sub    0x20(%rcx),%rax
add    -0x190(%rbp),%rax
mov    %rax,-0x278(%rbp)
mov    -0x130(%rbp),%rdi
call   1030 <labs@plt>
mov    %eax,%ecx
mov    -0x278(%rbp),%rax
movslq %ecx,%rcx
cqto
idiv   %rcx
cmp    $0x0,%rdx
setne  %al
mov    %al,-0x269(%rbp)
mov    -0x269(%rbp),%al
test   $0x1,%al
jne    1913 <imcomp_copy_overlap+0x7f3>
jmp    192a <imcomp_copy_overlap+0x80a>
mov    -0x190(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x190(%rbp)
jmp    189f <imcomp_copy_overlap+0x77f>
cmpq   $0x0,-0x130(%rbp)
jle    1957 <imcomp_copy_overlap+0x837>
mov    -0x170(%rbp),%rax
add    -0xa0(%rbp),%rax
imul   -0x48(%rbp),%rax
mov    %rax,-0x1b0(%rbp)
jmp    197c <imcomp_copy_overlap+0x85c>
mov    -0x40(%rbp),%rax
mov    -0x170(%rbp),%rcx
add    $0x1,%rcx
add    -0xa0(%rbp),%rcx
imul   -0x48(%rbp),%rcx
sub    %rcx,%rax
mov    %rax,-0x1b0(%rbp)
mov    -0x100(%rbp),%rax
add    -0x190(%rbp),%rax
imul   -0x78(%rbp),%rax
mov    %rax,-0x1e0(%rbp)
movq   $0x0,-0x168(%rbp)
movq   $0x0,-0x188(%rbp)
mov    -0x168(%rbp),%rax
mov    -0xd8(%rbp),%rcx
sub    -0xa8(%rbp),%rcx
cmp    %rcx,%rax
jg     1f70 <imcomp_copy_overlap+0xe50>
jmp    19cf <imcomp_copy_overlap+0x8af>
xor    %eax,%eax
cmpl   $0x3,-0x18(%rbp)
mov    %al,-0x279(%rbp)
jle    1a30 <imcomp_copy_overlap+0x910>
mov    -0x20(%rbp),%rax
mov    0x18(%rax),%rax
add    -0x108(%rbp),%rax
mov    0x18(%rbp),%rcx
sub    0x18(%rcx),%rax
add    -0x188(%rbp),%rax
mov    %rax,-0x288(%rbp)
mov    -0x138(%rbp),%rdi
call   1030 <labs@plt>
mov    %eax,%ecx
mov    -0x288(%rbp),%rax
movslq %ecx,%rcx
cqto
idiv   %rcx
cmp    $0x0,%rdx
setne  %al
mov    %al,-0x279(%rbp)
mov    -0x279(%rbp),%al
test   $0x1,%al
jne    1a43 <imcomp_copy_overlap+0x923>
jmp    1a5a <imcomp_copy_overlap+0x93a>
mov    -0x188(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x188(%rbp)
jmp    19cf <imcomp_copy_overlap+0x8af>
cmpq   $0x0,-0x138(%rbp)
jle    1a8e <imcomp_copy_overlap+0x96e>
mov    -0x168(%rbp),%rax
add    -0xa8(%rbp),%rax
imul   -0x50(%rbp),%rax
add    -0x1b0(%rbp),%rax
mov    %rax,-0x1a8(%rbp)
jmp    1aba <imcomp_copy_overlap+0x99a>
mov    -0x48(%rbp),%rax
mov    -0x168(%rbp),%rcx
add    $0x1,%rcx
add    -0xa8(%rbp),%rcx
imul   -0x50(%rbp),%rcx
sub    %rcx,%rax
add    -0x1b0(%rbp),%rax
mov    %rax,-0x1a8(%rbp)
mov    -0x108(%rbp),%rax
add    -0x188(%rbp),%rax
imul   -0x80(%rbp),%rax
add    -0x1e0(%rbp),%rax
mov    %rax,-0x1d8(%rbp)
movq   $0x0,-0x160(%rbp)
movq   $0x0,-0x180(%rbp)
mov    -0x160(%rbp),%rax
mov    -0xe0(%rbp),%rcx
sub    -0xb0(%rbp),%rcx
cmp    %rcx,%rax
jg     1f42 <imcomp_copy_overlap+0xe22>
jmp    1b14 <imcomp_copy_overlap+0x9f4>
xor    %eax,%eax
cmpl   $0x2,-0x18(%rbp)
mov    %al,-0x289(%rbp)
jle    1b75 <imcomp_copy_overlap+0xa55>
mov    -0x20(%rbp),%rax
mov    0x10(%rax),%rax
add    -0x110(%rbp),%rax
mov    0x18(%rbp),%rcx
sub    0x10(%rcx),%rax
add    -0x180(%rbp),%rax
mov    %rax,-0x298(%rbp)
mov    -0x140(%rbp),%rdi
call   1030 <labs@plt>
mov    %eax,%ecx
mov    -0x298(%rbp),%rax
movslq %ecx,%rcx
cqto
idiv   %rcx
cmp    $0x0,%rdx
setne  %al
mov    %al,-0x289(%rbp)
mov    -0x289(%rbp),%al
test   $0x1,%al
jne    1b88 <imcomp_copy_overlap+0xa68>
jmp    1b9f <imcomp_copy_overlap+0xa7f>
mov    -0x180(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x180(%rbp)
jmp    1b14 <imcomp_copy_overlap+0x9f4>
cmpq   $0x0,-0x140(%rbp)
jle    1bd3 <imcomp_copy_overlap+0xab3>
mov    -0x160(%rbp),%rax
add    -0xb0(%rbp),%rax
imul   -0x58(%rbp),%rax
add    -0x1a8(%rbp),%rax
mov    %rax,-0x1a0(%rbp)
jmp    1bff <imcomp_copy_overlap+0xadf>
mov    -0x50(%rbp),%rax
mov    -0x160(%rbp),%rcx
add    $0x1,%rcx
add    -0xb0(%rbp),%rcx
imul   -0x58(%rbp),%rcx
sub    %rcx,%rax
add    -0x1a8(%rbp),%rax
mov    %rax,-0x1a0(%rbp)
mov    -0x110(%rbp),%rax
add    -0x180(%rbp),%rax
imul   -0x88(%rbp),%rax
ff
add    -0x1d8(%rbp),%rax
mov    %rax,-0x1d0(%rbp)
movq   $0x0,-0x158(%rbp)
movq   $0x0,-0x178(%rbp)
mov    -0x158(%rbp),%rax
mov    -0xe8(%rbp),%rcx
sub    -0xb8(%rbp),%rcx
cmp    %rcx,%rax
jg     1f14 <imcomp_copy_overlap+0xdf4>
jmp    1c5c <imcomp_copy_overlap+0xb3c>
xor    %eax,%eax
cmpl   $0x1,-0x18(%rbp)
mov    %al,-0x299(%rbp)
jle    1cbd <imcomp_copy_overlap+0xb9d>
mov    -0x20(%rbp),%rax
mov    0x8(%rax),%rax
add    -0x118(%rbp),%rax
mov    0x18(%rbp),%rcx
sub    0x8(%rcx),%rax
add    -0x178(%rbp),%rax
mov    %rax,-0x2a8(%rbp)
mov    -0x148(%rbp),%rdi
call   1030 <labs@plt>
mov    %eax,%ecx
mov    -0x2a8(%rbp),%rax
movslq %ecx,%rcx
cqto
idiv   %rcx
cmp    $0x0,%rdx
setne  %al
mov    %al,-0x299(%rbp)
mov    -0x299(%rbp),%al
test   $0x1,%al
jne    1cd0 <imcomp_copy_overlap+0xbb0>
jmp    1ce7 <imcomp_copy_overlap+0xbc7>
mov    -0x178(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x178(%rbp)
jmp    1c5c <imcomp_copy_overlap+0xb3c>
mov    -0x120(%rbp),%rax
mov    -0x118(%rbp),%rcx
add    -0x178(%rbp),%rcx
imul   -0x90(%rbp),%rcx
ff
add    %rcx,%rax
add    -0x1d0(%rbp),%rax
mov    %rax,-0x1e8(%rbp)
cmpq   $0x0,-0x148(%rbp)
jle    1d49 <imcomp_copy_overlap+0xc29>
mov    -0x158(%rbp),%rax
add    -0xb8(%rbp),%rax
imul   -0x60(%rbp),%rax
add    -0x1a0(%rbp),%rax
mov    %rax,-0x198(%rbp)
jmp    1d75 <imcomp_copy_overlap+0xc55>
mov    -0x58(%rbp),%rax
mov    -0x158(%rbp),%rcx
add    $0x1,%rcx
add    -0xb8(%rbp),%rcx
imul   -0x60(%rbp),%rcx
sub    %rcx,%rax
add    -0x1a0(%rbp),%rax
mov    %rax,-0x198(%rbp)
cmpq   $0x0,-0x150(%rbp)
jle    1d9d <imcomp_copy_overlap+0xc7d>
mov    -0xc0(%rbp),%rax
add    -0x198(%rbp),%rax
mov    %rax,-0x1f0(%rbp)
jmp    1dba <imcomp_copy_overlap+0xc9a>
mov    -0x60(%rbp),%rax
sub    $0x1,%rax
sub    -0xc0(%rbp),%rax
add    -0x198(%rbp),%rax
mov    %rax,-0x1f0(%rbp)
mov    -0xc0(%rbp),%rax
mov    %rax,-0x1b8(%rbp)
mov    -0x1b8(%rbp),%rax
cmp    -0xf0(%rbp),%rax
jg     1ee6 <imcomp_copy_overlap+0xdc6>
cmpl   $0x2,0x30(%rbp)
jne    1e07 <imcomp_copy_overlap+0xce7>
mov    0x38(%rbp),%rdi
add    -0x1f0(%rbp),%rdi
mov    -0x30(%rbp),%rsi
add    -0x1e8(%rbp),%rsi
mov    -0x20c(%rbp),%edx
call   1040 <memcpy@plt>
mov    -0x1e8(%rbp),%rax
movslq -0x14(%rbp),%rcx
imul   %rcx,%rax
mov    %rax,-0x1f8(%rbp)
mov    -0x1f0(%rbp),%rax
movslq -0x14(%rbp),%rcx
imul   %rcx,%rax
mov    %rax,-0x200(%rbp)
mov    0x10(%rbp),%rdi
add    -0x200(%rbp),%rdi
mov    -0x10(%rbp),%rsi
add    -0x1f8(%rbp),%rsi
mov    -0x208(%rbp),%edx
call   1040 <memcpy@plt>
mov    -0x20c(%rbp),%eax
mov    %eax,-0x2ac(%rbp)
mov    -0x150(%rbp),%rdi
call   1030 <labs@plt>
mov    %eax,%ecx
mov    -0x2ac(%rbp),%eax
imul   %ecx,%eax
cltq
add    -0x1e8(%rbp),%rax
mov    %rax,-0x1e8(%rbp)
cmpq   $0x0,-0x150(%rbp)
jle    1eaf <imcomp_copy_overlap+0xd8f>
movslq -0x20c(%rbp),%rax
add    -0x1f0(%rbp),%rax
mov    %rax,-0x1f0(%rbp)
jmp    1ec7 <imcomp_copy_overlap+0xda7>
movslq -0x20c(%rbp),%rcx
mov    -0x1f0(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x1f0(%rbp)
jmp    1ecc <imcomp_copy_overlap+0xdac>
movslq -0x20c(%rbp),%rax
add    -0x1b8(%rbp),%rax
mov    %rax,-0x1b8(%rbp)
jmp    1dc8 <imcomp_copy_overlap+0xca8>
jmp    1eeb <imcomp_copy_overlap+0xdcb>
mov    -0x158(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x158(%rbp)
mov    -0x178(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x178(%rbp)
jmp    1c39 <imcomp_copy_overlap+0xb19>
jmp    1f19 <imcomp_copy_overlap+0xdf9>
mov    -0x160(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x160(%rbp)
mov    -0x180(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x180(%rbp)
jmp    1af1 <imcomp_copy_overlap+0x9d1>
jmp    1f47 <imcomp_copy_overlap+0xe27>
mov    -0x168(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x168(%rbp)
mov    -0x188(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x188(%rbp)
jmp    19ac <imcomp_copy_overlap+0x88c>
jmp    1f75 <imcomp_copy_overlap+0xe55>
mov    -0x170(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x170(%rbp)
mov    -0x190(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x190(%rbp)
jmp    187c <imcomp_copy_overlap+0x75c>
mov    0x40(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x2b0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<imcomp_copy_overlap>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x308,%rsp
mov    %r8,%r15
mov    0x370(%rsp),%r8
mov    (%r8),%eax
test   %eax,%eax
jg     1f3f <imcomp_copy_overlap+0xe1f>
mov    %rcx,%r13
mov    0x348(%rsp),%r14
xorps  %xmm0,%xmm0
movaps %xmm0,0x2f0(%rsp)
movaps %xmm0,0x2e0(%rsp)
movaps %xmm0,0x2d0(%rsp)
movaps %xmm0,0x2a0(%rsp)
movaps %xmm0,0x2b0(%rsp)
movaps %xmm0,0x2c0(%rsp)
movaps %xmm0,0x210(%rsp)
movaps %xmm0,0x220(%rsp)
movaps %xmm0,0x230(%rsp)
movaps 0xe5c(%rip),%xmm0
movaps %xmm0,0x270(%rsp)
movaps %xmm0,0x1e0(%rsp)
movaps %xmm0,0x240(%rsp)
movaps %xmm0,0x280(%rsp)
movaps %xmm0,0x1f0(%rsp)
movaps %xmm0,0x250(%rsp)
movaps %xmm0,0x290(%rsp)
movaps %xmm0,0x200(%rsp)
movaps %xmm0,0x260(%rsp)
test   %edx,%edx
mov    %r9,0x1c0(%rsp)
mov    %rcx,0x68(%rsp)
mov    %edx,0xc(%rsp)
mov    %rdi,0x1d8(%rsp)
jle    168e <imcomp_copy_overlap+0x56e>
mov    %edx,%eax
mov    0x358(%rsp),%rdx
mov    0x350(%rsp),%rbp
mov    %eax,%eax
mov    %rax,0xb0(%rsp)
xor    %ecx,%ecx
mov    %esi,0x70(%rsp)
mov    0x348(%rsp),%rax
mov    (%rax,%rcx,8),%rax
cmp    %rax,(%r15,%rcx,8)
jl     1f51 <imcomp_copy_overlap+0xe31>
mov    0x0(%rbp,%rcx,8),%rbx
cmp    %rbx,0x0(%r13,%rcx,8)
jg     1f51 <imcomp_copy_overlap+0xe31>
mov    (%rdx,%rcx,8),%rdi
mov    %rcx,0x18(%rsp)
mov    %rdi,0x270(%rsp,%rcx,8)
sub    %rax,%rbx
mov    %rdi,0x10(%rsp)
call   1030 <labs@plt>
mov    %eax,%ecx
movslq %eax,%rsi
mov    %rbx,%rax
or     %rsi,%rax
shr    $0x20,%rax
je     128e <imcomp_copy_overlap+0x16e>
mov    %rbx,%rax
cqto
idiv   %rsi
jmp    1294 <imcomp_copy_overlap+0x174>
mov    %ebx,%eax
xor    %edx,%edx
div    %ecx
mov    0x370(%rsp),%rcx
lea    0x1(%rax),%rsi
mov    0x18(%rsp),%rdx
mov    %rsi,0x1e0(%rsp,%rdx,8)
test   %rax,%rax
js     1f56 <imcomp_copy_overlap+0xe36>
mov    %rax,0x38(%rsp)
mov    %rsi,0x30(%rsp)
mov    (%r15,%rdx,8),%r12
mov    0x0(%r13,%rdx,8),%r14
mov    %r12,%rax
sub    %r14,%rax
lea    0x1(%rax),%rsi
mov    %rsi,0x20(%rsp)
mov    %rsi,0x240(%rsp,%rdx,8)
test   %rax,%rax
js     1f56 <imcomp_copy_overlap+0xe36>
mov    %rdx,%rbp
mov    %r15,%r13
test   %rdx,%rdx
je     1316 <imcomp_copy_overlap+0x1f6>
mov    $0xffffffff,%eax
add    %ebp,%eax
mov    0x20(%rsp),%rcx
imul   0x240(%rsp,%rax,8),%rcx
mov    %rcx,0x20(%rsp)
mov    %rcx,0x240(%rsp,%rbp,8)
lea    -0x1(%r12),%r15
nopl   0x0(%rax,%rax,1)
mov    %r14,%rbx
mov    0x348(%rsp),%rax
sub    (%rax,%rbp,8),%rbx
mov    0x10(%rsp),%rdi
call   1030 <labs@plt>
mov    %eax,%ecx
movslq %eax,%rsi
mov    %rbx,%rax
or     %rsi,%rax
shr    $0x20,%rax
je     1360 <imcomp_copy_overlap+0x240>
mov    %rbx,%rax
cqto
idiv   %rsi
test   %rdx,%rdx
jne    136b <imcomp_copy_overlap+0x24b>
jmp    1380 <imcomp_copy_overlap+0x260>
nopl   0x0(%rax)
mov    %ebx,%eax
xor    %edx,%edx
div    %ecx
test   %rdx,%rdx
je     1380 <imcomp_copy_overlap+0x260>
lea    0x1(%r14),%rax
add    $0xffffffffffffffff,%r14
cmp    %r15,%r14
mov    %rax,%r14
jl     1320 <imcomp_copy_overlap+0x200>
jmp    1f35 <imcomp_copy_overlap+0xe15>
lea    -0x1(%r14),%r15
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r12,%rbx
mov    0x348(%rsp),%rax
sub    (%rax,%rbp,8),%rbx
mov    0x10(%rsp),%rdi
call   1030 <labs@plt>
mov    %eax,%ecx
movslq %eax,%rsi
mov    %rbx,%rax
or     %rsi,%rax
shr    $0x20,%rax
je     13d0 <imcomp_copy_overlap+0x2b0>
mov    %rbx,%rax
cqto
idiv   %rsi
test   %rdx,%rdx
jne    13db <imcomp_copy_overlap+0x2bb>
jmp    13e9 <imcomp_copy_overlap+0x2c9>
nopl   0x0(%rax)
mov    %ebx,%eax
xor    %edx,%edx
div    %ecx
test   %rdx,%rdx
je     13e9 <imcomp_copy_overlap+0x2c9>
add    $0xffffffffffffffff,%r12
cmp    %r12,%r15
jl     1390 <imcomp_copy_overlap+0x270>
jmp    1f35 <imcomp_copy_overlap+0xe15>
mov    %r14,%rbx
mov    0x348(%rsp),%rax
sub    (%rax,%rbp,8),%rbx
mov    0x10(%rsp),%rdi
call   1030 <labs@plt>
mov    %eax,%ecx
movslq %eax,%rsi
mov    %rbx,%rax
or     %rsi,%rax
shr    $0x20,%rax
je     141d <imcomp_copy_overlap+0x2fd>
mov    %rbx,%rax
cqto
idiv   %rsi
jmp    1423 <imcomp_copy_overlap+0x303>
mov    %ebx,%eax
xor    %edx,%edx
div    %ecx
mov    %r13,%r15
test   %rax,%rax
jle    145c <imcomp_copy_overlap+0x33c>
mov    0x348(%rsp),%rax
sub    (%rax,%rbp,8),%r14
mov    0x10(%rsp),%rdi
call   1030 <labs@plt>
mov    %eax,%ecx
movslq %eax,%rsi
mov    %r14,%rax
or     %rsi,%rax
shr    $0x20,%rax
je     1460 <imcomp_copy_overlap+0x340>
mov    %r14,%rax
cqto
idiv   %rsi
jmp    1467 <imcomp_copy_overlap+0x347>
xor    %eax,%eax
jmp    1467 <imcomp_copy_overlap+0x347>
mov    %r14d,%eax
xor    %edx,%edx
div    %ecx
mov    0x68(%rsp),%r13
mov    0x18(%rsp),%rcx
mov    %rax,0x2d0(%rsp,%rcx,8)
mov    %r12,%rbx
mov    0x348(%rsp),%rax
sub    (%rax,%rcx,8),%rbx
mov    0x10(%rsp),%rdi
call   1030 <labs@plt>
mov    %eax,%ecx
movslq %eax,%rsi
mov    %rbx,%rax
or     %rsi,%rax
shr    $0x20,%rax
je     14ad <imcomp_copy_overlap+0x38d>
mov    %rbx,%rax
cqto
idiv   %rsi
jmp    14b3 <imcomp_copy_overlap+0x393>
mov    %ebx,%eax
xor    %edx,%edx
div    %ecx
mov    0x38(%rsp),%rdx
cmp    %rdx,%rax
jge    14ff <imcomp_copy_overlap+0x3df>
mov    0x348(%rsp),%rax
mov    0x18(%rsp),%rcx
sub    (%rax,%rcx,8),%r12
mov    0x10(%rsp),%rdi
call   1030 <labs@plt>
mov    %eax,%ecx
movslq %eax,%rsi
mov    %r12,%rax
or     %rsi,%rax
shr    $0x20,%rax
je     14f6 <imcomp_copy_overlap+0x3d6>
mov    %r12,%rax
cqto
idiv   %rsi
mov    %rax,%rdx
jmp    14ff <imcomp_copy_overlap+0x3df>
mov    %r12d,%eax
xor    %edx,%edx
div    %ecx
mov    %eax,%edx
mov    0x18(%rsp),%rcx
mov    %rdx,0x2a0(%rsp,%rcx,8)
mov    0x348(%rsp),%rax
mov    (%rax,%rcx,8),%rax
mov    0x0(%r13,%rcx,8),%rbx
mov    %rax,%r14
sub    %rbx,%r14
mov    $0x0,%ecx
cmovs  %rcx,%r14
add    %r14,%rbx
sub    %rax,%rbx
mov    0x10(%rsp),%rdi
call   1030 <labs@plt>
mov    %eax,%ecx
movslq %eax,%rsi
mov    %rbx,%rax
or     %rsi,%rax
shr    $0x20,%rax
je     1557 <imcomp_copy_overlap+0x437>
mov    %rbx,%rax
cqto
idiv   %rsi
jmp    155d <imcomp_copy_overlap+0x43d>
mov    %ebx,%eax
xor    %edx,%edx
div    %ecx
mov    0x20(%rsp),%rbp
test   %rdx,%rdx
je     15ca <imcomp_copy_overlap+0x4aa>
add    $0x1,%r14
jmp    1581 <imcomp_copy_overlap+0x461>
nopl   (%rax)
mov    %rbx,%rax
cqto
idiv   %rsi
add    $0x1,%r14
test   %rdx,%rdx
je     15c6 <imcomp_copy_overlap+0x4a6>
cmp    %rbp,%r14
jge    1f28 <imcomp_copy_overlap+0xe08>
mov    0x18(%rsp),%rcx
mov    0x0(%r13,%rcx,8),%rbx
mov    0x348(%rsp),%rax
sub    (%rax,%rcx,8),%rbx
add    %r14,%rbx
mov    0x10(%rsp),%rdi
call   1030 <labs@plt>
mov    %eax,%ecx
movslq %eax,%rsi
mov    %rbx,%rax
or     %rsi,%rax
shr    $0x20,%rax
jne    1570 <imcomp_copy_overlap+0x450>
mov    %ebx,%eax
xor    %edx,%edx
div    %ecx
jmp    1578 <imcomp_copy_overlap+0x458>
add    $0xffffffffffffffff,%r14
mov    0x370(%rsp),%r8
mov    0x70(%rsp),%esi
mov    0x18(%rsp),%rcx
mov    %r14,0x210(%rsp,%rcx,8)
test   %rcx,%rcx
je     1605 <imcomp_copy_overlap+0x4e5>
mov    $0xffffffff,%eax
add    %ecx,%eax
mov    0x30(%rsp),%rdx
imul   0x1e0(%rsp,%rax,8),%rdx
mov    %rdx,0x1e0(%rsp,%rcx,8)
add    $0x1,%rcx
cmp    0xb0(%rsp),%rcx
mov    0x358(%rsp),%rdx
mov    0x350(%rsp),%rbp
jne    122f <imcomp_copy_overlap+0x10f>
mov    0x270(%rsp),%rbp
mov    0x2a0(%rsp),%rax
mov    0x2c0(%rsp),%rcx
mov    %rcx,0x48(%rsp)
mov    0x2d0(%rsp),%rcx
mov    0x2f0(%rsp),%rdx
mov    %rdx,0x40(%rsp)
movl   $0x1,0x10(%rsp)
mov    %rbp,0x30(%rsp)
cmp    $0x1,%rbp
mov    %rcx,0x28(%rsp)
jne    1f63 <imcomp_copy_overlap+0xe43>
mov    %eax,%edx
sub    %ecx,%edx
add    $0x1,%edx
mov    %edx,0x10(%rsp)
mov    0xc(%rsp),%edx
mov    0x348(%rsp),%r14
jmp    16ad <imcomp_copy_overlap+0x58d>
movl   $0x1,0x10(%rsp)
xor    %eax,%eax
xor    %ecx,%ecx
mov    %rcx,0x28(%rsp)
xor    %ecx,%ecx
mov    %rcx,0x48(%rsp)
xor    %ecx,%ecx
mov    %rcx,0x40(%rsp)
mov    %rax,0x18(%rsp)
mov    $0x1,%eax
mov    %rax,0x30(%rsp)
mov    0x40(%rsp),%rax
sub    %rax,0x48(%rsp)
jl     1f35 <imcomp_copy_overlap+0xe15>
mov    0x10(%rsp),%r10d
mov    %r10d,%eax
imul   %esi,%eax
mov    %eax,0xb0(%rsp)
mov    0x2b8(%rsp),%r8
mov    0x2e8(%rsp),%r9
mov    0x2a8(%rsp),%r12
mov    0x2b0(%rsp),%r11
mov    0x2d8(%rsp),%rdi
mov    0x2e0(%rsp),%r15
mov    %edx,%ebp
mov    0x1e0(%rsp),%rdx
mov    0x28(%rsp),%rax
mov    %rax,%rcx
not    %rcx
mov    %rdx,0xf8(%rsp)
add    %rdx,%rcx
movslq %r10d,%rbx
mov    %rbx,%rdx
neg    %rdx
cmpq   $0x0,0x30(%rsp)
cmovg  %rax,%rcx
mov    %rbx,0x1d0(%rsp)
cmovg  %rbx,%rdx
movslq %esi,%rsi
mov    %r12,0x180(%rsp)
mov    %rdi,%rax
mov    %rdi,0xa8(%rsp)
sub    %rdi,%r12
add    $0x1,%r12
mov    %r12,0x1b8(%rsp)
mov    %r11,0x140(%rsp)
mov    %r15,%rax
mov    %r15,0x98(%rsp)
sub    %r15,%r11
add    $0x1,%r11
mov    %r11,0x178(%rsp)
mov    %r8,0x118(%rsp)
mov    %r9,%rax
mov    %r9,0x88(%rsp)
sub    %r9,%r8
add    $0x1,%r8
mov    %r8,0x138(%rsp)
addq   $0x1,0x48(%rsp)
mov    0x368(%rsp),%rax
mov    %rcx,0x190(%rsp)
add    %rcx,%rax
mov    %rax,0x110(%rsp)
mov    %rdx,0x70(%rsp)
mov    %rsi,0x20(%rsp)
imul   %rsi,%rdx
mov    %rdx,0x1c8(%rsp)
mov    %ebp,%edx
mov    0x230(%rsp),%rax
mov    %rax,0xc0(%rsp)
mov    0x290(%rsp),%rax
mov    %rax,0xc8(%rsp)
mov    0x200(%rsp),%rax
mov    %rax,0x100(%rsp)
mov    0x1f8(%rsp),%rax
mov    %rax,0x78(%rsp)
mov    0x258(%rsp),%rax
mov    %rax,0x108(%rsp)
mov    0x228(%rsp),%rax
mov    %rax,0xd8(%rsp)
mov    0x288(%rsp),%rax
mov    %rax,0xe0(%rsp)
mov    0x1f0(%rsp),%rax
mov    %rax,0x90(%rsp)
mov    0x250(%rsp),%rax
mov    %rax,0x120(%rsp)
mov    0x220(%rsp),%r15
mov    0x278(%rsp),%rax
mov    %rax,0x1b0(%rsp)
mov    0x280(%rsp),%rbp
mov    0x1e8(%rsp),%rax
mov    %rax,0xa0(%rsp)
mov    0x240(%rsp),%rax
mov    %rax,0x188(%rsp)
mov    0x248(%rsp),%rax
mov    %rax,0x150(%rsp)
mov    0x210(%rsp),%rax
mov    %rax,0x148(%rsp)
mov    0x218(%rsp),%rax
mov    %rax,0x38(%rsp)
xor    %eax,%eax
mov    %rax,0x50(%rsp)
xor    %esi,%esi
mov    %r15,0xe8(%rsp)
mov    %rbp,0x170(%rsp)
jmp    1938 <imcomp_copy_overlap+0x818>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x50(%rsp),%rcx
add    $0x1,%rcx
mov    0xb8(%rsp),%rsi
add    $0x1,%rsi
mov    %rcx,%rax
mov    %rcx,0x50(%rsp)
cmp    0x48(%rsp),%rcx
je     1f35 <imcomp_copy_overlap+0xe15>
cmp    $0x5,%edx
jge    1954 <imcomp_copy_overlap+0x834>
jmp    19a4 <imcomp_copy_overlap+0x884>
nop
mov    %rbx,%rax
cqto
idiv   %rsi
mov    %r12,%rsi
add    $0x1,%rsi
test   %rdx,%rdx
je     19a0 <imcomp_copy_overlap+0x880>
mov    0x20(%r13),%rbx
sub    0x20(%r14),%rbx
mov    0xc0(%rsp),%rax
mov    %rsi,%r12
add    %rsi,%rax
add    %rax,%rbx
mov    0xc8(%rsp),%rdi
call   1030 <labs@plt>
mov    %eax,%ecx
movslq %eax,%rsi
mov    %rbx,%rax
or     %rsi,%rax
shr    $0x20,%rax
jne    1940 <imcomp_copy_overlap+0x820>
mov    %ebx,%eax
xor    %edx,%edx
div    %ecx
jmp    1948 <imcomp_copy_overlap+0x828>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0xffffffffffffffff,%rsi
cmpq   $0x0,0xc8(%rsp)
mov    %rsi,0xb8(%rsp)
jle    19e0 <imcomp_copy_overlap+0x8c0>
mov    0x40(%rsp),%rax
mov    0x50(%rsp),%rcx
add    %rcx,%rax
imul   0x78(%rsp),%rax
mov    %rax,0x80(%rsp)
jmp    1a0a <imcomp_copy_overlap+0x8ea>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x40(%rsp),%rax
mov    0x50(%rsp),%rcx
add    %rcx,%rax
add    $0x1,%rax
imul   0x78(%rsp),%rax
mov    0x100(%rsp),%rcx
sub    %rax,%rcx
mov    %rcx,0x80(%rsp)
mov    0xc(%rsp),%edx
mov    0x88(%rsp),%rax
cmp    %rax,0x118(%rsp)
jl     1910 <imcomp_copy_overlap+0x7f0>
mov    0xc0(%rsp),%rax
mov    0xb8(%rsp),%rcx
add    %rcx,%rax
imul   0x108(%rsp),%rax
mov    %rax,0x130(%rsp)
mov    0x110(%rsp),%rax
mov    0x80(%rsp),%rcx
add    %rcx,%rax
mov    %rax,0x128(%rsp)
xor    %eax,%eax
mov    %rax,0x58(%rsp)
xor    %esi,%esi
jmp    1a9b <imcomp_copy_overlap+0x97b>
xchg   %ax,%ax
mov    0x58(%rsp),%rcx
add    $0x1,%rcx
mov    0xd0(%rsp),%rsi
add    $0x1,%rsi
mov    %rcx,%rax
mov    %rcx,0x58(%rsp)
cmp    0x138(%rsp),%rcx
je     1910 <imcomp_copy_overlap+0x7f0>
cmp    $0x4,%edx
jge    1ac4 <imcomp_copy_overlap+0x9a4>
jmp    1b14 <imcomp_copy_overlap+0x9f4>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rbx,%rax
cqto
idiv   %rsi
mov    %r12,%rsi
add    $0x1,%rsi
test   %rdx,%rdx
je     1b10 <imcomp_copy_overlap+0x9f0>
mov    0x18(%r13),%rbx
sub    0x18(%r14),%rbx
mov    0xd8(%rsp),%rax
mov    %rsi,%r12
add    %rsi,%rax
add    %rax,%rbx
mov    0xe0(%rsp),%rdi
call   1030 <labs@plt>
mov    %eax,%ecx
movslq %eax,%rsi
mov    %rbx,%rax
or     %rsi,%rax
shr    $0x20,%rax
jne    1ab0 <imcomp_copy_overlap+0x990>
mov    %ebx,%eax
xor    %edx,%edx
div    %ecx
jmp    1ab8 <imcomp_copy_overlap+0x998>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0xffffffffffffffff,%rsi
cmpq   $0x0,0xe0(%rsp)
mov    %rsi,0xd0(%rsp)
jle    1b50 <imcomp_copy_overlap+0xa30>
mov    0x88(%rsp),%rax
mov    0x58(%rsp),%rcx
lea    (%rax,%rcx,1),%rsi
imul   0x90(%rsp),%rsi
jmp    1b75 <imcomp_copy_overlap+0xa55>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x88(%rsp),%rax
mov    0x58(%rsp),%rcx
add    %rcx,%rax
add    $0x1,%rax
imul   0x90(%rsp),%rax
mov    0x78(%rsp),%rsi
sub    %rax,%rsi
mov    0x98(%rsp),%rax
cmp    %rax,0x140(%rsp)
mov    0xc(%rsp),%edx
jl     1a70 <imcomp_copy_overlap+0x950>
mov    0xd8(%rsp),%rax
mov    0xd0(%rsp),%rcx
add    %rcx,%rax
imul   0x120(%rsp),%rax
add    0x130(%rsp),%rax
mov    %rax,0x160(%rsp)
mov    0x128(%rsp),%rax
add    %rsi,%rax
mov    %rax,0x158(%rsp)
add    0x80(%rsp),%rsi
mov    %rsi,0x168(%rsp)
xor    %eax,%eax
mov    %rax,0x60(%rsp)
xor    %esi,%esi
jmp    1c2b <imcomp_copy_overlap+0xb0b>
nopl   0x0(%rax)
mov    0x60(%rsp),%rcx
add    $0x1,%rcx
mov    0xf0(%rsp),%rsi
add    $0x1,%rsi
mov    %rcx,%rax
mov    %rcx,0x60(%rsp)
cmp    0x178(%rsp),%rcx
mov    0xe8(%rsp),%r15
mov    0x170(%rsp),%rbp
je     1a70 <imcomp_copy_overlap+0x950>
cmp    $0x3,%edx
jge    1c54 <imcomp_copy_overlap+0xb34>
jmp    1c94 <imcomp_copy_overlap+0xb74>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rbx,%rax
cqto
idiv   %rsi
mov    %r12,%rsi
add    $0x1,%rsi
test   %rdx,%rdx
je     1c90 <imcomp_copy_overlap+0xb70>
mov    0x10(%r13),%rbx
sub    0x10(%r14),%rbx
mov    %rsi,%r12
add    %r15,%rbx
add    %rsi,%rbx
mov    %rbp,%rdi
call   1030 <labs@plt>
mov    %eax,%ecx
movslq %eax,%rsi
mov    %rbx,%rax
or     %rsi,%rax
shr    $0x20,%rax
jne    1c40 <imcomp_copy_overlap+0xb20>
mov    %ebx,%eax
xor    %edx,%edx
div    %ecx
jmp    1c48 <imcomp_copy_overlap+0xb28>
cs nopw 0x0(%rax,%rax,1)
add    $0xffffffffffffffff,%rsi
test   %rbp,%rbp
mov    %rsi,0xf0(%rsp)
jle    1cc0 <imcomp_copy_overlap+0xba0>
mov    0x98(%rsp),%rax
mov    0x60(%rsp),%rcx
add    %rax,%rcx
imul   0xa0(%rsp),%rcx
jmp    1ce8 <imcomp_copy_overlap+0xbc8>
nopl   0x0(%rax)
mov    0x98(%rsp),%rax
mov    0x60(%rsp),%rcx
add    %rcx,%rax
add    $0x1,%rax
imul   0xa0(%rsp),%rax
mov    0x90(%rsp),%rcx
sub    %rax,%rcx
mov    0xc(%rsp),%edx
mov    0xa8(%rsp),%rax
cmp    %rax,0x180(%rsp)
jl     1bf0 <imcomp_copy_overlap+0xad0>
mov    0x168(%rsp),%rax
mov    %rcx,%rsi
add    %rcx,%rax
mov    %rax,0x1a0(%rsp)
mov    0xe8(%rsp),%rax
mov    0xf0(%rsp),%rcx
add    %rcx,%rax
imul   0x150(%rsp),%rax
add    0x160(%rsp),%rax
add    0x148(%rsp),%rax
mov    %rax,0x198(%rsp)
add    0x158(%rsp),%rsi
mov    %rsi,0x1a8(%rsp)
xor    %r12d,%r12d
xor    %r15d,%r15d
jmp    1d97 <imcomp_copy_overlap+0xc77>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r12
add    $0x1,%r15
cmp    0x1b8(%rsp),%r12
mov    0x68(%rsp),%r13
mov    0xc(%rsp),%edx
mov    0x348(%rsp),%r14
je     1bf0 <imcomp_copy_overlap+0xad0>
cmp    $0x2,%edx
mov    0x1b0(%rsp),%rbp
jge    1de1 <imcomp_copy_overlap+0xcc1>
test   %rbp,%rbp
jle    1e29 <imcomp_copy_overlap+0xd09>
mov    0xa8(%rsp),%rax
lea    (%rax,%r12,1),%r13
imul   0xf8(%rsp),%r13
jmp    1e4c <imcomp_copy_overlap+0xd2c>
nopw   0x0(%rax,%rax,1)
mov    %rbx,%rax
cqto
idiv   %rsi
add    $0x1,%r15
test   %rdx,%rdx
je     1e20 <imcomp_copy_overlap+0xd00>
mov    0x8(%r13),%rbx
sub    0x8(%r14),%rbx
mov    0x38(%rsp),%rax
add    %r15,%rax
add    %rax,%rbx
mov    %rbp,%rdi
call   1030 <labs@plt>
mov    %eax,%ecx
movslq %eax,%rsi
mov    %rbx,%rax
or     %rsi,%rax
shr    $0x20,%rax
jne    1dd0 <imcomp_copy_overlap+0xcb0>
mov    %ebx,%eax
xor    %edx,%edx
div    %ecx
jmp    1dd8 <imcomp_copy_overlap+0xcb8>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0xffffffffffffffff,%r15
test   %rbp,%rbp
jg     1dad <imcomp_copy_overlap+0xc8d>
mov    0xa8(%rsp),%rax
add    %r12,%rax
add    $0x1,%rax
imul   0xf8(%rsp),%rax
mov    0xa0(%rsp),%r13
sub    %rax,%r13
mov    0x18(%rsp),%rax
mov    0x28(%rsp),%rcx
cmp    %rcx,%rax
jl     1d70 <imcomp_copy_overlap+0xc50>
mov    0x38(%rsp),%rax
lea    (%rax,%r15,1),%r14
imul   0x188(%rsp),%r14
add    0x198(%rsp),%r14
mov    0x1a0(%rsp),%rax
lea    (%rax,%r13,1),%rbx
add    0x190(%rsp),%rbx
add    0x1a8(%rsp),%r13
imul   0x20(%rsp),%rbx
add    0x340(%rsp),%rbx
mov    0x28(%rsp),%rbp
jmp    1f04 <imcomp_copy_overlap+0xde4>
nopw   0x0(%rax,%rax,1)
mov    %r14,%rsi
imul   0x20(%rsp),%rsi
add    0x1d8(%rsp),%rsi
mov    %rbx,%rdi
mov    0xb0(%rsp),%edx
call   1040 <memcpy@plt>
mov    0x30(%rsp),%rdi
call   1030 <labs@plt>
imul   0x10(%rsp),%eax
cltq
add    %rax,%r14
add    0x1d0(%rsp),%rbp
add    0x70(%rsp),%r13
add    0x1c8(%rsp),%rbx
cmp    0x18(%rsp),%rbp
jg     1d70 <imcomp_copy_overlap+0xc50>
cmpl   $0x2,0x360(%rsp)
02
jne    1eb0 <imcomp_copy_overlap+0xd90>
mov    0x1c0(%rsp),%rax
lea    (%rax,%r14,1),%rsi
mov    %r13,%rdi
mov    0x10(%rsp),%edx
call   1040 <memcpy@plt>
jmp    1eb0 <imcomp_copy_overlap+0xd90>
mov    0x18(%rsp),%rax
mov    %r14,0x210(%rsp,%rax,8)
mov    0x370(%rsp),%rax
mov    (%rax),%eax
add    $0x308,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    (%r8),%eax
jmp    1f3f <imcomp_copy_overlap+0xe1f>
movl   $0x143,(%rcx)
mov    $0x143,%eax
jmp    1f3f <imcomp_copy_overlap+0xe1f>
mov    %rax,0x18(%rsp)
mov    0xc(%rsp),%edx
mov    0x348(%rsp),%r14
jmp    16bc <imcomp_copy_overlap+0x59c>

LLVM IR (-O0):
define i32 @imcomp_copy_overlap(i8* %0, i32 %1, i32 %2, i64* %3, i64* %4, i8* %5, i8* %6, i64* %7, i64* %8, i64* %9, i32 %10, i8* %11, i32* %12) {
%14 = alloca i32
%15 = alloca i8*
%16 = alloca i32
%17 = alloca i32
%18 = alloca i64*
%19 = alloca i64*
%20 = alloca i8*
%21 = alloca i8*
%22 = alloca i64*
%23 = alloca i64*
%24 = alloca i64*
%25 = alloca i32
%26 = alloca i8*
%27 = alloca i32*
%28 = alloca [6 x i64]
%29 = alloca [6 x i64]
%30 = alloca [6 x i64]
%31 = alloca [6 x i64]
%32 = alloca [6 x i64]
%33 = alloca [6 x i64]
%34 = alloca i64
%35 = alloca i64
%36 = alloca i64
%37 = alloca i64
%38 = alloca i64
%39 = alloca i64
%40 = alloca i64
%41 = alloca i64
%42 = alloca i64
%43 = alloca i64
%44 = alloca i64
%45 = alloca i64
%46 = alloca i64
%47 = alloca i64
%48 = alloca i64
%49 = alloca i64
%50 = alloca i64
%51 = alloca i64
%52 = alloca i64
%53 = alloca i64
%54 = alloca i64
%55 = alloca i64
%56 = alloca i32
%57 = alloca i32
%58 = alloca i32
store i8* %0, i8** %15
store i32 %1, i32* %16
store i32 %2, i32* %17
store i64* %3, i64** %18
store i64* %4, i64** %19
store i8* %5, i8** %20
store i8* %6, i8** %21
store i64* %7, i64** %22
store i64* %8, i64** %23
store i64* %9, i64** %24
store i32 %10, i32* %25
store i8* %11, i8** %26
store i32* %12, i32** %27
%59 = load i32*, i32** %27
%60 = load i32, i32* %59
%61 = icmp sgt i32 %60, 0
br i1 %61, label %62, label %65
62: ; preds = %13
%63 = load i32*, i32** %27
%64 = load i32, i32* %63
store i32 %64, i32* %14
br label %863
65: ; preds = %13
store i32 0, i32* %56
br label %66
66: ; preds = %88, %65
%67 = load i32, i32* %56
%68 = icmp slt i32 %67, 6
br i1 %68, label %69, label %91
69: ; preds = %66
%70 = load i32, i32* %56
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds [6 x i64], [6 x i64]* %33, i64 0, i64 %71
store i64 1, i64* %72
%73 = load i32, i32* %56
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds [6 x i64], [6 x i64]* %28, i64 0, i64 %74
store i64 1, i64* %75
%76 = load i32, i32* %56
%77 = sext i32 %76 to i64
%78 = getelementptr inbounds [6 x i64], [6 x i64]* %29, i64 0, i64 %77
store i64 1, i64* %78
%79 = load i32, i32* %56
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds [6 x i64], [6 x i64]* %30, i64 0, i64 %80
store i64 0, i64* %81
%82 = load i32, i32* %56
%83 = sext i32 %82 to i64
%84 = getelementptr inbounds [6 x i64], [6 x i64]* %31, i64 0, i64 %83
store i64 0, i64* %84
%85 = load i32, i32* %56
%86 = sext i32 %85 to i64
%87 = getelementptr inbounds [6 x i64], [6 x i64]* %32, i64 0, i64 %86
store i64 0, i64* %87
br label %88
88: ; preds = %69
%89 = load i32, i32* %56
%90 = add nsw i32 %89, 1
store i32 %90, i32* %56
br label %66
91: ; preds = %66
store i32 0, i32* %56
br label %92
92: ; preds = %442, %91
%93 = load i32, i32* %56
%94 = load i32, i32* %17
%95 = icmp slt i32 %93, %94
br i1 %95, label %96, label %445
96: ; preds = %92
%97 = load i64*, i64** %19
%98 = load i32, i32* %56
%99 = sext i32 %98 to i64
%100 = getelementptr inbounds i64, i64* %97, i64 %99
%101 = load i64, i64* %100
%102 = load i64*, i64** %22
%103 = load i32, i32* %56
%104 = sext i32 %103 to i64
%105 = getelementptr inbounds i64, i64* %102, i64 %104
%106 = load i64, i64* %105
%107 = icmp slt i64 %101, %106
br i1 %107, label %120, label %108
108: ; preds = %96
%109 = load i64*, i64** %18
%110 = load i32, i32* %56
%111 = sext i32 %110 to i64
%112 = getelementptr inbounds i64, i64* %109, i64 %111
%113 = load i64, i64* %112
%114 = load i64*, i64** %23
%115 = load i32, i32* %56
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds i64, i64* %114, i64 %116
%118 = load i64, i64* %117
%119 = icmp sgt i64 %113, %118
br i1 %119, label %120, label %123
120: ; preds = %108, %96
%121 = load i32*, i32** %27
%122 = load i32, i32* %121
store i32 %122, i32* %14
br label %863
123: ; preds = %108
%124 = load i64*, i64** %24
%125 = load i32, i32* %56
%126 = sext i32 %125 to i64
%127 = getelementptr inbounds i64, i64* %124, i64 %126
%128 = load i64, i64* %127
%129 = load i32, i32* %56
%130 = sext i32 %129 to i64
%131 = getelementptr inbounds [6 x i64], [6 x i64]* %33, i64 0, i64 %130
store i64 %128, i64* %131
%132 = load i64*, i64** %23
%133 = load i32, i32* %56
%134 = sext i32 %133 to i64
%135 = getelementptr inbounds i64, i64* %132, i64 %134
%136 = load i64, i64* %135
%137 = load i64*, i64** %22
%138 = load i32, i32* %56
%139 = sext i32 %138 to i64
%140 = getelementptr inbounds i64, i64* %137, i64 %139
%141 = load i64, i64* %140
%142 = sub nsw i64 %136, %141
%143 = load i32, i32* %56
%144 = sext i32 %143 to i64
%145 = getelementptr inbounds [6 x i64], [6 x i64]* %33, i64 0, i64 %144
%146 = load i64, i64* %145
%147 = call i32 @labs(i64 %146)
%148 = sext i32 %147 to i64
%149 = sdiv i64 %142, %148
%150 = add nsw i64 %149, 1
%151 = load i32, i32* %56
%152 = sext i32 %151 to i64
%153 = getelementptr inbounds [6 x i64], [6 x i64]* %28, i64 0, i64 %152
store i64 %150, i64* %153
%154 = load i32, i32* %56
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds [6 x i64], [6 x i64]* %28, i64 0, i64 %155
%157 = load i64, i64* %156
%158 = icmp slt i64 %157, 1
br i1 %158, label %159, label %161
159: ; preds = %123
%160 = load i32*, i32** %27
store i32 323, i32* %160
store i32 323, i32* %14
br label %863
161: ; preds = %123
%162 = load i64*, i64** %19
%163 = load i32, i32* %56
%164 = sext i32 %163 to i64
%165 = getelementptr inbounds i64, i64* %162, i64 %164
%166 = load i64, i64* %165
%167 = load i64*, i64** %18
%168 = load i32, i32* %56
%169 = sext i32 %168 to i64
%170 = getelementptr inbounds i64, i64* %167, i64 %169
%171 = load i64, i64* %170
%172 = sub nsw i64 %166, %171
%173 = add nsw i64 %172, 1
%174 = load i32, i32* %56
%175 = sext i32 %174 to i64
%176 = getelementptr inbounds [6 x i64], [6 x i64]* %29, i64 0, i64 %175
store i64 %173, i64* %176
%177 = load i32, i32* %56
%178 = sext i32 %177 to i64
%179 = getelementptr inbounds [6 x i64], [6 x i64]* %29, i64 0, i64 %178
%180 = load i64, i64* %179
%181 = icmp slt i64 %180, 1
br i1 %181, label %182, label %184
182: ; preds = %161
%183 = load i32*, i32** %27
store i32 323, i32* %183
store i32 323, i32* %14
br label %863
184: ; preds = %161
%185 = load i32, i32* %56
%186 = icmp sgt i32 %185, 0
br i1 %186, label %187, label %198
187: ; preds = %184
%188 = load i32, i32* %56
%189 = sub nsw i32 %188, 1
%190 = sext i32 %189 to i64
%191 = getelementptr inbounds [6 x i64], [6 x i64]* %29, i64 0, i64 %190
%192 = load i64, i64* %191
%193 = load i32, i32* %56
%194 = sext i32 %193 to i64
%195 = getelementptr inbounds [6 x i64], [6 x i64]* %29, i64 0, i64 %194
%196 = load i64, i64* %195
%197 = mul nsw i64 %196, %192
store i64 %197, i64* %195
br label %198
198: ; preds = %187, %184
%199 = load i64*, i64** %18
%200 = load i32, i32* %56
%201 = sext i32 %200 to i64
%202 = getelementptr inbounds i64, i64* %199, i64 %201
%203 = load i64, i64* %202
%204 = sub nsw i64 %203, 1
store i64 %204, i64* %47
%205 = load i64*, i64** %19
%206 = load i32, i32* %56
%207 = sext i32 %206 to i64
%208 = getelementptr inbounds i64, i64* %205, i64 %207
%209 = load i64, i64* %208
%210 = sub nsw i64 %209, 1
store i64 %210, i64* %48
br label %211
211: ; preds = %237, %198
%212 = load i64, i64* %47
%213 = load i64*, i64** %22
%214 = load i32, i32* %56
%215 = sext i32 %214 to i64
%216 = getelementptr inbounds i64, i64* %213, i64 %215
%217 = load i64, i64* %216
%218 = sub nsw i64 %217, 1
%219 = sub nsw i64 %212, %218
%220 = load i32, i32* %56
%221 = sext i32 %220 to i64
%222 = getelementptr inbounds [6 x i64], [6 x i64]* %33, i64 0, i64 %221
%223 = load i64, i64* %222
%224 = call i32 @labs(i64 %223)
%225 = sext i32 %224 to i64
%226 = srem i64 %219, %225
%227 = icmp ne i64 %226, 0
br i1 %227, label %228, label %238
228: ; preds = %211
%229 = load i64, i64* %47
%230 = add nsw i64 %229, 1
store i64 %230, i64* %47
%231 = load i64, i64* %47
%232 = load i64, i64* %48
%233 = icmp sgt i64 %231, %232
br i1 %233, label %234, label %237
234: ; preds = %228
%235 = load i32*, i32** %27
%236 = load i32, i32* %235
store i32 %236, i32* %14
br label %863
237: ; preds = %228
br label %211
238: ; preds = %211
br label %239
239: ; preds = %265, %238
%240 = load i64, i64* %48
%241 = load i64*, i64** %22
%242 = load i32, i32* %56
%243 = sext i32 %242 to i64
%244 = getelementptr inbounds i64, i64* %241, i64 %243
%245 = load i64, i64* %244
%246 = sub nsw i64 %245, 1
%247 = sub nsw i64 %240, %246
%248 = load i32, i32* %56
%249 = sext i32 %248 to i64
%250 = getelementptr inbounds [6 x i64], [6 x i64]* %33, i64 0, i64 %249
%251 = load i64, i64* %250
%252 = call i32 @labs(i64 %251)
%253 = sext i32 %252 to i64
%254 = srem i64 %247, %253
%255 = icmp ne i64 %254, 0
br i1 %255, label %256, label %266
256: ; preds = %239
%257 = load i64, i64* %48
%258 = add nsw i64 %257, -1
store i64 %258, i64* %48
%259 = load i64, i64* %47
%260 = load i64, i64* %48
%261 = icmp sgt i64 %259, %260
br i1 %261, label %262, label %265
262: ; preds = %256
%263 = load i32*, i32** %27
%264 = load i32, i32* %263
store i32 %264, i32* %14
br label %863
265: ; preds = %256
br label %239
266: ; preds = %239
%267 = load i64, i64* %47
%268 = load i64*, i64** %22
%269 = load i32, i32* %56
%270 = sext i32 %269 to i64
%271 = getelementptr inbounds i64, i64* %268, i64 %270
%272 = load i64, i64* %271
%273 = sub nsw i64 %267, %272
%274 = add nsw i64 %273, 1
%275 = load i32, i32* %56
%276 = sext i32 %275 to i64
%277 = getelementptr inbounds [6 x i64], [6 x i64]* %33, i64 0, i64 %276
%278 = load i64, i64* %277
%279 = call i32 @labs(i64 %278)
%280 = sext i32 %279 to i64
%281 = sdiv i64 %274, %280
%282 = icmp sgt i64 %281, 0
br i1 %282, label %283, label %299
283: ; preds = %266
%284 = load i64, i64* %47
%285 = load i64*, i64** %22
%286 = load i32, i32* %56
%287 = sext i32 %286 to i64
%288 = getelementptr inbounds i64, i64* %285, i64 %287
%289 = load i64, i64* %288
%290 = sub nsw i64 %284, %289
%291 = add nsw i64 %290, 1
%292 = load i32, i32* %56
%293 = sext i32 %292 to i64
%294 = getelementptr inbounds [6 x i64], [6 x i64]* %33, i64 0, i64 %293
%295 = load i64, i64* %294
%296 = call i32 @labs(i64 %295)
%297 = sext i32 %296 to i64
%298 = sdiv i64 %291, %297
br label %300
299: ; preds = %266
br label %300
300: ; preds = %299, %283
%301 = phi i64 [ %298, %283 ], [ 0, %299 ]
%302 = load i32, i32* %56
%303 = sext i32 %302 to i64
%304 = getelementptr inbounds [6 x i64], [6 x i64]* %30, i64 0, i64 %303
store i64 %301, i64* %304
%305 = load i64, i64* %48
%306 = load i64*, i64** %22
%307 = load i32, i32* %56
%308 = sext i32 %307 to i64
%309 = getelementptr inbounds i64, i64* %306, i64 %308
%310 = load i64, i64* %309
%311 = sub nsw i64 %305, %310
%312 = add nsw i64 %311, 1
%313 = load i32, i32* %56
%314 = sext i32 %313 to i64
%315 = getelementptr inbounds [6 x i64], [6 x i64]* %33, i64 0, i64 %314
%316 = load i64, i64* %315
%317 = call i32 @labs(i64 %316)
%318 = sext i32 %317 to i64
%319 = sdiv i64 %312, %318
%320 = load i32, i32* %56
%321 = sext i32 %320 to i64
%322 = getelementptr inbounds [6 x i64], [6 x i64]* %28, i64 0, i64 %321
%323 = load i64, i64* %322
%324 = sub nsw i64 %323, 1
%325 = icmp slt i64 %319, %324
br i1 %325, label %326, label %342
326: ; preds = %300
%327 = load i64, i64* %48
%328 = load i64*, i64** %22
%329 = load i32, i32* %56
%330 = sext i32 %329 to i64
%331 = getelementptr inbounds i64, i64* %328, i64 %330
%332 = load i64, i64* %331
%333 = sub nsw i64 %327, %332
%334 = add nsw i64 %333, 1
%335 = load i32, i32* %56
%336 = sext i32 %335 to i64
%337 = getelementptr inbounds [6 x i64], [6 x i64]* %33, i64 0, i64 %336
%338 = load i64, i64* %337
%339 = call i32 @labs(i64 %338)
%340 = sext i32 %339 to i64
%341 = sdiv i64 %334, %340
br label %348
342: ; preds = %300
%343 = load i32, i32* %56
%344 = sext i32 %343 to i64
%345 = getelementptr inbounds [6 x i64], [6 x i64]* %28, i64 0, i64 %344
%346 = load i64, i64* %345
%347 = sub nsw i64 %346, 1
br label %348
348: ; preds = %342, %326
%349 = phi i64 [ %341, %326 ], [ %347, %342 ]
%350 = load i32, i32* %56
%351 = sext i32 %350 to i64
%352 = getelementptr inbounds [6 x i64], [6 x i64]* %31, i64 0, i64 %351
store i64 %349, i64* %352
%353 = load i64*, i64** %22
%354 = load i32, i32* %56
%355 = sext i32 %354 to i64
%356 = getelementptr inbounds i64, i64* %353, i64 %355
%357 = load i64, i64* %356
%358 = load i64*, i64** %18
%359 = load i32, i32* %56
%360 = sext i32 %359 to i64
%361 = getelementptr inbounds i64, i64* %358, i64 %360
%362 = load i64, i64* %361
%363 = sub nsw i64 %357, %362
%364 = icmp sgt i64 %363, 0
br i1 %364, label %365, label %377
365: ; preds = %348
%366 = load i64*, i64** %22
%367 = load i32, i32* %56
%368 = sext i32 %367 to i64
%369 = getelementptr inbounds i64, i64* %366, i64 %368
%370 = load i64, i64* %369
%371 = load i64*, i64** %18
%372 = load i32, i32* %56
%373 = sext i32 %372 to i64
%374 = getelementptr inbounds i64, i64* %371, i64 %373
%375 = load i64, i64* %374
%376 = sub nsw i64 %370, %375
br label %378
377: ; preds = %348
br label %378
378: ; preds = %377, %365
%379 = phi i64 [ %376, %365 ], [ 0, %377 ]
%380 = load i32, i32* %56
%381 = sext i32 %380 to i64
%382 = getelementptr inbounds [6 x i64], [6 x i64]* %32, i64 0, i64 %381
store i64 %379, i64* %382
br label %383
383: ; preds = %426, %378
%384 = load i64*, i64** %18
%385 = load i32, i32* %56
%386 = sext i32 %385 to i64
%387 = getelementptr inbounds i64, i64* %384, i64 %386
%388 = load i64, i64* %387
%389 = load i32, i32* %56
%390 = sext i32 %389 to i64
%391 = getelementptr inbounds [6 x i64], [6 x i64]* %32, i64 0, i64 %390
%392 = load i64, i64* %391
%393 = add nsw i64 %388, %392
%394 = load i64*, i64** %22
%395 = load i32, i32* %56
%396 = sext i32 %395 to i64
%397 = getelementptr inbounds i64, i64* %394, i64 %396
%398 = load i64, i64* %397
%399 = sub nsw i64 %393, %398
%400 = load i32, i32* %56
%401 = sext i32 %400 to i64
%402 = getelementptr inbounds [6 x i64], [6 x i64]* %33, i64 0, i64 %401
%403 = load i64, i64* %402
%404 = call i32 @labs(i64 %403)
%405 = sext i32 %404 to i64
%406 = srem i64 %399, %405
%407 = icmp ne i64 %406, 0
br i1 %407, label %408, label %427
408: ; preds = %383
%409 = load i32, i32* %56
%410 = sext i32 %409 to i64
%411 = getelementptr inbounds [6 x i64], [6 x i64]* %32, i64 0, i64 %410
%412 = load i64, i64* %411
%413 = add nsw i64 %412, 1
store i64 %413, i64* %411
%414 = load i32, i32* %56
%415 = sext i32 %414 to i64
%416 = getelementptr inbounds [6 x i64], [6 x i64]* %32, i64 0, i64 %415
%417 = load i64, i64* %416
%418 = load i32, i32* %56
%419 = sext i32 %418 to i64
%420 = getelementptr inbounds [6 x i64], [6 x i64]* %29, i64 0, i64 %419
%421 = load i64, i64* %420
%422 = icmp sge i64 %417, %421
br i1 %422, label %423, label %426
423: ; preds = %408
%424 = load i32*, i32** %27
%425 = load i32, i32* %424
store i32 %425, i32* %14
br label %863
426: ; preds = %408
br label %383
427: ; preds = %383
%428 = load i32, i32* %56
%429 = icmp sgt i32 %428, 0
br i1 %429, label %430, label %441
430: ; preds = %427
%431 = load i32, i32* %56
%432 = sub nsw i32 %431, 1
%433 = sext i32 %432 to i64
%434 = getelementptr inbounds [6 x i64], [6 x i64]* %28, i64 0, i64 %433
%435 = load i64, i64* %434
%436 = load i32, i32* %56
%437 = sext i32 %436 to i64
%438 = getelementptr inbounds [6 x i64], [6 x i64]* %28, i64 0, i64 %437
%439 = load i64, i64* %438
%440 = mul nsw i64 %439, %435
store i64 %440, i64* %438
br label %441
441: ; preds = %430, %427
br label %442
442: ; preds = %441
%443 = load i32, i32* %56
%444 = add nsw i32 %443, 1
store i32 %444, i32* %56
br label %92
445: ; preds = %92
%446 = getelementptr inbounds [6 x i64], [6 x i64]* %33, i64 0, i64 0
%447 = load i64, i64* %446
%448 = icmp ne i64 %447, 1
br i1 %448, label %449, label %450
449: ; preds = %445
store i32 1, i32* %58
br label %458
450: ; preds = %445
%451 = getelementptr inbounds [6 x i64], [6 x i64]* %31, i64 0, i64 0
%452 = load i64, i64* %451
%453 = getelementptr inbounds [6 x i64], [6 x i64]* %30, i64 0, i64 0
%454 = load i64, i64* %453
%455 = sub nsw i64 %452, %454
%456 = add nsw i64 %455, 1
%457 = trunc i64 %456 to i32
store i32 %457, i32* %58
br label %458
458: ; preds = %450, %449
%459 = load i32, i32* %58
%460 = load i32, i32* %16
%461 = mul nsw i32 %459, %460
store i32 %461, i32* %57
store i64 0, i64* %37
store i64 0, i64* %41
br label %462
462: ; preds = %855, %458
%463 = load i64, i64* %37
%464 = getelementptr inbounds [6 x i64], [6 x i64]* %31, i64 0, i64 4
%465 = load i64, i64* %464
%466 = getelementptr inbounds [6 x i64], [6 x i64]* %30, i64 0, i64 4
%467 = load i64, i64* %466
%468 = sub nsw i64 %465, %467
%469 = icmp sle i64 %463, %468
br i1 %469, label %470, label %860
470: ; preds = %462
br label %471
471: ; preds = %495, %470
%472 = load i32, i32* %17
%473 = icmp sgt i32 %472, 4
br i1 %473, label %474, label %493
474: ; preds = %471
%475 = load i64*, i64** %18
%476 = getelementptr inbounds i64, i64* %475, i64 4
%477 = load i64, i64* %476
%478 = getelementptr inbounds [6 x i64], [6 x i64]* %32, i64 0, i64 4
%479 = load i64, i64* %478
%480 = add nsw i64 %477, %479
%481 = load i64*, i64** %22
%482 = getelementptr inbounds i64, i64* %481, i64 4
%483 = load i64, i64* %482
%484 = sub nsw i64 %480, %483
%485 = load i64, i64* %41
%486 = add nsw i64 %484, %485
%487 = getelementptr inbounds [6 x i64], [6 x i64]* %33, i64 0, i64 4
%488 = load i64, i64* %487
%489 = call i32 @labs(i64 %488)
%490 = sext i32 %489 to i64
%491 = srem i64 %486, %490
%492 = icmp ne i64 %491, 0
br label %493
493: ; preds = %474, %471
%494 = phi i1 [ false, %471 ], [ %492, %474 ]
br i1 %494, label %495, label %498
495: ; preds = %493
%496 = load i64, i64* %41
%497 = add nsw i64 %496, 1
store i64 %497, i64* %41
br label %471
498: ; preds = %493
%499 = getelementptr inbounds [6 x i64], [6 x i64]* %33, i64 0, i64 4
%500 = load i64, i64* %499
%501 = icmp sgt i64 %500, 0
br i1 %501, label %502, label %510
502: ; preds = %498
%503 = load i64, i64* %37
%504 = getelementptr inbounds [6 x i64], [6 x i64]* %30, i64 0, i64 4
%505 = load i64, i64* %504
%506 = add nsw i64 %503, %505
%507 = getelementptr inbounds [6 x i64], [6 x i64]* %28, i64 0, i64 3
%508 = load i64, i64* %507
%509 = mul nsw i64 %506, %508
store i64 %509, i64* %45
br label %522
510: ; preds = %498
%511 = getelementptr inbounds [6 x i64], [6 x i64]* %28, i64 0, i64 4
%512 = load i64, i64* %511
%513 = load i64, i64* %37
%514 = add nsw i64 %513, 1
%515 = getelementptr inbounds [6 x i64], [6 x i64]* %30, i64 0, i64 4
%516 = load i64, i64* %515
%517 = add nsw i64 %514, %516
%518 = getelementptr inbounds [6 x i64], [6 x i64]* %28, i64 0, i64 3
%519 = load i64, i64* %518
%520 = mul nsw i64 %517, %519
%521 = sub nsw i64 %512, %520
store i64 %521, i64* %45
br label %522
522: ; preds = %510, %502
%523 = getelementptr inbounds [6 x i64], [6 x i64]* %32, i64 0, i64 4
%524 = load i64, i64* %523
%525 = load i64, i64* %41
%526 = add nsw i64 %524, %525
%527 = getelementptr inbounds [6 x i64], [6 x i64]* %29, i64 0, i64 3
%528 = load i64, i64* %527
%529 = mul nsw i64 %526, %528
store i64 %529, i64* %51
store i64 0, i64* %36
store i64 0, i64* %40
br label %530
530: ; preds = %849, %522
%531 = load i64, i64* %36
%532 = getelementptr inbounds [6 x i64], [6 x i64]* %31, i64 0, i64 3
%533 = load i64, i64* %532
%534 = getelementptr inbounds [6 x i64], [6 x i64]* %30, i64 0, i64 3
%535 = load i64, i64* %534
%536 = sub nsw i64 %533, %535
%537 = icmp sle i64 %531, %536
br i1 %537, label %538, label %854
538: ; preds = %530
br label %539
539: ; preds = %563, %538
%540 = load i32, i32* %17
%541 = icmp sgt i32 %540, 3
br i1 %541, label %542, label %561
542: ; preds = %539
%543 = load i64*, i64** %18
%544 = getelementptr inbounds i64, i64* %543, i64 3
%545 = load i64, i64* %544
%546 = getelementptr inbounds [6 x i64], [6 x i64]* %32, i64 0, i64 3
%547 = load i64, i64* %546
%548 = add nsw i64 %545, %547
%549 = load i64*, i64** %22
%550 = getelementptr inbounds i64, i64* %549, i64 3
%551 = load i64, i64* %550
%552 = sub nsw i64 %548, %551
%553 = load i64, i64* %40
%554 = add nsw i64 %552, %553
%555 = getelementptr inbounds [6 x i64], [6 x i64]* %33, i64 0, i64 3
%556 = load i64, i64* %555
%557 = call i32 @labs(i64 %556)
%558 = sext i32 %557 to i64
%559 = srem i64 %554, %558
%560 = icmp ne i64 %559, 0
br label %561
561: ; preds = %542, %539
%562 = phi i1 [ false, %539 ], [ %560, %542 ]
br i1 %562, label %563, label %566
563: ; preds = %561
%564 = load i64, i64* %40
%565 = add nsw i64 %564, 1
store i64 %565, i64* %40
br label %539
566: ; preds = %561
%567 = getelementptr inbounds [6 x i64], [6 x i64]* %33, i64 0, i64 3
%568 = load i64, i64* %567
%569 = icmp sgt i64 %568, 0
br i1 %569, label %570, label %580
570: ; preds = %566
%571 = load i64, i64* %36
%572 = getelementptr inbounds [6 x i64], [6 x i64]* %30, i64 0, i64 3
%573 = load i64, i64* %572
%574 = add nsw i64 %571, %573
%575 = getelementptr inbounds [6 x i64], [6 x i64]* %28, i64 0, i64 2
%576 = load i64, i64* %575
%577 = mul nsw i64 %574, %576
%578 = load i64, i64* %45
%579 = add nsw i64 %577, %578
store i64 %579, i64* %44
br label %594
580: ; preds = %566
%581 = getelementptr inbounds [6 x i64], [6 x i64]* %28, i64 0, i64 3
%582 = load i64, i64* %581
%583 = load i64, i64* %36
%584 = add nsw i64 %583, 1
%585 = getelementptr inbounds [6 x i64], [6 x i64]* %30, i64 0, i64 3
%586 = load i64, i64* %585
%587 = add nsw i64 %584, %586
%588 = getelementptr inbounds [6 x i64], [6 x i64]* %28, i64 0, i64 2
%589 = load i64, i64* %588
%590 = mul nsw i64 %587, %589
%591 = sub nsw i64 %582, %590
%592 = load i64, i64* %45
%593 = add nsw i64 %591, %592
store i64 %593, i64* %44
br label %594
594: ; preds = %580, %570
%595 = getelementptr inbounds [6 x i64], [6 x i64]* %32, i64 0, i64 3
%596 = load i64, i64* %595
%597 = load i64, i64* %40
%598 = add nsw i64 %596, %597
%599 = getelementptr inbounds [6 x i64], [6 x i64]* %29, i64 0, i64 2
%600 = load i64, i64* %599
%601 = mul nsw i64 %598, %600
%602 = load i64, i64* %51
%603 = add nsw i64 %601, %602
store i64 %603, i64* %50
store i64 0, i64* %35
store i64 0, i64* %39
br label %604
604: ; preds = %843, %594
%605 = load i64, i64* %35
%606 = getelementptr inbounds [6 x i64], [6 x i64]* %31, i64 0, i64 2
%607 = load i64, i64* %606
%608 = getelementptr inbounds [6 x i64], [6 x i64]* %30, i64 0, i64 2
%609 = load i64, i64* %608
%610 = sub nsw i64 %607, %609
%611 = icmp sle i64 %605, %610
br i1 %611, label %612, label %848
612: ; preds = %604
br label %613
613: ; preds = %637, %612
%614 = load i32, i32* %17
%615 = icmp sgt i32 %614, 2
br i1 %615, label %616, label %635
616: ; preds = %613
%617 = load i64*, i64** %18
%618 = getelementptr inbounds i64, i64* %617, i64 2
%619 = load i64, i64* %618
%620 = getelementptr inbounds [6 x i64], [6 x i64]* %32, i64 0, i64 2
%621 = load i64, i64* %620
%622 = add nsw i64 %619, %621
%623 = load i64*, i64** %22
%624 = getelementptr inbounds i64, i64* %623, i64 2
%625 = load i64, i64* %624
%626 = sub nsw i64 %622, %625
%627 = load i64, i64* %39
%628 = add nsw i64 %626, %627
%629 = getelementptr inbounds [6 x i64], [6 x i64]* %33, i64 0, i64 2
%630 = load i64, i64* %629
%631 = call i32 @labs(i64 %630)
%632 = sext i32 %631 to i64
%633 = srem i64 %628, %632
%634 = icmp ne i64 %633, 0
br label %635
635: ; preds = %616, %613
%636 = phi i1 [ false, %613 ], [ %634, %616 ]
br i1 %636, label %637, label %640
637: ; preds = %635
%638 = load i64, i64* %39
%639 = add nsw i64 %638, 1
store i64 %639, i64* %39
br label %613
640: ; preds = %635
%641 = getelementptr inbounds [6 x i64], [6 x i64]* %33, i64 0, i64 2
%642 = load i64, i64* %641
%643 = icmp sgt i64 %642, 0
br i1 %643, label %644, label %654
644: ; preds = %640
%645 = load i64, i64* %35
%646 = getelementptr inbounds [6 x i64], [6 x i64]* %30, i64 0, i64 2
%647 = load i64, i64* %646
%648 = add nsw i64 %645, %647
%649 = getelementptr inbounds [6 x i64], [6 x i64]* %28, i64 0, i64 1
%650 = load i64, i64* %649
%651 = mul nsw i64 %648, %650
%652 = load i64, i64* %44
%653 = add nsw i64 %651, %652
store i64 %653, i64* %43
br label %668
654: ; preds = %640
%655 = getelementptr inbounds [6 x i64], [6 x i64]* %28, i64 0, i64 2
%656 = load i64, i64* %655
%657 = load i64, i64* %35
%658 = add nsw i64 %657, 1
%659 = getelementptr inbounds [6 x i64], [6 x i64]* %30, i64 0, i64 2
%660 = load i64, i64* %659
%661 = add nsw i64 %658, %660
%662 = getelementptr inbounds [6 x i64], [6 x i64]* %28, i64 0, i64 1
%663 = load i64, i64* %662
%664 = mul nsw i64 %661, %663
%665 = sub nsw i64 %656, %664
%666 = load i64, i64* %44
%667 = add nsw i64 %665, %666
store i64 %667, i64* %43
br label %668
668: ; preds = %654, %644
%669 = getelementptr inbounds [6 x i64], [6 x i64]* %32, i64 0, i64 2
%670 = load i64, i64* %669
%671 = load i64, i64* %39
%672 = add nsw i64 %670, %671
%673 = getelementptr inbounds [6 x i64], [6 x i64]* %29, i64 0, i64 1
%674 = load i64, i64* %673
%675 = mul nsw i64 %672, %674
%676 = load i64, i64* %50
%677 = add nsw i64 %675, %676
store i64 %677, i64* %49
store i64 0, i64* %34
store i64 0, i64* %38
br label %678
678: ; preds = %837, %668
%679 = load i64, i64* %34
%680 = getelementptr inbounds [6 x i64], [6 x i64]* %31, i64 0, i64 1
%681 = load i64, i64* %680
%682 = getelementptr inbounds [6 x i64], [6 x i64]* %30, i64 0, i64 1
%683 = load i64, i64* %682
%684 = sub nsw i64 %681, %683
%685 = icmp sle i64 %679, %684
br i1 %685, label %686, label %842
686: ; preds = %678
br label %687
687: ; preds = %711, %686
%688 = load i32, i32* %17
%689 = icmp sgt i32 %688, 1
br i1 %689, label %690, label %709
690: ; preds = %687
%691 = load i64*, i64** %18
%692 = getelementptr inbounds i64, i64* %691, i64 1
%693 = load i64, i64* %692
%694 = getelementptr inbounds [6 x i64], [6 x i64]* %32, i64 0, i64 1
%695 = load i64, i64* %694
%696 = add nsw i64 %693, %695
%697 = load i64*, i64** %22
%698 = getelementptr inbounds i64, i64* %697, i64 1
%699 = load i64, i64* %698
%700 = sub nsw i64 %696, %699
%701 = load i64, i64* %38
%702 = add nsw i64 %700, %701
%703 = getelementptr inbounds [6 x i64], [6 x i64]* %33, i64 0, i64 1
%704 = load i64, i64* %703
%705 = call i32 @labs(i64 %704)
%706 = sext i32 %705 to i64
%707 = srem i64 %702, %706
%708 = icmp ne i64 %707, 0
br label %709
709: ; preds = %690, %687
%710 = phi i1 [ false, %687 ], [ %708, %690 ]
br i1 %710, label %711, label %714
711: ; preds = %709
%712 = load i64, i64* %38
%713 = add nsw i64 %712, 1
store i64 %713, i64* %38
br label %687
714: ; preds = %709
%715 = getelementptr inbounds [6 x i64], [6 x i64]* %32, i64 0, i64 0
%716 = load i64, i64* %715
%717 = getelementptr inbounds [6 x i64], [6 x i64]* %32, i64 0, i64 1
%718 = load i64, i64* %717
%719 = load i64, i64* %38
%720 = add nsw i64 %718, %719
%721 = getelementptr inbounds [6 x i64], [6 x i64]* %29, i64 0, i64 0
%722 = load i64, i64* %721
%723 = mul nsw i64 %720, %722
%724 = add nsw i64 %716, %723
%725 = load i64, i64* %49
%726 = add nsw i64 %724, %725
store i64 %726, i64* %52
%727 = getelementptr inbounds [6 x i64], [6 x i64]* %33, i64 0, i64 1
%728 = load i64, i64* %727
%729 = icmp sgt i64 %728, 0
br i1 %729, label %730, label %740
730: ; preds = %714
%731 = load i64, i64* %34
%732 = getelementptr inbounds [6 x i64], [6 x i64]* %30, i64 0, i64 1
%733 = load i64, i64* %732
%734 = add nsw i64 %731, %733
%735 = getelementptr inbounds [6 x i64], [6 x i64]* %28, i64 0, i64 0
%736 = load i64, i64* %735
%737 = mul nsw i64 %734, %736
%738 = load i64, i64* %43
%739 = add nsw i64 %737, %738
store i64 %739, i64* %42
br label %754
740: ; preds = %714
%741 = getelementptr inbounds [6 x i64], [6 x i64]* %28, i64 0, i64 1
%742 = load i64, i64* %741
%743 = load i64, i64* %34
%744 = add nsw i64 %743, 1
%745 = getelementptr inbounds [6 x i64], [6 x i64]* %30, i64 0, i64 1
%746 = load i64, i64* %745
%747 = add nsw i64 %744, %746
%748 = getelementptr inbounds [6 x i64], [6 x i64]* %28, i64 0, i64 0
%749 = load i64, i64* %748
%750 = mul nsw i64 %747, %749
%751 = sub nsw i64 %742, %750
%752 = load i64, i64* %43
%753 = add nsw i64 %751, %752
store i64 %753, i64* %42
br label %754
754: ; preds = %740, %730
%755 = getelementptr inbounds [6 x i64], [6 x i64]* %33, i64 0, i64 0
%756 = load i64, i64* %755
%757 = icmp sgt i64 %756, 0
br i1 %757, label %758, label %763
758: ; preds = %754
%759 = getelementptr inbounds [6 x i64], [6 x i64]* %30, i64 0, i64 0
%760 = load i64, i64* %759
%761 = load i64, i64* %42
%762 = add nsw i64 %760, %761
store i64 %762, i64* %53
br label %772
763: ; preds = %754
%764 = getelementptr inbounds [6 x i64], [6 x i64]* %28, i64 0, i64 0
%765 = load i64, i64* %764
%766 = sub nsw i64 %765, 1
%767 = getelementptr inbounds [6 x i64], [6 x i64]* %30, i64 0, i64 0
%768 = load i64, i64* %767
%769 = sub nsw i64 %766, %768
%770 = load i64, i64* %42
%771 = add nsw i64 %769, %770
store i64 %771, i64* %53
br label %772
772: ; preds = %763, %758
%773 = getelementptr inbounds [6 x i64], [6 x i64]* %30, i64 0, i64 0
%774 = load i64, i64* %773
store i64 %774, i64* %46
br label %775
775: ; preds = %831, %772
%776 = load i64, i64* %46
%777 = getelementptr inbounds [6 x i64], [6 x i64]* %31, i64 0, i64 0
%778 = load i64, i64* %777
%779 = icmp sle i64 %776, %778
br i1 %779, label %780, label %836
780: ; preds = %775
%781 = load i32, i32* %25
%782 = icmp eq i32 %781, 2
br i1 %782, label %783, label %792
783: ; preds = %780
%784 = load i8*, i8** %26
%785 = load i64, i64* %53
%786 = getelementptr inbounds i8, i8* %784, i64 %785
%787 = load i8*, i8** %20
%788 = load i64, i64* %52
%789 = getelementptr inbounds i8, i8* %787, i64 %788
%790 = load i32, i32* %58
%791 = call i32 @memcpy(i8* %786, i8* %789, i32 %790)
br label %792
792: ; preds = %783, %780
%793 = load i64, i64* %52
%794 = load i32, i32* %16
%795 = sext i32 %794 to i64
%796 = mul nsw i64 %793, %795
store i64 %796, i64* %54
%797 = load i64, i64* %53
%798 = load i32, i32* %16
%799 = sext i32 %798 to i64
%800 = mul nsw i64 %797, %799
store i64 %800, i64* %55
%801 = load i8*, i8** %21
%802 = load i64, i64* %55
%803 = getelementptr inbounds i8, i8* %801, i64 %802
%804 = load i8*, i8** %15
%805 = load i64, i64* %54
%806 = getelementptr inbounds i8, i8* %804, i64 %805
%807 = load i32, i32* %57
%808 = call i32 @memcpy(i8* %803, i8* %806, i32 %807)
%809 = load i32, i32* %58
%810 = getelementptr inbounds [6 x i64], [6 x i64]* %33, i64 0, i64 0
%811 = load i64, i64* %810
%812 = call i32 @labs(i64 %811)
%813 = mul nsw i32 %809, %812
%814 = sext i32 %813 to i64
%815 = load i64, i64* %52
%816 = add nsw i64 %815, %814
store i64 %816, i64* %52
%817 = getelementptr inbounds [6 x i64], [6 x i64]* %33, i64 0, i64 0
%818 = load i64, i64* %817
%819 = icmp sgt i64 %818, 0
br i1 %819, label %820, label %825
820: ; preds = %792
%821 = load i32, i32* %58
%822 = sext i32 %821 to i64
%823 = load i64, i64* %53
%824 = add nsw i64 %823, %822
store i64 %824, i64* %53
br label %830
825: ; preds = %792
%826 = load i32, i32* %58
%827 = sext i32 %826 to i64
%828 = load i64, i64* %53
%829 = sub nsw i64 %828, %827
store i64 %829, i64* %53
br label %830
830: ; preds = %825, %820
br label %831
831: ; preds = %830
%832 = load i32, i32* %58
%833 = sext i32 %832 to i64
%834 = load i64, i64* %46
%835 = add nsw i64 %834, %833
store i64 %835, i64* %46
br label %775
836: ; preds = %775
br label %837
837: ; preds = %836
%838 = load i64, i64* %34
%839 = add nsw i64 %838, 1
store i64 %839, i64* %34
%840 = load i64, i64* %38
%841 = add nsw i64 %840, 1
store i64 %841, i64* %38
br label %678
842: ; preds = %678
br label %843
843: ; preds = %842
%844 = load i64, i64* %35
%845 = add nsw i64 %844, 1
store i64 %845, i64* %35
%846 = load i64, i64* %39
%847 = add nsw i64 %846, 1
store i64 %847, i64* %39
br label %604
848: ; preds = %604
br label %849
849: ; preds = %848
%850 = load i64, i64* %36
%851 = add nsw i64 %850, 1
store i64 %851, i64* %36
%852 = load i64, i64* %40
%853 = add nsw i64 %852, 1
store i64 %853, i64* %40
br label %530
854: ; preds = %530
br label %855
855: ; preds = %854
%856 = load i64, i64* %37
%857 = add nsw i64 %856, 1
store i64 %857, i64* %37
%858 = load i64, i64* %41
%859 = add nsw i64 %858, 1
store i64 %859, i64* %41
br label %462
860: ; preds = %462
%861 = load i32*, i32** %27
%862 = load i32, i32* %861
store i32 %862, i32* %14
br label %863
863: ; preds = %860, %423, %262, %234, %182, %159, %120, %62
%864 = load i32, i32* %14
ret i32 %864
}

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