#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 */
double **new_matrix_double(int, int);
scalar_t__ vectors_are_equal(double *, double *, int);
int remove_duplicates(double **set, int setlen, int vlen, double ***newset) {
  size_t i, j;
  int unique[setlen];
  for (i = 0; i < setlen; i++)
    unique[i] = 1;
  for (i = 0; i < (setlen - 1); i++) {
    for (j = i; j < setlen; j++) {
      if ((i != j) && (unique[i] || unique[j])) {
        if (vectors_are_equal(set[i], set[j], vlen))
          unique[j] = 0;
      }
    }
  }
  int ctr = 0;
  for (i = 0; i < setlen; i++) {
    if (unique[i])
      ctr++;
  }
  (*newset) = new_matrix_double(ctr, vlen);
  ctr = 0;
  for (i = 0; i < setlen; i++) {
    if (unique[i]) {
      for (j = 0; j < vlen; j++)
        (*newset)[ctr][j] = set[i][j];
      ctr++;
    }
  }
  return ctr;
}


x86 assembly (clang, -O0):
<remove_duplicates>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    -0xc(%rbp),%eax
mov    %rsp,%rcx
mov    %rcx,-0x30(%rbp)
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x48(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x38(%rbp)
movq   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%rax
movslq -0xc(%rbp),%rcx
cmp    %rcx,%rax
jae    1196 <remove_duplicates+0x76>
mov    -0x48(%rbp),%rax
mov    -0x20(%rbp),%rcx
movl   $0x1,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    1165 <remove_duplicates+0x45>
movq   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
cmp    %rcx,%rax
jae    1269 <remove_duplicates+0x149>
mov    -0x20(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
movslq -0xc(%rbp),%rcx
cmp    %rcx,%rax
jae    1253 <remove_duplicates+0x133>
mov    -0x20(%rbp),%rax
cmp    -0x28(%rbp),%rax
je     123d <remove_duplicates+0x11d>
mov    -0x48(%rbp),%rax
mov    -0x20(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    11ff <remove_duplicates+0xdf>
mov    -0x48(%rbp),%rax
mov    -0x28(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     123d <remove_duplicates+0x11d>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
mov    -0x10(%rbp),%edx
call   1040 <vectors_are_equal@plt>
cmp    $0x0,%rax
je     1238 <remove_duplicates+0x118>
mov    -0x48(%rbp),%rax
mov    -0x28(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
jmp    123d <remove_duplicates+0x11d>
jmp    1242 <remove_duplicates+0x122>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    11bc <remove_duplicates+0x9c>
jmp    1258 <remove_duplicates+0x138>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    119e <remove_duplicates+0x7e>
movl   $0x0,-0x3c(%rbp)
movq   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%rax
movslq -0xc(%rbp),%rcx
cmp    %rcx,%rax
jae    12ba <remove_duplicates+0x19a>
mov    -0x48(%rbp),%rax
mov    -0x20(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     12a4 <remove_duplicates+0x184>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    12a9 <remove_duplicates+0x189>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    1278 <remove_duplicates+0x158>
mov    -0x3c(%rbp),%edi
mov    -0x10(%rbp),%esi
call   1030 <new_matrix_double@plt>
mov    %rax,%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,(%rax)
movl   $0x0,-0x3c(%rbp)
movq   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%rax
movslq -0xc(%rbp),%rcx
cmp    %rcx,%rax
jae    1377 <remove_duplicates+0x257>
mov    -0x48(%rbp),%rax
mov    -0x20(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     1361 <remove_duplicates+0x241>
movq   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x10(%rbp),%rcx
cmp    %rcx,%rax
jae    1358 <remove_duplicates+0x238>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    1309 <remove_duplicates+0x1e9>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1366 <remove_duplicates+0x246>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    12de <remove_duplicates+0x1be>
mov    -0x3c(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rsp
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<remove_duplicates>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %edx,-0x2c(%rbp)
mov    %rdi,-0x50(%rbp)
mov    %esi,%eax
mov    %rsp,%rdx
lea    0xf(,%rax,4),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%rdx
mov    %rdx,%rsp
movslq %esi,%r15
test   %r15d,%r15d
mov    %rdx,-0x58(%rbp)
mov    %rcx,-0x38(%rbp)
mov    %esi,-0x40(%rbp)
je     117c <remove_duplicates+0x5c>
cmp    $0x2,%r15
mov    $0x1,%eax
cmovae %r15,%rax
cmp    $0x8,%rax
jae    1186 <remove_duplicates+0x66>
xor    %ecx,%ecx
jmp    1276 <remove_duplicates+0x156>
mov    $0xffffffff,%eax
jmp    128d <remove_duplicates+0x16d>
mov    %rax,%rcx
and    $0xfffffffffffffff8,%rcx
lea    -0x8(%rcx),%rdi
mov    %rdi,%rbx
shr    $0x3,%rbx
add    $0x1,%rbx
mov    %ebx,%r8d
and    $0x7,%r8d
cmp    $0x38,%rdi
jae    11b0 <remove_duplicates+0x90>
xor    %edi,%edi
jmp    1245 <remove_duplicates+0x125>
and    $0xfffffffffffffff8,%rbx
xor    %edi,%edi
movdqa 0xe42(%rip),%xmm0
xchg   %ax,%ax
movdqa %xmm0,(%rdx,%rdi,4)
movdqa %xmm0,0x10(%rdx,%rdi,4)
movdqa %xmm0,0x20(%rdx,%rdi,4)
movdqa %xmm0,0x30(%rdx,%rdi,4)
movdqa %xmm0,0x40(%rdx,%rdi,4)
movdqa %xmm0,0x50(%rdx,%rdi,4)
movdqa %xmm0,0x60(%rdx,%rdi,4)
movdqa %xmm0,0x70(%rdx,%rdi,4)
movdqa %xmm0,0x80(%rdx,%rdi,4)
movdqa %xmm0,0x90(%rdx,%rdi,4)
movdqa %xmm0,0xa0(%rdx,%rdi,4)
movdqa %xmm0,0xb0(%rdx,%rdi,4)
movdqa %xmm0,0xc0(%rdx,%rdi,4)
movdqa %xmm0,0xd0(%rdx,%rdi,4)
movdqa %xmm0,0xe0(%rdx,%rdi,4)
movdqa %xmm0,0xf0(%rdx,%rdi,4)
add    $0x40,%rdi
add    $0xfffffffffffffff8,%rbx
jne    11c0 <remove_duplicates+0xa0>
test   %r8,%r8
je     1281 <remove_duplicates+0x161>
lea    (%rdx,%rdi,4),%rbx
add    $0x10,%rbx
shl    $0x5,%r8
xor    %edi,%edi
movdqa 0xda0(%rip),%xmm0
movdqa %xmm0,-0x10(%rbx,%rdi,1)
movdqa %xmm0,(%rbx,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%r8
jne    1260 <remove_duplicates+0x140>
jmp    1281 <remove_duplicates+0x161>
movl   $0x1,(%rdx,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1276 <remove_duplicates+0x156>
mov    %esi,%eax
add    $0xffffffff,%eax
je     130b <remove_duplicates+0x1eb>
cltq
mov    %rax,-0x48(%rbp)
xor    %r12d,%r12d
mov    -0x50(%rbp),%r14
mov    %rdx,%rbx
jmp    12b2 <remove_duplicates+0x192>
nop
add    $0x1,%r12
add    $0x4,%rbx
add    $0x8,%r14
cmp    -0x48(%rbp),%r12
je     130b <remove_duplicates+0x1eb>
cmp    %r15,%r12
jae    12a0 <remove_duplicates+0x180>
xor    %r13d,%r13d
jmp    12d1 <remove_duplicates+0x1b1>
nopl   0x0(%rax)
lea    (%r12,%r13,1),%rax
add    $0x1,%rax
add    $0x1,%r13
cmp    %r15,%rax
jae    12a0 <remove_duplicates+0x180>
test   %r13,%r13
je     12c0 <remove_duplicates+0x1a0>
cmpl   $0x0,(%rdx,%r12,4)
jne    12e4 <remove_duplicates+0x1c4>
cmpl   $0x0,(%rbx,%r13,4)
je     12c0 <remove_duplicates+0x1a0>
mov    -0x50(%rbp),%rax
mov    (%rax,%r12,8),%rdi
mov    (%r14,%r13,8),%rsi
mov    -0x2c(%rbp),%edx
call   1040 <vectors_are_equal@plt>
mov    -0x58(%rbp),%rdx
test   %rax,%rax
je     12c0 <remove_duplicates+0x1a0>
movl   $0x0,(%rbx,%r13,4)
jmp    12c0 <remove_duplicates+0x1a0>
mov    -0x40(%rbp),%r14d
test   %r14d,%r14d
je     1330 <remove_duplicates+0x210>
cmp    $0x2,%r15
mov    $0x1,%eax
cmovae %r15,%rax
cmp    $0x8,%rax
jae    1349 <remove_duplicates+0x229>
xor    %edi,%edi
xor    %ecx,%ecx
jmp    1432 <remove_duplicates+0x312>
xor    %r12d,%r12d
xor    %edi,%edi
mov    -0x2c(%rbp),%esi
call   1030 <new_matrix_double@plt>
mov    -0x38(%rbp),%rcx
mov    %rax,(%rcx)
jmp    166a <remove_duplicates+0x54a>
mov    %rax,%rcx
and    $0xfffffffffffffff8,%rcx
lea    -0x8(%rcx),%rsi
mov    %rsi,%rbx
shr    $0x3,%rbx
add    $0x1,%rbx
test   %rsi,%rsi
je     1421 <remove_duplicates+0x301>
movabs $0x3ffffffffffffff8,%rdi
ff ff 3f
or     $0x6,%rdi
and    %rbx,%rdi
pxor   %xmm2,%xmm2
xor    %esi,%esi
movdqa 0xc89(%rip),%xmm3
pxor   %xmm0,%xmm0
pxor   %xmm1,%xmm1
nop
movdqa (%rdx,%rsi,4),%xmm4
pcmpeqd %xmm2,%xmm4
paddd  %xmm0,%xmm4
movdqa 0x10(%rdx,%rsi,4),%xmm5
pcmpeqd %xmm2,%xmm5
paddd  %xmm1,%xmm5
movdqa 0x20(%rdx,%rsi,4),%xmm0
pcmpeqd %xmm2,%xmm0
movdqa 0x30(%rdx,%rsi,4),%xmm1
pcmpeqd %xmm2,%xmm1
paddd  %xmm3,%xmm0
paddd  %xmm4,%xmm0
paddd  %xmm3,%xmm1
paddd  %xmm5,%xmm1
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1390 <remove_duplicates+0x270>
test   $0x1,%bl
je     1405 <remove_duplicates+0x2e5>
pxor   %xmm2,%xmm2
movdqa (%rdx,%rsi,4),%xmm3
pcmpeqd %xmm2,%xmm3
paddd  %xmm3,%xmm0
pcmpeqd 0x10(%rdx,%rsi,4),%xmm2
paddd  %xmm2,%xmm1
pcmpeqd %xmm2,%xmm2
psubd  %xmm2,%xmm0
psubd  %xmm2,%xmm1
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%edi
jmp    143d <remove_duplicates+0x31d>
pxor   %xmm0,%xmm0
xor    %esi,%esi
pxor   %xmm1,%xmm1
test   $0x1,%bl
jne    13de <remove_duplicates+0x2be>
jmp    1405 <remove_duplicates+0x2e5>
cmpl   $0x1,(%rdx,%rcx,4)
sbb    $0xffffffff,%edi
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1432 <remove_duplicates+0x312>
mov    -0x2c(%rbp),%ebx
mov    %ebx,%esi
call   1030 <new_matrix_double@plt>
mov    -0x38(%rbp),%rcx
mov    %rax,(%rcx)
test   %r14d,%r14d
je     1667 <remove_duplicates+0x547>
cmp    $0x2,%ebx
mov    $0x1,%r8d
cmovae %ebx,%r8d
movslq %r8d,%rdx
cmp    $0x2,%r15
mov    $0x1,%r13d
cmovae %r15,%r13
lea    -0x4(%rdx),%r11
mov    %r11,-0x48(%rbp)
shr    $0x2,%r11
add    $0x1,%r11
mov    %rdx,%rcx
and    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x40(%rbp)
mov    %r11d,%ecx
and    $0x3,%ecx
and    $0xfffffffffffffffc,%r11
mov    %edx,%r14d
and    $0x3,%r14d
mov    %rcx,-0x38(%rbp)
shl    $0x5,%rcx
xor    %r12d,%r12d
xor    %r15d,%r15d
mov    %ebx,%esi
mov    -0x58(%rbp),%rdi
jmp    14d5 <remove_duplicates+0x3b5>
nopl   0x0(%rax)
add    $0x1,%r12d
mov    -0x58(%rbp),%rdi
add    $0x1,%r15
cmp    %r13,%r15
je     166a <remove_duplicates+0x54a>
cmpl   $0x0,(%rdi,%r15,4)
je     14c8 <remove_duplicates+0x3a8>
test   %esi,%esi
je     14c0 <remove_duplicates+0x3a0>
mov    -0x50(%rbp),%rsi
mov    (%rsi,%r15,8),%r10
movslq %r12d,%rsi
mov    (%rax,%rsi,8),%r9
cmp    $0x4,%r8d
jb     150b <remove_duplicates+0x3eb>
lea    (%r10,%rdx,8),%rsi
cmp    %rsi,%r9
jae    1584 <remove_duplicates+0x464>
lea    (%r9,%rdx,8),%rsi
cmp    %rsi,%r10
jae    1584 <remove_duplicates+0x464>
xor    %ebx,%ebx
mov    %rbx,%rdi
not    %rdi
add    %rdx,%rdi
test   %r14,%r14
je     1536 <remove_duplicates+0x416>
mov    %r14,%rsi
xchg   %ax,%ax
movq   (%r10,%rbx,8),%xmm0
movq   %xmm0,(%r9,%rbx,8)
add    $0x1,%rbx
add    $0xffffffffffffffff,%rsi
jne    1520 <remove_duplicates+0x400>
cmp    $0x3,%rdi
mov    -0x2c(%rbp),%esi
jb     14c0 <remove_duplicates+0x3a0>
nop
movsd  (%r10,%rbx,8),%xmm0
movsd  %xmm0,(%r9,%rbx,8)
movsd  0x8(%r10,%rbx,8),%xmm0
movsd  %xmm0,0x8(%r9,%rbx,8)
movsd  0x10(%r10,%rbx,8),%xmm0
movsd  %xmm0,0x10(%r9,%rbx,8)
movq   0x18(%r10,%rbx,8),%xmm0
movq   %xmm0,0x18(%r9,%rbx,8)
add    $0x4,%rbx
cmp    %rbx,%rdx
jne    1540 <remove_duplicates+0x420>
jmp    14c0 <remove_duplicates+0x3a0>
cmpq   $0xc,-0x48(%rbp)
jae    1592 <remove_duplicates+0x472>
xor    %ebx,%ebx
jmp    160c <remove_duplicates+0x4ec>
mov    %r11,%rdi
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movups (%r10,%rbx,8),%xmm0
movups 0x10(%r10,%rbx,8),%xmm1
movups %xmm0,(%r9,%rbx,8)
movups %xmm1,0x10(%r9,%rbx,8)
movups 0x20(%r10,%rbx,8),%xmm0
movups 0x30(%r10,%rbx,8),%xmm1
movups %xmm0,0x20(%r9,%rbx,8)
movups %xmm1,0x30(%r9,%rbx,8)
movups 0x40(%r10,%rbx,8),%xmm0
movups 0x50(%r10,%rbx,8),%xmm1
movups %xmm0,0x40(%r9,%rbx,8)
movups %xmm1,0x50(%r9,%rbx,8)
movdqu 0x60(%r10,%rbx,8),%xmm0
movdqu 0x70(%r10,%rbx,8),%xmm1
movdqu %xmm0,0x60(%r9,%rbx,8)
movdqu %xmm1,0x70(%r9,%rbx,8)
add    $0x10,%rbx
add    $0xfffffffffffffffc,%rdi
jne    15a0 <remove_duplicates+0x480>
cmpq   $0x0,-0x38(%rbp)
je     164f <remove_duplicates+0x52f>
lea    (%r9,%rbx,8),%rdi
add    $0x10,%rdi
lea    (%r10,%rbx,8),%rsi
add    $0x10,%rsi
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
movdqu -0x10(%rsi,%rbx,1),%xmm0
movdqu (%rsi,%rbx,1),%xmm1
movdqu %xmm0,-0x10(%rdi,%rbx,1)
movdqu %xmm1,(%rdi,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%rcx
jne    1630 <remove_duplicates+0x510>
mov    -0x40(%rbp),%rsi
mov    %rsi,%rbx
cmp    %rdx,%rsi
mov    -0x2c(%rbp),%esi
je     14c0 <remove_duplicates+0x3a0>
jmp    150d <remove_duplicates+0x3ed>
xor    %r12d,%r12d
mov    %r12d,%eax
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @remove_duplicates(double** %0, i32 %1, i32 %2, double*** %3) {
%5 = alloca double**
%6 = alloca i32
%7 = alloca i32
%8 = alloca double***
%9 = alloca i64
%10 = alloca i64
%11 = alloca i8*
%12 = alloca i64
%13 = alloca i32
store double** %0, double*** %5
store i32 %1, i32* %6
store i32 %2, i32* %7
store double*** %3, double**** %8
%14 = load i32, i32* %6
%15 = zext i32 %14 to i64
%16 = call i8* @llvm.stacksave()
store i8* %16, i8** %11
%17 = alloca i32, i64 %15
store i64 %15, i64* %12
store i64 0, i64* %9
br label %18
18: ; preds = %26, %4
%19 = load i64, i64* %9
%20 = load i32, i32* %6
%21 = sext i32 %20 to i64
%22 = icmp ult i64 %19, %21
br i1 %22, label %23, label %29
23: ; preds = %18
%24 = load i64, i64* %9
%25 = getelementptr inbounds i32, i32* %17, i64 %24
store i32 1, i32* %25
br label %26
26: ; preds = %23
%27 = load i64, i64* %9
%28 = add i64 %27, 1
store i64 %28, i64* %9
br label %18
29: ; preds = %18
store i64 0, i64* %9
br label %30
30: ; preds = %78, %29
%31 = load i64, i64* %9
%32 = load i32, i32* %6
%33 = sub nsw i32 %32, 1
%34 = sext i32 %33 to i64
%35 = icmp ult i64 %31, %34
br i1 %35, label %36, label %81
36: ; preds = %30
%37 = load i64, i64* %9
store i64 %37, i64* %10
br label %38
38: ; preds = %74, %36
%39 = load i64, i64* %10
%40 = load i32, i32* %6
%41 = sext i32 %40 to i64
%42 = icmp ult i64 %39, %41
br i1 %42, label %43, label %77
43: ; preds = %38
%44 = load i64, i64* %9
%45 = load i64, i64* %10
%46 = icmp ne i64 %44, %45
br i1 %46, label %47, label %73
47: ; preds = %43
%48 = load i64, i64* %9
%49 = getelementptr inbounds i32, i32* %17, i64 %48
%50 = load i32, i32* %49
%51 = icmp ne i32 %50, 0
br i1 %51, label %57, label %52
52: ; preds = %47
%53 = load i64, i64* %10
%54 = getelementptr inbounds i32, i32* %17, i64 %53
%55 = load i32, i32* %54
%56 = icmp ne i32 %55, 0
br i1 %56, label %57, label %73
57: ; preds = %52, %47
%58 = load double**, double*** %5
%59 = load i64, i64* %9
%60 = getelementptr inbounds double*, double** %58, i64 %59
%61 = load double*, double** %60
%62 = load double**, double*** %5
%63 = load i64, i64* %10
%64 = getelementptr inbounds double*, double** %62, i64 %63
%65 = load double*, double** %64
%66 = load i32, i32* %7
%67 = call i64 @vectors_are_equal(double* %61, double* %65, i32 %66)
%68 = icmp ne i64 %67, 0
br i1 %68, label %69, label %72
69: ; preds = %57
%70 = load i64, i64* %10
%71 = getelementptr inbounds i32, i32* %17, i64 %70
store i32 0, i32* %71
br label %72
72: ; preds = %69, %57
br label %73
73: ; preds = %72, %52, %43
br label %74
74: ; preds = %73
%75 = load i64, i64* %10
%76 = add i64 %75, 1
store i64 %76, i64* %10
br label %38
77: ; preds = %38
br label %78
78: ; preds = %77
%79 = load i64, i64* %9
%80 = add i64 %79, 1
store i64 %80, i64* %9
br label %30
81: ; preds = %30
store i32 0, i32* %13
store i64 0, i64* %9
br label %82
82: ; preds = %96, %81
%83 = load i64, i64* %9
%84 = load i32, i32* %6
%85 = sext i32 %84 to i64
%86 = icmp ult i64 %83, %85
br i1 %86, label %87, label %99
87: ; preds = %82
%88 = load i64, i64* %9
%89 = getelementptr inbounds i32, i32* %17, i64 %88
%90 = load i32, i32* %89
%91 = icmp ne i32 %90, 0
br i1 %91, label %92, label %95
92: ; preds = %87
%93 = load i32, i32* %13
%94 = add nsw i32 %93, 1
store i32 %94, i32* %13
br label %95
95: ; preds = %92, %87
br label %96
96: ; preds = %95
%97 = load i64, i64* %9
%98 = add i64 %97, 1
store i64 %98, i64* %9
br label %82
99: ; preds = %82
%100 = load i32, i32* %13
%101 = load i32, i32* %7
%102 = call double** @new_matrix_double(i32 %100, i32 %101)
%103 = load double***, double**** %8
store double** %102, double*** %103
store i32 0, i32* %13
store i64 0, i64* %9
br label %104
104: ; preds = %143, %99
%105 = load i64, i64* %9
%106 = load i32, i32* %6
%107 = sext i32 %106 to i64
%108 = icmp ult i64 %105, %107
br i1 %108, label %109, label %146
109: ; preds = %104
%110 = load i64, i64* %9
%111 = getelementptr inbounds i32, i32* %17, i64 %110
%112 = load i32, i32* %111
%113 = icmp ne i32 %112, 0
br i1 %113, label %114, label %142
114: ; preds = %109
store i64 0, i64* %10
br label %115
115: ; preds = %136, %114
%116 = load i64, i64* %10
%117 = load i32, i32* %7
%118 = sext i32 %117 to i64
%119 = icmp ult i64 %116, %118
br i1 %119, label %120, label %139
120: ; preds = %115
%121 = load double**, double*** %5
%122 = load i64, i64* %9
%123 = getelementptr inbounds double*, double** %121, i64 %122
%124 = load double*, double** %123
%125 = load i64, i64* %10
%126 = getelementptr inbounds double, double* %124, i64 %125
%127 = load double, double* %126
%128 = load double***, double**** %8
%129 = load double**, double*** %128
%130 = load i32, i32* %13
%131 = sext i32 %130 to i64
%132 = getelementptr inbounds double*, double** %129, i64 %131
%133 = load double*, double** %132
%134 = load i64, i64* %10
%135 = getelementptr inbounds double, double* %133, i64 %134
store double %127, double* %135
br label %136
136: ; preds = %120
%137 = load i64, i64* %10
%138 = add i64 %137, 1
store i64 %138, i64* %10
br label %115
139: ; preds = %115
%140 = load i32, i32* %13
%141 = add nsw i32 %140, 1
store i32 %141, i32* %13
br label %142
142: ; preds = %139, %109
br label %143
143: ; preds = %142
%144 = load i64, i64* %9
%145 = add i64 %144, 1
store i64 %145, i64* %9
br label %104
146: ; preds = %104
%147 = load i32, i32* %13
%148 = load i8*, i8** %11
ret i32 %147
}

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