#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 DBL_EPSILON;
double DBL_MIN;
long double fabs(double);
double pow(double, double);
double stub1(double, void *);
double stub2(double, void *);
double stub3(double, void *);
double stub4(double, void *);
double stub5(double, void *);
double G_K21(double f(double, void *), void *cbData, double a, double b,
             double *abserr, double *resabs, double *resasc) {
  static long double XGK21[11] = {
      0.99565716302580808074, 0.97390652851717172008, 0.93015749135570822600,
      0.86506336668898451073, 0.78081772658641689706, 0.67940956829902440623,
      0.56275713466860468334, 0.43339539412924719080, 0.29439286270146019813,
      0.14887433898163121088, 0.00000000000000000000};
  static long double WGK21[11] = {
      0.01169463886737187428, 0.03255816230796472748, 0.05475589657435199603,
      0.07503967481091995277, 0.09312545458369760554, 0.10938715880229764190,
      0.12349197626206585108, 0.13470921731147332593, 0.14277593857706008080,
      0.14773910490133849137, 0.14944555400291690566};
  static long double WG10[5] = {0.06667134430868813759, 0.14945134915058059315,
                                0.21908636251598204400, 0.26926671930999635509,
                                0.29552422471475287017};
  double fv1[10], fv2[10];
  double adir, centr, dhlgth;
  double fc, fsum, fval1, fval2, hlgth;
  double resg, resk, reskh, result;
  int j, jtw, jtwm1;
  centr = 0.5 * (a + b);
  hlgth = 0.5 * (b - a);
  dhlgth = fabs(hlgth);
  resg = 0.0;
  fc = (*f)(centr, cbData);
  resk = fc * WGK21[10];
  *resabs = fabs(resk);
  for (j = 0; j < 5; j++) {
    jtw = 2 * j + 1;
    adir = hlgth * XGK21[jtw];
    fval1 = (*f)(centr - adir, cbData);
    fval2 = (*f)(centr + adir, cbData);
    fv1[jtw] = fval1;
    fv2[jtw] = fval2;
    fsum = fval1 + fval2;
    resg += WG10[j] * fsum;
    resk += WGK21[jtw] * fsum;
    *resabs = *resabs + WGK21[jtw] * (fabs(fval1) + fabs(fval2));
  }
  for (j = 0; j < 5; j++) {
    jtwm1 = j * 2;
    adir = hlgth * XGK21[jtwm1];
    fval1 = (*f)(centr - adir, cbData);
    fval2 = (*f)(centr + adir, cbData);
    fv1[jtwm1] = fval1;
    fv2[jtwm1] = fval2;
    fsum = fval1 + fval2;
    resk = resk + WGK21[jtwm1] * fsum;
    *resabs = (*resabs) + WGK21[jtwm1] * (fabs(fval1) + fabs(fval2));
  }
  reskh = resk * 0.5;
  *resasc = WGK21[10] * fabs(fc - reskh);
  for (j = 0; j < 10; j++)
    *resasc =
        (*resasc) + WGK21[j] * (fabs(fv1[j] - reskh) + fabs(fv2[j] - reskh));
  result = resk * hlgth;
  *resabs = (*resabs) * dhlgth;
  *resasc = (*resasc) * dhlgth;
  *abserr = fabs((resk - resg) * hlgth);
  if ((*resasc != 0.0) && (*abserr != 0.0))
    *abserr = (*resasc) * (((1.0) < (pow((200.0 * (*abserr) / (*resasc)), 1.5)))
                               ? (1.0)
                               : (pow((200.0 * (*abserr) / (*resasc)), 1.5)));
  if (*resabs > DBL_MIN / (50.0 * DBL_EPSILON))
    *abserr = (((DBL_EPSILON * 50.0 * (*resabs)) > ((*abserr)))
                   ? (DBL_EPSILON * 50.0 * (*resabs))
                   : ((*abserr)));
  return result;
}


