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

/* Forward declarations */

/* Type definitions */
typedef int /*<<< orphan*/ FILE;

/* Variables and functions */
float RAND_MAX;
int /*<<< orphan*/ fclose(int /*<<< orphan*/ *);
int /*<<< orphan*/ *fopen(char *, char *);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/ *, char *, int, ...);
int /*<<< orphan*/ printf(char *);
scalar_t__ rand();
int /*<<< orphan*/ scanf(char *, ...);
int /*<<< orphan*/ srand(int);
int main() {
  int n, i, j, k;
  double A[700][700], M[700][700], b[700], x[700];
  FILE *fp;
  char filename[100];
  printf("\nn= ");
  scanf("%d", &n);
  printf("\nOutput file name= ");
  scanf("%s", filename);
  srand(853);
  for (i = 0; i < n; i++)
    for (j = 0; j < n; j++)
      M[i][j] = 10 * ((float)rand() / RAND_MAX - 0.5);
  for (i = 0; i < n; i++)
    for (j = 0; j < n; j++) {
      A[i][j] = 0;
      for (k = 0; k < n; k++)
        A[i][j] += M[i][k] * M[j][k];
    }
  for (i = 0; i < n; i++)
    x[i] = 1 + i % (n / 100);
  for (i = 0; i < n; i++) {
    b[i] = 0;
    for (j = 0; j < n; j++)
      b[i] += A[i][j] * x[j];
  }
  fp = fopen(filename, "wt");
  fprintf(fp, "%d", n);
  for (i = 0; i < n; i++)
    if (i == n - 1)
      for (j = 0; j < n; j++)
        fprintf(fp, "\n%3d %3d % .20e", i, j, A[0][j]);
    else
      for (j = 0; j < n; j++)
        fprintf(fp, "\n%3d %3d % .20e", i, j, A[i][j]);
  for (i = 0; i < n; i++)
    fprintf(fp, "\n%3d % .20e", i, b[i]);
  fclose(fp);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x77cd60,%rsp
movl   $0x0,-0x4(%rbp)
lea    0xe87(%rip),%rdi
call   1040 <printf@plt>
lea    0xe80(%rip),%rdi
lea    -0x8(%rbp),%rsi
mov    $0x0,%al
call   1070 <scanf@plt>
lea    0xe71(%rip),%rdi
call   1040 <printf@plt>
lea    -0x77cd50(%rbp),%rsi
lea    0xe72(%rip),%rdi
mov    $0x0,%al
call   1070 <scanf@plt>
mov    $0x355,%edi
call   1050 <srand@plt>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1263 <main+0xf3>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1250 <main+0xe0>
mov    $0x0,%al
call   1090 <rand@plt>
cvtsi2ss %rax,%xmm0
mov    0x2de4(%rip),%rax
divss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xdf4(%rip),%xmm0
subsd  %xmm0,%xmm1
movsd  0xde0(%rip),%xmm0
mulsd  %xmm1,%xmm0
movslq -0xc(%rbp),%rcx
lea    -0x77a120(%rbp),%rax
imul   $0x15e0,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    11e5 <main+0x75>
jmp    1255 <main+0xe5>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    11d2 <main+0x62>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1358 <main+0x1e8>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1345 <main+0x1d5>
movslq -0xc(%rbp),%rcx
lea    -0x3bd0a0(%rbp),%rax
imul   $0x15e0,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1332 <main+0x1c2>
movslq -0xc(%rbp),%rcx
lea    -0x77a120(%rbp),%rax
imul   $0x15e0,%rcx,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x10(%rbp),%rcx
lea    -0x77a120(%rbp),%rax
imul   $0x15e0,%rcx,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movslq -0xc(%rbp),%rcx
lea    -0x3bd0a0(%rbp),%rax
imul   $0x15e0,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    12b1 <main+0x141>
jmp    1337 <main+0x1c7>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    127d <main+0x10d>
jmp    134a <main+0x1da>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    126a <main+0xfa>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    13ac <main+0x23c>
mov    -0xc(%rbp),%eax
mov    %eax,-0x77cd54(%rbp)
mov    -0x8(%rbp),%eax
mov    $0x64,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x77cd54(%rbp),%eax
cltd
idiv   %ecx
add    $0x1,%edx
cvtsi2sd %edx,%xmm0
movslq -0xc(%rbp),%rax
movsd  %xmm0,-0x77cce0(%rbp,%rax,8)
88 ff
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    135f <main+0x1ef>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    144c <main+0x2dc>
movslq -0xc(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x77b700(%rbp,%rax,8)
88 ff
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1439 <main+0x2c9>
movslq -0xc(%rbp),%rcx
lea    -0x3bd0a0(%rbp),%rax
imul   $0x15e0,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x10(%rbp),%rax
movsd  -0x77cce0(%rbp,%rax,8),%xmm2
88 ff
movslq -0xc(%rbp),%rax
movsd  -0x77b700(%rbp,%rax,8),%xmm1
88 ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x77b700(%rbp,%rax,8)
88 ff
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    13d6 <main+0x266>
jmp    143e <main+0x2ce>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    13b3 <main+0x243>
lea    -0x77cd50(%rbp),%rdi
lea    0xbd5(%rip),%rsi
call   1080 <fopen@plt>
mov    %rax,-0x77cce8(%rbp)
mov    -0x77cce8(%rbp),%rdi
mov    -0x8(%rbp),%edx
lea    0xb9e(%rip),%rsi
mov    $0x0,%al
call   1060 <fprintf@plt>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1562 <main+0x3f2>
mov    -0xc(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    14f0 <main+0x380>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    14eb <main+0x37b>
mov    -0x77cce8(%rbp),%rdi
mov    -0xc(%rbp),%edx
mov    -0x10(%rbp),%ecx
movslq -0x10(%rbp),%rax
movsd  -0x3bd0a0(%rbp,%rax,8),%xmm0
c4 ff
lea    0xb5c(%rip),%rsi
mov    $0x1,%al
call   1060 <fprintf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    14a9 <main+0x339>
jmp    154f <main+0x3df>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    154a <main+0x3da>
mov    -0x77cce8(%rbp),%rdi
mov    -0xc(%rbp),%edx
mov    -0x10(%rbp),%ecx
movslq -0xc(%rbp),%rsi
lea    -0x3bd0a0(%rbp),%rax
imul   $0x15e0,%rsi,%rsi
add    %rsi,%rax
movslq -0x10(%rbp),%rsi
movsd  (%rax,%rsi,8),%xmm0
lea    0xafd(%rip),%rsi
mov    $0x1,%al
call   1060 <fprintf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    14f7 <main+0x387>
jmp    154f <main+0x3df>
jmp    1554 <main+0x3e4>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1485 <main+0x315>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    15a8 <main+0x438>
mov    -0x77cce8(%rbp),%rdi
mov    -0xc(%rbp),%edx
movslq -0xc(%rbp),%rax
movsd  -0x77b700(%rbp,%rax,8),%xmm0
88 ff
lea    0xaaf(%rip),%rsi
mov    $0x1,%al
call   1060 <fprintf@plt>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1569 <main+0x3f9>
mov    -0x77cce8(%rbp),%rdi
call   1030 <fclose@plt>
xor    %eax,%eax
add    $0x77cd60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x77cd40,%rsp
lea    0xe89(%rip),%rdi
call   1040 <printf@plt>
lea    0xe82(%rip),%rdi
lea    0xc(%rsp),%rsi
xor    %eax,%eax
call   1070 <scanf@plt>
lea    0xe72(%rip),%rdi
call   1040 <printf@plt>
lea    0xe7a(%rip),%rdi
lea    0x10(%rsp),%rsi
xor    %eax,%eax
call   1070 <scanf@plt>
mov    $0x355,%edi
call   1050 <srand@plt>
mov    0xc(%rsp),%r13d
test   %r13d,%r13d
jle    14bc <main+0x34c>
lea    0x3bfcc0(%rsp),%r12
mov    0x2e03(%rip),%r14
xor    %r15d,%r15d
jmp    1203 <main+0x93>
nopw   0x0(%rax,%rax,1)
movslq %r13d,%rax
add    $0x1,%r15
add    $0x15e0,%r12
cmp    %rax,%r15
jge    1256 <main+0xe6>
test   %r13d,%r13d
jle    11f0 <main+0x80>
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
xor    %eax,%eax
call   1090 <rand@plt>
movsd  0xde1(%rip),%xmm1
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
divss  (%r14),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm1,%xmm0
movsd  0xdcc(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,(%r12,%rbx,8)
add    $0x1,%rbx
movslq 0xc(%rsp),%r13
cmp    %r13,%rbx
jl     1210 <main+0xa0>
jmp    11f0 <main+0x80>
test   %r13d,%r13d
jle    14bc <main+0x34c>
mov    %r13d,%r10d
lea    -0x1(%r10),%r9
mov    %r10d,%ecx
and    $0xfffffffe,%ecx
lea    0x3bfcc8(%rsp),%r8
xor    %r11d,%r11d
mov    %r8,%rdx
jmp    1294 <main+0x124>
nopl   0x0(%rax)
add    $0x1,%r11
add    $0x15e0,%rdx
cmp    %r10,%r11
je     1340 <main+0x1d0>
mov    %r8,%rdi
xor    %esi,%esi
jmp    12c2 <main+0x152>
nopl   0x0(%rax,%rax,1)
lea    (%rsp,%r14,1),%rax
add    $0x2c40,%rax
lea    (%rax,%rsi,8),%rax
movsd  %xmm0,(%rax)
add    $0x1,%rsi
add    $0x15e0,%rdi
cmp    %r10,%rsi
je     1280 <main+0x110>
test   %r9,%r9
je     1300 <main+0x190>
xorpd  %xmm1,%xmm1
xor    %ebx,%ebx
nopl   (%rax)
movsd  -0x8(%rdx,%rbx,8),%xmm2
movsd  (%rdx,%rbx,8),%xmm0
mulsd  -0x8(%rdi,%rbx,8),%xmm2
mulsd  (%rdi,%rbx,8),%xmm0
addsd  %xmm1,%xmm2
addsd  %xmm2,%xmm0
add    $0x2,%rbx
movapd %xmm0,%xmm1
cmp    %rbx,%rcx
jne    12d0 <main+0x160>
jmp    1306 <main+0x196>
nopl   (%rax)
xorpd  %xmm0,%xmm0
xor    %ebx,%ebx
imul   $0x15e0,%r11,%r14
test   $0x1,%r10b
je     12a0 <main+0x130>
lea    (%rsp,%r14,1),%rax
add    $0x3bfcc0,%rax
movsd  (%rax,%rbx,8),%xmm1
imul   $0x15e0,%rsi,%rax
add    %rsp,%rax
add    $0x3bfcc0,%rax
mulsd  (%rax,%rbx,8),%xmm1
addsd  %xmm1,%xmm0
jmp    12a0 <main+0x130>
test   %r13d,%r13d
jle    14bc <main+0x34c>
imul   $0x51eb851f,%r10,%rsi
shr    $0x25,%rsi
test   %r9,%r9
je     1601 <main+0x491>
mov    %r10d,%edi
and    $0xfffffffe,%edi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
mov    %ecx,%eax
cltd
idiv   %esi
add    $0x1,%edx
xorps  %xmm0,%xmm0
cvtsi2sd %edx,%xmm0
movsd  %xmm0,0x80(%rsp,%rcx,8)
lea    0x1(%rcx),%eax
cltd
idiv   %esi
add    $0x1,%edx
xorps  %xmm0,%xmm0
cvtsi2sd %edx,%xmm0
movsd  %xmm0,0x88(%rsp,%rcx,8)
add    $0x2,%rcx
cmp    %rdi,%rcx
jne    1370 <main+0x200>
test   $0x1,%r10b
je     13c8 <main+0x258>
mov    %ecx,%eax
cltd
idiv   %esi
add    $0x1,%edx
xorps  %xmm0,%xmm0
cvtsi2sd %edx,%xmm0
movsd  %xmm0,0x80(%rsp,%rcx,8)
mov    %r10d,%eax
and    $0x3,%eax
mov    %r10d,%ecx
and    $0xfffffffc,%ecx
lea    0x2c58(%rsp),%rdx
lea    0x2c40(%rsp),%r8
xor    %r11d,%r11d
jmp    1415 <main+0x2a5>
nopl   0x0(%rax)
movsd  %xmm0,0x1660(%rsp,%r11,8)
add    $0x1,%r11
add    $0x15e0,%rdx
add    $0x15e0,%r8
cmp    %r10,%r11
je     14bc <main+0x34c>
xorpd  %xmm0,%xmm0
xor    %esi,%esi
cmp    $0x3,%r9
jb     1484 <main+0x314>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  -0x18(%rdx,%rsi,8),%xmm1
movsd  -0x10(%rdx,%rsi,8),%xmm2
mulsd  0x80(%rsp,%rsi,8),%xmm1
mulsd  0x88(%rsp,%rsi,8),%xmm2
addsd  %xmm0,%xmm1
movsd  -0x8(%rdx,%rsi,8),%xmm3
mulsd  0x90(%rsp,%rsi,8),%xmm3
addsd  %xmm1,%xmm2
movsd  (%rdx,%rsi,8),%xmm0
mulsd  0x98(%rsp,%rsi,8),%xmm0
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm0
add    $0x4,%rsi
cmp    %rsi,%rcx
jne    1430 <main+0x2c0>
test   %rax,%rax
je     13f0 <main+0x280>
lea    (%rsp,%rsi,8),%rdi
add    $0x80,%rdi
lea    (%r8,%rsi,8),%rsi
xor    %ebx,%ebx
xchg   %ax,%ax
movsd  (%rsi,%rbx,8),%xmm1
mulsd  (%rdi,%rbx,8),%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rbx
cmp    %rbx,%rax
jne    14a0 <main+0x330>
jmp    13f0 <main+0x280>
lea    0xb6c(%rip),%rsi
lea    0x10(%rsp),%rdi
call   1080 <fopen@plt>
mov    %rax,%r14
mov    0xc(%rsp),%edx
lea    0xb3a(%rip),%rsi
mov    %rax,%rdi
xor    %eax,%eax
call   1060 <fprintf@plt>
mov    0xc(%rsp),%eax
test   %eax,%eax
jle    15e6 <main+0x476>
lea    0x2c40(%rsp),%r13
xor    %r12d,%r12d
lea    0xb2f(%rip),%r15
jmp    1527 <main+0x3b7>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r12
movslq %eax,%rcx
add    $0x15e0,%r13
cmp    %rcx,%r12
jge    15ac <main+0x43c>
lea    -0x1(%rax),%ecx
cmp    %rcx,%r12
jne    1570 <main+0x400>
test   %eax,%eax
jle    1510 <main+0x3a0>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
movsd  0x2c40(%rsp,%rbx,8),%xmm0
mov    %r14,%rdi
mov    %r15,%rsi
mov    %r12d,%edx
mov    %ebx,%ecx
mov    $0x1,%al
call   1060 <fprintf@plt>
add    $0x1,%rbx
movslq 0xc(%rsp),%rax
cmp    %rax,%rbx
jl     1540 <main+0x3d0>
jmp    1510 <main+0x3a0>
nopl   0x0(%rax,%rax,1)
test   %eax,%eax
jle    1510 <main+0x3a0>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
movsd  0x0(%r13,%rbx,8),%xmm0
mov    %r14,%rdi
mov    %r15,%rsi
mov    %r12d,%edx
mov    %ebx,%ecx
mov    $0x1,%al
call   1060 <fprintf@plt>
add    $0x1,%rbx
movslq 0xc(%rsp),%rax
cmp    %rax,%rbx
jl     1580 <main+0x410>
jmp    1510 <main+0x3a0>
test   %eax,%eax
jle    15e6 <main+0x476>
xor    %ebx,%ebx
lea    0xa89(%rip),%r15
nopl   0x0(%rax)
movsd  0x1660(%rsp,%rbx,8),%xmm0
mov    %r14,%rdi
mov    %r15,%rsi
mov    %ebx,%edx
mov    $0x1,%al
call   1060 <fprintf@plt>
add    $0x1,%rbx
movslq 0xc(%rsp),%rax
cmp    %rax,%rbx
jl     15c0 <main+0x450>
mov    %r14,%rdi
call   1030 <fclose@plt>
xor    %eax,%eax
add    $0x77cd40,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
ret
xor    %ecx,%ecx
test   $0x1,%r10b
jne    13b0 <main+0x240>
jmp    13c8 <main+0x258>

LLVM IR (-O0):
@.str = [5 x i8] c"\0An= \00"
@.str.1 = [3 x i8] c"%d\00"
@.str.2 = [20 x i8] c"\0AOutput file name= \00"
@.str.3 = [3 x i8] c"%s\00"
@RAND_MAX = global float 0.000000e+00
@.str.4 = [3 x i8] c"wt\00"
@.str.5 = [16 x i8] c"\0A%3d %3d % .20e\00"
@.str.6 = [12 x i8] c"\0A%3d % .20e\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca i32
%4 = alloca i32
%5 = alloca i32
%6 = alloca [700 x [700 x double]]
%7 = alloca [700 x [700 x double]]
%8 = alloca [700 x double]
%9 = alloca [700 x double]
%10 = alloca i32*
%11 = alloca [100 x i8]
store i32 0, i32* %1
%12 = call i32 @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0))
%13 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %2)
%14 = call i32 @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.2, i64 0, i64 0))
%15 = getelementptr inbounds [100 x i8], [100 x i8]* %11, i64 0, i64 0
%16 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), i8* %15)
%17 = call i32 @srand(i32 853)
store i32 0, i32* %3
br label %18
18: ; preds = %45, %0
%19 = load i32, i32* %3
%20 = load i32, i32* %2
%21 = icmp slt i32 %19, %20
br i1 %21, label %22, label %48
22: ; preds = %18
store i32 0, i32* %4
br label %23
23: ; preds = %41, %22
%24 = load i32, i32* %4
%25 = load i32, i32* %2
%26 = icmp slt i32 %24, %25
br i1 %26, label %27, label %44
27: ; preds = %23
%28 = call i64 (...) @rand()
%29 = sitofp i64 %28 to float
%30 = load float, float* @RAND_MAX
%31 = fdiv float %29, %30
%32 = fpext float %31 to double
%33 = fsub double %32, 5.000000e-01
%34 = fmul double 1.000000e+01, %33
%35 = load i32, i32* %3
%36 = sext i32 %35 to i64
%37 = getelementptr inbounds [700 x [700 x double]], [700 x [700 x double]]* %7, i64 0, i64 %36
%38 = load i32, i32* %4
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds [700 x double], [700 x double]* %37, i64 0, i64 %39
store double %34, double* %40
br label %41
41: ; preds = %27
%42 = load i32, i32* %4
%43 = add nsw i32 %42, 1
store i32 %43, i32* %4
br label %23
44: ; preds = %23
br label %45
45: ; preds = %44
%46 = load i32, i32* %3
%47 = add nsw i32 %46, 1
store i32 %47, i32* %3
br label %18
48: ; preds = %18
store i32 0, i32* %3
br label %49
49: ; preds = %100, %48
%50 = load i32, i32* %3
%51 = load i32, i32* %2
%52 = icmp slt i32 %50, %51
br i1 %52, label %53, label %103
53: ; preds = %49
store i32 0, i32* %4
br label %54
54: ; preds = %96, %53
%55 = load i32, i32* %4
%56 = load i32, i32* %2
%57 = icmp slt i32 %55, %56
br i1 %57, label %58, label %99
58: ; preds = %54
%59 = load i32, i32* %3
%60 = sext i32 %59 to i64
%61 = getelementptr inbounds [700 x [700 x double]], [700 x [700 x double]]* %6, i64 0, i64 %60
%62 = load i32, i32* %4
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds [700 x double], [700 x double]* %61, i64 0, i64 %63
store double 0.000000e+00, double* %64
store i32 0, i32* %5
br label %65
65: ; preds = %92, %58
%66 = load i32, i32* %5
%67 = load i32, i32* %2
%68 = icmp slt i32 %66, %67
br i1 %68, label %69, label %95
69: ; preds = %65
%70 = load i32, i32* %3
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds [700 x [700 x double]], [700 x [700 x double]]* %7, i64 0, i64 %71
%73 = load i32, i32* %5
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds [700 x double], [700 x double]* %72, i64 0, i64 %74
%76 = load double, double* %75
%77 = load i32, i32* %4
%78 = sext i32 %77 to i64
%79 = getelementptr inbounds [700 x [700 x double]], [700 x [700 x double]]* %7, i64 0, i64 %78
%80 = load i32, i32* %5
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds [700 x double], [700 x double]* %79, i64 0, i64 %81
%83 = load double, double* %82
%84 = load i32, i32* %3
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds [700 x [700 x double]], [700 x [700 x double]]* %6, i64 0, i64 %85
%87 = load i32, i32* %4
%88 = sext i32 %87 to i64
%89 = getelementptr inbounds [700 x double], [700 x double]* %86, i64 0, i64 %88
%90 = load double, double* %89
%91 = call double @llvm.fmuladd.f64(double %76, double %83, double %90)
store double %91, double* %89
br label %92
92: ; preds = %69
%93 = load i32, i32* %5
%94 = add nsw i32 %93, 1
store i32 %94, i32* %5
br label %65
95: ; preds = %65
br label %96
96: ; preds = %95
%97 = load i32, i32* %4
%98 = add nsw i32 %97, 1
store i32 %98, i32* %4
br label %54
99: ; preds = %54
br label %100
100: ; preds = %99
%101 = load i32, i32* %3
%102 = add nsw i32 %101, 1
store i32 %102, i32* %3
br label %49
103: ; preds = %49
store i32 0, i32* %3
br label %104
104: ; preds = %118, %103
%105 = load i32, i32* %3
%106 = load i32, i32* %2
%107 = icmp slt i32 %105, %106
br i1 %107, label %108, label %121
108: ; preds = %104
%109 = load i32, i32* %3
%110 = load i32, i32* %2
%111 = sdiv i32 %110, 100
%112 = srem i32 %109, %111
%113 = add nsw i32 1, %112
%114 = sitofp i32 %113 to double
%115 = load i32, i32* %3
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds [700 x double], [700 x double]* %9, i64 0, i64 %116
store double %114, double* %117
br label %118
118: ; preds = %108
%119 = load i32, i32* %3
%120 = add nsw i32 %119, 1
store i32 %120, i32* %3
br label %104
121: ; preds = %104
store i32 0, i32* %3
br label %122
122: ; preds = %155, %121
%123 = load i32, i32* %3
%124 = load i32, i32* %2
%125 = icmp slt i32 %123, %124
br i1 %125, label %126, label %158
126: ; preds = %122
%127 = load i32, i32* %3
%128 = sext i32 %127 to i64
%129 = getelementptr inbounds [700 x double], [700 x double]* %8, i64 0, i64 %128
store double 0.000000e+00, double* %129
store i32 0, i32* %4
br label %130
130: ; preds = %151, %126
%131 = load i32, i32* %4
%132 = load i32, i32* %2
%133 = icmp slt i32 %131, %132
br i1 %133, label %134, label %154
134: ; preds = %130
%135 = load i32, i32* %3
%136 = sext i32 %135 to i64
%137 = getelementptr inbounds [700 x [700 x double]], [700 x [700 x double]]* %6, i64 0, i64 %136
%138 = load i32, i32* %4
%139 = sext i32 %138 to i64
%140 = getelementptr inbounds [700 x double], [700 x double]* %137, i64 0, i64 %139
%141 = load double, double* %140
%142 = load i32, i32* %4
%143 = sext i32 %142 to i64
%144 = getelementptr inbounds [700 x double], [700 x double]* %9, i64 0, i64 %143
%145 = load double, double* %144
%146 = load i32, i32* %3
%147 = sext i32 %146 to i64
%148 = getelementptr inbounds [700 x double], [700 x double]* %8, i64 0, i64 %147
%149 = load double, double* %148
%150 = call double @llvm.fmuladd.f64(double %141, double %145, double %149)
store double %150, double* %148
br label %151
151: ; preds = %134
%152 = load i32, i32* %4
%153 = add nsw i32 %152, 1
store i32 %153, i32* %4
br label %130
154: ; preds = %130
br label %155
155: ; preds = %154
%156 = load i32, i32* %3
%157 = add nsw i32 %156, 1
store i32 %157, i32* %3
br label %122
158: ; preds = %122
%159 = getelementptr inbounds [100 x i8], [100 x i8]* %11, i64 0, i64 0
%160 = call i32* @fopen(i8* %159, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i64 0, i64 0))
store i32* %160, i32** %10
%161 = load i32*, i32** %10
%162 = load i32, i32* %2
%163 = call i32 (i32*, i8*, i32, ...) @fprintf(i32* %161, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32 %162)
store i32 0, i32* %3
br label %164
164: ; preds = %214, %158
%165 = load i32, i32* %3
%166 = load i32, i32* %2
%167 = icmp slt i32 %165, %166
br i1 %167, label %168, label %217
168: ; preds = %164
%169 = load i32, i32* %3
%170 = load i32, i32* %2
%171 = sub nsw i32 %170, 1
%172 = icmp eq i32 %169, %171
br i1 %172, label %173, label %192
173: ; preds = %168
store i32 0, i32* %4
br label %174
174: ; preds = %188, %173
%175 = load i32, i32* %4
%176 = load i32, i32* %2
%177 = icmp slt i32 %175, %176
br i1 %177, label %178, label %191
178: ; preds = %174
%179 = load i32*, i32** %10
%180 = load i32, i32* %3
%181 = load i32, i32* %4
%182 = getelementptr inbounds [700 x [700 x double]], [700 x [700 x double]]* %6, i64 0, i64 0
%183 = load i32, i32* %4
%184 = sext i32 %183 to i64
%185 = getelementptr inbounds [700 x double], [700 x double]* %182, i64 0, i64 %184
%186 = load double, double* %185
%187 = call i32 (i32*, i8*, i32, ...) @fprintf(i32* %179, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.5, i64 0, i64 0), i32 %180, i32 %181, double %186)
br label %188
188: ; preds = %178
%189 = load i32, i32* %4
%190 = add nsw i32 %189, 1
store i32 %190, i32* %4
br label %174
191: ; preds = %174
br label %213
192: ; preds = %168
store i32 0, i32* %4
br label %193
193: ; preds = %209, %192
%194 = load i32, i32* %4
%195 = load i32, i32* %2
%196 = icmp slt i32 %194, %195
br i1 %196, label %197, label %212
197: ; preds = %193
%198 = load i32*, i32** %10
%199 = load i32, i32* %3
%200 = load i32, i32* %4
%201 = load i32, i32* %3
%202 = sext i32 %201 to i64
%203 = getelementptr inbounds [700 x [700 x double]], [700 x [700 x double]]* %6, i64 0, i64 %202
%204 = load i32, i32* %4
%205 = sext i32 %204 to i64
%206 = getelementptr inbounds [700 x double], [700 x double]* %203, i64 0, i64 %205
%207 = load double, double* %206
%208 = call i32 (i32*, i8*, i32, ...) @fprintf(i32* %198, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.5, i64 0, i64 0), i32 %199, i32 %200, double %207)
br label %209
209: ; preds = %197
%210 = load i32, i32* %4
%211 = add nsw i32 %210, 1
store i32 %211, i32* %4
br label %193
212: ; preds = %193
br label %213
213: ; preds = %212, %191
br label %214
214: ; preds = %213
%215 = load i32, i32* %3
%216 = add nsw i32 %215, 1
store i32 %216, i32* %3
br label %164
217: ; preds = %164
store i32 0, i32* %3
br label %218
218: ; preds = %230, %217
%219 = load i32, i32* %3
%220 = load i32, i32* %2
%221 = icmp slt i32 %219, %220
br i1 %221, label %222, label %233
222: ; preds = %218
%223 = load i32*, i32** %10
%224 = load i32, i32* %3
%225 = load i32, i32* %3
%226 = sext i32 %225 to i64
%227 = getelementptr inbounds [700 x double], [700 x double]* %8, i64 0, i64 %226
%228 = load double, double* %227
%229 = call i32 (i32*, i8*, i32, ...) @fprintf(i32* %223, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.6, i64 0, i64 0), i32 %224, double %228)
br label %230
230: ; preds = %222
%231 = load i32, i32* %3
%232 = add nsw i32 %231, 1
store i32 %232, i32* %3
br label %218
233: ; preds = %218
%234 = load i32*, i32** %10
%235 = call i32 @fclose(i32* %234)
ret i32 0
}

