#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*/ gets(char *);
int horspool(char *, char *, int *);
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ shift_table(char *, int);
int strlen(char *);
void bollywood_game(char text[100]) {
  int n, shadow[100], i, chance, win, m, result, temp;
  char pattern[100], name[50] = "BOLLYWOOD";
  n = strlen(text);
  temp = 'a' - 'A';
  for (i = 0; i < n; i++)
    if (text[i] >= 'A' && text[i] <= 'Z')
      text[i] += temp;
  for (i = 0; i < n; i++) {
    if (text[i] == ' ')
      shadow[i] = 1;
    else
      shadow[i] = 0;
  }
  for (chance = 9, win = 0; chance > 0 && win == 0;) {
    printf("Number of chances left : ");
    for (i = 9 - chance; i < 9; i++)
      printf("%c ", name[i]);
    printf("\n\n\tMovie name is : \n\n\t\t");
    for (i = 0; i < n; i++) {
      if (shadow[i] == 1)
        printf("%c", text[i]);
      else
        printf("%c", '_');
      printf(" ");
    }
    printf("\n\nEnetr the letter : ");
    gets(pattern);
    m = strlen(pattern);
    for (i = 0; i < m; i++)
      if (pattern[i] >= 'A' && pattern[i] <= 'Z')
        pattern[i] += temp;
    shift_table(pattern, m);
    result = horspool(text, pattern, shadow);
    if (result == -1) {
      printf("Letter not found!\n");
      chance--;
    } else
      for (i = 0, win = 1; i < n; i++)
        if (shadow[i] == 0)
          win = 0;
  }
  if (win == 1)
    printf("Correct movie! You have won the game! \n\n\tMovie name : %s", text);
  else
    printf("You have run out of chances! Sorry you lose the game...\n\tMovie "
           "name : %s",
           text);
}


