#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 *malloc(size_t);
char *strcpy(char *, char const *);
size_t strlen(char const *);
char *pathexpand(const char *cwd, const char *path) {
  static const char SEP[] = "/";
  if (!*path)
    path = ".";
  if (!*cwd || *SEP == *path)
    cwd = "";
  while (*cwd && *SEP == *cwd)
    ++cwd;
  size_t len = strlen(cwd);
  char *out = malloc(len + 1 + strlen(path) + 1);
  char *p = strcpy(out, cwd) + len;
  for (; *path; ++path) {
    char *pl;
    if (p > out && p[-1] != *SEP)
      *p++ = *SEP;
    pl = p;
    while (*path && *SEP != *path)
      *p++ = *path++;
    *p = '\0';
    if (p == pl)
      ;
    else if (p - pl == 1 && '.' == *pl)
      --p;
    else if (p - pl == 2 && '.' == pl[0] && '.' == pl[1]) {
      if (pl > out && --pl > out)
        for (--pl; pl > out && *SEP != *pl; --pl)
          ;
      p = pl > out ? ++pl : out;
    } else if (*path)
      *p++ = *path;
    if (!*path)
      break;
  }
  if (p > out + 1 && *SEP == p[-1])
    --p;
  *p = '\0';
  return out;
}


