#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 */
unsigned char *malloc(size_t);
unsigned char *nt_unicode(const char *string, size_t len) {
  unsigned char *uni, *pp;
  if (len == 0)
    return NULL;
  uni = malloc(len * 2);
  if ((pp = uni) != NULL)
    while (len-- > 0) {
      *pp++ = (unsigned char)*string++;
      *pp++ = 0;
    }
  return uni;
}


x86 assembly (clang, -O0):
<nt_unicode>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
cmpq   $0x0,-0x18(%rbp)
jne    1138 <nt_unicode+0x28>
movq   $0x0,-0x8(%rbp)
jmp    11bf <nt_unicode+0xaf>
mov    -0x18(%rbp),%rdi
shl    $0x1,%rdi
call   1030 <malloc@plt>
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x28(%rbp)
cmp    $0x0,%rax
je     11b7 <nt_unicode+0xa7>
jmp    1160 <nt_unicode+0x50>
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x18(%rbp)
cmp    $0x0,%rax
jbe    11b2 <nt_unicode+0xa2>
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)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movb   $0x0,(%rax)
jmp    1160 <nt_unicode+0x50>
jmp    11b7 <nt_unicode+0xa7>
mov    -0x20(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<nt_unicode>:
push   %r15
push   %r14
push   %rbx
test   %rsi,%rsi
je     11e5 <nt_unicode+0xd5>
mov    %rsi,%r14
mov    %rdi,%r15
lea    (%rsi,%rsi,1),%rdi
call   1030 <malloc@plt>
test   %rax,%rax
je     11e5 <nt_unicode+0xd5>
cmp    $0x10,%r14
jb     1156 <nt_unicode+0x46>
lea    (%r15,%r14,1),%rcx
cmp    %rcx,%rax
jae    11ed <nt_unicode+0xdd>
lea    (%rax,%r14,2),%rcx
cmp    %r15,%rcx
jbe    11ed <nt_unicode+0xdd>
mov    %rax,%rcx
lea    -0x1(%r14),%r8
mov    %r14,%rdi
and    $0x3,%rdi
je     118e <nt_unicode+0x7e>
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movzbl (%r15,%rsi,1),%edx
mov    %dl,(%rcx)
movb   $0x0,0x1(%rcx)
add    $0x2,%rcx
add    $0x1,%rsi
cmp    %rsi,%rdi
jne    1170 <nt_unicode+0x60>
sub    %rsi,%r14
add    %rsi,%r15
cmp    $0x3,%r8
jb     11e7 <nt_unicode+0xd7>
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
movzbl (%r15,%rdx,1),%ebx
mov    %bl,(%rcx,%rdx,2)
movb   $0x0,0x1(%rcx,%rdx,2)
movzbl 0x1(%r15,%rdx,1),%ebx
mov    %bl,0x2(%rcx,%rdx,2)
movb   $0x0,0x3(%rcx,%rdx,2)
movzbl 0x2(%r15,%rdx,1),%ebx
mov    %bl,0x4(%rcx,%rdx,2)
movb   $0x0,0x5(%rcx,%rdx,2)
movzbl 0x3(%r15,%rdx,1),%ebx
mov    %bl,0x6(%rcx,%rdx,2)
movb   $0x0,0x7(%rcx,%rdx,2)
add    $0x4,%rdx
cmp    %rdx,%r14
jne    11a0 <nt_unicode+0x90>
jmp    11e7 <nt_unicode+0xd7>
xor    %eax,%eax
pop    %rbx
pop    %r14
pop    %r15
ret
mov    %r14,%rdx
and    $0xfffffffffffffff0,%rdx
lea    -0x10(%rdx),%rcx
mov    %rcx,%rsi
shr    $0x4,%rsi
add    $0x1,%rsi
test   %rcx,%rcx
je     12b6 <nt_unicode+0x1a6>
mov    %rsi,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %ecx,%ecx
pxor   %xmm0,%xmm0
nopl   0x0(%rax)
movq   (%r15,%rcx,1),%xmm1
movq   0x8(%r15,%rcx,1),%xmm2
punpcklbw %xmm0,%xmm1
movdqu %xmm1,(%rax,%rcx,2)
punpcklbw %xmm0,%xmm2
movdqu %xmm2,0x10(%rax,%rcx,2)
movq   0x10(%r15,%rcx,1),%xmm1
movq   0x18(%r15,%rcx,1),%xmm2
punpcklbw %xmm0,%xmm1
movdqu %xmm1,0x20(%rax,%rcx,2)
punpcklbw %xmm0,%xmm2
movdqu %xmm2,0x30(%rax,%rcx,2)
add    $0x20,%rcx
add    $0xfffffffffffffffe,%rdi
jne    1220 <nt_unicode+0x110>
test   $0x1,%sil
je     129d <nt_unicode+0x18d>
lea    (%rcx,%rcx,1),%rsi
or     $0x10,%rsi
movq   (%r15,%rcx,1),%xmm0
movq   0x8(%r15,%rcx,1),%xmm1
pxor   %xmm2,%xmm2
punpcklbw %xmm2,%xmm0
movdqu %xmm0,(%rax,%rcx,2)
punpcklbw %xmm2,%xmm1
movdqu %xmm1,(%rax,%rsi,1)
cmp    %r14,%rdx
je     11e7 <nt_unicode+0xd7>
and    $0xf,%r14d
lea    (%rax,%rdx,2),%rcx
add    %rdx,%r15
jmp    1159 <nt_unicode+0x49>
xor    %ecx,%ecx
test   $0x1,%sil
jne    1272 <nt_unicode+0x162>
jmp    129d <nt_unicode+0x18d>

LLVM IR (-O0):
define i8* @nt_unicode(i8* %0, i64 %1) {
%3 = alloca i8*
%4 = alloca i8*
%5 = alloca i64
%6 = alloca i8*
%7 = alloca i8*
store i8* %0, i8** %4
store i64 %1, i64* %5
%8 = load i64, i64* %5
%9 = icmp eq i64 %8, 0
br i1 %9, label %10, label %11
10: ; preds = %2
store i8* null, i8** %3
br label %33
11: ; preds = %2
%12 = load i64, i64* %5
%13 = mul i64 %12, 2
%14 = call i8* @malloc(i64 %13)
store i8* %14, i8** %6
%15 = load i8*, i8** %6
store i8* %15, i8** %7
%16 = icmp ne i8* %15, null
br i1 %16, label %17, label %31
17: ; preds = %11
br label %18
18: ; preds = %22, %17
%19 = load i64, i64* %5
%20 = add i64 %19, -1
store i64 %20, i64* %5
%21 = icmp ugt i64 %19, 0
br i1 %21, label %22, label %30
22: ; preds = %18
%23 = load i8*, i8** %4
%24 = getelementptr inbounds i8, i8* %23, i32 1
store i8* %24, i8** %4
%25 = load i8, i8* %23
%26 = load i8*, i8** %7
%27 = getelementptr inbounds i8, i8* %26, i32 1
store i8* %27, i8** %7
store i8 %25, i8* %26
%28 = load i8*, i8** %7
%29 = getelementptr inbounds i8, i8* %28, i32 1
store i8* %29, i8** %7
store i8 0, i8* %28
br label %18
30: ; preds = %18
br label %31
31: ; preds = %30, %11
%32 = load i8*, i8** %6
store i8* %32, i8** %3
br label %33
33: ; preds = %31, %10
%34 = load i8*, i8** %3
ret i8* %34
}

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