#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 */
char *sanitize_path(char *out, size_t outlen, const char *path,
                    const char *cwd) {
  char *outp = out;
  const char *in;
  int dots = 0;
  if (*path != '/') {
    dots = 0;
    for (in = cwd; *in && outp - out < outlen - 2;) {
      if (*in == '/') {
        if (dots > 0) {
          outp--;
          while (outp > out && *outp == '.')
            *outp-- = '\0';
        }
        *outp++ = '/';
        while (*in == '/')
          in++;
        dots = 0;
        continue;
      }
      if (*in == '.') {
        if (dots >= 0) {
          dots++;
        }
      } else {
        dots = -1;
      }
      *outp++ = *in++;
    }
    *outp = '\0';
    if (outp > out && outp[-1] == '/') {
      outp--;
      while (outp > out && *outp == '/')
        *outp-- = '\0';
      if (outp > out)
        outp++;
    }
    if (cwd && *cwd) {
      *outp++ = '/';
    }
    *outp = '\0';
  }
  dots = 0;
  for (in = path; *in && outp - out < outlen - 2;) {
    if (*in == '/') {
      if (dots > 0) {
        outp--;
        while (outp > out && *outp == '.')
          *outp-- = '\0';
      }
      *outp++ = '/';
      while (*in == '/')
        in++;
      dots = 0;
      continue;
    }
    if (*in == '.') {
      if (dots >= 0) {
        dots++;
      }
    } else {
      dots = -1;
    }
    *outp++ = *in++;
  }
  *outp = '\0';
  if (outp > out && outp[-1] == '/') {
    outp--;
    while (outp > out && *outp == '/')
      *outp-- = '\0';
  }
  return out;
}


