#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;
  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    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x10(%rbp),%rdi
shl    $0x1,%rdi
call   1030 <malloc@plt>
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x20(%rbp)
cmp    $0x0,%rax
je     119f <nt_unicode+0x8f>
jmp    1148 <nt_unicode+0x38>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x10(%rbp)
cmp    $0x0,%rax
jbe    119a <nt_unicode+0x8a>
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
mov    (%rax),%cl
mov    -0x20(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x20(%rbp)
mov    %cl,(%rax)
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
movb   $0x0,(%rax)
jmp    1148 <nt_unicode+0x38>
jmp    119f <nt_unicode+0x8f>
mov    -0x18(%rbp),%rax
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<nt_unicode>:
push   %r15
push   %r14
push   %rbx
mov    %rsi,%r14
mov    %rdi,%r15
lea    (%rsi,%rsi,1),%rdi
call   1030 <malloc@plt>
test   %rax,%rax
je     12a2 <nt_unicode+0x192>
test   %r14,%r14
je     12a2 <nt_unicode+0x192>
cmp    $0x10,%r14
jb     1156 <nt_unicode+0x46>
lea    (%r15,%r14,1),%rcx
cmp    %rcx,%rax
jae    11e8 <nt_unicode+0xd8>
lea    (%rax,%r14,2),%rcx
cmp    %r15,%rcx
jbe    11e8 <nt_unicode+0xd8>
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>
add    %rsi,%r15
sub    %rsi,%r14
cmp    $0x3,%r8
jb     12a2 <nt_unicode+0x192>
xor    %edx,%edx
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    12a2 <nt_unicode+0x192>
mov    %r14,%rdx
and    $0xfffffffffffffff0,%rdx
lea    -0x10(%rdx),%rcx
mov    %rcx,%rsi
shr    $0x4,%rsi
add    $0x1,%rsi
test   %rcx,%rcx
je     12b8 <nt_unicode+0x1a8>
mov    %rsi,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %ecx,%ecx
pxor   %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
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
jne    12a8 <nt_unicode+0x198>
pop    %rbx
pop    %r14
pop    %r15
ret
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 i64
%5 = alloca i8*
%6 = alloca i8*
store i8* %0, i8** %3
store i64 %1, i64* %4
%7 = load i64, i64* %4
%8 = mul i64 %7, 2
%9 = call i8* @malloc(i64 %8)
store i8* %9, i8** %5
%10 = load i8*, i8** %5
store i8* %10, i8** %6
%11 = icmp ne i8* %10, null
br i1 %11, label %12, label %26
12: ; preds = %2
br label %13
13: ; preds = %17, %12
%14 = load i64, i64* %4
%15 = add i64 %14, -1
store i64 %15, i64* %4
%16 = icmp ugt i64 %14, 0
br i1 %16, label %17, label %25
17: ; preds = %13
%18 = load i8*, i8** %3
%19 = getelementptr inbounds i8, i8* %18, i32 1
store i8* %19, i8** %3
%20 = load i8, i8* %18
%21 = load i8*, i8** %6
%22 = getelementptr inbounds i8, i8* %21, i32 1
store i8* %22, i8** %6
store i8 %20, i8* %21
%23 = load i8*, i8** %6
%24 = getelementptr inbounds i8, i8* %23, i32 1
store i8* %24, i8** %6
store i8 0, i8* %23
br label %13
25: ; preds = %13
br label %26
26: ; preds = %25, %2
%27 = load i8*, i8** %5
ret i8* %27
}

LLVM IR (-O2):
define noalias i8* @nt_unicode(i8* nocapture %0, i64 %1) {
%3 = shl i64 %1, 1
%4 = tail call i8* @malloc(i64 %3)
%5 = icmp eq i8* %4, null
%6 = icmp eq i64 %1, 0
%7 = or i1 %5, %6
br i1 %7, label %134, label %8
8: ; preds = %2
%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* %4, i64 %11
%13 = getelementptr i8, i8* %0, i64 %1
%14 = icmp ult i8* %4, %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* %4, i64 %19
%21 = getelementptr i8, i8* %0, i64 %18
%22 = and i64 %1, 15
%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* %4, i64 %33
%43 = bitcast i8* %42 to <16 x i8>*
%44 = getelementptr inbounds i8, i8* %4, 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* %4, i64 %49
%59 = bitcast i8* %58 to <16 x i8>*
%60 = getelementptr inbounds i8, i8* %4, 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* %4, i64 %71
%81 = bitcast i8* %80 to <16 x i8>*
%82 = getelementptr inbounds i8, i8* %4, 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* [ %4, %10 ], [ %4, %8 ], [ %20, %86 ]
%90 = phi i8* [ %0, %10 ], [ %0, %8 ], [ %21, %86 ]
%91 = phi i64 [ %1, %10 ], [ %1, %8 ], [ %22, %86 ]
%92 = add i64 %91, -1
%93 = and i64 %91, 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 i8* [ %101, %95 ], [ %90, %88 ]
%98 = phi i64 [ %100, %95 ], [ %91, %88 ]
%99 = phi i64 [ %105, %95 ], [ 0, %88 ]
%100 = add i64 %98, -1
%101 = getelementptr inbounds i8, i8* %97, i64 1
%102 = load i8, i8* %97
%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 i8* [ %90, %88 ], [ %101, %95 ]
%110 = phi i64 [ %91, %88 ], [ %100, %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 i8* [ %129, %112 ], [ %109, %107 ]
%115 = phi i64 [ %128, %112 ], [ %110, %107 ]
%116 = getelementptr inbounds i8, i8* %114, i64 1
%117 = load i8, i8* %114
%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* %114, 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* %114, 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 %115, -4
%129 = getelementptr inbounds i8, i8* %114, 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, %2
ret i8* %4
}