#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 strlen(char const *);
scalar_t__ strncmp(char const *, char const *, int);
int _xmlGetString(const char *xmlString, const char *tagName,
                  const int tagIndex, char *strOut, const int outBufLen) {
  const char *src, *srcStart, *srcEnd;
  int tagLen;
  char *dst;
  int index;
  tagLen = strlen(tagName);
  index = 0;
  for (src = xmlString + 1; src[0] != 0; src++) {
    if (src[0] != '<')
      continue;
    src++;
    if (strncmp(src, tagName, tagLen) != 0)
      continue;
    src += tagLen;
    if (src[0] != '>')
      continue;
    src++;
    if (index == tagIndex)
      break;
    index++;
  }
  if (src[0] == 0)
    return -1;
  srcStart = srcEnd = src;
  for (; src[0] != 0; src++) {
    srcEnd = src;
    if (src[0] != '<')
      continue;
    src++;
    if (src[0] != '/')
      continue;
    src++;
    if (strncmp(src, tagName, tagLen) != 0)
      continue;
    src += tagLen;
    if (src[0] != '>')
      continue;
    src++;
    break;
  }
  if (src[0] == 0)
    return -2;
  if (srcEnd - srcStart >= outBufLen)
    return -3;
  dst = strOut;
  for (src = srcStart; src != srcEnd; src++) {
    *dst = *src;
    dst++;
  }
  *dst = 0;
  return 0;
}


