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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
scalar_t__ calloc(int, int);
float distance2(float *, float *, int);
scalar_t__ fmatrix(int, int);
int /*<<< orphan*/ free(int *);
int /*<<< orphan*/ free_fmatrix(float **, int);
int mergecb1(float **, float *, float **, unsigned char *, int, int, float *,
             int, int *, int);
int /*<<< orphan*/ printf(char *, float);
int mergecb(float *B, float **cb, unsigned char *P, int npt, int N,
            float thresh, int dim) {
  int i, j, newN, *count, l, ei, *count2;
  float **dist, **dist2, **cb2;
  if (N == 1)
    return 1;
  count = (int *)calloc(N, sizeof(int));
  for (l = 0; l < npt; l++)
    count[P[l]]++;
  dist = (float **)fmatrix(N, N);
  ei = N - 1;
  for (i = 0; i < ei; i++) {
    for (j = i + 1; j < N; j++) {
      dist[i][j] = distance2(cb[i], cb[j], dim);
      dist[j][i] = dist[i][j];
    }
  }
  if (thresh < 0) {
    cb2 = (float **)fmatrix(N, dim);
    for (i = 0; i < N; i++)
      for (j = 0; j < dim; j++)
        cb2[i][j] = cb[i][j];
    count2 = (int *)calloc(N, sizeof(int));
    for (i = 0; i < N; i++)
      count2[i] = count[i];
    dist2 = (float **)fmatrix(N, N);
    for (i = 0; i < N; i++)
      for (j = 0; j < N; j++)
        dist2[i][j] = dist[i][j];
    if (dim == 3)
      thresh = 400;
    else if (dim == 1)
      thresh = 800;
    mergecb1(dist2, B, cb2, P, npt, N, &thresh, dim, count2, 1);
    free_fmatrix(cb2, N);
    free(count2);
    free_fmatrix(dist2, N);
  }
  printf("thresh %f ", thresh);
  newN = mergecb1(dist, B, cb, P, npt, N, &thresh, dim, count, 0);
  free_fmatrix(dist, N);
  free(count);
  return newN;
}


