#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 floatarrcpynomalloc(float *in, size_t size, float **out) {
  float *ipt, *opt, *fpt;
  ipt = in;
  fpt = *out + size;
  opt = *out;
  while (opt < fpt)
    *opt++ = *ipt++;
}


x86 assembly (clang, -O0):
<floatarrcpynomalloc>:
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    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    -0x10(%rbp),%rcx
shl    $0x2,%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    1172 <floatarrcpynomalloc+0x72>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x20(%rbp)
movss  (%rax),%xmm0
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x28(%rbp)
movss  %xmm0,(%rax)
jmp    1139 <floatarrcpynomalloc+0x39>
pop    %rbp
ret

x86 assembly (clang, -O2):
<floatarrcpynomalloc>:
test   %rsi,%rsi
jle    1265 <floatarrcpynomalloc+0x165>
mov    (%rdx),%rax
lea    (%rax,%rsi,4),%r11
lea    0x4(%rax),%rdx
cmp    %rdx,%r11
mov    %rdx,%r9
cmova  %r11,%r9
mov    %rax,%rcx
not    %rcx
add    %rcx,%r9
cmp    $0x1c,%r9
jb     1250 <floatarrcpynomalloc+0x150>
cmp    %rdx,%r11
cmova  %r11,%rdx
add    %rcx,%rdx
and    $0xfffffffffffffffc,%rdx
lea    (%rdi,%rdx,1),%rcx
add    $0x4,%rcx
cmp    %rcx,%rax
jae    115d <floatarrcpynomalloc+0x5d>
lea    (%rax,%rdx,1),%rcx
add    $0x4,%rcx
cmp    %rdi,%rcx
ja     1250 <floatarrcpynomalloc+0x150>
shr    $0x2,%r9
add    $0x1,%r9
mov    %r9,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rcx
mov    %rcx,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%r10d
and    $0x3,%r10d
cmp    $0x18,%rcx
jae    118c <floatarrcpynomalloc+0x8c>
xor    %edx,%edx
jmp    11f8 <floatarrcpynomalloc+0xf8>
and    $0xfffffffffffffffc,%rsi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups (%rdi,%rdx,4),%xmm0
movups 0x10(%rdi,%rdx,4),%xmm1
movups %xmm0,(%rax,%rdx,4)
movups %xmm1,0x10(%rax,%rdx,4)
movups 0x20(%rdi,%rdx,4),%xmm0
movups 0x30(%rdi,%rdx,4),%xmm1
movups %xmm0,0x20(%rax,%rdx,4)
movups %xmm1,0x30(%rax,%rdx,4)
movups 0x40(%rdi,%rdx,4),%xmm0
movups 0x50(%rdi,%rdx,4),%xmm1
movups %xmm0,0x40(%rax,%rdx,4)
movups %xmm1,0x50(%rax,%rdx,4)
movups 0x60(%rdi,%rdx,4),%xmm0
movups 0x70(%rdi,%rdx,4),%xmm1
movups %xmm0,0x60(%rax,%rdx,4)
movups %xmm1,0x70(%rax,%rdx,4)
add    $0x20,%rdx
add    $0xfffffffffffffffc,%rsi
jne    11a0 <floatarrcpynomalloc+0xa0>
test   %r10,%r10
je     123b <floatarrcpynomalloc+0x13b>
lea    (%rax,%rdx,4),%rsi
add    $0x10,%rsi
lea    (%rdi,%rdx,4),%rdx
add    $0x10,%rdx
shl    $0x5,%r10
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x10(%rdx,%rcx,1),%xmm0
movups (%rdx,%rcx,1),%xmm1
movups %xmm0,-0x10(%rsi,%rcx,1)
movups %xmm1,(%rsi,%rcx,1)
add    $0x20,%rcx
cmp    %rcx,%r10
jne    1220 <floatarrcpynomalloc+0x120>
cmp    %r8,%r9
je     1265 <floatarrcpynomalloc+0x165>
lea    (%rdi,%r8,4),%rdi
lea    (%rax,%r8,4),%rax
nopl   0x0(%rax,%rax,1)
movss  (%rdi),%xmm0
add    $0x4,%rdi
movss  %xmm0,(%rax)
add    $0x4,%rax
cmp    %r11,%rax
jb     1250 <floatarrcpynomalloc+0x150>
ret

LLVM IR (-O0):
define void @floatarrcpynomalloc(float* %0, i64 %1, float** %2) {
%4 = alloca float*
%5 = alloca i64
%6 = alloca float**
%7 = alloca float*
%8 = alloca float*
%9 = alloca float*
store float* %0, float** %4
store i64 %1, i64* %5
store float** %2, float*** %6
%10 = load float*, float** %4
store float* %10, float** %7
%11 = load float**, float*** %6
%12 = load float*, float** %11
%13 = load i64, i64* %5
%14 = getelementptr inbounds float, float* %12, i64 %13
store float* %14, float** %9
%15 = load float**, float*** %6
%16 = load float*, float** %15
store float* %16, float** %8
br label %17
17: ; preds = %21, %3
%18 = load float*, float** %8
%19 = load float*, float** %9
%20 = icmp ult float* %18, %19
br i1 %20, label %21, label %27
21: ; preds = %17
%22 = load float*, float** %7
%23 = getelementptr inbounds float, float* %22, i32 1
store float* %23, float** %7
%24 = load float, float* %22
%25 = load float*, float** %8
%26 = getelementptr inbounds float, float* %25, i32 1
store float* %26, float** %8
store float %24, float* %25
br label %17
27: ; preds = %17
ret void
}

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