x86 assembly (clang, -O0):
<pathexpand>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x10(%rbp),%rax
cmpb   $0x0,(%rax)
jne    1158 <pathexpand+0x28>
lea    0xeae(%rip),%rax
mov    %rax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
cmpb   $0x0,(%rax)
je     117b <pathexpand+0x4b>
movsbl 0xe94(%rip),%eax
mov    -0x10(%rbp),%rcx
movsbl (%rcx),%ecx
cmp    %ecx,%eax
jne    1186 <pathexpand+0x56>
lea    0xe81(%rip),%rax
mov    %rax,-0x8(%rbp)
jmp    118b <pathexpand+0x5b>
mov    -0x8(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x31(%rbp)
je     11b6 <pathexpand+0x86>
movsbl 0xe59(%rip),%eax
mov    -0x8(%rbp),%rcx
movsbl (%rcx),%ecx
cmp    %ecx,%eax
sete   %al
mov    %al,-0x31(%rbp)
mov    -0x31(%rbp),%al
test   $0x1,%al
jne    11c6 <pathexpand+0x96>
jmp    11d7 <pathexpand+0xa7>
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
jmp    118b <pathexpand+0x5b>
mov    -0x8(%rbp),%rdi
call   1040 <strlen@plt>
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
mov    -0x10(%rbp),%rdi
call   1040 <strlen@plt>
mov    -0x40(%rbp),%rdi
add    %rax,%rdi
add    $0x1,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rdi
mov    -0x8(%rbp),%rsi
call   1030 <strcpy@plt>
add    -0x18(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
cmpb   $0x0,(%rax)
je     147e <pathexpand+0x34e>
mov    -0x28(%rbp),%rax
cmp    -0x20(%rbp),%rax
jbe    126b <pathexpand+0x13b>
mov    -0x28(%rbp),%rax
movsbl -0x1(%rax),%eax
movsbl 0xdb4(%rip),%ecx
cmp    %ecx,%eax
je     126b <pathexpand+0x13b>
mov    0xda6(%rip),%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,(%rax)
mov    -0x28(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x10(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x41(%rbp)
je     129e <pathexpand+0x16e>
movsbl 0xd71(%rip),%eax
mov    -0x10(%rbp),%rcx
movsbl (%rcx),%ecx
cmp    %ecx,%eax
setne  %al
mov    %al,-0x41(%rbp)
mov    -0x41(%rbp),%al
test   $0x1,%al
jne    12ae <pathexpand+0x17e>
jmp    12d5 <pathexpand+0x1a5>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
mov    (%rax),%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,(%rax)
jmp    1273 <pathexpand+0x143>
mov    -0x28(%rbp),%rax
movb   $0x0,(%rax)
mov    -0x28(%rbp),%rax
cmp    -0x30(%rbp),%rax
jne    12ef <pathexpand+0x1bf>
jmp    1456 <pathexpand+0x326>
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
sub    %rcx,%rax
cmp    $0x1,%rax
jne    1329 <pathexpand+0x1f9>
mov    -0x30(%rbp),%rax
movsbl (%rax),%ecx
mov    $0x2e,%eax
cmp    %ecx,%eax
jne    1329 <pathexpand+0x1f9>
mov    -0x28(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x28(%rbp)
jmp    1451 <pathexpand+0x321>
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
sub    %rcx,%rax
cmp    $0x2,%rax
jne    1423 <pathexpand+0x2f3>
mov    -0x30(%rbp),%rax
movsbl (%rax),%ecx
mov    $0x2e,%eax
cmp    %ecx,%eax
jne    1423 <pathexpand+0x2f3>
mov    -0x30(%rbp),%rax
movsbl 0x1(%rax),%ecx
mov    $0x2e,%eax
cmp    %ecx,%eax
jne    1423 <pathexpand+0x2f3>
mov    -0x30(%rbp),%rax
cmp    -0x20(%rbp),%rax
jbe    13eb <pathexpand+0x2bb>
mov    -0x30(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x30(%rbp)
cmp    -0x20(%rbp),%rax
jbe    13eb <pathexpand+0x2bb>
mov    -0x30(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rcx
xor    %eax,%eax
cmp    -0x20(%rbp),%rcx
mov    %al,-0x42(%rbp)
jbe    13c0 <pathexpand+0x290>
movsbl 0xc4f(%rip),%eax
mov    -0x30(%rbp),%rcx
movsbl (%rcx),%ecx
cmp    %ecx,%eax
setne  %al
mov    %al,-0x42(%rbp)
mov    -0x42(%rbp),%al
test   $0x1,%al
jne    13d0 <pathexpand+0x2a0>
jmp    13e6 <pathexpand+0x2b6>
jmp    13d5 <pathexpand+0x2a5>
mov    -0x30(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x30(%rbp)
jmp    1397 <pathexpand+0x267>
jmp    13eb <pathexpand+0x2bb>
mov    -0x30(%rbp),%rax
cmp    -0x20(%rbp),%rax
jbe    140e <pathexpand+0x2de>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
mov    %rax,-0x50(%rbp)
jmp    1416 <pathexpand+0x2e6>
mov    -0x20(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x50(%rbp),%rax
mov    %rax,-0x28(%rbp)
jmp    144c <pathexpand+0x31c>
mov    -0x10(%rbp),%rax
cmpb   $0x0,(%rax)
je     1447 <pathexpand+0x317>
mov    -0x10(%rbp),%rax
mov    (%rax),%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,(%rax)
jmp    144c <pathexpand+0x31c>
jmp    1451 <pathexpand+0x321>
jmp    1456 <pathexpand+0x326>
mov    -0x10(%rbp),%rax
cmpb   $0x0,(%rax)
jne    1468 <pathexpand+0x338>
jmp    147e <pathexpand+0x34e>
jmp    146d <pathexpand+0x33d>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    1222 <pathexpand+0xf2>
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
add    $0x1,%rcx
cmp    %rcx,%rax
jbe    14b6 <pathexpand+0x386>
movsbl 0xb66(%rip),%eax
mov    -0x28(%rbp),%rcx
movsbl -0x1(%rcx),%ecx
cmp    %ecx,%eax
jne    14b6 <pathexpand+0x386>
mov    -0x28(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
movb   $0x0,(%rax)
mov    -0x20(%rbp),%rax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<pathexpand>:
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
cmpb   $0x0,(%rsi)
lea    0xebd(%rip),%r13
cmovne %rsi,%r13
cmpb   $0x0,(%rdi)
je     1156 <pathexpand+0x26>
mov    %rdi,%rbx
cmpb   $0x2f,0x0(%r13)
jne    115d <pathexpand+0x2d>
lea    0xea4(%rip),%rbx
add    $0xffffffffffffffff,%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cmpb   $0x2f,0x1(%rbx)
lea    0x1(%rbx),%rbx
je     1170 <pathexpand+0x40>
mov    %rbx,%rdi
call   1040 <strlen@plt>
mov    %rax,%r12
mov    %r13,%rdi
call   1040 <strlen@plt>
lea    (%r12,%rax,1),%rdi
add    $0x2,%rdi
call   1050 <malloc@plt>
mov    %rax,%r15
mov    %rax,%r14
mov    %rax,%rdi
mov    %rbx,%rsi
call   1030 <strcpy@plt>
cmpb   $0x0,0x0(%r13)
je     12ac <pathexpand+0x17c>
cs nopw 0x0(%rax,%rax,1)
test   %r12,%r12
jle    11d6 <pathexpand+0xa6>
cmpb   $0x2f,-0x1(%r14,%r12,1)
je     11d6 <pathexpand+0xa6>
movb   $0x2f,(%r14,%r12,1)
add    $0x1,%r12
lea    (%r15,%r12,1),%rcx
xor    %eax,%eax
nopl   0x0(%rax)
movzbl 0x0(%r13,%rax,1),%edx
test   %dl,%dl
je     1200 <pathexpand+0xd0>
cmp    $0x2f,%dl
je     1200 <pathexpand+0xd0>
mov    %dl,(%rcx,%rax,1)
add    $0x1,%rax
jmp    11e0 <pathexpand+0xb0>
nopl   0x0(%rax,%rax,1)
movb   $0x0,(%rcx,%rax,1)
test   %rax,%rax
je     1283 <pathexpand+0x153>
cmp    $0x2,%rax
je     1230 <pathexpand+0x100>
cmp    $0x1,%rax
jne    1270 <pathexpand+0x140>
cmpb   $0x2e,(%rcx)
jne    1270 <pathexpand+0x140>
add    %rax,%r12
add    $0xffffffffffffffff,%r12
jmp    1283 <pathexpand+0x153>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cmpb   $0x2e,(%rcx)
jne    1270 <pathexpand+0x140>
cmpb   $0x2e,0x1(%rcx)
jne    1270 <pathexpand+0x140>
cmp    $0x3,%r12
jl     129f <pathexpand+0x16f>
add    $0xffffffffffffffff,%r12
mov    %r12,%rcx
nopl   0x0(%rax,%rax,1)
cmpb   $0x2f,-0x1(%r14,%rcx,1)
je     12a4 <pathexpand+0x174>
add    $0xffffffffffffffff,%rcx
mov    $0x0,%r12d
cmp    $0x1,%rcx
jg     1250 <pathexpand+0x120>
jmp    1283 <pathexpand+0x153>
nopw   0x0(%rax,%rax,1)
mov    0x0(%r13,%rax,1),%dl
test   %dl,%dl
je     12a9 <pathexpand+0x179>
add    %rax,%r12
add    $0x1,%r12
mov    %dl,(%rcx,%rax,1)
cmpb   $0x0,0x0(%r13,%rax,1)
je     12ac <pathexpand+0x17c>
add    %rax,%r13
add    $0x1,%r13
cmpb   $0x0,0x0(%r13)
jne    11c0 <pathexpand+0x90>
jmp    12ac <pathexpand+0x17c>
xor    %r12d,%r12d
jmp    1283 <pathexpand+0x153>
mov    %rcx,%r12
jmp    1283 <pathexpand+0x153>
add    %rax,%r12
add    %r12,%r15
cmp    $0x2,%r12
jl     12c2 <pathexpand+0x192>
lea    -0x1(%r15),%rax
cmpb   $0x2f,-0x1(%r15)
cmove  %rax,%r15
movb   $0x0,(%r15)
mov    %r14,%rax
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
ret

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

LLVM IR (-O2):
@.str = [2 x i8] c".\00"
@.str.1 = [1 x i8] zeroinitializer
define i8* @pathexpand(i8* nocapture %0, i8* nocapture %1) {
%3 = load i8, i8* %1
%4 = icmp eq i8 %3, 0
%5 = select i1 %4, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0), i8* %1
%6 = load i8, i8* %0
%7 = icmp eq i8 %6, 0
br i1 %7, label %11, label %8
8: ; preds = %2
%9 = load i8, i8* %5
%10 = icmp eq i8 %9, 47
br i1 %10, label %11, label %12
11: ; preds = %8, %2
br label %12
12: ; preds = %11, %8
%13 = phi i8* [ %0, %8 ], [ getelementptr inbounds ([1 x i8], [1 x i8]* @.str.1, i64 0, i64 0), %11 ]
br label %14
14: ; preds = %12, %14
%15 = phi i8* [ %18, %14 ], [ %13, %12 ]
%16 = load i8, i8* %15
%17 = icmp eq i8 %16, 47
%18 = getelementptr inbounds i8, i8* %15, i64 1
br i1 %17, label %14, label %19
19: ; preds = %14
%20 = tail call i64 @strlen(i8* %15)
%21 = tail call i64 @strlen(i8* dereferenceable(1) %5)
%22 = add i64 %20, 2
%23 = add i64 %22, %21
%24 = tail call i8* @malloc(i64 %23)
%25 = tail call i8* @strcpy(i8* dereferenceable(1) %24, i8* %15)
%26 = load i8, i8* %5
%27 = icmp eq i8 %26, 0
br i1 %27, label %95, label %31
28: ; preds = %90
%29 = load i8, i8* %94
%30 = icmp eq i8 %29, 0
br i1 %30, label %95, label %31
31: ; preds = %19, %28
%32 = phi i64 [ %91, %28 ], [ %20, %19 ]
%33 = phi i8* [ %94, %28 ], [ %5, %19 ]
%34 = getelementptr inbounds i8, i8* %24, i64 %32
%35 = icmp sgt i64 %32, 0
br i1 %35, label %36, label %42
36: ; preds = %31
%37 = getelementptr inbounds i8, i8* %34, i64 -1
%38 = load i8, i8* %37
%39 = icmp eq i8 %38, 47
br i1 %39, label %42, label %40
40: ; preds = %36
%41 = add nuw nsw i64 %32, 1
store i8 47, i8* %34
br label %42
42: ; preds = %40, %36, %31
%43 = phi i64 [ %41, %40 ], [ %32, %36 ], [ %32, %31 ]
%44 = getelementptr inbounds i8, i8* %24, i64 %43
br label %45
45: ; preds = %50, %42
%46 = phi i8* [ %33, %42 ], [ %51, %50 ]
%47 = phi i64 [ %43, %42 ], [ %52, %50 ]
%48 = getelementptr inbounds i8, i8* %24, i64 %47
%49 = load i8, i8* %46
switch i8 %49, label %50 [
i8 0, label %53
i8 47, label %53
]
50: ; preds = %45
%51 = getelementptr inbounds i8, i8* %46, i64 1
%52 = add nsw i64 %47, 1
store i8 %49, i8* %48
br label %45
53: ; preds = %45, %45
store i8 0, i8* %48
%54 = icmp eq i64 %47, %43
br i1 %54, label %90, label %55
55: ; preds = %53
%56 = ptrtoint i8* %48 to i64
%57 = ptrtoint i8* %44 to i64
%58 = sub i64 %56, %57
switch i64 %58, label %85 [
i64 1, label %59
i64 2, label %64
]
59: ; preds = %55
%60 = load i8, i8* %44
%61 = icmp eq i8 %60, 46
br i1 %61, label %62, label %85
62: ; preds = %59
%63 = add nsw i64 %47, -1
br label %90
64: ; preds = %55
%65 = load i8, i8* %44
%66 = icmp eq i8 %65, 46
br i1 %66, label %67, label %85
67: ; preds = %64
%68 = getelementptr inbounds i8, i8* %44, i64 1
%69 = load i8, i8* %68
%70 = icmp eq i8 %69, 46
br i1 %70, label %71, label %85
71: ; preds = %67
%72 = icmp sgt i64 %43, 2
br i1 %72, label %73, label %90
73: ; preds = %71
%74 = add nsw i64 %43, -2
br label %75
75: ; preds = %73, %80
%76 = phi i64 [ %81, %80 ], [ %74, %73 ]
%77 = getelementptr inbounds i8, i8* %24, i64 %76
%78 = load i8, i8* %77
%79 = icmp eq i8 %78, 47
br i1 %79, label %83, label %80
80: ; preds = %75
%81 = add nsw i64 %76, -1
%82 = icmp sgt i64 %76, 1
br i1 %82, label %75, label %90
83: ; preds = %75
%84 = add nuw nsw i64 %76, 1
br label %90
85: ; preds = %59, %55, %67, %64
%86 = load i8, i8* %46
%87 = icmp eq i8 %86, 0
br i1 %87, label %95, label %88
88: ; preds = %85
%89 = add nsw i64 %47, 1
store i8 %86, i8* %48
br label %90
90: ; preds = %80, %71, %83, %62, %88, %53
%91 = phi i64 [ %89, %88 ], [ %63, %62 ], [ %43, %53 ], [ %84, %83 ], [ 0, %71 ], [ 0, %80 ]
%92 = load i8, i8* %46
%93 = icmp eq i8 %92, 0
%94 = getelementptr inbounds i8, i8* %46, i64 1
br i1 %93, label %95, label %28
95: ; preds = %28, %90, %85, %19
%96 = phi i64 [ %20, %19 ], [ %47, %85 ], [ %91, %90 ], [ %91, %28 ]
%97 = getelementptr inbounds i8, i8* %24, i64 %96
%98 = icmp sgt i64 %96, 1
br i1 %98, label %99, label %104
99: ; preds = %95
%100 = getelementptr inbounds i8, i8* %97, i64 -1
%101 = load i8, i8* %100
%102 = icmp eq i8 %101, 47
%103 = select i1 %102, i8* %100, i8* %97
br label %104
104: ; preds = %99, %95
%105 = phi i8* [ %97, %95 ], [ %103, %99 ]
store i8 0, i8* %105
ret i8* %24
}