#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 /*<<< orphan*/ err_log(int, int, char *, ...);
int util_utf16toutf8_len(unsigned char *, int);
int util_utf16toutf8(unsigned char *utf8, int dlen, unsigned char *utf16,
                     int len) {
  unsigned char *src = utf16;
  unsigned char *dst;
  unsigned int w1, w2;
  int bytes;
  int new_len;
  if (!len)
    return 0;
  new_len = util_utf16toutf8_len(utf16, len);
  if ((new_len == -1) || (dlen <= new_len)) {
    err_log(1, 0x80000000, "Cannot convert %s to utf8; E2BIG (%d vs %d)\n",
            utf8, new_len, dlen);
    return 0;
  }
  dst = utf8;
  while ((src + 2) <= utf16 + len) {
    w1 = src[1] << 8 | src[0];
    src += 2;
    if ((w1 & 0xFC00) == 0xD800) {
      if (src + 2 > utf16 + len) {
        err_log(5, 0x00000008, "Invalid utf-16 in file\n");
        return 0;
      }
      w2 = src[3] << 8 | src[2];
      if ((w2 & 0xFC00) != 0xDC00) {
        err_log(5, 0x00000008, "Invalid utf-16 in file\n");
        return 0;
      }
      w1 = w1 & 0x03FF;
      w1 = w1 << 10;
      w1 = w1 | (w2 & 0x03FF);
      w1 += 0x10000;
    }
    if (w1 < 0x80) {
      *dst++ = w1;
      bytes = 0;
    } else if (w1 < 0x800) {
      *dst++ = 0xC0 | (w1 >> 6);
      bytes = 1;
    } else if (w1 < 0x10000) {
      *dst++ = 0xE0 | (w1 >> 12);
      bytes = 2;
    } else {
      *dst++ = 0xF0 | (w1 >> 18);
      bytes = 3;
    }
    while (bytes) {
      *dst++ = 0x80 | ((w1 >> (6 * (bytes - 1))) & 0x3f);
      bytes--;
    }
  }
  *dst = '\x0';
  return new_len;
}