x86 assembly (clang, -O0):
<_xmlGetString>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8d,-0x2c(%rbp)
mov    -0x18(%rbp),%rdi
call   1040 <strlen@plt>
mov    %eax,-0x4c(%rbp)
movl   $0x0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
je     1207 <_xmlGetString+0xe7>
mov    -0x38(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x3c,%eax
je     117f <_xmlGetString+0x5f>
jmp    11f6 <_xmlGetString+0xd6>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x4c(%rbp),%edx
call   1030 <strncmp@plt>
cmp    $0x0,%rax
je     11aa <_xmlGetString+0x8a>
jmp    11f6 <_xmlGetString+0xd6>
mov    -0x4c(%rbp),%ecx
mov    -0x38(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x3e,%eax
je     11d0 <_xmlGetString+0xb0>
jmp    11f6 <_xmlGetString+0xd6>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jne    11ed <_xmlGetString+0xcd>
jmp    1207 <_xmlGetString+0xe7>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    115a <_xmlGetString+0x3a>
mov    -0x38(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
jne    1223 <_xmlGetString+0x103>
movl   $0xffffffff,-0x4(%rbp)
jmp    1385 <_xmlGetString+0x265>
mov    -0x38(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    %rax,-0x40(%rbp)
mov    -0x38(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
je     12f0 <_xmlGetString+0x1d0>
mov    -0x38(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x38(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x3c,%eax
je     125c <_xmlGetString+0x13c>
jmp    12df <_xmlGetString+0x1bf>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2f,%eax
je     127d <_xmlGetString+0x15d>
jmp    12df <_xmlGetString+0x1bf>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x4c(%rbp),%edx
call   1030 <strncmp@plt>
cmp    $0x0,%rax
je     12a8 <_xmlGetString+0x188>
jmp    12df <_xmlGetString+0x1bf>
mov    -0x4c(%rbp),%ecx
mov    -0x38(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x3e,%eax
je     12ce <_xmlGetString+0x1ae>
jmp    12df <_xmlGetString+0x1bf>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    12f0 <_xmlGetString+0x1d0>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    122f <_xmlGetString+0x10f>
mov    -0x38(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
jne    130c <_xmlGetString+0x1ec>
movl   $0xfffffffe,-0x4(%rbp)
jmp    1385 <_xmlGetString+0x265>
mov    -0x48(%rbp),%rax
mov    -0x40(%rbp),%rcx
sub    %rcx,%rax
movslq -0x2c(%rbp),%rcx
cmp    %rcx,%rax
jl     1330 <_xmlGetString+0x210>
movl   $0xfffffffd,-0x4(%rbp)
jmp    1385 <_xmlGetString+0x265>
mov    -0x28(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x48(%rbp),%rax
je     1377 <_xmlGetString+0x257>
mov    -0x38(%rbp),%rax
mov    (%rax),%cl
mov    -0x58(%rbp),%rax
mov    %cl,(%rax)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    1340 <_xmlGetString+0x220>
mov    -0x58(%rbp),%rax
movb   $0x0,(%rax)
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<_xmlGetString>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %r8d,0x24(%rsp)
mov    %rcx,0x10(%rsp)
mov    %edx,0x18(%rsp)
mov    %rsi,%r12
mov    %rdi,%r14
mov    %rsi,%rdi
call   1040 <strlen@plt>
mov    %eax,%ebp
movslq %eax,%r15
movl   $0x0,0x8(%rsp)
jmp    116b <_xmlGetString+0x4b>
nopl   0x0(%rax)
add    $0x1,%rbx
mov    %rbx,%r14
test   %al,%al
je     11c0 <_xmlGetString+0xa0>
mov    %r14,%rbx
movzbl 0x1(%r14),%eax
cmp    $0x3c,%al
jne    1160 <_xmlGetString+0x40>
lea    0x2(%rbx),%r14
mov    %r14,%rdi
mov    %r12,%rsi
mov    %ebp,%edx
call   1030 <strncmp@plt>
test   %rax,%rax
jne    116b <_xmlGetString+0x4b>
lea    (%r14,%r15,1),%r13
cmpb   $0x3e,(%r14,%r15,1)
mov    %r13,%r14
jne    116b <_xmlGetString+0x4b>
lea    0x1(%r13),%r14
mov    0x8(%rsp),%eax
cmp    0x18(%rsp),%eax
je     11b2 <_xmlGetString+0x92>
add    $0x1,%eax
mov    %eax,0x8(%rsp)
jmp    116b <_xmlGetString+0x4b>
mov    (%r14),%al
test   %al,%al
je     11c0 <_xmlGetString+0xa0>
mov    $0x1,%ecx
jmp    11e6 <_xmlGetString+0xc6>
mov    $0xffffffff,%eax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
test   %al,%al
je     1267 <_xmlGetString+0x147>
movzbl 0x1(%r13,%rcx,1),%eax
add    $0x1,%rcx
cmp    $0x3c,%al
jne    11d4 <_xmlGetString+0xb4>
cmpb   $0x2f,0x1(%r13,%rcx,1)
jne    121e <_xmlGetString+0xfe>
lea    0x2(%rcx),%rax
mov    %rax,0x8(%rsp)
lea    (%rcx,%r13,1),%rdi
add    $0x2,%rdi
mov    %r12,%rsi
mov    %ebp,%edx
mov    %rcx,0x18(%rsp)
call   1030 <strncmp@plt>
test   %rax,%rax
je     1224 <_xmlGetString+0x104>
mov    0x8(%rsp),%rcx
jmp    11dc <_xmlGetString+0xbc>
add    $0x1,%rcx
jmp    11dc <_xmlGetString+0xbc>
mov    0x18(%rsp),%rdx
mov    0x8(%rsp),%rcx
add    %r15,%rcx
cmpb   $0x3e,0x0(%r13,%rcx,1)
jne    11dc <_xmlGetString+0xbc>
cmpb   $0x0,0x1(%r13,%rcx,1)
je     1267 <_xmlGetString+0x147>
movslq 0x24(%rsp),%rcx
mov    $0xfffffffd,%eax
cmp    %rcx,%rdx
jg     11c5 <_xmlGetString+0xa5>
mov    %rdx,%rcx
cmp    $0x1,%rdx
jne    1271 <_xmlGetString+0x151>
mov    0x10(%rsp),%rsi
jmp    13f9 <_xmlGetString+0x2d9>
mov    $0xfffffffe,%eax
jmp    11c5 <_xmlGetString+0xa5>
add    %rcx,%r13
mov    %r13,%rax
sub    %r14,%rax
cmp    $0x20,%rax
mov    0x10(%rsp),%rsi
jb     137f <_xmlGetString+0x25f>
cmp    %rsi,%r13
jbe    129b <_xmlGetString+0x17b>
lea    (%rsi,%rax,1),%rcx
cmp    %rcx,%r14
jb     137f <_xmlGetString+0x25f>
mov    %rax,%r8
and    $0xffffffffffffffe0,%r8
lea    -0x20(%r8),%rdi
mov    %rdi,%rsi
shr    $0x5,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0x60,%rdi
jae    12c5 <_xmlGetString+0x1a5>
xor    %edi,%edi
mov    0x10(%rsp),%rcx
jmp    1331 <_xmlGetString+0x211>
and    $0xfffffffffffffffc,%rsi
lea    (%r15,%rbx,1),%rbp
add    $0x73,%rbp
xor    %edi,%edi
mov    0x10(%rsp),%rcx
movups -0x70(%rbp,%rdi,1),%xmm0
movups -0x60(%rbp,%rdi,1),%xmm1
movups %xmm0,(%rcx,%rdi,1)
movups %xmm1,0x10(%rcx,%rdi,1)
movups -0x50(%rbp,%rdi,1),%xmm0
movups -0x40(%rbp,%rdi,1),%xmm1
movups %xmm0,0x20(%rcx,%rdi,1)
movups %xmm1,0x30(%rcx,%rdi,1)
movups -0x30(%rbp,%rdi,1),%xmm0
movups -0x20(%rbp,%rdi,1),%xmm1
movups %xmm0,0x40(%rcx,%rdi,1)
movups %xmm1,0x50(%rcx,%rdi,1)
movups -0x10(%rbp,%rdi,1),%xmm0
movups 0x0(%rbp,%rdi,1),%xmm1
movups %xmm0,0x60(%rcx,%rdi,1)
movups %xmm1,0x70(%rcx,%rdi,1)
sub    $0xffffffffffffff80,%rdi
add    $0xfffffffffffffffc,%rsi
jne    12d8 <_xmlGetString+0x1b8>
test   %rdx,%rdx
je     1369 <_xmlGetString+0x249>
add    %rdi,%r15
lea    (%rbx,%r15,1),%rsi
add    $0x13,%rsi
add    %rcx,%rdi
add    $0x10,%rdi
shl    $0x5,%rdx
xor    %ebp,%ebp
movups -0x10(%rsi,%rbp,1),%xmm0
movups (%rsi,%rbp,1),%xmm1
movups %xmm0,-0x10(%rdi,%rbp,1)
movups %xmm1,(%rdi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rdx
jne    134e <_xmlGetString+0x22e>
add    %r8,%rcx
cmp    %r8,%rax
jne    1379 <_xmlGetString+0x259>
mov    %rcx,%rsi
jmp    13f9 <_xmlGetString+0x2d9>
add    %r8,%r14
mov    %rcx,%rsi
mov    %r13d,%ecx
sub    %r14d,%ecx
mov    %r14,%rax
not    %rax
add    %r13,%rax
and    $0x7,%rcx
je     13a8 <_xmlGetString+0x288>
movzbl (%r14),%edx
mov    %dl,(%rsi)
add    $0x1,%rsi
add    $0x1,%r14
add    $0xffffffffffffffff,%rcx
jne    1394 <_xmlGetString+0x274>
cmp    $0x7,%rax
jb     13f9 <_xmlGetString+0x2d9>
movzbl (%r14),%eax
mov    %al,(%rsi)
movzbl 0x1(%r14),%eax
mov    %al,0x1(%rsi)
movzbl 0x2(%r14),%eax
mov    %al,0x2(%rsi)
movzbl 0x3(%r14),%eax
mov    %al,0x3(%rsi)
movzbl 0x4(%r14),%eax
mov    %al,0x4(%rsi)
movzbl 0x5(%r14),%eax
mov    %al,0x5(%rsi)
movzbl 0x6(%r14),%eax
mov    %al,0x6(%rsi)
movzbl 0x7(%r14),%eax
mov    %al,0x7(%rsi)
add    $0x8,%rsi
add    $0x8,%r14
cmp    %r13,%r14
jne    13ae <_xmlGetString+0x28e>
movb   $0x0,(%rsi)
xor    %eax,%eax
jmp    11c5 <_xmlGetString+0xa5>

LLVM IR (-O0):
define i32 @_xmlGetString(i8* %0, i8* %1, i32 %2, i8* %3, i32 %4) {
%6 = alloca i32
%7 = alloca i8*
%8 = alloca i8*
%9 = alloca i32
%10 = alloca i8*
%11 = alloca i32
%12 = alloca i8*
%13 = alloca i8*
%14 = alloca i8*
%15 = alloca i32
%16 = alloca i8*
%17 = alloca i32
store i8* %0, i8** %7
store i8* %1, i8** %8
store i32 %2, i32* %9
store i8* %3, i8** %10
store i32 %4, i32* %11
%18 = load i8*, i8** %8
%19 = call i32 @strlen(i8* %18)
store i32 %19, i32* %15
store i32 0, i32* %17
%20 = load i8*, i8** %7
%21 = getelementptr inbounds i8, i8* %20, i64 1
store i8* %21, i8** %12
br label %22
22: ; preds = %65, %5
%23 = load i8*, i8** %12
%24 = getelementptr inbounds i8, i8* %23, i64 0
%25 = load i8, i8* %24
%26 = sext i8 %25 to i32
%27 = icmp ne i32 %26, 0
br i1 %27, label %28, label %68
28: ; preds = %22
%29 = load i8*, i8** %12
%30 = getelementptr inbounds i8, i8* %29, i64 0
%31 = load i8, i8* %30
%32 = sext i8 %31 to i32
%33 = icmp ne i32 %32, 60
br i1 %33, label %34, label %35
34: ; preds = %28
br label %65
35: ; preds = %28
%36 = load i8*, i8** %12
%37 = getelementptr inbounds i8, i8* %36, i32 1
store i8* %37, i8** %12
%38 = load i8*, i8** %12
%39 = load i8*, i8** %8
%40 = load i32, i32* %15
%41 = call i64 @strncmp(i8* %38, i8* %39, i32 %40)
%42 = icmp ne i64 %41, 0
br i1 %42, label %43, label %44
43: ; preds = %35
br label %65
44: ; preds = %35
%45 = load i32, i32* %15
%46 = load i8*, i8** %12
%47 = sext i32 %45 to i64
%48 = getelementptr inbounds i8, i8* %46, i64 %47
store i8* %48, i8** %12
%49 = load i8*, i8** %12
%50 = getelementptr inbounds i8, i8* %49, i64 0
%51 = load i8, i8* %50
%52 = sext i8 %51 to i32
%53 = icmp ne i32 %52, 62
br i1 %53, label %54, label %55
54: ; preds = %44
br label %65
55: ; preds = %44
%56 = load i8*, i8** %12
%57 = getelementptr inbounds i8, i8* %56, i32 1
store i8* %57, i8** %12
%58 = load i32, i32* %17
%59 = load i32, i32* %9
%60 = icmp eq i32 %58, %59
br i1 %60, label %61, label %62
61: ; preds = %55
br label %68
62: ; preds = %55
%63 = load i32, i32* %17
%64 = add nsw i32 %63, 1
store i32 %64, i32* %17
br label %65
65: ; preds = %62, %54, %43, %34
%66 = load i8*, i8** %12
%67 = getelementptr inbounds i8, i8* %66, i32 1
store i8* %67, i8** %12
br label %22
68: ; preds = %61, %22
%69 = load i8*, i8** %12
%70 = getelementptr inbounds i8, i8* %69, i64 0
%71 = load i8, i8* %70
%72 = sext i8 %71 to i32
%73 = icmp eq i32 %72, 0
br i1 %73, label %74, label %75
74: ; preds = %68
store i32 -1, i32* %6
br label %161
75: ; preds = %68
%76 = load i8*, i8** %12
store i8* %76, i8** %14
store i8* %76, i8** %13
br label %77
77: ; preds = %123, %75
%78 = load i8*, i8** %12
%79 = getelementptr inbounds i8, i8* %78, i64 0
%80 = load i8, i8* %79
%81 = sext i8 %80 to i32
%82 = icmp ne i32 %81, 0
br i1 %82, label %83, label %126
83: ; preds = %77
%84 = load i8*, i8** %12
store i8* %84, i8** %14
%85 = load i8*, i8** %12
%86 = getelementptr inbounds i8, i8* %85, i64 0
%87 = load i8, i8* %86
%88 = sext i8 %87 to i32
%89 = icmp ne i32 %88, 60
br i1 %89, label %90, label %91
90: ; preds = %83
br label %123
91: ; preds = %83
%92 = load i8*, i8** %12
%93 = getelementptr inbounds i8, i8* %92, i32 1
store i8* %93, i8** %12
%94 = load i8*, i8** %12
%95 = getelementptr inbounds i8, i8* %94, i64 0
%96 = load i8, i8* %95
%97 = sext i8 %96 to i32
%98 = icmp ne i32 %97, 47
br i1 %98, label %99, label %100
99: ; preds = %91
br label %123
100: ; preds = %91
%101 = load i8*, i8** %12
%102 = getelementptr inbounds i8, i8* %101, i32 1
store i8* %102, i8** %12
%103 = load i8*, i8** %12
%104 = load i8*, i8** %8
%105 = load i32, i32* %15
%106 = call i64 @strncmp(i8* %103, i8* %104, i32 %105)
%107 = icmp ne i64 %106, 0
br i1 %107, label %108, label %109
108: ; preds = %100
br label %123
109: ; preds = %100
%110 = load i32, i32* %15
%111 = load i8*, i8** %12
%112 = sext i32 %110 to i64
%113 = getelementptr inbounds i8, i8* %111, i64 %112
store i8* %113, i8** %12
%114 = load i8*, i8** %12
%115 = getelementptr inbounds i8, i8* %114, i64 0
%116 = load i8, i8* %115
%117 = sext i8 %116 to i32
%118 = icmp ne i32 %117, 62
br i1 %118, label %119, label %120
119: ; preds = %109
br label %123
120: ; preds = %109
%121 = load i8*, i8** %12
%122 = getelementptr inbounds i8, i8* %121, i32 1
store i8* %122, i8** %12
br label %126
123: ; preds = %119, %108, %99, %90
%124 = load i8*, i8** %12
%125 = getelementptr inbounds i8, i8* %124, i32 1
store i8* %125, i8** %12
br label %77
126: ; preds = %120, %77
%127 = load i8*, i8** %12
%128 = getelementptr inbounds i8, i8* %127, i64 0
%129 = load i8, i8* %128
%130 = sext i8 %129 to i32
%131 = icmp eq i32 %130, 0
br i1 %131, label %132, label %133
132: ; preds = %126
store i32 -2, i32* %6
br label %161
133: ; preds = %126
%134 = load i8*, i8** %14
%135 = load i8*, i8** %13
%136 = ptrtoint i8* %134 to i64
%137 = ptrtoint i8* %135 to i64
%138 = sub i64 %136, %137
%139 = load i32, i32* %11
%140 = sext i32 %139 to i64
%141 = icmp sge i64 %138, %140
br i1 %141, label %142, label %143
142: ; preds = %133
store i32 -3, i32* %6
br label %161
143: ; preds = %133
%144 = load i8*, i8** %10
store i8* %144, i8** %16
%145 = load i8*, i8** %13
store i8* %145, i8** %12
br label %146
146: ; preds = %156, %143
%147 = load i8*, i8** %12
%148 = load i8*, i8** %14
%149 = icmp ne i8* %147, %148
br i1 %149, label %150, label %159
150: ; preds = %146
%151 = load i8*, i8** %12
%152 = load i8, i8* %151
%153 = load i8*, i8** %16
store i8 %152, i8* %153
%154 = load i8*, i8** %16
%155 = getelementptr inbounds i8, i8* %154, i32 1
store i8* %155, i8** %16
br label %156
156: ; preds = %150
%157 = load i8*, i8** %12
%158 = getelementptr inbounds i8, i8* %157, i32 1
store i8* %158, i8** %12
br label %146
159: ; preds = %146
%160 = load i8*, i8** %16
store i8 0, i8* %160
store i32 0, i32* %6
br label %161
161: ; preds = %159, %142, %132, %74
%162 = load i32, i32* %6
ret i32 %162
}

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