#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 */
scalar_t__ EOF;
int INT_MAX;
int /*<<< orphan*/ printf(char *, char *);
scalar_t__ scanf(char *, char *);
int main(int argc, const char *argv[]) {
  int char_frequency[8][26] = {0};
  char line[8 + 1];
  while (scanf("%s\n", line) != EOF) {
    for (int i = 0; i < 8; i++) {
      char c = line[i];
      char_frequency[i][c - 'a']++;
    }
  }
  char error_corrected_message[8 + 1];
  char error_corrected_message_part_2[8 + 1];
  for (int i = 0; i < 8; i++) {
    int most_frequent_char = 0;
    int max_frequency = 0;
    int least_frequent_char = 0;
    int min_frequency = INT_MAX;
    for (int j = 0; j < 26; j++) {
      if (max_frequency < char_frequency[i][j]) {
        max_frequency = char_frequency[i][j];
        most_frequent_char = j;
      }
      if (min_frequency > char_frequency[i][j] && char_frequency[i][j] >= 1) {
        min_frequency = char_frequency[i][j];
        least_frequent_char = j;
      }
    }
    error_corrected_message[i] = most_frequent_char + 'a';
    error_corrected_message_part_2[i] = least_frequent_char + 'a';
  }
  printf("%s\n", error_corrected_message);
  printf("%s\n", error_corrected_message_part_2);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x390,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
lea    -0x350(%rbp),%rdi
xor    %esi,%esi
mov    $0x340,%edx
call   1040 <memset@plt>
lea    -0x359(%rbp),%rsi
lea    0xe96(%rip),%rdi
call   1050 <scanf@plt>
mov    0x2e6a(%rip),%rcx
cmp    (%rcx),%rax
je     11ee <main+0xbe>
movl   $0x0,-0x360(%rbp)
cmpl   $0x8,-0x360(%rbp)
jge    11e9 <main+0xb9>
movslq -0x360(%rbp),%rax
mov    -0x359(%rbp,%rax,1),%al
mov    %al,-0x361(%rbp)
movslq -0x360(%rbp),%rcx
lea    -0x350(%rbp),%rax
imul   $0x68,%rcx,%rcx
add    %rcx,%rax
movsbl -0x361(%rbp),%ecx
sub    $0x61,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x360(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x360(%rbp)
jmp    1189 <main+0x59>
jmp    115c <main+0x2c>
movl   $0x0,-0x378(%rbp)
cmpl   $0x8,-0x378(%rbp)
jge    1386 <main+0x256>
movl   $0x0,-0x37c(%rbp)
movl   $0x0,-0x380(%rbp)
movl   $0x0,-0x384(%rbp)
mov    0x2dbe(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x388(%rbp)
movl   $0x0,-0x38c(%rbp)
cmpl   $0x1a,-0x38c(%rbp)
jge    1340 <main+0x210>
mov    -0x380(%rbp),%eax
movslq -0x378(%rbp),%rdx
lea    -0x350(%rbp),%rcx
imul   $0x68,%rdx,%rdx
add    %rdx,%rcx
movslq -0x38c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    12a5 <main+0x175>
movslq -0x378(%rbp),%rcx
lea    -0x350(%rbp),%rax
imul   $0x68,%rcx,%rcx
add    %rcx,%rax
movslq -0x38c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x380(%rbp)
mov    -0x38c(%rbp),%eax
mov    %eax,-0x37c(%rbp)
mov    -0x388(%rbp),%eax
movslq -0x378(%rbp),%rdx
lea    -0x350(%rbp),%rcx
imul   $0x68,%rdx,%rdx
add    %rdx,%rcx
movslq -0x38c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    1327 <main+0x1f7>
movslq -0x378(%rbp),%rcx
lea    -0x350(%rbp),%rax
imul   $0x68,%rcx,%rcx
add    %rcx,%rax
movslq -0x38c(%rbp),%rcx
cmpl   $0x1,(%rax,%rcx,4)
jl     1327 <main+0x1f7>
movslq -0x378(%rbp),%rcx
lea    -0x350(%rbp),%rax
imul   $0x68,%rcx,%rcx
add    %rcx,%rax
movslq -0x38c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x388(%rbp)
mov    -0x38c(%rbp),%eax
mov    %eax,-0x384(%rbp)
jmp    132c <main+0x1fc>
mov    -0x38c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38c(%rbp)
jmp    123c <main+0x10c>
mov    -0x37c(%rbp),%eax
add    $0x61,%eax
mov    %al,%cl
movslq -0x378(%rbp),%rax
mov    %cl,-0x36a(%rbp,%rax,1)
mov    -0x384(%rbp),%eax
add    $0x61,%eax
mov    %al,%cl
movslq -0x378(%rbp),%rax
mov    %cl,-0x373(%rbp,%rax,1)
mov    -0x378(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x378(%rbp)
jmp    11f8 <main+0xc8>
lea    -0x36a(%rbp),%rsi
lea    0xc6c(%rip),%rdi
call   1030 <printf@plt>
lea    -0x373(%rbp),%rsi
lea    0xc59(%rip),%rdi
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x390,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %rbx
sub    $0x368,%rsp
lea    0x20(%rsp),%rdi
mov    $0x340,%edx
xor    %esi,%esi
call   1040 <memset@plt>
lea    0xeab(%rip),%rdi
lea    0x5(%rsp),%rsi
call   1050 <scanf@plt>
mov    0x2e7a(%rip),%r15
cmp    (%r15),%rax
je     11fa <main+0xca>
lea    0xe8a(%rip),%r14
lea    0x5(%rsp),%rbx
nopl   0x0(%rax,%rax,1)
movsbq 0x5(%rsp),%rax
addl   $0x1,-0x164(%rsp,%rax,4)
01
movsbq 0x6(%rsp),%rax
addl   $0x1,-0xfc(%rsp,%rax,4)
01
movsbq 0x7(%rsp),%rax
addl   $0x1,-0x94(%rsp,%rax,4)
01
movsbq 0x8(%rsp),%rax
addl   $0x1,-0x2c(%rsp,%rax,4)
movsbq 0x9(%rsp),%rax
addl   $0x1,0x3c(%rsp,%rax,4)
movsbq 0xa(%rsp),%rax
addl   $0x1,0xa4(%rsp,%rax,4)
01
movsbq 0xb(%rsp),%rax
addl   $0x1,0x10c(%rsp,%rax,4)
01
movsbq 0xc(%rsp),%rax
addl   $0x1,0x174(%rsp,%rax,4)
01
mov    %r14,%rdi
mov    %rbx,%rsi
call   1050 <scanf@plt>
cmp    (%r15),%rax
jne    1180 <main+0x50>
mov    0x2de7(%rip),%rax
mov    (%rax),%r8d
lea    0x24(%rsp),%r10
xor    %r9d,%r9d
jmp    1230 <main+0x100>
xchg   %ax,%ax
add    $0x61,%sil
mov    %sil,0x17(%rsp,%r9,1)
add    $0x61,%r11b
mov    %r11b,0xe(%rsp,%r9,1)
add    $0x1,%r9
add    $0x68,%r10
cmp    $0x8,%r9
je     1295 <main+0x165>
xor    %edi,%edi
mov    %r8d,%ecx
xor    %r11d,%r11d
xor    %ebp,%ebp
xor    %esi,%esi
jmp    124a <main+0x11a>
xchg   %ax,%ax
add    $0x2,%rdi
cmp    $0x1a,%rdi
je     1210 <main+0xe0>
mov    -0x4(%r10,%rdi,4),%edx
cmp    %edx,%ebp
cmovl  %edi,%esi
cmovl  %edx,%ebp
cmp    %edx,%ecx
setg   %r14b
test   %edx,%edx
setg   %bl
mov    %edi,%r15d
test   %bl,%r14b
jne    126f <main+0x13f>
mov    %r11d,%r15d
mov    %ecx,%edx
mov    (%r10,%rdi,4),%ecx
lea    0x1(%rdi),%r11d
cmp    %ecx,%ebp
cmovl  %r11d,%esi
cmovl  %ecx,%ebp
cmp    %ecx,%edx
setg   %bl
test   %ecx,%ecx
setg   %al
test   %al,%bl
jne    1240 <main+0x110>
mov    %r15d,%r11d
mov    %edx,%ecx
jmp    1240 <main+0x110>
lea    0xd64(%rip),%rbx
lea    0x17(%rsp),%rsi
mov    %rbx,%rdi
call   1030 <printf@plt>
lea    0xe(%rsp),%rsi
mov    %rbx,%rdi
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x368,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [4 x i8] c"%s\0A\00"
@EOF = global i64 0
@INT_MAX = global i32 0
define i32 @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8**
%6 = alloca [8 x [26 x i32]]
%7 = alloca [9 x i8]
%8 = alloca i32
%9 = alloca i8
%10 = alloca [9 x i8]
%11 = alloca [9 x i8]
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
%18 = bitcast [8 x [26 x i32]]* %6 to i8*
br label %19
19: ; preds = %46, %2
%20 = getelementptr inbounds [9 x i8], [9 x i8]* %7, i64 0, i64 0
%21 = call i64 @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i8* %20)
%22 = load i64, i64* @EOF
%23 = icmp ne i64 %21, %22
br i1 %23, label %24, label %47
24: ; preds = %19
store i32 0, i32* %8
br label %25
25: ; preds = %43, %24
%26 = load i32, i32* %8
%27 = icmp slt i32 %26, 8
br i1 %27, label %28, label %46
28: ; preds = %25
%29 = load i32, i32* %8
%30 = sext i32 %29 to i64
%31 = getelementptr inbounds [9 x i8], [9 x i8]* %7, i64 0, i64 %30
%32 = load i8, i8* %31
store i8 %32, i8* %9
%33 = load i32, i32* %8
%34 = sext i32 %33 to i64
%35 = getelementptr inbounds [8 x [26 x i32]], [8 x [26 x i32]]* %6, i64 0, i64 %34
%36 = load i8, i8* %9
%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]* %35, 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 = %28
%44 = load i32, i32* %8
%45 = add nsw i32 %44, 1
store i32 %45, i32* %8
br label %25
46: ; preds = %25
br label %19
47: ; preds = %19
store i32 0, i32* %12
br label %48
48: ; preds = %120, %47
%49 = load i32, i32* %12
%50 = icmp slt i32 %49, 8
br i1 %50, label %51, label %123
51: ; preds = %48
store i32 0, i32* %13
store i32 0, i32* %14
store i32 0, i32* %15
%52 = load i32, i32* @INT_MAX
store i32 %52, i32* %16
store i32 0, i32* %17
br label %53
53: ; preds = %104, %51
%54 = load i32, i32* %17
%55 = icmp slt i32 %54, 26
br i1 %55, label %56, label %107
56: ; preds = %53
%57 = load i32, i32* %14
%58 = load i32, i32* %12
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds [8 x [26 x i32]], [8 x [26 x i32]]* %6, i64 0, i64 %59
%61 = load i32, i32* %17
%62 = sext i32 %61 to i64
%63 = getelementptr inbounds [26 x i32], [26 x i32]* %60, i64 0, i64 %62
%64 = load i32, i32* %63
%65 = icmp slt i32 %57, %64
br i1 %65, label %66, label %75
66: ; preds = %56
%67 = load i32, i32* %12
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds [8 x [26 x i32]], [8 x [26 x i32]]* %6, i64 0, i64 %68
%70 = load i32, i32* %17
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds [26 x i32], [26 x i32]* %69, i64 0, i64 %71
%73 = load i32, i32* %72
store i32 %73, i32* %14
%74 = load i32, i32* %17
store i32 %74, i32* %13
br label %75
75: ; preds = %66, %56
%76 = load i32, i32* %16
%77 = load i32, i32* %12
%78 = sext i32 %77 to i64
%79 = getelementptr inbounds [8 x [26 x i32]], [8 x [26 x i32]]* %6, i64 0, i64 %78
%80 = load i32, i32* %17
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds [26 x i32], [26 x i32]* %79, i64 0, i64 %81
%83 = load i32, i32* %82
%84 = icmp sgt i32 %76, %83
br i1 %84, label %85, label %103
85: ; preds = %75
%86 = load i32, i32* %12
%87 = sext i32 %86 to i64
%88 = getelementptr inbounds [8 x [26 x i32]], [8 x [26 x i32]]* %6, i64 0, i64 %87
%89 = load i32, i32* %17
%90 = sext i32 %89 to i64
%91 = getelementptr inbounds [26 x i32], [26 x i32]* %88, i64 0, i64 %90
%92 = load i32, i32* %91
%93 = icmp sge i32 %92, 1
br i1 %93, label %94, label %103
94: ; preds = %85
%95 = load i32, i32* %12
%96 = sext i32 %95 to i64
%97 = getelementptr inbounds [8 x [26 x i32]], [8 x [26 x i32]]* %6, i64 0, i64 %96
%98 = load i32, i32* %17
%99 = sext i32 %98 to i64
%100 = getelementptr inbounds [26 x i32], [26 x i32]* %97, i64 0, i64 %99
%101 = load i32, i32* %100
store i32 %101, i32* %16
%102 = load i32, i32* %17
store i32 %102, i32* %15
br label %103
103: ; preds = %94, %85, %75
br label %104
104: ; preds = %103
%105 = load i32, i32* %17
%106 = add nsw i32 %105, 1
store i32 %106, i32* %17
br label %53
107: ; preds = %53
%108 = load i32, i32* %13
%109 = add nsw i32 %108, 97
%110 = trunc i32 %109 to i8
%111 = load i32, i32* %12
%112 = sext i32 %111 to i64
%113 = getelementptr inbounds [9 x i8], [9 x i8]* %10, i64 0, i64 %112
store i8 %110, i8* %113
%114 = load i32, i32* %15
%115 = add nsw i32 %114, 97
%116 = trunc i32 %115 to i8
%117 = load i32, i32* %12
%118 = sext i32 %117 to i64
%119 = getelementptr inbounds [9 x i8], [9 x i8]* %11, i64 0, i64 %118
store i8 %116, i8* %119
br label %120
120: ; preds = %107
%121 = load i32, i32* %12
%122 = add nsw i32 %121, 1
store i32 %122, i32* %12
br label %48
123: ; preds = %48
%124 = getelementptr inbounds [9 x i8], [9 x i8]* %10, i64 0, i64 0
%125 = call i32 @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i8* %124)
%126 = getelementptr inbounds [9 x i8], [9 x i8]* %11, i64 0, i64 0
%127 = call i32 @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i8* %126)
ret i32 0
}

