#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 */
char *getTok(char const **);
scalar_t__ matchkey(char const *, char const *, char *);
int /*<<< orphan*/ strcpy(char *, char *);
void getXMLCharset(const char *buf, char *charset) {
  const char *next, *p;
  charset[0] = '\0';
  next = buf;
  p = getTok(&next);
  if (matchkey(p, next, "text"))
    strcpy(charset, "us-ascii");
  else if (!matchkey(p, next, "application"))
    return;
  p = getTok(&next);
  if (!p || *p != '/')
    return;
  p = getTok(&next);
  p = getTok(&next);
  while (p) {
    if (*p == ';') {
      p = getTok(&next);
      if (matchkey(p, next, "charset")) {
        p = getTok(&next);
        if (p && *p == '=') {
          p = getTok(&next);
          if (p) {
            char *s = charset;
            if (*p == '"') {
              while (++p != next - 1) {
                if (*p == '\\')
                  ++p;
                if (s == charset + 41 - 1) {
                  charset[0] = '\0';
                  break;
                }
                *s++ = *p;
              }
              *s++ = '\0';
            } else {
              if (next - p > 41 - 1)
                break;
              while (p != next)
                *s++ = *p++;
              *s = 0;
              break;
            }
          }
        }
        break;
      }
    } else
      p = getTok(&next);
  }
}


