#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*/ assert(int /*<<< orphan*/);
long *malloc(size_t);
void longarrcpy(long *in, size_t size, long **out) {
  long *ipt, *opt, *fpt;
  ipt = in;
  *out = malloc(size * sizeof(long));
  assert(*out != NULL);
  fpt = *out + size;
  opt = *out;
  while (opt < fpt)
    *opt++ = *ipt++;
}


x86 assembly (clang, -O0):
<longarrcpy>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x10(%rbp),%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x18(%rbp),%rax
cmpq   $0x0,(%rax)
setne  %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    -0x10(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
cmp    -0x30(%rbp),%rax
jae    11c0 <longarrcpy+0xa0>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%rcx
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x28(%rbp)
mov    %rcx,(%rax)
jmp    1189 <longarrcpy+0x69>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<longarrcpy>:
push   %r15
push   %r14
push   %rbx
mov    %rdx,%r15
mov    %rsi,%r14
mov    %rdi,%rbx
lea    0x0(,%rsi,8),%rdi
call   1040 <malloc@plt>
mov    %rax,(%r15)
xor    %edi,%edi
test   %rax,%rax
setne  %dil
call   1030 <assert@plt>
test   %r14,%r14
jle    12a3 <longarrcpy+0x183>
mov    (%r15),%rax
lea    (%rax,%r14,8),%rcx
lea    0x8(%rax),%rdx
cmp    %rdx,%rcx
mov    %rdx,%r9
cmova  %rcx,%r9
mov    %rax,%rsi
not    %rsi
add    %rsi,%r9
cmp    $0x18,%r9
jb     1290 <longarrcpy+0x170>
cmp    %rdx,%rcx
cmova  %rcx,%rdx
add    %rsi,%rdx
and    $0xfffffffffffffff8,%rdx
lea    (%rbx,%rdx,1),%rsi
add    $0x8,%rsi
cmp    %rsi,%rax
jae    11a8 <longarrcpy+0x88>
add    %rax,%rdx
add    $0x8,%rdx
cmp    %rbx,%rdx
ja     1290 <longarrcpy+0x170>
shr    $0x3,%r9
add    $0x1,%r9
mov    %r9,%r8
and    $0xfffffffffffffffc,%r8
lea    -0x4(%r8),%rdx
mov    %rdx,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
mov    %edi,%r10d
and    $0x3,%r10d
cmp    $0xc,%rdx
jae    11d7 <longarrcpy+0xb7>
xor    %edx,%edx
jmp    1238 <longarrcpy+0x118>
and    $0xfffffffffffffffc,%rdi
xor    %edx,%edx
nopl   (%rax)
movups (%rbx,%rdx,8),%xmm0
movups 0x10(%rbx,%rdx,8),%xmm1
movups %xmm0,(%rax,%rdx,8)
movups %xmm1,0x10(%rax,%rdx,8)
movups 0x20(%rbx,%rdx,8),%xmm0
movups 0x30(%rbx,%rdx,8),%xmm1
movups %xmm0,0x20(%rax,%rdx,8)
movups %xmm1,0x30(%rax,%rdx,8)
movups 0x40(%rbx,%rdx,8),%xmm0
movups 0x50(%rbx,%rdx,8),%xmm1
movups %xmm0,0x40(%rax,%rdx,8)
movups %xmm1,0x50(%rax,%rdx,8)
movups 0x60(%rbx,%rdx,8),%xmm0
movups 0x70(%rbx,%rdx,8),%xmm1
movups %xmm0,0x60(%rax,%rdx,8)
movups %xmm1,0x70(%rax,%rdx,8)
add    $0x10,%rdx
add    $0xfffffffffffffffc,%rdi
jne    11e0 <longarrcpy+0xc0>
test   %r10,%r10
je     127b <longarrcpy+0x15b>
lea    (%rax,%rdx,8),%rdi
add    $0x10,%rdi
lea    (%rbx,%rdx,8),%rdx
add    $0x10,%rdx
shl    $0x5,%r10
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x10(%rdx,%rsi,1),%xmm0
movups (%rdx,%rsi,1),%xmm1
movups %xmm0,-0x10(%rdi,%rsi,1)
movups %xmm1,(%rdi,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%r10
jne    1260 <longarrcpy+0x140>
cmp    %r8,%r9
je     12a3 <longarrcpy+0x183>
lea    (%rbx,%r8,8),%rbx
lea    (%rax,%r8,8),%rax
nopl   0x0(%rax,%rax,1)
mov    (%rbx),%rdx
add    $0x8,%rbx
mov    %rdx,(%rax)
add    $0x8,%rax
cmp    %rcx,%rax
jb     1290 <longarrcpy+0x170>
pop    %rbx
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
define void @longarrcpy(i64* %0, i64 %1, i64** %2) {
%4 = alloca i64*
%5 = alloca i64
%6 = alloca i64**
%7 = alloca i64*
%8 = alloca i64*
%9 = alloca i64*
store i64* %0, i64** %4
store i64 %1, i64* %5
store i64** %2, i64*** %6
%10 = load i64*, i64** %4
store i64* %10, i64** %7
%11 = load i64, i64* %5
%12 = mul i64 %11, 8
%13 = call i64* @malloc(i64 %12)
%14 = load i64**, i64*** %6
store i64* %13, i64** %14
%15 = load i64**, i64*** %6
%16 = load i64*, i64** %15
%17 = icmp ne i64* %16, null
%18 = zext i1 %17 to i32
%19 = call i32 @assert(i32 %18)
%20 = load i64**, i64*** %6
%21 = load i64*, i64** %20
%22 = load i64, i64* %5
%23 = getelementptr inbounds i64, i64* %21, i64 %22
store i64* %23, i64** %9
%24 = load i64**, i64*** %6
%25 = load i64*, i64** %24
store i64* %25, i64** %8
br label %26
26: ; preds = %30, %3
%27 = load i64*, i64** %8
%28 = load i64*, i64** %9
%29 = icmp ult i64* %27, %28
br i1 %29, label %30, label %36
30: ; preds = %26
%31 = load i64*, i64** %7
%32 = getelementptr inbounds i64, i64* %31, i32 1
store i64* %32, i64** %7
%33 = load i64, i64* %31
%34 = load i64*, i64** %8
%35 = getelementptr inbounds i64, i64* %34, i32 1
store i64* %35, i64** %8
store i64 %33, i64* %34
br label %26
36: ; preds = %26
ret void
}

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