#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 *dvector(int, int);
int /*<<< orphan*/ free_dvector(double *, int, int);
int /*<<< orphan*/ free_ivector(int *, int, int);
int *ivector(int, int);
int /*<<< orphan*/ printf(char *);
int /*<<< orphan*/ quicksortd(int, double *, int *);
void sort_int_matrix(int **m, int n_rows, int n_cols_sort, int n_cols_write,
                     int **sorted_matrix, int max_entry) {
  int i, j;
  int **temp_matrix1;
  int **temp_matrix2;
  int *indices;
  int curr_index;
  double g1, g2, g3, g4, g;
  double *vd;
  vd = dvector(1, n_rows);
  indices = ivector(1, n_rows);
  for (i = 1; i <= n_rows; i++)
    indices[i] = i;
  if (n_cols_sort == 1) {
    for (i = 1; i <= n_rows; i++)
      vd[i] = (double)m[i][1] * (double)max_entry;
  } else {
    if (n_cols_sort == 2) {
      for (i = 1; i <= n_rows; i++) {
        g1 = (double)m[i][1] * (double)max_entry;
        g2 = (double)m[i][2];
        g = g1 + g2;
        vd[i] = g;
      }
    } else {
      if (n_cols_sort == 3) {
        for (i = 1; i <= n_rows; i++) {
          g1 = (double)m[i][1] * (double)max_entry;
          g2 = (double)m[i][2];
          g3 = (double)m[i][3] / (double)max_entry;
          g = g1 + g2 + g3;
          vd[i] = (float)g;
        }
      } else {
        if (n_cols_sort == 4) {
          for (i = 1; i <= n_rows; i++) {
            g1 = (double)m[i][1] * (double)max_entry;
            g2 = (double)m[i][2];
            g3 = (double)m[i][3] / (double)max_entry;
            g4 = (double)m[i][4] / (double)(max_entry * max_entry);
            g = g1 + g2 + g3 + g4;
            vd[i] = g;
          }
        } else {
          printf("you shouldn't be here ...\n");
        }
      }
    }
  }
  quicksortd(n_rows, vd, indices);
  for (i = 1; i <= n_rows; i++) {
    curr_index = indices[i];
    for (j = 1; j <= n_cols_write; j++)
      sorted_matrix[i][j] = m[curr_index][j];
  }
  free_dvector(vd, 1, n_rows);
  free_ivector(indices, 1, n_rows);
}


