#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 double clock_t;

/* Variables and functions */
double CLOCKS_PER_SEC;
int ceil(double);
double clock();
int /*<<< orphan*/ fflush(int /*<<< orphan*/);
int /*<<< orphan*/ free(int **);
int /*<<< orphan*/ get_progress(char *, int, int, int);
scalar_t__ malloc(int);
int /*<<< orphan*/ printf(char *, int, double, double, char *, int);
int /*<<< orphan*/ stdout;
int **floyd(int **graph, int nodes, int steps) {
  char *progress = (char *)malloc(sizeof(char) * (steps + ((int)steps / 3)));
  clock_t begin, end;
  double start, time_step[4];
  int **dist = (int **)malloc(sizeof(int *) * nodes);
  int **pred = (int **)malloc(sizeof(int *) * nodes);
  for (int i = 0; i < nodes; i++) {
    dist[i] = (int *)malloc(sizeof(int) * nodes);
    pred[i] = (int *)malloc(sizeof(int) * nodes);
    for (int j = 0; j < nodes; j++) {
      dist[i][j] = graph[i][j];
      pred[i][j] = (int)NULL;
    }
  }
  start = clock();
  for (int k = 0; k < nodes; k++) {
    begin = clock();
    for (int i = 0; i < nodes; i++)
      for (int j = 0; j < nodes; j++)
        if (dist[i][k] + dist[k][j] < dist[i][j]) {
          dist[i][j] = dist[i][k] + dist[k][j];
          pred[i][j] = k;
        }
    end = clock();
    get_progress(progress, k, nodes, steps);
    time_step[0] = (double)(end - begin) / CLOCKS_PER_SEC;
    time_step[0] *= (nodes - k);
    time_step[0] =
        ceil(time_step[3] + time_step[2] + time_step[1] + time_step[0]) / 4;
    time_step[3] = ceil(time_step[2]);
    time_step[2] = ceil(time_step[1]);
    time_step[1] = ceil(time_step[0]);
    printf(" vertex %i in:\t%.6f sec\t\tETA: %.0f sec %s %.1f%%\r", k + 1,
           ((double)(clock() - start) / CLOCKS_PER_SEC),
           (k == nodes - 1) ? 0 : time_step[0], progress,
           (k == nodes - 1) ? 100 : 100 * ((float)k / nodes));
    fflush(stdout);
  }
  free(pred);
  return dist;
  free(dist);
}


