#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 */
typedef int /*<<< orphan*/ threaded_topics;
typedef int /*<<< orphan*/ threaded_docs;
typedef int /*<<< orphan*/ cont_topics;
typedef int /*<<< orphan*/ cont_docs;

/* Variables and functions */
int /*<<< orphan*/ MMT2x2PB(float *, float *, float *, int, int, int, int, int,
                            int);
void *calloc(int, int);
float millitime();
int /*<<< orphan*/ printf(char *, ...);
float scv_dot(float *, float *);
int /*<<< orphan*/ scv_matrix_by_matrix(float *, float **, float **, int, int);
int main(int argc, char *argv[]) {
  int i, j;
  float *z;
  float *cont_topics;
  float *cont_docs;
  float r[100 * 1000];
  double x_drand48();
  float **threaded_topics, **threaded_docs;
  float t0, t1;
  threaded_docs = calloc(100, sizeof(threaded_docs[0]));
  for (i = 0; i < 100; i++) {
    threaded_docs[i] = calloc(280, sizeof(threaded_docs[0][0]));
    for (j = 0; j < 280; j++) {
      threaded_docs[i][j] = 2 * x_drand48() - 1;
    }
    j = x_drand48() * (i + 1);
    z = threaded_docs[i];
    threaded_docs[i] = threaded_docs[j];
    threaded_docs[j] = z;
  }
  threaded_topics = calloc(1000, sizeof(threaded_topics[0]));
  for (i = 0; i < 1000; i++) {
    threaded_topics[i] = calloc(280, sizeof(threaded_topics[0][0]));
    for (j = 0; j < 280; j++) {
      threaded_topics[i][j] = 2 * x_drand48() - 1;
    }
    j = x_drand48() * (i + 1);
    z = threaded_topics[i];
    threaded_topics[i] = threaded_topics[j];
    threaded_topics[j] = z;
  }
  cont_docs = calloc(100 * 280, sizeof(cont_docs[0]));
  cont_topics = calloc(1000 * 280, sizeof(cont_topics[0]));
  for (i = 0; i < 100; i++) {
    for (j = 0; j < 280; j++) {
      cont_docs[i * 280 + j] = threaded_docs[i][j];
    }
  }
  for (i = 0; i < 1000; i++) {
    for (j = 0; j < 280; j++) {
      cont_topics[i * 280 + j] = threaded_topics[i][j];
    }
  }
  t0 = millitime();
  printf("a\n");
  for (i = 0; i < 100; i++) {
    for (j = 0; j < 1000; j++) {
      r[i * 1000 + j] = scv_dot(threaded_topics[j], threaded_docs[i]);
    }
  }
  t1 = millitime();
  printf("b\n");
  printf("%.3f seconds for %d convectis style categorizations\n", t1 - t0, 100);
  t0 = millitime();
  printf("c\n");
  scv_matrix_by_matrix(r, threaded_topics, threaded_docs, 1000, 100);
  t1 = millitime();
  printf("%.3f seconds for %d matrix categorizations\n", t1 - t0, 100);
  t0 = millitime();
  printf("d\n");
  scv_matrix_by_matrix(r, threaded_docs, threaded_topics, 100, 1000);
  t1 = millitime();
  printf("e\n");
  printf("%.3f seconds for %d matrix categorizations\n", t1 - t0, 100);
  t0 = millitime();
  printf("f\n");
  for (j = 0; j < 1000; j++) {
    for (i = 0; i < 100; i++) {
      r[i * 1000 + j] = scv_dot(threaded_topics[j], threaded_docs[i]);
    }
  }
  t1 = millitime();
  printf("g\n");
  printf("%.3f seconds for %d convectis matrix categorizations\n", t1 - t0,
         100);
  t0 = millitime();
  printf("g\n");
  for (i = 0; i < 100; i++) {
    for (j = 0; j < 1000; j++) {
      r[i * 1000 + j] = scv_dot(cont_topics + j * 280, cont_docs + i * 280);
    }
  }
  t1 = millitime();
  printf("h\n");
  printf("%.3f seconds for %d contiguous array by vector categorizations\n",
         t1 - t0, 100);
  t0 = millitime();
  for (j = 0; j < 1000; j++) {
    for (i = 0; i < 100; i++) {
      r[i * 1000 + j] = scv_dot(cont_topics + j * 280, cont_docs + i * 280);
    }
  }
  t1 = millitime();
  printf("%.3f seconds for %d contiguous array by matrix categorizations\n",
         t1 - t0, 100);
  t0 = millitime();
  MMT2x2PB(r, cont_topics, cont_docs, 1000, 100, 280, 280, 280, 20);
  t1 = millitime();
  printf("%.3f seconds for %d contiguous array blocked categorizations\n",
         t1 - t0, 100);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x61ae0,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    $0x64,%edi
mov    $0x8,%esi
call   1050 <calloc@plt>
mov    %rax,-0x61ac0(%rbp)
movl   $0x0,-0x14(%rbp)
cmpl   $0x64,-0x14(%rbp)
jge    1294 <main+0x124>
mov    $0x118,%edi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,%rdx
mov    -0x61ac0(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
movl   $0x0,-0x18(%rbp)
cmpl   $0x118,-0x18(%rbp)
jge    1226 <main+0xb6>
mov    $0x0,%al
call   1060 <x_drand48@plt>
addsd  %xmm0,%xmm0
movsd  0xe08(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x61ac0(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x18(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    11d8 <main+0x68>
mov    $0x0,%al
call   1060 <x_drand48@plt>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
cvtsi2sd %eax,%xmm1
mulsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0x18(%rbp)
mov    -0x61ac0(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x20(%rbp)
mov    -0x61ac0(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x61ac0(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x20(%rbp),%rdx
mov    -0x61ac0(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    11a6 <main+0x36>
mov    $0x3e8,%edi
mov    $0x8,%esi
call   1050 <calloc@plt>
mov    %rax,-0x61ab8(%rbp)
movl   $0x0,-0x14(%rbp)
cmpl   $0x3e8,-0x14(%rbp)
jge    13a2 <main+0x232>
mov    $0x118,%edi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,%rdx
mov    -0x61ab8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
movl   $0x0,-0x18(%rbp)
cmpl   $0x118,-0x18(%rbp)
jge    1334 <main+0x1c4>
mov    $0x0,%al
call   1060 <x_drand48@plt>
addsd  %xmm0,%xmm0
movsd  0xcfa(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x61ab8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x18(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    12e6 <main+0x176>
mov    $0x0,%al
call   1060 <x_drand48@plt>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
cvtsi2sd %eax,%xmm1
mulsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0x18(%rbp)
mov    -0x61ab8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x20(%rbp)
mov    -0x61ab8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x61ab8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x20(%rbp),%rdx
mov    -0x61ab8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    12b1 <main+0x141>
mov    $0x6d60,%edi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,-0x30(%rbp)
mov    $0x445c0,%edi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,-0x28(%rbp)
movl   $0x0,-0x14(%rbp)
cmpl   $0x64,-0x14(%rbp)
jge    143c <main+0x2cc>
movl   $0x0,-0x18(%rbp)
cmpl   $0x118,-0x18(%rbp)
jge    1429 <main+0x2b9>
mov    -0x61ac0(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x18(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
imul   $0x118,-0x14(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    13e0 <main+0x270>
jmp    142e <main+0x2be>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    13cf <main+0x25f>
movl   $0x0,-0x14(%rbp)
cmpl   $0x3e8,-0x14(%rbp)
jge    14b3 <main+0x343>
movl   $0x0,-0x18(%rbp)
cmpl   $0x118,-0x18(%rbp)
jge    14a0 <main+0x330>
mov    -0x61ab8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x18(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
imul   $0x118,-0x14(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1457 <main+0x2e7>
jmp    14a5 <main+0x335>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1443 <main+0x2d3>
mov    $0x0,%al
call   1080 <millitime@plt>
movss  %xmm0,-0x61ac4(%rbp)
ff
lea    0xb3f(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x14(%rbp)
cmpl   $0x64,-0x14(%rbp)
jge    154e <main+0x3de>
movl   $0x0,-0x18(%rbp)
cmpl   $0x3e8,-0x18(%rbp)
jge    153b <main+0x3cb>
mov    -0x61ab8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x61ac0(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
call   1090 <scv_dot@plt>
imul   $0x3e8,-0x14(%rbp),%eax
add    -0x18(%rbp),%eax
cltq
movss  %xmm0,-0x61ab0(%rbp,%rax,4)
f9 ff
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    14e8 <main+0x378>
jmp    1540 <main+0x3d0>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    14d7 <main+0x367>
mov    $0x0,%al
call   1080 <millitime@plt>
movss  %xmm0,-0x61ac8(%rbp)
ff
lea    0xaa7(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movss  -0x61ac8(%rbp),%xmm0
ff
subss  -0x61ac4(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
lea    0xa88(%rip),%rdi
mov    $0x64,%esi
mov    $0x1,%al
call   1030 <printf@plt>
mov    $0x0,%al
call   1080 <millitime@plt>
movss  %xmm0,-0x61ac4(%rbp)
ff
lea    0xa9b(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    -0x61ab0(%rbp),%rdi
mov    -0x61ab8(%rbp),%rsi
mov    -0x61ac0(%rbp),%rdx
mov    $0x3e8,%ecx
mov    $0x64,%r8d
call   1070 <scv_matrix_by_matrix@plt>
mov    $0x0,%al
call   1080 <millitime@plt>
movss  %xmm0,-0x61ac8(%rbp)
ff
movss  -0x61ac8(%rbp),%xmm0
ff
subss  -0x61ac4(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
lea    0xa48(%rip),%rdi
mov    $0x64,%esi
mov    $0x1,%al
call   1030 <printf@plt>
mov    $0x0,%al
call   1080 <millitime@plt>
movss  %xmm0,-0x61ac4(%rbp)
ff
lea    0xa52(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    -0x61ab0(%rbp),%rdi
mov    -0x61ac0(%rbp),%rsi
mov    -0x61ab8(%rbp),%rdx
mov    $0x64,%ecx
mov    $0x3e8,%r8d
call   1070 <scv_matrix_by_matrix@plt>
mov    $0x0,%al
call   1080 <millitime@plt>
movss  %xmm0,-0x61ac8(%rbp)
ff
lea    0xa13(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movss  -0x61ac8(%rbp),%xmm0
ff
subss  -0x61ac4(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
lea    0x9c2(%rip),%rdi
mov    $0x64,%esi
mov    $0x1,%al
call   1030 <printf@plt>
mov    $0x0,%al
call   1080 <millitime@plt>
movss  %xmm0,-0x61ac4(%rbp)
ff
lea    0x9d2(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x18(%rbp)
cmpl   $0x3e8,-0x18(%rbp)
jge    172b <main+0x5bb>
movl   $0x0,-0x14(%rbp)
cmpl   $0x64,-0x14(%rbp)
jge    1718 <main+0x5a8>
mov    -0x61ab8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x61ac0(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
call   1090 <scv_dot@plt>
imul   $0x3e8,-0x14(%rbp),%eax
add    -0x18(%rbp),%eax
cltq
movss  %xmm0,-0x61ab0(%rbp,%rax,4)
f9 ff
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    16c8 <main+0x558>
jmp    171d <main+0x5ad>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    16b4 <main+0x544>
mov    $0x0,%al
call   1080 <millitime@plt>
movss  %xmm0,-0x61ac8(%rbp)
ff
lea    0x93a(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movss  -0x61ac8(%rbp),%xmm0
ff
subss  -0x61ac4(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
lea    0x91b(%rip),%rdi
mov    $0x64,%esi
mov    $0x1,%al
call   1030 <printf@plt>
mov    $0x0,%al
call   1080 <millitime@plt>
movss  %xmm0,-0x61ac4(%rbp)
ff
lea    0x8f6(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x14(%rbp)
cmpl   $0x64,-0x14(%rbp)
jge    1814 <main+0x6a4>
movl   $0x0,-0x18(%rbp)
cmpl   $0x3e8,-0x18(%rbp)
jge    1801 <main+0x691>
mov    -0x28(%rbp),%rdi
imul   $0x118,-0x18(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x30(%rbp),%rsi
imul   $0x118,-0x14(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rsi
call   1090 <scv_dot@plt>
imul   $0x3e8,-0x14(%rbp),%eax
add    -0x18(%rbp),%eax
cltq
movss  %xmm0,-0x61ab0(%rbp,%rax,4)
f9 ff
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    17a4 <main+0x634>
jmp    1806 <main+0x696>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1793 <main+0x623>
mov    $0x0,%al
call   1080 <millitime@plt>
movss  %xmm0,-0x61ac8(%rbp)
ff
lea    0x88a(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movss  -0x61ac8(%rbp),%xmm0
ff
subss  -0x61ac4(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
lea    0x86b(%rip),%rdi
mov    $0x64,%esi
mov    $0x1,%al
call   1030 <printf@plt>
mov    $0x0,%al
call   1080 <millitime@plt>
movss  %xmm0,-0x61ac4(%rbp)
ff
movl   $0x0,-0x18(%rbp)
cmpl   $0x3e8,-0x18(%rbp)
jge    18ef <main+0x77f>
movl   $0x0,-0x14(%rbp)
cmpl   $0x64,-0x14(%rbp)
jge    18dc <main+0x76c>
mov    -0x28(%rbp),%rdi
imul   $0x118,-0x18(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x30(%rbp),%rsi
imul   $0x118,-0x14(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rsi
call   1090 <scv_dot@plt>
imul   $0x3e8,-0x14(%rbp),%eax
add    -0x18(%rbp),%eax
cltq
movss  %xmm0,-0x61ab0(%rbp,%rax,4)
f9 ff
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1882 <main+0x712>
jmp    18e1 <main+0x771>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    186e <main+0x6fe>
mov    $0x0,%al
call   1080 <millitime@plt>
movss  %xmm0,-0x61ac8(%rbp)
ff
movss  -0x61ac8(%rbp),%xmm0
ff
subss  -0x61ac4(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
lea    0x7de(%rip),%rdi
mov    $0x64,%esi
mov    $0x1,%al
call   1030 <printf@plt>
mov    $0x0,%al
call   1080 <millitime@plt>
movss  %xmm0,-0x61ac4(%rbp)
ff
lea    -0x61ab0(%rbp),%rdi
mov    -0x28(%rbp),%rsi
mov    -0x30(%rbp),%rdx
mov    $0x3e8,%ecx
mov    $0x64,%r8d
mov    $0x118,%r9d
movl   $0x118,(%rsp)
movl   $0x118,0x8(%rsp)
movl   $0x14,0x10(%rsp)
call   1040 <MMT2x2PB@plt>
mov    $0x0,%al
call   1080 <millitime@plt>
movss  %xmm0,-0x61ac8(%rbp)
ff
movss  -0x61ac8(%rbp),%xmm0
ff
subss  -0x61ac4(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
lea    0x79d(%rip),%rdi
mov    $0x64,%esi
mov    $0x1,%al
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x61ae0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x61aa8,%rsp
mov    $0x64,%edi
mov    $0x8,%esi
call   1060 <calloc@plt>
mov    %rax,%r12
xor    %r14d,%r14d
cs nopw 0x0(%rax,%rax,1)
mov    $0x118,%edi
mov    $0x4,%esi
call   1060 <calloc@plt>
mov    %rax,%rbx
mov    %rax,(%r12,%r14,8)
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
xor    %eax,%eax
call   1070 <x_drand48@plt>
addsd  %xmm0,%xmm0
addsd  0xe1d(%rip),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rbx,%rbp,4)
add    $0x1,%rbp
cmp    $0x118,%rbp
jne    11d0 <main+0x50>
xor    %eax,%eax
call   1070 <x_drand48@plt>
lea    0x1(%r14),%rax
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
mulsd  %xmm0,%xmm1
cvttsd2si %xmm1,%ecx
movslq %ecx,%rcx
mov    (%r12,%rcx,8),%rdx
mov    %rdx,(%r12,%r14,8)
mov    %rbx,(%r12,%rcx,8)
mov    %rax,%r14
cmp    $0x64,%rax
jne    11b0 <main+0x30>
mov    $0x3e8,%edi
mov    $0x8,%esi
call   1060 <calloc@plt>
mov    %rax,%r15
xor    %r14d,%r14d
mov    $0x118,%edi
mov    $0x4,%esi
call   1060 <calloc@plt>
mov    %rax,%rbx
mov    %rax,(%r15,%r14,8)
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
xor    %eax,%eax
call   1070 <x_drand48@plt>
addsd  %xmm0,%xmm0
addsd  0xd8d(%rip),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rbx,%rbp,4)
add    $0x1,%rbp
cmp    $0x118,%rbp
jne    1260 <main+0xe0>
xor    %eax,%eax
call   1070 <x_drand48@plt>
lea    0x1(%r14),%rax
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
mulsd  %xmm0,%xmm1
cvttsd2si %xmm1,%ecx
movslq %ecx,%rcx
mov    (%r15,%rcx,8),%rdx
mov    %rdx,(%r15,%r14,8)
mov    %rbx,(%r15,%rcx,8)
mov    %rax,%r14
cmp    $0x3e8,%rax
jne    1240 <main+0xc0>
mov    $0x6d60,%edi
mov    $0x4,%esi
call   1060 <calloc@plt>
mov    %rax,%rbx
mov    $0x445c0,%edi
mov    $0x4,%esi
call   1060 <calloc@plt>
lea    0x70(%rbx),%rcx
xor    %r9d,%r9d
mov    %rbx,0x18(%rsp)
mov    %rbx,%rdx
mov    0x18(%rsp),%rbp
jmp    131c <main+0x19c>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r9
add    $0x460,%rcx
add    $0x460,%rdx
cmp    $0x64,%r9
je     1415 <main+0x295>
imul   $0x460,%r9,%rdi
mov    (%r12,%r9,8),%rsi
lea    (%rdi,%rbp,1),%r8
lea    0x460(%rsi),%rbx
cmp    %rbx,%r8
jae    13a0 <main+0x220>
add    %rbp,%rdi
add    $0x460,%rdi
cmp    %rsi,%rdi
jbe    13a0 <main+0x220>
mov    $0x4,%edi
nopl   0x0(%rax,%rax,1)
movss  -0x10(%rsi,%rdi,4),%xmm0
movss  %xmm0,-0x10(%rdx,%rdi,4)
movss  -0xc(%rsi,%rdi,4),%xmm0
movss  %xmm0,-0xc(%rdx,%rdi,4)
movss  -0x8(%rsi,%rdi,4),%xmm0
movss  %xmm0,-0x8(%rdx,%rdi,4)
movss  -0x4(%rsi,%rdi,4),%xmm0
movss  %xmm0,-0x4(%rdx,%rdi,4)
movss  (%rsi,%rdi,4),%xmm0
movss  %xmm0,(%rdx,%rdi,4)
add    $0x5,%rdi
cmp    $0x11c,%rdi
jne    1350 <main+0x1d0>
jmp    1300 <main+0x180>
nopl   0x0(%rax)
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups (%rsi,%rdi,4),%xmm0
movups 0x10(%rsi,%rdi,4),%xmm1
movups %xmm0,-0x70(%rcx,%rdi,4)
movups %xmm1,-0x60(%rcx,%rdi,4)
movups 0x20(%rsi,%rdi,4),%xmm0
movups 0x30(%rsi,%rdi,4),%xmm1
movups %xmm0,-0x50(%rcx,%rdi,4)
movups %xmm1,-0x40(%rcx,%rdi,4)
movups 0x40(%rsi,%rdi,4),%xmm0
movupd 0x50(%rsi,%rdi,4),%xmm1
movups %xmm0,-0x30(%rcx,%rdi,4)
movupd %xmm1,-0x20(%rcx,%rdi,4)
cmp    $0x100,%rdi
je     1300 <main+0x180>
movups 0x60(%rsi,%rdi,4),%xmm0
movupd 0x70(%rsi,%rdi,4),%xmm1
movups %xmm0,-0x10(%rcx,%rdi,4)
movupd %xmm1,(%rcx,%rdi,4)
add    $0x20,%rdi
jmp    13b0 <main+0x230>
lea    0x70(%rax),%rbp
xor    %ecx,%ecx
mov    %rax,%rdx
jmp    143f <main+0x2bf>
add    $0x1,%rcx
add    $0x460,%rbp
add    $0x460,%rdx
cmp    $0x3e8,%rcx
je     1536 <main+0x3b6>
imul   $0x460,%rcx,%rdi
mov    (%r15,%rcx,8),%rsi
lea    (%rax,%rdi,1),%r8
lea    0x460(%rsi),%rbx
cmp    %rbx,%r8
jae    14c0 <main+0x340>
add    %rax,%rdi
add    $0x460,%rdi
cmp    %rsi,%rdi
jbe    14c0 <main+0x340>
mov    $0x4,%edi
xchg   %ax,%ax
movss  -0x10(%rsi,%rdi,4),%xmm0
movss  %xmm0,-0x10(%rdx,%rdi,4)
movss  -0xc(%rsi,%rdi,4),%xmm0
movss  %xmm0,-0xc(%rdx,%rdi,4)
movss  -0x8(%rsi,%rdi,4),%xmm0
movss  %xmm0,-0x8(%rdx,%rdi,4)
movss  -0x4(%rsi,%rdi,4),%xmm0
movss  %xmm0,-0x4(%rdx,%rdi,4)
movss  (%rsi,%rdi,4),%xmm0
movss  %xmm0,(%rdx,%rdi,4)
add    $0x5,%rdi
cmp    $0x11c,%rdi
jne    1470 <main+0x2f0>
jmp    1420 <main+0x2a0>
nopl   0x0(%rax)
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups (%rsi,%rdi,4),%xmm0
movups 0x10(%rsi,%rdi,4),%xmm1
movups %xmm0,-0x70(%rbp,%rdi,4)
movups %xmm1,-0x60(%rbp,%rdi,4)
movups 0x20(%rsi,%rdi,4),%xmm0
movups 0x30(%rsi,%rdi,4),%xmm1
movups %xmm0,-0x50(%rbp,%rdi,4)
movups %xmm1,-0x40(%rbp,%rdi,4)
movups 0x40(%rsi,%rdi,4),%xmm0
movupd 0x50(%rsi,%rdi,4),%xmm1
movups %xmm0,-0x30(%rbp,%rdi,4)
movupd %xmm1,-0x20(%rbp,%rdi,4)
cmp    $0x100,%rdi
je     1420 <main+0x2a0>
movups 0x60(%rsi,%rdi,4),%xmm0
movupd 0x70(%rsi,%rdi,4),%xmm1
movups %xmm0,-0x10(%rbp,%rdi,4)
movupd %xmm1,0x0(%rbp,%rdi,4)
add    $0x20,%rdi
jmp    14d0 <main+0x350>
mov    %rax,0x10(%rsp)
xor    %r13d,%r13d
xor    %eax,%eax
call   1090 <millitime@plt>
movss  %xmm0,0x8(%rsp)
lea    0xc0b(%rip),%rdi
call   1030 <puts@plt>
lea    0x20(%rsp),%r14
nopl   0x0(%rax)
mov    (%r12,%r13,8),%rbx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
mov    (%r15,%rbp,8),%rdi
mov    %rbx,%rsi
call   10a0 <scv_dot@plt>
movss  %xmm0,(%r14,%rbp,4)
add    $0x1,%rbp
cmp    $0x3e8,%rbp
jne    1570 <main+0x3f0>
add    $0x1,%r13
add    $0xfa0,%r14
cmp    $0x64,%r13
jne    1560 <main+0x3e0>
xor    %r14d,%r14d
xor    %eax,%eax
call   1090 <millitime@plt>
movss  %xmm0,0xc(%rsp)
lea    0xba8(%rip),%rdi
call   1030 <puts@plt>
movss  0xc(%rsp),%xmm0
subss  0x8(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xa35(%rip),%rdi
mov    $0x64,%esi
mov    $0x1,%al
call   1040 <printf@plt>
xor    %eax,%eax
call   1090 <millitime@plt>
movss  %xmm0,0x8(%rsp)
lea    0xb6e(%rip),%rdi
call   1030 <puts@plt>
lea    0x20(%rsp),%r13
mov    %r13,%rdi
mov    %r15,%rsi
mov    %r12,%rdx
mov    $0x3e8,%ecx
mov    $0x64,%r8d
call   1080 <scv_matrix_by_matrix@plt>
xor    %eax,%eax
call   1090 <millitime@plt>
subss  0x8(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xa0f(%rip),%rbx
mov    %rbx,%rdi
mov    $0x64,%esi
mov    $0x1,%al
call   1040 <printf@plt>
xor    %eax,%eax
call   1090 <millitime@plt>
movss  %xmm0,0x8(%rsp)
lea    0xb12(%rip),%rdi
call   1030 <puts@plt>
mov    %r13,%rdi
mov    %r12,%rsi
mov    %r15,%rdx
mov    $0x64,%ecx
mov    $0x3e8,%r8d
call   1080 <scv_matrix_by_matrix@plt>
xor    %eax,%eax
call   1090 <millitime@plt>
movss  %xmm0,0xc(%rsp)
lea    0xae2(%rip),%rdi
call   1030 <puts@plt>
movss  0xc(%rsp),%xmm0
subss  0x8(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rdi
mov    $0x64,%esi
mov    $0x1,%al
call   1040 <printf@plt>
xor    %eax,%eax
call   1090 <millitime@plt>
movss  %xmm0,0x8(%rsp)
lea    0xaac(%rip),%rdi
call   1030 <puts@plt>
mov    %r13,%rbp
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%r15,%r14,8),%rdi
mov    (%r12,%rbx,8),%rsi
call   10a0 <scv_dot@plt>
movss  %xmm0,0x0(%rbp)
add    $0x1,%rbx
add    $0xfa0,%rbp
cmp    $0x64,%rbx
jne    16d0 <main+0x550>
add    $0x1,%r14
add    $0x4,%r13
cmp    $0x3e8,%r14
jne    16c0 <main+0x540>
xor    %r12d,%r12d
xor    %eax,%eax
call   1090 <millitime@plt>
movss  %xmm0,0xc(%rsp)
lea    0xa4e(%rip),%rbx
mov    %rbx,%rdi
call   1030 <puts@plt>
movss  0xc(%rsp),%xmm0
subss  0x8(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0x92f(%rip),%rdi
mov    $0x64,%esi
mov    $0x1,%al
call   1040 <printf@plt>
xor    %eax,%eax
call   1090 <millitime@plt>
movss  %xmm0,0x8(%rsp)
mov    %rbx,%rdi
call   1030 <puts@plt>
lea    0x20(%rsp),%r13
mov    0x18(%rsp),%r15
cs nopw 0x0(%rax,%rax,1)
nop
imul   $0x460,%r12,%r14
add    %r15,%r14
mov    0x10(%rsp),%rbp
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %rbp,%rdi
mov    %r14,%rsi
call   10a0 <scv_dot@plt>
movss  %xmm0,0x0(%r13,%rbx,4)
add    $0x1,%rbx
add    $0x460,%rbp
cmp    $0x3e8,%rbx
jne    1790 <main+0x610>
add    $0x1,%r12
add    $0xfa0,%r13
cmp    $0x64,%r12
jne    1770 <main+0x5f0>
xor    %r12d,%r12d
xor    %eax,%eax
call   1090 <millitime@plt>
movss  %xmm0,0xc(%rsp)
lea    0x98d(%rip),%rdi
call   1030 <puts@plt>
movss  0xc(%rsp),%xmm0
subss  0x8(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0x8a5(%rip),%rdi
mov    $0x64,%esi
mov    $0x1,%al
call   1040 <printf@plt>
xor    %eax,%eax
call   1090 <millitime@plt>
movss  %xmm0,0x8(%rsp)
lea    0x20(%rsp),%r13
nopl   0x0(%rax,%rax,1)
imul   $0x460,%r12,%r14
add    0x10(%rsp),%r14
mov    $0xfffffffffff9e580,%rbx
mov    %r15,%rbp
cs nopw 0x0(%rax,%rax,1)
mov    %r14,%rdi
mov    %rbp,%rsi
call   10a0 <scv_dot@plt>
movss  %xmm0,0x61a80(%r13,%rbx,1)
add    $0x460,%rbp
add    $0xfa0,%rbx
jne    1840 <main+0x6c0>
add    $0x1,%r12
add    $0x4,%r13
cmp    $0x3e8,%r12
jne    1820 <main+0x6a0>
xor    %eax,%eax
call   1090 <millitime@plt>
subss  0x8(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0x851(%rip),%rdi
mov    $0x64,%esi
mov    $0x1,%al
call   1040 <printf@plt>
xor    %eax,%eax
call   1090 <millitime@plt>
movss  %xmm0,0x8(%rsp)
sub    $0x8,%rsp
lea    0x28(%rsp),%rdi
mov    0x18(%rsp),%rsi
mov    %r15,%rdx
mov    $0x3e8,%ecx
mov    $0x64,%r8d
mov    $0x118,%r9d
push   $0x14
push   $0x118
push   $0x118
call   1050 <MMT2x2PB@plt>
add    $0x20,%rsp
xor    %eax,%eax
call   1090 <millitime@plt>
subss  0x8(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0x829(%rip),%rdi
mov    $0x64,%esi
mov    $0x1,%al
call   1040 <printf@plt>
xor    %eax,%eax
add    $0x61aa8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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