#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*/ free(double *);
scalar_t__ malloc(int);
void sum_squares(double *x, int *nr, int *nc, int *k, int *cluster,
                 double *centers, double *totss, double *withiness) {
  int i, j;
  double *global_average = (double *)malloc(*nc * sizeof(double));
  for (j = 0; j < *nc; ++j) {
    global_average[j] = 0.0;
  }
  for (i = 0; i < *nr; ++i) {
    for (j = 0; j < *nc; ++j) {
      global_average[j] += x[j * (*nr) + i];
    }
  }
  for (j = 0; j < *nc; ++j) {
    global_average[j] = global_average[j] / (*nr);
  }
  *totss = 0.0;
  double tmp_ss, temp;
  for (i = 0; i < (*nr); ++i) {
    tmp_ss = 0.0;
    for (j = 0; j < (*nc); ++j) {
      temp = global_average[j] - x[j * (*nr) + i];
      tmp_ss += temp * temp;
    }
    *totss += tmp_ss;
  }
  int t;
  for (t = 0; t < (*k); ++t) {
    withiness[t] = 0.0;
  }
  for (i = 0; i < (*nr); ++i) {
    tmp_ss = 0;
    for (j = 0; j < (*nc); ++j) {
      temp = x[j * (*nr) + i] - centers[j * (*k) + cluster[i]];
      tmp_ss += temp * temp;
    }
    withiness[cluster[i]] += tmp_ss;
  }
  free(global_average);
  return;
}