x86 assembly (clang, -O0):
<getXMLCharset>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x10(%rbp),%rax
movb   $0x0,(%rax)
mov    -0x8(%rbp),%rax
mov    %rax,-0x18(%rbp)
lea    -0x18(%rbp),%rdi
call   1040 <getTok@plt>
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rdi
mov    -0x18(%rbp),%rsi
lea    0xe95(%rip),%rdx
call   1050 <matchkey@plt>
cmp    $0x0,%rax
je     118f <getXMLCharset+0x5f>
mov    -0x10(%rbp),%rdi
lea    0xe80(%rip),%rsi
call   1030 <strcpy@plt>
jmp    11b7 <getXMLCharset+0x87>
mov    -0x20(%rbp),%rdi
mov    -0x18(%rbp),%rsi
lea    0xe70(%rip),%rdx
call   1050 <matchkey@plt>
cmp    $0x0,%rax
jne    11b2 <getXMLCharset+0x82>
jmp    13b8 <getXMLCharset+0x288>
jmp    11b7 <getXMLCharset+0x87>
lea    -0x18(%rbp),%rdi
call   1040 <getTok@plt>
mov    %rax,-0x20(%rbp)
cmpq   $0x0,-0x20(%rbp)
je     11df <getXMLCharset+0xaf>
mov    -0x20(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2f,%eax
je     11e4 <getXMLCharset+0xb4>
jmp    13b8 <getXMLCharset+0x288>
lea    -0x18(%rbp),%rdi
call   1040 <getTok@plt>
mov    %rax,-0x20(%rbp)
lea    -0x18(%rbp),%rdi
call   1040 <getTok@plt>
mov    %rax,-0x20(%rbp)
cmpq   $0x0,-0x20(%rbp)
je     13b8 <getXMLCharset+0x288>
mov    -0x20(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x3b,%eax
jne    13a6 <getXMLCharset+0x276>
lea    -0x18(%rbp),%rdi
call   1040 <getTok@plt>
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rdi
mov    -0x18(%rbp),%rsi
lea    0xde5(%rip),%rdx
call   1050 <matchkey@plt>
cmp    $0x0,%rax
je     13a1 <getXMLCharset+0x271>
lea    -0x18(%rbp),%rdi
call   1040 <getTok@plt>
mov    %rax,-0x20(%rbp)
cmpq   $0x0,-0x20(%rbp)
je     139c <getXMLCharset+0x26c>
mov    -0x20(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x3d,%eax
jne    139c <getXMLCharset+0x26c>
lea    -0x18(%rbp),%rdi
call   1040 <getTok@plt>
mov    %rax,-0x20(%rbp)
cmpq   $0x0,-0x20(%rbp)
je     1397 <getXMLCharset+0x267>
mov    -0x10(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x22,%eax
jne    1332 <getXMLCharset+0x202>
jmp    12a1 <getXMLCharset+0x171>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rcx
add    $0xffffffffffffffff,%rcx
cmp    %rcx,%rax
je     131b <getXMLCharset+0x1eb>
mov    -0x20(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x5c,%eax
jne    12da <getXMLCharset+0x1aa>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x10(%rbp),%rcx
add    $0x29,%rcx
add    $0xffffffffffffffff,%rcx
cmp    %rcx,%rax
jne    12ff <getXMLCharset+0x1cf>
mov    -0x10(%rbp),%rax
movb   $0x0,(%rax)
jmp    131b <getXMLCharset+0x1eb>
mov    -0x20(%rbp),%rax
mov    (%rax),%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,(%rax)
jmp    12a1 <getXMLCharset+0x171>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movb   $0x0,(%rax)
jmp    1392 <getXMLCharset+0x262>
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%rcx
sub    %rcx,%rax
cmp    $0x28,%rax
jle    134c <getXMLCharset+0x21c>
jmp    13b8 <getXMLCharset+0x288>
jmp    1351 <getXMLCharset+0x221>
mov    -0x20(%rbp),%rax
cmp    -0x18(%rbp),%rax
je     1386 <getXMLCharset+0x256>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,(%rax)
jmp    1351 <getXMLCharset+0x221>
mov    -0x28(%rbp),%rax
movb   $0x0,(%rax)
jmp    13b8 <getXMLCharset+0x288>
jmp    1397 <getXMLCharset+0x267>
jmp    139c <getXMLCharset+0x26c>
jmp    13b8 <getXMLCharset+0x288>
jmp    13b3 <getXMLCharset+0x283>
lea    -0x18(%rbp),%rdi
call   1040 <getTok@plt>
mov    %rax,-0x20(%rbp)
jmp    11fe <getXMLCharset+0xce>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<getXMLCharset>:
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x10,%rsp
mov    %rsi,%r14
movb   $0x0,(%rsi)
mov    %rdi,0x8(%rsp)
lea    0x8(%rsp),%rdi
call   1040 <getTok@plt>
mov    %rax,%rbx
mov    0x8(%rsp),%rsi
lea    0xe9f(%rip),%rdx
mov    %rax,%rdi
call   1050 <matchkey@plt>
test   %rax,%rax
je     117f <getXMLCharset+0x4f>
lea    0xe90(%rip),%rsi
mov    %r14,%rdi
call   1030 <strcpy@plt>
jmp    119c <getXMLCharset+0x6c>
mov    0x8(%rsp),%rsi
lea    0xe83(%rip),%rdx
mov    %rbx,%rdi
call   1050 <matchkey@plt>
test   %rax,%rax
je     1357 <getXMLCharset+0x227>
lea    0x8(%rsp),%rdi
call   1040 <getTok@plt>
test   %rax,%rax
je     1357 <getXMLCharset+0x227>
cmpb   $0x2f,(%rax)
jne    1357 <getXMLCharset+0x227>
lea    0x8(%rsp),%rbx
mov    %rbx,%rdi
call   1040 <getTok@plt>
mov    %rbx,%rdi
call   1040 <getTok@plt>
test   %rax,%rax
je     1357 <getXMLCharset+0x227>
mov    %rax,%r13
lea    0x8(%rsp),%r15
lea    0xe35(%rip),%r12
jmp    11f9 <getXMLCharset+0xc9>
nopw   0x0(%rax,%rax,1)
test   %r13,%r13
je     1357 <getXMLCharset+0x227>
movzbl 0x0(%r13),%ebx
mov    %r15,%rdi
call   1040 <getTok@plt>
mov    %rax,%r13
cmp    $0x3b,%bl
jne    11f0 <getXMLCharset+0xc0>
mov    0x8(%rsp),%rsi
mov    %r13,%rdi
mov    %r12,%rdx
call   1050 <matchkey@plt>
test   %rax,%rax
je     11f0 <getXMLCharset+0xc0>
lea    0x8(%rsp),%rdi
call   1040 <getTok@plt>
test   %rax,%rax
je     1357 <getXMLCharset+0x227>
cmpb   $0x3d,(%rax)
jne    1357 <getXMLCharset+0x227>
lea    0x8(%rsp),%rdi
call   1040 <getTok@plt>
test   %rax,%rax
je     1357 <getXMLCharset+0x227>
mov    (%rax),%bl
mov    0x8(%rsp),%r11
cmp    $0x22,%bl
jne    12d5 <getXMLCharset+0x1a5>
add    $0xffffffffffffffff,%r11
mov    %rax,%rsi
add    $0x1,%rsi
cmp    %r11,%rsi
je     1353 <getXMLCharset+0x223>
lea    0x1(%r14),%rdx
mov    $0x28,%edi
jmp    129b <getXMLCharset+0x16b>
mov    %cl,%bl
movzbl 0x1(%rbx,%rsi,1),%ecx
mov    %cl,(%rdx)
lea    0x1(%rax),%rsi
add    $0x2,%rdx
add    $0xfffffffffffffffe,%rdi
cmp    %r11,%rsi
je     134c <getXMLCharset+0x21c>
cmpb   $0x5c,0x1(%rax)
jne    12a8 <getXMLCharset+0x178>
add    $0x2,%rax
mov    %rax,%rsi
test   %rdi,%rdi
je     1348 <getXMLCharset+0x218>
movzbl (%rsi),%eax
mov    %al,-0x1(%rdx)
lea    0x1(%rsi),%rax
cmp    %r11,%rax
je     1350 <getXMLCharset+0x220>
xor    %ebx,%ebx
cmpb   $0x5c,0x1(%rsi)
sete   %cl
jne    127d <getXMLCharset+0x14d>
lea    0x2(%rsi),%rax
jmp    127d <getXMLCharset+0x14d>
mov    %r11,%rdi
sub    %rax,%rdi
cmp    $0x28,%rdi
jg     1357 <getXMLCharset+0x227>
cmp    %r11,%rax
je     1353 <getXMLCharset+0x223>
lea    0x1(%rax),%rsi
lea    0x1(%r14),%rdx
mov    %bl,(%r14)
cmp    %r11,%rsi
je     1350 <getXMLCharset+0x220>
mov    %rax,%r9
not    %r9
add    %r11,%r9
cmp    $0x20,%r9
jb     1410 <getXMLCharset+0x2e0>
lea    (%rax,%rdi,1),%rcx
cmp    %rcx,%rdx
jae    131e <getXMLCharset+0x1ee>
add    %r14,%rdi
cmp    %rdi,%rsi
jb     1410 <getXMLCharset+0x2e0>
mov    %r9,%r8
and    $0xffffffffffffffe0,%r8
lea    -0x20(%r8),%rcx
mov    %rcx,%rbx
shr    $0x5,%rbx
add    $0x1,%rbx
mov    %ebx,%r10d
and    $0x3,%r10d
cmp    $0x60,%rcx
jae    1365 <getXMLCharset+0x235>
xor    %edi,%edi
jmp    13cd <getXMLCharset+0x29d>
movb   $0x0,(%r14)
add    $0xffffffffffffffff,%rdx
mov    %rdx,%r14
movb   $0x0,(%r14)
add    $0x10,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
ret
and    $0xfffffffffffffffc,%rbx
xor    %edi,%edi
movups 0x1(%rax,%rdi,1),%xmm0
movups 0x11(%rax,%rdi,1),%xmm1
movups %xmm0,0x1(%r14,%rdi,1)
movups %xmm1,0x11(%r14,%rdi,1)
movups 0x21(%rax,%rdi,1),%xmm0
movups 0x31(%rax,%rdi,1),%xmm1
movups %xmm0,0x21(%r14,%rdi,1)
movups %xmm1,0x31(%r14,%rdi,1)
movups 0x41(%rax,%rdi,1),%xmm0
movups 0x51(%rax,%rdi,1),%xmm1
movups %xmm0,0x41(%r14,%rdi,1)
movups %xmm1,0x51(%r14,%rdi,1)
movups 0x61(%rax,%rdi,1),%xmm0
movups 0x71(%rax,%rdi,1),%xmm1
movups %xmm0,0x61(%r14,%rdi,1)
movups %xmm1,0x71(%r14,%rdi,1)
sub    $0xffffffffffffff80,%rdi
add    $0xfffffffffffffffc,%rbx
jne    136b <getXMLCharset+0x23b>
test   %r10,%r10
je     1401 <getXMLCharset+0x2d1>
add    %rdi,%rax
add    $0x11,%rax
add    %r14,%rdi
add    $0x11,%rdi
shl    $0x5,%r10
xor    %ebx,%ebx
movups -0x10(%rax,%rbx,1),%xmm0
movups (%rax,%rbx,1),%xmm1
movups %xmm0,-0x10(%rdi,%rbx,1)
movups %xmm1,(%rdi,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%r10
jne    13e6 <getXMLCharset+0x2b6>
add    %r8,%rdx
cmp    %r8,%r9
je     1350 <getXMLCharset+0x220>
add    %r8,%rsi
mov    %r11d,%edi
sub    %esi,%edi
mov    %rsi,%rax
not    %rax
add    %r11,%rax
and    $0x7,%rdi
je     1437 <getXMLCharset+0x307>
movzbl (%rsi),%ecx
add    $0x1,%rsi
mov    %cl,(%rdx)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rdi
jne    1424 <getXMLCharset+0x2f4>
mov    %rdx,%r14
cmp    $0x7,%rax
jb     1353 <getXMLCharset+0x223>
movzbl (%rsi),%eax
mov    %al,(%rdx)
movzbl 0x1(%rsi),%eax
mov    %al,0x1(%rdx)
movzbl 0x2(%rsi),%eax
mov    %al,0x2(%rdx)
movzbl 0x3(%rsi),%eax
mov    %al,0x3(%rdx)
movzbl 0x4(%rsi),%eax
mov    %al,0x4(%rdx)
movzbl 0x5(%rsi),%eax
mov    %al,0x5(%rdx)
movzbl 0x6(%rsi),%eax
mov    %al,0x6(%rdx)
movzbl 0x7(%rsi),%eax
mov    %al,0x7(%rdx)
add    $0x8,%rdx
add    $0x8,%rsi
cmp    %r11,%rsi
jne    1444 <getXMLCharset+0x314>
jmp    1350 <getXMLCharset+0x220>

LLVM IR (-O0):
@.str = [5 x i8] c"text\00"
@.str.1 = [9 x i8] c"us-ascii\00"
@.str.2 = [12 x i8] c"application\00"
@.str.3 = [8 x i8] c"charset\00"
define void @getXMLCharset(i8* %0, i8* %1) {
%3 = alloca i8*
%4 = alloca i8*
%5 = alloca i8*
%6 = alloca i8*
%7 = alloca i8*
store i8* %0, i8** %3
store i8* %1, i8** %4
%8 = load i8*, i8** %4
%9 = getelementptr inbounds i8, i8* %8, i64 0
store i8 0, i8* %9
%10 = load i8*, i8** %3
store i8* %10, i8** %5
%11 = call i8* @getTok(i8** %5)
store i8* %11, i8** %6
%12 = load i8*, i8** %6
%13 = load i8*, i8** %5
%14 = call i64 @matchkey(i8* %12, i8* %13, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0))
%15 = icmp ne i64 %14, 0
br i1 %15, label %16, label %19
16: ; preds = %2
%17 = load i8*, i8** %4
%18 = call i32 @strcpy(i8* %17, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.1, i64 0, i64 0))
br label %26
19: ; preds = %2
%20 = load i8*, i8** %6
%21 = load i8*, i8** %5
%22 = call i64 @matchkey(i8* %20, i8* %21, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.2, i64 0, i64 0))
%23 = icmp ne i64 %22, 0
br i1 %23, label %25, label %24
24: ; preds = %19
br label %132
25: ; preds = %19
br label %26
26: ; preds = %25, %16
%27 = call i8* @getTok(i8** %5)
store i8* %27, i8** %6
%28 = load i8*, i8** %6
%29 = icmp ne i8* %28, null
br i1 %29, label %30, label %35
30: ; preds = %26
%31 = load i8*, i8** %6
%32 = load i8, i8* %31
%33 = sext i8 %32 to i32
%34 = icmp ne i32 %33, 47
br i1 %34, label %35, label %36
35: ; preds = %30, %26
br label %132
36: ; preds = %30
%37 = call i8* @getTok(i8** %5)
store i8* %37, i8** %6
%38 = call i8* @getTok(i8** %5)
store i8* %38, i8** %6
br label %39
39: ; preds = %131, %36
%40 = load i8*, i8** %6
%41 = icmp ne i8* %40, null
br i1 %41, label %42, label %132
42: ; preds = %39
%43 = load i8*, i8** %6
%44 = load i8, i8* %43
%45 = sext i8 %44 to i32
%46 = icmp eq i32 %45, 59
br i1 %46, label %47, label %129
47: ; preds = %42
%48 = call i8* @getTok(i8** %5)
store i8* %48, i8** %6
%49 = load i8*, i8** %6
%50 = load i8*, i8** %5
%51 = call i64 @matchkey(i8* %49, i8* %50, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.3, i64 0, i64 0))
%52 = icmp ne i64 %51, 0
br i1 %52, label %53, label %128
53: ; preds = %47
%54 = call i8* @getTok(i8** %5)
store i8* %54, i8** %6
%55 = load i8*, i8** %6
%56 = icmp ne i8* %55, null
br i1 %56, label %57, label %127
57: ; preds = %53
%58 = load i8*, i8** %6
%59 = load i8, i8* %58
%60 = sext i8 %59 to i32
%61 = icmp eq i32 %60, 61
br i1 %61, label %62, label %127
62: ; preds = %57
%63 = call i8* @getTok(i8** %5)
store i8* %63, i8** %6
%64 = load i8*, i8** %6
%65 = icmp ne i8* %64, null
br i1 %65, label %66, label %126
66: ; preds = %62
%67 = load i8*, i8** %4
store i8* %67, i8** %7
%68 = load i8*, i8** %6
%69 = load i8, i8* %68
%70 = sext i8 %69 to i32
%71 = icmp eq i32 %70, 34
br i1 %71, label %72, label %104
72: ; preds = %66
br label %73
73: ; preds = %96, %72
%74 = load i8*, i8** %6
%75 = getelementptr inbounds i8, i8* %74, i32 1
store i8* %75, i8** %6
%76 = load i8*, i8** %5
%77 = getelementptr inbounds i8, i8* %76, i64 -1
%78 = icmp ne i8* %75, %77
br i1 %78, label %79, label %101
79: ; preds = %73
%80 = load i8*, i8** %6
%81 = load i8, i8* %80
%82 = sext i8 %81 to i32
%83 = icmp eq i32 %82, 92
br i1 %83, label %84, label %87
84: ; preds = %79
%85 = load i8*, i8** %6
%86 = getelementptr inbounds i8, i8* %85, i32 1
store i8* %86, i8** %6
br label %87
87: ; preds = %84, %79
%88 = load i8*, i8** %7
%89 = load i8*, i8** %4
%90 = getelementptr inbounds i8, i8* %89, i64 41
%91 = getelementptr inbounds i8, i8* %90, i64 -1
%92 = icmp eq i8* %88, %91
br i1 %92, label %93, label %96
93: ; preds = %87
%94 = load i8*, i8** %4
%95 = getelementptr inbounds i8, i8* %94, i64 0
store i8 0, i8* %95
br label %101
96: ; preds = %87
%97 = load i8*, i8** %6
%98 = load i8, i8* %97
%99 = load i8*, i8** %7
%100 = getelementptr inbounds i8, i8* %99, i32 1
store i8* %100, i8** %7
store i8 %98, i8* %99
br label %73
101: ; preds = %93, %73
%102 = load i8*, i8** %7
%103 = getelementptr inbounds i8, i8* %102, i32 1
store i8* %103, i8** %7
store i8 0, i8* %102
br label %125
104: ; preds = %66
%105 = load i8*, i8** %5
%106 = load i8*, i8** %6
%107 = ptrtoint i8* %105 to i64
%108 = ptrtoint i8* %106 to i64
%109 = sub i64 %107, %108
%110 = icmp sgt i64 %109, 40
br i1 %110, label %111, label %112
111: ; preds = %104
br label %132
112: ; preds = %104
br label %113
113: ; preds = %117, %112
%114 = load i8*, i8** %6
%115 = load i8*, i8** %5
%116 = icmp ne i8* %114, %115
br i1 %116, label %117, label %123
117: ; preds = %113
%118 = load i8*, i8** %6
%119 = getelementptr inbounds i8, i8* %118, i32 1
store i8* %119, i8** %6
%120 = load i8, i8* %118
%121 = load i8*, i8** %7
%122 = getelementptr inbounds i8, i8* %121, i32 1
store i8* %122, i8** %7
store i8 %120, i8* %121
br label %113
123: ; preds = %113
%124 = load i8*, i8** %7
store i8 0, i8* %124
br label %132
125: ; preds = %101
br label %126
126: ; preds = %125, %62
br label %127
127: ; preds = %126, %57, %53
br label %132
128: ; preds = %47
br label %131
129: ; preds = %42
%130 = call i8* @getTok(i8** %5)
store i8* %130, i8** %6
br label %131
131: ; preds = %129, %128
br label %39
132: ; preds = %24, %35, %127, %123, %111, %39
ret void
}

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