#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 */
char *galloc(int);
int str_length(char const *);
char *str_slicep(const char *from, const char *to) {
  char *ret = NULL;
  if (!to)
    to = from + str_length(from);
  if (from) {
    ret = galloc(to - from + 1);
    for (const char *i = from; i < to; i++)
      ret[i - from] = *i;
    ret[to - from] = 0;
  }
  return ret;
}


x86 assembly (clang, -O0):
<str_slicep>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movq   $0x0,-0x18(%rbp)
cmpq   $0x0,-0x10(%rbp)
jne    1164 <str_slicep+0x44>
mov    -0x8(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x8(%rbp),%rdi
call   1030 <str_length@plt>
mov    %eax,%ecx
mov    -0x28(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x10(%rbp)
cmpq   $0x0,-0x8(%rbp)
je     11db <str_slicep+0xbb>
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%rcx
sub    %rcx,%rax
add    $0x1,%rax
mov    %eax,%edi
call   1040 <galloc@plt>
mov    %rax,-0x18(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
cmp    -0x10(%rbp),%rax
jae    11c8 <str_slicep+0xa8>
mov    -0x20(%rbp),%rax
mov    (%rax),%dl
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    -0x8(%rbp),%rsi
sub    %rsi,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    1191 <str_slicep+0x71>
mov    -0x18(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    -0x8(%rbp),%rdx
sub    %rdx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x18(%rbp),%rax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<str_slicep>:
push   %r15
push   %r14
push   %rbx
mov    %rsi,%r14
mov    %rdi,%r15
test   %rsi,%rsi
je     1182 <str_slicep+0x62>
test   %r15,%r15
je     1195 <str_slicep+0x75>
mov    %r14,%rdi
sub    %r15,%rdi
add    $0x1,%edi
call   1040 <galloc@plt>
mov    %r14,%r9
sub    %r15,%r9
jbe    1333 <str_slicep+0x213>
lea    (%r15,%r9,1),%r10
mov    %r15,%rdi
cmp    $0x8,%r9
jb     12b1 <str_slicep+0x191>
cmp    %r10,%rax
jae    1175 <str_slicep+0x55>
lea    (%rax,%r9,1),%rcx
mov    %r15,%rdi
cmp    %r15,%rcx
ja     12b1 <str_slicep+0x191>
cmp    $0x20,%r9
jae    119c <str_slicep+0x7c>
xor    %esi,%esi
jmp    127a <str_slicep+0x15a>
mov    %r15,%rdi
call   1030 <str_length@plt>
movslq %eax,%r14
add    %r15,%r14
test   %r15,%r15
jne    1135 <str_slicep+0x15>
xor    %eax,%eax
jmp    1338 <str_slicep+0x218>
mov    %r9,%rsi
and    $0xffffffffffffffe0,%rsi
lea    -0x20(%rsi),%rcx
mov    %rcx,%rdi
shr    $0x5,%rdi
add    $0x1,%rdi
mov    %edi,%r8d
and    $0x3,%r8d
cmp    $0x60,%rcx
jae    11c3 <str_slicep+0xa3>
xor    %ecx,%ecx
jmp    1230 <str_slicep+0x110>
and    $0xfffffffffffffffc,%rdi
xor    %ecx,%ecx
nopl   0x0(%rax)
movups (%r15,%rcx,1),%xmm0
movups 0x10(%r15,%rcx,1),%xmm1
movups %xmm0,(%rax,%rcx,1)
movups %xmm1,0x10(%rax,%rcx,1)
movups 0x20(%r15,%rcx,1),%xmm0
movups 0x30(%r15,%rcx,1),%xmm1
movups %xmm0,0x20(%rax,%rcx,1)
movups %xmm1,0x30(%rax,%rcx,1)
movups 0x40(%r15,%rcx,1),%xmm0
movups 0x50(%r15,%rcx,1),%xmm1
movups %xmm0,0x40(%rax,%rcx,1)
movups %xmm1,0x50(%rax,%rcx,1)
movups 0x60(%r15,%rcx,1),%xmm0
movups 0x70(%r15,%rcx,1),%xmm1
movups %xmm0,0x60(%rax,%rcx,1)
movups %xmm1,0x70(%rax,%rcx,1)
sub    $0xffffffffffffff80,%rcx
add    $0xfffffffffffffffc,%rdi
jne    11d0 <str_slicep+0xb0>
test   %r8,%r8
je     126b <str_slicep+0x14b>
lea    (%rax,%rcx,1),%rdi
add    $0x10,%rdi
add    %r15,%rcx
add    $0x10,%rcx
shl    $0x5,%r8
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movups -0x10(%rcx,%rdx,1),%xmm0
movups (%rcx,%rdx,1),%xmm1
movups %xmm0,-0x10(%rdi,%rdx,1)
movups %xmm1,(%rdi,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%r8
jne    1250 <str_slicep+0x130>
cmp    %rsi,%r9
je     1333 <str_slicep+0x213>
test   $0x18,%r9b
je     12ab <str_slicep+0x18b>
mov    %r9,%rcx
and    $0xfffffffffffffff8,%rcx
lea    (%r15,%rcx,1),%rdi
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%r15,%rsi,1),%rdx
mov    %rdx,(%rax,%rsi,1)
add    $0x8,%rsi
cmp    %rsi,%rcx
jne    1290 <str_slicep+0x170>
cmp    %rcx,%r9
jne    12b1 <str_slicep+0x191>
jmp    1333 <str_slicep+0x213>
add    %r15,%rsi
mov    %rsi,%rdi
mov    %r14d,%esi
sub    %edi,%esi
mov    %rdi,%r8
not    %r8
add    %r14,%r8
and    $0x3,%rsi
je     12e3 <str_slicep+0x1c3>
mov    %rdi,%rdx
sub    %r15,%rdx
add    %rax,%rdx
xor    %ecx,%ecx
movzbl (%rdi,%rcx,1),%ebx
mov    %bl,(%rdx,%rcx,1)
add    $0x1,%rcx
cmp    %rcx,%rsi
jne    12d0 <str_slicep+0x1b0>
add    %rcx,%rdi
cmp    $0x3,%r8
jb     1333 <str_slicep+0x213>
mov    %rdi,%rcx
sub    %r15,%rcx
add    %rax,%rcx
add    $0x3,%rcx
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movzbl (%rdi,%rsi,1),%edx
mov    %dl,-0x3(%rcx,%rsi,1)
movzbl 0x1(%rdi,%rsi,1),%edx
mov    %dl,-0x2(%rcx,%rsi,1)
movzbl 0x2(%rdi,%rsi,1),%edx
mov    %dl,-0x1(%rcx,%rsi,1)
movzbl 0x3(%rdi,%rsi,1),%edx
mov    %dl,(%rcx,%rsi,1)
lea    (%rdi,%rsi,1),%rdx
add    $0x4,%rdx
add    $0x4,%rsi
cmp    %r10,%rdx
jne    1300 <str_slicep+0x1e0>
movb   $0x0,(%rax,%r9,1)
pop    %rbx
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
define i8* @str_slicep(i8* %0, i8* %1) {
%3 = alloca i8*
%4 = alloca i8*
%5 = alloca i8*
%6 = alloca i8*
store i8* %0, i8** %3
store i8* %1, i8** %4
store i8* null, i8** %5
%7 = load i8*, i8** %4
%8 = icmp ne i8* %7, null
br i1 %8, label %15, label %9
9: ; preds = %2
%10 = load i8*, i8** %3
%11 = load i8*, i8** %3
%12 = call i32 @str_length(i8* %11)
%13 = sext i32 %12 to i64
%14 = getelementptr inbounds i8, i8* %10, i64 %13
store i8* %14, i8** %4
br label %15
15: ; preds = %9, %2
%16 = load i8*, i8** %3
%17 = icmp ne i8* %16, null
br i1 %17, label %18, label %53
18: ; preds = %15
%19 = load i8*, i8** %4
%20 = load i8*, i8** %3
%21 = ptrtoint i8* %19 to i64
%22 = ptrtoint i8* %20 to i64
%23 = sub i64 %21, %22
%24 = add nsw i64 %23, 1
%25 = trunc i64 %24 to i32
%26 = call i8* @galloc(i32 %25)
store i8* %26, i8** %5
%27 = load i8*, i8** %3
store i8* %27, i8** %6
br label %28
28: ; preds = %42, %18
%29 = load i8*, i8** %6
%30 = load i8*, i8** %4
%31 = icmp ult i8* %29, %30
br i1 %31, label %32, label %45
32: ; preds = %28
%33 = load i8*, i8** %6
%34 = load i8, i8* %33
%35 = load i8*, i8** %5
%36 = load i8*, i8** %6
%37 = load i8*, i8** %3
%38 = ptrtoint i8* %36 to i64
%39 = ptrtoint i8* %37 to i64
%40 = sub i64 %38, %39
%41 = getelementptr inbounds i8, i8* %35, i64 %40
store i8 %34, i8* %41
br label %42
42: ; preds = %32
%43 = load i8*, i8** %6
%44 = getelementptr inbounds i8, i8* %43, i32 1
store i8* %44, i8** %6
br label %28
45: ; preds = %28
%46 = load i8*, i8** %5
%47 = load i8*, i8** %4
%48 = load i8*, i8** %3
%49 = ptrtoint i8* %47 to i64
%50 = ptrtoint i8* %48 to i64
%51 = sub i64 %49, %50
%52 = getelementptr inbounds i8, i8* %46, i64 %51
store i8 0, i8* %52
br label %53
53: ; preds = %45, %15
%54 = load i8*, i8** %5
ret i8* %54
}

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