#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);
int resultado_impacto(int);
int checar_colision(int posicioHorizontalMario, int posicionVerticalMario,
                    char movimiento, int nivel[14][212]) {
  int colision = 0;
  switch (movimiento) {
  case 'w':
    if (resultado_impacto(
            nivel[posicioHorizontalMario][posicionVerticalMario]) == 1)
      colision = 1;
    break;
  case 'a':
    if (resultado_impacto(
            nivel[posicioHorizontalMario][posicionVerticalMario]) == 1)
      colision = 1;
    break;
  case 's':
    if (resultado_impacto(
            nivel[posicioHorizontalMario][posicionVerticalMario]) == 1)
      colision = 1;
    printf("%i\n", nivel[posicioHorizontalMario][posicionVerticalMario]);
    break;
  case 'd':
    if (resultado_impacto(
            nivel[posicioHorizontalMario][posicionVerticalMario]) == 1)
      colision = 1;
    break;
  }
  return colision;
}


x86 assembly (clang, -O0):
<checar_colision>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %dl,%al
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %al,-0x9(%rbp)
mov    %rcx,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
movsbl -0x9(%rbp),%eax
add    $0xffffff9f,%eax
mov    %eax,%ecx
mov    %rcx,-0x28(%rbp)
sub    $0x16,%eax
ja     1259 <checar_colision+0x139>
mov    -0x28(%rbp),%rax
lea    0xea1(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x18(%rbp),%rax
movslq -0x4(%rbp),%rcx
imul   $0x350,%rcx,%rcx
add    %rcx,%rax
movslq -0x8(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
call   1040 <resultado_impacto@plt>
cmp    $0x1,%eax
jne    1196 <checar_colision+0x76>
movl   $0x1,-0x1c(%rbp)
jmp    1259 <checar_colision+0x139>
mov    -0x18(%rbp),%rax
movslq -0x4(%rbp),%rcx
imul   $0x350,%rcx,%rcx
add    %rcx,%rax
movslq -0x8(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
call   1040 <resultado_impacto@plt>
cmp    $0x1,%eax
jne    11c9 <checar_colision+0xa9>
movl   $0x1,-0x1c(%rbp)
jmp    1259 <checar_colision+0x139>
mov    -0x18(%rbp),%rax
movslq -0x4(%rbp),%rcx
imul   $0x350,%rcx,%rcx
add    %rcx,%rax
movslq -0x8(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
call   1040 <resultado_impacto@plt>
cmp    $0x1,%eax
jne    11fc <checar_colision+0xdc>
movl   $0x1,-0x1c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x4(%rbp),%rcx
imul   $0x350,%rcx,%rcx
add    %rcx,%rax
movslq -0x8(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
lea    0xe40(%rip),%rdi
call   1030 <printf@plt>
jmp    1259 <checar_colision+0x139>
mov    -0x18(%rbp),%rax
movslq -0x4(%rbp),%rcx
imul   $0x350,%rcx,%rcx
add    %rcx,%rax
movslq -0x8(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
call   1040 <resultado_impacto@plt>
cmp    $0x1,%eax
jne    1254 <checar_colision+0x134>
movl   $0x1,-0x1c(%rbp)
jmp    1259 <checar_colision+0x139>
mov    -0x1c(%rbp),%eax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<checar_colision>:
push   %rbp
push   %r14
push   %rbx
xor    %ebp,%ebp
add    $0xffffff9f,%edx
cmp    $0x16,%edx
ja     1192 <checar_colision+0x72>
mov    %rcx,%rbx
lea    0xec8(%rip),%rax
movslq (%rax,%rdx,4),%rcx
add    %rax,%rcx
jmp    *%rcx
movslq %edi,%rax
movslq %esi,%rcx
imul   $0x350,%rax,%rax
add    %rax,%rbx
mov    (%rbx,%rcx,4),%edi
call   1040 <resultado_impacto@plt>
cmp    $0x1,%eax
sete   %bpl
jmp    1192 <checar_colision+0x72>
movslq %edi,%rax
movslq %esi,%r14
imul   $0x350,%rax,%rax
add    %rax,%rbx
mov    (%rbx,%r14,4),%edi
call   1040 <resultado_impacto@plt>
cmp    $0x1,%eax
sete   %bpl
mov    (%rbx,%r14,4),%esi
lea    0xecf(%rip),%rdi
call   1030 <printf@plt>
movzbl %bpl,%eax
pop    %rbx
pop    %r14
pop    %rbp
ret

LLVM IR (-O0):
@.str = [4 x i8] c"%i\0A\00"
define i32 @checar_colision(i32 %0, i32 %1, i8 signext %2, [212 x i32]* %3) {
%5 = alloca i32
%6 = alloca i32
%7 = alloca i8
%8 = alloca [212 x i32]*
%9 = alloca i32
store i32 %0, i32* %5
store i32 %1, i32* %6
store i8 %2, i8* %7
store [212 x i32]* %3, [212 x i32]** %8
store i32 0, i32* %9
%10 = load i8, i8* %7
%11 = sext i8 %10 to i32
switch i32 %11, label %73 [
i32 119, label %12
i32 97, label %25
i32 115, label %38
i32 100, label %60
]
12: ; preds = %4
%13 = load [212 x i32]*, [212 x i32]** %8
%14 = load i32, i32* %5
%15 = sext i32 %14 to i64
%16 = getelementptr inbounds [212 x i32], [212 x i32]* %13, i64 %15
%17 = load i32, i32* %6
%18 = sext i32 %17 to i64
%19 = getelementptr inbounds [212 x i32], [212 x i32]* %16, i64 0, i64 %18
%20 = load i32, i32* %19
%21 = call i32 @resultado_impacto(i32 %20)
%22 = icmp eq i32 %21, 1
br i1 %22, label %23, label %24
23: ; preds = %12
store i32 1, i32* %9
br label %24
24: ; preds = %23, %12
br label %73
25: ; preds = %4
%26 = load [212 x i32]*, [212 x i32]** %8
%27 = load i32, i32* %5
%28 = sext i32 %27 to i64
%29 = getelementptr inbounds [212 x i32], [212 x i32]* %26, i64 %28
%30 = load i32, i32* %6
%31 = sext i32 %30 to i64
%32 = getelementptr inbounds [212 x i32], [212 x i32]* %29, i64 0, i64 %31
%33 = load i32, i32* %32
%34 = call i32 @resultado_impacto(i32 %33)
%35 = icmp eq i32 %34, 1
br i1 %35, label %36, label %37
36: ; preds = %25
store i32 1, i32* %9
br label %37
37: ; preds = %36, %25
br label %73
38: ; preds = %4
%39 = load [212 x i32]*, [212 x i32]** %8
%40 = load i32, i32* %5
%41 = sext i32 %40 to i64
%42 = getelementptr inbounds [212 x i32], [212 x i32]* %39, i64 %41
%43 = load i32, i32* %6
%44 = sext i32 %43 to i64
%45 = getelementptr inbounds [212 x i32], [212 x i32]* %42, i64 0, i64 %44
%46 = load i32, i32* %45
%47 = call i32 @resultado_impacto(i32 %46)
%48 = icmp eq i32 %47, 1
br i1 %48, label %49, label %50
49: ; preds = %38
store i32 1, i32* %9
br label %50
50: ; preds = %49, %38
%51 = load [212 x i32]*, [212 x i32]** %8
%52 = load i32, i32* %5
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds [212 x i32], [212 x i32]* %51, i64 %53
%55 = load i32, i32* %6
%56 = sext i32 %55 to i64
%57 = getelementptr inbounds [212 x i32], [212 x i32]* %54, i64 0, i64 %56
%58 = load i32, i32* %57
%59 = call i32 @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i32 %58)
br label %73
60: ; preds = %4
%61 = load [212 x i32]*, [212 x i32]** %8
%62 = load i32, i32* %5
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds [212 x i32], [212 x i32]* %61, i64 %63
%65 = load i32, i32* %6
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds [212 x i32], [212 x i32]* %64, i64 0, i64 %66
%68 = load i32, i32* %67
%69 = call i32 @resultado_impacto(i32 %68)
%70 = icmp eq i32 %69, 1
br i1 %70, label %71, label %72
71: ; preds = %60
store i32 1, i32* %9
br label %72
72: ; preds = %71, %60
br label %73
73: ; preds = %4, %72, %50, %37, %24
%74 = load i32, i32* %9
ret i32 %74
}

LLVM IR (-O2):
@.str = [4 x i8] c"%i\0A\00"
define i32 @checar_colision(i32 %0, i32 %1, i8 signext %2, [212 x i32]* nocapture %3) {
%5 = sext i8 %2 to i32
switch i32 %5, label %36 [
i32 119, label %6
i32 97, label %13
i32 115, label %20
i32 100, label %29
]
6: ; preds = %4
%7 = sext i32 %0 to i64
%8 = sext i32 %1 to i64
%9 = getelementptr inbounds [212 x i32], [212 x i32]* %3, i64 %7, i64 %8
%10 = load i32, i32* %9
%11 = tail call i32 @resultado_impacto(i32 %10)
%12 = icmp eq i32 %11, 1
br label %36
13: ; preds = %4
%14 = sext i32 %0 to i64
%15 = sext i32 %1 to i64
%16 = getelementptr inbounds [212 x i32], [212 x i32]* %3, i64 %14, i64 %15
%17 = load i32, i32* %16
%18 = tail call i32 @resultado_impacto(i32 %17)
%19 = icmp eq i32 %18, 1
br label %36
20: ; preds = %4
%21 = sext i32 %0 to i64
%22 = sext i32 %1 to i64
%23 = getelementptr inbounds [212 x i32], [212 x i32]* %3, i64 %21, i64 %22
%24 = load i32, i32* %23
%25 = tail call i32 @resultado_impacto(i32 %24)
%26 = icmp eq i32 %25, 1
%27 = load i32, i32* %23
%28 = tail call i32 @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i32 %27)
br label %36
29: ; preds = %4
%30 = sext i32 %0 to i64
%31 = sext i32 %1 to i64
%32 = getelementptr inbounds [212 x i32], [212 x i32]* %3, i64 %30, i64 %31
%33 = load i32, i32* %32
%34 = tail call i32 @resultado_impacto(i32 %33)
%35 = icmp eq i32 %34, 1
br label %36
36: ; preds = %29, %13, %6, %4, %20
%37 = phi i1 [ false, %4 ], [ %26, %20 ], [ %12, %6 ], [ %19, %13 ], [ %35, %29 ]
%38 = zext i1 %37 to i32
ret i32 %38
}