#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */
typedef int wchar_t;

/* Variables and functions */
int /*<<< orphan*/ LC_CTYPE;
scalar_t__ alloca(int);
int /*<<< orphan*/ free(char *);
size_t mbstowcs(int *, char *, size_t);
scalar_t__ realloc(char *, size_t);
char *setlocale(int /*<<< orphan*/, char *);
char *strdup(char *);
int wcstombs(char *, ...);
__attribute__((visibility("default"))) char *basename(char *path) {
  size_t len;
  static char *retfail = NULL;
  char *locale = setlocale(LC_CTYPE, NULL);
  if (locale != NULL)
    locale = strdup(locale);
  setlocale(LC_CTYPE, "");
  if (path && *path) {
    wchar_t *refcopy = (wchar_t *)alloca((1 + (len = mbstowcs(NULL, path, 0))) *
                                         sizeof(wchar_t));
    wchar_t *refpath = refcopy;
    if (((len = mbstowcs(refpath, path, len)) > 1) && (refpath[1] == L':')) {
      refpath += 2;
    }
    refcopy[len] = L'\0';
    if (*refpath) {
      wchar_t *refname;
      for (refname = refpath; *refpath; ++refpath) {
        if ((*refpath == L'/') || (*refpath == L'\\')) {
          while ((*refpath == L'/') || (*refpath == L'\\'))
            ++refpath;
          if (*refpath)
            refname = refpath;
          else
            while ((refpath > refname) &&
                   ((*--refpath == L'/') || (*refpath == L'\\')))
              *refpath = L'\0';
        }
      }
      if (*refname) {
        if ((len = wcstombs(path, refcopy, len)) != (size_t)(-1))
          path[len] = '\0';
        *refname = L'\0';
        if ((len = wcstombs(NULL, refcopy, 0)) != (size_t)(-1))
          path += len;
      } else {
        retfail = (char *)realloc(retfail, len = 1 + wcstombs(NULL, L"/", 0));
        wcstombs(path = retfail, L"/", len);
      }
      setlocale(LC_CTYPE, locale);
      free(locale);
      return (path);
    }
  }
  retfail = (char *)realloc(retfail, len = 1 + wcstombs(NULL, L".", 0));
  wcstombs(retfail, L".", len);
  setlocale(LC_CTYPE, locale);
  free(locale);
  return (retfail);
}


