#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 < 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)
movslq -0x14(%rbp),%rax
cmp    -0x10(%rbp),%rax
jae    1184 <unicodeToString+0x74>
mov    -0x8(%rbp),%rax
movsbl (%rax),%eax
and    $0x7f,%eax
mov    %al,%dl
movslq -0x14(%rbp),%rcx
lea    0x2ed9(%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    0x2eb1(%rip),%rax
movb   $0x0,(%rax,%rcx,1)
lea    0x2ea6(%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   %r14,%r14
je     115e <unicodeToString+0x4e>
cmp    $0x9,%r14
jb     1157 <unicodeToString+0x47>
lea    0x2eff(%rip),%rcx
lea    (%rbx,%r14,2),%rax
add    $0xffffffffffffffff,%rax
cmp    %rcx,%rax
jbe    1165 <unicodeToString+0x55>
lea    (%rcx,%r14,1),%rax
cmp    %rbx,%rax
jbe    1165 <unicodeToString+0x55>
xor    %eax,%eax
jmp    1232 <unicodeToString+0x122>
xor    %ecx,%ecx
jmp    12ca <unicodeToString+0x1ba>
cmp    $0x11,%r14
jae    116f <unicodeToString+0x5f>
xor    %eax,%eax
jmp    11d4 <unicodeToString+0xc4>
mov    %r14d,%eax
and    $0xf,%eax
test   %rax,%rax
mov    $0x10,%edx
cmovne %rax,%rdx
mov    %r14,%rax
sub    %rdx,%rax
xor    %esi,%esi
movdqa 0xe6f(%rip),%xmm0
movdqa 0xe77(%rip),%xmm1
nopl   0x0(%rax)
movdqu (%rbx,%rsi,2),%xmm2
movdqu 0x10(%rbx,%rsi,2),%xmm3
pand   %xmm0,%xmm3
pand   %xmm0,%xmm2
packuswb %xmm3,%xmm2
pand   %xmm1,%xmm2
movdqa %xmm2,(%rsi,%rcx,1)
add    $0x10,%rsi
cmp    %rsi,%rax
jne    11a0 <unicodeToString+0x90>
cmp    $0x9,%edx
jae    11d4 <unicodeToString+0xc4>
lea    (%rbx,%rax,2),%rbx
jmp    1232 <unicodeToString+0x122>
mov    %rax,%rdx
mov    %r14d,%eax
and    $0x7,%eax
test   %rax,%rax
mov    $0x8,%esi
cmovne %rax,%rsi
mov    %r14,%rax
sub    %rsi,%rax
lea    (%rbx,%rax,2),%rsi
movdqa 0xe05(%rip),%xmm0
movdqa 0xe1d(%rip),%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movdqu (%rbx,%rdx,2),%xmm2
pand   %xmm0,%xmm2
packuswb %xmm2,%xmm2
pand   %xmm1,%xmm2
movq   %xmm2,(%rdx,%rcx,1)
add    $0x8,%rdx
cmp    %rdx,%rax
jne    1210 <unicodeToString+0x100>
mov    %rsi,%rbx
mov    %r14d,%edx
sub    %eax,%edx
mov    %rax,%rdi
not    %rdi
add    %r14,%rdi
and    $0x3,%rdx
je     1267 <unicodeToString+0x157>
lea    0x2df3(%rip),%rsi
nopl   (%rax)
movzbl (%rbx),%ecx
and    $0x7f,%cl
mov    %cl,(%rax,%rsi,1)
add    $0x2,%rbx
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1250 <unicodeToString+0x140>
cmp    $0x3,%rdi
jb     12c7 <unicodeToString+0x1b7>
mov    %r14,%rsi
sub    %rax,%rsi
lea    0x2dc6(%rip),%rdx
add    %rdx,%rax
add    $0x3,%rax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzbl (%rbx,%rdx,2),%ecx
and    $0x7f,%cl
mov    %cl,-0x3(%rax,%rdx,1)
movzbl 0x2(%rbx,%rdx,2),%ecx
and    $0x7f,%cl
mov    %cl,-0x2(%rax,%rdx,1)
movzbl 0x4(%rbx,%rdx,2),%ecx
and    $0x7f,%cl
mov    %cl,-0x1(%rax,%rdx,1)
movzbl 0x6(%rbx,%rdx,2),%ecx
and    $0x7f,%cl
mov    %cl,(%rax,%rdx,1)
add    $0x4,%rdx
cmp    %rdx,%rsi
jne    1290 <unicodeToString+0x180>
mov    %r14d,%ecx
lea    0x2d6f(%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 = sext i32 %12 to i64
%14 = load i64, i64* %4
%15 = icmp ult i64 %13, %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 = icmp eq i64 %1, 0
br i1 %7, label %110, label %8
8: ; preds = %2
%9 = icmp ult i64 %1, 9
br i1 %9, label %61, label %10
10: ; preds = %8
%11 = getelementptr [1024 x i8], [1024 x i8]* @unicodeToString.buf, i64 0, i64 %1
%12 = shl i64 %1, 1
%13 = add i64 %12, -1
%14 = getelementptr i8, i8* %0, i64 %13
%15 = icmp ugt i8* %14, getelementptr inbounds ([1024 x i8], [1024 x i8]* @unicodeToString.buf, i64 0, i64 0)
%16 = icmp ugt i8* %11, %0
%17 = and i1 %15, %16
br i1 %17, label %61, label %18
18: ; preds = %10
%19 = icmp ult i64 %1, 17
br i1 %19, label %41, label %20
20: ; preds = %18
%21 = and i64 %1, 15
%22 = icmp eq i64 %21, 0
%23 = select i1 %22, i64 16, i64 %21
%24 = sub i64 %1, %23
br label %25
25: ; preds = %25, %20
%26 = phi i64 [ 0, %20 ], [ %35, %25 ]
%27 = shl i64 %26, 1
%28 = getelementptr i8, i8* %0, i64 %27
%29 = bitcast i8* %28 to <32 x i8>*
%30 = load <32 x i8>, <32 x i8>* %29
%31 = shufflevector <32 x i8> %30, <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>
%32 = and <16 x i8> %31, <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>
%33 = getelementptr inbounds [1024 x i8], [1024 x i8]* @unicodeToString.buf, i64 0, i64 %26
%34 = bitcast i8* %33 to <16 x i8>*
store <16 x i8> %32, <16 x i8>* %34
%35 = add nuw i64 %26, 16
%36 = icmp eq i64 %35, %24
br i1 %36, label %37, label %25
37: ; preds = %25
%38 = shl i64 %24, 1
%39 = getelementptr i8, i8* %0, i64 %38
%40 = icmp ult i64 %23, 9
br i1 %40, label %61, label %41
41: ; preds = %18, %37
%42 = phi i64 [ %24, %37 ], [ 0, %18 ]
%43 = and i64 %1, 7
%44 = icmp eq i64 %43, 0
%45 = select i1 %44, i64 8, i64 %43
%46 = sub i64 %1, %45
%47 = shl i64 %46, 1
%48 = getelementptr i8, i8* %0, i64 %47
br label %49
49: ; preds = %49, %41
%50 = phi i64 [ %42, %41 ], [ %59, %49 ]
%51 = shl i64 %50, 1
%52 = getelementptr i8, i8* %0, i64 %51
%53 = bitcast i8* %52 to <16 x i8>*
%54 = load <16 x i8>, <16 x i8>* %53
%55 = shufflevector <16 x i8> %54, <16 x i8> poison, <8 x i32> <i32 0, i32 2, i32 4, i32 6, i32 8, i32 10, i32 12, i32 14>
%56 = and <8 x i8> %55, <i8 127, i8 127, i8 127, i8 127, i8 127, i8 127, i8 127, i8 127>
%57 = getelementptr inbounds [1024 x i8], [1024 x i8]* @unicodeToString.buf, i64 0, i64 %50
%58 = bitcast i8* %57 to <8 x i8>*
store <8 x i8> %56, <8 x i8>* %58
%59 = add nuw i64 %50, 8
%60 = icmp eq i64 %59, %46
br i1 %60, label %61, label %49
61: ; preds = %49, %10, %8, %37
%62 = phi i64 [ 0, %8 ], [ 0, %10 ], [ %24, %37 ], [ %46, %49 ]
%63 = phi i8* [ %0, %8 ], [ %0, %10 ], [ %39, %37 ], [ %48, %49 ]
%64 = sub i64 %1, %62
%65 = xor i64 %62, -1
%66 = add i64 %65, %1
%67 = and i64 %64, 3
%68 = icmp eq i64 %67, 0
br i1 %68, label %80, label %69
69: ; preds = %61, %69
%70 = phi i64 [ %77, %69 ], [ %62, %61 ]
%71 = phi i8* [ %76, %69 ], [ %63, %61 ]
%72 = phi i64 [ %78, %69 ], [ 0, %61 ]
%73 = load i8, i8* %71
%74 = and i8 %73, 127
%75 = getelementptr inbounds [1024 x i8], [1024 x i8]* @unicodeToString.buf, i64 0, i64 %70
store i8 %74, i8* %75
%76 = getelementptr inbounds i8, i8* %71, i64 2
%77 = add nuw nsw i64 %70, 1
%78 = add i64 %72, 1
%79 = icmp eq i64 %78, %67
br i1 %79, label %80, label %69
80: ; preds = %69, %61
%81 = phi i64 [ %62, %61 ], [ %77, %69 ]
%82 = phi i8* [ %63, %61 ], [ %76, %69 ]
%83 = icmp ult i64 %66, 3
br i1 %83, label %108, label %84
84: ; preds = %80, %84
%85 = phi i64 [ %106, %84 ], [ %81, %80 ]
%86 = phi i8* [ %105, %84 ], [ %82, %80 ]
%87 = load i8, i8* %86
%88 = and i8 %87, 127
%89 = getelementptr inbounds [1024 x i8], [1024 x i8]* @unicodeToString.buf, i64 0, i64 %85
store i8 %88, i8* %89
%90 = getelementptr inbounds i8, i8* %86, i64 2
%91 = add nuw nsw i64 %85, 1
%92 = load i8, i8* %90
%93 = and i8 %92, 127
%94 = getelementptr inbounds [1024 x i8], [1024 x i8]* @unicodeToString.buf, i64 0, i64 %91
store i8 %93, i8* %94
%95 = getelementptr inbounds i8, i8* %86, i64 4
%96 = add nuw nsw i64 %85, 2
%97 = load i8, i8* %95
%98 = and i8 %97, 127
%99 = getelementptr inbounds [1024 x i8], [1024 x i8]* @unicodeToString.buf, i64 0, i64 %96
store i8 %98, i8* %99
%100 = getelementptr inbounds i8, i8* %86, i64 6
%101 = add nuw nsw i64 %85, 3
%102 = load i8, i8* %100
%103 = and i8 %102, 127
%104 = getelementptr inbounds [1024 x i8], [1024 x i8]* @unicodeToString.buf, i64 0, i64 %101
store i8 %103, i8* %104
%105 = getelementptr inbounds i8, i8* %86, i64 8
%106 = add nuw nsw i64 %85, 4
%107 = icmp eq i64 %106, %1
br i1 %107, label %108, label %84
108: ; preds = %84, %80
%109 = and i64 %1, 4294967295
br label %110
110: ; preds = %108, %2
%111 = phi i64 [ 0, %2 ], [ %109, %108 ]
%112 = getelementptr inbounds [1024 x i8], [1024 x i8]* @unicodeToString.buf, i64 0, i64 %111
store i8 0, i8* %112
ret i8* getelementptr inbounds ([1024 x i8], [1024 x i8]* @unicodeToString.buf, i64 0, i64 0)
}