#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 GetTimer();
int /*<<< orphan*/ StartTimer();
float asinf(float);
float expf(float const);
int /*<<< orphan*/ fabsf(float);
float fmaxf(float, int /*<<< orphan*/);
scalar_t__ malloc(int);
int /*<<< orphan*/ memset(float *, int /*<<< orphan*/, int);
int /*<<< orphan*/ printf(char *, double, ...);
float sinf(float const);
int main(int argc, char **argv) {
  int n = 4096;
  int m = 4096;
  int iter_max = 1000;
  const float pi = 2.0f * asinf(1.0f);
  const float tol = 1.0e-5f;
  float error = 1.0f;
  float *restrict A = (float *)malloc(sizeof(float) * n * m);
  float *restrict Anew = (float *)malloc(sizeof(float) * n * m);
  float *restrict y0 = (float *)malloc(sizeof(float) * n);
  memset(A, 0, n * m * sizeof(float));
  for (int i = 0; i < m; i++) {
    A[0 * m + i] = 0.f;
    A[(n - 1) * m + i] = 0.f;
  }
  for (int j = 0; j < n; j++) {
    y0[j] = sinf(pi * j / (n - 1));
    A[j * m + 0] = y0[j];
    A[j * m + m - 1] = y0[j] * expf(-pi);
  }
  printf("Jacobi relaxation Calculation: %d x %d mesh\n", n, m);
  StartTimer();
  int iter = 0;
#pragma omp parallel for shared(Anew)
  for (int i = 1; i < m; i++) {
    Anew[0 * m + i] = 0.f;
    Anew[(n - 1) * m + i] = 0.f;
  }
#pragma omp parallel for shared(Anew)
  for (int j = 1; j < n; j++) {
    Anew[j * m + 0] = y0[j];
    Anew[j * m + m - 1] = y0[j] * expf(-pi);
  }
  while (error > tol && iter < iter_max) {
    error = 0.f;
#pragma acc kernels
    {
#pragma acc loop independent
      for (int j = 1; j < n - 1; j++) {
        for (int i = 1; i < m - 1; i++) {
          Anew[j * m + i] = 0.25f * (A[j * m + i + 1] + A[j * m + i - 1] +
                                     A[(j - 1) * m + i] + A[(j + 1) * m + i]);
          error = fmaxf(error, fabsf(Anew[j * m + i] - A[j * m + i]));
        }
      }
#pragma acc loop independent
      for (int j = 1; j < n - 1; j++) {
        for (int i = 1; i < m - 1; i++) {
          A[j * m + i] = Anew[j * m + i];
        }
      }
    }
    if (iter % 100 == 0)
      printf("%5d, %0.6f\n", iter, error);
    iter++;
  }
  double runtime = GetTimer();
  printf(" total: %f s\n", runtime / 1000.f);
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x1000,-0x14(%rbp)
movl   $0x1000,-0x18(%rbp)
movl   $0x3e8,-0x1c(%rbp)
movss  0xe2a(%rip),%xmm0
call   10c0 <asinf@plt>
movaps %xmm0,%xmm1
movss  0xe22(%rip),%xmm0
mulss  %xmm1,%xmm0
movss  %xmm0,-0x20(%rbp)
movss  0xe0d(%rip),%xmm0
movss  %xmm0,-0x24(%rbp)
movss  0xdfc(%rip),%xmm0
movss  %xmm0,-0x28(%rbp)
movslq -0x14(%rbp),%rax
shl    $0x2,%rax
movslq -0x18(%rbp),%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   10a0 <malloc@plt>
mov    %rax,-0x30(%rbp)
movslq -0x14(%rbp),%rax
shl    $0x2,%rax
movslq -0x18(%rbp),%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   10a0 <malloc@plt>
mov    %rax,-0x38(%rbp)
movslq -0x14(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   10a0 <malloc@plt>
mov    %rax,-0x40(%rbp)
mov    -0x30(%rbp),%rdi
mov    -0x14(%rbp),%eax
imul   -0x18(%rbp),%eax
cltq
shl    $0x2,%rax
mov    %eax,%edx
xor    %esi,%esi
call   1080 <memset@plt>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    12bf <main+0x11f>
mov    -0x30(%rbp),%rax
imul   $0x0,-0x18(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x18(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1273 <main+0xd3>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    137f <main+0x1df>
movss  -0x20(%rbp),%xmm0
cvtsi2ssl -0x48(%rbp),%xmm1
mulss  %xmm1,%xmm0
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
cvtsi2ss %eax,%xmm1
divss  %xmm1,%xmm0
call   1040 <sinf@plt>
mov    -0x40(%rbp),%rax
movslq -0x48(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x48(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x20(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
call   1070 <expf@plt>
movaps %xmm0,%xmm1
movss  -0x74(%rbp),%xmm0
mulss  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
mov    -0x48(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    12c6 <main+0x126>
cvtsi2sdl -0x14(%rbp),%xmm0
mov    -0x18(%rbp),%esi
lea    0xc8a(%rip),%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    $0x0,%al
call   10b0 <StartTimer@plt>
movl   $0x0,-0x4c(%rbp)
movl   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    13f6 <main+0x256>
mov    -0x38(%rbp),%rax
imul   $0x0,-0x18(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x18(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    13aa <main+0x20a>
movl   $0x1,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1488 <main+0x2e8>
mov    -0x40(%rbp),%rax
movslq -0x54(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%rax
movslq -0x54(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x20(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
call   1070 <expf@plt>
movaps %xmm0,%xmm1
movss  -0x78(%rbp),%xmm0
mulss  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    13fd <main+0x25d>
jmp    148d <main+0x2ed>
movss  -0x28(%rbp),%xmm0
xor    %eax,%eax
movss  0xb68(%rip),%xmm1
ucomiss %xmm1,%xmm0
mov    %al,-0x79(%rbp)
jbe    14b4 <main+0x314>
mov    -0x4c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
setl   %al
mov    %al,-0x79(%rbp)
mov    -0x79(%rbp),%al
test   $0x1,%al
jne    14c4 <main+0x324>
jmp    16aa <main+0x50a>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x28(%rbp)
movl   $0x1,-0x58(%rbp)
mov    -0x58(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    15ef <main+0x44f>
movl   $0x1,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    15dc <main+0x43c>
mov    -0x30(%rbp),%rax
mov    -0x58(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x5c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x30(%rbp),%rax
mov    -0x58(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x5c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm1
mov    -0x30(%rbp),%rax
mov    -0x58(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x18(%rbp),%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm1
mov    -0x30(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    $0x1,%ecx
imul   -0x18(%rbp),%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm1
movss  0xaa4(%rip),%xmm0
mulss  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
mov    -0x58(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x28(%rbp),%xmm0
movss  %xmm0,-0x80(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x58(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x58(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
call   1030 <fabsf@plt>
movss  -0x80(%rbp),%xmm0
mov    %eax,%edi
call   1090 <fmaxf@plt>
movss  %xmm0,-0x28(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    14eb <main+0x34b>
jmp    15e1 <main+0x441>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    14d3 <main+0x333>
movl   $0x1,-0x60(%rbp)
mov    -0x60(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    166c <main+0x4cc>
movl   $0x1,-0x64(%rbp)
mov    -0x64(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1659 <main+0x4b9>
mov    -0x38(%rbp),%rax
mov    -0x60(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x64(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x60(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x64(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    160e <main+0x46e>
jmp    165e <main+0x4be>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    15f6 <main+0x456>
mov    -0x4c(%rbp),%eax
mov    $0x64,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    169c <main+0x4fc>
cvtsi2sdl -0x4c(%rbp),%xmm0
movss  -0x28(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
lea    0x9b0(%rip),%rdi
mov    $0x2,%al
call   1060 <printf@plt>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    148d <main+0x2ed>
mov    $0x0,%al
call   1050 <GetTimer@plt>
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm0
movsd  0x94d(%rip),%xmm1
divsd  %xmm1,%xmm0
lea    0x983(%rip),%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    -0x4(%rbp),%eax
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    $0x4000000,%edi
call   1090 <malloc@plt>
mov    %rax,%r14
mov    $0x4000000,%edi
call   1090 <malloc@plt>
mov    %rax,%r12
mov    $0x4000,%edi
call   1090 <malloc@plt>
mov    %rax,%r15
xor    %ebx,%ebx
mov    %r14,%rdi
xor    %esi,%esi
mov    $0x4000000,%edx
call   1070 <memset@plt>
mov    $0x4000,%edx
mov    %r14,%rdi
xor    %esi,%esi
call   1070 <memset@plt>
lea    0x3ffc000(%r14),%rdi
mov    $0x4000,%edx
xor    %esi,%esi
call   1070 <memset@plt>
mov    %r14,%rbp
nopl   0x0(%rax,%rax,1)
xorps  %xmm0,%xmm0
cvtsi2ss %ebx,%xmm0
mulss  0xe01(%rip),%xmm0
divss  0xdfd(%rip),%xmm0
call   1040 <sinf@plt>
movss  %xmm0,(%r15,%rbx,4)
movss  %xmm0,0x0(%rbp)
movss  (%r15,%rbx,4),%xmm0
mulss  0xde3(%rip),%xmm0
movss  %xmm0,0x3ffc(%rbp)
add    $0x1,%rbx
add    $0x4000,%rbp
cmp    $0x1000,%rbx
jne    11f0 <main+0x70>
lea    0xde0(%rip),%rdi
movsd  0xdc8(%rip),%xmm0
mov    $0x1000,%esi
mov    $0x1,%al
call   1060 <printf@plt>
xor    %eax,%eax
call   10a0 <StartTimer@plt>
lea    0x4(%r12),%rdi
mov    $0x3ffc,%edx
xor    %esi,%esi
call   1070 <memset@plt>
lea    0x3ffc004(%r12),%rdi
03
mov    $0x3ffc,%edx
xor    %esi,%esi
call   1070 <memset@plt>
lea    0xbffc(%r12),%rax
mov    $0x2,%ecx
movss  0xd6b(%rip),%xmm1
nopl   (%rax)
movss  -0x4(%r15,%rcx,4),%xmm0
movss  %xmm0,-0x7ffc(%rax)
ff
movss  -0x4(%r15,%rcx,4),%xmm0
mulss  %xmm1,%xmm0
movss  %xmm0,-0x4000(%rax)
ff
cmp    $0x1000,%rcx
je     12f3 <main+0x173>
movss  (%r15,%rcx,4),%xmm0
movss  %xmm0,-0x3ffc(%rax)
ff
movss  (%r15,%rcx,4),%xmm0
mulss  %xmm1,%xmm0
movss  %xmm0,(%rax)
add    $0x2,%rcx
add    $0x8000,%rax
jmp    12a0 <main+0x120>
lea    0x8004(%r14),%rax
mov    %rax,0x38(%rsp)
lea    0x4004(%r12),%rax
mov    %rax,0x30(%rsp)
lea    0x4034(%r14),%rax
mov    %rax,0x28(%rsp)
lea    0x4034(%r12),%rax
mov    %rax,0x20(%rsp)
lea    0x4008(%r14),%rax
mov    %rax,0x18(%rsp)
lea    0x400c(%r12),%rax
mov    %rax,0x10(%rsp)
xor    %eax,%eax
movss  0xcc4(%rip),%xmm2
nopl   0x0(%rax,%rax,1)
mov    %rax,0x40(%rsp)
xorps  %xmm3,%xmm3
mov    $0x1,%ebx
mov    0x30(%rsp),%rbp
mov    0x38(%rsp),%r13
nopw   0x0(%rax,%rax,1)
mov    $0xfffffffffffff002,%r15
nopw   0x0(%rax,%rax,1)
movss  %xmm3,0xc(%rsp)
movss  -0x4(%r13,%r15,4),%xmm0
addss  -0xc(%r13,%r15,4),%xmm0
addss  -0x4008(%r13,%r15,4),%xmm0
bf ff ff
addss  0x3ff8(%r13,%r15,4),%xmm0
mulss  %xmm2,%xmm0
movss  %xmm0,0x3ff8(%rbp,%r15,4)
subss  -0x8(%r13,%r15,4),%xmm0
call   1030 <fabsf@plt>
movss  0xc(%rsp),%xmm0
mov    %eax,%edi
call   1080 <fmaxf@plt>
movss  0xc35(%rip),%xmm2
movaps %xmm0,%xmm3
inc    %r15
jne    1380 <main+0x200>
add    $0x1,%rbx
add    $0x4000,%r13
add    $0x4000,%rbp
cmp    $0xfff,%rbx
jne    1370 <main+0x1f0>
mov    $0x1,%r8d
mov    $0x1000,%r9d
mov    0x10(%rsp),%r10
mov    0x18(%rsp),%r11
mov    0x20(%rsp),%rdi
mov    0x28(%rsp),%rbp
xor    %r15d,%r15d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r15,%rax
shl    $0xe,%rax
lea    (%r12,%rax,1),%rcx
add    $0x7ffc,%rcx
lea    (%r14,%rax,1),%rdx
add    $0x4004,%rdx
cmp    %rcx,%rdx
jae    1471 <main+0x2f1>
lea    (%r12,%rax,1),%rcx
add    $0x4004,%rcx
add    %r14,%rax
add    $0x7ffc,%rax
mov    $0x1,%r13d
cmp    %rax,%rcx
jb     14c6 <main+0x346>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x30(%rdi,%rax,4),%xmm0
movups -0x20(%rdi,%rax,4),%xmm1
movups %xmm0,-0x30(%rbp,%rax,4)
movups %xmm1,-0x20(%rbp,%rax,4)
cmp    $0xff0,%rax
je     14c0 <main+0x340>
movups -0x10(%rdi,%rax,4),%xmm0
movups (%rdi,%rax,4),%xmm1
movups %xmm0,-0x10(%rbp,%rax,4)
movups %xmm1,0x0(%rbp,%rax,4)
add    $0x10,%rax
jmp    1480 <main+0x300>
cs nopw 0x0(%rax,%rax,1)
nop
mov    $0xff9,%r13d
lea    (%r9,%r13,1),%rax
lea    (%r14,%rax,4),%rcx
lea    (%r12,%rax,4),%rsi
mov    $0x1,%edx
xor    %ebx,%ebx
nopl   0x0(%rax)
mov    %rdx,%rax
movss  (%rsi,%rbx,4),%xmm0
movss  %xmm0,(%rcx,%rbx,4)
add    $0x1,%rbx
add    $0x1,%rdx
cmp    $0x2,%rbx
jne    14e0 <main+0x360>
mov    %r13,%rcx
xor    $0xfff,%rcx
lea    (%r11,%r13,4),%rsi
lea    (%r10,%r13,4),%rdx
nopl   (%rax)
movss  -0xc(%rdx,%rax,4),%xmm0
movss  %xmm0,-0x8(%rsi,%rax,4)
movss  -0x8(%rdx,%rax,4),%xmm0
movss  %xmm0,-0x4(%rsi,%rax,4)
movss  -0x4(%rdx,%rax,4),%xmm0
movss  %xmm0,(%rsi,%rax,4)
movss  (%rdx,%rax,4),%xmm0
movss  %xmm0,0x4(%rsi,%rax,4)
add    $0x4,%rax
cmp    %rax,%rcx
jne    1510 <main+0x390>
add    $0x1,%r8
add    $0x1,%r15
add    $0x4000,%rbp
add    $0x4000,%rdi
add    $0x1000,%r9
add    $0x4000,%r11
add    $0x4000,%r10
cmp    $0xfff,%r8
jne    1430 <main+0x2b0>
mov    0x40(%rsp),%rbx
imul   $0xc28f5c29,%ebx,%eax
ror    $0x2,%eax
cmp    $0x28f5c29,%eax
jae    15c4 <main+0x444>
xorps  %xmm0,%xmm0
cvtsi2sd %ebx,%xmm0
xorps  %xmm1,%xmm1
cvtss2sd %xmm3,%xmm1
lea    0xaac(%rip),%rdi
mov    $0x2,%al
movss  %xmm3,0xc(%rsp)
call   1060 <printf@plt>
movss  0xc(%rsp),%xmm3
movss  0xa48(%rip),%xmm2
ucomiss 0xa45(%rip),%xmm3
jbe    15dc <main+0x45c>
lea    0x1(%rbx),%eax
cmp    $0x3e7,%ebx
jb     1350 <main+0x1d0>
xor    %eax,%eax
call   1050 <GetTimer@plt>
divsd  0xa35(%rip),%xmm0
lea    0xa6f(%rip),%rdi
mov    $0x1,%al
call   1060 <printf@plt>
xor    %eax,%eax
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@.str = [45 x i8] c"Jacobi relaxation Calculation: %d x %d mesh\0A\00"
@.str.1 = [12 x i8] c"%5d, %0.6f\0A\00"
@.str.2 = [14 x i8] c" total: %f s\0A\00"
define i32 @main(i32 %0, i8** nocapture readnone %1) {
%3 = tail call i64 @malloc(i32 67108864)
%4 = inttoptr i64 %3 to float*
%5 = inttoptr i64 %3 to i8*
%6 = tail call i64 @malloc(i32 67108864)
%7 = tail call i64 @malloc(i32 16384)
%8 = tail call i32 @memset(float* %4, i32 0, i32 67108864)
%9 = getelementptr float, float* %4, i64 16773120
%10 = bitcast float* %9 to i8*
%11 = inttoptr i64 %7 to float*
br label %20
12: ; preds = %20
%13 = inttoptr i64 %6 to float*
%14 = tail call i32 (i8*, double, ...) @printf(i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str, i64 0, i64 0), double 4.096000e+03, i32 4096)
%15 = tail call i32 (...) @StartTimer()
%16 = getelementptr float, float* %13, i64 1
%17 = bitcast float* %16 to i8*
%18 = getelementptr float, float* %13, i64 16773121
%19 = bitcast float* %18 to i8*
br label %36
20: ; preds = %2, %20
%21 = phi i64 [ 0, %2 ], [ %34, %20 ]
%22 = trunc i64 %21 to i32
%23 = sitofp i32 %22 to float
%24 = fmul float %23, 0x400921FB60000000
%25 = fdiv float %24, 4.095000e+03
%26 = tail call float @sinf(float %25)
%27 = getelementptr inbounds float, float* %11, i64 %21
store float %26, float* %27
%28 = shl nuw nsw i64 %21, 12
%29 = getelementptr inbounds float, float* %4, i64 %28
store float %26, float* %29
%30 = load float, float* %27
%31 = fmul float %30, 0x3FA6202260000000
%32 = or i64 %28, 4095
%33 = getelementptr inbounds float, float* %4, i64 %32
store float %31, float* %33
%34 = add nuw nsw i64 %21, 1
%35 = icmp eq i64 %34, 4096
br i1 %35, label %12, label %20
36: ; preds = %48, %12
%37 = phi i64 [ 1, %12 ], [ %57, %48 ]
%38 = getelementptr inbounds float, float* %11, i64 %37
%39 = load float, float* %38
%40 = shl nuw nsw i64 %37, 12
%41 = getelementptr inbounds float, float* %13, i64 %40
store float %39, float* %41
%42 = load float, float* %38
%43 = fmul float %42, 0x3FA6202260000000
%44 = or i64 %40, 4095
%45 = getelementptr inbounds float, float* %13, i64 %44
store float %43, float* %45
%46 = add nuw nsw i64 %37, 1
%47 = icmp eq i64 %46, 4096
br i1 %47, label %58, label %48
48: ; preds = %36
%49 = getelementptr inbounds float, float* %11, i64 %46
%50 = load float, float* %49
%51 = shl nuw nsw i64 %46, 12
%52 = getelementptr inbounds float, float* %13, i64 %51
store float %50, float* %52
%53 = load float, float* %49
%54 = fmul float %53, 0x3FA6202260000000
%55 = or i64 %51, 4095
%56 = getelementptr inbounds float, float* %13, i64 %55
store float %54, float* %56
%57 = add nuw nsw i64 %37, 2
br label %36
58: ; preds = %36, %184
%59 = phi i32 [ %185, %184 ], [ 0, %36 ]
br label %60
60: ; preds = %58, %64
%61 = phi i64 [ 1, %58 ], [ %65, %64 ]
%62 = phi float [ 0.000000e+00, %58 ], [ %92, %64 ]
%63 = shl nsw i64 %61, 12
br label %67
64: ; preds = %67
%65 = add nuw nsw i64 %61, 1
%66 = icmp eq i64 %65, 4095
br i1 %66, label %95, label %60
67: ; preds = %60, %67
%68 = phi i64 [ 1, %60 ], [ %93, %67 ]
%69 = phi float [ %62, %60 ], [ %92, %67 ]
%70 = add nuw nsw i64 %68, %63
%71 = add nuw nsw i64 %70, 1
%72 = getelementptr inbounds float, float* %4, i64 %71
%73 = load float, float* %72
%74 = add nsw i64 %70, -1
%75 = getelementptr inbounds float, float* %4, i64 %74
%76 = load float, float* %75
%77 = fadd float %73, %76
%78 = add nsw i64 %70, -4096
%79 = getelementptr inbounds float, float* %4, i64 %78
%80 = load float, float* %79
%81 = fadd float %77, %80
%82 = add nuw nsw i64 %70, 4096
%83 = getelementptr inbounds float, float* %4, i64 %82
%84 = load float, float* %83
%85 = fadd float %81, %84
%86 = fmul float %85, 2.500000e-01
%87 = getelementptr inbounds float, float* %13, i64 %70
store float %86, float* %87
%88 = getelementptr inbounds float, float* %4, i64 %70
%89 = load float, float* %88
%90 = fsub float %86, %89
%91 = tail call i32 @fabsf(float %90)
%92 = tail call float @fmaxf(float %69, i32 %91)
%93 = add nuw nsw i64 %68, 1
%94 = icmp eq i64 %93, 4095
br i1 %94, label %64, label %67
95: ; preds = %64, %153
%96 = phi i64 [ %156, %153 ], [ 0, %64 ]
%97 = phi i64 [ %154, %153 ], [ 1, %64 ]
%98 = shl nuw nsw i64 %96, 12
%99 = add i64 %98, 4097
%100 = add i64 %98, 8191
%101 = shl nsw i64 %97, 12
%102 = getelementptr float, float* %13, i64 %100
%103 = getelementptr float, float* %13, i64 %99
%104 = getelementptr float, float* %4, i64 %100
%105 = getelementptr float, float* %4, i64 %99
%106 = icmp ult float* %105, %102
%107 = icmp ult float* %103, %104
%108 = and i1 %106, %107
br i1 %108, label %109, label %121
109: ; preds = %95, %121
%110 = phi i64 [ 1, %95 ], [ 4089, %121 ]
br label %111
111: ; preds = %111, %109
%112 = phi i64 [ %118, %111 ], [ %110, %109 ]
%113 = phi i64 [ %119, %111 ], [ 0, %109 ]
%114 = add nuw nsw i64 %112, %101
%115 = getelementptr inbounds float, float* %13, i64 %114
%116 = load float, float* %115
%117 = getelementptr inbounds float, float* %4, i64 %114
store float %116, float* %117
%118 = add nuw nsw i64 %112, 1
%119 = add i64 %113, 1
%120 = icmp eq i64 %119, 2
br i1 %120, label %157, label %111
121: ; preds = %95, %136
%122 = phi i64 [ %149, %136 ], [ 0, %95 ]
%123 = or i64 %122, 1
%124 = add nuw nsw i64 %123, %101
%125 = getelementptr inbounds float, float* %13, i64 %124
%126 = bitcast float* %125 to <4 x float>*
%127 = load <4 x float>, <4 x float>* %126
%128 = getelementptr inbounds float, float* %125, i64 4
%129 = bitcast float* %128 to <4 x float>*
%130 = load <4 x float>, <4 x float>* %129
%131 = getelementptr inbounds float, float* %4, i64 %124
%132 = bitcast float* %131 to <4 x float>*
store <4 x float> %127, <4 x float>* %132
%133 = getelementptr inbounds float, float* %131, i64 4
%134 = bitcast float* %133 to <4 x float>*
store <4 x float> %130, <4 x float>* %134
%135 = icmp eq i64 %122, 4080
br i1 %135, label %109, label %136
136: ; preds = %121
%137 = or i64 %122, 9
%138 = add nuw nsw i64 %137, %101
%139 = getelementptr inbounds float, float* %13, i64 %138
%140 = bitcast float* %139 to <4 x float>*
%141 = load <4 x float>, <4 x float>* %140
%142 = getelementptr inbounds float, float* %139, i64 4
%143 = bitcast float* %142 to <4 x float>*
%144 = load <4 x float>, <4 x float>* %143
%145 = getelementptr inbounds float, float* %4, i64 %138
%146 = bitcast float* %145 to <4 x float>*
store <4 x float> %141, <4 x float>* %146
%147 = getelementptr inbounds float, float* %145, i64 4
%148 = bitcast float* %147 to <4 x float>*
store <4 x float> %144, <4 x float>* %148
%149 = add nuw nsw i64 %122, 16
br label %121
150: ; preds = %153
%151 = urem i32 %59, 100
%152 = icmp eq i32 %151, 0
br i1 %152, label %180, label %184
153: ; preds = %157
%154 = add nuw nsw i64 %97, 1
%155 = icmp eq i64 %154, 4095
%156 = add i64 %96, 1
br i1 %155, label %150, label %95
157: ; preds = %111, %157
%158 = phi i64 [ %178, %157 ], [ %118, %111 ]
%159 = add nuw nsw i64 %158, %101
%160 = getelementptr inbounds float, float* %13, i64 %159
%161 = load float, float* %160
%162 = getelementptr inbounds float, float* %4, i64 %159
store float %161, float* %162
%163 = add nuw nsw i64 %158, 1
%164 = add nuw nsw i64 %163, %101
%165 = getelementptr inbounds float, float* %13, i64 %164
%166 = load float, float* %165
%167 = getelementptr inbounds float, float* %4, i64 %164
store float %166, float* %167
%168 = add nuw nsw i64 %158, 2
%169 = add nuw nsw i64 %168, %101
%170 = getelementptr inbounds float, float* %13, i64 %169
%171 = load float, float* %170
%172 = getelementptr inbounds float, float* %4, i64 %169
store float %171, float* %172
%173 = add nuw nsw i64 %158, 3
%174 = add nuw nsw i64 %173, %101
%175 = getelementptr inbounds float, float* %13, i64 %174
%176 = load float, float* %175
%177 = getelementptr inbounds float, float* %4, i64 %174
store float %176, float* %177
%178 = add nuw nsw i64 %158, 4
%179 = icmp eq i64 %178, 4095
br i1 %179, label %153, label %157
180: ; preds = %150
%181 = sitofp i32 %59 to double
%182 = fpext float %92 to double
%183 = tail call i32 (i8*, double, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.1, i64 0, i64 0), double %181, double %182)
br label %184
184: ; preds = %180, %150
%185 = add nuw nsw i32 %59, 1
%186 = fcmp ogt float %92, 0x3EE4F8B580000000
%187 = icmp ult i32 %59, 999
%188 = select i1 %186, i1 %187, i1 false
br i1 %188, label %58, label %189
189: ; preds = %184
%190 = tail call double (...) @GetTimer()
%191 = fdiv double %190, 1.000000e+03
%192 = tail call i32 (i8*, double, ...) @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.2, i64 0, i64 0), double %191)
ret i32 0
}