#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 */
int /*<<< orphan*/ fflush(int /*<<< orphan*/);
int /*<<< orphan*/ stdout;
int main(void) {
  int i, j, k;
  float A[512][512];
  float B[512][512];
  float C[512][512];
  for (i = 0; i < 512; i++) {
    for (k = 0; k < 512; k++) {
      A[i][k] = (i + k) * 1.4;
    }
  }
  for (k = 0; k < 512; k++) {
    for (j = 0; j < 512; j++) {
      B[k][j] = k * j / 0.9;
    }
  }
  for (i = 0; i < 512; i++) {
    for (j = 0; j < 512; j++) {
      C[i][j] = 0;
    }
  }
#pragma species kernel 0 : N - 1,                                              \
    0 : N - 1 | chunk(0 : 0, 0                                                 \
                      : N - 1) ^                                               \
                    0 : N - 1,                                                 \
    0 : N - 1 | chunk(0                                                        \
                      : N - 1, 0 : 0)                                          \
                        ->0 : N -                                              \
                    1,                                                         \
    0 : N - 1 | element
  for (i = 0; i < 512; i++) {
    for (j = 0; j < 512; j++) {
      C[i][j] = 0;
      for (k = 0; k < 512; k++) {
        C[i][j] += A[i][k] * B[k][j];
      }
    }
  }
#pragma species endkernel mm
#pragma endscop
  fflush(stdout);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x300010,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x0,-0x8(%rbp)
cmpl   $0x200,-0x8(%rbp)
jge    11a0 <main+0x90>
movl   $0x0,-0x10(%rbp)
cmpl   $0x200,-0x10(%rbp)
jge    118d <main+0x7d>
mov    -0x8(%rbp),%eax
add    -0x10(%rbp),%eax
cvtsi2sd %eax,%xmm0
movsd  0xeac(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movslq -0x8(%rbp),%rcx
lea    -0x100010(%rbp),%rax
shl    $0xb,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    113d <main+0x2d>
jmp    1192 <main+0x82>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1129 <main+0x19>
movl   $0x0,-0x10(%rbp)
cmpl   $0x200,-0x10(%rbp)
jge    121f <main+0x10f>
movl   $0x0,-0xc(%rbp)
cmpl   $0x200,-0xc(%rbp)
jge    120c <main+0xfc>
mov    -0x10(%rbp),%eax
imul   -0xc(%rbp),%eax
cvtsi2sd %eax,%xmm0
movsd  0xe25(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movslq -0x10(%rbp),%rcx
lea    -0x200010(%rbp),%rax
shl    $0xb,%rcx
add    %rcx,%rax
movslq -0xc(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    11bb <main+0xab>
jmp    1211 <main+0x101>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    11a7 <main+0x97>
movl   $0x0,-0x8(%rbp)
cmpl   $0x200,-0x8(%rbp)
jge    1286 <main+0x176>
movl   $0x0,-0xc(%rbp)
cmpl   $0x200,-0xc(%rbp)
jge    1273 <main+0x163>
movslq -0x8(%rbp),%rcx
lea    -0x300010(%rbp),%rax
shl    $0xb,%rcx
add    %rcx,%rax
movslq -0xc(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    123a <main+0x12a>
jmp    1278 <main+0x168>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1226 <main+0x116>
movl   $0x0,-0x8(%rbp)
cmpl   $0x200,-0x8(%rbp)
jge    1372 <main+0x262>
movl   $0x0,-0xc(%rbp)
cmpl   $0x200,-0xc(%rbp)
jge    135f <main+0x24f>
movslq -0x8(%rbp),%rcx
lea    -0x300010(%rbp),%rax
shl    $0xb,%rcx
add    %rcx,%rax
movslq -0xc(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movl   $0x0,-0x10(%rbp)
cmpl   $0x200,-0x10(%rbp)
jge    134c <main+0x23c>
movslq -0x8(%rbp),%rcx
lea    -0x100010(%rbp),%rax
shl    $0xb,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movslq -0x10(%rbp),%rcx
lea    -0x200010(%rbp),%rax
shl    $0xb,%rcx
add    %rcx,%rax
movslq -0xc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movslq -0x8(%rbp),%rcx
lea    -0x300010(%rbp),%rax
shl    $0xb,%rcx
add    %rcx,%rax
movslq -0xc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    12d3 <main+0x1c3>
jmp    1351 <main+0x241>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    12a1 <main+0x191>
jmp    1364 <main+0x254>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    128d <main+0x17d>
mov    0x2c67(%rip),%rax
mov    (%rax),%edi
call   1030 <fflush@plt>
xor    %eax,%eax
add    $0x300010,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rax
mov    0x2ec8(%rip),%rax
mov    (%rax),%edi
call   1030 <fflush@plt>
xor    %eax,%eax
pop    %rcx
ret

LLVM IR (-O0):
@stdout = global i32 0
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca i32
%4 = alloca i32
%5 = alloca [512 x [512 x float]]
%6 = alloca [512 x [512 x float]]
%7 = alloca [512 x [512 x float]]
store i32 0, i32* %1
store i32 0, i32* %2
br label %8
8: ; preds = %32, %0
%9 = load i32, i32* %2
%10 = icmp slt i32 %9, 512
br i1 %10, label %11, label %35
11: ; preds = %8
store i32 0, i32* %4
br label %12
12: ; preds = %28, %11
%13 = load i32, i32* %4
%14 = icmp slt i32 %13, 512
br i1 %14, label %15, label %31
15: ; preds = %12
%16 = load i32, i32* %2
%17 = load i32, i32* %4
%18 = add nsw i32 %16, %17
%19 = sitofp i32 %18 to double
%20 = fmul double %19, 1.400000e+00
%21 = fptrunc double %20 to float
%22 = load i32, i32* %2
%23 = sext i32 %22 to i64
%24 = getelementptr inbounds [512 x [512 x float]], [512 x [512 x float]]* %5, i64 0, i64 %23
%25 = load i32, i32* %4
%26 = sext i32 %25 to i64
%27 = getelementptr inbounds [512 x float], [512 x float]* %24, i64 0, i64 %26
store float %21, float* %27
br label %28
28: ; preds = %15
%29 = load i32, i32* %4
%30 = add nsw i32 %29, 1
store i32 %30, i32* %4
br label %12
31: ; preds = %12
br label %32
32: ; preds = %31
%33 = load i32, i32* %2
%34 = add nsw i32 %33, 1
store i32 %34, i32* %2
br label %8
35: ; preds = %8
store i32 0, i32* %4
br label %36
36: ; preds = %60, %35
%37 = load i32, i32* %4
%38 = icmp slt i32 %37, 512
br i1 %38, label %39, label %63
39: ; preds = %36
store i32 0, i32* %3
br label %40
40: ; preds = %56, %39
%41 = load i32, i32* %3
%42 = icmp slt i32 %41, 512
br i1 %42, label %43, label %59
43: ; preds = %40
%44 = load i32, i32* %4
%45 = load i32, i32* %3
%46 = mul nsw i32 %44, %45
%47 = sitofp i32 %46 to double
%48 = fdiv double %47, 9.000000e-01
%49 = fptrunc double %48 to float
%50 = load i32, i32* %4
%51 = sext i32 %50 to i64
%52 = getelementptr inbounds [512 x [512 x float]], [512 x [512 x float]]* %6, i64 0, i64 %51
%53 = load i32, i32* %3
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds [512 x float], [512 x float]* %52, i64 0, i64 %54
store float %49, float* %55
br label %56
56: ; preds = %43
%57 = load i32, i32* %3
%58 = add nsw i32 %57, 1
store i32 %58, i32* %3
br label %40
59: ; preds = %40
br label %60
60: ; preds = %59
%61 = load i32, i32* %4
%62 = add nsw i32 %61, 1
store i32 %62, i32* %4
br label %36
63: ; preds = %36
store i32 0, i32* %2
br label %64
64: ; preds = %82, %63
%65 = load i32, i32* %2
%66 = icmp slt i32 %65, 512
br i1 %66, label %67, label %85
67: ; preds = %64
store i32 0, i32* %3
br label %68
68: ; preds = %78, %67
%69 = load i32, i32* %3
%70 = icmp slt i32 %69, 512
br i1 %70, label %71, label %81
71: ; preds = %68
%72 = load i32, i32* %2
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds [512 x [512 x float]], [512 x [512 x float]]* %7, i64 0, i64 %73
%75 = load i32, i32* %3
%76 = sext i32 %75 to i64
%77 = getelementptr inbounds [512 x float], [512 x float]* %74, i64 0, i64 %76
store float 0.000000e+00, float* %77
br label %78
78: ; preds = %71
%79 = load i32, i32* %3
%80 = add nsw i32 %79, 1
store i32 %80, i32* %3
br label %68
81: ; preds = %68
br label %82
82: ; preds = %81
%83 = load i32, i32* %2
%84 = add nsw i32 %83, 1
store i32 %84, i32* %2
br label %64
85: ; preds = %64
store i32 0, i32* %2
br label %86
86: ; preds = %134, %85
%87 = load i32, i32* %2
%88 = icmp slt i32 %87, 512
br i1 %88, label %89, label %137
89: ; preds = %86
store i32 0, i32* %3
br label %90
90: ; preds = %130, %89
%91 = load i32, i32* %3
%92 = icmp slt i32 %91, 512
br i1 %92, label %93, label %133
93: ; preds = %90
%94 = load i32, i32* %2
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds [512 x [512 x float]], [512 x [512 x float]]* %7, i64 0, i64 %95
%97 = load i32, i32* %3
%98 = sext i32 %97 to i64
%99 = getelementptr inbounds [512 x float], [512 x float]* %96, i64 0, i64 %98
store float 0.000000e+00, float* %99
store i32 0, i32* %4
br label %100
100: ; preds = %126, %93
%101 = load i32, i32* %4
%102 = icmp slt i32 %101, 512
br i1 %102, label %103, label %129
103: ; preds = %100
%104 = load i32, i32* %2
%105 = sext i32 %104 to i64
%106 = getelementptr inbounds [512 x [512 x float]], [512 x [512 x float]]* %5, i64 0, i64 %105
%107 = load i32, i32* %4
%108 = sext i32 %107 to i64
%109 = getelementptr inbounds [512 x float], [512 x float]* %106, i64 0, i64 %108
%110 = load float, float* %109
%111 = load i32, i32* %4
%112 = sext i32 %111 to i64
%113 = getelementptr inbounds [512 x [512 x float]], [512 x [512 x float]]* %6, i64 0, i64 %112
%114 = load i32, i32* %3
%115 = sext i32 %114 to i64
%116 = getelementptr inbounds [512 x float], [512 x float]* %113, i64 0, i64 %115
%117 = load float, float* %116
%118 = load i32, i32* %2
%119 = sext i32 %118 to i64
%120 = getelementptr inbounds [512 x [512 x float]], [512 x [512 x float]]* %7, i64 0, i64 %119
%121 = load i32, i32* %3
%122 = sext i32 %121 to i64
%123 = getelementptr inbounds [512 x float], [512 x float]* %120, i64 0, i64 %122
%124 = load float, float* %123
%125 = call float @llvm.fmuladd.f32(float %110, float %117, float %124)
store float %125, float* %123
br label %126
126: ; preds = %103
%127 = load i32, i32* %4
%128 = add nsw i32 %127, 1
store i32 %128, i32* %4
br label %100
129: ; preds = %100
br label %130
130: ; preds = %129
%131 = load i32, i32* %3
%132 = add nsw i32 %131, 1
store i32 %132, i32* %3
br label %90
133: ; preds = %90
br label %134
134: ; preds = %133
%135 = load i32, i32* %2
%136 = add nsw i32 %135, 1
store i32 %136, i32* %2
br label %86
137: ; preds = %86
%138 = load i32, i32* @stdout
%139 = call i32 @fflush(i32 %138)
ret i32 0
}

LLVM IR (-O2):
@stdout = global i32 0
define i32 @main() {
%1 = load i32, i32* @stdout
%2 = tail call i32 @fflush(i32 %1)
ret i32 0
}