#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*/ strcpy(char *, char *);
void path_simplify(char *path) {
  register int i, start, ddot;
  char stub_char;
  if (!*path)
    return;
  stub_char = '/';
  i = 0;
  ddot = 0;
  while (1) {
    if (path[i] == '.' && path[i + 1] == '/')
      i += 2;
    else if (path[i] == '.' && path[i + 1] == '.' && path[i + 2] == '/') {
      i += 3;
      ddot = 1;
    } else
      break;
  }
  if (i)
    strcpy(path, path + i - ddot);
  if ((path[0] == '.' && path[1] == '\0') ||
      (path[0] == '.' && path[1] == '.' && path[2] == '\0')) {
    path[0] = stub_char;
    path[1] = '\0';
    return;
  }
  i = 0;
  while (1) {
    if (!path[i])
      break;
    while (path[i] && path[i] != '/')
      i++;
    start = i++;
    if (!path[start])
      break;
    while (path[i] == '/')
      i++;
    if ((start + 1) != i) {
      strcpy(path + start + 1, path + i);
      i = start + 1;
    }
    if (start && !path[i]) {
    zero_last:
      path[--i] = '\0';
      break;
    }
    if (path[i] == '.') {
      if (!path[i + 1])
        goto zero_last;
      if (path[i + 1] == '/') {
        strcpy(path + i, path + i + 1);
        i = (start < 0) ? 0 : start;
        continue;
      }
      if (path[i + 1] == '.' && (path[i + 2] == '/' || !path[i + 2])) {
        while (--start > -1 && path[start] != '/')
          ;
        strcpy(path + start + 1, path + i + 2);
        i = (start < 0) ? 0 : start;
        continue;
      }
    }
  }
  if (!*path) {
    *path = stub_char;
    path[1] = '\0';
  }
}


