#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 people_in(char *str, size_t size, int max) {
  char waiting = 0;
  int index = 0;
  int counts[2] = {0, 0};
  while (1) {
    if (index >= size) {
      if (waiting != 0 &&
          ((counts[((waiting) != 'M')] + 1 - counts[!((waiting) != 'M')]) < 0
               ? -(counts[((waiting) != 'M')] + 1 - counts[!((waiting) != 'M')])
               : (counts[((waiting) != 'M')] + 1 -
                  counts[!((waiting) != 'M')])) <= max)
        counts[((waiting) != 'M')]++;
      break;
    }
    char next = str[index++];
    if (((counts[((next) != 'M')] + 1 - counts[!((next) != 'M')]) < 0
             ? -(counts[((next) != 'M')] + 1 - counts[!((next) != 'M')])
             : (counts[((next) != 'M')] + 1 - counts[!((next) != 'M')])) <=
        max) {
      counts[((next) != 'M')]++;
    } else if (waiting == 0) {
      waiting = next;
    } else if (((counts[((waiting) != 'M')] + 1 - counts[!((waiting) != 'M')]) <
                        0
                    ? -(counts[((waiting) != 'M')] + 1 -
                        counts[!((waiting) != 'M')])
                    : (counts[((waiting) != 'M')] + 1 -
                       counts[!((waiting) != 'M')])) <= max) {
      counts[((waiting) != 'M')]++;
      index--;
    } else {
      break;
    }
  }
  return counts[0] + counts[1];
}


