#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 exp(double);
double th_Uax9Strip(double aa, double x, double wStart, double Dw) {
  double aMh, R2xS, w, f[28], integral;
  double th_Power(double x, double p);
  const double a[5] = {0.2869754464285714, 1.581127232142857,
                       0.1084821428571429, 1.943035714285714,
                       0.5803794642857144};
  int k;
  aMh = aa - 0.5;
  R2xS = 1.0 / (2.0 * x * x);
  w = wStart;
  for (k = 0; k <= 27; k++) {
    f[k] = exp(-w * (1.0 + w * R2xS)) * th_Power(w, aMh);
    w += Dw;
  }
  integral = Dw * (a[0] * (f[0] + f[27] + 2.0 * (f[9] + f[18])) +
                   a[1] * (f[1] + f[8] + f[10] + f[17] + f[19] + f[26]) +
                   a[2] * (f[2] + f[7] + f[11] + f[16] + f[20] + f[25]) +
                   a[3] * (f[3] + f[6] + f[12] + f[15] + f[21] + f[24]) +
                   a[4] * (f[4] + f[5] + f[13] + f[14] + f[22] + f[23]));
  return integral;
}


x86 assembly (clang, -O0):
<th_Uax9Strip>:
push   %rbp
mov    %rsp,%rbp
sub    $0x160,%rsp
movsd  %xmm0,-0x8(%rbp)
movsd  %xmm1,-0x10(%rbp)
movsd  %xmm2,-0x18(%rbp)
movsd  %xmm3,-0x20(%rbp)
lea    -0x150(%rbp),%rdi
xor    %esi,%esi
mov    $0x28,%edx
call   1030 <memset@plt>
movsd  0xece(%rip),%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
movsd  0xeb6(%rip),%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
movsd  0xe9e(%rip),%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
movsd  0xe86(%rip),%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  0xe6e(%rip),%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x8(%rbp),%xmm0
movsd  0xe51(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x28(%rbp)
movsd  0xe38(%rip),%xmm1
mulsd  -0x10(%rbp),%xmm1
mulsd  -0x10(%rbp),%xmm1
movsd  0xe1e(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x30(%rbp)
movsd  -0x18(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
movl   $0x0,-0x154(%rbp)
cmpl   $0x1b,-0x154(%rbp)
jg     12a4 <th_Uax9Strip+0x174>
movsd  -0x38(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0x38(%rbp),%xmm1
movsd  -0x30(%rbp),%xmm2
mulsd  %xmm2,%xmm1
movsd  0xdc2(%rip),%xmm2
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
call   1050 <exp@plt>
movsd  %xmm0,-0x160(%rbp)
ff
movsd  -0x38(%rbp),%xmm0
movsd  -0x28(%rbp),%xmm1
call   1040 <th_Power@plt>
movaps %xmm0,%xmm1
movsd  -0x160(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movslq -0x154(%rbp),%rax
movsd  %xmm0,-0x120(%rbp,%rax,8)
ff ff
movsd  -0x20(%rbp),%xmm0
addsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x154(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x154(%rbp)
jmp    11ff <th_Uax9Strip+0xcf>
movsd  -0x20(%rbp),%xmm0
movsd  -0x150(%rbp),%xmm2
ff
movsd  -0x120(%rbp),%xmm1
ff
addsd  -0x48(%rbp),%xmm1
movsd  -0xd8(%rbp),%xmm3
ff
addsd  -0x90(%rbp),%xmm3
ff
addsd  %xmm3,%xmm3
addsd  %xmm1,%xmm3
movsd  -0x148(%rbp),%xmm1
ff
movsd  -0x118(%rbp),%xmm4
ff
addsd  -0xe0(%rbp),%xmm4
ff
addsd  -0xd0(%rbp),%xmm4
ff
addsd  -0x98(%rbp),%xmm4
ff
addsd  -0x88(%rbp),%xmm4
ff
addsd  -0x50(%rbp),%xmm4
mulsd  %xmm4,%xmm1
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  -0x140(%rbp),%xmm1
ff
movsd  -0x110(%rbp),%xmm3
ff
addsd  -0xe8(%rbp),%xmm3
ff
addsd  -0xc8(%rbp),%xmm3
ff
addsd  -0xa0(%rbp),%xmm3
ff
addsd  -0x80(%rbp),%xmm3
addsd  -0x58(%rbp),%xmm3
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
movsd  -0x138(%rbp),%xmm2
ff
movsd  -0x108(%rbp),%xmm3
ff
addsd  -0xf0(%rbp),%xmm3
ff
addsd  -0xc0(%rbp),%xmm3
ff
addsd  -0xa8(%rbp),%xmm3
ff
addsd  -0x78(%rbp),%xmm3
addsd  -0x60(%rbp),%xmm3
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  -0x130(%rbp),%xmm1
ff
movsd  -0x100(%rbp),%xmm3
ff
addsd  -0xf8(%rbp),%xmm3
ff
addsd  -0xb8(%rbp),%xmm3
ff
addsd  -0xb0(%rbp),%xmm3
ff
addsd  -0x70(%rbp),%xmm3
addsd  -0x68(%rbp),%xmm3
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0x128(%rbp),%xmm0
ff
add    $0x160,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<th_Uax9Strip>:
push   %rbx
sub    $0x110,%rsp
movsd  %xmm3,(%rsp)
addsd  0xecb(%rip),%xmm0
movsd  %xmm0,0x10(%rsp)
movapd %xmm1,%xmm0
addsd  %xmm1,%xmm0
mulsd  %xmm1,%xmm0
movsd  0xeb9(%rip),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movapd %xmm2,0x20(%rsp)
movapd %xmm2,%xmm1
xorpd  0xece(%rip),%xmm1
movapd %xmm2,%xmm0
mulsd  0x8(%rsp),%xmm0
addsd  0xe84(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1040 <exp@plt>
movsd  %xmm0,0x18(%rsp)
movapd 0x20(%rsp),%xmm0
movsd  0x10(%rsp),%xmm1
call   1030 <th_Power@plt>
movapd 0x20(%rsp),%xmm2
mulsd  0x18(%rsp),%xmm0
movsd  %xmm0,0x30(%rsp,%rbx,8)
addsd  (%rsp),%xmm2
add    $0x1,%rbx
cmp    $0x1c,%rbx
jne    1160 <th_Uax9Strip+0x40>
movsd  0x30(%rsp),%xmm1
addsd  0x108(%rsp),%xmm1
movsd  0x38(%rsp),%xmm2
movsd  0x78(%rsp),%xmm0
addsd  0xc0(%rsp),%xmm0
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
addsd  0x70(%rsp),%xmm2
addsd  0x80(%rsp),%xmm2
addsd  0xb8(%rsp),%xmm2
addsd  0xc8(%rsp),%xmm2
addsd  0x100(%rsp),%xmm2
mulsd  0xded(%rip),%xmm2
mulsd  0xded(%rip),%xmm0
addsd  %xmm2,%xmm0
movsd  0x40(%rsp),%xmm1
addsd  0x68(%rsp),%xmm1
addsd  0x88(%rsp),%xmm1
addsd  0xb0(%rsp),%xmm1
addsd  0xd0(%rsp),%xmm1
addsd  0xf8(%rsp),%xmm1
mulsd  0xdb9(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x48(%rsp),%xmm2
addsd  0x60(%rsp),%xmm2
addsd  0x90(%rsp),%xmm2
addsd  0xa8(%rsp),%xmm2
addsd  0xd8(%rsp),%xmm2
addsd  0xf0(%rsp),%xmm2
mulsd  0xd85(%rip),%xmm2
addsd  %xmm1,%xmm2
movsd  0x50(%rsp),%xmm0
addsd  0x58(%rsp),%xmm0
addsd  0x98(%rsp),%xmm0
addsd  0xa0(%rsp),%xmm0
addsd  0xe0(%rsp),%xmm0
addsd  0xe8(%rsp),%xmm0
mulsd  0xd51(%rip),%xmm0
addsd  %xmm2,%xmm0
mulsd  (%rsp),%xmm0
add    $0x110,%rsp
pop    %rbx
ret

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

LLVM IR (-O2):
define double @th_Uax9Strip(double %0, double %1, double %2, double %3) {
%5 = alloca [28 x double]
%6 = bitcast [28 x double]* %5 to i8*
%7 = fadd double %0, -5.000000e-01
%8 = fmul double %1, 2.000000e+00
%9 = fmul double %8, %1
%10 = fdiv double 1.000000e+00, %9
br label %11
11: ; preds = %4, %11
%12 = phi i64 [ 0, %4 ], [ %22, %11 ]
%13 = phi double [ %2, %4 ], [ %21, %11 ]
%14 = fneg double %13
%15 = tail call double @llvm.fmuladd.f64(double %13, double %10, double 1.000000e+00)
%16 = fmul double %15, %14
%17 = tail call double @exp(double %16)
%18 = tail call double @th_Power(double %13, double %7)
%19 = fmul double %17, %18
%20 = getelementptr inbounds [28 x double], [28 x double]* %5, i64 0, i64 %12
store double %19, double* %20
%21 = fadd double %13, %3
%22 = add nuw nsw i64 %12, 1
%23 = icmp eq i64 %22, 28
br i1 %23, label %24, label %11
24: ; preds = %11
%25 = getelementptr inbounds [28 x double], [28 x double]* %5, i64 0, i64 0
%26 = load double, double* %25
%27 = getelementptr inbounds [28 x double], [28 x double]* %5, i64 0, i64 27
%28 = load double, double* %27
%29 = fadd double %26, %28
%30 = getelementptr inbounds [28 x double], [28 x double]* %5, i64 0, i64 9
%31 = load double, double* %30
%32 = getelementptr inbounds [28 x double], [28 x double]* %5, i64 0, i64 18
%33 = load double, double* %32
%34 = fadd double %31, %33
%35 = tail call double @llvm.fmuladd.f64(double %34, double 2.000000e+00, double %29)
%36 = getelementptr inbounds [28 x double], [28 x double]* %5, i64 0, i64 1
%37 = load double, double* %36
%38 = getelementptr inbounds [28 x double], [28 x double]* %5, i64 0, i64 8
%39 = load double, double* %38
%40 = fadd double %37, %39
%41 = getelementptr inbounds [28 x double], [28 x double]* %5, i64 0, i64 10
%42 = load double, double* %41
%43 = fadd double %40, %42
%44 = getelementptr inbounds [28 x double], [28 x double]* %5, i64 0, i64 17
%45 = load double, double* %44
%46 = fadd double %43, %45
%47 = getelementptr inbounds [28 x double], [28 x double]* %5, i64 0, i64 19
%48 = load double, double* %47
%49 = fadd double %46, %48
%50 = getelementptr inbounds [28 x double], [28 x double]* %5, i64 0, i64 26
%51 = load double, double* %50
%52 = fadd double %49, %51
%53 = fmul double %52, 0x3FF94C4C118DE5AB
%54 = tail call double @llvm.fmuladd.f64(double %35, double 0x3FD25DCE434A9B10, double %53)
%55 = getelementptr inbounds [28 x double], [28 x double]* %5, i64 0, i64 2
%56 = load double, double* %55
%57 = getelementptr inbounds [28 x double], [28 x double]* %5, i64 0, i64 7
%58 = load double, double* %57
%59 = fadd double %56, %58
%60 = getelementptr inbounds [28 x double], [28 x double]* %5, i64 0, i64 11
%61 = load double, double* %60
%62 = fadd double %59, %61
%63 = getelementptr inbounds [28 x double], [28 x double]* %5, i64 0, i64 16
%64 = load double, double* %63
%65 = fadd double %62, %64
%66 = getelementptr inbounds [28 x double], [28 x double]* %5, i64 0, i64 20
%67 = load double, double* %66
%68 = fadd double %65, %67
%69 = getelementptr inbounds [28 x double], [28 x double]* %5, i64 0, i64 25
%70 = load double, double* %69
%71 = fadd double %68, %70
%72 = tail call double @llvm.fmuladd.f64(double %71, double 0x3FBBC57C57C57C5B, double %54)
%73 = getelementptr inbounds [28 x double], [28 x double]* %5, i64 0, i64 3
%74 = load double, double* %73
%75 = getelementptr inbounds [28 x double], [28 x double]* %5, i64 0, i64 6
%76 = load double, double* %75
%77 = fadd double %74, %76
%78 = getelementptr inbounds [28 x double], [28 x double]* %5, i64 0, i64 12
%79 = load double, double* %78
%80 = fadd double %77, %79
%81 = getelementptr inbounds [28 x double], [28 x double]* %5, i64 0, i64 15
%82 = load double, double* %81
%83 = fadd double %80, %82
%84 = getelementptr inbounds [28 x double], [28 x double]* %5, i64 0, i64 21
%85 = load double, double* %84
%86 = fadd double %83, %85
%87 = getelementptr inbounds [28 x double], [28 x double]* %5, i64 0, i64 24
%88 = load double, double* %87
%89 = fadd double %86, %88
%90 = tail call double @llvm.fmuladd.f64(double %89, double 0x3FFF16AC9DFD1303, double %72)
%91 = getelementptr inbounds [28 x double], [28 x double]* %5, i64 0, i64 4
%92 = load double, double* %91
%93 = getelementptr inbounds [28 x double], [28 x double]* %5, i64 0, i64 5
%94 = load double, double* %93
%95 = fadd double %92, %94
%96 = getelementptr inbounds [28 x double], [28 x double]* %5, i64 0, i64 13
%97 = load double, double* %96
%98 = fadd double %95, %97
%99 = getelementptr inbounds [28 x double], [28 x double]* %5, i64 0, i64 14
%100 = load double, double* %99
%101 = fadd double %98, %100
%102 = getelementptr inbounds [28 x double], [28 x double]* %5, i64 0, i64 22
%103 = load double, double* %102
%104 = fadd double %101, %103
%105 = getelementptr inbounds [28 x double], [28 x double]* %5, i64 0, i64 23
%106 = load double, double* %105
%107 = fadd double %104, %106
%108 = tail call double @llvm.fmuladd.f64(double %107, double 0x3FE29277F44C118F, double %90)
%109 = fmul double %108, %3
ret double %109
}