#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 */
double *calloc(int, int);
int /*<<< orphan*/ free(double *);
double radius_of_gyration(double(**poly_ptr), unsigned int numberofbeads) {
  double *centroid;
  centroid = calloc(3, sizeof(double));
  double rgyr2 = 0.0;
  for (int dim1 = 0; dim1 < (numberofbeads); dim1++) {
    centroid[0] += poly_ptr[dim1][0];
    centroid[1] += poly_ptr[dim1][1];
    centroid[2] += poly_ptr[dim1][2];
  }
  centroid[0] /= (double)(numberofbeads);
  centroid[1] /= (double)(numberofbeads);
  centroid[2] /= (double)(numberofbeads);
  for (int dim1 = 0; dim1 < (numberofbeads); dim1++) {
    rgyr2 +=
        (poly_ptr[dim1][0] - centroid[0]) * (poly_ptr[dim1][0] - centroid[0]) +
        (poly_ptr[dim1][1] - centroid[1]) * (poly_ptr[dim1][1] - centroid[1]) +
        (poly_ptr[dim1][2] - centroid[2]) * (poly_ptr[dim1][2] - centroid[2]);
  }
  rgyr2 /= (double)(numberofbeads);
  free(centroid);
  return rgyr2;
}


x86 assembly (clang, -O0):
<radius_of_gyration>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    $0x3,%edi
mov    $0x8,%esi
call   1040 <calloc@plt>
mov    %rax,-0x18(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jae    11c5 <radius_of_gyration+0xa5>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
addsd  (%rax),%xmm0
movsd  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  0x8(%rax),%xmm0
mov    -0x18(%rbp),%rax
addsd  0x8(%rax),%xmm0
movsd  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  0x10(%rax),%xmm0
mov    -0x18(%rbp),%rax
addsd  0x10(%rax),%xmm0
movsd  %xmm0,0x10(%rax)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1151 <radius_of_gyration+0x31>
mov    -0xc(%rbp),%eax
cvtsi2sd %rax,%xmm1
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
mov    -0xc(%rbp),%eax
cvtsi2sd %rax,%xmm1
mov    -0x18(%rbp),%rax
movsd  0x8(%rax),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%rax)
mov    -0xc(%rbp),%eax
cvtsi2sd %rax,%xmm1
mov    -0x18(%rbp),%rax
movsd  0x10(%rax),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x10(%rax)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0xc(%rbp),%eax
jae    12e8 <radius_of_gyration+0x1c8>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm1
mov    -0x18(%rbp),%rax
subsd  (%rax),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm2
mov    -0x18(%rbp),%rax
subsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  0x8(%rax),%xmm0
mov    -0x18(%rbp),%rax
subsd  0x8(%rax),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  0x8(%rax),%xmm3
mov    -0x18(%rbp),%rax
subsd  0x8(%rax),%xmm3
mulsd  %xmm3,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  0x10(%rax),%xmm0
mov    -0x18(%rbp),%rax
subsd  0x10(%rax),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  0x10(%rax),%xmm2
mov    -0x18(%rbp),%rax
subsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
addsd  -0x20(%rbp),%xmm0
movsd  %xmm0,-0x20(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1218 <radius_of_gyration+0xf8>
mov    -0xc(%rbp),%eax
cvtsi2sd %rax,%xmm1
movsd  -0x20(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x20(%rbp)
mov    -0x18(%rbp),%rdi
call   1030 <free@plt>
movsd  -0x20(%rbp),%xmm0
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<radius_of_gyration>:
push   %rbp
push   %r14
push   %rbx
sub    $0x10,%rsp
mov    %esi,%r14d
mov    %rdi,%rbx
mov    $0x3,%edi
mov    $0x8,%esi
call   1040 <calloc@plt>
mov    %r14d,%r8d
test   %r14d,%r14d
je     1162 <radius_of_gyration+0x42>
movupd (%rax),%xmm1
movsd  0x10(%rax),%xmm0
lea    -0x1(%r8),%rsi
mov    %r8d,%edx
and    $0x3,%edx
cmp    $0x3,%rsi
jae    1170 <radius_of_gyration+0x50>
xor    %esi,%esi
jmp    11d1 <radius_of_gyration+0xb1>
movupd (%rax),%xmm1
movsd  0x10(%rax),%xmm0
jmp    11fb <radius_of_gyration+0xdb>
mov    %r8d,%edi
and    $0xfffffffc,%edi
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
mov    (%rbx,%rsi,8),%rbp
mov    0x8(%rbx,%rsi,8),%rcx
movupd 0x0(%rbp),%xmm2
addpd  %xmm1,%xmm2
addsd  0x10(%rbp),%xmm0
movupd (%rcx),%xmm1
addpd  %xmm2,%xmm1
addsd  0x10(%rcx),%xmm0
mov    0x10(%rbx,%rsi,8),%rcx
movupd (%rcx),%xmm2
addsd  0x10(%rcx),%xmm0
addpd  %xmm1,%xmm2
mov    0x18(%rbx,%rsi,8),%rcx
movupd (%rcx),%xmm1
addpd  %xmm2,%xmm1
addsd  0x10(%rcx),%xmm0
add    $0x4,%rsi
cmp    %rsi,%rdi
jne    1180 <radius_of_gyration+0x60>
test   %rdx,%rdx
je     11fb <radius_of_gyration+0xdb>
lea    (%rbx,%rsi,8),%rsi
xor    %edi,%edi
nopl   0x0(%rax)
mov    (%rsi,%rdi,8),%rbp
movupd 0x0(%rbp),%xmm2
addpd  %xmm2,%xmm1
addsd  0x10(%rbp),%xmm0
add    $0x1,%rdi
cmp    %rdi,%rdx
jne    11e0 <radius_of_gyration+0xc0>
xorps  %xmm2,%xmm2
cvtsi2sd %r8,%xmm2
movapd %xmm2,%xmm3
unpcklpd %xmm2,%xmm3
divpd  %xmm3,%xmm1
movupd %xmm1,(%rax)
divsd  %xmm2,%xmm0
movsd  %xmm0,0x10(%rax)
test   %r14d,%r14d
je     1271 <radius_of_gyration+0x151>
movapd %xmm1,%xmm3
unpckhpd %xmm1,%xmm3
xorpd  %xmm6,%xmm6
xor    %edx,%edx
nop
mov    (%rbx,%rdx,8),%rcx
movsd  (%rcx),%xmm4
movsd  0x8(%rcx),%xmm5
subsd  %xmm1,%xmm4
subsd  %xmm3,%xmm5
mulsd  %xmm5,%xmm5
mulsd  %xmm4,%xmm4
addsd  %xmm5,%xmm4
movsd  0x10(%rcx),%xmm5
subsd  %xmm0,%xmm5
mulsd  %xmm5,%xmm5
addsd  %xmm4,%xmm5
addsd  %xmm5,%xmm6
add    $0x1,%rdx
cmp    %rdx,%r8
jne    1230 <radius_of_gyration+0x110>
jmp    1275 <radius_of_gyration+0x155>
xorpd  %xmm6,%xmm6
divsd  %xmm2,%xmm6
movsd  %xmm6,0x8(%rsp)
mov    %rax,%rdi
call   1030 <free@plt>
movsd  0x8(%rsp),%xmm0
add    $0x10,%rsp
pop    %rbx
pop    %r14
pop    %rbp
ret

LLVM IR (-O0):
define double @radius_of_gyration(double** %0, i32 %1) {
%3 = alloca double**
%4 = alloca i32
%5 = alloca double*
%6 = alloca double
%7 = alloca i32
%8 = alloca i32
store double** %0, double*** %3
store i32 %1, i32* %4
%9 = call double* @calloc(i32 3, i32 8)
store double* %9, double** %5
store double 0.000000e+00, double* %6
store i32 0, i32* %7
br label %10
10: ; preds = %48, %2
%11 = load i32, i32* %7
%12 = load i32, i32* %4
%13 = icmp ult i32 %11, %12
br i1 %13, label %14, label %51
14: ; preds = %10
%15 = load double**, double*** %3
%16 = load i32, i32* %7
%17 = sext i32 %16 to i64
%18 = getelementptr inbounds double*, double** %15, i64 %17
%19 = load double*, double** %18
%20 = getelementptr inbounds double, double* %19, i64 0
%21 = load double, double* %20
%22 = load double*, double** %5
%23 = getelementptr inbounds double, double* %22, i64 0
%24 = load double, double* %23
%25 = fadd double %24, %21
store double %25, double* %23
%26 = load double**, double*** %3
%27 = load i32, i32* %7
%28 = sext i32 %27 to i64
%29 = getelementptr inbounds double*, double** %26, i64 %28
%30 = load double*, double** %29
%31 = getelementptr inbounds double, double* %30, i64 1
%32 = load double, double* %31
%33 = load double*, double** %5
%34 = getelementptr inbounds double, double* %33, i64 1
%35 = load double, double* %34
%36 = fadd double %35, %32
store double %36, double* %34
%37 = load double**, double*** %3
%38 = load i32, i32* %7
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds double*, double** %37, i64 %39
%41 = load double*, double** %40
%42 = getelementptr inbounds double, double* %41, i64 2
%43 = load double, double* %42
%44 = load double*, double** %5
%45 = getelementptr inbounds double, double* %44, i64 2
%46 = load double, double* %45
%47 = fadd double %46, %43
store double %47, double* %45
br label %48
48: ; preds = %14
%49 = load i32, i32* %7
%50 = add nsw i32 %49, 1
store i32 %50, i32* %7
br label %10
51: ; preds = %10
%52 = load i32, i32* %4
%53 = uitofp i32 %52 to double
%54 = load double*, double** %5
%55 = getelementptr inbounds double, double* %54, i64 0
%56 = load double, double* %55
%57 = fdiv double %56, %53
store double %57, double* %55
%58 = load i32, i32* %4
%59 = uitofp i32 %58 to double
%60 = load double*, double** %5
%61 = getelementptr inbounds double, double* %60, i64 1
%62 = load double, double* %61
%63 = fdiv double %62, %59
store double %63, double* %61
%64 = load i32, i32* %4
%65 = uitofp i32 %64 to double
%66 = load double*, double** %5
%67 = getelementptr inbounds double, double* %66, i64 2
%68 = load double, double* %67
%69 = fdiv double %68, %65
store double %69, double* %67
store i32 0, i32* %8
br label %70
70: ; preds = %146, %51
%71 = load i32, i32* %8
%72 = load i32, i32* %4
%73 = icmp ult i32 %71, %72
br i1 %73, label %74, label %149
74: ; preds = %70
%75 = load double**, double*** %3
%76 = load i32, i32* %8
%77 = sext i32 %76 to i64
%78 = getelementptr inbounds double*, double** %75, i64 %77
%79 = load double*, double** %78
%80 = getelementptr inbounds double, double* %79, i64 0
%81 = load double, double* %80
%82 = load double*, double** %5
%83 = getelementptr inbounds double, double* %82, i64 0
%84 = load double, double* %83
%85 = fsub double %81, %84
%86 = load double**, double*** %3
%87 = load i32, i32* %8
%88 = sext i32 %87 to i64
%89 = getelementptr inbounds double*, double** %86, i64 %88
%90 = load double*, double** %89
%91 = getelementptr inbounds double, double* %90, i64 0
%92 = load double, double* %91
%93 = load double*, double** %5
%94 = getelementptr inbounds double, double* %93, i64 0
%95 = load double, double* %94
%96 = fsub double %92, %95
%97 = load double**, double*** %3
%98 = load i32, i32* %8
%99 = sext i32 %98 to i64
%100 = getelementptr inbounds double*, double** %97, i64 %99
%101 = load double*, double** %100
%102 = getelementptr inbounds double, double* %101, i64 1
%103 = load double, double* %102
%104 = load double*, double** %5
%105 = getelementptr inbounds double, double* %104, i64 1
%106 = load double, double* %105
%107 = fsub double %103, %106
%108 = load double**, double*** %3
%109 = load i32, i32* %8
%110 = sext i32 %109 to i64
%111 = getelementptr inbounds double*, double** %108, i64 %110
%112 = load double*, double** %111
%113 = getelementptr inbounds double, double* %112, i64 1
%114 = load double, double* %113
%115 = load double*, double** %5
%116 = getelementptr inbounds double, double* %115, i64 1
%117 = load double, double* %116
%118 = fsub double %114, %117
%119 = fmul double %107, %118
%120 = call double @llvm.fmuladd.f64(double %85, double %96, double %119)
%121 = load double**, double*** %3
%122 = load i32, i32* %8
%123 = sext i32 %122 to i64
%124 = getelementptr inbounds double*, double** %121, i64 %123
%125 = load double*, double** %124
%126 = getelementptr inbounds double, double* %125, i64 2
%127 = load double, double* %126
%128 = load double*, double** %5
%129 = getelementptr inbounds double, double* %128, i64 2
%130 = load double, double* %129
%131 = fsub double %127, %130
%132 = load double**, double*** %3
%133 = load i32, i32* %8
%134 = sext i32 %133 to i64
%135 = getelementptr inbounds double*, double** %132, i64 %134
%136 = load double*, double** %135
%137 = getelementptr inbounds double, double* %136, i64 2
%138 = load double, double* %137
%139 = load double*, double** %5
%140 = getelementptr inbounds double, double* %139, i64 2
%141 = load double, double* %140
%142 = fsub double %138, %141
%143 = call double @llvm.fmuladd.f64(double %131, double %142, double %120)
%144 = load double, double* %6
%145 = fadd double %144, %143
store double %145, double* %6
br label %146
146: ; preds = %74
%147 = load i32, i32* %8
%148 = add nsw i32 %147, 1
store i32 %148, i32* %8
br label %70
149: ; preds = %70
%150 = load i32, i32* %4
%151 = uitofp i32 %150 to double
%152 = load double, double* %6
%153 = fdiv double %152, %151
store double %153, double* %6
%154 = load double*, double** %5
%155 = call i32 @free(double* %154)
%156 = load double, double* %6
ret double %156
}

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