#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 */
typedef size_t ssize_t;

/* Variables and functions */
double fabs(double);
int log(double);
double rand0_1();
double *rand_gaussnd(size_t n, const double *L, const double *mean,
                     double *pt) {
  double spt[1024];
  ssize_t i, j;
  double u, v, x, y, q;
  for (i = 0; i < n; i++) {
    do {
      u = rand0_1();
      v = 1.7156 * (rand0_1() - 0.5);
      x = u - 0.449871;
      y = fabs(v) + 0.386595;
      q = x * x + y * (0.19600 * y - 0.25472 * x);
    } while (q > 0.27597 && (q > 0.27846 || v * v > -4. * log(u) * u * u));
    spt[i] = v / u;
  }
  for (i = 0; i < n; i++) {
    pt[i] = 0.0;
    for (j = 0; j <= i; j++)
      pt[i] += L[i * n + j] * spt[j];
    pt[i] += mean[i];
  }
  return pt;
}


x86 assembly (clang, -O0):
<rand_gaussnd>:
push   %rbp
mov    %rsp,%rbp
sub    $0x2070,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
movq   $0x0,-0x2028(%rbp)
mov    -0x2028(%rbp),%rax
cmp    -0x8(%rbp),%rax
jae    1332 <rand_gaussnd+0x212>
jmp    115c <rand_gaussnd+0x3c>
mov    $0x0,%al
call   1030 <rand0_1@plt>
movsd  %xmm0,-0x2038(%rbp)
ff
mov    $0x0,%al
call   1030 <rand0_1@plt>
movaps %xmm0,%xmm1
movsd  0xeab(%rip),%xmm0
subsd  %xmm0,%xmm1
movsd  0xe97(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x2040(%rbp)
ff
movsd  -0x2038(%rbp),%xmm0
ff
movsd  0xe73(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x2048(%rbp)
ff
movsd  -0x2040(%rbp),%xmm0
ff
movaps 0xe90(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  0xe44(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2050(%rbp)
ff
movsd  -0x2048(%rbp),%xmm0
ff
movsd  -0x2048(%rbp),%xmm2
ff
movsd  -0x2050(%rbp),%xmm1
ff
movsd  -0x2050(%rbp),%xmm3
ff
movsd  0xe08(%rip),%xmm4
mulsd  -0x2048(%rbp),%xmm4
ff
movq   %xmm4,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm4
movsd  0xdd9(%rip),%xmm5
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2058(%rbp)
ff
movsd  -0x2058(%rbp),%xmm0
ff
xor    %eax,%eax
movsd  0xddb(%rip),%xmm1
ucomisd %xmm1,%xmm0
mov    %al,-0x2059(%rbp)
jbe    12ed <rand_gaussnd+0x1cd>
movsd  -0x2058(%rbp),%xmm0
ff
mov    $0x1,%al
movsd  0xdc1(%rip),%xmm1
ucomisd %xmm1,%xmm0
mov    %al,-0x205a(%rbp)
ja     12e1 <rand_gaussnd+0x1c1>
movsd  -0x2040(%rbp),%xmm0
ff
mulsd  -0x2040(%rbp),%xmm0
ff
movsd  %xmm0,-0x2068(%rbp)
ff
movsd  -0x2038(%rbp),%xmm0
ff
call   1040 <log@plt>
movsd  -0x2068(%rbp),%xmm0
ff
cvtsi2sd %eax,%xmm2
movsd  0xd80(%rip),%xmm1
mulsd  %xmm2,%xmm1
mulsd  -0x2038(%rbp),%xmm1
ff
mulsd  -0x2038(%rbp),%xmm1
ff
ucomisd %xmm1,%xmm0
seta   %al
mov    %al,-0x205a(%rbp)
mov    -0x205a(%rbp),%al
mov    %al,-0x2059(%rbp)
mov    -0x2059(%rbp),%al
test   $0x1,%al
jne    115c <rand_gaussnd+0x3c>
movsd  -0x2040(%rbp),%xmm0
ff
divsd  -0x2038(%rbp),%xmm0
ff
mov    -0x2028(%rbp),%rax
movsd  %xmm0,-0x2020(%rbp,%rax,8)
ff ff
mov    -0x2028(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x2028(%rbp)
jmp    1146 <rand_gaussnd+0x26>
movq   $0x0,-0x2028(%rbp)
mov    -0x2028(%rbp),%rax
cmp    -0x8(%rbp),%rax
jae    141c <rand_gaussnd+0x2fc>
mov    -0x20(%rbp),%rax
mov    -0x2028(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movq   $0x0,-0x2030(%rbp)
mov    -0x2030(%rbp),%rax
cmp    -0x2028(%rbp),%rax
ja     13e0 <rand_gaussnd+0x2c0>
mov    -0x10(%rbp),%rax
mov    -0x2028(%rbp),%rcx
imul   -0x8(%rbp),%rcx
add    -0x2030(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x2030(%rbp),%rax
movsd  -0x2020(%rbp,%rax,8),%xmm2
ff ff
mov    -0x20(%rbp),%rax
mov    -0x2028(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2030(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x2030(%rbp)
jmp    136c <rand_gaussnd+0x24c>
mov    -0x18(%rbp),%rax
mov    -0x2028(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x2028(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2028(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x2028(%rbp)
jmp    133d <rand_gaussnd+0x21d>
mov    -0x20(%rbp),%rax
add    $0x2070,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<rand_gaussnd>:
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x2020,%rsp
mov    %rcx,%rbx
test   %rdi,%rdi
je     1323 <rand_gaussnd+0x203>
mov    %rdx,%r14
mov    %rsi,%r15
mov    %rdi,%r12
xor    %r13d,%r13d
jmp    1170 <rand_gaussnd+0x50>
divsd  (%rsp),%xmm4
movsd  %xmm4,0x20(%rsp,%r13,8)
add    $0x1,%r13
cmp    %r12,%r13
je     1251 <rand_gaussnd+0x131>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xor    %eax,%eax
call   1030 <rand0_1@plt>
movsd  %xmm0,(%rsp)
xor    %eax,%eax
call   1030 <rand0_1@plt>
movapd %xmm0,%xmm4
addsd  0xe71(%rip),%xmm4
mulsd  0xe71(%rip),%xmm4
movsd  (%rsp),%xmm0
addsd  0xe6c(%rip),%xmm0
movapd %xmm4,%xmm1
andpd  0xea0(%rip),%xmm1
addsd  0xe60(%rip),%xmm1
movapd %xmm0,%xmm2
mulsd  0xe5c(%rip),%xmm2
movapd %xmm1,%xmm3
mulsd  0xe58(%rip),%xmm3
addsd  %xmm2,%xmm3
mulsd  %xmm1,%xmm3
mulsd  %xmm0,%xmm0
addsd  %xmm3,%xmm0
ucomisd 0xe48(%rip),%xmm0
jbe    114a <rand_gaussnd+0x2a>
ucomisd 0xe42(%rip),%xmm0
ja     1170 <rand_gaussnd+0x50>
movapd %xmm4,%xmm0
mulsd  %xmm4,%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  (%rsp),%xmm0
movapd %xmm4,0x10(%rsp)
call   1040 <log@plt>
movapd 0x10(%rsp),%xmm4
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mulsd  0xe11(%rip),%xmm0
movsd  (%rsp),%xmm1
mulsd  %xmm1,%xmm0
mulsd  %xmm1,%xmm0
movsd  0x8(%rsp),%xmm1
ucomisd %xmm0,%xmm1
ja     1170 <rand_gaussnd+0x50>
jmp    114a <rand_gaussnd+0x2a>
test   %r12,%r12
je     1323 <rand_gaussnd+0x203>
lea    0x8(%r15),%rax
lea    0x0(,%r12,8),%r8
mov    $0x1,%ecx
xor    %esi,%esi
jmp    128f <rand_gaussnd+0x16f>
nop
addsd  (%r14,%rsi,8),%xmm0
movsd  %xmm0,(%rbx,%rsi,8)
add    $0x1,%rsi
add    $0x1,%rcx
add    %r8,%rax
cmp    %r12,%rsi
je     1323 <rand_gaussnd+0x203>
movq   $0x0,(%rbx,%rsi,8)
test   %rsi,%rsi
je     12f0 <rand_gaussnd+0x1d0>
mov    %rcx,%rdx
and    $0xfffffffffffffffe,%rdx
xorpd  %xmm0,%xmm0
xor    %edi,%edi
nopl   0x0(%rax)
movsd  -0x8(%rax,%rdi,8),%xmm1
mulsd  0x20(%rsp,%rdi,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rbx,%rsi,8)
movsd  (%rax,%rdi,8),%xmm0
mulsd  0x28(%rsp,%rdi,8),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rbx,%rsi,8)
add    $0x2,%rdi
cmp    %rdi,%rdx
jne    12b0 <rand_gaussnd+0x190>
test   $0x1,%cl
je     1270 <rand_gaussnd+0x150>
jmp    12ff <rand_gaussnd+0x1df>
nopl   0x0(%rax)
xorpd  %xmm0,%xmm0
xor    %edi,%edi
test   $0x1,%cl
je     1270 <rand_gaussnd+0x150>
mov    %rsi,%rdx
imul   %r12,%rdx
add    %rdi,%rdx
movsd  (%r15,%rdx,8),%xmm1
mulsd  0x20(%rsp,%rdi,8),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rbx,%rsi,8)
jmp    1270 <rand_gaussnd+0x150>
mov    %rbx,%rax
add    $0x2020,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
define double* @rand_gaussnd(i64 %0, double* %1, double* %2, double* %3) {
%5 = alloca i64
%6 = alloca double*
%7 = alloca double*
%8 = alloca double*
%9 = alloca [1024 x double]
%10 = alloca i64
%11 = alloca i64
%12 = alloca double
%13 = alloca double
%14 = alloca double
%15 = alloca double
%16 = alloca double
store i64 %0, i64* %5
store double* %1, double** %6
store double* %2, double** %7
store double* %3, double** %8
store i64 0, i64* %10
br label %17
17: ; preds = %71, %4
%18 = load i64, i64* %10
%19 = load i64, i64* %5
%20 = icmp ult i64 %18, %19
br i1 %20, label %21, label %74
21: ; preds = %17
br label %22
22: ; preds = %63, %21
%23 = call double (...) @rand0_1()
store double %23, double* %12
%24 = call double (...) @rand0_1()
%25 = fsub double %24, 5.000000e-01
%26 = fmul double 1.715600e+00, %25
store double %26, double* %13
%27 = load double, double* %12
%28 = fsub double %27, 4.498710e-01
store double %28, double* %14
%29 = load double, double* %13
%30 = call double @llvm.fabs.f64(double %29)
%31 = fadd double %30, 3.865950e-01
store double %31, double* %15
%32 = load double, double* %14
%33 = load double, double* %14
%34 = load double, double* %15
%35 = load double, double* %15
%36 = load double, double* %14
%37 = fmul double 2.547200e-01, %36
%38 = fneg double %37
%39 = call double @llvm.fmuladd.f64(double 1.960000e-01, double %35, double %38)
%40 = fmul double %34, %39
%41 = call double @llvm.fmuladd.f64(double %32, double %33, double %40)
store double %41, double* %16
br label %42
42: ; preds = %22
%43 = load double, double* %16
%44 = fcmp ogt double %43, 2.759700e-01
br i1 %44, label %45, label %63
45: ; preds = %42
%46 = load double, double* %16
%47 = fcmp ogt double %46, 2.784600e-01
br i1 %47, label %61, label %48
48: ; preds = %45
%49 = load double, double* %13
%50 = load double, double* %13
%51 = fmul double %49, %50
%52 = load double, double* %12
%53 = call i32 @log(double %52)
%54 = sitofp i32 %53 to double
%55 = fmul double -4.000000e+00, %54
%56 = load double, double* %12
%57 = fmul double %55, %56
%58 = load double, double* %12
%59 = fmul double %57, %58
%60 = fcmp ogt double %51, %59
br label %61
61: ; preds = %48, %45
%62 = phi i1 [ true, %45 ], [ %60, %48 ]
br label %63
63: ; preds = %61, %42
%64 = phi i1 [ false, %42 ], [ %62, %61 ]
br i1 %64, label %22, label %65
65: ; preds = %63
%66 = load double, double* %13
%67 = load double, double* %12
%68 = fdiv double %66, %67
%69 = load i64, i64* %10
%70 = getelementptr inbounds [1024 x double], [1024 x double]* %9, i64 0, i64 %69
store double %68, double* %70
br label %71
71: ; preds = %65
%72 = load i64, i64* %10
%73 = add i64 %72, 1
store i64 %73, i64* %10
br label %17
74: ; preds = %17
store i64 0, i64* %10
br label %75
75: ; preds = %117, %74
%76 = load i64, i64* %10
%77 = load i64, i64* %5
%78 = icmp ult i64 %76, %77
br i1 %78, label %79, label %120
79: ; preds = %75
%80 = load double*, double** %8
%81 = load i64, i64* %10
%82 = getelementptr inbounds double, double* %80, i64 %81
store double 0.000000e+00, double* %82
store i64 0, i64* %11
br label %83
83: ; preds = %104, %79
%84 = load i64, i64* %11
%85 = load i64, i64* %10
%86 = icmp ule i64 %84, %85
br i1 %86, label %87, label %107
87: ; preds = %83
%88 = load double*, double** %6
%89 = load i64, i64* %10
%90 = load i64, i64* %5
%91 = mul i64 %89, %90
%92 = load i64, i64* %11
%93 = add i64 %91, %92
%94 = getelementptr inbounds double, double* %88, i64 %93
%95 = load double, double* %94
%96 = load i64, i64* %11
%97 = getelementptr inbounds [1024 x double], [1024 x double]* %9, i64 0, i64 %96
%98 = load double, double* %97
%99 = load double*, double** %8
%100 = load i64, i64* %10
%101 = getelementptr inbounds double, double* %99, i64 %100
%102 = load double, double* %101
%103 = call double @llvm.fmuladd.f64(double %95, double %98, double %102)
store double %103, double* %101
br label %104
104: ; preds = %87
%105 = load i64, i64* %11
%106 = add i64 %105, 1
store i64 %106, i64* %11
br label %83
107: ; preds = %83
%108 = load double*, double** %7
%109 = load i64, i64* %10
%110 = getelementptr inbounds double, double* %108, i64 %109
%111 = load double, double* %110
%112 = load double*, double** %8
%113 = load i64, i64* %10
%114 = getelementptr inbounds double, double* %112, i64 %113
%115 = load double, double* %114
%116 = fadd double %115, %111
store double %116, double* %114
br label %117
117: ; preds = %107
%118 = load i64, i64* %10
%119 = add i64 %118, 1
store i64 %119, i64* %10
br label %75
120: ; preds = %75
%121 = load double*, double** %8
ret double* %121
}

LLVM IR (-O2):
define double* @rand_gaussnd(i64 %0, double* nocapture %1, double* nocapture %2, double* returned %3) {
%5 = alloca [1024 x double]
%6 = bitcast [1024 x double]* %5 to i8*
%7 = icmp eq i64 %0, 0
br i1 %7, label %105, label %8
8: ; preds = %4, %49
%9 = phi i64 [ %54, %49 ], [ 0, %4 ]
%10 = tail call double (...) @rand0_1()
%11 = tail call double (...) @rand0_1()
%12 = fadd double %11, -5.000000e-01
%13 = fmul double %12, 1.715600e+00
%14 = fadd double %10, -4.498710e-01
%15 = tail call double @llvm.fabs.f64(double %13)
%16 = fadd double %15, 3.865950e-01
%17 = fmul double %14, -2.547200e-01
%18 = tail call double @llvm.fmuladd.f64(double %16, double 1.960000e-01, double %17)
%19 = fmul double %16, %18
%20 = tail call double @llvm.fmuladd.f64(double %14, double %14, double %19)
%21 = fcmp ogt double %20, 2.759700e-01
br i1 %21, label %23, label %49
22: ; preds = %49
br i1 %7, label %105, label %56
23: ; preds = %8, %36
%24 = phi double [ %47, %36 ], [ %20, %8 ]
%25 = phi double [ %40, %36 ], [ %13, %8 ]
%26 = phi double [ %37, %36 ], [ %10, %8 ]
%27 = fcmp ogt double %24, 2.784600e-01
br i1 %27, label %36, label %28
28: ; preds = %23
%29 = fmul double %25, %25
%30 = tail call i32 @log(double %26)
%31 = sitofp i32 %30 to double
%32 = fmul double %31, -4.000000e+00
%33 = fmul double %26, %32
%34 = fmul double %26, %33
%35 = fcmp ogt double %29, %34
br i1 %35, label %36, label %49
36: ; preds = %28, %23
%37 = tail call double (...) @rand0_1()
%38 = tail call double (...) @rand0_1()
%39 = fadd double %38, -5.000000e-01
%40 = fmul double %39, 1.715600e+00
%41 = fadd double %37, -4.498710e-01
%42 = tail call double @llvm.fabs.f64(double %40)
%43 = fadd double %42, 3.865950e-01
%44 = fmul double %41, -2.547200e-01
%45 = tail call double @llvm.fmuladd.f64(double %43, double 1.960000e-01, double %44)
%46 = fmul double %43, %45
%47 = tail call double @llvm.fmuladd.f64(double %41, double %41, double %46)
%48 = fcmp ogt double %47, 2.759700e-01
br i1 %48, label %23, label %49
49: ; preds = %28, %36, %8
%50 = phi double [ %10, %8 ], [ %37, %36 ], [ %26, %28 ]
%51 = phi double [ %13, %8 ], [ %40, %36 ], [ %25, %28 ]
%52 = fdiv double %51, %50
%53 = getelementptr inbounds [1024 x double], [1024 x double]* %5, i64 0, i64 %9
store double %52, double* %53
%54 = add nuw i64 %9, 1
%55 = icmp eq i64 %54, %0
br i1 %55, label %22, label %8
56: ; preds = %22, %97
%57 = phi i64 [ %103, %97 ], [ 1, %22 ]
%58 = phi i64 [ %102, %97 ], [ 0, %22 ]
%59 = getelementptr inbounds double, double* %3, i64 %58
store double 0.000000e+00, double* %59
%60 = mul i64 %58, %0
%61 = and i64 %57, 1
%62 = icmp eq i64 %58, 0
br i1 %62, label %85, label %63
63: ; preds = %56
%64 = and i64 %57, -2
br label %65
65: ; preds = %65, %63
%66 = phi double [ 0.000000e+00, %63 ], [ %81, %65 ]
%67 = phi i64 [ 0, %63 ], [ %82, %65 ]
%68 = phi i64 [ 0, %63 ], [ %83, %65 ]
%69 = add i64 %67, %60
%70 = getelementptr inbounds double, double* %1, i64 %69
%71 = load double, double* %70
%72 = getelementptr inbounds [1024 x double], [1024 x double]* %5, i64 0, i64 %67
%73 = load double, double* %72
%74 = tail call double @llvm.fmuladd.f64(double %71, double %73, double %66)
store double %74, double* %59
%75 = or i64 %67, 1
%76 = add i64 %75, %60
%77 = getelementptr inbounds double, double* %1, i64 %76
%78 = load double, double* %77
%79 = getelementptr inbounds [1024 x double], [1024 x double]* %5, i64 0, i64 %75
%80 = load double, double* %79
%81 = tail call double @llvm.fmuladd.f64(double %78, double %80, double %74)
store double %81, double* %59
%82 = add nuw i64 %67, 2
%83 = add i64 %68, 2
%84 = icmp eq i64 %83, %64
br i1 %84, label %85, label %65
85: ; preds = %65, %56
%86 = phi double [ undef, %56 ], [ %81, %65 ]
%87 = phi double [ 0.000000e+00, %56 ], [ %81, %65 ]
%88 = phi i64 [ 0, %56 ], [ %82, %65 ]
%89 = icmp eq i64 %61, 0
br i1 %89, label %97, label %90
90: ; preds = %85
%91 = add i64 %88, %60
%92 = getelementptr inbounds double, double* %1, i64 %91
%93 = load double, double* %92
%94 = getelementptr inbounds [1024 x double], [1024 x double]* %5, i64 0, i64 %88
%95 = load double, double* %94
%96 = tail call double @llvm.fmuladd.f64(double %93, double %95, double %87)
store double %96, double* %59
br label %97
97: ; preds = %85, %90
%98 = phi double [ %86, %85 ], [ %96, %90 ]
%99 = getelementptr inbounds double, double* %2, i64 %58
%100 = load double, double* %99
%101 = fadd double %100, %98
store double %101, double* %59
%102 = add nuw i64 %58, 1
%103 = add i64 %57, 1
%104 = icmp eq i64 %102, %0
br i1 %104, label %105, label %56
105: ; preds = %97, %4, %22
ret double* %3
}