#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 nmultiply(float *dst, float *src, size_t len, float x) {
  int i;
  for (i = 0; i < len; i++) {
    *dst++ = *src++ * x;
  }
}


x86 assembly (clang, -O0):
<nmultiply>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movss  %xmm0,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
movslq -0x20(%rbp),%rax
cmp    -0x18(%rbp),%rax
jae    1163 <nmultiply+0x63>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  (%rax),%xmm0
mulss  -0x1c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x8(%rbp)
movss  %xmm0,(%rax)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    111c <nmultiply+0x1c>
pop    %rbp
ret

x86 assembly (clang, -O2):
<nmultiply>:
test   %rdx,%rdx
je     125f <nmultiply+0x15f>
cmp    $0x8,%rdx
jb     1129 <nmultiply+0x29>
lea    (%rsi,%rdx,4),%rax
cmp    %rdi,%rax
jbe    11cc <nmultiply+0xcc>
lea    (%rdi,%rdx,4),%rax
cmp    %rsi,%rax
jbe    11cc <nmultiply+0xcc>
xor    %r9d,%r9d
mov    %r9,%r8
not    %r8
add    %rdx,%r8
mov    %rdx,%rax
and    $0x3,%rax
je     1170 <nmultiply+0x70>
neg    %rax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  (%rsi),%xmm1
mulss  %xmm0,%xmm1
add    $0x4,%rsi
movss  %xmm1,(%rdi)
add    $0x4,%rdi
add    $0xffffffffffffffff,%rcx
cmp    %rcx,%rax
jne    1150 <nmultiply+0x50>
sub    %rcx,%r9
cmp    $0x3,%r8
jb     125f <nmultiply+0x15f>
sub    %r9,%rdx
xor    %eax,%eax
nop
movss  (%rsi,%rax,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%rdi,%rax,4)
movss  0x4(%rsi,%rax,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0x4(%rdi,%rax,4)
movss  0x8(%rsi,%rax,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0x8(%rdi,%rax,4)
movss  0xc(%rsi,%rax,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0xc(%rdi,%rax,4)
add    $0x4,%rax
cmp    %rax,%rdx
jne    1180 <nmultiply+0x80>
jmp    125f <nmultiply+0x15f>
mov    %rdx,%r9
and    $0xfffffffffffffff8,%r9
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
lea    -0x8(%r9),%rax
mov    %rax,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rax,%rax
je     126d <nmultiply+0x16d>
mov    %r8,%rax
and    $0xfffffffffffffffe,%rax
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movups (%rsi,%rcx,4),%xmm2
movups 0x10(%rsi,%rcx,4),%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,(%rdi,%rcx,4)
movups %xmm3,0x10(%rdi,%rcx,4)
movups 0x20(%rsi,%rcx,4),%xmm2
movups 0x30(%rsi,%rcx,4),%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,0x20(%rdi,%rcx,4)
movups %xmm3,0x30(%rdi,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rax
jne    1200 <nmultiply+0x100>
test   $0x1,%r8b
je     125a <nmultiply+0x15a>
movups (%rsi,%rcx,4),%xmm2
movups 0x10(%rsi,%rcx,4),%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,(%rdi,%rcx,4)
movups %xmm3,0x10(%rdi,%rcx,4)
cmp    %rdx,%r9
jne    1260 <nmultiply+0x160>
ret
lea    (%rdi,%r9,4),%rdi
lea    (%rsi,%r9,4),%rsi
jmp    112c <nmultiply+0x2c>
xor    %ecx,%ecx
test   $0x1,%r8b
jne    1242 <nmultiply+0x142>
jmp    125a <nmultiply+0x15a>

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

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