x86 assembly (clang, -O0):
<path_simplify>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rax
cmpb   $0x0,(%rax)
jne    112e <path_simplify+0x1e>
jmp    153b <path_simplify+0x42b>
movb   $0x2f,-0x15(%rbp)
movl   $0x0,-0xc(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2e,%eax
jne    117d <path_simplify+0x6d>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2f,%eax
jne    117d <path_simplify+0x6d>
mov    -0xc(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0xc(%rbp)
jmp    11e5 <path_simplify+0xd5>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2e,%eax
jne    11db <path_simplify+0xcb>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2e,%eax
jne    11db <path_simplify+0xcb>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2f,%eax
jne    11db <path_simplify+0xcb>
mov    -0xc(%rbp),%eax
add    $0x3,%eax
mov    %eax,-0xc(%rbp)
movl   $0x1,-0x14(%rbp)
jmp    11e0 <path_simplify+0xd0>
jmp    11ea <path_simplify+0xda>
jmp    11e5 <path_simplify+0xd5>
jmp    1140 <path_simplify+0x30>
cmpl   $0x0,-0xc(%rbp)
je     1214 <path_simplify+0x104>
mov    -0x8(%rbp),%rdi
mov    -0x8(%rbp),%rsi
movslq -0xc(%rbp),%rax
add    %rax,%rsi
movslq -0x14(%rbp),%rcx
xor    %eax,%eax
sub    %rcx,%rax
add    %rax,%rsi
call   1030 <strcpy@plt>
mov    -0x8(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2e,%eax
jne    1235 <path_simplify+0x125>
mov    -0x8(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x0,%eax
je     1267 <path_simplify+0x157>
mov    -0x8(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2e,%eax
jne    127d <path_simplify+0x16d>
mov    -0x8(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x2e,%eax
jne    127d <path_simplify+0x16d>
mov    -0x8(%rbp),%rax
movsbl 0x2(%rax),%eax
cmp    $0x0,%eax
jne    127d <path_simplify+0x16d>
mov    -0x15(%rbp),%cl
mov    -0x8(%rbp),%rax
mov    %cl,(%rax)
mov    -0x8(%rbp),%rax
movb   $0x0,0x1(%rax)
jmp    153b <path_simplify+0x42b>
movl   $0x0,-0xc(%rbp)
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
cmpb   $0x0,(%rax,%rcx,1)
jne    129b <path_simplify+0x18b>
jmp    151d <path_simplify+0x40d>
jmp    12a0 <path_simplify+0x190>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x16(%rbp)
je     12cf <path_simplify+0x1bf>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2f,%eax
setne  %al
mov    %al,-0x16(%rbp)
mov    -0x16(%rbp),%al
test   $0x1,%al
jne    12df <path_simplify+0x1cf>
jmp    12ed <path_simplify+0x1dd>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    12a0 <path_simplify+0x190>
mov    -0xc(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0xc(%rbp)
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
cmpb   $0x0,(%rax,%rcx,1)
jne    1312 <path_simplify+0x202>
jmp    151d <path_simplify+0x40d>
jmp    1317 <path_simplify+0x207>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2f,%eax
jne    133a <path_simplify+0x22a>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1317 <path_simplify+0x207>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
cmp    -0xc(%rbp),%eax
je     1371 <path_simplify+0x261>
mov    -0x8(%rbp),%rdi
movslq -0x10(%rbp),%rax
add    %rax,%rdi
add    $0x1,%rdi
mov    -0x8(%rbp),%rsi
movslq -0xc(%rbp),%rax
add    %rax,%rsi
call   1030 <strcpy@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
cmpl   $0x0,-0x10(%rbp)
je     13ab <path_simplify+0x29b>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
cmpb   $0x0,(%rax,%rcx,1)
jne    13ab <path_simplify+0x29b>
jmp    1392 <path_simplify+0x282>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0xc(%rbp)
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
jmp    151d <path_simplify+0x40d>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2e,%eax
jne    1518 <path_simplify+0x408>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
cmpb   $0x0,(%rax,%rcx,1)
jne    13dc <path_simplify+0x2cc>
jmp    1392 <path_simplify+0x282>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2f,%eax
jne    143a <path_simplify+0x32a>
mov    -0x8(%rbp),%rdi
movslq -0xc(%rbp),%rax
add    %rax,%rdi
mov    -0x8(%rbp),%rsi
movslq -0xc(%rbp),%rax
add    %rax,%rsi
add    $0x1,%rsi
call   1030 <strcpy@plt>
cmpl   $0x0,-0x10(%rbp)
jge    1429 <path_simplify+0x319>
xor    %eax,%eax
mov    %eax,-0x1c(%rbp)
jmp    142f <path_simplify+0x31f>
mov    -0x10(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0xc(%rbp)
jmp    1284 <path_simplify+0x174>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2e,%eax
jne    1513 <path_simplify+0x403>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2f,%eax
je     1485 <path_simplify+0x375>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
cmpb   $0x0,(%rax,%rcx,1)
jne    1513 <path_simplify+0x403>
jmp    148a <path_simplify+0x37a>
mov    -0x10(%rbp),%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x10(%rbp)
xor    %eax,%eax
cmp    $0xffffffff,%ecx
mov    %al,-0x1d(%rbp)
jle    14b6 <path_simplify+0x3a6>
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2f,%eax
setne  %al
mov    %al,-0x1d(%rbp)
mov    -0x1d(%rbp),%al
test   $0x1,%al
jne    14c6 <path_simplify+0x3b6>
jmp    14cb <path_simplify+0x3bb>
jmp    148a <path_simplify+0x37a>
mov    -0x8(%rbp),%rdi
movslq -0x10(%rbp),%rax
add    %rax,%rdi
add    $0x1,%rdi
mov    -0x8(%rbp),%rsi
movslq -0xc(%rbp),%rax
add    %rax,%rsi
add    $0x2,%rsi
call   1030 <strcpy@plt>
cmpl   $0x0,-0x10(%rbp)
jge    1502 <path_simplify+0x3f2>
xor    %eax,%eax
mov    %eax,-0x24(%rbp)
jmp    1508 <path_simplify+0x3f8>
mov    -0x10(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0xc(%rbp)
jmp    1284 <path_simplify+0x174>
jmp    1518 <path_simplify+0x408>
jmp    1284 <path_simplify+0x174>
mov    -0x8(%rbp),%rax
cmpb   $0x0,(%rax)
jne    153b <path_simplify+0x42b>
mov    -0x15(%rbp),%cl
mov    -0x8(%rbp),%rax
mov    %cl,(%rax)
mov    -0x8(%rbp),%rax
movb   $0x0,0x1(%rax)
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<path_simplify>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    (%rdi),%al
test   %al,%al
je     1367 <path_simplify+0x257>
mov    %rdi,%r14
cmp    $0x2e,%al
jne    1198 <path_simplify+0x88>
xor    %esi,%esi
xor    %edx,%edx
xor    %ecx,%ecx
jmp    114f <path_simplify+0x3f>
nopw   0x0(%rax,%rax,1)
mov    %ebp,%edx
add    %rdi,%rdx
cmpb   $0x2e,(%r14,%rdx,1)
mov    %rdx,%rsi
jne    117a <path_simplify+0x6a>
mov    %edx,%edi
movzbl 0x1(%rdi,%r14,1),%ebx
mov    $0x2,%ebp
cmp    $0x2f,%bl
je     1140 <path_simplify+0x30>
cmp    $0x2e,%bl
jne    1181 <path_simplify+0x71>
cmpb   $0x2f,0x2(%rdi,%r14,1)
jne    1181 <path_simplify+0x71>
mov    $0x1,%ecx
mov    $0x3,%ebp
jmp    1140 <path_simplify+0x30>
mov    %edx,%esi
mov    $0x1,%edx
test   %edx,%edx
je     1198 <path_simplify+0x88>
add    %r14,%rsi
mov    %ecx,%eax
sub    %rax,%rsi
mov    %r14,%rdi
call   1030 <strcpy@plt>
mov    (%r14),%al
test   %al,%al
je     1355 <path_simplify+0x245>
cmp    $0x2e,%al
jne    11bf <path_simplify+0xaf>
mov    0x1(%r14),%al
test   %al,%al
je     135b <path_simplify+0x24b>
cmp    $0x2e,%al
jne    11bf <path_simplify+0xaf>
cmpb   $0x0,0x2(%r14)
je     135b <path_simplify+0x24b>
movabs $0xffffffff00000000,%rbp
ff ff ff
lea    0x1(%r14),%rax
mov    %rax,(%rsp)
lea    -0x1(%r14),%rax
mov    %rax,0x8(%rsp)
xor    %ebx,%ebx
jmp    11f6 <path_simplify+0xe6>
test   %al,%al
je     1349 <path_simplify+0x239>
mov    %edi,%ebx
movslq %ebx,%rax
cmpb   $0x0,(%r14,%rax,1)
je     1355 <path_simplify+0x245>
movslq %ebx,%r13
mov    %r13,%r12
imul   %rbp,%r12
lea    (%r14,%r13,1),%rax
lea    0x1(%r13),%edx
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movzbl (%rax,%rcx,1),%ebx
test   %bl,%bl
je     1230 <path_simplify+0x120>
cmp    $0x2f,%bl
je     1230 <path_simplify+0x120>
add    %rbp,%r12
add    $0x1,%rcx
add    $0x1,%edx
jmp    1210 <path_simplify+0x100>
nopl   0x0(%rax)
test   %bl,%bl
je     1355 <path_simplify+0x245>
mov    %r13d,%ebx
lea    (%rbx,%rcx,1),%rdi
add    $0x1,%rdi
add    %rcx,%rbx
add    %rcx,%r13
movslq %edi,%r8
movslq %edx,%rsi
add    0x8(%rsp),%rsi
mov    $0x1,%edx
nopl   0x0(%rax)
add    $0xffffffff,%edx
cmpb   $0x2f,0x1(%rsi)
lea    0x1(%rsi),%rsi
je     1260 <path_simplify+0x150>
test   %edx,%edx
je     128e <path_simplify+0x17e>
mov    %rdi,0x10(%rsp)
lea    (%rcx,%rax,1),%rdi
add    $0x1,%rdi
mov    %r8,%r15
call   1030 <strcpy@plt>
mov    %r15,%r8
mov    0x10(%rsp),%rdi
mov    (%r14,%r8,1),%al
test   %ebx,%ebx
je     129e <path_simplify+0x18e>
test   %al,%al
je     1349 <path_simplify+0x239>
cmp    $0x2e,%al
jne    11e6 <path_simplify+0xd6>
add    %r14,%r8
movabs $0x200000000,%rax
sub    %r12,%rax
sar    $0x20,%rax
mov    (%r14,%rax,1),%al
cmp    $0x2e,%al
je     12d4 <path_simplify+0x1c4>
cmp    $0x2f,%al
jne    11de <path_simplify+0xce>
mov    $0x1,%eax
mov    %r8,%rdi
jmp    132f <path_simplify+0x21f>
movabs $0x300000000,%rax
sub    %r12,%rax
sar    $0x20,%rax
mov    (%r14,%rax,1),%al
test   %al,%al
je     12f5 <path_simplify+0x1e5>
cmp    $0x2f,%al
jne    11e6 <path_simplify+0xd6>
mov    %r13d,%eax
test   %ebx,%ebx
mov    $0x0,%ecx
cmovns %ecx,%ebx
add    $0xffffffff,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
test   %eax,%eax
jle    1323 <path_simplify+0x213>
add    $0xffffffffffffffff,%rax
mov    %eax,%ecx
cmpb   $0x2f,(%r14,%rcx,1)
jne    1310 <path_simplify+0x200>
mov    %eax,%ebx
movslq %ebx,%rdi
add    (%rsp),%rdi
mov    $0x2,%eax
add    %rax,%r8
mov    %r8,%rsi
call   1030 <strcpy@plt>
test   %ebx,%ebx
mov    $0x0,%eax
cmovs  %eax,%ebx
jmp    11e8 <path_simplify+0xd8>
neg    %r12
sar    $0x20,%r12
movb   $0x0,(%r14,%r12,1)
cmpb   $0x0,(%r14)
jne    1367 <path_simplify+0x257>
movb   $0x2f,(%r14)
add    $0x1,%r14
movb   $0x0,(%r14)
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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