#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();
char **ships(char **, int, int, int, int, char);
char **chck(char **matr, int m, int n, int dir, int cse, char nt) {
  int x, y, l, nbl;
  int u = 0, v = 0;
  int itn, itj;
  int cnt, seq = 0, seqc = 0;
  int vtn[10][10];
  int svt[10][10];
  int ind = 0, indm = 0, indv = 0, indc = 0;
  for (u = 0; u < 10; u++) {
    for (v = 0; v < 10; v++) {
      vtn[u][v] = v;
      svt[u][v] = 11;
    }
  }
  for (x = 0, nbl = 0; x < 10; nbl = 0, v = 0, x++) {
    for (y = 1; y < 10; y++) {
      if ((matr[x][y] == matr[x][y - 1]) && matr[x][y] == '-') {
        nbl++;
        vtn[x][v] = y - 1;
        v++;
      }
    }
    if (v == 0) {
      for (itn = x; itn < x + 1; itn++) {
        for (itj = 0; itj < 10; itj++) {
          vtn[itn][itj] = 11;
        }
      }
    }
  }
  if (dir == 0) {
    for (x = 0, seqc = 0; x < 10; seqc = 0, seq = 0, v = 0, ++x) {
      for (y = 1; y < 10; ++y) {
        if (vtn[x][y] - vtn[x][y - 1] == 1) {
          seq++;
          seqc++;
        } else {
          seq = 0;
        }
        if (seq >= cse - 1) {
          svt[x][v] = vtn[x][y - cse + 1];
          v++;
        }
        if (seq == 9) {
          for (itn = x; itn < x + 1; itn++) {
            for (itj = 0; itj < 10; itj++) {
              if (itj < 10 - cse + 1)
                svt[itn][itj] = itj;
              else
                svt[itn][itj] = 11;
            }
          }
        }
      }
      if (seqc == 0) {
        for (itn = x; itn < x + 1; itn++) {
          for (itj = 0; itj < 10; itj++) {
            svt[itn][itj] = 11;
          }
        }
      }
      for (l = 0; l < 10; ++l) {
      }
    }
    printf("\nmatriz de indicess\n");
    for (itn = 0; itn < 10; itn++) {
      printf("\n");
      for (itj = 0; itj < 10; itj++) {
        printf("%d ", svt[itn][itj]);
      }
    }
  } else if (dir == 1) {
    for (x = 0; x < 10; ++x) {
      v = 0, seq = 0, seqc = 0;
      for (y = 1; y < 10; ++y) {
        if ((vtn[y][x] == vtn[y - 1][x]) && vtn[y][x] != 11) {
          seq++;
          seqc++;
        } else {
          seq = 0;
        }
        if (seq >= cse - 1) {
          svt[v][x] = vtn[y - cse + 1][x];
          v++;
        }
        if (seq == 9) {
          for (itn = x; itn < x + 1; itn++) {
            for (itj = 0; itj < 10; itj++) {
              if (itj < 10 - cse + 1)
                svt[itj][itn] = itj;
              else
                svt[itj][itn] = 11;
            }
          }
        }
      }
      if (seqc == 0) {
        for (itn = x; itn < x + 1; itn++) {
          for (itj = 0; itj < 10; itj++) {
            svt[itj][itn] = 11;
          }
        }
      }
    }
    printf("\nmatriz de indices: \n");
    for (itn = 0; itn < 10; itn++) {
      printf("\n");
      for (itj = 0; itj < 10; itj++) {
        printf("%d ", svt[itn][itj]);
      }
    }
  }
  itn = 0;
  int def_line = 0;
  do {
    itn = 0;
    indc = 0;
    indm = rand() % 10;
    for (x = indm, indc = 0; x < indm + 1; ++x) {
      if (dir == 0) {
        for (y = 0; y < 10; ++y) {
          if (svt[x][y] != 11) {
            indc++;
            itn++;
            def_line = indm;
          }
        }
      } else {
        for (y = 0; y < 10; ++y) {
          if (svt[y][x] != 11) {
            indc++;
            itn++;
          }
        }
      }
    }
    indv = rand() % indc;
  } while ((matr[def_line][indv] != '-') ||
           (matr[def_line][indv + cse - 1] != '-'));
  if (dir == 0) {
    ind = svt[def_line][indv];
  } else {
    ind = svt[indv][def_line];
  }
  printf("\nIndice escolhido: (dir: %d, col. /lin. : %d, loct: %d)\n", dir,
         def_line, ind);
  matr = ships(matr, dir, def_line, ind, cse, nt);
  return matr;
}


