#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 */
typedef int /*<<< orphan*/ uint8_t;

/* Variables and functions */
void *memmove(void *d, const void *s, size_t n) {
  const uint8_t *s8 = s;
  uint8_t *d8 = d;
  if (((uintptr_t)d < (uintptr_t)s) || ((uintptr_t)s + n <= (uintptr_t)d))
    while (n--)
      *(d8++) = *(s8++);
  else
    while (n--)
      d8[n] = s8[n];
  return d;
}


x86 assembly (clang, -O0):
<memmove>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%rcx
cmp    %rcx,%rax
jb     1146 <memmove+0x46>
mov    -0x10(%rbp),%rax
add    -0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
cmp    %rcx,%rax
ja     1190 <memmove+0x90>
jmp    114b <memmove+0x4b>
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x18(%rbp)
cmp    $0x0,%rax
je     118b <memmove+0x8b>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%ecx
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x28(%rbp)
mov    %ecx,(%rax)
jmp    114b <memmove+0x4b>
jmp    11ce <memmove+0xce>
jmp    1195 <memmove+0x95>
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x18(%rbp)
cmp    $0x0,%rax
je     11c9 <memmove+0xc9>
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1195 <memmove+0x95>
jmp    11ce <memmove+0xce>
mov    -0x8(%rbp),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<memmove>:
mov    %rdi,%rax
cmp    %rsi,%rdi
jb     1234 <memmove+0x134>
lea    (%rsi,%rdx,1),%rcx
cmp    %rax,%rcx
jbe    1234 <memmove+0x134>
test   %rdx,%rdx
je     1412 <memmove+0x312>
cmp    $0x8,%rdx
jb     11f5 <memmove+0xf5>
lea    (%rsi,%rdx,4),%rcx
cmp    %rax,%rcx
jbe    1142 <memmove+0x42>
lea    (%rax,%rdx,4),%rcx
cmp    %rsi,%rcx
ja     11f5 <memmove+0xf5>
mov    %rdx,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rcx
mov    %rcx,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rcx,%rcx
je     1423 <memmove+0x323>
movabs $0x3ffffffffffffffc,%rdi
ff ff 3f
or     $0x2,%rdi
and    %r9,%rdi
lea    (%rax,%rdx,4),%r10
add    $0xfffffffffffffff0,%r10
lea    (%rsi,%rdx,4),%r11
add    $0xfffffffffffffff0,%r11
mov    $0xfffffffffffffffc,%rcx
nopl   0x0(%rax)
movups (%r11,%rcx,4),%xmm0
movups 0x10(%r11,%rcx,4),%xmm1
movups %xmm1,0x10(%r10,%rcx,4)
movups %xmm0,(%r10,%rcx,4)
movups -0x20(%r11,%rcx,4),%xmm0
movups -0x10(%r11,%rcx,4),%xmm1
movups %xmm1,-0x10(%r10,%rcx,4)
movups %xmm0,-0x20(%r10,%rcx,4)
add    $0xfffffffffffffff0,%rcx
add    $0xfffffffffffffffe,%rdi
jne    1190 <memmove+0x90>
add    $0x3,%rcx
test   $0x1,%r9b
je     11e9 <memmove+0xe9>
add    %rdx,%rcx
movups -0x1c(%rsi,%rcx,4),%xmm0
movups -0xc(%rsi,%rcx,4),%xmm1
movups %xmm1,-0xc(%rax,%rcx,4)
movups %xmm0,-0x1c(%rax,%rcx,4)
cmp    %rdx,%r8
je     1412 <memmove+0x312>
and    $0x7,%edx
lea    -0x1(%rdx),%r8
mov    %rdx,%r9
and    $0x3,%r9
je     12f4 <memmove+0x1f4>
cs nopw 0x0(%rax,%rax,1)
lea    -0x1(%rdx),%rcx
mov    -0x4(%rsi,%rdx,4),%edi
mov    %edi,-0x4(%rax,%rdx,4)
mov    %rcx,%rdx
add    $0xffffffffffffffff,%r9
jne    1210 <memmove+0x110>
cmp    $0x3,%r8
jae    1301 <memmove+0x201>
jmp    1412 <memmove+0x312>
test   %rdx,%rdx
je     1412 <memmove+0x312>
cmp    $0x8,%rdx
jb     125d <memmove+0x15d>
lea    (%rsi,%rdx,4),%rcx
cmp    %rax,%rcx
jbe    133e <memmove+0x23e>
lea    (%rax,%rdx,4),%rcx
cmp    %rsi,%rcx
jbe    133e <memmove+0x23e>
mov    %rax,%r11
lea    -0x1(%rdx),%r8
mov    %rdx,%r9
and    $0x7,%r9
je     128a <memmove+0x18a>
xor    %edi,%edi
nop
mov    (%rsi),%r10d
add    $0x4,%rsi
mov    %r10d,(%r11)
add    $0x4,%r11
add    $0x1,%rdi
cmp    %rdi,%r9
jne    1270 <memmove+0x170>
sub    %rdi,%rdx
cmp    $0x7,%r8
jb     1412 <memmove+0x312>
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
mov    (%rsi,%rdi,4),%ecx
mov    %ecx,(%r11,%rdi,4)
mov    0x4(%rsi,%rdi,4),%ecx
mov    %ecx,0x4(%r11,%rdi,4)
mov    0x8(%rsi,%rdi,4),%ecx
mov    %ecx,0x8(%r11,%rdi,4)
mov    0xc(%rsi,%rdi,4),%ecx
mov    %ecx,0xc(%r11,%rdi,4)
mov    0x10(%rsi,%rdi,4),%ecx
mov    %ecx,0x10(%r11,%rdi,4)
mov    0x14(%rsi,%rdi,4),%ecx
mov    %ecx,0x14(%r11,%rdi,4)
mov    0x18(%rsi,%rdi,4),%ecx
mov    %ecx,0x18(%r11,%rdi,4)
mov    0x1c(%rsi,%rdi,4),%ecx
mov    %ecx,0x1c(%r11,%rdi,4)
add    $0x8,%rdi
cmp    %rdi,%rdx
jne    12a0 <memmove+0x1a0>
jmp    1412 <memmove+0x312>
mov    %rdx,%rcx
cmp    $0x3,%r8
jb     1412 <memmove+0x312>
mov    %rcx,%rdx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    -0x4(%rsi,%rcx,4),%edi
mov    %edi,-0x4(%rax,%rcx,4)
mov    -0x8(%rsi,%rcx,4),%edi
mov    %edi,-0x8(%rax,%rcx,4)
mov    -0xc(%rsi,%rcx,4),%edi
mov    %edi,-0xc(%rax,%rcx,4)
mov    -0x10(%rsi,%rcx,4),%edi
mov    %edi,-0x10(%rax,%rcx,4)
add    $0xfffffffffffffffc,%rdx
mov    %rdx,%rcx
jne    1310 <memmove+0x210>
jmp    1412 <memmove+0x312>
mov    %rdx,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rdi
mov    %rdi,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
mov    %ecx,%r9d
and    $0x3,%r9d
cmp    $0x18,%rdi
jae    1365 <memmove+0x265>
xor    %edi,%edi
jmp    13c8 <memmove+0x2c8>
and    $0xfffffffffffffffc,%rcx
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movups (%rsi,%rdi,4),%xmm0
movups 0x10(%rsi,%rdi,4),%xmm1
movups %xmm0,(%rax,%rdi,4)
movups %xmm1,0x10(%rax,%rdi,4)
movups 0x20(%rsi,%rdi,4),%xmm0
movups 0x30(%rsi,%rdi,4),%xmm1
movups %xmm0,0x20(%rax,%rdi,4)
movups %xmm1,0x30(%rax,%rdi,4)
movups 0x40(%rsi,%rdi,4),%xmm0
movups 0x50(%rsi,%rdi,4),%xmm1
movups %xmm0,0x40(%rax,%rdi,4)
movups %xmm1,0x50(%rax,%rdi,4)
movups 0x60(%rsi,%rdi,4),%xmm0
movups 0x70(%rsi,%rdi,4),%xmm1
movups %xmm0,0x60(%rax,%rdi,4)
movups %xmm1,0x70(%rax,%rdi,4)
add    $0x20,%rdi
add    $0xfffffffffffffffc,%rcx
jne    1370 <memmove+0x270>
test   %r9,%r9
je     140d <memmove+0x30d>
lea    (%rsi,%rdi,4),%r10
add    $0x10,%r10
lea    (%rax,%rdi,4),%rdi
add    $0x10,%rdi
shl    $0x5,%r9
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x10(%r10,%rcx,1),%xmm0
movups (%r10,%rcx,1),%xmm1
movups %xmm0,-0x10(%rdi,%rcx,1)
movups %xmm1,(%rdi,%rcx,1)
add    $0x20,%rcx
cmp    %rcx,%r9
jne    13f0 <memmove+0x2f0>
cmp    %rdx,%r8
jne    1413 <memmove+0x313>
ret
and    $0x7,%edx
lea    (%rax,%r8,4),%r11
lea    (%rsi,%r8,4),%rsi
jmp    1260 <memmove+0x160>
mov    $0xffffffffffffffff,%rcx
test   $0x1,%r9b
jne    11d2 <memmove+0xd2>
jmp    11e9 <memmove+0xe9>

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

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