#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 /*<<< orphan*/ assert(int);
char *unicodeToString(char *p, size_t len) {
  int i;
  static char buf[1024];
  assert(len + 1 < sizeof buf);
  for (i = 0; i < (signed int)len; ++i) {
    buf[i] = *p & 0x7f;
    p += 2;
  }
  buf[i] = '\0';
  return buf;
}


x86 assembly (clang, -O0):
<unicodeToString>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
cmp    $0x400,%rax
setb   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x10(%rbp),%rcx
cmp    %ecx,%eax
jge    1185 <unicodeToString+0x75>
mov    -0x8(%rbp),%rax
movsbl (%rax),%eax
and    $0x7f,%eax
mov    %al,%dl
movslq -0x14(%rbp),%rcx
lea    0x2ed8(%rip),%rax
mov    %dl,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x8(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1142 <unicodeToString+0x32>
movslq -0x14(%rbp),%rcx
lea    0x2eb0(%rip),%rax
movb   $0x0,(%rax,%rcx,1)
lea    0x2ea5(%rip),%rax
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<unicodeToString>:
push   %r14
push   %rbx
push   %rax
mov    %rsi,%r14
mov    %rdi,%rbx
lea    0x1(%rsi),%rax
xor    %edi,%edi
cmp    $0x400,%rax
setb   %dil
call   1030 <assert@plt>
test   %r14d,%r14d
jle    1161 <unicodeToString+0x51>
mov    %r14d,%r9d
cmp    $0x9,%r9
jb     115a <unicodeToString+0x4a>
lea    0x2efc(%rip),%rdx
lea    (%rbx,%r9,2),%rcx
add    $0xffffffffffffffff,%rcx
cmp    %rdx,%rcx
jbe    1168 <unicodeToString+0x58>
lea    (%rdx,%r9,1),%rcx
cmp    %rbx,%rcx
jbe    1168 <unicodeToString+0x58>
xor    %ecx,%ecx
jmp    1232 <unicodeToString+0x122>
xor    %ecx,%ecx
jmp    12b6 <unicodeToString+0x1a6>
cmp    $0x11,%r9d
jae    1172 <unicodeToString+0x62>
xor    %ecx,%ecx
jmp    11d4 <unicodeToString+0xc4>
mov    %r14d,%ecx
and    $0xf,%ecx
test   %rcx,%rcx
mov    $0x10,%esi
cmovne %rcx,%rsi
mov    %r9,%rcx
sub    %rsi,%rcx
xor    %edi,%edi
movdqa 0xe6c(%rip),%xmm0
movdqa 0xe74(%rip),%xmm1
nopl   0x0(%rax)
movdqu (%rbx,%rdi,2),%xmm2
movdqu 0x10(%rbx,%rdi,2),%xmm3
pand   %xmm0,%xmm3
pand   %xmm0,%xmm2
packuswb %xmm3,%xmm2
pand   %xmm1,%xmm2
movdqa %xmm2,(%rdi,%rdx,1)
add    $0x10,%rdi
cmp    %rdi,%rcx
jne    11a0 <unicodeToString+0x90>
cmp    $0x9,%esi
jae    11d4 <unicodeToString+0xc4>
lea    (%rbx,%rcx,2),%rbx
jmp    1232 <unicodeToString+0x122>
mov    %rcx,%rsi
mov    %r14d,%ecx
and    $0x7,%ecx
test   %rcx,%rcx
mov    $0x8,%edi
cmovne %rcx,%rdi
mov    %r9,%rcx
sub    %rdi,%rcx
lea    (%rbx,%rcx,2),%rdi
movdqa 0xe05(%rip),%xmm0
movdqa 0xe1d(%rip),%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movdqu (%rbx,%rsi,2),%xmm2
pand   %xmm0,%xmm2
packuswb %xmm2,%xmm2
pand   %xmm1,%xmm2
movq   %xmm2,(%rsi,%rdx,1)
add    $0x8,%rsi
cmp    %rsi,%rcx
jne    1210 <unicodeToString+0x100>
mov    %rdi,%rbx
mov    %r14d,%esi
sub    %ecx,%esi
mov    %rcx,%r8
not    %r8
add    %r9,%r8
and    $0x3,%rsi
je     1267 <unicodeToString+0x157>
lea    0x2df3(%rip),%rdi
nopl   (%rax)
movzbl (%rbx),%edx
and    $0x7f,%dl
mov    %dl,(%rcx,%rdi,1)
add    $0x2,%rbx
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    1250 <unicodeToString+0x140>
cmp    $0x3,%r8
jb     12b3 <unicodeToString+0x1a3>
sub    %rcx,%r9
lea    0x2dc9(%rip),%rdx
add    %rdx,%rcx
add    $0x3,%rcx
xor    %edx,%edx
movzbl (%rbx,%rdx,2),%eax
and    $0x7f,%al
mov    %al,-0x3(%rcx,%rdx,1)
movzbl 0x2(%rbx,%rdx,2),%eax
and    $0x7f,%al
mov    %al,-0x2(%rcx,%rdx,1)
movzbl 0x4(%rbx,%rdx,2),%eax
and    $0x7f,%al
mov    %al,-0x1(%rcx,%rdx,1)
movzbl 0x6(%rbx,%rdx,2),%eax
and    $0x7f,%al
mov    %al,(%rcx,%rdx,1)
add    $0x4,%rdx
cmp    %rdx,%r9
jne    1280 <unicodeToString+0x170>
mov    %r14d,%ecx
lea    0x2d83(%rip),%rax
movb   $0x0,(%rcx,%rax,1)
add    $0x8,%rsp
pop    %rbx
pop    %r14
ret

LLVM IR (-O0):
@unicodeToString.buf = internal global [1024 x i8] zeroinitializer
define i8* @unicodeToString(i8* %0, i64 %1) {
%3 = alloca i8*
%4 = alloca i64
%5 = alloca i32
store i8* %0, i8** %3
store i64 %1, i64* %4
%6 = load i64, i64* %4
%7 = add i64 %6, 1
%8 = icmp ult i64 %7, 1024
%9 = zext i1 %8 to i32
%10 = call i32 @assert(i32 %9)
store i32 0, i32* %5
br label %11
11: ; preds = %27, %2
%12 = load i32, i32* %5
%13 = load i64, i64* %4
%14 = trunc i64 %13 to i32
%15 = icmp slt i32 %12, %14
br i1 %15, label %16, label %30
16: ; preds = %11
%17 = load i8*, i8** %3
%18 = load i8, i8* %17
%19 = sext i8 %18 to i32
%20 = and i32 %19, 127
%21 = trunc i32 %20 to i8
%22 = load i32, i32* %5
%23 = sext i32 %22 to i64
%24 = getelementptr inbounds [1024 x i8], [1024 x i8]* @unicodeToString.buf, i64 0, i64 %23
store i8 %21, i8* %24
%25 = load i8*, i8** %3
%26 = getelementptr inbounds i8, i8* %25, i64 2
store i8* %26, i8** %3
br label %27
27: ; preds = %16
%28 = load i32, i32* %5
%29 = add nsw i32 %28, 1
store i32 %29, i32* %5
br label %11
30: ; preds = %11
%31 = load i32, i32* %5
%32 = sext i32 %31 to i64
%33 = getelementptr inbounds [1024 x i8], [1024 x i8]* @unicodeToString.buf, i64 0, i64 %32
store i8 0, i8* %33
ret i8* getelementptr inbounds ([1024 x i8], [1024 x i8]* @unicodeToString.buf, i64 0, i64 0)
}

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