#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*/ alfa_beta(int, char *, char, int *, int *, int, int, int);
int /*<<< orphan*/ copiar_tablero(char *, char *);
int encontrar_jugada_posible(char *, char, int *, int *, int);
scalar_t__ es_mate(char *);
int evaluar_tablero(char *, char);
int /*<<< orphan*/ quicksort(int *, int *, int *, int *);
int /*<<< orphan*/ realizar_jugada(char *, int, int, int, int);
void alfa_beta_opt(int profundidad, char *ptablero, char jugador,
                   int *jugada_mejor, int *puntaje, int niv_rec, int a, int b) {
  int jugada_elegida = 0, puntaje_elegido = 10000, jugada = 0, num_jugadas = 0;
  char copia_tablero[64];
  register int i = 0;
  int a1 = 0, a2 = 0, puntajes_ordenar[300], jugadas_ordenadas[300];
  while (jugadas_ordenadas[num_jugadas] = encontrar_jugada_posible(
             ptablero, jugador, &a1, &a2, num_jugadas)) {
    copiar_tablero(ptablero, copia_tablero);
    realizar_jugada(copia_tablero, jugadas_ordenadas[num_jugadas] >> 9,
                    (jugadas_ordenadas[num_jugadas] >> 6) % 8,
                    (jugadas_ordenadas[num_jugadas] >> 3) % 8,
                    jugadas_ordenadas[num_jugadas] % 8);
    if (es_mate(copia_tablero)) {
      *jugada_mejor = jugadas_ordenadas[num_jugadas];
      if (profundidad % 2)
        *puntaje = -10000;
      else
        *puntaje = 10000;
      return;
    }
    puntajes_ordenar[num_jugadas++] = -evaluar_tablero(copia_tablero, jugador);
  }
  quicksort(puntajes_ordenar, &puntajes_ordenar[num_jugadas - 1],
            puntajes_ordenar, jugadas_ordenadas);
  for (; i < num_jugadas; i++) {
    jugada = jugadas_ordenadas[i];
    copiar_tablero(ptablero, copia_tablero);
    realizar_jugada(copia_tablero, jugada >> 9, (jugada >> 6) % 8,
                    (jugada >> 3) % 8, jugada % 8);
    if (profundidad < 3)
      alfa_beta(profundidad - 1, copia_tablero, ((jugador == 'N') ? 'B' : 'N'),
                jugada_mejor, puntaje, niv_rec + 1, a, b);
    else
      alfa_beta_opt(profundidad - 1, copia_tablero,
                    ((jugador == 'N') ? 'B' : 'N'), jugada_mejor, puntaje,
                    niv_rec + 1, a, b);
    if ((niv_rec + 7) % 2) {
      if (*puntaje < puntaje_elegido || jugada_elegida == 0) {
        puntaje_elegido = *puntaje;
        jugada_elegida = jugada;
      }
      b = puntaje_elegido;
      if (b <= a) {
        *puntaje = a;
        *jugada_mejor = jugada_elegida;
        return;
      }
    } else {
      if (*puntaje > puntaje_elegido || jugada_elegida == 0) {
        puntaje_elegido = *puntaje;
        jugada_elegida = jugada;
      }
      a = puntaje_elegido;
      if (a >= b) {
        *puntaje = b;
        *jugada_mejor = jugada_elegida;
        return;
      }
    }
  }
  *puntaje = puntaje_elegido;
  *jugada_mejor = jugada_elegida;
}