x86 assembly (clang, -O0):
<bollywood_game>:
push   %rbp
mov    %rsp,%rbp
sub    $0x270,%rsp
mov    %rdi,-0x8(%rbp)
lea    -0x260(%rbp),%rdi
lea    0xe83(%rip),%rsi
mov    $0x32,%edx
call   1050 <memcpy@plt>
mov    -0x8(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0xc(%rbp)
movl   $0x20,-0x1b8(%rbp)
movl   $0x0,-0x1a4(%rbp)
mov    -0x1a4(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1219 <bollywood_game+0xb9>
mov    -0x8(%rbp),%rax
movslq -0x1a4(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x41,%eax
jl     1200 <bollywood_game+0xa0>
mov    -0x8(%rbp),%rax
movslq -0x1a4(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x5a,%eax
jg     1200 <bollywood_game+0xa0>
mov    -0x1b8(%rbp),%esi
mov    -0x8(%rbp),%rax
movslq -0x1a4(%rbp),%rcx
movsbl (%rax,%rcx,1),%edx
add    %esi,%edx
mov    %dl,(%rax,%rcx,1)
jmp    1205 <bollywood_game+0xa5>
mov    -0x1a4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1a4(%rbp)
jmp    11a7 <bollywood_game+0x47>
movl   $0x0,-0x1a4(%rbp)
mov    -0x1a4(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    128c <bollywood_game+0x12c>
mov    -0x8(%rbp),%rax
movslq -0x1a4(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x20,%eax
jne    1261 <bollywood_game+0x101>
movslq -0x1a4(%rbp),%rax
movl   $0x1,-0x1a0(%rbp,%rax,4)
jmp    1273 <bollywood_game+0x113>
movslq -0x1a4(%rbp),%rax
movl   $0x0,-0x1a0(%rbp,%rax,4)
jmp    1278 <bollywood_game+0x118>
mov    -0x1a4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1a4(%rbp)
jmp    1223 <bollywood_game+0xc3>
movl   $0x9,-0x1a8(%rbp)
movl   $0x0,-0x1ac(%rbp)
xor    %eax,%eax
cmpl   $0x0,-0x1a8(%rbp)
mov    %al,-0x261(%rbp)
jle    12c5 <bollywood_game+0x165>
cmpl   $0x0,-0x1ac(%rbp)
sete   %al
mov    %al,-0x261(%rbp)
mov    -0x261(%rbp),%al
test   $0x1,%al
jne    12d8 <bollywood_game+0x178>
jmp    153a <bollywood_game+0x3da>
lea    0xd53(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    $0x9,%eax
sub    -0x1a8(%rbp),%eax
mov    %eax,-0x1a4(%rbp)
cmpl   $0x9,-0x1a4(%rbp)
jge    1335 <bollywood_game+0x1d5>
movslq -0x1a4(%rbp),%rax
movsbl -0x260(%rbp,%rax,1),%esi
ff
lea    0xd32(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x1a4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1a4(%rbp)
jmp    12f7 <bollywood_game+0x197>
lea    0xd14(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x1a4(%rbp)
mov    -0x1a4(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    13c8 <bollywood_game+0x268>
movslq -0x1a4(%rbp),%rax
cmpl   $0x1,-0x1a0(%rbp,%rax,4)
01
jne    1393 <bollywood_game+0x233>
mov    -0x8(%rbp),%rax
movslq -0x1a4(%rbp),%rcx
movsbl (%rax,%rcx,1),%esi
lea    0xce1(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    13a6 <bollywood_game+0x246>
lea    0xcce(%rip),%rdi
mov    $0x5f,%esi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xcd2(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x1a4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1a4(%rbp)
jmp    134d <bollywood_game+0x1ed>
lea    0xc9c(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    -0x220(%rbp),%rdi
call   1060 <gets@plt>
lea    -0x220(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x1b0(%rbp)
movl   $0x0,-0x1a4(%rbp)
mov    -0x1a4(%rbp),%eax
cmp    -0x1b0(%rbp),%eax
jge    1477 <bollywood_game+0x317>
movslq -0x1a4(%rbp),%rax
movsbl -0x220(%rbp,%rax,1),%eax
ff
cmp    $0x41,%eax
jl     145e <bollywood_game+0x2fe>
movslq -0x1a4(%rbp),%rax
movsbl -0x220(%rbp,%rax,1),%eax
ff
cmp    $0x5a,%eax
jg     145e <bollywood_game+0x2fe>
mov    -0x1b8(%rbp),%edx
movslq -0x1a4(%rbp),%rax
movsbl -0x220(%rbp,%rax,1),%ecx
ff
add    %edx,%ecx
mov    %cl,-0x220(%rbp,%rax,1)
jmp    1463 <bollywood_game+0x303>
mov    -0x1a4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1a4(%rbp)
jmp    13fe <bollywood_game+0x29e>
lea    -0x220(%rbp),%rdi
mov    -0x1b0(%rbp),%esi
call   1080 <shift_table@plt>
mov    -0x8(%rbp),%rdi
lea    -0x220(%rbp),%rsi
lea    -0x1a0(%rbp),%rdx
call   1070 <horspool@plt>
mov    %eax,-0x1b4(%rbp)
cmpl   $0xffffffff,-0x1b4(%rbp)
jne    14d5 <bollywood_game+0x375>
lea    0xbc7(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x1a8(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1a8(%rbp)
jmp    1535 <bollywood_game+0x3d5>
movl   $0x0,-0x1a4(%rbp)
movl   $0x1,-0x1ac(%rbp)
mov    -0x1a4(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1530 <bollywood_game+0x3d0>
movslq -0x1a4(%rbp),%rax
cmpl   $0x0,-0x1a0(%rbp,%rax,4)
jne    1517 <bollywood_game+0x3b7>
movl   $0x0,-0x1ac(%rbp)
jmp    151c <bollywood_game+0x3bc>
mov    -0x1a4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1a4(%rbp)
jmp    14e9 <bollywood_game+0x389>
jmp    1535 <bollywood_game+0x3d5>
jmp    12a0 <bollywood_game+0x140>
cmpl   $0x1,-0x1ac(%rbp)
jne    155e <bollywood_game+0x3fe>
mov    -0x8(%rbp),%rsi
lea    0xb42(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1570 <bollywood_game+0x410>
mov    -0x8(%rbp),%rsi
lea    0xb64(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
add    $0x270,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<bollywood_game>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x238,%rsp
mov    %rdi,%rbx
movabs $0x3ffffffffffffffe,%rax
ff ff 3f
mov    %rax,0x8(%rsp)
call   1050 <strlen@plt>
mov    %eax,%ebp
mov    %eax,%r15d
test   %eax,%eax
jle    1469 <bollywood_game+0x2f9>
cmp    $0x8,%ebp
jae    11b1 <bollywood_game+0x41>
xor    %eax,%eax
jmp    1319 <bollywood_game+0x1a9>
mov    %r15d,%eax
and    $0xfffffff8,%eax
xor    %ecx,%ecx
movdqa 0xe3f(%rip),%xmm0
movdqa 0xe47(%rip),%xmm1
pcmpeqd %xmm2,%xmm2
jmp    11dd <bollywood_game+0x6d>
nop
add    $0x8,%rcx
cmp    %rcx,%rax
je     12f6 <bollywood_game+0x186>
movq   (%rbx,%rcx,1),%xmm3
movdqa %xmm3,%xmm4
paddb  %xmm0,%xmm4
movdqa %xmm4,%xmm5
pmaxub %xmm1,%xmm5
pcmpeqb %xmm4,%xmm5
movd   %xmm5,%edx
not    %dl
test   $0x1,%dl
je     120b <bollywood_game+0x9b>
movd   %xmm3,%edx
add    $0x20,%dl
mov    %dl,(%rbx,%rcx,1)
movdqa %xmm5,%xmm4
pxor   %xmm2,%xmm4
movdqa %xmm4,%xmm6
pslld  $0x8,%xmm6
movd   %xmm6,%edx
shr    $0x10,%edx
test   $0x1,%dl
je     1236 <bollywood_game+0xc6>
movd   %xmm3,%edx
shr    $0x8,%edx
add    $0x20,%dl
mov    %dl,0x1(%rbx,%rcx,1)
pshuflw $0x55,%xmm5,%xmm6
pxor   %xmm2,%xmm6
pextrw $0x2,%xmm6,%edx
test   $0x1,%dl
je     1257 <bollywood_game+0xe7>
movd   %xmm3,%edx
shr    $0x10,%edx
add    $0x20,%dl
mov    %dl,0x2(%rbx,%rcx,1)
movdqa %xmm4,%xmm6
psllq  $0x18,%xmm6
pextrw $0x3,%xmm6,%edx
test   $0x1,%dl
je     1278 <bollywood_game+0x108>
movd   %xmm3,%edx
shr    $0x18,%edx
add    $0x20,%dl
mov    %dl,0x3(%rbx,%rcx,1)
pshufd $0x55,%xmm5,%xmm5
pxor   %xmm2,%xmm5
pextrw $0x4,%xmm5,%edx
test   $0x1,%dl
je     1297 <bollywood_game+0x127>
pextrw $0x2,%xmm3,%edx
add    $0x20,%dl
mov    %dl,0x4(%rbx,%rcx,1)
movdqa %xmm4,%xmm5
pslldq $0x5,%xmm5
pextrw $0x5,%xmm5,%edx
test   $0x1,%dl
je     12b9 <bollywood_game+0x149>
pextrw $0x2,%xmm3,%edx
shr    $0x8,%edx
add    $0x20,%dl
mov    %dl,0x5(%rbx,%rcx,1)
pextrw $0x3,%xmm4,%edx
test   $0x1,%dl
je     12cf <bollywood_game+0x15f>
pextrw $0x3,%xmm3,%edx
add    $0x20,%dl
mov    %dl,0x6(%rbx,%rcx,1)
pslldq $0x7,%xmm4
pextrw $0x7,%xmm4,%edx
test   $0x1,%dl
je     11d0 <bollywood_game+0x60>
pextrw $0x3,%xmm3,%edx
shr    $0x8,%edx
add    $0x20,%dl
mov    %dl,0x7(%rbx,%rcx,1)
jmp    11d0 <bollywood_game+0x60>
cmp    %r15,%rax
jne    1319 <bollywood_game+0x1a9>
test   %ebp,%ebp
jle    1469 <bollywood_game+0x2f9>
cmp    $0x8,%ebp
jae    132d <bollywood_game+0x1bd>
xor    %eax,%eax
jmp    1450 <bollywood_game+0x2e0>
nop
add    $0x1,%rax
cmp    %rax,%r15
je     12fb <bollywood_game+0x18b>
movzbl (%rbx,%rax,1),%ecx
lea    -0x41(%rcx),%edx
cmp    $0x19,%dl
ja     1310 <bollywood_game+0x1a0>
add    $0x20,%cl
mov    %cl,(%rbx,%rax,1)
jmp    1310 <bollywood_game+0x1a0>
mov    %r15d,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rcx
mov    %rcx,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     18f1 <bollywood_game+0x781>
mov    %rdx,%rsi
movabs $0x3ffffffffffffffe,%rcx
ff ff 3f
and    %rcx,%rsi
xor    %ecx,%ecx
movdqa 0xcbb(%rip),%xmm0
movdqa 0xcc3(%rip),%xmm1
nopl   (%rax)
movd   (%rbx,%rcx,1),%xmm2
movd   0x4(%rbx,%rcx,1),%xmm3
pcmpeqb %xmm0,%xmm2
punpcklbw %xmm2,%xmm2
punpcklwd %xmm2,%xmm2
pand   %xmm1,%xmm2
pcmpeqb %xmm0,%xmm3
punpcklbw %xmm3,%xmm3
punpcklwd %xmm3,%xmm3
pand   %xmm1,%xmm3
movdqa %xmm2,0xa0(%rsp,%rcx,4)
movdqa %xmm3,0xb0(%rsp,%rcx,4)
movd   0x8(%rbx,%rcx,1),%xmm2
movd   0xc(%rbx,%rcx,1),%xmm3
pcmpeqb %xmm0,%xmm2
punpcklbw %xmm2,%xmm2
punpcklwd %xmm2,%xmm2
pand   %xmm1,%xmm2
pcmpeqb %xmm0,%xmm3
punpcklbw %xmm3,%xmm3
punpcklwd %xmm3,%xmm3
pand   %xmm1,%xmm3
movdqa %xmm2,0xc0(%rsp,%rcx,4)
movdqa %xmm3,0xd0(%rsp,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rsi
jne    1370 <bollywood_game+0x200>
test   $0x1,%dl
je     144b <bollywood_game+0x2db>
movd   (%rbx,%rcx,1),%xmm0
movd   0x4(%rbx,%rcx,1),%xmm1
movdqa 0xc0f(%rip),%xmm2
pcmpeqb %xmm2,%xmm0
punpcklbw %xmm0,%xmm0
punpcklwd %xmm0,%xmm0
movdqa 0xc0b(%rip),%xmm3
pand   %xmm3,%xmm0
pcmpeqb %xmm2,%xmm1
punpcklbw %xmm1,%xmm1
punpcklwd %xmm1,%xmm1
pand   %xmm3,%xmm1
movdqa %xmm0,0xa0(%rsp,%rcx,4)
movdqa %xmm1,0xb0(%rsp,%rcx,4)
cmp    %r15,%rax
je     1469 <bollywood_game+0x2f9>
xor    %ecx,%ecx
cmpb   $0x20,(%rbx,%rax,1)
sete   %cl
mov    %ecx,0xa0(%rsp,%rax,4)
add    $0x1,%rax
cmp    %rax,%r15
jne    1450 <bollywood_game+0x2e0>
mov    %rbx,0x10(%rsp)
mov    %r15d,%eax
and    $0xfffffff8,%eax
mov    %rax,0x28(%rsp)
add    $0xfffffffffffffff8,%rax
mov    %rax,0x20(%rsp)
shr    $0x3,%rax
add    $0x1,%rax
mov    %rax,%rcx
mov    %rax,0x18(%rsp)
and    %rax,0x8(%rsp)
mov    $0x9,%r12d
lea    0xbe8(%rip),%r14
mov    %ebp,0x4(%rsp)
nopl   0x0(%rax,%rax,1)
mov    %r12d,%r13d
lea    0xbb8(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
mov    $0x9,%eax
sub    %r12d,%eax
movslq %eax,%rbx
lea    0xb6d(%rip),%rax
add    %rax,%rbx
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
movsbl (%rbx,%rbp,1),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
add    $0x1,%rbp
cmp    %ebp,%r13d
jne    14e0 <bollywood_game+0x370>
lea    0xb92(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
mov    0x4(%rsp),%ebp
test   %ebp,%ebp
mov    0x10(%rsp),%r12
jle    1550 <bollywood_game+0x3e0>
xor    %ebx,%ebx
jmp    1538 <bollywood_game+0x3c8>
cs nopw 0x0(%rax,%rax,1)
call   1030 <putchar@plt>
mov    $0x20,%edi
call   1030 <putchar@plt>
add    $0x1,%rbx
cmp    %rbx,%r15
je     1550 <bollywood_game+0x3e0>
mov    $0x5f,%edi
cmpl   $0x1,0xa0(%rsp,%rbx,4)
01
jne    1520 <bollywood_game+0x3b0>
movsbl (%r12,%rbx,1),%edi
jmp    1520 <bollywood_game+0x3b0>
xchg   %ax,%ax
lea    0xb51(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
lea    0x30(%rsp),%rbx
mov    %rbx,%rdi
call   1070 <gets@plt>
mov    %rbx,%rdi
call   1050 <strlen@plt>
test   %eax,%eax
movdqa 0xa83(%rip),%xmm4
movdqa 0xa8b(%rip),%xmm5
pcmpeqd %xmm6,%xmm6
jle    16f0 <bollywood_game+0x580>
mov    %eax,%ecx
cmp    $0x8,%eax
jae    15a0 <bollywood_game+0x430>
xor    %edx,%edx
jmp    1739 <bollywood_game+0x5c9>
nopl   (%rax)
mov    %ecx,%edx
and    $0xfffffff8,%edx
xor    %esi,%esi
jmp    15bd <bollywood_game+0x44d>
nopl   0x0(%rax)
add    $0x8,%rsi
cmp    %rsi,%rdx
je     16e0 <bollywood_game+0x570>
movq   0x30(%rsp,%rsi,1),%xmm0
movdqa %xmm0,%xmm1
paddb  %xmm4,%xmm1
movdqa %xmm1,%xmm2
pmaxub %xmm5,%xmm2
pcmpeqb %xmm1,%xmm2
movd   %xmm2,%ebp
not    %bpl
movd   %xmm0,%edi
test   $0x1,%bpl
je     15f0 <bollywood_game+0x480>
lea    0x20(%rdi),%ebp
mov    %bpl,0x30(%rsp,%rsi,1)
movdqa %xmm2,%xmm1
pxor   %xmm6,%xmm1
movdqa %xmm1,%xmm3
pslld  $0x8,%xmm3
movd   %xmm3,%ebp
shr    $0x10,%ebp
test   $0x1,%bpl
je     161c <bollywood_game+0x4ac>
mov    %edi,%ebp
shr    $0x8,%ebp
add    $0x20,%bpl
mov    %bpl,0x31(%rsp,%rsi,1)
pshuflw $0x55,%xmm2,%xmm3
pxor   %xmm6,%xmm3
pextrw $0x2,%xmm3,%ebp
test   $0x1,%bpl
je     163e <bollywood_game+0x4ce>
mov    %edi,%ebp
shr    $0x10,%ebp
add    $0x20,%bpl
mov    %bpl,0x32(%rsp,%rsi,1)
movdqa %xmm1,%xmm3
psllq  $0x18,%xmm3
pextrw $0x3,%xmm3,%ebp
test   $0x1,%bpl
je     165e <bollywood_game+0x4ee>
shr    $0x18,%edi
add    $0x20,%dil
mov    %dil,0x33(%rsp,%rsi,1)
pshufd $0x55,%xmm2,%xmm2
pxor   %xmm6,%xmm2
pextrw $0x4,%xmm2,%ebp
pextrw $0x2,%xmm0,%edi
test   $0x1,%bpl
je     167f <bollywood_game+0x50f>
lea    0x20(%rdi),%ebp
mov    %bpl,0x34(%rsp,%rsi,1)
movdqa %xmm1,%xmm2
pslldq $0x5,%xmm2
pextrw $0x5,%xmm2,%ebp
test   $0x1,%bpl
je     169f <bollywood_game+0x52f>
shr    $0x8,%edi
add    $0x20,%dil
mov    %dil,0x35(%rsp,%rsi,1)
pextrw $0x3,%xmm1,%ebp
pextrw $0x3,%xmm0,%edi
test   $0x1,%bpl
je     16b7 <bollywood_game+0x547>
lea    0x20(%rdi),%ebp
mov    %bpl,0x36(%rsp,%rsi,1)
pslldq $0x7,%xmm1
pextrw $0x7,%xmm1,%ebp
test   $0x1,%bpl
je     15b0 <bollywood_game+0x440>
shr    $0x8,%edi
add    $0x20,%dil
mov    %dil,0x37(%rsp,%rsi,1)
jmp    15b0 <bollywood_game+0x440>
nopl   0x0(%rax)
cmp    %rcx,%rdx
mov    0x4(%rsp),%ebp
jne    1739 <bollywood_game+0x5c9>
nopl   0x0(%rax)
mov    %rbx,%rdi
mov    %eax,%esi
call   1090 <shift_table@plt>
mov    %r12,%rdi
mov    %rbx,%rsi
lea    0xa0(%rsp),%rdx
call   1080 <horspool@plt>
cmp    $0xffffffff,%eax
je     1760 <bollywood_game+0x5f0>
test   %ebp,%ebp
jle    18ce <bollywood_game+0x75e>
cmp    $0x8,%ebp
jae    1780 <bollywood_game+0x610>
mov    $0x1,%eax
xor    %ecx,%ecx
jmp    1870 <bollywood_game+0x700>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rdx
cmp    %rdx,%rcx
je     16f0 <bollywood_game+0x580>
movzbl 0x30(%rsp,%rdx,1),%esi
lea    -0x41(%rsi),%edi
cmp    $0x19,%dil
ja     1730 <bollywood_game+0x5c0>
add    $0x20,%sil
mov    %sil,0x30(%rsp,%rdx,1)
jmp    1730 <bollywood_game+0x5c0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    0x9d9(%rip),%rdi
call   1040 <puts@plt>
lea    -0x1(%r13),%r12d
xor    %eax,%eax
test   %r12d,%r12d
jg     188d <bollywood_game+0x71d>
jmp    18b2 <bollywood_game+0x742>
cmpq   $0x0,0x20(%rsp)
mov    0x28(%rsp),%rdx
pxor   %xmm5,%xmm5
je     1897 <bollywood_game+0x727>
mov    0x8(%rsp),%rcx
xor    %eax,%eax
movdqa 0x88c(%rip),%xmm2
movdqa %xmm2,%xmm3
nopl   0x0(%rax,%rax,1)
movdqa 0xa0(%rsp,%rax,4),%xmm1
pcmpeqd %xmm5,%xmm1
movdqa 0xb0(%rsp,%rax,4),%xmm4
pcmpeqd %xmm5,%xmm4
movdqa 0xc0(%rsp,%rax,4),%xmm0
pcmpeqd %xmm5,%xmm0
por    %xmm1,%xmm0
pandn  %xmm3,%xmm0
movdqa 0xd0(%rsp,%rax,4),%xmm1
pcmpeqd %xmm5,%xmm1
por    %xmm4,%xmm1
pandn  %xmm2,%xmm1
add    $0x10,%rax
movdqa %xmm0,%xmm3
movdqa %xmm1,%xmm2
add    $0xfffffffffffffffe,%rcx
jne    17b0 <bollywood_game+0x640>
testb  $0x1,0x18(%rsp)
je     1837 <bollywood_game+0x6c7>
movdqa 0xa0(%rsp,%rax,4),%xmm2
pcmpeqd %xmm5,%xmm2
pandn  %xmm0,%xmm2
movdqa 0xb0(%rsp,%rax,4),%xmm3
pcmpeqd %xmm5,%xmm3
pandn  %xmm1,%xmm3
movdqa %xmm2,%xmm0
movdqa %xmm3,%xmm1
movdqa %xmm0,%xmm2
movdqa 0x7ed(%rip),%xmm3
pcmpeqd %xmm3,%xmm2
pand   %xmm2,%xmm1
pandn  %xmm0,%xmm2
por    %xmm1,%xmm2
pcmpeqd %xmm3,%xmm2
movmskps %xmm2,%ecx
xor    %eax,%eax
cmp    $0xf,%ecx
sete   %al
cmp    %r15,%rdx
je     1885 <bollywood_game+0x715>
mov    %rdx,%rcx
nopw   0x0(%rax,%rax,1)
mov    0xa0(%rsp,%rcx,4),%edx
test   %edx,%edx
cmove  %edx,%eax
add    $0x1,%rcx
cmp    %rcx,%r15
jne    1870 <bollywood_game+0x700>
mov    %r13d,%r12d
test   %r12d,%r12d
jle    18b2 <bollywood_game+0x742>
test   %eax,%eax
je     14b0 <bollywood_game+0x340>
jmp    18b2 <bollywood_game+0x742>
xor    %eax,%eax
movdqa 0x78f(%rip),%xmm1
movdqa %xmm1,%xmm0
testb  $0x1,0x18(%rsp)
jne    180d <bollywood_game+0x69d>
jmp    1837 <bollywood_game+0x6c7>
cmp    $0x1,%eax
lea    0x802(%rip),%rax
lea    0x834(%rip),%rdi
cmove  %rax,%rdi
mov    0x10(%rsp),%r12
jmp    18d5 <bollywood_game+0x765>
lea    0x7e9(%rip),%rdi
mov    %r12,%rsi
xor    %eax,%eax
call   1060 <printf@plt>
add    $0x238,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %ecx,%ecx
test   $0x1,%dl
jne    13fe <bollywood_game+0x28e>
jmp    144b <bollywood_game+0x2db>

LLVM IR (-O0):
@__const.bollywood_game.name = [50 x i8] c"BOLLYWOOD\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00"
@.str = [26 x i8] c"Number of chances left : \00"
@.str.1 = [4 x i8] c"%c \00"
@.str.2 = [24 x i8] c"\0A\0A\09Movie name is : \0A\0A\09\09\00"
@.str.3 = [3 x i8] c"%c\00"
@.str.4 = [2 x i8] c" \00"
@.str.5 = [22 x i8] c"\0A\0AEnetr the letter : \00"
@.str.6 = [19 x i8] c"Letter not found!\0A\00"
@.str.7 = [57 x i8] c"Correct movie! You have won the game! \0A\0A\09Movie name : %s\00"
@.str.8 = [73 x i8] c"You have run out of chances! Sorry you lose the game...\0A\09Movie name : %s\00"
define void @bollywood_game(i8* %0) {
%2 = alloca i8*
%3 = alloca i32
%4 = alloca [100 x i32]
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca [100 x i8]
%12 = alloca [50 x i8]
store i8* %0, i8** %2
%13 = bitcast [50 x i8]* %12 to i8*
%14 = load i8*, i8** %2
%15 = call i32 @strlen(i8* %14)
store i32 %15, i32* %3
store i32 32, i32* %10
store i32 0, i32* %5
br label %16
16: ; preds = %47, %1
%17 = load i32, i32* %5
%18 = load i32, i32* %3
%19 = icmp slt i32 %17, %18
br i1 %19, label %20, label %50
20: ; preds = %16
%21 = load i8*, i8** %2
%22 = load i32, i32* %5
%23 = sext i32 %22 to i64
%24 = getelementptr inbounds i8, i8* %21, i64 %23
%25 = load i8, i8* %24
%26 = sext i8 %25 to i32
%27 = icmp sge i32 %26, 65
br i1 %27, label %28, label %46
28: ; preds = %20
%29 = load i8*, i8** %2
%30 = load i32, i32* %5
%31 = sext i32 %30 to i64
%32 = getelementptr inbounds i8, i8* %29, i64 %31
%33 = load i8, i8* %32
%34 = sext i8 %33 to i32
%35 = icmp sle i32 %34, 90
br i1 %35, label %36, label %46
36: ; preds = %28
%37 = load i32, i32* %10
%38 = load i8*, i8** %2
%39 = load i32, i32* %5
%40 = sext i32 %39 to i64
%41 = getelementptr inbounds i8, i8* %38, i64 %40
%42 = load i8, i8* %41
%43 = sext i8 %42 to i32
%44 = add nsw i32 %43, %37
%45 = trunc i32 %44 to i8
store i8 %45, i8* %41
br label %46
46: ; preds = %36, %28, %20
br label %47
47: ; preds = %46
%48 = load i32, i32* %5
%49 = add nsw i32 %48, 1
store i32 %49, i32* %5
br label %16
50: ; preds = %16
store i32 0, i32* %5
br label %51
51: ; preds = %72, %50
%52 = load i32, i32* %5
%53 = load i32, i32* %3
%54 = icmp slt i32 %52, %53
br i1 %54, label %55, label %75
55: ; preds = %51
%56 = load i8*, i8** %2
%57 = load i32, i32* %5
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds i8, i8* %56, i64 %58
%60 = load i8, i8* %59
%61 = sext i8 %60 to i32
%62 = icmp eq i32 %61, 32
br i1 %62, label %63, label %67
63: ; preds = %55
%64 = load i32, i32* %5
%65 = sext i32 %64 to i64
%66 = getelementptr inbounds [100 x i32], [100 x i32]* %4, i64 0, i64 %65
store i32 1, i32* %66
br label %71
67: ; preds = %55
%68 = load i32, i32* %5
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds [100 x i32], [100 x i32]* %4, i64 0, i64 %69
store i32 0, i32* %70
br label %71
71: ; preds = %67, %63
br label %72
72: ; preds = %71
%73 = load i32, i32* %5
%74 = add nsw i32 %73, 1
store i32 %74, i32* %5
br label %51
75: ; preds = %51
store i32 9, i32* %6
store i32 0, i32* %7
br label %76
76: ; preds = %196, %75
%77 = load i32, i32* %6
%78 = icmp sgt i32 %77, 0
br i1 %78, label %79, label %82
79: ; preds = %76
%80 = load i32, i32* %7
%81 = icmp eq i32 %80, 0
br label %82
82: ; preds = %79, %76
%83 = phi i1 [ false, %76 ], [ %81, %79 ]
br i1 %83, label %84, label %197
84: ; preds = %82
%85 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str, i64 0, i64 0))
%86 = load i32, i32* %6
%87 = sub nsw i32 9, %86
store i32 %87, i32* %5
br label %88
88: ; preds = %98, %84
%89 = load i32, i32* %5
%90 = icmp slt i32 %89, 9
br i1 %90, label %91, label %101
91: ; preds = %88
%92 = load i32, i32* %5
%93 = sext i32 %92 to i64
%94 = getelementptr inbounds [50 x i8], [50 x i8]* %12, i64 0, i64 %93
%95 = load i8, i8* %94
%96 = sext i8 %95 to i32
%97 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %96)
br label %98
98: ; preds = %91
%99 = load i32, i32* %5
%100 = add nsw i32 %99, 1
store i32 %100, i32* %5
br label %88
101: ; preds = %88
%102 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.2, i64 0, i64 0))
store i32 0, i32* %5
br label %103
103: ; preds = %125, %101
%104 = load i32, i32* %5
%105 = load i32, i32* %3
%106 = icmp slt i32 %104, %105
br i1 %106, label %107, label %128
107: ; preds = %103
%108 = load i32, i32* %5
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds [100 x i32], [100 x i32]* %4, i64 0, i64 %109
%111 = load i32, i32* %110
%112 = icmp eq i32 %111, 1
br i1 %112, label %113, label %121
113: ; preds = %107
%114 = load i8*, i8** %2
%115 = load i32, i32* %5
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds i8, i8* %114, i64 %116
%118 = load i8, i8* %117
%119 = sext i8 %118 to i32
%120 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), i32 %119)
br label %123
121: ; preds = %107
%122 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), i32 95)
br label %123
123: ; preds = %121, %113
%124 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
br label %125
125: ; preds = %123
%126 = load i32, i32* %5
%127 = add nsw i32 %126, 1
store i32 %127, i32* %5
br label %103
128: ; preds = %103
%129 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.5, i64 0, i64 0))
%130 = getelementptr inbounds [100 x i8], [100 x i8]* %11, i64 0, i64 0
%131 = call i32 @gets(i8* %130)
%132 = getelementptr inbounds [100 x i8], [100 x i8]* %11, i64 0, i64 0
%133 = call i32 @strlen(i8* %132)
store i32 %133, i32* %8
store i32 0, i32* %5
br label %134
134: ; preds = %162, %128
%135 = load i32, i32* %5
%136 = load i32, i32* %8
%137 = icmp slt i32 %135, %136
br i1 %137, label %138, label %165
138: ; preds = %134
%139 = load i32, i32* %5
%140 = sext i32 %139 to i64
%141 = getelementptr inbounds [100 x i8], [100 x i8]* %11, i64 0, i64 %140
%142 = load i8, i8* %141
%143 = sext i8 %142 to i32
%144 = icmp sge i32 %143, 65
br i1 %144, label %145, label %161
145: ; preds = %138
%146 = load i32, i32* %5
%147 = sext i32 %146 to i64
%148 = getelementptr inbounds [100 x i8], [100 x i8]* %11, i64 0, i64 %147
%149 = load i8, i8* %148
%150 = sext i8 %149 to i32
%151 = icmp sle i32 %150, 90
br i1 %151, label %152, label %161
152: ; preds = %145
%153 = load i32, i32* %10
%154 = load i32, i32* %5
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds [100 x i8], [100 x i8]* %11, i64 0, i64 %155
%157 = load i8, i8* %156
%158 = sext i8 %157 to i32
%159 = add nsw i32 %158, %153
%160 = trunc i32 %159 to i8
store i8 %160, i8* %156
br label %161
161: ; preds = %152, %145, %138
br label %162
162: ; preds = %161
%163 = load i32, i32* %5
%164 = add nsw i32 %163, 1
store i32 %164, i32* %5
br label %134
165: ; preds = %134
%166 = getelementptr inbounds [100 x i8], [100 x i8]* %11, i64 0, i64 0
%167 = load i32, i32* %8
%168 = call i32 @shift_table(i8* %166, i32 %167)
%169 = load i8*, i8** %2
%170 = getelementptr inbounds [100 x i8], [100 x i8]* %11, i64 0, i64 0
%171 = getelementptr inbounds [100 x i32], [100 x i32]* %4, i64 0, i64 0
%172 = call i32 @horspool(i8* %169, i8* %170, i32* %171)
store i32 %172, i32* %9
%173 = load i32, i32* %9
%174 = icmp eq i32 %173, -1
br i1 %174, label %175, label %179
175: ; preds = %165
%176 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.6, i64 0, i64 0))
%177 = load i32, i32* %6
%178 = add nsw i32 %177, -1
store i32 %178, i32* %6
br label %196
179: ; preds = %165
store i32 0, i32* %5
store i32 1, i32* %7
br label %180
180: ; preds = %192, %179
%181 = load i32, i32* %5
%182 = load i32, i32* %3
%183 = icmp slt i32 %181, %182
br i1 %183, label %184, label %195
184: ; preds = %180
%185 = load i32, i32* %5
%186 = sext i32 %185 to i64
%187 = getelementptr inbounds [100 x i32], [100 x i32]* %4, i64 0, i64 %186
%188 = load i32, i32* %187
%189 = icmp eq i32 %188, 0
br i1 %189, label %190, label %191
190: ; preds = %184
store i32 0, i32* %7
br label %191
191: ; preds = %190, %184
br label %192
192: ; preds = %191
%193 = load i32, i32* %5
%194 = add nsw i32 %193, 1
store i32 %194, i32* %5
br label %180
195: ; preds = %180
br label %196
196: ; preds = %195, %175
br label %76
197: ; preds = %82
%198 = load i32, i32* %7
%199 = icmp eq i32 %198, 1
br i1 %199, label %200, label %203
200: ; preds = %197
%201 = load i8*, i8** %2
%202 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([57 x i8], [57 x i8]* @.str.7, i64 0, i64 0), i8* %201)
br label %206
203: ; preds = %197
%204 = load i8*, i8** %2
%205 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([73 x i8], [73 x i8]* @.str.8, i64 0, i64 0), i8* %204)
br label %206
206: ; preds = %203, %200
ret void
}

LLVM IR (-O2):
@__const.bollywood_game.name = [50 x i8] c"BOLLYWOOD\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00"
@.str = [26 x i8] c"Number of chances left : \00"
@.str.1 = [4 x i8] c"%c \00"
@.str.2 = [24 x i8] c"\0A\0A\09Movie name is : \0A\0A\09\09\00"
@.str.5 = [22 x i8] c"\0A\0AEnetr the letter : \00"
@.str.7 = [57 x i8] c"Correct movie! You have won the game! \0A\0A\09Movie name : %s\00"
@.str.8 = [73 x i8] c"You have run out of chances! Sorry you lose the game...\0A\09Movie name : %s\00"
@str = [18 x i8] c"Letter not found!\00"
define void @bollywood_game(i8* %0) {
%2 = alloca [100 x i32]
%3 = alloca [100 x i8]
%4 = bitcast [100 x i32]* %2 to i8*
%5 = getelementptr inbounds [100 x i8], [100 x i8]* %3, i64 0, i64 0
%6 = tail call i32 @strlen(i8* %0)
%7 = icmp sgt i32 %6, 0
br i1 %7, label %8, label %162
8: ; preds = %1
%9 = zext i32 %6 to i64
%10 = icmp ult i32 %6, 8
br i1 %10, label %79, label %11
11: ; preds = %8
%12 = and i64 %9, 4294967288
br label %13
13: ; preds = %74, %11
%14 = phi i64 [ 0, %11 ], [ %75, %74 ]
%15 = getelementptr inbounds i8, i8* %0, i64 %14
%16 = bitcast i8* %15 to <8 x i8>*
%17 = load <8 x i8>, <8 x i8>* %16
%18 = add <8 x i8> %17, <i8 -65, i8 -65, i8 -65, i8 -65, i8 -65, i8 -65, i8 -65, i8 -65>
%19 = icmp ult <8 x i8> %18, <i8 26, i8 26, i8 26, i8 26, i8 26, i8 26, i8 26, i8 26>
%20 = extractelement <8 x i1> %19, i64 0
br i1 %20, label %21, label %25
21: ; preds = %13
%22 = extractelement <8 x i8> %17, i64 0
%23 = add nuw nsw i8 %22, 32
%24 = getelementptr inbounds i8, i8* %0, i64 %14
store i8 %23, i8* %24
br label %25
25: ; preds = %21, %13
%26 = extractelement <8 x i1> %19, i64 1
br i1 %26, label %27, label %32
27: ; preds = %25
%28 = or i64 %14, 1
%29 = extractelement <8 x i8> %17, i64 1
%30 = add nuw nsw i8 %29, 32
%31 = getelementptr inbounds i8, i8* %0, i64 %28
store i8 %30, i8* %31
br label %32
32: ; preds = %27, %25
%33 = extractelement <8 x i1> %19, i64 2
br i1 %33, label %34, label %39
34: ; preds = %32
%35 = or i64 %14, 2
%36 = extractelement <8 x i8> %17, i64 2
%37 = add nuw nsw i8 %36, 32
%38 = getelementptr inbounds i8, i8* %0, i64 %35
store i8 %37, i8* %38
br label %39
39: ; preds = %34, %32
%40 = extractelement <8 x i1> %19, i64 3
br i1 %40, label %41, label %46
41: ; preds = %39
%42 = or i64 %14, 3
%43 = extractelement <8 x i8> %17, i64 3
%44 = add nuw nsw i8 %43, 32
%45 = getelementptr inbounds i8, i8* %0, i64 %42
store i8 %44, i8* %45
br label %46
46: ; preds = %41, %39
%47 = extractelement <8 x i1> %19, i64 4
br i1 %47, label %48, label %53
48: ; preds = %46
%49 = or i64 %14, 4
%50 = extractelement <8 x i8> %17, i64 4
%51 = add nuw nsw i8 %50, 32
%52 = getelementptr inbounds i8, i8* %0, i64 %49
store i8 %51, i8* %52
br label %53
53: ; preds = %48, %46
%54 = extractelement <8 x i1> %19, i64 5
br i1 %54, label %55, label %60
55: ; preds = %53
%56 = or i64 %14, 5
%57 = extractelement <8 x i8> %17, i64 5
%58 = add nuw nsw i8 %57, 32
%59 = getelementptr inbounds i8, i8* %0, i64 %56
store i8 %58, i8* %59
br label %60
60: ; preds = %55, %53
%61 = extractelement <8 x i1> %19, i64 6
br i1 %61, label %62, label %67
62: ; preds = %60
%63 = or i64 %14, 6
%64 = extractelement <8 x i8> %17, i64 6
%65 = add nuw nsw i8 %64, 32
%66 = getelementptr inbounds i8, i8* %0, i64 %63
store i8 %65, i8* %66
br label %67
67: ; preds = %62, %60
%68 = extractelement <8 x i1> %19, i64 7
br i1 %68, label %69, label %74
69: ; preds = %67
%70 = or i64 %14, 7
%71 = extractelement <8 x i8> %17, i64 7
%72 = add nuw nsw i8 %71, 32
%73 = getelementptr inbounds i8, i8* %0, i64 %70
store i8 %72, i8* %73
br label %74
74: ; preds = %69, %67
%75 = add nuw i64 %14, 8
%76 = icmp eq i64 %75, %12
br i1 %76, label %77, label %13
77: ; preds = %74
%78 = icmp eq i64 %12, %9
br i1 %78, label %81, label %79
79: ; preds = %8, %77
%80 = phi i64 [ 0, %8 ], [ %12, %77 ]
br label %151
81: ; preds = %159, %77
br i1 %7, label %82, label %162
82: ; preds = %81
%83 = zext i32 %6 to i64
%84 = icmp ult i32 %6, 8
br i1 %84, label %149, label %85
85: ; preds = %82
%86 = and i64 %9, 4294967288
%87 = add nsw i64 %86, -8
%88 = lshr exact i64 %87, 3
%89 = add nuw nsw i64 %88, 1
%90 = and i64 %89, 1
%91 = icmp eq i64 %87, 0
br i1 %91, label %129, label %92
92: ; preds = %85
%93 = and i64 %89, 4611686018427387902
br label %94
94: ; preds = %94, %92
%95 = phi i64 [ 0, %92 ], [ %126, %94 ]
%96 = phi i64 [ 0, %92 ], [ %127, %94 ]
%97 = getelementptr inbounds i8, i8* %0, i64 %95
%98 = bitcast i8* %97 to <4 x i8>*
%99 = load <4 x i8>, <4 x i8>* %98
%100 = getelementptr inbounds i8, i8* %97, i64 4
%101 = bitcast i8* %100 to <4 x i8>*
%102 = load <4 x i8>, <4 x i8>* %101
%103 = icmp eq <4 x i8> %99, <i8 32, i8 32, i8 32, i8 32>
%104 = icmp eq <4 x i8> %102, <i8 32, i8 32, i8 32, i8 32>
%105 = zext <4 x i1> %103 to <4 x i32>
%106 = zext <4 x i1> %104 to <4 x i32>
%107 = getelementptr inbounds [100 x i32], [100 x i32]* %2, i64 0, i64 %95
%108 = bitcast i32* %107 to <4 x i32>*
store <4 x i32> %105, <4 x i32>* %108
%109 = getelementptr inbounds i32, i32* %107, i64 4
%110 = bitcast i32* %109 to <4 x i32>*
store <4 x i32> %106, <4 x i32>* %110
%111 = or i64 %95, 8
%112 = getelementptr inbounds i8, i8* %0, i64 %111
%113 = bitcast i8* %112 to <4 x i8>*
%114 = load <4 x i8>, <4 x i8>* %113
%115 = getelementptr inbounds i8, i8* %112, i64 4
%116 = bitcast i8* %115 to <4 x i8>*
%117 = load <4 x i8>, <4 x i8>* %116
%118 = icmp eq <4 x i8> %114, <i8 32, i8 32, i8 32, i8 32>
%119 = icmp eq <4 x i8> %117, <i8 32, i8 32, i8 32, i8 32>
%120 = zext <4 x i1> %118 to <4 x i32>
%121 = zext <4 x i1> %119 to <4 x i32>
%122 = getelementptr inbounds [100 x i32], [100 x i32]* %2, i64 0, i64 %111
%123 = bitcast i32* %122 to <4 x i32>*
store <4 x i32> %120, <4 x i32>* %123
%124 = getelementptr inbounds i32, i32* %122, i64 4
%125 = bitcast i32* %124 to <4 x i32>*
store <4 x i32> %121, <4 x i32>* %125
%126 = add nuw i64 %95, 16
%127 = add i64 %96, 2
%128 = icmp eq i64 %127, %93
br i1 %128, label %129, label %94
129: ; preds = %94, %85
%130 = phi i64 [ 0, %85 ], [ %126, %94 ]
%131 = icmp eq i64 %90, 0
br i1 %131, label %147, label %132
132: ; preds = %129
%133 = getelementptr inbounds i8, i8* %0, i64 %130
%134 = bitcast i8* %133 to <4 x i8>*
%135 = load <4 x i8>, <4 x i8>* %134
%136 = getelementptr inbounds i8, i8* %133, i64 4
%137 = bitcast i8* %136 to <4 x i8>*
%138 = load <4 x i8>, <4 x i8>* %137
%139 = icmp eq <4 x i8> %135, <i8 32, i8 32, i8 32, i8 32>
%140 = icmp eq <4 x i8> %138, <i8 32, i8 32, i8 32, i8 32>
%141 = zext <4 x i1> %139 to <4 x i32>
%142 = zext <4 x i1> %140 to <4 x i32>
%143 = getelementptr inbounds [100 x i32], [100 x i32]* %2, i64 0, i64 %130
%144 = bitcast i32* %143 to <4 x i32>*
store <4 x i32> %141, <4 x i32>* %144
%145 = getelementptr inbounds i32, i32* %143, i64 4
%146 = bitcast i32* %145 to <4 x i32>*
store <4 x i32> %142, <4 x i32>* %146
br label %147
147: ; preds = %129, %132
%148 = icmp eq i64 %86, %9
br i1 %148, label %162, label %149
149: ; preds = %82, %147
%150 = phi i64 [ 0, %82 ], [ %86, %147 ]
br label %177
151: ; preds = %79, %159
%152 = phi i64 [ %160, %159 ], [ %80, %79 ]
%153 = getelementptr inbounds i8, i8* %0, i64 %152
%154 = load i8, i8* %153
%155 = add i8 %154, -65
%156 = icmp ult i8 %155, 26
br i1 %156, label %157, label %159
157: ; preds = %151
%158 = add nuw nsw i8 %154, 32
store i8 %158, i8* %153
br label %159
159: ; preds = %151, %157
%160 = add nuw nsw i64 %152, 1
%161 = icmp eq i64 %160, %9
br i1 %161, label %81, label %151
162: ; preds = %177, %147, %1, %81
%163 = getelementptr inbounds [100 x i32], [100 x i32]* %2, i64 0, i64 0
%164 = zext i32 %6 to i64
%165 = zext i32 %6 to i64
%166 = and i64 %164, 4294967288
%167 = add nsw i64 %166, -8
%168 = lshr exact i64 %167, 3
%169 = add nuw nsw i64 %168, 1
%170 = icmp ult i32 %6, 8
%171 = and i64 %164, 4294967288
%172 = and i64 %169, 1
%173 = icmp eq i64 %167, 0
%174 = and i64 %169, 4611686018427387902
%175 = icmp eq i64 %172, 0
%176 = icmp eq i64 %171, %164
br label %186
177: ; preds = %149, %177
%178 = phi i64 [ %184, %177 ], [ %150, %149 ]
%179 = getelementptr inbounds i8, i8* %0, i64 %178
%180 = load i8, i8* %179
%181 = icmp eq i8 %180, 32
%182 = zext i1 %181 to i32
%183 = getelementptr inbounds [100 x i32], [100 x i32]* %2, i64 0, i64 %178
store i32 %182, i32* %183
%184 = add nuw nsw i64 %178, 1
%185 = icmp eq i64 %184, %83
br i1 %185, label %162, label %177
186: ; preds = %383, %162
%187 = phi i32 [ 9, %162 ], [ %385, %383 ]
%188 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([26 x i8], [26 x i8]* @.str, i64 0, i64 0))
%189 = sub nsw i32 9, %187
%190 = sext i32 %189 to i64
br label %191
191: ; preds = %186, %191
%192 = phi i64 [ %190, %186 ], [ %197, %191 ]
%193 = getelementptr inbounds [50 x i8], [50 x i8]* @__const.bollywood_game.name, i64 0, i64 %192
%194 = load i8, i8* %193
%195 = sext i8 %194 to i32
%196 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %195)
%197 = add nsw i64 %192, 1
%198 = trunc i64 %197 to i32
%199 = icmp eq i32 %198, 9
br i1 %199, label %200, label %191
200: ; preds = %191
%201 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([24 x i8], [24 x i8]* @.str.2, i64 0, i64 0))
br i1 %7, label %202, label %217
202: ; preds = %200, %211
%203 = phi i64 [ %215, %211 ], [ 0, %200 ]
%204 = getelementptr inbounds [100 x i32], [100 x i32]* %2, i64 0, i64 %203
%205 = load i32, i32* %204
%206 = icmp eq i32 %205, 1
br i1 %206, label %207, label %211
207: ; preds = %202
%208 = getelementptr inbounds i8, i8* %0, i64 %203
%209 = load i8, i8* %208
%210 = sext i8 %209 to i32
br label %211
211: ; preds = %202, %207
%212 = phi i32 [ %210, %207 ], [ 95, %202 ]
%213 = call i32 @putchar(i32 %212)
%214 = call i32 @putchar(i32 32)
%215 = add nuw nsw i64 %203, 1
%216 = icmp eq i64 %215, %164
br i1 %216, label %217, label %202
217: ; preds = %211, %200
%218 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([22 x i8], [22 x i8]* @.str.5, i64 0, i64 0))
%219 = call i32 @gets(i8* %5)
%220 = call i32 @strlen(i8* %5)
%221 = icmp sgt i32 %220, 0
br i1 %221, label %222, label %306
222: ; preds = %217
%223 = zext i32 %220 to i64
%224 = icmp ult i32 %220, 8
br i1 %224, label %293, label %225
225: ; preds = %222
%226 = and i64 %223, 4294967288
br label %227
227: ; preds = %288, %225
%228 = phi i64 [ 0, %225 ], [ %289, %288 ]
%229 = getelementptr inbounds [100 x i8], [100 x i8]* %3, i64 0, i64 %228
%230 = bitcast i8* %229 to <8 x i8>*
%231 = load <8 x i8>, <8 x i8>* %230
%232 = add <8 x i8> %231, <i8 -65, i8 -65, i8 -65, i8 -65, i8 -65, i8 -65, i8 -65, i8 -65>
%233 = icmp ult <8 x i8> %232, <i8 26, i8 26, i8 26, i8 26, i8 26, i8 26, i8 26, i8 26>
%234 = extractelement <8 x i1> %233, i64 0
br i1 %234, label %235, label %239
235: ; preds = %227
%236 = extractelement <8 x i8> %231, i64 0
%237 = add nuw nsw i8 %236, 32
%238 = getelementptr inbounds [100 x i8], [100 x i8]* %3, i64 0, i64 %228
store i8 %237, i8* %238
br label %239
239: ; preds = %235, %227
%240 = extractelement <8 x i1> %233, i64 1
br i1 %240, label %241, label %246
241: ; preds = %239
%242 = or i64 %228, 1
%243 = extractelement <8 x i8> %231, i64 1
%244 = add nuw nsw i8 %243, 32
%245 = getelementptr inbounds [100 x i8], [100 x i8]* %3, i64 0, i64 %242
store i8 %244, i8* %245
br label %246
246: ; preds = %241, %239
%247 = extractelement <8 x i1> %233, i64 2
br i1 %247, label %248, label %253
248: ; preds = %246
%249 = or i64 %228, 2
%250 = extractelement <8 x i8> %231, i64 2
%251 = add nuw nsw i8 %250, 32
%252 = getelementptr inbounds [100 x i8], [100 x i8]* %3, i64 0, i64 %249
store i8 %251, i8* %252
br label %253
253: ; preds = %248, %246
%254 = extractelement <8 x i1> %233, i64 3
br i1 %254, label %255, label %260
255: ; preds = %253
%256 = or i64 %228, 3
%257 = extractelement <8 x i8> %231, i64 3
%258 = add nuw nsw i8 %257, 32
%259 = getelementptr inbounds [100 x i8], [100 x i8]* %3, i64 0, i64 %256
store i8 %258, i8* %259
br label %260
260: ; preds = %255, %253
%261 = extractelement <8 x i1> %233, i64 4
br i1 %261, label %262, label %267
262: ; preds = %260
%263 = or i64 %228, 4
%264 = extractelement <8 x i8> %231, i64 4
%265 = add nuw nsw i8 %264, 32
%266 = getelementptr inbounds [100 x i8], [100 x i8]* %3, i64 0, i64 %263
store i8 %265, i8* %266
br label %267
267: ; preds = %262, %260
%268 = extractelement <8 x i1> %233, i64 5
br i1 %268, label %269, label %274
269: ; preds = %267
%270 = or i64 %228, 5
%271 = extractelement <8 x i8> %231, i64 5
%272 = add nuw nsw i8 %271, 32
%273 = getelementptr inbounds [100 x i8], [100 x i8]* %3, i64 0, i64 %270
store i8 %272, i8* %273
br label %274
274: ; preds = %269, %267
%275 = extractelement <8 x i1> %233, i64 6
br i1 %275, label %276, label %281
276: ; preds = %274
%277 = or i64 %228, 6
%278 = extractelement <8 x i8> %231, i64 6
%279 = add nuw nsw i8 %278, 32
%280 = getelementptr inbounds [100 x i8], [100 x i8]* %3, i64 0, i64 %277
store i8 %279, i8* %280
br label %281
281: ; preds = %276, %274
%282 = extractelement <8 x i1> %233, i64 7
br i1 %282, label %283, label %288
283: ; preds = %281
%284 = or i64 %228, 7
%285 = extractelement <8 x i8> %231, i64 7
%286 = add nuw nsw i8 %285, 32
%287 = getelementptr inbounds [100 x i8], [100 x i8]* %3, i64 0, i64 %284
store i8 %286, i8* %287
br label %288
288: ; preds = %283, %281
%289 = add nuw i64 %228, 8
%290 = icmp eq i64 %289, %226
br i1 %290, label %291, label %227
291: ; preds = %288
%292 = icmp eq i64 %226, %223
br i1 %292, label %306, label %293
293: ; preds = %222, %291
%294 = phi i64 [ 0, %222 ], [ %226, %291 ]
br label %295
295: ; preds = %293, %303
%296 = phi i64 [ %304, %303 ], [ %294, %293 ]
%297 = getelementptr inbounds [100 x i8], [100 x i8]* %3, i64 0, i64 %296
%298 = load i8, i8* %297
%299 = add i8 %298, -65
%300 = icmp ult i8 %299, 26
br i1 %300, label %301, label %303
301: ; preds = %295
%302 = add nuw nsw i8 %298, 32
store i8 %302, i8* %297
br label %303
303: ; preds = %295, %301
%304 = add nuw nsw i64 %296, 1
%305 = icmp eq i64 %304, %223
br i1 %305, label %306, label %295
306: ; preds = %303, %291, %217
%307 = call i32 @shift_table(i8* %5, i32 %220)
%308 = call i32 @horspool(i8* %0, i8* %5, i32* %163)
%309 = icmp eq i32 %308, -1
br i1 %309, label %371, label %310
310: ; preds = %306
br i1 %7, label %311, label %392
311: ; preds = %310
br i1 %170, label %368, label %312
312: ; preds = %311
br i1 %173, label %342, label %313
313: ; preds = %312, %313
%314 = phi i64 [ %339, %313 ], [ 0, %312 ]
%315 = phi <4 x i32> [ %336, %313 ], [ <i32 1, i32 1, i32 1, i32 1>, %312 ]
%316 = phi <4 x i32> [ %338, %313 ], [ <i32 1, i32 1, i32 1, i32 1>, %312 ]
%317 = phi i64 [ %340, %313 ], [ 0, %312 ]
%318 = getelementptr inbounds [100 x i32], [100 x i32]* %2, i64 0, i64 %314
%319 = bitcast i32* %318 to <4 x i32>*
%320 = load <4 x i32>, <4 x i32>* %319
%321 = getelementptr inbounds i32, i32* %318, i64 4
%322 = bitcast i32* %321 to <4 x i32>*
%323 = load <4 x i32>, <4 x i32>* %322
%324 = icmp eq <4 x i32> %320, zeroinitializer
%325 = icmp eq <4 x i32> %323, zeroinitializer
%326 = or i64 %314, 8
%327 = getelementptr inbounds [100 x i32], [100 x i32]* %2, i64 0, i64 %326
%328 = bitcast i32* %327 to <4 x i32>*
%329 = load <4 x i32>, <4 x i32>* %328
%330 = getelementptr inbounds i32, i32* %327, i64 4
%331 = bitcast i32* %330 to <4 x i32>*
%332 = load <4 x i32>, <4 x i32>* %331
%333 = icmp eq <4 x i32> %329, zeroinitializer
%334 = icmp eq <4 x i32> %332, zeroinitializer
%335 = select <4 x i1> %333, <4 x i1> <i1 true, i1 true, i1 true, i1 true>, <4 x i1> %324
%336 = select <4 x i1> %335, <4 x i32> zeroinitializer, <4 x i32> %315
%337 = select <4 x i1> %334, <4 x i1> <i1 true, i1 true, i1 true, i1 true>, <4 x i1> %325
%338 = select <4 x i1> %337, <4 x i32> zeroinitializer, <4 x i32> %316
%339 = add nuw i64 %314, 16
%340 = add i64 %317, 2
%341 = icmp eq i64 %340, %174
br i1 %341, label %342, label %313
342: ; preds = %313, %312
%343 = phi <4 x i32> [ undef, %312 ], [ %336, %313 ]
%344 = phi <4 x i32> [ undef, %312 ], [ %338, %313 ]
%345 = phi i64 [ 0, %312 ], [ %339, %313 ]
%346 = phi <4 x i32> [ <i32 1, i32 1, i32 1, i32 1>, %312 ], [ %336, %313 ]
%347 = phi <4 x i32> [ <i32 1, i32 1, i32 1, i32 1>, %312 ], [ %338, %313 ]
br i1 %175, label %359, label %348
348: ; preds = %342
%349 = getelementptr inbounds [100 x i32], [100 x i32]* %2, i64 0, i64 %345
%350 = bitcast i32* %349 to <4 x i32>*
%351 = load <4 x i32>, <4 x i32>* %350
%352 = getelementptr inbounds i32, i32* %349, i64 4
%353 = bitcast i32* %352 to <4 x i32>*
%354 = load <4 x i32>, <4 x i32>* %353
%355 = icmp eq <4 x i32> %351, zeroinitializer
%356 = icmp eq <4 x i32> %354, zeroinitializer
%357 = select <4 x i1> %355, <4 x i32> zeroinitializer, <4 x i32> %346
%358 = select <4 x i1> %356, <4 x i32> zeroinitializer, <4 x i32> %347
br label %359
359: ; preds = %342, %348
%360 = phi <4 x i32> [ %343, %342 ], [ %357, %348 ]
%361 = phi <4 x i32> [ %344, %342 ], [ %358, %348 ]
%362 = icmp eq <4 x i32> %360, <i32 1, i32 1, i32 1, i32 1>
%363 = select <4 x i1> %362, <4 x i32> %361, <4 x i32> %360
%364 = icmp ne <4 x i32> %363, <i32 1, i32 1, i32 1, i32 1>
%365 = bitcast <4 x i1> %364 to i4
%366 = icmp eq i4 %365, 0
%367 = zext i1 %366 to i32
br i1 %176, label %383, label %368
368: ; preds = %311, %359
%369 = phi i64 [ 0, %311 ], [ %171, %359 ]
%370 = phi i32 [ 1, %311 ], [ %367, %359 ]
br label %374
371: ; preds = %306
%372 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @str, i64 0, i64 0))
%373 = add nsw i32 %187, -1
br label %383
374: ; preds = %368, %374
%375 = phi i64 [ %381, %374 ], [ %369, %368 ]
%376 = phi i32 [ %380, %374 ], [ %370, %368 ]
%377 = getelementptr inbounds [100 x i32], [100 x i32]* %2, i64 0, i64 %375
%378 = load i32, i32* %377
%379 = icmp eq i32 %378, 0
%380 = select i1 %379, i32 0, i32 %376
%381 = add nuw nsw i64 %375, 1
%382 = icmp eq i64 %381, %165
br i1 %382, label %383, label %374
383: ; preds = %374, %359, %371
%384 = phi i32 [ 0, %371 ], [ %367, %359 ], [ %380, %374 ]
%385 = phi i32 [ %373, %371 ], [ %187, %359 ], [ %187, %374 ]
%386 = icmp sgt i32 %385, 0
%387 = icmp eq i32 %384, 0
%388 = select i1 %386, i1 %387, i1 false
br i1 %388, label %186, label %389
389: ; preds = %383
%390 = icmp eq i32 %384, 1
%391 = select i1 %390, i8* getelementptr inbounds ([57 x i8], [57 x i8]* @.str.7, i64 0, i64 0), i8* getelementptr inbounds ([73 x i8], [73 x i8]* @.str.8, i64 0, i64 0)
br label %392
392: ; preds = %310, %389
%393 = phi i8* [ %391, %389 ], [ getelementptr inbounds ([57 x i8], [57 x i8]* @.str.7, i64 0, i64 0), %310 ]
%394 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) %393, i8* %0)
ret void
}