x86 assembly (clang, -O0):
<chck>:
push   %rbp
mov    %rsp,%rbp
sub    $0x390,%rsp
mov    %r9b,%al
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8d,-0x18(%rbp)
mov    %al,-0x19(%rbp)
movl   $0x0,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
movl   $0x0,-0x44(%rbp)
movl   $0x0,-0x48(%rbp)
movl   $0x0,-0x374(%rbp)
movl   $0x0,-0x378(%rbp)
movl   $0x0,-0x37c(%rbp)
movl   $0x0,-0x380(%rbp)
movl   $0x0,-0x30(%rbp)
cmpl   $0xa,-0x30(%rbp)
jge    1212 <chck+0xe2>
movl   $0x0,-0x34(%rbp)
cmpl   $0xa,-0x34(%rbp)
jge    11ff <chck+0xcf>
mov    -0x34(%rbp),%edx
movslq -0x30(%rbp),%rcx
lea    -0x1e0(%rbp),%rax
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
movslq -0x30(%rbp),%rcx
lea    -0x370(%rbp),%rax
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
movl   $0xb,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11ae <chck+0x7e>
jmp    1204 <chck+0xd4>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    119d <chck+0x6d>
movl   $0x0,-0x20(%rbp)
movl   $0x0,-0x2c(%rbp)
cmpl   $0xa,-0x20(%rbp)
jge    1367 <chck+0x237>
movl   $0x1,-0x24(%rbp)
cmpl   $0xa,-0x24(%rbp)
jge    12d1 <chck+0x1a1>
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    -0x8(%rbp),%rcx
movslq -0x20(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jne    12be <chck+0x18e>
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2d,%eax
jne    12be <chck+0x18e>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
movslq -0x20(%rbp),%rcx
lea    -0x1e0(%rbp),%rax
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12c3 <chck+0x193>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1231 <chck+0x101>
cmpl   $0x0,-0x34(%rbp)
jne    1346 <chck+0x216>
mov    -0x20(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1341 <chck+0x211>
movl   $0x0,-0x3c(%rbp)
cmpl   $0xa,-0x3c(%rbp)
jge    132e <chck+0x1fe>
movslq -0x38(%rbp),%rcx
lea    -0x1e0(%rbp),%rax
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x3c(%rbp),%rcx
movl   $0xb,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    12f9 <chck+0x1c9>
jmp    1333 <chck+0x203>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    12e1 <chck+0x1b1>
jmp    1346 <chck+0x216>
jmp    134b <chck+0x21b>
movl   $0x0,-0x2c(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1220 <chck+0xf0>
cmpl   $0x0,-0x14(%rbp)
jne    165c <chck+0x52c>
movl   $0x0,-0x20(%rbp)
movl   $0x0,-0x48(%rbp)
cmpl   $0xa,-0x20(%rbp)
jge    15d1 <chck+0x4a1>
movl   $0x1,-0x24(%rbp)
cmpl   $0xa,-0x24(%rbp)
jge    1510 <chck+0x3e0>
movslq -0x20(%rbp),%rcx
lea    -0x1e0(%rbp),%rax
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
movslq -0x20(%rbp),%rdx
lea    -0x1e0(%rbp),%rcx
imul   $0x28,%rdx,%rdx
add    %rdx,%rcx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
sub    (%rcx,%rdx,4),%eax
cmp    $0x1,%eax
jne    13f1 <chck+0x2c1>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    13f8 <chck+0x2c8>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jl     144c <chck+0x31c>
movslq -0x20(%rbp),%rcx
lea    -0x1e0(%rbp),%rax
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
mov    -0x24(%rbp),%ecx
sub    -0x18(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
movslq -0x20(%rbp),%rcx
lea    -0x370(%rbp),%rax
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
cmpl   $0x9,-0x44(%rbp)
jne    14fd <chck+0x3cd>
mov    -0x20(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    14f8 <chck+0x3c8>
movl   $0x0,-0x3c(%rbp)
cmpl   $0xa,-0x3c(%rbp)
jge    14e5 <chck+0x3b5>
mov    -0x3c(%rbp),%eax
mov    $0xa,%ecx
sub    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    14b5 <chck+0x385>
mov    -0x3c(%rbp),%edx
movslq -0x38(%rbp),%rcx
lea    -0x370(%rbp),%rax
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x3c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    14d2 <chck+0x3a2>
movslq -0x38(%rbp),%rcx
lea    -0x370(%rbp),%rax
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x3c(%rbp),%rcx
movl   $0xb,(%rax,%rcx,4)
jmp    14d7 <chck+0x3a7>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1474 <chck+0x344>
jmp    14ea <chck+0x3ba>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    145c <chck+0x32c>
jmp    14fd <chck+0x3cd>
jmp    1502 <chck+0x3d2>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1390 <chck+0x260>
cmpl   $0x0,-0x48(%rbp)
jne    1585 <chck+0x455>
mov    -0x20(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1580 <chck+0x450>
movl   $0x0,-0x3c(%rbp)
cmpl   $0xa,-0x3c(%rbp)
jge    156d <chck+0x43d>
movslq -0x38(%rbp),%rcx
lea    -0x370(%rbp),%rax
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x3c(%rbp),%rcx
movl   $0xb,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1538 <chck+0x408>
jmp    1572 <chck+0x442>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1520 <chck+0x3f0>
jmp    1585 <chck+0x455>
movl   $0x0,-0x28(%rbp)
cmpl   $0xa,-0x28(%rbp)
jge    15a9 <chck+0x479>
jmp    159b <chck+0x46b>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    158c <chck+0x45c>
jmp    15ae <chck+0x47e>
movl   $0x0,-0x48(%rbp)
movl   $0x0,-0x44(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    137f <chck+0x24f>
lea    0xa28(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x38(%rbp)
cmpl   $0xa,-0x38(%rbp)
jge    1657 <chck+0x527>
lea    0xa36(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x3c(%rbp)
cmpl   $0xa,-0x3c(%rbp)
jge    1644 <chck+0x514>
movslq -0x38(%rbp),%rcx
lea    -0x370(%rbp),%rax
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
lea    0x9e6(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1605 <chck+0x4d5>
jmp    1649 <chck+0x519>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    15e6 <chck+0x4b6>
jmp    1948 <chck+0x818>
cmpl   $0x1,-0x14(%rbp)
jne    1943 <chck+0x813>
movl   $0x0,-0x20(%rbp)
cmpl   $0xa,-0x20(%rbp)
jge    18b8 <chck+0x788>
movl   $0x0,-0x34(%rbp)
movl   $0x0,-0x44(%rbp)
movl   $0x0,-0x48(%rbp)
movl   $0x1,-0x24(%rbp)
cmpl   $0xa,-0x24(%rbp)
jge    1830 <chck+0x700>
movslq -0x24(%rbp),%rcx
lea    -0x1e0(%rbp),%rax
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rdx
lea    -0x1e0(%rbp),%rcx
imul   $0x28,%rdx,%rdx
add    %rdx,%rcx
movslq -0x20(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jne    1711 <chck+0x5e1>
movslq -0x24(%rbp),%rcx
lea    -0x1e0(%rbp),%rax
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
cmpl   $0xb,(%rax,%rcx,4)
je     1711 <chck+0x5e1>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1718 <chck+0x5e8>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jl     176c <chck+0x63c>
mov    -0x24(%rbp),%eax
sub    -0x18(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x1e0(%rbp),%rax
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
movslq -0x34(%rbp),%rcx
lea    -0x370(%rbp),%rax
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
cmpl   $0x9,-0x44(%rbp)
jne    181d <chck+0x6ed>
mov    -0x20(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1818 <chck+0x6e8>
movl   $0x0,-0x3c(%rbp)
cmpl   $0xa,-0x3c(%rbp)
jge    1805 <chck+0x6d5>
mov    -0x3c(%rbp),%eax
mov    $0xa,%ecx
sub    -0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    17d5 <chck+0x6a5>
mov    -0x3c(%rbp),%edx
movslq -0x3c(%rbp),%rcx
lea    -0x370(%rbp),%rax
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    17f2 <chck+0x6c2>
movslq -0x3c(%rbp),%rcx
lea    -0x370(%rbp),%rax
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movl   $0xb,(%rax,%rcx,4)
jmp    17f7 <chck+0x6c7>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1794 <chck+0x664>
jmp    180a <chck+0x6da>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    177c <chck+0x64c>
jmp    181d <chck+0x6ed>
jmp    1822 <chck+0x6f2>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1693 <chck+0x563>
cmpl   $0x0,-0x48(%rbp)
jne    18a5 <chck+0x775>
mov    -0x20(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    18a0 <chck+0x770>
movl   $0x0,-0x3c(%rbp)
cmpl   $0xa,-0x3c(%rbp)
jge    188d <chck+0x75d>
movslq -0x3c(%rbp),%rcx
lea    -0x370(%rbp),%rax
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movl   $0xb,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1858 <chck+0x728>
jmp    1892 <chck+0x762>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1840 <chck+0x710>
jmp    18a5 <chck+0x775>
jmp    18aa <chck+0x77a>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    166d <chck+0x53d>
lea    0x75a(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x38(%rbp)
cmpl   $0xa,-0x38(%rbp)
jge    193e <chck+0x80e>
lea    0x74f(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x3c(%rbp)
cmpl   $0xa,-0x3c(%rbp)
jge    192b <chck+0x7fb>
movslq -0x38(%rbp),%rcx
lea    -0x370(%rbp),%rax
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
lea    0x6ff(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    18ec <chck+0x7bc>
jmp    1930 <chck+0x800>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    18cd <chck+0x79d>
jmp    1943 <chck+0x813>
jmp    1948 <chck+0x818>
movl   $0x0,-0x38(%rbp)
movl   $0x0,-0x384(%rbp)
movl   $0x0,-0x38(%rbp)
movl   $0x0,-0x380(%rbp)
mov    $0x0,%al
call   1050 <rand@plt>
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %edx,-0x378(%rbp)
mov    -0x378(%rbp),%eax
mov    %eax,-0x20(%rbp)
movl   $0x0,-0x380(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x378(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1a91 <chck+0x961>
cmpl   $0x0,-0x14(%rbp)
jne    1a1d <chck+0x8ed>
movl   $0x0,-0x24(%rbp)
cmpl   $0xa,-0x24(%rbp)
jge    1a18 <chck+0x8e8>
movslq -0x20(%rbp),%rcx
lea    -0x370(%rbp),%rax
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
cmpl   $0xb,(%rax,%rcx,4)
je     1a05 <chck+0x8d5>
mov    -0x380(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x380(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x378(%rbp),%eax
mov    %eax,-0x384(%rbp)
jmp    1a0a <chck+0x8da>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    19b7 <chck+0x887>
jmp    1a7e <chck+0x94e>
movl   $0x0,-0x24(%rbp)
cmpl   $0xa,-0x24(%rbp)
jge    1a79 <chck+0x949>
movslq -0x24(%rbp),%rcx
lea    -0x370(%rbp),%rax
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
cmpl   $0xb,(%rax,%rcx,4)
je     1a66 <chck+0x936>
mov    -0x380(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x380(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1a6b <chck+0x93b>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1a24 <chck+0x8f4>
jmp    1a7e <chck+0x94e>
jmp    1a83 <chck+0x953>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1992 <chck+0x862>
mov    $0x0,%al
call   1050 <rand@plt>
cltd
idivl  -0x380(%rbp)
mov    %edx,-0x37c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x384(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x37c(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
mov    $0x1,%al
cmp    $0x2d,%ecx
mov    %al,-0x385(%rbp)
jne    1afe <chck+0x9ce>
mov    -0x8(%rbp),%rax
movslq -0x384(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x37c(%rbp),%ecx
add    -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2d,%eax
setne  %al
mov    %al,-0x385(%rbp)
mov    -0x385(%rbp),%al
test   $0x1,%al
jne    1959 <chck+0x829>
cmpl   $0x0,-0x14(%rbp)
jne    1b40 <chck+0xa10>
movslq -0x384(%rbp),%rcx
lea    -0x370(%rbp),%rax
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x37c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x374(%rbp)
jmp    1b65 <chck+0xa35>
movslq -0x37c(%rbp),%rcx
lea    -0x370(%rbp),%rax
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x384(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x374(%rbp)
mov    -0x14(%rbp),%esi
mov    -0x384(%rbp),%edx
mov    -0x374(%rbp),%ecx
lea    0x4b4(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x384(%rbp),%edx
mov    -0x374(%rbp),%ecx
mov    -0x18(%rbp),%r8d
movsbl -0x19(%rbp),%r9d
call   1040 <ships@plt>
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x390,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<chck>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x3a8,%rsp
mov    %r9d,%r12d
mov    %r8d,%r15d
mov    %ecx,%r13d
mov    %rdi,0x20(%rsp)
mov    $0x24,%eax
movdqa 0xe84(%rip),%xmm0
movdqa 0xe8c(%rip),%xmm2
movdqa 0xe94(%rip),%xmm1
movabs $0x900000008,%rcx
movabs $0xb0000000b,%rbp
movdqu %xmm0,0x1ec(%rsp,%rax,1)
movdqu %xmm2,0x5c(%rsp,%rax,1)
movdqu %xmm1,0x1fc(%rsp,%rax,1)
movdqu %xmm2,0x6c(%rsp,%rax,1)
mov    %rcx,0x20c(%rsp,%rax,1)
mov    %rbp,0x7c(%rsp,%rax,1)
add    $0x28,%rax
cmp    $0x1b4,%rax
jne    11a0 <chck+0x50>
mov    $0xa,%esi
xor    %ecx,%ecx
mov    0x20(%rsp),%rdx
jmp    1207 <chck+0xb7>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x8,%rdx
add    $0x28,%rcx
xor    %esi,%esi
cmp    $0x190,%rcx
je     1391 <chck+0x241>
mov    (%rdx),%rdi
movzbl 0x1(%rdi),%eax
cmp    $0x2d,%al
jne    1231 <chck+0xe1>
cmpb   $0x2d,(%rdi)
jne    1231 <chck+0xe1>
mov    %esi,%eax
lea    (%rsp,%rax,4),%rax
add    $0x210,%rax
movl   $0x0,(%rcx,%rax,1)
or     $0x1,%esi
movzbl 0x1(%rdi),%eax
movzbl 0x2(%rdi),%ebx
cmp    $0x2d,%bl
jne    1258 <chck+0x108>
cmp    $0x2d,%al
jne    1258 <chck+0x108>
mov    %esi,%eax
lea    (%rsp,%rax,4),%rax
add    $0x210,%rax
movl   $0x1,(%rcx,%rax,1)
add    $0x1,%esi
movzbl 0x2(%rdi),%ebx
movzbl 0x3(%rdi),%eax
cmp    $0x2d,%al
jne    1280 <chck+0x130>
cmp    $0x2d,%bl
jne    1280 <chck+0x130>
movslq %esi,%rsi
lea    (%rsp,%rsi,4),%rax
add    $0x210,%rax
movl   $0x2,(%rcx,%rax,1)
add    $0x1,%esi
movzbl 0x3(%rdi),%eax
movzbl 0x4(%rdi),%ebx
cmp    $0x2d,%bl
jne    12a8 <chck+0x158>
cmp    $0x2d,%al
jne    12a8 <chck+0x158>
movslq %esi,%rsi
lea    (%rsp,%rsi,4),%rax
add    $0x210,%rax
movl   $0x3,(%rcx,%rax,1)
add    $0x1,%esi
movzbl 0x4(%rdi),%ebx
movzbl 0x5(%rdi),%eax
cmp    $0x2d,%al
jne    12d0 <chck+0x180>
cmp    $0x2d,%bl
jne    12d0 <chck+0x180>
movslq %esi,%rsi
lea    (%rsp,%rsi,4),%rax
add    $0x210,%rax
movl   $0x4,(%rcx,%rax,1)
add    $0x1,%esi
movzbl 0x5(%rdi),%eax
movzbl 0x6(%rdi),%ebx
cmp    $0x2d,%bl
jne    12f8 <chck+0x1a8>
cmp    $0x2d,%al
jne    12f8 <chck+0x1a8>
movslq %esi,%rsi
lea    (%rsp,%rsi,4),%rax
add    $0x210,%rax
movl   $0x5,(%rcx,%rax,1)
add    $0x1,%esi
movzbl 0x6(%rdi),%ebx
movzbl 0x7(%rdi),%eax
cmp    $0x2d,%al
jne    1320 <chck+0x1d0>
cmp    $0x2d,%bl
jne    1320 <chck+0x1d0>
movslq %esi,%rsi
lea    (%rsp,%rsi,4),%rax
add    $0x210,%rax
movl   $0x6,(%rcx,%rax,1)
add    $0x1,%esi
movzbl 0x7(%rdi),%eax
movzbl 0x8(%rdi),%ebx
cmp    $0x2d,%bl
jne    1348 <chck+0x1f8>
cmp    $0x2d,%al
jne    1348 <chck+0x1f8>
movslq %esi,%rsi
lea    (%rsp,%rsi,4),%rax
add    $0x210,%rax
movl   $0x7,(%rcx,%rax,1)
add    $0x1,%esi
movzbl 0x8(%rdi),%ebx
cmpb   $0x2d,0x9(%rdi)
jne    136a <chck+0x21a>
cmp    $0x2d,%bl
jne    136a <chck+0x21a>
movslq %esi,%rsi
lea    (%rsp,%rsi,4),%rax
add    $0x210,%rax
movl   $0x8,(%rcx,%rax,1)
add    $0x1,%esi
test   %esi,%esi
jne    11f0 <chck+0xa0>
movdqu %xmm2,0x210(%rsp,%rcx,1)
movdqu %xmm2,0x220(%rsp,%rcx,1)
mov    %rbp,0x230(%rsp,%rcx,1)
jmp    11f0 <chck+0xa0>
test   %r13d,%r13d
je     166d <chck+0x51d>
lea    -0x1(%r15),%eax
mov    %eax,0xc(%rsp)
cmp    $0x1,%r13d
jne    1ad9 <chck+0x989>
mov    %r12d,0x10(%rsp)
mov    %r13d,0x14(%rsp)
mov    $0xb,%r11d
sub    %r15d,%r11d
xor    %eax,%eax
cmp    $0xa,%r11d
setb   %al
lea    (%rax,%rax,1),%r8d
add    $0x9,%r8d
mov    $0x2,%r9d
mov    %r15,0x18(%rsp)
sub    %r15d,%r9d
lea    0x210(%rsp),%r14
xor    %r10d,%r10d
xor    %r13d,%r13d
jmp    140a <chck+0x2ba>
xchg   %ax,%ax
test   %edi,%edi
je     15f0 <chck+0x4a0>
add    $0x1,%r13
add    $0x4,%r14
cmp    $0xa,%r13
je     19ff <chck+0x8af>
mov    0x210(%rsp,%r13,4),%r12d
mov    $0x28,%ebp
mov    %r9d,%edx
xor    %edi,%edi
xor    %eax,%eax
xor    %r15d,%r15d
jmp    14b8 <chck+0x368>
movl   $0xb,0x80(%rsp,%r13,4)
movl   $0xb,0xa8(%rsp,%r13,4)
movl   $0xb,0xd0(%rsp,%r13,4)
movl   $0xb,0xf8(%rsp,%r13,4)
movl   $0xb,0x120(%rsp,%r13,4)
movl   $0xb,0x148(%rsp,%r13,4)
movl   $0xb,0x170(%rsp,%r13,4)
movl   $0xb,0x198(%rsp,%r13,4)
movl   $0xb,0x1c0(%rsp,%r13,4)
mov    $0xb,%esi
mov    %esi,0x1e8(%rsp,%r13,4)
movzbl %cl,%ecx
add    %ecx,%edi
add    $0x28,%rbp
add    $0x1,%edx
cmp    $0x190,%rbp
je     13f0 <chck+0x2a0>
mov    %r12d,%ecx
mov    (%r14,%rbp,1),%r12d
cmp    %ecx,%r12d
setne  %bl
cmp    $0xb,%r12d
sete   %cl
or     %bl,%cl
add    $0x1,%eax
test   %cl,%cl
cmovne %r10d,%eax
cmp    0xc(%rsp),%eax
jl     150d <chck+0x3bd>
movslq %edx,%rsi
lea    (%rsi,%rsi,4),%rsi
lea    (%rsp,%rsi,8),%rsi
add    $0x210,%rsi
mov    (%rsi,%r13,4),%esi
movslq %r15d,%r15
lea    (%r15,%r15,4),%rbx
lea    (%rsp,%rbx,8),%rbx
add    $0x80,%rbx
mov    %esi,(%rbx,%r13,4)
add    $0x1,%r15d
xor    $0x1,%cl
cmp    $0x9,%eax
jne    149f <chck+0x34f>
test   %r11d,%r11d
jle    1426 <chck+0x2d6>
movl   $0x0,0x80(%rsp,%r13,4)
cmp    $0x1,%r11d
jbe    1432 <chck+0x2e2>
movl   $0x1,0xa8(%rsp,%r13,4)
cmp    $0x2,%r11d
jbe    143e <chck+0x2ee>
movl   $0x2,0xd0(%rsp,%r13,4)
cmp    $0x3,%r11d
jbe    144a <chck+0x2fa>
movl   $0x3,0xf8(%rsp,%r13,4)
cmp    $0x4,%r11d
jbe    1456 <chck+0x306>
movl   $0x4,0x120(%rsp,%r13,4)
cmp    $0x5,%r11d
jbe    1462 <chck+0x312>
movl   $0x5,0x148(%rsp,%r13,4)
cmp    $0x6,%r11d
jbe    146e <chck+0x31e>
movl   $0x6,0x170(%rsp,%r13,4)
cmp    $0x7,%r11d
jbe    147a <chck+0x32a>
movl   $0x7,0x198(%rsp,%r13,4)
cmp    $0x8,%r11d
jbe    1486 <chck+0x336>
movl   $0x8,0x1c0(%rsp,%r13,4)
mov    %r8d,%esi
jmp    1497 <chck+0x347>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movl   $0xb,0x80(%rsp,%r13,4)
movl   $0xb,0xa8(%rsp,%r13,4)
movl   $0xb,0xd0(%rsp,%r13,4)
movl   $0xb,0xf8(%rsp,%r13,4)
movl   $0xb,0x120(%rsp,%r13,4)
movl   $0xb,0x148(%rsp,%r13,4)
movl   $0xb,0x170(%rsp,%r13,4)
movl   $0xb,0x198(%rsp,%r13,4)
movl   $0xb,0x1c0(%rsp,%r13,4)
movl   $0xb,0x1e8(%rsp,%r13,4)
jmp    13f8 <chck+0x2a8>
mov    %r12d,0x10(%rsp)
mov    %r13d,0x14(%rsp)
lea    -0x1(%r15),%eax
mov    %eax,0xc(%rsp)
mov    $0xb,%r11d
sub    %r15d,%r11d
xor    %eax,%eax
cmp    $0xa,%r11d
setb   %al
lea    0x9(%rax,%rax,1),%eax
mov    %eax,0x2c(%rsp)
lea    0x214(%rsp),%rsi
mov    $0x2,%eax
mov    %r15,0x18(%rsp)
sub    %r15d,%eax
mov    %rax,0x78(%rsp)
xor    %ecx,%ecx
xor    %edi,%edi
jmp    16ea <chck+0x59a>
nopl   0x0(%rax)
test   %r14d,%r14d
movabs $0xb0000000b,%rdx
mov    0x70(%rsp),%rdi
je     1790 <chck+0x640>
add    $0x1,%rdi
add    $0x28,%rsi
cmp    $0xa,%rdi
je     1932 <chck+0x7e2>
mov    %rdi,0x70(%rsp)
lea    0x0(,%rdi,8),%rax
lea    (%rax,%rax,4),%rax
mov    0x210(%rsp,%rax,1),%r10d
lea    (%rsp,%rax,1),%rdx
add    $0x80,%rdx
mov    %rdx,%rdi
or     $0x4,%rdi
mov    %rdi,0x48(%rsp)
lea    (%rsp,%rax,1),%rdi
add    $0x88,%rdi
mov    %rdi,0x30(%rsp)
lea    0x8c(%rsp,%rax,1),%rdi
mov    %rdi,0x40(%rsp)
lea    0x90(%rsp,%rax,1),%rdi
mov    %rdi,0x38(%rsp)
lea    0x94(%rsp,%rax,1),%rdi
mov    %rdi,0x60(%rsp)
lea    0x98(%rsp,%rax,1),%rdi
mov    %rdi,0x58(%rsp)
lea    0x9c(%rsp,%rax,1),%rdi
mov    %rdi,0x68(%rsp)
lea    (%rsp,%rax,1),%rdi
add    $0xa0,%rdi
mov    %rdi,0x50(%rsp)
xor    %r15d,%r15d
xor    %r14d,%r14d
xor    %ebx,%ebx
xor    %r8d,%r8d
jmp    17ea <chck+0x69a>
nopl   0x0(%rax,%rax,1)
lea    (%rdi,%rdi,4),%rax
movdqu %xmm2,0x80(%rsp,%rax,8)
movdqu %xmm2,0x90(%rsp,%rax,8)
mov    %rdx,0xa0(%rsp,%rax,8)
jmp    16d8 <chck+0x588>
mov    0x50(%rsp),%rcx
movl   $0x8,(%rcx)
mov    0x2c(%rsp),%r13d
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r13d,0x24(%rdx)
xor    %ecx,%ecx
mov    %r12b,%r9b
add    %r9d,%r14d
add    $0x1,%r15
cmp    $0x9,%r15
je     16c0 <chck+0x570>
mov    %r10d,%edi
mov    (%rsi,%r15,4),%r10d
mov    %r10d,%ebp
sub    %edi,%ebp
add    $0x1,%ebx
xor    %r9d,%r9d
cmp    $0x1,%ebp
sete   %r12b
cmovne %ecx,%ebx
cmp    0xc(%rsp),%ebx
jl     182e <chck+0x6de>
mov    0x78(%rsp),%rdi
add    %r15d,%edi
movslq %edi,%rdi
lea    0x210(%rsp,%rax,1),%rbp
mov    0x0(%rbp,%rdi,4),%edi
movslq %r8d,%r8
mov    %edi,(%rdx,%r8,4)
add    $0x1,%r8d
cmp    $0x9,%ebx
jne    17d6 <chck+0x686>
test   %r11d,%r11d
jle    18c9 <chck+0x779>
movl   $0x0,(%rdx)
cmp    $0x1,%r11d
jbe    18cf <chck+0x77f>
mov    0x48(%rsp),%rcx
movl   $0x1,(%rcx)
cmp    $0x2,%r11d
jbe    18da <chck+0x78a>
mov    0x30(%rsp),%rcx
movl   $0x2,(%rcx)
cmp    $0x3,%r11d
jbe    18e5 <chck+0x795>
mov    0x40(%rsp),%rcx
movl   $0x3,(%rcx)
cmp    $0x4,%r11d
jbe    18f0 <chck+0x7a0>
mov    0x38(%rsp),%rcx
movl   $0x4,(%rcx)
cmp    $0x5,%r11d
jbe    18fb <chck+0x7ab>
mov    0x60(%rsp),%rcx
movl   $0x5,(%rcx)
cmp    $0x6,%r11d
jbe    1906 <chck+0x7b6>
mov    0x58(%rsp),%rcx
movl   $0x6,(%rcx)
cmp    $0x7,%r11d
jbe    1911 <chck+0x7c1>
mov    0x68(%rsp),%rcx
movl   $0x7,(%rcx)
cmp    $0x8,%r11d
ja     17b3 <chck+0x663>
jmp    191c <chck+0x7cc>
movl   $0xb,(%rdx)
mov    0x48(%rsp),%rcx
movl   $0xb,(%rcx)
mov    0x30(%rsp),%rcx
movl   $0xb,(%rcx)
mov    0x40(%rsp),%rcx
movl   $0xb,(%rcx)
mov    0x38(%rsp),%rcx
movl   $0xb,(%rcx)
mov    0x60(%rsp),%rcx
movl   $0xb,(%rcx)
mov    0x58(%rsp),%rcx
movl   $0xb,(%rcx)
mov    0x68(%rsp),%rcx
movl   $0xb,(%rcx)
mov    0x50(%rsp),%rcx
movl   $0xb,(%rcx)
mov    $0xb,%r13d
jmp    17d0 <chck+0x680>
lea    0x749(%rip),%rdi
call   1040 <puts@plt>
mov    $0x24,%ebp
lea    0x6e6(%rip),%rbx
nopw   0x0(%rax,%rax,1)
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0x5c(%rsp,%rbp,1),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x60(%rsp,%rbp,1),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x64(%rsp,%rbp,1),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x68(%rsp,%rbp,1),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x6c(%rsp,%rbp,1),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x70(%rsp,%rbp,1),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x74(%rsp,%rbp,1),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x78(%rsp,%rbp,1),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x7c(%rsp,%rbp,1),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x80(%rsp,%rbp,1),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
add    $0x28,%rbp
cmp    $0x1b4,%rbp
jne    1950 <chck+0x800>
jmp    1aca <chck+0x97a>
lea    0x667(%rip),%rdi
call   1040 <puts@plt>
mov    $0x24,%ebp
lea    0x619(%rip),%rbx
nopw   0x0(%rax,%rax,1)
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0x5c(%rsp,%rbp,1),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x60(%rsp,%rbp,1),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x64(%rsp,%rbp,1),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x68(%rsp,%rbp,1),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x6c(%rsp,%rbp,1),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x70(%rsp,%rbp,1),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x74(%rsp,%rbp,1),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x78(%rsp,%rbp,1),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x7c(%rsp,%rbp,1),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x80(%rsp,%rbp,1),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
add    $0x28,%rbp
cmp    $0x1b4,%rbp
jne    1a20 <chck+0x8d0>
mov    0x18(%rsp),%r15
mov    0x14(%rsp),%r13d
mov    0x10(%rsp),%r12d
xor    %r14d,%r14d
nopl   0x0(%rax)
xor    %eax,%eax
call   1070 <rand@plt>
cltq
imul   $0x66666667,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x22,%rcx
add    %edx,%ecx
add    %ecx,%ecx
lea    (%rcx,%rcx,4),%ecx
sub    %ecx,%eax
cltq
test   %r13d,%r13d
je     1bb0 <chck+0xa60>
xor    %ecx,%ecx
cmpl   $0xb,0x80(%rsp,%rax,4)
0b
setne  %cl
xor    %edx,%edx
cmpl   $0xb,0xa8(%rsp,%rax,4)
0b
setne  %dl
add    %ecx,%edx
xor    %ecx,%ecx
cmpl   $0xb,0xd0(%rsp,%rax,4)
0b
setne  %cl
add    %edx,%ecx
xor    %edx,%edx
cmpl   $0xb,0xf8(%rsp,%rax,4)
0b
setne  %dl
add    %ecx,%edx
xor    %ecx,%ecx
cmpl   $0xb,0x120(%rsp,%rax,4)
0b
setne  %cl
add    %edx,%ecx
xor    %edx,%edx
cmpl   $0xb,0x148(%rsp,%rax,4)
0b
setne  %dl
add    %ecx,%edx
xor    %ecx,%ecx
cmpl   $0xb,0x170(%rsp,%rax,4)
0b
setne  %cl
add    %edx,%ecx
xor    %edx,%edx
cmpl   $0xb,0x198(%rsp,%rax,4)
0b
setne  %dl
add    %ecx,%edx
xor    %ecx,%ecx
cmpl   $0xb,0x1c0(%rsp,%rax,4)
0b
setne  %cl
add    %edx,%ecx
xor    %ebx,%ebx
cmpl   $0xb,0x1e8(%rsp,%rax,4)
0b
setne  %bl
add    %ecx,%ebx
jmp    1c53 <chck+0xb03>
nopl   0x0(%rax,%rax,1)
lea    (%rax,%rax,4),%rcx
movdqu 0x80(%rsp,%rcx,8),%xmm1
movdqu 0x90(%rsp,%rcx,8),%xmm2
movdqa 0x442(%rip),%xmm0
pcmpeqd %xmm0,%xmm2
pcmpeqd %xmm0,%xmm1
movdqa %xmm1,%xmm0
packssdw %xmm2,%xmm0
pcmpeqd %xmm3,%xmm3
pxor   %xmm3,%xmm2
pxor   %xmm3,%xmm1
packssdw %xmm2,%xmm1
packsswb %xmm1,%xmm1
pmovmskb %xmm1,%edx
mov    %edx,%ebx
shr    %bl
and    $0x55,%bl
sub    %bl,%dl
mov    %edx,%ebx
and    $0x33,%bl
shr    $0x2,%dl
and    $0x33,%dl
add    %bl,%dl
mov    %edx,%ebx
shr    $0x4,%bl
add    %dl,%bl
and    $0xf,%bl
xor    %edx,%edx
cmpl   $0xb,0xa0(%rsp,%rcx,8)
0b
setne  %dl
movzbl %bl,%esi
cmovne %eax,%r14d
add    %edx,%esi
xor    %ebx,%ebx
cmpl   $0xb,0xa4(%rsp,%rcx,8)
0b
cmovne %eax,%r14d
setne  %bl
add    %esi,%ebx
psllw  $0xf,%xmm0
packsswb %xmm0,%xmm0
pmovmskb %xmm0,%ecx
cmp    $0xff,%cl
cmovne %eax,%r14d
xor    %eax,%eax
call   1070 <rand@plt>
cltd
idiv   %ebx
movslq %r14d,%rbx
mov    0x20(%rsp),%rax
mov    (%rax,%rbx,8),%rcx
movslq %edx,%rax
cmpb   $0x2d,(%rcx,%rax,1)
jne    1ae0 <chck+0x990>
add    0xc(%rsp),%edx
movslq %edx,%rdx
cmpb   $0x2d,(%rcx,%rdx,1)
jne    1ae0 <chck+0x990>
test   %r13d,%r13d
lea    (%rbx,%rbx,4),%rcx
lea    0x80(%rsp,%rcx,8),%rcx
lea    (%rcx,%rax,4),%rcx
lea    (%rax,%rax,4),%rax
lea    0x80(%rsp,%rax,8),%rax
lea    (%rax,%rbx,4),%rax
cmove  %rcx,%rax
mov    (%rax),%r14d
lea    0x37c(%rip),%rdi
mov    %r13d,%esi
mov    %ebx,%edx
mov    %r14d,%ecx
xor    %eax,%eax
call   1050 <printf@plt>
movsbl %r12b,%r9d
mov    0x20(%rsp),%rdi
mov    %r13d,%esi
mov    %ebx,%edx
mov    %r14d,%ecx
mov    %r15d,%r8d
add    $0x3a8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1060 <ships@plt>

LLVM IR (-O0):
@.str = [21 x i8] c"\0Amatriz de indicess\0A\00"
@.str.1 = [2 x i8] c"\0A\00"
@.str.2 = [4 x i8] c"%d \00"
@.str.3 = [22 x i8] c"\0Amatriz de indices: \0A\00"
@.str.4 = [57 x i8] c"\0AIndice escolhido: (dir: %d, col. /lin. : %d, loct: %d)\0A\00"
define i8** @chck(i8** %0, i32 %1, i32 %2, i32 %3, i32 %4, i8 signext %5) {
%7 = alloca i8**
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i8
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
%24 = alloca [10 x [10 x i32]]
%25 = alloca [10 x [10 x i32]]
%26 = alloca i32
%27 = alloca i32
%28 = alloca i32
%29 = alloca i32
%30 = alloca i32
store i8** %0, i8*** %7
store i32 %1, i32* %8
store i32 %2, i32* %9
store i32 %3, i32* %10
store i32 %4, i32* %11
store i8 %5, i8* %12
store i32 0, i32* %17
store i32 0, i32* %18
store i32 0, i32* %22
store i32 0, i32* %23
store i32 0, i32* %26
store i32 0, i32* %27
store i32 0, i32* %28
store i32 0, i32* %29
store i32 0, i32* %17
br label %31
31: ; preds = %56, %6
%32 = load i32, i32* %17
%33 = icmp slt i32 %32, 10
br i1 %33, label %34, label %59
34: ; preds = %31
store i32 0, i32* %18
br label %35
35: ; preds = %52, %34
%36 = load i32, i32* %18
%37 = icmp slt i32 %36, 10
br i1 %37, label %38, label %55
38: ; preds = %35
%39 = load i32, i32* %18
%40 = load i32, i32* %17
%41 = sext i32 %40 to i64
%42 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %24, i64 0, i64 %41
%43 = load i32, i32* %18
%44 = sext i32 %43 to i64
%45 = getelementptr inbounds [10 x i32], [10 x i32]* %42, i64 0, i64 %44
store i32 %39, i32* %45
%46 = load i32, i32* %17
%47 = sext i32 %46 to i64
%48 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %25, i64 0, i64 %47
%49 = load i32, i32* %18
%50 = sext i32 %49 to i64
%51 = getelementptr inbounds [10 x i32], [10 x i32]* %48, i64 0, i64 %50
store i32 11, i32* %51
br label %52
52: ; preds = %38
%53 = load i32, i32* %18
%54 = add nsw i32 %53, 1
store i32 %54, i32* %18
br label %35
55: ; preds = %35
br label %56
56: ; preds = %55
%57 = load i32, i32* %17
%58 = add nsw i32 %57, 1
store i32 %58, i32* %17
br label %31
59: ; preds = %31
store i32 0, i32* %13
store i32 0, i32* %16
br label %60
60: ; preds = %149, %59
%61 = load i32, i32* %13
%62 = icmp slt i32 %61, 10
br i1 %62, label %63, label %152
63: ; preds = %60
store i32 1, i32* %14
br label %64
64: ; preds = %116, %63
%65 = load i32, i32* %14
%66 = icmp slt i32 %65, 10
br i1 %66, label %67, label %119
67: ; preds = %64
%68 = load i8**, i8*** %7
%69 = load i32, i32* %13
%70 = sext i32 %69 to i64
%71 = getelementptr inbounds i8*, i8** %68, i64 %70
%72 = load i8*, i8** %71
%73 = load i32, i32* %14
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds i8, i8* %72, i64 %74
%76 = load i8, i8* %75
%77 = sext i8 %76 to i32
%78 = load i8**, i8*** %7
%79 = load i32, i32* %13
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds i8*, i8** %78, i64 %80
%82 = load i8*, i8** %81
%83 = load i32, i32* %14
%84 = sub nsw i32 %83, 1
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds i8, i8* %82, i64 %85
%87 = load i8, i8* %86
%88 = sext i8 %87 to i32
%89 = icmp eq i32 %77, %88
br i1 %89, label %90, label %115
90: ; preds = %67
%91 = load i8**, i8*** %7
%92 = load i32, i32* %13
%93 = sext i32 %92 to i64
%94 = getelementptr inbounds i8*, i8** %91, i64 %93
%95 = load i8*, i8** %94
%96 = load i32, i32* %14
%97 = sext i32 %96 to i64
%98 = getelementptr inbounds i8, i8* %95, i64 %97
%99 = load i8, i8* %98
%100 = sext i8 %99 to i32
%101 = icmp eq i32 %100, 45
br i1 %101, label %102, label %115
102: ; preds = %90
%103 = load i32, i32* %16
%104 = add nsw i32 %103, 1
store i32 %104, i32* %16
%105 = load i32, i32* %14
%106 = sub nsw i32 %105, 1
%107 = load i32, i32* %13
%108 = sext i32 %107 to i64
%109 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %24, i64 0, i64 %108
%110 = load i32, i32* %18
%111 = sext i32 %110 to i64
%112 = getelementptr inbounds [10 x i32], [10 x i32]* %109, i64 0, i64 %111
store i32 %106, i32* %112
%113 = load i32, i32* %18
%114 = add nsw i32 %113, 1
store i32 %114, i32* %18
br label %115
115: ; preds = %102, %90, %67
br label %116
116: ; preds = %115
%117 = load i32, i32* %14
%118 = add nsw i32 %117, 1
store i32 %118, i32* %14
br label %64
119: ; preds = %64
%120 = load i32, i32* %18
%121 = icmp eq i32 %120, 0
br i1 %121, label %122, label %148
122: ; preds = %119
%123 = load i32, i32* %13
store i32 %123, i32* %19
br label %124
124: ; preds = %144, %122
%125 = load i32, i32* %19
%126 = load i32, i32* %13
%127 = add nsw i32 %126, 1
%128 = icmp slt i32 %125, %127
br i1 %128, label %129, label %147
129: ; preds = %124
store i32 0, i32* %20
br label %130
130: ; preds = %140, %129
%131 = load i32, i32* %20
%132 = icmp slt i32 %131, 10
br i1 %132, label %133, label %143
133: ; preds = %130
%134 = load i32, i32* %19
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %24, i64 0, i64 %135
%137 = load i32, i32* %20
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds [10 x i32], [10 x i32]* %136, i64 0, i64 %138
store i32 11, i32* %139
br label %140
140: ; preds = %133
%141 = load i32, i32* %20
%142 = add nsw i32 %141, 1
store i32 %142, i32* %20
br label %130
143: ; preds = %130
br label %144
144: ; preds = %143
%145 = load i32, i32* %19
%146 = add nsw i32 %145, 1
store i32 %146, i32* %19
br label %124
147: ; preds = %124
br label %148
148: ; preds = %147, %119
br label %149
149: ; preds = %148
store i32 0, i32* %16
store i32 0, i32* %18
%150 = load i32, i32* %13
%151 = add nsw i32 %150, 1
store i32 %151, i32* %13
br label %60
152: ; preds = %60
%153 = load i32, i32* %10
%154 = icmp eq i32 %153, 0
br i1 %154, label %155, label %327
155: ; preds = %152
store i32 0, i32* %13
store i32 0, i32* %23
br label %156
156: ; preds = %297, %155
%157 = load i32, i32* %13
%158 = icmp slt i32 %157, 10
br i1 %158, label %159, label %300
159: ; preds = %156
store i32 1, i32* %14
br label %160
160: ; preds = %256, %159
%161 = load i32, i32* %14
%162 = icmp slt i32 %161, 10
br i1 %162, label %163, label %259
163: ; preds = %160
%164 = load i32, i32* %13
%165 = sext i32 %164 to i64
%166 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %24, i64 0, i64 %165
%167 = load i32, i32* %14
%168 = sext i32 %167 to i64
%169 = getelementptr inbounds [10 x i32], [10 x i32]* %166, i64 0, i64 %168
%170 = load i32, i32* %169
%171 = load i32, i32* %13
%172 = sext i32 %171 to i64
%173 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %24, i64 0, i64 %172
%174 = load i32, i32* %14
%175 = sub nsw i32 %174, 1
%176 = sext i32 %175 to i64
%177 = getelementptr inbounds [10 x i32], [10 x i32]* %173, i64 0, i64 %176
%178 = load i32, i32* %177
%179 = sub nsw i32 %170, %178
%180 = icmp eq i32 %179, 1
br i1 %180, label %181, label %186
181: ; preds = %163
%182 = load i32, i32* %22
%183 = add nsw i32 %182, 1
store i32 %183, i32* %22
%184 = load i32, i32* %23
%185 = add nsw i32 %184, 1
store i32 %185, i32* %23
br label %187
186: ; preds = %163
store i32 0, i32* %22
br label %187
187: ; preds = %186, %181
%188 = load i32, i32* %22
%189 = load i32, i32* %11
%190 = sub nsw i32 %189, 1
%191 = icmp sge i32 %188, %190
br i1 %191, label %192, label %211
192: ; preds = %187
%193 = load i32, i32* %13
%194 = sext i32 %193 to i64
%195 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %24, i64 0, i64 %194
%196 = load i32, i32* %14
%197 = load i32, i32* %11
%198 = sub nsw i32 %196, %197
%199 = add nsw i32 %198, 1
%200 = sext i32 %199 to i64
%201 = getelementptr inbounds [10 x i32], [10 x i32]* %195, i64 0, i64 %200
%202 = load i32, i32* %201
%203 = load i32, i32* %13
%204 = sext i32 %203 to i64
%205 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %25, i64 0, i64 %204
%206 = load i32, i32* %18
%207 = sext i32 %206 to i64
%208 = getelementptr inbounds [10 x i32], [10 x i32]* %205, i64 0, i64 %207
store i32 %202, i32* %208
%209 = load i32, i32* %18
%210 = add nsw i32 %209, 1
store i32 %210, i32* %18
br label %211
211: ; preds = %192, %187
%212 = load i32, i32* %22
%213 = icmp eq i32 %212, 9
br i1 %213, label %214, label %255
214: ; preds = %211
%215 = load i32, i32* %13
store i32 %215, i32* %19
br label %216
216: ; preds = %251, %214
%217 = load i32, i32* %19
%218 = load i32, i32* %13
%219 = add nsw i32 %218, 1
%220 = icmp slt i32 %217, %219
br i1 %220, label %221, label %254
221: ; preds = %216
store i32 0, i32* %20
br label %222
222: ; preds = %247, %221
%223 = load i32, i32* %20
%224 = icmp slt i32 %223, 10
br i1 %224, label %225, label %250
225: ; preds = %222
%226 = load i32, i32* %20
%227 = load i32, i32* %11
%228 = sub nsw i32 10, %227
%229 = add nsw i32 %228, 1
%230 = icmp slt i32 %226, %229
br i1 %230, label %231, label %239
231: ; preds = %225
%232 = load i32, i32* %20
%233 = load i32, i32* %19
%234 = sext i32 %233 to i64
%235 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %25, i64 0, i64 %234
%236 = load i32, i32* %20
%237 = sext i32 %236 to i64
%238 = getelementptr inbounds [10 x i32], [10 x i32]* %235, i64 0, i64 %237
store i32 %232, i32* %238
br label %246
239: ; preds = %225
%240 = load i32, i32* %19
%241 = sext i32 %240 to i64
%242 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %25, i64 0, i64 %241
%243 = load i32, i32* %20
%244 = sext i32 %243 to i64
%245 = getelementptr inbounds [10 x i32], [10 x i32]* %242, i64 0, i64 %244
store i32 11, i32* %245
br label %246
246: ; preds = %239, %231
br label %247
247: ; preds = %246
%248 = load i32, i32* %20
%249 = add nsw i32 %248, 1
store i32 %249, i32* %20
br label %222
250: ; preds = %222
br label %251
251: ; preds = %250
%252 = load i32, i32* %19
%253 = add nsw i32 %252, 1
store i32 %253, i32* %19
br label %216
254: ; preds = %216
br label %255
255: ; preds = %254, %211
br label %256
256: ; preds = %255
%257 = load i32, i32* %14
%258 = add nsw i32 %257, 1
store i32 %258, i32* %14
br label %160
259: ; preds = %160
%260 = load i32, i32* %23
%261 = icmp eq i32 %260, 0
br i1 %261, label %262, label %288
262: ; preds = %259
%263 = load i32, i32* %13
store i32 %263, i32* %19
br label %264
264: ; preds = %284, %262
%265 = load i32, i32* %19
%266 = load i32, i32* %13
%267 = add nsw i32 %266, 1
%268 = icmp slt i32 %265, %267
br i1 %268, label %269, label %287
269: ; preds = %264
store i32 0, i32* %20
br label %270
270: ; preds = %280, %269
%271 = load i32, i32* %20
%272 = icmp slt i32 %271, 10
br i1 %272, label %273, label %283
273: ; preds = %270
%274 = load i32, i32* %19
%275 = sext i32 %274 to i64
%276 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %25, i64 0, i64 %275
%277 = load i32, i32* %20
%278 = sext i32 %277 to i64
%279 = getelementptr inbounds [10 x i32], [10 x i32]* %276, i64 0, i64 %278
store i32 11, i32* %279
br label %280
280: ; preds = %273
%281 = load i32, i32* %20
%282 = add nsw i32 %281, 1
store i32 %282, i32* %20
br label %270
283: ; preds = %270
br label %284
284: ; preds = %283
%285 = load i32, i32* %19
%286 = add nsw i32 %285, 1
store i32 %286, i32* %19
br label %264
287: ; preds = %264
br label %288
288: ; preds = %287, %259
store i32 0, i32* %15
br label %289
289: ; preds = %293, %288
%290 = load i32, i32* %15
%291 = icmp slt i32 %290, 10
br i1 %291, label %292, label %296
292: ; preds = %289
br label %293
293: ; preds = %292
%294 = load i32, i32* %15
%295 = add nsw i32 %294, 1
store i32 %295, i32* %15
br label %289
296: ; preds = %289
br label %297
297: ; preds = %296
store i32 0, i32* %23
store i32 0, i32* %22
store i32 0, i32* %18
%298 = load i32, i32* %13
%299 = add nsw i32 %298, 1
store i32 %299, i32* %13
br label %156
300: ; preds = %156
%301 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str, i64 0, i64 0))
store i32 0, i32* %19
br label %302
302: ; preds = %323, %300
%303 = load i32, i32* %19
%304 = icmp slt i32 %303, 10
br i1 %304, label %305, label %326
305: ; preds = %302
%306 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
store i32 0, i32* %20
br label %307
307: ; preds = %319, %305
%308 = load i32, i32* %20
%309 = icmp slt i32 %308, 10
br i1 %309, label %310, label %322
310: ; preds = %307
%311 = load i32, i32* %19
%312 = sext i32 %311 to i64
%313 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %25, i64 0, i64 %312
%314 = load i32, i32* %20
%315 = sext i32 %314 to i64
%316 = getelementptr inbounds [10 x i32], [10 x i32]* %313, i64 0, i64 %315
%317 = load i32, i32* %316
%318 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), i32 %317)
br label %319
319: ; preds = %310
%320 = load i32, i32* %20
%321 = add nsw i32 %320, 1
store i32 %321, i32* %20
br label %307
322: ; preds = %307
br label %323
323: ; preds = %322
%324 = load i32, i32* %19
%325 = add nsw i32 %324, 1
store i32 %325, i32* %19
br label %302
326: ; preds = %302
br label %503
327: ; preds = %152
%328 = load i32, i32* %10
%329 = icmp eq i32 %328, 1
br i1 %329, label %330, label %502
330: ; preds = %327
store i32 0, i32* %13
br label %331
331: ; preds = %472, %330
%332 = load i32, i32* %13
%333 = icmp slt i32 %332, 10
br i1 %333, label %334, label %475
334: ; preds = %331
store i32 0, i32* %18
store i32 0, i32* %22
store i32 0, i32* %23
store i32 1, i32* %14
br label %335
335: ; preds = %439, %334
%336 = load i32, i32* %14
%337 = icmp slt i32 %336, 10
br i1 %337, label %338, label %442
338: ; preds = %335
%339 = load i32, i32* %14
%340 = sext i32 %339 to i64
%341 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %24, i64 0, i64 %340
%342 = load i32, i32* %13
%343 = sext i32 %342 to i64
%344 = getelementptr inbounds [10 x i32], [10 x i32]* %341, i64 0, i64 %343
%345 = load i32, i32* %344
%346 = load i32, i32* %14
%347 = sub nsw i32 %346, 1
%348 = sext i32 %347 to i64
%349 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %24, i64 0, i64 %348
%350 = load i32, i32* %13
%351 = sext i32 %350 to i64
%352 = getelementptr inbounds [10 x i32], [10 x i32]* %349, i64 0, i64 %351
%353 = load i32, i32* %352
%354 = icmp eq i32 %345, %353
br i1 %354, label %355, label %369
355: ; preds = %338
%356 = load i32, i32* %14
%357 = sext i32 %356 to i64
%358 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %24, i64 0, i64 %357
%359 = load i32, i32* %13
%360 = sext i32 %359 to i64
%361 = getelementptr inbounds [10 x i32], [10 x i32]* %358, i64 0, i64 %360
%362 = load i32, i32* %361
%363 = icmp ne i32 %362, 11
br i1 %363, label %364, label %369
364: ; preds = %355
%365 = load i32, i32* %22
%366 = add nsw i32 %365, 1
store i32 %366, i32* %22
%367 = load i32, i32* %23
%368 = add nsw i32 %367, 1
store i32 %368, i32* %23
br label %370
369: ; preds = %355, %338
store i32 0, i32* %22
br label %370
370: ; preds = %369, %364
%371 = load i32, i32* %22
%372 = load i32, i32* %11
%373 = sub nsw i32 %372, 1
%374 = icmp sge i32 %371, %373
br i1 %374, label %375, label %394
375: ; preds = %370
%376 = load i32, i32* %14
%377 = load i32, i32* %11
%378 = sub nsw i32 %376, %377
%379 = add nsw i32 %378, 1
%380 = sext i32 %379 to i64
%381 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %24, i64 0, i64 %380
%382 = load i32, i32* %13
%383 = sext i32 %382 to i64
%384 = getelementptr inbounds [10 x i32], [10 x i32]* %381, i64 0, i64 %383
%385 = load i32, i32* %384
%386 = load i32, i32* %18
%387 = sext i32 %386 to i64
%388 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %25, i64 0, i64 %387
%389 = load i32, i32* %13
%390 = sext i32 %389 to i64
%391 = getelementptr inbounds [10 x i32], [10 x i32]* %388, i64 0, i64 %390
store i32 %385, i32* %391
%392 = load i32, i32* %18
%393 = add nsw i32 %392, 1
store i32 %393, i32* %18
br label %394
394: ; preds = %375, %370
%395 = load i32, i32* %22
%396 = icmp eq i32 %395, 9
br i1 %396, label %397, label %438
397: ; preds = %394
%398 = load i32, i32* %13
store i32 %398, i32* %19
br label %399
399: ; preds = %434, %397
%400 = load i32, i32* %19
%401 = load i32, i32* %13
%402 = add nsw i32 %401, 1
%403 = icmp slt i32 %400, %402
br i1 %403, label %404, label %437
404: ; preds = %399
store i32 0, i32* %20
br label %405
405: ; preds = %430, %404
%406 = load i32, i32* %20
%407 = icmp slt i32 %406, 10
br i1 %407, label %408, label %433
408: ; preds = %405
%409 = load i32, i32* %20
%410 = load i32, i32* %11
%411 = sub nsw i32 10, %410
%412 = add nsw i32 %411, 1
%413 = icmp slt i32 %409, %412
br i1 %413, label %414, label %422
414: ; preds = %408
%415 = load i32, i32* %20
%416 = load i32, i32* %20
%417 = sext i32 %416 to i64
%418 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %25, i64 0, i64 %417
%419 = load i32, i32* %19
%420 = sext i32 %419 to i64
%421 = getelementptr inbounds [10 x i32], [10 x i32]* %418, i64 0, i64 %420
store i32 %415, i32* %421
br label %429
422: ; preds = %408
%423 = load i32, i32* %20
%424 = sext i32 %423 to i64
%425 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %25, i64 0, i64 %424
%426 = load i32, i32* %19
%427 = sext i32 %426 to i64
%428 = getelementptr inbounds [10 x i32], [10 x i32]* %425, i64 0, i64 %427
store i32 11, i32* %428
br label %429
429: ; preds = %422, %414
br label %430
430: ; preds = %429
%431 = load i32, i32* %20
%432 = add nsw i32 %431, 1
store i32 %432, i32* %20
br label %405
433: ; preds = %405
br label %434
434: ; preds = %433
%435 = load i32, i32* %19
%436 = add nsw i32 %435, 1
store i32 %436, i32* %19
br label %399
437: ; preds = %399
br label %438
438: ; preds = %437, %394
br label %439
439: ; preds = %438
%440 = load i32, i32* %14
%441 = add nsw i32 %440, 1
store i32 %441, i32* %14
br label %335
442: ; preds = %335
%443 = load i32, i32* %23
%444 = icmp eq i32 %443, 0
br i1 %444, label %445, label %471
445: ; preds = %442
%446 = load i32, i32* %13
store i32 %446, i32* %19
br label %447
447: ; preds = %467, %445
%448 = load i32, i32* %19
%449 = load i32, i32* %13
%450 = add nsw i32 %449, 1
%451 = icmp slt i32 %448, %450
br i1 %451, label %452, label %470
452: ; preds = %447
store i32 0, i32* %20
br label %453
453: ; preds = %463, %452
%454 = load i32, i32* %20
%455 = icmp slt i32 %454, 10
br i1 %455, label %456, label %466
456: ; preds = %453
%457 = load i32, i32* %20
%458 = sext i32 %457 to i64
%459 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %25, i64 0, i64 %458
%460 = load i32, i32* %19
%461 = sext i32 %460 to i64
%462 = getelementptr inbounds [10 x i32], [10 x i32]* %459, i64 0, i64 %461
store i32 11, i32* %462
br label %463
463: ; preds = %456
%464 = load i32, i32* %20
%465 = add nsw i32 %464, 1
store i32 %465, i32* %20
br label %453
466: ; preds = %453
br label %467
467: ; preds = %466
%468 = load i32, i32* %19
%469 = add nsw i32 %468, 1
store i32 %469, i32* %19
br label %447
470: ; preds = %447
br label %471
471: ; preds = %470, %442
br label %472
472: ; preds = %471
%473 = load i32, i32* %13
%474 = add nsw i32 %473, 1
store i32 %474, i32* %13
br label %331
475: ; preds = %331
%476 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.3, i64 0, i64 0))
store i32 0, i32* %19
br label %477
477: ; preds = %498, %475
%478 = load i32, i32* %19
%479 = icmp slt i32 %478, 10
br i1 %479, label %480, label %501
480: ; preds = %477
%481 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
store i32 0, i32* %20
br label %482
482: ; preds = %494, %480
%483 = load i32, i32* %20
%484 = icmp slt i32 %483, 10
br i1 %484, label %485, label %497
485: ; preds = %482
%486 = load i32, i32* %19
%487 = sext i32 %486 to i64
%488 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %25, i64 0, i64 %487
%489 = load i32, i32* %20
%490 = sext i32 %489 to i64
%491 = getelementptr inbounds [10 x i32], [10 x i32]* %488, i64 0, i64 %490
%492 = load i32, i32* %491
%493 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), i32 %492)
br label %494
494: ; preds = %485
%495 = load i32, i32* %20
%496 = add nsw i32 %495, 1
store i32 %496, i32* %20
br label %482
497: ; preds = %482
br label %498
498: ; preds = %497
%499 = load i32, i32* %19
%500 = add nsw i32 %499, 1
store i32 %500, i32* %19
br label %477
501: ; preds = %477
br label %502
502: ; preds = %501, %327
br label %503
503: ; preds = %502, %326
store i32 0, i32* %19
store i32 0, i32* %30
br label %504
504: ; preds = %598, %503
store i32 0, i32* %19
store i32 0, i32* %29
%505 = call i32 (...) @rand()
%506 = srem i32 %505, 10
store i32 %506, i32* %27
%507 = load i32, i32* %27
store i32 %507, i32* %13
store i32 0, i32* %29
br label %508
508: ; preds = %564, %504
%509 = load i32, i32* %13
%510 = load i32, i32* %27
%511 = add nsw i32 %510, 1
%512 = icmp slt i32 %509, %511
br i1 %512, label %513, label %567
513: ; preds = %508
%514 = load i32, i32* %10
%515 = icmp eq i32 %514, 0
br i1 %515, label %516, label %540
516: ; preds = %513
store i32 0, i32* %14
br label %517
517: ; preds = %536, %516
%518 = load i32, i32* %14
%519 = icmp slt i32 %518, 10
br i1 %519, label %520, label %539
520: ; preds = %517
%521 = load i32, i32* %13
%522 = sext i32 %521 to i64
%523 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %25, i64 0, i64 %522
%524 = load i32, i32* %14
%525 = sext i32 %524 to i64
%526 = getelementptr inbounds [10 x i32], [10 x i32]* %523, i64 0, i64 %525
%527 = load i32, i32* %526
%528 = icmp ne i32 %527, 11
br i1 %528, label %529, label %535
529: ; preds = %520
%530 = load i32, i32* %29
%531 = add nsw i32 %530, 1
store i32 %531, i32* %29
%532 = load i32, i32* %19
%533 = add nsw i32 %532, 1
store i32 %533, i32* %19
%534 = load i32, i32* %27
store i32 %534, i32* %30
br label %535
535: ; preds = %529, %520
br label %536
536: ; preds = %535
%537 = load i32, i32* %14
%538 = add nsw i32 %537, 1
store i32 %538, i32* %14
br label %517
539: ; preds = %517
br label %563
540: ; preds = %513
store i32 0, i32* %14
br label %541
541: ; preds = %559, %540
%542 = load i32, i32* %14
%543 = icmp slt i32 %542, 10
br i1 %543, label %544, label %562
544: ; preds = %541
%545 = load i32, i32* %14
%546 = sext i32 %545 to i64
%547 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %25, i64 0, i64 %546
%548 = load i32, i32* %13
%549 = sext i32 %548 to i64
%550 = getelementptr inbounds [10 x i32], [10 x i32]* %547, i64 0, i64 %549
%551 = load i32, i32* %550
%552 = icmp ne i32 %551, 11
br i1 %552, label %553, label %558
553: ; preds = %544
%554 = load i32, i32* %29
%555 = add nsw i32 %554, 1
store i32 %555, i32* %29
%556 = load i32, i32* %19
%557 = add nsw i32 %556, 1
store i32 %557, i32* %19
br label %558
558: ; preds = %553, %544
br label %559
559: ; preds = %558
%560 = load i32, i32* %14
%561 = add nsw i32 %560, 1
store i32 %561, i32* %14
br label %541
562: ; preds = %541
br label %563
563: ; preds = %562, %539
br label %564
564: ; preds = %563
%565 = load i32, i32* %13
%566 = add nsw i32 %565, 1
store i32 %566, i32* %13
br label %508
567: ; preds = %508
%568 = call i32 (...) @rand()
%569 = load i32, i32* %29
%570 = srem i32 %568, %569
store i32 %570, i32* %28
br label %571
571: ; preds = %567
%572 = load i8**, i8*** %7
%573 = load i32, i32* %30
%574 = sext i32 %573 to i64
%575 = getelementptr inbounds i8*, i8** %572, i64 %574
%576 = load i8*, i8** %575
%577 = load i32, i32* %28
%578 = sext i32 %577 to i64
%579 = getelementptr inbounds i8, i8* %576, i64 %578
%580 = load i8, i8* %579
%581 = sext i8 %580 to i32
%582 = icmp ne i32 %581, 45
br i1 %582, label %598, label %583
583: ; preds = %571
%584 = load i8**, i8*** %7
%585 = load i32, i32* %30
%586 = sext i32 %585 to i64
%587 = getelementptr inbounds i8*, i8** %584, i64 %586
%588 = load i8*, i8** %587
%589 = load i32, i32* %28
%590 = load i32, i32* %11
%591 = add nsw i32 %589, %590
%592 = sub nsw i32 %591, 1
%593 = sext i32 %592 to i64
%594 = getelementptr inbounds i8, i8* %588, i64 %593
%595 = load i8, i8* %594
%596 = sext i8 %595 to i32
%597 = icmp ne i32 %596, 45
br label %598
598: ; preds = %583, %571
%599 = phi i1 [ true, %571 ], [ %597, %583 ]
br i1 %599, label %504, label %600
600: ; preds = %598
%601 = load i32, i32* %10
%602 = icmp eq i32 %601, 0
br i1 %602, label %603, label %611
603: ; preds = %600
%604 = load i32, i32* %30
%605 = sext i32 %604 to i64
%606 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %25, i64 0, i64 %605
%607 = load i32, i32* %28
%608 = sext i32 %607 to i64
%609 = getelementptr inbounds [10 x i32], [10 x i32]* %606, i64 0, i64 %608
%610 = load i32, i32* %609
store i32 %610, i32* %26
br label %619
611: ; preds = %600
%612 = load i32, i32* %28
%613 = sext i32 %612 to i64
%614 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %25, i64 0, i64 %613
%615 = load i32, i32* %30
%616 = sext i32 %615 to i64
%617 = getelementptr inbounds [10 x i32], [10 x i32]* %614, i64 0, i64 %616
%618 = load i32, i32* %617
store i32 %618, i32* %26
br label %619
619: ; preds = %611, %603
%620 = load i32, i32* %10
%621 = load i32, i32* %30
%622 = load i32, i32* %26
%623 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([57 x i8], [57 x i8]* @.str.4, i64 0, i64 0), i32 %620, i32 %621, i32 %622)
%624 = load i8**, i8*** %7
%625 = load i32, i32* %10
%626 = load i32, i32* %30
%627 = load i32, i32* %26
%628 = load i32, i32* %11
%629 = load i8, i8* %12
%630 = call i8** @ships(i8** %624, i32 %625, i32 %626, i32 %627, i32 %628, i8 signext %629)
store i8** %630, i8*** %7
%631 = load i8**, i8*** %7
ret i8** %631
}

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