#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*/ stack;

/* Variables and functions */
int /*<<< orphan*/ memset(unsigned char *, int /*<<< orphan*/, int);
int xgetc(unsigned char **, unsigned char *);
int yuke_bpe(unsigned char *in, int insz, unsigned char *out, int outsz,
             int fill_outsz) {
  unsigned char stack[512 + 4096];
  int c, count, i, size, n;
  unsigned char *inl, *o, *outl;
  inl = in + insz;
  o = out;
  outl = out + outsz;
  count = 0;
  for (;;) {
    i = 0;
    do {
      if ((c = xgetc(&in, inl)) < 0)
        break;
      if (c > 127) {
        c -= 127;
        while ((c > 0) && (i < 256)) {
          stack[i * 2] = i;
          c--;
          i++;
        }
      }
      c++;
      while ((c > 0) && (i < 256)) {
        if ((n = xgetc(&in, inl)) < 0)
          break;
        stack[i * 2] = n;
        if (i != n) {
          if ((n = xgetc(&in, inl)) < 0)
            break;
          stack[(i * 2) + 1] = n;
        }
        c--;
        i++;
      }
    } while (i < 256);
    if ((n = xgetc(&in, inl)) < 0)
      break;
    size = n;
    if ((n = xgetc(&in, inl)) < 0)
      break;
    size |= (n << 8);
    while (size || count) {
      if (count) {
        count--;
        n = stack[count + 512];
      } else {
        if ((n = xgetc(&in, inl)) < 0)
          break;
        size--;
      }
      c = stack[n * 2];
      if (n == c) {
        if (o >= outl)
          return (-1);
        *o++ = n;
      } else {
        if ((count + 512 + 2) > sizeof(stack))
          return (-1);
        stack[count + 512] = stack[(n * 2) + 1];
        stack[count + 512 + 1] = c;
        count += 2;
      }
    }
  }
  if (fill_outsz) {
    memset(o, 0, outl - o);
    o = outl;
  }
  return (o - out);
}


