#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*/ potential_double(int *, double *, double *, double *,
                                    double *);
void potential_float(int *ndim, float *pos, float *acc, float *pot,
                     float *time) {
  double dpos[3], dacc[3], dpot, dtime;
  int i;
  for (i = 0; i < *ndim; i++)
    dpos[i] = pos[i];
  dtime = *time;
  potential_double(ndim, dpos, dacc, &dpot, &dtime);
  for (i = 0; i < *ndim; i++)
    acc[i] = dacc[i];
  *pot = dpot;
}


x86 assembly (clang, -O0):
<potential_float>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
mov    -0x8(%rbp),%rcx
cmp    (%rcx),%eax
jge    116e <potential_float+0x5e>
mov    -0x10(%rbp),%rax
movslq -0x74(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movslq -0x74(%rbp),%rax
movsd  %xmm0,-0x40(%rbp,%rax,8)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    1136 <potential_float+0x26>
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x8(%rbp),%rdi
lea    -0x40(%rbp),%rsi
lea    -0x60(%rbp),%rdx
lea    -0x68(%rbp),%rcx
lea    -0x70(%rbp),%r8
call   1030 <potential_double@plt>
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
mov    -0x8(%rbp),%rcx
cmp    (%rcx),%eax
jge    11d7 <potential_float+0xc7>
movslq -0x74(%rbp),%rax
movsd  -0x60(%rbp,%rax,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x74(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    119f <potential_float+0x8f>
movsd  -0x68(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,(%rax)
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<potential_float>:
push   %r15
push   %r14
push   %rbx
sub    $0x50,%rsp
mov    %rcx,%r14
mov    %rdx,%rbx
mov    %rdi,%r15
mov    (%rdi),%eax
test   %eax,%eax
jle    11d8 <potential_float+0xc8>
cmp    $0x4,%eax
jae    1138 <potential_float+0x28>
xor    %ecx,%ecx
jmp    11c0 <potential_float+0xb0>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rdx
mov    %rdx,%r9
shr    $0x2,%r9
add    $0x1,%r9
test   %rdx,%rdx
je     12d0 <potential_float+0x1c0>
mov    %r9,%rdx
and    $0xfffffffffffffffe,%rdx
xor    %edi,%edi
xchg   %ax,%ax
cvtps2pd (%rsi,%rdi,4),%xmm0
cvtps2pd 0x8(%rsi,%rdi,4),%xmm1
movaps %xmm0,0x20(%rsp,%rdi,8)
movaps %xmm1,0x30(%rsp,%rdi,8)
cvtps2pd 0x10(%rsi,%rdi,4),%xmm0
cvtps2pd 0x18(%rsi,%rdi,4),%xmm1
movaps %xmm0,0x40(%rsp,%rdi,8)
movapd %xmm1,0x50(%rsp,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rdx
jne    1160 <potential_float+0x50>
test   $0x1,%r9b
je     11ac <potential_float+0x9c>
cvtps2pd (%rsi,%rdi,4),%xmm0
cvtps2pd 0x8(%rsi,%rdi,4),%xmm1
movaps %xmm0,0x20(%rsp,%rdi,8)
movapd %xmm1,0x30(%rsp,%rdi,8)
cmp    %rax,%rcx
je     11d8 <potential_float+0xc8>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%rsi,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x20(%rsp,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    11c0 <potential_float+0xb0>
movss  (%r8),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x40(%rsp)
lea    0x20(%rsp),%rsi
mov    %rsp,%rdx
lea    0x48(%rsp),%rcx
lea    0x40(%rsp),%r8
mov    %r15,%rdi
call   1030 <potential_double@plt>
mov    (%r15),%eax
test   %eax,%eax
jle    12b7 <potential_float+0x1a7>
cmp    $0x4,%eax
jae    1218 <potential_float+0x108>
xor    %ecx,%ecx
jmp    12a0 <potential_float+0x190>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rsi
mov    %rsi,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rsi,%rsi
je     12e1 <potential_float+0x1d1>
mov    %rdx,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %esi,%esi
xchg   %ax,%ax
cvtpd2ps (%rsp,%rsi,8),%xmm0
cvtpd2ps 0x10(%rsp,%rsi,8),%xmm1
unpcklpd %xmm1,%xmm0
movupd %xmm0,(%rbx,%rsi,4)
cvtpd2ps 0x20(%rsp,%rsi,8),%xmm0
cvtpd2ps 0x30(%rsp,%rsi,8),%xmm1
unpcklpd %xmm1,%xmm0
movupd %xmm0,0x10(%rbx,%rsi,4)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1240 <potential_float+0x130>
test   $0x1,%dl
je     128d <potential_float+0x17d>
cvtpd2ps (%rsp,%rsi,8),%xmm0
cvtpd2ps 0x10(%rsp,%rsi,8),%xmm1
unpcklpd %xmm1,%xmm0
movupd %xmm0,(%rbx,%rsi,4)
cmp    %rax,%rcx
je     12b7 <potential_float+0x1a7>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rsp,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rbx,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    12a0 <potential_float+0x190>
movsd  0x48(%rsp),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%r14)
add    $0x50,%rsp
pop    %rbx
pop    %r14
pop    %r15
ret
xor    %edi,%edi
test   $0x1,%r9b
jne    1198 <potential_float+0x88>
jmp    11ac <potential_float+0x9c>
xor    %esi,%esi
test   $0x1,%dl
jne    1279 <potential_float+0x169>
jmp    128d <potential_float+0x17d>

LLVM IR (-O0):
define void @potential_float(i32* %0, float* %1, float* %2, float* %3, float* %4) {
%6 = alloca i32*
%7 = alloca float*
%8 = alloca float*
%9 = alloca float*
%10 = alloca float*
%11 = alloca [3 x double]
%12 = alloca [3 x double]
%13 = alloca double
%14 = alloca double
%15 = alloca i32
store i32* %0, i32** %6
store float* %1, float** %7
store float* %2, float** %8
store float* %3, float** %9
store float* %4, float** %10
store i32 0, i32* %15
br label %16
16: ; preds = %31, %5
%17 = load i32, i32* %15
%18 = load i32*, i32** %6
%19 = load i32, i32* %18
%20 = icmp slt i32 %17, %19
br i1 %20, label %21, label %34
21: ; preds = %16
%22 = load float*, float** %7
%23 = load i32, i32* %15
%24 = sext i32 %23 to i64
%25 = getelementptr inbounds float, float* %22, i64 %24
%26 = load float, float* %25
%27 = fpext float %26 to double
%28 = load i32, i32* %15
%29 = sext i32 %28 to i64
%30 = getelementptr inbounds [3 x double], [3 x double]* %11, i64 0, i64 %29
store double %27, double* %30
br label %31
31: ; preds = %21
%32 = load i32, i32* %15
%33 = add nsw i32 %32, 1
store i32 %33, i32* %15
br label %16
34: ; preds = %16
%35 = load float*, float** %10
%36 = load float, float* %35
%37 = fpext float %36 to double
store double %37, double* %14
%38 = load i32*, i32** %6
%39 = getelementptr inbounds [3 x double], [3 x double]* %11, i64 0, i64 0
%40 = getelementptr inbounds [3 x double], [3 x double]* %12, i64 0, i64 0
%41 = call i32 @potential_double(i32* %38, double* %39, double* %40, double* %13, double* %14)
store i32 0, i32* %15
br label %42
42: ; preds = %57, %34
%43 = load i32, i32* %15
%44 = load i32*, i32** %6
%45 = load i32, i32* %44
%46 = icmp slt i32 %43, %45
br i1 %46, label %47, label %60
47: ; preds = %42
%48 = load i32, i32* %15
%49 = sext i32 %48 to i64
%50 = getelementptr inbounds [3 x double], [3 x double]* %12, i64 0, i64 %49
%51 = load double, double* %50
%52 = fptrunc double %51 to float
%53 = load float*, float** %8
%54 = load i32, i32* %15
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds float, float* %53, i64 %55
store float %52, float* %56
br label %57
57: ; preds = %47
%58 = load i32, i32* %15
%59 = add nsw i32 %58, 1
store i32 %59, i32* %15
br label %42
60: ; preds = %42
%61 = load double, double* %13
%62 = fptrunc double %61 to float
%63 = load float*, float** %9
store float %62, float* %63
ret void
}

LLVM IR (-O2):
define void @potential_float(i32* %0, float* nocapture %1, float* nocapture writeonly %2, float* nocapture writeonly %3, float* nocapture %4) {
%6 = alloca [3 x double]
%7 = alloca [3 x double]
%8 = alloca double
%9 = alloca double
%10 = bitcast [3 x double]* %6 to i8*
%11 = bitcast [3 x double]* %7 to i8*
%12 = bitcast double* %8 to i8*
%13 = bitcast double* %9 to i8*
%14 = load i32, i32* %0
%15 = icmp sgt i32 %14, 0
br i1 %15, label %16, label %87
16: ; preds = %5
%17 = zext i32 %14 to i64
%18 = icmp ult i32 %14, 4
br i1 %18, label %77, label %19
19: ; preds = %16
%20 = and i64 %17, 4294967292
%21 = add nsw i64 %20, -4
%22 = lshr exact i64 %21, 2
%23 = add nuw nsw i64 %22, 1
%24 = and i64 %23, 1
%25 = icmp eq i64 %21, 0
br i1 %25, label %59, label %26
26: ; preds = %19
%27 = and i64 %23, 9223372036854775806
br label %28
28: ; preds = %28, %26
%29 = phi i64 [ 0, %26 ], [ %56, %28 ]
%30 = phi i64 [ 0, %26 ], [ %57, %28 ]
%31 = getelementptr inbounds float, float* %1, i64 %29
%32 = bitcast float* %31 to <2 x float>*
%33 = load <2 x float>, <2 x float>* %32
%34 = getelementptr inbounds float, float* %31, i64 2
%35 = bitcast float* %34 to <2 x float>*
%36 = load <2 x float>, <2 x float>* %35
%37 = fpext <2 x float> %33 to <2 x double>
%38 = fpext <2 x float> %36 to <2 x double>
%39 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 %29
%40 = bitcast double* %39 to <2 x double>*
store <2 x double> %37, <2 x double>* %40
%41 = getelementptr inbounds double, double* %39, i64 2
%42 = bitcast double* %41 to <2 x double>*
store <2 x double> %38, <2 x double>* %42
%43 = or i64 %29, 4
%44 = getelementptr inbounds float, float* %1, i64 %43
%45 = bitcast float* %44 to <2 x float>*
%46 = load <2 x float>, <2 x float>* %45
%47 = getelementptr inbounds float, float* %44, i64 2
%48 = bitcast float* %47 to <2 x float>*
%49 = load <2 x float>, <2 x float>* %48
%50 = fpext <2 x float> %46 to <2 x double>
%51 = fpext <2 x float> %49 to <2 x double>
%52 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 %43
%53 = bitcast double* %52 to <2 x double>*
store <2 x double> %50, <2 x double>* %53
%54 = getelementptr inbounds double, double* %52, i64 2
%55 = bitcast double* %54 to <2 x double>*
store <2 x double> %51, <2 x double>* %55
%56 = add nuw i64 %29, 8
%57 = add i64 %30, 2
%58 = icmp eq i64 %57, %27
br i1 %58, label %59, label %28
59: ; preds = %28, %19
%60 = phi i64 [ 0, %19 ], [ %56, %28 ]
%61 = icmp eq i64 %24, 0
br i1 %61, label %75, label %62
62: ; preds = %59
%63 = getelementptr inbounds float, float* %1, i64 %60
%64 = bitcast float* %63 to <2 x float>*
%65 = load <2 x float>, <2 x float>* %64
%66 = getelementptr inbounds float, float* %63, i64 2
%67 = bitcast float* %66 to <2 x float>*
%68 = load <2 x float>, <2 x float>* %67
%69 = fpext <2 x float> %65 to <2 x double>
%70 = fpext <2 x float> %68 to <2 x double>
%71 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 %60
%72 = bitcast double* %71 to <2 x double>*
store <2 x double> %69, <2 x double>* %72
%73 = getelementptr inbounds double, double* %71, i64 2
%74 = bitcast double* %73 to <2 x double>*
store <2 x double> %70, <2 x double>* %74
br label %75
75: ; preds = %59, %62
%76 = icmp eq i64 %20, %17
br i1 %76, label %87, label %77
77: ; preds = %16, %75
%78 = phi i64 [ 0, %16 ], [ %20, %75 ]
br label %79
79: ; preds = %77, %79
%80 = phi i64 [ %85, %79 ], [ %78, %77 ]
%81 = getelementptr inbounds float, float* %1, i64 %80
%82 = load float, float* %81
%83 = fpext float %82 to double
%84 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 %80
store double %83, double* %84
%85 = add nuw nsw i64 %80, 1
%86 = icmp eq i64 %85, %17
br i1 %86, label %87, label %79
87: ; preds = %79, %75, %5
%88 = load float, float* %4
%89 = fpext float %88 to double
store double %89, double* %9
%90 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 0
%91 = getelementptr inbounds [3 x double], [3 x double]* %7, i64 0, i64 0
%92 = call i32 @potential_double(i32* %0, double* %90, double* %91, double* %8, double* %9)
%93 = load i32, i32* %0
%94 = icmp sgt i32 %93, 0
br i1 %94, label %95, label %166
95: ; preds = %87
%96 = zext i32 %93 to i64
%97 = icmp ult i32 %93, 4
br i1 %97, label %156, label %98
98: ; preds = %95
%99 = and i64 %96, 4294967292
%100 = add nsw i64 %99, -4
%101 = lshr exact i64 %100, 2
%102 = add nuw nsw i64 %101, 1
%103 = and i64 %102, 1
%104 = icmp eq i64 %100, 0
br i1 %104, label %138, label %105
105: ; preds = %98
%106 = and i64 %102, 9223372036854775806
br label %107
107: ; preds = %107, %105
%108 = phi i64 [ 0, %105 ], [ %135, %107 ]
%109 = phi i64 [ 0, %105 ], [ %136, %107 ]
%110 = getelementptr inbounds [3 x double], [3 x double]* %7, i64 0, i64 %108
%111 = bitcast double* %110 to <2 x double>*
%112 = load <2 x double>, <2 x double>* %111
%113 = getelementptr inbounds double, double* %110, i64 2
%114 = bitcast double* %113 to <2 x double>*
%115 = load <2 x double>, <2 x double>* %114
%116 = fptrunc <2 x double> %112 to <2 x float>
%117 = fptrunc <2 x double> %115 to <2 x float>
%118 = getelementptr inbounds float, float* %2, i64 %108
%119 = bitcast float* %118 to <2 x float>*
store <2 x float> %116, <2 x float>* %119
%120 = getelementptr inbounds float, float* %118, i64 2
%121 = bitcast float* %120 to <2 x float>*
store <2 x float> %117, <2 x float>* %121
%122 = or i64 %108, 4
%123 = getelementptr inbounds [3 x double], [3 x double]* %7, i64 0, i64 %122
%124 = bitcast double* %123 to <2 x double>*
%125 = load <2 x double>, <2 x double>* %124
%126 = getelementptr inbounds double, double* %123, i64 2
%127 = bitcast double* %126 to <2 x double>*
%128 = load <2 x double>, <2 x double>* %127
%129 = fptrunc <2 x double> %125 to <2 x float>
%130 = fptrunc <2 x double> %128 to <2 x float>
%131 = getelementptr inbounds float, float* %2, i64 %122
%132 = bitcast float* %131 to <2 x float>*
store <2 x float> %129, <2 x float>* %132
%133 = getelementptr inbounds float, float* %131, i64 2
%134 = bitcast float* %133 to <2 x float>*
store <2 x float> %130, <2 x float>* %134
%135 = add nuw i64 %108, 8
%136 = add i64 %109, 2
%137 = icmp eq i64 %136, %106
br i1 %137, label %138, label %107
138: ; preds = %107, %98
%139 = phi i64 [ 0, %98 ], [ %135, %107 ]
%140 = icmp eq i64 %103, 0
br i1 %140, label %154, label %141
141: ; preds = %138
%142 = getelementptr inbounds [3 x double], [3 x double]* %7, i64 0, i64 %139
%143 = bitcast double* %142 to <2 x double>*
%144 = load <2 x double>, <2 x double>* %143
%145 = getelementptr inbounds double, double* %142, i64 2
%146 = bitcast double* %145 to <2 x double>*
%147 = load <2 x double>, <2 x double>* %146
%148 = fptrunc <2 x double> %144 to <2 x float>
%149 = fptrunc <2 x double> %147 to <2 x float>
%150 = getelementptr inbounds float, float* %2, i64 %139
%151 = bitcast float* %150 to <2 x float>*
store <2 x float> %148, <2 x float>* %151
%152 = getelementptr inbounds float, float* %150, i64 2
%153 = bitcast float* %152 to <2 x float>*
store <2 x float> %149, <2 x float>* %153
br label %154
154: ; preds = %138, %141
%155 = icmp eq i64 %99, %96
br i1 %155, label %166, label %156
156: ; preds = %95, %154
%157 = phi i64 [ 0, %95 ], [ %99, %154 ]
br label %158
158: ; preds = %156, %158
%159 = phi i64 [ %164, %158 ], [ %157, %156 ]
%160 = getelementptr inbounds [3 x double], [3 x double]* %7, i64 0, i64 %159
%161 = load double, double* %160
%162 = fptrunc double %161 to float
%163 = getelementptr inbounds float, float* %2, i64 %159
store float %162, float* %163
%164 = add nuw nsw i64 %159, 1
%165 = icmp eq i64 %164, %96
br i1 %165, label %166, label %158
166: ; preds = %158, %154, %87
%167 = load double, double* %8
%168 = fptrunc double %167 to float
store float %168, float* %3
ret void
}