#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 */
void *_memmove_bw_timec(void *dest, const void *src, size_t n) {
  unsigned char *d = dest;
  const unsigned char *s = src;
  int i = 0, z = 0;
  for (i = n - 1, z = 0; z <= i; i--)
    d[i] = s[i];
  return dest;
}


x86 assembly (clang, -O0):
<_memmove_bw_timec>:
push   %rbp
mov    %rsp,%rbp
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)
movl   $0x0,-0x2c(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x18(%rbp),%rax
sub    $0x1,%rax
mov    %eax,-0x2c(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jg     1170 <_memmove_bw_timec+0x70>
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    1140 <_memmove_bw_timec+0x40>
mov    -0x8(%rbp),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<_memmove_bw_timec>:
push   %rbx
mov    %rdi,%rax
mov    %edx,%r8d
add    $0xffffffff,%r8d
js     1252 <_memmove_bw_timec+0x152>
cmp    $0x4,%edx
jb     122e <_memmove_bw_timec+0x12e>
mov    %r8d,%ecx
lea    (%rsi,%rcx,1),%rdi
add    $0x1,%rdi
cmp    %rax,%rdi
jbe    113a <_memmove_bw_timec+0x3a>
add    %rax,%rcx
add    $0x1,%rcx
cmp    %rsi,%rcx
ja     122e <_memmove_bw_timec+0x12e>
xor    %r11d,%r11d
cmp    $0x10,%edx
jb     11ef <_memmove_bw_timec+0xef>
mov    %edx,%r11d
and    $0xfffffff0,%r11d
lea    -0x10(%r11),%edi
mov    %edi,%r10d
shr    $0x4,%r10d
add    $0x1,%r10d
mov    %r10d,%r9d
and    $0x3,%r9d
xor    %ecx,%ecx
cmp    $0x30,%edi
jb     11bf <_memmove_bw_timec+0xbf>
and    $0xfffffffc,%r10d
lea    -0x31(%rdx),%edi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    0x30(%rdi),%ebx
movups -0xf(%rsi,%rbx,1),%xmm0
movups %xmm0,-0xf(%rax,%rbx,1)
lea    0x20(%rdi),%ebx
movups -0xf(%rsi,%rbx,1),%xmm0
movups %xmm0,-0xf(%rax,%rbx,1)
lea    0x10(%rdi),%ebx
movups -0xf(%rsi,%rbx,1),%xmm0
movups %xmm0,-0xf(%rax,%rbx,1)
mov    %edi,%ebx
movups -0xf(%rsi,%rbx,1),%xmm0
movups %xmm0,-0xf(%rax,%rbx,1)
add    $0x40,%ecx
add    $0xffffffc0,%edi
add    $0xfffffffc,%r10d
jne    1180 <_memmove_bw_timec+0x80>
test   %r9d,%r9d
je     11e5 <_memmove_bw_timec+0xe5>
not    %ecx
add    %edx,%ecx
nopl   0x0(%rax,%rax,1)
mov    %ecx,%edi
movups -0xf(%rsi,%rdi,1),%xmm0
movups %xmm0,-0xf(%rax,%rdi,1)
add    $0xfffffff0,%ecx
add    $0xffffffff,%r9d
jne    11d0 <_memmove_bw_timec+0xd0>
cmp    %edx,%r11d
je     1252 <_memmove_bw_timec+0x152>
test   $0xc,%dl
je     122b <_memmove_bw_timec+0x12b>
mov    %edx,%r9d
and    $0xfffffffc,%r9d
sub    %r9d,%r8d
mov    %r11d,%edi
sub    %r9d,%edi
not    %r11d
add    %edx,%r11d
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r11d,%ebx
mov    -0x3(%rsi,%rbx,1),%ecx
mov    %ecx,-0x3(%rax,%rbx,1)
add    $0xfffffffc,%r11d
add    $0x4,%edi
jne    1210 <_memmove_bw_timec+0x110>
cmp    %edx,%r9d
jne    122e <_memmove_bw_timec+0x12e>
jmp    1252 <_memmove_bw_timec+0x152>
sub    %r11d,%r8d
mov    %r8d,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl (%rsi,%rcx,1),%edx
mov    %dl,(%rax,%rcx,1)
add    $0xffffffffffffffff,%rcx
lea    0x1(%rcx),%edx
test   %edx,%edx
jg     1240 <_memmove_bw_timec+0x140>
pop    %rbx
ret

LLVM IR (-O0):
define i8* @_memmove_bw_timec(i8* %0, i8* %1, i64 %2) {
%4 = alloca i8*
%5 = alloca i8*
%6 = alloca i64
%7 = alloca i8*
%8 = alloca i8*
%9 = alloca i32
%10 = alloca i32
store i8* %0, i8** %4
store i8* %1, i8** %5
store i64 %2, i64* %6
%11 = load i8*, i8** %4
store i8* %11, i8** %7
%12 = load i8*, i8** %5
store i8* %12, i8** %8
store i32 0, i32* %9
store i32 0, i32* %10
%13 = load i64, i64* %6
%14 = sub i64 %13, 1
%15 = trunc i64 %14 to i32
store i32 %15, i32* %9
store i32 0, i32* %10
br label %16
16: ; preds = %30, %3
%17 = load i32, i32* %10
%18 = load i32, i32* %9
%19 = icmp sle i32 %17, %18
br i1 %19, label %20, label %33
20: ; preds = %16
%21 = load i8*, i8** %8
%22 = load i32, i32* %9
%23 = sext i32 %22 to i64
%24 = getelementptr inbounds i8, i8* %21, i64 %23
%25 = load i8, i8* %24
%26 = load i8*, i8** %7
%27 = load i32, i32* %9
%28 = sext i32 %27 to i64
%29 = getelementptr inbounds i8, i8* %26, i64 %28
store i8 %25, i8* %29
br label %30
30: ; preds = %20
%31 = load i32, i32* %9
%32 = add nsw i32 %31, -1
store i32 %32, i32* %9
br label %16
33: ; preds = %16
%34 = load i8*, i8** %4
ret i8* %34
}

LLVM IR (-O2):
define i8* @_memmove_bw_timec(i8* returned writeonly %0, i8* nocapture %1, i64 %2) {
%4 = trunc i64 %2 to i32
%5 = add i32 %4, -1
%6 = icmp sgt i32 %5, -1
br i1 %6, label %7, label %127
7: ; preds = %3
%8 = icmp ult i32 %4, 4
br i1 %8, label %117, label %9
9: ; preds = %7
%10 = zext i32 %5 to i64
%11 = add nuw nsw i64 %10, 1
%12 = getelementptr i8, i8* %0, i64 %11
%13 = getelementptr i8, i8* %1, i64 %11
%14 = icmp ugt i8* %13, %0
%15 = icmp ugt i8* %12, %1
%16 = and i1 %14, %15
br i1 %16, label %117, label %17
17: ; preds = %9
%18 = icmp ult i32 %4, 16
br i1 %18, label %98, label %19
19: ; preds = %17
%20 = and i32 %4, -16
%21 = add i32 %20, -16
%22 = lshr exact i32 %21, 4
%23 = add nuw nsw i32 %22, 1
%24 = and i32 %23, 3
%25 = icmp ult i32 %21, 48
br i1 %25, label %73, label %26
26: ; preds = %19
%27 = and i32 %23, 536870908
%28 = getelementptr inbounds i8, i8* %1, i64 -15
%29 = getelementptr inbounds i8, i8* %0, i64 -15
%30 = getelementptr inbounds i8, i8* %1, i64 -15
%31 = getelementptr inbounds i8, i8* %0, i64 -15
%32 = getelementptr inbounds i8, i8* %1, i64 -15
%33 = getelementptr inbounds i8, i8* %0, i64 -15
%34 = getelementptr inbounds i8, i8* %1, i64 -15
%35 = getelementptr inbounds i8, i8* %0, i64 -15
br label %36
36: ; preds = %36, %26
%37 = phi i32 [ 0, %26 ], [ %70, %36 ]
%38 = phi i32 [ 0, %26 ], [ %71, %36 ]
%39 = sub i32 %5, %37
%40 = zext i32 %39 to i64
%41 = getelementptr inbounds i8, i8* %28, i64 %40
%42 = bitcast i8* %41 to <16 x i8>*
%43 = load <16 x i8>, <16 x i8>* %42
%44 = getelementptr inbounds i8, i8* %29, i64 %40
%45 = bitcast i8* %44 to <16 x i8>*
store <16 x i8> %43, <16 x i8>* %45
%46 = or i32 %37, 16
%47 = sub i32 %5, %46
%48 = zext i32 %47 to i64
%49 = getelementptr inbounds i8, i8* %30, i64 %48
%50 = bitcast i8* %49 to <16 x i8>*
%51 = load <16 x i8>, <16 x i8>* %50
%52 = getelementptr inbounds i8, i8* %31, i64 %48
%53 = bitcast i8* %52 to <16 x i8>*
store <16 x i8> %51, <16 x i8>* %53
%54 = or i32 %37, 32
%55 = sub i32 %5, %54
%56 = zext i32 %55 to i64
%57 = getelementptr inbounds i8, i8* %32, i64 %56
%58 = bitcast i8* %57 to <16 x i8>*
%59 = load <16 x i8>, <16 x i8>* %58
%60 = getelementptr inbounds i8, i8* %33, i64 %56
%61 = bitcast i8* %60 to <16 x i8>*
store <16 x i8> %59, <16 x i8>* %61
%62 = or i32 %37, 48
%63 = sub i32 %5, %62
%64 = zext i32 %63 to i64
%65 = getelementptr inbounds i8, i8* %34, i64 %64
%66 = bitcast i8* %65 to <16 x i8>*
%67 = load <16 x i8>, <16 x i8>* %66
%68 = getelementptr inbounds i8, i8* %35, i64 %64
%69 = bitcast i8* %68 to <16 x i8>*
store <16 x i8> %67, <16 x i8>* %69
%70 = add nuw i32 %37, 64
%71 = add i32 %38, 4
%72 = icmp eq i32 %71, %27
br i1 %72, label %73, label %36
73: ; preds = %36, %19
%74 = phi i32 [ 0, %19 ], [ %70, %36 ]
%75 = icmp eq i32 %24, 0
br i1 %75, label %92, label %76
76: ; preds = %73
%77 = getelementptr inbounds i8, i8* %1, i64 -15
%78 = getelementptr inbounds i8, i8* %0, i64 -15
br label %79
79: ; preds = %79, %76
%80 = phi i32 [ %74, %76 ], [ %89, %79 ]
%81 = phi i32 [ 0, %76 ], [ %90, %79 ]
%82 = sub i32 %5, %80
%83 = zext i32 %82 to i64
%84 = getelementptr inbounds i8, i8* %77, i64 %83
%85 = bitcast i8* %84 to <16 x i8>*
%86 = load <16 x i8>, <16 x i8>* %85
%87 = getelementptr inbounds i8, i8* %78, i64 %83
%88 = bitcast i8* %87 to <16 x i8>*
store <16 x i8> %86, <16 x i8>* %88
%89 = add nuw i32 %80, 16
%90 = add i32 %81, 1
%91 = icmp eq i32 %90, %24
br i1 %91, label %92, label %79
92: ; preds = %79, %73
%93 = icmp eq i32 %20, %4
br i1 %93, label %127, label %94
94: ; preds = %92
%95 = sub i32 %5, %20
%96 = and i32 %4, 12
%97 = icmp eq i32 %96, 0
br i1 %97, label %117, label %98
98: ; preds = %17, %94
%99 = phi i32 [ %20, %94 ], [ 0, %17 ]
%100 = and i32 %4, -4
%101 = sub i32 %5, %100
%102 = getelementptr inbounds i8, i8* %1, i64 -3
%103 = getelementptr inbounds i8, i8* %0, i64 -3
br label %104
104: ; preds = %104, %98
%105 = phi i32 [ %99, %98 ], [ %113, %104 ]
%106 = sub i32 %5, %105
%107 = zext i32 %106 to i64
%108 = getelementptr inbounds i8, i8* %102, i64 %107
%109 = bitcast i8* %108 to <4 x i8>*
%110 = load <4 x i8>, <4 x i8>* %109
%111 = getelementptr inbounds i8, i8* %103, i64 %107
%112 = bitcast i8* %111 to <4 x i8>*
store <4 x i8> %110, <4 x i8>* %112
%113 = add nuw i32 %105, 4
%114 = icmp eq i32 %113, %100
br i1 %114, label %115, label %104
115: ; preds = %104
%116 = icmp eq i32 %100, %4
br i1 %116, label %127, label %117
117: ; preds = %9, %7, %94, %115
%118 = phi i32 [ %5, %7 ], [ %5, %9 ], [ %95, %94 ], [ %101, %115 ]
br label %119
119: ; preds = %117, %119
%120 = phi i32 [ %125, %119 ], [ %118, %117 ]
%121 = zext i32 %120 to i64
%122 = getelementptr inbounds i8, i8* %1, i64 %121
%123 = load i8, i8* %122
%124 = getelementptr inbounds i8, i8* %0, i64 %121
store i8 %123, i8* %124
%125 = add nsw i32 %120, -1
%126 = icmp sgt i32 %120, 0
br i1 %126, label %119, label %127
127: ; preds = %119, %92, %115, %3
ret i8* %0
}