#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*/ Analyze(char **);
int CheckAnagram(char *, char *);
int /*<<< orphan*/ CreateHashTable(char **, char *);
int Key(char *);
scalar_t__ LookHashTable(char **, char *, int /*<<< orphan*/);
int /*<<< orphan*/ PrintHashTable(char **);
char getch();
int /*<<< orphan*/ getchar();
int h(int, int /*<<< orphan*/);
int /*<<< orphan*/ printf(char *, ...);
int rand();
int /*<<< orphan*/ scanf(char *, char *);
int /*<<< orphan*/ srand(int /*<<< orphan*/);
int /*<<< orphan*/ time(int /*<<< orphan*/ *);
int main() {
  int i, j;
  char hashTable[8495][5] = {0};
  char userEnteredWords[100][5] = {0};
  char randomWord[5] = {0};
  char userChosenWord[5] = {0};
  int randomInteger;
  int point = 0;
  char menuChoice;
  char wordsFileName[100];
  int menuChoiceCompleted = 0;
  int userEnteredWordCount = 0;
  int letterCheck = 0;
  srand(time(NULL));
  do {
    printf("\n\n:::: MENU ::::\n\n");
    printf("[1] Create new hash table (read from words file and save to a new "
           "hashtable file). \n");
    printf("[2] Read hash table from a file (read from existing hashtable "
           "file). \n");
    menuChoice = getch();
    switch (menuChoice) {
    case '1':
      printf("Please enter the words file's name (ex: %s)> ", "words.txt");
      scanf("%s", wordsFileName);
      CreateHashTable(hashTable, wordsFileName);
      menuChoiceCompleted = 1;
      break;
    case '2':
      printf("This part is not implemented because I tried 3 days in a row "
             "just to figure out what is wrong with fseek, fwrite and fread; "
             "and angrily quit.\n");
      menuChoiceCompleted = 0;
      break;
    default:
      printf("You hit the wrong button, try again. \n\n");
      break;
    }
  } while (menuChoiceCompleted == 0);
  if (1)
    Analyze(hashTable);
  do {
    randomInteger = rand() % 8495;
    for (i = 0; i < 5; i++) {
      randomWord[i] = hashTable[randomInteger][i];
    }
  } while (randomWord[0] == 0);
  printf("\n\nYour word is \"%s\". GO!\n", randomWord);
  printf("If you want to quit, enter letter \"q\" or \"Q\".\n\n");
  do {
    printf("Enter the anagram word of %s> ", randomWord);
    scanf("%4s", userChosenWord);
    printf("You entered \"%s\" ", userChosenWord);
    if ((userChosenWord[0] != 'q' && userChosenWord[0] != 'Q') ||
        userChosenWord[1] != 0) {
      if (1)
        printf("Key: %d HashIndex (when i=0): %d %s\n", Key(userChosenWord),
               h(Key(userChosenWord), 0),
               CheckAnagram(randomWord, userChosenWord) == 1
                   ? "Its an anagram word"
                   : "Its not an anagram word");
      if (CheckAnagram(randomWord, userChosenWord) &&
          LookHashTable(hashTable, userChosenWord, 0)) {
        for (i = 0; i < userEnteredWordCount && letterCheck == 0; i++) {
          letterCheck = 1;
          for (j = 0; j < 5 - 1; j++) {
            if (userEnteredWords[i][j] != userChosenWord[j])
              letterCheck = 0;
          }
        }
        if (letterCheck == 1) {
          printf("You already entered %s. Try again.\n", userChosenWord);
          letterCheck = 0;
        } else {
          printf("%s is a meaningful anagram word. You gain 5 points!\n",
                 userChosenWord);
          point += 5;
          printf("Your total point is: %d\n\n", point);
          for (j = 0; j < 5 - 1; j++) {
            userEnteredWords[userEnteredWordCount][j] = userChosenWord[j];
          }
          userEnteredWords[userEnteredWordCount][5 - 1] = '\0';
          userEnteredWordCount++;
        }
      } else {
        printf("%s is NOT a meaningful anagram word. You lost 5 points!\n",
               userChosenWord);
        point -= 5;
        printf("Your total point is: %d\n\n", point);
      }
    }
  } while ((userChosenWord[0] != 'q' && userChosenWord[0] != 'Q') ||
           userChosenWord[1] != 0);
  printf("Your total point is %d\n", point);
  getchar();
  getchar();
  if (1)
    PrintHashTable(hashTable);
  getchar();
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa8a0,%rsp
movl   $0x0,-0x4(%rbp)
lea    -0xa600(%rbp),%rdi
xor    %esi,%esi
mov    $0xa5eb,%edx
call   1080 <memset@plt>
lea    -0xa800(%rbp),%rdi
xor    %esi,%esi
mov    $0x1f4,%edx
call   1080 <memset@plt>
lea    -0xa805(%rbp),%rdi
xor    %esi,%esi
mov    $0x5,%edx
call   1080 <memset@plt>
lea    -0xa80a(%rbp),%rdi
xor    %esi,%esi
mov    $0x5,%edx
call   1080 <memset@plt>
movl   $0x0,-0xa814(%rbp)
movl   $0x0,-0xa884(%rbp)
movl   $0x0,-0xa888(%rbp)
movl   $0x0,-0xa88c(%rbp)
xor    %eax,%eax
mov    %eax,%edi
call   10d0 <time@plt>
mov    %eax,%edi
call   10a0 <srand@plt>
lea    0xd73(%rip),%rdi
xor    %eax,%eax
mov    %al,-0xa891(%rbp)
call   1060 <printf@plt>
mov    -0xa891(%rbp),%al
lea    0xd6c(%rip),%rdi
call   1060 <printf@plt>
mov    -0xa891(%rbp),%al
lea    0xdaf(%rip),%rdi
call   1060 <printf@plt>
mov    -0xa891(%rbp),%al
call   1100 <getch@plt>
mov    %al,-0xa815(%rbp)
movsbl -0xa815(%rbp),%eax
mov    %eax,-0xa890(%rbp)
sub    $0x31,%eax
je     12fe <main+0x10e>
jmp    12ea <main+0xfa>
mov    -0xa890(%rbp),%eax
sub    $0x32,%eax
je     1348 <main+0x158>
jmp    1365 <main+0x175>
lea    0xdaa(%rip),%rdi
lea    0xdd1(%rip),%rsi
mov    $0x0,%al
call   1060 <printf@plt>
lea    -0xa880(%rbp),%rsi
lea    0xdc6(%rip),%rdi
call   10f0 <scanf@plt>
lea    -0xa600(%rbp),%rdi
lea    -0xa880(%rbp),%rsi
call   10b0 <CreateHashTable@plt>
movl   $0x1,-0xa884(%rbp)
jmp    1373 <main+0x183>
lea    0xd9b(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x0,-0xa884(%rbp)
jmp    1373 <main+0x183>
lea    0xe0d(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
jmp    1378 <main+0x188>
cmpl   $0x0,-0xa884(%rbp)
je     1286 <main+0x96>
lea    -0xa600(%rbp),%rdi
call   1030 <Analyze@plt>
mov    $0x0,%al
call   1110 <rand@plt>
mov    $0x212f,%ecx
cltd
idiv   %ecx
mov    %edx,-0xa810(%rbp)
movl   $0x0,-0x8(%rbp)
cmpl   $0x5,-0x8(%rbp)
jge    13ec <main+0x1fc>
movslq -0xa810(%rbp),%rcx
lea    -0xa600(%rbp),%rax
imul   $0x5,%rcx,%rcx
add    %rcx,%rax
movslq -0x8(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
movslq -0x8(%rbp),%rax
mov    %cl,-0xa805(%rbp,%rax,1)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    13ad <main+0x1bd>
jmp    13f1 <main+0x201>
movsbl -0xa805(%rbp),%eax
cmp    $0x0,%eax
je     1391 <main+0x1a1>
lea    -0xa805(%rbp),%rsi
lea    0xd92(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0xd9e(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    -0xa805(%rbp),%rsi
lea    0xdb9(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    -0xa80a(%rbp),%rsi
lea    0xdc3(%rip),%rdi
call   10f0 <scanf@plt>
lea    -0xa80a(%rbp),%rsi
lea    0xdb4(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movsbl -0xa80a(%rbp),%eax
cmp    $0x71,%eax
je     1481 <main+0x291>
movsbl -0xa80a(%rbp),%eax
cmp    $0x51,%eax
jne    1491 <main+0x2a1>
movsbl -0xa809(%rbp),%eax
cmp    $0x0,%eax
je     1710 <main+0x520>
lea    -0xa80a(%rbp),%rdi
call   1040 <Key@plt>
mov    %eax,-0xa89c(%rbp)
lea    -0xa80a(%rbp),%rdi
call   1040 <Key@plt>
mov    %eax,%edi
xor    %esi,%esi
call   1050 <h@plt>
mov    %eax,-0xa898(%rbp)
lea    -0xa805(%rbp),%rdi
lea    -0xa80a(%rbp),%rsi
call   1090 <CheckAnagram@plt>
mov    -0xa89c(%rbp),%esi
mov    -0xa898(%rbp),%edx
mov    %eax,%edi
lea    0xd73(%rip),%rcx
lea    0xd58(%rip),%rax
cmp    $0x1,%edi
cmove  %rax,%rcx
lea    0xd25(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    -0xa805(%rbp),%rdi
lea    -0xa80a(%rbp),%rsi
call   1090 <CheckAnagram@plt>
cmp    $0x0,%eax
je     16d3 <main+0x4e3>
lea    -0xa600(%rbp),%rdi
lea    -0xa80a(%rbp),%rsi
xor    %edx,%edx
call   1070 <LookHashTable@plt>
cmp    $0x0,%rax
je     16d3 <main+0x4e3>
movl   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%ecx
xor    %eax,%eax
cmp    -0xa888(%rbp),%ecx
mov    %al,-0xa89d(%rbp)
jge    156b <main+0x37b>
cmpl   $0x0,-0xa88c(%rbp)
sete   %al
mov    %al,-0xa89d(%rbp)
mov    -0xa89d(%rbp),%al
test   $0x1,%al
jne    157e <main+0x38e>
jmp    15f7 <main+0x407>
movl   $0x1,-0xa88c(%rbp)
movl   $0x0,-0xc(%rbp)
cmpl   $0x4,-0xc(%rbp)
jge    15e4 <main+0x3f4>
movslq -0x8(%rbp),%rcx
lea    -0xa800(%rbp),%rax
imul   $0x5,%rcx,%rcx
add    %rcx,%rax
movslq -0xc(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
movslq -0xc(%rbp),%rcx
movsbl -0xa80a(%rbp,%rcx,1),%ecx
ff
cmp    %ecx,%eax
je     15d1 <main+0x3e1>
movl   $0x0,-0xa88c(%rbp)
jmp    15d6 <main+0x3e6>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    158f <main+0x39f>
jmp    15e9 <main+0x3f9>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1544 <main+0x354>
cmpl   $0x1,-0xa88c(%rbp)
jne    1628 <main+0x438>
lea    -0xa80a(%rbp),%rsi
lea    0xc5f(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x0,-0xa88c(%rbp)
jmp    16ce <main+0x4de>
lea    -0xa80a(%rbp),%rsi
lea    0xc5f(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    -0xa814(%rbp),%eax
add    $0x5,%eax
mov    %eax,-0xa814(%rbp)
mov    -0xa814(%rbp),%esi
lea    0xc71(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x0,-0xc(%rbp)
cmpl   $0x4,-0xc(%rbp)
jge    16a6 <main+0x4b6>
movslq -0xc(%rbp),%rax
mov    -0xa80a(%rbp,%rax,1),%dl
movslq -0xa888(%rbp),%rcx
lea    -0xa800(%rbp),%rax
imul   $0x5,%rcx,%rcx
add    %rcx,%rax
movslq -0xc(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1667 <main+0x477>
movslq -0xa888(%rbp),%rcx
lea    -0xa800(%rbp),%rax
imul   $0x5,%rcx,%rcx
add    %rcx,%rax
movb   $0x0,0x4(%rax)
mov    -0xa888(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa888(%rbp)
jmp    170b <main+0x51b>
lea    -0xa80a(%rbp),%rsi
lea    0xc03(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    -0xa814(%rbp),%eax
sub    $0x5,%eax
mov    %eax,-0xa814(%rbp)
mov    -0xa814(%rbp),%esi
lea    0xbc6(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
jmp    1710 <main+0x520>
jmp    1715 <main+0x525>
movsbl -0xa80a(%rbp),%eax
cmp    $0x71,%eax
je     173d <main+0x54d>
movsbl -0xa80a(%rbp),%ecx
mov    $0x1,%al
cmp    $0x51,%ecx
mov    %al,-0xa89e(%rbp)
jne    1750 <main+0x560>
movsbl -0xa809(%rbp),%eax
cmp    $0x0,%eax
setne  %al
mov    %al,-0xa89e(%rbp)
mov    -0xa89e(%rbp),%al
test   $0x1,%al
jne    1424 <main+0x234>
mov    -0xa814(%rbp),%esi
lea    0xbb2(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    $0x0,%al
call   10c0 <getchar@plt>
mov    $0x0,%al
call   10c0 <getchar@plt>
lea    -0xa600(%rbp),%rdi
call   10e0 <PrintHashTable@plt>
mov    $0x0,%al
call   10c0 <getchar@plt>
xor    %eax,%eax
add    $0xa8a0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xa888,%rsp
lea    0x290(%rsp),%rdi
mov    $0xa5eb,%edx
xor    %esi,%esi
call   1090 <memset@plt>
lea    0x90(%rsp),%rdi
mov    $0x1f4,%edx
xor    %esi,%esi
call   1090 <memset@plt>
movb   $0x0,0xc(%rsp)
movl   $0x0,0x8(%rsp)
xor    %edi,%edi
call   10e0 <time@plt>
mov    %eax,%edi
call   10b0 <srand@plt>
lea    0xf44(%rip),%r14
lea    0xf4f(%rip),%r15
lea    0xf9c(%rip),%rbx
lea    0xfdb(%rip),%rbp
lea    0x1091(%rip),%r12
jmp    1285 <main+0x85>
nopl   0x0(%rax)
call   1040 <puts@plt>
mov    %r14,%rdi
call   1040 <puts@plt>
mov    %r15,%rdi
call   1040 <puts@plt>
mov    %rbx,%rdi
call   1040 <puts@plt>
xor    %eax,%eax
call   1110 <getch@plt>
movsbl %al,%eax
mov    %rbp,%rdi
cmp    $0x32,%eax
je     1280 <main+0x80>
cmp    $0x31,%eax
je     12b9 <main+0xb9>
mov    %r12,%rdi
jmp    1280 <main+0x80>
lea    0xd40(%rip),%rdi
lea    0xd67(%rip),%rsi
xor    %eax,%eax
call   1070 <printf@plt>
lea    0xd63(%rip),%rdi
lea    0x20(%rsp),%rbx
mov    %rbx,%rsi
call   1100 <scanf@plt>
lea    0x290(%rsp),%rbp
mov    %rbp,%rdi
mov    %rbx,%rsi
call   10c0 <CreateHashTable@plt>
mov    %rbp,%rdi
call   1030 <Analyze@plt>
nopl   (%rax)
xor    %eax,%eax
call   1120 <rand@plt>
cltq
imul   $0x1edbceb3,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x2a,%rcx
add    %edx,%ecx
imul   $0x212f,%ecx,%ecx
sub    %ecx,%eax
cltq
lea    (%rax,%rax,4),%rax
mov    0x290(%rsp,%rax,1),%ecx
mov    %ecx,0x18(%rsp)
movzbl 0x294(%rsp,%rax,1),%eax
mov    %al,0x1c(%rsp)
test   %cl,%cl
je     1300 <main+0x100>
lea    0xcee(%rip),%rdi
lea    0x18(%rsp),%r15
mov    %r15,%rsi
xor    %eax,%eax
call   1070 <printf@plt>
lea    0xf76(%rip),%rdi
call   1040 <puts@plt>
lea    0xce6(%rip),%r14
lea    0xcfe(%rip),%rbx
lea    0x8(%rsp),%r13
lea    0xcf6(%rip),%rbp
movl   $0x0,0x10(%rsp)
xor    %r12d,%r12d
nopl   (%rax)
mov    %r14,%rdi
mov    %r15,%rsi
xor    %eax,%eax
call   1070 <printf@plt>
mov    %rbx,%rdi
mov    %r13,%rsi
call   1100 <scanf@plt>
mov    %rbp,%rdi
mov    %r13,%rsi
xor    %eax,%eax
call   1070 <printf@plt>
mov    0x8(%rsp),%al
and    $0xdf,%al
cmp    $0x51,%al
jne    13ca <main+0x1ca>
cmpb   $0x0,0x9(%rsp)
je     1549 <main+0x349>
mov    %r12d,0x14(%rsp)
mov    %r14,%rbp
mov    %r13,%rdi
call   1050 <Key@plt>
mov    %eax,%r14d
mov    %r13,%rdi
call   1050 <Key@plt>
mov    %eax,%edi
xor    %esi,%esi
call   1060 <h@plt>
mov    %eax,%r12d
mov    %r15,%rdi
mov    %r13,%rsi
call   10a0 <CheckAnagram@plt>
cmp    $0x1,%eax
lea    0xcbd(%rip),%rcx
lea    0xca2(%rip),%rax
cmove  %rax,%rcx
lea    0xc72(%rip),%rdi
mov    %r14d,%esi
mov    %r12d,%edx
xor    %eax,%eax
call   1070 <printf@plt>
mov    %r15,%rdi
mov    %r13,%rsi
call   10a0 <CheckAnagram@plt>
test   %eax,%eax
je     1510 <main+0x310>
lea    0x290(%rsp),%rdi
mov    %r13,%rsi
xor    %edx,%edx
call   1080 <LookHashTable@plt>
test   %rax,%rax
je     1510 <main+0x310>
mov    0x14(%rsp),%r12d
test   %r12d,%r12d
mov    %rbp,%r14
lea    0xc13(%rip),%rbp
jle    14bd <main+0x2bd>
mov    %r12d,%eax
mov    $0x1,%ecx
movd   0x8(%rsp),%xmm0
lea    0x90(%rsp),%rdx
nopl   (%rax)
movd   (%rdx),%xmm1
pcmpeqb %xmm0,%xmm1
punpcklbw %xmm1,%xmm1
punpcklwd %xmm1,%xmm1
psrad  $0x18,%xmm1
pslld  $0x1f,%xmm1
movmskps %xmm1,%esi
cmp    $0xf,%sil
je     14b3 <main+0x2b3>
add    $0x5,%rdx
lea    0x1(%rcx),%rdi
cmp    %rax,%rcx
mov    %rdi,%rcx
jb     1480 <main+0x280>
cmp    $0xf,%sil
je     1564 <main+0x364>
lea    0xc3b(%rip),%rdi
mov    %r13,%rsi
xor    %eax,%eax
call   1070 <printf@plt>
mov    0x10(%rsp),%esi
add    $0x5,%esi
lea    0xc58(%rip),%rdi
mov    %esi,0x10(%rsp)
xor    %eax,%eax
call   1070 <printf@plt>
movslq %r12d,%rax
lea    (%rax,%rax,4),%rax
mov    0x8(%rsp),%ecx
mov    %ecx,0x90(%rsp,%rax,1)
movb   $0x0,0x94(%rsp,%rax,1)
add    $0x1,%r12d
jmp    1549 <main+0x349>
nopw   0x0(%rax,%rax,1)
lea    0xc37(%rip),%rdi
mov    %r13,%rsi
xor    %eax,%eax
call   1070 <printf@plt>
mov    0x10(%rsp),%esi
add    $0xfffffffb,%esi
lea    0xc05(%rip),%rdi
mov    %esi,0x10(%rsp)
xor    %eax,%eax
call   1070 <printf@plt>
mov    %rbp,%r14
lea    0xb34(%rip),%rbp
mov    0x14(%rsp),%r12d
mov    0x8(%rsp),%al
and    $0xdf,%al
cmp    $0x51,%al
jne    1390 <main+0x190>
cmpb   $0x0,0x9(%rsp)
jne    1390 <main+0x190>
jmp    1577 <main+0x377>
lea    0xb70(%rip),%rdi
mov    %r13,%rsi
xor    %eax,%eax
call   1070 <printf@plt>
jmp    1549 <main+0x349>
lea    0xc09(%rip),%rdi
mov    0x10(%rsp),%esi
xor    %eax,%eax
call   1070 <printf@plt>
xor    %eax,%eax
call   10d0 <getchar@plt>
xor    %eax,%eax
call   10d0 <getchar@plt>
lea    0x290(%rsp),%rdi
call   10f0 <PrintHashTable@plt>
xor    %eax,%eax
call   10d0 <getchar@plt>
xor    %eax,%eax
add    $0xa888,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [19 x i8] c"\0A\0A:::: MENU ::::\0A\0A\00"
@.str.1 = [85 x i8] c"[1] Create new hash table (read from words file and save to a new hashtable file). \0A\00"
@.str.2 = [71 x i8] c"[2] Read hash table from a file (read from existing hashtable file). \0A\00"
@.str.3 = [46 x i8] c"Please enter the words file's name (ex: %s)> \00"
@.str.4 = [10 x i8] c"words.txt\00"
@.str.5 = [3 x i8] c"%s\00"
@.str.6 = [143 x i8] c"This part is not implemented because I tried 3 days in a row just to figure out what is wrong with fseek, fwrite and fread; and angrily quit.\0A\00"
@.str.7 = [40 x i8] c"You hit the wrong button, try again. \0A\0A\00"
@.str.8 = [26 x i8] c"\0A\0AYour word is \22%s\22. GO!\0A\00"
@.str.9 = [48 x i8] c"If you want to quit, enter letter \22q\22 or \22Q\22.\0A\0A\00"
@.str.10 = [31 x i8] c"Enter the anagram word of %s> \00"
@.str.11 = [4 x i8] c"%4s\00"
@.str.12 = [18 x i8] c"You entered \22%s\22 \00"
@.str.13 = [37 x i8] c"Key: %d HashIndex (when i=0): %d %s\0A\00"
@.str.14 = [20 x i8] c"Its an anagram word\00"
@.str.15 = [24 x i8] c"Its not an anagram word\00"
@.str.16 = [36 x i8] c"You already entered %s. Try again.\0A\00"
@.str.17 = [53 x i8] c"%s is a meaningful anagram word. You gain 5 points!\0A\00"
@.str.18 = [26 x i8] c"Your total point is: %d\0A\0A\00"
@.str.19 = [57 x i8] c"%s is NOT a meaningful anagram word. You lost 5 points!\0A\00"
@.str.20 = [24 x i8] c"Your total point is %d\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca i32
%4 = alloca [8495 x [5 x i8]]
%5 = alloca [100 x [5 x i8]]
%6 = alloca [5 x i8]
%7 = alloca [5 x i8]
%8 = alloca i32
%9 = alloca i32
%10 = alloca i8
%11 = alloca [100 x i8]
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
store i32 0, i32* %1
%15 = bitcast [8495 x [5 x i8]]* %4 to i8*
%16 = bitcast [100 x [5 x i8]]* %5 to i8*
%17 = bitcast [5 x i8]* %6 to i8*
%18 = bitcast [5 x i8]* %7 to i8*
store i32 0, i32* %9
store i32 0, i32* %12
store i32 0, i32* %13
store i32 0, i32* %14
%19 = call i32 @time(i32* null)
%20 = call i32 @srand(i32 %19)
br label %21
21: ; preds = %41, %0
%22 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str, i64 0, i64 0))
%23 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([85 x i8], [85 x i8]* @.str.1, i64 0, i64 0))
%24 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([71 x i8], [71 x i8]* @.str.2, i64 0, i64 0))
%25 = call signext i8 (...) @getch()
store i8 %25, i8* %10
%26 = load i8, i8* %10
%27 = sext i8 %26 to i32
switch i32 %27, label %38 [
i32 49, label %28
i32 50, label %36
]
28: ; preds = %21
%29 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.4, i64 0, i64 0))
%30 = getelementptr inbounds [100 x i8], [100 x i8]* %11, i64 0, i64 0
%31 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %30)
%32 = getelementptr inbounds [8495 x [5 x i8]], [8495 x [5 x i8]]* %4, i64 0, i64 0
%33 = bitcast [5 x i8]* %32 to i8**
%34 = getelementptr inbounds [100 x i8], [100 x i8]* %11, i64 0, i64 0
%35 = call i32 @CreateHashTable(i8** %33, i8* %34)
store i32 1, i32* %12
br label %40
36: ; preds = %21
%37 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([143 x i8], [143 x i8]* @.str.6, i64 0, i64 0))
store i32 0, i32* %12
br label %40
38: ; preds = %21
%39 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.7, i64 0, i64 0))
br label %40
40: ; preds = %38, %36, %28
br label %41
41: ; preds = %40
%42 = load i32, i32* %12
%43 = icmp eq i32 %42, 0
br i1 %43, label %21, label %44
44: ; preds = %41
%45 = getelementptr inbounds [8495 x [5 x i8]], [8495 x [5 x i8]]* %4, i64 0, i64 0
%46 = bitcast [5 x i8]* %45 to i8**
%47 = call i32 @Analyze(i8** %46)
br label %48
48: ; preds = %69, %44
%49 = call i32 (...) @rand()
%50 = srem i32 %49, 8495
store i32 %50, i32* %8
store i32 0, i32* %2
br label %51
51: ; preds = %65, %48
%52 = load i32, i32* %2
%53 = icmp slt i32 %52, 5
br i1 %53, label %54, label %68
54: ; preds = %51
%55 = load i32, i32* %8
%56 = sext i32 %55 to i64
%57 = getelementptr inbounds [8495 x [5 x i8]], [8495 x [5 x i8]]* %4, i64 0, i64 %56
%58 = load i32, i32* %2
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds [5 x i8], [5 x i8]* %57, i64 0, i64 %59
%61 = load i8, i8* %60
%62 = load i32, i32* %2
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds [5 x i8], [5 x i8]* %6, i64 0, i64 %63
store i8 %61, i8* %64
br label %65
65: ; preds = %54
%66 = load i32, i32* %2
%67 = add nsw i32 %66, 1
store i32 %67, i32* %2
br label %51
68: ; preds = %51
br label %69
69: ; preds = %68
%70 = getelementptr inbounds [5 x i8], [5 x i8]* %6, i64 0, i64 0
%71 = load i8, i8* %70
%72 = sext i8 %71 to i32
%73 = icmp eq i32 %72, 0
br i1 %73, label %48, label %74
74: ; preds = %69
%75 = getelementptr inbounds [5 x i8], [5 x i8]* %6, i64 0, i64 0
%76 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.8, i64 0, i64 0), i8* %75)
%77 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([48 x i8], [48 x i8]* @.str.9, i64 0, i64 0))
br label %78
78: ; preds = %222, %74
%79 = getelementptr inbounds [5 x i8], [5 x i8]* %6, i64 0, i64 0
%80 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.10, i64 0, i64 0), i8* %79)
%81 = getelementptr inbounds [5 x i8], [5 x i8]* %7, i64 0, i64 0
%82 = call i32 @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.11, i64 0, i64 0), i8* %81)
%83 = getelementptr inbounds [5 x i8], [5 x i8]* %7, i64 0, i64 0
%84 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.12, i64 0, i64 0), i8* %83)
%85 = getelementptr inbounds [5 x i8], [5 x i8]* %7, i64 0, i64 0
%86 = load i8, i8* %85
%87 = sext i8 %86 to i32
%88 = icmp ne i32 %87, 113
br i1 %88, label %89, label %94
89: ; preds = %78
%90 = getelementptr inbounds [5 x i8], [5 x i8]* %7, i64 0, i64 0
%91 = load i8, i8* %90
%92 = sext i8 %91 to i32
%93 = icmp ne i32 %92, 81
br i1 %93, label %99, label %94
94: ; preds = %89, %78
%95 = getelementptr inbounds [5 x i8], [5 x i8]* %7, i64 0, i64 1
%96 = load i8, i8* %95
%97 = sext i8 %96 to i32
%98 = icmp ne i32 %97, 0
br i1 %98, label %99, label %206
99: ; preds = %94, %89
%100 = getelementptr inbounds [5 x i8], [5 x i8]* %7, i64 0, i64 0
%101 = call i32 @Key(i8* %100)
%102 = getelementptr inbounds [5 x i8], [5 x i8]* %7, i64 0, i64 0
%103 = call i32 @Key(i8* %102)
%104 = call i32 @h(i32 %103, i32 0)
%105 = getelementptr inbounds [5 x i8], [5 x i8]* %6, i64 0, i64 0
%106 = getelementptr inbounds [5 x i8], [5 x i8]* %7, i64 0, i64 0
%107 = call i32 @CheckAnagram(i8* %105, i8* %106)
%108 = icmp eq i32 %107, 1
%109 = zext i1 %108 to i64
%110 = select i1 %108, i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.14, i64 0, i64 0), i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.15, i64 0, i64 0)
%111 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str.13, i64 0, i64 0), i32 %101, i32 %104, i8* %110)
%112 = getelementptr inbounds [5 x i8], [5 x i8]* %6, i64 0, i64 0
%113 = getelementptr inbounds [5 x i8], [5 x i8]* %7, i64 0, i64 0
%114 = call i32 @CheckAnagram(i8* %112, i8* %113)
%115 = icmp ne i32 %114, 0
br i1 %115, label %116, label %198
116: ; preds = %99
%117 = getelementptr inbounds [8495 x [5 x i8]], [8495 x [5 x i8]]* %4, i64 0, i64 0
%118 = bitcast [5 x i8]* %117 to i8**
%119 = getelementptr inbounds [5 x i8], [5 x i8]* %7, i64 0, i64 0
%120 = call i64 @LookHashTable(i8** %118, i8* %119, i32 0)
%121 = icmp ne i64 %120, 0
br i1 %121, label %122, label %198
122: ; preds = %116
store i32 0, i32* %2
br label %123
123: ; preds = %157, %122
%124 = load i32, i32* %2
%125 = load i32, i32* %13
%126 = icmp slt i32 %124, %125
br i1 %126, label %127, label %130
127: ; preds = %123
%128 = load i32, i32* %14
%129 = icmp eq i32 %128, 0
br label %130
130: ; preds = %127, %123
%131 = phi i1 [ false, %123 ], [ %129, %127 ]
br i1 %131, label %132, label %160
132: ; preds = %130
store i32 1, i32* %14
store i32 0, i32* %3
br label %133
133: ; preds = %153, %132
%134 = load i32, i32* %3
%135 = icmp slt i32 %134, 4
br i1 %135, label %136, label %156
136: ; preds = %133
%137 = load i32, i32* %2
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds [100 x [5 x i8]], [100 x [5 x i8]]* %5, i64 0, i64 %138
%140 = load i32, i32* %3
%141 = sext i32 %140 to i64
%142 = getelementptr inbounds [5 x i8], [5 x i8]* %139, i64 0, i64 %141
%143 = load i8, i8* %142
%144 = sext i8 %143 to i32
%145 = load i32, i32* %3
%146 = sext i32 %145 to i64
%147 = getelementptr inbounds [5 x i8], [5 x i8]* %7, i64 0, i64 %146
%148 = load i8, i8* %147
%149 = sext i8 %148 to i32
%150 = icmp ne i32 %144, %149
br i1 %150, label %151, label %152
151: ; preds = %136
store i32 0, i32* %14
br label %152
152: ; preds = %151, %136
br label %153
153: ; preds = %152
%154 = load i32, i32* %3
%155 = add nsw i32 %154, 1
store i32 %155, i32* %3
br label %133
156: ; preds = %133
br label %157
157: ; preds = %156
%158 = load i32, i32* %2
%159 = add nsw i32 %158, 1
store i32 %159, i32* %2
br label %123
160: ; preds = %130
%161 = load i32, i32* %14
%162 = icmp eq i32 %161, 1
br i1 %162, label %163, label %166
163: ; preds = %160
%164 = getelementptr inbounds [5 x i8], [5 x i8]* %7, i64 0, i64 0
%165 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.16, i64 0, i64 0), i8* %164)
store i32 0, i32* %14
br label %197
166: ; preds = %160
%167 = getelementptr inbounds [5 x i8], [5 x i8]* %7, i64 0, i64 0
%168 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([53 x i8], [53 x i8]* @.str.17, i64 0, i64 0), i8* %167)
%169 = load i32, i32* %9
%170 = add nsw i32 %169, 5
store i32 %170, i32* %9
%171 = load i32, i32* %9
%172 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.18, i64 0, i64 0), i32 %171)
store i32 0, i32* %3
br label %173
173: ; preds = %187, %166
%174 = load i32, i32* %3
%175 = icmp slt i32 %174, 4
br i1 %175, label %176, label %190
176: ; preds = %173
%177 = load i32, i32* %3
%178 = sext i32 %177 to i64
%179 = getelementptr inbounds [5 x i8], [5 x i8]* %7, i64 0, i64 %178
%180 = load i8, i8* %179
%181 = load i32, i32* %13
%182 = sext i32 %181 to i64
%183 = getelementptr inbounds [100 x [5 x i8]], [100 x [5 x i8]]* %5, i64 0, i64 %182
%184 = load i32, i32* %3
%185 = sext i32 %184 to i64
%186 = getelementptr inbounds [5 x i8], [5 x i8]* %183, i64 0, i64 %185
store i8 %180, i8* %186
br label %187
187: ; preds = %176
%188 = load i32, i32* %3
%189 = add nsw i32 %188, 1
store i32 %189, i32* %3
br label %173
190: ; preds = %173
%191 = load i32, i32* %13
%192 = sext i32 %191 to i64
%193 = getelementptr inbounds [100 x [5 x i8]], [100 x [5 x i8]]* %5, i64 0, i64 %192
%194 = getelementptr inbounds [5 x i8], [5 x i8]* %193, i64 0, i64 4
store i8 0, i8* %194
%195 = load i32, i32* %13
%196 = add nsw i32 %195, 1
store i32 %196, i32* %13
br label %197
197: ; preds = %190, %163
br label %205
198: ; preds = %116, %99
%199 = getelementptr inbounds [5 x i8], [5 x i8]* %7, i64 0, i64 0
%200 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([57 x i8], [57 x i8]* @.str.19, i64 0, i64 0), i8* %199)
%201 = load i32, i32* %9
%202 = sub nsw i32 %201, 5
store i32 %202, i32* %9
%203 = load i32, i32* %9
%204 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.18, i64 0, i64 0), i32 %203)
br label %205
205: ; preds = %198, %197
br label %206
206: ; preds = %205, %94
br label %207
207: ; preds = %206
%208 = getelementptr inbounds [5 x i8], [5 x i8]* %7, i64 0, i64 0
%209 = load i8, i8* %208
%210 = sext i8 %209 to i32
%211 = icmp ne i32 %210, 113
br i1 %211, label %212, label %217
212: ; preds = %207
%213 = getelementptr inbounds [5 x i8], [5 x i8]* %7, i64 0, i64 0
%214 = load i8, i8* %213
%215 = sext i8 %214 to i32
%216 = icmp ne i32 %215, 81
br i1 %216, label %222, label %217
217: ; preds = %212, %207
%218 = getelementptr inbounds [5 x i8], [5 x i8]* %7, i64 0, i64 1
%219 = load i8, i8* %218
%220 = sext i8 %219 to i32
%221 = icmp ne i32 %220, 0
br label %222
222: ; preds = %217, %212
%223 = phi i1 [ true, %212 ], [ %221, %217 ]
br i1 %223, label %78, label %224
224: ; preds = %222
%225 = load i32, i32* %9
%226 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.20, i64 0, i64 0), i32 %225)
%227 = call i32 (...) @getchar()
%228 = call i32 (...) @getchar()
%229 = getelementptr inbounds [8495 x [5 x i8]], [8495 x [5 x i8]]* %4, i64 0, i64 0
%230 = bitcast [5 x i8]* %229 to i8**
%231 = call i32 @PrintHashTable(i8** %230)
%232 = call i32 (...) @getchar()
ret i32 0
}

