#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ assert(int);
int compress_duplicates(int *__restrict i, int *__restrict j,
                        int *__restrict oi, int *__restrict oj,
                        int *__restrict tmp, int n, int nt) {
  int k, vmax, c, t, ik, jk;
  vmax = i[0];
  for (k = 0; k < n; k++) {
    if (i[k] > vmax)
      vmax = i[k];
    if (j[k] > vmax)
      vmax = j[k];
  }
  assert(vmax < nt);
  for (k = 0; k <= vmax; k++) {
    tmp[k] = 0;
  }
  for (k = 0; k < n; k++) {
    tmp[j[k]] = tmp[j[k]] + 1;
  }
  c = 0;
  for (k = 0; k <= vmax; k++) {
    t = tmp[k];
    tmp[k] = c;
    c = c + t;
  }
  for (k = 0; k < n; k++) {
    oi[tmp[j[k]]] = i[k];
    oj[tmp[j[k]]] = j[k];
    tmp[j[k]]++;
  }
  for (k = 0; k <= vmax; k++) {
    tmp[k] = 0;
  }
  for (k = 0; k < n; k++) {
    tmp[i[k]]++;
  }
  c = 0;
  for (k = 0; k <= vmax; k++) {
    t = tmp[k];
    tmp[k] = c;
    c = c + t;
  }
  for (k = 0; k < n; k++) {
    j[tmp[oi[k]]] = oj[k];
    i[tmp[oi[k]]] = oi[k];
    tmp[oi[k]]++;
  }
  ik = i[0];
  jk = j[0];
  t = 1;
  c = 0;
  for (k = 1; k < n; k++) {
    if ((ik == i[k]) && (jk == j[k])) {
      t++;
    } else {
      i[c] = ik;
      j[c] = jk;
      oi[c] = t;
      c++;
      t = 1;
      ik = i[k];
      jk = j[k];
    }
  }
  i[c] = ik;
  j[c] = jk;
  oi[c] = t;
  c++;
  return c;
}


