#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 */
scalar_t__ safe_malloc(int);
int strlen(char *);
char *get_unquoted_string(char *s) {
  int i = 0, j = strlen(s) - 1;
  char *str = (char *)safe_malloc(sizeof(char) * j);
  for (i = 0; i < j - 1; i++)
    str[i] = s[i + 1];
  str[j - 1] = '\0';
  return str;
}


x86 assembly (clang, -O0):
<get_unquoted_string>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
movl   $0x0,-0xc(%rbp)
mov    -0x8(%rbp),%rdi
call   1040 <strlen@plt>
sub    $0x1,%eax
mov    %eax,-0x10(%rbp)
movslq -0x10(%rbp),%rax
shl    $0x0,%rax
mov    %eax,%edi
call   1030 <safe_malloc@plt>
mov    %rax,-0x18(%rbp)
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1196 <get_unquoted_string+0x76>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x18(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    115c <get_unquoted_string+0x3c>
mov    -0x18(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x18(%rbp),%rax
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<get_unquoted_string>:
push   %r14
push   %rbx
push   %rax
mov    %rdi,%rbx
call   1040 <strlen@plt>
mov    %eax,%r14d
lea    -0x1(%r14),%edi
call   1030 <safe_malloc@plt>
lea    -0x2(%r14),%r8d
cmp    $0x3,%r14d
jl     11ef <get_unquoted_string+0xcf>
mov    %r8d,%r9d
cmp    $0x8,%r8d
jb     1173 <get_unquoted_string+0x53>
lea    (%r9,%rbx,1),%rcx
add    $0x1,%rcx
cmp    %rax,%rcx
jbe    11fe <get_unquoted_string+0xde>
mov    %rax,%rcx
add    %r9,%rcx
lea    0x1(%rbx),%rdx
cmp    %rcx,%rdx
jae    11fe <get_unquoted_string+0xde>
xor    %esi,%esi
mov    %rsi,%r10
not    %r10
add    %r9,%r10
mov    %r9,%rdi
and    $0x3,%rdi
je     11ad <get_unquoted_string+0x8d>
nopw   0x0(%rax,%rax,1)
lea    0x1(%rsi),%rcx
movzbl 0x1(%rbx,%rsi,1),%edx
mov    %dl,(%rax,%rsi,1)
mov    %rcx,%rsi
add    $0xffffffffffffffff,%rdi
jne    1190 <get_unquoted_string+0x70>
cmp    $0x3,%r10
jb     11ef <get_unquoted_string+0xcf>
jmp    11c0 <get_unquoted_string+0xa0>
mov    %rsi,%rcx
cmp    $0x3,%r10
jb     11ef <get_unquoted_string+0xcf>
cs nopw 0x0(%rax,%rax,1)
movzbl 0x1(%rbx,%rcx,1),%edx
mov    %dl,(%rax,%rcx,1)
movzbl 0x2(%rbx,%rcx,1),%edx
mov    %dl,0x1(%rax,%rcx,1)
movzbl 0x3(%rbx,%rcx,1),%edx
mov    %dl,0x2(%rax,%rcx,1)
movzbl 0x4(%rbx,%rcx,1),%edx
mov    %dl,0x3(%rax,%rcx,1)
lea    0x4(%rcx),%rdx
mov    %rdx,%rcx
cmp    %rdx,%r9
jne    11c0 <get_unquoted_string+0xa0>
movslq %r8d,%rcx
movb   $0x0,(%rax,%rcx,1)
add    $0x8,%rsp
pop    %rbx
pop    %r14
ret
cmp    $0x20,%r8d
jae    120b <get_unquoted_string+0xeb>
xor    %esi,%esi
jmp    12d6 <get_unquoted_string+0x1b6>
mov    %r9d,%esi
and    $0xffffffe0,%esi
lea    -0x20(%rsi),%rcx
mov    %rcx,%rdi
shr    $0x5,%rdi
add    $0x1,%rdi
mov    %edi,%edx
and    $0x3,%edx
cmp    $0x60,%rcx
jae    122f <get_unquoted_string+0x10f>
xor    %ecx,%ecx
jmp    1299 <get_unquoted_string+0x179>
and    $0xfffffffffffffffc,%rdi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
movups 0x1(%rbx,%rcx,1),%xmm0
movups 0x11(%rbx,%rcx,1),%xmm1
movups %xmm0,(%rax,%rcx,1)
movups %xmm1,0x10(%rax,%rcx,1)
movups 0x21(%rbx,%rcx,1),%xmm0
movups 0x31(%rbx,%rcx,1),%xmm1
movups %xmm0,0x20(%rax,%rcx,1)
movups %xmm1,0x30(%rax,%rcx,1)
movups 0x41(%rbx,%rcx,1),%xmm0
movups 0x51(%rbx,%rcx,1),%xmm1
movups %xmm0,0x40(%rax,%rcx,1)
movups %xmm1,0x50(%rax,%rcx,1)
movups 0x61(%rbx,%rcx,1),%xmm0
movups 0x71(%rbx,%rcx,1),%xmm1
movups %xmm0,0x60(%rax,%rcx,1)
movups %xmm1,0x70(%rax,%rcx,1)
sub    $0xffffffffffffff80,%rcx
add    $0xfffffffffffffffc,%rdi
jne    1240 <get_unquoted_string+0x120>
test   %rdx,%rdx
je     12c3 <get_unquoted_string+0x1a3>
xchg   %ax,%ax
mov    %rcx,%rdi
or     $0x1,%rdi
movups (%rbx,%rdi,1),%xmm0
movups 0x10(%rbx,%rdi,1),%xmm1
movups %xmm0,(%rax,%rcx,1)
movups %xmm1,0x10(%rax,%rcx,1)
add    $0x20,%rcx
add    $0xffffffffffffffff,%rdx
jne    12a0 <get_unquoted_string+0x180>
cmp    %r9,%rsi
je     11ef <get_unquoted_string+0xcf>
test   $0x18,%r9b
je     1175 <get_unquoted_string+0x55>
mov    %rsi,%rcx
mov    %r9d,%esi
and    $0xfffffff8,%esi
nop
mov    0x1(%rbx,%rcx,1),%rdx
mov    %rdx,(%rax,%rcx,1)
add    $0x8,%rcx
cmp    %rcx,%rsi
jne    12e0 <get_unquoted_string+0x1c0>
cmp    %r9,%rsi
je     11ef <get_unquoted_string+0xcf>
jmp    1175 <get_unquoted_string+0x55>

LLVM IR (-O0):
define i8* @get_unquoted_string(i8* %0) {
%2 = alloca i8*
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8*
store i8* %0, i8** %2
store i32 0, i32* %3
%6 = load i8*, i8** %2
%7 = call i32 @strlen(i8* %6)
%8 = sub nsw i32 %7, 1
store i32 %8, i32* %4
%9 = load i32, i32* %4
%10 = sext i32 %9 to i64
%11 = mul i64 1, %10
%12 = trunc i64 %11 to i32
%13 = call i64 @safe_malloc(i32 %12)
%14 = inttoptr i64 %13 to i8*
store i8* %14, i8** %5
store i32 0, i32* %3
br label %15
15: ; preds = %31, %1
%16 = load i32, i32* %3
%17 = load i32, i32* %4
%18 = sub nsw i32 %17, 1
%19 = icmp slt i32 %16, %18
br i1 %19, label %20, label %34
20: ; preds = %15
%21 = load i8*, i8** %2
%22 = load i32, i32* %3
%23 = add nsw i32 %22, 1
%24 = sext i32 %23 to i64
%25 = getelementptr inbounds i8, i8* %21, i64 %24
%26 = load i8, i8* %25
%27 = load i8*, i8** %5
%28 = load i32, i32* %3
%29 = sext i32 %28 to i64
%30 = getelementptr inbounds i8, i8* %27, i64 %29
store i8 %26, i8* %30
br label %31
31: ; preds = %20
%32 = load i32, i32* %3
%33 = add nsw i32 %32, 1
store i32 %33, i32* %3
br label %15
34: ; preds = %15
%35 = load i8*, i8** %5
%36 = load i32, i32* %4
%37 = sub nsw i32 %36, 1
%38 = sext i32 %37 to i64
%39 = getelementptr inbounds i8, i8* %35, i64 %38
store i8 0, i8* %39
%40 = load i8*, i8** %5
ret i8* %40
}

LLVM IR (-O2):
define i8* @get_unquoted_string(i8* %0) {
%2 = tail call i32 @strlen(i8* %0)
%3 = add nsw i32 %2, -1
%4 = tail call i64 @safe_malloc(i32 %3)
%5 = inttoptr i64 %4 to i8*
%6 = add i32 %2, -2
%7 = icmp sgt i32 %2, 2
br i1 %7, label %8, label %160
8: ; preds = %1
%9 = zext i32 %6 to i64
%10 = icmp ult i32 %6, 8
br i1 %10, label %123, label %11
11: ; preds = %8
%12 = getelementptr i8, i8* %5, i64 %9
%13 = getelementptr i8, i8* %0, i64 1
%14 = add nuw nsw i64 %9, 1
%15 = getelementptr i8, i8* %0, i64 %14
%16 = icmp ugt i8* %15, %5
%17 = icmp ult i8* %13, %12
%18 = and i1 %16, %17
br i1 %18, label %123, label %19
19: ; preds = %11
%20 = icmp ult i32 %6, 32
br i1 %20, label %108, label %21
21: ; preds = %19
%22 = and i64 %9, 4294967264
%23 = add nsw i64 %22, -32
%24 = lshr exact i64 %23, 5
%25 = add nuw nsw i64 %24, 1
%26 = and i64 %25, 3
%27 = icmp ult i64 %23, 96
br i1 %27, label %83, label %28
28: ; preds = %21
%29 = and i64 %25, 1152921504606846972
br label %30
30: ; preds = %30, %28
%31 = phi i64 [ 0, %28 ], [ %80, %30 ]
%32 = phi i64 [ 0, %28 ], [ %81, %30 ]
%33 = or i64 %31, 1
%34 = getelementptr inbounds i8, i8* %0, i64 %33
%35 = bitcast i8* %34 to <16 x i8>*
%36 = load <16 x i8>, <16 x i8>* %35
%37 = getelementptr inbounds i8, i8* %34, i64 16
%38 = bitcast i8* %37 to <16 x i8>*
%39 = load <16 x i8>, <16 x i8>* %38
%40 = getelementptr inbounds i8, i8* %5, i64 %31
%41 = bitcast i8* %40 to <16 x i8>*
store <16 x i8> %36, <16 x i8>* %41
%42 = getelementptr inbounds i8, i8* %40, i64 16
%43 = bitcast i8* %42 to <16 x i8>*
store <16 x i8> %39, <16 x i8>* %43
%44 = or i64 %31, 32
%45 = or i64 %31, 33
%46 = getelementptr inbounds i8, i8* %0, i64 %45
%47 = bitcast i8* %46 to <16 x i8>*
%48 = load <16 x i8>, <16 x i8>* %47
%49 = getelementptr inbounds i8, i8* %46, i64 16
%50 = bitcast i8* %49 to <16 x i8>*
%51 = load <16 x i8>, <16 x i8>* %50
%52 = getelementptr inbounds i8, i8* %5, i64 %44
%53 = bitcast i8* %52 to <16 x i8>*
store <16 x i8> %48, <16 x i8>* %53
%54 = getelementptr inbounds i8, i8* %52, i64 16
%55 = bitcast i8* %54 to <16 x i8>*
store <16 x i8> %51, <16 x i8>* %55
%56 = or i64 %31, 64
%57 = or i64 %31, 65
%58 = getelementptr inbounds i8, i8* %0, i64 %57
%59 = bitcast i8* %58 to <16 x i8>*
%60 = load <16 x i8>, <16 x i8>* %59
%61 = getelementptr inbounds i8, i8* %58, i64 16
%62 = bitcast i8* %61 to <16 x i8>*
%63 = load <16 x i8>, <16 x i8>* %62
%64 = getelementptr inbounds i8, i8* %5, i64 %56
%65 = bitcast i8* %64 to <16 x i8>*
store <16 x i8> %60, <16 x i8>* %65
%66 = getelementptr inbounds i8, i8* %64, i64 16
%67 = bitcast i8* %66 to <16 x i8>*
store <16 x i8> %63, <16 x i8>* %67
%68 = or i64 %31, 96
%69 = or i64 %31, 97
%70 = getelementptr inbounds i8, i8* %0, i64 %69
%71 = bitcast i8* %70 to <16 x i8>*
%72 = load <16 x i8>, <16 x i8>* %71
%73 = getelementptr inbounds i8, i8* %70, i64 16
%74 = bitcast i8* %73 to <16 x i8>*
%75 = load <16 x i8>, <16 x i8>* %74
%76 = getelementptr inbounds i8, i8* %5, i64 %68
%77 = bitcast i8* %76 to <16 x i8>*
store <16 x i8> %72, <16 x i8>* %77
%78 = getelementptr inbounds i8, i8* %76, i64 16
%79 = bitcast i8* %78 to <16 x i8>*
store <16 x i8> %75, <16 x i8>* %79
%80 = add nuw i64 %31, 128
%81 = add i64 %32, 4
%82 = icmp eq i64 %81, %29
br i1 %82, label %83, label %30
83: ; preds = %30, %21
%84 = phi i64 [ 0, %21 ], [ %80, %30 ]
%85 = icmp eq i64 %26, 0
br i1 %85, label %103, label %86
86: ; preds = %83, %86
%87 = phi i64 [ %100, %86 ], [ %84, %83 ]
%88 = phi i64 [ %101, %86 ], [ 0, %83 ]
%89 = or i64 %87, 1
%90 = getelementptr inbounds i8, i8* %0, i64 %89
%91 = bitcast i8* %90 to <16 x i8>*
%92 = load <16 x i8>, <16 x i8>* %91
%93 = getelementptr inbounds i8, i8* %90, i64 16
%94 = bitcast i8* %93 to <16 x i8>*
%95 = load <16 x i8>, <16 x i8>* %94
%96 = getelementptr inbounds i8, i8* %5, i64 %87
%97 = bitcast i8* %96 to <16 x i8>*
store <16 x i8> %92, <16 x i8>* %97
%98 = getelementptr inbounds i8, i8* %96, i64 16
%99 = bitcast i8* %98 to <16 x i8>*
store <16 x i8> %95, <16 x i8>* %99
%100 = add nuw i64 %87, 32
%101 = add i64 %88, 1
%102 = icmp eq i64 %101, %26
br i1 %102, label %103, label %86
103: ; preds = %86, %83
%104 = icmp eq i64 %22, %9
br i1 %104, label %160, label %105
105: ; preds = %103
%106 = and i64 %9, 24
%107 = icmp eq i64 %106, 0
br i1 %107, label %123, label %108
108: ; preds = %19, %105
%109 = phi i64 [ %22, %105 ], [ 0, %19 ]
%110 = and i64 %9, 4294967288
br label %111
111: ; preds = %111, %108
%112 = phi i64 [ %109, %108 ], [ %119, %111 ]
%113 = or i64 %112, 1
%114 = getelementptr inbounds i8, i8* %0, i64 %113
%115 = bitcast i8* %114 to <8 x i8>*
%116 = load <8 x i8>, <8 x i8>* %115
%117 = getelementptr inbounds i8, i8* %5, i64 %112
%118 = bitcast i8* %117 to <8 x i8>*
store <8 x i8> %116, <8 x i8>* %118
%119 = add nuw i64 %112, 8
%120 = icmp eq i64 %119, %110
br i1 %120, label %121, label %111
121: ; preds = %111
%122 = icmp eq i64 %110, %9
br i1 %122, label %160, label %123
123: ; preds = %11, %8, %105, %121
%124 = phi i64 [ 0, %8 ], [ 0, %11 ], [ %22, %105 ], [ %110, %121 ]
%125 = xor i64 %124, -1
%126 = add nsw i64 %125, %9
%127 = and i64 %9, 3
%128 = icmp eq i64 %127, 0
br i1 %128, label %138, label %129
129: ; preds = %123, %129
%130 = phi i64 [ %132, %129 ], [ %124, %123 ]
%131 = phi i64 [ %136, %129 ], [ 0, %123 ]
%132 = add nuw nsw i64 %130, 1
%133 = getelementptr inbounds i8, i8* %0, i64 %132
%134 = load i8, i8* %133
%135 = getelementptr inbounds i8, i8* %5, i64 %130
store i8 %134, i8* %135
%136 = add i64 %131, 1
%137 = icmp eq i64 %136, %127
br i1 %137, label %138, label %129
138: ; preds = %129, %123
%139 = phi i64 [ %124, %123 ], [ %132, %129 ]
%140 = icmp ult i64 %126, 3
br i1 %140, label %160, label %141
141: ; preds = %138, %141
%142 = phi i64 [ %155, %141 ], [ %139, %138 ]
%143 = add nuw nsw i64 %142, 1
%144 = getelementptr inbounds i8, i8* %0, i64 %143
%145 = load i8, i8* %144
%146 = getelementptr inbounds i8, i8* %5, i64 %142
store i8 %145, i8* %146
%147 = add nuw nsw i64 %142, 2
%148 = getelementptr inbounds i8, i8* %0, i64 %147
%149 = load i8, i8* %148
%150 = getelementptr inbounds i8, i8* %5, i64 %143
store i8 %149, i8* %150
%151 = add nuw nsw i64 %142, 3
%152 = getelementptr inbounds i8, i8* %0, i64 %151
%153 = load i8, i8* %152
%154 = getelementptr inbounds i8, i8* %5, i64 %147
store i8 %153, i8* %154
%155 = add nuw nsw i64 %142, 4
%156 = getelementptr inbounds i8, i8* %0, i64 %155
%157 = load i8, i8* %156
%158 = getelementptr inbounds i8, i8* %5, i64 %151
store i8 %157, i8* %158
%159 = icmp eq i64 %155, %9
br i1 %159, label %160, label %141
160: ; preds = %138, %141, %103, %121, %1
%161 = sext i32 %6 to i64
%162 = getelementptr inbounds i8, i8* %5, i64 %161
store i8 0, i8* %162
ret i8* %5
}