#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__ malloc(int);
int *non_dominated_sorting(float **, int);
int **population_evolution(int **P, int **Q, float **objectives_functions_P,
                           float **objectives_functions_Q, int *fronts_P,
                           int number_of_individuals, int v_size) {
  int **PQ = (int **)malloc(2 * number_of_individuals * sizeof(int *));
  float **objectives_functions_PQ =
      (float **)malloc(2 * number_of_individuals * sizeof(float *));
  int iterator_individual_P = 0;
  int iterator_individual_Q = 0;
  int iterator_individual_position = 0;
  for (iterator_individual_P = 0; iterator_individual_P < number_of_individuals;
       iterator_individual_P++) {
    PQ[iterator_individual_P] = (int *)malloc(v_size * sizeof(int));
    objectives_functions_PQ[iterator_individual_P] =
        (float *)malloc(3 * sizeof(float));
    for (iterator_individual_position = 0;
         iterator_individual_position < v_size;
         iterator_individual_position++) {
      PQ[iterator_individual_P][iterator_individual_position] =
          P[iterator_individual_P][iterator_individual_position];
    }
    objectives_functions_PQ[iterator_individual_P][0] =
        objectives_functions_P[iterator_individual_P][0];
    objectives_functions_PQ[iterator_individual_P][1] =
        objectives_functions_P[iterator_individual_P][1];
    objectives_functions_PQ[iterator_individual_P][2] =
        objectives_functions_P[iterator_individual_P][2];
  }
  for (iterator_individual_P = number_of_individuals;
       iterator_individual_P < 2 * number_of_individuals;
       iterator_individual_P++) {
    PQ[iterator_individual_P] = (int *)malloc(v_size * sizeof(int));
    objectives_functions_PQ[iterator_individual_P] =
        (float *)malloc(3 * sizeof(float));
    for (iterator_individual_position = 0;
         iterator_individual_position < v_size;
         iterator_individual_position++) {
      PQ[iterator_individual_P][iterator_individual_position] =
          Q[iterator_individual_Q][iterator_individual_position];
    }
    objectives_functions_PQ[iterator_individual_P][0] =
        objectives_functions_Q[iterator_individual_Q][0];
    objectives_functions_PQ[iterator_individual_P][1] =
        objectives_functions_Q[iterator_individual_Q][1];
    objectives_functions_PQ[iterator_individual_P][2] =
        objectives_functions_Q[iterator_individual_Q][2];
    iterator_individual_Q++;
  }
  int *fronts_PQ =
      non_dominated_sorting(objectives_functions_PQ, number_of_individuals * 2);
  int *population_aux = (int *)malloc(v_size * sizeof(int));
  int iterator;
  int iterator_virtual;
  int iterator_P = 0;
  int actual_pareto = 0;
  int i, j;
  int iterator_solution;
  while (iterator_P < number_of_individuals) {
    actual_pareto++;
    for (iterator = 0; iterator < number_of_individuals * 2; iterator++) {
      if (fronts_PQ[iterator] == actual_pareto &&
          iterator_P < number_of_individuals) {
        if (objectives_functions_PQ[iterator][0] != 0 ||
            objectives_functions_PQ[iterator][1] != 0 ||
            objectives_functions_PQ[iterator][2] != 0) {
          objectives_functions_P[iterator_P][0] =
              objectives_functions_PQ[iterator][0];
          objectives_functions_P[iterator_P][1] =
              objectives_functions_PQ[iterator][1];
          objectives_functions_P[iterator_P][2] =
              objectives_functions_PQ[iterator][2];
          fronts_P[iterator_P] = fronts_PQ[iterator];
          for (iterator_virtual = 0; iterator_virtual < v_size;
               iterator_virtual++) {
            P[iterator_P][iterator_virtual] = PQ[iterator][iterator_virtual];
          }
          iterator_P++;
        }
      }
    }
  }
  return P;
}