x86 assembly (clang, -O0):
<util_utf16toutf8>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %ecx,-0x24(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x30(%rbp)
cmpl   $0x0,-0x24(%rbp)
jne    1154 <util_utf16toutf8+0x34>
movl   $0x0,-0x4(%rbp)
jmp    13e6 <util_utf16toutf8+0x2c6>
mov    -0x20(%rbp),%rdi
mov    -0x24(%rbp),%esi
call   1040 <util_utf16toutf8_len@plt>
mov    %eax,-0x48(%rbp)
cmpl   $0xffffffff,-0x48(%rbp)
je     1179 <util_utf16toutf8+0x59>
mov    -0x14(%rbp),%eax
cmp    -0x48(%rbp),%eax
jg     11a9 <util_utf16toutf8+0x89>
mov    -0x10(%rbp),%rcx
mov    -0x48(%rbp),%r8d
mov    -0x14(%rbp),%r9d
mov    $0x1,%edi
mov    $0x80000000,%esi
lea    0xe6a(%rip),%rdx
mov    $0x0,%al
call   1030 <err_log@plt>
movl   $0x0,-0x4(%rbp)
jmp    13e6 <util_utf16toutf8+0x2c6>
mov    -0x10(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x30(%rbp),%rax
add    $0x2,%rax
mov    -0x20(%rbp),%rcx
movslq -0x24(%rbp),%rdx
add    %rdx,%rcx
cmp    %rcx,%rax
ja     13d9 <util_utf16toutf8+0x2b9>
mov    -0x30(%rbp),%rax
movzbl 0x1(%rax),%eax
shl    $0x8,%eax
mov    -0x30(%rbp),%rcx
movzbl (%rcx),%ecx
or     %ecx,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x30(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x30(%rbp)
mov    -0x3c(%rbp),%eax
and    $0xfc00,%eax
cmp    $0xd800,%eax
jne    12c2 <util_utf16toutf8+0x1a2>
mov    -0x30(%rbp),%rax
add    $0x2,%rax
mov    -0x20(%rbp),%rcx
movslq -0x24(%rbp),%rdx
add    %rdx,%rcx
cmp    %rcx,%rax
jbe    1243 <util_utf16toutf8+0x123>
mov    $0x5,%edi
mov    $0x8,%esi
lea    0xdfd(%rip),%rdx
mov    $0x0,%al
call   1030 <err_log@plt>
movl   $0x0,-0x4(%rbp)
jmp    13e6 <util_utf16toutf8+0x2c6>
mov    -0x30(%rbp),%rax
movzbl 0x3(%rax),%eax
shl    $0x8,%eax
mov    -0x30(%rbp),%rcx
movzbl 0x2(%rcx),%ecx
or     %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
and    $0xfc00,%eax
cmp    $0xdc00,%eax
je     1292 <util_utf16toutf8+0x172>
mov    $0x5,%edi
mov    $0x8,%esi
lea    0xdae(%rip),%rdx
mov    $0x0,%al
call   1030 <err_log@plt>
movl   $0x0,-0x4(%rbp)
jmp    13e6 <util_utf16toutf8+0x2c6>
mov    -0x3c(%rbp),%eax
and    $0x3ff,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
shl    $0xa,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x40(%rbp),%ecx
and    $0x3ff,%ecx
or     %ecx,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x10000,%eax
mov    %eax,-0x3c(%rbp)
cmpl   $0x80,-0x3c(%rbp)
jae    12f1 <util_utf16toutf8+0x1d1>
mov    -0x3c(%rbp),%eax
mov    %al,%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
movl   $0x0,-0x44(%rbp)
jmp    138e <util_utf16toutf8+0x26e>
cmpl   $0x800,-0x3c(%rbp)
jae    1328 <util_utf16toutf8+0x208>
mov    -0x3c(%rbp),%eax
shr    $0x6,%eax
or     $0xc0,%eax
mov    %al,%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
movl   $0x1,-0x44(%rbp)
jmp    1389 <util_utf16toutf8+0x269>
cmpl   $0x10000,-0x3c(%rbp)
jae    135f <util_utf16toutf8+0x23f>
mov    -0x3c(%rbp),%eax
shr    $0xc,%eax
or     $0xe0,%eax
mov    %al,%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
movl   $0x2,-0x44(%rbp)
jmp    1384 <util_utf16toutf8+0x264>
mov    -0x3c(%rbp),%eax
shr    $0x12,%eax
or     $0xf0,%eax
mov    %al,%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
movl   $0x3,-0x44(%rbp)
jmp    1389 <util_utf16toutf8+0x269>
jmp    138e <util_utf16toutf8+0x26e>
jmp    1393 <util_utf16toutf8+0x273>
cmpl   $0x0,-0x44(%rbp)
je     13d4 <util_utf16toutf8+0x2b4>
mov    -0x3c(%rbp),%eax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
imul   $0x6,%ecx,%ecx
shr    %cl,%eax
and    $0x3f,%eax
or     $0x80,%eax
mov    %al,%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
mov    -0x44(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x44(%rbp)
jmp    1393 <util_utf16toutf8+0x273>
jmp    11b1 <util_utf16toutf8+0x91>
mov    -0x38(%rbp),%rax
movb   $0x0,(%rax)
mov    -0x48(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<util_utf16toutf8>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
test   %ecx,%ecx
je     115d <util_utf16toutf8+0x3d>
mov    %ecx,%ebx
mov    %rdx,%rbp
mov    %esi,%r15d
mov    %rdi,%r12
mov    %rdx,%rdi
mov    %ecx,%esi
call   1040 <util_utf16toutf8_len@plt>
mov    %eax,%r14d
cmp    $0xffffffff,%eax
je     1165 <util_utf16toutf8+0x45>
cmp    %r15d,%r14d
jge    1165 <util_utf16toutf8+0x45>
cmp    $0x2,%ebx
jge    118e <util_utf16toutf8+0x6e>
movb   $0x0,(%r12)
jmp    12f9 <util_utf16toutf8+0x1d9>
xor    %r14d,%r14d
jmp    12f9 <util_utf16toutf8+0x1d9>
lea    0xe94(%rip),%rdx
mov    $0x1,%edi
mov    $0x80000000,%esi
mov    %r12,%rcx
mov    %r14d,%r8d
mov    %r15d,%r9d
xor    %eax,%eax
call   1030 <err_log@plt>
xor    %r14d,%r14d
jmp    12f9 <util_utf16toutf8+0x1d9>
movslq %ebx,%rax
add    %rbp,%rax
add    $0x2,%rbp
jmp    11ad <util_utf16toutf8+0x8d>
nopw   0x0(%rax,%rax,1)
add    $0x2,%r12
add    $0x2,%rbp
cmp    %rax,%rbp
ja     1153 <util_utf16toutf8+0x33>
movzbl -0x1(%rbp),%ecx
mov    %ecx,%edx
shl    $0x8,%edx
movzbl -0x2(%rbp),%esi
or     %esi,%edx
mov    %ecx,%edi
and    $0xfffffffc,%edi
cmp    $0xd8,%edi
jne    1220 <util_utf16toutf8+0x100>
lea    0x2(%rbp),%rsi
cmp    %rax,%rsi
ja     12de <util_utf16toutf8+0x1be>
movzbl 0x3(%rbp),%ecx
mov    %ecx,%edi
and    $0xfffffffc,%edi
cmp    $0xdc,%edi
jne    12de <util_utf16toutf8+0x1be>
movzbl (%rsi),%esi
shl    $0xa,%edx
and    $0xffc00,%edx
and    $0x3,%ecx
shl    $0x8,%ecx
or     %edx,%ecx
lea    (%rsi,%rcx,1),%edx
add    $0x10000,%edx
mov    %edx,%ecx
shr    $0x12,%ecx
or     $0xf0,%cl
mov    $0x3,%esi
jmp    1270 <util_utf16toutf8+0x150>
nopw   0x0(%rax,%rax,1)
cmp    $0x80,%edx
jae    1240 <util_utf16toutf8+0x120>
mov    %sil,(%r12)
add    $0x1,%r12
jmp    11a4 <util_utf16toutf8+0x84>
cs nopw 0x0(%rax,%rax,1)
nop
cmp    $0x7ff,%edx
ja     1257 <util_utf16toutf8+0x137>
mov    %edx,%ecx
shr    $0x6,%ecx
or     $0xc0,%cl
mov    $0x1,%esi
jmp    1270 <util_utf16toutf8+0x150>
shr    $0x4,%cl
or     $0xe0,%cl
mov    $0x2,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %cl,(%r12)
lea    (%rsi,%rsi,1),%ecx
lea    (%rcx,%rcx,2),%ecx
add    $0xfa,%cl
mov    %edx,%edi
shr    %cl,%edi
and    $0x3f,%dil
or     $0x80,%dil
mov    %dil,0x1(%r12)
mov    %esi,%ecx
add    $0xffffffff,%ecx
je     11a0 <util_utf16toutf8+0x80>
add    %ecx,%ecx
lea    (%rcx,%rcx,2),%ecx
add    $0xfa,%cl
mov    %edx,%edi
shr    %cl,%edi
and    $0x3f,%dil
or     $0x80,%dil
mov    %dil,0x2(%r12)
add    $0xfffffffe,%esi
je     12d5 <util_utf16toutf8+0x1b5>
add    %esi,%esi
lea    (%rsi,%rsi,2),%ecx
add    $0xfa,%cl
shr    %cl,%edx
and    $0x3f,%dl
or     $0x80,%dl
mov    %dl,0x3(%r12)
add    $0x4,%r12
jmp    11a4 <util_utf16toutf8+0x84>
add    $0x3,%r12
jmp    11a4 <util_utf16toutf8+0x84>
lea    0xd48(%rip),%rdx
xor    %r14d,%r14d
mov    $0x5,%edi
mov    $0x8,%esi
xor    %eax,%eax
call   1030 <err_log@plt>
mov    %r14d,%eax
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [45 x i8] c"Cannot convert %s to utf8; E2BIG (%d vs %d)\0A\00"
@.str.1 = [24 x i8] c"Invalid utf-16 in file\0A\00"
define i32 @util_utf16toutf8(i8* %0, i32 %1, i8* %2, i32 %3) {
%5 = alloca i32
%6 = alloca i8*
%7 = alloca i32
%8 = alloca i8*
%9 = alloca i32
%10 = alloca i8*
%11 = alloca i8*
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
store i8* %0, i8** %6
store i32 %1, i32* %7
store i8* %2, i8** %8
store i32 %3, i32* %9
%16 = load i8*, i8** %8
store i8* %16, i8** %10
%17 = load i32, i32* %9
%18 = icmp ne i32 %17, 0
br i1 %18, label %20, label %19
19: ; preds = %4
store i32 0, i32* %5
br label %156
20: ; preds = %4
%21 = load i8*, i8** %8
%22 = load i32, i32* %9
%23 = call i32 @util_utf16toutf8_len(i8* %21, i32 %22)
store i32 %23, i32* %15
%24 = load i32, i32* %15
%25 = icmp eq i32 %24, -1
br i1 %25, label %30, label %26
26: ; preds = %20
%27 = load i32, i32* %7
%28 = load i32, i32* %15
%29 = icmp sle i32 %27, %28
br i1 %29, label %30, label %35
30: ; preds = %26, %20
%31 = load i8*, i8** %6
%32 = load i32, i32* %15
%33 = load i32, i32* %7
%34 = call i32 (i32, i32, i8*, ...) @err_log(i32 1, i32 -2147483648, i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str, i64 0, i64 0), i8* %31, i32 %32, i32 %33)
store i32 0, i32* %5
br label %156
35: ; preds = %26
%36 = load i8*, i8** %6
store i8* %36, i8** %11
br label %37
37: ; preds = %152, %35
%38 = load i8*, i8** %10
%39 = getelementptr inbounds i8, i8* %38, i64 2
%40 = load i8*, i8** %8
%41 = load i32, i32* %9
%42 = sext i32 %41 to i64
%43 = getelementptr inbounds i8, i8* %40, i64 %42
%44 = icmp ule i8* %39, %43
br i1 %44, label %45, label %153
45: ; preds = %37
%46 = load i8*, i8** %10
%47 = getelementptr inbounds i8, i8* %46, i64 1
%48 = load i8, i8* %47
%49 = zext i8 %48 to i32
%50 = shl i32 %49, 8
%51 = load i8*, i8** %10
%52 = getelementptr inbounds i8, i8* %51, i64 0
%53 = load i8, i8* %52
%54 = zext i8 %53 to i32
%55 = or i32 %50, %54
store i32 %55, i32* %12
%56 = load i8*, i8** %10
%57 = getelementptr inbounds i8, i8* %56, i64 2
store i8* %57, i8** %10
%58 = load i32, i32* %12
%59 = and i32 %58, 64512
%60 = icmp eq i32 %59, 55296
br i1 %60, label %61, label %98
61: ; preds = %45
%62 = load i8*, i8** %10
%63 = getelementptr inbounds i8, i8* %62, i64 2
%64 = load i8*, i8** %8
%65 = load i32, i32* %9
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds i8, i8* %64, i64 %66
%68 = icmp ugt i8* %63, %67
br i1 %68, label %69, label %71
69: ; preds = %61
%70 = call i32 (i32, i32, i8*, ...) @err_log(i32 5, i32 8, i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.1, i64 0, i64 0))
store i32 0, i32* %5
br label %156
71: ; preds = %61
%72 = load i8*, i8** %10
%73 = getelementptr inbounds i8, i8* %72, i64 3
%74 = load i8, i8* %73
%75 = zext i8 %74 to i32
%76 = shl i32 %75, 8
%77 = load i8*, i8** %10
%78 = getelementptr inbounds i8, i8* %77, i64 2
%79 = load i8, i8* %78
%80 = zext i8 %79 to i32
%81 = or i32 %76, %80
store i32 %81, i32* %13
%82 = load i32, i32* %13
%83 = and i32 %82, 64512
%84 = icmp ne i32 %83, 56320
br i1 %84, label %85, label %87
85: ; preds = %71
%86 = call i32 (i32, i32, i8*, ...) @err_log(i32 5, i32 8, i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.1, i64 0, i64 0))
store i32 0, i32* %5
br label %156
87: ; preds = %71
%88 = load i32, i32* %12
%89 = and i32 %88, 1023
store i32 %89, i32* %12
%90 = load i32, i32* %12
%91 = shl i32 %90, 10
store i32 %91, i32* %12
%92 = load i32, i32* %12
%93 = load i32, i32* %13
%94 = and i32 %93, 1023
%95 = or i32 %92, %94
store i32 %95, i32* %12
%96 = load i32, i32* %12
%97 = add i32 %96, 65536
store i32 %97, i32* %12
br label %98
98: ; preds = %87, %45
%99 = load i32, i32* %12
%100 = icmp ult i32 %99, 128
br i1 %100, label %101, label %106
101: ; preds = %98
%102 = load i32, i32* %12
%103 = trunc i32 %102 to i8
%104 = load i8*, i8** %11
%105 = getelementptr inbounds i8, i8* %104, i32 1
store i8* %105, i8** %11
store i8 %103, i8* %104
store i32 0, i32* %14
br label %135
106: ; preds = %98
%107 = load i32, i32* %12
%108 = icmp ult i32 %107, 2048
br i1 %108, label %109, label %116
109: ; preds = %106
%110 = load i32, i32* %12
%111 = lshr i32 %110, 6
%112 = or i32 192, %111
%113 = trunc i32 %112 to i8
%114 = load i8*, i8** %11
%115 = getelementptr inbounds i8, i8* %114, i32 1
store i8* %115, i8** %11
store i8 %113, i8* %114
store i32 1, i32* %14
br label %134
116: ; preds = %106
%117 = load i32, i32* %12
%118 = icmp ult i32 %117, 65536
br i1 %118, label %119, label %126
119: ; preds = %116
%120 = load i32, i32* %12
%121 = lshr i32 %120, 12
%122 = or i32 224, %121
%123 = trunc i32 %122 to i8
%124 = load i8*, i8** %11
%125 = getelementptr inbounds i8, i8* %124, i32 1
store i8* %125, i8** %11
store i8 %123, i8* %124
store i32 2, i32* %14
br label %133
126: ; preds = %116
%127 = load i32, i32* %12
%128 = lshr i32 %127, 18
%129 = or i32 240, %128
%130 = trunc i32 %129 to i8
%131 = load i8*, i8** %11
%132 = getelementptr inbounds i8, i8* %131, i32 1
store i8* %132, i8** %11
store i8 %130, i8* %131
store i32 3, i32* %14
br label %133
133: ; preds = %126, %119
br label %134
134: ; preds = %133, %109
br label %135
135: ; preds = %134, %101
br label %136
136: ; preds = %139, %135
%137 = load i32, i32* %14
%138 = icmp ne i32 %137, 0
br i1 %138, label %139, label %152
139: ; preds = %136
%140 = load i32, i32* %12
%141 = load i32, i32* %14
%142 = sub nsw i32 %141, 1
%143 = mul nsw i32 6, %142
%144 = lshr i32 %140, %143
%145 = and i32 %144, 63
%146 = or i32 128, %145
%147 = trunc i32 %146 to i8
%148 = load i8*, i8** %11
%149 = getelementptr inbounds i8, i8* %148, i32 1
store i8* %149, i8** %11
store i8 %147, i8* %148
%150 = load i32, i32* %14
%151 = add nsw i32 %150, -1
store i32 %151, i32* %14
br label %136
152: ; preds = %136
br label %37
153: ; preds = %37
%154 = load i8*, i8** %11
store i8 0, i8* %154
%155 = load i32, i32* %15
store i32 %155, i32* %5
br label %156
156: ; preds = %153, %85, %69, %30, %19
%157 = load i32, i32* %5
ret i32 %157
}

LLVM IR (-O2):
@.str = [45 x i8] c"Cannot convert %s to utf8; E2BIG (%d vs %d)\0A\00"
@.str.1 = [24 x i8] c"Invalid utf-16 in file\0A\00"
define i32 @util_utf16toutf8(i8* %0, i32 %1, i8* %2, i32 %3) {
%5 = icmp eq i32 %3, 0
br i1 %5, label %109, label %6
6: ; preds = %4
%7 = tail call i32 @util_utf16toutf8_len(i8* %2, i32 %3)
%8 = icmp ne i32 %7, -1
%9 = icmp slt i32 %7, %1
%10 = and i1 %8, %9
br i1 %10, label %11, label %17
11: ; preds = %6
%12 = sext i32 %3 to i64
%13 = getelementptr inbounds i8, i8* %2, i64 %12
%14 = icmp slt i32 %3, 2
br i1 %14, label %107, label %15
15: ; preds = %11
%16 = getelementptr inbounds i8, i8* %2, i64 2
br label %23
17: ; preds = %6
%18 = tail call i32 (i32, i32, i8*, ...) @err_log(i32 1, i32 -2147483648, i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str, i64 0, i64 0), i8* %0, i32 %7, i32 %1)
br label %109
19: ; preds = %75, %89, %99, %73
%20 = phi i8* [ %74, %73 ], [ %87, %75 ], [ %97, %89 ], [ %106, %99 ]
%21 = getelementptr inbounds i8, i8* %24, i64 2
%22 = icmp ugt i8* %21, %13
br i1 %22, label %107, label %23
23: ; preds = %15, %19
%24 = phi i8* [ %21, %19 ], [ %16, %15 ]
%25 = phi i8* [ %24, %19 ], [ %2, %15 ]
%26 = phi i8* [ %20, %19 ], [ %0, %15 ]
%27 = getelementptr inbounds i8, i8* %25, i64 1
%28 = load i8, i8* %27
%29 = zext i8 %28 to i32
%30 = shl nuw nsw i32 %29, 8
%31 = load i8, i8* %25
%32 = zext i8 %31 to i32
%33 = or i32 %30, %32
%34 = and i32 %29, 252
%35 = icmp eq i32 %34, 216
br i1 %35, label %36, label %62
36: ; preds = %23
%37 = getelementptr inbounds i8, i8* %25, i64 4
%38 = icmp ugt i8* %37, %13
br i1 %38, label %39, label %41
39: ; preds = %36
%40 = tail call i32 (i32, i32, i8*, ...) @err_log(i32 5, i32 8, i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.1, i64 0, i64 0))
br label %109
41: ; preds = %36
%42 = getelementptr inbounds i8, i8* %25, i64 5
%43 = load i8, i8* %42
%44 = zext i8 %43 to i32
%45 = and i32 %44, 252
%46 = icmp eq i32 %45, 220
br i1 %46, label %49, label %47
47: ; preds = %41
%48 = tail call i32 (i32, i32, i8*, ...) @err_log(i32 5, i32 8, i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.1, i64 0, i64 0))
br label %109
49: ; preds = %41
%50 = shl nuw nsw i32 %44, 8
%51 = load i8, i8* %37
%52 = zext i8 %51 to i32
%53 = shl nuw nsw i32 %33, 10
%54 = and i32 %53, 1047552
%55 = and i32 %50, 768
%56 = or i32 %55, %54
%57 = or i32 %56, %52
%58 = add nuw nsw i32 %57, 65536
%59 = lshr i32 %58, 18
%60 = trunc i32 %59 to i8
%61 = or i8 %60, -16
br label %75
62: ; preds = %23
%63 = icmp ult i32 %33, 128
br i1 %63, label %73, label %64
64: ; preds = %62
%65 = icmp ult i32 %33, 2048
br i1 %65, label %66, label %70
66: ; preds = %64
%67 = lshr i32 %33, 6
%68 = trunc i32 %67 to i8
%69 = or i8 %68, -64
br label %75
70: ; preds = %64
%71 = lshr i8 %28, 4
%72 = or i8 %71, -32
br label %75
73: ; preds = %62
store i8 %31, i8* %26
%74 = getelementptr inbounds i8, i8* %26, i64 1
br label %19
75: ; preds = %66, %70, %49
%76 = phi i8 [ %69, %66 ], [ %72, %70 ], [ %61, %49 ]
%77 = phi i32 [ %33, %66 ], [ %33, %70 ], [ %58, %49 ]
%78 = phi i32 [ 1, %66 ], [ 2, %70 ], [ 3, %49 ]
store i8 %76, i8* %26
%79 = getelementptr inbounds i8, i8* %26, i64 1
%80 = mul nuw nsw i32 %78, 6
%81 = add nsw i32 %80, -6
%82 = lshr i32 %77, %81
%83 = trunc i32 %82 to i8
%84 = and i8 %83, 63
%85 = or i8 %84, -128
store i8 %85, i8* %79
%86 = add nsw i32 %78, -1
%87 = getelementptr inbounds i8, i8* %26, i64 2
%88 = icmp eq i32 %86, 0
br i1 %88, label %19, label %89
89: ; preds = %75
%90 = mul nsw i32 %86, 6
%91 = add nsw i32 %90, -6
%92 = lshr i32 %77, %91
%93 = trunc i32 %92 to i8
%94 = and i8 %93, 63
%95 = or i8 %94, -128
store i8 %95, i8* %87
%96 = add nsw i32 %78, -2
%97 = getelementptr inbounds i8, i8* %26, i64 3
%98 = icmp eq i32 %96, 0
br i1 %98, label %19, label %99
99: ; preds = %89
%100 = mul nsw i32 %96, 6
%101 = add nsw i32 %100, -6
%102 = lshr i32 %77, %101
%103 = trunc i32 %102 to i8
%104 = and i8 %103, 63
%105 = or i8 %104, -128
store i8 %105, i8* %97
%106 = getelementptr inbounds i8, i8* %26, i64 4
br label %19
107: ; preds = %19, %11
%108 = phi i8* [ %0, %11 ], [ %20, %19 ]
store i8 0, i8* %108
br label %109
109: ; preds = %4, %107, %47, %39, %17
%110 = phi i32 [ 0, %17 ], [ 0, %39 ], [ 0, %47 ], [ %7, %107 ], [ 0, %4 ]
ret i32 %110
}