#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 get_line_len(char const *);
void remove_junk_data(const char *src, char *dst) {
  int linelen, counter;
  int emptyline;
  const char *readpos, *readpos2;
  char *writepos, *writepos2;
  readpos = src;
  writepos = dst;
  while ((linelen = get_line_len(readpos)) != 0) {
    counter = linelen;
    while (counter) {
      if (*readpos == '#') {
        if (*(readpos + counter - 1) == '\n')
          *(writepos++) = '\n';
        readpos += counter;
        counter = 0;
      } else {
        *(writepos++) = *(readpos++);
        counter--;
      }
    }
  }
  *writepos = '\0';
  readpos = dst;
  writepos = dst;
  while ((linelen = get_line_len(readpos)) != 0) {
    counter = linelen;
    emptyline = 1;
    readpos2 = readpos;
    writepos2 = writepos;
    while (counter--) {
      if ((*readpos2 > ' ') && (*readpos2 != '\n'))
        emptyline = 0;
      readpos2++;
    }
    if (emptyline == 0) {
      counter = linelen;
      while (counter--)
        *(writepos++) = *(readpos++);
    } else {
      readpos += linelen;
    }
  }
  *writepos = '\0';
  readpos = dst;
  writepos = dst;
  while ((linelen = get_line_len(readpos)) != 0) {
    counter = linelen;
    while (counter) {
      if ((*readpos <= ' ') && (*readpos != '\n')) {
        readpos++;
      } else if (*readpos == '\\') {
        *(writepos++) = *(readpos++);
        if (counter > 1) {
          *(writepos++) = *(readpos++);
          counter--;
        }
      } else {
        *(writepos++) = *(readpos++);
      }
      counter--;
    }
  }
  *writepos = '\0';
}


