#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 */
unsigned long long current_time_ns();
int /*<<< orphan*/ lud_diagonal_omp(float *, int, int);
int /*<<< orphan*/ printf(char *, unsigned long long const);
void lud_omp(float *a, int size) {
  const unsigned long long full_program_start = current_time_ns();
  {
    int offset, chunk_idx, size_inter, chunks_in_inter_row, chunks_per_inter;
    for (offset = 0; offset < size - 16; offset += 16) {
      lud_diagonal_omp(a, size, offset);
      size_inter = size - offset - 16;
      chunks_in_inter_row = size_inter / 16;
      {
        const unsigned long long parallel_for_start = current_time_ns();
#pragma omp parallel for default(none) private(chunk_idx)                      \
    firstprivate(size, a)                                                      \
        shared(chunks_per_inter, chunks_in_inter_row, offset)
        for (chunk_idx = 0; chunk_idx < chunks_in_inter_row; chunk_idx++) {
          int i, j, k, i_global, j_global, i_here, j_here;
          float sum;
          float temp[16 * 16] __attribute__((aligned(64)));
          for (i = 0; i < 16; i++) {
#pragma omp simd
            for (j = 0; j < 16; j++) {
              temp[i * 16 + j] = a[size * (i + offset) + offset + j];
            }
          }
          i_global = offset;
          j_global = offset;
          j_global += 16 * (chunk_idx + 1);
          for (j = 0; j < 16; j++) {
            for (i = 0; i < 16; i++) {
              sum = 0.f;
              for (k = 0; k < i; k++) {
                sum += temp[16 * i + k] *
                       a[(i_global + k) * size + (j_global + j)];
              }
              i_here = i_global + i;
              j_here = j_global + j;
              a[i_here * size + j_here] = a[i_here * size + j_here] - sum;
            }
          }
          j_global = offset;
          i_global += 16 * (chunk_idx + 1);
          for (i = 0; i < 16; i++) {
            for (j = 0; j < 16; j++) {
              sum = 0.f;
              for (k = 0; k < j; k++) {
                sum += a[(i_global + i) * size + (j_global + k)] *
                       temp[16 * k + j];
              }
              i_here = i_global + i;
              j_here = j_global + j;
              a[size * i_here + j_here] = (a[size * i_here + j_here] - sum) /
                                          a[size * (offset + j) + offset + j];
            }
          }
        };
        const unsigned long long parallel_for_end = current_time_ns();
        printf("pragma52_omp_parallel %llu ns\n",
               parallel_for_end - parallel_for_start);
      }
      chunks_per_inter = chunks_in_inter_row * chunks_in_inter_row;
      {
        const unsigned long long parallel_for_start = current_time_ns();
#pragma omp parallel for schedule(auto) default(none) private(chunk_idx)       \
    firstprivate(size, a)                                                      \
        shared(chunks_per_inter, chunks_in_inter_row, offset)
        for (chunk_idx = 0; chunk_idx < chunks_per_inter; chunk_idx++) {
          int i, j, k, i_global, j_global;
          float temp_top[16 * 16] __attribute__((aligned(64)));
          float temp_left[16 * 16] __attribute__((aligned(64)));
          float sum[16] __attribute__((aligned(64))) = {0.f};
          i_global = offset + 16 * (1 + chunk_idx / chunks_in_inter_row);
          j_global = offset + 16 * (1 + chunk_idx % chunks_in_inter_row);
          for (i = 0; i < 16; i++) {
#pragma omp simd
            for (j = 0; j < 16; j++) {
              temp_top[i * 16 + j] = a[size * (i + offset) + j + j_global];
              temp_left[i * 16 + j] = a[size * (i + i_global) + offset + j];
            }
          }
          for (i = 0; i < 16; i++) {
            for (k = 0; k < 16; k++) {
#pragma omp simd
              for (j = 0; j < 16; j++) {
                sum[j] += temp_left[16 * i + k] * temp_top[16 * k + j];
              }
            }
#pragma omp simd
            for (j = 0; j < 16; j++) {
              a[(i + i_global) * size + (j + j_global)] -= sum[j];
              sum[j] = 0.f;
            }
          }
        };
        const unsigned long long parallel_for_end = current_time_ns();
        printf("pragma106_omp_parallel %llu ns\n",
               parallel_for_end - parallel_for_start);
      }
    }
    lud_diagonal_omp(a, size, offset);
  };
  const unsigned long long full_program_end = current_time_ns();
  printf("full_program %llu ns\n", full_program_end - full_program_start);
}


