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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double RAND_MAX;
double fabs(double);
int /*<<< orphan*/ free(double *);
scalar_t__ malloc(int);
double omp_get_wtime();
double rand();
int sqrt(unsigned int);
double gemm() {
  extern unsigned int datasize;
  int i = 0;
  int j = 0;
  int k = 0;
  double alpha = 0;
  double beta = 0;
  double *A = NULL;
  double *B = NULL;
  double *C = NULL;
  double *H = NULL;
  double t_start = 0;
  double t_end = 0;
  int flag = 0;
  int n = 0;
  n = sqrt((datasize / sizeof(double)) / 3);
  A = (double *)malloc(n * n * sizeof(double));
  B = (double *)malloc(n * n * sizeof(double));
  C = (double *)malloc(n * n * sizeof(double));
  H = (double *)malloc(n * n * sizeof(double));
  if (C == NULL || A == NULL || B == NULL || H == NULL) {
    return (-10000);
  }
  alpha = 32412;
  beta = 2123;
  for (i = 0; i < n; i++) {
    for (j = 0; j < n; j++) {
      A[i * n + j] = rand() / (1.0 + RAND_MAX);
      B[i * n + j] = rand() / (1.0 + RAND_MAX);
      C[i * n + j] = rand() / (1.0 + RAND_MAX);
      H[i * n + j] = C[i * n + j];
    }
  }
  for (i = 0; i < n; i++) {
    for (j = 0; j < n; j++) {
      H[i * n + j] *= beta;
      for (k = 0; k < n; k++)
        H[i * n + j] += alpha * A[i * n + k] * B[k * n + j];
    }
  }
  t_start = omp_get_wtime();
#pragma acc data copyin(A [0:n * n], B [0:n * n]), copy(C [0:n * n])
  {
#pragma acc kernels
#pragma acc loop independent
    for (i = 0; i < n; i++) {
#pragma acc loop independent
      for (j = 0; j < n; j++) {
        C[i * n + j] *= beta;
        for (k = 0; k < n; k++) {
          C[i * n + j] += alpha * A[i * n + k] * B[k * n + j];
        }
      }
    }
  }
  t_end = omp_get_wtime();
  for (i = 0; i < n; i++) {
    for (j = 0; j < n; j++) {
      if (fabs(H[i * n + j] - C[i * n + j]) / H[i * n + j] > 1e-14) {
        flag = 1;
      }
    }
  }
  free(C);
  free(H);
  free(A);
  free(B);
  if (flag == 0)
    return (t_end - t_start);
  else
    return (-11000);
}


