#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*/ proc(unsigned char ***, int, int, int, int, unsigned char,
                        unsigned char);
unsigned int strlen(char *);
int stringReduction(char a[]) {
  unsigned int len = strlen(a);
  unsigned char l[100][100][3];
  for (int i = 0; i < len; i++) {
    if ('a' == a[i]) {
      l[i][i][0] = 1;
      l[i][i][1] = 0;
      l[i][i][2] = 0;
    } else if ('b' == a[i]) {
      l[i][i][0] = 0;
      l[i][i][1] = 1;
      l[i][i][2] = 0;
    } else {
      l[i][i][0] = 0;
      l[i][i][1] = 0;
      l[i][i][2] = 1;
    }
  }
  for (int step = 1; step < len; step++) {
    for (int i = 0; i < len - step; i++) {
      l[i][i + step][0] = 0;
      l[i][i + step][1] = 0;
      l[i][i + step][2] = 0;
      for (int j = i; j < i + step; j++) {
        if (l[i][j][0]) {
          if (l[j + 1][i + step][0]) {
            if (0 == l[i][i + step][0] ||
                l[i][i + step][0] > (l[i][j][0] + l[j + 1][i + step][0])) {
              l[i][i + step][0] = l[i][j][0] + l[j + 1][i + step][0];
            }
          }
          if (l[j + 1][i + step][1]) {
            proc(l, i, i + step, 0, 1, l[i][j][0], l[j + 1][i + step][1]);
          }
          if (l[j + 1][i + step][2]) {
            proc(l, i, i + step, 0, 2, l[i][j][0], l[j + 1][i + step][2]);
          }
        }
        if (l[i][j][1]) {
          if (l[j + 1][i + step][1]) {
            if (0 == l[i][i + step][1] ||
                l[i][i + step][1] > (l[i][j][1] + l[j + 1][i + step][1])) {
              l[i][i + step][1] = l[i][j][1] + l[j + 1][i + step][1];
            }
          }
          if (l[j + 1][i + step][0]) {
            proc(l, i, i + step, 1, 0, l[i][j][1], l[j + 1][i + step][0]);
          }
          if (l[j + 1][i + step][2]) {
            proc(l, i, i + step, 1, 2, l[i][j][1], l[j + 1][i + step][2]);
          }
        }
        if (l[i][j][2]) {
          if (l[j + 1][i + step][2]) {
            if (0 == l[i][i + step][2] ||
                l[i][i + step][2] > (l[i][j][2] + l[j + 1][i + step][2])) {
              l[i][i + step][2] = l[i][j][2] + l[j + 1][i + step][2];
            }
          }
          if (l[j + 1][i + step][1]) {
            proc(l, i, i + step, 2, 1, l[i][j][2], l[j + 1][i + step][1]);
          }
          if (l[j + 1][i + step][0]) {
            proc(l, i, i + step, 2, 0, l[i][j][2], l[j + 1][i + step][0]);
          }
        }
      }
    }
  }
  int ret;
  ret = l[0][len - 1][0];
  if (0 == ret || (l[0][len - 1][1] && l[0][len - 1][1] < ret)) {
    ret = l[0][len - 1][1];
  }
  if (0 == ret || (l[0][len - 1][2] && l[0][len - 1][2] < ret)) {
    ret = l[0][len - 1][2];
  }
  return ret;
}