x86 assembly (clang, -O0):
<remove_junk_data>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%rdi
call   1030 <get_line_len@plt>
mov    %eax,-0x14(%rbp)
cmp    $0x0,%eax
je     11df <remove_junk_data+0xcf>
mov    -0x14(%rbp),%eax
mov    %eax,-0x18(%rbp)
cmpl   $0x0,-0x18(%rbp)
je     11da <remove_junk_data+0xca>
mov    -0x28(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x23,%eax
jne    11aa <remove_junk_data+0x9a>
mov    -0x28(%rbp),%rax
movslq -0x18(%rbp),%rcx
movsbl -0x1(%rax,%rcx,1),%eax
cmp    $0xa,%eax
jne    118d <remove_junk_data+0x7d>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
movb   $0xa,(%rax)
mov    -0x18(%rbp),%ecx
mov    -0x28(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
movl   $0x0,-0x18(%rbp)
jmp    11d5 <remove_junk_data+0xc5>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
mov    -0x18(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
jmp    114b <remove_junk_data+0x3b>
jmp    1130 <remove_junk_data+0x20>
mov    -0x38(%rbp),%rax
movb   $0x0,(%rax)
mov    -0x10(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%rdi
call   1030 <get_line_len@plt>
mov    %eax,-0x14(%rbp)
cmp    $0x0,%eax
je     12da <remove_junk_data+0x1ca>
mov    -0x14(%rbp),%eax
mov    %eax,-0x18(%rbp)
movl   $0x1,-0x1c(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x18(%rbp)
cmp    $0x0,%eax
je     1274 <remove_junk_data+0x164>
mov    -0x30(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x20,%eax
jle    1263 <remove_junk_data+0x153>
mov    -0x30(%rbp),%rax
movsbl (%rax),%eax
cmp    $0xa,%eax
je     1263 <remove_junk_data+0x153>
movl   $0x0,-0x1c(%rbp)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    1228 <remove_junk_data+0x118>
cmpl   $0x0,-0x1c(%rbp)
jne    12c4 <remove_junk_data+0x1b4>
mov    -0x14(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x18(%rbp)
cmp    $0x0,%eax
je     12bf <remove_junk_data+0x1af>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
jmp    1284 <remove_junk_data+0x174>
jmp    12d5 <remove_junk_data+0x1c5>
mov    -0x14(%rbp),%ecx
mov    -0x28(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
jmp    11f6 <remove_junk_data+0xe6>
mov    -0x38(%rbp),%rax
movb   $0x0,(%rax)
mov    -0x10(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%rdi
call   1030 <get_line_len@plt>
mov    %eax,-0x14(%rbp)
cmp    $0x0,%eax
je     13ed <remove_junk_data+0x2dd>
mov    -0x14(%rbp),%eax
mov    %eax,-0x18(%rbp)
cmpl   $0x0,-0x18(%rbp)
je     13e8 <remove_junk_data+0x2d8>
mov    -0x28(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x20,%eax
jg     1347 <remove_junk_data+0x237>
mov    -0x28(%rbp),%rax
movsbl (%rax),%eax
cmp    $0xa,%eax
je     1347 <remove_junk_data+0x237>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    13da <remove_junk_data+0x2ca>
mov    -0x28(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x5c,%eax
jne    13b3 <remove_junk_data+0x2a3>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
cmpl   $0x1,-0x18(%rbp)
jle    13ae <remove_junk_data+0x29e>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
mov    -0x18(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
jmp    13d5 <remove_junk_data+0x2c5>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
jmp    13da <remove_junk_data+0x2ca>
mov    -0x18(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
jmp    130c <remove_junk_data+0x1fc>
jmp    12f1 <remove_junk_data+0x1e1>
mov    -0x38(%rbp),%rax
movb   $0x0,(%rax)
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<remove_junk_data>:
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %rsi,%r14
mov    %rdi,%rbx
call   1030 <get_line_len@plt>
mov    %r14,%r12
test   %eax,%eax
je     1176 <remove_junk_data+0x66>
mov    %r14,%r12
jmp    113f <remove_junk_data+0x2f>
mov    %r15,%rdi
call   1030 <get_line_len@plt>
mov    %r15,%rbx
test   %eax,%eax
je     1176 <remove_junk_data+0x66>
movzbl (%rbx),%ecx
cmp    $0x23,%cl
jne    1160 <remove_junk_data+0x50>
cltq
lea    (%rbx,%rax,1),%r15
cmpb   $0xa,-0x1(%rbx,%rax,1)
jne    1130 <remove_junk_data+0x20>
movb   $0xa,(%r12)
add    $0x1,%r12
jmp    1130 <remove_junk_data+0x20>
nop
add    $0x1,%rbx
mov    %cl,(%r12)
add    $0x1,%r12
mov    %rbx,%r15
add    $0xffffffff,%eax
jne    113f <remove_junk_data+0x2f>
jmp    1130 <remove_junk_data+0x20>
movb   $0x0,(%r12)
mov    %r14,%rdi
call   1030 <get_line_len@plt>
mov    %r14,%r13
test   %eax,%eax
je     14f1 <remove_junk_data+0x3e1>
movabs $0x1ffffffe0,%r15
xor    %r12d,%r12d
movdqa 0xe6d(%rip),%xmm6
mov    %r14,%r13
mov    %r14,%rbx
jmp    11cd <remove_junk_data+0xbd>
nopl   0x0(%rax,%rax,1)
cltq
add    %rax,%rbx
mov    %rbx,%rdi
call   1030 <get_line_len@plt>
test   %eax,%eax
movdqa 0xe49(%rip),%xmm6
je     14f1 <remove_junk_data+0x3e1>
lea    -0x1(%rax),%r9d
mov    $0x1,%ecx
mov    %rbx,%rsi
mov    %eax,%edi
cmp    $0x7,%r9d
jb     12fd <remove_junk_data+0x1ed>
lea    0x1(%r9),%r8
lea    0x18(%r15),%rdx
and    %r8,%rdx
lea    -0x8(%rdx),%rsi
mov    %rsi,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
test   %rsi,%rsi
je     137b <remove_junk_data+0x26b>
mov    %rcx,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %esi,%esi
movdqa 0xde7(%rip),%xmm2
movdqa %xmm2,%xmm3
nopl   (%rax)
movd   (%rbx,%rsi,1),%xmm0
movd   0x4(%rbx,%rsi,1),%xmm4
pcmpgtb %xmm6,%xmm0
pcmpgtb %xmm6,%xmm4
movd   0x8(%rbx,%rsi,1),%xmm1
movd   0xc(%rbx,%rsi,1),%xmm5
pcmpgtb %xmm6,%xmm1
por    %xmm0,%xmm1
punpcklbw %xmm1,%xmm0
punpcklwd %xmm0,%xmm1
pcmpgtb %xmm6,%xmm5
por    %xmm4,%xmm5
punpcklbw %xmm5,%xmm0
punpcklwd %xmm0,%xmm0
psrad  $0x18,%xmm1
pandn  %xmm3,%xmm1
psrad  $0x18,%xmm0
pandn  %xmm2,%xmm0
add    $0x10,%rsi
movdqa %xmm1,%xmm3
movdqa %xmm0,%xmm2
add    $0xfffffffffffffffe,%rdi
jne    1220 <remove_junk_data+0x110>
test   $0x1,%cl
je     12c5 <remove_junk_data+0x1b5>
movd   (%rbx,%rsi,1),%xmm2
movd   0x4(%rbx,%rsi,1),%xmm3
pcmpgtb %xmm6,%xmm2
punpcklbw %xmm2,%xmm2
punpcklwd %xmm2,%xmm2
psrad  $0x18,%xmm2
pandn  %xmm1,%xmm2
pcmpgtb %xmm6,%xmm3
punpcklbw %xmm3,%xmm1
punpcklwd %xmm1,%xmm3
psrad  $0x18,%xmm3
pandn  %xmm0,%xmm3
movdqa %xmm2,%xmm1
movdqa %xmm3,%xmm0
movdqa %xmm1,%xmm2
movdqa 0xd2f(%rip),%xmm3
pcmpeqd %xmm3,%xmm2
pand   %xmm2,%xmm0
pandn  %xmm1,%xmm2
por    %xmm0,%xmm2
pcmpeqd %xmm3,%xmm2
movmskps %xmm2,%esi
xor    %ecx,%ecx
cmp    $0xf,%esi
sete   %cl
cmp    %rdx,%r8
je     1320 <remove_junk_data+0x210>
lea    (%rbx,%rdx,1),%rsi
mov    %eax,%edi
sub    %edx,%edi
mov    %edi,%edx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cmpb   $0x21,(%rsi,%rdi,1)
cmovge %r12d,%ecx
add    $0x1,%rdi
cmp    %edi,%edx
jne    1310 <remove_junk_data+0x200>
test   %ecx,%ecx
jne    11b0 <remove_junk_data+0xa0>
cmp    $0x1f,%r9d
jb     1460 <remove_junk_data+0x350>
lea    (%rbx,%r9,1),%rcx
add    $0x1,%rcx
cmp    %rcx,%r13
jae    1350 <remove_junk_data+0x240>
lea    (%r9,%r13,1),%rcx
add    $0x1,%rcx
cmp    %rcx,%rbx
jb     1460 <remove_junk_data+0x350>
add    $0x1,%r9
mov    %r9,%r8
and    %r15,%r8
lea    -0x20(%r8),%rdx
mov    %rdx,%rcx
shr    $0x5,%rcx
add    $0x1,%rcx
mov    %ecx,%esi
and    $0x3,%esi
cmp    $0x60,%rdx
jae    1397 <remove_junk_data+0x287>
xor    %edi,%edi
jmp    1405 <remove_junk_data+0x2f5>
xor    %esi,%esi
movdqa 0xc7b(%rip),%xmm0
movdqa %xmm0,%xmm1
test   $0x1,%cl
jne    1288 <remove_junk_data+0x178>
jmp    12c5 <remove_junk_data+0x1b5>
and    $0xfffffffffffffffc,%rcx
xor    %edi,%edi
nopl   (%rax)
movups (%rbx,%rdi,1),%xmm0
movups 0x10(%rbx,%rdi,1),%xmm1
movups %xmm0,0x0(%r13,%rdi,1)
movups %xmm1,0x10(%r13,%rdi,1)
movups 0x20(%rbx,%rdi,1),%xmm0
movups 0x30(%rbx,%rdi,1),%xmm1
movups %xmm0,0x20(%r13,%rdi,1)
movups %xmm1,0x30(%r13,%rdi,1)
movups 0x40(%rbx,%rdi,1),%xmm0
movups 0x50(%rbx,%rdi,1),%xmm1
movups %xmm0,0x40(%r13,%rdi,1)
movups %xmm1,0x50(%r13,%rdi,1)
movdqu 0x60(%rbx,%rdi,1),%xmm0
movdqu 0x70(%rbx,%rdi,1),%xmm1
movdqu %xmm0,0x60(%r13,%rdi,1)
movdqu %xmm1,0x70(%r13,%rdi,1)
sub    $0xffffffffffffff80,%rdi
add    $0xfffffffffffffffc,%rcx
jne    13a0 <remove_junk_data+0x290>
test   %rsi,%rsi
je     143f <remove_junk_data+0x32f>
lea    (%rbx,%rdi,1),%rcx
add    $0x10,%rcx
add    %r13,%rdi
add    $0x10,%rdi
shl    $0x5,%rsi
xor    %edx,%edx
nop
movdqu -0x10(%rcx,%rdx,1),%xmm0
movdqu (%rcx,%rdx,1),%xmm1
movdqu %xmm0,-0x10(%rdi,%rdx,1)
movdqu %xmm1,(%rdi,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%rsi
jne    1420 <remove_junk_data+0x310>
add    %r8,%r13
add    %r8,%rbx
cmp    %r8,%r9
je     11b5 <remove_junk_data+0xa5>
sub    %r8d,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    -0x1(%rax),%edi
test   $0x7,%al
je     1489 <remove_junk_data+0x379>
mov    %eax,%esi
and    $0x7,%esi
xor    %edx,%edx
xchg   %ax,%ax
movzbl (%rbx,%rdx,1),%ecx
mov    %cl,0x0(%r13,%rdx,1)
add    $0x1,%rdx
cmp    %edx,%esi
jne    1470 <remove_junk_data+0x360>
add    %rdx,%r13
add    %rdx,%rbx
sub    %edx,%eax
cmp    $0x7,%edi
jb     11b5 <remove_junk_data+0xa5>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl (%rbx),%ecx
mov    %cl,0x0(%r13)
movzbl 0x1(%rbx),%ecx
mov    %cl,0x1(%r13)
movzbl 0x2(%rbx),%ecx
mov    %cl,0x2(%r13)
movzbl 0x3(%rbx),%ecx
mov    %cl,0x3(%r13)
movzbl 0x4(%rbx),%ecx
mov    %cl,0x4(%r13)
movzbl 0x5(%rbx),%ecx
mov    %cl,0x5(%r13)
movzbl 0x6(%rbx),%ecx
mov    %cl,0x6(%r13)
movzbl 0x7(%rbx),%ecx
add    $0x8,%rbx
mov    %cl,0x7(%r13)
add    $0x8,%r13
add    $0xfffffff8,%eax
jne    14a0 <remove_junk_data+0x390>
jmp    11b5 <remove_junk_data+0xa5>
movb   $0x0,0x0(%r13)
mov    %r14,%rdi
call   1030 <get_line_len@plt>
test   %eax,%eax
je     157a <remove_junk_data+0x46a>
mov    %r14,%rbx
cs nopw 0x0(%rax,%rax,1)
nop
movzbl (%rbx),%edx
cmp    $0x20,%dl
jg     1530 <remove_junk_data+0x420>
cmp    $0xa,%dl
je     1530 <remove_junk_data+0x420>
add    $0x1,%rbx
jmp    1569 <remove_junk_data+0x459>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    0x1(%rbx),%rsi
lea    0x1(%r14),%rcx
cmp    $0x5c,%dl
jne    1560 <remove_junk_data+0x450>
movb   $0x5c,(%r14)
cmp    $0x2,%eax
jl     1563 <remove_junk_data+0x453>
movzbl 0x1(%rbx),%ecx
add    $0x2,%rbx
mov    %cl,0x1(%r14)
add    $0x2,%r14
add    $0xffffffff,%eax
jmp    1569 <remove_junk_data+0x459>
nopl   0x0(%rax,%rax,1)
mov    %dl,(%r14)
mov    %rsi,%rbx
mov    %rcx,%r14
add    $0xffffffff,%eax
jne    1510 <remove_junk_data+0x400>
mov    %rbx,%rdi
call   1030 <get_line_len@plt>
test   %eax,%eax
jne    1510 <remove_junk_data+0x400>
movb   $0x0,(%r14)
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
ret

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

LLVM IR (-O2):
define void @remove_junk_data(i8* %0, i8* %1) {
%3 = tail call i32 @get_line_len(i8* %0)
%4 = icmp eq i32 %3, 0
br i1 %4, label %33, label %10
5: ; preds = %24, %16, %22
%6 = phi i8* [ %11, %16 ], [ %23, %22 ], [ %26, %24 ]
%7 = phi i8* [ %18, %16 ], [ %18, %22 ], [ %25, %24 ]
%8 = tail call i32 @get_line_len(i8* %7)
%9 = icmp eq i32 %8, 0
br i1 %9, label %33, label %29
10: ; preds = %2, %29
%11 = phi i8* [ %30, %29 ], [ %1, %2 ]
%12 = phi i8* [ %31, %29 ], [ %0, %2 ]
%13 = phi i32 [ %32, %29 ], [ %3, %2 ]
%14 = load i8, i8* %12
%15 = icmp eq i8 %14, 35
br i1 %15, label %16, label %24
16: ; preds = %10
%17 = sext i32 %13 to i64
%18 = getelementptr inbounds i8, i8* %12, i64 %17
%19 = getelementptr inbounds i8, i8* %18, i64 -1
%20 = load i8, i8* %19
%21 = icmp eq i8 %20, 10
br i1 %21, label %22, label %5
22: ; preds = %16
%23 = getelementptr inbounds i8, i8* %11, i64 1
store i8 10, i8* %11
br label %5
24: ; preds = %10
%25 = getelementptr inbounds i8, i8* %12, i64 1
%26 = getelementptr inbounds i8, i8* %11, i64 1
store i8 %14, i8* %11
%27 = add nsw i32 %13, -1
%28 = icmp eq i32 %27, 0
br i1 %28, label %5, label %29
29: ; preds = %24, %5
%30 = phi i8* [ %26, %24 ], [ %6, %5 ]
%31 = phi i8* [ %25, %24 ], [ %7, %5 ]
%32 = phi i32 [ %27, %24 ], [ %8, %5 ]
br label %10
33: ; preds = %5, %2
%34 = phi i8* [ %1, %2 ], [ %6, %5 ]
store i8 0, i8* %34
%35 = tail call i32 @get_line_len(i8* %1)
%36 = icmp eq i32 %35, 0
br i1 %36, label %292, label %37
37: ; preds = %33, %287
%38 = phi i32 [ %290, %287 ], [ %35, %33 ]
%39 = phi i8* [ %289, %287 ], [ %1, %33 ]
%40 = phi i8* [ %288, %287 ], [ %1, %33 ]
%41 = add i32 %38, -1
%42 = zext i32 %41 to i64
%43 = add nuw nsw i64 %42, 1
%44 = icmp ult i32 %41, 7
br i1 %44, label %114, label %45
45: ; preds = %37
%46 = and i64 %43, 8589934584
%47 = getelementptr i8, i8* %40, i64 %46
%48 = trunc i64 %46 to i32
%49 = sub i32 %38, %48
%50 = add nsw i64 %46, -8
%51 = lshr exact i64 %50, 3
%52 = add nuw nsw i64 %51, 1
%53 = and i64 %52, 1
%54 = icmp eq i64 %50, 0
br i1 %54, label %86, label %55
55: ; preds = %45
%56 = and i64 %52, 4611686018427387902
br label %57
57: ; preds = %57, %55
%58 = phi i64 [ 0, %55 ], [ %83, %57 ]
%59 = phi <4 x i32> [ <i32 1, i32 1, i32 1, i32 1>, %55 ], [ %80, %57 ]
%60 = phi <4 x i32> [ <i32 1, i32 1, i32 1, i32 1>, %55 ], [ %82, %57 ]
%61 = phi i64 [ 0, %55 ], [ %84, %57 ]
%62 = getelementptr i8, i8* %40, i64 %58
%63 = bitcast i8* %62 to <4 x i8>*
%64 = load <4 x i8>, <4 x i8>* %63
%65 = getelementptr i8, i8* %62, i64 4
%66 = bitcast i8* %65 to <4 x i8>*
%67 = load <4 x i8>, <4 x i8>* %66
%68 = icmp sgt <4 x i8> %64, <i8 32, i8 32, i8 32, i8 32>
%69 = icmp sgt <4 x i8> %67, <i8 32, i8 32, i8 32, i8 32>
%70 = or i64 %58, 8
%71 = getelementptr i8, i8* %40, i64 %70
%72 = bitcast i8* %71 to <4 x i8>*
%73 = load <4 x i8>, <4 x i8>* %72
%74 = getelementptr i8, i8* %71, i64 4
%75 = bitcast i8* %74 to <4 x i8>*
%76 = load <4 x i8>, <4 x i8>* %75
%77 = icmp sgt <4 x i8> %73, <i8 32, i8 32, i8 32, i8 32>
%78 = icmp sgt <4 x i8> %76, <i8 32, i8 32, i8 32, i8 32>
%79 = select <4 x i1> %77, <4 x i1> <i1 true, i1 true, i1 true, i1 true>, <4 x i1> %68
%80 = select <4 x i1> %79, <4 x i32> zeroinitializer, <4 x i32> %59
%81 = select <4 x i1> %78, <4 x i1> <i1 true, i1 true, i1 true, i1 true>, <4 x i1> %69
%82 = select <4 x i1> %81, <4 x i32> zeroinitializer, <4 x i32> %60
%83 = add nuw i64 %58, 16
%84 = add i64 %61, 2
%85 = icmp eq i64 %84, %56
br i1 %85, label %86, label %57
86: ; preds = %57, %45
%87 = phi <4 x i32> [ undef, %45 ], [ %80, %57 ]
%88 = phi <4 x i32> [ undef, %45 ], [ %82, %57 ]
%89 = phi i64 [ 0, %45 ], [ %83, %57 ]
%90 = phi <4 x i32> [ <i32 1, i32 1, i32 1, i32 1>, %45 ], [ %80, %57 ]
%91 = phi <4 x i32> [ <i32 1, i32 1, i32 1, i32 1>, %45 ], [ %82, %57 ]
%92 = icmp eq i64 %53, 0
br i1 %92, label %104, label %93
93: ; preds = %86
%94 = getelementptr i8, i8* %40, i64 %89
%95 = bitcast i8* %94 to <4 x i8>*
%96 = load <4 x i8>, <4 x i8>* %95
%97 = getelementptr i8, i8* %94, i64 4
%98 = bitcast i8* %97 to <4 x i8>*
%99 = load <4 x i8>, <4 x i8>* %98
%100 = icmp sgt <4 x i8> %96, <i8 32, i8 32, i8 32, i8 32>
%101 = icmp sgt <4 x i8> %99, <i8 32, i8 32, i8 32, i8 32>
%102 = select <4 x i1> %100, <4 x i32> zeroinitializer, <4 x i32> %90
%103 = select <4 x i1> %101, <4 x i32> zeroinitializer, <4 x i32> %91
br label %104
104: ; preds = %86, %93
%105 = phi <4 x i32> [ %87, %86 ], [ %102, %93 ]
%106 = phi <4 x i32> [ %88, %86 ], [ %103, %93 ]
%107 = icmp eq <4 x i32> %105, <i32 1, i32 1, i32 1, i32 1>
%108 = select <4 x i1> %107, <4 x i32> %106, <4 x i32> %105
%109 = icmp ne <4 x i32> %108, <i32 1, i32 1, i32 1, i32 1>
%110 = bitcast <4 x i1> %109 to i4
%111 = icmp eq i4 %110, 0
%112 = zext i1 %111 to i32
%113 = icmp eq i64 %43, %46
br i1 %113, label %128, label %114
114: ; preds = %37, %104
%115 = phi i8* [ %40, %37 ], [ %47, %104 ]
%116 = phi i32 [ 1, %37 ], [ %112, %104 ]
%117 = phi i32 [ %38, %37 ], [ %49, %104 ]
br label %118
118: ; preds = %114, %118
%119 = phi i8* [ %126, %118 ], [ %115, %114 ]
%120 = phi i32 [ %125, %118 ], [ %116, %114 ]
%121 = phi i32 [ %122, %118 ], [ %117, %114 ]
%122 = add nsw i32 %121, -1
%123 = load i8, i8* %119
%124 = icmp sgt i8 %123, 32
%125 = select i1 %124, i32 0, i32 %120
%126 = getelementptr inbounds i8, i8* %119, i64 1
%127 = icmp eq i32 %122, 0
br i1 %127, label %128, label %118
128: ; preds = %118, %104
%129 = phi i32 [ %112, %104 ], [ %125, %118 ]
%130 = icmp eq i32 %129, 0
br i1 %130, label %131, label %284
131: ; preds = %128
%132 = add i32 %38, -1
%133 = zext i32 %132 to i64
%134 = add nuw nsw i64 %133, 1
%135 = icmp ult i32 %132, 31
br i1 %135, label %229, label %136
136: ; preds = %131
%137 = getelementptr i8, i8* %39, i64 1
%138 = add i32 %38, -1
%139 = zext i32 %138 to i64
%140 = getelementptr i8, i8* %137, i64 %139
%141 = getelementptr i8, i8* %40, i64 1
%142 = getelementptr i8, i8* %141, i64 %139
%143 = icmp ult i8* %39, %142
%144 = icmp ult i8* %40, %140
%145 = and i1 %143, %144
br i1 %145, label %229, label %146
146: ; preds = %136
%147 = and i64 %134, 8589934560
%148 = getelementptr i8, i8* %39, i64 %147
%149 = getelementptr i8, i8* %40, i64 %147
%150 = trunc i64 %147 to i32
%151 = sub i32 %38, %150
%152 = add nsw i64 %147, -32
%153 = lshr exact i64 %152, 5
%154 = add nuw nsw i64 %153, 1
%155 = and i64 %154, 3
%156 = icmp ult i64 %152, 96
br i1 %156, label %208, label %157
157: ; preds = %146
%158 = and i64 %154, 1152921504606846972
br label %159
159: ; preds = %159, %157
%160 = phi i64 [ 0, %157 ], [ %205, %159 ]
%161 = phi i64 [ 0, %157 ], [ %206, %159 ]
%162 = getelementptr i8, i8* %39, i64 %160
%163 = getelementptr i8, i8* %40, i64 %160
%164 = bitcast i8* %163 to <16 x i8>*
%165 = load <16 x i8>, <16 x i8>* %164
%166 = getelementptr i8, i8* %163, i64 16
%167 = bitcast i8* %166 to <16 x i8>*
%168 = load <16 x i8>, <16 x i8>* %167
%169 = bitcast i8* %162 to <16 x i8>*
store <16 x i8> %165, <16 x i8>* %169
%170 = getelementptr i8, i8* %162, i64 16
%171 = bitcast i8* %170 to <16 x i8>*
store <16 x i8> %168, <16 x i8>* %171
%172 = or i64 %160, 32
%173 = getelementptr i8, i8* %39, i64 %172
%174 = getelementptr i8, i8* %40, i64 %172
%175 = bitcast i8* %174 to <16 x i8>*
%176 = load <16 x i8>, <16 x i8>* %175
%177 = getelementptr i8, i8* %174, i64 16
%178 = bitcast i8* %177 to <16 x i8>*
%179 = load <16 x i8>, <16 x i8>* %178
%180 = bitcast i8* %173 to <16 x i8>*
store <16 x i8> %176, <16 x i8>* %180
%181 = getelementptr i8, i8* %173, i64 16
%182 = bitcast i8* %181 to <16 x i8>*
store <16 x i8> %179, <16 x i8>* %182
%183 = or i64 %160, 64
%184 = getelementptr i8, i8* %39, i64 %183
%185 = getelementptr i8, i8* %40, i64 %183
%186 = bitcast i8* %185 to <16 x i8>*
%187 = load <16 x i8>, <16 x i8>* %186
%188 = getelementptr i8, i8* %185, i64 16
%189 = bitcast i8* %188 to <16 x i8>*
%190 = load <16 x i8>, <16 x i8>* %189
%191 = bitcast i8* %184 to <16 x i8>*
store <16 x i8> %187, <16 x i8>* %191
%192 = getelementptr i8, i8* %184, i64 16
%193 = bitcast i8* %192 to <16 x i8>*
store <16 x i8> %190, <16 x i8>* %193
%194 = or i64 %160, 96
%195 = getelementptr i8, i8* %39, i64 %194
%196 = getelementptr i8, i8* %40, i64 %194
%197 = bitcast i8* %196 to <16 x i8>*
%198 = load <16 x i8>, <16 x i8>* %197
%199 = getelementptr i8, i8* %196, i64 16
%200 = bitcast i8* %199 to <16 x i8>*
%201 = load <16 x i8>, <16 x i8>* %200
%202 = bitcast i8* %195 to <16 x i8>*
store <16 x i8> %198, <16 x i8>* %202
%203 = getelementptr i8, i8* %195, i64 16
%204 = bitcast i8* %203 to <16 x i8>*
store <16 x i8> %201, <16 x i8>* %204
%205 = add nuw i64 %160, 128
%206 = add i64 %161, 4
%207 = icmp eq i64 %206, %158
br i1 %207, label %208, label %159
208: ; preds = %159, %146
%209 = phi i64 [ 0, %146 ], [ %205, %159 ]
%210 = icmp eq i64 %155, 0
br i1 %210, label %227, label %211
211: ; preds = %208, %211
%212 = phi i64 [ %224, %211 ], [ %209, %208 ]
%213 = phi i64 [ %225, %211 ], [ 0, %208 ]
%214 = getelementptr i8, i8* %39, i64 %212
%215 = getelementptr i8, i8* %40, i64 %212
%216 = bitcast i8* %215 to <16 x i8>*
%217 = load <16 x i8>, <16 x i8>* %216
%218 = getelementptr i8, i8* %215, i64 16
%219 = bitcast i8* %218 to <16 x i8>*
%220 = load <16 x i8>, <16 x i8>* %219
%221 = bitcast i8* %214 to <16 x i8>*
store <16 x i8> %217, <16 x i8>* %221
%222 = getelementptr i8, i8* %214, i64 16
%223 = bitcast i8* %222 to <16 x i8>*
store <16 x i8> %220, <16 x i8>* %223
%224 = add nuw i64 %212, 32
%225 = add i64 %213, 1
%226 = icmp eq i64 %225, %155
br i1 %226, label %227, label %211
227: ; preds = %211, %208
%228 = icmp eq i64 %134, %147
br i1 %228, label %287, label %229
229: ; preds = %136, %131, %227
%230 = phi i8* [ %39, %136 ], [ %39, %131 ], [ %148, %227 ]
%231 = phi i8* [ %40, %136 ], [ %40, %131 ], [ %149, %227 ]
%232 = phi i32 [ %38, %136 ], [ %38, %131 ], [ %151, %227 ]
%233 = add i32 %232, -1
%234 = and i32 %232, 7
%235 = icmp eq i32 %234, 0
br i1 %235, label %247, label %236
236: ; preds = %229, %236
%237 = phi i8* [ %244, %236 ], [ %230, %229 ]
%238 = phi i8* [ %242, %236 ], [ %231, %229 ]
%239 = phi i32 [ %241, %236 ], [ %232, %229 ]
%240 = phi i32 [ %245, %236 ], [ 0, %229 ]
%241 = add nsw i32 %239, -1
%242 = getelementptr inbounds i8, i8* %238, i64 1
%243 = load i8, i8* %238
%244 = getelementptr inbounds i8, i8* %237, i64 1
store i8 %243, i8* %237
%245 = add i32 %240, 1
%246 = icmp eq i32 %245, %234
br i1 %246, label %247, label %236
247: ; preds = %236, %229
%248 = phi i8* [ undef, %229 ], [ %242, %236 ]
%249 = phi i8* [ undef, %229 ], [ %244, %236 ]
%250 = phi i8* [ %230, %229 ], [ %244, %236 ]
%251 = phi i8* [ %231, %229 ], [ %242, %236 ]
%252 = phi i32 [ %232, %229 ], [ %241, %236 ]
%253 = icmp ult i32 %233, 7
br i1 %253, label %287, label %254
254: ; preds = %247, %254
%255 = phi i8* [ %282, %254 ], [ %250, %247 ]
%256 = phi i8* [ %280, %254 ], [ %251, %247 ]
%257 = phi i32 [ %279, %254 ], [ %252, %247 ]
%258 = getelementptr inbounds i8, i8* %256, i64 1
%259 = load i8, i8* %256
%260 = getelementptr inbounds i8, i8* %255, i64 1
store i8 %259, i8* %255
%261 = getelementptr inbounds i8, i8* %256, i64 2
%262 = load i8, i8* %258
%263 = getelementptr inbounds i8, i8* %255, i64 2
store i8 %262, i8* %260
%264 = getelementptr inbounds i8, i8* %256, i64 3
%265 = load i8, i8* %261
%266 = getelementptr inbounds i8, i8* %255, i64 3
store i8 %265, i8* %263
%267 = getelementptr inbounds i8, i8* %256, i64 4
%268 = load i8, i8* %264
%269 = getelementptr inbounds i8, i8* %255, i64 4
store i8 %268, i8* %266
%270 = getelementptr inbounds i8, i8* %256, i64 5
%271 = load i8, i8* %267
%272 = getelementptr inbounds i8, i8* %255, i64 5
store i8 %271, i8* %269
%273 = getelementptr inbounds i8, i8* %256, i64 6
%274 = load i8, i8* %270
%275 = getelementptr inbounds i8, i8* %255, i64 6
store i8 %274, i8* %272
%276 = getelementptr inbounds i8, i8* %256, i64 7
%277 = load i8, i8* %273
%278 = getelementptr inbounds i8, i8* %255, i64 7
store i8 %277, i8* %275
%279 = add nsw i32 %257, -8
%280 = getelementptr inbounds i8, i8* %256, i64 8
%281 = load i8, i8* %276
%282 = getelementptr inbounds i8, i8* %255, i64 8
store i8 %281, i8* %278
%283 = icmp eq i32 %279, 0
br i1 %283, label %287, label %254
284: ; preds = %128
%285 = sext i32 %38 to i64
%286 = getelementptr inbounds i8, i8* %40, i64 %285
br label %287
287: ; preds = %247, %254, %227, %284
%288 = phi i8* [ %286, %284 ], [ %149, %227 ], [ %248, %247 ], [ %280, %254 ]
%289 = phi i8* [ %39, %284 ], [ %148, %227 ], [ %249, %247 ], [ %282, %254 ]
%290 = tail call i32 @get_line_len(i8* %288)
%291 = icmp eq i32 %290, 0
br i1 %291, label %292, label %37
292: ; preds = %287, %33
%293 = phi i8* [ %1, %33 ], [ %289, %287 ]
store i8 0, i8* %293
%294 = tail call i32 @get_line_len(i8* %1)
%295 = icmp eq i32 %294, 0
br i1 %295, label %329, label %299
296: ; preds = %321
%297 = tail call i32 @get_line_len(i8* %323)
%298 = icmp eq i32 %297, 0
br i1 %298, label %329, label %327
299: ; preds = %292, %327
%300 = phi i8* [ %324, %327 ], [ %1, %292 ]
%301 = phi i8* [ %323, %327 ], [ %1, %292 ]
%302 = phi i32 [ %328, %327 ], [ %294, %292 ]
%303 = load i8, i8* %301
%304 = icmp sgt i8 %303, 32
%305 = icmp eq i8 %303, 10
%306 = or i1 %304, %305
br i1 %306, label %309, label %307
307: ; preds = %299
%308 = getelementptr inbounds i8, i8* %301, i64 1
br label %321
309: ; preds = %299
%310 = icmp eq i8 %303, 92
%311 = getelementptr inbounds i8, i8* %301, i64 1
%312 = getelementptr inbounds i8, i8* %300, i64 1
br i1 %310, label %313, label %320
313: ; preds = %309
store i8 92, i8* %300
%314 = icmp sgt i32 %302, 1
br i1 %314, label %315, label %321
315: ; preds = %313
%316 = getelementptr inbounds i8, i8* %301, i64 2
%317 = load i8, i8* %311
%318 = getelementptr inbounds i8, i8* %300, i64 2
store i8 %317, i8* %312
%319 = add nsw i32 %302, -1
br label %321
320: ; preds = %309
store i8 %303, i8* %300
br label %321
321: ; preds = %320, %315, %313, %307
%322 = phi i32 [ %302, %307 ], [ %319, %315 ], [ %302, %313 ], [ %302, %320 ]
%323 = phi i8* [ %308, %307 ], [ %316, %315 ], [ %311, %313 ], [ %311, %320 ]
%324 = phi i8* [ %300, %307 ], [ %318, %315 ], [ %312, %313 ], [ %312, %320 ]
%325 = add nsw i32 %322, -1
%326 = icmp eq i32 %325, 0
br i1 %326, label %296, label %327
327: ; preds = %321, %296
%328 = phi i32 [ %325, %321 ], [ %297, %296 ]
br label %299
329: ; preds = %296, %292
%330 = phi i8* [ %1, %292 ], [ %324, %296 ]
store i8 0, i8* %330
ret void
}