#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*/ exit(int /*<<< orphan*/);
char getchar();
int /*<<< orphan*/ isalpha(char);
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ putchar(char);
int /*<<< orphan*/ puts(char *);
int rand();
int /*<<< orphan*/ scanf(char *, int *);
int /*<<< orphan*/ srand(int /*<<< orphan*/);
int /*<<< orphan*/ time(int /*<<< orphan*/ *);
int main(void) {
  int list[16], c, d, turns;
  long mask;
  char yn;
  srand(time(NULL));
  printf("Reverse\n-------\n\n"
         "This is the game of Reverse. To win all you have to do is arrange a "
         "list\n"
         "of numbers (1 through %d) in numerical order left to right.\n"
         "To move, you input how many numbers from the right you want to "
         "reverse.\n"
         "You will no doubt like this game but, if you want to quit just input "
         "'0'\n"
         "as your move.\n\n",
         16);
  do {
    mask = 0;
    for (c = 0; c < 16; c++) {
      while (1 << (list[c] = rand() % 16 + 1) & mask)
        ;
      mask |= 1 << list[c];
    }
    turns = 0;
    puts("Here we go...\n");
    do {
      putchar('\t');
      for (c = 16; c > 0;)
        printf("%2d ", list[--c]);
      printf("\t? ");
      scanf("%d", &d);
      if (d > 1 && d <= 16) {
        for (c = 0; c < (d / 2); c++) {
          list[c] ^= list[d - c - 1];
          list[d - c - 1] ^= list[c];
          list[c] ^= list[d - c - 1];
        }
        turns++;
      } else
        printf("You can not reverse %d. Try again.\n", d);
      for (c = 0; c < 16 - 1 && list[c] > list[c + 1]; c++)
        ;
    } while (d && c < 16 - 1);
    if (d) {
      putchar('\t');
      for (c = 16; c > 0;)
        printf("%2d ", list[--c]);
      printf("\n\nYou ordered the list in %d moves.\n", turns);
      if (turns > 16 * 2 - 3)
        printf("But it shouldn't have taken more than %d moves.\n", 16 * 2 - 3);
      if (turns <= 16)
        puts("Wow, you are either extremely good, or extremely lucky.");
    }
    printf("\nWould you like to try another? (y/n) : ");
    while (!isalpha(yn = getchar()))
      ;
  } while (yn == 'y');
  puts("Good bye for now then!");
  exit(0);
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
movl   $0x0,-0x4(%rbp)
xor    %eax,%eax
mov    %eax,%edi
call   1080 <time@plt>
mov    %eax,%edi
call   1060 <srand@plt>
lea    0xe37(%rip),%rdi
mov    $0x10,%esi
mov    $0x0,%al
call   1050 <printf@plt>
movq   $0x0,-0x68(%rbp)
movl   $0x0,-0x54(%rbp)
cmpl   $0x10,-0x54(%rbp)
jge    1252 <main+0xb2>
jmp    11f3 <main+0x53>
mov    $0x0,%al
call   10c0 <rand@plt>
mov    $0x10,%ecx
cltd
idiv   %ecx
mov    %edx,%ecx
add    $0x1,%ecx
movslq -0x54(%rbp),%rax
mov    %ecx,-0x50(%rbp,%rax,4)
mov    $0x1,%eax
shl    %cl,%eax
cltq
and    -0x68(%rbp),%rax
cmp    $0x0,%rax
je     122b <main+0x8b>
jmp    11f3 <main+0x53>
movslq -0x54(%rbp),%rax
mov    -0x50(%rbp,%rax,4),%ecx
mov    $0x1,%eax
shl    %cl,%eax
cltq
or     -0x68(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    11e4 <main+0x44>
movl   $0x0,-0x5c(%rbp)
lea    0xed7(%rip),%rdi
call   1040 <puts@plt>
mov    $0x9,%edi
call   1030 <putchar@plt>
movl   $0x10,-0x54(%rbp)
cmpl   $0x0,-0x54(%rbp)
jle    12a2 <main+0x102>
mov    -0x54(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x54(%rbp)
cltq
mov    -0x50(%rbp,%rax,4),%esi
lea    0xeb0(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    1276 <main+0xd6>
lea    0xea2(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0xe98(%rip),%rdi
lea    -0x58(%rbp),%rsi
call   10a0 <scanf@plt>
cmpl   $0x1,-0x58(%rbp)
jle    1366 <main+0x1c6>
cmpl   $0x10,-0x58(%rbp)
jg     1366 <main+0x1c6>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x58(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x70(%rbp),%eax
cmp    %ecx,%eax
jge    1358 <main+0x1b8>
mov    -0x58(%rbp),%eax
sub    -0x54(%rbp),%eax
sub    $0x1,%eax
cltq
mov    -0x50(%rbp,%rax,4),%ecx
movslq -0x54(%rbp),%rax
xor    -0x50(%rbp,%rax,4),%ecx
mov    %ecx,-0x50(%rbp,%rax,4)
movslq -0x54(%rbp),%rax
mov    -0x50(%rbp,%rax,4),%ecx
mov    -0x58(%rbp),%eax
sub    -0x54(%rbp),%eax
sub    $0x1,%eax
cltq
xor    -0x50(%rbp,%rax,4),%ecx
mov    %ecx,-0x50(%rbp,%rax,4)
mov    -0x58(%rbp),%eax
sub    -0x54(%rbp),%eax
sub    $0x1,%eax
cltq
mov    -0x50(%rbp,%rax,4),%ecx
movslq -0x54(%rbp),%rax
xor    -0x50(%rbp,%rax,4),%ecx
mov    %ecx,-0x50(%rbp,%rax,4)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    12db <main+0x13b>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1377 <main+0x1d7>
mov    -0x58(%rbp),%esi
lea    0xde2(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x54(%rbp)
xor    %eax,%eax
cmpl   $0xf,-0x54(%rbp)
mov    %al,-0x71(%rbp)
jge    13a8 <main+0x208>
movslq -0x54(%rbp),%rax
mov    -0x50(%rbp,%rax,4),%eax
mov    -0x54(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
cmp    -0x50(%rbp,%rcx,4),%eax
setg   %al
mov    %al,-0x71(%rbp)
mov    -0x71(%rbp),%al
test   $0x1,%al
jne    13b8 <main+0x218>
jmp    13cb <main+0x22b>
jmp    13bd <main+0x21d>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    137e <main+0x1de>
jmp    13d0 <main+0x230>
xor    %eax,%eax
cmpl   $0x0,-0x58(%rbp)
mov    %al,-0x72(%rbp)
je     13e9 <main+0x249>
cmpl   $0xf,-0x54(%rbp)
setl   %al
mov    %al,-0x72(%rbp)
mov    -0x72(%rbp),%al
test   $0x1,%al
jne    1265 <main+0xc5>
cmpl   $0x0,-0x58(%rbp)
je     1484 <main+0x2e4>
mov    $0x9,%edi
call   1030 <putchar@plt>
movl   $0x10,-0x54(%rbp)
cmpl   $0x0,-0x54(%rbp)
jle    143b <main+0x29b>
mov    -0x54(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x54(%rbp)
cltq
mov    -0x50(%rbp,%rax,4),%esi
lea    0xd17(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    140f <main+0x26f>
mov    -0x5c(%rbp),%esi
lea    0xd31(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
cmpl   $0x1d,-0x5c(%rbp)
jle    1469 <main+0x2c9>
lea    0xd3e(%rip),%rdi
mov    $0x1d,%esi
mov    $0x0,%al
call   1050 <printf@plt>
cmpl   $0x10,-0x5c(%rbp)
jg     147f <main+0x2df>
lea    0xd52(%rip),%rdi
call   1040 <puts@plt>
jmp    1484 <main+0x2e4>
lea    0xd79(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    $0x0,%al
call   1070 <getchar@plt>
mov    %al,-0x69(%rbp)
movsbl %al,%edi
call   1090 <isalpha@plt>
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
test   $0x1,%al
jne    14b9 <main+0x319>
jmp    14be <main+0x31e>
jmp    1492 <main+0x2f2>
jmp    14c3 <main+0x323>
movsbl -0x69(%rbp),%eax
cmp    $0x79,%eax
je     11d5 <main+0x35>
lea    0xd56(%rip),%rdi
call   1040 <puts@plt>
xor    %edi,%edi
call   10b0 <exit@plt>

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
xor    %edi,%edi
call   1080 <time@plt>
mov    %eax,%edi
call   1060 <srand@plt>
lea    0xe3d(%rip),%rdi
mov    $0x10,%esi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0xf70(%rip),%r12
lea    0xf6e(%rip),%rbx
lea    0x44(%rsp),%r13
xor    %r14d,%r14d
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
xor    %eax,%eax
call   10c0 <rand@plt>
lea    0xf(%rax),%ecx
test   %eax,%eax
cmovns %eax,%ecx
and    $0xfffffff0,%ecx
neg    %ecx
add    %eax,%ecx
add    $0x1,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    %ecx,(%rsp,%r14,4)
cltq
test   %rax,%rbp
jne    11f0 <main+0x50>
or     %rax,%rbp
add    $0x1,%r14
cmp    $0x10,%r14
jne    11f0 <main+0x50>
lea    0xf08(%rip),%rdi
call   1040 <puts@plt>
xor    %r15d,%r15d
jmp    124b <main+0xab>
nopl   0x0(%rax)
cmpl   $0x0,0x44(%rsp)
je     1677 <main+0x4d7>
mov    $0x9,%edi
call   1030 <putchar@plt>
mov    0x3c(%rsp),%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x38(%rsp),%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x34(%rsp),%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x30(%rsp),%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x2c(%rsp),%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x28(%rsp),%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x24(%rsp),%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x20(%rsp),%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x1c(%rsp),%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x18(%rsp),%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x14(%rsp),%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x10(%rsp),%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0xc(%rsp),%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x8(%rsp),%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x4(%rsp),%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    (%rsp),%ebp
mov    %r12,%rdi
mov    %ebp,%esi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0xe08(%rip),%rdi
mov    %r13,%rsi
call   10a0 <scanf@plt>
mov    0x44(%rsp),%esi
lea    -0x2(%rsi),%ecx
cmp    $0xe,%ecx
ja     1480 <main+0x2e0>
mov    %esi,%eax
shr    %eax
and    $0x7f,%eax
lea    -0x1(%rsi),%edx
movslq %edx,%rdx
xor    (%rsp,%rdx,4),%ebp
mov    %ebp,(%rsp)
xor    (%rsp,%rdx,4),%ebp
mov    %ebp,(%rsp,%rdx,4)
xor    %ebp,(%rsp)
cmp    $0x1,%eax
je     1470 <main+0x2d0>
mov    0x4(%rsp),%edx
movslq %ecx,%rcx
xor    (%rsp,%rcx,4),%edx
mov    %edx,0x4(%rsp)
xor    (%rsp,%rcx,4),%edx
mov    %edx,(%rsp,%rcx,4)
xor    %edx,0x4(%rsp)
cmp    $0x2,%eax
je     1470 <main+0x2d0>
mov    0x8(%rsp),%ecx
lea    -0x3(%rsi),%edx
movslq %edx,%rdx
xor    (%rsp,%rdx,4),%ecx
mov    %ecx,0x8(%rsp)
xor    (%rsp,%rdx,4),%ecx
mov    %ecx,(%rsp,%rdx,4)
xor    %ecx,0x8(%rsp)
cmp    $0x3,%eax
je     1470 <main+0x2d0>
mov    0xc(%rsp),%ecx
lea    -0x4(%rsi),%edx
movslq %edx,%rdx
xor    (%rsp,%rdx,4),%ecx
mov    %ecx,0xc(%rsp)
xor    (%rsp,%rdx,4),%ecx
mov    %ecx,(%rsp,%rdx,4)
xor    %ecx,0xc(%rsp)
cmp    $0x4,%eax
je     1470 <main+0x2d0>
mov    0x10(%rsp),%ecx
lea    -0x5(%rsi),%edx
movslq %edx,%rdx
xor    (%rsp,%rdx,4),%ecx
mov    %ecx,0x10(%rsp)
xor    (%rsp,%rdx,4),%ecx
mov    %ecx,(%rsp,%rdx,4)
xor    %ecx,0x10(%rsp)
cmp    $0x5,%eax
je     1470 <main+0x2d0>
mov    0x14(%rsp),%ecx
lea    -0x6(%rsi),%edx
movslq %edx,%rdx
xor    (%rsp,%rdx,4),%ecx
mov    %ecx,0x14(%rsp)
xor    (%rsp,%rdx,4),%ecx
mov    %ecx,(%rsp,%rdx,4)
xor    %ecx,0x14(%rsp)
cmp    $0x6,%eax
je     1470 <main+0x2d0>
mov    0x18(%rsp),%ecx
lea    -0x7(%rsi),%edx
movslq %edx,%rdx
xor    (%rsp,%rdx,4),%ecx
mov    %ecx,0x18(%rsp)
xor    (%rsp,%rdx,4),%ecx
mov    %ecx,(%rsp,%rdx,4)
xor    %ecx,0x18(%rsp)
cmp    $0x7,%eax
je     1470 <main+0x2d0>
mov    0x1c(%rsp),%eax
add    $0xfffffff8,%esi
movslq %esi,%rcx
xor    (%rsp,%rcx,4),%eax
mov    %eax,0x1c(%rsp)
xor    (%rsp,%rcx,4),%eax
mov    %eax,(%rsp,%rcx,4)
xor    %eax,0x1c(%rsp)
nopl   0x0(%rax,%rax,1)
add    $0x1,%r15d
jmp    148e <main+0x2ee>
cs nopw 0x0(%rax,%rax,1)
lea    0xccb(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    (%rsp),%r14d
mov    0x4(%rsp),%eax
cmp    %eax,%r14d
jle    1240 <main+0xa0>
mov    0x8(%rsp),%ecx
cmp    %ecx,%eax
jle    1240 <main+0xa0>
mov    0xc(%rsp),%eax
cmp    %eax,%ecx
jle    1240 <main+0xa0>
mov    0x10(%rsp),%ecx
cmp    %ecx,%eax
jle    1240 <main+0xa0>
mov    0x14(%rsp),%eax
cmp    %eax,%ecx
jle    1240 <main+0xa0>
mov    0x18(%rsp),%ecx
cmp    %ecx,%eax
jle    1240 <main+0xa0>
mov    0x1c(%rsp),%eax
cmp    %eax,%ecx
jle    1240 <main+0xa0>
mov    0x20(%rsp),%ecx
cmp    %ecx,%eax
jle    1240 <main+0xa0>
mov    0x24(%rsp),%eax
cmp    %eax,%ecx
jle    1240 <main+0xa0>
mov    0x28(%rsp),%ecx
cmp    %ecx,%eax
jle    1240 <main+0xa0>
mov    0x2c(%rsp),%eax
cmp    %eax,%ecx
jle    1240 <main+0xa0>
mov    0x30(%rsp),%ecx
cmp    %ecx,%eax
jle    1240 <main+0xa0>
mov    0x34(%rsp),%eax
cmp    %eax,%ecx
jle    1240 <main+0xa0>
mov    0x38(%rsp),%ecx
cmp    %ecx,%eax
jle    1240 <main+0xa0>
cmp    0x3c(%rsp),%ecx
jle    1240 <main+0xa0>
cmpl   $0x0,0x44(%rsp)
je     1677 <main+0x4d7>
mov    $0x9,%edi
call   1030 <putchar@plt>
mov    0x3c(%rsp),%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x38(%rsp),%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x34(%rsp),%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x30(%rsp),%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x2c(%rsp),%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x28(%rsp),%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x24(%rsp),%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x20(%rsp),%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x1c(%rsp),%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x18(%rsp),%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x14(%rsp),%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x10(%rsp),%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0xc(%rsp),%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x8(%rsp),%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x4(%rsp),%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %r12,%rdi
mov    %r14d,%esi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0xb36(%rip),%rdi
mov    %r15d,%esi
xor    %eax,%eax
call   1050 <printf@plt>
cmp    $0x1e,%r15d
jl     1665 <main+0x4c5>
lea    0xb44(%rip),%rdi
mov    $0x1d,%esi
xor    %eax,%eax
call   1050 <printf@plt>
jmp    1677 <main+0x4d7>
cmp    $0x10,%r15d
jg     1677 <main+0x4d7>
lea    0xb5a(%rip),%rdi
call   1040 <puts@plt>
mov    %rbx,%r15
lea    0xb83(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
nopl   0x0(%rax,%rax,1)
xor    %eax,%eax
call   1070 <getchar@plt>
mov    %eax,%ebx
movsbl %al,%edi
call   1090 <isalpha@plt>
test   %eax,%eax
je     1690 <main+0x4f0>
mov    $0x0,%r14d
mov    $0x0,%ebp
cmp    $0x79,%bl
mov    %r15,%rbx
je     11f0 <main+0x50>
lea    0xb6a(%rip),%rdi
call   1040 <puts@plt>
xor    %edi,%edi
call   10b0 <exit@plt>

LLVM IR (-O0):
@.str = [311 x i8] c"Reverse\0A-------\0A\0AThis is the game of Reverse. To win all you have to do is arrange a list\0Aof numbers (1 through %d) in numerical order left to right.\0ATo move, you input how many numbers from the right you want to reverse.\0AYou will no doubt like this game but, if you want to quit just input '0'\0Aas your move.\0A\0A\00"
@.str.1 = [15 x i8] c"Here we go...\0A\00"
@.str.2 = [5 x i8] c"%2d \00"
@.str.3 = [4 x i8] c"\09? \00"
@.str.4 = [3 x i8] c"%d\00"
@.str.5 = [36 x i8] c"You can not reverse %d. Try again.\0A\00"
@.str.6 = [37 x i8] c"\0A\0AYou ordered the list in %d moves.\0A\00"
@.str.7 = [49 x i8] c"But it shouldn't have taken more than %d moves.\0A\00"
@.str.8 = [56 x i8] c"Wow, you are either extremely good, or extremely lucky.\00"
@.str.9 = [41 x i8] c"\0AWould you like to try another? (y/n) : \00"
@.str.10 = [23 x i8] c"Good bye for now then!\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca [16 x i32]
%3 = alloca i32
%4 = alloca i32
%5 = alloca i32
%6 = alloca i64
%7 = alloca i8
store i32 0, i32* %1
%8 = call i32 @time(i32* null)
%9 = call i32 @srand(i32 %8)
%10 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([311 x i8], [311 x i8]* @.str, i64 0, i64 0), i32 16)
br label %11
11: ; preds = %182, %0
store i64 0, i64* %6
store i32 0, i32* %3
br label %12
12: ; preds = %38, %11
%13 = load i32, i32* %3
%14 = icmp slt i32 %13, 16
br i1 %14, label %15, label %41
15: ; preds = %12
br label %16
16: ; preds = %28, %15
%17 = call i32 (...) @rand()
%18 = srem i32 %17, 16
%19 = add nsw i32 %18, 1
%20 = load i32, i32* %3
%21 = sext i32 %20 to i64
%22 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 %21
store i32 %19, i32* %22
%23 = shl i32 1, %19
%24 = sext i32 %23 to i64
%25 = load i64, i64* %6
%26 = and i64 %24, %25
%27 = icmp ne i64 %26, 0
br i1 %27, label %28, label %29
28: ; preds = %16
br label %16
29: ; preds = %16
%30 = load i32, i32* %3
%31 = sext i32 %30 to i64
%32 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 %31
%33 = load i32, i32* %32
%34 = shl i32 1, %33
%35 = sext i32 %34 to i64
%36 = load i64, i64* %6
%37 = or i64 %36, %35
store i64 %37, i64* %6
br label %38
38: ; preds = %29
%39 = load i32, i32* %3
%40 = add nsw i32 %39, 1
store i32 %40, i32* %3
br label %12
41: ; preds = %12
store i32 0, i32* %5
%42 = call i32 @puts(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.1, i64 0, i64 0))
br label %43
43: ; preds = %143, %41
%44 = call i32 @putchar(i8 signext 9)
store i32 16, i32* %3
br label %45
45: ; preds = %48, %43
%46 = load i32, i32* %3
%47 = icmp sgt i32 %46, 0
br i1 %47, label %48, label %55
48: ; preds = %45
%49 = load i32, i32* %3
%50 = add nsw i32 %49, -1
store i32 %50, i32* %3
%51 = sext i32 %50 to i64
%52 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 %51
%53 = load i32, i32* %52
%54 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0), i32 %53)
br label %45
55: ; preds = %45
%56 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0))
%57 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i64 0, i64 0), i32* %4)
%58 = load i32, i32* %4
%59 = icmp sgt i32 %58, 1
br i1 %59, label %60, label %112
60: ; preds = %55
%61 = load i32, i32* %4
%62 = icmp sle i32 %61, 16
br i1 %62, label %63, label %112
63: ; preds = %60
store i32 0, i32* %3
br label %64
64: ; preds = %106, %63
%65 = load i32, i32* %3
%66 = load i32, i32* %4
%67 = sdiv i32 %66, 2
%68 = icmp slt i32 %65, %67
br i1 %68, label %69, label %109
69: ; preds = %64
%70 = load i32, i32* %4
%71 = load i32, i32* %3
%72 = sub nsw i32 %70, %71
%73 = sub nsw i32 %72, 1
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 %74
%76 = load i32, i32* %75
%77 = load i32, i32* %3
%78 = sext i32 %77 to i64
%79 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 %78
%80 = load i32, i32* %79
%81 = xor i32 %80, %76
store i32 %81, i32* %79
%82 = load i32, i32* %3
%83 = sext i32 %82 to i64
%84 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 %83
%85 = load i32, i32* %84
%86 = load i32, i32* %4
%87 = load i32, i32* %3
%88 = sub nsw i32 %86, %87
%89 = sub nsw i32 %88, 1
%90 = sext i32 %89 to i64
%91 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 %90
%92 = load i32, i32* %91
%93 = xor i32 %92, %85
store i32 %93, i32* %91
%94 = load i32, i32* %4
%95 = load i32, i32* %3
%96 = sub nsw i32 %94, %95
%97 = sub nsw i32 %96, 1
%98 = sext i32 %97 to i64
%99 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 %98
%100 = load i32, i32* %99
%101 = load i32, i32* %3
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 %102
%104 = load i32, i32* %103
%105 = xor i32 %104, %100
store i32 %105, i32* %103
br label %106
106: ; preds = %69
%107 = load i32, i32* %3
%108 = add nsw i32 %107, 1
store i32 %108, i32* %3
br label %64
109: ; preds = %64
%110 = load i32, i32* %5
%111 = add nsw i32 %110, 1
store i32 %111, i32* %5
br label %115
112: ; preds = %60, %55
%113 = load i32, i32* %4
%114 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.5, i64 0, i64 0), i32 %113)
br label %115
115: ; preds = %112, %109
store i32 0, i32* %3
br label %116
116: ; preds = %133, %115
%117 = load i32, i32* %3
%118 = icmp slt i32 %117, 15
br i1 %118, label %119, label %130
119: ; preds = %116
%120 = load i32, i32* %3
%121 = sext i32 %120 to i64
%122 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 %121
%123 = load i32, i32* %122
%124 = load i32, i32* %3
%125 = add nsw i32 %124, 1
%126 = sext i32 %125 to i64
%127 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 %126
%128 = load i32, i32* %127
%129 = icmp sgt i32 %123, %128
br label %130
130: ; preds = %119, %116
%131 = phi i1 [ false, %116 ], [ %129, %119 ]
br i1 %131, label %132, label %136
132: ; preds = %130
br label %133
133: ; preds = %132
%134 = load i32, i32* %3
%135 = add nsw i32 %134, 1
store i32 %135, i32* %3
br label %116
136: ; preds = %130
br label %137
137: ; preds = %136
%138 = load i32, i32* %4
%139 = icmp ne i32 %138, 0
br i1 %139, label %140, label %143
140: ; preds = %137
%141 = load i32, i32* %3
%142 = icmp slt i32 %141, 15
br label %143
143: ; preds = %140, %137
%144 = phi i1 [ false, %137 ], [ %142, %140 ]
br i1 %144, label %43, label %145
145: ; preds = %143
%146 = load i32, i32* %4
%147 = icmp ne i32 %146, 0
br i1 %147, label %148, label %173
148: ; preds = %145
%149 = call i32 @putchar(i8 signext 9)
store i32 16, i32* %3
br label %150
150: ; preds = %153, %148
%151 = load i32, i32* %3
%152 = icmp sgt i32 %151, 0
br i1 %152, label %153, label %160
153: ; preds = %150
%154 = load i32, i32* %3
%155 = add nsw i32 %154, -1
store i32 %155, i32* %3
%156 = sext i32 %155 to i64
%157 = getelementptr inbounds [16 x i32], [16 x i32]* %2, i64 0, i64 %156
%158 = load i32, i32* %157
%159 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0), i32 %158)
br label %150
160: ; preds = %150
%161 = load i32, i32* %5
%162 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str.6, i64 0, i64 0), i32 %161)
%163 = load i32, i32* %5
%164 = icmp sgt i32 %163, 29
br i1 %164, label %165, label %167
165: ; preds = %160
%166 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.7, i64 0, i64 0), i32 29)
br label %167
167: ; preds = %165, %160
%168 = load i32, i32* %5
%169 = icmp sle i32 %168, 16
br i1 %169, label %170, label %172
170: ; preds = %167
%171 = call i32 @puts(i8* getelementptr inbounds ([56 x i8], [56 x i8]* @.str.8, i64 0, i64 0))
br label %172
172: ; preds = %170, %167
br label %173
173: ; preds = %172, %145
%174 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str.9, i64 0, i64 0))
br label %175
175: ; preds = %180, %173
%176 = call signext i8 (...) @getchar()
store i8 %176, i8* %7
%177 = call i32 @isalpha(i8 signext %176)
%178 = icmp ne i32 %177, 0
%179 = xor i1 %178, true
br i1 %179, label %180, label %181
180: ; preds = %175
br label %175
181: ; preds = %175
br label %182
182: ; preds = %181
%183 = load i8, i8* %7
%184 = sext i8 %183 to i32
%185 = icmp eq i32 %184, 121
br i1 %185, label %11, label %186
186: ; preds = %182
%187 = call i32 @puts(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.10, i64 0, i64 0))
%188 = call i32 @exit(i32 0)
unreachable
}

