#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 */
typedef int /*<<< orphan*/ uint32_t;
typedef int /*<<< orphan*/ uint16_t;
typedef int /*<<< orphan*/ character;

/* Variables and functions */
unsigned char *format_hex(unsigned char *, char *, int);
int /*<<< orphan*/ htons(int /*<<< orphan*/);
size_t utf8_read(int /*<<< orphan*/ *, unsigned char const *, size_t);
char *json_string_dump(unsigned char *restrict dest,
                       const unsigned char *restrict src, size_t size) {
  size_t i = 0;
  while (i < size) {
    if ((0x1f < src[i]) && (src[i] < 0x7f)) {
      if ((src[i] == '"') || (src[i] == '\\'))
        *dest++ = '\\';
      *dest++ = src[i];
    } else if (src[i] == '\t') {
      *dest++ = '\\';
      *dest++ = 't';
    } else if (src[i] == '\n') {
      *dest++ = '\\';
      *dest++ = 'n';
    } else if (src[i] <= 0x1f) {
      uint32_t code;
      uint16_t character;
      i += utf8_read(&code, src + i, size - i);
      character = htons(code);
      *dest++ = '\\';
      *dest++ = 'u';
      dest = format_hex(dest, (char *)&character, sizeof(character));
      continue;
    } else {
      size_t bytes = utf8_read(0, src + i, size - i);
      while (bytes--)
        *dest++ = src[i++];
      continue;
    }
    ++i;
  }
  return dest;
}