x86 assembly (clang, -O0):
<stringReduction>:
push   %rbp
mov    %rsp,%rbp
sub    $0x7560,%rsp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0xc(%rbp)
movl   $0x0,-0x7544(%rbp)
mov    -0x7544(%rbp),%eax
cmp    -0xc(%rbp),%eax
jae    132b <stringReduction+0x20b>
mov    -0x8(%rbp),%rax
movslq -0x7544(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
mov    $0x61,%eax
cmp    %ecx,%eax
jne    11f2 <stringReduction+0xd2>
movslq -0x7544(%rbp),%rcx
lea    -0x7540(%rbp),%rax
imul   $0x12c,%rcx,%rcx
add    %rcx,%rax
movslq -0x7544(%rbp),%rcx
imul   $0x3,%rcx,%rcx
add    %rcx,%rax
movb   $0x1,(%rax)
movslq -0x7544(%rbp),%rcx
lea    -0x7540(%rbp),%rax
imul   $0x12c,%rcx,%rcx
add    %rcx,%rax
movslq -0x7544(%rbp),%rcx
imul   $0x3,%rcx,%rcx
add    %rcx,%rax
movb   $0x0,0x1(%rax)
movslq -0x7544(%rbp),%rcx
lea    -0x7540(%rbp),%rax
imul   $0x12c,%rcx,%rcx
add    %rcx,%rax
movslq -0x7544(%rbp),%rcx
imul   $0x3,%rcx,%rcx
add    %rcx,%rax
movb   $0x0,0x2(%rax)
jmp    1312 <stringReduction+0x1f2>
mov    -0x8(%rbp),%rax
movslq -0x7544(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
mov    $0x62,%eax
cmp    %ecx,%eax
jne    1290 <stringReduction+0x170>
movslq -0x7544(%rbp),%rcx
lea    -0x7540(%rbp),%rax
imul   $0x12c,%rcx,%rcx
add    %rcx,%rax
movslq -0x7544(%rbp),%rcx
imul   $0x3,%rcx,%rcx
add    %rcx,%rax
movb   $0x0,(%rax)
movslq -0x7544(%rbp),%rcx
lea    -0x7540(%rbp),%rax
imul   $0x12c,%rcx,%rcx
add    %rcx,%rax
movslq -0x7544(%rbp),%rcx
imul   $0x3,%rcx,%rcx
add    %rcx,%rax
movb   $0x1,0x1(%rax)
movslq -0x7544(%rbp),%rcx
lea    -0x7540(%rbp),%rax
imul   $0x12c,%rcx,%rcx
add    %rcx,%rax
movslq -0x7544(%rbp),%rcx
imul   $0x3,%rcx,%rcx
add    %rcx,%rax
movb   $0x0,0x2(%rax)
jmp    130d <stringReduction+0x1ed>
movslq -0x7544(%rbp),%rcx
lea    -0x7540(%rbp),%rax
imul   $0x12c,%rcx,%rcx
add    %rcx,%rax
movslq -0x7544(%rbp),%rcx
imul   $0x3,%rcx,%rcx
add    %rcx,%rax
movb   $0x0,(%rax)
movslq -0x7544(%rbp),%rcx
lea    -0x7540(%rbp),%rax
imul   $0x12c,%rcx,%rcx
add    %rcx,%rax
movslq -0x7544(%rbp),%rcx
imul   $0x3,%rcx,%rcx
add    %rcx,%rax
movb   $0x0,0x1(%rax)
movslq -0x7544(%rbp),%rcx
lea    -0x7540(%rbp),%rax
imul   $0x12c,%rcx,%rcx
add    %rcx,%rax
movslq -0x7544(%rbp),%rcx
imul   $0x3,%rcx,%rcx
add    %rcx,%rax
movb   $0x1,0x2(%rax)
jmp    1312 <stringReduction+0x1f2>
jmp    1317 <stringReduction+0x1f7>
mov    -0x7544(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7544(%rbp)
jmp    1145 <stringReduction+0x25>
movl   $0x1,-0x7548(%rbp)
mov    -0x7548(%rbp),%eax
cmp    -0xc(%rbp),%eax
jae    1ed6 <stringReduction+0xdb6>
movl   $0x0,-0x754c(%rbp)
mov    -0x754c(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    -0x7548(%rbp),%ecx
cmp    %ecx,%eax
jae    1ebd <stringReduction+0xd9d>
movslq -0x754c(%rbp),%rcx
lea    -0x7540(%rbp),%rax
imul   $0x12c,%rcx,%rcx
add    %rcx,%rax
mov    -0x754c(%rbp),%ecx
add    -0x7548(%rbp),%ecx
movslq %ecx,%rcx
imul   $0x3,%rcx,%rcx
add    %rcx,%rax
movb   $0x0,(%rax)
movslq -0x754c(%rbp),%rcx
lea    -0x7540(%rbp),%rax
imul   $0x12c,%rcx,%rcx
add    %rcx,%rax
mov    -0x754c(%rbp),%ecx
add    -0x7548(%rbp),%ecx
movslq %ecx,%rcx
imul   $0x3,%rcx,%rcx
add    %rcx,%rax
movb   $0x0,0x1(%rax)
movslq -0x754c(%rbp),%rcx
lea    -0x7540(%rbp),%rax
imul   $0x12c,%rcx,%rcx
add    %rcx,%rax
mov    -0x754c(%rbp),%ecx
add    -0x7548(%rbp),%ecx
movslq %ecx,%rcx
imul   $0x3,%rcx,%rcx
add    %rcx,%rax
movb   $0x0,0x2(%rax)
mov    -0x754c(%rbp),%eax
mov    %eax,-0x7550(%rbp)
mov    -0x7550(%rbp),%eax
mov    -0x754c(%rbp),%ecx
add    -0x7548(%rbp),%ecx
cmp    %ecx,%eax
jge    1ea4 <stringReduction+0xd84>
movslq -0x754c(%rbp),%rcx
lea    -0x7540(%rbp),%rax
imul   $0x12c,%rcx,%rcx
add    %rcx,%rax
movslq -0x7550(%rbp),%rcx
imul   $0x3,%rcx,%rcx
add    %rcx,%rax
cmpb   $0x0,(%rax)
je     1791 <stringReduction+0x671>
mov    -0x7550(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x7540(%rbp),%rax
imul   $0x12c,%rcx,%rcx
add    %rcx,%rax
mov    -0x754c(%rbp),%ecx
add    -0x7548(%rbp),%ecx
movslq %ecx,%rcx
imul   $0x3,%rcx,%rcx
add    %rcx,%rax
cmpb   $0x0,(%rax)
je     15f8 <stringReduction+0x4d8>
movslq -0x754c(%rbp),%rcx
lea    -0x7540(%rbp),%rax
imul   $0x12c,%rcx,%rcx
add    %rcx,%rax
mov    -0x754c(%rbp),%ecx
add    -0x7548(%rbp),%ecx
movslq %ecx,%rcx
imul   $0x3,%rcx,%rcx
add    %rcx,%rax
movzbl (%rax),%ecx
xor    %eax,%eax
cmp    %ecx,%eax
je     1560 <stringReduction+0x440>
movslq -0x754c(%rbp),%rcx
lea    -0x7540(%rbp),%rax
imul   $0x12c,%rcx,%rcx
add    %rcx,%rax
mov    -0x754c(%rbp),%ecx
add    -0x7548(%rbp),%ecx
movslq %ecx,%rcx
imul   $0x3,%rcx,%rcx
add    %rcx,%rax
movzbl (%rax),%eax
movslq -0x754c(%rbp),%rdx
lea    -0x7540(%rbp),%rcx
imul   $0x12c,%rdx,%rdx
add    %rdx,%rcx
movslq -0x7550(%rbp),%rdx
imul   $0x3,%rdx,%rdx
add    %rdx,%rcx
movzbl (%rcx),%ecx
mov    -0x7550(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rsi
lea    -0x7540(%rbp),%rdx
imul   $0x12c,%rsi,%rsi
add    %rsi,%rdx
mov    -0x754c(%rbp),%esi
add    -0x7548(%rbp),%esi
movslq %esi,%rsi
imul   $0x3,%rsi,%rsi
add    %rsi,%rdx
movzbl (%rdx),%edx
add    %edx,%ecx
cmp    %ecx,%eax
jle    15f3 <stringReduction+0x4d3>
movslq -0x754c(%rbp),%rcx
lea    -0x7540(%rbp),%rax
imul   $0x12c,%rcx,%rcx
add    %rcx,%rax
movslq -0x7550(%rbp),%rcx
imul   $0x3,%rcx,%rcx
add    %rcx,%rax
movzbl (%rax),%eax
mov    -0x7550(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rdx
lea    -0x7540(%rbp),%rcx
imul   $0x12c,%rdx,%rdx
add    %rdx,%rcx
mov    -0x754c(%rbp),%edx
add    -0x7548(%rbp),%edx
movslq %edx,%rdx
imul   $0x3,%rdx,%rdx
add    %rdx,%rcx
movzbl (%rcx),%ecx
add    %ecx,%eax
mov    %al,%cl
movslq -0x754c(%rbp),%rdx
lea    -0x7540(%rbp),%rax
imul   $0x12c,%rdx,%rdx
add    %rdx,%rax
mov    -0x754c(%rbp),%edx
add    -0x7548(%rbp),%edx
movslq %edx,%rdx
imul   $0x3,%rdx,%rdx
add    %rdx,%rax
mov    %cl,(%rax)
jmp    15f8 <stringReduction+0x4d8>
mov    -0x7550(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x7540(%rbp),%rax
imul   $0x12c,%rcx,%rcx
add    %rcx,%rax
mov    -0x754c(%rbp),%ecx
add    -0x7548(%rbp),%ecx
movslq %ecx,%rcx
imul   $0x3,%rcx,%rcx
add    %rcx,%rax
cmpb   $0x0,0x1(%rax)
je     16c2 <stringReduction+0x5a2>
lea    -0x7540(%rbp),%rdi
mov    -0x754c(%rbp),%esi
mov    -0x754c(%rbp),%edx
add    -0x7548(%rbp),%edx
movslq -0x754c(%rbp),%rcx
lea    -0x7540(%rbp),%rax
imul   $0x12c,%rcx,%rcx
add    %rcx,%rax
movslq -0x7550(%rbp),%rcx
imul   $0x3,%rcx,%rcx
add    %rcx,%rax
mov    (%rax),%r9b
mov    -0x7550(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x7540(%rbp),%rax
imul   $0x12c,%rcx,%rcx
add    %rcx,%rax
mov    -0x754c(%rbp),%ecx
add    -0x7548(%rbp),%ecx
movslq %ecx,%rcx
imul   $0x3,%rcx,%rcx
add    %rcx,%rax
xor    %ecx,%ecx
mov    $0x1,%r8d
movzbl %r9b,%r9d
movzbl 0x1(%rax),%eax
mov    %eax,(%rsp)
call   1040 <proc@plt>
mov    -0x7550(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x7540(%rbp),%rax
imul   $0x12c,%rcx,%rcx
add    %rcx,%rax
mov    -0x754c(%rbp),%ecx
add    -0x7548(%rbp),%ecx
movslq %ecx,%rcx
imul   $0x3,%rcx,%rcx
add    %rcx,%rax
cmpb   $0x0,0x2(%rax)
je     178c <stringReduction+0x66c>
lea    -0x7540(%rbp),%rdi
mov    -0x754c(%rbp),%esi
mov    -0x754c(%rbp),%edx
add    -0x7548(%rbp),%edx
movslq -0x754c(%rbp),%rcx
lea    -0x7540(%rbp),%rax
imul   $0x12c,%rcx,%rcx
add    %rcx,%rax
movslq -0x7550(%rbp),%rcx
imul   $0x3,%rcx,%rcx
add    %rcx,%rax
mov    (%rax),%r9b
mov    -0x7550(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x7540(%rbp),%rax
imul   $0x12c,%rcx,%rcx
add    %rcx,%rax
mov    -0x754c(%rbp),%ecx
add    -0x7548(%rbp),%ecx
movslq %ecx,%rcx
imul   $0x3,%rcx,%rcx
add    %rcx,%rax
xor    %ecx,%ecx
mov    $0x2,%r8d
movzbl %r9b,%r9d
movzbl 0x2(%rax),%eax
mov    %eax,(%rsp)
call   1040 <proc@plt>
jmp    1791 <stringReduction+0x671>
movslq -0x754c(%rbp),%rcx
lea    -0x7540(%rbp),%rax
imul   $0x12c,%rcx,%rcx
add    %rcx,%rax
movslq -0x7550(%rbp),%rcx
imul   $0x3,%rcx,%rcx
add    %rcx,%rax
cmpb   $0x0,0x1(%rax)
je     1b0e <stringReduction+0x9ee>
mov    -0x7550(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x7540(%rbp),%rax
imul   $0x12c,%rcx,%rcx
add    %rcx,%rax
mov    -0x754c(%rbp),%ecx
add    -0x7548(%rbp),%ecx
movslq %ecx,%rcx
imul   $0x3,%rcx,%rcx
add    %rcx,%rax
cmpb   $0x0,0x1(%rax)
je     1972 <stringReduction+0x852>
movslq -0x754c(%rbp),%rcx
lea    -0x7540(%rbp),%rax
imul   $0x12c,%rcx,%rcx
add    %rcx,%rax
mov    -0x754c(%rbp),%ecx
add    -0x7548(%rbp),%ecx
movslq %ecx,%rcx
imul   $0x3,%rcx,%rcx
add    %rcx,%rax
movzbl 0x1(%rax),%ecx
xor    %eax,%eax
cmp    %ecx,%eax
je     18d7 <stringReduction+0x7b7>
movslq -0x754c(%rbp),%rcx
lea    -0x7540(%rbp),%rax
imul   $0x12c,%rcx,%rcx
add    %rcx,%rax
mov    -0x754c(%rbp),%ecx
add    -0x7548(%rbp),%ecx
movslq %ecx,%rcx
imul   $0x3,%rcx,%rcx
add    %rcx,%rax
movzbl 0x1(%rax),%eax
movslq -0x754c(%rbp),%rdx
lea    -0x7540(%rbp),%rcx
imul   $0x12c,%rdx,%rdx
add    %rdx,%rcx
movslq -0x7550(%rbp),%rdx
imul   $0x3,%rdx,%rdx
add    %rdx,%rcx
movzbl 0x1(%rcx),%ecx
mov    -0x7550(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rsi
lea    -0x7540(%rbp),%rdx
imul   $0x12c,%rsi,%rsi
add    %rsi,%rdx
mov    -0x754c(%rbp),%esi
add    -0x7548(%rbp),%esi
movslq %esi,%rsi
imul   $0x3,%rsi,%rsi
add    %rsi,%rdx
movzbl 0x1(%rdx),%edx
add    %edx,%ecx
cmp    %ecx,%eax
jle    196d <stringReduction+0x84d>
movslq -0x754c(%rbp),%rcx
lea    -0x7540(%rbp),%rax
imul   $0x12c,%rcx,%rcx
add    %rcx,%rax
movslq -0x7550(%rbp),%rcx
imul   $0x3,%rcx,%rcx
add    %rcx,%rax
movzbl 0x1(%rax),%eax
mov    -0x7550(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rdx
lea    -0x7540(%rbp),%rcx
imul   $0x12c,%rdx,%rdx
add    %rdx,%rcx
mov    -0x754c(%rbp),%edx
add    -0x7548(%rbp),%edx
movslq %edx,%rdx
imul   $0x3,%rdx,%rdx
add    %rdx,%rcx
movzbl 0x1(%rcx),%ecx
add    %ecx,%eax
mov    %al,%cl
movslq -0x754c(%rbp),%rdx
lea    -0x7540(%rbp),%rax
imul   $0x12c,%rdx,%rdx
add    %rdx,%rax
mov    -0x754c(%rbp),%edx
add    -0x7548(%rbp),%edx
movslq %edx,%rdx
imul   $0x3,%rdx,%rdx
add    %rdx,%rax
mov    %cl,0x1(%rax)
jmp    1972 <stringReduction+0x852>
mov    -0x7550(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x7540(%rbp),%rax
imul   $0x12c,%rcx,%rcx
add    %rcx,%rax
mov    -0x754c(%rbp),%ecx
add    -0x7548(%rbp),%ecx
movslq %ecx,%rcx
imul   $0x3,%rcx,%rcx
add    %rcx,%rax
cmpb   $0x0,(%rax)
je     1a3b <stringReduction+0x91b>
lea    -0x7540(%rbp),%rdi
mov    -0x754c(%rbp),%esi
mov    -0x754c(%rbp),%edx
add    -0x7548(%rbp),%edx
movslq -0x754c(%rbp),%rcx
lea    -0x7540(%rbp),%rax
imul   $0x12c,%rcx,%rcx
add    %rcx,%rax
movslq -0x7550(%rbp),%rcx
imul   $0x3,%rcx,%rcx
add    %rcx,%rax
mov    0x1(%rax),%r9b
mov    -0x7550(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x7540(%rbp),%rax
imul   $0x12c,%rcx,%rcx
add    %rcx,%rax
mov    -0x754c(%rbp),%ecx
add    -0x7548(%rbp),%ecx
movslq %ecx,%rcx
imul   $0x3,%rcx,%rcx
add    %rcx,%rax
mov    $0x1,%ecx
xor    %r8d,%r8d
movzbl %r9b,%r9d
movzbl (%rax),%eax
mov    %eax,(%rsp)
call   1040 <proc@plt>
mov    -0x7550(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x7540(%rbp),%rax
imul   $0x12c,%rcx,%rcx
add    %rcx,%rax
mov    -0x754c(%rbp),%ecx
add    -0x7548(%rbp),%ecx
movslq %ecx,%rcx
imul   $0x3,%rcx,%rcx
add    %rcx,%rax
cmpb   $0x0,0x2(%rax)
je     1b09 <stringReduction+0x9e9>
lea    -0x7540(%rbp),%rdi
mov    -0x754c(%rbp),%esi
mov    -0x754c(%rbp),%edx
add    -0x7548(%rbp),%edx
movslq -0x754c(%rbp),%rcx
lea    -0x7540(%rbp),%rax
imul   $0x12c,%rcx,%rcx
add    %rcx,%rax
movslq -0x7550(%rbp),%rcx
imul   $0x3,%rcx,%rcx
add    %rcx,%rax
mov    0x1(%rax),%r9b
mov    -0x7550(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x7540(%rbp),%rax
imul   $0x12c,%rcx,%rcx
add    %rcx,%rax
mov    -0x754c(%rbp),%ecx
add    -0x7548(%rbp),%ecx
movslq %ecx,%rcx
imul   $0x3,%rcx,%rcx
add    %rcx,%rax
mov    $0x1,%ecx
mov    $0x2,%r8d
movzbl %r9b,%r9d
movzbl 0x2(%rax),%eax
mov    %eax,(%rsp)
call   1040 <proc@plt>
jmp    1b0e <stringReduction+0x9ee>
movslq -0x754c(%rbp),%rcx
lea    -0x7540(%rbp),%rax
imul   $0x12c,%rcx,%rcx
add    %rcx,%rax
movslq -0x7550(%rbp),%rcx
imul   $0x3,%rcx,%rcx
add    %rcx,%rax
cmpb   $0x0,0x2(%rax)
je     1e8b <stringReduction+0xd6b>
mov    -0x7550(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x7540(%rbp),%rax
imul   $0x12c,%rcx,%rcx
add    %rcx,%rax
mov    -0x754c(%rbp),%ecx
add    -0x7548(%rbp),%ecx
movslq %ecx,%rcx
imul   $0x3,%rcx,%rcx
add    %rcx,%rax
cmpb   $0x0,0x2(%rax)
je     1cef <stringReduction+0xbcf>
movslq -0x754c(%rbp),%rcx
lea    -0x7540(%rbp),%rax
imul   $0x12c,%rcx,%rcx
add    %rcx,%rax
mov    -0x754c(%rbp),%ecx
add    -0x7548(%rbp),%ecx
movslq %ecx,%rcx
imul   $0x3,%rcx,%rcx
add    %rcx,%rax
movzbl 0x2(%rax),%ecx
xor    %eax,%eax
cmp    %ecx,%eax
je     1c54 <stringReduction+0xb34>
movslq -0x754c(%rbp),%rcx
lea    -0x7540(%rbp),%rax
imul   $0x12c,%rcx,%rcx
add    %rcx,%rax
mov    -0x754c(%rbp),%ecx
add    -0x7548(%rbp),%ecx
movslq %ecx,%rcx
imul   $0x3,%rcx,%rcx
add    %rcx,%rax
movzbl 0x2(%rax),%eax
movslq -0x754c(%rbp),%rdx
lea    -0x7540(%rbp),%rcx
imul   $0x12c,%rdx,%rdx
add    %rdx,%rcx
movslq -0x7550(%rbp),%rdx
imul   $0x3,%rdx,%rdx
add    %rdx,%rcx
movzbl 0x2(%rcx),%ecx
mov    -0x7550(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rsi
lea    -0x7540(%rbp),%rdx
imul   $0x12c,%rsi,%rsi
add    %rsi,%rdx
mov    -0x754c(%rbp),%esi
add    -0x7548(%rbp),%esi
movslq %esi,%rsi
imul   $0x3,%rsi,%rsi
add    %rsi,%rdx
movzbl 0x2(%rdx),%edx
add    %edx,%ecx
cmp    %ecx,%eax
jle    1cea <stringReduction+0xbca>
movslq -0x754c(%rbp),%rcx
lea    -0x7540(%rbp),%rax
imul   $0x12c,%rcx,%rcx
add    %rcx,%rax
movslq -0x7550(%rbp),%rcx
imul   $0x3,%rcx,%rcx
add    %rcx,%rax
movzbl 0x2(%rax),%eax
mov    -0x7550(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rdx
lea    -0x7540(%rbp),%rcx
imul   $0x12c,%rdx,%rdx
add    %rdx,%rcx
mov    -0x754c(%rbp),%edx
add    -0x7548(%rbp),%edx
movslq %edx,%rdx
imul   $0x3,%rdx,%rdx
add    %rdx,%rcx
movzbl 0x2(%rcx),%ecx
add    %ecx,%eax
mov    %al,%cl
movslq -0x754c(%rbp),%rdx
lea    -0x7540(%rbp),%rax
imul   $0x12c,%rdx,%rdx
add    %rdx,%rax
mov    -0x754c(%rbp),%edx
add    -0x7548(%rbp),%edx
movslq %edx,%rdx
imul   $0x3,%rdx,%rdx
add    %rdx,%rax
mov    %cl,0x2(%rax)
jmp    1cef <stringReduction+0xbcf>
mov    -0x7550(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x7540(%rbp),%rax
imul   $0x12c,%rcx,%rcx
add    %rcx,%rax
mov    -0x754c(%rbp),%ecx
add    -0x7548(%rbp),%ecx
movslq %ecx,%rcx
imul   $0x3,%rcx,%rcx
add    %rcx,%rax
cmpb   $0x0,0x1(%rax)
je     1dbd <stringReduction+0xc9d>
lea    -0x7540(%rbp),%rdi
mov    -0x754c(%rbp),%esi
mov    -0x754c(%rbp),%edx
add    -0x7548(%rbp),%edx
movslq -0x754c(%rbp),%rcx
lea    -0x7540(%rbp),%rax
imul   $0x12c,%rcx,%rcx
add    %rcx,%rax
movslq -0x7550(%rbp),%rcx
imul   $0x3,%rcx,%rcx
add    %rcx,%rax
mov    0x2(%rax),%r9b
mov    -0x7550(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x7540(%rbp),%rax
imul   $0x12c,%rcx,%rcx
add    %rcx,%rax
mov    -0x754c(%rbp),%ecx
add    -0x7548(%rbp),%ecx
movslq %ecx,%rcx
imul   $0x3,%rcx,%rcx
add    %rcx,%rax
mov    $0x2,%ecx
mov    $0x1,%r8d
movzbl %r9b,%r9d
movzbl 0x1(%rax),%eax
mov    %eax,(%rsp)
call   1040 <proc@plt>
mov    -0x7550(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x7540(%rbp),%rax
imul   $0x12c,%rcx,%rcx
add    %rcx,%rax
mov    -0x754c(%rbp),%ecx
add    -0x7548(%rbp),%ecx
movslq %ecx,%rcx
imul   $0x3,%rcx,%rcx
add    %rcx,%rax
cmpb   $0x0,(%rax)
je     1e86 <stringReduction+0xd66>
lea    -0x7540(%rbp),%rdi
mov    -0x754c(%rbp),%esi
mov    -0x754c(%rbp),%edx
add    -0x7548(%rbp),%edx
movslq -0x754c(%rbp),%rcx
lea    -0x7540(%rbp),%rax
imul   $0x12c,%rcx,%rcx
add    %rcx,%rax
movslq -0x7550(%rbp),%rcx
imul   $0x3,%rcx,%rcx
add    %rcx,%rax
mov    0x2(%rax),%r9b
mov    -0x7550(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x7540(%rbp),%rax
imul   $0x12c,%rcx,%rcx
add    %rcx,%rax
mov    -0x754c(%rbp),%ecx
add    -0x7548(%rbp),%ecx
movslq %ecx,%rcx
imul   $0x3,%rcx,%rcx
add    %rcx,%rax
mov    $0x2,%ecx
xor    %r8d,%r8d
movzbl %r9b,%r9d
movzbl (%rax),%eax
mov    %eax,(%rsp)
call   1040 <proc@plt>
jmp    1e8b <stringReduction+0xd6b>
jmp    1e90 <stringReduction+0xd70>
mov    -0x7550(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7550(%rbp)
jmp    1406 <stringReduction+0x2e6>
jmp    1ea9 <stringReduction+0xd89>
mov    -0x754c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x754c(%rbp)
jmp    134e <stringReduction+0x22e>
jmp    1ec2 <stringReduction+0xda2>
mov    -0x7548(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7548(%rbp)
jmp    1335 <stringReduction+0x215>
lea    -0x7540(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
imul   $0x3,%rcx,%rcx
add    %rcx,%rax
movzbl (%rax),%eax
mov    %eax,-0x7554(%rbp)
xor    %eax,%eax
cmp    -0x7554(%rbp),%eax
je     1f4c <stringReduction+0xe2c>
lea    -0x7540(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
imul   $0x3,%rcx,%rcx
add    %rcx,%rax
movzbl 0x1(%rax),%eax
cmp    $0x0,%eax
je     1f6c <stringReduction+0xe4c>
lea    -0x7540(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
imul   $0x3,%rcx,%rcx
add    %rcx,%rax
movzbl 0x1(%rax),%eax
cmp    -0x7554(%rbp),%eax
jge    1f6c <stringReduction+0xe4c>
lea    -0x7540(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
imul   $0x3,%rcx,%rcx
add    %rcx,%rax
movzbl 0x1(%rax),%eax
mov    %eax,-0x7554(%rbp)
xor    %eax,%eax
cmp    -0x7554(%rbp),%eax
je     1fc3 <stringReduction+0xea3>
lea    -0x7540(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
imul   $0x3,%rcx,%rcx
add    %rcx,%rax
movzbl 0x2(%rax),%eax
cmp    $0x0,%eax
je     1fe3 <stringReduction+0xec3>
lea    -0x7540(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
imul   $0x3,%rcx,%rcx
add    %rcx,%rax
movzbl 0x2(%rax),%eax
cmp    -0x7554(%rbp),%eax
jge    1fe3 <stringReduction+0xec3>
lea    -0x7540(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
imul   $0x3,%rcx,%rcx
add    %rcx,%rax
movzbl 0x2(%rax),%eax
mov    %eax,-0x7554(%rbp)
mov    -0x7554(%rbp),%eax
add    $0x7560,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<stringReduction>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x7588,%rsp
mov    %rdi,%r14
call   1030 <strlen@plt>
test   %eax,%eax
je     1450 <stringReduction+0x330>
mov    %eax,%ebx
lea    0x52(%rsp),%rbp
xor    %ecx,%ecx
jmp    1172 <stringReduction+0x52>
nopl   0x0(%rax)
mov    $0x1,%dil
xor    %edx,%edx
xor    %esi,%esi
mov    %dl,-0x2(%rbp)
mov    %sil,-0x1(%rbp)
mov    %dil,0x0(%rbp)
add    $0x1,%rcx
add    $0x12f,%rbp
cmp    %rcx,%rbx
je     1198 <stringReduction+0x78>
movzbl (%r14,%rcx,1),%edx
cmp    $0x61,%dl
je     1190 <stringReduction+0x70>
cmp    $0x62,%dl
jne    1150 <stringReduction+0x30>
mov    $0x1,%sil
xor    %edx,%edx
xor    %edi,%edi
jmp    1157 <stringReduction+0x37>
nopw   0x0(%rax,%rax,1)
mov    $0x1,%dl
xor    %esi,%esi
xor    %edi,%edi
jmp    1157 <stringReduction+0x37>
cmp    $0x1,%eax
jbe    1450 <stringReduction+0x330>
lea    -0x1(%rax),%ecx
lea    0x181(%rsp),%rdx
mov    %rdx,0x10(%rsp)
mov    $0x1,%edx
mov    $0x3,%esi
mov    %rsi,0x20(%rsp)
mov    %ecx,0xc(%rsp)
mov    %ecx,0x8(%rsp)
mov    %rax,0x30(%rsp)
mov    %rbx,0x28(%rsp)
jmp    1208 <stringReduction+0xe8>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rdx
addl   $0xffffffff,0x8(%rsp)
addq   $0x3,0x20(%rsp)
addq   $0x3,0x10(%rsp)
mov    0x28(%rsp),%rbx
cmp    %rbx,%rdx
mov    0x30(%rsp),%rax
je     1455 <stringReduction+0x335>
cmp    %edx,%eax
je     11e0 <stringReduction+0xc0>
mov    0x8(%rsp),%eax
mov    %rax,0x38(%rsp)
lea    0x52(%rsp),%r13
mov    0x10(%rsp),%r12
xor    %ebx,%ebx
mov    %rdx,0x40(%rsp)
jmp    1253 <stringReduction+0x133>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rbx
mov    0x48(%rsp),%r12
add    $0x12f,%r12
add    $0x12f,%r13
cmp    0x38(%rsp),%rbx
mov    0x40(%rsp),%rdx
je     11e0 <stringReduction+0xc0>
lea    (%rbx,%rdx,1),%rax
lea    (%rbx,%rdx,1),%ebp
lea    (%rax,%rax,2),%rax
imul   $0x12c,%rbx,%rcx
add    %rsp,%rcx
add    $0x50,%rcx
lea    (%rcx,%rax,1),%rdx
mov    %rdx,0x18(%rsp)
movw   $0x0,(%rcx,%rax,1)
lea    (%rcx,%rax,1),%r14
add    $0x1,%r14
movb   $0x0,0x2(%rcx,%rax,1)
mov    %r12,0x48(%rsp)
xor    %r15d,%r15d
jmp    12b6 <stringReduction+0x196>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x3,%r15
add    $0x12c,%r12
cmp    %r15,0x20(%rsp)
je     1230 <stringReduction+0x110>
movzbl -0x2(%r13,%r15,1),%eax
test   %eax,%eax
je     133d <stringReduction+0x21d>
movzbl -0x2(%r12),%ecx
test   %ecx,%ecx
je     12e6 <stringReduction+0x1c6>
mov    0x18(%rsp),%rdx
movzbl (%rdx),%edx
test   %edx,%edx
je     12dd <stringReduction+0x1bd>
lea    (%rcx,%rax,1),%esi
cmp    %edx,%esi
jae    12e6 <stringReduction+0x1c6>
add    %cl,%al
mov    0x18(%rsp),%rcx
mov    %al,(%rcx)
movzbl -0x1(%r12),%eax
test   %al,%al
je     1312 <stringReduction+0x1f2>
movzbl -0x2(%r13,%r15,1),%r9d
movzbl %al,%eax
mov    %eax,(%rsp)
lea    0x50(%rsp),%rdi
mov    %ebx,%esi
mov    %ebp,%edx
xor    %ecx,%ecx
mov    $0x1,%r8d
call   1040 <proc@plt>
movzbl (%r12),%eax
test   %al,%al
je     133d <stringReduction+0x21d>
movzbl -0x2(%r13,%r15,1),%r9d
movzbl %al,%eax
mov    %eax,(%rsp)
lea    0x50(%rsp),%rdi
mov    %ebx,%esi
mov    %ebp,%edx
xor    %ecx,%ecx
mov    $0x2,%r8d
call   1040 <proc@plt>
movzbl -0x1(%r13,%r15,1),%eax
test   %eax,%eax
je     13bf <stringReduction+0x29f>
movzbl -0x1(%r12),%ecx
test   %ecx,%ecx
je     1365 <stringReduction+0x245>
movzbl (%r14),%edx
test   %edx,%edx
je     1360 <stringReduction+0x240>
lea    (%rcx,%rax,1),%esi
cmp    %edx,%esi
jae    1365 <stringReduction+0x245>
add    %cl,%al
mov    %al,(%r14)
movzbl -0x2(%r12),%eax
test   %al,%al
je     1391 <stringReduction+0x271>
movzbl -0x1(%r13,%r15,1),%r9d
movzbl %al,%eax
mov    %eax,(%rsp)
lea    0x50(%rsp),%rdi
mov    %ebx,%esi
mov    %ebp,%edx
mov    $0x1,%ecx
xor    %r8d,%r8d
call   1040 <proc@plt>
movzbl (%r12),%eax
test   %al,%al
je     13bf <stringReduction+0x29f>
movzbl -0x1(%r13,%r15,1),%r9d
movzbl %al,%eax
mov    %eax,(%rsp)
lea    0x50(%rsp),%rdi
mov    %ebx,%esi
mov    %ebp,%edx
mov    $0x1,%ecx
mov    $0x2,%r8d
call   1040 <proc@plt>
movzbl 0x0(%r13,%r15,1),%eax
test   %eax,%eax
je     12a0 <stringReduction+0x180>
movzbl (%r12),%ecx
test   %ecx,%ecx
je     13ec <stringReduction+0x2cc>
movzbl 0x1(%r14),%edx
test   %edx,%edx
je     13e6 <stringReduction+0x2c6>
lea    (%rcx,%rax,1),%esi
cmp    %edx,%esi
jae    13ec <stringReduction+0x2cc>
add    %cl,%al
mov    %al,0x1(%r14)
movzbl -0x1(%r12),%eax
test   %al,%al
je     141b <stringReduction+0x2fb>
movzbl 0x0(%r13,%r15,1),%r9d
movzbl %al,%eax
mov    %eax,(%rsp)
lea    0x50(%rsp),%rdi
mov    %ebx,%esi
mov    %ebp,%edx
mov    $0x2,%ecx
mov    $0x1,%r8d
call   1040 <proc@plt>
movzbl -0x2(%r12),%eax
test   %al,%al
je     12a0 <stringReduction+0x180>
movzbl 0x0(%r13,%r15,1),%r9d
movzbl %al,%eax
mov    %eax,(%rsp)
lea    0x50(%rsp),%rdi
mov    %ebx,%esi
mov    %ebp,%edx
mov    $0x2,%ecx
xor    %r8d,%r8d
call   1040 <proc@plt>
jmp    12a0 <stringReduction+0x180>
add    $0xffffffff,%eax
jmp    1459 <stringReduction+0x339>
mov    0xc(%rsp),%eax
mov    %eax,%eax
lea    (%rax,%rax,2),%rcx
mov    0x50(%rsp,%rcx,1),%dl
mov    0x51(%rsp,%rcx,1),%al
test   %dl,%dl
je     1480 <stringReduction+0x360>
cmp    %dl,%al
movzbl %al,%esi
movzbl %dl,%edx
mov    %edx,%eax
cmovb  %esi,%eax
test   %sil,%sil
cmove  %edx,%eax
jmp    1484 <stringReduction+0x364>
test   %al,%al
je     1492 <stringReduction+0x372>
mov    0x52(%rsp,%rcx,1),%cl
test   %cl,%cl
je     1498 <stringReduction+0x378>
cmp    %cl,%al
ja     1496 <stringReduction+0x376>
jmp    1498 <stringReduction+0x378>
mov    0x52(%rsp,%rcx,1),%cl
mov    %ecx,%eax
movzbl %al,%eax
add    $0x7588,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @stringReduction(i8* %0) {
%2 = alloca i8*
%3 = alloca i32
%4 = alloca [100 x [100 x [3 x i8]]]
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
store i8* %0, i8** %2
%10 = load i8*, i8** %2
%11 = call i32 @strlen(i8* %10)
store i32 %11, i32* %3
store i32 0, i32* %5
br label %12
12: ; preds = %100, %1
%13 = load i32, i32* %5
%14 = load i32, i32* %3
%15 = icmp ult i32 %13, %14
br i1 %15, label %16, label %103
16: ; preds = %12
%17 = load i8*, i8** %2
%18 = load i32, i32* %5
%19 = sext i32 %18 to i64
%20 = getelementptr inbounds i8, i8* %17, i64 %19
%21 = load i8, i8* %20
%22 = sext i8 %21 to i32
%23 = icmp eq i32 97, %22
br i1 %23, label %24, label %46
24: ; preds = %16
%25 = load i32, i32* %5
%26 = sext i32 %25 to i64
%27 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 %26
%28 = load i32, i32* %5
%29 = sext i32 %28 to i64
%30 = getelementptr inbounds [100 x [3 x i8]], [100 x [3 x i8]]* %27, i64 0, i64 %29
%31 = getelementptr inbounds [3 x i8], [3 x i8]* %30, i64 0, i64 0
store i8 1, i8* %31
%32 = load i32, i32* %5
%33 = sext i32 %32 to i64
%34 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 %33
%35 = load i32, i32* %5
%36 = sext i32 %35 to i64
%37 = getelementptr inbounds [100 x [3 x i8]], [100 x [3 x i8]]* %34, i64 0, i64 %36
%38 = getelementptr inbounds [3 x i8], [3 x i8]* %37, i64 0, i64 1
store i8 0, i8* %38
%39 = load i32, i32* %5
%40 = sext i32 %39 to i64
%41 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 %40
%42 = load i32, i32* %5
%43 = sext i32 %42 to i64
%44 = getelementptr inbounds [100 x [3 x i8]], [100 x [3 x i8]]* %41, i64 0, i64 %43
%45 = getelementptr inbounds [3 x i8], [3 x i8]* %44, i64 0, i64 2
store i8 0, i8* %45
br label %99
46: ; preds = %16
%47 = load i8*, i8** %2
%48 = load i32, i32* %5
%49 = sext i32 %48 to i64
%50 = getelementptr inbounds i8, i8* %47, i64 %49
%51 = load i8, i8* %50
%52 = sext i8 %51 to i32
%53 = icmp eq i32 98, %52
br i1 %53, label %54, label %76
54: ; preds = %46
%55 = load i32, i32* %5
%56 = sext i32 %55 to i64
%57 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 %56
%58 = load i32, i32* %5
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds [100 x [3 x i8]], [100 x [3 x i8]]* %57, i64 0, i64 %59
%61 = getelementptr inbounds [3 x i8], [3 x i8]* %60, i64 0, i64 0
store i8 0, i8* %61
%62 = load i32, i32* %5
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 %63
%65 = load i32, i32* %5
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds [100 x [3 x i8]], [100 x [3 x i8]]* %64, i64 0, i64 %66
%68 = getelementptr inbounds [3 x i8], [3 x i8]* %67, i64 0, i64 1
store i8 1, i8* %68
%69 = load i32, i32* %5
%70 = sext i32 %69 to i64
%71 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 %70
%72 = load i32, i32* %5
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds [100 x [3 x i8]], [100 x [3 x i8]]* %71, i64 0, i64 %73
%75 = getelementptr inbounds [3 x i8], [3 x i8]* %74, i64 0, i64 2
store i8 0, i8* %75
br label %98
76: ; preds = %46
%77 = load i32, i32* %5
%78 = sext i32 %77 to i64
%79 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 %78
%80 = load i32, i32* %5
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds [100 x [3 x i8]], [100 x [3 x i8]]* %79, i64 0, i64 %81
%83 = getelementptr inbounds [3 x i8], [3 x i8]* %82, i64 0, i64 0
store i8 0, i8* %83
%84 = load i32, i32* %5
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 %85
%87 = load i32, i32* %5
%88 = sext i32 %87 to i64
%89 = getelementptr inbounds [100 x [3 x i8]], [100 x [3 x i8]]* %86, i64 0, i64 %88
%90 = getelementptr inbounds [3 x i8], [3 x i8]* %89, i64 0, i64 1
store i8 0, i8* %90
%91 = load i32, i32* %5
%92 = sext i32 %91 to i64
%93 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 %92
%94 = load i32, i32* %5
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds [100 x [3 x i8]], [100 x [3 x i8]]* %93, i64 0, i64 %95
%97 = getelementptr inbounds [3 x i8], [3 x i8]* %96, i64 0, i64 2
store i8 1, i8* %97
br label %98
98: ; preds = %76, %54
br label %99
99: ; preds = %98, %24
br label %100
100: ; preds = %99
%101 = load i32, i32* %5
%102 = add nsw i32 %101, 1
store i32 %102, i32* %5
br label %12
103: ; preds = %12
store i32 1, i32* %6
br label %104
104: ; preds = %717, %103
%105 = load i32, i32* %6
%106 = load i32, i32* %3
%107 = icmp ult i32 %105, %106
br i1 %107, label %108, label %720
108: ; preds = %104
store i32 0, i32* %7
br label %109
109: ; preds = %713, %108
%110 = load i32, i32* %7
%111 = load i32, i32* %3
%112 = load i32, i32* %6
%113 = sub i32 %111, %112
%114 = icmp ult i32 %110, %113
br i1 %114, label %115, label %716
115: ; preds = %109
%116 = load i32, i32* %7
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 %117
%119 = load i32, i32* %7
%120 = load i32, i32* %6
%121 = add nsw i32 %119, %120
%122 = sext i32 %121 to i64
%123 = getelementptr inbounds [100 x [3 x i8]], [100 x [3 x i8]]* %118, i64 0, i64 %122
%124 = getelementptr inbounds [3 x i8], [3 x i8]* %123, i64 0, i64 0
store i8 0, i8* %124
%125 = load i32, i32* %7
%126 = sext i32 %125 to i64
%127 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 %126
%128 = load i32, i32* %7
%129 = load i32, i32* %6
%130 = add nsw i32 %128, %129
%131 = sext i32 %130 to i64
%132 = getelementptr inbounds [100 x [3 x i8]], [100 x [3 x i8]]* %127, i64 0, i64 %131
%133 = getelementptr inbounds [3 x i8], [3 x i8]* %132, i64 0, i64 1
store i8 0, i8* %133
%134 = load i32, i32* %7
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 %135
%137 = load i32, i32* %7
%138 = load i32, i32* %6
%139 = add nsw i32 %137, %138
%140 = sext i32 %139 to i64
%141 = getelementptr inbounds [100 x [3 x i8]], [100 x [3 x i8]]* %136, i64 0, i64 %140
%142 = getelementptr inbounds [3 x i8], [3 x i8]* %141, i64 0, i64 2
store i8 0, i8* %142
%143 = load i32, i32* %7
store i32 %143, i32* %8
br label %144
144: ; preds = %709, %115
%145 = load i32, i32* %8
%146 = load i32, i32* %7
%147 = load i32, i32* %6
%148 = add nsw i32 %146, %147
%149 = icmp slt i32 %145, %148
br i1 %149, label %150, label %712
150: ; preds = %144
%151 = load i32, i32* %7
%152 = sext i32 %151 to i64
%153 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 %152
%154 = load i32, i32* %8
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds [100 x [3 x i8]], [100 x [3 x i8]]* %153, i64 0, i64 %155
%157 = getelementptr inbounds [3 x i8], [3 x i8]* %156, i64 0, i64 0
%158 = load i8, i8* %157
%159 = icmp ne i8 %158, 0
br i1 %159, label %160, label %336
160: ; preds = %150
%161 = load i32, i32* %8
%162 = add nsw i32 %161, 1
%163 = sext i32 %162 to i64
%164 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 %163
%165 = load i32, i32* %7
%166 = load i32, i32* %6
%167 = add nsw i32 %165, %166
%168 = sext i32 %167 to i64
%169 = getelementptr inbounds [100 x [3 x i8]], [100 x [3 x i8]]* %164, i64 0, i64 %168
%170 = getelementptr inbounds [3 x i8], [3 x i8]* %169, i64 0, i64 0
%171 = load i8, i8* %170
%172 = icmp ne i8 %171, 0
br i1 %172, label %173, label %255
173: ; preds = %160
%174 = load i32, i32* %7
%175 = sext i32 %174 to i64
%176 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 %175
%177 = load i32, i32* %7
%178 = load i32, i32* %6
%179 = add nsw i32 %177, %178
%180 = sext i32 %179 to i64
%181 = getelementptr inbounds [100 x [3 x i8]], [100 x [3 x i8]]* %176, i64 0, i64 %180
%182 = getelementptr inbounds [3 x i8], [3 x i8]* %181, i64 0, i64 0
%183 = load i8, i8* %182
%184 = zext i8 %183 to i32
%185 = icmp eq i32 0, %184
br i1 %185, label %221, label %186
186: ; preds = %173
%187 = load i32, i32* %7
%188 = sext i32 %187 to i64
%189 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 %188
%190 = load i32, i32* %7
%191 = load i32, i32* %6
%192 = add nsw i32 %190, %191
%193 = sext i32 %192 to i64
%194 = getelementptr inbounds [100 x [3 x i8]], [100 x [3 x i8]]* %189, i64 0, i64 %193
%195 = getelementptr inbounds [3 x i8], [3 x i8]* %194, i64 0, i64 0
%196 = load i8, i8* %195
%197 = zext i8 %196 to i32
%198 = load i32, i32* %7
%199 = sext i32 %198 to i64
%200 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 %199
%201 = load i32, i32* %8
%202 = sext i32 %201 to i64
%203 = getelementptr inbounds [100 x [3 x i8]], [100 x [3 x i8]]* %200, i64 0, i64 %202
%204 = getelementptr inbounds [3 x i8], [3 x i8]* %203, i64 0, i64 0
%205 = load i8, i8* %204
%206 = zext i8 %205 to i32
%207 = load i32, i32* %8
%208 = add nsw i32 %207, 1
%209 = sext i32 %208 to i64
%210 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 %209
%211 = load i32, i32* %7
%212 = load i32, i32* %6
%213 = add nsw i32 %211, %212
%214 = sext i32 %213 to i64
%215 = getelementptr inbounds [100 x [3 x i8]], [100 x [3 x i8]]* %210, i64 0, i64 %214
%216 = getelementptr inbounds [3 x i8], [3 x i8]* %215, i64 0, i64 0
%217 = load i8, i8* %216
%218 = zext i8 %217 to i32
%219 = add nsw i32 %206, %218
%220 = icmp sgt i32 %197, %219
br i1 %220, label %221, label %254
221: ; preds = %186, %173
%222 = load i32, i32* %7
%223 = sext i32 %222 to i64
%224 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 %223
%225 = load i32, i32* %8
%226 = sext i32 %225 to i64
%227 = getelementptr inbounds [100 x [3 x i8]], [100 x [3 x i8]]* %224, i64 0, i64 %226
%228 = getelementptr inbounds [3 x i8], [3 x i8]* %227, i64 0, i64 0
%229 = load i8, i8* %228
%230 = zext i8 %229 to i32
%231 = load i32, i32* %8
%232 = add nsw i32 %231, 1
%233 = sext i32 %232 to i64
%234 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 %233
%235 = load i32, i32* %7
%236 = load i32, i32* %6
%237 = add nsw i32 %235, %236
%238 = sext i32 %237 to i64
%239 = getelementptr inbounds [100 x [3 x i8]], [100 x [3 x i8]]* %234, i64 0, i64 %238
%240 = getelementptr inbounds [3 x i8], [3 x i8]* %239, i64 0, i64 0
%241 = load i8, i8* %240
%242 = zext i8 %241 to i32
%243 = add nsw i32 %230, %242
%244 = trunc i32 %243 to i8
%245 = load i32, i32* %7
%246 = sext i32 %245 to i64
%247 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 %246
%248 = load i32, i32* %7
%249 = load i32, i32* %6
%250 = add nsw i32 %248, %249
%251 = sext i32 %250 to i64
%252 = getelementptr inbounds [100 x [3 x i8]], [100 x [3 x i8]]* %247, i64 0, i64 %251
%253 = getelementptr inbounds [3 x i8], [3 x i8]* %252, i64 0, i64 0
store i8 %244, i8* %253
br label %254
254: ; preds = %221, %186
br label %255
255: ; preds = %254, %160
%256 = load i32, i32* %8
%257 = add nsw i32 %256, 1
%258 = sext i32 %257 to i64
%259 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 %258
%260 = load i32, i32* %7
%261 = load i32, i32* %6
%262 = add nsw i32 %260, %261
%263 = sext i32 %262 to i64
%264 = getelementptr inbounds [100 x [3 x i8]], [100 x [3 x i8]]* %259, i64 0, i64 %263
%265 = getelementptr inbounds [3 x i8], [3 x i8]* %264, i64 0, i64 1
%266 = load i8, i8* %265
%267 = icmp ne i8 %266, 0
br i1 %267, label %268, label %295
268: ; preds = %255
%269 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 0
%270 = bitcast [100 x [3 x i8]]* %269 to i8***
%271 = load i32, i32* %7
%272 = load i32, i32* %7
%273 = load i32, i32* %6
%274 = add nsw i32 %272, %273
%275 = load i32, i32* %7
%276 = sext i32 %275 to i64
%277 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 %276
%278 = load i32, i32* %8
%279 = sext i32 %278 to i64
%280 = getelementptr inbounds [100 x [3 x i8]], [100 x [3 x i8]]* %277, i64 0, i64 %279
%281 = getelementptr inbounds [3 x i8], [3 x i8]* %280, i64 0, i64 0
%282 = load i8, i8* %281
%283 = load i32, i32* %8
%284 = add nsw i32 %283, 1
%285 = sext i32 %284 to i64
%286 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 %285
%287 = load i32, i32* %7
%288 = load i32, i32* %6
%289 = add nsw i32 %287, %288
%290 = sext i32 %289 to i64
%291 = getelementptr inbounds [100 x [3 x i8]], [100 x [3 x i8]]* %286, i64 0, i64 %290
%292 = getelementptr inbounds [3 x i8], [3 x i8]* %291, i64 0, i64 1
%293 = load i8, i8* %292
%294 = call i32 @proc(i8*** %270, i32 %271, i32 %274, i32 0, i32 1, i8 zeroext %282, i8 zeroext %293)
br label %295
295: ; preds = %268, %255
%296 = load i32, i32* %8
%297 = add nsw i32 %296, 1
%298 = sext i32 %297 to i64
%299 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 %298
%300 = load i32, i32* %7
%301 = load i32, i32* %6
%302 = add nsw i32 %300, %301
%303 = sext i32 %302 to i64
%304 = getelementptr inbounds [100 x [3 x i8]], [100 x [3 x i8]]* %299, i64 0, i64 %303
%305 = getelementptr inbounds [3 x i8], [3 x i8]* %304, i64 0, i64 2
%306 = load i8, i8* %305
%307 = icmp ne i8 %306, 0
br i1 %307, label %308, label %335
308: ; preds = %295
%309 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 0
%310 = bitcast [100 x [3 x i8]]* %309 to i8***
%311 = load i32, i32* %7
%312 = load i32, i32* %7
%313 = load i32, i32* %6
%314 = add nsw i32 %312, %313
%315 = load i32, i32* %7
%316 = sext i32 %315 to i64
%317 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 %316
%318 = load i32, i32* %8
%319 = sext i32 %318 to i64
%320 = getelementptr inbounds [100 x [3 x i8]], [100 x [3 x i8]]* %317, i64 0, i64 %319
%321 = getelementptr inbounds [3 x i8], [3 x i8]* %320, i64 0, i64 0
%322 = load i8, i8* %321
%323 = load i32, i32* %8
%324 = add nsw i32 %323, 1
%325 = sext i32 %324 to i64
%326 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 %325
%327 = load i32, i32* %7
%328 = load i32, i32* %6
%329 = add nsw i32 %327, %328
%330 = sext i32 %329 to i64
%331 = getelementptr inbounds [100 x [3 x i8]], [100 x [3 x i8]]* %326, i64 0, i64 %330
%332 = getelementptr inbounds [3 x i8], [3 x i8]* %331, i64 0, i64 2
%333 = load i8, i8* %332
%334 = call i32 @proc(i8*** %310, i32 %311, i32 %314, i32 0, i32 2, i8 zeroext %322, i8 zeroext %333)
br label %335
335: ; preds = %308, %295
br label %336
336: ; preds = %335, %150
%337 = load i32, i32* %7
%338 = sext i32 %337 to i64
%339 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 %338
%340 = load i32, i32* %8
%341 = sext i32 %340 to i64
%342 = getelementptr inbounds [100 x [3 x i8]], [100 x [3 x i8]]* %339, i64 0, i64 %341
%343 = getelementptr inbounds [3 x i8], [3 x i8]* %342, i64 0, i64 1
%344 = load i8, i8* %343
%345 = icmp ne i8 %344, 0
br i1 %345, label %346, label %522
346: ; preds = %336
%347 = load i32, i32* %8
%348 = add nsw i32 %347, 1
%349 = sext i32 %348 to i64
%350 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 %349
%351 = load i32, i32* %7
%352 = load i32, i32* %6
%353 = add nsw i32 %351, %352
%354 = sext i32 %353 to i64
%355 = getelementptr inbounds [100 x [3 x i8]], [100 x [3 x i8]]* %350, i64 0, i64 %354
%356 = getelementptr inbounds [3 x i8], [3 x i8]* %355, i64 0, i64 1
%357 = load i8, i8* %356
%358 = icmp ne i8 %357, 0
br i1 %358, label %359, label %441
359: ; preds = %346
%360 = load i32, i32* %7
%361 = sext i32 %360 to i64
%362 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 %361
%363 = load i32, i32* %7
%364 = load i32, i32* %6
%365 = add nsw i32 %363, %364
%366 = sext i32 %365 to i64
%367 = getelementptr inbounds [100 x [3 x i8]], [100 x [3 x i8]]* %362, i64 0, i64 %366
%368 = getelementptr inbounds [3 x i8], [3 x i8]* %367, i64 0, i64 1
%369 = load i8, i8* %368
%370 = zext i8 %369 to i32
%371 = icmp eq i32 0, %370
br i1 %371, label %407, label %372
372: ; preds = %359
%373 = load i32, i32* %7
%374 = sext i32 %373 to i64
%375 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 %374
%376 = load i32, i32* %7
%377 = load i32, i32* %6
%378 = add nsw i32 %376, %377
%379 = sext i32 %378 to i64
%380 = getelementptr inbounds [100 x [3 x i8]], [100 x [3 x i8]]* %375, i64 0, i64 %379
%381 = getelementptr inbounds [3 x i8], [3 x i8]* %380, i64 0, i64 1
%382 = load i8, i8* %381
%383 = zext i8 %382 to i32
%384 = load i32, i32* %7
%385 = sext i32 %384 to i64
%386 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 %385
%387 = load i32, i32* %8
%388 = sext i32 %387 to i64
%389 = getelementptr inbounds [100 x [3 x i8]], [100 x [3 x i8]]* %386, i64 0, i64 %388
%390 = getelementptr inbounds [3 x i8], [3 x i8]* %389, i64 0, i64 1
%391 = load i8, i8* %390
%392 = zext i8 %391 to i32
%393 = load i32, i32* %8
%394 = add nsw i32 %393, 1
%395 = sext i32 %394 to i64
%396 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 %395
%397 = load i32, i32* %7
%398 = load i32, i32* %6
%399 = add nsw i32 %397, %398
%400 = sext i32 %399 to i64
%401 = getelementptr inbounds [100 x [3 x i8]], [100 x [3 x i8]]* %396, i64 0, i64 %400
%402 = getelementptr inbounds [3 x i8], [3 x i8]* %401, i64 0, i64 1
%403 = load i8, i8* %402
%404 = zext i8 %403 to i32
%405 = add nsw i32 %392, %404
%406 = icmp sgt i32 %383, %405
br i1 %406, label %407, label %440
407: ; preds = %372, %359
%408 = load i32, i32* %7
%409 = sext i32 %408 to i64
%410 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 %409
%411 = load i32, i32* %8
%412 = sext i32 %411 to i64
%413 = getelementptr inbounds [100 x [3 x i8]], [100 x [3 x i8]]* %410, i64 0, i64 %412
%414 = getelementptr inbounds [3 x i8], [3 x i8]* %413, i64 0, i64 1
%415 = load i8, i8* %414
%416 = zext i8 %415 to i32
%417 = load i32, i32* %8
%418 = add nsw i32 %417, 1
%419 = sext i32 %418 to i64
%420 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 %419
%421 = load i32, i32* %7
%422 = load i32, i32* %6
%423 = add nsw i32 %421, %422
%424 = sext i32 %423 to i64
%425 = getelementptr inbounds [100 x [3 x i8]], [100 x [3 x i8]]* %420, i64 0, i64 %424
%426 = getelementptr inbounds [3 x i8], [3 x i8]* %425, i64 0, i64 1
%427 = load i8, i8* %426
%428 = zext i8 %427 to i32
%429 = add nsw i32 %416, %428
%430 = trunc i32 %429 to i8
%431 = load i32, i32* %7
%432 = sext i32 %431 to i64
%433 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 %432
%434 = load i32, i32* %7
%435 = load i32, i32* %6
%436 = add nsw i32 %434, %435
%437 = sext i32 %436 to i64
%438 = getelementptr inbounds [100 x [3 x i8]], [100 x [3 x i8]]* %433, i64 0, i64 %437
%439 = getelementptr inbounds [3 x i8], [3 x i8]* %438, i64 0, i64 1
store i8 %430, i8* %439
br label %440
440: ; preds = %407, %372
br label %441
441: ; preds = %440, %346
%442 = load i32, i32* %8
%443 = add nsw i32 %442, 1
%444 = sext i32 %443 to i64
%445 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 %444
%446 = load i32, i32* %7
%447 = load i32, i32* %6
%448 = add nsw i32 %446, %447
%449 = sext i32 %448 to i64
%450 = getelementptr inbounds [100 x [3 x i8]], [100 x [3 x i8]]* %445, i64 0, i64 %449
%451 = getelementptr inbounds [3 x i8], [3 x i8]* %450, i64 0, i64 0
%452 = load i8, i8* %451
%453 = icmp ne i8 %452, 0
br i1 %453, label %454, label %481
454: ; preds = %441
%455 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 0
%456 = bitcast [100 x [3 x i8]]* %455 to i8***
%457 = load i32, i32* %7
%458 = load i32, i32* %7
%459 = load i32, i32* %6
%460 = add nsw i32 %458, %459
%461 = load i32, i32* %7
%462 = sext i32 %461 to i64
%463 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 %462
%464 = load i32, i32* %8
%465 = sext i32 %464 to i64
%466 = getelementptr inbounds [100 x [3 x i8]], [100 x [3 x i8]]* %463, i64 0, i64 %465
%467 = getelementptr inbounds [3 x i8], [3 x i8]* %466, i64 0, i64 1
%468 = load i8, i8* %467
%469 = load i32, i32* %8
%470 = add nsw i32 %469, 1
%471 = sext i32 %470 to i64
%472 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 %471
%473 = load i32, i32* %7
%474 = load i32, i32* %6
%475 = add nsw i32 %473, %474
%476 = sext i32 %475 to i64
%477 = getelementptr inbounds [100 x [3 x i8]], [100 x [3 x i8]]* %472, i64 0, i64 %476
%478 = getelementptr inbounds [3 x i8], [3 x i8]* %477, i64 0, i64 0
%479 = load i8, i8* %478
%480 = call i32 @proc(i8*** %456, i32 %457, i32 %460, i32 1, i32 0, i8 zeroext %468, i8 zeroext %479)
br label %481
481: ; preds = %454, %441
%482 = load i32, i32* %8
%483 = add nsw i32 %482, 1
%484 = sext i32 %483 to i64
%485 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 %484
%486 = load i32, i32* %7
%487 = load i32, i32* %6
%488 = add nsw i32 %486, %487
%489 = sext i32 %488 to i64
%490 = getelementptr inbounds [100 x [3 x i8]], [100 x [3 x i8]]* %485, i64 0, i64 %489
%491 = getelementptr inbounds [3 x i8], [3 x i8]* %490, i64 0, i64 2
%492 = load i8, i8* %491
%493 = icmp ne i8 %492, 0
br i1 %493, label %494, label %521
494: ; preds = %481
%495 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 0
%496 = bitcast [100 x [3 x i8]]* %495 to i8***
%497 = load i32, i32* %7
%498 = load i32, i32* %7
%499 = load i32, i32* %6
%500 = add nsw i32 %498, %499
%501 = load i32, i32* %7
%502 = sext i32 %501 to i64
%503 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 %502
%504 = load i32, i32* %8
%505 = sext i32 %504 to i64
%506 = getelementptr inbounds [100 x [3 x i8]], [100 x [3 x i8]]* %503, i64 0, i64 %505
%507 = getelementptr inbounds [3 x i8], [3 x i8]* %506, i64 0, i64 1
%508 = load i8, i8* %507
%509 = load i32, i32* %8
%510 = add nsw i32 %509, 1
%511 = sext i32 %510 to i64
%512 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 %511
%513 = load i32, i32* %7
%514 = load i32, i32* %6
%515 = add nsw i32 %513, %514
%516 = sext i32 %515 to i64
%517 = getelementptr inbounds [100 x [3 x i8]], [100 x [3 x i8]]* %512, i64 0, i64 %516
%518 = getelementptr inbounds [3 x i8], [3 x i8]* %517, i64 0, i64 2
%519 = load i8, i8* %518
%520 = call i32 @proc(i8*** %496, i32 %497, i32 %500, i32 1, i32 2, i8 zeroext %508, i8 zeroext %519)
br label %521
521: ; preds = %494, %481
br label %522
522: ; preds = %521, %336
%523 = load i32, i32* %7
%524 = sext i32 %523 to i64
%525 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 %524
%526 = load i32, i32* %8
%527 = sext i32 %526 to i64
%528 = getelementptr inbounds [100 x [3 x i8]], [100 x [3 x i8]]* %525, i64 0, i64 %527
%529 = getelementptr inbounds [3 x i8], [3 x i8]* %528, i64 0, i64 2
%530 = load i8, i8* %529
%531 = icmp ne i8 %530, 0
br i1 %531, label %532, label %708
532: ; preds = %522
%533 = load i32, i32* %8
%534 = add nsw i32 %533, 1
%535 = sext i32 %534 to i64
%536 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 %535
%537 = load i32, i32* %7
%538 = load i32, i32* %6
%539 = add nsw i32 %537, %538
%540 = sext i32 %539 to i64
%541 = getelementptr inbounds [100 x [3 x i8]], [100 x [3 x i8]]* %536, i64 0, i64 %540
%542 = getelementptr inbounds [3 x i8], [3 x i8]* %541, i64 0, i64 2
%543 = load i8, i8* %542
%544 = icmp ne i8 %543, 0
br i1 %544, label %545, label %627
545: ; preds = %532
%546 = load i32, i32* %7
%547 = sext i32 %546 to i64
%548 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 %547
%549 = load i32, i32* %7
%550 = load i32, i32* %6
%551 = add nsw i32 %549, %550
%552 = sext i32 %551 to i64
%553 = getelementptr inbounds [100 x [3 x i8]], [100 x [3 x i8]]* %548, i64 0, i64 %552
%554 = getelementptr inbounds [3 x i8], [3 x i8]* %553, i64 0, i64 2
%555 = load i8, i8* %554
%556 = zext i8 %555 to i32
%557 = icmp eq i32 0, %556
br i1 %557, label %593, label %558
558: ; preds = %545
%559 = load i32, i32* %7
%560 = sext i32 %559 to i64
%561 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 %560
%562 = load i32, i32* %7
%563 = load i32, i32* %6
%564 = add nsw i32 %562, %563
%565 = sext i32 %564 to i64
%566 = getelementptr inbounds [100 x [3 x i8]], [100 x [3 x i8]]* %561, i64 0, i64 %565
%567 = getelementptr inbounds [3 x i8], [3 x i8]* %566, i64 0, i64 2
%568 = load i8, i8* %567
%569 = zext i8 %568 to i32
%570 = load i32, i32* %7
%571 = sext i32 %570 to i64
%572 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 %571
%573 = load i32, i32* %8
%574 = sext i32 %573 to i64
%575 = getelementptr inbounds [100 x [3 x i8]], [100 x [3 x i8]]* %572, i64 0, i64 %574
%576 = getelementptr inbounds [3 x i8], [3 x i8]* %575, i64 0, i64 2
%577 = load i8, i8* %576
%578 = zext i8 %577 to i32
%579 = load i32, i32* %8
%580 = add nsw i32 %579, 1
%581 = sext i32 %580 to i64
%582 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 %581
%583 = load i32, i32* %7
%584 = load i32, i32* %6
%585 = add nsw i32 %583, %584
%586 = sext i32 %585 to i64
%587 = getelementptr inbounds [100 x [3 x i8]], [100 x [3 x i8]]* %582, i64 0, i64 %586
%588 = getelementptr inbounds [3 x i8], [3 x i8]* %587, i64 0, i64 2
%589 = load i8, i8* %588
%590 = zext i8 %589 to i32
%591 = add nsw i32 %578, %590
%592 = icmp sgt i32 %569, %591
br i1 %592, label %593, label %626
593: ; preds = %558, %545
%594 = load i32, i32* %7
%595 = sext i32 %594 to i64
%596 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 %595
%597 = load i32, i32* %8
%598 = sext i32 %597 to i64
%599 = getelementptr inbounds [100 x [3 x i8]], [100 x [3 x i8]]* %596, i64 0, i64 %598
%600 = getelementptr inbounds [3 x i8], [3 x i8]* %599, i64 0, i64 2
%601 = load i8, i8* %600
%602 = zext i8 %601 to i32
%603 = load i32, i32* %8
%604 = add nsw i32 %603, 1
%605 = sext i32 %604 to i64
%606 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 %605
%607 = load i32, i32* %7
%608 = load i32, i32* %6
%609 = add nsw i32 %607, %608
%610 = sext i32 %609 to i64
%611 = getelementptr inbounds [100 x [3 x i8]], [100 x [3 x i8]]* %606, i64 0, i64 %610
%612 = getelementptr inbounds [3 x i8], [3 x i8]* %611, i64 0, i64 2
%613 = load i8, i8* %612
%614 = zext i8 %613 to i32
%615 = add nsw i32 %602, %614
%616 = trunc i32 %615 to i8
%617 = load i32, i32* %7
%618 = sext i32 %617 to i64
%619 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 %618
%620 = load i32, i32* %7
%621 = load i32, i32* %6
%622 = add nsw i32 %620, %621
%623 = sext i32 %622 to i64
%624 = getelementptr inbounds [100 x [3 x i8]], [100 x [3 x i8]]* %619, i64 0, i64 %623
%625 = getelementptr inbounds [3 x i8], [3 x i8]* %624, i64 0, i64 2
store i8 %616, i8* %625
br label %626
626: ; preds = %593, %558
br label %627
627: ; preds = %626, %532
%628 = load i32, i32* %8
%629 = add nsw i32 %628, 1
%630 = sext i32 %629 to i64
%631 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 %630
%632 = load i32, i32* %7
%633 = load i32, i32* %6
%634 = add nsw i32 %632, %633
%635 = sext i32 %634 to i64
%636 = getelementptr inbounds [100 x [3 x i8]], [100 x [3 x i8]]* %631, i64 0, i64 %635
%637 = getelementptr inbounds [3 x i8], [3 x i8]* %636, i64 0, i64 1
%638 = load i8, i8* %637
%639 = icmp ne i8 %638, 0
br i1 %639, label %640, label %667
640: ; preds = %627
%641 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 0
%642 = bitcast [100 x [3 x i8]]* %641 to i8***
%643 = load i32, i32* %7
%644 = load i32, i32* %7
%645 = load i32, i32* %6
%646 = add nsw i32 %644, %645
%647 = load i32, i32* %7
%648 = sext i32 %647 to i64
%649 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 %648
%650 = load i32, i32* %8
%651 = sext i32 %650 to i64
%652 = getelementptr inbounds [100 x [3 x i8]], [100 x [3 x i8]]* %649, i64 0, i64 %651
%653 = getelementptr inbounds [3 x i8], [3 x i8]* %652, i64 0, i64 2
%654 = load i8, i8* %653
%655 = load i32, i32* %8
%656 = add nsw i32 %655, 1
%657 = sext i32 %656 to i64
%658 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 %657
%659 = load i32, i32* %7
%660 = load i32, i32* %6
%661 = add nsw i32 %659, %660
%662 = sext i32 %661 to i64
%663 = getelementptr inbounds [100 x [3 x i8]], [100 x [3 x i8]]* %658, i64 0, i64 %662
%664 = getelementptr inbounds [3 x i8], [3 x i8]* %663, i64 0, i64 1
%665 = load i8, i8* %664
%666 = call i32 @proc(i8*** %642, i32 %643, i32 %646, i32 2, i32 1, i8 zeroext %654, i8 zeroext %665)
br label %667
667: ; preds = %640, %627
%668 = load i32, i32* %8
%669 = add nsw i32 %668, 1
%670 = sext i32 %669 to i64
%671 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 %670
%672 = load i32, i32* %7
%673 = load i32, i32* %6
%674 = add nsw i32 %672, %673
%675 = sext i32 %674 to i64
%676 = getelementptr inbounds [100 x [3 x i8]], [100 x [3 x i8]]* %671, i64 0, i64 %675
%677 = getelementptr inbounds [3 x i8], [3 x i8]* %676, i64 0, i64 0
%678 = load i8, i8* %677
%679 = icmp ne i8 %678, 0
br i1 %679, label %680, label %707
680: ; preds = %667
%681 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 0
%682 = bitcast [100 x [3 x i8]]* %681 to i8***
%683 = load i32, i32* %7
%684 = load i32, i32* %7
%685 = load i32, i32* %6
%686 = add nsw i32 %684, %685
%687 = load i32, i32* %7
%688 = sext i32 %687 to i64
%689 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 %688
%690 = load i32, i32* %8
%691 = sext i32 %690 to i64
%692 = getelementptr inbounds [100 x [3 x i8]], [100 x [3 x i8]]* %689, i64 0, i64 %691
%693 = getelementptr inbounds [3 x i8], [3 x i8]* %692, i64 0, i64 2
%694 = load i8, i8* %693
%695 = load i32, i32* %8
%696 = add nsw i32 %695, 1
%697 = sext i32 %696 to i64
%698 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 %697
%699 = load i32, i32* %7
%700 = load i32, i32* %6
%701 = add nsw i32 %699, %700
%702 = sext i32 %701 to i64
%703 = getelementptr inbounds [100 x [3 x i8]], [100 x [3 x i8]]* %698, i64 0, i64 %702
%704 = getelementptr inbounds [3 x i8], [3 x i8]* %703, i64 0, i64 0
%705 = load i8, i8* %704
%706 = call i32 @proc(i8*** %682, i32 %683, i32 %686, i32 2, i32 0, i8 zeroext %694, i8 zeroext %705)
br label %707
707: ; preds = %680, %667
br label %708
708: ; preds = %707, %522
br label %709
709: ; preds = %708
%710 = load i32, i32* %8
%711 = add nsw i32 %710, 1
store i32 %711, i32* %8
br label %144
712: ; preds = %144
br label %713
713: ; preds = %712
%714 = load i32, i32* %7
%715 = add nsw i32 %714, 1
store i32 %715, i32* %7
br label %109
716: ; preds = %109
br label %717
717: ; preds = %716
%718 = load i32, i32* %6
%719 = add nsw i32 %718, 1
store i32 %719, i32* %6
br label %104
720: ; preds = %104
%721 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 0
%722 = load i32, i32* %3
%723 = sub i32 %722, 1
%724 = zext i32 %723 to i64
%725 = getelementptr inbounds [100 x [3 x i8]], [100 x [3 x i8]]* %721, i64 0, i64 %724
%726 = getelementptr inbounds [3 x i8], [3 x i8]* %725, i64 0, i64 0
%727 = load i8, i8* %726
%728 = zext i8 %727 to i32
store i32 %728, i32* %9
%729 = load i32, i32* %9
%730 = icmp eq i32 0, %729
br i1 %730, label %752, label %731
731: ; preds = %720
%732 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 0
%733 = load i32, i32* %3
%734 = sub i32 %733, 1
%735 = zext i32 %734 to i64
%736 = getelementptr inbounds [100 x [3 x i8]], [100 x [3 x i8]]* %732, i64 0, i64 %735
%737 = getelementptr inbounds [3 x i8], [3 x i8]* %736, i64 0, i64 1
%738 = load i8, i8* %737
%739 = zext i8 %738 to i32
%740 = icmp ne i32 %739, 0
br i1 %740, label %741, label %761
741: ; preds = %731
%742 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 0
%743 = load i32, i32* %3
%744 = sub i32 %743, 1
%745 = zext i32 %744 to i64
%746 = getelementptr inbounds [100 x [3 x i8]], [100 x [3 x i8]]* %742, i64 0, i64 %745
%747 = getelementptr inbounds [3 x i8], [3 x i8]* %746, i64 0, i64 1
%748 = load i8, i8* %747
%749 = zext i8 %748 to i32
%750 = load i32, i32* %9
%751 = icmp slt i32 %749, %750
br i1 %751, label %752, label %761
752: ; preds = %741, %720
%753 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 0
%754 = load i32, i32* %3
%755 = sub i32 %754, 1
%756 = zext i32 %755 to i64
%757 = getelementptr inbounds [100 x [3 x i8]], [100 x [3 x i8]]* %753, i64 0, i64 %756
%758 = getelementptr inbounds [3 x i8], [3 x i8]* %757, i64 0, i64 1
%759 = load i8, i8* %758
%760 = zext i8 %759 to i32
store i32 %760, i32* %9
br label %761
761: ; preds = %752, %741, %731
%762 = load i32, i32* %9
%763 = icmp eq i32 0, %762
br i1 %763, label %785, label %764
764: ; preds = %761
%765 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 0
%766 = load i32, i32* %3
%767 = sub i32 %766, 1
%768 = zext i32 %767 to i64
%769 = getelementptr inbounds [100 x [3 x i8]], [100 x [3 x i8]]* %765, i64 0, i64 %768
%770 = getelementptr inbounds [3 x i8], [3 x i8]* %769, i64 0, i64 2
%771 = load i8, i8* %770
%772 = zext i8 %771 to i32
%773 = icmp ne i32 %772, 0
br i1 %773, label %774, label %794
774: ; preds = %764
%775 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 0
%776 = load i32, i32* %3
%777 = sub i32 %776, 1
%778 = zext i32 %777 to i64
%779 = getelementptr inbounds [100 x [3 x i8]], [100 x [3 x i8]]* %775, i64 0, i64 %778
%780 = getelementptr inbounds [3 x i8], [3 x i8]* %779, i64 0, i64 2
%781 = load i8, i8* %780
%782 = zext i8 %781 to i32
%783 = load i32, i32* %9
%784 = icmp slt i32 %782, %783
br i1 %784, label %785, label %794
785: ; preds = %774, %761
%786 = getelementptr inbounds [100 x [100 x [3 x i8]]], [100 x [100 x [3 x i8]]]* %4, i64 0, i64 0
%787 = load i32, i32* %3
%788 = sub i32 %787, 1
%789 = zext i32 %788 to i64
%790 = getelementptr inbounds [100 x [3 x i8]], [100 x [3 x i8]]* %786, i64 0, i64 %789
%791 = getelementptr inbounds [3 x i8], [3 x i8]* %790, i64 0, i64 2
%792 = load i8, i8* %791
%793 = zext i8 %792 to i32
store i32 %793, i32* %9
br label %794
794: ; preds = %785, %774, %764
%795 = load i32, i32* %9
ret i32 %795
}

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