void shftstr(string, shift) char *string;
int shift;
{
  char *ptr, *start, *end;
  start = string;
  end = string + strlen(string);
  if (shift == 0)
    return;
  if (shift > 0)
    for (ptr = end; ptr >= start; --ptr)
      *(ptr + shift) = *ptr;
  else
    for (ptr = start; ptr <= end; ++ptr)
      *(ptr + shift) = *ptr;
}


x86 assembly (clang, -O0):
<shftstr>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x8(%rbp),%rdi
call   1030 <strlen@plt>
mov    %rax,%rcx
mov    -0x30(%rbp),%rax
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
cmpl   $0x0,-0xc(%rbp)
jne    1155 <shftstr+0x45>
jmp    11d9 <shftstr+0xc9>
cmpl   $0x0,-0xc(%rbp)
jle    119c <shftstr+0x8c>
mov    -0x28(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
cmp    -0x20(%rbp),%rax
jb     1197 <shftstr+0x87>
mov    -0x18(%rbp),%rax
mov    (%rax),%dl
mov    -0x18(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x18(%rbp)
jmp    1167 <shftstr+0x57>
jmp    11d9 <shftstr+0xc9>
mov    -0x20(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
cmp    -0x28(%rbp),%rax
ja     11d4 <shftstr+0xc4>
mov    -0x18(%rbp),%rax
mov    (%rax),%dl
mov    -0x18(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    11a4 <shftstr+0x94>
jmp    11d9 <shftstr+0xc9>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<shftstr>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %esi,%ebp
mov    %rdi,%rbx
call   1030 <strlen@plt>
lea    (%rbx,%rax,1),%rcx
test   %ebp,%ebp
je     14af <shftstr+0x39f>
jle    1184 <shftstr+0x74>
test   %rax,%rax
js     14af <shftstr+0x39f>
mov    %ebp,%edx
lea    (%rbx,%rax,1),%r8
lea    (%rax,%rbx,1),%r9
add    $0xffffffffffffffff,%r9
lea    -0x1(%rbx),%r14
cmp    %r14,%r9
mov    %r14,%rsi
cmovb  %r9,%rsi
mov    %r8,%r15
sub    %rsi,%r15
cmp    $0x4,%r15
jae    11b7 <shftstr+0xa7>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl (%rcx),%eax
mov    %al,(%rcx,%rdx,1)
add    $0xffffffffffffffff,%rcx
cmp    %rbx,%rcx
jae    1170 <shftstr+0x60>
jmp    14af <shftstr+0x39f>
test   %rax,%rax
js     14af <shftstr+0x39f>
lea    (%rax,%rbx,1),%r8
add    $0x1,%r8
lea    0x1(%rbx),%r9
cmp    %r9,%r8
mov    %r9,%r11
cmova  %r8,%r11
movslq %ebp,%rax
sub    %rbx,%r11
cmp    $0x8,%r11
jae    1222 <shftstr+0x112>
mov    %rbx,%rdx
jmp    14a0 <shftstr+0x390>
xor    %esi,%esi
mov    %r9,%rdi
sub    %r14,%rdi
cmovae %rdi,%rsi
lea    (%rax,%rdx,1),%r10
lea    (%rbx,%r10,1),%rbp
mov    %rbp,%rdi
sub    %rsi,%rdi
cmp    %rbp,%rdi
ja     1170 <shftstr+0x60>
mov    %rcx,%rdi
sub    %rsi,%rdi
cmp    %rcx,%rdi
ja     1170 <shftstr+0x60>
cmp    %r14,%r9
mov    %r14,%rsi
cmovb  %r9,%rsi
lea    (%rsi,%rdx,1),%rdi
add    $0x1,%rdi
lea    (%rax,%rbx,1),%rbp
add    $0x1,%rbp
cmp    %rbp,%rdi
jae    1215 <shftstr+0x105>
lea    (%rbx,%r10,1),%rdi
add    $0x1,%rdi
add    $0x1,%rsi
cmp    %rdi,%rsi
jb     1170 <shftstr+0x60>
cmp    $0x10,%r15
jae    127c <shftstr+0x16c>
xor    %esi,%esi
jmp    1451 <shftstr+0x341>
lea    (%rbx,%rax,1),%rsi
cmp    %r9,%r8
mov    %r9,%rdx
cmova  %r8,%rdx
cmp    %rdx,%rsi
jae    1245 <shftstr+0x135>
add    %rax,%rdx
cmp    %rbx,%rdx
jbe    1245 <shftstr+0x135>
mov    %rbx,%rdx
jmp    14a0 <shftstr+0x390>
cmp    $0x20,%r11
jae    1252 <shftstr+0x142>
xor    %edi,%edi
jmp    136e <shftstr+0x25e>
mov    %r11,%rdi
and    $0xffffffffffffffe0,%rdi
lea    -0x20(%rdi),%rdx
mov    %rdx,%rbp
shr    $0x5,%rbp
add    $0x1,%rbp
mov    %ebp,%r10d
and    $0x3,%r10d
cmp    $0x60,%rdx
jae    12aa <shftstr+0x19a>
xor    %esi,%esi
jmp    1318 <shftstr+0x208>
mov    %r15,%rsi
and    $0xfffffffffffffff0,%rsi
lea    -0x10(%rsi),%rdi
mov    %rdi,%rbp
shr    $0x4,%rbp
add    $0x1,%rbp
mov    %ebp,%r11d
and    $0x3,%r11d
cmp    $0x30,%rdi
jae    13af <shftstr+0x29f>
xor    %edi,%edi
jmp    140c <shftstr+0x2fc>
and    $0xfffffffffffffffc,%rbp
lea    (%rax,%rbx,1),%rdx
add    $0x70,%rdx
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movups (%rbx,%rsi,1),%xmm0
movups 0x10(%rbx,%rsi,1),%xmm1
movups %xmm0,-0x70(%rdx,%rsi,1)
movups %xmm1,-0x60(%rdx,%rsi,1)
movups 0x20(%rbx,%rsi,1),%xmm0
movups 0x30(%rbx,%rsi,1),%xmm1
movups %xmm0,-0x50(%rdx,%rsi,1)
movups %xmm1,-0x40(%rdx,%rsi,1)
movups 0x40(%rbx,%rsi,1),%xmm0
movups 0x50(%rbx,%rsi,1),%xmm1
movups %xmm0,-0x30(%rdx,%rsi,1)
movups %xmm1,-0x20(%rdx,%rsi,1)
movups 0x60(%rbx,%rsi,1),%xmm0
movups 0x70(%rbx,%rsi,1),%xmm1
movups %xmm0,-0x10(%rdx,%rsi,1)
movups %xmm1,(%rdx,%rsi,1)
sub    $0xffffffffffffff80,%rsi
add    $0xfffffffffffffffc,%rbp
jne    12c0 <shftstr+0x1b0>
test   %r10,%r10
je     135b <shftstr+0x24b>
lea    (%rsi,%rax,1),%rdx
add    %rbx,%rdx
add    $0x10,%rdx
add    %rbx,%rsi
add    $0x10,%rsi
shl    $0x5,%r10
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
movups -0x10(%rsi,%rbp,1),%xmm0
movups (%rsi,%rbp,1),%xmm1
movups %xmm0,-0x10(%rdx,%rbp,1)
movups %xmm1,(%rdx,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%r10
jne    1340 <shftstr+0x230>
cmp    %rdi,%r11
je     14af <shftstr+0x39f>
test   $0x18,%r11b
je     149a <shftstr+0x38a>
cmp    %r9,%r8
cmova  %r8,%r9
sub    %rbx,%r9
mov    %r9,%rsi
and    $0xfffffffffffffff8,%rsi
lea    (%rbx,%rsi,1),%rdx
add    %rdi,%rbx
sub    %rsi,%rdi
nopl   0x0(%rax)
mov    (%rbx),%rbp
mov    %rbp,(%rbx,%rax,1)
add    $0x8,%rbx
add    $0x8,%rdi
jne    1390 <shftstr+0x280>
cmp    %rsi,%r9
jne    14a0 <shftstr+0x390>
jmp    14af <shftstr+0x39f>
and    $0xfffffffffffffffc,%rbp
lea    (%rbx,%r10,1),%r12
add    $0xfffffffffffffff1,%r12
lea    (%rax,%rbx,1),%r13
add    $0xfffffffffffffff1,%r13
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nop
movups 0x0(%r13,%rdi,1),%xmm0
movups %xmm0,(%r12,%rdi,1)
movups -0x10(%r13,%rdi,1),%xmm0
movups %xmm0,-0x10(%r12,%rdi,1)
movups -0x20(%r13,%rdi,1),%xmm0
movups %xmm0,-0x20(%r12,%rdi,1)
movups -0x30(%r13,%rdi,1),%xmm0
movups %xmm0,-0x30(%r12,%rdi,1)
add    $0xffffffffffffffc0,%rdi
add    $0xfffffffffffffffc,%rbp
jne    13d0 <shftstr+0x2c0>
neg    %rdi
test   %r11,%r11
je     1446 <shftstr+0x336>
sub    %rdi,%r10
add    %rbx,%r10
add    $0xfffffffffffffff1,%r10
mov    %rax,%rbp
sub    %rdi,%rbp
lea    (%rbx,%rbp,1),%r12
add    $0xfffffffffffffff1,%r12
shl    $0x4,%r11
xor    %ebp,%ebp
nop
movups (%r12,%rbp,1),%xmm0
movups %xmm0,(%r10,%rbp,1)
add    $0xfffffffffffffff0,%rbp
mov    %r11,%rdi
add    %rbp,%rdi
jne    1430 <shftstr+0x320>
cmp    %rsi,%r15
je     14af <shftstr+0x39f>
test   $0xc,%r15b
je     14be <shftstr+0x3ae>
cmp    %r14,%r9
cmovb  %r9,%r14
sub    %r14,%r8
mov    %r8,%rdi
and    $0xfffffffffffffffc,%rdi
sub    %rdi,%rcx
sub    %rsi,%rax
add    %rbx,%rax
add    $0xfffffffffffffffd,%rax
sub    %rdi,%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%rax),%ebp
mov    %ebp,(%rax,%rdx,1)
add    $0xfffffffffffffffc,%rax
add    $0x4,%rsi
jne    1480 <shftstr+0x370>
cmp    %rdi,%r8
jne    1170 <shftstr+0x60>
jmp    14af <shftstr+0x39f>
add    %rdi,%rbx
mov    %rbx,%rdx
movzbl (%rdx),%ebx
mov    %bl,(%rdx,%rax,1)
add    $0x1,%rdx
cmp    %rcx,%rdx
jbe    14a0 <shftstr+0x390>
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
sub    %rsi,%rcx
jmp    1170 <shftstr+0x60>

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

LLVM IR (-O2):
define void @shftstr(i8* %0, i32 %1) {
%3 = ptrtoint i8* %0 to i64
%4 = tail call i64 @strlen(i8* dereferenceable(1) %0)
%5 = getelementptr i8, i8* %0, i64 %4
%6 = icmp eq i32 %1, 0
br i1 %6, label %295, label %7
7: ; preds = %2
%8 = icmp sgt i32 %1, 0
%9 = icmp slt i64 %4, 0
br i1 %8, label %140, label %10
10: ; preds = %7
br i1 %9, label %295, label %11
11: ; preds = %10
%12 = sext i32 %1 to i64
%13 = add i64 %4, %3
%14 = add i64 %13, 1
%15 = add i64 %3, 1
%16 = call i64 @llvm.umax.i64(i64 %14, i64 %15)
%17 = sub i64 %16, %3
%18 = icmp ult i64 %17, 8
br i1 %18, label %138, label %19
19: ; preds = %11
%20 = getelementptr i8, i8* %0, i64 %12
%21 = add i64 %4, %3
%22 = add i64 %21, 1
%23 = add i64 %3, 1
%24 = call i64 @llvm.umax.i64(i64 %22, i64 %23)
%25 = add i64 %24, %12
%26 = sub i64 %25, %3
%27 = getelementptr i8, i8* %0, i64 %26
%28 = sub i64 %24, %3
%29 = getelementptr i8, i8* %0, i64 %28
%30 = icmp ult i8* %20, %29
%31 = icmp ugt i8* %27, %0
%32 = and i1 %30, %31
br i1 %32, label %138, label %33
33: ; preds = %19
%34 = icmp ult i64 %17, 32
br i1 %34, label %118, label %35
35: ; preds = %33
%36 = and i64 %17, -32
%37 = add i64 %36, -32
%38 = lshr exact i64 %37, 5
%39 = add nuw nsw i64 %38, 1
%40 = and i64 %39, 3
%41 = icmp ult i64 %37, 96
br i1 %41, label %93, label %42
42: ; preds = %35
%43 = and i64 %39, 1152921504606846972
br label %44
44: ; preds = %44, %42
%45 = phi i64 [ 0, %42 ], [ %90, %44 ]
%46 = phi i64 [ 0, %42 ], [ %91, %44 ]
%47 = getelementptr i8, i8* %0, i64 %45
%48 = bitcast i8* %47 to <16 x i8>*
%49 = load <16 x i8>, <16 x i8>* %48
%50 = getelementptr i8, i8* %47, i64 16
%51 = bitcast i8* %50 to <16 x i8>*
%52 = load <16 x i8>, <16 x i8>* %51
%53 = getelementptr inbounds i8, i8* %47, i64 %12
%54 = bitcast i8* %53 to <16 x i8>*
store <16 x i8> %49, <16 x i8>* %54
%55 = getelementptr inbounds i8, i8* %53, i64 16
%56 = bitcast i8* %55 to <16 x i8>*
store <16 x i8> %52, <16 x i8>* %56
%57 = or i64 %45, 32
%58 = getelementptr i8, i8* %0, i64 %57
%59 = bitcast i8* %58 to <16 x i8>*
%60 = load <16 x i8>, <16 x i8>* %59
%61 = getelementptr 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* %58, i64 %12
%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 %45, 64
%69 = getelementptr i8, i8* %0, i64 %68
%70 = bitcast i8* %69 to <16 x i8>*
%71 = load <16 x i8>, <16 x i8>* %70
%72 = getelementptr i8, i8* %69, i64 16
%73 = bitcast i8* %72 to <16 x i8>*
%74 = load <16 x i8>, <16 x i8>* %73
%75 = getelementptr inbounds i8, i8* %69, i64 %12
%76 = bitcast i8* %75 to <16 x i8>*
store <16 x i8> %71, <16 x i8>* %76
%77 = getelementptr inbounds i8, i8* %75, i64 16
%78 = bitcast i8* %77 to <16 x i8>*
store <16 x i8> %74, <16 x i8>* %78
%79 = or i64 %45, 96
%80 = getelementptr i8, i8* %0, i64 %79
%81 = bitcast i8* %80 to <16 x i8>*
%82 = load <16 x i8>, <16 x i8>* %81
%83 = getelementptr i8, i8* %80, i64 16
%84 = bitcast i8* %83 to <16 x i8>*
%85 = load <16 x i8>, <16 x i8>* %84
%86 = getelementptr inbounds i8, i8* %80, i64 %12
%87 = bitcast i8* %86 to <16 x i8>*
store <16 x i8> %82, <16 x i8>* %87
%88 = getelementptr inbounds i8, i8* %86, i64 16
%89 = bitcast i8* %88 to <16 x i8>*
store <16 x i8> %85, <16 x i8>* %89
%90 = add nuw i64 %45, 128
%91 = add i64 %46, 4
%92 = icmp eq i64 %91, %43
br i1 %92, label %93, label %44
93: ; preds = %44, %35
%94 = phi i64 [ 0, %35 ], [ %90, %44 ]
%95 = icmp eq i64 %40, 0
br i1 %95, label %112, label %96
96: ; preds = %93, %96
%97 = phi i64 [ %109, %96 ], [ %94, %93 ]
%98 = phi i64 [ %110, %96 ], [ 0, %93 ]
%99 = getelementptr i8, i8* %0, i64 %97
%100 = bitcast i8* %99 to <16 x i8>*
%101 = load <16 x i8>, <16 x i8>* %100
%102 = getelementptr i8, i8* %99, i64 16
%103 = bitcast i8* %102 to <16 x i8>*
%104 = load <16 x i8>, <16 x i8>* %103
%105 = getelementptr inbounds i8, i8* %99, i64 %12
%106 = bitcast i8* %105 to <16 x i8>*
store <16 x i8> %101, <16 x i8>* %106
%107 = getelementptr inbounds i8, i8* %105, i64 16
%108 = bitcast i8* %107 to <16 x i8>*
store <16 x i8> %104, <16 x i8>* %108
%109 = add nuw i64 %97, 32
%110 = add i64 %98, 1
%111 = icmp eq i64 %110, %40
br i1 %111, label %112, label %96
112: ; preds = %96, %93
%113 = icmp eq i64 %17, %36
br i1 %113, label %295, label %114
114: ; preds = %112
%115 = getelementptr i8, i8* %0, i64 %36
%116 = and i64 %17, 24
%117 = icmp eq i64 %116, 0
br i1 %117, label %138, label %118
118: ; preds = %33, %114
%119 = phi i64 [ %36, %114 ], [ 0, %33 ]
%120 = add i64 %4, %3
%121 = add i64 %120, 1
%122 = add i64 %3, 1
%123 = call i64 @llvm.umax.i64(i64 %121, i64 %122)
%124 = sub i64 %123, %3
%125 = and i64 %124, -8
%126 = getelementptr i8, i8* %0, i64 %125
br label %127
127: ; preds = %127, %118
%128 = phi i64 [ %119, %118 ], [ %134, %127 ]
%129 = getelementptr i8, i8* %0, i64 %128
%130 = bitcast i8* %129 to <8 x i8>*
%131 = load <8 x i8>, <8 x i8>* %130
%132 = getelementptr inbounds i8, i8* %129, i64 %12
%133 = bitcast i8* %132 to <8 x i8>*
store <8 x i8> %131, <8 x i8>* %133
%134 = add nuw i64 %128, 8
%135 = icmp eq i64 %134, %125
br i1 %135, label %136, label %127
136: ; preds = %127
%137 = icmp eq i64 %124, %125
br i1 %137, label %295, label %138
138: ; preds = %19, %11, %114, %136
%139 = phi i8* [ %0, %11 ], [ %0, %19 ], [ %115, %114 ], [ %126, %136 ]
br label %289
140: ; preds = %7
br i1 %9, label %295, label %141
141: ; preds = %140
%142 = zext i32 %1 to i64
%143 = add i64 %4, %3
%144 = add i64 %143, -1
%145 = add i64 %3, -1
%146 = call i64 @llvm.umin.i64(i64 %144, i64 %145)
%147 = sub i64 %143, %146
%148 = icmp ult i64 %147, 4
br i1 %148, label %281, label %149
149: ; preds = %141
%150 = add i64 %4, %3
%151 = add i64 %150, -1
%152 = add i64 %3, -1
%153 = call i64 @llvm.umin.i64(i64 %151, i64 %152)
%154 = sub i64 %151, %153
%155 = add i64 %4, %142
%156 = getelementptr i8, i8* %0, i64 %155
%157 = sub i64 0, %154
%158 = getelementptr i8, i8* %156, i64 %157
%159 = icmp ugt i8* %158, %156
%160 = sub i64 0, %154
%161 = getelementptr i8, i8* %5, i64 %160
%162 = icmp ugt i8* %161, %5
%163 = or i1 %159, %162
br i1 %163, label %281, label %164
164: ; preds = %149
%165 = add i64 %4, %3
%166 = add i64 %165, -1
%167 = add i64 %3, -1
%168 = call i64 @llvm.umin.i64(i64 %166, i64 %167)
%169 = add i64 %168, %142
%170 = add i64 %169, 1
%171 = sub i64 %170, %3
%172 = getelementptr i8, i8* %0, i64 %171
%173 = add i64 %4, %142
%174 = add i64 %173, 1
%175 = getelementptr i8, i8* %0, i64 %174
%176 = add i64 %168, 1
%177 = sub i64 %176, %3
%178 = getelementptr i8, i8* %0, i64 %177
%179 = add i64 %4, 1
%180 = getelementptr i8, i8* %0, i64 %179
%181 = icmp ult i8* %172, %180
%182 = icmp ult i8* %178, %175
%183 = and i1 %181, %182
br i1 %183, label %281, label %184
184: ; preds = %164
%185 = icmp ult i64 %147, 16
br i1 %185, label %257, label %186
186: ; preds = %184
%187 = and i64 %147, -16
%188 = add i64 %187, -16
%189 = lshr exact i64 %188, 4
%190 = add nuw nsw i64 %189, 1
%191 = and i64 %190, 3
%192 = icmp ult i64 %188, 48
br i1 %192, label %233, label %193
193: ; preds = %186
%194 = and i64 %190, 2305843009213693948
br label %195
195: ; preds = %195, %193
%196 = phi i64 [ 0, %193 ], [ %230, %195 ]
%197 = phi i64 [ 0, %193 ], [ %231, %195 ]
%198 = sub i64 0, %196
%199 = getelementptr i8, i8* %5, i64 %198
%200 = getelementptr i8, i8* %199, i64 -15
%201 = bitcast i8* %200 to <16 x i8>*
%202 = load <16 x i8>, <16 x i8>* %201
%203 = getelementptr inbounds i8, i8* %199, i64 %142
%204 = getelementptr inbounds i8, i8* %203, i64 -15
%205 = bitcast i8* %204 to <16 x i8>*
store <16 x i8> %202, <16 x i8>* %205
%206 = sub nuw nsw i64 -16, %196
%207 = getelementptr i8, i8* %5, i64 %206
%208 = getelementptr i8, i8* %207, i64 -15
%209 = bitcast i8* %208 to <16 x i8>*
%210 = load <16 x i8>, <16 x i8>* %209
%211 = getelementptr inbounds i8, i8* %207, i64 %142
%212 = getelementptr inbounds i8, i8* %211, i64 -15
%213 = bitcast i8* %212 to <16 x i8>*
store <16 x i8> %210, <16 x i8>* %213
%214 = sub nuw nsw i64 -32, %196
%215 = getelementptr i8, i8* %5, i64 %214
%216 = getelementptr i8, i8* %215, i64 -15
%217 = bitcast i8* %216 to <16 x i8>*
%218 = load <16 x i8>, <16 x i8>* %217
%219 = getelementptr inbounds i8, i8* %215, i64 %142
%220 = getelementptr inbounds i8, i8* %219, i64 -15
%221 = bitcast i8* %220 to <16 x i8>*
store <16 x i8> %218, <16 x i8>* %221
%222 = sub nuw nsw i64 -48, %196
%223 = getelementptr i8, i8* %5, i64 %222
%224 = getelementptr i8, i8* %223, i64 -15
%225 = bitcast i8* %224 to <16 x i8>*
%226 = load <16 x i8>, <16 x i8>* %225
%227 = getelementptr inbounds i8, i8* %223, i64 %142
%228 = getelementptr inbounds i8, i8* %227, i64 -15
%229 = bitcast i8* %228 to <16 x i8>*
store <16 x i8> %226, <16 x i8>* %229
%230 = add nuw i64 %196, 64
%231 = add i64 %197, 4
%232 = icmp eq i64 %231, %194
br i1 %232, label %233, label %195
233: ; preds = %195, %186
%234 = phi i64 [ 0, %186 ], [ %230, %195 ]
%235 = icmp eq i64 %191, 0
br i1 %235, label %250, label %236
236: ; preds = %233, %236
%237 = phi i64 [ %247, %236 ], [ %234, %233 ]
%238 = phi i64 [ %248, %236 ], [ 0, %233 ]
%239 = sub i64 0, %237
%240 = getelementptr i8, i8* %5, i64 %239
%241 = getelementptr i8, i8* %240, i64 -15
%242 = bitcast i8* %241 to <16 x i8>*
%243 = load <16 x i8>, <16 x i8>* %242
%244 = getelementptr inbounds i8, i8* %240, i64 %142
%245 = getelementptr inbounds i8, i8* %244, i64 -15
%246 = bitcast i8* %245 to <16 x i8>*
store <16 x i8> %243, <16 x i8>* %246
%247 = add nuw i64 %237, 16
%248 = add i64 %238, 1
%249 = icmp eq i64 %248, %191
br i1 %249, label %250, label %236
250: ; preds = %236, %233
%251 = icmp eq i64 %147, %187
br i1 %251, label %295, label %252
252: ; preds = %250
%253 = sub i64 0, %187
%254 = getelementptr i8, i8* %5, i64 %253
%255 = and i64 %147, 12
%256 = icmp eq i64 %255, 0
br i1 %256, label %281, label %257
257: ; preds = %184, %252
%258 = phi i64 [ %187, %252 ], [ 0, %184 ]
%259 = add i64 %4, %3
%260 = add i64 %259, -1
%261 = add i64 %3, -1
%262 = call i64 @llvm.umin.i64(i64 %260, i64 %261)
%263 = sub i64 %259, %262
%264 = and i64 %263, -4
%265 = sub i64 0, %264
%266 = getelementptr i8, i8* %5, i64 %265
br label %267
267: ; preds = %267, %257
%268 = phi i64 [ %258, %257 ], [ %277, %267 ]
%269 = sub i64 0, %268
%270 = getelementptr i8, i8* %5, i64 %269
%271 = getelementptr i8, i8* %270, i64 -3
%272 = bitcast i8* %271 to <4 x i8>*
%273 = load <4 x i8>, <4 x i8>* %272
%274 = getelementptr inbounds i8, i8* %270, i64 %142
%275 = getelementptr inbounds i8, i8* %274, i64 -3
%276 = bitcast i8* %275 to <4 x i8>*
store <4 x i8> %273, <4 x i8>* %276
%277 = add nuw i64 %268, 4
%278 = icmp eq i64 %277, %264
br i1 %278, label %279, label %267
279: ; preds = %267
%280 = icmp eq i64 %263, %264
br i1 %280, label %295, label %281
281: ; preds = %164, %149, %141, %252, %279
%282 = phi i8* [ %5, %141 ], [ %5, %164 ], [ %5, %149 ], [ %254, %252 ], [ %266, %279 ]
br label %283
283: ; preds = %281, %283
%284 = phi i8* [ %287, %283 ], [ %282, %281 ]
%285 = load i8, i8* %284
%286 = getelementptr inbounds i8, i8* %284, i64 %142
store i8 %285, i8* %286
%287 = getelementptr inbounds i8, i8* %284, i64 -1
%288 = icmp ult i8* %287, %0
br i1 %288, label %295, label %283
289: ; preds = %138, %289
%290 = phi i8* [ %293, %289 ], [ %139, %138 ]
%291 = load i8, i8* %290
%292 = getelementptr inbounds i8, i8* %290, i64 %12
store i8 %291, i8* %292
%293 = getelementptr inbounds i8, i8* %290, i64 1
%294 = icmp ugt i8* %293, %5
br i1 %294, label %295, label %289
295: ; preds = %289, %283, %112, %136, %250, %279, %10, %140, %2
ret void
}