#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 */
unsigned int __builtin_bswap32(unsigned int const);
void *memcpy_bswap32(void *dest, const void *src, size_t n) {
  unsigned int *destp;
  const unsigned int *srcp;
  unsigned int i;
  destp = dest;
  srcp = src;
  for (i = 0; i < (n >> 2); i++) {
    *destp = __builtin_bswap32(*srcp);
    destp++;
    srcp++;
  }
  return dest;
}


x86 assembly (clang, -O0):
<memcpy_bswap32>:
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)
mov    -0x2c(%rbp),%eax
mov    -0x18(%rbp),%rcx
shr    $0x2,%rcx
cmp    %rcx,%rax
jae    116f <memcpy_bswap32+0x6f>
mov    -0x28(%rbp),%rax
mov    (%rax),%ecx
bswap  %ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x20(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x28(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1127 <memcpy_bswap32+0x27>
mov    -0x8(%rbp),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<memcpy_bswap32>:
mov    %rdi,%rax
cmp    $0x4,%rdx
jb     1186 <memcpy_bswap32+0x86>
shr    $0x2,%rdx
cmp    $0x2,%rdx
mov    $0x1,%ecx
mov    $0x1,%r9d
cmovae %rdx,%r9
xor    %r8d,%r8d
cmp    $0x8,%r9
jb     115f <memcpy_bswap32+0x5f>
cmp    $0x2,%rdx
cmovae %rdx,%rcx
add    $0xffffffffffffffff,%rcx
cmp    $0xffffffff,%ecx
je     115f <memcpy_bswap32+0x5f>
shr    $0x20,%rcx
jne    115f <memcpy_bswap32+0x5f>
cmp    $0x2,%rdx
mov    $0x1,%ecx
cmovae %rdx,%rcx
lea    (%rsi,%rcx,4),%rdi
cmp    %rax,%rdi
jbe    1187 <memcpy_bswap32+0x87>
lea    (%rax,%rcx,4),%rcx
cmp    %rsi,%rcx
jbe    1187 <memcpy_bswap32+0x87>
mov    %rsi,%r10
mov    %rax,%r11
mov    %r8d,%esi
add    $0x1,%rsi
xor    %edi,%edi
xchg   %ax,%ax
mov    (%r10,%rdi,4),%ecx
bswap  %ecx
mov    %ecx,(%r11,%rdi,4)
lea    (%rsi,%rdi,1),%ecx
add    $0x1,%rdi
cmp    %rcx,%rdx
ja     1170 <memcpy_bswap32+0x70>
ret
mov    %r9,%r8
and    $0xfffffffffffffff8,%r8
lea    (%rsi,%r8,4),%r10
lea    (%rax,%r8,4),%r11
xor    %edi,%edi
pxor   %xmm0,%xmm0
nopl   0x0(%rax)
movdqu (%rsi,%rdi,4),%xmm1
movdqu 0x10(%rsi,%rdi,4),%xmm2
movdqa %xmm1,%xmm3
punpckhbw %xmm0,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpcklbw %xmm0,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm3,%xmm1
movdqa %xmm2,%xmm3
punpckhbw %xmm0,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpcklbw %xmm0,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
packuswb %xmm3,%xmm2
movdqu %xmm1,(%rax,%rdi,4)
movdqu %xmm2,0x10(%rax,%rdi,4)
add    $0x8,%rdi
cmp    %rdi,%r8
jne    11a0 <memcpy_bswap32+0xa0>
cmp    %r8,%r9
jne    1165 <memcpy_bswap32+0x65>
jmp    1186 <memcpy_bswap32+0x86>

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

LLVM IR (-O2):
define i8* @memcpy_bswap32(i8* returned writeonly %0, i8* nocapture %1, i64 %2) {
%4 = lshr i64 %2, 2
%5 = icmp ult i64 %2, 4
br i1 %5, label %64, label %6
6: ; preds = %3
%7 = bitcast i8* %1 to i32*
%8 = bitcast i8* %0 to i32*
%9 = call i64 @llvm.umax.i64(i64 %4, i64 1)
%10 = icmp ult i64 %9, 8
br i1 %10, label %49, label %11
11: ; preds = %6
%12 = call i64 @llvm.umax.i64(i64 %4, i64 1)
%13 = add nsw i64 %12, -1
%14 = trunc i64 %13 to i32
%15 = icmp eq i32 %14, -1
%16 = icmp ugt i64 %13, 4294967295
%17 = or i1 %15, %16
br i1 %17, label %49, label %18
18: ; preds = %11
%19 = call i64 @llvm.umax.i64(i64 %4, i64 1)
%20 = shl nuw i64 %19, 2
%21 = getelementptr i8, i8* %0, i64 %20
%22 = getelementptr i8, i8* %1, i64 %20
%23 = icmp ugt i8* %22, %0
%24 = icmp ugt i8* %21, %1
%25 = and i1 %23, %24
br i1 %25, label %49, label %26
26: ; preds = %18
%27 = and i64 %9, 4611686018427387896
%28 = trunc i64 %27 to i32
%29 = getelementptr i32, i32* %7, i64 %27
%30 = getelementptr i32, i32* %8, i64 %27
br label %31
31: ; preds = %31, %26
%32 = phi i64 [ 0, %26 ], [ %45, %31 ]
%33 = getelementptr i32, i32* %7, i64 %32
%34 = getelementptr i32, i32* %8, i64 %32
%35 = bitcast i32* %33 to <4 x i32>*
%36 = load <4 x i32>, <4 x i32>* %35
%37 = getelementptr i32, i32* %33, i64 4
%38 = bitcast i32* %37 to <4 x i32>*
%39 = load <4 x i32>, <4 x i32>* %38
%40 = call <4 x i32> @llvm.bswap.v4i32(<4 x i32> %36)
%41 = call <4 x i32> @llvm.bswap.v4i32(<4 x i32> %39)
%42 = bitcast i32* %34 to <4 x i32>*
store <4 x i32> %40, <4 x i32>* %42
%43 = getelementptr i32, i32* %34, i64 4
%44 = bitcast i32* %43 to <4 x i32>*
store <4 x i32> %41, <4 x i32>* %44
%45 = add nuw i64 %32, 8
%46 = icmp eq i64 %45, %27
br i1 %46, label %47, label %31
47: ; preds = %31
%48 = icmp eq i64 %9, %27
br i1 %48, label %64, label %49
49: ; preds = %18, %11, %6, %47
%50 = phi i32 [ 0, %18 ], [ 0, %11 ], [ 0, %6 ], [ %28, %47 ]
%51 = phi i32* [ %7, %18 ], [ %7, %11 ], [ %7, %6 ], [ %29, %47 ]
%52 = phi i32* [ %8, %18 ], [ %8, %11 ], [ %8, %6 ], [ %30, %47 ]
br label %53
53: ; preds = %49, %53
%54 = phi i32 [ %61, %53 ], [ %50, %49 ]
%55 = phi i32* [ %60, %53 ], [ %51, %49 ]
%56 = phi i32* [ %59, %53 ], [ %52, %49 ]
%57 = load i32, i32* %55
%58 = tail call i32 @llvm.bswap.i32(i32 %57)
store i32 %58, i32* %56
%59 = getelementptr inbounds i32, i32* %56, i64 1
%60 = getelementptr inbounds i32, i32* %55, i64 1
%61 = add i32 %54, 1
%62 = zext i32 %61 to i64
%63 = icmp ugt i64 %4, %62
br i1 %63, label %53, label %64
64: ; preds = %53, %47, %3
ret i8* %0
}