#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*/ getch();
int /*<<< orphan*/ printf(char *, ...);
int rand();
int /*<<< orphan*/ scanf(char *, int *);
int /*<<< orphan*/ srand(int /*<<< orphan*/);
int /*<<< orphan*/ time(int /*<<< orphan*/ *);
int main() {
  int base[5][5][5];
  int opcao, i, negativos;
  int x, y, z, xn, yn, zn;
  int negativo;
  int xneg[256], yneg[256], zneg[256];
  srand(time(NULL));
  i = 1;
  negativos = 0;
  xn = 0;
  yn = 0;
  zn = 0;
  printf("Escolha a opcao:\n1 - Matriz Povoada com 0\n2 - Matriz Povoada "
         "Aleatoriamente [+ Num Negativos]\n");
  scanf("%d", &opcao);
  while ((opcao != 1) && (opcao != 2)) {
    printf("Opcao invalida, digite 1 ou 2.");
    scanf("%d", &opcao);
  }
  switch (opcao) {
  case 1:
    for (z = 0; z < 5; z++) {
      for (y = 0; y < 5; y++) {
        for (x = 0; x < 5; x++) {
          base[x][y][z] = 0;
        }
      }
    }
    for (z = 0; z < 5; z++) {
      printf("\n => Face %d:\n", i);
      for (y = 0; y < 5; y++) {
        for (x = 0; x < 5; x++) {
          printf("%d\t", base[x][y][z]);
        }
        printf("\n");
      }
      i++;
      printf("\n");
    }
    break;
  case 2:
    for (z = 0; z < 5; z++) {
      for (y = 0; y < 5; y++) {
        for (x = 0; x < 5; x++) {
          negativo = rand() % 50;
          base[x][y][z] = (rand() % 101) - negativo;
          if (base[x][y][z] < 0) {
            negativos++;
            xneg[xn] = x;
            xn++;
            yneg[yn] = y;
            yn++;
            zneg[zn] = z;
            zn++;
          }
        }
      }
    }
    for (z = 0; z < 5; z++) {
      printf("\n => Face %d:\n", i);
      for (y = 0; y < 5; y++) {
        for (x = 0; x < 5; x++) {
          printf("%d\t", base[x][y][z]);
        }
        printf("\n");
      }
      i++;
      printf("\n");
    }
    printf("Ha %d numeros negativos nessa matriz.\nEles estao ocupando as "
           "posicoes:\n",
           negativos);
    for (x = 0; x < xn; x++) {
      printf("|[%d]\t [%d]\t [%d]|\n", xneg[x], xneg[x], xneg[x]);
    }
    break;
  }
  getch();
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xe40,%rsp
movl   $0x0,-0x4(%rbp)
xor    %eax,%eax
mov    %eax,%edi
call   1050 <time@plt>
mov    %eax,%edi
call   1040 <srand@plt>
movl   $0x1,-0x208(%rbp)
movl   $0x0,-0x20c(%rbp)
movl   $0x0,-0x21c(%rbp)
movl   $0x0,-0x220(%rbp)
movl   $0x0,-0x224(%rbp)
lea    0xe45(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xe96(%rip),%rdi
lea    -0x204(%rbp),%rsi
call   1060 <scanf@plt>
xor    %eax,%eax
cmpl   $0x1,-0x204(%rbp)
mov    %al,-0xe31(%rbp)
je     11fa <main+0x9a>
cmpl   $0x2,-0x204(%rbp)
setne  %al
mov    %al,-0xe31(%rbp)
mov    -0xe31(%rbp),%al
test   $0x1,%al
jne    120d <main+0xad>
jmp    1233 <main+0xd3>
lea    0xe4e(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xe3d(%rip),%rdi
lea    -0x204(%rbp),%rsi
call   1060 <scanf@plt>
jmp    11d5 <main+0x75>
mov    -0x204(%rbp),%eax
mov    %eax,-0xe38(%rbp)
sub    $0x1,%eax
je     1261 <main+0x101>
jmp    124d <main+0xed>
mov    -0xe38(%rbp),%eax
sub    $0x2,%eax
je     141d <main+0x2bd>
jmp    172c <main+0x5cc>
movl   $0x0,-0x218(%rbp)
cmpl   $0x5,-0x218(%rbp)
jge    131d <main+0x1bd>
movl   $0x0,-0x214(%rbp)
cmpl   $0x5,-0x214(%rbp)
jge    1304 <main+0x1a4>
movl   $0x0,-0x210(%rbp)
cmpl   $0x5,-0x210(%rbp)
jge    12eb <main+0x18b>
movslq -0x210(%rbp),%rcx
lea    -0x200(%rbp),%rax
imul   $0x64,%rcx,%rcx
add    %rcx,%rax
movslq -0x214(%rbp),%rcx
imul   $0x14,%rcx,%rcx
add    %rcx,%rax
movslq -0x218(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x210(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x210(%rbp)
jmp    1299 <main+0x139>
jmp    12f0 <main+0x190>
mov    -0x214(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x214(%rbp)
jmp    1282 <main+0x122>
jmp    1309 <main+0x1a9>
mov    -0x218(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x218(%rbp)
jmp    126b <main+0x10b>
movl   $0x0,-0x218(%rbp)
cmpl   $0x5,-0x218(%rbp)
jge    1418 <main+0x2b8>
mov    -0x208(%rbp),%esi
lea    0xd40(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x214(%rbp)
cmpl   $0x5,-0x214(%rbp)
jge    13e7 <main+0x287>
movl   $0x0,-0x210(%rbp)
cmpl   $0x5,-0x210(%rbp)
jge    13c5 <main+0x265>
movslq -0x210(%rbp),%rcx
lea    -0x200(%rbp),%rax
imul   $0x64,%rcx,%rcx
add    %rcx,%rax
movslq -0x214(%rbp),%rcx
imul   $0x14,%rcx,%rcx
add    %rcx,%rax
movslq -0x218(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
lea    0xce6(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x210(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x210(%rbp)
jmp    1369 <main+0x209>
lea    0xcc2(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x214(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x214(%rbp)
jmp    1352 <main+0x1f2>
mov    -0x208(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x208(%rbp)
lea    0xc91(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x218(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x218(%rbp)
jmp    1327 <main+0x1c7>
jmp    172c <main+0x5cc>
movl   $0x0,-0x218(%rbp)
cmpl   $0x5,-0x218(%rbp)
jge    15b0 <main+0x450>
movl   $0x0,-0x214(%rbp)
cmpl   $0x5,-0x214(%rbp)
jge    1597 <main+0x437>
movl   $0x0,-0x210(%rbp)
cmpl   $0x5,-0x210(%rbp)
jge    157e <main+0x41e>
mov    $0x0,%al
call   1080 <rand@plt>
mov    $0x32,%ecx
cltd
idiv   %ecx
mov    %edx,-0x228(%rbp)
mov    $0x0,%al
call   1080 <rand@plt>
mov    $0x65,%ecx
cltd
idiv   %ecx
sub    -0x228(%rbp),%edx
movslq -0x210(%rbp),%rcx
lea    -0x200(%rbp),%rax
imul   $0x64,%rcx,%rcx
add    %rcx,%rax
movslq -0x214(%rbp),%rcx
imul   $0x14,%rcx,%rcx
add    %rcx,%rax
movslq -0x218(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
movslq -0x210(%rbp),%rcx
lea    -0x200(%rbp),%rax
imul   $0x64,%rcx,%rcx
add    %rcx,%rax
movslq -0x214(%rbp),%rcx
imul   $0x14,%rcx,%rcx
add    %rcx,%rax
movslq -0x218(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jge    1565 <main+0x405>
mov    -0x20c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20c(%rbp)
mov    -0x210(%rbp),%ecx
movslq -0x21c(%rbp),%rax
mov    %ecx,-0x630(%rbp,%rax,4)
mov    -0x21c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x21c(%rbp)
mov    -0x214(%rbp),%ecx
movslq -0x220(%rbp),%rax
mov    %ecx,-0xa30(%rbp,%rax,4)
mov    -0x220(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x220(%rbp)
mov    -0x218(%rbp),%ecx
movslq -0x224(%rbp),%rax
mov    %ecx,-0xe30(%rbp,%rax,4)
mov    -0x224(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x224(%rbp)
jmp    156a <main+0x40a>
mov    -0x210(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x210(%rbp)
jmp    1455 <main+0x2f5>
jmp    1583 <main+0x423>
mov    -0x214(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x214(%rbp)
jmp    143e <main+0x2de>
jmp    159c <main+0x43c>
mov    -0x218(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x218(%rbp)
jmp    1427 <main+0x2c7>
movl   $0x0,-0x218(%rbp)
cmpl   $0x5,-0x218(%rbp)
jge    16ab <main+0x54b>
mov    -0x208(%rbp),%esi
lea    0xaad(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x214(%rbp)
cmpl   $0x5,-0x214(%rbp)
jge    167a <main+0x51a>
movl   $0x0,-0x210(%rbp)
cmpl   $0x5,-0x210(%rbp)
jge    1658 <main+0x4f8>
movslq -0x210(%rbp),%rcx
lea    -0x200(%rbp),%rax
imul   $0x64,%rcx,%rcx
add    %rcx,%rax
movslq -0x214(%rbp),%rcx
imul   $0x14,%rcx,%rcx
add    %rcx,%rax
movslq -0x218(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
lea    0xa53(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x210(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x210(%rbp)
jmp    15fc <main+0x49c>
lea    0xa2f(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x214(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x214(%rbp)
jmp    15e5 <main+0x485>
mov    -0x208(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x208(%rbp)
lea    0x9fe(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x218(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x218(%rbp)
jmp    15ba <main+0x45a>
mov    -0x20c(%rbp),%esi
lea    0x9dc(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x210(%rbp)
mov    -0x210(%rbp),%eax
cmp    -0x21c(%rbp),%eax
jge    1727 <main+0x5c7>
movslq -0x210(%rbp),%rax
mov    -0x630(%rbp,%rax,4),%esi
movslq -0x210(%rbp),%rax
mov    -0x630(%rbp,%rax,4),%edx
movslq -0x210(%rbp),%rax
mov    -0x630(%rbp,%rax,4),%ecx
lea    0x9d0(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x210(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x210(%rbp)
jmp    16c9 <main+0x569>
jmp    172c <main+0x5cc>
mov    $0x0,%al
call   1070 <getch@plt>
xor    %eax,%eax
add    $0xe40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x618,%rsp
xor    %edi,%edi
call   1070 <time@plt>
mov    %eax,%edi
call   1060 <srand@plt>
lea    0xeeb(%rip),%rdi
call   1040 <puts@plt>
lea    0xe4e(%rip),%rdi
lea    0x4(%rsp),%rsi
call   1080 <scanf@plt>
mov    0x4(%rsp),%eax
lea    -0x3(%rax),%ecx
cmp    $0xfffffffd,%ecx
ja     1201 <main+0x81>
lea    0xe34(%rip),%r14
lea    0xe2a(%rip),%r15
lea    0x4(%rsp),%rbx
nopl   0x0(%rax,%rax,1)
mov    %r14,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %r15,%rdi
mov    %rbx,%rsi
call   1080 <scanf@plt>
mov    0x4(%rsp),%eax
lea    -0x3(%rax),%ecx
cmp    $0xfffffffe,%ecx
jb     11e0 <main+0x60>
cmp    $0x1,%eax
je     1476 <main+0x2f6>
cmp    $0x2,%eax
jne    19ee <main+0x86e>
lea    0x1a0(%rsp),%r15
xor    %eax,%eax
xor    %r13d,%r13d
xor    %r14d,%r14d
jmp    1247 <main+0xc7>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x8(%rsp),%rax
add    $0x1,%rax
add    $0x4,%r15
cmp    $0x5,%rax
je     17a1 <main+0x621>
mov    %rax,0x8(%rsp)
mov    $0xffffffffffffff9c,%r12
jmp    1266 <main+0xe6>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x14,%r12
je     1230 <main+0xb0>
mov    %r14d,%ebp
xor    %eax,%eax
call   10a0 <rand@plt>
movslq %eax,%rbx
imul   $0x51eb851f,%rbx,%rax
mov    %rax,%rcx
shr    $0x3f,%rcx
sar    $0x24,%rax
add    %ecx,%eax
imul   $0x32,%eax,%r14d
xor    %eax,%eax
call   10a0 <rand@plt>
cltq
imul   $0x288df0cb,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x24,%rcx
add    %edx,%ecx
imul   $0x65,%ecx,%ecx
sub    %ecx,%eax
sub    %ebx,%r14d
add    %eax,%r14d
mov    %r14d,-0x12c(%r15,%r12,1)
ff
mov    %ebp,%r14d
jns    12d7 <main+0x157>
add    $0x1,%r14d
movslq %r13d,%r13
movl   $0x0,0x210(%rsp,%r13,4)
add    $0x1,%r13d
xor    %eax,%eax
call   10a0 <rand@plt>
movslq %eax,%rbx
imul   $0x51eb851f,%rbx,%rax
mov    %rax,%rcx
shr    $0x3f,%rcx
sar    $0x24,%rax
add    %ecx,%eax
imul   $0x32,%eax,%ebp
xor    %eax,%eax
call   10a0 <rand@plt>
cltq
imul   $0x288df0cb,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x24,%rcx
add    %edx,%ecx
imul   $0x65,%ecx,%ecx
sub    %ecx,%eax
sub    %ebx,%ebp
add    %eax,%ebp
mov    %ebp,-0xc8(%r15,%r12,1)
ff
jns    133f <main+0x1bf>
add    $0x1,%r14d
movslq %r13d,%r13
movl   $0x1,0x210(%rsp,%r13,4)
add    $0x1,%r13d
xor    %eax,%eax
call   10a0 <rand@plt>
movslq %eax,%rbx
imul   $0x51eb851f,%rbx,%rax
mov    %rax,%rcx
shr    $0x3f,%rcx
sar    $0x24,%rax
add    %ecx,%eax
imul   $0x32,%eax,%ebp
xor    %eax,%eax
call   10a0 <rand@plt>
cltq
imul   $0x288df0cb,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x24,%rcx
add    %edx,%ecx
imul   $0x65,%ecx,%ecx
sub    %ecx,%eax
sub    %ebx,%ebp
add    %eax,%ebp
mov    %ebp,-0x64(%r15,%r12,1)
jns    13a4 <main+0x224>
add    $0x1,%r14d
movslq %r13d,%r13
movl   $0x2,0x210(%rsp,%r13,4)
add    $0x1,%r13d
xor    %eax,%eax
call   10a0 <rand@plt>
movslq %eax,%rbx
imul   $0x51eb851f,%rbx,%rax
mov    %rax,%rcx
shr    $0x3f,%rcx
sar    $0x24,%rax
add    %ecx,%eax
imul   $0x32,%eax,%ebp
xor    %eax,%eax
call   10a0 <rand@plt>
cltq
imul   $0x288df0cb,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x24,%rcx
add    %edx,%ecx
imul   $0x65,%ecx,%ecx
sub    %ecx,%eax
sub    %ebx,%ebp
add    %eax,%ebp
mov    %ebp,(%r15,%r12,1)
jns    1408 <main+0x288>
add    $0x1,%r14d
movslq %r13d,%r13
movl   $0x3,0x210(%rsp,%r13,4)
add    $0x1,%r13d
xor    %eax,%eax
call   10a0 <rand@plt>
movslq %eax,%rbx
imul   $0x51eb851f,%rbx,%rax
mov    %rax,%rcx
shr    $0x3f,%rcx
sar    $0x24,%rax
add    %ecx,%eax
imul   $0x32,%eax,%ebp
xor    %eax,%eax
call   10a0 <rand@plt>
cltq
imul   $0x288df0cb,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x24,%rcx
add    %edx,%ecx
imul   $0x65,%ecx,%ecx
sub    %ecx,%eax
sub    %ebx,%ebp
add    %eax,%ebp
mov    %ebp,0x64(%r15,%r12,1)
jns    1260 <main+0xe0>
add    $0x1,%r14d
movslq %r13d,%r13
movl   $0x4,0x210(%rsp,%r13,4)
add    $0x1,%r13d
jmp    1260 <main+0xe0>
xorps  %xmm0,%xmm0
movaps %xmm0,0x60(%rsp)
movaps %xmm0,0x50(%rsp)
movaps %xmm0,0x40(%rsp)
movaps %xmm0,0x30(%rsp)
movaps %xmm0,0x20(%rsp)
movaps %xmm0,0x10(%rsp)
movl   $0x0,0x70(%rsp)
mov    $0xfffffffffffffffb,%rax
cs nopw 0x0(%rax,%rax,1)
movl   $0x0,0x88(%rsp,%rax,4)
movl   $0x0,0xec(%rsp,%rax,4)
movl   $0x0,0x150(%rsp,%rax,4)
movl   $0x0,0x1b4(%rsp,%rax,4)
movl   $0x0,0x9c(%rsp,%rax,4)
movl   $0x0,0x100(%rsp,%rax,4)
movl   $0x0,0x164(%rsp,%rax,4)
movl   $0x0,0x1c8(%rsp,%rax,4)
movl   $0x0,0xb0(%rsp,%rax,4)
movl   $0x0,0x114(%rsp,%rax,4)
movl   $0x0,0x178(%rsp,%rax,4)
movl   $0x0,0x1dc(%rsp,%rax,4)
movl   $0x0,0xc4(%rsp,%rax,4)
movl   $0x0,0x128(%rsp,%rax,4)
movl   $0x0,0x18c(%rsp,%rax,4)
movl   $0x0,0x1f0(%rsp,%rax,4)
movl   $0x0,0xd8(%rsp,%rax,4)
movl   $0x0,0x13c(%rsp,%rax,4)
movl   $0x0,0x1a0(%rsp,%rax,4)
movl   $0x0,0x204(%rsp,%rax,4)
inc    %rax
jne    14b0 <main+0x330>
mov    $0xfffffffffffffffb,%rbp
lea    0xa7f(%rip),%r14
lea    0xa87(%rip),%rbx
nopw   0x0(%rax,%rax,1)
lea    0x6(%rbp),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x24(%rsp,%rbp,4),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x88(%rsp,%rbp,4),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0xec(%rsp,%rbp,4),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x150(%rsp,%rbp,4),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x1b4(%rsp,%rbp,4),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0x38(%rsp,%rbp,4),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x9c(%rsp,%rbp,4),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x100(%rsp,%rbp,4),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x164(%rsp,%rbp,4),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x1c8(%rsp,%rbp,4),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0x4c(%rsp,%rbp,4),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0xb0(%rsp,%rbp,4),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x114(%rsp,%rbp,4),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x178(%rsp,%rbp,4),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x1dc(%rsp,%rbp,4),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0x60(%rsp,%rbp,4),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0xc4(%rsp,%rbp,4),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x128(%rsp,%rbp,4),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x18c(%rsp,%rbp,4),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x1f0(%rsp,%rbp,4),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0x74(%rsp,%rbp,4),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0xd8(%rsp,%rbp,4),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x13c(%rsp,%rbp,4),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x1a0(%rsp,%rbp,4),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x204(%rsp,%rbp,4),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
inc    %rbp
jne    15b0 <main+0x430>
jmp    19ee <main+0x86e>
mov    %r14d,%ebx
mov    $0xfffffffffffffffb,%rbp
lea    0x870(%rip),%r14
lea    0x878(%rip),%r15
nopl   0x0(%rax)
lea    0x6(%rbp),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x24(%rsp,%rbp,4),%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x88(%rsp,%rbp,4),%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0xec(%rsp,%rbp,4),%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x150(%rsp,%rbp,4),%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x1b4(%rsp,%rbp,4),%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0x38(%rsp,%rbp,4),%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x9c(%rsp,%rbp,4),%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x100(%rsp,%rbp,4),%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x164(%rsp,%rbp,4),%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x1c8(%rsp,%rbp,4),%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0x4c(%rsp,%rbp,4),%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0xb0(%rsp,%rbp,4),%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x114(%rsp,%rbp,4),%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x178(%rsp,%rbp,4),%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x1dc(%rsp,%rbp,4),%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0x60(%rsp,%rbp,4),%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0xc4(%rsp,%rbp,4),%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x128(%rsp,%rbp,4),%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x18c(%rsp,%rbp,4),%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x1f0(%rsp,%rbp,4),%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0x74(%rsp,%rbp,4),%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0xd8(%rsp,%rbp,4),%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x13c(%rsp,%rbp,4),%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x1a0(%rsp,%rbp,4),%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x204(%rsp,%rbp,4),%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
inc    %rbp
jne    17c0 <main+0x640>
lea    0x682(%rip),%rdi
mov    %ebx,%esi
xor    %eax,%eax
call   1050 <printf@plt>
test   %r13d,%r13d
jle    19ee <main+0x86e>
mov    %r13d,%ebp
lea    0x6b2(%rip),%r14
xor    %ebx,%ebx
nopl   (%rax)
mov    0x210(%rsp,%rbx,4),%ecx
mov    %r14,%rdi
mov    %ecx,%esi
mov    %ecx,%edx
xor    %eax,%eax
call   1050 <printf@plt>
add    $0x1,%rbx
cmp    %rbx,%rbp
jne    19d0 <main+0x850>
xor    %eax,%eax
call   1090 <getch@plt>
xor    %eax,%eax
add    $0x618,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [95 x i8] c"Escolha a opcao:\0A1 - Matriz Povoada com 0\0A2 - Matriz Povoada Aleatoriamente [+ Num Negativos]\0A\00"
@.str.1 = [3 x i8] c"%d\00"
@.str.2 = [31 x i8] c"Opcao invalida, digite 1 ou 2.\00"
@.str.3 = [15 x i8] c"\0A => Face %d:\0A\00"
@.str.4 = [4 x i8] c"%d\09\00"
@.str.5 = [2 x i8] c"\0A\00"
@.str.6 = [72 x i8] c"Ha %d numeros negativos nessa matriz.\0AEles estao ocupando as posicoes:\0A\00"
@.str.7 = [20 x i8] c"|[%d]\09 [%d]\09 [%d]|\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca [5 x [5 x [5 x i32]]]
%3 = alloca i32
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca [256 x i32]
%14 = alloca [256 x i32]
%15 = alloca [256 x i32]
store i32 0, i32* %1
%16 = call i32 @time(i32* null)
%17 = call i32 @srand(i32 %16)
store i32 1, i32* %4
store i32 0, i32* %5
store i32 0, i32* %9
store i32 0, i32* %10
store i32 0, i32* %11
%18 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([95 x i8], [95 x i8]* @.str, i64 0, i64 0))
%19 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %3)
br label %20
20: ; preds = %28, %0
%21 = load i32, i32* %3
%22 = icmp ne i32 %21, 1
br i1 %22, label %23, label %26
23: ; preds = %20
%24 = load i32, i32* %3
%25 = icmp ne i32 %24, 2
br label %26
26: ; preds = %23, %20
%27 = phi i1 [ false, %20 ], [ %25, %23 ]
br i1 %27, label %28, label %31
28: ; preds = %26
%29 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.2, i64 0, i64 0))
%30 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %3)
br label %20
31: ; preds = %26
%32 = load i32, i32* %3
switch i32 %32, label %246 [
i32 1, label %33
i32 2, label %108
]
33: ; preds = %31
store i32 0, i32* %8
br label %34
34: ; preds = %63, %33
%35 = load i32, i32* %8
%36 = icmp slt i32 %35, 5
br i1 %36, label %37, label %66
37: ; preds = %34
store i32 0, i32* %7
br label %38
38: ; preds = %59, %37
%39 = load i32, i32* %7
%40 = icmp slt i32 %39, 5
br i1 %40, label %41, label %62
41: ; preds = %38
store i32 0, i32* %6
br label %42
42: ; preds = %55, %41
%43 = load i32, i32* %6
%44 = icmp slt i32 %43, 5
br i1 %44, label %45, label %58
45: ; preds = %42
%46 = load i32, i32* %6
%47 = sext i32 %46 to i64
%48 = getelementptr inbounds [5 x [5 x [5 x i32]]], [5 x [5 x [5 x i32]]]* %2, i64 0, i64 %47
%49 = load i32, i32* %7
%50 = sext i32 %49 to i64
%51 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %48, i64 0, i64 %50
%52 = load i32, i32* %8
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds [5 x i32], [5 x i32]* %51, i64 0, i64 %53
store i32 0, i32* %54
br label %55
55: ; preds = %45
%56 = load i32, i32* %6
%57 = add nsw i32 %56, 1
store i32 %57, i32* %6
br label %42
58: ; preds = %42
br label %59
59: ; preds = %58
%60 = load i32, i32* %7
%61 = add nsw i32 %60, 1
store i32 %61, i32* %7
br label %38
62: ; preds = %38
br label %63
63: ; preds = %62
%64 = load i32, i32* %8
%65 = add nsw i32 %64, 1
store i32 %65, i32* %8
br label %34
66: ; preds = %34
store i32 0, i32* %8
br label %67
67: ; preds = %104, %66
%68 = load i32, i32* %8
%69 = icmp slt i32 %68, 5
br i1 %69, label %70, label %107
70: ; preds = %67
%71 = load i32, i32* %4
%72 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.3, i64 0, i64 0), i32 %71)
store i32 0, i32* %7
br label %73
73: ; preds = %97, %70
%74 = load i32, i32* %7
%75 = icmp slt i32 %74, 5
br i1 %75, label %76, label %100
76: ; preds = %73
store i32 0, i32* %6
br label %77
77: ; preds = %92, %76
%78 = load i32, i32* %6
%79 = icmp slt i32 %78, 5
br i1 %79, label %80, label %95
80: ; preds = %77
%81 = load i32, i32* %6
%82 = sext i32 %81 to i64
%83 = getelementptr inbounds [5 x [5 x [5 x i32]]], [5 x [5 x [5 x i32]]]* %2, i64 0, i64 %82
%84 = load i32, i32* %7
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %83, i64 0, i64 %85
%87 = load i32, i32* %8
%88 = sext i32 %87 to i64
%89 = getelementptr inbounds [5 x i32], [5 x i32]* %86, i64 0, i64 %88
%90 = load i32, i32* %89
%91 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i64 0, i64 0), i32 %90)
br label %92
92: ; preds = %80
%93 = load i32, i32* %6
%94 = add nsw i32 %93, 1
store i32 %94, i32* %6
br label %77
95: ; preds = %77
%96 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0))
br label %97
97: ; preds = %95
%98 = load i32, i32* %7
%99 = add nsw i32 %98, 1
store i32 %99, i32* %7
br label %73
100: ; preds = %73
%101 = load i32, i32* %4
%102 = add nsw i32 %101, 1
store i32 %102, i32* %4
%103 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0))
br label %104
104: ; preds = %100
%105 = load i32, i32* %8
%106 = add nsw i32 %105, 1
store i32 %106, i32* %8
br label %67
107: ; preds = %67
br label %246
108: ; preds = %31
store i32 0, i32* %8
br label %109
109: ; preds = %177, %108
%110 = load i32, i32* %8
%111 = icmp slt i32 %110, 5
br i1 %111, label %112, label %180
112: ; preds = %109
store i32 0, i32* %7
br label %113
113: ; preds = %173, %112
%114 = load i32, i32* %7
%115 = icmp slt i32 %114, 5
br i1 %115, label %116, label %176
116: ; preds = %113
store i32 0, i32* %6
br label %117
117: ; preds = %169, %116
%118 = load i32, i32* %6
%119 = icmp slt i32 %118, 5
br i1 %119, label %120, label %172
120: ; preds = %117
%121 = call i32 (...) @rand()
%122 = srem i32 %121, 50
store i32 %122, i32* %12
%123 = call i32 (...) @rand()
%124 = srem i32 %123, 101
%125 = load i32, i32* %12
%126 = sub nsw i32 %124, %125
%127 = load i32, i32* %6
%128 = sext i32 %127 to i64
%129 = getelementptr inbounds [5 x [5 x [5 x i32]]], [5 x [5 x [5 x i32]]]* %2, i64 0, i64 %128
%130 = load i32, i32* %7
%131 = sext i32 %130 to i64
%132 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %129, i64 0, i64 %131
%133 = load i32, i32* %8
%134 = sext i32 %133 to i64
%135 = getelementptr inbounds [5 x i32], [5 x i32]* %132, i64 0, i64 %134
store i32 %126, i32* %135
%136 = load i32, i32* %6
%137 = sext i32 %136 to i64
%138 = getelementptr inbounds [5 x [5 x [5 x i32]]], [5 x [5 x [5 x i32]]]* %2, i64 0, i64 %137
%139 = load i32, i32* %7
%140 = sext i32 %139 to i64
%141 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %138, i64 0, i64 %140
%142 = load i32, i32* %8
%143 = sext i32 %142 to i64
%144 = getelementptr inbounds [5 x i32], [5 x i32]* %141, i64 0, i64 %143
%145 = load i32, i32* %144
%146 = icmp slt i32 %145, 0
br i1 %146, label %147, label %168
147: ; preds = %120
%148 = load i32, i32* %5
%149 = add nsw i32 %148, 1
store i32 %149, i32* %5
%150 = load i32, i32* %6
%151 = load i32, i32* %9
%152 = sext i32 %151 to i64
%153 = getelementptr inbounds [256 x i32], [256 x i32]* %13, i64 0, i64 %152
store i32 %150, i32* %153
%154 = load i32, i32* %9
%155 = add nsw i32 %154, 1
store i32 %155, i32* %9
%156 = load i32, i32* %7
%157 = load i32, i32* %10
%158 = sext i32 %157 to i64
%159 = getelementptr inbounds [256 x i32], [256 x i32]* %14, i64 0, i64 %158
store i32 %156, i32* %159
%160 = load i32, i32* %10
%161 = add nsw i32 %160, 1
store i32 %161, i32* %10
%162 = load i32, i32* %8
%163 = load i32, i32* %11
%164 = sext i32 %163 to i64
%165 = getelementptr inbounds [256 x i32], [256 x i32]* %15, i64 0, i64 %164
store i32 %162, i32* %165
%166 = load i32, i32* %11
%167 = add nsw i32 %166, 1
store i32 %167, i32* %11
br label %168
168: ; preds = %147, %120
br label %169
169: ; preds = %168
%170 = load i32, i32* %6
%171 = add nsw i32 %170, 1
store i32 %171, i32* %6
br label %117
172: ; preds = %117
br label %173
173: ; preds = %172
%174 = load i32, i32* %7
%175 = add nsw i32 %174, 1
store i32 %175, i32* %7
br label %113
176: ; preds = %113
br label %177
177: ; preds = %176
%178 = load i32, i32* %8
%179 = add nsw i32 %178, 1
store i32 %179, i32* %8
br label %109
180: ; preds = %109
store i32 0, i32* %8
br label %181
181: ; preds = %218, %180
%182 = load i32, i32* %8
%183 = icmp slt i32 %182, 5
br i1 %183, label %184, label %221
184: ; preds = %181
%185 = load i32, i32* %4
%186 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.3, i64 0, i64 0), i32 %185)
store i32 0, i32* %7
br label %187
187: ; preds = %211, %184
%188 = load i32, i32* %7
%189 = icmp slt i32 %188, 5
br i1 %189, label %190, label %214
190: ; preds = %187
store i32 0, i32* %6
br label %191
191: ; preds = %206, %190
%192 = load i32, i32* %6
%193 = icmp slt i32 %192, 5
br i1 %193, label %194, label %209
194: ; preds = %191
%195 = load i32, i32* %6
%196 = sext i32 %195 to i64
%197 = getelementptr inbounds [5 x [5 x [5 x i32]]], [5 x [5 x [5 x i32]]]* %2, i64 0, i64 %196
%198 = load i32, i32* %7
%199 = sext i32 %198 to i64
%200 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %197, i64 0, i64 %199
%201 = load i32, i32* %8
%202 = sext i32 %201 to i64
%203 = getelementptr inbounds [5 x i32], [5 x i32]* %200, i64 0, i64 %202
%204 = load i32, i32* %203
%205 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i64 0, i64 0), i32 %204)
br label %206
206: ; preds = %194
%207 = load i32, i32* %6
%208 = add nsw i32 %207, 1
store i32 %208, i32* %6
br label %191
209: ; preds = %191
%210 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0))
br label %211
211: ; preds = %209
%212 = load i32, i32* %7
%213 = add nsw i32 %212, 1
store i32 %213, i32* %7
br label %187
214: ; preds = %187
%215 = load i32, i32* %4
%216 = add nsw i32 %215, 1
store i32 %216, i32* %4
%217 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0))
br label %218
218: ; preds = %214
%219 = load i32, i32* %8
%220 = add nsw i32 %219, 1
store i32 %220, i32* %8
br label %181
221: ; preds = %181
%222 = load i32, i32* %5
%223 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([72 x i8], [72 x i8]* @.str.6, i64 0, i64 0), i32 %222)
store i32 0, i32* %6
br label %224
224: ; preds = %242, %221
%225 = load i32, i32* %6
%226 = load i32, i32* %9
%227 = icmp slt i32 %225, %226
br i1 %227, label %228, label %245
228: ; preds = %224
%229 = load i32, i32* %6
%230 = sext i32 %229 to i64
%231 = getelementptr inbounds [256 x i32], [256 x i32]* %13, i64 0, i64 %230
%232 = load i32, i32* %231
%233 = load i32, i32* %6
%234 = sext i32 %233 to i64
%235 = getelementptr inbounds [256 x i32], [256 x i32]* %13, i64 0, i64 %234
%236 = load i32, i32* %235
%237 = load i32, i32* %6
%238 = sext i32 %237 to i64
%239 = getelementptr inbounds [256 x i32], [256 x i32]* %13, i64 0, i64 %238
%240 = load i32, i32* %239
%241 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.7, i64 0, i64 0), i32 %232, i32 %236, i32 %240)
br label %242
242: ; preds = %228
%243 = load i32, i32* %6
%244 = add nsw i32 %243, 1
store i32 %244, i32* %6
br label %224
245: ; preds = %224
br label %246
246: ; preds = %31, %245, %107
%247 = call i32 (...) @getch()
ret i32 0
}

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