LLVM IR (-O2):
@.str = [5 x i8] c"\0An= \00"
@.str.1 = [3 x i8] c"%d\00"
@.str.2 = [20 x i8] c"\0AOutput file name= \00"
@.str.3 = [3 x i8] c"%s\00"
@RAND_MAX = global float 0.000000e+00
@.str.4 = [3 x i8] c"wt\00"
@.str.5 = [16 x i8] c"\0A%3d %3d % .20e\00"
@.str.6 = [12 x i8] c"\0A%3d % .20e\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca [700 x [700 x double]]
%3 = alloca [700 x [700 x double]]
%4 = alloca [700 x double]
%5 = alloca [700 x double]
%6 = alloca [100 x i8]
%7 = bitcast i32* %1 to i8*
%8 = bitcast [700 x [700 x double]]* %2 to i8*
%9 = bitcast [700 x [700 x double]]* %3 to i8*
%10 = bitcast [700 x double]* %4 to i8*
%11 = bitcast [700 x double]* %5 to i8*
%12 = getelementptr inbounds [100 x i8], [100 x i8]* %6, i64 0, i64 0
%13 = tail call i32 @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0))
%14 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %1)
%15 = call i32 @printf(i8* dereferenceable(1) getelementptr inbounds ([20 x i8], [20 x i8]* @.str.2, i64 0, i64 0))
%16 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), i8* %12)
%17 = call i32 @srand(i32 853)
%18 = load i32, i32* %1
%19 = icmp sgt i32 %18, 0
br i1 %19, label %20, label %184
20: ; preds = %0, %47
%21 = phi i32 [ %48, %47 ], [ %18, %0 ]
%22 = phi i64 [ %50, %47 ], [ 0, %0 ]
%23 = icmp sgt i32 %21, 0
br i1 %23, label %33, label %47
24: ; preds = %47
%25 = icmp sgt i32 %48, 0
br i1 %25, label %26, label %184
26: ; preds = %24
%27 = zext i32 %48 to i64
%28 = add nsw i64 %27, -1
%29 = and i64 %27, 1
%30 = icmp eq i64 %28, 0
%31 = and i64 %27, 4294967294
%32 = icmp eq i64 %29, 0
br label %52
33: ; preds = %20, %33
%34 = phi i64 [ %43, %33 ], [ 0, %20 ]
%35 = call i64 (...) @rand()
%36 = sitofp i64 %35 to float
%37 = load float, float* @RAND_MAX
%38 = fdiv float %36, %37
%39 = fpext float %38 to double
%40 = fadd double %39, -5.000000e-01
%41 = fmul double %40, 1.000000e+01
%42 = getelementptr inbounds [700 x [700 x double]], [700 x [700 x double]]* %3, i64 0, i64 %22, i64 %34
store double %41, double* %42
%43 = add nuw nsw i64 %34, 1
%44 = load i32, i32* %1
%45 = sext i32 %44 to i64
%46 = icmp slt i64 %43, %45
br i1 %46, label %33, label %47
47: ; preds = %33, %20
%48 = phi i32 [ %21, %20 ], [ %44, %33 ]
%49 = sext i32 %48 to i64
%50 = add nuw nsw i64 %22, 1
%51 = icmp slt i64 %50, %49
br i1 %51, label %20, label %24
52: ; preds = %96, %26
%53 = phi i64 [ 0, %26 ], [ %97, %96 ]
br label %61
54: ; preds = %96
br i1 %25, label %55, label %184
55: ; preds = %54
%56 = udiv i32 %48, 100
%57 = and i64 %27, 1
%58 = icmp eq i64 %28, 0
br i1 %58, label %99, label %59
59: ; preds = %55
%60 = and i64 %27, 4294967294
br label %114
61: ; preds = %92, %52
%62 = phi i64 [ 0, %52 ], [ %94, %92 ]
%63 = getelementptr inbounds [700 x [700 x double]], [700 x [700 x double]]* %2, i64 0, i64 %53, i64 %62
br i1 %30, label %82, label %64
64: ; preds = %61, %64
%65 = phi i64 [ %79, %64 ], [ 0, %61 ]
%66 = phi double [ %78, %64 ], [ 0.000000e+00, %61 ]
%67 = phi i64 [ %80, %64 ], [ 0, %61 ]
%68 = getelementptr inbounds [700 x [700 x double]], [700 x [700 x double]]* %3, i64 0, i64 %53, i64 %65
%69 = load double, double* %68
%70 = getelementptr inbounds [700 x [700 x double]], [700 x [700 x double]]* %3, i64 0, i64 %62, i64 %65
%71 = load double, double* %70
%72 = call double @llvm.fmuladd.f64(double %69, double %71, double %66)
%73 = or i64 %65, 1
%74 = getelementptr inbounds [700 x [700 x double]], [700 x [700 x double]]* %3, i64 0, i64 %53, i64 %73
%75 = load double, double* %74
%76 = getelementptr inbounds [700 x [700 x double]], [700 x [700 x double]]* %3, i64 0, i64 %62, i64 %73
%77 = load double, double* %76
%78 = call double @llvm.fmuladd.f64(double %75, double %77, double %72)
%79 = add nuw nsw i64 %65, 2
%80 = add i64 %67, 2
%81 = icmp eq i64 %80, %31
br i1 %81, label %82, label %64
82: ; preds = %64, %61
%83 = phi double [ undef, %61 ], [ %78, %64 ]
%84 = phi i64 [ 0, %61 ], [ %79, %64 ]
%85 = phi double [ 0.000000e+00, %61 ], [ %78, %64 ]
br i1 %32, label %92, label %86
86: ; preds = %82
%87 = getelementptr inbounds [700 x [700 x double]], [700 x [700 x double]]* %3, i64 0, i64 %53, i64 %84
%88 = load double, double* %87
%89 = getelementptr inbounds [700 x [700 x double]], [700 x [700 x double]]* %3, i64 0, i64 %62, i64 %84
%90 = load double, double* %89
%91 = call double @llvm.fmuladd.f64(double %88, double %90, double %85)
br label %92
92: ; preds = %82, %86
%93 = phi double [ %83, %82 ], [ %91, %86 ]
store double %93, double* %63
%94 = add nuw nsw i64 %62, 1
%95 = icmp eq i64 %94, %27
br i1 %95, label %96, label %61
96: ; preds = %92
%97 = add nuw nsw i64 %53, 1
%98 = icmp eq i64 %97, %27
br i1 %98, label %54, label %52
99: ; preds = %114, %55
%100 = phi i64 [ 0, %55 ], [ %128, %114 ]
%101 = icmp eq i64 %57, 0
br i1 %101, label %108, label %102
102: ; preds = %99
%103 = trunc i64 %100 to i32
%104 = srem i32 %103, %56
%105 = add nuw nsw i32 %104, 1
%106 = sitofp i32 %105 to double
%107 = getelementptr inbounds [700 x double], [700 x double]* %5, i64 0, i64 %100
store double %106, double* %107
br label %108
108: ; preds = %99, %102
%109 = zext i32 %48 to i64
%110 = and i64 %27, 3
%111 = icmp ult i64 %28, 3
%112 = and i64 %27, 4294967292
%113 = icmp eq i64 %110, 0
br label %131
114: ; preds = %114, %59
%115 = phi i64 [ 0, %59 ], [ %128, %114 ]
%116 = phi i64 [ 0, %59 ], [ %129, %114 ]
%117 = trunc i64 %115 to i32
%118 = srem i32 %117, %56
%119 = add nuw nsw i32 %118, 1
%120 = sitofp i32 %119 to double
%121 = getelementptr inbounds [700 x double], [700 x double]* %5, i64 0, i64 %115
store double %120, double* %121
%122 = or i64 %115, 1
%123 = trunc i64 %122 to i32
%124 = srem i32 %123, %56
%125 = add nuw nsw i32 %124, 1
%126 = sitofp i32 %125 to double
%127 = getelementptr inbounds [700 x double], [700 x double]* %5, i64 0, i64 %122
store double %126, double* %127
%128 = add nuw nsw i64 %115, 2
%129 = add i64 %116, 2
%130 = icmp eq i64 %129, %60
br i1 %130, label %99, label %114
131: ; preds = %180, %108
%132 = phi i64 [ 0, %108 ], [ %182, %180 ]
%133 = getelementptr inbounds [700 x double], [700 x double]* %4, i64 0, i64 %132
br i1 %111, label %164, label %134
134: ; preds = %131, %134
%135 = phi i64 [ %161, %134 ], [ 0, %131 ]
%136 = phi double [ %160, %134 ], [ 0.000000e+00, %131 ]
%137 = phi i64 [ %162, %134 ], [ 0, %131 ]
%138 = getelementptr inbounds [700 x [700 x double]], [700 x [700 x double]]* %2, i64 0, i64 %132, i64 %135
%139 = load double, double* %138
%140 = getelementptr inbounds [700 x double], [700 x double]* %5, i64 0, i64 %135
%141 = load double, double* %140
%142 = call double @llvm.fmuladd.f64(double %139, double %141, double %136)
%143 = or i64 %135, 1
%144 = getelementptr inbounds [700 x [700 x double]], [700 x [700 x double]]* %2, i64 0, i64 %132, i64 %143
%145 = load double, double* %144
%146 = getelementptr inbounds [700 x double], [700 x double]* %5, i64 0, i64 %143
%147 = load double, double* %146
%148 = call double @llvm.fmuladd.f64(double %145, double %147, double %142)
%149 = or i64 %135, 2
%150 = getelementptr inbounds [700 x [700 x double]], [700 x [700 x double]]* %2, i64 0, i64 %132, i64 %149
%151 = load double, double* %150
%152 = getelementptr inbounds [700 x double], [700 x double]* %5, i64 0, i64 %149
%153 = load double, double* %152
%154 = call double @llvm.fmuladd.f64(double %151, double %153, double %148)
%155 = or i64 %135, 3
%156 = getelementptr inbounds [700 x [700 x double]], [700 x [700 x double]]* %2, i64 0, i64 %132, i64 %155
%157 = load double, double* %156
%158 = getelementptr inbounds [700 x double], [700 x double]* %5, i64 0, i64 %155
%159 = load double, double* %158
%160 = call double @llvm.fmuladd.f64(double %157, double %159, double %154)
%161 = add nuw nsw i64 %135, 4
%162 = add i64 %137, 4
%163 = icmp eq i64 %162, %112
br i1 %163, label %164, label %134
164: ; preds = %134, %131
%165 = phi double [ undef, %131 ], [ %160, %134 ]
%166 = phi i64 [ 0, %131 ], [ %161, %134 ]
%167 = phi double [ 0.000000e+00, %131 ], [ %160, %134 ]
br i1 %113, label %180, label %168
168: ; preds = %164, %168
%169 = phi i64 [ %177, %168 ], [ %166, %164 ]
%170 = phi double [ %176, %168 ], [ %167, %164 ]
%171 = phi i64 [ %178, %168 ], [ 0, %164 ]
%172 = getelementptr inbounds [700 x [700 x double]], [700 x [700 x double]]* %2, i64 0, i64 %132, i64 %169
%173 = load double, double* %172
%174 = getelementptr inbounds [700 x double], [700 x double]* %5, i64 0, i64 %169
%175 = load double, double* %174
%176 = call double @llvm.fmuladd.f64(double %173, double %175, double %170)
%177 = add nuw nsw i64 %169, 1
%178 = add i64 %171, 1
%179 = icmp eq i64 %178, %110
br i1 %179, label %180, label %168
180: ; preds = %168, %164
%181 = phi double [ %165, %164 ], [ %176, %168 ]
store double %181, double* %133
%182 = add nuw nsw i64 %132, 1
%183 = icmp eq i64 %182, %109
br i1 %183, label %184, label %131
184: ; preds = %180, %24, %0, %54
%185 = call i32* @fopen(i8* %12, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i64 0, i64 0))
%186 = load i32, i32* %1
%187 = call i32 (i32*, i8*, i32, ...) @fprintf(i32* %185, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32 %186)
%188 = load i32, i32* %1
%189 = icmp sgt i32 %188, 0
br i1 %189, label %192, label %240
190: ; preds = %225
%191 = icmp sgt i32 %226, 0
br i1 %191, label %230, label %240
192: ; preds = %184, %225
%193 = phi i32 [ %226, %225 ], [ %188, %184 ]
%194 = phi i64 [ %227, %225 ], [ 0, %184 ]
%195 = add nsw i32 %193, -1
%196 = zext i32 %195 to i64
%197 = icmp eq i64 %194, %196
%198 = icmp sgt i32 %193, 0
br i1 %197, label %202, label %199
199: ; preds = %192
br i1 %198, label %200, label %225
200: ; preds = %199
%201 = trunc i64 %194 to i32
br label %215
202: ; preds = %192
br i1 %198, label %203, label %225
203: ; preds = %202
%204 = trunc i64 %194 to i32
br label %205
205: ; preds = %203, %205
%206 = phi i64 [ 0, %203 ], [ %211, %205 ]
%207 = getelementptr inbounds [700 x [700 x double]], [700 x [700 x double]]* %2, i64 0, i64 0, i64 %206
%208 = load double, double* %207
%209 = trunc i64 %206 to i32
%210 = call i32 (i32*, i8*, i32, ...) @fprintf(i32* %185, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.5, i64 0, i64 0), i32 %204, i32 %209, double %208)
%211 = add nuw nsw i64 %206, 1
%212 = load i32, i32* %1
%213 = sext i32 %212 to i64
%214 = icmp slt i64 %211, %213
br i1 %214, label %205, label %225
215: ; preds = %200, %215
%216 = phi i64 [ 0, %200 ], [ %221, %215 ]
%217 = getelementptr inbounds [700 x [700 x double]], [700 x [700 x double]]* %2, i64 0, i64 %194, i64 %216
%218 = load double, double* %217
%219 = trunc i64 %216 to i32
%220 = call i32 (i32*, i8*, i32, ...) @fprintf(i32* %185, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.5, i64 0, i64 0), i32 %201, i32 %219, double %218)
%221 = add nuw nsw i64 %216, 1
%222 = load i32, i32* %1
%223 = sext i32 %222 to i64
%224 = icmp slt i64 %221, %223
br i1 %224, label %215, label %225
225: ; preds = %215, %205, %199, %202
%226 = phi i32 [ %193, %199 ], [ %193, %202 ], [ %212, %205 ], [ %222, %215 ]
%227 = add nuw nsw i64 %194, 1
%228 = sext i32 %226 to i64
%229 = icmp slt i64 %227, %228
br i1 %229, label %192, label %190
230: ; preds = %190, %230
%231 = phi i64 [ %236, %230 ], [ 0, %190 ]
%232 = getelementptr inbounds [700 x double], [700 x double]* %4, i64 0, i64 %231
%233 = load double, double* %232
%234 = trunc i64 %231 to i32
%235 = call i32 (i32*, i8*, i32, ...) @fprintf(i32* %185, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.6, i64 0, i64 0), i32 %234, double %233)
%236 = add nuw nsw i64 %231, 1
%237 = load i32, i32* %1
%238 = sext i32 %237 to i64
%239 = icmp slt i64 %236, %238
br i1 %239, label %230, label %240
240: ; preds = %230, %184, %190
%241 = call i32 @fclose(i32* %185)
ret i32 0
}