#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 *dest, const void *src, size_t n) {
  uint8_t const *byte_src = (uint8_t const *)src;
  uint8_t *byte_dest = (uint8_t *)dest;
  if (dest < src) {
    while (n--)
      *byte_dest++ = *byte_src++;
  } else {
    byte_src += n;
    byte_dest += n;
    while (n--)
      *--byte_dest = *--byte_src;
  }
  return dest;
}


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
cmp    -0x10(%rbp),%rax
jae    1178 <memmove+0x78>
jmp    1133 <memmove+0x33>
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x18(%rbp)
cmp    $0x0,%rax
je     1173 <memmove+0x73>
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    1133 <memmove+0x33>
jmp    11df <memmove+0xdf>
mov    -0x18(%rbp),%rax
shl    $0x2,%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
shl    $0x2,%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x18(%rbp)
cmp    $0x0,%rax
je     11da <memmove+0xda>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x20(%rbp)
mov    -0x4(%rax),%ecx
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0xfffffffffffffffc,%rdx
mov    %rdx,-0x28(%rbp)
mov    %ecx,-0x4(%rax)
jmp    1198 <memmove+0x98>
jmp    11df <memmove+0xdf>
mov    -0x8(%rbp),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<memmove>:
push   %rbx
mov    %rdi,%rax
cmp    %rsi,%rdi
jae    11cc <memmove+0xcc>
test   %rdx,%rdx
je     1420 <memmove+0x320>
cmp    $0x8,%rdx
jb     1136 <memmove+0x36>
lea    (%rsi,%rdx,4),%rcx
cmp    %rax,%rcx
jbe    134e <memmove+0x24e>
lea    (%rax,%rdx,4),%rcx
cmp    %rsi,%rcx
jbe    134e <memmove+0x24e>
mov    %rax,%rcx
lea    -0x1(%rdx),%r8
mov    %rdx,%r9
and    $0x7,%r9
je     1168 <memmove+0x68>
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
mov    (%rsi),%ebx
add    $0x4,%rsi
mov    %ebx,(%rcx)
add    $0x4,%rcx
add    $0x1,%rdi
cmp    %rdi,%r9
jne    1150 <memmove+0x50>
sub    %rdi,%rdx
cmp    $0x7,%r8
jb     1420 <memmove+0x320>
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%rsi,%rdi,4),%ebx
mov    %ebx,(%rcx,%rdi,4)
mov    0x4(%rsi,%rdi,4),%ebx
mov    %ebx,0x4(%rcx,%rdi,4)
mov    0x8(%rsi,%rdi,4),%ebx
mov    %ebx,0x8(%rcx,%rdi,4)
mov    0xc(%rsi,%rdi,4),%ebx
mov    %ebx,0xc(%rcx,%rdi,4)
mov    0x10(%rsi,%rdi,4),%ebx
mov    %ebx,0x10(%rcx,%rdi,4)
mov    0x14(%rsi,%rdi,4),%ebx
mov    %ebx,0x14(%rcx,%rdi,4)
mov    0x18(%rsi,%rdi,4),%ebx
mov    %ebx,0x18(%rcx,%rdi,4)
mov    0x1c(%rsi,%rdi,4),%ebx
mov    %ebx,0x1c(%rcx,%rdi,4)
add    $0x8,%rdi
cmp    %rdi,%rdx
jne    1180 <memmove+0x80>
jmp    1420 <memmove+0x320>
test   %rdx,%rdx
je     1420 <memmove+0x320>
lea    (%rax,%rdx,4),%rcx
lea    (%rsi,%rdx,4),%rdi
cmp    $0x8,%rdx
jb     12b5 <memmove+0x1b5>
lea    (%rsi,%rdx,4),%rbx
cmp    %rax,%rbx
jbe    11fd <memmove+0xfd>
lea    (%rax,%rdx,4),%rbx
cmp    %rsi,%rbx
ja     12b5 <memmove+0x1b5>
mov    %rdx,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rbx
mov    %rbx,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rbx,%rbx
je     1432 <memmove+0x332>
movabs $0x3ffffffffffffffc,%r10
ff ff 3f
or     $0x2,%r10
and    %r9,%r10
lea    (%rsi,%rdx,4),%r11
add    $0xfffffffffffffff0,%r11
lea    (%rax,%rdx,4),%rbx
add    $0xfffffffffffffff0,%rbx
xor    %esi,%esi
nop
movups -0x10(%r11,%rsi,4),%xmm0
movups (%r11,%rsi,4),%xmm1
movups %xmm1,(%rbx,%rsi,4)
movups %xmm0,-0x10(%rbx,%rsi,4)
movups -0x30(%r11,%rsi,4),%xmm0
movups -0x20(%r11,%rsi,4),%xmm1
movups %xmm1,-0x20(%rbx,%rsi,4)
movups %xmm0,-0x30(%rbx,%rsi,4)
add    $0xfffffffffffffff0,%rsi
add    $0xfffffffffffffffe,%r10
jne    1240 <memmove+0x140>
neg    %rsi
test   $0x1,%r9b
je     129f <memmove+0x19f>
shl    $0x2,%rsi
mov    %rcx,%r9
sub    %rsi,%r9
mov    %rdi,%rbx
sub    %rsi,%rbx
movups -0x20(%rbx),%xmm0
movups -0x10(%rbx),%xmm1
movups %xmm1,-0x10(%r9)
movups %xmm0,-0x20(%r9)
cmp    %rdx,%r8
je     1420 <memmove+0x320>
shl    $0x2,%r8
and    $0x7,%edx
sub    %r8,%rcx
sub    %r8,%rdi
lea    -0x1(%rdx),%r8
mov    %rdx,%r9
and    $0x7,%r9
je     12ea <memmove+0x1ea>
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    -0x4(%rdi),%ebx
add    $0xfffffffffffffffc,%rdi
mov    %ebx,-0x4(%rcx)
add    $0xfffffffffffffffc,%rcx
add    $0x1,%rsi
cmp    %rsi,%r9
jne    12d0 <memmove+0x1d0>
sub    %rsi,%rdx
cmp    $0x7,%r8
jb     1420 <memmove+0x320>
neg    %rdx
xor    %esi,%esi
nopl   0x0(%rax)
mov    -0x4(%rdi,%rsi,4),%ebx
mov    %ebx,-0x4(%rcx,%rsi,4)
mov    -0x8(%rdi,%rsi,4),%ebx
mov    %ebx,-0x8(%rcx,%rsi,4)
mov    -0xc(%rdi,%rsi,4),%ebx
mov    %ebx,-0xc(%rcx,%rsi,4)
mov    -0x10(%rdi,%rsi,4),%ebx
mov    %ebx,-0x10(%rcx,%rsi,4)
mov    -0x14(%rdi,%rsi,4),%ebx
mov    %ebx,-0x14(%rcx,%rsi,4)
mov    -0x18(%rdi,%rsi,4),%ebx
mov    %ebx,-0x18(%rcx,%rsi,4)
mov    -0x1c(%rdi,%rsi,4),%ebx
mov    %ebx,-0x1c(%rcx,%rsi,4)
mov    -0x20(%rdi,%rsi,4),%ebx
mov    %ebx,-0x20(%rcx,%rsi,4)
add    $0xfffffffffffffff8,%rsi
cmp    %rsi,%rdx
jne    1300 <memmove+0x200>
jmp    1420 <memmove+0x320>
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    1375 <memmove+0x275>
xor    %edi,%edi
jmp    13d8 <memmove+0x2d8>
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    1380 <memmove+0x280>
test   %r9,%r9
je     141b <memmove+0x31b>
lea    (%rsi,%rdi,4),%rcx
add    $0x10,%rcx
lea    (%rax,%rdi,4),%rdi
add    $0x10,%rdi
shl    $0x5,%r9
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x10(%rcx,%rbx,1),%xmm0
movups (%rcx,%rbx,1),%xmm1
movups %xmm0,-0x10(%rdi,%rbx,1)
movups %xmm1,(%rdi,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%r9
jne    1400 <memmove+0x300>
cmp    %rdx,%r8
jne    1422 <memmove+0x322>
pop    %rbx
ret
and    $0x7,%edx
lea    (%rax,%r8,4),%rcx
lea    (%rsi,%r8,4),%rsi
jmp    1139 <memmove+0x39>
xor    %esi,%esi
test   $0x1,%r9b
jne    127d <memmove+0x17d>
jmp    129f <memmove+0x19f>

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 = load i8*, i8** %5
%15 = icmp ult i8* %13, %14
br i1 %15, label %16, label %28
16: ; preds = %3
br label %17
17: ; preds = %21, %16
%18 = load i64, i64* %6
%19 = add i64 %18, -1
store i64 %19, i64* %6
%20 = icmp ne i64 %18, 0
br i1 %20, label %21, label %27
21: ; preds = %17
%22 = load i32*, i32** %7
%23 = getelementptr inbounds i32, i32* %22, i32 1
store i32* %23, i32** %7
%24 = load i32, i32* %22
%25 = load i32*, i32** %8
%26 = getelementptr inbounds i32, i32* %25, i32 1
store i32* %26, i32** %8
store i32 %24, i32* %25
br label %17
27: ; preds = %17
br label %46
28: ; preds = %3
%29 = load i64, i64* %6
%30 = load i32*, i32** %7
%31 = getelementptr inbounds i32, i32* %30, i64 %29
store i32* %31, i32** %7
%32 = load i64, i64* %6
%33 = load i32*, i32** %8
%34 = getelementptr inbounds i32, i32* %33, i64 %32
store i32* %34, i32** %8
br label %35
35: ; preds = %39, %28
%36 = load i64, i64* %6
%37 = add i64 %36, -1
store i64 %37, i64* %6
%38 = icmp ne i64 %36, 0
br i1 %38, label %39, label %45
39: ; preds = %35
%40 = load i32*, i32** %7
%41 = getelementptr inbounds i32, i32* %40, i32 -1
store i32* %41, i32** %7
%42 = load i32, i32* %41
%43 = load i32*, i32** %8
%44 = getelementptr inbounds i32, i32* %43, i32 -1
store i32* %44, i32** %8
store i32 %42, i32* %44
br label %35
45: ; preds = %35
br label %46
46: ; preds = %45, %27
%47 = load i8*, i8** %4
ret i8* %47
}

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