x86 assembly (clang, -O0):
<alfa_beta_opt>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa10,%rsp
mov    %dl,%al
mov    0x18(%rbp),%edx
mov    0x10(%rbp),%edx
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %al,-0x11(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9d,-0x2c(%rbp)
movl   $0x0,-0x30(%rbp)
movl   $0x2710,-0x34(%rbp)
movl   $0x0,-0x38(%rbp)
movl   $0x0,-0x3c(%rbp)
movl   $0x0,-0x84(%rbp)
movl   $0x0,-0x88(%rbp)
movl   $0x0,-0x8c(%rbp)
mov    -0x10(%rbp),%rdi
mov    -0x11(%rbp),%al
mov    -0x3c(%rbp),%r8d
lea    -0x88(%rbp),%rdx
lea    -0x8c(%rbp),%rcx
movsbl %al,%esi
call   1030 <encontrar_jugada_posible@plt>
movslq -0x3c(%rbp),%rcx
mov    %eax,-0x9f0(%rbp,%rcx,4)
cmp    $0x0,%eax
je     130e <alfa_beta_opt+0x18e>
mov    -0x10(%rbp),%rdi
lea    -0x80(%rbp),%rsi
call   1070 <copiar_tablero@plt>
lea    -0x80(%rbp),%rdi
movslq -0x3c(%rbp),%rax
mov    -0x9f0(%rbp,%rax,4),%esi
sar    $0x9,%esi
movslq -0x3c(%rbp),%rax
mov    -0x9f0(%rbp,%rax,4),%eax
sar    $0x6,%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    %edx,-0x9f4(%rbp)
movslq -0x3c(%rbp),%rax
mov    -0x9f0(%rbp,%rax,4),%eax
sar    $0x3,%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    %edx,%ecx
movslq -0x3c(%rbp),%rax
mov    -0x9f0(%rbp,%rax,4),%eax
mov    $0x8,%r8d
cltd
idiv   %r8d
mov    %edx,%r8d
mov    -0x9f4(%rbp),%edx
call   1090 <realizar_jugada@plt>
lea    -0x80(%rbp),%rdi
call   1050 <es_mate@plt>
cmp    $0x0,%rax
je     12e4 <alfa_beta_opt+0x164>
movslq -0x3c(%rbp),%rax
mov    -0x9f0(%rbp,%rax,4),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x4(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
je     12d5 <alfa_beta_opt+0x155>
mov    -0x28(%rbp),%rax
movl   $0xffffd8f0,(%rax)
jmp    12df <alfa_beta_opt+0x15f>
mov    -0x28(%rbp),%rax
movl   $0x2710,(%rax)
jmp    153f <alfa_beta_opt+0x3bf>
lea    -0x80(%rbp),%rdi
movsbl -0x11(%rbp),%esi
call   1060 <evaluar_tablero@plt>
xor    %ecx,%ecx
sub    %eax,%ecx
mov    -0x3c(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x3c(%rbp)
cltq
mov    %ecx,-0x540(%rbp,%rax,4)
jmp    11e3 <alfa_beta_opt+0x63>
lea    -0x540(%rbp),%rdi
mov    -0x3c(%rbp),%eax
sub    $0x1,%eax
cltq
lea    -0x540(%rbp),%rsi
shl    $0x2,%rax
add    %rax,%rsi
lea    -0x540(%rbp),%rdx
lea    -0x9f0(%rbp),%rcx
call   1040 <quicksort@plt>
mov    -0x84(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    152d <alfa_beta_opt+0x3ad>
movslq -0x84(%rbp),%rax
mov    -0x9f0(%rbp,%rax,4),%eax
mov    %eax,-0x38(%rbp)
mov    -0x10(%rbp),%rdi
lea    -0x80(%rbp),%rsi
call   1070 <copiar_tablero@plt>
lea    -0x80(%rbp),%rdi
mov    -0x38(%rbp),%esi
sar    $0x9,%esi
mov    -0x38(%rbp),%eax
sar    $0x6,%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    %edx,-0x9f8(%rbp)
mov    -0x38(%rbp),%eax
sar    $0x3,%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    %edx,%ecx
mov    -0x38(%rbp),%eax
mov    $0x8,%r8d
cltd
idiv   %r8d
mov    %edx,%r8d
mov    -0x9f8(%rbp),%edx
call   1090 <realizar_jugada@plt>
cmpl   $0x3,-0x4(%rbp)
jge    140a <alfa_beta_opt+0x28a>
mov    -0x4(%rbp),%edi
sub    $0x1,%edi
lea    -0x80(%rbp),%rsi
movsbl -0x11(%rbp),%edx
mov    $0x4e,%eax
mov    $0x42,%ecx
cmp    $0x4e,%edx
cmove  %ecx,%eax
mov    %al,%dl
mov    -0x20(%rbp),%rcx
mov    -0x28(%rbp),%r8
mov    -0x2c(%rbp),%r9d
add    $0x1,%r9d
mov    0x10(%rbp),%r10d
mov    0x18(%rbp),%eax
movsbl %dl,%edx
mov    %r10d,(%rsp)
mov    %eax,0x8(%rsp)
call   10a0 <alfa_beta@plt>
jmp    1451 <alfa_beta_opt+0x2d1>
mov    -0x4(%rbp),%edi
sub    $0x1,%edi
lea    -0x80(%rbp),%rsi
movsbl -0x11(%rbp),%edx
mov    $0x4e,%eax
mov    $0x42,%ecx
cmp    $0x4e,%edx
cmove  %ecx,%eax
mov    %al,%dl
mov    -0x20(%rbp),%rcx
mov    -0x28(%rbp),%r8
mov    -0x2c(%rbp),%r9d
add    $0x1,%r9d
mov    0x10(%rbp),%r10d
mov    0x18(%rbp),%eax
movsbl %dl,%edx
mov    %r10d,(%rsp)
mov    %eax,0x8(%rsp)
call   1080 <alfa_beta_opt@plt>
mov    -0x2c(%rbp),%eax
add    $0x7,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
je     14be <alfa_beta_opt+0x33e>
mov    -0x28(%rbp),%rax
mov    (%rax),%eax
cmp    -0x34(%rbp),%eax
jl     1481 <alfa_beta_opt+0x301>
cmpl   $0x0,-0x30(%rbp)
jne    1490 <alfa_beta_opt+0x310>
mov    -0x28(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,0x18(%rbp)
mov    0x18(%rbp),%eax
cmp    0x10(%rbp),%eax
jg     14b9 <alfa_beta_opt+0x339>
mov    0x10(%rbp),%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x30(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
jmp    153f <alfa_beta_opt+0x3bf>
jmp    1514 <alfa_beta_opt+0x394>
mov    -0x28(%rbp),%rax
mov    (%rax),%eax
cmp    -0x34(%rbp),%eax
jg     14d7 <alfa_beta_opt+0x357>
cmpl   $0x0,-0x30(%rbp)
jne    14e6 <alfa_beta_opt+0x366>
mov    -0x28(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,0x10(%rbp)
mov    0x10(%rbp),%eax
cmp    0x18(%rbp),%eax
jl     150f <alfa_beta_opt+0x38f>
mov    0x18(%rbp),%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x30(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
jmp    153f <alfa_beta_opt+0x3bf>
jmp    1514 <alfa_beta_opt+0x394>
jmp    1519 <alfa_beta_opt+0x399>
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    133e <alfa_beta_opt+0x1be>
mov    -0x34(%rbp),%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x30(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
add    $0xa10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<alfa_beta_opt>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x9f8,%rsp
mov    %r9,0x40(%rsp)
mov    %r8,0x30(%rsp)
mov    %rcx,0x8(%rsp)
mov    %edx,%eax
mov    %rsi,%rbx
mov    %rdi,0x38(%rsp)
movl   $0x0,0x2c(%rsp)
movl   $0x0,0x28(%rsp)
lea    0x2c(%rsp),%rdx
lea    0x28(%rsp),%rcx
xor    %r12d,%r12d
mov    %rsi,%rdi
mov    %eax,0x4(%rsp)
mov    %eax,%esi
xor    %r8d,%r8d
call   1030 <encontrar_jugada_posible@plt>
mov    %eax,0x90(%rsp)
mov    $0x0,%r13d
test   %eax,%eax
je     12b3 <alfa_beta_opt+0x133>
xor    %r15d,%r15d
lea    0x50(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rbx,%rdi
mov    %rbp,%rsi
call   1070 <copiar_tablero@plt>
mov    0x90(%rsp,%r15,4),%r8d
mov    %r8d,%esi
sar    $0x9,%esi
mov    %r8d,%edx
sar    $0x6,%edx
lea    0x7(%rdx),%eax
test   %edx,%edx
cmovns %edx,%eax
and    $0xfffffff8,%eax
sub    %eax,%edx
mov    %r8d,%ecx
sar    $0x3,%ecx
lea    0x7(%rcx),%eax
test   %ecx,%ecx
cmovns %ecx,%eax
and    $0xfffffff8,%eax
sub    %eax,%ecx
lea    0x7(%r8),%eax
test   %r8d,%r8d
cmovns %r8d,%eax
and    $0xfffffff8,%eax
sub    %eax,%r8d
mov    %rbp,%rdi
call   1090 <realizar_jugada@plt>
mov    %rbp,%rdi
call   1050 <es_mate@plt>
test   %rax,%rax
jne    149a <alfa_beta_opt+0x31a>
movsbl 0x4(%rsp),%r14d
mov    %rbp,%rdi
mov    %r14d,%esi
call   1060 <evaluar_tablero@plt>
neg    %eax
lea    0x1(%r15),%r13
mov    %eax,0x540(%rsp,%r15,4)
mov    %rbx,%rdi
mov    %r14d,%esi
lea    0x2c(%rsp),%rdx
lea    0x28(%rsp),%rcx
mov    %r13d,%r8d
call   1030 <encontrar_jugada_posible@plt>
mov    %eax,0x94(%rsp,%r15,4)
mov    %r13,%r15
test   %eax,%eax
jne    1200 <alfa_beta_opt+0x80>
lea    -0x1(%r13),%eax
cltq
lea    (%rsp,%rax,4),%rsi
add    $0x540,%rsi
lea    0x540(%rsp),%rdi
lea    0x90(%rsp),%rcx
mov    %rdi,%rdx
call   1040 <quicksort@plt>
mov    $0x2710,%r14d
cmp    $0x1,%r13d
jae    12fd <alfa_beta_opt+0x17d>
mov    0x30(%rsp),%rax
mov    %r14d,(%rax)
mov    0x8(%rsp),%rax
mov    %r12d,(%rax)
jmp    14c2 <alfa_beta_opt+0x342>
mov    0xa38(%rsp),%eax
mov    %rax,0x18(%rsp)
mov    0xa30(%rsp),%eax
mov    %rax,0x10(%rsp)
mov    0x38(%rsp),%rax
add    $0xffffffff,%eax
mov    %eax,0x24(%rsp)
cmpb   $0x4e,0x4(%rsp)
mov    $0x42,%eax
mov    $0x4e,%ecx
cmove  %eax,%ecx
mov    %ecx,0x4(%rsp)
mov    0x40(%rsp),%rax
add    $0x1,%eax
mov    %eax,0x20(%rsp)
mov    %r13d,%eax
mov    %rax,0x48(%rsp)
xor    %r13d,%r13d
mov    $0x2710,%r14d
lea    0x50(%rsp),%rbp
xor    %r15d,%r15d
jmp    1377 <alfa_beta_opt+0x1f7>
xchg   %ax,%ax
add    $0x1,%r13
mov    %r12d,%r15d
cmp    %r13,0x48(%rsp)
lea    0x50(%rsp),%rbp
je     12e8 <alfa_beta_opt+0x168>
mov    0x90(%rsp,%r13,4),%r12d
mov    %rbx,%rdi
mov    %rbp,%rsi
call   1070 <copiar_tablero@plt>
mov    %r12d,%esi
sar    $0x9,%esi
mov    %r12d,%edx
sar    $0x6,%edx
lea    0x7(%rdx),%eax
test   %edx,%edx
cmovns %edx,%eax
and    $0xfffffff8,%eax
sub    %eax,%edx
mov    %r12d,%ecx
sar    $0x3,%ecx
lea    0x7(%rcx),%eax
test   %ecx,%ecx
cmovns %ecx,%eax
and    $0xfffffff8,%eax
sub    %eax,%ecx
lea    0x7(%r12),%eax
test   %r12d,%r12d
cmovns %r12d,%eax
and    $0xfffffff8,%eax
mov    %r12d,%r8d
sub    %eax,%r8d
mov    %rbp,%rdi
call   1090 <realizar_jugada@plt>
movzbl 0x4(%rsp),%edx
cmpl   $0x2,0x38(%rsp)
jg     1410 <alfa_beta_opt+0x290>
mov    0x24(%rsp),%edi
mov    %rbp,%rsi
mov    0x8(%rsp),%rcx
mov    0x30(%rsp),%rbp
mov    %rbp,%r8
mov    0x20(%rsp),%r9d
push   0x18(%rsp)
push   0x18(%rsp)
call   10a0 <alfa_beta@plt>
jmp    1436 <alfa_beta_opt+0x2b6>
nopw   0x0(%rax,%rax,1)
mov    0x24(%rsp),%edi
mov    %rbp,%rsi
mov    0x8(%rsp),%rcx
mov    0x30(%rsp),%rbp
mov    %rbp,%r8
mov    0x20(%rsp),%r9d
push   0x18(%rsp)
push   0x18(%rsp)
call   1080 <alfa_beta_opt@plt>
add    $0x10,%rsp
mov    0x0(%rbp),%eax
testb  $0x1,0x40(%rsp)
jne    1470 <alfa_beta_opt+0x2f0>
cmp    %r14d,%eax
setl   %cl
test   %r15d,%r15d
sete   %dl
or     %cl,%dl
cmove  %r15d,%r12d
cmovne %eax,%r14d
cmp    0x10(%rsp),%r14d
jle    14d4 <alfa_beta_opt+0x354>
mov    %r14d,%eax
mov    %rax,0x18(%rsp)
jmp    1360 <alfa_beta_opt+0x1e0>
xchg   %ax,%ax
cmp    %r14d,%eax
setg   %cl
test   %r15d,%r15d
sete   %dl
or     %cl,%dl
cmove  %r15d,%r12d
cmovne %eax,%r14d
cmp    0x18(%rsp),%r14d
jge    14e1 <alfa_beta_opt+0x361>
mov    %r14d,%eax
mov    %rax,0x10(%rsp)
jmp    1360 <alfa_beta_opt+0x1e0>
mov    0x90(%rsp,%r15,4),%eax
mov    0x8(%rsp),%rcx
mov    %eax,(%rcx)
testb  $0x1,0x38(%rsp)
mov    $0x2710,%eax
mov    $0xffffd8f0,%ecx
cmove  %eax,%ecx
mov    0x30(%rsp),%rax
mov    %ecx,(%rax)
add    $0x9f8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0x10(%rsp),%rax
mov    %eax,0x0(%rbp)
jmp    12f0 <alfa_beta_opt+0x170>
mov    0x18(%rsp),%rax
mov    %eax,0x0(%rbp)
jmp    12f0 <alfa_beta_opt+0x170>

LLVM IR (-O0):
define void @alfa_beta_opt(i32 %0, i8* %1, i8 signext %2, i32* %3, i32* %4, i32 %5, i32 %6, i32 %7) {
%9 = alloca i32
%10 = alloca i8*
%11 = alloca i8
%12 = alloca i32*
%13 = alloca i32*
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca [64 x i8]
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32
%25 = alloca [300 x i32]
%26 = alloca [300 x i32]
store i32 %0, i32* %9
store i8* %1, i8** %10
store i8 %2, i8* %11
store i32* %3, i32** %12
store i32* %4, i32** %13
store i32 %5, i32* %14
store i32 %6, i32* %15
store i32 %7, i32* %16
store i32 0, i32* %17
store i32 10000, i32* %18
store i32 0, i32* %19
store i32 0, i32* %20
store i32 0, i32* %22
store i32 0, i32* %23
store i32 0, i32* %24
br label %27
27: ; preds = %81, %8
%28 = load i8*, i8** %10
%29 = load i8, i8* %11
%30 = load i32, i32* %20
%31 = call i32 @encontrar_jugada_posible(i8* %28, i8 signext %29, i32* %23, i32* %24, i32 %30)
%32 = load i32, i32* %20
%33 = sext i32 %32 to i64
%34 = getelementptr inbounds [300 x i32], [300 x i32]* %26, i64 0, i64 %33
store i32 %31, i32* %34
%35 = icmp ne i32 %31, 0
br i1 %35, label %36, label %90
36: ; preds = %27
%37 = load i8*, i8** %10
%38 = getelementptr inbounds [64 x i8], [64 x i8]* %21, i64 0, i64 0
%39 = call i32 @copiar_tablero(i8* %37, i8* %38)
%40 = getelementptr inbounds [64 x i8], [64 x i8]* %21, i64 0, i64 0
%41 = load i32, i32* %20
%42 = sext i32 %41 to i64
%43 = getelementptr inbounds [300 x i32], [300 x i32]* %26, i64 0, i64 %42
%44 = load i32, i32* %43
%45 = ashr i32 %44, 9
%46 = load i32, i32* %20
%47 = sext i32 %46 to i64
%48 = getelementptr inbounds [300 x i32], [300 x i32]* %26, i64 0, i64 %47
%49 = load i32, i32* %48
%50 = ashr i32 %49, 6
%51 = srem i32 %50, 8
%52 = load i32, i32* %20
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds [300 x i32], [300 x i32]* %26, i64 0, i64 %53
%55 = load i32, i32* %54
%56 = ashr i32 %55, 3
%57 = srem i32 %56, 8
%58 = load i32, i32* %20
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds [300 x i32], [300 x i32]* %26, i64 0, i64 %59
%61 = load i32, i32* %60
%62 = srem i32 %61, 8
%63 = call i32 @realizar_jugada(i8* %40, i32 %45, i32 %51, i32 %57, i32 %62)
%64 = getelementptr inbounds [64 x i8], [64 x i8]* %21, i64 0, i64 0
%65 = call i64 @es_mate(i8* %64)
%66 = icmp ne i64 %65, 0
br i1 %66, label %67, label %81
67: ; preds = %36
%68 = load i32, i32* %20
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds [300 x i32], [300 x i32]* %26, i64 0, i64 %69
%71 = load i32, i32* %70
%72 = load i32*, i32** %12
store i32 %71, i32* %72
%73 = load i32, i32* %9
%74 = srem i32 %73, 2
%75 = icmp ne i32 %74, 0
br i1 %75, label %76, label %78
76: ; preds = %67
%77 = load i32*, i32** %13
store i32 -10000, i32* %77
br label %80
78: ; preds = %67
%79 = load i32*, i32** %13
store i32 10000, i32* %79
br label %80
80: ; preds = %78, %76
br label %218
81: ; preds = %36
%82 = getelementptr inbounds [64 x i8], [64 x i8]* %21, i64 0, i64 0
%83 = load i8, i8* %11
%84 = call i32 @evaluar_tablero(i8* %82, i8 signext %83)
%85 = sub nsw i32 0, %84
%86 = load i32, i32* %20
%87 = add nsw i32 %86, 1
store i32 %87, i32* %20
%88 = sext i32 %86 to i64
%89 = getelementptr inbounds [300 x i32], [300 x i32]* %25, i64 0, i64 %88
store i32 %85, i32* %89
br label %27
90: ; preds = %27
%91 = getelementptr inbounds [300 x i32], [300 x i32]* %25, i64 0, i64 0
%92 = load i32, i32* %20
%93 = sub nsw i32 %92, 1
%94 = sext i32 %93 to i64
%95 = getelementptr inbounds [300 x i32], [300 x i32]* %25, i64 0, i64 %94
%96 = getelementptr inbounds [300 x i32], [300 x i32]* %25, i64 0, i64 0
%97 = getelementptr inbounds [300 x i32], [300 x i32]* %26, i64 0, i64 0
%98 = call i32 @quicksort(i32* %91, i32* %95, i32* %96, i32* %97)
br label %99
99: ; preds = %210, %90
%100 = load i32, i32* %22
%101 = load i32, i32* %20
%102 = icmp slt i32 %100, %101
br i1 %102, label %103, label %213
103: ; preds = %99
%104 = load i32, i32* %22
%105 = sext i32 %104 to i64
%106 = getelementptr inbounds [300 x i32], [300 x i32]* %26, i64 0, i64 %105
%107 = load i32, i32* %106
store i32 %107, i32* %19
%108 = load i8*, i8** %10
%109 = getelementptr inbounds [64 x i8], [64 x i8]* %21, i64 0, i64 0
%110 = call i32 @copiar_tablero(i8* %108, i8* %109)
%111 = getelementptr inbounds [64 x i8], [64 x i8]* %21, i64 0, i64 0
%112 = load i32, i32* %19
%113 = ashr i32 %112, 9
%114 = load i32, i32* %19
%115 = ashr i32 %114, 6
%116 = srem i32 %115, 8
%117 = load i32, i32* %19
%118 = ashr i32 %117, 3
%119 = srem i32 %118, 8
%120 = load i32, i32* %19
%121 = srem i32 %120, 8
%122 = call i32 @realizar_jugada(i8* %111, i32 %113, i32 %116, i32 %119, i32 %121)
%123 = load i32, i32* %9
%124 = icmp slt i32 %123, 3
br i1 %124, label %125, label %142
125: ; preds = %103
%126 = load i32, i32* %9
%127 = sub nsw i32 %126, 1
%128 = getelementptr inbounds [64 x i8], [64 x i8]* %21, i64 0, i64 0
%129 = load i8, i8* %11
%130 = sext i8 %129 to i32
%131 = icmp eq i32 %130, 78
%132 = zext i1 %131 to i64
%133 = select i1 %131, i32 66, i32 78
%134 = trunc i32 %133 to i8
%135 = load i32*, i32** %12
%136 = load i32*, i32** %13
%137 = load i32, i32* %14
%138 = add nsw i32 %137, 1
%139 = load i32, i32* %15
%140 = load i32, i32* %16
%141 = call i32 @alfa_beta(i32 %127, i8* %128, i8 signext %134, i32* %135, i32* %136, i32 %138, i32 %139, i32 %140)
br label %158
142: ; preds = %103
%143 = load i32, i32* %9
%144 = sub nsw i32 %143, 1
%145 = getelementptr inbounds [64 x i8], [64 x i8]* %21, i64 0, i64 0
%146 = load i8, i8* %11
%147 = sext i8 %146 to i32
%148 = icmp eq i32 %147, 78
%149 = zext i1 %148 to i64
%150 = select i1 %148, i32 66, i32 78
%151 = trunc i32 %150 to i8
%152 = load i32*, i32** %12
%153 = load i32*, i32** %13
%154 = load i32, i32* %14
%155 = add nsw i32 %154, 1
%156 = load i32, i32* %15
%157 = load i32, i32* %16
br label %158
158: ; preds = %142, %125
%159 = load i32, i32* %14
%160 = add nsw i32 %159, 7
%161 = srem i32 %160, 2
%162 = icmp ne i32 %161, 0
br i1 %162, label %163, label %186
163: ; preds = %158
%164 = load i32*, i32** %13
%165 = load i32, i32* %164
%166 = load i32, i32* %18
%167 = icmp slt i32 %165, %166
br i1 %167, label %171, label %168
168: ; preds = %163
%169 = load i32, i32* %17
%170 = icmp eq i32 %169, 0
br i1 %170, label %171, label %175
171: ; preds = %168, %163
%172 = load i32*, i32** %13
%173 = load i32, i32* %172
store i32 %173, i32* %18
%174 = load i32, i32* %19
store i32 %174, i32* %17
br label %175
175: ; preds = %171, %168
%176 = load i32, i32* %18
store i32 %176, i32* %16
%177 = load i32, i32* %16
%178 = load i32, i32* %15
%179 = icmp sle i32 %177, %178
br i1 %179, label %180, label %185
180: ; preds = %175
%181 = load i32, i32* %15
%182 = load i32*, i32** %13
store i32 %181, i32* %182
%183 = load i32, i32* %17
%184 = load i32*, i32** %12
store i32 %183, i32* %184
br label %218
185: ; preds = %175
br label %209
186: ; preds = %158
%187 = load i32*, i32** %13
%188 = load i32, i32* %187
%189 = load i32, i32* %18
%190 = icmp sgt i32 %188, %189
br i1 %190, label %194, label %191
191: ; preds = %186
%192 = load i32, i32* %17
%193 = icmp eq i32 %192, 0
br i1 %193, label %194, label %198
194: ; preds = %191, %186
%195 = load i32*, i32** %13
%196 = load i32, i32* %195
store i32 %196, i32* %18
%197 = load i32, i32* %19
store i32 %197, i32* %17
br label %198
198: ; preds = %194, %191
%199 = load i32, i32* %18
store i32 %199, i32* %15
%200 = load i32, i32* %15
%201 = load i32, i32* %16
%202 = icmp sge i32 %200, %201
br i1 %202, label %203, label %208
203: ; preds = %198
%204 = load i32, i32* %16
%205 = load i32*, i32** %13
store i32 %204, i32* %205
%206 = load i32, i32* %17
%207 = load i32*, i32** %12
store i32 %206, i32* %207
br label %218
208: ; preds = %198
br label %209
209: ; preds = %208, %185
br label %210
210: ; preds = %209
%211 = load i32, i32* %22
%212 = add nsw i32 %211, 1
store i32 %212, i32* %22
br label %99
213: ; preds = %99
%214 = load i32, i32* %18
%215 = load i32*, i32** %13
store i32 %214, i32* %215
%216 = load i32, i32* %17
%217 = load i32*, i32** %12
store i32 %216, i32* %217
br label %218
218: ; preds = %213, %203, %180, %80
ret void
}

LLVM IR (-O2):
define void @alfa_beta_opt(i32 %0, i8* %1, i8 signext %2, i32* %3, i32* %4, i32 %5, i32 %6, i32 %7) {
%9 = alloca [64 x i8]
%10 = alloca i32
%11 = alloca i32
%12 = alloca [300 x i32]
%13 = alloca [300 x i32]
%14 = getelementptr inbounds [64 x i8], [64 x i8]* %9, i64 0, i64 0
%15 = bitcast i32* %10 to i8*
store i32 0, i32* %10
%16 = bitcast i32* %11 to i8*
store i32 0, i32* %11
%17 = bitcast [300 x i32]* %12 to i8*
%18 = bitcast [300 x i32]* %13 to i8*
%19 = call i32 @encontrar_jugada_posible(i8* %1, i8 signext %2, i32* %10, i32* %11, i32 0)
%20 = getelementptr inbounds [300 x i32], [300 x i32]* %13, i64 0, i64 0
store i32 %19, i32* %20
%21 = icmp eq i32 %19, 0
br i1 %21, label %52, label %22
22: ; preds = %8, %41
%23 = phi i64 [ %44, %41 ], [ 0, %8 ]
%24 = phi i32* [ %48, %41 ], [ %20, %8 ]
%25 = call i32 @copiar_tablero(i8* %1, i8* %14)
%26 = load i32, i32* %24
%27 = ashr i32 %26, 9
%28 = ashr i32 %26, 6
%29 = srem i32 %28, 8
%30 = ashr i32 %26, 3
%31 = srem i32 %30, 8
%32 = srem i32 %26, 8
%33 = call i32 @realizar_jugada(i8* %14, i32 %27, i32 %29, i32 %31, i32 %32)
%34 = call i64 @es_mate(i8* %14)
%35 = icmp eq i64 %34, 0
br i1 %35, label %41, label %36
36: ; preds = %22
%37 = load i32, i32* %24
store i32 %37, i32* %3
%38 = and i32 %0, 1
%39 = icmp eq i32 %38, 0
%40 = select i1 %39, i32 10000, i32 -10000
store i32 %40, i32* %4
br label %116
41: ; preds = %22
%42 = call i32 @evaluar_tablero(i8* %14, i8 signext %2)
%43 = sub nsw i32 0, %42
%44 = add nuw i64 %23, 1
%45 = getelementptr inbounds [300 x i32], [300 x i32]* %12, i64 0, i64 %23
store i32 %43, i32* %45
%46 = trunc i64 %44 to i32
%47 = call i32 @encontrar_jugada_posible(i8* %1, i8 signext %2, i32* %10, i32* %11, i32 %46)
%48 = getelementptr inbounds [300 x i32], [300 x i32]* %13, i64 0, i64 %44
store i32 %47, i32* %48
%49 = icmp eq i32 %47, 0
br i1 %49, label %50, label %22
50: ; preds = %41
%51 = trunc i64 %44 to i32
br label %52
52: ; preds = %50, %8
%53 = phi i32 [ 0, %8 ], [ %51, %50 ]
%54 = getelementptr inbounds [300 x i32], [300 x i32]* %12, i64 0, i64 0
%55 = add nsw i32 %53, -1
%56 = sext i32 %55 to i64
%57 = getelementptr inbounds [300 x i32], [300 x i32]* %12, i64 0, i64 %56
%58 = call i32 @quicksort(i32* %54, i32* %57, i32* %54, i32* %20)
%59 = icmp eq i32 %53, 0
br i1 %59, label %113, label %60
60: ; preds = %52
%61 = icmp slt i32 %0, 3
%62 = add nsw i32 %0, -1
%63 = icmp eq i8 %2, 78
%64 = select i1 %63, i8 66, i8 78
%65 = add nsw i32 %5, 1
%66 = and i32 %5, 1
%67 = icmp eq i32 %66, 0
%68 = zext i32 %53 to i64
br label %69
69: ; preds = %60, %106
%70 = phi i64 [ 0, %60 ], [ %111, %106 ]
%71 = phi i32 [ 10000, %60 ], [ %110, %106 ]
%72 = phi i32 [ 0, %60 ], [ %109, %106 ]
%73 = phi i32 [ %7, %60 ], [ %108, %106 ]
%74 = phi i32 [ %6, %60 ], [ %107, %106 ]
%75 = getelementptr inbounds [300 x i32], [300 x i32]* %13, i64 0, i64 %70
%76 = load i32, i32* %75
%77 = call i32 @copiar_tablero(i8* %1, i8* %14)
%78 = ashr i32 %76, 9
%79 = ashr i32 %76, 6
%80 = srem i32 %79, 8
%81 = ashr i32 %76, 3
%82 = srem i32 %81, 8
%83 = srem i32 %76, 8
%84 = call i32 @realizar_jugada(i8* %14, i32 %78, i32 %80, i32 %82, i32 %83)
br i1 %61, label %85, label %87
85: ; preds = %69
%86 = call i32 @alfa_beta(i32 %62, i8* %14, i8 signext %64, i32* %3, i32* %4, i32 %65, i32 %74, i32 %73)
br label %88
87: ; preds = %69
br label %88
88: ; preds = %87, %85
%89 = load i32, i32* %4
br i1 %67, label %90, label %98
90: ; preds = %88
%91 = icmp slt i32 %89, %71
%92 = icmp eq i32 %72, 0
%93 = select i1 %91, i1 true, i1 %92
%94 = select i1 %93, i32 %76, i32 %72
%95 = select i1 %93, i32 %89, i32 %71
%96 = icmp sgt i32 %95, %74
br i1 %96, label %106, label %97
97: ; preds = %90
store i32 %74, i32* %4
store i32 %94, i32* %3
br label %116
98: ; preds = %88
%99 = icmp sgt i32 %89, %71
%100 = icmp eq i32 %72, 0
%101 = select i1 %99, i1 true, i1 %100
%102 = select i1 %101, i32 %76, i32 %72
%103 = select i1 %101, i32 %89, i32 %71
%104 = icmp slt i32 %103, %73
br i1 %104, label %106, label %105
105: ; preds = %98
store i32 %73, i32* %4
store i32 %102, i32* %3
br label %116
106: ; preds = %90, %98
%107 = phi i32 [ %74, %90 ], [ %103, %98 ]
%108 = phi i32 [ %95, %90 ], [ %73, %98 ]
%109 = phi i32 [ %94, %90 ], [ %102, %98 ]
%110 = phi i32 [ %95, %90 ], [ %103, %98 ]
%111 = add nuw nsw i64 %70, 1
%112 = icmp eq i64 %111, %68
br i1 %112, label %113, label %69
113: ; preds = %106, %52
%114 = phi i32 [ 0, %52 ], [ %109, %106 ]
%115 = phi i32 [ 10000, %52 ], [ %110, %106 ]
store i32 %115, i32* %4
store i32 %114, i32* %3
br label %116
116: ; preds = %113, %105, %97, %36
ret void
}