#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 strlen(char *);
void get_filename(char *s, char *d) {
  int i, ss, ee = strlen(s);
  ss = ee - 1;
  while ((s[ss] != '/') && (s[ss] != '\\') && (ss))
    ss--;
  if ((s[ss] == '/') || (s[ss] == '\\'))
    ss++;
  for (i = 0; i != (ee - ss); i++)
    d[i] = s[ss + i];
  d[i] = 0;
}


x86 assembly (clang, -O0):
<get_filename>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
xor    %eax,%eax
cmp    $0x2f,%ecx
mov    %al,-0x1d(%rbp)
je     1173 <get_filename+0x63>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
xor    %eax,%eax
cmp    $0x5c,%ecx
mov    %al,-0x1d(%rbp)
je     1173 <get_filename+0x63>
cmpl   $0x0,-0x18(%rbp)
setne  %al
mov    %al,-0x1d(%rbp)
mov    -0x1d(%rbp),%al
test   $0x1,%al
jne    1183 <get_filename+0x73>
jmp    1191 <get_filename+0x81>
mov    -0x18(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
jmp    1135 <get_filename+0x25>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2f,%eax
je     11bb <get_filename+0xab>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x5c,%eax
jne    11c4 <get_filename+0xb4>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    -0x18(%rbp),%ecx
cmp    %ecx,%eax
je     1205 <get_filename+0xf5>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    11cb <get_filename+0xbb>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<get_filename>:
push   %r15
push   %r14
push   %rbx
mov    %rsi,%r15
mov    %rdi,%r14
call   1030 <strlen@plt>
movslq %eax,%rdi
lea    -0x1(%rdi),%esi
cs nopw 0x0(%rax,%rax,1)
mov    %rdi,%rdx
movzbl -0x1(%r14,%rdi,1),%ebx
cmp    $0x2f,%bl
je     1156 <get_filename+0x46>
add    $0xffffffff,%esi
setb   %cl
lea    -0x1(%rdx),%rdi
cmp    $0x5c,%bl
je     1151 <get_filename+0x41>
test   %cl,%cl
jne    1130 <get_filename+0x20>
cmp    $0x5c,%bl
jne    1159 <get_filename+0x49>
mov    %rdx,%rdi
sub    %edi,%eax
je     11f1 <get_filename+0xe1>
movslq %edi,%r8
mov    %eax,%ecx
cmp    $0x8,%eax
jb     1188 <get_filename+0x78>
lea    (%r14,%r8,1),%r10
lea    (%r8,%rcx,1),%rdx
add    %r14,%rdx
cmp    %r15,%rdx
jbe    11fe <get_filename+0xee>
lea    (%r15,%rcx,1),%rdx
cmp    %rdx,%r10
jae    11fe <get_filename+0xee>
xor    %eax,%eax
mov    %rax,%rdx
not    %rdx
add    %rcx,%rdx
mov    %rcx,%rsi
and    $0x3,%rsi
je     11b2 <get_filename+0xa2>
lea    (%r14,%r8,1),%rdi
movzbl (%rdi,%rax,1),%ebx
mov    %bl,(%r15,%rax,1)
add    $0x1,%rax
add    $0xffffffffffffffff,%rsi
jne    11a0 <get_filename+0x90>
cmp    $0x3,%rdx
jb     11f3 <get_filename+0xe3>
lea    (%r8,%r14,1),%rdx
add    $0x3,%rdx
movzbl -0x3(%rdx,%rax,1),%ebx
mov    %bl,(%r15,%rax,1)
movzbl -0x2(%rdx,%rax,1),%ebx
mov    %bl,0x1(%r15,%rax,1)
movzbl -0x1(%rdx,%rax,1),%ebx
mov    %bl,0x2(%r15,%rax,1)
movzbl (%rdx,%rax,1),%ebx
mov    %bl,0x3(%r15,%rax,1)
add    $0x4,%rax
cmp    %rax,%rcx
jne    11c0 <get_filename+0xb0>
jmp    11f3 <get_filename+0xe3>
xor    %ecx,%ecx
movb   $0x0,(%r15,%rcx,1)
pop    %rbx
pop    %r14
pop    %r15
ret
cmp    $0x20,%eax
jae    120a <get_filename+0xfa>
xor    %eax,%eax
jmp    12ed <get_filename+0x1dd>
mov    %ecx,%eax
and    $0xffffffe0,%eax
lea    -0x20(%rax),%rdx
mov    %rdx,%rdi
shr    $0x5,%rdi
add    $0x1,%rdi
mov    %edi,%r9d
and    $0x3,%r9d
cmp    $0x60,%rdx
jae    122f <get_filename+0x11f>
xor    %edx,%edx
jmp    12a0 <get_filename+0x190>
and    $0xfffffffffffffffc,%rdi
lea    (%r8,%r14,1),%rsi
add    $0x70,%rsi
xor    %edx,%edx
nopl   (%rax)
movups -0x70(%rsi,%rdx,1),%xmm0
movups -0x60(%rsi,%rdx,1),%xmm1
movups %xmm0,(%r15,%rdx,1)
movups %xmm1,0x10(%r15,%rdx,1)
movups -0x50(%rsi,%rdx,1),%xmm0
movups -0x40(%rsi,%rdx,1),%xmm1
movups %xmm0,0x20(%r15,%rdx,1)
movups %xmm1,0x30(%r15,%rdx,1)
movups -0x30(%rsi,%rdx,1),%xmm0
movups -0x20(%rsi,%rdx,1),%xmm1
movups %xmm0,0x40(%r15,%rdx,1)
movups %xmm1,0x50(%r15,%rdx,1)
movups -0x10(%rsi,%rdx,1),%xmm0
movups (%rsi,%rdx,1),%xmm1
movups %xmm0,0x60(%r15,%rdx,1)
movups %xmm1,0x70(%r15,%rdx,1)
sub    $0xffffffffffffff80,%rdx
add    $0xfffffffffffffffc,%rdi
jne    1240 <get_filename+0x130>
test   %r9,%r9
je     12db <get_filename+0x1cb>
lea    (%rdx,%r15,1),%rsi
add    $0x10,%rsi
add    %r8,%rdx
add    %r14,%rdx
add    $0x10,%rdx
shl    $0x5,%r9
xor    %edi,%edi
nopl   (%rax)
movups -0x10(%rdx,%rdi,1),%xmm0
movups (%rdx,%rdi,1),%xmm1
movups %xmm0,-0x10(%rsi,%rdi,1)
movups %xmm1,(%rsi,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%r9
jne    12c0 <get_filename+0x1b0>
cmp    %rcx,%rax
je     11f3 <get_filename+0xe3>
test   $0x18,%cl
je     118a <get_filename+0x7a>
mov    %rax,%rdx
mov    %ecx,%eax
and    $0xfffffff8,%eax
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%r10,%rdx,1),%rsi
mov    %rsi,(%r15,%rdx,1)
add    $0x8,%rdx
cmp    %rdx,%rax
jne    1300 <get_filename+0x1f0>
cmp    %rcx,%rax
je     11f3 <get_filename+0xe3>
jmp    118a <get_filename+0x7a>

LLVM IR (-O0):
define void @get_filename(i8* %0, i8* %1) {
%3 = alloca i8*
%4 = alloca i8*
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
store i8* %0, i8** %3
store i8* %1, i8** %4
%8 = load i8*, i8** %3
%9 = call i32 @strlen(i8* %8)
store i32 %9, i32* %7
%10 = load i32, i32* %7
%11 = sub nsw i32 %10, 1
store i32 %11, i32* %6
br label %12
12: ; preds = %33, %2
%13 = load i8*, i8** %3
%14 = load i32, i32* %6
%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 ne i32 %18, 47
br i1 %19, label %20, label %31
20: ; preds = %12
%21 = load i8*, i8** %3
%22 = load i32, i32* %6
%23 = sext i32 %22 to i64
%24 = getelementptr inbounds i8, i8* %21, i64 %23
%25 = load i8, i8* %24
%26 = sext i8 %25 to i32
%27 = icmp ne i32 %26, 92
br i1 %27, label %28, label %31
28: ; preds = %20
%29 = load i32, i32* %6
%30 = icmp ne i32 %29, 0
br label %31
31: ; preds = %28, %20, %12
%32 = phi i1 [ false, %20 ], [ false, %12 ], [ %30, %28 ]
br i1 %32, label %33, label %36
33: ; preds = %31
%34 = load i32, i32* %6
%35 = add nsw i32 %34, -1
store i32 %35, i32* %6
br label %12
36: ; preds = %31
%37 = load i8*, i8** %3
%38 = load i32, i32* %6
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds i8, i8* %37, i64 %39
%41 = load i8, i8* %40
%42 = sext i8 %41 to i32
%43 = icmp eq i32 %42, 47
br i1 %43, label %52, label %44
44: ; preds = %36
%45 = load i8*, i8** %3
%46 = load i32, i32* %6
%47 = sext i32 %46 to i64
%48 = getelementptr inbounds i8, i8* %45, i64 %47
%49 = load i8, i8* %48
%50 = sext i8 %49 to i32
%51 = icmp eq i32 %50, 92
br i1 %51, label %52, label %55
52: ; preds = %44, %36
%53 = load i32, i32* %6
%54 = add nsw i32 %53, 1
store i32 %54, i32* %6
br label %55
55: ; preds = %52, %44
store i32 0, i32* %5
br label %56
56: ; preds = %74, %55
%57 = load i32, i32* %5
%58 = load i32, i32* %7
%59 = load i32, i32* %6
%60 = sub nsw i32 %58, %59
%61 = icmp ne i32 %57, %60
br i1 %61, label %62, label %77
62: ; preds = %56
%63 = load i8*, i8** %3
%64 = load i32, i32* %6
%65 = load i32, i32* %5
%66 = add nsw i32 %64, %65
%67 = sext i32 %66 to i64
%68 = getelementptr inbounds i8, i8* %63, i64 %67
%69 = load i8, i8* %68
%70 = load i8*, i8** %4
%71 = load i32, i32* %5
%72 = sext i32 %71 to i64
%73 = getelementptr inbounds i8, i8* %70, i64 %72
store i8 %69, i8* %73
br label %74
74: ; preds = %62
%75 = load i32, i32* %5
%76 = add nsw i32 %75, 1
store i32 %76, i32* %5
br label %56
77: ; preds = %56
%78 = load i8*, i8** %4
%79 = load i32, i32* %5
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds i8, i8* %78, i64 %80
store i8 0, i8* %81
ret void
}

LLVM IR (-O2):
define void @get_filename(i8* %0, i8* nocapture writeonly %1) {
%3 = tail call i32 @strlen(i8* %0)
%4 = sext i32 %3 to i64
br label %5
5: ; preds = %11, %2
%6 = phi i64 [ %7, %11 ], [ %4, %2 ]
%7 = add nsw i64 %6, -1
%8 = getelementptr inbounds i8, i8* %0, i64 %7
%9 = load i8, i8* %8
%10 = icmp eq i8 %9, 47
br i1 %10, label %18, label %11
11: ; preds = %5
%12 = icmp ne i8 %9, 92
%13 = trunc i64 %7 to i32
%14 = icmp ne i32 %13, 0
%15 = select i1 %12, i1 %14, i1 false
br i1 %15, label %5, label %16
16: ; preds = %11
%17 = icmp eq i8 %9, 92
br i1 %17, label %18, label %19
18: ; preds = %5, %16
br label %19
19: ; preds = %16, %18
%20 = phi i64 [ %6, %18 ], [ %7, %16 ]
%21 = trunc i64 %20 to i32
%22 = sub nsw i32 %3, %21
%23 = icmp eq i32 %22, 0
br i1 %23, label %185, label %24
24: ; preds = %19
%25 = shl i64 %20, 32
%26 = ashr exact i64 %25, 32
%27 = zext i32 %22 to i64
%28 = icmp ult i32 %22, 8
br i1 %28, label %141, label %29
29: ; preds = %24
%30 = getelementptr i8, i8* %1, i64 %27
%31 = getelementptr i8, i8* %0, i64 %26
%32 = add nsw i64 %26, %27
%33 = getelementptr i8, i8* %0, i64 %32
%34 = icmp ugt i8* %33, %1
%35 = icmp ult i8* %31, %30
%36 = and i1 %34, %35
br i1 %36, label %141, label %37
37: ; preds = %29
%38 = icmp ult i32 %22, 32
br i1 %38, label %126, label %39
39: ; preds = %37
%40 = and i64 %27, 4294967264
%41 = add nsw i64 %40, -32
%42 = lshr exact i64 %41, 5
%43 = add nuw nsw i64 %42, 1
%44 = and i64 %43, 3
%45 = icmp ult i64 %41, 96
br i1 %45, label %101, label %46
46: ; preds = %39
%47 = and i64 %43, 1152921504606846972
br label %48
48: ; preds = %48, %46
%49 = phi i64 [ 0, %46 ], [ %98, %48 ]
%50 = phi i64 [ 0, %46 ], [ %99, %48 ]
%51 = add nsw i64 %49, %26
%52 = getelementptr inbounds i8, i8* %0, i64 %51
%53 = bitcast i8* %52 to <16 x i8>*
%54 = load <16 x i8>, <16 x i8>* %53
%55 = getelementptr inbounds i8, i8* %52, i64 16
%56 = bitcast i8* %55 to <16 x i8>*
%57 = load <16 x i8>, <16 x i8>* %56
%58 = getelementptr inbounds i8, i8* %1, i64 %49
%59 = bitcast i8* %58 to <16 x i8>*
store <16 x i8> %54, <16 x i8>* %59
%60 = getelementptr inbounds i8, i8* %58, i64 16
%61 = bitcast i8* %60 to <16 x i8>*
store <16 x i8> %57, <16 x i8>* %61
%62 = or i64 %49, 32
%63 = add nsw i64 %62, %26
%64 = getelementptr inbounds i8, i8* %0, i64 %63
%65 = bitcast i8* %64 to <16 x i8>*
%66 = load <16 x i8>, <16 x i8>* %65
%67 = getelementptr inbounds i8, i8* %64, i64 16
%68 = bitcast i8* %67 to <16 x i8>*
%69 = load <16 x i8>, <16 x i8>* %68
%70 = getelementptr inbounds i8, i8* %1, i64 %62
%71 = bitcast i8* %70 to <16 x i8>*
store <16 x i8> %66, <16 x i8>* %71
%72 = getelementptr inbounds i8, i8* %70, i64 16
%73 = bitcast i8* %72 to <16 x i8>*
store <16 x i8> %69, <16 x i8>* %73
%74 = or i64 %49, 64
%75 = add nsw i64 %74, %26
%76 = getelementptr inbounds i8, i8* %0, i64 %75
%77 = bitcast i8* %76 to <16 x i8>*
%78 = load <16 x i8>, <16 x i8>* %77
%79 = getelementptr inbounds i8, i8* %76, i64 16
%80 = bitcast i8* %79 to <16 x i8>*
%81 = load <16 x i8>, <16 x i8>* %80
%82 = getelementptr inbounds i8, i8* %1, i64 %74
%83 = bitcast i8* %82 to <16 x i8>*
store <16 x i8> %78, <16 x i8>* %83
%84 = getelementptr inbounds i8, i8* %82, i64 16
%85 = bitcast i8* %84 to <16 x i8>*
store <16 x i8> %81, <16 x i8>* %85
%86 = or i64 %49, 96
%87 = add nsw i64 %86, %26
%88 = getelementptr inbounds i8, i8* %0, i64 %87
%89 = bitcast i8* %88 to <16 x i8>*
%90 = load <16 x i8>, <16 x i8>* %89
%91 = getelementptr inbounds i8, i8* %88, i64 16
%92 = bitcast i8* %91 to <16 x i8>*
%93 = load <16 x i8>, <16 x i8>* %92
%94 = getelementptr inbounds i8, i8* %1, i64 %86
%95 = bitcast i8* %94 to <16 x i8>*
store <16 x i8> %90, <16 x i8>* %95
%96 = getelementptr inbounds i8, i8* %94, i64 16
%97 = bitcast i8* %96 to <16 x i8>*
store <16 x i8> %93, <16 x i8>* %97
%98 = add nuw i64 %49, 128
%99 = add i64 %50, 4
%100 = icmp eq i64 %99, %47
br i1 %100, label %101, label %48
101: ; preds = %48, %39
%102 = phi i64 [ 0, %39 ], [ %98, %48 ]
%103 = icmp eq i64 %44, 0
br i1 %103, label %121, label %104
104: ; preds = %101, %104
%105 = phi i64 [ %118, %104 ], [ %102, %101 ]
%106 = phi i64 [ %119, %104 ], [ 0, %101 ]
%107 = add nsw i64 %105, %26
%108 = getelementptr inbounds i8, i8* %0, i64 %107
%109 = bitcast i8* %108 to <16 x i8>*
%110 = load <16 x i8>, <16 x i8>* %109
%111 = getelementptr inbounds i8, i8* %108, i64 16
%112 = bitcast i8* %111 to <16 x i8>*
%113 = load <16 x i8>, <16 x i8>* %112
%114 = getelementptr inbounds i8, i8* %1, i64 %105
%115 = bitcast i8* %114 to <16 x i8>*
store <16 x i8> %110, <16 x i8>* %115
%116 = getelementptr inbounds i8, i8* %114, i64 16
%117 = bitcast i8* %116 to <16 x i8>*
store <16 x i8> %113, <16 x i8>* %117
%118 = add nuw i64 %105, 32
%119 = add i64 %106, 1
%120 = icmp eq i64 %119, %44
br i1 %120, label %121, label %104
121: ; preds = %104, %101
%122 = icmp eq i64 %40, %27
br i1 %122, label %183, label %123
123: ; preds = %121
%124 = and i64 %27, 24
%125 = icmp eq i64 %124, 0
br i1 %125, label %141, label %126
126: ; preds = %37, %123
%127 = phi i64 [ %40, %123 ], [ 0, %37 ]
%128 = and i64 %27, 4294967288
br label %129
129: ; preds = %129, %126
%130 = phi i64 [ %127, %126 ], [ %137, %129 ]
%131 = add nsw i64 %130, %26
%132 = getelementptr inbounds i8, i8* %0, i64 %131
%133 = bitcast i8* %132 to <8 x i8>*
%134 = load <8 x i8>, <8 x i8>* %133
%135 = getelementptr inbounds i8, i8* %1, i64 %130
%136 = bitcast i8* %135 to <8 x i8>*
store <8 x i8> %134, <8 x i8>* %136
%137 = add nuw i64 %130, 8
%138 = icmp eq i64 %137, %128
br i1 %138, label %139, label %129
139: ; preds = %129
%140 = icmp eq i64 %128, %27
br i1 %140, label %183, label %141
141: ; preds = %29, %24, %123, %139
%142 = phi i64 [ 0, %24 ], [ 0, %29 ], [ %40, %123 ], [ %128, %139 ]
%143 = xor i64 %142, -1
%144 = add nsw i64 %143, %27
%145 = and i64 %27, 3
%146 = icmp eq i64 %145, 0
br i1 %146, label %157, label %147
147: ; preds = %141, %147
%148 = phi i64 [ %154, %147 ], [ %142, %141 ]
%149 = phi i64 [ %155, %147 ], [ 0, %141 ]
%150 = add nsw i64 %148, %26
%151 = getelementptr inbounds i8, i8* %0, i64 %150
%152 = load i8, i8* %151
%153 = getelementptr inbounds i8, i8* %1, i64 %148
store i8 %152, i8* %153
%154 = add nuw nsw i64 %148, 1
%155 = add i64 %149, 1
%156 = icmp eq i64 %155, %145
br i1 %156, label %157, label %147
157: ; preds = %147, %141
%158 = phi i64 [ %142, %141 ], [ %154, %147 ]
%159 = icmp ult i64 %144, 3
br i1 %159, label %183, label %160
160: ; preds = %157, %160
%161 = phi i64 [ %181, %160 ], [ %158, %157 ]
%162 = add nsw i64 %161, %26
%163 = getelementptr inbounds i8, i8* %0, i64 %162
%164 = load i8, i8* %163
%165 = getelementptr inbounds i8, i8* %1, i64 %161
store i8 %164, i8* %165
%166 = add nuw nsw i64 %161, 1
%167 = add nsw i64 %166, %26
%168 = getelementptr inbounds i8, i8* %0, i64 %167
%169 = load i8, i8* %168
%170 = getelementptr inbounds i8, i8* %1, i64 %166
store i8 %169, i8* %170
%171 = add nuw nsw i64 %161, 2
%172 = add nsw i64 %171, %26
%173 = getelementptr inbounds i8, i8* %0, i64 %172
%174 = load i8, i8* %173
%175 = getelementptr inbounds i8, i8* %1, i64 %171
store i8 %174, i8* %175
%176 = add nuw nsw i64 %161, 3
%177 = add nsw i64 %176, %26
%178 = getelementptr inbounds i8, i8* %0, i64 %177
%179 = load i8, i8* %178
%180 = getelementptr inbounds i8, i8* %1, i64 %176
store i8 %179, i8* %180
%181 = add nuw nsw i64 %161, 4
%182 = icmp eq i64 %181, %27
br i1 %182, label %183, label %160
183: ; preds = %157, %160, %139, %121
%184 = zext i32 %22 to i64
br label %185
185: ; preds = %19, %183
%186 = phi i64 [ %184, %183 ], [ 0, %19 ]
%187 = getelementptr inbounds i8, i8* %1, i64 %186
store i8 0, i8* %187
ret void
}