x86 assembly (clang, -O0):
<population_evolution>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9d,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
shl    $0x1,%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x38(%rbp)
mov    -0x2c(%rbp),%eax
shl    $0x1,%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x44(%rbp)
movl   $0x0,-0x48(%rbp)
movl   $0x0,-0x4c(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    128c <population_evolution+0x16c>
movslq 0x10(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,%rdx
mov    -0x38(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    $0xc,%edi
call   1040 <malloc@plt>
mov    %rax,%rdx
mov    -0x40(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    121a <population_evolution+0xfa>
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x38(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    11da <population_evolution+0xba>
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  (%rax),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  %xmm0,(%rax)
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  0x4(%rax),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  %xmm0,0x4(%rax)
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  0x8(%rax),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  %xmm0,0x8(%rax)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1190 <population_evolution+0x70>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    -0x2c(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jge    139c <population_evolution+0x27c>
movslq 0x10(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,%rdx
mov    -0x38(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    $0xc,%edi
call   1040 <malloc@plt>
mov    %rax,%rdx
mov    -0x40(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1321 <population_evolution+0x201>
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x38(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    12e1 <population_evolution+0x1c1>
mov    -0x20(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  (%rax),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  %xmm0,(%rax)
mov    -0x20(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  0x4(%rax),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  %xmm0,0x4(%rax)
mov    -0x20(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  0x8(%rax),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  %xmm0,0x8(%rax)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1292 <population_evolution+0x172>
mov    -0x40(%rbp),%rdi
mov    -0x2c(%rbp),%esi
shl    $0x1,%esi
call   1030 <non_dominated_sorting@plt>
mov    %rax,-0x58(%rbp)
movslq 0x10(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x60(%rbp)
movl   $0x0,-0x6c(%rbp)
movl   $0x0,-0x70(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1571 <population_evolution+0x451>
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
mov    -0x2c(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jge    156c <population_evolution+0x44c>
mov    -0x58(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x70(%rbp),%eax
jne    1559 <population_evolution+0x439>
mov    -0x6c(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1559 <population_evolution+0x439>
mov    -0x40(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  (%rax),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    148a <population_evolution+0x36a>
jp     148a <population_evolution+0x36a>
mov    -0x40(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  0x4(%rax),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    148a <population_evolution+0x36a>
jp     148a <population_evolution+0x36a>
mov    -0x40(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  0x8(%rax),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    148a <population_evolution+0x36a>
jp     148a <population_evolution+0x36a>
jmp    1554 <population_evolution+0x434>
mov    -0x40(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  (%rax),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x6c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  %xmm0,(%rax)
mov    -0x40(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  0x4(%rax),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x6c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  %xmm0,0x4(%rax)
mov    -0x40(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  0x8(%rax),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x6c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  %xmm0,0x8(%rax)
mov    -0x58(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x28(%rbp),%rax
movslq -0x6c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    154b <population_evolution+0x42b>
mov    -0x38(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x6c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    150b <population_evolution+0x3eb>
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    1559 <population_evolution+0x439>
jmp    155e <population_evolution+0x43e>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    13ec <population_evolution+0x2cc>
jmp    13d0 <population_evolution+0x2b0>
mov    -0x8(%rbp),%rax
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<population_evolution>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
mov    %r9d,%r15d
mov    %r8,0x70(%rsp)
mov    %rcx,0x48(%rsp)
mov    %rdx,0x58(%rsp)
mov    %rsi,0x68(%rsp)
mov    %rdi,0x50(%rsp)
mov    0xb0(%rsp),%ebx
lea    (%r15,%r15,1),%eax
mov    %eax,0x1c(%rsp)
mov    %r9d,%ebp
shl    $0x4,%ebp
mov    %ebp,%edi
call   1040 <malloc@plt>
mov    %rax,0x10(%rsp)
mov    %ebp,%edi
call   1040 <malloc@plt>
mov    %rax,0x28(%rsp)
mov    %r15d,%eax
mov    %rax,0x20(%rsp)
mov    %ebx,%r13d
test   %r15d,%r15d
jle    13b1 <population_evolution+0x291>
mov    0xb0(%rsp),%eax
lea    0x0(,%rax,4),%eax
mov    %eax,0x8(%rsp)
mov    %r13d,%eax
and    $0xfffffff8,%eax
mov    %rax,0x40(%rsp)
add    $0xfffffffffffffff8,%rax
mov    %rax,0x38(%rsp)
mov    %rax,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
mov    %ecx,%r12d
and    $0x3,%r12d
movabs $0x3ffffffffffffffc,%rax
ff ff 3f
and    %rax,%rcx
mov    %rcx,0x60(%rsp)
mov    %r13d,%ebp
and    $0x3,%ebp
mov    %r12,0x30(%rsp)
shl    $0x5,%r12
xor    %r14d,%r14d
mov    %rbp,(%rsp)
jmp    1224 <population_evolution+0x104>
nopl   (%rax)
mov    0x58(%rsp),%rcx
mov    (%rcx,%r14,8),%rcx
movss  (%rcx),%xmm0
movss  %xmm0,(%rax)
movss  0x4(%rcx),%xmm0
movss  %xmm0,0x4(%rax)
movss  0x8(%rcx),%xmm0
movss  %xmm0,0x8(%rax)
add    $0x1,%r14
cmp    0x20(%rsp),%r14
je     13b1 <population_evolution+0x291>
mov    0x8(%rsp),%edi
call   1040 <malloc@plt>
mov    0x10(%rsp),%rcx
mov    %rax,(%rcx,%r14,8)
mov    $0xc,%edi
call   1040 <malloc@plt>
mov    0x28(%rsp),%rcx
mov    %rax,(%rcx,%r14,8)
mov    0xb0(%rsp),%ecx
test   %ecx,%ecx
jle    11f0 <population_evolution+0xd0>
mov    0x50(%rsp),%rcx
mov    (%rcx,%r14,8),%rcx
mov    0x10(%rsp),%rdx
mov    (%rdx,%r14,8),%rdx
mov    0xb0(%rsp),%esi
cmp    $0x8,%esi
jb     1284 <population_evolution+0x164>
lea    (%rcx,%r13,4),%rsi
cmp    %rsi,%rdx
jae    12ec <population_evolution+0x1cc>
lea    (%rdx,%r13,4),%rsi
cmp    %rsi,%rcx
jae    12ec <population_evolution+0x1cc>
xor    %esi,%esi
mov    %rsi,%rdi
not    %rdi
add    %r13,%rdi
test   %rbp,%rbp
je     12b0 <population_evolution+0x190>
mov    %rbp,%rbx
nopw   0x0(%rax,%rax,1)
mov    (%rcx,%rsi,4),%ebp
mov    %ebp,(%rdx,%rsi,4)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rbx
jne    12a0 <population_evolution+0x180>
cmp    $0x3,%rdi
mov    (%rsp),%rbp
jb     11f0 <population_evolution+0xd0>
xchg   %ax,%ax
mov    (%rcx,%rsi,4),%edi
mov    %edi,(%rdx,%rsi,4)
mov    0x4(%rcx,%rsi,4),%edi
mov    %edi,0x4(%rdx,%rsi,4)
mov    0x8(%rcx,%rsi,4),%edi
mov    %edi,0x8(%rdx,%rsi,4)
mov    0xc(%rcx,%rsi,4),%edi
mov    %edi,0xc(%rdx,%rsi,4)
add    $0x4,%rsi
cmp    %rsi,%r13
jne    12c0 <population_evolution+0x1a0>
jmp    11f0 <population_evolution+0xd0>
cmpq   $0x18,0x38(%rsp)
jae    12f8 <population_evolution+0x1d8>
xor    %esi,%esi
jmp    1358 <population_evolution+0x238>
mov    0x60(%rsp),%rdi
xor    %esi,%esi
nop
movups (%rcx,%rsi,4),%xmm0
movups 0x10(%rcx,%rsi,4),%xmm1
movups %xmm0,(%rdx,%rsi,4)
movups %xmm1,0x10(%rdx,%rsi,4)
movups 0x20(%rcx,%rsi,4),%xmm0
movups 0x30(%rcx,%rsi,4),%xmm1
movups %xmm0,0x20(%rdx,%rsi,4)
movups %xmm1,0x30(%rdx,%rsi,4)
movups 0x40(%rcx,%rsi,4),%xmm0
movups 0x50(%rcx,%rsi,4),%xmm1
movups %xmm0,0x40(%rdx,%rsi,4)
movups %xmm1,0x50(%rdx,%rsi,4)
movups 0x60(%rcx,%rsi,4),%xmm0
movups 0x70(%rcx,%rsi,4),%xmm1
movups %xmm0,0x60(%rdx,%rsi,4)
movups %xmm1,0x70(%rdx,%rsi,4)
add    $0x20,%rsi
add    $0xfffffffffffffffc,%rdi
jne    1300 <population_evolution+0x1e0>
cmpq   $0x0,0x30(%rsp)
je     139b <population_evolution+0x27b>
lea    (%rdx,%rsi,4),%rdi
add    $0x10,%rdi
lea    (%rcx,%rsi,4),%rsi
add    $0x10,%rsi
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups -0x10(%rsi,%rbx,1),%xmm0
movups (%rsi,%rbx,1),%xmm1
movups %xmm0,-0x10(%rdi,%rbx,1)
movups %xmm1,(%rdi,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%r12
jne    1380 <population_evolution+0x260>
mov    0x40(%rsp),%rdi
mov    %rdi,%rsi
cmp    %r13,%rdi
je     11f0 <population_evolution+0xd0>
jmp    1286 <population_evolution+0x166>
mov    0xb0(%rsp),%eax
lea    0x0(,%rax,4),%ebp
cmp    %r15d,0x1c(%rsp)
jle    15f0 <population_evolution+0x4d0>
movslq %r15d,%r14
mov    %r13d,%eax
and    $0xfffffff8,%eax
mov    %rax,(%rsp)
add    $0xfffffffffffffff8,%rax
mov    %rax,0x40(%rsp)
mov    %rax,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
mov    %ecx,%edx
and    $0x3,%edx
movabs $0x3ffffffffffffffc,%rax
ff ff 3f
and    %rax,%rcx
mov    %rcx,0x30(%rsp)
mov    %r13d,%eax
and    $0x3,%eax
mov    %rax,0x8(%rsp)
mov    %rdx,0x38(%rsp)
mov    %rdx,%r9
shl    $0x5,%r9
xor    %r12d,%r12d
jmp    1458 <population_evolution+0x338>
xchg   %ax,%ax
mov    0x48(%rsp),%rcx
mov    (%rcx,%r12,8),%rcx
movss  (%rcx),%xmm0
movss  %xmm0,(%rax)
movss  0x4(%rcx),%xmm0
movss  %xmm0,0x4(%rax)
movss  0x8(%rcx),%xmm0
movss  %xmm0,0x8(%rax)
add    $0x1,%r12
add    $0x1,%r14
cmp    0x20(%rsp),%r12
je     15f0 <population_evolution+0x4d0>
mov    %ebp,%edi
mov    %r9,%rbx
call   1040 <malloc@plt>
mov    0x10(%rsp),%rcx
mov    %rax,(%rcx,%r14,8)
mov    $0xc,%edi
call   1040 <malloc@plt>
mov    %rbx,%r9
mov    0x28(%rsp),%rcx
mov    %rax,(%rcx,%r14,8)
mov    0xb0(%rsp),%ecx
test   %ecx,%ecx
jle    1420 <population_evolution+0x300>
mov    0x68(%rsp),%rcx
mov    (%rcx,%r12,8),%rcx
mov    0x10(%rsp),%rdx
mov    (%rdx,%r14,8),%rdx
mov    0xb0(%rsp),%esi
cmp    $0x8,%esi
jb     14bc <population_evolution+0x39c>
lea    (%rcx,%r13,4),%rsi
cmp    %rsi,%rdx
jae    152c <population_evolution+0x40c>
lea    (%rdx,%r13,4),%rsi
cmp    %rsi,%rcx
jae    152c <population_evolution+0x40c>
xor    %esi,%esi
mov    %ebp,%r8d
mov    %rsi,%rdi
not    %rdi
add    %r13,%rdi
mov    0x8(%rsp),%rbx
test   %rbx,%rbx
je     14f0 <population_evolution+0x3d0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%rcx,%rsi,4),%ebp
mov    %ebp,(%rdx,%rsi,4)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rbx
jne    14e0 <population_evolution+0x3c0>
cmp    $0x3,%rdi
mov    %r8d,%ebp
jb     1420 <population_evolution+0x300>
nopl   (%rax)
mov    (%rcx,%rsi,4),%edi
mov    %edi,(%rdx,%rsi,4)
mov    0x4(%rcx,%rsi,4),%edi
mov    %edi,0x4(%rdx,%rsi,4)
mov    0x8(%rcx,%rsi,4),%edi
mov    %edi,0x8(%rdx,%rsi,4)
mov    0xc(%rcx,%rsi,4),%edi
mov    %edi,0xc(%rdx,%rsi,4)
add    $0x4,%rsi
cmp    %rsi,%r13
jne    1500 <population_evolution+0x3e0>
jmp    1420 <population_evolution+0x300>
cmpq   $0x18,0x40(%rsp)
jae    1538 <population_evolution+0x418>
xor    %esi,%esi
jmp    1598 <population_evolution+0x478>
mov    0x30(%rsp),%rdi
xor    %esi,%esi
nop
movups (%rcx,%rsi,4),%xmm0
movups 0x10(%rcx,%rsi,4),%xmm1
movups %xmm0,(%rdx,%rsi,4)
movups %xmm1,0x10(%rdx,%rsi,4)
movups 0x20(%rcx,%rsi,4),%xmm0
movups 0x30(%rcx,%rsi,4),%xmm1
movups %xmm0,0x20(%rdx,%rsi,4)
movups %xmm1,0x30(%rdx,%rsi,4)
movups 0x40(%rcx,%rsi,4),%xmm0
movups 0x50(%rcx,%rsi,4),%xmm1
movups %xmm0,0x40(%rdx,%rsi,4)
movups %xmm1,0x50(%rdx,%rsi,4)
movups 0x60(%rcx,%rsi,4),%xmm0
movups 0x70(%rcx,%rsi,4),%xmm1
movups %xmm0,0x60(%rdx,%rsi,4)
movups %xmm1,0x70(%rdx,%rsi,4)
add    $0x20,%rsi
add    $0xfffffffffffffffc,%rdi
jne    1540 <population_evolution+0x420>
cmpq   $0x0,0x38(%rsp)
je     15db <population_evolution+0x4bb>
lea    (%rdx,%rsi,4),%rdi
add    $0x10,%rdi
lea    (%rcx,%rsi,4),%rsi
add    $0x10,%rsi
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups -0x10(%rsi,%rbx,1),%xmm0
movups (%rsi,%rbx,1),%xmm1
movups %xmm0,-0x10(%rdi,%rbx,1)
movups %xmm1,(%rdi,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%r9
jne    15c0 <population_evolution+0x4a0>
mov    (%rsp),%rdi
mov    %rdi,%rsi
cmp    %r13,%rdi
je     1420 <population_evolution+0x300>
jmp    14be <population_evolution+0x39e>
mov    0x28(%rsp),%rdi
mov    0x1c(%rsp),%ebx
mov    %ebx,%esi
call   1030 <non_dominated_sorting@plt>
mov    %rax,%r12
mov    %ebp,%edi
call   1040 <malloc@plt>
test   %r15d,%r15d
jle    1881 <population_evolution+0x761>
cmp    $0x2,%ebx
mov    $0x1,%r14d
cmovge %ebx,%r14d
mov    %r13d,%eax
and    $0xfffffff8,%eax
mov    %rax,0x20(%rsp)
add    $0xfffffffffffffff8,%rax
mov    %rax,0x8(%rsp)
mov    %rax,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
mov    %ecx,%edi
and    $0x3,%edi
movabs $0x3ffffffffffffffc,%rax
ff ff 3f
and    %rax,%rcx
mov    %rcx,(%rsp)
mov    %r13d,%r10d
and    $0x3,%r10d
mov    %rdi,0x48(%rsp)
shl    $0x5,%rdi
xor    %edx,%edx
xorps  %xmm0,%xmm0
xor    %ecx,%ecx
jmp    1679 <population_evolution+0x559>
xchg   %ax,%ax
cmp    %r15d,%ecx
jge    1881 <population_evolution+0x761>
add    $0x1,%edx
xor    %ebp,%ebp
jmp    168c <population_evolution+0x56c>
add    $0x1,%ecx
add    $0x1,%rbp
cmp    %r14,%rbp
je     1670 <population_evolution+0x550>
cmp    %edx,(%r12,%rbp,4)
jne    1683 <population_evolution+0x563>
cmp    %r15d,%ecx
jge    1683 <population_evolution+0x563>
mov    0x28(%rsp),%rax
mov    (%rax,%rbp,8),%rsi
movss  (%rsi),%xmm1
ucomiss %xmm0,%xmm1
jne    16d0 <population_evolution+0x5b0>
jp     16d0 <population_evolution+0x5b0>
movss  0x4(%rsi),%xmm2
ucomiss %xmm0,%xmm2
jne    16d0 <population_evolution+0x5b0>
jp     16d0 <population_evolution+0x5b0>
movss  0x8(%rsi),%xmm2
ucomiss %xmm0,%xmm2
jne    16d0 <population_evolution+0x5b0>
jnp    1683 <population_evolution+0x563>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movslq %ecx,%rbx
mov    0x58(%rsp),%rax
mov    (%rax,%rbx,8),%rax
movss  %xmm1,(%rax)
movss  0x4(%rsi),%xmm1
movss  %xmm1,0x4(%rax)
movss  0x8(%rsi),%xmm1
movss  %xmm1,0x8(%rax)
mov    0x70(%rsp),%rax
mov    %edx,(%rax,%rbx,4)
mov    0xb0(%rsp),%eax
test   %eax,%eax
jle    1680 <population_evolution+0x560>
mov    0x10(%rsp),%rax
mov    (%rax,%rbp,8),%r8
mov    0x50(%rsp),%rax
mov    (%rax,%rbx,8),%r9
mov    0xb0(%rsp),%eax
cmp    $0x8,%eax
jb     173b <population_evolution+0x61b>
lea    (%r8,%r13,4),%rax
cmp    %rax,%r9
jae    17a4 <population_evolution+0x684>
lea    (%r9,%r13,4),%rax
cmp    %rax,%r8
jae    17a4 <population_evolution+0x684>
xor    %r11d,%r11d
mov    %r11,%rsi
not    %rsi
add    %r13,%rsi
test   %r10,%r10
je     1762 <population_evolution+0x642>
mov    %r10,%rbx
nop
mov    (%r8,%r11,4),%eax
mov    %eax,(%r9,%r11,4)
add    $0x1,%r11
add    $0xffffffffffffffff,%rbx
jne    1750 <population_evolution+0x630>
cmp    $0x3,%rsi
jb     1680 <population_evolution+0x560>
nopl   0x0(%rax)
mov    (%r8,%r11,4),%eax
mov    %eax,(%r9,%r11,4)
mov    0x4(%r8,%r11,4),%eax
mov    %eax,0x4(%r9,%r11,4)
mov    0x8(%r8,%r11,4),%eax
mov    %eax,0x8(%r9,%r11,4)
mov    0xc(%r8,%r11,4),%eax
mov    %eax,0xc(%r9,%r11,4)
add    $0x4,%r11
cmp    %r11,%r13
jne    1770 <population_evolution+0x650>
jmp    1680 <population_evolution+0x560>
cmpq   $0x18,0x8(%rsp)
jae    17b0 <population_evolution+0x690>
xor    %ebx,%ebx
jmp    1828 <population_evolution+0x708>
mov    (%rsp),%rsi
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
movups (%r8,%rbx,4),%xmm1
movups 0x10(%r8,%rbx,4),%xmm2
movups %xmm1,(%r9,%rbx,4)
movups %xmm2,0x10(%r9,%rbx,4)
movups 0x20(%r8,%rbx,4),%xmm1
movups 0x30(%r8,%rbx,4),%xmm2
movups %xmm1,0x20(%r9,%rbx,4)
movups %xmm2,0x30(%r9,%rbx,4)
movups 0x40(%r8,%rbx,4),%xmm1
movups 0x50(%r8,%rbx,4),%xmm2
movups %xmm1,0x40(%r9,%rbx,4)
movups %xmm2,0x50(%r9,%rbx,4)
movups 0x60(%r8,%rbx,4),%xmm1
movups 0x70(%r8,%rbx,4),%xmm2
movups %xmm1,0x60(%r9,%rbx,4)
movups %xmm2,0x70(%r9,%rbx,4)
add    $0x20,%rbx
add    $0xfffffffffffffffc,%rsi
jne    17c0 <population_evolution+0x6a0>
cmpq   $0x0,0x48(%rsp)
je     186b <population_evolution+0x74b>
lea    (%r9,%rbx,4),%rsi
add    $0x10,%rsi
lea    (%r8,%rbx,4),%rbx
add    $0x10,%rbx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups -0x10(%rbx,%rax,1),%xmm1
movups (%rbx,%rax,1),%xmm2
movups %xmm1,-0x10(%rsi,%rax,1)
movups %xmm2,(%rsi,%rax,1)
add    $0x20,%rax
cmp    %rax,%rdi
jne    1850 <population_evolution+0x730>
mov    0x20(%rsp),%rax
mov    %rax,%r11
cmp    %r13,%rax
je     1680 <population_evolution+0x560>
jmp    173e <population_evolution+0x61e>
mov    0x50(%rsp),%rax
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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