#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 */
char getchar();
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ reach(char **, char, char, char *, unsigned int *, char *,
                         unsigned int *);
int /*<<< orphan*/ scanf(char *, ...);
int main(int argc, char *argv[]) {
  unsigned int t, e, i, j, k, l;
  char f[9], a1, a2;
  char visibility[26][26];
  char messageStore[50][103];
  unsigned int msc;
  char *messages[26][50];
  unsigned int messageCount[26];
  char receivers[26];
  unsigned int receiverCount;
  char nonReceivers[26];
  unsigned int nonReceiverCount;
  char sent;
  scanf("%u", &t);
  for (i = 0; i < t; ++i) {
    for (j = 0; j < 26; ++j)
      for (k = 0; k < 26; ++k)
        visibility[j][k] = 0;
    for (j = 0; j < 26; ++j)
      messageCount[j] = 0;
    msc = 0;
    scanf("%u", &e);
    for (j = 0; j < e; ++j) {
      scanf("%s %c %c", f, &a1, &a2);
      a1 -= 'A';
      a2 -= 'A';
      if (f[0] == 'V') {
        visibility[a1][a2] = visibility[a2][a1] = 1;
      } else if (f[0] == 'O' || f[0] == 'W') {
        visibility[a1][a2] = visibility[a2][a1] = 0;
      } else {
        messageStore[msc][0] = a2 + 'A';
        k = 1;
        do
          messageStore[msc][k] = getchar();
        while (messageStore[msc][k++] != '"');
        messageStore[msc][k] = '\0';
        for (k = 0; k < 26; ++k) {
          receivers[k] = 0;
          nonReceivers[k] = k;
        }
        receiverCount = 0;
        nonReceiverCount = 26;
        reach(visibility, a1, a1, receivers, &receiverCount, nonReceivers,
              &nonReceiverCount);
        for (k = 1; k < receiverCount; ++k)
          messages[receivers[k]][messageCount[receivers[k]]++] =
              messageStore[msc];
        msc += 1;
      }
    }
    if (i > 0)
      printf("\n");
    for (j = 0; j < 26; ++j) {
      if (messageCount[j] > 0) {
        printf("%c: [%s", j + 'A', messages[j][0]);
        for (k = 1; k < messageCount[j]; ++k) {
          printf(", %s", messages[j][k]);
        }
        printf("]\n");
      }
    }
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x4070,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
lea    0xea0(%rip),%rdi
lea    -0x14(%rbp),%rsi
mov    $0x0,%al
call   1050 <scanf@plt>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jae    15b6 <main+0x476>
movl   $0x0,-0x20(%rbp)
cmpl   $0x1a,-0x20(%rbp)
jae    11db <main+0x9b>
movl   $0x0,-0x24(%rbp)
cmpl   $0x1a,-0x24(%rbp)
jae    11c8 <main+0x88>
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
lea    -0x2e0(%rbp),%rax
imul   $0x1a,%rcx,%rcx
add    %rcx,%rax
mov    -0x24(%rbp),%ecx
movb   $0x0,(%rax,%rcx,1)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1196 <main+0x56>
jmp    11cd <main+0x8d>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1185 <main+0x45>
movl   $0x0,-0x20(%rbp)
cmpl   $0x1a,-0x20(%rbp)
jae    1208 <main+0xc8>
mov    -0x20(%rbp),%eax
movl   $0x0,-0x4020(%rbp,%rax,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    11e2 <main+0xa2>
movl   $0x0,-0x1704(%rbp)
lea    0xde7(%rip),%rdi
lea    -0x18(%rbp),%rsi
mov    $0x0,%al
call   1050 <scanf@plt>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x18(%rbp),%eax
jae    14c8 <main+0x388>
lea    -0x31(%rbp),%rsi
lea    0xdc1(%rip),%rdi
lea    -0x32(%rbp),%rdx
lea    -0x33(%rbp),%rcx
mov    $0x0,%al
call   1050 <scanf@plt>
movsbl -0x32(%rbp),%eax
sub    $0x41,%eax
mov    %al,-0x32(%rbp)
movsbl -0x33(%rbp),%eax
sub    $0x41,%eax
mov    %al,-0x33(%rbp)
movsbl -0x31(%rbp),%eax
cmp    $0x56,%eax
jne    12af <main+0x16f>
movsbq -0x33(%rbp),%rcx
lea    -0x2e0(%rbp),%rax
imul   $0x1a,%rcx,%rcx
add    %rcx,%rax
movsbq -0x32(%rbp),%rcx
movb   $0x1,(%rax,%rcx,1)
movsbq -0x32(%rbp),%rcx
lea    -0x2e0(%rbp),%rax
imul   $0x1a,%rcx,%rcx
add    %rcx,%rax
movsbq -0x33(%rbp),%rcx
movb   $0x1,(%rax,%rcx,1)
jmp    14b5 <main+0x375>
movsbl -0x31(%rbp),%eax
cmp    $0x4f,%eax
je     12c9 <main+0x189>
movsbl -0x31(%rbp),%eax
cmp    $0x57,%eax
jne    1306 <main+0x1c6>
movsbq -0x33(%rbp),%rcx
lea    -0x2e0(%rbp),%rax
imul   $0x1a,%rcx,%rcx
add    %rcx,%rax
movsbq -0x32(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
movsbq -0x32(%rbp),%rcx
lea    -0x2e0(%rbp),%rax
imul   $0x1a,%rcx,%rcx
add    %rcx,%rax
movsbq -0x33(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
jmp    14b0 <main+0x370>
movsbl -0x33(%rbp),%eax
add    $0x41,%eax
mov    %al,%cl
mov    -0x1704(%rbp),%eax
mov    %eax,%edx
lea    -0x1700(%rbp),%rax
imul   $0x67,%rdx,%rdx
add    %rdx,%rax
mov    %cl,(%rax)
movl   $0x1,-0x24(%rbp)
mov    $0x0,%al
call   1040 <getchar@plt>
mov    %al,%dl
mov    -0x1704(%rbp),%eax
mov    %eax,%ecx
lea    -0x1700(%rbp),%rax
imul   $0x67,%rcx,%rcx
add    %rcx,%rax
mov    -0x24(%rbp),%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x1704(%rbp),%eax
mov    %eax,%ecx
lea    -0x1700(%rbp),%rax
imul   $0x67,%rcx,%rcx
add    %rcx,%rax
mov    -0x24(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x24(%rbp)
mov    %ecx,%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x22,%eax
jne    132e <main+0x1ee>
mov    -0x1704(%rbp),%eax
mov    %eax,%ecx
lea    -0x1700(%rbp),%rax
imul   $0x67,%rcx,%rcx
add    %rcx,%rax
mov    -0x24(%rbp),%ecx
movb   $0x0,(%rax,%rcx,1)
movl   $0x0,-0x24(%rbp)
cmpl   $0x1a,-0x24(%rbp)
jae    13d9 <main+0x299>
mov    -0x24(%rbp),%eax
movb   $0x0,-0x4040(%rbp,%rax,1)
mov    -0x24(%rbp),%eax
mov    %al,%cl
mov    -0x24(%rbp),%eax
mov    %cl,-0x4060(%rbp,%rax,1)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    13a7 <main+0x267>
movl   $0x0,-0x4044(%rbp)
movl   $0x1a,-0x4064(%rbp)
lea    -0x2e0(%rbp),%rdi
mov    -0x32(%rbp),%sil
mov    -0x32(%rbp),%dl
lea    -0x4040(%rbp),%rcx
lea    -0x4060(%rbp),%r9
lea    -0x4044(%rbp),%r8
lea    -0x4064(%rbp),%rax
movsbl %sil,%esi
movsbl %dl,%edx
mov    %rax,(%rsp)
call   1060 <reach@plt>
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x4044(%rbp),%eax
jae    14a1 <main+0x361>
mov    -0x1704(%rbp),%eax
lea    -0x1700(%rbp),%rdx
imul   $0x67,%rax,%rax
add    %rax,%rdx
mov    -0x24(%rbp),%eax
movsbq -0x4040(%rbp,%rax,1),%rcx
ff ff
lea    -0x3fb0(%rbp),%rax
imul   $0x190,%rcx,%rcx
add    %rcx,%rax
mov    -0x24(%rbp),%ecx
movsbq -0x4040(%rbp,%rcx,1),%rsi
ff ff
mov    -0x4020(%rbp,%rsi,4),%ecx
mov    %ecx,%edi
add    $0x1,%edi
mov    %edi,-0x4020(%rbp,%rsi,4)
mov    %ecx,%ecx
mov    %rdx,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    142e <main+0x2ee>
mov    -0x1704(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1704(%rbp)
jmp    14b5 <main+0x375>
jmp    14ba <main+0x37a>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    122b <main+0xeb>
cmpl   $0x0,-0x1c(%rbp)
jbe    14e0 <main+0x3a0>
lea    0xb41(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x20(%rbp)
cmpl   $0x1a,-0x20(%rbp)
jae    15a3 <main+0x463>
mov    -0x20(%rbp),%eax
cmpl   $0x0,-0x4020(%rbp,%rax,4)
jbe    1590 <main+0x450>
mov    -0x20(%rbp),%esi
add    $0x41,%esi
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
lea    -0x3fb0(%rbp),%rax
imul   $0x190,%rcx,%rcx
add    %rcx,%rax
mov    (%rax),%rdx
lea    0xae4(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x20(%rbp),%ecx
cmp    -0x4020(%rbp,%rcx,4),%eax
jae    1582 <main+0x442>
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
lea    -0x3fb0(%rbp),%rax
imul   $0x190,%rcx,%rcx
add    %rcx,%rax
mov    -0x24(%rbp),%ecx
mov    (%rax,%rcx,8),%rsi
lea    0xaa7(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1536 <main+0x3f6>
lea    0xa90(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    1595 <main+0x455>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    14e7 <main+0x3a7>
jmp    15a8 <main+0x468>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1172 <main+0x32>
xor    %eax,%eax
add    $0x4070,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x4058,%rsp
lea    0xe88(%rip),%rdi
lea    0x1c(%rsp),%rsi
xor    %eax,%eax
call   1080 <scanf@plt>
cmpl   $0x0,0x1c(%rsp)
je     1559 <main+0x3e9>
lea    0xe7e(%rip),%r12
lea    0xe66(%rip),%r15
lea    0x27(%rsp),%rbp
movl   $0x0,0x10(%rsp)
jmp    11e1 <main+0x71>
nopl   0x0(%rax)
mov    0x10(%rsp),%eax
add    $0x1,%eax
mov    %eax,0x10(%rsp)
cmp    0x1c(%rsp),%eax
lea    0xe3d(%rip),%r15
lea    0x27(%rsp),%rbp
jae    1559 <main+0x3e9>
mov    $0x2a4,%edx
lea    0xe0(%rsp),%rdi
xor    %esi,%esi
call   1060 <memset@plt>
xorps  %xmm0,%xmm0
movaps %xmm0,0x70(%rsp)
movaps %xmm0,0x80(%rsp)
movaps %xmm0,0x90(%rsp)
movaps %xmm0,0xa0(%rsp)
movaps %xmm0,0xb0(%rsp)
movaps %xmm0,0xc0(%rsp)
movq   $0x0,0xd0(%rsp)
lea    0xdd8(%rip),%rdi
lea    0x18(%rsp),%rsi
xor    %eax,%eax
call   1080 <scanf@plt>
cmpl   $0x0,0x18(%rsp)
je     14b0 <main+0x340>
xor    %r13d,%r13d
xor    %r14d,%r14d
jmp    12a9 <main+0x139>
nopw   0x0(%rax,%rax,1)
movsbq %dl,%rcx
movsbq %al,%rax
lea    (%rcx,%rcx,4),%rdx
lea    (%rdx,%rdx,4),%rdx
add    %rcx,%rdx
add    %rsp,%rdx
add    $0xe0,%rdx
movb   $0x0,(%rax,%rdx,1)
lea    (%rax,%rax,4),%rdx
lea    (%rdx,%rdx,4),%rdx
add    %rax,%rdx
lea    (%rsp,%rdx,1),%rax
add    $0xe0,%rax
movb   $0x0,(%rcx,%rax,1)
add    $0x1,%r14d
cmp    0x18(%rsp),%r14d
jae    14b0 <main+0x340>
mov    %r15,%rdi
mov    %rbp,%rsi
lea    0xe(%rsp),%rdx
lea    0xf(%rsp),%rcx
xor    %eax,%eax
call   1080 <scanf@plt>
mov    0xe(%rsp),%al
add    $0xbf,%al
mov    %al,0xe(%rsp)
mov    0xf(%rsp),%cl
lea    -0x41(%rcx),%edx
mov    %dl,0xf(%rsp)
mov    0x27(%rsp),%bl
cmp    $0x4f,%bl
je     1260 <main+0xf0>
cmp    $0x57,%bl
je     1260 <main+0xf0>
cmp    $0x56,%bl
jne    1330 <main+0x1c0>
movsbq %dl,%rcx
movsbq %al,%rax
lea    (%rcx,%rcx,4),%rdx
lea    (%rdx,%rdx,4),%rdx
add    %rcx,%rdx
add    %rsp,%rdx
add    $0xe0,%rdx
movb   $0x1,(%rax,%rdx,1)
lea    (%rax,%rax,4),%rdx
lea    (%rdx,%rdx,4),%rdx
add    %rax,%rdx
lea    (%rsp,%rdx,1),%rax
add    $0xe0,%rax
movb   $0x1,(%rcx,%rax,1)
jmp    129a <main+0x12a>
nopl   0x0(%rax,%rax,1)
mov    %r13d,%eax
imul   $0x67,%rax,%rax
lea    (%rsp,%rax,1),%r15
add    $0x2c30,%r15
mov    %cl,0x2c30(%rsp,%rax,1)
mov    $0x1,%ebp
xchg   %ax,%ax
xor    %eax,%eax
call   1070 <getchar@plt>
mov    %ebp,%ecx
mov    %al,(%rcx,%r15,1)
add    $0x1,%ebp
cmp    $0x22,%al
jne    1350 <main+0x1e0>
mov    %ebp,%eax
movb   $0x0,(%rax,%r15,1)
xorps  %xmm0,%xmm0
movups %xmm0,0x3a(%rsp)
movaps %xmm0,0x30(%rsp)
movaps 0xc81(%rip),%xmm0
movaps %xmm0,0x50(%rsp)
movabs $0x1716151413121110,%rax
15 16 17
mov    %rax,0x60(%rsp)
movw   $0x1918,0x68(%rsp)
movl   $0x0,0x14(%rsp)
movl   $0x1a,0x20(%rsp)
movsbl 0xe(%rsp),%edx
lea    0x20(%rsp),%rax
mov    %rax,(%rsp)
lea    0xe0(%rsp),%rdi
mov    %edx,%esi
lea    0x30(%rsp),%rcx
lea    0x14(%rsp),%r8
lea    0x50(%rsp),%r9
call   1090 <reach@plt>
mov    0x14(%rsp),%eax
cmp    $0x2,%rax
jb     1497 <main+0x327>
mov    %eax,%edx
add    $0xffffffffffffffff,%rax
mov    $0x1,%ecx
cmp    $0x2,%edx
je     146e <main+0x2fe>
mov    %rax,%rdx
and    $0xfffffffffffffffe,%rdx
neg    %rdx
mov    $0x1,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsbq 0x30(%rsp,%rcx,1),%rsi
mov    0x70(%rsp,%rsi,4),%edi
lea    0x1(%rdi),%ebp
mov    %ebp,0x70(%rsp,%rsi,4)
imul   $0x190,%rsi,%rsi
add    %rsp,%rsi
add    $0x390,%rsi
mov    %r15,(%rsi,%rdi,8)
movsbq 0x31(%rsp,%rcx,1),%rsi
mov    0x70(%rsp,%rsi,4),%edi
lea    0x1(%rdi),%ebp
mov    %ebp,0x70(%rsp,%rsi,4)
imul   $0x190,%rsi,%rsi
add    %rsp,%rsi
add    $0x390,%rsi
mov    %r15,(%rsi,%rdi,8)
lea    (%rdx,%rcx,1),%rsi
add    $0x2,%rsi
add    $0x2,%rcx
cmp    $0x1,%rsi
jne    1410 <main+0x2a0>
test   $0x1,%al
je     1497 <main+0x327>
movsbq 0x30(%rsp,%rcx,1),%rax
mov    0x70(%rsp,%rax,4),%ecx
lea    0x1(%rcx),%edx
mov    %edx,0x70(%rsp,%rax,4)
imul   $0x190,%rax,%rax
add    %rsp,%rax
add    $0x390,%rax
mov    %r15,(%rax,%rcx,8)
add    $0x1,%r13d
lea    0xb71(%rip),%r15
lea    0x27(%rsp),%rbp
jmp    129a <main+0x12a>
nopl   0x0(%rax)
cmpl   $0x0,0x10(%rsp)
je     14c1 <main+0x351>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x390(%rsp),%r15
xor    %r14d,%r14d
lea    0xb49(%rip),%r13
jmp    1501 <main+0x391>
cs nopw 0x0(%rax,%rax,1)
nop
lea    0xb42(%rip),%rdi
call   1040 <puts@plt>
add    $0x1,%r14
add    $0x190,%r15
cmp    $0x1a,%r14
je     11c0 <main+0x50>
mov    0x70(%rsp,%r14,4),%ebp
test   %rbp,%rbp
je     14ec <main+0x37c>
imul   $0x190,%r14,%rax
mov    0x390(%rsp,%rax,1),%rdx
lea    0x41(%r14),%esi
mov    %r13,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
cmp    $0x1,%ebp
je     14e0 <main+0x370>
mov    $0x1,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%r15,%rbx,8),%rsi
mov    %r12,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
add    $0x1,%rbx
cmp    %rbx,%rbp
jne    1540 <main+0x3d0>
jmp    14e0 <main+0x370>
xor    %eax,%eax
add    $0x4058,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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