#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 /*<<< orphan*/ scanf(char *, ...);
int main() {
  int x, y;
  int p, c;
  int e, i, j, k, num;
  char boxes[10][10];
  char sqnc[60];
  char progs[9][62];
  int garra = 0, acidente = 0;
  char hold = '.';
  scanf("%d %d %d %d %d", &x, &y, &p, &c, &e);
  for (i = 0; i < y; i++)
    scanf("%s", boxes[i]);
  scanf(" ");
  for (i = 0; i < e; i++)
    scanf("%c", &sqnc[i]);
  for (i = 0; i < p; i++)
    scanf("%s", progs[i]);
  for (k = 0; k < e; k++) {
    i = 0;
    num = sqnc[k] - '1';
    while (progs[num][i] != '*') {
      j = 0;
      switch (progs[num][i]) {
      case 'D':
        if (hold == '.') {
          while (boxes[j][garra] == '.' && j < y - 1)
            j++;
          hold = boxes[j][garra];
          boxes[j][garra] = '.';
        } else {
          for (j = 0; j < y; j++)
            if (boxes[j + 1][garra] != '.')
              break;
          boxes[j][garra] = hold;
          hold = '.';
        }
        break;
      case 'R':
        if (garra < x - 1)
          garra++;
        if (boxes[0][garra] != '.' && hold != '.')
          acidente = 1;
        break;
      case 'L':
        if (garra > 0)
          garra--;
        if (boxes[0][garra] != '.' && hold != '.')
          acidente = 1;
        break;
      case 'B':
        if (hold != 'B')
          i++;
        break;
      case 'G':
        if (hold != 'G')
          i++;
        break;
      case 'N':
        if (hold != '.')
          i++;
        break;
      case 'A':
        if (hold == '.')
          i++;
        break;
      }
      if (acidente == 1)
        k = e;
      i++;
    }
  }
  if (acidente == 0)
    for (i = 0; i < y; i++) {
      printf("%s", boxes[i]);
      printf("\n");
    }
  else
    printf("Um acidente ocorreu\n");
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x320,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x0,-0x304(%rbp)
movl   $0x0,-0x308(%rbp)
movb   $0x2e,-0x309(%rbp)
lea    0xef4(%rip),%rdi
lea    -0x8(%rbp),%rsi
lea    -0xc(%rbp),%rdx
lea    -0x10(%rbp),%rcx
lea    -0x14(%rbp),%r8
lea    -0x18(%rbp),%r9
mov    $0x0,%al
call   1040 <scanf@plt>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    11b0 <main+0x90>
movslq -0x1c(%rbp),%rax
lea    -0x90(%rbp),%rsi
imul   $0xa,%rax,%rax
add    %rax,%rsi
lea    0xebc(%rip),%rdi
mov    $0x0,%al
call   1040 <scanf@plt>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1176 <main+0x56>
lea    0xea3(%rip),%rdi
mov    $0x0,%al
call   1040 <scanf@plt>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    11fb <main+0xdb>
movslq -0x1c(%rbp),%rax
lea    -0xd0(%rbp),%rsi
add    %rax,%rsi
lea    0xe76(%rip),%rdi
mov    $0x0,%al
call   1040 <scanf@plt>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11c5 <main+0xa5>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    123c <main+0x11c>
movslq -0x1c(%rbp),%rax
lea    -0x300(%rbp),%rsi
imul   $0x3e,%rax,%rax
add    %rax,%rsi
lea    0xe30(%rip),%rdi
mov    $0x0,%al
call   1040 <scanf@plt>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1202 <main+0xe2>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1578 <main+0x458>
movl   $0x0,-0x1c(%rbp)
movslq -0x24(%rbp),%rax
movsbl -0xd0(%rbp,%rax,1),%eax
ff
sub    $0x31,%eax
mov    %eax,-0x28(%rbp)
movslq -0x28(%rbp),%rcx
lea    -0x300(%rbp),%rax
imul   $0x3e,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2a,%eax
je     1565 <main+0x445>
movl   $0x0,-0x20(%rbp)
movslq -0x28(%rbp),%rcx
mov    %rcx,%rax
shl    $0x6,%rax
sub    %rcx,%rax
sub    %rcx,%rax
lea    -0x300(%rbp,%rax,1),%rcx
ff
movslq -0x1c(%rbp),%rax
movsbl (%rax,%rcx,1),%eax
add    $0xffffffbf,%eax
mov    %eax,%ecx
mov    %rcx,-0x318(%rbp)
sub    $0x11,%eax
ja     1544 <main+0x424>
mov    -0x318(%rbp),%rax
lea    0xd2a(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movsbl -0x309(%rbp),%eax
cmp    $0x2e,%eax
jne    139b <main+0x27b>
jmp    12f4 <main+0x1d4>
movslq -0x20(%rbp),%rcx
lea    -0x90(%rbp),%rax
imul   $0xa,%rcx,%rcx
add    %rcx,%rax
movslq -0x304(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
xor    %eax,%eax
cmp    $0x2e,%ecx
mov    %al,-0x319(%rbp)
jne    1336 <main+0x216>
mov    -0x20(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
setl   %al
mov    %al,-0x319(%rbp)
mov    -0x319(%rbp),%al
test   $0x1,%al
jne    1349 <main+0x229>
jmp    1357 <main+0x237>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    12f4 <main+0x1d4>
movslq -0x20(%rbp),%rcx
lea    -0x90(%rbp),%rax
imul   $0xa,%rcx,%rcx
add    %rcx,%rax
movslq -0x304(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x309(%rbp)
movslq -0x20(%rbp),%rcx
lea    -0x90(%rbp),%rax
imul   $0xa,%rcx,%rcx
add    %rcx,%rax
movslq -0x304(%rbp),%rcx
movb   $0x2e,(%rax,%rcx,1)
jmp    141a <main+0x2fa>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    13f1 <main+0x2d1>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x90(%rbp),%rax
imul   $0xa,%rcx,%rcx
add    %rcx,%rax
movslq -0x304(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2e,%eax
je     13de <main+0x2be>
jmp    13f1 <main+0x2d1>
jmp    13e3 <main+0x2c3>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    13a2 <main+0x282>
mov    -0x309(%rbp),%dl
movslq -0x20(%rbp),%rcx
lea    -0x90(%rbp),%rax
imul   $0xa,%rcx,%rcx
add    %rcx,%rax
movslq -0x304(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
movb   $0x2e,-0x309(%rbp)
jmp    1544 <main+0x424>
mov    -0x304(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1442 <main+0x322>
mov    -0x304(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x304(%rbp)
movslq -0x304(%rbp),%rax
movsbl -0x90(%rbp,%rax,1),%eax
ff
cmp    $0x2e,%eax
je     1474 <main+0x354>
movsbl -0x309(%rbp),%eax
cmp    $0x2e,%eax
je     1474 <main+0x354>
movl   $0x1,-0x308(%rbp)
jmp    1544 <main+0x424>
cmpl   $0x0,-0x304(%rbp)
jle    1495 <main+0x375>
mov    -0x304(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x304(%rbp)
movslq -0x304(%rbp),%rax
movsbl -0x90(%rbp,%rax,1),%eax
ff
cmp    $0x2e,%eax
je     14c7 <main+0x3a7>
movsbl -0x309(%rbp),%eax
cmp    $0x2e,%eax
je     14c7 <main+0x3a7>
movl   $0x1,-0x308(%rbp)
jmp    1544 <main+0x424>
movsbl -0x309(%rbp),%eax
cmp    $0x42,%eax
je     14e5 <main+0x3c5>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1544 <main+0x424>
movsbl -0x309(%rbp),%eax
cmp    $0x47,%eax
je     1503 <main+0x3e3>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1544 <main+0x424>
movsbl -0x309(%rbp),%eax
cmp    $0x2e,%eax
je     1521 <main+0x401>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1544 <main+0x424>
movsbl -0x309(%rbp),%eax
cmp    $0x2e,%eax
jne    153f <main+0x41f>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1544 <main+0x424>
cmpl   $0x1,-0x308(%rbp)
jne    1557 <main+0x437>
mov    -0x18(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1268 <main+0x148>
jmp    156a <main+0x44a>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1243 <main+0x123>
cmpl   $0x0,-0x308(%rbp)
jne    15d9 <main+0x4b9>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    15d4 <main+0x4b4>
movslq -0x1c(%rbp),%rax
lea    -0x90(%rbp),%rsi
imul   $0xa,%rax,%rax
add    %rax,%rsi
lea    0xaa6(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xab3(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    158c <main+0x46c>
jmp    15e7 <main+0x4c7>
lea    0xa7f(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x320,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x308,%rsp
lea    0xef0(%rip),%rdi
lea    0x18(%rsp),%rsi
lea    0xc(%rsp),%rdx
lea    0x14(%rsp),%rcx
lea    0x1c(%rsp),%r8
lea    0x10(%rsp),%r9
xor    %eax,%eax
call   1060 <scanf@plt>
cmpl   $0x0,0xc(%rsp)
jle    11af <main+0x6f>
lea    0x20(%rsp),%rbx
lea    0xecc(%rip),%r14
xor    %ebp,%ebp
nopl   (%rax)
mov    %r14,%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1060 <scanf@plt>
add    $0x1,%rbp
movslq 0xc(%rsp),%rax
add    $0xa,%rbx
cmp    %rax,%rbp
jl     1190 <main+0x50>
lea    0xea4(%rip),%rdi
xor    %eax,%eax
call   1060 <scanf@plt>
mov    0x10(%rsp),%r12d
test   %r12d,%r12d
jle    11f3 <main+0xb3>
lea    0xe8e(%rip),%rbx
xor    %ebp,%ebp
lea    (%rsp,%rbp,1),%rsi
add    $0x90,%rsi
mov    %rbx,%rdi
xor    %eax,%eax
call   1060 <scanf@plt>
add    $0x1,%rbp
movslq 0x10(%rsp),%r12
cmp    %r12,%rbp
jl     11d0 <main+0x90>
cmpl   $0x0,0x14(%rsp)
jle    1234 <main+0xf4>
lea    0xd0(%rsp),%rbx
lea    0xe4e(%rip),%r14
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
mov    %r14,%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1060 <scanf@plt>
add    $0x1,%rbp
movslq 0x14(%rsp),%rax
add    $0x3e,%rbx
cmp    %rax,%rbp
jl     1210 <main+0xd0>
mov    0x10(%rsp),%r12d
test   %r12d,%r12d
jle    13f3 <main+0x2b3>
mov    0x18(%rsp),%r8d
add    $0xffffffff,%r8d
movslq 0xc(%rsp),%rax
mov    %rax,%rdx
add    $0xffffffffffffffff,%rdx
xor    %r9d,%r9d
test   %eax,%eax
mov    $0x0,%r14d
cmovg  %eax,%r14d
mov    $0x2e,%cl
lea    0xd96(%rip),%r11
mov    $0x1,%edi
xor    %r15d,%r15d
xor    %ebx,%ebx
jmp    128c <main+0x14c>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%ebx
cmp    %r12d,%ebx
jge    13e0 <main+0x2a0>
movslq %ebx,%rax
movsbq 0x90(%rsp,%rax,1),%rax
add    $0xffffffffffffffcf,%rax
mov    %rax,%r10
shl    $0x6,%r10
sub    %rax,%r10
sub    %rax,%r10
mov    0xd0(%rsp,%r10,1),%al
cmp    $0x2a,%al
je     1280 <main+0x140>
xor    %ebp,%ebp
jmp    12e4 <main+0x1a4>
xor    %eax,%eax
cmp    $0x2e,%cl
sete   %al
add    %eax,%ebp
cmp    $0x1,%r9d
cmove  %r12d,%ebx
movslq %ebp,%rax
add    $0x1,%ebp
lea    (%rsp,%r10,1),%rsi
add    $0xd0,%rsi
mov    0x1(%rax,%rsi,1),%al
cmp    $0x2a,%al
je     1280 <main+0x140>
movsbl %al,%eax
add    $0xffffffbf,%eax
cmp    $0x11,%eax
ja     12c3 <main+0x183>
movslq (%r11,%rax,4),%rax
add    %r11,%rax
jmp    *%rax
xor    %eax,%eax
cmp    $0x42,%cl
setne  %al
jmp    12c1 <main+0x181>
movslq %r15d,%r13
cmp    $0x2e,%cl
jne    138f <main+0x24f>
lea    (%rsp,%r13,1),%rax
add    $0x20,%rax
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movzbl (%rax),%ecx
add    $0xa,%rax
cmp    $0x2e,%cl
jne    1338 <main+0x1f8>
lea    0x1(%rsi),%rdi
cmp    %rdx,%rsi
mov    %rdi,%rsi
jl     1320 <main+0x1e0>
movb   $0x2e,-0xa(%rax)
mov    $0x1,%edi
jmp    12c3 <main+0x183>
xor    %eax,%eax
cmp    $0x47,%cl
setne  %al
jmp    12c1 <main+0x181>
xor    %eax,%eax
test   %r15d,%r15d
setg   %al
sub    %eax,%r15d
jmp    1375 <main+0x235>
xor    %eax,%eax
cmp    $0x2e,%cl
setne  %al
jmp    12c1 <main+0x181>
xor    %eax,%eax
cmp    %r8d,%r15d
setl   %al
add    %eax,%r15d
movslq %r15d,%rax
cmp    $0x2e,%cl
mov    %r9d,%esi
cmovne %edi,%esi
cmpb   $0x2e,0x20(%rsp,%rax,1)
cmovne %esi,%r9d
jmp    12c3 <main+0x183>
mov    %r8d,%edi
lea    0x2a(%rsp),%rax
lea    (%rax,%r13,1),%r8
mov    $0x1,%eax
lea    (%r14,%rax,1),%rsi
cmp    $0x1,%rsi
je     13bd <main+0x27d>
add    $0xffffffffffffffff,%rax
cmpb   $0x2e,(%r8)
lea    0xa(%r8),%r8
je     13a0 <main+0x260>
neg    %rax
jmp    13c0 <main+0x280>
mov    %r14,%rax
mov    %edi,%r8d
mov    $0x1,%edi
lea    (%rax,%rax,4),%rax
lea    (%rsp,%rax,2),%rax
add    $0x20,%rax
mov    %cl,0x0(%r13,%rax,1)
mov    $0x2e,%cl
jmp    12c3 <main+0x183>
test   %r9d,%r9d
je     13f3 <main+0x2b3>
lea    0xc73(%rip),%rdi
call   1040 <puts@plt>
jmp    1439 <main+0x2f9>
cmpl   $0x0,0xc(%rsp)
jle    1439 <main+0x2f9>
lea    0x20(%rsp),%rbx
lea    0xc51(%rip),%r14
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
mov    %r14,%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1050 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
add    $0x1,%rbp
movslq 0xc(%rsp),%rax
add    $0xa,%rbx
cmp    %rax,%rbp
jl     1410 <main+0x2d0>
xor    %eax,%eax
add    $0x308,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@.str = [15 x i8] c"%d %d %d %d %d\00"
@.str.1 = [3 x i8] c"%s\00"
@.str.2 = [2 x i8] c" \00"
@.str.3 = [3 x i8] c"%c\00"
@str = [20 x i8] c"Um acidente ocorreu\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca i32
%4 = alloca i32
%5 = alloca i32
%6 = alloca [10 x [10 x i8]]
%7 = alloca [60 x i8]
%8 = alloca [9 x [62 x i8]]
%9 = bitcast i32* %1 to i8*
%10 = bitcast i32* %2 to i8*
%11 = bitcast i32* %3 to i8*
%12 = bitcast i32* %4 to i8*
%13 = bitcast i32* %5 to i8*
%14 = getelementptr inbounds [10 x [10 x i8]], [10 x [10 x i8]]* %6, i64 0, i64 0, i64 0
%15 = getelementptr inbounds [60 x i8], [60 x i8]* %7, i64 0, i64 0
%16 = getelementptr inbounds [9 x [62 x i8]], [9 x [62 x i8]]* %8, i64 0, i64 0, i64 0
%17 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str, i64 0, i64 0), i32* %1, i32* %2, i32* %3, i32* %4, i32* %5)
%18 = load i32, i32* %2
%19 = icmp sgt i32 %18, 0
br i1 %19, label %20, label %28
20: ; preds = %0, %20
%21 = phi i64 [ %24, %20 ], [ 0, %0 ]
%22 = getelementptr inbounds [10 x [10 x i8]], [10 x [10 x i8]]* %6, i64 0, i64 %21, i64 0
%23 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i8* %22)
%24 = add nuw nsw i64 %21, 1
%25 = load i32, i32* %2
%26 = sext i32 %25 to i64
%27 = icmp slt i64 %24, %26
br i1 %27, label %20, label %28
28: ; preds = %20, %0
%29 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%30 = load i32, i32* %5
%31 = icmp sgt i32 %30, 0
br i1 %31, label %36, label %32
32: ; preds = %36, %28
%33 = phi i32 [ %30, %28 ], [ %41, %36 ]
%34 = load i32, i32* %3
%35 = icmp sgt i32 %34, 0
br i1 %35, label %57, label %46
36: ; preds = %28, %36
%37 = phi i64 [ %40, %36 ], [ 0, %28 ]
%38 = getelementptr inbounds [60 x i8], [60 x i8]* %7, i64 0, i64 %37
%39 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), i8* %38)
%40 = add nuw nsw i64 %37, 1
%41 = load i32, i32* %5
%42 = sext i32 %41 to i64
%43 = icmp slt i64 %40, %42
br i1 %43, label %36, label %32
44: ; preds = %57
%45 = load i32, i32* %5
br label %46
46: ; preds = %44, %32
%47 = phi i32 [ %45, %44 ], [ %33, %32 ]
%48 = icmp sgt i32 %47, 0
br i1 %48, label %49, label %170
49: ; preds = %46
%50 = load i32, i32* %1
%51 = add nsw i32 %50, -1
%52 = load i32, i32* %2
%53 = add nsw i32 %52, -1
%54 = call i32 @llvm.smax.i32(i32 %52, i32 0)
%55 = sext i32 %53 to i64
%56 = zext i32 %54 to i64
br label %65
57: ; preds = %32, %57
%58 = phi i64 [ %61, %57 ], [ 0, %32 ]
%59 = getelementptr inbounds [9 x [62 x i8]], [9 x [62 x i8]]* %8, i64 0, i64 %58, i64 0
%60 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i8* %59)
%61 = add nuw nsw i64 %58, 1
%62 = load i32, i32* %3
%63 = sext i32 %62 to i64
%64 = icmp slt i64 %61, %63
br i1 %64, label %57, label %44
65: ; preds = %49, %161
%66 = phi i8 [ 46, %49 ], [ %165, %161 ]
%67 = phi i32 [ 0, %49 ], [ %164, %161 ]
%68 = phi i32 [ 0, %49 ], [ %163, %161 ]
%69 = phi i32 [ 0, %49 ], [ %166, %161 ]
%70 = sext i32 %69 to i64
%71 = getelementptr inbounds [60 x i8], [60 x i8]* %7, i64 0, i64 %70
%72 = load i8, i8* %71
%73 = sext i8 %72 to i64
%74 = add nsw i64 %73, -49
%75 = getelementptr inbounds [9 x [62 x i8]], [9 x [62 x i8]]* %8, i64 0, i64 %74, i64 0
%76 = load i8, i8* %75
%77 = icmp eq i8 %76, 42
br i1 %77, label %161, label %78
78: ; preds = %65, %149
%79 = phi i8 [ %159, %149 ], [ %76, %65 ]
%80 = phi i8 [ %153, %149 ], [ %66, %65 ]
%81 = phi i32 [ %152, %149 ], [ %67, %65 ]
%82 = phi i32 [ %151, %149 ], [ %68, %65 ]
%83 = phi i32 [ %156, %149 ], [ 0, %65 ]
%84 = phi i32 [ %155, %149 ], [ %69, %65 ]
%85 = sext i8 %79 to i32
switch i32 %85, label %149 [
i32 68, label %86
i32 82, label %111
i32 76, label %122
i32 66, label %133
i32 71, label %137
i32 78, label %141
i32 65, label %145
]
86: ; preds = %78
%87 = icmp eq i8 %80, 46
%88 = sext i32 %82 to i64
br i1 %87, label %89, label %98
89: ; preds = %86, %89
%90 = phi i64 [ %96, %89 ], [ 0, %86 ]
%91 = getelementptr inbounds [10 x [10 x i8]], [10 x [10 x i8]]* %6, i64 0, i64 %90, i64 %88
%92 = load i8, i8* %91
%93 = icmp eq i8 %92, 46
%94 = icmp slt i64 %90, %55
%95 = select i1 %93, i1 %94, i1 false
%96 = add nuw nsw i64 %90, 1
br i1 %95, label %89, label %97
97: ; preds = %89
store i8 46, i8* %91
br label %149
98: ; preds = %86, %101
%99 = phi i64 [ %102, %101 ], [ 0, %86 ]
%100 = icmp eq i64 %99, %56
br i1 %100, label %108, label %101
101: ; preds = %98
%102 = add nuw nsw i64 %99, 1
%103 = getelementptr inbounds [10 x [10 x i8]], [10 x [10 x i8]]* %6, i64 0, i64 %102, i64 %88
%104 = load i8, i8* %103
%105 = icmp eq i8 %104, 46
br i1 %105, label %98, label %106
106: ; preds = %101
%107 = and i64 %99, 4294967295
br label %108
108: ; preds = %98, %106
%109 = phi i64 [ %107, %106 ], [ %56, %98 ]
%110 = getelementptr inbounds [10 x [10 x i8]], [10 x [10 x i8]]* %6, i64 0, i64 %109, i64 %88
store i8 %80, i8* %110
br label %149
111: ; preds = %78
%112 = icmp slt i32 %82, %51
%113 = zext i1 %112 to i32
%114 = add nsw i32 %82, %113
%115 = sext i32 %114 to i64
%116 = getelementptr inbounds [10 x [10 x i8]], [10 x [10 x i8]]* %6, i64 0, i64 0, i64 %115
%117 = load i8, i8* %116
%118 = icmp ne i8 %117, 46
%119 = icmp ne i8 %80, 46
%120 = select i1 %118, i1 %119, i1 false
%121 = select i1 %120, i32 1, i32 %81
br label %149
122: ; preds = %78
%123 = icmp sgt i32 %82, 0
%124 = sext i1 %123 to i32
%125 = add nsw i32 %82, %124
%126 = sext i32 %125 to i64
%127 = getelementptr inbounds [10 x [10 x i8]], [10 x [10 x i8]]* %6, i64 0, i64 0, i64 %126
%128 = load i8, i8* %127
%129 = icmp ne i8 %128, 46
%130 = icmp ne i8 %80, 46
%131 = select i1 %129, i1 %130, i1 false
%132 = select i1 %131, i32 1, i32 %81
br label %149
133: ; preds = %78
%134 = icmp ne i8 %80, 66
%135 = zext i1 %134 to i32
%136 = add nsw i32 %83, %135
br label %149
137: ; preds = %78
%138 = icmp ne i8 %80, 71
%139 = zext i1 %138 to i32
%140 = add nsw i32 %83, %139
br label %149
141: ; preds = %78
%142 = icmp ne i8 %80, 46
%143 = zext i1 %142 to i32
%144 = add nsw i32 %83, %143
br label %149
145: ; preds = %78
%146 = icmp eq i8 %80, 46
%147 = zext i1 %146 to i32
%148 = add nsw i32 %83, %147
br label %149
149: ; preds = %122, %111, %145, %141, %137, %133, %97, %108, %78
%150 = phi i32 [ %83, %78 ], [ %83, %97 ], [ %83, %108 ], [ %136, %133 ], [ %140, %137 ], [ %144, %141 ], [ %148, %145 ], [ %83, %111 ], [ %83, %122 ]
%151 = phi i32 [ %82, %78 ], [ %82, %97 ], [ %82, %108 ], [ %82, %133 ], [ %82, %137 ], [ %82, %141 ], [ %82, %145 ], [ %114, %111 ], [ %125, %122 ]
%152 = phi i32 [ %81, %78 ], [ %81, %97 ], [ %81, %108 ], [ %81, %133 ], [ %81, %137 ], [ %81, %141 ], [ %81, %145 ], [ %121, %111 ], [ %132, %122 ]
%153 = phi i8 [ %80, %78 ], [ %92, %97 ], [ 46, %108 ], [ %80, %133 ], [ %80, %137 ], [ %80, %141 ], [ %80, %145 ], [ %80, %111 ], [ %80, %122 ]
%154 = icmp eq i32 %152, 1
%155 = select i1 %154, i32 %47, i32 %84
%156 = add nsw i32 %150, 1
%157 = sext i32 %156 to i64
%158 = getelementptr inbounds [9 x [62 x i8]], [9 x [62 x i8]]* %8, i64 0, i64 %74, i64 %157
%159 = load i8, i8* %158
%160 = icmp eq i8 %159, 42
br i1 %160, label %161, label %78
161: ; preds = %149, %65
%162 = phi i32 [ %69, %65 ], [ %155, %149 ]
%163 = phi i32 [ %68, %65 ], [ %151, %149 ]
%164 = phi i32 [ %67, %65 ], [ %152, %149 ]
%165 = phi i8 [ %66, %65 ], [ %153, %149 ]
%166 = add nsw i32 %162, 1
%167 = icmp slt i32 %166, %47
br i1 %167, label %65, label %168
168: ; preds = %161
%169 = icmp eq i32 %164, 0
br i1 %169, label %170, label %182
170: ; preds = %46, %168
%171 = load i32, i32* %2
%172 = icmp sgt i32 %171, 0
br i1 %172, label %173, label %184
173: ; preds = %170, %173
%174 = phi i64 [ %178, %173 ], [ 0, %170 ]
%175 = getelementptr inbounds [10 x [10 x i8]], [10 x [10 x i8]]* %6, i64 0, i64 %174, i64 0
%176 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i8* %175)
%177 = call i32 @putchar(i32 10)
%178 = add nuw nsw i64 %174, 1
%179 = load i32, i32* %2
%180 = sext i32 %179 to i64
%181 = icmp slt i64 %178, %180
br i1 %181, label %173, label %184
182: ; preds = %168
%183 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([20 x i8], [20 x i8]* @str, i64 0, i64 0))
br label %184
184: ; preds = %173, %170, %182
ret i32 0
}