LLVM IR (-O2):
@.str = [311 x i8] c"Reverse\0A-------\0A\0AThis is the game of Reverse. To win all you have to do is arrange a list\0Aof numbers (1 through %d) in numerical order left to right.\0ATo move, you input how many numbers from the right you want to reverse.\0AYou will no doubt like this game but, if you want to quit just input '0'\0Aas your move.\0A\0A\00"
@.str.1 = [15 x i8] c"Here we go...\0A\00"
@.str.2 = [5 x i8] c"%2d \00"
@.str.3 = [4 x i8] c"\09? \00"
@.str.4 = [3 x i8] c"%d\00"
@.str.5 = [36 x i8] c"You can not reverse %d. Try again.\0A\00"
@.str.6 = [37 x i8] c"\0A\0AYou ordered the list in %d moves.\0A\00"
@.str.7 = [49 x i8] c"But it shouldn't have taken more than %d moves.\0A\00"
@.str.8 = [56 x i8] c"Wow, you are either extremely good, or extremely lucky.\00"
@.str.9 = [41 x i8] c"\0AWould you like to try another? (y/n) : \00"
@.str.10 = [23 x i8] c"Good bye for now then!\00"
define i32 @main() {
%1 = alloca [16 x i32]
%2 = alloca i32
%3 = bitcast [16 x i32]* %1 to i8*
%4 = bitcast i32* %2 to i8*
%5 = tail call i32 @time(i32* null)
%6 = tail call i32 @srand(i32 %5)
%7 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([311 x i8], [311 x i8]* @.str, i64 0, i64 0), i32 16)
%8 = getelementptr inbounds [16 x i32], [16 x i32]* %1, i64 0, i64 15
%9 = getelementptr inbounds [16 x i32], [16 x i32]* %1, i64 0, i64 14
%10 = getelementptr inbounds [16 x i32], [16 x i32]* %1, i64 0, i64 13
%11 = getelementptr inbounds [16 x i32], [16 x i32]* %1, i64 0, i64 12
%12 = getelementptr inbounds [16 x i32], [16 x i32]* %1, i64 0, i64 11
%13 = getelementptr inbounds [16 x i32], [16 x i32]* %1, i64 0, i64 10
%14 = getelementptr inbounds [16 x i32], [16 x i32]* %1, i64 0, i64 9
%15 = getelementptr inbounds [16 x i32], [16 x i32]* %1, i64 0, i64 8
%16 = getelementptr inbounds [16 x i32], [16 x i32]* %1, i64 0, i64 7
%17 = getelementptr inbounds [16 x i32], [16 x i32]* %1, i64 0, i64 6
%18 = getelementptr inbounds [16 x i32], [16 x i32]* %1, i64 0, i64 5
%19 = getelementptr inbounds [16 x i32], [16 x i32]* %1, i64 0, i64 4
%20 = getelementptr inbounds [16 x i32], [16 x i32]* %1, i64 0, i64 3
%21 = getelementptr inbounds [16 x i32], [16 x i32]* %1, i64 0, i64 2
%22 = getelementptr inbounds [16 x i32], [16 x i32]* %1, i64 0, i64 1
%23 = getelementptr inbounds [16 x i32], [16 x i32]* %1, i64 0, i64 0
%24 = getelementptr inbounds [16 x i32], [16 x i32]* %1, i64 0, i64 0
%25 = getelementptr inbounds [16 x i32], [16 x i32]* %1, i64 0, i64 1
%26 = getelementptr inbounds [16 x i32], [16 x i32]* %1, i64 0, i64 1
%27 = getelementptr inbounds [16 x i32], [16 x i32]* %1, i64 0, i64 2
%28 = getelementptr inbounds [16 x i32], [16 x i32]* %1, i64 0, i64 2
%29 = getelementptr inbounds [16 x i32], [16 x i32]* %1, i64 0, i64 3
%30 = getelementptr inbounds [16 x i32], [16 x i32]* %1, i64 0, i64 3
%31 = getelementptr inbounds [16 x i32], [16 x i32]* %1, i64 0, i64 4
%32 = getelementptr inbounds [16 x i32], [16 x i32]* %1, i64 0, i64 4
%33 = getelementptr inbounds [16 x i32], [16 x i32]* %1, i64 0, i64 5
%34 = getelementptr inbounds [16 x i32], [16 x i32]* %1, i64 0, i64 5
%35 = getelementptr inbounds [16 x i32], [16 x i32]* %1, i64 0, i64 6
%36 = getelementptr inbounds [16 x i32], [16 x i32]* %1, i64 0, i64 6
%37 = getelementptr inbounds [16 x i32], [16 x i32]* %1, i64 0, i64 7
%38 = getelementptr inbounds [16 x i32], [16 x i32]* %1, i64 0, i64 7
br label %39
39: ; preds = %55, %0
%40 = phi i64 [ 0, %0 ], [ %56, %55 ]
%41 = phi i64 [ 0, %0 ], [ %57, %55 ]
%42 = getelementptr inbounds [16 x i32], [16 x i32]* %1, i64 0, i64 %40
br label %43
43: ; preds = %39, %43
%44 = call i32 (...) @rand()
%45 = srem i32 %44, 16
%46 = add nsw i32 %45, 1
store i32 %46, i32* %42
%47 = shl nuw nsw i32 1, %46
%48 = sext i32 %47 to i64
%49 = and i64 %41, %48
%50 = icmp eq i64 %49, 0
br i1 %50, label %51, label %43
51: ; preds = %43
%52 = or i64 %41, %48
%53 = add nuw nsw i64 %40, 1
%54 = icmp eq i64 %53, 16
br i1 %54, label %58, label %55
55: ; preds = %51, %301
%56 = phi i64 [ %53, %51 ], [ 0, %301 ]
%57 = phi i64 [ %52, %51 ], [ 0, %301 ]
br label %39
58: ; preds = %51
%59 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @.str.1, i64 0, i64 0))
br label %60
60: ; preds = %251, %58
%61 = phi i32 [ 0, %58 ], [ %202, %251 ]
%62 = call i32 @putchar(i8 signext 9)
%63 = load i32, i32* %8
%64 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0), i32 %63)
%65 = load i32, i32* %9
%66 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0), i32 %65)
%67 = load i32, i32* %10
%68 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0), i32 %67)
%69 = load i32, i32* %11
%70 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0), i32 %69)
%71 = load i32, i32* %12
%72 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0), i32 %71)
%73 = load i32, i32* %13
%74 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0), i32 %73)
%75 = load i32, i32* %14
%76 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0), i32 %75)
%77 = load i32, i32* %15
%78 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0), i32 %77)
%79 = load i32, i32* %16
%80 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0), i32 %79)
%81 = load i32, i32* %17
%82 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0), i32 %81)
%83 = load i32, i32* %18
%84 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0), i32 %83)
%85 = load i32, i32* %19
%86 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0), i32 %85)
%87 = load i32, i32* %20
%88 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0), i32 %87)
%89 = load i32, i32* %21
%90 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0), i32 %89)
%91 = load i32, i32* %22
%92 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0), i32 %91)
%93 = load i32, i32* %23
%94 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0), i32 %93)
%95 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0))
%96 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i64 0, i64 0), i32* %2)
%97 = load i32, i32* %2
%98 = add i32 %97, -2
%99 = icmp ult i32 %98, 15
br i1 %99, label %100, label %199
100: ; preds = %60
%101 = lshr i32 %97, 1
%102 = and i32 %101, 127
%103 = add i32 %97, -1
%104 = sext i32 %103 to i64
%105 = getelementptr inbounds [16 x i32], [16 x i32]* %1, i64 0, i64 %104
%106 = load i32, i32* %105
%107 = xor i32 %93, %106
store i32 %107, i32* %24
%108 = load i32, i32* %105
%109 = xor i32 %108, %107
store i32 %109, i32* %105
%110 = load i32, i32* %24
%111 = xor i32 %110, %109
store i32 %111, i32* %24
%112 = icmp eq i32 %102, 1
br i1 %112, label %197, label %113
113: ; preds = %100
%114 = load i32, i32* %25
%115 = add i32 %97, -2
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds [16 x i32], [16 x i32]* %1, i64 0, i64 %116
%118 = load i32, i32* %117
%119 = xor i32 %114, %118
store i32 %119, i32* %26
%120 = load i32, i32* %117
%121 = xor i32 %120, %119
store i32 %121, i32* %117
%122 = load i32, i32* %26
%123 = xor i32 %122, %121
store i32 %123, i32* %26
%124 = icmp eq i32 %102, 2
br i1 %124, label %197, label %125
125: ; preds = %113
%126 = load i32, i32* %27
%127 = add i32 %97, -3
%128 = sext i32 %127 to i64
%129 = getelementptr inbounds [16 x i32], [16 x i32]* %1, i64 0, i64 %128
%130 = load i32, i32* %129
%131 = xor i32 %126, %130
store i32 %131, i32* %28
%132 = load i32, i32* %129
%133 = xor i32 %132, %131
store i32 %133, i32* %129
%134 = load i32, i32* %28
%135 = xor i32 %134, %133
store i32 %135, i32* %28
%136 = icmp eq i32 %102, 3
br i1 %136, label %197, label %137
137: ; preds = %125
%138 = load i32, i32* %29
%139 = add i32 %97, -4
%140 = sext i32 %139 to i64
%141 = getelementptr inbounds [16 x i32], [16 x i32]* %1, i64 0, i64 %140
%142 = load i32, i32* %141
%143 = xor i32 %138, %142
store i32 %143, i32* %30
%144 = load i32, i32* %141
%145 = xor i32 %144, %143
store i32 %145, i32* %141
%146 = load i32, i32* %30
%147 = xor i32 %146, %145
store i32 %147, i32* %30
%148 = icmp eq i32 %102, 4
br i1 %148, label %197, label %149
149: ; preds = %137
%150 = load i32, i32* %31
%151 = add i32 %97, -5
%152 = sext i32 %151 to i64
%153 = getelementptr inbounds [16 x i32], [16 x i32]* %1, i64 0, i64 %152
%154 = load i32, i32* %153
%155 = xor i32 %150, %154
store i32 %155, i32* %32
%156 = load i32, i32* %153
%157 = xor i32 %156, %155
store i32 %157, i32* %153
%158 = load i32, i32* %32
%159 = xor i32 %158, %157
store i32 %159, i32* %32
%160 = icmp eq i32 %102, 5
br i1 %160, label %197, label %161
161: ; preds = %149
%162 = load i32, i32* %33
%163 = add i32 %97, -6
%164 = sext i32 %163 to i64
%165 = getelementptr inbounds [16 x i32], [16 x i32]* %1, i64 0, i64 %164
%166 = load i32, i32* %165
%167 = xor i32 %162, %166
store i32 %167, i32* %34
%168 = load i32, i32* %165
%169 = xor i32 %168, %167
store i32 %169, i32* %165
%170 = load i32, i32* %34
%171 = xor i32 %170, %169
store i32 %171, i32* %34
%172 = icmp eq i32 %102, 6
br i1 %172, label %197, label %173
173: ; preds = %161
%174 = load i32, i32* %35
%175 = add i32 %97, -7
%176 = sext i32 %175 to i64
%177 = getelementptr inbounds [16 x i32], [16 x i32]* %1, i64 0, i64 %176
%178 = load i32, i32* %177
%179 = xor i32 %174, %178
store i32 %179, i32* %36
%180 = load i32, i32* %177
%181 = xor i32 %180, %179
store i32 %181, i32* %177
%182 = load i32, i32* %36
%183 = xor i32 %182, %181
store i32 %183, i32* %36
%184 = icmp eq i32 %102, 7
br i1 %184, label %197, label %185
185: ; preds = %173
%186 = load i32, i32* %37
%187 = add i32 %97, -8
%188 = sext i32 %187 to i64
%189 = getelementptr inbounds [16 x i32], [16 x i32]* %1, i64 0, i64 %188
%190 = load i32, i32* %189
%191 = xor i32 %186, %190
store i32 %191, i32* %38
%192 = load i32, i32* %189
%193 = xor i32 %192, %191
store i32 %193, i32* %189
%194 = load i32, i32* %38
%195 = xor i32 %194, %193
store i32 %195, i32* %38
%196 = icmp eq i32 %102, 8
br label %197
197: ; preds = %185, %173, %161, %149, %137, %125, %113, %100
%198 = add nsw i32 %61, 1
br label %201
199: ; preds = %60
%200 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([36 x i8], [36 x i8]* @.str.5, i64 0, i64 0), i32 %97)
br label %201
201: ; preds = %199, %197
%202 = phi i32 [ %198, %197 ], [ %61, %199 ]
%203 = load i32, i32* %23
%204 = load i32, i32* %22
%205 = icmp sgt i32 %203, %204
br i1 %205, label %209, label %251
206: ; preds = %245
%207 = load i32, i32* %2
%208 = icmp eq i32 %207, 0
br i1 %208, label %295, label %254
209: ; preds = %201
%210 = load i32, i32* %21
%211 = icmp sgt i32 %204, %210
br i1 %211, label %212, label %251
212: ; preds = %209
%213 = load i32, i32* %20
%214 = icmp sgt i32 %210, %213
br i1 %214, label %215, label %251
215: ; preds = %212
%216 = load i32, i32* %19
%217 = icmp sgt i32 %213, %216
br i1 %217, label %218, label %251
218: ; preds = %215
%219 = load i32, i32* %18
%220 = icmp sgt i32 %216, %219
br i1 %220, label %221, label %251
221: ; preds = %218
%222 = load i32, i32* %17
%223 = icmp sgt i32 %219, %222
br i1 %223, label %224, label %251
224: ; preds = %221
%225 = load i32, i32* %16
%226 = icmp sgt i32 %222, %225
br i1 %226, label %227, label %251
227: ; preds = %224
%228 = load i32, i32* %15
%229 = icmp sgt i32 %225, %228
br i1 %229, label %230, label %251
230: ; preds = %227
%231 = load i32, i32* %14
%232 = icmp sgt i32 %228, %231
br i1 %232, label %233, label %251
233: ; preds = %230
%234 = load i32, i32* %13
%235 = icmp sgt i32 %231, %234
br i1 %235, label %236, label %251
236: ; preds = %233
%237 = load i32, i32* %12
%238 = icmp sgt i32 %234, %237
br i1 %238, label %239, label %251
239: ; preds = %236
%240 = load i32, i32* %11
%241 = icmp sgt i32 %237, %240
br i1 %241, label %242, label %251
242: ; preds = %239
%243 = load i32, i32* %10
%244 = icmp sgt i32 %240, %243
br i1 %244, label %245, label %251
245: ; preds = %242
%246 = load i32, i32* %9
%247 = icmp sgt i32 %243, %246
%248 = load i32, i32* %8
%249 = icmp sgt i32 %246, %248
%250 = select i1 %247, i1 %249, i1 false
br i1 %250, label %206, label %251
251: ; preds = %245, %242, %239, %236, %233, %230, %227, %224, %221, %218, %215, %212, %209, %201
%252 = load i32, i32* %2
%253 = icmp eq i32 %252, 0
br i1 %253, label %295, label %60
254: ; preds = %206
%255 = call i32 @putchar(i8 signext 9)
%256 = load i32, i32* %8
%257 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0), i32 %256)
%258 = load i32, i32* %9
%259 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0), i32 %258)
%260 = load i32, i32* %10
%261 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0), i32 %260)
%262 = load i32, i32* %11
%263 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0), i32 %262)
%264 = load i32, i32* %12
%265 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0), i32 %264)
%266 = load i32, i32* %13
%267 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0), i32 %266)
%268 = load i32, i32* %14
%269 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0), i32 %268)
%270 = load i32, i32* %15
%271 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0), i32 %270)
%272 = load i32, i32* %16
%273 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0), i32 %272)
%274 = load i32, i32* %17
%275 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0), i32 %274)
%276 = load i32, i32* %18
%277 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0), i32 %276)
%278 = load i32, i32* %19
%279 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0), i32 %278)
%280 = load i32, i32* %20
%281 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0), i32 %280)
%282 = load i32, i32* %21
%283 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0), i32 %282)
%284 = load i32, i32* %22
%285 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0), i32 %284)
%286 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0), i32 %203)
%287 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([37 x i8], [37 x i8]* @.str.6, i64 0, i64 0), i32 %202)
%288 = icmp sgt i32 %202, 29
br i1 %288, label %289, label %291
289: ; preds = %254
%290 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([49 x i8], [49 x i8]* @.str.7, i64 0, i64 0), i32 29)
br label %295
291: ; preds = %254
%292 = icmp slt i32 %202, 17
br i1 %292, label %293, label %295
293: ; preds = %291
%294 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([56 x i8], [56 x i8]* @.str.8, i64 0, i64 0))
br label %295
295: ; preds = %251, %289, %206, %291, %293
%296 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([41 x i8], [41 x i8]* @.str.9, i64 0, i64 0))
br label %297
297: ; preds = %297, %295
%298 = call signext i8 (...) @getchar()
%299 = call i32 @isalpha(i8 signext %298)
%300 = icmp eq i32 %299, 0
br i1 %300, label %297, label %301
301: ; preds = %297
%302 = icmp eq i8 %298, 121
br i1 %302, label %55, label %303
303: ; preds = %301
%304 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([23 x i8], [23 x i8]* @.str.10, i64 0, i64 0))
%305 = call i32 @exit(i32 0)
unreachable
}