x86 assembly (clang, -O0):
<lud_omp>:
push   %rbp
mov    %rsp,%rbp
and    $0xffffffffffffffc0,%rsp
sub    $0xd40,%rsp
mov    %rdi,0xd28(%rsp)
mov    %esi,0xd24(%rsp)
mov    $0x0,%al
call   1060 <current_time_ns@plt>
mov    %rax,0xd18(%rsp)
movl   $0x0,0xd14(%rsp)
mov    0xd14(%rsp),%eax
mov    0xd24(%rsp),%ecx
sub    $0x10,%ecx
cmp    %ecx,%eax
jge    1a3f <lud_omp+0x8ff>
mov    0xd28(%rsp),%rdi
mov    0xd24(%rsp),%esi
mov    0xd14(%rsp),%edx
call   1030 <lud_diagonal_omp@plt>
mov    0xd24(%rsp),%eax
sub    0xd14(%rsp),%eax
sub    $0x10,%eax
mov    %eax,0xd0c(%rsp)
mov    0xd0c(%rsp),%eax
mov    $0x10,%ecx
cltd
idiv   %ecx
mov    %eax,0xd08(%rsp)
mov    $0x0,%al
call   1060 <current_time_ns@plt>
mov    %rax,0xcf8(%rsp)
movl   $0x0,0xd10(%rsp)
mov    0xd10(%rsp),%eax
cmp    0xd08(%rsp),%eax
jge    168c <lud_omp+0x54c>
movl   $0x0,0xcf4(%rsp)
cmpl   $0x10,0xcf4(%rsp)
10
jge    12bd <lud_omp+0x17d>
movl   $0x0,0xcf0(%rsp)
cmpl   $0x10,0xcf0(%rsp)
10
jge    12a2 <lud_omp+0x162>
mov    0xd28(%rsp),%rax
mov    0xd24(%rsp),%ecx
mov    0xcf4(%rsp),%edx
add    0xd14(%rsp),%edx
imul   %edx,%ecx
add    0xd14(%rsp),%ecx
add    0xcf0(%rsp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0xcf4(%rsp),%eax
shl    $0x4,%eax
add    0xcf0(%rsp),%eax
cltq
movss  %xmm0,0x8c0(%rsp,%rax,4)
mov    0xcf0(%rsp),%eax
add    $0x1,%eax
mov    %eax,0xcf0(%rsp)
jmp    122c <lud_omp+0xec>
jmp    12a7 <lud_omp+0x167>
mov    0xcf4(%rsp),%eax
add    $0x1,%eax
mov    %eax,0xcf4(%rsp)
jmp    1213 <lud_omp+0xd3>
mov    0xd14(%rsp),%eax
mov    %eax,0xce8(%rsp)
mov    0xd14(%rsp),%eax
mov    %eax,0xce4(%rsp)
mov    0xd10(%rsp),%eax
add    $0x1,%eax
shl    $0x4,%eax
add    0xce4(%rsp),%eax
mov    %eax,0xce4(%rsp)
movl   $0x0,0xcf0(%rsp)
cmpl   $0x10,0xcf0(%rsp)
10
jge    1483 <lud_omp+0x343>
movl   $0x0,0xcf4(%rsp)
cmpl   $0x10,0xcf4(%rsp)
10
jge    1468 <lud_omp+0x328>
xorps  %xmm0,%xmm0
movss  %xmm0,0xcd8(%rsp)
movl   $0x0,0xcec(%rsp)
mov    0xcec(%rsp),%eax
cmp    0xcf4(%rsp),%eax
jge    13d3 <lud_omp+0x293>
mov    0xcf4(%rsp),%eax
shl    $0x4,%eax
add    0xcec(%rsp),%eax
cltq
movss  0x8c0(%rsp,%rax,4),%xmm0
mov    0xd28(%rsp),%rax
mov    0xce8(%rsp),%ecx
add    0xcec(%rsp),%ecx
imul   0xd24(%rsp),%ecx
mov    0xce4(%rsp),%edx
add    0xcf0(%rsp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movss  0xcd8(%rsp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0xcd8(%rsp)
mov    0xcec(%rsp),%eax
add    $0x1,%eax
mov    %eax,0xcec(%rsp)
jmp    133d <lud_omp+0x1fd>
mov    0xce8(%rsp),%eax
add    0xcf4(%rsp),%eax
mov    %eax,0xce0(%rsp)
mov    0xce4(%rsp),%eax
add    0xcf0(%rsp),%eax
mov    %eax,0xcdc(%rsp)
mov    0xd28(%rsp),%rax
mov    0xce0(%rsp),%ecx
imul   0xd24(%rsp),%ecx
add    0xcdc(%rsp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
subss  0xcd8(%rsp),%xmm0
mov    0xd28(%rsp),%rax
mov    0xce0(%rsp),%ecx
imul   0xd24(%rsp),%ecx
add    0xcdc(%rsp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0xcf4(%rsp),%eax
add    $0x1,%eax
mov    %eax,0xcf4(%rsp)
jmp    1318 <lud_omp+0x1d8>
jmp    146d <lud_omp+0x32d>
mov    0xcf0(%rsp),%eax
add    $0x1,%eax
mov    %eax,0xcf0(%rsp)
jmp    12ff <lud_omp+0x1bf>
mov    0xd14(%rsp),%eax
mov    %eax,0xce4(%rsp)
mov    0xd10(%rsp),%eax
add    $0x1,%eax
shl    $0x4,%eax
add    0xce8(%rsp),%eax
mov    %eax,0xce8(%rsp)
movl   $0x0,0xcf4(%rsp)
cmpl   $0x10,0xcf4(%rsp)
10
jge    1671 <lud_omp+0x531>
movl   $0x0,0xcf0(%rsp)
cmpl   $0x10,0xcf0(%rsp)
10
jge    1656 <lud_omp+0x516>
xorps  %xmm0,%xmm0
movss  %xmm0,0xcd8(%rsp)
movl   $0x0,0xcec(%rsp)
mov    0xcec(%rsp),%eax
cmp    0xcf0(%rsp),%eax
jge    158b <lud_omp+0x44b>
mov    0xd28(%rsp),%rax
mov    0xce8(%rsp),%ecx
add    0xcf4(%rsp),%ecx
imul   0xd24(%rsp),%ecx
mov    0xce4(%rsp),%edx
add    0xcec(%rsp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0xcec(%rsp),%eax
shl    $0x4,%eax
add    0xcf0(%rsp),%eax
cltq
movss  0x8c0(%rsp,%rax,4),%xmm2
movss  0xcd8(%rsp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0xcd8(%rsp)
mov    0xcec(%rsp),%eax
add    $0x1,%eax
mov    %eax,0xcec(%rsp)
jmp    14f5 <lud_omp+0x3b5>
mov    0xce8(%rsp),%eax
add    0xcf4(%rsp),%eax
mov    %eax,0xce0(%rsp)
mov    0xce4(%rsp),%eax
add    0xcf0(%rsp),%eax
mov    %eax,0xcdc(%rsp)
mov    0xd28(%rsp),%rax
mov    0xd24(%rsp),%ecx
imul   0xce0(%rsp),%ecx
add    0xcdc(%rsp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
subss  0xcd8(%rsp),%xmm0
mov    0xd28(%rsp),%rax
mov    0xd24(%rsp),%ecx
mov    0xd14(%rsp),%edx
add    0xcf0(%rsp),%edx
imul   %edx,%ecx
add    0xd14(%rsp),%ecx
add    0xcf0(%rsp),%ecx
movslq %ecx,%rcx
divss  (%rax,%rcx,4),%xmm0
mov    0xd28(%rsp),%rax
mov    0xd24(%rsp),%ecx
imul   0xce0(%rsp),%ecx
add    0xcdc(%rsp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0xcf0(%rsp),%eax
add    $0x1,%eax
mov    %eax,0xcf0(%rsp)
jmp    14d0 <lud_omp+0x390>
jmp    165b <lud_omp+0x51b>
mov    0xcf4(%rsp),%eax
add    $0x1,%eax
mov    %eax,0xcf4(%rsp)
jmp    14b7 <lud_omp+0x377>
jmp    1676 <lud_omp+0x536>
mov    0xd10(%rsp),%eax
add    $0x1,%eax
mov    %eax,0xd10(%rsp)
jmp    11f4 <lud_omp+0xb4>
mov    $0x0,%al
call   1060 <current_time_ns@plt>
mov    %rax,0x8b8(%rsp)
mov    0x8b8(%rsp),%rsi
sub    0xcf8(%rsp),%rsi
lea    0x94e(%rip),%rdi
call   1040 <printf@plt>
mov    0xd08(%rsp),%eax
imul   0xd08(%rsp),%eax
mov    %eax,0xd04(%rsp)
mov    $0x0,%al
call   1060 <current_time_ns@plt>
mov    %rax,0x8b0(%rsp)
movl   $0x0,0xd10(%rsp)
mov    0xd10(%rsp),%eax
cmp    0xd04(%rsp),%eax
jge    1a04 <lud_omp+0x8c4>
lea    0x40(%rsp),%rdi
xor    %esi,%esi
mov    $0x40,%edx
call   1050 <memset@plt>
mov    0xd14(%rsp),%eax
mov    %eax,0x28(%rsp)
mov    0xd10(%rsp),%eax
cltd
idivl  0xd08(%rsp)
mov    %eax,%ecx
mov    0x28(%rsp),%eax
add    $0x1,%ecx
shl    $0x4,%ecx
add    %ecx,%eax
mov    %eax,0x8a0(%rsp)
mov    0xd14(%rsp),%eax
mov    %eax,0x2c(%rsp)
mov    0xd10(%rsp),%eax
cltd
idivl  0xd08(%rsp)
mov    0x2c(%rsp),%eax
mov    %edx,%ecx
add    $0x1,%ecx
shl    $0x4,%ecx
add    %ecx,%eax
mov    %eax,0x89c(%rsp)
movl   $0x0,0x8ac(%rsp)
cmpl   $0x10,0x8ac(%rsp)
10
jge    1871 <lud_omp+0x731>
movl   $0x0,0x8a8(%rsp)
cmpl   $0x10,0x8a8(%rsp)
10
jge    1856 <lud_omp+0x716>
mov    0xd28(%rsp),%rax
mov    0xd24(%rsp),%ecx
mov    0x8ac(%rsp),%edx
add    0xd14(%rsp),%edx
imul   %edx,%ecx
add    0x8a8(%rsp),%ecx
add    0x89c(%rsp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x8ac(%rsp),%eax
shl    $0x4,%eax
add    0x8a8(%rsp),%eax
cltq
movss  %xmm0,0x480(%rsp,%rax,4)
mov    0xd28(%rsp),%rax
mov    0xd24(%rsp),%ecx
mov    0x8ac(%rsp),%edx
add    0x8a0(%rsp),%edx
imul   %edx,%ecx
add    0xd14(%rsp),%ecx
add    0x8a8(%rsp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x8ac(%rsp),%eax
shl    $0x4,%eax
add    0x8a8(%rsp),%eax
cltq
movss  %xmm0,0x80(%rsp,%rax,4)
mov    0x8a8(%rsp),%eax
add    $0x1,%eax
mov    %eax,0x8a8(%rsp)
jmp    178e <lud_omp+0x64e>
jmp    185b <lud_omp+0x71b>
mov    0x8ac(%rsp),%eax
add    $0x1,%eax
mov    %eax,0x8ac(%rsp)
jmp    1775 <lud_omp+0x635>
movl   $0x0,0x8ac(%rsp)
cmpl   $0x10,0x8ac(%rsp)
10
jge    19e9 <lud_omp+0x8a9>
movl   $0x0,0x8a4(%rsp)
cmpl   $0x10,0x8a4(%rsp)
10
jge    1941 <lud_omp+0x801>
movl   $0x0,0x8a8(%rsp)
cmpl   $0x10,0x8a8(%rsp)
10
jge    1926 <lud_omp+0x7e6>
mov    0x8ac(%rsp),%eax
shl    $0x4,%eax
add    0x8a4(%rsp),%eax
cltq
movss  0x80(%rsp,%rax,4),%xmm0
mov    0x8a4(%rsp),%eax
shl    $0x4,%eax
add    0x8a8(%rsp),%eax
cltq
movss  0x480(%rsp,%rax,4),%xmm2
movslq 0x8a8(%rsp),%rax
movss  0x40(%rsp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x40(%rsp,%rax,4)
mov    0x8a8(%rsp),%eax
add    $0x1,%eax
mov    %eax,0x8a8(%rsp)
jmp    18ae <lud_omp+0x76e>
jmp    192b <lud_omp+0x7eb>
mov    0x8a4(%rsp),%eax
add    $0x1,%eax
mov    %eax,0x8a4(%rsp)
jmp    1895 <lud_omp+0x755>
movl   $0x0,0x8a8(%rsp)
cmpl   $0x10,0x8a8(%rsp)
10
jge    19ce <lud_omp+0x88e>
movslq 0x8a8(%rsp),%rax
movss  0x40(%rsp,%rax,4),%xmm1
mov    0xd28(%rsp),%rax
mov    0x8ac(%rsp),%ecx
add    0x8a0(%rsp),%ecx
imul   0xd24(%rsp),%ecx
mov    0x8a8(%rsp),%edx
add    0x89c(%rsp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movslq 0x8a8(%rsp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x40(%rsp,%rax,4)
mov    0x8a8(%rsp),%eax
add    $0x1,%eax
mov    %eax,0x8a8(%rsp)
jmp    194c <lud_omp+0x80c>
jmp    19d3 <lud_omp+0x893>
mov    0x8ac(%rsp),%eax
add    $0x1,%eax
mov    %eax,0x8ac(%rsp)
jmp    187c <lud_omp+0x73c>
jmp    19ee <lud_omp+0x8ae>
mov    0xd10(%rsp),%eax
add    $0x1,%eax
mov    %eax,0xd10(%rsp)
jmp    16e7 <lud_omp+0x5a7>
mov    $0x0,%al
call   1060 <current_time_ns@plt>
mov    %rax,0x38(%rsp)
mov    0x38(%rsp),%rsi
sub    0x8b0(%rsp),%rsi
lea    0x5fb(%rip),%rdi
call   1040 <printf@plt>
mov    0xd14(%rsp),%eax
add    $0x10,%eax
mov    %eax,0xd14(%rsp)
jmp    1178 <lud_omp+0x38>
mov    0xd28(%rsp),%rdi
mov    0xd24(%rsp),%esi
mov    0xd14(%rsp),%edx
call   1030 <lud_diagonal_omp@plt>
mov    $0x0,%al
call   1060 <current_time_ns@plt>
mov    %rax,0x30(%rsp)
mov    0x30(%rsp),%rsi
sub    0xd18(%rsp),%rsi
lea    0x5c5(%rip),%rdi
call   1040 <printf@plt>
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<lud_omp>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
and    $0xffffffffffffffc0,%rsp
sub    $0xa80,%rsp
mov    %esi,%r14d
mov    %rdi,%r12
xor    %eax,%eax
call   1050 <current_time_ns@plt>
xor    %edx,%edx
mov    %rax,%rbx
cmp    $0x11,%r14d
jl     2019 <lud_omp+0xee9>
mov    %rbx,0x118(%rsp)
lea    -0x10(%r14),%eax
movabs $0x200000000,%r13
mov    %r14d,%ecx
shl    $0x4,%ecx
add    $0x10,%ecx
mov    %ecx,0x1c(%rsp)
mov    %r14d,%ecx
mov    %eax,0x7c(%rsp)
mov    %eax,%eax
mov    %rax,0x198(%rsp)
lea    0x0(,%rcx,8),%r15
mov    %r15,%rax
sub    %rcx,%rax
mov    %rax,0x180(%rsp)
mov    %rcx,%rax
shl    $0x4,%rax
sub    %rcx,%rax
sub    %rcx,%rax
mov    %rax,0x178(%rsp)
mov    %rcx,%rax
shl    $0x6,%rax
add    $0x40,%rax
mov    %rax,0x190(%rsp)
mov    %rcx,%rax
shl    $0x24,%rax
movabs $0x100000000,%rdx
or     %rax,%rdx
mov    %rdx,0x110(%rsp)
movabs $0x1000000000,%rdx
add    %rax,%rdx
mov    %rdx,0x188(%rsp)
mov    %rcx,%rdx
shl    $0x20,%rdx
mov    %rdx,0x30(%rsp)
lea    (%rcx,%rcx,1),%rdx
lea    (%rcx,%rcx,2),%r8
lea    0x0(,%rcx,4),%rdi
lea    (%rcx,%rcx,4),%rbx
lea    (%rdx,%rdx,2),%rsi
mov    %rsi,0x150(%rsp)
lea    (%rcx,%rcx,8),%rsi
mov    %rsi,0x148(%rsp)
mov    %rdx,0x170(%rsp)
lea    (%rdx,%rdx,4),%rdx
mov    %rdx,0x140(%rsp)
lea    (%rcx,%rbx,2),%rdx
mov    %rdx,0x138(%rsp)
mov    %rdi,0x160(%rsp)
lea    (%rdi,%rdi,2),%rdx
mov    %rdx,0x130(%rsp)
mov    %r8,0x168(%rsp)
lea    (%rcx,%r8,4),%rdx
mov    %rdx,0x128(%rsp)
mov    %rbx,0x158(%rsp)
lea    (%rbx,%rbx,2),%rdx
mov    %rdx,0x120(%rsp)
mov    %rcx,0x38(%rsp)
lea    0x40(%r12,%rcx,4),%rcx
mov    %rcx,0x108(%rsp)
lea    0x40(%r12),%rcx
mov    %rcx,0x100(%rsp)
mov    $0x10,%ecx
mov    %rcx,0x58(%rsp)
mov    $0x11,%ecx
mov    %rcx,0x50(%rsp)
movl   $0x10,(%rsp)
mov    %rax,0x1a8(%rsp)
mov    %rax,0xf8(%rsp)
mov    %r14,%rbx
xor    %r14d,%r14d
xor    %eax,%eax
mov    %rax,0xf0(%rsp)
mov    %rbx,0x10(%rsp)
jmp    138e <lud_omp+0x25e>
nop
xor    %eax,%eax
call   1050 <current_time_ns@plt>
sub    0x60(%rsp),%rax
lea    0x1d0c(%rip),%rdi
mov    %rax,%rsi
call   1040 <printf@plt>
addq   $0x1,0xf0(%rsp)
mov    0x190(%rsp),%rax
add    %rax,0x108(%rsp)
add    %rax,0x100(%rsp)
mov    0x188(%rsp),%rax
add    %rax,0x110(%rsp)
add    %rax,0xf8(%rsp)
mov    (%rsp),%eax
add    0x1c(%rsp),%eax
mov    %eax,(%rsp)
mov    0x58(%rsp),%rax
add    $0x10,%eax
mov    %rax,0x58(%rsp)
mov    0x50(%rsp),%rax
add    $0x10,%eax
mov    %rax,0x50(%rsp)
mov    0x8(%rsp),%rdx
mov    %rdx,%r14
cmp    0x198(%rsp),%rdx
jge    200e <lud_omp+0xede>
mov    %r12,%rdi
mov    %ebx,%esi
mov    %r14d,%edx
call   1030 <lud_diagonal_omp@plt>
mov    0x7c(%rsp),%eax
mov    %eax,%ebx
sub    %r14d,%ebx
lea    0xf(%rbx),%eax
test   %ebx,%ebx
cmovns %ebx,%eax
sar    $0x4,%eax
mov    %eax,0x4(%rsp)
xor    %eax,%eax
call   1050 <current_time_ns@plt>
mov    %rax,0x1a0(%rsp)
cmp    $0x10,%ebx
jl     1b60 <lud_omp+0xa30>
mov    0x1c(%rsp),%eax
imul   0xf0(%rsp),%eax
cltq
mov    0x38(%rsp),%rcx
add    %rax,%rcx
lea    (%r12,%rcx,4),%rcx
mov    %rcx,0x230(%rsp)
mov    0x170(%rsp),%rcx
lea    (%rcx,%rax,1),%rcx
lea    (%r12,%rcx,4),%rcx
mov    %rcx,0x228(%rsp)
mov    0x168(%rsp),%rcx
lea    (%rcx,%rax,1),%rcx
lea    (%r12,%rcx,4),%rcx
mov    %rcx,0x220(%rsp)
mov    0x160(%rsp),%rcx
lea    (%rcx,%rax,1),%rcx
lea    (%r12,%rcx,4),%rcx
mov    %rcx,0x218(%rsp)
mov    0x158(%rsp),%rcx
lea    (%rcx,%rax,1),%rcx
lea    (%r12,%rcx,4),%rcx
mov    %rcx,0x210(%rsp)
mov    0x150(%rsp),%rcx
lea    (%rcx,%rax,1),%rcx
lea    (%r12,%rcx,4),%rcx
mov    %rcx,0x208(%rsp)
mov    0x180(%rsp),%rcx
lea    (%rcx,%rax,1),%rcx
lea    (%r12,%rcx,4),%rcx
mov    %rcx,0x200(%rsp)
lea    (%r15,%rax,1),%rcx
lea    (%r12,%rcx,4),%rcx
mov    %rcx,0x1f8(%rsp)
mov    0x148(%rsp),%rcx
lea    (%rcx,%rax,1),%rcx
lea    (%r12,%rcx,4),%rcx
mov    %rcx,0x1f0(%rsp)
mov    0x140(%rsp),%rcx
lea    (%rcx,%rax,1),%rcx
lea    (%r12,%rcx,4),%rcx
mov    %rcx,0x1e8(%rsp)
mov    0x138(%rsp),%rcx
lea    (%rcx,%rax,1),%rcx
lea    (%r12,%rcx,4),%rcx
mov    %rcx,0x1e0(%rsp)
mov    0x130(%rsp),%rcx
lea    (%rcx,%rax,1),%rcx
lea    (%r12,%rcx,4),%rcx
mov    %rcx,0x1d8(%rsp)
mov    0x128(%rsp),%rcx
add    %rax,%rcx
lea    (%r12,%rcx,4),%rcx
mov    %rcx,0x1d0(%rsp)
mov    0x178(%rsp),%rcx
add    %rax,%rcx
lea    (%r12,%rcx,4),%rcx
mov    %rcx,0x1c8(%rsp)
lea    (%r12,%rax,4),%rcx
mov    %rcx,0x1c0(%rsp)
add    0x120(%rsp),%rax
lea    (%r12,%rax,4),%rax
mov    %rax,0x1b8(%rsp)
mov    0x4(%rsp),%eax
mov    %rax,0x1b0(%rsp)
mov    0xf8(%rsp),%rax
mov    %rax,0x8(%rsp)
mov    0x110(%rsp),%rax
mov    %rax,0x20(%rsp)
mov    0x100(%rsp),%r10
mov    0x108(%rsp),%rdx
xor    %esi,%esi
jmp    15ba <lud_omp+0x48a>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x60(%rsp),%rdx
add    $0x40,%rdx
mov    0x68(%rsp),%r10
add    $0x40,%r10
mov    0x1a8(%rsp),%rax
add    %rax,0x20(%rsp)
add    %rax,0x8(%rsp)
mov    0x238(%rsp),%rsi
cmp    0x1b0(%rsp),%rsi
je     1b60 <lud_omp+0xa30>
mov    0x1c0(%rsp),%rax
movups (%rax),%xmm0
movups 0x10(%rax),%xmm1
movups 0x20(%rax),%xmm2
movups 0x30(%rax),%xmm3
movaps %xmm3,0x270(%rsp)
movaps %xmm2,0x260(%rsp)
movaps %xmm1,0x250(%rsp)
movaps %xmm0,0x240(%rsp)
mov    0x230(%rsp),%rax
movups (%rax),%xmm0
movups 0x10(%rax),%xmm1
movups 0x20(%rax),%xmm2
movups 0x30(%rax),%xmm3
lea    0x280(%rsp),%rax
movups %xmm3,0x30(%rax)
movups %xmm2,0x20(%rax)
movups %xmm1,0x10(%rax)
movups %xmm0,(%rax)
mov    0x228(%rsp),%rcx
movups (%rcx),%xmm0
movups 0x10(%rcx),%xmm1
movups 0x20(%rcx),%xmm2
movups 0x30(%rcx),%xmm3
movups %xmm3,0x70(%rax)
movups %xmm2,0x60(%rax)
movups %xmm1,0x50(%rax)
movups %xmm0,0x40(%rax)
mov    0x220(%rsp),%rcx
movups (%rcx),%xmm0
movups 0x10(%rcx),%xmm1
movups 0x20(%rcx),%xmm2
movups 0x30(%rcx),%xmm3
movups %xmm3,0xb0(%rax)
movups %xmm2,0xa0(%rax)
movups %xmm1,0x90(%rax)
movups %xmm0,0x80(%rax)
mov    0x218(%rsp),%rcx
movups (%rcx),%xmm0
movups 0x10(%rcx),%xmm1
movups 0x20(%rcx),%xmm2
movups 0x30(%rcx),%xmm3
movups %xmm3,0xf0(%rax)
movups %xmm2,0xe0(%rax)
movups %xmm1,0xd0(%rax)
movups %xmm0,0xc0(%rax)
mov    0x210(%rsp),%rcx
movups (%rcx),%xmm0
movups 0x10(%rcx),%xmm1
movups 0x20(%rcx),%xmm2
movups 0x30(%rcx),%xmm3
movups %xmm3,0x130(%rax)
movups %xmm2,0x120(%rax)
movups %xmm1,0x110(%rax)
movups %xmm0,0x100(%rax)
mov    0x208(%rsp),%rcx
movups (%rcx),%xmm0
movups 0x10(%rcx),%xmm1
movups 0x20(%rcx),%xmm2
movups 0x30(%rcx),%xmm3
movups %xmm3,0x170(%rax)
movups %xmm2,0x160(%rax)
movups %xmm1,0x150(%rax)
movups %xmm0,0x140(%rax)
mov    0x200(%rsp),%rcx
movups (%rcx),%xmm0
movups 0x10(%rcx),%xmm1
movups 0x20(%rcx),%xmm2
movups 0x30(%rcx),%xmm3
movups %xmm0,0x180(%rax)
movups %xmm1,0x190(%rax)
movups %xmm2,0x1a0(%rax)
movups %xmm3,0x1b0(%rax)
mov    0x1f8(%rsp),%rcx
movups (%rcx),%xmm0
movups 0x10(%rcx),%xmm1
movups 0x20(%rcx),%xmm2
movups 0x30(%rcx),%xmm3
movups %xmm3,0x1f0(%rax)
movups %xmm2,0x1e0(%rax)
movups %xmm1,0x1d0(%rax)
movups %xmm0,0x1c0(%rax)
mov    0x1f0(%rsp),%rcx
movups (%rcx),%xmm0
movups 0x10(%rcx),%xmm1
movups 0x20(%rcx),%xmm2
movups 0x30(%rcx),%xmm3
movups %xmm3,0x230(%rax)
movups %xmm2,0x220(%rax)
movups %xmm1,0x210(%rax)
movups %xmm0,0x200(%rax)
mov    0x1e8(%rsp),%rcx
movups (%rcx),%xmm0
movups 0x10(%rcx),%xmm1
movups 0x20(%rcx),%xmm2
movups 0x30(%rcx),%xmm3
movups %xmm3,0x270(%rax)
movups %xmm2,0x260(%rax)
movups %xmm1,0x250(%rax)
movups %xmm0,0x240(%rax)
mov    0x1e0(%rsp),%rcx
movups (%rcx),%xmm0
movups 0x10(%rcx),%xmm1
movups 0x20(%rcx),%xmm2
movups 0x30(%rcx),%xmm3
movups %xmm3,0x2b0(%rax)
movups %xmm2,0x2a0(%rax)
movups %xmm1,0x290(%rax)
movups %xmm0,0x280(%rax)
mov    0x1d8(%rsp),%rcx
movups (%rcx),%xmm0
movups 0x10(%rcx),%xmm1
movups 0x20(%rcx),%xmm2
movups 0x30(%rcx),%xmm3
movups %xmm3,0x2f0(%rax)
movups %xmm2,0x2e0(%rax)
movups %xmm1,0x2d0(%rax)
movups %xmm0,0x2c0(%rax)
mov    0x1d0(%rsp),%rcx
movups (%rcx),%xmm0
movups 0x10(%rcx),%xmm1
movups 0x20(%rcx),%xmm2
movups 0x30(%rcx),%xmm3
movups %xmm3,0x330(%rax)
movups %xmm2,0x320(%rax)
movups %xmm1,0x310(%rax)
movups %xmm0,0x300(%rax)
mov    0x1c8(%rsp),%rcx
movups (%rcx),%xmm0
movups 0x10(%rcx),%xmm1
movups 0x20(%rcx),%xmm2
movups 0x30(%rcx),%xmm3
movups %xmm3,0x370(%rax)
movups %xmm2,0x360(%rax)
movups %xmm1,0x350(%rax)
movups %xmm0,0x340(%rax)
mov    0x1b8(%rsp),%rcx
movups (%rcx),%xmm0
movups 0x10(%rcx),%xmm1
movups 0x20(%rcx),%xmm2
movups 0x30(%rcx),%xmm3
movups %xmm3,0x3b0(%rax)
movups %xmm2,0x3a0(%rax)
movups %xmm1,0x390(%rax)
movups %xmm0,0x380(%rax)
add    $0x1,%rsi
mov    %rsi,0x238(%rsp)
shl    $0x4,%rsi
add    %r14,%rsi
mov    %rsi,0x28(%rsp)
mov    %r10,0x68(%rsp)
mov    %rdx,0x60(%rsp)
mov    %rdx,%rax
xor    %r8d,%r8d
mov    0x38(%rsp),%r11
jmp    1926 <lud_omp+0x7f6>
nopl   0x0(%rax)
add    $0x1,%r8
add    $0x4,%rax
add    $0x4,%r10
cmp    $0x10,%r8
je     19f0 <lud_omp+0x8c0>
mov    0x28(%rsp),%rcx
lea    (%r8,%rcx,1),%r9
lea    0x244(%rsp),%rdi
xor    %ebx,%ebx
jmp    196c <lud_omp+0x83c>
nopl   0x0(%rax,%rax,1)
xorps  %xmm0,%xmm0
lea    (%rbx,%r14,1),%rcx
imul   %r11,%rcx
add    %r9,%rcx
movss  (%r12,%rcx,4),%xmm1
subss  %xmm0,%xmm1
movss  %xmm1,(%r12,%rcx,4)
add    $0x1,%rbx
add    $0x40,%rdi
cmp    $0x10,%rbx
je     1910 <lud_omp+0x7e0>
test   %rbx,%rbx
je     1940 <lud_omp+0x810>
cmp    $0x1,%rbx
jne    1980 <lud_omp+0x850>
xorps  %xmm0,%xmm0
xor    %esi,%esi
jmp    19bd <lud_omp+0x88d>
xchg   %ax,%ax
mov    %rbx,%rdx
and    $0xfffffffffffffffe,%rdx
xorps  %xmm1,%xmm1
xor    %ecx,%ecx
xor    %esi,%esi
xchg   %ax,%ax
movss  -0x4(%rdi,%rsi,4),%xmm2
mulss  (%r10,%rcx,1),%xmm2
movss  (%rdi,%rsi,4),%xmm0
addss  %xmm1,%xmm2
mulss  (%rax,%rcx,1),%xmm0
addss  %xmm2,%xmm0
add    $0x2,%rsi
add    %r15,%rcx
movaps %xmm0,%xmm1
cmp    %rsi,%rdx
jne    1990 <lud_omp+0x860>
test   $0x1,%bl
je     1943 <lud_omp+0x813>
mov    %rbx,%rcx
shl    $0x4,%rcx
add    %rsi,%rcx
movss  0x240(%rsp,%rcx,4),%xmm1
add    %r14,%rsi
imul   %r11,%rsi
add    %r9,%rsi
mulss  (%r12,%rsi,4),%xmm1
addss  %xmm1,%xmm0
jmp    1943 <lud_omp+0x813>
xchg   %ax,%ax
mov    0x8(%rsp),%rax
mov    %rax,0x48(%rsp)
mov    0x20(%rsp),%rdi
xor    %ecx,%ecx
mov    0x10(%rsp),%rbx
jmp    1a30 <lud_omp+0x900>
nopl   0x0(%rax,%rax,1)
mov    0x70(%rsp),%rcx
add    $0x1,%rcx
mov    0x30(%rsp),%rax
add    %rax,%rdi
add    %rax,0x48(%rsp)
cmp    $0x10,%rcx
je     1580 <lud_omp+0x450>
mov    0x28(%rsp),%rax
mov    %rcx,0x70(%rsp)
lea    (%rcx,%rax,1),%r11
imul   0x38(%rsp),%r11
lea    (%r11,%r14,1),%rax
mov    %rax,0x40(%rsp)
lea    0x280(%rsp),%rcx
xor    %r10d,%r10d
jmp    1a9e <lud_omp+0x96e>
nopw   0x0(%rax,%rax,1)
xorps  %xmm0,%xmm0
lea    (%r10,%r14,1),%rax
lea    (%r10,%r14,1),%edx
lea    (%rax,%r11,1),%rsi
movss  (%r12,%rsi,4),%xmm1
subss  %xmm0,%xmm1
imul   %ebx,%edx
add    %edx,%eax
cltq
divss  (%r12,%rax,4),%xmm1
movss  %xmm1,(%r12,%rsi,4)
add    $0x1,%r10
add    $0x4,%rcx
cmp    $0x10,%r10
je     1a10 <lud_omp+0x8e0>
test   %r10,%r10
je     1a60 <lud_omp+0x930>
cmp    $0x1,%r10
jne    1ac0 <lud_omp+0x990>
xorps  %xmm0,%xmm0
xor    %r9d,%r9d
jmp    1b1e <lud_omp+0x9ee>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r10,%r8
and    $0xfffffffffffffffe,%r8
xorps  %xmm0,%xmm0
mov    0x48(%rsp),%rbx
mov    %rcx,%rax
mov    %rdi,%rsi
xor    %r9d,%r9d
nopl   0x0(%rax,%rax,1)
mov    %rbx,%rdx
sar    $0x1e,%rdx
movss  (%r12,%rdx,1),%xmm1
mulss  -0x40(%rax),%xmm1
addss  %xmm0,%xmm1
mov    %rsi,%rdx
sar    $0x1e,%rdx
movss  (%r12,%rdx,1),%xmm0
mulss  (%rax),%xmm0
addss  %xmm1,%xmm0
add    $0x2,%r9
add    %r13,%rsi
sub    $0xffffffffffffff80,%rax
add    %r13,%rbx
cmp    %r9,%r8
jne    1ae0 <lud_omp+0x9b0>
test   $0x1,%r10b
mov    0x10(%rsp),%rbx
je     1a63 <lud_omp+0x933>
mov    0x40(%rsp),%rax
add    %r9d,%eax
cltq
movss  (%r12,%rax,4),%xmm1
shl    $0x4,%r9
add    %r10,%r9
mulss  0x240(%rsp,%r9,4),%xmm1
addss  %xmm1,%xmm0
jmp    1a63 <lud_omp+0x933>
nopw   0x0(%rax,%rax,1)
xor    %eax,%eax
call   1050 <current_time_ns@plt>
sub    0x1a0(%rsp),%rax
lea    0x148a(%rip),%rdi
mov    %rax,%rsi
call   1040 <printf@plt>
mov    0x4(%rsp),%ebx
imul   %ebx,%ebx
xor    %eax,%eax
call   1050 <current_time_ns@plt>
mov    %rax,0x60(%rsp)
lea    0x10(%r14),%rax
mov    %rax,0x8(%rsp)
mov    %ebx,0x20(%rsp)
test   %ebx,%ebx
mov    0x10(%rsp),%rbx
mov    0x30(%rsp),%r8
xorps  %xmm12,%xmm12
je     1300 <lud_omp+0x1d0>
lea    0x10(%r14),%eax
mov    %eax,0x68(%rsp)
xor    %eax,%eax
jmp    1bd1 <lud_omp+0xaa1>
mov    0x70(%rsp),%eax
add    $0x1,%eax
cmp    0x20(%rsp),%eax
je     1300 <lud_omp+0x1d0>
movaps %xmm12,0xb0(%rsp)
movaps %xmm12,0xa0(%rsp)
movaps %xmm12,0x90(%rsp)
movaps %xmm12,0x80(%rsp)
mov    %eax,0x70(%rsp)
cltd
idivl  0x4(%rsp)
mov    %eax,%edi
shl    $0x4,%edi
shl    $0x4,%edx
mov    0x8(%rsp),%rcx
lea    (%rdx,%rcx,1),%eax
mov    %eax,0x28(%rsp)
mov    0x58(%rsp),%rax
lea    (%rax,%rdi,1),%esi
add    %ecx,%edi
mov    %rdi,0x40(%rsp)
imul   %ebx,%esi
lea    (%r14,%rsi,1),%r11d
shl    $0x20,%r11
xor    %edi,%edi
mov    (%rsp),%eax
mov    %eax,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r11,%rax
sar    $0x1e,%rax
lea    (%rdx,%rcx,1),%ebx
movups (%r12,%rax,1),%xmm0
movups 0x10(%r12,%rax,1),%xmm1
movups 0x20(%r12,%rax,1),%xmm2
movups 0x30(%r12,%rax,1),%xmm3
movups %xmm3,0x670(%rsp,%rdi,1)
movups %xmm2,0x660(%rsp,%rdi,1)
movups %xmm1,0x650(%rsp,%rdi,1)
movups %xmm0,0x640(%rsp,%rdi,1)
movslq %ebx,%rax
mov    0x10(%rsp),%rbx
movss  (%r12,%rax,4),%xmm0
movss  %xmm0,0x240(%rsp,%rdi,1)
lea    0x1(%rdx,%rcx,1),%eax
cltq
movss  (%r12,%rax,4),%xmm0
movss  %xmm0,0x244(%rsp,%rdi,1)
lea    0x2(%rdx,%rcx,1),%eax
cltq
movss  (%r12,%rax,4),%xmm0
movss  %xmm0,0x248(%rsp,%rdi,1)
lea    0x3(%rdx,%rcx,1),%eax
cltq
movss  (%r12,%rax,4),%xmm0
movss  %xmm0,0x24c(%rsp,%rdi,1)
lea    0x4(%rdx,%rcx,1),%eax
cltq
movss  (%r12,%rax,4),%xmm0
movss  %xmm0,0x250(%rsp,%rdi,1)
lea    0x5(%rdx,%rcx,1),%eax
cltq
movss  (%r12,%rax,4),%xmm0
movss  %xmm0,0x254(%rsp,%rdi,1)
lea    0x6(%rdx,%rcx,1),%eax
cltq
movss  (%r12,%rax,4),%xmm0
movss  %xmm0,0x258(%rsp,%rdi,1)
lea    0x7(%rdx,%rcx,1),%eax
cltq
movss  (%r12,%rax,4),%xmm0
movss  %xmm0,0x25c(%rsp,%rdi,1)
lea    0x8(%rdx,%rcx,1),%eax
cltq
movss  (%r12,%rax,4),%xmm0
movss  %xmm0,0x260(%rsp,%rdi,1)
lea    0x9(%rdx,%rcx,1),%eax
cltq
movss  (%r12,%rax,4),%xmm0
movss  %xmm0,0x264(%rsp,%rdi,1)
lea    0xa(%rdx,%rcx,1),%eax
cltq
movss  (%r12,%rax,4),%xmm0
movss  %xmm0,0x268(%rsp,%rdi,1)
lea    0xb(%rdx,%rcx,1),%eax
cltq
movss  (%r12,%rax,4),%xmm0
movss  %xmm0,0x26c(%rsp,%rdi,1)
lea    0xc(%rdx,%rcx,1),%eax
cltq
movss  (%r12,%rax,4),%xmm0
movss  %xmm0,0x270(%rsp,%rdi,1)
lea    0xd(%rdx,%rcx,1),%eax
cltq
movss  (%r12,%rax,4),%xmm0
movss  %xmm0,0x274(%rsp,%rdi,1)
lea    0xe(%rdx,%rcx,1),%eax
cltq
movss  (%r12,%rax,4),%xmm0
movss  %xmm0,0x278(%rsp,%rdi,1)
lea    0xf(%rdx,%rcx,1),%eax
cltq
movss  (%r12,%rax,4),%xmm0
movss  %xmm0,0x27c(%rsp,%rdi,1)
add    %ebx,%ecx
add    %r8,%r11
add    $0x40,%rdi
cmp    $0x400,%rdi
jne    1c40 <lud_omp+0xb10>
mov    0x40(%rsp),%rax
imul   %ebx,%eax
add    0x68(%rsp),%eax
add    %edx,%eax
mov    %eax,0x48(%rsp)
mov    0x50(%rsp),%rax
lea    (%rax,%rsi,1),%r11d
add    %edx,%r11d
add    %r14d,%esi
add    %edx,%esi
lea    0x640(%rsp),%rdx
xor    %ecx,%ecx
jmp    1ed4 <lud_omp+0xda4>
nopl   0x0(%rax,%rax,1)
mov    0x40(%rsp),%rax
lea    (%rax,%rcx,1),%edi
imul   %ebx,%edi
add    0x28(%rsp),%edi
movslq %edi,%rdi
movups (%r12,%rdi,4),%xmm0
subps  0x80(%rsp),%xmm0
movups %xmm0,(%r12,%rdi,4)
movaps %xmm12,0x80(%rsp)
lea    0x4(%rdi),%ebx
movslq %ebx,%rbx
movups (%r12,%rbx,4),%xmm0
subps  0x90(%rsp),%xmm0
movups %xmm0,(%r12,%rbx,4)
movaps %xmm12,0x90(%rsp)
lea    0x8(%rdi),%ebx
movslq %ebx,%rbx
movups (%r12,%rbx,4),%xmm0
subps  0xa0(%rsp),%xmm0
movups %xmm0,(%r12,%rbx,4)
movaps %xmm12,0xa0(%rsp)
add    $0xc,%edi
movslq %edi,%rdi
movups (%r12,%rdi,4),%xmm0
subps  0xb0(%rsp),%xmm0
movups %xmm0,(%r12,%rdi,4)
movaps %xmm12,0xb0(%rsp)
mov    0x30(%rsp),%r8
add    $0x1,%rcx
add    $0x40,%rdx
mov    0x10(%rsp),%rbx
add    %ebx,%r11d
add    0x38(%rsp),%rsi
cmp    $0x10,%rcx
je     1bc0 <lud_omp+0xa90>
mov    %ecx,%r8d
imul   %ebx,%r8d
add    0x48(%rsp),%r8d
movaps 0x80(%rsp),%xmm3
movaps 0x90(%rsp),%xmm2
movaps 0xa0(%rsp),%xmm1
movaps 0xb0(%rsp),%xmm5
lea    0x270(%rsp),%r9
xor    %r10d,%r10d
nopl   0x0(%rax,%rax,1)
movaps %xmm5,%xmm11
movaps %xmm1,%xmm10
movaps %xmm2,%xmm9
movaps %xmm3,%xmm8
movss  (%rdx,%r10,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movaps -0x30(%r9),%xmm6
mulps  %xmm0,%xmm6
movaps %xmm6,%xmm3
addps  %xmm8,%xmm3
movaps -0x20(%r9),%xmm7
mulps  %xmm0,%xmm7
movaps %xmm7,%xmm2
addps  %xmm9,%xmm2
movaps -0x10(%r9),%xmm4
mulps  %xmm0,%xmm4
movaps %xmm4,%xmm1
addps  %xmm10,%xmm1
mulps  (%r9),%xmm0
movaps %xmm0,%xmm5
addps  %xmm11,%xmm5
add    $0x1,%r10
add    $0x40,%r9
cmp    $0x10,%r10
jne    1f10 <lud_omp+0xde0>
addps  %xmm11,%xmm0
addps  %xmm10,%xmm4
addps  %xmm9,%xmm7
addps  %xmm8,%xmm6
movaps %xmm6,0x80(%rsp)
movaps %xmm7,0x90(%rsp)
movaps %xmm4,0xa0(%rsp)
movaps %xmm0,0xb0(%rsp)
cmp    $0x7ffffff1,%r8d
jl     1e20 <lud_omp+0xcf0>
mov    $0x10,%ebx
mov    %r11d,%edi
mov    0x30(%rsp),%r8
nopw   0x0(%rax,%rax,1)
lea    (%rsi,%rbx,1),%eax
cltq
movss  (%r12,%rax,4),%xmm0
subss  0x40(%rsp,%rbx,4),%xmm0
movss  %xmm0,(%r12,%rax,4)
movl   $0x0,0x40(%rsp,%rbx,4)
movslq %edi,%rdi
movss  (%r12,%rdi,4),%xmm0
subss  0x44(%rsp,%rbx,4),%xmm0
movss  %xmm0,(%r12,%rdi,4)
movl   $0x0,0x44(%rsp,%rbx,4)
add    $0x2,%rbx
add    $0x2,%edi
cmp    $0x20,%rbx
jne    1fc0 <lud_omp+0xe90>
jmp    1eb5 <lud_omp+0xd85>
mov    %rbx,%r14
mov    0x118(%rsp),%rbx
mov    %r12,%rdi
mov    %r14d,%esi
call   1030 <lud_diagonal_omp@plt>
xor    %eax,%eax
call   1050 <current_time_ns@plt>
sub    %rbx,%rax
lea    0x100a(%rip),%rdi
mov    %rax,%rsi
call   1040 <printf@plt>
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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