x86 assembly (clang, -O0):
<people_in>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
movb   $0x0,-0x15(%rbp)
movl   $0x0,-0x1c(%rbp)
lea    -0x24(%rbp),%rdi
xor    %esi,%esi
mov    $0x8,%edx
call   1030 <memset@plt>
movslq -0x1c(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     1231 <people_in+0x121>
movsbl -0x15(%rbp),%eax
cmp    $0x0,%eax
je     122c <people_in+0x11c>
movsbl -0x15(%rbp),%eax
cmp    $0x4d,%eax
setne  %al
and    $0x1,%al
movzbl %al,%eax
cltq
mov    -0x24(%rbp,%rax,4),%eax
add    $0x1,%eax
movsbl -0x15(%rbp),%ecx
cmp    $0x4d,%ecx
setne  %cl
xor    $0xff,%cl
and    $0x1,%cl
movzbl %cl,%ecx
movslq %ecx,%rcx
sub    -0x24(%rbp,%rcx,4),%eax
cmp    $0x0,%eax
jge    11cf <people_in+0xbf>
movsbl -0x15(%rbp),%eax
cmp    $0x4d,%eax
setne  %al
and    $0x1,%al
movzbl %al,%eax
cltq
mov    -0x24(%rbp,%rax,4),%ecx
add    $0x1,%ecx
movsbl -0x15(%rbp),%eax
cmp    $0x4d,%eax
setne  %al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
cltq
sub    -0x24(%rbp,%rax,4),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x2c(%rbp)
jmp    1204 <people_in+0xf4>
movsbl -0x15(%rbp),%eax
cmp    $0x4d,%eax
setne  %al
and    $0x1,%al
movzbl %al,%eax
cltq
mov    -0x24(%rbp,%rax,4),%eax
add    $0x1,%eax
movsbl -0x15(%rbp),%ecx
cmp    $0x4d,%ecx
setne  %cl
xor    $0xff,%cl
and    $0x1,%cl
movzbl %cl,%ecx
movslq %ecx,%rcx
sub    -0x24(%rbp,%rcx,4),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     122c <people_in+0x11c>
movsbl -0x15(%rbp),%eax
cmp    $0x4d,%eax
setne  %al
and    $0x1,%al
movzbl %al,%eax
cltq
mov    -0x24(%rbp,%rax,4),%ecx
add    $0x1,%ecx
mov    %ecx,-0x24(%rbp,%rax,4)
jmp    142e <people_in+0x31e>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x1c(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x25(%rbp)
movsbl -0x25(%rbp),%eax
cmp    $0x4d,%eax
setne  %al
and    $0x1,%al
movzbl %al,%eax
cltq
mov    -0x24(%rbp,%rax,4),%eax
add    $0x1,%eax
movsbl -0x25(%rbp),%ecx
cmp    $0x4d,%ecx
setne  %cl
xor    $0xff,%cl
and    $0x1,%cl
movzbl %cl,%ecx
movslq %ecx,%rcx
sub    -0x24(%rbp,%rcx,4),%eax
cmp    $0x0,%eax
jge    12bf <people_in+0x1af>
movsbl -0x25(%rbp),%eax
cmp    $0x4d,%eax
setne  %al
and    $0x1,%al
movzbl %al,%eax
cltq
mov    -0x24(%rbp,%rax,4),%ecx
add    $0x1,%ecx
movsbl -0x25(%rbp),%eax
cmp    $0x4d,%eax
setne  %al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
cltq
sub    -0x24(%rbp,%rax,4),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x30(%rbp)
jmp    12f4 <people_in+0x1e4>
movsbl -0x25(%rbp),%eax
cmp    $0x4d,%eax
setne  %al
and    $0x1,%al
movzbl %al,%eax
cltq
mov    -0x24(%rbp,%rax,4),%eax
add    $0x1,%eax
movsbl -0x25(%rbp),%ecx
cmp    $0x4d,%ecx
setne  %cl
xor    $0xff,%cl
and    $0x1,%cl
movzbl %cl,%ecx
movslq %ecx,%rcx
sub    -0x24(%rbp,%rcx,4),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1321 <people_in+0x211>
movsbl -0x25(%rbp),%eax
cmp    $0x4d,%eax
setne  %al
and    $0x1,%al
movzbl %al,%eax
cltq
mov    -0x24(%rbp,%rax,4),%ecx
add    $0x1,%ecx
mov    %ecx,-0x24(%rbp,%rax,4)
jmp    1429 <people_in+0x319>
movsbl -0x15(%rbp),%eax
cmp    $0x0,%eax
jne    1339 <people_in+0x229>
mov    -0x25(%rbp),%al
mov    %al,-0x15(%rbp)
jmp    1424 <people_in+0x314>
movsbl -0x15(%rbp),%eax
cmp    $0x4d,%eax
setne  %al
and    $0x1,%al
movzbl %al,%eax
cltq
mov    -0x24(%rbp,%rax,4),%eax
add    $0x1,%eax
movsbl -0x15(%rbp),%ecx
cmp    $0x4d,%ecx
setne  %cl
xor    $0xff,%cl
and    $0x1,%cl
movzbl %cl,%ecx
movslq %ecx,%rcx
sub    -0x24(%rbp,%rcx,4),%eax
cmp    $0x0,%eax
jge    13af <people_in+0x29f>
movsbl -0x15(%rbp),%eax
cmp    $0x4d,%eax
setne  %al
and    $0x1,%al
movzbl %al,%eax
cltq
mov    -0x24(%rbp,%rax,4),%ecx
add    $0x1,%ecx
movsbl -0x15(%rbp),%eax
cmp    $0x4d,%eax
setne  %al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
cltq
sub    -0x24(%rbp,%rax,4),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x34(%rbp)
jmp    13e4 <people_in+0x2d4>
movsbl -0x15(%rbp),%eax
cmp    $0x4d,%eax
setne  %al
and    $0x1,%al
movzbl %al,%eax
cltq
mov    -0x24(%rbp,%rax,4),%eax
add    $0x1,%eax
movsbl -0x15(%rbp),%ecx
cmp    $0x4d,%ecx
setne  %cl
xor    $0xff,%cl
and    $0x1,%cl
movzbl %cl,%ecx
movslq %ecx,%rcx
sub    -0x24(%rbp,%rcx,4),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     141a <people_in+0x30a>
movsbl -0x15(%rbp),%eax
cmp    $0x4d,%eax
setne  %al
and    $0x1,%al
movzbl %al,%eax
cltq
mov    -0x24(%rbp,%rax,4),%ecx
add    $0x1,%ecx
mov    %ecx,-0x24(%rbp,%rax,4)
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
jmp    141f <people_in+0x30f>
jmp    142e <people_in+0x31e>
jmp    1424 <people_in+0x314>
jmp    1429 <people_in+0x319>
jmp    113e <people_in+0x2e>
mov    -0x24(%rbp),%eax
add    -0x20(%rbp),%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<people_in>:
push   %rbp
push   %rbx
movq   $0x0,-0x8(%rsp)
test   %rsi,%rsi
je     11c8 <people_in+0xc8>
xor    %eax,%eax
xor    %r11d,%r11d
xor    %r9d,%r9d
jmp    1132 <people_in+0x32>
xchg   %ax,%ax
mov    %ecx,-0x8(%rsp,%rax,4)
mov    %r8d,%r11d
movslq %r10d,%rax
mov    %r10d,%r9d
cmp    %rsi,%rax
jae    1198 <people_in+0x98>
mov    %r11d,%r8d
lea    0x1(%r9),%r10d
movzbl (%rdi,%rax,1),%r11d
xor    %ebx,%ebx
xor    %eax,%eax
cmp    $0x4d,%r11b
sete   %bl
setne  %al
mov    -0x8(%rsp,%rax,4),%ecx
add    $0x1,%ecx
mov    %ecx,%ebp
sub    -0x8(%rsp,%rbx,4),%ebp
mov    %ebp,%ebx
neg    %ebx
cmovs  %ebp,%ebx
cmp    %edx,%ebx
jle    1120 <people_in+0x20>
test   %r8b,%r8b
je     1127 <people_in+0x27>
xor    %ebx,%ebx
xor    %eax,%eax
cmp    $0x4d,%r8b
sete   %bl
setne  %al
mov    -0x8(%rsp,%rax,4),%ecx
add    $0x1,%ecx
mov    %ecx,%ebp
sub    -0x8(%rsp,%rbx,4),%ebp
mov    %ebp,%ebx
neg    %ebx
cmovs  %ebp,%ebx
cmp    %edx,%ebx
jg     11c8 <people_in+0xc8>
mov    %ecx,-0x8(%rsp,%rax,4)
mov    %r9d,%r10d
jmp    1124 <people_in+0x24>
test   %r11b,%r11b
je     11c8 <people_in+0xc8>
xor    %esi,%esi
xor    %eax,%eax
cmp    $0x4d,%r11b
sete   %sil
setne  %al
mov    -0x8(%rsp,%rax,4),%ecx
add    $0x1,%ecx
mov    %ecx,%edi
sub    -0x8(%rsp,%rsi,4),%edi
mov    %edi,%esi
neg    %esi
cmovs  %edi,%esi
cmp    %edx,%esi
jg     11c8 <people_in+0xc8>
mov    %ecx,-0x8(%rsp,%rax,4)
mov    -0x4(%rsp),%eax
add    -0x8(%rsp),%eax
pop    %rbx
pop    %rbp
ret

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

LLVM IR (-O2):
define i32 @people_in(i8* nocapture %0, i64 %1, i32 %2) {
%4 = alloca i64
%5 = bitcast i64* %4 to [2 x i32]*
%6 = bitcast i64* %4 to i8*
store i64 0, i64* %4
%7 = icmp eq i64 %1, 0
br i1 %7, label %65, label %24
8: ; preds = %60
%9 = icmp eq i8 %62, 0
br i1 %9, label %65, label %10
10: ; preds = %8
%11 = icmp ne i8 %62, 77
%12 = zext i1 %11 to i64
%13 = getelementptr inbounds [2 x i32], [2 x i32]* %5, i64 0, i64 %12
%14 = load i32, i32* %13
%15 = add nsw i32 %14, 1
%16 = xor i1 %11, true
%17 = zext i1 %16 to i64
%18 = getelementptr inbounds [2 x i32], [2 x i32]* %5, i64 0, i64 %17
%19 = load i32, i32* %18
%20 = sub nsw i32 %15, %19
%21 = tail call i32 @llvm.abs.i32(i32 %20, i1 true)
%22 = icmp sgt i32 %21, %2
br i1 %22, label %65, label %23
23: ; preds = %10
store i32 %15, i32* %13
br label %65
24: ; preds = %3, %60
%25 = phi i64 [ %63, %60 ], [ 0, %3 ]
%26 = phi i8 [ %62, %60 ], [ 0, %3 ]
%27 = phi i32 [ %61, %60 ], [ 0, %3 ]
%28 = add nsw i32 %27, 1
%29 = getelementptr inbounds i8, i8* %0, i64 %25
%30 = load i8, i8* %29
%31 = icmp ne i8 %30, 77
%32 = zext i1 %31 to i64
%33 = getelementptr inbounds [2 x i32], [2 x i32]* %5, i64 0, i64 %32
%34 = load i32, i32* %33
%35 = add nsw i32 %34, 1
%36 = xor i1 %31, true
%37 = zext i1 %36 to i64
%38 = getelementptr inbounds [2 x i32], [2 x i32]* %5, i64 0, i64 %37
%39 = load i32, i32* %38
%40 = sub nsw i32 %35, %39
%41 = tail call i32 @llvm.abs.i32(i32 %40, i1 true)
%42 = icmp sgt i32 %41, %2
br i1 %42, label %44, label %43
43: ; preds = %24
store i32 %35, i32* %33
br label %60
44: ; preds = %24
%45 = icmp eq i8 %26, 0
br i1 %45, label %60, label %46
46: ; preds = %44
%47 = icmp ne i8 %26, 77
%48 = zext i1 %47 to i64
%49 = getelementptr inbounds [2 x i32], [2 x i32]* %5, i64 0, i64 %48
%50 = load i32, i32* %49
%51 = add nsw i32 %50, 1
%52 = xor i1 %47, true
%53 = zext i1 %52 to i64
%54 = getelementptr inbounds [2 x i32], [2 x i32]* %5, i64 0, i64 %53
%55 = load i32, i32* %54
%56 = sub nsw i32 %51, %55
%57 = tail call i32 @llvm.abs.i32(i32 %56, i1 true)
%58 = icmp sgt i32 %57, %2
br i1 %58, label %65, label %59
59: ; preds = %46
store i32 %51, i32* %49
br label %60
60: ; preds = %43, %59, %44
%61 = phi i32 [ %28, %43 ], [ %27, %59 ], [ %28, %44 ]
%62 = phi i8 [ %26, %43 ], [ %26, %59 ], [ %30, %44 ]
%63 = sext i32 %61 to i64
%64 = icmp ult i64 %63, %1
br i1 %64, label %24, label %8
65: ; preds = %46, %3, %8, %10, %23
%66 = bitcast i64* %4 to i32*
%67 = load i32, i32* %66
%68 = getelementptr inbounds [2 x i32], [2 x i32]* %5, i64 0, i64 1
%69 = load i32, i32* %68
%70 = add nsw i32 %69, %67
ret i32 %70
}