x86 assembly (clang, -O0):
<json_string_dump>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movq   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%rax
cmp    -0x18(%rbp),%rax
jae    1363 <json_string_dump+0x233>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
movzbl (%rax,%rcx,1),%ecx
mov    $0x1f,%eax
cmp    %ecx,%eax
jge    11e5 <json_string_dump+0xb5>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0x7f,%eax
jge    11e5 <json_string_dump+0xb5>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0x22,%eax
je     11b2 <json_string_dump+0x82>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0x5c,%eax
jne    11c4 <json_string_dump+0x94>
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
movb   $0x5c,(%rax)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x8(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x8(%rbp)
mov    %cl,(%rax)
jmp    1352 <json_string_dump+0x222>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0x9,%eax
jne    1223 <json_string_dump+0xf3>
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
movb   $0x5c,(%rax)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
movb   $0x74,(%rax)
jmp    134d <json_string_dump+0x21d>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0xa,%eax
jne    1261 <json_string_dump+0x131>
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
movb   $0x5c,(%rax)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
movb   $0x6e,(%rax)
jmp    1348 <json_string_dump+0x218>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0x1f,%eax
jg     12e1 <json_string_dump+0x1b1>
mov    -0x10(%rbp),%rsi
add    -0x20(%rbp),%rsi
mov    -0x18(%rbp),%rdx
sub    -0x20(%rbp),%rdx
lea    -0x24(%rbp),%rdi
call   1050 <utf8_read@plt>
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x24(%rbp),%edi
call   1030 <htons@plt>
mov    %eax,-0x28(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
movb   $0x5c,(%rax)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
movb   $0x75,(%rax)
mov    -0x8(%rbp),%rdi
lea    -0x28(%rbp),%rsi
mov    $0x4,%edx
call   1040 <format_hex@plt>
mov    %rax,-0x8(%rbp)
jmp    114c <json_string_dump+0x1c>
mov    -0x10(%rbp),%rsi
add    -0x20(%rbp),%rsi
mov    -0x18(%rbp),%rdx
sub    -0x20(%rbp),%rdx
xor    %eax,%eax
mov    %eax,%edi
call   1050 <utf8_read@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x30(%rbp)
cmp    $0x0,%rax
je     1343 <json_string_dump+0x213>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x20(%rbp)
mov    (%rax,%rcx,1),%cl
mov    -0x8(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x8(%rbp)
mov    %cl,(%rax)
jmp    12fe <json_string_dump+0x1ce>
jmp    114c <json_string_dump+0x1c>
jmp    134d <json_string_dump+0x21d>
jmp    1352 <json_string_dump+0x222>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    114c <json_string_dump+0x1c>
mov    -0x8(%rbp),%rax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<json_string_dump>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %rdi,%rbx
test   %rdx,%rdx
je     13ac <json_string_dump+0x27c>
mov    %rdx,%r14
mov    %rsi,%r13
lea    0x70(%rsi),%rax
mov    %rax,0x8(%rsp)
lea    0x10(%rsi),%rax
mov    %rax,0x10(%rsp)
xor    %r15d,%r15d
mov    %rsp,%r12
jmp    118d <json_string_dump+0x5d>
nopw   0x0(%rax,%rax,1)
movb   $0x5c,(%rbx)
add    $0x1,%rbx
mov    0x0(%rbp),%al
mov    %al,(%rbx)
add    $0x1,%rbx
add    $0x1,%r15
cmp    %r14,%r15
jae    13ac <json_string_dump+0x27c>
lea    (%r15,%r13,1),%rbp
mov    0x0(%r13,%r15,1),%al
lea    -0x20(%rax),%ecx
cmp    $0x5e,%cl
ja     11b0 <json_string_dump+0x80>
cmp    $0x5c,%al
je     1170 <json_string_dump+0x40>
cmp    $0x22,%al
je     1170 <json_string_dump+0x40>
jmp    117a <json_string_dump+0x4a>
nopl   0x0(%rax,%rax,1)
cmp    $0xa,%al
je     11bf <json_string_dump+0x8f>
cmp    $0x9,%al
jne    11ca <json_string_dump+0x9a>
movw   $0x745c,(%rbx)
jmp    11c4 <json_string_dump+0x94>
movw   $0x6e5c,(%rbx)
add    $0x2,%rbx
jmp    1180 <json_string_dump+0x50>
mov    %r14,%rdx
sub    %r15,%rdx
cmp    $0x1f,%al
ja     1211 <json_string_dump+0xe1>
lea    0x4(%rsp),%rdi
mov    %rbp,%rsi
call   1050 <utf8_read@plt>
add    %rax,%r15
mov    0x4(%rsp),%edi
call   1030 <htons@plt>
mov    %eax,(%rsp)
movw   $0x755c,(%rbx)
add    $0x2,%rbx
mov    %rbx,%rdi
mov    %r12,%rsi
mov    $0x4,%edx
call   1040 <format_hex@plt>
mov    %rax,%rbx
jmp    1184 <json_string_dump+0x54>
xor    %edi,%edi
mov    %rbp,%rsi
call   1050 <utf8_read@plt>
test   %rax,%rax
je     1184 <json_string_dump+0x54>
cmp    $0x20,%rax
jb     132d <json_string_dump+0x1fd>
lea    (%rax,%r15,1),%rcx
add    %r13,%rcx
cmp    %rcx,%rbx
jae    1247 <json_string_dump+0x117>
lea    (%rbx,%rax,1),%rcx
cmp    %rcx,%rbp
jb     132d <json_string_dump+0x1fd>
mov    %rax,%rcx
and    $0xffffffffffffffe0,%rcx
lea    -0x20(%rcx),%rsi
mov    %rsi,%rdi
shr    $0x5,%rdi
add    $0x1,%rdi
mov    %edi,%edx
and    $0x3,%edx
cmp    $0x60,%rsi
jae    126c <json_string_dump+0x13c>
xor    %esi,%esi
jmp    12d9 <json_string_dump+0x1a9>
and    $0xfffffffffffffffc,%rdi
mov    0x8(%rsp),%rsi
lea    (%rsi,%r15,1),%rbp
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movups -0x70(%rbp,%rsi,1),%xmm0
movups -0x60(%rbp,%rsi,1),%xmm1
movups %xmm0,(%rbx,%rsi,1)
movups %xmm1,0x10(%rbx,%rsi,1)
movups -0x50(%rbp,%rsi,1),%xmm0
movups -0x40(%rbp,%rsi,1),%xmm1
movups %xmm0,0x20(%rbx,%rsi,1)
movups %xmm1,0x30(%rbx,%rsi,1)
movups -0x30(%rbp,%rsi,1),%xmm0
movups -0x20(%rbp,%rsi,1),%xmm1
movups %xmm0,0x40(%rbx,%rsi,1)
movups %xmm1,0x50(%rbx,%rsi,1)
movups -0x10(%rbp,%rsi,1),%xmm0
movups 0x0(%rbp,%rsi,1),%xmm1
movups %xmm0,0x60(%rbx,%rsi,1)
movups %xmm1,0x70(%rbx,%rsi,1)
sub    $0xffffffffffffff80,%rsi
add    $0xfffffffffffffffc,%rdi
jne    1280 <json_string_dump+0x150>
test   %rdx,%rdx
je     131b <json_string_dump+0x1eb>
lea    (%rbx,%rsi,1),%rdi
add    $0x10,%rdi
add    %r15,%rsi
add    0x10(%rsp),%rsi
shl    $0x5,%rdx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
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    1300 <json_string_dump+0x1d0>
add    %rcx,%r15
add    %rcx,%rbx
cmp    %rcx,%rax
je     1184 <json_string_dump+0x54>
and    $0x1f,%eax
lea    -0x1(%rax),%rbp
mov    %rax,%rsi
and    $0x3,%rsi
je     1359 <json_string_dump+0x229>
lea    (%r15,%r13,1),%rdi
xor    %edx,%edx
movzbl (%rdi,%rdx,1),%ecx
mov    %cl,(%rbx,%rdx,1)
add    $0x1,%rdx
cmp    %rdx,%rsi
jne    1340 <json_string_dump+0x210>
sub    %rdx,%rax
add    %rdx,%r15
add    %rdx,%rbx
mov    %r15,%rdx
mov    %rbx,%rsi
cmp    $0x3,%rbp
jb     1184 <json_string_dump+0x54>
nopl   0x0(%rax)
movzbl 0x0(%r13,%rdx,1),%ecx
mov    %cl,(%rsi)
movzbl 0x1(%r13,%rdx,1),%ecx
mov    %cl,0x1(%rsi)
movzbl 0x2(%r13,%rdx,1),%ecx
mov    %cl,0x2(%rsi)
lea    0x4(%rdx),%r15
lea    0x4(%rsi),%rbx
movzbl 0x3(%r13,%rdx,1),%ecx
mov    %cl,0x3(%rsi)
mov    %r15,%rdx
mov    %rbx,%rsi
add    $0xfffffffffffffffc,%rax
jne    1370 <json_string_dump+0x240>
jmp    1184 <json_string_dump+0x54>
mov    %rbx,%rax
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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