x86 assembly (clang, -O0):
<gemm>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
movl   $0x0,-0xc(%rbp)
movl   $0x0,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x20(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x28(%rbp)
movq   $0x0,-0x30(%rbp)
movq   $0x0,-0x38(%rbp)
movq   $0x0,-0x40(%rbp)
movq   $0x0,-0x48(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0x5c(%rbp)
movl   $0x0,-0x60(%rbp)
mov    0x2e1e(%rip),%rax
mov    (%rax),%eax
shr    $0x3,%rax
mov    $0x3,%ecx
xor    %edx,%edx
div    %rcx
mov    %eax,%edi
call   1060 <sqrt@plt>
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
imul   -0x60(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x30(%rbp)
mov    -0x60(%rbp),%eax
imul   -0x60(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x38(%rbp)
mov    -0x60(%rbp),%eax
imul   -0x60(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x40(%rbp)
mov    -0x60(%rbp),%eax
imul   -0x60(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x48(%rbp)
cmpq   $0x0,-0x40(%rbp)
je     1268 <gemm+0x118>
cmpq   $0x0,-0x30(%rbp)
je     1268 <gemm+0x118>
cmpq   $0x0,-0x38(%rbp)
je     1268 <gemm+0x118>
cmpq   $0x0,-0x48(%rbp)
jne    127a <gemm+0x12a>
movsd  0xdb8(%rip),%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    167e <gemm+0x52e>
movsd  0xd86(%rip),%xmm0
movsd  %xmm0,-0x20(%rbp)
movsd  0xd71(%rip),%xmm0
movsd  %xmm0,-0x28(%rbp)
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x60(%rbp),%eax
jge    13a3 <gemm+0x253>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x60(%rbp),%eax
jge    1390 <gemm+0x240>
mov    $0x0,%al
call   1070 <rand@plt>
movsd  0xd57(%rip),%xmm1
mov    0x2d18(%rip),%rax
addsd  (%rax),%xmm1
divsd  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x60(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    $0x0,%al
call   1070 <rand@plt>
movsd  0xd23(%rip),%xmm1
mov    0x2ce4(%rip),%rax
addsd  (%rax),%xmm1
divsd  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x60(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    $0x0,%al
call   1070 <rand@plt>
movsd  0xcef(%rip),%xmm1
mov    0x2cb0(%rip),%rax
addsd  (%rax),%xmm1
divsd  %xmm1,%xmm0
mov    -0x40(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x60(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x60(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x60(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    12ae <gemm+0x15e>
jmp    1395 <gemm+0x245>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    129b <gemm+0x14b>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x60(%rbp),%eax
jge    1484 <gemm+0x334>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x60(%rbp),%eax
jge    1471 <gemm+0x321>
movsd  -0x28(%rbp),%xmm0
mov    -0x48(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x60(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x60(%rbp),%eax
jge    145e <gemm+0x30e>
movsd  -0x20(%rbp),%xmm0
mov    -0x30(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x60(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x60(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x48(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x60(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    13f0 <gemm+0x2a0>
jmp    1463 <gemm+0x313>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    13bd <gemm+0x26d>
jmp    1476 <gemm+0x326>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    13aa <gemm+0x25a>
mov    $0x0,%al
call   1040 <omp_get_wtime@plt>
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x60(%rbp),%eax
jge    1571 <gemm+0x421>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x60(%rbp),%eax
jge    155e <gemm+0x40e>
movsd  -0x28(%rbp),%xmm0
mov    -0x40(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x60(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x60(%rbp),%eax
jge    154b <gemm+0x3fb>
movsd  -0x20(%rbp),%xmm0
mov    -0x30(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x60(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x60(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x40(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x60(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    14dd <gemm+0x38d>
jmp    1550 <gemm+0x400>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    14aa <gemm+0x35a>
jmp    1563 <gemm+0x413>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1497 <gemm+0x347>
mov    $0x0,%al
call   1040 <omp_get_wtime@plt>
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x60(%rbp),%eax
jge    162f <gemm+0x4df>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x60(%rbp),%eax
jge    161c <gemm+0x4cc>
mov    -0x48(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x60(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x60(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movaps 0xa5a(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x48(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x60(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  0xa20(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1609 <gemm+0x4b9>
movl   $0x1,-0x5c(%rbp)
jmp    160e <gemm+0x4be>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1597 <gemm+0x447>
jmp    1621 <gemm+0x4d1>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1584 <gemm+0x434>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
cmpl   $0x0,-0x5c(%rbp)
jne    1671 <gemm+0x521>
movsd  -0x58(%rbp),%xmm0
subsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    167e <gemm+0x52e>
movsd  0x997(%rip),%xmm0
movsd  %xmm0,-0x8(%rbp)
movsd  -0x8(%rbp),%xmm0
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<gemm>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    0x2e7b(%rip),%rax
mov    (%rax),%eax
mov    $0xaaaaaaab,%edi
imul   %rax,%rdi
shr    $0x24,%rdi
call   1060 <sqrt@plt>
mov    %eax,%r14d
mov    %eax,%ebx
imul   %eax,%ebx
shl    $0x3,%ebx
mov    %ebx,%edi
call   1050 <malloc@plt>
mov    %rax,%rbp
mov    %ebx,%edi
call   1050 <malloc@plt>
mov    %rax,0x10(%rsp)
mov    %ebx,%edi
call   1050 <malloc@plt>
mov    %rax,%r12
mov    %ebx,%edi
call   1050 <malloc@plt>
movsd  0xe4d(%rip),%xmm0
test   %r12,%r12
je     145b <gemm+0x30b>
test   %rbp,%rbp
je     145b <gemm+0x30b>
cmpq   $0x0,0x10(%rsp)
je     145b <gemm+0x30b>
mov    %rax,%r15
test   %rax,%rax
je     145b <gemm+0x30b>
test   %r14d,%r14d
mov    %rbp,0x30(%rsp)
jle    1401 <gemm+0x2b1>
mov    %r14d,0x1c(%rsp)
mov    %r14d,%eax
mov    %rax,0x8(%rsp)
lea    0x0(,%rax,8),%r13
mov    0x2de1(%rip),%rdx
mov    %r15,%rbx
mov    %r12,0x38(%rsp)
mov    0x10(%rsp),%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
mov    %rbp,0x20(%rsp)
mov    %rsi,0x28(%rsp)
mov    %rdi,0x40(%rsp)
xor    %r14d,%r14d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xor    %eax,%eax
mov    %r12,%rbp
mov    %rdx,%r12
call   1070 <rand@plt>
movsd  (%r12),%xmm1
addsd  0xdad(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    0x20(%rsp),%rax
movsd  %xmm0,(%rax,%r14,8)
xor    %eax,%eax
call   1070 <rand@plt>
movsd  (%r12),%xmm1
addsd  0xd89(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    0x28(%rsp),%rax
movsd  %xmm0,(%rax,%r14,8)
xor    %eax,%eax
call   1070 <rand@plt>
mov    %r12,%rdx
mov    %rbp,%r12
movsd  0xd65(%rip),%xmm2
movsd  (%rdx),%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,0x0(%rbp,%r14,8)
movsd  %xmm0,(%rbx,%r14,8)
add    $0x1,%r14
cmp    %r14,0x8(%rsp)
jne    1240 <gemm+0xf0>
mov    0x40(%rsp),%rdi
add    $0x1,%rdi
mov    0x20(%rsp),%rbp
add    %r13,%rbp
mov    0x28(%rsp),%rsi
add    %r13,%rsi
add    %r13,%r12
add    %r13,%rbx
cmp    0x8(%rsp),%rdi
jne    1220 <gemm+0xd0>
cmpl   $0x0,0x1c(%rsp)
mov    0x30(%rsp),%r11
mov    0x38(%rsp),%r12
jle    1401 <gemm+0x2b1>
mov    0x8(%rsp),%rbx
lea    -0x1(%rbx),%r14
mov    %ebx,%eax
and    $0xfffffffe,%eax
lea    0x8(%r11),%rcx
mov    %rbx,%rbp
shl    $0x4,%rbp
xor    %r8d,%r8d
movsd  0xcea(%rip),%xmm2
jmp    1340 <gemm+0x1f0>
add    $0x1,%r8
add    %r13,%rcx
cmp    %rbx,%r8
je     146a <gemm+0x31a>
mov    %r8,%r9
imul   %rbx,%r9
mov    0x10(%rsp),%r10
xor    %edx,%edx
jmp    135d <gemm+0x20d>
add    $0x1,%rdx
add    $0x8,%r10
cmp    %rbx,%rdx
je     1330 <gemm+0x1e0>
lea    (%rdx,%r9,1),%rsi
movsd  (%r15,%rsi,8),%xmm0
mulsd  0xca1(%rip),%xmm0
movsd  %xmm0,(%r15,%rsi,8)
test   %r14,%r14
je     13c0 <gemm+0x270>
mov    %r10,%rbx
xor    %edi,%edi
nop
movsd  -0x8(%rcx,%rdi,8),%xmm1
mulsd  %xmm2,%xmm1
mulsd  (%rbx),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%r15,%rsi,8)
movsd  (%rcx,%rdi,8),%xmm0
mulsd  %xmm2,%xmm0
mulsd  (%rbx,%r13,1),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%r15,%rsi,8)
add    $0x2,%rdi
add    %rbp,%rbx
cmp    %rdi,%rax
jne    1380 <gemm+0x230>
jmp    13c2 <gemm+0x272>
nop
xor    %edi,%edi
mov    0x8(%rsp),%rbx
test   $0x1,%bl
je     1350 <gemm+0x200>
lea    (%rdi,%r9,1),%rbx
movsd  (%r11,%rbx,8),%xmm1
mulsd  %xmm2,%xmm1
imul   0x8(%rsp),%rdi
add    %rdx,%rdi
mov    0x10(%rsp),%rbx
mulsd  (%rbx,%rdi,8),%xmm1
mov    0x8(%rsp),%rbx
addsd  %xmm0,%xmm1
movsd  %xmm1,(%r15,%rsi,8)
jmp    1350 <gemm+0x200>
xor    %eax,%eax
call   1040 <omp_get_wtime@plt>
movsd  %xmm0,0x28(%rsp)
xor    %ebp,%ebp
xor    %eax,%eax
call   1040 <omp_get_wtime@plt>
movsd  %xmm0,0x20(%rsp)
mov    %r12,%rdi
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    0x30(%rsp),%rdi
call   1030 <free@plt>
mov    0x10(%rsp),%rdi
call   1030 <free@plt>
test   %ebp,%ebp
je     144f <gemm+0x2ff>
movsd  0xbdb(%rip),%xmm0
jmp    145b <gemm+0x30b>
movsd  0x20(%rsp),%xmm0
subsd  0x28(%rsp),%xmm0
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %eax,%eax
call   1040 <omp_get_wtime@plt>
cmpl   $0x0,0x1c(%rsp)
movsd  %xmm0,0x28(%rsp)
jle    140e <gemm+0x2be>
mov    %ebx,%eax
and    $0xfffffffe,%eax
mov    0x30(%rsp),%r11
mov    %r11,%rcx
add    $0x8,%rcx
xor    %r8d,%r8d
movsd  0xb76(%rip),%xmm2
movsd  0xb76(%rip),%xmm3
jmp    14c0 <gemm+0x370>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r8
add    %r13,%rcx
cmp    %rbx,%r8
je     1581 <gemm+0x431>
mov    %r8,%r9
imul   %rbx,%r9
mov    0x10(%rsp),%r10
xor    %edx,%edx
jmp    14dd <gemm+0x38d>
add    $0x1,%rdx
add    $0x8,%r10
cmp    %rbx,%rdx
je     14b0 <gemm+0x360>
lea    (%rdx,%r9,1),%rsi
movsd  (%r12,%rsi,8),%xmm0
mulsd  %xmm2,%xmm0
movsd  %xmm0,(%r12,%rsi,8)
test   %r14,%r14
je     1540 <gemm+0x3f0>
mov    %r10,%rbx
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%rcx,%rdi,8),%xmm1
mulsd  %xmm3,%xmm1
mulsd  (%rbx),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%r12,%rsi,8)
movsd  (%rcx,%rdi,8),%xmm0
mulsd  %xmm3,%xmm0
mulsd  (%rbx,%r13,1),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%r12,%rsi,8)
add    $0x2,%rdi
add    %rbp,%rbx
cmp    %rdi,%rax
jne    1500 <gemm+0x3b0>
jmp    1542 <gemm+0x3f2>
nop
xor    %edi,%edi
mov    0x8(%rsp),%rbx
test   $0x1,%bl
je     14d0 <gemm+0x380>
lea    (%rdi,%r9,1),%rbx
movsd  (%r11,%rbx,8),%xmm1
mulsd  %xmm3,%xmm1
imul   0x8(%rsp),%rdi
add    %rdx,%rdi
mov    0x10(%rsp),%rbx
mulsd  (%rbx,%rdi,8),%xmm1
mov    0x8(%rsp),%rbx
addsd  %xmm0,%xmm1
movsd  %xmm1,(%r12,%rsi,8)
jmp    14d0 <gemm+0x380>
xor    %ebp,%ebp
xor    %eax,%eax
call   1040 <omp_get_wtime@plt>
mov    0x1c(%rsp),%r13d
test   %r13d,%r13d
movsd  %xmm0,0x20(%rsp)
jle    141d <gemm+0x2cd>
mov    %ebx,%r8d
and    $0xfffffffc,%r8d
mov    %r12,%rcx
add    $0x10,%rcx
lea    0x0(,%rbx,8),%r9
mov    %r15,%rsi
add    $0x10,%rsi
mov    %r9,%r14
and    $0xffffffffffffffe0,%r14
xor    %r10d,%r10d
movapd 0xa63(%rip),%xmm0
movsd  0xa4a(%rip),%xmm9
mov    $0x1,%r11d
movapd 0xa5b(%rip),%xmm11
movaps 0xa63(%rip),%xmm10
mov    %r12,%rax
mov    %r15,%rdx
xor    %ebp,%ebp
jmp    1619 <gemm+0x4c9>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r10
add    %r9,%rcx
add    %r9,%rsi
add    %r9,%rdx
add    %r9,%rax
cmp    %rbx,%r10
je     141d <gemm+0x2cd>
cmp    $0x4,%r13d
jae    1630 <gemm+0x4e0>
xor    %edi,%edi
jmp    1710 <gemm+0x5c0>
cs nopw 0x0(%rax,%rax,1)
movd   %ebp,%xmm8
pshufd $0x50,%xmm8,%xmm4
xor    %edi,%edi
movdqa %xmm4,%xmm6
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd -0x10(%rsi,%rdi,1),%xmm2
movupd (%rsi,%rdi,1),%xmm5
movupd -0x10(%rcx,%rdi,1),%xmm1
movupd (%rcx,%rdi,1),%xmm3
movapd %xmm2,%xmm7
subpd  %xmm1,%xmm7
movapd %xmm5,%xmm1
subpd  %xmm3,%xmm1
andpd  %xmm0,%xmm7
andpd  %xmm0,%xmm1
divpd  %xmm2,%xmm7
divpd  %xmm5,%xmm1
movapd %xmm11,%xmm2
cmpltpd %xmm7,%xmm2
shufps $0xe8,%xmm2,%xmm2
movapd %xmm11,%xmm3
cmpltpd %xmm1,%xmm3
shufps $0xe8,%xmm3,%xmm3
movaps %xmm2,%xmm1
andnps %xmm4,%xmm1
andps  %xmm10,%xmm2
movaps %xmm2,%xmm4
orps   %xmm1,%xmm4
movaps %xmm3,%xmm1
andnps %xmm6,%xmm1
andps  %xmm10,%xmm3
movaps %xmm3,%xmm6
orps   %xmm1,%xmm6
add    $0x20,%rdi
cmp    %rdi,%r14
jne    1650 <gemm+0x500>
pshufd $0x50,%xmm8,%xmm1
movaps %xmm4,%xmm2
pcmpeqd %xmm1,%xmm2
andps  %xmm2,%xmm6
andnps %xmm4,%xmm2
orps   %xmm6,%xmm2
movq   %xmm2,%rdi
movq   %xmm1,%rbx
cmp    %rbx,%rdi
cmovne %r11d,%ebp
mov    %r8,%rdi
mov    0x8(%rsp),%rbx
cmp    %rbx,%r8
je     1600 <gemm+0x4b0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rdx,%rdi,8),%xmm1
movapd %xmm1,%xmm2
subsd  (%rax,%rdi,8),%xmm2
andpd  %xmm0,%xmm2
divsd  %xmm1,%xmm2
ucomisd %xmm9,%xmm2
cmova  %r11d,%ebp
add    $0x1,%rdi
cmp    %rdi,%rbx
jne    1710 <gemm+0x5c0>
jmp    1600 <gemm+0x4b0>

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

LLVM IR (-O2):
@datasize = external global i32
@RAND_MAX = global double 0.000000e+00
define double @gemm() {
%1 = load i32, i32* @datasize
%2 = udiv i32 %1, 24
%3 = tail call i32 @sqrt(i32 %2)
%4 = shl i32 %3, 3
%5 = mul i32 %4, %3
%6 = tail call i64 @malloc(i32 %5)
%7 = inttoptr i64 %6 to double*
%8 = tail call i64 @malloc(i32 %5)
%9 = inttoptr i64 %8 to double*
%10 = tail call i64 @malloc(i32 %5)
%11 = inttoptr i64 %10 to double*
%12 = tail call i64 @malloc(i32 %5)
%13 = inttoptr i64 %12 to double*
%14 = icmp eq i64 %10, 0
%15 = icmp eq i64 %6, 0
%16 = select i1 %14, i1 true, i1 %15
%17 = icmp eq i64 %8, 0
%18 = select i1 %16, i1 true, i1 %17
%19 = icmp eq i64 %12, 0
%20 = select i1 %18, i1 true, i1 %19
br i1 %20, label %272, label %21
21: ; preds = %0
%22 = icmp sgt i32 %3, 0
br i1 %22, label %23, label %116
23: ; preds = %21
%24 = zext i32 %3 to i64
%25 = zext i32 %3 to i64
br label %26
26: ; preds = %59, %23
%27 = phi i64 [ 0, %23 ], [ %60, %59 ]
%28 = mul nsw i64 %27, %24
br label %38
29: ; preds = %59
br i1 %22, label %30, label %116
30: ; preds = %29
%31 = zext i32 %3 to i64
%32 = zext i32 %3 to i64
%33 = add nsw i64 %25, -1
%34 = and i64 %25, 1
%35 = icmp eq i64 %33, 0
%36 = and i64 %25, 4294967294
%37 = icmp eq i64 %34, 0
br label %62
38: ; preds = %26, %38
%39 = phi i64 [ 0, %26 ], [ %57, %38 ]
%40 = tail call double (...) @rand()
%41 = load double, double* @RAND_MAX
%42 = fadd double %41, 1.000000e+00
%43 = fdiv double %40, %42
%44 = add nuw nsw i64 %39, %28
%45 = getelementptr inbounds double, double* %7, i64 %44
store double %43, double* %45
%46 = tail call double (...) @rand()
%47 = load double, double* @RAND_MAX
%48 = fadd double %47, 1.000000e+00
%49 = fdiv double %46, %48
%50 = getelementptr inbounds double, double* %9, i64 %44
store double %49, double* %50
%51 = tail call double (...) @rand()
%52 = load double, double* @RAND_MAX
%53 = fadd double %52, 1.000000e+00
%54 = fdiv double %51, %53
%55 = getelementptr inbounds double, double* %11, i64 %44
store double %54, double* %55
%56 = getelementptr inbounds double, double* %13, i64 %44
store double %54, double* %56
%57 = add nuw nsw i64 %39, 1
%58 = icmp eq i64 %57, %25
br i1 %58, label %59, label %38
59: ; preds = %38
%60 = add nuw nsw i64 %27, 1
%61 = icmp eq i64 %60, %25
br i1 %61, label %29, label %26
62: ; preds = %113, %30
%63 = phi i64 [ 0, %30 ], [ %114, %113 ]
%64 = mul nsw i64 %63, %31
br label %65
65: ; preds = %110, %62
%66 = phi i64 [ 0, %62 ], [ %111, %110 ]
%67 = add nuw nsw i64 %66, %64
%68 = getelementptr inbounds double, double* %13, i64 %67
%69 = load double, double* %68
%70 = fmul double %69, 2.123000e+03
store double %70, double* %68
br i1 %35, label %97, label %71
71: ; preds = %65, %71
%72 = phi double [ %93, %71 ], [ %70, %65 ]
%73 = phi i64 [ %94, %71 ], [ 0, %65 ]
%74 = phi i64 [ %95, %71 ], [ 0, %65 ]
%75 = add nuw nsw i64 %73, %64
%76 = getelementptr inbounds double, double* %7, i64 %75
%77 = load double, double* %76
%78 = fmul double %77, 3.241200e+04
%79 = mul nsw i64 %73, %31
%80 = add nuw nsw i64 %79, %66
%81 = getelementptr inbounds double, double* %9, i64 %80
%82 = load double, double* %81
%83 = tail call double @llvm.fmuladd.f64(double %78, double %82, double %72)
store double %83, double* %68
%84 = or i64 %73, 1
%85 = add nuw nsw i64 %84, %64
%86 = getelementptr inbounds double, double* %7, i64 %85
%87 = load double, double* %86
%88 = fmul double %87, 3.241200e+04
%89 = mul nsw i64 %84, %31
%90 = add nuw nsw i64 %89, %66
%91 = getelementptr inbounds double, double* %9, i64 %90
%92 = load double, double* %91
%93 = tail call double @llvm.fmuladd.f64(double %88, double %92, double %83)
store double %93, double* %68
%94 = add nuw nsw i64 %73, 2
%95 = add i64 %74, 2
%96 = icmp eq i64 %95, %36
br i1 %96, label %97, label %71
97: ; preds = %71, %65
%98 = phi double [ %70, %65 ], [ %93, %71 ]
%99 = phi i64 [ 0, %65 ], [ %94, %71 ]
br i1 %37, label %110, label %100
100: ; preds = %97
%101 = add nuw nsw i64 %99, %64
%102 = getelementptr inbounds double, double* %7, i64 %101
%103 = load double, double* %102
%104 = fmul double %103, 3.241200e+04
%105 = mul nsw i64 %99, %31
%106 = add nuw nsw i64 %105, %66
%107 = getelementptr inbounds double, double* %9, i64 %106
%108 = load double, double* %107
%109 = tail call double @llvm.fmuladd.f64(double %104, double %108, double %98)
store double %109, double* %68
br label %110
110: ; preds = %97, %100
%111 = add nuw nsw i64 %66, 1
%112 = icmp eq i64 %111, %32
br i1 %112, label %113, label %65
113: ; preds = %110
%114 = add nuw nsw i64 %63, 1
%115 = icmp eq i64 %114, %32
br i1 %115, label %118, label %62
116: ; preds = %29, %21
%117 = tail call double (...) @omp_get_wtime()
br label %181
118: ; preds = %113
%119 = tail call double (...) @omp_get_wtime()
br i1 %22, label %120, label %181
120: ; preds = %118
%121 = zext i32 %3 to i64
%122 = zext i32 %3 to i64
%123 = and i64 %25, 1
%124 = icmp eq i64 %33, 0
%125 = and i64 %25, 4294967294
%126 = icmp eq i64 %123, 0
br label %127
127: ; preds = %178, %120
%128 = phi i64 [ 0, %120 ], [ %179, %178 ]
%129 = mul nsw i64 %128, %121
br label %130
130: ; preds = %175, %127
%131 = phi i64 [ 0, %127 ], [ %176, %175 ]
%132 = add nuw nsw i64 %131, %129
%133 = getelementptr inbounds double, double* %11, i64 %132
%134 = load double, double* %133
%135 = fmul double %134, 2.123000e+03
store double %135, double* %133
br i1 %124, label %162, label %136
136: ; preds = %130, %136
%137 = phi double [ %158, %136 ], [ %135, %130 ]
%138 = phi i64 [ %159, %136 ], [ 0, %130 ]
%139 = phi i64 [ %160, %136 ], [ 0, %130 ]
%140 = add nuw nsw i64 %138, %129
%141 = getelementptr inbounds double, double* %7, i64 %140
%142 = load double, double* %141
%143 = fmul double %142, 3.241200e+04
%144 = mul nsw i64 %138, %121
%145 = add nuw nsw i64 %144, %131
%146 = getelementptr inbounds double, double* %9, i64 %145
%147 = load double, double* %146
%148 = tail call double @llvm.fmuladd.f64(double %143, double %147, double %137)
store double %148, double* %133
%149 = or i64 %138, 1
%150 = add nuw nsw i64 %149, %129
%151 = getelementptr inbounds double, double* %7, i64 %150
%152 = load double, double* %151
%153 = fmul double %152, 3.241200e+04
%154 = mul nsw i64 %149, %121
%155 = add nuw nsw i64 %154, %131
%156 = getelementptr inbounds double, double* %9, i64 %155
%157 = load double, double* %156
%158 = tail call double @llvm.fmuladd.f64(double %153, double %157, double %148)
store double %158, double* %133
%159 = add nuw nsw i64 %138, 2
%160 = add i64 %139, 2
%161 = icmp eq i64 %160, %125
br i1 %161, label %162, label %136
162: ; preds = %136, %130
%163 = phi double [ %135, %130 ], [ %158, %136 ]
%164 = phi i64 [ 0, %130 ], [ %159, %136 ]
br i1 %126, label %175, label %165
165: ; preds = %162
%166 = add nuw nsw i64 %164, %129
%167 = getelementptr inbounds double, double* %7, i64 %166
%168 = load double, double* %167
%169 = fmul double %168, 3.241200e+04
%170 = mul nsw i64 %164, %121
%171 = add nuw nsw i64 %170, %131
%172 = getelementptr inbounds double, double* %9, i64 %171
%173 = load double, double* %172
%174 = tail call double @llvm.fmuladd.f64(double %169, double %173, double %163)
store double %174, double* %133
br label %175
175: ; preds = %162, %165
%176 = add nuw nsw i64 %131, 1
%177 = icmp eq i64 %176, %122
br i1 %177, label %178, label %130
178: ; preds = %175
%179 = add nuw nsw i64 %128, 1
%180 = icmp eq i64 %179, %122
br i1 %180, label %184, label %127
181: ; preds = %116, %118
%182 = phi double [ %119, %118 ], [ %117, %116 ]
%183 = tail call double (...) @omp_get_wtime()
br label %261
184: ; preds = %178
%185 = tail call double (...) @omp_get_wtime()
br i1 %22, label %186, label %261
186: ; preds = %184
%187 = zext i32 %3 to i64
%188 = zext i32 %3 to i64
%189 = icmp ult i32 %3, 4
%190 = and i64 %25, 4294967292
%191 = icmp eq i64 %190, %25
br label %192
192: ; preds = %257, %186
%193 = phi i64 [ 0, %186 ], [ %259, %257 ]
%194 = phi i32 [ 0, %186 ], [ %258, %257 ]
%195 = mul nsw i64 %193, %187
br i1 %189, label %239, label %196
196: ; preds = %192
%197 = insertelement <2 x i32> poison, i32 %194, i64 0
%198 = shufflevector <2 x i32> %197, <2 x i32> poison, <2 x i32> zeroinitializer
br label %199
199: ; preds = %199, %196
%200 = phi i64 [ 0, %196 ], [ %226, %199 ]
%201 = phi <2 x i32> [ %198, %196 ], [ %224, %199 ]
%202 = phi <2 x i32> [ %198, %196 ], [ %225, %199 ]
%203 = add nuw nsw i64 %200, %195
%204 = getelementptr inbounds double, double* %13, i64 %203
%205 = bitcast double* %204 to <2 x double>*
%206 = load <2 x double>, <2 x double>* %205
%207 = getelementptr inbounds double, double* %204, i64 2
%208 = bitcast double* %207 to <2 x double>*
%209 = load <2 x double>, <2 x double>* %208
%210 = getelementptr inbounds double, double* %11, i64 %203
%211 = bitcast double* %210 to <2 x double>*
%212 = load <2 x double>, <2 x double>* %211
%213 = getelementptr inbounds double, double* %210, i64 2
%214 = bitcast double* %213 to <2 x double>*
%215 = load <2 x double>, <2 x double>* %214
%216 = fsub <2 x double> %206, %212
%217 = fsub <2 x double> %209, %215
%218 = call <2 x double> @llvm.fabs.v2f64(<2 x double> %216)
%219 = call <2 x double> @llvm.fabs.v2f64(<2 x double> %217)
%220 = fdiv <2 x double> %218, %206
%221 = fdiv <2 x double> %219, %209
%222 = fcmp ogt <2 x double> %220, <double 0x3D06849B86A12B9B, double 0x3D06849B86A12B9B>
%223 = fcmp ogt <2 x double> %221, <double 0x3D06849B86A12B9B, double 0x3D06849B86A12B9B>
%224 = select <2 x i1> %222, <2 x i32> <i32 1, i32 1>, <2 x i32> %201
%225 = select <2 x i1> %223, <2 x i32> <i32 1, i32 1>, <2 x i32> %202
%226 = add nuw i64 %200, 4
%227 = icmp eq i64 %226, %190
br i1 %227, label %228, label %199
228: ; preds = %199
%229 = insertelement <2 x i32> poison, i32 %194, i64 0
%230 = shufflevector <2 x i32> %229, <2 x i32> poison, <2 x i32> zeroinitializer
%231 = icmp eq <2 x i32> %224, %230
%232 = select <2 x i1> %231, <2 x i32> %225, <2 x i32> %224
%233 = insertelement <2 x i32> poison, i32 %194, i64 0
%234 = shufflevector <2 x i32> %233, <2 x i32> poison, <2 x i32> zeroinitializer
%235 = bitcast <2 x i32> %232 to i64
%236 = bitcast <2 x i32> %234 to i64
%237 = icmp eq i64 %235, %236
%238 = select i1 %237, i32 %194, i32 1
br i1 %191, label %257, label %239
239: ; preds = %192, %228
%240 = phi i64 [ 0, %192 ], [ %190, %228 ]
%241 = phi i32 [ %194, %192 ], [ %238, %228 ]
br label %242
242: ; preds = %239, %242
%243 = phi i64 [ %255, %242 ], [ %240, %239 ]
%244 = phi i32 [ %254, %242 ], [ %241, %239 ]
%245 = add nuw nsw i64 %243, %195
%246 = getelementptr inbounds double, double* %13, i64 %245
%247 = load double, double* %246
%248 = getelementptr inbounds double, double* %11, i64 %245
%249 = load double, double* %248
%250 = fsub double %247, %249
%251 = tail call double @llvm.fabs.f64(double %250)
%252 = fdiv double %251, %247
%253 = fcmp ogt double %252, 0x3D06849B86A12B9B
%254 = select i1 %253, i32 1, i32 %244
%255 = add nuw nsw i64 %243, 1
%256 = icmp eq i64 %255, %188
br i1 %256, label %257, label %242
257: ; preds = %242, %228
%258 = phi i32 [ %238, %228 ], [ %254, %242 ]
%259 = add nuw nsw i64 %193, 1
%260 = icmp eq i64 %259, %188
br i1 %260, label %261, label %192
261: ; preds = %257, %181, %184
%262 = phi double [ %185, %184 ], [ %183, %181 ], [ %185, %257 ]
%263 = phi double [ %119, %184 ], [ %182, %181 ], [ %119, %257 ]
%264 = phi i32 [ 0, %184 ], [ 0, %181 ], [ %258, %257 ]
%265 = tail call i32 @free(double* %11)
%266 = tail call i32 @free(double* %13)
%267 = tail call i32 @free(double* %7)
%268 = tail call i32 @free(double* %9)
%269 = icmp eq i32 %264, 0
%270 = fsub double %262, %263
%271 = select i1 %269, double %270, double -1.100000e+04
br label %272
272: ; preds = %261, %0
%273 = phi double [ -1.000000e+04, %0 ], [ %271, %261 ]
ret double %273
}