#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 escape(const char *name, size_t name_len, char *buf, size_t buf_len) {
  unsigned int i, j = 0;
  buf[0] = '\'';
  for (i = 1; j < name_len && i + 2 < buf_len; j++) {
    switch (name[j]) {
    case '\'':
      if (i + 5 < buf_len)
        return -1;
      buf[i++] = '\'';
      buf[i++] = '"';
      buf[i++] = '\'';
      buf[i++] = '"';
      buf[i++] = '\'';
      break;
    default:
      buf[i++] = name[j];
    }
  }
  buf[i] = '\'';
  buf[++i] = '\0';
  return i;
}


x86 assembly (clang, -O0):
<escape>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x20(%rbp),%rax
movb   $0x27,(%rax)
movl   $0x1,-0x2c(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,%ecx
xor    %eax,%eax
cmp    -0x18(%rbp),%rcx
mov    %al,-0x31(%rbp)
jae    114f <escape+0x4f>
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,%eax
cmp    -0x28(%rbp),%rax
setb   %al
mov    %al,-0x31(%rbp)
mov    -0x31(%rbp),%al
test   $0x1,%al
jne    115f <escape+0x5f>
jmp    1233 <escape+0x133>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
mov    (%rax,%rcx,1),%al
sub    $0x27,%al
jne    1202 <escape+0x102>
jmp    1176 <escape+0x76>
mov    -0x2c(%rbp),%eax
add    $0x5,%eax
mov    %eax,%eax
cmp    -0x28(%rbp),%rax
jae    1194 <escape+0x94>
movl   $0xffffffff,-0x4(%rbp)
jmp    1257 <escape+0x157>
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x2c(%rbp)
mov    %ecx,%ecx
movb   $0x27,(%rax,%rcx,1)
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x2c(%rbp)
mov    %ecx,%ecx
movb   $0x22,(%rax,%rcx,1)
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x2c(%rbp)
mov    %ecx,%ecx
movb   $0x27,(%rax,%rcx,1)
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x2c(%rbp)
mov    %ecx,%ecx
movb   $0x22,(%rax,%rcx,1)
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x2c(%rbp)
mov    %ecx,%ecx
movb   $0x27,(%rax,%rcx,1)
jmp    1220 <escape+0x120>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
mov    (%rax,%rcx,1),%dl
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x2c(%rbp)
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
jmp    1225 <escape+0x125>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1129 <escape+0x29>
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
movb   $0x27,(%rax,%rcx,1)
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x2c(%rbp)
mov    %ecx,%ecx
movb   $0x0,(%rax,%rcx,1)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<escape>:
movb   $0x27,(%rdx)
mov    $0x1,%eax
test   %rsi,%rsi
je     1188 <escape+0x88>
cmp    $0x4,%rcx
jb     1188 <escape+0x88>
mov    $0x1,%eax
mov    $0x3,%r9d
xor    %r8d,%r8d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl (%rdi,%r8,1),%r10d
cmp    $0x27,%r10b
jne    1169 <escape+0x69>
lea    0x5(%rax),%r10d
cmp    %rcx,%r10
jb     1196 <escape+0x96>
lea    0x1(%rax),%r10d
mov    %eax,%r11d
movb   $0x27,(%rdx,%r11,1)
movb   $0x22,(%rdx,%r10,1)
lea    0x3(%rax),%r10d
movb   $0x27,(%rdx,%r9,1)
add    $0x4,%eax
movb   $0x22,(%rdx,%r10,1)
mov    $0x27,%r10b
mov    %eax,%r9d
mov    %eax,%eax
mov    %r10b,(%rdx,%rax,1)
lea    0x1(%r9),%eax
add    $0x1,%r8d
cmp    %rsi,%r8
jae    1188 <escape+0x88>
add    $0x3,%r9d
cmp    %rcx,%r9
jb     1130 <escape+0x30>
mov    %eax,%ecx
movb   $0x27,(%rdx,%rcx,1)
add    $0x1,%eax
movb   $0x0,(%rdx,%rax,1)
ret
mov    $0xffffffff,%eax
ret

LLVM IR (-O0):
define i32 @escape(i8* %0, i64 %1, i8* %2, i64 %3) {
%5 = alloca i32
%6 = alloca i8*
%7 = alloca i64
%8 = alloca i8*
%9 = alloca i64
%10 = alloca i32
%11 = alloca i32
store i8* %0, i8** %6
store i64 %1, i64* %7
store i8* %2, i8** %8
store i64 %3, i64* %9
store i32 0, i32* %11
%12 = load i8*, i8** %8
%13 = getelementptr inbounds i8, i8* %12, i64 0
store i8 39, i8* %13
store i32 1, i32* %10
br label %14
14: ; preds = %79, %4
%15 = load i32, i32* %11
%16 = zext i32 %15 to i64
%17 = load i64, i64* %7
%18 = icmp ult i64 %16, %17
br i1 %18, label %19, label %25
19: ; preds = %14
%20 = load i32, i32* %10
%21 = add i32 %20, 2
%22 = zext i32 %21 to i64
%23 = load i64, i64* %9
%24 = icmp ult i64 %22, %23
br label %25
25: ; preds = %19, %14
%26 = phi i1 [ false, %14 ], [ %24, %19 ]
br i1 %26, label %27, label %82
27: ; preds = %25
%28 = load i8*, i8** %6
%29 = load i32, i32* %11
%30 = zext i32 %29 to i64
%31 = getelementptr inbounds i8, i8* %28, i64 %30
%32 = load i8, i8* %31
%33 = sext i8 %32 to i32
switch i32 %33, label %67 [
i32 39, label %34
]
34: ; preds = %27
%35 = load i32, i32* %10
%36 = add i32 %35, 5
%37 = zext i32 %36 to i64
%38 = load i64, i64* %9
%39 = icmp ult i64 %37, %38
br i1 %39, label %40, label %41
40: ; preds = %34
store i32 -1, i32* %5
br label %93
41: ; preds = %34
%42 = load i8*, i8** %8
%43 = load i32, i32* %10
%44 = add i32 %43, 1
store i32 %44, i32* %10
%45 = zext i32 %43 to i64
%46 = getelementptr inbounds i8, i8* %42, i64 %45
store i8 39, i8* %46
%47 = load i8*, i8** %8
%48 = load i32, i32* %10
%49 = add i32 %48, 1
store i32 %49, i32* %10
%50 = zext i32 %48 to i64
%51 = getelementptr inbounds i8, i8* %47, i64 %50
store i8 34, i8* %51
%52 = load i8*, i8** %8
%53 = load i32, i32* %10
%54 = add i32 %53, 1
store i32 %54, i32* %10
%55 = zext i32 %53 to i64
%56 = getelementptr inbounds i8, i8* %52, i64 %55
store i8 39, i8* %56
%57 = load i8*, i8** %8
%58 = load i32, i32* %10
%59 = add i32 %58, 1
store i32 %59, i32* %10
%60 = zext i32 %58 to i64
%61 = getelementptr inbounds i8, i8* %57, i64 %60
store i8 34, i8* %61
%62 = load i8*, i8** %8
%63 = load i32, i32* %10
%64 = add i32 %63, 1
store i32 %64, i32* %10
%65 = zext i32 %63 to i64
%66 = getelementptr inbounds i8, i8* %62, i64 %65
store i8 39, i8* %66
br label %78
67: ; preds = %27
%68 = load i8*, i8** %6
%69 = load i32, i32* %11
%70 = zext i32 %69 to i64
%71 = getelementptr inbounds i8, i8* %68, i64 %70
%72 = load i8, i8* %71
%73 = load i8*, i8** %8
%74 = load i32, i32* %10
%75 = add i32 %74, 1
store i32 %75, i32* %10
%76 = zext i32 %74 to i64
%77 = getelementptr inbounds i8, i8* %73, i64 %76
store i8 %72, i8* %77
br label %78
78: ; preds = %67, %41
br label %79
79: ; preds = %78
%80 = load i32, i32* %11
%81 = add i32 %80, 1
store i32 %81, i32* %11
br label %14
82: ; preds = %25
%83 = load i8*, i8** %8
%84 = load i32, i32* %10
%85 = zext i32 %84 to i64
%86 = getelementptr inbounds i8, i8* %83, i64 %85
store i8 39, i8* %86
%87 = load i8*, i8** %8
%88 = load i32, i32* %10
%89 = add i32 %88, 1
store i32 %89, i32* %10
%90 = zext i32 %89 to i64
%91 = getelementptr inbounds i8, i8* %87, i64 %90
store i8 0, i8* %91
%92 = load i32, i32* %10
store i32 %92, i32* %5
br label %93
93: ; preds = %82, %40
%94 = load i32, i32* %5
ret i32 %94
}

LLVM IR (-O2):
define i32 @escape(i8* nocapture %0, i64 %1, i8* nocapture writeonly %2, i64 %3) {
store i8 39, i8* %2
%5 = icmp ne i64 %1, 0
%6 = icmp ugt i64 %3, 3
%7 = and i1 %5, %6
br i1 %7, label %8, label %43
8: ; preds = %4, %30
%9 = phi i64 [ %40, %30 ], [ 3, %4 ]
%10 = phi i64 [ %37, %30 ], [ 0, %4 ]
%11 = phi i32 [ %35, %30 ], [ 1, %4 ]
%12 = getelementptr inbounds i8, i8* %0, i64 %10
%13 = load i8, i8* %12
%14 = icmp eq i8 %13, 39
br i1 %14, label %15, label %30
15: ; preds = %8
%16 = add i32 %11, 5
%17 = zext i32 %16 to i64
%18 = icmp ult i64 %17, %3
br i1 %18, label %50, label %19
19: ; preds = %15
%20 = add i32 %11, 1
%21 = zext i32 %11 to i64
%22 = getelementptr inbounds i8, i8* %2, i64 %21
store i8 39, i8* %22
%23 = zext i32 %20 to i64
%24 = getelementptr inbounds i8, i8* %2, i64 %23
store i8 34, i8* %24
%25 = add i32 %11, 3
%26 = getelementptr inbounds i8, i8* %2, i64 %9
store i8 39, i8* %26
%27 = add i32 %11, 4
%28 = zext i32 %25 to i64
%29 = getelementptr inbounds i8, i8* %2, i64 %28
store i8 34, i8* %29
br label %30
30: ; preds = %8, %19
%31 = phi i32 [ %27, %19 ], [ %11, %8 ]
%32 = phi i8 [ 39, %19 ], [ %13, %8 ]
%33 = zext i32 %31 to i64
%34 = getelementptr inbounds i8, i8* %2, i64 %33
store i8 %32, i8* %34
%35 = add i32 %31, 1
%36 = add nuw nsw i64 %10, 1
%37 = and i64 %36, 4294967295
%38 = icmp ult i64 %37, %1
%39 = add i32 %31, 3
%40 = zext i32 %39 to i64
%41 = icmp ult i64 %40, %3
%42 = select i1 %38, i1 %41, i1 false
br i1 %42, label %8, label %43
43: ; preds = %30, %4
%44 = phi i32 [ 1, %4 ], [ %35, %30 ]
%45 = zext i32 %44 to i64
%46 = getelementptr inbounds i8, i8* %2, i64 %45
store i8 39, i8* %46
%47 = add i32 %44, 1
%48 = zext i32 %47 to i64
%49 = getelementptr inbounds i8, i8* %2, i64 %48
store i8 0, i8* %49
br label %50
50: ; preds = %15, %43
%51 = phi i32 [ %47, %43 ], [ -1, %15 ]
ret i32 %51
}