#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*/ opa_free(unsigned char *);
unsigned char *opa_malloc(size_t);
void *memmove(void *dest, const void *src, size_t n) {
  unsigned char *d = dest;
  const unsigned char *s = src;
  unsigned char *t = opa_malloc(n);
  for (size_t i = 0; i < n; i++) {
    t[i] = s[i];
  }
  for (size_t i = 0; i < n; i++) {
    d[i] = t[i];
  }
  opa_free(t);
  return dest;
}


x86 assembly (clang, -O0):
<memmove>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rdi
call   1040 <opa_malloc@plt>
mov    %rax,-0x30(%rbp)
movq   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x18(%rbp),%rax
jae    118e <memmove+0x6e>
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    1159 <memmove+0x39>
movq   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x18(%rbp),%rax
jae    11cb <memmove+0xab>
mov    -0x30(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x20(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    1196 <memmove+0x76>
mov    -0x30(%rbp),%rdi
call   1030 <opa_free@plt>
mov    -0x8(%rbp),%rax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<memmove>:
push   %r15
push   %r14
push   %rbx
mov    %rdx,%r14
mov    %rsi,%rbx
mov    %rdi,%r15
mov    %rdx,%rdi
call   1040 <opa_malloc@plt>
test   %r14,%r14
je     125f <memmove+0x13f>
cmp    $0x8,%r14
jb     115f <memmove+0x3f>
lea    (%rbx,%r14,1),%rcx
cmp    %rcx,%rax
jae    1270 <memmove+0x150>
lea    (%rax,%r14,1),%rcx
cmp    %rbx,%rcx
jbe    1270 <memmove+0x150>
xor    %ecx,%ecx
mov    %rcx,%rdi
not    %rdi
add    %r14,%rdi
mov    %r14,%rsi
and    $0x3,%rsi
je     1191 <memmove+0x71>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzbl (%rbx,%rcx,1),%edx
mov    %dl,(%rax,%rcx,1)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    1180 <memmove+0x60>
cmp    $0x3,%rdi
jb     11cb <memmove+0xab>
nopw   0x0(%rax,%rax,1)
movzbl (%rbx,%rcx,1),%edx
mov    %dl,(%rax,%rcx,1)
movzbl 0x1(%rbx,%rcx,1),%edx
mov    %dl,0x1(%rax,%rcx,1)
movzbl 0x2(%rbx,%rcx,1),%edx
mov    %dl,0x2(%rax,%rcx,1)
movzbl 0x3(%rbx,%rcx,1),%edx
mov    %dl,0x3(%rax,%rcx,1)
add    $0x4,%rcx
cmp    %rcx,%r14
jne    11a0 <memmove+0x80>
test   %r14,%r14
je     125f <memmove+0x13f>
cmp    $0x8,%r14
jb     11f4 <memmove+0xd4>
lea    (%rax,%r14,1),%rcx
cmp    %r15,%rcx
jbe    127d <memmove+0x15d>
lea    (%r15,%r14,1),%rcx
cmp    %rcx,%rax
jae    127d <memmove+0x15d>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %r14,%rdx
mov    %r14,%rsi
and    $0x3,%rsi
je     1222 <memmove+0x102>
nopl   0x0(%rax,%rax,1)
movzbl (%rax,%rcx,1),%ebx
mov    %bl,(%r15,%rcx,1)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    1210 <memmove+0xf0>
cmp    $0x3,%rdx
jb     125f <memmove+0x13f>
nopl   0x0(%rax,%rax,1)
movzbl (%rax,%rcx,1),%edx
mov    %dl,(%r15,%rcx,1)
movzbl 0x1(%rax,%rcx,1),%edx
mov    %dl,0x1(%r15,%rcx,1)
movzbl 0x2(%rax,%rcx,1),%edx
mov    %dl,0x2(%r15,%rcx,1)
movzbl 0x3(%rax,%rcx,1),%edx
mov    %dl,0x3(%r15,%rcx,1)
add    $0x4,%rcx
cmp    %rcx,%r14
jne    1230 <memmove+0x110>
mov    %rax,%rdi
call   1030 <opa_free@plt>
mov    %r15,%rax
pop    %rbx
pop    %r14
pop    %r15
ret
cmp    $0x20,%r14
jae    128a <memmove+0x16a>
xor    %ecx,%ecx
jmp    139e <memmove+0x27e>
cmp    $0x20,%r14
jae    12b4 <memmove+0x194>
xor    %ecx,%ecx
jmp    148e <memmove+0x36e>
mov    %r14,%rcx
and    $0xffffffffffffffe0,%rcx
lea    -0x20(%rcx),%rdx
mov    %rdx,%rsi
shr    $0x5,%rsi
add    $0x1,%rsi
mov    %esi,%r8d
and    $0x3,%r8d
cmp    $0x60,%rdx
jae    12e0 <memmove+0x1c0>
xor    %edi,%edi
jmp    1348 <memmove+0x228>
mov    %r14,%rcx
and    $0xffffffffffffffe0,%rcx
lea    -0x20(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x5,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0x60,%rdi
jae    13cf <memmove+0x2af>
xor    %edi,%edi
jmp    1440 <memmove+0x320>
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
movups (%rbx,%rdi,1),%xmm0
movups 0x10(%rbx,%rdi,1),%xmm1
movups %xmm0,(%rax,%rdi,1)
movups %xmm1,0x10(%rax,%rdi,1)
movups 0x20(%rbx,%rdi,1),%xmm0
movups 0x30(%rbx,%rdi,1),%xmm1
movups %xmm0,0x20(%rax,%rdi,1)
movups %xmm1,0x30(%rax,%rdi,1)
movups 0x40(%rbx,%rdi,1),%xmm0
movups 0x50(%rbx,%rdi,1),%xmm1
movups %xmm0,0x40(%rax,%rdi,1)
movups %xmm1,0x50(%rax,%rdi,1)
movups 0x60(%rbx,%rdi,1),%xmm0
movups 0x70(%rbx,%rdi,1),%xmm1
movups %xmm0,0x60(%rax,%rdi,1)
movups %xmm1,0x70(%rax,%rdi,1)
sub    $0xffffffffffffff80,%rdi
add    $0xfffffffffffffffc,%rsi
jne    12f0 <memmove+0x1d0>
test   %r8,%r8
je     138b <memmove+0x26b>
lea    (%rax,%rdi,1),%rsi
add    $0x10,%rsi
add    %rbx,%rdi
add    $0x10,%rdi
shl    $0x5,%r8
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups -0x10(%rdi,%rdx,1),%xmm0
movups (%rdi,%rdx,1),%xmm1
movups %xmm0,-0x10(%rsi,%rdx,1)
movups %xmm1,(%rsi,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%r8
jne    1370 <memmove+0x250>
cmp    %r14,%rcx
je     11cb <memmove+0xab>
test   $0x18,%r14b
je     1161 <memmove+0x41>
mov    %rcx,%rdx
mov    %r14,%rcx
and    $0xfffffffffffffff8,%rcx
nopl   0x0(%rax,%rax,1)
mov    (%rbx,%rdx,1),%rsi
mov    %rsi,(%rax,%rdx,1)
add    $0x8,%rdx
cmp    %rdx,%rcx
jne    13b0 <memmove+0x290>
cmp    %r14,%rcx
je     11cb <memmove+0xab>
jmp    1161 <memmove+0x41>
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nop
movups (%rax,%rdi,1),%xmm0
movups 0x10(%rax,%rdi,1),%xmm1
movups %xmm0,(%r15,%rdi,1)
movups %xmm1,0x10(%r15,%rdi,1)
movups 0x20(%rax,%rdi,1),%xmm0
movups 0x30(%rax,%rdi,1),%xmm1
movups %xmm0,0x20(%r15,%rdi,1)
movups %xmm1,0x30(%r15,%rdi,1)
movups 0x40(%rax,%rdi,1),%xmm0
movups 0x50(%rax,%rdi,1),%xmm1
movups %xmm0,0x40(%r15,%rdi,1)
movups %xmm1,0x50(%r15,%rdi,1)
movups 0x60(%rax,%rdi,1),%xmm0
movups 0x70(%rax,%rdi,1),%xmm1
movups %xmm0,0x60(%r15,%rdi,1)
movups %xmm1,0x70(%r15,%rdi,1)
sub    $0xffffffffffffff80,%rdi
add    $0xfffffffffffffffc,%rsi
jne    13e0 <memmove+0x2c0>
test   %rdx,%rdx
je     147b <memmove+0x35b>
lea    (%r15,%rdi,1),%rsi
add    $0x10,%rsi
add    %rax,%rdi
add    $0x10,%rdi
shl    $0x5,%rdx
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movups -0x10(%rdi,%rbx,1),%xmm0
movups (%rdi,%rbx,1),%xmm1
movups %xmm0,-0x10(%rsi,%rbx,1)
movups %xmm1,(%rsi,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%rdx
jne    1460 <memmove+0x340>
cmp    %r14,%rcx
je     125f <memmove+0x13f>
test   $0x18,%r14b
je     11f6 <memmove+0xd6>
mov    %rcx,%rdx
mov    %r14,%rcx
and    $0xfffffffffffffff8,%rcx
nopl   0x0(%rax,%rax,1)
mov    (%rax,%rdx,1),%rsi
mov    %rsi,(%r15,%rdx,1)
add    $0x8,%rdx
cmp    %rdx,%rcx
jne    14a0 <memmove+0x380>
cmp    %r14,%rcx
je     125f <memmove+0x13f>
jmp    11f6 <memmove+0xd6>

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

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