x86 assembly (clang, -O0):
<sum_squares>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    -0x18(%rbp),%rax
movslq (%rax),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x18(%rbp),%rcx
cmp    (%rcx),%eax
jge    1192 <sum_squares+0x72>
mov    -0x40(%rbp),%rax
movslq -0x38(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1165 <sum_squares+0x45>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x10(%rbp),%rcx
cmp    (%rcx),%eax
jge    120a <sum_squares+0xea>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x18(%rbp),%rcx
cmp    (%rcx),%eax
jge    11f7 <sum_squares+0xd7>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    -0x10(%rbp),%rdx
imul   (%rdx),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x38(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    11af <sum_squares+0x8f>
jmp    11fc <sum_squares+0xdc>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1199 <sum_squares+0x79>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x18(%rbp),%rcx
cmp    (%rcx),%eax
jge    1254 <sum_squares+0x134>
mov    -0x40(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
cvtsi2sdl (%rax),%xmm1
divsd  %xmm1,%xmm0
mov    -0x40(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1211 <sum_squares+0xf1>
mov    0x10(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x10(%rbp),%rcx
cmp    (%rcx),%eax
jge    1307 <sum_squares+0x1e7>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x18(%rbp),%rcx
cmp    (%rcx),%eax
jge    12e8 <sum_squares+0x1c8>
mov    -0x40(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    -0x10(%rbp),%rdx
imul   (%rdx),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm2
movsd  -0x48(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1284 <sum_squares+0x164>
movsd  -0x48(%rbp),%xmm0
mov    0x10(%rbp),%rax
addsd  (%rax),%xmm0
movsd  %xmm0,(%rax)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1266 <sum_squares+0x146>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
mov    -0x20(%rbp),%rcx
cmp    (%rcx),%eax
jge    133b <sum_squares+0x21b>
mov    0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    130e <sum_squares+0x1ee>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x10(%rbp),%rcx
cmp    (%rcx),%eax
jge    1405 <sum_squares+0x2e5>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x18(%rbp),%rcx
cmp    (%rcx),%eax
jge    13d8 <sum_squares+0x2b8>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    -0x10(%rbp),%rdx
imul   (%rdx),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    -0x20(%rbp),%rdx
imul   (%rdx),%ecx
mov    -0x28(%rbp),%rdx
movslq -0x34(%rbp),%rsi
add    (%rdx,%rsi,4),%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm2
movsd  -0x48(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1360 <sum_squares+0x240>
movsd  -0x48(%rbp),%xmm0
mov    0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movslq -0x34(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1342 <sum_squares+0x222>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<sum_squares>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %r9,0x10(%rsp)
mov    %r8,0x20(%rsp)
mov    %rcx,0x18(%rsp)
mov    %rdx,%r14
mov    %rsi,%rbp
mov    %rdi,%r12
mov    0x68(%rsp),%r13
mov    0x60(%rsp),%r15
mov    (%rdx),%edi
shl    $0x3,%edi
call   1050 <malloc@plt>
mov    %rax,%rbx
mov    (%r14),%r14d
test   %r14d,%r14d
jle    1187 <sum_squares+0x57>
lea    0x0(,%r14,8),%rdx
mov    %rbx,%rdi
xor    %esi,%esi
call   1040 <memset@plt>
mov    0x0(%rbp),%ebp
test   %ebp,%ebp
jle    122d <sum_squares+0xfd>
mov    %r14d,%eax
and    $0xfffffffe,%eax
mov    %rbp,%rcx
shl    $0x4,%rcx
xor    %edx,%edx
mov    %r12,%r8
jmp    11bd <sum_squares+0x8d>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rdx
add    $0x8,%r8
cmp    %rbp,%rdx
je     122d <sum_squares+0xfd>
test   %r14d,%r14d
jle    11b0 <sum_squares+0x80>
cmp    $0x1,%r14d
jne    11d0 <sum_squares+0xa0>
xor    %edi,%edi
jmp    120b <sum_squares+0xdb>
nopl   0x0(%rax)
mov    %r8,%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rsi),%xmm0
addsd  (%rbx,%rdi,8),%xmm0
movsd  %xmm0,(%rbx,%rdi,8)
movsd  (%rsi,%rbp,8),%xmm0
addsd  0x8(%rbx,%rdi,8),%xmm0
movsd  %xmm0,0x8(%rbx,%rdi,8)
add    $0x2,%rdi
add    %rcx,%rsi
cmp    %rdi,%rax
jne    11e0 <sum_squares+0xb0>
test   $0x1,%r14b
je     11b0 <sum_squares+0x80>
mov    %rdi,%rsi
imul   %rbp,%rsi
add    %rdx,%rsi
movsd  (%r12,%rsi,8),%xmm0
addsd  (%rbx,%rdi,8),%xmm0
movsd  %xmm0,(%rbx,%rdi,8)
jmp    11b0 <sum_squares+0x80>
test   %r14d,%r14d
jle    12d7 <sum_squares+0x1a7>
xorps  %xmm0,%xmm0
cvtsi2sd %ebp,%xmm0
cmp    $0x1,%r14d
jne    1247 <sum_squares+0x117>
xor    %eax,%eax
jmp    12c0 <sum_squares+0x190>
mov    %r14d,%eax
and    $0xfffffffe,%eax
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    -0x2(%rax),%rdx
mov    %rdx,%rcx
shr    %rcx
add    $0x1,%rcx
test   %rdx,%rdx
je     14e6 <sum_squares+0x3b6>
mov    %rcx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nop
movupd (%rbx,%rdx,8),%xmm2
movupd 0x10(%rbx,%rdx,8),%xmm3
divpd  %xmm1,%xmm2
movupd %xmm2,(%rbx,%rdx,8)
divpd  %xmm1,%xmm3
movupd %xmm3,0x10(%rbx,%rdx,8)
add    $0x4,%rdx
add    $0xfffffffffffffffe,%rsi
jne    1280 <sum_squares+0x150>
test   $0x1,%cl
je     12bb <sum_squares+0x18b>
movupd (%rbx,%rdx,8),%xmm2
divpd  %xmm1,%xmm2
movupd %xmm2,(%rbx,%rdx,8)
cmp    %r14,%rax
je     12d7 <sum_squares+0x1a7>
movsd  (%rbx,%rax,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%rbx,%rax,8)
add    $0x1,%rax
cmp    %rax,%r14
jne    12c0 <sum_squares+0x190>
movq   $0x0,(%r15)
test   %ebp,%ebp
jle    13ad <sum_squares+0x27d>
mov    %r14d,%eax
and    $0xfffffffe,%eax
mov    %rbp,%rcx
shl    $0x4,%rcx
xorpd  %xmm0,%xmm0
xor    %edx,%edx
mov    %r12,%r8
jmp    131a <sum_squares+0x1ea>
xchg   %ax,%ax
addsd  %xmm1,%xmm0
movsd  %xmm0,(%r15)
add    $0x1,%rdx
add    $0x8,%r8
cmp    %rbp,%rdx
je     13ad <sum_squares+0x27d>
xorpd  %xmm1,%xmm1
test   %r14d,%r14d
jle    1300 <sum_squares+0x1d0>
cmp    $0x1,%r14d
jne    1340 <sum_squares+0x210>
xorpd  %xmm1,%xmm1
xor    %edi,%edi
jmp    1384 <sum_squares+0x254>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xorpd  %xmm2,%xmm2
mov    %r8,%rsi
xor    %edi,%edi
nopl   0x0(%rax)
movsd  (%rbx,%rdi,8),%xmm3
movsd  0x8(%rbx,%rdi,8),%xmm1
subsd  (%rsi),%xmm3
mulsd  %xmm3,%xmm3
addsd  %xmm2,%xmm3
subsd  (%rsi,%rbp,8),%xmm1
mulsd  %xmm1,%xmm1
addsd  %xmm3,%xmm1
add    $0x2,%rdi
add    %rcx,%rsi
movapd %xmm1,%xmm2
cmp    %rdi,%rax
jne    1350 <sum_squares+0x220>
test   $0x1,%r14b
je     1300 <sum_squares+0x1d0>
movsd  (%rbx,%rdi,8),%xmm2
imul   %rbp,%rdi
add    %rdx,%rdi
subsd  (%r12,%rdi,8),%xmm2
mulsd  %xmm2,%xmm2
addsd  %xmm2,%xmm1
jmp    1300 <sum_squares+0x1d0>
mov    %r12,0x8(%rsp)
mov    0x18(%rsp),%rax
mov    (%rax),%r15d
test   %r15d,%r15d
jle    13d1 <sum_squares+0x2a1>
lea    0x0(,%r15,8),%rdx
mov    %r13,%rdi
xor    %esi,%esi
call   1040 <memset@plt>
test   %ebp,%ebp
jle    14d0 <sum_squares+0x3a0>
movslq %r15d,%r8
mov    %r14d,%r11d
and    $0xfffffffe,%r11d
mov    %rbp,%r15
shl    $0x4,%r15
mov    %r8,%rsi
shl    $0x4,%rsi
xor    %r10d,%r10d
mov    0x8(%rsp),%r12
jmp    1423 <sum_squares+0x2f3>
nopl   0x0(%rax,%rax,1)
xorpd  %xmm0,%xmm0
addsd  0x0(%r13,%rax,8),%xmm0
movsd  %xmm0,0x0(%r13,%rax,8)
add    $0x1,%r10
add    $0x8,%r12
cmp    %rbp,%r10
je     14d0 <sum_squares+0x3a0>
mov    0x20(%rsp),%rax
movslq (%rax,%r10,4),%rax
test   %r14d,%r14d
jle    1400 <sum_squares+0x2d0>
cmp    $0x1,%r14d
jne    1440 <sum_squares+0x310>
xorpd  %xmm0,%xmm0
xor    %edi,%edi
jmp    1494 <sum_squares+0x364>
nop
lea    (%r8,%rax,1),%rcx
xorpd  %xmm0,%xmm0
mov    0x10(%rsp),%rdx
mov    %r12,%r9
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%r9),%xmm1
subsd  (%rdx,%rax,8),%xmm1
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  (%r9,%rbp,8),%xmm0
subsd  (%rdx,%rcx,8),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
add    $0x2,%rdi
add    %r15,%r9
add    %rsi,%rdx
cmp    %rdi,%r11
jne    1460 <sum_squares+0x330>
test   $0x1,%r14b
je     1404 <sum_squares+0x2d4>
mov    %rdi,%rcx
imul   %rbp,%rcx
add    %r10,%rcx
mov    0x8(%rsp),%rdx
movsd  (%rdx,%rcx,8),%xmm1
imul   %r8,%rdi
add    %rax,%rdi
mov    0x10(%rsp),%rcx
subsd  (%rcx,%rdi,8),%xmm1
mulsd  %xmm1,%xmm1
addsd  %xmm1,%xmm0
jmp    1404 <sum_squares+0x2d4>
mov    %rbx,%rdi
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>
xor    %edx,%edx
test   $0x1,%cl
jne    12ad <sum_squares+0x17d>
jmp    12bb <sum_squares+0x18b>

LLVM IR (-O0):
define void @sum_squares(double* %0, i32* %1, i32* %2, i32* %3, i32* %4, double* %5, double* %6, double* %7) {
%9 = alloca double*
%10 = alloca i32*
%11 = alloca i32*
%12 = alloca i32*
%13 = alloca i32*
%14 = alloca double*
%15 = alloca double*
%16 = alloca double*
%17 = alloca i32
%18 = alloca i32
%19 = alloca double*
%20 = alloca double
%21 = alloca double
%22 = alloca i32
store double* %0, double** %9
store i32* %1, i32** %10
store i32* %2, i32** %11
store i32* %3, i32** %12
store i32* %4, i32** %13
store double* %5, double** %14
store double* %6, double** %15
store double* %7, double** %16
%23 = load i32*, i32** %11
%24 = load i32, i32* %23
%25 = sext i32 %24 to i64
%26 = mul i64 %25, 8
%27 = trunc i64 %26 to i32
%28 = call i64 @malloc(i32 %27)
%29 = inttoptr i64 %28 to double*
store double* %29, double** %19
store i32 0, i32* %18
br label %30
30: ; preds = %40, %8
%31 = load i32, i32* %18
%32 = load i32*, i32** %11
%33 = load i32, i32* %32
%34 = icmp slt i32 %31, %33
br i1 %34, label %35, label %43
35: ; preds = %30
%36 = load double*, double** %19
%37 = load i32, i32* %18
%38 = sext i32 %37 to i64
%39 = getelementptr inbounds double, double* %36, i64 %38
store double 0.000000e+00, double* %39
br label %40
40: ; preds = %35
%41 = load i32, i32* %18
%42 = add nsw i32 %41, 1
store i32 %42, i32* %18
br label %30
43: ; preds = %30
store i32 0, i32* %17
br label %44
44: ; preds = %76, %43
%45 = load i32, i32* %17
%46 = load i32*, i32** %10
%47 = load i32, i32* %46
%48 = icmp slt i32 %45, %47
br i1 %48, label %49, label %79
49: ; preds = %44
store i32 0, i32* %18
br label %50
50: ; preds = %72, %49
%51 = load i32, i32* %18
%52 = load i32*, i32** %11
%53 = load i32, i32* %52
%54 = icmp slt i32 %51, %53
br i1 %54, label %55, label %75
55: ; preds = %50
%56 = load double*, double** %9
%57 = load i32, i32* %18
%58 = load i32*, i32** %10
%59 = load i32, i32* %58
%60 = mul nsw i32 %57, %59
%61 = load i32, i32* %17
%62 = add nsw i32 %60, %61
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds double, double* %56, i64 %63
%65 = load double, double* %64
%66 = load double*, double** %19
%67 = load i32, i32* %18
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds double, double* %66, i64 %68
%70 = load double, double* %69
%71 = fadd double %70, %65
store double %71, double* %69
br label %72
72: ; preds = %55
%73 = load i32, i32* %18
%74 = add nsw i32 %73, 1
store i32 %74, i32* %18
br label %50
75: ; preds = %50
br label %76
76: ; preds = %75
%77 = load i32, i32* %17
%78 = add nsw i32 %77, 1
store i32 %78, i32* %17
br label %44
79: ; preds = %44
store i32 0, i32* %18
br label %80
80: ; preds = %99, %79
%81 = load i32, i32* %18
%82 = load i32*, i32** %11
%83 = load i32, i32* %82
%84 = icmp slt i32 %81, %83
br i1 %84, label %85, label %102
85: ; preds = %80
%86 = load double*, double** %19
%87 = load i32, i32* %18
%88 = sext i32 %87 to i64
%89 = getelementptr inbounds double, double* %86, i64 %88
%90 = load double, double* %89
%91 = load i32*, i32** %10
%92 = load i32, i32* %91
%93 = sitofp i32 %92 to double
%94 = fdiv double %90, %93
%95 = load double*, double** %19
%96 = load i32, i32* %18
%97 = sext i32 %96 to i64
%98 = getelementptr inbounds double, double* %95, i64 %97
store double %94, double* %98
br label %99
99: ; preds = %85
%100 = load i32, i32* %18
%101 = add nsw i32 %100, 1
store i32 %101, i32* %18
br label %80
102: ; preds = %80
%103 = load double*, double** %15
store double 0.000000e+00, double* %103
store i32 0, i32* %17
br label %104
104: ; preds = %144, %102
%105 = load i32, i32* %17
%106 = load i32*, i32** %10
%107 = load i32, i32* %106
%108 = icmp slt i32 %105, %107
br i1 %108, label %109, label %147
109: ; preds = %104
store double 0.000000e+00, double* %20
store i32 0, i32* %18
br label %110
110: ; preds = %136, %109
%111 = load i32, i32* %18
%112 = load i32*, i32** %11
%113 = load i32, i32* %112
%114 = icmp slt i32 %111, %113
br i1 %114, label %115, label %139
115: ; preds = %110
%116 = load double*, double** %19
%117 = load i32, i32* %18
%118 = sext i32 %117 to i64
%119 = getelementptr inbounds double, double* %116, i64 %118
%120 = load double, double* %119
%121 = load double*, double** %9
%122 = load i32, i32* %18
%123 = load i32*, i32** %10
%124 = load i32, i32* %123
%125 = mul nsw i32 %122, %124
%126 = load i32, i32* %17
%127 = add nsw i32 %125, %126
%128 = sext i32 %127 to i64
%129 = getelementptr inbounds double, double* %121, i64 %128
%130 = load double, double* %129
%131 = fsub double %120, %130
store double %131, double* %21
%132 = load double, double* %21
%133 = load double, double* %21
%134 = load double, double* %20
%135 = call double @llvm.fmuladd.f64(double %132, double %133, double %134)
store double %135, double* %20
br label %136
136: ; preds = %115
%137 = load i32, i32* %18
%138 = add nsw i32 %137, 1
store i32 %138, i32* %18
br label %110
139: ; preds = %110
%140 = load double, double* %20
%141 = load double*, double** %15
%142 = load double, double* %141
%143 = fadd double %142, %140
store double %143, double* %141
br label %144
144: ; preds = %139
%145 = load i32, i32* %17
%146 = add nsw i32 %145, 1
store i32 %146, i32* %17
br label %104
147: ; preds = %104
store i32 0, i32* %22
br label %148
148: ; preds = %158, %147
%149 = load i32, i32* %22
%150 = load i32*, i32** %12
%151 = load i32, i32* %150
%152 = icmp slt i32 %149, %151
br i1 %152, label %153, label %161
153: ; preds = %148
%154 = load double*, double** %16
%155 = load i32, i32* %22
%156 = sext i32 %155 to i64
%157 = getelementptr inbounds double, double* %154, i64 %156
store double 0.000000e+00, double* %157
br label %158
158: ; preds = %153
%159 = load i32, i32* %22
%160 = add nsw i32 %159, 1
store i32 %160, i32* %22
br label %148
161: ; preds = %148
store i32 0, i32* %17
br label %162
162: ; preds = %218, %161
%163 = load i32, i32* %17
%164 = load i32*, i32** %10
%165 = load i32, i32* %164
%166 = icmp slt i32 %163, %165
br i1 %166, label %167, label %221
167: ; preds = %162
store double 0.000000e+00, double* %20
store i32 0, i32* %18
br label %168
168: ; preds = %203, %167
%169 = load i32, i32* %18
%170 = load i32*, i32** %11
%171 = load i32, i32* %170
%172 = icmp slt i32 %169, %171
br i1 %172, label %173, label %206
173: ; preds = %168
%174 = load double*, double** %9
%175 = load i32, i32* %18
%176 = load i32*, i32** %10
%177 = load i32, i32* %176
%178 = mul nsw i32 %175, %177
%179 = load i32, i32* %17
%180 = add nsw i32 %178, %179
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds double, double* %174, i64 %181
%183 = load double, double* %182
%184 = load double*, double** %14
%185 = load i32, i32* %18
%186 = load i32*, i32** %12
%187 = load i32, i32* %186
%188 = mul nsw i32 %185, %187
%189 = load i32*, i32** %13
%190 = load i32, i32* %17
%191 = sext i32 %190 to i64
%192 = getelementptr inbounds i32, i32* %189, i64 %191
%193 = load i32, i32* %192
%194 = add nsw i32 %188, %193
%195 = sext i32 %194 to i64
%196 = getelementptr inbounds double, double* %184, i64 %195
%197 = load double, double* %196
%198 = fsub double %183, %197
store double %198, double* %21
%199 = load double, double* %21
%200 = load double, double* %21
%201 = load double, double* %20
%202 = call double @llvm.fmuladd.f64(double %199, double %200, double %201)
store double %202, double* %20
br label %203
203: ; preds = %173
%204 = load i32, i32* %18
%205 = add nsw i32 %204, 1
store i32 %205, i32* %18
br label %168
206: ; preds = %168
%207 = load double, double* %20
%208 = load double*, double** %16
%209 = load i32*, i32** %13
%210 = load i32, i32* %17
%211 = sext i32 %210 to i64
%212 = getelementptr inbounds i32, i32* %209, i64 %211
%213 = load i32, i32* %212
%214 = sext i32 %213 to i64
%215 = getelementptr inbounds double, double* %208, i64 %214
%216 = load double, double* %215
%217 = fadd double %216, %207
store double %217, double* %215
br label %218
218: ; preds = %206
%219 = load i32, i32* %17
%220 = add nsw i32 %219, 1
store i32 %220, i32* %17
br label %162
221: ; preds = %162
%222 = load double*, double** %19
%223 = call i32 @free(double* %222)
ret void
}

LLVM IR (-O2):
define void @sum_squares(double* nocapture %0, i32* nocapture %1, i32* nocapture %2, i32* nocapture %3, i32* nocapture %4, double* nocapture %5, double* nocapture %6, double* nocapture %7) {
%9 = bitcast double* %7 to i8*
%10 = load i32, i32* %2
%11 = shl i32 %10, 3
%12 = tail call i64 @malloc(i32 %11)
%13 = inttoptr i64 %12 to double*
%14 = load i32, i32* %2
%15 = icmp sgt i32 %14, 0
br i1 %15, label %16, label %20
16: ; preds = %8
%17 = inttoptr i64 %12 to i8*
%18 = zext i32 %14 to i64
%19 = shl nuw nsw i64 %18, 3
br label %20
20: ; preds = %16, %8
%21 = load i32, i32* %1
%22 = icmp sgt i32 %21, 0
br i1 %22, label %23, label %34
23: ; preds = %20
%24 = zext i32 %21 to i64
%25 = zext i32 %21 to i64
%26 = zext i32 %14 to i64
%27 = and i64 %26, 1
%28 = icmp eq i32 %14, 1
%29 = and i64 %26, 4294967294
%30 = icmp eq i64 %27, 0
br label %31
31: ; preds = %23, %111
%32 = phi i64 [ 0, %23 ], [ %112, %111 ]
br i1 %15, label %33, label %111
33: ; preds = %31
br i1 %28, label %101, label %80
34: ; preds = %111, %20
br i1 %15, label %35, label %121
35: ; preds = %34
%36 = sitofp i32 %21 to double
%37 = zext i32 %14 to i64
%38 = icmp eq i32 %14, 1
br i1 %38, label %78, label %39
39: ; preds = %35
%40 = and i64 %37, 4294967294
%41 = insertelement <2 x double> poison, double %36, i64 0
%42 = shufflevector <2 x double> %41, <2 x double> poison, <2 x i32> zeroinitializer
%43 = add nsw i64 %40, -2
%44 = lshr exact i64 %43, 1
%45 = add nuw i64 %44, 1
%46 = and i64 %45, 1
%47 = icmp eq i64 %43, 0
br i1 %47, label %67, label %48
48: ; preds = %39
%49 = and i64 %45, -2
br label %50
50: ; preds = %50, %48
%51 = phi i64 [ 0, %48 ], [ %64, %50 ]
%52 = phi i64 [ 0, %48 ], [ %65, %50 ]
%53 = getelementptr inbounds double, double* %13, i64 %51
%54 = bitcast double* %53 to <2 x double>*
%55 = load <2 x double>, <2 x double>* %54
%56 = fdiv <2 x double> %55, %42
%57 = bitcast double* %53 to <2 x double>*
store <2 x double> %56, <2 x double>* %57
%58 = or i64 %51, 2
%59 = getelementptr inbounds double, double* %13, i64 %58
%60 = bitcast double* %59 to <2 x double>*
%61 = load <2 x double>, <2 x double>* %60
%62 = fdiv <2 x double> %61, %42
%63 = bitcast double* %59 to <2 x double>*
store <2 x double> %62, <2 x double>* %63
%64 = add nuw i64 %51, 4
%65 = add nuw i64 %52, 2
%66 = icmp eq i64 %65, %49
br i1 %66, label %67, label %50
67: ; preds = %50, %39
%68 = phi i64 [ 0, %39 ], [ %64, %50 ]
%69 = icmp eq i64 %46, 0
br i1 %69, label %76, label %70
70: ; preds = %67
%71 = getelementptr inbounds double, double* %13, i64 %68
%72 = bitcast double* %71 to <2 x double>*
%73 = load <2 x double>, <2 x double>* %72
%74 = fdiv <2 x double> %73, %42
%75 = bitcast double* %71 to <2 x double>*
store <2 x double> %74, <2 x double>* %75
br label %76
76: ; preds = %67, %70
%77 = icmp eq i64 %40, %37
br i1 %77, label %121, label %78
78: ; preds = %35, %76
%79 = phi i64 [ 0, %35 ], [ %40, %76 ]
br label %114
80: ; preds = %33, %80
%81 = phi i64 [ %98, %80 ], [ 0, %33 ]
%82 = phi i64 [ %99, %80 ], [ 0, %33 ]
%83 = mul nsw i64 %81, %24
%84 = add nuw nsw i64 %83, %32
%85 = getelementptr inbounds double, double* %0, i64 %84
%86 = load double, double* %85
%87 = getelementptr inbounds double, double* %13, i64 %81
%88 = load double, double* %87
%89 = fadd double %86, %88
store double %89, double* %87
%90 = or i64 %81, 1
%91 = mul nsw i64 %90, %24
%92 = add nuw nsw i64 %91, %32
%93 = getelementptr inbounds double, double* %0, i64 %92
%94 = load double, double* %93
%95 = getelementptr inbounds double, double* %13, i64 %90
%96 = load double, double* %95
%97 = fadd double %94, %96
store double %97, double* %95
%98 = add nuw nsw i64 %81, 2
%99 = add i64 %82, 2
%100 = icmp eq i64 %99, %29
br i1 %100, label %101, label %80
101: ; preds = %80, %33
%102 = phi i64 [ 0, %33 ], [ %98, %80 ]
br i1 %30, label %111, label %103
103: ; preds = %101
%104 = mul nsw i64 %102, %24
%105 = add nuw nsw i64 %104, %32
%106 = getelementptr inbounds double, double* %0, i64 %105
%107 = load double, double* %106
%108 = getelementptr inbounds double, double* %13, i64 %102
%109 = load double, double* %108
%110 = fadd double %107, %109
store double %110, double* %108
br label %111
111: ; preds = %103, %101, %31
%112 = add nuw nsw i64 %32, 1
%113 = icmp eq i64 %112, %25
br i1 %113, label %34, label %31
114: ; preds = %78, %114
%115 = phi i64 [ %119, %114 ], [ %79, %78 ]
%116 = getelementptr inbounds double, double* %13, i64 %115
%117 = load double, double* %116
%118 = fdiv double %117, %36
store double %118, double* %116
%119 = add nuw nsw i64 %115, 1
%120 = icmp eq i64 %119, %37
br i1 %120, label %121, label %114
121: ; preds = %114, %76, %34
store double 0.000000e+00, double* %6
br i1 %22, label %122, label %134
122: ; preds = %121
%123 = zext i32 %21 to i64
%124 = zext i32 %21 to i64
%125 = zext i32 %14 to i64
%126 = and i64 %125, 1
%127 = icmp eq i32 %14, 1
%128 = and i64 %125, 4294967294
%129 = icmp eq i64 %126, 0
br label %130
130: ; preds = %122, %177
%131 = phi double [ 0.000000e+00, %122 ], [ %179, %177 ]
%132 = phi i64 [ 0, %122 ], [ %180, %177 ]
br i1 %15, label %133, label %177
133: ; preds = %130
br i1 %127, label %164, label %140
134: ; preds = %177, %121
%135 = load i32, i32* %3
%136 = icmp sgt i32 %135, 0
br i1 %136, label %137, label %182
137: ; preds = %134
%138 = zext i32 %135 to i64
%139 = shl nuw nsw i64 %138, 3
br label %182
140: ; preds = %133, %140
%141 = phi i64 [ %161, %140 ], [ 0, %133 ]
%142 = phi double [ %160, %140 ], [ 0.000000e+00, %133 ]
%143 = phi i64 [ %162, %140 ], [ 0, %133 ]
%144 = getelementptr inbounds double, double* %13, i64 %141
%145 = load double, double* %144
%146 = mul nsw i64 %141, %123
%147 = add nuw nsw i64 %146, %132
%148 = getelementptr inbounds double, double* %0, i64 %147
%149 = load double, double* %148
%150 = fsub double %145, %149
%151 = tail call double @llvm.fmuladd.f64(double %150, double %150, double %142)
%152 = or i64 %141, 1
%153 = getelementptr inbounds double, double* %13, i64 %152
%154 = load double, double* %153
%155 = mul nsw i64 %152, %123
%156 = add nuw nsw i64 %155, %132
%157 = getelementptr inbounds double, double* %0, i64 %156
%158 = load double, double* %157
%159 = fsub double %154, %158
%160 = tail call double @llvm.fmuladd.f64(double %159, double %159, double %151)
%161 = add nuw nsw i64 %141, 2
%162 = add i64 %143, 2
%163 = icmp eq i64 %162, %128
br i1 %163, label %164, label %140
164: ; preds = %140, %133
%165 = phi double [ undef, %133 ], [ %160, %140 ]
%166 = phi i64 [ 0, %133 ], [ %161, %140 ]
%167 = phi double [ 0.000000e+00, %133 ], [ %160, %140 ]
br i1 %129, label %177, label %168
168: ; preds = %164
%169 = getelementptr inbounds double, double* %13, i64 %166
%170 = load double, double* %169
%171 = mul nsw i64 %166, %123
%172 = add nuw nsw i64 %171, %132
%173 = getelementptr inbounds double, double* %0, i64 %172
%174 = load double, double* %173
%175 = fsub double %170, %174
%176 = tail call double @llvm.fmuladd.f64(double %175, double %175, double %167)
br label %177
177: ; preds = %168, %164, %130
%178 = phi double [ 0.000000e+00, %130 ], [ %165, %164 ], [ %176, %168 ]
%179 = fadd double %178, %131
store double %179, double* %6
%180 = add nuw nsw i64 %132, 1
%181 = icmp eq i64 %180, %124
br i1 %181, label %134, label %130
182: ; preds = %137, %134
br i1 %22, label %183, label %248
183: ; preds = %182
%184 = zext i32 %21 to i64
%185 = sext i32 %135 to i64
%186 = zext i32 %21 to i64
%187 = zext i32 %14 to i64
%188 = and i64 %187, 1
%189 = icmp eq i32 %14, 1
%190 = and i64 %187, 4294967294
%191 = icmp eq i64 %188, 0
br label %192
192: ; preds = %183, %241
%193 = phi i64 [ 0, %183 ], [ %246, %241 ]
%194 = getelementptr inbounds i32, i32* %4, i64 %193
%195 = load i32, i32* %194
%196 = sext i32 %195 to i64
br i1 %15, label %197, label %241
197: ; preds = %192
br i1 %189, label %226, label %198
198: ; preds = %197, %198
%199 = phi i64 [ %223, %198 ], [ 0, %197 ]
%200 = phi double [ %222, %198 ], [ 0.000000e+00, %197 ]
%201 = phi i64 [ %224, %198 ], [ 0, %197 ]
%202 = mul nsw i64 %199, %184
%203 = add nuw nsw i64 %202, %193
%204 = getelementptr inbounds double, double* %0, i64 %203
%205 = load double, double* %204
%206 = mul nsw i64 %199, %185
%207 = add nsw i64 %206, %196
%208 = getelementptr inbounds double, double* %5, i64 %207
%209 = load double, double* %208
%210 = fsub double %205, %209
%211 = tail call double @llvm.fmuladd.f64(double %210, double %210, double %200)
%212 = or i64 %199, 1
%213 = mul nsw i64 %212, %184
%214 = add nuw nsw i64 %213, %193
%215 = getelementptr inbounds double, double* %0, i64 %214
%216 = load double, double* %215
%217 = mul nsw i64 %212, %185
%218 = add nsw i64 %217, %196
%219 = getelementptr inbounds double, double* %5, i64 %218
%220 = load double, double* %219
%221 = fsub double %216, %220
%222 = tail call double @llvm.fmuladd.f64(double %221, double %221, double %211)
%223 = add nuw nsw i64 %199, 2
%224 = add i64 %201, 2
%225 = icmp eq i64 %224, %190
br i1 %225, label %226, label %198
226: ; preds = %198, %197
%227 = phi double [ undef, %197 ], [ %222, %198 ]
%228 = phi i64 [ 0, %197 ], [ %223, %198 ]
%229 = phi double [ 0.000000e+00, %197 ], [ %222, %198 ]
br i1 %191, label %241, label %230
230: ; preds = %226
%231 = mul nsw i64 %228, %184
%232 = add nuw nsw i64 %231, %193
%233 = getelementptr inbounds double, double* %0, i64 %232
%234 = load double, double* %233
%235 = mul nsw i64 %228, %185
%236 = add nsw i64 %235, %196
%237 = getelementptr inbounds double, double* %5, i64 %236
%238 = load double, double* %237
%239 = fsub double %234, %238
%240 = tail call double @llvm.fmuladd.f64(double %239, double %239, double %229)
br label %241
241: ; preds = %230, %226, %192
%242 = phi double [ 0.000000e+00, %192 ], [ %227, %226 ], [ %240, %230 ]
%243 = getelementptr inbounds double, double* %7, i64 %196
%244 = load double, double* %243
%245 = fadd double %242, %244
store double %245, double* %243
%246 = add nuw nsw i64 %193, 1
%247 = icmp eq i64 %246, %186
br i1 %247, label %248, label %192
248: ; preds = %241, %182
%249 = tail call i32 @free(double* %13)
ret void
}