x86 assembly (clang, -O0):
<sort_int_matrix>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9d,-0x24(%rbp)
mov    -0xc(%rbp),%esi
mov    $0x1,%edi
call   1050 <dvector@plt>
mov    %rax,-0x80(%rbp)
mov    -0xc(%rbp),%esi
mov    $0x1,%edi
call   1080 <ivector@plt>
mov    %rax,-0x48(%rbp)
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     11d1 <sort_int_matrix+0x71>
mov    -0x28(%rbp),%edx
mov    -0x48(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11a9 <sort_int_matrix+0x49>
cmpl   $0x1,-0x10(%rbp)
jne    1228 <sort_int_matrix+0xc8>
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1223 <sort_int_matrix+0xc3>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
cvtsi2sdl 0x4(%rax),%xmm0
cvtsi2sdl -0x24(%rbp),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x80(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11e2 <sort_int_matrix+0x82>
jmp    144f <sort_int_matrix+0x2ef>
cmpl   $0x2,-0x10(%rbp)
jne    12ae <sort_int_matrix+0x14e>
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     12a9 <sort_int_matrix+0x149>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
cvtsi2sdl 0x4(%rax),%xmm0
cvtsi2sdl -0x24(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
cvtsi2sdl 0x8(%rax),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x58(%rbp),%xmm0
addsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm0
mov    -0x80(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1239 <sort_int_matrix+0xd9>
jmp    144a <sort_int_matrix+0x2ea>
cmpl   $0x3,-0x10(%rbp)
jne    1360 <sort_int_matrix+0x200>
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     135b <sort_int_matrix+0x1fb>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
cvtsi2sdl 0x4(%rax),%xmm0
cvtsi2sdl -0x24(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
cvtsi2sdl 0x8(%rax),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
cvtsi2sdl 0xc(%rax),%xmm0
cvtsi2sdl -0x24(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x58(%rbp),%xmm0
addsd  -0x60(%rbp),%xmm0
addsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x80(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    12bf <sort_int_matrix+0x15f>
jmp    1445 <sort_int_matrix+0x2e5>
cmpl   $0x4,-0x10(%rbp)
jne    1434 <sort_int_matrix+0x2d4>
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     142f <sort_int_matrix+0x2cf>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
cvtsi2sdl 0x4(%rax),%xmm0
cvtsi2sdl -0x24(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
cvtsi2sdl 0x8(%rax),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
cvtsi2sdl 0xc(%rax),%xmm0
cvtsi2sdl -0x24(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
cvtsi2sdl 0x10(%rax),%xmm0
mov    -0x24(%rbp),%eax
imul   -0x24(%rbp),%eax
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x58(%rbp),%xmm0
addsd  -0x60(%rbp),%xmm0
addsd  -0x68(%rbp),%xmm0
addsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm0
mov    -0x80(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1371 <sort_int_matrix+0x211>
jmp    1440 <sort_int_matrix+0x2e0>
lea    0xbc5(%rip),%rdi
call   1030 <printf@plt>
jmp    1445 <sort_int_matrix+0x2e5>
jmp    144a <sort_int_matrix+0x2ea>
jmp    144f <sort_int_matrix+0x2ef>
mov    -0xc(%rbp),%edi
mov    -0x80(%rbp),%rsi
mov    -0x48(%rbp),%rdx
call   1040 <quicksortd@plt>
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     14da <sort_int_matrix+0x37a>
mov    -0x48(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x4c(%rbp)
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     14c7 <sort_int_matrix+0x367>
mov    -0x8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1487 <sort_int_matrix+0x327>
jmp    14cc <sort_int_matrix+0x36c>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1466 <sort_int_matrix+0x306>
mov    -0x80(%rbp),%rdi
mov    -0xc(%rbp),%edx
mov    $0x1,%esi
call   1070 <free_dvector@plt>
mov    -0x48(%rbp),%rdi
mov    -0xc(%rbp),%edx
mov    $0x1,%esi
call   1060 <free_ivector@plt>
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<sort_int_matrix>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %r9d,0x10(%rsp)
mov    %r8,0x30(%rsp)
mov    %ecx,%r13d
mov    %edx,%r15d
mov    %esi,%ebp
mov    %rdi,%r14
mov    $0x1,%edi
call   1050 <dvector@plt>
mov    %rax,%r12
mov    $0x1,%edi
mov    %ebp,%esi
call   1080 <ivector@plt>
mov    %rax,%rbx
mov    %rbp,0x8(%rsp)
test   %ebp,%ebp
jle    131c <sort_int_matrix+0x1bc>
mov    0x8(%rsp),%rdx
mov    %edx,%eax
mov    $0x1,%ecx
cmp    $0x8,%edx
jb     1306 <sort_int_matrix+0x1a6>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rsi
mov    %rsi,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%edx
and    $0x3,%edx
cmp    $0x18,%rsi
jae    11ef <sort_int_matrix+0x8f>
movdqa 0xe18(%rip),%xmm0
xor    %esi,%esi
jmp    12b9 <sort_int_matrix+0x159>
and    $0xfffffffffffffffc,%rdi
movdqa 0xe05(%rip),%xmm0
xor    %esi,%esi
movdqa 0xe0a(%rip),%xmm8
movdqa 0xe11(%rip),%xmm9
movdqa 0xe18(%rip),%xmm10
movdqa 0xe20(%rip),%xmm4
movdqa 0xe28(%rip),%xmm5
movdqa 0xe30(%rip),%xmm6
movdqa 0xe38(%rip),%xmm7
movdqa 0xe40(%rip),%xmm1
movdqa %xmm0,%xmm2
paddd  %xmm8,%xmm2
movdqu %xmm0,0x4(%rbx,%rsi,4)
movdqu %xmm2,0x14(%rbx,%rsi,4)
movdqa %xmm0,%xmm2
paddd  %xmm9,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm10,%xmm3
movdqu %xmm2,0x24(%rbx,%rsi,4)
movdqu %xmm3,0x34(%rbx,%rsi,4)
movdqa %xmm0,%xmm2
paddd  %xmm4,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm5,%xmm3
movdqu %xmm2,0x44(%rbx,%rsi,4)
movdqu %xmm3,0x54(%rbx,%rsi,4)
movdqa %xmm0,%xmm2
paddd  %xmm6,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm7,%xmm3
movdqu %xmm2,0x64(%rbx,%rsi,4)
movdqu %xmm3,0x74(%rbx,%rsi,4)
add    $0x20,%rsi
paddd  %xmm1,%xmm0
add    $0xfffffffffffffffc,%rdi
jne    1240 <sort_int_matrix+0xe0>
test   %rdx,%rdx
je     12fd <sort_int_matrix+0x19d>
movdqa 0xd4a(%rip),%xmm1
movdqa 0xd52(%rip),%xmm2
xchg   %ax,%ax
lea    0x0(,%rsi,4),%rdi
movdqa %xmm0,%xmm3
paddd  %xmm1,%xmm3
or     $0x4,%rdi
movdqu %xmm0,(%rbx,%rdi,1)
movdqu %xmm3,0x10(%rbx,%rdi,1)
add    $0x8,%rsi
paddd  %xmm2,%xmm0
add    $0xffffffffffffffff,%rdx
jne    12d0 <sort_int_matrix+0x170>
cmp    %rcx,%rax
je     131c <sort_int_matrix+0x1bc>
or     $0x1,%rcx
add    $0x1,%rax
nopw   0x0(%rax,%rax,1)
mov    %ecx,(%rbx,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1310 <sort_int_matrix+0x1b0>
add    $0xffffffff,%r15d
cmp    $0x3,%r15d
ja     13d3 <sort_int_matrix+0x273>
lea    0xd5f(%rip),%rax
movslq (%rax,%r15,4),%rcx
add    %rax,%rcx
jmp    *%rcx
mov    0x8(%rsp),%rbp
test   %ebp,%ebp
jle    1784 <sort_int_matrix+0x624>
xorps  %xmm0,%xmm0
cvtsi2sdl 0x10(%rsp),%xmm0
mov    %ebp,%eax
mov    $0x1,%ecx
cmp    $0x1,%ebp
je     13b0 <sort_int_matrix+0x250>
mov    %eax,%edx
and    $0xfffffffe,%edx
neg    %rdx
mov    $0x1,%ecx
nopl   0x0(%rax)
mov    (%r14,%rcx,8),%rsi
xorps  %xmm1,%xmm1
cvtsi2sdl 0x4(%rsi),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%r12,%rcx,8)
mov    0x8(%r14,%rcx,8),%rsi
xorps  %xmm1,%xmm1
cvtsi2sdl 0x4(%rsi),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r12,%rcx,8)
lea    (%rdx,%rcx,1),%rsi
add    $0x2,%rsi
add    $0x2,%rcx
cmp    $0x1,%rsi
jne    1370 <sort_int_matrix+0x210>
test   $0x1,%al
je     158b <sort_int_matrix+0x42b>
mov    (%r14,%rcx,8),%rax
xorps  %xmm1,%xmm1
cvtsi2sdl 0x4(%rax),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,(%r12,%rcx,8)
jmp    158b <sort_int_matrix+0x42b>
lea    0xcc6(%rip),%rdi
call   1030 <puts@plt>
mov    0x8(%rsp),%rbp
jmp    158b <sort_int_matrix+0x42b>
mov    0x8(%rsp),%rbp
test   %ebp,%ebp
jle    1784 <sort_int_matrix+0x624>
xorps  %xmm0,%xmm0
cvtsi2sdl 0x10(%rsp),%xmm0
mov    %ebp,%ecx
mov    $0x1,%eax
cmp    $0x1,%ebp
je     1478 <sort_int_matrix+0x318>
mov    %ecx,%edx
and    $0xfffffffe,%edx
neg    %rdx
mov    $0x1,%eax
nopl   0x0(%rax,%rax,1)
mov    (%r14,%rax,8),%rsi
xorps  %xmm1,%xmm1
cvtsi2sdl 0x4(%rsi),%xmm1
mulsd  %xmm0,%xmm1
xorps  %xmm2,%xmm2
cvtsi2sdl 0x8(%rsi),%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,(%r12,%rax,8)
mov    0x8(%r14,%rax,8),%rsi
xorps  %xmm1,%xmm1
cvtsi2sdl 0x4(%rsi),%xmm1
mulsd  %xmm0,%xmm1
xorps  %xmm2,%xmm2
cvtsi2sdl 0x8(%rsi),%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,0x8(%r12,%rax,8)
lea    (%rdx,%rax,1),%rsi
add    $0x2,%rsi
add    $0x2,%rax
cmp    $0x1,%rsi
jne    1420 <sort_int_matrix+0x2c0>
test   $0x1,%cl
je     158b <sort_int_matrix+0x42b>
mov    (%r14,%rax,8),%rcx
xorps  %xmm1,%xmm1
cvtsi2sdl 0x4(%rcx),%xmm1
mulsd  %xmm1,%xmm0
xorps  %xmm1,%xmm1
cvtsi2sdl 0x8(%rcx),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%r12,%rax,8)
jmp    158b <sort_int_matrix+0x42b>
mov    0x8(%rsp),%rbp
test   %ebp,%ebp
jle    1784 <sort_int_matrix+0x624>
xorps  %xmm0,%xmm0
cvtsi2sdl 0x10(%rsp),%xmm0
lea    0x1(%rbp),%eax
mov    $0x1,%ecx
cs nopw 0x0(%rax,%rax,1)
mov    (%r14,%rcx,8),%rdx
xorps  %xmm1,%xmm1
cvtsi2sdl 0x4(%rdx),%xmm1
xorps  %xmm2,%xmm2
cvtsi2sdl 0x8(%rdx),%xmm2
mulsd  %xmm0,%xmm1
addsd  %xmm1,%xmm2
xorps  %xmm1,%xmm1
cvtsi2sdl 0xc(%rdx),%xmm1
divsd  %xmm0,%xmm1
addsd  %xmm2,%xmm1
cvtsd2ss %xmm1,%xmm1
cvtss2sd %xmm1,%xmm1
movsd  %xmm1,(%r12,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    14d0 <sort_int_matrix+0x370>
jmp    158b <sort_int_matrix+0x42b>
mov    0x8(%rsp),%rbp
test   %ebp,%ebp
jle    1784 <sort_int_matrix+0x624>
mov    0x10(%rsp),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
imul   %eax,%eax
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
lea    0x1(%rbp),%eax
mov    $0x1,%ecx
nop
mov    (%r14,%rcx,8),%rdx
xorps  %xmm2,%xmm2
cvtsi2sdl 0x4(%rdx),%xmm2
mulsd  %xmm0,%xmm2
xorps  %xmm3,%xmm3
cvtsi2sdl 0x8(%rdx),%xmm3
addsd  %xmm2,%xmm3
xorps  %xmm2,%xmm2
cvtsi2sdl 0xc(%rdx),%xmm2
divsd  %xmm0,%xmm2
addsd  %xmm3,%xmm2
xorps  %xmm3,%xmm3
cvtsi2sdl 0x10(%rdx),%xmm3
divsd  %xmm1,%xmm3
addsd  %xmm2,%xmm3
movsd  %xmm3,(%r12,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1540 <sort_int_matrix+0x3e0>
mov    %ebp,%edi
mov    %r12,%rsi
mov    %rbx,%rdx
call   1040 <quicksortd@plt>
test   %ebp,%ebp
jle    1791 <sort_int_matrix+0x631>
lea    0x1(%r13),%eax
mov    0x8(%rsp),%rcx
lea    0x1(%rcx),%r11d
lea    -0x1(%rax),%r10
lea    -0x9(%rax),%rcx
mov    %rcx,0x10(%rsp)
shr    $0x3,%rcx
add    $0x1,%rcx
mov    %r10,%rdx
and    $0xfffffffffffffff8,%rdx
mov    %rdx,0x28(%rsp)
add    $0x1,%rdx
mov    %rdx,0x20(%rsp)
mov    %ecx,%r15d
and    $0x3,%r15d
and    $0xfffffffffffffffc,%rcx
mov    %rcx,0x18(%rsp)
mov    $0x1,%esi
jmp    15fd <sort_int_matrix+0x49d>
xchg   %ax,%ax
add    $0x1,%rsi
cmp    %r11,%rsi
je     1791 <sort_int_matrix+0x631>
test   %r13d,%r13d
jle    15f0 <sort_int_matrix+0x490>
movslq (%rbx,%rsi,4),%rdx
mov    (%r14,%rdx,8),%rdi
mov    0x30(%rsp),%rcx
mov    (%rcx,%rsi,8),%r9
mov    $0x1,%r8d
cmp    $0x8,%r10
jb     1710 <sort_int_matrix+0x5b0>
lea    0x4(%r9),%rdx
lea    (%rdi,%rax,4),%rbp
cmp    %rbp,%rdx
jae    1641 <sort_int_matrix+0x4e1>
lea    (%r9,%rax,4),%rdx
lea    0x4(%rdi),%rbp
cmp    %rdx,%rbp
jb     1710 <sort_int_matrix+0x5b0>
cmpq   $0x18,0x10(%rsp)
jae    164d <sort_int_matrix+0x4ed>
xor    %ebp,%ebp
jmp    16c6 <sort_int_matrix+0x566>
mov    0x18(%rsp),%rdx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups 0x4(%rdi,%rbp,4),%xmm0
movups 0x14(%rdi,%rbp,4),%xmm1
movups %xmm0,0x4(%r9,%rbp,4)
movups %xmm1,0x14(%r9,%rbp,4)
movups 0x24(%rdi,%rbp,4),%xmm0
movups 0x34(%rdi,%rbp,4),%xmm1
movups %xmm0,0x24(%r9,%rbp,4)
movups %xmm1,0x34(%r9,%rbp,4)
movups 0x44(%rdi,%rbp,4),%xmm0
movups 0x54(%rdi,%rbp,4),%xmm1
movups %xmm0,0x44(%r9,%rbp,4)
movups %xmm1,0x54(%r9,%rbp,4)
movupd 0x64(%rdi,%rbp,4),%xmm0
movupd 0x74(%rdi,%rbp,4),%xmm1
movupd %xmm0,0x64(%r9,%rbp,4)
movupd %xmm1,0x74(%r9,%rbp,4)
add    $0x20,%rbp
add    $0xfffffffffffffffc,%rdx
jne    1660 <sort_int_matrix+0x500>
test   %r15,%r15
je     16fe <sort_int_matrix+0x59e>
mov    %r15,%rdx
xchg   %ax,%ax
lea    0x0(,%rbp,4),%rcx
or     $0x4,%rcx
movupd (%rdi,%rcx,1),%xmm0
movupd 0x10(%rdi,%rcx,1),%xmm1
movupd %xmm0,(%r9,%rcx,1)
movupd %xmm1,0x10(%r9,%rcx,1)
add    $0x8,%rbp
add    $0xffffffffffffffff,%rdx
jne    16d0 <sort_int_matrix+0x570>
mov    0x20(%rsp),%r8
cmp    0x28(%rsp),%r10
je     15f0 <sort_int_matrix+0x490>
xchg   %ax,%ax
mov    %eax,%ebp
sub    %r8d,%ebp
mov    %r8,%rdx
not    %rdx
add    %rax,%rdx
and    $0x3,%rbp
je     1742 <sort_int_matrix+0x5e2>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%rdi,%r8,4),%ecx
mov    %ecx,(%r9,%r8,4)
add    $0x1,%r8
add    $0xffffffffffffffff,%rbp
jne    1730 <sort_int_matrix+0x5d0>
cmp    $0x3,%rdx
jb     15f0 <sort_int_matrix+0x490>
nopl   0x0(%rax)
mov    (%rdi,%r8,4),%ecx
mov    %ecx,(%r9,%r8,4)
mov    0x4(%rdi,%r8,4),%ecx
mov    %ecx,0x4(%r9,%r8,4)
mov    0x8(%rdi,%r8,4),%ecx
mov    %ecx,0x8(%r9,%r8,4)
mov    0xc(%rdi,%r8,4),%ecx
mov    %ecx,0xc(%r9,%r8,4)
add    $0x4,%r8
cmp    %r8,%rax
jne    1750 <sort_int_matrix+0x5f0>
jmp    15f0 <sort_int_matrix+0x490>
mov    %ebp,%edi
mov    %r12,%rsi
mov    %rbx,%rdx
call   1040 <quicksortd@plt>
mov    %r12,%rdi
mov    $0x1,%esi
mov    0x8(%rsp),%rbp
mov    %ebp,%edx
call   1070 <free_dvector@plt>
mov    %rbx,%rdi
mov    $0x1,%esi
mov    %ebp,%edx
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1060 <free_ivector@plt>

LLVM IR (-O0):
@.str = [27 x i8] c"you shouldn't be here ...\0A\00"
define void @sort_int_matrix(i32** %0, i32 %1, i32 %2, i32 %3, i32** %4, i32 %5) {
%7 = alloca i32**
%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 double
%20 = alloca double
%21 = alloca double
%22 = alloca double
%23 = alloca double
%24 = alloca double*
store i32** %0, i32*** %7
store i32 %1, i32* %8
store i32 %2, i32* %9
store i32 %3, i32* %10
store i32** %4, i32*** %11
store i32 %5, i32* %12
%25 = load i32, i32* %8
%26 = call double* @dvector(i32 1, i32 %25)
store double* %26, double** %24
%27 = load i32, i32* %8
%28 = call i32* @ivector(i32 1, i32 %27)
store i32* %28, i32** %17
store i32 1, i32* %13
br label %29
29: ; preds = %39, %6
%30 = load i32, i32* %13
%31 = load i32, i32* %8
%32 = icmp sle i32 %30, %31
br i1 %32, label %33, label %42
33: ; preds = %29
%34 = load i32, i32* %13
%35 = load i32*, i32** %17
%36 = load i32, i32* %13
%37 = sext i32 %36 to i64
%38 = getelementptr inbounds i32, i32* %35, i64 %37
store i32 %34, i32* %38
br label %39
39: ; preds = %33
%40 = load i32, i32* %13
%41 = add nsw i32 %40, 1
store i32 %41, i32* %13
br label %29
42: ; preds = %29
%43 = load i32, i32* %9
%44 = icmp eq i32 %43, 1
br i1 %44, label %45, label %70
45: ; preds = %42
store i32 1, i32* %13
br label %46
46: ; preds = %66, %45
%47 = load i32, i32* %13
%48 = load i32, i32* %8
%49 = icmp sle i32 %47, %48
br i1 %49, label %50, label %69
50: ; preds = %46
%51 = load i32**, i32*** %7
%52 = load i32, i32* %13
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds i32*, i32** %51, i64 %53
%55 = load i32*, i32** %54
%56 = getelementptr inbounds i32, i32* %55, i64 1
%57 = load i32, i32* %56
%58 = sitofp i32 %57 to double
%59 = load i32, i32* %12
%60 = sitofp i32 %59 to double
%61 = fmul double %58, %60
%62 = load double*, double** %24
%63 = load i32, i32* %13
%64 = sext i32 %63 to i64
%65 = getelementptr inbounds double, double* %62, i64 %64
store double %61, double* %65
br label %66
66: ; preds = %50
%67 = load i32, i32* %13
%68 = add nsw i32 %67, 1
store i32 %68, i32* %13
br label %46
69: ; preds = %46
br label %238
70: ; preds = %42
%71 = load i32, i32* %9
%72 = icmp eq i32 %71, 2
br i1 %72, label %73, label %110
73: ; preds = %70
store i32 1, i32* %13
br label %74
74: ; preds = %106, %73
%75 = load i32, i32* %13
%76 = load i32, i32* %8
%77 = icmp sle i32 %75, %76
br i1 %77, label %78, label %109
78: ; preds = %74
%79 = load i32**, i32*** %7
%80 = load i32, i32* %13
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds i32*, i32** %79, i64 %81
%83 = load i32*, i32** %82
%84 = getelementptr inbounds i32, i32* %83, i64 1
%85 = load i32, i32* %84
%86 = sitofp i32 %85 to double
%87 = load i32, i32* %12
%88 = sitofp i32 %87 to double
%89 = fmul double %86, %88
store double %89, double* %19
%90 = load i32**, i32*** %7
%91 = load i32, i32* %13
%92 = sext i32 %91 to i64
%93 = getelementptr inbounds i32*, i32** %90, i64 %92
%94 = load i32*, i32** %93
%95 = getelementptr inbounds i32, i32* %94, i64 2
%96 = load i32, i32* %95
%97 = sitofp i32 %96 to double
store double %97, double* %20
%98 = load double, double* %19
%99 = load double, double* %20
%100 = fadd double %98, %99
store double %100, double* %23
%101 = load double, double* %23
%102 = load double*, double** %24
%103 = load i32, i32* %13
%104 = sext i32 %103 to i64
%105 = getelementptr inbounds double, double* %102, i64 %104
store double %101, double* %105
br label %106
106: ; preds = %78
%107 = load i32, i32* %13
%108 = add nsw i32 %107, 1
store i32 %108, i32* %13
br label %74
109: ; preds = %74
br label %237
110: ; preds = %70
%111 = load i32, i32* %9
%112 = icmp eq i32 %111, 3
br i1 %112, label %113, label %165
113: ; preds = %110
store i32 1, i32* %13
br label %114
114: ; preds = %161, %113
%115 = load i32, i32* %13
%116 = load i32, i32* %8
%117 = icmp sle i32 %115, %116
br i1 %117, label %118, label %164
118: ; preds = %114
%119 = load i32**, i32*** %7
%120 = load i32, i32* %13
%121 = sext i32 %120 to i64
%122 = getelementptr inbounds i32*, i32** %119, i64 %121
%123 = load i32*, i32** %122
%124 = getelementptr inbounds i32, i32* %123, i64 1
%125 = load i32, i32* %124
%126 = sitofp i32 %125 to double
%127 = load i32, i32* %12
%128 = sitofp i32 %127 to double
%129 = fmul double %126, %128
store double %129, double* %19
%130 = load i32**, i32*** %7
%131 = load i32, i32* %13
%132 = sext i32 %131 to i64
%133 = getelementptr inbounds i32*, i32** %130, i64 %132
%134 = load i32*, i32** %133
%135 = getelementptr inbounds i32, i32* %134, i64 2
%136 = load i32, i32* %135
%137 = sitofp i32 %136 to double
store double %137, double* %20
%138 = load i32**, i32*** %7
%139 = load i32, i32* %13
%140 = sext i32 %139 to i64
%141 = getelementptr inbounds i32*, i32** %138, i64 %140
%142 = load i32*, i32** %141
%143 = getelementptr inbounds i32, i32* %142, i64 3
%144 = load i32, i32* %143
%145 = sitofp i32 %144 to double
%146 = load i32, i32* %12
%147 = sitofp i32 %146 to double
%148 = fdiv double %145, %147
store double %148, double* %21
%149 = load double, double* %19
%150 = load double, double* %20
%151 = fadd double %149, %150
%152 = load double, double* %21
%153 = fadd double %151, %152
store double %153, double* %23
%154 = load double, double* %23
%155 = fptrunc double %154 to float
%156 = fpext float %155 to double
%157 = load double*, double** %24
%158 = load i32, i32* %13
%159 = sext i32 %158 to i64
%160 = getelementptr inbounds double, double* %157, i64 %159
store double %156, double* %160
br label %161
161: ; preds = %118
%162 = load i32, i32* %13
%163 = add nsw i32 %162, 1
store i32 %163, i32* %13
br label %114
164: ; preds = %114
br label %236
165: ; preds = %110
%166 = load i32, i32* %9
%167 = icmp eq i32 %166, 4
br i1 %167, label %168, label %233
168: ; preds = %165
store i32 1, i32* %13
br label %169
169: ; preds = %229, %168
%170 = load i32, i32* %13
%171 = load i32, i32* %8
%172 = icmp sle i32 %170, %171
br i1 %172, label %173, label %232
173: ; preds = %169
%174 = load i32**, i32*** %7
%175 = load i32, i32* %13
%176 = sext i32 %175 to i64
%177 = getelementptr inbounds i32*, i32** %174, i64 %176
%178 = load i32*, i32** %177
%179 = getelementptr inbounds i32, i32* %178, i64 1
%180 = load i32, i32* %179
%181 = sitofp i32 %180 to double
%182 = load i32, i32* %12
%183 = sitofp i32 %182 to double
%184 = fmul double %181, %183
store double %184, double* %19
%185 = load i32**, i32*** %7
%186 = load i32, i32* %13
%187 = sext i32 %186 to i64
%188 = getelementptr inbounds i32*, i32** %185, i64 %187
%189 = load i32*, i32** %188
%190 = getelementptr inbounds i32, i32* %189, i64 2
%191 = load i32, i32* %190
%192 = sitofp i32 %191 to double
store double %192, double* %20
%193 = load i32**, i32*** %7
%194 = load i32, i32* %13
%195 = sext i32 %194 to i64
%196 = getelementptr inbounds i32*, i32** %193, i64 %195
%197 = load i32*, i32** %196
%198 = getelementptr inbounds i32, i32* %197, i64 3
%199 = load i32, i32* %198
%200 = sitofp i32 %199 to double
%201 = load i32, i32* %12
%202 = sitofp i32 %201 to double
%203 = fdiv double %200, %202
store double %203, double* %21
%204 = load i32**, i32*** %7
%205 = load i32, i32* %13
%206 = sext i32 %205 to i64
%207 = getelementptr inbounds i32*, i32** %204, i64 %206
%208 = load i32*, i32** %207
%209 = getelementptr inbounds i32, i32* %208, i64 4
%210 = load i32, i32* %209
%211 = sitofp i32 %210 to double
%212 = load i32, i32* %12
%213 = load i32, i32* %12
%214 = mul nsw i32 %212, %213
%215 = sitofp i32 %214 to double
%216 = fdiv double %211, %215
store double %216, double* %22
%217 = load double, double* %19
%218 = load double, double* %20
%219 = fadd double %217, %218
%220 = load double, double* %21
%221 = fadd double %219, %220
%222 = load double, double* %22
%223 = fadd double %221, %222
store double %223, double* %23
%224 = load double, double* %23
%225 = load double*, double** %24
%226 = load i32, i32* %13
%227 = sext i32 %226 to i64
%228 = getelementptr inbounds double, double* %225, i64 %227
store double %224, double* %228
br label %229
229: ; preds = %173
%230 = load i32, i32* %13
%231 = add nsw i32 %230, 1
store i32 %231, i32* %13
br label %169
232: ; preds = %169
br label %235
233: ; preds = %165
%234 = call i32 @printf(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str, i64 0, i64 0))
br label %235
235: ; preds = %233, %232
br label %236
236: ; preds = %235, %164
br label %237
237: ; preds = %236, %109
br label %238
238: ; preds = %237, %69
%239 = load i32, i32* %8
%240 = load double*, double** %24
%241 = load i32*, i32** %17
%242 = call i32 @quicksortd(i32 %239, double* %240, i32* %241)
store i32 1, i32* %13
br label %243
243: ; preds = %279, %238
%244 = load i32, i32* %13
%245 = load i32, i32* %8
%246 = icmp sle i32 %244, %245
br i1 %246, label %247, label %282
247: ; preds = %243
%248 = load i32*, i32** %17
%249 = load i32, i32* %13
%250 = sext i32 %249 to i64
%251 = getelementptr inbounds i32, i32* %248, i64 %250
%252 = load i32, i32* %251
store i32 %252, i32* %18
store i32 1, i32* %14
br label %253
253: ; preds = %275, %247
%254 = load i32, i32* %14
%255 = load i32, i32* %10
%256 = icmp sle i32 %254, %255
br i1 %256, label %257, label %278
257: ; preds = %253
%258 = load i32**, i32*** %7
%259 = load i32, i32* %18
%260 = sext i32 %259 to i64
%261 = getelementptr inbounds i32*, i32** %258, i64 %260
%262 = load i32*, i32** %261
%263 = load i32, i32* %14
%264 = sext i32 %263 to i64
%265 = getelementptr inbounds i32, i32* %262, i64 %264
%266 = load i32, i32* %265
%267 = load i32**, i32*** %11
%268 = load i32, i32* %13
%269 = sext i32 %268 to i64
%270 = getelementptr inbounds i32*, i32** %267, i64 %269
%271 = load i32*, i32** %270
%272 = load i32, i32* %14
%273 = sext i32 %272 to i64
%274 = getelementptr inbounds i32, i32* %271, i64 %273
store i32 %266, i32* %274
br label %275
275: ; preds = %257
%276 = load i32, i32* %14
%277 = add nsw i32 %276, 1
store i32 %277, i32* %14
br label %253
278: ; preds = %253
br label %279
279: ; preds = %278
%280 = load i32, i32* %13
%281 = add nsw i32 %280, 1
store i32 %281, i32* %13
br label %243
282: ; preds = %243
%283 = load double*, double** %24
%284 = load i32, i32* %8
%285 = call i32 @free_dvector(double* %283, i32 1, i32 %284)
%286 = load i32*, i32** %17
%287 = load i32, i32* %8
%288 = call i32 @free_ivector(i32* %286, i32 1, i32 %287)
ret void
}

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