#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 devredir_cvt_to_unicode(char *unicode, char *path) {
  int len = strlen(path);
  int i;
  int j = 0;
  for (i = 0; i < len; i++) {
    unicode[j++] = path[i];
    unicode[j++] = 0x00;
  }
  unicode[j++] = 0x00;
  unicode[j++] = 0x00;
}


x86 assembly (clang, -O0):
<devredir_cvt_to_unicode>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x10(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x14(%rbp)
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    118a <devredir_cvt_to_unicode+0x7a>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x1c(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x1c(%rbp)
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    113a <devredir_cvt_to_unicode+0x2a>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x1c(%rbp)
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x1c(%rbp)
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<devredir_cvt_to_unicode>:
push   %r14
push   %rbx
push   %rax
mov    %rsi,%r14
mov    %rdi,%rbx
mov    %rsi,%rdi
call   1030 <strlen@plt>
test   %eax,%eax
jle    11b8 <devredir_cvt_to_unicode+0xa8>
mov    %eax,%esi
cmp    $0x10,%eax
jb     114b <devredir_cvt_to_unicode+0x3b>
lea    (%r14,%rsi,1),%rax
cmp    %rbx,%rax
jbe    11d0 <devredir_cvt_to_unicode+0xc0>
lea    (%rbx,%rsi,2),%rax
cmp    %r14,%rax
jbe    11d0 <devredir_cvt_to_unicode+0xc0>
xor    %eax,%eax
xor    %edx,%edx
mov    %rax,%rcx
not    %rcx
test   $0x1,%sil
je     1176 <devredir_cvt_to_unicode+0x66>
mov    (%r14,%rax,1),%r8b
mov    %rdx,%rdi
or     $0x1,%rdi
mov    %r8b,(%rbx,%rdx,1)
add    $0x2,%rdx
movb   $0x0,(%rbx,%rdi,1)
or     $0x1,%rax
add    %rsi,%rcx
je     11ba <devredir_cvt_to_unicode+0xaa>
nopl   0x0(%rax,%rax,1)
movzbl (%r14,%rax,1),%ecx
mov    %rdx,%rdi
or     $0x1,%rdi
mov    %cl,(%rbx,%rdx,1)
movb   $0x0,(%rbx,%rdi,1)
movzbl 0x1(%r14,%rax,1),%ecx
lea    0x2(%rdx),%rdi
or     $0x1,%rdi
mov    %cl,0x2(%rbx,%rdx,1)
add    $0x4,%rdx
movb   $0x0,(%rbx,%rdi,1)
add    $0x2,%rax
cmp    %rax,%rsi
jne    1180 <devredir_cvt_to_unicode+0x70>
jmp    11ba <devredir_cvt_to_unicode+0xaa>
xor    %edx,%edx
mov    %edx,%eax
movb   $0x0,(%rbx,%rax,1)
or     $0x1,%rax
movb   $0x0,(%rbx,%rax,1)
add    $0x8,%rsp
pop    %rbx
pop    %r14
ret
mov    %esi,%eax
and    $0xfffffff0,%eax
lea    -0x10(%rax),%rdx
mov    %rdx,%rcx
shr    $0x4,%rcx
add    $0x1,%rcx
test   %rdx,%rdx
je     128f <devredir_cvt_to_unicode+0x17f>
mov    %rcx,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %edx,%edx
pxor   %xmm0,%xmm0
nopw   0x0(%rax,%rax,1)
movq   (%r14,%rdx,1),%xmm1
movq   0x8(%r14,%rdx,1),%xmm2
punpcklbw %xmm0,%xmm1
movdqu %xmm1,(%rbx,%rdx,2)
punpcklbw %xmm0,%xmm2
movdqu %xmm2,0x10(%rbx,%rdx,2)
movq   0x10(%r14,%rdx,1),%xmm1
movq   0x18(%r14,%rdx,1),%xmm2
punpcklbw %xmm0,%xmm1
movdqu %xmm1,0x20(%rbx,%rdx,2)
punpcklbw %xmm0,%xmm2
movdqu %xmm2,0x30(%rbx,%rdx,2)
add    $0x20,%rdx
add    $0xfffffffffffffffe,%rdi
jne    1200 <devredir_cvt_to_unicode+0xf0>
test   $0x1,%cl
je     127d <devredir_cvt_to_unicode+0x16d>
lea    (%rdx,%rdx,1),%rcx
movq   (%r14,%rdx,1),%xmm0
movq   0x8(%r14,%rdx,1),%xmm1
or     $0x11,%rcx
pxor   %xmm2,%xmm2
punpcklbw %xmm2,%xmm0
movdqu %xmm0,(%rbx,%rdx,2)
punpcklbw %xmm2,%xmm1
movdqu %xmm1,-0x1(%rbx,%rcx,1)
lea    (%rax,%rax,1),%rdx
cmp    %rsi,%rax
jne    114f <devredir_cvt_to_unicode+0x3f>
jmp    11ba <devredir_cvt_to_unicode+0xaa>
xor    %edx,%edx
test   $0x1,%cl
jne    1251 <devredir_cvt_to_unicode+0x141>
jmp    127d <devredir_cvt_to_unicode+0x16d>

LLVM IR (-O0):
define void @devredir_cvt_to_unicode(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** %4
%9 = call i32 @strlen(i8* %8)
store i32 %9, i32* %5
store i32 0, i32* %7
store i32 0, i32* %6
br label %10
10: ; preds = %30, %2
%11 = load i32, i32* %6
%12 = load i32, i32* %5
%13 = icmp slt i32 %11, %12
br i1 %13, label %14, label %33
14: ; preds = %10
%15 = load i8*, i8** %4
%16 = load i32, i32* %6
%17 = sext i32 %16 to i64
%18 = getelementptr inbounds i8, i8* %15, i64 %17
%19 = load i8, i8* %18
%20 = load i8*, i8** %3
%21 = load i32, i32* %7
%22 = add nsw i32 %21, 1
store i32 %22, i32* %7
%23 = sext i32 %21 to i64
%24 = getelementptr inbounds i8, i8* %20, i64 %23
store i8 %19, i8* %24
%25 = load i8*, i8** %3
%26 = load i32, i32* %7
%27 = add nsw i32 %26, 1
store i32 %27, i32* %7
%28 = sext i32 %26 to i64
%29 = getelementptr inbounds i8, i8* %25, i64 %28
store i8 0, i8* %29
br label %30
30: ; preds = %14
%31 = load i32, i32* %6
%32 = add nsw i32 %31, 1
store i32 %32, i32* %6
br label %10
33: ; preds = %10
%34 = load i8*, i8** %3
%35 = load i32, i32* %7
%36 = add nsw i32 %35, 1
store i32 %36, i32* %7
%37 = sext i32 %35 to i64
%38 = getelementptr inbounds i8, i8* %34, i64 %37
store i8 0, i8* %38
%39 = load i8*, i8** %3
%40 = load i32, i32* %7
%41 = add nsw i32 %40, 1
store i32 %41, i32* %7
%42 = sext i32 %40 to i64
%43 = getelementptr inbounds i8, i8* %39, i64 %42
store i8 0, i8* %43
ret void
}

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