#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
scalar_t__ malloc(int);
char *closureContent(char *str, char start, char end) {
  int len = 0, i = 0;
  while (str[len]) {
    if (str[len] == start)
      i++;
    else if (str[len] == end) {
      if (i)
        i--;
      else
        break;
    }
    len++;
  }
  char *result = (char *)malloc((len + 1) * sizeof(char));
  i = 0;
  while (i < len) {
    result[i] = str[i];
    i++;
  }
  result[i] = '\0';
  return result;
}


x86 assembly (clang, -O0):
<closureContent>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %dl,%al
mov    %sil,%cl
mov    %rdi,-0x8(%rbp)
mov    %cl,-0x9(%rbp)
mov    %al,-0xa(%rbp)
movl   $0x0,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
cmpb   $0x0,(%rax,%rcx,1)
je     11ba <closureContent+0xaa>
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
movsbl -0x9(%rbp),%ecx
cmp    %ecx,%eax
jne    116d <closureContent+0x5d>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    11ac <closureContent+0x9c>
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
movsbl -0xa(%rbp),%ecx
cmp    %ecx,%eax
jne    11a7 <closureContent+0x97>
cmpl   $0x0,-0x14(%rbp)
je     119d <closureContent+0x8d>
mov    -0x14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
jmp    11a2 <closureContent+0x92>
jmp    11ba <closureContent+0xaa>
jmp    11a7 <closureContent+0x97>
jmp    11ac <closureContent+0x9c>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1135 <closureContent+0x25>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x0,%rax
mov    %eax,%edi
call   1030 <malloc@plt>
mov    %rax,-0x20(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1208 <closureContent+0xf8>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x20(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    11d8 <closureContent+0xc8>
mov    -0x20(%rbp),%rax
movslq -0x14(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x20(%rbp),%rax
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<closureContent>:
push   %r14
push   %rbx
push   %rax
mov    (%rdi),%cl
test   %cl,%cl
je     11f1 <closureContent+0xe1>
mov    %rdi,%r14
xor    %ebx,%ebx
xor    %eax,%eax
jmp    1141 <closureContent+0x31>
nopw   0x0(%rax,%rax,1)
add    $0x1,%eax
movzbl 0x1(%r14,%rbx,1),%ecx
add    $0x1,%rbx
test   %cl,%cl
je     1157 <closureContent+0x47>
cmp    %sil,%cl
je     1130 <closureContent+0x20>
cmp    %dl,%cl
jne    1133 <closureContent+0x23>
test   %eax,%eax
je     1217 <closureContent+0x107>
add    $0xffffffff,%eax
jmp    1133 <closureContent+0x23>
lea    0x1(%rbx),%edi
call   1030 <malloc@plt>
mov    %ebx,%r9d
cmp    $0x8,%ebx
jb     1181 <closureContent+0x71>
lea    (%r14,%r9,1),%rcx
cmp    %rcx,%rax
jae    120b <closureContent+0xfb>
lea    (%rax,%r9,1),%rcx
cmp    %r14,%rcx
jbe    120b <closureContent+0xfb>
xor    %edx,%edx
mov    %rdx,%rsi
not    %rsi
add    %r9,%rsi
mov    %r9,%rdi
and    $0x3,%rdi
je     11b2 <closureContent+0xa2>
cs nopw 0x0(%rax,%rax,1)
nop
movzbl (%r14,%rdx,1),%ecx
mov    %cl,(%rax,%rdx,1)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rdi
jne    11a0 <closureContent+0x90>
cmp    $0x3,%rsi
jb     11fd <closureContent+0xed>
nopl   0x0(%rax,%rax,1)
movzbl (%r14,%rdx,1),%ecx
mov    %cl,(%rax,%rdx,1)
movzbl 0x1(%r14,%rdx,1),%ecx
mov    %cl,0x1(%rax,%rdx,1)
movzbl 0x2(%r14,%rdx,1),%ecx
mov    %cl,0x2(%rax,%rdx,1)
movzbl 0x3(%r14,%rdx,1),%ecx
mov    %cl,0x3(%rax,%rdx,1)
add    $0x4,%rdx
cmp    %rdx,%r9
jne    11c0 <closureContent+0xb0>
jmp    11fd <closureContent+0xed>
mov    $0x1,%edi
call   1030 <malloc@plt>
xor    %ebx,%ebx
mov    %ebx,%ecx
movb   $0x0,(%rax,%rcx,1)
add    $0x8,%rsp
pop    %rbx
pop    %r14
ret
cmp    $0x20,%ebx
jae    122b <closureContent+0x11b>
xor    %edx,%edx
jmp    130e <closureContent+0x1fe>
lea    0x1(%rbx),%edi
call   1030 <malloc@plt>
test   %ebx,%ebx
jne    115f <closureContent+0x4f>
xor    %ebx,%ebx
jmp    11fd <closureContent+0xed>
mov    %r9d,%edx
and    $0xffffffe0,%edx
lea    -0x20(%rdx),%rcx
mov    %rcx,%rdi
shr    $0x5,%rdi
add    $0x1,%rdi
mov    %edi,%r8d
and    $0x3,%r8d
cmp    $0x60,%rcx
jae    1251 <closureContent+0x141>
xor    %esi,%esi
jmp    12c0 <closureContent+0x1b0>
and    $0xfffffffffffffffc,%rdi
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movups (%r14,%rsi,1),%xmm0
movups 0x10(%r14,%rsi,1),%xmm1
movups %xmm0,(%rax,%rsi,1)
movups %xmm1,0x10(%rax,%rsi,1)
movups 0x20(%r14,%rsi,1),%xmm0
movups 0x30(%r14,%rsi,1),%xmm1
movups %xmm0,0x20(%rax,%rsi,1)
movups %xmm1,0x30(%rax,%rsi,1)
movups 0x40(%r14,%rsi,1),%xmm0
movups 0x50(%r14,%rsi,1),%xmm1
movups %xmm0,0x40(%rax,%rsi,1)
movups %xmm1,0x50(%rax,%rsi,1)
movups 0x60(%r14,%rsi,1),%xmm0
movups 0x70(%r14,%rsi,1),%xmm1
movups %xmm0,0x60(%rax,%rsi,1)
movups %xmm1,0x70(%rax,%rsi,1)
sub    $0xffffffffffffff80,%rsi
add    $0xfffffffffffffffc,%rdi
jne    1260 <closureContent+0x150>
test   %r8,%r8
je     12fb <closureContent+0x1eb>
lea    (%rax,%rsi,1),%rdi
add    $0x10,%rdi
add    %r14,%rsi
add    $0x10,%rsi
shl    $0x5,%r8
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movups -0x10(%rsi,%rcx,1),%xmm0
movups (%rsi,%rcx,1),%xmm1
movups %xmm0,-0x10(%rdi,%rcx,1)
movups %xmm1,(%rdi,%rcx,1)
add    $0x20,%rcx
cmp    %rcx,%r8
jne    12e0 <closureContent+0x1d0>
cmp    %r9,%rdx
je     11fd <closureContent+0xed>
test   $0x18,%r9b
je     1183 <closureContent+0x73>
mov    %rdx,%rsi
mov    %r9d,%edx
and    $0xfffffff8,%edx
nopw   0x0(%rax,%rax,1)
mov    (%r14,%rsi,1),%rcx
mov    %rcx,(%rax,%rsi,1)
add    $0x8,%rsi
cmp    %rsi,%rdx
jne    1320 <closureContent+0x210>
cmp    %r9,%rdx
je     11fd <closureContent+0xed>
jmp    1183 <closureContent+0x73>

LLVM IR (-O0):
define i8* @closureContent(i8* %0, i8 signext %1, i8 signext %2) {
%4 = alloca i8*
%5 = alloca i8
%6 = alloca i8
%7 = alloca i32
%8 = alloca i32
%9 = alloca i8*
store i8* %0, i8** %4
store i8 %1, i8* %5
store i8 %2, i8* %6
store i32 0, i32* %7
store i32 0, i32* %8
br label %10
10: ; preds = %49, %3
%11 = load i8*, i8** %4
%12 = load i32, i32* %7
%13 = sext i32 %12 to i64
%14 = getelementptr inbounds i8, i8* %11, i64 %13
%15 = load i8, i8* %14
%16 = icmp ne i8 %15, 0
br i1 %16, label %17, label %52
17: ; preds = %10
%18 = load i8*, i8** %4
%19 = load i32, i32* %7
%20 = sext i32 %19 to i64
%21 = getelementptr inbounds i8, i8* %18, i64 %20
%22 = load i8, i8* %21
%23 = sext i8 %22 to i32
%24 = load i8, i8* %5
%25 = sext i8 %24 to i32
%26 = icmp eq i32 %23, %25
br i1 %26, label %27, label %30
27: ; preds = %17
%28 = load i32, i32* %8
%29 = add nsw i32 %28, 1
store i32 %29, i32* %8
br label %49
30: ; preds = %17
%31 = load i8*, i8** %4
%32 = load i32, i32* %7
%33 = sext i32 %32 to i64
%34 = getelementptr inbounds i8, i8* %31, i64 %33
%35 = load i8, i8* %34
%36 = sext i8 %35 to i32
%37 = load i8, i8* %6
%38 = sext i8 %37 to i32
%39 = icmp eq i32 %36, %38
br i1 %39, label %40, label %48
40: ; preds = %30
%41 = load i32, i32* %8
%42 = icmp ne i32 %41, 0
br i1 %42, label %43, label %46
43: ; preds = %40
%44 = load i32, i32* %8
%45 = add nsw i32 %44, -1
store i32 %45, i32* %8
br label %47
46: ; preds = %40
br label %52
47: ; preds = %43
br label %48
48: ; preds = %47, %30
br label %49
49: ; preds = %48, %27
%50 = load i32, i32* %7
%51 = add nsw i32 %50, 1
store i32 %51, i32* %7
br label %10
52: ; preds = %46, %10
%53 = load i32, i32* %7
%54 = add nsw i32 %53, 1
%55 = sext i32 %54 to i64
%56 = mul i64 %55, 1
%57 = trunc i64 %56 to i32
%58 = call i64 @malloc(i32 %57)
%59 = inttoptr i64 %58 to i8*
store i8* %59, i8** %9
store i32 0, i32* %8
br label %60
60: ; preds = %64, %52
%61 = load i32, i32* %8
%62 = load i32, i32* %7
%63 = icmp slt i32 %61, %62
br i1 %63, label %64, label %76
64: ; preds = %60
%65 = load i8*, i8** %4
%66 = load i32, i32* %8
%67 = sext i32 %66 to i64
%68 = getelementptr inbounds i8, i8* %65, i64 %67
%69 = load i8, i8* %68
%70 = load i8*, i8** %9
%71 = load i32, i32* %8
%72 = sext i32 %71 to i64
%73 = getelementptr inbounds i8, i8* %70, i64 %72
store i8 %69, i8* %73
%74 = load i32, i32* %8
%75 = add nsw i32 %74, 1
store i32 %75, i32* %8
br label %60
76: ; preds = %60
%77 = load i8*, i8** %9
%78 = load i32, i32* %8
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds i8, i8* %77, i64 %79
store i8 0, i8* %80
%81 = load i8*, i8** %9
ret i8* %81
}

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