#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 loc(int, int, int **, int /*<<< orphan*/);
int loce(int, int, int **, int);
int /*<<< orphan*/ printf(char *, long long);
int /*<<< orphan*/ scanf(char *, ...);
int strlen(char *);
int main() {
  char a, b, str[100000];
  int arr[100000][4];
  long long int count;
  int pos, L, R, Q, i, j, len, s1, s2, c, h, e, f, e1, e2, a1, b1;
  for (i = 0; i < 100000; i++) {
    arr[i][0] = arr[i][1] = arr[i][2] = arr[i][3] = 10000001;
  }
  scanf(" %s", str);
  c = h = e = f = -1;
  len = strlen(str);
  for (i = 0; i < len; i++) {
    if (str[i] == 'c')
      arr[++c][0] = i;
    else if (str[i] == 'h')
      arr[++h][1] = i;
    else if (str[i] == 'e')
      arr[++e][2] = i;
    else
      arr[++f][3] = i;
  }
  scanf("%d", &Q);
  while (Q--) {
    count = pos = 0;
    scanf(" %c %c %d %d", &a, &b, &L, &R);
    R--;
    L--;
    switch (a) {
    case 'c':
      a1 = 0;
      break;
    case 'h':
      a1 = 1;
      break;
    case 'e':
      a1 = 2;
      break;
    case 'f':
      a1 = 3;
      break;
    }
    switch (b) {
    case 'c':
      b1 = 0;
      break;
    case 'h':
      b1 = 1;
      break;
    case 'e':
      b1 = 2;
      break;
    case 'f':
      b1 = 3;
      break;
    }
    s1 = loc(L, a1, arr, 0);
    e1 = loce(R, a1, arr, s1);
    s2 = loc(L, b1, arr, 0);
    e2 = loce(R, b1, arr, s2);
    for (i = s1; i < e1; i++) {
      for (j = s2; j < e2; j++) {
        if (arr[i][a1] < arr[j][b1])
          count++;
      }
    }
    printf("%d\n", count);
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x19f110,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x0,-0x19f0cc(%rbp)
cmpl   $0x186a0,-0x19f0cc(%rbp)
jge    11ff <main+0xaf>
movslq -0x19f0cc(%rbp),%rcx
lea    -0x19f0b0(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x989681,0xc(%rax)
movslq -0x19f0cc(%rbp),%rcx
lea    -0x19f0b0(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x989681,0x8(%rax)
movslq -0x19f0cc(%rbp),%rcx
lea    -0x19f0b0(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x989681,0x4(%rax)
movslq -0x19f0cc(%rbp),%rcx
lea    -0x19f0b0(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movl   $0x989681,(%rax)
mov    -0x19f0cc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x19f0cc(%rbp)
jmp    116c <main+0x1c>
lea    -0x186b0(%rbp),%rsi
lea    0xe23(%rip),%rdi
mov    $0x0,%al
call   1060 <scanf@plt>
movl   $0xffffffff,-0x19f0ec(%rbp)
ff ff ff
movl   $0xffffffff,-0x19f0e8(%rbp)
ff ff ff
movl   $0xffffffff,-0x19f0e4(%rbp)
ff ff ff
movl   $0xffffffff,-0x19f0e0(%rbp)
ff ff ff
lea    -0x186b0(%rbp),%rdi
call   1040 <strlen@plt>
mov    %eax,-0x19f0d4(%rbp)
movl   $0x0,-0x19f0cc(%rbp)
mov    -0x19f0cc(%rbp),%eax
cmp    -0x19f0d4(%rbp),%eax
jge    1387 <main+0x237>
movslq -0x19f0cc(%rbp),%rax
movsbl -0x186b0(%rbp,%rax,1),%eax
ff
cmp    $0x63,%eax
jne    12af <main+0x15f>
mov    -0x19f0cc(%rbp),%ecx
mov    -0x19f0e0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x19f0e0(%rbp)
movslq %eax,%rdx
lea    -0x19f0b0(%rbp),%rax
shl    $0x4,%rdx
add    %rdx,%rax
mov    %ecx,(%rax)
jmp    136e <main+0x21e>
movslq -0x19f0cc(%rbp),%rax
movsbl -0x186b0(%rbp,%rax,1),%eax
ff
cmp    $0x68,%eax
jne    12f5 <main+0x1a5>
mov    -0x19f0cc(%rbp),%ecx
mov    -0x19f0e4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x19f0e4(%rbp)
movslq %eax,%rdx
lea    -0x19f0b0(%rbp),%rax
shl    $0x4,%rdx
add    %rdx,%rax
mov    %ecx,0x4(%rax)
jmp    1369 <main+0x219>
movslq -0x19f0cc(%rbp),%rax
movsbl -0x186b0(%rbp,%rax,1),%eax
ff
cmp    $0x65,%eax
jne    133b <main+0x1eb>
mov    -0x19f0cc(%rbp),%ecx
mov    -0x19f0e8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x19f0e8(%rbp)
movslq %eax,%rdx
lea    -0x19f0b0(%rbp),%rax
shl    $0x4,%rdx
add    %rdx,%rax
mov    %ecx,0x8(%rax)
jmp    1364 <main+0x214>
mov    -0x19f0cc(%rbp),%ecx
mov    -0x19f0ec(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x19f0ec(%rbp)
movslq %eax,%rdx
lea    -0x19f0b0(%rbp),%rax
shl    $0x4,%rdx
add    %rdx,%rax
mov    %ecx,0xc(%rax)
jmp    1369 <main+0x219>
jmp    136e <main+0x21e>
jmp    1373 <main+0x223>
mov    -0x19f0cc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x19f0cc(%rbp)
jmp    1258 <main+0x108>
lea    0xcb0(%rip),%rdi
lea    -0x19f0c8(%rbp),%rsi
mov    $0x0,%al
call   1060 <scanf@plt>
mov    -0x19f0c8(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x19f0c8(%rbp)
cmp    $0x0,%eax
je     163f <main+0x4ef>
movl   $0x0,-0x19f0bc(%rbp)
movq   $0x0,-0x19f0b8(%rbp)
lea    0xc62(%rip),%rdi
xor    %eax,%eax
lea    -0x5(%rbp),%rsi
lea    -0x6(%rbp),%rdx
lea    -0x19f0c0(%rbp),%rcx
lea    -0x19f0c4(%rbp),%r8
call   1060 <scanf@plt>
mov    -0x19f0c4(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x19f0c4(%rbp)
mov    -0x19f0c0(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x19f0c0(%rbp)
movsbl -0x5(%rbp),%eax
add    $0xffffff9d,%eax
mov    %eax,%ecx
mov    %rcx,-0x19f108(%rbp)
sub    $0x5,%eax
ja     1474 <main+0x324>
mov    -0x19f108(%rbp),%rax
lea    0xbcc(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movl   $0x0,-0x19f0f8(%rbp)
jmp    1474 <main+0x324>
movl   $0x1,-0x19f0f8(%rbp)
jmp    1474 <main+0x324>
movl   $0x2,-0x19f0f8(%rbp)
jmp    1474 <main+0x324>
movl   $0x3,-0x19f0f8(%rbp)
movsbl -0x6(%rbp),%eax
add    $0xffffff9d,%eax
mov    %eax,%ecx
mov    %rcx,-0x19f110(%rbp)
sub    $0x5,%eax
ja     14db <main+0x38b>
mov    -0x19f110(%rbp),%rax
lea    0xb7d(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movl   $0x0,-0x19f0fc(%rbp)
jmp    14db <main+0x38b>
movl   $0x1,-0x19f0fc(%rbp)
jmp    14db <main+0x38b>
movl   $0x2,-0x19f0fc(%rbp)
jmp    14db <main+0x38b>
movl   $0x3,-0x19f0fc(%rbp)
mov    -0x19f0c0(%rbp),%edi
mov    -0x19f0f8(%rbp),%esi
lea    -0x19f0b0(%rbp),%rdx
xor    %ecx,%ecx
call   1070 <loc@plt>
mov    %eax,-0x19f0d8(%rbp)
mov    -0x19f0c4(%rbp),%edi
mov    -0x19f0f8(%rbp),%esi
lea    -0x19f0b0(%rbp),%rdx
mov    -0x19f0d8(%rbp),%ecx
call   1030 <loce@plt>
mov    %eax,-0x19f0f0(%rbp)
mov    -0x19f0c0(%rbp),%edi
mov    -0x19f0fc(%rbp),%esi
lea    -0x19f0b0(%rbp),%rdx
xor    %ecx,%ecx
call   1070 <loc@plt>
mov    %eax,-0x19f0dc(%rbp)
mov    -0x19f0c4(%rbp),%edi
mov    -0x19f0fc(%rbp),%esi
lea    -0x19f0b0(%rbp),%rdx
mov    -0x19f0dc(%rbp),%ecx
call   1030 <loce@plt>
mov    %eax,-0x19f0f4(%rbp)
mov    -0x19f0d8(%rbp),%eax
mov    %eax,-0x19f0cc(%rbp)
mov    -0x19f0cc(%rbp),%eax
cmp    -0x19f0f0(%rbp),%eax
jge    1627 <main+0x4d7>
mov    -0x19f0dc(%rbp),%eax
mov    %eax,-0x19f0d0(%rbp)
mov    -0x19f0d0(%rbp),%eax
cmp    -0x19f0f4(%rbp),%eax
jge    160e <main+0x4be>
movslq -0x19f0cc(%rbp),%rcx
lea    -0x19f0b0(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x19f0f8(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
movslq -0x19f0d0(%rbp),%rdx
lea    -0x19f0b0(%rbp),%rcx
shl    $0x4,%rdx
add    %rdx,%rcx
movslq -0x19f0fc(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    15f5 <main+0x4a5>
mov    -0x19f0b8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x19f0b8(%rbp)
jmp    15fa <main+0x4aa>
mov    -0x19f0d0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x19f0d0(%rbp)
jmp    158d <main+0x43d>
jmp    1613 <main+0x4c3>
mov    -0x19f0cc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x19f0cc(%rbp)
jmp    156f <main+0x41f>
mov    -0x19f0b8(%rbp),%rsi
lea    0xa0c(%rip),%rdi
call   1050 <printf@plt>
jmp    139c <main+0x24c>
xor    %eax,%eax
add    $0x19f110,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x19f0d8,%rsp
mov    $0x70,%eax
movdqa 0xe92(%rip),%xmm0
xchg   %ax,%ax
movdqa %xmm0,0x18660(%rsp,%rax,1)
movdqa %xmm0,0x18670(%rsp,%rax,1)
movdqa %xmm0,0x18680(%rsp,%rax,1)
movdqa %xmm0,0x18690(%rsp,%rax,1)
movdqa %xmm0,0x186a0(%rsp,%rax,1)
movdqa %xmm0,0x186b0(%rsp,%rax,1)
movdqa %xmm0,0x186c0(%rsp,%rax,1)
movdqa %xmm0,0x186d0(%rsp,%rax,1)
sub    $0xffffffffffffff80,%rax
cmp    $0x186a70,%rax
jne    1170 <main+0x20>
lea    0xe55(%rip),%rdi
lea    0x30(%rsp),%rbx
mov    %rbx,%rsi
xor    %eax,%eax
call   1060 <scanf@plt>
mov    %rbx,%rdi
call   1040 <strlen@plt>
test   %eax,%eax
jle    1281 <main+0x131>
mov    %eax,%eax
mov    $0xffffffff,%esi
xor    %edx,%edx
lea    0x186d0(%rsp),%r8
mov    $0xffffffff,%edi
mov    $0xffffffff,%ebp
mov    $0xffffffff,%ebx
jmp    1228 <main+0xd8>
nopl   0x0(%rax)
movslq %edi,%rcx
add    $0x1,%edi
shl    $0x4,%rcx
mov    %edx,0x18(%rcx,%r8,1)
add    $0x1,%rdx
cmp    %rdx,%rax
je     1281 <main+0x131>
movzbl 0x30(%rsp,%rdx,1),%ecx
cmp    $0x68,%cl
je     1250 <main+0x100>
cmp    $0x65,%cl
je     1210 <main+0xc0>
cmp    $0x63,%cl
jne    1270 <main+0x120>
movslq %ebx,%rcx
add    $0x1,%ebx
shl    $0x4,%rcx
mov    %edx,0x10(%rcx,%r8,1)
jmp    121f <main+0xcf>
nopl   (%rax)
movslq %ebp,%rcx
add    $0x1,%ebp
shl    $0x4,%rcx
mov    %edx,0x14(%rcx,%r8,1)
jmp    121f <main+0xcf>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movslq %esi,%rcx
add    $0x1,%esi
shl    $0x4,%rcx
mov    %edx,0x1c(%rcx,%r8,1)
jmp    121f <main+0xcf>
lea    0xda6(%rip),%rdi
lea    0x14(%rsp),%rsi
xor    %eax,%eax
call   1060 <scanf@plt>
subl   $0x1,0x14(%rsp)
jae    12af <main+0x15f>
xor    %eax,%eax
add    $0x19f0d8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
jmp    12d5 <main+0x185>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xor    %esi,%esi
lea    0xd68(%rip),%rdi
call   1050 <printf@plt>
subl   $0x1,0x14(%rsp)
jb     129b <main+0x14b>
lea    0xd48(%rip),%rdi
lea    0xb(%rsp),%rsi
lea    0xa(%rsp),%rdx
lea    0x10(%rsp),%rcx
lea    0xc(%rsp),%r8
xor    %eax,%eax
call   1060 <scanf@plt>
addl   $0xffffffff,0xc(%rsp)
mov    0x10(%rsp),%edi
add    $0xffffffff,%edi
mov    %edi,0x10(%rsp)
movsbl 0xb(%rsp),%eax
lea    -0x63(%rax),%ecx
cmp    $0x5,%ecx
mov    0x1c(%rsp),%r15d
mov    0x18(%rsp),%r12d
ja     1339 <main+0x1e9>
mov    $0x2d,%edx
bt     %ecx,%edx
jae    1339 <main+0x1e9>
cltq
lea    0xd07(%rip),%rcx
mov    -0x18c(%rcx,%rax,4),%r12d
ff
movsbl 0xa(%rsp),%eax
lea    -0x63(%rax),%ecx
cmp    $0x5,%ecx
ja     1361 <main+0x211>
mov    $0x2d,%edx
bt     %ecx,%edx
jae    1361 <main+0x211>
cltq
lea    0xcdf(%rip),%rcx
mov    -0x18c(%rcx,%rax,4),%r15d
ff
mov    %r12d,%esi
lea    0x186d0(%rsp),%rbp
mov    %rbp,%rdx
xor    %ecx,%ecx
call   1070 <loc@plt>
mov    %eax,%ebx
mov    0xc(%rsp),%edi
mov    %r12d,%esi
mov    %rbp,%rdx
mov    %eax,%ecx
call   1030 <loce@plt>
mov    %eax,%r14d
mov    0x10(%rsp),%edi
mov    %r15d,%esi
mov    %rbp,%rdx
xor    %ecx,%ecx
call   1070 <loc@plt>
mov    %eax,%r13d
mov    0xc(%rsp),%edi
mov    %r15d,%esi
mov    %rbp,%rdx
mov    %eax,%ecx
call   1030 <loce@plt>
cmp    %r14d,%ebx
mov    %r15d,0x1c(%rsp)
mov    %r12d,0x18(%rsp)
jge    12c0 <main+0x170>
movslq %r12d,%r9
movslq %r15d,%rcx
movslq %r13d,%rsi
movslq %ebx,%rdi
movslq %r14d,%rbx
movslq %eax,%r11
mov    %r11,%rbp
sub    %rsi,%rbp
mov    %ebp,%r12d
and    $0x3,%r12d
test   %r12,%r12
mov    $0x4,%edx
cmove  %rdx,%r12
mov    %rbp,%r10
sub    %r12,%r10
add    %rsi,%r10
add    %rsi,%r12
sub    %r11,%r12
mov    %rsi,0x28(%rsp)
lea    (%rcx,%rsi,4),%rdx
lea    0x18700(%rsp),%rsi
lea    (%rsi,%rdx,4),%rdx
mov    %rdx,0x20(%rsp)
lea    (%rsp,%rcx,4),%rdx
add    $0x186d0,%rdx
xor    %esi,%esi
jmp    143d <main+0x2ed>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rdi
cmp    %rbx,%rdi
je     12c2 <main+0x172>
cmp    %eax,%r13d
jge    1430 <main+0x2e0>
mov    %rdi,%rcx
shl    $0x4,%rcx
add    %rsp,%rcx
add    $0x186d0,%rcx
mov    (%rcx,%r9,4),%r15d
cmp    $0x5,%rbp
jae    1470 <main+0x320>
mov    0x28(%rsp),%rcx
jmp    1501 <main+0x3b1>
nopw   0x0(%rax,%rax,1)
movq   %rsi,%xmm0
movd   %r15d,%xmm1
pshufd $0x50,%xmm1,%xmm2
pxor   %xmm1,%xmm1
mov    0x20(%rsp),%rsi
mov    %r12,%rcx
movdqa 0xb7d(%rip),%xmm6
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movd   -0x20(%rsi),%xmm3
movd   -0x30(%rsi),%xmm4
punpckldq %xmm3,%xmm4
movd   (%rsi),%xmm3
movd   -0x10(%rsi),%xmm5
punpckldq %xmm3,%xmm5
pshufd $0xd4,%xmm4,%xmm3
pshufd $0xd4,%xmm2,%xmm4
pcmpgtd %xmm4,%xmm3
pand   %xmm6,%xmm3
paddq  %xmm3,%xmm0
pshufd $0xd4,%xmm5,%xmm3
pcmpgtd %xmm4,%xmm3
pand   %xmm6,%xmm3
paddq  %xmm3,%xmm1
add    $0x40,%rsi
add    $0x4,%rcx
jne    14a0 <main+0x350>
paddq  %xmm0,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddq  %xmm1,%xmm0
movq   %xmm0,%rsi
mov    %r10,%rcx
mov    %r11,%r14
sub    %rcx,%r14
shl    $0x4,%rcx
add    %rdx,%rcx
xchg   %ax,%ax
xor    %r8d,%r8d
cmp    (%rcx),%r15d
setl   %r8b
add    %r8,%rsi
add    $0x10,%rcx
add    $0xffffffffffffffff,%r14
jne    1510 <main+0x3c0>
jmp    1430 <main+0x2e0>

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

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