LLVM IR (-O2):
@.str = [4 x i8] c"%s\0A\00"
@EOF = global i64 0
@INT_MAX = global i32 0
define i32 @main(i32 %0, i8** nocapture readnone %1) {
%3 = alloca [8 x [26 x i32]]
%4 = alloca [9 x i8]
%5 = alloca [9 x i8]
%6 = alloca [9 x i8]
%7 = bitcast [8 x [26 x i32]]* %3 to i8*
%8 = getelementptr inbounds [9 x i8], [9 x i8]* %4, i64 0, i64 0
%9 = call i64 @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i8* %8)
%10 = load i64, i64* @EOF
%11 = icmp eq i64 %9, %10
br i1 %11, label %72, label %12
12: ; preds = %2
%13 = getelementptr inbounds [9 x i8], [9 x i8]* %4, i64 0, i64 1
%14 = getelementptr inbounds [9 x i8], [9 x i8]* %4, i64 0, i64 2
%15 = getelementptr inbounds [9 x i8], [9 x i8]* %4, i64 0, i64 3
%16 = getelementptr inbounds [9 x i8], [9 x i8]* %4, i64 0, i64 4
%17 = getelementptr inbounds [9 x i8], [9 x i8]* %4, i64 0, i64 5
%18 = getelementptr inbounds [9 x i8], [9 x i8]* %4, i64 0, i64 6
%19 = getelementptr inbounds [9 x i8], [9 x i8]* %4, i64 0, i64 7
br label %20
20: ; preds = %12, %20
%21 = load i8, i8* %8
%22 = sext i8 %21 to i64
%23 = add nsw i64 %22, -97
%24 = getelementptr inbounds [8 x [26 x i32]], [8 x [26 x i32]]* %3, i64 0, i64 0, i64 %23
%25 = load i32, i32* %24
%26 = add nsw i32 %25, 1
store i32 %26, i32* %24
%27 = load i8, i8* %13
%28 = sext i8 %27 to i64
%29 = add nsw i64 %28, -97
%30 = getelementptr inbounds [8 x [26 x i32]], [8 x [26 x i32]]* %3, i64 0, i64 1, i64 %29
%31 = load i32, i32* %30
%32 = add nsw i32 %31, 1
store i32 %32, i32* %30
%33 = load i8, i8* %14
%34 = sext i8 %33 to i64
%35 = add nsw i64 %34, -97
%36 = getelementptr inbounds [8 x [26 x i32]], [8 x [26 x i32]]* %3, i64 0, i64 2, i64 %35
%37 = load i32, i32* %36
%38 = add nsw i32 %37, 1
store i32 %38, i32* %36
%39 = load i8, i8* %15
%40 = sext i8 %39 to i64
%41 = add nsw i64 %40, -97
%42 = getelementptr inbounds [8 x [26 x i32]], [8 x [26 x i32]]* %3, i64 0, i64 3, i64 %41
%43 = load i32, i32* %42
%44 = add nsw i32 %43, 1
store i32 %44, i32* %42
%45 = load i8, i8* %16
%46 = sext i8 %45 to i64
%47 = add nsw i64 %46, -97
%48 = getelementptr inbounds [8 x [26 x i32]], [8 x [26 x i32]]* %3, i64 0, i64 4, i64 %47
%49 = load i32, i32* %48
%50 = add nsw i32 %49, 1
store i32 %50, i32* %48
%51 = load i8, i8* %17
%52 = sext i8 %51 to i64
%53 = add nsw i64 %52, -97
%54 = getelementptr inbounds [8 x [26 x i32]], [8 x [26 x i32]]* %3, i64 0, i64 5, i64 %53
%55 = load i32, i32* %54
%56 = add nsw i32 %55, 1
store i32 %56, i32* %54
%57 = load i8, i8* %18
%58 = sext i8 %57 to i64
%59 = add nsw i64 %58, -97
%60 = getelementptr inbounds [8 x [26 x i32]], [8 x [26 x i32]]* %3, i64 0, i64 6, i64 %59
%61 = load i32, i32* %60
%62 = add nsw i32 %61, 1
store i32 %62, i32* %60
%63 = load i8, i8* %19
%64 = sext i8 %63 to i64
%65 = add nsw i64 %64, -97
%66 = getelementptr inbounds [8 x [26 x i32]], [8 x [26 x i32]]* %3, i64 0, i64 7, i64 %65
%67 = load i32, i32* %66
%68 = add nsw i32 %67, 1
store i32 %68, i32* %66
%69 = call i64 @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i8* %8)
%70 = load i64, i64* @EOF
%71 = icmp eq i64 %69, %70
br i1 %71, label %72, label %20
72: ; preds = %20, %2
%73 = getelementptr inbounds [9 x i8], [9 x i8]* %5, i64 0, i64 0
%74 = getelementptr inbounds [9 x i8], [9 x i8]* %6, i64 0, i64 0
%75 = load i32, i32* @INT_MAX
br label %79
76: ; preds = %81
%77 = call i32 @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i8* %73)
%78 = call i32 @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i8* %74)
ret i32 0
79: ; preds = %72, %81
%80 = phi i64 [ 0, %72 ], [ %88, %81 ]
br label %90
81: ; preds = %90
%82 = trunc i32 %112 to i8
%83 = add i8 %82, 97
%84 = getelementptr inbounds [9 x i8], [9 x i8]* %5, i64 0, i64 %80
store i8 %83, i8* %84
%85 = trunc i32 %117 to i8
%86 = add i8 %85, 97
%87 = getelementptr inbounds [9 x i8], [9 x i8]* %6, i64 0, i64 %80
store i8 %86, i8* %87
%88 = add nuw nsw i64 %80, 1
%89 = icmp eq i64 %88, 8
br i1 %89, label %76, label %79
90: ; preds = %90, %79
%91 = phi i64 [ 0, %79 ], [ %119, %90 ]
%92 = phi i32 [ %75, %79 ], [ %118, %90 ]
%93 = phi i32 [ 0, %79 ], [ %117, %90 ]
%94 = phi i32 [ 0, %79 ], [ %113, %90 ]
%95 = phi i32 [ 0, %79 ], [ %112, %90 ]
%96 = getelementptr inbounds [8 x [26 x i32]], [8 x [26 x i32]]* %3, i64 0, i64 %80, i64 %91
%97 = load i32, i32* %96
%98 = icmp slt i32 %94, %97
%99 = trunc i64 %91 to i32
%100 = select i1 %98, i32 %99, i32 %95
%101 = select i1 %98, i32 %97, i32 %94
%102 = icmp sgt i32 %92, %97
%103 = icmp sgt i32 %97, 0
%104 = and i1 %102, %103
%105 = select i1 %104, i32 %99, i32 %93
%106 = select i1 %104, i32 %97, i32 %92
%107 = or i64 %91, 1
%108 = getelementptr inbounds [8 x [26 x i32]], [8 x [26 x i32]]* %3, i64 0, i64 %80, i64 %107
%109 = load i32, i32* %108
%110 = icmp slt i32 %101, %109
%111 = trunc i64 %107 to i32
%112 = select i1 %110, i32 %111, i32 %100
%113 = select i1 %110, i32 %109, i32 %101
%114 = icmp sgt i32 %106, %109
%115 = icmp sgt i32 %109, 0
%116 = and i1 %114, %115
%117 = select i1 %116, i32 %111, i32 %105
%118 = select i1 %116, i32 %109, i32 %106
%119 = add nuw nsw i64 %91, 2
%120 = icmp eq i64 %119, 26
br i1 %120, label %81, label %90
}