#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 */
struct timeval {
  int dummy;
};

/* Variables and functions */
int atoi(char *);
scalar_t__ malloc(int);
int pow(int, int);
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ usleep(int);
int main(int argc, char *argv[]) {
  int nombreLignes, nombreColonnes, nombrePasTemps, tempsDiscretise,
      tailleSubdivision, nbProc;
  int idProc;
  struct timeval start, end;
  if (argc != 7) {
    printf("Veuillez entrer le nombre d'arguments comme suivant: #1 Nombre de "
           "lignes de la matrice, #2 Nombre de colonnes de la matrice, #3 le "
           "nombre de pas de temps, #4 le temps discrétisé, #5 la taille d'un "
           "côté d'une subdivision, #6 le nombre de processus à utiliser.\n");
    return 1;
  }
  nombreLignes = atoi(argv[1]);
  nombreColonnes = atoi(argv[2]);
  nombrePasTemps = atoi(argv[3]);
  tempsDiscretise = atoi(argv[4]);
  tailleSubdivision = atoi(argv[5]);
  nbProc = atoi(argv[6]);
  float **mat, **matkmoins1;
  mat = (float **)malloc(nombreLignes * sizeof(float *));
  for (int i = 0; i < nombreLignes; i++) {
    mat[i] = (float *)malloc(nombreColonnes * sizeof(float));
  }
  for (int y = 0; y < nombreLignes; y++) {
    for (int x = 0; x < nombreColonnes; x++) {
      usleep(5);
      mat[y][x] = (x * (nombreColonnes - x - 1)) * (y * (nombreLignes - y - 1));
    }
  }
  matkmoins1 = mat;
  printf("Impression de la plaque initiale (mat) :\n");
  for (int i = nombreLignes - 1; i >= 0; i--) {
    for (int j = 0; j < nombreColonnes; j++) {
      printf("%.1f  ", mat[i][j]);
    }
    printf("\n");
  }
  float part1formula, part2formula, part3formula;
  for (int k = 1; k <= nombrePasTemps; k++) {
    for (int y = 0; y < nombreLignes; y++) {
      for (int x = 0; x < nombreColonnes; x++) {
        usleep(5);
        part1formula =
            (1 - (4 * (tempsDiscretise / (pow(tailleSubdivision, 2))))) *
            matkmoins1[y][x];
        part2formula = (tempsDiscretise / (pow(tailleSubdivision, 2)));
        part3formula = 0;
        printf("x : %d, y : %d\n", x, y);
        if (y != 0) {
          printf("CRASH1.1 ?\n");
          part3formula = part3formula + matkmoins1[y - 1][x];
        }
        printf("CRASH1 ?\n");
        if (y != nombreLignes - 1) {
          part3formula += matkmoins1[y + 1][x];
        }
        printf("CRASH2 ?\n");
        if (x != 0) {
          part3formula += matkmoins1[y][x - 1];
        }
        printf("CRASH3 ?\n");
        if (x != nombreColonnes - 1) {
          part3formula += matkmoins1[y][x + 1];
        }
        printf("CRASH4 ?\n");
        mat[y][x] = part1formula + (part2formula * part3formula);
      }
    }
    matkmoins1 = mat;
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
cmpl   $0x7,-0x8(%rbp)
je     118d <main+0x3d>
lea    0xe86(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x4(%rbp)
jmp    1595 <main+0x445>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rdi
call   1060 <atoi@plt>
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rdi
call   1060 <atoi@plt>
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rdi
call   1060 <atoi@plt>
mov    %eax,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
mov    0x20(%rax),%rdi
call   1060 <atoi@plt>
mov    %eax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
mov    0x28(%rax),%rdi
call   1060 <atoi@plt>
mov    %eax,-0x24(%rbp)
mov    -0x10(%rbp),%rax
mov    0x30(%rax),%rdi
call   1060 <atoi@plt>
mov    %eax,-0x28(%rbp)
movslq -0x14(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    123f <main+0xef>
movslq -0x18(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,%rdx
mov    -0x40(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1207 <main+0xb7>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    12ca <main+0x17a>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    12b7 <main+0x167>
mov    $0x5,%edi
call   1070 <usleep@plt>
mov    -0x54(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    -0x54(%rbp),%ecx
sub    $0x1,%ecx
imul   %ecx,%eax
mov    -0x50(%rbp),%ecx
mov    -0x14(%rbp),%edx
sub    -0x50(%rbp),%edx
sub    $0x1,%edx
imul   %edx,%ecx
imul   %ecx,%eax
cvtsi2ss %eax,%xmm0
mov    -0x40(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x54(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1259 <main+0x109>
jmp    12bc <main+0x16c>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1246 <main+0xf6>
mov    -0x40(%rbp),%rax
mov    %rax,-0x48(%rbp)
lea    0xe30(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x58(%rbp)
cmpl   $0x0,-0x58(%rbp)
jl     1357 <main+0x207>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    133b <main+0x1eb>
mov    -0x40(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x5c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xe0d(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    12fa <main+0x1aa>
lea    0xdc5(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x58(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x58(%rbp)
jmp    12e9 <main+0x199>
movl   $0x1,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     158e <main+0x43e>
movl   $0x0,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1578 <main+0x428>
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1565 <main+0x415>
mov    $0x5,%edi
call   1070 <usleep@plt>
mov    -0x20(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x24(%rbp),%edi
mov    $0x2,%esi
call   1050 <pow@plt>
mov    %eax,%ecx
mov    -0x7c(%rbp),%eax
cltd
idiv   %ecx
mov    %eax,%ecx
shl    $0x2,%ecx
mov    $0x1,%eax
sub    %ecx,%eax
cvtsi2ss %eax,%xmm0
mov    -0x48(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x74(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x20(%rbp),%eax
mov    %eax,-0x78(%rbp)
mov    -0x24(%rbp),%edi
mov    $0x2,%esi
call   1050 <pow@plt>
mov    %eax,%ecx
mov    -0x78(%rbp),%eax
cltd
idiv   %ecx
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x64(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x74(%rbp),%esi
mov    -0x70(%rbp),%edx
lea    0xd22(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
cmpl   $0x0,-0x70(%rbp)
je     145b <main+0x30b>
lea    0xd1a(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movss  -0x68(%rbp),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x70(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x74(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x68(%rbp)
lea    0xcf4(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x70(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
je     149e <main+0x34e>
mov    -0x48(%rbp),%rax
mov    -0x70(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x74(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x68(%rbp),%xmm0
movss  %xmm0,-0x68(%rbp)
lea    0xcbb(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
cmpl   $0x0,-0x74(%rbp)
je     14da <main+0x38a>
mov    -0x48(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x74(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x68(%rbp),%xmm0
movss  %xmm0,-0x68(%rbp)
lea    0xc89(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x74(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
je     151d <main+0x3cd>
mov    -0x48(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x74(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x68(%rbp),%xmm0
movss  %xmm0,-0x68(%rbp)
lea    0xc50(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movss  -0x60(%rbp),%xmm1
movss  -0x64(%rbp),%xmm0
movss  -0x68(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x40(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x74(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    1384 <main+0x234>
jmp    156a <main+0x41a>
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    1371 <main+0x221>
mov    -0x40(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    135e <main+0x20e>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
cmp    $0x7,%edi
jne    12ba <main+0x14a>
mov    %rsi,%rbx
mov    0x8(%rsi),%rdi
call   1080 <atoi@plt>
mov    %eax,%ebp
mov    0x10(%rbx),%rdi
call   1080 <atoi@plt>
mov    %eax,%r15d
mov    0x18(%rbx),%rdi
call   1080 <atoi@plt>
mov    %eax,0x24(%rsp)
mov    0x20(%rbx),%rdi
call   1080 <atoi@plt>
mov    %eax,0x2c(%rsp)
mov    0x28(%rbx),%rdi
mov    %rbp,%rbx
mov    %rbp,0x30(%rsp)
call   1080 <atoi@plt>
mov    %eax,0x28(%rsp)
lea    0x0(,%rbp,8),%edi
call   1060 <malloc@plt>
mov    %rax,%rbp
mov    %ebx,%eax
mov    %rax,0x18(%rsp)
mov    %r15d,%eax
mov    %rax,0x48(%rsp)
test   %ebx,%ebx
mov    %r15,0x38(%rsp)
jle    12d0 <main+0x160>
lea    0x0(,%r15,4),%r14d
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r14d,%edi
call   1060 <malloc@plt>
mov    %rax,0x0(%rbp,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,0x18(%rsp)
jne    1210 <main+0xa0>
mov    0x30(%rsp),%rax
test   %eax,%eax
jle    12d0 <main+0x160>
lea    -0x2(%rax),%ecx
lea    -0x1(%r15),%eax
mov    %eax,0x40(%rsp)
xor    %eax,%eax
xor    %r13d,%r13d
mov    0x48(%rsp),%rbx
jmp    1264 <main+0xf4>
nopl   0x0(%rax)
add    $0x1,%r13
mov    0x14(%rsp),%ecx
add    %ecx,%eax
add    $0xfffffffe,%ecx
cmp    0x18(%rsp),%r13
je     12de <main+0x16e>
mov    %ecx,0x14(%rsp)
cmpl   $0x0,0x38(%rsp)
jle    1250 <main+0xe0>
xor    %r14d,%r14d
mov    0x40(%rsp),%r12d
xor    %r15d,%r15d
mov    %rax,0x8(%rsp)
nop
mov    $0x5,%edi
call   1090 <usleep@plt>
mov    %r14d,%eax
imul   %r12d,%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
mov    0x0(%rbp,%r13,8),%rax
movss  %xmm0,(%rax,%r15,4)
mov    0x8(%rsp),%rax
add    $0x1,%r15
add    %eax,%r14d
add    $0xffffffff,%r12d
cmp    %r15,%rbx
jne    1280 <main+0x110>
jmp    1250 <main+0xe0>
lea    0xdb2(%rip),%rdi
call   1040 <puts@plt>
mov    $0x1,%eax
jmp    16f6 <main+0x586>
lea    0xd44(%rip),%rdi
call   1040 <puts@plt>
jmp    1353 <main+0x1e3>
lea    0xd36(%rip),%rdi
call   1040 <puts@plt>
cmpl   $0x0,0x30(%rsp)
jle    1353 <main+0x1e3>
lea    0xd0c(%rip),%r14
mov    0x18(%rsp),%r15
mov    0x48(%rsp),%r13
jmp    1323 <main+0x1b3>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    $0xa,%edi
call   1030 <putchar@plt>
cmp    $0x1,%r15
mov    %r12,%r15
jle    1353 <main+0x1e3>
lea    -0x1(%r15),%r12
cmpl   $0x0,0x38(%rsp)
jle    1310 <main+0x1a0>
xor    %ebx,%ebx
mov    0x0(%rbp,%r12,8),%rax
movss  (%rax,%rbx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
add    $0x1,%rbx
cmp    %rbx,%r13
jne    1330 <main+0x1c0>
jmp    1310 <main+0x1a0>
cmpl   $0x0,0x24(%rsp)
jle    16f4 <main+0x584>
mov    0x30(%rsp),%rax
add    $0xffffffff,%eax
mov    %rax,0x40(%rsp)
mov    0x38(%rsp),%r15
lea    -0x1(%r15),%eax
mov    %rax,0x50(%rsp)
mov    $0x1,%eax
mov    0x18(%rsp),%rcx
jmp    13a2 <main+0x232>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x58(%rsp),%rdx
lea    0x1(%rdx),%eax
cmp    0x24(%rsp),%edx
je     16f4 <main+0x584>
mov    %rax,0x58(%rsp)
cmpl   $0x0,0x30(%rsp)
jle    1390 <main+0x220>
xor    %r12d,%r12d
jmp    13cf <main+0x25f>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r12
mov    %r12,%rbx
mov    %rbx,%r12
cmp    %rcx,%rbx
je     1390 <main+0x220>
test   %r15d,%r15d
jle    13c0 <main+0x250>
mov    $0x5,%edi
call   1090 <usleep@plt>
mov    0x28(%rsp),%r14d
mov    %r14d,%edi
mov    $0x2,%esi
call   1070 <pow@plt>
mov    %eax,%ecx
mov    0x2c(%rsp),%ebx
mov    %ebx,%eax
cltd
idiv   %ecx
shl    $0x2,%eax
mov    $0x1,%ecx
sub    %eax,%ecx
xorps  %xmm0,%xmm0
cvtsi2ss %ecx,%xmm0
mov    0x0(%rbp,%r12,8),%rax
mulss  (%rax),%xmm0
movss  %xmm0,0x14(%rsp)
mov    %r14d,%edi
mov    $0x2,%esi
call   1070 <pow@plt>
mov    %eax,%ecx
mov    %ebx,%eax
cltd
idiv   %ecx
mov    %eax,%r14d
lea    0xbd2(%rip),%rdi
xor    %esi,%esi
mov    %r12d,%edx
xor    %eax,%eax
call   1050 <printf@plt>
test   %r12,%r12
je     1470 <main+0x300>
lea    0xc17(%rip),%rdi
call   1040 <puts@plt>
mov    -0x8(%rbp,%r12,8),%rax
movss  (%rax),%xmm0
addss  0xb99(%rip),%xmm0
jmp    1473 <main+0x303>
nopl   0x0(%rax)
xorps  %xmm0,%xmm0
movss  %xmm0,0x8(%rsp)
lea    0xbc4(%rip),%rdi
call   1040 <puts@plt>
cmp    0x40(%rsp),%r12
je     14a1 <main+0x331>
mov    0x8(%rbp,%r12,8),%rax
movss  0x8(%rsp),%xmm0
addss  (%rax),%xmm0
movss  %xmm0,0x8(%rsp)
lea    0xba5(%rip),%rdi
call   1040 <puts@plt>
lea    0xba2(%rip),%rdi
call   1040 <puts@plt>
cmpq   $0x0,0x50(%rsp)
je     14e0 <main+0x370>
mov    0x0(%rbp,%r12,8),%rax
movss  0x8(%rsp),%xmm1
addss  0x4(%rax),%xmm1
movss  0x14(%rsp),%xmm0
jmp    14ec <main+0x37c>
nopl   0x0(%rax)
movss  0x14(%rsp),%xmm0
movss  0x8(%rsp),%xmm1
xorps  %xmm2,%xmm2
cvtsi2ss %r14d,%xmm2
lea    0x1(%r12),%rbx
mulss  %xmm1,%xmm2
addss  %xmm0,%xmm2
movss  %xmm2,0x8(%rsp)
lea    0xb51(%rip),%rdi
call   1040 <puts@plt>
mov    0x0(%rbp,%r12,8),%rax
movss  0x8(%rsp),%xmm0
movss  %xmm0,(%rax)
cmp    $0x1,%r15d
jne    1540 <main+0x3d0>
mov    0x18(%rsp),%rcx
jmp    13c7 <main+0x257>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rbx,0x60(%rsp)
mov    $0x1,%r15d
jmp    15aa <main+0x43a>
nopl   (%rax)
mov    0x0(%rbp,%r12,8),%rax
lea    0x1(%r15),%r13
movss  0x8(%rsp),%xmm1
addss  0x4(%rax,%r15,4),%xmm1
movss  0x14(%rsp),%xmm0
cvtsi2ss %r14d,%xmm2
mulss  %xmm1,%xmm2
addss  %xmm0,%xmm2
movss  %xmm2,0x8(%rsp)
lea    0xad9(%rip),%rdi
call   1040 <puts@plt>
mov    0x0(%rbp,%r12,8),%rax
movss  0x8(%rsp),%xmm0
movss  %xmm0,(%rax,%r15,4)
mov    %r13,%r15
cmp    0x48(%rsp),%r13
je     16e0 <main+0x570>
mov    $0x5,%edi
call   1090 <usleep@plt>
mov    %rbp,%r13
mov    0x28(%rsp),%ebp
mov    %ebp,%edi
mov    $0x2,%esi
call   1070 <pow@plt>
mov    %eax,%ecx
mov    0x2c(%rsp),%ebx
mov    %ebx,%eax
cltd
idiv   %ecx
shl    $0x2,%eax
mov    $0x1,%ecx
sub    %eax,%ecx
xorps  %xmm0,%xmm0
cvtsi2ss %ecx,%xmm0
mov    0x0(%r13,%r12,8),%rax
mulss  (%rax,%r15,4),%xmm0
movss  %xmm0,0x14(%rsp)
mov    %ebp,%edi
mov    $0x2,%esi
call   1070 <pow@plt>
mov    %eax,%ecx
mov    %ebx,%eax
cltd
idiv   %ecx
mov    %eax,%r14d
lea    0x9fa(%rip),%rdi
mov    %r15d,%esi
mov    %r12d,%edx
xor    %eax,%eax
call   1050 <printf@plt>
test   %r12,%r12
je     1650 <main+0x4e0>
lea    0xa3e(%rip),%rdi
call   1040 <puts@plt>
mov    -0x8(%r13,%r12,8),%rax
movss  (%rax,%r15,4),%xmm0
addss  0x9be(%rip),%xmm0
jmp    1653 <main+0x4e3>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
xorps  %xmm0,%xmm0
movss  %xmm0,0x8(%rsp)
mov    %r13,%rbp
lea    0x9e1(%rip),%rdi
call   1040 <puts@plt>
cmp    0x40(%rsp),%r12
je     1686 <main+0x516>
mov    0x8(%rbp,%r12,8),%rax
movss  0x8(%rsp),%xmm0
addss  (%rax,%r15,4),%xmm0
movss  %xmm0,0x8(%rsp)
lea    0x9c0(%rip),%rdi
call   1040 <puts@plt>
mov    0x0(%rbp,%r12,8),%rax
movss  0x8(%rsp),%xmm0
addss  -0x4(%rax,%r15,4),%xmm0
movss  %xmm0,0x8(%rsp)
lea    0x9a5(%rip),%rdi
call   1040 <puts@plt>
cmp    0x50(%rsp),%r15
jne    1550 <main+0x3e0>
lea    0x1(%r15),%r13
movss  0x14(%rsp),%xmm0
movss  0x8(%rsp),%xmm1
jmp    156c <main+0x3fc>
cs nopw 0x0(%rax,%rax,1)
mov    0x38(%rsp),%r15
mov    0x18(%rsp),%rcx
mov    0x60(%rsp),%rbx
jmp    13c7 <main+0x257>
xor    %eax,%eax
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
%struct.timeval = type { i32 }
@.str = [265 x i8] c"Veuillez entrer le nombre d'arguments comme suivant: Nombre de lignes de la matrice, Nombre de colonnes de la matrice, le nombre de pas de temps, le temps discr\C3\A9tis\C3\A9, la taille d'un c\C3\B4t\C3\A9 d'une subdivision, le nombre de processus \C3\A0 utiliser.\0A\00"
@.str.1 = [42 x i8] c"Impression de la plaque initiale (mat) :\0A\00"
@.str.2 = [7 x i8] c"%.1f \00"
@.str.3 = [2 x i8] c"\0A\00"
@.str.4 = [16 x i8] c"x : %d, y : %d\0A\00"
@.str.5 = [12 x i8] c"CRASH1.1 ?\0A\00"
@.str.6 = [10 x i8] c"CRASH1 ?\0A\00"
@.str.7 = [10 x i8] c"CRASH2 ?\0A\00"
@.str.8 = [10 x i8] c"CRASH3 ?\0A\00"
@.str.9 = [10 x i8] c"CRASH4 ?\0A\00"
define i32 @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8**
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca %struct.timeval
%14 = alloca %struct.timeval
%15 = alloca float**
%16 = alloca float**
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca float
%23 = alloca float
%24 = alloca float
%25 = alloca i32
%26 = alloca i32
%27 = alloca i32
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
%28 = load i32, i32* %4
%29 = icmp ne i32 %28, 7
br i1 %29, label %30, label %32
30: ; preds = %2
%31 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([265 x i8], [265 x i8]* @.str, i64 0, i64 0))
store i32 1, i32* %3
br label %295
32: ; preds = %2
%33 = load i8**, i8*** %5
%34 = getelementptr inbounds i8*, i8** %33, i64 1
%35 = load i8*, i8** %34
%36 = call i32 @atoi(i8* %35)
store i32 %36, i32* %6
%37 = load i8**, i8*** %5
%38 = getelementptr inbounds i8*, i8** %37, i64 2
%39 = load i8*, i8** %38
%40 = call i32 @atoi(i8* %39)
store i32 %40, i32* %7
%41 = load i8**, i8*** %5
%42 = getelementptr inbounds i8*, i8** %41, i64 3
%43 = load i8*, i8** %42
%44 = call i32 @atoi(i8* %43)
store i32 %44, i32* %8
%45 = load i8**, i8*** %5
%46 = getelementptr inbounds i8*, i8** %45, i64 4
%47 = load i8*, i8** %46
%48 = call i32 @atoi(i8* %47)
store i32 %48, i32* %9
%49 = load i8**, i8*** %5
%50 = getelementptr inbounds i8*, i8** %49, i64 5
%51 = load i8*, i8** %50
%52 = call i32 @atoi(i8* %51)
store i32 %52, i32* %10
%53 = load i8**, i8*** %5
%54 = getelementptr inbounds i8*, i8** %53, i64 6
%55 = load i8*, i8** %54
%56 = call i32 @atoi(i8* %55)
store i32 %56, i32* %11
%57 = load i32, i32* %6
%58 = sext i32 %57 to i64
%59 = mul i64 %58, 8
%60 = trunc i64 %59 to i32
%61 = call i64 @malloc(i32 %60)
%62 = inttoptr i64 %61 to float**
store float** %62, float*** %15
store i32 0, i32* %17
br label %63
63: ; preds = %78, %32
%64 = load i32, i32* %17
%65 = load i32, i32* %6
%66 = icmp slt i32 %64, %65
br i1 %66, label %67, label %81
67: ; preds = %63
%68 = load i32, i32* %7
%69 = sext i32 %68 to i64
%70 = mul i64 %69, 4
%71 = trunc i64 %70 to i32
%72 = call i64 @malloc(i32 %71)
%73 = inttoptr i64 %72 to float*
%74 = load float**, float*** %15
%75 = load i32, i32* %17
%76 = sext i32 %75 to i64
%77 = getelementptr inbounds float*, float** %74, i64 %76
store float* %73, float** %77
br label %78
78: ; preds = %67
%79 = load i32, i32* %17
%80 = add nsw i32 %79, 1
store i32 %80, i32* %17
br label %63
81: ; preds = %63
store i32 0, i32* %18
br label %82
82: ; preds = %119, %81
%83 = load i32, i32* %18
%84 = load i32, i32* %6
%85 = icmp slt i32 %83, %84
br i1 %85, label %86, label %122
86: ; preds = %82
store i32 0, i32* %19
br label %87
87: ; preds = %115, %86
%88 = load i32, i32* %19
%89 = load i32, i32* %7
%90 = icmp slt i32 %88, %89
br i1 %90, label %91, label %118
91: ; preds = %87
%92 = call i32 @usleep(i32 5)
%93 = load i32, i32* %19
%94 = load i32, i32* %7
%95 = load i32, i32* %19
%96 = sub nsw i32 %94, %95
%97 = sub nsw i32 %96, 1
%98 = mul nsw i32 %93, %97
%99 = load i32, i32* %18
%100 = load i32, i32* %6
%101 = load i32, i32* %18
%102 = sub nsw i32 %100, %101
%103 = sub nsw i32 %102, 1
%104 = mul nsw i32 %99, %103
%105 = mul nsw i32 %98, %104
%106 = sitofp i32 %105 to float
%107 = load float**, float*** %15
%108 = load i32, i32* %18
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds float*, float** %107, i64 %109
%111 = load float*, float** %110
%112 = load i32, i32* %19
%113 = sext i32 %112 to i64
%114 = getelementptr inbounds float, float* %111, i64 %113
store float %106, float* %114
br label %115
115: ; preds = %91
%116 = load i32, i32* %19
%117 = add nsw i32 %116, 1
store i32 %117, i32* %19
br label %87
118: ; preds = %87
br label %119
119: ; preds = %118
%120 = load i32, i32* %18
%121 = add nsw i32 %120, 1
store i32 %121, i32* %18
br label %82
122: ; preds = %82
%123 = load float**, float*** %15
store float** %123, float*** %16
%124 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([42 x i8], [42 x i8]* @.str.1, i64 0, i64 0))
%125 = load i32, i32* %6
%126 = sub nsw i32 %125, 1
store i32 %126, i32* %20
br label %127
127: ; preds = %152, %122
%128 = load i32, i32* %20
%129 = icmp sge i32 %128, 0
br i1 %129, label %130, label %155
130: ; preds = %127
store i32 0, i32* %21
br label %131
131: ; preds = %147, %130
%132 = load i32, i32* %21
%133 = load i32, i32* %7
%134 = icmp slt i32 %132, %133
br i1 %134, label %135, label %150
135: ; preds = %131
%136 = load float**, float*** %15
%137 = load i32, i32* %20
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds float*, float** %136, i64 %138
%140 = load float*, float** %139
%141 = load i32, i32* %21
%142 = sext i32 %141 to i64
%143 = getelementptr inbounds float, float* %140, i64 %142
%144 = load float, float* %143
%145 = fpext float %144 to double
%146 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.2, i64 0, i64 0), double %145)
br label %147
147: ; preds = %135
%148 = load i32, i32* %21
%149 = add nsw i32 %148, 1
store i32 %149, i32* %21
br label %131
150: ; preds = %131
%151 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i64 0, i64 0))
br label %152
152: ; preds = %150
%153 = load i32, i32* %20
%154 = add nsw i32 %153, -1
store i32 %154, i32* %20
br label %127
155: ; preds = %127
store i32 1, i32* %25
br label %156
156: ; preds = %291, %155
%157 = load i32, i32* %25
%158 = load i32, i32* %8
%159 = icmp sle i32 %157, %158
br i1 %159, label %160, label %294
160: ; preds = %156
store i32 0, i32* %26
br label %161
161: ; preds = %286, %160
%162 = load i32, i32* %26
%163 = load i32, i32* %6
%164 = icmp slt i32 %162, %163
br i1 %164, label %165, label %289
165: ; preds = %161
store i32 0, i32* %27
br label %166
166: ; preds = %282, %165
%167 = load i32, i32* %27
%168 = load i32, i32* %7
%169 = icmp slt i32 %167, %168
br i1 %169, label %170, label %285
170: ; preds = %166
%171 = call i32 @usleep(i32 5)
%172 = load i32, i32* %9
%173 = load i32, i32* %10
%174 = call i32 @pow(i32 %173, i32 2)
%175 = sdiv i32 %172, %174
%176 = mul nsw i32 4, %175
%177 = sub nsw i32 1, %176
%178 = sitofp i32 %177 to float
%179 = load float**, float*** %16
%180 = load i32, i32* %26
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds float*, float** %179, i64 %181
%183 = load float*, float** %182
%184 = load i32, i32* %27
%185 = sext i32 %184 to i64
%186 = getelementptr inbounds float, float* %183, i64 %185
%187 = load float, float* %186
%188 = fmul float %178, %187
store float %188, float* %22
%189 = load i32, i32* %9
%190 = load i32, i32* %10
%191 = call i32 @pow(i32 %190, i32 2)
%192 = sdiv i32 %189, %191
%193 = sitofp i32 %192 to float
store float %193, float* %23
store float 0.000000e+00, float* %24
%194 = load i32, i32* %27
%195 = load i32, i32* %26
%196 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.4, i64 0, i64 0), i32 %194, i32 %195)
%197 = load i32, i32* %26
%198 = icmp ne i32 %197, 0
br i1 %198, label %199, label %213
199: ; preds = %170
%200 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.5, i64 0, i64 0))
%201 = load float, float* %24
%202 = load float**, float*** %16
%203 = load i32, i32* %26
%204 = sub nsw i32 %203, 1
%205 = sext i32 %204 to i64
%206 = getelementptr inbounds float*, float** %202, i64 %205
%207 = load float*, float** %206
%208 = load i32, i32* %27
%209 = sext i32 %208 to i64
%210 = getelementptr inbounds float, float* %207, i64 %209
%211 = load float, float* %210
%212 = fadd float %201, %211
store float %212, float* %24
br label %213
213: ; preds = %199, %170
%214 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.6, i64 0, i64 0))
%215 = load i32, i32* %26
%216 = load i32, i32* %6
%217 = sub nsw i32 %216, 1
%218 = icmp ne i32 %215, %217
br i1 %218, label %219, label %232
219: ; preds = %213
%220 = load float**, float*** %16
%221 = load i32, i32* %26
%222 = add nsw i32 %221, 1
%223 = sext i32 %222 to i64
%224 = getelementptr inbounds float*, float** %220, i64 %223
%225 = load float*, float** %224
%226 = load i32, i32* %27
%227 = sext i32 %226 to i64
%228 = getelementptr inbounds float, float* %225, i64 %227
%229 = load float, float* %228
%230 = load float, float* %24
%231 = fadd float %230, %229
store float %231, float* %24
br label %232
232: ; preds = %219, %213
%233 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.7, i64 0, i64 0))
%234 = load i32, i32* %27
%235 = icmp ne i32 %234, 0
br i1 %235, label %236, label %249
236: ; preds = %232
%237 = load float**, float*** %16
%238 = load i32, i32* %26
%239 = sext i32 %238 to i64
%240 = getelementptr inbounds float*, float** %237, i64 %239
%241 = load float*, float** %240
%242 = load i32, i32* %27
%243 = sub nsw i32 %242, 1
%244 = sext i32 %243 to i64
%245 = getelementptr inbounds float, float* %241, i64 %244
%246 = load float, float* %245
%247 = load float, float* %24
%248 = fadd float %247, %246
store float %248, float* %24
br label %249
249: ; preds = %236, %232
%250 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.8, i64 0, i64 0))
%251 = load i32, i32* %27
%252 = load i32, i32* %7
%253 = sub nsw i32 %252, 1
%254 = icmp ne i32 %251, %253
br i1 %254, label %255, label %268
255: ; preds = %249
%256 = load float**, float*** %16
%257 = load i32, i32* %26
%258 = sext i32 %257 to i64
%259 = getelementptr inbounds float*, float** %256, i64 %258
%260 = load float*, float** %259
%261 = load i32, i32* %27
%262 = add nsw i32 %261, 1
%263 = sext i32 %262 to i64
%264 = getelementptr inbounds float, float* %260, i64 %263
%265 = load float, float* %264
%266 = load float, float* %24
%267 = fadd float %266, %265
store float %267, float* %24
br label %268
268: ; preds = %255, %249
%269 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.9, i64 0, i64 0))
%270 = load float, float* %22
%271 = load float, float* %23
%272 = load float, float* %24
%273 = call float @llvm.fmuladd.f32(float %271, float %272, float %270)
%274 = load float**, float*** %15
%275 = load i32, i32* %26
%276 = sext i32 %275 to i64
%277 = getelementptr inbounds float*, float** %274, i64 %276
%278 = load float*, float** %277
%279 = load i32, i32* %27
%280 = sext i32 %279 to i64
%281 = getelementptr inbounds float, float* %278, i64 %280
store float %273, float* %281
br label %282
282: ; preds = %268
%283 = load i32, i32* %27
%284 = add nsw i32 %283, 1
store i32 %284, i32* %27
br label %166
285: ; preds = %166
br label %286
286: ; preds = %285
%287 = load i32, i32* %26
%288 = add nsw i32 %287, 1
store i32 %288, i32* %26
br label %161
289: ; preds = %161
%290 = load float**, float*** %15
store float** %290, float*** %16
br label %291
291: ; preds = %289
%292 = load i32, i32* %25
%293 = add nsw i32 %292, 1
store i32 %293, i32* %25
br label %156
294: ; preds = %156
store i32 0, i32* %3
br label %295
295: ; preds = %294, %30
%296 = load i32, i32* %3
ret i32 %296
}

LLVM IR (-O2):
@.str.2 = [7 x i8] c"%.1f \00"
@.str.4 = [16 x i8] c"x : %d, y : %d\0A\00"
@str = [41 x i8] c"Impression de la plaque initiale (mat) :\00"
@str.10 = [9 x i8] c"CRASH1 ?\00"
@str.11 = [9 x i8] c"CRASH2 ?\00"
@str.12 = [9 x i8] c"CRASH3 ?\00"
@str.13 = [9 x i8] c"CRASH4 ?\00"
@str.14 = [11 x i8] c"CRASH1.1 ?\00"
@str.15 = [264 x i8] c"Veuillez entrer le nombre d'arguments comme suivant: Nombre de lignes de la matrice, Nombre de colonnes de la matrice, le nombre de pas de temps, le temps discr\C3\A9tis\C3\A9, la taille d'un c\C3\B4t\C3\A9 d'une subdivision, le nombre de processus \C3\A0 utiliser.\00"
define i32 @main(i32 %0, i8** nocapture %1) {
%3 = icmp eq i32 %0, 7
br i1 %3, label %6, label %4
4: ; preds = %2
%5 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([264 x i8], [264 x i8]* @str.15, i64 0, i64 0))
br label %219
6: ; preds = %2
%7 = getelementptr inbounds i8*, i8** %1, i64 1
%8 = load i8*, i8** %7
%9 = tail call i32 @atoi(i8* %8)
%10 = getelementptr inbounds i8*, i8** %1, i64 2
%11 = load i8*, i8** %10
%12 = tail call i32 @atoi(i8* %11)
%13 = getelementptr inbounds i8*, i8** %1, i64 3
%14 = load i8*, i8** %13
%15 = tail call i32 @atoi(i8* %14)
%16 = getelementptr inbounds i8*, i8** %1, i64 4
%17 = load i8*, i8** %16
%18 = tail call i32 @atoi(i8* %17)
%19 = getelementptr inbounds i8*, i8** %1, i64 5
%20 = load i8*, i8** %19
%21 = tail call i32 @atoi(i8* %20)
%22 = shl i32 %9, 3
%23 = tail call i64 @malloc(i32 %22)
%24 = inttoptr i64 %23 to float**
%25 = icmp sgt i32 %9, 0
br i1 %25, label %26, label %49
26: ; preds = %6
%27 = shl i32 %12, 2
%28 = zext i32 %9 to i64
br label %34
29: ; preds = %34
br i1 %25, label %30, label %49
30: ; preds = %29
%31 = icmp sgt i32 %12, 0
%32 = zext i32 %9 to i64
%33 = zext i32 %12 to i64
br label %41
34: ; preds = %26, %34
%35 = phi i64 [ 0, %26 ], [ %39, %34 ]
%36 = tail call i64 @malloc(i32 %27)
%37 = inttoptr i64 %36 to float*
%38 = getelementptr inbounds float*, float** %24, i64 %35
store float* %37, float** %38
%39 = add nuw nsw i64 %35, 1
%40 = icmp eq i64 %39, %28
br i1 %40, label %29, label %34
41: ; preds = %30, %57
%42 = phi i64 [ 0, %30 ], [ %58, %57 ]
%43 = trunc i64 %42 to i32
br i1 %31, label %44, label %57
44: ; preds = %41
%45 = xor i32 %43, -1
%46 = add i32 %9, %45
%47 = mul i32 %46, %43
%48 = getelementptr inbounds float*, float** %24, i64 %42
br label %60
49: ; preds = %29, %6
%50 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([41 x i8], [41 x i8]* @str, i64 0, i64 0))
br label %78
51: ; preds = %57
%52 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([41 x i8], [41 x i8]* @str, i64 0, i64 0))
br i1 %25, label %53, label %78
53: ; preds = %51
%54 = icmp sgt i32 %12, 0
%55 = zext i32 %9 to i64
%56 = zext i32 %12 to i64
br label %73
57: ; preds = %60, %41
%58 = add nuw nsw i64 %42, 1
%59 = icmp eq i64 %58, %32
br i1 %59, label %51, label %41
60: ; preds = %44, %60
%61 = phi i64 [ 0, %44 ], [ %71, %60 ]
%62 = trunc i64 %61 to i32
%63 = tail call i32 @usleep(i32 5)
%64 = xor i32 %62, -1
%65 = add i32 %12, %64
%66 = mul i32 %47, %62
%67 = mul i32 %66, %65
%68 = sitofp i32 %67 to float
%69 = load float*, float** %48
%70 = getelementptr inbounds float, float* %69, i64 %61
store float %68, float* %70
%71 = add nuw nsw i64 %61, 1
%72 = icmp eq i64 %71, %33
br i1 %72, label %57, label %60
73: ; preds = %53, %90
%74 = phi i64 [ %55, %53 ], [ %75, %90 ]
%75 = add nsw i64 %74, -1
br i1 %54, label %76, label %90
76: ; preds = %73
%77 = getelementptr inbounds float*, float** %24, i64 %75
br label %93
78: ; preds = %90, %49, %51
%79 = icmp slt i32 %15, 1
br i1 %79, label %219, label %80
80: ; preds = %78
%81 = add nsw i32 %9, -1
%82 = icmp sgt i32 %12, 0
%83 = add nsw i32 %12, -1
%84 = zext i32 %83 to i64
%85 = zext i32 %81 to i64
%86 = zext i32 %9 to i64
%87 = zext i32 %12 to i64
%88 = icmp eq i32 %83, 0
%89 = icmp eq i32 %12, 1
br label %102
90: ; preds = %93, %73
%91 = tail call i32 @putchar(i32 10)
%92 = icmp sgt i64 %74, 1
br i1 %92, label %73, label %78
93: ; preds = %76, %93
%94 = phi i64 [ 0, %76 ], [ %100, %93 ]
%95 = load float*, float** %77
%96 = getelementptr inbounds float, float* %95, i64 %94
%97 = load float, float* %96
%98 = fpext float %97 to double
%99 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.2, i64 0, i64 0), double %98)
%100 = add nuw nsw i64 %94, 1
%101 = icmp eq i64 %100, %56
br i1 %101, label %90, label %93
102: ; preds = %80, %156
%103 = phi i32 [ 1, %80 ], [ %157, %156 ]
br i1 %25, label %104, label %156
104: ; preds = %102, %159
%105 = phi i64 [ %160, %159 ], [ 0, %102 ]
br i1 %82, label %108, label %106
106: ; preds = %104
%107 = add nuw nsw i64 %105, 1
br label %159
108: ; preds = %104
%109 = getelementptr inbounds float*, float** %24, i64 %105
%110 = icmp eq i64 %105, 0
%111 = add nsw i64 %105, -1
%112 = getelementptr inbounds float*, float** %24, i64 %111
%113 = icmp eq i64 %105, %85
%114 = add nuw nsw i64 %105, 1
%115 = getelementptr inbounds float*, float** %24, i64 %114
%116 = tail call i32 @usleep(i32 5)
%117 = tail call i32 @pow(i32 %21, i32 2)
%118 = sdiv i32 %18, %117
%119 = mul i32 %118, -4
%120 = or i32 %119, 1
%121 = sitofp i32 %120 to float
%122 = load float*, float** %109
%123 = load float, float* %122
%124 = fmul float %123, %121
%125 = tail call i32 @pow(i32 %21, i32 2)
%126 = sdiv i32 %18, %125
%127 = sitofp i32 %126 to float
%128 = trunc i64 %105 to i32
%129 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([16 x i8], [16 x i8]* @.str.4, i64 0, i64 0), i32 0, i32 %128)
br i1 %110, label %135, label %130
130: ; preds = %108
%131 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([11 x i8], [11 x i8]* @str.14, i64 0, i64 0))
%132 = load float*, float** %112
%133 = load float, float* %132
%134 = fadd float %133, 0.000000e+00
br label %135
135: ; preds = %130, %108
%136 = phi float [ %134, %130 ], [ 0.000000e+00, %108 ]
%137 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([9 x i8], [9 x i8]* @str.10, i64 0, i64 0))
br i1 %113, label %142, label %138
138: ; preds = %135
%139 = load float*, float** %115
%140 = load float, float* %139
%141 = fadd float %136, %140
br label %142
142: ; preds = %135, %138
%143 = phi float [ %141, %138 ], [ %136, %135 ]
%144 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([9 x i8], [9 x i8]* @str.11, i64 0, i64 0))
%145 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([9 x i8], [9 x i8]* @str.12, i64 0, i64 0))
br i1 %88, label %151, label %146
146: ; preds = %142
%147 = load float*, float** %109
%148 = getelementptr inbounds float, float* %147, i64 1
%149 = load float, float* %148
%150 = fadd float %143, %149
br label %151
151: ; preds = %146, %142
%152 = phi float [ %150, %146 ], [ %143, %142 ]
%153 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([9 x i8], [9 x i8]* @str.13, i64 0, i64 0))
%154 = tail call float @llvm.fmuladd.f32(float %127, float %152, float %124)
%155 = load float*, float** %109
store float %154, float* %155
br i1 %89, label %159, label %162
156: ; preds = %159, %102
%157 = add nuw i32 %103, 1
%158 = icmp eq i32 %103, %15
br i1 %158, label %219, label %102
159: ; preds = %211, %151, %106
%160 = phi i64 [ %107, %106 ], [ %114, %151 ], [ %114, %211 ]
%161 = icmp eq i64 %160, %86
br i1 %161, label %156, label %104
162: ; preds = %151, %211
%163 = phi i64 [ %212, %211 ], [ 1, %151 ]
%164 = tail call i32 @usleep(i32 5)
%165 = tail call i32 @pow(i32 %21, i32 2)
%166 = sdiv i32 %18, %165
%167 = mul i32 %166, -4
%168 = or i32 %167, 1
%169 = sitofp i32 %168 to float
%170 = load float*, float** %109
%171 = getelementptr inbounds float, float* %170, i64 %163
%172 = load float, float* %171
%173 = fmul float %172, %169
%174 = tail call i32 @pow(i32 %21, i32 2)
%175 = sdiv i32 %18, %174
%176 = sitofp i32 %175 to float
%177 = trunc i64 %163 to i32
%178 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([16 x i8], [16 x i8]* @.str.4, i64 0, i64 0), i32 %177, i32 %128)
br i1 %110, label %185, label %179
179: ; preds = %162
%180 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([11 x i8], [11 x i8]* @str.14, i64 0, i64 0))
%181 = load float*, float** %112
%182 = getelementptr inbounds float, float* %181, i64 %163
%183 = load float, float* %182
%184 = fadd float %183, 0.000000e+00
br label %185
185: ; preds = %179, %162
%186 = phi float [ %184, %179 ], [ 0.000000e+00, %162 ]
%187 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([9 x i8], [9 x i8]* @str.10, i64 0, i64 0))
br i1 %113, label %193, label %188
188: ; preds = %185
%189 = load float*, float** %115
%190 = getelementptr inbounds float, float* %189, i64 %163
%191 = load float, float* %190
%192 = fadd float %186, %191
br label %193
193: ; preds = %188, %185
%194 = phi float [ %192, %188 ], [ %186, %185 ]
%195 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([9 x i8], [9 x i8]* @str.11, i64 0, i64 0))
%196 = load float*, float** %109
%197 = add nsw i64 %163, -1
%198 = getelementptr inbounds float, float* %196, i64 %197
%199 = load float, float* %198
%200 = fadd float %194, %199
%201 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([9 x i8], [9 x i8]* @str.12, i64 0, i64 0))
%202 = icmp eq i64 %163, %84
br i1 %202, label %203, label %205
203: ; preds = %193
%204 = add nuw nsw i64 %163, 1
br label %211
205: ; preds = %193
%206 = load float*, float** %109
%207 = add nuw nsw i64 %163, 1
%208 = getelementptr inbounds float, float* %206, i64 %207
%209 = load float, float* %208
%210 = fadd float %200, %209
br label %211
211: ; preds = %203, %205
%212 = phi i64 [ %204, %203 ], [ %207, %205 ]
%213 = phi float [ %200, %203 ], [ %210, %205 ]
%214 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([9 x i8], [9 x i8]* @str.13, i64 0, i64 0))
%215 = tail call float @llvm.fmuladd.f32(float %176, float %213, float %173)
%216 = load float*, float** %109
%217 = getelementptr inbounds float, float* %216, i64 %163
store float %215, float* %217
%218 = icmp eq i64 %212, %87
br i1 %218, label %159, label %162
219: ; preds = %156, %78, %4
%220 = phi i32 [ 1, %4 ], [ 0, %78 ], [ 0, %156 ]
ret i32 %220
}