x86 assembly (clang, -O0):
<floyd>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    %eax,-0x78(%rbp)
mov    -0x10(%rbp),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x78(%rbp),%eax
add    %ecx,%eax
cltq
shl    $0x0,%rax
mov    %eax,%edi
call   1080 <malloc@plt>
mov    %rax,-0x18(%rbp)
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1080 <malloc@plt>
mov    %rax,-0x58(%rbp)
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1080 <malloc@plt>
mov    %rax,-0x60(%rbp)
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1294 <floyd+0x124>
movslq -0xc(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1080 <malloc@plt>
mov    %rax,%rdx
mov    -0x58(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
movslq -0xc(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1080 <malloc@plt>
mov    %rax,%rdx
mov    -0x60(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1281 <floyd+0x111>
mov    -0x8(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x58(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x60(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    122a <floyd+0xba>
jmp    1286 <floyd+0x116>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    11db <floyd+0x6b>
mov    $0x0,%al
call   1060 <clock@plt>
movsd  %xmm0,-0x30(%rbp)
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    154f <floyd+0x3df>
mov    $0x0,%al
call   1060 <clock@plt>
movsd  %xmm0,-0x20(%rbp)
movl   $0x0,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1399 <floyd+0x229>
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1386 <floyd+0x216>
mov    -0x58(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x6c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x58(%rbp),%rcx
movslq -0x6c(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
movslq -0x74(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
mov    -0x58(%rbp),%rcx
movslq -0x70(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
movslq -0x74(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1373 <floyd+0x203>
mov    -0x58(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x6c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x58(%rbp),%rax
movslq -0x6c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x74(%rbp),%rcx
add    (%rax,%rcx,4),%edx
mov    -0x58(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x74(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x6c(%rbp),%edx
mov    -0x60(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x74(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1378 <floyd+0x208>
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    12d9 <floyd+0x169>
jmp    138b <floyd+0x21b>
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    12c6 <floyd+0x156>
mov    $0x0,%al
call   1060 <clock@plt>
movsd  %xmm0,-0x28(%rbp)
mov    -0x18(%rbp),%rdi
mov    -0x6c(%rbp),%esi
mov    -0xc(%rbp),%edx
mov    -0x10(%rbp),%ecx
call   1040 <get_progress@plt>
movsd  -0x28(%rbp),%xmm0
subsd  -0x20(%rbp),%xmm0
mov    0x2c20(%rip),%rax
divsd  (%rax),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0xc(%rbp),%eax
sub    -0x6c(%rbp),%eax
cvtsi2sd %eax,%xmm0
mulsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x38(%rbp),%xmm0
addsd  -0x40(%rbp),%xmm0
addsd  -0x48(%rbp),%xmm0
addsd  -0x50(%rbp),%xmm0
call   1050 <ceil@plt>
mov    $0x4,%ecx
cltd
idiv   %ecx
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x40(%rbp),%xmm0
call   1050 <ceil@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x48(%rbp),%xmm0
call   1050 <ceil@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x50(%rbp),%xmm0
call   1050 <ceil@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
mov    $0x0,%al
call   1060 <clock@plt>
subsd  -0x30(%rbp),%xmm0
mov    0x2b81(%rip),%rax
divsd  (%rax),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x6c(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    1491 <floyd+0x321>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
jmp    149e <floyd+0x32e>
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x6c(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    14df <floyd+0x36f>
movss  0xb2e(%rip),%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
jmp    1501 <floyd+0x391>
cvtsi2ssl -0x6c(%rbp),%xmm1
cvtsi2ssl -0xc(%rbp),%xmm0
divss  %xmm0,%xmm1
movss  0xb0b(%rip),%xmm0
mulss  %xmm1,%xmm0
movss  %xmm0,-0xa4(%rbp)
mov    -0x98(%rbp),%rdx
movsd  -0xa0(%rbp),%xmm1
ff
movsd  -0x80(%rbp),%xmm0
mov    -0x84(%rbp),%esi
movss  -0xa4(%rbp),%xmm2
ff
cvttss2si %xmm2,%ecx
lea    0xad6(%rip),%rdi
call   1070 <printf@plt>
mov    0x2a9e(%rip),%rax
mov    (%rax),%edi
call   1090 <fflush@plt>
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    12a7 <floyd+0x137>
mov    -0x60(%rbp),%rdi
call   1030 <free@plt>
mov    -0x58(%rbp),%rax
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<floyd>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %esi,%ebp
mov    %rdi,0x10(%rsp)
movslq %edx,%rax
imul   $0x55555556,%rax,%rdi
mov    %rdi,%rax
shr    $0x3f,%rax
shr    $0x20,%rdi
add    %eax,%edi
mov    %edx,0x44(%rsp)
add    %edx,%edi
call   1080 <malloc@plt>
mov    %rax,0x48(%rsp)
lea    0x0(,%rbp,8),%ebx
mov    %ebx,%edi
call   1080 <malloc@plt>
mov    %rax,%r15
mov    %ebx,%edi
call   1080 <malloc@plt>
mov    %rax,%rbx
test   %ebp,%ebp
jle    162d <floyd+0x4bd>
lea    0x0(,%rbp,4),%eax
mov    %eax,0x8(%rsp)
mov    %rbp,0x20(%rsp)
mov    %ebp,%r14d
mov    %r14d,%eax
and    $0xfffffff8,%eax
mov    %rax,0x18(%rsp)
add    $0xfffffffffffffff8,%rax
mov    %rax,0x38(%rsp)
mov    %rax,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
lea    -0x1(%r14),%r13
mov    %rcx,%rax
mov    %rcx,0x30(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x28(%rsp)
mov    %r14d,%eax
and    $0x3,%eax
mov    %rax,(%rsp)
xor    %r12d,%r12d
jmp    123d <floyd+0xcd>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r12
cmp    %r14,%r12
je     13ee <floyd+0x27e>
mov    0x8(%rsp),%ebp
mov    %ebp,%edi
call   1080 <malloc@plt>
mov    %rax,(%r15,%r12,8)
mov    %ebp,%edi
call   1080 <malloc@plt>
mov    %rax,(%rbx,%r12,8)
mov    0x10(%rsp),%rcx
mov    (%rcx,%r12,8),%rcx
mov    (%r15,%r12,8),%rdx
cmpl   $0x8,0x20(%rsp)
jae    12f0 <floyd+0x180>
xor    %esi,%esi
mov    %r13,%r8
sub    %rsi,%r8
mov    (%rsp),%rbp
test   %rbp,%rbp
je     1297 <floyd+0x127>
mov    (%rcx,%rsi,4),%edi
mov    %edi,(%rdx,%rsi,4)
movl   $0x0,(%rax,%rsi,4)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rbp
jne    1280 <floyd+0x110>
cmp    $0x3,%r8
jb     1230 <floyd+0xc0>
nopl   (%rax)
mov    (%rcx,%rsi,4),%edi
mov    %edi,(%rdx,%rsi,4)
movl   $0x0,(%rax,%rsi,4)
mov    0x4(%rcx,%rsi,4),%edi
mov    %edi,0x4(%rdx,%rsi,4)
movl   $0x0,0x4(%rax,%rsi,4)
mov    0x8(%rcx,%rsi,4),%edi
mov    %edi,0x8(%rdx,%rsi,4)
movl   $0x0,0x8(%rax,%rsi,4)
mov    0xc(%rcx,%rsi,4),%edi
mov    %edi,0xc(%rdx,%rsi,4)
movl   $0x0,0xc(%rax,%rsi,4)
add    $0x4,%rsi
cmp    %rsi,%r14
jne    12a0 <floyd+0x130>
jmp    1230 <floyd+0xc0>
nopl   0x0(%rax,%rax,1)
lea    (%rdx,%r14,4),%rdi
lea    (%rax,%r14,4),%rbp
lea    (%rcx,%r14,4),%rsi
cmp    %rbp,%rdx
setb   %r11b
cmp    %rdi,%rax
setb   %r8b
cmp    %rsi,%rdx
setb   %r10b
cmp    %rdi,%rcx
setb   %r9b
cmp    %rsi,%rax
setb   %dil
cmp    %rbp,%rcx
setb   %bpl
test   %r8b,%r11b
jne    126f <floyd+0xff>
and    %r9b,%r10b
jne    126f <floyd+0xff>
mov    $0x0,%esi
and    %bpl,%dil
xorps  %xmm2,%xmm2
jne    1271 <floyd+0x101>
cmpq   $0x0,0x38(%rsp)
je     13e3 <floyd+0x273>
mov    0x28(%rsp),%rdi
xor    %esi,%esi
nopl   0x0(%rax)
movups (%rcx,%rsi,4),%xmm0
movups 0x10(%rcx,%rsi,4),%xmm1
movups %xmm0,(%rdx,%rsi,4)
movups %xmm1,0x10(%rdx,%rsi,4)
movups %xmm2,(%rax,%rsi,4)
movups %xmm2,0x10(%rax,%rsi,4)
movupd 0x20(%rcx,%rsi,4),%xmm0
movupd 0x30(%rcx,%rsi,4),%xmm1
movupd %xmm0,0x20(%rdx,%rsi,4)
movupd %xmm1,0x30(%rdx,%rsi,4)
movups %xmm2,0x20(%rax,%rsi,4)
movups %xmm2,0x30(%rax,%rsi,4)
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1360 <floyd+0x1f0>
testb  $0x1,0x30(%rsp)
je     13cd <floyd+0x25d>
movupd (%rcx,%rsi,4),%xmm0
movupd 0x10(%rcx,%rsi,4),%xmm1
movupd %xmm0,(%rdx,%rsi,4)
movupd %xmm1,0x10(%rdx,%rsi,4)
movups %xmm2,(%rax,%rsi,4)
movups %xmm2,0x10(%rax,%rsi,4)
mov    0x18(%rsp),%rdi
mov    %rdi,%rsi
cmp    %r14,%rdi
je     1230 <floyd+0xc0>
jmp    1271 <floyd+0x101>
xor    %esi,%esi
testb  $0x1,0x30(%rsp)
jne    13ae <floyd+0x23e>
jmp    13cd <floyd+0x25d>
xor    %eax,%eax
call   1060 <clock@plt>
movsd  %xmm0,0x30(%rsp)
cmpl   $0x0,0x20(%rsp)
jle    1634 <floyd+0x4c4>
mov    0x20(%rsp),%rax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,0x40(%rsp)
add    $0xffffffff,%eax
mov    %rax,0x28(%rsp)
mov    %r14d,%r12d
and    $0xfffffffe,%r12d
xor    %ebp,%ebp
mov    %r15,0x50(%rsp)
jmp    148f <floyd+0x31f>
cvtsi2sdl 0x8(%rsp),%xmm3
movsd  %xmm3,(%rsp)
xorps  %xmm3,%xmm3
cvtsi2sdl 0x10(%rsp),%xmm3
movsd  %xmm3,0x8(%rsp)
xorps  %xmm3,%xmm3
cvtsi2sdl 0x18(%rsp),%xmm3
movsd  %xmm3,0x10(%rsp)
cvttss2si %xmm2,%ecx
lea    0xba0(%rip),%rdi
mov    %r15,%rbp
mov    %ebp,%esi
mov    0x48(%rsp),%rdx
call   1070 <printf@plt>
mov    0x2b5e(%rip),%rax
mov    (%rax),%edi
call   1090 <fflush@plt>
cmp    %r14,%r15
mov    0x50(%rsp),%r15
je     1634 <floyd+0x4c4>
xor    %eax,%eax
call   1060 <clock@plt>
movsd  %xmm0,0x18(%rsp)
mov    (%r15,%rbp,8),%rax
xor    %ecx,%ecx
jmp    14b9 <floyd+0x349>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rcx
cmp    %r14,%rcx
je     1530 <floyd+0x3c0>
mov    (%r15,%rcx,8),%rdx
xor    %esi,%esi
test   %r13,%r13
jne    14f9 <floyd+0x389>
test   $0x1,%r14b
je     14b0 <floyd+0x340>
mov    (%rax,%rsi,4),%edi
add    (%rdx,%rbp,4),%edi
cmp    (%rdx,%rsi,4),%edi
jge    14b0 <floyd+0x340>
mov    %edi,(%rdx,%rsi,4)
mov    (%rbx,%rcx,8),%rdx
mov    %ebp,(%rdx,%rsi,4)
jmp    14b0 <floyd+0x340>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x2,%rsi
cmp    %rsi,%r12
je     14c4 <floyd+0x354>
mov    (%rax,%rsi,4),%edi
add    (%rdx,%rbp,4),%edi
cmp    (%rdx,%rsi,4),%edi
jge    150e <floyd+0x39e>
mov    %edi,(%rdx,%rsi,4)
mov    (%rbx,%rcx,8),%rdi
mov    %ebp,(%rdi,%rsi,4)
mov    0x4(%rax,%rsi,4),%edi
add    (%rdx,%rbp,4),%edi
cmp    0x4(%rdx,%rsi,4),%edi
jge    14f0 <floyd+0x380>
mov    %edi,0x4(%rdx,%rsi,4)
mov    (%rbx,%rcx,8),%rdi
mov    %ebp,0x4(%rdi,%rsi,4)
jmp    14f0 <floyd+0x380>
nopl   0x0(%rax)
xor    %eax,%eax
call   1060 <clock@plt>
movsd  %xmm0,0x38(%rsp)
mov    0x48(%rsp),%rdi
mov    %ebp,%esi
mov    0x20(%rsp),%r15
mov    %r15d,%edx
mov    0x44(%rsp),%ecx
call   1040 <get_progress@plt>
movsd  0x38(%rsp),%xmm0
subsd  0x18(%rsp),%xmm0
mov    0x2a80(%rip),%rax
divsd  (%rax),%xmm0
mov    %r15d,%eax
sub    %ebp,%eax
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
mulsd  %xmm0,%xmm1
movsd  (%rsp),%xmm0
addsd  0x8(%rsp),%xmm0
addsd  0x10(%rsp),%xmm0
addsd  %xmm1,%xmm0
call   1050 <ceil@plt>
lea    0x3(%rax),%ecx
test   %eax,%eax
cmovns %eax,%ecx
sar    $0x2,%ecx
xorps  %xmm0,%xmm0
cvtsi2sd %ecx,%xmm0
movsd  %xmm0,(%rsp)
movsd  0x8(%rsp),%xmm0
call   1050 <ceil@plt>
mov    %eax,0x8(%rsp)
movsd  0x10(%rsp),%xmm0
call   1050 <ceil@plt>
mov    %eax,0x10(%rsp)
movsd  (%rsp),%xmm0
call   1050 <ceil@plt>
mov    %eax,0x18(%rsp)
lea    0x1(%rbp),%r15
xor    %eax,%eax
call   1060 <clock@plt>
subsd  0x30(%rsp),%xmm0
mov    0x29f7(%rip),%rax
divsd  (%rax),%xmm0
xorpd  %xmm1,%xmm1
cmp    0x28(%rsp),%rbp
je     1605 <floyd+0x495>
movsd  (%rsp),%xmm1
movss  0x9f3(%rip),%xmm2
je     1430 <floyd+0x2c0>
xorps  %xmm2,%xmm2
cvtsi2ss %ebp,%xmm2
divss  0x40(%rsp),%xmm2
mulss  0x9d8(%rip),%xmm2
jmp    1430 <floyd+0x2c0>
xor    %eax,%eax
call   1060 <clock@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    %r15,%rax
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@CLOCKS_PER_SEC = global double 0.000000e+00
@.str = [50 x i8] c" vertex %i in:\09%.6f sec\09\09ETA: %.0f sec %s %.1f%%\0D\00"
@stdout = global i32 0
define i32** @floyd(i32** %0, i32 %1, i32 %2) {
%4 = alloca i32**
%5 = alloca i32
%6 = alloca i32
%7 = alloca i8*
%8 = alloca double
%9 = alloca double
%10 = alloca double
%11 = alloca [4 x double]
%12 = alloca i32**
%13 = alloca i32**
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
store i32** %0, i32*** %4
store i32 %1, i32* %5
store i32 %2, i32* %6
%19 = load i32, i32* %6
%20 = load i32, i32* %6
%21 = sdiv i32 %20, 3
%22 = add nsw i32 %19, %21
%23 = sext i32 %22 to i64
%24 = mul i64 1, %23
%25 = trunc i64 %24 to i32
%26 = call i64 @malloc(i32 %25)
%27 = inttoptr i64 %26 to i8*
store i8* %27, i8** %7
%28 = load i32, i32* %5
%29 = sext i32 %28 to i64
%30 = mul i64 8, %29
%31 = trunc i64 %30 to i32
%32 = call i64 @malloc(i32 %31)
%33 = inttoptr i64 %32 to i32**
store i32** %33, i32*** %12
%34 = load i32, i32* %5
%35 = sext i32 %34 to i64
%36 = mul i64 8, %35
%37 = trunc i64 %36 to i32
%38 = call i64 @malloc(i32 %37)
%39 = inttoptr i64 %38 to i32**
store i32** %39, i32*** %13
store i32 0, i32* %14
br label %40
40: ; preds = %99, %3
%41 = load i32, i32* %14
%42 = load i32, i32* %5
%43 = icmp slt i32 %41, %42
br i1 %43, label %44, label %102
44: ; preds = %40
%45 = load i32, i32* %5
%46 = sext i32 %45 to i64
%47 = mul i64 4, %46
%48 = trunc i64 %47 to i32
%49 = call i64 @malloc(i32 %48)
%50 = inttoptr i64 %49 to i32*
%51 = load i32**, i32*** %12
%52 = load i32, i32* %14
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds i32*, i32** %51, i64 %53
store i32* %50, i32** %54
%55 = load i32, i32* %5
%56 = sext i32 %55 to i64
%57 = mul i64 4, %56
%58 = trunc i64 %57 to i32
%59 = call i64 @malloc(i32 %58)
%60 = inttoptr i64 %59 to i32*
%61 = load i32**, i32*** %13
%62 = load i32, i32* %14
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds i32*, i32** %61, i64 %63
store i32* %60, i32** %64
store i32 0, i32* %15
br label %65
65: ; preds = %95, %44
%66 = load i32, i32* %15
%67 = load i32, i32* %5
%68 = icmp slt i32 %66, %67
br i1 %68, label %69, label %98
69: ; preds = %65
%70 = load i32**, i32*** %4
%71 = load i32, i32* %14
%72 = sext i32 %71 to i64
%73 = getelementptr inbounds i32*, i32** %70, i64 %72
%74 = load i32*, i32** %73
%75 = load i32, i32* %15
%76 = sext i32 %75 to i64
%77 = getelementptr inbounds i32, i32* %74, i64 %76
%78 = load i32, i32* %77
%79 = load i32**, i32*** %12
%80 = load i32, i32* %14
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds i32*, i32** %79, i64 %81
%83 = load i32*, i32** %82
%84 = load i32, i32* %15
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds i32, i32* %83, i64 %85
store i32 %78, i32* %86
%87 = load i32**, i32*** %13
%88 = load i32, i32* %14
%89 = sext i32 %88 to i64
%90 = getelementptr inbounds i32*, i32** %87, i64 %89
%91 = load i32*, i32** %90
%92 = load i32, i32* %15
%93 = sext i32 %92 to i64
%94 = getelementptr inbounds i32, i32* %91, i64 %93
store i32 0, i32* %94
br label %95
95: ; preds = %69
%96 = load i32, i32* %15
%97 = add nsw i32 %96, 1
store i32 %97, i32* %15
br label %65
98: ; preds = %65
br label %99
99: ; preds = %98
%100 = load i32, i32* %14
%101 = add nsw i32 %100, 1
store i32 %101, i32* %14
br label %40
102: ; preds = %40
%103 = call double (...) @clock()
store double %103, double* %10
store i32 0, i32* %16
br label %104
104: ; preds = %280, %102
%105 = load i32, i32* %16
%106 = load i32, i32* %5
%107 = icmp slt i32 %105, %106
br i1 %107, label %108, label %283
108: ; preds = %104
%109 = call double (...) @clock()
store double %109, double* %8
store i32 0, i32* %17
br label %110
110: ; preds = %191, %108
%111 = load i32, i32* %17
%112 = load i32, i32* %5
%113 = icmp slt i32 %111, %112
br i1 %113, label %114, label %194
114: ; preds = %110
store i32 0, i32* %18
br label %115
115: ; preds = %187, %114
%116 = load i32, i32* %18
%117 = load i32, i32* %5
%118 = icmp slt i32 %116, %117
br i1 %118, label %119, label %190
119: ; preds = %115
%120 = load i32**, i32*** %12
%121 = load i32, i32* %17
%122 = sext i32 %121 to i64
%123 = getelementptr inbounds i32*, i32** %120, i64 %122
%124 = load i32*, i32** %123
%125 = load i32, i32* %16
%126 = sext i32 %125 to i64
%127 = getelementptr inbounds i32, i32* %124, i64 %126
%128 = load i32, i32* %127
%129 = load i32**, i32*** %12
%130 = load i32, i32* %16
%131 = sext i32 %130 to i64
%132 = getelementptr inbounds i32*, i32** %129, i64 %131
%133 = load i32*, i32** %132
%134 = load i32, i32* %18
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds i32, i32* %133, i64 %135
%137 = load i32, i32* %136
%138 = add nsw i32 %128, %137
%139 = load i32**, i32*** %12
%140 = load i32, i32* %17
%141 = sext i32 %140 to i64
%142 = getelementptr inbounds i32*, i32** %139, i64 %141
%143 = load i32*, i32** %142
%144 = load i32, i32* %18
%145 = sext i32 %144 to i64
%146 = getelementptr inbounds i32, i32* %143, i64 %145
%147 = load i32, i32* %146
%148 = icmp slt i32 %138, %147
br i1 %148, label %149, label %186
149: ; preds = %119
%150 = load i32**, i32*** %12
%151 = load i32, i32* %17
%152 = sext i32 %151 to i64
%153 = getelementptr inbounds i32*, i32** %150, i64 %152
%154 = load i32*, i32** %153
%155 = load i32, i32* %16
%156 = sext i32 %155 to i64
%157 = getelementptr inbounds i32, i32* %154, i64 %156
%158 = load i32, i32* %157
%159 = load i32**, i32*** %12
%160 = load i32, i32* %16
%161 = sext i32 %160 to i64
%162 = getelementptr inbounds i32*, i32** %159, i64 %161
%163 = load i32*, i32** %162
%164 = load i32, i32* %18
%165 = sext i32 %164 to i64
%166 = getelementptr inbounds i32, i32* %163, i64 %165
%167 = load i32, i32* %166
%168 = add nsw i32 %158, %167
%169 = load i32**, i32*** %12
%170 = load i32, i32* %17
%171 = sext i32 %170 to i64
%172 = getelementptr inbounds i32*, i32** %169, i64 %171
%173 = load i32*, i32** %172
%174 = load i32, i32* %18
%175 = sext i32 %174 to i64
%176 = getelementptr inbounds i32, i32* %173, i64 %175
store i32 %168, i32* %176
%177 = load i32, i32* %16
%178 = load i32**, i32*** %13
%179 = load i32, i32* %17
%180 = sext i32 %179 to i64
%181 = getelementptr inbounds i32*, i32** %178, i64 %180
%182 = load i32*, i32** %181
%183 = load i32, i32* %18
%184 = sext i32 %183 to i64
%185 = getelementptr inbounds i32, i32* %182, i64 %184
store i32 %177, i32* %185
br label %186
186: ; preds = %149, %119
br label %187
187: ; preds = %186
%188 = load i32, i32* %18
%189 = add nsw i32 %188, 1
store i32 %189, i32* %18
br label %115
190: ; preds = %115
br label %191
191: ; preds = %190
%192 = load i32, i32* %17
%193 = add nsw i32 %192, 1
store i32 %193, i32* %17
br label %110
194: ; preds = %110
%195 = call double (...) @clock()
store double %195, double* %9
%196 = load i8*, i8** %7
%197 = load i32, i32* %16
%198 = load i32, i32* %5
%199 = load i32, i32* %6
%200 = call i32 @get_progress(i8* %196, i32 %197, i32 %198, i32 %199)
%201 = load double, double* %9
%202 = load double, double* %8
%203 = fsub double %201, %202
%204 = load double, double* @CLOCKS_PER_SEC
%205 = fdiv double %203, %204
%206 = getelementptr inbounds [4 x double], [4 x double]* %11, i64 0, i64 0
store double %205, double* %206
%207 = load i32, i32* %5
%208 = load i32, i32* %16
%209 = sub nsw i32 %207, %208
%210 = sitofp i32 %209 to double
%211 = getelementptr inbounds [4 x double], [4 x double]* %11, i64 0, i64 0
%212 = load double, double* %211
%213 = fmul double %212, %210
store double %213, double* %211
%214 = getelementptr inbounds [4 x double], [4 x double]* %11, i64 0, i64 3
%215 = load double, double* %214
%216 = getelementptr inbounds [4 x double], [4 x double]* %11, i64 0, i64 2
%217 = load double, double* %216
%218 = fadd double %215, %217
%219 = getelementptr inbounds [4 x double], [4 x double]* %11, i64 0, i64 1
%220 = load double, double* %219
%221 = fadd double %218, %220
%222 = getelementptr inbounds [4 x double], [4 x double]* %11, i64 0, i64 0
%223 = load double, double* %222
%224 = fadd double %221, %223
%225 = call i32 @ceil(double %224)
%226 = sdiv i32 %225, 4
%227 = sitofp i32 %226 to double
%228 = getelementptr inbounds [4 x double], [4 x double]* %11, i64 0, i64 0
store double %227, double* %228
%229 = getelementptr inbounds [4 x double], [4 x double]* %11, i64 0, i64 2
%230 = load double, double* %229
%231 = call i32 @ceil(double %230)
%232 = sitofp i32 %231 to double
%233 = getelementptr inbounds [4 x double], [4 x double]* %11, i64 0, i64 3
store double %232, double* %233
%234 = getelementptr inbounds [4 x double], [4 x double]* %11, i64 0, i64 1
%235 = load double, double* %234
%236 = call i32 @ceil(double %235)
%237 = sitofp i32 %236 to double
%238 = getelementptr inbounds [4 x double], [4 x double]* %11, i64 0, i64 2
store double %237, double* %238
%239 = getelementptr inbounds [4 x double], [4 x double]* %11, i64 0, i64 0
%240 = load double, double* %239
%241 = call i32 @ceil(double %240)
%242 = sitofp i32 %241 to double
%243 = getelementptr inbounds [4 x double], [4 x double]* %11, i64 0, i64 1
store double %242, double* %243
%244 = load i32, i32* %16
%245 = add nsw i32 %244, 1
%246 = call double (...) @clock()
%247 = load double, double* %10
%248 = fsub double %246, %247
%249 = load double, double* @CLOCKS_PER_SEC
%250 = fdiv double %248, %249
%251 = load i32, i32* %16
%252 = load i32, i32* %5
%253 = sub nsw i32 %252, 1
%254 = icmp eq i32 %251, %253
br i1 %254, label %255, label %256
255: ; preds = %194
br label %259
256: ; preds = %194
%257 = getelementptr inbounds [4 x double], [4 x double]* %11, i64 0, i64 0
%258 = load double, double* %257
br label %259
259: ; preds = %256, %255
%260 = phi double [ 0.000000e+00, %255 ], [ %258, %256 ]
%261 = load i8*, i8** %7
%262 = load i32, i32* %16
%263 = load i32, i32* %5
%264 = sub nsw i32 %263, 1
%265 = icmp eq i32 %262, %264
br i1 %265, label %266, label %267
266: ; preds = %259
br label %274
267: ; preds = %259
%268 = load i32, i32* %16
%269 = sitofp i32 %268 to float
%270 = load i32, i32* %5
%271 = sitofp i32 %270 to float
%272 = fdiv float %269, %271
%273 = fmul float 1.000000e+02, %272
br label %274
274: ; preds = %267, %266
%275 = phi float [ 1.000000e+02, %266 ], [ %273, %267 ]
%276 = fptosi float %275 to i32
%277 = call i32 @printf(i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str, i64 0, i64 0), i32 %245, double %250, double %260, i8* %261, i32 %276)
%278 = load i32, i32* @stdout
%279 = call i32 @fflush(i32 %278)
br label %280
280: ; preds = %274
%281 = load i32, i32* %16
%282 = add nsw i32 %281, 1
store i32 %282, i32* %16
br label %104
283: ; preds = %104
%284 = load i32**, i32*** %13
%285 = call i32 @free(i32** %284)
%286 = load i32**, i32*** %12
ret i32** %286
}

LLVM IR (-O2):
@CLOCKS_PER_SEC = global double 0.000000e+00
@.str = [50 x i8] c" vertex %i in:\09%.6f sec\09\09ETA: %.0f sec %s %.1f%%\0D\00"
@stdout = global i32 0
define i32** @floyd(i32** nocapture %0, i32 %1, i32 %2) {
%4 = sdiv i32 %2, 3
%5 = add nsw i32 %4, %2
%6 = tail call i64 @malloc(i32 %5)
%7 = inttoptr i64 %6 to i8*
%8 = shl i32 %1, 3
%9 = tail call i64 @malloc(i32 %8)
%10 = inttoptr i64 %9 to i32**
%11 = tail call i64 @malloc(i32 %8)
%12 = inttoptr i64 %11 to i32**
%13 = icmp sgt i32 %1, 0
br i1 %13, label %16, label %14
14: ; preds = %3
%15 = tail call double (...) @clock()
br label %169
16: ; preds = %3
%17 = shl i32 %1, 2
%18 = zext i32 %1 to i64
%19 = and i64 %18, 4294967288
%20 = add nsw i64 %19, -8
%21 = lshr exact i64 %20, 3
%22 = add nuw nsw i64 %21, 1
%23 = add nsw i64 %18, -1
%24 = icmp ult i32 %1, 8
%25 = and i64 %18, 4294967288
%26 = and i64 %22, 1
%27 = icmp eq i64 %20, 0
%28 = and i64 %22, 4611686018427387902
%29 = icmp eq i64 %26, 0
%30 = icmp eq i64 %25, %18
%31 = and i64 %18, 3
%32 = icmp eq i64 %31, 0
br label %44
33: ; preds = %143
%34 = tail call double (...) @clock()
br i1 %13, label %35, label %169
35: ; preds = %33
%36 = add nsw i32 %1, -1
%37 = sitofp i32 %1 to float
%38 = zext i32 %36 to i64
%39 = zext i32 %1 to i64
%40 = and i64 %39, 1
%41 = icmp eq i64 %23, 0
%42 = and i64 %39, 4294967294
%43 = icmp eq i64 %40, 0
br label %171
44: ; preds = %143, %16
%45 = phi i64 [ 0, %16 ], [ %144, %143 ]
%46 = tail call i64 @malloc(i32 %17)
%47 = inttoptr i64 %46 to i32*
%48 = getelementptr inbounds i32*, i32** %10, i64 %45
store i32* %47, i32** %48
%49 = tail call i64 @malloc(i32 %17)
%50 = inttoptr i64 %49 to i32*
%51 = inttoptr i64 %49 to i8*
%52 = getelementptr inbounds i32*, i32** %12, i64 %45
store i32* %50, i32** %52
%53 = getelementptr inbounds i32*, i32** %0, i64 %45
%54 = load i32*, i32** %53
%55 = load i32*, i32** %48
br i1 %24, label %127, label %56
56: ; preds = %44
%57 = getelementptr i32, i32* %55, i64 %18
%58 = bitcast i32* %57 to i8*
%59 = getelementptr i32, i32* %50, i64 %18
%60 = getelementptr i32, i32* %54, i64 %18
%61 = bitcast i32* %60 to i8*
%62 = icmp ult i32* %55, %59
%63 = icmp ult i8* %51, %58
%64 = and i1 %62, %63
%65 = icmp ult i32* %55, %60
%66 = icmp ult i32* %54, %57
%67 = and i1 %65, %66
%68 = or i1 %64, %67
%69 = icmp ult i8* %51, %61
%70 = icmp ult i32* %54, %59
%71 = and i1 %69, %70
%72 = or i1 %68, %71
br i1 %72, label %127, label %73
73: ; preds = %56
br i1 %27, label %109, label %74
74: ; preds = %73, %74
%75 = phi i64 [ %106, %74 ], [ 0, %73 ]
%76 = phi i64 [ %107, %74 ], [ 0, %73 ]
%77 = getelementptr inbounds i32, i32* %54, i64 %75
%78 = bitcast i32* %77 to <4 x i32>*
%79 = load <4 x i32>, <4 x i32>* %78
%80 = getelementptr inbounds i32, i32* %77, i64 4
%81 = bitcast i32* %80 to <4 x i32>*
%82 = load <4 x i32>, <4 x i32>* %81
%83 = getelementptr inbounds i32, i32* %55, i64 %75
%84 = bitcast i32* %83 to <4 x i32>*
store <4 x i32> %79, <4 x i32>* %84
%85 = getelementptr inbounds i32, i32* %83, i64 4
%86 = bitcast i32* %85 to <4 x i32>*
store <4 x i32> %82, <4 x i32>* %86
%87 = getelementptr inbounds i32, i32* %50, i64 %75
%88 = bitcast i32* %87 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %88
%89 = getelementptr inbounds i32, i32* %87, i64 4
%90 = bitcast i32* %89 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %90
%91 = or i64 %75, 8
%92 = getelementptr inbounds i32, i32* %54, i64 %91
%93 = bitcast i32* %92 to <4 x i32>*
%94 = load <4 x i32>, <4 x i32>* %93
%95 = getelementptr inbounds i32, i32* %92, i64 4
%96 = bitcast i32* %95 to <4 x i32>*
%97 = load <4 x i32>, <4 x i32>* %96
%98 = getelementptr inbounds i32, i32* %55, i64 %91
%99 = bitcast i32* %98 to <4 x i32>*
store <4 x i32> %94, <4 x i32>* %99
%100 = getelementptr inbounds i32, i32* %98, i64 4
%101 = bitcast i32* %100 to <4 x i32>*
store <4 x i32> %97, <4 x i32>* %101
%102 = getelementptr inbounds i32, i32* %50, i64 %91
%103 = bitcast i32* %102 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %103
%104 = getelementptr inbounds i32, i32* %102, i64 4
%105 = bitcast i32* %104 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %105
%106 = add nuw i64 %75, 16
%107 = add i64 %76, 2
%108 = icmp eq i64 %107, %28
br i1 %108, label %109, label %74
109: ; preds = %74, %73
%110 = phi i64 [ 0, %73 ], [ %106, %74 ]
br i1 %29, label %126, label %111
111: ; preds = %109
%112 = getelementptr inbounds i32, i32* %54, i64 %110
%113 = bitcast i32* %112 to <4 x i32>*
%114 = load <4 x i32>, <4 x i32>* %113
%115 = getelementptr inbounds i32, i32* %112, i64 4
%116 = bitcast i32* %115 to <4 x i32>*
%117 = load <4 x i32>, <4 x i32>* %116
%118 = getelementptr inbounds i32, i32* %55, i64 %110
%119 = bitcast i32* %118 to <4 x i32>*
store <4 x i32> %114, <4 x i32>* %119
%120 = getelementptr inbounds i32, i32* %118, i64 4
%121 = bitcast i32* %120 to <4 x i32>*
store <4 x i32> %117, <4 x i32>* %121
%122 = getelementptr inbounds i32, i32* %50, i64 %110
%123 = bitcast i32* %122 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %123
%124 = getelementptr inbounds i32, i32* %122, i64 4
%125 = bitcast i32* %124 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %125
br label %126
126: ; preds = %109, %111
br i1 %30, label %143, label %127
127: ; preds = %56, %44, %126
%128 = phi i64 [ 0, %56 ], [ 0, %44 ], [ %25, %126 ]
%129 = sub nsw i64 %23, %128
br i1 %32, label %140, label %130
130: ; preds = %127, %130
%131 = phi i64 [ %137, %130 ], [ %128, %127 ]
%132 = phi i64 [ %138, %130 ], [ 0, %127 ]
%133 = getelementptr inbounds i32, i32* %54, i64 %131
%134 = load i32, i32* %133
%135 = getelementptr inbounds i32, i32* %55, i64 %131
store i32 %134, i32* %135
%136 = getelementptr inbounds i32, i32* %50, i64 %131
store i32 0, i32* %136
%137 = add nuw nsw i64 %131, 1
%138 = add i64 %132, 1
%139 = icmp eq i64 %138, %31
br i1 %139, label %140, label %130
140: ; preds = %130, %127
%141 = phi i64 [ %128, %127 ], [ %137, %130 ]
%142 = icmp ult i64 %129, 3
br i1 %142, label %143, label %146
143: ; preds = %140, %146, %126
%144 = add nuw nsw i64 %45, 1
%145 = icmp eq i64 %144, %18
br i1 %145, label %33, label %44
146: ; preds = %140, %146
%147 = phi i64 [ %167, %146 ], [ %141, %140 ]
%148 = getelementptr inbounds i32, i32* %54, i64 %147
%149 = load i32, i32* %148
%150 = getelementptr inbounds i32, i32* %55, i64 %147
store i32 %149, i32* %150
%151 = getelementptr inbounds i32, i32* %50, i64 %147
store i32 0, i32* %151
%152 = add nuw nsw i64 %147, 1
%153 = getelementptr inbounds i32, i32* %54, i64 %152
%154 = load i32, i32* %153
%155 = getelementptr inbounds i32, i32* %55, i64 %152
store i32 %154, i32* %155
%156 = getelementptr inbounds i32, i32* %50, i64 %152
store i32 0, i32* %156
%157 = add nuw nsw i64 %147, 2
%158 = getelementptr inbounds i32, i32* %54, i64 %157
%159 = load i32, i32* %158
%160 = getelementptr inbounds i32, i32* %55, i64 %157
store i32 %159, i32* %160
%161 = getelementptr inbounds i32, i32* %50, i64 %157
store i32 0, i32* %161
%162 = add nuw nsw i64 %147, 3
%163 = getelementptr inbounds i32, i32* %54, i64 %162
%164 = load i32, i32* %163
%165 = getelementptr inbounds i32, i32* %55, i64 %162
store i32 %164, i32* %165
%166 = getelementptr inbounds i32, i32* %50, i64 %162
store i32 0, i32* %166
%167 = add nuw nsw i64 %147, 4
%168 = icmp eq i64 %167, %18
br i1 %168, label %143, label %146
169: ; preds = %264, %14, %33
%170 = tail call i32 @free(i32** %12)
ret i32** %10
171: ; preds = %264, %35
%172 = phi i64 [ 0, %35 ], [ %208, %264 ]
%173 = phi double [ undef, %35 ], [ %203, %264 ]
%174 = phi double [ undef, %35 ], [ %205, %264 ]
%175 = phi double [ undef, %35 ], [ %207, %264 ]
%176 = tail call double (...) @clock()
%177 = getelementptr inbounds i32*, i32** %10, i64 %172
%178 = load i32*, i32** %177
%179 = trunc i64 %172 to i32
br label %180
180: ; preds = %228, %171
%181 = phi i64 [ 0, %171 ], [ %229, %228 ]
%182 = getelementptr inbounds i32*, i32** %10, i64 %181
%183 = load i32*, i32** %182
%184 = getelementptr inbounds i32, i32* %183, i64 %172
%185 = getelementptr inbounds i32*, i32** %12, i64 %181
br i1 %41, label %215, label %231
186: ; preds = %228
%187 = tail call double (...) @clock()
%188 = trunc i64 %172 to i32
%189 = tail call i32 @get_progress(i8* %7, i32 %188, i32 %1, i32 %2)
%190 = fsub double %187, %176
%191 = load double, double* @CLOCKS_PER_SEC
%192 = fdiv double %190, %191
%193 = sub nsw i32 %1, %188
%194 = sitofp i32 %193 to double
%195 = fmul double %192, %194
%196 = fadd double %174, %173
%197 = fadd double %175, %196
%198 = fadd double %197, %195
%199 = tail call i32 @ceil(double %198)
%200 = sdiv i32 %199, 4
%201 = sitofp i32 %200 to double
%202 = tail call i32 @ceil(double %174)
%203 = sitofp i32 %202 to double
%204 = tail call i32 @ceil(double %175)
%205 = sitofp i32 %204 to double
%206 = tail call i32 @ceil(double %201)
%207 = sitofp i32 %206 to double
%208 = add nuw nsw i64 %172, 1
%209 = tail call double (...) @clock()
%210 = fsub double %209, %34
%211 = load double, double* @CLOCKS_PER_SEC
%212 = fdiv double %210, %211
%213 = icmp eq i64 %172, %38
%214 = select i1 %213, double 0.000000e+00, double %201
br i1 %213, label %264, label %260
215: ; preds = %256, %180
%216 = phi i64 [ 0, %180 ], [ %257, %256 ]
br i1 %43, label %228, label %217
217: ; preds = %215
%218 = load i32, i32* %184
%219 = getelementptr inbounds i32, i32* %178, i64 %216
%220 = load i32, i32* %219
%221 = add nsw i32 %220, %218
%222 = getelementptr inbounds i32, i32* %183, i64 %216
%223 = load i32, i32* %222
%224 = icmp slt i32 %221, %223
br i1 %224, label %225, label %228
225: ; preds = %217
store i32 %221, i32* %222
%226 = load i32*, i32** %185
%227 = getelementptr inbounds i32, i32* %226, i64 %216
store i32 %179, i32* %227
br label %228
228: ; preds = %217, %225, %215
%229 = add nuw nsw i64 %181, 1
%230 = icmp eq i64 %229, %39
br i1 %230, label %186, label %180
231: ; preds = %180, %256
%232 = phi i64 [ %257, %256 ], [ 0, %180 ]
%233 = phi i64 [ %258, %256 ], [ 0, %180 ]
%234 = load i32, i32* %184
%235 = getelementptr inbounds i32, i32* %178, i64 %232
%236 = load i32, i32* %235
%237 = add nsw i32 %236, %234
%238 = getelementptr inbounds i32, i32* %183, i64 %232
%239 = load i32, i32* %238
%240 = icmp slt i32 %237, %239
br i1 %240, label %241, label %244
241: ; preds = %231
store i32 %237, i32* %238
%242 = load i32*, i32** %185
%243 = getelementptr inbounds i32, i32* %242, i64 %232
store i32 %179, i32* %243
br label %244
244: ; preds = %231, %241
%245 = or i64 %232, 1
%246 = load i32, i32* %184
%247 = getelementptr inbounds i32, i32* %178, i64 %245
%248 = load i32, i32* %247
%249 = add nsw i32 %248, %246
%250 = getelementptr inbounds i32, i32* %183, i64 %245
%251 = load i32, i32* %250
%252 = icmp slt i32 %249, %251
br i1 %252, label %253, label %256
253: ; preds = %244
store i32 %249, i32* %250
%254 = load i32*, i32** %185
%255 = getelementptr inbounds i32, i32* %254, i64 %245
store i32 %179, i32* %255
br label %256
256: ; preds = %253, %244
%257 = add nuw nsw i64 %232, 2
%258 = add i64 %233, 2
%259 = icmp eq i64 %258, %42
br i1 %259, label %215, label %231
260: ; preds = %186
%261 = sitofp i32 %188 to float
%262 = fdiv float %261, %37
%263 = fmul float %262, 1.000000e+02
br label %264
264: ; preds = %186, %260
%265 = phi float [ %263, %260 ], [ 1.000000e+02, %186 ]
%266 = fptosi float %265 to i32
%267 = trunc i64 %208 to i32
%268 = tail call i32 @printf(i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str, i64 0, i64 0), i32 %267, double %212, double %214, i8* %7, i32 %266)
%269 = load i32, i32* @stdout
%270 = tail call i32 @fflush(i32 %269)
%271 = icmp eq i64 %208, %39
br i1 %271, label %169, label %171
}