#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 *malloc(int);
char *tagfile_simplify_query(const char *query) {
  static char pairs[50][2];
  int num_pairs = 0;
  int pos = 0;
  int i;
  bool found;
  char *result;
  if (query == NULL || query[0] == 0)
    return NULL;
  while (query[pos + 1] != 0 && num_pairs < 50) {
    found = false;
    for (i = 0; i < num_pairs; ++i) {
      if (pairs[i][0] == query[pos] && pairs[i][1] == query[pos + 1]) {
        found = true;
        break;
      }
    }
    if (!found) {
      pairs[num_pairs][0] = query[pos];
      pairs[num_pairs][1] = query[pos + 1];
      num_pairs++;
    }
    pos++;
  }
  result = malloc(num_pairs + 2);
  if (result) {
    for (i = 0; i < num_pairs; ++i) {
      result[i] = pairs[i][0];
    }
    result[i] = pairs[i - 1][1];
    i++;
    result[i] = 0;
  }
  return result;
}


x86 assembly (clang, -O0):
<tagfile_simplify_query>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
movl   $0x0,-0x18(%rbp)
cmpq   $0x0,-0x10(%rbp)
je     1145 <tagfile_simplify_query+0x35>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
jne    1152 <tagfile_simplify_query+0x42>
movq   $0x0,-0x8(%rbp)
jmp    12fe <tagfile_simplify_query+0x1ee>
jmp    1157 <tagfile_simplify_query+0x47>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x29(%rbp)
je     1180 <tagfile_simplify_query+0x70>
cmpl   $0x32,-0x14(%rbp)
setl   %al
mov    %al,-0x29(%rbp)
mov    -0x29(%rbp),%al
test   $0x1,%al
jne    1190 <tagfile_simplify_query+0x80>
jmp    126e <tagfile_simplify_query+0x15e>
movl   $0x0,-0x20(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1215 <tagfile_simplify_query+0x105>
movslq -0x1c(%rbp),%rcx
lea    0x2e8b(%rip),%rax
movsbl (%rax,%rcx,2),%eax
mov    -0x10(%rbp),%rcx
movslq -0x18(%rbp),%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jne    1202 <tagfile_simplify_query+0xf2>
movslq -0x1c(%rbp),%rcx
lea    0x2e68(%rip),%rax
movsbl 0x1(%rax,%rcx,2),%eax
mov    -0x10(%rbp),%rcx
mov    -0x18(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jne    1202 <tagfile_simplify_query+0xf2>
movl   $0x1,-0x20(%rbp)
jmp    1215 <tagfile_simplify_query+0x105>
jmp    1207 <tagfile_simplify_query+0xf7>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    119e <tagfile_simplify_query+0x8e>
cmpl   $0x0,-0x20(%rbp)
jne    1260 <tagfile_simplify_query+0x150>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
movslq -0x14(%rbp),%rcx
lea    0x2e0b(%rip),%rax
mov    %dl,(%rax,%rcx,2)
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
movslq -0x14(%rbp),%rcx
lea    0x2ded(%rip),%rax
mov    %dl,0x1(%rax,%rcx,2)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1157 <tagfile_simplify_query+0x47>
mov    -0x14(%rbp),%edi
add    $0x2,%edi
call   1030 <malloc@plt>
mov    %rax,-0x28(%rbp)
cmpq   $0x0,-0x28(%rbp)
je     12f6 <tagfile_simplify_query+0x1e6>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    12c2 <tagfile_simplify_query+0x1b2>
movslq -0x1c(%rbp),%rcx
lea    0x2d9a(%rip),%rax
mov    (%rax,%rcx,2),%dl
mov    -0x28(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    128f <tagfile_simplify_query+0x17f>
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
movslq %eax,%rcx
lea    0x2d6e(%rip),%rax
mov    0x1(%rax,%rcx,2),%dl
mov    -0x28(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x28(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<tagfile_simplify_query>:
push   %rbp
push   %r14
push   %rbx
test   %rdi,%rdi
je     11d2 <tagfile_simplify_query+0xc2>
xor    %r14d,%r14d
cmpb   $0x0,(%rdi)
je     11d2 <tagfile_simplify_query+0xc2>
mov    0x1(%rdi),%bl
test   %bl,%bl
je     11a5 <tagfile_simplify_query+0x95>
xor    %r8d,%r8d
mov    $0x1,%r9d
lea    0x2f00(%rip),%rdx
xor    %r14d,%r14d
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%rdi,%r8,1),%al
test   %r14d,%r14d
jle    1180 <tagfile_simplify_query+0x70>
mov    %r14d,%esi
xor    %ecx,%ecx
jmp    1169 <tagfile_simplify_query+0x59>
add    $0x1,%rcx
cmp    %rcx,%rsi
je     1180 <tagfile_simplify_query+0x70>
cmp    %al,(%rdx,%rcx,2)
jne    1160 <tagfile_simplify_query+0x50>
cmp    %bl,0x1(%rdx,%rcx,2)
jne    1160 <tagfile_simplify_query+0x50>
jmp    118e <tagfile_simplify_query+0x7e>
cs nopw 0x0(%rax,%rax,1)
movslq %r14d,%rcx
mov    %al,(%rdx,%rcx,2)
mov    %bl,0x1(%rdx,%rcx,2)
add    $0x1,%r14d
mov    0x1(%rdi,%r9,1),%bl
test   %bl,%bl
je     11a5 <tagfile_simplify_query+0x95>
add    $0x1,%r9
add    $0x1,%r8
cmp    $0x32,%r14d
jl     1150 <tagfile_simplify_query+0x40>
lea    0x2(%r14),%edi
call   1030 <malloc@plt>
xor    %edx,%edx
test   %rax,%rax
je     11d2 <tagfile_simplify_query+0xc2>
mov    %rax,%r11
test   %r14d,%r14d
jle    13a4 <tagfile_simplify_query+0x294>
mov    %r14d,%r10d
cmp    $0x9,%r14d
jae    11d9 <tagfile_simplify_query+0xc9>
xor    %r9d,%r9d
jmp    136e <tagfile_simplify_query+0x25e>
xor    %eax,%eax
jmp    13bc <tagfile_simplify_query+0x2ac>
cmp    $0x11,%r14d
jae    11e7 <tagfile_simplify_query+0xd7>
xor    %r9d,%r9d
jmp    12df <tagfile_simplify_query+0x1cf>
mov    %r10d,%esi
and    $0xf,%esi
test   %rsi,%rsi
mov    $0x10,%r8d
cmovne %rsi,%r8
mov    %r10,%r9
sub    %r8,%r9
xor    %edi,%edi
lea    0x2e37(%rip),%rsi
nopl   0x0(%rax)
movd   0x1c(%rsi,%rdi,2),%xmm0
movzbl 0x1e(%rsi,%rdi,2),%ebx
movd   %ebx,%xmm1
punpcklbw %xmm1,%xmm0
movd   0x18(%rsi,%rdi,2),%xmm1
movzbl 0x1a(%rsi,%rdi,2),%ebx
movd   %ebx,%xmm2
punpcklbw %xmm2,%xmm1
punpcklwd %xmm0,%xmm1
movd   0x14(%rsi,%rdi,2),%xmm2
movzbl 0x16(%rsi,%rdi,2),%ebx
movd   %ebx,%xmm0
punpcklbw %xmm0,%xmm2
movd   0x10(%rsi,%rdi,2),%xmm0
movzbl 0x12(%rsi,%rdi,2),%ebx
movd   %ebx,%xmm3
punpcklbw %xmm3,%xmm0
punpcklwd %xmm2,%xmm0
punpckldq %xmm1,%xmm0
movd   0xc(%rsi,%rdi,2),%xmm1
movzbl 0xe(%rsi,%rdi,2),%ebx
movd   %ebx,%xmm2
punpcklbw %xmm2,%xmm1
movd   0x8(%rsi,%rdi,2),%xmm2
movzbl 0xa(%rsi,%rdi,2),%ebx
movd   %ebx,%xmm3
punpcklbw %xmm3,%xmm2
punpcklwd %xmm1,%xmm2
movd   0x4(%rsi,%rdi,2),%xmm1
movzbl 0x6(%rsi,%rdi,2),%ebx
movd   %ebx,%xmm3
punpcklbw %xmm3,%xmm1
movd   (%rsi,%rdi,2),%xmm3
movzbl 0x2(%rsi,%rdi,2),%ebx
movd   %ebx,%xmm4
punpcklbw %xmm4,%xmm3
punpcklwd %xmm1,%xmm3
punpckldq %xmm2,%xmm3
punpcklqdq %xmm0,%xmm3
movdqu %xmm3,(%rax,%rdi,1)
add    $0x10,%rdi
cmp    %rdi,%r9
jne    1210 <tagfile_simplify_query+0x100>
cmp    $0x9,%r8d
jb     136e <tagfile_simplify_query+0x25e>
mov    %r9,%rsi
mov    %r10d,%edi
and    $0x7,%edi
test   %rdi,%rdi
mov    $0x8,%ebx
cmovne %rdi,%rbx
mov    %r10,%r9
sub    %rbx,%r9
lea    0x2d3f(%rip),%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl (%rdi,%rsi,2),%ebx
movzbl 0x4(%rdi,%rsi,2),%edx
movzbl 0x8(%rdi,%rsi,2),%ecx
movzbl 0xc(%rdi,%rsi,2),%r8d
movzbl 0x6(%rdi,%rsi,2),%ebp
shl    $0x8,%ebp
or     %edx,%ebp
movzbl 0x2(%rdi,%rsi,2),%edx
shl    $0x8,%edx
or     %ebx,%edx
movd   %edx,%xmm0
pinsrw $0x1,%ebp,%xmm0
movzbl 0xa(%rdi,%rsi,2),%edx
shl    $0x8,%edx
or     %ecx,%edx
pinsrw $0x2,%edx,%xmm0
movzbl 0xe(%rdi,%rsi,2),%ecx
shl    $0x8,%ecx
or     %r8d,%ecx
pinsrw $0x3,%ecx,%xmm0
movq   %xmm0,(%rax,%rsi,1)
add    $0x8,%rsi
cmp    %rsi,%r9
jne    1310 <tagfile_simplify_query+0x200>
add    %r9,%r11
lea    0x2cc8(%rip),%rcx
lea    (%rcx,%r9,2),%rsi
sub    %r9,%r10
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl (%rsi,%rdi,2),%ecx
mov    %cl,(%r11,%rdi,1)
add    $0x1,%rdi
cmp    %rdi,%r10
jne    1390 <tagfile_simplify_query+0x280>
mov    %r14d,%edx
movslq %edx,%rcx
lea    0x2c92(%rip),%rdx
mov    -0x1(%rdx,%rcx,2),%dl
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
movb   $0x0,0x1(%rax,%rcx,1)
pop    %rbx
pop    %r14
pop    %rbp
ret

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

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