#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 size_t j;
typedef size_t i;

/* Variables and functions */
int EXIT_SUCCESS;
int atoi(char *);
int /*<<< orphan*/ exit(int);
int /*<<< orphan*/ free(float *);
scalar_t__ malloc(int);
int malloc_error(char *);
int /*<<< orphan*/ printf(char *, ...);
double seconds();
int sin(int);
int main(int argc, char **argv) {
  int i, j, k, t;
  double t1, t2, nFlops;
  float *u_0_m1 = NULL;
  float *u_0_0 = NULL;
  float *u_0_1 = NULL;
  if (argc != 4) {
    printf("Wrong number of parameters. Syntax:\n%s <x_max> <y_max> <z_max>\n",
           argv[0]);
    exit(-1);
  }
  int x_max = atoi(argv[1]) + 4;
  int y_max = atoi(argv[2]) + 4;
  int z_max = atoi(argv[3]) + 4;
  const int T_MAX = 100;
  const float MIN = -1.f;
  const float MAX = 1.f;
  const float DX = (MAX - MIN) / (x_max - 3);
  const float DT = DX / 2.0f;
  const float DT_DX_SQUARE = DT * DT / (DX * DX);
  u_0_m1 = (float *)malloc(x_max * y_max * z_max * sizeof(float));
  if (u_0_m1 == NULL)
    return malloc_error("u_0_m1");
  u_0_0 = (float *)malloc(x_max * y_max * z_max * sizeof(float));
  if (u_0_0 == NULL) {
    free(u_0_m1);
    return malloc_error("u_0_0");
  }
  u_0_1 = (float *)malloc(x_max * y_max * z_max * sizeof(float));
  if (u_0_1 == NULL) {
    free(u_0_m1);
    free(u_0_0);
    return malloc_error("u_0_1");
  }
#pragma omp parallel for private(k, j, i)
  for (k = 2; k < z_max - 2; k++) {
    for (j = 2; j < y_max - 2; j++) {
      for (i = 2; i < x_max - 2; i++) {
        float x = (i - 1) * DX + MIN;
        float y = (j - 1) * DX + MIN;
        float z = (k - 1) * DX + MIN;
        if (k == 2) {
          u_0_m1[((i) + x_max * ((j) + y_max * (0)))] = 0;
          u_0_m1[((i) + x_max * ((j) + y_max * (1)))] = 0;
          u_0_0[((i) + x_max * ((j) + y_max * (0)))] = 0;
          u_0_0[((i) + x_max * ((j) + y_max * (1)))] = 0;
        }
        if (k == z_max - 3) {
          u_0_m1[((i) + x_max * ((j) + y_max * (z_max - 2)))] = 0;
          u_0_m1[((i) + x_max * ((j) + y_max * (z_max - 1)))] = 0;
          u_0_0[((i) + x_max * ((j) + y_max * (z_max - 2)))] = 0;
          u_0_0[((i) + x_max * ((j) + y_max * (z_max - 1)))] = 0;
        }
        if (j == 2) {
          u_0_m1[((i) + x_max * ((0) + y_max * (k)))] = 0;
          u_0_m1[((i) + x_max * ((1) + y_max * (k)))] = 0;
          u_0_0[((i) + x_max * ((0) + y_max * (k)))] = 0;
          u_0_0[((i) + x_max * ((1) + y_max * (k)))] = 0;
        }
        if (j == y_max - 3) {
          u_0_m1[((i) + x_max * ((y_max - 2) + y_max * (k)))] = 0;
          u_0_m1[((i) + x_max * ((y_max - 1) + y_max * (k)))] = 0;
          u_0_0[((i) + x_max * ((y_max - 2) + y_max * (k)))] = 0;
          u_0_0[((i) + x_max * ((y_max - 1) + y_max * (k)))] = 0;
        }
        if (i == 2) {
          u_0_m1[((0) + x_max * ((j) + y_max * (k)))] = 0;
          u_0_m1[((1) + x_max * ((j) + y_max * (k)))] = 0;
          u_0_0[((0) + x_max * ((j) + y_max * (k)))] = 0;
          u_0_0[((1) + x_max * ((j) + y_max * (k)))] = 0;
        }
        if (i == x_max - 3) {
          u_0_m1[((x_max - 2) + x_max * ((j) + y_max * (k)))] = 0;
          u_0_m1[((x_max - 1) + x_max * ((j) + y_max * (k)))] = 0;
          u_0_0[((x_max - 2) + x_max * ((j) + y_max * (k)))] = 0;
          u_0_0[((x_max - 1) + x_max * ((j) + y_max * (k)))] = 0;
        }
        u_0_0[((i) + x_max * ((j) + y_max * (k)))] =
            (float)(sin(2 * 3.14159265358979323846 * x) *
                    sin(2 * 3.14159265358979323846 * y) *
                    sin(2 * 3.14159265358979323846 * z));
        u_0_m1[((i) + x_max * ((j) + y_max * (k)))] =
            u_0_0[((i) + x_max * ((j) + y_max * (k)))];
      }
    }
  }
  float c1 = 2.0f - DT_DX_SQUARE * 7.5f;
  float c2 = DT_DX_SQUARE * 4.0f / 3.0f;
  float c3 = DT_DX_SQUARE * (-1.0f / 12.0f);
  t1 = seconds();
  for (t = 0; t < T_MAX; t++) {
#pragma omp parallel for private(k, j, i)
    for (k = 2; k < z_max - 2; k++) {
      for (j = 2; j < y_max - 2; j++) {
        for (i = 2; i < x_max - 2; i++) {
          u_0_1[((i) + x_max * ((j) + y_max * (k)))] =
              c1 * u_0_0[((i) + x_max * ((j) + y_max * (k)))] -
              u_0_m1[((i) + x_max * ((j) + y_max * (k)))] +
              +c2 * (u_0_0[((i + 1) + x_max * ((j) + y_max * (k)))] +
                     u_0_0[((i - 1) + x_max * ((j) + y_max * (k)))] +
                     u_0_0[((i) + x_max * ((j + 1) + y_max * (k)))] +
                     u_0_0[((i) + x_max * ((j - 1) + y_max * (k)))] +
                     u_0_0[((i) + x_max * ((j) + y_max * (k + 1)))] +
                     u_0_0[((i) + x_max * ((j) + y_max * (k - 1)))]) +
              c3 * (u_0_0[((i + 2) + x_max * ((j) + y_max * (k)))] +
                    u_0_0[((i - 2) + x_max * ((j) + y_max * (k)))] +
                    u_0_0[((i) + x_max * ((j + 2) + y_max * (k)))] +
                    u_0_0[((i) + x_max * ((j - 2) + y_max * (k)))] +
                    u_0_0[((i) + x_max * ((j) + y_max * (k + 2)))] +
                    u_0_0[((i) + x_max * ((j) + y_max * (k - 2)))]);
        }
      }
    }
    float *tmp = u_0_m1;
    u_0_m1 = u_0_0;
    u_0_0 = u_0_1;
    u_0_1 = tmp;
  }
  t2 = seconds();
  nFlops = (double)(x_max - 4) * (double)(y_max - 4) * (double)(z_max - 4) *
           T_MAX * 16.0;
  printf("FLOPs in stencil code:      %e\n", nFlops);
  printf("Time spent in stencil code: %f\n", t2 - t1);
  printf("Performance in GFlop/s:     %f\n", nFlops / (1e9 * (t2 - t1)));
  free(u_0_m1);
  free(u_0_0);
  free(u_0_1);
  return EXIT_SUCCESS;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movq   $0x0,-0x40(%rbp)
movq   $0x0,-0x48(%rbp)
movq   $0x0,-0x50(%rbp)
cmpl   $0x4,-0x8(%rbp)
je     11da <main+0x5a>
mov    -0x10(%rbp),%rax
mov    (%rax),%rsi
lea    0xe77(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    $0xffffffff,%edi
call   10a0 <exit@plt>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rdi
call   1090 <atoi@plt>
add    $0x4,%eax
mov    %eax,-0x54(%rbp)
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rdi
call   1090 <atoi@plt>
add    $0x4,%eax
mov    %eax,-0x58(%rbp)
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rdi
call   1090 <atoi@plt>
add    $0x4,%eax
mov    %eax,-0x5c(%rbp)
movl   $0x64,-0x60(%rbp)
movss  0xde6(%rip),%xmm0
movss  %xmm0,-0x64(%rbp)
movss  0xdd5(%rip),%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x54(%rbp),%eax
sub    $0x3,%eax
cvtsi2ss %eax,%xmm1
movss  0xdba(%rip),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x6c(%rbp),%xmm0
movss  0xda4(%rip),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x70(%rbp),%xmm0
mulss  -0x70(%rbp),%xmm0
movss  -0x6c(%rbp),%xmm1
mulss  -0x6c(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x74(%rbp)
mov    -0x54(%rbp),%eax
imul   -0x58(%rbp),%eax
imul   -0x5c(%rbp),%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0x40(%rbp)
cmpq   $0x0,-0x40(%rbp)
jne    12bd <main+0x13d>
lea    0xdd0(%rip),%rdi
call   1080 <malloc_error@plt>
mov    %eax,-0x4(%rbp)
jmp    1da5 <main+0xc25>
mov    -0x54(%rbp),%eax
imul   -0x58(%rbp),%eax
imul   -0x5c(%rbp),%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0x48(%rbp)
cmpq   $0x0,-0x48(%rbp)
jne    1301 <main+0x181>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
lea    0xd93(%rip),%rdi
call   1080 <malloc_error@plt>
mov    %eax,-0x4(%rbp)
jmp    1da5 <main+0xc25>
mov    -0x54(%rbp),%eax
imul   -0x58(%rbp),%eax
imul   -0x5c(%rbp),%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0x50(%rbp)
cmpq   $0x0,-0x50(%rbp)
jne    134e <main+0x1ce>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
lea    0xd4c(%rip),%rdi
call   1080 <malloc_error@plt>
mov    %eax,-0x4(%rbp)
jmp    1da5 <main+0xc25>
movl   $0x2,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x5c(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jge    1920 <main+0x7a0>
movl   $0x2,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x58(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jge    190d <main+0x78d>
movl   $0x2,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x54(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jge    18fa <main+0x77a>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
cvtsi2ss %eax,%xmm0
movss  -0x6c(%rbp),%xmm1
mulss  %xmm1,%xmm0
movss  0xc57(%rip),%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,-0x78(%rbp)
mov    -0x18(%rbp),%eax
sub    $0x1,%eax
cvtsi2ss %eax,%xmm0
movss  -0x6c(%rbp),%xmm1
mulss  %xmm1,%xmm0
movss  0xc33(%rip),%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,-0x7c(%rbp)
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
cvtsi2ss %eax,%xmm0
movss  -0x6c(%rbp),%xmm1
mulss  %xmm1,%xmm0
movss  0xc0f(%rip),%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,-0x80(%rbp)
cmpl   $0x2,-0x1c(%rbp)
jne    149c <main+0x31c>
mov    -0x40(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x54(%rbp),%edx
mov    -0x18(%rbp),%esi
imul   $0x0,-0x58(%rbp),%edi
add    %edi,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x54(%rbp),%edx
mov    -0x18(%rbp),%esi
mov    -0x58(%rbp),%edi
shl    $0x0,%edi
add    %edi,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x54(%rbp),%edx
mov    -0x18(%rbp),%esi
imul   $0x0,-0x58(%rbp),%edi
add    %edi,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x54(%rbp),%edx
mov    -0x18(%rbp),%esi
mov    -0x58(%rbp),%edi
shl    $0x0,%edi
add    %edi,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
mov    -0x5c(%rbp),%ecx
sub    $0x3,%ecx
cmp    %ecx,%eax
jne    1565 <main+0x3e5>
mov    -0x40(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x54(%rbp),%edx
mov    -0x18(%rbp),%esi
mov    -0x58(%rbp),%edi
mov    -0x5c(%rbp),%r8d
sub    $0x2,%r8d
imul   %r8d,%edi
add    %edi,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x54(%rbp),%edx
mov    -0x18(%rbp),%esi
mov    -0x58(%rbp),%edi
mov    -0x5c(%rbp),%r8d
sub    $0x1,%r8d
imul   %r8d,%edi
add    %edi,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x54(%rbp),%edx
mov    -0x18(%rbp),%esi
mov    -0x58(%rbp),%edi
mov    -0x5c(%rbp),%r8d
sub    $0x2,%r8d
imul   %r8d,%edi
add    %edi,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x54(%rbp),%edx
mov    -0x18(%rbp),%esi
mov    -0x58(%rbp),%edi
mov    -0x5c(%rbp),%r8d
sub    $0x1,%r8d
imul   %r8d,%edi
add    %edi,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
cmpl   $0x2,-0x18(%rbp)
jne    15ff <main+0x47f>
mov    -0x40(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x54(%rbp),%edx
mov    -0x58(%rbp),%esi
imul   -0x1c(%rbp),%esi
add    $0x0,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x54(%rbp),%edx
mov    -0x58(%rbp),%esi
imul   -0x1c(%rbp),%esi
add    $0x1,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x54(%rbp),%edx
mov    -0x58(%rbp),%esi
imul   -0x1c(%rbp),%esi
add    $0x0,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x54(%rbp),%edx
mov    -0x58(%rbp),%esi
imul   -0x1c(%rbp),%esi
add    $0x1,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
mov    -0x58(%rbp),%ecx
sub    $0x3,%ecx
cmp    %ecx,%eax
jne    16b4 <main+0x534>
mov    -0x40(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x54(%rbp),%edx
mov    -0x58(%rbp),%esi
sub    $0x2,%esi
mov    -0x58(%rbp),%edi
imul   -0x1c(%rbp),%edi
add    %edi,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x54(%rbp),%edx
mov    -0x58(%rbp),%esi
sub    $0x1,%esi
mov    -0x58(%rbp),%edi
imul   -0x1c(%rbp),%edi
add    %edi,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x54(%rbp),%edx
mov    -0x58(%rbp),%esi
sub    $0x2,%esi
mov    -0x58(%rbp),%edi
imul   -0x1c(%rbp),%edi
add    %edi,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x54(%rbp),%edx
mov    -0x58(%rbp),%esi
sub    $0x1,%esi
mov    -0x58(%rbp),%edi
imul   -0x1c(%rbp),%edi
add    %edi,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
cmpl   $0x2,-0x14(%rbp)
jne    174e <main+0x5ce>
mov    -0x40(%rbp),%rax
mov    -0x54(%rbp),%ecx
mov    -0x18(%rbp),%edx
mov    -0x58(%rbp),%esi
imul   -0x1c(%rbp),%esi
add    %esi,%edx
imul   %edx,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%rax
mov    -0x54(%rbp),%ecx
mov    -0x18(%rbp),%edx
mov    -0x58(%rbp),%esi
imul   -0x1c(%rbp),%esi
add    %esi,%edx
imul   %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%rax
mov    -0x54(%rbp),%ecx
mov    -0x18(%rbp),%edx
mov    -0x58(%rbp),%esi
imul   -0x1c(%rbp),%esi
add    %esi,%edx
imul   %edx,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%rax
mov    -0x54(%rbp),%ecx
mov    -0x18(%rbp),%edx
mov    -0x58(%rbp),%esi
imul   -0x1c(%rbp),%esi
add    %esi,%edx
imul   %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
mov    -0x54(%rbp),%ecx
sub    $0x3,%ecx
cmp    %ecx,%eax
jne    1803 <main+0x683>
mov    -0x40(%rbp),%rax
mov    -0x54(%rbp),%ecx
sub    $0x2,%ecx
mov    -0x54(%rbp),%edx
mov    -0x18(%rbp),%esi
mov    -0x58(%rbp),%edi
imul   -0x1c(%rbp),%edi
add    %edi,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%rax
mov    -0x54(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x54(%rbp),%edx
mov    -0x18(%rbp),%esi
mov    -0x58(%rbp),%edi
imul   -0x1c(%rbp),%edi
add    %edi,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%rax
mov    -0x54(%rbp),%ecx
sub    $0x2,%ecx
mov    -0x54(%rbp),%edx
mov    -0x18(%rbp),%esi
mov    -0x58(%rbp),%edi
imul   -0x1c(%rbp),%edi
add    %edi,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%rax
mov    -0x54(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x54(%rbp),%edx
mov    -0x18(%rbp),%esi
mov    -0x58(%rbp),%edi
imul   -0x1c(%rbp),%edi
add    %edi,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x78(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x824(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   1060 <sin@plt>
mov    %eax,-0xa0(%rbp)
movss  -0x7c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x800(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   1060 <sin@plt>
mov    %eax,%ecx
mov    -0xa0(%rbp),%eax
imul   %ecx,%eax
mov    %eax,-0x9c(%rbp)
movss  -0x80(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x7d1(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   1060 <sin@plt>
mov    %eax,%ecx
mov    -0x9c(%rbp),%eax
imul   %ecx,%eax
cvtsi2ss %eax,%xmm0
mov    -0x48(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x54(%rbp),%edx
mov    -0x18(%rbp),%esi
mov    -0x58(%rbp),%edi
imul   -0x1c(%rbp),%edi
add    %edi,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x54(%rbp),%edx
mov    -0x18(%rbp),%esi
mov    -0x58(%rbp),%edi
imul   -0x1c(%rbp),%edi
add    %edi,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x54(%rbp),%edx
mov    -0x18(%rbp),%esi
mov    -0x58(%rbp),%edi
imul   -0x1c(%rbp),%edi
add    %edi,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1385 <main+0x205>
jmp    18ff <main+0x77f>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    136d <main+0x1ed>
jmp    1912 <main+0x792>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1355 <main+0x1d5>
movss  -0x74(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  0x6de(%rip),%xmm1
mulss  %xmm1,%xmm0
movss  0x6ba(%rip),%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  0x6ba(%rip),%xmm0
mulss  -0x74(%rbp),%xmm0
movss  0x6a9(%rip),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  0x691(%rip),%xmm0
mulss  -0x74(%rbp),%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
mov    $0x0,%al
call   1040 <seconds@plt>
movsd  %xmm0,-0x28(%rbp)
movl   $0x0,-0x20(%rbp)
cmpl   $0x64,-0x20(%rbp)
jge    1cd7 <main+0xb57>
movl   $0x2,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x5c(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jge    1ca3 <main+0xb23>
movl   $0x2,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x58(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jge    1c90 <main+0xb10>
movl   $0x2,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x54(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jge    1c7d <main+0xafd>
movss  -0x84(%rbp),%xmm0
ff
mov    -0x48(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x54(%rbp),%edx
mov    -0x18(%rbp),%esi
mov    -0x58(%rbp),%edi
imul   -0x1c(%rbp),%edi
add    %edi,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x40(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x54(%rbp),%edx
mov    -0x18(%rbp),%esi
mov    -0x58(%rbp),%edi
imul   -0x1c(%rbp),%edi
add    %edi,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x88(%rbp),%xmm1
ff
mov    -0x48(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
mov    -0x54(%rbp),%edx
mov    -0x18(%rbp),%esi
mov    -0x58(%rbp),%edi
imul   -0x1c(%rbp),%edi
add    %edi,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x48(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x54(%rbp),%edx
mov    -0x18(%rbp),%esi
mov    -0x58(%rbp),%edi
imul   -0x1c(%rbp),%edi
add    %edi,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x48(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x54(%rbp),%edx
mov    -0x18(%rbp),%esi
add    $0x1,%esi
mov    -0x58(%rbp),%edi
imul   -0x1c(%rbp),%edi
add    %edi,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x48(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x54(%rbp),%edx
mov    -0x18(%rbp),%esi
sub    $0x1,%esi
mov    -0x58(%rbp),%edi
imul   -0x1c(%rbp),%edi
add    %edi,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x48(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x54(%rbp),%edx
mov    -0x18(%rbp),%esi
mov    -0x58(%rbp),%edi
mov    -0x1c(%rbp),%r8d
add    $0x1,%r8d
imul   %r8d,%edi
add    %edi,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x48(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x54(%rbp),%edx
mov    -0x18(%rbp),%esi
mov    -0x58(%rbp),%edi
mov    -0x1c(%rbp),%r8d
sub    $0x1,%r8d
imul   %r8d,%edi
add    %edi,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x8c(%rbp),%xmm0
ff
mov    -0x48(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x2,%ecx
mov    -0x54(%rbp),%edx
mov    -0x18(%rbp),%esi
mov    -0x58(%rbp),%edi
imul   -0x1c(%rbp),%edi
add    %edi,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x48(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x2,%ecx
mov    -0x54(%rbp),%edx
mov    -0x18(%rbp),%esi
mov    -0x58(%rbp),%edi
imul   -0x1c(%rbp),%edi
add    %edi,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x48(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x54(%rbp),%edx
mov    -0x18(%rbp),%esi
add    $0x2,%esi
mov    -0x58(%rbp),%edi
imul   -0x1c(%rbp),%edi
add    %edi,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x48(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x54(%rbp),%edx
mov    -0x18(%rbp),%esi
sub    $0x2,%esi
mov    -0x58(%rbp),%edi
imul   -0x1c(%rbp),%edi
add    %edi,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x48(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x54(%rbp),%edx
mov    -0x18(%rbp),%esi
mov    -0x58(%rbp),%edi
mov    -0x1c(%rbp),%r8d
add    $0x2,%r8d
imul   %r8d,%edi
add    %edi,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mov    -0x48(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x54(%rbp),%edx
mov    -0x18(%rbp),%esi
mov    -0x58(%rbp),%edi
mov    -0x1c(%rbp),%r8d
sub    $0x2,%r8d
imul   %r8d,%edi
add    %edi,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x50(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x54(%rbp),%edx
mov    -0x18(%rbp),%esi
mov    -0x58(%rbp),%edi
imul   -0x1c(%rbp),%edi
add    %edi,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    19dc <main+0x85c>
jmp    1c82 <main+0xb02>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    19c4 <main+0x844>
jmp    1c95 <main+0xb15>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    19ac <main+0x82c>
mov    -0x40(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x50(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x98(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    199b <main+0x81b>
mov    $0x0,%al
call   1040 <seconds@plt>
movsd  %xmm0,-0x30(%rbp)
mov    -0x54(%rbp),%eax
sub    $0x4,%eax
cvtsi2sd %eax,%xmm0
mov    -0x58(%rbp),%eax
sub    $0x4,%eax
cvtsi2sd %eax,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x5c(%rbp),%eax
sub    $0x4,%eax
cvtsi2sd %eax,%xmm1
mulsd  %xmm1,%xmm0
movsd  0x31f(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0x30b(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x38(%rbp),%xmm0
lea    0x361(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
movsd  -0x30(%rbp),%xmm0
subsd  -0x28(%rbp),%xmm0
lea    0x369(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
movsd  -0x38(%rbp),%xmm0
movsd  -0x30(%rbp),%xmm2
subsd  -0x28(%rbp),%xmm2
movsd  0x2b8(%rip),%xmm1
mulsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
lea    0x35c(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
mov    0x2240(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1b8,%rsp
mov    %rsi,%rbx
cmp    $0x4,%edi
jne    1ee9 <main+0xd69>
mov    0x8(%rbx),%rdi
call   1090 <atoi@plt>
mov    %rax,0x50(%rsp)
lea    0x4(%rax),%ebp
mov    0x10(%rbx),%rdi
call   1090 <atoi@plt>
mov    %rax,0x38(%rsp)
lea    0x4(%rax),%r15d
mov    0x18(%rbx),%rdi
call   1090 <atoi@plt>
mov    %rax,0x60(%rsp)
add    $0x4,%eax
mov    %ebp,0x14(%rsp)
mov    %ebp,%ebx
imul   %r15d,%ebx
imul   %eax,%ebx
shl    $0x2,%ebx
mov    %ebx,%edi
call   1070 <malloc@plt>
test   %rax,%rax
je     197c <main+0x7fc>
mov    %rax,%r13
mov    %ebx,%edi
call   1070 <malloc@plt>
test   %rax,%rax
je     1985 <main+0x805>
mov    %rax,0x20(%rsp)
mov    %ebx,%edi
call   1070 <malloc@plt>
mov    %rax,0x68(%rsp)
test   %rax,%rax
je     19a5 <main+0x825>
mov    0x50(%rsp),%rdx
lea    0x1(%rdx),%ecx
cvtsi2ss %ecx,%xmm0
movss  0xdce(%rip),%xmm2
divss  %xmm0,%xmm2
movss  0xdc6(%rip),%xmm1
mulss  %xmm2,%xmm1
mulss  %xmm1,%xmm1
movss  %xmm2,0x58(%rsp)
movaps %xmm2,%xmm0
mulss  %xmm2,%xmm0
divss  %xmm0,%xmm1
mov    0x60(%rsp),%rbp
test   %ebp,%ebp
mov    %rcx,0x138(%rsp)
jle    19d4 <main+0x854>
lea    0x2(%rbp),%r10d
mov    0x38(%rsp),%r14
lea    0x2(%r14),%r11d
lea    0x2(%rdx),%r12d
mov    %r10d,%eax
imul   %r15d,%eax
lea    0x3(%rbp),%ebx
imul   %r15d,%ebx
lea    0x3(%rdx),%ebp
mov    %ecx,%r8d
cmp    $0x4,%r12d
mov    $0x3,%edx
mov    $0x3,%r9d
cmovge %r12d,%r9d
movslq 0x14(%rsp),%rsi
movslq %r15d,%rdi
cltq
movslq %ebx,%r15
movslq %r12d,%rbx
mov    %rbx,0x190(%rsp)
movslq %ebp,%rbx
mov    %rbx,0x188(%rsp)
cmp    $0x4,%r11d
mov    $0x3,%ebx
cmovge %r11d,%ebx
mov    %rbx,0x1a8(%rsp)
movslq %r11d,%r11
cmp    $0x4,%r10d
cmovge %r10d,%edx
mov    %rdx,0xd0(%rsp)
add    $0xfffffffffffffffe,%r8
mov    %r8,0xc0(%rsp)
lea    (%rdi,%rdi,1),%rdx
add    $0x2,%rdx
imul   %rsi,%rdx
mov    0x20(%rsp),%rcx
lea    (%rcx,%rdx,4),%rbp
add    $0x8,%rbp
mov    %rbp,0xf0(%rsp)
mov    %rdi,%rbp
imul   %rsi,%rbp
shl    $0x2,%rbp
mov    %rbp,0x180(%rsp)
lea    -0x10(,%rsi,4),%rbp
ff
add    $0x10,%rbp
mov    %rbp,0x1a0(%rsp)
lea    0x8(,%rdx,4),%rdx
add    %r13,%rdx
mov    %rdx,0xe8(%rsp)
lea    (%r11,%rdi,2),%rdx
imul   %rsi,%rdx
lea    0x8(,%rdx,4),%rbp
add    %r13,%rbp
mov    %rbp,0x130(%rsp)
lea    0x8(%rcx,%rdx,4),%rdx
mov    %rdx,0x128(%rsp)
movslq %r14d,%rdx
lea    (%rdx,%rdi,2),%rdx
add    $0x3,%rdx
imul   %rsi,%rdx
lea    0x8(,%rdx,4),%rbp
add    %r13,%rbp
mov    %rbp,0x120(%rsp)
lea    (%rcx,%rdx,4),%rdx
add    $0x8,%rdx
mov    %rdx,0x118(%rsp)
lea    (%rdi,%rdi,1),%rdx
imul   %rsi,%rdx
lea    0x8(,%rdx,4),%rbp
add    %r13,%rbp
mov    %rbp,0x110(%rsp)
lea    (%rcx,%rdx,4),%rdx
add    $0x8,%rdx
mov    %rdx,0x108(%rsp)
lea    (%rdi,%rdi,1),%rdx
add    $0x1,%rdx
imul   %rsi,%rdx
lea    0x8(,%rdx,4),%rbp
add    %r13,%rbp
mov    %rbp,0x100(%rsp)
lea    (%rcx,%rdx,4),%rdx
add    $0x8,%rdx
mov    %rdx,0xf8(%rsp)
add    $0x2,%rax
imul   %rsi,%rax
lea    0x8(,%rax,4),%rdx
add    %r13,%rdx
mov    %rdx,0x178(%rsp)
lea    (%rcx,%rax,4),%rax
add    $0x8,%rax
mov    %rax,0x170(%rsp)
add    $0x2,%r15
imul   %rsi,%r15
lea    0x8(,%r15,4),%rax
add    %r13,%rax
mov    %rax,0x168(%rsp)
lea    0x8(%rcx,%r15,4),%rax
mov    %rax,0x160(%rsp)
mov    %rdi,0xc8(%rsp)
lea    0x2(%rdi),%rax
imul   %rsi,%rax
lea    0x8(,%rax,4),%rdx
add    %r13,%rdx
mov    %rdx,0x158(%rsp)
lea    (%rcx,%rax,4),%rax
add    $0x8,%rax
mov    %rax,0x150(%rsp)
add    $0xfffffffffffffffe,%r9
mov    %r9,0xb8(%rsp)
mov    0x60(%rsp),%rax
add    $0x1,%eax
mov    %rax,0xb0(%rsp)
lea    0x1(%r14),%ebx
mov    %r13,0x48(%rsp)
lea    0x8(%r13,%rsi,8),%rax
mov    %rax,0x148(%rsp)
mov    %rsi,0xa8(%rsp)
lea    0x8(%rcx,%rsi,8),%rax
mov    %rax,0x140(%rsp)
mov    $0x2,%ebp
movss  %xmm1,0x34(%rsp)
jmp    155a <main+0x3da>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rbp
mov    0x180(%rsp),%rax
add    %rax,0xf0(%rsp)
add    %rax,0xe8(%rsp)
add    %rax,0x130(%rsp)
add    %rax,0x128(%rsp)
add    %rax,0x120(%rsp)
add    %rax,0x118(%rsp)
add    %rax,0x110(%rsp)
add    %rax,0x108(%rsp)
add    %rax,0x100(%rsp)
add    %rax,0xf8(%rsp)
cmp    0xd0(%rsp),%rbp
je     1996 <main+0x816>
cmpl   $0x0,0x38(%rsp)
jle    14f0 <main+0x370>
lea    -0x1(%rbp),%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
mulss  0x58(%rsp),%xmm0
addss  0xa8f(%rip),%xmm0
mov    %rbp,%rax
imul   0xc8(%rsp),%rax
mov    %rax,0x198(%rsp)
cvtss2sd %xmm0,%xmm0
mulsd  0xa87(%rip),%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,0x18(%rsp)
mov    $0x2,%r14d
mov    0x140(%rsp),%rax
mov    %rax,0xa0(%rsp)
mov    0x148(%rsp),%rax
mov    %rax,0x98(%rsp)
mov    0x150(%rsp),%rax
mov    %rax,0x90(%rsp)
mov    0x158(%rsp),%rax
mov    %rax,0x88(%rsp)
mov    0x160(%rsp),%rax
mov    %rax,0x80(%rsp)
mov    0x168(%rsp),%rax
mov    %rax,0x78(%rsp)
mov    0x170(%rsp),%rax
mov    %rax,0x40(%rsp)
mov    0x178(%rsp),%rax
mov    %rax,0x70(%rsp)
mov    0xe8(%rsp),%rax
mov    %rax,0x8(%rsp)
mov    0xf0(%rsp),%rax
mov    %rax,0x28(%rsp)
jmp    169b <main+0x51b>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r14
mov    0x1a0(%rsp),%rax
add    %rax,0x28(%rsp)
add    %rax,0x8(%rsp)
add    %rax,0x70(%rsp)
add    %rax,0x40(%rsp)
add    %rax,0x78(%rsp)
add    %rax,0x80(%rsp)
add    %rax,0x88(%rsp)
add    %rax,0x90(%rsp)
add    %rax,0x98(%rsp)
add    %rax,0xa0(%rsp)
cmp    0x1a8(%rsp),%r14
je     14f0 <main+0x370>
cmpl   $0x0,0x50(%rsp)
jle    1640 <main+0x4c0>
lea    -0x1(%r14),%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
mulss  0x58(%rsp),%xmm0
addss  0x94d(%rip),%xmm0
mov    0x198(%rsp),%rax
lea    (%r14,%rax,1),%rsi
imul   0xa8(%rsp),%rsi
mov    0x190(%rsp),%rax
add    %rsi,%rax
mov    %rax,0xe0(%rsp)
mov    0x188(%rsp),%rax
mov    %rsi,0x1b0(%rsp)
add    %rsi,%rax
mov    %rax,0xd8(%rsp)
cvtss2sd %xmm0,%xmm0
mulsd  0x916(%rip),%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,0x1c(%rsp)
xor    %r12d,%r12d
jmp    178a <main+0x60a>
nopw   0x0(%rax,%rax,1)
cvtss2sd %xmm0,%xmm0
mulsd  0x8f4(%rip),%xmm0
cvttsd2si %xmm0,%edi
call   1060 <sin@plt>
mov    %eax,%r15d
mov    0x1c(%rsp),%edi
call   1060 <sin@plt>
mov    %eax,%r13d
mov    0x18(%rsp),%edi
call   1060 <sin@plt>
imul   %r13d,%eax
imul   %r15d,%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
mov    0x28(%rsp),%rax
movss  %xmm0,(%rax,%r12,4)
mov    0x8(%rsp),%rax
movss  %xmm0,(%rax,%r12,4)
add    $0x1,%r12
cmp    %r12,0xb8(%rsp)
movss  0x34(%rsp),%xmm1
je     1640 <main+0x4c0>
lea    0x1(%r12),%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
mulss  0x58(%rsp),%xmm0
addss  0x864(%rip),%xmm0
cmp    $0x2,%rbp
je     17f0 <main+0x670>
cmp    0xb0(%rsp),%rbp
je     183e <main+0x6be>
cmp    $0x2,%r14
je     187f <main+0x6ff>
cmp    %rbx,%r14
je     18c8 <main+0x748>
test   %r12,%r12
je     1911 <main+0x791>
cmp    %r12,0xc0(%rsp)
jne    1720 <main+0x5a0>
jmp    1941 <main+0x7c1>
nopw   0x0(%rax,%rax,1)
mov    0x98(%rsp),%rax
movl   $0x0,(%rax,%r12,4)
mov    0x88(%rsp),%rax
movl   $0x0,(%rax,%r12,4)
mov    0xa0(%rsp),%rax
movl   $0x0,(%rax,%r12,4)
mov    0x90(%rsp),%rax
movl   $0x0,(%rax,%r12,4)
cmp    0xb0(%rsp),%rbp
jne    17b8 <main+0x638>
mov    0x70(%rsp),%rax
movl   $0x0,(%rax,%r12,4)
mov    0x78(%rsp),%rax
movl   $0x0,(%rax,%r12,4)
mov    0x40(%rsp),%rax
movl   $0x0,(%rax,%r12,4)
mov    0x80(%rsp),%rax
movl   $0x0,(%rax,%r12,4)
cmp    $0x2,%r14
jne    17c2 <main+0x642>
mov    0x110(%rsp),%rax
movl   $0x0,(%rax,%r12,4)
mov    0x100(%rsp),%rax
movl   $0x0,(%rax,%r12,4)
mov    0x108(%rsp),%rax
movl   $0x0,(%rax,%r12,4)
mov    0xf8(%rsp),%rax
movl   $0x0,(%rax,%r12,4)
cmp    %rbx,%r14
jne    17cb <main+0x64b>
mov    0x130(%rsp),%rax
movl   $0x0,(%rax,%r12,4)
mov    0x120(%rsp),%rax
movl   $0x0,(%rax,%r12,4)
mov    0x128(%rsp),%rax
movl   $0x0,(%rax,%r12,4)
mov    0x118(%rsp),%rax
movl   $0x0,(%rax,%r12,4)
test   %r12,%r12
jne    17d4 <main+0x654>
mov    0x48(%rsp),%rax
mov    0x1b0(%rsp),%rsi
movq   $0x0,(%rax,%rsi,4)
mov    0x20(%rsp),%rax
movq   $0x0,(%rax,%rsi,4)
cmp    %r12,0xc0(%rsp)
jne    1720 <main+0x5a0>
mov    0x48(%rsp),%rax
mov    0xe0(%rsp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    0xd8(%rsp),%rdx
movl   $0x0,(%rax,%rdx,4)
mov    0x20(%rsp),%rax
movl   $0x0,(%rax,%rcx,4)
movl   $0x0,(%rax,%rdx,4)
jmp    1720 <main+0x5a0>
lea    0x6fd(%rip),%rdi
jmp    19be <main+0x83e>
mov    %r13,%rdi
call   1030 <free@plt>
lea    0x6f3(%rip),%rdi
jmp    19be <main+0x83e>
mov    0xa8(%rsp),%rbp
mov    0x48(%rsp),%r13
jmp    19f9 <main+0x879>
mov    %r13,%rdi
call   1030 <free@plt>
mov    0x20(%rsp),%rdi
call   1030 <free@plt>
lea    0x6cf(%rip),%rdi
add    $0x1b8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1080 <malloc_error@plt>
movslq 0x14(%rsp),%rbp
mov    0x38(%rsp),%rax
lea    0x1(%rax),%ebx
movslq %r15d,%rax
mov    %rax,0xc8(%rsp)
mov    $0x3,%eax
mov    %rax,0xd0(%rsp)
movss  0x60b(%rip),%xmm0
mulss  %xmm1,%xmm0
addss  0x5f3(%rip),%xmm0
movss  %xmm0,0xe0(%rsp)
movss  0x5f2(%rip),%xmm0
mulss  %xmm1,%xmm0
divss  0x5ea(%rip),%xmm0
movss  %xmm0,0xd8(%rsp)
mulss  0x5dd(%rip),%xmm1
movss  %xmm1,0x34(%rsp)
xor    %eax,%eax
mov    %rax,0x40(%rsp)
xor    %eax,%eax
call   1040 <seconds@plt>
movss  0xd8(%rsp),%xmm5
movss  0xe0(%rsp),%xmm4
movss  0x34(%rsp),%xmm3
mov    0x138(%rsp),%rdi
cmp    $0x3,%edi
mov    $0x2,%eax
cmovl  %eax,%edi
cmp    $0x3,%ebx
cmovge %ebx,%eax
movsd  %xmm0,0x70(%rsp)
add    $0x1,%eax
mov    %rax,0x48(%rsp)
mov    %rbp,%r12
lea    0x0(,%rbp,4),%rax
mov    %rax,0xa0(%rsp)
add    $0xffffffffffffffff,%rdi
mov    0x20(%rsp),%rax
mov    %rbp,0xa8(%rsp)
jmp    1adc <main+0x95c>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x40(%rsp),%rcx
add    $0x1,%ecx
mov    %rbx,%r13
mov    %r15,%rax
mov    %rcx,0x40(%rsp)
cmp    $0x64,%ecx
je     1e1a <main+0xc9a>
mov    0x68(%rsp),%r15
mov    %rax,%rbx
mov    %r13,0x68(%rsp)
cmpl   $0x0,0x60(%rsp)
jle    1ac0 <main+0x940>
lea    0x8(%rbx),%rax
mov    %rax,0x20(%rsp)
lea    0xc(%rbx),%rax
mov    %rax,0x88(%rsp)
mov    0x68(%rsp),%rax
add    $0x8,%rax
mov    %rax,0x80(%rsp)
lea    0x8(%r15),%rax
mov    %rax,0x78(%rsp)
mov    $0x2,%eax
mov    %r15,0x90(%rsp)
mov    %rbx,0xb0(%rsp)
jmp    1b69 <main+0x9e9>
cs nopw 0x0(%rax,%rax,1)
mov    0x98(%rsp),%rcx
mov    %rcx,%rax
mov    0x90(%rsp),%r15
mov    0xb0(%rsp),%rbx
cmp    0xd0(%rsp),%rcx
je     1ac0 <main+0x940>
cmpl   $0x0,0x38(%rsp)
jle    1e00 <main+0xc80>
mov    %rax,%rcx
mov    0xc8(%rsp),%rdx
imul   %rdx,%rcx
lea    0x1(%rax),%r8
mov    %r8,0x98(%rsp)
imul   %rdx,%r8
lea    -0x1(%rax),%r9
imul   %rdx,%r9
lea    0x2(%rax),%rbp
imul   %rdx,%rbp
add    $0xfffffffffffffffe,%rax
imul   %rdx,%rax
lea    0x2(%rcx),%esi
imul   %r12d,%esi
add    $0x2,%rax
imul   %r12,%rax
mov    0x20(%rsp),%r10
lea    (%r10,%rax,4),%rbx
add    $0x2,%rbp
imul   %r12,%rbp
lea    (%r10,%rbp,4),%r14
mov    0x14(%rsp),%eax
mov    %eax,%edx
imul   %ecx,%edx
mov    %edx,0x1c(%rsp)
lea    0x4(%rcx),%edx
imul   %eax,%edx
mov    %edx,0x18(%rsp)
add    $0x2,%r9
imul   %r12,%r9
lea    (%r10,%r9,4),%r9
add    $0x2,%r8
imul   %r12,%r8
lea    (%r10,%r8,4),%r10
mov    %rbx,%r8
lea    0x1(%rcx),%edx
imul   %eax,%edx
mov    %edx,0xc0(%rsp)
lea    0x3(%rcx),%edx
imul   %eax,%edx
mov    %edx,0xb8(%rsp)
add    $0x2,%rcx
imul   %r12,%rcx
mov    0x88(%rsp),%rax
lea    (%rax,%rcx,4),%r11
mov    0x80(%rsp),%rax
lea    (%rax,%rcx,4),%rax
mov    0x78(%rsp),%rdx
lea    (%rdx,%rcx,4),%rdx
mov    $0x2,%r15d
mov    0x50(%rsp),%rcx
jmp    1cd7 <main+0xb57>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x58(%rsp),%r15
add    $0x1,%r15
mov    0xa8(%rsp),%r12
add    %r12,%rsi
mov    0xa0(%rsp),%rbp
add    %rbp,%rcx
mov    %rbx,%r14
add    %rbp,%r14
mov    %rcx,%r8
mov    0x14(%rsp),%ecx
add    %ecx,0x1c(%rsp)
add    %ecx,0x18(%rsp)
mov    %rdx,%r9
add    %rbp,%r9
add    %rbp,%rax
add    %ecx,0xc0(%rsp)
add    %ecx,0xb8(%rsp)
add    %rbp,%r11
mov    0x8(%rsp),%rdx
add    %rbp,%rdx
mov    0x28(%rsp),%rbx
add    %rbp,%rbx
cmp    0x48(%rsp),%r15
mov    0x50(%rsp),%rcx
mov    %rax,%r10
mov    %rdx,%rax
mov    %rbx,%rdx
je     1b40 <main+0x9c0>
mov    %rdx,0x28(%rsp)
mov    %rax,0x8(%rsp)
mov    %r15,0x58(%rsp)
test   %ecx,%ecx
mov    %r8,%rcx
mov    %r14,%rbx
mov    %r9,%rdx
mov    %r10,%rax
mov    0xb0(%rsp),%r13
jle    1c60 <main+0xae0>
mov    %rcx,%r8
movslq 0x1c(%rsp),%rcx
mov    0x20(%rsp),%rbp
lea    0x0(,%rcx,4),%r14
add    %rbp,%r14
movslq 0x18(%rsp),%rcx
lea    0x0(%rbp,%rcx,4),%r12
movslq 0xc0(%rsp),%rcx
lea    0x0(,%rcx,4),%r15
add    %rbp,%r15
movslq 0xb8(%rsp),%rcx
lea    0x0(,%rcx,4),%r9
add    %rbp,%r9
xor    %r10d,%r10d
nopl   (%rax)
movss  (%r11,%r10,4),%xmm0
lea    (%rsi,%r10,1),%rcx
mov    %rdi,%rbp
lea    0x1(%rcx),%edi
movslq %edi,%rdi
addss  0x0(%r13,%rdi,4),%xmm0
lea    0x4(%rcx),%edi
movslq %edi,%rdi
movss  0x0(%r13,%rdi,4),%xmm1
mov    %rbp,%rdi
movslq %ecx,%rcx
addss  0x0(%r13,%rcx,4),%xmm1
mov    %r8,%rcx
movss  -0x4(%r11,%r10,4),%xmm2
mulss  %xmm4,%xmm2
mov    0x8(%rsp),%rbp
subss  0x0(%rbp,%r10,4),%xmm2
addss  (%r9,%r10,4),%xmm0
addss  (%r15,%r10,4),%xmm0
addss  (%rax,%r10,4),%xmm0
addss  (%rdx,%r10,4),%xmm0
mulss  %xmm5,%xmm0
addss  (%r12,%r10,4),%xmm1
addss  (%r14,%r10,4),%xmm1
addss  (%rbx,%r10,4),%xmm1
addss  %xmm2,%xmm0
addss  (%r8,%r10,4),%xmm1
mulss  %xmm3,%xmm1
addss  %xmm0,%xmm1
mov    0x28(%rsp),%rbp
movss  %xmm1,0x0(%rbp,%r10,4)
add    $0x1,%r10
cmp    %r10,%rdi
jne    1d50 <main+0xbd0>
jmp    1c60 <main+0xae0>
nopl   0x0(%rax)
add    $0x1,%rax
mov    %rax,%rcx
cmp    0xd0(%rsp),%rcx
jne    1b69 <main+0x9e9>
jmp    1ac0 <main+0x940>
xor    %eax,%eax
call   1040 <seconds@plt>
movsd  %xmm0,0x8(%rsp)
xorps  %xmm0,%xmm0
cvtsi2sdl 0x50(%rsp),%xmm0
xorps  %xmm1,%xmm1
cvtsi2sdl 0x38(%rsp),%xmm1
mulsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsi2sdl 0x60(%rsp),%xmm0
mulsd  %xmm1,%xmm0
mulsd  0x1d6(%rip),%xmm0
mulsd  0x1d6(%rip),%xmm0
movsd  %xmm0,0x28(%rsp)
lea    0x22c(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
movsd  0x8(%rsp),%xmm0
subsd  0x70(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
lea    0x22c(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
movsd  0x8(%rsp),%xmm1
mulsd  0x19c(%rip),%xmm1
movsd  0x28(%rsp),%xmm0
divsd  %xmm1,%xmm0
lea    0x226(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    0x68(%rsp),%rdi
call   1030 <free@plt>
mov    0x210b(%rip),%rax
mov    (%rax),%eax
add    $0x1b8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    (%rbx),%rsi
lea    0x14d(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    $0xffffffff,%edi
call   10a0 <exit@plt>

LLVM IR (-O0):
@.str = [64 x i8] c"Wrong number of parameters. Syntax:\0A%s <x_max> <y_max> <z_max>\0A\00"
@.str.1 = [7 x i8] c"u_0_m1\00"
@.str.2 = [6 x i8] c"u_0_0\00"
@.str.3 = [6 x i8] c"u_0_1\00"
@.str.4 = [32 x i8] c"FLOPs in stencil code: %e\0A\00"
@.str.5 = [32 x i8] c"Time spent in stencil code: %f\0A\00"
@.str.6 = [32 x i8] c"Performance in GFlop/s: %f\0A\00"
@EXIT_SUCCESS = global i32 0
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 i32
%10 = alloca double
%11 = alloca double
%12 = alloca double
%13 = alloca float*
%14 = alloca float*
%15 = alloca float*
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca float
%21 = alloca float
%22 = alloca float
%23 = alloca float
%24 = alloca float
%25 = alloca float
%26 = alloca float
%27 = alloca float
%28 = alloca float
%29 = alloca float
%30 = alloca float
%31 = alloca float*
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
store float* null, float** %13
store float* null, float** %14
store float* null, float** %15
%32 = load i32, i32* %4
%33 = icmp ne i32 %32, 4
br i1 %33, label %34, label %40
34: ; preds = %2
%35 = load i8**, i8*** %5
%36 = getelementptr inbounds i8*, i8** %35, i64 0
%37 = load i8*, i8** %36
%38 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str, i64 0, i64 0), i8* %37)
%39 = call i32 @exit(i32 -1)
unreachable
40: ; preds = %2
%41 = load i8**, i8*** %5
%42 = getelementptr inbounds i8*, i8** %41, i64 1
%43 = load i8*, i8** %42
%44 = call i32 @atoi(i8* %43)
%45 = add nsw i32 %44, 4
store i32 %45, i32* %16
%46 = load i8**, i8*** %5
%47 = getelementptr inbounds i8*, i8** %46, i64 2
%48 = load i8*, i8** %47
%49 = call i32 @atoi(i8* %48)
%50 = add nsw i32 %49, 4
store i32 %50, i32* %17
%51 = load i8**, i8*** %5
%52 = getelementptr inbounds i8*, i8** %51, i64 3
%53 = load i8*, i8** %52
%54 = call i32 @atoi(i8* %53)
%55 = add nsw i32 %54, 4
store i32 %55, i32* %18
store i32 100, i32* %19
store float -1.000000e+00, float* %20
store float 1.000000e+00, float* %21
%56 = load i32, i32* %16
%57 = sub nsw i32 %56, 3
%58 = sitofp i32 %57 to float
%59 = fdiv float 2.000000e+00, %58
store float %59, float* %22
%60 = load float, float* %22
%61 = fdiv float %60, 2.000000e+00
store float %61, float* %23
%62 = load float, float* %23
%63 = load float, float* %23
%64 = fmul float %62, %63
%65 = load float, float* %22
%66 = load float, float* %22
%67 = fmul float %65, %66
%68 = fdiv float %64, %67
store float %68, float* %24
%69 = load i32, i32* %16
%70 = load i32, i32* %17
%71 = mul nsw i32 %69, %70
%72 = load i32, i32* %18
%73 = mul nsw i32 %71, %72
%74 = sext i32 %73 to i64
%75 = mul i64 %74, 4
%76 = trunc i64 %75 to i32
%77 = call i64 @malloc(i32 %76)
%78 = inttoptr i64 %77 to float*
store float* %78, float** %13
%79 = load float*, float** %13
%80 = icmp eq float* %79, null
br i1 %80, label %81, label %83
81: ; preds = %40
%82 = call i32 @malloc_error(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0))
store i32 %82, i32* %3
br label %846
83: ; preds = %40
%84 = load i32, i32* %16
%85 = load i32, i32* %17
%86 = mul nsw i32 %84, %85
%87 = load i32, i32* %18
%88 = mul nsw i32 %86, %87
%89 = sext i32 %88 to i64
%90 = mul i64 %89, 4
%91 = trunc i64 %90 to i32
%92 = call i64 @malloc(i32 %91)
%93 = inttoptr i64 %92 to float*
store float* %93, float** %14
%94 = load float*, float** %14
%95 = icmp eq float* %94, null
br i1 %95, label %96, label %100
96: ; preds = %83
%97 = load float*, float** %13
%98 = call i32 @free(float* %97)
%99 = call i32 @malloc_error(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0))
store i32 %99, i32* %3
br label %846
100: ; preds = %83
%101 = load i32, i32* %16
%102 = load i32, i32* %17
%103 = mul nsw i32 %101, %102
%104 = load i32, i32* %18
%105 = mul nsw i32 %103, %104
%106 = sext i32 %105 to i64
%107 = mul i64 %106, 4
%108 = trunc i64 %107 to i32
%109 = call i64 @malloc(i32 %108)
%110 = inttoptr i64 %109 to float*
store float* %110, float** %15
%111 = load float*, float** %15
%112 = icmp eq float* %111, null
br i1 %112, label %113, label %119
113: ; preds = %100
%114 = load float*, float** %13
%115 = call i32 @free(float* %114)
%116 = load float*, float** %14
%117 = call i32 @free(float* %116)
%118 = call i32 @malloc_error(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0))
store i32 %118, i32* %3
br label %846
119: ; preds = %100
store i32 2, i32* %8
br label %120
120: ; preds = %534, %119
%121 = load i32, i32* %8
%122 = load i32, i32* %18
%123 = sub nsw i32 %122, 2
%124 = icmp slt i32 %121, %123
br i1 %124, label %125, label %537
125: ; preds = %120
store i32 2, i32* %7
br label %126
126: ; preds = %530, %125
%127 = load i32, i32* %7
%128 = load i32, i32* %17
%129 = sub nsw i32 %128, 2
%130 = icmp slt i32 %127, %129
br i1 %130, label %131, label %533
131: ; preds = %126
store i32 2, i32* %6
br label %132
132: ; preds = %526, %131
%133 = load i32, i32* %6
%134 = load i32, i32* %16
%135 = sub nsw i32 %134, 2
%136 = icmp slt i32 %133, %135
br i1 %136, label %137, label %529
137: ; preds = %132
%138 = load i32, i32* %6
%139 = sub nsw i32 %138, 1
%140 = sitofp i32 %139 to float
%141 = load float, float* %22
%142 = call float @llvm.fmuladd.f32(float %140, float %141, float -1.000000e+00)
store float %142, float* %25
%143 = load i32, i32* %7
%144 = sub nsw i32 %143, 1
%145 = sitofp i32 %144 to float
%146 = load float, float* %22
%147 = call float @llvm.fmuladd.f32(float %145, float %146, float -1.000000e+00)
store float %147, float* %26
%148 = load i32, i32* %8
%149 = sub nsw i32 %148, 1
%150 = sitofp i32 %149 to float
%151 = load float, float* %22
%152 = call float @llvm.fmuladd.f32(float %150, float %151, float -1.000000e+00)
store float %152, float* %27
%153 = load i32, i32* %8
%154 = icmp eq i32 %153, 2
br i1 %154, label %155, label %200
155: ; preds = %137
%156 = load float*, float** %13
%157 = load i32, i32* %6
%158 = load i32, i32* %16
%159 = load i32, i32* %7
%160 = load i32, i32* %17
%161 = mul nsw i32 %160, 0
%162 = add nsw i32 %159, %161
%163 = mul nsw i32 %158, %162
%164 = add nsw i32 %157, %163
%165 = sext i32 %164 to i64
%166 = getelementptr inbounds float, float* %156, i64 %165
store float 0.000000e+00, float* %166
%167 = load float*, float** %13
%168 = load i32, i32* %6
%169 = load i32, i32* %16
%170 = load i32, i32* %7
%171 = load i32, i32* %17
%172 = mul nsw i32 %171, 1
%173 = add nsw i32 %170, %172
%174 = mul nsw i32 %169, %173
%175 = add nsw i32 %168, %174
%176 = sext i32 %175 to i64
%177 = getelementptr inbounds float, float* %167, i64 %176
store float 0.000000e+00, float* %177
%178 = load float*, float** %14
%179 = load i32, i32* %6
%180 = load i32, i32* %16
%181 = load i32, i32* %7
%182 = load i32, i32* %17
%183 = mul nsw i32 %182, 0
%184 = add nsw i32 %181, %183
%185 = mul nsw i32 %180, %184
%186 = add nsw i32 %179, %185
%187 = sext i32 %186 to i64
%188 = getelementptr inbounds float, float* %178, i64 %187
store float 0.000000e+00, float* %188
%189 = load float*, float** %14
%190 = load i32, i32* %6
%191 = load i32, i32* %16
%192 = load i32, i32* %7
%193 = load i32, i32* %17
%194 = mul nsw i32 %193, 1
%195 = add nsw i32 %192, %194
%196 = mul nsw i32 %191, %195
%197 = add nsw i32 %190, %196
%198 = sext i32 %197 to i64
%199 = getelementptr inbounds float, float* %189, i64 %198
store float 0.000000e+00, float* %199
br label %200
200: ; preds = %155, %137
%201 = load i32, i32* %8
%202 = load i32, i32* %18
%203 = sub nsw i32 %202, 3
%204 = icmp eq i32 %201, %203
br i1 %204, label %205, label %258
205: ; preds = %200
%206 = load float*, float** %13
%207 = load i32, i32* %6
%208 = load i32, i32* %16
%209 = load i32, i32* %7
%210 = load i32, i32* %17
%211 = load i32, i32* %18
%212 = sub nsw i32 %211, 2
%213 = mul nsw i32 %210, %212
%214 = add nsw i32 %209, %213
%215 = mul nsw i32 %208, %214
%216 = add nsw i32 %207, %215
%217 = sext i32 %216 to i64
%218 = getelementptr inbounds float, float* %206, i64 %217
store float 0.000000e+00, float* %218
%219 = load float*, float** %13
%220 = load i32, i32* %6
%221 = load i32, i32* %16
%222 = load i32, i32* %7
%223 = load i32, i32* %17
%224 = load i32, i32* %18
%225 = sub nsw i32 %224, 1
%226 = mul nsw i32 %223, %225
%227 = add nsw i32 %222, %226
%228 = mul nsw i32 %221, %227
%229 = add nsw i32 %220, %228
%230 = sext i32 %229 to i64
%231 = getelementptr inbounds float, float* %219, i64 %230
store float 0.000000e+00, float* %231
%232 = load float*, float** %14
%233 = load i32, i32* %6
%234 = load i32, i32* %16
%235 = load i32, i32* %7
%236 = load i32, i32* %17
%237 = load i32, i32* %18
%238 = sub nsw i32 %237, 2
%239 = mul nsw i32 %236, %238
%240 = add nsw i32 %235, %239
%241 = mul nsw i32 %234, %240
%242 = add nsw i32 %233, %241
%243 = sext i32 %242 to i64
%244 = getelementptr inbounds float, float* %232, i64 %243
store float 0.000000e+00, float* %244
%245 = load float*, float** %14
%246 = load i32, i32* %6
%247 = load i32, i32* %16
%248 = load i32, i32* %7
%249 = load i32, i32* %17
%250 = load i32, i32* %18
%251 = sub nsw i32 %250, 1
%252 = mul nsw i32 %249, %251
%253 = add nsw i32 %248, %252
%254 = mul nsw i32 %247, %253
%255 = add nsw i32 %246, %254
%256 = sext i32 %255 to i64
%257 = getelementptr inbounds float, float* %245, i64 %256
store float 0.000000e+00, float* %257
br label %258
258: ; preds = %205, %200
%259 = load i32, i32* %7
%260 = icmp eq i32 %259, 2
br i1 %260, label %261, label %306
261: ; preds = %258
%262 = load float*, float** %13
%263 = load i32, i32* %6
%264 = load i32, i32* %16
%265 = load i32, i32* %17
%266 = load i32, i32* %8
%267 = mul nsw i32 %265, %266
%268 = add nsw i32 0, %267
%269 = mul nsw i32 %264, %268
%270 = add nsw i32 %263, %269
%271 = sext i32 %270 to i64
%272 = getelementptr inbounds float, float* %262, i64 %271
store float 0.000000e+00, float* %272
%273 = load float*, float** %13
%274 = load i32, i32* %6
%275 = load i32, i32* %16
%276 = load i32, i32* %17
%277 = load i32, i32* %8
%278 = mul nsw i32 %276, %277
%279 = add nsw i32 1, %278
%280 = mul nsw i32 %275, %279
%281 = add nsw i32 %274, %280
%282 = sext i32 %281 to i64
%283 = getelementptr inbounds float, float* %273, i64 %282
store float 0.000000e+00, float* %283
%284 = load float*, float** %14
%285 = load i32, i32* %6
%286 = load i32, i32* %16
%287 = load i32, i32* %17
%288 = load i32, i32* %8
%289 = mul nsw i32 %287, %288
%290 = add nsw i32 0, %289
%291 = mul nsw i32 %286, %290
%292 = add nsw i32 %285, %291
%293 = sext i32 %292 to i64
%294 = getelementptr inbounds float, float* %284, i64 %293
store float 0.000000e+00, float* %294
%295 = load float*, float** %14
%296 = load i32, i32* %6
%297 = load i32, i32* %16
%298 = load i32, i32* %17
%299 = load i32, i32* %8
%300 = mul nsw i32 %298, %299
%301 = add nsw i32 1, %300
%302 = mul nsw i32 %297, %301
%303 = add nsw i32 %296, %302
%304 = sext i32 %303 to i64
%305 = getelementptr inbounds float, float* %295, i64 %304
store float 0.000000e+00, float* %305
br label %306
306: ; preds = %261, %258
%307 = load i32, i32* %7
%308 = load i32, i32* %17
%309 = sub nsw i32 %308, 3
%310 = icmp eq i32 %307, %309
br i1 %310, label %311, label %364
311: ; preds = %306
%312 = load float*, float** %13
%313 = load i32, i32* %6
%314 = load i32, i32* %16
%315 = load i32, i32* %17
%316 = sub nsw i32 %315, 2
%317 = load i32, i32* %17
%318 = load i32, i32* %8
%319 = mul nsw i32 %317, %318
%320 = add nsw i32 %316, %319
%321 = mul nsw i32 %314, %320
%322 = add nsw i32 %313, %321
%323 = sext i32 %322 to i64
%324 = getelementptr inbounds float, float* %312, i64 %323
store float 0.000000e+00, float* %324
%325 = load float*, float** %13
%326 = load i32, i32* %6
%327 = load i32, i32* %16
%328 = load i32, i32* %17
%329 = sub nsw i32 %328, 1
%330 = load i32, i32* %17
%331 = load i32, i32* %8
%332 = mul nsw i32 %330, %331
%333 = add nsw i32 %329, %332
%334 = mul nsw i32 %327, %333
%335 = add nsw i32 %326, %334
%336 = sext i32 %335 to i64
%337 = getelementptr inbounds float, float* %325, i64 %336
store float 0.000000e+00, float* %337
%338 = load float*, float** %14
%339 = load i32, i32* %6
%340 = load i32, i32* %16
%341 = load i32, i32* %17
%342 = sub nsw i32 %341, 2
%343 = load i32, i32* %17
%344 = load i32, i32* %8
%345 = mul nsw i32 %343, %344
%346 = add nsw i32 %342, %345
%347 = mul nsw i32 %340, %346
%348 = add nsw i32 %339, %347
%349 = sext i32 %348 to i64
%350 = getelementptr inbounds float, float* %338, i64 %349
store float 0.000000e+00, float* %350
%351 = load float*, float** %14
%352 = load i32, i32* %6
%353 = load i32, i32* %16
%354 = load i32, i32* %17
%355 = sub nsw i32 %354, 1
%356 = load i32, i32* %17
%357 = load i32, i32* %8
%358 = mul nsw i32 %356, %357
%359 = add nsw i32 %355, %358
%360 = mul nsw i32 %353, %359
%361 = add nsw i32 %352, %360
%362 = sext i32 %361 to i64
%363 = getelementptr inbounds float, float* %351, i64 %362
store float 0.000000e+00, float* %363
br label %364
364: ; preds = %311, %306
%365 = load i32, i32* %6
%366 = icmp eq i32 %365, 2
br i1 %366, label %367, label %412
367: ; preds = %364
%368 = load float*, float** %13
%369 = load i32, i32* %16
%370 = load i32, i32* %7
%371 = load i32, i32* %17
%372 = load i32, i32* %8
%373 = mul nsw i32 %371, %372
%374 = add nsw i32 %370, %373
%375 = mul nsw i32 %369, %374
%376 = add nsw i32 0, %375
%377 = sext i32 %376 to i64
%378 = getelementptr inbounds float, float* %368, i64 %377
store float 0.000000e+00, float* %378
%379 = load float*, float** %13
%380 = load i32, i32* %16
%381 = load i32, i32* %7
%382 = load i32, i32* %17
%383 = load i32, i32* %8
%384 = mul nsw i32 %382, %383
%385 = add nsw i32 %381, %384
%386 = mul nsw i32 %380, %385
%387 = add nsw i32 1, %386
%388 = sext i32 %387 to i64
%389 = getelementptr inbounds float, float* %379, i64 %388
store float 0.000000e+00, float* %389
%390 = load float*, float** %14
%391 = load i32, i32* %16
%392 = load i32, i32* %7
%393 = load i32, i32* %17
%394 = load i32, i32* %8
%395 = mul nsw i32 %393, %394
%396 = add nsw i32 %392, %395
%397 = mul nsw i32 %391, %396
%398 = add nsw i32 0, %397
%399 = sext i32 %398 to i64
%400 = getelementptr inbounds float, float* %390, i64 %399
store float 0.000000e+00, float* %400
%401 = load float*, float** %14
%402 = load i32, i32* %16
%403 = load i32, i32* %7
%404 = load i32, i32* %17
%405 = load i32, i32* %8
%406 = mul nsw i32 %404, %405
%407 = add nsw i32 %403, %406
%408 = mul nsw i32 %402, %407
%409 = add nsw i32 1, %408
%410 = sext i32 %409 to i64
%411 = getelementptr inbounds float, float* %401, i64 %410
store float 0.000000e+00, float* %411
br label %412
412: ; preds = %367, %364
%413 = load i32, i32* %6
%414 = load i32, i32* %16
%415 = sub nsw i32 %414, 3
%416 = icmp eq i32 %413, %415
br i1 %416, label %417, label %470
417: ; preds = %412
%418 = load float*, float** %13
%419 = load i32, i32* %16
%420 = sub nsw i32 %419, 2
%421 = load i32, i32* %16
%422 = load i32, i32* %7
%423 = load i32, i32* %17
%424 = load i32, i32* %8
%425 = mul nsw i32 %423, %424
%426 = add nsw i32 %422, %425
%427 = mul nsw i32 %421, %426
%428 = add nsw i32 %420, %427
%429 = sext i32 %428 to i64
%430 = getelementptr inbounds float, float* %418, i64 %429
store float 0.000000e+00, float* %430
%431 = load float*, float** %13
%432 = load i32, i32* %16
%433 = sub nsw i32 %432, 1
%434 = load i32, i32* %16
%435 = load i32, i32* %7
%436 = load i32, i32* %17
%437 = load i32, i32* %8
%438 = mul nsw i32 %436, %437
%439 = add nsw i32 %435, %438
%440 = mul nsw i32 %434, %439
%441 = add nsw i32 %433, %440
%442 = sext i32 %441 to i64
%443 = getelementptr inbounds float, float* %431, i64 %442
store float 0.000000e+00, float* %443
%444 = load float*, float** %14
%445 = load i32, i32* %16
%446 = sub nsw i32 %445, 2
%447 = load i32, i32* %16
%448 = load i32, i32* %7
%449 = load i32, i32* %17
%450 = load i32, i32* %8
%451 = mul nsw i32 %449, %450
%452 = add nsw i32 %448, %451
%453 = mul nsw i32 %447, %452
%454 = add nsw i32 %446, %453
%455 = sext i32 %454 to i64
%456 = getelementptr inbounds float, float* %444, i64 %455
store float 0.000000e+00, float* %456
%457 = load float*, float** %14
%458 = load i32, i32* %16
%459 = sub nsw i32 %458, 1
%460 = load i32, i32* %16
%461 = load i32, i32* %7
%462 = load i32, i32* %17
%463 = load i32, i32* %8
%464 = mul nsw i32 %462, %463
%465 = add nsw i32 %461, %464
%466 = mul nsw i32 %460, %465
%467 = add nsw i32 %459, %466
%468 = sext i32 %467 to i64
%469 = getelementptr inbounds float, float* %457, i64 %468
store float 0.000000e+00, float* %469
br label %470
470: ; preds = %417, %412
%471 = load float, float* %25
%472 = fpext float %471 to double
%473 = fmul double 0x401921FB54442D18, %472
%474 = fptosi double %473 to i32
%475 = call i32 @sin(i32 %474)
%476 = load float, float* %26
%477 = fpext float %476 to double
%478 = fmul double 0x401921FB54442D18, %477
%479 = fptosi double %478 to i32
%480 = call i32 @sin(i32 %479)
%481 = mul nsw i32 %475, %480
%482 = load float, float* %27
%483 = fpext float %482 to double
%484 = fmul double 0x401921FB54442D18, %483
%485 = fptosi double %484 to i32
%486 = call i32 @sin(i32 %485)
%487 = mul nsw i32 %481, %486
%488 = sitofp i32 %487 to float
%489 = load float*, float** %14
%490 = load i32, i32* %6
%491 = load i32, i32* %16
%492 = load i32, i32* %7
%493 = load i32, i32* %17
%494 = load i32, i32* %8
%495 = mul nsw i32 %493, %494
%496 = add nsw i32 %492, %495
%497 = mul nsw i32 %491, %496
%498 = add nsw i32 %490, %497
%499 = sext i32 %498 to i64
%500 = getelementptr inbounds float, float* %489, i64 %499
store float %488, float* %500
%501 = load float*, float** %14
%502 = load i32, i32* %6
%503 = load i32, i32* %16
%504 = load i32, i32* %7
%505 = load i32, i32* %17
%506 = load i32, i32* %8
%507 = mul nsw i32 %505, %506
%508 = add nsw i32 %504, %507
%509 = mul nsw i32 %503, %508
%510 = add nsw i32 %502, %509
%511 = sext i32 %510 to i64
%512 = getelementptr inbounds float, float* %501, i64 %511
%513 = load float, float* %512
%514 = load float*, float** %13
%515 = load i32, i32* %6
%516 = load i32, i32* %16
%517 = load i32, i32* %7
%518 = load i32, i32* %17
%519 = load i32, i32* %8
%520 = mul nsw i32 %518, %519
%521 = add nsw i32 %517, %520
%522 = mul nsw i32 %516, %521
%523 = add nsw i32 %515, %522
%524 = sext i32 %523 to i64
%525 = getelementptr inbounds float, float* %514, i64 %524
store float %513, float* %525
br label %526
526: ; preds = %470
%527 = load i32, i32* %6
%528 = add nsw i32 %527, 1
store i32 %528, i32* %6
br label %132
529: ; preds = %132
br label %530
530: ; preds = %529
%531 = load i32, i32* %7
%532 = add nsw i32 %531, 1
store i32 %532, i32* %7
br label %126
533: ; preds = %126
br label %534
534: ; preds = %533
%535 = load i32, i32* %8
%536 = add nsw i32 %535, 1
store i32 %536, i32* %8
br label %120
537: ; preds = %120
%538 = load float, float* %24
%539 = fneg float %538
%540 = call float @llvm.fmuladd.f32(float %539, float 7.500000e+00, float 2.000000e+00)
store float %540, float* %28
%541 = load float, float* %24
%542 = fmul float %541, 4.000000e+00
%543 = fdiv float %542, 3.000000e+00
store float %543, float* %29
%544 = load float, float* %24
%545 = fmul float %544, 0xBFB5555560000000
store float %545, float* %30
%546 = call double (...) @seconds()
store double %546, double* %10
store i32 0, i32* %9
br label %547
547: ; preds = %808, %537
%548 = load i32, i32* %9
%549 = icmp slt i32 %548, 100
br i1 %549, label %550, label %811
550: ; preds = %547
store i32 2, i32* %8
br label %551
551: ; preds = %800, %550
%552 = load i32, i32* %8
%553 = load i32, i32* %18
%554 = sub nsw i32 %553, 2
%555 = icmp slt i32 %552, %554
br i1 %555, label %556, label %803
556: ; preds = %551
store i32 2, i32* %7
br label %557
557: ; preds = %796, %556
%558 = load i32, i32* %7
%559 = load i32, i32* %17
%560 = sub nsw i32 %559, 2
%561 = icmp slt i32 %558, %560
br i1 %561, label %562, label %799
562: ; preds = %557
store i32 2, i32* %6
br label %563
563: ; preds = %792, %562
%564 = load i32, i32* %6
%565 = load i32, i32* %16
%566 = sub nsw i32 %565, 2
%567 = icmp slt i32 %564, %566
br i1 %567, label %568, label %795
568: ; preds = %563
%569 = load float, float* %28
%570 = load float*, float** %14
%571 = load i32, i32* %6
%572 = load i32, i32* %16
%573 = load i32, i32* %7
%574 = load i32, i32* %17
%575 = load i32, i32* %8
%576 = mul nsw i32 %574, %575
%577 = add nsw i32 %573, %576
%578 = mul nsw i32 %572, %577
%579 = add nsw i32 %571, %578
%580 = sext i32 %579 to i64
%581 = getelementptr inbounds float, float* %570, i64 %580
%582 = load float, float* %581
%583 = load float*, float** %13
%584 = load i32, i32* %6
%585 = load i32, i32* %16
%586 = load i32, i32* %7
%587 = load i32, i32* %17
%588 = load i32, i32* %8
%589 = mul nsw i32 %587, %588
%590 = add nsw i32 %586, %589
%591 = mul nsw i32 %585, %590
%592 = add nsw i32 %584, %591
%593 = sext i32 %592 to i64
%594 = getelementptr inbounds float, float* %583, i64 %593
%595 = load float, float* %594
%596 = fneg float %595
%597 = call float @llvm.fmuladd.f32(float %569, float %582, float %596)
%598 = load float, float* %29
%599 = load float*, float** %14
%600 = load i32, i32* %6
%601 = add nsw i32 %600, 1
%602 = load i32, i32* %16
%603 = load i32, i32* %7
%604 = load i32, i32* %17
%605 = load i32, i32* %8
%606 = mul nsw i32 %604, %605
%607 = add nsw i32 %603, %606
%608 = mul nsw i32 %602, %607
%609 = add nsw i32 %601, %608
%610 = sext i32 %609 to i64
%611 = getelementptr inbounds float, float* %599, i64 %610
%612 = load float, float* %611
%613 = load float*, float** %14
%614 = load i32, i32* %6
%615 = sub nsw i32 %614, 1
%616 = load i32, i32* %16
%617 = load i32, i32* %7
%618 = load i32, i32* %17
%619 = load i32, i32* %8
%620 = mul nsw i32 %618, %619
%621 = add nsw i32 %617, %620
%622 = mul nsw i32 %616, %621
%623 = add nsw i32 %615, %622
%624 = sext i32 %623 to i64
%625 = getelementptr inbounds float, float* %613, i64 %624
%626 = load float, float* %625
%627 = fadd float %612, %626
%628 = load float*, float** %14
%629 = load i32, i32* %6
%630 = load i32, i32* %16
%631 = load i32, i32* %7
%632 = add nsw i32 %631, 1
%633 = load i32, i32* %17
%634 = load i32, i32* %8
%635 = mul nsw i32 %633, %634
%636 = add nsw i32 %632, %635
%637 = mul nsw i32 %630, %636
%638 = add nsw i32 %629, %637
%639 = sext i32 %638 to i64
%640 = getelementptr inbounds float, float* %628, i64 %639
%641 = load float, float* %640
%642 = fadd float %627, %641
%643 = load float*, float** %14
%644 = load i32, i32* %6
%645 = load i32, i32* %16
%646 = load i32, i32* %7
%647 = sub nsw i32 %646, 1
%648 = load i32, i32* %17
%649 = load i32, i32* %8
%650 = mul nsw i32 %648, %649
%651 = add nsw i32 %647, %650
%652 = mul nsw i32 %645, %651
%653 = add nsw i32 %644, %652
%654 = sext i32 %653 to i64
%655 = getelementptr inbounds float, float* %643, i64 %654
%656 = load float, float* %655
%657 = fadd float %642, %656
%658 = load float*, float** %14
%659 = load i32, i32* %6
%660 = load i32, i32* %16
%661 = load i32, i32* %7
%662 = load i32, i32* %17
%663 = load i32, i32* %8
%664 = add nsw i32 %663, 1
%665 = mul nsw i32 %662, %664
%666 = add nsw i32 %661, %665
%667 = mul nsw i32 %660, %666
%668 = add nsw i32 %659, %667
%669 = sext i32 %668 to i64
%670 = getelementptr inbounds float, float* %658, i64 %669
%671 = load float, float* %670
%672 = fadd float %657, %671
%673 = load float*, float** %14
%674 = load i32, i32* %6
%675 = load i32, i32* %16
%676 = load i32, i32* %7
%677 = load i32, i32* %17
%678 = load i32, i32* %8
%679 = sub nsw i32 %678, 1
%680 = mul nsw i32 %677, %679
%681 = add nsw i32 %676, %680
%682 = mul nsw i32 %675, %681
%683 = add nsw i32 %674, %682
%684 = sext i32 %683 to i64
%685 = getelementptr inbounds float, float* %673, i64 %684
%686 = load float, float* %685
%687 = fadd float %672, %686
%688 = call float @llvm.fmuladd.f32(float %598, float %687, float %597)
%689 = load float, float* %30
%690 = load float*, float** %14
%691 = load i32, i32* %6
%692 = add nsw i32 %691, 2
%693 = load i32, i32* %16
%694 = load i32, i32* %7
%695 = load i32, i32* %17
%696 = load i32, i32* %8
%697 = mul nsw i32 %695, %696
%698 = add nsw i32 %694, %697
%699 = mul nsw i32 %693, %698
%700 = add nsw i32 %692, %699
%701 = sext i32 %700 to i64
%702 = getelementptr inbounds float, float* %690, i64 %701
%703 = load float, float* %702
%704 = load float*, float** %14
%705 = load i32, i32* %6
%706 = sub nsw i32 %705, 2
%707 = load i32, i32* %16
%708 = load i32, i32* %7
%709 = load i32, i32* %17
%710 = load i32, i32* %8
%711 = mul nsw i32 %709, %710
%712 = add nsw i32 %708, %711
%713 = mul nsw i32 %707, %712
%714 = add nsw i32 %706, %713
%715 = sext i32 %714 to i64
%716 = getelementptr inbounds float, float* %704, i64 %715
%717 = load float, float* %716
%718 = fadd float %703, %717
%719 = load float*, float** %14
%720 = load i32, i32* %6
%721 = load i32, i32* %16
%722 = load i32, i32* %7
%723 = add nsw i32 %722, 2
%724 = load i32, i32* %17
%725 = load i32, i32* %8
%726 = mul nsw i32 %724, %725
%727 = add nsw i32 %723, %726
%728 = mul nsw i32 %721, %727
%729 = add nsw i32 %720, %728
%730 = sext i32 %729 to i64
%731 = getelementptr inbounds float, float* %719, i64 %730
%732 = load float, float* %731
%733 = fadd float %718, %732
%734 = load float*, float** %14
%735 = load i32, i32* %6
%736 = load i32, i32* %16
%737 = load i32, i32* %7
%738 = sub nsw i32 %737, 2
%739 = load i32, i32* %17
%740 = load i32, i32* %8
%741 = mul nsw i32 %739, %740
%742 = add nsw i32 %738, %741
%743 = mul nsw i32 %736, %742
%744 = add nsw i32 %735, %743
%745 = sext i32 %744 to i64
%746 = getelementptr inbounds float, float* %734, i64 %745
%747 = load float, float* %746
%748 = fadd float %733, %747
%749 = load float*, float** %14
%750 = load i32, i32* %6
%751 = load i32, i32* %16
%752 = load i32, i32* %7
%753 = load i32, i32* %17
%754 = load i32, i32* %8
%755 = add nsw i32 %754, 2
%756 = mul nsw i32 %753, %755
%757 = add nsw i32 %752, %756
%758 = mul nsw i32 %751, %757
%759 = add nsw i32 %750, %758
%760 = sext i32 %759 to i64
%761 = getelementptr inbounds float, float* %749, i64 %760
%762 = load float, float* %761
%763 = fadd float %748, %762
%764 = load float*, float** %14
%765 = load i32, i32* %6
%766 = load i32, i32* %16
%767 = load i32, i32* %7
%768 = load i32, i32* %17
%769 = load i32, i32* %8
%770 = sub nsw i32 %769, 2
%771 = mul nsw i32 %768, %770
%772 = add nsw i32 %767, %771
%773 = mul nsw i32 %766, %772
%774 = add nsw i32 %765, %773
%775 = sext i32 %774 to i64
%776 = getelementptr inbounds float, float* %764, i64 %775
%777 = load float, float* %776
%778 = fadd float %763, %777
%779 = call float @llvm.fmuladd.f32(float %689, float %778, float %688)
%780 = load float*, float** %15
%781 = load i32, i32* %6
%782 = load i32, i32* %16
%783 = load i32, i32* %7
%784 = load i32, i32* %17
%785 = load i32, i32* %8
%786 = mul nsw i32 %784, %785
%787 = add nsw i32 %783, %786
%788 = mul nsw i32 %782, %787
%789 = add nsw i32 %781, %788
%790 = sext i32 %789 to i64
%791 = getelementptr inbounds float, float* %780, i64 %790
store float %779, float* %791
br label %792
792: ; preds = %568
%793 = load i32, i32* %6
%794 = add nsw i32 %793, 1
store i32 %794, i32* %6
br label %563
795: ; preds = %563
br label %796
796: ; preds = %795
%797 = load i32, i32* %7
%798 = add nsw i32 %797, 1
store i32 %798, i32* %7
br label %557
799: ; preds = %557
br label %800
800: ; preds = %799
%801 = load i32, i32* %8
%802 = add nsw i32 %801, 1
store i32 %802, i32* %8
br label %551
803: ; preds = %551
%804 = load float*, float** %13
store float* %804, float** %31
%805 = load float*, float** %14
store float* %805, float** %13
%806 = load float*, float** %15
store float* %806, float** %14
%807 = load float*, float** %31
store float* %807, float** %15
br label %808
808: ; preds = %803
%809 = load i32, i32* %9
%810 = add nsw i32 %809, 1
store i32 %810, i32* %9
br label %547
811: ; preds = %547
%812 = call double (...) @seconds()
store double %812, double* %11
%813 = load i32, i32* %16
%814 = sub nsw i32 %813, 4
%815 = sitofp i32 %814 to double
%816 = load i32, i32* %17
%817 = sub nsw i32 %816, 4
%818 = sitofp i32 %817 to double
%819 = fmul double %815, %818
%820 = load i32, i32* %18
%821 = sub nsw i32 %820, 4
%822 = sitofp i32 %821 to double
%823 = fmul double %819, %822
%824 = fmul double %823, 1.000000e+02
%825 = fmul double %824, 1.600000e+01
store double %825, double* %12
%826 = load double, double* %12
%827 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.4, i64 0, i64 0), double %826)
%828 = load double, double* %11
%829 = load double, double* %10
%830 = fsub double %828, %829
%831 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.5, i64 0, i64 0), double %830)
%832 = load double, double* %12
%833 = load double, double* %11
%834 = load double, double* %10
%835 = fsub double %833, %834
%836 = fmul double 1.000000e+09, %835
%837 = fdiv double %832, %836
%838 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.6, i64 0, i64 0), double %837)
%839 = load float*, float** %13
%840 = call i32 @free(float* %839)
%841 = load float*, float** %14
%842 = call i32 @free(float* %841)
%843 = load float*, float** %15
%844 = call i32 @free(float* %843)
%845 = load i32, i32* @EXIT_SUCCESS
store i32 %845, i32* %3
br label %846
846: ; preds = %811, %113, %96, %81
%847 = load i32, i32* %3
ret i32 %847
}

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