LLVM IR (-O2):
@.str.3 = [46 x i8] c"Please enter the words file's name (ex: %s)> \00"
@.str.4 = [10 x i8] c"words.txt\00"
@.str.5 = [3 x i8] c"%s\00"
@.str.8 = [26 x i8] c"\0A\0AYour word is \22%s\22. GO!\0A\00"
@.str.10 = [31 x i8] c"Enter the anagram word of %s> \00"
@.str.11 = [4 x i8] c"%4s\00"
@.str.12 = [18 x i8] c"You entered \22%s\22 \00"
@.str.13 = [37 x i8] c"Key: %d HashIndex (when i=0): %d %s\0A\00"
@.str.14 = [20 x i8] c"Its an anagram word\00"
@.str.15 = [24 x i8] c"Its not an anagram word\00"
@.str.16 = [36 x i8] c"You already entered %s. Try again.\0A\00"
@.str.17 = [53 x i8] c"%s is a meaningful anagram word. You gain 5 points!\0A\00"
@.str.18 = [26 x i8] c"Your total point is: %d\0A\0A\00"
@.str.19 = [57 x i8] c"%s is NOT a meaningful anagram word. You lost 5 points!\0A\00"
@.str.20 = [24 x i8] c"Your total point is %d\0A\00"
@str = [18 x i8] c"\0A\0A:::: MENU ::::\0A\00"
@str.21 = [84 x i8] c"[1] Create new hash table (read from words file and save to a new hashtable file). \00"
@str.22 = [70 x i8] c"[2] Read hash table from a file (read from existing hashtable file). \00"
@str.23 = [142 x i8] c"This part is not implemented because I tried 3 days in a row just to figure out what is wrong with fseek, fwrite and fread; and angrily quit.\00"
@str.24 = [47 x i8] c"If you want to quit, enter letter \22q\22 or \22Q\22.\0A\00"
@str.25 = [39 x i8] c"You hit the wrong button, try again. \0A\00"
define i32 @main() {
%1 = alloca [8495 x [5 x i8]]
%2 = alloca [100 x [5 x i8]]
%3 = alloca [5 x i8]
%4 = getelementptr inbounds [5 x i8], [5 x i8]* %3, i64 0, i64 0
%5 = alloca [5 x i8]
%6 = alloca [100 x i8]
%7 = getelementptr inbounds [8495 x [5 x i8]], [8495 x [5 x i8]]* %1, i64 0, i64 0, i64 0
%8 = getelementptr inbounds [100 x [5 x i8]], [100 x [5 x i8]]* %2, i64 0, i64 0, i64 0
%9 = getelementptr inbounds [5 x i8], [5 x i8]* %3, i64 0, i64 0
%10 = getelementptr inbounds [5 x i8], [5 x i8]* %5, i64 0, i64 0
%11 = getelementptr inbounds [100 x i8], [100 x i8]* %6, i64 0, i64 0
%12 = tail call i32 @time(i32* null)
%13 = tail call i32 @srand(i32 %12)
br label %14
14: ; preds = %27, %0
%15 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @str, i64 0, i64 0))
%16 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([84 x i8], [84 x i8]* @str.21, i64 0, i64 0))
%17 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([70 x i8], [70 x i8]* @str.22, i64 0, i64 0))
%18 = tail call signext i8 (...) @getch()
%19 = sext i8 %18 to i32
switch i32 %19, label %26 [
i32 49, label %20
i32 50, label %27
]
20: ; preds = %14
%21 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([46 x i8], [46 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.4, i64 0, i64 0))
%22 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* %11)
%23 = bitcast [8495 x [5 x i8]]* %1 to i8**
%24 = call i32 @CreateHashTable(i8** %23, i8* %11)
%25 = call i32 @Analyze(i8** %23)
br label %30
26: ; preds = %14
br label %27
27: ; preds = %14, %26
%28 = phi i8* [ getelementptr inbounds ([39 x i8], [39 x i8]* @str.25, i64 0, i64 0), %26 ], [ getelementptr inbounds ([142 x i8], [142 x i8]* @str.23, i64 0, i64 0), %14 ]
%29 = tail call i32 @puts(i8* dereferenceable(1) %28)
br label %14
30: ; preds = %30, %20
%31 = call i32 (...) @rand()
%32 = srem i32 %31, 8495
%33 = sext i32 %32 to i64
%34 = getelementptr [8495 x [5 x i8]], [8495 x [5 x i8]]* %1, i64 0, i64 %33, i64 0
%35 = load i8, i8* %9
%36 = icmp eq i8 %35, 0
br i1 %36, label %30, label %37
37: ; preds = %30
%38 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([26 x i8], [26 x i8]* @.str.8, i64 0, i64 0), i8* %9)
%39 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @str.24, i64 0, i64 0))
%40 = getelementptr inbounds [5 x i8], [5 x i8]* %5, i64 0, i64 1
%41 = bitcast [5 x i8]* %5 to i32*
%42 = bitcast [5 x i8]* %5 to <4 x i8>*
br label %43
43: ; preds = %102, %37
%44 = phi i32 [ 0, %37 ], [ %103, %102 ]
%45 = phi i32 [ 0, %37 ], [ %104, %102 ]
%46 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([31 x i8], [31 x i8]* @.str.10, i64 0, i64 0), i8* %9)
%47 = call i32 @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.11, i64 0, i64 0), i8* %10)
%48 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @.str.12, i64 0, i64 0), i8* %10)
%49 = load i8, i8* %10
%50 = and i8 %49, -33
%51 = icmp ne i8 %50, 81
%52 = load i8, i8* %40
%53 = icmp ne i8 %52, 0
%54 = select i1 %51, i1 true, i1 %53
br i1 %54, label %55, label %102
55: ; preds = %43
%56 = call i32 @Key(i8* %10)
%57 = call i32 @Key(i8* %10)
%58 = call i32 @h(i32 %57, i32 0)
%59 = call i32 @CheckAnagram(i8* %9, i8* %10)
%60 = icmp eq i32 %59, 1
%61 = select i1 %60, i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.14, i64 0, i64 0), i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.15, i64 0, i64 0)
%62 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([37 x i8], [37 x i8]* @.str.13, i64 0, i64 0), i32 %56, i32 %58, i8* %61)
%63 = call i32 @CheckAnagram(i8* %9, i8* %10)
%64 = icmp eq i32 %63, 0
br i1 %64, label %98, label %65
65: ; preds = %55
%66 = call i64 @LookHashTable(i8** %23, i8* %10, i32 0)
%67 = icmp eq i64 %66, 0
br i1 %67, label %98, label %68
68: ; preds = %65
%69 = icmp sgt i32 %45, 0
br i1 %69, label %70, label %88
70: ; preds = %68
%71 = zext i32 %45 to i64
%72 = load <4 x i8>, <4 x i8>* %42
br label %73
73: ; preds = %70, %73
%74 = phi i64 [ 0, %70 ], [ %82, %73 ]
%75 = getelementptr inbounds [100 x [5 x i8]], [100 x [5 x i8]]* %2, i64 0, i64 %74, i64 0
%76 = bitcast i8* %75 to <4 x i8>*
%77 = load <4 x i8>, <4 x i8>* %76
%78 = icmp eq <4 x i8> %77, %72
%79 = freeze <4 x i1> %78
%80 = bitcast <4 x i1> %79 to i4
%81 = icmp eq i4 %80, -1
%82 = add nuw nsw i64 %74, 1
%83 = icmp uge i64 %82, %71
%84 = or i1 %81, %83
br i1 %84, label %85, label %73
85: ; preds = %73
br i1 %81, label %86, label %88
86: ; preds = %85
%87 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([36 x i8], [36 x i8]* @.str.16, i64 0, i64 0), i8* %10)
br label %102
88: ; preds = %68, %85
%89 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([53 x i8], [53 x i8]* @.str.17, i64 0, i64 0), i8* %10)
%90 = add nsw i32 %44, 5
%91 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([26 x i8], [26 x i8]* @.str.18, i64 0, i64 0), i32 %90)
%92 = sext i32 %45 to i64
%93 = getelementptr [100 x [5 x i8]], [100 x [5 x i8]]* %2, i64 0, i64 %92, i64 0
%94 = bitcast i8* %93 to i32*
%95 = load i32, i32* %41
store i32 %95, i32* %94
%96 = getelementptr inbounds [100 x [5 x i8]], [100 x [5 x i8]]* %2, i64 0, i64 %92, i64 4
store i8 0, i8* %96
%97 = add nsw i32 %45, 1
br label %102
98: ; preds = %65, %55
%99 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([57 x i8], [57 x i8]* @.str.19, i64 0, i64 0), i8* %10)
%100 = add nsw i32 %44, -5
%101 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([26 x i8], [26 x i8]* @.str.18, i64 0, i64 0), i32 %100)
br label %102
102: ; preds = %43, %86, %88, %98
%103 = phi i32 [ %44, %86 ], [ %90, %88 ], [ %100, %98 ], [ %44, %43 ]
%104 = phi i32 [ %45, %86 ], [ %97, %88 ], [ %45, %98 ], [ %45, %43 ]
%105 = load i8, i8* %10
%106 = and i8 %105, -33
%107 = icmp ne i8 %106, 81
%108 = load i8, i8* %40
%109 = icmp ne i8 %108, 0
%110 = select i1 %107, i1 true, i1 %109
br i1 %110, label %43, label %111
111: ; preds = %102
%112 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([24 x i8], [24 x i8]* @.str.20, i64 0, i64 0), i32 %103)
%113 = call i32 (...) @getchar()
%114 = call i32 (...) @getchar()
%115 = call i32 @PrintHashTable(i8** %23)
%116 = call i32 (...) @getchar()
ret i32 0
}