x86 assembly (clang, -O0):
<G_K21>:
push   %rbp
mov    %rsp,%rbp
sub    $0x210,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movsd  %xmm0,-0x18(%rbp)
movsd  %xmm1,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    %rcx,-0x30(%rbp)
mov    %r8,-0x38(%rbp)
movsd  -0x18(%rbp),%xmm0
movsd  -0x20(%rbp),%xmm1
addsd  %xmm1,%xmm0
movsd  0xea1(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  -0x20(%rbp),%xmm0
movsd  -0x18(%rbp),%xmm2
subsd  %xmm2,%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0x120(%rbp),%xmm0
ff
call   1030 <fabs@plt>
fstpl  -0xf8(%rbp)
movq   $0x0,-0x128(%rbp)
mov    -0x8(%rbp),%rax
movsd  -0xf0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rdi
call   *%rax
movsd  %xmm0,-0x100(%rbp)
ff
fldl   -0x100(%rbp)
fldt   0x2fc7(%rip)
fmulp  %st,%st(1)
fstpl  -0x130(%rbp)
movsd  -0x130(%rbp),%xmm0
ff
call   1030 <fabs@plt>
fstpl  -0x158(%rbp)
movsd  -0x158(%rbp),%xmm0
ff
mov    -0x30(%rbp),%rax
movsd  %xmm0,(%rax)
movl   $0x0,-0x144(%rbp)
cmpl   $0x5,-0x144(%rbp)
jge    13b8 <G_K21+0x298>
mov    -0x144(%rbp),%ecx
mov    %ecx,%eax
lea    0x1(%rax,%rax,1),%eax
mov    %eax,-0x148(%rbp)
fldl   -0x120(%rbp)
movslq -0x148(%rbp),%rax
shl    $0x4,%rax
lea    0x2e0b(%rip),%rcx
fldt   (%rax,%rcx,1)
fmulp  %st,%st(1)
fstpl  -0xe8(%rbp)
mov    -0x8(%rbp),%rax
movsd  -0xf0(%rbp),%xmm0
ff
movsd  -0xe8(%rbp),%xmm1
ff
subsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rdi
call   *%rax
movsd  %xmm0,-0x110(%rbp)
ff
mov    -0x8(%rbp),%rax
movsd  -0xf0(%rbp),%xmm0
ff
movsd  -0xe8(%rbp),%xmm1
ff
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rdi
call   *%rax
movsd  %xmm0,-0x118(%rbp)
ff
movsd  -0x110(%rbp),%xmm0
ff
movslq -0x148(%rbp),%rax
movsd  %xmm0,-0x90(%rbp,%rax,8)
ff ff
movsd  -0x118(%rbp),%xmm0
ff
movslq -0x148(%rbp),%rax
movsd  %xmm0,-0xe0(%rbp,%rax,8)
ff ff
movsd  -0x110(%rbp),%xmm0
ff
movsd  -0x118(%rbp),%xmm1
ff
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
movslq -0x144(%rbp),%rax
shl    $0x4,%rax
lea    0x2eb6(%rip),%rcx
fldt   (%rax,%rcx,1)
fldl   -0x108(%rbp)
fldl   -0x128(%rbp)
fxch   %st(2)
fmulp  %st,%st(1)
faddp  %st,%st(1)
fstpl  -0x128(%rbp)
movslq -0x148(%rbp),%rax
shl    $0x4,%rax
lea    0x2dd9(%rip),%rcx
fldt   (%rax,%rcx,1)
fldl   -0x108(%rbp)
fldl   -0x130(%rbp)
fxch   %st(2)
fmulp  %st,%st(1)
faddp  %st,%st(1)
fstpl  -0x130(%rbp)
mov    -0x30(%rbp),%rax
fldl   (%rax)
fstpt  -0x198(%rbp)
movslq -0x148(%rbp),%rax
shl    $0x4,%rax
fldt   (%rax,%rcx,1)
fstpt  -0x18c(%rbp)
movsd  -0x110(%rbp),%xmm0
ff
call   1030 <fabs@plt>
fstpt  -0x1a4(%rbp)
movsd  -0x118(%rbp),%xmm0
ff
call   1030 <fabs@plt>
fldt   -0x1a4(%rbp)
fldt   -0x198(%rbp)
fldt   -0x18c(%rbp)
fxch   %st(2)
faddp  %st,%st(3)
fxch   %st(1)
fmulp  %st,%st(2)
faddp  %st,%st(1)
fstpl  -0x180(%rbp)
movsd  -0x180(%rbp),%xmm0
ff
mov    -0x30(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x144(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x144(%rbp)
jmp    11fe <G_K21+0xde>
movl   $0x0,-0x144(%rbp)
cmpl   $0x5,-0x144(%rbp)
jge    1549 <G_K21+0x429>
mov    -0x144(%rbp),%eax
add    %eax,%eax
mov    %eax,-0x14c(%rbp)
fldl   -0x120(%rbp)
movslq -0x14c(%rbp),%rax
shl    $0x4,%rax
lea    0x2c4b(%rip),%rcx
fldt   (%rax,%rcx,1)
fmulp  %st,%st(1)
fstpl  -0xe8(%rbp)
mov    -0x8(%rbp),%rax
movsd  -0xf0(%rbp),%xmm0
ff
movsd  -0xe8(%rbp),%xmm1
ff
subsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rdi
call   *%rax
movsd  %xmm0,-0x110(%rbp)
ff
mov    -0x8(%rbp),%rax
movsd  -0xf0(%rbp),%xmm0
ff
movsd  -0xe8(%rbp),%xmm1
ff
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rdi
call   *%rax
movsd  %xmm0,-0x118(%rbp)
ff
movsd  -0x110(%rbp),%xmm0
ff
movslq -0x14c(%rbp),%rax
movsd  %xmm0,-0x90(%rbp,%rax,8)
ff ff
movsd  -0x118(%rbp),%xmm0
ff
movslq -0x14c(%rbp),%rax
movsd  %xmm0,-0xe0(%rbp,%rax,8)
ff ff
movsd  -0x110(%rbp),%xmm0
ff
movsd  -0x118(%rbp),%xmm1
ff
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
fldl   -0x130(%rbp)
movslq -0x14c(%rbp),%rax
shl    $0x4,%rax
lea    0x2c40(%rip),%rcx
fldt   (%rax,%rcx,1)
fldl   -0x108(%rbp)
fmulp  %st,%st(1)
faddp  %st,%st(1)
fstpl  -0x130(%rbp)
mov    -0x30(%rbp),%rax
fldl   (%rax)
fstpt  -0x1bc(%rbp)
movslq -0x14c(%rbp),%rax
shl    $0x4,%rax
fldt   (%rax,%rcx,1)
fstpt  -0x1b0(%rbp)
movsd  -0x110(%rbp),%xmm0
ff
call   1030 <fabs@plt>
fstpt  -0x1c8(%rbp)
movsd  -0x118(%rbp),%xmm0
ff
call   1030 <fabs@plt>
fldt   -0x1c8(%rbp)
fldt   -0x1bc(%rbp)
fldt   -0x1b0(%rbp)
fxch   %st(2)
faddp  %st,%st(3)
fxch   %st(1)
fmulp  %st,%st(2)
faddp  %st,%st(1)
fstpl  -0x178(%rbp)
movsd  -0x178(%rbp),%xmm0
ff
mov    -0x30(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x144(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x144(%rbp)
jmp    13c2 <G_K21+0x2a2>
movsd  -0x130(%rbp),%xmm0
ff
movsd  0xaa7(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
fldt   0x2c25(%rip)
fstpt  -0x1d4(%rbp)
movsd  -0x100(%rbp),%xmm0
ff
movsd  -0x138(%rbp),%xmm1
ff
subsd  %xmm1,%xmm0
call   1030 <fabs@plt>
fldt   -0x1d4(%rbp)
fmulp  %st,%st(1)
fstpl  -0x160(%rbp)
movsd  -0x160(%rbp),%xmm0
ff
mov    -0x38(%rbp),%rax
movsd  %xmm0,(%rax)
movl   $0x0,-0x144(%rbp)
cmpl   $0xa,-0x144(%rbp)
jge    1670 <G_K21+0x550>
mov    -0x38(%rbp),%rax
fldl   (%rax)
fstpt  -0x1ec(%rbp)
movslq -0x144(%rbp),%rax
mov    %rax,%rcx
shl    $0x4,%rcx
lea    0x2b10(%rip),%rdx
fldt   (%rcx,%rdx,1)
fstpt  -0x1e0(%rbp)
movsd  -0x90(%rbp,%rax,8),%xmm0
ff ff
movsd  -0x138(%rbp),%xmm1
ff
subsd  %xmm1,%xmm0
call   1030 <fabs@plt>
fstpt  -0x1f8(%rbp)
movslq -0x144(%rbp),%rax
movsd  -0xe0(%rbp,%rax,8),%xmm0
ff ff
movsd  -0x138(%rbp),%xmm1
ff
subsd  %xmm1,%xmm0
call   1030 <fabs@plt>
fldt   -0x1f8(%rbp)
fldt   -0x1ec(%rbp)
fldt   -0x1e0(%rbp)
fxch   %st(2)
faddp  %st,%st(3)
fxch   %st(1)
fmulp  %st,%st(2)
faddp  %st,%st(1)
fstpl  -0x170(%rbp)
movsd  -0x170(%rbp),%xmm0
ff
mov    -0x38(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x144(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x144(%rbp)
jmp    15b2 <G_K21+0x492>
movsd  -0x130(%rbp),%xmm0
ff
movsd  -0x120(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
mov    -0x30(%rbp),%rax
movsd  (%rax),%xmm0
movsd  -0xf8(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm0
movsd  -0xf8(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
movsd  -0x130(%rbp),%xmm0
ff
movsd  -0x128(%rbp),%xmm1
ff
subsd  %xmm1,%xmm0
movsd  -0x120(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
call   1030 <fabs@plt>
fstpl  -0x168(%rbp)
movsd  -0x168(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1717 <G_K21+0x5f7>
jp     1717 <G_K21+0x5f7>
jmp    17dc <G_K21+0x6bc>
mov    -0x28(%rbp),%rax
movsd  (%rax),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1737 <G_K21+0x617>
jp     1737 <G_K21+0x617>
jmp    17dc <G_K21+0x6bc>
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x200(%rbp)
ff
mov    -0x28(%rbp),%rax
movsd  0x8c5(%rip),%xmm0
mulsd  (%rax),%xmm0
mov    -0x38(%rbp),%rax
divsd  (%rax),%xmm0
movsd  0x8a9(%rip),%xmm1
call   1040 <pow@plt>
movsd  0x894(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1793 <G_K21+0x673>
movsd  0x882(%rip),%xmm0
movsd  %xmm0,-0x208(%rbp)
ff
jmp    17c0 <G_K21+0x6a0>
mov    -0x28(%rbp),%rax
movsd  0x879(%rip),%xmm0
mulsd  (%rax),%xmm0
mov    -0x38(%rbp),%rax
divsd  (%rax),%xmm0
movsd  0x85d(%rip),%xmm1
call   1040 <pow@plt>
movsd  %xmm0,-0x208(%rbp)
ff
movsd  -0x200(%rbp),%xmm0
ff
movsd  -0x208(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x30(%rbp),%rax
movsd  (%rax),%xmm0
mov    0x27ed(%rip),%rax
movsd  (%rax),%xmm1
movsd  0x829(%rip),%xmm2
mov    0x27ea(%rip),%rax
mulsd  (%rax),%xmm2
divsd  %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jbe    1881 <G_K21+0x761>
movsd  0x808(%rip),%xmm0
mov    0x27c9(%rip),%rax
mulsd  (%rax),%xmm0
mov    -0x30(%rbp),%rax
mulsd  (%rax),%xmm0
mov    -0x28(%rbp),%rax
ucomisd (%rax),%xmm0
jbe    1861 <G_K21+0x741>
movsd  0x7df(%rip),%xmm0
mov    0x27a0(%rip),%rax
mulsd  (%rax),%xmm0
mov    -0x30(%rbp),%rax
mulsd  (%rax),%xmm0
movsd  %xmm0,-0x210(%rbp)
ff
jmp    1871 <G_K21+0x751>
mov    -0x28(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x210(%rbp)
ff
movsd  -0x210(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x140(%rbp),%xmm0
ff
add    $0x210,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<G_K21>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x258,%rsp
mov    %r8,0x78(%rsp)
mov    %rcx,%r12
mov    %rdx,0x80(%rsp)
movapd %xmm1,%xmm2
mov    %rsi,%r13
mov    %rdi,%r14
movapd %xmm0,%xmm3
addsd  %xmm1,%xmm3
movsd  0xea5(%rip),%xmm1
mulsd  %xmm1,%xmm3
movsd  %xmm3,0x8(%rsp)
subsd  %xmm0,%xmm2
mulsd  %xmm1,%xmm2
movsd  %xmm2,0x48(%rsp)
movapd %xmm2,%xmm0
call   1030 <fabs@plt>
fstpt  0x1a4(%rsp)
movsd  0x8(%rsp),%xmm0
mov    %r13,%rdi
call   *%r14
movsd  %xmm0,0x70(%rsp)
movsd  %xmm0,0x190(%rsp)
fldl   0x190(%rsp)
fmull  0xe5d(%rip)
fstpl  0x188(%rsp)
movsd  0x188(%rsp),%xmm0
movsd  %xmm0,0x20(%rsp)
call   1030 <fabs@plt>
fstpl  (%r12)
movsd  0x48(%rsp),%xmm0
movsd  %xmm0,0x198(%rsp)
xorps  %xmm0,%xmm0
movsd  %xmm0,0x50(%rsp)
xor    %r15d,%r15d
fldl   0x198(%rsp)
lea    0xe8d(%rip),%rbx
lea    0xf36(%rip),%rbp
fld    %st(0)
fstpt  0x14(%rsp)
fldt   0x10(%rbx,%r15,2)
fmulp  %st,%st(1)
fstpl  0x170(%rsp)
movsd  0x170(%rsp),%xmm1
movsd  %xmm1,0x38(%rsp)
movsd  0x8(%rsp),%xmm0
subsd  %xmm1,%xmm0
mov    %r13,%rdi
call   *%r14
movsd  %xmm0,0x28(%rsp)
movsd  0x38(%rsp),%xmm0
addsd  0x8(%rsp),%xmm0
mov    %r13,%rdi
call   *%r14
movsd  %xmm0,0x38(%rsp)
movsd  0x28(%rsp),%xmm1
movsd  %xmm1,0x208(%rsp,%r15,1)
movsd  %xmm0,0x1b8(%rsp,%r15,1)
movapd %xmm1,%xmm2
addsd  %xmm0,%xmm2
lea    0xf6c(%rip),%rax
fldt   (%r15,%rax,1)
movsd  %xmm2,0x168(%rsp)
fldl   0x168(%rsp)
movsd  0x50(%rsp),%xmm0
movsd  %xmm0,0x180(%rsp)
fmul   %st,%st(1)
fxch   %st(1)
faddl  0x180(%rsp)
fstpl  0x158(%rsp)
movsd  0x158(%rsp),%xmm0
movsd  %xmm0,0x50(%rsp)
fldt   0x10(%rbp,%r15,2)
fld    %st(0)
fstpt  0x58(%rsp)
movsd  0x20(%rsp),%xmm0
movsd  %xmm0,0x178(%rsp)
fmulp  %st,%st(1)
faddl  0x178(%rsp)
fstpl  0x160(%rsp)
movsd  0x160(%rsp),%xmm0
movsd  %xmm0,0x20(%rsp)
fldl   (%r12)
fstpt  0x64(%rsp)
movapd %xmm1,%xmm0
call   1030 <fabs@plt>
fstpt  0x28(%rsp)
movsd  0x38(%rsp),%xmm0
call   1030 <fabs@plt>
fldt   0x14(%rsp)
fldt   0x28(%rsp)
faddp  %st,%st(2)
fldt   0x58(%rsp)
fmulp  %st,%st(2)
fldt   0x64(%rsp)
faddp  %st,%st(2)
fxch   %st(1)
fstpl  (%r12)
add    $0x10,%r15
cmp    $0x50,%r15
jne    1200 <G_K21+0xe0>
xor    %ebp,%ebp
mov    %rbx,%r15
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
fldt   (%rbx,%r15,1)
fmulp  %st,%st(1)
fstpl  0x148(%rsp)
movsd  0x148(%rsp),%xmm1
movsd  %xmm1,0x38(%rsp)
movsd  0x8(%rsp),%xmm0
subsd  %xmm1,%xmm0
mov    %r13,%rdi
call   *%r14
movsd  %xmm0,0x28(%rsp)
movsd  0x38(%rsp),%xmm0
addsd  0x8(%rsp),%xmm0
mov    %r13,%rdi
call   *%r14
movsd  %xmm0,0x58(%rsp)
movsd  0x28(%rsp),%xmm2
movsd  %xmm2,0x200(%rsp,%rbp,1)
movsd  %xmm0,0x1b0(%rsp,%rbp,1)
movapd %xmm2,%xmm3
addsd  %xmm0,%xmm3
movsd  0x20(%rsp),%xmm1
movsd  %xmm1,0x150(%rsp)
lea    0xd60(%rip),%rax
fldt   (%rbx,%rax,1)
fld    %st(0)
fstpt  0x38(%rsp)
movsd  %xmm3,0x140(%rsp)
fmull  0x140(%rsp)
faddl  0x150(%rsp)
fstpl  0x138(%rsp)
movsd  0x138(%rsp),%xmm0
movsd  %xmm0,0x20(%rsp)
fldl   (%r12)
fstpt  0x64(%rsp)
movapd %xmm2,%xmm0
call   1030 <fabs@plt>
fstpt  0x28(%rsp)
movsd  0x58(%rsp),%xmm0
call   1030 <fabs@plt>
fldt   0x14(%rsp)
fldt   0x28(%rsp)
faddp  %st,%st(2)
fldt   0x38(%rsp)
fmulp  %st,%st(2)
fldt   0x64(%rsp)
faddp  %st,%st(2)
fxch   %st(1)
fstpl  (%r12)
add    $0x20,%rbx
add    $0x10,%rbp
cmp    $0x50,%rbp
jne    1350 <G_K21+0x230>
fstp   %st(0)
movsd  0xba2(%rip),%xmm1
mulsd  0x20(%rsp),%xmm1
movsd  %xmm1,0x8(%rsp)
movsd  0x70(%rsp),%xmm0
subsd  %xmm1,%xmm0
call   1030 <fabs@plt>
fmull  0xb89(%rip)
fstpl  0x128(%rsp)
movsd  0x128(%rsp),%xmm0
mov    0x78(%rsp),%rbp
movsd  %xmm0,0x0(%rbp)
movsd  %xmm0,0x120(%rsp)
movsd  0x200(%rsp),%xmm0
subsd  0x8(%rsp),%xmm0
call   1030 <fabs@plt>
fstpt  0x14(%rsp)
movsd  0x1b0(%rsp),%xmm0
subsd  0x8(%rsp),%xmm0
call   1030 <fabs@plt>
fldt   0x14(%rsp)
faddp  %st,%st(1)
fmull  0xb36(%rip)
faddl  0x120(%rsp)
fstpl  0x118(%rsp)
movsd  0x118(%rsp),%xmm0
movsd  %xmm0,0x0(%rbp)
movsd  %xmm0,0x110(%rsp)
movsd  0x208(%rsp),%xmm0
subsd  0x8(%rsp),%xmm0
call   1030 <fabs@plt>
fstpt  0x14(%rsp)
movsd  0x1b8(%rsp),%xmm0
subsd  0x8(%rsp),%xmm0
call   1030 <fabs@plt>
fldt   0x14(%rsp)
faddp  %st,%st(1)
fmull  0xae1(%rip)
faddl  0x110(%rsp)
fstpl  0x108(%rsp)
movsd  0x108(%rsp),%xmm0
movsd  %xmm0,0x0(%rbp)
movsd  %xmm0,0x100(%rsp)
movsd  0x210(%rsp),%xmm0
subsd  0x8(%rsp),%xmm0
call   1030 <fabs@plt>
fstpt  0x14(%rsp)
movsd  0x1c0(%rsp),%xmm0
subsd  0x8(%rsp),%xmm0
call   1030 <fabs@plt>
fldt   0x14(%rsp)
faddp  %st,%st(1)
fmull  0xa8c(%rip)
faddl  0x100(%rsp)
fstpl  0xf8(%rsp)
movsd  0xf8(%rsp),%xmm0
movsd  %xmm0,0x0(%rbp)
movsd  %xmm0,0xf0(%rsp)
movsd  0x218(%rsp),%xmm0
subsd  0x8(%rsp),%xmm0
call   1030 <fabs@plt>
fstpt  0x14(%rsp)
movsd  0x1c8(%rsp),%xmm0
subsd  0x8(%rsp),%xmm0
call   1030 <fabs@plt>
fldt   0x14(%rsp)
faddp  %st,%st(1)
fmull  0xa37(%rip)
faddl  0xf0(%rsp)
fstpl  0xe8(%rsp)
movsd  0xe8(%rsp),%xmm0
movsd  %xmm0,0x0(%rbp)
movsd  %xmm0,0xe0(%rsp)
movsd  0x220(%rsp),%xmm0
subsd  0x8(%rsp),%xmm0
call   1030 <fabs@plt>
fstpt  0x14(%rsp)
movsd  0x1d0(%rsp),%xmm0
subsd  0x8(%rsp),%xmm0
call   1030 <fabs@plt>
fldt   0x14(%rsp)
faddp  %st,%st(1)
fmull  0x9e2(%rip)
faddl  0xe0(%rsp)
fstpl  0xd8(%rsp)
movsd  0xd8(%rsp),%xmm0
movsd  %xmm0,0x0(%rbp)
movsd  %xmm0,0xd0(%rsp)
movsd  0x228(%rsp),%xmm0
subsd  0x8(%rsp),%xmm0
call   1030 <fabs@plt>
fstpt  0x14(%rsp)
movsd  0x1d8(%rsp),%xmm0
subsd  0x8(%rsp),%xmm0
call   1030 <fabs@plt>
fldt   0x14(%rsp)
faddp  %st,%st(1)
fmull  0x98d(%rip)
faddl  0xd0(%rsp)
fstpl  0xc8(%rsp)
movsd  0xc8(%rsp),%xmm0
movsd  %xmm0,0x0(%rbp)
movsd  %xmm0,0xc0(%rsp)
movsd  0x230(%rsp),%xmm0
subsd  0x8(%rsp),%xmm0
call   1030 <fabs@plt>
fstpt  0x14(%rsp)
movsd  0x1e0(%rsp),%xmm0
subsd  0x8(%rsp),%xmm0
call   1030 <fabs@plt>
fldt   0x14(%rsp)
faddp  %st,%st(1)
fmull  0x938(%rip)
faddl  0xc0(%rsp)
fstpl  0xb8(%rsp)
movsd  0xb8(%rsp),%xmm0
movsd  %xmm0,0x0(%rbp)
movsd  %xmm0,0xb0(%rsp)
movsd  0x238(%rsp),%xmm0
subsd  0x8(%rsp),%xmm0
call   1030 <fabs@plt>
fstpt  0x14(%rsp)
movsd  0x1e8(%rsp),%xmm0
subsd  0x8(%rsp),%xmm0
call   1030 <fabs@plt>
fldt   0x14(%rsp)
faddp  %st,%st(1)
fmull  0x8e3(%rip)
faddl  0xb0(%rsp)
fstpl  0xa8(%rsp)
movsd  0xa8(%rsp),%xmm0
movsd  %xmm0,0x0(%rbp)
movsd  %xmm0,0xa0(%rsp)
movsd  0x240(%rsp),%xmm0
subsd  0x8(%rsp),%xmm0
call   1030 <fabs@plt>
fstpt  0x14(%rsp)
movsd  0x1f0(%rsp),%xmm0
subsd  0x8(%rsp),%xmm0
call   1030 <fabs@plt>
fldt   0x14(%rsp)
faddp  %st,%st(1)
fmull  0x88e(%rip)
faddl  0xa0(%rsp)
fstpl  0x98(%rsp)
movsd  0x98(%rsp),%xmm0
movsd  %xmm0,0x0(%rbp)
movsd  %xmm0,0x90(%rsp)
movsd  0x248(%rsp),%xmm0
subsd  0x8(%rsp),%xmm0
call   1030 <fabs@plt>
fstpt  0x14(%rsp)
movsd  0x1f8(%rsp),%xmm0
subsd  0x8(%rsp),%xmm0
call   1030 <fabs@plt>
fldt   0x14(%rsp)
faddp  %st,%st(1)
fmull  0x839(%rip)
faddl  0x90(%rsp)
fstpl  0x0(%rbp)
fldt   0x1a4(%rsp)
fstpl  0x130(%rsp)
movsd  0x130(%rsp),%xmm0
movsd  (%r12),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%r12)
mulsd  0x0(%rbp),%xmm0
movsd  %xmm0,0x0(%rbp)
movsd  0x20(%rsp),%xmm0
subsd  0x50(%rsp),%xmm0
mulsd  0x48(%rsp),%xmm0
call   1030 <fabs@plt>
fstpl  0x88(%rsp)
movsd  0x88(%rsp),%xmm0
mov    0x80(%rsp),%rbx
movsd  %xmm0,(%rbx)
movsd  0x0(%rbp),%xmm2
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm2
jne    189e <G_K21+0x77e>
jnp    1907 <G_K21+0x7e7>
ucomisd %xmm1,%xmm0
jne    18a6 <G_K21+0x786>
jnp    1907 <G_K21+0x7e7>
mulsd  0x7b2(%rip),%xmm0
divsd  %xmm2,%xmm0
movsd  0x7ae(%rip),%xmm1
movsd  %xmm2,0x8(%rsp)
call   1040 <pow@plt>
movapd %xmm0,%xmm1
movsd  0x79f(%rip),%xmm0
ucomisd %xmm0,%xmm1
ja     18f5 <G_K21+0x7d5>
movsd  (%rbx),%xmm0
mulsd  0x77d(%rip),%xmm0
divsd  0x0(%rbp),%xmm0
movsd  0x778(%rip),%xmm1
call   1040 <pow@plt>
movsd  0x8(%rsp),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rbx)
movapd %xmm1,%xmm0
movsd  0x20(%rsp),%xmm4
movsd  (%r12),%xmm1
mov    0x26ce(%rip),%rax
movsd  (%rax),%xmm2
mov    0x26b3(%rip),%rax
mulsd  0x74b(%rip),%xmm2
movsd  (%rax),%xmm3
divsd  %xmm2,%xmm3
ucomisd %xmm3,%xmm1
jbe    1947 <G_K21+0x827>
mulsd  %xmm2,%xmm1
maxsd  %xmm0,%xmm1
movsd  %xmm1,(%rbx)
movsd  0x48(%rsp),%xmm0
mulsd  %xmm4,%xmm0
add    $0x258,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@G_K21.XGK21 = internal global [11 x x86_fp80] [x86_fp80 0xK3FFEFEE3634939572800, x86_fp80 0xK3FFEF951F0315796C000, x86_fp80 0xK3FFEEE1ECD25808E3000, x86_fp80 0xK3FFEDD74CAF4E5979800, x86_fp80 0xK3FFEC7E3ABA7D3631000, x86_fp80 0xK3FFEADEDC9146F0CC000, x86_fp80 0xK3FFE9010DA00FE090000, x86_fp80 0xK3FFDDDE600480B56E000, x86_fp80 0xK3FFD96BAA94AF509B800, x86_fp80 0xK3FFC987283C48F13D000, x86_fp80 0xK00000000000000000000]
@G_K21.WGK21 = internal global [11 x x86_fp80] [x86_fp80 0xK3FF8BF9ADEDE5441F800, x86_fp80 0xK3FFA855BB5254A021000, x86_fp80 0xK3FFAE047B810CCCD1000, x86_fp80 0xK3FFB99AE66A9B9172800, x86_fp80 0xK3FFBBEB88EEEE59C4800, x86_fp80 0xK3FFBE0065FED440C7800, x86_fp80 0xK3FFBFCE95C7AE96EF000, x86_fp80 0xK3FFC89F1368B4A46A000, x86_fp80 0xK3FFC9233DB0B60702800, x86_fp80 0xK3FFC9748EB7F90F5A800, x86_fp80 0xK3FFC9908415BE6887800]
@G_K21.WG10 = internal global [5 x x86_fp80] [x86_fp80 0xK3FFB888AFC5B16E0F800, x86_fp80 0xK3FFC9909C643C77F2800, x86_fp80 0xK3FFCE0582CE805E18800, x86_fp80 0xK3FFD89DD53D2ACDFF000, x86_fp80 0xK3FFD974EF380A6B77800]
@DBL_MIN = global double 0.000000e+00
@DBL_EPSILON = global double 0.000000e+00
define double @G_K21(double (double, i8*)* %0, i8* %1, double %2, double %3, double* %4, double* %5, double* %6) {
%8 = alloca double (double, i8*)*
%9 = alloca i8*
%10 = alloca double
%11 = alloca double
%12 = alloca double*
%13 = alloca double*
%14 = alloca double*
%15 = alloca [10 x double]
%16 = alloca [10 x double]
%17 = alloca double
%18 = alloca double
%19 = alloca double
%20 = alloca double
%21 = alloca double
%22 = alloca double
%23 = alloca double
%24 = alloca double
%25 = alloca double
%26 = alloca double
%27 = alloca double
%28 = alloca double
%29 = alloca i32
%30 = alloca i32
%31 = alloca i32
store double (double, i8*)* %0, double (double, i8*)** %8
store i8* %1, i8** %9
store double %2, double* %10
store double %3, double* %11
store double* %4, double** %12
store double* %5, double** %13
store double* %6, double** %14
%32 = load double, double* %10
%33 = load double, double* %11
%34 = fadd double %32, %33
%35 = fmul double 5.000000e-01, %34
store double %35, double* %18
%36 = load double, double* %11
%37 = load double, double* %10
%38 = fsub double %36, %37
%39 = fmul double 5.000000e-01, %38
store double %39, double* %24
%40 = load double, double* %24
%41 = call x86_fp80 @fabs(double %40)
%42 = fptrunc x86_fp80 %41 to double
store double %42, double* %19
store double 0.000000e+00, double* %25
%43 = load double (double, i8*)*, double (double, i8*)** %8
%44 = load double, double* %18
%45 = load i8*, i8** %9
%46 = call double %43(double %44, i8* %45)
store double %46, double* %20
%47 = load double, double* %20
%48 = fpext double %47 to x86_fp80
%49 = load x86_fp80, x86_fp80* getelementptr inbounds ([11 x x86_fp80], [11 x x86_fp80]* @G_K21.WGK21, i64 0, i64 10)
%50 = fmul x86_fp80 %48, %49
%51 = fptrunc x86_fp80 %50 to double
store double %51, double* %26
%52 = load double, double* %26
%53 = call x86_fp80 @fabs(double %52)
%54 = fptrunc x86_fp80 %53 to double
%55 = load double*, double** %13
store double %54, double* %55
store i32 0, i32* %29
br label %56
56: ; preds = %129, %7
%57 = load i32, i32* %29
%58 = icmp slt i32 %57, 5
br i1 %58, label %59, label %132
59: ; preds = %56
%60 = load i32, i32* %29
%61 = mul nsw i32 2, %60
%62 = add nsw i32 %61, 1
store i32 %62, i32* %30
%63 = load double, double* %24
%64 = fpext double %63 to x86_fp80
%65 = load i32, i32* %30
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds [11 x x86_fp80], [11 x x86_fp80]* @G_K21.XGK21, i64 0, i64 %66
%68 = load x86_fp80, x86_fp80* %67
%69 = fmul x86_fp80 %64, %68
%70 = fptrunc x86_fp80 %69 to double
store double %70, double* %17
%71 = load double (double, i8*)*, double (double, i8*)** %8
%72 = load double, double* %18
%73 = load double, double* %17
%74 = fsub double %72, %73
%75 = load i8*, i8** %9
%76 = call double %71(double %74, i8* %75)
store double %76, double* %22
%77 = load double (double, i8*)*, double (double, i8*)** %8
%78 = load double, double* %18
%79 = load double, double* %17
%80 = fadd double %78, %79
%81 = load i8*, i8** %9
%82 = call double %77(double %80, i8* %81)
store double %82, double* %23
%83 = load double, double* %22
%84 = load i32, i32* %30
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds [10 x double], [10 x double]* %15, i64 0, i64 %85
store double %83, double* %86
%87 = load double, double* %23
%88 = load i32, i32* %30
%89 = sext i32 %88 to i64
%90 = getelementptr inbounds [10 x double], [10 x double]* %16, i64 0, i64 %89
store double %87, double* %90
%91 = load double, double* %22
%92 = load double, double* %23
%93 = fadd double %91, %92
store double %93, double* %21
%94 = load i32, i32* %29
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds [5 x x86_fp80], [5 x x86_fp80]* @G_K21.WG10, i64 0, i64 %95
%97 = load x86_fp80, x86_fp80* %96
%98 = load double, double* %21
%99 = fpext double %98 to x86_fp80
%100 = load double, double* %25
%101 = fpext double %100 to x86_fp80
%102 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %97, x86_fp80 %99, x86_fp80 %101)
%103 = fptrunc x86_fp80 %102 to double
store double %103, double* %25
%104 = load i32, i32* %30
%105 = sext i32 %104 to i64
%106 = getelementptr inbounds [11 x x86_fp80], [11 x x86_fp80]* @G_K21.WGK21, i64 0, i64 %105
%107 = load x86_fp80, x86_fp80* %106
%108 = load double, double* %21
%109 = fpext double %108 to x86_fp80
%110 = load double, double* %26
%111 = fpext double %110 to x86_fp80
%112 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %107, x86_fp80 %109, x86_fp80 %111)
%113 = fptrunc x86_fp80 %112 to double
store double %113, double* %26
%114 = load double*, double** %13
%115 = load double, double* %114
%116 = fpext double %115 to x86_fp80
%117 = load i32, i32* %30
%118 = sext i32 %117 to i64
%119 = getelementptr inbounds [11 x x86_fp80], [11 x x86_fp80]* @G_K21.WGK21, i64 0, i64 %118
%120 = load x86_fp80, x86_fp80* %119
%121 = load double, double* %22
%122 = call x86_fp80 @fabs(double %121)
%123 = load double, double* %23
%124 = call x86_fp80 @fabs(double %123)
%125 = fadd x86_fp80 %122, %124
%126 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %120, x86_fp80 %125, x86_fp80 %116)
%127 = fptrunc x86_fp80 %126 to double
%128 = load double*, double** %13
store double %127, double* %128
br label %129
129: ; preds = %59
%130 = load i32, i32* %29
%131 = add nsw i32 %130, 1
store i32 %131, i32* %29
br label %56
132: ; preds = %56
store i32 0, i32* %29
br label %133
133: ; preds = %195, %132
%134 = load i32, i32* %29
%135 = icmp slt i32 %134, 5
br i1 %135, label %136, label %198
136: ; preds = %133
%137 = load i32, i32* %29
%138 = mul nsw i32 %137, 2
store i32 %138, i32* %31
%139 = load double, double* %24
%140 = fpext double %139 to x86_fp80
%141 = load i32, i32* %31
%142 = sext i32 %141 to i64
%143 = getelementptr inbounds [11 x x86_fp80], [11 x x86_fp80]* @G_K21.XGK21, i64 0, i64 %142
%144 = load x86_fp80, x86_fp80* %143
%145 = fmul x86_fp80 %140, %144
%146 = fptrunc x86_fp80 %145 to double
store double %146, double* %17
%147 = load double (double, i8*)*, double (double, i8*)** %8
%148 = load double, double* %18
%149 = load double, double* %17
%150 = fsub double %148, %149
%151 = load i8*, i8** %9
%152 = call double %147(double %150, i8* %151)
store double %152, double* %22
%153 = load double (double, i8*)*, double (double, i8*)** %8
%154 = load double, double* %18
%155 = load double, double* %17
%156 = fadd double %154, %155
%157 = load i8*, i8** %9
%158 = call double %153(double %156, i8* %157)
store double %158, double* %23
%159 = load double, double* %22
%160 = load i32, i32* %31
%161 = sext i32 %160 to i64
%162 = getelementptr inbounds [10 x double], [10 x double]* %15, i64 0, i64 %161
store double %159, double* %162
%163 = load double, double* %23
%164 = load i32, i32* %31
%165 = sext i32 %164 to i64
%166 = getelementptr inbounds [10 x double], [10 x double]* %16, i64 0, i64 %165
store double %163, double* %166
%167 = load double, double* %22
%168 = load double, double* %23
%169 = fadd double %167, %168
store double %169, double* %21
%170 = load double, double* %26
%171 = fpext double %170 to x86_fp80
%172 = load i32, i32* %31
%173 = sext i32 %172 to i64
%174 = getelementptr inbounds [11 x x86_fp80], [11 x x86_fp80]* @G_K21.WGK21, i64 0, i64 %173
%175 = load x86_fp80, x86_fp80* %174
%176 = load double, double* %21
%177 = fpext double %176 to x86_fp80
%178 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %175, x86_fp80 %177, x86_fp80 %171)
%179 = fptrunc x86_fp80 %178 to double
store double %179, double* %26
%180 = load double*, double** %13
%181 = load double, double* %180
%182 = fpext double %181 to x86_fp80
%183 = load i32, i32* %31
%184 = sext i32 %183 to i64
%185 = getelementptr inbounds [11 x x86_fp80], [11 x x86_fp80]* @G_K21.WGK21, i64 0, i64 %184
%186 = load x86_fp80, x86_fp80* %185
%187 = load double, double* %22
%188 = call x86_fp80 @fabs(double %187)
%189 = load double, double* %23
%190 = call x86_fp80 @fabs(double %189)
%191 = fadd x86_fp80 %188, %190
%192 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %186, x86_fp80 %191, x86_fp80 %182)
%193 = fptrunc x86_fp80 %192 to double
%194 = load double*, double** %13
store double %193, double* %194
br label %195
195: ; preds = %136
%196 = load i32, i32* %29
%197 = add nsw i32 %196, 1
store i32 %197, i32* %29
br label %133
198: ; preds = %133
%199 = load double, double* %26
%200 = fmul double %199, 5.000000e-01
store double %200, double* %27
%201 = load x86_fp80, x86_fp80* getelementptr inbounds ([11 x x86_fp80], [11 x x86_fp80]* @G_K21.WGK21, i64 0, i64 10)
%202 = load double, double* %20
%203 = load double, double* %27
%204 = fsub double %202, %203
%205 = call x86_fp80 @fabs(double %204)
%206 = fmul x86_fp80 %201, %205
%207 = fptrunc x86_fp80 %206 to double
%208 = load double*, double** %14
store double %207, double* %208
store i32 0, i32* %29
br label %209
209: ; preds = %238, %198
%210 = load i32, i32* %29
%211 = icmp slt i32 %210, 10
br i1 %211, label %212, label %241
212: ; preds = %209
%213 = load double*, double** %14
%214 = load double, double* %213
%215 = fpext double %214 to x86_fp80
%216 = load i32, i32* %29
%217 = sext i32 %216 to i64
%218 = getelementptr inbounds [11 x x86_fp80], [11 x x86_fp80]* @G_K21.WGK21, i64 0, i64 %217
%219 = load x86_fp80, x86_fp80* %218
%220 = load i32, i32* %29
%221 = sext i32 %220 to i64
%222 = getelementptr inbounds [10 x double], [10 x double]* %15, i64 0, i64 %221
%223 = load double, double* %222
%224 = load double, double* %27
%225 = fsub double %223, %224
%226 = call x86_fp80 @fabs(double %225)
%227 = load i32, i32* %29
%228 = sext i32 %227 to i64
%229 = getelementptr inbounds [10 x double], [10 x double]* %16, i64 0, i64 %228
%230 = load double, double* %229
%231 = load double, double* %27
%232 = fsub double %230, %231
%233 = call x86_fp80 @fabs(double %232)
%234 = fadd x86_fp80 %226, %233
%235 = call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %219, x86_fp80 %234, x86_fp80 %215)
%236 = fptrunc x86_fp80 %235 to double
%237 = load double*, double** %14
store double %236, double* %237
br label %238
238: ; preds = %212
%239 = load i32, i32* %29
%240 = add nsw i32 %239, 1
store i32 %240, i32* %29
br label %209
241: ; preds = %209
%242 = load double, double* %26
%243 = load double, double* %24
%244 = fmul double %242, %243
store double %244, double* %28
%245 = load double*, double** %13
%246 = load double, double* %245
%247 = load double, double* %19
%248 = fmul double %246, %247
%249 = load double*, double** %13
store double %248, double* %249
%250 = load double*, double** %14
%251 = load double, double* %250
%252 = load double, double* %19
%253 = fmul double %251, %252
%254 = load double*, double** %14
store double %253, double* %254
%255 = load double, double* %26
%256 = load double, double* %25
%257 = fsub double %255, %256
%258 = load double, double* %24
%259 = fmul double %257, %258
%260 = call x86_fp80 @fabs(double %259)
%261 = fptrunc x86_fp80 %260 to double
%262 = load double*, double** %12
store double %261, double* %262
%263 = load double*, double** %14
%264 = load double, double* %263
%265 = fcmp une double %264, 0.000000e+00
br i1 %265, label %266, label %294
266: ; preds = %241
%267 = load double*, double** %12
%268 = load double, double* %267
%269 = fcmp une double %268, 0.000000e+00
br i1 %269, label %270, label %294
270: ; preds = %266
%271 = load double*, double** %14
%272 = load double, double* %271
%273 = load double*, double** %12
%274 = load double, double* %273
%275 = fmul double 2.000000e+02, %274
%276 = load double*, double** %14
%277 = load double, double* %276
%278 = fdiv double %275, %277
%279 = call double @pow(double %278, double 1.500000e+00)
%280 = fcmp olt double 1.000000e+00, %279
br i1 %280, label %281, label %282
281: ; preds = %270
br label %290
282: ; preds = %270
%283 = load double*, double** %12
%284 = load double, double* %283
%285 = fmul double 2.000000e+02, %284
%286 = load double*, double** %14
%287 = load double, double* %286
%288 = fdiv double %285, %287
%289 = call double @pow(double %288, double 1.500000e+00)
br label %290
290: ; preds = %282, %281
%291 = phi double [ 1.000000e+00, %281 ], [ %289, %282 ]
%292 = fmul double %272, %291
%293 = load double*, double** %12
store double %292, double* %293
br label %294
294: ; preds = %290, %266, %241
%295 = load double*, double** %13
%296 = load double, double* %295
%297 = load double, double* @DBL_MIN
%298 = load double, double* @DBL_EPSILON
%299 = fmul double 5.000000e+01, %298
%300 = fdiv double %297, %299
%301 = fcmp ogt double %296, %300
br i1 %301, label %302, label %323
302: ; preds = %294
%303 = load double, double* @DBL_EPSILON
%304 = fmul double %303, 5.000000e+01
%305 = load double*, double** %13
%306 = load double, double* %305
%307 = fmul double %304, %306
%308 = load double*, double** %12
%309 = load double, double* %308
%310 = fcmp ogt double %307, %309
br i1 %310, label %311, label %317
311: ; preds = %302
%312 = load double, double* @DBL_EPSILON
%313 = fmul double %312, 5.000000e+01
%314 = load double*, double** %13
%315 = load double, double* %314
%316 = fmul double %313, %315
br label %320
317: ; preds = %302
%318 = load double*, double** %12
%319 = load double, double* %318
br label %320
320: ; preds = %317, %311
%321 = phi double [ %316, %311 ], [ %319, %317 ]
%322 = load double*, double** %12
store double %321, double* %322
br label %323
323: ; preds = %320, %294
%324 = load double, double* %28
ret double %324
}

LLVM IR (-O2):
@G_K21.XGK21 = internal unnamed_addr constant [11 x x86_fp80] [x86_fp80 0xK3FFEFEE3634939572800, x86_fp80 0xK3FFEF951F0315796C000, x86_fp80 0xK3FFEEE1ECD25808E3000, x86_fp80 0xK3FFEDD74CAF4E5979800, x86_fp80 0xK3FFEC7E3ABA7D3631000, x86_fp80 0xK3FFEADEDC9146F0CC000, x86_fp80 0xK3FFE9010DA00FE090000, x86_fp80 0xK3FFDDDE600480B56E000, x86_fp80 0xK3FFD96BAA94AF509B800, x86_fp80 0xK3FFC987283C48F13D000, x86_fp80 0xK00000000000000000000]
@G_K21.WGK21 = internal unnamed_addr constant [11 x x86_fp80] [x86_fp80 0xK3FF8BF9ADEDE5441F800, x86_fp80 0xK3FFA855BB5254A021000, x86_fp80 0xK3FFAE047B810CCCD1000, x86_fp80 0xK3FFB99AE66A9B9172800, x86_fp80 0xK3FFBBEB88EEEE59C4800, x86_fp80 0xK3FFBE0065FED440C7800, x86_fp80 0xK3FFBFCE95C7AE96EF000, x86_fp80 0xK3FFC89F1368B4A46A000, x86_fp80 0xK3FFC9233DB0B60702800, x86_fp80 0xK3FFC9748EB7F90F5A800, x86_fp80 0xK3FFC9908415BE6887800]
@G_K21.WG10 = internal unnamed_addr constant [5 x x86_fp80] [x86_fp80 0xK3FFB888AFC5B16E0F800, x86_fp80 0xK3FFC9909C643C77F2800, x86_fp80 0xK3FFCE0582CE805E18800, x86_fp80 0xK3FFD89DD53D2ACDFF000, x86_fp80 0xK3FFD974EF380A6B77800]
@DBL_MIN = global double 0.000000e+00
@DBL_EPSILON = global double 0.000000e+00
define double @G_K21(double (double, i8*)* nocapture %0, i8* %1, double %2, double %3, double* nocapture %4, double* nocapture %5, double* nocapture %6) {
%8 = alloca [10 x double]
%9 = alloca [10 x double]
%10 = bitcast [10 x double]* %8 to i8*
%11 = bitcast [10 x double]* %9 to i8*
%12 = fadd double %2, %3
%13 = fmul double %12, 5.000000e-01
%14 = fsub double %3, %2
%15 = fmul double %14, 5.000000e-01
%16 = tail call x86_fp80 @fabs(double %15)
%17 = tail call double %0(double %13, i8* %1)
%18 = fpext double %17 to x86_fp80
%19 = fmul x86_fp80 %18, 0xK3FFC9908415BE6887800
%20 = fptrunc x86_fp80 %19 to double
%21 = tail call x86_fp80 @fabs(double %20)
%22 = fptrunc x86_fp80 %21 to double
store double %22, double* %5
%23 = fpext double %15 to x86_fp80
br label %24
24: ; preds = %7, %24
%25 = phi i64 [ 0, %7 ], [ %59, %24 ]
%26 = phi double [ %20, %7 ], [ %51, %24 ]
%27 = phi double [ 0.000000e+00, %7 ], [ %46, %24 ]
%28 = shl nuw nsw i64 %25, 1
%29 = or i64 %28, 1
%30 = getelementptr inbounds [11 x x86_fp80], [11 x x86_fp80]* @G_K21.XGK21, i64 0, i64 %29
%31 = load x86_fp80, x86_fp80* %30
%32 = fmul x86_fp80 %31, %23
%33 = fptrunc x86_fp80 %32 to double
%34 = fsub double %13, %33
%35 = tail call double %0(double %34, i8* %1)
%36 = fadd double %13, %33
%37 = tail call double %0(double %36, i8* %1)
%38 = getelementptr inbounds [10 x double], [10 x double]* %8, i64 0, i64 %29
store double %35, double* %38
%39 = getelementptr inbounds [10 x double], [10 x double]* %9, i64 0, i64 %29
store double %37, double* %39
%40 = fadd double %35, %37
%41 = getelementptr inbounds [5 x x86_fp80], [5 x x86_fp80]* @G_K21.WG10, i64 0, i64 %25
%42 = load x86_fp80, x86_fp80* %41
%43 = fpext double %40 to x86_fp80
%44 = fpext double %27 to x86_fp80
%45 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %42, x86_fp80 %43, x86_fp80 %44)
%46 = fptrunc x86_fp80 %45 to double
%47 = getelementptr inbounds [11 x x86_fp80], [11 x x86_fp80]* @G_K21.WGK21, i64 0, i64 %29
%48 = load x86_fp80, x86_fp80* %47
%49 = fpext double %26 to x86_fp80
%50 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %48, x86_fp80 %43, x86_fp80 %49)
%51 = fptrunc x86_fp80 %50 to double
%52 = load double, double* %5
%53 = fpext double %52 to x86_fp80
%54 = tail call x86_fp80 @fabs(double %35)
%55 = tail call x86_fp80 @fabs(double %37)
%56 = fadd x86_fp80 %54, %55
%57 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %48, x86_fp80 %56, x86_fp80 %53)
%58 = fptrunc x86_fp80 %57 to double
store double %58, double* %5
%59 = add nuw nsw i64 %25, 1
%60 = icmp eq i64 %59, 5
br i1 %60, label %61, label %24
61: ; preds = %24, %61
%62 = phi i64 [ %89, %61 ], [ 0, %24 ]
%63 = phi double [ %81, %61 ], [ %51, %24 ]
%64 = shl nuw nsw i64 %62, 1
%65 = getelementptr inbounds [11 x x86_fp80], [11 x x86_fp80]* @G_K21.XGK21, i64 0, i64 %64
%66 = load x86_fp80, x86_fp80* %65
%67 = fmul x86_fp80 %66, %23
%68 = fptrunc x86_fp80 %67 to double
%69 = fsub double %13, %68
%70 = tail call double %0(double %69, i8* %1)
%71 = fadd double %13, %68
%72 = tail call double %0(double %71, i8* %1)
%73 = getelementptr inbounds [10 x double], [10 x double]* %8, i64 0, i64 %64
store double %70, double* %73
%74 = getelementptr inbounds [10 x double], [10 x double]* %9, i64 0, i64 %64
store double %72, double* %74
%75 = fadd double %70, %72
%76 = fpext double %63 to x86_fp80
%77 = getelementptr inbounds [11 x x86_fp80], [11 x x86_fp80]* @G_K21.WGK21, i64 0, i64 %64
%78 = load x86_fp80, x86_fp80* %77
%79 = fpext double %75 to x86_fp80
%80 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %78, x86_fp80 %79, x86_fp80 %76)
%81 = fptrunc x86_fp80 %80 to double
%82 = load double, double* %5
%83 = fpext double %82 to x86_fp80
%84 = tail call x86_fp80 @fabs(double %70)
%85 = tail call x86_fp80 @fabs(double %72)
%86 = fadd x86_fp80 %84, %85
%87 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %78, x86_fp80 %86, x86_fp80 %83)
%88 = fptrunc x86_fp80 %87 to double
store double %88, double* %5
%89 = add nuw nsw i64 %62, 1
%90 = icmp eq i64 %89, 5
br i1 %90, label %91, label %61
91: ; preds = %61
%92 = fmul double %81, 5.000000e-01
%93 = fsub double %17, %92
%94 = tail call x86_fp80 @fabs(double %93)
%95 = fmul x86_fp80 %94, 0xK3FFC9908415BE6887800
%96 = fptrunc x86_fp80 %95 to double
store double %96, double* %6
%97 = fpext double %96 to x86_fp80
%98 = getelementptr inbounds [10 x double], [10 x double]* %8, i64 0, i64 0
%99 = load double, double* %98
%100 = fsub double %99, %92
%101 = tail call x86_fp80 @fabs(double %100)
%102 = getelementptr inbounds [10 x double], [10 x double]* %9, i64 0, i64 0
%103 = load double, double* %102
%104 = fsub double %103, %92
%105 = tail call x86_fp80 @fabs(double %104)
%106 = fadd x86_fp80 %101, %105
%107 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %106, x86_fp80 0xK3FF8BF9ADEDE5441F800, x86_fp80 %97)
%108 = fptrunc x86_fp80 %107 to double
store double %108, double* %6
%109 = fpext double %108 to x86_fp80
%110 = getelementptr inbounds [10 x double], [10 x double]* %8, i64 0, i64 1
%111 = load double, double* %110
%112 = fsub double %111, %92
%113 = tail call x86_fp80 @fabs(double %112)
%114 = getelementptr inbounds [10 x double], [10 x double]* %9, i64 0, i64 1
%115 = load double, double* %114
%116 = fsub double %115, %92
%117 = tail call x86_fp80 @fabs(double %116)
%118 = fadd x86_fp80 %113, %117
%119 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %118, x86_fp80 0xK3FFA855BB5254A021000, x86_fp80 %109)
%120 = fptrunc x86_fp80 %119 to double
store double %120, double* %6
%121 = fpext double %120 to x86_fp80
%122 = getelementptr inbounds [10 x double], [10 x double]* %8, i64 0, i64 2
%123 = load double, double* %122
%124 = fsub double %123, %92
%125 = tail call x86_fp80 @fabs(double %124)
%126 = getelementptr inbounds [10 x double], [10 x double]* %9, i64 0, i64 2
%127 = load double, double* %126
%128 = fsub double %127, %92
%129 = tail call x86_fp80 @fabs(double %128)
%130 = fadd x86_fp80 %125, %129
%131 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %130, x86_fp80 0xK3FFAE047B810CCCD1000, x86_fp80 %121)
%132 = fptrunc x86_fp80 %131 to double
store double %132, double* %6
%133 = fpext double %132 to x86_fp80
%134 = getelementptr inbounds [10 x double], [10 x double]* %8, i64 0, i64 3
%135 = load double, double* %134
%136 = fsub double %135, %92
%137 = tail call x86_fp80 @fabs(double %136)
%138 = getelementptr inbounds [10 x double], [10 x double]* %9, i64 0, i64 3
%139 = load double, double* %138
%140 = fsub double %139, %92
%141 = tail call x86_fp80 @fabs(double %140)
%142 = fadd x86_fp80 %137, %141
%143 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %142, x86_fp80 0xK3FFB99AE66A9B9172800, x86_fp80 %133)
%144 = fptrunc x86_fp80 %143 to double
store double %144, double* %6
%145 = fpext double %144 to x86_fp80
%146 = getelementptr inbounds [10 x double], [10 x double]* %8, i64 0, i64 4
%147 = load double, double* %146
%148 = fsub double %147, %92
%149 = tail call x86_fp80 @fabs(double %148)
%150 = getelementptr inbounds [10 x double], [10 x double]* %9, i64 0, i64 4
%151 = load double, double* %150
%152 = fsub double %151, %92
%153 = tail call x86_fp80 @fabs(double %152)
%154 = fadd x86_fp80 %149, %153
%155 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %154, x86_fp80 0xK3FFBBEB88EEEE59C4800, x86_fp80 %145)
%156 = fptrunc x86_fp80 %155 to double
store double %156, double* %6
%157 = fpext double %156 to x86_fp80
%158 = getelementptr inbounds [10 x double], [10 x double]* %8, i64 0, i64 5
%159 = load double, double* %158
%160 = fsub double %159, %92
%161 = tail call x86_fp80 @fabs(double %160)
%162 = getelementptr inbounds [10 x double], [10 x double]* %9, i64 0, i64 5
%163 = load double, double* %162
%164 = fsub double %163, %92
%165 = tail call x86_fp80 @fabs(double %164)
%166 = fadd x86_fp80 %161, %165
%167 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %166, x86_fp80 0xK3FFBE0065FED440C7800, x86_fp80 %157)
%168 = fptrunc x86_fp80 %167 to double
store double %168, double* %6
%169 = fpext double %168 to x86_fp80
%170 = getelementptr inbounds [10 x double], [10 x double]* %8, i64 0, i64 6
%171 = load double, double* %170
%172 = fsub double %171, %92
%173 = tail call x86_fp80 @fabs(double %172)
%174 = getelementptr inbounds [10 x double], [10 x double]* %9, i64 0, i64 6
%175 = load double, double* %174
%176 = fsub double %175, %92
%177 = tail call x86_fp80 @fabs(double %176)
%178 = fadd x86_fp80 %173, %177
%179 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %178, x86_fp80 0xK3FFBFCE95C7AE96EF000, x86_fp80 %169)
%180 = fptrunc x86_fp80 %179 to double
store double %180, double* %6
%181 = fpext double %180 to x86_fp80
%182 = getelementptr inbounds [10 x double], [10 x double]* %8, i64 0, i64 7
%183 = load double, double* %182
%184 = fsub double %183, %92
%185 = tail call x86_fp80 @fabs(double %184)
%186 = getelementptr inbounds [10 x double], [10 x double]* %9, i64 0, i64 7
%187 = load double, double* %186
%188 = fsub double %187, %92
%189 = tail call x86_fp80 @fabs(double %188)
%190 = fadd x86_fp80 %185, %189
%191 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %190, x86_fp80 0xK3FFC89F1368B4A46A000, x86_fp80 %181)
%192 = fptrunc x86_fp80 %191 to double
store double %192, double* %6
%193 = fpext double %192 to x86_fp80
%194 = getelementptr inbounds [10 x double], [10 x double]* %8, i64 0, i64 8
%195 = load double, double* %194
%196 = fsub double %195, %92
%197 = tail call x86_fp80 @fabs(double %196)
%198 = getelementptr inbounds [10 x double], [10 x double]* %9, i64 0, i64 8
%199 = load double, double* %198
%200 = fsub double %199, %92
%201 = tail call x86_fp80 @fabs(double %200)
%202 = fadd x86_fp80 %197, %201
%203 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %202, x86_fp80 0xK3FFC9233DB0B60702800, x86_fp80 %193)
%204 = fptrunc x86_fp80 %203 to double
store double %204, double* %6
%205 = fpext double %204 to x86_fp80
%206 = getelementptr inbounds [10 x double], [10 x double]* %8, i64 0, i64 9
%207 = load double, double* %206
%208 = fsub double %207, %92
%209 = tail call x86_fp80 @fabs(double %208)
%210 = getelementptr inbounds [10 x double], [10 x double]* %9, i64 0, i64 9
%211 = load double, double* %210
%212 = fsub double %211, %92
%213 = tail call x86_fp80 @fabs(double %212)
%214 = fadd x86_fp80 %209, %213
%215 = tail call x86_fp80 @llvm.fmuladd.f80(x86_fp80 %214, x86_fp80 0xK3FFC9748EB7F90F5A800, x86_fp80 %205)
%216 = fptrunc x86_fp80 %215 to double
store double %216, double* %6
%217 = fptrunc x86_fp80 %16 to double
%218 = load double, double* %5
%219 = fmul double %218, %217
store double %219, double* %5
%220 = load double, double* %6
%221 = fmul double %220, %217
store double %221, double* %6
%222 = fsub double %81, %46
%223 = fmul double %15, %222
%224 = tail call x86_fp80 @fabs(double %223)
%225 = fptrunc x86_fp80 %224 to double
store double %225, double* %4
%226 = load double, double* %6
%227 = fcmp une double %226, 0.000000e+00
%228 = fcmp une double %225, 0.000000e+00
%229 = select i1 %227, i1 %228, i1 false
br i1 %229, label %230, label %244
230: ; preds = %91
%231 = fmul double %225, 2.000000e+02
%232 = fdiv double %231, %226
%233 = tail call double @pow(double %232, double 1.500000e+00)
%234 = fcmp ogt double %233, 1.000000e+00
br i1 %234, label %241, label %235
235: ; preds = %230
%236 = load double, double* %4
%237 = fmul double %236, 2.000000e+02
%238 = load double, double* %6
%239 = fdiv double %237, %238
%240 = tail call double @pow(double %239, double 1.500000e+00)
br label %241
241: ; preds = %230, %235
%242 = phi double [ %240, %235 ], [ 1.000000e+00, %230 ]
%243 = fmul double %226, %242
store double %243, double* %4
br label %244
244: ; preds = %241, %91
%245 = phi double [ %243, %241 ], [ %225, %91 ]
%246 = load double, double* %5
%247 = load double, double* @DBL_MIN
%248 = load double, double* @DBL_EPSILON
%249 = fmul double %248, 5.000000e+01
%250 = fdiv double %247, %249
%251 = fcmp ogt double %246, %250
br i1 %251, label %252, label %256
252: ; preds = %244
%253 = fmul double %246, %249
%254 = fcmp ogt double %253, %245
%255 = select i1 %254, double %253, double %245
store double %255, double* %4
br label %256
256: ; preds = %252, %244
%257 = fmul double %15, %81
ret double %257
}