#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_merge_overlap(char *tile, int pixlen, int ndim, long *tfpixel,
                         long *tlpixel, char *bnullarray, char *image,
                         long *fpixel, long *lpixel, int nullcheck,
                         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);
    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) {
            tilepixbyte = tilepix * pixlen;
            imgpixbyte = imgpix * pixlen;
            memcpy(tile + tilepixbyte, image + imgpixbyte, 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_merge_overlap>:
push   %rbp
mov    %rsp,%rbp
sub    $0x2b0,%rsp
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%eax
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    0x30(%rbp),%rax
cmpl   $0x0,(%rax)
jle    116f <imcomp_merge_overlap+0x4f>
mov    0x30(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x4(%rbp)
jmp    1f56 <imcomp_merge_overlap+0xe36>
movl   $0x0,-0x204(%rbp)
cmpl   $0x6,-0x204(%rbp)
jge    1209 <imcomp_merge_overlap+0xe9>
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    1179 <imcomp_merge_overlap+0x59>
movl   $0x0,-0x204(%rbp)
mov    -0x204(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    17fb <imcomp_merge_overlap+0x6db>
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     126a <imcomp_merge_overlap+0x14a>
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    1278 <imcomp_merge_overlap+0x158>
mov    0x30(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x4(%rbp)
jmp    1f56 <imcomp_merge_overlap+0xe36>
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    12fe <imcomp_merge_overlap+0x1de>
mov    0x30(%rbp),%rax
movl   $0x143,(%rax)
movl   $0x143,-0x4(%rbp)
jmp    1f56 <imcomp_merge_overlap+0xe36>
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    135b <imcomp_merge_overlap+0x23b>
mov    0x30(%rbp),%rax
movl   $0x143,(%rax)
movl   $0x143,-0x4(%rbp)
jmp    1f56 <imcomp_merge_overlap+0xe36>
cmpl   $0x0,-0x204(%rbp)
jle    1393 <imcomp_merge_overlap+0x273>
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     1453 <imcomp_merge_overlap+0x333>
mov    -0x1c0(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x1c0(%rbp)
mov    -0x1c0(%rbp),%rax
cmp    -0x1c8(%rbp),%rax
jle    144e <imcomp_merge_overlap+0x32e>
mov    0x30(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x4(%rbp)
jmp    1f56 <imcomp_merge_overlap+0xe36>
jmp    13c7 <imcomp_merge_overlap+0x2a7>
jmp    1458 <imcomp_merge_overlap+0x338>
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     14e4 <imcomp_merge_overlap+0x3c4>
mov    -0x1c8(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x1c8(%rbp)
mov    -0x1c0(%rbp),%rax
cmp    -0x1c8(%rbp),%rax
jle    14df <imcomp_merge_overlap+0x3bf>
mov    0x30(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x4(%rbp)
jmp    1f56 <imcomp_merge_overlap+0xe36>
jmp    1458 <imcomp_merge_overlap+0x338>
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    1586 <imcomp_merge_overlap+0x466>
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    1594 <imcomp_merge_overlap+0x474>
xor    %eax,%eax
mov    %rax,-0x238(%rbp)
jmp    1594 <imcomp_merge_overlap+0x474>
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    165b <imcomp_merge_overlap+0x53b>
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    1672 <imcomp_merge_overlap+0x552>
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    16da <imcomp_merge_overlap+0x5ba>
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    16e8 <imcomp_merge_overlap+0x5c8>
xor    %eax,%eax
mov    %rax,-0x260(%rbp)
jmp    16e8 <imcomp_merge_overlap+0x5c8>
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     17b3 <imcomp_merge_overlap+0x693>
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     17ae <imcomp_merge_overlap+0x68e>
mov    0x30(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x4(%rbp)
jmp    1f56 <imcomp_merge_overlap+0xe36>
jmp    16fe <imcomp_merge_overlap+0x5de>
cmpl   $0x0,-0x204(%rbp)
jle    17e2 <imcomp_merge_overlap+0x6c2>
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    17e7 <imcomp_merge_overlap+0x6c7>
mov    -0x204(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x204(%rbp)
jmp    1213 <imcomp_merge_overlap+0xf3>
cmpq   $0x1,-0x150(%rbp)
01
je     1818 <imcomp_merge_overlap+0x6f8>
movl   $0x1,-0x20c(%rbp)
jmp    1830 <imcomp_merge_overlap+0x710>
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     1f4d <imcomp_merge_overlap+0xe2d>
jmp    1879 <imcomp_merge_overlap+0x759>
xor    %eax,%eax
cmpl   $0x4,-0x18(%rbp)
mov    %al,-0x269(%rbp)
jle    18da <imcomp_merge_overlap+0x7ba>
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    18ed <imcomp_merge_overlap+0x7cd>
jmp    1904 <imcomp_merge_overlap+0x7e4>
mov    -0x190(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x190(%rbp)
jmp    1879 <imcomp_merge_overlap+0x759>
cmpq   $0x0,-0x130(%rbp)
jle    1931 <imcomp_merge_overlap+0x811>
mov    -0x170(%rbp),%rax
add    -0xa0(%rbp),%rax
imul   -0x48(%rbp),%rax
mov    %rax,-0x1b0(%rbp)
jmp    1956 <imcomp_merge_overlap+0x836>
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     1f1f <imcomp_merge_overlap+0xdff>
jmp    19a9 <imcomp_merge_overlap+0x889>
xor    %eax,%eax
cmpl   $0x3,-0x18(%rbp)
mov    %al,-0x279(%rbp)
jle    1a0a <imcomp_merge_overlap+0x8ea>
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    1a1d <imcomp_merge_overlap+0x8fd>
jmp    1a34 <imcomp_merge_overlap+0x914>
mov    -0x188(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x188(%rbp)
jmp    19a9 <imcomp_merge_overlap+0x889>
cmpq   $0x0,-0x138(%rbp)
jle    1a68 <imcomp_merge_overlap+0x948>
mov    -0x168(%rbp),%rax
add    -0xa8(%rbp),%rax
imul   -0x50(%rbp),%rax
add    -0x1b0(%rbp),%rax
mov    %rax,-0x1a8(%rbp)
jmp    1a94 <imcomp_merge_overlap+0x974>
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     1ef1 <imcomp_merge_overlap+0xdd1>
jmp    1aee <imcomp_merge_overlap+0x9ce>
xor    %eax,%eax
cmpl   $0x2,-0x18(%rbp)
mov    %al,-0x289(%rbp)
jle    1b4f <imcomp_merge_overlap+0xa2f>
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    1b62 <imcomp_merge_overlap+0xa42>
jmp    1b79 <imcomp_merge_overlap+0xa59>
mov    -0x180(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x180(%rbp)
jmp    1aee <imcomp_merge_overlap+0x9ce>
cmpq   $0x0,-0x140(%rbp)
jle    1bad <imcomp_merge_overlap+0xa8d>
mov    -0x160(%rbp),%rax
add    -0xb0(%rbp),%rax
imul   -0x58(%rbp),%rax
add    -0x1a8(%rbp),%rax
mov    %rax,-0x1a0(%rbp)
jmp    1bd9 <imcomp_merge_overlap+0xab9>
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     1ec3 <imcomp_merge_overlap+0xda3>
jmp    1c36 <imcomp_merge_overlap+0xb16>
xor    %eax,%eax
cmpl   $0x1,-0x18(%rbp)
mov    %al,-0x299(%rbp)
jle    1c97 <imcomp_merge_overlap+0xb77>
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    1caa <imcomp_merge_overlap+0xb8a>
jmp    1cc1 <imcomp_merge_overlap+0xba1>
mov    -0x178(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x178(%rbp)
jmp    1c36 <imcomp_merge_overlap+0xb16>
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    1d23 <imcomp_merge_overlap+0xc03>
mov    -0x158(%rbp),%rax
add    -0xb8(%rbp),%rax
imul   -0x60(%rbp),%rax
add    -0x1a0(%rbp),%rax
mov    %rax,-0x198(%rbp)
jmp    1d4f <imcomp_merge_overlap+0xc2f>
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    1d77 <imcomp_merge_overlap+0xc57>
mov    -0xc0(%rbp),%rax
add    -0x198(%rbp),%rax
mov    %rax,-0x1f0(%rbp)
jmp    1d94 <imcomp_merge_overlap+0xc74>
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     1e95 <imcomp_merge_overlap+0xd75>
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    -0x1f8(%rbp),%rdi
mov    0x10(%rbp),%rsi
add    -0x200(%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    1e5e <imcomp_merge_overlap+0xd3e>
movslq -0x20c(%rbp),%rax
add    -0x1f0(%rbp),%rax
mov    %rax,-0x1f0(%rbp)
jmp    1e76 <imcomp_merge_overlap+0xd56>
movslq -0x20c(%rbp),%rcx
mov    -0x1f0(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x1f0(%rbp)
jmp    1e7b <imcomp_merge_overlap+0xd5b>
movslq -0x20c(%rbp),%rax
add    -0x1b8(%rbp),%rax
mov    %rax,-0x1b8(%rbp)
jmp    1da2 <imcomp_merge_overlap+0xc82>
jmp    1e9a <imcomp_merge_overlap+0xd7a>
mov    -0x158(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x158(%rbp)
mov    -0x178(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x178(%rbp)
jmp    1c13 <imcomp_merge_overlap+0xaf3>
jmp    1ec8 <imcomp_merge_overlap+0xda8>
mov    -0x160(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x160(%rbp)
mov    -0x180(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x180(%rbp)
jmp    1acb <imcomp_merge_overlap+0x9ab>
jmp    1ef6 <imcomp_merge_overlap+0xdd6>
mov    -0x168(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x168(%rbp)
mov    -0x188(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x188(%rbp)
jmp    1986 <imcomp_merge_overlap+0x866>
jmp    1f24 <imcomp_merge_overlap+0xe04>
mov    -0x170(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x170(%rbp)
mov    -0x190(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x190(%rbp)
jmp    1856 <imcomp_merge_overlap+0x736>
mov    0x30(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x2b0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<imcomp_merge_overlap>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x298,%rsp
mov    0x2f0(%rsp),%r13
mov    0x0(%r13),%eax
test   %eax,%eax
jg     15cb <imcomp_merge_overlap+0x4ab>
mov    %rcx,%r15
mov    %edx,%r14d
mov    0x2d8(%rsp),%rbp
xorps  %xmm0,%xmm0
movaps %xmm0,0x250(%rsp)
movaps %xmm0,0x240(%rsp)
movaps %xmm0,0x230(%rsp)
movaps %xmm0,0x200(%rsp)
movaps %xmm0,0x210(%rsp)
movaps %xmm0,0x220(%rsp)
movaps %xmm0,0x170(%rsp)
movaps %xmm0,0x180(%rsp)
movaps %xmm0,0x190(%rsp)
movaps 0xe5b(%rip),%xmm0
movaps %xmm0,0x260(%rsp)
movaps %xmm0,0x1d0(%rsp)
movaps %xmm0,0x1a0(%rsp)
movaps %xmm0,0x270(%rsp)
movaps %xmm0,0x1e0(%rsp)
movaps %xmm0,0x1b0(%rsp)
movaps %xmm0,0x280(%rsp)
movaps %xmm0,0x1f0(%rsp)
movaps %xmm0,0x1c0(%rsp)
test   %edx,%edx
mov    %rcx,0x18(%rsp)
mov    %edx,0x3c(%rsp)
mov    %rdi,0xa8(%rsp)
jle    15dd <imcomp_merge_overlap+0x4bd>
mov    %r8,%r12
mov    0x2e0(%rsp),%rcx
mov    %r14d,%eax
mov    %rax,0x68(%rsp)
xor    %r14d,%r14d
mov    %esi,0x28(%rsp)
mov    %r8,0x8(%rsp)
mov    0x0(%rbp,%r14,8),%rax
cmp    %rax,(%r12,%r14,8)
jl     1c73 <imcomp_merge_overlap+0xb53>
mov    (%rcx,%r14,8),%rbx
cmp    %rbx,(%r15,%r14,8)
jg     1c73 <imcomp_merge_overlap+0xb53>
sub    %rax,%rbx
mov    0x260(%rsp,%r14,8),%rdi
mov    %rdi,(%rsp)
call   1030 <labs@plt>
mov    %eax,%ecx
movslq %eax,%rsi
mov    %rbx,%rax
or     %rsi,%rax
mov    %rbp,%r12
shr    $0x20,%rax
je     1277 <imcomp_merge_overlap+0x157>
mov    %rbx,%rax
cqto
idiv   %rsi
mov    %rax,%rcx
jmp    127f <imcomp_merge_overlap+0x15f>
mov    %ebx,%eax
xor    %edx,%edx
div    %ecx
mov    %eax,%ecx
lea    0x1(%rcx),%rax
mov    %rax,0x1d0(%rsp,%r14,8)
test   %rcx,%rcx
js     1c7c <imcomp_merge_overlap+0xb5c>
mov    %rax,0x40(%rsp)
mov    0x8(%rsp),%rax
mov    (%rax,%r14,8),%rdx
mov    (%r15,%r14,8),%rbp
mov    %rdx,%rax
sub    %rbp,%rax
lea    0x1(%rax),%rsi
mov    %rsi,0x1a0(%rsp,%r14,8)
test   %rax,%rax
js     1c7c <imcomp_merge_overlap+0xb5c>
test   %r14,%r14
mov    %rcx,0x30(%rsp)
je     12eb <imcomp_merge_overlap+0x1cb>
mov    $0xffffffff,%eax
add    %r14d,%eax
imul   0x1a0(%rsp,%rax,8),%rsi
mov    %rsi,0x10(%rsp)
mov    %rsi,0x1a0(%rsp,%r14,8)
jmp    12f0 <imcomp_merge_overlap+0x1d0>
mov    %rsi,0x10(%rsp)
mov    %rdx,%r15
lea    -0x1(%rdx),%r13
jmp    131f <imcomp_merge_overlap+0x1ff>
nopl   0x0(%rax)
mov    %ebx,%eax
xor    %edx,%edx
div    %ecx
test   %rdx,%rdx
je     134d <imcomp_merge_overlap+0x22d>
lea    0x1(%rbp),%rax
add    $0xffffffffffffffff,%rbp
cmp    %r13,%rbp
mov    %rax,%rbp
jge    15c1 <imcomp_merge_overlap+0x4a1>
mov    %rbp,%rbx
sub    (%r12,%r14,8),%rbx
mov    (%rsp),%rdi
call   1030 <labs@plt>
mov    %eax,%ecx
movslq %eax,%rsi
mov    %rbx,%rax
or     %rsi,%rax
shr    $0x20,%rax
je     1300 <imcomp_merge_overlap+0x1e0>
mov    %rbx,%rax
cqto
idiv   %rsi
test   %rdx,%rdx
jne    130b <imcomp_merge_overlap+0x1eb>
lea    -0x1(%rbp),%r13
mov    %r15,%rbx
jmp    137b <imcomp_merge_overlap+0x25b>
cs nopw 0x0(%rax,%rax,1)
mov    %ebx,%eax
xor    %edx,%edx
div    %ecx
test   %rdx,%rdx
je     13a9 <imcomp_merge_overlap+0x289>
mov    %r15,%rbx
add    $0xffffffffffffffff,%rbx
cmp    %rbx,%r13
jge    15c1 <imcomp_merge_overlap+0x4a1>
mov    %rbx,%r15
sub    (%r12,%r14,8),%rbx
mov    (%rsp),%rdi
call   1030 <labs@plt>
mov    %eax,%ecx
movslq %eax,%rsi
mov    %rbx,%rax
or     %rsi,%rax
shr    $0x20,%rax
je     1360 <imcomp_merge_overlap+0x240>
mov    %rbx,%rax
cqto
idiv   %rsi
test   %rdx,%rdx
jne    136b <imcomp_merge_overlap+0x24b>
mov    %rbp,%rbx
sub    (%r12,%r14,8),%rbx
mov    (%rsp),%rdi
call   1030 <labs@plt>
mov    %eax,%ecx
movslq %eax,%rsi
mov    %rbx,%rax
or     %rsi,%rax
shr    $0x20,%rax
je     13d4 <imcomp_merge_overlap+0x2b4>
mov    %rbx,%rax
cqto
idiv   %rsi
jmp    13da <imcomp_merge_overlap+0x2ba>
mov    %ebx,%eax
xor    %edx,%edx
div    %ecx
mov    0x2f0(%rsp),%r13
mov    %r15,%rbx
test   %rax,%rax
jle    1412 <imcomp_merge_overlap+0x2f2>
sub    (%r12,%r14,8),%rbp
mov    (%rsp),%rdi
call   1030 <labs@plt>
mov    %eax,%ecx
movslq %eax,%rsi
mov    %rbp,%rax
or     %rsi,%rax
shr    $0x20,%rax
je     141b <imcomp_merge_overlap+0x2fb>
mov    %rbp,%rax
cqto
idiv   %rsi
jmp    1421 <imcomp_merge_overlap+0x301>
xor    %eax,%eax
mov    0x18(%rsp),%rbp
jmp    1429 <imcomp_merge_overlap+0x309>
mov    %ebp,%eax
xor    %edx,%edx
div    %ecx
mov    0x18(%rsp),%rbp
mov    %r15,%rbx
mov    %rax,0x230(%rsp,%r14,8)
sub    (%r12,%r14,8),%rbx
mov    (%rsp),%rdi
call   1030 <labs@plt>
mov    %eax,%ecx
movslq %eax,%rsi
mov    %rbx,%rax
or     %rsi,%rax
shr    $0x20,%rax
je     1459 <imcomp_merge_overlap+0x339>
mov    %rbx,%rax
cqto
idiv   %rsi
jmp    145f <imcomp_merge_overlap+0x33f>
mov    %ebx,%eax
xor    %edx,%edx
div    %ecx
mov    0x30(%rsp),%rcx
cmp    %rcx,%rax
jge    149d <imcomp_merge_overlap+0x37d>
sub    (%r12,%r14,8),%r15
mov    (%rsp),%rdi
call   1030 <labs@plt>
mov    %eax,%ecx
movslq %eax,%rsi
mov    %r15,%rax
or     %rsi,%rax
shr    $0x20,%rax
je     1494 <imcomp_merge_overlap+0x374>
mov    %r15,%rax
cqto
idiv   %rsi
mov    %rax,%rcx
jmp    149d <imcomp_merge_overlap+0x37d>
mov    %r15d,%eax
xor    %edx,%edx
div    %ecx
mov    %eax,%ecx
mov    %rcx,0x200(%rsp,%r14,8)
mov    (%r12,%r14,8),%rax
mov    0x0(%rbp,%r14,8),%rbx
mov    %rax,%rbp
sub    %rbx,%rbp
mov    $0x0,%ecx
cmovs  %rcx,%rbp
add    %rbp,%rbx
sub    %rax,%rbx
mov    (%rsp),%rdi
call   1030 <labs@plt>
mov    %eax,%ecx
movslq %eax,%rsi
mov    %rbx,%rax
or     %rsi,%rax
shr    $0x20,%rax
je     14e7 <imcomp_merge_overlap+0x3c7>
mov    %rbx,%rax
cqto
idiv   %rsi
jmp    14ed <imcomp_merge_overlap+0x3cd>
mov    %ebx,%eax
xor    %edx,%edx
div    %ecx
mov    0x10(%rsp),%r15
test   %rdx,%rdx
je     1550 <imcomp_merge_overlap+0x430>
add    $0x1,%rbp
jmp    1511 <imcomp_merge_overlap+0x3f1>
nopl   (%rax)
mov    %rbx,%rax
cqto
idiv   %rsi
add    $0x1,%rbp
test   %rdx,%rdx
je     154c <imcomp_merge_overlap+0x42c>
cmp    %r15,%rbp
jge    1c6b <imcomp_merge_overlap+0xb4b>
mov    0x18(%rsp),%rax
mov    (%rax,%r14,8),%rbx
sub    (%r12,%r14,8),%rbx
add    %rbp,%rbx
mov    (%rsp),%rdi
call   1030 <labs@plt>
mov    %eax,%ecx
movslq %eax,%rsi
mov    %rbx,%rax
or     %rsi,%rax
shr    $0x20,%rax
jne    1500 <imcomp_merge_overlap+0x3e0>
mov    %ebx,%eax
xor    %edx,%edx
div    %ecx
jmp    1508 <imcomp_merge_overlap+0x3e8>
add    $0xffffffffffffffff,%rbp
mov    0x28(%rsp),%esi
mov    0x2e0(%rsp),%rcx
mov    %rbp,0x170(%rsp,%r14,8)
test   %r14,%r14
je     1587 <imcomp_merge_overlap+0x467>
mov    $0xffffffff,%eax
add    %r14d,%eax
mov    0x40(%rsp),%rdx
imul   0x1d0(%rsp,%rax,8),%rdx
mov    %rdx,0x1d0(%rsp,%r14,8)
add    $0x1,%r14
cmp    0x68(%rsp),%r14
mov    0x18(%rsp),%r15
mov    %r12,%rbp
mov    0x8(%rsp),%r12
jne    1225 <imcomp_merge_overlap+0x105>
mov    0x220(%rsp),%rdi
mov    0x250(%rsp),%rax
cmp    %rax,%rdi
mov    0x3c(%rsp),%r14d
jge    1c8e <imcomp_merge_overlap+0xb6e>
mov    0x2f0(%rsp),%rax
mov    (%rax),%eax
add    $0x298,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
movl   $0x1,0x8(%rsp)
xor    %eax,%eax
mov    %rax,(%rsp)
mov    %esi,0x38(%rsp)
xor    %r13d,%r13d
xor    %edi,%edi
xor    %eax,%eax
mov    0x1e8(%rsp),%rcx
mov    %rcx,0x48(%rsp)
mov    0x218(%rsp),%rcx
mov    %rcx,0x70(%rsp)
mov    0x248(%rsp),%rdx
mov    0x1e0(%rsp),%r11
mov    0x208(%rsp),%rcx
mov    0x210(%rsp),%rbx
mov    %rbx,0x78(%rsp)
mov    0x238(%rsp),%r10
mov    0x240(%rsp),%rbx
mov    0x1d0(%rsp),%r9
mov    0x1d8(%rsp),%r8
movslq %esi,%rsi
movslq 0x8(%rsp),%r12
mov    %r12,0x30(%rsp)
mov    %rcx,0x130(%rsp)
sub    %r10,%rcx
add    $0x1,%rcx
mov    %rcx,0x158(%rsp)
sub    %rax,%rdi
mov    0x48(%rsp),%r12
imul   %r12,%rax
add    %r13,%rax
mov    %rdx,%rcx
imul   %r11,%rcx
add    %rax,%rcx
mov    %rbx,%rax
imul   %r8,%rax
add    %rcx,%rax
mov    %r10,0x128(%rsp)
imul   %r9,%r10
add    %rax,%r10
mov    0x78(%rsp),%rax
mov    %rbx,0xe8(%rsp)
sub    %rbx,%rax
add    $0x1,%rax
mov    %rax,0x118(%rsp)
mov    0x70(%rsp),%rax
mov    %rdx,0xb8(%rsp)
sub    %rdx,%rax
add    $0x1,%rax
mov    %rax,0xe0(%rsp)
add    $0x1,%rdi
imul   %rsi,%r10
add    0x2d0(%rsp),%r10
mov    %r10,0x50(%rsp)
mov    %r12,%rax
imul   %rsi,%rax
mov    %rax,0x48(%rsp)
imul   %rsi,%r11
mov    %r11,0xf0(%rsp)
imul   %rsi,%r8
mov    %r8,0x120(%rsp)
imul   %rsi,%r9
mov    %r9,0x168(%rsp)
mov    0x30(%rsp),%rax
mov    %rsi,0x160(%rsp)
imul   %rsi,%rax
mov    %rax,0x150(%rsp)
mov    0x190(%rsp),%rax
mov    %rax,0x80(%rsp)
mov    0x1b8(%rsp),%rax
mov    %rax,0xb0(%rsp)
mov    0x188(%rsp),%rax
mov    %rax,0x90(%rsp)
mov    0x1b0(%rsp),%rax
mov    %rax,0xd0(%rsp)
mov    0x180(%rsp),%rax
mov    %rax,0x28(%rsp)
mov    0x1a0(%rsp),%rax
mov    %rax,0x140(%rsp)
mov    0x1a8(%rsp),%rax
mov    %rax,0x108(%rsp)
mov    0x170(%rsp),%rax
mov    %rax,0x100(%rsp)
mov    0x178(%rsp),%rax
mov    %rax,0x8(%rsp)
xor    %ecx,%ecx
xor    %esi,%esi
mov    %rdi,0xc0(%rsp)
mov    %r13,0xa0(%rsp)
jmp    1825 <imcomp_merge_overlap+0x705>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0xc8(%rsp),%rcx
add    $0x1,%rcx
mov    0x20(%rsp),%rsi
add    $0x1,%rsi
mov    0x50(%rsp),%rax
add    0x48(%rsp),%rax
mov    %rax,0x50(%rsp)
mov    0xc0(%rsp),%rdi
cmp    %rdi,%rcx
je     15c1 <imcomp_merge_overlap+0x4a1>
mov    %rcx,0xc8(%rsp)
cmp    $0x5,%r14d
jge    1856 <imcomp_merge_overlap+0x736>
jmp    18a4 <imcomp_merge_overlap+0x784>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rbx,%rax
cqto
idiv   %rsi
mov    0x20(%rsp),%rsi
add    $0x1,%rsi
test   %rdx,%rdx
je     18a0 <imcomp_merge_overlap+0x780>
mov    0x20(%r15),%rbx
sub    0x20(%rbp),%rbx
mov    0x80(%rsp),%rax
mov    %rsi,0x20(%rsp)
add    %rsi,%rax
add    %rax,%rbx
mov    $0x1,%edi
call   1030 <labs@plt>
mov    %eax,%ecx
movslq %eax,%rsi
mov    %rbx,%rax
or     %rsi,%rax
shr    $0x20,%rax
jne    1840 <imcomp_merge_overlap+0x720>
mov    %ebx,%eax
xor    %edx,%edx
div    %ecx
jmp    1848 <imcomp_merge_overlap+0x728>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0xffffffffffffffff,%rsi
mov    %rsi,0x20(%rsp)
mov    0xb8(%rsp),%rax
cmp    %rax,0x70(%rsp)
jl     17f0 <imcomp_merge_overlap+0x6d0>
mov    0x80(%rsp),%rax
mov    0x20(%rsp),%rcx
add    %rcx,%rax
imul   0xb0(%rsp),%rax
mov    %rax,0xd8(%rsp)
mov    0x50(%rsp),%rax
mov    %rax,0x58(%rsp)
xor    %ecx,%ecx
xor    %esi,%esi
jmp    1928 <imcomp_merge_overlap+0x808>
nopl   (%rax)
mov    0xf8(%rsp),%rcx
add    $0x1,%rcx
mov    0x88(%rsp),%rsi
add    $0x1,%rsi
mov    0x58(%rsp),%rax
add    0xf0(%rsp),%rax
mov    %rax,0x58(%rsp)
cmp    0xe0(%rsp),%rcx
je     17f0 <imcomp_merge_overlap+0x6d0>
mov    %rcx,0xf8(%rsp)
cmp    $0x4,%r14d
jge    1954 <imcomp_merge_overlap+0x834>
jmp    1994 <imcomp_merge_overlap+0x874>
nopl   0x0(%rax,%rax,1)
mov    %rbx,%rax
cqto
idiv   %rsi
mov    %r12,%rsi
add    $0x1,%rsi
test   %rdx,%rdx
je     1990 <imcomp_merge_overlap+0x870>
mov    0x18(%r15),%rbx
sub    0x18(%rbp),%rbx
mov    0x90(%rsp),%rax
mov    %rsi,%r12
add    %rsi,%rax
add    %rax,%rbx
mov    $0x1,%edi
call   1030 <labs@plt>
mov    %eax,%ecx
movslq %eax,%rsi
mov    %rbx,%rax
or     %rsi,%rax
shr    $0x20,%rax
jne    1940 <imcomp_merge_overlap+0x820>
mov    %ebx,%eax
xor    %edx,%edx
div    %ecx
jmp    1948 <imcomp_merge_overlap+0x828>
add    $0xffffffffffffffff,%rsi
mov    %rsi,0x88(%rsp)
mov    0xe8(%rsp),%rax
cmp    %rax,0x78(%rsp)
jl     18f0 <imcomp_merge_overlap+0x7d0>
mov    0x90(%rsp),%rax
mov    0x88(%rsp),%rcx
add    %rcx,%rax
imul   0xd0(%rsp),%rax
add    0xd8(%rsp),%rax
mov    %rax,0x110(%rsp)
mov    0x58(%rsp),%rax
mov    %rax,0x60(%rsp)
xor    %ecx,%ecx
xor    %esi,%esi
jmp    1a28 <imcomp_merge_overlap+0x908>
nopl   0x0(%rax,%rax,1)
mov    0x138(%rsp),%rcx
add    $0x1,%rcx
mov    0x98(%rsp),%rsi
add    $0x1,%rsi
mov    0x60(%rsp),%rax
add    0x120(%rsp),%rax
mov    %rax,0x60(%rsp)
cmp    0x118(%rsp),%rcx
je     18f0 <imcomp_merge_overlap+0x7d0>
mov    %rcx,0x138(%rsp)
cmp    $0x3,%r14d
jge    1a54 <imcomp_merge_overlap+0x934>
jmp    1a94 <imcomp_merge_overlap+0x974>
nopl   0x0(%rax,%rax,1)
mov    %rbx,%rax
cqto
idiv   %rsi
mov    %r12,%rsi
add    $0x1,%rsi
test   %rdx,%rdx
je     1a90 <imcomp_merge_overlap+0x970>
mov    0x10(%r15),%rbx
sub    0x10(%rbp),%rbx
mov    0x28(%rsp),%rax
mov    %rsi,%r12
add    %rsi,%rax
add    %rax,%rbx
mov    $0x1,%edi
call   1030 <labs@plt>
mov    %eax,%ecx
movslq %eax,%rsi
mov    %rbx,%rax
or     %rsi,%rax
shr    $0x20,%rax
jne    1a40 <imcomp_merge_overlap+0x920>
mov    %ebx,%eax
xor    %edx,%edx
div    %ecx
jmp    1a48 <imcomp_merge_overlap+0x928>
nopl   (%rax)
add    $0xffffffffffffffff,%rsi
mov    %rsi,0x98(%rsp)
mov    0x128(%rsp),%rax
cmp    %rax,0x130(%rsp)
jl     19f0 <imcomp_merge_overlap+0x8d0>
mov    0x28(%rsp),%rax
mov    0x98(%rsp),%rcx
add    %rcx,%rax
imul   0x108(%rsp),%rax
add    0x110(%rsp),%rax
add    0x100(%rsp),%rax
mov    %rax,0x148(%rsp)
mov    0x60(%rsp),%rax
mov    %rax,0x10(%rsp)
xor    %ecx,%ecx
xor    %r12d,%r12d
jmp    1b4c <imcomp_merge_overlap+0xa2c>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x68(%rsp),%rcx
add    $0x1,%rcx
mov    0x40(%rsp),%r12
add    $0x1,%r12
mov    0x10(%rsp),%rax
add    0x168(%rsp),%rax
mov    %rax,0x10(%rsp)
cmp    0x158(%rsp),%rcx
mov    0x18(%rsp),%r15
mov    0x3c(%rsp),%r14d
mov    0x2d8(%rsp),%rbp
mov    0xa0(%rsp),%r13
je     19f0 <imcomp_merge_overlap+0x8d0>
mov    %rcx,0x68(%rsp)
cmp    $0x2,%r14d
mov    (%rsp),%r14
jge    1b71 <imcomp_merge_overlap+0xa51>
jmp    1bb4 <imcomp_merge_overlap+0xa94>
nopl   (%rax)
mov    %rbx,%rax
cqto
idiv   %rsi
add    $0x1,%r12
test   %rdx,%rdx
je     1bb0 <imcomp_merge_overlap+0xa90>
mov    0x8(%r15),%rbx
sub    0x8(%rbp),%rbx
mov    0x8(%rsp),%rax
add    %r12,%rax
add    %rax,%rbx
mov    $0x1,%edi
call   1030 <labs@plt>
mov    %eax,%ecx
movslq %eax,%rsi
mov    %rbx,%rax
or     %rsi,%rax
shr    $0x20,%rax
jne    1b60 <imcomp_merge_overlap+0xa40>
mov    %ebx,%eax
xor    %edx,%edx
div    %ecx
jmp    1b68 <imcomp_merge_overlap+0xa48>
nopw   0x0(%rax,%rax,1)
add    $0xffffffffffffffff,%r12
mov    %r12,0x40(%rsp)
cmp    %r13,%r14
mov    0xa8(%rsp),%rcx
mov    0x38(%rsp),%r15d
mov    0x160(%rsp),%r13
mov    0x150(%rsp),%r12
jl     1b00 <imcomp_merge_overlap+0x9e0>
mov    %r14,%r10
mov    0x8(%rsp),%rax
mov    0x40(%rsp),%rsi
lea    (%rax,%rsi,1),%rbp
imul   0x140(%rsp),%rbp
add    0x148(%rsp),%rbp
mov    0x10(%rsp),%rbx
mov    0xa0(%rsp),%r14
mov    %r10,(%rsp)
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rbp,%rdi
imul   %r13,%rdi
add    %rcx,%rdi
mov    %rbx,%rsi
mov    %r15d,%edx
call   1040 <memcpy@plt>
mov    $0x1,%edi
call   1030 <labs@plt>
mov    0x30(%rsp),%rdi
mov    (%rsp),%r10
mov    %edi,%ecx
imul   %eax,%ecx
movslq %ecx,%rax
mov    0xa8(%rsp),%rcx
add    %rax,%rbp
add    %rdi,%r14
add    %r12,%rbx
cmp    %r10,%r14
jle    1c20 <imcomp_merge_overlap+0xb00>
jmp    1b00 <imcomp_merge_overlap+0x9e0>
mov    %rbp,0x170(%rsp,%r14,8)
mov    0x0(%r13),%eax
jmp    15cb <imcomp_merge_overlap+0x4ab>
movl   $0x143,0x0(%r13)
mov    $0x143,%eax
jmp    15cb <imcomp_merge_overlap+0x4ab>
mov    0x200(%rsp),%rdx
mov    0x230(%rsp),%r13
mov    %rdx,%rcx
mov    %rdx,(%rsp)
sub    %r13d,%ecx
add    $0x1,%ecx
mov    %ecx,0x8(%rsp)
imul   %esi,%ecx
mov    %ecx,0x38(%rsp)
jmp    15f6 <imcomp_merge_overlap+0x4d6>

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

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