#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*/ printf(char *, char, int);
int strlen(char *);
int create_letter_distribution_diagram(char txt[100]) {
  int counter = 0, lenght, word[26], help;
  char let[26];
  while (counter <= 25) {
    word[counter] = 0;
    let[counter] = 'a' + counter;
    counter++;
  }
  counter = 0;
  lenght = strlen(txt);
  while (counter != lenght) {
    if (txt[counter] >= 'a' && txt[counter] <= 'z')
      word[txt[counter] - 'a']++;
    if (txt[counter] >= 'A' && txt[counter] <= 'Z')
      word[txt[counter] - 'A']++;
    counter++;
  }
  counter = 0;
  lenght = 25;
  while (lenght != 0) {
    while (counter != 25) {
      if (word[counter] < word[counter + 1]) {
        help = word[counter];
        word[counter] = word[counter + 1];
        word[counter + 1] = help;
        help = let[counter];
        let[counter] = let[counter + 1];
        let[counter + 1] = help;
      }
      counter++;
    }
    counter = 0;
    lenght--;
  }
  while (counter <= 25) {
    printf("\n%c - %d", let[counter], word[counter]);
    counter++;
  }
}


x86 assembly (clang, -O0):
<create_letter_distribution_diagram>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    %rdi,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
cmpl   $0x19,-0x14(%rbp)
jg     116d <create_letter_distribution_diagram+0x4d>
movslq -0x14(%rbp),%rax
movl   $0x0,-0x80(%rbp,%rax,4)
mov    -0x14(%rbp),%eax
add    $0x61,%eax
mov    %al,%cl
movslq -0x14(%rbp),%rax
mov    %cl,-0xa0(%rbp,%rax,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1136 <create_letter_distribution_diagram+0x16>
movl   $0x0,-0x14(%rbp)
mov    -0x10(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x18(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x18(%rbp),%eax
je     1226 <create_letter_distribution_diagram+0x106>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x61,%eax
jl     11d2 <create_letter_distribution_diagram+0xb2>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x7a,%eax
jg     11d2 <create_letter_distribution_diagram+0xb2>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
sub    $0x61,%eax
cltq
mov    -0x80(%rbp,%rax,4),%ecx
add    $0x1,%ecx
mov    %ecx,-0x80(%rbp,%rax,4)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x41,%eax
jl     1218 <create_letter_distribution_diagram+0xf8>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x5a,%eax
jg     1218 <create_letter_distribution_diagram+0xf8>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
sub    $0x41,%eax
cltq
mov    -0x80(%rbp,%rax,4),%ecx
add    $0x1,%ecx
mov    %ecx,-0x80(%rbp,%rax,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1180 <create_letter_distribution_diagram+0x60>
movl   $0x0,-0x14(%rbp)
movl   $0x19,-0x18(%rbp)
cmpl   $0x0,-0x18(%rbp)
je     1302 <create_letter_distribution_diagram+0x1e2>
jmp    1243 <create_letter_distribution_diagram+0x123>
cmpl   $0x19,-0x14(%rbp)
je     12ed <create_letter_distribution_diagram+0x1cd>
movslq -0x14(%rbp),%rax
mov    -0x80(%rbp,%rax,4),%eax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
cmp    -0x80(%rbp,%rcx,4),%eax
jge    12df <create_letter_distribution_diagram+0x1bf>
movslq -0x14(%rbp),%rax
mov    -0x80(%rbp,%rax,4),%eax
mov    %eax,-0x84(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
cltq
mov    -0x80(%rbp,%rax,4),%ecx
movslq -0x14(%rbp),%rax
mov    %ecx,-0x80(%rbp,%rax,4)
mov    -0x84(%rbp),%ecx
mov    -0x14(%rbp),%eax
add    $0x1,%eax
cltq
mov    %ecx,-0x80(%rbp,%rax,4)
movslq -0x14(%rbp),%rax
movsbl -0xa0(%rbp,%rax,1),%eax
ff
mov    %eax,-0x84(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
cltq
mov    -0xa0(%rbp,%rax,1),%cl
movslq -0x14(%rbp),%rax
mov    %cl,-0xa0(%rbp,%rax,1)
mov    -0x84(%rbp),%eax
mov    %al,%cl
mov    -0x14(%rbp),%eax
add    $0x1,%eax
cltq
mov    %cl,-0xa0(%rbp,%rax,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1243 <create_letter_distribution_diagram+0x123>
movl   $0x0,-0x14(%rbp)
mov    -0x18(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
jmp    1234 <create_letter_distribution_diagram+0x114>
jmp    1307 <create_letter_distribution_diagram+0x1e7>
cmpl   $0x19,-0x14(%rbp)
jg     1341 <create_letter_distribution_diagram+0x221>
movslq -0x14(%rbp),%rax
mov    -0xa0(%rbp,%rax,1),%al
movslq -0x14(%rbp),%rcx
mov    -0x80(%rbp,%rcx,4),%edx
lea    0xcd5(%rip),%rdi
movsbl %al,%esi
call   1040 <printf@plt>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1307 <create_letter_distribution_diagram+0x1e7>
mov    -0x4(%rbp),%eax
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<create_letter_distribution_diagram>:
push   %r14
push   %rbx
sub    $0x88,%rsp
mov    %rdi,%rbx
xorps  %xmm0,%xmm0
movaps %xmm0,0x20(%rsp)
movaps %xmm0,0x30(%rsp)
movaps %xmm0,0x40(%rsp)
movaps %xmm0,0x50(%rsp)
movaps %xmm0,0x60(%rsp)
movaps %xmm0,0x70(%rsp)
movq   $0x0,0x80(%rsp)
movaps 0xe9f(%rip),%xmm0
movaps %xmm0,(%rsp)
movabs $0x7877767574737271,%rax
76 77 78
mov    %rax,0x10(%rsp)
movw   $0x7a79,0x18(%rsp)
call   1030 <strlen@plt>
test   %eax,%eax
je     11cf <create_letter_distribution_diagram+0xaf>
mov    $0xffffff9f,%edx
mov    %eax,%eax
xor    %ecx,%ecx
lea    0x20(%rdx),%r8
jmp    11b0 <create_letter_distribution_diagram+0x90>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    %esi,%edi
addl   $0x1,0x20(%rsp,%rdi,4)
add    $0x1,%rcx
cmp    %rcx,%rax
je     11cf <create_letter_distribution_diagram+0xaf>
movsbq (%rbx,%rcx,1),%rsi
lea    -0x61(%rsi),%edx
mov    $0xffffff9f,%edi
cmp    $0x1a,%dl
jb     11a0 <create_letter_distribution_diagram+0x80>
lea    -0x41(%rsi),%edx
mov    %r8,%rdi
cmp    $0x19,%dl
jbe    11a0 <create_letter_distribution_diagram+0x80>
jmp    11a7 <create_letter_distribution_diagram+0x87>
mov    $0x19,%eax
jmp    11e5 <create_letter_distribution_diagram+0xc5>
cs nopw 0x0(%rax,%rax,1)
add    $0xffffffff,%eax
je     1214 <create_letter_distribution_diagram+0xf4>
mov    $0x1,%ecx
mov    0x20(%rsp),%edx
jmp    1208 <create_letter_distribution_diagram+0xe8>
mov    %esi,0x1c(%rsp,%rcx,4)
mov    %edx,0x20(%rsp,%rcx,4)
rolw   $0x8,-0x1(%rsp,%rcx,1)
add    $0x1,%rcx
cmp    $0x1a,%rcx
je     11e0 <create_letter_distribution_diagram+0xc0>
mov    0x20(%rsp,%rcx,4),%esi
cmp    %esi,%edx
jl     11f0 <create_letter_distribution_diagram+0xd0>
mov    %esi,%edx
jmp    11fe <create_letter_distribution_diagram+0xde>
xor    %ebx,%ebx
lea    0xdf3(%rip),%r14
nopl   (%rax)
movsbl (%rsp,%rbx,1),%esi
mov    0x20(%rsp,%rbx,4),%edx
mov    %r14,%rdi
call   1040 <printf@plt>
add    $0x1,%rbx
cmp    $0x1a,%rbx
jne    1220 <create_letter_distribution_diagram+0x100>
add    $0x88,%rsp
pop    %rbx
pop    %r14
ret

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

LLVM IR (-O2):
@.str = [9 x i8] c"\0A%c - %d\00"
define i32 @create_letter_distribution_diagram(i8* %0) {
%2 = alloca [26 x i32]
%3 = bitcast [26 x i32]* %2 to i8*
%4 = alloca [26 x i8]
%5 = getelementptr inbounds [26 x i8], [26 x i8]* %4, i64 0, i64 0
%6 = bitcast [26 x i8]* %4 to <16 x i8>*
store <16 x i8> <i8 97, i8 98, i8 99, i8 100, i8 101, i8 102, i8 103, i8 104, i8 105, i8 106, i8 107, i8 108, i8 109, i8 110, i8 111, i8 112>, <16 x i8>* %6
%7 = getelementptr inbounds [26 x i8], [26 x i8]* %4, i64 0, i64 16
store i8 113, i8* %7
%8 = getelementptr inbounds [26 x i8], [26 x i8]* %4, i64 0, i64 17
store i8 114, i8* %8
%9 = getelementptr inbounds [26 x i8], [26 x i8]* %4, i64 0, i64 18
store i8 115, i8* %9
%10 = getelementptr inbounds [26 x i8], [26 x i8]* %4, i64 0, i64 19
store i8 116, i8* %10
%11 = getelementptr inbounds [26 x i8], [26 x i8]* %4, i64 0, i64 20
store i8 117, i8* %11
%12 = getelementptr inbounds [26 x i8], [26 x i8]* %4, i64 0, i64 21
store i8 118, i8* %12
%13 = getelementptr inbounds [26 x i8], [26 x i8]* %4, i64 0, i64 22
store i8 119, i8* %13
%14 = getelementptr inbounds [26 x i8], [26 x i8]* %4, i64 0, i64 23
store i8 120, i8* %14
%15 = getelementptr inbounds [26 x i8], [26 x i8]* %4, i64 0, i64 24
store i8 121, i8* %15
%16 = getelementptr inbounds [26 x i8], [26 x i8]* %4, i64 0, i64 25
store i8 122, i8* %16
%17 = tail call i32 @strlen(i8* %0)
%18 = icmp eq i32 %17, 0
br i1 %18, label %21, label %19
19: ; preds = %1
%20 = zext i32 %17 to i64
br label %23
21: ; preds = %40, %1
%22 = getelementptr inbounds [26 x i32], [26 x i32]* %2, i64 0, i64 0
br label %43
23: ; preds = %19, %40
%24 = phi i64 [ 0, %19 ], [ %41, %40 ]
%25 = getelementptr inbounds i8, i8* %0, i64 %24
%26 = load i8, i8* %25
%27 = sext i8 %26 to i64
%28 = add i8 %26, -97
%29 = icmp ult i8 %28, 26
br i1 %29, label %33, label %30
30: ; preds = %23
%31 = add i8 %26, -65
%32 = icmp ult i8 %31, 26
br i1 %32, label %33, label %40
33: ; preds = %30, %23
%34 = phi i64 [ 4294967199, %23 ], [ 4294967231, %30 ]
%35 = add nsw i64 %34, %27
%36 = and i64 %35, 4294967295
%37 = getelementptr inbounds [26 x i32], [26 x i32]* %2, i64 0, i64 %36
%38 = load i32, i32* %37
%39 = add nsw i32 %38, 1
store i32 %39, i32* %37
br label %40
40: ; preds = %33, %30
%41 = add nuw nsw i64 %24, 1
%42 = icmp eq i64 %41, %20
br i1 %42, label %21, label %23
43: ; preds = %21, %62
%44 = phi i32 [ 25, %21 ], [ %63, %62 ]
%45 = load i32, i32* %22
br label %46
46: ; preds = %43, %59
%47 = phi i32 [ %45, %43 ], [ %60, %59 ]
%48 = phi i64 [ 0, %43 ], [ %49, %59 ]
%49 = add nuw nsw i64 %48, 1
%50 = getelementptr inbounds [26 x i32], [26 x i32]* %2, i64 0, i64 %49
%51 = load i32, i32* %50
%52 = icmp slt i32 %47, %51
br i1 %52, label %53, label %59
53: ; preds = %46
%54 = getelementptr inbounds [26 x i32], [26 x i32]* %2, i64 0, i64 %48
store i32 %51, i32* %54
store i32 %47, i32* %50
%55 = getelementptr inbounds [26 x i8], [26 x i8]* %4, i64 0, i64 %48
%56 = load i8, i8* %55
%57 = getelementptr inbounds [26 x i8], [26 x i8]* %4, i64 0, i64 %49
%58 = load i8, i8* %57
store i8 %58, i8* %55
store i8 %56, i8* %57
br label %59
59: ; preds = %53, %46
%60 = phi i32 [ %47, %53 ], [ %51, %46 ]
%61 = icmp eq i64 %49, 25
br i1 %61, label %62, label %46
62: ; preds = %59
%63 = add nsw i32 %44, -1
%64 = icmp eq i32 %63, 0
br i1 %64, label %65, label %43
65: ; preds = %62, %65
%66 = phi i64 [ %72, %65 ], [ 0, %62 ]
%67 = getelementptr inbounds [26 x i8], [26 x i8]* %4, i64 0, i64 %66
%68 = load i8, i8* %67
%69 = getelementptr inbounds [26 x i32], [26 x i32]* %2, i64 0, i64 %66
%70 = load i32, i32* %69
%71 = tail call i32 @printf(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0), i8 signext %68, i32 %70)
%72 = add nuw nsw i64 %66, 1
%73 = icmp eq i64 %72, 26
br i1 %73, label %74, label %65
74: ; preds = %65
ret i32 undef
}