x86 assembly (clang, -O0):
<mergecb>:
push   %rbp
mov    %rsp,%rbp
push   %rbx
sub    $0x98,%rsp
mov    %rdi,-0x18(%rbp)
mov    %rsi,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    %ecx,-0x2c(%rbp)
mov    %r8d,-0x30(%rbp)
movss  %xmm0,-0x34(%rbp)
mov    %r9d,-0x38(%rbp)
cmpl   $0x1,-0x30(%rbp)
jne    11ae <mergecb+0x3e>
movl   $0x1,-0xc(%rbp)
jmp    1516 <mergecb+0x3a6>
mov    -0x30(%rbp),%edi
mov    $0x4,%esi
call   1080 <calloc@plt>
mov    %rax,-0x50(%rbp)
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    11f9 <mergecb+0x89>
mov    -0x50(%rbp),%rax
mov    -0x28(%rbp),%rcx
movslq -0x54(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    11c6 <mergecb+0x56>
mov    -0x30(%rbp),%edi
mov    -0x30(%rbp),%esi
call   1090 <fmatrix@plt>
mov    %rax,-0x68(%rbp)
mov    -0x30(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x58(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x58(%rbp),%eax
jge    12b9 <mergecb+0x149>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    12a6 <mergecb+0x136>
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x20(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
mov    -0x38(%rbp),%edx
call   1050 <distance2@plt>
mov    -0x68(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    122d <mergecb+0xbd>
jmp    12ab <mergecb+0x13b>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1218 <mergecb+0xa8>
xorps  %xmm0,%xmm0
ucomiss -0x34(%rbp),%xmm0
jbe    14a6 <mergecb+0x336>
mov    -0x30(%rbp),%edi
mov    -0x38(%rbp),%esi
call   1090 <fmatrix@plt>
mov    %rax,-0x78(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1346 <mergecb+0x1d6>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1333 <mergecb+0x1c3>
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x78(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    12ef <mergecb+0x17f>
jmp    1338 <mergecb+0x1c8>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    12dc <mergecb+0x16c>
mov    -0x30(%rbp),%edi
mov    $0x4,%esi
call   1080 <calloc@plt>
mov    %rax,-0x60(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    138e <mergecb+0x21e>
mov    -0x50(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x60(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    135e <mergecb+0x1ee>
mov    -0x30(%rbp),%edi
mov    -0x30(%rbp),%esi
call   1090 <fmatrix@plt>
mov    %rax,-0x70(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    140e <mergecb+0x29e>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    13fb <mergecb+0x28b>
mov    -0x68(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    13b7 <mergecb+0x247>
jmp    1400 <mergecb+0x290>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    13a4 <mergecb+0x234>
cmpl   $0x3,-0x38(%rbp)
jne    142a <mergecb+0x2ba>
movss  0xbe4(%rip),%xmm0
movss  %xmm0,-0x34(%rbp)
jmp    1446 <mergecb+0x2d6>
cmpl   $0x1,-0x38(%rbp)
jne    1441 <mergecb+0x2d1>
movss  0xbc4(%rip),%xmm0
movss  %xmm0,-0x34(%rbp)
jmp    1446 <mergecb+0x2d6>
mov    -0x70(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x78(%rbp),%rdx
mov    -0x28(%rbp),%rcx
mov    -0x2c(%rbp),%r8d
mov    -0x30(%rbp),%r9d
mov    -0x38(%rbp),%r10d
mov    -0x60(%rbp),%rax
lea    -0x34(%rbp),%r11
mov    %r11,(%rsp)
mov    %r10d,0x8(%rsp)
mov    %rax,0x10(%rsp)
movl   $0x1,0x18(%rsp)
call   1040 <mergecb1@plt>
mov    -0x78(%rbp),%rdi
mov    -0x30(%rbp),%esi
call   1070 <free_fmatrix@plt>
mov    -0x60(%rbp),%rdi
call   1030 <free@plt>
mov    -0x70(%rbp),%rdi
mov    -0x30(%rbp),%esi
call   1070 <free_fmatrix@plt>
movss  -0x34(%rbp),%xmm0
lea    0xb56(%rip),%rdi
call   1060 <printf@plt>
mov    -0x68(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdx
mov    -0x28(%rbp),%rcx
mov    -0x2c(%rbp),%r8d
mov    -0x30(%rbp),%r9d
mov    -0x38(%rbp),%r10d
mov    -0x50(%rbp),%rax
lea    -0x34(%rbp),%r11
xor    %ebx,%ebx
mov    %r11,(%rsp)
mov    %r10d,0x8(%rsp)
mov    %rax,0x10(%rsp)
movl   $0x0,0x18(%rsp)
call   1040 <mergecb1@plt>
mov    %eax,-0x44(%rbp)
mov    -0x68(%rbp),%rdi
mov    -0x30(%rbp),%esi
call   1070 <free_fmatrix@plt>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
mov    -0x44(%rbp),%eax
mov    %eax,-0xc(%rbp)
mov    -0xc(%rbp),%eax
add    $0x98,%rsp
pop    %rbx
pop    %rbp
ret

x86 assembly (clang, -O2):
<mergecb>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
movss  %xmm0,0xc(%rsp)
mov    $0x1,%r13d
cmp    $0x1,%r8d
je     19da <mergecb+0x86a>
mov    %r9d,%ebx
mov    %r8d,%r14d
mov    %ecx,%r15d
mov    %rdx,%rbp
movss  %xmm0,0x38(%rsp)
mov    %rdi,0x48(%rsp)
mov    %rsi,0x58(%rsp)
mov    %r8d,%edi
mov    $0x4,%esi
call   1080 <calloc@plt>
mov    %rax,%r12
test   %r15d,%r15d
jle    1232 <mergecb+0xc2>
mov    %r15d,%edx
lea    -0x1(%rdx),%rcx
mov    %edx,%eax
and    $0x3,%eax
cmp    $0x3,%rcx
jae    11db <mergecb+0x6b>
xor    %ecx,%ecx
jmp    1211 <mergecb+0xa1>
and    $0xfffffffc,%edx
xor    %ecx,%ecx
movzbl 0x0(%rbp,%rcx,1),%esi
addl   $0x1,(%r12,%rsi,4)
movzbl 0x1(%rbp,%rcx,1),%esi
addl   $0x1,(%r12,%rsi,4)
movzbl 0x2(%rbp,%rcx,1),%esi
addl   $0x1,(%r12,%rsi,4)
movzbl 0x3(%rbp,%rcx,1),%esi
addl   $0x1,(%r12,%rsi,4)
add    $0x4,%rcx
cmp    %rcx,%rdx
jne    11e0 <mergecb+0x70>
test   %rax,%rax
je     1232 <mergecb+0xc2>
add    %rbp,%rcx
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movzbl (%rcx,%rdx,1),%esi
addl   $0x1,(%r12,%rsi,4)
add    $0x1,%rdx
cmp    %rdx,%rax
jne    1220 <mergecb+0xb0>
mov    %r14d,%edi
mov    %r14d,%esi
call   1090 <fmatrix@plt>
mov    %rax,0x50(%rsp)
cmp    $0x2,%r14d
mov    %rbx,0x30(%rsp)
movss  0x38(%rsp),%xmm0
mov    %r15d,0x44(%rsp)
jl     131b <mergecb+0x1ab>
mov    %rbp,0x18(%rsp)
mov    %r12,0x60(%rsp)
lea    -0x1(%r14),%eax
mov    %rax,0x28(%rsp)
mov    %r14,0x20(%rsp)
mov    %r14d,%r13d
mov    $0x1,%eax
mov    %rax,0x10(%rsp)
xor    %r14d,%r14d
mov    0x30(%rsp),%r12
mov    0x58(%rsp),%rbx
mov    0x50(%rsp),%rbp
jmp    12b2 <mergecb+0x142>
cs nopw 0x0(%rax,%rax,1)
nop
addq   $0x1,0x10(%rsp)
mov    0x38(%rsp),%r14
cmp    0x28(%rsp),%r14
je     1301 <mergecb+0x191>
lea    0x1(%r14),%rax
mov    %rax,0x38(%rsp)
cmp    %r13,%rax
jae    12a0 <mergecb+0x130>
mov    0x10(%rsp),%r15
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%rbx,%r14,8),%rdi
mov    (%rbx,%r15,8),%rsi
mov    %r12d,%edx
call   1050 <distance2@plt>
mov    0x0(%rbp,%r14,8),%rax
movss  %xmm0,(%rax,%r15,4)
mov    0x0(%rbp,%r15,8),%rax
movss  %xmm0,(%rax,%r14,4)
add    $0x1,%r15
cmp    %r15,%r13
jne    12d0 <mergecb+0x160>
jmp    12a0 <mergecb+0x130>
movss  0xc(%rsp),%xmm0
mov    0x20(%rsp),%r14
mov    0x30(%rsp),%rbx
mov    0x60(%rsp),%r12
mov    0x18(%rsp),%rbp
xorps  %xmm1,%xmm1
ucomiss %xmm0,%xmm1
jbe    1987 <mergecb+0x817>
mov    %r14d,%edi
mov    %ebx,%esi
call   1090 <fmatrix@plt>
mov    %rax,0x38(%rsp)
test   %r14d,%r14d
jle    15c0 <mergecb+0x450>
mov    %rbp,0x18(%rsp)
mov    %r14,0x20(%rsp)
mov    %r14d,%r14d
mov    %ebx,%eax
mov    %eax,%r9d
and    $0xfffffff8,%r9d
lea    -0x8(%r9),%r10
mov    %r10,0x10(%rsp)
shr    $0x3,%r10
add    $0x1,%r10
mov    %r10d,%r13d
and    $0x3,%r13d
and    $0xfffffffffffffffc,%r10
mov    %eax,%r15d
and    $0x3,%r15d
mov    %r13,0x28(%rsp)
shl    $0x5,%r13
xor    %esi,%esi
mov    0x58(%rsp),%rbp
jmp    139d <mergecb+0x22d>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rsi
cmp    %r14,%rsi
je     1516 <mergecb+0x3a6>
test   %ebx,%ebx
jle    1390 <mergecb+0x220>
mov    0x0(%rbp,%rsi,8),%rcx
mov    0x38(%rsp),%rdx
mov    (%rdx,%rsi,8),%r8
cmp    $0x8,%ebx
jb     13ca <mergecb+0x25a>
lea    (%rcx,%rax,4),%rdx
cmp    %rdx,%r8
jae    1444 <mergecb+0x2d4>
lea    (%r8,%rax,4),%rdx
cmp    %rdx,%rcx
jae    1444 <mergecb+0x2d4>
xor    %r11d,%r11d
mov    %r11,%rdx
not    %rdx
add    %rax,%rdx
test   %r15,%r15
je     13f6 <mergecb+0x286>
mov    %r15,%rdi
xchg   %ax,%ax
movss  (%rcx,%r11,4),%xmm0
movss  %xmm0,(%r8,%r11,4)
add    $0x1,%r11
add    $0xffffffffffffffff,%rdi
jne    13e0 <mergecb+0x270>
cmp    $0x3,%rdx
jb     1390 <mergecb+0x220>
nopl   0x0(%rax)
movss  (%rcx,%r11,4),%xmm0
movss  %xmm0,(%r8,%r11,4)
movss  0x4(%rcx,%r11,4),%xmm0
movss  %xmm0,0x4(%r8,%r11,4)
movss  0x8(%rcx,%r11,4),%xmm0
movss  %xmm0,0x8(%r8,%r11,4)
movss  0xc(%rcx,%r11,4),%xmm0
movss  %xmm0,0xc(%r8,%r11,4)
add    $0x4,%r11
cmp    %r11,%rax
jne    1400 <mergecb+0x290>
jmp    1390 <mergecb+0x220>
cmpq   $0x18,0x10(%rsp)
jae    1450 <mergecb+0x2e0>
xor    %edx,%edx
jmp    14c0 <mergecb+0x350>
mov    %r10,%rdi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nop
movups (%rcx,%rdx,4),%xmm0
movups 0x10(%rcx,%rdx,4),%xmm1
movups %xmm0,(%r8,%rdx,4)
movups %xmm1,0x10(%r8,%rdx,4)
movups 0x20(%rcx,%rdx,4),%xmm0
movups 0x30(%rcx,%rdx,4),%xmm1
movups %xmm0,0x20(%r8,%rdx,4)
movups %xmm1,0x30(%r8,%rdx,4)
movups 0x40(%rcx,%rdx,4),%xmm0
movups 0x50(%rcx,%rdx,4),%xmm1
movups %xmm0,0x40(%r8,%rdx,4)
movups %xmm1,0x50(%r8,%rdx,4)
movups 0x60(%rcx,%rdx,4),%xmm0
movups 0x70(%rcx,%rdx,4),%xmm1
movups %xmm0,0x60(%r8,%rdx,4)
movups %xmm1,0x70(%r8,%rdx,4)
add    $0x20,%rdx
add    $0xfffffffffffffffc,%rdi
jne    1460 <mergecb+0x2f0>
cmpq   $0x0,0x28(%rsp)
je     14fb <mergecb+0x38b>
lea    (%r8,%rdx,4),%rdi
add    $0x10,%rdi
lea    (%rcx,%rdx,4),%rdx
add    $0x10,%rdx
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movups -0x10(%rdx,%rbp,1),%xmm0
movups (%rdx,%rbp,1),%xmm1
movups %xmm0,-0x10(%rdi,%rbp,1)
movups %xmm1,(%rdi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%r13
jne    14e0 <mergecb+0x370>
mov    %r9,%r11
cmp    %rax,%r9
mov    0x30(%rsp),%rbx
mov    0x58(%rsp),%rbp
je     1390 <mergecb+0x220>
jmp    13cd <mergecb+0x25d>
mov    0x20(%rsp),%r13
mov    %r13d,%edi
mov    $0x4,%esi
call   1080 <calloc@plt>
test   %r13d,%r13d
mov    %rax,0x28(%rsp)
jle    15d4 <mergecb+0x464>
cmp    $0x8,%r13d
jb     1556 <mergecb+0x3e6>
lea    (%r12,%r14,4),%rcx
cmp    %rcx,%rax
jae    1611 <mergecb+0x4a1>
lea    (%rax,%r14,4),%rcx
cmp    %rcx,%r12
jae    1611 <mergecb+0x4a1>
xor    %ebx,%ebx
mov    0x18(%rsp),%rbp
mov    %rbx,%rcx
not    %rcx
add    %r14,%rcx
mov    %r14,%rdx
and    $0x3,%rdx
je     1581 <mergecb+0x411>
nop
mov    (%r12,%rbx,4),%esi
mov    %esi,(%rax,%rbx,4)
add    $0x1,%rbx
add    $0xffffffffffffffff,%rdx
jne    1570 <mergecb+0x400>
cmp    $0x3,%rcx
jb     16f4 <mergecb+0x584>
nopl   0x0(%rax,%rax,1)
mov    (%r12,%rbx,4),%ecx
mov    %ecx,(%rax,%rbx,4)
mov    0x4(%r12,%rbx,4),%ecx
mov    %ecx,0x4(%rax,%rbx,4)
mov    0x8(%r12,%rbx,4),%ecx
mov    %ecx,0x8(%rax,%rbx,4)
mov    0xc(%r12,%rbx,4),%ecx
mov    %ecx,0xc(%rax,%rbx,4)
add    $0x4,%rbx
cmp    %rbx,%r14
jne    1590 <mergecb+0x420>
jmp    16f4 <mergecb+0x584>
mov    %r14d,%edi
mov    $0x4,%esi
call   1080 <calloc@plt>
mov    %rax,0x28(%rsp)
jmp    15dc <mergecb+0x46c>
mov    0x18(%rsp),%rbp
mov    %r13,%r14
mov    %r14d,%edi
mov    %r14d,%esi
call   1090 <fmatrix@plt>
mov    %rax,%r9
mov    0x48(%rsp),%rsi
cmp    $0x1,%ebx
je     191e <mergecb+0x7ae>
mov    %rbx,%rax
cmp    $0x3,%ebx
jne    1929 <mergecb+0x7b9>
movl   $0x43c80000,0xc(%rsp)
43
jmp    1929 <mergecb+0x7b9>
mov    %r14d,%ebx
and    $0xfffffff8,%ebx
lea    -0x8(%rbx),%rsi
mov    %rsi,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %edx,%ecx
and    $0x3,%ecx
cmp    $0x18,%rsi
mov    0x18(%rsp),%rbp
jae    163a <mergecb+0x4ca>
xor    %esi,%esi
jmp    16b0 <mergecb+0x540>
movabs $0x3ffffffffffffffc,%rsi
ff ff 3f
and    %rsi,%rdx
xor    %esi,%esi
nopl   0x0(%rax)
movups (%r12,%rsi,4),%xmm0
movups 0x10(%r12,%rsi,4),%xmm1
movups %xmm0,(%rax,%rsi,4)
movups %xmm1,0x10(%rax,%rsi,4)
movups 0x20(%r12,%rsi,4),%xmm0
movups 0x30(%r12,%rsi,4),%xmm1
movups %xmm0,0x20(%rax,%rsi,4)
movups %xmm1,0x30(%rax,%rsi,4)
movups 0x40(%r12,%rsi,4),%xmm0
movups 0x50(%r12,%rsi,4),%xmm1
movups %xmm0,0x40(%rax,%rsi,4)
movups %xmm1,0x50(%rax,%rsi,4)
movups 0x60(%r12,%rsi,4),%xmm0
movups 0x70(%r12,%rsi,4),%xmm1
movups %xmm0,0x60(%rax,%rsi,4)
movups %xmm1,0x70(%rax,%rsi,4)
add    $0x20,%rsi
add    $0xfffffffffffffffc,%rdx
jne    1650 <mergecb+0x4e0>
test   %rcx,%rcx
je     16eb <mergecb+0x57b>
lea    (%rax,%rsi,4),%rdx
add    $0x10,%rdx
lea    (%r12,%rsi,4),%rsi
add    $0x10,%rsi
shl    $0x5,%rcx
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movups -0x10(%rsi,%rdi,1),%xmm0
movups (%rsi,%rdi,1),%xmm1
movups %xmm0,-0x10(%rdx,%rdi,1)
movups %xmm1,(%rdx,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rcx
jne    16d0 <mergecb+0x560>
cmp    %r14,%rbx
jne    155d <mergecb+0x3ed>
mov    0x20(%rsp),%r13
mov    %r13d,%edi
mov    %r13d,%esi
call   1090 <fmatrix@plt>
mov    %rax,%r9
test   %r13d,%r13d
jle    19ec <mergecb+0x87c>
mov    %r14d,%r10d
and    $0xfffffff8,%r10d
add    $0xfffffffffffffff8,%r10
mov    %r10,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
mov    %r14d,%r8d
and    $0xfffffff8,%r8d
mov    %ecx,%r13d
and    $0x3,%r13d
movabs $0x3ffffffffffffffc,%rax
ff ff 3f
and    %rax,%rcx
mov    %rcx,0x60(%rsp)
mov    %r14d,%r15d
and    $0x3,%r15d
mov    %r13,0x10(%rsp)
shl    $0x5,%r13
xor    %ecx,%ecx
mov    0x50(%rsp),%rbp
mov    0x30(%rsp),%rbx
jmp    177d <mergecb+0x60d>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rcx
cmp    %r14,%rcx
je     1906 <mergecb+0x796>
mov    0x0(%rbp,%rcx,8),%rax
mov    (%r9,%rcx,8),%rdx
cmpl   $0x8,0x20(%rsp)
jb     17a7 <mergecb+0x637>
lea    (%rax,%r14,4),%rsi
cmp    %rsi,%rdx
jae    1830 <mergecb+0x6c0>
lea    (%rdx,%r14,4),%rsi
cmp    %rsi,%rax
jae    1830 <mergecb+0x6c0>
xor    %r11d,%r11d
mov    %r11,%rsi
not    %rsi
add    %r14,%rsi
test   %r15,%r15
je     17d6 <mergecb+0x666>
mov    %r15,%rdi
nopl   0x0(%rax,%rax,1)
movss  (%rax,%r11,4),%xmm0
movss  %xmm0,(%rdx,%r11,4)
add    $0x1,%r11
add    $0xffffffffffffffff,%rdi
jne    17c0 <mergecb+0x650>
cmp    $0x3,%rsi
jb     1770 <mergecb+0x600>
nopl   0x0(%rax)
movss  (%rax,%r11,4),%xmm0
movss  %xmm0,(%rdx,%r11,4)
movss  0x4(%rax,%r11,4),%xmm0
movss  %xmm0,0x4(%rdx,%r11,4)
movss  0x8(%rax,%r11,4),%xmm0
movss  %xmm0,0x8(%rdx,%r11,4)
movss  0xc(%rax,%r11,4),%xmm0
movss  %xmm0,0xc(%rdx,%r11,4)
add    $0x4,%r11
cmp    %r11,%r14
jne    17e0 <mergecb+0x670>
jmp    1770 <mergecb+0x600>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cmp    $0x18,%r10
jae    183a <mergecb+0x6ca>
xor    %edi,%edi
jmp    18a8 <mergecb+0x738>
mov    0x60(%rsp),%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups (%rax,%rdi,4),%xmm0
movups 0x10(%rax,%rdi,4),%xmm1
movups %xmm0,(%rdx,%rdi,4)
movups %xmm1,0x10(%rdx,%rdi,4)
movups 0x20(%rax,%rdi,4),%xmm0
movups 0x30(%rax,%rdi,4),%xmm1
movups %xmm0,0x20(%rdx,%rdi,4)
movups %xmm1,0x30(%rdx,%rdi,4)
movups 0x40(%rax,%rdi,4),%xmm0
movups 0x50(%rax,%rdi,4),%xmm1
movups %xmm0,0x40(%rdx,%rdi,4)
movups %xmm1,0x50(%rdx,%rdi,4)
movups 0x60(%rax,%rdi,4),%xmm0
movups 0x70(%rax,%rdi,4),%xmm1
movups %xmm0,0x60(%rdx,%rdi,4)
movups %xmm1,0x70(%rdx,%rdi,4)
add    $0x20,%rdi
add    $0xfffffffffffffffc,%rsi
jne    1850 <mergecb+0x6e0>
cmpq   $0x0,0x10(%rsp)
je     18eb <mergecb+0x77b>
lea    (%rdx,%rdi,4),%rsi
add    $0x10,%rsi
lea    (%rax,%rdi,4),%rdi
add    $0x10,%rdi
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups -0x10(%rdi,%rbp,1),%xmm0
movups (%rdi,%rbp,1),%xmm1
movups %xmm0,-0x10(%rsi,%rbp,1)
movups %xmm1,(%rsi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%r13
jne    18d0 <mergecb+0x760>
mov    %r8,%r11
cmp    %r14,%r8
mov    0x30(%rsp),%rbx
mov    0x50(%rsp),%rbp
je     1770 <mergecb+0x600>
jmp    17aa <mergecb+0x63a>
mov    0x18(%rsp),%rbp
mov    0x48(%rsp),%rsi
mov    0x20(%rsp),%r14
cmp    $0x1,%ebx
jne    15f8 <mergecb+0x488>
mov    %rbx,%rax
movl   $0x44480000,0xc(%rsp)
44
lea    0xc(%rsp),%r10
mov    %r9,0x10(%rsp)
mov    %r9,%rdi
mov    0x38(%rsp),%r15
mov    %r15,%rdx
mov    %rbp,%rcx
mov    0x44(%rsp),%r8d
mov    %r14d,%r9d
push   $0x1
mov    0x30(%rsp),%r13
push   %r13
mov    %rax,%rbx
push   %rax
push   %r10
call   1040 <mergecb1@plt>
add    $0x20,%rsp
mov    %r15,%rdi
mov    %r14d,%esi
call   1070 <free_fmatrix@plt>
mov    %r13,%rdi
call   1030 <free@plt>
mov    0x10(%rsp),%rdi
mov    %r14d,%esi
call   1070 <free_fmatrix@plt>
movss  0xc(%rsp),%xmm0
lea    0x672(%rip),%rdi
call   1060 <printf@plt>
lea    0xc(%rsp),%rax
mov    0x50(%rsp),%r15
mov    %r15,%rdi
mov    0x48(%rsp),%rsi
mov    0x58(%rsp),%rdx
mov    %rbp,%rcx
mov    0x44(%rsp),%r8d
mov    %r14d,%r9d
push   $0x0
push   %r12
push   %rbx
push   %rax
call   1040 <mergecb1@plt>
add    $0x20,%rsp
mov    %eax,%r13d
mov    %r15,%rdi
mov    %r14d,%esi
call   1070 <free_fmatrix@plt>
mov    %r12,%rdi
call   1030 <free@plt>
mov    %r13d,%eax
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0x20(%rsp),%r14
mov    0x30(%rsp),%rbx
jmp    15ea <mergecb+0x47a>

LLVM IR (-O0):
@.str = [11 x i8] c"thresh %f \00"
define i32 @mergecb(float* %0, float** %1, i8* %2, i32 %3, i32 %4, float %5, i32 %6) {
%8 = alloca i32
%9 = alloca float*
%10 = alloca float**
%11 = alloca i8*
%12 = alloca i32
%13 = alloca i32
%14 = alloca float
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32*
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32*
%23 = alloca float**
%24 = alloca float**
%25 = alloca float**
store float* %0, float** %9
store float** %1, float*** %10
store i8* %2, i8** %11
store i32 %3, i32* %12
store i32 %4, i32* %13
store float %5, float* %14
store i32 %6, i32* %15
%26 = load i32, i32* %13
%27 = icmp eq i32 %26, 1
br i1 %27, label %28, label %29
28: ; preds = %7
store i32 1, i32* %8
br label %261
29: ; preds = %7
%30 = load i32, i32* %13
%31 = call i64 @calloc(i32 %30, i32 4)
%32 = inttoptr i64 %31 to i32*
store i32* %32, i32** %19
store i32 0, i32* %20
br label %33
33: ; preds = %48, %29
%34 = load i32, i32* %20
%35 = load i32, i32* %12
%36 = icmp slt i32 %34, %35
br i1 %36, label %37, label %51
37: ; preds = %33
%38 = load i32*, i32** %19
%39 = load i8*, i8** %11
%40 = load i32, i32* %20
%41 = sext i32 %40 to i64
%42 = getelementptr inbounds i8, i8* %39, i64 %41
%43 = load i8, i8* %42
%44 = zext i8 %43 to i64
%45 = getelementptr inbounds i32, i32* %38, i64 %44
%46 = load i32, i32* %45
%47 = add nsw i32 %46, 1
store i32 %47, i32* %45
br label %48
48: ; preds = %37
%49 = load i32, i32* %20
%50 = add nsw i32 %49, 1
store i32 %50, i32* %20
br label %33
51: ; preds = %33
%52 = load i32, i32* %13
%53 = load i32, i32* %13
%54 = call i64 @fmatrix(i32 %52, i32 %53)
%55 = inttoptr i64 %54 to float**
store float** %55, float*** %23
%56 = load i32, i32* %13
%57 = sub nsw i32 %56, 1
store i32 %57, i32* %21
store i32 0, i32* %16
br label %58
58: ; preds = %111, %51
%59 = load i32, i32* %16
%60 = load i32, i32* %21
%61 = icmp slt i32 %59, %60
br i1 %61, label %62, label %114
62: ; preds = %58
%63 = load i32, i32* %16
%64 = add nsw i32 %63, 1
store i32 %64, i32* %17
br label %65
65: ; preds = %107, %62
%66 = load i32, i32* %17
%67 = load i32, i32* %13
%68 = icmp slt i32 %66, %67
br i1 %68, label %69, label %110
69: ; preds = %65
%70 = load float**, float*** %10
%71 = load i32, i32* %16
%72 = sext i32 %71 to i64
%73 = getelementptr inbounds float*, float** %70, i64 %72
%74 = load float*, float** %73
%75 = load float**, float*** %10
%76 = load i32, i32* %17
%77 = sext i32 %76 to i64
%78 = getelementptr inbounds float*, float** %75, i64 %77
%79 = load float*, float** %78
%80 = load i32, i32* %15
%81 = call float @distance2(float* %74, float* %79, i32 %80)
%82 = load float**, float*** %23
%83 = load i32, i32* %16
%84 = sext i32 %83 to i64
%85 = getelementptr inbounds float*, float** %82, i64 %84
%86 = load float*, float** %85
%87 = load i32, i32* %17
%88 = sext i32 %87 to i64
%89 = getelementptr inbounds float, float* %86, i64 %88
store float %81, float* %89
%90 = load float**, float*** %23
%91 = load i32, i32* %16
%92 = sext i32 %91 to i64
%93 = getelementptr inbounds float*, float** %90, i64 %92
%94 = load float*, float** %93
%95 = load i32, i32* %17
%96 = sext i32 %95 to i64
%97 = getelementptr inbounds float, float* %94, i64 %96
%98 = load float, float* %97
%99 = load float**, float*** %23
%100 = load i32, i32* %17
%101 = sext i32 %100 to i64
%102 = getelementptr inbounds float*, float** %99, i64 %101
%103 = load float*, float** %102
%104 = load i32, i32* %16
%105 = sext i32 %104 to i64
%106 = getelementptr inbounds float, float* %103, i64 %105
store float %98, float* %106
br label %107
107: ; preds = %69
%108 = load i32, i32* %17
%109 = add nsw i32 %108, 1
store i32 %109, i32* %17
br label %65
110: ; preds = %65
br label %111
111: ; preds = %110
%112 = load i32, i32* %16
%113 = add nsw i32 %112, 1
store i32 %113, i32* %16
br label %58
114: ; preds = %58
%115 = load float, float* %14
%116 = fcmp olt float %115, 0.000000e+00
br i1 %116, label %117, label %243
117: ; preds = %114
%118 = load i32, i32* %13
%119 = load i32, i32* %15
%120 = call i64 @fmatrix(i32 %118, i32 %119)
%121 = inttoptr i64 %120 to float**
store float** %121, float*** %25
store i32 0, i32* %16
br label %122
122: ; preds = %153, %117
%123 = load i32, i32* %16
%124 = load i32, i32* %13
%125 = icmp slt i32 %123, %124
br i1 %125, label %126, label %156
126: ; preds = %122
store i32 0, i32* %17
br label %127
127: ; preds = %149, %126
%128 = load i32, i32* %17
%129 = load i32, i32* %15
%130 = icmp slt i32 %128, %129
br i1 %130, label %131, label %152
131: ; preds = %127
%132 = load float**, float*** %10
%133 = load i32, i32* %16
%134 = sext i32 %133 to i64
%135 = getelementptr inbounds float*, float** %132, i64 %134
%136 = load float*, float** %135
%137 = load i32, i32* %17
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds float, float* %136, i64 %138
%140 = load float, float* %139
%141 = load float**, float*** %25
%142 = load i32, i32* %16
%143 = sext i32 %142 to i64
%144 = getelementptr inbounds float*, float** %141, i64 %143
%145 = load float*, float** %144
%146 = load i32, i32* %17
%147 = sext i32 %146 to i64
%148 = getelementptr inbounds float, float* %145, i64 %147
store float %140, float* %148
br label %149
149: ; preds = %131
%150 = load i32, i32* %17
%151 = add nsw i32 %150, 1
store i32 %151, i32* %17
br label %127
152: ; preds = %127
br label %153
153: ; preds = %152
%154 = load i32, i32* %16
%155 = add nsw i32 %154, 1
store i32 %155, i32* %16
br label %122
156: ; preds = %122
%157 = load i32, i32* %13
%158 = call i64 @calloc(i32 %157, i32 4)
%159 = inttoptr i64 %158 to i32*
store i32* %159, i32** %22
store i32 0, i32* %16
br label %160
160: ; preds = %174, %156
%161 = load i32, i32* %16
%162 = load i32, i32* %13
%163 = icmp slt i32 %161, %162
br i1 %163, label %164, label %177
164: ; preds = %160
%165 = load i32*, i32** %19
%166 = load i32, i32* %16
%167 = sext i32 %166 to i64
%168 = getelementptr inbounds i32, i32* %165, i64 %167
%169 = load i32, i32* %168
%170 = load i32*, i32** %22
%171 = load i32, i32* %16
%172 = sext i32 %171 to i64
%173 = getelementptr inbounds i32, i32* %170, i64 %172
store i32 %169, i32* %173
br label %174
174: ; preds = %164
%175 = load i32, i32* %16
%176 = add nsw i32 %175, 1
store i32 %176, i32* %16
br label %160
177: ; preds = %160
%178 = load i32, i32* %13
%179 = load i32, i32* %13
%180 = call i64 @fmatrix(i32 %178, i32 %179)
%181 = inttoptr i64 %180 to float**
store float** %181, float*** %24
store i32 0, i32* %16
br label %182
182: ; preds = %213, %177
%183 = load i32, i32* %16
%184 = load i32, i32* %13
%185 = icmp slt i32 %183, %184
br i1 %185, label %186, label %216
186: ; preds = %182
store i32 0, i32* %17
br label %187
187: ; preds = %209, %186
%188 = load i32, i32* %17
%189 = load i32, i32* %13
%190 = icmp slt i32 %188, %189
br i1 %190, label %191, label %212
191: ; preds = %187
%192 = load float**, float*** %23
%193 = load i32, i32* %16
%194 = sext i32 %193 to i64
%195 = getelementptr inbounds float*, float** %192, i64 %194
%196 = load float*, float** %195
%197 = load i32, i32* %17
%198 = sext i32 %197 to i64
%199 = getelementptr inbounds float, float* %196, i64 %198
%200 = load float, float* %199
%201 = load float**, float*** %24
%202 = load i32, i32* %16
%203 = sext i32 %202 to i64
%204 = getelementptr inbounds float*, float** %201, i64 %203
%205 = load float*, float** %204
%206 = load i32, i32* %17
%207 = sext i32 %206 to i64
%208 = getelementptr inbounds float, float* %205, i64 %207
store float %200, float* %208
br label %209
209: ; preds = %191
%210 = load i32, i32* %17
%211 = add nsw i32 %210, 1
store i32 %211, i32* %17
br label %187
212: ; preds = %187
br label %213
213: ; preds = %212
%214 = load i32, i32* %16
%215 = add nsw i32 %214, 1
store i32 %215, i32* %16
br label %182
216: ; preds = %182
%217 = load i32, i32* %15
%218 = icmp eq i32 %217, 3
br i1 %218, label %219, label %220
219: ; preds = %216
store float 4.000000e+02, float* %14
br label %225
220: ; preds = %216
%221 = load i32, i32* %15
%222 = icmp eq i32 %221, 1
br i1 %222, label %223, label %224
223: ; preds = %220
store float 8.000000e+02, float* %14
br label %224
224: ; preds = %223, %220
br label %225
225: ; preds = %224, %219
%226 = load float**, float*** %24
%227 = load float*, float** %9
%228 = load float**, float*** %25
%229 = load i8*, i8** %11
%230 = load i32, i32* %12
%231 = load i32, i32* %13
%232 = load i32, i32* %15
%233 = load i32*, i32** %22
%234 = call i32 @mergecb1(float** %226, float* %227, float** %228, i8* %229, i32 %230, i32 %231, float* %14, i32 %232, i32* %233, i32 1)
%235 = load float**, float*** %25
%236 = load i32, i32* %13
%237 = call i32 @free_fmatrix(float** %235, i32 %236)
%238 = load i32*, i32** %22
%239 = call i32 @free(i32* %238)
%240 = load float**, float*** %24
%241 = load i32, i32* %13
%242 = call i32 @free_fmatrix(float** %240, i32 %241)
br label %243
243: ; preds = %225, %114
%244 = load float, float* %14
%245 = call i32 @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str, i64 0, i64 0), float %244)
%246 = load float**, float*** %23
%247 = load float*, float** %9
%248 = load float**, float*** %10
%249 = load i8*, i8** %11
%250 = load i32, i32* %12
%251 = load i32, i32* %13
%252 = load i32, i32* %15
%253 = load i32*, i32** %19
%254 = call i32 @mergecb1(float** %246, float* %247, float** %248, i8* %249, i32 %250, i32 %251, float* %14, i32 %252, i32* %253, i32 0)
store i32 %254, i32* %18
%255 = load float**, float*** %23
%256 = load i32, i32* %13
%257 = call i32 @free_fmatrix(float** %255, i32 %256)
%258 = load i32*, i32** %19
%259 = call i32 @free(i32* %258)
%260 = load i32, i32* %18
store i32 %260, i32* %8
br label %261
261: ; preds = %243, %28
%262 = load i32, i32* %8
ret i32 %262
}

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