x86 assembly (clang, -O0):
<basename>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x10(%rbp)
mov    0x2e65(%rip),%rax
mov    (%rax),%edi
xor    %eax,%eax
mov    %eax,%esi
call   1070 <setlocale@plt>
mov    %rax,-0x20(%rbp)
cmpq   $0x0,-0x20(%rbp)
je     11aa <basename+0x3a>
mov    -0x20(%rbp),%rdi
call   1090 <strdup@plt>
mov    %rax,-0x20(%rbp)
mov    0x2e37(%rip),%rax
mov    (%rax),%edi
lea    0xe46(%rip),%rsi
call   1070 <setlocale@plt>
cmpq   $0x0,-0x10(%rbp)
je     146f <basename+0x2ff>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
je     146f <basename+0x2ff>
mov    -0x10(%rbp),%rsi
xor    %eax,%eax
mov    %eax,%edx
mov    %rdx,%rdi
call   1040 <mbstowcs@plt>
mov    %rax,-0x18(%rbp)
add    $0x1,%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1050 <alloca@plt>
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x18(%rbp),%rdx
call   1040 <mbstowcs@plt>
mov    %rax,-0x18(%rbp)
cmp    $0x1,%rax
jbe    1242 <basename+0xd2>
mov    -0x30(%rbp),%rax
cmpl   $0x3a,0x4(%rax)
jne    1242 <basename+0xd2>
mov    -0x30(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
cmpl   $0x0,(%rax)
je     146a <basename+0x2fa>
mov    -0x30(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x30(%rbp),%rax
cmpl   $0x0,(%rax)
je     1374 <basename+0x204>
mov    -0x30(%rbp),%rax
cmpl   $0x2f,(%rax)
je     128d <basename+0x11d>
mov    -0x30(%rbp),%rax
cmpl   $0x5c,(%rax)
jne    135e <basename+0x1ee>
jmp    1292 <basename+0x122>
mov    -0x30(%rbp),%rcx
mov    $0x1,%al
cmpl   $0x2f,(%rcx)
mov    %al,-0x39(%rbp)
je     12b1 <basename+0x141>
mov    -0x30(%rbp),%rax
cmpl   $0x5c,(%rax)
sete   %al
mov    %al,-0x39(%rbp)
mov    -0x39(%rbp),%al
test   $0x1,%al
jne    12c1 <basename+0x151>
jmp    12d2 <basename+0x162>
mov    -0x30(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x30(%rbp)
jmp    1292 <basename+0x122>
mov    -0x30(%rbp),%rax
cmpl   $0x0,(%rax)
je     12ec <basename+0x17c>
mov    -0x30(%rbp),%rax
mov    %rax,-0x38(%rbp)
jmp    1359 <basename+0x1e9>
jmp    12f1 <basename+0x181>
mov    -0x30(%rbp),%rcx
xor    %eax,%eax
cmp    -0x38(%rbp),%rcx
mov    %al,-0x3a(%rbp)
jbe    1335 <basename+0x1c5>
mov    -0x30(%rbp),%rcx
mov    %rcx,%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x30(%rbp)
mov    $0x1,%al
cmpl   $0x2f,-0x4(%rcx)
mov    %al,-0x3b(%rbp)
je     132f <basename+0x1bf>
mov    -0x30(%rbp),%rax
cmpl   $0x5c,(%rax)
sete   %al
mov    %al,-0x3b(%rbp)
mov    -0x3b(%rbp),%al
mov    %al,-0x3a(%rbp)
mov    -0x3a(%rbp),%al
test   $0x1,%al
jne    1345 <basename+0x1d5>
jmp    1354 <basename+0x1e4>
mov    -0x30(%rbp),%rax
movl   $0x0,(%rax)
jmp    12f1 <basename+0x181>
jmp    1359 <basename+0x1e9>
jmp    135e <basename+0x1ee>
jmp    1363 <basename+0x1f3>
mov    -0x30(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x30(%rbp)
jmp    1266 <basename+0xf6>
mov    -0x38(%rbp),%rax
cmpl   $0x0,(%rax)
je     13ec <basename+0x27c>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    $0x0,%al
call   1080 <wcstombs@plt>
cltq
mov    %rax,-0x18(%rbp)
cmp    $0xffffffffffffffff,%rax
je     13b0 <basename+0x240>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x38(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x28(%rbp),%rsi
xor    %eax,%eax
mov    %eax,%edi
xor    %edx,%edx
mov    $0x0,%al
call   1080 <wcstombs@plt>
cltq
mov    %rax,-0x18(%rbp)
cmp    $0xffffffffffffffff,%rax
je     13e7 <basename+0x277>
mov    -0x18(%rbp),%rax
add    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
jmp    1442 <basename+0x2d2>
mov    0x2c6d(%rip),%rax
mov    %rax,-0x48(%rbp)
xor    %eax,%eax
mov    %eax,%edi
lea    0xc02(%rip),%rsi
xor    %edx,%edx
mov    $0x0,%al
call   1080 <wcstombs@plt>
mov    -0x48(%rbp),%rdi
add    $0x1,%eax
movslq %eax,%rsi
mov    %rsi,-0x18(%rbp)
call   1060 <realloc@plt>
mov    %rax,0x2c3b(%rip)
mov    0x2c34(%rip),%rdi
mov    %rdi,-0x10(%rbp)
mov    -0x18(%rbp),%rdx
lea    0xbc9(%rip),%rsi
mov    $0x0,%al
call   1080 <wcstombs@plt>
mov    0x2b9f(%rip),%rax
mov    (%rax),%edi
mov    -0x20(%rbp),%rsi
call   1070 <setlocale@plt>
mov    -0x20(%rbp),%rdi
call   1030 <free@plt>
mov    -0x10(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    14e7 <basename+0x377>
jmp    146f <basename+0x2ff>
mov    0x2bea(%rip),%rax
mov    %rax,-0x50(%rbp)
xor    %eax,%eax
mov    %eax,%edi
lea    0xb87(%rip),%rsi
xor    %edx,%edx
mov    $0x0,%al
call   1080 <wcstombs@plt>
mov    -0x50(%rbp),%rdi
add    $0x1,%eax
movslq %eax,%rsi
mov    %rsi,-0x18(%rbp)
call   1060 <realloc@plt>
mov    %rax,0x2bb8(%rip)
mov    0x2bb1(%rip),%rdi
mov    -0x18(%rbp),%rdx
lea    0xb52(%rip),%rsi
mov    $0x0,%al
call   1080 <wcstombs@plt>
mov    0x2b20(%rip),%rax
mov    (%rax),%edi
mov    -0x20(%rbp),%rsi
call   1070 <setlocale@plt>
mov    -0x20(%rbp),%rdi
call   1030 <free@plt>
mov    0x2b7d(%rip),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<basename>:
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %rdi,%r12
mov    0x2e65(%rip),%r13
mov    0x0(%r13),%edi
xor    %r14d,%r14d
xor    %esi,%esi
call   1070 <setlocale@plt>
test   %rax,%rax
je     11a1 <basename+0x31>
mov    %rax,%rdi
call   1090 <strdup@plt>
mov    %rax,%r14
mov    0x0(%r13),%edi
lea    0xe54(%rip),%rsi
call   1070 <setlocale@plt>
test   %r12,%r12
je     1280 <basename+0x110>
cmpb   $0x0,(%r12)
je     1280 <basename+0x110>
xor    %edi,%edi
mov    %r12,%rsi
xor    %edx,%edx
call   1040 <mbstowcs@plt>
mov    %rax,%rbx
lea    0x4(,%rax,4),%edi
call   1050 <alloca@plt>
mov    %rax,%r15
mov    %rax,%rdi
mov    %r12,%rsi
mov    %rbx,%rdx
call   1040 <mbstowcs@plt>
mov    %r15,%rcx
cmp    $0x2,%rax
jb     1208 <basename+0x98>
xor    %ecx,%ecx
cmpl   $0x3a,0x4(%r15)
sete   %cl
lea    (%r15,%rcx,8),%rcx
movl   $0x0,(%r15,%rax,4)
mov    (%rcx),%edx
test   %edx,%edx
je     1280 <basename+0x110>
mov    %rcx,%rbx
jmp    122f <basename+0xbf>
nopl   0x0(%rax,%rax,1)
test   %edx,%edx
je     12e4 <basename+0x174>
mov    0x4(%rcx),%edx
add    $0x4,%rcx
cmp    $0x2f,%edx
je     1239 <basename+0xc9>
cmp    $0x5c,%edx
jne    1220 <basename+0xb0>
lea    -0x4(%rcx),%rsi
jmp    124b <basename+0xdb>
nop
mov    0x4(%rcx),%edx
add    $0x4,%rcx
add    $0x4,%rsi
cmp    $0x2f,%edx
je     1240 <basename+0xd0>
cmp    $0x5c,%edx
je     1240 <basename+0xd0>
test   %edx,%edx
je     126a <basename+0xfa>
mov    %rcx,%rbx
jmp    1228 <basename+0xb8>
xchg   %ax,%ax
movl   $0x0,(%rcx)
lea    -0x4(%rcx),%rsi
cmp    %rbx,%rcx
jbe    1228 <basename+0xb8>
mov    %rsi,%rcx
mov    (%rsi),%edx
cmp    $0x5c,%edx
je     1260 <basename+0xf0>
cmp    $0x2f,%edx
je     1260 <basename+0xf0>
jmp    1228 <basename+0xb8>
mov    0x2dd9(%rip),%r12
lea    0xd7e(%rip),%r15
xor    %edi,%edi
mov    %r15,%rsi
xor    %edx,%edx
xor    %eax,%eax
call   1080 <wcstombs@plt>
add    $0x1,%eax
movslq %eax,%rbx
mov    %r12,%rdi
mov    %rbx,%rsi
call   1060 <realloc@plt>
mov    %rax,0x2dac(%rip)
mov    %rax,%rdi
mov    %r15,%rsi
mov    %rbx,%rdx
xor    %eax,%eax
call   1080 <wcstombs@plt>
mov    0x0(%r13),%edi
mov    %r14,%rsi
call   1070 <setlocale@plt>
mov    %r14,%rdi
call   1030 <free@plt>
mov    0x2d81(%rip),%r12
jmp    1380 <basename+0x210>
cmpl   $0x0,(%rbx)
je     1325 <basename+0x1b5>
mov    %r12,%rdi
mov    %r15,%rsi
mov    %rax,%rdx
xor    %eax,%eax
call   1080 <wcstombs@plt>
cmp    $0xffffffff,%eax
je     1305 <basename+0x195>
cltq
movb   $0x0,(%r12,%rax,1)
movl   $0x0,(%rbx)
xor    %edi,%edi
mov    %r15,%rsi
xor    %edx,%edx
xor    %eax,%eax
call   1080 <wcstombs@plt>
cmp    $0xffffffff,%eax
je     136c <basename+0x1fc>
cltq
add    %rax,%r12
jmp    136c <basename+0x1fc>
mov    0x2d34(%rip),%r12
lea    0xcd1(%rip),%r15
xor    %edi,%edi
mov    %r15,%rsi
xor    %edx,%edx
xor    %eax,%eax
call   1080 <wcstombs@plt>
add    $0x1,%eax
movslq %eax,%rbx
mov    %r12,%rdi
mov    %rbx,%rsi
call   1060 <realloc@plt>
mov    %rax,%r12
mov    %rax,0x2d04(%rip)
mov    %rax,%rdi
mov    %r15,%rsi
mov    %rbx,%rdx
xor    %eax,%eax
call   1080 <wcstombs@plt>
mov    0x0(%r13),%edi
mov    %r14,%rsi
call   1070 <setlocale@plt>
mov    %r14,%rdi
call   1030 <free@plt>
mov    %r12,%rax
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
ret

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

LLVM IR (-O2):
@basename.retfail = internal unnamed_addr global i8* null
@LC_CTYPE = global i32 0
@.str = [1 x i8] zeroinitializer
@.str.1 = [2 x i32] [i32 47, i32 0]
@.str.2 = [2 x i32] [i32 46, i32 0]
define i8* @basename(i8* %0) {
%2 = load i32, i32* @LC_CTYPE
%3 = tail call i8* @setlocale(i32 %2, i8* null)
%4 = icmp eq i8* %3, null
br i1 %4, label %7, label %5
5: ; preds = %1
%6 = tail call i8* @strdup(i8* %3)
br label %7
7: ; preds = %5, %1
%8 = phi i8* [ %6, %5 ], [ null, %1 ]
%9 = load i32, i32* @LC_CTYPE
%10 = tail call i8* @setlocale(i32 %9, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str, i64 0, i64 0))
%11 = icmp eq i8* %0, null
br i1 %11, label %87, label %12
12: ; preds = %7
%13 = load i8, i8* %0
%14 = icmp eq i8 %13, 0
br i1 %14, label %87, label %15
15: ; preds = %12
%16 = tail call i64 @mbstowcs(i32* null, i8* %0, i64 0)
%17 = trunc i64 %16 to i32
%18 = shl i32 %17, 2
%19 = add i32 %18, 4
%20 = tail call i64 @alloca(i32 %19)
%21 = inttoptr i64 %20 to i32*
%22 = tail call i64 @mbstowcs(i32* %21, i8* %0, i64 %16)
%23 = icmp ugt i64 %22, 1
br i1 %23, label %24, label %30
24: ; preds = %15
%25 = getelementptr inbounds i32, i32* %21, i64 1
%26 = load i32, i32* %25
%27 = icmp eq i32 %26, 58
%28 = select i1 %27, i64 2, i64 0
%29 = getelementptr i32, i32* %21, i64 %28
br label %30
30: ; preds = %24, %15
%31 = phi i32* [ %21, %15 ], [ %29, %24 ]
%32 = getelementptr inbounds i32, i32* %21, i64 %22
store i32 0, i32* %32
%33 = load i32, i32* %31
%34 = icmp eq i32 %33, 0
br i1 %34, label %87, label %35
35: ; preds = %30, %54
%36 = phi i32 [ %58, %54 ], [ %33, %30 ]
%37 = phi i32* [ %57, %54 ], [ %31, %30 ]
%38 = phi i32* [ %56, %54 ], [ %31, %30 ]
switch i32 %36, label %54 [
i32 0, label %59
i32 47, label %39
i32 92, label %39
]
39: ; preds = %35, %35
br label %40
40: ; preds = %39, %45
%41 = phi i32 [ %47, %45 ], [ %36, %39 ]
%42 = phi i32* [ %46, %45 ], [ %37, %39 ]
switch i32 %41, label %54 [
i32 47, label %45
i32 92, label %45
i32 0, label %43
]
43: ; preds = %40
%44 = icmp ugt i32* %42, %38
br i1 %44, label %48, label %54
45: ; preds = %40, %40
%46 = getelementptr inbounds i32, i32* %42, i64 1
%47 = load i32, i32* %46
br label %40
48: ; preds = %43, %52
%49 = phi i32* [ %50, %52 ], [ %42, %43 ]
%50 = getelementptr inbounds i32, i32* %49, i64 -1
%51 = load i32, i32* %50
switch i32 %51, label %54 [
i32 47, label %52
i32 92, label %52
]
52: ; preds = %48, %48
store i32 0, i32* %50
%53 = icmp ugt i32* %50, %38
br i1 %53, label %48, label %54
54: ; preds = %40, %52, %48, %43, %35
%55 = phi i32* [ %37, %35 ], [ %42, %43 ], [ %50, %48 ], [ %50, %52 ], [ %42, %40 ]
%56 = phi i32* [ %38, %35 ], [ %38, %43 ], [ %38, %48 ], [ %38, %52 ], [ %42, %40 ]
%57 = getelementptr inbounds i32, i32* %55, i64 1
%58 = load i32, i32* %57
br label %35
59: ; preds = %35
%60 = load i32, i32* %38
%61 = icmp eq i32 %60, 0
br i1 %61, label %74, label %62
62: ; preds = %59
%63 = tail call i32 (i8*, ...) @wcstombs(i8* %0, i32* %21, i64 %22)
%64 = icmp eq i32 %63, -1
br i1 %64, label %68, label %65
65: ; preds = %62
%66 = sext i32 %63 to i64
%67 = getelementptr inbounds i8, i8* %0, i64 %66
store i8 0, i8* %67
br label %68
68: ; preds = %65, %62
store i32 0, i32* %38
%69 = tail call i32 (i8*, ...) @wcstombs(i8* null, i32* %21, i32 0)
%70 = icmp eq i32 %69, -1
br i1 %70, label %82, label %71
71: ; preds = %68
%72 = sext i32 %69 to i64
%73 = getelementptr inbounds i8, i8* %0, i64 %72
br label %82
74: ; preds = %59
%75 = load i8*, i8** @basename.retfail
%76 = tail call i32 (i8*, ...) @wcstombs(i8* null, i32* getelementptr inbounds ([2 x i32], [2 x i32]* @.str.1, i64 0, i64 0), i32 0)
%77 = add nsw i32 %76, 1
%78 = sext i32 %77 to i64
%79 = tail call i64 @realloc(i8* %75, i64 %78)
%80 = inttoptr i64 %79 to i8*
store i8* %80, i8** @basename.retfail
%81 = tail call i32 (i8*, ...) @wcstombs(i8* %80, i32* getelementptr inbounds ([2 x i32], [2 x i32]* @.str.1, i64 0, i64 0), i64 %78)
br label %82
82: ; preds = %74, %71, %68
%83 = phi i8* [ %73, %71 ], [ %0, %68 ], [ %80, %74 ]
%84 = load i32, i32* @LC_CTYPE
%85 = tail call i8* @setlocale(i32 %84, i8* %8)
%86 = tail call i32 @free(i8* %8)
br label %99
87: ; preds = %30, %12, %7
%88 = load i8*, i8** @basename.retfail
%89 = tail call i32 (i8*, ...) @wcstombs(i8* null, i32* getelementptr inbounds ([2 x i32], [2 x i32]* @.str.2, i64 0, i64 0), i32 0)
%90 = add nsw i32 %89, 1
%91 = sext i32 %90 to i64
%92 = tail call i64 @realloc(i8* %88, i64 %91)
%93 = inttoptr i64 %92 to i8*
store i8* %93, i8** @basename.retfail
%94 = tail call i32 (i8*, ...) @wcstombs(i8* %93, i32* getelementptr inbounds ([2 x i32], [2 x i32]* @.str.2, i64 0, i64 0), i64 %91)
%95 = load i32, i32* @LC_CTYPE
%96 = tail call i8* @setlocale(i32 %95, i8* %8)
%97 = tail call i32 @free(i8* %8)
%98 = load i8*, i8** @basename.retfail
br label %99
99: ; preds = %82, %87
%100 = phi i8* [ %98, %87 ], [ %83, %82 ]
ret i8* %100
}