x86 assembly (clang, -O0):
<compress_duplicates>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9d,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x34(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    11a6 <compress_duplicates+0x96>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x34(%rbp),%eax
jle    1171 <compress_duplicates+0x61>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x34(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x34(%rbp),%eax
jle    1193 <compress_duplicates+0x83>
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x34(%rbp)
jmp    1198 <compress_duplicates+0x88>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1143 <compress_duplicates+0x33>
mov    -0x34(%rbp),%eax
cmp    0x10(%rbp),%eax
setl   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x34(%rbp),%eax
jg     11e9 <compress_duplicates+0xd9>
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11c0 <compress_duplicates+0xb0>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1233 <compress_duplicates+0x123>
mov    -0x28(%rbp),%rax
mov    -0x10(%rbp),%rcx
movslq -0x30(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    -0x28(%rbp),%rax
mov    -0x10(%rbp),%rcx
movslq -0x30(%rbp),%rsi
movslq (%rcx,%rsi,4),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11f0 <compress_duplicates+0xe0>
movl   $0x0,-0x38(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x34(%rbp),%eax
jg     1280 <compress_duplicates+0x170>
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x38(%rbp),%edx
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    -0x3c(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1241 <compress_duplicates+0x131>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1306 <compress_duplicates+0x1f6>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x10(%rbp),%rsi
movslq -0x30(%rbp),%rdi
movslq (%rsi,%rdi,4),%rsi
movslq (%rcx,%rsi,4),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x10(%rbp),%rsi
movslq -0x30(%rbp),%rdi
movslq (%rsi,%rdi,4),%rsi
movslq (%rcx,%rsi,4),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
mov    -0x10(%rbp),%rcx
movslq -0x30(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1287 <compress_duplicates+0x177>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x34(%rbp),%eax
jg     1336 <compress_duplicates+0x226>
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    130d <compress_duplicates+0x1fd>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1370 <compress_duplicates+0x260>
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%rcx
movslq -0x30(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    133d <compress_duplicates+0x22d>
movl   $0x0,-0x38(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x34(%rbp),%eax
jg     13bd <compress_duplicates+0x2ad>
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x38(%rbp),%edx
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    -0x3c(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    137e <compress_duplicates+0x26e>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1443 <compress_duplicates+0x333>
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x18(%rbp),%rsi
movslq -0x30(%rbp),%rdi
movslq (%rsi,%rdi,4),%rsi
movslq (%rcx,%rsi,4),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x18(%rbp),%rsi
movslq -0x30(%rbp),%rdi
movslq (%rsi,%rdi,4),%rsi
movslq (%rcx,%rsi,4),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rcx
movslq -0x30(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    13c4 <compress_duplicates+0x2b4>
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x40(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x44(%rbp)
movl   $0x1,-0x3c(%rbp)
movl   $0x0,-0x38(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1515 <compress_duplicates+0x405>
mov    -0x40(%rbp),%eax
mov    -0x8(%rbp),%rcx
movslq -0x30(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jne    14ac <compress_duplicates+0x39c>
mov    -0x44(%rbp),%eax
mov    -0x10(%rbp),%rcx
movslq -0x30(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jne    14ac <compress_duplicates+0x39c>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1502 <compress_duplicates+0x3f2>
mov    -0x40(%rbp),%edx
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x44(%rbp),%edx
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x3c(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
movl   $0x1,-0x3c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x44(%rbp)
jmp    1507 <compress_duplicates+0x3f7>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    146a <compress_duplicates+0x35a>
mov    -0x40(%rbp),%edx
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x44(%rbp),%edx
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x3c(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<compress_duplicates>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %r8,%rbp
mov    %rcx,%r13
mov    %rdx,%r14
mov    %rsi,%rbx
mov    %rdi,%r15
mov    0x50(%rsp),%r8d
mov    (%rdi),%ecx
mov    %r9d,%r10d
mov    %ecx,%r12d
test   %r9d,%r9d
jle    118d <compress_duplicates+0x6d>
mov    (%rbx),%r12d
cmp    %ecx,%r12d
cmovle %ecx,%r12d
cmp    $0x1,%r9d
je     118d <compress_duplicates+0x6d>
lea    -0x1(%r10),%r11
cmp    $0x2,%r9d
jne    15fb <compress_duplicates+0x4db>
mov    $0x1,%edx
test   $0x1,%r11b
je     118d <compress_duplicates+0x6d>
mov    (%r15,%rdx,4),%eax
cmp    %r12d,%eax
cmovg  %eax,%r12d
mov    (%rbx,%rdx,4),%eax
cmp    %r12d,%eax
cmovg  %eax,%r12d
mov    %r9d,(%rsp)
mov    %ecx,0x4(%rsp)
mov    %r10,0x10(%rsp)
xor    %edi,%edi
cmp    %r8d,%r12d
setl   %dil
call   1040 <assert@plt>
mov    %r12d,%r8d
test   %r12d,%r12d
mov    %r8,0x8(%rsp)
js     11cc <compress_duplicates+0xac>
lea    0x4(,%r8,4),%rdx
mov    %rbp,%rdi
xor    %esi,%esi
call   1030 <memset@plt>
mov    0x8(%rsp),%r8
mov    (%rsp),%r11d
test   %r11d,%r11d
mov    0x10(%rsp),%r9
mov    0x4(%rsp),%r10d
jle    1252 <compress_duplicates+0x132>
lea    -0x1(%r9),%rcx
mov    %r9d,%eax
and    $0x3,%eax
cmp    $0x3,%rcx
jae    11f3 <compress_duplicates+0xd3>
xor    %ecx,%ecx
jmp    1230 <compress_duplicates+0x110>
mov    %r9d,%edx
and    $0xfffffffc,%edx
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movslq (%rbx,%rcx,4),%rsi
addl   $0x1,0x0(%rbp,%rsi,4)
movslq 0x4(%rbx,%rcx,4),%rsi
addl   $0x1,0x0(%rbp,%rsi,4)
movslq 0x8(%rbx,%rcx,4),%rsi
addl   $0x1,0x0(%rbp,%rsi,4)
movslq 0xc(%rbx,%rcx,4),%rsi
addl   $0x1,0x0(%rbp,%rsi,4)
add    $0x4,%rcx
cmp    %rcx,%rdx
jne    1200 <compress_duplicates+0xe0>
test   %rax,%rax
je     1252 <compress_duplicates+0x132>
lea    (%rbx,%rcx,4),%rcx
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movslq (%rcx,%rdx,4),%rsi
addl   $0x1,0x0(%rbp,%rsi,4)
add    $0x1,%rdx
cmp    %rdx,%rax
jne    1240 <compress_duplicates+0x120>
test   %r12d,%r12d
js     12e3 <compress_duplicates+0x1c3>
lea    0x1(%r8),%rcx
mov    %ecx,%eax
and    $0x3,%eax
cmp    $0x3,%r12d
jae    1270 <compress_duplicates+0x150>
xor    %edx,%edx
xor    %esi,%esi
jmp    12b1 <compress_duplicates+0x191>
and    $0xfffffffc,%ecx
xor    %edx,%edx
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
mov    0x0(%rbp,%rdx,4),%edi
add    %esi,%edi
mov    %esi,0x0(%rbp,%rdx,4)
mov    0x4(%rbp,%rdx,4),%esi
add    %edi,%esi
mov    %edi,0x4(%rbp,%rdx,4)
mov    0x8(%rbp,%rdx,4),%edi
add    %esi,%edi
mov    %esi,0x8(%rbp,%rdx,4)
mov    0xc(%rbp,%rdx,4),%esi
add    %edi,%esi
mov    %edi,0xc(%rbp,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%rcx
jne    1280 <compress_duplicates+0x160>
test   %rax,%rax
je     12e3 <compress_duplicates+0x1c3>
lea    0x0(,%rdx,4),%rcx
add    %rbp,%rcx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%rcx,%rdx,4),%edi
add    %esi,%edi
mov    %esi,(%rcx,%rdx,4)
add    $0x1,%rdx
mov    %edi,%esi
cmp    %rdx,%rax
jne    12d0 <compress_duplicates+0x1b0>
test   %r11d,%r11d
jle    13a6 <compress_duplicates+0x286>
movslq (%rbx),%rax
movslq 0x0(%rbp,%rax,4),%rcx
mov    %r10d,(%r14,%rcx,4)
mov    %eax,0x0(%r13,%rcx,4)
add    $0x1,%ecx
mov    %ecx,0x0(%rbp,%rax,4)
cmp    $0x1,%r11d
je     13a6 <compress_duplicates+0x286>
lea    -0x1(%r9),%r8
mov    $0x1,%ecx
cmp    $0x2,%r11d
je     137e <compress_duplicates+0x25e>
mov    %r8,%rdx
and    $0xfffffffffffffffe,%rdx
neg    %rdx
mov    $0x1,%ecx
nopl   0x0(%rax)
mov    (%r15,%rcx,4),%esi
movslq (%rbx,%rcx,4),%rdi
movslq 0x0(%rbp,%rdi,4),%rax
mov    %esi,(%r14,%rax,4)
mov    %edi,0x0(%r13,%rax,4)
add    $0x1,%eax
mov    %eax,0x0(%rbp,%rdi,4)
mov    0x4(%r15,%rcx,4),%eax
movslq 0x4(%rbx,%rcx,4),%rsi
movslq 0x0(%rbp,%rsi,4),%rdi
mov    %eax,(%r14,%rdi,4)
mov    %esi,0x0(%r13,%rdi,4)
lea    0x1(%rdi),%eax
mov    %eax,0x0(%rbp,%rsi,4)
lea    (%rdx,%rcx,1),%rax
add    $0x2,%rax
add    $0x2,%rcx
cmp    $0x1,%rax
jne    1330 <compress_duplicates+0x210>
test   $0x1,%r8b
mov    0x8(%rsp),%r8
je     13a6 <compress_duplicates+0x286>
mov    (%r15,%rcx,4),%eax
movslq (%rbx,%rcx,4),%rcx
movslq 0x0(%rbp,%rcx,4),%rdx
mov    %eax,(%r14,%rdx,4)
mov    %ecx,0x0(%r13,%rdx,4)
lea    0x1(%rdx),%eax
mov    %eax,0x0(%rbp,%rcx,4)
test   %r12d,%r12d
js     13d0 <compress_duplicates+0x2b0>
lea    0x4(,%r8,4),%rdx
mov    %rbp,%rdi
xor    %esi,%esi
call   1030 <memset@plt>
mov    0x8(%rsp),%r8
mov    (%rsp),%r11d
mov    0x4(%rsp),%r10d
mov    0x10(%rsp),%r9
test   %r11d,%r11d
jle    1462 <compress_duplicates+0x342>
movslq %r10d,%rax
addl   $0x1,0x0(%rbp,%rax,4)
cmp    $0x1,%r11d
je     1462 <compress_duplicates+0x342>
lea    -0x1(%r9),%rdx
lea    -0x2(%r9),%rsi
mov    %edx,%eax
and    $0x3,%eax
mov    $0x1,%ecx
cmp    $0x3,%rsi
jb     1445 <compress_duplicates+0x325>
and    $0xfffffffffffffffc,%rdx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
movslq 0x4(%r15,%rcx,4),%rsi
addl   $0x1,0x0(%rbp,%rsi,4)
movslq 0x8(%r15,%rcx,4),%rsi
addl   $0x1,0x0(%rbp,%rsi,4)
movslq 0xc(%r15,%rcx,4),%rsi
addl   $0x1,0x0(%rbp,%rsi,4)
movslq 0x10(%r15,%rcx,4),%rsi
addl   $0x1,0x0(%rbp,%rsi,4)
add    $0x4,%rcx
cmp    %rcx,%rdx
jne    1410 <compress_duplicates+0x2f0>
add    $0x1,%rcx
test   %rax,%rax
je     1462 <compress_duplicates+0x342>
lea    (%r15,%rcx,4),%rcx
xor    %edx,%edx
movslq (%rcx,%rdx,4),%rsi
addl   $0x1,0x0(%rbp,%rsi,4)
add    $0x1,%rdx
cmp    %rdx,%rax
jne    1450 <compress_duplicates+0x330>
test   %r12d,%r12d
js     14f3 <compress_duplicates+0x3d3>
add    $0x1,%r8
mov    %r8d,%eax
and    $0x3,%eax
cmp    $0x3,%r12d
jae    1481 <compress_duplicates+0x361>
xor    %ecx,%ecx
xor    %edx,%edx
jmp    14c1 <compress_duplicates+0x3a1>
and    $0xfffffffc,%r8d
xor    %ecx,%ecx
xor    %edx,%edx
nopl   0x0(%rax)
mov    0x0(%rbp,%rcx,4),%esi
add    %edx,%esi
mov    %edx,0x0(%rbp,%rcx,4)
mov    0x4(%rbp,%rcx,4),%edx
add    %esi,%edx
mov    %esi,0x4(%rbp,%rcx,4)
mov    0x8(%rbp,%rcx,4),%esi
add    %edx,%esi
mov    %edx,0x8(%rbp,%rcx,4)
mov    0xc(%rbp,%rcx,4),%edx
add    %esi,%edx
mov    %esi,0xc(%rbp,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r8
jne    1490 <compress_duplicates+0x370>
test   %rax,%rax
je     14f3 <compress_duplicates+0x3d3>
lea    0x0(,%rcx,4),%rcx
add    %rbp,%rcx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%rcx,%rsi,4),%edi
add    %edx,%edi
mov    %edx,(%rcx,%rsi,4)
add    $0x1,%rsi
mov    %edi,%edx
cmp    %rsi,%rax
jne    14e0 <compress_duplicates+0x3c0>
test   %r11d,%r11d
jle    1502 <compress_duplicates+0x3e2>
cmp    $0x1,%r11d
jne    1509 <compress_duplicates+0x3e9>
xor    %eax,%eax
jmp    1562 <compress_duplicates+0x442>
mov    (%rbx),%ecx
jmp    15d5 <compress_duplicates+0x4b5>
mov    %r9d,%ecx
and    $0xfffffffe,%ecx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x0(%r13,%rax,4),%edx
movslq (%r14,%rax,4),%rsi
movslq 0x0(%rbp,%rsi,4),%rdi
mov    %edx,(%rbx,%rdi,4)
mov    %esi,(%r15,%rdi,4)
lea    0x1(%rdi),%edx
mov    %edx,0x0(%rbp,%rsi,4)
mov    0x4(%r13,%rax,4),%edx
movslq 0x4(%r14,%rax,4),%rsi
movslq 0x0(%rbp,%rsi,4),%rdi
mov    %edx,(%rbx,%rdi,4)
mov    %esi,(%r15,%rdi,4)
lea    0x1(%rdi),%edx
mov    %edx,0x0(%rbp,%rsi,4)
add    $0x2,%rax
cmp    %rax,%rcx
jne    1520 <compress_duplicates+0x400>
test   $0x1,%r9b
je     1584 <compress_duplicates+0x464>
mov    0x0(%r13,%rax,4),%ecx
movslq (%r14,%rax,4),%rax
movslq 0x0(%rbp,%rax,4),%rdx
mov    %ecx,(%rbx,%rdx,4)
mov    %eax,(%r15,%rdx,4)
lea    0x1(%rdx),%ecx
mov    %ecx,0x0(%rbp,%rax,4)
mov    (%r15),%r10d
mov    (%rbx),%ecx
cmp    $0x2,%r11d
jl     15d5 <compress_duplicates+0x4b5>
xor    %eax,%eax
mov    $0x1,%edx
mov    $0x1,%esi
jmp    15c5 <compress_duplicates+0x4a5>
nopl   (%rax)
cltq
mov    %r10d,(%r15,%rax,4)
mov    %ecx,(%rbx,%rax,4)
mov    %edx,(%r14,%rax,4)
add    $0x1,%eax
mov    (%r15,%rsi,4),%r10d
mov    (%rbx,%rsi,4),%ecx
mov    $0x1,%edx
add    $0x1,%rsi
cmp    %rsi,%r9
je     15dc <compress_duplicates+0x4bc>
cmp    (%r15,%rsi,4),%r10d
jne    15a0 <compress_duplicates+0x480>
cmp    (%rbx,%rsi,4),%ecx
jne    15a0 <compress_duplicates+0x480>
add    $0x1,%edx
jmp    15bc <compress_duplicates+0x49c>
mov    $0x1,%edx
xor    %eax,%eax
cltq
mov    %r10d,(%r15,%rax,4)
mov    %ecx,(%rbx,%rax,4)
mov    %edx,(%r14,%rax,4)
add    $0x1,%eax
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %r11,%rsi
and    $0xfffffffffffffffe,%rsi
neg    %rsi
mov    $0x1,%edx
jmp    1626 <compress_duplicates+0x506>
nopl   0x0(%rax)
lea    (%rsi,%rdx,1),%rax
add    $0x2,%rax
add    $0x2,%rdx
cmp    $0x1,%rax
je     1172 <compress_duplicates+0x52>
mov    (%r15,%rdx,4),%eax
cmp    %r12d,%eax
cmovg  %eax,%r12d
mov    (%rbx,%rdx,4),%edi
cmp    %r12d,%edi
jg     163c <compress_duplicates+0x51c>
mov    %r12d,%edi
mov    0x4(%r15,%rdx,4),%eax
cmp    %edi,%eax
jg     1647 <compress_duplicates+0x527>
mov    %edi,%eax
mov    0x4(%rbx,%rdx,4),%r12d
cmp    %eax,%r12d
jg     1610 <compress_duplicates+0x4f0>
mov    %eax,%r12d
jmp    1610 <compress_duplicates+0x4f0>

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

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