x86 assembly (clang, -O0):
<yuke_bpe>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1270,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %ecx,-0x24(%rbp)
mov    %r8d,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x1250(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x1258(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x1260(%rbp)
movl   $0x0,-0x1238(%rbp)
movl   $0x0,-0x123c(%rbp)
mov    -0x1250(%rbp),%rsi
lea    -0x10(%rbp),%rdi
call   1040 <xgetc@plt>
mov    %eax,-0x1234(%rbp)
cmp    $0x0,%eax
jge    11a4 <yuke_bpe+0x84>
jmp    1350 <yuke_bpe+0x230>
cmpl   $0x7f,-0x1234(%rbp)
jle    123d <yuke_bpe+0x11d>
mov    -0x1234(%rbp),%eax
sub    $0x7f,%eax
mov    %eax,-0x1234(%rbp)
xor    %eax,%eax
cmpl   $0x0,-0x1234(%rbp)
mov    %al,-0x1261(%rbp)
jle    11e8 <yuke_bpe+0xc8>
cmpl   $0x100,-0x123c(%rbp)
setl   %al
mov    %al,-0x1261(%rbp)
mov    -0x1261(%rbp),%al
test   $0x1,%al
jne    11fb <yuke_bpe+0xdb>
jmp    1238 <yuke_bpe+0x118>
mov    -0x123c(%rbp),%eax
mov    %al,%cl
mov    -0x123c(%rbp),%eax
shl    $0x1,%eax
cltq
mov    %cl,-0x1230(%rbp,%rax,1)
mov    -0x1234(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1234(%rbp)
mov    -0x123c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x123c(%rbp)
jmp    11c0 <yuke_bpe+0xa0>
jmp    123d <yuke_bpe+0x11d>
mov    -0x1234(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1234(%rbp)
xor    %eax,%eax
cmpl   $0x0,-0x1234(%rbp)
mov    %al,-0x1262(%rbp)
jle    1274 <yuke_bpe+0x154>
cmpl   $0x100,-0x123c(%rbp)
setl   %al
mov    %al,-0x1262(%rbp)
mov    -0x1262(%rbp),%al
test   $0x1,%al
jne    1287 <yuke_bpe+0x167>
jmp    133b <yuke_bpe+0x21b>
mov    -0x1250(%rbp),%rsi
lea    -0x10(%rbp),%rdi
call   1040 <xgetc@plt>
mov    %eax,-0x1244(%rbp)
cmp    $0x0,%eax
jge    12ab <yuke_bpe+0x18b>
jmp    133b <yuke_bpe+0x21b>
mov    -0x1244(%rbp),%eax
mov    %al,%cl
mov    -0x123c(%rbp),%eax
shl    $0x1,%eax
cltq
mov    %cl,-0x1230(%rbp,%rax,1)
mov    -0x123c(%rbp),%eax
cmp    -0x1244(%rbp),%eax
je     1318 <yuke_bpe+0x1f8>
mov    -0x1250(%rbp),%rsi
lea    -0x10(%rbp),%rdi
call   1040 <xgetc@plt>
mov    %eax,-0x1244(%rbp)
cmp    $0x0,%eax
jge    12fb <yuke_bpe+0x1db>
jmp    133b <yuke_bpe+0x21b>
mov    -0x1244(%rbp),%eax
mov    %al,%cl
mov    -0x123c(%rbp),%eax
shl    $0x1,%eax
add    $0x1,%eax
cltq
mov    %cl,-0x1230(%rbp,%rax,1)
mov    -0x1234(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1234(%rbp)
mov    -0x123c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x123c(%rbp)
jmp    124c <yuke_bpe+0x12c>
jmp    1340 <yuke_bpe+0x220>
cmpl   $0x100,-0x123c(%rbp)
jl     1180 <yuke_bpe+0x60>
mov    -0x1250(%rbp),%rsi
lea    -0x10(%rbp),%rdi
call   1040 <xgetc@plt>
mov    %eax,-0x1244(%rbp)
cmp    $0x0,%eax
jge    1374 <yuke_bpe+0x254>
jmp    1558 <yuke_bpe+0x438>
mov    -0x1244(%rbp),%eax
mov    %eax,-0x1240(%rbp)
mov    -0x1250(%rbp),%rsi
lea    -0x10(%rbp),%rdi
call   1040 <xgetc@plt>
mov    %eax,-0x1244(%rbp)
cmp    $0x0,%eax
jge    13a4 <yuke_bpe+0x284>
jmp    1558 <yuke_bpe+0x438>
mov    -0x1244(%rbp),%eax
shl    $0x8,%eax
or     -0x1240(%rbp),%eax
mov    %eax,-0x1240(%rbp)
mov    $0x1,%al
cmpl   $0x0,-0x1240(%rbp)
mov    %al,-0x1263(%rbp)
jne    13de <yuke_bpe+0x2be>
cmpl   $0x0,-0x1238(%rbp)
setne  %al
mov    %al,-0x1263(%rbp)
mov    -0x1263(%rbp),%al
test   $0x1,%al
jne    13f1 <yuke_bpe+0x2d1>
jmp    1553 <yuke_bpe+0x433>
cmpl   $0x0,-0x1238(%rbp)
je     142d <yuke_bpe+0x30d>
mov    -0x1238(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1238(%rbp)
mov    -0x1238(%rbp),%eax
add    $0x200,%eax
cltq
movzbl -0x1230(%rbp,%rax,1),%eax
ff
mov    %eax,-0x1244(%rbp)
jmp    1460 <yuke_bpe+0x340>
mov    -0x1250(%rbp),%rsi
lea    -0x10(%rbp),%rdi
call   1040 <xgetc@plt>
mov    %eax,-0x1244(%rbp)
cmp    $0x0,%eax
jge    1451 <yuke_bpe+0x331>
jmp    1553 <yuke_bpe+0x433>
mov    -0x1240(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1240(%rbp)
mov    -0x1244(%rbp),%eax
shl    $0x1,%eax
cltq
movzbl -0x1230(%rbp,%rax,1),%eax
ff
mov    %eax,-0x1234(%rbp)
mov    -0x1244(%rbp),%eax
cmp    -0x1234(%rbp),%eax
jne    14cf <yuke_bpe+0x3af>
mov    -0x1258(%rbp),%rax
cmp    -0x1260(%rbp),%rax
jb     14ab <yuke_bpe+0x38b>
movl   $0xffffffff,-0x4(%rbp)
jmp    15a2 <yuke_bpe+0x482>
mov    -0x1244(%rbp),%eax
mov    %al,%cl
mov    -0x1258(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x1258(%rbp)
mov    %cl,(%rax)
jmp    154e <yuke_bpe+0x42e>
mov    -0x1238(%rbp),%eax
add    $0x200,%eax
add    $0x2,%eax
cltq
cmp    $0x1200,%rax
jbe    14f7 <yuke_bpe+0x3d7>
movl   $0xffffffff,-0x4(%rbp)
jmp    15a2 <yuke_bpe+0x482>
mov    -0x1244(%rbp),%eax
shl    $0x1,%eax
add    $0x1,%eax
cltq
mov    -0x1230(%rbp,%rax,1),%cl
mov    -0x1238(%rbp),%eax
add    $0x200,%eax
cltq
mov    %cl,-0x1230(%rbp,%rax,1)
mov    -0x1234(%rbp),%eax
mov    %al,%cl
mov    -0x1238(%rbp),%eax
add    $0x200,%eax
add    $0x1,%eax
cltq
mov    %cl,-0x1230(%rbp,%rax,1)
mov    -0x1238(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x1238(%rbp)
jmp    13b9 <yuke_bpe+0x299>
jmp    1176 <yuke_bpe+0x56>
cmpl   $0x0,-0x28(%rbp)
je     1591 <yuke_bpe+0x471>
mov    -0x1258(%rbp),%rdi
mov    -0x1260(%rbp),%rax
mov    -0x1258(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,%edx
xor    %esi,%esi
call   1030 <memset@plt>
mov    -0x1260(%rbp),%rax
mov    %rax,-0x1258(%rbp)
mov    -0x1258(%rbp),%rax
mov    -0x20(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x1270,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<yuke_bpe>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1238,%rsp
mov    %r8d,0x14(%rsp)
mov    %rdi,0x28(%rsp)
movslq %esi,%r14
add    %rdi,%r14
movslq %ecx,%r15
add    %rdx,%r15
lea    0x28(%rsp),%r13
mov    %rdx,0x18(%rsp)
mov    %rdx,%rbp
mov    %r15,0x20(%rsp)
mov    %rbp,0x8(%rsp)
xchg   %ax,%ax
xor    %r15d,%r15d
jmp    117d <yuke_bpe+0x5d>
cs nopw 0x0(%rax,%rax,1)
nop
mov    $0x1,%al
mov    %r12d,%r15d
test   %al,%al
je     1270 <yuke_bpe+0x150>
mov    %r13,%rdi
mov    %r14,%rsi
call   1040 <xgetc@plt>
test   %eax,%eax
js     1270 <yuke_bpe+0x150>
mov    %eax,%ebx
cmp    $0x80,%eax
jb     11e0 <yuke_bpe+0xc0>
add    $0xffffff81,%ebx
cmp    $0xff,%r15d
jg     11e0 <yuke_bpe+0xc0>
movslq %r15d,%rax
add    %r15d,%r15d
mov    %r15d,%ecx
xchg   %ax,%ax
mov    %ebx,%edx
movslq %ecx,%rsi
mov    %al,0x30(%rsp,%rsi,1)
lea    -0x1(%rdx),%ebx
lea    0x1(%rax),%r15
cmp    $0x2,%edx
jb     11e0 <yuke_bpe+0xc0>
add    $0x2,%ecx
cmp    $0xff,%rax
mov    %r15,%rax
jl     11b0 <yuke_bpe+0x90>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cmp    $0x100,%r15d
setl   %al
jge    1175 <yuke_bpe+0x55>
add    $0x1,%ebx
movslq %r15d,%r12
add    %r15d,%r15d
mov    %r15d,%ebp
nopl   0x0(%rax,%rax,1)
mov    %r13,%rdi
mov    %r14,%rsi
call   1040 <xgetc@plt>
test   %eax,%eax
js     1170 <yuke_bpe+0x50>
movslq %ebp,%rcx
mov    %al,0x30(%rsp,%rcx,1)
cmp    %eax,%r12d
je     123c <yuke_bpe+0x11c>
mov    %r13,%rdi
mov    %r14,%rsi
call   1040 <xgetc@plt>
test   %eax,%eax
js     1170 <yuke_bpe+0x50>
lea    0x1(%rbp),%ecx
movslq %ecx,%rcx
mov    %al,0x30(%rsp,%rcx,1)
lea    0x1(%r12),%r15
cmp    $0xff,%r12
setl   %al
cmp    $0x2,%ebx
jl     1175 <yuke_bpe+0x55>
add    $0xffffffff,%ebx
add    $0x2,%ebp
cmp    $0xff,%r12
mov    %r15,%r12
jl     1200 <yuke_bpe+0xe0>
jmp    1175 <yuke_bpe+0x55>
nopl   0x0(%rax,%rax,1)
mov    %r13,%rdi
mov    %r14,%rsi
call   1040 <xgetc@plt>
test   %eax,%eax
js     136a <yuke_bpe+0x24a>
mov    %eax,%r15d
mov    %r13,%rdi
mov    %r14,%rsi
call   1040 <xgetc@plt>
test   %eax,%eax
js     136a <yuke_bpe+0x24a>
mov    %eax,%ebx
shl    $0x8,%ebx
or     %r15d,%ebx
je     1160 <yuke_bpe+0x40>
xor    %eax,%eax
xor    %ecx,%ecx
mov    0x8(%rsp),%rbp
mov    0x20(%rsp),%r15
jmp    12cf <yuke_bpe+0x1af>
nopw   0x0(%rax,%rax,1)
test   %ecx,%ecx
setne  %al
mov    %ebx,%edx
or     %ecx,%edx
je     1159 <yuke_bpe+0x39>
test   $0x1,%al
je     12f0 <yuke_bpe+0x1d0>
movslq %ecx,%rax
add    $0xffffffff,%ecx
lea    0x30(%rsp),%rdx
movzbl 0x1ff(%rax,%rdx,1),%eax
jmp    1308 <yuke_bpe+0x1e8>
nopl   0x0(%rax,%rax,1)
mov    %r13,%rdi
mov    %r14,%rsi
call   1040 <xgetc@plt>
test   %eax,%eax
js     1159 <yuke_bpe+0x39>
add    $0xffffffff,%ebx
xor    %ecx,%ecx
movslq %eax,%rsi
movzbl 0x30(%rsp,%rsi,2),%edx
cmp    %edx,%esi
jne    1330 <yuke_bpe+0x210>
cmp    %r15,%rbp
jae    13ae <yuke_bpe+0x28e>
mov    %al,0x0(%rbp)
add    $0x1,%rbp
jmp    12c0 <yuke_bpe+0x1a0>
cs nopw 0x0(%rax,%rax,1)
lea    -0xfff(%rcx),%eax
cmp    $0xffffedff,%eax
jb     13ae <yuke_bpe+0x28e>
add    %rsi,%rsi
movslq %ecx,%rdi
movslq %esi,%rsi
or     $0x1,%rsi
movzbl 0x30(%rsp,%rsi,1),%eax
lea    0x30(%rsp),%rsi
mov    %al,0x200(%rdi,%rsi,1)
mov    %dl,0x201(%rdi,%rsi,1)
add    $0x2,%ecx
jmp    12c0 <yuke_bpe+0x1a0>
cmpl   $0x0,0x14(%rsp)
je     1390 <yuke_bpe+0x270>
mov    0x20(%rsp),%rbx
mov    %ebx,%edx
mov    0x8(%rsp),%rdi
sub    %edi,%edx
xor    %esi,%esi
call   1030 <memset@plt>
mov    %rbx,%rax
mov    0x18(%rsp),%rcx
jmp    139a <yuke_bpe+0x27a>
mov    0x18(%rsp),%rcx
mov    0x8(%rsp),%rax
sub    %ecx,%eax
add    $0x1238,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    $0xffffffff,%eax
jmp    139c <yuke_bpe+0x27c>

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

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