x86 assembly (clang, -O0):
<sanitize_path>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x28(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2f,%eax
je     135c <sanitize_path+0x25c>
movl   $0x0,-0x34(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x35(%rbp)
je     1173 <sanitize_path+0x73>
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%rcx
sub    %rcx,%rax
mov    -0x10(%rbp),%rcx
sub    $0x2,%rcx
cmp    %rcx,%rax
setb   %al
mov    %al,-0x35(%rbp)
mov    -0x35(%rbp),%al
test   $0x1,%al
jne    1183 <sanitize_path+0x83>
jmp    128d <sanitize_path+0x18d>
mov    -0x30(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2f,%eax
jne    1237 <sanitize_path+0x137>
cmpl   $0x0,-0x34(%rbp)
jle    11f8 <sanitize_path+0xf8>
mov    -0x28(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rcx
xor    %eax,%eax
cmp    -0x8(%rbp),%rcx
mov    %al,-0x36(%rbp)
jbe    11cc <sanitize_path+0xcc>
mov    -0x28(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2e,%eax
sete   %al
mov    %al,-0x36(%rbp)
mov    -0x36(%rbp),%al
test   $0x1,%al
jne    11dc <sanitize_path+0xdc>
jmp    11f3 <sanitize_path+0xf3>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x28(%rbp)
movb   $0x0,(%rax)
jmp    11a9 <sanitize_path+0xa9>
jmp    11f8 <sanitize_path+0xf8>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movb   $0x2f,(%rax)
mov    -0x30(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2f,%eax
jne    122b <sanitize_path+0x12b>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    120a <sanitize_path+0x10a>
movl   $0x0,-0x34(%rbp)
jmp    1142 <sanitize_path+0x42>
mov    -0x30(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2e,%eax
jne    125f <sanitize_path+0x15f>
cmpl   $0x0,-0x34(%rbp)
jl     125a <sanitize_path+0x15a>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1266 <sanitize_path+0x166>
movl   $0xffffffff,-0x34(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,(%rax)
jmp    1142 <sanitize_path+0x42>
mov    -0x28(%rbp),%rax
movb   $0x0,(%rax)
mov    -0x28(%rbp),%rax
cmp    -0x8(%rbp),%rax
jbe    1328 <sanitize_path+0x228>
mov    -0x28(%rbp),%rax
movsbl -0x1(%rax),%eax
cmp    $0x2f,%eax
jne    1328 <sanitize_path+0x228>
mov    -0x28(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rcx
xor    %eax,%eax
cmp    -0x8(%rbp),%rcx
mov    %al,-0x37(%rbp)
jbe    12e2 <sanitize_path+0x1e2>
mov    -0x28(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2f,%eax
sete   %al
mov    %al,-0x37(%rbp)
mov    -0x37(%rbp),%al
test   $0x1,%al
jne    12f2 <sanitize_path+0x1f2>
jmp    1309 <sanitize_path+0x209>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x28(%rbp)
movb   $0x0,(%rax)
jmp    12bf <sanitize_path+0x1bf>
mov    -0x28(%rbp),%rax
cmp    -0x8(%rbp),%rax
jbe    1323 <sanitize_path+0x223>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    1328 <sanitize_path+0x228>
cmpq   $0x0,-0x20(%rbp)
je     1355 <sanitize_path+0x255>
mov    -0x20(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
je     1355 <sanitize_path+0x255>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movb   $0x2f,(%rax)
mov    -0x28(%rbp),%rax
movb   $0x0,(%rax)
movl   $0x0,-0x34(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x38(%rbp)
je     139c <sanitize_path+0x29c>
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%rcx
sub    %rcx,%rax
mov    -0x10(%rbp),%rcx
sub    $0x2,%rcx
cmp    %rcx,%rax
setb   %al
mov    %al,-0x38(%rbp)
mov    -0x38(%rbp),%al
test   $0x1,%al
jne    13ac <sanitize_path+0x2ac>
jmp    14b6 <sanitize_path+0x3b6>
mov    -0x30(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2f,%eax
jne    1460 <sanitize_path+0x360>
cmpl   $0x0,-0x34(%rbp)
jle    1421 <sanitize_path+0x321>
mov    -0x28(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rcx
xor    %eax,%eax
cmp    -0x8(%rbp),%rcx
mov    %al,-0x39(%rbp)
jbe    13f5 <sanitize_path+0x2f5>
mov    -0x28(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2e,%eax
sete   %al
mov    %al,-0x39(%rbp)
mov    -0x39(%rbp),%al
test   $0x1,%al
jne    1405 <sanitize_path+0x305>
jmp    141c <sanitize_path+0x31c>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x28(%rbp)
movb   $0x0,(%rax)
jmp    13d2 <sanitize_path+0x2d2>
jmp    1421 <sanitize_path+0x321>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movb   $0x2f,(%rax)
mov    -0x30(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2f,%eax
jne    1454 <sanitize_path+0x354>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    1433 <sanitize_path+0x333>
movl   $0x0,-0x34(%rbp)
jmp    136b <sanitize_path+0x26b>
mov    -0x30(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2e,%eax
jne    1488 <sanitize_path+0x388>
cmpl   $0x0,-0x34(%rbp)
jl     1483 <sanitize_path+0x383>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    148f <sanitize_path+0x38f>
movl   $0xffffffff,-0x34(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,(%rax)
jmp    136b <sanitize_path+0x26b>
mov    -0x28(%rbp),%rax
movb   $0x0,(%rax)
mov    -0x28(%rbp),%rax
cmp    -0x8(%rbp),%rax
jbe    1537 <sanitize_path+0x437>
mov    -0x28(%rbp),%rax
movsbl -0x1(%rax),%eax
cmp    $0x2f,%eax
jne    1537 <sanitize_path+0x437>
mov    -0x28(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rcx
xor    %eax,%eax
cmp    -0x8(%rbp),%rcx
mov    %al,-0x3a(%rbp)
jbe    150b <sanitize_path+0x40b>
mov    -0x28(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2f,%eax
sete   %al
mov    %al,-0x3a(%rbp)
mov    -0x3a(%rbp),%al
test   $0x1,%al
jne    151b <sanitize_path+0x41b>
jmp    1532 <sanitize_path+0x432>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x28(%rbp)
movb   $0x0,(%rax)
jmp    14e8 <sanitize_path+0x3e8>
jmp    1537 <sanitize_path+0x437>
mov    -0x8(%rbp),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<sanitize_path>:
push   %rbx
mov    %rdi,%rax
mov    $0x2f,%r8b
cmpb   $0x2f,(%rdx)
je     124e <sanitize_path+0x14e>
mov    (%rcx),%r10b
test   %r10b,%r10b
je     1223 <sanitize_path+0x123>
lea    -0x2(%rsi),%r9
xor    %r11d,%r11d
mov    %rcx,%rdi
mov    %rax,%r8
jmp    116f <sanitize_path+0x6f>
nopl   0x0(%rax,%rax,1)
mov    %r11d,%ebx
not    %ebx
shr    $0x1f,%ebx
add    %r11d,%ebx
mov    %r10b,(%r8)
add    $0x1,%r8
mov    0x1(%rdi),%r10b
add    $0x1,%rdi
mov    %ebx,%r11d
test   %r10b,%r10b
jne    116f <sanitize_path+0x6f>
jmp    11d1 <sanitize_path+0xd1>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r8
mov    $0x0,%r11d
test   %r10b,%r10b
je     11d1 <sanitize_path+0xd1>
mov    %r8,%rbx
sub    %rax,%rbx
cmp    %r9,%rbx
jae    11d1 <sanitize_path+0xd1>
cmp    $0x2e,%r10b
je     1130 <sanitize_path+0x30>
mov    $0xffffffff,%ebx
cmp    $0x2f,%r10b
jne    113b <sanitize_path+0x3b>
test   %r11d,%r11d
jle    11b0 <sanitize_path+0xb0>
add    $0xffffffffffffffff,%r8
cmp    %rax,%r8
jbe    11b0 <sanitize_path+0xb0>
cmpb   $0x2e,(%r8)
jne    11b0 <sanitize_path+0xb0>
movb   $0x0,(%r8)
jmp    1190 <sanitize_path+0x90>
cs nopw 0x0(%rax,%rax,1)
nop
movb   $0x2f,(%r8)
add    $0xffffffffffffffff,%rdi
nopl   0x0(%rax,%rax,1)
movzbl 0x1(%rdi),%r10d
add    $0x1,%rdi
cmp    $0x2f,%r10b
je     11c0 <sanitize_path+0xc0>
jmp    1160 <sanitize_path+0x60>
movb   $0x0,(%r8)
cmp    %rax,%r8
jbe    1230 <sanitize_path+0x130>
cmpb   $0x2f,-0x1(%r8)
jne    1334 <sanitize_path+0x234>
lea    -0x1(%r8),%rdi
cmp    %rax,%rdi
jbe    1233 <sanitize_path+0x133>
add    $0xfffffffffffffffe,%r8
mov    %r8,%rdi
cs nopw 0x0(%rax,%rax,1)
nop
movb   $0x0,0x1(%rdi)
cmp    %rax,%rdi
jbe    1233 <sanitize_path+0x133>
lea    -0x1(%rdi),%rbx
cmpb   $0x2f,(%rdi)
mov    %rbx,%rdi
je     1200 <sanitize_path+0x100>
add    $0x2,%rbx
mov    %rbx,%rdi
cmpb   $0x0,(%rcx)
jne    1238 <sanitize_path+0x138>
jmp    123f <sanitize_path+0x13f>
movb   $0x0,(%rax)
mov    %rax,%rdi
cmpb   $0x0,(%rcx)
jne    1238 <sanitize_path+0x138>
jmp    123f <sanitize_path+0x13f>
mov    %r8,%rdi
cmpb   $0x0,(%rcx)
je     123f <sanitize_path+0x13f>
movb   $0x2f,(%rdi)
add    $0x1,%rdi
movb   $0x0,(%rdi)
mov    (%rdx),%r8b
test   %r8b,%r8b
je     1301 <sanitize_path+0x201>
add    $0xfffffffffffffffe,%rsi
xor    %ebx,%ebx
jmp    129e <sanitize_path+0x19e>
cs nopw 0x0(%rax,%rax,1)
mov    %ebx,%ecx
not    %ecx
shr    $0x1f,%ecx
add    %ebx,%ecx
mov    %r8b,(%rdi)
add    $0x1,%rdi
mov    0x1(%rdx),%r8b
add    $0x1,%rdx
mov    %ecx,%ebx
test   %r8b,%r8b
jne    129e <sanitize_path+0x19e>
jmp    1301 <sanitize_path+0x201>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rdi
mov    $0x0,%ebx
test   %r8b,%r8b
je     1301 <sanitize_path+0x201>
mov    %rdi,%rcx
sub    %rax,%rcx
cmp    %rsi,%rcx
jae    1301 <sanitize_path+0x201>
cmp    $0x2e,%r8b
je     1260 <sanitize_path+0x160>
mov    $0xffffffff,%ecx
cmp    $0x2f,%r8b
jne    1269 <sanitize_path+0x169>
test   %ebx,%ebx
jle    12e0 <sanitize_path+0x1e0>
xchg   %ax,%ax
add    $0xffffffffffffffff,%rdi
cmp    %rax,%rdi
jbe    12e0 <sanitize_path+0x1e0>
cmpb   $0x2e,(%rdi)
jne    12e0 <sanitize_path+0x1e0>
movb   $0x0,(%rdi)
jmp    12c0 <sanitize_path+0x1c0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movb   $0x2f,(%rdi)
add    $0xffffffffffffffff,%rdx
nopw   0x0(%rax,%rax,1)
movzbl 0x1(%rdx),%r8d
add    $0x1,%rdx
cmp    $0x2f,%r8b
je     12f0 <sanitize_path+0x1f0>
jmp    1290 <sanitize_path+0x190>
movb   $0x0,(%rdi)
cmp    %rax,%rdi
jbe    1332 <sanitize_path+0x232>
cmpb   $0x2f,-0x1(%rdi)
jne    1332 <sanitize_path+0x232>
lea    -0x1(%rdi),%rcx
cmp    %rax,%rcx
jbe    1332 <sanitize_path+0x232>
add    $0xfffffffffffffffe,%rdi
nopl   0x0(%rax)
movb   $0x0,0x1(%rdi)
cmp    %rax,%rdi
jbe    1332 <sanitize_path+0x232>
cmpb   $0x2f,(%rdi)
lea    -0x1(%rdi),%rdi
je     1320 <sanitize_path+0x220>
pop    %rbx
ret
mov    %r8,%rdi
cmpb   $0x0,(%rcx)
jne    1238 <sanitize_path+0x138>
jmp    123f <sanitize_path+0x13f>

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

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