#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 /*<<< orphan*/ printf(char *, char);
int strlen(char *);
int main() {
  int i = 0;
  int j = 0;
  char word[100];
  gets(word);
  int hash[26] = {0};
  int even_count = 0;
  int odd_count = 0;
  int len = strlen(word);
  for (i = 0; i < len; i++) {
    if (word[i] != ' ') {
      hash[(int)word[i] - 97]++;
    }
  }
  for (i = 0; i < 26; i++) {
    if (hash[i] % 2 == 0 && hash[i] != 0) {
      even_count++;
    } else if (hash[i] == 0) {
    } else {
      odd_count++;
    }
  }
  printf("%d\n", even_count);
  printf("%d\n", odd_count);
  if (odd_count > 0)
    odd_count = 1;
  int tot = even_count + odd_count;
  char words[tot];
  int slider = 0;
  int flag = 0;
  for (i = 0; i < 26; i++) {
    char c = (char)i + 97;
    int occur = hash[i];
    if (occur % 2 == 0 && occur != 0) {
      for (j = slider; occur >= 0; j++) {
        words[j] = c;
        words[(tot - 1) - j] = c;
        occur--;
        slider++;
      }
    } else {
      if (flag == 0) {
        for (j = (((tot - 1) / 2) - occur / 2); occur >= 0; j++) {
          words[j] = c;
          occur--;
          flag = 1;
        }
      }
    }
  }
  for (i = 0; i < tot; i++) {
    printf("%c", words[i]);
  }
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x120,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x0,-0x8(%rbp)
movl   $0x0,-0xc(%rbp)
lea    -0x70(%rbp),%rdi
call   1060 <gets@plt>
lea    -0xe0(%rbp),%rdi
xor    %esi,%esi
mov    $0x68,%edx
call   1050 <memset@plt>
movl   $0x0,-0xe4(%rbp)
movl   $0x0,-0xe8(%rbp)
lea    -0x70(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0xec(%rbp)
movl   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0xec(%rbp),%eax
jge    11f9 <main+0xb9>
movslq -0x8(%rbp),%rax
movsbl -0x70(%rbp,%rax,1),%eax
cmp    $0x20,%eax
je     11e6 <main+0xa6>
movslq -0x8(%rbp),%rax
movsbl -0x70(%rbp,%rax,1),%eax
sub    $0x61,%eax
cltq
mov    -0xe0(%rbp,%rax,4),%ecx
add    $0x1,%ecx
mov    %ecx,-0xe0(%rbp,%rax,4)
jmp    11eb <main+0xab>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    11a6 <main+0x66>
movl   $0x0,-0x8(%rbp)
cmpl   $0x1a,-0x8(%rbp)
jge    128a <main+0x14a>
movslq -0x8(%rbp),%rax
mov    -0xe0(%rbp,%rax,4),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    124c <main+0x10c>
movslq -0x8(%rbp),%rax
cmpl   $0x0,-0xe0(%rbp,%rax,4)
je     124c <main+0x10c>
mov    -0xe4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe4(%rbp)
jmp    1277 <main+0x137>
movslq -0x8(%rbp),%rax
cmpl   $0x0,-0xe0(%rbp,%rax,4)
jne    1263 <main+0x123>
jmp    1272 <main+0x132>
mov    -0xe8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe8(%rbp)
jmp    1277 <main+0x137>
jmp    127c <main+0x13c>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1200 <main+0xc0>
mov    -0xe4(%rbp),%eax
lea    0xd69(%rip),%rdi
movsbl %al,%esi
call   1040 <printf@plt>
mov    -0xe8(%rbp),%eax
lea    0xd54(%rip),%rdi
movsbl %al,%esi
call   1040 <printf@plt>
cmpl   $0x0,-0xe8(%rbp)
jle    12cb <main+0x18b>
movl   $0x1,-0xe8(%rbp)
mov    -0xe4(%rbp),%eax
mov    -0xe8(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xf0(%rbp)
mov    -0xf0(%rbp),%eax
mov    %rsp,%rcx
mov    %rcx,-0xf8(%rbp)
mov    %rax,%rdx
add    $0xf,%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x118(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x100(%rbp)
movl   $0x0,-0x104(%rbp)
movl   $0x0,-0x108(%rbp)
movl   $0x0,-0x8(%rbp)
cmpl   $0x1a,-0x8(%rbp)
jge    1491 <main+0x351>
mov    -0x8(%rbp),%eax
movsbl %al,%eax
add    $0x61,%eax
mov    %al,-0x109(%rbp)
movslq -0x8(%rbp),%rax
mov    -0xe0(%rbp,%rax,4),%eax
mov    %eax,-0x110(%rbp)
mov    -0x110(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    13ed <main+0x2ad>
cmpl   $0x0,-0x110(%rbp)
je     13ed <main+0x2ad>
mov    -0x104(%rbp),%eax
mov    %eax,-0xc(%rbp)
cmpl   $0x0,-0x110(%rbp)
jl     13e8 <main+0x2a8>
mov    -0x118(%rbp),%rax
mov    -0x109(%rbp),%dl
movslq -0xc(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x109(%rbp),%dl
mov    -0xf0(%rbp),%ecx
sub    $0x1,%ecx
sub    -0xc(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x110(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x110(%rbp)
mov    -0x104(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x104(%rbp)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1383 <main+0x243>
jmp    147e <main+0x33e>
cmpl   $0x0,-0x108(%rbp)
jne    1479 <main+0x339>
mov    -0xf0(%rbp),%eax
sub    $0x1,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x11c(%rbp)
mov    -0x110(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x11c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xc(%rbp)
cmpl   $0x0,-0x110(%rbp)
jl     1474 <main+0x334>
mov    -0x118(%rbp),%rax
mov    -0x109(%rbp),%dl
movslq -0xc(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x110(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x110(%rbp)
movl   $0x1,-0x108(%rbp)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    142c <main+0x2ec>
jmp    1479 <main+0x339>
jmp    147e <main+0x33e>
jmp    1483 <main+0x343>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    132c <main+0x1ec>
movl   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0xf0(%rbp),%eax
jge    14d0 <main+0x390>
mov    -0x118(%rbp),%rax
movslq -0x8(%rbp),%rcx
lea    0xb4b(%rip),%rdi
movsbl (%rax,%rcx,1),%esi
call   1040 <printf@plt>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1498 <main+0x358>
mov    -0xf8(%rbp),%rax
mov    %rax,%rsp
mov    -0x4(%rbp),%eax
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xf8,%rsp
lea    -0x120(%rbp),%rbx
mov    %rbx,%rdi
call   1060 <gets@plt>
xorps  %xmm0,%xmm0
movaps %xmm0,-0x60(%rbp)
movaps %xmm0,-0x70(%rbp)
movaps %xmm0,-0x80(%rbp)
movaps %xmm0,-0x90(%rbp)
movaps %xmm0,-0xa0(%rbp)
movaps %xmm0,-0xb0(%rbp)
movq   $0x0,-0x50(%rbp)
mov    %rbx,%rdi
call   1030 <strlen@plt>
test   %eax,%eax
jle    11c4 <main+0x84>
mov    %eax,%ecx
cmp    $0x1,%eax
jne    151b <main+0x3db>
xor    %eax,%eax
test   $0x1,%cl
je     11c4 <main+0x84>
movsbq -0x120(%rbp,%rax,1),%rax
ff ff
cmp    $0x20,%rax
je     11c4 <main+0x84>
addl   $0x1,-0x234(%rbp,%rax,4)
01
movdqa -0xb0(%rbp),%xmm13
ff ff
movdqa -0xa0(%rbp),%xmm12
ff ff
movdqa -0x90(%rbp),%xmm11
ff ff
movdqa -0x80(%rbp),%xmm9
movdqa %xmm13,%xmm7
pxor   %xmm1,%xmm1
pcmpeqd %xmm1,%xmm7
movdqa %xmm12,%xmm5
pcmpeqd %xmm1,%xmm5
movdqa %xmm11,%xmm6
pcmpeqd %xmm1,%xmm6
movdqa %xmm9,%xmm4
pcmpeqd %xmm1,%xmm4
movdqa -0x70(%rbp),%xmm10
movdqa %xmm10,%xmm15
pcmpeqd %xmm1,%xmm15
movdqa -0x60(%rbp),%xmm8
pcmpeqd %xmm8,%xmm1
movdqa %xmm7,%xmm3
por    %xmm13,%xmm3
movdqa 0xdc6(%rip),%xmm14
pandn  %xmm14,%xmm3
movdqa %xmm5,%xmm2
por    %xmm12,%xmm2
pandn  %xmm14,%xmm2
paddd  %xmm3,%xmm2
movdqa %xmm6,%xmm3
por    %xmm11,%xmm3
pandn  %xmm14,%xmm3
movdqa %xmm4,%xmm0
por    %xmm9,%xmm0
pandn  %xmm14,%xmm0
paddd  %xmm3,%xmm0
paddd  %xmm2,%xmm0
movdqa %xmm15,%xmm2
por    %xmm10,%xmm2
pandn  %xmm14,%xmm2
movdqa %xmm1,%xmm3
por    %xmm8,%xmm3
pandn  %xmm14,%xmm3
paddd  %xmm2,%xmm3
paddd  %xmm0,%xmm3
pshufd $0xee,%xmm3,%xmm0
paddd  %xmm3,%xmm0
pshufd $0x55,%xmm0,%xmm2
paddd  %xmm0,%xmm2
movd   %xmm2,%esi
mov    %rsi,-0x30(%rbp)
pandn  %xmm13,%xmm7
pand   %xmm14,%xmm7
pandn  %xmm12,%xmm5
pand   %xmm14,%xmm5
paddd  %xmm7,%xmm5
pandn  %xmm11,%xmm6
pand   %xmm14,%xmm6
pandn  %xmm9,%xmm4
pand   %xmm14,%xmm4
paddd  %xmm6,%xmm4
paddd  %xmm5,%xmm4
pandn  %xmm10,%xmm15
pand   %xmm14,%xmm15
pandn  %xmm8,%xmm1
pand   %xmm14,%xmm1
paddd  %xmm15,%xmm1
paddd  %xmm4,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%eax
mov    -0x50(%rbp),%ecx
test   %ecx,%ecx
setne  %dl
sete   %bl
or     %cl,%bl
and    %cl,%dl
movzbl %dl,%ecx
add    %eax,%ecx
not    %bl
movzbl %bl,%r12d
and    $0x1,%r12d
lea    (%rsi,%r12,1),%r14d
mov    -0x4c(%rbp),%eax
test   %eax,%eax
setne  %dl
sete   %bl
or     %al,%bl
and    %al,%dl
movzbl %dl,%r15d
add    %ecx,%r15d
not    %bl
movzbl %bl,%r13d
and    $0x1,%r13d
add    %r13d,%r14d
movsbl %r14b,%esi
lea    0xca5(%rip),%rbx
mov    %rbx,%rdi
call   1040 <printf@plt>
movsbl %r15b,%esi
mov    %rbx,%rdi
call   1040 <printf@plt>
mov    %rsp,-0x48(%rbp)
xor    %eax,%eax
test   %r15d,%r15d
setne  %al
lea    (%r14,%rax,1),%edi
lea    0xf(%rdi),%rcx
and    $0xfffffffffffffff0,%rcx
mov    %rsp,%rdx
mov    %rdx,%r15
sub    %rcx,%r15
mov    %r15,%rsp
lea    (%rax,%r14,1),%esi
add    $0xffffffff,%esi
shr    $0x1f,%esi
mov    %rdi,-0x40(%rbp)
add    %edi,%esi
add    $0xffffffff,%esi
sar    %esi
mov    %esi,-0x34(%rbp)
neg    %rcx
lea    (%rdx,%rcx,1),%r11
add    $0x1,%r11
mov    -0x30(%rbp),%rcx
add    %eax,%ecx
add    %r12d,%ecx
lea    (%rcx,%r13,1),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
xor    %r12d,%r12d
xor    %r9d,%r9d
xor    %r13d,%r13d
jmp    1404 <main+0x2c4>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r9d,%r14d
add    $0x1,%r12
mov    %r14d,%r9d
cmp    $0x1a,%r12
je     14d3 <main+0x393>
lea    0x61(%r12),%ecx
mov    -0xb0(%rbp,%r12,4),%edx
ff
test   %rdx,%rdx
je     1450 <main+0x310>
mov    %edx,%eax
and    $0x1,%eax
jne    1450 <main+0x310>
test   %edx,%edx
js     13f0 <main+0x2b0>
movslq %r13d,%r8
test   $0x1,%dl
jne    1485 <main+0x345>
mov    %cl,(%r15,%r8,1)
mov    %r8d,%eax
not    %eax
add    -0x40(%rbp),%eax
cltq
mov    %cl,(%r15,%rax,1)
lea    -0x1(%rdx),%r10d
add    $0x1,%r8
jmp    1488 <main+0x348>
cs nopw 0x0(%rax,%rax,1)
nop
mov    $0x1,%r14d
test   %r9d,%r9d
jne    13f3 <main+0x2b3>
test   %edx,%edx
js     14cb <main+0x38b>
mov    %edx,%eax
shr    %eax
mov    -0x34(%rbp),%esi
sub    %eax,%esi
movslq %esi,%rdi
add    %r15,%rdi
add    $0x1,%rdx
movzbl %cl,%esi
mov    %r11,%rbx
call   1050 <memset@plt>
mov    %rbx,%r11
jmp    13f3 <main+0x2b3>
mov    %edx,%r10d
add    $0x1,%r13d
lea    (%r11,%r8,1),%rdi
mov    -0x30(%rbp),%eax
sub    %r8d,%eax
add    $0x1,%r10d
xor    %ebx,%ebx
nopl   0x0(%rax)
mov    %cl,-0x1(%rdi,%rbx,1)
cltq
mov    %cl,(%r15,%rax,1)
mov    %cl,(%rdi,%rbx,1)
lea    -0x1(%rax),%esi
movslq %esi,%rsi
mov    %cl,(%r15,%rsi,1)
add    $0x2,%rbx
add    $0xfffffffe,%eax
cmp    %ebx,%r10d
jne    14a0 <main+0x360>
add    %edx,%r13d
jmp    13f0 <main+0x2b0>
xor    %r14d,%r14d
jmp    13f3 <main+0x2b3>
mov    -0x40(%rbp),%r14
test   %r14,%r14
je     1506 <main+0x3c6>
xor    %ebx,%ebx
lea    0xb2f(%rip),%r12
cs nopw 0x0(%rax,%rax,1)
nop
movsbl (%r15,%rbx,1),%esi
mov    %r12,%rdi
call   1040 <printf@plt>
add    $0x1,%rbx
cmp    %rbx,%r14
jne    14f0 <main+0x3b0>
mov    -0x48(%rbp),%rsp
xor    %eax,%eax
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %ecx,%edx
and    $0xfffffffe,%edx
xor    %eax,%eax
jmp    153d <main+0x3fd>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x2,%rax
cmp    %rax,%rdx
je     11a8 <main+0x68>
movsbq -0x120(%rbp,%rax,1),%rsi
ff ff
cmp    $0x20,%rsi
je     1554 <main+0x414>
addl   $0x1,-0x234(%rbp,%rsi,4)
01
movsbq -0x11f(%rbp,%rax,1),%rsi
ff ff
cmp    $0x20,%rsi
je     1530 <main+0x3f0>
addl   $0x1,-0x234(%rbp,%rsi,4)
01
jmp    1530 <main+0x3f0>

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

LLVM IR (-O2):
@.str = [4 x i8] c"%d\0A\00"
@.str.1 = [3 x i8] c"%c\00"
define i32 @main() {
%1 = alloca [100 x i8]
%2 = alloca [26 x i32]
%3 = getelementptr inbounds [100 x i8], [100 x i8]* %1, i64 0, i64 0
%4 = call i32 @gets(i8* %3)
%5 = bitcast [26 x i32]* %2 to i8*
%6 = call i32 @strlen(i8* %3)
%7 = icmp sgt i32 %6, 0
br i1 %7, label %8, label %54
8: ; preds = %0
%9 = zext i32 %6 to i64
%10 = and i64 %9, 1
%11 = icmp eq i32 %6, 1
br i1 %11, label %41, label %12
12: ; preds = %8
%13 = and i64 %9, 4294967294
br label %14
14: ; preds = %37, %12
%15 = phi i64 [ 0, %12 ], [ %38, %37 ]
%16 = phi i64 [ 0, %12 ], [ %39, %37 ]
%17 = getelementptr inbounds [100 x i8], [100 x i8]* %1, i64 0, i64 %15
%18 = load i8, i8* %17
%19 = icmp eq i8 %18, 32
br i1 %19, label %26, label %20
20: ; preds = %14
%21 = sext i8 %18 to i64
%22 = add nsw i64 %21, -97
%23 = getelementptr inbounds [26 x i32], [26 x i32]* %2, i64 0, i64 %22
%24 = load i32, i32* %23
%25 = add nsw i32 %24, 1
store i32 %25, i32* %23
br label %26
26: ; preds = %14, %20
%27 = or i64 %15, 1
%28 = getelementptr inbounds [100 x i8], [100 x i8]* %1, i64 0, i64 %27
%29 = load i8, i8* %28
%30 = icmp eq i8 %29, 32
br i1 %30, label %37, label %31
31: ; preds = %26
%32 = sext i8 %29 to i64
%33 = add nsw i64 %32, -97
%34 = getelementptr inbounds [26 x i32], [26 x i32]* %2, i64 0, i64 %33
%35 = load i32, i32* %34
%36 = add nsw i32 %35, 1
store i32 %36, i32* %34
br label %37
37: ; preds = %31, %26
%38 = add nuw nsw i64 %15, 2
%39 = add i64 %16, 2
%40 = icmp eq i64 %39, %13
br i1 %40, label %41, label %14
41: ; preds = %37, %8
%42 = phi i64 [ 0, %8 ], [ %38, %37 ]
%43 = icmp eq i64 %10, 0
br i1 %43, label %54, label %44
44: ; preds = %41
%45 = getelementptr inbounds [100 x i8], [100 x i8]* %1, i64 0, i64 %42
%46 = load i8, i8* %45
%47 = icmp eq i8 %46, 32
br i1 %47, label %54, label %48
48: ; preds = %44
%49 = sext i8 %46 to i64
%50 = add nsw i64 %49, -97
%51 = getelementptr inbounds [26 x i32], [26 x i32]* %2, i64 0, i64 %50
%52 = load i32, i32* %51
%53 = add nsw i32 %52, 1
store i32 %53, i32* %51
br label %54
54: ; preds = %41, %48, %44, %0
%55 = bitcast [26 x i32]* %2 to <4 x i32>*
%56 = load <4 x i32>, <4 x i32>* %55
%57 = trunc <4 x i32> %56 to <4 x i1>
%58 = icmp eq <4 x i32> %56, zeroinitializer
%59 = getelementptr inbounds [26 x i32], [26 x i32]* %2, i64 0, i64 4
%60 = bitcast i32* %59 to <4 x i32>*
%61 = load <4 x i32>, <4 x i32>* %60
%62 = trunc <4 x i32> %61 to <4 x i1>
%63 = icmp eq <4 x i32> %61, zeroinitializer
%64 = getelementptr inbounds [26 x i32], [26 x i32]* %2, i64 0, i64 8
%65 = bitcast i32* %64 to <4 x i32>*
%66 = load <4 x i32>, <4 x i32>* %65
%67 = trunc <4 x i32> %66 to <4 x i1>
%68 = icmp eq <4 x i32> %66, zeroinitializer
%69 = getelementptr inbounds [26 x i32], [26 x i32]* %2, i64 0, i64 12
%70 = bitcast i32* %69 to <4 x i32>*
%71 = load <4 x i32>, <4 x i32>* %70
%72 = trunc <4 x i32> %71 to <4 x i1>
%73 = icmp eq <4 x i32> %71, zeroinitializer
%74 = getelementptr inbounds [26 x i32], [26 x i32]* %2, i64 0, i64 16
%75 = bitcast i32* %74 to <4 x i32>*
%76 = load <4 x i32>, <4 x i32>* %75
%77 = trunc <4 x i32> %76 to <4 x i1>
%78 = icmp eq <4 x i32> %76, zeroinitializer
%79 = getelementptr inbounds [26 x i32], [26 x i32]* %2, i64 0, i64 20
%80 = bitcast i32* %79 to <4 x i32>*
%81 = load <4 x i32>, <4 x i32>* %80
%82 = trunc <4 x i32> %81 to <4 x i1>
%83 = icmp eq <4 x i32> %81, zeroinitializer
%84 = or <4 x i1> %58, %57
%85 = xor <4 x i1> %84, <i1 true, i1 true, i1 true, i1 true>
%86 = zext <4 x i1> %85 to <4 x i32>
%87 = or <4 x i1> %63, %62
%88 = xor <4 x i1> %87, <i1 true, i1 true, i1 true, i1 true>
%89 = zext <4 x i1> %88 to <4 x i32>
%90 = add nuw nsw <4 x i32> %86, %89
%91 = or <4 x i1> %68, %67
%92 = xor <4 x i1> %91, <i1 true, i1 true, i1 true, i1 true>
%93 = zext <4 x i1> %92 to <4 x i32>
%94 = add nuw nsw <4 x i32> %90, %93
%95 = or <4 x i1> %73, %72
%96 = xor <4 x i1> %95, <i1 true, i1 true, i1 true, i1 true>
%97 = zext <4 x i1> %96 to <4 x i32>
%98 = add nuw nsw <4 x i32> %94, %97
%99 = or <4 x i1> %78, %77
%100 = xor <4 x i1> %99, <i1 true, i1 true, i1 true, i1 true>
%101 = zext <4 x i1> %100 to <4 x i32>
%102 = add nuw nsw <4 x i32> %98, %101
%103 = or <4 x i1> %83, %82
%104 = xor <4 x i1> %103, <i1 true, i1 true, i1 true, i1 true>
%105 = zext <4 x i1> %104 to <4 x i32>
%106 = add nuw nsw <4 x i32> %102, %105
%107 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %106)
%108 = xor <4 x i1> %58, <i1 true, i1 true, i1 true, i1 true>
%109 = and <4 x i1> %57, %108
%110 = zext <4 x i1> %109 to <4 x i32>
%111 = xor <4 x i1> %63, <i1 true, i1 true, i1 true, i1 true>
%112 = and <4 x i1> %62, %111
%113 = zext <4 x i1> %112 to <4 x i32>
%114 = add nuw nsw <4 x i32> %110, %113
%115 = xor <4 x i1> %68, <i1 true, i1 true, i1 true, i1 true>
%116 = and <4 x i1> %67, %115
%117 = zext <4 x i1> %116 to <4 x i32>
%118 = add nuw nsw <4 x i32> %114, %117
%119 = xor <4 x i1> %73, <i1 true, i1 true, i1 true, i1 true>
%120 = and <4 x i1> %72, %119
%121 = zext <4 x i1> %120 to <4 x i32>
%122 = add nuw nsw <4 x i32> %118, %121
%123 = xor <4 x i1> %78, <i1 true, i1 true, i1 true, i1 true>
%124 = and <4 x i1> %77, %123
%125 = zext <4 x i1> %124 to <4 x i32>
%126 = add nuw nsw <4 x i32> %122, %125
%127 = xor <4 x i1> %83, <i1 true, i1 true, i1 true, i1 true>
%128 = and <4 x i1> %82, %127
%129 = zext <4 x i1> %128 to <4 x i32>
%130 = add nuw nsw <4 x i32> %126, %129
%131 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %130)
%132 = getelementptr inbounds [26 x i32], [26 x i32]* %2, i64 0, i64 24
%133 = load i32, i32* %132
%134 = and i32 %133, 1
%135 = icmp ne i32 %134, 0
%136 = icmp eq i32 %133, 0
%137 = or i1 %136, %135
%138 = xor i1 %136, true
%139 = and i1 %135, %138
%140 = zext i1 %139 to i32
%141 = add nuw nsw i32 %131, %140
%142 = xor i1 %137, true
%143 = zext i1 %142 to i32
%144 = add nuw nsw i32 %107, %143
%145 = getelementptr inbounds [26 x i32], [26 x i32]* %2, i64 0, i64 25
%146 = load i32, i32* %145
%147 = and i32 %146, 1
%148 = icmp ne i32 %147, 0
%149 = icmp eq i32 %146, 0
%150 = or i1 %149, %148
%151 = xor i1 %149, true
%152 = and i1 %148, %151
%153 = zext i1 %152 to i32
%154 = add nuw nsw i32 %141, %153
%155 = xor i1 %150, true
%156 = zext i1 %155 to i32
%157 = add nuw nsw i32 %144, %156
%158 = trunc i32 %157 to i8
%159 = call i32 @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i8 signext %158)
%160 = trunc i32 %154 to i8
%161 = call i32 @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i8 signext %160)
%162 = icmp ne i32 %154, 0
%163 = zext i1 %162 to i32
%164 = add nuw i32 %157, %163
%165 = zext i32 %164 to i64
%166 = call i8* @llvm.stacksave()
%167 = alloca i8, i64 %165
%168 = add nsw i32 %164, -1
%169 = sdiv i32 %168, 2
br label %172
170: ; preds = %234
%171 = icmp eq i32 %164, 0
br i1 %171, label %246, label %239
172: ; preds = %54, %234
%173 = phi i64 [ 0, %54 ], [ %237, %234 ]
%174 = phi i32 [ 0, %54 ], [ %236, %234 ]
%175 = phi i32 [ 0, %54 ], [ %235, %234 ]
%176 = trunc i64 %173 to i8
%177 = add nuw nsw i8 %176, 97
%178 = getelementptr inbounds [26 x i32], [26 x i32]* %2, i64 0, i64 %173
%179 = load i32, i32* %178
%180 = and i32 %179, 1
%181 = icmp eq i32 %180, 0
%182 = icmp ne i32 %179, 0
%183 = and i1 %182, %181
br i1 %183, label %184, label %221
184: ; preds = %172
%185 = icmp sgt i32 %179, -1
br i1 %185, label %186, label %234
186: ; preds = %184
%187 = sext i32 %175 to i64
%188 = add i32 %175, 1
%189 = and i32 %179, 1
%190 = icmp eq i32 %189, 0
br i1 %190, label %191, label %199
191: ; preds = %186
%192 = getelementptr inbounds i8, i8* %167, i64 %187
store i8 %177, i8* %192
%193 = xor i32 %175, -1
%194 = add i32 %164, %193
%195 = sext i32 %194 to i64
%196 = getelementptr inbounds i8, i8* %167, i64 %195
store i8 %177, i8* %196
%197 = add nsw i32 %179, -1
%198 = add nsw i64 %187, 1
br label %199
199: ; preds = %186, %191
%200 = phi i64 [ %187, %186 ], [ %198, %191 ]
%201 = phi i32 [ %179, %186 ], [ %197, %191 ]
br label %202
202: ; preds = %202, %199
%203 = phi i64 [ %200, %199 ], [ %219, %202 ]
%204 = phi i32 [ %201, %199 ], [ %218, %202 ]
%205 = getelementptr inbounds i8, i8* %167, i64 %203
store i8 %177, i8* %205
%206 = trunc i64 %203 to i32
%207 = xor i32 %206, -1
%208 = add i32 %164, %207
%209 = sext i32 %208 to i64
%210 = getelementptr inbounds i8, i8* %167, i64 %209
store i8 %177, i8* %210
%211 = add nsw i64 %203, 1
%212 = getelementptr inbounds i8, i8* %167, i64 %211
store i8 %177, i8* %212
%213 = trunc i64 %211 to i32
%214 = xor i32 %213, -1
%215 = add i32 %164, %214
%216 = sext i32 %215 to i64
%217 = getelementptr inbounds i8, i8* %167, i64 %216
store i8 %177, i8* %217
%218 = add nsw i32 %204, -2
%219 = add nsw i64 %203, 2
%220 = icmp eq i32 %204, 1
br i1 %220, label %232, label %202
221: ; preds = %172
%222 = icmp eq i32 %174, 0
br i1 %222, label %223, label %234
223: ; preds = %221
%224 = icmp sgt i32 %179, -1
br i1 %224, label %225, label %234
225: ; preds = %223
%226 = lshr i32 %179, 1
%227 = sub i32 %169, %226
%228 = sext i32 %227 to i64
%229 = getelementptr i8, i8* %167, i64 %228
%230 = add nuw i32 %179, 1
%231 = zext i32 %230 to i64
br label %234
232: ; preds = %202
%233 = add i32 %188, %179
br label %234
234: ; preds = %225, %232, %223, %184, %221
%235 = phi i32 [ %175, %221 ], [ %175, %184 ], [ %175, %223 ], [ %233, %232 ], [ %175, %225 ]
%236 = phi i32 [ 1, %221 ], [ %174, %184 ], [ 0, %223 ], [ %174, %232 ], [ 1, %225 ]
%237 = add nuw nsw i64 %173, 1
%238 = icmp eq i64 %237, 26
br i1 %238, label %170, label %172
239: ; preds = %170, %239
%240 = phi i64 [ %244, %239 ], [ 0, %170 ]
%241 = getelementptr inbounds i8, i8* %167, i64 %240
%242 = load i8, i8* %241
%243 = call i32 @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i8 signext %242)
%244 = add nuw nsw i64 %240, 1
%245 = icmp eq i64 %244, %165
br i1 %245, label %246, label %239
246: ; preds = %239, %170
ret i32 0
}