#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 */
float log(double);
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ scanf(char *, char *);
int strlen(char *);
char tolower(char);
int main() {
  char s[256];
  char inv[256];
  char freq[26];
  int i, len, pangram;
  float H, p;
  scanf("%[^\n]s", s);
  len = strlen(s);
  inv[len] = '\0';
  for (i = 0; i < len; i++) {
    inv[i] = s[len - i - 1];
  }
  printf("%s\n", inv);
  for (i = 0; i < 26; i++)
    freq[i] = 0;
  for (i = 0; i < len; i++) {
    freq[tolower(s[i]) - 'a']++;
  }
  pangram = 1;
  for (i = 0; i < 26; i++) {
    if (!freq[i]) {
      pangram = 0;
      break;
    }
  }
  if (pangram)
    printf("É pangram\n");
  else
    printf("Não é pangram\n");
  H = 0.0;
  for (i = 0; i < 26; i++) {
    if (freq[i]) {
      p = freq[i] / (float)len;
      H -= p * log(p) / log(2.0);
    }
  }
  printf("%f\n", H);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x250,%rsp
movl   $0x0,-0x4(%rbp)
lea    -0x110(%rbp),%rsi
lea    0xe98(%rip),%rdi
call   1060 <scanf@plt>
lea    -0x110(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x238(%rbp)
movslq -0x238(%rbp),%rax
movb   $0x0,-0x210(%rbp,%rax,1)
movl   $0x0,-0x234(%rbp)
mov    -0x234(%rbp),%eax
cmp    -0x238(%rbp),%eax
jge    11ec <main+0x9c>
mov    -0x238(%rbp),%eax
sub    -0x234(%rbp),%eax
sub    $0x1,%eax
cltq
mov    -0x110(%rbp,%rax,1),%cl
movslq -0x234(%rbp),%rax
mov    %cl,-0x210(%rbp,%rax,1)
mov    -0x234(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x234(%rbp)
jmp    11a0 <main+0x50>
lea    -0x210(%rbp),%rsi
lea    0xe15(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x234(%rbp)
cmpl   $0x1a,-0x234(%rbp)
jge    123b <main+0xeb>
movslq -0x234(%rbp),%rax
movb   $0x0,-0x230(%rbp,%rax,1)
mov    -0x234(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x234(%rbp)
jmp    120b <main+0xbb>
movl   $0x0,-0x234(%rbp)
mov    -0x234(%rbp),%eax
cmp    -0x238(%rbp),%eax
jge    1298 <main+0x148>
movslq -0x234(%rbp),%rax
movsbl -0x110(%rbp,%rax,1),%edi
ff
call   1050 <tolower@plt>
movsbl %al,%eax
sub    $0x61,%eax
cltq
mov    -0x230(%rbp,%rax,1),%cl
add    $0x1,%cl
mov    %cl,-0x230(%rbp,%rax,1)
mov    -0x234(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x234(%rbp)
jmp    1245 <main+0xf5>
movl   $0x1,-0x23c(%rbp)
movl   $0x0,-0x234(%rbp)
cmpl   $0x1a,-0x234(%rbp)
jge    12f6 <main+0x1a6>
movslq -0x234(%rbp),%rax
cmpb   $0x0,-0x230(%rbp,%rax,1)
jne    12dd <main+0x18d>
movl   $0x0,-0x23c(%rbp)
jmp    12f6 <main+0x1a6>
jmp    12e2 <main+0x192>
mov    -0x234(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x234(%rbp)
jmp    12ac <main+0x15c>
cmpl   $0x0,-0x23c(%rbp)
je     1316 <main+0x1c6>
lea    0xd09(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1324 <main+0x1d4>
lea    0xd02(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x240(%rbp)
ff
movl   $0x0,-0x234(%rbp)
cmpl   $0x1a,-0x234(%rbp)
jge    1400 <main+0x2b0>
movslq -0x234(%rbp),%rax
cmpb   $0x0,-0x230(%rbp,%rax,1)
je     13e7 <main+0x297>
movslq -0x234(%rbp),%rax
movsbl -0x230(%rbp,%rax,1),%eax
ff
cvtsi2ss %eax,%xmm0
cvtsi2ssl -0x238(%rbp),%xmm1
ff
divss  %xmm1,%xmm0
movss  %xmm0,-0x244(%rbp)
ff
movss  -0x244(%rbp),%xmm0
ff
movss  %xmm0,-0x24c(%rbp)
ff
movss  -0x244(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
call   1070 <log@plt>
movaps %xmm0,%xmm1
movss  -0x24c(%rbp),%xmm0
ff
mulss  %xmm1,%xmm0
movss  %xmm0,-0x248(%rbp)
ff
movsd  0xc3e(%rip),%xmm0
call   1070 <log@plt>
movss  -0x248(%rbp),%xmm1
ff
divss  %xmm0,%xmm1
movss  -0x240(%rbp),%xmm0
ff
subss  %xmm1,%xmm0
movss  %xmm0,-0x240(%rbp)
ff
jmp    13ec <main+0x29c>
mov    -0x234(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x234(%rbp)
jmp    1339 <main+0x1e9>
movss  -0x240(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
lea    0xc1d(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
xor    %eax,%eax
add    $0x250,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x238,%rsp
lea    0xe93(%rip),%rdi
lea    0x130(%rsp),%rbx
mov    %rbx,%rsi
call   1070 <scanf@plt>
mov    %rbx,%rdi
call   1040 <strlen@plt>
mov    %eax,%r14d
cltq
movb   $0x0,0x30(%rsp,%rax,1)
test   %eax,%eax
jle    11ab <main+0x4b>
mov    %r14d,%r15d
cmp    $0x8,%r14d
jae    11ca <main+0x6a>
xor    %eax,%eax
jmp    12fa <main+0x19a>
lea    0x30(%rsp),%rdi
call   1030 <puts@plt>
pxor   %xmm0,%xmm0
movdqa %xmm0,0x10(%rsp)
movdqu %xmm0,0x1a(%rsp)
jmp    143f <main+0x2df>
lea    -0x1(%r15),%rdx
lea    -0x1(%r14),%ecx
mov    %ecx,%esi
sub    %edx,%esi
xor    %eax,%eax
cmp    %ecx,%esi
jg     12fa <main+0x19a>
shr    $0x20,%rdx
jne    12fa <main+0x19a>
cmp    $0x20,%r14d
jae    11f7 <main+0x97>
xor    %eax,%eax
jmp    12ac <main+0x14c>
mov    %r15d,%eax
and    $0xffffffe0,%eax
xor    %edx,%edx
pxor   %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movslq %ecx,%rcx
movdqu 0x111(%rsp,%rcx,1),%xmm1
movdqu 0x121(%rsp,%rcx,1),%xmm2
movdqa %xmm2,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
packuswb %xmm3,%xmm2
movdqa %xmm1,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm3,%xmm1
movdqa %xmm2,0x30(%rsp,%rdx,1)
movdqa %xmm1,0x40(%rsp,%rdx,1)
add    $0x20,%rdx
add    $0xffffffe0,%ecx
cmp    %rdx,%rax
jne    1210 <main+0xb0>
cmp    %r15,%rax
je     136c <main+0x20c>
test   $0x18,%r15b
je     12fa <main+0x19a>
mov    %rax,%rcx
mov    %r15d,%eax
and    $0xfffffff8,%eax
mov    %ecx,%edx
not    %edx
add    %r14d,%edx
pxor   %xmm0,%xmm0
movslq %edx,%rdx
movq   0x129(%rsp,%rdx,1),%xmm1
punpcklbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm1,%xmm1
movq   %xmm1,0x30(%rsp,%rcx,1)
add    $0x8,%rcx
add    $0xfffffff8,%edx
cmp    %rcx,%rax
jne    12c0 <main+0x160>
cmp    %r15,%rax
je     136c <main+0x20c>
mov    %rax,%rcx
not    %rcx
test   $0x1,%r15b
je     131f <main+0x1bf>
mov    %eax,%edx
not    %edx
add    %r14d,%edx
movslq %edx,%rdx
mov    0x130(%rsp,%rdx,1),%dl
mov    %dl,0x30(%rsp,%rax,1)
or     $0x1,%rax
add    %r15,%rcx
je     136c <main+0x20c>
mov    %r15,%rcx
sub    %rax,%rcx
mov    %eax,%edx
not    %edx
add    %r14d,%edx
lea    0x30(%rsp),%rsi
add    %rsi,%rax
add    $0x1,%rax
xor    %esi,%esi
nop
movslq %edx,%rdx
movzbl 0x130(%rsp,%rdx,1),%ebx
mov    %bl,-0x1(%rax,%rsi,1)
lea    -0x1(%rdx),%edi
movslq %edi,%rdi
movzbl 0x130(%rsp,%rdi,1),%ebx
mov    %bl,(%rax,%rsi,1)
add    $0x2,%rsi
add    $0xfffffffe,%edx
cmp    %rsi,%rcx
jne    1340 <main+0x1e0>
lea    0x30(%rsp),%rdi
call   1030 <puts@plt>
pxor   %xmm0,%xmm0
movdqa %xmm0,0x10(%rsp)
movdqu %xmm0,0x1a(%rsp)
test   %r14d,%r14d
jle    143f <main+0x2df>
xor    %ebx,%ebx
lea    0x10(%rsp),%r12
cs nopw 0x0(%rax,%rax,1)
movsbl 0x130(%rsp,%rbx,1),%edi
call   1060 <tolower@plt>
movsbq %al,%rax
addb   $0x1,-0x61(%rax,%r12,1)
add    $0x1,%rbx
cmp    %rbx,%r15
jne    13a0 <main+0x240>
pxor   %xmm0,%xmm0
movdqa 0x10(%rsp),%xmm1
pcmpeqb %xmm0,%xmm1
pmovmskb %xmm1,%eax
test   %eax,%eax
jne    143f <main+0x2df>
movq   0x20(%rsp),%xmm1
pcmpeqb %xmm0,%xmm1
pmovmskb %xmm1,%eax
test   $0x1,%al
jne    143f <main+0x2df>
mov    %eax,%ecx
and    $0x2,%cl
shr    %cl
jne    143f <main+0x2df>
mov    %eax,%ecx
and    $0x4,%cl
shr    $0x2,%cl
jne    143f <main+0x2df>
mov    %eax,%ecx
and    $0x8,%cl
shr    $0x3,%cl
jne    143f <main+0x2df>
mov    %eax,%ecx
and    $0x10,%cl
shr    $0x4,%cl
jne    143f <main+0x2df>
mov    %eax,%ecx
and    $0x20,%cl
shr    $0x5,%cl
jne    143f <main+0x2df>
mov    %eax,%ecx
and    $0x40,%cl
shr    $0x6,%cl
jne    143f <main+0x2df>
shr    $0x7,%al
jne    143f <main+0x2df>
cmpb   $0x0,0x28(%rsp)
je     143f <main+0x2df>
cmpb   $0x0,0x29(%rsp)
je     143f <main+0x2df>
lea    0xbe6(%rip),%rdi
jmp    1446 <main+0x2e6>
lea    0xbcd(%rip),%rdi
call   1030 <puts@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %r14d,%xmm0
movss  %xmm0,0x8(%rsp)
xorps  %xmm0,%xmm0
xor    %ebx,%ebx
jmp    146a <main+0x30a>
add    $0x1,%rbx
cmp    $0x1a,%rbx
je     14ca <main+0x36a>
movzbl 0x10(%rsp,%rbx,1),%eax
test   %al,%al
je     1460 <main+0x300>
movsbl %al,%eax
xorps  %xmm1,%xmm1
cvtsi2ss %eax,%xmm1
divss  0x8(%rsp),%xmm1
movss  %xmm1,0x4(%rsp)
movss  %xmm0,0xc(%rsp)
xorps  %xmm0,%xmm0
cvtss2sd %xmm1,%xmm0
call   1080 <log@plt>
mulss  0x4(%rsp),%xmm0
movss  %xmm0,0x4(%rsp)
movsd  0xb51(%rip),%xmm0
call   1080 <log@plt>
movss  0x4(%rsp),%xmm1
divss  %xmm0,%xmm1
movss  0xc(%rsp),%xmm0
subss  %xmm1,%xmm0
jmp    1460 <main+0x300>
cvtss2sd %xmm0,%xmm0
lea    0xb3a(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
xor    %eax,%eax
add    $0x238,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
@.str = [7 x i8] c"%[^\0A]s\00"
@.str.1 = [4 x i8] c"%s\0A\00"
@.str.2 = [12 x i8] c"\C3\89 pangram\0A\00"
@.str.3 = [17 x i8] c"N\C3\A3o \C3\A9 pangram\0A\00"
@.str.4 = [4 x i8] c"%f\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca [256 x i8]
%3 = alloca [256 x i8]
%4 = alloca [26 x i8]
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca float
%9 = alloca float
store i32 0, i32* %1
%10 = getelementptr inbounds [256 x i8], [256 x i8]* %2, i64 0, i64 0
%11 = call i32 @scanf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str, i64 0, i64 0), i8* %10)
%12 = getelementptr inbounds [256 x i8], [256 x i8]* %2, i64 0, i64 0
%13 = call i32 @strlen(i8* %12)
store i32 %13, i32* %6
%14 = load i32, i32* %6
%15 = sext i32 %14 to i64
%16 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 %15
store i8 0, i8* %16
store i32 0, i32* %5
br label %17
17: ; preds = %32, %0
%18 = load i32, i32* %5
%19 = load i32, i32* %6
%20 = icmp slt i32 %18, %19
br i1 %20, label %21, label %35
21: ; preds = %17
%22 = load i32, i32* %6
%23 = load i32, i32* %5
%24 = sub nsw i32 %22, %23
%25 = sub nsw i32 %24, 1
%26 = sext i32 %25 to i64
%27 = getelementptr inbounds [256 x i8], [256 x i8]* %2, i64 0, i64 %26
%28 = load i8, i8* %27
%29 = load i32, i32* %5
%30 = sext i32 %29 to i64
%31 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 %30
store i8 %28, i8* %31
br label %32
32: ; preds = %21
%33 = load i32, i32* %5
%34 = add nsw i32 %33, 1
store i32 %34, i32* %5
br label %17
35: ; preds = %17
%36 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 0
%37 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i8* %36)
store i32 0, i32* %5
br label %38
38: ; preds = %45, %35
%39 = load i32, i32* %5
%40 = icmp slt i32 %39, 26
br i1 %40, label %41, label %48
41: ; preds = %38
%42 = load i32, i32* %5
%43 = sext i32 %42 to i64
%44 = getelementptr inbounds [26 x i8], [26 x i8]* %4, i64 0, i64 %43
store i8 0, i8* %44
br label %45
45: ; preds = %41
%46 = load i32, i32* %5
%47 = add nsw i32 %46, 1
store i32 %47, i32* %5
br label %38
48: ; preds = %38
store i32 0, i32* %5
br label %49
49: ; preds = %65, %48
%50 = load i32, i32* %5
%51 = load i32, i32* %6
%52 = icmp slt i32 %50, %51
br i1 %52, label %53, label %68
53: ; preds = %49
%54 = load i32, i32* %5
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds [256 x i8], [256 x i8]* %2, i64 0, i64 %55
%57 = load i8, i8* %56
%58 = call signext i8 @tolower(i8 signext %57)
%59 = sext i8 %58 to i32
%60 = sub nsw i32 %59, 97
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds [26 x i8], [26 x i8]* %4, i64 0, i64 %61
%63 = load i8, i8* %62
%64 = add i8 %63, 1
store i8 %64, i8* %62
br label %65
65: ; preds = %53
%66 = load i32, i32* %5
%67 = add nsw i32 %66, 1
store i32 %67, i32* %5
br label %49
68: ; preds = %49
store i32 1, i32* %7
store i32 0, i32* %5
br label %69
69: ; preds = %80, %68
%70 = load i32, i32* %5
%71 = icmp slt i32 %70, 26
br i1 %71, label %72, label %83
72: ; preds = %69
%73 = load i32, i32* %5
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds [26 x i8], [26 x i8]* %4, i64 0, i64 %74
%76 = load i8, i8* %75
%77 = icmp ne i8 %76, 0
br i1 %77, label %79, label %78
78: ; preds = %72
store i32 0, i32* %7
br label %83
79: ; preds = %72
br label %80
80: ; preds = %79
%81 = load i32, i32* %5
%82 = add nsw i32 %81, 1
store i32 %82, i32* %5
br label %69
83: ; preds = %78, %69
%84 = load i32, i32* %7
%85 = icmp ne i32 %84, 0
br i1 %85, label %86, label %88
86: ; preds = %83
%87 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.2, i64 0, i64 0))
br label %90
88: ; preds = %83
%89 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.3, i64 0, i64 0))
br label %90
90: ; preds = %88, %86
store float 0.000000e+00, float* %8
store i32 0, i32* %5
br label %91
91: ; preds = %120, %90
%92 = load i32, i32* %5
%93 = icmp slt i32 %92, 26
br i1 %93, label %94, label %123
94: ; preds = %91
%95 = load i32, i32* %5
%96 = sext i32 %95 to i64
%97 = getelementptr inbounds [26 x i8], [26 x i8]* %4, i64 0, i64 %96
%98 = load i8, i8* %97
%99 = icmp ne i8 %98, 0
br i1 %99, label %100, label %119
100: ; preds = %94
%101 = load i32, i32* %5
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds [26 x i8], [26 x i8]* %4, i64 0, i64 %102
%104 = load i8, i8* %103
%105 = sext i8 %104 to i32
%106 = sitofp i32 %105 to float
%107 = load i32, i32* %6
%108 = sitofp i32 %107 to float
%109 = fdiv float %106, %108
store float %109, float* %9
%110 = load float, float* %9
%111 = load float, float* %9
%112 = fpext float %111 to double
%113 = call float @log(double %112)
%114 = fmul float %110, %113
%115 = call float @log(double 2.000000e+00)
%116 = fdiv float %114, %115
%117 = load float, float* %8
%118 = fsub float %117, %116
store float %118, float* %8
br label %119
119: ; preds = %100, %94
br label %120
120: ; preds = %119
%121 = load i32, i32* %5
%122 = add nsw i32 %121, 1
store i32 %122, i32* %5
br label %91
123: ; preds = %91
%124 = load float, float* %8
%125 = fpext float %124 to double
%126 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i64 0, i64 0), double %125)
ret i32 0
}

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