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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ printf(char *, ...);
int rand();
int /*<<< orphan*/ srand(int /*<<< orphan*/);
int /*<<< orphan*/ time(int /*<<< orphan*/ *);
int main(int argc) {
  char *file = "navi.txt";
  printf("Opening.. %s \n", file);
  int righe[10];
  int colonne[10];
  int caselle[10][10];
  caselle[1][2] = 10;
  int i, j, k;
  for (i = 0; i < 10; i++) {
    for (j = 0; j < 10; j++) {
      caselle[i][j] = 0;
    }
  }
  printf(" ");
  int lettere[14] = {2, 2, 2, 2, 2, 3, 4, 5, 6, 6, 7, 8, 10, 10};
  int numeri[14] = {5, 6, 7, 8, 9, 3, 3, 3, 3, 7, 7, 7, 7, 8};
  for (i = 0; i < 10; i++) {
    for (j = 0; j < 10; j++) {
      for (k = 0; k < 14; k++) {
        if (i == lettere[k] && j == numeri[k]) {
          caselle[i][j] = 1;
        }
      }
    }
  }
  for (i = 0; i < 10; i++) {
    for (j = 0; j < 10; j++) {
      printf("%d\t", caselle[i][j]);
    }
    printf("\n ");
  }
  srand(time(NULL));
  int col = rand() % 10;
  col++;
  int rig = rand() % 10;
  rig++;
  int t = 1;
  int cento[100];
  for (t = 0; t < 100; t++) {
    cento[t] = 0;
  }
  int cas1 = 1;
  int cas = 1;
  int conto = 0;
  int contatore;
  int ko;
  srand(time(NULL));
  for (t = 0; t < 100; t++) {
    while (cento[cas1] == 2) {
      cas = rand() % 100;
      cas1 = cas - 1;
      cas = cas + 10;
    }
    for (k = 0; k < 14; k++) {
      if ((cas / 10) == lettere[k] && (cas % 10) == numeri[k]) {
        printf("c'hai preso! %d %d \n", cas / 10, cas % 10);
        conto++;
        for (contatore = 1; contatore < 6; contatore++) {
          if (cento[cas1 + contatore] != 2) {
            int preso = 0;
            t++;
            cento[cas1 + contatore] = 2;
            for (ko = 0; ko < 14; ko++) {
              if (((cas + contatore) / 10) == lettere[ko] &&
                  ((cas + contatore) % 10) == numeri[ko]) {
                printf("c'hai ripreso! %d %d \n", (cas + contatore) / 10,
                       (cas + contatore) % 10);
                conto++;
                preso = 1;
              } else {
                if (ko == 13 && preso == 0) {
                  contatore = 6;
                }
              }
            }
          }
        }
        for (contatore = 1; contatore < 6; contatore++) {
          if (cento[cas1 - contatore] != 2) {
            int preso = 0;
            t++;
            cento[cas1 - contatore] = 2;
            for (ko = 0; ko < 14; ko++) {
              if (((cas - contatore) / 10) == lettere[ko] &&
                  ((cas - contatore) % 10) == numeri[ko]) {
                printf("c'hai ripreso! %d %d \n", (cas - contatore) / 10,
                       (cas - contatore) % 10);
                conto++;
                preso = 1;
              } else {
                if (ko == 13 && preso == 0) {
                  contatore = 6;
                }
              }
            }
          }
        }
        for (contatore = 10; contatore < 60; contatore = contatore + 10) {
          if (cento[cas1 + contatore] != 2) {
            int preso = 0;
            t++;
            cento[cas1 + contatore] = 2;
            for (ko = 0; ko < 14; ko++) {
              if (((cas + contatore) / 10) == lettere[ko] &&
                  ((cas + contatore) % 10) == numeri[ko]) {
                printf("c'hai ripreso! %d %d \n", (cas + contatore) / 10,
                       (cas + contatore) % 10);
                conto++;
                preso = 1;
              } else {
                if (ko == 13 && preso == 0) {
                  contatore = 60;
                }
              }
            }
          }
        }
        for (contatore = 10; contatore < 60; contatore = contatore + 10) {
          if (cento[cas1 - contatore] != 2) {
            int preso = 0;
            t++;
            cento[cas1 - contatore] = 2;
            for (ko = 0; ko < 14; ko++) {
              if (((cas - contatore) / 10) == lettere[ko] &&
                  ((cas - contatore) % 10) == numeri[ko]) {
                printf("c'hai ripreso! %d %d \n", (cas - contatore) / 10,
                       (cas - contatore) % 10);
                conto++;
                preso = 1;
              } else {
                if (ko == 13 && preso == 0) {
                  contatore = 60;
                }
              }
            }
          }
        }
        if (conto == 14) {
          printf("%d \n", t + 1);
        }
      }
    }
    cento[cas1] = 2;
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x460,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
lea    0xe94(%rip),%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rsi
lea    0xe8e(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0xa,-0x1d0(%rbp)
movl   $0x0,-0x204(%rbp)
cmpl   $0xa,-0x204(%rbp)
jge    120a <main+0xba>
movl   $0x0,-0x208(%rbp)
cmpl   $0xa,-0x208(%rbp)
jge    11f1 <main+0xa1>
movslq -0x204(%rbp),%rcx
lea    -0x200(%rbp),%rax
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x208(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x208(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x208(%rbp)
jmp    11ad <main+0x5d>
jmp    11f6 <main+0xa6>
mov    -0x204(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x204(%rbp)
jmp    1196 <main+0x46>
lea    0xe0c(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    -0x250(%rbp),%rdi
lea    0xe2a(%rip),%rsi
mov    $0x38,%edx
call   1050 <memcpy@plt>
lea    -0x290(%rbp),%rdi
lea    0xe52(%rip),%rsi
mov    $0x38,%edx
call   1050 <memcpy@plt>
movl   $0x0,-0x204(%rbp)
cmpl   $0xa,-0x204(%rbp)
jge    132f <main+0x1df>
movl   $0x0,-0x208(%rbp)
cmpl   $0xa,-0x208(%rbp)
jge    1316 <main+0x1c6>
movl   $0x0,-0x20c(%rbp)
cmpl   $0xe,-0x20c(%rbp)
jge    12fd <main+0x1ad>
mov    -0x204(%rbp),%eax
movslq -0x20c(%rbp),%rcx
cmp    -0x250(%rbp,%rcx,4),%eax
jne    12e4 <main+0x194>
mov    -0x208(%rbp),%eax
movslq -0x20c(%rbp),%rcx
cmp    -0x290(%rbp,%rcx,4),%eax
jne    12e4 <main+0x194>
movslq -0x204(%rbp),%rcx
lea    -0x200(%rbp),%rax
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x208(%rbp),%rcx
movl   $0x1,(%rax,%rcx,4)
jmp    12e9 <main+0x199>
mov    -0x20c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20c(%rbp)
jmp    1280 <main+0x130>
jmp    1302 <main+0x1b2>
mov    -0x208(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x208(%rbp)
jmp    1269 <main+0x119>
jmp    131b <main+0x1cb>
mov    -0x204(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x204(%rbp)
jmp    1252 <main+0x102>
movl   $0x0,-0x204(%rbp)
cmpl   $0xa,-0x204(%rbp)
jge    13c0 <main+0x270>
movl   $0x0,-0x208(%rbp)
cmpl   $0xa,-0x208(%rbp)
jge    139e <main+0x24e>
movslq -0x204(%rbp),%rcx
lea    -0x200(%rbp),%rax
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x208(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
lea    0xc95(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x208(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x208(%rbp)
jmp    1350 <main+0x200>
lea    0xc77(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x204(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x204(%rbp)
jmp    1339 <main+0x1e9>
xor    %eax,%eax
mov    %eax,%edi
call   1060 <time@plt>
mov    %eax,%edi
call   1040 <srand@plt>
mov    $0x0,%al
call   1070 <rand@plt>
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %edx,-0x294(%rbp)
mov    -0x294(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x294(%rbp)
mov    $0x0,%al
call   1070 <rand@plt>
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %edx,-0x298(%rbp)
mov    -0x298(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x298(%rbp)
movl   $0x1,-0x29c(%rbp)
movl   $0x0,-0x29c(%rbp)
cmpl   $0x64,-0x29c(%rbp)
jge    145f <main+0x30f>
movslq -0x29c(%rbp),%rax
movl   $0x0,-0x430(%rbp,%rax,4)
mov    -0x29c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x29c(%rbp)
jmp    142c <main+0x2dc>
movl   $0x1,-0x434(%rbp)
movl   $0x1,-0x438(%rbp)
movl   $0x0,-0x43c(%rbp)
xor    %eax,%eax
mov    %eax,%edi
call   1060 <time@plt>
mov    %eax,%edi
call   1040 <srand@plt>
movl   $0x0,-0x29c(%rbp)
cmpl   $0x64,-0x29c(%rbp)
jge    1bfc <main+0xaac>
jmp    14a9 <main+0x359>
movslq -0x434(%rbp),%rax
cmpl   $0x2,-0x430(%rbp,%rax,4)
02
jne    14f6 <main+0x3a6>
mov    $0x0,%al
call   1070 <rand@plt>
mov    $0x64,%ecx
cltd
idiv   %ecx
mov    %edx,-0x438(%rbp)
mov    -0x438(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x434(%rbp)
mov    -0x438(%rbp),%eax
add    $0xa,%eax
mov    %eax,-0x438(%rbp)
jmp    14a9 <main+0x359>
movl   $0x0,-0x20c(%rbp)
cmpl   $0xe,-0x20c(%rbp)
jge    1bd6 <main+0xa86>
mov    -0x438(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
movslq -0x20c(%rbp),%rcx
cmp    -0x250(%rbp,%rcx,4),%eax
jne    1bbd <main+0xa6d>
mov    -0x438(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
movslq -0x20c(%rbp),%rax
cmp    -0x290(%rbp,%rax,4),%edx
jne    1bbd <main+0xa6d>
mov    -0x438(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %eax,%esi
mov    -0x438(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
lea    0xaa9(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x43c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x43c(%rbp)
movl   $0x1,-0x440(%rbp)
cmpl   $0x6,-0x440(%rbp)
jge    170e <main+0x5be>
mov    -0x434(%rbp),%eax
add    -0x440(%rbp),%eax
cltq
cmpl   $0x2,-0x430(%rbp,%rax,4)
02
je     16f5 <main+0x5a5>
movl   $0x0,-0x448(%rbp)
mov    -0x29c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x29c(%rbp)
mov    -0x434(%rbp),%eax
add    -0x440(%rbp),%eax
cltq
movl   $0x2,-0x430(%rbp,%rax,4)
movl   $0x0,-0x444(%rbp)
cmpl   $0xe,-0x444(%rbp)
jge    16f0 <main+0x5a0>
mov    -0x438(%rbp),%eax
add    -0x440(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
movslq -0x444(%rbp),%rcx
cmp    -0x250(%rbp,%rcx,4),%eax
jne    16ae <main+0x55e>
mov    -0x438(%rbp),%eax
add    -0x440(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
movslq -0x444(%rbp),%rax
cmp    -0x290(%rbp,%rax,4),%edx
jne    16ae <main+0x55e>
mov    -0x438(%rbp),%eax
add    -0x440(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %eax,%esi
mov    -0x438(%rbp),%eax
add    -0x440(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
lea    0x9ab(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x43c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x43c(%rbp)
movl   $0x1,-0x448(%rbp)
jmp    16d7 <main+0x587>
cmpl   $0xd,-0x444(%rbp)
jne    16d2 <main+0x582>
cmpl   $0x0,-0x448(%rbp)
jne    16d2 <main+0x582>
movl   $0x6,-0x440(%rbp)
jmp    16d7 <main+0x587>
jmp    16dc <main+0x58c>
mov    -0x444(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x444(%rbp)
jmp    15fb <main+0x4ab>
jmp    16f5 <main+0x5a5>
jmp    16fa <main+0x5aa>
mov    -0x440(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x440(%rbp)
jmp    1596 <main+0x446>
movl   $0x1,-0x440(%rbp)
cmpl   $0x6,-0x440(%rbp)
jge    1890 <main+0x740>
mov    -0x434(%rbp),%eax
sub    -0x440(%rbp),%eax
cltq
cmpl   $0x2,-0x430(%rbp,%rax,4)
02
je     1877 <main+0x727>
movl   $0x0,-0x44c(%rbp)
mov    -0x29c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x29c(%rbp)
mov    -0x434(%rbp),%eax
sub    -0x440(%rbp),%eax
cltq
movl   $0x2,-0x430(%rbp,%rax,4)
movl   $0x0,-0x444(%rbp)
cmpl   $0xe,-0x444(%rbp)
jge    1872 <main+0x722>
mov    -0x438(%rbp),%eax
sub    -0x440(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
movslq -0x444(%rbp),%rcx
cmp    -0x250(%rbp,%rcx,4),%eax
jne    1830 <main+0x6e0>
mov    -0x438(%rbp),%eax
sub    -0x440(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
movslq -0x444(%rbp),%rax
cmp    -0x290(%rbp,%rax,4),%edx
jne    1830 <main+0x6e0>
mov    -0x438(%rbp),%eax
sub    -0x440(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %eax,%esi
mov    -0x438(%rbp),%eax
sub    -0x440(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
lea    0x829(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x43c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x43c(%rbp)
movl   $0x1,-0x44c(%rbp)
jmp    1859 <main+0x709>
cmpl   $0xd,-0x444(%rbp)
jne    1854 <main+0x704>
cmpl   $0x0,-0x44c(%rbp)
jne    1854 <main+0x704>
movl   $0x6,-0x440(%rbp)
jmp    1859 <main+0x709>
jmp    185e <main+0x70e>
mov    -0x444(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x444(%rbp)
jmp    177d <main+0x62d>
jmp    1877 <main+0x727>
jmp    187c <main+0x72c>
mov    -0x440(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x440(%rbp)
jmp    1718 <main+0x5c8>
movl   $0xa,-0x440(%rbp)
cmpl   $0x3c,-0x440(%rbp)
jge    1a12 <main+0x8c2>
mov    -0x434(%rbp),%eax
add    -0x440(%rbp),%eax
cltq
cmpl   $0x2,-0x430(%rbp,%rax,4)
02
je     19f9 <main+0x8a9>
movl   $0x0,-0x450(%rbp)
mov    -0x29c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x29c(%rbp)
mov    -0x434(%rbp),%eax
add    -0x440(%rbp),%eax
cltq
movl   $0x2,-0x430(%rbp,%rax,4)
movl   $0x0,-0x444(%rbp)
cmpl   $0xe,-0x444(%rbp)
jge    19f4 <main+0x8a4>
mov    -0x438(%rbp),%eax
add    -0x440(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
movslq -0x444(%rbp),%rcx
cmp    -0x250(%rbp,%rcx,4),%eax
jne    19b2 <main+0x862>
mov    -0x438(%rbp),%eax
add    -0x440(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
movslq -0x444(%rbp),%rax
cmp    -0x290(%rbp,%rax,4),%edx
jne    19b2 <main+0x862>
mov    -0x438(%rbp),%eax
add    -0x440(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %eax,%esi
mov    -0x438(%rbp),%eax
add    -0x440(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
lea    0x6a7(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x43c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x43c(%rbp)
movl   $0x1,-0x450(%rbp)
jmp    19db <main+0x88b>
cmpl   $0xd,-0x444(%rbp)
jne    19d6 <main+0x886>
cmpl   $0x0,-0x450(%rbp)
jne    19d6 <main+0x886>
movl   $0x3c,-0x440(%rbp)
jmp    19db <main+0x88b>
jmp    19e0 <main+0x890>
mov    -0x444(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x444(%rbp)
jmp    18ff <main+0x7af>
jmp    19f9 <main+0x8a9>
jmp    19fe <main+0x8ae>
mov    -0x440(%rbp),%eax
add    $0xa,%eax
mov    %eax,-0x440(%rbp)
jmp    189a <main+0x74a>
movl   $0xa,-0x440(%rbp)
cmpl   $0x3c,-0x440(%rbp)
jge    1b94 <main+0xa44>
mov    -0x434(%rbp),%eax
sub    -0x440(%rbp),%eax
cltq
cmpl   $0x2,-0x430(%rbp,%rax,4)
02
je     1b7b <main+0xa2b>
movl   $0x0,-0x454(%rbp)
mov    -0x29c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x29c(%rbp)
mov    -0x434(%rbp),%eax
sub    -0x440(%rbp),%eax
cltq
movl   $0x2,-0x430(%rbp,%rax,4)
movl   $0x0,-0x444(%rbp)
cmpl   $0xe,-0x444(%rbp)
jge    1b76 <main+0xa26>
mov    -0x438(%rbp),%eax
sub    -0x440(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
movslq -0x444(%rbp),%rcx
cmp    -0x250(%rbp,%rcx,4),%eax
jne    1b34 <main+0x9e4>
mov    -0x438(%rbp),%eax
sub    -0x440(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
movslq -0x444(%rbp),%rax
cmp    -0x290(%rbp,%rax,4),%edx
jne    1b34 <main+0x9e4>
mov    -0x438(%rbp),%eax
sub    -0x440(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %eax,%esi
mov    -0x438(%rbp),%eax
sub    -0x440(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
lea    0x525(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x43c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x43c(%rbp)
movl   $0x1,-0x454(%rbp)
jmp    1b5d <main+0xa0d>
cmpl   $0xd,-0x444(%rbp)
jne    1b58 <main+0xa08>
cmpl   $0x0,-0x454(%rbp)
jne    1b58 <main+0xa08>
movl   $0x3c,-0x440(%rbp)
jmp    1b5d <main+0xa0d>
jmp    1b62 <main+0xa12>
mov    -0x444(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x444(%rbp)
jmp    1a81 <main+0x931>
jmp    1b7b <main+0xa2b>
jmp    1b80 <main+0xa30>
mov    -0x440(%rbp),%eax
add    $0xa,%eax
mov    %eax,-0x440(%rbp)
jmp    1a1c <main+0x8cc>
cmpl   $0xe,-0x43c(%rbp)
jne    1bb8 <main+0xa68>
mov    -0x29c(%rbp),%esi
add    $0x1,%esi
lea    0x47e(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    1bbd <main+0xa6d>
jmp    1bc2 <main+0xa72>
mov    -0x20c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20c(%rbp)
jmp    1500 <main+0x3b0>
movslq -0x434(%rbp),%rax
movl   $0x2,-0x430(%rbp,%rax,4)
mov    -0x29c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x29c(%rbp)
jmp    1497 <main+0x347>
xor    %eax,%eax
add    $0x460,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x358,%rsp
lea    0xe91(%rip),%rdi
lea    0xe81(%rip),%rsi
xor    %ebx,%ebx
xor    %eax,%eax
call   1040 <printf@plt>
lea    0x1c0(%rsp),%rdi
mov    $0x190,%edx
xor    %esi,%esi
call   1050 <memset@plt>
mov    $0x20,%edi
call   1030 <putchar@plt>
lea    0xea3(%rip),%r14
lea    0xedc(%rip),%r13
jmp    11ca <main+0x6a>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rbx
cmp    $0xa,%rbx
je     123f <main+0xdf>
xor    %eax,%eax
jmp    11da <main+0x7a>
xchg   %ax,%ax
add    $0x1,%rax
cmp    $0xa,%rax
je     11c0 <main+0x60>
lea    (%rbx,%rbx,4),%rcx
lea    (%rsp,%rcx,8),%rcx
add    $0x1c0,%rcx
lea    (%rcx,%rax,4),%rcx
mov    $0x1,%edx
jmp    120a <main+0xaa>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x2,%rdx
cmp    $0xf,%rdx
je     11d0 <main+0x70>
mov    -0x4(%r14,%rdx,4),%esi
cmp    %rsi,%rbx
jne    1224 <main+0xc4>
mov    -0x4(%r13,%rdx,4),%esi
cmp    %rsi,%rax
jne    1224 <main+0xc4>
movl   $0x1,(%rcx)
mov    (%r14,%rdx,4),%esi
cmp    %rsi,%rbx
jne    1200 <main+0xa0>
mov    0x0(%r13,%rdx,4),%esi
cmp    %rsi,%rax
jne    1200 <main+0xa0>
movl   $0x1,(%rcx)
jmp    1200 <main+0xa0>
mov    $0x24,%ebp
lea    0xdcd(%rip),%rbx
lea    0xdca(%rip),%r15
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x19c(%rsp,%rbp,1),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x1a0(%rsp,%rbp,1),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x1a4(%rsp,%rbp,1),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x1a8(%rsp,%rbp,1),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x1ac(%rsp,%rbp,1),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x1b0(%rsp,%rbp,1),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x1b4(%rsp,%rbp,1),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x1b8(%rsp,%rbp,1),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x1bc(%rsp,%rbp,1),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x1c0(%rsp,%rbp,1),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %r15,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
add    $0x28,%rbp
cmp    $0x1b4,%rbp
jne    1260 <main+0x100>
xor    %edi,%edi
call   1070 <time@plt>
mov    %eax,%edi
call   1060 <srand@plt>
xor    %eax,%eax
call   1080 <rand@plt>
xor    %eax,%eax
call   1080 <rand@plt>
lea    0x30(%rsp),%rdi
mov    $0x190,%edx
xor    %esi,%esi
call   1050 <memset@plt>
xor    %edi,%edi
call   1070 <time@plt>
mov    %eax,%edi
call   1060 <srand@plt>
mov    $0x1,%r12d
xor    %r15d,%r15d
mov    $0x1,%eax
mov    %rax,0x8(%rsp)
xor    %eax,%eax
mov    %rax,(%rsp)
jmp    13a1 <main+0x241>
nopl   0x0(%rax,%rax,1)
mov    0x10(%rsp),%rax
movl   $0x2,0x30(%rsp,%rax,4)
mov    (%rsp),%rcx
lea    0x1(%rcx),%eax
cmp    $0x63,%ecx
mov    %rax,(%rsp)
jge    17aa <main+0x64a>
movslq 0x8(%rsp),%rax
mov    %rax,0x10(%rsp)
cmpl   $0x2,0x30(%rsp,%rax,4)
jne    1408 <main+0x2a8>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xor    %eax,%eax
call   1080 <rand@plt>
movslq %eax,%rdx
imul   $0x51eb851f,%rdx,%rcx
mov    %rcx,%rsi
shr    $0x3f,%rsi
sar    $0x25,%rcx
add    %esi,%ecx
imul   $0x64,%ecx,%ecx
sub    %ecx,%edx
movslq %edx,%r12
cmpl   $0x2,0x2c(%rsp,%r12,4)
je     13c0 <main+0x260>
neg    %ecx
add    %ecx,%eax
add    $0xffffffff,%eax
mov    %rax,0x8(%rsp)
lea    -0x1(%r12),%rax
mov    %rax,0x10(%rsp)
add    $0xa,%r12d
movslq %r12d,%rdx
imul   $0x66666667,%rdx,%rsi
mov    %rsi,%rax
shr    $0x3f,%rax
sar    $0x22,%rsi
add    %eax,%esi
lea    (%rsi,%rsi,1),%eax
lea    (%rax,%rax,4),%eax
sub    %eax,%edx
xor    %eax,%eax
mov    %rdx,0x20(%rsp)
mov    %rsi,0x18(%rsp)
jmp    145d <main+0x2fd>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x20(%rsp),%rdx
mov    0x18(%rsp),%rsi
mov    0x28(%rsp),%rax
add    $0x1,%rax
cmp    $0xe,%rax
je     1380 <main+0x220>
cmp    (%r14,%rax,4),%esi
jne    144f <main+0x2ef>
cmp    0x0(%r13,%rax,4),%edx
jne    144f <main+0x2ef>
mov    %rax,0x28(%rsp)
mov    %r13,%rbx
lea    0xba6(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
add    $0x1,%r15d
mov    $0x1,%r13d
xor    %edi,%edi
jmp    14ac <main+0x34c>
xchg   %ax,%ax
mov    (%rsp),%rax
add    $0x1,%eax
mov    %rax,(%rsp)
lea    0x1(%r13),%eax
cmp    $0x5,%r13d
mov    %eax,%r13d
jge    1540 <main+0x3e0>
mov    0x8(%rsp),%rax
add    %r13d,%eax
cltq
cmpl   $0x2,0x30(%rsp,%rax,4)
je     149b <main+0x33b>
movl   $0x2,0x30(%rsp,%rax,4)
xor    %ebp,%ebp
xor    %eax,%eax
jmp    14f4 <main+0x394>
nopl   0x0(%rax,%rax,1)
cmp    $0x34,%rbp
sete   %cl
test   %eax,%eax
sete   %dl
test   %dl,%cl
mov    $0x6,%ecx
cmovne %ecx,%r13d
cmovne %edi,%eax
add    $0x4,%rbp
cmp    $0x38,%rbp
je     1490 <main+0x330>
lea    (%r12,%r13,1),%edx
movslq %edx,%rcx
imul   $0x66666667,%rcx,%rsi
mov    %rsi,%rcx
shr    $0x3f,%rcx
sar    $0x22,%rsi
add    %ecx,%esi
cmp    0x0(%rbp,%r14,1),%esi
jne    14d0 <main+0x370>
lea    (%rsi,%rsi,1),%ecx
lea    (%rcx,%rcx,4),%ecx
sub    %ecx,%edx
cmp    0x0(%rbp,%rbx,1),%edx
jne    14d0 <main+0x370>
lea    0xb09(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
xor    %edi,%edi
add    $0x1,%r15d
mov    $0x1,%eax
jmp    14ea <main+0x38a>
nop
mov    $0x1,%ebp
mov    %rbx,%r13
jmp    1569 <main+0x409>
nopw   0x0(%rax,%rax,1)
mov    (%rsp),%rax
add    $0x1,%eax
mov    %rax,(%rsp)
lea    0x1(%rbp),%eax
cmp    $0x5,%ebp
mov    %eax,%ebp
jge    1600 <main+0x4a0>
mov    0x8(%rsp),%rax
sub    %ebp,%eax
cltq
cmpl   $0x2,0x30(%rsp,%rax,4)
je     155b <main+0x3fb>
movl   $0x2,0x30(%rsp,%rax,4)
xor    %ebx,%ebx
xor    %eax,%eax
jmp    15b3 <main+0x453>
nopw   0x0(%rax,%rax,1)
cmp    $0x34,%rbx
sete   %cl
test   %eax,%eax
sete   %dl
test   %dl,%cl
mov    $0x6,%ecx
cmovne %ecx,%ebp
cmovne %edi,%eax
add    $0x4,%rbx
cmp    $0x38,%rbx
je     1550 <main+0x3f0>
mov    %r12d,%edx
sub    %ebp,%edx
movslq %edx,%rcx
imul   $0x66666667,%rcx,%rsi
mov    %rsi,%rcx
shr    $0x3f,%rcx
sar    $0x22,%rsi
add    %ecx,%esi
cmp    (%rbx,%r14,1),%esi
jne    1590 <main+0x430>
lea    (%rsi,%rsi,1),%ecx
lea    (%rcx,%rcx,4),%ecx
sub    %ecx,%edx
cmp    (%rbx,%r13,1),%edx
jne    1590 <main+0x430>
lea    0xa4a(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
xor    %edi,%edi
add    $0x1,%r15d
mov    $0x1,%eax
jmp    15a9 <main+0x449>
xchg   %ax,%ax
mov    $0xa,%ebp
jmp    1629 <main+0x4c9>
nopw   0x0(%rax,%rax,1)
mov    (%rsp),%rax
add    $0x1,%eax
mov    %rax,(%rsp)
lea    0xa(%rbp),%eax
cmp    $0x32,%ebp
mov    %eax,%ebp
jge    16c0 <main+0x560>
mov    0x8(%rsp),%rax
add    %ebp,%eax
cltq
cmpl   $0x2,0x30(%rsp,%rax,4)
je     161b <main+0x4bb>
movl   $0x2,0x30(%rsp,%rax,4)
xor    %ebx,%ebx
xor    %eax,%eax
jmp    1673 <main+0x513>
nopw   0x0(%rax,%rax,1)
cmp    $0x34,%rbx
sete   %cl
test   %eax,%eax
sete   %dl
test   %dl,%cl
mov    $0x3c,%ecx
cmovne %ecx,%ebp
cmovne %edi,%eax
add    $0x4,%rbx
cmp    $0x38,%rbx
je     1610 <main+0x4b0>
lea    (%r12,%rbp,1),%edx
movslq %edx,%rcx
imul   $0x66666667,%rcx,%rsi
mov    %rsi,%rcx
shr    $0x3f,%rcx
sar    $0x22,%rsi
add    %ecx,%esi
cmp    (%rbx,%r14,1),%esi
jne    1650 <main+0x4f0>
lea    (%rsi,%rsi,1),%ecx
lea    (%rcx,%rcx,4),%ecx
sub    %ecx,%edx
cmp    (%rbx,%r13,1),%edx
jne    1650 <main+0x4f0>
lea    0x98b(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
xor    %edi,%edi
add    $0x1,%r15d
mov    $0x1,%eax
jmp    1669 <main+0x509>
nopl   (%rax)
mov    $0xa,%ebp
jmp    16e9 <main+0x589>
nopw   0x0(%rax,%rax,1)
mov    (%rsp),%rax
add    $0x1,%eax
mov    %rax,(%rsp)
lea    0xa(%rbp),%eax
cmp    $0x32,%ebp
mov    %eax,%ebp
jge    1780 <main+0x620>
mov    0x8(%rsp),%rax
sub    %ebp,%eax
cltq
cmpl   $0x2,0x30(%rsp,%rax,4)
je     16db <main+0x57b>
movl   $0x2,0x30(%rsp,%rax,4)
xor    %ebx,%ebx
xor    %eax,%eax
jmp    1733 <main+0x5d3>
nopw   0x0(%rax,%rax,1)
cmp    $0x34,%rbx
sete   %cl
test   %eax,%eax
sete   %dl
test   %dl,%cl
mov    $0x3c,%ecx
cmovne %ecx,%ebp
cmovne %edi,%eax
add    $0x4,%rbx
cmp    $0x38,%rbx
je     16d0 <main+0x570>
mov    %r12d,%edx
sub    %ebp,%edx
movslq %edx,%rcx
imul   $0x66666667,%rcx,%rsi
mov    %rsi,%rcx
shr    $0x3f,%rcx
sar    $0x22,%rsi
add    %ecx,%esi
cmp    (%rbx,%r14,1),%esi
jne    1710 <main+0x5b0>
lea    (%rsi,%rsi,1),%ecx
lea    (%rcx,%rcx,4),%ecx
sub    %ecx,%edx
cmp    (%rbx,%r13,1),%edx
jne    1710 <main+0x5b0>
lea    0x8ca(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
xor    %edi,%edi
add    $0x1,%r15d
mov    $0x1,%eax
jmp    1729 <main+0x5c9>
xchg   %ax,%ax
cmp    $0xe,%r15d
jne    1440 <main+0x2e0>
mov    (%rsp),%rax
lea    0x1(%rax),%esi
lea    0x897(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0xe,%r15d
jmp    1440 <main+0x2e0>
xor    %eax,%eax
add    $0x358,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [9 x i8] c"navi.txt\00"
@.str.1 = [15 x i8] c"Opening.. %s \0A\00"
@.str.2 = [2 x i8] c" \00"
@__const.main.lettere = [14 x i32] [i32 2, i32 2, i32 2, i32 2, i32 2, i32 3, i32 4, i32 5, i32 6, i32 6, i32 7, i32 8, i32 10, i32 10]
@__const.main.numeri = [14 x i32] [i32 5, i32 6, i32 7, i32 8, i32 9, i32 3, i32 3, i32 3, i32 3, i32 7, i32 7, i32 7, i32 7, i32 8]
@.str.3 = [4 x i8] c"%d\09\00"
@.str.4 = [3 x i8] c"\0A \00"
@.str.5 = [21 x i8] c"c'hai preso! %d %d \0A\00"
@.str.6 = [23 x i8] c"c'hai ripreso! %d %d \0A\00"
@.str.7 = [5 x i8] c"%d \0A\00"
define i32 @main(i32 %0) {
%2 = alloca i32
%3 = alloca i32
%4 = alloca i8*
%5 = alloca [10 x i32]
%6 = alloca [10 x i32]
%7 = alloca [10 x [10 x i32]]
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca [14 x i32]
%12 = alloca [14 x i32]
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca [100 x i32]
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32
%25 = alloca i32
store i32 0, i32* %2
store i32 %0, i32* %3
store i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0), i8** %4
%26 = load i8*, i8** %4
%27 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.1, i64 0, i64 0), i8* %26)
%28 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %7, i64 0, i64 1
%29 = getelementptr inbounds [10 x i32], [10 x i32]* %28, i64 0, i64 2
store i32 10, i32* %29
store i32 0, i32* %8
br label %30
30: ; preds = %48, %1
%31 = load i32, i32* %8
%32 = icmp slt i32 %31, 10
br i1 %32, label %33, label %51
33: ; preds = %30
store i32 0, i32* %9
br label %34
34: ; preds = %44, %33
%35 = load i32, i32* %9
%36 = icmp slt i32 %35, 10
br i1 %36, label %37, label %47
37: ; preds = %34
%38 = load i32, i32* %8
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %7, i64 0, i64 %39
%41 = load i32, i32* %9
%42 = sext i32 %41 to i64
%43 = getelementptr inbounds [10 x i32], [10 x i32]* %40, i64 0, i64 %42
store i32 0, i32* %43
br label %44
44: ; preds = %37
%45 = load i32, i32* %9
%46 = add nsw i32 %45, 1
store i32 %46, i32* %9
br label %34
47: ; preds = %34
br label %48
48: ; preds = %47
%49 = load i32, i32* %8
%50 = add nsw i32 %49, 1
store i32 %50, i32* %8
br label %30
51: ; preds = %30
%52 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%53 = bitcast [14 x i32]* %11 to i8*
%54 = bitcast [14 x i32]* %12 to i8*
store i32 0, i32* %8
br label %55
55: ; preds = %96, %51
%56 = load i32, i32* %8
%57 = icmp slt i32 %56, 10
br i1 %57, label %58, label %99
58: ; preds = %55
store i32 0, i32* %9
br label %59
59: ; preds = %92, %58
%60 = load i32, i32* %9
%61 = icmp slt i32 %60, 10
br i1 %61, label %62, label %95
62: ; preds = %59
store i32 0, i32* %10
br label %63
63: ; preds = %88, %62
%64 = load i32, i32* %10
%65 = icmp slt i32 %64, 14
br i1 %65, label %66, label %91
66: ; preds = %63
%67 = load i32, i32* %8
%68 = load i32, i32* %10
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds [14 x i32], [14 x i32]* %11, i64 0, i64 %69
%71 = load i32, i32* %70
%72 = icmp eq i32 %67, %71
br i1 %72, label %73, label %87
73: ; preds = %66
%74 = load i32, i32* %9
%75 = load i32, i32* %10
%76 = sext i32 %75 to i64
%77 = getelementptr inbounds [14 x i32], [14 x i32]* %12, i64 0, i64 %76
%78 = load i32, i32* %77
%79 = icmp eq i32 %74, %78
br i1 %79, label %80, label %87
80: ; preds = %73
%81 = load i32, i32* %8
%82 = sext i32 %81 to i64
%83 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %7, i64 0, i64 %82
%84 = load i32, i32* %9
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds [10 x i32], [10 x i32]* %83, i64 0, i64 %85
store i32 1, i32* %86
br label %87
87: ; preds = %80, %73, %66
br label %88
88: ; preds = %87
%89 = load i32, i32* %10
%90 = add nsw i32 %89, 1
store i32 %90, i32* %10
br label %63
91: ; preds = %63
br label %92
92: ; preds = %91
%93 = load i32, i32* %9
%94 = add nsw i32 %93, 1
store i32 %94, i32* %9
br label %59
95: ; preds = %59
br label %96
96: ; preds = %95
%97 = load i32, i32* %8
%98 = add nsw i32 %97, 1
store i32 %98, i32* %8
br label %55
99: ; preds = %55
store i32 0, i32* %8
br label %100
100: ; preds = %121, %99
%101 = load i32, i32* %8
%102 = icmp slt i32 %101, 10
br i1 %102, label %103, label %124
103: ; preds = %100
store i32 0, i32* %9
br label %104
104: ; preds = %116, %103
%105 = load i32, i32* %9
%106 = icmp slt i32 %105, 10
br i1 %106, label %107, label %119
107: ; preds = %104
%108 = load i32, i32* %8
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %7, i64 0, i64 %109
%111 = load i32, i32* %9
%112 = sext i32 %111 to i64
%113 = getelementptr inbounds [10 x i32], [10 x i32]* %110, i64 0, i64 %112
%114 = load i32, i32* %113
%115 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0), i32 %114)
br label %116
116: ; preds = %107
%117 = load i32, i32* %9
%118 = add nsw i32 %117, 1
store i32 %118, i32* %9
br label %104
119: ; preds = %104
%120 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i64 0, i64 0))
br label %121
121: ; preds = %119
%122 = load i32, i32* %8
%123 = add nsw i32 %122, 1
store i32 %123, i32* %8
br label %100
124: ; preds = %100
%125 = call i32 @time(i32* null)
%126 = call i32 @srand(i32 %125)
%127 = call i32 (...) @rand()
%128 = srem i32 %127, 10
store i32 %128, i32* %13
%129 = load i32, i32* %13
%130 = add nsw i32 %129, 1
store i32 %130, i32* %13
%131 = call i32 (...) @rand()
%132 = srem i32 %131, 10
store i32 %132, i32* %14
%133 = load i32, i32* %14
%134 = add nsw i32 %133, 1
store i32 %134, i32* %14
store i32 1, i32* %15
store i32 0, i32* %15
br label %135
135: ; preds = %142, %124
%136 = load i32, i32* %15
%137 = icmp slt i32 %136, 100
br i1 %137, label %138, label %145
138: ; preds = %135
%139 = load i32, i32* %15
%140 = sext i32 %139 to i64
%141 = getelementptr inbounds [100 x i32], [100 x i32]* %16, i64 0, i64 %140
store i32 0, i32* %141
br label %142
142: ; preds = %138
%143 = load i32, i32* %15
%144 = add nsw i32 %143, 1
store i32 %144, i32* %15
br label %135
145: ; preds = %135
store i32 1, i32* %17
store i32 1, i32* %18
store i32 0, i32* %19
%146 = call i32 @time(i32* null)
%147 = call i32 @srand(i32 %146)
store i32 0, i32* %15
br label %148
148: ; preds = %496, %145
%149 = load i32, i32* %15
%150 = icmp slt i32 %149, 100
br i1 %150, label %151, label %499
151: ; preds = %148
br label %152
152: ; preds = %158, %151
%153 = load i32, i32* %17
%154 = sext i32 %153 to i64
%155 = getelementptr inbounds [100 x i32], [100 x i32]* %16, i64 0, i64 %154
%156 = load i32, i32* %155
%157 = icmp eq i32 %156, 2
br i1 %157, label %158, label %165
158: ; preds = %152
%159 = call i32 (...) @rand()
%160 = srem i32 %159, 100
store i32 %160, i32* %18
%161 = load i32, i32* %18
%162 = sub nsw i32 %161, 1
store i32 %162, i32* %17
%163 = load i32, i32* %18
%164 = add nsw i32 %163, 10
store i32 %164, i32* %18
br label %152
165: ; preds = %152
store i32 0, i32* %10
br label %166
166: ; preds = %489, %165
%167 = load i32, i32* %10
%168 = icmp slt i32 %167, 14
br i1 %168, label %169, label %492
169: ; preds = %166
%170 = load i32, i32* %18
%171 = sdiv i32 %170, 10
%172 = load i32, i32* %10
%173 = sext i32 %172 to i64
%174 = getelementptr inbounds [14 x i32], [14 x i32]* %11, i64 0, i64 %173
%175 = load i32, i32* %174
%176 = icmp eq i32 %171, %175
br i1 %176, label %177, label %488
177: ; preds = %169
%178 = load i32, i32* %18
%179 = srem i32 %178, 10
%180 = load i32, i32* %10
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds [14 x i32], [14 x i32]* %12, i64 0, i64 %181
%183 = load i32, i32* %182
%184 = icmp eq i32 %179, %183
br i1 %184, label %185, label %488
185: ; preds = %177
%186 = load i32, i32* %18
%187 = sdiv i32 %186, 10
%188 = load i32, i32* %18
%189 = srem i32 %188, 10
%190 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.5, i64 0, i64 0), i32 %187, i32 %189)
%191 = load i32, i32* %19
%192 = add nsw i32 %191, 1
store i32 %192, i32* %19
store i32 1, i32* %20
br label %193
193: ; preds = %261, %185
%194 = load i32, i32* %20
%195 = icmp slt i32 %194, 6
br i1 %195, label %196, label %264
196: ; preds = %193
%197 = load i32, i32* %17
%198 = load i32, i32* %20
%199 = add nsw i32 %197, %198
%200 = sext i32 %199 to i64
%201 = getelementptr inbounds [100 x i32], [100 x i32]* %16, i64 0, i64 %200
%202 = load i32, i32* %201
%203 = icmp ne i32 %202, 2
br i1 %203, label %204, label %260
204: ; preds = %196
store i32 0, i32* %22
%205 = load i32, i32* %15
%206 = add nsw i32 %205, 1
store i32 %206, i32* %15
%207 = load i32, i32* %17
%208 = load i32, i32* %20
%209 = add nsw i32 %207, %208
%210 = sext i32 %209 to i64
%211 = getelementptr inbounds [100 x i32], [100 x i32]* %16, i64 0, i64 %210
store i32 2, i32* %211
store i32 0, i32* %21
br label %212
212: ; preds = %256, %204
%213 = load i32, i32* %21
%214 = icmp slt i32 %213, 14
br i1 %214, label %215, label %259
215: ; preds = %212
%216 = load i32, i32* %18
%217 = load i32, i32* %20
%218 = add nsw i32 %216, %217
%219 = sdiv i32 %218, 10
%220 = load i32, i32* %21
%221 = sext i32 %220 to i64
%222 = getelementptr inbounds [14 x i32], [14 x i32]* %11, i64 0, i64 %221
%223 = load i32, i32* %222
%224 = icmp eq i32 %219, %223
br i1 %224, label %225, label %247
225: ; preds = %215
%226 = load i32, i32* %18
%227 = load i32, i32* %20
%228 = add nsw i32 %226, %227
%229 = srem i32 %228, 10
%230 = load i32, i32* %21
%231 = sext i32 %230 to i64
%232 = getelementptr inbounds [14 x i32], [14 x i32]* %12, i64 0, i64 %231
%233 = load i32, i32* %232
%234 = icmp eq i32 %229, %233
br i1 %234, label %235, label %247
235: ; preds = %225
%236 = load i32, i32* %18
%237 = load i32, i32* %20
%238 = add nsw i32 %236, %237
%239 = sdiv i32 %238, 10
%240 = load i32, i32* %18
%241 = load i32, i32* %20
%242 = add nsw i32 %240, %241
%243 = srem i32 %242, 10
%244 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.6, i64 0, i64 0), i32 %239, i32 %243)
%245 = load i32, i32* %19
%246 = add nsw i32 %245, 1
store i32 %246, i32* %19
store i32 1, i32* %22
br label %255
247: ; preds = %225, %215
%248 = load i32, i32* %21
%249 = icmp eq i32 %248, 13
br i1 %249, label %250, label %254
250: ; preds = %247
%251 = load i32, i32* %22
%252 = icmp eq i32 %251, 0
br i1 %252, label %253, label %254
253: ; preds = %250
store i32 6, i32* %20
br label %254
254: ; preds = %253, %250, %247
br label %255
255: ; preds = %254, %235
br label %256
256: ; preds = %255
%257 = load i32, i32* %21
%258 = add nsw i32 %257, 1
store i32 %258, i32* %21
br label %212
259: ; preds = %212
br label %260
260: ; preds = %259, %196
br label %261
261: ; preds = %260
%262 = load i32, i32* %20
%263 = add nsw i32 %262, 1
store i32 %263, i32* %20
br label %193
264: ; preds = %193
store i32 1, i32* %20
br label %265
265: ; preds = %333, %264
%266 = load i32, i32* %20
%267 = icmp slt i32 %266, 6
br i1 %267, label %268, label %336
268: ; preds = %265
%269 = load i32, i32* %17
%270 = load i32, i32* %20
%271 = sub nsw i32 %269, %270
%272 = sext i32 %271 to i64
%273 = getelementptr inbounds [100 x i32], [100 x i32]* %16, i64 0, i64 %272
%274 = load i32, i32* %273
%275 = icmp ne i32 %274, 2
br i1 %275, label %276, label %332
276: ; preds = %268
store i32 0, i32* %23
%277 = load i32, i32* %15
%278 = add nsw i32 %277, 1
store i32 %278, i32* %15
%279 = load i32, i32* %17
%280 = load i32, i32* %20
%281 = sub nsw i32 %279, %280
%282 = sext i32 %281 to i64
%283 = getelementptr inbounds [100 x i32], [100 x i32]* %16, i64 0, i64 %282
store i32 2, i32* %283
store i32 0, i32* %21
br label %284
284: ; preds = %328, %276
%285 = load i32, i32* %21
%286 = icmp slt i32 %285, 14
br i1 %286, label %287, label %331
287: ; preds = %284
%288 = load i32, i32* %18
%289 = load i32, i32* %20
%290 = sub nsw i32 %288, %289
%291 = sdiv i32 %290, 10
%292 = load i32, i32* %21
%293 = sext i32 %292 to i64
%294 = getelementptr inbounds [14 x i32], [14 x i32]* %11, i64 0, i64 %293
%295 = load i32, i32* %294
%296 = icmp eq i32 %291, %295
br i1 %296, label %297, label %319
297: ; preds = %287
%298 = load i32, i32* %18
%299 = load i32, i32* %20
%300 = sub nsw i32 %298, %299
%301 = srem i32 %300, 10
%302 = load i32, i32* %21
%303 = sext i32 %302 to i64
%304 = getelementptr inbounds [14 x i32], [14 x i32]* %12, i64 0, i64 %303
%305 = load i32, i32* %304
%306 = icmp eq i32 %301, %305
br i1 %306, label %307, label %319
307: ; preds = %297
%308 = load i32, i32* %18
%309 = load i32, i32* %20
%310 = sub nsw i32 %308, %309
%311 = sdiv i32 %310, 10
%312 = load i32, i32* %18
%313 = load i32, i32* %20
%314 = sub nsw i32 %312, %313
%315 = srem i32 %314, 10
%316 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.6, i64 0, i64 0), i32 %311, i32 %315)
%317 = load i32, i32* %19
%318 = add nsw i32 %317, 1
store i32 %318, i32* %19
store i32 1, i32* %23
br label %327
319: ; preds = %297, %287
%320 = load i32, i32* %21
%321 = icmp eq i32 %320, 13
br i1 %321, label %322, label %326
322: ; preds = %319
%323 = load i32, i32* %23
%324 = icmp eq i32 %323, 0
br i1 %324, label %325, label %326
325: ; preds = %322
store i32 6, i32* %20
br label %326
326: ; preds = %325, %322, %319
br label %327
327: ; preds = %326, %307
br label %328
328: ; preds = %327
%329 = load i32, i32* %21
%330 = add nsw i32 %329, 1
store i32 %330, i32* %21
br label %284
331: ; preds = %284
br label %332
332: ; preds = %331, %268
br label %333
333: ; preds = %332
%334 = load i32, i32* %20
%335 = add nsw i32 %334, 1
store i32 %335, i32* %20
br label %265
336: ; preds = %265
store i32 10, i32* %20
br label %337
337: ; preds = %405, %336
%338 = load i32, i32* %20
%339 = icmp slt i32 %338, 60
br i1 %339, label %340, label %408
340: ; preds = %337
%341 = load i32, i32* %17
%342 = load i32, i32* %20
%343 = add nsw i32 %341, %342
%344 = sext i32 %343 to i64
%345 = getelementptr inbounds [100 x i32], [100 x i32]* %16, i64 0, i64 %344
%346 = load i32, i32* %345
%347 = icmp ne i32 %346, 2
br i1 %347, label %348, label %404
348: ; preds = %340
store i32 0, i32* %24
%349 = load i32, i32* %15
%350 = add nsw i32 %349, 1
store i32 %350, i32* %15
%351 = load i32, i32* %17
%352 = load i32, i32* %20
%353 = add nsw i32 %351, %352
%354 = sext i32 %353 to i64
%355 = getelementptr inbounds [100 x i32], [100 x i32]* %16, i64 0, i64 %354
store i32 2, i32* %355
store i32 0, i32* %21
br label %356
356: ; preds = %400, %348
%357 = load i32, i32* %21
%358 = icmp slt i32 %357, 14
br i1 %358, label %359, label %403
359: ; preds = %356
%360 = load i32, i32* %18
%361 = load i32, i32* %20
%362 = add nsw i32 %360, %361
%363 = sdiv i32 %362, 10
%364 = load i32, i32* %21
%365 = sext i32 %364 to i64
%366 = getelementptr inbounds [14 x i32], [14 x i32]* %11, i64 0, i64 %365
%367 = load i32, i32* %366
%368 = icmp eq i32 %363, %367
br i1 %368, label %369, label %391
369: ; preds = %359
%370 = load i32, i32* %18
%371 = load i32, i32* %20
%372 = add nsw i32 %370, %371
%373 = srem i32 %372, 10
%374 = load i32, i32* %21
%375 = sext i32 %374 to i64
%376 = getelementptr inbounds [14 x i32], [14 x i32]* %12, i64 0, i64 %375
%377 = load i32, i32* %376
%378 = icmp eq i32 %373, %377
br i1 %378, label %379, label %391
379: ; preds = %369
%380 = load i32, i32* %18
%381 = load i32, i32* %20
%382 = add nsw i32 %380, %381
%383 = sdiv i32 %382, 10
%384 = load i32, i32* %18
%385 = load i32, i32* %20
%386 = add nsw i32 %384, %385
%387 = srem i32 %386, 10
%388 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.6, i64 0, i64 0), i32 %383, i32 %387)
%389 = load i32, i32* %19
%390 = add nsw i32 %389, 1
store i32 %390, i32* %19
store i32 1, i32* %24
br label %399
391: ; preds = %369, %359
%392 = load i32, i32* %21
%393 = icmp eq i32 %392, 13
br i1 %393, label %394, label %398
394: ; preds = %391
%395 = load i32, i32* %24
%396 = icmp eq i32 %395, 0
br i1 %396, label %397, label %398
397: ; preds = %394
store i32 60, i32* %20
br label %398
398: ; preds = %397, %394, %391
br label %399
399: ; preds = %398, %379
br label %400
400: ; preds = %399
%401 = load i32, i32* %21
%402 = add nsw i32 %401, 1
store i32 %402, i32* %21
br label %356
403: ; preds = %356
br label %404
404: ; preds = %403, %340
br label %405
405: ; preds = %404
%406 = load i32, i32* %20
%407 = add nsw i32 %406, 10
store i32 %407, i32* %20
br label %337
408: ; preds = %337
store i32 10, i32* %20
br label %409
409: ; preds = %477, %408
%410 = load i32, i32* %20
%411 = icmp slt i32 %410, 60
br i1 %411, label %412, label %480
412: ; preds = %409
%413 = load i32, i32* %17
%414 = load i32, i32* %20
%415 = sub nsw i32 %413, %414
%416 = sext i32 %415 to i64
%417 = getelementptr inbounds [100 x i32], [100 x i32]* %16, i64 0, i64 %416
%418 = load i32, i32* %417
%419 = icmp ne i32 %418, 2
br i1 %419, label %420, label %476
420: ; preds = %412
store i32 0, i32* %25
%421 = load i32, i32* %15
%422 = add nsw i32 %421, 1
store i32 %422, i32* %15
%423 = load i32, i32* %17
%424 = load i32, i32* %20
%425 = sub nsw i32 %423, %424
%426 = sext i32 %425 to i64
%427 = getelementptr inbounds [100 x i32], [100 x i32]* %16, i64 0, i64 %426
store i32 2, i32* %427
store i32 0, i32* %21
br label %428
428: ; preds = %472, %420
%429 = load i32, i32* %21
%430 = icmp slt i32 %429, 14
br i1 %430, label %431, label %475
431: ; preds = %428
%432 = load i32, i32* %18
%433 = load i32, i32* %20
%434 = sub nsw i32 %432, %433
%435 = sdiv i32 %434, 10
%436 = load i32, i32* %21
%437 = sext i32 %436 to i64
%438 = getelementptr inbounds [14 x i32], [14 x i32]* %11, i64 0, i64 %437
%439 = load i32, i32* %438
%440 = icmp eq i32 %435, %439
br i1 %440, label %441, label %463
441: ; preds = %431
%442 = load i32, i32* %18
%443 = load i32, i32* %20
%444 = sub nsw i32 %442, %443
%445 = srem i32 %444, 10
%446 = load i32, i32* %21
%447 = sext i32 %446 to i64
%448 = getelementptr inbounds [14 x i32], [14 x i32]* %12, i64 0, i64 %447
%449 = load i32, i32* %448
%450 = icmp eq i32 %445, %449
br i1 %450, label %451, label %463
451: ; preds = %441
%452 = load i32, i32* %18
%453 = load i32, i32* %20
%454 = sub nsw i32 %452, %453
%455 = sdiv i32 %454, 10
%456 = load i32, i32* %18
%457 = load i32, i32* %20
%458 = sub nsw i32 %456, %457
%459 = srem i32 %458, 10
%460 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.6, i64 0, i64 0), i32 %455, i32 %459)
%461 = load i32, i32* %19
%462 = add nsw i32 %461, 1
store i32 %462, i32* %19
store i32 1, i32* %25
br label %471
463: ; preds = %441, %431
%464 = load i32, i32* %21
%465 = icmp eq i32 %464, 13
br i1 %465, label %466, label %470
466: ; preds = %463
%467 = load i32, i32* %25
%468 = icmp eq i32 %467, 0
br i1 %468, label %469, label %470
469: ; preds = %466
store i32 60, i32* %20
br label %470
470: ; preds = %469, %466, %463
br label %471
471: ; preds = %470, %451
br label %472
472: ; preds = %471
%473 = load i32, i32* %21
%474 = add nsw i32 %473, 1
store i32 %474, i32* %21
br label %428
475: ; preds = %428
br label %476
476: ; preds = %475, %412
br label %477
477: ; preds = %476
%478 = load i32, i32* %20
%479 = add nsw i32 %478, 10
store i32 %479, i32* %20
br label %409
480: ; preds = %409
%481 = load i32, i32* %19
%482 = icmp eq i32 %481, 14
br i1 %482, label %483, label %487
483: ; preds = %480
%484 = load i32, i32* %15
%485 = add nsw i32 %484, 1
%486 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.7, i64 0, i64 0), i32 %485)
br label %487
487: ; preds = %483, %480
br label %488
488: ; preds = %487, %177, %169
br label %489
489: ; preds = %488
%490 = load i32, i32* %10
%491 = add nsw i32 %490, 1
store i32 %491, i32* %10
br label %166
492: ; preds = %166
%493 = load i32, i32* %17
%494 = sext i32 %493 to i64
%495 = getelementptr inbounds [100 x i32], [100 x i32]* %16, i64 0, i64 %494
store i32 2, i32* %495
br label %496
496: ; preds = %492
%497 = load i32, i32* %15
%498 = add nsw i32 %497, 1
store i32 %498, i32* %15
br label %148
499: ; preds = %148
ret i32 0
}

LLVM IR (-O2):
@.str = [9 x i8] c"navi.txt\00"
@.str.1 = [15 x i8] c"Opening.. %s \0A\00"
@__const.main.lettere = [14 x i32] [i32 2, i32 2, i32 2, i32 2, i32 2, i32 3, i32 4, i32 5, i32 6, i32 6, i32 7, i32 8, i32 10, i32 10]
@__const.main.numeri = [14 x i32] [i32 5, i32 6, i32 7, i32 8, i32 9, i32 3, i32 3, i32 3, i32 3, i32 7, i32 7, i32 7, i32 7, i32 8]
@.str.3 = [4 x i8] c"%d\09\00"
@.str.4 = [3 x i8] c"\0A \00"
@.str.5 = [21 x i8] c"c'hai preso! %d %d \0A\00"
@.str.6 = [23 x i8] c"c'hai ripreso! %d %d \0A\00"
@.str.7 = [5 x i8] c"%d \0A\00"
define i32 @main(i32 %0) {
%2 = alloca [10 x [10 x i32]]
%3 = bitcast [10 x [10 x i32]]* %2 to i8*
%4 = alloca [100 x i32]
%5 = bitcast [100 x i32]* %4 to i8*
%6 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0))
%7 = tail call i32 @putchar(i32 32)
br label %8
8: ; preds = %1, %43
%9 = phi i64 [ 0, %1 ], [ %44, %43 ]
br label %10
10: ; preds = %8, %40
%11 = phi i64 [ 0, %8 ], [ %41, %40 ]
%12 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %2, i64 0, i64 %9, i64 %11
br label %13
13: ; preds = %37, %10
%14 = phi i64 [ 0, %10 ], [ %38, %37 ]
%15 = getelementptr inbounds [14 x i32], [14 x i32]* @__const.main.lettere, i64 0, i64 %14
%16 = load i32, i32* %15
%17 = zext i32 %16 to i64
%18 = icmp eq i64 %9, %17
br i1 %18, label %19, label %25
19: ; preds = %13
%20 = getelementptr inbounds [14 x i32], [14 x i32]* @__const.main.numeri, i64 0, i64 %14
%21 = load i32, i32* %20
%22 = zext i32 %21 to i64
%23 = icmp eq i64 %11, %22
br i1 %23, label %24, label %25
24: ; preds = %19
store i32 1, i32* %12
br label %25
25: ; preds = %13, %19, %24
%26 = or i64 %14, 1
%27 = getelementptr inbounds [14 x i32], [14 x i32]* @__const.main.lettere, i64 0, i64 %26
%28 = load i32, i32* %27
%29 = zext i32 %28 to i64
%30 = icmp eq i64 %9, %29
br i1 %30, label %31, label %37
31: ; preds = %25
%32 = getelementptr inbounds [14 x i32], [14 x i32]* @__const.main.numeri, i64 0, i64 %26
%33 = load i32, i32* %32
%34 = zext i32 %33 to i64
%35 = icmp eq i64 %11, %34
br i1 %35, label %36, label %37
36: ; preds = %31
store i32 1, i32* %12
br label %37
37: ; preds = %36, %31, %25
%38 = add nuw nsw i64 %14, 2
%39 = icmp eq i64 %38, 14
br i1 %39, label %40, label %13
40: ; preds = %37
%41 = add nuw nsw i64 %11, 1
%42 = icmp eq i64 %41, 10
br i1 %42, label %43, label %10
43: ; preds = %40
%44 = add nuw nsw i64 %9, 1
%45 = icmp eq i64 %44, 10
br i1 %45, label %46, label %8
46: ; preds = %43, %46
%47 = phi i64 [ %79, %46 ], [ 0, %43 ]
%48 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %2, i64 0, i64 %47, i64 0
%49 = load i32, i32* %48
%50 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0), i32 %49)
%51 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %2, i64 0, i64 %47, i64 1
%52 = load i32, i32* %51
%53 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0), i32 %52)
%54 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %2, i64 0, i64 %47, i64 2
%55 = load i32, i32* %54
%56 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0), i32 %55)
%57 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %2, i64 0, i64 %47, i64 3
%58 = load i32, i32* %57
%59 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0), i32 %58)
%60 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %2, i64 0, i64 %47, i64 4
%61 = load i32, i32* %60
%62 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0), i32 %61)
%63 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %2, i64 0, i64 %47, i64 5
%64 = load i32, i32* %63
%65 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0), i32 %64)
%66 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %2, i64 0, i64 %47, i64 6
%67 = load i32, i32* %66
%68 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0), i32 %67)
%69 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %2, i64 0, i64 %47, i64 7
%70 = load i32, i32* %69
%71 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0), i32 %70)
%72 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %2, i64 0, i64 %47, i64 8
%73 = load i32, i32* %72
%74 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0), i32 %73)
%75 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %2, i64 0, i64 %47, i64 9
%76 = load i32, i32* %75
%77 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0), i32 %76)
%78 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i64 0, i64 0))
%79 = add nuw nsw i64 %47, 1
%80 = icmp eq i64 %79, 10
br i1 %80, label %81, label %46
81: ; preds = %46
%82 = tail call i32 @time(i32* null)
%83 = tail call i32 @srand(i32 %82)
%84 = tail call i32 (...) @rand()
%85 = tail call i32 (...) @rand()
%86 = tail call i32 @time(i32* null)
%87 = tail call i32 @srand(i32 %86)
br label %88
88: ; preds = %81, %329
%89 = phi i32 [ 0, %81 ], [ %326, %329 ]
%90 = phi i32 [ 1, %81 ], [ %102, %329 ]
%91 = phi i32 [ 1, %81 ], [ %101, %329 ]
%92 = phi i32 [ 0, %81 ], [ %331, %329 ]
%93 = sext i32 %91 to i64
%94 = getelementptr inbounds [100 x i32], [100 x i32]* %4, i64 0, i64 %93
%95 = load i32, i32* %94
%96 = icmp eq i32 %95, 2
br i1 %96, label %105, label %99
97: ; preds = %105
%98 = add nsw i32 %107, 10
br label %99
99: ; preds = %97, %88
%100 = phi i64 [ %109, %97 ], [ %93, %88 ]
%101 = phi i32 [ %108, %97 ], [ %91, %88 ]
%102 = phi i32 [ %98, %97 ], [ %90, %88 ]
%103 = sdiv i32 %102, 10
%104 = srem i32 %102, 10
br label %113
105: ; preds = %88, %105
%106 = tail call i32 (...) @rand()
%107 = srem i32 %106, 100
%108 = add nsw i32 %107, -1
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds [100 x i32], [100 x i32]* %4, i64 0, i64 %109
%111 = load i32, i32* %110
%112 = icmp eq i32 %111, 2
br i1 %112, label %105, label %97
113: ; preds = %99, %324
%114 = phi i64 [ 0, %99 ], [ %327, %324 ]
%115 = phi i32 [ %89, %99 ], [ %326, %324 ]
%116 = phi i32 [ %92, %99 ], [ %325, %324 ]
%117 = getelementptr inbounds [14 x i32], [14 x i32]* @__const.main.lettere, i64 0, i64 %114
%118 = load i32, i32* %117
%119 = icmp eq i32 %103, %118
br i1 %119, label %120, label %324
120: ; preds = %113
%121 = getelementptr inbounds [14 x i32], [14 x i32]* @__const.main.numeri, i64 0, i64 %114
%122 = load i32, i32* %121
%123 = icmp eq i32 %104, %122
br i1 %123, label %124, label %324
124: ; preds = %120
%125 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @.str.5, i64 0, i64 0), i32 %103, i32 %104)
%126 = add nsw i32 %115, 1
br label %127
127: ; preds = %124, %169
%128 = phi i32 [ 1, %124 ], [ %173, %169 ]
%129 = phi i32 [ %126, %124 ], [ %171, %169 ]
%130 = phi i32 [ %116, %124 ], [ %170, %169 ]
%131 = add nsw i32 %128, %101
%132 = sext i32 %131 to i64
%133 = getelementptr inbounds [100 x i32], [100 x i32]* %4, i64 0, i64 %132
%134 = load i32, i32* %133
%135 = icmp eq i32 %134, 2
br i1 %135, label %169, label %136
136: ; preds = %127
store i32 2, i32* %133
br label %137
137: ; preds = %136, %161
%138 = phi i64 [ 0, %136 ], [ %165, %161 ]
%139 = phi i32 [ 0, %136 ], [ %164, %161 ]
%140 = phi i32 [ %128, %136 ], [ %163, %161 ]
%141 = phi i32 [ %129, %136 ], [ %162, %161 ]
%142 = add nsw i32 %140, %102
%143 = sdiv i32 %142, 10
%144 = srem i32 %142, 10
%145 = getelementptr inbounds [14 x i32], [14 x i32]* @__const.main.lettere, i64 0, i64 %138
%146 = load i32, i32* %145
%147 = icmp eq i32 %143, %146
br i1 %147, label %148, label %155
148: ; preds = %137
%149 = getelementptr inbounds [14 x i32], [14 x i32]* @__const.main.numeri, i64 0, i64 %138
%150 = load i32, i32* %149
%151 = icmp eq i32 %144, %150
br i1 %151, label %152, label %155
152: ; preds = %148
%153 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([23 x i8], [23 x i8]* @.str.6, i64 0, i64 0), i32 %143, i32 %144)
%154 = add nsw i32 %141, 1
br label %161
155: ; preds = %148, %137
%156 = icmp eq i64 %138, 13
%157 = icmp eq i32 %139, 0
%158 = select i1 %156, i1 %157, i1 false
%159 = select i1 %158, i32 6, i32 %140
%160 = select i1 %158, i32 0, i32 %139
br label %161
161: ; preds = %155, %152
%162 = phi i32 [ %154, %152 ], [ %141, %155 ]
%163 = phi i32 [ %140, %152 ], [ %159, %155 ]
%164 = phi i32 [ 1, %152 ], [ %160, %155 ]
%165 = add nuw nsw i64 %138, 1
%166 = icmp eq i64 %165, 14
br i1 %166, label %167, label %137
167: ; preds = %161
%168 = add nsw i32 %130, 1
br label %169
169: ; preds = %167, %127
%170 = phi i32 [ %130, %127 ], [ %168, %167 ]
%171 = phi i32 [ %129, %127 ], [ %162, %167 ]
%172 = phi i32 [ %128, %127 ], [ %163, %167 ]
%173 = add nsw i32 %172, 1
%174 = icmp slt i32 %172, 5
br i1 %174, label %127, label %175
175: ; preds = %169, %217
%176 = phi i32 [ %221, %217 ], [ 1, %169 ]
%177 = phi i32 [ %219, %217 ], [ %171, %169 ]
%178 = phi i32 [ %218, %217 ], [ %170, %169 ]
%179 = sub nsw i32 %101, %176
%180 = sext i32 %179 to i64
%181 = getelementptr inbounds [100 x i32], [100 x i32]* %4, i64 0, i64 %180
%182 = load i32, i32* %181
%183 = icmp eq i32 %182, 2
br i1 %183, label %217, label %184
184: ; preds = %175
store i32 2, i32* %181
br label %185
185: ; preds = %184, %209
%186 = phi i64 [ 0, %184 ], [ %213, %209 ]
%187 = phi i32 [ 0, %184 ], [ %212, %209 ]
%188 = phi i32 [ %176, %184 ], [ %211, %209 ]
%189 = phi i32 [ %177, %184 ], [ %210, %209 ]
%190 = sub nsw i32 %102, %188
%191 = sdiv i32 %190, 10
%192 = srem i32 %190, 10
%193 = getelementptr inbounds [14 x i32], [14 x i32]* @__const.main.lettere, i64 0, i64 %186
%194 = load i32, i32* %193
%195 = icmp eq i32 %191, %194
br i1 %195, label %196, label %203
196: ; preds = %185
%197 = getelementptr inbounds [14 x i32], [14 x i32]* @__const.main.numeri, i64 0, i64 %186
%198 = load i32, i32* %197
%199 = icmp eq i32 %192, %198
br i1 %199, label %200, label %203
200: ; preds = %196
%201 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([23 x i8], [23 x i8]* @.str.6, i64 0, i64 0), i32 %191, i32 %192)
%202 = add nsw i32 %189, 1
br label %209
203: ; preds = %196, %185
%204 = icmp eq i64 %186, 13
%205 = icmp eq i32 %187, 0
%206 = select i1 %204, i1 %205, i1 false
%207 = select i1 %206, i32 6, i32 %188
%208 = select i1 %206, i32 0, i32 %187
br label %209
209: ; preds = %203, %200
%210 = phi i32 [ %202, %200 ], [ %189, %203 ]
%211 = phi i32 [ %188, %200 ], [ %207, %203 ]
%212 = phi i32 [ 1, %200 ], [ %208, %203 ]
%213 = add nuw nsw i64 %186, 1
%214 = icmp eq i64 %213, 14
br i1 %214, label %215, label %185
215: ; preds = %209
%216 = add nsw i32 %178, 1
br label %217
217: ; preds = %215, %175
%218 = phi i32 [ %178, %175 ], [ %216, %215 ]
%219 = phi i32 [ %177, %175 ], [ %210, %215 ]
%220 = phi i32 [ %176, %175 ], [ %211, %215 ]
%221 = add nsw i32 %220, 1
%222 = icmp slt i32 %220, 5
br i1 %222, label %175, label %223
223: ; preds = %217, %265
%224 = phi i32 [ %269, %265 ], [ 10, %217 ]
%225 = phi i32 [ %267, %265 ], [ %219, %217 ]
%226 = phi i32 [ %266, %265 ], [ %218, %217 ]
%227 = add nsw i32 %224, %101
%228 = sext i32 %227 to i64
%229 = getelementptr inbounds [100 x i32], [100 x i32]* %4, i64 0, i64 %228
%230 = load i32, i32* %229
%231 = icmp eq i32 %230, 2
br i1 %231, label %265, label %232
232: ; preds = %223
store i32 2, i32* %229
br label %233
233: ; preds = %232, %257
%234 = phi i64 [ 0, %232 ], [ %261, %257 ]
%235 = phi i32 [ 0, %232 ], [ %260, %257 ]
%236 = phi i32 [ %224, %232 ], [ %259, %257 ]
%237 = phi i32 [ %225, %232 ], [ %258, %257 ]
%238 = add nsw i32 %236, %102
%239 = sdiv i32 %238, 10
%240 = srem i32 %238, 10
%241 = getelementptr inbounds [14 x i32], [14 x i32]* @__const.main.lettere, i64 0, i64 %234
%242 = load i32, i32* %241
%243 = icmp eq i32 %239, %242
br i1 %243, label %244, label %251
244: ; preds = %233
%245 = getelementptr inbounds [14 x i32], [14 x i32]* @__const.main.numeri, i64 0, i64 %234
%246 = load i32, i32* %245
%247 = icmp eq i32 %240, %246
br i1 %247, label %248, label %251
248: ; preds = %244
%249 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([23 x i8], [23 x i8]* @.str.6, i64 0, i64 0), i32 %239, i32 %240)
%250 = add nsw i32 %237, 1
br label %257
251: ; preds = %244, %233
%252 = icmp eq i64 %234, 13
%253 = icmp eq i32 %235, 0
%254 = select i1 %252, i1 %253, i1 false
%255 = select i1 %254, i32 60, i32 %236
%256 = select i1 %254, i32 0, i32 %235
br label %257
257: ; preds = %251, %248
%258 = phi i32 [ %250, %248 ], [ %237, %251 ]
%259 = phi i32 [ %236, %248 ], [ %255, %251 ]
%260 = phi i32 [ 1, %248 ], [ %256, %251 ]
%261 = add nuw nsw i64 %234, 1
%262 = icmp eq i64 %261, 14
br i1 %262, label %263, label %233
263: ; preds = %257
%264 = add nsw i32 %226, 1
br label %265
265: ; preds = %263, %223
%266 = phi i32 [ %226, %223 ], [ %264, %263 ]
%267 = phi i32 [ %225, %223 ], [ %258, %263 ]
%268 = phi i32 [ %224, %223 ], [ %259, %263 ]
%269 = add nsw i32 %268, 10
%270 = icmp slt i32 %268, 50
br i1 %270, label %223, label %271
271: ; preds = %265, %313
%272 = phi i32 [ %317, %313 ], [ 10, %265 ]
%273 = phi i32 [ %315, %313 ], [ %267, %265 ]
%274 = phi i32 [ %314, %313 ], [ %266, %265 ]
%275 = sub nsw i32 %101, %272
%276 = sext i32 %275 to i64
%277 = getelementptr inbounds [100 x i32], [100 x i32]* %4, i64 0, i64 %276
%278 = load i32, i32* %277
%279 = icmp eq i32 %278, 2
br i1 %279, label %313, label %280
280: ; preds = %271
store i32 2, i32* %277
br label %281
281: ; preds = %280, %305
%282 = phi i64 [ 0, %280 ], [ %309, %305 ]
%283 = phi i32 [ 0, %280 ], [ %308, %305 ]
%284 = phi i32 [ %272, %280 ], [ %307, %305 ]
%285 = phi i32 [ %273, %280 ], [ %306, %305 ]
%286 = sub nsw i32 %102, %284
%287 = sdiv i32 %286, 10
%288 = srem i32 %286, 10
%289 = getelementptr inbounds [14 x i32], [14 x i32]* @__const.main.lettere, i64 0, i64 %282
%290 = load i32, i32* %289
%291 = icmp eq i32 %287, %290
br i1 %291, label %292, label %299
292: ; preds = %281
%293 = getelementptr inbounds [14 x i32], [14 x i32]* @__const.main.numeri, i64 0, i64 %282
%294 = load i32, i32* %293
%295 = icmp eq i32 %288, %294
br i1 %295, label %296, label %299
296: ; preds = %292
%297 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([23 x i8], [23 x i8]* @.str.6, i64 0, i64 0), i32 %287, i32 %288)
%298 = add nsw i32 %285, 1
br label %305
299: ; preds = %292, %281
%300 = icmp eq i64 %282, 13
%301 = icmp eq i32 %283, 0
%302 = select i1 %300, i1 %301, i1 false
%303 = select i1 %302, i32 60, i32 %284
%304 = select i1 %302, i32 0, i32 %283
br label %305
305: ; preds = %299, %296
%306 = phi i32 [ %298, %296 ], [ %285, %299 ]
%307 = phi i32 [ %284, %296 ], [ %303, %299 ]
%308 = phi i32 [ 1, %296 ], [ %304, %299 ]
%309 = add nuw nsw i64 %282, 1
%310 = icmp eq i64 %309, 14
br i1 %310, label %311, label %281
311: ; preds = %305
%312 = add nsw i32 %274, 1
br label %313
313: ; preds = %311, %271
%314 = phi i32 [ %274, %271 ], [ %312, %311 ]
%315 = phi i32 [ %273, %271 ], [ %306, %311 ]
%316 = phi i32 [ %272, %271 ], [ %307, %311 ]
%317 = add nsw i32 %316, 10
%318 = icmp slt i32 %316, 50
br i1 %318, label %271, label %319
319: ; preds = %313
%320 = icmp eq i32 %315, 14
br i1 %320, label %321, label %324
321: ; preds = %319
%322 = add nsw i32 %314, 1
%323 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.7, i64 0, i64 0), i32 %322)
br label %324
324: ; preds = %113, %120, %321, %319
%325 = phi i32 [ %314, %321 ], [ %314, %319 ], [ %116, %120 ], [ %116, %113 ]
%326 = phi i32 [ 14, %321 ], [ %315, %319 ], [ %115, %120 ], [ %115, %113 ]
%327 = add nuw nsw i64 %114, 1
%328 = icmp eq i64 %327, 14
br i1 %328, label %329, label %113
329: ; preds = %324
%330 = getelementptr inbounds [100 x i32], [100 x i32]* %4, i64 0, i64 %100
store i32 2, i32* %330
%331 = add nsw i32 %325, 1
%332 = icmp slt i32 %325, 99
br i1 %332, label %88, label %333
333: ; preds = %329
ret i32 0
}